जावास्क्रिप्ट में एक सरणी में तत्वों को घुमाएं

Question 1

मैं सोच रहा था कि जावास्क्रिप्ट ऐरे को घुमाने का सबसे कारगर तरीका क्या था।

मैं इस समाधान के साथ आया था, जहां एक सकारात्मक nसरणी को दाईं ओर घुमाता है, और बाईं ओर एक नकारात्मक n( -length < n < length):

Array.prototype.rotateRight = function( n ) {
  this.unshift( this.splice( n, this.length ) );
}

जो तब इस तरह इस्तेमाल किया जा सकता है:

var months = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
months.rotate( new Date().getMonth() );

ऊपर दिए गए मेरे मूल संस्करण में एक दोष है, जैसा कि क्रिस्टोफ़ ने टिप्पणी में कहा है , एक सही संस्करण है (अतिरिक्त रिटर्न की अनुमति देता है):

Array.prototype.rotateRight = function( n ) {
  this.unshift.apply( this, this.splice( n, this.length ) );
  return this;
}

क्या संभवतः एक जावास्क्रिप्ट ढांचे के संदर्भ में अधिक कॉम्पैक्ट और / या तेज समाधान है? (प्रस्तावित संस्करणों में से कोई भी बेली या तो अधिक कॉम्पैक्ट या तेज है)

वहाँ किसी भी जावास्क्रिप्ट फ्रेमवर्क के साथ एक सरणी में निर्मित में बारी बारी से है? (फिर भी किसी ने जवाब नहीं दिया)

Question 2

प्रकार-सुरक्षित, सामान्य संस्करण जो सरणी को बदल देता है:

Array.prototype.rotate = (function() {
    // save references to array functions to make lookup faster
    var push = Array.prototype.push,
        splice = Array.prototype.splice;

    return function(count) {
        var len = this.length >>> 0, // convert to uint
            count = count >> 0; // convert to int

        // convert count to value in range [0, len)
        count = ((count % len) + len) % len;

        // use splice.call() instead of this.splice() to make function generic
        push.apply(this, splice.call(this, 0, count));
        return this;
    };
})();

टिप्पणियों में, जीन ने यह मुद्दा उठाया कि कोड ओवरलोडिंग का समर्थन नहीं करता है push()और splice()। मुझे नहीं लगता कि यह वास्तव में उपयोगी है (टिप्पणियों को देखें), लेकिन एक त्वरित समाधान (कुछ हद तक एक हैक, हालांकि) लाइन को बदलने के लिए होगा

push.apply(this, splice.call(this, 0, count));

इसके साथ:

(this.push || push).apply(this, (this.splice || splice).call(this, 0, count));

का उपयोग unshift()करने के बजाय push()लगभग दोगुनी गति से ओपेरा 10 में है, जबकि एफएफ में अंतर बहुत मामूली थे; कोड:

Array.prototype.rotate = (function() {
    var unshift = Array.prototype.unshift,
        splice = Array.prototype.splice;

    return function(count) {
        var len = this.length >>> 0,
            count = count >> 0;

        unshift.apply(this, splice.call(this, count % len, len));
        return this;
    };
})();

Question 3

आप उपयोग कर सकते हैं push(), pop(), shift()और unshift()तरीके:

function arrayRotate(arr, reverse) {
  if (reverse) arr.unshift(arr.pop());
  else arr.push(arr.shift());
  return arr;
}

उपयोग:

arrayRotate(['h','e','l','l','o']);       // ['e','l','l','o','h'];
arrayRotate(['h','e','l','l','o'], true); // ['o','h','e','l','l'];

यदि आपको countतर्क की आवश्यकता है तो मेरे अन्य उत्तर देखें: https://stackoverflow.com/a/33451102 my

Question 4

मैं शायद ऐसा कुछ करूंगा:

Array.prototype.rotate = function(n) {
    return this.slice(n, this.length).concat(this.slice(0, n));
}

यहाँ एक उत्परिवर्ती संस्करण संपादित करें :

Array.prototype.rotate = function(n) {
    while (this.length && n < 0) n += this.length;
    this.push.apply(this, this.splice(0, n));
    return this;
}

Question 5

