Loop - removing elements from array - javascript

I am attempting to remove specific elements from an array that is found in another array. My array is returning unchanged. My assumption is my condition in the if statement is not correct, however, I can't find a clear explanation online as to what this is supposed to be exactly. Any help is greatly appreciated.
Trying to remove ...args from array
<script>
removeFromArray = function(array, ...args) {
let removalItems = Array.from(args);
for (i = 0; i < removalItems.length; i++) {
if (array === removalItems[i]) {
array.splice(i, 1);
} else {
i++
}
}
// console.log(array);
return array;
}
removeFromArray([1, 2, 3, 4], 3, 2)
</script>
```


The problem in your code is that you are making one loop through removeFromArray but you are not looping through your array to check every element in array against removefromarray you have to use nested loop
removeFromArray = function(array, ...args) {
let removalItems = Array.from(args);
for (i = 0; i < array.length; i++) {
for (j = 0; j < removalItems.length; j++) {
if (array[i] === removalItems[j]) {
array.splice(i, 1);
i--
}
else continue
}
}
return array
}
console.log(removeFromArray([1, 2, 3, 4], 3, 2))
A different approach is to use filter
removeFromArray = function(array, ...args) {
let removalItems = Array.from(args);
return array.filter(x=>!removalItems.some(y=>x==y))
}
console.log(removeFromArray([1, 2, 3, 4], 3, 2));


Using filter() would simplify this and would not mutate original array
const removeFromArray = (array, ...args) => {
let removalItems = new Set(args);
return array.filter(e => !removalItems.has(e));
}
console.log(removeFromArray([1, 2, 3, 4], 3, 2))


You have few errors, wont work if they are not in same position and also as you remove the item with slice you need to decrement i otherwise you will skip items
const removeFromArray = (array, ...removalItems) => {
for (i = 0; i < array.length; i++) {
if (removalItems.includes(array[i])) {
array.splice(i, 1);
i--;
}
}
return array;
}
But filter is much clenaner
const removeFromArray = (array, ...removalItems) => array.filter(x => !removalItems.includes(x))


You are treating array as if it has single object.
Loop over the array and using includes method check if that element if present in the removalItems array . If yes splice , else increment.
removeFromArray = function(array, ...args) {
let removalItems = Array.from(args);
for (i = 0; i < array.length; i++) {
if (removalItems.includes(array[i])) {
array.splice(i, 1);
i--;
}
}
// console.log(array);
return array;
}
console.log(removeFromArray([1, 2, 3, 4], 3, 2));
Here is the another solution , without splicing the array while iterating over it.
removeFromArray = function(array, ...args) {
let removalItems = Array.from(args);
let result = [];
for (i = 0; i < array.length; i++) {
if (!removalItems.includes(array[i])) {
result.push(array[i]);
}
}
// console.log(array);
return result;
}
console.log(removeFromArray([1, 2, 3, 4], 3, 2));


In your for loop you have to
for (let j=0; j<array.length; j++)
if (array[j]===removalItems[i])
...the rest is the same


Using your same code pattern, you have 3 mistakes:
let removalItems = Array.from(args);
for (i = 0; i < array.length; i++) {
for (j = 0; j < removalItems.length; j++) {
if (array[i] === removalItems[j]) {
array.splice(i, 1);
i--
}
}
}
Furthermore you need another for loop to iterate through all the options.
This code has ended up being slightly inefficient but it'll do for most applications. I removed the else statement because you are already incrememnting i every time you loop.

Related

equivalent of python's array.pop() in javascript

I wonder if there's an easy to implement equivalent to python's array.pop() which returns the deleted element while deleting it from the array in parallel in javascript.
let nums = [2, 1, 3, 4, 5, 6];
function sortArray(nums) {
let arr = new Array();
let smallest_index;
for (let j = 0; j < nums.length; j++) {
smallest_index = find_smallest(nums);
console.log("smallest", smallest_index);
arr.push(nums.splice(smallest_index, 1).join(""));
}
return arr;
}
function find_smallest(arr) {
let smallest = arr[0];
let smallest_index = 0;
for (let i = 1; i < arr.length; i++) {
if (arr[i] < smallest) {
// console.log("this");
smallest = arr[i];
smallest_index = i;
}
}
return smallest_index;
}
it seems that if I replace javascript's (nums.splice(smallest_index, 1).join()) with python's (arr.append(nums.pop(smallest_index)) I would get a perfectly sorted array. is there a similar straightforward solution in javascript as well ?

OK, you use splice. Here's an example of the implementation below:
Array.prototype.pythonPop = function (index) {
return this.splice(index, 1)[0];
}
Now, I found the issue, you'll love the answer. So you were using num.length but your methods were augmenting the length of num array. Which is why your answer had only half the needed numbers. See code below. I cached the length prop of nums array
let nums = [2, 1, 3, 4, 5, 6];
function sortArray(nums) {
let arr = new Array();
let smallest_index;
console.log(nums)
for (let j = 0, length = nums.length; j < length; j++) {
smallest_index = find_smallest(nums);
console.log("smallest", smallest_index);
console.log(nums)
arr[j] = nums.splice(smallest_index, 1).join("");
}
return arr;
}
function find_smallest(arr) {
let smallest = arr[0];
let smallest_index = 0;
for (let i = 1; i < arr.length; i++) {
if (arr[i] < smallest) {
// console.log("this");
smallest = arr[i];
smallest_index = i;
}
}
return smallest_index;
}
console.log(sortArray(nums))

JS find an array's element is in another array or not

I am new to JS and I want to check an array's element in another array or not, also want to add to the array if not exist.
Here has 2 arrays:
let array1 = [[1,3,'Betty','Betty#email.com'],[2,5,'Mary','Mary#email.com'],[3,73,'Tom','Tom#email.com']]
let array2 = [[1,3,'Betty','Betty#email.com'],[9,25,'Jo','Jo#email.com'],[10,733,'Louis','Louis#email.com']]
Then I want to check the every single element of array2 is in array1 or not, and checking by the name or mail address, also push it to array1 if not.
But I don't know what's the method to do it, please help. Many Thanks!!

In my version I first create a dictionary object dict that helps me find an existing element in array1 and then I step through all the elements of array2 and push them onto array1 if the combination of both, name and mail address is not yet in array1.
const array1 = [[1,3,'Betty','Betty#email.com'],[2,5,'Mary','Mary#email.com'],[3,73,'Tom','Tom#email.com']],
array2 = [[1,3,'Betty','Betty#email.com'],[9,25,'Jo','Jo#email.com'],[10,733,'Louis','Louis#email.com']];
const dict=array1.reduce((a,c)=>
(a[c.slice(2).join('|')]=1,a),{});
array2.forEach(c=>dict[c.slice(2).join('|')]||array1.push(c))
console.log(array1)

This is my solution. I have created 2 function
The first one. This function will check if data is in array or not.
Note: This function is work around only to this question (Array nested within array)
function isExistInArray(data, array) {
for (let i = 0; i < array.length; i++) {
let isExist = true
for (let j = 0; j < data.length; j++) {
if (data[j] !== array[i][j]) {
isExist = false
}
}
if (isExist) {
return true
}
}
return false
}
And the second one is function to add item in array2 into array1 if it isn't exist.
function combineArray(arr1, arr2) {
const result = [...arr1]
arr2.forEach(item => {
if (!isExistInArray(item, arr1)) {
result.push(item)
}
})
return result
}
And then this code is now working!
Here is full code
let array1 = [[1, 3, 'Betty', 'Betty#email.com'], [2, 5, 'Mary', 'Mary#email.com'], [3, 73, 'Tom', 'Tom#email.com']]
let array2 = [[1, 3, 'Betty', 'Betty#email.com'], [9, 25, 'Jo', 'Jo#email.com'], [10, 733, 'Louis', 'Louis#email.com']]
function isExistInArray(data, array) {
for (let i = 0; i < array.length; i++) {
let isExist = true
for (let j = 0; j < data.length; j++) {
if (data[j] !== array[i][j]) {
isExist = false
}
}
if (isExist) {
return true
}
}
return false
}
function combineArray(arr1, arr2) {
const result = [...arr1]
arr2.forEach(item => {
if (!isExistInArray(item, arr1)) {
result.push(item)
}
})
return result
}
console.log(combineArray(array1, array2))

Here you can use this, but first understand what you are doing.
for(let i = 0; i < array2.length; i++) {
for(let j = 0; j < array1.length; j++) {
// If name or email matches break
if(array1[j][2] === array2[i][2] || array1[j][3] === array2[i][3]) {
break;
} else {
// If it comes here than that means email or name does not match so pushing it
if(j === array1.length - 1) { // Last Element
array1.push(array2[i])
}
}
}
}

Find variable is array or not
const arr = [{name:'vishal'},{name:'Rahul'}];
if(Array.isArray(arr)){
console.log("array")
}
else{
console.log('not array');
}

How to return the first occurrence of repeated item in an array using for loop?

I am trying to build logic currently with arrays and data structure. I am trying to implement the logic using for loop
function getRepeatingNumber(arr) {
for (var i = 0; i < arr.length; i++) {
for (var j = i + 1; j < arr.length; j++) {
if (arr[i] === arr[j]) {
return arr[i];
}
}
}
return undefined;
}
getRepeatingNumber([2, 3, 6, 5, 2]);
the above function takes in array and returns a repeated item in the array so in the above case it will return 2. But what if I have an array something like this arr[2,3,3,6,5,2] in this case it should return 3 but as the outer loop has index [0] which is 2 as the reference it will return 2 as the answer.
How to implement a function that returns the first occurrence of the repeated item.

Instead of iterating with j in the part after i, iterate the part before i:
function getRepeatingNumber(arr){
for (var i = 1; i < arr.length; i++) {
for (var j = 0; j < i; j++) {
if (arr[i] === arr[j]) {
return arr[i];
}
}
}
}
console.log(getRepeatingNumber([2,3,3,6,5,2]));
Note that an explicit return undefined is not needed, that is the default behaviour already.
You could also use indexOf to shorten the code a bit:
function getRepeatingNumber(arr){
for (var i = 1; i < arr.length; i++) {
if (arr.indexOf(arr[i]) < i) {
return arr[i];
}
}
}
console.log(getRepeatingNumber([2,3,3,6,5,2]));
You could even decide to make use of find -- which will return undefined in case of no match (i.e. no duplicates in our case):
function getRepeatingNumber(arr){
return arr.find((a, i) => {
if (arr.indexOf(a) < i) {
return true;
}
});
}
console.log(getRepeatingNumber([2,3,3,6,5,2]));
If you do this for huge arrays, then it would become important to have a solution that runs with linear time complexity. In that case, a Set will be useful:
function getRepeatingNumber(arr){
var set = new Set;
return arr.find(a => {
if (set.has(a)) return true;
set.add(a);
});
}
console.log(getRepeatingNumber([2,3,3,6,5,2]));
And if you are into functions of functions, and one-liners, then:
const getRepeatingNumber = r=>(t=>r.find(a=>[t.has(a),t.add(a)][0]))(new Set);
console.log(getRepeatingNumber([2,3,3,6,5,2]));

You need a data structure to keep track of first occurring index.
My recommendation is to use an array to store all the index of repeating numbers. Sort the array in ascending order and return the item at first index from the array.
function getRepeatingNumber(arr){
var resultIndexArr = [];
var count = 0;
var flag = 0;
for(var i=0;i<arr.length;i++)
{
for(var j=i+1;j<arr.length;j++)
{
if(arr[i] === arr[j])
{
flag = 1;
resultIndexArr[count++] = j;
}
}
}
resultIndexArr.sort((a, b) => a - b);
var resultIndex = resultIndexArr[0];
if(flag === 1)
return arr[resultIndex];
else
return;
}
console.log(getRepeatingNumber([2,3,6,5,2])); // test case 1
console.log(getRepeatingNumber([2,3,3,6,5,2])); // test case 2
console.log(getRepeatingNumber([2,5,3,6,5,2])); // test case 3
This will return correct result, but this is not the best solution. The best solution is to store your items in an array, check for each iteration if the item already exists in your array, if it exists then just return that item.

as a javascript dev you should be comfortable wit functional programming & higher-order functions so check the doc to get more understanding of some useful functions: like filter - find - reduce - findIndex map ...
Documentation
Now to answer your question:
at first you should think by step :
Get the occurrence of an item in an array as function:
const arr = [2, 5, 6, 2, 4, 5, 6, 8, 2, 5, 2]
const res = arr.reduce((numberofOcc, item) => {
if (item === 2)
numberofOcc++
return numberofOcc
}, 0);
console.log(`result without function ${res}`);
/* so my function will be */
const occurenceFun = (num, arr) => {
return arr.reduce((numberofOcc, item) => {
if (item === num)
numberofOcc++
return numberofOcc
}, 0);
}
console.log(`result using my function ${occurenceFun(2, arr)}`);
Now i have this function so i can use it inside another function to get the higher occurrence i have in an array
const arr = [1, 2, 5, 6, 8, 7, 2, 2, 2, 10, 10, 2]
const occurenceFun = (num, arr) => {
return arr.reduce((numberofOcc, item) => {
if (item === num)
numberofOcc++
return numberofOcc
}, 0);
}
/*let's create our function*/
const maxOccurenceFun = arr => {
let max = 0;
arr.forEach(el => {
if (max < occurenceFun(el, arr)) {
max = el
}
})
return max;
}
console.log(`the max occurence in this array is : ${maxOccurenceFun(arr)}`);

A simpler way to write the sum_pairs function

I want someone to show me a simpler way to write my sum_pairs(arr,sum) function which return the first 2 values in arr that adds up to form sum . My code works but i think it is complex , i need someone to simplify it . So, this is my code .
function sum_pairs(ints,s){
let arr=[];
let arrOfIndex=[];
for(let i=0;i<ints.length;i++){
for(let a=0;a<ints.length;a++){
if(a!=i){
if(ints[i]+ints[a]==s){
let newArr=[ints[i],ints[a]];
let sumIndex=i+a;
arr.push(newArr);
arrOfIndex.push(sumIndex);
}
}
}
}
let sortedArray=arrOfIndex.sort((a,b)=>a-b);
return arr[arrOfIndex.indexOf(sortedArray[0])];
}
console.log(sum_pairs([7,2,5,8,4,3],7))//[2,5]

You could take a single loop with a hash table for the second pair element.
It works by looking up the actual value and if found, then this value is part of a pair. In this case return the delta of the sum and the value and the value.
If not found, add a new entry to the hash table with the missing value for getting a sum.
Proceed until found or end.
function sum_pairs(ints, s) {
var hash = Object.create(null),
i,
value;
for (i = 0; i < ints.length; i++) {
value = ints[i];
if (hash[value]) return [s - value, value];
hash[s - value] = true;
}
}
console.log(sum_pairs([7, 2, 5, 8, 4, 3], 7));
All pairs (with an array without duplicates)
function allPairs(ints, s) {
var hash = Object.create(null),
i,
value,
pairs = [];
for (i = 0; i < ints.length; i++) {
value = ints[i];
if (hash[value]) pairs.push([s - value, value]);
hash[s - value] = true;
}
return pairs;
}
console.log(allPairs([7, 2, 5, 8, 4, 3], 7));
Finally find duplicate pairs as well :-)
function allPairs(ints, s) {
var hash = Object.create(null),
i,
value,
pairs = [];
for (i = 0; i < ints.length; i++) {
value = ints[i];
if (hash[value]) {
pairs.push([s - value, value]);
hash[value]--;
continue;
}
if (!hash[s - value]) {
hash[s - value] = 0;
}
++hash[s - value];
}
return pairs;
}
console.log(allPairs([4, 3, 3, 4, 7, 2, 5, 8, 3], 7));

Steps
Iterate through the array
Find the composition of n (n is the number in each interation) by using this equation n_composition = sum - n
Search for n_composition in the array
If found return [n, n_comp]. If not then continue the loop. If not found at all then return null.
let n = 0;
let n_comp = 0;
let sum_pairs = (arr, sum) => {
for(let i = 0, len = arr.length; i < len; ++i){
n = arr[i];
n_comp = sum - n;
if (arr.includes(n_comp)){
return [n, n_comp];
}
}
return null;
}
console.log(sum_pairs([7,2,5,8,4,3],7))//[2,5]

You can use the following code
function sum_pairs(ints, s) {
let results = [];
for (let i=0; i<ints.length; i++) {
for (let j=i+1; j<ints.length; j++) {
if (ints[j] === s - ints[i]) {
results.push([ints[i], ints[j]])
}
}
}
return results;
}
This will provide you all the pairs
To return a single pair you can use following
function sum_pairs(ints, s) {
let results = [];
for (let i=0; i<ints.length; i++) {
for (let j=i+1; j<ints.length; j++) {
if (ints[j] === s - ints[i]) {
results.push([ints[i], ints[j]])
return results;
}
}
}
}

javascript reverse an array without using reverse()

I want to reverse an array without using reverse() function like this:
function reverse(array){
var output = [];
for (var i = 0; i<= array.length; i++){
output.push(array.pop());
}
return output;
}
console.log(reverse([1,2,3,4,5,6,7]));
However, the it shows [7, 6, 5, 4] Can someone tell me, why my reverse function is wrong? Thanks in advance!

array.pop() removes the popped element from the array, reducing its size by one. Once you're at i === 4, your break condition no longer evaluates to true and the loop ends.
One possible solution:
function reverse(array) {
var output = [];
while (array.length) {
output.push(array.pop());
}
return output;
}
console.log(reverse([1, 2, 3, 4, 5, 6, 7]));

You can make use of Array.prototype.reduceright and reverse it
check the following snippet
var arr = ([1, 2, 3, 4, 5, 6, 7]).reduceRight(function(previous, current) {
previous.push(current);
return previous;
}, []);
console.log(arr);

In ES6 this could be written as
reverse = (array) => array.map(array.pop, [... array]);

No need to pop anything... Just iterate through the existing array in reverse order to make your new one.
function reverse(array){
var output = [];
for (var i = array.length - 1; i> -1; i--){
output.push(array[i]);
}
return output;
}
console.log(reverse([1,2,3,4,5,6,7]));
Edit after answer got accepted.
A link in a comment on your opening post made me test my way VS the accepted answer's way. I was pleased to see that my way, at least in my case, turned out to be faster every single time. By a small margin but, faster non the less.
Here's the copy/paste of what I used to test it (tested from Firefox developer scratch pad):
function reverseMyWay(array){
var output = [];
for (var i = array.length - 1; i> -1; i--){
output.push(array[i]);
}
return output;
}
function reverseTheirWay(array) {
var output = [];
while (array.length) {
output.push(array.pop());
}
return output;
}
function JustDoIt(){
console.log("their way starts")
var startOf = new Date().getTime();
for(var p = 0; p < 10000; p++)
{
console.log(reverseTheirWay([7,6,5,4,3,2,1]))
}
var endOf = new Date().getTime();
console.log("ran for " + (endOf - startOf) + " ms");
console.log("their way ends")
}
function JustDoIMyWay(){
console.log("my way starts")
var startOf = new Date().getTime();
for(var p = 0; p < 10000; p++)
{
console.log(reverseMyWay([7,6,5,4,3,2,1]))
}
var endOf = new Date().getTime();
console.log("ran for " + (endOf - startOf) + " ms");
console.log("my way ends")
}
JustDoIt();
JustDoIMyWay();

Solution to reverse an array without using built-in function and extra space.
let arr = [1, 2, 3, 4, 5, 6, 7];
let n = arr.length-1;
for(let i=0; i<=n/2; i++) {
let temp = arr[i];
arr[i] = arr[n-i];
arr[n-i] = temp;
}
console.log(arr);

Do it in a reverse way, Because when you do .pop() every time the array's length got affected.
function reverse(array){
var output = [];
for (var i = array.length; i > 0; i--){
output.push(array.pop());
}
return output;
}
console.log(reverse([1,2,3,4,5,6,7]));
Or you could cache the length of the array in a variable before popping out from the array,
function reverse(array){
var output = [];
for (var i = 0, len= array.length; i< len; i++){
output.push(array.pop());
}
return output;
}
console.log(reverse([1,2,3,4,5,6,7]));

You are modifying the existing array with your reverse function, which is affecting array.length.
Don't pop off the array, just access the item in the array and unshift the item on the new array so that the first element of the existing array becomes the last element of the new array:
function reverse(array){
var output = [],
i;
for (i = 0; i < array.length; i++){
output.unshift(array[i]);
}
return output;
}
console.log(reverse([1,2,3,4,5,6,7]));
If you'd like to modify the array in-place similar to how Array.prototype.reverse does (it's generally inadvisable to cause side-effects), you can splice the array, and unshift the item back on at the beginning:
function reverse(array) {
var i,
tmp;
for (i = 1; i < array.length; i++) {
tmp = array.splice(i, 1)[0];
array.unshift(tmp);
}
return array;
}
var a = [1, 2, 3, 4, 5];
console.log('reverse result', reverse(a));
console.log('a', a);

This piece allows to reverse the array in place, without pop, splice, or push.
var arr = [1, 2, 3, 4, 5];
function reverseArrayInPlace(arr2) {
var half = Math.floor(arr2.length / 2);
for (var i = 0; i < half; i++) {
var temp = arr2[arr2.length - 1 - i];
arr2[arr2.length - 1 - i] = arr2[i];
arr2[i] = temp;
}
return arr2;
}

As you pop items off the first array, it's length changes and your loop count is shortened. You need to cache the original length of the original array so that the loop will run the correct amount of times.
function reverse(array){
var output = [];
var len = array.length;
for (var i = 0; i< len; i++){
output.push(array.pop());
}
return output;
}
console.log(reverse([1,2,3,4,5,6,7]));

You're modifying the original array and changing it's size. instead of a for loop you could use a while
function reverse(array){
var output = [];
while(array.length){
//this removes the last element making the length smaller
output.push(array.pop());
}
return output;
}
console.log(reverse([1,2,3,4,5,6,7]));

function rvrc(arr) {
for (let i = 0; i < arr.length / 2; i++) {
const buffer = arr[i];
arr[i] = arr[arr.length - 1 - i];
arr[arr.length - 1 - i] = buffer;
}
};

const reverse = (array)=>{
var output = [];
for(let i=array.length; i>0; i--){
output.push(array.pop());
}
console.log(output);
}
reverse([1, 2, 3, 4, 5, 6, 7, 8]);

This happens because every time you do array.pop(), whilst it does return the last index in the array, it also removes it from the array. The loop recalculates the length of the array at each iteration. Because the array gets 1 index shorter at each iteration, you get a much shorter array returned from the function.

This piece of code will work without using a second array. It is using the built in method splice.
function reverse(array){
for (let i = 0; i < array.length; i++) {
array.splice(i, 0, array.splice(array.length - 1)[0]);
}
return array;
}

Here, let's define the function
function rev(arr) {
const na = [];
for (let i=0; i<arr.length; i++) {
na.push(arr[arr.length-i])
}
return na;
}
Let's say your array is defined as 'abca' and contains ['a','b','c','d','e','foo','bar']
We would do:
var reva = rev(abca)
This would make 'reva' return ['bar','foo','e','d','c','b','a'].
I hope I helped!

You can use .map as it is perfect for this situation and is only 1 line:
const reverse = a =>{ i=a.length; return a.map(_=>a[i-=1]) }
This will take the array, and for each index, change it to the length of the array - index, or the opposite side of the array.

with reverse for loop
let array = ["ahmet", "mehmet", "aslı"]
length = array.length
newArray = [];
for (let i = length-1; i >-1; i--) {
newArray.push(array[i])
}
console.log(newArray)

And this one:
function reverseArray(arr) {
let top = arr.length - 1;
let bottom = 0;
let swap = 0;
while (top - bottom >= 1) {
swap = arr[bottom];
arr[bottom] = arr[top];
arr[top] = swap;
bottom++;
top--;
}
}

function reverse(arr) {
for (let i = 0; i < arr.length - 1; i++) {
arr.splice(i, 0, arr.pop())
}
return arr;
}
console.log(reverse([1, 2, 3, 4, 5]))
//without another array

reverse=a=>a.map((x,y)=>a[a.length-1-y])
reverse=a=>a.map((x,y)=>a[a.length-1-y])
console.log(reverse(["Works","It","One","Line"]))

One of shortest:
let reverse = arr = arr.map(arr.pop, [...arr])

This is an old question, but someone may find this helpful.
There are two main ways to do it:
First, out of place, you basically push the last element to a new array, and use the new array:
function arrReverse(arr) {
let newArr = [];
for(let i = 0; i<arr.length; i++){
newArr.push(arr.length -1 -i);
}
return newArr;
}
arrReverse([0,1,2,3,4,5,6,7,8,9]);
Then there's in place. This is a bit tricky, but the way I think of it is like having four objects in front of you. You need to hold the first in your hand, then move the last item to the first place, and then place the item in your hand in the last place.
Afterwards, you increase the leftmost side by one and decrease the rightmost side by one:
function reverseArr(arr) {
let lh;
for(let i = 0; i<arr.length/2; i++){
lh = arr[i];
arr[i] = arr[arr.length -i -1];
arr[arr.length -i -1] = lh;
}
return arr;
}
reverseArr([0,1,2,3,4,5,6,7,8,9]);
Like so. I even named my variable lh for "left hand" to help the idea along.
Understanding arrays is massively important, and figuring out how they work will not only save you from unnecessarily long and tedious ways of solving this, but will also help you grasp certain data concepts way better!

I found a way of reversing the array this way:
function reverse(arr){
for (let i = arr.length-1; i >= 0; i--){
arr.splice(i, 0, arr.shift());
}
return arr;
}

Without Using any Pre-define function
const reverseArray = (array) => {
for (let i = 0; i < Math.floor(array.length / 2); i++) {
[array[i], array[array.length - i - 1]] = [
array[array.length - i - 1],
array[i]
];
}
return array;
};

let array = [1,2,3,4,5,6];
const reverse = (array) => {
let reversed = [];
for(let i = array.length - 1; i >= 0; i--){
reversed[array.length - i] = array[i];
}
return reversed;
}
console.log(reverse(array))

you can use the two pointers approach
example
function reverseArrayTwoPointers(arr = [1, 2, 3, 4, 5]) {
let p1 = 0;
let p2 = arr.length - 1;
while (p2 > p1) {
const temp = arr[p1];
arr[p1] = arr[p2];
arr[p2] = temp;
p1++;
p2--;
}
return arr;
}
to return [5,4,3,2,1]
example on vscode

let checkValue = ["h","a","p","p","y"]
let reverseValue = [];
checkValue.map((data, i) => {
x = checkValue.length - (i + 1);
reverseValue[x] = data;
})

function reverse(str1) {
let newstr = [];
let count = 0;
for (let i = str1.length - 1; i >= 0; i--) {
newstr[count] = str1[i];
count++;
}
return newstr;
}
reverse(['x','y','z']);

Array=[2,3,4,5]
for(var i=0;i<Array.length/2;i++){
var temp =Array[i];
Array[i]=Array[Array.length-i-1]
Array[Array.length-i-1]=temp
}
console.log(Array) //[5,4,3,2]

Categories

Resources