Bessere Hex-Farbcodes für Ihr Internet

46

Hexadezimaltripel wie #ffffff(weiß) oder #3764ef(bläulich) werden häufig zur Bezeichnung von RGB-Farben verwendet. Sie bestehen aus #sechs hexadezimalen Ziffern (0-f) oder manchmal drei Ziffern, wobei die echte Farbe durch Verdoppeln jeder Ziffer erhalten wird. Zum Beispiel #fffist #ffffffund #1a8ist #11aa88.

Leider war die dreistellige Kurzschreibweise die golfiest das Internet zu bieten hatte, bis jetzt .

Schreiben Sie ein Programm oder eine Funktion mit einer Zeichenfolge von 1 bis 7 Zeichen:

  • Das erste Zeichen wird immer sein #.
  • Die anderen Zeichen werden immer hexadezimale Ziffern sein: 0123456789abcdef.

Die Eingabe ist eine Kurzform eines Hex-Tripletts (oder die vollständige Form, wenn 7 Zeichen angegeben sind). Sie müssen ein vollständiges Hex-Triplet ausgeben, das die Eingabekurzform basierend auf den folgenden Mustern erweitert:

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

Jede U, V, W, X, Y, und Zkann jede hexadezimale Ziffer sein. Die Ausgabe ist immer 7 Zeichen.

Zum Beispiel:

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

Anmerkungen

  • Die Eingabe beginnt immer mit #und muss auch die Ausgabe sein.

  • Sie können davon ausgehen, dass alle eingegebenen Buchstaben Kleinbuchstaben ( abcdef) oder Großbuchstaben ( ABCDEF) sind.

  • Die Buchstaben in der Ausgabe können in beiden Fällen beliebig sein. Sie können sogar Fälle mischen.

  • Alpha / Transparenz wird hier nicht behandelt (obwohl es hexadezimale Versionen von RGBA-Farben gibt).

Der kürzeste Code in Bytes gewinnt.

code-golf  string  hexadecimal  color 
— Calvins Hobbys
quelle
11
" Leider war diese dreistellige Abkürzung die Golfste, die das Internet bisher zu bieten hatte. " - Äh, nicht genau . HTML, 0 Bytes - es funktioniert
— sofort
11
Das Gegenteil wäre auch eine coole Herausforderung
— Beta Decay
9
Ich bin mit dem #UVWXY -> #UVWXYYEintrag nicht zufrieden, da er eine Einzelwertdarstellung für den blauen Kanal zulässt, aber es gibt keinen ähnlichen Ausdruck für Rot und Grün (z. B. wenn ich wollte, #889071kann ich nicht abkürzen, #907188kann aber ... wie #90718die anderen sein) Alle arbeiten großartig.
— Draco18s
3
@ Draco18s Ich liebe es. Das und das #UVWX -> #UXVXWX. Es ist ein so inkonsistentes und willkürliches Verhalten, dass es kaum zu glauben gibt, dass es derzeit nicht einige Browser gibt, die es tatsächlich implementieren.
— xDaizu
1
@xDaizu CSS-Spezifikation hat #RGBAund #RRGGBBAA, so dass # 1234 alsrgba(17, 34, 51, 0.25)
— tsh

Antworten:

13

JavaScript, 86 82 77 Bytes

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

Finden Sie heraus, dass rekursive Save 4 Bytes entfernen ...

Idee von @Arnauld spart 4 Bytes, +1 weitere Bytes

