Esse desafio é um desafio simples da arte ASCII inspirado no eclipse solar que ocorreu em 21 de agosto de 2017. Dada a entrada 0 <= n <= 4, faça a saída do estágio correspondente do eclipse descrito abaixo:

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

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

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

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

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

Regras

• Você pode 0 ou 1 índice, indicar o que você escolheu.
• Os caracteres usados ​​são espaço e *, você pode usar qualquer caractere imprimível para *(que não seja espaço).
• Os espaços à direita são opcionais (você pode ou não tê-los).
• Este é o código-golfe , o menor número de bytes é o vencedor.

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

Experimente online!

-7 Obrigado ao Sr. Xcoder .

Carvão , 82 81 55 43 bytes

-38 bytes graças a Neil!

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

Experimente online! Link é a versão detalhada.

Eu fiz para o diabo. : P Provavelmente ficarei fora do golfe por 40 bytes. 26 38 bytes ... Perto o suficiente?

Goma 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(...

Experimente online!

Estou esperando há tanto tempo para descobrir como usar esse idioma. : P

Portanto, o chiclete de canela é chiclete, mas é mais uma linguagem "real" que o chiclete.

O primeiro byte ( l) define o modo para o modo de dicionário. O restante dos bytes é a seguinte sequência compactada.

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

Isso cria essencialmente uma tabela de pesquisa com cada texto atribuído a um número. O programa, em seguida, recebe e envia o respectivo texto.

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: salvou 1 byte graças a @darrylyeo.

SOGL V0.12 , 40 39 bytes

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

Experimente aqui!

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>é o Enteracidente vascular cerebral, <C-?>corresponde a Control + ?, e <Esc>para Escape, obviamente. Cada um deles conta com 1 byte (consulte meta ). A quebra de linha na solução é para facilitar a leitura. <CR>Representa apenas Entertraços reais .

Entrada

O arquivo de entrada deve conter apenas 1 caractere, representando n.

Lançamento

VI deve ser iniciado como:

vi -u NONE input

Explicações

Existem 3 partes na solução. Descreverei a 2ª parte primeiro (2ª linha), pois é a mais fácil de explicar.

Desenhando o sol

O comando para desenhar o sol é:

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

O sol deve ser desenhado com , *, 0, 1e 3, como este:

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

Uma simetria teria ajudado a reduzir o tamanho dos bytes desta parte, mas não é tão importante. Não explicarei a linha completa, mas o padrão *****é usado para gerar facilmente a última linha, e o padrão **1110333**foi tomado como referência para gerar as outras 3 linhas que contêm 0, 1e 3.

É importante usar 0, 1e 3para peças de sol que podem ser preenchidos (veja a próxima explicações). Desenhar este sol leva 55 bytes e provavelmente pode ser jogado com alguns truques.

Enchendo o sol de acordo com n

Para preencher corretamente o sol, as instruções a seguir são:

• se n = 0, então 0, 1e 3(todos os dígitos) devem ser substituídos por
• se n = 1, então 1, for substituído por , os outros dígitos com*
• se n = 2, então 0, 1e 3(todos os dígitos) devem ser substituídos por*
• se n = 3, então 3, for substituído por , os outros dígitos com*
• se n = 4, então 0, 1e 3(todos os dígitos) devem ser substituídos por (como n = 0)

A partir disso, podemos inferir que as substituições necessárias são:

• substituir alguns dígitos por ( primeira substituição )
• substitua todos os outros dígitos por *( segunda substituição )

Observe que "alguns dígitos" pode significar "sem dígitos" ( n = 2por exemplo). E "todos os outros dígitos" também podem representar "sem dígitos", se todos os dígitos já tiverem sido substituídos pela primeira substituição ( n = 0por exemplo).

A segunda substituição pode ser escrita facilmente em 11 bytes :

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

A primeira substituição depende n, então primeiro temos que calcular quais dígitos serão substituídos. Se os caracteres substituídos estiverem armazenados no registro a, o comando de substituição também será gravado em 11 bytes :

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

<C-r>aé substituído pelo conteúdo do registro aquando o comando é digitado.

Para calcular o valor de a, seguindo as instruções anteriores, o algoritmo é (em pseudo-código):

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

"X"string é usada porque quando n = 2, nenhum dígito é substituído por espaços. Qualquer string que não seja o sol pode ser usada aqui, desde que a primeira substituição não faça nada.

Isso pode ser escrito em 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

Solução

Coloque todas essas peças na ordem certa e você terá a solução:

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. Obrigado @ Neil pela dica de mudança.

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

usa sublinhado para *, indexado a 0. Execute como pipe -nRou experimente online .

Requer PHP 5.5 ou posterior: o
PHP antigo não entende a indexação literal de strings (erro de análise);
O PHP 7.1 reclama de valores não numéricos (substitua +$cpor$c>0 para corrigir).

Python 2 , 170 169 bytes

• -1 byte graças a @TheIOSCoder: use of 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

Experimente online!

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]

Experimente online!

Abordagem muito ingênua, trabalhando no golfe .

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  *******";}

Experimente aqui.

05AB1E , 46 bytes

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

Experimente online!