Chaîne de somme suprême


15

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 :)


Y aura-t-il toujours au moins un espace (au moins 2 mots)?
Emigna

2
Cela aurait été plus intéressant avec ASCII au lieu d'Unicode, car plus de langues auraient pu participer. L'exigence d'un support Unicode ne semble rien ajouter au défi
Luis Mendo

1
J'ai surtout utilisé Unicode car il a des emojis lol
GammaGames

2
Étant donné que la plupart des réponses actuelles semblent utiliser la somme des unités de code UTF-8 ou UTF-32, vous devez ajouter des cas de test supplémentaires. Par exemple, "α ää" donne des résultats différents avec UTF-8 (383 <718) et UTF-16 (945> 456).
nwellnhof

1
Oui, la zone de retour à la ligne est autorisée. Onglets aussi!
GammaGames

Réponses:


3

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.

Si la spécification est assouplie pour que la saisie soit autorisée sous forme de liste de mots, alorsO§MḢị
Jonathan Allan

@JonathanAllan Où OP a-t-il dit que cela était autorisé?
dylnan

pas seulement si ...
Jonathan Allan

@JonathanAllan Ah, gotcha.
dylnan

1
@GammaGames Il serait utile que je prenne une liste de chaînes, par exemple ["abc", "def"]. Mais à ce stade, il y a beaucoup de réponses, donc je ne recommande pas d'ajouter de nouvelles méthodes de saisie
dylnan


6

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().


Y a-t-il une raison pour laquelle il y a des espaces devant le mot? Lorsque je l'exécute, "💀 👻 🤡 🦇 🕷️ 🍬 🎃"il s'imprime " 🕷️ "(avec un tas d'espaces devant lui)
GammaGames

2
@GammaGames la sortie est ce que l'on appelle un "vecteur nommé" dans R. Dans ce cas, la valeur est la somme des points de code du mot gagnant, et le nom est imprimé avec lui, qui dans ce cas est le mot gagnant lui-même. Le nom est aligné à droite sur le numéro en dessous.
ngm

Oh, bien! Il semble qu'il respecte les règles, donc je vais le permettre. Entrée cool!
GammaGames

sort(-sapply(...))est plus court de 3 octets.
Giuseppe

3
@JayCe le mapplyfait unlistgratuitement.
ngm

5

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

Wow, je suis toujours étonné par les réponses apportées dans les langues dédiées au golf!
GammaGames

Pourquoi devez-vous inverser la liste résultante? Ça va être trié de toute façon, non? Ou Rinversement la liste est-elle triée?
FireCubez

@FireCubez Pour le cas de test, àà as a testle ààet testont la même plus grande somme unicode. Donc, sans l'inverse testserait sorti au lieu de àà. Btw, Emigna, utilisez #pour enregistrer un octet. ;) EDIT: Peu importe. Je vois que cela n'emballe pas l'entrée dans une liste pour les entrées d'un seul mot. C'est malheureux.
Kevin Cruijssen

4

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!


C'est bien mieux que le code que j'ai trouvé quand j'écrivais le défi, le mien faisait ~ 200 caractères!
GammaGames


@ guest271314 ne fonctionne pas pour l'avant-dernier cas de test et certains cas extrêmes commef("😂 龘龘龘龘龘")
Shieru Asakoto

@ShieruAsakoto semble renvoyer le résultat correct ici tio.run/##y0osSyxOLsosKNHNy09J/… ? Quel est le résultat attendu "😂 龘龘龘龘龘"?
guest271314

Oh nvm 隣(\uf9f1)était celui du bloc idéogramme de compatibilité CJK à la place lol. Je pensais que c'était 隣(\u96a3)le cas dans le bloc CJK Unified Ideograph.
Shieru Asakoto

4

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!


En effet. J'ai raté cette affaire. ☹ Merci, @nimi.
manatwork du

4

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

Explication:
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

Wow, c'est vraiment précis! Merci pour l'explication!
GammaGames

4

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.


c'est intelligent. Merci. 2 moments: pourquoi pas sort -uplutôt un revers? peut être suffisant +pour convertir le nombre? (-split$args|sort{($_|% t*y|%{+$_})-join"+"|iex} -u)[-1]
mazzy

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

@mazzy Oui, merci!
AdmBorkBork

3

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.

Vous pouvez économiser 3 octets en ne passant aucun argument split(), car il se divise sur n'importe quel groupe d'espaces.
Gigaflop

2

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


2

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!


Identique à ce que j'allais poster. La nécessité de l'inversion m'énerve; aurait préféré que nous puissions sortir l'un des mots dans le cas d'une égalité.
Shaggy

@Shaggy si c'était possible, j'ai une réponse de 6 octets
Luis felipe De jesus Munoz

Même 6 octets avec lequel j'ai commencé avant de repérer cette exigence dans la spécification.
Shaggy

Je suis désolé! À l'origine, lorsque je mettais le défi en bac à sable, je pensais qu'il pouvait produire n'importe laquelle des réponses, mais je l'ai changé après un petit retour afin qu'il soit plus cohérent
GammaGames

2

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!


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

1

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é.)


1

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.


Oh boy, une réponse pyth! Merci pour l'explication, belle entrée!
GammaGames

1

Fusain , 20 octets

≔⪪S θ≔EθΣEι℅λη§θ⌕η⌈η

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

≔⪪S θ

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

≔EθΣEι℅λη

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.


1

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: 🕷️
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.