Advanced-Frontend/Daily-Interview-Question

第 77 题：旋转数组算法题

ZodiacSyndicate opened this issue · 136 comments

ZodiacSyndicate commented

因为步数有可能大于数组长度，所以要先取余

function rotate(arr, k) {
  const len = arr.length
  const step = k % len
  return arr.slice(-step).concat(arr.slice(0, len - step))
}
// rotate([1, 2, 3, 4, 5, 6], 7) => [6, 1, 2, 3, 4, 5]
sgzhm4444 commented 
var arr = [-1, -100, 3, 99];
var k = 5;

for (let i = 0; i < k; i++) {
	let val = arr.pop();
	arr.unshift(val);
}

console.log(arr);
  • 👍40
  • 👎6
zxcweb commented 
var rotate = function(nums, k) {
    for(var i = 0;i<k;i++){
        nums.unshift(nums.pop())
    }
    return nums;
}
  • 👍23
YouziXR commented 
/* 第 77 题：旋转数组算法题

给定一个数组，将数组中的元素向右移动 k 个位置，其中 k 是非负数。

输入: [1, 2, 3, 4, 5, 6, 7] 和 k = 3
输出: [5, 6, 7, 1, 2, 3, 4]
解释:
向右旋转 1 步: [7, 1, 2, 3, 4, 5, 6]
向右旋转 2 步: [6, 7, 1, 2, 3, 4, 5]
向右旋转 3 步: [5, 6, 7, 1, 2, 3, 4] */

const rotateAry = (ary, k) => {
	let len = ary.length
	let rotateNum = k % len
	if (rotateNum === 0) {
		return ary
	}
	let tmpAry = new Array(len)
	ary.forEach((el, index) => {
		if ((index + rotateNum) >= len) {
			tmpAry[index + rotateNum - len] = el
		} else {
			tmpAry[index + rotateNum] = el
		}
	})
	return tmpAry
}
console.log(rotateAry([1, 2, 3, 4, 5, 6, 7], 3))

这么一对比我的写法好low啊= =

  • 😄6
  • ❤️2
  • 🚀3
Rashomon511 commented

用splice就好了嘛
就不用考虑步数超出数组长度
一行代码解决问题

function rotateArr(arr, k) { 
    return [...arr.splice(k+1), ...arr];
}

image

你这个是不是有点问题，你把key换成1试一试

  • 👍11
  • 👎4
francecil commented

问题转化为：数组的末尾k个元素移动到数组前面
末尾元素：arr.splice(-k%arr.length)的返回值
剩余元素：arr

const moveArr = (arr,k)=>arr.splice(-k%arr.length).concat(arr)

test:
moveArr([1,2,3,4,5,6,7],0) => [1,2,3,4,5,6,7]
moveArr([1,2,3,4,5,6,7],5) => [3,4 5,6,7,1,2]
moveArr([1,2,3,4,5,6,7],8) => [7,1,2,3,4,5,6]

  • 👍37
  • ❤️1
RichardPear commented

找到一个合适的位置剪掉，unshift到原来的数组， 题目的意思应该是要改变原来的数组，所以直接对原数组开刀。

Array.prototype.rotate = function rotateArr(k = 0) {
    const len = this.length;
    if(!len) {
	return this;
    }
    k = k % len;
    if(k <= 0) {
	return this;
    }
    const cut = this.splice(len - k);
    return this.unshift(...cut);
}
let a = [1, 2, 3, 4, 5, 6];
a.rotate(3);
  • 👍1
ChasLui commented 
function rotateArr(arr, k) { 
    return [...arr.splice(k+1), ...arr];
}

拷贝下数组, 防止修改入参

function rotateArr(arr, k) {
  const _tmp = JSON.parse(JSON.stringify(arr));
  return [..._tmp.splice(k + 1), ..._tmp];
}
benzhemin commented 
function rotateStep(arr: any[]) {
  arr.unshift(arr.pop());
}

function rotateTimes(arr: any[], k: number) {
  for(let i=0; i<k; i++) {
    rotateStep(arr);
  }
}

const  arr = [1, 2, 3, 4, 5, 6, 7, 8];
rotateTimes(arr, 1);

console.log(`arr ${JSON.stringify(arr)}`);
dhzou commented

var a = [1,2,3,4,5,6,7];
var move = function(arr,k) {
const len = arr.length
const step = k % len
return arr.slice(len-step).concat(arr.slice(0, len - step))
}
console.log(move(a,3))

