46

#ffffff(সাদা) বা #3764ef(নীল) হিসাবে হেক্স ট্রিপল্টগুলি প্রায়শই আরজিবি রঙ বোঝাতে ব্যবহৃত হয়। তারা গঠিত #ছয় হেক্সাডেসিমেল সংখ্যা (0-F), অথবা কখনও কখনও দ্বারা অনুসরণ তিনটি সংখ্যা যেখানে বাস্তব রঙ প্রতিটি অঙ্ক দ্বিগুন দ্বারা প্রাপ্ত হয়। উদাহরণস্বরূপ, #fffহয় #ffffffএবং #1a8হয় #11aa88।

দুঃখের বিষয়, সেই তিন ডিজিটের শর্টহ্যান্ডই ছিল এখন পর্যন্ত ইন্টারনেটকে যে গল্ফিয়েস্ট অফার করেছিল ।

এমন একটি প্রোগ্রাম বা ফাংশন লিখুন যা 1 থেকে 7 টি অক্ষরের স্ট্রিংয়ের মধ্যে নিয়ে থাকে:

প্রথম চরিত্রটি সর্বদা থাকবে #।
অন্যান্য অক্ষরের সবসময় হেক্সাডেসিমেল সংখ্যার হতে হবে: 0123456789abcdef।

ইনপুটটি হেক্স ট্রিপলিটের শর্টহ্যান্ড ফর্ম (বা 7 টি অক্ষর দেওয়া থাকলে সম্পূর্ণ ফর্ম)। আপনাকে একটি পূর্ণ হেক্স ট্রিপলেট আউটপুট তৈরি করতে হবে যা এই নিদগুলির উপর ভিত্তি করে ইনপুট শর্টহ্যান্ড প্রসারিত করে:

Input   -> Output
#       -> #000000    (black)
#U      -> #UUUUUU
#UV     -> #UVUVUV
#UVW    -> #UUVVWW    (usual 3-digit shorthand)
#UVWX   -> #UXVXWX
#UVWXY  -> #UVWXYY
#UVWXYZ -> #UVWXYZ    (not shorthand)

প্রত্যেকটি U, V, W, X, Y, এবং Zকোন হেক্সাডেসিমেল অঙ্ক হতে পারে। আউটপুট সর্বদা 7 টি অক্ষর।

উদাহরণ স্বরূপ:

Input -> Output
# -> #000000
#0 -> #000000
#4 -> #444444
#f -> #ffffff
#a1 -> #a1a1a1
#0f -> #0f0f0f
#99 -> #999999
#1a8 -> #11aa88
#223 -> #222233
#fff -> #ffffff
#1230 -> #102030
#d767 -> #d77767
#bbb5 -> #b5b5b5
#aabbc -> #aabbcc
#00000 -> #000000
#3764e -> #3764ee
#3764ef -> #3764ef
#123456 -> #123456
#f8f8f8 -> #f8f8f8

নোট

ইনপুটটি সর্বদা শুরু হবে #এবং তাই অবশ্যই আউটপুট।
আপনি ধরে নিতে পারেন সমস্ত ইনপুট অক্ষর হ'ল ছোট হাতের অক্ষর ( abcdef) বা বড় হাতের ( ABCDEF) আপনার পছন্দ অনুসারে।
আপনার পছন্দ অনুসারে আউটপুটে বর্ণ দুটি ক্ষেত্রে হতে পারে। আপনি এমনকি কেস মিশ্রিত করতে পারেন।
আলফা / স্বচ্ছতা এখানে মোকাবেলা করা হয় না (যদিও সেখানে RGBA রঙের হেক্স সংস্করণ রয়েছে)।

বাইটের মধ্যে সংক্ষিপ্ততম কোডটি জয়ী।

— ক্যালভিনের শখ
সূত্র

11

" দুঃখের বিষয়, সেই তিন ডিজিটের শর্টহ্যান্ড হ'ল এখন অবধি ইন্টারনেটের সবচেয়ে গল্ফিয়াস্ট ছিল। " - উহ, ঠিক তা নয় । এইচটিএমএল, 0 বাইট - এটি বাক্সের বাইরে কাজ করে

— বার্গি

11

এর বিপরীতটিও একটি দুর্দান্ত চ্যালেঞ্জ হবে

— বিটা ডেকায়

9

আমি #UVWXY -> #UVWXYYএন্ট্রি নিয়ে অসন্তুষ্ট কারণ এটি নীল চ্যানেলের জন্য একক মানের প্রতিনিধিত্বের অনুমতি দেয়, তবে লাল এবং সবুজ রঙের জন্য কোনও মিল নেই (উদাহরণস্বরূপ যদি আমি চাইতাম #889071আমি সংক্ষিপ্ত করতে পারি না, তবে অন্য #907188হিসাবে হতে পারি #90718) অন্যরা সব দুর্দান্ত কাজ।

— Draco18s

3

@ ড্রাকো 18 আমি এটি পছন্দ করি। যে এক এবং #UVWX -> #UXVXWX। এটি এমন একটি বেমানান এবং স্বেচ্ছাচারী আচরণ যে এটি বিশ্বাস করা কঠিন যে বর্তমানে ব্রাউজারের এমন কোনও দম্পতি নেই যা বাস্তবে এটি বাস্তবায়ন করে।

— এক্সডাইজু

1

@ এক্সডাইজু সিএসএসের স্পেসিফিকেশন রয়েছে #RGBAএবং #RRGGBBAAতাই # 1234 হিসাবে পড়তে হবেrgba(17, 34, 51, 0.25)

— tsh

13

জাভাস্ক্রিপ্ট, 86 82 77 বাইট

