Schreiben Sie anhand einer Eingabezeichenfolge ein Programm, das die Gesamtzahl der Linien und Kurven ausgibt.

Die Herausforderung

• Nehmen Sie Eingaben von STDINoder eine andere Eingabemethode entgegen.
• Ausgabe an STDOUToder eine andere Ausgabemethode für die Gesamtzahl der in der Zeichenfolge enthaltenen Linien und Kurven in dieser Reihenfolge , basierend auf der folgenden Tabelle im Codeausschnitt.
• Nicht alphanumerische Zeichen sollten ignoriert werden.
• Standardlücken sind verboten.
• Dies ist Code-Golf , also gewinnt der kürzeste Code.

Klarstellungen

• Die Linien und Kurven werden durch die in Stackexchange für verwendete Schriftart bestimmt code blocks.
• Kreise (wie O, o, 0) und Punkte ( i, j) werden als jeweils 1 Kurve betrachtet.
• Die Eingabe kann eine Zeichenfolge, eine Liste von Zeichen, ein Strom von Zeichen, Bytecodes usw. sein.
• Die Ausgabe kann ein Array von ganzen Zahlen sein, Tupel von ganzen Zahlen, durch Kommas getrennte Zeichenfolge, usw. Die beiden Zahlen getrennt sein müssen, so 104ist nicht gültig, aber 10,4, 10 4, 10\n4, [10,4], (10, 4), und so weiter ist.
• Überschriften und nachfolgende Leerzeichen sind durchaus akzeptabel.

Sample Input und Output

# Format: str -> line, curve
hi -> 4, 2
HELLO WORLD -> 20, 4
l33+ 5pEak -> 13, 8
+=-_!...?~`g@#$%^ -> 1, 2
9001 -> 5, 3
O o O o O o -> 0, 6

Zeichentabelle

Char | Lines | Curves
0    | 1     | 1
1    | 3     | 0
2    | 1     | 1
3    | 0     | 2
4    | 3     | 0
5    | 2     | 1
6    | 0     | 1
7    | 2     | 0
8    | 0     | 2
9    | 0     | 1
A    | 3     | 0
B    | 1     | 2
C    | 0     | 1
D    | 1     | 1
E    | 4     | 0
F    | 3     | 0
G    | 2     | 1
H    | 3     | 0
I    | 3     | 0
J    | 1     | 1
K    | 3     | 0
L    | 2     | 0
M    | 4     | 0
N    | 3     | 0
O    | 0     | 1
P    | 1     | 1
Q    | 0     | 2
R    | 2     | 1
S    | 0     | 1
T    | 2     | 0
U    | 0     | 1
V    | 2     | 0
W    | 4     | 0
X    | 4     | 0
Y    | 3     | 0
Z    | 3     | 0
a    | 0     | 2
b    | 1     | 1
c    | 0     | 1
d    | 1     | 1
e    | 1     | 1
f    | 1     | 1
g    | 1     | 2
h    | 1     | 1
i    | 3     | 1
j    | 1     | 2
k    | 3     | 0
l    | 3     | 0
m    | 3     | 2
n    | 2     | 1
o    | 0     | 1
p    | 1     | 1
q    | 1     | 1
r    | 1     | 1
s    | 0     | 1
t    | 1     | 1
u    | 1     | 1
v    | 2     | 0
w    | 4     | 0
x    | 4     | 0
y    | 1     | 1
z    | 3     | 0

Haskell, 214 199 188 175 Bytes

 g 0=[]
 g n=mod n 5:g(div n 5)
 d#s=sum[n|c<-d,(i,n)<-zip['0'..]$g s,c==i]
 f s=(s#0x300BBD37F30B5C234DE4A308D077AC8EF7FB328355A6,s#0x2D5E73A8E3D345386593A829D63104FED5552D080CA)

Probieren Sie es online aus!

Die Anzahl der Linien und Kurven sind die Ziffern der Basis-5-Zahlen und werden als Basis-16-Zahlen gespeichert. Die Funktion wird gzurück zur Basis 5 übersetzt.

Bearbeiten: -13 Bytes dank @cole.

05AB1E , 78 69 65 Bytes

-4 Bytes danke an Kevin Cruijssen, Geh und schau dir seine noch bessere 05AB1E Antwort an

žKÃÇ48-©•7ć_qýÊΣŸßαŽ_ì¡vFÛ–ÄÔ™”súyån!₁ζB?òrβÂ@µk₆¼×¬°•5в2ä`®èrè‚O

