Tâche

Étant donné un tableau de nombres non négatifs, sortez le plus grand et le plus petit nombre possible qui peut être formé en les joignant.

Règles

L'entrée, la sortie peuvent être dans n'importe quel format pratique.

Le tableau peut avoir au plus 1 nombre décimal.

Exemples

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

C'est le code-golf donc le code le plus court gagne.

Python 2 , 84 80 78 76 octets

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

Essayez-le en ligne!

_{-2 octets, merci à Arnauld}

05AB1E , 11 octets

œJΣ'.¡ï}Á2£

Essayez-le en ligne! ou comme suite de tests

Explication

 œ             # 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

JavaScript (ES6), 68 66 octets

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

Essayez-le en ligne!

Comment?

Nous utilisons le test suivant pour comparer deux valeurs dans le tableau d'entrée:

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

x % 1 || x$x$$x$$x$

L'expression [x % 1 || x] + ycontraint le résultat ci-dessus à une chaîne et le concatène avec l'autre valeur.

S'il y a un nombre décimal dans la liste, il doit toujours être considéré comme la plus petite valeur. En appliquant notre conversion, un nombre décimal est transformé en une chaîne commençant par "0.", qui est lexicographiquement ordonnée avant toute autre chose.

Exemples:

  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 octets

á m¬ñn é v2

Essayez-le

1 octet économisé grâce à Luis , s'il vous plaît +1sa solution aussi.

á               :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 octets

á m¬ñn gJò

Essayez-le en ligne!

Gelée , 6 octets

Œ!VṢ.ị

Essayez-le en ligne!

Explication:

Œ!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)

Rubis , 56 45 octets

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

Essayez-le en ligne!

-11 octets, merci Jordan

Pyth, 13 12 octets

hM_BSvsM.p`M

Sorties sous forme [smallest, largest]. Essayez-le en ligne ici ou vérifiez tous les cas de test en même temps ici .

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

Modifier: a enregistré un octet en supprimant la stringification de la fonction de mappage. La version précédente: hM_BSmvs`Md.p

Perl 6 , 41 octets

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

Essayez-le en ligne!

Alternatives:

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

Décortiquer , 10 octets

§,▼▲morṁsP

Essayez-le en ligne ou vérifiez tout!

Explication

§,▼▲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)