Neden bir simülatör?

Bugünlerde çocuklar, testere kutularına gidip istifleme veya fiziksel nesneleri dengeleme ile oynamaya hazır değil. Bu, benim modelime göre deli gibi satacak bir Lever Simulator için yazılım pazarında çok fazla yer bırakıyor!

Programlama Yardım Aranıyor

Böyle bir oyun için patent başvurusunda bulundum (beklemede), ancak benim için oyun mantığını yazmak için uzman bir programcıya ihtiyacım var. Anladığım kadarıyla, programcıları nihai programın byte büyüklüğüne göre telafi etmek standart bir uygulamadır . Bu nedenle bu kazançlı sözleşmeyi en düşük teklifi verene vereceğim.

Şartname

Kol, bir dayanak noktası tarafından dengelenen bir dizi kutu veya boş alandır. Her bir kutunun bir ila dokuz arasında bir ağırlığı vardır ve boşlukların ağırlığı yoktur. Bildiğiniz gibi, bir kutunun kol üzerindeki ağırlığı, doğrudan o kutunun dayanak noktası ile orantılıdır. 4Dayanaktan üçüncü boşlukta bulunan bir ağırlık kutusu 12, kolun o tarafına etkili kuvvet birimleri sağlayacaktır .

Bir giriş kolu verildiğinde, kolun sola, sağa doğru ya da mükemmel bir şekilde dengeli olup olmayacağını gösteren bir programa ihtiyacım var.

G / Ç Kuralları

• Benim için bir program yazacaksın.
• Giriş bir satır metin içerecektir.
• Giriş, stdinbir komut satırı dizgisinden veya bir komut dizisi olarak gelecektir .
• Kutular ' 1' ile ' 9' karakterleriyle temsil edilir . Bu karakterler kendi ağırlıklarını temsil eder. Boş bir boşluk bir boşlukla gösterilecektir ' '. Dayanak noktası bir ' ^' şapka 'ile temsil edilecektir .

Bir örnek giriş kolu şöyle görünebilir: 8 2^ 941

Bu kol mükemmel dengelenmiş: (4*8) + 0 + 0 + (1*2) == 0 + (2*9) + (3*4) + (4*1) == 34

• Önde gelen ve takip eden boşluklar olmayacak. Sonunda yeni bir satır olmayacak.
• Hatalı biçimlendirilmiş girişi kullanmaya gerek yok, giriş her zaman tam olarak bir dayanak noktasına ve sadece sayı ve boşluklara sahip olacaktır.
• Çıktı, kolun sol ağır mı, sağ ağır mı yoksa dengeli mı olduğunu gösterir.
• Programınız, iyi biçimlendirilmiş bir girdiden kaynaklanabilecek tam olarak 3 olası çıktıya sahip olmalıdır. Bunların ne olduğunu seçebilirsiniz.
• Çıktı stdout, programın dönüş koduna yazdırılmalı veya yazdırılmalıdır .

Test durumları

Burada kullandığım L, R, Bdengeli sol ağır, sağ ağır, demek:

1. Giriş: 11 ^9Çıkış:B

2. Giriş: 321^ 12Çıkış:L

3. Giriş: 9^ 1Çıkış:R

(Bazılarında "zorlayıcı" test durumları varsa, bunları düzenlemek için çekinmeyin).

Kaynakça

Değil-ille-by-inspired, bunlarla ilgili bir tahterevalli Denge ağırlıkları kümesi

Python 2,69 bayt

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

Modül ord(c)%16, boşluk için 0 alırken basamak karakterinin değerini alır. Her karakter için tork katkısı, pivotun işaretli mesafesinin ağırlığının çarpı çarpımı olarak hesaplanır i-s.find('^')ve bunlardan biri toplanarak 0 ile karşılaştırılır -1,0,1. Karakterin ^ağırlığı 14 olacak şekilde hesaplandı, ancak önemli değil, çünkü üzerinde.

Bir 18-bayt Pyth portu Maltysen tarafından:

._s.e*-kxz\^%Cb16z

Python kodu için, eğer tam bir program gerekiyorsa, işte 79 bayt. Fikir endeksi başlamaktır ikaymış s.find('^')ve aşağı saymak gerekir.

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 Bayt

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

