अवलोकन

एक 3 लाइन स्ट्रिंग को देखते हुए, यह पता करें कि क्या संरचना बाईं ओर गिरती है, संतुलित होती है, या दाईं ओर गिरती है।

इनपुट संरचना

आप शीर्ष पर सामान के साथ धातु की छड़ के रूप में संरचना की कल्पना कर सकते हैं, सभी एक ऊर्ध्वाधर छड़ के शीर्ष पर संतुलित किया जा रहा है।

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

पहली पंक्ति आइटम है। प्रत्येक आइटम के वजन को वर्ण माइनस 32 के एससीआई मान के रूप में गणना की जाती है। (32 से कम वर्णों पर विचार नहीं किया जाता है और रिक्त स्थान का वजन 0 होता है)। ध्यान रखें कि छड़ पर किसी वस्तु का बल धुरी बिंदु से दूरी का वजन है।

दूसरी पंक्ति छड़ है। रॉड की प्रत्येक लंबाई का वजन 1 इकाई होता है। यह रेखा विशेष रूप से संकेत ( =) के बराबर है ।

तीसरी पंक्ति धुरी बिंदु है। इसे कहीं भी रखा जा सकता है, और एक पाइप ( |) वर्ण के बाद कई रिक्त स्थान द्वारा दर्शाया जाता है ।

उदाहरण

इनपुट:

=====
  |

आउटपुट: संतुलन

इनपुट:

=====
   |

आउटपुट: फॉल्स छोड़ दिया

इनपुट:

    %
=====
   |

आउटपुट: शेष (क्योंकि %रॉड के बाईं ओर के वजन का मुकाबला करने के लिए पर्याप्त वजन होता है)

इनपुट:

 आ
=======
   |

आउटपुट: फॉल्स राइट (क्योंकि aदाईं ओर धुरी बिंदु से दूर है)

इनपुट:

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

आउटपुट: फॉल्स छोड़ दिया

इनपुट:

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

आउटपुट: फॉल्स राइट (लोअर केस लेटर्स भारी हैं!)

इनपुट:

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

आउटपुट: संतुलन

अनुगामी व्हाट्सएप की अनुमति है, प्रमुख व्हाट्सएप नहीं है।
आपके कार्यक्रम को आप जिस भी प्रारूप में पसंद करते हैं उसमें आउटपुट कर सकते हैं, जब तक कि बाएं, संतुलन और दाएं के लिए 3 अलग-अलग आउटपुट हैं।
आपके कार्यक्रम को इनपुट के रूप में दिखाए गए प्रारूप को स्वीकार करना चाहिए।

code-golf parsing physics

— पागल
स्रोत

1

निकटता से संबंधित

— लुइस मेंडो

कार्यक्रम तीन लाइनों को तीन अलग-अलग स्ट्रिंग्स के रूप में ले सकता है (जैसे कि फ़ंक्शन के तीन तर्क या तीन तत्व सूची के रूप में)?

— नॉटजैगन

@notjagan इनपुट को नई लाइन वर्णों द्वारा अलग किया गया एक स्ट्रिंग होना चाहिए।

— डफली

संबंधित , संभव है।

— xnor

@xnor कोई डुप्लिकेट नहीं है क्योंकि यह प्रश्न केवल अपरकेस अक्षरों से संबंधित है, और इसका लक्ष्य धुरी को खोजना है। मेरा प्रश्न सभी एएससीआई पात्रों = = 32 के बारे में है, और मेरा पिवट की आपूर्ति करता है और पूछता है कि क्या संरचना खत्म हो जाएगी। अनिवार्य रूप से आपके द्वारा लिंक किए गए एक के विपरीत।

— पागल

8

जावास्क्रिप्ट (ईएस 6), 116 111 108 106 बाइट्स

के eval(array.join`+`)बजाय के माध्यम से संक्षेप द्वारा -5 बाइट्स array.reduce()। इसके बजाय
डिफ़ॉल्ट रूप से -3 बाइट्स , जिससे कोष्ठकों को हटाया जा सके।132 - 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पर एक सरणी के बजाय +, हम संख्याओं की एक स्ट्रिंग बनाते हैं, प्रत्येक उपसर्ग +। अग्रणी +को नजरअंदाज कर दिया जाता है।

