Eingang

Ein Faden.

Ausgabe

Die Summe aller ganzen Zahlen in der Zeile.

Einschränkungen

1 ≤ Leitungslänge ≤ 500

Beispieltestfall

Eingang

the 5is 108 seCONd4 a

Ausgabe

117

Erläuterung

Die Summe ist: 5 + 108 + 4 = 117

Javascript, 34 32 Bytes

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

Ordnen Sie alle Ziffern zu und verbinden Sie sie, indem Sie +sie in 5 + 108 + 4 umwandeln. Bewerten Sie das Ergebnis.
Funktioniert nur mit positiven ganzen Zahlen.

2 Bytes dank Arnauld gespeichert

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 Bytes

{sum m:g/\d+/}

Probieren Sie es online aus!

Anonymer Codeblock, der die Summe aller Ziffernreihen zurückgibt

05AB1E , 11 6 Bytes

þмS¡þO

Probieren Sie es online aus.

Erläuterung:

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

Nachdem ich den PowerShell-Eintrag gesehen hatte, konnte ich dies weiter spielen.

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

Probieren Sie es online aus!

APL (Dyalog Unicode) , 11 Bytes

Anonyme stillschweigende Präfektfunktion

+/#⍎¨∊∘⎕D⊆⊢

Probieren Sie es online aus!

⊢ das Argument

⊆ partitioniert (Läufe von True werden zu Stücken, Läufe von False sind Trennzeichen) durch

∊ Mitgliedschaft
∘ von
⎕D dem Satz von Ziffern

#⍎¨ Bewerten Sie jeden im Root-Namespace

+/ Summe

Retina 0,8,2 , 8 Bytes

\d+
$*
1

Probieren Sie es online aus!

• Die erste Zeile entspricht allen Zahlen
• Die zweite Zeile ersetzt diese durch 1s und wird so oft wiederholt
• Die letzte Zeile ist eine Übereinstimmung und zählt die Gesamtzahl der Einsen in der Zeichenfolge

PowerShell , 29 Byte

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

Probieren Sie es online aus!

Holzkohle , 5 Bytes

ＩΣ⁺ψＳ

Probieren Sie es online aus! Der Link führt zur ausführlichen Version des Codes. Erläuterung: Der SumOperator von Charcoal extrahiert automatisch Zahlen aus einer Zeichenfolge. Wenn die Zeichenfolge jedoch keine nichtstelligen Zeichen enthält, wird stattdessen die digitale Summe verwendet. Daher verkette ich ein Null-Byte, um dies zu vermeiden. Das Ergebnis wird dann für die implizite Ausgabe in einen String zurückgesetzt.

Haskell , 50 Bytes

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

Probieren Sie es online aus!

Es gibt wahrscheinlich einen besseren Weg, aber dies ist der offensichtlichste.

Zsh , 21 Bytes

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

Probieren Sie es online aus!

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

Leider beschwert sich Bash, weil es 0108als oktal interpretiert wird . Zsh nicht (außer setopt octalzeroes)

Bash, 43 Bytes

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

Ersetzt jede Nicht-Zahl durch ein Leerzeichen und summiert sie dann zusammen.

-5 Bytes dank GammaFunction

Python 3 , 63 59 56 Bytes

Warum nicht. Obligatorische Regex-Antwort. Könnte wahrscheinlich 6 mit Python 2 andocken, aber was auch immer. Gilt nicht mehr, da ich einen Eval-Ansatz anstelle einer Karte verwende.

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

Erläuterung:

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

Probieren Sie es online aus!

Java 10, 66 Bytes

Dies ist ein Lambda von Stringbis int.

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

Negative Ganzzahlen werden nicht unterstützt. Vermutlich ist das okay.

Probieren Sie es online aus

Danksagung

• -3 Bytes dank Verkörperung der Ignoranz

Ruby, 32 27 Zeichen

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

Danksagung

• -5 Bytes dank Conor O 'Brien

Cubix , 17 Bytes

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

Probieren Sie es online aus!

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

Schau es dir an

Eine ziemlich einfache. IIn Cubix wird die erste Ganzzahl in der Eingabe genommen und auf den Stapel verschoben. Dies hat den Effekt, dass alle Zeichen übersprungen werden. Der Rest befasst sich mit dem zusätzlichen und Erkennen des Endes der Eingabe.

