Este desafío es un desafío de arte ASCII simple inspirado en el eclipse solar que ocurrió el 21 de agosto de 2017. Dada una entrada 0 <= n <= 4, salida de la etapa correspondiente del eclipse que se describe a continuación:

n=0:
   *****
 **     **
*         *
*         *
**       **
  *******

n=1:
   *****
 **  *****
*   *******
*   *******
**   ******
  *******

n=2:
   *****
 *********
***********
***********
***********
  *******

n=3:
   *****
 *****  **
*******   *
*******   *
******   **
  *******

n=4:
   *****
 **     **
*         *
*         *
**       **
  *******

Reglas

• Puede 0 o 1 índice, indicar lo que eligió.
• Los caracteres utilizados son espacio y *puede utilizar cualquier carácter imprimible para *(que no sea espacio).
• Los espacios finales son opcionales (puede que los tenga o no).
• Este es el código de golf , el conteo de bytes más bajo es el ganador.

Python 2 , 161 149 142 135 bytes

lambda n,u=u' *':u'''   *****
 ****
**
**
****
  *******'''.translate({1:u[0<n<3],2:u[0<n<4],3:u[1<n<4]})

Pruébalo en línea!

-7 gracias al Sr. Xcoder .

Carbón , 82 81 55 43 bytes

-38 bytes gracias a Neil!

