Questa sfida è una semplice sfida di arte ASCII ispirata all'eclissi solare avvenuta il 21 agosto 2017. Dato un input 0 <= n <= 4, emette lo stadio corrispondente dell'eclissi descritto di seguito:

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

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

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

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

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

Regole

• Puoi 0 o 1 indicizzare, dichiarare ciò che hai scelto.
• I caratteri utilizzati sono spazio e *, è possibile utilizzare qualsiasi carattere stampabile per* (diverso dallo spazio).
• Gli spazi finali sono facoltativi (potresti o meno averli).
• Questo è code-golf , il conteggio di byte più basso è il vincitore.

Python 2 , 161 149 142 135 byte

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

Provalo online!

-7 grazie a Mr. Xcoder .

Carbone , 82 81 55 43 byte

-38 byte grazie a Neil!

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

Provalo online! Il collegamento è alla versione dettagliata.

L'ho fatto per diamine. : P Probabilmente uscirò a golf di 40 byte. 26 38 byte ... Abbastanza vicino?

Gomma Di Cannella , 70 byte

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

Provalo online!

Ho aspettato così tanto tempo per scoprire come usare questa lingua. : P

Quindi, Cinnamon Gum è Bubblegum, ma è più un linguaggio "reale" che Bubblegum.

Il primo byte ( l) imposta la modalità sulla modalità dizionario. Il resto dei byte è la seguente stringa compressa.

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

Questo essenzialmente crea una tabella di ricerca con ogni testo assegnato a un numero. Il programma accetta quindi input e genera il rispettivo testo.

JavaScript (ES6), 103 102 byte

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>

Modifica: salvato 1 byte grazie a @darrylyeo.

SOGL V0.12 , 40 39 byte

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

Provalo qui!

VI, 108 byte

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>è l' Enterictus, <C-?>corrisponde Control + ?, e <Esc>di Escapeovviamente. Ognuno di questi conta per 1 byte (vedi meta ). Le interruzioni di riga nella soluzione sono leggibili. <CR>Rappresenta solo Entertratti reali .

Ingresso

Il file di input deve contenere solo 1 carattere, che rappresenta n.

Lanciare

VI dovrebbe essere avviato come:

vi -u NONE input

spiegazioni

Ci sono 3 parti nella soluzione. Descriverò prima la seconda parte (seconda riga), poiché è la più semplice da spiegare.

Disegnare il sole

Il comando per disegnare il sole è:

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

Il sole deve essere disegnato con ,* , 0, 1e 3, in questo modo:

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

Una simmetria avrebbe contribuito a ridurre la dimensione dei byte di questa parte, ma non è così importante. Non spiegherò la linea completa, ma lo schema***** viene utilizzato per generare facilmente l'ultima riga e il pattern **1110333**è stato preso come riferimento per generare le altre 3 righe contenenti 0, 1e 3.

È importante da usare 0 , 1e 3per le parti del sole che possono essere riempiti (vedi il prossimo spiegazioni). Disegnare questo sole richiede 55 byte e probabilmente può essere giocato a golf con alcuni trucchi.

Riempiendo il sole secondo n

Per riempire correttamente il sole, le istruzioni da seguire sono:

• se n = 0, quindi 0,1e3 (tutte le cifre) devono essere sostituiti con
• se n = 1, quindi 1dovrebbe essere sostituito con , le altre cifre con*
• se n = 2, quindi 0, 1e3 (tutte le cifre) devono essere sostituiti con*
• se n = 3, quindi 3dovrebbe essere sostituito con , le altre cifre con*
• se n = 4, quindi 0, 1e 3(tutte le cifre) devono essere sostituiti con (comen = 0 )

Da ciò, possiamo dedurre che le sostituzioni richieste sono:

• sostituire alcune cifre con ( prima sostituzione )
• sostituire tutte le altre cifre con *( seconda sostituzione )

Nota che "alcune cifre" può significare "nessuna cifra" ( n = 2ad esempio). E "tutte le altre cifre" può anche rappresentare "nessuna cifra", se tutte le cifre sono già state sostituite dalla prima sostituzione ( n = 0ad esempio).

La seconda sostituzione può essere facilmente scritta in 11 byte :

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

La prima sostituzione dipende n, quindi prima dobbiamo calcolare quali cifre verranno sostituite. Se i caratteri sostituiti sono memorizzati nel registro a, il comando di sostituzione è scritto anche in 11 byte :

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

<C-r>aviene sostituito dal contenuto del registro aquando viene digitato il comando.

Per calcolare il valore di a, seguendo le precedenti istruzioni, l'algoritmo è (in pseudo-codice):

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

"X"stringa viene utilizzata perché quando n = 2, nessuna cifra viene sostituita da spazi. Qualsiasi stringa che non sia il sole potrebbe essere usata qui, purché la prima sostituzione non faccia nulla.

Questo potrebbe essere scritto in 31 byte :

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

Soluzione

Metti tutte queste parti nell'ordine giusto e avrai la soluzione:

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 byte

+1 byte per -R. Grazie @Neil per il suggerimento mobile.

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

usa il trattino basso per *, indicizzato 0. Esegui come pipe -nRo provalo online .

Richiede PHP 5.5 o versioni successive:
PHP precedente non comprende l'indicizzazione letterale delle stringhe (errore di analisi);
PHP 7.1 si lamenta di valori non numerici (sostituisci +$ccon $c>0per correggere).

Python 2 , 170 169 byte

• -1 byte grazie a @TheIOSCoder: utilizzo di 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

Provalo online!

Python 2 , 181 byte

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]

Provalo online!

Approccio molto ingenuo, lavorando sul golf nvm.

Java 8, 225 213 211 byte

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

Provalo qui.

05AB1E , 46 byte

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

Provalo online!