kungithub commented

function f(arr,k){arr.unshift(...arr.splice(-k)); console.log(arr) }

  • 👍1
  • 😕2
kingstone3 commented

用splice就好了嘛
就不用考虑步数超出数组长度
一行代码解决问题

function rotateArr(arr, k) { 
    return [...arr.splice(k+1), ...arr];
}

image

你这个是不是有点问题，你把key换成1试一试

把 k+1 改成 -k 就好了

  • 👍3
  • 👀2
ChasLui commented 
function rotate(arr, k) {
  if (!Array.isArray(arr) || !arr.length) {
    console.error('参数 arr 必须为长度大于 0 的数组');
    return [];
  }
  if (!Number.isInteger(k) || k <= 0) {
    console.error('参数 k 必须为非负整数');
    return [];
  }
  const _tmp = JSON.parse(JSON.stringify(arr));
  return [..._tmp.splice(-k % _tmp.length), ..._tmp];
}

// test
const arr = [1, 2, 3, 4, 5, 6, 7];
console.log(rotate(arr, 0)); // [1, 2, 3, 4, 5, 6, 7]
console.log(arr); // [1, 2, 3, 4, 5, 6, 7], 纯函数,不改变原数组
console.log(rotate(arr, 'aaa')); // []
console.log(rotate(arr, 2)); // [ 6, 7, 1, 2, 3, 4, 5 ]
yaonote commented 
const changeArr = (arr,k) => {
    const len = arr.length;
    return arr.reduce((acc,curr,idx,origin) => {
        const temp = idx+k <= len-1 ? idx+k : idx+k-len;
        acc[temp] = curr;
        return acc
    },[])
}
Hunterang commented

let rotArr = (arr,k) => {
let len = arr.length
return [...arr,..arr].slice(k,len+k)
}

  • 😄1
keiseiTi commented

leetcode 第77题
尽可能想出更多的解决方案，至少有三种不同的方法可以解决这个问题。
要求使用空间复杂度为 O(1) 的原地算法。

/**
 * @param {number[]} nums
 * @param {number} k
 * @return {void} Do not return anything, modify nums in-place instead.
 */
var rotate = function (nums, k) {
  nums.unshift(...nums.splice(nums.length - k, k))
  return nums
};
  • 👀1
wubetter commented 
let arr = [1, 2, 3, 4, 5, 6, 7];
let rotate = (arr,k)=>[...arr.slice(-k),...arr.slice(0,-k)]
  • 👍2
bran-nie commented

找到一个合适的位置剪掉，unshift到原来的数组， 题目的意思应该是要改变原来的数组，所以直接对原数组开刀。

Array.prototype.rotate = function rotateArr(k = 0) {
    const len = this.length;
    if(!len) {
	return this;
    }
    k = k % len;
    if(k <= 0) {
	return this;
    }
    const cut = this.splice(len - k);
    return this.unshift(...cut);
}
let a = [1, 2, 3, 4, 5, 6];
a.rotate(3);

这操作。。。
之前了解到的一个建议是尽量避免在原型链上添加方法。

bran-nie commented 
let arr1 = [1, 2, 3, 4, 5]
function func(arr, num) {
    if (num % arr.length === 0) return arr
    return arr.splice(arr.length - (num%arr.length)).concat(arr)
}

image

  • 😄2
pengcc commented 
let rotateRight = (arr, k) => [...arr.slice(arr.length - k), ...arr.slice(0, arr.length - k)];
mengsixing commented 
function rotateArray(array, step) {
    // 旋转长度超过数组长度，只需要旋转余数就行了
    step = step % array.length;
    // splice 方法同时会将原数组截断
    var rotateArray = array.splice(array.length - step);
    // 重新拼接
    return rotateArray.concat(array);
}
rotateArray([1, 2, 3, 4, 5], 6);
wingmeng commented

编程式实现，见笑了

function rotateArr(arr, k) {
  let len = arr.length;
  let result = [];

  k = k > len ? k % len : k;

  for (let i = len - 1; i >= 0; i--) {
    if (len - i <= k) {
      result.unshift(arr[i]);
    } else {
      result[i + k] = arr[i];
    }
  }

  return result;
}
wingmeng commented

因为步数有可能大于数组长度，所以要先取余

function rotate(arr, k) {
  const len = arr.length
  const step = k % len
  return arr.slice(-step).concat(arr.slice(0, len - step))
}
// rotate([1, 2, 3, 4, 5, 6], 7) => [6, 1, 2, 3, 4, 5]

