नंबरों का वितरण

Question

इस चुनौती में आप हो का उपयोग किया जाएगा वितरण रकम और संख्या के मतभेदों पर एक उत्पाद, के रूप में समझाया यहाँ ।

उदाहरण

  Input      |     Output
-------------|-------------
23(12+42)    | (23*12)+(23*42)
9(62-5)      | (9*62)-(9*5)
4(17+8-14)   | (4*17)+(4*8)-(4*14)
15(-5)       | -(15*5)
2(3)         | (2*3)
8(+18)       | +(8*18)
8(-40+18)    | -(8*40)+(8*18)

विशिष्टता

इनपुट फॉर्म की एक स्ट्रिंग होगी n(_), जिसमें एक एकल सकारात्मक अहस्ताक्षरित पूर्णांक होगा nजिसके बाद एक कोष्ठक अभिव्यक्ति होगी _। यह अभिव्यक्ति _योगों +और -संकेतों द्वारा अलग किए गए अधिक सकारात्मक-पूर्णांक शब्दों में से एक के अंतर और अंतर से मिलकर बनेगी । पहला शब्द एक +संकेत, एक -संकेत, या बिना किसी संकेत के हो सकता है।

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

अमान्य इनपुट्स

ये उन इनपुट्स के उदाहरण हैं जिन्हें आपको संभालना नहीं है।

3(5 plus 3)
6(5 13)
(5+8)(6+6)
(5+3)8

जीतना

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

Comments

यह मेरे लिए होता है कि इस समस्या के लिए रेगेक्स वास्तव में अच्छी तरह से अनुकूल है। यदि आप reg-ex समाधानों के साथ ठीक नहीं हैं, तो आप इसे प्रतिबंधित कर सकते हैं, हालांकि लोग पहले से ही इस पर काम कर रहे होंगे।

— xnor

क्या पुस्तकालयों की अनुमति है?

— orlp

@orlp एक निश्चित सीमा तक जो मेटा पर चर्चा की गई थी ।

— डाउनगेट

दिलचस्प मामला:8(-40+18)

— BrainSteel

Answer 1

पिप, 28 बाइट्स

