Cadena de suma suprema

Dada una cadena de entrada, devuelve la palabra con la suma más alta de cada uno de sus caracteres unicode.

Reglas

• La entrada debe estar separada por espacios en blanco
• El valor de cada palabra se basa en la suma de cada carácter en el código UTF-16 de la palabra.
• La salida debe ser la primera palabra con el valor más alto (en caso de sumas duplicadas)

Ejemplos

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

Este es el código de golf, por lo que gana la respuesta más corta. Buena suerte :)

Jalea , 7 bytes

ḲOS$ÐṀḢ

Pruébalo en línea!

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

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

Pruébalo en línea!

R , 77 69 59 58 56 44 bytes

Un esfuerzo grupal ahora.

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

Pruébalo en línea!

Convierte en puntos de código, suma cada palabra, niega, ordena (establemente), devuelve el primer elemento.

Técnicamente, el valor de retorno es un "vector nombrado" cuyo valor es la suma y el nombre es la palabra ganadora, pero esto parece seguir las reglas. Si desea devolver la palabra ganadora como una cadena, tendría que gastar 7 bytes más y envolver lo anterior names().

05AB1E , 8 bytes

ð¡RΣÇO}θ

Pruébalo en línea!

Explicación

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

JavaScript (ES6), 81 bytes

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

Pruébalo en línea!

jq, 61 43 57 37 caracteres

( 57 39 53 código de 33 caracteres + opciones de línea de comando de 4 caracteres)

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

Ejecución de muestra:

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

Pruébalo en línea!

Pyth, 8 bytes

h.MsCMZc

Banco de pruebas

Sé que ya hay una respuesta de Pyth, pero siento que esto usa un enfoque bastante diferente _{^{y también es muuuucho más corto}}

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 bytes

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

Pruébalo en línea!

Gracias a mazzy por la friolera de -22 bytes.

-splits la entrada $argsen espacios en blanco, canaliza eso sortcon un mecanismo de clasificación particular {...}y la -ubandera de nique.

Aquí estamos tomando la palabra actual $_, cambiándola toCharArra y, luego para cada letra la estamos agregando a nuestro $result. Eso convierte la cadena en un número basado en su representación UTF-16.

Por una vez, ¡PowerShell con todas las cadenas en UTF-16 en segundo plano es un salvavidas!

Luego encapsulamos esos resultados (...)para transformarlos en una matriz y tomar el último [-1], es decir, el resultado más grande que es el más cercano al comienzo de la oración. Esto funciona debido a la -ubandera de nique, es decir, si hay un elemento posterior que tiene el mismo valor, se descarta. Esa palabra se deja en la tubería y la salida es implícita.

Python 3 , 55 52 bytes

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

Pruébalo en línea!

• -3 bytes gracias a Gigaflop por señalar que no se necesita ningún argumento en el splitmétodo.

MATLAB, 57 bytes

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

En mi MATLAB R2016a se pasan todas las pruebas, excepto que los emojis no se representan correctamente. Pero los caracteres se devuelven correctamente

Japt -h , 8 bytes

Enfoque @Enigma

¸w ñ_¬xc

Pruébalo en línea!

Otro enfoque

Japt -g , 8 bytes

¸ñ@-X¬xc

Pruébalo en línea!

Java (JDK) , 117 97 84 bytes

-13 bytes gracias @Nevay. Aparentemente no sabía que también puedo usar varen Java.

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

Pruébalo en línea!

Ruby, 45 caracteres.

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

Ejecución de muestra:

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

Pruébalo en línea!

Ruby 2.4, 40 caracteres

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

(No probado)

Pyth , 33 bytes

FHmCdmcd)Kczd aYu+GHmCdH0)@KxYeSY

Pruébalo en línea!

Es casi seguro que hay una mejor manera de hacer esto, pero gasté demasiado en eso, así que esto funcionará.

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

Hubiera pasado una reducción a otro mapa en lugar de usar el bucle for, pero no pude hacer que eso funcionara.

Carbón de leña , 20 bytes

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

Pruébalo en línea! El enlace es a la versión detallada del código. Explicación:

≔⪪Ｓ θ

Dividir la cadena de entrada en espacios y asignar a q.

≔ＥθΣＥι℅λη

Calcular la suma de los ordinales de los caracteres en cada palabra y asignar a h.

§θ⌕η⌈η

Encuentre el índice de la suma más alta e imprima la palabra en ese índice.

Powershell, 66 bytes

Sencillo. Vea la respuesta de AdmBorkBork para encontrar un uso inteligente de Powershell.

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

¡Nota! Para corregir el trabajo con Unicode, guarde su archivo de script con UTF-16o UTF8 with BOMcodificación.

Script de prueba:

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

Salida:

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