Sfida

Data la fase della luna, disegnala usando l'arte ASCII.

Il tuo programma deve gestire la luna nuova, l'inceratura della mezzaluna, il primo quarto, l'inceratura del gibboso, la luna piena, il gibboso calante, l'ultimo quarto e la mezzaluna calante. Il tuo input sarà un numero intero.

0 -> new moon
1 -> waxing crescent
2 -> first quarter
3 -> waxing gibbous
4 -> full moon
5 -> waning gibbous
6 -> last quarter
7 -> waning crescent

L'arte ASCII è tutta posizionata su una griglia 16x8 (perché rapporti di dimensione dei caratteri). È possibile sostituire .con qualsiasi carattere e #con qualsiasi altro carattere non bianco.

L'output per new moon dovrebbe essere:

................
................
................
................
................
................
................
................

Per ceretta a mezzaluna:

..........######
............####
.............###
.............###
.............###
.............###
............####
..........######

Per il primo trimestre:

........########
........########
........########
........########
........########
........########
........########
........########

Per la ceretta gibbosa:

......##########
....############
...#############
...#############
...#############
...#############
....############
......##########

E per la luna piena:

################
################
################
################
################
################
################
################

La mezzaluna calante è solo la mezzaluna crescente con ogni linea invertita, come con il gibboso calante e il gibboso crescente e il primo e l'ultimo quarto.

Regole

• Si applicano scappatoie standard
• Se lo desideri, puoi scegliere di produrre l'inceratura / calata nella direzione opposta, anche se non dovrebbe fare alcuna differenza (la grafica mostrata in questa domanda è per l'emisfero nord)
• L'output deve essere esattamente come specificato. Le tue nuove righe possono essere un discreto separatore di riga e, se lo desideri, potresti avere una riga finale.

Gelatina ,  43 32 byte

-7 byte che si spostano dalla maschera di bit alla maschera di confronto
-2 byte con alcuni miglioramenti di programmazione tacita
-1 byte che si sposta nell'emisfero meridionale
-1 byte - usa il nuovissimo ɓseparatore di catene ... il suo primo utilizzo!

“>,##‘m0Dm€0ż@€4Ḷ¤Œṙɓ%4>C¹⁸:4¤?Y

Usa i personaggi 0per .e 1per #.

Tutti i casi in una suite di test su Provalo online!

Come?

Costruisce una maschera catturando le prime quattro fasi e invece di invertire le linee completa i valori risultanti del risultato della fase modulo-4 quando la fase div-4 è diversa da zero.

Originariamente ho costruito una maschera di bit, ma i valori della maschera erano 0, 8, 12, e 14- 0000, 1000, 1100, e 1110- questi hanno phasequelli che portano - in modo da un confronto-maschera potrebbe essere usato al posto.

“>,##‘m0Dm€0ż@€4Ḷ¤Œṙɓ%4>C¹⁸:4¤?Y - Main link 1: number phase
“>,##‘                           - code-page index literal [62,44,35,35]
      m0                         - reflect -> [62,44,35,35,35,35,44,62]
        D                        - decimalise -> [[6,2],[4,4],[3,5],[3,5],[3,5],[3,5],[4,4],[6,2]]
         m€0                     - reflect €ach -> [[6,2,2,6],[4,4,4,4],[3,5,5,3],[3,5,5,3],[3,5,5,3],[3,5,5,3],[4,4,4,4],[6,2,2,6]]
                 ¤               - nilad and link(s) as a nilad:
               4                 -   literal 4
                Ḷ                -   lowered range -> [0,1,2,3]
            ż@€                  - zip (reverse @rguments) for €ach -> [[[0,6],[1,2],[2,2],[3,6]],[[0,4],[1,4],[2,4],[3,4]],[[0,3],[1,5],[2,5],[3,3]],[[0,3],[1,5],[2,5],[3,3]],[[0,3],[1,5],[2,5],[3,3]],[[0,3],[1,5],[2,5],[3,3]],[[0,4],[1,4],[2,4],[3,4]],[[0,6],[1,2],[2,2],[3,6]]]
                  Œṙ             - run-length decode -> [[0,0,0,0,0,0,1,1,2,2,3,3,3,3,3,3],[0,0,0,0,1,1,1,1,2,2,2,2,3,3,3,3],[0,0,0,1,1,1,1,1,2,2,2,2,2,3,3,3],[0,0,0,1,1,1,1,1,2,2,2,2,2,3,3,3],[0,0,0,1,1,1,1,1,2,2,2,2,2,3,3,3],[0,0,0,1,1,1,1,1,2,2,2,2,2,3,3,3],[0,0,0,0,1,1,1,1,2,2,2,2,3,3,3,3],[0,0,0,0,0,0,1,1,2,2,3,3,3,3,3,3]]
                                    -   i.e.: 0000001122333333  -
                                              0000111122223333  - Marking out the separate
                                              0001111122222333  - regions as filled up by
                                              0001111122222333  - the phases of the moon in
                                              0001111122222333  - the southern hemisphere.
                                              0001111122222333  -
                                              0000111122223333  -
                                              0000001122333333  -
                    ɓ            - dyadic chain separation & swap arguments, call that m
                     %4          - phase mod 4
                       >         - greater than? (vectorises across m) 1 if so 0 if not
                              ?  - if:
                             ¤   -   nilad followed by link(s) as a nilad:
                          ⁸      -     link's left argument, phase
                           :4    -     integer divide by 4
                        C        - then: complement
                         ¹       - else: identity (do nothing)
                               Y - join with newlines
                                 - implicit print

