Рычаг Симулятор 2015

46

Почему симулятор?

В наши дни у детей нет ни времени, ни амбиций, чтобы пойти и сложить коробки на качелях или поиграть с уравновешивающими физическими объектами. Это оставляет много места на рынке программного обеспечения для Lever Simulator, который, согласно моим моделям, будет продаваться как сумасшедший!

Требуется помощь по программированию

Я подал патент на такую ​​игру (в ожидании), но мне нужен опытный программист, чтобы написать игровую логику для меня. Насколько я понимаю, это стандартная практика, чтобы компенсировать программистов на основе размера в байтах конечной программы. Таким образом, я буду заключать этот выгодный контракт с самой низкой ставкой.

Спецификация

Рычаг - это серия ящиков или пустых пространств, уравновешенных точкой опоры. Каждая коробка имеет определенный вес от одного до девяти, а пробелы не имеют веса. Как вы знаете, вес коробки на рычаге прямо пропорционален тому, как далеко этот ящик находится от точки опоры. Ящик с весом, 4который находится на третьем месте от точки опоры, будет вносить 12эффективные единицы силы в ту сторону рычага.

Мне нужна программа, которая при наличии рычага ввода будет выводить, будет ли рычаг наклонен влево, вправо или будет идеально сбалансирован.

Руководство по вводу / выводу

  • Вы напишите для меня программу.
  • Ввод будет содержать одну строку текста.
  • Входные данные будут поступать из 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

(Если у кого-то есть более «сложные» тестовые случаи, не стесняйтесь их редактировать).

Библиография

Не обязательно вдохновленный, но связанный с Балансом набор весов на качелях

turbulencetoo
источник
8
The output must either be print to stdout or be the return code of the program.Что ж, теперь вы просите меня создать дистрибутив Linux, который использует обозначения качелей для кодов выхода.
кот
1
Я бы пошел поиграть в качели-качалки, за исключением того, что большинство игровых площадок убрали их, поскольку они «небезопасны». Я надеюсь, что они никогда не удаляют качели по этой причине. "Дети могут спрыгнуть с них, о нет!"
mbomb007
2
Может ли вход иметь пустые стороны? Как и в ^16, 16^или ^? (Предположим, что это возможно)
Runium 25.11.15
аааа дыра в спецификации, да я бы предположил, что стороны могут быть пустыми
турбулентность
7
Я просто потратил несколько долгих секунд на размышления о том, как смещение 11 на 3 или 4 может быть сбалансировано с 9 смещением 1.
Джеймс Торп

Ответы:

7

Python 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, но это не имеет значения, потому что он в центре внимания.

18-байтовый Pyth порт по Maltysen:

._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)
XNOR
источник
Вот программа Pyth, использующая ваш метод, которую вы можете опубликовать, если хотите pyth.herokuapp.com/… 18 байт. Не чувствовал себя правильно, отправив его сам.
Maltysen
@ Maltysen Спасибо, я включил это.
xnor
16

Javascript ES6, 62 байта

s=>Math.sign([...s].reduce((p,c,i)=>p+~~c*(i-s.indexOf`^`),0))
  • -1 если левый тяжелее
  • 0 если сбалансирован
  • 1 если право тяжелее

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)

Тестовые прогоны (назначение анонимной функции 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ʀɪᴇɴ)
Dendrobium
источник
3
Общепринято, что вы можете опустить ведущее f=и сказать, что оно генерирует анонимную функцию. (-2 байта FYI)
Конор О'Брайен
5

Japt , 22 байта

Japt - это сокращенная версия Ja vaScri pt . переводчик

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

Возвращает -1для L, 0для Bи 1для 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
ETHproductions
источник
5

APL, 39 30 байт

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

Перечитав правила, я изменил это на вывод -1 0 1вместо того L B R, чтобы сэкономить девять байтов.

Попробуй это здесь .

lirtosiast
источник
4

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.
isaacg
источник
4

Haskell, 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's mod 16 для преобразования цифр / пробелов в целочисленные значения. Если сумма отрицательная (положительная), рычаг будет тяжелым слева (правым) и сбалансирован, если сумма равна 0.

Ними
источник
4

TeaScript , 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
Downgoat
источник
4

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 нет умножения? Какая? пб определенно определенно имеет умножение. Я разработал и реализовал этот язык, я должен знать, что в него встроено умножение, и мне не нужно делать какие-то глупые циклические сложения. Исправление этого (а также внесение некоторой креативной перестройки теперь, когда я мог бы подойти к этой части проблемы под [почти буквально] другим углом) экономит мне 20 байтов. Затруднительный.

Самым сложным было, после получения сумм (вес * расстояние) для каждой стороны, определить, какую букву нужно напечатать. у пб нету >или <операторов, просто ==и !=. Нет простого способа узнать, какое значение больше. Я не могу даже вычесть и сравнить с 0 ... если я не сделаю что-то действительно глупое.

  • Найдите сумму двух сумм.
  • Идите так далеко направо, на линии, которая ни для чего не используется.
  • До достижения X = 0, идите налево и поместите 'L'.
  • Поместите «B» в X = 0.
  • Идите налево на сумму двух сумм.
  • До достижения X = 0 идите направо и поместите 'R'.

Затем вы просто переходите к X = (слева - справа), и вот ваш ответ! Удалите все в этой строке, чтобы очистить, а затем напечатайте значение, которое было найдено в (0, 0).

