एक स्ट्रिंग में सम पूर्णांक

11

इनपुट

एक स्ट्रिंग।

उत्पादन

पंक्ति में सभी पूर्णांकों का योग।

प्रतिबन्ध

1≤ लाइन की संरचना

नमूना परीक्षण मामला

इनपुट

the 5is 108 seCONd4 a

उत्पादन

117

व्याख्या

योग है: ५ + १० is + ४ = ११।

code-golf  string  number  integer  parsing 
— करनदीप सिंह
स्रोत
6
नमस्ते वहाँ, PPCG में आपका स्वागत है। किसी एकल भाषा के लिए चुनौतियां आमतौर पर पीपीसीजी में यहाँ पर फेंक दी जाती हैं। हो सकता है कि आप इसे एक सामान्य चुनौती में बदल सकते हैं: एक स्ट्रिंग दी गई है, स्ट्रिंग में सभी नंबरों का योग, बाकी सब को अनदेखा करते हुए ( क्योंकि इसमें "the 5is 108 seCONd4 a"परिणाम होगा )। साथ ही, यहां प्रत्येक 'प्रश्न' में जीतने की स्थिति का टैग होना चाहिए । इस मामले में मुझे लगता है कि यह [कोड-गोल्फ] (सबसे कम संभव समाधान है)? 1175+108+4=117
— केविन क्रूज़सेन
4
ऐसा प्रतीत होता है कि आपने SO पर एक समान प्रश्न पोस्ट किया है , जो इस बात की पुष्टि करता है कि यह PPCG चुनौती के लिए डिज़ाइन नहीं किया गया था और आप गोल्फ कोड के बजाय 'प्रयोग करने योग्य' कोड की तलाश कर रहे हैं। मैं इसके बजाय SO पर आपके मूल प्रश्न को बेहतर बनाने की सलाह दूंगा, ताकि यह साइट के नियमों को बेहतर ढंग से फिट करे।
— अरनुलद
4
हमारे मानकों पर खरा उतरने के लिए मैंने आपकी पोस्ट को ओवरहॉल किया है। अगर परिणाम आपको शोभा नहीं देता तो बेझिझक संपादित करें।
— प्रवेश
4
— mbomb007
2
इस मामले के बारे में क्या string x='-12hello3';आप नकारात्मक पूर्णांक (जैसे? -12 + 3 === -9) की गिनती कर रहे हैं?
— शॉन बेयबर्स

जवाबों:

4

जावास्क्रिप्ट, 34 32 बाइट्स

s=>eval(s.match(/\d+/g).join`+`)

सभी अंकों का मिलान करें और उन्हें +5 + 108 + 4 में बदलकर, परिणाम निकालें।
केवल सकारात्मक पूर्णांक पर काम करता है।

2 बाइट्स अर्नुल्ड के लिए धन्यवाद

f=
    s=>eval(s.match(/\d+/g).join`+`)

g=()=>b.innerHTML = f(a.value)
g()
<input id=a value="the 5is 108 seCONd4 a" onkeyup="g()">
<pre id=b>
स्निपेट का विस्तार करें

— बैसड्रॉब कंबरवुबवबब
स्रोत
मुझे लगता है कि वर्णों की गणना करने के लिए कंसोल में string.length का उपयोग करना एक अच्छा विचार नहीं है जब इसमें भागने के पात्र हों ... वूप्स, इसे ठीक किया। Thx फिर से
— बैसड्रॉफ़ कम्बरबुवबूब
एक थोड़ा बेहतर विकल्प होगा console.log(f.toString().length), लेकिन यह है नहीं या तो 100% विश्वसनीय।
— अरनुलद
या सिर्फ TIO का उपयोग कर रहे हैं ...
— जो किंग
4

05AB1E , 11 6 बाइट्स

þмS¡þO

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

स्पष्टीकरण:

