вход

Строка.

Выход

Сумма всех целых чисел в строке.

Ограничения

1≤Длина линии≤500

Образец теста

вход

the 5is 108 seCONd4 a

Выход

117

объяснение

Сумма: 5 + 108 + 4 = 117

Javascript, 34 32 байта

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

Сопоставьте все цифры и соедините их, +превратив в 5 + 108 + 4, оцените результат.
Работает только на натуральных числах.

Сохранено 2 байта благодаря Арно

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 байт

{sum m:g/\d+/}

Попробуйте онлайн!

Блок анонимного кода, который возвращает сумму всех серий цифр

05AB1E , 11 6 байтов

þмS¡þ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 байт

Увидев запись PowerShell, я смог сыграть в эту игру дальше.

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

Попробуйте онлайн!

APL (Dyalog Unicode) , 11 байт

Функция анонимного молчаливого префикса

+/#⍎¨∊∘⎕D⊆⊢

Попробуйте онлайн!

⊢ Аргумент

⊆ разделены на части (прогоны True становятся частями, прогоны False являются разделителями)

∊ членство
∘ в
⎕D наборе цифр

#⍎¨ оценивать каждый в корневом пространстве имен

+/ сумма

Сетчатка 0.8.2 , 8 байт

\d+
$*
1

Попробуйте онлайн!

• Первая строка соответствует всем числам
• Вторая строка заменяет их на 1 с, повторяется указанное количество раз
• Последняя строка совпадает и подсчитывает общее количество единиц в строке

PowerShell , 29 байт

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

Попробуйте онлайн!

Древесный уголь , 5 байтов

ＩΣ⁺ψＳ

Попробуйте онлайн! Ссылка на подробную версию кода. Объяснение: SumОператор Charcoal автоматически извлекает числа из строки, однако, если строка не содержит нецифровых символов, вместо этого она принимает цифровую сумму, поэтому я объединяю нулевой байт, чтобы избежать этого. Затем результат возвращается в строку для неявного вывода.

Haskell , 50 байтов

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

Попробуйте онлайн!

Возможно, есть лучший способ, но это самый очевидный.

Zsh , 21 байт

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

Попробуйте онлайн!

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

К сожалению, Bash жалуется, потому что он интерпретируется 0108как восьмеричное. Zsh не (если только setopt octalzeroes)

Баш, 43 байта

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

Заменяет каждое нечисловое число пробелом, а затем суммирует их вместе.

-5 байт благодаря GammaFunction

Python 3 , 63 59 56 байт

Почему бы и нет. Обязательный регулярный ответ. Вероятно, может состыковать 6 с использованием Python 2, но что угодно. Больше не применяется, так как я использую подход eval вместо использования map.

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

Объяснение:

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

Попробуйте онлайн!

Java 10, 66 байт

Это лямбда от Stringдо int.

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

Отрицательные целые числа не поддерживаются. Предположительно это нормально.

Попробуйте онлайн

Подтверждения

• -3 байта благодаря воплощению невежества

Руби, 32 27 символов

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

Подтверждения

• -5 байт благодаря Конору О'Брайену

Cubix , 17 байтов

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

Попробуйте онлайн!

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

Смотреть это беги

Довольно простой. Iв Cubix возьмет первое целое число на входе и поместит его в стек. Это дает эффект пропуска всех персонажей. Остальная часть имеет дело с дополнительным и обнаруживает конец ввода.

• I! Введите целое число и проверьте его на 0
• s+q;;Если не ноль, поменяйте местами TOS (силы и начальные 0) и добавьте. Выдвиньте результат на дно стека и очистите верх. Вернуться к началу.
• /i? Если ноль, перенаправить и сделать ввод символов, чтобы проверить
• |?;/Если положительный (символ) поворачивается направо в отражение, он затем проталкивает его обратно через шашку ?и поворачивает вправо на стопку из стека, оставляя 0 в TOS. Затем IP-адрес перенаправляется обратно в основной цикл.
• I>p.O@ если отрицательный (конец ввода) повернуть налево, сделать целочисленный ввод, довести нижнюю часть стека до вершины, вывести и остановить.

PHP ,40 39 байт

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

Попробуйте онлайн!

Запуск с php -nFвводом от STDIN. Пример:

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

Haskell , 43 байта

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

Попробуйте онлайн!

Использует reads.

Впереди 13 байтов

Это работает, потому что Iпросто сканирует входной поток для следующего токена, который выглядит как число, игнорируя все остальное.

~Ilj~#
 >K+O@

Попробуйте онлайн!

QuadR , 9 байт

+/⍎⍵
\D
 

Попробуйте онлайн!

+/ сумма

⍎ оценка как APL

⍵ результат

\D заменяя каждую не цифру

 пространство

Japt -x , 5 байт

f/\d+

Попробуйте онлайн!

Атташе , 23 байта

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

Попробуйте онлайн!

Более интересный, но косвенный ответ (37 байт): {Sum!Reap[ReplaceF[_,/"\\d+",Sow@N]]}

объяснение

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

Это имеет вид:

f##g=>h&x

который, будучи расширенным и заключенным в скобки, становится:

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

##объединяет две функции вместе, =>создает функцию, отображающую левую функцию на результат правой функции, и &привязывает аргумент к стороне функции. Для ввода _это эквивалентно:

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

Сначала мы MatchAllзапускаем цифры ( \\d+). После этого мы конвертируем каждый прогон в фактическое целое число, используя Nфункцию. Наконец, мы берем сумму этих чисел, используя Sum.

APL (NARS), символы 13, байты 26

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

тест:

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

C # (интерактивный компилятор Visual C #), 117 111 байт

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

Попробуйте онлайн.

Perl 5 -p , 17 байт

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

Попробуйте онлайн!

Japt v2.0a0 -x, 3 байта

Еще один тест-драйв для моего (очень WIP) переводчика.

q\D

Попробуй

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 байт

105 байтов + 25 байтов для импорта регулярных выражений

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

Попробуйте онлайн!
объяснение

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 байт

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

Попробуйте онлайн!

Swift, 109 байт

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

Попробуйте онлайн!

Пип , 6 байт

$+a@XI

Рассматривается -123как отрицательное целое число. Попробуйте онлайн!

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

Если дефисы следует игнорировать, а не рассматривать как знаки минус, то для 7 байтов работает следующее :

$+a@+XD

XDпредустановленная переменная для `\d`; +XDдобавляет к нему +модификатор regex , чтобы он совпадал с 1 или более цифрами.

Java (JDK) , 98 94 93 байта

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

Попробуйте онлайн!

-4 bytesиспользуя Long::newвместо Long::valueOf.
-1 byteСокращая регулярное выражение - если мы уже удаляем пустые строки позже, добавляем некоторые дополнительные функции, когда расщепление в порядке.

Разъяснения

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.