Mengapa Harus Simulator?

Anak-anak sekarang ini tidak punya waktu atau ambisi untuk benar-benar pergi dan menumpuk kotak-kotak di gergaji atau bermain-main dengan menyeimbangkan benda-benda fisik. Ini menyisakan banyak ruang di pasar perangkat lunak untuk Lever Simulator yang, menurut model saya, akan laku keras!

Bantuan Pemrograman Dicari

Saya telah mengajukan paten untuk game semacam itu (tertunda), tetapi membutuhkan programmer ahli untuk menulis logika game untuk saya. Dari pemahaman saya, itu adalah praktik standar untuk mengkompensasi programmer berdasarkan ukuran dalam byte dari program akhir. Karena itu saya akan memberikan kontrak menguntungkan ini kepada penawar terendah.

Spesifikasi

Tuas adalah serangkaian kotak atau ruang kosong yang diseimbangkan dengan titik tumpu. Setiap kotak memiliki berat satu hingga sembilan dan ruang tidak memiliki bobot. Seperti yang Anda ketahui, berat kotak pada tuas berbanding lurus dengan seberapa jauh kotak itu dari titik tumpu. Sebuah kotak berat 4yang ada di ruang ketiga dari titik tumpu akan berkontribusi 12unit kekuatan efektif ke sisi tuas itu.

Saya membutuhkan program yang, diberi tuas masukan, akan menampilkan apakah tuas akan condong ke kiri, kanan, atau seimbang sempurna.

Pedoman I / O

• Anda akan menulis untuk saya sebuah program.
• Input akan berisi satu baris teks.
• Input akan datang dari stdinatau sebagai satu string baris perintah.
• Kotak akan diwakili oleh karakter ' 1' hingga ' 9'. Karakter-karakter ini mewakili bobot masing-masing. Ruang kosong akan diwakili oleh spasi ' '. Titik tumpu akan diwakili oleh tanda sisipan ' ^'.

Tuas masukan sampel dapat terlihat seperti: 8 2^ 941

Tuas ini sangat seimbang: (4*8) + 0 + 0 + (1*2) == 0 + (2*9) + (3*4) + (4*1) == 34

• Tidak akan ada ruang depan atau belakang. Tidak akan ada trailing newline.
• Tidak perlu menangani input yang salah, input akan selalu memiliki tepat satu titik tumpu, dan hanya angka dan spasi.
• Output akan menunjukkan apakah tuas kiri-berat, kanan-berat, atau seimbang.
• Program Anda harus memiliki 3 kemungkinan output yang mungkin dihasilkan dari input yang dibentuk dengan baik. Anda dapat memilih apa ini.
• Outputnya harus cetak stdoutatau kode pengembalian program.

Uji kasus

Di sini saya menggunakan L, R, Bberarti kiri-berat, benar-berat, seimbang:

1. Input: 11 ^9Keluaran:B

2. Input: 321^ 12Keluaran:L

3. Input: 9^ 1Keluaran:R

(Jika ada yang memiliki beberapa kasus uji "rumit", silakan mengeditnya).

Bibliografi

Tidak-perlu-terinspirasi-oleh, tetapi terkait dengan Balance serangkaian bobot pada jungkat-jungkit

Python 2, 69 byte

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

Modulus ord(c)%16mengekstraksi nilai karakter digit sambil mendapatkan 0 untuk spasi. Untuk setiap karakter, kontribusi torsi dihitung saat bobot dikalikan dengan jarak masuk ke inden i-s.find('^'), dan ini dijumlahkan dan dibandingkan dengan 0, menghasilkan satu -1,0,1. Karakter ^dihitung memiliki bobot 14, tetapi itu tidak masalah karena berada di pivot.

Sebuah 18-byte Pyth pelabuhan oleh Maltysen:

._s.e*-kxz\^%Cb16z

Untuk kode Python, jika program lengkap diperlukan, ini 79 byte. Idenya adalah untuk memulai indeks idengan bergeser s.find('^'), dan memilikinya mundur.

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 jika dibiarkan lebih berat
• 0 jika seimbang
• 1 jika benar lebih berat

