एक स्ट्रिंग में सभी संख्याओं को गुणा करें

Question

विजेता: चिलीमेजिक , एक विशाल 21 बाइट्स!

आप अपना जवाब प्रस्तुत करना जारी रख सकते हैं, हालाँकि अब आप जीत नहीं सकते। मूल पद रखा:

---

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

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

उदाहरण:

वाक्य इनपुट: यह 1 is22a 3352sentence 50 है

संख्या इनपुट: ३

आउटपुट: यह ३६६ ए १००५६ वेंचर १५० है

---

• यह प्रतियोगिता 6 सितंबर 2014 (पोस्टिंग से 7 दिन) पर समाप्त होती है।
• यह एक कोड-गोल्फ है , इसलिए सबसे छोटा कोड जीतता है

Comments

किसी भी संख्या को गुणा करना है। मैंने अपना उदाहरण अद्यतन किया।

— जॉन

मुझे आपकी चुनौती में "9 बटन दबाएं" का महत्व या उपयोग समझ में नहीं आता है। दिए गए उदाहरण में यह कैसे या कहाँ लागू होता है?

— डैरेन स्टोन

@ डेरेन वह मूल रूप से कह रहे हैं कि आप संख्या को हार्डकोड नहीं कर सकते।

— बीटा डिके

क्या हम शामिल संख्याओं के आकार के बारे में धारणा बना सकते हैं, विशेष रूप से अतिप्रवाह की संभावना? उपरोक्त परिणामों के आधार पर, क्या हम "-1234" को "-" मानते हैं और उसके बाद 1234 या -1234 को मानते हैं?

— Alchymist

@ IlmariKaronen के प्रश्न में जोड़ने के लिए: "बॉन्ड इज एजेंट 007" के रूप में अग्रणी शून्य के साथ क्या करना है -> "बॉन्ड एजेंट 21 है" या "बॉन्ड एजेंट है 0021" या "बॉन्ड एजेंट 021 है" या ...?

— हेगन वॉन एटिजन

Answer 1

अद्यतन - पर्ल - १ 17

s/\d+/$&*$^I/ge

15 अक्षर + 2 -iऔर -pझंडे के लिए।

हम -iफ़ाइल एक्सटेंशन को इनपुट करने के लिए ध्वज का उपयोग कर सकते हैं , लेकिन चूंकि हम किसी भी फाइल को नहीं पढ़ रहे हैं, इसलिए हम इसका उपयोग नंबर प्राप्त करने के लिए कर सकते हैं और यह चर $^Iको सौंपा जाएगा।

साथ दौड़ो:

perl -e'print"This 1 is22a 3352sentence 50"' | perl -i3 -pe's/\d+/$&*$^I/ge'

पर्ल - 21

@ डेनिस की टिप्पणी के अनुसार अपडेट किया गया।

$n=<>;s/\d+/$&*$n/ge

-pझंडे के साथ दौड़ो ।

उदाहरण रन:

perl -e'print"This 1 is22a 3352sentence 50\n3"' | perl -pe'$n=<>;s/\d+/$&*$n/ge'

स्पष्टीकरण:

$n=<>; संख्या में पढ़ें

-p उत्पादन प्रिंट करता है

s/\d+/$&*$n/ge<> के साथ इनपुट पढ़ें और एक या अधिक अंकों की खोज करें और अंकों की संख्या के साथ उन्हें बदलें। gवैश्विक है, eहै evalरों /// की खुराक की जगह। $&जिसमें मिलान किया गया था और यह संख्या से गुणा किया गया था $n,।

आप के बारे में और अधिक पढ़ सकते s///में perlop और अधिक पर्ल में regexes के बारे में perlre ।

एक और समाधान:

@ F.Hauri ने बताया कि आप 4 को चर असाइन करने के लिए s स्विच का उपयोग कर सकते हैं $n। मुझे यकीन नहीं है कि यह कितने वर्णों को गिनता है, लेकिन मैं इसे यहाँ छोड़ दूँगा:

perl -spe 's/\d+/$&*$n/ge' -- -n=4 <<<'This 1 is22a 3352sentence 50'

Comments

मुझे लगता है कि आप <>=~इसके बजाय का उपयोग करके कुछ और अक्षर बचा सकते हैं _$=<>;। क्या आप यह भी बता सकते हैं sकि रेगेक्स का क्या मतलब है, हमारे लिए नौसिखिए?

— ताल

@Tal स्ट्रिंग।

— Kaz वोल्फ

@ मुझे पूरा यकीन है कि यह "प्रतिस्थापन" के लिए है

— मार्टिन

1. आप का उपयोग करते हैं $&बजाय $1, आप छोटा कर सकते हैं (\d)करने के लिए \d। 2. यदि आप -pस्विच का उपयोग करते हैं और इनपुट ऑर्डर बदलते हैं, तो आप ड्रॉप कर सकते हैं say<>=~और r।

