Tại sao là Trình mô phỏng?

Trẻ em ngày nay không có thời gian cũng không có tham vọng thực sự đi và xếp các hộp lên cưa hoặc chơi xung quanh với các vật thể cân bằng. Điều này để lại rất nhiều chỗ trong thị trường phần mềm cho Lever Simulator, theo mô hình của tôi, sẽ bán như điên!

Trợ giúp lập trình

Tôi đã nộp bằng sáng chế cho một trò chơi như vậy (đang chờ xử lý), nhưng cần một lập trình viên chuyên gia để viết logic trò chơi cho tôi. Theo hiểu biết của tôi, đó là thông lệ tiêu chuẩn để bù cho các lập trình viên dựa trên kích thước tính theo byte của chương trình cuối cùng. Như vậy tôi sẽ trao hợp đồng béo bở này cho người trả giá thấp nhất.

Đặc điểm kỹ thuật

Đòn bẩy là một loạt các hộp hoặc khoảng trống được cân bằng bởi một điểm tựa. Mỗi hộp có trọng lượng riêng từ một đến chín và không gian không có trọng lượng. Như bạn đã biết, trọng lượng của một hộp trên đòn bẩy tỷ lệ thuận với khoảng cách của hộp đó đến điểm tựa. Một hộp trọng lượng 4nằm trên không gian thứ ba từ điểm tựa sẽ đóng góp 12các đơn vị lực hiệu quả cho phía bên kia của đòn bẩy.

Tôi cần một chương trình, được đưa ra một đòn bẩy đầu vào, sẽ đưa ra liệu đòn bẩy sẽ nghiêng về bên trái, bên phải hay được cân bằng hoàn hảo.

Hướng dẫn I / O

• Bạn sẽ viết cho tôi một chương trình.
• Đầu vào sẽ chứa một dòng văn bản.
• Đầu vào sẽ đến từ stdinhoặc dưới dạng một chuỗi dòng lệnh.
• Các hộp sẽ được đại diện bởi các ký tự ' 1' thông qua ' 9'. Những nhân vật này đại diện cho trọng lượng tương ứng của họ. Một không gian trống sẽ được biểu thị bằng một khoảng trắng ' '. Điểm tựa sẽ được đại diện bởi một dấu mũ ' ^'.

Một đòn bẩy đầu vào mẫu có thể trông giống như: 8 2^ 941

Đòn bẩy này hoàn toàn cân bằng: (4*8) + 0 + 0 + (1*2) == 0 + (2*9) + (3*4) + (4*1) == 34

• Sẽ không có không gian hàng đầu cũng như dấu. Sẽ không có dòng mới.
• Không cần xử lý đầu vào không đúng định dạng, đầu vào sẽ luôn có chính xác một điểm tựa và chỉ có số và khoảng trắng.
• Đầu ra sẽ cho biết liệu đòn bẩy là trái nặng, nặng phải hay cân bằng.
• Chương trình của bạn phải có chính xác 3 đầu ra có thể có thể xuất phát từ đầu vào được định dạng tốt. Bạn có thể chọn những gì đang có.
• Đầu ra phải được in stdouthoặc là mã trả về của chương trình.

Các trường hợp thử nghiệm

Ở đây tôi sử dụng L, R, Bnghĩa là trái nặng, phải nặng, cân:

1. Đầu vào: 11 ^9Đầu ra:B

2. Đầu vào: 321^ 12Đầu ra:L

3. Đầu vào: 9^ 1Đầu ra:R

(Nếu bất cứ ai có một số trường hợp thử nghiệm "phức tạp hơn", vui lòng chỉnh sửa chúng trong).

Thư mục

Không nhất thiết phải lấy cảm hứng từ, nhưng liên quan đến Cân bằng một tập các trọng số trên bập bênh

Python 2, 69 byte

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

Mô-đun ord(c)%16trích xuất giá trị của một ký tự chữ số trong khi lấy 0 cho không gian. Đối với mỗi ký tự, đóng góp mô-men xoắn của nó được tính bằng trọng lượng của nó nhân với khoảng cách đã ký với trục i-s.find('^'), và chúng được tính tổng và so sánh với 0, tạo ra một trong số đó -1,0,1. Nhân vật ^được tính toán có trọng lượng 14, nhưng điều đó không thành vấn đề vì nó nằm trên trục.

Một 18-byte cổng Pyth bởi Maltysen:

._s.e*-kxz\^%Cb16z

