Огляд

Давши рядок із 3 рядків, з’ясуйте, чи структура падає зліва, врівноважується чи падає праворуч.

Структура вводу

Ви можете уявити структуру як металевий прут з речами зверху, всі вони врівноважені вертикально.

1  7 4        a
===============
        |

Перший рядок - це пункти. Вага кожного предмета обчислюється як значення ассі символу мінус 32. (Символи до 32 років не враховуються, а пробіли важать 0). Майте на увазі, що сила предмета на стержень - його вага, менша відстані до точки повороту.

Другий рядок - стрижень. Кожна довжина стрижня важить 1 одиницю. Цей рядок є виключно рівним знакам ( =).

Третій рядок - точка зведення. Це може бути розміщено в будь-якому місці і представлене кількома пробілами, за якими слідує один |символ ( ).

Приклади

Вхід:

=====
  |

Вихід: баланс

Вхід:

=====
   |

Вихід: Падіння ліворуч

Вхід:

    %
=====
   |

Вихід: баланс (Оскільки %важить достатньо, щоб протиставити вазі лівої сторони штанги)

Вхід:

 аа
=======
   |

Вихід: падає праворуч (тому що aсправа праворуч знаходиться далі від точки зрізу)

Вхід:

1  7 4        A
===============
        |

Вихід: Падіння ліворуч

Вхід:

1  7 4        a
===============
        |

Вихід: Падає праворуч (малі літери важкі!)

Вхід:

            $ ~
===============
             |

Вихід: баланс

Примітки

• Дозволений пробіл пробілів дозволений, провідна пробіл - ні.
• Ваша програма може виводити в будь-якому форматі, який вам подобається, якщо є 3 різних виходу для лівого, балансового та правого.
• Ваша програма повинна приймати формат, показаний як вхідний.

JavaScript (ES6), 116 111 108 106 байт

-5 байт шляхом підсумовування через, eval(array.join`+`)а не array.reduce().
-3 байти, дефолт - 1замість 32 - 31, дозволяючи видалити дужки.
-2 байти, оскільки точка зведення - довжина останнього рядка - 1

(s,[t,r,b]=s.split`
`)=>Math.sign(eval([...r].map((_,i)=>(t.charCodeAt(i)-31||1)*(i-b.length+1)).join`+`))

Виходи -1, 0або, відповідно 1, для лівого, збалансованого або правого. Закінчився подібним до відповіді пітона Шаса Брауна , тому кредити існують там.

Можна зберегти 4 байти, якщо перший рядок буде прокладений, щоб відповідати довжині стрижня за допомогою
(31-t.charCodeAt(i))*(b.length+~i).

Тест-фрагмент

Включає додатковий вихід ( Left/ Balanced/ Right) разом з номером.

f=
(s,[t,r,b]=s.split`
`)=>Math.sign(eval([...r].map((_,i)=>(t.charCodeAt(i)-31||1)*(i-b.length+1)).join`+`))

<textarea id=I rows=3 cols=20></textarea><br><button onclick="O.value=I.value?`${x=f(I.value)} (${['Left','Balanced','Right'][x+1]})`:''">Run</button> <input id=O disabled>

Ще 106 байт-метод

(s,[t,r,b]=s.split`
`)=>Math.sign(eval(r.replace(/./g,(_,i)=>"+"+(t.charCodeAt(i)-31||1)*(i-b.length+1))))

Замість того, joinщоб вводити масив на +s, ми створюємо рядок чисел, кожне з префіксом +. Ведучі +ігноруються.

Python 2 , 112 110 байт

def f(s):w,b,p=s.split('\n');return cmp(sum((ord((w+' '*-~i)[i])-31)*(i-p.find('|'))for i in range(len(b))),0)

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

EDIT: Нарешті вдалося усунути enumerateі rjustдля 2-х байт ...

Бере в рядку; виходи -1,0, або 1 для падінь ліворуч, балансує, падає праворуч відповідно.

Перший пропуск у 112 байт був:

def f(s):w,b,p=s.split('\n');return cmp(sum((ord(c)-31)*(i-p.find('|'))for i,c in enumerate(w.rjust(len(b))),0)

Haskell, 212 171 байт (188, якщо взяти введення як один рядок)

o!p=map(fst)(zip[p-0,p-1..]o)
x#p=sum(zipWith(\c w->(max(fromEnum c-32)0)*w)x(x!p))+sum(x!p)
x?c=length(takeWhile(==c)x)

171 байт варіант

r a b c=signum(take(b?'=')(a++repeat ' ')#(c?' '))

Варіант 188 байт

x%y=lines x!!y
r i=signum(take(i%1?'=')(i%0++repeat ' ')#(i%2?' '))

Пояснення

o!p=map(fst)(zip[p-0,p-1..]o)        Creates weights coefs list. 
                                     o - list, p - pivot position
                                     for list "abcdf" and p=3 (pivot under 'd')
                                     outputs [3,2,1,0,-1]

x#p                                  Calculates total balance
                                     x-list of "objects" on lever, p-pivot place
  sum(zipWith                        sum of zipped lists
   (\c w->(max(fromEnum c-32)0)*w)   weight of ascii "object" times
                                     distance from pivot
    x(x!p))                          x-ascii objects, 
                                     (x!p)-distances list(weight coefs)
  +sum(x!p)                          balance of lever ("==") itself

x?c=length(takeWhile(==c)x)          length of list before non c element met
                                     used to find '|' position
                                     and length of "===" lever
                                     before right whitespaces met

r a b c=                             Sums it all up =)
                                     a-ascii objects, b-lever, c-pivot line
   signum(                           1-tips left, 0-balance, -1-tips right
     take(b?'=')(a++repeat ' ')      takes all object on lever 
                                     plus whitespaces up to length of the lever
      #                              calculate the balance
       (c?' ')                       determine place of pivot

Желе , 30 байт

O_31×J_¥A+\sṪ€µ÷ḢṪ_2Ṡ
ỴṪLç@ỴḢ$

Тестовий сюїт

Виводи 0 для збалансованого, 1 для правого та -1 для лівого.

Як це працює

O_31×J_¥A+\sṪ€µ÷ḢṪ_2Ṡ - helper function. Arguments position of pivot and first line
O                        - char codes of first line
 _31                     - subtract 31 to get weight
    ×                    - elementwise product with:
     J_¥                 - distances from the pivot
        A                - absolute value
         +\              - cumulative sum
           s             - split to get [[...,left weight],...,[..., right + left weight]]
            Ṫ€           - last element of each sublist: [left weight, ... right weight]
              µ÷Ḣ        - get ratio of each element over left weight: ratio n indicates
                              right + left = n × left ===> right = left if n = 2
                 _2      - subtract 2: positive is right>left and negative is right<left
                   Ṡ     - return the sign of this


ỴṪLç@ỴḢ$              - main link. Argument: 3 line string.
   ç@                  - apply helper function with arguments:
Ỵ                        - split by linefeeds
 Ṫ                       - last line
  L                      - length (returns position of pivot)
       $               - and
     Ỵ                   - split by linefeeds
      Ḣ                  - first line              

Желе , 24 байти

ṪO_31
ỴµṪLạЀṪL$×Çṣ0S€IṠ

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

-1для падіння ліворуч, 0для врівноваження, 1для падіння правого (повна програма).
[-1]для падіння ліворуч, [0]для врівноваження, [1]для падіння праворуч (функція).

Перший рядок повинен мати пробіли, в останньому рядку.

Пояснення (ми починаємо з нижнього рядка):

Перш за все, ми працюємо з окремими лініями, тому нам потрібно якось їх отримати. Це робота для Ỵ. Тоді нам потрібно ставитися до \n-split-версії вводу так, ніби це був вихідний вхід, тому ми використовуємо µдля створення монадичного ланцюга, застосованого до поточного значення.

Зараз ми починаємо реальні роботи, і нашим першим завданням було б обчислення факторів ваг. По суті це діапазон [відстань від лівого краю до вершини..0..відстань від шарніра до крайнього правого]. Перш за все, ми повинні знайти 1-заснований індекс стрижня, який по суті є довжиною останнього рядка без пробілів. Таким чином, ми виводимо останній рядок (зведений рядок) з нашого початкового списку Ṫ, оскільки він нам більше не потрібен, а потім беремо його довжину L. Потім нам потрібно взяти довжину стрижня, для якого ми робимо те саме, що і з останньою лінією (стрижневою лінією) ṪL$. Нарешті, щоб отримати діапазон, ми картаємо | х - у | до [1..rod length], де x - індекс повороту і y- це кожен елемент списку, який ми картаємо. Ми робимо це, використовуючи ạЀ, де ạобчислює | х - у | і Ѐскладає діапазон від 1 до, включаючи довжину стрижня. Тепер ми матимемо потрібний нам діапазон.

Після цього нам треба помножити кожне ціле число, що представляє собою шматок стрижня, на відповідну його вагу. Для обчислення ваг ми використовуємо Ç, переходячи до верхнього рядка нашого коду. Ми беремо решту рядок з Ṫ, його штрихкодами O, а потім обчислюємо х - 31, використовуючи _31, x - кожен шаркод. Потім ми присвоюємо простір вазі 1 (0 + шматок штанги = 1), !вазі 2 (1 + 1) і т. Д. Ми закінчили верхню лінію, тому тепер Çповернемо список ваг, які ми множимо на відповідні цілі числа, що представляють шматочки стержня ×.

Після цього ми розділимо з ṣ0точкою зрізу, представленою 0 (оскільки будь-яка вага там не вплине на результат), у результаті вийде список форми [[1-а вага, 2-а вага ... вага безпосередньо перед стрибком] , [вага відразу після стрижня, вага після тієї, що була раніше ... остання вага]]. Ці списки представляють сторони стержня, зліва та справа. Тепер ми підсумовуємо кожен із списків, використовуючи S€для отримання загальної ваги на кожній стороні, і використовуємо Iдля взяття дельти, яка буде негативною, якщо ліва сторона важча, нульова, якщо вони рівноважені, і позитивної, якщо права сторона важча . Отже, щоб повернути кінцевий результат, використовуючи це належним чином на нашу користь, ми беремо знак із Ṡ.

APL (Діалог) , 43 байти *

{×(¯31+⎕UCS⊃⍵)+.×(⍳≢⊃⍵)-'|'⍳⍨⊃⌽⍵}⎕TC[2]∘≠⊆⊢

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

⊆⊢ розділіть аргумент на пробіги символів, які є

⎕TC[2]∘≠ відрізняється від 2- ^го Т ермінального символу C ontrol (Linefeed) **

{… } Застосувати таку анонімну функцію до списку рядків:

 ⊃⌽⍵ у першому рядку зворотного списку (тобто останньому)

 '|'⍳⍨ знайдіть ɩ ndex точки зрізу

 (… )- Відніміть це з наступного списку:

  ⊃⍵ перша рядок

  ≢ його довжина

  ⍳ всі of ices диски цього

 (…)+.×  Зважена сума з цими вагами та наступними значеннями:

  ⊃⍵ перша рядок

  ⎕UCS Точки код в U niversal З haracter S і ін

  ¯31+ додайте мінус тридцять один (32 для необхідного зміщення мінус один для стрижня)

 × симптом того

^{* Для отримання 1 байт на напівкокс, використовуйте {×(¯31+⎕UCS↑⍵)+.×(⍳≢↑⍵)-'|'⍳⍨↑⌽⍵}⎕TC[3]∘≠⊂⊢з ⎕ML←3. Спробуйте в Інтернеті!
** ⎕TCзастаріло і використовується тут лише для цілей гольфу. У виробничому коді слід використовувати ⎕UCS 10.}

Haskell (Lambdabot), 142 байти

l=length
g[a,c,b]=splitAt(l b)$a++(' '<$[1..l c-l a])
k e=sum$zipWith((*).(-31+).ord)e[1..]
f=signum.uncurry(-).(k.drop 1.reverse***k).g.lines

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

Безгольова версія:

-- for readability, allows reading top-down/left-right
(.>) = flip (.)

ungolfed =
     lines                                 -- separate out lines into..
  .> (\[a,b,c] ->                          -- a,b,c (first,second,third)
                                           -- ' ' pad the first line & split on pivot
       splitAt (length c) (a ++ replicate (length b - length a) ' ')
     )
  .> (weight.drop 1.reverse *** weight)    -- reverse left half, drop element above pivot & get weight for both
  .> uncurry (-)                           -- subtract right from left
  .> signum                                -- get sign

-- get ord of the character subtract 31 ('=' char from bar),
-- then multiply with scales ([1..]) and sum it all up
weight es = sum $ zipWith (ord .> subtract 31 .> (*)) es [1..]

Python 2 , 90 байт

def f(s):L=len(s)/3;print cmp(sum((ord(s[i])-31)*(i-s[-L:].find('|'))for i in range(L)),0)

Очікує, що рядки вводу будуть прокладені (з пробілами) до потрібної довжини. Виходи -1для падінь зліва , 0для збалансованості , а 1для падінь праворуч .

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

94 байти

Для +4 байтів ми можемо мати версію, яка, використовуючи whileцикл, вимагає позбавлених ліній, а не прокладених ліній:

def f(s):
 i=r=0
 while''<s[i]:r+=(ord(s[i])-31)*(i-s[-3::-1].find('='));i+=1
 print cmp(r,0)

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

Рубін, 543 байти

def willittip(s)
leftw=0;
rightw=0;
arr=[];
fields=s.split("\n")
pos=fields[2].index("|")
fields[0].split("").each do |i|
arr << i.ord-32
end
arr[pos+1..-1].each_with_index do |x,y|
rightw=rightw+1
if x>0
if pos>0
rightw=rightw+x*(pos-y).abs
else
rightw=rightw+x
end
end
end
arr[0..pos-1].each_with_index do |x,y|
leftw=leftw+1
if x>0
if pos>0
leftw=leftw+x*(pos-y).abs
else
leftw=leftw+x
end
end
end
if leftw==rightw
return "Equal"
elsif leftw<rightw
return "Right"
elsif leftw>rightw
return "Left"
end
end

C (gcc) , 106107 121 123 124 129 131 байт

c,b,l,i;f(char*a){l=strlen(a)/3;for(i=b=c=0;32/a[l*2+c];++c);for(;i<l-1;b+=(a[i]-31)*(i++-c));a=b>0?2:!b;}

Поверніть 0 для падіння ліворуч, 1 для балансу і 2 для падіння праворуч.

Потрібно, щоб усі три рядки мали однакову довжину і закінчили, \nщоб визначити довжину рядка.

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

Математика, 91 92 байт

Sign[(v=(g=ToCharacterCode)@#&@@(d=#~StringSplit~"
")-31).(Range@(l=Length)@v-l@g@Last@d)]&

Перший рядок повинен мати однакову довжину зі стрижнем. Третій рядок не повинен містити пробілів.

Повернення -1, 0, 1 для падіння ліворуч, рівноваги та падіння праворуч.

C # (.NET Core) , 127 95 90 + 18 = 108 байт

Для цієї функції перший рядок повинен бути викладений праворуч з пробілами, що мають однакову довжину, як стрижень, а в третьому рядку не повинно бути пробілів. Ця умова дозволена (див. Коментарі до запитання).

s=>s.Split('\n')[0].Select((c,i)=>(c-31)*(i-s.Split('\n')[2].Length+1)).Sum().CompareTo(0)

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

Виходи:

-1 для наконечника зліва
0 для балансу
1 для наконечника праворуч

Python 3, 217 байт

Також працює в Python 2.7

def f(s):i,b,p=s.split('\n');c=p.find('|');l=sum((ord(e)-32)*(c-i.find(e))for e in i[:c])+sum(x for x in range(1,c+1));r=sum((ord(e)-32)*i[c:].find(e)for e in i[c:])+sum(x for x in range(len(b[c:])));return(l>r)-(r>l)

Повертає 1 для лівого боку, -1 для правого боку або нуля, якщо врівноважено.

Читаема версія:

def f(s):
    i,b,p = s.split('\n')
    c = p.find('|')

    l = sum((ord(e)-32)*(c-i.find(e))for e in i[:c])+sum(x for x in range(1, c+1))
    r = sum((ord(e)-32)*i[c:].find(e)for e in i[c:])+sum(x for x in range(len(b[c:])))

    return(l>r)-(r>l)

PHP, 105 байт

for([$a,$b,$c]=explode("
",$argn);$b[$i];)$w+=(strpos($c,"|")-$i++)*8*(max(1,ord($a[$i])-31));echo$w<=>0;

відбитки -1/ 0/ 1для лівого / балансу / правого. Запустіть як трубу -nRабо спробуйте в Інтернеті .

зламатися

for([$a,$b,$c]=explode("\n",$argn); # import input
    $b[$i];)                        # loop through bar
    $f+=                                # add to force:
        ($i-strpos($c,"|"))             # distance (<0 if left, >0 if right of pivot)
        *8                              # *8
        *(max(1,ord($a[$i++])-31));     # *weight
echo$f<=>0;                         # print -1 if $f<0, 1 if $f>0, 0 if $f==0

Вугілля деревне , 31 байт

Ａ⁰ξＦＬθＡ⁺ξ×⁻ι⌕ζ|⁻℅§θι³¹ξＩ⁻›ξ⁰‹ξ⁰

Спробуйте в Інтернеті! Посилання на багатослівну версію коду. Виводи 0 для балансу або -1 або 1 для падіння ліворуч або праворуч. Редагувати: Зміни у вугіллі тепер означають, що він ≔ΣＥθ×⁻κ⌕ζ|⁻℅ι³¹ξＩ⁻›ξ⁰‹ξ⁰працює на 24 байти: Спробуйте в Інтернеті! Посилання на багатослівну версію коду. Примітка. Обидві відповіді потребують додаткового введення, але їх можна адаптувати, щоб прийняти невкладені дані вартістю 3 байти: ≔⁰ξＦＬη≔⁺ξ×⁻ι⌕ζ|⁻℅§◨θＬηι³¹ξＩ⁻›ξ⁰‹ξ⁰ Спробуйте в Інтернеті! ≔ΣＥ◨θＬη×⁻κ⌕ζ|⁻℅ι³¹ξＩ⁻›ξ⁰‹ξ⁰ Спробуйте в Інтернеті! Посилання на багатослівну версію коду.