Develop Reference

Compare 2 arrays and combine in Javascript

How can i compare and combine 2 arrays using array functions of javascript or using lodash?
I have this initial array of dates for last 30 days.
[
'2022-12-11', '2022-12-12', '2022-12-13',
'2022-12-14', '2022-12-15', '2022-12-16',
'2022-12-17', '2022-12-18', '2022-12-19',
'2022-12-20', '2022-12-21', '2022-12-22',
'2022-12-23', '2022-12-24', '2022-12-25',
'2022-12-26', '2022-12-27', '2022-12-28',
'2022-12-29', '2022-12-30', '2022-12-31',
'2023-01-01', '2023-01-02', '2023-01-03',
'2023-01-04', '2023-01-05', '2023-01-06',
'2023-01-07', '2023-01-08', '2023-01-09',
'2023-01-10', '2023-01-11'
]
Then this is the second with count value.
[ [ '2023-01-09', 1 ], [ '2023-01-10', 3 ] ]
Now i have this code that compare and combine these array manually
let testData = [];
let k = 0;
dayList.forEach(o => {
let is_match = 0;
let frags = [];
submitted.forEach(i => {
if(o == i[0]){
is_match = 1;
frags = i;
}
});
testData[k] = [
(is_match == 1) ? frags[0] : o,
(is_match == 1) ? frags[1] : 0
];
k++;
});
console.log(testData);
this will result to...
[
[ '2022-12-11', 0 ], [ '2022-12-12', 0 ],
[ '2022-12-13', 0 ], [ '2022-12-14', 0 ],
[ '2022-12-15', 0 ], [ '2022-12-16', 0 ],
[ '2022-12-17', 0 ], [ '2022-12-18', 0 ],
[ '2022-12-19', 0 ], [ '2022-12-20', 0 ],
[ '2022-12-21', 0 ], [ '2022-12-22', 0 ],
[ '2022-12-23', 0 ], [ '2022-12-24', 0 ],
[ '2022-12-25', 0 ], [ '2022-12-26', 0 ],
[ '2022-12-27', 0 ], [ '2022-12-28', 0 ],
[ '2022-12-29', 0 ], [ '2022-12-30', 0 ],
[ '2022-12-31', 0 ], [ '2023-01-01', 0 ],
[ '2023-01-02', 0 ], [ '2023-01-03', 0 ],
[ '2023-01-04', 0 ], [ '2023-01-05', 0 ],
[ '2023-01-06', 0 ], [ '2023-01-07', 0 ],
[ '2023-01-08', 0 ], [ '2023-01-09', 1 ],
[ '2023-01-10', 3 ], [ '2023-01-11', 0 ]
]
As you can see the date 2023-01-09 and 2023-01-10 have values then the rest has 0 values.
Which is what i expected, i'm just new in coding a pure javascript application, i just translated my PHP code to javascript.
Now is there a way that this code may be simplified using array functions of javascript or using lodash?

Here's an approach, we first create a map with the date as key and count as value and then use this map to generate the result
const dates=["2022-12-11","2022-12-12","2022-12-13","2022-12-14","2022-12-15","2022-12-16","2022-12-17","2022-12-18","2022-12-19","2022-12-20","2022-12-21","2022-12-22","2022-12-23","2022-12-24","2022-12-25","2022-12-26","2022-12-27","2022-12-28","2022-12-29","2022-12-30","2022-12-31","2023-01-01","2023-01-02","2023-01-03","2023-01-04","2023-01-05","2023-01-06","2023-01-07","2023-01-08","2023-01-09","2023-01-10","2023-01-11",];
const count=[["2023-01-09",1],["2023-01-10",3]];
const countMap = count.reduce((acc, [date, count]) => {
acc[date] = count;
return acc;
}, {});
const result = dates.map((date) => [date, countMap[date] || 0]);
console.log(result)