यह फ़ंक्शन दोनों तरह से काम करता है और किसी भी संख्या के साथ काम करता है (यहां तक कि सरणी लंबाई से अधिक संख्या के साथ):

function arrayRotate(arr, count) {
  count -= arr.length * Math.floor(count / arr.length);
  arr.push.apply(arr, arr.splice(0, count));
  return arr;
}

उपयोग:

for(let i = -6 ; i <= 6 ; i++) {
  console.log(arrayRotate(["🧡","💚","💙","💜","🖤"], i), i);
}

परिणाम:

[ "🖤", "🧡", "💚", "💙", "💜" ]    -6
[ "🧡", "💚", "💙", "💜", "🖤" ]    -5
[ "💚", "💙", "💜", "🖤", "🧡" ]    -4
[ "💙", "💜", "🖤", "🧡", "💚" ]    -3
[ "💜", "🖤", "🧡", "💚", "💙" ]    -2
[ "🖤", "🧡", "💚", "💙", "💜" ]    -1
[ "🧡", "💚", "💙", "💜", "🖤" ]    0
[ "💚", "💙", "💜", "🖤", "🧡" ]    1
[ "💙", "💜", "🖤", "🧡", "💚" ]    2
[ "💜", "🖤", "🧡", "💚", "💙" ]    3
[ "🖤", "🧡", "💚", "💙", "💜" ]    4
[ "🧡", "💚", "💙", "💜", "🖤" ]    5
[ "💚", "💙", "💜", "🖤", "🧡" ]    6

Question 6

इसलिए इनमें से कई उत्तर अधिक जटिल और पढ़ने में मुश्किल लगते हैं। मुझे नहीं लगता कि मैंने किसी को कॉनसैट के साथ ब्याह का उपयोग करते देखा ...

function rotateCalendar(){
    var cal=["Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"],
    cal=cal.concat(cal.splice(0,new Date().getMonth()));
    console.log(cal);  // return cal;
}

कंसोल.लॉग आउटपुट (* मई में उत्पन्न):

["May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec", "Jan", "Feb", "Mar", "Apr"]

कॉम्पैक्टनेस के लिए, मैं कुछ जेनेरिक वन-लाइनर फ़ंक्शंस की पेशकश कर सकता हूं (कंसोल की गिनती नहीं कर रहा हूं। वापसी भाग)। बस इसे दलीलों में सरणी और लक्ष्य मान खिलाएं।

मैं इन कार्यों को एक चार-खिलाड़ी कार्ड गेम कार्यक्रम के लिए एक में जोड़ता हूं जहां सरणी ['N', 'E', 'S', 'W'] है। मैंने उन्हें अलग छोड़ दिया अगर कोई भी उनकी आवश्यकताओं के लिए कॉपी / पेस्ट करना चाहता है। अपने उद्देश्यों के लिए, मैं उन कार्यों का उपयोग करता हूं जब खेल के विभिन्न चरणों (पिनोकल) के दौरान खेलने / अभिनय करने के लिए किसकी बारी है। मैंने गति के लिए परीक्षण करने की जहमत नहीं उठाई, इसलिए यदि कोई और चाहता है, तो बेझिझक मुझे परिणाम बताएं।

* ध्यान दें, फ़ंक्शन के बीच एकमात्र अंतर "+1" है।

function rotateToFirst(arr,val){  // val is Trump Declarer's seat, first to play
    arr=arr.concat(arr.splice(0,arr.indexOf(val)));
    console.log(arr); // return arr;
}
function rotateToLast(arr,val){  // val is Dealer's seat, last to bid
    arr=arr.concat(arr.splice(0,arr.indexOf(val)+1));
    console.log(arr); // return arr;
}

संयोजन समारोह ...

function rotateArray(arr,val,pos){
    // set pos to 0 if moving val to first position, or 1 for last position
    arr=arr.concat(arr.splice(0,arr.indexOf(val)+pos));
    return arr;
}
var adjustedArray=rotateArray(['N','E','S','W'],'S',1);

adjustedArray =

W,N,E,S

Question 7

एक अपरिवर्तनीय उदाहरण के लिए ES6 के प्रसार का उपयोग ...

[...array.slice(1, array.length), array[0]]