当 k = 0 或 k = arr.length 时，返回结果有误：
rotate([1, 2, 3, 4, 5, 6], 6); // [1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6]

  • 👍1
i-lijin commented

function rotateArr(arr,k){
return[...arr.splice(-k), ...arr]
}

LiuMengzhou commented 
/**
 * solution1
 * 最短路径逐个转移
 */
var rotate = function (nums, k) {
  const len = nums.length;
  let c = k % len;
  if (c > len / 2) {
    c = len - c;
    while (c > 0) {
      nums.push(nums.shift());
      c--;
    }
  }
  else {
    while (c > 0) {
      nums.unshift(nums.pop());
      c--;
    }
  }
};

/**
 * solution2
 * 妙用API一次性转移
 */
var rotate = function (nums, k) {
  nums.unshift(...nums.splice(- (k % nums.length)));
};

/**
 * solution3
 * 三次翻转
 */
var rotate = function (nums, k) {
  k %= nums.length;
  reverse(nums, 0, nums.length - 1);
  reverse(nums, 0, k - 1);
  reverse(nums, k, nums.length - 1);
};

function reverse(nums, start, end) {
  while (start < end) {
    let temp = nums[start];
    nums[start] = nums[end];
    nums[end] = temp;
    start++;
    end--;
  }
}
  • 👍5
  • 😄1
  • 🎉1
  • ❤️1
  • 🚀1
LiuMengzhou commented

用splice就好了嘛
就不用考虑步数超出数组长度
一行代码解决问题

function rotateArr(arr, k) { 
    return [...arr.splice(k+1), ...arr];
}

image

@zpzxgcr 仔细看题目的example老哥

输入: [1, 2, 3, 4, 5, 6, 7] 和 k = 3
输出: [5, 6, 7, 1, 2, 3, 4]
解释:
向右旋转 1 步: [7, 1, 2, 3, 4, 5, 6]
向右旋转 2 步: [6, 7, 1, 2, 3, 4, 5]
向右旋转 3 步: [5, 6, 7, 1, 2, 3, 4]
LiuMengzhou commented 
var rotate = function(nums, k) {
    for(var i = 0;i<k;i++){
        nums.unshift(nums.pop())
    }
    return nums;
}

@zxcweb k = 10000000000

LiuMengzhou commented 
function rotateArr(arr, k) { 
    return [...arr.splice(k+1), ...arr];
}

拷贝下数组, 防止修改入参

function rotateArr(arr, k) {
  const _tmp = JSON.parse(JSON.stringify(arr));
  return [..._tmp.splice(k + 1), ..._tmp];
}

@ChasLui
这样拷贝数组的操作我头一次见。

const _tmp = [...arr];
  • 👍1
LiuMengzhou commented

function f(arr,k){arr.unshift(...arr.splice(-k)); console.log(arr) }

var rotate = function (nums, k) {
nums.unshift(...nums.splice(nums.length - k, k))
return nums
};

function rotateArr(arr,k){
return[...arr.splice(-k), ...arr]
}

@kungithub
@kingstone3
@yupeilin123
@i-lijin
都试试下面这个case

f([1,2],13);
> [1, 2]
kingstone3 commented

function f(arr,k){arr.unshift(...arr.splice(-k)); console.log(arr) }
var rotate = function (nums, k) {
nums.unshift(...nums.splice(nums.length - k, k))
return nums
};
function rotateArr(arr,k){
return[...arr.splice(-k), ...arr]
}

@kungithub
@kingstone3
@yupeilin123
@i-lijin
都试试下面这个case

f([1,2],13);
> [1, 2]
function rotateArr(arr, k) { 
  return [...arr.splice(-(k % arr.length)), ...arr];
}
  • 👍1
kingstone3 commented 
function rotateArr(arr, k) { 
    return [...arr.splice(k+1), ...arr];
}

拷贝下数组, 防止修改入参

function rotateArr(arr, k) {
  const _tmp = JSON.parse(JSON.stringify(arr));
  return [..._tmp.splice(k + 1), ..._tmp];
}

@ChasLui
这样拷贝数组的操作我头一次见。

const _tmp = [...arr];

@LiuMengzhou
... 是 rest/spread 运算符:

  1. 作为 rest 的情况:
    函数声明中作为剩余参数，例如 functuin foo(...args) {}
    解构赋值中收集剩余元素: let [a, ...arr] = [1, 2, 3, 4] 或 let {a, ...obj} = {a: 1, b:2, c:3}
  2. 作为 spread 的情况:
    数组: let arr = [1, ...[2, 3]]
    对象: let obj = {a: 1, ...otherObj}

