왜 시뮬레이터인가?

요즘 아이들은 실제로 시소에 상자를 쌓아 놓거나 물리적 물체의 균형을 잡는 데 시간과 야망이 없습니다. 이것은 소프트웨어 모델에 레버 시뮬레이터를위한 많은 공간을 남겨 둡니다. 레버 시뮬레이터는 내 모델에 따르면 미친 것처럼 판매합니다!

원하는 프로그래밍 도움말

그러한 게임에 대한 특허를 출원 중이지만 (보류 중), 게임 로직을 작성하려면 전문 프로그래머가 필요합니다. 내가 이해 한 바에 따르면 최종 프로그램의 바이트 크기를 기준으로 프로그래머를 보상하는 것이 표준 관행 입니다. 따라서 나는 가장 유리한 입찰자에게이 유리한 계약을 수여 할 것입니다.

사양

레버는 받침으로 균형을 이루는 일련의 상자 또는 빈 공간입니다. 각 상자에는 1 에서 9 까지 의 특정 무게가 있으며 공간에는 무게가 없습니다. 아시다시피, 레버의 상자 무게는 상자가 받침에서 얼마나 떨어져 있는지에 정비례합니다. 4받침점에서 세 번째 공간에있는 무게 상자 12는 레버의 측면에 효과적인 힘의 단위를 제공합니다.

입력 레버가 주어지면 레버가 왼쪽, 오른쪽으로 기울어 지거나 완벽하게 균형을 잡을지 여부를 출력하는 프로그램이 필요합니다.

I / O 지침

• 당신은 나를 위해 프로그램을 작성합니다.
• 입력은 한 줄의 텍스트를 포함합니다.
• 입력은 stdin하나의 명령 행 문자열 에서 나옵니다 .
• 상자는 ' 1'- ' 9' 문자로 표시됩니다 . 이 문자들은 각각의 가중치를 나타냅니다. 빈 공간은 공백 ' ' 으로 표시됩니다 . 받침점은 캐럿 ' ^' 으로 표시됩니다 .

샘플 입력 레버는 다음과 같습니다. 8 2^ 941

이 레버는 완벽하게 균형을 이룹니다 : (4*8) + 0 + 0 + (1*2) == 0 + (2*9) + (3*4) + (4*1) == 34

• 선행 또는 후행 공백이 없습니다. 후행 줄 바꿈이 없습니다.
• 잘못된 입력을 처리 할 필요가 없으며 입력에는 항상 정확히 하나의 받침점이 있고 숫자와 공백 만 있습니다.
• 출력은 레버가 왼쪽, 오른쪽 또는 균형인지를 나타냅니다.
• 프로그램에는 올바른 형식의 입력으로 생성 될 수있는 3 가지 가능한 출력이 있어야합니다. 이것들이 무엇인지 선택할 수 있습니다.
• 출력은 인쇄 stdout되거나 프로그램의 리턴 코드 여야합니다.

테스트 사례

여기 내가 사용 L, R, B균형 왼쪽 무거운 마우스 오른쪽 무거운를 의미합니다 :

1. 입력 : 11 ^9출력 :B

2. 입력 : 321^ 12출력 :L

3. 입력 : 9^ 1출력 :R

(누군가 "trickier"테스트 사례가있는 경우 자유롭게 수정하십시오.)

서지

불필요하게 영감을 얻지 만 시소에 무게 세트 균형 을 잡는 것과 관련이 있습니다.

파이썬 2, 69 바이트

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

계수 ord(c)%16는 공백에 대해 0을 얻는 동안 숫자 문자의 값을 추출합니다. 각 캐릭터에 대해 토크 기여는 가중치를 피벗까지의 서명 된 거리에 곱한 값으로 계산되며 i-s.find('^'),이를 합산하여 0과 비교하여 다음 중 하나를 생성 -1,0,1합니다. 캐릭터의 ^무게는 14로 계산되지만 피벗에 있으므로 중요하지 않습니다.

Maltysen 의 18 바이트 Pyth 포트 :

._s.e*-kxz\^%Cb16z

Python 코드의 경우 전체 프로그램이 필요한 경우 79 바이트입니다. 아이디어는에 i의해 이동 된 인덱스를 시작하고 s.find('^')카운트 다운하는 것입니다.

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

