Zadanie

Zadanie jest bardzo proste. Biorąc pod uwagę niepusty ciąg zawierający cyfry , wielkie i małe litery , wypisz sumę pozostałych liczb. Na przykład:

a1wAD5qw45REs5Fw4eRQR33wqe4WE

Filtrowanie wszystkich liter spowoduje:

 1   5  45   5  4    33   4

Suma tych liczb to 1 + 5 + 45 + 5 + 4 + 33 + 4 = 97. Więc wynik byłby 97.

Przypadki testowe

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

To jest golf golfowy , więc wygrywanie z najmniejszą ilością bajtów wygrywa!

GS2, 2 bajty

Wd

Wypróbuj online!

Jak to działa

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

Labirynt , 8 bajtów

Weź to, Pyth ...

?+
;,;!@

Wypróbuj online!

Wyjaśnienie

Zwykły podkład (skradziony ze Sp3000):

• Labirynt jest oparty na 2D i oparty na stosach. Stosy mają na dole nieskończoną liczbę zer.
• Gdy wskaźnik instrukcji osiągnie skrzyżowanie, sprawdza górną część stosu, aby określić, gdzie należy skręcić. Ujemne jest lewe, zero jest do przodu, a pozytywne jest prawe.

Przydaje się tutaj to, że Labirynt ma dwa różne polecenia wejściowe ,i ?. Pierwszy z nich odczytuje pojedynczy bajt ze STDIN lub -1z EOF. Ten ostatni odczytuje liczbę całkowitą ze STDIN. Robi to pomijając wszystko, co nie jest jest liczbą, a następnie odczytuje pierwszą znalezioną liczbę dziesiętną. Ten powraca 0w EOF, więc nie możemy go użyć do wiarygodnego sprawdzenia EOF tutaj.

Główną pętlą programu jest ten kompaktowy bit:

?+
;,

Gdy ?czytamy liczbę całkowitą (ignorując wszystkie litery), +dodajemy ją do bieżącej sumy (która zaczyna się jako jedna z niejawnych zer na dole stosu). Następnie czytamy inną postać, ,aby sprawdzić EOF. Tak długo, jak nie jesteśmy w EOF, odczytywany znak będzie literą, która ma dodatni kod znaku, więc adres IP skręca w prawo (z jego punktu widzenia, tj. Na zachód). ;odrzuca postać, ponieważ nie jest nam potrzebna, a następnie ponownie wchodzimy do pętli.

Gdy jesteśmy w EOF, ,przesuń a, -1więc IP skręca w lewo (na wschód). ;ponownie odrzuca to -1, !wypisuje bieżącą sumę jako liczbę całkowitą i @kończy działanie programu.

CJam, 13 bajtów

Naprawiono do pracy z wprowadzaniem bez liczb dzięki Dennis! Zapisano również bajt, zastępując tablicę liter tablicą ASCII powyżej kodu 64. Kolejny bajt zapisany przez Dennisa!

q_A,s-Ser~]1b

Prosta transliteracja z liter na spacje, następnie ewaluacja i sumowanie. Wypróbuj online .

MATL , 8 bajtów

1Y4XXXUs

Wypróbuj 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

Siatkówka oka ,22 11

\d+
$0$*1
1

Wypróbuj online!

11 bajtów (!) Zapisanych dzięki Martinowi!

Zasadniczo od dziesiętnego do unarnego, a następnie policz 1s.

Japt, 2 bajty

Nx

Przetestuj online!

Jak to działa

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

JavaScript ES6, 35 bajtów

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

Jak to działa

Najpierw zamieniamy każdy ciąg znaków innych niż cyfry na "+". Istnieją w zasadzie cztery różne sposoby, w jakie może to zakończyć:

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

Sprawy 1 i 2 zostały już załatwione. Ale w jakiś sposób musimy naprawić ten ostatni, +aby nie spowodował błędu. Możemy to usunąć za pomocą .replace(/\+$,""), ale to zbyt kosztowne. Możemy dodać a 0na końcu, ale wpłynęłoby to na ostatnią liczbę, jeśli ciąg nie kończy się na +. Kompromisem jest dołączenie .0, które samo w sobie jest poprawną liczbą i nie wpływa na wartość innych liczb całkowitych.

Oto kilka innych wartości, które również by działały:

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

Alternatywna wersja, również 35 bajtów

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

Kolejna alternatywna wersja, 36 bajtów

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

Pyth, 12 11 10 bajtów

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

Na szczęście s(konwersja na int) zwraca 0po zastosowaniu do pustego ciągu, więc nie muszę się martwić o to, że split("a1b", "\D+")zwraca["", "1", ""] . Podobnie split("a", "\D+")zwraca ["", ""].