तथा

[array[array.items.length -1], ...array.slice(0, array.length -1)]

यह शायद सबसे कुशल नहीं है, लेकिन यह संक्षिप्त है।

Question 8

टुकड़ा और विनाशकारी के साथ आसान समाधान:

const rotate = (arr, count = 1) => {
  return [...arr.slice(count, arr.length), ...arr.slice(0, count)];
};

const arr = [1,2,3,4,5];

console.log(rotate(arr, 1));  // [2, 3, 4, 5, 1]
console.log(rotate(arr, 2));  // [3, 4, 5, 1, 2]
console.log(rotate(arr, -2)); // [4, 5, 1, 2, 3]
console.log(rotate(arr, -1)); // [5, 1, 2, 3, 4]

स्निपेट का विस्तार करें

Question 9

यहाँ एक सरणी में आइटम को शिफ्ट करने का एक बहुत ही सरल तरीका है:

function rotate(array, stepsToShift) {

    for (var i = 0; i < stepsToShift; i++) {
        array.unshift(array.pop());
    }

    return array;
}

Question 10

@Christoph, आपने एक साफ कोड किया है, लेकिन मुझे जो मिला, उससे 60% धीमा । परिणाम को jsPerf पर देखें: http://jsperf.com/js-rotate-array/2 [संपादित करें] अब ठीक है और अधिक ब्राउज़र हैं जो स्पष्ट रूप से चुड़ैल नहीं हैं

var rotateArray = function(a, inc) {
    for (var l = a.length, inc = (Math.abs(inc) >= l && (inc %= l), inc < 0 && (inc += l), inc), i, x; inc; inc = (Math.ceil(l / inc) - 1) * inc - l + (l = inc))
    for (i = l; i > inc; x = a[--i], a[i] = a[i - inc], a[i - inc] = x);
    return a;
};

var array = ['a','b','c','d','e','f','g','h','i'];

console.log(array);
console.log(rotateArray(array.slice(), -1)); // Clone array with slice() to keep original

Question 11

http://jsperf.com/js-rotate-array/8 देखें

function reverse(a, from, to) {
  --from;
  while (++from < --to) {
    var tmp = a[from];
    a[from] = a[to];
    a[to] = tmp;
  }
}

function rotate(a, from, to, k) {
  var n = to - from;
  k = (k % n + n) % n;
  if (k > 0) {
    reverse(a, from, from + k);
    reverse(a, from + k, to);
    reverse(a, from, to);
  }
}

Question 12

जब मुझे 'आज' के साथ दिनों की सूची शुरू करने के लिए तैयार स्निपेट नहीं मिला, तो मैंने इसे इस तरह किया (काफी सामान्य नहीं, शायद उपरोक्त उदाहरणों की तुलना में कम परिष्कृत, लेकिन काम किया):

//returns 7 day names with today first
function startday() {
    const days = ['Sun','Mon','Tue','Wed','Thu','Fri','Sat'];
    let today = new Date();
    let start = today.getDay(); //gets day number
    if (start == 0) { //if Sunday, days are in order
        return days
    }
    else { //if not Sunday, start days with today
        return days.slice(start).concat(days.slice(0,start))
    }
}

मेरे द्वारा एक बेहतर प्रोग्रामर द्वारा थोड़ा सा रिफ्लेक्टर करने के लिए धन्यवाद, यह मेरे प्रारंभिक प्रयास की तुलना में एक पंक्ति या दो छोटा है, लेकिन दक्षता पर आगे की कोई भी टिप्पणी स्वागत योग्य है।

Question 13

function rotate(arr, k) {
for (var i = 0; i < k+1; i++) {
    arr.push(arr.shift());
}
return arr;
}
//k work as an index array
console.log(rotate([1, 2, 7, 4, 5, 6, 7], 3)); //[5,6,7,1,2,7,4]
console.log(rotate([-1, -100, 3, 99], 2));     //[99,-1,-100,3]

Question 14

// Example of array to rotate
let arr = ['E', 'l', 'e', 'p', 'h', 'a', 'n', 't'];

// Getting array length
let length = arr.length;

// rotation < 0 (move left), rotation > 0 (move right)
let rotation = 5;

