Compito

Il compito è molto semplice. Data una stringa non vuota contenente numeri , lettere maiuscole e minuscole , genera la somma dei numeri rimanenti. Per esempio:

a1wAD5qw45REs5Fw4eRQR33wqe4WE

Filtrare tutte le lettere si tradurrebbe in:

 1   5  45   5  4    33   4

La somma di questi numeri è 1 + 5 + 45 + 5 + 4 + 33 + 4 = 97. Quindi l'output sarebbe 97.

Casi test

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

Questo è code-golf , quindi vince l'invio con il minor numero di byte!

GS2, 2 byte

Wd

Provalo online!

Come funziona

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

Labirinto , 8 byte

Prendi questo, Pyth ...

?+
;,;!@

Provalo online!

Spiegazione

Il solito primer (rubato da Sp3000):

• Labyrinth è basato su 2D e stack. Le pile hanno un numero infinito di zeri sul fondo.
• Quando il puntatore dell'istruzione raggiunge una giunzione, controlla la parte superiore dello stack per determinare dove girare successivamente. Il negativo è a sinistra, lo zero è in avanti e il positivo è a destra.

Ciò che è davvero utile qui è che Labyrinth ha due diversi comandi di input ,e ?. Il primo legge un singolo byte da STDIN o -1su EOF. Quest'ultimo legge un numero intero da STDIN. Lo fa saltando tutto ciò che non lo è un numero e quindi legge il primo numero decimale che trova. Questo ritorna 0su EOF, quindi non possiamo usarlo per verificare l'affidabilità di EOF qui.

Il ciclo principale del programma è questo bit compatto:

?+
;,

Con ?leggiamo un numero intero (ignorando tutte le lettere), con +lo aggiungiamo al totale parziale (che inizia come uno degli zero impliciti nella parte inferiore dello stack). Quindi leggiamo un altro personaggio con ,per verificare la presenza di EOF. Finché non siamo in EOF, il carattere letto sarà una lettera che ha un codice carattere positivo, quindi l'IP gira a destra (dal suo punto di vista; cioè ovest). ;scarta il personaggio perché non ne abbiamo bisogno e poi entriamo di nuovo nel loop.

Una volta che siamo in EOF, ,spinge a in -1modo che l'IP giri invece a sinistra (est). ;lo scarta di nuovo -1, !stampa il totale parziale come intero e @termina il programma.

CJam, 13 byte

Risolto per funzionare con input senza numeri grazie a Dennis! Anche salvato un byte sostituendo l'array di lettere con un array di ASCII sopra il punto di codice 64. E poi un altro byte salvato da Dennis!

q_A,s-Ser~]1b

Traslitterazione semplice dalle lettere agli spazi, quindi valutazione e somma. Provalo online .

MATL , 8 byte

1Y4XXXUs

Provalo online!

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

Retina ,22 11

\d+
$0$*1
1

Provalo online!

11 byte (!) Salvati grazie a Martin!

Fondamentalmente solo da decimale a unario, quindi conta la 1s.

Japt, 2 byte

Nx

Provalo online!

Come funziona

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

JavaScript ES6, 35 byte

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

Come funziona

Innanzitutto, sostituiamo ogni stringa di non cifre con "+". Esistono fondamentalmente quattro modi diversi in cui questo potrebbe finire:

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

I casi 1 e 2 sono già stati risolti. Ma in qualche modo dobbiamo correggere l'ultimo in +modo che non causi un errore. Potremmo rimuoverlo con .replace(/\+$,""), ma è troppo costoso. Potremmo aggiungere 0a alla fine, ma ciò influenzerebbe l'ultimo numero se la stringa non termina con a +. Un compromesso è quello di aggiungere .0, che è un numero valido da solo e non influisce sul valore di altri numeri interi.

Ecco alcuni altri valori che potrebbero funzionare anche:

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

Versione alternativa, anche 35 byte

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

Un'altra versione alternativa, 36 byte

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

Pyth, 12 11 10 byte

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

Fortunatamente, s(convertito in int) ritorna 0quando viene applicato alla stringa vuota, quindi non devo preoccuparmi del fatto che split("a1b", "\D+")ritorni ["", "1", ""]. Allo stesso modo, split("a", "\D+")ritorna ["", ""].

Questo mi permette persino di dividere ogni singola cifra non individualmente, poiché 1 + 0 + 0 + 0 + 0 + 2è la stessa cosa di 1 + 2.

Grazie a Thomas Kwa per un byte!

Gol> <> , 4 byte

iEh+

Così breve ho bisogno di un testo fittizio ...

Perl 6 , 18 byte

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

Uso:

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

Gelatina, 6 byte

&-ṣ-ḌS

Provalo online!

Come funziona

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

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

Richiede la -pbandiera:

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

Julia, 35 byte

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

Questa è una funzione anonima che accetta una stringa e restituisce un numero intero. Per chiamarlo, assegnarlo a una variabile.

Usiamo matchallper ottenere una matrice composta da corrispondenze dell'espressione regolare \d+, che sono solo i numeri interi nella stringa. Dobbiamo virare su uno 0 all'inizio della stringa, altrimenti per casi del genere "a", dovremmo sommare un array vuoto, che causa un errore. Quindi applichiamo parseogni corrispondenza di stringa, che viene convertita in numeri interi, e prendiamo la somma.

PHP, 64 byte

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

Eseguilo come

php -f filterOutAndAddUp.php <test_case>

https://eval.in/517817

Javascript, 32 39 byte

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 byte

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

Catturare l'estremità sbagliata dei builtins di Mathematica verbose. 1 Byte off con l'aiuto di @DavidC

R, 46 43 byte

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

Spiegazione

                    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

Esecuzione del campione

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

Modifica: sostituito [^0-9]con \\D.

PowerShell, 28 26 byte

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

Prende input, $argsquindi esegue una regex -replacecon cui scambiare le lettere +0, quindi reindirizza a iex(abbreviazione di Invoke-Expressione simile a eval).

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

In alternativa

Se stai bene con qualche output estraneo, puoi fare quanto segue, anche a 28 26 byte:

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

Questo prenderà la stringa di input $argse la inserirà -splitin una matrice di stringhe sui non numeri (rimuovendoli nel processo). Ad esempio, 1a2b33si trasformerebbe in ['1','2','33']. Lo convogliamo Measure-Objectcon il -Sumparametro. L'output sarebbe simile al seguente:

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

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

_{Modifica - durr, non è necessario [ ]nel regex poiché non sto più specificando un elenco di possibili corrispondenze ...}

Gema, 39 personaggi

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

Esecuzione di esempio:

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.