— डेनिस

आप उपयोग कर सकते हैं -swhipe करने के लिए स्विच, $n=<>बाहर: perl -spe 's/\d+/$&*$n/ge' -- -n=4 <<<'This 1 is22a 3352sentence 50'(प्रस्तुत करना है: This 4 is88a 13408sentence 200)

— एफ HAURI

Answer 2

जावास्क्रिप्ट (ईएस 6) - 48 44 चार्ट

एक पात्र को बचाने के लिए @bebe को धन्यवाद । अद्यतन: 8 / मार्च / 16, एक और चार वर्णों को हटा दिया

b=(p=prompt)();p(p().replace(/\d+/g,y=>y*b))

अघोषित :

var sentence = prompt(),
    num = parseInt(prompt(), 10); // base 10

sentence = sentence.replace(/\d+/g, digit => digit * num);

alert(sentence);

43 वर्ण:

(p=prompt)(p(b=p()).replace(/\d+/g,y=>y*b))

b=(p=prompt)();p(p().replace(/\d+/g,y=>y*b))

पहले इनपुट की आवश्यकता है और फिर वाक्य की। फिर से यहाँ एक और धन्यवाद @bebe कट!

Comments

आप पार्स संख्या इनपुट की जरूरत नहीं है

— bebe

@ जरूर! मैंने ध्यान नहीं दिया! आपका बहुत बहुत धन्यवाद!

— गौरांग टंडन

(p=prompt)(p(b=p()).replace(/\d+/g,y=>y*b))एक और (लेकिन यह पहले गुणक के लिए पूछता है)

— bebe

@bebe इसके लिए भी धन्यवाद!

— गौरांग टंडन

Answer 3

पायथन 2 (79)

import re
n=input()
s=input()
print re.sub('\d+',lambda x:`int(x.group())*n`,s)

नमूना चला

इनपुट:

$ python mult.py
3
"This 1 is22a 3352sentence 50"

आउटपुट:

This 3 is66a 10056sentence 150

ऑनलाइन डेमो: http://ideone.com/V6jpyQ

Comments

प्रतिभाशाली। मुझे लगता re.subहै कि विधि बीटा डेके और मैं (अन्य दो पायथन प्रस्तुतियाँ) को फिर से लागू करने की कोशिश कर रहे थे। यह इतना आसान होता ... कुछ और जो मैंने सीखा है! ;)

— फाल्को

@ फालो re.subएक तरफ, आपने तर्क की जगह स्ट्रिंग को गोल करने में एक उत्कृष्ट काम किया है

— क्रिस्टियन लुपस्कु

@ फालो मैं सहमत हूं, re.subबिल्कुल वही चीज है जो मैं चाहता था!

— बीटा डिके

Answer 4

अजगर 2 - 126

import re
n=input()
s=input()
for i in list(re.finditer('\d+',s))[::-1]:s=s[:i.start()]+`int(i.group())*n`+s[i.end():]
print s

पहला इनपुट: पूर्णांक n।

दूसरा इनपुट: स्ट्रिंग s(उद्धरण चिह्नों के साथ, जैसे "abc42")।

Answer 5

CJam, 47 33 30 बाइट्स

q_A,sNerN%\[_A,s-Ner~](f*]zs1>

STDIN से संख्या और स्ट्रिंग (उस क्रम में और एक ही स्थान से अलग) पढ़ता है।

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

उदाहरण चलाते हैं

$ cjam multiply.cjam <<< '7 N0 R3GUL4R 3XPR35510N5 1N CJ4M M4K3 M3 4 54D P4ND4'
N0 R21GUL28R 21XPR248570N35 7N CJ28M M28K21 M21 28 378D P28ND28

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

q                                 " Read from STDIN (“Q”) and push a second copy.         ";
  A,s                             " Push “0123456789” (thanks, @aditsu).                  ";
 _   NerN%                        " Replace digits with linefeeds and split at linefeeds. ";
          \ _A,s-Ner              " Replace non-digits with linefeeds.                    ";
                    ~             " Evaluate the resulting string.                        ";
           [         ]            " Collect the results in an array.                      ";
                      (f*         " Multiply all other integers by the first.             ";
                         ]z       " Interleave the elements of both arrays.               ";
                           s1>    " Flatten the result and discard the leading space.     ";

Comments

यह कोड का सबसे अजीब टुकड़ा है !!!

— अजराफती

@ ब्लॉग: यह भी अजीब कोड मैं लिखा है नहीं है । : पी

— डेनिस

हम्म, 3 * 7 = 27?

— २०

