Ü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.

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.

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)

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

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              

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 Ṡ.

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.}

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..]

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!

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

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!

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.

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

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)

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

Kohle , 31 Bytes

Ａ⁰ξＦＬθＡ⁺ξ×⁻ι⌕ζ|⁻℅§θι³¹ξＩ⁻›ξ⁰‹ξ⁰

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 ≔ΣＥθ×⁻κ⌕ζ|⁻℅ι³¹ξＩ⁻›ξ⁰‹ξ⁰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: ≔⁰ξＦＬη≔⁺ξ×⁻ι⌕ζ|⁻℅§◨θＬηι³¹ξＩ⁻›ξ⁰‹ξ⁰ Probieren Sie es online aus! ≔ΣＥ◨θＬη×⁻κ⌕ζ|⁻℅ι³¹ξＩ⁻›ξ⁰‹ξ⁰ Probieren Sie es online! Links führen zur ausführlichen Version des Codes.