Dato un elenco con numero, genera gli intervalli in questo modo:

Input: [0, 5, 0]diventerebbe [0, 1, 2, 3, 4, 5, 4, 3, 2, 1, 0].

Questo sta mappando un intervallo attraverso l'array, quindi dobbiamo prima creare l'intervallo [0, 5], che è [0, 1, 2, 3, 4, 5]. Successivamente, usiamo il 5per creare l'intervallo [5, 0]. Aggiunto alla nostra gamma precedente, questo ci dà:

[0, 1, 2, 3, 4, 5, 4, 3, 2, 1, 0]

Osserviamo un caso di test con due stesse cifre una accanto all'altra:

[3, 5, 5, 3], ranges:

[3, 5] = 3, 4, 5
[5, 5] = 5 (actually [5, 5] due to overlapping)
[5, 3] = 5, 4, 3

Quindi questo ci darebbe [3, 4, 5, 5, 4, 3].

Alcuni altri casi di test:

[1, 9] > [1, 2, 3, 4, 5, 6, 7, 8, 9]
[10, -10] > [10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0, -1, -2, -3, -4, -5, -6, -7, -8, -9, -10]
[3, 0, 0, -3] > [3, 2, 1, 0, 0, -1, -2, -3]
[1, 3, 5, 7, 5, 3, 1, -1, -3] > [1, 2, 3, 4, 5, 6, 7, 6, 5, 4, 3, 2, 1, 0, -1, -2, -3]

L'input avrà sempre almeno 2 numeri interi.

Vince la risposta più breve!

05AB1E, 1 byte

Ÿ

Provalo online!

Come funziona

È integrato.

Javascript, 99 95 93 byte

4 6 byte di sconto grazie @Neil .

a=>a.reduce((x,y)=>x.concat(b.map?b=y:[...Array(y<b?b-y:y-b||1)].map(_=>b+=y<b?-1:y>b)),b=[])

f=
a=>a.reduce(
    (x,y)=>
        x.concat(
            b.map?b=y
            :[...Array(y<b?b-y:y-b||1)]
                .map(_=>b+=y<b?-1:y>b)
        )
    ,b=[])


G.addEventListener('click',_=>O.innerHTML=f(JSON.parse(I.value)));

<input id=I value="[3,5,5,3]"><button id=G>Go</button><pre id=O>

JavaScript (SpiderMonkey 30+), 81 76 byte

([n,...a])=>[n,...[for(i of a)for(j of Array(i<n?n-i:i-n||1))n+=i<n?-1:i>n]]

Testato in Firefox 44. Utilizza le fantastiche capacità di distruzione degli argomenti di ES6 e le comprensioni dell'array di ES7 (che sono state purtroppo rimosse dalle specifiche ES7).

JavaScript (ES6) 66 72

Una funzione ricorsiva che aggiunge ripetutamente valori all'interno dell'array per riempire gli spazi tra i numeri vicini

f=l=>l.some((x,i)=>(z=l[i-1]-x)*z>1&&l.splice(i,0,x+z/2|0))?f(l):l

Test

f=l=>l.some((x,i)=>(z=l[i-1]-x)*z>1&&l.splice(i,0,x+z/2|0))?f(l):l

console.log=x=>O.textContent+=x+'\n'

;[[1,9],[10,-10],[3,0,0,-3],[1, 3, 5, 7, 5, 3, 1, -1, -3]]
.forEach(t=>console.log(t+' -> ' +f(t)))

<pre id=O></pre>

C, 120 + 12 = 132 byte

i,j,k;f(a,n)int*a;{a[0]--;for(i=0;i<n-1;i++)for(k=0,j=a[i]-a[i+1]?a[i]:a[i]-1;j-a[i+1];)printf("%i ",j+=a[i+1]>j?1:-1);}

Esempio di chiamata:

f(a,sizeof(a)/4);        // I've added 12 bytes because of ",sizeof(a)/4"

Prova dal vivo su ideone .

Python 2, 77 byte

lambda n:n[0:1]+sum([range(x,y,2*(y>x)-1)[1:]+[y]for(x,y)in zip(n,n[1:])],[])

Provalo online

Grazie a Neil, DenkerAffe ed Erwan per aver sottolineato i miglioramenti che mi mancavano

Perl, 47 byte

