задача

Задача очень простая. Учитывая непустую строку, содержащую цифры , прописные и строчные буквы , выведите сумму оставшихся чисел. Например:

a1wAD5qw45REs5Fw4eRQR33wqe4WE

Фильтрация всех писем приведет к:

 1   5  45   5  4    33   4

Сумма этих чисел 1 + 5 + 45 + 5 + 4 + 33 + 4 = 97. Так что выход будет 97.

Тестовые случаи

a > 0
0 > 0
5 > 5
10 > 10
a0A > 0
1a1 > 2
11a1 > 12
4dasQWE65asAs5dAa5dWD > 79
a1wAD5qw45REs5Fw4eRQR33wqe4WE > 97

Это код-гольф , поэтому выигрывает представление с наименьшим количеством байтов!

GS2, 2 байта

Wd

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

Как это устроено

W     Read all numbers.
      For input x, this executes map(int, re.findall(r'-?\d+', x)) internally.
 d    Compute their sum.

Лабиринт , 8 байт

Возьми это, Пиф ...

?+
;,;!@

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

объяснение

Обычный праймер (украден у Sp3000):

• Лабиринт 2D и основанный на стеке. Стеки имеют бесконечное количество нулей на дне.
• Когда указатель инструкции достигает соединения, он проверяет вершину стека, чтобы определить, куда повернуть дальше. Отрицательный слева, ноль вперед и положительный справа.

Здесь очень удобно то, что у Labyrinth есть две разные команды ввода, ,и ?. Первый читает один байт из STDIN или -1в EOF. Последний читает целое число из STDIN. Он пропускает все, что не является числом, а затем читает первое найденное десятичное число. Этот возвращается 0в EOF, поэтому мы не можем использовать его для надежной проверки EOF здесь.

Основным циклом программы является этот компактный бит:

?+
;,

Когда ?мы читаем целое число (игнорируя все буквы), +мы добавляем его к промежуточной сумме (которая начинается как один из неявных нулей в нижней части стека). Затем мы читаем другой символ, ,чтобы проверить EOF. Пока мы не в EOF, прочитанный символ будет буквой с положительным символьным кодом, поэтому IP поворачивается направо (с его точки зрения, то есть на запад). ;сбрасывает символ, потому что он нам не нужен, и затем мы снова входим в цикл.

После того, как мы в EOF, ,толкает -1так IP повороты налево ( на восток) вместо этого. ;снова отбрасывает это -1, !печатает промежуточный итог как целое число и @завершает программу.

CJam, 13 байтов

Исправлена ​​работа с вводом без чисел благодаря Денису! Также сохранен байт, заменив массив букв на массив ASCII выше кодовой точки 64. И затем еще один байт, сохраненный Денисом!

q_A,s-Ser~]1b

Простая транслитерация от букв к пробелам, затем eval и sum. Попробуйте онлайн .

MATL , 8 байт

1Y4XXXUs

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

1Y4      % predefined literal: '\d+'
XX       % implicit input. Match regular expression. Returns a cell array of strings
         % representing numbers
XU       % convert each string to a double. Returns a numeric array
s        % sum of numeric array

Сетчатка ,22 11

\d+
$0$*1
1

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

11 байтов (!) Сэкономлено благодаря Мартину!

В основном, просто десятичные в одинарные, а затем считать 1с.

Japt, 2 байта

Nx

Проверьте это онлайн!

Как это устроено

N    // Implicit: N = (parse input for numbers, "strings", and [arrays])
x    // Sum. Implicit output.

JavaScript ES6, 35 байт

s=>eval(s.replace(/\D+/g,'+')+'.0')

Как это устроено

Сначала мы заменим каждую строку не цифр "+". Есть четыре основных способа, которыми это может закончиться:

1. 1b23c456   => 1+23+456
2. a1b23c456  => +1+23+456
3. 1b23c456d  => 1+23+456+
4. a1b23c456d => +1+23+456+

Случаи 1 и 2 уже решены. Но нам как-то нужно исправить последнее, +чтобы оно не вызывало ошибку. Мы могли бы удалить его .replace(/\+$,""), но это слишком дорого. Мы могли бы добавить 0к концу, но это повлияет на последнее число, если строка не заканчивается на +. Компромисс состоит в добавлении .0, которое само по себе является действительным числом и не влияет на значение других целых чисел.

Вот несколько других значений, которые также будут работать:

.0
-0
 +0
-""
-[]
0/10
0e-1
.1-.1

Альтернативная версия, также 35 байтов

s=>s.replace(/\d+/g,d=>t+=+d,t=0)|t

Другая альтернативная версия, 36 байт

