อินพุต

สตริง.

เอาท์พุต

ผลรวมของจำนวนเต็มทั้งหมดในบรรทัด

ข้อ จำกัด

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 ไบต์ขอบคุณ 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 ไบต์

{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 ไบต์

ฟังก์ชั่น prefic นิรนาม

+/#⍎¨∊∘⎕D⊆⊢

ลองออนไลน์!

⊢ อาร์กิวเมนต์

⊆ แบ่งพาร์ติชันแล้ว (การรันของ True กลายเป็นชิ้นส่วนการรันของ False คือตัวคั่น)

∊ สมาชิก
∘ ของ
⎕D ชุดของตัวเลข

#⍎¨ ประเมินแต่ละรายการในรูทเนทรูท

+/ รวม

เรติน่า 0.8.2 , 8 ไบต์

\d+
$*
1

ลองออนไลน์!

• บรรทัดแรกตรงกับตัวเลขทั้งหมด
• บรรทัดที่สองมาแทนที่สิ่งเหล่านี้ด้วย 1s ซ้ำจำนวนครั้งที่กล่าว
• บรรทัดสุดท้ายคือการจับคู่และนับจำนวนทั้งหมด 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)

Bash, 43 ไบต์

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

แทนที่ไม่ใช่ตัวเลขด้วยช่องว่างแล้วรวมเข้าด้วยกัน

-5 ไบต์ขอบคุณ GammaFunction

Python 3 , 63 59 56 ไบต์

ทำไมจะไม่ล่ะ. คำตอบ regex บังคับ อาจเทียบท่า 6 โดยใช้ Python 2 แต่อะไรก็ได้ ไม่ได้ใช้อีกต่อไปเนื่องจากฉันใช้วิธีการประเมินแทนการใช้แผนที่

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 ไบต์

นี่คือแลมบ์ดาจากไปStringint

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

ไม่รองรับจำนวนเต็มลบ สันนิษฐานว่าไม่เป็นไร

ลองออนไลน์

กิตติกรรมประกาศ

• -3 ไบต์ต้องขอบคุณศูนย์รวมแห่งความไม่รู้

Ruby, 32 27 ตัวอักษร

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

กิตติกรรมประกาศ

• -5 ไบต์ขอบคุณConor O 'Brien

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 # Interactive Compiler), 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 ไบต์สำหรับการนำเข้า regex

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

ลองออนไลน์!

สวิฟท์, 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)}

ลองออนไลน์!

Pip , 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::newLong::valueOf
-1 byteโดยการทำให้ regex สั้นลง - ถ้าเรากำลังเอาสายว่างเปล่าออกไปในภายหลังทำ extras บางอย่างเมื่อแยกได้

อธิบาย

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.