• -1 sol ağır ise
• 0 eğer dengelenmişse
• 1 eğer hak ağırsa

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)

Test çalıştırması (anonim işlev atama f):

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

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

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

• -11 bayt: çıktı değiştirildi R B Liçin-1 0 1
• -3 bayt: değiştirilebilir e.split``için [...e](sayesinde @ Vɪʜᴀɴ)
• -33 bayt: pivotta bölmek yerine negatif ağırlıkları kullanmak için algoritmayı değiştirdi
• -9 bayt: kaldırıldı pivot kontrolü (görünüşe göre, ... olarak ~~'^'değerlendirilir 0)
• -2 bayt: işlevi anonim hale getirdi (thanks @ cᴏɴᴏʀ-obʀɪᴇɴ)

Japt , 22 bayt

Japt kısaltılmış versiyonudur Ja vaScri nk . yorumlayıcı

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

-1İçin L, 0için Bve 1için döndürür R.

Nasıl çalışır

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 bayt

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

Kuralları yeniden okuduktan sonra, bunu dokuz bayttan tasarruf ettirmek -1 0 1yerine çıktı olarak değiştirdim L B R.

Burada dene .

Pyth, 20 bayt

._s*V-Rxz\^Uzm.xsd0z

Test odası

-1sol önyargılı, 0dengeli, 1sağ önyargılı.

Nasıl çalışır:

._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 bayt

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

Çıktı 0dengeli, -1sol ağır ve 1sağ ağır için.

Kullanım örneği: f "321^ 12"->-1

Nasıl çalışır: önce parçasını bulun ^. Giriş dizesini ve başlayan ağırlık listesini çarpın - length-of-first-part. ^0 bir ağırlığa sahiptir ve toplamına eklemez. Rakamları / boşlukları tamsayı değerlerine dönüştürmek için @ xnor'ın mod 16 numarası kullanıyorum. Toplam negatifse (pozitif), kaldıraç sol ağırdır (sağ ağır) ve toplam 0 ise dengelidir.

TeaScript , 23 bayt 25

Pyth cevabı yazmayı denedim ama bu korkunç bir şekilde gitti: \

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

Bu ²çok yerde görünüyor ama 1 bayt kazandırıyor, ben de saklıyorum.

Çevrimiçi deneyin!

Tüm vakaları test et

Seçtiğim çıktı şeması için:

• -1Sol Sağ'dan daha ağır ise ( L)
• 0Sol, Sağ ( B) kadar ağırsa
• 1Sol Sağ'dan daha az ağırdır ( R)

Ungolfed ve Açıklama

Bu, işleri yapmak için haritaları kullanır ve azaltır.

$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 bayt

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

Bu çok zordu. pb bu tür şeylerde iyi olacak şekilde tasarlanmamıştır. Çarpma bile yok . Ama hey, işe yarıyor.

Ed. not: Az önce pb'nin çarpımı olmadığını mı söyledim? Ne? pb kesinlikle kesinlikle çarpma özelliğine sahip. Ben tasarlanmış ve uygulamaya Ben çarpma inşa bilmelidir ki ve bazı saçma ilmekli ek yapmak gerekmez, bu dili. Bunu düzeltmek (şimdi problemin bu kısmına (neredeyse kelimenin tam anlamıyla) farklı bir açıdan yaklaşabilmem için bazı yaratıcı yeniden düzenlemeler yapmak) bana 20 byte kazandırıyor. Utandırıcı.

En zor kısım, her bir taraf için toplam ağırlığı (ağırlık * mesafe) aldıktan sonra, gerçekte hangi mektubun yazdırılacağını belirlemekti. pb yok >ya da <operatörleri, sadece ==ve !=. Hangi değerin daha büyük olduğunu söylemenin kolay bir yolu yok. Gerçekten saçma sapan bir şey yapmazsam, 0 çıkarıp 0 ile kıyaslayamam bile.

• İki toplamın toplamını bulun.
• O kadar sağa git, hiçbir şey için kullanılmayan bir çizgide.
• X = 0'a ulaşana kadar sola dönün ve 'L's'i yerleştirin.
• X = 0'a bir 'B' yerleştirin.
• İki toplamın toplamı tarafından sola gidin.
• X = 0'a ulaşana kadar sağa dönün ve 'R's'i yerleştirin.

