Tarea

Dada una serie de números no negativos, genera el número más grande y más pequeño posible que se puede formar uniéndolos.

Reglas

Entrada, Salida puede estar en cualquier formato conveniente.

La matriz puede tener como máximo 1 número decimal.

Ejemplos

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

Este es el código de golf, por lo que gana el código más corto.

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]]

Pruébalo en línea!

_{-2 bytes, gracias a Arnauld}

05AB1E , 11 bytes

œJΣ'.¡ï}Á2£

Pruébalo en línea! o como un conjunto de pruebas

Explicación

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

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

Pruébalo en línea!

¿Cómo?

Utilizamos la siguiente prueba para comparar dos valores en la matriz de entrada:

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

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

La expresión [x % 1 || x] + yobliga al resultado anterior a una cadena y lo concatena con el otro valor.

Si hay un número decimal en la lista, siempre debe considerarse como el valor más pequeño. Al aplicar nuestra conversión, un número decimal se convierte en una cadena que comienza "0.", que se ordena lexicográficamente antes que nada.

Ejemplos:

  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

Intentalo

1 byte guardado gracias a Luis , por favor +1su solución también.

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

Pruébalo en línea!

Jalea , 6 bytes

Œ!VṢ.ị

Pruébalo en línea!

Explicación:

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

Ruby , 56 45 bytes

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

Pruébalo en línea!

-11 bytes, gracias Jordan

Pyth, 13 12 bytes

hM_BSvsM.p`M

Salidas en forma [smallest, largest]. Pruébelo en línea aquí , o verifique todos los casos de prueba a la vez aquí .

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

Editar: guardado un byte al eliminar la cadena de la función de mapeo. Versión previa: hM_BSmvs`Md.p

Perl 6 , 41 bytes

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

Pruébalo en línea!

Alternativas:

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

Casco , 10 bytes

§,▼▲morṁsP

¡Pruébelo en línea o verifique todo!

Explicación

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