Dato un elenco non ordinato di numeri interi unici e positivi, genera l'elenco più breve degli intervalli più lunghi possibili di numeri interi sequenziali.

INGRESSO

• Un elenco non ordinato di numeri interi unici e positivi
  • per esempio 9 13 3 11 8 4 10 15
• L'input può essere preso da uno dei seguenti:
  • stdin
  • argomenti della riga di comando
  • argomenti di funzione

PRODUZIONE

• Un elenco ordinato di intervalli o singoli valori stampati su una riga su stdout o sull'output simile più vicino alla tua lingua.
  • Se sono presenti due o più numeri interi sequenziali (sequenziali per valore, non per posizione nell'elenco), saranno indicati come un intervallo inclusivo usando -, ad es. 8-11
  • Tutti gli altri numeri interi vengono semplicemente stampati senza altra notazione
  • Un singolo spazio delimiterà l'output
• I numeri non presenti nell'input non dovrebbero essere nell'output, ad es. 3 5 6Non possono essere abbreviati 3-6perché 4non presenti

ESEMPI

Riuscito:

 IN> 9 13 3 11 8 4 10 15 6
OUT> 3-4 6 8-11 13 15

 IN> 11 10 6 9 13 8 3 4 15
OUT> 3-4 6 8-11 13 15

 IN> 5 8 3 2 6 4 7 1
OUT> 1-8

 IN> 5 3 7 1 9
OUT> 1 3 5 7 9

Sbagliato:

 IN> 9 13 3 11 8 4 10 15
OUT> 3-15

L'intervallo contiene valori non presenti nell'input

 IN> 9 13 3 11 8 4 10 15
OUT> 3 4 8 9 10 11 13 15

Tutti i valori sequenziali devono essere rappresentati come un intervallo

 IN> 9 13 3 11 8 4 10 15
OUT> 3-4 8-9 10-11 13 15

Diviso intervallo, 8-9e 10-11dovrebbe essere8-11

 IN> 9 13 3 11 8 4 10 15
OUT> 8-9 13 10-11 3-4 15

Uscita non ordinata correttamente

REGOLE

• Le scappatoie standard non sono ammesse
• Se la tua lingua ha una funzione per farlo, non è permesso
• È possibile scrivere un programma completo o una funzione
• gli spazi bianchi finali non contano

PUNTEGGIO

• Vince il minimo byte

Python 2, 123 120 byte

N=sorted(map(int,raw_input().split(' ')));print(''.join((''if n+1in N else'-'+`n`)if n-1in N else' '+`n`for n in N)[1:])

Se l'input può essere un elenco come argomento di funzione, allora (grazie a mbomb007 e xnor per i condizionali)

93 90 81 byte

def f(N):print''.join((' '+`n`,`-n`*-~-(n+1in N))[n-1in N]for n in sorted(N))[1:]

(77 byte se lo spazio bianco iniziale è accettabile - elimina il finale [1:])

JavaScript (ES6): 171 154 140 137 byte

Grazie edc65 e vihan1086 per i suggerimenti! [...n]è molto bello ma in questi casi non funziona a causa di numeri a più cifre.

f=n=>{s=e=o='';n.split` `.map(Number).sort((a,b)=>a-b).map(v=>{s=s||v;if(e&&v>e+1){o+=`${s<e?s+'-'+e:s} `;s=v}e=v});return o+(s<e?s+'-'+e:e)}

Variante ES5, 198 184 183 174 byte

f=function(n){s=e=o='';n.split(' ').map(Number).sort(function(a,b){return a-b}).map(function(v){s=s||v;if(e&&v>e+1){o+=(s<e?s+'-'+e:s)+' ';s=v}e=v});return o+(s<e?s+'-'+e:e)}

f = function (n) {
    s = e = 0, o = '';
    n.split(' ').map(Number).sort(function (a, b) {
        return a - b
    }).map(function (v) {
        s = s || v;
        if (e && v > e + 1) {
            o += (s < e ? s + '-' + e : s) + ' ';
            s = v
        }
        e = v
    });
    return o + (s < e ? s + '-' + e : e)
}

// Demonstration
document.body.innerHTML = f('1 2');
document.body.innerHTML += '<p>' + f('9 13 3 11 8 4 10 15 6');
document.body.innerHTML += '<p>' + f('11 10 6 9 13 8 3 4 15');
document.body.innerHTML += '<p>' + f('5 8 3 2 6 4 7 1');
document.body.innerHTML += '<p>' + f('5 3 7 1 9');

Rubino, 86 84 byte

s=->*a{puts a.sort.slice_when{|i,j|i+1!=j}.map{|e|e.size<2?e:[e[0],e[-1]]*"-"}*" "}

# demo
s[9, 13, 3, 11, 8, 4, 10, 15, 6]
# => 3-4 6 8-11 13 15

Questa è una versione leggermente giocata da un esempio nei documenti per slice_when .

CJam, 35 byte

l~${__0=f-ee::=0+0#/((oW>Wf*S+oe_}h

Provalo online nell'interprete CJam .

Come funziona

l~$     e# Read a line from STDIN, evaluate it and sort the result.
{       e# Do:
  _     e#   Push a copy of the array.
  _0=f- e#   Subtract the first element from all array elements.
  ee    e#   Enumerate the differences: [0 1 4] -> [[0 0] [1 1] [2 4]]
  ::=   e#   Vectorized quality: [i j] -> (i == j)
  0+    e#   Append a zero.
  0#    e#   Push the first index of 0.
  /     e#   Split the array into chunks of that size.
  (     e#   Shift out the first chunk.
  (o    e#   Print its first element.
  W>    e#   Discard all remaining elements (if any) except the last.
  Wf*   e#   Multiply all elements of the remainder by -1.
  S+o   e#   Append a space and print.
  e_    e#   Flatten the rest of the array.
}h      e# Repeat while the array is non-empty.

Rubino, 70 byte

Problemi come questi tendono a farmi controllare l'API Ruby per metodi adeguati, e oggi ne ho scoperto uno nuovo Array#slice_when:, appena introdotto in Ruby v2.2 e apparentemente destinato a questa situazione esatta :)

f=->a{puts a.sort.slice_when{|i,j|j-i>1}.map{|x|x.minmax.uniq*?-}*' '}

Dopo aver ordinato e suddiviso opportunamente l'array, prende ciascun array secondario e crea una stringa dall'elemento più alto e più basso, quindi unisce l'intero array in una stringa.

Esempio:

f.call [9,13,3,11,8,4,10,15,6] stampe 3-4 6 8-11 13 15

SWI-Prolog, 165 162 159 byte

b(Z,C,[D|E]):-Z=[A|B],(A=:=D+1,(B=[],put(45),print(A);b(B,C,[A,D|E]));(E=[],tab(1),print(A);writef('-%t %t',[D,A])),b(B,A,[A]));!.
a(A):-sort(A,B),b(B,_,[-1]).

Abbastanza male, ma poi Prolog è un linguaggio da golf terribile

Esempio: a([9,13,3,11,8,4,10,15,6]).uscite3-4 6 8-11 13 15

CJam, 38 33 byte

Nuova versione, usando idee e frammenti di codice suggeriti da @Dennis:

l~$_,,.-e`{~T+\_T+:T;(_2$+W*Q?S}/

Provalo online

Il formato di input è un array CJam tra parentesi quadre.

L'idea di base qui è che sottraggo prima una sequenza monotonica dalla sequenza di input ordinata:

3  4  8  9 10 11 13 15
0  1  2  3  4  5  6  7  (-)
----------------------
3  3  6  6  6  6  7  8

In questa differenza, i valori che fanno parte dello stesso intervallo hanno lo stesso valore. L'applicazione dell'operatore CJam RLE a questa differenza enumera direttamente gli intervalli.

I valori sequenziali sottratti devono essere aggiunti nuovamente durante l'output. Non sono del tutto contento di come è stato fatto nel mio codice. Ho il sospetto che avrei potuto salvare qualche byte con un modo più elegante di gestirlo.

Per generare l'output degli intervalli, utilizza l'idea di Dennis di generare un numero negativo per il valore finale, che si occupa di produrre un - , e semplifica anche la logica perché è necessario aggiungere / omettere un solo valore in base alla dimensione dell'intervallo .

Spiegazione:

l~    Get input.
$     Sort it.
_,,   Create monotonic sequence of same length.
.-    Calculate vector difference between the two.
e`    Calculate RLE of difference vector.
{     Loop over entries in RLE.
  ~     Unpack the RLE entry, now have length/value on stack.
  T+    Add position to get original value for start of interval.
  \     Bring length of interval to top of stack.
  _T+:T;  Add length of interval to variable T, which tracks position.
  (     Decrement interval length.
  _     Copy it, we need it once for calculating end value, once for ternary if condition.
  2$    Copy interval start value to top...
  +     ... and add interval length - 1 to get end value.
  W*    Negate end value.
  Q?    Output end value if interval length was > 1, empty string otherwise.
  S     Add a space.
}%    End loop.

CoffeeScript, 178 161 byte

Proprio come la mia risposta JavaScript. Devo capire se l'uso della comprensione comporterà un codice più breve.

f=(n)->s=e=o='';n.split(' ').map(Number).sort((a,b)->a-b).map((v)->s=s||v;(o+=s+(if s<e then'-'+e else'')+' ';s=v)if(e&&v>e+1);e=v);o+(if s<e then s+'-'else'')+e

Originale:

f=(n)->o='';s=e=0;n.split(' ').map(Number).sort((a,b)->a-b).forEach((v,i)->if!i then s=v else(o+=s+(if s<e then'-'+e else'')+' ';s=v)if(v!=e+1);e=v);o+(if s<e then s+'-'else'')+e

Python 2, 126 122 121 byte

So che questo può essere più breve, ma non so dove .. Richiede un input nel modulo [#, #, #, #, ..., #].

l=sorted(input());s=`l[0]`;c=0;x=1
while x<len(l):y,z=l[x],l[x-1];s+=(('-'+`z`)*c+' '+`y`)*(y-z>1);c=(y-z<2);x+=1
print s

Java, 191 byte

void f(int[]a){java.util.Arrays.sort(a);for(int b=a.length,c=b-1,i=0,j=a[0],l=j;++i<b;){if(a[i]!=++j||i==c){System.out.print((l+1==j?l+(i==c?" "+a[c]:""):l+"-"+(i==c?j:j-1))+" ");l=j=a[i];}}}

Verifica le gamme e le stampa di conseguenza. Sfortunatamente ho dovuto creare un caso speciale per l'ultimo elemento dell'array poiché il programma sarebbe terminato senza stampare l'ultimo numero o intervallo.

Java, 171 162 byte

String s(int[] n){Arrays.sort(n);int p=0,b=0;String r="",d="";for(int c:n){if(c==++p)b=1;else{if(b==1){r+="-"+--p+d+c;p=c;b=0;}else{r+=d+c;p=c;}d=" ";}}return r;}

Prende l'input come un array int, restituisce l'output come un elenco String separato da spazi