สตริงผลรวมสูงสุด

รับสตริงอินพุตคืนคำด้วยผลรวมสูงสุดของอักขระยูนิโค้ดแต่ละตัว

กฎระเบียบ

• อินพุตควรถูกคั่นด้วยช่องว่าง
• ค่าของแต่ละคำขึ้นอยู่กับผลรวมของตัวละครแต่ละตัวในรหัส UTF-16 ของคำ
• ผลลัพธ์ควรเป็นคำแรกที่มีค่าสูงสุด (ในกรณีที่เป็นผลรวมซ้ำ)

ตัวอย่าง

Input: "a b c d e"
Output: "e"

Input: "hello world"
Output: "world"

Input: "this is a test"
Output: "test"

Input: "àà as a test"
Output: "àà"

Input "α ää"
Output: "α"

Input: "🍬 隣隣隣"
Output: "隣隣隣"

Input: "💀 👻 🤡 🦇 🕷️ 🍬 🎃"
Output: "🕷️"

นี่คือรหัสกอล์ฟดังนั้นคำตอบที่สั้นที่สุดชนะ! โชคดี :)

เยลลี่ขนาด 7 ไบต์

ḲOS$ÐṀḢ

ลองออนไลน์!

ḲOS$ÐṀḢ
Ḳ        Split input on spaces
    ÐṀ   Give words that have maximum of:
   $       Monad:
 O           ord(each character)
  S          sum
      Ḣ  First word that gives the max ord-sum.

Perl 6 , 34 ไบต์

*.words.max(*.encode('utf16').sum)

ลองออนไลน์!

R , 77 69 59 58 56 44 ไบต์

ความพยายามของกลุ่มในขณะนี้

'^'=mapply
sort(-sum^utf8ToInt^scan(,""))[1]

ลองออนไลน์!

แปลงเป็นรหัสจุดรวมคำแต่ละคำคัดค้านเรียงลำดับ (เสถียร) ส่งคืนองค์ประกอบแรก

ในทางเทคนิคค่าส่งคืนคือ "เวกเตอร์ที่ระบุชื่อ" ซึ่งมีค่าเป็นผลรวมและชื่อเป็นคำที่ชนะ หากคุณต้องการที่จะกลับคำชนะเป็นสตริงคุณจะมีการใช้จ่ายมากขึ้น 7 names()ไบต์และห่อในข้างต้น

05AB1E , 8 ไบต์

ð¡RΣÇO}θ

ลองออนไลน์!

คำอธิบาย

ð¡          # split input on spaces
  R         # reverse the resulting list
   Σ  }     # sort by
    ÇO      # sum of character codes
       θ    # take the last

JavaScript (ES6), 81 ไบต์

s=>s.split` `.map(m=s=>m=[...s].map(c=>t+=c.charCodeAt(),t=0)&&t<=m?m:(r=s,t))&&r

ลองออนไลน์!

jq, 61 43 57 37 ตัวอักษร

( 57 39 53 33 ตัวอักษรรหัส + ตัวเลือกบรรทัดคำสั่ง 4 ตัว)

./" "|reverse|max_by(explode|add)

วิ่งตัวอย่าง:

bash-4.4$ jq -Rr './" "|reverse|max_by(explode|add)' <<< 'àà as a test'
àà

ลองออนไลน์!

Pyth, 8 ไบต์

h.MsCMZc

ชุดทดสอบ

ฉันรู้ว่ามีคำตอบของ Pyth อยู่แล้ว แต่ฉันรู้สึกว่านี่ใช้แนวทางที่แตกต่างกันไป_{^{และมันก็สั้นกว่าด้วย}}

h.MsCMZc  | Full code
h.MsCMZcQ | with implicit variables added
----------+------------------------------------
h         | The first element of
       cQ | the input chopped at whitespace
 .M       | with the maximal value for
   s      | the sum of
    CMZ   | the Unicode value of each character

PowerShell , 74 52 ไบต์

(-split$args|sort{$r=0;$_|% t*y|%{$r+=$_};$r}-u)[-1]

ลองออนไลน์!

ขอบคุณ mazzy สำหรับ whopping -22 bytes

-splitการป้อนข้อมูล$argsบนช่องว่างท่อที่sortมีกลไกการเรียงลำดับเฉพาะ{...}และ-uแฟล็ก nique

ที่นี่เรากำลังใช้คำปัจจุบัน$_เปลี่ยนเป็นtoCharArra yจากนั้นสำหรับจดหมายแต่ละฉบับที่เราเพิ่มเข้าไปใน$result ของเรา ที่เปลี่ยนสตริงเป็นตัวเลขตามการแสดง UTF-16

ครั้งหนึ่ง PowerShell ที่มีสตริงทั้งหมดเป็น UTF-16 ในพื้นหลังเป็นเครื่องมือช่วยชีวิต!

จากนั้นเราจะสรุปผลลัพธ์เหล่านั้น(...)เพื่อแปลงให้เป็นอาร์เรย์และนำผลลัพธ์สุดท้าย[-1]มากล่าวคือผลลัพธ์ที่ใหญ่ที่สุดซึ่งใกล้เคียงกับจุดเริ่มต้นของประโยคมากที่สุด สิ่งนี้ใช้งานได้เนื่องจาก-uแฟล็ก nique กล่าวคือหากมีองค์ประกอบในภายหลังที่มีค่าเท่ากันก็จะถูกลบทิ้ง คำนั้นถูกทิ้งไว้บนไพพ์ไลน์และเอาท์พุทก็เป็นนัย