You can simply run any loop and find the index of the current element in the submitted array and check if exist then assign date otherwise assign 0 to the array
var dayList = ['2022-12-11', '2023-01-10', '2023-01-09']
var submitted = [ [ '2023-01-09', 1 ], [ '2023-01-10', 3 ] ]
var testData = []
dayList.filter(o => {
const exist = submitted.find(e => e.indexOf(o) != -1)
if(exist){
testData.push([o, exist[1]])
} else {
testData.push([o, 0])
}
});
console.log("your data=", testData)

Function on a nested array in js

Here is my Function which turns timestamps to seconds,
const convertor = (x) => {
const result = x.split(':');
const final =
parseInt(result[0] * 60) +
parseInt(result[1] * 60) +
parseInt(result[2]) -
1.2;
return final;
};
input = 00:01:02.330
result: 62.330
How can I implement it on a nested array like this?
array = [ [ 00:01:02.330],[00:01:04.550],[01:11:02.330] ], [ [00:01:02.330],[00:01:02.330] ] , [ [00:01:02.330],[00:01:02.330],[00:01:02.330] ] ]
I want to preserve its nested structure so the result should be:
[ [ 22.3],[28.5],[903.50] ], [ [1252.3],[62.2] ] , [ [654.25],[965.25],[1254.32] ] ]

You can write a wrapper that accepts a function and an array, and maps over the array-- if the item is an array, it recurses; otherwise, it passes the item into the passed function-- this allows you to process nested arrays of any arbitrary depth and retain the desired structure:
const convertor = (x) => {
const result = x.split(':');
const final =
parseInt(result[0] * 60) +
parseInt(result[1] * 60) +
parseInt(result[2]) -
1.2;
return final;
};
const recursiveNestedMapper = (fn, arr) => {
const output = arr.map((item) => {
if (Array.isArray(item)) {
return recursiveNestedMapper(fn, item);
} else {
return fn(item);
}
});
return output;
}
const inputArray = [
[
['00:01:02.330'],
['00:01:04.550'],
['01:11:02.330']
],
[
['00:01:02.330'],
['00:01:02.330']
],
[
['00:01:02.330'],
['00:01:02.330'],
['00:01:02.330']
]
];
const outArray = recursiveNestedMapper(convertor, inputArray);
console.log(outArray);

Not sure why you're keeping the timestamps in an array when it's the only element, but you can get the desired output by chaining map()
const convertor = (x) => {
const result = x[0].split(':');
const final =
parseInt(result[0] * 60) +
parseInt(result[1] * 60) +
parseInt(result[2]) -
1.2;
return final;
};
const array = [
[ [ '00:01:02.330' ], [ '00:01:04.550' ], [ '01:11:02.330' ] ],
[ [ '00:01:02.330' ], [ '00:01:02.330' ] ],
[ [ '00:01:02.330' ], [ '00:01:02.330' ], [ '00:01:02.330' ] ]
];
const output = array.map(a => a.map(b => convertor(b)));
console.log(output);
[
[
60.8,
62.8,
720.8
],
[
60.8,
60.8
],
[
60.8,
60.8,
60.8
]
]

Javascript: update a column in matrix

I want to update an entire column of a matrix.
I started by initializing the matrix like:
m =({length:10}, (_,i) => Array.from({length:2}, (_,j) => i+'x'+j));
Then, I have an array of 2 element (say, a2) that I want to put in the j-th column of the matrix with manipulation.
If I am using matlab I would do the following: m(:,j)=a2+ m(:,j)
How can I do this in javascript?

