Aufgabe

Die Aufgabe ist sehr einfach. Geben Sie bei einer nicht leeren Zeichenfolge mit Zahlen , Groß- und Kleinbuchstaben die Summe der verbleibenden Zahlen aus. Beispielsweise:

a1wAD5qw45REs5Fw4eRQR33wqe4WE

Wenn Sie alle Buchstaben herausfiltern, erhalten Sie:

 1   5  45   5  4    33   4

Die Summe dieser Zahlen ist 1 + 5 + 45 + 5 + 4 + 33 + 4 = 97. So wäre die Ausgabe 97.

Testfälle

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

Das ist Code-Golf , also gewinnt die Einsendung mit der geringsten Anzahl von Bytes!

GS2, 2 Bytes

Wd

Probieren Sie es online!

Wie es funktioniert

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

Labyrinth , 8 Bytes

Nimm das, Pyth ...

?+
;,;!@

Probieren Sie es online!

Erläuterung

Die übliche Grundierung (von Sp3000 gestohlen):

• Labyrinth ist 2D und stapelbasiert. Stapel haben eine unendliche Anzahl von Nullen am unteren Rand.
• Wenn der Anweisungszeiger eine Kreuzung erreicht, prüft er die Oberseite des Stapels, um festzustellen, wohin er als nächstes abbiegen soll. Negativ ist links, Null ist vorwärts und positiv ist rechts.

Was hier wirklich nützlich ist, ist, dass Labyrinth zwei verschiedene Eingabebefehle hat, ,und ?. Ersteres liest ein einzelnes Byte von STDIN oder -1bei EOF. Letzterer liest eine ganze Zahl aus STDIN. Dabei wird alles übersprungen, was keine Zahl ist, und dann die erste gefundene Dezimalzahl gelesen. Dieser kehrt 0bei EOF zurück, daher können wir ihn hier nicht verwenden, um zuverlässig nach EOF zu suchen.

Die Hauptschleife des Programms ist dieses kompakte Bit:

?+
;,

Wenn ?wir eine Ganzzahl lesen (alle Buchstaben ignorieren), +addieren wir sie zur laufenden Summe (die als eine der impliziten Nullen am unteren Ende des Stapels beginnt). Dann lesen wir ein anderes Zeichen mit ,, um nach EOF zu suchen. Solange wir nicht bei EOF sind, wird das gelesene Zeichen ein Buchstabe sein, der einen positiven Zeichencode hat. Die IP dreht sich also nach rechts (aus Sicht von Westen). ;Wir verwerfen den Charakter, weil wir ihn nicht brauchen und betreten dann die Schleife erneut.

Sobald wir bei EOF sind, ,drückt man a, -1so dass die IP stattdessen nach links (nach Osten) dreht. ;verwirft dies erneut -1, !druckt die laufende Summe als Ganzzahl und @beendet das Programm.

CJam, 13 Bytes

Problem behoben, bei dem dank Dennis mit Eingaben ohne Zahlen gearbeitet werden konnte! Außerdem wurde ein Byte gespeichert, indem das Buchstaben-Array durch ein ASCII-Array über Codepunkt 64 ersetzt wurde. Und dann ein weiteres Byte, das von Dennis gespeichert wurde!

q_A,s-Ser~]1b

Einfache Transliteration von Buchstaben zu Leerzeichen, dann Auswertung und Summe. Probieren Sie es online aus .

MATL , 8 Bytes

1Y4XXXUs

Probieren Sie es 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

Netzhaut ,22 11

\d+
$0$*1
1

Probieren Sie es online!

11 Bytes (!) Gespart dank Martin!

Grundsätzlich nur dezimal bis unär, dann zählen die 1s.

Japt, 2 Bytes

Nx

Online testen!

Wie es funktioniert

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

Wie es funktioniert

Erstens ersetzen wir jede Zeichenfolge von Nicht-Ziffern durch "+". Grundsätzlich gibt es vier verschiedene Möglichkeiten, wie dies enden könnte:

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

Die Fälle 1 und 2 sind bereits erledigt. Aber wir müssen irgendwie den letzten reparieren, +damit er keinen Fehler verursacht. Wir könnten es mit entfernen .replace(/\+$,""), aber das ist zu teuer. Wir könnten ein 0an das Ende anhängen , aber das würde sich auf die letzte Zahl auswirken, wenn die Zeichenfolge nicht mit einem endet +. Ein Kompromiss ist das Anhängen .0, das für sich genommen eine gültige Zahl ist und den Wert anderer Ganzzahlen nicht beeinflusst.

Hier sind einige andere Werte, die ebenfalls funktionieren würden:

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

Alternative Version, auch 35 Bytes

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

Eine andere alternative Version, 36 Bytes

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

Pyth, 12 11 10 Bytes

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

