एक सिम्युलेटर क्यों?

इन दिनों बच्चों के पास समय नहीं है और न ही वास्तव में जाने और देखने के लिए बक्से को ढेर करने या भौतिक वस्तुओं को संतुलित करने के साथ खेलने के लिए। यह सॉफ्टवेयर बाजार में बहुत सारे लीवर सिम्युलेटर के लिए छोड़ देता है, जो मेरे मॉडल के अनुसार, पागल की तरह बेच देगा!

प्रोग्रामिंग मदद चाहता था

मैंने इस तरह के खेल (लंबित) के लिए पेटेंट दायर किया है, लेकिन मेरे लिए खेल-तर्क लिखने के लिए एक विशेषज्ञ प्रोग्रामर की आवश्यकता है। मेरी समझ से, अंतिम कार्यक्रम के बाइट्स में आकार के आधार पर प्रोग्रामर को क्षतिपूर्ति करना मानक अभ्यास है । जैसे मैं सबसे कम बोली लगाने वाले को यह आकर्षक अनुबंध प्रदान करूंगा।

विशिष्टता

एक लीवर बक्से या खाली स्थानों की एक श्रृंखला है जो एक पूर्णक्रम द्वारा संतुलित है। प्रत्येक बॉक्स एक विशेष वजन है एक के माध्यम से नौ और रिक्त स्थान कोई वजन है। जैसा कि आप जानते हैं, लीवर पर एक बॉक्स का वजन सीधे उस आनुपातिक से कितना आनुपातिक है, यह बॉक्स फुलक्रम से है। भार का एक बक्सा 4जो फुलक्रम से तीसरे स्थान पर 12है, लीवर के उस तरफ बल की प्रभावी इकाइयों का योगदान देगा ।

मुझे एक प्रोग्राम की आवश्यकता है, जो एक इनपुट लीवर दिया जाता है, यह आउटपुट करेगा कि लीवर बाएं, दाएं की ओर तिरछा होगा या पूरी तरह से संतुलित होगा।

I / O दिशानिर्देश

आप मेरे लिए एक कार्यक्रम लिखेंगे।
इनपुट में पाठ की एक पंक्ति होगी।
इनपुट से 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मतलब के लिए छोड़ दिया भारी, राइट-भारी, संतुलित:

इनपुट: 11 ^9आउटपुट:B
इनपुट: 321^ 12आउटपुट:L
इनपुट: 9^ 1आउटपुट:R

(यदि किसी के पास कुछ "ट्रिकियर" परीक्षण मामले हैं, तो उन्हें संपादित करने के लिए स्वतंत्र महसूस करें)।

ग्रन्थसूची

जरूरी नहीं कि प्रेरित-द्वारा, लेकिन एक सीसा पर वजन के एक सेट को संतुलित करने से संबंधित है

code-golf decision-problem physics

— turbulencetoo
स्रोत

8

The output must either be print to stdout or be the return code of the program.खैर, अब आप मुझसे लिनक्स का वितरण करने के लिए कह रहे हैं जो निकास कोड के लिए सीसा-नोटेशन का उपयोग करता है।

— बिल्ली

1

मैं खेल-देखा / टेटर-टोट्टर पर खेलता हूँ, जब तक कि वे "असुरक्षित" नहीं हैं, ज्यादातर खेल के मैदानों ने उन्हें हटा दिया है। मुझे उम्मीद है कि उन्होंने कभी भी इस कारण से झूलों को नहीं हटाया। "बच्चे उनमें से कूद सकते हैं, ओह नहीं!"

— mbomb007

2

क्या इनपुट के खाली पक्ष हो सकते हैं? के रूप में ^16, 16^या ^? (यह मान लें)

— Runium

आह में एक छेद, हाँ, मुझे लगता है कि पक्ष खाली होगा

— टर्बुलेंसेटू

7

मैंने सिर्फ यह सोचकर कई लंबे सेकंड बिताए कि कैसे 3 या 4 से 11 ऑफसेट संभवत: 9 ऑफसेट 1 के साथ संतुलित हो सकते हैं।

— जेम्स थॉर्प

