Tâche

La tâche est très simple. Étant donné une chaîne non vide contenant des nombres , des lettres majuscules et minuscules , affichez la somme des nombres restants. Par exemple:

a1wAD5qw45REs5Fw4eRQR33wqe4WE

Filtrer toutes les lettres entraînerait:

 1   5  45   5  4    33   4

La somme de ces nombres est 1 + 5 + 45 + 5 + 4 + 33 + 4 = 97. Ainsi, la sortie serait 97.

Cas de test

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

C'est du code-golf , donc la soumission avec le moins d'octets gagne!

GS2, 2 octets

Wd

Essayez-le en ligne!

Comment ça fonctionne

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

Labyrinthe , 8 octets

Prenez ça, Pyth ...

?+
;,;!@

Essayez-le en ligne!

Explication

L'amorce habituelle (volée au Sp3000):

• Labyrinth est 2D et basé sur la pile. Les piles ont un nombre infini de zéros en bas.
• Lorsque le pointeur d'instruction atteint une jonction, il vérifie le haut de la pile pour déterminer où tourner ensuite. Le négatif est à gauche, le zéro est en avant et le positif est à droite.

Ce qui est vraiment pratique ici, c'est que Labyrinth a deux commandes d'entrée différentes, ,et ?. Le premier lit un seul octet de STDIN, ou -1à EOF. Ce dernier lit un entier depuis STDIN. Il fait ainsi sauter tout ce qui ignore n'est pas un nombre, puis lit le premier nombre décimal qu'il trouve. Celui-ci revient 0à EOF, nous ne pouvons donc pas l'utiliser pour vérifier de manière fiable EOF ici.

La boucle principale du programme est ce bit compact:

?+
;,

Avec ?nous lisons un entier (ignorant toutes les lettres), avec +nous l'ajoutons au total cumulé (qui commence comme l'un des zéros implicites en bas de la pile). Ensuite, nous lisons un autre personnage avec, pour vérifier EOF. Tant que nous ne sommes pas à l'EOF, le caractère lu sera une lettre qui a un code de caractère positif, donc l'IP tourne à droite (de son point de vue, c'est-à-dire vers l'ouest). ;jette le personnage parce que nous n'en avons pas besoin, puis nous entrons à nouveau dans la boucle.

Une fois que nous sommes à l'EOF, ,pousse un -1pour que l'IP tourne à gauche (est) à la place. ;rejette à nouveau cela -1, !imprime le total cumulé sous forme d'entier et @termine le programme.

CJam, 13 octets

Correction de travailler avec une entrée sans chiffres grâce à Dennis! Également enregistré un octet en remplaçant le tableau de lettres par un tableau ASCII au-dessus du point de code 64. Et puis un autre octet enregistré par Dennis!

q_A,s-Ser~]1b

Translittération simple des lettres aux espaces, puis eval et sum. Essayez-le en ligne .

MATL , 8 octets

1Y4XXXUs

Essayez-le en ligne!

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

Rétine ,22 11

\d+
$0$*1
1

Essayez-le en ligne!

11 octets (!) Économisés grâce à Martin!

Fondamentalement, juste décimal à unaire, puis compter le 1s.

Japt, 2 octets

Nx

Testez-le en ligne!

Comment ça fonctionne

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

JavaScript ES6, 35 octets

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

Comment ça fonctionne

Tout d'abord, nous remplaçons chaque chaîne de non-chiffres par "+". Il existe essentiellement quatre façons différentes pour que cela se termine:

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

Les cas 1 et 2 sont déjà pris en charge. Mais nous devons en quelque sorte corriger le dernier +afin qu'il ne provoque pas d'erreur. Nous pourrions l'enlever avec .replace(/\+$,""), mais c'est trop cher. Nous pourrions ajouter un 0à la fin, mais cela affecterait le dernier nombre si la chaîne ne se termine pas par un +. Un compromis est d’ajouter.0 , qui est à la fois un nombre valide et n'affecte pas la valeur des autres entiers.

