Tarefa

A tarefa é muito simples. Dada uma sequência não vazia contendo números , letras maiúsculas e minúsculas , produza a soma dos números restantes. Por exemplo:

a1wAD5qw45REs5Fw4eRQR33wqe4WE

Filtrar todas as letras resultaria em:

 1   5  45   5  4    33   4

A soma desses números é 1 + 5 + 45 + 5 + 4 + 33 + 4 = 97. Então a saída seria 97.

Casos de teste

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

Isso é código-golfe , então a submissão com a menor quantidade de bytes ganha!

GS2, 2 bytes

Wd

Experimente online!

Como funciona

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

Labirinto , 8 bytes

Tome isso, Pyth ...

?+
;,;!@

Experimente online!

Explicação

O iniciador usual (roubado do Sp3000):

• O labirinto é 2D e baseado em pilha. As pilhas têm um número infinito de zeros na parte inferior.
• Quando o ponteiro de instrução atinge uma junção, ele verifica o topo da pilha para determinar para onde virar a seguir. Negativo é deixado, zero é para frente e positivo é direito.

O que é realmente útil aqui é que o Labyrinth tem dois comandos de entrada diferentes, ,e ?. O primeiro lê um único byte do STDIN, ou -1no EOF. Este último lê um número inteiro de STDIN. Ele faz isso pulando tudo o que não é um número e depois lê o primeiro número decimal encontrado. Como este retorna 0no EOF, não podemos usá-lo para verificar o EOF de forma confiável aqui.

O loop principal do programa é este bit compacto:

?+
;,

Com ?lemos um número inteiro (ignorando todas as letras), +adicionamos o total em execução (que começa como um dos zeros implícitos na parte inferior da pilha). Em seguida, lemos outro caractere ,para verificar o EOF. Enquanto não estivermos no EOF, o caractere de leitura será uma letra com um código de caractere positivo; portanto, o IP vira à direita (do ponto de vista; ou seja, oeste). ;descarta o personagem porque não precisamos dele e entramos no loop novamente.

Quando estivermos no EOF, ,pressione a -1para que o IP vire à esquerda (leste). ;novamente descarta isso -1, !imprime o total em execução como um número inteiro e @finaliza o programa.

CJam, 13 bytes

Corrigido para trabalhar com entrada sem números, graças a Dennis! Também salvou um byte, substituindo a matriz de letras por uma matriz de ASCII acima do ponto de código 64. E depois outro byte salvo por Dennis!

q_A,s-Ser~]1b

Transliteração simples de letras para espaços, depois avaliação e soma. Experimente online .

MATL , 8 bytes

1Y4XXXUs

Experimente 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

Experimente online!

11 bytes (!) Economizados graças ao Martin!

Basicamente, apenas decimal para unário, em seguida, conte os 1s.

Japonês, 2 bytes

Nx

Teste online!

Como funciona

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

JavaScript ES6, 35 bytes

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

Como funciona

Primeiro, substituímos cada sequência de não dígitos por "+". Existem basicamente quatro maneiras diferentes de acabar:

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

Os casos 1 e 2 já estão resolvidos. Mas, de alguma forma, precisamos corrigir o último +para que ele não cause erro. Nós poderíamos removê-lo com .replace(/\+$,""), mas isso é muito caro. Poderíamos acrescentar 0a ao final, mas isso afetaria o último número se a sequência não terminar com a +. Um compromisso é anexar .0, que é um número válido por si só e não afeta o valor de outros números inteiros.

Aqui estão alguns outros valores que também funcionariam:

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

Versão alternativa, também 35 bytes

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

Outra versão alternativa, 36 bytes

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

Pitão, 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

Felizmente, s(converter para int) retorna 0quando aplicado à string vazia, então não preciso me preocupar com o fato de split("a1b", "\D+")retornar ["", "1", ""]. Da mesma forma, split("a", "\D+")retorna ["", ""].

Isso até me permite dividir todos os não dígitos individualmente, pois 1 + 0 + 0 + 0 + 0 + 2é a mesma coisa que 1 + 2.

Obrigado a Thomas Kwa por um byte!

Gol> <> , 4 bytes

iEh+

Tão curto que eu preciso de texto fictício ...

Perl 6 , 18 bytes

{[+] .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 bytes

&-ṣ-ḌS

Experimente online!

Como funciona

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

Requer a -pbandeira:

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

Julia, 35 bytes

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

Esta é uma função anônima que aceita uma string e retorna um número inteiro. Para chamá-lo, atribua-o a uma variável.

Nós usamos matchall para obter uma matriz que consiste em correspondências da expressão regular \d+, que são apenas os números inteiros na string. Temos que colocar um 0 na frente da string, caso contrário, em casos como "a"estaríamos somando sobre uma matriz vazia, o que causa um erro. Em seguida, aplicamos parsea cada correspondência de string, que é convertida em números inteiros, e obtemos a soma.

PHP, 64 bytes

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

Execute-o como

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

Pegando o lado errado dos recursos detalhados do Mathematica. 1 byte off com a ajuda de @DavidC

R, 46 43 bytes

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

Explicação

                    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

Amostra de execução

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

Editar: Substituído [^0-9]por \\D.

PowerShell, 28 26 bytes

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

Recebe a entrada $argse executa um regex -replacepara trocar as letras e +0, em seguida, canaliza isso para iex(abreviado Invoke-Expressione semelhante a eval).

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

alternativamente

Se você concorda com alguma saída estranha, pode fazer o seguinte, também em 28 26 bytes:

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

Isso levará a sequência de entrada $argse a seqüência -splitde caracteres para os não números (removendo-os no processo). Por exemplo, 1a2b33se tornaria ['1','2','33']. Nós canalizamos isso para Measure-Objecto -Sumparâmetro A saída seria como a abaixo:

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

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

_{Editar - durr, não precisa do [ ]no regex, pois não estou mais especificando uma lista de possíveis correspondências ...}

Gema, 39 caracteres

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

Exemplo de execução:

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

Sério, 13 bytes

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

Experimente online!

Explicação:

,ú;û+@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-Básico, 106 bytes

Funciona em calculadoras 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 bytes

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

R, 50 bytes

Requer ter gsubfninstalado

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

Usa strtoipara coagir ao numérico

Ruby 45 bytes

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

(A primeira tentativa no trabalho revisitará isso)

POSIX sh + tr + dc, 27 25 bytes

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

Converte qualquer execução de não dígitos (incluindo a nova linha final) em +operador, pressiona dois zeros na pilha (caso a entrada comece com não dígitos), adiciona todos e imprime o resultado. Pode haver um zero extra restante no final da pilha, mas não nos importamos com isso.

Lua, 51 bytes

Muito curto pela primeira vez! Ainda mais curto que o Java! A entrada deve ser um argumento da linha de comandos para que funcione.

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

Utilitários Bash + GNU, 29

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

Se for necessário suportar entrada sem números (por exemplo, a ), podemos fazer o seguinte:

Utilitários Bash + GNU, 38

1 byte salvo graças a @TobySpeight.

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

Python 2, 70 bytes

Estou colocando uma resposta em Python apenas por diversão.

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

Muito simples e usa regex para encontrar todos os números na entrada. Experimente online!

Oracle SQL 11.2, 105 bytes

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

O regex converte caracteres alfa em ','

XMLTABLE cria uma linha por item na cadeia usando ',' como separador.

SUM as linhas para obter o resultado.

O NVL é necessário para contabilizar uma sequência sem dígito.