— जस्टिन मेरिनर
स्रोत

1

मुझे लगता है कि (b.length+~i)बाइट को बचाने में मदद मिल सकती है। (इसके अलावा मुझे समझ नहीं आता कि आपके पास क्यों है ||1।)

— नील

1

@ नील b.length+~iने नकारात्मक वापसी की i-b.length+1; अगर मैं दूसरे हिस्से को नकार सकता हूं तो इससे मदद मिल सकती है। उस के लिए ||1, ऐसा इसलिए था क्योंकि मैं मान रहा था कि पहली पंक्ति को रॉड की लंबाई से मिलान करने के लिए गद्देदार नहीं किया गया था, इसलिए पहली पंक्ति के अंत से परे t.charCodeAt(i)लौट आएगा NaN।

— जस्टिन मेरिनर

हालांकि मैं एक गैर-गद्देदार परीक्षण मामले की कोशिश करने के लिए नहीं था; समझाने के लिए धन्यवाद।

— नील

3

पायथन 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)

इसे ऑनलाइन आज़माएं!

संपादित करें: अंत में enumerateऔर rjustएक 2 बाइट्स के लिए समाप्त करने में कामयाब रहे ... 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)

— चास ब्राउन
स्रोत

(ord(c)-31)मुझे यह महसूस करने में थोड़ा समय लगा कि यह वास्तव में रॉड के वजन को आइटम के साथ शामिल कर रहा है। बहुत चालाक!

— डैफी

1

मेटा के अनुसार , आप -1 बाइट के returnसाथ बदल सकते हैं print(हालांकि यह वास्तव में वर्तमान TIO कोड के साथ अच्छी तरह से नहीं खेलता है)।

— नॉटजैगन

3

हास्केल, 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

— सर्गी मार्टीनेंको जूनियर
स्रोत

1

आप के fromEnumबजाय का उपयोग कर सकते हैं ordऔर ड्रॉप import। (या ) के साथ cसरलीकृत किया जा सकता है और जैसा कि आप इसे केवल एक बार उपयोग कर रहे हैं, इसे इनलाइन करें। c p=max(ord p-32)0fromEnum

— नमि

या आप (लैम्बडाबोट) को अपने शीर्षक में जोड़ सकते हैं, यह आपकी जरूरत की हर चीज का आयात करता है, यहां देखें ।

— ბიმო

1

समारोह cको और भी सरल बनाया जा सकता है (32 से कम उम्र के वर्णों पर विचार नहीं किया गया है) c p=ord p-32। यह pभी मूल रूप से length(शून्य से 1) है, इसलिए p x=length x-1भी काम करेगा (और आप इसे भी इनलाइन कर सकते हैं)। मेरे समाधान पर एक नज़र डालें, मैं कैसे उपयोग करता हूं signum- आप कर सकते हैं r o l s = signum $ 2 * z ...जो 0,1,-1बी, एल, आर के लिए रिटर्न देता है ।

— ბიმო

1

इसके अलावा, यह समाधान परीक्षण मामलों को विफल करने के लिए लगता है [3,4,7]और एक के बजाय 3 स्ट्रिंग्स लेता है। (देखें lines)।

— ბიმო

1

यहाँ कुछ युक्तियों के साथ एक संस्करण लागू होता है (आपको 29 बाइट्स बचाता है;))।

— ბიმო

2

जेली , 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

— fireflame241
स्रोत

2

जेली , 24 बाइट्स

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

इसे ऑनलाइन आज़माएं!

-1बाएं गिरने के लिए, 0संतुलन के लिए, 1दाएं गिरने के लिए (पूर्ण कार्यक्रम)। संतुलन के
[-1]लिए गिरने के [0]लिए,[1] दाएं गिरने के लिए (फ़ंक्शन)।

पहली पंक्ति में अनुगामी स्थान होना चाहिए, अंतिम पंक्ति में नहीं होना चाहिए।