• I! Geben Sie eine Ganzzahl ein und testen Sie sie auf 0
• s+q;;Wenn nicht Null, tauschen Sie TOS (Kräfte und anfängliche 0) und addieren Sie. Schieben Sie das Ergebnis auf die Unterseite des Stapels und reinigen Sie die Oberseite. Kehren Sie zum Anfang zurück.
• /i? Wenn Null, leiten Sie um und führen Sie eine Zeicheneingabe durch, um dies zu überprüfen
• |?;/Wenn sich das Positive (Zeichen) nach rechts in ein Reflect ?verwandelt, wird es durch den Checker zurückgeschoben und biegt vom Stack nach rechts auf den Pop ab, wobei 0 auf TOS verbleibt. Die IP wird dann zurück in die Hauptschleife umgeleitet.
• I>p.O@ Wenn negativ (Ende der Eingabe), biegen Sie links ab, geben Sie eine ganzzahlige Eingabe ein, bringen Sie die Unterseite des Stapels nach oben, geben Sie aus und halten Sie an.

PHP ,40 39 Bytes

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

Probieren Sie es online aus!

Mit php -nFEingabe ausführen ist von STDIN. Beispiel:

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

Haskell , 43 Bytes

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

Probieren Sie es online aus!

Nutzt aus reads.

Voraus , 13 Bytes

Dies funktioniert, weil Ider Eingabestream einfach nach dem nächsten Token durchsucht wird, das wie eine Zahl aussieht, und alles andere ignoriert.

~Ilj~#
 >K+O@

Probieren Sie es online aus!

QuadR , 9 Bytes

+/⍎⍵
\D
 

Probieren Sie es online aus!

+/ die Summe von

⍎ Auswertung als APL von

⍵ das Ergebnis von

\D Ersetzen jeder Nicht-Ziffer durch

 ein Leerzeichen

Japt -x , 5 Bytes

f/\d+

Probieren Sie es online aus!

Attache , 23 Bytes

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

Probieren Sie es online aus!

Eine interessantere, aber indirekte Antwort (37 Bytes): {Sum!Reap[ReplaceF[_,/"\\d+",Sow@N]]}

Erläuterung

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

Dies hat die Form:

f##g=>h&x

was, wenn es erweitert und in Klammern gesetzt wird, wird:

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

##setzt zwei Funktionen zusammen, =>erstellt eine Funktion, die die linke Funktion über dem Ergebnis der rechten Funktion &abbildet , und bindet ein Argument an eine Seite einer Funktion. Für die Eingabe _entspricht dies:

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

Zuerst MatchAlllaufen dann Ziffern ( \\d+). Danach konvertieren wir jeden Lauf mit der NFunktion in eine tatsächliche Ganzzahl . Schließlich nehmen wir die Summe dieser Zahlen mit Sum.

APL (NARS), Zeichen 13, Bytes 26

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

Prüfung:

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

C # (Visual C # Interactive Compiler), 117 111 Byte

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

Probieren Sie es online aus.

Perl 5 -p , 17 Bytes

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

Probieren Sie es online aus!

Japt v2.0a0 -x, 3 Bytes

Eine weitere Probefahrt für meinen (sehr WIP) Dolmetscher.

q\D

Versuch es

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 Bytes

105 Bytes + 25 Bytes für den Regex-Import

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

Probieren Sie es online aus!
Erläuterung

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 Bytes

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

Probieren Sie es online aus!

Schnell, 109 Bytes

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

Probieren Sie es online aus!

Pip , 6 Bytes

$+a@XI

Behandelt -123als negative ganze Zahl. Probieren Sie es online aus!

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

Wenn Bindestriche ignoriert und nicht als Minuszeichen behandelt werden sollen, funktioniert das Folgende für 7 Bytes :

$+a@+XD

XDist eine voreingestellte Variable für `\d`; +XDFügt den Regex- +Modifikator hinzu , sodass er mit einer oder mehreren Ziffern übereinstimmt.

Java (JDK) , 98 94 93 Byte

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

Probieren Sie es online aus!

-4 bytesmit Long::newanstelle von Long::valueOf.
-1 bytedurch Kürzen des regulären Ausdrucks - wenn wir später bereits leere Zeichenfolgen entfernen, sind einige Extras beim Teilen in Ordnung.

Erklärt

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.