인터넷을위한 더 나은 16 진 색상 코드

46

#ffffff(흰색) 또는 (파란색) 과 같은 16 진 삼중 항#3764ef 은 종종 RGB 색상을 나타내는 데 사용됩니다. 이들은 구성 #여섯 자리 16 진수 (0-F), 또는 때때로 다음 세 자리 실제 색상 각 숫자를 두배로함으로써 얻어진다. 예를 들어 #fffis #ffffffand #1a8is #11aa88입니다.

슬프게도, 그 세 자리 수의 속기는 인터넷이 지금까지 제공했던 가장 골치 거리였습니다 .

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임의 진수 숫자 일 수있다. 출력은 항상 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)로 가정 할 수 있습니다 .

  • 출력의 문자는 원하는 경우 모두 가능합니다. 케이스를 혼합 할 수도 있습니다.

  • 여기에서는 알파 / 투명도를 다루지 않습니다 (16 진수 버전의 RGBA 색상이 있음).

바이트 단위의 가장 짧은 코드가 이깁니다.

code-golf  string  hexadecimal  color 
— 캘빈의 취미
소스
11
" 슬프게도, 그 세 자리 속기는 인터넷 golfiest가 지금까지 제공해야했다. "- 어, 정확히 . HTML, 0 바이트
— 기본적으로
11
이것의 반대도 멋진 도전이 될 것입니다
— Beta Decay
9
#UVWXY -> #UVWXYYBlue 채널에 대한 단일 값 표현을 허용하기 때문에 항목에 만족하지 않지만 Red 및 Green에 대한 유사한 표현은 없습니다 (예 : 원하는 경우 #889071약어를 사용할 #907188수는 없지만 ... as #90718) 모두 잘 작동합니다.
— Draco18s
3
@ Draco18s 사랑합니다. 저것과 #UVWX -> #UXVXWX. 실제로 일관되지 않은 임의의 동작으로 실제로 현재이를 구현하는 브라우저가 없다고 믿기 어렵 습니다.
— xDaizu
1
@xDaizu CSS의 사양이 #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 바이트를 제거한다는 것을 알 수 있습니다 ...

@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 바이트
— 누가 복음
@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. 또한 #프로그램은 그대로 있기 때문에 수동으로 교체해야했습니다.

— 조나단 앨런
소스
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;
— 사용자
소스
나는 당신이 어떻게이 아이디어를 얻는 지 전혀 모르지만 작동합니다. 일 _21422112233122444113355123456[6*$i+++strlen($argn|aa)-8]?
— Jörg Hülsermann
1
어떻게 작동하는지 설명해 주시겠습니까?
— Brian H.
이것은 좋은 것입니다! 이것은 오프셋 점포 $argn에서 21422112233122444113355123456나 strlen에 기초하여 올바른 선택한다. aa문자열을 2 자 이상으로 채 웁니다. 입력시 #에는 없기 $argn[1]때문에 ?:0출력한다 0. 이것은 0문자열 에서도 작동 합니다. 내가 본 최고의 답변 중 하나! 슬프게도 너무 많이 지불하지 않습니다 (Jörg의 답변이 95까지 골프를 쳤습니다).
— Christoph
1
하하, 이것은 내가 본 PHP 자동 문자열의 가장 좋은 남용입니다. +1
— ETH 프로덕션
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의 답변 이지만 크게 골프를 쳤으므로 별도의 답변으로 게시하기로 결정했습니다. 나는이 답변을 나와 Jörg의 공동 노력으로 간주합니다.

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

각 패턴에 대한 정규식 대체 튜플 목록을 구성한 다음 index에서 튜플을 추출하여 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'(감사합니다, Gábor Fekete)

— L3viathan
소스
1
r'\1'명명 된 매개 변수로 사용하지 않으면 바이트가 절약됩니까?
— Gábor Fekete
1
코드를 작성 o=r'\1'했지만 사용 b: D
— Gábor Fekete
1
@ GáborFekete Whoops : D
— L3viathan
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

APL (Dyalog) , 43 바이트

⎕IO←0많은 시스템에서 기본값이 필요합니다 .

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

온라인으로 사용해보십시오!

1↓⍞ 첫 번째 문자 (해시)를 삭제