https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Functions/Rest_parameters
https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Operators/Spread_syntax

  • 👍1
LiuMengzhou commented

@kingstone3 老哥可以的～还引经据典。这些我都会。你看看他的回答

const _tmp = JSON.parse(JSON.stringify(arr)); // 那位老哥写的
const _tmp = [...arr]; // 我写的
kingstone3 commented

@LiuMengzhou
他的那个方法我也看过，不过有些缺陷 javascript经典面试题之拷贝

5SSS commented 
function rotateArr (arr, step) {
	if (arr.length <= 0) {
		return arr
	}
	let count = step % arr.length
	return arr.splice(-count).concat(arr)
}
FounderIsShadowWalker commented

function Test(a, k){
k = k % a.length;
do{
TransformUnit(a);
k--;
}while(k>0)
return a;
}

function TransformUnit(a){
var first = a[0];
for(var i=0; i<a.length - 1; i++){
a[i] = a[i+1];
}
a[a.length - 1] = first;
return a;
}
console.error(Test([1,2,3,4,5,6,7], 7));

Tsionhe commented 
const moveArr = (arr, k) => {
    const arrLeft = arr.splice(arr.length - k, k);
    return arrLeft.concat(arr);
};

moveArr([1, 2, 3, 4, 5, 6, 7], 1); // [7, 1, 2, 3, 4, 5, 6]
moveArr([-1, -100, 3, 99], 2); // [3, 99, -1, -100]
rocky-191 commented 
var arr = [-1, -100, 3, 99];
var k = 5;

for (let i = 0; i < k; i++) {
	let val = arr.pop();
	arr.unshift(val);
}

console.log(arr);

如果移动步数大于数组长度的话可能会重复

arieltlm commented

let rotArr = (arr,k) => {
let len = arr.length
return [...arr,..arr].slice(k,len+k)
}

这里应该是return [...arr,...arr].slice(len-k%len, len * 2 - k%len)吧

DWNEWS-jixiaohong commented 
var arr = [1,2,3,4,5,6,7,8,9];
function arrMoveStep(arr, k) {
  const len  = arr.length;
  let copyArr = JSON.parse(JSON.stringify(arr))
  return [...copyArr.splice(len - (k % len) , len),...copyArr]
}
console.log(arr)//[ 1, 2, 3, 4, 5, 6, 7, 8, 9 ]
console.log(arrMoveStep(arr, 14))//[ 5, 6, 7, 8, 9, 1, 2, 3, 4 ]
console.log(arrMoveStep(arr, 7))//[ 3, 4, 5, 6, 7, 8, 9, 1, 2 ]
Caitingwei commented 
function rotate(arr, k) {
  arr.unshift(...arr.splice(arr.length - k, k));
  return arr;
}
B2D1 commented 
const rotate = (arr, step) => {
  let len = arr.length;
  return arr.reduce((acc, v, i) => {
    return i + step >= len
      ? ((acc[i + step - len] = v), acc)
      : ((acc[i + step] = v), acc);
  }, []);
};

rotate([-1, -100, 3, 99] , 2);  // [3, 99, -1, -100]
ckjie commented

function rotateArr( arr, k ) {
  for( let i = 0; i < k; i++) {
    arr.unshift( arr.pop() )
  }
  return arr;
}

dorseysen commented 
//  the first solution，利用映射
const rotateArray0 = (arr, size) => arr.map((item, index) => arr[ (index - size + arr.length ) % arr.length]);

console.log(rotateArray0([1, 2, 3, 4, 5, 6], 3));

//  the second solution 利用splice

const rotateArray = (arr, size) => [...arr.splice(size % arr.length), ...arr];

console.log(rotateArray([1, 2, 3, 4, 5, 6], 3));
yangxy6 commented

// splice
const rotateArray = (arr, k) => arr.splice(arr.length - k).concat(arr);

yucopowo commented 
const arr = [1, 2, 3, 4, 5, 6, 7];
const k = 3;
console.log(
      Array.from({length:arr.length},(x,i)=>arr[(i+k+arr.length%2)%arr.length])
)
linlinyang commented 
    var arr = [1, 2, 3, 4, 5, 6, 7];

    function reverse(arr,k){
        k = k % arr.length;
        while(k--){
            arr.unshift(arr.pop());
        }
    }

    reverse(arr,3);
    console.log(arr);