Include +3 per -p(il codice contiene $'così spazio e -conta anche)

Fornisci l'elenco dei numeri su STDIN:

fluctuating.pl <<< "3 5 5 3"

fluctuating.pl:

#!/usr/bin/perl -p
($n=$&+($'<=>$&))-$'&&s/\G/$n / while/\S+ /g

La variabile temporanea e tutte queste parentesi sembrano non ottimali ...

Haskell, 63 55 byte

g(a:b:r)=[a|a==b]++[a..b-1]++[a,a-1..b+1]++g(b:r)
g x=x

Esempio di utilizzo: g [3,5,5,3]-> [3,4,5,5,4,3].

È una modifica della mia risposta a una sfida correlata . Ancora una volta, il lavoro principale viene eseguito concatenando l'elenco da averso l'alto b-1e averso il basso b+1(dove un elenco sarà vuoto) e una chiamata ricorsiva. Per gestire il a==bcaso in cui entrambi gli elenchi sono vuoti, anteponiamo [a|a==b]che valuta [a]se a==be []altrimenti.

R, 86 82 75 byte

function(x)rep((y<-rle(unlist(Map(seq,head(x,-1),x[-1]))))$v,pmax(1,y$l-1))

salvato 4 byte utilizzando rep not rep.int (codice golf non prestazioni!) salvato altri 7 byte utilizzando la corrispondenza parziale incorporata quando si utilizza $(e comprimendo la definizione della funzione su 1 riga

Rubino, 116 82 byte

->n{o,*m=n;o=[o];m.zip(n).map{|t,u|o+=[[u],[*u+1..t],[*t..u-1].reverse][t<=>u]};o}

Il mio primo golf in assoluto.

Modifica: grazie manatwork per i fantastici suggerimenti.

Japt , 12 byte

16 byte salvati grazie a @ETHproductions !

ä!õ ËsE©DÊ>1

Provalo online

Perl 6, 94 byte

Non sono molto contento di questo in questo momento, probabilmente farò un altro tentativo più tardi

{reduce {|@^a[0..*-2],|@^b},map {@_[0]!= @_[1]??(@_[0]...@_[1])!!(@_[0],@_[1])},.rotor(2=>-1)}

PHP 5.4, 86 byte

Questo è pensato per essere usato come file incluso, che restituisce il risultato.

I valori vengono passati come parametri della riga di comando.

<?for($i=1;$i<$argc-1;$R=array_merge($R?:[],range($argv[$i++],$argv[$i++])));return$R;

Non esattamente carino o altro, ma fa il lavoro.

Python 3 , 76 byte

Primo tentativo di risposta Python. L'idea di base è identificare ripetutamente le coppie nella sequenza in cui la differenza è maggiore di un passo e inserire un (e solo un) elemento aggiuntivo per completare la sequenza nella giusta direzione. Ripeti fino a quando tutte le differenze tra gli elementi consecutivi sono comprese tra +1 e -1.

d=diff
while any(d(x)**2>1):i=argmax(d(x)**2);x[:i+1]+=[x[i]+sign(d(x)[i])]

Provalo online!

Lua, 156 byte

Una funzione che accetta un array nel parametro e restituisce l'array esteso.

function f(t)r={}for i=2,#t
do x,y=t[i-1],t[i]r[#r+1]=x==y and x or nil
z=x>y and-1or 1
x=x==r[#r]and x+z or x
for j=x,y,z
do r[#r+1]=j end end
return r end

Ungolfed e spiegazioni

function f(t)
  r={}                        -- Initialise an empty array
  for i=2,#t                  -- Iterate over the parameter array
  do
    x,y=t[i-1],t[i]           -- x and y are shorter names than t[i-1]
    r[#r+1]=                  -- when there's a range like [5,5]
      x==y and x or nil       -- put this number once in the array
    z=x>y and-1or 1         -- determine the step value
    x= x==r[#r]               -- prevent repeating the last value of r
          and x+z or x        -- by incrementing/decrementing x
    for j=x,y,z               -- iterate from t[i-1] to t[i] by step z (-1 or 1)
    do
      r[#r+1]=j               -- put j into the array r
    end
  end
  return r                    -- return the extended array
end

Per facilità d'uso, è possibile utilizzare la seguente funzione per stampare l'array restituito da f().

function printArray(t)
  print("["..table.concat(t,",").."]")
end

Durante il test di questo invio, puoi chiamarlo come:

printArray(f( {0,5,0,3,4,4,7,3,-3} ))
> [0,1,2,3,4,5,4,3,2,1,0,1,2,3,4,4,5,6,7,6,5,4,3,2,1,0,-1,-2,-3]

Mathcad, 62 "byte"

Poiché Mathcad utilizza una "lavagna" 2D e operatori speciali (ad es. Operatore di somma, operatore integrale) e salva in un formato XML, un foglio di lavoro reale può contenere diverse centinaia (o più) caratteri. Ai fini di Code Golf, ho considerato un "conteggio byte" di Mathcad come il numero di caratteri o operatori che l'utente deve inserire per creare il foglio di lavoro.

La conversione della definizione della funzione in un programma semplice e la sostituzione della variabile lst con un nome di singolo carattere, danno un totale di 62 "byte". Con la funzione, usando un singolo carattere anziché il nome completo, questo aumenta a 65 "byte" per la definizione e altri 4 "byte" per ogni chiamata (supponendo che la creazione dell'elenco stesso non sia inclusa nel byte complessivo count (L'uso delle tabelle incorporate di Mathcad è un altro modo per inserire l'elenco).

PHP, 144 byte

function f($r){$m=[];for($i=0;++$i<count($r);){$d=array_pop($m);$n=$r[$i];$p=$r[$i-1];$m=array_merge($m,$p==$n?[$p,$n]:range($p,$n));}return$m;}

function f($r) {
  $m = [];
  for ($i=0; ++$i < count($r); ) {
    $d = array_pop($m);
    $n = $r[$i];
    $p = $r[$i-1];
    $m = array_merge($m, $p==$n ? [$p,$n]
                                : range($p,$n));
  }
  return $m;
}

f([ bound1, bound2, bound3, ... ]);

[int, int, int, int, ...]

È disordinato e grosso, e proverò a ottimizzarlo in seguito. Crea una range()da ciascuna coppia di coppie di valori adiacenti, quindi le ricucisce (dopo aver poprimosso la fine del cumulativo precedente Array).

Perl6, 21

.join è l'abbreviazione di $ _. join

say EVAL .join: "..."

Test (rakudo)

perl6 -MMONKEY-SEE-NO-EVAL -e'say EVAL @*ARGS.join: "..."' 1 3 5 7 5 3 1 -1 -3

Produzione

(1 2 3 4 5 6 7 6 5 4 3 2 1 0 -1 -2 -3)

Gelatina , 10 byte

,r⁼?2\Ṗ;¥/

Provalo online!

R , 74 byte

Un'altra soluzione R.

function(x){b=x[1];z=c();for(a in x[-1]){z=c(z,c(b:(a-sign(a-b))));b=a};z}

Provalo online!