Do you mean like this?:
const m = Array.from({length:10}, (_,i) => Array.from({length:2}, (_,j) => i+'x'+j));
console.log("before", m);
const j = 2;
const a2 = "z"
const n = m.map(row => {row.splice(j, 0, a2); return row});
console.log("after", n);
before manipulation:
before [
[ "0x0", "0x1" ],
[ "1x0", "1x1" ],
[ "2x0", "2x1" ],
[ "3x0", "3x1" ],
[ "4x0", "4x1" ],
[ "5x0", "5x1" ],
[ "6x0", "6x1" ],
[ "7x0", "7x1" ],
[ "8x0", "8x1" ],
[ "9x0", "9x1" ]
]
And after manipulation (i.e. add "z" to column 2):
after [
[ "0x0", "0x1", "z" ],
[ "1x0", "1x1", "z" ],
[ "2x0", "2x1", "z" ],
[ "3x0", "3x1", "z" ],
[ "4x0", "4x1", "z" ],
[ "5x0", "5x1", "z" ],
[ "6x0", "6x1", "z" ],
[ "7x0", "7x1", "z" ],
[ "8x0", "8x1", "z" ],
[ "9x0", "9x1", "z" ]
]
Or if a2 should be an array itself? Then, the simple case that it is a 1D array:
const m = Array.from({length:10}, (_,i) => Array.from({length:2}, (_,j) => i+'x'+j));
console.log("before", m);
const j = 2;
const a2 = Array.from({length:10}, (_,j) => 'z'+j)
const n = m.map((row, i) => {row.splice(j, 0, a2[i]); return row});
console.log("after", n);
After manipulation (i.e. add "z{ i }" to column 2):
after [
[ "0x0", "0x1", "z0" ],
[ "1x0", "1x1", "z1" ],
[ "2x0", "2x1", "z2" ],
[ "3x0", "3x1", "z3" ],
[ "4x0", "4x1", "z4" ],
[ "5x0", "5x1", "z5" ],
[ "6x0", "6x1", "z6" ],
[ "7x0", "7x1", "z7" ],
[ "8x0", "8x1", "z8" ],
[ "9x0", "9x1", "z9" ]
]
Or the more complex case when a2 is a 2D array:
const m = Array.from({length:10}, (_,i) => Array.from({length:2}, (_,j) => i+'x'+j));
console.log("before", m);
const j = 2;
const a2 = Array.from({length:10}, (_,i) => Array.from({length:2}, (_,j) => i+'z'+j));
const n = m.map((row, i) => {row.splice(j, 0, a2[i]); return row.flat()});
console.log("after", n);
After manipulation (i.e. add "z{ i }" to column 2):
after [
[ "0x0", "0x1", "0z0", "0z1" ],
[ "1x0", "1x1", "1z0", "1z1" ],
[ "2x0", "2x1", "2z0", "2z1" ],
[ "3x0", "3x1", "3z0", "3z1" ],
[ "4x0", "4x1", "4z0", "4z1" ],
[ "5x0", "5x1", "5z0", "5z1" ],
[ "6x0", "6x1", "6z0", "6z1" ],
[ "7x0", "7x1", "7z0", "7z1" ],
[ "8x0", "8x1", "8z0", "8z1" ],
[ "9x0", "9x1", "9z0", "9z1" ]
]

I think using Array.prototype.forEach and Array.prototype.splice is a good way to accomplish this:
// Setup for demo
const Row = (w) =>Array.from({length:w}).fill('').map((c,i)=>c=i);
const Matrix = (h, w) => Array.from({length:h}).fill('').map(r=>r=Row(w));
const print = (mtx) => mtx.forEach(r=>console.log([...r].join(", ")));
// Original state of matrix
const m1 = Matrix(2,10);
print(m1);
console.log('----------');
// Insertion function
const insertCol = (mtx, cInd, newCol) => {
mtx.forEach( (row, rInd) => { row.splice(cInd, 0, newCol[rInd]); }
);
}
// Matrix with inserted column
const someCol = ['X','Y'];
insertCol(m1, 3, someCol);
print(m1);

How to match the string values of 2 arrays when the other array has a Number(value)

I'm new to Javascript. I'm trying to get the Math.max(...arr1[i][1]) of the array(arr1), only when it is matched with the 2nd array(arr2). Then, push it on the array(arr3) and the result should have no duplicate values.
I tried iterating both arrays(arr1 & arr2) then used an "if statement" for matching them.
var arr1 = [ [ 'abandon', -2 ],
[ 'abandon', 1 ],
[ 'abandon', -2 ],
[ 'abduct', 1 ],
[ 'abduct', -2 ],
[ 'abduct', -2 ],
[ 'abhor', -3 ],
[ 'abhor', 1 ],
[ 'abhor', -1 ],
[ 'abil', 2 ],
[ 'abil', 4 ] ];
var arr2 = [ [ 'abandon' ],
[ 'abil' ],
[ 'abhor' ],
[ 'abduct' ],
['test'],
['hey'],
['testAgain'],
['array']];
var arr3 = [];
const mapping = arr2.map(word => {
return word
})
for(var i = 0; i < arr1.length; i++){
if(arr1[i][0] === mapping){
arr3.push(Math.max(...arr1[i][1]))
}
}
let arr4 = [...new Set(arr3)]
//example result:
var arr4 = [[abandon, -2],
[abduct, -2],
[abhor, -3],
[abil, 4]... and so on]
I know I'm doing something wrong, and I'm out of option. Need help.

