Desafío

Dada la fase de la luna, dibuje usando el arte ASCII.

Su programa debe manejar luna nueva, luna creciente, primer trimestre, gibosa creciente, luna llena, gibosa menguante, último cuarto y media luna menguante. Su entrada será un número entero.

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

El arte ASCII se coloca en una cuadrícula de 16x8 (debido a las proporciones de dimensión de caracteres). Puede reemplazar .con cualquier carácter y #con cualquier otro carácter que no sea un espacio en blanco.

La salida para luna nueva debe ser:

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

Para la depilación creciente:

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

Para el primer trimestre:

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

Para la depilación gibosa:

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

Y para luna llena:

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

La media luna menguante es solo la media luna creciente con cada línea invertida, como con la gibosa menguante y la gibosa creciente, y el primer y último cuarto.

Reglas

• Se aplican lagunas estándar
• Si lo desea, puede optar por aumentar / disminuir en la dirección opuesta, aunque no debería hacer ninguna diferencia (los gráficos que se muestran en esta pregunta son para el hemisferio norte)
• Su salida debe ser exactamente como se especifica. Sus líneas nuevas pueden ser cualquier separador de línea razonable, y puede tener una línea nueva posterior si lo desea.

Jalea ,  43 32 bytes

-7 bytes pasando de máscara de bits a máscara de comparación
-2 bytes con algunas mejoras de programación tácitas
-1 byte moviéndose al hemisferio sur
-1 byte - use el nuevo ɓseparador de cadena ... ¡su primer uso!

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

Utiliza los caracteres 0para .y 1para #.

Todos los casos en un conjunto de pruebas en Pruébelo en línea.

¿Cómo?

Crea una máscara que captura las primeras cuatro fases y, en lugar de invertir las líneas, complementa los valores resultantes del resultado de la fase módulo 4 cuando la fase div-4 no es cero.

Originalmente construido una máscara de bits, pero los valores de máscara eran 0, 8, 12, y 14- 0000, 1000, 1100, y 1110- estos tienen phaseque llevan la delantera - lo que una comparación máscara podría ser utilizado en su lugar.

“>,##‘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]:''

Manifestación

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

Recorre las filas y columnas usando la mónada de la lista (un dobloque para las filas y una comprensión de la lista para las columnas) y determina qué carácter para cada celda usando una expresión de la entrada ( i), el valor de desplazamiento para la fila ( a) y el índice de la columna ( x)

Ahorró 8 bytes al simplificar la subexpresión para el desplazamiento verdadero

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

Pruébalo en línea!

Definitivamente se puede jugar más golf, se agradecen los consejos :)

Golfed 1 byte gracias al metro subterráneo!

Golfé muchos bytes gracias a Ovi y Mego porque soy un tonto que se olvida de no usar 4 espacios para 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])."
";

Pruébalo en línea!

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

Devuelve una cuadrícula usando 1y en 0lugar de .y #respectivamente.

Funciona usando dos máscaras, una circular y una media sombra, y combinándolas lógicamente para obtener las formas apropiadas.

Las dos máscaras están hechas 1-{3.4,5}~DiskMatrix~{8,16}para la circular y Table[Boole[i>8],8,{i,16}]para la media. La logica es como sigue:

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 lógica se simula con 1sy 0s mediante el uso de la multiplicación por ANDy x -> 1-xpara NOT.

Una solución extra (no ASCII), para 28 bytes: IconData["MoonPhase",#/4-1]&