योग्य, हाँ दोनों के लिए मतदान किया। हालांकि ये दुनिया को बेहतर जगह नहीं बनाने जा रहे हैं। पृथ्वी प्रोग्रामिंग भाषाओं को कैसे पठनीय माना जाता है?

— अजराफती

@aditsu: विभाजन बनाम पुनरावृत्ति, लड़ाई जारी है। : पी

— डेनिस

Answer 6

बैश + कोरुटिल्स, 38 बाइट्स

eval echo `sed "s/[0-9]\+/$\[$1*&]/g"`

एसटीडीआईएन से इनपुट स्ट्रिंग और एक कमांड-लाइन पैरामीटर के रूप में गुणक पढ़ता है।

आउटपुट:

$ ./multstr.sh 3 <<< "This 1 is22a 3352sentence 50"
This 3 is66a 10056sentence 150
$ 

Comments

दिलचस्प विचार है, लेकिन यह केवल तभी काम करेगा जब स्ट्रिंग में कोई भी वर्ण नहीं है जो बैश के लिए विशेष हैं ... यह एक स्ट्रिंग का एक उदाहरण है जो मैं कोशिश नहीं करूंगा :1 D4R3 Y0U: ; rm -rf /

— डेनिस

@ डेनिस हाँ जो एक दुर्भाग्यपूर्ण चेतावनी है

— डिजिटल ट्रॉमा

Answer 7

LINQPad, 124 में C #

सीधा। LINQPad (भाषा: C # कथन) में CTRL + 2 का उपयोग करें ।

var s=Console.ReadLine();var k=int.Parse(Console.ReadLine());new Regex("\\d+").Replace(s,t=>""+int.Parse(t.Value)*k).Dump();

यदि गुणक को पहले इनपुट पैरामीटर के रूप में दिया जाता है, तो यह 116 वर्णों में किया जा सकता है:

var k=int.Parse(Console.ReadLine());new Regex("\\d+").Replace(Console.ReadLine(),t=>""+int.Parse(t.Value)*k).Dump();

---

संपादित करें:

नीचे अब्बास की टिप्पणी के लिए धन्यवाद, यह भी Regex स्थैतिक विधि का उपयोग करके और अधिक गोल्फ किया जा सकता है , बजाय यह तत्काल:

var k=int.Parse(Console.ReadLine());Regex.Replace(Console.ReadLine(),"\\d+",t=>""+int‌​.Parse(t.Value)*k).Dump();

Comments

अच्छा है, C # में कोड-गोल्फ आसान नहीं है! मैं आपके प्रयास पर निरस्त नहीं होना चाहता, इसलिए मैं आपको अपना जवाब पोस्ट करने के बजाय एक टिप प्रदान करूंगा: नए Regex ("...") के बजाय स्थिर Regex.Replace (string, string, string) का उपयोग करें। ।बदलने के(...); यहाँ लघु गुणक-प्रथम संस्करण है var k=int.Parse(Console.ReadLine());Regex.Replace(Console.ReadLine(),"\\d+",t=>""+int.Parse(t.Value)*k).Dump();:। दोनों संस्करणों में यह एक और 5 पात्रों को बचाता है, आपको लंबे संस्करण के लिए 119 पर और गुणक-प्रथम संस्करण के लिए 111 पर

— अब्बास

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

— जैकब

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

— अब्बास

ज़रूर। उत्तर संपादित किया गया था।

— जैकब

Answer 8

कोबरा - 171

use System.Text.RegularExpressions
class P
    def main
        a=int.parse(Console.readLine?'')
        print Regex.replace(Console.readLine,'\d+',do(m as Match)="[int.parse('[m]')*a]")

Answer 9

पायथन 3 - 141

मुझे नहीं लगता कि मैं इसे और अधिक गोल्फ कर सकता हूं ...

import re
n=input()
f=input()
o=''
p=0
for i in re.finditer('\d+',f):o+=f[p:i.start()]+str(int(i.group())*int(n));p=i.end()
o+=f[p:]
print(o)

उदाहरण:

3     # This is input
h3110 # This is input
h9330 # This is output

10
hello100 hello100
hello1000 hello1000

Comments

दुर्भाग्य से यह दृष्टिकोण काम नहीं करता है। के लिए n=2और s="1 2"इसकी पैदावार 4 4, replaceदो बार पहली संख्या को संशोधित करता है। वही समस्या मैं अभी पाइथन 2 ...;) के साथ सामना कर रहा हूँ;

— फल्को

@ फालो मैं इस समस्या को ठीक करने में कामयाब रहा, हालाँकि इस प्रक्रिया में मेरा कोड अधिक लंबा है

— बीटा डेके

ओह, अच्छा किया! बस कुछ मामूली टिप्पणी: m=input()आप कुछ भी नहीं बचाता है। और x=intवास्तव में int(...)दो बार कॉल करने की तुलना में 2 बाइट्स लंबा है ।

