Related
Can anyone tell me how to solv this problem please:
I tried doing this with array.map, array.filter, array.reduce but i did not got result:
Write a function putNum(arrayOfNum: number[], num: number),
which would find all possible combinations of numbers from arrayOfNum,
whose sum is equal to number. Wherein:
arrayOfNum contains only unique positive numbers (>0)
there should not be repetitions of numbers in the combination
all combinations must be unique
#param arrayOfNum: number[]
#param num: number[]
#return Array<Array<number>>
function putNum(arrayOfNum, num) {
***// write code only inside this function***
return [[1, 2], [3]];
}
// console.log(putNum([8, 2, 3, 4, 6, 7, 1], 99)); => []
// console.log(putNum([8, 2, 3, 4, 6, 7, 1], 5)); => [[2, 3], [4, 1]]
// console.log(putNum([1, 2, 3, 4, 5, 6, 7, 8], 8)); => [[1, 3, 4], [1, 2, 5], [3, 5], [2, 6], [1, 7], [8]]
let resultnum = result.filter(e => typeof e === 'number' && e > 0); // to make a new array with nums > 0
The best approach to solve this problem in optimized way is to use hash map
let twoSum = (array, sum) => {
let hashMap = {},
results = []
for (let i = 0; i < array.length; i++){
if (hashMap[array[i]]){
results.push([hashMap[array[i]], array[i]])
}else{
hashMap[sum - array[i]] = array[i];
}
}
return results;
}
console.log(twoSum([10,20,40,50,60,70,30],50));
Output:
[ [ 10, 40 ], [ 20, 30 ] ]
I need to organize the arrays that are inside an array so that the first numbers in the array are even
For now I can only scroll through the arrays, I couldn't implement the logic
let matriz = [
[5, 1, 2, 4, 7, 9],
[2, 4, 3, 1, 7, 9],
[1, 2, 3, 4, 5, 6],
]
for (let i = 0; i < matriz.length; i++) {
let innerArrLength = matriz[i].length
for (let j = 0; j < innerArrLength; j++) {
if (matriz[i][j] % 2 === 0) {
// code
} else {
// code
}
}
}
`
You could sort the array by taking a function which returns true fro even values.
const
move = (array, fn) => array.sort((a, b) => fn(b) - fn(a)),
array = [5, 1, 2, 4, 7, 9];
move(array, v => v % 2 === 0);
console.log(...array);
If you don't mind a less performant solution, filter can be very clear here:
let matriz = [
[5, 1, 2, 4, 7, 9],
[2, 4, 3, 1, 7, 9],
[1, 2, 3, 4, 5, 6],
]
for (let i = 0; i < matriz.length; i++) {
matriz[i] = matriz[i].filter(x => x%2 == 0)
.concat(
matriz[i].filter(x => x%2 != 0))
}
console.log(matriz)
(the problem is that you traverse twice every inner array and you could do it with a single pass)
I'm trying to test my JS ability and i have no idea how to do the following.
I have an array of data var array = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];.
I want to pair the items and return a new array of arrays eg var newArray = [[1,2], [3,4], [5,6]]; ect
How would I got about this
var arr = [ 4, 1, 2, 8, 9, 0 ]
var newArray = []
for (var i=0; i<arr.length; i+=2) {
newArray.push([arr[i], arr[i+1]])
}
console.log(newArray)
I made a scalable function that you can use to do this for you but you can also configure it so that it is flexible enough to handle any number of objects that you want by passing in n.
const numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
function partitionListByN(list, n = 2, reverse) {
if(reverse) {
return [list.splice(list.length - n).reverse()].concat(list.length > 0 partitionListByN(list, n, reverse) : list)
}
return [list.splice(0, n)].concat(list.length > 0 ? partitionListByN(list, n) : list)
}
console.log(partitionListByN(numbers, 3));
Whats happening is you pass in a list, we are returning a list [firstPartition, shortenedListFromRecursiveCall] so this will go [[1, 2, 3], [4, 5, 6], [7, 8, 9], [10]] since I passed n in as 3. As you can see it defaults to 2 in the params list.
It also supports a reverse setting: console.log(partionListByN(numbers, 3, true)) this would yield [ [ 10, 9, 8 ], [ 7, 6, 5 ], [ 4, 3, 2 ], [ 1 ] ]
You could take a variable for the wanted chunk size and an index and iterate as long as some elements are available.
var array = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
size = 2,
chunks = [],
i = 0;
while (i < array.length) chunks.push(array.slice(i, i += size));
console.log(chunks);
.as-console-wrapper { max-height: 100% !important; top: 0; }
I am creating a function to compare items in a multidimensional array of length 6. I compare from bottom to top and left to right. If the first elements (index 0) are as follows i[0][5] > i[0][4] > i[0][3] > i[0][2] > i[0][1] > i[0][0] it returns false and if there is only at least one element that does not respect the rule above it should return false.
When I try to use for loop, the program only returns 1 result not all expected ones.
let multidimArr = [
[1, 2, 3, 2, 1, 1]
[2, 4, 4, 3, 2, 2]
[5, 5, 5, 5, 4, 4]
[6, 6, 7, 6, 5, 5]
[4, 7, 6, 8, 7, 6]
[4, 9, 6, 7, 8, 9]
];
function compare() {
for (var i=0, len=multidimArr.length; i<len; i++) {
for (var j=0, len2=multidimArr[i].length; j<len2; j++) {
if( i <= 0 ) continue;
if ( multidimArr[i][j] < multidimArr[i - 1][j] ) {
return false
);
} else if( multidimArr[i][j] > multidimArr[i - 1][j] ){
return true;
}
}
console.log('the status is [' + compare() + ']');
For this code the expected result is false for the first column, true for the second, false for the 3rd, true for 4th, false for 5th and true for last column.
Unfortunately it only return false.
You could reduce the array and take true for the first row and then check the last and actual value and respect the last check.
function check(array) {
return array.reduce((r, a, i, { [i - 1]: b }) => a.map((v, j) => i
? r[j] && b[j] < v
: true
), []);
}
var array = [[1, 2, 3, 2, 1, 1], [2, 4, 4, 3, 2, 2], [5, 5, 5, 5, 4, 4], [6, 6, 7, 6, 5, 5], [4, 7, 6, 8, 7, 6], [4, 9, 6, 7, 8, 9]];
console.log(check(array));
Now I am working on a exercise in freecodecamp. Currently I got an logical error but do not why the failure happens.
In the code,I have to build in a function, which chop the input array based on the parameter. The testing result should be as follows:
chunkArrayInGroups(["a", "b", "c", "d"], 2) should return [["a", "b"], ["c", "d"]].
chunkArrayInGroups([0, 1, 2, 3, 4, 5], 3) should return [[0, 1, 2], [3, 4, 5]].
chunkArrayInGroups([0, 1, 2, 3, 4, 5, 6, 7, 8], 4) should return [[0, 1, 2, 3], [4, 5, 6, 7], [8]].
chunkArrayInGroups([0, 1, 2, 3, 4, 5, 6, 7, 8], 2) should return [[0, 1], [2, 3], [4, 5], [6, 7], [8]].
And my code are as follows:
function chunkArrayInGroups(arr, size) {
var array = [];
for (var x = 0; x < arr.length ; x+=size){
var spliceArr = arr.splice(0,size);
array.push(spliceArr);
}
array.push(arr);
return array;
}
chunkArrayInGroups(["a", "b", "c", "d","e"], 2);
For most of the conditions, the code works. But for the last condition i.e
chunkArrayInGroups([0, 1, 2, 3, 4, 5, 6, 7, 8], 2) should return [[0, 1], [2, 3], [4, 5], [6, 7], [8]].
in this case I cannot get the correct answer. I tested in console log, and turn out the output is like
[[0, 1], [2, 3], [4, 5], [6, 7, 8]].
I know that it is not a difficult question and there are lots of better way to approach it, but can I know what is the logic fallancy in this code?
Many thanks!
Instead of splice use slice. This will also guarantees that the original array is not modified.
Like this (working demo):
function chunkArrayInGroups(arr, size) {
var array = [];
for (var x = 0; x < arr.length; x += size) {
// take elements from current index (`x`) to `x` + `size`
// (do not remove them from the original array, so the original size is not modified either)
var sliceArr = arr.slice(x, x + size);
array.push(sliceArr);
}
return array;
}
console.log(chunkArrayInGroups(["a", "b", "c", "d"], 2)); //should return [["a", "b"], ["c", "d"]].
console.log(chunkArrayInGroups([0, 1, 2, 3, 4, 5], 3)); // should return [[0, 1, 2], [3, 4, 5]].
console.log(chunkArrayInGroups([0, 1, 2, 3, 4, 5, 6, 7, 8], 4)); // should return [[0, 1, 2, 3], [4, 5, 6, 7], [8]].
console.log(chunkArrayInGroups([0, 1, 2, 3, 4, 5, 6, 7, 8], 2)); // should return [[0, 1], [2, 3], [4, 5], [6, 7], [8]]
It might help to add a console.log(arr) to your loop to see how the array changes over time.
You would see that it looks like this:
[0, 1, 2, 3, 4, 5, 6, 7, 8]
[2, 3, 4, 5, 6, 7, 8]
[4, 5, 6, 7, 8]
Then, take into account your final splice and add which occurs outside of the loop:
[6, 7, 8]
Since your loop increments by size, it will exit once it has gathered all subarrays of exactly size.
Instead, I would recommend continuing until your input is empty:
function chunkArrayInGroups(arr, size) {
var array = [];
while(arr.length > 0){
var spliceArr = arr.splice(0,size);
array.push(spliceArr);
}
return array;
}
You will want to step using the size to save on the number of loops through the array. We are also saving the length so it's not fetched each time as it saves operations. Also you will notice that I'm not using var as you shouldn't be using it. Please use let for normal variables and const for variables you are not going to reassign.
function chunkArrayInGroups(arr, size) {
let array = [];
let arrayLength = arr.length;
for (let i = 0; i < arrayLength; i+=size) {
array.push(arr.slice(i, i+size));
}
return array
}
console.log(chunkArrayInGroups(["a", "b", "c", "d"], 2), [["a", "b"], ["c", "d"]])
console.log(chunkArrayInGroups([0, 1, 2, 3, 4, 5], 3), [[0, 1, 2], [3, 4, 5]])
console.log(chunkArrayInGroups([0, 1, 2, 3, 4, 5, 6, 7, 8], 4), [[0, 1, 2, 3], [4, 5, 6, 7], [8]])
console.log(chunkArrayInGroups([0, 1, 2, 3, 4, 5, 6, 7, 8], 2), [[0, 1], [2, 3], [4, 5], [6, 7], [8]])
The issue here is that you are reducing the array length throughout your iteration. I.e. your array gets smaller within each iteration while your x continously increases. That means that before your last iteration your x will be at 6 and the array length will be 3, hence x < arr.length evaluates to false and your last iteration does not happen. The most simplistic solution that I can think of is to store the original array length into a variable I named stop and remove the unneccessary final array push outside the loop.
function chunkArrayInGroups(arr, size) {
var array = [];
var stop = arr.length;
for (var x = 0; x < stop; x+=size){
var spliceArr = arr.splice(0,size);
array.push(spliceArr);
}
return array;
}
console.log(chunkArrayInGroups([1,2,3,4,5,6,7], 2))
splice method changes the length of array on every iteration. That's why your loop exits before you expect. You can read more about splice here.
Unlike splice, slice will not remove items from the array that's why lealceldeiro answer will work as expected.
Kevin Bruccoleri answer looks cleaner and shorter but if you have an app where you store an array in to a variable and then pass it to the function, that variable will be empty after the execution of the function, which can lead to bugs in your app. That's why arrays are basically object, but that's science fiction of javascript.
function chunkArrayInGroups(arr, size) {
var array = [];
while (arr.length) {
array.push(arr.splice(0, size))
}
return array
}
var nums = [0, 1, 2, 3, 4, 5, 6, 7, 8]
console.log('now it full', nums);
console.log(chunkArrayInGroups(nums, 2));
console.log('now it empty', nums);
Used slice to copy original array two
map() and splice() to insert array from n index
const frankenSplice = (arr1, arr2, n) => {
let arr = arr2.slice();
arr1.map(e => {
arr.splice(n, 0, e);
n++;
})
return arr;
}