x=>([s,a=0,b=a,c,d,e,f]=x,f?x:e?x+e:[s,a,d||a,c?b:a,d||b,v=c||b,d||v].join``)

কেবল এটি খুঁজে বার করুন যে 4 টি বাইট সংরক্ষণ করে পুনরাবৃত্ত করুন ...

@ আরনাউল্ড থেকে ধারণা 4 বাইট সংরক্ষণ করুন, আরও 1 বাইট

— TSH
সূত্র

([s,a=0,b=a,c,d,e,f]=x)=>f?x:e?x+e:d?s+a+d+b+d+c+d:c?s+a+a+b+b+c+c:s+a+a+a+b+b+b80 বাইট

— লুক

@Luke আমি মাত্র পেলামReferenceError: x is not defined

— TSH

6

জেলি , 24 বাইট



x2
j0ị$
m0

0
Ḣ;LĿṁ6$$

একটি সম্পূর্ণ প্রোগ্রাম (খালি লাইন আসলে ফাঁকা লাইন)।

এটি অনলাইন চেষ্টা করুন! অথবা একটি পরীক্ষা স্যুট দেখুন *

কিভাবে?

     - Link 1 (0 bytes), returns its input (e.g. "U" -> "U")
     - Link 2 (0 bytes), returns its input (e.g. "UV" -> "UV")
x2   - Link 3, doubles up (e.g. "UVW" -> "UUVVWW")
j0ị$ - Link 4, joins with final element (e.g. "UVWX" -> "UXVXWXX")
m0   - Link 5, reflects its input (e.g. "UVWXY" -> "UVWXYYXWVU")
     - Link 6 (0 bytes), returns its input (e.g. "UVWXYZ" -> "UVWXYX")
0    - Link 7, returns zero (link 7 is also link 0 since there are 7 links)
Ḣ;LĿṁ6$$ - Main link: string
Ḣ        - head (get the '#')
       $ - last two links as a monad:
   Ŀ     -   call link at index:
  L      -     length
      $  -   last two links as a monad:
    ṁ6   -     mould like 6 (e.g. "UVWXYYXWVU" -> "UVWXYY"
         -                    or  "UV" -> "UVUVUV")
 ;       - concatenate (prepend the '#' again)
         - implicit print

* পরীক্ষা স্যুট প্রোগ্রাম কি ছিল ক্রম সোয়াপিং পরিবর্তন করা হয়েছিল Main linkএবং Link 7, যখন পাদচরণ ওঠে Main Link। তদুপরি #প্রোগ্রামটি হ'ল ম্যানুয়ালি প্রতিস্থাপন করতে হয়েছিল।

— জোনাথন অ্যালান
সূত্র

5

সিজেম, 45 44 42 40 36 35 বাইট