Đối với mã Python, nếu cần một chương trình đầy đủ, đây là 79 byte. Ý tưởng là bắt đầu chỉ số ithay đổi s.find('^')và đếm ngược lại.

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 byte

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

• -1 nếu trái nặng hơn
• 0 nếu cân bằng
• 1 nếu đúng thì nặng hơn

Ung dung:

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)

Chạy thử (gán chức năng ẩn danh cho f):

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

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

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

• -11 byte: đầu ra thay đổi từ R B Lthành-1 0 1
• -3 byte: được đổi e.split``thành [...e](cảm ơn @ Vɪʜᴀɴ)
• -33 byte: thuật toán đã thay đổi để sử dụng trọng số âm thay vì chia tách tại trục
• -9 byte: đã loại bỏ kiểm tra trục (rõ ràng, ~~'^'ước tính thành 0...)
• -2 byte: thực hiện chức năng ẩn danh (cảm ơn @ cᴏɴᴏʀ-obʀɪᴇɴ)

Japt , 22 byte

Japt là phiên bản rút gọn của Ja vaScri pt . Thông dịch viên

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

Trả về -1cho L, 0cho Bvà 1cho R.

Làm thế nào nó hoạt động

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 byte

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

Sau khi đọc lại các quy tắc, tôi đã thay đổi điều này thành đầu ra -1 0 1thay vì L B R, tiết kiệm chín byte.

Hãy thử nó ở đây .

Bình thường, 20 byte

._s*V-Rxz\^Uzm.xsd0z

Bộ kiểm tra

-1cho thiên vị trái, 0cho cân bằng, 1cho thiên vị phải.

Làm thế nào nó hoạt động:

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

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

Đầu ra là 0để cân bằng, -1cho nặng bên trái và nặng 1bên phải.

Ví dụ sử dụng: f "321^ 12"->-1

Làm thế nào nó hoạt động: tìm phần trước ^. Nhân chuỗi đầu vào và danh sách các trọng số bắt đầu từ - length-of-first-part. Có ^trọng số bằng 0 và không cộng vào tổng. Tôi đang sử dụng thủ thuật mod 16 của @ xnor để chuyển đổi chữ số / dấu cách thành giá trị nguyên. Nếu tổng là âm (dương), đòn bẩy là trái nặng (nặng phải) và cân bằng nếu tổng bằng 0.

TeaScript , 23 byte 25

Tôi đã thử viết một câu trả lời Pyth nhưng điều đó thật tồi tệ: \

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

Điều đó có ²vẻ không đúng chỗ nhưng nó tiết kiệm được 1 byte, vì vậy tôi sẽ giữ nó.

Hãy thử trực tuyến!

Kiểm tra tất cả các trường hợp

Đối với sơ đồ đầu ra tôi đã chọn:

• -1nếu bên trái nặng hơn bên phải ( L)
• 0nếu bên trái nặng như bên phải ( B)
• 1bên trái ít nặng hơn bên phải ( R)

Ungolfed && Giải thích

Điều này sử dụng bản đồ và giảm để hoàn thành công việc.

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

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

Đây là một trong những khó khăn. pb không được thiết kế để giỏi loại này. Nó thậm chí không có phép nhân . Nhưng này, nó hoạt động.

Ed. lưu ý: Có phải tôi vừa nói pb không có phép nhân? Gì? pb chắc chắn có nhân. Tôi đã thiết kế và triển khai ngôn ngữ này, tôi nên biết rằng nó có phép nhân được tích hợp và tôi không phải thực hiện một số bổ sung lặp đi lặp lại ngớ ngẩn. Khắc phục điều đó (cũng như thực hiện sắp xếp lại sáng tạo bây giờ để tôi có thể tiếp cận phần đó của vấn đề từ [gần như theo nghĩa đen] một góc khác) giúp tôi tiết kiệm 20 byte. Lúng túng.

Phần khó nhất là, sau khi nhận được tổng (khoảng cách * khoảng cách) cho mỗi bên, thực sự xác định chữ nào sẽ được in. pb không có >hoặc <toán tử, chỉ ==và !=. Không có cách nào dễ dàng để nói giá trị nào lớn hơn. Tôi thậm chí không thể trừ và so sánh với 0 ... trừ khi tôi làm điều gì đó thực sự ngớ ngẩn.

• Tìm tổng của hai khoản tiền.
• Đi xa về bên phải, trên một dòng không được sử dụng cho bất cứ điều gì.
• Cho đến khi đạt X = 0, rẽ trái và đặt 'L's.
• Đặt một 'B' tại X = 0.
• Đi bên trái bằng tổng của hai khoản tiền.
• Cho đến khi đạt X = 0, hãy sang phải và đặt 'R's.

