Werde ich umkippen?

36

Überblick

Finden Sie bei einer 3-zeiligen Zeichenfolge heraus, ob die Struktur nach links fällt, ausgeglichen ist oder nach rechts fällt.

Eingabestruktur

Sie können sich die Struktur als Metallstange vorstellen, auf der alles auf einer vertikalen Stange balanciert ist.

1  7 4        a
===============
        |

Die erste Zeile enthält die Artikel. Das Gewicht jedes Gegenstands wird als ASCII-Wert des Zeichens minus 32 berechnet. (Zeichen unter 32 werden nicht berücksichtigt und Leerzeichen wiegen 0). Denken Sie daran, dass die Kraft eines Gegenstands auf die Stange das Gewicht multipliziert mit dem Abstand zum Drehpunkt ist.

Die zweite Linie ist die Stange. Jede Stangenlänge wiegt 1 Stück für sich. Diese Zeile ist ausschließlich Gleichheitszeichen ( =).

Die dritte Linie ist der Drehpunkt. Dies kann an einer beliebigen Stelle platziert werden und wird durch eine Reihe von Leerzeichen gefolgt von einem einzelnen pipe ( |) -Zeichen dargestellt.

Beispiele

Eingang:

=====
  |

Ausgabe: Balance

Eingang:

=====
   |

Ausgang: Fällt nach links

Eingang:

    %
=====
   |

Output: Balance (Weil es %genug wiegt, um dem Gewicht der linken Seite der Stange entgegenzuwirken)

Eingang:

 aa
=======
   |

Ausgang: Fällt nach rechts (da der arechte weiter vom Drehpunkt entfernt ist)

Eingang:

1  7 4        A
===============
        |

Ausgang: Fällt nach links

Eingang:

1  7 4        a
===============
        |

Ausgabe: Fällt nach rechts (Kleinbuchstaben sind schwer!)

Eingang:

            $ ~
===============
             |

Ausgabe: Balance

Anmerkungen

  • Nachgestellte Leerzeichen sind zulässig, führende Leerzeichen nicht.
  • Ihr Programm kann in jedem gewünschten Format ausgegeben werden, solange es 3 verschiedene Ausgaben für Links, Balance und Rechts gibt.
  • Ihr Programm muss das als Eingabe angezeigte Format akzeptieren.
Daffy
quelle
1
Eng verwandt
Luis Mendo
Darf das Programm die drei Zeilen als drei separate Zeichenfolgen verwenden (z. B. als drei Argumente für eine Funktion oder als Liste mit drei Elementen)?
Notjagan
@notjagan Die Eingabe muss eine einzelne Zeichenfolge sein, die durch neue Zeilenzeichen getrennt wird.
Daffy
Verwandte , mögliche Betrug.
Xnor
@xnor Kein Betrüger, da diese Frage nur Großbuchstaben behandelt und das Ziel darin besteht, den Drehpunkt zu finden. Meine Frage betrifft alle ASCII-Zeichen> = 32, und meine liefert den Drehpunkt und fragt, ob die Struktur umfallen wird. Im Wesentlichen das Gegenteil von dem, den Sie verlinkt haben.
Daffy

Antworten:

8

JavaScript (ES6), 116 111 108 106 Bytes

-5 Bytes durch Summieren über eval(array.join`+`)anstelle von array.reduce().
Standardmäßig -3 Byte 1anstelle von 32 - 31, sodass Klammern entfernt werden können.
-2 Bytes, da Drehpunkt die Länge der letzten Zeile ist - 1

(s,[t,r,b]=s.split`
`)=>Math.sign(eval([...r].map((_,i)=>(t.charCodeAt(i)-31||1)*(i-b.length+1)).join`+`))

Ausgänge -1, 0oder 1, für links, symmetrisch oder rechts. Endete ähnlich wie Chas Browns Python-Antwort , also geht die Ehre dahin.

Kann 4 Bytes einsparen, wenn die erste Zeile mit der Länge des Stabes aufgefüllt wird
(31-t.charCodeAt(i))*(b.length+~i).

Testschnipsel

Schließt zusätzliche Ausgabe ( Left/ Balanced/ Right) zusammen mit der Zahl ein.

f=
(s,[t,r,b]=s.split`
`)=>Math.sign(eval([...r].map((_,i)=>(t.charCodeAt(i)-31||1)*(i-b.length+1)).join`+`))
<textarea id=I rows=3 cols=20></textarea><br><button onclick="O.value=I.value?`${x=f(I.value)} (${['Left','Balanced','Right'][x+1]})`:''">Run</button> <input id=O disabled>