स्पष्टीकरण (हम नीचे पंक्ति से शुरू करते हैं):

सबसे पहले, हम व्यक्तिगत लाइनों के साथ काम कर रहे हैं, इसलिए हमें किसी तरह उन्हें प्राप्त करने की आवश्यकता है। यह एक नौकरी के लिए है Ỵ। फिर, हमें \nइनपुट के -split संस्करण का इलाज करने की आवश्यकता है जैसे कि यह मूल इनपुट था, इसलिए हम उपयोग करते हैंµ वर्तमान मूल्य पर लागू एक मौद्रिक श्रृंखला बनाने के लिए करते हैं।

अब हम असली काम शुरू करते हैं, और हमारा पहला काम वजन के कारकों की गणना करना होगा। अनिवार्य रूप से यह एक सीमा है [दूर से बाईं ओर की धुरी।।।। धुरी से दूर दाईं ओर]। सबसे पहले, हमें धुरी के 1-आधारित सूचकांक को ढूंढना होगा, जो अनिवार्य रूप से रिक्त स्थान के बिना अंतिम पंक्ति की लंबाई है। इसलिए हम अपनी मूल सूची से अंतिम पंक्ति (धुरी रेखा) को पॉप करते हैं Ṫ, क्योंकि हमें अब इसकी आवश्यकता नहीं होगी, और फिर हम इसकी लंबाई ले लेंगे L। फिर हमें रॉड की लंबाई लेने की आवश्यकता होती है, जिसके लिए हम एक ही काम करते हैं अब-अंतिम लाइन (रॉड लाइन) के साथ ṪL$। अंत में, रेंज पाने के लिए, हम नक्शा | x - y | [1..rod लंबाई], जहां हम सूची के प्रत्येक तत्व को देखते हैं। हम इसका उपयोग करते हैं x धुरी सूचकांक और y हैạÐ€ , जहां ạगणना करता है | x - y | तथाÐ€ रॉड की लंबाई सहित 1 तक और सीमा बनाता है। अब हमारे पास वह रेंज होगी जो हम चाहते हैं।

उसके बाद, हमें प्रत्येक पूर्णांक को गुणा करना होगा, रॉड के एक टुकड़े का प्रतिनिधित्व करते हुए, इसके संबंधित वजन के साथ। वजन की गणना करने के लिए, हम उपयोग करते हैं Ç, हमारे कोड की शीर्ष रेखा पर जाते हैं। हम शेष रेखा को Ṫ, इसके चारकोड के साथ लेते हैं O, और फिर हम x - 31 का उपयोग करते हुए गणना करते हैं _31, x प्रत्येक चारकोड के साथ। फिर हम वेट 1 (0 + रॉड पीस = 1), !वेट 2 (1 + 1) आदि के लिए स्पेस असाइन करते हैं । हम टॉप लाइन के साथ काम कर रहे हैं, इसलिए अब Çवेट की सूची लौटा देंगे, जिसे हम संबंधित के साथ गुणा करेंगे। पूर्णांकों के साथ रॉड के टुकड़ों का प्रतिनिधित्व करते हैं× ।

उसके बाद, हम ṣ00 (जिसका कोई भी परिणाम परिणाम को प्रभावित नहीं करेगा) द्वारा प्रस्तुत धुरी बिंदु पर विभाजित होता है , जिसके परिणामस्वरूप प्रपत्र की सूची [[1 वजन, 2 वाँ वजन ... धुरी के ठीक पहले वजन] [धुरी के बाद वजन, पहले एक के बाद वजन ... अंतिम वजन]]। वे सूचियाँ छड़ के किनारों को बाएँ और दाएँ दर्शाती हैं। अब हम S€प्रत्येक पक्ष पर कुल भार प्राप्त करने के लिए उपयोग करने वाली प्रत्येक सूची का योग करते हैं , और Iडेल्टा का उपयोग करने के लिए उपयोग करते हैं, जो नकारात्मक होगा यदि बाईं ओर भारी है, शून्य है यदि वे समान-भारित हैं, और सकारात्मक अगर दाएं तरफ भारी है । तो, हमारे लाभ के लिए इसे ठीक से उपयोग करके अंतिम परिणाम वापस करने के लिए, हम साइन इन करते हैं Ṡ।

