Mejores códigos de color hexadecimales para su Internet


46

Los tripletes hexadecimales como #ffffff(blanco) o #3764ef(azulado) se usan a menudo para denotar colores RGB. Consisten en #seguidos de seis dígitos hexadecimales (0-f), o, a veces, tres dígitos donde se obtiene el color real duplicando cada dígito. Por ejemplo, #fffes #ffffffy #1a8es #11aa88.

Lamentablemente, esa taquigrafía de tres dígitos era la más elegante que Internet tenía para ofrecer, hasta ahora .

Escriba un programa o función que tome una cadena de 1 a 7 caracteres:

  • El primer carácter será siempre #.
  • Los otros personajes siempre estarán dígitos hexadecimales: 0123456789abcdef.

La entrada es una forma abreviada de un triplete hexadecimal (o la forma completa si se dan 7 caracteres). Debe generar un triplete hexadecimal completo que expanda la taquigrafía de entrada en función de estos patrones:

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

Cada uno de U, V, W, X, Y, y Zpuede ser cualquier dígito hexadecimal. La salida es siempre de 7 caracteres.

Por ejemplo:

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

Notas

  • La entrada siempre comenzará #y también la salida.

  • Puede suponer que todas las letras de entrada son minúsculas ( abcdef) o mayúsculas ( ABCDEF) como prefiera.

  • Las letras en la salida pueden estar en cualquier caso como prefiera. Incluso puedes mezclar casos.

  • Alfa / transparencia no se trata aquí (aunque hay versiones hexadecimales de colores RGBA).

El código más corto en bytes gana.


11
" Lamentablemente, esa taquigrafía de tres dígitos era la más elegante que Internet tenía para ofrecer, hasta ahora ". Uh, no exactamente . HTML, 0 bytes - funciona de fábrica
Bergi

11
El reverso de esto también sería un desafío genial
Beta Decay

99
No estoy satisfecho con la #UVWXY -> #UVWXYYentrada porque permite una representación de un solo valor para el canal Azul, pero no hay una expresión similar para Rojo y Verde (por ejemplo, si quisiera #889071no puedo abreviar, pero #907188puedo ser ... como #90718) los otros Todo funciona muy bien.
Draco18s

3
@ Draco18s me encanta. Ese y el #UVWX -> #UXVXWX. Es un comportamiento tan inconsistente y arbitrario que es difícil creer que no haya un par de navegadores que lo implementen actualmente.
xDaizu

1
La especificación CSS @xDaizu tiene #RGBAy #RRGGBBAA, por lo tanto, # 1234 debe leerse comorgba(17, 34, 51, 0.25)
tsh

Respuestas:


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

solo descubra que eliminar recursivo guardar 4 bytes ...

idea de @Arnauld guardar 4 bytes, +1 bytes más


([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+bpor 80 bytes
Lucas

@Luke que acabo de recibirReferenceError: x is not defined
tsh

6

Jalea , 24 bytes



x2
j0ị$
m0

0
Ḣ;LĿṁ6$$

Un programa completo (las líneas vacías son en realidad líneas vacías).

Pruébalo en línea! o ver un conjunto de pruebas *

¿Cómo?

     - 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

* el programa de la suite de pruebas tuvo que modificarse cambiando el orden de lo que eran Main linky Link 7, mientras que el pie de página se convirtió en Main Link. Además, #tuvo que ser reemplazado manualmente, ya que el programa tal cual lo encabeza.



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;

No tengo idea de cómo se obtiene esta idea, pero funciona. Trabajo _21422112233122444113355123456[6*$i+++strlen($argn|aa)-8]?
Jörg Hülsermann

1
¿podría explicar cómo funciona esto?
Brian H.

Este es lindo! Almacena el desplazamiento en $argnen 21422112233122444113355123456y selecciona el correcto basado en strlen. aarellena la cadena con al menos 2 caracteres. En la entrada #hay ninguna es $argn[1]tan ?:0da salida a una 0. Esto también funciona para 0en la cadena. ¡Una de las mejores respuestas que he visto! Lamentablemente, no paga demasiado (la respuesta de Jörg se redujo a 95).
Christoph

1
Jaja, este es el mejor abuso de las cadenas automáticas de PHP que he visto en mucho tiempo. +1
ETHproductions

1
@Christoph La segunda versión necesita una versión PHP en 7.1 y una versión PHP en 5.6 Creo que agregar esto debería
aclarar

3

PHP, 95 93 89 87

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

Básicamente, la respuesta de @ JörgHülsermann, pero fue un gran fracaso, así que decidí publicarla como una respuesta separada. Contaría esta respuesta como un esfuerzo colectivo de mí y Jörg.

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

Construyo una lista de tuplas de reemplazo de expresiones regulares para cada patrón, y luego len(x)-1extraigo la tupla en el índice , finalmente salpicando ( *) en los argumentos 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

ahorró 8 bytes al memorizar r'\1'(gracias, Gábor Fekete)


1
¿El uso r'\1'como parámetro con nombre no guardaría algunos bytes?
Gábor Fekete

1
Escribiste o=r'\1'pero usas ben tu código: 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);}

