संतुलनकारी कार्य

एक देखा-देखा (माना जाता है कि फ्रांसीसी 'सी-आईका', जिसका अर्थ है 'यह-वह') समान रूप से सर्वव्यापी स्लाइड और स्विंग के साथ, खेल के मैदान के पवित्र ट्रिनिटी का एक तिहाई बनाता है। एक देखा-देखा सही संतुलन में है अगर, और केवल अगर, प्रत्येक पक्ष पर क्षणों का योग बराबर है। एक देखा-देखा इसलिए कम पल राशि के साथ पक्ष में एक विशिष्ट मात्रा में वजन जोड़कर संतुलित किया जा सकता है; इसे प्राप्त करना इस चुनौती के लिए आपका लक्ष्य है।

चुनौती

आपकी चुनौती इनपुट के रूप में एक देखा-देखा चित्रण करना है और इसे फिर से आउटपुट करना है, साथ ही इसे संतुलित करने के लिए देखा-देखी के एक छोर पर वजन जोड़ा गया है।

इनपुट

आपका कार्यक्रम किसी भी उचित प्रारूप में, ASCII देखना-देखा जाना चाहिए जैसे कि निम्नलिखित:

100             100
-------------------
         ^

पहली पंक्ति में दो संख्याएँ होती हैं, जिनमें से प्रत्येक को देखा-देखी पर भार होता है। बिल्कुल एक वजन प्रत्येक पक्ष पर मौजूद है, प्रत्येक अपने तख़्त के किनारे के छोर पर अभिनय करता है। वजन पूर्णांक होने की गारंटी है, और हमेशा तख़्त के अपने अंत के साथ संरेखित करें। ये संख्या कभी भी पूर्णांक ( ^) को ओवरलैप नहीं करेगी ।

दूसरी पंक्ति दृश्य-आरा के 'तख्ती' का प्रतिनिधित्व करती है। प्रत्येक डैश ( -) एक दूसरे की डैश के बराबर लंबाई का प्रतिनिधित्व करता है, डैश के एकमात्र अपवाद के साथ सीधे पूर्णक्रम ( ^) पर, जिसकी कोई लंबाई नहीं है।

तीसरी पंक्ति दृश्य-आरी के फुलक्रैम का प्रतिनिधित्व करती है। इस फुलक्रैम को एकमात्र चरित्र द्वारा चिह्नित किया जाता है जो इस लाइन पर एक स्थान नहीं है, जो एक circumflex ('^') है। फुलक्रम को एक वैध इनपुट में तख़्त की लंबाई के साथ कहीं भी रखा जा सकता है, जब तक कि पर्याप्त जगह न रह जाए ताकि वेट का प्रतिनिधित्व करने वाले नंबर इनपुट या आउटपुट में फुलक्रम को ओवरलैप न करें।

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

उत्पादन

आउटपुट के लिए, एक ही सी-सॉ चित्रण को stdout में मुद्रित किया जाना चाहिए, लेकिन वेट के एक (और केवल एक) को एक बड़े वजन के साथ बदल दिया गया, ताकि सी-व्यू को संतुलित किया जा सके। केवल पूर्णांक का उपयोग करके यह संभव बनाने के लिए इनपुट की गारंटी दी जाती है। इसलिए, दशमलव बिंदुओं या अन्य समान सूचनाओं के बिना वज़न दिखाया जाना चाहिए। यदि आपकी भाषा stdout का उपयोग नहीं करती है तो आपको आउटपुट पर समुदाय / मेटा सर्वसम्मति से जाना चाहिए। अनुगामी newlines ठीक हैं, लेकिन चित्रण प्रारूप में कोई अन्य परिवर्तन संभवतः ठीक नहीं हैं।

दृष्टांत

परीक्षण इनपुट और पत्राचार आउटपुट

इनपुट 1

12                22
--------------------
             ^

आउटपुट 1

12                26
--------------------
             ^

इनपुट 2

42       42
-----------
     ^

आउटपुट 2

42       42
-----------
     ^

इनपुट 3

3             16
----------------
        ^

आउटपुट 3

14            16
----------------
        ^

इनपुट 4