You can better use a Set instead of an array like arr2 directly for finding a match as it will be constant time lookup in case of a Set.
Then use a Array.prototype.filter to filter the array arr1 and get those arrays which are in arr2.
Lastly Array.prototype.reduce would help you make an object with the keys being the words and values being the largest value for that word in the arr1 and you could use Object.entries from that object returned from reduce to get the data in the form of a 2-D array:
var arr1 = [ [ 'abandon', -2 ],
[ 'abandon', 1 ],
[ 'abandon', -2 ],
[ 'abduct', 1 ],
[ 'abduct', -2 ],
[ 'abduct', -2 ],
[ 'abhor', -3 ],
[ 'abhor', 1 ],
[ 'abhor', -1 ],
[ 'abil', 2 ],
[ 'abil', 4 ] ];
var arr2 = [ [ 'abandon' ],
[ 'abil' ],
[ 'abhor' ],
[ 'abduct' ],
['test'],
['hey'],
['testAgain'],
['array']];
var lookup = new Set(arr2.flat());
var mapping = arr1.filter(([word, val]) => lookup.has(word));
var data = Object.entries(mapping.reduce((acc, o, i) => {
if(acc[o[0]]){
acc[o[0]] = Math.max(o[1], acc[o[0]]);
}else{
acc[o[0]] = o[1];
}
return acc;
},{}));
console.log(data);
EDIT
Form your comment I assume that you are using a older version of node runtime where flat() is not present in the Array.prototype. So you can use the edited snippet below:
var arr1 = [ [ 'abandon', -2 ],
[ 'abandon', 1 ],
[ 'abandon', -2 ],
[ 'abduct', 1 ],
[ 'abduct', -2 ],
[ 'abduct', -2 ],
[ 'abhor', -3 ],
[ 'abhor', 1 ],
[ 'abhor', -1 ],
[ 'abil', 2 ],
[ 'abil', 4 ] ];
var arr2 = [ [ 'abandon' ],
[ 'abil' ],
[ 'abhor' ],
[ 'abduct' ],
['test'],
['hey'],
['testAgain'],
['array']];
//flatten using Array.prototype.concat
var lookup = new Set([].concat.apply([], arr2));
//If Set doesn't work use the array, but this will not be a constant time lookup
//var lookup = [].concat.apply([], arr2);
var mapping = arr1.filter(([word, val]) => lookup.has(word));
//If you are not using Set and going with an array, use Array.prototype.includes, so search won't be O(1)
//var mapping = arr1.filter(([word, val]) => lookup.includes(word));
var data = Object.entries(mapping.reduce((acc, o, i) => {
if(acc[o[0]]){
acc[o[0]] = Math.max(o[1], acc[o[0]]);
}else{
acc[o[0]] = o[1];
}
return acc;
},{}));
console.log(data);

