Task

Given an array of non-negative numbers, output the largest and smallest possible number that can be formed by joining them.

Rules

Input,Output can be in any convenient format.

The array may have at most 1 decimal number.

Examples

input:[22,33,44,55.55,33]
output:4433332255.55,55.5522333344

input:[34,900,3,11,9]
output:990034311,113349009

input:[99.93,9,3,39]
output:939399.93,99.933399

input:[45.45,45,45,45]
output:45454545.45,45.45454545

input:[12,21,34,43,45.1]
output:4334211245.1,45.112213443

This is code-golf so shortest code wins.

  • 1
    Wouldn't the first output be: 4422333355.55, 55.5544333322? Those are smaller and larger respectively. – ouflak Nov 15 at 12:26
  • @ouflak, you have to output the largest and smallest. – Vedant Kandoi Nov 15 at 12:30
  • 1
    Nevermind, see it now. Got confused with the decimal place. – ouflak Nov 15 at 12:35
  • Would [[55.55,22,33,33,44],[44,33,33,22,55.55]] be an acceptable output format? – Shaggy Nov 15 at 12:44
  • 1
    Any way is fine @Jordan – Vedant Kandoi Nov 16 at 5:34

10 Answers 10

Python 2, 84 80 78 76 bytes

lambda a:[''.join(sorted(a,key=lambda s:'.'in s or s+s)[::i])for i in[-1,1]]

Try it online!

-2 bytes, thanks to Arnauld

05AB1E, 11 bytes

œJΣ'.¡ï}Á2£

Try it online! or as a Test Suite

Explanation

 œ             # get permutations of input
  J            # join each
   Σ    }      # sort by
    '.¡        # splitting into [before decimal, after decimal]
       ï       # and converting each to int
         Á     # rotate the result right
          2£   # and take the first 2 values
  • Too bad we don't have a cast to float. I remember there was one in the Legacy, but I just looked it up and apparently it was a stringified cast to float, which is pretty useless since you want floats instead of strings to sort on.. xD – Kevin Cruijssen Nov 15 at 13:25
  • @KevinCruijssen: Yeah. We had an is_number but unfortunately no to_number. – Emigna Nov 15 at 13:33

JavaScript (ES6), 68 66 bytes

a=>[1,-1].map(n=>a.sort((a,b)=>[a%1||a]+b<[b%1||b]+a?n:-n).join``)

Try it online!

How?

We use the following test to compare two values in the input array:

[a % 1 || a] + b < [b % 1 || b] + a

The expression x % 1 || x returns the decimal part of \$x\$ if \$x\$ is a decimal number, or leaves \$x\$ unchanged otherwise.

The expression [x % 1 || x] + y coerces the above result to a string and concatenates it with the other value.

If there's a decimal number in the list, it must always be considered as the smallest value. By applying our conversion, a decimal number is turned into a string starting with "0.", which is lexicographically ordered before anything else.

Examples:

  a |   b | [a%1||a]+b | [b%1||b]+a
----+-----+------------+------------
  4 |   5 | "45"       | "54"
 10 |  11 | "1011"     | "1110"
  8 |  80 | "880"      | "808"
  7 | 9.5 | "79.5"     | "0.57"

Japt, 14 11 bytes

á m¬ñn é v2

Try it

1 byte saved thanks to Luis, please +1 his solution too.

á               :Permutations
  m             :Map
   ¬            :  Join
    ñ           :Sort by
     n          :  Converting each to a number
       é        :Rotate right
         v2     :Remove & return the first 2 elements

Japt, 14 11 10 bytes

á m¬ñn gJò

Try it online!

  • Nice one. I had á ®¬nÃn for the first line - kicking myself that I didn't think of your way. – Shaggy Nov 15 at 12:34
  • 12 bytes, using the -h flag. – Shaggy Nov 15 at 12:56
  • 11 bytes, using the -g flag. Also works with í instead of ï. – Shaggy Nov 15 at 13:00
  • @Shaggy Excellent! Thanks!! – Luis felipe De jesus Munoz Nov 15 at 13:06
  • Dang! Looks like I gave up to soon; very nicely done. – Shaggy Nov 15 at 17:18

Jelly, 6 bytes

Œ!VṢ.ị

Try it online!

Explanation:

Œ!VṢ.ị Arguments: x
Œ!     Permutations of x
  V    Concatenate the representations of each permutation's elements and evaluate the result as Jelly code
   Ṣ   Sort
    .ị Get element at index 0.5, i.e. elements at indices 0 (last) and 1 (first)
  • I never program in Jelly, but .ị is a pretty cool way of getting both the first and last item of a list. Nice answer! +1 from me. – Kevin Cruijssen Nov 15 at 13:10
  • 1
    @KevinCruijssen It actually gets the last and first item. :P – Erik the Outgolfer Nov 15 at 13:12
  • I've also never programmed in Jelly, but I'm confused as to how .ị works. If I'm reading the docs correctly, I would think gets the element of y at floor(x) and ceil(x), and . is 0.5. Doesn't that mean it will get elements of y at index 0 and 1? – Cowabunghole Nov 15 at 16:23
  • Is Jelly 1-based indexed? That would explain this behavior but I don't see anything about that in the docs. – Cowabunghole Nov 15 at 16:59
  • 1
    @Cowabunghole Yes, Jelly is 1-indexed. – Erik the Outgolfer Nov 15 at 17:13

Ruby, 56 45 bytes

->a{a.permutation.map{|p|p.join.to_f}.minmax}

Try it online!

-11 bytes, thanks Jordan

  • 1
    Nice work! You can save 2 bytes by dropping the parentheses around your argument (->a{...) and another 9 by using the handy minmax method: tio.run/… – Jordan Nov 16 at 16:04

Pyth, 13 12 bytes

hM_BSvsM.p`M

Outputs in form [smallest, largest]. Try it online here, or verify all the test cases at once here.

hM_BSvsM.p`MQ   Implicit: Q=eval(input())
                Trailing Q inferred
          `MQ   Stringify all elements of Q
        .p      Generate all permutations of the above
      sM        Concatenate each permutation
     v          Evaluate each as a number
    S           Sort them
  _B            Pair the sorted list with its reverse
hM              Take the first element of each, implicit print

Edit: Saved a byte by taking stringification out of the mapping function. Previous version: hM_BSmvs`Md.p

Perl 6, 41 bytes

{.max,.min}o+<<*.permutations.map(*.join)

Try it online!

Alternatives:

{.max,.min}o+<<*.permutations.map:{.join}
{.max,.min}o{[map +*.join,.permutations]}
{.max,.min}o{+<<map *.join,.permutations}

Husk, 10 bytes

§,▼▲morṁsP

Try it online or verify all!

Explanation

§,▼▲m(rṁs)P  -- example input: [2,3,1.1]
          P  -- permutations: [[2,3,1.1],[3,2,1.1],[1.1,3,2],[3,1.1,2],[1.1,2,3],[2,1.1,3]]
    m(   )   -- map the following
                (example with [1.1,2,3])
       ṁs    -- | show each and join: "1.123"
      r      -- | read: 1.123
             -- : [231.1,321.1,1.132,31.12,1.123,21.13]
§,           -- fork and join as tuple
  ▼          -- | min: 1.123
   ▲         -- | max: 321.1
             -- : (1.123,321.1)

Your Answer

By clicking "Post Your Answer", you acknowledge that you have read our updated terms of service, privacy policy and cookie policy, and that your continued use of the website is subject to these policies.

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