— फाल्को

Answer 10

गणितज्ञ 71 61

मार्टिन चटनर की बदौलत 10 चार्ट बच गए।

कोड में रिक्त स्थान पठनीयता के लिए हैं।

fएक ऐसा कार्य है जिसमें sइनपुट स्ट्रिंग है और nवह संख्या है जिसके द्वारा खोजे गए स्ट्रिंग संख्याओं को गुणा करना है।

 StringReplace[#, a : DigitCharacter .. :> ToString[#2 FromDigits@a]] &

---

उदाहरण

 s="This 1 is22a 3352sentence 50"

पूर्णांक

StringReplace[#, a : DigitCharacter .. :> ToString[#2 FromDigits@a]] &@@{s, 3}

"यह 3 is66a 10056sentence 150"

---

परिमेय संख्या

StringReplace[#, a : DigitCharacter .. :> ToString[#2 FromDigits@a]] &@@{s, -7.13}

"यह -7.13 है, 156.86a -23899.8sentence -356.5"

---

जटिल संख्या

StringReplace[#, a : DigitCharacter .. :> ToString[#2 FromDigits@a]] &@@{s, -5 + 3 I}

"यह -5 + 3 I-110 + 66 Ia -16760 + 10056 Isentence -250 + 150 I" है

Comments

मैं गणितज्ञ को नहीं जानता। लेकिन आपके उदाहरणों में सभी संख्याएं और शब्द रिक्त स्थान से अलग हो जाते हैं। क्या यह अक्षरों के साथ-साथ "abc42" जैसे अक्षरों से सीधे जुड़ा हुआ है?

— फल्को

इसके लिए StringReplaceकोई फर्क नहीं पड़ता कि क्या स्थान हैं। मैंने मूल रूप से चिपेरमैन द्वारा दिए गए उदाहरणों का उपयोग किया।

— डेविड

मैंने अद्यतन उदाहरण पर स्विच किया। (मैंने पहले चिपेरमैन द्वारा दिए गए उदाहरण का उपयोग किया था।) इसके लिए StringReplaceकोई फर्क नहीं पड़ता कि क्या रिक्त स्थान हैं।

— डेविड ऑक

Answer 11

रूबी 40

a,b=$*
p a.gsub(/\d+/){|s|s.to_i*b.to_i}

स्टड से इनपुट।

उदाहरण रन:

$ ruby mult.rb "This 1 is22a 3352sentence 50" 3 
"This 3 is66a 10056sentence 150"

ऑनलाइन डेमो: http://ideone.com/4BiHC8

Answer 12

लुआ: 73 69 वर्ण

r=io.read
s=r()n=r()s=s:gsub("%d+",function(m)return m*n end)print(s)

नमूना रन:

bash-4.3$ lua -e 'r=io.read;s=r()n=r()s=s:gsub("%d+",function(m)return m*n end)print(s)' <<< $'This 1 is22a 3352sentence 50\n3'
This 3 is66a 10056sentence 150

Comments

आप एक पंक्ति में सब कुछ डालकर इसे थोड़ा और गोल्फ कर सकते हैं, और ") के बगल में स्मूशिंग निर्देश"। जैसे "s = r () n = ()" पूरी तरह से ठीक है।

— अंदोअन

दोह, और मैंने कुछ हफ़्ते पहले लूआ में गोल्फ के लिए टिप्स पढ़ी थीं। :( धन्यवाद, @AndoDaan।

— manatwork

Answer 13

जावास्क्रिप्ट, ईएस 6, 43 अक्षर

यह गोल्फ में मेरा पहला प्रयास है!

(p=prompt)(p(n=p()).replace(/\d+/g,y=>y*n))

इसे नवीनतम फ़ायरफ़ॉक्स के कंसोल में चलाएं। पहला इनपुट नंबर है और दूसरा इनपुट वह स्ट्रिंग है जिसमें से संख्याओं को पहले इनपुट नंबर से गुणा किया जाना है।

अंतिम संकेत आउटपुट को सूचीबद्ध करता है।

Comments

पहले टाइमर के लिए बहुत अच्छा जेएस गोल्फ!

— अनुकूलक

यदि नंबर पहले पढ़ा गया था, तो कई अन्य उत्तर कम हो सकते हैं। यह बहुत आसान था।

— मैनटवर्क

@manatwork - हाँ, लेकिन प्रश्न आदेश पर कोई वरीयता नहीं देता है, इसलिए मुझे लगता है कि यह ठीक होना चाहिए।

सही बात। यह स्वयं प्रश्न की कमी है। व्यक्तिगत रूप से मैंने अपने जवाब में स्ट्रिंग + नंबर ऑर्डर में इनपुट को संभालना पसंद किया, ताकि उन्हें दूसरों के साथ तुलनीय रखा जा सके।

— मैनटवर्क

Answer 14

पर्ल - 48 वर्ण

$n=<>;print/\d/?$_*$n:$_ for(<>=~/(\d+)|(\D+)/g)

पहली पंक्ति पर एक संख्या पढ़ें, फिर एक वाक्य पढ़ें और इसे अंक या गैर अंक के चक्र में तोड़ दें। गैर अंकों को प्रिंट करें जैसा कि वे हैं, और संख्याएं गुणा हो जाती हैं।

Answer 15

जे - 63 चार

कार्यक्रम संख्या में पढ़ता है, और फिर वाक्य।

;(*&.".&(1!:1]1)^:(0{i)(<@);.1~1,2~:/\i=.e.&'0123456789')1!:1]1

विस्फोट से समझाया:

;(*&.".&(1!:1]1)^:(0{i)(<@);.1~1,2~:/\i=.e.&'0123456789')1!:1]1
                                                         1!:1]1  NB. read sentence
                                         e.&'0123456789'         NB. is digit? bool vector
                                      i=.                        NB. save to i
                                 2  /\                           NB. between adjacent chars:
                                  ~:                             NB.  true if not equal
                               1,                                NB. pad to sentence length
 (                         ;.1~                         )        NB. cut the sentence
                ^:(0{i)                                          NB. if cut is digits:
  *&.".                                                          NB.  multiply as number
       &(1!:1]1)                                                 NB.  with user input
;                                                                NB. rejoin sentence

अगर हमें J की PCRE लाइब्रेरी का उपयोग करने और वाक्य को पहले आने के लिए मिलता है, तो हम इसे 54 अक्षरों तक गिरा सकते हैं :

;_2(,*&.".&(1!:1]1)&.>)/\'\d+'(rxmatches rxcut])1!:1]1

विस्फोट से समझाया:

                                                1!:1]1  NB. read in sentence
                         '\d+'(rxmatches       )        NB. all /\d+/ matches
                              (          rxcut])        NB. cut by those matches
 _2                     \                               NB. on each nonmatch-match pair:
   (               &.>)/                                NB.  take the match
     *&.".                                              NB.  multiply as number
          &(1!:1]1)                                     NB.  by user input
   (,                 )                                 NB.  prepend nonmatch
;                                                       NB. rejoin sentence

जे इस पर बुरा है, मैं क्या कह सकता हूं। यह असुविधाजनक है क्योंकि जे इतना गैर-उत्तेजक है।

कुछ उदाहरण:

   ;(*&.".&(1!:1]1)^:(0{i)(<@);.1~1,2~:/\i=.e.&'0123456789')1!:1]1
3
This 1 is22a 3352sentence 50
This 3 is66a 10056sentence 150
   ;(*&.".&(1!:1]1)^:(0{i)(<@);.1~1,2~:/\i=.e.&'0123456789')1!:1]1
100
N0 R3GUL4R 3XPR35510N5 1N J M4K35 M3 54D ALS0
N0 R300GUL400R 300XPR3551000N500 100N J M400K3500 M300 5400D ALS0
   0!:0 <'system\main\regex.ijs'  NB. this is usually preloaded by J on startup anyway
   ;_2(,*&.".&(1!:1]1)&.>)/\'\d+'(rxmatches rxcut])1!:1]1
TH4T'5 M4RG1N411Y B3TT3R
0
TH0T'0 M0RG0N0Y B0TT0R

Answer 16

CJam - 35

li:X;lN+{_sA,s-,{])\_!!{iX*}*oo}*}/

इसे http://cjam.aditsu.net/ पर आज़माएं

नमूना इनपुट:

7
CJ4M W1LL H4V3 R3GUL4R 3XPR35510N5 L4T3R

नमूना उत्पादन:

CJ28M W7LL H28V21 R21GUL28R 21XPR248570N35 L28T21R

स्पष्टीकरण:

कार्यक्रम प्रत्येक चरित्र के माध्यम से जाता है, स्टैक पर अंकों को इकट्ठा करता है, और प्रत्येक गैर-अंक के लिए यह पहले एकत्रित संख्या को प्रिंट करता है (यदि कोई है) तो संख्यात्मक इनपुट से गुणा किया जाता है, फिर चरित्र को प्रिंट करता है।

li:X;संख्यात्मक इनपुट पढ़ता है और इसे X में संग्रहीत करता है
lN+स्ट्रिंग को पढ़ता है और स्ट्रिंग
{…}/में प्रत्येक वर्ण के लिए एक नई रेखा (अनुगामी संख्या के साथ मदद करता है) को जोड़ता है
- _sचरित्र की प्रतिलिपि बनाता है और स्ट्रिंग में कनवर्ट करता है
- A,s-,सभी अंकों को निकालता है और शेष वर्णों को गिनता है; परिणाम 0 होगा यदि चरित्र एक अंक या 1 था यदि नहीं
- {…}*ब्लॉक को निष्पादित करता है यदि गिनती 1 थी (यानी गैर-अंक); अंकों के लिए यह कुछ नहीं करता है, इसलिए वे स्टैक पर बने रहते हैं
- स्टैक ]से पात्रों को एक सरणी (यानी एक स्ट्रिंग) में इकट्ठा करता है; वर्ण पिछले पुनरावृत्तियों से कोई अंक हैं, और वर्तमान वर्ण
- )\अंतिम आइटम (वर्तमान वर्ण) को अलग करता है और इसे (शेष) स्ट्रिंग से पहले स्थानांतरित करता है
- _!!स्ट्रिंग को कॉपी करता है और इसे बूलियन मान में कनवर्ट करता है - 0 यदि खाली है, तो 1
- यदि नहीं - {…}*ब्लॉक को निष्पादित करता है यदि स्ट्रिंग खाली नहीं था, तो वर्तमान गैर-अंक चरित्र से पहले हमारे पास कुछ अंक थे
--- iX*स्ट्रिंग को कनवर्ट करता है पूर्णांक और गुणन द्वारा X
- oस्टैक के शीर्ष को प्रिंट करता है - या तो गुणा संख्या या रिक्त स्ट्रिंग यदि हमारे पास कोई संख्या नहीं है
- o(दूसरा वाला) स्टैक के नए शीर्ष को प्रिंट करता है - वर्तमान गैर- अंक चरित्र

Comments

यह एक बहुत ही पवित्र दृष्टिकोण है।

— डेनिस

Answer 17

हास्केल (161)

golfed

main=do{n<-getLine;l<-getContents;let{g c(t,s)|c>'/'&&c<':'=(c:t,s)|t/=""=([],c:(show.(*(read n)).read$t)++s)|True=(t,c:s)};putStr.tail.snd.foldr g("","")$' ':l}

Ungolfed

modify :: (Show a, Read a) => (a -> a) -> String -> String
modify f = show . f . read

main=do
  number <- fmap read $ getLine    -- get number  
  l <- getContents                 -- get input

  -- if the current character is a digit, add it to the digits
  -- if the current character isn't a digit, and we have collected
  --    some digits, modify them and add them to the string
  -- otherwise add the current characters to the string

  let go current (digits , string) 
        | current `elem` ['0'..'9'] = (current : digits, string)
        | not (null digits)         = ([], current:(modify (*number) digits) ++ string)
        | otherwise                 = (digits, current:string)

  -- since the result of `go` is a pair, take the second value,
  -- remove the head (it's a space, in order to convert digits at the start)
  -- and print it
  putStr . tail . snd . foldr go ("","")$' ':l

दुर्भाग्य से, हास्केल अपने में एक Regex पुस्तकालय नहीं है प्रस्तावना ।

Comments

अच्छी गोल्फिंग; आप {}1 char के लाभ के लिए सबसे बाहरी हटा सकते थे । इसके अलावा, मैंने सिर्फ 70 बाइट्स के साथ इस हास्केल समाधान को पोस्ट किया: codegolf.stackexchange.com/questions/37110/…

— गर्वित हैकेलर

Answer 18

फ्लेक्स (-लेक्सर) ( 94 89 वर्ण)

 int m;main(c,v)char**v;{m=atoi(*++v);yylex();}
%%
[0-9]+ {printf("%d",m*atoi(yytext));}

यदि आप कमांड-लाइन तर्क (बहुत अधिक समय नहीं) भूल जाते हैं तो अनगुल्ड संस्करण, जो सेगफॉल्ट नहीं करता है:

%{
#define YY_DECL int y(int m)
%}
%option noyywrap noinput nounput
%%
[0-9]+ {printf("%d",m*atoi(yytext));}
%%
int main(int argc, char** argv) {
  return (argc > 1) ? y(atoi(argv[1])) : 1;
}

संकलन:

flex -o m.c m.l
cc -o m m.c -lfl

या:

flex --noyywrap -o m.c m.l
cc -o m m.c

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

$ ./m 163
This 1 is22a 3352sentence 50
This 163 is3586a 546376sentence 8150

Answer 19

Groovy - 124

Scanner s=new Scanner(System.in)
def x=s.nextLine()
def n=s.nextInt()
x=x.replaceAll(/\d+/,{it->it.toInteger()*n})
println x

रन करने योग्य उदाहरण देखने के लिए शीर्षक पर क्लिक करें

उदाहरण दिए गए:

यह १ .२२ ए ३३२ सेंसेंटेंस ५०
३
यह ३ ई ६६ ए १००५६ वेंचर १५०

---

यह १ .२२ ए ३३५२सेन्टनेस ५०
४२
यह ४२ is924a 140784sentence 2100

Answer 20

GNU Awk: 86 वर्ण

s{n=split(s RS,a,/[^0-9]+/,d);while(++i<n)printf"%s%s",a[i]==""?"":a[i]*$1,d[i]}{s=$0}

नमूना रन:

bash-4.3$ awk 's{n=split(s RS,a,/[^0-9]+/,d);while(++i<n)printf"%s%s",a[i]==""?"":a[i]*$1,d[i]}{s=$0}' <<< $'This 1 is22a 3352sentence 50\n3'
This 3 is66a 10056sentence 150

Answer 21

PHP - 75/115 68/109

दो संस्करण, नए php संस्करण यह कर सकते हैं:

echo preg_replace_callback("/\d+/",function($m){return$m[0]*$f;},$s);

पुराने php संस्करण: मैंने न्यूलाइन को नहीं गिना, पठनीयता के लिए जोड़ा।

function a($s){echo preg_replace_callback("/\d+/",b,$s);}
function b($i){global$f;return$i[0]*$f;}
a($s,$f);

उदाहरण इनपुट + आउटपुट

$s = "ab11cd22"; // string
$f =  3; // -> output: ab36cd69
$f = -2; // -> output: ab-24cd-46

मुश्किल, शब्द 'फंक्शन' और 'प्रीग_रेप्ले_कॉलबैक' में बहुत सारे आकर्षण हैं।
के बाद अंतरिक्ष globalऔर returnनहीं हैं, तो एक $ वर (-2 वर्ण) के बाद की जरूरत

Comments

\dचरित्र वर्ग (-2 वर्ण) में डालने की आवश्यकता नहीं ; फ़ंक्शन को दोहरे उद्धरण (-2 वर्ण) में संलग्न करने की आवश्यकता नहीं है; आपको फ़ंक्शन के अंदर के स्टेटमेंट को अर्धविराम (+1 वर्ण) के साथ ठीक से समाप्त करना होगा। वैसे, \dदोहरे उद्धरण में स्ट्रिंग के रूप में लिखा जाना चाहिए \\d, इसलिए बेहतर उद्धरण को एकल उद्धरण में बदल दें।

— मैनटवर्क

धन्यवाद। [0-9] से शुरू होकर, 0-9\ d में बदल गया । फ़ंक्शन के आस-पास के उद्धरणों के बारे में सुनिश्चित नहीं है, मैं यह परीक्षण कर सकता हूं कि एक, मेरे स्थानीय php के संस्करण ने इसे अनुमति नहीं दी है।

— मार्टिज़न

दोहरे उद्धरण ठीक काम करते हैं (कम से कम मेरे लिए) :)

— मार्टीजन

Answer 22

सी ( 142 134 अक्षर)

main(a,b)char**b;{char*c=b++[2],*d="0123456789";for(;*c;c+=strspn(c
,d))write(1,c,a=strcspn(c,d)),dprintf(1,"%d",atoi(*b)*atoi(c+=a));}

बढ़ी हुई सुगमता के लिए डाला गया न्यूलाइन। पहले के रूप में कारक पास करें, दूसरी कमांड लाइन विकल्प के रूप में स्ट्रिंग। इस कार्यान्वयन के लिए dprintfफ़ंक्शन की आवश्यकता है जो POSIX.1 2008 का हिस्सा है और विंडोज पर उपलब्ध नहीं हो सकता है। यहाँ अघोषित स्रोत है:

/*
 * Multiply all numbers in a string by a number.
 * http://codegolf.stackexchange.com/q/37110/134
 * Solution by user FUZxxl
 */

#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>

extern int
main(int count, char **argv)
{
    char *str = argv++[2], *digits = "0123456789";

    while (*str) {          /* as long as we have not reached the end */
        count = strcspn(str, digits);
        write(1, str, count);

        dprintf(1, "%d", atoi(*argv) * atoi(str += count));
        str += strspn(str, digits);
    }
}

सुधार

• 142 → 134: उपयोग करें strspnऔर strcspnस्ट्रिंग पर लूपिंग के बजाय।

Answer 23

पायथन 89

import re,sys
j,n,s=sys.argv
print re.sub('(\d+)',lambda m:str(int(m.group())*int(n)),s)

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

# python numberstring.py 3 '1shoop da2 w007p!'
3shoop da6 w21p!

Answer 24

प्रतिबल - ११bol

n: do input d: charset"0123456789"parse s: input[any[b: some d e:(e: insert b n * do take/part b e):e | skip]]print s

Ungolfed:

n: do input 
d: charset "0123456789"

parse s: input [
    any [
        b: some d e: (e: insert b n * do take/part b e) :e
        | skip
    ]
]

print s

Answer 25

क्लोजर - 141 140 128 चरस

मैं एक नौसिखिया नौसिखिया हूँ, लेकिन FWIW:

(let[[a b]*command-line-args*](println ((fn[s n](clojure.string/replace s #"\d+"#(str(*(read-string %)(read-string n)))))a b)))

नमूना रन:

bash$ java -jar clojure-1.6.0.jar multstr.clj "This 1 is22a 3352sentence 50" 3  
This 3 is66a 10056sentence 150

अस्वाभाविक (बदसूरत लेकिन उम्मीद है कि पढ़ने के लिए कुछ आसान):

(let [[a b] *command-line-args*]
    (println ( (fn [s n] 
                    (clojure.string/replace 
                        s 
                        #"\d+" 
                        #(str (* (read-string %) (read-string n)))))
                    a b)))

Answer 26

अजगर - 142

import re
s=raw_input()
i=int(raw_input())
print ''.join([x[0]+str(int(x[1])*i) for x in filter(None,re.findall('(\D*)(\d*)',s)) if x[0]!=''])

Answer 27

जावा 218

किसी को जावा करना था। इनपुट स्ट्रिंग कमांड लाइन पर 2 टोकन हैं।

java M 'यह 1 is22a 3352sentence 50' 3 है

public class M{
    public static void main(String[]a) {
        int m=new Integer(a[1]),n=0,b=0;
        String s="";
        for(char c:a[0].toCharArray()){
            if(c<48|c>57)s=b>(b=0)?s+m*n+c:s+c;
            else n=b*n+c-38-(b=10);
        }
        System.out.println(b>0?s+m*n:s);
    }
}

Comments

मेरे परीक्षण के अनुसार, ifस्थिति बिटवाइज़ के साथ |भी काम करती है, जो 1 वर्ण छोटा है।

— मैनटवर्क

धन्यवाद। कोड अपडेट किया गया। (यह वास्तव में अभी भी एक बूलियन है या, सिर्फ मूल्यांकन शॉर्टकट के बिना)।

— फ्लोरियन एफ

Answer 28

दो उत्तर: पर्ल + बैश

शुद्ध बैश (~ 262)

सबसे पहले, इतना छोटा शुद्ध बैश संस्करण नहीं है (कोई कांटा नहीं, कोई बाहरी बायनेरी नहीं)!

mn () { 
    if [[ $1 =~ ^(.*[^0-9]|)([0-9]+)([^0-9].*|)$ ]]; then
        local num=${BASH_REMATCH[2]} rhs="${BASH_REMATCH[3]}";
        mn "${BASH_REMATCH[1]}" ${2:-3} l;
        echo -n "$[num*${2:-3}]$rhs";
    else
        echo -n "$1";
    fi;
    [ "$3" ] || echo
}

आइए दिखाते हैं:

mn "This 1 is22a 3352sentence 50" 42
This 42 is924a 140784sentence 2100

(जो पूरी तरह से अनुचित वाक्य है)

पर्ल थोड़ा मोटे तौर पर (केवल मनोरंजन के लिए)

यह संस्करण ( @ चिलमजिक के उत्तर पर आधारित ) छोटा नहीं है, लेकिन एक टोटेम स्क्रिप्ट के रूप में बनाया गया है :

cat <<eof >mn.pl

#!/usr/bin/perl          -sp
                      eval eval'"'
                      .('['^'(')
           .'/\\'.'\\'.('`'|'$').'+'.'/\\$\&'
                        .'*\\$'
                      .('`'|'.').'/'
                      .('`'|"'")
                      .('`'|'%').'"'

eof chmod +x mn.pl

नमूना रन:

./mn.pl -n=2 <<<$'This 1 is22a 3352sentence 50\n21.'
This 2 is44a 6704sentence 100
42.

Answer 29

हास्केल, 70

बहुत बुरा मुझे बहुत देर हो रही है IMHO यह इस विशिष्ट प्रश्न और भाषा के लिए बहुत अच्छा है। अन्य हास्केल समाधान यहाँ 161 वर्ण है ..

[]%n=""
s%n=f s(reads s)n
f _((a,b):_)n=show(a*n)++b%n
f(x:s)_ n=x:s%n

यह readsफ़ंक्शन का उपयोग करके काम करता है जो एक स्ट्रिंग को आंशिक रूप से पार्स करता है। उदाहरण के लिए, reads "34abc" = [(34, "abc")]। यह स्पष्ट रूप से इस चुनौती के लिए एकदम सही है।

उपयोग:

*Main> " This 1 is22a 3352sentence 50"%3
" This3 is66a10056sentence150"