Ingresso

Una stringa.

Produzione

La somma di tutti i numeri interi nella riga.

vincoli

1≤Lunghezza della linea≤500

Caso di prova campione

Ingresso

the 5is 108 seCONd4 a

Produzione

117

Spiegazione

La somma è: 5 + 108 + 4 = 117

Javascript, 34 32 byte

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

Abbina tutte le cifre e uniscile +trasformandole in 5 + 108 + 4, valutando il risultato.
Funziona solo su numeri interi positivi.

Salvato 2 byte grazie ad Arnauld

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>

Perl 6 , 14 byte

{sum m:g/\d+/}

Provalo online!

Blocco di codice anonimo che restituisce la somma di tutte le serie di cifre

05AB1E , 11 6 byte

þмS¡þO

Provalo online.

Spiegazione:

þм       # 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

R , 64 48 45 byte

Dopo aver visto la voce PowerShell sono stato in grado di giocare a golf ulteriormente.

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

Provalo online!

APL (Dyalog Unicode) , 11 byte

Funzione di preimpostazione tacita anonima

+/#⍎¨∊∘⎕D⊆⊢

Provalo online!

⊢ l'argomento

⊆ partizionato (le serie di True diventano pezzi, le serie di False sono separatori) di

∊ l'adesione
∘ del
⎕D l'insieme delle cifre

#⍎¨ valutare ciascuno nello spazio dei nomi di root

+/ somma

Retina 0.8.2 , 8 byte

\d+
$*
1

Provalo online!

• La prima riga corrisponde a tutti i numeri
• La seconda riga li sostituisce con 1s, ripetendo il numero di volte
• L'ultima riga è una corrispondenza e conta il numero totale di 1s nella stringa

PowerShell , 29 byte

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

Provalo online!

Carbone , 5 byte

ＩΣ⁺ψＳ

Provalo online! Il collegamento è alla versione dettagliata del codice. Spiegazione: L' Sumoperatore Charcoal estrae automaticamente i numeri da una stringa, tuttavia se la stringa non contiene caratteri non numerici, prende invece la somma digitale, quindi concateno un byte null per evitarlo. Il risultato viene quindi riportato alla stringa per l'output implicito.

Haskell , 50 byte

sum.map read.words.map f
f x|'/'<x,x<':'=x
f _=' '

Provalo online!

Probabilmente c'è un modo migliore, ma questo è il più ovvio.

Zsh , 21 byte

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