// Slicing array in two parts
let first  = arr.slice(   (length - rotation) % length, length); //['p', 'h', 'a' ,'n', 't']
let second = arr.slice(0, (length - rotation) % length); //['E', 'l', 'e']

// Rotated element
let rotated = [...first, ...second]; // ['p', 'h', 'a' ,'n', 't', 'E', 'l', 'e']

कोड की एक पंक्ति में:

let rotated = [...arr.slice((length - rotation) % length, length), ...arr.slice(0, (length - rotation) % length)];

Question 15

स्वीकृत उत्तर में कॉल स्टैक आकार से बड़े सरणियों को संभालने में सक्षम नहीं होने का दोष है जो सत्र पर निर्भर करता है लेकिन लगभग 100 ~ 300K आइटम की तरह होना चाहिए। उदाहरण के लिए, वर्तमान क्रोम सत्र में मैंने कोशिश की थी कि यह 250891 था। कई मामलों में आप यह भी नहीं जानते होंगे कि सरणी किस आकार में गतिशील रूप से विकसित हो सकती है। तो यह एक गंभीर समस्या है।

इस सीमा को पार करने के लिए, मुझे लगता है कि एक दिलचस्प विधि Array.prototype.map()एक गोलाकार तरीके से सूचकांकों को पुनर्व्यवस्थित करके तत्वों का उपयोग और मानचित्रण कर रही है। यह विधि एक पूर्णांक तर्क लेती है। यदि यह तर्क सकारात्मक है तो यह बढ़ते हुए सूचकांकों पर और यदि घटती हुई सूचकांकों की दिशा में नकारात्मक होगा। इसमें केवल O (n) समय की जटिलता है और बिना किसी समस्या के लाखों आइटम्स को हैंडल करने के दौरान इसे कॉल किए बिना एक नई सरणी लौटाएगा। देखते हैं कि यह कैसे काम करता है;

Array.prototype.rotate = function(n) {
var len = this.length;
return !(n % len) ? this
                  : n > 0 ? this.map((e,i,a) => a[(i + n) % len])
                          : this.map((e,i,a) => a[(len - (len - i - n) % len) % len]);
};
var a = [1,2,3,4,5,6,7,8,9],
    b = a.rotate(2);
console.log(JSON.stringify(b));
    b = a.rotate(-1);
console.log(JSON.stringify(b));

स्निपेट का विस्तार करें

वास्तव में बाद में मुझे दो मामलों पर आलोचना की गई है;

सकारात्मक या नकारात्मक इनपुट के लिए सशर्त की कोई आवश्यकता नहीं है क्योंकि यह DRY के उल्लंघन का खुलासा करता है। आप इसे एक मानचित्र के साथ कर सकते हैं क्योंकि प्रत्येक नकारात्मक n में एक सकारात्मक समतुल्य है (पूरी तरह से सही ..)
एक सरणी फ़ंक्शन को वर्तमान सरणी को बदलना चाहिए या एक नई सरणी बनाना चाहिए, आपका फ़ंक्शन या तो इस बात पर निर्भर कर सकता है कि क्या शिफ्ट आवश्यक है या नहीं (पूरी तरह से सही है)

मैंने निम्नानुसार कोड को संशोधित करने का निर्णय लिया है;

Array.prototype.rotate = function(n) {
var len = this.length;
return !(n % len) ? this.slice()
                  : this.map((e,i,a) => a[(i + (len + n % len)) % len]);
};
var a = [1,2,3,4,5,6,7,8,9],
    b = a.rotate(10);
console.log(JSON.stringify(b));
    b = a.rotate(-10);
console.log(JSON.stringify(b));

स्निपेट का विस्तार करें

तो फिर; निश्चित रूप से जेएस फंक्शनलर्स जैसे Array.prototype.map()उनके समकक्षों की तुलना में धीमे हैं , जो कि सादे जेएस में कोडित हैं। 100% से अधिक प्रदर्शन हासिल करने के लिए, निम्नलिखित में से शायद मेरी पसंद Array.prototype.rotate()होगी यदि मुझे कभी उत्पादन कोड में एक सरणी को घुमाने की जरूरत हो, जैसे कि मैं अपने प्रयास में उपयोग करता हूंString.prototype.diff()

