インターネットに適した16進カラーコード

46

#ffffff（白）や#3764ef（青みがかった）などの16進数のトリプレットは、RGBカラーを表すためによく使用されます。これらは、#6桁の16進数（0〜f）、または実際の色が各桁を2倍にすることで得られる3桁で構成される場合があります。たとえば、#fffis #ffffffおよび#1a8is #11aa88です。

残念なことに、その3桁の速記は、今までインターネットが提供しなければならなかったゴルフの中で一番でした。

1〜7文字の文字列を受け取るプログラムまたは関数を作成します。

  • 最初の文字は常にです#。
  • 他の文字は常に16進数です：0123456789abcdef。

入力は、16進トリプレットの短縮形（または7文字が指定されている場合は完全形）です。次のパターンに基づいて入力の短縮形を展開する完全な16進数のトリプレットを出力する必要があります。

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任意の16進数字であってもよいです。出力は常に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カラーの16進バージョンがあります）。

バイト単位の最短コードが優先されます。

code-golf  string  hexadecimal  color 
— カルビンの趣味
ソース
11
「悲しいことに、その3桁の短縮形は、インターネットgolfiestは今まで、提供していただった。」 -ええと、ない正確に。HTML、0バイト-そのまま使用可能
— -Bergi
11
これの逆もクールな挑戦になるだろう
— ベータ崩壊
9
#UVWXY -> #UVWXYYBlueチャネルの単一値表現を許可するため、このエントリには満足していませんが、RedとGreenに同様の表現はありません（たとえば、#889071省略したくない場合は#907188... asにすることができます#90718）すべてうまくいきます。
— Draco18s
3
@ Draco18s大好きです。それと#UVWX -> #UXVXWX。これは非常に一貫性のないarbitrary意的な動作であるため、実際に実装しているブラウザが2つも存在しないと考えるのは困難です。
— -xDaizu
1
@xDaizu CSS仕様には#RGBAand #RRGGBBAAがあるため、＃1234は次のように読む必要がありますrgba(17, 34, 51, 0.25)
— -tsh

回答:

13

JavaScript、 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バイトの再帰的な保存を削除するだけです...

@Arnauldからのアイデアは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バイト
— ルーク
私がちょうど得た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。さらに、#プログラムは現状のままであるため、手動で交換する必要がありました。

— ジョナサン・アラン
ソース
4

PHP 7.1、88バイト

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

PHP 5、90の 88バイト

#<?for(;$i<6;)echo$argn[_10311001122011333002244012345[6*$i+++strlen($argn|aa)-8]+1]?:0;
— user63956
ソース
私はあなたがこのアイデアをどのように得るのか分かりませんが、うまくいきます。仕事_21422112233122444113355123456[6*$i+++strlen($argn|aa)-8]？
— ヨルクヒュルサーマン
1
これがどのように機能するか説明していただけますか？
— ブライアンH.
これはいいね！これは、オフセット保存$argn中21422112233122444113355123456とはstrlenに基づいて正しいものを選択します。aa文字列を少なくとも2文字にパディングします。入力#では$argn[1]そう?:0出力されません0。これ0は文字列のonでも機能します。私が見た中で最高の答えの一つ！悲しいことに、あまりお金を払っていない（ヨルグの答えは95まで落ち​​込んだ）。
— クリストフ
1
ハハ、これは私がしばらく見てきたPHPの自動文字列の最大の悪用です。+1
— ETHproductions
1
@Christophザ・セカンドバージョンが7.1の下でPHPのバージョンを必要とし、5.6以上のPHPバージョンが、私はこの明確にする必要があり、これを追加すると思う
— イェルクHülsermann
3

PHP、95 93 89 87

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

基本的に@JörgHülsermannの回答ですが、かなり落ち着いていたので、別の回答として投稿することにしました。この答えは、私とヨルクの共同の努力と考えています。