q(\0se|_,("6* 3* 2e* )f+ _W=+ "S/=~

ইনপুটটির দৈর্ঘ্যের উপর ভিত্তি করে বিভিন্ন কোড স্নিপেট চালায়।

— ফল ফল
সূত্র

1

কিছু ফর্ম্যাটিং <s> নয় </ strong> প্রয়োজন ....<s></s>

— স্টিভেফস্টেল

3

@ স্টিভেস্টেস্ট কিন্তু ৪৪ পেরিয়ে গেছে এখনও নিয়মিত 44 ...

— এসোলাং ফল 13

1

হুম! আমাকে বুঝতে পেরেছ! আমি যে ভুলে গেছি!

— স্টিভেফেসেল

4

পিএইচপি 7.1, 88 বাইট

#<?for(;$i<6;)echo@$argn[_22222232532233423355224462[5*$i+++strlen($argn|aa)*.85]-1]?:0;

পিএইচপি 5, 90 88 বাইট

#<?for(;$i<6;)echo$argn[_10311001122011333002244012345[6*$i+++strlen($argn|aa)-8]+1]?:0;

— user63956
সূত্র

আপনি এই ধারণাটি পান কীভাবে আমার কোনও ধারণা নেই তবে এটি কার্যকর হয় works কাজ _21422112233122444113355123456[6*$i+++strlen($argn|aa)-8]?

— জার্গ হালসারম্যান

1

আপনি কিভাবে দয়া করে ব্যাখ্যা করতে পারেন?

— ব্রায়ান এইচ।

এই এক সুন্দর! এটি অফসেটটি ইন- $argnইন সংরক্ষণ করে 21422112233122444113355123456এবং স্ট্রেনের উপর ভিত্তি করে সঠিকটি নির্বাচন করে। aaকমপক্ষে 2 টি অক্ষরে স্ট্রিং প্যাড করুন। ইনপুটের #সেখানে নেই $argn[1]তাই ?:0একটি আউটপুট 0। এটি 0স্ট্রিংয়ের জন্যও কাজ করে । আমি দেখেছি একটি সেরা উত্তর! দুঃখজনকভাবে এটি খুব বেশি মূল্য দেয় না (জার্গের উত্তরটি 95 তে নেমে গেছে)।

— ক্রিস্টোফ

1

হাহাহা, আমি পিএইচপি-র স্বয়ংক্রিয় স্ট্রিংগুলির মধ্যে এটির মধ্যে সেরা আপত্তি। +1

— ইটিএইচ প্রোডাকশনগুলি

1

@Christoph দ্য দ্বিতীয় সংস্করণ 7.1 এর অধীনে একটি পিএইচপি সংস্করণ প্রয়োজন 5.6 উপর একটি পিএইচপি সংস্করণ আমি এই যোগ করবেন তারা এই পরিষ্কার করা উচিত মনে করি

— Jörg Hülsermann

3

পিএইচপি, 95 93 89 87

<?=strtr(_1.intval([a6n,sot,c8c,lba,vf1,vf2][strlen($argn|aa)-2],33),_134256,$argn.=0);

মূলত @ জার্গএলসারম্যানের উত্তর কিন্তু প্রচুর গল্ফলে পড়েছে তাই আমি এটিকে পৃথক উত্তর হিসাবে পোস্ট করার সিদ্ধান্ত নিয়েছি। আমি এই উত্তরটি আমার এবং জারের একটি সম্মিলিত প্রচেষ্টা হিসাবে গণ্য করব।

-4 bytes thanks to @JörgHülsermann
-1 bytes thanks to @JörgHülsermann's base 33 numbers

— ক্রিস্টোফ
সূত্র

3

পাইথন 3, 166 162 160 152 বাইট

import re
lambda x,d='(.)$',b=r'\1':re.sub(*[('$','0'*6),(d,b*6),('(..)$',b*3),('(\w)',b*2),('.'+'(.)'*4,r'#\1\4\2\4\3\4'),(d,b*2),('','')][len(x)-1],x)

আমি প্রতিটি প্যাটার্নের জন্য রেজেক্স রিপ্লেসমেন্ট টিপলগুলির একটি তালিকা তৈরি করি এবং তারপরে len(x)-1সূচকগুলিতে টিপলটি বের করি , শেষ পর্যন্ত এটির যুক্তিতে স্প্ল্যাটিং করে ( *) re.sub:

lambda x, d='(.)$', b=r'\1':   # lambda expression, save often used strings
  re.sub(   # regex replacement of:
         *  # expand what follows into arguments, i.e. f(*(1,2)) -> f(1,2)
         [  # list of replacement patterns:
            # 1 character: replace the end with 6 zeroes
            ('$', '0'*6),
            # 2 chars: repeat the last character 6 times
            (d, b*6),
            # 3 chars: repeat the two non-#s 3 times.
            ('(..)$', b*3),
            # 4 chars: replace every non-# with twice itself
            ('(\w)', b*2),
            # 5 chars: has to be somewhat verbose..
            ('.'+'(.)'*4, r'#\1\4\2\4\3\4'), 
            # 6 chars: repeat the last character
            (d, b*2),
            # 7 chars: complete already, replace nothing with nothing
            ('', '')
         ][len(x)-1], # select the element from the list that has the right length
        x)  # replace in argument x

মুখস্থ করে 8 বাইট সংরক্ষণ করা হয়েছে r'\1'(ধন্যবাদ, গ্যাবার ফেকেট)

— L3viathan
সূত্র

1

r'\1'নামকরণকৃত প্যারামিটার হিসাবে কিছু বাইট সংরক্ষণ না করে ?

— গ্যাবার ফেকেট

1

আপনি লিখেছেন o=r'\1'তবে bআপনার কোডটি ব্যবহার করুন: ডি

— গ্যাবার ফেকটে

1

@ গ্যাবারফিকেট ওফস: ডি

— এল

3

জাভা 10, 228 227 224 182 বাইট

s->{var x="$1$1";int l=s.length();return l>6?s:l>5?s+s.charAt(5):l<2?"#000000":s.replaceAll(l>4?"(.)(.)(.)(.)$":l==3?"([^#]{2})":"([^#])",l>4?"$1$4$2$4$3$4":l>3?x:l>2?x+"$1":x+x+x);}

এটি অনলাইনে চেষ্টা করুন।

ব্যাখ্যা:

s->{                      // Method with String as both parameter and return-type
  var x="$1$1";         //  Create a temp String to repeat a match
  int l=s.length();     //  Length of the String
  return l>6?           //  If the length is 7:
    s                   //   Return the input-String as is
   :l>5?                //  Else-if the length is 6:
    s+s.charAt(5)       //   Return the input-String with the last character repeated
   :l<2?                //  Else-if the length is 1:
    "#000000";          //   Simply return the literal String #000000
   :                    //  Else (the length is 2, 3, 4, or 5):
    s.replaceAll(       //   Return the input-String after a regex replace:
                        //    With as match:
     l>4?               //     If the length is 5:
      "(.)(.)(.)(.)$",  //      Use a match for pattern #(A)(B)(C)(D)
     :l==3?             //     Else-if the length is 3:
      "([^#]{2})"       //      Use a match for pattern #(AB)
     :                  //     Else (the length is 2 or 4):
      "([^#])",         //      Use a match for pattern #(A) or #(A)(B)(C)
                        //    And as replacement: 
     l>4?               //     If the length is 5:
      "$1$4$2$4$3$4"    //      Change #ABCD to #ADBDCD
     :l>3?              //     Else-if the length is 4:
      x                 //      Change #ABC to #AABBCC
     :l>2?              //     Else-if the length is 3:
      x+"$1"            //      Change #AB to #ABABAB
     :                  //     Else (the length is 2):
      x+x+x);}          //      Change #A to #AAAAAA

— কেভিন ক্রুইজসেন
সূত্র

2

এপিএল (ডায়ালগ) , 43 বাইট

প্রয়োজন ⎕IO←0অনেক সিস্টেমে পূর্বনির্ধারিত।

'#',{6⍴(≢⍵)⊃'0'⍵ ⍵(2/⍵)(∊⍵,¨⊃⌽⍵)(⍵,⌽⍵)⍵}1↓⍞

এটি অনলাইন চেষ্টা করুন!

1↓⍞ প্রথম অক্ষর (হ্যাশ) বাদ দিন

{ নিম্নলিখিত বেনামী ফাংশন প্রয়োগ করুন

(≢⍵)⊃ নিম্নলিখিত সাতটি মানগুলির মধ্যে
'0' একটি বাছাই করতে যুক্তির দৈর্ঘ্যটি ব্যবহার করুন: একটি শূন্য
⍵ আর্গুমেন্ট
⍵ আর্গুমেন্টের প্রতিটি ( ) এর
2/⍵ দুটি ( 2) /আর্গুমেন্ট ( ⍵)
∊⍵,¨⊃⌽⍵ সমতল ( ∊) আর্গুমেন্ট ( ⍵) প্রতিটি ( ,¨) এর প্রথম ( ⊃) দ্বারা অনুসরণ করে বিপরীত ( ⌽) যুক্তি ( ⍵)
⍵,⌽⍵ আর্গুমেন্ট ( ⍵) চাপ দেওয়া ( ,) বিপরীত ( ⌽) যুক্তি ( ⍵)
⍵ যুক্তি

6⍴ যেগুলি থেকে ছয়টির দৈর্ঘ্য অর্জন না হওয়া পর্যন্ত পুনরাবৃত্তি করুন

} বেনামে ফাংশন শেষ

'#', এটির জন্য একটি হ্যাশ প্রিপেন্ড করুন

— আদম
সূত্র

2

পাইথন 2, 167 165 বাইট

-2 বাইট ধন্যবাদ ট্রেলজিরকে

z=zip
lambda s:'#'+''.join([reduce(lambda x,y:x+y,c)for c in['0'*6,s[1:2]*6,z(s[1:2],s[2:3])*3,z(*z(s[1:2],s[2:3],s[3:4]))*2,z(s[1:4],s[-1]*3),s+s[-1],s][len(s)-1]])

এটি স্ট্রিংয়ের একটি তালিকা তৈরি করে এবং স্ট্রিংয়ের দৈর্ঘ্যের উপর নির্ভর করে চয়ন করে।

— গ্যাবার ফেকেট
সূত্র

1

আপনি ব্যবহার করে 2 বাইট সংরক্ষণ করতে পারেন z=zip।

— ট্রেলজভীর

2

সেড, 119 (118 বাইট + `-E`)

s/#//
s/^$/0/
s/^.$/&&/
s/^..$/&&&/
s/^(.)(.)(.)$/\1\1\2\2\3\3/
s/^(.)(.)(.)(.)$/\1\4\2\4\3\4/
s/^....(.)$/&\1/
s/^/#/

সোজা পাঠ্য প্রতিস্থাপন।

— কেভিন
সূত্র

2

পিএইচপি, 87 বাইট

বেস 35 নম্বর ব্যবহার করুন

<?=strtr(_2.intval([i4w,qdi,j1y,apg,ruu,ruv][strlen($argn|aa)-2],35),_234156,$argn.=0);

এটি অনলাইন চেষ্টা করুন!

অথবা বেস 33 নম্বর ব্যবহার করুন

<?=strtr(_1.intval([a6n,sot,c8c,lba,vf1,vf2][strlen($argn|aa)-2],33),_134256,$argn.=0);

এটি অনলাইন চেষ্টা করুন!

পিএইচপি, 89 বাইট

<?=strtr(_1.[11111,21212,12233,42434,23455,23456][strlen($argn|aa)-2],_123456,$argn."0");

এটি অনলাইন চেষ্টা করুন!

intval(["8kn",gd8,"9ft",wqq,i3j,i3k][strlen($argn|aa)-2],36) 36 টি বেস ব্যবহার করে 3 বাইটস

পিএইচপি, 102 বাইট

<?=strtr("01".substr("11111111112121212233424342345523456",5*strlen($argn)-5,5),str_split($argn."0"));

এটি অনলাইন চেষ্টা করুন!

পিএইচপি, 180 বাইট

<?=[str_pad("#",7,($l=strlen($p=substr($argn,1)))?$p:0),"#$p[0]$p[0]$p[1]$p[1]$p[2]$p[2]","#$p[0]$p[3]$p[1]$p[3]$p[2]$p[3]","#$p[0]$p[1]$p[2]$p[3]$p[4]$p[4]",$argn][($l>2)*($l-2)];

এটি অনলাইন চেষ্টা করুন!

— জার্গ হালসারম্যান
সূত্র

1

আমি এই সংস্করণটি 95 বাইটে গল্ফ করেছিলাম তবে আমি ভেবেছিলাম এটি অন্যরকম তাই আমি এটি একটি নিজস্ব উত্তর হিসাবে পোস্ট করেছি । আশা করি আপনি এটি পছন্দ করেছেন :)

— ক্রিস্টোফ

2

@ ক্রিসটফ এই মুহুর্তে আমি এখানে আমার সংস্করণটি নিয়ে এটিকে অনলাইনে চেষ্টা করুন!

— জার্গ হালসারম্যান

2

বেস 33 একটি দুর্দান্ত ধারণা! আমি এখানে কিছুক্ষন বসে আছি কিন্তু এটি নিয়ে জটলা নিয়ে আসিনি।

— ক্রিস্টোফ

1

@ ক্রিসটফ এটি আমার প্রথম সংস্করণে আপনার গল্ফিংয়ের সাথে খুব মিল। আপনার পদ্ধতির অধীনে আমার পদ্ধতির গল্ফ করা সহজ ছিল না

— জার্গ হালসারম্যান

1

@ ক্রিসটফ ধন্যবাদ এবং বেস 35 নম্বর সিস্টেমটি আমাদের

— টিম ওয়ার্কে

2

রেটিনা , 90 বাইট

#(..)$
#$1$1$1
#(.)(.)(.)$
#$1$1$2$2$3
#(.)(.)(.(.))$
#$1$4$2$4$3
#$
#0
+`#.{0,4}(.)$
$&$1

এটি অনলাইন চেষ্টা করুন! পরীক্ষার কেস অন্তর্ভুক্ত।

ব্যাখ্যা: প্রথম অনুবাদটি দুটি অঙ্ক পরিচালনা করে, দ্বিতীয়টি তিনটি, তৃতীয়টি চারটি এবং চতুর্থটি শূন্য। যাইহোক, দ্বিতীয় এবং চতুর্থ অনুবাদ দুটিও (শেষ) অঙ্কটির পুনরাবৃত্তি করে না, যেহেতু বাকী সমস্ত কেস কভার করার জন্য এটি শেষের দিকে করা হয়।

— নিল
সূত্র

2

হাস্কেল , 130 127 122 118 109 95 বাইট ( ব্যবহারকারী 1472751 দ্বারা )

y a|l<-[last a]=[y"0",y$a++a,a++a++a,do c<-a;[c,c],(:l)=<<init a,a++l,a]!!length a
f(h:r)=h:y r

এটি অনলাইন চেষ্টা করুন!

— bartavelle
সূত্র

পিছনে একটি অতিরিক্ত অতিরিক্ত জায়গা আছে g।

— লাইকনি

1

এর (x:r)!(y:t)=x:y:r!t;e!_=eচেয়ে ছোটও a!b=id=<<[[x,y]|(x,y)<-zip a b]।

— লাইকনি

প্রথম চর যেমন সর্বদা #আপনি করতে পারেনg(a:t)|l<-last t=a:[ ...

— লাইকনি

@ লাইকনি সত্যিই, এগুলি দুর্দান্ত উন্নতি!

— বার্তাওলে

আমি একটি 95 বাইট সমাধান পেয়েছি যা আপনার অনুরূপ দৃষ্টিভঙ্গি ব্যবহার করে (মহান মন একসাথে ভাবেন, হাহ?) আপনি এটি ব্যবহার করতে পারেন বা আমি একটি পৃথক উত্তর পোস্ট করতে পারি।

— ব্যবহারকারী 1472751

2

পাওয়ারশেল, 113 111 বাইট

param($s)-join($s+='0'*($s-eq'#'))[0,1+((,1*5),(2,1*2+2),(1,2,2,3,3),(4,2,4,3,4),(2..5+5),(2..6))[$s.Length-2]]

পরীক্ষার স্ক্রিপ্ট ব্যাখ্যা করা:

$f = {

param($s)           # parameter string
$s+='0'*($s-eq'#')  # append '0' if $s equal to '#'
$i=(                # get indexes from array
    (,1*5),         # $i = 1,1,1,1,1 if $s.length-2 = 0
    (2,1*2+2),      # $i = 2,1,2,1,2 if $s.length-2 = 1
    (1,2,2,3,3),    # $i = 1,2,2,3,3 if $s.length-2 = 2
    (4,2,4,3,4),    # $i = 4,2,4,3,4 if $s.length-2 = 3
    (2..5+5),       # $i = 2,3,4,5,5 if $s.length-2 = 4
    (2..6)          # $i = 2,3,4,5,6 if $s.length-2 = 5
)[$s.Length-2]
-join$s[0,1+$i]     # join chars from $s by indexes 0, 1 and $i


}

@(
    , ("#", "#000000")
    , ("#0", "#000000")
    , ("#4", "#444444")
    , ("#f", "#ffffff")
    , ("#a1", "#a1a1a1")
    , ("#0f", "#0f0f0f")
    , ("#99", "#999999")
    , ("#1a8", "#11aa88")
    , ("#223", "#222233")
    , ("#fff", "#ffffff")
    , ("#1230", "#102030")
    , ("#d767", "#d77767")
    , ("#bbb5", "#b5b5b5")
    , ("#aabbc", "#aabbcc")
    , ("#00000", "#000000")
    , ("#3764e", "#3764ee")
    , ("#3764ef", "#3764ef")
    , ("#123456", "#123456")
    , ("#f8f8f8", "#f8f8f8")
) |% {
    $s, $e = $_
    $r = &$f $s
    "$($e-eq$r): $r"
}

আউটপুট:

True: #000000
True: #000000
True: #444444
True: #ffffff
True: #a1a1a1
True: #0f0f0f
True: #999999
True: #11aa88
True: #222233
True: #ffffff
True: #102030
True: #d77767
True: #b5b5b5
True: #aabbcc
True: #000000
True: #3764ee
True: #3764ef
True: #123456
True: #f8f8f8

— mazzy
সূত্র

1

জাভাস্ক্রিপ্ট (ES6), 96 বাইট

s=>'#'+(c=[u,v,w,x,y,z]=s.slice(1)||'0',z?c:y?c+y:(x?u+x+v+x+w+x:w?u+u+v+v+w+w:c.repeat(v?3:6)))

কোড স্নিপেট দেখান

f=
s=>'#'+(c=[u,v,w,x,y,z]=s.slice(1)||'0',z?c:y?c+y:(x?u+x+v+x+w+x:w?u+u+v+v+w+w:c.repeat(v?3:6)))

console.log(
  f('#'),
  f('#U'),
  f('#UV'),
  f('#UVW'),
  f('#UVWX'),
  f('#UVWXY'),
  f('#UVWXYZ')
)

স্নিপেট প্রসারিত করুন

— darrylyeo
সূত্র

1

পার্ল, 61 বাইট

say+(/./g,0)[0,1,(unpack+S7,"g+g+ÜRÉ/Â¥[ [")[y/#//c]=~/./g]

সাথে চালাও perl -nE। ধরে নেওয়া হয় যে ইনপুটটি ঠিক বর্ণিত হিসাবে রয়েছে (ইনপুটটির পিছনে নতুন লাইনে থাকলে ভুল ফলাফল দেয়)।

স্ট্রিং "g + g + ÜRÉ / Â" [["7 16-বিট সংখ্যাগুলিকে 11111,11111,21212,12233,42434,23455,2345614 লাতিন 1 অক্ষর হিসাবে এনকোড করে । স্বচ্ছতার জন্য এখানে একটি হেক্সডাম্প রয়েছে:

0000001d: 672b 672b dc52 c92f c2a5 9f5b a05b       g+g+.R./...[.[

— Grimmy
সূত্র

আমি কলের মাধ্যমে ল্যাটিন -1 স্ট্রিং প্রতিস্থাপিত প্যাক করার জন্য (), এবং করেছেন: perl -nE 'say+(/./g,0)[0,1,(unpack+S7,pack "H*","672b672bdc52c92fc2a59f5ba05b")[y/#//c]=~/./g]'। তবে আমি যখন "# এ" টাইপ করি তখন আমি "# a0a0a0" পাই যা আমার মনে হয় ভুল। এটি "#aaaaa" হওয়া উচিত। (সম্ভবত আমি প্যাকটিতে ভুল করেছি () কল))

— জেএল

এই সময় আমি আনপ্যাক () & প্যাক () আক্ষরিক হাফপ্যান্ট কল প্রতিস্থাপিত, এবং করেছেন: perl -nE 'say+(/./g,0)[0,1,(11111,11111,21212,12233,42434,23455,23456)[y/#//c]=~/./g]'। এটি এখনও ভুল বলে মনে হচ্ছে, যেহেতু "# ক" এখনও "# a0a0a0" ("#aaaaa" এর পরিবর্তে) এর ভুল উত্তর দেয়।

— জেএল

আহ! আমি এটি খুঁজে বের! আমি ব্যবহার করা প্রয়োজন -lসুইচ সঙ্গে (যে এর "চিঠি L" লিখে হিসেবে "ইএলএল") -nEএই মত, সুইচ: perl -lnE 'say+(/./g,0)[0,1,(11111,11111,21212,12233,42434,23455,23456)[y/#//c]=~/./g]'। এখন এটি সঠিকভাবে কাজ করে।

— জেএল

"(ইনপুটটির পিছনে নতুন লাইনের উপস্থিতি থাকলে ভুল ফলাফল দেয়)" বলে যে সতর্কতাটি "রান উইথ perl -nE" দিয়ে "রান উইথ perl -lnE" পরিবর্তন করে মুছে ফেলা যায় । ( -lআপনার জন্য নতুন লাইনের পিছনে সুইচের অংশটি মুক্তি পেয়েছে))

— জেএল

-Fকমান্ড লাইনে ব্যবহার করা আপনাকে say+(@F,0)[0,1,(unpack+S7,"g+g+ÜRÉ/Â¥[ [")[$#F]=~/./g]কোডে 5 বাইট সংরক্ষণে এটি পরিবর্তন করতে দেয় ।

— এক্সকালি

1

উইন্ডোজ ব্যাচ, 389 372 362 349 231 বাইট

আমি নিল কোডটি সম্পূর্ণ অনুলিপি করেছি ...

@call:c %s:~1,1% %s:~2,1% %s:~3,1% %s:~4,1% %s:~5,1% %s:~6,1%
@exit/b
:c
@for %%r in (#%1%2%3%4%5%6.%6 #%1%2%3%4%5%5.%5 #%1%4%2%4%3%4.%4 %s%%1%2%3.%3 
%s%%1%2%1%2.%2 %s%%1%1%1%1%1.%1 #000000.0)do @if not %%~xr.==. @echo %%~nr&exit/b

— stevefestl
সূত্র

1

% s এর সাথে% 1 প্রতিস্থাপন করা আপনাকে কয়েকটি বাইট সংরক্ষণ করতে হবে।

— 17'6

2

%s:~3,1%%s:~4,1%সঙ্গে প্রতিস্থাপন করা যেতে পারে %s:~3,2%। এছাড়াও আমি নিশ্চিত নই যে এটি কোনও ইনপুটটির জন্য কাজ করে #।

— নীল

2

যাইহোক, আমি একটি ভিন্ন অ্যালগরিদম চেষ্টা করেছি এবং এটি 243 বাইটে বেরিয়েছে।

— নীল

1

আমি কি জানতে পারি অ্যালগরিদম কী?

— স্টিভেস্টেল

1

(দুঃখিত, @ নীলের অভাবের কারণে আমি আপনার মন্তব্যটি দেখতে পাইনি)) এখানে কিছু বয়লারপ্লেট রয়েছে তবে দুটি লাইনের আগ্রহ রয়েছে call:c %s:~1,1% %s:~2,1% %s:~3,1% %s:~4,1% %s:~5,1% %s:~6,1%এবং

for %%r in (#%1%2%3%4%5%6.%6 #%1%2%3%4%5%5.%5 #%1%4%2%4%3%4.%4 %s%%1%2%3.%3 %s%%1%2%1%2.%2 %s%%1%1%1%1%1.%1 #000000.0)do if not %%~xr.==. echo %%~nr&exit/b

।

— নীল

1

পাইথ, 35 বাইট

+\#@<R6[J|tQ\0K*6JKKs*R2JjeJJ+JeJ)l

এটি এখানে অনলাইনে চেষ্টা করুন , বা সমস্ত পরীক্ষার কেস এখানে যাচাই করুন ।

+\#@<R6[J|tQ\0K*6JKKs*R2JjeJJ+JeJ)lQ   Implicit: Q=eval(input())
                                       Trailing Q inferred
          tQ                           Remove first char of input
         |  \0                         The above, or "0" if empty
        J                             *Store in J (also yields stored value)
              K*6J                    *Repeat J 6 times, store in K
                  KK                  *2 more copies of the above
                    s*R2J             *Duplicate each char of J in place
                         jeJJ         *Join chars of J on last char of J
                             +JeJ     *Append last char of J to J
       [                         )     Wrap the 5 starred results in an array
    <R6                                Trim each to length 6
   @                              lQ   Choose result at index of length of input
                                       (Modular indexing, so length 7 selects 0th element)
+\#                                    Prepend #, implicit print

— সোক
সূত্র

1

পাইথন 2 , 99 বাইট

def a(s):s=s[1:]or'0';l=len(s);print('#'+(l/4*s[-1]).join(i+i*(l==3)for i in(l<5)*6*s)+s+s[-1])[:7]

এটি অনলাইন চেষ্টা করুন!

— Jitse
সূত্র

সুন্দর প্রথম পোস্ট। একদিকে যেমন, অনলাইনে চেষ্টা করে দেখুন! anচ্ছিক কিন্তু প্রস্তাবিত সাইট যা আপনার উত্তরে অন্তর্ভুক্ত করার জন্য কোড চালায়। এটি সিজি ও সিসি পোস্ট তৈরি করতে পারে এবং বুট করার জন্য একটি সঠিক বাইট গণনা দেয়।

— ভেসকাঃ

খুব সুন্দর, ধন্যবাদ!

— জিতসে

0

পাইথন 2 - 179 বাইট

n=raw_input()                                #prompts for string
t=len(n)                                     #the length of the string is stored to 't'
if t==1:n+="0"*6                             #if t is only one char long, it needs to be black, so n is assigned 6 zeroes
if t==2:n+=n[1]*5                            #if t is two chars long, it adds the last character times 5 at the end
if t==3:n+=n[1:3]*2                          #if t is 3 chars, it multiplies the last two digits times 3
if t==4:n="#"+n[1]*2+n[2]*2+n[3]*2           #if t is 4 chars, it multiplies each char by two
if t==5:n=n[:2]+n[4]+n[2]+n[4]+n[3]+n[4]     #if t is 5 chars, it makes it work
if t==6:n+=n[t-1]                            #if t is 6 chars, it adds the last character to the end
print n                                      #it prints out n

কেউ আমাকে কিছু বাইট সংরক্ষণ করতে সাহায্য করতে পারেন? সমস্ত বিবৃতি যদি মনে হয় যে এগুলি সংক্ষিপ্ত কিছুতে সংক্ষিপ্ত করা যেতে পারে, তবে আমি জানি না।

— FantaC
সূত্র

1

প্রতিটি স্নিপেটকে একটি তালিকায় এবং সূচকে রেখে দেওয়ার চেষ্টা করুন। এছাড়াও, পাইথন 3 স্যুইচ হবে সম্ভবত বাইট সংরক্ষণ এবং list[len(list)-x]হিসাবে একই list[-x]।

— ক্যালকুলেটরলাইন

আপনি কিছু বাইট আলিঙ্গন করতে চান তাহলে, রূপান্তর বিবেচনা if t==1:করতে if t<2:(এবং if t==2:করতে if t<3:, ইত্যাদি)। এটি নিশ্চিতভাবে কম পাঠযোগ্য, তবে আরও কোড-গল্ফ-সক্ষম!

— জেএল

0

টিএক্সআর লিস্প: 171 বাইট

ইন্ডেন্টযুক্ত:

(do let ((s (cdr @1)))
  (caseql (length s)
    (0 "#000000") 
    (1 `#@s@s@s@s@s@s`)
    (2 `#@s@s@s`)
    (3 `#@[mappend list s s]`)
    (4 `#@[s 0]@[s 3]@[s 1]@[s 3]@[s 2]@[s 3]`)
    (5 `#@s@[s 4]`)
    (6 `#@s`))))

