In ASCII-Agrippa-Nummern konvertieren

Herausforderung

Geben Sie eine natürliche Zahl in der ASCII-Form des Agrippa-Zahlensystems aus.

Beschreibung

Ich mag ungerade Alphabete und Zahlensysteme. Mein Lieblingszahlensystem ist eines von Heinrich Cornelius Agrippa . Es gibt eine prägnante Möglichkeit, Zahlen in den Bereich zu schreiben, in dem [0,9999]einzelne Ziffern wie folgt geschrieben werden:

Größere Zahlen sind kleiner als 10^4eine Kombination aus einzelnen Ziffern, werden jedoch wie folgt auf einer einzelnen zentralen Leiste gedreht / horizontal gespiegelt:

[0° mirrored, 10's  ] | [0°,            1's  ]
[180°,        1000's] | [180° mirrored, 100's]

Hier einige Beispiele:

Die ASCII-Äquivalente sind:

Ones:
  0  1  2  3  4  5  6  7  8  9
  |  |- |_ |\ |/ |~ || |^ |v |]
  |  |  |  |  |  |  |  |  |  |

Tens:
  0  1  2  3  4  5  6  7  8  9
  | -| _| /| \| ~| || ^| v| [|
  |  |  |  |  |  |  |  |  |  |

Hundreds:
  0  1  2  3  4  5  6  7  8  9
  |  |  |  |  |  |  |  |  |  |
  |  |_ |- |/ |\ |~ || |v |^ |]

Thousands:
  0  1  2  3  4  5  6  7  8  9
  |  |  |  |  |  |  |  |  |  |
  | _| -| \| /| ~| || v| ^| [|

 1510:  1511:  1471:  1486:  3421:
 -|     -|-    ^|-    v||    _|-
 _|~    _|~    _|\    -|\    \|\

Zahlen, die größer sind als, 9999werden in 4-stellige Abschnitte unterteilt (wobei führende Nullen hinzugefügt werden, um ein Vielfaches von vier zu erhalten), und jede wird konvertiert. Zum Beispiel:

314159: (0031 4159)
         /|-  ~|]
          |   /|_

Regeln

Ihre Antwort kann eine Funktion oder ein vollständiges Programm sein
Die Eingabe ist eine positive ganze Zahl
Einträge müssen Eingaben unterstützen 10^8
Jeder vierstellige Abschnitt besteht aus genau sechs Zeichen
Abschnitte von vier sind durch ein einzelnes Leerzeichen getrennt
Nachfolgende Zeilenumbrüche sind optional
Pro Zeile sind bis zu zwei Leerzeichen zulässig
Ich werde meine eigene Antwort nicht akzeptieren
Die Punktzahl ist in Bytes angegeben, die niedrigste Punktzahl gewinnt!

code-golf ascii-art kolmogorov-complexity

— Michael Klein
quelle

Entschuldigung, aber ich verstehe keines Ihrer Beispiele. Sie sind nicht einmal miteinander konsistent, geschweige denn die Grafiken.

— Neil

@Neil Ich fand, dass die 6er nicht konsistent waren, aber ich habe sie behoben. Gibt es noch etwas? Was meinst du mit "die Grafik"? Die ASCII-Kunst ist meine Interpretation der Grafiken, keine direkte Übersetzung jeglicher Art.

— Michael Klein

Ich meine, i.stack.imgur.com/2BUbM.gif zeigt deutlich, dass sich die Einheiten oben rechts und die Hunderte unten rechts befinden, aber Ihre Beispiele haben die Hunderte oben links und die Einheiten unten rechts.

— Neil

@ Neil Danke, dass du das verstanden hast. Habe ich noch etwas verpasst?

— Michael Klein

Ihr 1486 sieht für mich wie 2486 aus, aber ich stimme jetzt dem Rest zu.

— Neil

Antworten:

Haskell, 310 Bytes