7

पायथन 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-बाइट का पायथ पोर्ट :

._s.e*-kxz\^%Cb16z

पायथन कोड के लिए, यदि एक पूर्ण कार्यक्रम की आवश्यकता है, तो यहां 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)

— XNOR
स्रोत

यहां आपकी विधि का उपयोग करके एक पायथ कार्यक्रम है जिसे आप पोस्ट कर सकते हैं यदि आप pyth.herokuapp.com/ ... 18 बाइट्स चाहते हैं । इसे स्वयं पोस्ट करने के बारे में सही नहीं लगा।

— माल्टेनसेन

@ मैलेटेन धन्यवाद, मैंने इसे शामिल किया।

— xnor

16

जावास्क्रिप्ट ईएस 6, 62 बाइट्स

s=>Math.sign([...s].reduce((p,c,i)=>p+~~c*(i-s.indexOf`^`),0))

-1 अगर छोड़ दिया गया है तो भारी है
0 अगर संतुलित है
1 अगर सही भारी है

Ungolfed:

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 बाइट्स: फंक्शन गुमनाम (धन्यवाद @ ctes-ob function)

— Dendrobium
स्रोत

3

यह आम सहमति है कि आप अग्रणी को छोड़ सकते हैं f=और कह सकते हैं कि यह एक अनाम फ़ंक्शन उत्पन्न करता है। (-2 बाइट्स FYI करें)

— कॉनर ओ'ब्रायन

5

जाप , 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

— ETHproductions
स्रोत

5

एपीएल, 39 30 बाइट्स

{×+/(10|⍵⍳⍨∊⍕¨⍳9)×(⍳⍴⍵)-⍵⍳'^'}

नियमों को फिर से लागू करने के बाद, मैंने इसे नौ बाइट की बचत के -1 0 1बजाय आउटपुट में बदल दिया है L B R।

इसे यहाँ आज़माएँ ।

— lirtosiast
स्रोत

4

अजगर, 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.

— isaacg
स्रोत

4

हास्केल, 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 है तो संतुलित है।

— nimi
स्रोत

4

TeaScript , 23 बाइट्स 25

मैंने एक पाइथ उत्तर लिखने की कोशिश की लेकिन वह बुरी तरह से चला गया: \

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

— Downgoat
स्रोत

4

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 को भी घटा नहीं सकता और तुलना नहीं कर सकता ... जब तक कि मैं वास्तव में मूर्खतापूर्ण कुछ नहीं करता।

दो योगों का योग ज्ञात कीजिए।
उस दूर तक दाईं ओर जाएं, जिस रेखा पर किसी चीज का उपयोग नहीं किया जा रहा है।
X = 0 तक पहुंचने तक, बाएं जाएं और 'L's रखें।
X = 0 पर एक 'B' रखें।
दो राशियों के योग से बचे।
X = 0 तक पहुंचने तक, दाईं ओर जाएं और 'R's' लगाएं।

फिर, आप बस एक्स = (बाईं ओर - दाईं ओर) पर जाएं, और आपका जवाब है! साफ करने के लिए उस लाइन पर सब कुछ हटा दें, और फिर उस मान को प्रिंट करें जो (0, 0) पर पाया गया था।

... लेकिन थोड़ा कम रास्ता है। 'L', 'B' और 'R' का उपयोग करने के बजाय, उन मानों - 'B' का उपयोग करें और छपाई करते समय 'B' को वापस जोड़ें। इस तरह, आपको कभी भी X = 0 पर 'B' नहीं रखना है, आप इसे केवल उसी तरह छोड़ते हैं जैसा कि पहले से था। एकमात्र समस्या यह है कि एक बार जब आप ऐसा करते हैं, तो प्रोग्राम वॉच मोड में बहुत नासमझ हो जाता है। 'L'-'B'==76-66==10=='\n'। लगता है कि सब कुछ ठीक काम कर रहा है, जब तक कि अचानक से बड़ी संख्या में नए अंक नहीं छप जाते हैं और जो चल रहा है उसका ट्रैक रखना असंभव है: डी पीबीआई के नियमित निष्पादन मोड में, हालांकि, सबकुछ ठीक काम करता है क्योंकि कुछ भी मुद्रित होने से पहले नए अंक हटा दिए जाते हैं। कंसोल।

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

