मिश्रित संख्या एक अनुचित भगदड़ के लिए

इस चुनौती में आप मिश्रित संख्या को अनुचित अंश में बदल देंगे।

क्योंकि अनुचित अंश कम संख्या का उपयोग करते हैं, आपके कोड को यथासंभव कम होना चाहिए।

उदाहरण

विशिष्टता

आप मान सकते हैं कि इनपुट का विभाजक कभी नहीं होगा 0. इनपुट हमेशा उस प्रारूप में होगा x y/zजहां x, y, z मनमाने ढंग से पूर्णांक रहित होते हैं। आपको आउटपुट को सरल बनाने की आवश्यकता नहीं है।

यह कोड-गोल्फ है इसलिए बाइट्स जीत में सबसे छोटा कोड है।

— Downgoat
स्रोत

5

आपको "पार्सिंग" टैग जोड़ना चाहिए। मुझे यकीन है कि अधिकांश उत्तर इनपुट को पार्स करने और गणित करने की तुलना में आउटपुट स्वरूपण पर अधिक बाइट्स खर्च करेंगे।

— नीमी

3

क्या आउटपुट एक तर्कसंगत संख्या प्रकार हो सकता है या क्या इसे एक स्ट्रिंग होना चाहिए?

— मार्टिन एंडर

2

@ अलेक्सा .: ... लेकिन चुनौती का एक बड़ा हिस्सा। इसके विवरण के अनुसार ऐसे मामलों में टैग का उपयोग किया जाना चाहिए।

— निमि

7

कर सकते हैं x, yऔर zनकारात्मक हो सकता है?

— डेनिस

2

चुनौती के आधार पर मैं यह मान रहा हूं, लेकिन क्या इनपुट प्रारूप "xy / z" अनिवार्य है, या क्या अंतरिक्ष एक नई लाइन हो सकती है, और / या x,y,zअलग-अलग इनपुट हो सकते हैं? अधिकांश उत्तर मानते हैं कि इनपुट प्रारूप वास्तव में होना अनिवार्य है x y/z, लेकिन कुछ नहीं हैं, इसलिए इस प्रश्न का एक निश्चित उत्तर है।

— केविन क्रूज़सेन

1

जाप, 10 बाइट्स

वोहू, वर्तमान में सीजेएम की पिटाई!

U*W+V+'/+W

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

यह काम किस प्रकार करता है

       // Implicit: [U,V,W] = eval(input). This automatically discards the slash.
U*W+V  // Calculate the new numerator: (whole part * denominator) + numerator.
+'/+W  // Add the slash and the denominator.
       // Implicit: output last expression

— ETHproductions
स्रोत

मैंने कल एक अच्छा समय बिताया, यह पता लगाने की कोशिश की कि मैंने एक उत्तर के 15 प्रतिनिधि कैसे अर्जित किए, जब तक मुझे एहसास नहीं हुआ: मेरा पहला ग्रीन चेकमार्क! \ o /

— ETHproductions

8

LabVIEW, 29 LabVIEW आदिम

— Eumel
स्रोत

7

CJam, 16 15 14 बाइट्स

l'/']er~:Xb'/X

या

l'/']er~_@b'/@

इसका परीक्षण यहां करें।

व्याख्या

l      e# Read input.
'/']er e# Replace the "/" with a "]".
~      e# Evaluate the string as code. If the input was "i n/d", this pushes [i n] d.
:X     e# Store the denominator in X.
b      e# Treat [i n] as base-d digits. This effectively computes i*d + n.
'/     e# Push a slash.
X      e# Push the denominator.

दूसरा संस्करण थोड़ा अधिक स्टैक शिफ्टिंग का उपयोग करके एक चर का उपयोग करने से बचता है।

— मार्टिन एंडर
स्रोत

मुझे वास्तव में CJam में बेस रूपांतरण का उपयोग शुरू करने की आवश्यकता है।

— फल

एक वैकल्पिक संस्करण:, '//~\S/1$b'/@यह 13 बाइट्स है। संपादित करें : ओह मैं इनपुट भूल गया l।

— क्रोमियम

4

मैथेमेटिका, 58 बाइट्स