... Но есть немного более короткий путь. Вместо использования «L», «B» и «R», используйте эти значения - «B» и добавьте «B» снова при печати. Таким образом, вам никогда не нужно ставить 'B' в X = 0, вы просто оставляете его как 0, в котором он уже был. Единственная проблема заключается в том, что, как только вы это сделаете, программа станет очень тупой в режиме просмотра. 'L'-'B'==76-66==10=='\n', Кажется, все работает нормально, пока внезапно не будет напечатано огромное количество новых строк, и невозможно отследить, что происходит: D В обычном режиме выполнения pbi все работает нормально, потому что новые строки удаляются до того, как что-либо будет напечатано в приставка.

^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)
undergroundmonorail
источник
3
Как смотреть, как человек погружается в безумие.
Kzqai
3

Perl 5, 72 байта

@_=split//,<>;($i)=grep$_[$_]eq'^',0..@_;$j+=$_*($k++-$i)for@_;say$j<=>0
msh210
источник
3

MATLAB 91, 57, 55 Octave, 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, так как каретка находится в 4-й позиции). Это идет с nnz(x)-iшагом в один. Мы можем использовать nnz(x)вместо numel(s), потому что xэто строка, не содержащая нулей.

Следовательно:

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

Теперь мы могли бы сделать поэлементное умножение s.*[...]и взять сумму этого. Но, поскольку у нас есть два вектора, мы также можем умножить sпутем транспонирования [...]и вычислить сумму с использованием умножения матриц:

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

Это дает нам либо отрицательное число, означающее, что левая сторона тяжелее, ноль, означающее, что он сбалансирован, либо положительное число, означающее, что правая сторона тяжелее. Вместо того чтобы использовать наивный подход sign(...), мы умножаем его на inf, который дадим нам либо -Infили Infдля левых и правых соответственно. Мы получаем NaNдля 0*inf, так как это не определено.

Это дает нам три различных значения для трех возможных результатов.

Стьюи Гриффин
источник
2

𝔼𝕊𝕄𝕚𝕟, 22 символа / 38 байт

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

Try it here (Firefox only).

Mama Fun Roll
источник
2
-1 это оптимизирует количество символов, а не количество байтов
Mego
Для этого и была создана, @Mego.
Mama Fun Roll
3
Независимо от того, для чего он был построен, выигрыш в байтах.
Mego
Я это понимаю.
Mama Fun Roll
2

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

Довольно массивный.

Demo .

nicael
источник
Вы можете сэкономить немало байтов, используя ES6. Целое function t(s){могло стать t=>{и split('^')могло статьsplit`^`
Downgoat
@ Vɪʜᴀɴ ты, наверное, имел ввиду s => {?
Никель
о да, извините, это то, что я имел в виду
Downgoat
@Ypnypn -6 символов :)
Никель
2

Рубин, 111 108 байт

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

объяснение

Суммирует взвешенное значение каждого числа на каждой стороне. Затем он использует оператор космического корабля ruby, чтобы обеспечить 1,0, -1 равенства / неравенства двух сторон, что является индексом массива с правильным выводом.

Алексис Андерсен
источник
2

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)

Использует тот же потрясающий алгоритм, что и превосходный ответ Дендробиума , и, следовательно, использует тот же результат, -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.

Это означает, что нам нужно преобразоватьchar обратно как a stringперед повторным вещанием как int, тогда может произойти умножение, прежде чем мы добавим его в наш аккумулятор $x.

Соедините это с длинным способом перебора строки и вызовом .NET для вывода знака, и мы получим довольно длинный кусок кода.

NB. Это приведет к выдающейся ошибке, когда он достигнет ^строки, заявив, что не может преобразовать ее в int. Не влияет на STDOUT.

AdmBorkBork
источник
У меня param($b)$i=-$b.indexOf('^');[char[]]$b|%{$x+=$i++*+"$_"};[math]::Sign($x)на 74 байта. Это заняло много времени и несколько попыток подхода. math :: sign выглядит так долго, но я не вижу способа улучшить этот бит.
TessellatingHeckler
@TessellatingHeckler Конечно, итерация самих символов, а не индексов ... имеет смысл! Я добавил дополнительный байт, используя неявное приведение PowerShell, $i++*+"$_"эквивалентно $i++*"$_"if $iis int.
AdmBorkBork
1

CJam, 29 байт

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

Попробуйте онлайн

Результат -1для левого тяжелого, 0для сбалансированного, 1для правого тяжелого.

Это казалось немного длинным, но я попробовал кучу альтернатив, и все они оказались между 29 и 33 байтами. Одна проблема заключается в том, что я не смог найти способ преобразования строки в значения, которые автоматически приводили бы к 0 для пробелов. Таким образом, я в итоге явно заменил пробелы символами '0, что, очевидно, увеличивает длину кода.

Альтернативы пробовали:

  • Разбить строку на '^, поменять местами 1-е, а затем вычислить взвешенное значение для обоих.
  • Использование 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.
Рето Коради
источник
1

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, если равен, L, если больше нуля, и R, если меньше нуля).

Огромное спасибо @ThomasKwa за обрезку 82 байтов (более 40%)!

Кодер-256
источник
Легкие 15 или около того байтов: используйте print('LBR'[(B>D)-(B<D)])для конца и B=D=0в начале.
Lirtosiast
Нет, даже лучше: не следите за левым и правым отдельно; вместо этого умножьте на отрицательное расстояние для чисел слева от ^. Это abs()тоже тебя спасает .
Lirtosiast
1

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.

Затем сумма по фактору расстояние до ^.

Runium
источник
1

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 отрицательным, нулевым или положительным, и печатает соответствующий символ R, B или L.

Я мог бы сбрить несколько байтов, просто выдав -1, 0 или 1, как некоторые другие ответы.

Брайан
источник
1

Java, 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));}
Роман Греф
источник