Schreiben Sie ein Programm oder eine Funktion, die bei einer positiven Ganzzahl als Eingabe die Darstellung dieser Ganzzahl in Mayazahlen ausgibt .

Maya-Ziffern

Maya-Ziffern sind ein Vigesimalsystem (Basis 20) mit nur 3 Symbolen:

• < >für Null (Das richtige Symbol ist eine Art Shell, die mit ASCII nicht einfach dargestellt werden kann).
• .für einen
• ----für fünf

Zahlen werden vertikal in Potenzen von 20 geschrieben, und Zahlen zwischen 0 und 19 werden als Stapel von fünf und eins geschrieben . Weitere Informationen finden Sie im Wikipedia-Artikel .

Als Beispiel hier sind die Zahlen zwischen 0 und 25, getrennt durch Kommas:

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

Eingänge

• Eingaben sind immer positive ganze Zahlen zwischen 0 und 2147483647 (2 ^ 31 - 1).
• Sie können die Eingabe von STDIN als Befehlszeilenargument, Funktionsparameter oder ähnliches verwenden.

Ausgänge

• Jede Zeile ist maximal 4 Zeichen lang. < >und ----sollte immer wie hier angegeben gedruckt werden (jeweils 4 Zeichen lang).
• Ein ( .) muss in der Linie zentriert sein. Wenn es 1 oder 3 .gibt, spielt es keine Rolle, ob es sich um eine Spalte links oder eine Spalte rechts oder eine Spalte in der Mitte handelt, da eine perfekte horizontale Ausrichtung nicht möglich ist.

• Es muss genau eine Leerzeile zwischen verschiedenen Potenzen von 20 stehen, unabhängig von der Höhe der Stapel in der Potenz von 20s. Die korrekte Ausgabe für 25 und 30 lautet beispielsweise:

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

• Keine führenden oder nachfolgenden Zeilen erlaubt.

• Die Ausgaben müssen genau so gedruckt werden, wie sie in den Beispielen angegeben sind.

Testfälle

• Jede einzelne Zahl zwischen 0 und 25 ist oben als Beispiel angegeben.

• Eingang: 42

Ausgabe:

 .. 

 .. 

• Eingang: 8000

Ausgabe:

 .  

<  >

<  >

<  >

• Eingang: 8080

Ausgabe:

 .  

<  >

....

<  >

• Eingang: 123456789

Ausgabe:

 .  

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

 .  
----
----

 .. 
----
----

 .  

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

....
----

• Eingang: 31415

Ausgabe:

... 

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

----
----

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

• Eingang: 2147483647

Ausgabe:

 .  

... 
----
----

 .  
----
----

 .  

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

....
----

 .. 

 .. 
----

Wertung

Das ist Code-Golf , also gewinnt der kürzeste Code in Bytes.

Pyth, 41 Bytes

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

Probieren Sie es online aus: Demonstration

Erläuterung:

                                     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

Vielen Dank an Dom Hastings, der mir geholfen hat, 8 Bytes zu sparen.

JavaScript ES6, 143 Bytes

Jede Menge Bytes hinzugefügt, da console.logweitere 23 Bytes gespeichert werden müssten .

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

Mit 18 Bytes, die dank des Vorschlags von Arcinde zur Verwendung anonymer Funktionen eingespart wurden,

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

Beispiel

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

Überprüfung

Die Dezimalzahl 31415, ausgedrückt in Basis 20. Mathematica verwendet hierfür Kleinbuchstaben.

BaseForm[31415, 20]

Die Dezimalstellen entsprechen der obigen Zahl zur Basis 20.

IntegerDigits[31415,20]

{3, 18, 10, 15}

Ein anderes Beispiel

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 Byte

Die Zeilenumbrüche sind signifikant und werden jeweils als 1 Byte gezählt. Da das Drucken auf STDOUT erforderlich ist, console.logkosten mich dort ein paar Bytes.

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

Demo

Zu Demonstrationszwecken schreibe ich eine ES5-Version, damit sie in allen Browsern funktioniert:

// 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 Bytes:

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]

Beispiel:

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

<  >

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

Edit: abschließende Zeile ...

CJam, 82 76 Bytes

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

Mein erstes CJam-Programm, im Grunde nur eine Transliteration meiner Perl-Antwort auf CJam.

Versuchen Sie es online

Mehrzeilig mit Kommentaren:

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 Bytes

Gleicher Ansatz wie meine JavaScript-Antwort. PHP hat für alles eingebaute Funktionen.

Nimmt 1 Eingabe von der Befehlszeile (dh STDIN) auf, wie mit $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("<  >");}

Verwendet die Rekursion, um die wichtigsten Zahlen zuerst zu drucken. Dann druckt entweder Null oder druckt alle Punkte mit einem cleveren printf und allen fünf Punkten in einer Schleife. Ich bin mir nicht sicher, ob ich es vermeiden kann, if-else hier zu verwenden.

Der Nachteil von clever printf ist, dass 1 und 3 nicht miteinander ausgerichtet sind:

Ergebnis für 23 ist:

  .

...

119 falsche lösung - nachgestellte newline

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 Bytes

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

Es erhält die Eingabe vom ersten Befehlszeilenargument.

Der vollständige Quellcode mit Kommentaren und Tests ist auf github verfügbar .

Python 2, 114 Bytes

Diese Antwort basiert auf der Pyth-Antwort von Jakube und der Python-2-Antwort von 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

Jelly , 50 49 47 Bytes

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

Probieren Sie es online!

... ist jetzt dank user202729s Punkt linksbündig ausgerichtet.

_{Wenn Sie sich zum Denken < >verleiten, ist das ein Palindrom ...}