Đầu vào

Một chuỗi.

Đầu ra

Tổng của tất cả các số nguyên trong dòng.

Những ràng buộc

1≤Chiều dài của dòng≤500

Mẫu thử

Đầu vào

the 5is 108 seCONd4 a

Đầu ra

117

Giải trình

Tổng là: 5 + 108 + 4 = 117

Javascript, 34 32 byte

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

Ghép tất cả các chữ số và nối chúng với nhau bằng cách +biến nó thành 5 + 108 + 4, đánh giá kết quả.
Chỉ hoạt động trên số nguyên dương.

Đã lưu 2 byte nhờ 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 byte

{sum m:g/\d+/}

Hãy thử trực tuyến!

Khối mã ẩn danh trả về tổng của tất cả các chuỗi chữ số

05AB1E , 11 6 byte

þмS¡þO

Hãy thử trực tuyến.

Giải trình:

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

Sau khi thấy mục PowerShell, tôi có thể đánh gôn thêm.

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

Hãy thử trực tuyến!

APL (Dyalog Unicode) , 11 byte

Chức năng ẩn danh ẩn danh

+/#⍎¨∊∘⎕D⊆⊢

Hãy thử trực tuyến!

⊢ tranh luận

⊆ được phân vùng (chạy True trở thành mảnh, chạy sai là dấu phân cách) bởi

∊ thành viên
∘ của
⎕D bộ chữ số

#⍎¨ đánh giá từng cái trong không gian tên gốc

+/ Tổng

Võng mạc 0.8.2 , 8 byte

\d+
$*
1

Hãy thử trực tuyến!

• Dòng đầu tiên phù hợp với tất cả các số
• Dòng thứ hai thay thế những dòng này bằng 1 giây, lặp lại số lần nói
• Dòng cuối cùng là một trận đấu và đếm tổng số 1 giây trong chuỗi

PowerShell , 29 byte

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

Hãy thử trực tuyến!

Than , 5 byte

ＩΣ⁺ψＳ

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã. Giải thích: SumToán tử của Char than tự động trích xuất các số từ một chuỗi, tuy nhiên nếu chuỗi không chứa các ký tự không có chữ số thì thay vào đó, nó lấy tổng số, vì vậy tôi ghép một byte rỗng để tránh điều này. Kết quả sau đó được đưa trở lại chuỗi cho đầu ra ẩn.

Haskell , 50 byte

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

Hãy thử trực tuyến!

Có lẽ có một cách tốt hơn, nhưng đây là cách rõ ràng nhất.

Zsh , 21 byte

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

Hãy thử trực tuyến!

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

Thật không may, bash phàn nàn vì nó diễn giải 0108như bát phân. Zsh không (trừ khi setopt octalzeroes)

Bash, 43 byte

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

Thay thế mọi số không bằng một khoảng trắng, sau đó tính tổng chúng lại với nhau.

-5 byte nhờ GammaFunction

Python 3 , 63 59 56 byte

Tại sao không. Bắt buộc regex trả lời. Có lẽ có thể cập bến 6 bằng cách sử dụng Python 2, nhưng bất cứ điều gì. Không áp dụng nữa vì tôi đang sử dụng phương pháp tiếp cận thay vì sử dụng bản đồ.

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

Giải trình:

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

Hãy thử trực tuyến!

Java 10, 66 byte

Đây là một lambda từ Stringđến int.

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

Số nguyên âm không được hỗ trợ. Có lẽ như vậy là ổn.

Dùng thử trực tuyến

Sự nhìn nhận

• -3 byte nhờ Hiện thân của sự thiếu hiểu biết

Ruby, 32 27 ký tự

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

Sự nhìn nhận

• -5 byte nhờ Conor O 'Brien

Khối , 17 byte

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

Hãy thử trực tuyến!

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

Xem nó chạy

Một điều khá đơn giản. Itrong cubix sẽ lấy số nguyên đầu tiên trong đầu vào và đẩy nó vào ngăn xếp. Điều này có tác dụng bỏ qua tất cả các nhân vật. Phần còn lại của nó là xử lý bổ sung và phát hiện kết thúc của đầu vào.