To pozwala mi nawet dzielić na każdą cyfrę osobno 1 + 0 + 0 + 0 + 0 + 2 jest to to samo, co 1 + 2.

Dzięki Thomas Kwa za bajt!

Gol> <> , 4 bajty

iEh+

Tak krótki, że potrzebuję smoczego tekstu ...

Perl 6 , 18 bajtów

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

Stosowanie:

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

Galaretka, 6 bajtów

&-ṣ-ḌS

Wypróbuj online!

Jak to działa

&-ṣ-Ḍ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 bajtów

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

Wymaga -pflagi:

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

Julia, 35 bajtów

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

Jest to anonimowa funkcja, która przyjmuje ciąg znaków i zwraca liczbę całkowitą. Aby go wywołać, przypisz go do zmiennej.

Używamy, matchallaby uzyskać tablicę składającą się z dopasowań wyrażenia regularnego \d+, które są tylko liczbami całkowitymi w ciągu. Musimy wstawić 0 na początku łańcucha, w przeciwnym razie w przypadku takich przypadków "a"sumujemy pustą tablicę, co powoduje błąd. Następnie stosujemy parsedo każdego dopasowania ciągu, które konwertuje się na liczby całkowite i bierzemy sumę.

PHP, 64 bajty

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

Uruchom jako

php -f filterOutAndAddUp.php <test_case>

https://eval.in/517817

JavaScript, 32 39 bajtów

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 bajtów

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

Łapanie niewłaściwego końca pełnych poleceń wbudowanych w Mathematica. 1 Bajkot przy pomocy @DavidC

R, 46 43 bajtów

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

Wyjaśnienie

                    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

Przykładowy przebieg

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

Edit: Wymieniłem [^0-9]z \\D.

PowerShell, 28 26 bajtów

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

Pobiera dane wejściowe, $argsa następnie dokonuje wyrażenia regularnego, -replaceaby zamienić litery +0, a następnie potokuje to iex(skrót Invoke-Expressioni podobne do eval).

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

Alternatywnie

Jeśli nie masz nic przeciwko zewnętrznym wynikom, możesz wykonać następujące czynności, również przy 28 26 bajtach:

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

Spowoduje to przeniesienie ciągu wejściowego $argsi umieszczenie -splitgo w tablicy ciągów znaków innych niż liczby (usunięcie ich w trakcie procesu). Na przykład 1a2b33zamieniłby się w ['1','2','33']. Podajemy to Measure-Objectza pomocą -Sumparametru. Dane wyjściowe byłyby następujące:

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

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

_{Edycja - durr, nie potrzebuję [ ]wyrażenia regularnego, ponieważ nie określam już listy możliwych dopasowań ...}

Gema, 39 znaków

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

Przykładowy przebieg:

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

Poważnie, 13 bajtów

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

Wypróbuj online!

Wyjaśnienie:

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

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

TI-Basic, 106 bajtów

Działa na kalkulatorach TI-83/84!

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 bajtów

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

R, 50 bajtów

Wymaga gsubfnzainstalowania

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

Używa strtoiprzymusu do numerycznego

Ruby 45 bajtów

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

(Pierwsza próba pracy, ponownie ją odwiedzę)

POSIX sh + tr + dc, 27 25 bajtów

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

Konwertuje dowolny ciąg znaków innych niż cyfry (w tym kończący znak nowej linii) na +operator, wypycha dwa zera na stos (w przypadku, gdy wprowadzanie rozpoczyna się od cyfry), dodaje je wszystkie i drukuje wynik. Na dole stosu może pozostać dodatkowe zero, ale nie dbamy o to.

Lua, 51 bajtów

Na razie dość krótko! Jeszcze krótszy niż Java! Dane wejściowe muszą być argumentem wiersza polecenia, aby działały.

a=0 arg[1]:gsub("%d+",function(c)a=a+c end)print(a)

Nie golfił

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

Narzędzia Bash + GNU, 29

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

Jeśli wymagane jest wsparcie wprowadzania bez liczb (np a ), Możemy to zrobić:

Narzędzia Bash + GNU, 38

1 bajt zapisany dzięki @TobySpeight.

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

Python 2, 70 bajtów

Dla przyjemności zamieszczam odpowiedź w języku Python.

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

Bardzo prosty i używa wyrażenia regularnego, aby znaleźć wszystkie liczby na wejściu. Wypróbuj online!

Oracle SQL 11.2, 105 bajtów

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

Wyrażenie regularne konwertuje znaki alfa na „,”

XMLTABLE utwórz jeden wiersz dla każdego elementu w ciągu, używając „,” jako separatora.

SUMUJ wiersze, aby uzyskać wynik.

NVL jest potrzebne, aby uwzględnić ciąg bez cyfr.