Entrada

Una cuerda.

Salida

La suma de todos los enteros en la línea.

Restricciones

1≤Longitud de línea≤500

Caso de prueba de muestra

Entrada

the 5is 108 seCONd4 a

Salida

117

Explicación

Suma es: 5 + 108 + 4 = 117

Javascript, 34 32 bytes

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

Une todos los dígitos y únelos +girándolos en 5 + 108 + 4, evalúa el resultado.
Solo funciona en enteros positivos.

Guardado 2 bytes gracias a Arnauld

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+/}

Pruébalo en línea!

Bloque de código anónimo que devuelve la suma de todas las series de dígitos

05AB1E , 11 6 bytes

þмS¡þO

Pruébalo en línea.

Explicación:

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

Después de ver la entrada de PowerShell, pude jugar más al golf.

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

Pruébalo en línea!

APL (Dyalog Unicode) , 11 bytes

Función anónima tácita prefic

+/#⍎¨∊∘⎕D⊆⊢

Pruébalo en línea!

⊢ el argumento

⊆ particionado (las ejecuciones de True se convierten en piezas, las ejecuciones de False son separadores) por

∊ membresía
∘ del
⎕D conjunto de dígitos

#⍎¨ evaluar cada uno en el espacio de nombres raíz

+/ suma

Retina 0.8.2 , 8 bytes

\d+
$*
1

Pruébalo en línea!

• La primera línea coincide con todos los números.
• La segunda línea reemplaza estos por 1s, repetido dicho número de veces
• La última línea es una coincidencia y cuenta el número total de 1s en la cadena.

PowerShell , 29 bytes

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

Pruébalo en línea!

Carbón de leña , 5 bytes

ＩΣ⁺ψＳ

Pruébalo en línea! El enlace es a la versión detallada del código. Explicación: El Sumoperador del carbón de leña extrae automáticamente los números de una cadena, sin embargo, si la cadena no contiene caracteres que no sean dígitos, toma la suma digital, por lo que concateno un byte nulo para evitar esto. El resultado se devuelve a la cadena para la salida implícita.

Haskell , 50 bytes

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

Pruébalo en línea!

Probablemente haya una mejor manera, pero esta es la más obvia.

Zsh , 21 bytes

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

Pruébalo en línea!

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

Desafortunadamente, bash se queja porque interpreta 0108como octal. Zsh no (a menos que setopt octalzeroes)

Bash, 43 bytes

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

Reemplaza cada no número con un espacio, y luego los suma.

-5 bytes gracias a GammaFunction

Python 3 , 63 59 56 bytes

Por qué no. Respuesta obligatoria de expresiones regulares. Probablemente podría acoplar 6 usando Python 2, pero lo que sea. Ya no se aplica ya que estoy usando un enfoque eval en lugar de usar el mapa.

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

Explicación:

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

Pruébalo en línea!

Java 10, 66 bytes

Esta es una lambda de Stringa int.

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

Los enteros negativos no son compatibles. Presumiblemente está bien.

Pruébalo en línea

Expresiones de gratitud

• -3 bytes gracias a Encarnación de la ignorancia

Ruby, 32 27 caracteres

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

Expresiones de gratitud

• -5 bytes gracias a Conor O 'Brien

Cubix , 17 bytes

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

Pruébalo en línea!

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

Míralo correr

Una bastante simple. Ien cubix tomará el primer entero en la entrada y lo empujará a la pila. Esto tiene el efecto de omitir todos los personajes. El resto se ocupa de lo adicional y detecta el final de la entrada.

• I! Ingrese un número entero y pruébelo para 0
• s+q;;Si no es cero, intercambie TOS (fuerzas y 0 inicial) y agregue. Empuje el resultado al fondo de la pila y limpie la parte superior. Regresar al comienzo.
• /i? Si es cero, redirige y realiza una entrada de caracteres para verificar
• |?;/Si el positivo (personaje) gira a la derecha en un reflejo, esto lo empuja hacia atrás a través del corrector ?y gira a la derecha en el pop desde la pila, dejando 0 en TOS. Luego, la IP se redirige al bucle principal.
• I>p.O@ si es negativo (final de la entrada), gire a la izquierda, ingrese enteros, coloque la parte inferior de la pila en la parte superior, haga salir y pare.

PHP ,40 39 bytes

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

Pruébalo en línea!

Ejecutar con php -nFentrada es de STDIN. Ejemplo:

$ 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

Pruébalo en línea!

Hace uso de reads.

Por delante , 13 bytes

Esto funciona porque Isimplemente escanea el flujo de entrada para el siguiente token que parece un número, ignorando cualquier otra cosa.

~Ilj~#
 >K+O@

Pruébalo en línea!

QuadR , 9 bytes

+/⍎⍵
\D
 

Pruébalo en línea!

+/ la suma de

⍎ evaluación como APL de

⍵ el resultado de

\D reemplazando cada no dígito con

 un espacio

Japt -x , 5 bytes

f/\d+

Pruébalo en línea!

Adjunto , 23 bytes

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

Pruébalo en línea!

Una respuesta más interesante, pero indirecta (37 bytes): {Sum!Reap[ReplaceF[_,/"\\d+",Sow@N]]}

Explicación

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

Esto tiene la forma:

f##g=>h&x

que, cuando se expande y se hace paréntesis, se convierte en

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

##compone dos funciones juntas, =>crea una función que asigna la función izquierda sobre el resultado de la función derecha y &vincula un argumento a un lado de una función. Para la entrada _, esto es equivalente a:

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

Primero, entonces, corremos MatchAllde caracteres de dígitos ( \\d+). Después, convertimos cada ejecución a un entero real usando la Nfunción. Finalmente, tomamos la suma de estos números usando Sum.

APL (NARS), caracteres 13, bytes 26

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

prueba:

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

C # (compilador interactivo de Visual C #), 117 111 bytes

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

Pruébalo en línea.

Perl 5 -p , 17 bytes

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

Pruébalo en línea!

Japt v2.0a0 -x, 3 bytes

Otra prueba de manejo para mi intérprete (muy WIP).

q\D

Intentalo

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 para la importación de expresiones regulares

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

Pruébalo en línea!
Explicación

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

Pruébalo en línea!

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

Pruébalo en línea!

Pip , 6 bytes

$+a@XI

Se trata -123como un entero negativo. Pruébalo en línea!

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

Si se deben ignorar los guiones en lugar de tratarlos como signos menos, entonces lo siguiente funciona para 7 bytes :

$+a@+XD

XDes una variable preestablecida para `\d`; +XDagrega el +modificador regex , haciendo que coincida con 1 o más dígitos.

Java (JDK) , 98 94 93 bytes

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

Pruébalo en línea!

-4 bytesmediante el uso de en Long::newlugar de Long::valueOf.
-1 byteacortando la expresión regular, si ya estamos eliminando cadenas vacías más tarde, haciendo algunos extras cuando la división está bien.

Explicado

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.