{ 다음 익명 함수를 적용하십시오

 (≢⍵)⊃ 다음의 7 개 값 중 하나를 선택하는 인수의 길이를 사용
  '0' A는 제로
  ⍵ 인수
  ⍵ 인수
  2/⍵ 개의 ( 2각각의) ( /인수) ( ⍵)
  ∊⍵,¨⊃⌽⍵ (가) (평탄화 ∊) 인자 ( ⍵각각 () 다음을 ,¨제에 의해) ( ⊃)의 역 ( ⌽) 인수 ( ⍵)
  ⍵,⌽⍵ 인수 ( ⍵) 앞에 ,역 ( ⌽) 인수 ( ⍵)
  ⍵ 인수

 6⍴ 6의 길이에 도달 할 때까지 그 요소를 반복

} 익명 함수의 끝

'#', 그것에 해시를 붙이다

— 아담
소스
2

파이썬 2, 167165 바이트

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.
— Trelzevir
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);

온라인으로 사용해보십시오!

또는 기본 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베이스를 사용하는 + 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 바이트로 줄 였지만 다른 것으로 생각하여 자체 답변 으로 게시했습니다 . 당신이 그것을 좋아 바랍니다 :)
— Christoph
2
@Christoph 나는 지금 내 버전으로 여기에 있습니다. 온라인에서 사용해보십시오!
— Jörg Hülsermann
2
베이스 33은 대단한 아이디어입니다! 나는 여기에 잠시 앉아 있었지만 망설이지 않았다.
— Christoph
1
@Christoph 그것은 내 첫 번째 버전의 골프와 매우 유사합니다. 당신의 접근하에 내 접근을 골프로 치는 것은 쉽지 않았습니다
— Jörg Hülsermann
1
@Christoph 감사와 기본 35 번호 시스템은 우리 팀워크에 대한 나의 접근 방식입니다.
— Jörg Hülsermann
2

레티 나 , 90 바이트

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

온라인으로 사용해보십시오! 테스트 사례를 포함합니다.

설명 : 첫 번째 변환은 두 자리 숫자, 두 번째 자리 3, 세 번째 자리 4, 네 번째 자리는 0을 처리합니다. 그러나 두 번째와 네 번째 번역은 마지막 자리를 반복하지만 나머지 모든 경우를 포함하기 위해 끝에서 수행됩니다.

— 닐
소스
2

하스켈 , 130 (127) 122 (118) 109 (95 바이트 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

온라인으로 사용해보십시오!

— Bartavelle
소스
뒤에 불필요한 공간이 있습니다 g.
— Laikoni 2016 년
1
또한 (x:r)!(y:t)=x:y:r!t;e!_=e보다 짧습니다 a!b=id=<<[[x,y]|(x,y)<-zip a b].
— Laikoni 2016 년
첫 번째 문자는 항상 #할 수 있습니다g(a:t)|l<-last t=a:[ ...
— Laikoni
@Laikoni, 정말로, 그것은 큰 개선입니다!
— bartavelle 2016 년
나는 당신과 비슷한 접근법을 사용 하는 95 바이트 솔루션 을 발견했다 . 사용하거나 별도의 답변을 게시 할 수 있습니다.
— user1472751
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
— 매지
소스
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)))

코드 스 니펫 표시

— 대릴 녀
소스
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,23456를 14 개의 latin1 문자로 인코딩합니다 . 명확성을위한 hexdump는 다음과 같습니다.

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 () 호출을 리터럴 반바지로 바꾸고 다음을 얻었습니다 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 배치, 389 372362 349231 바이트

@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 (으)로 바꾸면 몇 바이트가 절약됩니다.
— satibel
2
%s:~3,1%%s:~4,1%로 교체 할 수 있습니다 %s:~3,2%. 또한 이것이 입력에 작동하는지 잘 모르겠습니다 #.
— Neil
2
그건 그렇고, 나는 다른 알고리즘을 시도했고 243 바이트에서 나왔습니다.
— Neil
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입니다.
— Neil
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

파이썬 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 게시물을 생성 할 수 있으며 부팅 할 정확한 바이트 수를 제공합니다.
— Veskah
매우 시원합니다, 감사합니다!
— Jitse
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

누구든지 바이트를 절약 할 수 있습니까? 모든 if 문은 더 짧은 것으로 단축 될 수있는 것처럼 보입니다. 나는 무엇을 알지 못합니다.

— 환타
소스
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 리스프 : 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.