LINNO1 commented

function rotate(arr,k){
while(k){
arr.unshift(arr.pop());
k--;
}
return arr;
}

NANAYWY commented 
function move (attr,num) {
  let oldAttr=[];
  if(Array.isArray(attr) && typeof(num)==='number'&&num>-1){
    attr.map((v,i)=>{
      if(i+num>=attr.length)  num-=attr.length
        oldAttr.splice(i+num, 0, v);
    })
    return oldAttr
  }else{
    throw  new Error('请输入数组及大于-1的数字')
  }

}
AchillesV commented 
function rotateArr(arr, k) {
    const temp = [];
    for(let i=0; i<k; i++) {
        temp.push(arr.pop());
    }
    return [...temp, ...arr]
}
azl397985856 commented

leetcode原题，以下是参考答案：

var rotate = function(nums, k) {
  // 就像扩容一样操作
  k = k % nums.length;
  const n = nums.length;

  for (let i = nums.length - 1; i >= 0; i--) {
    nums[i + k] = nums[i];
  }

  for (let i = 0; i < k; i++) {
    nums[i] = nums[n + i];
  }
  nums.length = n;
};

如果你对数据结构和算法感兴趣，欢迎关注我的leetcode题解

dengshangli commented 
   function rotate (arr, k) {
     for (let index = 0; index < k; index++) {
       const item = arr.pop()
       arr.unshift(item)
     }
    return arr
   }

   console.log(rotate([1, 2, 3, 4, 5, 6, 7], 3))
Mrlhz commented 
function rotate(arr, k) {
  if (!arr) throw Error('requires an array')
  if (!k || k < 0) return arr

  let n = k % arr.length
  let stack = [].concat(arr)

  let index = 1

  while (n) {
    stack.unshift(stack.pop())
    n--
    console.log(`向右旋转 ${index++} 步`, stack);
  }

  return stack
}

console.log(rotate([1, 2, 3, 4, 5, 6, 7], 3))
console.log(rotate([-1, -100, 3, 99], 2))
console.log(rotate([1, 2], 13))
console.log(rotate([1, 2], -1))
console.log(rotate([1, 2, 3, 4, 5, 6, 7]))
console.log(rotate([]))
cheungzh commented 
function move(arr, step) {
  let length = arr.length;
  let hash = arr.reduce((hash, value, key) => {
    hash[key] = value;
    return hash;
  }, {});
  let newHash = Object.keys(hash).reduce((newHash, key) => {
    key = Number(key);
    let newKey = key + step > length - 1 ?  key + step - length : key + step;
    newHash[newKey] = hash[key]; 
    return newHash;
  }, {})
  return Array.from({...newHash, length})
}
用了一个很蠢的方式
  • 👍1
montage-f commented 
const rightMove = (arr: Array<number>, step: number) => {
    while (step > 0) {
        arr.unshift(arr.pop());
        step--;
    }
    return arr;
};
console.log(leftMove([1, 2, 3, 4, 5, 6, 7], 3));
console.log(leftMove([-1, -100, 3, 99], 2));

image

yangxinSamsara commented

let arr = [1, 2, 3, 5, 4, -12, -23, 56];

    function rotateArr(arr, k) {
        if (k <= 0) {
            return arr;
        }
        for (let i = 1; i <= k; i++) {
            const last = arr[arr.length - 1];
            arr.pop();
            arr.unshift(last)
        }
        return arr
    }

    rotateArr(arr, 3)
mao-th commented

function rotate(arr, k) { let list = arr.slice(0); list.reduce((target, cur, curIndex, arr)) { target[(curIndex + k) % arr.length] = cur; return target; }, arr) ; }

1045598742 commented

因为步数有可能大于数组长度，所以要先取余

function  rotate（arr，k）{
   const  len  =  arr。length 
  const  step  = k ％ len
   return  arr。切片（-步骤）。concat（arr。切片（0，len - step））
}
// rotate（[1,2,3,4,5,6]，7）=> [6,1,2,3,4,5]

let arrd= [1, 2, 3, 4, 5, 6, 7];
function rotate(arr, k) {
const len = arr.length
const step = k % len
console.log(step);
return arr.slice(-step).concat(arr.slice(0, len - step))
}
console.log(rotate(arrd,7)); //[1, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7]
当k等于数组长度就尴尬了
改成 const step = k % len||len;

