सरणी से ऐरे कैसे बनाएँ [बंद]

Question

मैं एक जावास्क्रिप्ट शुरुआत कर रहा हूं और मैं एक मुख्य सरणी से मूल्यों के साथ दो अलग-अलग सरणियां बनाने की कोशिश कर रहा हूं।

मेरा मुख्य सरणी दिखता है:

0: Array(3) [ 2011, 127072.7, 51584 ]
1: Array(3) [ 2012, 125920.3, 59974 ]
2: Array(3) [ 2013, 129305.4, 15468 ]
3: Array(3) [ 2014, 135364, 84554 ]
4: Array(3) [ 2015, 136757, 98754 ]
5: Array(3) [ 2016, 155653.5, 155548 ]
6: Array(3) [ 2017, 164130.5, 284848 ]

और मुझे दो सरणियाँ बनाने की आवश्यकता है, पहली बार देख रहे हैं:

0: Array(2) [ 2011, 127072.7]
1: Array(2) [ 2012, 125920.3]
2: Array(2) [ 2013, 129305.4]
3: Array(2) [ 2014, 135364]
4: Array(2) [ 2015, 136757]
5: Array(2) [ 2016, 155653.5]
6: Array(2) [ 2017, 164130.5]

(पहला और दूसरा मूल्य)

और दूसरा जैसा:

0: Array(2) [ 2011, 51584]
1: Array(2) [ 2012, 59974]
2: Array(2) [ 2013, 15468]
3: Array(2) [ 2014, 84554]
4: Array(2) [ 2015, 98754]
5: Array(2) [ 2016, 155548]
6: Array(2) [ 2017, 284848]

(पहला और तीसरा मूल्य)

मैं ब्याह, फिल्टर आदि की कोशिश कर रहा हूं, लेकिन मुझे नहीं पता, कैसे शुरू करें।

यह मुझे एक सटीक समाधान लिखने के लिए आवश्यक नहीं है, लेकिन केवल यह कैसे करना है कदम।

Comments

शानदार जवाब के लिए बहुत-बहुत धन्यवाद। वे महान काम करते हैं। मेरे पास भविष्य के लिए एक प्रश्न हो सकता है। क्या ऐसा किया जा सकता है कि यह दो क्षेत्रों के लिए तय नहीं है? लेकिन तीन, चार, आदि भी?

— डोमिनिक लेव

वास्तविक समस्या क्या है जिसे आप यहाँ हल करने का प्रयास कर रहे हैं? ऐसा लगता है कि वस्तुओं की एक सरणी का उपयोग करना बेहतर विकल्प है।

— ब्लूराजा - डैनी पफ्लुगुएफ्ट

सुझाव: अपने सरणी में स्पष्ट रूप से लगातार वर्षों के बजाय, आप किसी दिए गए प्रारंभिक बिंदु से वर्ष का अनुमान लगा सकते हैं। तब आपको केवल एक स्केलर शुरुआती बिंदु की आवश्यकता होती है, और किसी भी तत्व के लिए वर्ष उसके सरणी सूचकांक के आधार पर जाना जाता है। (केवल तभी काम करता है जब आपके वर्ष हमेशा सन्निहित हों और इस उदाहरण की तरह आरोही क्रम में। लेकिन क्या जोड़े की एक सरणी से सिर्फ आदिम संख्या की एक सरणी तक सरलता से सरलता होती है।)

— पीटर कॉर्ड

Answer 1

आप एक गतिशील दृष्टिकोण ले सकते हैं और प्रत्येक नए सरणी के लिए महत्वपूर्ण मान के बाद सरणी के सभी आइटम प्राप्त कर सकते हैं।

var data = [[2011, 127072.7, 51584], [2012, 125920.3, 59974], [2013, 129305.4, 15468], [2014, 135364, 84554], [2015, 136757, 98754], [2016, 155653.5, 155548], [2017, 164130.5, 284848]],
    [first, second] = data.reduce(
        (r, [k, ...a]) => {
            a.forEach((v, i) => r[i].push([k, v]));
            return r;
        },
        Array.from({ length: Array.isArray(data[0]) ? data[0].length - 1 : 0 }, () => [])
    );

console.log(first);
console.log(second);

