Dada una lista con número, genera los rangos de esta manera:

Entrada: [0, 5, 0]se convertiría [0, 1, 2, 3, 4, 5, 4, 3, 2, 1, 0].

Esto es mapear un rango a través de la matriz, por lo que primero tenemos que crear el rango [0, 5], que es [0, 1, 2, 3, 4, 5]. Después de eso, usamos 5para crear el rango [5, 0]. Agregado a nuestro rango anterior, esto nos da:

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

Observemos un caso de prueba con dos mismos dígitos uno al lado del otro:

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

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

Entonces esto nos daría [3, 4, 5, 5, 4, 3].

Algunos otros casos de prueba:

[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]

La entrada siempre tendrá al menos 2 enteros.

¡La respuesta más corta gana!

05AB1E, 1 byte

Ÿ

Pruébalo en línea!

Cómo funciona

Es un incorporado.

Javascript, 99 95 93 bytes

4 6 bytes de descuento gracias @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 bytes

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

Probado en Firefox 44. Utiliza las increíbles capacidades de desestructuración de argumentos de ES6 y las comprensiones de matriz de ES7 (que lamentablemente se han eliminado de la especificación ES7).

JavaScript (ES6) 66 72

Una función recursiva que agrega valores repetidamente dentro de la matriz para llenar los espacios entre números cercanos

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

Prueba

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 bytes

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);}

Llamada de ejemplo:

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

Prueba en vivo en ideone .

Python 2, 77 bytes

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

Pruébalo en línea

Gracias a Neil, DenkerAffe y Erwan por señalar las mejoras que me perdí

Perl, 47 bytes

Incluye +3 para -p(el código contiene $'espacio y -cuenta también)

Dé la lista de números en STDIN:

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

fluctuating.pl:

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

La variable temporal y todos estos paréntesis se sienten subóptimos ...

Haskell, 63 55 bytes

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

Ejemplo de uso: g [3,5,5,3]-> [3,4,5,5,4,3].

Es una modificación de mi respuesta a un desafío relacionado . Nuevamente, el trabajo principal se realiza concatenando la lista de aarriba hacia abajo b-1y ahacia abajo b+1(donde una lista estará vacía) y una llamada recursiva. Para manejar el a==bcaso donde ambas listas están vacías, anteponemos [a|a==b]que evalúa [a]si a==by de lo []contrario.

R, 86 82 75 bytes

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

guardó 4 bytes usando rep no rep.int (¡código de golf no rendimiento!) guardó otros 7 bytes usando coincidencia parcial incorporada al usar $(y colapsando la definición de función a 1 línea

Ruby, 116 82 bytes

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

Mi primer golf.

Editar: Gracias manatwork por las increíbles sugerencias.

Japt , 12 bytes

¡ Ahorró 16 bytes gracias a @ETHproductions !

ä!õ ËsE©DÊ>1

Pruébelo en línea

Perl 6, 94 bytes

No estoy muy contento con esto ahora, probablemente tomaré otra oportunidad más tarde

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

PHP 5.4, 86 bytes

Está destinado a ser utilizado como un archivo incluido, que devuelve el resultado.

Los valores se pasan como parámetros de la línea de comandos.

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

No es exactamente bonito ni nada, pero hace el trabajo.

Python 3 , 76 bytes

Primer intento de una respuesta de Python. La idea básica es identificar repetidamente pares en la secuencia donde la diferencia es mayor que un paso e insertar un elemento adicional (y solo uno) para completar la secuencia en la dirección correcta. Repita hasta que todas las diferencias entre elementos consecutivos estén entre +1 y -1.

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

Pruébalo en línea!

Lua, 156 bytes

Una función que toma una matriz en parámetro y devuelve la matriz extendida.

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

Sin golfos y explicaciones

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

Para facilitar su uso, puede usar la siguiente función para imprimir la matriz devuelta por f().

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

Al probar este envío, puede llamarlo así:

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 "bytes"

Como Mathcad utiliza una "pizarra" 2D y operadores especiales (por ejemplo, operador de suma, operador integral) y guarda en un formato XML, una hoja de trabajo real puede contener varios cientos (o más) caracteres. Para los propósitos de Code Golf, he tomado un "conteo de bytes" de Mathcad para que sea el número de caracteres u operadores que el usuario debe ingresar para crear la hoja de trabajo.

La conversión de la definición de la función a un programa directo, y la sustitución de la variable lst con un solo nombre de carácter, da un total de 62 "bytes". Con la función, usando un solo carácter en lugar del nombre completo, esto aumenta a 65 "bytes" para la definición y otros 4 "bytes" para cada llamada (suponiendo que la creación de la lista en sí misma no esté incluida en el byte general contar (Usar las tablas integradas de Mathcad es otra forma de ingresar la lista).

PHP, 144 bytes

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, ...]

Es desordenado y grueso, y trataré de optimizarlo más tarde. Crea un a range()partir de cada par de pares de valores adyacentes, luego los une (después popdel final del acumulado anterior Array).

Perl6, 21

.join es la abreviatura de $ _. join

say EVAL .join: "..."

Prueba (rakudo)

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

Salida

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

Jalea , 10 bytes

,r⁼?2\Ṗ;¥/

Pruébalo en línea!

R , 74 bytes

Otra solución 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}

Pruébalo en línea!