String with the smallest sum of ASCII values

Question

Description

In this challenge, you need to write a function that takes in a list of strings and returns the smallest string based on their ASCII value. You should assume that the input list contains only lowercase alphabetical strings.

Test Cases

["a", "b", "c"] => "a"
["hello", "world", "code"] => "code"
["aaa", "aa", ""] => ""
["cat", "bat", "rat"] => "bat"
["zab", "xyz", "abcd"] => "zab"

Write the function in as few bytes as possible. The code itself can be a function, process or anything provided that it gives the desired output. Use of other ASCII characters like big or small letters, with space function must be supported.

• Seggan: "Smallest string based on ASCII value" as in the string with the smallest sum of ASCII values?
• aitzazisstuffed: @Seggan precisely correct, the individual ASCII values are added
• Seggan: I suggest you clarify that in the post
• The Thonnu: Suggested test case: ["zab", "xyz", "abcd"] => "zab"
• Luis Mendo: I suggest you remove the requirement of supporting extended ASCII. With standard ASCII the logic of the algorithm is probably the same, and it allows more languages to participate

Answer 1

05AB1E, 5 bytes

ΣÇO}н

Try it online!

Explanation

ΣÇO}н # Implicit input
Σ } # Sort by:
 Ç # ASCII values
 O # Sum
 н # First item
 # Implicit output

Answer 2

Factor, 22 bytes

[ [ sum ] infimum-by ]

Try it online!

Answer 3

Java (JDK), 57 bytes

l->l.stream().min((a,b)->a.chars().sum()-b.chars().sum())

Try it online!

Takes input as a List<String> and returns an Optional<String>.

Answer 4

BQN, (削除) 18 (削除ここまで) 16 bytes

-2 from Dominic van Essen for replacing '0' with @.

{x⊑ ̃⊑⍒(+ ́@⊸-) ̈x}

Try it online!

Explanation

{x⊑ ̃⊑⍒(+ ́@⊸-) ̈x} 
{ ̈x} 1. For each string in the (monadic) input x
{ ( @⊸-) } 2a. convert the string to (negative) its unicode representation...
{ (+ ́ ) } 2b. and perform a sum reduction.
{ ⍒( ) } 3. return descending-sorted indices.
{ ⊑ } 4. take the first.
{x⊑ ̃ } 5. take this index into the input x where ̃ "flips" the next function.

• Dominic van Essen: Save 2 bytes by changing '0' to @...
• Jacobus Smit: Cheers, I didn't know about @ :s

Answer 5

Vyxal, (削除) 5 (削除ここまで) 4 bytes

‡C∑P

Try it Online!

-1 thanks to @mathcat

Explanation

‡C∑P # Implicit input
‡ P # Minimum by:
 C # ASCII values
 ∑ # Sum
 # Implicit output

Old:

C∑)ṡh # Implicit input
 )ṡ # Sort by:
C # ASCII values
 ∑ # Sum
 h # First item
 # Implicit output 

• math scat: 4 bytes
• The Thonnu: @mathcat thanks, updated

Answer 6

C (gcc), 92 bytes

f(s,t,u,i,c)char**s,*t,*u;{for(i=~0,u=0;t=*s;c<i+0U?u=*s,i=c:0,s++)for(c=0;*t;c+=*t++);s=u;}

Try it online!

Ungolfed:

f(s,t,u,i,c)char**s,*t,*u;{
 for(i=~0, // initialize minimum string sum to largest possible
 u=0; // initialize smallest string (in case of empty list)
 t=*s; // scan list
 c<i+0U?u=*s,i=c:0, // reset minimum string sum and pointer if smaller
 s++)
 for(c=0;*t;c+=*t++); // get string sum
 s=u; // return smallest string
}

Answer 7

Raku, 17 bytes

*.min(*.ords.sum)

Try it online!

*.ords.sum is an anonymous function that calculates the sum of the ordinal values of its string argument. That function is passed as the argument to *.min, which returns the element of the input list with the smallest value computed by the first function.

• Dominic van Essen: Your explanation seems to break off at a
• Sean: Huh! Fixed. Dunno how that happened.

Answer 8

Ruby, 19 bytes

->x{x.min_by &:sum}

Try it online!

Answer 9

Swift, (削除) 64 (削除ここまで) 69 bytes