Tidak Disatukan:

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)

Tes berjalan (menugaskan fungsi anonim ke f):

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

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

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

• -11 byte: mengubah output dari R B Lmenjadi-1 0 1
• -3 byte: diubah e.split``menjadi [...e](terima kasih @ Vɪʜᴀɴ)
• -33 byte: algoritma diubah untuk menggunakan bobot negatif daripada pemisahan di pivot
• -9 byte: menghapus pivot check (ternyata, ~~'^'mengevaluasi ke 0...)
• -2 byte: membuat fungsi anonim (terima kasih @ cᴏɴᴏʀ-obʀɪᴇɴ)

Japt , 22 byte

Japt adalah versi singkat dari Ja vaScri pt . Penerjemah

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

Pengembalian -1untuk L, 0untuk B, dan 1untuk R.

Bagaimana itu bekerja

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)×(⍳⍴⍵)-⍵⍳'^'}

Setelah membaca ulang aturan, saya mengubah ini menjadi keluaran -1 0 1alih-alih L B R, menghemat sembilan byte.

Coba di sini .

Pyth, 20 byte

._s*V-Rxz\^Uzm.xsd0z

Suite uji

-1untuk bias kiri, 0seimbang, 1untuk bias kanan.

Bagaimana itu bekerja:

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

Output adalah 0untuk seimbang, -1untuk kiri-berat dan 1kanan-berat.

Contoh penggunaan: f "321^ 12"->-1

Cara kerjanya: temukan bagian sebelum ^. Lipat gandakan string input dan daftar bobot yang dimulai dengan - length-of-first-part. The ^memiliki berat 0 dan tidak menambah jumlah. Saya menggunakan trik mod 16 xnor untuk mengkonversi angka / spasi menjadi nilai integer. Jika jumlahnya negatif (positif), tuas kiri-berat (kanan-berat) dan seimbang jika jumlahnya adalah 0.

TeaScript , 23 byte 25

Saya mencoba menulis jawaban Pyth tapi itu berjalan sangat buruk: \

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

Itu ²terlihat sangat tidak pada tempatnya tetapi menghemat 1 byte, jadi saya akan menyimpannya.

Cobalah online!

Uji semua kasus

Untuk skema hasil yang saya pilih:

• -1jika Kiri lebih berat dari Kanan ( L)
• 0jika Kiri seberat Kanan ( B)
• 1is Left lebih ringan dari Right ( R)

Penjelasan && Tidak Terkumpul

Ini menggunakan peta dan mengurangi untuk menyelesaikan pekerjaan.

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

Ini yang sulit. pb tidak dirancang untuk pandai dalam hal semacam ini. Bahkan tidak memiliki multiplikasi . Tapi hei, itu berhasil.

Ed. catatan: Apakah saya baru saja mengatakan pb tidak memiliki perkalian? Apa? pb pasti memiliki multiplikasi. Saya merancang dan mengimplementasikan bahasa ini, saya harus tahu bahwa ia memiliki multiplikasi bawaan dan saya tidak perlu melakukan beberapa penambahan yang konyol. Memperbaiki itu (serta melakukan beberapa penyusunan ulang kreatif sekarang sehingga saya bisa mendekati bagian masalah dari [hampir secara harfiah] sudut yang berbeda) menyelamatkan saya 20 byte. Memalukan.

Bagian tersulit adalah, setelah mendapatkan jumlah (berat * jarak) untuk setiap sisi, sebenarnya menentukan huruf mana yang akan dicetak. pb tidak memiliki >atau <operator, adil ==dan !=. Tidak ada cara mudah untuk mengetahui nilai mana yang lebih besar. Saya bahkan tidak bisa mengurangi dan membandingkan dengan 0 ... kecuali saya melakukan sesuatu yang sangat konyol.

• Temukan jumlah dari dua jumlah tersebut.
• Pergi sejauh itu ke kanan, pada jalur yang tidak digunakan untuk apa pun.
• Sampai mencapai X = 0, ke kiri dan letakkan 'L's.
• Tempatkan 'B' di X = 0.
• Ke kiri dengan jumlah dari dua jumlah.
• Sampai mencapai X = 0, ke kanan dan letakkan 'R's.