자바 스크립트 ES6, 62 바이트

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

• -1 왼쪽이 더 무겁다면
• 0 균형이 잡힌다면
• 1 오른쪽이 더 무겁다면

언 골프 드 :

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)

테스트 실행 (익명 기능을에 할당 f) :

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

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

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

• -11 바이트 : 출력을 변경 R B L하는-1 0 1
• -3 바이트 : 변경 e.split``에 [...e](감사 @ Vɪʜᴀɴ를)
• -33 바이트 : 피벗에서 분할하는 대신 음수 가중치를 사용하도록 알고리즘을 변경했습니다.
• -9 바이트 : 피벗 검사 제거 (분명히 ...로 ~~'^'평가 0)
• -2 바이트 : 익명으로 함수 작성 (@ cᴏɴᴏʀ-obʀɪᴇɴ 덕분에)

apt , 22 바이트

Japt 는 Ja vaScri pt 의 단축 버전입니다 . 통역사

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

, for 및 for 를 반환 -1합니다 .L0B1R

작동 원리

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 바이트

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

규칙을 다시 읽은 후 9 바이트를 절약하고 -1 0 1대신 출력으로 변경했습니다 L B R.

여기서 사용해보십시오 .

Pyth, 20 바이트

._s*V-Rxz\^Uzm.xsd0z

테스트 스위트

-1왼쪽 바이어스, 0균형, 1오른쪽 바이어스.

작동 방식 :

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

하스켈, 116 96 82 76 바이트

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

출력은 0균형 잡힌, -1왼쪽 및 1오른쪽을위한 것입니다.

사용 예 : f "321^ 12"->-1

작동 방식 : 이전의 부품을 찾으십시오 ^. 입력 문자열과에서 시작하는 가중치 목록을 곱하십시오 - length-of-first-part. 의 ^가중치는 0이며 합계에 추가되지 않습니다. @xnor의 mod 16 트릭 을 사용하여 숫자 / 공백을 정수 값으로 변환합니다. 합이 음수 (양수)이면 레버는 왼쪽 (무거운)이고 합계가 0 인 경우 균형이 조정됩니다.

티 스크립트 , 23 바이트 25

Pyth 답변을 작성하려고 시도했지만 끔찍하게 진행되었습니다.

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

그것은 ²제자리에서 보이지 않지만 1 바이트를 절약하므로 계속 유지할 것입니다.

온라인으로 사용해보십시오!

모든 사례를 테스트

내가 선택한 출력 체계의 경우 :

• -1왼쪽이 오른쪽보다 무거울 경우 ( L)
• 0왼쪽이 오른쪽 ( B) 만큼 무겁다면
• 1왼쪽이 오른쪽보다 덜 무겁습니다 ( R)

Ungolfed && 설명

이것은 맵을 사용하고 작업을 완료하기 위해 줄입니다.

$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 바이트

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

이것은 까다로운 일이었습니다. pb는 이런 종류의 일을 잘하도록 설계되지 않았습니다. 곱셈 조차하지 않습니다 . 그러나 이봐, 작동합니다.

에드 참고 : pb에 곱셈이 없다고 말했습니까? 뭐? pb는 확실히 곱셈을 가지고 있습니다. 나는 이 언어를 디자인하고 구현 했으며, 곱셈 기능이 내장되어 있으며 약간의 반복 추가를 할 필요가 없다는 것을 알아야합니다. 문제를 해결하고 (거의 다른 각도에서 문제의 해당 부분에 접근 할 수 있도록 창의적인 재정렬을 수행하면) 20 바이트가 절약됩니다. 부끄러운.

가장 어려운 부분은 각면에 대해 (중량 * 거리)의 합계를 얻은 후 실제로 인쇄 할 문자를 결정하는 것이 었습니다. PB는 없습니다 >또는 <사업자 단지 ==와 !=. 어떤 값이 더 큰지를 쉽게 알 수있는 방법은 없습니다. 정말 바보 같은 것을하지 않으면 0을 빼고 비교할 수도 없습니다.

