Ce problème provient de cinq problèmes de programmation que chaque ingénieur logiciel devrait être en mesure de résoudre en moins d'une heure, ce qui est en soi une lecture intéressante. Les premiers problèmes sont triviaux, mais le quatrième peut être un peu plus intéressant.

Étant donné une liste d'entiers séparés par un seul espace sur l'entrée standard, imprimez les valeurs les plus grandes et les plus petites qui peuvent être obtenues en concaténant les entiers ensemble sur leur propre ligne.

Par exemple:

Contribution:

5 56 50

Production:

50556
56550

Différents rappels au règlement:

• L'ordre des résultats est le plus petit puis le plus grand.
• Seules les valeurs les plus petites et les plus grandes peuvent être imprimées (itérer sur toutes les variations et les imprimer n'est pas valide).
• Il y aura toujours deux ou plusieurs entiers dans la liste.
• Il est possible que les résultats les plus grands et les plus petits soient identiques. En cas de saisie 5 55, le numéro 555doit être imprimé deux fois.
• Les entiers ne sont pas nécessairement distincts. 5 5est une entrée valide.
• Les 0s sur les entiers ne sont pas des entrées valides. Vous n'aurez pas besoin d'en rendre compte 05 55.

Comme il s'agit de golf de code, l'entrée la plus courte l'emporte.

CJam, 14 13 octets

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

Assez simple. Voilà comment cela fonctionne:

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'

Essayez-le en ligne ici

Pyth, 14 13 octets

hJSmsd.pcz)eJ

Génère toutes les permutations et les trie, imprimant le premier et le dernier élément.

Python 2, 104 99 octets

Oui.

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

Edit: merci à xnor pour -5 octets!

Mathematica, 64 58 octets

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

Ceci définit une fonction sans nom prenant une chaîne et imprimant les deux lignes. C'est assez simple comme les autres: obtenez toutes les permutations, réunissez-les, triez-les et imprimez le premier et le dernier résultat.

Six octets économisés grâce à l'alephalphe.

JavaScript (ES6) 54 72 85

C'est plus facile qu'il n'y paraît. Triez-les simplement lexicographiquement. La bonne nouvelle est: c'est exactement comme cela que le tri en javascript fonctionne.Eh bien ... non, c'est faux ... toujours un lexicographe (plus compliqué) peut faire le travail.

Remarque: ayant a et b numérique, a + [b] est un raccourci pour a + '' + b, car nous avons besoin d'une concaténation de chaînes et non d'une somme.
Note 2: la nouvelle ligne à l'intérieur `` est significative et doit être comptée

Éditer Ne discutez pas avec un modérateur (... je plaisante)

Edit2 Format d'E / S fixe à l'aide de fenêtres contextuelles (voir Par défaut pour Code Golf: méthodes d'entrée / sortie )

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

Tester dans la 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} octets

force brute 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 octets

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

Séparez la chaîne d'entrée aux espaces, concaténez chaque permutation et triez. Imprimer le premier et le dernier élément.

Julia, 77 octets

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

Cela crée une fonction sans nom qui accepte un vecteur en entrée et imprime le minimum et le maximum des permutations des éléments joints. Pour l'appeler, donnez-lui un nom, par exemple f=v->....

Non golfé + explication:

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

Les suggestions sont les bienvenues!

Javascript ( ES6 ) 134

Malheureusement, il n'y a pas de fonction de permutation intégrée dans 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 octets

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

Rubis 75

Ce n'est pas ma langue «native», mais celle que je pensais essayer… donc cela pourrait (peut-être) utiliser des conseils de golf. Pourtant, pas un mauvais participant.

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

Je ne dirais pas que c'est élégant autre que tout est intégré à la langue. Il devrait être assez évident exactement comment cela fonctionne.

Perl, 79 70B (68 + 2)

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

Appelez avec echo 13 42 532 3 6|perl -M5.10.0 -an scratch.pl. Il y a une pénalité de +2 octets pour -an. Dommage pour la longueur du nom du module ...

JavaScript (ES6), 85 octets

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

usage:

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