Probieren Sie es online aus!

Ausgaben als [Kurve, Linie]

Ich bin wirklich schlecht bei 05AB1E. Ich habe es gerade herausgefunden. Kann definitiv mehr Bytes sparen, wenn ich 05AB1E in èmeiner Liste der Listen ausführen kann

Erläuterung

žKÃ                                    #Filter out non alpha-nums
    Ç48-                               #Convert to ascii and subtract 48 so "0" is 0 etc.
        ©                              #Store that for later
          •...•5в                      #De-compress compressed list 
                 2ä                    #Split into 2 chunks (lines + curves)
                   `                   #Separate them onto the stack 
                    ®                  #Get the value that we stored 
                     èrè               #Apply indexing to both lists
                        ‚              #Put our indexed values back into a list
                         O             #Sum our lists

Gelee , 45 Bytes

ØBċþSḋ“yƘ.ṪñF[)µṡṭɗḌyė$Ṫk“¢⁶KɱzV$QḂḥỵṙu’b5,3¤

Ein monadischer Link, der eine Liste von Zeichen akzeptiert, die eine Liste von (zwei) ganzen Zahlen ergibt.

Probieren Sie es online aus! Oder sehen Sie sich die Testsuite an .

Wie?

ØBċþSḋ“...“...’b5,3¤ - Link: list of characters, T
ØB                   - base-chars = "01...9A...Za...z'
   þ                 - outer product with T using:
  ċ                  -   count occurrences
    S                - sum -> [n(0), n(1), ..., n(9), n(A), ..., n(Z), n(a), ..., n(z)]'
                   ¤ - nilad followed by link(s) as a nilad:
      “...“...’      -   list of two large integers (encoded in base 250)
                5,3  -   five paired with three = [5,3]
               b     -   to base  -> [[Lines(0), Lines(1), ...], Curves(0), Curves(1), ...]
     ḋ               - dot-product

Scala , 235 Bytes

val a=('0'to'9')++('A'to'Z')++('a'to'z')
def f(s:String)=s.filter(a.contains(_)).map(c=>"gdgkdhfckfdlfgedhddgdcedfgkhfcfceeddkgfggglgilddnhfgggfggceegd"(a.indexOf(c))-'a').map(x=>(x%5,x/5)).foldLeft((0,0))((x,y)=>(x._1+y._1,x._2+y._2))

Probieren Sie es online aus!

Nicht so klein, kann wahrscheinlich weiter Golf gespielt werden.
Hinweis: Das Zeichenfolgenliteral mit 52 Zeichen ähnelt einem Wörterbuch, das ein Zeichen einem anderen Zeichen zuordnet, das die Anzahl der Linien und Kurven gemäß der folgenden Tabelle angibt:

Curves|Lines
      |0 1 2 3 4
----------------
     0|a b c d e
     1|f g h i j
     2|k l m n o

Python 2 , 159 154 Bytes

Für jedes Zeichen lines*4 + curveswird ein Wert von 0 bis 16 angegeben. Base-36 wird verwendet, um diese Werte zu codieren (1 Zeichen = 1 Wert).

-5 Bytes dank @Chas Brown

lambda s:map(sum,zip(*(divmod(int("5c52c918210000000c615gc9cc5c8gc15291818ggcc00000025155565d6cce915551558gg5c"[ord(x)-48],36),4)for x in s if'/'<x<'{')))

Probieren Sie es online aus!

Python 2 , 141 Bytes

Dies ist ein Port meiner Python3-Lösung. Diese Version gibt eine Liste mit langen Ints aus, also sieht es so aus wie [4L, 2L]statt [4, 2].

lambda s:map(sum,zip(*(divmod(int("8BK5NLC8RS10XWUX12BG408C2UELUAFEOVARZKCHEEDDMXG09L48ZG",36)/13**(ord(x)-48)%13,3)for x in s if'/'<x<'{')))

Probieren Sie es online aus!

Gelee , 51 Bytes

ØBiⱮị“Æƭ&¶*ṪḳAøƬsøD<~²ṂvṠỤṣT3rdʠ¬⁻ÇṆṇ.ÑƑaȮż’b5¤s2¤S

Probieren Sie es online aus!

Ein monadischer Link, der eine Zeichenfolge als Eingabe verwendet und eine Liste von Ganzzahlen als zurückgibt [lines, curves]

JavaScript (Node.js) , 251 219 217 Byte

-34 Bytes von @Expired Data : o

_=>_.map(a=>(p+=~~"13103202003101432331324301020202443301011111313332011101124413"[(x=a.charCodeAt()-48)>16?(x-=7)>41?x-=6:x:x])&(o+=~~"10120110210211001001000011211010000021111121120021111111100010"[x]),p=o=0)&&[p,o]

Probieren Sie es online aus!

Retina 0.8.2 , 160 Bytes

$
¶$`
T`dLl`13103202003101432331324301020202443301011111313332011101124413`^.*
T`dLl`10120110210211001001000011211010000021111121120021111111100010`.*$
.
$*
%`1

Probieren Sie es online aus!Link enthält Testfälle. Erläuterung:

$
¶$`