zjkblade commented 
    let arr = [-1, -100, 3, 99];
    let k = 2;
    let test = (array, key) => [...array.splice(-key), ...array];
    console.log(test([...arr], k));
tengwei30 commented

/**

  • 旋转数组
  • 给定一个数组，将数组中的元素向右移动 k 个位置，其中 k 是非负数
    */

const reverseArr = (arr, k) => {
if (arr.length < k) return
const newarr = arr.splice(arr.length - k, k)
console.log([...newarr, ...arr])
}
reverseArr([1, 2, 3, 4, 5, 6, 7], 3)

image

lvzhiyi commented

上面大部分答案是splice截取再添加，我这里提供另外一种算法：

  • 只是将原数组index移动key个位置即可，超出数组长度，依次添加在数组头部，相当于固定位数的链表循环
function transformArr(arr, key){
    let resArr = [];
    arr.forEach((item, i) => {
        resArr[i] = i - key >= 0 ? arr[i - key] : arr[arr.length - key + i]
    });

    return resArr;
}
  • 👍1
  • 🎉1
  • ❤️1
  • 🚀1
daiyunchao commented 
var arr=[1,2,3,4,5,6,7];
var k=3;

var length=arr.length;
var moveCount=Math.abs(k%length);
console.log(moveCount)
if(moveCount>0){
	for(let i=0;i<moveCount;i++){
		let v=arr.splice(length-1,1);
		console.log(v)
		arr.unshift(...v)
	}
}
console.log(arr);
DarthVaderrr commented

leetcode初级算法数组原题
原地修改,可以这样:
1.reverse原数组 [ 1,2,3,4,5,6,7 ]===>[ 7,6,5,4,3,2,1 ]
2.reverse前k项 (k=2) [ 7,6,5,4,3,2,1 ]===>[ 6,7,5,4,3,2,1 ]
3.reverse剩余项 [ 6,7,5,4,3,2,1 ]===>[ 6,7,1,2,3,4,5]

weiweiwu01 commented

let arr = [1, 2, 3, 4, 5, 6, 7];
function handleArr(arr,k){
while(k--){
arr.unshift(arr.pop())
}
return arr
}
let newArr = handleArr(arr,2)
console.log(newArr)

tumimowei commented

function turnArr(arr,num){
let arrlen = arr.length;
if(arrlen < num) return -1;
var newArr = [];
for(var i=0;i<arrlen;i++){
if((i+num)<arrlen){
newArr[i+num] = arr[i]
}else{
var xiabiao = (i+num)%arrlen
newArr[xiabiao] = arr[i]
}
}
return newArr
}

  • 😄1
yuwanli commented 
function circleArr(arr,step){
    const storeArr = []
    storeArr[0] = arr.splice(-1 * step)
    storeArr[1] = arr
    return storeArr.flat(1)
}
tzh11 commented

arr.map((a, index) => arr[(index - k % arr.length + arr.length) % arr.length])

tianjucun commented

let arr = [1, 2, 3, 4, "5", "6"];

const step = 2 % arr.length; // 避免步长超过数组大小

let sliceArr = arr.slice(0, arr.length - step);

let spliceArr = [].splice.bind(sliceArr, 0, 0);

spliceArr.apply(this, arr.slice(-step));

console.log(sliceArr); // [ '5', '6', 1, 2, 3, 4 ]

  • 👍1
  • 👀1
mrhuang2365 commented

function fn(arr, k){ const r = k % arr.length return arr.concat(arr.splice(0, r+1)) }

zhangyuanze commented

function rotateArr(arr, k) {
let temp=arr.splice(-k);
temp.push(...arr);
return temp;
}

  • 👍1
  • 😄1
  • 🎉1
  • 🚀1
  • 👀1
yaodongyi commented 
function rotate(arr, k) {
  Array.from({ length: k }).map(() => arr.unshift(arr.pop()));
  return arr;
}
rotate(arr, k);
lzxxxxx commented

in-place 的解法来一波，不包含unshift/pop等数组的操作，先计算每一项在移动之后应该在的位置，然后依次赋值

let arr = [1,2,3,4,5];
function rotate (array, k){
  a = [...array];
  k = k % 5;
  for(let i=0;i<a.length;i++){
    array[i] = a[(i+a.length-k)%a.length];
  }
}
rotate(arr, 1);
xuyaodegithub commented

console.log([...abc.splice(abc.length-(k % abc.length)),...abc])

  • 👍1
  • 🎉1