DQaUnxWa^'(xR`\d+`'(.n.`*&)`

स्पष्टीकरण:

                              a is first cmdline arg (implicit)
DQa                           Remove (DeQueue) the closing paren from a
   UnxWa^'(                   Unify n and x with a split on open paren--Python equivalent
                                n,x=a.split("(")
                              n is thus the number to be distributed, and x is the
                                addition/subtraction expression
           xR                 In x, replace...
             `\d+`            ... regex matching numbers...
                  '(.n.`*&)`  ... with the replacement pattern (n*&), where n is the
                                appropriate number and & substitutes the complete match
                              Print result (implicit)

पिप के पैटर्न ऑब्जेक्ट ज्यादातर पायथन रेगेक्स सिंटैक्स का पालन करते हैं, लेकिन &प्रतिस्थापन पैटर्न सेड से उधार लिया गया है।

Github रिपॉजिटरी में Pip के बारे में और पढ़ें

Answer 2

जावास्क्रिप्ट 65 बाइट्स

s=>(q=s.split(/[()]/))[1].replace(/(\D?)(\d+)/g,`$1(${q[0]}*$2)`)

यह इनपुट लेगा। + या -, फिर अंक प्राप्त करें, फिर इसे सही क्रम में बदलें।

व्याख्या

s=>   // Function with argument "s"
  (q= // Set q to...
    s.split(/[()]/) // Splits on parenthesis, returns array
  )
  [1] // Gets second match or text inside brackets
  .replace(/ // Replaces string 
     (\D?)  // Try to match a non-digit, the +-/* (group 1)
     (\d+)  // Then match one or more digits (group 2)
  /,
      // $1 is group 1 and $2 is group 2 q[0] is the text before the parenthesis 
  `$1(${q[0]}*$2)`
  ) 

प्रयोग

यह केवल फ़ायरफ़ॉक्स और सफारी नाइटली एज एज में काम करता है ? क्योंकि यह ES6 सुविधाओं का उपयोग करता है। आप इसे द्वारा चला सकते हैं:

var t = s => (q = s.split (/ [()] /)) [1] .replace (/ (\ D?) (\ d +) / g, `$ 1 ($ {q [0]}) * $ 2) `)

t ( "5 (-6 + 7 + 3-8 + 9)" ); // - (5 * 6) + (5 * 7) + (5 * 3) - (5 * 8) + (5 * 9)

Comments

(.?)(\d+)टूट गया है। यह 23(12+42)उत्पादन में विफल रहता है 1(23*2)+(23*42)।

— orlp

@orlp मैंने तय किया है कि

यह कोड केवल ऐरो फंक्शन के फ़ायरफ़ॉक्स b / c में काम करेगा, लेकिन यह ठीक है

— MayorMonty

@SpeedyNinja यह एज में भी काम करता है। क्रोम / ओपेरा के लिए आपको "प्रयोगात्मक जावास्क्रिप्ट सुविधाओं" को सक्षम करने की आवश्यकता है।

— रिंक.टेंडेंट .6

\D?इसके बजाय इस्तेमाल किया जा सकता है[+-]?

— edc65

Answer 3

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

import re
p=re.findall('([+-]?)(\d+)',raw_input())
print"".join("%s(%s*%s)"%(e[0],p[0][1],e[1])for e in p[1:])

कार्यक्रम स्टड से इनपुट लेता है, के खिलाफ मैचों की खोज ([+-]?)(\d+)करता है - रेगेक्स और आउटपुट स्ट्रिंग बनाता है।
इसका परीक्षण -

<< 23(12+42)
>> (23*12)+(23*42)

<< 9(62-5)
>> (9*62)-(9*5)

<< 4(17+8-14)
>> (4*17)+(4*8)-(4*14)

<< 15(-5)
>> -(15*5)

<< 2(3)
>> (2*3)

<< 8(+18)
>> +(8*18)

<< 8(-40+18)
>> -(8*40)+(8*18)

Answer 4

रेटिना , 40 बाइट्स

+`(\d+)\((\D)?(\d+)
$2($1*$3)$1(
\d+..$
<empty line>

प्रत्येक पंक्ति को अपनी फ़ाइल पर जाना चाहिए लेकिन आप -sध्वज के साथ एक फ़ाइल के रूप में कोड चला सकते हैं । उदाहरण के लिए:

>echo -n "8(-40+18)"|retina -s distributing_numbers
-(8*40)+(8*18)

पहली दो पंक्तियाँ अपेक्षित संख्या में हर संख्या के आगे गुणक को धक्का देती हैं:

8(-40+18)
-(8*40)8(+18)
-(8*40)+(8*18)8()

अंतिम दो पंक्तियाँ अनावश्यक अनुगामी भाग को हटा देती हैं:

-(8*40)+(8*18)8()
-(8*40)+(8*18)

Answer 5

सीड, 105 बाइट्स

बस यह देखना चाहता था कि क्या यह सेड के साथ किया जा सकता है।
शायद थोड़ा पुराना स्कूल है, लेकिन यह काम करता है।

$ cat distnum.sed
s@\([0-9]*\)(\([0-9]*\)\([+-]*\)\([0-9]*\)\([+-]*\)\([0-9]*\))@(\1*\2)\3(\1*\4)\5(\1*\6)@
s@([0-9]*\*)@@g

$ cat distnum.txt
23(12+42)
9(62-5)
4(17+8-14)
15(-5)
2(3)
8(+18)
8(-40+18)

$ sed -f distnum.sed distnum.txt
(23*12)+(23*42)
(9*62)-(9*5)
(4*17)+(4*8)-(4*14)
-(15*5)
(2*3)
+(8*18)
-(8*40)+(8*18)

Answer 6

आरएस , 77 बाइट्स

$$d=(?<!\))([+-]?)(\d+)
+$d\($d([+-])/\3(\1\2*\4)\5\1\2(
$d\($d\)/\3(\1\2*\4)

लाइव डेमो और सभी परीक्षण मामलों।

यह पहली बार है जब आरएस का मैक्रो वास्तव में उपयोग किया गया है!

Answer 7

REGXY , 45 बाइट्स

REGXY, एक रेगेक्स प्रतिस्थापन आधारित भाषा का उपयोग करता है।

/(\d+)\((\D)?(\d+)/\2(\1*\3)\1(/
//
/\d+\(.//

Comments

कैसे //काम करता है ? मुझे लगता है कि यह स्ट्रिंग में बदलाव होने तक शीर्ष पर रहता है, लेकिन मैं एसोलंग पृष्ठ में क्यों नहीं मिल सकता।

— यादृच्छिक

यह भाषा कल्पना में अस्पष्टता का एक छोटा सा दुरुपयोग है, लेकिन मैंने इसे यहाँ समझाया है: codegolf.stackexchange.com/questions/52946/…

— Jarmex

मुझे अभी भी नहीं मिलता है कि //अनंत लूप क्यों नहीं बनता है क्योंकि nothingहमेशा मैच होगा इसलिए हम हमेशा पहली पंक्ति में वापस कूदते हैं।

— यादृच्छिक

Y'know क्या? मुझे वास्तव में पता नहीं क्यों। आप बिल्कुल सही हैं, इसके बारे में सोचने से अब कोई तार्किक समझ नहीं बनती है, लेकिन यह निश्चित रूप से संकलित करता है और प्रदान किए गए दुभाषिया में चलता है। यहां तक ​​कि संकलित पर्ल को देखने से यह मुझे भ्रमित करता है, क्योंकि यह और भी स्पष्ट दिखता है कि यह एक अनंत लूप होना चाहिए: pastebin.com/9q7M0tpZ

— Jarmex

Answer 8

पर्ल, 36 बाइट्स

35 बाइट्स कोड + 1 बाइट कमांड लाइन

($a,$_)=split/[()]/;s/\d+/($a*$&)/g

उपयोग:

echo "4(17+8-14)" | perl -p entry.pl

Answer 9

पायथ, 39 38 बाइट्स

एक भयानक रेगेक्स समाधान:

P:eJcz\("([+-]?)(\d+)"X"\\1(_*\\2)"3hJ

Comments

मैं इसे ऑनलाइन दुभाषिया में चलाने के लिए प्राप्त करने के लिए प्रतीत नहीं कर सकता ।

— BrainSteel

@BrainSteel यह ऑफ़लाइन दुभाषिया में काम करता है, यह हर्को के साथ एक समस्या लगती है।

— orlp

@orlp यह हर्को के साथ कोई समस्या नहीं है। डायनेमिक आयात एक हैक की संभावना को कम करने के लिए सुरक्षित मोड में अक्षम हैं, और पुनः मॉड्यूल एक डायनामिक आयात करता है। तो फिर से ऑनलाइन सहित सुरक्षित मोड में उपयोग नहीं किया जा सकता है।

— isaacg

Answer 10

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

gets.scan(/(\d+)\(([[-+]?\d+]+)/){|a,b|b.scan(/([-+]?)(\d+)/).map{|c,d|$><<"#{c}(#{a}*#{d})"}}

Answer 11

सीजेएम, 50 बाइट्स

l__'(#_@<'*+@@)>);'+/'-f/\ff{1$'(@@++')+L?}'-f*'+*

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

CJam में regex सपोर्ट नहीं है, या स्ट्रिंग सर्चिंग और स्प्लिटिंग से परे कुछ भी जो पार्सिंग एक्सप्रेशन के लिए बहुत सुविधाजनक है। तो यहाँ कुछ श्रम शामिल है।

स्पष्टीकरण:

l__   Get input and push 2 copies for splitting.
'(#   Find index of '(.
_     Copy index, will be used twice.
@<    Get one copy of input to top, and slice to get first multiplier.
'*+   Append '* to first multiplier.
@@    Get another copy of input and '( index to top.
)>    Increment and slice to get everything after '(.
);    Remove trailing ').
'+/   Split at '+.
'-f/  Split each part at '-.
\     Swap first multiplier to top.
ff{   Apply block to nested list of second multipliers.
  1$    Copy term. Will use this copy as condition to skip empty second multipliers
        that result from unary + or -.
  '(    Opening parentheses.
  @@    Get first and second multiplier to top.
  ++    Concatenate it all.
  ')+   Concatenate closing parentheses.
  L     Push empty string for case where term is skipped.
  ?     Ternary if to pick term or empty string.
}     End of loop over list of second multipliers.
'-f*  Join sub-lists with '-.
'+*   Join list with '+.

Answer 12

gawk - 60 58

$0=gensub(/(.*\()?(+|-)?([0-9]+))?/,"\\2("$0+0"*\\3)","G")

Phew ... काफी समय में regexp के साथ काम नहीं किया।

Answer 13

पर्ल 5, 70 60 55 44 बाइट्स + 1 जुर्माना

एक पर्ल समाधान जो केवल विभाजन और 1 नियमित अभिव्यक्ति का उपयोग करता है।
साथ ही लंबी इनपुट की गणना करता है।

($a,$_)=split/[()]/;s/(\D?)(\d+)/$1($a*$2)/g

परीक्षा

$ echo "8(9-10+11-12+13-14)"|perl -p distnums.pl   
(8*9)-(8*10)+(8*11)-(8*12)+(8*13)-(8*14)

एक संस्करण जो एक पैरामीटर लेता है

($a,$_)=split/[()]/,pop;s/(\D?)(\d+)/$1($a*$2)/g;print

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

s/(\d+)\((.*)\)/$2:$1/;s/(\D?)(\d+)(?=.*:(\d+)).*?/$1($3*$2)/g;s/:.*//

यह एक सकारात्मक रूपांतर और आलसी मिलान के भीतर कैप्चर समूह के माध्यम से काम करता है। संभवतः पर्ल पॉज़ 5 ने इसका समर्थन किया, लेकिन अफसोस। मुझे यह पता लगाने में थोड़ा समय लगा कि इस तरह की चीज regex के साथ संभव है।

Comments

हे लुक, आप -pकमांड लाइन विकल्प का उपयोग करके कुछ वर्णों को बचाने में सक्षम हो सकते हैं (मुझे लगता है कि यह +1 चार बनाम 9 के लिए है ) ,<>और ;printजैसा कि डिफ़ॉल्ट रूप splitसे काम करेगा $_(जो कुछ भी होगा <>) और प्रिंट लूप में भी शामिल है ! उम्मीद है की वो मदद करदे!

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

धन्यवाद! यह मदद करता है। -P विकल्प केवल मेरे दिमाग को पार नहीं करता था। संभवतः चूंकि यह कुछ ऐसा है जो शायद ही कभी एक गोल्फिंग संदर्भ के बाहर उपयोग किया जाता है। आपको क्या लगता है कि यह +1 वर्ण है? यह चुनौती स्विच का उपयोग करने के लिए दंड के बारे में कुछ भी उल्लेख नहीं करती है।

— 19

मुझे अब पोस्ट नहीं मिल रही है, लेकिन इस मेटा पोस्ट में पर्ल के झंडे का उल्लेख है।

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

मेरा बुरा, ऐसा लग रहा है जैसे मैं ऊपर आया और आपके लिए एक बहुत ही समान समाधान पोस्ट किया, जो प्रभावी रूप से आपका थोड़ा अधिक गोल्फ वाला संस्करण है! मूल रूप से आपको [+ -] पर कब्जा करने की आवश्यकता नहीं है क्योंकि आप उन्हें वैसे भी प्रतिस्थापन में बरकरार रखते हैं: codegolf.stackexchange.com/a/57117/26977

— Jarmex

यह अच्छा है। आपकी वजह से, पर्ल ने इस चुनौती में भी पाइथ / सीजम समाधानों को हराया। मुझे वैसे भी अमान्य इनपुट की परवाह नहीं करनी चाहिए क्योंकि विभाजन के बाद कोष्ठक हटा दिए गए।

— लुकस्टॉर्म

Answer 14

रेटिना , 50 51 43 बाइट्स

मुझे लगता है कि यह मेरा पहला रेटिना कार्यक्रम हो सकता है। यदि नहीं, तो यह मेरा पहला रेटिना प्रोग्राम है जो यह कॉम्प्लेक्स है (न कि कॉम्प्लेक्स, वास्तव में।) प्रत्येक लाइन अपनी फ़ाइल में जाती है।

+`(\d+)\((\D?)(\d+)
$1($'$2($1*$3)
.+?\)
$'

मैंने वास्तव में रेटिना के साथ इसका परीक्षण नहीं किया था, मैंने कई बार एक रेगेक्स-रिप्लेस्ड परीक्षक का उपयोग करके इसका परीक्षण किया, लेकिन यह काम करना चाहिए।

पहले उदाहरण के लिए विवरण:

चूंकि फ़ाइलों की एक समान संख्या है, रेटिना प्रतिस्थापित मोड का उपयोग करता है। पहली जगह (पहली दो फाइलें) वितरित करने के लिए एक संख्या को हटा देती है और उस वितरण जोड़ी (23*12)को अंत में जोड़ देती है , जिससे 23(+42)(23*12)। +`शुरू में रेटिना को बार-बार बदलने के लिए कहता है जब तक कि पैटर्न मैच नहीं करता है, और चूंकि यह फिर से मेल खाता है, पैटर्न इस के साथ बदल देता है 23()(23*12)+(23*42)। यह अब मेल नहीं खाता है, इसलिए अगले 2 फ़ाइलों का उपयोग अगले प्रतिस्थापन के लिए किया जाता है। इस बार, यह केवल हटा देता है 23()। यह अच्छी तरह से काम करता है: चूंकि उत्पादों को अंत तक जोड़ दिया जाता है, मुझे कुछ भी अजीब नहीं करना पड़ता है अगर एक नंबर पर कोई संकेत नहीं है, क्योंकि केवल एक ही जो बिना हस्ताक्षर के हो सकता है वह पहला नंबर है।

संपादित करें: $'प्रतिस्थापन मैच के बाद बाकी स्ट्रिंग का प्रतिनिधित्व करता है, इसलिए मैं अनुगामी (.*)एस को हटा सकता हूं ।

Answer 15

k, 98 बाइट्स

बहुत गोल्फ नहीं है।

{,/(*x){(s#y),("*"/:(x;(s:(*y)in"+-")_y))/:$"()"}/:1_x@:&~~#:'x:((0,&~x in .Q.n)_x){x_'x?'y}/"()"}

गैर-अंक पर विभाजित करें, Parens को हटा दें, खाली तारों को हटा दें, फिर xपहले स्ट्रिंग के रूप में स्थिर रखते हुए , *प्रत्येक शेष स्ट्रिंग के साथ गठबंधन करें y, कोष्ठक करें, और यदि मौजूद हो तो शुरुआत पर हस्ताक्षर करें; एक एकल स्ट्रिंग में समतल उत्पादन।