Entrada

Uma linha.

Resultado

A soma de todos os números inteiros na linha.

Restrições

1≤Comprimento da linha≤500

Caso de teste de amostra

Entrada

the 5is 108 seCONd4 a

Resultado

117

Explicação

A soma é: 5 + 108 + 4 = 117

Javascript, 34 32 bytes

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

Combine todos os dígitos e junte-os, +transformando-os em 5 + 108 + 4, avaliando o resultado.
Funciona apenas em números inteiros positivos.

Economizou 2 bytes graças 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+/}

Experimente online!

Bloco de código anônimo que retorna a soma de todas as séries de dígitos

05AB1E , 11 6 bytes

þмS¡þO

Experimente online.

Explicação:

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

Depois de ver a entrada do PowerShell, consegui jogar golfe ainda mais.

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

Experimente online!

APL (Dyalog Unicode) , 11 bytes

Função de prefixo tácito anônimo

+/#⍎¨∊∘⎕D⊆⊢

Experimente online!

⊢ o argumento

⊆ particionado (execuções de True tornam-se partes, execuções de False são separadores) por

∊ associação  do conjunto de dígitos
∘
⎕D

#⍎¨ avalie cada um no espaço para nome raiz

+/ soma

Retina 0.8.2 , 8 bytes

\d+
$*
1

Experimente online!

• A primeira linha corresponde a todos os números
• A segunda linha os substitui por 1s, repetido o referido número de vezes
• A última linha é uma correspondência e conta o número total de 1s na sequência

PowerShell , 29 bytes

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

Experimente online!

Carvão , 5 bytes

ＩΣ⁺ψＳ

Experimente online! Link é a versão detalhada do código. Explicação: O Sumoperador do Charcoal extrai automaticamente os números de uma sequência, no entanto, se a sequência não contém caracteres que não sejam dígitos, ela recebe a soma digital, então concatenarei um byte nulo para evitar isso. O resultado é então convertido de volta na string para saída implícita.

Haskell , 50 bytes

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

Experimente online!

Provavelmente existe uma maneira melhor, mas essa é a mais óbvia.

Zsh , 21 bytes

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

Experimente online!

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

Infelizmente, o bash reclama porque interpreta 0108como octal. Zsh não (a menos que setopt octalzeroes)

Bash, 43 bytes

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

Substitui todos os não números por um espaço e os soma juntos.

-5 bytes graças ao GammaFunction

Python 3 , 63 59 56 bytes

Por que não. Resposta obrigatória regex. Provavelmente poderia atracar 6 usando Python 2, mas tanto faz. Não se aplica mais, pois estou usando uma abordagem de avaliação em vez de usar o mapa.

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

Explicação:

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

Experimente online!

Java 10, 66 bytes

Este é um lambda de Stringpara int.

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

Inteiros negativos não são suportados. Presumivelmente, tudo bem.

Experimente Online

Agradecimentos

• -3 bytes graças à incorporação da ignorância

Ruby, 32 27 caracteres

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

Agradecimentos

• -5 bytes graças a Conor O 'Brien

Cubix , 17 bytes

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

Experimente online!

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

Assista correr

Um bastante simples. Ino cubix pegará o primeiro número inteiro na entrada e o empurrará para a pilha. Isso tem o efeito de pular todos os caracteres. O restante está lidando com o adicional e detectando o final da entrada.

• I! Insira um número inteiro e teste-o para 0
• s+q;;Se não for zero, troque TOS (forças e 0 inicial) e adicione. Empurre o resultado para o fundo da pilha e limpe a parte superior. Retorne ao começo.
• /i? Se zero, redirecione e insira um caractere para verificar
• |?;/Se positivo (caractere) virar à direita em um reflexo, ele o empurra de volta pelo verificador ?e vira à direita na pilha pop, deixando 0 no TOS. O IP é redirecionado novamente para o loop principal.
• I>p.O@ se negativo (final da entrada) virar à esquerda, faça a entrada inteira, traga a parte inferior da pilha para cima, a saída e a parada.

PHP ,40. 39 bytes

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

Experimente online!

Executar com php -nFentrada é de STDIN. Exemplo:

$ 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

Experimente online!

Faz uso de reads.

Adiante , 13 bytes

Isso funciona porque Isimplesmente verifica o fluxo de entrada para o próximo token que se parece com um número, ignorando qualquer outra coisa.

~Ilj~#
 >K+O@

Experimente online!

QuadR , 9 bytes

+/⍎⍵
\D
 

Experimente online!

+/ soma de

⍎ avaliação como APL de

⍵ o resultado de

\D substituindo cada não dígito por

 um espaço

Japonês -x , 5 bytes

f/\d+

Experimente online!

Anexo , 23 bytes

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

Experimente online!

Uma resposta mais interessante, mas indireta (37 bytes): {Sum!Reap[ReplaceF[_,/"\\d+",Sow@N]]}

Explicação

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

Isto tem a forma:

f##g=>h&x

que, quando expandido e entre parênteses, se torna:

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

##compõe duas funções juntas, =>cria uma função que mapeia a função esquerda sobre o resultado da função direita e &vincula um argumento ao lado de uma função. Para entrada _, isso é equivalente a:

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

Primeiro, então, MatchAllexecutamos caracteres digitados ( \\d+). Depois, convertemos cada execução em um número inteiro real usando a Nfunção Finalmente, tomamos a soma desses números usando Sum.

APL (NARS), caracteres 13, bytes 26

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

teste:

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

C # (Compilador interativo do Visual C #), 117 111 bytes

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

Experimente online.

Perl 5 -p , 17 bytes

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

Experimente online!

Japt v2.0a0-x , 3 bytes

Outro test drive para meu intérprete (muito WIP).

q\D

Tente

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 importação de regex

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

Experimente online!
Explicação

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

Experimente online!

Rápido, 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)}

Experimente online!

Pip , 6 bytes

$+a@XI

Trata -123como um número inteiro negativo. Experimente online!

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

Se os hífens devem ser ignorados em vez de tratados como sinais de menos, o seguinte funciona com 7 bytes :

$+a@+XD

XDé uma variável predefinida para `\d`; +XDadiciona o +modificador regex a ele, correspondendo a 1 ou mais dígitos.

Java (JDK) , 98 94 93 bytes

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

Experimente online!

-4 bytesusando em Long::newvez de Long::valueOf.
-1 byteencurtando a regex - se já removermos seqüências de caracteres vazias mais tarde, fazer alguns extras quando a divisão for boa.

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.