Esse problema é causado por cinco problemas de programação que todo engenheiro de software deve resolver em menos de 1 hora, o que é uma leitura interessante. Os primeiros problemas são triviais, mas o quarto pode ser um pouco mais interessante.

Dada uma lista de números inteiros separados por um único espaço na entrada padrão, imprima os valores maiores e menores que podem ser obtidos concatenando os números inteiros juntos em sua própria linha.

Por exemplo:

Entrada:

5 56 50

Resultado:

50556
56550

Vários pontos de ordem:

• A ordem dos resultados é menor e depois maior.
• Somente os menores e os maiores valores podem ser impressos (iterar sobre todas as variações e imprimi-las não é válido).
• Sempre haverá dois ou mais números inteiros na lista.
• É possível que os maiores e menores resultados sejam os mesmos. No caso de entrada 5 55, o número 555deve ser impresso duas vezes.
• Os números inteiros não são necessariamente distintos. 5 5é uma entrada válida.
• Principais 0s sobre inteiros são não entrada válida. Você não precisará prestar contas 05 55.

Como se trata de código de golfe, a entrada mais curta vence.

CJam, 14 13 bytes

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

Bem direto. É assim que 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'

Experimente online aqui

Pitão, 14 13 bytes

hJSmsd.pcz)eJ

Gera todas as permutações e as classifica, imprimindo o primeiro e o último elemento.

Python 2, 104 99 bytes

Sim.

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

Edit: graças ao xnor por -5 bytes!

Mathematica, 64 58 bytes

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

Isso define uma função sem nome pegando uma string e imprimindo as duas linhas. É bem simples como os outros: obtenha todas as permutações, junte-as, classifique-as e imprima o primeiro e o último resultado.

Seis bytes salvos graças ao alefhalpha.

JavaScript (ES6) 54 72 85

Isso é mais fácil do que parece. Basta classificá-los lexicograficamente. A boa notícia é: é exatamente assim que a classificação javascript simples funciona. Bem ... não, isso está errado ... ainda uma comparação lexicográfica (mais complicada) pode fazer o trabalho.

Nota: tendo a e b numéricos, a + [b] é um atalho para a + '' + b, pois precisamos de uma concatenação de strings e não de uma soma.
Nota 2: a nova linha dentro de `` é significativa e deve ser contada

Editar Não discuta com um moderador (... brincando)

Edit2 Formato de E / S fixo usando pop-ups (consulte Padrão para Code Golf: Métodos de entrada / saída )

// 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(''))

Teste no console 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

força bruta simples:

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

Divida a sequência de entrada em espaços, concatene todas as permutações e classificações. Imprima o primeiro e o último elemento.

Julia, 77 bytes

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

Isso cria uma função sem nome que aceita um vetor como entrada e imprime o mínimo e o máximo das permutações dos elementos unidos. Para chamá-lo, dê um nome, por exemplo f=v->....

Ungolfed + explicação:

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

Sugestões são bem-vindas!

Javascript ( ES6 ) 134

Infelizmente, não há função de permutação embutida no 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="")),"")

Ruby 75

Não é a minha língua 'nativa', mas pensei em tentar ... assim, isso poderia (possivelmente) usar algumas dicas de golfe. Ainda assim, não é um mau participante.

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

Eu não diria que é elegante que tudo esteja embutido no idioma. Deve ser bastante óbvio exatamente como isso funciona.

Perl, 79 70B (68 + 2)

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

Ligue com echo 13 42 532 3 6|perl -M5.10.0 -an scratch.pl. Há uma penalidade de +2 bytes para -an. Que vergonha quanto ao comprimento do nome do 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
*/