এটি একটি বেনামে ফাংশন: doম্যাক্রো একটি (lambda ...)ফর্ম উত্পন্ন করে ।

এটি আইডোমেটিক কোডিং স্টাইল, উত্পাদনের জন্য উপযুক্ত; একমাত্র গল্ফিং হ'ল হোয়াইট স্পেসে স্কোয়াশ করছে:

(do let((s(cdr @1)))(caseql(length s)(0"#000000")(1`#@s@s@s@s@s@s`)(2`#@s@s@s`)(3`#@[mappend list s s]`)(4`#@[s 0]@[s 3]@[s 1]@[s 3]@[s 2]@[s 3]`)(5`#@s@[s 4]`)(6`#@s`))))

— Kaz
সূত্র

0

ব্রেনল্ফ , 95 বাইট

l1-.1e$_!&@4>[!@]|.2e$_!&@!@2!@2|.3e$_<@V2[R<!@!@v]|.4e$_<@VRM&,2>[@v!@R]|.5e$_<@!&@@|.6e$_&@|;

এটি অনলাইন চেষ্টা করুন!

এটি #ইনপুট-এর পরে অক্ষরের পরিমাণ সম্পর্কে কার্যকরভাবে ব্রাইংলফের স্যুইচ-কেসের সমতুল্য ।