Voici quelques autres valeurs qui pourraient également fonctionner:

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

Version alternative, également 35 octets

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

Une autre version alternative, 36 octets

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

Pyth, 12 11 10 octets

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

Heureusement, s(convertir en int) retourne 0lorsqu'il est appliqué à la chaîne vide, donc je n'ai pas à me soucier du fait quesplit("a1b", "\D+") retourne ["", "1", ""]. De même, split("a", "\D+")renvoie["", ""] .

Cela me permet même de séparer chaque non-chiffre individuellement, car 1 + 0 + 0 + 0 + 0 + 2 c'est la même chose que 1 + 2.

Merci à Thomas Kwa pour un octet!

Gol> <> , 4 octets

iEh+

Si court j'ai besoin d'un texte factice ...

Perl 6, 18 bytes

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

Usage:

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

Jelly, 6 bytes

&-ṣ-ḌS

Try it online!

How it works

&-ṣ-Ḍ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.

Perl, 21 + 1 = 22 bytes

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

Requires the -p flag:

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

Julia, 35 bytes

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

This is an anonymous function that accepts a string and returns an integer. To call it, assign it to a variable.

We use matchall to get an array consisting of matches of the regular expression \d+, which are just the integers in the string. We have to tack on a 0 to the front of the string, otherwise for cases like "a", we'd be summing over an empty array, which causes an error. We then apply parse to each string match, which converts to integers, and take the sum.

PHP, 64 bytes

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

Run it as

php -f filterOutAndAddUp.php <test_case>

https://eval.in/517817

Javascript, 32 39 bytes

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')

Mathematica, 51 bytes

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

Catching the wrong end of the verbose Mathematica builtins. 1 Byte off with the help of @DavidC

R, 46 43 bytes

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

Explanation

                    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

Sample run

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

Edit: Replaced [^0-9] with \\D.

PowerShell, 28 26 bytes

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

Takes input $args then does a regex -replace to swap the letters with +0, then pipes that to iex (short for Invoke-Expression and similar to eval).

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

Alternatively

If you're OK with some extraneous output, you can do the following, also at 28 26 bytes:

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

This will take the input string $args and -split it into an array-of-strings on the non-numbers (removing them in the process). For example, 1a2b33 would turn into ['1','2','33']. We pipe that to Measure-Object with the -Sum parameter. Output would be like the below:

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

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

_{Edit -- durr, don't need the [ ] in the regex since I'm no longer specifying a list of possible matches ...}

Gema, 39 characters

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

Sample run:

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

Seriously, 13 bytes

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

Try it online!

Explanation:

,ú;û+@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)

Java, 70 bytes

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

TI-Basic, 106 bytes

Works on TI-83/84 calculators!

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

Clojure/ClojureScript, 35 bytes

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

R, 50 bytes

Requires having gsubfn installed

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

Uses strtoi to coerce to numeric

Ruby 45 bytes

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

(First attempt at work, will revisit this)

POSIX sh + tr + dc, 27 25 bytes

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

Converts any run of non-digits (including the terminating newline) to + operator, pushes two zeros onto the stack (in case input begins with non-digit), adds them all and prints the result. There may be an extra zero remaining at bottom of stack, but we don't care about that.

Lua, 51 Bytes

Pretty short for once! Even shorter than Java! The input must be a command-line argument for it to work.

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

Bash + GNU utilities, 29

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

If it is required to support input with no numbers (e.g. a), then we can do this:

Bash + GNU utilities, 38

1 byte saved thanks to @TobySpeight.

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

Python 2, 70 bytes

I am putting a Python answer just for fun.

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

Very simple and uses regex to find all the numbers in the input. Try it online!

Oracle SQL 11.2, 105 bytes

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

The regex convert alpha characters to ','

XMLTABLE create one row per item in the string using ',' as the separator.

SUM the rows to get the result.

NVL is needed to account for a string with no digit.