छानकर ऊपर डालें

Question

कार्य

कार्य बहुत सरल है। गैर-रिक्त स्ट्रिंग वाली संख्याओं , अपरकेस और लोअरकेस अक्षरों को देखते हुए , शेष संख्याओं के योग का उत्पादन करते हैं। उदाहरण के लिए:

a1wAD5qw45REs5Fw4eRQR33wqe4WE

सभी अक्षरों को छानने से परिणाम होगा:

 1   5  45   5  4    33   4

इन संख्याओं का योग है 1 + 5 + 45 + 5 + 4 + 33 + 4 = 97। तो आउटपुट होगा 97।

परीक्षण के मामलों

a > 0
0 > 0
5 > 5
10 > 10
a0A > 0
1a1 > 2
11a1 > 12
4dasQWE65asAs5dAa5dWD > 79
a1wAD5qw45REs5Fw4eRQR33wqe4WE > 97

यह कोड-गोल्फ है , इसलिए कम से कम बाइट्स जीत के साथ सबमिशन!

Comments

मुझे पता था कि मैंने इससे पहले लेबिरिंथ प्रोग्राम लिखा था ... यहाँ एक ही चुनौती है लेकिन नकारात्मक संख्याओं के साथ (जो कुछ भाषाओं के लिए आश्चर्यजनक रूप से बड़ा अंतर पैदा करता है, इसलिए मुझे नहीं लगता कि वे नकल करते हैं)।

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

@ मार्टिनबटनर ऐसा लगता है कि किसी में नकारात्मक संख्याएं शामिल नहीं हैं: "-n (जहां n एक पूर्णांक है) को एक नकारात्मक n के रूप में नहीं गिना जाता है, लेकिन एन के बाद एक हाइफ़न के रूप में गिना जाता है।"

— पॉल

ओह, मैं समझता हूं कि तुम्हारा क्या मतलब है। आप कह रहे हैं कि इसमें हाइफ़न है और यह नहीं है।

— पॉल

Answer 1

जीएस 2, 2 बाइट्स

Wd

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

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

W     Read all numbers.
      For input x, this executes map(int, re.findall(r'-?\d+', x)) internally.
 d    Compute their sum.

Comments

खैर, यह अप्रत्याशित था ...

— अदनान

@ अदनान: यह डेनिस है। पर्याप्त समय को देखते हुए वह 4 बाइट्स से कम में किसी भी कोड गोल्फ का समाधान पा सकता है।

— देसुवी

Answer 2

भूलभुलैया , 8 बाइट्स

ले लो, वह पायथ ...

?+
;,;!@

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

व्याख्या

सामान्य प्राइमर (Sp3000 से चुराया गया):

• भूलभुलैया 2 डी और स्टैक-आधारित है। ढेर के निचले हिस्से पर अनंत संख्या में शून्य होते हैं।
• जब निर्देश सूचक एक जंक्शन पर पहुंचता है, तो यह स्टैक के शीर्ष को यह निर्धारित करने के लिए जांचता है कि आगे कहां मोड़ना है। नकारात्मक छोड़ दिया गया है, शून्य आगे है और सकारात्मक सही है।

यहाँ वास्तव में जो काम आता है वह यह है कि लेबिरिंथ में दो अलग-अलग इनपुट कमांड होते हैं, ,और ?। पूर्व में STDIN, या -1EOF से एक एकल बाइट पढ़ता है । उत्तरार्द्ध STDIN से एक पूर्णांक पढ़ता है। यह सब कुछ लंघन करता है जो एक नंबर नहीं है और फिर यह पहली दशमलव संख्या को पाता है। यह 0ईओएफ पर लौटता है , इसलिए हम इसे ईओएफ के लिए मज़बूती से यहां जांचने के लिए उपयोग नहीं कर सकते हैं।

कार्यक्रम का मुख्य लूप यह कॉम्पैक्ट बिट है:

?+
;,

जब ?हम एक पूर्णांक (सभी अक्षरों को अनदेखा करते हैं) पढ़ते हैं, +तो हम इसे रनिंग टोटल में जोड़ते हैं (जो स्टैक बॉटम में निहित शून्य में से एक के रूप में शुरू होता है)। तब हम ,ईओएफ की जांच के लिए एक और चरित्र पढ़ते हैं । जब तक हम EOF में नहीं होते हैं, तब तक पढ़ा गया वर्ण एक अक्षर होगा, जिसमें एक सकारात्मक वर्ण कोड होता है, इसलिए IP सही (अपने दृष्टिकोण से; पश्चिम की ओर) मुड़ता है।;चरित्र को त्यागता है क्योंकि हमें इसकी आवश्यकता नहीं है और फिर हम फिर से लूप में प्रवेश करते हैं।

