Given a list (array) of names, your challenge is to join the items using some glue and abbreviate the longest items first until the joined string fits a maximum length. And output that string. Since the glue is part of the final string, the length of the glue is included too

Abbreviation is done using the character


For example when | is the glue and 20 is the maximum length

  • giraffe would become giraffe (length = 7)
  • giraffe, Spiny lumpsucker would become giraffe|Spiny lumps… (length = 20)
  • giraffe, Spiny lumpsucker, rhinoceros would become giraf…|Spiny…|rhino… (length = 20)
  • giraffe, Spiny lumpsucker, rhinoceros, Hellbender would become any of these:
    • gira…|Spi…|rhi…|Hel…
    • gir…|Spin…|rhi…|Hel…
    • gir…|Spi…|rhin…|Hel…
    • gir…|Spi…|rhi…|Hell… (all length = 20)


The list, glue and maximum length are input parameters of the program.

When abbreviation is needed, abbreviation must be done on any of the longest items first. When the longest items are equally long, it doesn't matter which you abbreviate.

The output length is smaller than the maximum length when no abbreviation was necessary. When abbreviation needs to occur, the length of the output is exactly equal to the maximum length.

The order of the (abbreviated) items must match the order of the items in the input

You can't assume that the abbreviation character and the glue won't occur as characters in the items in the list.


I'm afraid that I overlooked the fact that the length of the glue concatenated with many items by itself may result into a string that is longer than the allowed maximum length. Without considering this, your program may run into an infinite loop. I prefer your program to throw an error in this case. I hope that's not too much of an inconvenience for the ones who already wrote an answer or that are busy writing one. To throw an error is NOT a requirement to win, but I would appreciate if you add a variant that does.

The winner

This is code-golf, so the shortest valid answer – measured in bytes – wins.

  • \$\begingroup\$ Do we choose the glue, or is one given to us in input? \$\endgroup\$ – Skidsdev Jul 11 '17 at 12:33
  • \$\begingroup\$ @Mayube the glue-string itself is input too \$\endgroup\$ – Christiaan Westerbeek Jul 11 '17 at 12:36
  • \$\begingroup\$ This is quite an interesting, 'planning to do it \$\endgroup\$ – V. Courtois Jul 11 '17 at 12:51
  • 1
    \$\begingroup\$ @ChristiaanWesterbeek can we abbreviate more than necessary? I mean, can we output gir…|Spi…|rhi…|Hel… in your example 4? \$\endgroup\$ – V. Courtois Jul 11 '17 at 13:16
  • 1
    \$\begingroup\$ @V.Courtois No. "When abbreviation needs to occur, the length of the output is exactly equal to the maximum length.". In your comment the output length is 19. It has to be 20 when that's the maximum length \$\endgroup\$ – Christiaan Westerbeek Jul 11 '17 at 13:17

Jelly, 25 bytes


Try it online!

This unfortunately does not contain the error-if-invalid feature.


This is what I call the Jelly syndrome: the easy part is explaining the algorithm, the hard part is explaining how you found the exact order to put the code in to make it execute correctly.

                       ¿     While
                 j           joining the input list
                  ⁴          with the glue produces a string
                   L         whose length
                    >        is larger than
                     ⁵       the maximum,
               ¦             in the input array at the
             Ḣ               first of the positions that
            M                have maximal
          L€                 length,
ṖṖ                           remove the last two characters,
  ;                          append
   ⁽÷ẓ                       the number 8230
      Ọ                      and cast it to a character.
                        j    Finally, join again with the glue.

05AB1E, 25 bytes


Try it online!

  • \$\begingroup\$ It's a draw with the Jelly answer. What now? \$\endgroup\$ – Christiaan Westerbeek Jul 14 '17 at 20:21
  • \$\begingroup\$ @ChristiaanWesterbeek Jelly was first so it wins (look at revision histories not post dates). \$\endgroup\$ – Erik the Outgolfer Jul 15 '17 at 11:12

JavaScript (ES6), 153 152 bytes


  f(['giraffe'], '|', 7),
  f('giraffe, Spiny lumpsucker'.split`, `, '|', 20),
  f('giraffe, Spiny lumpsucker, rhinoceros'.split`, `, '|', 20),
  f('giraffe, Spiny lumpsucker, rhinoceros, Hellbender'.split`, `, '|', 20)


Python 3, 102 bytes

def f(l,n,g):
 while len(g.join(l))>n:i=l.index(max(l,key=len));l[i]=l[i][:-2]+'…'
 return g.join(l)

Try it online!

Alternatively if you want to see the result being shortened over time:

def f(l,n,g):
 while len(g.join(l))>n:i=l.index(max(l,key=len));l[i]=l[i][:-2]+'…';yield g.join(l)

JavaScript (ES6), 91 bytes


Uses currying i.e. F(A)(N)(G)(). Explanation: No string can have a length of more than n and still fit, so without loss of generality the overlong length l starts off at n. Each recursive call then checks whether the strings fit. If not, then the first overlong string found is trimmed, otherwise the overlong length is decremented when all strings have been trimmed to that length.

  • \$\begingroup\$ Cool. This is how I used it x=a=>n=>g=>f=(l=n,r=a.join(g))=>r[n]?f(l-!a.some((s,i)=>s[l]&&(a[i]=s.slice(0,-2)+'…'))):r and than x(['giraffe', 'Spiny lumpsucker'])(20)('|')(). Works. But x(['giraffe', 'Spiny lumpsucker'])(2)('|')() gives a Maximum call stack size error (because it wouldn't all fit in a string with a length of 2). But that's something I can catch. \$\endgroup\$ – Christiaan Westerbeek Jul 14 '17 at 19:25

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.