Array.prototype.rotate = function(n){
  var len = this.length,
      res = new Array(this.length);
  if (n % len === 0) return this.slice();
  else for (var i = 0; i < len; i++) res[i] = this[(i + (len + n % len)) % len];
  return res;
};

Question 16

यह फ़ंक्शन छोटे सरणियों के लिए स्वीकृत उत्तर की तुलना में थोड़ा तेज़ है, लेकिन बड़े सरणियों के लिए बहुत तेज़ है। यह फ़ंक्शन सरणी की लंबाई से अधिक घूर्णन की एक मनमानी संख्या के लिए भी अनुमति देता है, जो मूल फ़ंक्शन की एक सीमा है।

अन्त में, स्वीकृत उत्तर विपरीत दिशा में वर्णित अनुसार घूमता है।

const rotateForEach = (a, n) => {
    const l = a.length;
    a.slice(0, -n % l).forEach(item => a.push( item ));
    return a.splice(n % l > 0 ? (-n % l) : l + (-n % l));
}

और कार्यात्मक समतुल्य (जो लगता है कि कुछ प्रदर्शन लाभ भी है):

const rotateReduce = (arr, n) => {
    const l = arr.length;
    return arr.slice(0, -n % l).reduce((a,b) => {
        a.push( b );
        return a;
    }, arr).splice(n % l> 0 ? l + (-n % l) : -n % l);
};

आप यहां प्रदर्शन के टूटने की जांच कर सकते हैं।

Question 17

संपादित करें :: अरे तो पता चलता है कि बहुत अधिक पुनरावृत्ति हो रही है। न लूप, न ब्रांचिंग।

फिर भी किसी भी आकार के एन के लिए दाएं रोटेशन के लिए नकारात्मक एन और बाएं एन के लिए पॉजिटिव एन के साथ काम करता है, म्यूटेशन फ्री

function rotate(A,n,l=A.length) {
  const offset = (((n % l) + l) %l)
  return A.slice(offset).concat(A.slice(0,offset))
}

यहाँ गिगल्स के लिए कोड गोल्फ संस्करण है

const r = (A,n,l=A.length,i=((n%l)+l)%l)=>A.slice(i).concat(A.slice(0,i))

EDIT1 :: * शाखा रहित, उत्परिवर्तन रहित कार्यान्वयन।

तो हे, पता चला कि मेरे पास एक शाखा थी जहां मुझे इसकी आवश्यकता नहीं थी। यहाँ एक काम कर समाधान है। ऋणात्मक संख्या = सही घुमाएँ | संख्या | पॉजिटिव संख्या = बाएं घुमाकर संख्या

function r(A,n,l=A.length) {
  return A.map((x,i,a) => A[(((n+i)%l) + l) % l])
}

समीकरण ((n%l) + l) % ln के किसी भी मनमाने ढंग से बड़े मूल्यों के बिल्कुल सकारात्मक और नकारात्मक संख्याओं को दर्शाता है

मूल

दाएं और बाएं घुमाएं। सकारात्मक के साथ बाईं ओर घुमाएं n, नकारात्मक के साथ दाएं घुमाएं n।

के बड़े अश्लील इनपुट के लिए काम करता है n।

कोई म्यूटेशन मोड नहीं। इन उत्तरों में बहुत अधिक उत्परिवर्तन।

इसके अलावा, अधिकांश उत्तरों की तुलना में कम संचालन। कोई पॉप नहीं, कोई धक्का नहीं, कोई ब्याह नहीं, कोई बदलाव नहीं।

const rotate = (A, num ) => {
   return A.map((x,i,a) => {
      const n = num + i
      return n < 0 
        ? A[(((n % A.length) + A.length) % A.length)]
        : n < A.length 
        ? A[n] 
        : A[n % A.length]
   })
}

या

 const rotate = (A, num) => A.map((x,i,a, n = num + i) => 
  n < 0
    ? A[(((n % A.length) + A.length) % A.length)]
    : n < A.length 
    ? A[n] 
    : A[n % A.length])

//test
rotate([...Array(5000).keys()],4101)   //left rotation
rotate([...Array(5000).keys()],-4101000)  //right rotation, num is negative