Provalo online!

  ${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

Sfortunatamente, bash si lamenta perché interpreta 0108come ottale. Zsh no (a meno che setopt octalzeroes)

Bash, 43 byte

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

Sostituisce ogni non-numero con uno spazio e quindi li somma insieme.

-5 byte grazie a GammaFunction

Python 3 , 63 59 56 byte

Perchè no. Risposta regex obbligatoria. Probabilmente potrebbe staccarsi da 6 usando Python 2, ma comunque. Non si applica più dal momento che sto usando un approccio eval invece di usare map.

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

Spiegazione:

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

Provalo online!

Java 10, 66 byte

Questo è un lambda da Stringa int.

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

Gli interi negativi non sono supportati. Presumibilmente va bene.

Provalo online

Ringraziamenti

• -3 byte grazie a Embodiment of Ignorance

Rubino, 32 27 caratteri

->s{eval s.scan(/\d+/)*?+}

Ringraziamenti

• -5 byte grazie a Conor O 'Brien

Cubix , 17 byte

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

Provalo online!

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

Guardalo correre

Uno abbastanza semplice. Iin cubix prenderà il primo intero nell'input e lo spingerà nello stack. Questo ha l'effetto di saltare tutti i personaggi. Il resto si occupa dell'ulteriore e rileva la fine dell'input.

• I! Immettere un numero intero e testarlo per 0
• s+q;;Se non zero, scambiare TOS (forze e 0 iniziale) e aggiungere. Spingere il risultato sul fondo della pila e pulire la parte superiore. Torna all'inizio.
• /i? Se pari a zero, reindirizza ed esegui un input di caratteri per verificare
• |?;/Se il positivo (personaggio) gira a destra in un riflesso, questo lo spinge indietro attraverso la pedina ?e gira a destra sul pop dallo stack, lasciando 0 su TOS. L'IP viene quindi reindirizzato nuovamente nel loop principale.
• I>p.O@ se negativo (fine dell'input) gira a sinistra, fai l'input intero, porta in cima lo stack, emetti e ferma.

PHP ,40 39 byte

<?=array_sum(preg_split('(\D)',$argn));

Provalo online!

Esegui con php -nFinput proviene da STDIN. Esempio:

$ echo the 5is 108 seCONd4 a | php -nF sumint.php    
117

Haskell , 43 byte

f s|[(n,r)]<-reads s=n+f r|h:t<-s=f t|1>0=0

Provalo online!

Fa uso di reads.

Avanti , 13 byte

Questo funziona perché Iscansiona semplicemente il flusso di input per il token successivo che assomiglia a un numero, ignorando qualsiasi altra cosa.

~Ilj~#
 >K+O@

Provalo online!

QuadR , 9 byte

+/⍎⍵
\D
 

Provalo online!

+/ somma di

⍎ valutazione come APL di

⍵ il risultato di

\D sostituendo ogni non cifra con

 Uno spazio

Japt -x , 5 byte

f/\d+

Provalo online!

Attache , 23 byte

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

Provalo online!

Una risposta più interessante, ma indiretta, (37 byte): {Sum!Reap[ReplaceF[_,/"\\d+",Sow@N]]}

Spiegazione

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

Questo ha la forma:

f##g=>h&x

che, quando espanso e tra parentesi, diventa:

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

##compone due funzioni insieme, =>crea una funzione mappando la funzione sinistra sul risultato della funzione destra e &associa un argomento a un lato di una funzione. Per input _, questo equivale a:

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

Innanzitutto, quindi, eseguiamo i MatchAllcaratteri delle cifre ( \\d+). Dopo, convertiamo ogni corsa in un intero reale usando la Nfunzione. Infine, prendiamo la somma di questi numeri usando Sum.

APL (NARS), caratteri 13, byte 26

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

test:

  f←{+/⍎¨⍵⊂⍨⍵∊⎕D}
  f 'the 5is 108 seCONd4 a'
117

C # (compilatore interattivo Visual C #), 117 111 byte

a=>System.Text.RegularExpressions.Regex.Replace(a,@"\D+"," ").Split(' ').Select(x=>x==""?0:int.Parse(x)).Sum();

Provalo online.

Perl 5 -p , 17 byte

s/\d+/$\+=$&/eg}{

Provalo online!

Japt v2.0a0 -x, 3 byte

Un altro test drive per il mio interprete (molto WIP).

q\D

Provalo

q\D     :Implicit input of string
q       :Split on
 \D     :  Non-digit characters (/[^0-9]/)
        :Implicitly reduce by addition and output

Java 8, 53 130 byte

105 byte + 25 byte per l'importazione regex

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

Provalo online!
Spiegazione

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
   }

SNOBOL4 (CSNOBOL4) , 81 byte

	S =INPUT
D	S SPAN('0123456789') . N REM . S	:F(O)
	O =O + N	:(D)
O	OUTPUT =O
END

Provalo online!

Rapido, 109 byte

func s(a:String){var d=0,t=0;a.forEach{(c) in if let e=Int(String(c)){d=d*10+e}else{t+=d;d=0}};t+=d;print(t)}

Provalo online!

Pip , 6 byte

$+a@XI

Tratta -123come un numero intero negativo. Provalo online!

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

Se i trattini devono essere ignorati anziché trattati come segni meno, allora il seguente funziona per 7 byte :

$+a@+XD

XDè una variabile preimpostata per `\d`; +XDaggiunge il +modificatore regex ad esso, facendolo corrispondere a 1 o più cifre.

Java (JDK) , 98 94 93 byte

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

Provalo online!

-4 bytesusando Long::newinvece di Long::valueOf.
-1 byteaccorciando la regex - se stiamo già rimuovendo stringhe vuote in seguito, fare degli extra quando si divide va bene.

spiegato

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.