Dessiner la phase de la lune

20

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.
code-golf  ascii-art 
— HyperNeutrino
source
5
— Martin Ender
"bien que cela ne fasse aucune différence" - m'a sauvé un octet (j'espère avoir bien compris) :)
— Jonathan Allan
1
Faut-il que ce soit de l'art ASCII? MoonPhase["Icon"]est de 17 octets dans Mathematica…
— Pas un arbre
@JonathanAllan Oh gentil. Eh bien, cela pourrait faire une différence: P
— HyperNeutrino
@ lanlock4 Vous avez indiqué l'une des raisons pour lesquelles j'ai créé l'art ASCII. Oui, cela doit être de l'art ASCII.
— HyperNeutrino

Réponses:

7

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
— Jonathan Allan
source
3
ce n'est pas une langue, c'est du bruit de modem ...
— Alnitak
@Alnitak Bienvenue chez PPCG! Avez-vous rejoint ce PPCG.SE juste pour pouvoir faire ce commentaire? ;)
— HyperNeutrino
8

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

Afficher l'extrait de code

— Arnauld
source
Aw, je voulais essayer ça à midi. Je doute que je t'aurais battu.
— Shaggy
4

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.

— faubi
source
3

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 :)

— musicman523
source
if i>2:y=16-ypourrait être changé en y=[16-y,y][i>2], ce qui est plus long, mais avec une utilisation libérale des points-virgules, cela permettrait à votre boucle d'être une ligne pour économiser plusieurs octets.
— Mego
1

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

— Pas un arbre
source
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.