1                56
-------------------
    ^

आउटपुट 4

196              56
-------------------
    ^

संदर्भ कार्यान्वयन - पायथन 3

# Takes a list of strings as input
def balance_seesaw(lines):
    weights = [int(w.strip()) for w in lines[0].split()]

    length  = len(lines[1])
    pivot   = lines[2].find("^")
    left_length    = pivot
    right_length   = length - 1 - pivot

    left_torque  = weights[0] * left_length
    right_torque = weights[1] * right_length

    if left_torque > right_torque:
        weights[1] = left_torque // right_length
    elif right_torque > left_torque:
        weights[0] = right_torque // left_length

    weights = [str(w) for w in weights]

    string_gap = " " * (length - sum(len(w) for w in weights))
    lines[0] = weights[0] + string_gap + weights[1]

    print("\n".join(lines))

balance_seesaw(["1                56",
                "-------------------",
                "    ^              "])

नियम

यह कोड-गोल्फ है , इसलिए सबसे छोटा कोड बाइट्स में गिना जाता है। मेटा की जाँच करें यदि बाइट्स गिनना आपकी भाषा में अजीब है।
मानक नियम / कमियां लागू होती हैं।
इनपुट एक उचित प्रारूप में लिया जाना चाहिए। उचित स्वरूपों की एक गैर-विस्तृत सूची निम्नानुसार दी गई है:
- न्यूलाइन वर्णों द्वारा अलग की गई लाइनों के साथ एक एकल स्ट्रिंग
- तार की एक सूची, प्रत्येक स्ट्रिंग एक रेखा का प्रतिनिधित्व करती है
- एक 2 डी सरणी या पात्रों का मैट्रिक्स

05AB1E ,60 51 50 49 47 45 बाइट्स

बची हुई 10 बाइट्स एमिग्ना की बदौलत और 1 बाइट अदनान की बदौलत।

सभी इनपुट लाइनों में समान मात्रा में वर्ण होने चाहिए।

#õKD³'^¡€gDŠ*¬-Os÷1®‚*D0›*+¬?DJg²gs-ð×?¤,²,³,

#                                             Split the first input line on spaces
 õKD                                          Push [first weight, second weight] twice
    ³'^¡€gD                                   Push both lengths from either side of the pivot '^' as an array [left, right] twice
           Š*                                 Multiply by weights to get torque
             ¬-O                              Evaluate rightTorque-leftTorque
                s÷                            Divide by each side's length to get the weights to add: [deltaLeft, deltaRight], keep integer values
                  1®‚                         Push [1,-1]
                     *D                       Yield [deltaLeft, -deltaRight]
                       0›*                    Replace the negative value by 0
                          +                   Add weights: old + deltaWeight
                           ¬?                 Print left weight
                             DJg              Take the size of total decimal representation
                                ²gs-ð×?       Print a string composed of filler spaces between both new weights
                                       ¤,     Print right weight and newline
                                         ²,³, Print the last two lines from input (unchanged)

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

अंगूठे का एक नियम होना चाहिए, जैसे "यदि आपका 05AB1E कोड 40 बाइट्स से अधिक लंबा है, तो आप शायद इसे गलत कर रहे हैं"। यह बहुत गोल्फ लगता है, किसी भी विचार का स्वागत है!

— Osable
स्रोत

1

एक शुरुआत के लिए ¬s¤s\‚किया जा सकता है õK।

— एमिगा

1

kD²g->(‚हो सकता है ¡€gकि अगर आप परीक्षण के मामले की निचली पंक्ति में गुम स्थान जोड़ दें

— एमिग्ना

1

स्पष्टीकरण के लिए धन्यवाद। मुझे लगता है कि यह संदर्भ एल्गोरिथ्म (कोई बुरी बात नहीं) के समान है, लेकिन इसमें कुछ चतुर चालें भी हैं। 05AB1E के बारे में कुछ का मतलब है कि यह कुछ अन्य गोल्फ भाषाओं की तुलना में चतुर उत्तर को बढ़ावा देता है - यह शायद मेरा पसंदीदा है, खासकर जब इसमें शामिल स्पष्टीकरण हो।

— FourOhFour 16

1

अच्छा उत्तर! आप बदल सकते हैं 31SÍके साथ 1®‚:)

