Dlaczego symulator?

Dzieci w dzisiejszych czasach nie mają czasu ani ambicji, aby chodzić i układać pudełka na pilarce lub bawić się równoważeniem przedmiotów fizycznych. To pozostawia wiele miejsca na rynku oprogramowania dla Lever Simulator, który według moich modeli będzie sprzedawać się jak szalony!

Potrzebna pomoc w programowaniu

Złożyłem patent na taką grę (w toku), ale potrzebuję specjalistycznego programisty, aby napisał dla mnie logikę gry. Z mojego zrozumienia, standardową praktyką jest kompensowanie programistów na podstawie wielkości w bajtach końcowego programu. W związku z tym zawrę ten lukratywny kontrakt z najniższą ceną.

Specyfikacja

Dźwignia to seria pudeł lub pustych przestrzeni, które są zrównoważone przez punkt podparcia. Każde pudełko ma określoną wagę od jednego do dziewięciu, a spacje nie mają wagi. Jak wiadomo, ciężar pudełka na dźwigni jest wprost proporcjonalny do odległości tego pudełka od punktu podparcia. Skrzynia ciężaru, 4która znajduje się na trzecim polu od punktu podparcia, wniesie 12skuteczne jednostki siły do ​​tej strony dźwigni.

Potrzebuję programu, który, biorąc pod uwagę dźwignię wejściową, wyświetli, czy dźwignia będzie przechylać się w lewo, w prawo, czy będzie idealnie wyważona.

Wytyczne I / O

• Napisz mi program.
• Dane wejściowe będą zawierać jeden wiersz tekstu.
• Dane wejściowe będą pochodzić z stdinlub jako jeden ciąg wiersza polecenia.
• Pola będą reprezentowane przez znaki 1„do 9”. Te postacie reprezentują ich wagi. Puste miejsce będzie reprezentowane przez spację ' '. Punkt podparcia będzie reprezentowany przez karetkę ' ^'.

Przykładowa dźwignia wprowadzania może wyglądać następująco: 8 2^ 941

Ta dźwignia jest idealnie wyważona: (4*8) + 0 + 0 + (1*2) == 0 + (2*9) + (3*4) + (4*1) == 34

• Nie będzie spacji wiodących ani końcowych. Nie będzie końca nowej linii.
• Nie trzeba obsługiwać źle sformułowanych danych wejściowych, dane wejściowe zawsze będą miały dokładnie jeden punkt podparcia, a jedynie liczby i spacje.
• Dane wyjściowe wskażą, czy dźwignia jest ciężka w lewo, prawa w prawo, czy zrównoważona.
• Twój program musi mieć dokładnie 3 możliwe wyniki, które mogą wynikać z dobrze sformułowanego wejścia. Możesz wybrać, jakie to są.
• Dane wyjściowe muszą być wydrukowane stdoutlub być kodem zwrotnym programu.

Przypadki testowe

Tutaj używam L, R, Boznacza lewy ciężki prawym ciężki, zbilansowany:

1. Wejście: 11 ^9Wyjście:B

2. Wejście: 321^ 12Wyjście:L

3. Wejście: 9^ 1Wyjście:R

(Jeśli ktoś ma jakieś „trudniejsze” przypadki testowe, możesz je edytować).

Bibliografia

Niekoniecznie zainspirowany, ale związany z Równowagą zestawu ciężarów na huśtawce

Python 2, 69 bajtów

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

Moduł ord(c)%16wyodrębnia wartość znaku cyfry, otrzymując 0 dla spacji. Dla każdego znaku jego udział momentu obrotowego jest obliczany jako waga razy iloczyn oznaczonej odległości do osi obrotu i-s.find('^'), a następnie są one sumowane i porównywane z 0, dając jeden z nich -1,0,1. ^Obliczona postać ma wagę 14, ale to nie ma znaczenia, ponieważ znajduje się na osi obrotu.

18-bajtowy Pyth portu przez Maltysen:

._s.e*-kxz\^%Cb16z

W przypadku kodu Python, jeśli wymagany jest pełny program, oto 79 bajtów. Chodzi o to, aby rozpocząć iprzesunięcie indeksu s.find('^')i pozwolić mu odliczać.

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 bajty

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

