Warum ein Simulator?

Kinder haben heutzutage weder die Zeit noch den Ehrgeiz, Kisten auf der Wippe zu stapeln oder mit balancierenden Gegenständen herumzuspielen. Dies lässt auf dem Softwaremarkt viel Platz für einen Hebel-Simulator, der sich nach meinen Modellen wie verrückt verkaufen wird!

Programmierhilfe gesucht

Ich habe ein Patent für ein solches Spiel angemeldet (anhängig), benötige aber einen erfahrenen Programmierer, um die Spielelogik für mich zu schreiben. Nach meinem Verständnis ist es üblich, Programmierer basierend auf der Größe des endgültigen Programms in Bytes zu kompensieren . Als solches werde ich diesen lukrativen Auftrag an den niedrigsten Bieter vergeben.

Spezifikation

Ein Hebel ist eine Reihe von Kisten oder leeren Räumen, die durch einen Drehpunkt ausgeglichen werden. Jede Box hat ein bestimmtes Gewicht von eins bis neun und Leerzeichen haben kein Gewicht. Wie Sie wissen, ist das Gewicht einer Box auf dem Hebel direkt proportional zum Abstand dieser Box vom Drehpunkt. Eine Gewichtskiste 4, die sich auf dem dritten Raum vom Drehpunkt befindet, trägt 12wirksame Krafteinheiten zu dieser Seite des Hebels bei.

Ich brauche ein Programm, das bei gegebenem Eingabehebel ausgibt, ob der Hebel nach links, rechts oder perfekt ausbalanciert ist.

I / O-Richtlinien

• Du wirst für mich ein Programm schreiben.
• Die Eingabe enthält eine Textzeile.
• Die Eingabe kommt von stdinoder als eine Befehlszeilenzeichenfolge.
• Boxen werden durch die Zeichen ' 1' bis ' 9' dargestellt. Diese Zeichen repräsentieren ihre jeweiligen Gewichte. Ein leerer Raum wird durch ein Leerzeichen ' ' dargestellt. Der Drehpunkt wird durch ein Caret ' ^' dargestellt.

Ein Beispieleingabehebel könnte folgendermaßen aussehen: 8 2^ 941

Dieser Hebel ist perfekt ausbalanciert: (4*8) + 0 + 0 + (1*2) == 0 + (2*9) + (3*4) + (4*1) == 34

• Es gibt keine führenden oder nachfolgenden Leerzeichen. Es wird keine nachgestellte Newline geben.
• Es ist nicht erforderlich, fehlerhafte Eingaben zu verarbeiten. Die Eingabe hat immer genau einen Drehpunkt und nur Zahlen und Leerzeichen.
• Der Ausgang zeigt an, ob der Hebel links schwer, rechts schwer oder ausgeglichen ist.
• Ihr Programm muss genau 3 mögliche Ausgaben haben, die sich aus einer wohlgeformten Eingabe ergeben könnten. Sie können wählen, was diese sind.
• Die Ausgabe muss entweder auf stdoutden Rückgabecode des Programms oder auf den Rückgabecode des Programms lauten.

Testfälle

Hier verwende ich L, R, Bbedeuten links schweren rechten schwer, ausgewogen:

1. Eingabe: 11 ^9Ausgabe:B

2. Eingabe: 321^ 12Ausgabe:L

3. Eingabe: 9^ 1Ausgabe:R

(Wenn jemand "kniffligere" Testfälle hat, können Sie diese gerne bearbeiten.)

Literaturverzeichnis

Nicht unbedingt inspiriert, aber mit Balance verbunden, eine Reihe von Gewichten auf einer Wippe

Python 2, 69 Bytes

lambda s:cmp(sum(ord(c)%16*(i-s.find('^'))for i,c in enumerate(s)),0)