• I! Nhập một số nguyên và kiểm tra nó cho 0
• s+q;;Nếu không bằng 0, hoán đổi TOS (lực và 0 ban đầu) và thêm. Đẩy kết quả xuống dưới cùng của ngăn xếp và làm sạch trên cùng. Quay trở lại bắt đầu.
• /i? Nếu không, chuyển hướng và thực hiện nhập ký tự để kiểm tra
• |?;/Nếu dương (ký tự) biến phải thành phản xạ, thì điều này sau đó đẩy nó trở lại qua trình kiểm tra ?và rẽ phải vào cửa sổ bật lên từ ngăn xếp, để lại 0 trên ĐKDV. IP sau đó được chuyển hướng trở lại vào vòng lặp chính.
• I>p.O@ nếu âm (kết thúc đầu vào) rẽ trái, làm đầu vào số nguyên, đưa đáy ngăn xếp lên trên cùng, đầu ra và tạm dừng.

PHP ,40 39 byte

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

Hãy thử trực tuyến!

Chạy với php -nFđầu vào là từ STDIN. Thí dụ:

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

Haskell , 43 byte

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

Hãy thử trực tuyến!

Làm cho việc sử dụng reads.

Trước , 13 byte

Điều này hoạt động vì Iđơn giản là quét luồng đầu vào cho mã thông báo tiếp theo trông giống như một số, bỏ qua mọi thứ khác.

~Ilj~#
 >K+O@

Hãy thử trực tuyến!

QuadR , 9 byte

+/⍎⍵
\D
 

Hãy thử trực tuyến!

+/ Tổng của

⍎ đánh giá là APL của

⍵ kết quả của

\D thay thế từng chữ số bằng

 một không gian

Japt -x , 5 byte

f/\d+

Hãy thử trực tuyến!

Tùy viên , 23 byte

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

Hãy thử trực tuyến!

Một câu trả lời thú vị hơn, nhưng gián tiếp (37 byte): {Sum!Reap[ReplaceF[_,/"\\d+",Sow@N]]}

Giải trình

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

Điều này có dạng:

f##g=>h&x

mà, khi được mở rộng và ngoặc đơn, trở thành:

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

##kết hợp hai hàm với nhau, =>tạo ra một hàm ánh xạ hàm trái qua kết quả của hàm phải và &liên kết một đối số với một mặt của hàm. Đối với đầu vào _, điều này tương đương với:

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

Đầu tiên, sau đó, chúng tôi MatchAllchạy các ký tự chữ số ( \\d+). Sau đó, chúng tôi chuyển đổi mỗi lần chạy thành một số nguyên thực tế bằng cách sử dụng Nhàm. Cuối cùng, chúng tôi lấy tổng của những con số này bằng cách sử dụng Sum.

APL (NARS), ký tự 13, byte 26

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

kiểm tra:

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

C # (Trình biên dịch tương tác Visual C #), 117 111 byte

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

Hãy thử trực tuyến.

Perl 5 -p , 17 byte

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

Hãy thử trực tuyến!

Japt v2.0a0 -x, 3 byte

Một ổ đĩa thử nghiệm khác cho trình thông dịch (rất WIP) của tôi.

q\D

Thử nó

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 byte

105 byte + 25 byte để nhập regex

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

Hãy thử trực tuyến!
Giải trình

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 byte

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

Hãy thử trực tuyến!

Swift, 109 byte

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

Hãy thử trực tuyến!

Pip , 6 byte

$+a@XI

Xử lý -123như một số nguyên âm. Hãy thử trực tuyến!

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

Nếu các dấu gạch nối nên được bỏ qua thay vì được coi là dấu trừ, thì sau đây hoạt động cho 7 byte :

$+a@+XD

XDlà một biến đặt trước cho `\d`; +XDthêm công cụ +sửa đổi regex cho nó, làm cho nó khớp với 1 hoặc nhiều chữ số.

Java (JDK) , 98 94 93 byte

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

Hãy thử trực tuyến!

-4 bytesbằng cách sử dụng Long::newthay vì Long::valueOf.
-1 bytebằng cách rút ngắn regex - nếu sau đó chúng tôi đã xóa các chuỗi trống, thực hiện một số bổ sung khi chia tách là tốt.

Giải thích

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.