• -1 jeśli pozostawiony jest cięższy
• 0 jeśli zrównoważony
• 1 jeśli prawo jest cięższe

Nie golfowany:

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)

Uruchamianie testowe (przypisywanie funkcji anonimowej f):

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

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

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

• -11 bajtów: zmieniono wyjście z R B Lna-1 0 1
• -3 bajty: zmieniono e.split``na [...e](dzięki @ Vɪʜᴀɴ)
• -33 bajtów: zmieniono algorytm, aby zamiast ujemnego podziału używać podziałek
• -9 bajtów: usunięto kontrolę obrotu (najwyraźniej ~~'^'ocenia na 0...)
• -2 bajty: uczyniono funkcję anonimową (dzięki @ cᴏɴᴏʀ-obʀɪᴇɴ)

Japt , 22 bajty

Japt to skrócona wersja Ja vaScri pt . Interpretator

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

Zwraca -1za L, 0za Bi 1za R.

Jak to działa

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 bajtów

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

Po ponownym przeczytaniu reguł zmieniłem to na wyjście -1 0 1zamiast L B R, oszczędzając dziewięć bajtów.

Wypróbuj tutaj .

Pyth, 20 bajtów

._s*V-Rxz\^Uzm.xsd0z

Zestaw testowy

-1dla stronniczości z lewej strony, 0dla równowagi, 1dla stronniczości z prawej strony.

Jak to działa:

._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 bajtów

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

Wyjście jest 0dla zbalansowanego, -1dla lewych ciężkich i 1dla prawych ciężkich.

Przykład użycia: f "321^ 12"->-1

Jak to działa: znajdź część przed ^. Pomnóż ciąg wejściowy i listę wag, które zaczynają się od - length-of-first-part. ^Ma masę równą 0 i nie dodawać do sumy. Używam sztuczki mod @ xnor 16 do konwersji cyfr / spacji na wartości całkowite. Jeśli suma jest ujemna (dodatnia), dźwignia jest ciężka w lewo (prawa-ciężka) i zrównoważona, jeśli suma wynosi 0.

TeaScript , 23 bajty 25

Próbowałem napisać odpowiedź w języku Pyth, ale poszło to okropnie: \

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

To ²wygląda tak nie na miejscu, ale pozwala zaoszczędzić 1 bajt, więc go zatrzymam.

Wypróbuj online!

Przetestuj wszystkie przypadki

Do schematu wyjściowego wybrałem:

• -1jeśli lewy jest cięższy niż prawy ( L)
• 0jeśli lewy jest tak ciężki jak prawy ( B)
• 1jest lewy jest mniej ciężki niż prawy ( R)

Niegolfowane i objaśnienia

Używa map i zmniejsza, aby wykonać zadanie.

$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 bajtów

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

To było trudne. PB nie został zaprojektowany, aby być dobrym w tego typu rzeczach. Nie ma nawet mnożenia . Ale hej, to działa.

Ed. Uwaga: Czy właśnie powiedziałem, że pb nie ma mnożenia? Co? pb zdecydowanie ma mnożenie. I zaprojektowany i wdrożony ten język, należy wiedzieć, że został zbudowany w mnożenie i nie muszę robić jakieś głupie zapętlone dodatek. Naprawienie tego (podobnie jak kreatywne przestawienie, kiedy mogłem podejść do tej części problemu z [prawie dosłownie] innego kąta) oszczędza mi 20 bajtów. Żenujący.

Najtrudniejszą częścią było, po uzyskaniu sum (waga * odległość) dla każdej strony, w rzeczywistości określenie, którą literę wydrukować. PB nie ma >ani <operatorów, tylko ==i !=. Nie ma łatwego sposobu na określenie, która wartość jest większa. Nie mogę nawet odjąć i porównać z 0 ... chyba że zrobię coś naprawdę głupiego.

• Znajdź sumę dwóch sum.
• Idź tak daleko w prawo, na linii, która do niczego nie jest używana.
• Aż do osiągnięcia X = 0, idź w lewo i umieść „L”.
• Umieść „B” na X = 0.
• Idź w lewo o sumę dwóch sum.
• Aż do osiągnięcia X = 0, idź w prawo i umieść 'R's.