^{Now with fewer compiler crashes!}

{0ドル.map{(0ドル.reduce(0){0ドル+Int(1ドル.asciiValue!)},0ドル)}.min{0ドル.0<1ドル.0}!.1}

SwiftFiddle link

• Bbrk24: The original version only worked for short strings; after more than a couple characters, it would overflow the limit for UInt8. However, when you hardcode the input, constant-folding causes this overflow to happen at compile-time, an the compiler crashes.

Answer 10

Python, 44 bytes

lambda l:min(l,key=lambda x:sum(map(ord,x)))

Attempt This Online!

Commented

lambda l: # Anonymous function taking l, a list of strings
 min(l, ) # Return the minimum of l...
 key= # ...using the following function:
 lambda x: # Function taking x, a string
 sum( ) # Sum the following:
 map(ord,x) # Convert all characters to ASCII values

Answer 11

JavaScript (Node.js), 59 bytes

a=>a.sort(g=(x,y)=>x>=x&&~~eval(Buffer(x).join`+`)-g(y))[0]

Try it online!

Commented

a => // a[] = input array
a.sort(g = // g is a recursive callback function
 (x, y) => // for each pair (x, y) to be tested:
 x >= x && // stop if x is undefined
 ~~eval( // otherwise, evaluate as JS code:
 Buffer(x) // the ASCII codes of x
 .join`+` // joined with '+'
 ) // end of eval()
 - g(y) // subtract the result of a recursive call with x = y
) // end of sort()
[0] // keep the first entry

Answer 12

Japt -g, 4 bytes

Takes input as an array of character arrays.

ñÈxc

Try it

ñÈxc :Implicit input of 2D array
ñ :Sort by
 È :Function
 x : Sum of
 c : Codepoints
 :Implicit output of first element

Answer 13

Excel, 78 bytes