• 두 합계의 합을 찾으십시오.
• 아무것도 사용하지 않는 줄에서 오른쪽으로 이동하십시오.
• X = 0에 도달 할 때까지 왼쪽으로 이동하여 'L'을 배치하십시오.
• X = 0에 'B'를 배치하십시오.
• 두 합계의 합으로 왼쪽으로 이동하십시오.
• X = 0에 도달 할 때까지 오른쪽으로 이동하여 'R'을 배치하십시오.

그런 다음 X = (왼쪽-오른쪽)으로 이동하면 답이 있습니다! 해당 줄의 모든 항목을 삭제하여 정리 한 다음 (0, 0)에있는 값을 인쇄하십시오.

...하지만 약간 더 짧은 방법이 있습니다. 'L', 'B'및 'R'을 사용하는 대신, 값 'B'를 사용하고 인쇄시 'B'를 다시 추가하십시오. 그렇게하면 X = 0에 'B'를 배치 할 필요가 없으며 이미 0으로 그대로 두십시오. 유일한 문제는 일단이 작업을 수행하면 프로그램이 시계 모드에서 매우 바보가된다는 것입니다. 'L'-'B'==76-66==10=='\n'. 갑자기 많은 수의 줄 바꿈이 인쇄 될 때까지 모든 것이 올바르게 작동하는 것 같으며 진행 상황을 추적하는 것은 불가능합니다. 콘솔.

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

펄 5, 72 바이트

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

MATLAB 91, 57, 55 옥타브, 50 바이트

더 이상 골프를 기대하지는 않았지만 Octave로 전환하면 5 바이트를 더 절약 할 수있었습니다! 와, 시간이 걸렸어 ...

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

각각 출력 -Inf, NaN, Inf합니다 L, B, R.

테스트 스위트!

설명:

이것은 확실히 읽기 어려운 코드이지만 가능한 한 설명하려고 노력할 것입니다. 코드 블록 설명과 텍스트 사이를 전환하겠습니다.

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

괄호 안에 무슨 일이 일어나는지 봅시다 :