JavaScript (ES6), 121 ... 103 92 byte

f=(n,i=128)=>i--?f(n,i)+(i%16?'':`
`)+'.#.'[i%16+4*n-~-'31000013'[n&1?i>>4:1]*~-(n&2)>>4]:''

dimostrazione

f=(n,i=128)=>i--?f(n,i)+(i%16?'':`
`)+'.#.'[i%16+4*n-~-'31000013'[n&1?i>>4:1]*~-(n&2)>>4]:''

o.innerHTML=f(0)

<input type="range" oninput="o.innerHTML=f(this.value)" value=0 min=0 max=7><pre id=o>

Haskell , 98 90 byte

f i=do{a<-[3,1,0,0,0,0,1,3];[".#."!!div(i*4+x+[0,a-1,0,1-a]!!mod i 4)16|x<-[0..15]]++"\n"}

Passa attraverso le righe e le colonne usando la monade list (un doblocco per le righe e una comprensione dell'elenco per le colonne) e determina quale carattere per ogni cella usando un'espressione dell'input ( i), il valore di offset per la riga ( a) e l'indice di colonna ( x).

Salvato 8 byte semplificando la sottoespressione per l'offset reale.

Python 2 , 144 142 127 byte

i=input()
a,b='#.'[::i/4*2-1]
i%=4
for x in range(8):y=(int(abs(x-3.5))or 1)+2;y=[y,16-y][i>2];y=[i*4,y][i%2];print(16-y)*a+b*y

Provalo online!

Può sicuramente essere ulteriormente giocato a golf, i suggerimenti sono apprezzati :)

Golfato fuori da 1 byte grazie a undergroundmonorail!

Giocato a golf molti byte grazie a ovi e Mego perché sono un pazzo che si dimentica di non usare 4 spazi per codegolf :)

PHP, 105 byte

for(;$i++<8;)echo($p=str_pad)($p("",[16,16-$b=_64333346[$i],8,$b][3&$a=$argn],_M[$a/4]),16,M_[$a/4])."
";

Provalo online!

Mathematica, 125 byte

s=Switch;Grid@If[1<#<6,#&,1-#&][s[m=#~Mod~4,0,0,2,1,_,1-{3.4,5}~DiskMatrix~{8,16}]s[m,1,h=Table[Boole[i>8],8,{i,16}],_,1-h]]&

Restituisce una griglia usando 1e 0anziché .e #rispettivamente.

Funziona usando due maschere, una circolare e una semi-ombreggiata, e logicamente combinandole per ottenere le forme appropriate.

Le due maschere sono realizzate con 1-{3.4,5}~DiskMatrix~{8,16}per quella circolare e Table[Boole[i>8],8,{i,16}]per la metà. La logica è la seguente:

output = f(a AND b)

where f, a and b are:

n | f    a  b
--+-----------
0 | NOT  F  ◨ 
1 | NOT  ○  ◧ 
2 | 1    T  ◨
3 | 1    ○  ◨
4 | 1    F  ◨ 
5 | 1    ○  ◧ 
6 | NOT  T  ◨ 
7 | NOT  ○  ◨

La logica viene simulata con 1s e 0s usando la moltiplicazione per ANDe x -> 1-xper NOT.

Una soluzione bonus (non ASCII), per 28 byte: IconData["MoonPhase",#/4-1]&