Der Modul ord(c)%16extrahiert den Wert eines Ziffernzeichens, während der Abstand 0 ergibt. Für jedes Zeichen wird sein Drehmomentbeitrag als sein Gewicht multipliziert mit dem vorzeichenbehafteten Abstand zum Drehpunkt berechnet. i-s.find('^')Diese werden summiert und mit 0 verglichen -1,0,1. Der Charakter ^wird mit einem Gewicht von 14 berechnet, aber das spielt keine Rolle, da er sich auf dem Drehpunkt befindet.

Ein 18-Byte-Pyth-Port von Maltysen:

._s.e*-kxz\^%Cb16z

Wenn für den Python-Code ein vollständiges Programm erforderlich ist, finden Sie hier 79 Bytes. Die Idee ist, den Index iverschoben zu starten s.find('^')und herunterzählen zu lassen.

s=raw_input()
t=0;i=s.find('^')
for c in s:t-=ord(c)%16*i;i-=1
print cmp(t,0)

Javascript ES6, 62 Bytes

s=>Math.sign([...s].reduce((p,c,i)=>p+~~c*(i-s.indexOf`^`),0))

• -1 wenn links ist schwerer
• 0 wenn ausgeglichen
• 1 wenn rechts schwerer ist

Ungolfed:

s=>
  Math.sign(                     // output sign of weight of lever
    [...s].reduce((p,c,i)=>      // split and reduce input
      p+~~c*(i-s.indexOf`^`),0)) // add weights of all elements
                                 //   (elements left of pivot are negatively weighted)

Testläufe (Zuweisen anonymer Funktionen an f):

>> f("11   ^9")
<< 0

>> f("321^  12")
<< -1

>> f("9^         1")
<< 1

• -11 Bytes: Ausgabe von R B Lnach geändert-1 0 1
• -3 Bytes: geändert e.split``in [...e](danke @ Vɪʜᴀɴ)
• -33 Bytes: Der Algorithmus wurde geändert, um negative Gewichte zu verwenden, anstatt am Pivot zu teilen
• -9 Bytes: Pivot Check entfernt (wird anscheinend ~~'^'zu 0... ausgewertet )
• -2 Bytes: Funktion anonymisiert (danke @ cᴏɴᴏʀ-obʀɪᴇɴ)

Japt , 22 Bytes

Japt ist eine verkürzte Version von Ja vaScri pt . Dolmetscher

