개요

3 줄 문자열이 주어지면 구조가 왼쪽으로 떨어지거나 균형을 잡거나 오른쪽으로 떨어지는 지 알아냅니다.

입력 구조

상단에 물건이있는 금속 막대의 구조를 상상할 수 있습니다.

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

첫 번째 줄은 항목입니다. 각 항목의 가중치는 문자 빼기 32의 ASCII 값으로 계산됩니다 (32 자 미만의 문자는 고려되지 않으며 공백의 무게는 0 임). 로드에 대한 항목의 힘은 무게와 피벗 포인트의 거리를 곱한 것입니다.

두 번째 줄은 막대입니다. 막대의 각 길이는 자체적으로 1 단위입니다. 이 줄은 독점적으로 부호 ( =) 와 같습니다 .

세 번째 선은 피벗 점입니다. 이것은 어디에나 배치 할 수 있으며 여러 개의 공백과 단일 파이프 ( |) 문자로 표시됩니다.

예

입력:

=====
  |

출력 : 밸런스

입력:

=====
   |

출력 : 남은 폭포

입력:

    %
=====
   |

출력 : 밸런스 ( %로드 왼쪽의 무게를 견딜 수있을만큼 무게가 나가므로)

입력:

 aa
=======
   |

출력 : 오른쪽으로 떨어짐 (오른쪽 a의 피벗 지점에서 더 멀리 떨어져 있기 때문에 )

입력:

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

출력 : 남은 폭포

입력:

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

출력 : 오른쪽으로 떨어짐 (소문자가 무겁습니다!)

입력:

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

출력 : 밸런스

노트

• 후행 공백은 허용되며 선행 공백은 허용되지 않습니다.
• 왼쪽, 균형 및 오른쪽에 대해 3 개의 고유 한 출력이있는 한 프로그램은 원하는 형식으로 출력 할 수 있습니다.
• 프로그램은 입력으로 표시된 형식을 승인해야합니다.

자바 스크립트 (ES6) 116 111 108 106 바이트

eval(array.join`+`)대신에 를 통해 -5 바이트를 계산 합니다 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왼쪽에 대해, 오른쪽, 각각 균형, 또는. Chas Brown의 python answer 와 비슷한 결과를 얻었 으므로 신용이 이어집니다.

를 사용하여 첫 번째 줄이 막대의 길이와 일치하도록 채워지면 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의 배열 을 사용 하는 대신 +앞에 접두사가 붙은 숫자 문자열을 만듭니다 +. 선행 +은 무시됩니다.

파이썬 2 , 112110 바이트

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)

온라인으로 사용해보십시오!

편집 : 마침내 enumerate와 rjust2 바이트 를 제거 할 수있었습니다 ... meh!

문자열을받습니다; 출력 -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)

하스켈 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$. 마지막으로 범위를 얻기 위해 | x - y | [1 ..로드 길이]로, 여기서 x 는 피벗 인덱스이고 y는우리가 매핑 한 목록의 각 요소입니다. 우리는이 사용합니까 ạЀ여기서 ạ계산 | x - y | 및 Ѐ1 내지 상기로드 길이를 포함한 다양한한다. 이제 우리는 우리가 원하는 범위를 가질 것입니다.

그런 다음 막대 조각을 나타내는 각 정수에 해당 가중치를 곱해야합니다. 가중치를 계산 Ç하기 위해 코드의 맨 윗줄로 이동합니다. 우리는 나머지 줄을로 사용 Ṫ하고 그 문자를로 사용 하고 x를 사용하여 x -31 을 O계산 합니다. x 는 각 문자 코드입니다. 그런 다음 가중치 1 (0 +로드 피스 = 1), 가중치 2 (1 + 1) 등에 공간을 할당합니다 . 우리는 맨 윗줄로 완료되었으므로 이제 가중치 목록을 반환합니다. 로 막대 조각을 나타내는 정수 ._31!Ç×

그 후, 우리 ṣ0는 피벗 포인트에서 0으로 표시됩니다 (결과에 영향을 미치지 않기 때문에). [[첫 번째 무게, 두 번째 무게 ... 피벗 직전의 무게]) , [피벗 직후 무게, 이전 무게 이후 무게 ... 마지막 무게]]. 이 목록은 막대의 측면을 좌우로 나타냅니다. 우리는 이제 각 목록을 S€합하여 각 측면의 총 가중치를 얻고 I델타를 취합니다. 왼쪽이 더 무거 우면 음수, 같은 가중치를 적용하면 0, 오른쪽이 무거 우면 양수 . 따라서 이것을 사용하여 최종 결과를 우리에게 유리하게 반환하기 위해로 부호를 붙입니다 Ṡ.

APL (Dyalog) , 43 바이트 *

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

온라인으로 사용해보십시오!

⊆⊢ 인수를 문자의 연속으로 분할

⎕TC[2]∘≠ 로부터 다른 2 ^차 T erminal C 조작부 문자 (라인 피드) **

{… } 문자열 목록에 다음 익명 함수를 적용하십시오.

 ⊃⌽⍵ 반전 된 목록의 첫 번째 문자열에서 (즉 마지막)

 '|'⍳⍨피벗 포인트  의 ɩ ndex 찾기

 (… )- 다음 목록에서 빼십시오.

  ⊃⍵ 첫 번째 문자열

  ≢ 길이

  ⍳ 그 모든 ndi 가지

 (… )+.× 그 가중치와 다음 값을 가진 가중치 합계 :

  ⊃⍵ 첫 번째 문자열

  ⎕UCS 코드 포인트 U WiFi의 C haracter S 외

  ¯31+ 마이너스 31을 추가하십시오 (필요한 오프셋의 경우 32-로드의 경우 -1).

 × 그것의 signum

^{* 문자 당 1 바이트의 경우 {×(¯31+⎕UCS↑⍵)+.×(⍳≢↑⍵)-'|'⍳⍨↑⌽⍵}⎕TC[3]∘≠⊂⊢와 함께 사용하십시오 ⎕ML←3. 온라인으로 사용해보십시오!
** ⎕TC여기서는 더 이상 사용되지 않으며 골프 목적으로 만 사용됩니다. 프로덕션 코드에서는을 사용해야합니다 ⎕UCS 10.}

하스켈 (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..]

파이썬 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 코어) , 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, 팁 오른쪽의
저울
1의 경우 0

파이썬 3, 217 바이트

파이썬 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, 균형이 맞으면 0을 반환합니다.

읽을 수있는 버전 :

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 바이트의 비용으로 패딩되지 않은 입력을 허용하도록 조정할 수 있습니다. ≔⁰ξＦＬη≔⁺ξ×⁻ι⌕ζ|⁻℅§◨θＬηι³¹ξＩ⁻›ξ⁰‹ξ⁰ 온라인으로 사용해보십시오! ≔ΣＥ◨θＬη×⁻κ⌕ζ|⁻℅ι³¹ξＩ⁻›ξ⁰‹ξ⁰ 온라인으로 사용해보십시오! 링크는 자세한 버전의 코드로 연결됩니다.