Чому тренажер?

Діти в ці дні не мають ані часу, ані амбіції реально ходити і складати коробки на пилораму чи грати навколо, врівноважуючи фізичні об’єкти. Це залишає багато місця на ринку програмного забезпечення для 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 якщо справа важча

Безголівки:

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 16 для перетворення цифр / пробілів у цілі значення. Якщо сума негативна (позитивна), важіль ліво-важкий (правий-важкий) і врівноважений, якщо сума дорівнює 0.

TeaScript , 23 байти 25

Я спробував написати відповідь Pyth, але це пішло жахливо: \

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

Це ²виглядає поза місцем, але це економить 1 байт, тому я буду його зберігати.

Спробуйте в Інтернеті!

Перевірте всі випадки

Для схеми виводу я вибрав:

• -1якщо лівий важчий за правий ( L)
• 0якщо лівий такий важкий, як правий ( B)
• 1лівий менш важкий, ніж правий ( R)

Без пояснення та пояснення

Це використовує карти та скорочення, щоб виконати роботу.

$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 ... якщо я не роблю щось справді нерозумно.

• Знайдіть суму двох сум.
• Ідіть так праворуч по лінії, яка ні для чого не використовується.
• Досягнувши Х = 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 Октава, 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)

Завдяки TesselilingHeckler за гольф.

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

Пітон 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%)!

С, 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- загальна кількість, значення негативні, коли позиція символів більше, ніж позиція карата. Наприкінці він бачить, чи загальний від’ємник, нуль чи позитив, і друкує відповідний символ 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));}