Meilleurs codes de couleur Hex pour votre Internet

46

Les triplets hexagonaux tels que #ffffff(blanc) ou #3764ef(bleuâtre) sont souvent utilisés pour désigner les couleurs RVB. Ils consistent en #suivis de six chiffres hexadécimaux (0-f), ou parfois de trois chiffres où la couleur réelle est obtenue en doublant chaque chiffre. Par exemple, #fffest #ffffffet #1a8est #11aa88.

Malheureusement, ce raccourci à trois chiffres était le plus risqué qu'Internet pouvait offrir jusqu'à présent .

Ecrivez un programme ou une fonction qui prend une chaîne de 1 à 7 caractères:

  • Le premier caractère sera toujours #.
  • Les autres personnages seront toujours des chiffres hexadécimaux: 0123456789abcdef.

L'entrée est une forme abrégée d'un triplet hexadécimal (ou la forme complète si 7 caractères sont fournis). Vous devez générer un triplet hexagonal complet qui élargit le raccourci d’entrée en fonction de ces modèles:

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

Chacun de U, V, W, X, Yet Zpeut - être un chiffre hexadécimal. La sortie comporte toujours 7 caractères.

Par exemple:

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

Remarques

  • L'entrée commencera toujours par #et la sortie aussi.

  • Vous pouvez supposer que toutes les lettres entrées sont en minuscule ( abcdef) ou en majuscule ( ABCDEF) selon vos préférences.

  • Les lettres dans la sortie peuvent être dans les deux cas comme vous préférez. Vous pouvez même mélanger des cas.

  • L'alpha / transparence n'est pas traité ici (bien qu'il existe des versions hexagonales des couleurs RGBA).

Le code le plus court en octets gagne.

Les passe-temps de Calvin
la source
11
" Malheureusement, ce raccourci à trois chiffres était le plus golfé qu'Internet pouvait offrir jusqu'à présent. " - Euh, pas exactement . HTML, 0 octet - ça marche comme
prévu
11
L'inverse de cela serait aussi un défi intéressant
Beta Decay
9
Je ne suis pas satisfait de l' #UVWXY -> #UVWXYYentrée car elle permet une représentation à valeur unique pour le canal bleu, mais il n'y a pas d'expression similaire pour le rouge et le vert (par exemple, si je voulais, #889071je ne peux pas abréger, mais #907188peut être ... comme #90718) les autres. tout fonctionne très bien.
Draco18s
3
@ Draco18s je l'aime. Celui-là et le #UVWX -> #UXVXWX. C'est un comportement tellement incohérent et arbitraire qu'il est difficile de croire qu'aucun navigateur ne l' implémente actuellement.
xDaizu
1
spécification @xDaizu CSS a #RGBAet #RRGGBBAA, donc # 1234 doit être lu commergba(17, 34, 51, 0.25)
tsh

Réponses:

13

JavaScript, 86 82 77 octets

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

juste découvrir que supprimer récursive enregistrer 4 octets ...

idée de @Arnauld économiser 4 octets, +1 octets supplémentaires

tsh
la source
([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+bpour 80 octets
Luke
@Luke je viens de recevoirReferenceError: x is not defined
tsh
6

Gelée , 24 octets



x2
j0ị$
m0

0
Ḣ;LĿṁ6$$

Un programme complet (les lignes vides sont en réalité des lignes vides).

Essayez-le en ligne! ou voir une suite de tests *

Comment?

     - 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

* le programme de la suite de tests a dû être modifié en inversant l’ordre de ce qui était le Main linket Link 7, tandis que le pied de page devenait le Main Link. En outre, il a #fallu le remplacer manuellement, car le programme en tant que tel l’est.

Jonathan Allan
la source
5

CJam, 45  44  42 40 36 35 octets

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

Exécute divers extraits de code en fonction de la longueur de l'entrée.

Fruit d'esolanging
la source
1
Un certain formatage <s> pas </ s> requis ....<s></s>
stevefestl
3
@SteveFest Mais le 44 barré est toujours régulier 44 ...
Fruit d'Esolanging
1
Aw! Tu m'as eu! Je l'ai oublié!
stevefestl
4

PHP 7.1, 88 octets

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

PHP 5, 90 88 octets

#<?for(;$i<6;)echo$argn[_10311001122011333002244012345[6*$i+++strlen($argn|aa)-8]+1]?:0;
utilisateur63956
la source
Je ne sais pas comment vous avez eu cette idée, mais ça marche. Travail _21422112233122444113355123456[6*$i+++strlen($argn|aa)-8]?
Jörg Hülsermann
1
Pourriez-vous s'il vous plaît expliquer comment cela fonctionne?
Brian H.
Celui-ci est sympa! Il stocke le décalage dans $argndans 21422112233122444113355123456et sélectionne la bonne base sur strlen. aacompresse la chaîne à au moins 2 caractères. Sur l’entrée, #il n’ya pas de sortie, $argn[1]donc ?:0a 0. Cela fonctionne aussi pour 0dans la chaîne. Une des meilleures réponses que j'ai vues! Malheureusement, cela ne paie pas trop (la réponse de Jörg a été réduite à 95).
Christoph
1
Haha, c'est le meilleur abus des chaînes automatiques de PHP que j'ai vues depuis un moment. +1
ETHproductions
1
@Christoph La deuxième version a besoin d'une version PHP inférieure à 7.1 et supérieure à 5.6 Je pense que cela devrait être plus clair
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);

Fondamentalement, la réponse de @ JörgHülsermann a beaucoup diminué, alors j’ai décidé de l’afficher séparément. Je considérerais cette réponse comme un effort collectif de Jörg et moi.

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

Python 3, 166 162 160 152 octets

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)

Je construis une liste de tuples de remplacement de regex pour chaque motif, puis extrait le tuple à l'index len(x)-1, le divisant enfin ( *) dans les arguments de 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

sauvé 8 octets en mémorisant r'\1'(merci, Gábor Fekete)

L3viathan
la source
1
Ne pas utiliser r'\1'comme paramètre nommé sauver quelques octets?
Gábor Fekete
1
Vous avez écrit o=r'\1'mais utilisez bdans votre code: D
Gábor Fekete
1
@ GáborFekete Whoops: D
L3viathan
3

Java 10, 228 227 224 182 octets

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

Essayez-le en ligne.

Explication:

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
la source
2

APL (Dyalog) , 43 octets

Nécessite ⎕IO←0ce qui est la valeur par défaut sur de nombreux systèmes.

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

Essayez-le en ligne!

1↓⍞ déposer le premier caractère (le hachage)

{ appliquer la fonction anonyme suivante

(≢⍵)⊃ utilisez la longueur de l'argument pour choisir l'une des sept valeurs suivantes:
  '0' a zéro
   l'argument
   l'argument
  2/⍵ two ( 2) de chaque ( /) de l'argument ( )
  ∊⍵,¨⊃⌽⍵ l' argument flattened ( ) ( ) suivi de chaque ( ) par le premier ( ) de l' argument reversé ( )
  ⍵,⌽⍵ l'argument ( ) prepended ( ,) à l' argument reversé ( )
   l'argument

6⍴ répéter les éléments à partir de ce point jusqu'à atteindre une longueur de six

} fin de la fonction anonyme

'#', ajouter un hachage à cela

Adam
la source
2

Python 2, 167 165 octets

-2 octets grâce à 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]])

