Soma números inteiros em uma sequência

11

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

Karandeep Singh
fonte
6
Olá, bem-vindo ao PPCG. Os desafios para um único idioma geralmente são desaprovados aqui no PPCG. Talvez você poderia alterá-lo para um desafio geral: dada uma cadeia, a saída da soma de todos os números na seqüência, ignorando tudo o resto (ou seja, "the 5is 108 seCONd4 a"irá resultar em 117causa 5+108+4=117). Além disso, todas as 'perguntas' aqui devem ter uma etiqueta de condição vencedora . Neste caso, suponho que seja [code-golf] (sendo a solução mais curta possível)?
Kevin Cruijssen 7/03/19
4
Parece que você postou uma pergunta semelhante no SO, o que tende a confirmar que ele não foi projetado para ser um desafio do PPCG e você está procurando um código 'utilizável' em vez de código de golfe. Eu recomendo melhorar sua pergunta original no SO, para que ela se encaixe melhor nas regras do site.
Arnauld
4
Substituímos sua postagem para atender aos nossos padrões. Sinta-se livre para editar se o resultado não combina com você.
Adám 7/03/19
2
E nesse caso, string x='-12hello3';você está contando números inteiros negativos (ou seja, -12 + 3 === -9)?
Shaun Bebbers 15/03/19

Respostas:

4

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>

Bassdrop Cumberwubwubwub
fonte
Eu acho que usar string.length no console para contar caracteres não é uma boa idéia quando ele contém caracteres de escape ... Opa, foi corrigido. Thx novamente
Bassdrop Cumberwubwubwub 07/03/19
Uma opção um pouco melhor seria console.log(f.toString().length), mas também não é 100% confiável.
Arnauld
Ou simplesmente usando TIO ...
Jo rei
4

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

Brincadeira
fonte
4

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
Kevin Cruijssen
fonte
1
Oh, ei, uso inteligente de ¡!
Erik the Outgolfer
4

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!

CT Hall
fonte
t=é suficiente aqui em vez detext
Giuseppe
Obrigado, eu sempre esqueço a correspondência parcial (e a sequência de ,,, até chegar à opção desejada).
CT Hall
3

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

Adão
fonte
3

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
Ven
fonte
2

Carvão , 5 bytes

IΣ⁺ψS

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.

Neil
fonte
2

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.

dfeuer
fonte
2

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)

GammaFunction
fonte
2

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

vityavv
fonte
1
obrigado! Eu editei meu post
vityavv 25/03/19
1

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!

Epicness
fonte
Agradável! No seu TIO, você deve usar em z == l[1]vez disso z is l[1]. O código atual pode dar falsos negativos se os números ficarem altos o suficiente.
Jakob
1

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

Jakob
fonte
1
Você pode alternar [^0-9]para \Dpor alguns bytes, você também pode mudar longe Stringpara var(embora você vai ter que mudar o tipo de retorno paraint
Personificação da ignorância
1

Ruby, 32 27 caracteres

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

Agradecimentos

GBrandt
fonte
Bem-vindo ao PPCG! Você pode usar em *?+vez de .join ?+-7 bytes. Veja ary * str
Conor O'Brien
1

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.
MickyT
fonte
1

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
640KB
fonte
1

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!

Caracol_
fonte
0

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

Adão
fonte
0

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.

Conor O'Brien
fonte
0

APL (NARS), caracteres 13, bytes 26

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

teste:

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

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.

Dados expirados
fonte
0

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
Shaggy
fonte
0

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
   }
Benjamin Urquhart
fonte
2
Eu não acho que isso esteja correto: o (único) exemplo do OP sugere que dígitos consecutivos devem formar um único número inteiro; portanto, "123" deve produzir 123, e não 6, como o seu código.
Michail
Isso é lamentável, vou revisar quando puder
Benjamin Urquhart
@Michail revised
Benjamin Urquhart
0

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!

onnoweb
fonte
0

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.

DLosc
fonte
0

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.
Sara J
fonte