एक बार जब हम EOF पर कर रहे हैं, ,धक्का एक -1तो आईपी बदल जाता है छोड़ दिया (पूर्व) के बजाय। ;फिर से बताता है कि -1, !चल रहे कुल को एक पूर्णांक के रूप में प्रिंट करता है और @कार्यक्रम को समाप्त करता है।

Comments

बहुत बढ़िया सामान मार्टिन!

— एक सीमन्स

Answer 3

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

डेनिस की बदौलत बिना नंबर के इनपुट के साथ काम करना तय! कोड बिंदु 64 से ऊपर ASCII के एक सरणी के साथ अक्षरों के सरणी को बदलकर एक बाइट को भी बचाया। और फिर डेनिस द्वारा बचाए गए एक अन्य बाइट!

q_A,s-Ser~]1b

अक्षरों से रिक्त स्थान तक सरल लिप्यंतरण, फिर निष्कासन और योग। इसे ऑनलाइन आज़माएं ।

Answer 4

MATL , 8 बाइट्स

1Y4XXXUs

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

1Y4      % predefined literal: '\d+'
XX       % implicit input. Match regular expression. Returns a cell array of strings
         % representing numbers
XU       % convert each string to a double. Returns a numeric array
s        % sum of numeric array

Answer 5

रेटिना ,22 1 1

\d+
$0$*1
1

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

11 बाइट्स (!) ने मार्टिन को धन्यवाद दिया!

मूल रूप से सिर्फ एकात्मक के लिए दशमलव तो एस गणना 1।

Comments

$0अगर एक प्रतिस्थापन के साथ शुरू होता है, तो मुझे शायद निहित बनाना चाहिए $*। यह एक बहुत ही सामान्य पैटर्न है और इससे आप पायथ को हरा सकते हैं। ;)

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

@ मार्टिनबटनर जब आप इसमें होते हैं तो आप सही चरित्र को कुछ के लिए भी डिफ़ॉल्ट बना सकते हैं: O

— FryAmTheEggman

हम्म, एक बुरा विचार नहीं है। मैं इसके बारे में सोचूंगा।

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

Answer 6

जाप, 2 बाइट्स

Nx

इसे ऑनलाइन टेस्ट करें!

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

N    // Implicit: N = (parse input for numbers, "strings", and [arrays])
x    // Sum. Implicit output.

Comments

मुझे एक त्रुटि मिल रही है "Japt.stdout" को एक HTMLElement

— Downgoat

@Downgoat ऐसा कभी-कभार होता है; मुझे यकीन नहीं है कि क्यों। पृष्ठ को पुनः लोड करना इसे ठीक करना प्रतीत होता है।

— ETHproductions

Answer 7

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

s=>eval(s.replace(/\D+/g,'+')+'.0')

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

सबसे पहले, हम गैर-अंकों के प्रत्येक स्ट्रिंग को बदलते हैं "+"। मूल रूप से चार अलग-अलग तरीके हैं जो इसे समाप्त कर सकते हैं:

1. 1b23c456   => 1+23+456
2. a1b23c456  => +1+23+456
3. 1b23c456d  => 1+23+456+
4. a1b23c456d => +1+23+456+

मामलों 1 और 2 पर पहले से ही ध्यान दिया गया है। लेकिन हमें किसी तरह आखिरी को ठीक करने की आवश्यकता है +ताकि यह एक त्रुटि का कारण न बने। हम इसे निकाल सकते हैं .replace(/\+$,""), लेकिन यह बहुत महंगा है। हम 0अंत में एक संलग्न कर सकते हैं , लेकिन यह अंतिम संख्या को प्रभावित करेगा यदि स्ट्रिंग एक के साथ समाप्त नहीं होती है +। एक समझौता करना है .0, जो अपने आप में एक मान्य संख्या है और अन्य पूर्णांकों के मूल्य को प्रभावित नहीं करता है।

यहाँ कुछ अन्य मान दिए गए हैं जो काम करेंगे:

.0
-0
 +0
-""
-[]
0/10
0e-1
.1-.1

वैकल्पिक संस्करण, 35 बाइट्स भी

s=>s.replace(/\d+/g,d=>t+=+d,t=0)|t

एक अन्य वैकल्पिक संस्करण, 36 बाइट्स

s=>s.split(/\D/).map(d=>t+=+d,t=0)|t

Answer 8

पायथ, 12 11 10 बाइट्स