[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

이것은 약간 까다 롭습니다.

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

사다리 양쪽의 숫자는 캐럿과의 거리를 곱해야합니다. 왼쪽에 음수를 사용하고 오른쪽에 양수를 사용하면 벡터를 합하여 어느 쪽이 가장 무거운지를 알 수 있습니다.

입력 문자열이 다음과 같다고 가정하십시오 '321^ 12'. 우리는 다음을 원합니다 : 3*(-3)+2*(-2)+1*(-1)+1*3+2*4. 우리가 대괄호 안에서 만든 벡터는에서 시작하며 1-i,이 경우 -3캐럿은 네 번째 위치에 있기 때문에입니다. 그것은까지가는 nnz(x)-i하나의 단위로. 0을 포함하지 않는 문자열 이기 때문에 nnz(x)대신 사용할 수 있습니다 .numel(s)x

따라서:

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

이제 요소 별 곱셈을 수행 할 수 s.*[...]있습니다. 우리는 두 벡터를 갖고 있기 때문에 그러나, 우리가 할 수도 mutliply s로의 전치 [...]행렬 곱셈을 사용하여 합계를 계산 :

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

이것은 우리에게 왼쪽이 더 무거워 짐을 의미하는 음수, 균형을 의미하는 0, 또는 오른쪽이 더 무거움을 의미하는 postive 수를 제공합니다. 대신 순진한 접근 방식을 사용 sign(...), 우리는 다중이로 inf, 우리 중 하나를 줄 것이다 -Inf또는 Inf왼쪽과 오른쪽으로 각각. 정의되지 않았으므로을 얻 NaN습니다 0*inf.

이것은 우리에게 가능한 세 가지 결과에 대해 세 가지의 뚜렷한 가치를 제공합니다.

𝔼𝕊𝕄𝕚𝕟, 22 자 / 38 바이트

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

Try it here (Firefox only).

자바 스크립트, 146 바이트

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

꽤 방대하다.

데모 .

루비, 111108 바이트

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

설명

각 변의 각 숫자에 대한 가중치를 합산합니다. 그런 다음 루비 우주선 연산자를 사용하여 양측에 1,0 / -1의 동등성 / 비 균등성을 제공합니다. 이는 올바른 출력을 가진 배열의 인덱스입니다.

PowerShell, 83 73 바이트

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

골프를위한 TessellatingHeckler 에게 감사합니다 .

아래의 오래된 코드와 본질적으로 동일한 알고리즘을 사용하지만 여기서는 색인을 반복하지 않고 입력 문자열의 문자를 한 번에 하나씩 반복하여 바이트 수를 절약합니다. 알고리즘이 도달 할 때에도 여전히 동일한 오류 메시지가 표시됩니다 ^. STDOUT에 영향을 미치지 않습니다.

이전

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

Dendrobium의 훌륭한 답변 과 동일한 멋진 알고리즘 을 사용하므로 -1 / 0 / 1입력이 인 경우 와 동일한 출력을 사용합니다 left-heavy / balanced / right-heavy.

어. 긴 때문에 캐스팅의 특질의 PowerShell을 가지고 기능입니다. 여기서 가장 적절한 것은 기능에 char곱하는 방법 int입니다. 객체 의 string결과를 배열 인덱스로 가져옵니다 char. PowerShell은 char곱하기 전에 리터럴 값이 아닌 해당 ASCII 값으로 변환합니다 . 따라서 다음과 같은 $a='012'[0];[int]$a*2결과가 나타납니다 96.

즉, 문자열로 다시 캐스팅해야합니다. 그러나 단순히 string시간을 int내면 string여러 번 반복됩니다. 예를 들어 $a='0';$a*2결과는 다음과 같습니다 00.

이 방법은 우리가 캐스팅 할 필요가 charA와 다시 string하기 전에 재 로 -casting int우리가 우리의 축적에 추가하기 전에, 다음 곱셈이 발생할 수 있습니다 $x.

문자열을 반복하는 긴 방법과 .NET 호출을 사용하여 부호를 출력하면 꽤 긴 코드 조각을 얻을 수 있습니다.

_{NB- ^문자열에 도달하면 으로 변환 할 수 없다는 오류가 발생 합니다 int. STDOUT에 영향을 미치지 않습니다.}

CJam, 29 바이트

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

온라인으로 사용해보십시오

결과는 -1좌중, 0균형, 우중에 1대한 것입니다.

이것은 조금 길어 보였지만 많은 대안을 시도했으며 모두 29 바이트와 33 바이트 사이였습니다. 한 가지 문제는 문자열을 공백으로 자동으로 0이되는 값으로 변환하는 방법을 찾을 수 없다는 것입니다. 그래서 공백을 '0 문자로 명시 적으로 대체하여 코드 길이를 추가합니다.

대안 시도 :

• '^에서 문자열을 분할하고 첫 번째 문자열을 반대로 한 다음 두 가지에 대한 가중치를 계산합니다.
• ee연산자를 사용하여 값 목록에 색인을 추가하십시오.
• 각 인덱스에서 캐럿 위치를 빼는 대신 빼기없이 내적을 계산 한 다음 결과에서 캐럿 위치 시간을 문자열 길이로 뺍니다.

설명:

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 바이트

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

정규 코드 :

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

설명:

1. 에서 받침점 + 받침점 목록을 생성합니다 stdin.
2. 모든 숫자에 대해 받침점에서 숫자와 변수까지의 거리를 총계에 더합니다 (왼쪽 숫자는 음수이고 오른쪽 숫자는 양수입니다).
3. 결과에 따라 올바른 문자를 인쇄합니다 (같으면 B, 0보다 크면 L, 0보다 작 으면 R).

82 바이트 (40 % 이상)를 트리밍 한 @ThomasKwa에게 큰 감사를드립니다!

C, 140 139 138 134 100 바이트

반환:

• 1 = 왼쪽
• 2 = 균형
• 0 = 오른쪽

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

운영:

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

ASCII가있는 것처럼 :

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

우리는 얻는다 :

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

그런 다음 요인 거리를 기준으로 합합니다 ^.

SpecBAS-140 바이트

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)

t누적 합계이고 문자 위치가 캐럿 위치보다 큰 경우 값은 음수입니다. 마지막에 total이 음수인지, 0인지 또는 양수인지 확인하고 해당 문자를 R, B 또는 L로 인쇄합니다.

다른 답변과 마찬가지로 -1, 0 또는 1을 출력하여 몇 바이트를 줄일 수 있습니다.

자바, 83 바이트

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