Il crée une liste de chaînes et choisit en fonction de la longueur de la chaîne.

Gábor Fekete
la source
1
Vous pouvez enregistrer 2 octets avec z=zip.
Trelzevir
2

Sed, 119 (118 octets + -E)

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

Substitution de texte simple.

Kevin
la source
2

PHP, 87 octets

utiliser des numéros de base 35

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

Essayez-le en ligne!

ou utilisez des numéros de base 33

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

Essayez-le en ligne!

PHP, 89 octets

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

Essayez-le en ligne!

intval(["8kn",gd8,"9ft",wqq,i3j,i3k][strlen($argn|aa)-2],36) + 3 octets utilisant une base de 36

PHP, 102 octets

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

Essayez-le en ligne!

PHP, 180 octets

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

Essayez-le en ligne!

Jörg Hülsermann
la source
1
J'ai joué cette version à 95 octets mais je pensais que c'était différent, alors je l'ai postée comme une réponse personnelle . J'espère que vous l'aimerez :)
Christoph
2
@Christoph Au moment où je suis ici avec ma version Essayez-le en ligne!
Jörg Hülsermann
2
La base 33 est une idée géniale! Je suis assis ici depuis un moment, mais je ne l'ai pas trouvé.
Christoph
1
@Christoph c'est très similaire avec votre golfing de ma première version. Il n’était pas facile de
jouer
1
@Christoph Merci et le système de base 35 Nombre est mon approche dans notre travail d'équipe
Jörg Hülsermann
2