Eine weitere 106-Byte-Methode

(s,[t,r,b]=s.split`
`)=>Math.sign(eval(r.replace(/./g,(_,i)=>"+"+(t.charCodeAt(i)-31||1)*(i-b.length+1))))

Anstatt joinein Array auf +s zu setzen, erstellen wir eine Folge von Zahlen, denen jeweils ein Präfix vorangestellt ist +. Die Führung +wird ignoriert.

Justin Mariner
quelle
1
Ich denke, (b.length+~i)könnte helfen, ein Byte zu retten. (Auch ich verstehe nicht, warum Sie die haben ||1.)
Neil
1
@Neil b.length+~igibt das Negativ von zurück i-b.length+1; das könnte helfen, wenn ich den anderen Teil negieren könnte. Das lag daran ||1, dass ich davon ausging, dass die erste Zeile nicht gepolstert war, um der Länge der Stange zu entsprechen, und daher über das Ende der ersten Zeile hinaus t.charCodeAt(i)zurückkehren würde NaN.
Justin Mariner
Ich musste jedoch keinen ungepolsterten Testfall ausprobieren. danke fürs erklären.
Neil
3

Python 2 , 112 110 Bytes

def f(s):w,b,p=s.split('\n');return cmp(sum((ord((w+' '*-~i)[i])-31)*(i-p.find('|'))for i in range(len(b))),0)

Probieren Sie es online!

EDIT: Endlich geschafft, die enumerateund rjustfür eine dürftige 2 Bytes zu beseitigen ... meh!

Nimmt eine Schnur auf; Ausgänge -1,0 bzw. 1 für Linksabgleich bzw. Rechtsabgleich.

Erster Durchlauf bei 112 Bytes war:

def f(s):w,b,p=s.split('\n');return cmp(sum((ord(c)-31)*(i-p.find('|'))for i,c in enumerate(w.rjust(len(b))),0)
Chas Brown
quelle
(ord(c)-31)Es dauerte eine Weile, bis mir klar wurde, dass dies tatsächlich das Gewicht der Stange selbst zusammen mit den Gegenständen beinhaltet. Sehr schlau!
Daffy
1
Wie pro Meta , können Sie ersetzen returnmit printfür -1 Byte (obwohl es nicht wirklich gut mit dem aktuellen TIO Code spielen wird).
Notjagan
3

Haskell, 212 171 Bytes (188, wenn Eingabe als eine Zeichenfolge übernommen wird)

o!p=map(fst)(zip[p-0,p-1..]o)
x#p=sum(zipWith(\c w->(max(fromEnum c-32)0)*w)x(x!p))+sum(x!p)
x?c=length(takeWhile(==c)x)

171-Byte-Variante

r a b c=signum(take(b?'=')(a++repeat ' ')#(c?' '))

Variante mit 188 Bytes

x%y=lines x!!y
r i=signum(take(i%1?'=')(i%0++repeat ' ')#(i%2?' '))

Erläuterung

o!p=map(fst)(zip[p-0,p-1..]o)        Creates weights coefs list. 
                                     o - list, p - pivot position
                                     for list "abcdf" and p=3 (pivot under 'd')
                                     outputs [3,2,1,0,-1]

x#p                                  Calculates total balance
                                     x-list of "objects" on lever, p-pivot place
  sum(zipWith                        sum of zipped lists
   (\c w->(max(fromEnum c-32)0)*w)   weight of ascii "object" times
                                     distance from pivot
    x(x!p))                          x-ascii objects, 
                                     (x!p)-distances list(weight coefs)
  +sum(x!p)                          balance of lever ("==") itself

x?c=length(takeWhile(==c)x)          length of list before non c element met
                                     used to find '|' position
                                     and length of "===" lever
                                     before right whitespaces met

r a b c=                             Sums it all up =)
                                     a-ascii objects, b-lever, c-pivot line
   signum(                           1-tips left, 0-balance, -1-tips right
     take(b?'=')(a++repeat ' ')      takes all object on lever 
                                     plus whitespaces up to length of the lever
      #                              calculate the balance
       (c?' ')                       determine place of pivot
Sergii Martynenko Jr
quelle
1
Sie können fromEnumanstelle von die verwenden ordund fallen lassen import. ckann zu c p=max(ord p-32)0(oder mit fromEnum) vereinfacht werden, und da Sie es nur einmal verwenden, fügen Sie es ein.
Nimi
Oder Sie können (Lambdabot) zu Ihrem Titel hinzufügen, dies importiert so ziemlich alles, was Sie brauchen, siehe hier .
7.
1
Die Funktion ckann noch weiter vereinfacht werden (Zeichen unter 32 werden nicht berücksichtigt) c p=ord p-32. Auch pist im Grunde length(minus 1), p x=length x-1würde also auch funktionieren (und Sie können es auch inline). Schauen Sie sich auch meine Lösung an, wie ich sie verwende signum- Sie könnten tun, r o l s = signum $ 2 * z ...was 0,1,-1für B, L, R gilt.
7.
1
Abgesehen davon, dass diese Lösung Testfälle zu scheitern scheint [3,4,7]und 3 Strings anstelle von einem benötigt. (siehe lines).
7.
1
Hier ist eine Version mit ein paar Tipps (Sie sparen 29 Bytes;)).
7.
2

Gelee , 30 Bytes

O_31×J_¥A+\sṪ€µ÷ḢṪ_2Ṡ
ỴṪLç@ỴḢ$

Test Suite

Ausgänge 0 für symmetrisch, 1 für rechts und -1 für links.

Wie es funktioniert

O_31×J_¥A+\sṪ€µ÷ḢṪ_2Ṡ - helper function. Arguments position of pivot and first line
O                        - char codes of first line
 _31                     - subtract 31 to get weight
    ×                    - elementwise product with:
     J_¥                 - distances from the pivot
        A                - absolute value
         +\              - cumulative sum
           s             - split to get [[...,left weight],...,[..., right + left weight]]
            Ṫ€           - last element of each sublist: [left weight, ... right weight]
              µ÷Ḣ        - get ratio of each element over left weight: ratio n indicates
                              right + left = n × left ===> right = left if n = 2
                 _2      - subtract 2: positive is right>left and negative is right<left
                   Ṡ     - return the sign of this


ỴṪLç@ỴḢ$              - main link. Argument: 3 line string.
   ç@                  - apply helper function with arguments:
Ỵ                        - split by linefeeds
 Ṫ                       - last line
  L                      - length (returns position of pivot)
       $               - and
     Ỵ                   - split by linefeeds
      Ḣ                  - first line              
fireflame241
quelle
2

Gelee , 24 Bytes

ṪO_31
ỴµṪLạЀṪL$×Çṣ0S€IṠ

Probieren Sie es online!

-1zum nach links fallen, 0zum ausbalancieren, 1zum nach rechts fallen (volles programm).
[-1]zum nach links fallen, [0]zum ausbalancieren,[1] zum nach rechts fallen (Funktion).

Die erste Zeile muss ein Leerzeichen enthalten, die letzte Zeile darf kein Leerzeichen enthalten.

Erklärung (wir beginnen mit dem Endergebnis):

Zuallererst arbeiten wir mit einzelnen Zeilen, also müssen wir sie irgendwie bekommen. Das ist ein Job für . Dann müssen wir die \n-split-Version der Eingabe so behandeln, als wäre es die ursprüngliche Eingabe, also verwenden wirµ eine monadische Kette, die auf den aktuellen Wert angewendet wird.

Jetzt fangen wir an, richtig zu arbeiten, und unsere erste Aufgabe wäre es, die Faktoren der Gewichte zu berechnen. Im Wesentlichen ist dies ein Bereich [Abstand von links nach rechts nach rechts nach rechts]. Zunächst müssen wir den 1-basierten Index des Pivots ermitteln, der im Wesentlichen die Länge der letzten Zeile ohne nachfolgende Leerzeichen ist. Also ziehen wir die letzte Zeile (Pivot-Linie) aus unserer ursprünglichen Liste mit , da wir sie nicht mehr brauchen, und nehmen dann ihre Länge mit L. Wir müssen dann die Länge der Stange nehmen, für die wir dasselbe mit der jetzt letzten Linie (Stangenlinie) machen ṪL$. Um die Reichweite zu ermitteln, kartieren wir | x - y | auf [1. Stablänge], wobei x der Pivot-Index ist und y istist jedes Element der Liste, auf die wir abbilden. Wir tun dies mit ạЀ, wobei | berechnet wird x - y | und macht einen Bereich von 1 bis einschließlich der Stablänge. Jetzt haben wir den Bereich, den wir wollen.Ѐ

Danach müssen wir jede ganze Zahl, die ein Stück des Stabes darstellt, mit dem entsprechenden Gewicht multiplizieren. Um die Gewichte zu berechnen, gehen wir Çzur obersten Zeile unseres Codes. Wir nehmen die restliche Linie mit , seine Zeichencodes mit O, und dann berechnen wir x - 31 mit _31, x jeweils charCode zu sein. Wir weisen dann Gewicht 1 (0 + Stabstück = 1), !Gewicht 2 (1 + 1) usw. ein Leerzeichen zu . Wir sind mit der obersten Zeile fertig und Çwürden nun die Liste der Gewichte zurückgeben, die wir mit der entsprechenden multiplizieren ganze Zahlen, die die Stabstücke mit darstellen ×.

Danach teilen wir uns mit ṣ0dem Pivotpunkt, der durch eine 0 dargestellt wird (da sich jedes Gewicht dort nicht auf das Ergebnis auswirkt), was zu einer Liste der Form führt [[1. Gewicht, 2. Gewicht ... Gewicht kurz vor dem Pivot] , [Gewicht kurz nach dem Drehpunkt, Gewicht nach dem vor ... letztes Gewicht]]. Diese Listen repräsentieren die Seiten der Stange, links und rechts. Wir addieren nun jede der Listen mit S€, um die Gesamtgewichte auf jeder Seite zu erhalten, und verwenden I, um das Delta zu nehmen, das negativ ist, wenn die linke Seite schwerer ist, null, wenn sie gleichgewichtet sind, und positiv, wenn die rechte Seite schwerer ist . Um das Endresultat mit diesem zu unserem Vorteil zurückzugeben, nehmen wir das Zeichen mit .

Erik der Outgolfer
quelle
2

APL (Dyalog) , 43 Byte *

{×(¯31+⎕UCS⊃⍵)+.×(⍳≢⊃⍵)-'|'⍳⍨⊃⌽⍵}⎕TC[2]∘≠⊆⊢

Probieren Sie es online!

⊆⊢ Teilen Sie das Argument in eine Reihe von Zeichen auf

⎕TC[2]∘≠ unterscheidet sich von der 2 nd T erminal C ontrol Zeichen (Zeilenvorschub) **

{... } die folgende anonyme Funktion auf der Liste von Strings gelten:

⊃⌽⍵ in der ersten Zeichenfolge der umgekehrten Liste (dh der letzten)

'|'⍳⍨ Finden Sie den ɩ ndex des Drehpunkts

()- Das von folgender Liste abziehen:

  ⊃⍵ die erste Saite

   seine Länge

   all die Vorteile davon

()+.× Gewichtete Summe mit diesen Gewichten und den folgenden Werten:

  ⊃⍵ die erste Saite

  ⎕UCS Codepunkte in der U niversal C HARACTER S et

  ¯31+ negative einunddreißig hinzufügen (32 für den erforderlichen Versatz minus eins für die Stange)

× Zeichen dafür


* Verwenden Sie für 1 Byte pro Zeichen {×(¯31+⎕UCS↑⍵)+.×(⍳≢↑⍵)-'|'⍳⍨↑⌽⍵}⎕TC[3]∘≠⊂⊢mit ⎕ML←3. Probieren Sie es online!
** ⎕TCist veraltet und wird hier nur zu Golfzwecken verwendet. Im Produktionscode sollte man verwenden ⎕UCS 10.

Adam
quelle
2

Haskell (Lambdabot), 142 Bytes

l=length
g[a,c,b]=splitAt(l b)$a++(' '<$[1..l c-l a])
k e=sum$zipWith((*).(-31+).ord)e[1..]
f=signum.uncurry(-).(k.drop 1.reverse***k).g.lines

Probieren Sie es online!

Ungolfed-Version:

-- for readability, allows reading top-down/left-right
(.>) = flip (.)

ungolfed =
     lines                                 -- separate out lines into..
  .> (\[a,b,c] ->                          -- a,b,c (first,second,third)
                                           -- ' ' pad the first line & split on pivot
       splitAt (length c) (a ++ replicate (length b - length a) ' ')
     )
  .> (weight.drop 1.reverse *** weight)    -- reverse left half, drop element above pivot & get weight for both
  .> uncurry (-)                           -- subtract right from left
  .> signum                                -- get sign

-- get ord of the character subtract 31 ('=' char from bar),
-- then multiply with scales ([1..]) and sum it all up
weight es = sum $ zipWith (ord .> subtract 31 .> (*)) es [1..]
ბიმო
quelle
2

Python 2 , 90 Bytes

def f(s):L=len(s)/3;print cmp(sum((ord(s[i])-31)*(i-s[-L:].find('|'))for i in range(L)),0)

Erwartet, dass Eingabezeilen (mit Leerzeichen) auf die richtige Länge aufgefüllt werden. Ausgänge -1für Stürze links , 0für ausgeglichen und 1für Stürze rechts .

Probieren Sie es online!


94 Bytes

Für +4 Bytes können wir eine Version haben, die unter Verwendung einer whileSchleife gestrippte Zeilen anstelle von aufgefüllten Zeilen benötigt:

def f(s):
 i=r=0
 while''<s[i]:r+=(ord(s[i])-31)*(i-s[-3::-1].find('='));i+=1
 print cmp(r,0)

Probieren Sie es online!

FlipTack
quelle
1

Ruby, 543 Bytes

def willittip(s)
leftw=0;
rightw=0;
arr=[];
fields=s.split("\n")
pos=fields[2].index("|")
fields[0].split("").each do |i|
arr << i.ord-32
end
arr[pos+1..-1].each_with_index do |x,y|
rightw=rightw+1
if x>0
if pos>0
rightw=rightw+x*(pos-y).abs
else
rightw=rightw+x
end
end
end
arr[0..pos-1].each_with_index do |x,y|
leftw=leftw+1
if x>0
if pos>0
leftw=leftw+x*(pos-y).abs
else
leftw=leftw+x
end
end
end
if leftw==rightw
return "Equal"
elsif leftw<rightw
return "Right"
elsif leftw>rightw
return "Left"
end
end
KittenDev
quelle
10
Willkommen bei PPCG! : D Das Ziel bei Code-Golf- Herausforderungen ist es, Ihren Code so klein wie möglich zu halten. Sie können die Codegröße reduzieren, indem Sie alle Variablen und Funktionsnamen zu einem einzigen Zeichen zusammenfassen und wenn möglich Leerzeichen löschen.
Daffy
1

C (gcc) , 106107 121 123 124 129 131 Bytes

c,b,l,i;f(char*a){l=strlen(a)/3;for(i=b=c=0;32/a[l*2+c];++c);for(;i<l-1;b+=(a[i]-31)*(i++-c));a=b>0?2:!b;}

Geben Sie 0 zurück, um nach links zu fallen, 1, um das Gleichgewicht zu halten, und 2, um nach rechts zu fallen.

Alle drei Zeilen müssen dieselbe Länge haben und mit enden \n, um die Länge der Zeichenfolge zu bestimmen.

Probieren Sie es online!

Keyu Gan
quelle
1

Mathematica, 91 92 Bytes

Sign[(v=(g=ToCharacterCode)@#&@@(d=#~StringSplit~"
")-31).(Range@(l=Length)@v-l@g@Last@d)]&

Die erste Leine sollte mit der Stange gleich lang sein. Die dritte Zeile sollte keine nachgestellten Leerzeichen enthalten.

Return -1, 0, 1 für links fallen, Balance und rechts fallen.

Keyu Gan
quelle
1

C # (.NET Core) , 127 95 90 + 18 = 108 Byte

Für diese Funktion muss die erste Zeile rechts mit Leerzeichen aufgefüllt werden, damit sie die gleiche Länge wie die Stange hat, und die dritte Zeile darf keine Test-Leerzeichen enthalten. Diese Bedingungen sind erlaubt (siehe Kommentare der Frage).

s=>s.Split('\n')[0].Select((c,i)=>(c-31)*(i-s.Split('\n')[2].Length+1)).Sum().CompareTo(0)

Probieren Sie es online!

Ausgänge:

-1 für die linke Spitze
0 für die Balance
für Spitze rechts 1

Rasnagul
quelle
1

Python 3, 217 Bytes

Funktioniert auch in Python 2.7

def f(s):i,b,p=s.split('\n');c=p.find('|');l=sum((ord(e)-32)*(c-i.find(e))for e in i[:c])+sum(x for x in range(1,c+1));r=sum((ord(e)-32)*i[c:].find(e)for e in i[c:])+sum(x for x in range(len(b[c:])));return(l>r)-(r>l)

Gibt 1 für die linke Seite, -1 für die rechte Seite oder Null zurück, wenn ausgeglichen.

Lesbare Version:

def f(s):
    i,b,p = s.split('\n')
    c = p.find('|')

    l = sum((ord(e)-32)*(c-i.find(e))for e in i[:c])+sum(x for x in range(1, c+1))
    r = sum((ord(e)-32)*i[c:].find(e)for e in i[c:])+sum(x for x in range(len(b[c:])))

    return(l>r)-(r>l)
U / min veganaiZe
quelle
1
Sie brauchen nicht sum([...]), Sie können einfach habensum(...)
Mr. Xcoder
@Daffy dies sollte zu 100% Ihrer Spezifikation und allen gegebenen Beispieleingaben entsprechen. Wenn Sie damit einverstanden sind, lassen Sie es mich bitte wissen, damit ich es weiter optimieren kann. Vielen Dank.
veganaiZe
@veganaiZe Hat alle meine Tests bestanden, sieht gut aus! :)
Daffy
1
Stuff es kurz zu machen : i[c:].find(e)kann sein i.find(e,c), die Verwendung i,m,n=s.split('\n')und die Notwendigkeit zu vermeiden , süberhaupt, Verwendung return 2*(r>l) or l>rdramatisch Testkosten am Ende (Rückgabewert numerisch äquivalent ist, aber es ist zu reduzieren Truestatt 1und Falsestatt 0), oder wirklich, verwenden Sie einen anderen Satz von Rückkehr Werte und tun return (l>r)-(r>l), um die 1, 0 oder -1 wie die alte cmpFunktion zurückzugeben.
ShadowRanger
Vielen Dank an ShadowRanger, Mr. Xcoder und Daffy! @ShadowRanger Ich musste mich an die halten, i[c:]weil der kürzere Weg ein seltsames Problem bei der Eingabe von Eckpunkten verursachte (platzieren Sie eine |genau in der Mitte - über der Leiste).
veganaiZe
1

PHP, 105 Bytes

for([$a,$b,$c]=explode("
",$argn);$b[$i];)$w+=(strpos($c,"|")-$i++)*8*(max(1,ord($a[$i])-31));echo$w<=>0;

druckt -1/ 0/ 1für links / balance / rechts. Laufen Sie als Pipe mit -nRoder probieren Sie es online aus .

Nervenzusammenbruch

for([$a,$b,$c]=explode("\n",$argn); # import input
    $b[$i];)                        # loop through bar
    $f+=                                # add to force:
        ($i-strpos($c,"|"))             # distance (<0 if left, >0 if right of pivot)
        *8                              # *8
        *(max(1,ord($a[$i++])-31));     # *weight
echo$f<=>0;                         # print -1 if $f<0, 1 if $f>0, 0 if $f==0
Titus
quelle
1

Kohle , 31 Bytes

A⁰ξFLθA⁺ξ×⁻ι⌕ζ|⁻℅§θι³¹ξI⁻›ξ⁰‹ξ⁰

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Ausgang 0 für Balance oder -1 oder 1 für Links- oder Rechtsabfall. Bearbeiten: Änderungen in Charcoal bedeuten jetzt, dass ≔ΣEθ×⁻κ⌕ζ|⁻℅ι³¹ξI⁻›ξ⁰‹ξ⁰für 24 Bytes funktioniert: Probieren Sie es online! Link ist eine ausführliche Version des Codes. Hinweis: Beide Antworten erfordern eine gepolsterte Eingabe, können jedoch so angepasst werden, dass ungepolsterte Eingaben zu einem Preis von 3 Byte akzeptiert werden: ≔⁰ξFLη≔⁺ξ×⁻ι⌕ζ|⁻℅§◨θLηι³¹ξI⁻›ξ⁰‹ξ⁰ Probieren Sie es online aus! ≔ΣE◨θLη×⁻κ⌕ζ|⁻℅ι³¹ξI⁻›ξ⁰‹ξ⁰ Probieren Sie es online! Links führen zur ausführlichen Version des Codes.

Neil
quelle
Sie möchten vielleicht erwähnen, dass dies voraussetzt, dass die Eingabezeilen mit Leerzeichen auf die richtige Länge aufgefüllt werden, sodass eine nicht aufgefüllte Eingabe möglicherweise nicht funktioniert.
FlipTack
@FlipTack Besser noch, ich habe Versionen entwickelt, die ungepolsterte Eingaben akzeptieren.
Neil