genel bakış

3 satırlık bir dize verildiğinde, yapının sola doğru düşüp düşmediğini, dengeyi sağladığını veya sağa düşüp düşmediğini belirleyin.

Giriş yapısı

Yapının üstünde metal bir çubuk olarak hayal edersiniz, hepsi dikey bir çubuğun üstünde dengelidir.

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

İlk satır öğelerdir. Her bir öğenin ağırlığı, 32 eksi karakterinin ascii değeri olarak hesaplanır. (32'nin altındaki karakterler dikkate alınmaz ve boşluklar 0'dır). Bir öğenin çubuk üzerindeki kuvvetinin, ağırlığının pivot noktasına olan mesafesinin katları olduğunu unutmayın.

İkinci satır çubuktur. Her bir çubuk uzunluğu 1 birim ağırlığındadır. Bu çizgi sadece işaretlere eşittir ( =).

Üçüncü satır, pivot noktasıdır. Bu, herhangi bir yere yerleştirilebilir ve tek bir pipe ( |) karakteriyle takip edilen birkaç boşlukla temsil edilir .

Örnekler

Giriş:

=====
  |

Çıktı: Bakiye

Giriş:

=====
   |

Çıktı: Düşüyor

Giriş:

    %
=====
   |

Çıktı: Denge ( %Çubuğun sol tarafının ağırlığını gidermek için yeterince ağır olduğu için)

Giriş:

 aa
=======
   |

Çıktı: Sağa düşer ( asağdaki pivot noktasından daha uzakta olduğu için)

Giriş:

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

Çıktı: Düşüyor

Giriş:

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

Çıktı: Sağa düşüyor (küçük harfler ağır!)

Giriş:

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

Çıktı: Bakiye

notlar

• İzleyen boşluk boşluğuna izin verilir, öncü boşluk boşluğu kullanılmaz.
• Programınız, sol, denge ve sağ için 3 ayrı çıktı olduğu sürece istediğiniz biçimde çıkartabilir.
• Programınız giriş olarak gösterilen formatı kabul etmelidir.

JavaScript (ES6), 116 111 108 106 bayt

-5 bayt eval(array.join`+`)yerine toplayarak array.reduce().
-3 bayt 1yerine 32 - 31, parantezlerin kaldırılmasını sağlar.
Pivot noktasından beri -2 bayt, son satırın uzunluğudur - 1

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

Çıkışlar -1, 0ya 1sol için, sağ sırasıyla dengeli veya. Chas Brown'ın python cevabına benzeyen sona erdi , böylece kredi oraya gidiyor.

İlk satır kullanarak çubuk uzunluğuna uygun yastıklı ise 4 byte tasarruf edebilirsiniz
(31-t.charCodeAt(i))*(b.length+~i).

Test Parçacığı

Rakamla birlikte ek çıkış ( Left/ Balanced/ Right) içerir .

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>

Başka bir 106 bayt yöntemi

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

S joinüzerine bir dizi girmek yerine +, her biri ön ekli bir sayı dizisi yaratırız +. Lider +göz ardı edilir.

Python 2 , 112 110 bayt

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)

Çevrimiçi deneyin!

EDIT: Sonunda enumerateve rjust2 kızak bir bayt için ortadan kaldırmak başardı ... meh!

Bir dize alır; sol düşmeler için -1,0 veya 1 çıktısı, bakiyeler sırasıyla sağ düşüyor.

