Questo problema deriva da cinque problemi di programmazione che ogni ingegnere del software dovrebbe essere in grado di risolvere in meno di 1 ora, che a sua volta è una lettura interessante. I primi problemi sono banali, ma il quarto può essere un po 'più interessante.

Dato un elenco di numeri interi separati da un singolo spazio sull'input standard, stampa i valori più grandi e più piccoli che possono essere ottenuti concatenando gli interi sulla loro stessa riga.

Per esempio:

Ingresso:

5 56 50

Produzione:

50556
56550

Vari punti di ordine:

• L'ordine dei risultati è il più piccolo quindi il più grande.
• È possibile stampare solo i valori più piccoli e più grandi (iterando su tutte le variazioni e stampandole non è valido).
• Ci saranno sempre due o più numeri interi nell'elenco.
• È possibile che i risultati più grandi e più piccoli siano gli stessi. In caso di input 5 55, il numero 555deve essere stampato due volte.
• I numeri interi non sono necessariamente distinti. 5 5è un input valido.
• Le 0s iniziali sugli interi non sono input validi. Sarà non necessario per conto 05 55.

Poiché si tratta di code golf, vince l'ingresso più breve.

CJam, 14 13 byte

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

Abbastanza diretto. È così che funziona:

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'

Provalo online qui

Pyth, 14 13 byte

hJSmsd.pcz)eJ

Genera tutte le permutazioni e le ordina, stampando il primo e l'ultimo elemento.

Python 2, 104 99 byte

Sì.

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

Modifica: grazie a xnor per -5 byte!

Mathematica, 64 58 byte

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

Questo definisce una funzione senza nome che prende una stringa e stampa le due linee. È abbastanza semplice come gli altri: ottieni tutte le permutazioni, uniscile, ordinale e stampa il primo e l'ultimo risultato.

Sei byte salvati grazie ad alephalpha.

JavaScript (ES6) 54 72 85

È più facile di quanto sembri. Ordinali lessicograficamente. La buona notizia è: è esattamente come funziona il semplice ordinamento javascript. Bene ... no, è sbagliato ... ancora un confronto lessicografico (più contorto) può fare il lavoro.

Nota: con a e b numerici, a + [b] è una scorciatoia per a + '' + b, poiché abbiamo bisogno di una concatenazione di stringhe e non di una somma.
Nota 2: la nuova riga all'interno di `` è significativa e deve essere contata

Modifica Non discutere con un moderatore (... sto solo scherzando)

Modifica2 Formato I / O fisso usando i popup (vedi Predefinito per Code Golf: metodi di input / output )

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

Test nella 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} byte

forza bruta semplice:

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

h 5 50 56
50556 
56550

h 50 2 1 9
12509
95021

Haskell, 98 byte

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

Dividi la stringa di input negli spazi, concatena ogni permutazione e ordinamento. Stampa il primo e l'ultimo elemento.

Julia, 77 byte

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

Ciò crea una funzione senza nome che accetta un vettore come input e stampa il minimo e il massimo delle permutazioni degli elementi uniti. Per chiamarlo, dagli un nome, ad es f=v->....

Ungolfed + spiegazione:

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

I suggerimenti sono benvenuti!

Javascript ( ES6 ) 134

Purtroppo, non esiste alcuna funzione di permutazione integrata in 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 byte

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

Ruby 75

Non la mia lingua "nativa", ma quella in cui pensavo di provare ... quindi questo potrebbe (forse) usare alcuni consigli sul golf. Tuttavia, non un cattivo concorrente.

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

Io non direi che è elegante, altro che tutto ciò che è costruito per la lingua. Dovrebbe essere abbastanza ovvio esattamente come funziona.

Perl, 79 70B (68 + 2)

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

Chiama con echo 13 42 532 3 6|perl -M5.10.0 -an scratch.pl. C'è una penalità di +2 byte per -an. Peccato per la lunghezza del nome del modulo ...

JavaScript (ES6), 85 byte

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

utilizzo:

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