.as-console-wrapper { max-height: 100% !important; top: 0; }

Comments

शानदार जवाब के लिए आपका बहुत-बहुत धन्यवाद। क्या मुझे भविष्य के लिए कोई सवाल हो सकता है? क्या यह केवल 2 सरणियों पर ही तय करना संभव है, लेकिन अधिक पर भी?

— डोमिनिक लेव

आप के [first, second]साथ प्रतिस्थापित कर सकते हैं arrayऔर आप सरणियों के रूप में डेटा के सभी स्तंभों के साथ सरणियाँ प्राप्त कर सकते हैं।

— नीना स्कोल्ज़

इसके बजाय r[i] = r[i] || []आपको धीमी गति से बस Array.from({length: (data[0]?.length ?? 1) - 1}, () => [])शुरुआती संचयकर्ता मूल्य के लिए उपयोग करना चाहिए

— बर्गी

@NinaScholz नहीं, मेरा मतलब था कि आप जाँच रहे हैं कि क्या r[i]प्रत्येक लूप पुनरावृत्ति में मौजूद है, जबकि आप बस reduceकॉल के बाहर आवश्यक परिणाम सरणियाँ बना सकते हैं।

— बरगी

@Klaycon नहीं, सरणी सीमा से बाहर की पहुंच सुपर सुपर धीमी है, इसलिए "पहले से मौजूद है तो जांचें" अच्छी तरह से काम नहीं करती है। मेरी टिप्पणी प्रदर्शन के बारे में चिंता करने के लिए नहीं थी, बल्कि स्वच्छ और पूर्वानुमेय (सही) कोड पसंद करने के लिए थी। मैंने पहली बार "बल्कि बदसूरत और धीमा" लिखा था, यह महसूस करने से पहले कि मेरा सुझाव जो खाली मामले से निपटने के लिए स्पष्ट है वह वास्तविक सौंदर्य भी नहीं है।

— बरगी

Answer 2

आप .map()अपने डेटा पर पुनरावृति करने के लिए और वांछित उत्पादन प्राप्त करने के लिए कुछ ऐरे विनाशकारी का उपयोग कर सकते हैं :

const data = [
  [ 2011, 127072.7, 51584 ],
  [ 2012, 125920.3, 59974 ],
  [ 2013, 129305.4, 15468 ],
  [ 2014, 135364, 84554 ],
  [ 2015, 136757, 98754 ],
  [ 2016, 155653.5, 155548 ],
  [ 2017, 164130.5, 284848 ]
];

const arr1 = data.map(([year, val]) => ([year, val]));
const arr2 = data.map(([year, _, val]) => ([year, val]));

console.log(arr1);
console.log(arr2);

.as-console-wrapper { max-height: 100% !important; top: 0; }

Comments

शानदार जवाब के लिए आपका बहुत-बहुत धन्यवाद। क्या मुझे भविष्य के लिए कोई सवाल हो सकता है? क्या यह केवल 2 सरणियों पर ही तय करना संभव है, लेकिन अधिक पर भी?

— डोमिनिक लेव

@DominikLev उस मामले में आप नीना द्वारा पोस्ट किए गए उत्तर का उपयोग कर सकते हैं। यह अच्छा है।

— मोहम्मद उस्मान

बाकी पैरामीटर सिंटैक्स का उपयोग करके इसे सामान्यीकृत किया जा सकता है([year, ...values]) => [year, values[n]]

— जॉली जोकर

@ जॉलीजॉकर - आपको एक उत्तर के रूप में पोस्ट करना चाहिए, यह वास्तव में अच्छा और संक्षिप्त सामान्यीकृत समाधान है

— फिलिप मिलोवैनोविक

@ FilipMilovanović मैंने पहले से ही stackoverflow.com/a/60166014/7126740

— जॉली जोकर

Answer 3

आप Array.prototype.forEachमूल सरणी के आइटम पर पुनरावृति करने के लिए उपयोग कर सकते हैं , फिर नए आइटम बना सकते हैं और उन्हें नए सरणियों में धकेल सकते हैं:

var original = [[ 2011, 127072.7, 51584 ], [ 2012, 125920.3, 59974 ], [ 2013, 129305.4, 15468 ]]

