जे सरणी को एन सरण में विभाजित करना

Question 1

कल्पना कीजिए कि मेरे पास एक जेएस सरणी है:

var a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11];

मैं जो चाहता हूं, उस सरणी को एन छोटे सरणियों में विभाजित करना है। उदाहरण के लिए:

split_list_in_n(a, 2)
[[1, 2, 3, 4, 5, 6], [7, 8, 9, 10, 11]]

For N = 3:
[[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11]]

For N = 4:
[[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11]]

For N = 5:
[[1, 2, 3], [4, 5], [6, 7], [8, 9], [10, 11]]

अजगर के लिए, मेरे पास यह है:

def split_list_in_n(l, cols):
    """ Split up a list in n lists evenly size chuncks """
    start = 0
    for i in xrange(cols):
        stop = start + len(l[i::cols])
        yield l[start:stop]
        start = stop

जेएस के लिए, सबसे अच्छा सही समाधान जिसके साथ मैं आ सकता था एक पुनरावर्ती कार्य है, लेकिन मुझे यह पसंद नहीं है क्योंकि यह जटिल और बदसूरत है। यह आंतरिक फ़ंक्शन इस तरह की एक सरणी देता है [1, 2, 3, null, 4, 5, 6, null, 7, 8], और फिर मुझे इसे फिर से लूप करना होगा और इसे मैन्युअल रूप से विभाजित करना होगा। (मेरा पहला प्रयास इसे वापस कर रहा था: [१, २, ३, [४, ५, ६, [returning, returning, ९]]], और मैंने इसे अशक्त विभाजक के साथ करने का निर्णय लिया।

function split(array, cols) {
    if (cols==1) return array;
    var size = Math.ceil(array.length / cols);
    return array.slice(0, size).concat([null]).concat(split(array.slice(size), cols-1));
}

यहाँ एक jsfiddle है कि: http://jsfiddle.net/uduhH/

आप वह कैसे करेंगें? धन्यवाद!

Question 2

आप स्लाइस को "संतुलित" बना सकते हैं (सबरेज़ की लंबाई जितनी हो सके उतनी कम हो सकती है) या "सम"

function chunkify(a, n, balanced) {
    
    if (n < 2)
        return [a];

    var len = a.length,
            out = [],
            i = 0,
            size;

    if (len % n === 0) {
        size = Math.floor(len / n);
        while (i < len) {
            out.push(a.slice(i, i += size));
        }
    }

    else if (balanced) {
        while (i < len) {
            size = Math.ceil((len - i) / n--);
            out.push(a.slice(i, i += size));
        }
    }

    else {

        n--;
        size = Math.floor(len / n);
        if (len % size === 0)
            size--;
        while (i < size * n) {
            out.push(a.slice(i, i += size));
        }
        out.push(a.slice(size * n));

    }

    return out;
}


///////////////////////

onload = function () {
    function $(x) {
        return document.getElementById(x);
    }

    function calc() {
        var s = +$('s').value, a = [];
        while (s--)
            a.unshift(s);
        var n = +$('n').value;
        $('b').textContent = JSON.stringify(chunkify(a, n, true))
        $('e').textContent = JSON.stringify(chunkify(a, n, false))
    }

    $('s').addEventListener('input', calc);
    $('n').addEventListener('input', calc);
    calc();
}

<p>slice <input type="number" value="20" id="s"> items into
<input type="number" value="6" id="n"> chunks:</p>
<pre id="b"></pre>
<pre id="e"></pre>

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

Question 3

मुझे लगता है कि ब्याह का उपयोग करने का तरीका सबसे साफ है:

splitToChunks(array, parts) {
    let result = [];
    for (let i = parts; i > 0; i--) {
        result.push(array.splice(0, Math.ceil(array.length / i)));
    }
    return result;
}

उदाहरण के लिए, उदाहरण के लिए parts = 3, आप 1/3 भाग लेंगे, फिर शेष भाग 1/2, फिर शेष सरणी। Math.ceilयह सुनिश्चित करता है कि तत्वों की असमान संख्या के मामले में वे सबसे पहले विखंडू में जाएंगे।

(नोट: यह प्रारंभिक सरणी को नष्ट कर देता है।)

Question 4

function split(array, n) {
  let [...arr]  = array;
  var res = [];
  while (arr.length) {
    res.push(arr.splice(0, n));
  }
  return res;
}

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

Question 5

मैंने अभी कलन विधि का पुनरावृत्ति कार्यान्वयन किया है: http://jsfiddle.net/ht22q/ । यह आपके परीक्षण मामलों को पास करता है।

function splitUp(arr, n) {
    var rest = arr.length % n, // how much to divide
        restUsed = rest, // to keep track of the division over the elements
        partLength = Math.floor(arr.length / n),
        result = [];

    for(var i = 0; i < arr.length; i += partLength) {
        var end = partLength + i,
            add = false;

        if(rest !== 0 && restUsed) { // should add one element for the division
            end++;
            restUsed--; // we've used one division element now
            add = true;
        }

        result.push(arr.slice(i, end)); // part of the array

        if(add) {
            i++; // also increment i in the case we added an extra element for division
        }
    }

    return result;
}

Question 6

आप इसे एक मैट्रिक्स में कम कर सकते हैं। नीचे दिया गया उदाहरण सरणी को विभाजित करता है (arr ) को दो-स्थिति सरणियों के मैट्रिक्स में हैं। यदि आप अन्य आकार चाहते हैं तो दूसरी पंक्ति में 2 मान बदलें:

target.reduce((memo, value, index) => {
  if (index % 2 === 0 && index !== 0) memo.push([])
  memo[memo.length - 1].push(value)
  return memo
}, [[]])

आशा है कि इससे सहायता मिलेगी!

संपादित करें: क्योंकि कुछ लोग अभी भी इस पर टिप्पणी कर रहे हैं, क्योंकि इस प्रश्न का उत्तर नहीं दिया गया है क्योंकि मैं प्रत्येक रंक की संख्या के बजाय जो मैं चाहता हूं, उसका आकार तय कर रहा था । यहाँ यह कोड आता है जो बताता है कि मैं क्या टिप्पणी अनुभाग में समझाने की कोशिश कर रहा हूं: का उपयोग करना target.length।

// Chunk function

const chunk = (target, size) => {
  return target.reduce((memo, value, index) => {
    // Here it comes the only difference
    if (index % (target.length / size) == 0 && index !== 0) memo.push([])
    memo[memo.length - 1].push(value)
    return memo
  }, [[]])
}

// Usage

write(chunk([1, 2, 3, 4], 2))
write(chunk([1, 2, 3, 4], 4))

// For rendering pruposes. Ignore
function write (content) { document.write(JSON.stringify(content), '</br>') }

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

Question 7

अपडेट: 7/21/2020

मैंने कुछ साल पहले जो जवाब दिया है वह केवल तभी काम करता है अगर originalArray.length<= numCols। आप वैकल्पिक रूप से इस फ़ंक्शन के नीचे कुछ का उपयोग कर सकते हैं, लेकिन यह एक ऐसा लेआउट बनाएगा जो हाथ पर सवाल से मेल नहीं खाता (क्षैतिज छंटाई के बजाय क्षैतिज छंटाई)। उर्फ: [1,2,3,4]-> [[1,4],[2],[3]]। मैं समझता हूं कि यह अभी भी मूल्य प्रदान कर सकता है इसलिए मैं इसे यहां छोड़ दूंगा, लेकिन मैं सेंथे के उत्तर की सिफारिश करता हूं ।

function splitArray(flatArray, numCols){
  const newArray = []
  for (let c = 0; c < numCols; c++) {
    newArray.push([])
  }
  for (let i = 0; i < flatArray.length; i++) {
    const mod = i % numCols
    newArray[mod].push(flatArray[i])
  }
  return newArray
}

2017 से मूल उत्तर:

पुराना सवाल है, लेकिन चूंकि वनिला जेएस एक आवश्यकता नहीं है और इसलिए कई लोग इसे लॉश / चंक के साथ हल करने की कोशिश कर रहे हैं, और बिना गलती किए कि _.chunkवास्तव में क्या करता है, यहां एक संक्षिप्त + सटीक समाधान का उपयोग किया गया है lodash:

(स्वीकृत उत्तर के विपरीत, यह n कॉलम की गारंटी देता है, भले ही originalArray.length< numCols)

import _chunk from 'lodash/chunk'

/**
 * Split an array into n subarrays (or columns)
 * @param  {Array} flatArray Doesn't necessarily have to be flat, but this func only works 1 level deep
 * @param  {Number} numCols   The desired number of columns
 * @return {Array}
 */
export function splitArray(flatArray, numCols){
  const maxColLength = Math.ceil(flatArray.length/numCols)
  const nestedArray = _chunk(flatArray, maxColLength)
  let newArray = []
  for (var i = 0; i < numCols; i++) {
    newArray[i] = nestedArray[i] || []
  }
  return newArray
}

forअंत में पाश क्या "कॉलम" की वांछित संख्या की गारंटी देता है है।

Question 8

पुनरावर्ती दृष्टिकोण, परीक्षण नहीं किया गया।

function splitArray(array, parts, out) {
    var
        len = array.length
        , partLen

    if (parts < len) {
        partLen = Math.ceil(len / parts);
        out.push(array.slice(0, partLen));
        if (parts > 1) {
            splitArray(array.slice(partLen), parts - 1, out);
        }
    } else {
        out.push(array);
    }
}

Question 9

एक और पुनरावर्ती काफी अच्छी तरह से काम करता है, यह कम बदसूरत है

function nSmaller(num, arr, sliced) {

    var mySliced = sliced || [];
    if(num === 0) {
        return sliced;
    }

    var len = arr.length,
        point = Math.ceil(len/num),
        nextArr = arr.slice(point);

    mySliced.push(arr.slice(0, point));
    nSmaller(num-1, nextArr, mySliced);

    return(mySliced);
}

Question 10

function parseToPages(elements, pageSize = 8) {
    var result = [];
    while (elements.length) {
        result.push(elements.splice(0, pageSize));
    }
    return result;
}

Question 11

यदि आप पहले से चाहते हैं कि चोक का आकार पता है, तो ऐसा करने का एक सुंदर ईएस 6 तरीका है:

const groupsOfFour = ([a,b,c,d, ...etc]) =>
  etc.length? [[a,b,c,d], ...groupsOfFour(etc)] : [[a,b,c,d]];
  
console.log(groupsOfFour([1,2,3,4,1,2,3,4,1,2,3,4]));

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

मुझे यह नोटेशन बहुत उपयोगी लगता है, उदाहरण के लिए आरजीए को पार्स करने से Uint8ClampedArray।

Question 12

संभवतः क्लीनर दृष्टिकोण निम्नलिखित होगा (किसी अन्य पुस्तकालय का उपयोग किए बिना):

var myArray = [];
for(var i=0; i<100; i++){
  myArray.push(i+1);
}
console.log(myArray);

function chunk(arr, size){
  var chunkedArr = [];
  var noOfChunks = Math.ceil(arr.length/size);
  console.log(noOfChunks);
  for(var i=0; i<noOfChunks; i++){
    chunkedArr.push(arr.slice(i*size, (i+1)*size));
  }
   return chunkedArr;
}

var chunkedArr = chunk(myArray, 3);
console.log(chunkedArr);

मैंने अपनी खुद की एक सरणी बनाई है जिसे चंक करना है। आप यहां कोड पा सकते हैं

इसके अलावा हमारे पास लॉश लाइब्रेरी में एक विधि "चंक" है जो बहुत काम का है। उम्मीद है की वो मदद करदे

Question 13

function splitArray(arr, numOfParts = 10){
        const splitedArray = []
        for (let i = 0; i < numOfParts;i++) {
            const numOfItemsToSplice = arr.length / 10;
            splitedArray.push(arr.splice(0, numOfItemsToSplice))
        }
        return splitedArray;
    }

Question 14

म्यूटेशन, आम तौर पर बोल रहा है, एक बुरा बात ™।

यह अच्छा, स्वच्छ, और कोमल है।

function partition(list = [], n = 1) {
  const isPositiveInteger = Number.isSafeInteger(n) && n > 0;
  if (!isPositiveInteger) {
    throw new RangeError('n must be a positive integer');
  }

  const partitions = [];
  const partitionLength = Math.ceil(list.length / n);

  for (let i = 0; i < list.length; i += partitionLength) {
    const partition = list.slice(i, i+partitionLength);
    partitions.push( partition );
  }

  return partitions;
}

Question 15

मैंने इसे इस तरह से बनाया है, यह काम करता है ...

function splitArray(array, parts) {
    if (parts< array.length && array.length > 1 && array != null) {
        var newArray = [];
        var counter1 = 0;
        var counter2 = 0;

        while (counter1 < parts) {
            newArray.push([]);
            counter1 += 1;
        }

        for (var i = 0; i < array.length; i++) {
            newArray[counter2++].push(array[i]);
            if (counter2 > parts - 1)
                counter2 = 0;
        }

        return newArray;
    } else 
        return array;
}

Question 16

इस सरणी विभाजन के मेरे संस्करण की जाँच करें

// divide array
Array.prototype.divideIt = function(d){
    if(this.length <= d) return this;
    var arr = this,
        hold = [],
        ref = -1;
    for(var i = 0; i < arr.length; i++){
        if(i % d === 0){
            ref++;
        }
        if(typeof hold[ref] === 'undefined'){
            hold[ref] = [];
        }
        hold[ref].push(arr[i]);
    }

    return hold;
};

Question 17

अगर आपको पता है कि child_arrays.length सेट करना चाहते हैं तो मुझे लगता है कि यह समाधान सबसे अच्छा है:

function sp(size, arr){ //size - child_array.length
    var out = [],i = 0, n= Math.ceil((arr.length)/size); 
    while(i < n) { out.push(arr.splice(0, (i==n-1) && size < arr.length ? arr.length: size));  i++;} 
    return out;
}

कॉल fn: sp (2, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]) // 2 - child_arrat.length