-4 bytes thanks to @JörgHülsermann
-1 bytes thanks to @JörgHülsermann's base 33 numbers
— クリストフ
ソース
3

Pythonの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、index でタプルを抽出し、最後に*それを引数にスプラッティング（）します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'（ありがとう、GáborFekete）

— L3viathan
ソース
1
r'\1'名前付きパラメーターとして使用すると、いくつかのバイトが節約されませんか？
— ガボールフェケテ
1
あなたは書きましたo=r'\1'が、使用bしてコードで：D
— ガーボルFekete
1
@GáborFeketeおっと：D
— L3viathan
3

Java 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

APL（Dyalog）、43バイト

⎕IO←0多くのシステムでデフォルトである必要があります。

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

オンラインでお試しください！

1↓⍞ 最初の文字（ハッシュ）をドロップします

{ 次の匿名関数を適用します

 (≢⍵)⊃ 次の7つの値のいずれかを選択する引数の長さを使用する：
  '0' ゼロ
  ⍵ 引数
  ⍵ の引数
  2/⍵ 2つ（2それぞれの）（/引数）（ ）⍵（
  ∊⍵,¨⊃⌽⍵ 平坦化∊）の引数は（⍵それぞれ（）に続くを,¨最初による）（ ⊃）の逆に（⌽）の引数（⍵）
  ⍵,⌽⍵ の引数（⍵）（先頭に追加,逆転（へ）⌽）の引数（⍵）
  ⍵ の引数

 6⍴ 6の長さが達成されるまで、それから要素を繰り返します

} 無名関数の終わり

'#', それにハッシュを追加します

— アダム
ソース
2

Python 2、167 165バイト

Trelzevirのおかげで-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

Sed、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

PHP、87バイト

Base 35番号を使用 

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

オンラインでお試しください！

またはBase 33番号を使用 

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

オンラインでお試しください！

PHP、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 Baseを使用した3バイト

PHP、102バイト

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

オンラインでお試しください！

PHP、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
@Christoph私は私のバージョンでここにいる瞬間にオンラインで試してみてください！
— ヨルクヒュルサーマン
2
ベース33は素晴らしいアイデアです！私はしばらくここに座っていたが、気に入らなかった。
— クリストフ
1
@Christophそれは私の最初のバージョンのあなたのゴルフと非常に似ています。あなたのアプローチの下で私のアプローチをゴルフするのは簡単ではありませんでした
— ヨルグヒュルザーマン
1
@Christoph Thanks and base 35番号システムは、チームワークでの私のアプローチです
— ヨルグヒュルサーマン
2

網膜、90バイト

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

オンラインでお試しください！テストケースが含まれています。

説明：最初の変換では、2桁、2桁目は3桁、3桁目は4桁、4桁目はゼロの2桁を処理します。ただし、2番目と4番目のどちらの変換も（最後の）数字を繰り返しません。これは、残りのすべてのケースをカバーするために最後に行われるためです。

— ニール
ソース
2

Haskell、130 127 122 118 109 95バイト（by user1472751）

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

オンラインでお試しください！

— バルタベル
ソース
後ろに余分なスペースがあり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:[ ...
— ライコニ
@Laikoniは確かに、これらは大きな改善です！
— -bartavelle
あなたと同様のアプローチを使用する95バイトのソリューションを見つけました（偉大な人は同じように考えていますか？）。あなたはそれを使用するか、別の回答を投稿することができます。
— user1472751
2

Powershell、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
— かっこいい
ソース
1

JavaScript（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)))

コードスニペットを表示

— ダリーリョ
ソース
1

Perl、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,23456を14のlatin1文字としてエンコードします。わかりやすくするために、16進ダンプを示します。