Glücklicherweise gibt s(convert to int) zurück, 0wenn es auf die leere Zeichenfolge angewendet wird, sodass ich mir keine Gedanken über die Tatsache machen muss, dass split("a1b", "\D+")zurückgegeben wird ["", "1", ""]. Ebenso split("a", "\D+")kehrt zurück ["", ""].

Dies erlaubt mir sogar, jede Ziffer einzeln aufzuteilen, da 1 + 0 + 0 + 0 + 0 + 2es dasselbe ist wie 1 + 2.

Danke an Thomas Kwa für ein Byte!

Gol> <> , 4 Bytes

iEh+

So kurz, ich brauche Dummy-Text ...

Perl 6 , 18 Bytes

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

Verwendung:

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

Gelee, 6 Bytes

&-ṣ-ḌS

Probieren Sie es online!

Wie es funktioniert

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

Benötigt die -pFlagge:

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

Julia, 35 Bytes

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

Dies ist eine anonyme Funktion, die eine Zeichenfolge akzeptiert und eine Ganzzahl zurückgibt. Um es aufzurufen, weisen Sie es einer Variablen zu.

Wir verwenden matchall, um ein Array zu erhalten, das aus Übereinstimmungen des regulären Ausdrucks besteht \d+, die nur die Ganzzahlen in der Zeichenfolge sind. Wir müssen eine 0 vor der Zeichenkette anheften, sonst "a"summieren wir in solchen Fällen über ein leeres Array, was einen Fehler verursacht. Wir wenden dann parseauf jede Zeichenfolgenübereinstimmung an, die in Ganzzahlen konvertiert wird, und nehmen die Summe.

PHP, 64 Bytes

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

Führen Sie es als

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..]&

Das falsche Ende der ausführlichen Mathematica-Builtins abfangen. 1 Byte aus mit Hilfe von @DavidC

R, 46 43 Bytes

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

Erläuterung

                    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

Probelauf

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

Bearbeiten: Ersetzt [^0-9]durch \\D.

PowerShell, 28 26 Bytes

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

Übernimmt die Eingabe $argsund führt dann einen regulären Ausdruck aus, -replacemit dem die Buchstaben ausgetauscht werden +0, und leitet diesen an iex(kurz für Invoke-Expressionund ähnlich wie eval).

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

Alternative

Wenn Sie mit einer fremden Ausgabe einverstanden sind, können Sie auch bei 28 bis 26 Byte Folgendes tun :

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

Dies nimmt die Eingabezeichenfolge $argsund -splitsie in ein Array von Zeichenfolgen auf den Nicht-Zahlen auf (wobei sie in dem Prozess entfernt werden). Zum Beispiel 1a2b33würde sich in ['1','2','33']. Das leiten wir Measure-Objectmit dem -SumParameter weiter. Die Ausgabe würde wie folgt aussehen:

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

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

_{Bearbeiten - durr, brauche das nicht [ ]im regulären Ausdruck, da ich keine Liste möglicher Übereinstimmungen mehr spezifiziere ...}

Gema, 39 Zeichen

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

Probelauf:

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

Im Ernst, 13 Bytes

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

Probieren Sie es online!

Erläuterung:

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

Funktioniert mit TI-83/84-Taschenrechnern!

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 Byte

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

R, 50 Bytes

Erfordert gsubfninstalliert zu haben

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

Verwendet strtoi, um zu numerisch zu zwingen

Ruby 45 Bytes

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

(Erster Versuch bei der Arbeit, wird dies nochmals besuchen)

POSIX sh + tr + dc, 27 25 Bytes

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

Wandelt eine beliebige Folge von Nicht-Ziffern (einschließlich des abschließenden Zeilenumbruchs) in einen +Operator um, schreibt zwei Nullen auf den Stapel (falls die Eingabe mit einer Nicht-Ziffer beginnt), fügt sie alle hinzu und druckt das Ergebnis. Möglicherweise verbleibt eine zusätzliche Null am Ende des Stapels, aber das interessiert uns nicht.

Lua, 51 Bytes

Ausnahmsweise mal ziemlich kurz! Noch kürzer als Java! Die Eingabe muss ein Befehlszeilenargument sein, damit sie funktioniert.

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-Dienstprogramme, 29

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

Wenn es erforderlich ist, Eingaben ohne Nummern zu unterstützen (z. B. a ), können wir dies tun:

Bash + GNU-Dienstprogramme, 38

Dank @TobySpeight 1 Byte gespart.

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

Python 2, 70 Bytes

Ich stelle eine Python-Antwort nur zum Spaß.

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

Sehr einfach und verwendet Regex, um alle Zahlen in der Eingabe zu finden. Probieren Sie es online!

Oracle SQL 11.2, 105 Bytes

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

Der Regex konvertiert Buchstaben in ','

XMLTABLE erstellt eine Zeile pro Element in der Zeichenfolge, wobei ',' als Trennzeichen verwendet wird.

SUMME die Zeilen, um das Ergebnis zu erhalten.

NVL wird benötigt, um eine Zeichenfolge ohne Ziffer zu berücksichtigen.