Ｎν”{“⟲ＦEd⧴_³⟲”‖Ｏ¿﹪ν⁴«Ｆ﹪ν²Ｇ↗³↑²↖²↙³*↑¤*¿⁼ν¹‖

Pruébalo en línea! El enlace es a la versión detallada.

Lo hice por el gusto de hacerlo. : P Probablemente saldré de golf por 40 bytes. 26 38 bytes ... ¿Lo suficientemente cerca?

Chicle de canela , 70 bytes

Hexdump:

0000000: 6c33 5053 5050 d002 012e 20a5 0002 4026  l3PSPP.... ...@&
0000010: 9001 0568 6c20 07a6 0648 4080 b521 8a19  ...hl ...H@..!..
0000020: 30a6 1644 1093 0de3 a098 6184 6206 422d  0..D......a.b.B-
0000030: 6136 c20c 6374 3380 3cb8 5aa0 1436 36ba  a6..ct3.<.Z..66.
0000040: 5f4c 280f 0f00                           _L(...

Pruébalo en línea!

He esperado tanto tiempo para descubrir cómo usar este idioma. :PAGS

Entonces, Cinnamon Gum es Bubblegum, pero es más un lenguaje "real" que Bubblegum.

El primer byte ( l) establece el modo en modo diccionario. El resto de los bytes es la siguiente cadena comprimida.

0&   *****
 **     **
*         *
*         *
**       **
  *******;1&   *****
 **  *****
*   *******
*   *******
**   ******
  *******;2&   *****
 *********
***********
***********
***********
  *******;3&   *****
 *****  **
*******   *
*******   *
******   **
  *******;4&   *****
 **     **
*         *
*         *
**       **
  *******

Esto esencialmente hace una tabla de búsqueda con cada texto asignado a un número. El programa luego toma entrada y da salida al texto respectivo.

JavaScript (ES6), 103 102 bytes

f=
n=>`   *****
 **66733**${s=`
*666777333*`}${s}
**6667333**
  *******`.replace(/\d/g,c=>" *"[c*2>>n&1])

<input type=number min=0 max=4 oninput=o.textContent=f(this.value)><pre id=o>

Editar: guardado 1 byte gracias a @darrylyeo.

SOGL V0.12 , 40 39 bytes

"⁽Ρūa╔Ƨ ‘╥▓.4%?52"¹ο1¹‘╬¡╬5.H?:±}.2=?╬8

Pruébalo aquí!

VI, 108 bytes

D:let@a=@"%2?@":@"%4?"X":"\\d"<CR>
3i <Esc>5a*<Esc>Yphr*$a*<Esc>O**1110333**<Esc>YPi <Esc>3lx3lx"0px4lyl2p$xYp
:%s/<C-r>a/ /g<CR>
:%s/\d/*/g<CR>

<CR>es el Enteraccidente cerebrovascular, <C-?>corresponde a Control + ?, y <Esc>que Escapeobviamente. Cada uno de estos cuenta para 1 byte (ver meta ). Los saltos de línea en la solución son para facilitar la lectura. Solo <CR>representa Entertrazos reales .

Entrada

El archivo de entrada debe contener solo 1 carácter, que representa n.

Lanzamiento

VI debe comenzar como:

vi -u NONE input

Explicaciones

Hay 3 partes en la solución. Primero describiré la segunda parte (segunda línea), ya que es la más fácil de explicar.

Dibujando el sol

El comando para dibujar el sol es:

3i <Esc>5a*<Esc>Yphr*$a*<Esc>O**1110333**<Esc>YPi <Esc>3lx3lx"0px4lyl2p$xYp

El sol debe ser dibujado con , *, 0, 1y 3, de esta manera:

   *****
 **11033**
*111000333*
*111000333*
**1110333**
  *******

Una simetría habría ayudado a reducir el tamaño de bytes de esta parte, pero no es tan importante. No explicaré la línea completa, pero el patrón *****se usa para generar fácilmente la última línea, y el patrón **1110333**se ha tomado como referencia para generar las otras 3 líneas que contienen 0, 1y3 .

Es importante usarlo 0, 1y 3para las partes solares que se pueden llenar (vea las siguientes explicaciones). Dibujar este sol toma 55 bytes , y probablemente se pueda jugar golf con algunos trucos.

Llenando el sol de acuerdo a n

Para llenar correctamente el sol, las instrucciones a seguir son:

• si n = 0, entonces 0, 1y 3(todos los dígitos) deben reemplazarse con
• si n = 1, entonces 1debe ser reemplazado con , los otros dígitos con*
• si n = 2, entonces 0, 1y 3(todos los dígitos) deben reemplazarse con*
• si n = 3, entonces 3debe ser reemplazado con , los otros dígitos con*
• si n = 4, entonces 0, 1y 3(todos los dígitos) deben reemplazarse con (like n = 0)

A partir de eso, podemos inferir que las sustituciones requeridas son:

• reemplazar algunos dígitos por ( primera sustitución )
• reemplazar todos los otros dígitos por *( segunda sustitución )

Tenga en cuenta que "algunos dígitos" pueden significar "sin dígitos" ( n = 2por ejemplo). Y "todos los demás dígitos" también pueden representar "sin dígitos", si todos los dígitos ya han sido reemplazados por la primera sustitución ( n = 0por ejemplo).

La segunda sustitución se puede escribir fácilmente en 11 bytes :

:%s/\d/*/g<CR>

La primera sustitución depende n, por lo que primero tenemos que calcular qué dígitos se van a reemplazar. Si los caracteres reemplazados se almacenan en el registro a, el comando de sustitución también se escribe en 11 bytes :

:%s/<C-r>a/ /g<CR>

<C-r>ase reemplaza por el contenido del registro acuando se escribe el comando.

Para calcular el valor de a, siguiendo las instrucciones anteriores, el algoritmo es (en pseudocódigo):

n := read()
if (n % 2 != 0)
then
    a := n
else
    if(n % 4 != 0)
    then
        a := "X"
    else
        a := "\d"

"X"La cadena se utiliza porque cuando n = 2no se reemplazan los dígitos por espacios. Aquí se puede usar cualquier cadena que no sea el sol, siempre que la primera sustitución no haga nada.

Esto podría escribirse en 31 bytes :

D                                   # yank and delete the first character of the file (n) to register "" (yank by default) : n = @"
 :let@a=                            # define register "a content
        @"%2                        # if (n % 2 != 0)
            ?                       # then
             @"                     #   n
               :                    # else
                @"%4                #   if (n % 4 != 0)
                    ?               #   then
                     "X"            #       "X"
                        :           #   else
                         "\\d"      #       "\\d"
                              <CR>  # calculate "a

Solución

Ponga todas estas partes en el orden correcto y tendrá la solución:

D:let@a=@"%2?@":@"%4?"X":"\\d"<CR>                                              # calculate the digits to replace with spaces
3i <Esc>5a*<Esc>Yphr*$a*<Esc>O**1110333**<Esc>YPi <Esc>3lx3lx"0px4lyl2p$xYp     # draw the sun with spaces, stars, 0, 1 and 3
:%s/<C-r>a/ /g<CR>                                                              # replace the pattern stored in register "a with spaces
:%s/\d/*/g<CR>                                                                  # replace the remaining digits with stars

PHP, 114 + 1 bytes

+1 byte para -R. Gracias @Neil por la indirecta cambiante.

for(;$c="   *****
 **66733**
*666777333*
*666777333*
**6667333**
  *******"[$i++];)echo+$c?" *"[$c*2>>$argn&1]:$c;

usa guión bajo para *, indexado a 0. Ejecutar como tubería -nRo probarlo en línea .

Requiere PHP 5.5 o posterior:
PHP anterior no comprende la indexación de cadenas literales (error de análisis);
PHP 7.1 se queja de valores no numéricos (reemplace +$ccon $c>0para arreglar).

Python 2 , 170 169 bytes

• -1 byte gracias a @TheIOSCoder: uso de exec

def f(x,k=0):exec'print"".join(ord(i)*" *"[j%2]for j,i in enumerate(["		","	","	!",""][x%4]))[11*k:][:11];k+=1;'*6

Pruébalo en línea!

Python 2 , 181 bytes

lambda n,s=' ',a='*':"""   *****
 **%s**
*%s*
*%s*
**%s**
  *******"""%[(s*5,s*9,s*9,s*7),(s*2+a*3,s*3+a*6,s*3+a*6,s*3+a*4),(a*5,a*9,a*9,a*7),(a*3+s*2,a*6+s*3,a*6+s*3,a*4+s*3)][n%4]

Pruébalo en línea!

Enfoque muy ingenuo, trabajando en golfin ' nvm.

Java 8, 225 213 211 bytes

n->{String a=n<2|n>3?"   ":"***",b=n<1|n>2?"   ":"***",c=n%4<1?" ":"*",d=a+(n%4<1?"   ":"***")+b;return"   *****\n **"+(n<2|n>3?"  ":"**")+c+(n<1|n>2?"  ":"**")+"**\n*"+d+"*\n*"+d+"*\n**"+a+c+b+"**\n  *******";}

Pruébalo aquí

05AB1E , 46 bytes

„* •zÇRéóĀ—ÚÂÐoʒ<]ÜA›¶Ò¿H¶ ∞m•b3äûIèSèJ6äIií}»

Pruébalo en línea!