— undergroundmonorail
स्रोत

3

जैसे आदमी के वंश को पागलपन में देखना।

— क्ज़कई

3

पर्ल 5, 72 बाइट्स

@_=split//,<>;($i)=grep$_[$_]eq'^',0..@_;$j+=$_*($k++-$i)for@_;say$j<=>0

— msh210
स्रोत

3

MATLAB 91, 57, 55 ऑक्टेव, 50 बाइट्स

मुझे इसके आगे बढ़ने की उम्मीद नहीं थी, लेकिन ऑक्टेव में जाने से 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 है, क्योंकि यह अपरिभाषित है।

यह हमें तीन संभावित परिणामों के लिए तीन अलग-अलग मूल्य देता है।

— स्टीवी ग्रिफिन
स्रोत

2

S, 22 चार्ट / 38 बाइट्स

МŴ⟬ïĊ⇀$+˜_*(ã-ïÿ⍘^),0⸩

Try it here (Firefox only).

— मामा फन रोल
स्रोत

2

-1, यह गिनती के लिए अनुकूलित है, न कि बाइट काउंट पर

— मेगो

यही built @Mego के लिए बनाया गया था।

— मामा फन रोल

3

इसके लिए चाहे जो भी बनाया गया हो, स्कोरिंग बाइट्स में है।

— Mego

मैं समझता हूँ कि।

— मामा फन रोल

2

जावास्क्रिप्ट, 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')}

बहुत बड़े पैमाने पर।

डेमो ।

— nicael
स्रोत