Pruébalo en línea.

Explicación:

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 bytes

Requiere ⎕IO←0cuál es el predeterminado en muchos sistemas.

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

Pruébalo en línea!

1↓⍞ soltar el primer carácter (el hash)

{ aplicar la siguiente función anónima

(≢⍵)⊃ use la longitud del argumento para elegir uno de los siguientes siete valores:
  '0' a cero
   el argumento
   el argumento
  2/⍵ dos ( 2) de cada ( /) del argumento ( )
  ∊⍵,¨⊃⌽⍵ el argumento aplanado ( ) seguido de cada ( ) por el primero ( ) de el argumento invertido ( ) ( )
  ⍵,⌽⍵ el argumento ( ) antepuesto ( ,) al argumento invertido ( ) ( )
   el argumento

6⍴ repita elementos de eso hasta que se logre una longitud de seis

} fin de la función anónima

'#', anteponer un hash a eso


2

Python 2, 167 165 bytes

-2 bytes gracias a 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]])

Crea una lista de cadenas y elige según la longitud de la cadena.


1
Puede guardar 2 bytes usando 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/^/#/

Sustitución directa de texto.


2

PHP, 87 bytes

utilizar números de Base 35

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

Pruébalo en línea!

o use los números de Base 33

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

Pruébalo en línea!

PHP, 89 bytes

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

Pruébalo en línea!

intval(["8kn",gd8,"9ft",wqq,i3j,i3k][strlen($argn|aa)-2],36) + 3 bytes usando una base 36

PHP, 102 bytes

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

Pruébalo en línea!

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

Pruébalo en línea!


1
Reduje esta versión a 95 bytes, pero pensé que era diferente, así que la publiqué como una respuesta propia . Espero que les guste :)
Christoph

2
@ Christoph En el momento en que estoy aquí con mi versión ¡ Pruébelo en línea!
Jörg Hülsermann

2
¡Base 33 es una idea increíble! He estado sentado aquí un tiempo, pero no se me ocurrió nada.
Christoph

1
@ Christoph es muy similar con tu golf de mi primera versión. No fue fácil jugar mi enfoque bajo tu enfoque
Jörg Hülsermann

1
@Christoph Gracias y el sistema de números base 35 es mi enfoque en nuestro trabajo en equipo
Jörg Hülsermann

2

Retina , 90 bytes

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

Pruébalo en línea! Incluye casos de prueba.

Explicación: La primera traducción maneja dos dígitos, el segundo tres, el tercero cuatro y el cuarto cero. Sin embargo, ni la segunda y la cuarta traducción repiten el (último) dígito, ya que eso se hace al final de todos modos para cubrir todos los casos restantes.


2

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

Pruébalo en línea!


Hay un espacio superfluo detrás g.
Laikoni 01 de

1
También (x:r)!(y:t)=x:y:r!t;e!_=ees más corto que a!b=id=<<[[x,y]|(x,y)<-zip a b].
Laikoni

Como el primer personaje es siempre #puedes hacerlog(a:t)|l<-last t=a:[ ...
Laikoni

@Laikoni de hecho, esas son grandes mejoras!
bartavelle 01 de

Encontré una solución de 95 bytes que usa un enfoque similar al tuyo (las grandes mentes piensan igual, ¿eh?). Puedes usarlo o puedo publicar una respuesta por separado.
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]]

Script de prueba explicado:

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

Salida:

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 bytes

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 bytes

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

Corre con perl -nE. Asume que la entrada es exactamente como se describe (da resultados incorrectos si la entrada tiene una nueva línea final).

La cadena "g + g + ÜRÉ / Â ¥ [[" codifica los 7 números de 16 bits 11111,11111,21212,12233,42434,23455,23456como 14 caracteres latin1. Aquí hay un hexdump para mayor claridad:

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

