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.

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 @.

{𝕩⊑˜⊑⍒(+´@⊸-)¨𝕩}

Try it online!

Explanation

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

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 

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.

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

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.

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, ⁹ 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

Answer 20

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(,""))))

Answer 21

Arturo, 42 bytes

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

Try it

Answer 22

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 23

Charcoal, 15 bytes

ＵＭθ⟦↨Ｅι℅λ¹ι⟧⊟⌊θ

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

ＵＭθ⟦↨Ｅι℅λ¹ι⟧

Calculate the sum of ASCII values for each string.

⊟⌊θ

Output the string with the smallest sum.

Answer 24

PowerShell Core, 55 bytes

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

Try it online!

Answer 25

Pyth, 6 bytes

.msCMb

Try it online!

Answer 26

Husk, 2 bytes

◄Σ

Try it online!

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

Answer 27

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 28

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 29

Scala 3, 34 bytes

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

Attempt This Online!