s=>s.split(/\D/).map(d=>t+=+d,t=0)|t

Pyth, 12 11 10 байт

ssM:z"\D"3

    z        autoinitialized to input()
   : "\D"3   split on non-digits
 sM          convert all elements of resulting array to ints
s            sum

К счастью, s(преобразовать в int) возвращает 0при применении к пустой строке, поэтому мне не нужно беспокоиться о том, что split("a1b", "\D+")возвращает ["", "1", ""]. Точно так же split("a", "\D+")возвращается ["", ""].

Это даже позволяет мне разделять каждую цифру отдельно, так как 1 + 0 + 0 + 0 + 0 + 2это то же самое, что и 1 + 2.

Спасибо Томасу Ква за байт!

Gol> <> , 4 байта

iEh+

Так коротко, мне нужен фиктивный текст ...

Perl 6 , 18 байт

{[+] .comb(/\d+/)}
{[+] .split(/\D/)}

Использование:

my &code = {[+] .comb(/\d+/)}

say code 'a'; # 0
say code '0'; # 0
say code '5'; # 5
say code '10'; # 10
say code 'a0A'; # 0
say code '1a1'; # 2
say code '11a1'; # 12
say code '4dasQWE65asAs5dAa5dWD'; # 79
say code 'a1wAD5qw45REs5Fw4eRQR33wqe4WE'; # 97

Желе, 6 байт

&-ṣ-ḌS

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

Как это устроено

&-ṣ-ḌS  Main link. Input: L (string)

&-      Take the bitwise AND of L's characters and -1.
        This attempts to cast to int, so '0' & -1 -> 0 & -1 -> 0.
        On failure, it returns the integer argument (if any), so 'a' & -1 -> -1.
  ṣ-    Split the resulting list at occurrences of -1.
    Ḍ   Convert each chunk from decimal to integer. In particular, [] -> 0.
     S  Compute the sum of the results.

Perl, 21 + 1 = 22 байта

$_=eval join"+",/\d+/g

Требуется -pфлаг:

$ perl -pe'$_=eval join"+",/\d+/g' <<< 'a1wAD5qw45REs5Fw4eRQR33wqe4WE'
97

Юлия, 35 байт

s->sum(parse,matchall(r"\d+","0"s))

Это анонимная функция, которая принимает строку и возвращает целое число. Чтобы вызвать его, присвойте его переменной.

Мы используем, matchallчтобы получить массив, состоящий из совпадений регулярного выражения \d+, которые являются просто целыми числами в строке. Мы должны прикрепить 0 к началу строки, иначе для таких случаев, как "a", мы будем суммировать по пустому массиву, что вызывает ошибку. Затем мы применяем parseк каждому совпадению строки, которое преобразуется в целые числа, и берем сумму.

PHP, 64 байта

<?php preg_match_all("/\d+/",$argv[1],$a);echo array_sum($a[0]);

Запустите это как

php -f filterOutAndAddUp.php <test_case>

https://eval.in/517817

Javascript, 32 39 байт

s=>eval((s.match(/\d+/g)||[0]).join`+`)

f=
s=>eval((s.match(/\d+/g)||[0]).join`+`)

F=s=>document.body.innerHTML+='<pre>f(\''+s+'\') -> '+f(s)+'\n</pre>'

F('a')
F('5')
F('10')
F('1a1')
F('11a1')
F('4dasQWE65asAs5dAa5dWD')
F('a1wAD5qw45REs5Fw4eRQR33wqe4WE')

Mathematica, 51 байт