Sonra, sadece X = 'e gidersiniz (sol - sağ taraf) ve cevabınız burada! Temizlemek için bu satırdaki her şeyi silin ve ardından (0, 0) konumunda bulunan değeri yazdırın.

... Ama biraz daha kısa bir yol var. 'L', 'B' ve 'R' yerine, bu değerleri kullanın - 'B' ve yazdırırken tekrar 'B' ekleyin. Bu şekilde, 'B' yi X = 0'a koymak zorunda değilsiniz, sadece olduğu gibi bırakın. Tek sorun, bunu bir kez yaptığınızda, programın izleme modunda oldukça kabarık hale gelmesidir. 'L'-'B'==76-66==10=='\n'. Her şey yolunda görünüyor, aniden çok sayıda yeni satır yazdırılıncaya ve neler olup bittiğini takip etmek imkansız: D pbi'nin normal uygulama modunda, her şey yolunda gidiyor çünkü yeni satırlar herhangi bir şey yazdırılmadan önce siliniyor konsolu.

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

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

MATLAB 91, 57, 55 Octave, 50 bayt

Daha fazla golf oynamayı beklemiyordum, ancak Octave'ye geçmek 5 ek bayttan tasarruf etmeyi mümkün kıldı! Vay, bu zaman aldı ...

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

Bu çıktılar -Inf, NaN, Infiçin L, B, Rsırasıyla.

Test odası!

Açıklama:

Bu kesinlikle okunması zor bir kod, ancak elimden geldiğince açıklamaya çalışacağım. Kod bloğu açıklaması ile metin arasında geçiş yapacağım.

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

Parantezlerin içinde neler olup bittiğine bakalım:

[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

Bu biraz zor:

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

Merdivenin her iki tarafındaki sayılar, şapkadan uzaklaştıkça çarpılmalıdır. Sol taraftaki negatif sayıları ve sağ taraftaki pozitif sayıları kullanırsak, hangi tarafın en ağır olduğunu görmek için vektörü toplayabiliriz.

Giriş dizesinin: olduğunu varsayalım '321^ 12'. Biz aşağıdakileri istiyorum: 3*(-3)+2*(-2)+1*(-1)+1*3+2*4. Parantezler içinde yaptığımız vektör 1-i, bu durumda, -3şapka dördüncü konumda olduğu için başlar. Bir nnz(x)-iartışlarla artar. nnz(x)Bunun yerine kullanabiliriz numel(s), çünkü xsıfır içermeyen bir dizedir.

Bu nedenle:

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

Şimdi element şeklinde çarpma yapabilir s.*[...]ve bunun toplamını alabiliriz. Ancak, iki vektörümüz olduğundan s, [...]matris çarpımını kullanarak toplamı çevirerek ve hesaplayarak da karşılıklı olarak yapabiliriz :

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

Bu bize ya negatif bir sayı verir, yani sol taraf daha ağır, sıfır, dengeli demektir, ve bir pozitif sayı, sağ taraf daha ağırdır. Yerine naif bir yaklaşım kullanarak sign(...), biz çarpın o tarafından inf, bize ya verecektir hangi -Infveya Infsola ve sağa sırasıyla. Tanımlanamadığı NaNiçin aldık 0*inf.

Bu bize üç olası sonuç için üç farklı değer verir.

𝔼𝕊𝕄𝕚𝕟, 22 karakter / 38 bayt

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

Try it here (Firefox only).

JavaScript, 146 bayt

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

Oldukça büyük.

Demo .

Ruby, 111 108 bayt

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

açıklama

Her iki taraftaki her sayının ağırlıklı değerini toplar. Daha sonra, yakut uzay gemisi operatörünü kullanarak, iki tarafın 1,0, -1 eşitlik / eşitsizliğini sağlar, ki bu da doğru çıktılı bir dizinin indeksidir.

PowerShell, 83 73 Bayt

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

Golf için TessellatingHeckler'e teşekkürler .

Temelde aşağıdaki eski kodla aynı algoritmayı kullanır, ancak burada bir avuç bayt tasarrufu sağlayan indeks boyunca yinelemekten ziyade giriş dizisindeki karakterleri teker teker yineleriz. Algoritma ulaştığında hala aynı muhteşem hata mesajı atıyor ^- STDOUT etkilemez.

Önceki

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

Dendrobium mükemmel aynı müthiş bir algoritma kullanır cevap ve böylece aynı çıktıyı kullanan -1 / 0 / 1girdi ise left-heavy / balanced / right-heavy.

Ugh. Uzun zamandır PowerShell'in sahip olduğu bir tuhaflık özelliği yüzünden. Burada en önemlisi char, intfonksiyonlarla nasıl çarpıldığıdır . stringBir charnesnede sonuçların dizi dizini alınması . PowerShell, çarpmadan önce charkarşılık gelen ASCII değerine (değişmez değer yerine) dönüştürür. Böylece, bunun gibi bir şey $a='012'[0];[int]$a*2sonuçlanır 96.

Bu, onu bir dize olarak tekrar kullanmamız gerektiği anlamına gelir. Ancak, basitçe stringzamanları yapmak intbize stringbirçok kez tekrarlanan bir şey verir . Örneğin, $a='0';$a*2sonuçlanır 00.

Bunun anlamı, yeniden yayınlamadan önce chargeri gibi dökmemiz gerektiğidir; bu durumda akümülatörümüze eklemeden önce çarpma olabilir .stringint$x

Bunu bir dize ile yineleme yapmak için uzun bir yol ve işareti çıkarmak için .NET çağrısı yapın ve oldukça uzun bir kod parçası elde ederiz.

_{Not - Bu ^, dizgeye ulaştığında göze çarpan bir hatayı fırlatıp , dönüştürmeyeceğini belirtir int. STDOUT'u etkilemez.}

CJam, 29 bayt

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

Çevrimiçi deneyin

Sonuç -1sol ağır, 0dengeli 1ve sağ ağır içindir.

Bu biraz uzun gözüküyordu, ama bir sürü alternatif denedim ve hepsi de 29 ila 33 bayt arasında bitmişti. Bir sorun, dizgiyi boşluklar için otomatik olarak 0 ile sonuçlanacak değerlere dönüştürmenin bir yolunu bulamamamdı. Bu yüzden, boşlukları açıkça kodun uzunluğuna ekleyen '0 karakter ile değiştirdim.

Denenen alternatifler:

• Dize '^' de bölmek, ilkini ters çevirmek ve sonra her ikisi için de ağırlıklı değeri hesaplamak.
• eeDizini değerler listesine eklemek için operatörün kullanılması .
• Çizgi dizisini her dizinden çıkarmak yerine, nokta ürününü çıkarmadan hesaplayın ve sonra çizgi dizisi çarpı çarpı uzunluğunu sonuçtan çıkarın.

Açıklama:

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 bayt

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

Düzenli 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)])

Açıklama:

1. Sayıların + dayanak noktasının bir listesini oluşturur stdin.
2. Her sayı için, dayanak noktadan sayıyı değişkenin toplamına kadar olan mesafeyi ekler (soldaki sayılar negatif olur ve sağdaki sayılar pozitif olur).
3. Sonuca bağlı olarak doğru harfi yazdırır (eşit ise B, sıfırdan büyükse L ve sıfırdan düşükse R).

82 byte (% 40'dan fazla) indirim için @ThomasKwa'ya çok teşekkürler!

C, 140 139 138 134 100 bayt

Dönüş:

• 1 = SOL
• 2 = DENGELİ
• 0 = SAĞ

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

Çalıştırmak:

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

ASCII’ye sahip olduğumuz gibi:

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

Biz alırız:

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

Sonra faktör mesafesine göre toplamı ^.

SpecBAS - 140 bayt

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)

ttoplam çalışan, karakter konumu ayar noktasından fazla olduğunda değerler negatif olur. Sonunda toplamın negatif, sıfır mı pozitif mi olduğunu görür ve karşılık gelen R, B veya L karakterini yazdırır.

Diğer cevapların bazıları gibi -1, 0 veya 1 çıktısı alarak birkaç byte'ı tıraş edebilirim.

Java, 83 bayt

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