— tsh
quelle
([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+bfür 80 Bytes
— Luke
@ Luke Ich habe geradeReferenceError: x is not defined
— tsh
6

Gelee , 24 Bytes



x2
j0ị$
m0

0
Ḣ;LĿṁ6$$

Ein volles Programm (die Leerzeilen sind eigentlich Leerzeilen).

Probieren Sie es online! oder sehen Sie sich eine Testsuite an *

Wie?

     - 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

* Das Programm der Testsuite musste geändert werden, indem die Reihenfolge der Main linkund vertauscht wurde Link 7, während die Fußzeile zur Main Link. Außerdem #musste das manuell ausgetauscht werden, da das Programm es so wie es ist leitet.

— Jonathan Allan
quelle
4

PHP 7.1, 88 Bytes

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

PHP 5, 90 88 Bytes

#<?for(;$i<6;)echo$argn[_10311001122011333002244012345[6*$i+++strlen($argn|aa)-8]+1]?:0;
— user63956
quelle
Ich habe keine Ahnung, wie Sie auf diese Idee kommen, aber sie funktioniert. Arbeit _21422112233122444113355123456[6*$i+++strlen($argn|aa)-8]?
— Jörg Hülsermann 30.
1
Könntest du bitte erklären, wie das funktioniert?
— Brian H.
Dieser ist schön! Es speichert den Versatz in $argnin 21422112233122444113355123456und wählt die richtige basierend auf Strlen. aaFüllt die Saite mit mindestens 2 Zeichen auf. Bei der Eingabe #gibt es keine $argn[1]so ?:0Ausgänge a 0. Dies funktioniert auch für 0die Zeichenfolge. Eine der besten Antworten, die ich gesehen habe! Leider zahlt es sich nicht zu viel aus (Jörgs Antwort wurde auf 95 herabgesetzt).
— Christoph
1
Haha, das ist der beste Missbrauch von PHPs automatischen Zeichenfolgen, den ich seit einiger Zeit gesehen habe. +1
— ETHproductions
1
@Christoph Die zweite Version benötigt eine PHP-Version unter 7.1 und eine PHP-Version über 5.6. Ich denke, dies sollte dies klarer machen
— Jörg 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);

Grundsätzlich hat @ JörgHülsermanns Antwort aber stark nachgelassen, so dass ich mich entschlossen habe, sie als separate Antwort zu posten. Ich würde diese Antwort als eine gemeinsame Anstrengung von mir und Jörg betrachten.

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

Python 3, 166 162 160 152 Bytes

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)

Ich len(x)-1erstelle eine Liste mit Regex-Ersetzungstupeln für jedes Muster, extrahiere dann das Tupel am Index und zerlege *es schließlich ( ) in die Argumente von 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 Bytes durch Auswendiglernen gespeichert r'\1'(Danke, Gábor Fekete)

— L3viathan
quelle
1
Würde die Verwendung r'\1'als benannter Parameter nicht einige Bytes sparen?
— Gábor Fekete
1
Sie haben geschrieben, o=r'\1'aber bin Ihrem Code verwendet: D
— Gábor Fekete
1
@ GáborFekete Whoops: D
— L3viathan
3

Java 10, 228 227 224 182 Bytes

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

Probieren Sie es online aus.

Erläuterung:

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
— Kevin Cruijssen
quelle
2

APL (Dyalog) , 43 Bytes

Benötigt, ⎕IO←0was auf vielen Systemen Standard ist.

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

Probieren Sie es online!

1↓⍞ lösche das erste Zeichen (den Hash)

{ Wenden Sie die folgende anonyme Funktion an

 (≢⍵)⊃ Verwenden Sie die Länge des Arguments, um einen der folgenden sieben Werte auszuwählen:
  '0' a Null
  ⍵ das Argument
  ⍵ das Argument
  2/⍵ zwei ( 2) von jedem ( /) des Arguments ( ⍵)
  ∊⍵,¨⊃⌽⍵ das abgeflachte ( ∊) Argument ( ⍵) gefolgt von jedem ( ,¨) von dem ersten ( ⊃) von das umgekehrte ( ⌽) Argument ( ⍵)
  ⍵,⌽⍵ das Argument ( ⍵) vorangestellt ( ,) auf das umgekehrte ( ⌽) Argument ( ⍵)
  ⍵ das Argument

 6⍴ Wiederholen Sie die Schritte, bis eine Länge von sechs erreicht ist

} Ende der anonymen Funktion

'#', stellen Sie dem einen Hash voran

— Adam
quelle
2

Python 2, 167 165 Bytes

-2 Bytes dank Trelzevir 

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

Es erstellt eine Liste von Zeichenfolgen und wählt basierend auf der Länge der Zeichenfolge.

— Gábor Fekete
quelle
1
Sie können mit 2 Bytes sparen z=zip.
— Trelzevir
2

Sed, 119 (118 Bytes + -E)

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

Einfache Textsubstitution.

— Kevin
quelle
2

PHP, 87 Bytes

benutze Base 35 Numbers 

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

Probieren Sie es online!

oder verwenden Sie die Basis 33-Nummern 

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

Probieren Sie es online!

PHP, 89 Bytes

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

Probieren Sie es online!

intval(["8kn",gd8,"9ft",wqq,i3j,i3k][strlen($argn|aa)-2],36) + 3 Bytes bei 36 Basen