Total@ToExpression@StringCases[#,DigitCharacter..]&

Поймать неправильный конец многословных встроенных Mathematica. 1 байт с помощью @DavidC

R, 46 43 байта

sum(strtoi(strsplit(scan(,''),'\\D')[[1]]))

объяснение

                    scan(,'')                  # Take the input string
           strsplit(         ,'\\D')           # Returns list of all numeric parts of the string
                                    [[1]]      # Unlists to character vector
    strtoi(                              )     # Converts to numeric vector
sum(                                      )    # Sums the numbers

Пробный прогон

> sum(strtoi(strsplit(scan(,''),'\\D')[[1]]))
1: a1wAD5qw45REs5Fw4eRQR33wqe4WE
2: 
Read 1 item
[1] 97

Изменить: Заменено [^0-9]на \\D.

PowerShell, 28 26 байт

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

Принимает ввод, $argsзатем выполняет регулярное выражение, -replaceчтобы поменять буквы +0, а затем направляет их к iex(сокращение Invoke-Expressionи аналогично eval).

PS C:\Tools\Scripts\golfing> .\filter-out-and-add-up.ps1 'a1wAD5qw45REs5Fw4eRQR33wqe4WE'
97

альтернативно

Если вы в порядке с каким-то посторонним выводом, вы можете сделать следующее, также с 28 26 байтами:

$args-split"\D"|measure -s

Это займет входную строку $argsи -splitее в массиве из-строк на нерабочих числах (удаление их в процессе). Например, 1a2b33превратится в ['1','2','33']. Мы передаем это Measure-Objectс -Sumпараметром. Вывод будет выглядеть следующим образом:

PS C:\Tools\Scripts\golfing> .\filter-out-and-add-up.ps1 'a1wAD5qw45REs5Fw4eRQR33wqe4WE'

Count    : 21
Average  : 
Sum      : 97
Maximum  : 
Minimum  : 
Property : 

_{Edit - durr, не нужно использовать [ ]регулярное выражение, так как я больше не указываю список возможных совпадений ...}

Гема, 39 знаков

<D>=@set{s;@add{${s;};$0}}
?=
\Z=${s;0}

Образец прогона:

bash-4.3$ gema '<D>=@set{s;@add{${s;};$0}};?=;\Z=${s;0}' <<< 'a1wAD5qw45REs5Fw4eRQR33wqe4WE'

Серьезно, 13 байтов

,ú;û+@s`≈`MΣl

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

Объяснение:

,ú;û+@s`≈`MΣl
,              push input
 ú;û+          push "abc...zABC...Z" (uppercase and lowercase English letters)
     @s        split on letters
       `≈`M    convert to ints
           Σ   sum
            l  length (does nothing to an integer, pushes 0 if an empty list is left, in the case where the string is all letters)

Java, 70 байт

s->{int n=0;for(String i:s.split("\\D+"))n+=Long.valueOf(i);return n;}

TI-Basic, 106 байт

Работает на калькуляторах ТИ-83/84!

Input Str1
"{0,→Str2
Str1+"N0→Str1
For(I,1,length(Ans
sub(Str1,I,1
If inString("0123456789",Ans
Then
Str2+Ans→Str2
Else
If ","≠sub(Str2,length(Str2),1
Str2+","→Str2
End
End
sum(expr(Ans

Clojure / ClojureScript, 35 байт

#(apply +(map int(re-seq #"\d+"%)))

R, 50 байтов

Требуется gsubfnустановить

sum(gsubfn::strapply(scan(,''),'\\d+',strtoi)[[1]])

Использует, strtoiчтобы привести к числовому

Рубин 45 байтов

$*[0].split(/[a-z]/i).map(&:to_i).inject 0,:+

(Первая попытка на работе, вернемся к этому)

POSIX sh + tr + dc, 27 25 байт

dc -e "0d`tr -sc 0-9 +`p"

Преобразует любой набор нецифровых чисел (включая завершающий символ новой строки) в +оператор, помещает два ноля в стек (в случае, если ввод начинается с нецифрового числа), добавляет их все и печатает результат. Возможно, в нижней части стека остался дополнительный ноль, но нас это не волнует.

Луа, 51 байт

Довольно коротко на этот раз! Даже короче, чем Java! Входные данные должны быть аргументом командной строки, чтобы он работал.

a=0 arg[1]:gsub("%d+",function(c)a=a+c end)print(a)

Ungolfed

a=0                 -- Initialize the sum at 0
arg[1]:gsub("%d+",  -- capture each group of digits in the string
  function(c)       -- and apply an anonymous function to each of them
  a=a+c             -- sums a with the latest group captured
end)               
print(a)            -- output a

Утилиты Bash + GNU, 29

grep -Eo [0-9]+|paste -sd+|bc

Если требуется поддержка ввода без номеров (например, a ), то мы можем сделать это:

Утилиты Bash + GNU, 38

1 байт сохранен благодаря @TobySpeight.

(grep -Eo [0-9]+;echo 0)|paste -sd+|bc

Python 2, 70 байт

Я помещаю ответ Python просто для удовольствия.

import re
j=0
for i in map(int,re.findall('\d+',input())):j+=i
print j

Очень просто и использует регулярные выражения, чтобы найти все числа на входе. Попробуйте онлайн!

Oracle SQL 11.2, 105 байт

SELECT NVL(SUM(TO_NUMBER(COLUMN_VALUE)),0)FROM XMLTABLE(('"'||regexp_replace(:1,'[a-zA-Z]','","')||'"'));

Регулярное выражение преобразует буквенные символы в символы ','

XMLTABLE создает одну строку для каждого элемента в строке, используя ',' в качестве разделителя.

Суммируйте строки, чтобы получить результат.

NVL необходим для учета строки без цифры.