0000001d: 672b 672b dc52 c92f c2a5 9f5b a05b       g+g+.R./...[.[
— グリムミー
ソース
Latin-1文字列をpack（）の呼び出しに置き換えて、次のものを取得しましたperl -nE 'say+(/./g,0)[0,1,(unpack+S7,pack "H*","672b672bdc52c92fc2a59f5ba05b")[y/#//c]=~/./g]'。しかし、「＃a」と入力すると、「＃a0a0a0」が表示されますが、これは間違っていると思います。「#aaaaaa」にする必要があります。（たぶんpack（）呼び出しでミスをした。）
— JL
今回、unpack（）とpack（）の呼び出しをリテラルのshortsに置き換えて、次のものを取得しましたperl -nE 'say+(/./g,0)[0,1,(11111,11111,21212,12233,42434,23455,23456)[y/#//c]=~/./g]'。「#a」は「#aaaaaa」ではなく「＃a0a0a0」という誤った答えを返すため、依然として間違っているように見えます。
— JL
あ！私はそれを考え出した！次のように、-lスイッチでスイッチを使用する必要がありました（「L」の-nEように 「エル」です）perl -lnE 'say+(/./g,0)[0,1,(11111,11111,21212,12233,42434,23455,23456)[y/#//c]=~/./g]'。今では正しく動作します。
— JL
「（入力に末尾の改行がある場合、誤った結果を与える）」という警告は、「Run with perl -nE」を「Run with perl -lnE」に変更することで除去できます。（-lスイッチの部分は、末尾の改行を取り除きます。）
— JL
-Fコマンドラインでを使用すると、これをsay+(@F,0)[0,1,(unpack+S7,"g+g+ÜRÉ/Â¥[ [")[$#F]=~/./g]コードの5バイトを節約するように変更できます。
— Xcali
1

Windowsバッチ、389372362349231バイト

@Neilコードを完全にコピーしました...

@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
— スティーブフェストル
ソース
1
％s％を％1に置き換えると、数バイト節約できます。
— サティベル
2
%s:~3,1%%s:~4,1%に置き換えることができます%s:~3,2%。また、これがの入力に対して機能するかどうかわかりません#。
— ニール
2
ちなみに、私は別のアルゴリズムを試しましたが、243バイトで出てきました。
— ニール
1
アルゴリズムは何ですか？
— -stevefestl
1
（申し訳ありませんが、@ Neilが不足しているため、コメントは表示されませんでした。）定型文は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ますが、関心のある2つの行はとです。
— ニール
1

Pyth、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

Python 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]

オンラインでお試しください！

— ジッツェ
ソース
素敵な最初の投稿。余談ですが、オンラインでお試しください！回答に含めるコードを実行するオプションの推奨サイトです。CG＆CCポストを生成でき、ブートする正確なバイトカウントを提供します。
— ヴェスカー
とてもクール、ありがとう！
— Jitse
0

Python 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

誰かが私にいくつかのバイトを節約するのを手伝ってもらえますか？ifステートメントはすべて、短いものに短縮できるように思えますが、私にはわかりません。

— FantaC
ソース
1
各スニペットをリストに入れてインデックスを作成してみてください。また、Python 3に切り替えるとバイトを節約できる可能性が高く、これlist[len(list)-x]はと同じlist[-x]です。
— CalculatorFeline
いくつかのバイトを絞り出す場合は、（およびなどに変換することif t==1:を検討してください。確かに読みやすくありませんが、より多くのコードゴルフが可能です！if t<2:if t==2:if t<3:
— JL
0

TXR Lisp：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`))))
— カズ
ソース
0

Braingolf、95バイト

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

オンラインでお試しください！

これは事実上#、入力後の文字数に関するスイッチケースに相当するBraingolfに相当します。

説明

常に実行されるもの：

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

あなたはアイデアを得る

— スキッドデブ
ソース
0

05AB1E、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)
— ケビン・クルーッセン
ソース
弊社のサイトを使用することにより、あなたは弊社のクッキーポリシーおよびプライバシーポリシーを読み、理解したものとみなされます。
Licensed under cc by-sa 3.0 with attribution required.