var array1 = []
var array2 = []

original.forEach(item => {
  array1.push([item[0], item[1]]);
  array2.push([item[0], item[2]]);
});

console.log(array1);
console.log(array2);

आउटपुट:

---

हमारे सरणियों को गतिशील रूप से उत्पन्न करना, ताकि कोई फर्क नहीं पड़ता कि मूल सरणियों में कितने आइटम हैं:

var original = [
  [2011, 127072.7, 51584, 1, 2, 3],
  [2012, 125920.3, 59974, 4, 5, 6],
  [2013, 129305.4, 15468, 7, 8, 9]
]

// Array of arrays
var myArray = []

// Fill it with empty arrays
for (var i = 0; i < original[0].length - 1; i++)
  myArray.push([])

// Iterate over original
// For each original, insert the first and i-th element into our array of arrays
original.forEach(item => {
  for (var i = 1; i < item.length; i++) {
    myArray[i - 1].push([item[0], item[i]]);
  }
});

console.log(myArray);

आउटपुट:

Comments

शानदार जवाब के लिए आपका बहुत-बहुत धन्यवाद। क्या मुझे भविष्य के लिए कोई सवाल हो सकता है? क्या यह केवल 2 सरणियों पर ही तय करना संभव है, लेकिन अधिक पर भी?

— डोमिनिक लेव

अग्रिम में जाने बिना यह जानना संभव है कि मूल सरणियों में कितने आइटम हैं, अग्रिम में गतिशील रूप से सरणियों को उत्पन्न करना। मेरे संपादित उत्तर पर एक नज़र डालें :)

— इस्माइल पैडीला

Answer 4

सबसे पहले, आपके पास शुरुआत में सरणियों की एक सरणी है। आप एक संक्षिप्त तरीके से सबरेज़ से प्रत्येक मान प्राप्त करने के mapलिए दो अलग-अलग सरणियों के लिए इस सरणी का उपयोग destructuringकर सकते हैं:

const data = [
  [ 2011, 127072.7, 51584 ],
  [ 2012, 125920.3, 59974 ],
  [ 2013, 129305.4, 15468 ],
  [ 2014, 135364, 84554 ],
  [ 2015, 136757, 98754 ],
  [ 2016, 155653.5, 155548 ],
  [ 2017, 164130.5, 284848 ],
];

const array1 = data.map(([first, second, third]) => [first, second]);
const array2 = data.map(([first, second, third]) => [first, third]);

console.log(JSON.stringify(array1));
console.log(JSON.stringify(array2));

Answer 5

मुख्य सरणी के माध्यम से लूप करें और अपने बच्चे सरणियों के मूल्यों तक पहुंचने के लिए निश्चित सूचकांक मूल्यों का उपयोग करके एक नया सरणी लौटाएं।

const multiDimArr = [
  [2011, 127072.7, 51584],
  [2012, 125920.3, 59974],
  [2013, 129305.4, 15468],
  [2014, 135364, 84554],
  [2015, 136757, 98754],
  [2016, 155653.5, 155548],
  [2017, 164130.5, 284848],
]

const arr1= multiDimArr.map(x=>[x[0],x[1]]);
const arr2= multiDimArr.map(x=>[x[0],x[2]]);

console.log(arr1)
console.log(arr2)

Answer 6

आप फंक्शन कम करने का उपयोग कर सकते हैं जो केवल एक बार पुनरावृत्त करता है:

let matrix = [[ 2011, 127072.7, 51584 ],[ 2012, 125920.3, 59974 ],[ 2013, 129305.4, 15468 ],[ 2014, 135364, 84554 ],[ 2015, 136757, 98754 ],[ 2016, 155653.5, 155548 ],[ 2017, 164130.5, 284848 ]];

let result = matrix.reduce((a, [year, k, v]) => {
  a.second.push([year, k]);
  a.third.push([year, v]);
  return a;
}, {second: [], third: []});

console.log(result);

.as-console-wrapper { max-height: 100% !important; top: 0; }

Comments

इस जवाब में सीएसएस क्यों?

— जोशुआ फॉक्स

@JoshuaFox सिर्फ कंसोल की ऊंचाई का विस्तार करने के लिए।

— हाथी