Sau đó, bạn chỉ cần truy cập X = (bên trái - bên phải) và có câu trả lời của bạn! Xóa mọi thứ trên dòng đó để dọn sạch, sau đó in giá trị được tìm thấy tại (0, 0).

... Nhưng có một cách ngắn hơn một chút. Thay vì sử dụng 'L', 'B' và 'R', hãy sử dụng các giá trị đó - 'B' và thêm 'B' trở lại khi in. Bằng cách đó, bạn không bao giờ phải đặt 'B' tại X = 0, bạn chỉ cần để nó là 0 như đã có. Vấn đề duy nhất là một khi bạn làm điều này, chương trình sẽ trở nên rất ngớ ngẩn trong chế độ đồng hồ. 'L'-'B'==76-66==10=='\n'. Mọi thứ dường như đang hoạt động tốt, cho đến khi đột nhiên một số lượng lớn các dòng mới được in và không thể theo dõi những gì đang diễn ra: D Trong chế độ thực thi thông thường của pbi, tuy nhiên, mọi thứ đều hoạt động tốt vì các dòng mới bị xóa trước khi mọi thứ được in ra bàn điều khiể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)

Perl 5, 72 byte

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

MATLAB 91, 57, 55 Octave, 50 byte

Tôi không mong đợi chơi golf thêm nữa, nhưng chuyển sang Octave đã giúp tiết kiệm thêm 5 byte! Wow, cái này mất thời gian ...

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

Nó ra -Inf, NaN, Infcho L, B, Rtương ứng.

Bộ thử nghiệm!

Giải trình:

Đây chắc chắn là một mã khó đọc, nhưng tôi sẽ cố gắng giải thích tốt nhất có thể. Tôi sẽ chuyển đổi giữa giải thích khối mã và văn bản.

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

Hãy xem những gì đang diễn ra bên trong ngoặc:

[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

Điều này là một chút khó khăn:

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

Các số ở mỗi bên của thang phải được nhân với khoảng cách từ dấu mũ. Nếu chúng ta sử dụng số âm ở phía bên trái và số dương ở phía bên phải, chúng ta có thể chỉ cần tính tổng vectơ để xem bên nào nặng nhất.

Giả sử chuỗi đầu vào là : '321^ 12'. Chúng tôi muốn như sau : 3*(-3)+2*(-2)+1*(-1)+1*3+2*4. Vectơ chúng ta tạo bên trong dấu ngoặc bắt đầu tại 1-i, trong trường hợp này là -3, vì dấu mũ ở vị trí thứ 4. Nó đi lên nnz(x)-itheo gia số của một. Chúng ta có thể sử dụng nnz(x)thay vì numel(s), bởi vì xmột chuỗi không chứa số không.

Vì thế:

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

Bây giờ, chúng ta có thể thực hiện phép nhân phần tử s.*[...]và lấy tổng của phần này. Nhưng, vì chúng ta có hai vectơ, chúng ta cũng có thể sthay đổi bằng cách hoán vị [...]và tính tổng bằng cách sử dụng phép nhân ma trận:

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

Điều này cung cấp cho chúng ta một số âm, có nghĩa là bên trái nặng hơn, số 0, có nghĩa là số cân bằng hoặc số thứ tự, có nghĩa là bên phải nặng hơn. Thay vì sử dụng cách tiếp cận ngây thơ của sign(...), chúng tôi nhân nó với inf, nó sẽ cung cấp cho chúng tôi -Infhoặc Infcho trái và phải tương ứng. Chúng tôi nhận được NaNcho 0*inf, vì nó không xác định.

Điều này cho chúng ta ba giá trị riêng biệt cho ba kết quả có thể xảy ra.

, 22 ký tự / 38 byte

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

Try it here (Firefox only).

JavaScript, 146 byte

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

Khá đồ sộ.

Bản trình diễn .

Ruby, 111 108 byte

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

Giải trình

Tổng giá trị trọng số của mỗi số ở mỗi bên. Sau đó, nó sử dụng toán tử tàu vũ trụ ruby ​​để cung cấp 1,0, -1 đẳng thức / bất đẳng thức của hai bên, là chỉ số của một mảng với đầu ra chính xác.

PowerShell, 83 73 byte

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

Cảm ơn TessellatingHeckler cho golf.

Về cơ bản sử dụng thuật toán tương tự như mã cũ hơn bên dưới, nhưng ở đây chúng tôi lặp lại thông qua các ký tự trong chuỗi đầu vào một lần thay vì lặp qua chỉ mục, giúp tiết kiệm một số byte. Vẫn đưa ra thông báo lỗi ngoạn mục tương tự khi thuật toán đạt ^- không ảnh hưởng đến STDOUT.

Trước

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

Sử dụng thuật toán tuyệt vời giống như câu trả lời tuyệt vời của Dendrobium , và do đó sử dụng cùng một đầu ra -1 / 0 / 1nếu đầu vào là left-heavy / balanced / right-heavy.

Ừ Dài vì một đúc những đứa tính năng PowerShell có. Thích hợp nhất ở đây là cách charnhân với các intchức năng. Lấy một chỉ số mảng của một stringkết quả trong một charđối tượng. PowerShell chuyển đổi chargiá trị ASCII tương ứng của nó (chứ không phải giá trị bằng chữ) trước khi nhân. Vì vậy, một cái gì đó như $a='012'[0];[int]$a*2kết quả trong 96.

Điều đó có nghĩa là chúng ta cần đúc lại nó dưới dạng một chuỗi. Tuy nhiên, chỉ đơn giản là làm stringnhiều lần intcho chúng ta stringlặp đi lặp lại nhiều lần. Ví dụ, $a='0';$a*2sẽ dẫn đến 00.

Điều này có nghĩa chúng ta cần phải cast charlại như một stringtrước khi tái -casting như int, sau đó nhân có thể xảy ra, trước khi chúng tôi thêm nó vào ắc của chúng tôi $x.

Kết hợp với cách dài để lặp qua một chuỗi và lệnh gọi .NET để xuất ký hiệu và chúng ta nhận được một đoạn mã khá dài.

_{NB - Điều này sẽ gây ra một lỗi ngoạn mục khi nó đạt đến ^chuỗi, nói rằng nó không thể chuyển đổi nó thành một int. Không ảnh hưởng đến STDOUT.}

CJam, 29 byte

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

Dùng thử trực tuyến

Kết quả là -1cho trái nặng, 0cân bằng, 1nặng phải.

Điều này có vẻ hơi dài, nhưng tôi đã thử một loạt các lựa chọn thay thế, và tất cả chúng đều kết thúc trong khoảng từ 29 đến 33 byte. Một vấn đề là tôi không thể tìm ra cách chuyển đổi chuỗi thành giá trị sẽ tự động dẫn đến 0 cho khoảng trắng. Vì vậy, cuối cùng tôi đã thay thế các khoảng trắng bằng '0 ký tự, điều này rõ ràng làm tăng thêm độ dài của mã.

Các lựa chọn thay thế đã thử:

• Chia chuỗi tại '^, đảo ngược chuỗi thứ nhất và sau đó tính giá trị trọng số cho cả hai.
• Sử dụng eetoán tử để thêm chỉ mục vào danh sách các giá trị.
• Thay vì trừ vị trí dấu mũ từ mỗi chỉ số, hãy tính sản phẩm chấm mà không trừ, và sau đó trừ vị trí dấu mũ thời gian chuỗi từ kết quả.

Giải trình:

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 byte

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

Mã thông thường:

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

Giải trình:

1. Tạo danh sách các số + điểm tựa từ stdin.
2. Đối với mỗi số, thêm khoảng cách từ điểm tựa nhân với số cho biến vào tổng (số bên trái sẽ âm và số bên phải sẽ dương).
3. In chữ đúng tùy theo kết quả (B nếu bằng, L nếu lớn hơn 0 và R nếu nhỏ hơn 0).

Rất cảm ơn @ThomasKwa đã cắt giảm 82 byte (hơn 40%)!

C, 140 139 138 134 100 byte

Trở về:

• 1 = TRÁI
• 2 = CÂN B BALNG
• 0 = QUYỀN

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

Chạy:

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

Như chúng ta có ASCII:

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

Chúng tôi nhận được:

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

Sau đó tính tổng theo khoảng cách đến ^.

SpecBAS - 140 byte

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)

tlà tổng cộng đang chạy, các giá trị âm khi vị trí ký tự nhiều hơn vị trí carat. Cuối cùng, nó nhìn thấy nếu tổng là âm, bằng 0 hoặc dương và in ký tự tương ứng của R, B hoặc L

Tôi có thể tắt một vài byte bằng cách chỉ xuất ra -1, 0 hoặc 1 như một số câu trả lời khác.

Java, 83 byte

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