He sustituido la cadena América-1 con una llamada a pack (), y tengo: perl -nE 'say+(/./g,0)[0,1,(unpack+S7,pack "H*","672b672bdc52c92fc2a59f5ba05b")[y/#//c]=~/./g]'. Pero cuando escribo "#a", obtengo "# a0a0a0", lo que creo que está mal. Debería ser "#aaaaaa". (Tal vez cometí un error en la llamada pack ().)
JL

Esta vez me sustituyó a la de desempaquetado () y paquete () llama a los cortos literales, y consiguió: perl -nE 'say+(/./g,0)[0,1,(11111,11111,21212,12233,42434,23455,23456)[y/#//c]=~/./g]'. Todavía parece estar equivocado, ya que "#a" aún produce la respuesta incorrecta de "# a0a0a0" (en lugar de "#aaaaaa").
JL

Ah! ¡Me lo imaginé! Necesitaba usar el -linterruptor (que es "ell" como en la "letra L") con el -nEinterruptor, así: perl -lnE 'say+(/./g,0)[0,1,(11111,11111,21212,12233,42434,23455,23456)[y/#//c]=~/./g]'. Ahora funciona correctamente.
JL

La advertencia que dice "(da resultados incorrectos si la entrada tiene una nueva línea final)" puede eliminarse cambiando "Ejecutar con perl -nE" a "Ejecutar con perl -lnE". (La -lparte del cambio se deshace de la nueva línea final para usted.)
JL

El uso -Fen la línea de comando le permite cambiar esto para say+(@F,0)[0,1,(unpack+S7,"g+g+ÜRÉ/Â¥[ [")[$#F]=~/./g]guardar 5 bytes en el código.
Xcali

1

Lote de Windows, 389 372 362 349 231 bytes

Copié totalmente el código @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
reemplazar% s% con% 1 debería ahorrarle unos pocos bytes.
satibel

2
%s:~3,1%%s:~4,1%puede ser reemplazado con %s:~3,2%. Además, no estoy seguro de que esto funcione para una entrada de #.
Neil

2
Por cierto, probé un algoritmo diferente, y salió a 243 bytes.
Neil

1
¿Puedo saber cuál es el algoritmo?
stevefestl

1
(Lo siento, no vi tu comentario debido a la falta de @Neil.) Hay algo repetitivo pero las dos líneas de interés son call:c %s:~1,1% %s:~2,1% %s:~3,1% %s:~4,1% %s:~5,1% %s:~6,1%y 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

Pruébelo en línea aquí , o verifique todos los casos de prueba aquí .

+\#@<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 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]

Pruébalo en línea!


Bonito primer post. Como comentario aparte, ¡ pruébelo en línea! es un sitio opcional pero recomendado que ejecuta código para incluir en su respuesta. Puede generar publicaciones CG&CC y proporciona un recuento de bytes preciso para arrancar.
Veskah

Muy bien, gracias!
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

¿Alguien puede ayudarme a guardar algunos bytes? Todas las declaraciones si parecen que podrían acortarse en algo más corto, simplemente no sé qué.


1
Intente poner cada fragmento en una lista e indexación. Además, cambiar a Python 3 probablemente ahorrará bytes y list[len(list)-x]es lo mismo que list[-x].
CalculatorFeline

Si desea exprimir algunos bytes, considere convertir if t==1:a if t<2:(y if t==2:a if t<3:, etc.). Es menos legible, sin duda, ¡pero más compatible con el código de golf!
JL

0

TXR Lisp: 171 bytes

Sangrado:

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

Esta es una función anónima: la domacro genera un (lambda ...)formulario.

Es un estilo de codificación idiomático, adecuado para la producción; el único golf es el espacio en blanco:

(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 bytes

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

Pruébalo en línea!

Esto es efectivamente el equivalente de Braingolf de un caso de cambio en la cantidad de caracteres después #de la entrada.

Explicación

Cosas que siempre se ejecutan:

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

Este puede ser un poco golfa, podría mirarlo cuando llegue a casa

.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

Tienes la idea


0

Rubí , 127 bytes

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)

Pruébalo en línea!


0

Ruby , 118 bytes

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

Pruébalo en línea!


0

05AB1E , 24 bytes

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

Pruébelo en línea o verifique todos los casos de prueba .

Explicación:

ć           # 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)
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.