Answer 7

हेयर यू गो

let values = [[ 2011, 127072.7, 51584 ],[ 2012, 125920.3, 59974 ],[ 2013, 129305.4, 15468 ],[ 2014, 135364, 84554 ],[ 2015, 136757, 98754 ],[ 2016, 155653.5, 155548 ],[ 2017, 164130.5, 284848 ]];

let chunk1 = values.map(arr1 => {
  return [arr1[0], arr1[1]]
});
let chunk2 = values.map(arr1 => {
  return [arr1[0], arr1[2]]
})

console.log("Chunk 1", chunk1);
console.log("Chunk 2", chunk2);

Answer 8

मैंने लूप के लिए मानचित्र का उपयोग किया है, आवश्यक मूल्यों को आगे बढ़ाने के लिए दो सरणियों।

let point_table = []
let integer_table = []
const historical_table = [
  [2011, 127072.7, 51584],
  [2012, 125920.3, 59974],
  [2013, 129305.4, 15468],
  [2014, 135364, 84554],
  [2015, 136757, 98754],
  [2016, 155653.5, 155548],
  [2017, 164130.5, 284848]
]
historical_table.map(row => {
  point_table.push([row[0], row[1]])
  integer_table.push([row[0], row[2]])
})
console.log(point_table, integer_table)

Answer 9

एक और समाधान :

 const original= [  [ 2011, 127072.7, 51584 ], [ 2012, 125920.3, 59974 ],[ 2013, 129305.4, 15468 ],  [ 2014, 135364, 84554 ],  [ 2015, 136757, 98754 ],  [ 2016, 155653.5, 155548 ],  [ 2017, 164130.5, 284848 ]];

original.map (x => [[x [0], x [1]], [x [0], x [2]])) .reduce ((a, b) => a.concat (b), [])

Answer 10

जेनेरिक सॉल्यूशन के लिए, मुझे लगता है कि वैल्यू कॉलम के लिए इंडेक्स की एक सरणी का निर्माण आपको इच्छित डेटा को पूरा डेटा मैप करने का एक सरल तरीका देता है।

[...data[0].keys()].slice(0,-1)

आप सूचकांकों की एक सरणी देता है, एक स्तंभ है कि वर्ष था, और

n => data.map(([year, ...values]) => [year, values[n]])

आपको वह मूल्य देता है जो आप nth मान कॉलम के लिए चाहते हैं। इसलिए:

var data = [[2011, 127072.7, 51584], [2012, 125920.3, 59974], [2013, 129305.4, 15468], [2014, 135364, 84554], [2015, 136757, 98754], [2016, 155653.5, 155548], [2017, 164130.5, 284848]]

const yearArrays = arr => [...arr[0].keys()].slice(0,-1)
       .map(arr.map(([year, ...values]) => [year, values[n]]))

console.log(yearArrays(data));

.as-console-wrapper { max-height: 100% !important; top: 0; }

Answer 11

जेनेरिक लंबाई के इनपुट सरणियों के लिए एक और समाधान।

const input = [[1,11,111,1111],[2,22,222,2222]];

const result = input.reduce((accumulator, [head, ...tail]) => {
  tail.forEach((item, index) => {
    accumulator[index] = accumulator[index] || [];
    accumulator[index].push([head, item]);
  });
  return accumulator;
}, [])

console.log(result);

Answer 12

मौजूदा बहु आयामी सरणी से किसी भी सामान्य संयोजन बनाने के लिए इस समाधान का उपयोग करें। आपको स्पष्ट रूप से चुनने के लिए वस्तुओं के सूचकांक को पास करना होगा और यही इसे सामान्य बनाता है।

    const multiDimArr = [
      [2011, 127072.7, 51584],
      [2012, 125920.3, 59974],
      [2013, 129305.4, 15468],
      [2014, 135364, 84554],
      [2015, 136757, 98754],
      [2016, 155653.5, 155548],
      [2017, 164130.5, 284848],
    ]


    function arrayCombo (idxA, idxB){
      return multiDimArr.map(x=>[x[idxA],x[idxB]]);
    }

    console.log(arrayCombo(0, 1));
    console.log(arrayCombo(0, 2));
    console.log(arrayCombo(1, 2));