þм       # Only leave the non-digits of the (implicit) input-string
         #  i.e. "the 5is 108 seCONd4 a" → "the is  seCONd a"
  S      # Split it into a list of characters
         #  → ["t","h","e"," ","i","s"," "," ","s","e","C","O","N","d"," ","a"]
   ¡     # Split the (implicit) input-string by each of these characters
         #  → ["","","","","5","","","108","","","","","","","4","",""]
    þ    # Remove the empty strings by only leaving the digits
         #  → ["5","108","4"]
     O   # And sum these numbers (which is output implicitly)
         #  → 117
— केविन क्रूज़सेन
स्रोत
1
अरे अरे, का चतुर उपयोग ¡!
— निकली आउटगॉल्फ
4

आर , 64 48 45 बाइट्स

पॉवरशेल प्रविष्टि देखने के बाद मैं इसे आगे बढ़ाने में सक्षम था।

function(s)eval(parse(,,gsub('\\D+','+0',s)))

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

— सीटी हॉल
स्रोत
t=के बजाय यहां पर्याप्त हैtext
— Giuseppe
धन्यवाद, मैं हमेशा आंशिक मिलान के बारे में भूल जाता हूं, (और, स्ट्रिंग ऑफ,, आप जिस विकल्प को चाहते हैं उसे प्राप्त करें)।
— सीटी हॉल
3

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

बेनामी टैकिट प्रीफ़िक फ़ंक्शन

+/#⍎¨∊∘⎕D⊆⊢

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

⊢ बहस

⊆ विभाजित (ट्रू के रन बनते हैं, फाल्स की रन विभाजक होते हैं)

∊ सदस्यता
∘ के
⎕D अंकों के सेट

#⍎¨ रूट नेमस्पेस में प्रत्येक का मूल्यांकन करें

+/ योग

— एडम
स्रोत
3

रेटिना 0.8.2 , 8 बाइट्स

\d+
$*
1

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

  • पहली पंक्ति सभी संख्याओं से मेल खाती है
  • दूसरी पंक्ति 1 एस द्वारा इनकी जगह लेती है, बार-बार कहा गया है
  • अंतिम पंक्ति एक मैच है, और स्ट्रिंग में कुल संख्या 1s गिना जाता है
— Ven
स्रोत
2

चारकोल , 5 बाइट्स

ＩΣ⁺ψＳ

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। स्पष्टीकरण: चारकोल का Sumऑपरेटर स्वचालित रूप से एक स्ट्रिंग से संख्याएं निकालता है, हालांकि यदि स्ट्रिंग में कोई गैर-अंक वर्ण नहीं है, तो इसके बजाय यह डिजिटल योग लेता है, इसलिए मैं इससे बचने के लिए एक अशक्त बाइट को सम्मिलित करता हूं। परिणाम तो निहित उत्पादन के लिए वापस स्ट्रिंग करने के लिए है।

— नील
स्रोत
2

Zsh , 21 बाइट्स