I would do with as few loops as possible.
var arr1 = [ [ 'abandon', -2 ], [ 'abandon', 1 ], [ 'abandon', -2 ], [ 'abduct', 1 ], [ 'abduct', -2 ], [ 'abduct', -2 ], [ 'abhor', -3 ], [ 'abhor', 1 ], [ 'abhor', -1 ], [ 'abil', 2 ], [ 'abil', 4 ] ];
var arr2 = [ [ 'abandon' ], [ 'abil' ], [ 'abhor' ], [ 'abduct' ], ['test'], ['hey'], ['testAgain'], ['array']];
function getHighestResults(dataArr, filterArr) {
var name = ''; // higher readability in code and created outside
var number = -1; // for loops to avoid creating variables inside of them
function existsInObject(obj, name) {
return obj.hasOwnProperty(name);
}
function filterBasedOn(arr, obj) {
var filteredArr = [];
for (let i = 0; i < arr.length; i++) {
name = arr[i][0];
if (existsInObject(obj, name)) {
filteredArr.push([name, obj[name]]);
}
}
return filteredArr;
}
function getHighestValuesAsObj(arr) {
var dataObj = {};
for (let i = 0; i < arr.length; i++) {
name = arr[i][0];
number = arr[i][1];
if (!existsInObject(dataObj, name) || dataObj[name] < number) {
dataObj[name] = number;
}
}
return dataObj;
}
return filterBasedOn(filterArr, getHighestValuesAsObj(dataArr));
}
console.log(getHighestResults(arr1, arr2));

How can I combine elements of an array that are linear?

My data looks like:
[ [ '0s', '0.200s' ],
[ '0.200s', '0.600s' ],
[ '1.600s', '2.500s' ],
[ '3.500s', '3.900s' ],
[ '3.900s', '4.400s' ],
[ '4.400s', '4.600s' ],
[ '4.600s', '4.700s' ],
[ '4.700s', '5.200s' ],
[ '5.200s', '5.400s' ],
[ '5.400s', '5.800s' ],
[ '5.800s', '6.100s' ],
[ '6.100s', '6.800s' ],
[ '6.800s', '7s' ],
[ '7s', '7.300s' ],
[ '7.300s', '7.500s' ]
]
The first element ends at 0.200s which is where the second element begins. So I want those 2 to combine to be ['0s', '0.600s'].
The next element doesn't start where this one ends, so it should continue on. Ultimately, the result should look like:
[ [ '0s', '0.600s' ],
[ '1.600s', '2.500s' ],
[ '3.500s', '7.500s' ]
]
I am trying to do it recursively, but it's giving errors. Here's my function:
function combineStartsEnds(timecodes) {
if (timecodes[0][1] === timecodes[1][0]) {
let combined = [
[timecodes[0][0], timecodes[1][1]]
].concat(_.slice(timecodes, 2));
return combineStartsEnds(combined);
} else {
return timecodes[0].concat(combineStartsEnds(_.slice(timecodes, 1)));
}
};
This gives an error:
TypeError: Cannot read property '0' of undefined
Any ideas on how to accomplish this?

