Stringa somma suprema

Data una stringa di input, restituisce la parola con la somma più alta di ciascuno dei suoi caratteri unicode.

Regole

• L'input deve essere separato da spazi bianchi
• Il valore di ogni parola si basa sulla somma di ciascun carattere nel codice UTF-16 della parola
• L'output dovrebbe essere la prima parola con il valore più alto (in caso di somme duplicate)

Esempi

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: "🕷️"

Questo è il golf del codice, quindi vince la risposta più breve! In bocca al lupo :)

Gelatina , 7 byte

ḲOS$ÐṀḢ

Provalo online!

Ḳ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 byte

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

Provalo online!

R , 77 69 59 58 56 44 byte

Uno sforzo di gruppo ora.

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

Provalo online!

Converti in punti di codice, somma ogni parola, nega, (stabilmente) ordina, restituisce il primo elemento.

Tecnicamente il valore di ritorno è un "vettore chiamato" il cui valore è la somma e il nome è la parola vincente, ma questo sembra seguire le regole. Se vuoi restituire la parola vincente come stringa, dovresti spendere altri 7 byte e racchiudere quanto sopra names().

05AB1E , 8 byte

ð¡RΣÇO}θ

Provalo online!

Spiegazione

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

JavaScript (ES6), 81 byte

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

Provalo online!

jq, 61 43 57 37 caratteri

( 57 39 53 33 caratteri codice + 4 caratteri opzioni della riga di comando)

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

Esecuzione di esempio:

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

Provalo online!

Pyth, 8 byte

h.MsCMZc

Suite di test

So che c'è già una risposta Pyth, ma penso che questo usi un approccio piuttosto diverso _{^{ed è anche più breve}}

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 byte

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

Provalo online!

Grazie a mazzy per un enorme -22 byte.

-splits l'input $argssu spazi bianchi, i tubi in sortcon un particolare meccanismo di ordinamento{...} e la -ubandiera di nicchia.

Qui stiamo prendendo la parola corrente $_, cambiandola toCharArra y, quindi per ogni lettera la stiamo aggiungendo alla nostra$r esult. Ciò trasforma la stringa in un numero in base alla sua rappresentazione UTF-16.

Per una volta, PowerShell con tutte le stringhe in UTF-16 in background è un salvavita!

Quindi incapsuliamo questi risultati (...)per trasformarli in un array e prendere l'ultimo [-1], ovvero il risultato più grande che è il più vicino all'inizio della frase. Funziona a causa della -ubandiera di nicchia, cioè se c'è un elemento successivo che ha lo stesso valore, viene scartato. Quella parola è rimasta sulla pipeline e l'output è implicito.

Python 3 , 55 52 byte

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

Provalo online!

• -3 byte grazie a Gigaflop per aver sottolineato che non è necessario alcun argomento nel splitmetodo.

MATLAB, 57 byte

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

Nel mio MATLAB R2016a tutti i test vengono superati, tranne per il fatto che gli emoji non vengono riprodotti correttamente. Ma i personaggi vengono restituiti correttamente

Japt -h , 8 byte

Approccio @Enigma

¸w ñ_¬xc

Provalo online!

Un altro approccio

Japt -g , 8 byte

¸ñ@-X¬xc

Provalo online!

Java (JDK) , 117 97 84 byte

-13 byte grazie @Nevay. Apparentemente non sapevo di poter usare anche varin Java.

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

Provalo online!

Rubino, 45 caratteri

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

Esecuzione di esempio:

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

Provalo online!

Ruby 2.4, 40 caratteri

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

(Non testato.)

Pyth , 33 byte

FHmCdmcd)Kczd aYu+GHmCdH0)@KxYeSY

Provalo online!

C'è quasi sicuramente un modo migliore per farlo, ma ho speso troppo per farlo, quindi lo farà.

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

Avrei passato una riduzione in un'altra mappa invece di usare il ciclo for, ma non riuscivo a farlo funzionare.

Carbone , 20 byte

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

Provalo online! Il collegamento è alla versione dettagliata del codice. Spiegazione:

≔⪪Ｓ θ

Dividere la stringa di input su spazi e assegnare a q.

≔ＥθΣＥι℅λη

Calcola la somma degli ordinali dei caratteri in ogni parola e assegna a h.

§θ⌕η⌈η

Trova l'indice della somma più alta e stampa la parola in quell'indice.

Powershell, 66 byte

Semplice. Vedi la risposta di AdmBorkBork per trovare un uso intelligente di Powershell.

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

Nota! Per correggere il lavoro con Unicode, salvare il file di script con UTF-16oUTF8 with BOM codifica.

Script di prova:

$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"
}

Produzione:

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