PHP, 102 Bytes

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

Probieren Sie es online!

PHP, 180 Bytes

<?=[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)];

Probieren Sie es online!

— Jörg Hülsermann
quelle
1
Ich habe diese Version auf 95 Bytes heruntergespielt, aber ich dachte, es wäre zu anders, also habe ich sie als eigene Antwort gepostet . Hoffe es gefällt euch :)
— Christoph
2
@Christoph Im Moment bin ich hier mit meiner Version Online
— Jörg Hülsermann 30.
2
Base 33 ist eine großartige Idee! Ich habe schon eine Weile hier gesessen, aber es ist mir nicht eingefallen, verdammt.
— Christoph
1
@Christoph es ist sehr ähnlich mit deinem Golfen meiner ersten Version. Es war nicht einfach, meinen Ansatz unter Ihrem Ansatz zu spielen
— Jörg
1
@Christoph Danke und das Base 35 Number System ist mein Ansatz in unserer Teamarbeit
— Jörg Hülsermann
2

Netzhaut , 90 Bytes

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

Probieren Sie es online! Beinhaltet Testfälle.

Erläuterung: Die erste Übersetzung behandelt zwei Ziffern, die zweite drei, die dritte vier und die vierte null. Weder die zweite noch die vierte Übersetzung wiederholen jedoch die (letzte) Ziffer, da dies ohnehin am Ende erfolgt, um alle verbleibenden Fälle abzudecken.

— Neil
quelle
2

Haskell , 130 127 122 118 109 95 Bytes (von 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

Probieren Sie es online!

— Bartavelle
quelle
Dahinter steckt ein überflüssiger Raum g.
— Laikoni
1
Ist auch (x:r)!(y:t)=x:y:r!t;e!_=ekürzer als a!b=id=<<[[x,y]|(x,y)<-zip a b].
— Laikoni
Da der erste Char immer #möglich istg(a:t)|l<-last t=a:[ ...
— Laikoni
@ Laikoni in der Tat, das sind tolle Verbesserungen!
— Bartavelle
Ich habe eine 95-Byte-Lösung gefunden , die einen ähnlichen Ansatz wie Sie verwendet (große Köpfe denken ähnlich, oder?). Sie können es verwenden oder ich kann eine separate Antwort posten.
— user1472751
2

Powershell, 113 111 Bytes

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

Erklärtes Testskript:

$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"
}

Ausgabe:

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
quelle
1

JavaScript (ES6), 96 Byte

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

Code-Snippet anzeigen

— darrylyeo
quelle
1

Perl, 61 Bytes

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

Laufen Sie mit perl -nE. Nimmt an, dass die Eingabe genau wie beschrieben ist (führt zu falschen Ergebnissen, wenn die Eingabe eine nachgestellte Newline enthält).

Die Zeichenfolge "g + g + ÜRÉ / Â ¥ [[" codiert die 7 16-Bit-Zahlen 11111,11111,21212,12233,42434,23455,23456als 14 lateinische Zeichen1 . Hier ist ein Hexdump zur Verdeutlichung:

0000001d: 672b 672b dc52 c92f c2a5 9f5b a05b       g+g+.R./...[.[
— Grimmig
quelle
Ich ersetzen das Latin-1 - String mit einem Anruf () zu packen, und bekam: perl -nE 'say+(/./g,0)[0,1,(unpack+S7,pack "H*","672b672bdc52c92fc2a59f5ba05b")[y/#//c]=~/./g]'. Aber wenn ich "#a" eingebe, erhalte ich "# a0a0a0", was ich für falsch halte. Es sollte "#aaaaaa" sein. (Vielleicht habe ich einen Fehler beim Aufruf von pack () gemacht.)
— JL
Diesmal ersetzt ich das auspacken () & pack () ruft die wörtlichen Shorts und bekam: perl -nE 'say+(/./g,0)[0,1,(11111,11111,21212,12233,42434,23455,23456)[y/#//c]=~/./g]'. Es scheint immer noch falsch zu sein, da "#a" immer noch die falsche Antwort von "#a0a0a0" liefert (anstelle von "#aaaaa").
— JL
Ah! Ich habe es herausgefunden! Ich brauchte die verwenden -lSchalter (das „ell“ , wie er in der „Buchstabe L“) mit dem -nESchalter, wie folgt aus : perl -lnE 'say+(/./g,0)[0,1,(11111,11111,21212,12233,42434,23455,23456)[y/#//c]=~/./g]'. Jetzt funktioniert es richtig.
— JL
Die Warnung "(führt zu falschen Ergebnissen, wenn die Eingabe einen Zeilenumbruch enthält)" kann durch Ändern von "Ausführen mit perl -nE" in "Ausführen mit perl -lnE" behoben werden . (Der -lTeil des Schalters beseitigt für Sie den nachgestellten Zeilenumbruch.)
— JL
Mit -Fin der Befehlszeile können Sie dies ändern, say+(@F,0)[0,1,(unpack+S7,"g+g+ÜRÉ/Â¥[ [")[$#F]=~/./g]um 5 Bytes im Code zu sparen.
— Xcali
1

Windows Batch, 389 372 362 349 231 Bytes

Ich habe den @Neil-Code komplett kopiert ...

@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
quelle
1
Wenn Sie% s% durch% 1 ersetzen, sparen Sie einige Bytes.
— Samstag,
2
%s:~3,1%%s:~4,1%kann durch ersetzt werden %s:~3,2%. Ich bin mir auch nicht sicher, ob das bei einer Eingabe von funktioniert #.
— Neil
2
Übrigens habe ich einen anderen Algorithmus ausprobiert, der bei 243 Byte herauskam.
— Neil
1
Darf ich wissen, was der Algorithmus ist?
— Stevefestl
1
(Entschuldigung, ich habe Ihren Kommentar aufgrund eines Mangels an @Neil nicht gesehen.) Es gibt ein Boilerplate, aber die beiden Linien von Interesse sind call:c %s:~1,1% %s:~2,1% %s:~3,1% %s:~4,1% %s:~5,1% %s:~6,1%und 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 Bytes

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

Probieren Sie es hier online aus oder überprüfen Sie alle Testfälle hier .

+\#@<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
— Sok
quelle
1

Python 2 , 99 Bytes

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]

Probieren Sie es online!

— Jitse
quelle
Schöner erster Beitrag. Übrigens, versuchen Sie es online! ist eine optionale, aber empfohlene Site, auf der Code ausgeführt wird, der in Ihre Antwort aufgenommen wird. Es kann CG & CC-Posts generieren und liefert eine genaue Byteanzahl zum Booten.
— Veskah,
Sehr cool, danke!
— Jitse
0

Python 2 - 179 Bytes

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

Kann mir jemand helfen, ein paar Bytes zu sparen? Alle if-Anweisungen scheinen sich in etwas Kürzeres zu verkürzen, ich weiß nur nicht, was.

— FantaC
quelle
1
Versuchen Sie, jedes Snippet in eine Liste aufzunehmen und zu indizieren. Wenn Sie zu Python 3 wechseln, sparen Sie höchstwahrscheinlich Byte und list[len(list)-x]das gleiche wie bei list[-x].
— CalculatorFeline
Wenn Sie einige Bytes herausdrücken möchten, sollten Sie if t==1:in if t<2:(und if t==2:nach if t<3:usw.) konvertieren . Es ist zwar weniger lesbar, aber mehr Code-Golf-fähig!
— JL
0

TXR Lisp: 171 Bytes

Eingerückt:

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

Dies ist eine anonyme Funktion: Das doMakro generiert ein (lambda ...)Formular.

Es ist idiomatische codierung stil, geeignet für die produktion; das einzige Golfspiel ist das Quetschen von Leerzeichen:

(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
quelle
0

Braingolf , 95 Bytes

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

Probieren Sie es online!

Dies ist praktisch das Äquivalent von Braingolf zu einem Schalter für die Anzahl der Zeichen nach dem #in der Eingabe.

Erläuterung

Sachen, die immer laufen:

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

Wenn #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

Wenn #XX

Dieser mag ein bisschen golf sein, ich könnte ihn mir ansehen, wenn ich nach Hause komme

.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

Wenn #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

Du hast die Idee

— Skidsdev
quelle
0

05AB1E , 24 Byte

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

Probieren Sie es online aus oder überprüfen Sie alle Testfälle .

Erläuterung:

ć           # 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)
— Kevin Cruijssen
quelle
Durch die Nutzung unserer Website bestätigen Sie, dass Sie unsere Cookie-Richtlinie und Datenschutzrichtlinie gelesen und verstanden haben.
Licensed under cc by-sa 3.0 with attribution required.