Następnie po prostu przejdź do X = (lewa strona - prawa strona) i tam jest twoja odpowiedź! Usuń wszystko w tym wierszu, aby wyczyścić, a następnie wydrukuj wartość znalezioną w (0, 0).

... Ale jest nieco krótsza droga. Zamiast używać „L”, „B” i „R”, użyj tych wartości - „B” i dodaj ponownie „B” podczas drukowania. W ten sposób nie musisz nigdy ustawiać „B” na X = 0, po prostu pozostawiasz ją jako 0, którą już było. Jedynym problemem jest to, że po wykonaniu tej czynności program staje się bardzo głupi w trybie zegarka. 'L'-'B'==76-66==10=='\n'. Wydaje się, że wszystko działa dobrze, dopóki nagle nie wydrukowano ogromnej liczby nowych linii i nie można śledzić, co się dzieje: D W zwykłym trybie wykonywania pbi wszystko działa jednak dobrze, ponieważ nowe linie są usuwane, zanim cokolwiek zostanie wydrukowane na konsola.

^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 bajtów

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

MATLAB 91, 57, 55 Oktawa, 50 bajtów

Nie spodziewałem się grać w golfa dalej, ale przejście na Octave pozwoliło zaoszczędzić 5 dodatkowych bajtów! Wow, ten zajął trochę czasu ...

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

Wysyła go -Inf, NaN, Infdo L, B, Rodpowiednio.

Zestaw testowy!

Wyjaśnienie:

Jest to z pewnością trudny do odczytania kod, ale postaram się wyjaśnić najlepiej, jak potrafię. Będę przełączać się między objaśnieniem bloku kodu a tekstem.