// will print the first index of the array having been rotated by -i
// demonstrating that the rotation works as intended
[...Array(5000).keys()].forEach((x,i,a) => {
   console.log(rotate(a,-i)[0])
}) 
// prints even numbers twice by rotating the array by i * 2 and getting the first value
//demonstrates the propper mapping of positive number rotation when out of range
[...Array(5000).keys()].forEach((x,i,a) => {
   console.log(rotate(a,i*2)[0])
})

स्पष्टीकरण:

अनुक्रमणिका ऑफसेट पर A के प्रत्येक अनुक्रमणिका के मान को मैप करें। इस मामले में

offset = num

अगर offset < 0तब offset + index + positive length of Aउलटा ऑफसेट को इंगित करेगा।

यदि offset > 0 and offset < length of Aतब बस वर्तमान सूचकांक को A के ऑफसेट इंडेक्स में मैप करें।

अन्यथा, सरणी की सीमा में ऑफसेट मैप करने के लिए ऑफसेट और लंबाई modulo।

उदाहरण के लिए ले लो offset = 4और offset = -4।

जब offset = -4, और A = [1,2,3,4,5], प्रत्येक सूचकांक के लिए, offset + indexपरिमाण (या Math.abs(offset)) छोटा कर देगा।

आइए पहले नकारात्मक n के सूचकांक के लिए गणना की व्याख्या करें। A[(((n % A.length) + A.length) % A.length)+0]और धमकाया गया। मत बनो। इसे काम करने में मुझे 3 मिनट लगे।

हम जानते हैं nकि नकारात्मक है क्योंकि मामला है n < 0। यदि संख्या ऐरे की सीमा से बड़ी है, तो इसे रेंज में n % A.lengthमैप करेगा।
n + A.lengthA.lengthसही मात्रा में ऑफसेट करने के लिए उस संख्या को जोड़ें ।
हम जानते हैं nकि नकारात्मक है क्योंकि मामला है n < 0। सही मात्रा में ऑफसेट n + A.lengthकरने के A.lengthलिए उस संख्या को जोड़ें ।
अगला इसे मोडुलो का उपयोग करके ए की लंबाई की सीमा तक मैप करें। गणना के परिणाम को एक अनुक्रमिक सीमा में मैप करने के लिए दूसरा मोडुलस आवश्यक है
पहला सूचकांक: -4 + 0 = -4। A.length = 5. A.length - 4 = 1. A 2 है 2. मैप इंडेक्स 0 से 2।[2,... ]
अगला सूचकांक, -4 + 1 = -3। 5 + -3 = 2. ए 2 है 3. मैप इंडेक्स 1 से 3।[2,3... ]
आदि।

उसी प्रक्रिया पर लागू होता है offset = 4। जब offset = -4, और A = [1,2,3,4,5], प्रत्येक सूचकांक के लिए, offset + indexपरिमाण को बड़ा बना देगा।

4 + 0 = 0। A [4] के मूल्य पर मैप A [0]।[5...]
4 + 1 = 5, 5 अनुक्रमण के दौरान सीमा से बाहर है, इसलिए शेष के मूल्य पर A 2 को मैप करें 5 / 5, जो कि A [0] पर 0. A 2 = मान है।[5,1...]
दोहराएँ।

Question 18

Follow a simpler approach of running a loop to n numbers and shifting places upto that element.

function arrayRotateOne(arr, n) {
  for (let i = 0; i < n; i++) {
    arr.unshift(arr.pop());
  }
  return arr;
}
console.log( arrayRotateOne([1,2,3,4,5,6],2));



function arrayRotateOne(arr,n) {
  for(let i=0; i<n;i++){
      arr.push(arr.shift());
      console.log('execute',arr)
    }
     return arr;
 }

कंसोल.लॉग (arrayRotateOne ([1,2,3,4,5,6], 2));

Question 19

गैर उत्परिवर्तन समाधान