Python 3 , 55 52 ไบต์

lambda s:max(s.split(),key=lambda w:sum(map(ord,w)))

ลองออนไลน์!

• -3 ไบต์ขอบคุณ Gigaflop สำหรับการชี้ให้เห็นว่าไม่จำเป็นต้องมีอาร์กิวเมนต์ในsplitวิธีการ

MATLAB, 57 ไบต์

s=strsplit(input('','s'));[Y I]=max(cellfun(@sum,s));s(I)

ใน MATLAB R2016a ของฉันการทดสอบทั้งหมดผ่านไปแล้วยกเว้นว่าอิโมจิไม่ได้แสดงผลอย่างถูกต้อง แต่ตัวละครจะถูกส่งกลับอย่างถูกต้อง

Japt -h , 8 ไบต์

วิธี @Enigma

¸w ñ_¬xc

ลองออนไลน์!

แนวทางอื่น

Japt -g , 8 ไบต์

¸ñ@-X¬xc

ลองออนไลน์!

Java (JDK) , 117 97 84 ไบต์

-13 ไบต์ขอบคุณ @Nevay เห็นได้ชัดว่าฉันไม่รู้ว่าฉันยังสามารถใช้varใน Java ได้

s->{var b="";for(var a:s.split(" "))b=a.chars().sum()>b.chars().sum()?a:b;return b;}

ลองออนไลน์!

Ruby, 45 ตัวอักษร

->s{s.split.max_by{|w|w.codepoints.reduce:+}}

วิ่งตัวอย่าง:

irb(main):001:0> ->s{s.split.max_by{|w|w.codepoints.reduce:+}}['àà as a test']
=> "àà"

ลองออนไลน์!

Ruby 2.4, 40 ตัวอักษร

->s{s.split.max_by{|w|w.codepoints.sum}}

(ยังไม่ทดลอง.)

Pyth , 33 ไบต์

FHmCdmcd)Kczd aYu+GHmCdH0)@KxYeSY

ลองออนไลน์!

มีวิธีที่ดีกว่าในการทำเช่นนี้ แต่ฉันใช้เวลามากเกินไปเพื่อทำสิ่งนี้

FH  #For every array of letters in 
  mCd   #the array of arrays of letters [['w', 'o', 'r', 'l', 'd'], ['h', 'e', 'l', 'l', 'o']]
     mcd)   #wrap that in another array [[hello"], ["world"]]
         Kczd   #split input(z) on spaces ["hello", "world"] and assign it to K for later
              aY     #append to list Y... " " silences the prints from the for loop.
                u+GH    #reduce the list of numbers by summing them    
                    mCdH    #convert each letter in the array to its int counterpart
                        0)    #the zero for the accumulator and close for loop
                          @K    #get by index the word from K
                            xY   #find the index in Y of that number
                              eSY   #sort Y, get the last (largest) number

ฉันจะผ่านการลดลงในแผนที่อื่นแทนที่จะใช้ for for loop แต่ฉันไม่สามารถใช้มันได้

ถ่าน 20 ไบต์

≔⪪Ｓ θ≔ＥθΣＥι℅λη§θ⌕η⌈η

ลองออนไลน์! การเชื่อมโยงคือการใช้รหัสเวอร์ชันอย่างละเอียด คำอธิบาย:

≔⪪Ｓ θ

qแยกสายป้อนในช่องว่างและกำหนดให้

≔ＥθΣＥι℅λη

hคำนวณผลรวมของเลขของตัวละครในแต่ละคำและกำหนดที่จะ

§θ⌕η⌈η

ค้นหาดัชนีของผลรวมสูงสุดและพิมพ์คำที่ดัชนีนั้น

Powershell, 66 ไบต์

ซื่อตรง ดูคำตอบของAdmBorkBorkเพื่อค้นพบการใช้ Powershell อย่างชาญฉลาด

-split$args|%{$s=0
$_|% t*y|%{$s+=$_}
if($s-gt$x){$w=$_;$x=$s}}
$w

บันทึก! หากต้องการแก้ไขการทำงานกับ unicode ให้บันทึกไฟล์สคริปต์ด้วยUTF-16หรือUTF8 with BOMเข้ารหัส

สคริปต์ทดสอบ:

$f = {

-split$args|%{$s=0         # split argument strings by whitespaces, for each word
$_|% t*y|%{$s+=$_}         # let $s is sum of unicode char code
if($s-gt$x){$w=$_;$x=$s}}  # if $s greater then previous one, store word and sum to variables
$w                         # return word from stored variable

}

@(
    ,("a b c d e", "e")

    ,("hello world", "world")

    ,("this is a test", "test")

    ,("àà as a test", "àà")

    ,("α ää", "α")

    ,("🍬 隣隣隣", "隣隣隣")

    ,("💀 👻 🤡 🦇 🕷️ 🍬 🎃", "🕷️")
) | % {
    $s,$e=$_
    $r=&$f $s
    "$($r-eq$e): $r"
}

เอาท์พุท:

True: e
True: world
True: test
True: àà
True: α
True: 隣隣隣
True: 🕷️