— आउटग्रॉफर को एरिक करें
स्रोत

2

APL (Dyalog) , 43 बाइट्स *

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

इसे ऑनलाइन आज़माएं!

⊆⊢ तर्क को वर्णों के रनों में विभाजित करें

⎕TC[2]∘≠2 ^{एन डी} टी erminal C से अलग ontrol चरित्र (linefeed) **

{… } स्ट्रिंग्स की सूची पर निम्नलिखित अनाम फ़ंक्शन लागू करें:

⊃⌽⍵ उलटी सूची के पहले तार में (यानी अंतिम)

'|'⍳⍨धुरी बिंदु के the ndex का पता लगाएं

(... )- निम्नलिखित सूची से घटाएँ:

⊃⍵ पहला तार

≢ इसकी लंबाई

⍳ उस के सभी d ndices

(... )+.× उन भार और निम्नलिखित मूल्यों के साथ भारित राशि:

⊃⍵ पहला तार

⎕UCSयू niversal सी हैचर एस एट में कोड अंक

¯31+ नकारात्मक इकतीस जोड़ो (32 आवश्यक छड़ के लिए शून्य से एक छड़ी के लिए)

× उस के हस्ताक्षर

^{* प्रति बाइट प्रति चार के लिए, के {×(¯31+⎕UCS↑⍵)+.×(⍳≢↑⍵)-'|'⍳⍨↑⌽⍵}⎕TC[3]∘≠⊂⊢साथ उपयोग करें ⎕ML←3। इसे ऑनलाइन आज़माएं!

** ⎕TCकेवल यहां गोल्फिंग के उद्देश्य से पदावनत और उपयोग किया जाता है। उत्पादन कोड में, एक का उपयोग करना चाहिए ⎕UCS 10।}

— एडम
स्रोत

2

हास्केल (लैंबडॉट), 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

इसे ऑनलाइन आज़माएं!

Ungolfed संस्करण:

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

पायथन 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)

इसे ऑनलाइन आज़माएं!

— FlipTack
स्रोत

1

रूबी, 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

— KittenDev
स्रोत

10

PPCG में आपका स्वागत है! : डी कोड-गोल्फ चुनौतियों के लिए लक्ष्य अपने कोड को यथासंभव छोटा बनाना है। आप सभी चर और फ़ंक्शन नामों को एक एकल वर्ण बनाकर और जहां भी संभव हो व्हाट्सएप को हटाकर अपने कोड आकार को कम कर सकते हैं।

— डफी

1

सी (जीसीसी) , 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स्ट्रिंग की लंबाई निर्धारित करने के लिए एक ही लंबाई और खत्म करने के लिए सभी तीन लाइनों की आवश्यकता होती है।

इसे ऑनलाइन आज़माएं!

— कीउ गण
स्रोत

1

गणितज्ञ, 91 92 बाइट्स

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

पहली पंक्ति में रॉड के साथ समान लंबाई होनी चाहिए। तीसरी पंक्ति में कोई अनुगामी स्थान नहीं होना चाहिए।

रिटर्न -1, 0, 1 बायें गिरने, बैलेंस और दाएं गिरने के लिए।

— कीउ गण
स्रोत

1

सी # (.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 बाएं के लिए
0 शेष के लिए
1 टिप दाएं के लिए

— raznagul
स्रोत

1

पायथन 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, राइट-साइड के लिए, या शून्य यदि संतुलित है।

पठनीय संस्करण:

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

आप की जरूरत नहीं है sum([...]), आप बस हो सकता हैsum(...)

— श्री Xcoder

@ यह आपके विनिर्देशन और सभी दिए गए उदाहरण इनपुट के अनुरूप 100% होना चाहिए। यदि आप सहमत हैं तो कृपया मुझे बताएं ताकि मैं इसे और अनुकूलित कर सकूं। धन्यवाद।

— veganaiZe

@veganaiZe ने मेरे सारे टेस्ट पास कर लिए, अच्छा लग रहा है! :)