Rétine , 90 octets

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

Essayez-le en ligne! Inclut les cas de test.

Explication: La première traduction utilise deux chiffres, la deuxième trois, la troisième quatre et la quatrième zéro. Cependant, ni les deuxième et quatrième traductions ne répètent le dernier chiffre, comme cela est fait à la fin pour couvrir tous les cas restants.

Neil
la source
2

Haskell , 130 127 122 118 109 95 octets (par l' utilisateur1472751 )

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

Essayez-le en ligne!

Bartavelle
la source
Il y a un espace superflu derrière g.
Laikoni
1
Aussi (x:r)!(y:t)=x:y:r!t;e!_=eest plus court que a!b=id=<<[[x,y]|(x,y)<-zip a b].
Laikoni
Comme le premier personnage est toujours #possibleg(a:t)|l<-last t=a:[ ...
Laikoni
@Laikoni en effet, ce sont de grandes améliorations!
bartavelle
J'ai trouvé une solution de 95 octets qui utilise une approche similaire à la vôtre (les grands esprits se rencontrent, hein?). Vous pouvez l'utiliser ou je peux poster une réponse séparée.
user1472751
2

Powershell, 113 111 octets

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

Script de test expliqué:

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

Sortie:

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
la source
1

JavaScript (ES6), 96 octets

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

Darrylyeo
la source
1

Perl, 61 octets

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

Courez avec perl -nE. Suppose que l’entrée est conforme à la description (donne des résultats incorrects si l’entrée a une nouvelle ligne).

La chaîne "g + g + ÜRÉ / Â ¥ [[" "code les 7 nombres de 16 bits 11111,11111,21212,12233,42434,23455,23456sous forme de 14 caractères latins1. Voici un cliché hexagonal pour plus de clarté:

0000001d: 672b 672b dc52 c92f c2a5 9f5b a05b       g+g+.R./...[.[
Grimmy
la source
Je l' ai remplacé la chaîne Latin-1 avec un appel à emballer (), et a obtenu: perl -nE 'say+(/./g,0)[0,1,(unpack+S7,pack "H*","672b672bdc52c92fc2a59f5ba05b")[y/#//c]=~/./g]'. Mais lorsque je tape "#a", je reçois "# a0a0a0", ce qui me semble faux. Ce devrait être "#aaaaaa". (Peut-être que j'ai commis une erreur lors de l'appel du pack ().)
JL
Cette fois , je remplace le déballer () & pack () appelle avec le short littéral, et a: perl -nE 'say+(/./g,0)[0,1,(11111,11111,21212,12233,42434,23455,23456)[y/#//c]=~/./g]'. Cela semble toujours être faux, car "#a" donne toujours la réponse incorrecte de "# a0a0a0" (au lieu de "#aaaaaa").
JL
Ah! Je l'ai compris! Je avais besoin d'utiliser le -lcommutateur (qui est « ELL » , comme dans la « lettre L ») avec le -nEcommutateur, comme celui - ci: perl -lnE 'say+(/./g,0)[0,1,(11111,11111,21212,12233,42434,23455,23456)[y/#//c]=~/./g]'. Maintenant cela fonctionne correctement.
JL
L'avertissement indiquant "(donne des résultats incorrects si l'entrée comporte une nouvelle ligne") peut être éliminé en remplaçant "Exécuter avec perl -nE" par "Exécuter avec perl -lnE". (La -lpartie du commutateur supprime la nouvelle ligne pour vous.)
JL
Utiliser -Fsur la ligne de commande vous permet de changer cela pour say+(@F,0)[0,1,(unpack+S7,"g+g+ÜRÉ/Â¥[ [")[$#F]=~/./g]économiser 5 octets dans le code.
Xcali
1

Lot Windows, 389 372 362 349 231 octets

J'ai totalement copié le code @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
stevefestl
la source
1
remplacer% s% par% 1 devrait vous faire économiser quelques octets.
Satibel
2
%s:~3,1%%s:~4,1%peut être remplacé par %s:~3,2%. Aussi, je ne suis pas sûr que cela fonctionne pour une entrée de #.
Neil
2
A propos, j'ai essayé un algorithme différent, et il est sorti à 243 octets.
Neil
1
Puis-je savoir quel est l'algorithme?
stevefestl
1
(Désolé, je n'ai pas vu votre commentaire à cause du manque de @Neil.) Il y a un passe-partout, mais les deux lignes d'intérêt sont call:c %s:~1,1% %s:~2,1% %s:~3,1% %s:~4,1% %s:~5,1% %s:~6,1%et 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 octets

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

Essayez-le en ligne ici ou vérifiez tous les cas de test ici .

+\#@<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
la source
1

Python 2 , 99 octets

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]

Essayez-le en ligne!

Jitse
la source
Nice premier post. De plus, essayez-le en ligne! est un site facultatif mais recommandé qui exécute du code à inclure dans votre réponse. Il peut générer des publications CG & CC et donner un nombre d'octets précis à démarrer.
Veskah le
Très cool, merci!
Jitse
0

Python 2 - 179 octets

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

Quelqu'un peut-il m'aider à économiser des octets? Si toutes les déclarations semblent pouvoir être réduites en quelque chose de plus court, je ne sais pas quoi.

FantaC
la source
1
Essayez de mettre chaque extrait dans une liste et d’indexer. En outre, le passage à Python 3 économisera probablement les octets et list[len(list)-x]est identique à list[-x].
CalculatriceFeline
Si vous souhaitez supprimer quelques octets, envisagez de convertir if t==1:en if t<2:(et if t==2:en if t<3:, etc.). C'est moins lisible, certes, mais plus codable au golf!
JL
0

TXR Lisp: 171 octets

Dentelé:

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

C’est une fonction anonyme: la domacro génère un(lambda ...) formulaire.

C'est un style de codage idiomatique, adapté à la production; le seul golf est en écrasant les espaces blancs:

(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
la source
0

Braingolf , 95 octets

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

Essayez-le en ligne!

Ceci est effectivement l'équivalent de Braingolf d'un switch-case sur le nombre de caractères après #l'entrée.

Explication

Des choses qui fonctionnent toujours:

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

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

Si #XX

Celui-ci peut être golfable un peu, je pourrais le regarder quand je rentre à la maison

.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

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

Vous avez eu l'idée

Skidsdev
la source
0

Ruby , 127 octets

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)

Essayez-le en ligne!

JL
la source
0

Ruby , 118 octets

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

Essayez-le en ligne!

JL
la source
0

05AB1E , 24 octets

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

Essayez-le en ligne ou vérifiez tous les cas de test .

Explication:

ć           # 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
la source