Desafio

Dada a fase da lua, desenhe-a usando arte ASCII.

O seu programa deve lidar com lua nova, crescente crescente, primeiro trimestre, crescente crescente, lua cheia, crescente crescente, último trimestre e crescente crescente. Sua entrada será um número inteiro.

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

A arte ASCII é toda colocada em uma grade 16x8 (devido à proporção da dimensão dos caracteres). Você pode substituir .por qualquer caractere e #por qualquer outro caractere que não seja um espaço em branco.

A saída para lua nova deve ser:

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

Para encerar crescente:

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

No primeiro trimestre:

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

Para encerar gibbous:

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

E para lua cheia:

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

O crescente crescente é apenas o crescente crescente, com cada linha invertida, assim como o gibbous minguante e o gibbous crescente, e o primeiro e o último trimestre.

Regras

• As brechas padrão se aplicam
• Você pode escolher encerar / diminuir na direção oposta, se desejar, embora isso não faça diferença (os gráficos mostrados nesta pergunta são para o hemisfério norte)
• Sua saída deve ser exatamente como especificado. Suas novas linhas podem ser qualquer separador de linha razoável e você pode ter uma nova linha à direita, se desejar.

Geléia ,  43 32 bytes

-7 bytes movendo-se da máscara de bits para a máscara de comparação
-2 bytes com algumas melhorias de programação tácita
-1 byte movendo-se para o hemisfério sul
-1 byte - use o novo ɓseparador de correntes ... seu primeiro uso!

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

Usa os caracteres 0para .e 1para #.

Todos os casos em um conjunto de testes em Experimente online!

Quão?

Constrói uma máscara capturando as quatro primeiras fases e, em vez de reverter as linhas, complementa os valores resultantes do resultado da fase do módulo-4 quando a fase div-4 é diferente de zero.

I originalmente construído uma máscara de bits, mas os valores de máscara foram 0, 8, 12, e 14- 0000, 1000, 1100e 1110- estes têm phaseos líderes - uma comparação-máscara pode ser usada.

“>,##‘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 bytes

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

Demo

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 bytes

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

Ele percorre as linhas e colunas usando a mônada da lista (um dobloco para linhas e uma compreensão da lista para colunas) e determina qual caractere para cada célula usando uma expressão da entrada ( i), valor de deslocamento da linha ( a) e índice da coluna ( x)

Economizou 8 bytes simplificando a subexpressão para o deslocamento verdadeiro.

Python 2 , 144 142 127 bytes

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

Experimente online!

Definitivamente pode ser jogado ainda mais, as dicas são apreciadas :)

Golpeou 1 byte graças ao undergroundmonorail!

Joguei muitos bytes graças ao ovi e Mego porque sou um tolo que esquece de não usar 4 espaços para o codegolf :)

PHP, 105 bytes

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

Experimente online!

Mathematica, 125 bytes

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]]&

Retorna uma grade usando 1e em 0vez de .e #respectivamente.

Ele funciona usando duas máscaras, uma circular e outra meio sombreada e combinando-as logicamente para obter as formas apropriadas.

As duas máscaras são feitas com 1-{3.4,5}~DiskMatrix~{8,16}a circular e Table[Boole[i>8],8,{i,16}]a metade. A lógica é a seguinte:

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  ○  ◨

A lógica é simulada com 1s e 0s usando multiplicação para ANDe x -> 1-xpara NOT.

Uma solução de bônus (não ASCII), para 28 bytes: IconData["MoonPhase",#/4-1]&