ব্যাখ্যা

স্টাফ যা সর্বদা চলমান:

l1-.1  Implicit input to stack
l      Push length of stack
 1-    Decrement last item in stack
   .   Duplicate last item in stack
    1  Push 1

যদি #X:

e$_!&@4>[!@]|
e              If last 2 items (input length - 1 and 1) are equal..
 $_            ..Pop last item silently
   !&@         ..Print entire stack as chars without popping
      4>       ..Push 4 and move it to start of stack
        [..]   ..While loop, decrements first item in stack when it reaches ]
               ..If first item in stack is 0 when reaching ], exit loop
               ..This loop will run 5 times
         !@    ....Print last char without popping
            |  endif

যদি #XX

এইটি কিছুটা গল্ফযোগ্য হতে পারে, আমি বাড়ি ফিরলে আমি এটির দিকে নজর দিতে পারি

.2e$_!&@!@2!@2|
.2               Duplicate last item and push 2
  e              If last 2 items (input length - 1 and 2) are equal..
   $_            ..Pop last item silently
     !&@         ..Print entire stack as chars without popping
        !@2      ..Print last 2 items as chars without popping
           !@2   ..Print last 2 items as chars without popping
              |  Endif

যদি #XXX

.3e$_<@V2[R<!@!@v]|
.3                   Duplicate last item and push 3
  e                  If last 2 items (input length - 1 and 3) are equal..
   $_                ..Pop last item silently
     <@              ..Move first item in stack to the end, then pop and print
       V2            ..Create new stack and push 2 to it
         [.......]   ..While loop, see above for explanation
          R<         ....Switch to stack1 and move first item to end of stack
            !@!@     ....Print last item on stack twice without popping
                v    ....Move to stack2 for loop counting
                  |  Endif

