Este problema proviene de cinco problemas de programación que todo ingeniero de software debería poder resolver en menos de 1 hora, lo que en sí mismo es una lectura interesante. Los primeros problemas son triviales, pero el cuarto puede ser un poco más interesante.

Dada una lista de enteros separados por un solo espacio en la entrada estándar, imprima los valores más grandes y más pequeños que se pueden obtener al concatenar los enteros en su propia línea.

Por ejemplo:

Entrada:

5 56 50

Salida:

50556
56550

Varios puntos de orden:

• El orden de los resultados es menor que mayor.
• Solo se pueden imprimir los valores más pequeños y más grandes (iterar sobre todas las variaciones e imprimirlas no es válido).
• Siempre habrá dos o más enteros en la lista.
• Es posible que los resultados más grandes y más pequeños sean los mismos. En el caso de la entrada 5 55, el número 555debe imprimirse dos veces.
• Los enteros no son necesariamente distintos. 5 5Es una entrada válida.
• Los principales 0s en enteros no son entradas válidas. Usted no necesita para tener en cuenta 05 55.

Como se trata de código de golf, gana la entrada más corta.

CJam, 14 13 bytes

qS/e!:s$(N@W=

Muy claro. Así es como funciona:

qS/                  e# Split the input on spaces
   e!                e# Get all permutations of the input numbers
     :s              e# Join each permutation order into a single string
       $             e# Sort them. This sorts the strings based on each digit's value
        (N@W=        e# Choose the first and the last out of the array separated by '\n'

Pruébalo en línea aquí

Pyth, 14 13 bytes

hJSmsd.pcz)eJ

Genera todas las permutaciones y las ordena, imprimiendo el primer y el último elemento.

Python 2, 104 99 bytes

Sí.

from itertools import*;z=[''.join(x)for x in permutations(raw_input().split())];print min(z),max(z)

Editar: gracias a xnor por -5 bytes!

Mathematica, 64 58 bytes

Print/@Sort[""<>#&/@Permutations@StringSplit@#][[{1,-1}]]&

Esto define una función sin nombre que toma una cadena e imprime las dos líneas. Es bastante sencillo como los demás: obtenga todas las permutaciones, únalas, ordénelas e imprima el primer y el último resultado.

Seis bytes guardados gracias a alephalpha.

JavaScript (ES6) 54 72 85

Eso es más fácil de lo que parece. Solo ordénelos lexicográficamente. La buena noticia es: así es exactamente cómo funciona el tipo de JavaScript simple. Bueno ... no, eso está mal ... todavía una comparación de lexicografía (más complicada) puede hacer el trabajo.

Nota: teniendo un número numérico ayb, a + [b] es un atajo para a + '' + b, ya que necesitamos una concatenación de cadenas y no una suma.
Nota 2: la nueva línea dentro de `` es significativa y debe contarse

Editar No discutas con un moderador (... es broma)

Edit2 Formato de E / S fijo mediante ventanas emergentes (consulte Predeterminado para Code Golf: métodos de entrada / salida )

// Complete program with I/O
// The sorting function is shorter as input are strings

alert((l=prompt().split(' ')).sort((a,b)=>a+b>b+a).join('')+`
`+l.reverse().join(''))

// Testable function (67 chars)
// With an integer array parameter, the sorting function must convert to string 

F=l=>(l.sort((a,b)=>a+[b]>b+[a]).join('')+`
`+l.reverse().join(''))

Prueba en la consola Firefox / FireBug

F([50, 2, 1, 9])
F([5,56,50])
F([52,36,526])
F([52,36,525])
F([52,36,524]

12509
95021

50556
56550

3652526
5265236

3652525
5255236

3652452
5252436

J, 34 ^{36 , 42} bytes

fuerza bruta simple:

h=:3 :'0 _1{/:~;"1":&.>y A.~i.!#y'

h 5 50 56
50556 
56550

h 50 2 1 9
12509
95021

Haskell, 98 bytes

import Data.List
g=sort.map concat.permutations.words
h i=unlines[g i!!0,last$g i]
main=interact h

Dividir la cadena de entrada en los espacios, concatenar cada permutación y ordenar. Imprime el primer y último elemento.

Julia, 77 bytes

v->(Q=extrema([int(join(x)) for x in permutations(v)]);print(Q[1],"\n",Q[2]))

Esto crea una función sin nombre que acepta un vector como entrada e imprime el mínimo y el máximo de las permutaciones de los elementos unidos. Para llamarlo, asígnele un nombre, por ejemplo f=v->....

Ungolfed + explicación:

function f(v)
    # Create an integer vector of the joined permutations using comprehension,
    # then get the minimum and maximum as a tuple using extrema().

    Q = extrema([int(join(x)) for x in permutations(v)])

    # Print the minimum and the maximum, separated by a newline.
    print(Q[1], "\n", Q[2])
end

¡Sugerencias son bienvenidas!

Javascript ( ES6 ) 134

Lamentablemente, no hay una función de permutación incorporada en JS :(

f=(o,y,i,a)=>y?o.concat(a[1]?a.filter((k,j)=>j^i).reduce(f,[]).map(z=>y+z):y):(q=o.split(' ').reduce(f,[])).sort().shift()+`
`+q.pop()

<!-- Snippet Demo (Firefox only) -->

<input id="input" value="5 56 50" />
<input type="button" onclick="output.innerHTML=f(input.value)" value="Run" />
<pre id="output"></pre>

R, 59 bytes

write(range(combinat:::permn(scan(),paste,collapse="")),"")

Rubí 75

No es mi idioma 'nativo', pero pensé que lo probaría ... así que esto (posiblemente) podría usar algunos consejos de golf. Aún así, no es un mal entrante.

puts STDIN.read.split(" ").permutation.map{|x|x.join}.sort.values_at(0,-1)

No diría que es elegante, aparte de que todo está integrado en el idioma. Debería ser bastante obvio exactamente cómo funciona esto.

Perl, 79 70B (68 + 2)

use Math::Combinatorics;say for(sort map{join'',@$_}permute@F)[0,-1]

Llamada con echo 13 42 532 3 6|perl -M5.10.0 -an scratch.pl. Hay una penalización de +2 bytes por -an. Lástima la longitud del nombre del módulo ...

JavaScript (ES6), 85 bytes

F=a=>(c=a.split(" ").sort((b,a)=>b+a-(a+b)),`${c.join("")}
${c.reverse().join("")}`)

uso:

F("50 2 1 9")
/*
    12509
    95021
*/