Chaîne de somme suprême

Étant donné une chaîne d'entrée, renvoyez le mot avec la somme la plus élevée de chacun de ses caractères unicode.

Règles

• L'entrée doit être séparée par des espaces
• La valeur de chaque mot est basée sur la somme de chaque caractère du code UTF-16 du mot
• La sortie doit être le premier mot avec la valeur la plus élevée (en cas de doublons)

Exemples

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

C'est le golf de code, donc la réponse la plus courte l'emporte! Bonne chance :)

Gelée , 7 octets

ḲOS$ÐṀḢ

Essayez-le en ligne!

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

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

Essayez-le en ligne!

R , 77 69 59 58 56 44 44 octets

Un effort de groupe maintenant.

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

Essayez-le en ligne!

Convertir en points de code, additionner chaque mot, annuler, trier (de manière stable), retourner le premier élément.

Techniquement, la valeur de retour est un "vecteur nommé" dont la valeur est la somme et le nom est le mot gagnant, mais cela semble suivre les règles. Si vous souhaitez renvoyer le mot gagnant sous forme de chaîne, vous devrez dépenser 7 octets de plus et encapsuler ce qui précède names().

05AB1E , 8 octets

ð¡RΣÇO}θ

Essayez-le en ligne!

Explication

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

JavaScript (ES6), 81 octets

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

Essayez-le en ligne!

jq, 61 43 57 37 caractères

( 57 39 53 33 caractères code + 4 caractères options de ligne de commande)

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

Exemple d'exécution:

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

Essayez-le en ligne!

Pyth, 8 octets

h.MsCMZc

Suite de tests

Je sais qu'il y a déjà une réponse Pyth mais j'ai l'impression que cela utilise une approche assez différente _{^{et aussi elle est plus courte}}

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 octets

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

Essayez-le en ligne!

Merci à mazzy pour un énorme -22 octets.

-splits l'entrée $argssur les espaces blancs, les canalisations sortavec un mécanisme de tri particulier {...}et le -udrapeau nique.

Ici, nous prenons le mot actuel $_, le changeant toCharArra y, puis pour chaque lettre, nous l'ajoutons à notre $rrésultat. Cela transforme la chaîne en un nombre basé sur sa représentation UTF-16.

Pour une fois, PowerShell ayant toutes les chaînes en UTF-16 en arrière-plan est une bouée de sauvetage!

Nous encapsulons ensuite ces résultats (...)pour les transformer en un tableau et prendre le dernier [-1], c'est-à-dire le résultat le plus grand qui est le plus proche du début de la phrase. Cela fonctionne à cause du -udrapeau nique, c'est-à-dire que s'il y a un élément ultérieur qui a la même valeur, il est rejeté. Ce mot est laissé sur le pipeline et la sortie est implicite.

Python 3 , 55 52 octets

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

Essayez-le en ligne!

• -3 octets grâce à Gigaflop pour avoir souligné qu'aucun argument n'est nécessaire dans la splitméthode.

MATLAB, 57 octets

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

Dans mon MATLAB R2016a, tous les tests sont réussis, sauf que les emojis ne sont pas rendus correctement. Mais les caractères sont retournés correctement

Japt -h , 8 octets

Approche @Enigma

¸w ñ_¬xc

Essayez-le en ligne!

Une autre approche

Japt -g , 8 octets

¸ñ@-X¬xc

Essayez-le en ligne!

Java (JDK) , 117 97 84 octets

-13 octets merci @Nevay. Apparemment, je ne savais pas que je pouvais aussi l'utiliser varen Java.

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

Essayez-le en ligne!

Ruby, 45 caractères

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

Exemple d'exécution:

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

Essayez-le en ligne!

Ruby 2.4, 40 caractères

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

(Non testé.)

Pyth , 33 octets

FHmCdmcd)Kczd aYu+GHmCdH0)@KxYeSY

Essayez-le en ligne!

Il y a presque certainement une meilleure façon de le faire, mais j'y ai trop dépensé, donc cela fera l'affaire.

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

J'aurais passé une réduction dans une autre carte au lieu d'utiliser la boucle for, mais je n'ai pas pu faire fonctionner cela.

Fusain , 20 octets

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

Essayez-le en ligne! Le lien est vers la version détaillée du code. Explication:

≔⪪Ｓ θ

Fractionnez la chaîne d'entrée sur les espaces et affectez-la à q.

≔ＥθΣＥι℅λη

Calculez la somme des ordinaux des caractères de chaque mot et attribuez-la à h.

§θ⌕η⌈η

Trouvez l'index de la somme la plus élevée et imprimez le mot à cet index.

Powershell, 66 octets

Simple. Voir la réponse d' AdmBorkBork pour trouver une utilisation intelligente de Powershell.

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

Remarque! Pour corriger le travail avec unicode, enregistrez votre fichier de script avec UTF-16ou UTF8 with BOMencodage.

Script de test:

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

Production:

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