ASCII Maya Numbers

21

Écrivez un programme ou une fonction qui, étant donné un entier positif en entrée, sort la représentation de cet entier en chiffres mayas .

Chiffres mayas

Les chiffres mayas sont un système vigésimal (base 20) utilisant seulement 3 symboles:

  • < >pour Zero (le symbole correct est une sorte de shell qui ne peut pas être facilement représenté en utilisant ASCII).
  • .pour un
  • ----pour cinq

Les nombres sont écrits verticalement en puissances de 20, et les nombres entre 0 et 19 sont écrits comme des piles de cinq et de uns . Vous devez vous référer à l'article Wikipedia pour plus de détails.

À titre d'exemple, voici les nombres compris entre 0 et 25, séparés par des virgules:

                                                                                 .    ..  ...  ....
                                                        .    ..  ...  .... ---- ---- ---- ---- ----  .    .    .    .    .    .
                               .    ..  ...  .... ---- ---- ---- ---- ---- ---- ---- ---- ---- ----
<  >, .  , .. ,... ,....,----,----,----,----,----,----,----,----,----,----,----,----,----,----,----,<  >, .  , .. ,... ,....,----

Contributions

  • Les entrées sont toujours des entiers positifs compris entre 0 et 2147483647 (2 ^ 31 - 1).
  • Vous pouvez prendre l'entrée de STDIN, comme argument de ligne de commande, paramètre de fonction ou quelque chose de similaire.

Les sorties

  • Chaque ligne comporte au maximum 4 caractères. < >et ----doit toujours être imprimé comme indiqué ici (4 caractères chacun).
  • Les uns ( .) doivent être centrés sur la ligne. S'il y en a 1 ou 3 ., car un alignement horizontal parfait est impossible, peu importe qu'il s'agisse d'une colonne à gauche ou d'une colonne à droite ou au centre.

  • Il doit y avoir exactement une ligne vide entre différentes puissances de 20, quelle que soit la hauteur des piles dans la puissance de 20s. Par exemple, la sortie correcte pour 25 et 30 est:

            .
 .
       ----
----   ----

  • Aucune ligne avant ou arrière n'est autorisée.

  • Les sorties doivent être imprimées exactement comme dans les exemples donnés.

Cas de test

  • Chaque numéro individuel entre 0 et 25 donné comme exemple ci-dessus.

  • Contribution: 42

Sortie:

 .. 

 ..
  • Contribution: 8000

Sortie:

 .  

<  >

<  >

<  >
  • Contribution: 8080

Sortie:

 .  

<  >

....

<  >
  • contribution: 123456789

Sortie:

 .  

... 
----
----
----

 .  
----
----

 .. 
----
----

 .  

....
----
----
----

....
----
  • Contribution: 31415

Sortie:

... 

... 
----
----
----

----
----

----
----
----
  • Contribution: 2147483647

Sortie:

 .  

... 
----
----

 .  
----
----

 .  

----
----
----

....
----

 .. 

 .. 
----

Notation

Il s'agit de code-golf , donc le code le plus court en octets l'emporte.

code-golf  number  base-conversion 
— Fatalize
source
15 et 20 semblent identiques.
— isaacg
@isaacg Merci, j'avais en fait 15 apparaissant au bon endroit et aussi entre 19 et 20. Corrigé.
— Fatalize
@Fatalize La sortie doit-elle être imprimée (c.-à-d. STDOUT) ou ma fonction peut-elle simplement renvoyer la sortie?
— rink.attendant.6
@ rink.attendant.6 Doit être imprimé exactement comme dans la publication.
— Fatalize
Est-ce correct si 1 est une colonne à droite, mais 3 est une colonne à gauche?
— aragaer

Réponses:

3

Pyth, 41 octets