@(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    

Spójrzmy na to, co dzieje się w nawiasach:

[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

Ten jest nieco trudny:

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

Liczby po każdej stronie drabiny należy pomnożyć przez odległość od karetki. Jeśli użyjemy liczb ujemnych po lewej stronie, a liczb dodatnich po prawej stronie, możemy po prostu zsumować wektor, aby zobaczyć, która strona jest najcięższa.

Załóżmy, że ciąg wejściowy jest: '321^ 12'. Chcemy, co następuje: 3*(-3)+2*(-2)+1*(-1)+1*3+2*4. Wektor, który wykonaliśmy w nawiasach, zaczyna się od 1-i, czyli w tym przypadku -3, ponieważ daszek znajduje się na 4 pozycji. Idzie nnz(x)-iw krokach co jeden. Możemy użyć nnz(x)zamiast numel(s), ponieważ xjest to ciąg nie zawierający zer.

W związku z tym:

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

Teraz możemy dokonać mnożenia elementarnego s.*[...]i zsumować to. Ale ponieważ mamy dwa wektory, możemy również mutliply sprzez transponowanie [...]i obliczenie sumy za pomocą mnożenia macierzy:

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

To daje nam albo liczbę ujemną, co oznacza, że ​​lewa strona jest cięższa, zero, co oznacza, że ​​jest wyważona, lub liczby dodatnie, co oznacza, że ​​prawa strona jest cięższa. Zamiast naiwnego podejścia sign(...)pomnożymy to inf, co da nam albo, -Infalbo Infodpowiednio lewą i prawą. Otrzymujemy NaNza 0*inf, ponieważ jest niezdefiniowany.

To daje nam trzy różne wartości dla trzech możliwych wyników.

𝔼𝕊𝕄𝕚𝕟, 22 znaki / 38 bajtów

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

Try it here (Firefox only).

JavaScript, 146 bajtów

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')}

Całkiem masywne.

Demo .

Rubin, 111 108 bajtów

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

Wyjaśnienie

Podsumowuje ważoną wartość każdej liczby z każdej strony. Następnie używa rubinowego operatora statku kosmicznego, aby zapewnić 1,0, -1 równości / nierówności dwóch stron, która jest indeksem tablicy z poprawnym wyjściem.

PowerShell, 83 73 bajtów

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

Dzięki TessellatingHeckler dla golfa.

Używa zasadniczo tego samego algorytmu, co poniższy starszy kod, ale tutaj iterujemy kolejno znaki w ciągu wejściowym zamiast iteracji przez indeks, który oszczędza garść bajtów. Nadal wyświetla ten sam spektakularny komunikat o błędzie, gdy algorytm osiąga ^- nie wpływa na STDOUT.

Poprzedni

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

Używa tego samego niesamowitego algorytmu, co doskonała odpowiedź Dendrobium , a zatem używa tego samego wyjścia, -1 / 0 / 1jeśli wejściowy left-heavy / balanced / right-heavy.

Ugh. Długo z powodu dziwnej funkcji rzutowania, którą posiada PowerShell. Najbardziej istotne jest tutaj charpomnożenie przez intfunkcje. Biorąc indeks tablicy stringwyników w charobiekcie. PowerShell konwertuje na charodpowiednią wartość ASCII (zamiast dosłownie) przed pomnożeniem. Więc coś $a='012'[0];[int]$a*2w tym skutkuje 96.

Oznacza to, że musimy ponownie rzucić go z powrotem jako ciąg. Jednak samo robienie stringczasów intdaje nam stringtyle razy. Na przykład $a='0';$a*2spowodowałoby 00.

Oznacza to, że musimy rzucić chartylną część stringprzed ponownym rzutowaniem, ponieważ intwtedy może nastąpić zwielokrotnienie, zanim dodamy go do naszego akumulatora $x.

Połączmy to z długim sposobem iteracji po łańcuchu i wywołaniem .NET w celu wyprowadzenia znaku, a otrzymamy dość długi fragment kodu.

_{NB - Spowoduje to spektakularny błąd, gdy dojdzie ^do łańcucha, stwierdzając, że nie można go przekonwertować na int. Nie wpływa na STDOUT.}

CJam, 29 bajtów

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

Wypróbuj online

Wynik jest -1dla lewych ciężkich, 0dla zrównoważonych, 1dla prawych ciężkich.

Wydawało się to nieco długie, ale wypróbowałem kilka alternatywnych rozwiązań, które skończyły od 29 do 33 bajtów. Jednym z problemów jest to, że nie mogłem znaleźć sposobu na konwersję łańcucha na wartości, które automatycznie spowodowałyby 0 dla spacji. Skończyłem więc jawnie, zastępując spacje znakami „0”, co oczywiście zwiększa długość kodu.

Wypróbowane alternatywy:

• Dzielenie ciągu na ^, odwrócenie pierwszego, a następnie obliczenie ważonej wartości dla obu.
• Za pomocą eeoperatora dodaj indeks do listy wartości.
• Zamiast odejmować pozycję karetki od każdego indeksu, oblicz wynik iloczynu bez odejmowania, a następnie odejmij od wyniku pozycję karetki razy długość łańcucha.

Wyjaśnienie:

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 bajtów

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

Zwykły kod:

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

Wyjaśnienie:

1. Generuje listę liczb + punkt podparcia z stdin.
2. Dla każdej liczby dodaje odległość od punktu podparcia razy liczbę do zmiennej do sumy (liczby po lewej będą ujemne, a liczby po prawej będą dodatnie).
3. Drukuje poprawną literę w zależności od wyniku (B, jeśli jest równy, L, jeśli jest większy od zera, i R, jeśli jest mniejszy niż zero).

Ogromne podziękowania dla @ThomasKwa za przycinanie 82 bajtów (ponad 40%) taniej!

C, 140 139 138 134 100 100 bajtów

Powrót:

• 1 = LEWY
• 2 = ZRÓWNOWAŻONY
• 0 = PRAWO

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

Biegać:

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

Jak mamy ASCII:

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

Otrzymujemy:

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

Następnie sumuj według współczynnika odległości do ^.

SpecBAS - 140 bajtów

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)

tjest sumą bieżącą, wartości są ujemne, gdy pozycja postaci jest większa niż pozycja karat. Na końcu sprawdza, czy suma jest ujemna, zero lub dodatnia i wypisuje odpowiedni znak R, B lub L.

Mógłbym ogolić kilka bajtów po prostu wypisując -1, 0 lub 1, jak niektóre inne odpowiedzi.

Java, 83 bajty

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));}