U¬r@X+~~Y*(Z-Ub'^),0 g

Gibt -1für L, 0für Bund 1für zurück R.

Wie es funktioniert

Uq r@X+~~Y*(Z-Ub'^),0 g
                         // Implicit: U = input string
Uq r@              ,0    // Reduce the input by this function, starting at 0:
     X+~~Y*              //  Return the previous value, plus the current value times
           (Z-Ub'^)      //   the current index minus the index of "^" in U.
                      g  // Take the sign of the resulting number.
                         // Implicit: output last expression

APL, 39 30 Bytes

{×+/(10|⍵⍳⍨∊⍕¨⍳9)×(⍳⍴⍵)-⍵⍳'^'}

Nach dem erneuten Lesen der Regeln habe ich dies geändert und -1 0 1stattdessen L B Rneun Bytes gespart.

Probieren Sie es hier aus .

Pyth, 20 Bytes

._s*V-Rxz\^Uzm.xsd0z

Testsuite

-1für links vorgespannt, 0für ausgeglichen, 1für rechts vorgespannt.

Wie es funktioniert:

._s*V-Rxz\^Uzm.xsd0z
                        z = input()
                        Weights:
             m     z    Map over z
              .x        try:
                sd           cast charater to int
                  0     except: 0
                        Lever arm:
           Uz           range(len(input()))
     -Rxz\^             Subtract index of caret from each value.
   *V                   Vectorized multiplication.
  s                     Sum.
._                      Take sign and print.

Haskell, 116 96 82 76 Bytes

 f x=signum$sum$zipWith(*)[-length(fst$span(<'^')x)..]$(`mod`16).fromEnum<$>x

Die Ausgabe ist 0für ausgeglichene, -1für linkslastige und 1für rechtslastige.

Anwendungsbeispiel: f "321^ 12"->-1

So funktioniert es: Finde das Teil vor dem ^. Multiplizieren Sie die Eingabezeichenfolge und die Liste der Gewichte, die bei beginnt - length-of-first-part. Der ^hat eine Gewichtung von 0 und addiert sich nicht zur Summe. Ich verwende @ xnors Mod 16-Trick , um Ziffern / Leerzeichen in ganzzahlige Werte umzuwandeln. Wenn die Summe negativ (positiv) ist, ist der Hebel linksschwer (rechtsschwer) und ausgeglichen, wenn die Summe 0 ist.

TeaScript , 23 Bytes 25

Ich habe versucht, eine Pyth-Antwort zu schreiben, aber das ist schrecklich gelaufen: \

$²xd»l+~~i*(a-xi`^`),0©

Das ²sieht so unangebracht aus, spart aber 1 Byte, also werde ich es behalten.

Probieren Sie es online!

Testen Sie alle Fälle

Für das von mir gewählte Ausgabeschema:

• -1wenn links schwerer ist als rechts ( L)
• 0wenn links so schwer ist wie rechts ( B)
• 1ist links ist weniger schwer als rechts ( R)

Ungolfed && Erklärung

Dabei werden Karten und Reduzierungen verwendet, um die Arbeit zu erledigen.

$C(xd(#l+~~i*(a-xi`^`),0))

              // Implicit: x = input
$C(           // Compare...
  xd(#        // Reduce...
    l+          // Pending weight...
    ~~i         // Current weight -> int times...
    (a-         // Total length minus...
    xi`^`       // Fulcrum location
  ,0)
)             // Implicit: Output result

pb , 349 329 Bytes

^w[B!94]{>}w[B!0]{vb[T]^t[T+1]>}vb[46]<w[B!0]{<}b[1]vvb[46]^^t[X]w[X!0]{<b[T-X]}^w[B!0]{w[B=32]{b[48]}>}w[X!0]{<t[B-48]vb[B*T]^}w[B!0]{vt[B]vb[1]>^w[B!46]{>}vvb[B+T]^w[B=0]{<}b[0]^b[0]^>}vb[0]vvt[B]<w[B!0]{<}t[B+T]^>[T]w[X!0]{b[10]<}<[T]w[X!0]{b[16]>}vw[B=0]{>}t[B]b[0]w[B=0]{>}t[T-B]b[0]^<[X-T]t[B]<[X]>w[B!0]{b[0]>}<[X]^b[T+66]

Das war eine knifflige Sache. pb war nicht dafür gedacht, in so etwas gut zu sein. Es gibt nicht einmal eine Multiplikation . Aber hey, es funktioniert.

Ed. Anmerkung: Habe ich gerade gesagt, dass pb keine Multiplikation hat? Was? pb hat definitiv definitiv Multiplikation. Ich habe diese Sprache entworfen und implementiert . Ich sollte wissen, dass sie eine integrierte Multiplikation hat und ich keine alberne Addition mit Schleifen durchführen muss. Wenn ich das behebe (und jetzt etwas kreativ umstelle, da ich diesen Teil des Problems aus einem anderen Blickwinkel betrachten könnte), spare ich 20 Bytes. Peinlich.

Der schwierigste Teil war, nachdem die Summe (Gewicht * Abstand) für jede Seite ermittelt worden war, tatsächlich zu bestimmen, welcher Brief gedruckt werden sollte. pb hat keine >oder <Operatoren, nur ==und !=. Es ist nicht einfach zu erkennen, welcher Wert größer ist. Ich kann nicht einmal subtrahieren und mit 0 vergleichen ... es sei denn, ich mache etwas wirklich Dummes.

• Finden Sie die Summe der beiden Summen.
• Gehen Sie so weit nach rechts, auf einer Linie, die für nichts verwendet wird.
• Bis X = 0 erreicht ist, gehe nach links und setze 'L'.
• Platziere ein 'B' bei X = 0.
• Gehe nach links um die Summe der beiden Summen.
• Bis X = 0 erreicht ist, gehe nach rechts und setze 'R'.

Dann gehen Sie einfach zu X = (linke Seite - rechte Seite) und es gibt Ihre Antwort! Löschen Sie alles in dieser Zeile, um zu bereinigen, und drucken Sie dann den Wert, der bei (0, 0) gefunden wurde.

... Aber es gibt einen etwas kürzeren Weg. Verwenden Sie statt 'L', 'B' und 'R' diese Werte - 'B' und fügen Sie beim Drucken wieder 'B' hinzu. Auf diese Weise müssen Sie niemals 'B' bei X = 0 platzieren, sondern belassen es einfach als die 0, die es bereits war. Das einzige Problem ist, dass das Programm im Watch-Modus sehr doof wird, wenn Sie dies tun. 'L'-'B'==76-66==10=='\n'. Alles scheint in Ordnung zu sein, bis plötzlich eine große Anzahl von Zeilenumbrüchen gedruckt wird und es unmöglich ist, den Überblick zu behalten: D Im regulären Ausführungsmodus von pbi funktioniert jedoch alles in Ordnung, da die Zeilenumbrüche gelöscht werden, bevor etwas auf die Seite gedruckt wird Konsole.

^w[B!94]{>}                 # Find the fulcrum

w[B!0]{                     # Starting at the fulcrum and going right:
    vb[T]^                    # Store the T below each character of input
    t[T+1]                    # Increment T
    >
}

vb[46]                      # Put a '.' at the end of the values below the input

<w[B!0]{<}                  # Go to the space below the fulcrum
b[1]                        # Put a 1 (So the fulcrum will be represented as '.' later)
vvb[46]^^                   # Put a 46 two spaces below it

t[X]                        # Store the current X value in T
w[X!0]{<                    # Until reaching the beginning of the input:
    b[T-X]                    # Put T - (the current X value) below each byte
}

^w[B!0]{                    # For each byte of input:
    w[B=32]{b[48]}            # Set spaces to '0'
    >
}

w[X!0]{<                    # For each byte of input:
    t[B-48]                   # Set T to the value of the number (fulcrum becomes '.')
    vb[B*T]^                  # Multiply the value below by T
}

# This has nothing to do with the input, except that it's the right length:
w[B!0]{                     # For every byte of input:
    v                         # Go to the value below it
    t[B]                      # Store it in T
    vb[1]>^                   # Put a flag below it
    w[B!46]{>}                # Go to the next '.' value
    vvb[B+T]                  # Add T to whatever is two spaces below the '.'
                              # This will cause the sum for the right side of
                              # the fulcrum to be 46 too high. This is why 46
                              # was left below the fulcrum earlier: both sums
                              # will be off by the same amount.
    ^w[B=0]{<}                # Go back to the flag
    b[0]^b[0]                 # Erase the flag and the value above it
    ^>
}

vb[0]                       # Erase the stray '.'
vvt[B]<w[B!0]{<}t[B+T]      # Get the sum of the two sums
^>[T]                       # Go right that far
w[X!0]{b[10]<}              # Head back to X=0, leaving 'L'-'B' the whole way
<[T]                        # Go left the same amount as before
w[X!0]{b[16]>}              # Head back to X=0, leaving 'R'-'B' the whole way
vw[B=0]{>}                  # Find the sum from left of the fulcrum
t[B]b[0]                    # Save it to T and erase it from the canvas
w[B=0]{>}                   # Find the other sum
t[T-B]b[0]                  # Subtract it from T and erase it from the canvas
^<[X-T]                     # On the line that was just prepared, go to X=T
t[B]                        # Save the value of that space to T
<[X]>w[B!0]{b[0]>}          # Erase the entire visible part of that line
<[X]^b[T+66]                # Print (the value read from that line)+'B' at (0, 0)

Perl 5, 72 Bytes

@_=split//,<>;($i)=grep$_[$_]eq'^',0..@_;$j+=$_*($k++-$i)for@_;say$j<=>0

MATLAB 91, 57, 55 Oktave, 50 Bytes

Ich hatte nicht damit gerechnet, weiter Golf zu spielen, aber durch den Wechsel zu Octave konnten 5 zusätzliche Bytes eingespart werden! Wow, das hat einige Zeit gedauert ...

@(x)(s=mod(+x,16))*[1-(i=find(s>9)):nnz(x)-i]'*inf 

Es gibt -Inf, NaN, Inffür L, B, Rjeweils.

Testsuite!

Erläuterung:

Dies ist definitiv ein schwer lesbarer Code, aber ich werde versuchen, ihn so gut wie möglich zu erklären. Ich werde zwischen Codeblock-Erklärung und Text wechseln.

@(x)                 % Anonymous function that takes a string x as input
           +x        % Convert the string into a numeric array, 
                     % where each character is represented by its ASCII-value
       mod(+x,16)    % Takes this string modulus 16, to make spaces (ASCII 32) equal 0 
    (s=mod(+x,16))   % Assigns this numeric array to s, thanks to Octave's awesome 
                     % inline variable assignment possibility
    (s=mod(+x,16))*  % Multiply s by the vector inside the brackets    

Schauen wir uns an, was in den Klammern vor sich geht:

[1-(i=find(s>9)):nnz(x)-i]
      find(s>9)             % The only value in the vector s that's larger than 9, 
                            % after the modulus is ^, (it's now 14)             
   (i=find(s>9))            % Assign the position of `^` to the index variable i

Dieser ist ein bisschen knifflig:

[1-(i=find(s>9)):nnz(x)-i]

Die Zahlen auf jeder Seite der Leiter müssen mit dem Abstand zum Caret multipliziert werden. Wenn wir auf der linken Seite negative Zahlen und auf der rechten Seite positive Zahlen verwenden, können wir den Vektor einfach summieren, um zu sehen, welche Seite am schwersten ist.

Angenommen , die Eingabezeichenfolge ist: '321^ 12'. Wir wollen die folgende: 3*(-3)+2*(-2)+1*(-1)+1*3+2*4. Der Vektor, den wir in den Klammern erstellt haben, beginnt bei 1-i, in diesem Fall -3, da sich das Caret in der 4. Position befindet. Es geht bis nnz(x)-iin Schritten von eins. Wir können nnz(x)statt verwenden numel(s), weil xes sich um eine Zeichenfolge handelt, die keine Nullen enthält.

Deshalb:

[1-(i=find(s>9)):nnz(x)-i]
ans =
  -3  -2  -1   0   1   2   3   4

Nun können wir elementweise multiplizieren s.*[...]und die Summe daraus ziehen. Da wir aber zwei Vektoren haben, können wir auch die Summe mit der Matrixmultiplikation stransponieren [...]und berechnen:

(s=mod(+x,16))*[1-(i=find(s>9)):nnz(x)-i]'

Dies ergibt entweder eine negative Zahl, was bedeutet, dass die linke Seite schwerer ist, eine Null, was bedeutet, dass sie ausgeglichen ist, oder eine positive Zahl, was bedeutet, dass die rechte Seite schwerer ist. Anstatt den naiven Ansatz von zu verwenden sign(...), multiplizieren wir ihn mit inf, was uns entweder für links -Infoder Inffür rechts ergibt. Wir bekommen NaNdafür 0*inf, da es undefiniert ist.

Dies gibt uns drei unterschiedliche Werte für die drei möglichen Ergebnisse.

𝔼𝕊𝕄𝕚𝕟 22 Zeichen / 38 Bytes

МŴ⟬ïĊ⇀$+˜_*(ã-ïÿ⍘^),0⸩

Try it here (Firefox only).

JavaScript, 146 Bytes

s=>{a=[0,0];d=s.split`^`;for(j=0;j<2;j++)for(i=0;i<d[j].length;i++)a[j]+=d[j][i]*(j==0?d[j].length-i:i+1);alert(a[0]==a[1]?'B':a[0]>a[1]?'L':'R')}

Ziemlich massiv.

Demo .

Ruby, 111 108 Bytes

->s{l,r=s.split'^';v=->x{x.chars.map.with_index{|c,i|c.to_i*(i+1)}.reduce:+};%w(B L R)[v[l.reverse]<=>v[r]]}

Erläuterung

Summiert den gewichteten Wert jeder Zahl auf jeder Seite. Dann verwendet es den Ruby-Raumschiff-Operator, um eine Gleichheit / Ungleichheit von 1,0, -1 der beiden Seiten bereitzustellen, was der Index eines Arrays mit der richtigen Ausgabe ist.

PowerShell, 83-73 Byte

param($b)$i=-$b.indexOf('^');[char[]]$b|%{$x+=$i++*"$_"};[math]::Sign($x)

Vielen Dank an TessellatingHeckler für den Golf.

Verwendet im Wesentlichen den gleichen Algorithmus wie den folgenden älteren Code, aber hier werden die Zeichen in der Eingabezeichenfolge einzeln durchlaufen, anstatt den Index zu durchlaufen, wodurch eine Handvoll Bytes gespart werden. Wirft immer noch die gleiche spektakuläre Fehlermeldung, wenn der Algorithmus erreicht ^- wirkt sich nicht auf STDOUT aus.

Bisherige

param($a)1..$a.length|%{$x+=+"$($a[$_-1])"*($_-$a.indexof('^')-1)};[math]::Sign($x)

Verwendet den gleichen hervorragenden Algorithmus wie Dendrobiums ausgezeichnete Antwort und verwendet daher die gleiche Ausgabe wie -1 / 0 / 1bei der Eingabe left-heavy / balanced / right-heavy.

Pfui. Lange wegen eines Casting Marotte Merkmal , dass Powershell hat. Am relevantesten ist hier die charMultiplikation mit intFunktionen. Einen Array-Index eines stringErgebnisses in ein charObjekt aufnehmen. PowerShell konvertiert den charWert vor der Multiplikation in den entsprechenden ASCII-Wert (und nicht in den Literalwert). So etwas $a='012'[0];[int]$a*2führt zu 96.

Das heißt, wir müssen es wieder als Zeichenfolge umwandeln. Wenn wir es jedoch einfach stringmal intmachen , werden wir es so oft stringwiederholen. Zum Beispiel $a='0';$a*2würde ergeben 00.

Dies bedeutet, dass wir den charRücken als stringvor dem erneuten Wirken werfen müssen, da intdann eine Multiplikation stattfinden kann, bevor wir ihn in unseren Akkumulator hinzufügen $x.

Kombinieren Sie dies mit der langen Iterationszeit durch einen String und dem .NET-Aufruf zur Ausgabe des Zeichens, und Sie erhalten einen ziemlich langen Code.

_{NB - Dies wird einen spektakulären Fehler auslösen, wenn es ^in die Zeichenkette gelangt und besagt, dass es nicht in eine konvertiert werden kann int. Beeinflusst STDOUT nicht.}

CJam, 29 Bytes

l_'^#\"^ "'0er'0f-_,,@fm.*:+g

Probieren Sie es online aus

Das Ergebnis ist -1für linkslastig, 0für ausgeglichen, 1für rechtslastig.

Das schien ein bisschen lang zu sein, aber ich habe eine Reihe von Alternativen ausprobiert, und alle endeten zwischen 29 und 33 Bytes. Ein Problem ist, dass ich keine Möglichkeit gefunden habe, die Zeichenfolge in Werte zu konvertieren, die automatisch zu 0 für die Leerzeichen führen würden. Also habe ich explizit die Leerzeichen durch '0 Zeichen ersetzt, was natürlich die Länge des Codes erhöht.

Alternativen ausprobiert:

• Teilen der Zeichenfolge bei '^, Umkehren der ersten und anschließendes Berechnen des gewichteten Werts für beide.
• Verwenden des eeOperators zum Hinzufügen des Index zur Werteliste.
• Anstatt die Caret-Position von jedem Index zu subtrahieren, berechnen Sie das Skalarprodukt ohne Subtraktion und subtrahieren Sie dann die Caret-Position mal die String-Länge vom Ergebnis.

Erläuterung:

l         Get input.
_'^#      Copy and find caret position.
\         Swap input back to top.
"^ "'0er  Replace caret and spaces with '0.
'0f-      Subtract '0 from all characters, to get integer values.
_,,       Build index array with same length.
@         Rotate caret position to top.
fm        Subtract it from all indices.
.*        Calculate element wise product of two vectors.
:+        Add up the element products to get dot product.
g         Signum.

Python 3, 196 114 Bytes

r=0
I=list(input())
p=I.index("^")
i=0
for E in I:
 if E.isdigit():r+=int(E)*(p-i)
 i+=1
print('BLR'[(r>0)-(r<0)])

Normaler Code:

total = 0

inp=list(input())
ful_index=inp.index("^")

i=0
for num in inp:
    if num.isdigit(): total += int(num) * (ful_index - i)
    i+=1

print('BLR'[(total>0)-(total<0)])

Erläuterung:

1. Erzeugt eine Liste von Zahlen + den Drehpunkt von stdin.
2. Addiert für jede Zahl den Abstand vom Drehpunkt zu der Variablen zur Gesamtsumme (Zahlen links sind negativ und Zahlen rechts sind positiv).
3. Gibt je nach Ergebnis den richtigen Buchstaben aus (B, wenn er gleich ist, L, wenn er größer als Null ist, und R, wenn er kleiner als Null ist).

Vielen Dank an @ThomasKwa für das Reduzieren von 82 Bytes (mehr als 40%)!

C, 140 139 138 134 100 Bytes

Rückkehr:

• 1 = LINKS
• 2 = AUSGEWOGEN
• 0 = RECHTS

k;main(int x,char**a){char*n=a[1],*g=n;for(;*n^94;++n);for(;*g;++g)k+=(*g&15)*(n-g);return!k?2:k>0;}

Lauf:

./see-saw "11   ^9"
echo $?
2

Wie wir ASCII haben:

SPACE = 0x20
    0 = 0x30 ... 9 = 0x39

Wir bekommen:

0x20 & 0x0f = 0
0x30 & 0x0f = 0
0x31 & 0x0f = 1
0x32 & 0x0f = 2
... etc.

Dann summiere nach Faktor Abstand zu ^.

SpecBAS - 140 Bytes

1 INPUT b$: LET t=0,p=POS("^",b$),l$="RBL"
2 FOR i=1 TO LEN b$
3 IF b$(i) IN ["1" TO "9"] THEN INC t,(p-i)*VAL b$(i)
4 NEXT i
5 TEXT l$(2+SGN t)

tWenn es sich um eine laufende Summe handelt, sind die Werte negativ, wenn die Zeichenposition größer als die Karatposition ist. Am Ende wird angezeigt, ob total negativ, null oder positiv ist, und es wird das entsprechende Zeichen von R, B oder L ausgegeben.

Ich könnte ein paar Bytes weg rasieren, indem ich einfach -1, 0 oder 1 wie einige der anderen Antworten ausgebe.

Java, 83 Bytes

l->{int s=0,l=0;for(char c:l)if(l<1)s-=c-48;else s+=c-48;return s<0?-1:(s>0?1:0));}