112 bayt'ta ilk geçiş:

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 bayt (girişi bir dize olarak alırsa 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 bayt değişken

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

188 bayt değişken

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

açıklama

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

Jöle , 30 bayt

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

Test odası

Dengeli için 0, sağ için 1 ve sola için -1 çıkışlar.

Nasıl çalışır

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              

Jöle , 24 bayt

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

Çevrimiçi deneyin!

-1sola düşmek 0için, dengelemek için, 1sağa düşmek için (tam program).
[-1]sola düşmek [0]için, dengelemek için, [1]sağa düşmek için (fonksiyon).

İlk satırda boşluklar olmalı, son satırda olmamalıdır.

Açıklama (alt satırdan başlıyoruz):

Her şeyden önce, bireysel çizgilerle çalışıyoruz, bu yüzden bir şekilde onları almamız gerekiyor. Bunun için bir iş Ỵ. Daha sonra, \ngirişin -split versiyonunu orijinal girişmiş gibi ele almamız gerekir , bu yüzden µmevcut değere bir monadik zincir yapmak için kullanırız .

Şimdi gerçek işe başlıyoruz ve ilk işimiz ağırlık faktörlerini hesaplamak olacaktır. Temel olarak bu, bir aralık [uzak soldan pivota olan mesafedir.0. Öncelikle, esasen iz bırakmayan boşlukları olmayan son satırın uzunluğu olan pivotun 1 tabanlı dizinini bulmalıyız. Bu yüzden, orijinal listemizdeki son çizgiyi (pivot çizgisi) açıyoruz Ṫ, çünkü artık ihtiyacımız olmayacak ve sonra uzunluğunu alıyoruz L. Daha sonra, çubuğun uzunluğunu almamız gerekir, bunun için de aynı şeyi en son çizgiye (çubuk çizgisine) yaparız ṪL$. Sonunda menzili elde etmek için, haritayı çıkardık | x - y | ila [1..rod uzunluğu], burada x pivot indeksi ve yÜzerinde harita yaptığımız listenin her bir öğesi. Bunu yaparken, do ạЀ, nerede ạhesaplar | x - y | ve Ѐçubuk uzunluğu dahil 1 ila 1 arasında bir aralık yapar. Şimdi istediğimiz aralığa sahip olacağız.

Bundan sonra, bir çubuk parçasını temsil eden her bir tamsayıyı, karşılık gelen ağırlığı ile çarpmak zorundayız. Ağırlıkları hesaplamak için kullanırız Ç, kodumuzun en üstündedir. Kalan çizgiyi Ṫcharcodes ile birlikte alıyoruz Ove sonra x - 31'i kullanarak _31, x'in her charcode olduğunu hesaplıyoruz. Daha sonra ağırlık 1 (0 + çubuk parçası = 1), !ağırlık 2 (1 + 1) vb. İçin alan tahsis ediyoruz. Üst satırla işimiz bitti, şimdi Çkarşılık gelen ile çarptığımız ağırlıkların listesini döndüreceğiz. çubuk parçalarını temsil eden tamsayılar ×.

Ondan sonra, ṣ00 ile temsil edilen pivot noktası ile ayrıldık (herhangi bir ağırlık sonucu etkilemeyecek çünkü) formun bir listesi ile sonuçlandı [[1. ağırlık, 2. ağırlık ... ağırlıktan hemen önce ağırlık] , [pivottan hemen sonraki ağırlık, önceki sondaki ağırlık ... son ağırlık]]. Bu listeler çubuğun sol ve sağ taraflarını temsil eder. Şimdi S€, her bir taraftaki toplam ağırlıkları almak için kullanılan listelerin her birini topluyoruz ve Isol taraf ağırsa, negatif, eşit ağırlıktaysa sıfır, sağ taraf ağırsa pozitif olan deltayı alıyoruz. . Dolayısıyla, bu sonucu kullanarak nihai sonucu kendi avantajımıza geri döndürmek için işareti alıyoruz Ṡ.

APL (Dyalog) , 43 bayt *

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

Çevrimiçi deneyin!

⊆⊢ argümanı, karakterlerin karakterlerine ayırma

⎕TC[2]∘≠ farklı 2 ^nci T erminal Cı ontrol karakteri (LF) **

{… } Dizge listesine aşağıdaki isimsiz işlevi uygulayın:

 ⊃⌽⍵ ters çevrilmiş listenin ilk dizesinde (yani sonuncu)

 '|'⍳⍨pivot noktasının Ndexini  bulun

 (… )- Bunu aşağıdaki listeden çıkarın:

  ⊃⍵ ilk dize

  ≢ uzunluğu

  ⍳ Tüm ɩ Bunun ndices

 (… )+.× Bu ağırlıklar ve aşağıdaki değerlerle ağırlıklı toplam:

  ⊃⍵ ilk dize

  ⎕UCS kod noktaları U niversal Cı haracter S ve

  ¯31+ Negatif otuz bir (eksi çubuk için gerekli ofset eksi için 32) ekleyin.

 × bunun imi

^{* Karakteri başına 1 bayt için kullanmak {×(¯31+⎕UCS↑⍵)+.×(⍳≢↑⍵)-'|'⍳⍨↑⌽⍵}⎕TC[3]∘≠⊂⊢ile ⎕ML←3. Çevrimiçi deneyin!
** ⎕TCburada kullanımdan kaldırılmıştır ve sadece golf amacıyla kullanılır. Üretim kodunda bir tane kullanılmalıdır ⎕UCS 10.}

Haskell (Lambdabot), 142 bayt

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

Çevrimiçi deneyin!

Ungolfed versiyonu:

-- 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 bayt

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

Giriş hatlarının doldurulmasını (boşluklu) doğru uzunlukta olmasını bekler. Çıkışlar -1için düşme bıraktı , 0için dengeli ve 1için doğru düşer .

Çevrimiçi deneyin!

94 bayt

+4 bayt için, bir whiledöngü kullanarak , yastıklı satırlar yerine soyulmuş satırlar gerektiren bir sürüme sahip olabiliriz :

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)

Çevrimiçi deneyin!

Ruby, 543 bayt

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 bayt

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

Sola düşen için 0, denge için 1 ve sağa düşen için 2 döndürün.

\nDize uzunluğunu belirlemek için üç çizginin hepsinin aynı uzunlukta olmasını ve bitmesini isteyin .

Çevrimiçi deneyin!

Mathematica, 91 92 bayt

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

İlk satır çubukla aynı uzunlukta olmalıdır. Üçüncü satırda sonda boşluk bulunmamalıdır.

Sola düşme, denge ve sağa düşme için -1, 0, 1 döndür.

C # (.NET Core) , 127 95 90 + 18 = 108 bayt

Bu fonksiyon için, ilk satır çubukla aynı uzunlukta olacak şekilde boşluklarla doldurulmalı ve üçüncü satır deneme boşluklarına sahip olmamalıdır. Bu şartlara izin verilir (sorunun yorumlarına bakınız).

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

Çevrimiçi deneyin!

Çıktılar:

-1 sol için
0
sağ, sol için 1 denge için

Python 3, 217 bayt

Ayrıca Python 2.7 de çalışır

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)

