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!

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

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.