aeolusheath commented

咋一看是对的。。实际上是错的。

    function rotate(arr, num) {
        return arr.splice(arr.length - num).concat(...arr)
      }

看了大家的回答才知道，因为移动的距离是可能大于数组的长度的。。。。

      function rotate(arr, num) {
        return arr.splice(arr.length - (num % arr.length) ).concat(...arr)
      }

上面还有位大兄弟的做法很赞，每次pop然后unshift到最前面。仍然需要求余数！！！！！！！

      function rotate(arr, num) {
        for (let i = 0, j = num % arr.length; i < j; i++) {
          arr.unshift(arr.pop())
        }
        return arr
      }
YeahPotato commented 
for(let i=0;i<k;i++){
    arr.unshift(arr.pop())
}
Wuxiaa commented 
function fn(arr,k){
	let temp = arr.splice(arr.length - k,arr.length)
	let result = [...temp,...arr]
	return result
}
fn(arr,2)

小白问一下代码怎么高亮啊

Fzzzzy commented 
function rotate(a, k) {
    k %= a.length;
    let pre = a.splice(0, k + 1);
    return a.concat(pre);
}
tywei90 commented

一行代码解决：

function rotate(arr, k) {
	return [...arr.splice(arr.length-k, k), ...arr]
}
DavidChen93 commented

function rotate(arr, k) {
return arr.splice(arr.length - k).concat(arr)
}

huangjieqiu commented 
function rotate(arr, step) {
    var _arr = arr.slice()
    while (step--) {
        _arr.unshift(_arr.pop())
    }
    return _arr
}
772658652 commented

let arr =[1, 2, 3, 4, 5, 6, 7];
function reverse(arr,k) {
while (k) {
arr = [arr.pop()].concat(arr);
k--;
}
return arr;
}

reverse(arr,3);

libin1991 commented 
function rotate(arr, k) {
  const len = arr.length
  const step = k % len
  return [...arr.slice(-step),...arr.slice(0, len - step)] ;
}
// rotate([1, 2, 3, 4, 5, 6], 7)
// [6, 1, 2, 3, 4, 5]
zhouqj1414657557 commented

来一个普普通通的

 let As = [1, 2, 3, 4, 5, 6, 7]
  let k = 3
  let newArry = []
  let oldArry = []
  for (let i = 1; i < (As.length - k); i++) {
    newArry.push(As[i + k])
  }
  for (let i = 0; i <= k; i++) {
    oldArry.push(As[i])
  }
  console.log([...newArry, ...oldArry])
  • 👍1
  • 😄1
  • 🎉1
  • ❤️1
  • 🚀1
  • 👀1
xl-wolf commented

var arr = [1, 2, 3, 4, 5, 6, 7];
var k = 3;
rotate(arr,k)

function rotate(arr,k){
for (var i = 0; i < k; i++) {
if(k>arr .length) return
for (var j = 0; j < arr.length; j++) {
if (j == arr.length - 1) {
var tempItem = arr.splice(j, 1);
arr.unshift(tempItem[0]);
}
}
}
}
console.log(arr);

lanOrage commented

const arr = [1, 2, 3, 4, 5, 6, 7]
function rotate(arr, k) {
while (k) {
k-- && arr.unshift(arr.pop())
}
console.log(arr)
}
rotate(arr, 8)
这样不就好了？

xiaoang commented

function stackWheel(arr , len){
return arr.splice(-len,len).concat(arr);
}

yygmind commented

给定一个数组，将数组中的元素向右移动 k 个位置，其中 k 是非负数。

示例 1：

输入: [1, 2, 3, 4, 5, 6, 7] 和 k = 3
输出: [5, 6, 7, 1, 2, 3, 4]
解释:
向右旋转 1 步: [7, 1, 2, 3, 4, 5, 6]
向右旋转 2 步: [6, 7, 1, 2, 3, 4, 5]
向右旋转 3 步: [5, 6, 7, 1, 2, 3, 4]

示例 2：

输入: [-1, -100, 3, 99] 和 k = 2
输出: [3, 99, -1, -100]
解释: 
向右旋转 1 步: [99, -1, -100, 3]
向右旋转 2 步: [3, 99, -1, -100]
lakalakaka commented

let rotateArr = (arr, num) => {
const len = arr.length;
const step = num % len;
for (let index = 0; index < step; index++) {
let item = arr.pop();
arr.unshift(item);
return arr;
}
};
rotateArr([5, 4, 3, 3, 2, 1], 6);

  • 👍1
  • 😄1
  • 🎉1
  • ❤️1
  • 🚀1
