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

11

вход

Строка.

Выход

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

Ограничения

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

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

вход

the 5is 108 seCONd4 a

Выход

117

объяснение

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

code-golf  string  number  integer  parsing 
— Карандип Сингх
источник
6
Привет, добро пожаловать в PPCG. Проблемы с одним языком обычно осуждаются здесь, в PPCG. Может быть, вы могли бы изменить его на общий вызов: при заданной строке выведите сумму всех чисел в строке, игнорируя все остальное (т.е. "the 5is 108 seCONd4 a"приведет к тому, 117что 5+108+4=117). Кроме того, каждый «вопрос» здесь должен иметь тег условия победы . В этом случае я предполагаю, что это [code-golf] (являясь кратчайшим возможным решением)?
— Кевин Круйссен
4
Похоже, что вы опубликовали аналогичный вопрос о SO, который имеет тенденцию подтверждать, что он не был спроектирован как вызов PPCG, и вы ищете «полезный» код, а не гольф-код. Я бы порекомендовал вместо этого улучшить исходный вопрос о SO, чтобы он лучше соответствовал правилам сайта.
— Арно
4
Я пересмотрел ваш пост, чтобы соответствовать нашим стандартам. Не стесняйтесь редактировать, если результат вас не устраивает.
— адам
4
— mbomb007
2
Как насчет этого случая string x='-12hello3';вы считаете отрицательные целые числа (т.е. -12 + 3 === -9)?
— Шон Бебберс

Ответы:

4

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>
Развернуть фрагмент

— Bassdrop Cumberwubwubwub
источник
Я предполагаю, что использование string.length в консоли для подсчета символов не очень хорошая идея, если в нем содержатся escape-символы ... К сожалению, исправлено. Еще раз
— спасибо
Немного лучший вариант console.log(f.toString().length), но он не на 100% надежен.
— Арно
Или просто с помощью TIO ...
— Джо Кинг
4

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
— Кевин Круйссен
источник
1
О, эй, умное использование ¡!
— Эрик Outgolfer
4

R , 64 48 45 байт

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

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

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

— КТ Холл
источник
t=здесь достаточно, а неtext
— Джузеппе
Спасибо, я всегда забываю о частичном сопоставлении (и строку ,,, пока вы не получите нужный вариант).
— CT Hall
3

APL (Dyalog Unicode) , 11 байт

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

+/#⍎¨∊∘⎕D⊆⊢

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

⊢ Аргумент

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

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

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

+/ сумма

— Адам
источник
3

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

\d+
$*
1

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

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

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

ＩΣ⁺ψＳ

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

— Нил
источник
2

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)

— GammaFunction
источник
1

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

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

— Эпичность
источник
Ницца! В вашем TIO вы должны использовать z == l[1]вместо, z is l[1]хотя. Текущий код может давать ложные отрицания, если числа становятся достаточно высокими.
— Якоб
1

Java 10, 66 байт

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

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

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

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

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

— Jakob
источник
1
Вы можете переключиться [^0-9]на \Dнесколько байтов, также вы можете переключиться longи Stringна var(хотя вам придется изменить тип возвращаемого значения наint
— Embodiment of Ignorance
1

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@ если отрицательный (конец ввода) повернуть налево, сделать целочисленный ввод, довести нижнюю часть стека до вершины, вывести и остановить.
— MickyT
источник
0

Атташе , 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.

— Конор О'Брайен
источник
0

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

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

тест:

  f←{+/⍎¨⍵⊂⍨⍵∊⎕D}
  f 'the 5is 108 seCONd4 a'
117
— RosLuP
источник
0

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
— мохнатый
источник
0

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
   }
— Бенджамин Уркхарт
источник
2
Я не думаю, что это правильно: (единственный) пример OP предполагает, что последовательные цифры должны образовывать одно целое число, поэтому «123» должно выдавать 123, а не 6, как ваш код.
— Михаил
Это прискорбно, я пересмотрю, когда смогу
— Бенджамин Уркхарт
@Michail исправлено
— Бенджамин Уркхарт
0

Пип , 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 или более цифрами.

— DLosc
источник
0

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.
— Сара Дж
источник
Используя наш сайт, вы подтверждаете, что прочитали и поняли нашу Политику в отношении файлов cookie и Политику конфиденциальности.
Licensed under cc by-sa 3.0 with attribution required.