16
\$\begingroup\$

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.

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

10 Answers 10

4
\$\begingroup\$

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

\$\endgroup\$
0
3
\$\begingroup\$

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
\$\endgroup\$
2
  • \$\begingroup\$ 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 \$\endgroup\$ Nov 15, 2018 at 13:25
  • \$\begingroup\$ @KevinCruijssen: Yeah. We had an is_number but unfortunately no to_number. \$\endgroup\$
    – Emigna
    Nov 15, 2018 at 13:33
3
\$\begingroup\$

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"
\$\endgroup\$
3
\$\begingroup\$

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
\$\endgroup\$
1
  • \$\begingroup\$ Ok, this is better!! damn!! that é was hidden all this time!! \$\endgroup\$ Nov 15, 2018 at 13:07
3
\$\begingroup\$

Japt, 14 11 10 bytes

á m¬ñn gJò

Try it online!

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

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)
\$\endgroup\$
7
  • \$\begingroup\$ 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. \$\endgroup\$ Nov 15, 2018 at 13:10
  • 1
    \$\begingroup\$ @KevinCruijssen It actually gets the last and first item. :P \$\endgroup\$ Nov 15, 2018 at 13:12
  • \$\begingroup\$ 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? \$\endgroup\$ Nov 15, 2018 at 16:23
  • \$\begingroup\$ Is Jelly 1-based indexed? That would explain this behavior but I don't see anything about that in the docs. \$\endgroup\$ Nov 15, 2018 at 16:59
  • 1
    \$\begingroup\$ @Cowabunghole Yes, Jelly is 1-indexed. \$\endgroup\$ Nov 15, 2018 at 17:13
3
\$\begingroup\$

Ruby, 56 45 bytes

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

Try it online!

-11 bytes, thanks Jordan

\$\endgroup\$
1
  • 1
    \$\begingroup\$ 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/… \$\endgroup\$
    – Jordan
    Nov 16, 2018 at 16:04
2
\$\begingroup\$

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

\$\endgroup\$
2
\$\begingroup\$

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}
\$\endgroup\$
1
\$\begingroup\$

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)
\$\endgroup\$

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.