Das Definieren reverse(wie ich es getan habe :) rist ein Byte kürzer als das Importieren Data.Listund Verwenden nur einmal
Definieren z=0:zund (!)=(!!).(++z)ist der kürzeste Weg, den ich bisher gefunden habe, 0um außerhalb der Grenzen zurückzukehren
Ich habe die take4sFunktion überprüft und schnell überprüft , aber es fühlt sich für mich immer noch magisch an

Hier ist der Code:

l=lines"    \n--__\n__--\n\\//\\\n/\\\\/\n~~~~\n||||\n^^vv\nvv^^\n][]["
d x|x<1=[]|1<2=mod x 10:d(div x 10)
(&)=(!!)
z=(0::Int):z
(!)=(&).(++z)
t a=[[a!q|q<-[p..p+3]]|p<-[0,4..length a-1]]
g[c,d,b,a]=[[l&b&1,'|',l&a&0,' '],[l&d&3,'|',l&c&2,' ']]
r[]=[]
r(x:y)=r y++[x]
f=unlines.foldl1(zipWith(++)).map g.r.t.d

Weniger Golf:

import Data.List (reverse)

dict = lines "    \n--__\n__--\n\\//\\\n/\\\\/\n~~~~\n||||\n^^vv\nvv^^\n][]["


-- Note that (digits x) returns the digits of x in little-endian order
digits x  | x < 1     = []
          | otherwise = mod x 10 : digits (div x 10)

-- Note: zeros needs the type signature, because otherwise it won't match [Int] (inferred from (!!))
zeros = (0::Int) : zeros

-- list ! position gives the element at the position, or 0 for out of bounds
(!) = (!!) . (++zeros)

-- This partitions the digits into groups of four, padded right
take4s a = [[a!q | q <-[p..p+3]] | p <- [0,4..length a - 1]]

convertOne[c,d,b,a] = [[dict !! b !! 1, '|', dict !! a !! 0, ' '], [dict !! d !! 3, '|', dict !! c !! 2, ' ']]

f = unlines . foldl1(zipWith (++)) . map convertOne . reverse . take4s . digits

Tests (Escapezeichen entfernt):

mapM_ print $ lines $ f 1510
-|  
_|~ 

mapM_ print $ lines $ f 1511
-|- 
_|~ 

mapM_ print $ lines $ f 1471
^|- 
_|\ 

mapM_ print $ lines $ f 1486
v|| 
_|\ 

mapM_ print $ lines $ f 3421
_|- 
\|\ 

mapM_ print $ lines $ f 1234567891011121314
_|\ ||^ -|  -|_ -|/ 
 |_ /|~ ^|] _|_ _|/ 

mapM_ print $ lines $ f 1024628340621757567
 |_ _|v  || ^|~ ||^ 
 |_ /|| \|\ -|_ v|~

— Michael Klein
quelle

Ich fragte mich, wie jemand eine Herausforderung so lange innerhalb einer Minute nach dem Posten beantworten konnte. Dann habe ich gesehen, dass du OP bist.

— Lirtosiast

JavaScript (ES6), 180 159 Byte

s=>`000${s}`.slice(-s.length&-4).replace(/..../g,([t,h,d,u])=>(r+=' _-\\/~|v^['[t]+`|${'_-/\\~|v^]'[h]} `,' -_/\\~|^v['[d]+`|${' -_\\/~|^v]'[u]} `),r='')+`\n`+r

Wobei \nein wörtliches Zeilenumbruchzeichen steht.

Bearbeiten: Aktualisiert für den Wechsel von ,'zu |. 14 Bytes wurden mit einem einzigen gespeichert, replaceum die gesamte Arbeit zu erledigen. Gespeichert 3 Bytes mit &-4anstelle von <<2>>2. 2 Bytes durch Missbrauch der Destrukturierungszuweisung gespeichert. 2 Bytes durch Missbrauch von Vorlagenzeichenfolgen gespeichert.

— Neil
quelle