3
votes

En JavaScript, comment créer une liste de différences d'éléments de tableau avec élégance?

J'ai une liste de nombres, disons nombres = [3,7,9,10] et je veux avoir une liste contenant les différences entre les éléments voisins - qui doit en avoir un moins d'élément - dans le cas donné diffs = [4,2,1]

Bien sûr, je pourrais créer une nouvelle liste, parcourir la liste d'entrée et compiler mon résultat manuellement.

Je recherche une manière élégante / fonctionnelle (pour ne pas dire pythonique) de le faire. En Python, vous écririez [j-i for i, j in zip (t [: - 1], t [1:])] ou utilisez numpy pour cela.

Existe-t-il également une approche de compréhension reduction () / liste en JavaScript?

javascript arrays ecmascript-6 functional-programming

1 commentaires

Avez-vous envisagé d'utiliser une bibliothèque comme lodash ?

6 Réponses :

1
votes

Vous pouvez le faire en utilisant la méthode reduction

const numbers = [3, 7, 9, 10]
const res = numbers.reduce((r, e, i, a) => i ? r.concat(e - a[i - 1]) : r, []);
console.log(res)

0 commentaires

5
votes

Vous pouvez découper et mapper la différence.

var numbers = [3, 7, 9, 10],
    result = numbers.map((b, i, { [i - 1]: a }) => b - a).slice(1);

console.log(result);

Une approche inversée, avec un découpage ultérieur.

var numbers = [3, 7, 9, 10],
    result = numbers.slice(1).map((v, i) => v - numbers[i]);

console.log(result);

0 commentaires

1
votes

Vous pouvez également afficher après la carte:

var numbers = [3, 7, 9, 10],
result = numbers.map((v, i) => numbers[i+1]-v);
result.pop()

console.log(result);

0 commentaires

0
votes

Vous pouvez découper (0 comme début, -1 pour ignorer le dernier élément) et mapper afin de générer les différences entre un élément et son successeur dans la séquence:

    const items = [3,7,9,10];
    console.log(items.slice(0,-1).map((e,i)=>items[i+1]-e))

0 commentaires

1
votes

vous pouvez utiliser map et slice

const numbers = [3, 7, 9, 10, 11, 13];


const res = numbers.map((num, index) => numbers[index + 1] - num).slice(0, -1);



console.log(res)

0 commentaires

1
votes

Vous pouvez utiliser l'affectation de déstructuration et la récursivité -

const recur = (...values) =>
  ({ recur, values })
  
const loop = f =>
{ let r = f ()
  while (r && r.recur === recur)
    r = f (...r.values)
  return r
}

const push = (a = [], v) =>
  ( a .push (v)
  , a
  )
  
const diff = (a = []) =>
  loop
    ( ( i = 1
      , r = []
      ) =>
        i >= a.length
          ? r
          : recur
              ( i + 1
              , push (r, a[i] - a[i - 1])
              )
    )
    
console .log (diff ([ 3, 7, 9, 10 ]))
// [ 4, 2, 1 ]

console .log (diff ([ 3 ]))
// []

console .log (diff ([]))
// []

Ou ignorez certaines valeurs intermédiaires en utilisant un index -

const diff = (a = [], i = 1) =>
  i >= a.length
    ? []
    : [ a[i] - a[i - 1], ...diff (a, i + 1) ]
    
console .log (diff ([ 3, 7, 9, 10 ]))
// [ 4, 2, 1 ]

console .log (diff ([ 3 ]))
// []

console .log (diff ([]))
// []

Si nécessaire, sécurisez la pile en utilisant loop et recur . Celui-ci fonctionne aussi très vite -

const diff = ([ a, b, ...more ]) =>
  b === undefined
    ? []
    : [ b - a, ...diff ([ b, ...more ]) ]
    
 
console .log (diff ([ 3, 7, 9, 10 ]))
// [ 4, 2, 1 ]

console .log (diff ([ 3 ]))
// []

console .log (diff ([]))
// []

0 commentaires