ssM:z"\D"3

    z        autoinitialized to input()
   : "\D"3   split on non-digits
 sM          convert all elements of resulting array to ints
s            sum

सौभाग्य से, s(इंट में कन्वर्ट) रिटर्न 0जब खाली स्ट्रिंग पर लागू होता है, तो मुझे इस तथ्य के बारे में चिंता करने की ज़रूरत नहीं है कि split("a1b", "\D+")रिटर्न ["", "1", ""]। इसी तरह, split("a", "\D+")रिटर्न ["", ""]।

यह भी मुझे व्यक्तिगत 1 + 0 + 0 + 0 + 0 + 2रूप से प्रत्येक गैर-अंक पर विभाजित करने की अनुमति देता है, क्योंकि यह एक ही चीज है 1 + 2।

धन्यवाद थॉमस Kwa एक बाइट के लिए!

Answer 9

गोल> <> , 4 बाइट्स

iEh+

इतना छोटा मुझे डमी पाठ की आवश्यकता है ...

Comments

शायद आपको अपने कोड को अपने अतिरिक्त स्थान के साथ समझाना चाहिए :)

— nneonneo

Answer 10

पर्ल 6 , 18 बाइट्स

{[+] .comb(/\d+/)}
{[+] .split(/\D/)}

उपयोग:

my &code = {[+] .comb(/\d+/)}

say code 'a'; # 0
say code '0'; # 0
say code '5'; # 5
say code '10'; # 10
say code 'a0A'; # 0
say code '1a1'; # 2
say code '11a1'; # 12
say code '4dasQWE65asAs5dAa5dWD'; # 79
say code 'a1wAD5qw45REs5Fw4eRQR33wqe4WE'; # 97

Answer 11

जेली, 6 बाइट्स

&-ṣ-ḌS

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

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

&-ṣ-ḌS  Main link. Input: L (string)

&-      Take the bitwise AND of L's characters and -1.
        This attempts to cast to int, so '0' & -1 -> 0 & -1 -> 0.
        On failure, it returns the integer argument (if any), so 'a' & -1 -> -1.
  ṣ-    Split the resulting list at occurrences of -1.
    Ḍ   Convert each chunk from decimal to integer. In particular, [] -> 0.
     S  Compute the sum of the results.

Answer 12

पर्ल, 21 + 1 = 22 बाइट्स

$_=eval join"+",/\d+/g

-pध्वज की आवश्यकता है :

$ perl -pe'$_=eval join"+",/\d+/g' <<< 'a1wAD5qw45REs5Fw4eRQR33wqe4WE'
97

Comments

क्या यह काम तब होता है जब कोई संख्या नहीं होती है? जैसे a?

— FryAmTheEggman

@FryAmTheEggman अच्छा सवाल है, मुझे लगता है कि यह एक संख्यात्मक संदर्भ में कुछ भी नहीं 0

— छपेगा

Answer 13

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

s->sum(parse,matchall(r"\d+","0"s))

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

हम matchallएक सरणी को रेगुलर एक्सप्रेशन के मिलान से युक्त करने के लिए उपयोग करते हैं \d+, जो स्ट्रिंग में केवल पूर्णांक हैं। हमें स्ट्रिंग के सामने 0 से निपटना होगा, अन्यथा "a", जैसे मामलों के लिए , हम एक खाली सरणी पर योग करेंगे, जो एक त्रुटि का कारण बनता है। हम फिर parseप्रत्येक स्ट्रिंग मैच पर लागू होते हैं , जो पूर्णांक में कनवर्ट करता है, और योग लेता है।

Comments

parseintयदि आप डिप्रेशन चेतावनी को बुरा नहीं मानते हैं तो आप बन सकते हैं ।

— डेनिस

@ डेनिस मैं हालांकि ।_।

— एलेक्स ए।

Answer 14

PHP, 64 बाइट्स

<?php preg_match_all("/\d+/",$argv[1],$a);echo array_sum($a[0]);

इसे के रूप में चलाएँ

php -f filterOutAndAddUp.php <test_case>

https://eval.in/517817

Comments

प्रोग्रामिंग पहेलियाँ और स्टैक एक्सचेंज में आपका स्वागत है। यह एक शानदार उत्तर (+1) है, हालांकि कोड स्पष्टीकरण और ब्रेकडाउन को जोड़कर इसे बेहतर बनाया जा सकता है। इसके अलावा, आप के <?बजाय उपयोग कर सकते हैं <?php?

— wizzwizz4

Answer 15

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

s=>eval((s.match(/\d+/g)||[0]).join`+`)

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