আপনি ধারণা পেতে

— Skidsdev
সূত্র

0

রুবি , 127 বাইট

c=~/#(.)?(.)?(.)?(.)?(.)?(.)?/
$6?c:'#'+($5?$1+$2+$3+$4+$5*2:$4?$1+$4+$2+$4+$3+$4:$3?$1*2+$2*2+$3*2:$2?($1+$2)*3:$1?$1*6:"0"*6)

এটি অনলাইন চেষ্টা করুন!

— জেএল
সূত্র

0

রুবি , 118 বাইট

def f c
c.sub!'#',''
s=c.size
t=c[3]
s>5?'#'+c:f(s<1?'0':s<2?c*6:s<3?c*3:s<4?c*2:s<5?c[0]+t+c[1]+t+c[2]+t:c+c[-1])
end

এটি অনলাইন চেষ্টা করুন!

— জেএল
সূত্র

0

05 এ বি 1 ই , 24 বাইট

ćU©0®Ð€D®S¤ý®¤«)JIgè6∍Xì

এটি অনলাইনে চেষ্টা করুন বা সমস্ত পরীক্ষার কেস যাচাই করুন ।

ব্যাখ্যা:

ć           # Extract the head of the (implicit) input-string;
            # pop and push remainder and head
 U          # Pop and store the head in variable `X`
  ©         # Store the remainder in variable `®` (without popping)
  0         # Push a 0
  ®Ð        # Push `®` three times
    €D      # Duplicate each character in the last copy (which becomes a character-list)
  ®S        # Push variable `®` again, converted to a character-list
    ¤       # Get its last character (without popping the list itself)
     ý      # Join the list by this character
  ®         # Push variable `®` once again
   ¤        # Get its last character (without popping the string itself)
    «       # Append it to the string
  )         # Wrap all values into a list
   J        # Join the inner list from `€D` together to a list,
            # or in case of input `#`, join everything together to string "0"
            #  i.e. "#" → (["","0","","","",""] → ) "0"
            #  i.e. "#4" → ["4","0","4","4","44","4","44"]
            #  i.e. "#a1" → ["a1","0","a1","a1","aa11","a11","a11"]
            #  i.e. "#1a8" → ["1a8","0","1a8","1a8","11aa88","18a88","1a88"]
            #  i.e. "#abcd" → ["abcd","0","abcd","abcd","aabbccdd","adbdcdd","abcdd"]
            #  i.e. "#3764e" → ["3764e","0","3764e","3764e","33776644ee","3e7e6e4ee","3764ee"]
            #  i.e. #123456 → ["123456","0","123456","123456","112233445566","16263646566","1234566"]
    Ig      # Push the length of the input
      è     # Index (0-based) this into the list (with automatic wraparound for length=7)
       6∍   # Extend/shorten the string to length 6
         Xì # And prepend variable `X` (the "#")
            # (after which the result is output implicitly)