— पागल

1

इसे छोटा करने के लिए सामग्री: उपयोग, उपयोग और सभी की आवश्यकता से बच i[c:].find(e)सकते हैं i.find(e,c), अंत में परीक्षण लागत को नाटकीय रूप से कम करने के लिए उपयोग करें (वापसी मूल्य संख्यात्मक रूप से बराबर है, लेकिन यह हैi,m,n=s.split('\n')sreturn 2*(r>l) or l>rTrue के बजाय 1और Falseके बजाय 0), या वास्तव में, वापसी का एक अलग सेट का उपयोग मान और return (l>r)-(r>l)1, 0 या -1 को वापस करने के लिए करते हैं जिस तरह से पुराने cmpफ़ंक्शन ने किया था।

— शैडो रेंजर

धन्यवाद ShadowRanger, श्री Xcoder, और Daffy! @ShadowRanger मुझे साथ रहना पड़ा i[c:]क्योंकि छोटे रास्ते ने कुछ कोने-मामले के इनपुट के लिए एक अजीब ऑफ-बाय-वन इश्यू का कारण बना ( |बार के ठीक बीच में - बिल्कुल ऊपर रखने की कोशिश करें )।

— veganaiZe

1

पीएचपी, 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

— टाइटस
स्रोत

1

चारकोल , 31 बाइट्स

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

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। शेष या दाएं गिरने के लिए आउटपुट 0 या -1 या 1 के लिए। संपादित करें: चारकोल में परिवर्तन का अब मतलब है कि ≔ΣＥθ×⁻κ⌕ζ|⁻℅ι³¹ξＩ⁻›ξ⁰‹ξ⁰24 बाइट्स के लिए काम करता है: इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। नोट: दोनों उत्तरों के लिए गद्देदार इनपुट की आवश्यकता होती है, लेकिन 3 बाइट्स की कीमत पर अनपेड इनपुट स्वीकार करने के लिए अनुकूलित किया जा सकता है: ≔⁰ξＦＬη≔⁺ξ×⁻ι⌕ζ|⁻℅§◨θＬηι³¹ξＩ⁻›ξ⁰‹ξ⁰ इसे ऑनलाइन आज़माएं! ≔ΣＥ◨θＬη×⁻κ⌕ζ|⁻℅ι³¹ξＩ⁻›ξ⁰‹ξ⁰ इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए हैं।

— नील
स्रोत

आप यह उल्लेख करना चाहते हैं कि यह इनपुट लाइनों को रिक्त स्थान के साथ सही लंबाई तक गद्देदार करने की उम्मीद करता है, इसलिए अनपेड इनपुट काम नहीं कर सकता है।

— फ्लिपकार्ट

@FlipTack बेहतर अभी भी, मैंने ऐसे संस्करण तैयार किए हैं जो अनपेड इनपुट स्वीकार करते हैं।

— नील

क्या मैं टिप करूंगा?

अवलोकन

इनपुट संरचना

उदाहरण

टिप्पणियाँ

जावास्क्रिप्ट (ईएस 6), 116 111 108 106 बाइट्स

टेस्ट स्निपेट

एक और 106 बाइट विधि

पायथन 2 , 112 110 बाइट्स

हास्केल, 212 171 बाइट्स (188 यदि एक स्ट्रिंग के रूप में इनपुट लेते हैं)

जेली , 30 बाइट्स

जेली , 24 बाइट्स

APL (Dyalog) , 43 बाइट्स *

हास्केल (लैंबडॉट), 142 बाइट्स

Ungolfed संस्करण:

पायथन 2 , 90 बाइट्स

94 बाइट्स

रूबी, 543 बाइट्स

सी (जीसीसी) , 106107 121 123 124 129 131 बाइट्स

गणितज्ञ, 91 92 बाइट्स

सी # (.NET कोर) , 127 95 90 + 18 = 108 बाइट्स

पायथन 3, 217 बाइट्स

पायथन 2.7 में भी काम करता है

पठनीय संस्करण:

पीएचपी, 105 बाइट्स

चारकोल , 31 बाइट्स