Duplizieren Sie die Eingabezeichenfolge.

T`dLl`13103202003101432331324301020202443301011111313332011101124413`^.*

Zählen Sie die Zeilen jedes Zeichens in der ersten Zeile.

T`dLl`10120110210211001001000011211010000021111121120021111111100010`.*$

Zählen Sie die Kurven jedes Zeichens in der zweiten Zeile.

.
$*
%`1

Summieren Sie die Ziffern in jeder Zeile separat.

R , 164 153 Bytes

function(s,`!`=utf8ToInt,x=(!"




")[match(!s,c(48:57,65:90,97:122),0)])c(sum(x%%5),sum(x%/%5))

Probieren Sie es online aus!

Ich hatte die gleiche Idee wie Nimis Antwort mit einer Base 5-Codierung, aber codiert als ASCII-Zeichen anstelle von Base 16. Verwendet nomatch = 0inmatch nicht-alphanumerische Zeichen zu beseitigen.

Rückgabe curves lines.

Holzkohle , 60 Bytes

ＩＥ⟦”)⊞∧cⅉ→ÞＹγμ◧⊞¶u№¶⊘¶∕«⁸””)∨⧴｜υ;↷dLτＩüＯ¦:”⟧Σ⭆Φθ№⭆ι⍘ξφλ§ι⍘λφ

Probieren Sie es online aus! Der Link führt zur ausführlichen Version des Codes. Erläuterung:

Ｅ⟦”)⊞∧cⅉ→ÞＹγμ◧⊞¶u№¶⊘¶∕«⁸””)∨⧴｜υ;↷dLτＩüＯ¦:”⟧

Dies ist ein Array aus zwei Zeichenfolgen 13103202000101111131333201110112441331014323313243010202024433und 10120110212111112112002111111110001002110010010000112110100000. Die Zeichenfolgen werden dann zugeordnet.

Φθ№⭆ι⍘ξφλ

Die Elemente der Eingabe werden darüber gefiltert, ob sie in den (62) Zeichen des Standard-Basiskonvertierungsalphabets enthalten sind.

⭆...§ι⍘λφ

Die verbleibenden Elemente werden dann von der Basis (62) konvertiert und diese werden dann in die zugeordnete Zeichenfolge indiziert.

Ｉ...Σ...

Die Ziffern werden summiert und für den impliziten Druck in eine Zeichenfolge zurückgesetzt.

Python 3 , 165 159 148 146 Bytes

Für jedes Zeichen (einschließlich nicht alphanumerischer Zeichen) lines*3 + curves wird ein Wert von 0 bis 12 angegeben, sodass wir zum Codieren von Daten eine lange Basis-13-Zahl verwenden können. Um es kürzer zu machen, wird es in Base-36 konvertiert.

Vielen Dank an @Chas Brown für tolle Ratschläge.

-2 Bytes durch Konvertieren von Lambda in Programm.

print(*map(sum,zip(*(divmod(int("8BK5NLC8RS10XWUX12BG408C2UELUAFEOVARZKCHEEDDMXG09L48ZG",36)//13**(ord(x)-48)%13,3)for x in input()if'/'<x<'{'))))

Probieren Sie es online aus!

Python 2 , 179 166 165 163 Bytes

lambda s:[sum(p[:max(0,p.find(c))].count(',')for c in s)for p in',02BDJPbdefghjpqrtuy,57GLRTVnv,14AFHIKNYZiklmz,EMWXwx',',02569CDGJOPRSUbcdefhinopqrstuy,38BQagjm']

Probieren Sie es online aus!

Gibt eine Liste zurück [curves, lines].

Python 2 , 525 Bytes

l=c=0;e=[(1,1),(3,0),(1,2),(0,2),(3,0),(2,1),(0,1),(2,0),(0,2),(0,1),(3,0),(1,2),(0,1),(1,1),(4,0),(3,0),(2,1),(3,0),(3,0),(1,1),(3,0),(2,0),(4,0),(3,0),(0,1),(1,1),(0,2),(2,1),(0,1),(2,0),(0,1),(2,0),(4,0),(4,0),(3,0),(3,0),(0,2),(1,1),(0,1),(1,1),(1,1),(1,1),(1,2),(1,1),(3,1),(1,2),(3,0),(3,0),(3,2),(2,1),(0,1),(1,1),(1,1),(1,1),(0,1),(1,1),(1,1),(2,0),(4,0),(4,0),(1,1),(3,0)]
d='0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz'
for i in input():
 if i in d:
  p=d.find(i);l+=e[p][0];c+=e[p][1];
print l,c

Probieren Sie es online aus!

Ähnlicher Ansatz zur Referenzimplementierung, jedoch etwas kürzer.

Perl 5 -MList::Util=sum -p , 180 Bytes

say sum y/0-9A-Za-z/13103202003101432331324301020202443301011111313332011101124413/r=~/./g;$_=sum y/0-9A-Za-z/10120110210211001001000011211010000021111121120021111111100010/r=~/./g

Probieren Sie es online aus!

05AB1E , 53 Bytes

•xþ¢*>ÌŸÑå#÷AUI'@æýXÁи<¥èå–ΘηžÎà₅åǚĕ5вR2ôžKISk®KèøO

Probieren Sie es online aus oder überprüfen Sie alle Testfälle .

Erläuterung:

•xþ¢*>ÌŸÑå#÷AUI'@æýXÁи<¥èå–ΘηžÎà₅åǚĕ
                 '# Compressed integer 101629259357674935528492544214548347273909568347978482331029666966024823518105773925160
 5в               # Converted to base-5 as list: [1,0,2,0,0,2,1,0,1,2,0,3,2,0,1,1,0,3,1,1,0,3,0,3,0,4,0,4,0,2,1,0,0,2,1,0,1,2,2,0,1,1,1,0,0,3,0,4,0,2,0,3,1,1,0,3,0,3,1,2,0,3,0,4,1,1,1,0,2,1,0,3,0,3,1,1,0,4,0,4,0,2,1,1,1,1,1,0,1,1,1,1,1,1,1,0,1,2,2,3,0,3,0,3,2,1,1,3,1,1,2,1,1,1,1,1,1,1,1,0,1,1,2,0]
   R              # Reverse this list (due to the leading 0)
    2ô            # Split it into pairs: [[0,2],[1,1],[0,1],[1,1],[1,1],[1,1],[1,2],[1,1],[3,1],[1,2],[3,0],[3,0],[3,2],[2,1],[0,1],[1,1],[1,1],[1,1],[0,1],[1,1],[1,1],[2,0],[4,0],[4,0],[1,1],[3,0],[3,0],[1,2],[0,1],[1,1],[4,0],[3,0],[2,1],[3,0],[3,0],[1,1],[3,0],[2,0],[4,0],[3,0],[0,1],[1,1],[0,2],[2,1],[0,1],[2,0],[0,1],[2,0],[4,0],[4,0],[3,0],[3,0],[1,1],[3,0],[1,1],[0,2],[3,0],[2,1],[0,1],[2,0],[0,2],[0,1]]
      žK          # Push builtin string "abc...xyzABC...XYZ012...789"
        IS        # Push the input, split into characters
          k       # Get the index of each of these characters in the builtin-string
           ®K     # Remove all -1 for non-alphanumeric characters that were present
             è    # Use these indices to index into the earlier created pair-list
              ø   # Zip/transpose; swapping rows/columns
               O  # Sum both inner lists
                  # (after which the result is output implicitly)

Sehen Sie diese 05AB1E Spitze von mir (Abschnitte Wie große natürliche Zahlen zu komprimieren? Und Wie zu komprimieren integer Listen? ) Zu verstehen , warum •xþ¢*>ÌŸÑå#÷AUI'@æýXÁи<¥èå–ΘηžÎà₅åǚĕist 101629259357674935528492544214548347273909568347978482331029666966024823518105773925160und •xþ¢*>ÌŸÑå#÷AUI'@æýXÁи<¥èå–ΘηžÎà₅åǚĕ5вist [1,0,2,0,0,2,1,0,1,2,0,3,2,0,1,1,0,3,1,1,0,3,0,3,0,4,0,4,0,2,1,0,0,2,1,0,1,2,2,0,1,1,1,0,0,3,0,4,0,2,0,3,1,1,0,3,0,3,1,2,0,3,0,4,1,1,1,0,2,1,0,3,0,3,1,1,0,4,0,4,0,2,1,1,1,1,1,0,1,1,1,1,1,1,1,0,1,2,2,3,0,3,0,3,2,1,1,3,1,1,2,1,1,1,1,1,1,1,1,0,1,1,2,0].

Python 3 , 697 Bytes

def f(s):
    l=0;c=0;d={'0':(1,1),'1':(3,0),'2':(1,2),'3':(0,2),'4':(3,0),'5':(2,1),'6':(0,1),'7':(2,0),'8':(0,2),'9':(0,1),'A':(3,0),'B':(1,2),'C':(0,1),'D':(1,1),'E':(4,0),'F':(3,0),'G':(2,1),'H':(3,0),'J':(1,1),'K':(3,0),'L':(2,0),'M':(4,0),'N':(3,0),'O':(0,1),'P':(1,1),'Q':(0,2),'R':(2,1),'S':(0,1),'T':(2,0),'U':(0,1),'V':(2,0),'W':(4,0),'X':(4,0),'Y':(3,0),'Z':(3,0),'a':(0,2),'b':(1,1),'c':(0,1),'d':(1,1),'e':(1,1),'f':(1,1),'g':(1,2),'h':(1,1),'i':(3,1),'j':(1,2),'k':(3,0),'l':(3,0),'m':(3,2),'n':(2,1),'o':(0,1),'p':(1,1),'q':(1,1),'r':(1,1),'s':(0,1),'t':(1,1),'u':(1,1),'v':(2,0),'w':(4,0),'x':(4,0),'y':(1,1),'z':(3,0)};
    for i in s:
        if i in d:
            l+=d[i][0];c+=d[i][1];
    return l,c

Ein einfacher erster Versuch. Ich legte die Tabelle in ein Wörterbuch, durchlief die Zeichenfolge, erhöhte einige Zähler und gab ein Tupel zurück. Eingabe ist eine Zeichenfolge.

Probieren Sie es online aus!

C # (Visual C # Interactive Compiler) , 157 Byte

x=>(x=x.Where(n=>n<123&n>47)).Sum(n=>p[n-48]/5)+" "+x.Sum(n=>p[n-48]%5);var p=@"




";

Probieren Sie es online aus!