var arr = ['a','b','c','d']
arr.slice(1,arr.length).concat(arr.slice(0,1)

उत्परिवर्तन के साथ

var arr = ['a','b','c','d']
arr = arr.concat(arr.splice(0,1))

Question 20

मैं अपना समाधान साझा कर रहा हूं जिसका उपयोग मैं हिंडोला पर घूमने के लिए कर रहा हूं। यह तब टूट सकता है जब सरणी का आकार छोटा होता है displayCount, लेकिन जब आप छोटा होता है , तो आप इसे बंद करने के लिए अतिरिक्त स्थिति जोड़ सकते हैं या मुख्य सरणी को प्रदर्शित कर सकते हैं * प्रदर्शन समय भी।

function rotate(arr, moveCount, displayCount) {
  const size = arr.length;

  // making sure startIndex is between `-size` and `size`
  let startIndex = moveCount % size;
  if (startIndex < 0) startIndex += size; 

  return [...arr, ...arr].slice(startIndex, startIndex + displayCount);
}

// move 3 to the right and display 4 items
// rotate([1,2,3,4,5], 3, 4) -> [4,5,1,2]

// move 3 to the left and display 4 items
// rotate([1,2,3,4,5], -3, 4) -> [3,4,5,1]

// move 11 to the right and display 4
// rotate([1,2,3,4,5], 3, 4) -> [2,3,4,5]

Question 21

कैसे एक काउंटर को बढ़ाने के बारे में और फिर एक विभाजन के शेष भाग को सरणी लंबाई से प्राप्त करने के लिए जहां आपको माना जाता है।

var i = 0;
while (true);
{
    var position = i % months.length;
    alert(months[position]);
    ++i;
}

भाषा सिंटैक्स एक तरफ यह ठीक काम करना चाहिए।

Question 22

यदि आपकी सरणी बड़ी होने जा रही है और / या आप बहुत चक्कर लगाने जा रहे हैं, तो आप किसी सरणी के बजाय लिंक की गई सूची का उपयोग करने पर विचार कर सकते हैं।

Question 23

@molokoloco मुझे एक ऐसे फ़ंक्शन की आवश्यकता थी जिसे मैं एक दिशा में घूमने के लिए कॉन्फ़िगर कर सकता हूं - आगे के लिए सच और पिछड़े के लिए झूठ। मैंने एक स्निपेट बनाया जो एक दिशा, एक काउंटर और एक सरणी बनाता है और एक ऑब्जेक्ट को उचित दिशा में और साथ ही पूर्व, वर्तमान और अगले मूल्यों में संवर्धित काउंटर के साथ आउटपुट करता है। यह मूल सरणी को संशोधित नहीं करता है।

मैंने इसे आपके स्निपेट के खिलाफ भी देखा था और हालांकि यह तेज़ नहीं है, यह उन लोगों की तुलना में तेज़ है, जिनसे आप अपनी तुलना करते हैं - 21% धीमी http://jsperf.com/js-rotate-array/7 ।

function directionalRotate(direction, counter, arr) {
  counter = direction ? (counter < arr.length - 1 ? counter + 1 : 0) : (counter > 0 ? counter - 1 : arr.length - 1)
  var currentItem = arr[counter]
  var priorItem = arr[counter - 1] ? arr[counter - 1] : arr[arr.length - 1]
  var nextItem = arr[counter + 1] ? arr[counter + 1] : arr[0]
  return {
    "counter": counter,
    "current": currentItem,
    "prior": priorItem,
    "next": nextItem
  }
}
var direction = true // forward
var counter = 0
var arr = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i'];

directionalRotate(direction, counter, arr)

Question 24

मैं देर से आ रहा हूं लेकिन मेरे पास इन अच्छे उत्तरों को जोड़ने के लिए एक ईंट है। मुझे इस तरह के समारोह को कोड करने के लिए कहा गया था और मैंने पहली बार किया था:

Array.prototype.rotate = function(n)
{
    for (var i = 0; i < n; i++)
    {
        this.push(this.shift());
    }
    return this;
}

लेकिन यह nबड़ा होने के बाद से कम कुशल प्रतीत होता है:

Array.prototype.rotate = function(n)
{
    var l = this.length;// Caching array length before map loop.

    return this.map(function(num, index) {
        return this[(index + n) % l]
    });
}

Question 25

मुझे यकीन नहीं है कि यह सबसे कुशल तरीका है, लेकिन मुझे पसंद है जिस तरह से यह पढ़ता है, यह सबसे बड़े कार्यों के लिए काफी तेज है क्योंकि मैंने इसे उत्पादन पर परीक्षण किया है ...

function shiftRight(array) {
  return array.map((_element, index) => {
    if (index === 0) {
      return array[array.length - 1]
    } else return array[index - 1]
  })
}

function test() {
  var input = [{
    name: ''
  }, 10, 'left-side'];
  var expected = ['left-side', {
    name: ''
  }, 10]
  var actual = shiftRight(input)

  console.log(expected)
  console.log(actual)

}

test()

स्निपेट का विस्तार करें

Question 26

देशी, तेज, छोटे, शब्दार्थ, पुराने इंजन और "करी" पर काम करता है।

function rotateArray(offset, array) {
    offset = -(offset % array.length) | 0 // ensure int
    return array.slice(offset).concat(
        array.slice(0, offset)
    )
}

Question 27

** जेएस के नवीनतम संस्करण का उपयोग करके हम इसे आसानी से बना सकते हैं **

 Array.prototype.rotateLeft = function (n) {
   this.unshift(...this.splice(-(n), n));
    return this
  }

यहाँ चलता है: रोटेशन की संख्या , एक सरणी जिसे आप यादृच्छिक संख्या पास कर सकते हैं

let a = [1, 2, 3, 4, 5, 6, 7];
let moves = 4;
let output = a.rotateLeft(moves);
console.log("Result:", output)

Question 28

Arrayजेएस में नीचे निर्मित विधि है जो एक सरणी को आसानी से घुमाने के लिए इस्तेमाल किया जा सकता है और जाहिर है कि ये विधियां प्रकृति में अपरिवर्तनीय हैं।

push: सरणी के अंत में आइटम सम्मिलित करता है।
pop: सरणी के अंत से आइटम को निकालता है।
unshift: सरणी के आरंभ में आइटम सम्मिलित करता है।
shift: सरणी की शुरुआत से आइटम को निकालता है।

नीचे दिए गए समाधान ( ES6) में दो तर्क होते हैं, सरणी को घुमाया जाना चाहिए और n, सरणी को जितनी बार घुमाया जाना चाहिए, उतनी बार।

const rotateArray = (arr, n) => {
  while(arr.length && n--) {
    arr.unshift(arr.pop());
  }
  return arr;
}

rotateArray(['stack', 'overflow', 'is', 'Awesome'], 2) 
// ["is", "Awesome", "stack", "overflow"]

इसे Array.prototype में जोड़ा जा सकता है और आपके सभी एप्लिकेशन में उपयोग किया जा सकता है

Array.prototype.rotate = function(n) {
 while(this.length && n--) {
   this.unshift(this.pop());
 }
 return this;
}
[1,2,3,4].rotate(3); //[2, 3, 4, 1]

Question 29

लूप के लिए उपयोग करना। यहाँ कदम हैं

अस्थायी चर के रूप में सरणी के पहले तत्व को स्टोर करें।
फिर बाईं से दाईं ओर स्वैप करें।
फिर सरणी के अंतिम तत्व के लिए अस्थायी चर असाइन करें।
रोटेशन की संख्या के लिए इन चरणों को दोहराएं।

function rotateLeft(arr, rotations) {
    let len = arr.length;
    for(let i=0; i<rotations; i++){ 
        let temp = arr[0];
        for(let i=0; i< len; i++){
            arr[i]=arr[i+1];
        }
        arr[len-1]=temp;
    }
    return arr;
}

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

let rotations = 3;
let output = rotateLeft(arr, rotations);
console.log("Result Array => ", output);

स्निपेट का विस्तार करें

Question 30

es6 वाक्य रचना के साथ

function rotLeft(a, d) {
    const removed = a.splice(0,d);
    return [...a, ...removed];
}

Question 31

दक्षता के बारे में निश्चित नहीं है लेकिन मैं इसे इस गैर उत्परिवर्ती तरीके से करूंगा:

	Array.prototype.rotate = function( n ) {
  
		 return this.map( (item, index)=> this[ (this.length + index + n)%this.length ] )
	}

स्निपेट का विस्तार करें