ToExpression@StringReplace[#," "->"+"]~ToString~InputForm&

यह सरलीकृत परिणाम देता है। यदि स्ट्रिंग के बजाय एक परिमेय संख्या का उत्पादन ठीक है, तो हम 19 बाइट्स बचा सकते हैं:

ToExpression@StringReplace[#," "->"+"]&

— मार्टिन एंडर
स्रोत

4

पॉवरशेल, 47 44 42 बाइट्स

_{पार किया 44 अभी भी नियमित है 44 ;;}

$l,$n,$d=$args-split'\D';"$(+$l*$d+$n)/$d"

रेगेक्स का उपयोग करके एक जोड़े को बाइट किया -split । रेगेक्स की अदला-बदली करके TessellatingHeckler के लिए कुछ और धन्यवाद ।

$args-split'\D'हमारे इनपुट तर्क लेता है और गैर अंकों पात्रों पर विभाजित होता है। यहाँ यह दो विभाजन करता है, एक व्हाट्सएप पर, दूसरा /चरित्र पर। परिणाम एक साथ असाइनमेंट का उपयोग करके तीन चर में संग्रहीत किए जाते हैं। हम तब कोड आउटपुट $l, $dस्लैम के $nरूप में निष्पादित किए गए स्ट्रिंग नंबर को कोड ब्लॉक, /स्लैश, और फिर फिर से $dइनोमिनेटर के रूप में बनाते हैं।

— AdmBorkBork
स्रोत

नमस्ते, मुझे लगता है कि आप -split ' |/'एक चरित्र को "मैच या तो" या "रेगेक्स" के साथ सहेज सकते हैं , या -split '\D'किसी भी चीज़ पर विभाजित करने के लिए उपयोग कर सकते हैं जो कि अंक और एस (ए) दो अक्षर नहीं है। अगर @ डाउनगटैट आउटपुट फॉर्मेट में थोड़ा लचीला होने को तैयार है,'{0}*{2}+{1};{2}'-f($args-split'\D')|iex तो 40 बाइट्स हैं और इसमें बहुत अधिक आउटपुट है क्योंकि नंबर एक से दूसरे के ऊपर भी हैं!

— TessellatingHeckler

1

@TessellatingHeckler regex सहायता के लिए धन्यवाद। मैंने इनपुट के लिए डाउन्गोएट से पूछा है। लेकिन $l,$n,$d=$args-split'\D';+$l*$d+$n;$dअभी तक 37 पर कम है, और तार्किक रूप से यहाँ के समान पैटर्न का अनुसरण करता है।

— AdmBorkBork

अरे हाँ, बस गणित! (यह एक पर्ल उत्तर को भी हरा देने के लिए पर्याप्त होगा)

— TessellatingHeckler

3

जावा दस फुट लेजर पोल के साथ 1.03, 79 + 25 (आयात) = 104 बाइट्स

आवश्यक है import sj224.tflp.math.*;

String m(String[]a){return ""+new BigRational(a[0]).add(new BigRational(a[1]));}

यह लगभग निश्चित रूप से 1.04 के साथ भी काम करेगा, लेकिन अभी तक मैंने केवल 1.03 के साथ इसका परीक्षण किया है क्योंकि मैं पहले से ही एक जावा परियोजना का निर्माण पथ में 1.03 के साथ स्थापित करने के लिए हुआ था।

— SuperJedi224
स्रोत

3

जावास्क्रिप्ट (ईएस 6), 44 41 बाइट्स

m=>([x,y,z]=m.match(/\d+/g),+y+x*z+"/"+z)

सहेजे गए 3 बाइट्स @ETHproductions की बदौलत !

व्याख्या

बहुत आसान।

m=>
  ([x,y,z]=m.match(/\d+/g), // x, y and z = numbers from input
    +y+x*z                  // numerator
    +"/"+z                  // denominator
  )

परीक्षा

अधिकांश ब्राउज़रों में काम करने के लिए टेस्ट विनाशकारी असाइनमेंट के बिना है।

कोड स्निपेट दिखाएं

var solution = m=>+(p=m.match(/\d+/g))[1]+p[0]*p[2]+"/"+p[2]

<input type="text" id="input" value="11 23/44" />
<button onclick="result.textContent=solution(input.value)">Go</button>
<pre id="result"></pre>

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

— user81655
स्रोत

अच्छा! आप उपयोग कर सकते हैं [p,q,r]=के स्थान पर p=, फिर की जगह p[0], p[1]और p[2]साथ p, q, और r, क्रमशः। इस परिवर्तन के बाद, मुझे 41:m=>([p,q,r]=m.match(/\d+/g),+q+p*r+"/"+r)

— ETHproductions

@ETHproductions टिप के लिए धन्यवाद! मैंने वास्तव में विनाशकारी असाइनमेंट का उपयोग करने पर विचार किया था, लेकिन वे क्रोम में काम नहीं करते हैं और मेरे पास इसे जांचने के लिए फ़ायरफ़ॉक्स नहीं था। : पी

— user81655

मेरा पहला ४४ पार हो गया! : D

— user81655

आप m.split(/\W/g)बाइट बचाने के लिए उपयोग कर सकते हैं

— क्रिक्टी लिथोस

2

जूलिया, 58 50 बाइट्स

s->eval(parse((r=replace)(r(s," ","+"),"/","//")))

यह एक अनाम फ़ंक्शन है जो एक स्ट्रिंग को स्वीकार करता है और एक Rationalप्रकार की वस्तु देता है । इसे कॉल करने के लिए, इसे एक नाम दें, उदा f=s->...।

हम इस तथ्य का फायदा उठा सकते हैं कि इनपुट को एक अभिव्यक्ति के लिए थोड़ा हेरफेर किया जा सकता है जो एक तर्कसंगत का मूल्यांकन करता है। विशेष रूप से, एक पूर्णांक प्लस एक तर्कसंगत एक तर्कसंगत है, और तर्कसंगत को डबल स्लैश के साथ चिह्नित किया जाता है। तो अगर हम बारी 4 1/2में 4+1//2, का मूल्यांकन परिणाम होगा9//2 ।

Ungolfed:

function f(s::AbstractString)
    # Replace the space in the input with a plus
    r1 = replace(s, " ", "+")

    # Replace the / with //
    r2 = replace(r1, "/", "//")

    # Parse the resulting expression as a rational
    return eval(parse(r2))
end

— एलेक्स ए।
स्रोत

2

स्मालटाक - 76 वर्ण

यह इनपुट स्मालटाक के सरणी सीमांकक और अंतर्निहित अंश प्रतिनिधित्व से बिल्कुल मेल खाता है। यदि यह सिर्फ इतनी क्रिया नहीं थी, तो यह एक गंभीर दावेदार हो सकता है!

Compiler evaluate:'|p|p:=0.#(',FileStream stdin nextLine,')do:[:q|p:=p+q].p'

यह बहुत बुरा सरलीकरण है एक आवश्यकता नहीं थी, स्मॉलटाक स्वचालित रूप से करता है!

2

बैश + कोरुटिल्स, 28

dc<<<${@/\// }sarla*+n47Plap

$@सभी कमांड-लाइन मापदंडों का ${@/\// }विस्तार करता है , इसलिए सभी कमांड-लाइन मापदंडों के साथ फैलता है , जिसे /प्रतिस्थापित किया जाता है dc। बाकी सरल स्टैक हेरफेर और अंकगणित है।

— डिजिटल आघात
स्रोत

2

हास्केल , 74 67 63 बाइट्स

r=read
f x|(a,(c,s:d):_)<-lex<$>lex x!!0=show(r a*r d+r c)++s:d

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

व्याख्या

जैसा कि H.PWiz को पता चला है कि हम यहां हास्केल के लेसर का उपयोग कर सकते हैं ताकि स्ट्रिंग को भागों में विभाजित किया जा सके। (पहले मैं उपयोग कर रहा था span(>'/')) और लिकोनी ने बताया कि <$>जैसे काम करता mapSndहैData.Tuple ।

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

lex x

फिर हम इसे उस सूची से खोल देते हैं जो हमें 2-ट्यूपल देती है

lex x!!0

पहला टोकन मिश्रित अंश का पूरा हिस्सा होगा जो कि अभी भी पार्स करने के लिए एक स्थान द्वारा पूर्वनिर्मित अंश को छोड़ देगा। तब से टुपल्स Functorsहम (<$>)एक उपनाम का उपयोग कर सकते हैं टुपल के दूसरे तत्व fmapपर लागू होते हैं lex।

lex<$>lex x!!0

यह अंतरिक्ष के माध्यम से खाता है और अगले टोकन को तोड़ता है, हमारे अंश का अंश। अब हम इसका उपयोग करते हुए एक पैटर्न मैच के लिए बाध्य करते हैं <-। हमारा पैटर्न है

(a,(c,s:d):_)

aअंश का पूरा भाग पकड़ लेता है, हमारा पहला टोकन। :_हमारे दूसरे से उत्पन्न सूची को हटाता है lex। cदूसरे टोकन को हमने लेक्स किया, जो कि अंश का अंश है। जो कुछ भी शेष है s:dवह उसके पहले चरित्र में विभाजित हो जाता है, प्रारूप द्वारा गारंटी दी जाती है/ कि शेष और जो कि हर होगा।

अब जब हमने उस इनपुट को पार्स किया है जो हम वास्तविक गणना करते हैं:

show(r a*r d+r c)++s:d

rपढ़ा हुआ कार्य हम पहले कहां से करते हैं।

यह नोट करना महत्वपूर्ण है कि lexयदि कोई सूची विफल हो जाती है तो वह खाली हो जाती है और यदि वह सफल नहीं होती है तो गैर-रिक्त होती है। यह Maybeमैं क्यों नहीं जानता।

— गेहूं का जादूगर
स्रोत

1

67 बाइट्स

— H.PWiz

@ H.PWiz यह lex का एक महान उपयोग है।

— गेहूं जादूगर

2

65 बाइट्स: इसे ऑनलाइन आज़माएं!

— लकोनी

2

आप से एक और 2 को बचाने के लिए सक्षम होना चाहिए पर मिलान/

— H.PWiz

1

59 बाइट्स

— H.PWiz

1

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

p=prompt;b=p(a=+p()).split`/`;alert((+b[1]*a+ +b[0])+"/"+b[1])

— SuperJedi224
स्रोत

1

बहुत अच्छा! कुछ सुझाव: आप उपयोग कर सकते हैं [b,c]=के स्थान पर b=, तो का उपयोग bके स्थान पर b[0]और cके स्थान पर b[1]। इसके अलावा, आप समीकरण को पुनर्व्यवस्थित कर सकते हैं, ताकि आपको कोष्ठक की आवश्यकता न हो: p=prompt;[b,c]=p(a=+p()).split/;alert(+b+c*a+"/"+c)

— ETHproductions

1

पर्ल, 82 61 38 बाइट्स

#!perl -paF/\D/
$_=$F[0]*$F[2]+$F[1]."/$F[2]"

यह शायद अधिक गोल्फ हो सकता है।

परिवर्तन

के बजाय का splitउपयोग करके एक regex और 5 का उपयोग करके 16 बाइट्स सहेजा गया ।<><STDIN>
डेनिस की बदौलत एक और 16 बाइट्स बचाए।

— ASCIIThenANSI
स्रोत

शेबंग #!perl -paF/\D/(9 बाइट्स) के साथ, आप उपयोग कर सकते हैं $_=$F[0]*$F[2]+$F[1]."/$F[2]"।

— डेनिस

@ डेनिस मैंने वह जोड़ा है। धन्यवाद!

— ASCIIThenANSI

#!perlशेबंग और लाइनफीड का हिस्सा गिनती नहीं करता है। यह केवल 38 बाइट्स है।

— डेनिस

@ डेनिस ओह, ठीक है। मैं इसे अब ठीक करूंगा। (उज्ज्वल पक्ष पर मुझे लगता है कि यह दूसरा सबसे छोटा गैर-गूढ़ उत्तर है)

— ASCIIThenANSI

1

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

Interpreter["ComputedNumber"]@#~ToString~InputForm&

दिलचस्प बात यह है कि, गणितज्ञ एक अंतर्निर्मित के साथ इसका समर्थन करता है। यदि किसी संख्या को आउटपुट करने की अनुमति है, तो हमें केवल 28 बाइट्स की आवश्यकता है:

Interpreter@"ComputedNumber"

— LegionMammal978
स्रोत

1

जावा, 159 148 142 120 110 बाइट्स

String m(String[]a){Long b=new Long(a[0]),d=new Long((a=a[1].split("/"))[1]);return b*d+new Long(a[0])+"/"+d;}

FlagAsSpam के लिए बाइट्स धन्यवाद का एक गुच्छा बचाया।

— SuperJedi224
स्रोत

@FlagAsSpam किया।

— SuperJedi224

@FlagAsSpam लेकिन तब चर अघोषित रह जाएंगे!

— SuperJedi224

मैंने अभी जो कुछ कहा, उसकी उपेक्षा करें - एक छोटा तरीका जो आप कर रहे हैं वह हैLong b=new Long(a[0]),c=new Long((a=a[1].split("/"))[0]),d=new Long(a[1]);

— Addison Crump

1

ARBLE , 13 बाइट्स

a*c+b.."/"..c

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

— Ataco
स्रोत

मुझे पूरा यकीन है कि "x y/z"इस विशेष चुनौती के लिए इनपुट प्रारूप अनिवार्य है, लेकिन सिर्फ मामले में मैंने ओपी को सत्यापित करने के लिए कहा है।

— केविन क्रूज़सेन

1

05AB1E , 17 15 बाइट्स

#`'/¡R`Š©*+®'/ý

-2 बाइट्स @MagicOctopusUrn को धन्यवाद ।

इसे ऑनलाइन आज़माएं या सभी परीक्षण मामलों को सत्यापित करें ।

स्पष्टीकरण:

#`         # Split input by spaces and push all items to the stack
           #  i.e. "4 1/2" → "4" and "1/2"
  '/¡      # Push the second item by "/"
           #  i.e. "1/2" → [1,2]
     R`    # Revert the list, and also push all items to the stack
           #  i.e. [1,2] → [2,1] → 2 and 1
Š          # Triple-swap the stack
           #  [4,2,1] → [1,4,2]
 ©         # Store the 2 in the register
  *        # Multiple the top two items
           #  4 and 2 → 8
   +       # Add the top two items
           #  1 and 8 → 9
®          # Push the 2 from the register to the stack again
 '/ý       # Join the two items by "/"
           #  9 and 2 → "9/2"

लचीला इनपुट- और आउटपुट-प्रारूप के साथ, पूर्णांकों को क्रम में लेते हुए x,z,yऔर अलग-अलग लाइनों पर नामांकित और भाजक को आउटपुट करते हुए यह 4 बाइट्स होगा (यही वजह है कि मैंने इसे जोड़ा पार्सिंग -टैग को चुनौती में ..):

*+²»

इसे ऑनलाइन आज़माएं या सभी परीक्षण मामलों को सत्यापित करें ।

स्पष्टीकरण:

*        # Multiply the first two inputs (x and z)
         #  i.e. 4 and 2 → 8
 +       # Add the third input (y)
         #  i.e. 8 and 1 → 9
  ²      # Take the second input again (z)
   »     # Join the stack by newlines and implicitly print it

— केविन क्रूज़सेन
स्रोत

@MagicOctopusUrn धन्यवाद, लेकिन इनपुट-प्रारूप चुनौती विवरण से अलग है। स्पष्ट रूप से प्रारूप (एकल स्ट्रिंग के रूप में) 4 1/2इस विशेष चुनौती के लिए अनिवार्य है। (या यदि उत्पादन अनिवार्य था, लेकिन इनपुट लचीला मैं इस 6-byter का प्रयोग करेंगे: अन्यथा मैं अपने 4 बाइट संस्करण का उपयोग किया है | *+'/²J)

— केविन क्रूज़सेन

1

15-बाइट

— मैजिक ऑक्टोपस Urn

@MagicOctopusUrn ओह, " स्टैक में सभी आइटम पुश करेंa " के बारे में भी नहीं जानते थे .. o. what वास्तव में मुझे इस चुनौती के लिए क्या चाहिए था! और "/" से जुड़ने के साथ स्मार्ट। धन्यवाद! :)

— केविन क्रूज़सेन

मैं "स्टैक के सभी आइटम को पुश करता हूं" कमांड का उपयोग करने से नफरत करता हूं क्योंकि यह "` "है और इसे इनलाइन कोड-टैग द्वारा नामांकित नहीं किया जा सकता है।

— मैजिक ऑक्टोपस Urn

@MagicOctopusUrn हाँ, यह टिप्पणियों में भी थोड़ा कष्टप्रद है (यही वजह है कि मैंने " स्टैक में सभी वस्तुओं को धक्का aदिया " का उपयोग करने के बजाय '`'..

— केविन क्रूज़सेन

1

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

def f(s):a,b=s.split();b,c=b.split('/');return'%s/'%(int(a)*int(c)+int(b))+c

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

— xbarbie
स्रोत

return'%s/'%(int(a)*int(c)+int(b))+cहै 2 बाइट्स छोटा

— ovs

1

स्टैक्स , 1 बाइट

इसे चलाएं और डीबग करें (हालाँकि डीबग करने के लिए बहुत कुछ नहीं है)

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

— पुनरावर्ती
स्रोत

1

पर्ल ५ with -la -Mfeature = say, 32 बाइट्स 25 बाइट्स

m|/|;say$_*$'+$F[1],"/$'"

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

(-7 बाइट्स डोम हेस्टिंग्स को धन्यवाद)

$_संपूर्ण इनपुट है x y/z, जो xसंख्यात्मक संदर्भों (जैसे *यहां) के मूल्य का मूल्यांकन करता है । $'रेगेक्स पोस्ट-मैच स्ट्रिंग है, जिसमें यहां जो कुछ भी है, उसके बाद आता है /- इसलिए z,। yमान प्राप्त करने के लिए , हम उस -aध्वज का उपयोग करते हैं जो रिक्त स्थान पर इनपुट को विभाजित करता है और उन्हें @Fसरणी में रखता है । तो यहाँ, @F = ("x", "y/z")जिसका अर्थ है $F[1]="y/z"जो yसंख्यात्मक संदर्भों में मूल्यांकन करता है (चूंकि yअंकों का प्रारंभिक सन्निहित अनुक्रम है $F[1])।

— sundar - मोनिका को बहाल करना
स्रोत

आपको -pअपने बाइट की गिनती में ध्वज की गणना करने की आवश्यकता नहीं है ; इसके बजाय आप भाषा को इस रूप में गिनते हैं Perl 5 with -p flag, 32 bytes। वर्तमान सहमति के लिए यह मेटा पोस्ट देखें ।

— ग्यूसेप

अच्छा तरीका! मैं बस इस पर थोड़ा गया और एक 25 बाइट संस्करण बनाने में कामयाब रहा: इसे ऑनलाइन आज़माएं! । उपयोग करना $'वास्तव में केवल वास्तविक अंतर था!

— डोम हेस्टिंग्स

स्ट्रिंग के कुछ हिस्सों को प्राप्त करने के लिए regex- $'और -a- दोनों का उपयोग करने का संयोजन $F[n]एक बहुत अच्छा विचार है, मुझे यह याद रखना होगा! धन्यवाद, पोस्ट अपडेट किया।

— सूंदर - मोनिका

0

लुआ, 123 बाइट्स

m=io.read()z=string x=z.find c=z.sub b=tonumber s=x(m," ")f=x(m,"/")d=c(m,f+1)print(b(c(m,1,s))*b(d)+b(c(m,s,f-1)).."/"..d)

— Nikolai97
स्रोत

0

मिल्की वे 1.6.0 , 31 बाइट्स

'" "\="/"\=>;<A;A;:>*;A+"/"+<+!

मैंने जितना सोचा था उससे कहीं अधिक लंबा होने का समर्थन किया।

व्याख्या

'" "\="/"\=>;<A;A;:>*;A+"/"+<+!

'                                # read input from the command line
 " "  "/"               "/"      # push a string to the stack
    \    \                       # split the STOS at the TOS
     =    =                      # dump the TOS to the stack
           >       >             # rotate the stack rightward
            ;  ; ;   ;           # swap the TOS and STOS
             <              <    # rotate the stack leftward
              A A     A          # push the integer representation of the TOS
                  :              # duplicate the TOS
                    *            # multiply the STOS by the TOS
                       +   + +   # add the TOS and STOS
                              !  # output the TOS

प्रयोग

./mw <path-to-code> -i <input>

— Zach गेट्स
स्रोत

0

पायथन 2.7, 88 बाइट्स

a = input ()। विभाजन ('/'); प्रिंट int ([-1]) * int ([0] .plplit () [0]) + int (a [0] .split () [1] ]), '/', एक [1]

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

आपको कोट्स में इनपुट टाइप करना है।

शायद सबसे अच्छा नहीं ...

— एलेक्स
स्रोत

76 बाइट्स

— कोइशोर रॉय

0

सी, 64

main(i,d,n){scanf("%d %d/%d",&i,&n,&d);printf("%d/%d",i*d+n,d);}

STDIN से इनपुट पढ़ता है। बहुत आत्म-व्याख्यात्मक, मुझे लगता है।

— डिजिटल आघात
स्रोत

0

जाँच करें , 120 बाइट्स

>]+>:>32r#v
#d@0+\)  ##:>4;:>5'=:>48-\R-?
dd)R>32-#v
#>15-#v  #?
47r@>@   #v
#dd#v #?
r@>@     #v
    #\d@\: @*@+pd"/"op

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

मैं पार्सिंग लूप (दूसरी पंक्ति) के पुन: उपयोग की कोशिश न करके कुछ बाइट्स को बचाने में सक्षम हो सकता हूं। इस तरह मैं पाश को अधिक विशिष्ट बना सकता था, सशर्त की बड़ी गड़बड़ी से बच सकता था, और मैं अन्य चीजों के लिए रजिस्टर का उपयोग कर सकता था।

— फल तोड़ना
स्रोत

0

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

->x{eval x.split*?++?r}

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

— जीबी
स्रोत

0

सी #, 112 बाइट्स

s=>{string[]a=s.Split(),b=a[1].Split('/');int o=int.Parse(b[1]);return int.Parse(a[0])*o+int.Parse(b[0])+"/"+o;}

पूर्ण / स्वरूपित संस्करण:

namespace System.Linq
{
    class P
    {
        static void Main()
        {
            Func<string, string> f = s =>
            {
                string[] a = s.Split(), b = a[1].Split('/');
                int o = int.Parse(b[1]);
                return int.Parse(a[0]) * o + int.Parse(b[0]) + "/" + o;
            };

            Console.WriteLine(f("4 1/2"));
            Console.WriteLine(f("12 2/4"));
            Console.WriteLine(f("0 0/2"));
            Console.WriteLine(f("11 23/44"));

            Console.ReadLine();
        }
    }
}

— TheLethalCoder
स्रोत

0

एपीएल (डायलॉग यूनिकोड) , 31 बाइट्स

∊∘(⍕¨⊃,⍨'/',⍨⊃⊥1∘↓)¯1⌽#⍎¨∊∘⎕D⊆⊢

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

⊃⊥1∘↓ट्रिक के लिए ngn का धन्यवाद

— क्रिक्टी लिथोस
स्रोत

0

PHP, 65 बाइट्स

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

कोड

<?=(($a=preg_split("/[\s,\/]/",$argv))[0]*$a[2]+$a[1])."/".$a[2];

व्याख्या

$a=preg_split("/[\s,\/]/",$argv); # Split the string on "/" and " "
(($a)[0]*$a[2]+$a[1]) # as always denominator*whole number + numerator 
."/"                  # echo an slash
.$a[2];               # echo de denominator

— फ्रांसिस्को हैन
स्रोत

0

जावा 10, 87 बाइट्स

से एक लैम्ब्डा Stringके लिए String।

s->{var p=s.split(" |/");return new Long(p[0])*new Long(p[2])+new Long(p[1])+"/"+p[2];}

यह ऑनलाइन की कोशिश करो

— जेकब
स्रोत