Sol taraf için 1, sağ taraf için -1, dengeliyse sıfır döndürür.

Okunabilir sürüm:

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 bayt

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

-1/ 0/ 1sola / denge / sağa yazdırır . Pipe ile çalıştırın -nRveya çevrimiçi deneyin .

Yıkmak

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

Kömür , 31 bayt

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

Çevrimiçi deneyin! Bağlantı, kodun ayrıntılı bir versiyonudur. Denge için 0, sola veya sağa düşmek için -1 veya 1 çıkışı. Düzenleme: Kömürdeki değişiklikler artık ≔ΣＥθ×⁻κ⌕ζ|⁻℅ι³¹ξＩ⁻›ξ⁰‹ξ⁰24 bayt için çalışıyor demektir : Çevrimiçi deneyin! Bağlantı, kodun ayrıntılı bir versiyonudur. Not: Her iki cevap da yastıklı giriş gerektirir, ancak 3 byte karşılığında paçasız girişi kabul etmek için uyarlanabilir: ≔⁰ξＦＬη≔⁺ξ×⁻ι⌕ζ|⁻℅§◨θＬηι³¹ξＩ⁻›ξ⁰‹ξ⁰ Çevrimiçi deneyin! ≔ΣＥ◨θＬη×⁻κ⌕ζ|⁻℅ι³¹ξＩ⁻›ξ⁰‹ξ⁰ Çevrimiçi deneyin! Bağlantılar, kodun ayrıntılı sürümüne yöneliktir.