Défi

Compte tenu de la phase de la lune, dessinez-la en utilisant l'art ASCII.

Votre programme doit gérer la nouvelle lune, le croissant croissant, le premier trimestre, le gibbeux croissant, la pleine lune, le gibbeux décroissant, le dernier trimestre et le croissant décroissant. Votre entrée sera un entier.

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'art ASCII est tout placé sur une grille 16x8 (parce que les ratios de dimension des caractères). Vous pouvez remplacer .par n'importe quel caractère et #par tout autre caractère non blanc.

La sortie pour la nouvelle lune devrait être:

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

Pour croître le croissant:

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

Pour le premier trimestre:

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

Pour épilation gibbeuse:

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

Et pour la pleine lune:

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

Le croissant décroissant est juste le croissant croissant avec chaque ligne inversée, comme avec le gibbeux décroissant et le gibbeux croissant, et le premier et le dernier trimestre.

Règles

• Les échappatoires standard s'appliquent
• Vous pouvez choisir de sortir l'épilation / décroissance dans le sens opposé si vous le souhaitez, bien que cela ne fasse aucune différence (les graphiques montrés dans cette question sont pour l'hémisphère nord)
• Votre sortie doit être exactement comme spécifié. Vos sauts de ligne peuvent être n'importe quel séparateur de ligne raisonnable, et vous pouvez avoir un saut de ligne de fin si vous le souhaitez.

Gelée ,  43 32 octets

-7 octets passant du masque de bits au masque de comparaison
-2 octets avec quelques améliorations de programmation tacites
-1 octet se déplaçant vers l'hémisphère sud
-1 octet - utilisez le tout nouveau ɓséparateur de chaîne ... sa toute première utilisation!

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

Utilise les caractères 0pour .et 1pour #.

Tous les cas dans une suite de tests sur Essayez-le en ligne!

Comment?

Construit un masque capturant les quatre premières phases, et plutôt que d'inverser les lignes, complète les valeurs résultantes du résultat de la phase modulo-4 lorsque la phase div-4 n'est pas nulle.

Je construit à l' origine un masque de bits, mais les valeurs de masque étaient 0, 8, 12et 14- 0000, 1000, 1100et 1110- ceux - ci ont plus phasegrands ceux - donc une comparaison masque pourrait être utilisé à la place.

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

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

Démo

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 octets

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

Il parcourt les lignes et les colonnes à l'aide de la liste monad (un dobloc pour les lignes et une compréhension de la liste pour les colonnes) et détermine quel caractère pour chaque cellule en utilisant une expression de l'entrée ( i), une valeur de décalage pour la ligne ( a) et un index de colonne ( x).

8 octets enregistrés en simplifiant la sous-expression pour le vrai décalage.

Python 2 , 144 142 127 127 octets

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

Essayez-le en ligne!

Peut certainement être joué plus loin, les conseils sont appréciés :)

Golfé 1 octet grâce au métro souterrain!

Golfé de nombreux octets grâce à ovi et Mego car je suis un imbécile qui oublie de ne pas utiliser 4 espaces pour codegolf :)

PHP, 105 octets

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

Essayez-le en ligne!

Mathematica, 125 octets

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

Renvoie une grille en utilisant 1et 0au lieu de .et #respectivement.

Il fonctionne en utilisant deux masques, un circulaire et un demi-ombré, et en les combinant logiquement pour obtenir les formes appropriées.

Les deux masques sont réalisés avec 1-{3.4,5}~DiskMatrix~{8,16}pour le circulaire, et Table[Boole[i>8],8,{i,16}]pour le demi. La logique est la suivante:

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 logique est simulée avec 1s et 0s en utilisant la multiplication pour ANDet x -> 1-xpour NOT.

Une solution bonus (non ASCII), pour 28 octets: IconData["MoonPhase",#/4-1]&