Tarea

La tarea es muy simple. Dada una cadena no vacía que contiene números , letras mayúsculas y minúsculas , genera la suma de los números restantes. Por ejemplo:

a1wAD5qw45REs5Fw4eRQR33wqe4WE

Filtrar todas las letras daría como resultado:

 1   5  45   5  4    33   4

La suma de estos números es 1 + 5 + 45 + 5 + 4 + 33 + 4 = 97. Entonces la salida sería 97.

Casos de prueba

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

Este es el código de golf , por lo que gana el envío con la menor cantidad de bytes.

GS2, 2 bytes

Wd

Pruébalo en línea!

Cómo funciona

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

Laberinto , 8 bytes

Toma eso, Pyth ...

?+
;,;!@

Pruébalo en línea!

Explicación

La cartilla habitual (robada de Sp3000):

• Labyrinth es 2D y está basado en pila. Las pilas tienen un número infinito de ceros en la parte inferior.
• Cuando el puntero de instrucción alcanza una unión, comprueba la parte superior de la pila para determinar a dónde girar a continuación. Negativo es izquierdo, cero es hacia adelante y positivo es correcto.

Lo que es realmente útil aquí es que Labyrinth tiene dos comandos de entrada diferentes, ,y ?. El primero lee un solo byte de STDIN, o -1en EOF. Este último lee un número entero de STDIN. Lo hace omitiendo todo lo que no es un número y luego lee el primer número decimal que encuentra. Este regresa 0en EOF, por lo que no podemos usarlo para verificar EOF de manera confiable aquí.

El bucle principal del programa es este bit compacto:

?+
;,

Con ?leemos un número entero (ignorando todas las letras), con +lo sumamos al total acumulado (que comienza como uno de los ceros implícitos en la parte inferior de la pila). Luego leemos otro personaje ,para verificar si hay EOF. Mientras no estemos en EOF, el carácter leído será una letra que tiene un código de carácter positivo, por lo que la IP gira a la derecha (desde su punto de vista; es decir, oeste). ;descarta el carácter porque no lo necesitamos y luego ingresamos al ciclo nuevamente.

Una vez que estamos en EOF, ,presiona a -1para que la IP gire a la izquierda (este) en su lugar. ;nuevamente descarta eso -1, !imprime el total acumulado como un número entero y @finaliza el programa.

CJam, 13 bytes

¡Arreglado para trabajar con entrada sin números gracias a Dennis! También guardé un byte al reemplazar la matriz de letras con una matriz de ASCII sobre el punto de código 64. ¡Y luego otro byte guardado por Dennis!

q_A,s-Ser~]1b

Transliteración simple de letras a espacios, luego evalúa y suma. Pruébalo en línea .

MATL , 8 bytes

1Y4XXXUs

Pruébalo en línea!

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

Pruébalo en línea!

¡11 bytes (!) Guardados gracias a Martin!

Básicamente solo decimal a unario y luego contar el 1s.

Japt, 2 bytes

Nx

¡Pruébelo en línea!

Cómo 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')

Cómo funciona

Primero, reemplazamos cada cadena de no dígitos con "+". Básicamente, hay cuatro formas diferentes en que esto podría terminar:

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

Los casos 1 y 2 ya están atendidos. Pero de alguna manera necesitamos arreglar el último +para que no cause un error. Podríamos eliminarlo con .replace(/\+$,""), pero eso es demasiado caro. Podríamos agregar 0a al final, pero eso afectaría el último número si la cadena no termina con a +. Un compromiso es agregar .0, que es un número válido por sí solo y no afecta el valor de otros enteros.

Aquí hay algunos otros valores que también funcionarían:

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

Versión alternativa, también 35 bytes.

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

Otra versión alternativa, 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

Afortunadamente, s(convertir a int) vuelve0 cuando se aplica a la cadena vacía, por lo que no tengo que preocuparme por el hecho de que split("a1b", "\D+")regresa ["", "1", ""]. Del mismo modo, split("a", "\D+")vuelve ["", ""].

Esto incluso me permite dividir en cada no dígito individualmente, ya que 1 + 0 + 0 + 0 + 0 + 2es lo mismo que 1 + 2.

¡Gracias a Thomas Kwa por un byte!

Gol> <> , 4 bytes

iEh+

Tan breve que necesito un texto falso ...

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

Jalea, 6 bytes

&-ṣ-ḌS

Pruébalo en línea!

Cómo 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

Requiere la -pbandera:

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

Julia, 35 bytes

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

Esta es una función anónima que acepta una cadena y devuelve un entero. Para llamarlo, asígnelo a una variable.

Usamos matchallpara obtener una matriz que consiste en coincidencias de la expresión regular \d+, que son solo los enteros en la cadena. Tenemos que agregar un 0 al frente de la cadena, de lo contrario para casos como "a", estaríamos sumando sobre una matriz vacía, lo que causa un error. Luego aplicamos parsea cada coincidencia de cadena, que se convierte en enteros, y tomamos la suma.

PHP, 64 bytes

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

Ejecútalo 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..]&

Capturando el extremo equivocado de los componentes detallados de Mathematica. 1 byte desactivado con la ayuda de @DavidC

R, 46 43 bytes

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

Explicación

                    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

Ejecución de la muestra

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

Editar: reemplazado [^0-9]por \\D.

PowerShell, 28 26 bytes

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

Toma la entrada y $argsluego realiza una expresión regular -replacepara intercambiar las letras +0, luego las canaliza a iex(abreviatura Invoke-Expressiony similar a eval).

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

Alternativamente

Si está de acuerdo con alguna salida extraña, puede hacer lo siguiente, también a 28 26 bytes:

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

Esto tomará la cadena de entrada $argsy la colocará -spliten una matriz de cadenas en los no números (eliminándolos en el proceso). Por ejemplo, 1a2b33se convertiría en ['1','2','33']. Lo canalizamos Measure-Objectcon el -Sumparámetro. La salida sería la siguiente:

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

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

_{Editar - durr, no necesito la [ ]expresión regular ya que ya no estoy especificando una lista de posibles coincidencias ...}

Gema, 39 personajes

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

Ejecución de muestra:

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

En serio, 13 bytes

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

Pruébalo en línea!

Explicación:

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

Funciona en 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

Requires having gsubfn installed

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

Uses strtoi to coerce to numeric

Ruby 45 bytes

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

(First attempt at work, will revisit this)

POSIX sh + tr + dc, 27 25 bytes

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

Converts any run of non-digits (including the terminating newline) to + operator, pushes two zeros onto the stack (in case input begins with non-digit), adds them all and prints the result. There may be an extra zero remaining at bottom of stack, but we don't care about that.

Lua, 51 Bytes

Pretty short for once! Even shorter than Java! The input must be a command-line argument for it to work.

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

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

If it is required to support input with no numbers (e.g. a), then we can do this:

Bash + GNU utilities, 38

1 byte saved thanks to @TobySpeight.

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

Python 2, 70 bytes

I am putting a Python answer just for fun.

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

Very simple and uses regex to find all the numbers in the input. Try it online!

Oracle SQL 11.2, 105 bytes

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

The regex convert alpha characters to ','

XMLTABLE create one row per item in the string using ',' as the separator.

SUM the rows to get the result.

NVL is needed to account for a string with no digit.