— अदनान

1

क्या आप शायद इसके / ïसाथ भी बदल सकते हैं ÷।

— एमिगा

5

जावास्क्रिप्ट (ईएस 6), 136

संभवतः Chrome में काम नहीं कर रहा है, क्योंकि यह विनाशकारी असाइनमेंट और डिफ़ॉल्ट मापदंडों का उपयोग करता है।

ध्यान दें कि मानक JS आउटपुट विधि alertविशेष रूप से कार्य के लिए अनुपयुक्त है, क्योंकि आनुपातिक फ़ॉन्ट का उपयोग किया जाता है।

(m,n,o,[p,q]=m.split(/ +/),l=n.length,h=o.indexOf`^`,g=l-h-1,c=p*h<q*g?q*g:p*h)=>alert((c/h+o).slice(0,h)+(o+c/g).slice(h-l)+`
${n}
`+o)

कम गोल्फ वाला

( m,n,o, // input parameters, 3 strings
  // default parameters used as local variables
  [p,q] = m.split(/ +/), // left and right weight
  l = n.length, // bar length
  h = o.indexOf`^`, // left length
  g = l-h-1, // right length
  // p*h left torque
  // q*g right torque
  c = p*h<q*g ? q*g : p*h // max torque
) => alert( (c/h+o).slice(0,h)+(o+c/g).slice(h-l) // o has enough spaces to pad left and right
     +`\n${n}\n`+o )

परीक्षा

F=
(m,n,o,[p,q]=m.split(/ +/),l=n.length,h=o.indexOf`^`,g=l-h-1,c=p*h<q*g?q*g:p*h)=>alert((c/h+o).slice(0,h)+(o+c/g).slice(h-l)+`
${n}
`+o)

function go()
{
  var [a,b,c]=I.value.split('\n')
  if(a.length!=b.length || a.length < c.length)
    alert('The strings are not of the same length')
  else 
  {  
    if (a.length > c.length)
      c = c+' '.repeat(a.length-c-length)
    F(a,b,c)
  }  
}

<textarea id=I>3             16
----------------
        ^      </textarea>
<button onclick='go()'>go</button>

स्निपेट का विस्तार करें

— edc65
स्रोत

Kangax.github.io/compat-table/es6 के अनुसार , Chrome 54 पूरी तरह से डिफ़ॉल्ट मापदंडों और विनाशकारी का समर्थन करता है, इसलिए मुझे नहीं लगता कि आपको बहुत परेशान होना पड़ेगा।

— ETHproductions

मेरे लिए क्रोम पर काम करता है।

— DLosc

3

पर्ल, 149 + 2 = 151 वर्ण

कमांड लाइन विकल्प की आवश्यकता है -p0(यह मुझे प्रोग्राम में 149 बाइट्स के शीर्ष पर 2 बाइट पेनल्टी देता है)।

($_,$b,$c,$d)=map length,/(\d+) +(.+)
(-+)
( +)/;$r=$d/($c-$d-1);($x,$y)=$1*$r>$2?($1,$1*$r):($2/$r,$2);$_="$x$,$y",$,.=$"while$c>length;$\="
$3
$4^"

स्पष्टीकरण:

-p0स्विच पहले NUL बाइट या EOF अप करने के लिए पूरे इनपुट पढ़ता है। यह समस्या NULs की अनुमति नहीं देती है, इसलिए हम $_डिफ़ॉल्ट रूप से regexes, आदि के लिए उपयोग किए जाने वाले चर में संपूर्ण इनपुट प्राप्त करेंगे ।
हम एक रेगेक्स से शुरू करते हैं जो इनपुट को पार करता है (पहली और दूसरी स्लैश के बीच)। ऐसे कई तरीके हैं जिनसे हम पहले वजन को पार कर सकते हैं (उदाहरण के लिए .+?), लेकिन मैं इसे 3 अक्षरों से नीचे नहीं ला सकता , इसलिए मैं स्पष्ट रूप से उपयोग कर सकता हूं \d+। दूसरी संख्या पंक्ति के अंत में है, इसलिए इसे .+(2 वर्ण) के रूप में पार्स किया जा सकता है । केंद्रीय रेखा का उपयोग यह निर्धारित करने के लिए किया जाता है कि तराजू कितनी व्यापक है; यह -+(कई अन्य अभ्यावेदन काम करेगा) के रूप में पार्स किया गया है । अंतिम पंक्ति पर कैरेट से पहले रिक्त स्थान हैं +। एक बार कैरेट (या वास्तव में कोई भी बकवास) दिखाई देता है, हम बाकी इनपुट को अनदेखा करते हैं।
पर्ल स्वचालित रूप में regex के चार समूहों (पहली वजन, दूसरा वजन, हाइफ़न की पंक्ति, रिक्त स्थान कैरट से पहले) कब्जा $1, $2, $3, $4। mapअतिरिक्त रूप से उन समूहों के एक सरणी के रूप में मैप करने के लिए सरणी के रूप में एक regex दे रहा है । इसलिए हम उनकी लंबाई लेते हैं; यह दो बार लिखने के लिए $3और $4बिना लंबाई को स्टोर करने का एक सुविधाजनक तरीका है length। हम $_की लंबाई के साथ ओवरराइट भी करते हैं $1; हम वास्तव में इस के मूल्य के बारे में परवाह नहीं करते हैं (बाएं इनपुट में अंकों की संख्या दयालु है), लेकिन यह तथ्य कि यह कम है ( $_'लंबाई अब अंकों की संख्या में अंकों की संख्या है) पहला वजन, जो तराजू की चौड़ाई की तुलना में बहुत छोटा है)।
हम उस अनुपात $rको मापते हैं जिसमें तराजू विभाजित होते हैं।
$1*$r>$2यह देखने के लिए कि कौन सा पक्ष भारी है। हम में नए वजन की दुकान $xऔर $y; वज़न के अनुपात ज्ञात होने के बाद इनमें बहुत सरल गणनाएँ हैं।
हम जोड़ $x, $,और $yमें $_शीर्ष पंक्ति के उत्पादन के लिए है, तो जोड़ने रिक्त स्थान (रखने $"डिफ़ॉल्ट रूप से एक भी स्थान शामिल हैं, और कम एक शाब्दिक स्थान की तुलना में है ' 'होगा) पर $,जब तक यह मध्य पंक्ति के समान ही लंबाई है (यानी लंबाई है $c)। (मैंने वैरिएबल $,को चुना क्योंकि यह एक अंतर्निहित वैरिएबल है जिसे सुरक्षित रूप से इस संदर्भ में बदला जा सकता है और डिफ़ॉल्ट रूप से खाली होने लगता है।) जैसा कि डिफ़ॉल्ट रूप से lengthसंचालित होता $_है, हमें इसे स्पष्ट रूप से तर्क देने की आवश्यकता नहीं है। मैंने एक योडा सशर्त का उपयोग किया क्योंकि इसे सही ढंग से पार्स करने के लिए काफी कम साइंटैक्स की आवश्यकता होती है।
अंत में, मैं कन्वेंशन ( $\) इनपुट के सेट के बाकी हिस्सों को समाहित करने के लिए कन्वेंशन ( ) के आउटपुट लाइन को समाप्त करने का पर्ल के विचार को पुनर्परिभाषित करता हूं , इसलिए मैं बस इसका उपयोग करने के लिए सीधे $3और $4सीधे उपयोग कर सकता हूं )। ध्यान दें कि इसका मतलब यह है कि तीसरी पंक्ति में कोई अनुगामी व्हाट्सएप नहीं है; इसे जोड़ने से कार्यक्रम थोड़ा लंबा हो जाएगा और किसी भी उद्देश्य की पूर्ति नहीं होगी, इसलिए मैंने इसे छोड़ दिया।
कार्यक्रम के अंत में, -pस्विच फिर से चालू हो जाता है; इस बार, यह $_"न्यूलाइन" ( $\) के बाद आउटपुट करता है । क्योंकि मैंने आउटपुट न्यूलाइन को पुनर्परिभाषित किया है, ये दो अंतर्निहित प्रिंट उनके बीच तराजू के नए सेट को उत्पन्न करते हैं (हालांकि एक साइड इफेक्ट के रूप में, आउटपुट पर कोई न्यूलाइन नहीं है)।
-pस्विच अब इनपुट फिर से पढ़ने की कोशिश करता है, लेकिन हम पहले से ही पूरी फ़ाइल slurped, तो यह EOF पढ़ता है और कार्यक्रम समाप्त होता है।

1

PHP, 212 209 205 बाइट्स

शायद गोल्फ

preg_match("#(\d+)( +)(\d+)\s*(-+)[\r\n]+( +)\^#",$s=$argv[1],$m);echo preg_replace("#\d+( +)\d+#",(($r=$m[3])>($q=$m[1]*($p=strlen($m[5]))/(-$p-1+$e=strlen($m[4])))?$r*$e/($p+1)-$q=$r:$m[1]).$m[2].$q,$s);

कमांड लाइन तर्क से इनपुट लेता है; बचना नई बात। के साथ चला -r।

एक प्लेसहोल्डर के साथ प्रतिस्थापित करना अपेक्षित रूप से काम नहीं करता था; इसलिए मुझे पहले रेगेक्स में अधिक पार्न्स जोड़ना पड़ा।

— टाइटस
स्रोत

1

Befunge, 223 217 बाइट्स

&:00p&10p~$0>~#<2#+%#1_:20p0~>8#~%#+!#1_:3v
v\g01/g03*g01_v#!\g04`*g01g04:*g03p04-1-p0<
>#g>#0>#0>#/>#<:.2\5>5>#\+/#1:#\_$50p:50g\5>5>#\+/#1:#\_$20g\-v>
1#,>#*-#4:#8_$.55+,20g>:#,1#*-#9\#5_55+,30g>:#,1#*-#8\#4_"^",@>>

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

— जेम्स होल्डरनेस
स्रोत

215 बाइट्स , मुझे लगता है

— Zacharý

@ Zacharý मुझे डर नहीं है। कम से कम उन तीरों में से एक की आवश्यकता है, अन्यथा यह विफल हो जाएगा जब भी बाएं टोक़> दायां टोक़ (उदाहरण के लिए पहला परीक्षण मामला)। दूसरे >मुझे लगता है कि सिर्फ सौंदर्य कारणों से छोड़ दिया गया था। उन्होंने कहा, मुझे लगता है कि मेरे नोटों में 215 बाइट का समाधान है, इसलिए यह संभव हो सकता है (इसमें मेरे बग भी हैं, जो बताएंगे कि मैंने इसे कभी क्यों नहीं जमा किया है - इसके परीक्षण का समय नहीं है)।

— जेम्स होल्डरनेस

1

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

निश्चित रूप से गोल्फ

i=raw_input
j=int
w=map(j,i().split())
W=len(i())
I=i().find('^')
R=W-I-1
a=[w[1]*R/I,w[0]*I/R]
h=a[1]>w[1]
w[h]=j(a[h])
k='\n'
print(' '*(W-len(str(w))+4)).join(map(str,w))+k+'-'*W+k+' '*I+'^'

बहुत सीधा। बस दोनों पक्षों को समायोजित करने के लिए समायोजित वजन लें, देखें कि कौन सा मूल से बड़ा है, और उस एक, और आउटपुट को बदल दें।

EDIT स्विच किए गए गुणन और विभाजन क्योंकि पूर्णांक विभाजन निष्फल है (इसे नोट करने के लिए @JonathanAllan के लिए धन्यवाद)

EDIT -1 बाइट बदल i().index('^')गया i().find('^')(@JonathanAllan के लिए धन्यवाद [फिर से!])

— HyperNeutrino
स्रोत

यानी - आप गुणा और भाग स्वैप चाहिए, क्योंकि विभाजन विभाजन पूर्णांक है a=[w[1]*R/I,w[0]*I/R](एक सरल उदाहरण है कि काम एक होगा नहीं होगा 1और 2साथ Iऔर Rदोनों 3)। वर्तमान में 194 नहीं 184 माध्यम से के बाद से नई-पंक्तियों एक बाइट प्रत्येक के रूप में गिनती है, लेकिन jऔर kअधिक लागत कर रहे हैं की तुलना में वे बचाने बाइट्स।

— जोनाथन एलन

आप अंतिम पंक्ति बनाने के लिए बैकटिक्स का उपयोग कर सकते हैं I=i().find('^'), और 182 तक नीचे जा सकते हैं - repl.it/EW8f__repr__print`w[0]`+' '*(W-len(`w`)+4)+`w[1]`+'\n'+'-'*W+'\n'+' '*I+'^'

— जोनाथन एलन

0

सी ++ 14, 482 बाइट्स

include<iostream>#include<string>#include<math.h>usingnamespacestd;intmain(){stringa,b,c,d;intj=0;inte[2];getline(cin,a);getline(cin,b);getline(cin,c);for(inti=0;i<a.size();i){if(isdigit(a.at(i))){while(i<a.size()&&isdigit(a.at(i))){d=a.at(i);i;}e[j]=stoi(d);d="";}}strings(b.size()-(int)log10(e[0])-(int)log10(e[1])-2,'');intl1=(c.size()-1);intl2=(b.size()-c.size());intl=e[0]*l1;intr=e[1]*l2;if(l>r)e[1]=l/l2;elsee[0]=r/l1;cout<<e[0]<<s<<e[1]<<endl;cout<<b<<endl;cout<<c;return0;}

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

#include <iostream>
#include <string>
#include <math.h>
using namespace std;
int main() {
    string a,b,c,d;
    int j=0;
    int e[2];
    // input
    getline(cin,a);// 1st line
    getline(cin,b);// 2nd line
    getline(cin,c);// 3rd line
    for (int i=0;i<a.size();i++) {
        if(isdigit(a.at(i))){
            while(i<a.size() && isdigit(a.at(i))){
                d+=a.at(i);
                i++;
            }
            e[j++]=stoi(d);
            d="";
        }
    }
    // amount of white space in between 2 numbers
    string s(b.size()-(int)log10(e[0])-(int)log10(e[1])-2,' ');
    int l1 = (c.size()-1);
    int l2 = (b.size()-c.size());
    int l = e[0]*l1;
    int r = e[1]*l2;
    // change the side with smaller torque
    if (l>r)
        e[1]=l/l2;
    else
        e[0]=r/l1;
    // output
    cout<<e[0]<<s<<e[1]<<endl;// 1st line
    cout<<b<<endl;// 2nd line
    cout<<c;// 3rd line
    return 0;
}

— Bobas_Pett
स्रोत

0

पायथन 3, 235 230 बाइट्स (न्यूनतम संदर्भ)

मैंने अभी संदर्भ को कम से कम किया है, क्योंकि मैं कोड-गोल्फिंग में बहुत नया हूं।

def s(l):
 w,i,t=[int(z.strip())for z in l[0].split()],len(l[1]),l[2].find("^");k,o=i-1-t,w[0]*t;p=w[1]*k
 if o>p:w[1]=o//k
 else:w[0]=p//t
 w=[str(z)for z in w];s=" "*(i-sum(len(z)for z in w));l[0]=w[0]+s+w[1];print("\n".join(l))

आप इसका उपयोग उदाहरण के समान ही करते हैं, लेकिन फ़ंक्शन sइसके बजाय है balance_seesaw।

— ender_scythe
स्रोत

लाइनें 5 और 6 बन सकती हैं w[o>p]=[o//k,p//t][o>p]। इसके अलावा, अधिकांश लाइनें कुछ अतिरिक्त व्हाट्सएप से छुटकारा पाने के लिए शामिल हो सकती हैं।

— जेम्स

धन्यवाद, जैसा कि मैंने कहा, मैं बहुत नया हूं, इसलिए मैं सबसे सरल सुधारों की भी अनदेखी करता हूं।

— Ender_scythe

सिवाय इसके, यह 196,56 के बजाय 0,56 प्रदान करने के बजाय काम नहीं करता है।

— ender_scythe

इसे संतुलित करने के लिए एक आरी में एक तरफ वजन जोड़ें