Étant donné une liste avec un nombre, affichez les plages comme ceci:

Entrée: [0, 5, 0]deviendrait [0, 1, 2, 3, 4, 5, 4, 3, 2, 1, 0].

Il s'agit de mapper une plage à travers le tableau, nous devons donc d'abord créer la plage [0, 5], qui est [0, 1, 2, 3, 4, 5]. Après cela, nous utilisons le 5pour créer la gamme [5, 0]. Annexé à notre gamme précédente, cela nous donne:

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

Observons un cas de test avec deux mêmes chiffres côte à côte:

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

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

Donc, cela nous donnerait [3, 4, 5, 5, 4, 3].

Quelques autres cas de 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'entrée aura toujours au moins 2 entiers.

La réponse la plus courte gagne!

05AB1E, 1 octet

Ÿ

Essayez-le en ligne!

Comment ça fonctionne

C'est un intégré.

Javascript, 99 95 93 octets

4 6 octets de réduction merci @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 octets

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

Testé dans Firefox 44. Utilise les capacités impressionnantes de déstructuration d'arguments d'ES6 et les compréhensions de tableaux d'ES7 (qui ont malheureusement été supprimées de la spécification ES7).

JavaScript (ES6) 66 72

Une fonction récursive qui ajoute à plusieurs reprises des valeurs à l'intérieur du tableau pour combler les écarts entre les nombres proches

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

Tester

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 octets

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

Exemple d'appel:

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

Testez en direct sur ideone .

Python 2, 77 octets

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

Essayez-le en ligne

Merci à Neil, DenkerAffe et Erwan d'avoir signalé les améliorations que j'ai manquées

Perl, 47 octets

Comprend +3 pour -p(le code contient $'donc de l'espace et -compte aussi)

Donnez la liste des numéros sur STDIN:

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

fluctuating.pl:

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

La variable temporaire et toutes ces parenthèses ne sont pas optimales ...

Haskell, 63 55 octets

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

Exemple d'utilisation: g [3,5,5,3]-> [3,4,5,5,4,3].

C'est une modification de ma réponse à un défi connexe . Encore une fois, le travail principal se fait en concaténant la liste de ahaut en bas b-1et de abas en haut b+1(où une liste sera vide) et un appel récursif. Pour gérer le a==bcas où les deux listes sont vides, nous ajoutons le préfixe [a|a==b]qui évalue [a]si a==bet []sinon.

R, 86 82 75 octets

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

sauvé 4 octets en représentant pas rep.int (golf code non performance!) 7 autres octets sauvé en utilisant intégré une correspondance partielle lors de l' utilisation $(et l' effondrement définition de fonction à 1 ligne

Rubis, 116 82 octets

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

Mon tout premier golf.

Edit: Merci manatwork pour les suggestions impressionnantes.

Japt , 12 octets

16 octets enregistrés grâce à @ETHproductions !

ä!õ ËsE©DÊ>1

Testez-le en ligne

Perl 6, 94 octets

Je ne suis pas super content de ça maintenant, je vais probablement prendre une autre photo plus tard

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

PHP 5.4, 86 octets

Il est destiné à être utilisé en tant que fichier inclus, qui renvoie le résultat.

Les valeurs sont transmises en tant que paramètres de ligne de commande.

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

Pas exactement jolie ou quoi que ce soit, mais fait le travail.

Python 3 , 76 octets

Première tentative de réponse Python. L'idée de base est d'identifier à plusieurs reprises les paires de la séquence où la différence est supérieure à une étape et d'insérer un (et un seul) élément supplémentaire pour terminer la séquence dans la bonne direction. Répétez jusqu'à ce que toutes les différences entre les éléments consécutifs soient comprises entre +1 et -1.

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

Essayez-le en ligne!

Lua, 156 octets

Une fonction qui prend un tableau en paramètre et retourne le tableau étendu.

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

Non golfé et explications

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

Pour faciliter l'utilisation, vous pouvez utiliser la fonction suivante pour imprimer le tableau renvoyé par f().

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

Lorsque vous testez cette soumission, vous pouvez l'appeler comme:

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

Comme Mathcad utilise un "tableau blanc" 2D et des opérateurs spéciaux (par exemple, opérateur de sommation, opérateur intégral) et enregistre au format XML, une feuille de calcul réelle peut contenir plusieurs centaines (ou plus) de caractères. Aux fins de Code Golf, j'ai pris un "nombre d'octets" Mathcad comme étant le nombre de caractères ou d'opérateurs que l'utilisateur doit entrer pour créer la feuille de calcul.

La conversion de la définition de fonction en un programme simple et le remplacement de la variable lst par un nom de caractère unique, donne un total de 62 "octets". Avec la fonction, en utilisant un seul caractère plutôt que le nom complet, cela augmente à 65 "octets" pour la définition et à 4 "octets" supplémentaires pour chaque appel (en supposant que la création de la liste elle-même n'est pas incluse dans l'octet global count (L'utilisation des tables intégrées de Mathcad est une autre façon de saisir la liste).

PHP, 144 octets

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

C'est désordonné et trapu, et je vais essayer de l'optimiser plus tard. Il crée un à range()partir de chaque paire de paires de valeurs adjacentes, puis les assemble ensemble (après avoir popsupprimé la fin du cumulatif précédent Array).

Perl6, 21

.join est l'abréviation de $ _. 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

Production

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

Gelée , 10 octets

,r⁼?2\Ṗ;¥/

Essayez-le en ligne!

R , 74 octets

Une autre solution 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}

Essayez-le en ligne!