<<<$[${1//[^0-9]/+0}]

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

  ${1           }  # the 5is 108 seCONd4 a
  ${1//[^0-9]/+0}  # +0+0+0+05+0+0+0108+0+0+0+0+0+0+04+0+0
$[${1//[^0-9]/+0}] # 117

दुर्भाग्य से, बैश शिकायत करता है क्योंकि यह 0108अष्टक के रूप में व्याख्या करता है। Zsh नहीं करता है (जब तक setopt octalzeroes)

— GammaFunction
स्रोत
2

बैश, 43 बाइट्स

for n in ${1//[!0-9]/ };{((s+=n));};echo $s

हर गैर-संख्या को एक स्थान के साथ बदल देता है, और फिर उन्हें एक साथ जोड़ देता है।

-5 बाइट्स गामाफंक्शन के लिए धन्यवाद

— vityavv
स्रोत
— गामा फंक्शन
1
धन्यवाद! मैंने अपने पोस्ट
— vityavv
1

पायथन 3 , 63 59 56 बाइट्स

क्यों नहीं। अप्रचलित रेगेक्स उत्तर। शायद पायथन 2 का उपयोग करके 6 को डॉक कर सकता है, लेकिन जो भी हो। अब लागू नहीं होता है क्योंकि मैं मानचित्र का उपयोग करने के बजाय एक स्पष्ट दृष्टिकोण का उपयोग कर रहा हूं। 

import re;x=lambda y:eval('+'.join(re.findall('\d+',y)))

स्पष्टीकरण:

import re; # Import regex module
x=lambda y: eval(                                 ) # Run as Python code
                  '+'.join(                     ) # Joined by '+'
                            re.findall('\d+',y) # A list of all matches of regex \d+ in string y

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

— epicness
स्रोत
अच्छा! अपने TIO में आपको हालांकि z == l[1]इसके बजाय का उपयोग करना चाहिए z is l[1]। यदि कोड पर्याप्त संख्या में मिलता है, तो वर्तमान कोड गलत नकारात्मक संकेत दे सकता है।
— जकॉब
1

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

यह एक लंबोदर Stringहै int।

s->{var r=0;for(var n:s.split("\\D"))r+=new Long("0"+n);return r;}

नकारात्मक पूर्णांक समर्थित नहीं हैं। संभवत: यह ठीक है।

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

स्वीकृतियाँ

— जेकब
स्रोत
1
आप बदल सकते हैं [^0-9]के लिए \Dकुछ बाइट्स के लिए, यह भी आप बदल सकते हैं longऔर Stringके लिए var(आप के लिए वापसी प्रकार बदलने के लिए होगा, हालांकिint
— अज्ञान की अवतार
1

क्यूबिक्स , 17 बाइट्स

?|i.I!/s+q;;>p.O@

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

    ? |
    i .
I ! / s + q ; ;
> p . O @ . . .
    . .
    . .

देखो इसे चलाते हैं

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

  • I! एक पूर्णांक इनपुट और यह 0 के लिए परीक्षण
  • s+q;;यदि शून्य न हो, तो टीओएस (बलों और प्रारंभिक 0) को स्वैप करें और जोड़ें। स्टैक के निचले भाग को धक्का दें और शीर्ष को साफ करें। शुरुआत पर लौटें।
  • /i? यदि शून्य है, तो पुनर्निर्देशित करें और जांच के लिए एक चरित्र इनपुट करें
  • |?;/यदि पॉजिटिव (कैरेक्टर) राइट रिफ्लेक्ट में बदल जाता है, तो यह इसे वापस चेकर के माध्यम से धकेलता है ?और स्टैक से पॉप पर दाईं ओर मुड़ता है, जिससे टीओएस पर 0 निकल जाता है। आईपी ​​फिर मुख्य लूप में वापस अप्रत्यक्ष हो जाता है।
  • I>p.O@ यदि नकारात्मक (इनपुट का अंत) बाएं मुड़ता है, तो पूर्णांक इनपुट करें, स्टैक के निचले भाग को शीर्ष, आउटपुट और पड़ाव पर लाएं।
— MickyT
स्रोत
1

आगे , 13 बाइट्स

यह काम करता है क्योंकि Iबस अगले टोकन के लिए इनपुट स्ट्रीम को स्कैन करता है जो किसी भी चीज़ को अनदेखा करते हुए, एक नंबर की तरह दिखता है।

~Ilj~#
 >K+O@

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

— snail_
स्रोत
0

अटैची , 23 बाइट्स

Sum##N=>MatchAll&"\\d+"

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

एक अधिक दिलचस्प, लेकिन अप्रत्यक्ष, उत्तर (37 बाइट्स): {Sum!Reap[ReplaceF[_,/"\\d+",Sow@N]]}

व्याख्या

Sum##N=>MatchAll&"\\d+"

इसका रूप है:

f##g=>h&x

जो, विस्तारित और कोष्ठक बनने पर:

f ## (g => (h&x))

##एक साथ दो कार्यों की रचना करता है, =>एक फ़ंक्शन को सही फ़ंक्शन के परिणाम पर बाएं फ़ंक्शन मैपिंग बनाता है, और &एक फ़ंक्शन के एक पक्ष में एक तर्क बांधता है। इनपुट के लिए _, यह इसके बराबर है:

{ f[Map[g, h[_, x]]] }

पहले, फिर, हम MatchAllअंकों के पात्रों ( \\d+) को चलाते हैं । Nफ़ंक्शन के उपयोग के बाद, हम प्रत्येक रन को एक वास्तविक पूर्णांक में परिवर्तित करते हैं । अंत में, हम इन संख्याओं का उपयोग कर लेते हैं Sum।

— कोनोर ओ ब्रायन
स्रोत
0

एपीएल (एनएआरएस), चार्ट 13, बाइट्स 26

{+/⍎¨⍵⊂⍨⍵∊⎕D}

परीक्षा:

  f←{+/⍎¨⍵⊂⍨⍵∊⎕D}
  f 'the 5is 108 seCONd4 a'
117
— RosLuP
स्रोत
0

जाप v2.0a0 -x, 3 बाइट्स

मेरी (बहुत WIP) दुभाषिया के लिए एक और परीक्षण ड्राइव।

q\D

कोशिश करो

q\D     :Implicit input of string
q       :Split on
 \D     :  Non-digit characters (/[^0-9]/)
        :Implicitly reduce by addition and output
— झबरा
स्रोत
0

जावा 8, 53 130 बाइट्स

रेगेक्स आयात के लिए 105 बाइट्स + 25 बाइट्स

s->{long c=0;for(Matcher m=Pattern.compile("\\d+").matcher(s);m.find();c+=new Long(m.group()));return c;}

इसे ऑनलाइन आज़माएं!
व्याख्या

s->{                                                    // Lambda function
    long c=0;                                           // Sum is zero
    for(Matcher m=Pattern.compile("\\d+").matcher(s);   // Prepare regex matcher
        m.find();                                       // While the string contains unused matches...
        c+=new Long(m.group()));                        // Add those matches to the output
    return c;                                           // Return the output
   }
— बेंजामिन अर्कहार्ट
स्रोत
2
मुझे नहीं लगता कि यह सही है: ओपी द्वारा (केवल) उदाहरण से पता चलता है कि लगातार अंकों को एक पूर्णांक बनाना चाहिए, इसलिए "123" को 123 का उत्पादन करना चाहिए, न कि 6 जैसा आपका कोड करता है।
— मिखाइल
यह दुर्भाग्यपूर्ण है, जब मैं कर सकता हूं तो मैं संशोधित करूंगा
— बेंजामिन अर्कहार्ट
@ मिचेल ने संशोधित किया
— बेंजामिन
0

पिप , 6 बाइट्स

$+a@XI

-123एक नकारात्मक पूर्णांक के रूप में व्यवहार करता है। इसे ऑनलाइन आज़माएं!

  a     Command-line input
   @XI  Regex find all integers (XI is a variable predefined as the regex `-?\d+`)
$+      Fold on +

यदि माइनस संकेतों के रूप में इलाज के बजाय हाइफ़न को अनदेखा किया जाना चाहिए, तो निम्न 7 बाइट्स के लिए काम करता है :

$+a@+XD

XDके लिए एक पूर्व निर्धारित चर है `\d`; +XDइसमें रेगेक्स +संशोधक जोड़ता है, जिससे यह 1 या अधिक अंकों से मेल खाता है।

— DLosc
स्रोत
0

जावा (JDK) , 98 94 93 बाइट्स

s->java.util.Arrays.stream(s.split("\\D")).filter(t->!t.isEmpty()).mapToLong(Long::new).sum()

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

-4 bytesके Long::newबजाय का उपयोग करके Long::valueOf।
-1 byteरेगेक्स को छोटा करके - यदि हम पहले से ही खाली तारों को हटा रहे हैं, तो बंटवारे के समय कुछ एक्स्ट्रा बनाते हैं।

व्याख्या की

s->                            // Lambda (target type is ToLongFunction<String>)
    java.util.Arrays.stream(   // Stream the result of
        s.split("\\D")        // splitting on non-digits
    )
    .filter(t->!t.isEmpty())   // Discard any empty strings
    .mapToLong(Long::new)      // Convert to long
    .sum()                     // Add up the stream's values.
— सारा जे
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.