Kemudian, Anda cukup pergi ke X = (sisi kiri - kanan), dan ada jawaban Anda! Hapus semua yang ada di baris itu untuk membersihkan, dan kemudian cetak nilai yang ditemukan di (0, 0).

... Tapi ada cara yang sedikit lebih pendek. Alih-alih menggunakan 'L', 'B' dan 'R', gunakan nilai-nilai itu - 'B' dan tambahkan 'B' kembali saat mencetak. Dengan begitu, Anda tidak perlu menempatkan 'B' di X = 0, Anda cukup membiarkannya seperti 0 sebelumnya. Satu-satunya masalah adalah bahwa setelah Anda melakukan ini, program menjadi sangat konyol dalam mode tontonan. 'L'-'B'==76-66==10=='\n'. Semuanya tampak berfungsi dengan baik, sampai tiba-tiba sejumlah besar baris baru dicetak dan tidak mungkin untuk melacak apa yang terjadi: D Dalam mode eksekusi reguler pbi, meskipun, semuanya bekerja dengan baik karena baris baru dihapus sebelum segala sesuatu dicetak ke menghibur.

^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 Oktaf, 50 byte

Saya tidak berharap untuk bermain golf ini lebih jauh, tetapi beralih ke Oktaf memungkinkan untuk menghemat 5 byte tambahan! Wow, ini butuh waktu ...

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

Output -Inf, NaN, Infuntuk L, B, Rmasing - masing.

Suite uji!

Penjelasan:

Ini jelas kode yang sulit dibaca, tetapi saya akan mencoba menjelaskan sebaik mungkin. Saya akan beralih antara penjelasan blok kode dan teks.

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

Mari kita lihat apa yang terjadi di dalam kurung:

[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

Yang ini agak rumit:

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

Angka-angka di setiap sisi tangga harus dikalikan dengan jarak dari tanda sisipan. Jika kita menggunakan angka negatif di sisi kiri, dan angka positif di sisi kanan kita cukup menjumlahkan vektor untuk melihat sisi mana yang terberat.

Misalkan input string adalah: '321^ 12'. Kami ingin berikut: 3*(-3)+2*(-2)+1*(-1)+1*3+2*4. Vektor yang kami buat di dalam tanda kurung dimulai 1-i, yang dalam hal ini adalah -3, karena tanda sisipan berada di posisi ke-4. Naik satu demi nnz(x)-isatu. Kita bisa menggunakan nnz(x)alih-alih numel(s), karena xstring tidak mengandung nol.

Karena itu:

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

Sekarang, kita bisa melakukan penggandaan elemen-bijaksana s.*[...], dan mengambil jumlah ini. Tetapi, karena kita memiliki dua vektor, kita juga dapat secara acak smengubah [...]dan menghitung jumlah menggunakan perkalian matriks:

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

Ini memberi kita angka negatif, artinya sisi kiri lebih berat, nol, berarti seimbang, atau angka postive, artinya sisi kanan lebih berat. Alih-alih menggunakan pendekatan naif sign(...), kami melipatgandakannya dengan inf, yang akan memberi kita masing -Inf- masing atau Infuntuk masing-masing kiri dan kanan. Kami mendapatkan NaNuntuk 0*inf, karena itu tidak terdefinisi.

Ini memberi kita tiga nilai berbeda untuk tiga kemungkinan hasil.

𝔼𝕊𝕄𝕚𝕟, 22 karakter / 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')}

Cukup besar.

Demo .

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

Penjelasan

Ringkas nilai tertimbang dari setiap angka di setiap sisi. Kemudian ia menggunakan operator pesawat ruang angkasa ruby ​​untuk memberikan 1,0, -1 dari kesetaraan / ketidaksetaraan dari dua sisi, yang merupakan indeks dari array dengan output yang benar.

PowerShell, 83 73 Bytes

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

Terima kasih kepada TessellatingHeckler untuk golfnya.

Pada dasarnya menggunakan algoritma yang sama dengan kode lama di bawah ini, tetapi di sini kita beralih melalui karakter dalam string input satu per satu alih-alih mengulangi melalui indeks, yang menyimpan beberapa byte. Masih melempar pesan kesalahan spektakuler yang sama ketika algoritma mencapai ^- tidak memengaruhi STDOUT.

Sebelumnya

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

Menggunakan algoritma luar biasa yang sama dengan jawaban Dendrobium yang sangat baik , dan karenanya menggunakan output yang sama -1 / 0 / 1jika inputnya left-heavy / balanced / right-heavy.

Ugh. Lama karena fitur casting quirk yang dimiliki PowerShell. Yang paling relevan di sini adalah bagaimana chardikalikan dengan intfungsi. Mengambil array-indeks stringhasil dalam suatu charobjek. PowerShell mengonversi charuntuk nilai ASCII yang sesuai (bukan nilai literal) sebelum perkalian. Jadi, sesuatu seperti $a='012'[0];[int]$a*2menghasilkan 96.

Itu berarti kita perlu melemparkannya kembali sebagai string. Namun, sekadar melakukan stringwaktu intmemberi kita stringberulang yang berkali-kali. Misalnya, $a='0';$a*2akan menghasilkan 00.

Ini berarti kita harus melempar bagian charbelakang stringsebelum menyiarkan ulangint , kemudian multiplikasi dapat terjadi, sebelum kita menambahkannya ke dalam akumulator kita $x.

Pasangan itu dengan cara panjang untuk beralih melalui string, dan panggilan .NET untuk menampilkan tanda, dan kami mendapatkan sepotong kode yang cukup panjang.

_{NB - Ini akan menghasilkan kesalahan spektakuler ketika mencapai ^dalam string, menyatakan bahwa itu tidak dapat mengubahnya menjadi int. Tidak memengaruhi STDOUT.}

CJam, 29 byte

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

Cobalah online

Hasil -1untuk kiri-berat, 0seimbang, 1untuk kanan-berat.

Ini sepertinya agak panjang, tapi saya mencoba banyak alternatif, dan mereka semua berakhir antara 29 dan 33 byte. Satu masalah adalah bahwa saya tidak dapat menemukan cara mengubah string ke nilai yang secara otomatis menghasilkan 0 untuk spasi. Jadi saya akhirnya secara eksplisit mengganti spasi dengan '0 karakter, yang jelas menambah panjang kode.

Alternatif mencoba:

• Memisahkan string pada '^, membalikkan yang pertama, dan kemudian menghitung nilai tertimbang untuk keduanya.
• Menggunakan eeoperator untuk menambahkan indeks ke daftar nilai.
• Alih-alih mengurangi posisi caret dari setiap indeks, hitung produk titik tanpa pengurangan, dan kemudian kurangi posisi caret kali dengan panjang string dari hasilnya.

Penjelasan:

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

Kode reguler:

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

Penjelasan:

1. Menghasilkan daftar angka + titik tumpu dari stdin.
2. Untuk setiap angka, tambahkan jarak dari titik tumpu kali angka ke variabel ke total (angka di sebelah kiri akan menjadi negatif dan angka di sebelah kanan akan menjadi positif).
3. Mencetak huruf yang benar tergantung pada hasilnya (B jika sama, L jika lebih dari nol, dan R jika kurang dari nol).

Terima kasih banyak kepada @ThomasKwa untuk memangkas 82 byte (lebih dari 40%)!

C, 140 139 138 134 100 byte

Kembali:

• 1 = KIRI
• 2 = SALDO
• 0 = KANAN

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

Lari:

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

Seperti yang kita miliki ASCII:

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

Kita mendapatkan:

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

Kemudian jumlah dengan faktor jarak ke ^.

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)

tadalah total berjalan, nilainya negatif ketika posisi karakter lebih dari posisi karat. Pada akhirnya ia melihat apakah total negatif, nol atau positif dan mencetak karakter yang sesuai dari R, B atau L.

Saya bisa mencukur beberapa byte dengan hanya mengeluarkan -1, 0 atau 1 seperti beberapa jawaban lainnya.

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