Contribution

Un string.

Production

La somme de tous les entiers de la ligne.

Contraintes

1≤Longueur de ligne≤500

Exemple de cas de test

Contribution

the 5is 108 seCONd4 a

Production

117

Explication

La somme est: 5 + 108 + 4 = 117

Javascript, 34 32 octets

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

Faites correspondre tous les chiffres et joignez-les en les +transformant en 5 + 108 + 4, évaluez le résultat.
Fonctionne uniquement sur des entiers positifs.

Enregistré 2 octets grâce à 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 octets

{sum m:g/\d+/}

Essayez-le en ligne!

Bloc de code anonyme qui renvoie la somme de toutes les séries de chiffres

05AB1E , 11 6 octets

þмS¡þO

Essayez-le en ligne.

Explication:

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

Après avoir vu l'entrée PowerShell, j'ai pu jouer au golf plus loin.

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

Essayez-le en ligne!

APL (Dyalog Unicode) , 11 octets

Fonction prefic tacite anonyme

+/#⍎¨∊∘⎕D⊆⊢

Essayez-le en ligne!

⊢ l'argument

⊆ partitionné (les séries de True deviennent des morceaux, les séries de False sont des séparateurs) par

∊ l' adhésion
∘ de
⎕D l'ensemble des chiffres

#⍎¨ évaluer chacun dans l'espace de noms racine

+/ somme

Retina 0.8.2 , 8 octets

\d+
$*
1

Essayez-le en ligne!

• La première ligne correspond à tous les nombres
• La deuxième ligne les remplace par 1, répété ledit nombre de fois
• La dernière ligne est une correspondance et compte le nombre total de 1 dans la chaîne

PowerShell , 29 octets

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

Essayez-le en ligne!

Fusain , 5 octets

ＩΣ⁺ψＳ

Essayez-le en ligne! Le lien est vers la version détaillée du code. Explication: l' Sumopérateur de Charcoal extrait automatiquement les nombres d'une chaîne, mais si la chaîne ne contient pas de caractères non numériques, alors il prend la somme numérique, donc je concatène un octet nul pour éviter cela. Le résultat est ensuite converti en chaîne pour une sortie implicite.

Haskell , 50 octets

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

Essayez-le en ligne!

Il y a probablement une meilleure façon, mais c'est la plus évidente.

Zsh , 21 octets

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

Essayez-le en ligne!

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

Malheureusement, bash se plaint car il interprète 0108comme octal. Zsh ne le fait pas (sauf setopt octalzeroes)

Bash, 43 octets

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

Remplace chaque non-nombre par un espace, puis les additionne ensemble.

-5 octets grâce à GammaFunction

Python 3 , 63 59 56 octets

Pourquoi pas. Réponse regex obligatoire. Pourrait probablement ancrer 6 en utilisant Python 2, mais peu importe. Ne s'applique plus puisque j'utilise une approche eval au lieu d'utiliser la carte.

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

Explication:

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

Essayez-le en ligne!

Java 10, 66 octets

Ceci est un lambda de Stringà int.

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

Les entiers négatifs ne sont pas pris en charge. Vraisemblablement, ça va.

Essayez-le en ligne

Remerciements

• -3 octets grâce à l' incarnation de l'ignorance

Ruby, 32 27 caractères

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

Remerciements

• -5 octets grâce à Conor O 'Brien

Cubix , 17 octets

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

Essayez-le en ligne!

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

Regardez-le courir

Un assez simple. Idans cubix prendra le premier entier dans l'entrée et le poussera vers la pile. Cela a pour effet de sauter tous les personnages. Le reste traite de l'apport supplémentaire et détecte la fin de l'entrée.

• I! Entrez un entier et testez-le pour 0
• s+q;;Si ce n'est pas zéro, échangez TOS (forces et 0 initial) et ajoutez. Poussez le résultat au bas de la pile et nettoyez le haut. Revenez au début.
• /i? Si zéro, redirigez et faites une entrée de caractère pour vérifier
• |?;/Si positif (caractère), tournez à droite dans un reflet, cela le repousse à travers le vérificateur ?et tourne à droite sur la pop de la pile, laissant 0 sur TOS. L'IP est ensuite redirigée vers la boucle principale.
• I>p.O@ si négatif (fin d'entrée) tourner à gauche, faire une entrée entière, amener le bas de la pile en haut, sortir et arrêter.

PHP ,40 39 octets

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

Essayez-le en ligne!

L' php -nFexécution avec entrée provient de STDIN. Exemple:

$ echo the 5is 108 seCONd4 a | php -nF sumint.php    
117

Haskell , 43 octets

f s|[(n,r)]<-reads s=n+f r|h:t<-s=f t|1>0=0

Essayez-le en ligne!

Fait usage de reads.

Avant , 13 octets

Cela fonctionne parce Ique balaye simplement le flux d'entrée pour le prochain jeton qui ressemble à un nombre, en ignorant toute autre chose.

~Ilj~#
 >K+O@

Essayez-le en ligne!

QuadR , 9 octets

+/⍎⍵
\D
 

Essayez-le en ligne!

+/ somme de

⍎ évaluation en tant qu'APL

⍵ Le résultat de

\D remplacer chaque non-chiffre par

 un espace

Japt -x , 5 octets

f/\d+

Essayez-le en ligne!

Attaché , 23 octets

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

Essayez-le en ligne!

Une réponse plus intéressante, mais indirecte (37 octets): {Sum!Reap[ReplaceF[_,/"\\d+",Sow@N]]}

Explication

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

Cela a la forme:

f##g=>h&x

qui, une fois développé et entre parenthèses, devient:

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

##compose deux fonctions ensemble, =>crée une fonction mappant la fonction gauche sur le résultat de la fonction droite et &lie un argument à un côté d'une fonction. Pour l'entrée _, cela équivaut à:

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

D'abord, ensuite, nous MatchAllexécutons des caractères numériques ( \\d+). Après, nous convertissons chaque exécution en un entier réel en utilisant la Nfonction. Enfin, nous prenons la somme de ces nombres en utilisant Sum.

APL (NARS), caractères 13, octets 26

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

tester:

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

C # (Visual C # Interactive Compiler), 117 111 octets

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

Essayez-le en ligne.

Perl 5 -p , 17 octets

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

Essayez-le en ligne!

Japt v2.0a0 -x, 3 octets

Un autre essai routier pour mon interprète (très-WIP).

q\D

Essayez-le

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 octets

105 octets + 25 octets pour l'importation d'expressions régulières

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

Essayez-le en ligne!
Explication

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 octets

	S =INPUT
D	S SPAN('0123456789') . N REM . S	:F(O)
	O =O + N	:(D)
O	OUTPUT =O
END

Essayez-le en ligne!

Swift, 109 octets

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

Essayez-le en ligne!

Pip , 6 octets

$+a@XI

Traite -123comme un entier négatif. Essayez-le en ligne!

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

Si les tirets doivent être ignorés plutôt que traités comme des signes moins, alors ce qui suit fonctionne pour 7 octets :

$+a@+XD

XDest une variable prédéfinie pour `\d`; +XDlui ajoute le +modificateur regex , le faisant correspondre à 1 ou plusieurs chiffres.

Java (JDK) , 98 94 93 octets

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

Essayez-le en ligne!

-4 bytesen utilisant Long::newau lieu de Long::valueOf.
-1 byteen raccourcissant l'expression régulière - si nous supprimons déjà les chaînes vides plus tard, faire quelques extras lors du fractionnement est très bien.

Expliqué

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.