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

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

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

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

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

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)

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ʀɪᴇɴ)

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

APL, 39 30 байт

{×+/(10|⍵⍳⍨∊⍕¨⍳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.

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.

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

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)

Perl 5, 72 байта

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

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, так как это не определено.

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

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

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

Try it here (Firefox only).

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 .

Рубин, 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 равенства / неравенства двух сторон, что является индексом массива с правильным выводом.

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

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.

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%)!

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

Я мог бы сбрить несколько байтов, просто выдав -1, 0 или 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));}