You are missing brackets here, this:
return timecodes[0].concat(...)
must be:
return [timecodes[0]].concat(...)
Additionally you need a base case to end the recursion:
function combineStartsEnds(timecodes) {
if(!timecodes.length) return [];
How I would do that:
function combineStartsEnds(timecodes) {
const result = []; let previous = [];
for(const [start, end] of timecodes) {
if(start === previous[/*end*/ 1]) {
previous[/*end*/ 1] = end;
} else {
result.push(previous = [start, end]);
}
}
return result;
}

You can also do this with reduce.
const times = [ [ '0s', '0.200s' ],
[ '0.200s', '0.600s' ],
[ '1.600s', '2.500s' ],
[ '3.500s', '3.900s' ],
[ '3.900s', '4.400s' ],
[ '4.400s', '4.600s' ],
[ '4.600s', '4.700s' ],
[ '4.700s', '5.200s' ],
[ '5.200s', '5.400s' ],
[ '5.400s', '5.800s' ],
[ '5.800s', '6.100s' ],
[ '6.100s', '6.800s' ],
[ '6.800s', '7s' ],
[ '7s', '7.300s' ],
[ '7.300s', '7.500s' ]
];
const merged = times.reduce((acc, [t3, t4]) => {
const [t1, t2] = acc[acc.length - 1] || [null, null];
if (t2 === t3) {
acc.pop();
acc.push([t1, t4]);
} else {
acc.push([t3, t4]);
}
return acc;
}, []);
console.log(merged);

You can also try below method to get your desired result.
(1) Flatten the array, you will get
arr.flat()
["0s", "0.200s", "0.200s", "0.600s", "1.600s", "2.500s", "3.500s", "3.900s", "3.900s", "4.400s", "4.400s", "4.600s", "4.600s", "4.700s", "4.700s", "5.200s", "5.200s", "5.400s", "5.400s", "5.800s", "5.800s", "6.100s", "6.100s", "6.800s", "6.800s", "7s", "7s", "7.300s", "7.300s", "7.500s"]
(2) Filter and remove elements if same exists before and after it's position, you will get
arr.flat().filter((d,i,c) => d != c[i-1] && d != c[i+1])
["0s", "0.600s", "1.600s", "2.500s", "3.500s", "7.500s"]
(3) Reduce the above result to the format you need
arr.flat()
.filter((d,i,c) => d != c[i-1] && d != c[i+1])
.reduce((res, d, i, c) => (i%2 == 0 && res.push([d, c[i+1]]) , res) , [])
[["0s", "0.600s"]
["1.600s", "2.500s"]
["3.500s", "7.500s"]]

How about using a Map():
const data = [
['0s', '0.200s'],
['0.200s', '0.600s'],
['1.600s', '2.500s'],
['3.500s', '3.900s'],
['3.900s', '4.400s'],
['4.400s', '4.600s'],
['4.600s', '4.700s'],
['4.700s', '5.200s'],
['5.200s', '5.400s'],
['5.400s', '5.800s'],
['5.800s', '6.100s'],
['6.100s', '6.800s'],
['6.800s', '7s'],
['7s', '7.300s'],
['7.300s', '7.500s']
];
var data_map = new Map(data);
for (var [key, value] of data_map) {
while (data_map.has(value)) {
var new_value = data_map.get(value);
data_map.set(key, new_value);
data_map.delete(value);
value = new_value;
}
}
data_map.forEach((value, key) => console.log(`[${key}, ${value}]`));

You could reduce the array with a single loop by checking the values and update either the last array or push a new array to the result set.
var data = [['0s', '0.200s'], ['0.200s', '0.600s'], ['1.600s', '2.500s'], ['3.500s', '3.900s'], ['3.900s', '4.400s'], ['4.400s', '4.600s'], ['4.600s', '4.700s'], ['4.700s', '5.200s'], ['5.200s', '5.400s'], ['5.400s', '5.800s'], ['5.800s', '6.100s'], ['6.100s', '6.800s'], ['6.800s', '7s'], ['7s', '7.300s'], ['7.300s', '7.500s']],
combined = data.reduce((r, [a, b]) => {
var last = r[r.length - 1];
if (last && a === last[1]) {
last[1] = b;
} else {
r.push([a, b]);
}
return r;
}, []);
console.log(combined);
.as-console-wrapper { max-height: 100% !important; top: 0; }

One way to do it using recursion –
const start = ([ a, b ]) =>
a
const end = ([ a, b ]) =>
b
const join = ([ a, b, ...rest ]) =>
// base: no `a`
a === undefined
? []
// inductive: some `a`
: b === undefined
? [ a ]
// inductive: some `a` and some `b` (joinable)
: end (a) === start (b)
? join ([ [ start (a), end (b) ], ...rest ])
// inductive: some `a` and some `b` (non-joinable)
: [ a, ...join ([ b, ...rest ]) ]
const data =
[ [ '0s', '0.200s' ]
, [ '0.200s', '0.600s' ]
, [ '1.600s', '2.500s' ]
, [ '3.500s', '3.900s' ]
, [ '3.900s', '4.400s' ]
, [ '4.400s', '4.600s' ]
, [ '4.600s', '4.700s' ]
, [ '4.700s', '5.200s' ]
, [ '5.200s', '5.400s' ]
, [ '5.400s', '5.800s' ]
, [ '5.800s', '6.100s' ]
, [ '6.100s', '6.800s' ]
, [ '6.800s', '7s' ]
, [ '7s', '7.300s' ]
, [ '7.300s', '7.500s' ]
]
console.log (join (data))
// [ [ '0s', '0.600s' ]
// , [ '1.600s', '2.500s' ]
// , [ '3.500s', '7.500s' ]
// ]