litokele2018 commented 
function rotateArray(arr, k) {
  let front = arr.slice(0, arr.length - k)
  let rear = arr.slice(arr.length - k, arr.length)
  let result = rear.concat(front)
  return result
}

// let arr = [1, 2, 3, 4, 5, 6, 7]
let arr = [-1, -100, 3, 99]

console.log(rotateArray(arr, 2))
coveyz commented

看看大佬的 看看我的....
流下了没有技术的眼泪 ....

function reversalArr(arr, frequency) {
  const newReversalArr = arr
  for (let index = 0; index < frequency; index++) {
    var first = newReversalArr.splice(newReversalArr.length - 1,1)
    newReversalArr.unshift(...first)
  }
  return newReversalArr
}
YanceyOfficial commented 
var rotate = function(nums, k) {
  for (let i = 0; i < k; i++) {
    nums.unshift(nums.pop())
  }
}
zhangpanfei commented 
function moveArr(arr,k) {
  const start = arr.length - k
  return [...arr.slice(start), ...arr.slice(0,start)]
}
hanzc0106 commented 
k = k % a.length;
let b = [...a.slice(-1 * k), ...a.slice(0, -1 * k)]
jackchang2015 commented 
function moveK(arr, k){
    const p = arr.slice(arr.length - k);
    arr.length = arr.length - k;
    arr.unshift(...p);
    return arr;

};
moveK([1, 2, 3, 4, 5, 6, 7], 3);  // [5, 6, 7, 1, 2, 3, 4]
woolson commented 
function rotate (arr, k) {
  return arr.concat(arr.splice(0, arr.length - k % arr.length))
}
rotate([1, 2, 3, 4, 5, 6, 7], 3) // [5, 6, 7, 1, 2, 3, 4]
weivea commented

个人觉得这道题考察的是：
基于传统数组的定义，如何以最小时间复杂度来实现该算法，
而不是直接调用各种Array的方法~，

下边是我的实现；

function transArray(arr, k) {
  k = k % arr.length;
  if (k === 0) {
    return;
  }
  const tmpArr = Array.from({length: k});
  const len = arr.length;
  for(let ind =1; ind <= len; ind++){
    if(ind<=k){
      tmpArr[k-ind] = arr[len-ind]
    } else {
      arr[len-ind+k] = arr[len-ind]
    }
  }
  for(let ind =0; ind < k; ind++){
    arr[ind] = tmpArr[ind]
  }
}


const arr = [1,2,3,4,5,6,7,8,9,10]

transArray(arr, 3);

console.log(arr);
//[8, 9, 10, 1, 2, 3, 4,  5, 6, 7]
jackchang2015 commented 
const rA = (arr, k) => {
let ln = arr.length;
let k1 = k % ln;
return arr.slice(ln - k1).concat(arr.slice(0, ln - k1));
};
rA([1, 2, 3, 4, 5, 6, 7], 3)  // [5, 6, 7, 1, 2, 3, 4]
//第二种
const rA = (arr, k) => {
    let ln = arr.length;
    let k1 = k % ln;
    Array.from({length:k1}).map( ()=> {arr.unshift(arr.pop())});
    return arr
};
RoeyXie commented

array.splice(index,howmany,item1,.....,itemX)

index：从何处添加/删除元素。
howmany：删除多少个元素。
item1~X：添加的元素1~X。

splice函数返回被删除元素的数组，会改变原数组，最好先拷贝下来。

var arr = [1, 2, 3, 4, 5, 6, 7];
function test(arr, index) {
  var _copy = [...arr]
  return index > arr.length || index < 0 ? arr : _copy.splice(arr.length - index).concat(_copy)
};
fengfan0409 commented 

function round(arr=[],n){
    let cut = arr.splice(arr.length-n,n)
    let result = cut.concat(arr)
    return result
}

round([1, 2, 3, 4, 5, 6, 7],3)
promotion-xu commented 
/**
 * @param {Array} arr - 数组
 * @param {number} step - 向右旋转的步数
 * */

const arr = [1, 2, 3, 4, 5, 6, 7];
const step = 3;
const autoReserver = (arr, step) => {
  for (let i = 0; i < step; i++) {
    arr.unshift(arr.pop());
  }
  return arr;
};

console.log(autoReserver(arr, step));