j+bbm|jb_m.[\ 4kc:*d\.*5\.*4\-4"<  >"jQ20

Essayez-le en ligne: Démonstration

Explication:

                                     jQ20   convert input to base 20
    m                                       map each value d to:
                  *d\.                         string of d points
                 :    *5\.*4\-                 replace 5 points by 4 -s
                c             4                split into groups of 4
         m.[\ 4k                               center each group
        _                                      invert order
      jb                                       join by newlines
     |                         "<  >"          or if 0 use "<  >"
j+bb                                        join by double newlines
— Jakube
source
5

Perl, 125 117 bytes

$-=<>;{$_=($-%20?(""," .
"," ..
","...
","....
")[$-%5]."----
"x($-/5&3):"<  >
").$_;($-/=20)&&($_=$/.$_,redo)}print

Merci à Dom Hastings de m'avoir aidé à économiser 8 octets.

— samgak
source
1
Hey samgak, quelques modifications de sauvegarde de plus d'octets, plutôt que redo,if(int($i/=20))vous ne pouvez les utiliser ~~($i/=20)&&redo. ~~convertit en int - vous pouvez également utiliser 0|au début (ou |0à la fin). Le remplacement substr(".... ... .. . ",20-$i%5*5,5)par (' .', ' ..','...','.'x4)[$i%5-1].$/semble fonctionner, mais je n'ai pas testé tous les cas de test ... Si ceux-ci fonctionnent, vous êtes à 114 ... Si je pense à autre chose à partager, je vous le ferai savoir!
— Dom Hastings
1
En y réfléchissant, si vous voulez seulement avoir un entier et ignorer le reste, vous pouvez utiliser la variable magique $-qui sera toujours tronquée en entier ... pourrait en sauver quelques autres!
— Dom Hastings
1
@DomHastings merci, l'astuce de conversion int enregistre quelques octets, et se débarrasser de substr en économise encore 4. Les sauts de ligne doivent aller à l'intérieur des constantes de chaîne car il ne doit pas y avoir de saut de ligne dans le cas où il n'y a pas de points.
— samgak
1
@DomHastings en effet, merci encore! Je suppose que cela signifie que je dois me débarrasser de ma blague de fin du monde
— samgak
4

JavaScript ES6, 143 octets

Des charges d'octets ajoutées car nécessaires console.log, pourraient économiser 23 octets supplémentaires sans elle.

n=>console.log((d=(x,s='',l=1,j=x/l|0)=>s+(j>19?d(x,s,l*20)+`

`:'')+((j=j%20)?(' '+`.`.repeat(j%5)).slice(-4)+`
----`.repeat(j/5):'<  >'))(n))
— George Reith
source
4

Mathematica 185 182 171 153

Avec 18 octets enregistrés grâce à la suggestion d'Arcinde d'utiliser des fonctions anonymes,

c=Column;c[If[#>0,{q,r}=#~QuotientRemainder~5;c@{{""," ."," .."," ...","...."}[[r+1]],c@{{""},{d="----"},{d,d},{d,d,d}}[[q+1]]},"< >"]&/@#~IntegerDigits~20]&

Exemple

c[If[# > 0, {q, r} = #~QuotientRemainder~5; c@{{"", " .", " ..", " ...", "...."}[[r + 1]], c@{{""}, {d = "----"}, {d, d}, {d, d, d}}[[q + 1]]}, "< >"] & /@ #~IntegerDigits~20] &[31415]

production

Vérification

Le nombre décimal, 31415, exprimé en base 20. Mathematica utilise pour cela des minuscules.

BaseForm[31415, 20]

base 20

Les chiffres décimaux correspondant au nombre de base 20 ci-dessus.

IntegerDigits[31415,20]

{3, 18, 10, 15}

Un autre exemple

IntegerDigits[2147483607, 20]

{1, 13, 11, 1, 15, 9, 0, 7}

c[If[# > 0, {q, r} = #~QuotientRemainder~5;c@{{"", " .", " ..", " ...","...."}[[r + 1]], c@{{""}, {d = "----"}, {d, d}, {d, d, d}}[[q + 1]]},"< >"] & /@ #~IntegerDigits~20] &[2147483607]

ex2

— DavidC
source
c=Column;c[If[#>0,{q,r}=#~QuotientRemainder~5;c@{{""," ."," .."," ...","...."}[[r+1]],c@{{""},{d="----"},{d,d},{d,d,d}}[[q+1]]},"< >"]&/@#~IntegerDigits~20]&en utilisant des fonctions anonymes.
— jcai
@Arcinde, merci. Bonnes vieilles fonctions anonymes.
— DavidC
3

JavaScript (ES6), 157 octets

Les sauts de ligne sont significatifs et comptent pour 1 octet chacun. Étant donné que l'impression sur STDOUT est requise, cela console.logm'a coûté quelques octets.

f=i=>console.log([...i.toString(20)].map(j=>(!(j=parseInt(j,20))||j%5?[`<  >`,` .`,` ..`,`...`,`....`][j%5]+`
`:'')+`----
`.repeat(j/5)).join`
`.slice(0,-1))

Démo

À des fins de démonstration, j'écrirai une version ES5 pour qu'elle fonctionne dans tous les navigateurs:

// Snippet stuff
console.log = function(x) {
  O.innerHTML = x;
}
document.getElementById('I').addEventListener('change', function() {
  f(this.valueAsNumber);
}, false);

// Actual function
f = function(i) {
  console.log(i.toString(20).split('').map(function(j) {
    return (! (j = parseInt(j, 20)) || j % 5 ? ['<  >', ' .', ' ..', '...', '....'][j % 5] + '\n' : '') + '----\n'.repeat(j / 5);
  }).join('\n').slice(0,-1));
}
<input type=number min=0 max=2147483647 value=0 id=I>

<pre><output id=O></output></pre>
Développer l'extrait

— rink.attendant.6
source
La dernière a-t-elle .joinbesoin de parenthèses?
— Downgoat
137 octets: pastebin.com/3Zgg4qtX
— Downgoat
@vihan Cela ne produit rien, il revient juste.
— rink.attendant.6
ne savait pas que c'était une exigence car l'entrée peut se faire via une fonction. pastebin.com/0pS0XtJa est 3 octets plus court
— Downgoat
2

Python 2.x, 142 octets:

def m(n):
 h=[[""," "*(2-n%5/2)+"."*(n%5)+"\n"][n%5!=0]+"----\n"*(n%20/5),"<  >\n"][n%20==0]
 n/=20
 if n>0:
  h=m(n)+"\n\n"+h
 return h[:-1]

Exemple:

>>> print m(2012)
----

<  >

 ..
----
----
>>>

Modifier: ligne de fuite ...

— Locoluis
source
J'ai quelques améliorations à suggérer. Commencez par passer [n%20==0]à [n%20<1]. Ensuite, passez [[""," "*(2-n%5/2)+"."*(n%5)+"\n"][n%5!=0]à h=[(" "*(2-a/2)+"."*a+"\n")*(a>0)+"----\n"*(n%20/5),"< >\n"][n%20<1]with a=n%5, qui déplace tous les n%5s et modifie le conditionnel *(a>0)auquel renvoie une chaîne vide à a==0pour le même effet.
— Sherlock9
Enfin, mettre a, het nsur une ligne, comme suit: a=n%5;h=[(" "*(2-a/2)+"."*a+"\n")*(a>0)+"----\n"*(n%20/5),"< >\n"][n%20<1];n/=20. Tout cela devrait vous laisser 131 octets.
— Sherlock9
2

CJam, 82 76 octets

li{_K%[""" .
"" ..
""...
""....
"]1$5%='-4*N+2$5/3&*+"<  >
"?N+L+:L;K/}h;L);

Mon premier programme CJam, essentiellement juste une translittération de ma réponse Perl à CJam.

Essayez en ligne

Multi-ligne avec commentaires:

li            # read input
{             # start of do-while loop
  _K%         # check if this base-20 digit is a zero
    [""" .
    "" ..
    ""...
    ""....
    "]1$5%=   # push dots for 1s onto stack
    '-4*N+2$5/3&*+    # push lines for 5s onto stack

    "<  >
    "         # push zero on stack
  ?           # ternary if test (for digit equals zero)
  N+L+:L;     # pre-concatenate string with output plus newline
  K/          # divide by 20
}h            # end of do while loop
;L);          # push output string on stack, chop off trailing newline
— samgak
source
1

PHP, 220 octets

Même approche que ma réponse JavaScript. PHP a des fonctions intégrées pour tout.

Prend 1 entrée de la ligne de commande (ie STDIN), comme vu avec $argv[1]:

<?=rtrim(implode("\n",array_map(function($j){return(!($j=base_convert($j,20,10))||$j%5?['<  >', ' .', ' ..', '...', '....'][$j%5]."\n":'').str_repeat("----\n",$j/5);},str_split(base_convert($argv[1],10,20)))));
— rink.attendant.6
source
1

C - 149

f(v){v/20&&(f(v/20),puts("\n"));if(v%=20)for(v%5&&printf("%3s%s","...."+4-v%5,v/5?"\n":""),v/=5;v--;v&&puts(""))printf("----");else printf("<  >");}

Utilise la récursivité pour imprimer d'abord les nombres les plus significatifs. Puis imprime zéro ou imprime tous les points avec un astucieux printf et tous les cinq en boucle. Je ne sais pas si je peux éviter d'utiliser if-else ici.

L'inconvénient de printf intelligent est que 1 et 3 ne sont pas alignés:

Le résultat pour 23 est:

  .

...

119 solution incorrecte - retour à la fin de la nouvelle ligne

f(v){v/20&&(f(v/20),puts(""));if(v%=20)for(v%5&&printf("%3s\n","...."+4-v%5),v/=5;v--;)puts("----");else puts("<  >");}
— aragaer
source
— Jonathan Frech
1

PHP, 202 192 octets

function m($n){return(($c=($n-($r=$n%20))/20)?m($c)."\n":"").
($r?(($q=$r%5)?substr(" .   .. ... ....",$q*4-4,4)."\n":"").
str_repeat("----\n",($r-$q)/5):"<  >\n");}
echo rtrim(m($argv[1]),"\n");

Il obtient l'entrée du premier argument de ligne de commande.

Le code source complet, avec commentaires et tests, est disponible sur github .

— axiaque
source
\nest deux caractères - mais une nouvelle ligne au milieu d'une chaîne n'en est qu'un.
— fisharebest
1

Python 2, 114 octets

Cette réponse est basée sur la réponse Python de Jakube et la réponse Python 2 de Locoluis.

def f(n):d,m=divmod(n%20,5);h=[" "*(2-m/2)+"."*m+"\n----"*d,"<  >"][n%20<1];n/=20;return(f(n)+"\n\n"if n else"")+h
— Sherlock9
source
0

Gelée , 50 49 47 octets

b5µṪ”.x⁶;$L<3Ɗ¡ṭ⁾--;UW¤ẋ$Ẏ$L¡Ṛø“<  >”WµẸ?
b20Ç€

Essayez-le en ligne!

... est maintenant aligné à gauche grâce au point de user202729.

Lorsque vous vous trompez en pensant < >est un palindrome ...

— dylnan
source
Pourquoi avez-vous ...
— aligné à
@ user202729 Pour .et ..il doit y avoir un espace donc j'en mets un ...aussi. Y a-t-il un moyen plus court?
— dylnan
Je pense que selon le défi, les spécifications ...ne doivent pas être alignées à droite. Changez simplement <4en <3?
— user202729
@ user202729 Vous avez raison, je pense avoir mal lu la spécification. Je ne pense pas que cela spécifie pour ... mais je peux le changer en <2
— dylnan
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.