É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.

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

Perl, 125 117 bytes

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

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

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

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]

Vérification

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

BaseForm[31415, 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]

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>

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 ...

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

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

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("<  >");}

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 .

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

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