F=s=>document.body.innerHTML+='<pre>f(\''+s+'\') -> '+f(s)+'\n</pre>'

F('a')
F('5')
F('10')
F('1a1')
F('11a1')
F('4dasQWE65asAs5dAa5dWD')
F('a1wAD5qw45REs5Fw4eRQR33wqe4WE')

Answer 16

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

Total@ToExpression@StringCases[#,DigitCharacter..]&

क्रियात्मक माथेमैटिका बिल्डिंस के गलत छोर को पकड़ना। 1 @ दाविद की मदद से बाइट करें

Comments

DigitCharacter ..1 बाइट

— बचाएगी

DigitCharacterलिखित रूप में काम नहीं करता क्योंकि यह सभी अंकों को हटा देता है जबकि हम सभी अक्षरों को हटाना चाहते हैं ...

— A Simmons

तुम सही हो। मैं सोच रहा थाTotal@ ToExpression@StringCases[#, DigitCharacter ..] &

— डेविड एफसी

समझा! हाँ, यह परिवर्तन एक बाइट बचाता है।

— एक सीमन्स

Answer 17

आर, 46 43 बाइट्स

sum(strtoi(strsplit(scan(,''),'\\D')[[1]]))

व्याख्या

                    scan(,'')                  # Take the input string
           strsplit(         ,'\\D')           # Returns list of all numeric parts of the string
                                    [[1]]      # Unlists to character vector
    strtoi(                              )     # Converts to numeric vector
sum(                                      )    # Sums the numbers

नमूना चला

> sum(strtoi(strsplit(scan(,''),'\\D')[[1]]))
1: a1wAD5qw45REs5Fw4eRQR33wqe4WE
2: 
Read 1 item
[1] 97

संपादित करें: बदला [^0-9]साथ \\D।

Comments

प्रोग्रामिंग और कोड गोल्फ में आपका स्वागत है। यह एक महान पहला जवाब है; हालाँकि यह एक कोड स्पष्टीकरण और ब्रेकडाउन जोड़कर बेहतर होगा, इसलिए हम जानते हैं कि यह कैसे काम करता है।

— wizzwizz4

Answer 18

पॉवरशेल, 28 26 बाइट्स

$args-replace"\D",'+0'|iex

इनपुट लेता है और $argsफिर -replaceअक्षरों को स्वैप करने के लिए एक रेगेक्स करता है +0, फिर पाइप को iex(कम Invoke-Expressionऔर इसके समान eval)।

PS C:\Tools\Scripts\golfing> .\filter-out-and-add-up.ps1 'a1wAD5qw45REs5Fw4eRQR33wqe4WE'
97

---

वैकल्पिक रूप से

यदि आप कुछ बाहरी उत्पादन के साथ ठीक हैं, तो आप निम्न कार्य कर सकते हैं, वह भी 28 26 बाइट्स पर:

$args-split"\D"|measure -s

यह इनपुट स्ट्रिंग को लेगा $argsऔर -splitइसे गैर-संख्याओं (प्रक्रिया में उन्हें हटाकर) पर एक सरणी-ऑफ-स्ट्रिंग्स में ले जाएगा। उदाहरण के लिए, में 1a2b33बदल जाएगा ['1','2','33']। हम पाइप करते हैंMeasure-Object-Sum पैरामीटर के साथ करते हैं। आउटपुट नीचे की तरह होगा:

PS C:\Tools\Scripts\golfing> .\filter-out-and-add-up.ps1 'a1wAD5qw45REs5Fw4eRQR33wqe4WE'

Count    : 21
Average  : 
Sum      : 97
Maximum  : 
Minimum  : 
Property : 

_{संपादित करें - durr, [ ]regex में आवश्यकता नहीं है क्योंकि मैं अब संभावित मैचों की सूची निर्दिष्ट नहीं कर रहा हूं ...}

Answer 19

गामा, 39 वर्ण

<D>=@set{s;@add{${s;};$0}}
?=
\Z=${s;0}

नमूना रन:

bash-4.3$ gema '<D>=@set{s;@add{${s;};$0}};?=;\Z=${s;0}' <<< 'a1wAD5qw45REs5Fw4eRQR33wqe4WE'

Answer 20

गंभीरता से, 13 बाइट्स

,ú;û+@s`≈`MΣl

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

स्पष्टीकरण:

,ú;û+@s`≈`MΣl
,              push input
 ú;û+          push "abc...zABC...Z" (uppercase and lowercase English letters)
     @s        split on letters
       `≈`M    convert to ints
           Σ   sum
            l  length (does nothing to an integer, pushes 0 if an empty list is left, in the case where the string is all letters)

Comments

@ अदनान अच्छी पकड़ - यह खाली सूची के साथ आउटपुट करता है a। एक-बाइट फिक्स होना चाहिए।

— मेगो

Answer 21

जावा, 70 बाइट्स

s->{int n=0;for(String i:s.split("\\D+"))n+=Long.valueOf(i);return n;}

Answer 22

टीआई-बेसिक, 106 बाइट्स

TI-83/84 कैलकुलेटर पर काम करता है!

Input Str1
"{0,→Str2
Str1+"N0→Str1
For(I,1,length(Ans
sub(Str1,I,1
If inString("0123456789",Ans
Then
Str2+Ans→Str2
Else
If ","≠sub(Str2,length(Str2),1
Str2+","→Str2
End
End
sum(expr(Ans

Answer 23

क्लोजर / क्लोजुरस्क्रिप्ट, 35 बाइट्स

#(apply +(map int(re-seq #"\d+"%)))

Answer 24

आर, 50 बाइट्स

gsubfnस्थापित करने की आवश्यकता है

sum(gsubfn::strapply(scan(,''),'\\d+',strtoi)[[1]])

strtoiन्यूमेरिक के लिए जबरदस्ती का उपयोग करता है

Answer 25

रूबी 45 बाइट्स

$*[0].split(/[a-z]/i).map(&:to_i).inject 0,:+

(काम पर पहला प्रयास, इस पर फिर से विचार करेंगे)

Answer 26

POSIX sh + tr + dc, 27 25 बाइट्स

dc -e "0d`tr -sc 0-9 +`p"

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

Answer 27

लूआ, 51 बाइट्स

एक बार के लिए बहुत कम! जावा से भी छोटा! काम करने के लिए इनपुट एक कमांड-लाइन तर्क होना चाहिए।

a=0 arg[1]:gsub("%d+",function(c)a=a+c end)print(a)

Ungolfed

a=0                 -- Initialize the sum at 0
arg[1]:gsub("%d+",  -- capture each group of digits in the string
  function(c)       -- and apply an anonymous function to each of them
  a=a+c             -- sums a with the latest group captured
end)               
print(a)            -- output a

Answer 28

बैश + जीएनयू उपयोगिताओं, 29

grep -Eo [0-9]+|paste -sd+|bc

---

यदि यह बिना संख्या वाले इनपुट का समर्थन करना आवश्यक है (उदाहरण के लिए) a ) के , तो हम यह कर सकते हैं:

बैश + जीएनयू उपयोगिताओं, 38

1 बाइट @TobySpeight की बदौलत बचा।

(grep -Eo [0-9]+;echo 0)|paste -sd+|bc

Comments

यह इनपुट के लिए कुछ भी प्रिंट नहीं करता है a। हम वर्तमान में चर्चा कर रहे हैं कि यह मान्य है या नहीं।

— डेनिस

@Dennis। ठीक है। मैंने दोनों घटनाओं को कवर करने के लिए एक और संस्करण जोड़ा।

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

आप बिना किसी नुकसान के हमेशा शून्य जोड़ने के ;बजाय उपयोग कर सकते हैं ||।

— टॉबी स्पाइट

@TobySpeight हाँ, अच्छा है - धन्यवाद!

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

Answer 29

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

मैं सिर्फ मजे के लिए पायथन जवाब दे रहा हूं।

import re
j=0
for i in map(int,re.findall('\d+',input())):j+=i
print j

बहुत सरल और इनपुट में सभी नंबरों को खोजने के लिए रेगेक्स का उपयोग करता है। इसे ऑनलाइन आज़माएं!

Comments

इस संदर्भ में आपको raw_inputpython3 का उपयोग या स्विच करना होगा। एक छोटा संस्करण (py3, 56 बाइट्स) import re;print(sum(map(int,re.findall('\d+',input())))):।

— डिका

Answer 30

Oracle SQL 11.2, 105 बाइट्स

SELECT NVL(SUM(TO_NUMBER(COLUMN_VALUE)),0)FROM XMLTABLE(('"'||regexp_replace(:1,'[a-zA-Z]','","')||'"'));

रेगीक्स अल्फा वर्णों को ',' में बदल देता है

XMLTABLE स्ट्रिंग में विभाजक के रूप में ',' का उपयोग करके प्रति आइटम एक पंक्ति बनाता है।

परिणाम प्राप्त करने के लिए पंक्तियों को SUM करें।

NVL को एक अंक के साथ स्ट्रिंग के लिए खाते की आवश्यकता है।