=LET(x,A1#,y,ROW(A:A),@SORTBY(x,MMULT(TOROW(y^0),IFERROR(CODE(MID(x,y,1)),))))

where A1# is a horizontal spilled range containing the strings.

• JvdV: In theory I thought =@SORTBY(A1#,MAP(A1#,LAMBDA(x,SUM(IFERROR(CODE(MID(x,ROW(A:A),1)),)+1)))) for 73 bytes would work. Using the implicit intersection operator should return the top-left cell. However, it's either bugged or not working as I expected.

Answer 14

Zsh +old utils, 47 (削除) 55 (削除ここまで) (削除) 103 (削除ここまで) bytes

Using the filesystem and the old System V sum* command:

for i;echo $i>$[++n];set `sum -s *|sort -n`;<3ドル

Try it online! (削除) _{55 bytes} (削除ここまで)

_{* On MacOS, cksum -o2 is equivalent to GNU sum -s. According to Wikipedia, the BSD checksum algorithm is "useless from a security perspective" 😛}

---

103 bytes, using arrays and builtins only:

for x;{w=;for a (${(s::)${x:?}})((w+=#a));k+=($w)}
for i ({1..$#})((k[i]==$(printf ${(n)k})))&&<<<$@[i]

Try it online!
_{Explanation of code is in earlier revisions of this answer}

Answer 15

Burlesque, 9 bytes

{)**++}<m

Try it online!

{
 )** # Map to ord
 ++ # sum
}<m # Minimum by

Answer 16

Jelly, 5 bytes

OS$ÞḢ

Try it online!

Explanation

OS$ÞḢ # Main link
 $ # Last two links as a monad:
O # Ordinals
 S # Sum
 Þ # Sort the input by this monad
 Ḣ # First item (minimum)

Answer 17

Stax, ^{(削除) 9 (削除ここまで)} 5 bytes

And pure ASCII!

{|+}e

Run and debug it (with test cases)

Explanation

{ }e # minimum by
 |+ # sum

Answer 18

janet, 51 bytes

(fn[l](((sort-by first(map(fn[x][(sum x)x])l))0)1))

in janet, you can save bytes by not using spaces between brackets, which i personally think is very ugly for a lisp-like language, so here's an de-uglified version and an example

(fn [l] (((sort-by first (map (fn [x] [(sum x) x]) l)) 0) 1))

$ janet
Janet 1.29.1-20230709 openbsd/x64/clang - '(doc)' for help
repl:1:> (def F (fn[l](((sort-by first(map(fn[x][(sum x)x])l))0)1)))
<function 0x028B13B5F580>
repl:2:> (F ["zab" "xyz" "abcd"])
"zab"

Answer 19

Pip, (削除) 12 (削除ここまで) 10 bytes

@Y$+A*_SKg

Attempt This Online!

-2 thanks to @DLosc

Explanation

@Y$+A*_SKg ; Input on command line
 g ; Input list
 SK ; Sorted by:
 $+ ; Sum of
 A* ; ASCII values of
 _ ; The string
@Y ; First item (minimum)
 ; Implicit output

• DLosc: Just noticing this answer a year later... you can save two bytes on the function by using a lambda expression $+A*_.

Answer 20

Perl 5 + -pl, 49 bytes

($_)=sort{unpack($x="%32A*",$a)-unpack$x,$b}$_,<>

Try it online!

Explanation

sorts a list of the current input ($_) and the remaining lines of input (<>) based on the value of unpacking the string using "exotic templates", having the first index of the result re-assigned to $_ to be implicitly -printed.

Answer 21

R, (削除) 50 (削除ここまで) 47 bytes

• -3 bytes by pajonk

which.min(Map(\(x)sum(utf8ToInt(x)),scan(,"")))

Attempt This Online!

This outputs a named vector with the smallest value string as the name and the value is the string's position in the input list. If this is against the rules, then the following code for 7 bytes more will provide the clean output: names(which.min(Map(\(x)sum(utf8ToInt(x)),scan(,""))))

• pajonk: -3 bytes using Map (apparently which.min works also for lists...)

Answer 22

Arturo, 42 bytes

$=>[minimum&=>[∑to[:integer]to[:char]&]]

Try it

Answer 23

Retina 0.8.2, 74 bytes

.
$&$&96$*~
0T1`l`L`\w\w
{`[J-Z]
9$&
}T`_L`dL
\d
$*~
+`(\w)~
~1ドル
O`
1G`
~

Try it online! Only accepts strings of lowercase letters. Explanation:

.
$&$&96$*~

Duplicate each letter and suffix 96 ~s to each pair.

0T1`l`L`\w\w

Uppercase alternate letters.

{`[J-Z]
9$&
}T`_L`dL

Map uppercase letters into digits that sum to their index i.e. A=1 to Z=998.

\d
$*~

Expand the digits into that many ~s.

+`(\w)~
~1ドル

Move all of the ~s to the beginning of the string.

O`

Sort the strings into order. Since ~ sorts after z, this means that the string with the fewest ~s will sort first.

1G`

Keep only the first string.

~

Delete the ~s.

Answer 24

Charcoal, 15 bytes

UMθ⟦↨Eιc/oλ1ι⟧⊟⌊θ

Try it online! Link is to verbose version of code. Explanation:

UMθ⟦↨Eιc/oλ1ι⟧

Calculate the sum of ASCII values for each string.

⊟⌊θ

Output the string with the smallest sum.

Answer 25

PowerShell Core, 55 bytes

($args|Sort-Object{"$($_|% t*y|%{'+',+$_[0]})"|iex})[0]

Try it online!

Answer 26

Pyth, 6 bytes

.msCMb

Try it online!

• hakr14: Fairly certain the b isn't necessary: tio.run/##K6gsyfj/Xy@32Nk36f//aKWqxCQlHQWlisoqEJWYlJyiFAsA

Answer 27

Husk, 2 bytes

◄Σ

Try it online!

◄ # minlon: Element that minimizes function result
 Σ # chrsum: Sum of code points

Answer 28

BQN, (削除) 15 (削除ここまで) 14 bytes

⊑∘⍋∘(+ ́ ̈-⟜@)⊑⊢

Try it at BQN REPL

⊑∘⍋∘(+ ́ ̈-⟜@)⊑⊢
 ( ̈ ) # for each element of input
 -⟜@ # subtract the null character from each letter
 # (thereby getting codepoint values)
 + ́ # and sum by fold-addition
⊑∘ # now get the first element of 
 ⍋∘ # the indices of sorted elements
 ⊑ # and use this to select from
 ⊢ # the elements of the input

Answer 29

Scala 3, 34 bytes

 _.minByOption(_.map(_.toInt).sum)

Attempt This Online!