उत्तर: [१, २], [३, ४], [५, ६], [2,,], [९, १०], [११]

Question 18

यदि आप उपयोग कर सकते हैं lodashऔर एक कार्यात्मक प्रोग्रामिंग दृष्टिकोण चाहते हैं, तो यहां मैं आपके साथ आ रहा हूं:

const _ = require('lodash')

function splitArray(array, numChunks) {
  return _.reduce(_.range(numChunks), ({array, result, numChunks}, chunkIndex) => {
    const numItems = Math.ceil(array.length / numChunks)
    const items = _.take(array, numItems)
    result.push(items)
    return {
      array: _.drop(array, numItems),
      result,
      numChunks: numChunks - 1
    }
  }, {
    array,
    result: [],
    numChunks
  }).result
}

Question 19

उपरोक्त सभी ठीक काम कर सकते हैं, लेकिन क्या होगा अगर आपके पास associativeचाबियाँ के रूप में तार हैं?

objectKeys = Object.keys;

arraySplit(arr, n) {
    let counter = 0;
    for (const a of this.objectKeys(arr)) {
        this.arr[(counter%n)][a] = arr[a];
        counter++;
    }
}

Question 20

मेरे पास एक ऐसा है जो मूल सरणी को नहीं बदलता है

function splitArray(array = [], nPieces = 1){
    const splitArray = [];
    let atArrPos = 0;
    for(let i = 0; i < nPieces; i++){
        const splitArrayLength  = Math.ceil((array.length - atArrPos)/ (nPieces - i));
        splitArray.push([]);
        splitArray[i] = array.slice(atArrPos, splitArrayLength + atArrPos);
        atArrPos += splitArrayLength;
    }
    return  splitArray
}

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

Question 21

आप एक सरल पुनरावर्ती फ़ंक्शन का उपयोग कर सकते हैं

const chunkify = (limit, completeArray, finalArray = [])=>{
    if(!completeArray.length) return finalArray
    const a = completeArray.splice(0,limit);
    return chunkify(limit, completeArray, [...finalArray,a])
}

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

Question 22

splitToChunks(arrayvar, parts) {
    let result = [];
    for (let i = parts; i > 0; i--) {
        result.push(arrayvar.splice(0, Math.ceil(arrayvar.length / i)));
    }
    return result;
}

Question 23

सरणी को छोटे सरणियों में विभाजित करने के लिए सिर्फ लेशक के चंक फ़ंक्शन का उपयोग करें https://lodash.com/docs#chunk अब लूप्स के साथ फिडेल करने की आवश्यकता नहीं है!

Question 24

यदि आप लॉश का उपयोग कर रहे हैं, तो आप इसे नीचे की तरह आसानी से प्राप्त कर सकते हैं:

import {chunk} from 'lodash';
// divides the array into 2 sections
chunk([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11], 2); // => [[1,2,3,4,5,6], [7,8,9,10,11]]