— কেভিন ক্রুইজসেন
সূত্র

আপনার ইন্টারনেটের জন্য আরও ভাল হেক্স রঙের কোড

নোট

জাভাস্ক্রিপ্ট, 86 82 77 বাইট

জেলি , 24 বাইট

কিভাবে?

সিজেম, 45 44 42 40 36 35 বাইট

পিএইচপি 7.1, 88 বাইট

পিএইচপি 5, 90 88 বাইট

পিএইচপি, 95 93 89 87

পাইথন 3, 166 162 160 152 বাইট

জাভা 10, 228 227 224 182 বাইট

এপিএল (ডায়ালগ) , 43 বাইট

পাইথন 2, 167 165 বাইট

সেড, 119 (118 বাইট + -E)

পিএইচপি, 87 বাইট

পিএইচপি, 89 বাইট

পিএইচপি, 102 বাইট

পিএইচপি, 180 বাইট

রেটিনা , 90 বাইট

হাস্কেল , 130 127 122 118 109 95 বাইট ( ব্যবহারকারী 1472751 দ্বারা )

পাওয়ারশেল, 113 111 বাইট

জাভাস্ক্রিপ্ট (ES6), 96 বাইট

পার্ল, 61 বাইট

উইন্ডোজ ব্যাচ, 389 372 362 349 231 বাইট

পাইথ, 35 বাইট

পাইথন 2 , 99 বাইট

পাইথন 2 - 179 বাইট

ব্রেনল্ফ , 95 বাইট

ব্যাখ্যা

রুবি , 127 বাইট

রুবি , 118 বাইট

05 এ বি 1 ই , 24 বাইট

সেড, 119 (118 বাইট + `-E`)