आप ES6 का उपयोग करके काफी कुछ बाइट्स बचा सकते हैं। पूरा function t(s){बन सकता है t=>{और बन split('^')सकता हैsplit`^`

— डाउनगोट

@ V @ आप का मतलब शायद s => {था?

— निकेल

ओह हाँ, क्षमा करें, यही मेरा मतलब है

— डाउगाट

@Ypnypn -6 chars :)

— nicael

2

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

व्याख्या

प्रत्येक पक्ष पर प्रत्येक संख्या का भारित मूल्य तय करता है। फिर यह दोनों पक्षों के 1,0, -1 को समानता / असमानता प्रदान करने के लिए रूबी स्पेसशिप ऑपरेटर का उपयोग करता है, जो सही आउटपुट के साथ एक सरणी का सूचकांक है।

— एलेक्सिस एंडरसन
स्रोत

2

पॉवरशेल, 83 73 बाइट्स

param($b)$i=-$b.indexOf('^');[char[]]$b|%{$x+=$i++*"$_"};[math]::Sign($x)

गोल्फ के लिए TessellatingHeckler के लिए धन्यवाद ।

अनिवार्य रूप से नीचे दिए गए पुराने कोड के समान एल्गोरिथ्म का उपयोग करता है, लेकिन यहां हम एक बार में सूचकांक के माध्यम से पुनरावृत्ति करने के बजाय इनपुट स्ट्रिंग एक में वर्णों के माध्यम से पुनरावृति करते हैं, जो मुट्ठी भर बाइट्स को बचाता है। एल्गोरिथ्म तक पहुँचने पर अभी भी वही शानदार त्रुटि संदेश फेंकता है ^- STDOUT को प्रभावित नहीं करता है।

पिछला

param($a)1..$a.length|%{$x+=+"$($a[$_-1])"*($_-$a.indexof('^')-1)};[math]::Sign($x)

डेंड्रोबियम के उत्कृष्ट उत्तर के रूप में उसी भयानक एल्गोरिथ्म का उपयोग करता है, और इस प्रकार -1 / 0 / 1इनपुट के समान आउटपुट का उपयोग करता है left-heavy / balanced / right-heavy।

ओह। लंबे समय से एक कास्टिंग ~~quirk~~ सुविधा है कि PowerShell है के कारण। यहाँ सबसे प्रासंगिक है कि कैसे कार्यों से charगुणा किया जाता intहै। stringकिसी charऑब्जेक्ट में परिणाम का एक सरणी-सूचकांक लेना । PowerShell charगुणन करने से पहले इसे अपने संबंधित ASCII मान (शाब्दिक मूल्य के बजाय) में परिवर्तित करता है। तो, $a='012'[0];[int]$a*2परिणाम में कुछ ऐसा है96 ।

इसका मतलब है कि हमें इसे एक स्ट्रिंग के रूप में फिर से कास्ट करने की आवश्यकता है। हालांकि, बस कर stringबार intहमें एक देता है stringकि कई बार दोहराया। उदाहरण के लिए, इसमें $a='0';$a*2परिणाम होगा00 ।

इसका मतलब है कि हमें पहले के charरूप में फिर से कास्ट करने के रूप में वापस कास्ट करने की आवश्यकता है , फिर गुणा हो सकता है, इससे पहले कि हम इसे हमारे नियामक में जोड़ देंstringint$x ।

युगल जो एक स्ट्रिंग के माध्यम से पुनरावृति करने के लिए लंबा रास्ता तय करते हैं, और साइन को आउटपुट करने के लिए .NET कॉल करते हैं, और हमें एक बहुत लंबा कोड मिलता है।

_{एनबी - यह ^स्ट्रिंग में पहुंचने पर एक शानदार त्रुटि फेंक देगा , यह कहते हुए कि यह इसे ए में परिवर्तित नहीं कर सकता है int। STDOUT को प्रभावित नहीं करता है।}

— AdmBorkBork
स्रोत

मेरे पास param($b)$i=-$b.indexOf('^');[char[]]$b|%{$x+=$i++*+"$_"};[math]::Sign($x)74 बाइट्स हैं। इसमें काफी समय लगा और कई तरह के प्रयास हुए। गणित :: साइन इतना लंबा दिखता है, लेकिन मैं उस बिट को बेहतर बनाने का कोई तरीका नहीं देख सकता।

— TessellatingHeckler

@TessellatingHeckler निश्चित रूप से, सूचकांकों के बजाय पात्रों के माध्यम से पुनरावृति ... समझ में आता है! मैं एक अतिरिक्त बाइट PowerShell की अंतर्निहित कास्टिंग का उपयोग करके गोल्फ $i++*+"$_"है $i++*"$_"अगर $iएक int है के बराबर है ।

— AdmBorkBork

1

सीजेएम, 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.

— रेटो कोराडी
स्रोत

1

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

स्पष्टीकरण:

से संख्याओं की सूची + बनाता है stdin।
प्रत्येक संख्या के लिए, कुल संख्या से पूर्णांक के समय की दूरी को चर में जोड़ता है (बाईं ओर संख्या नकारात्मक होगी और दाईं ओर संख्याएं सकारात्मक होंगी)।
परिणाम के आधार पर सही अक्षर प्रिंट करता है (बी यदि बराबर, एल यदि शून्य से अधिक है, और आर शून्य से कम है तो)।

82 बाइट्स (40% से अधिक) बंद करने के लिए @ThomasKwa के लिए बहुत धन्यवाद!

— Coder256
स्रोत

एक आसान 15 या तो बाइट्स: print('LBR'[(B>D)-(B<D)])अंत के लिए उपयोग करें , और B=D=0शुरुआत में।

— २०:५० पर lirtosiast

नहीं, और भी बेहतर: बाईं और दाईं ओर अलग से नज़र न रखें; इसके बजाय बाईं ओर की संख्याओं के लिए ऋणात्मक दूरी से गुणा करें ^। जो आपको abs()भी बचाता है।

— 23

1

सी, 140 139 138 134 100 बाइट्स

वापसी:

1 = बाएँ
2 = प्रतिबंधित
० = सही

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

Daud:

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

फिर कारक दूरी से योग करें ^।

— Runium
स्रोत

1

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 को आउटपुट करके कुछ बाइट्स को बंद कर सकता हूं।

— ब्रायन
स्रोत

1

जावा, 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));}

— रोमन ग्रैफ़
स्रोत

लीवर सिम्युलेटर 2015