জাভাস্ক্রিপ্টে 2D-অ্যারে স্থানান্তরিত হচ্ছে

Question

আমি অ্যারে একটি অ্যারে পেয়েছি, এরকম কিছু:

[
    [1,2,3],
    [1,2,3],
    [1,2,3],
]

আমি নিম্নলিখিত অ্যারে পেতে এটি স্থানান্তর করতে চাই:

[
    [1,1,1],
    [2,2,2],
    [3,3,3],
]

প্রোগ্রামগুলি লুপগুলি ব্যবহার করে এটি করা কঠিন নয়:

function transposeArray(array, arrayLength){
    var newArray = [];
    for(var i = 0; i < array.length; i++){
        newArray.push([]);
    };

    for(var i = 0; i < array.length; i++){
        for(var j = 0; j < arrayLength; j++){
            newArray[j].push(array[i][j]);
        };
    };

    return newArray;
}

এটি অবশ্য ভারী বলে মনে হচ্ছে এবং আমি মনে করি এটি করার কোনও সহজ উপায় হওয়া উচিত। আছে?

Comments

আপনি গ্যারান্টি দিতে পারেন যে দুটি মাত্রা সবসময় একই থাকবে? 1x1, 2x2, 3x3, ইত্যাদি arrayLengthপ্যারামিটারটি ঠিক কী জন্য ব্যবহৃত হয়? আপনি অ্যারেতে নির্দিষ্ট সংখ্যক উপাদান অতিক্রম করবেন না তা নিশ্চিত করার জন্য?

— ক্রাশ করুন

জিকুয়েরির সাথে এর কোনও যোগসূত্র নেই, আমি শিরোনামটি পরিবর্তন করেছি।

— জো

এটি দেখুন: স্ট্যাকওভারফ্লো / প্রশ্ন / 4492678/… । আপনি যা করছেন তা একটি ম্যাট্রিক্স ট্রান্সপোস করছে

— stackErr

হ্যাঁ, ট্রান্সপোসিং করা হচ্ছে। ইনভার্টিং সম্পূর্ণ আলাদা হবে এবং আমি এতে আগ্রহী নই। আপাতত

— ckersch

উপরের বাম থেকে নীচে ডান তির্যকটি অপরিবর্তিত রয়েছে সুতরাং একটি অপ্টিমাইজেশনের সুযোগ রয়েছে।

— এস মেইডেন

Answer 1

array[0].map((_, colIndex) => array.map(row => row[colIndex]));

mapcallbackঅ্যারেতে প্রতিটি উপাদানগুলির জন্য একবার সরবরাহিত ফাংশনকে কল করে, ফলাফল থেকে নতুন অ্যারে তৈরি করে।callbackকেবলমাত্র অ্যারের সূচকগুলির জন্য অনুরোধ করা হয়েছে যা নির্ধারিত মানগুলি দিয়েছে; এটি মুছে ফেলা হয়েছে বা যা কখনও মান নির্ধারিত হয় নি এমন সূচিগুলির জন্য অনুরোধ করা হয়নি।

callbackতিনটি যুক্তি সহ আহ্বান করা হয়: উপাদানটির মান, উপাদানটির সূচী এবং অ্যারে অবজেক্টকে বিভ্রান্ত করা হয়। [উৎস]

Comments

এটি একটি ভাল সমাধান। তবে, আপনি যদি পারফরম্যান্সের বিষয়ে চিন্তা করেন তবে আপনাকে ওপি'র আসল সমাধানটি ব্যবহার করতে হবে (এম / এন বাগানে এম! এন সমর্থন করার জন্য ডাব্লু / বাগ ফিক্স)। এই jscreen দেখুন

— বিলি ম্যাকি

আপনি যদি একই অ্যারেটিতে দু'বার ব্যবহার করেন, তবে এটি আবার 90 'ঘোরানোর প্রথম এক আন্তঃতে ফিরে আসে

— অলিভিয়ার পন্স

এর array[0].mapপরিবর্তে কেন array.map?

— জন ভ্যান্ডিভিয়ার

array[0].mapকারণ তিনি অনেকবার পুনরাবৃত্তি করতে চান যে কলামগুলি রয়েছে, array.mapএটি আবার কতগুলি সারি রয়েছে তা পুনরাবৃত্তি করবে।

— joeycozza

2019 সালে বিলিএমসিকি এবং ক্রোম 75 loopsএর চেয়ে 45% ধীর map। এবং হ্যাঁ, এটি সঠিকভাবে স্থানান্তর করে, তাই দ্বিতীয় রান প্রাথমিক ম্যাট্রিক্স প্রদান করে।

— এবুল

Answer 2

এখানে আধুনিক ব্রাউজারে আমার বাস্তবায়ন রয়েছে (নির্ভরতা ছাড়াই):

transpose = m => m[0].map((x,i) => m.map(x => x[i]))

Comments

আপনি যদি একই অ্যারেটিতে দু'বার ব্যবহার করেন, তবে এটি আবার 90 'ঘোরানোর প্রথম এক আন্তঃতে ফিরে আসে

— অলিভিয়ার পন্স

ট্রান্সপোজ ম্যাট্রিক্সের ট্রান্সপোজটি মূল ম্যাট্রিক্স, math.nyu.edu/~neylon/linalgfall04/project1/dj/proptranspose.htm দেখুন

— মাহদী জাদালিহা

Answer 3

আপনি আন্ডারস্কোর.জেএস ব্যবহার করতে পারেন

_.zip.apply(_, [[1,2,3], [1,2,3], [1,2,3]])

Comments

এটি সুন্দর ছিল - এছাড়াও, আন্ডারস্কোরটি আমার কাছে jQuery এর চেয়ে বেশি প্রয়োজনীয়।

— জন স্ট্রিকলার

বা আপনি যদি কোনও কার্যকরী লাইব্রেরি ব্যবহার করছেন তবে আপনি rambdaকরতে পারেনconst transpose = apply(zip)

— গাই হু জানে স্টাফ

কেন এই বিকল্পটি নির্বাচিত উত্তরের চেয়ে ভাল হবে?

— অ্যালেক্স লেনাইল

এই প্রশ্নটি বহু বছরের পুরনো এবং এখনই তা নিশ্চিত। এটা চেয়ে ক্লিনার, যদিও গৃহীত উত্তর আসল সংস্করণটি । আপনি দেখতে পাবেন যে এটির পরে যথেষ্ট পরিমাণে সম্পাদনা করা হয়েছে। দেখে মনে হচ্ছে এটি ES6 ব্যবহার করে, যা আমি মনে করি না যে 2013 সালে যখন প্রশ্নটি ব্যাপকভাবে জিজ্ঞাসা করা হয়েছিল তখন এটি উপলব্ধ ছিল।

— জো

Answer 4

সঙ্গে সংক্ষিপ্ত রাস্তা lodash/ underscoreএবং es6:

_.zip(...matrix)

যেখানে matrixহতে পারে:

const matrix = [[1,2,3], [1,2,3], [1,2,3]];

Comments

অথবা, ES6 ছাড়াই:_.zip.apply(_, matrix)

— এচ

বন্ধ করুন তবে _.উনজিপ (ম্যাট্রিক্স) খাটো;)

— প্রাণবন্ত

আপনি এই উপর প্রসারিত করতে পারেন? আপনি এখানে যা বলছেন তা আমি পাই না। এই সংক্ষিপ্ত স্নিপলেট সমস্যার সমাধান করার কথা? বা এটি কেবল একটি অংশ বা কী?

— জুলিক্স

আমার গুশ এটি একটি সংক্ষিপ্ত সমাধান। সবেমাত্র ... অপারেটর সম্পর্কে শিখেছি - এটি একটি অক্ষরগুলিতে একটি স্ট্রিং ভাঙ্গতে ব্যবহার করেছিল ... উত্তরের জন্য ধন্যবাদ

— জুলিক্স

Answer 5

এখানে অনেক ভাল উত্তর! আমি তাদের একটি উত্তরে একত্রীকরণ করেছি এবং আরও আধুনিক সিনট্যাক্সের জন্য কিছু কোড আপডেট করেছি:

ফাওয়াদ গাফুর এবং অস্কার গমেজ আলকায়েজ দ্বারা অনুপ্রাণিত ওয়ান-লাইনার

function transpose(matrix) {
  return matrix[0].map((col, i) => matrix.map(row => row[i]));
}

function transpose(matrix) {
  return matrix[0].map((col, c) => matrix.map((row, r) => matrix[r][c]));
}

অ্যান্ড্রু ট্যাটোমির দ্বারা হ্রাস সহ কার্যকরী পদ্ধতির স্টাইল

function transpose(matrix) {
  return matrix.reduce((prev, next) => next.map((item, i) =>
    (prev[i] || []).concat(next[i])
  ), []);
}

Lodash / আন্ডারস্কোর দ্বারা মার্সেল

function tranpose(matrix) {
  return _.zip(...matrix);
}

// Without spread operator.
function transpose(matrix) {
  return _.zip.apply(_, [[1,2,3], [1,2,3], [1,2,3]])
}

ভ্যানিলা পদ্ধতির

function transpose(matrix) {
  const rows = matrix.length, cols = matrix[0].length;
  const grid = [];
  for (let j = 0; j < cols; j++) {
    grid[j] = Array(rows);
  }
  for (let i = 0; i < rows; i++) {
    for (let j = 0; j < cols; j++) {
      grid[j][i] = matrix[i][j];
    }
  }
  return grid;
}

ইমানুয়েল সারানান দ্বারা অনুপ্রাণিত ভ্যানিলা ইন-প্লেস ES6 পদ্ধতির

function transpose(matrix) {
  for (var i = 0; i < matrix.length; i++) {
    for (var j = 0; j < i; j++) {
      const temp = matrix[i][j];
      matrix[i][j] = matrix[j][i];
      matrix[j][i] = temp;
    }
  }
}

// Using destructing
function transpose(matrix) {
  for (var i = 0; i < matrix.length; i++) {
    for (var j = 0; j < i; j++) {
      [matrix[i][j], matrix[j][i]] = [matrix[j][i], matrix[i][j]];
    }
  }
}

Answer 6

পরিষ্কার এবং বিশুদ্ধ:

[[0, 1], [2, 3], [4, 5]].reduce((prev, next) => next.map((item, i) =>
    (prev[i] || []).concat(next[i])
), []); // [[0, 2, 4], [1, 3, 5]]

পূর্ববর্তী সমাধানগুলি যদি খালি অ্যারে সরবরাহ করা হয় তবে ব্যর্থতার দিকে নিয়ে যেতে পারে।

এখানে এটি একটি ফাংশন হিসাবে রয়েছে:

function transpose(array) {
    return array.reduce((prev, next) => next.map((item, i) =>
        (prev[i] || []).concat(next[i])
    ), []);
}

console.log(transpose([[0, 1], [2, 3], [4, 5]]));

হালনাগাদ. এটি স্প্রেড অপারেটরের সাথে আরও ভাল লেখা যেতে পারে:

const transpose = matrix => matrix.reduce(
    ($, row) => row.map((_, i) => [...($[i] || []), row[i]]), 
    []
)

Comments

আমি জানি না যে আমি সেই আপডেটটিকে আরও ভাল বলব। এটি চালাক, নিশ্চিত, তবে এটি পড়ার জন্য দুঃস্বপ্ন।

— মেরি

Answer 7

আপনি এটি কেবলমাত্র একটি পাস দিয়ে স্থানে করতে পারেন:

function transpose(arr,arrLen) {
  for (var i = 0; i < arrLen; i++) {
    for (var j = 0; j <i; j++) {
      //swap element[i,j] and element[j,i]
      var temp = arr[i][j];
      arr[i][j] = arr[j][i];
      arr[j][i] = temp;
    }
  }
}

Comments

যদি আপনার অ্যারেটি বর্গক্ষেত্র না হয় (উদাহরণস্বরূপ 2x8) এটি অনুমান করে না যে

— অলিভিয়ার পন্স

এই সমাধানটি মূল অ্যারে পরিবর্তন করে। আপনার যদি এখনও মূল অ্যারের প্রয়োজন হয় তবে এই সমাধানটি আপনি যা চান তা নাও হতে পারে। অন্যান্য সমাধান পরিবর্তে একটি নতুন অ্যারে তৈরি করে।

— অ্যালেক্স

কেউ কি জানেন কীভাবে এটি ES6 সিনট্যাক্সে করা হয়? আমি চেষ্টা করেছি [arr[j][j],arr[i][j]] = [arr[i][j],arr[j][j]]কিন্তু মনে হচ্ছে এটি কাজ করছে না, আমি কি কিছু মিস করছি?

— নিকাসভ

@Nikasv আপনি সম্ভবত চান [arr[j][i], arr[i][j]] = [arr[i][j], arr[j][i]]। মনে রাখবেন আপনার কিছু arr[j][j]শর্ত রয়েছে যা সর্বদা তির্যক কক্ষগুলিকে উল্লেখ করবে।

— অ্যালগরিদমিক ক্যানারি

Answer 8

ব্যবহার করে আরও একটি ভিন্নতা Array.map। সূচকগুলি ব্যবহার করে ম্যাট্রিকগুলি স্থানান্তর করতে দেয় যেখানে M != N:

// Get just the first row to iterate columns first
var t = matrix[0].map(function (col, c) {
    // For each column, iterate all rows
    return matrix.map(function (row, r) { 
        return matrix[r][c]; 
    }); 
});

ট্রান্সপোসিংয়ের যাবতীয় উপাদানগুলি কলাম-প্রথমে এবং পরে সারিবদ্ধভাবে উপাদানগুলিকে ম্যাপিং করছে।

Answer 9

যদি আপনার কাছে রমদা জেএস এবং ইএস 6 সিনট্যাক্স ব্যবহারের বিকল্প থাকে তবে এটি করার জন্য এখানে আরও একটি উপায় রয়েছে:

const transpose = a => R.map(c => R.map(r => r[c], a), R.keys(a[0]));

console.log(transpose([
  [1, 2, 3, 4],
  [5, 6, 7, 8],
  [9, 10, 11, 12]
])); // =>  [[1,5,9],[2,6,10],[3,7,11],[4,8,12]]

<script src="https://cdnjs.cloudflare.com/ajax/libs/ramda/0.22.1/ramda.min.js"></script>

Comments

এটি সমাধানের জন্য রামদা এবং

— ইএস 6

রামদা আসলে এখন একটি transposeফাংশন আছে।

— জ্যাকব লরিজেন

Answer 10

বাইরে থেকে অভ্যন্তরে অ্যারেটি পুনরায় করা এবং অভ্যন্তরীণ মানগুলি ম্যাপিংয়ের মাধ্যমে ম্যাট্রিক্স হ্রাস করার মাধ্যমে আরেকটি পদ্ধতি approach

const
    transpose = array => array.reduce((r, a) => a.map((v, i) => [...(r[i] || []), v]), []),
    matrix = [[1, 2, 3], [1, 2, 3], [1, 2, 3]];

console.log(transpose(matrix));

Comments

প্রকৃতপক্ষে! আপনি @ অ্যান্ড্রু টেটোমির উত্তরটি অনুকূলিত করেছেন! (

— মানদণ্ডগুলি

Answer 11

যদি রামদাজেএস ব্যবহার করা কোনও বিকল্প হয় তবে এটি এক লাইনে অর্জন করা যেতে পারে: R.transpose(myArray)

Answer 12

আপনি নিম্নলিখিত ব্যবহার করে লুপগুলি ছাড়াই এটি অর্জন করতে পারেন।

• Array
• Array.prototype.map
• Array.prototype.reduce
• Array.prototype.join
• String.prototype.split

এটি দেখতে খুব মার্জিত দেখাচ্ছে এবং এর জন্য বোঝার দরকার নেই যেমন বোঝার মতো jQuery.js ।

function transpose(matrix) {  
    return zeroFill(getMatrixWidth(matrix)).map(function(r, i) {
        return zeroFill(matrix.length).map(function(c, j) {
            return matrix[j][i];
        });
    });
}

function getMatrixWidth(matrix) {
    return matrix.reduce(function (result, row) {
        return Math.max(result, row.length);
    }, 0);
}

function zeroFill(n) {
    return new Array(n+1).join('0').split('').map(Number);
}

minified

function transpose(m){return zeroFill(m.reduce(function(m,r){return Math.max(m,r.length)},0)).map(function(r,i){return zeroFill(m.length).map(function(c,j){return m[j][i]})})}function zeroFill(n){return new Array(n+1).join("0").split("").map(Number)}

---

এখানে একটি ডেমো আমি একসাথে ছুড়েছি। লুপের অভাব লক্ষ্য করুন :-)

// Create a 5 row, by 9 column matrix.
var m = CoordinateMatrix(5, 9);

// Make the matrix an irregular shape.
m[2] = m[2].slice(0, 5);
m[4].pop();

// Transpose and print the matrix.
println(formatMatrix(transpose(m)));

function Matrix(rows, cols, defaultVal) {
    return AbstractMatrix(rows, cols, function(r, i) {
        return arrayFill(cols, defaultVal);
    });
}
function ZeroMatrix(rows, cols) {
    return AbstractMatrix(rows, cols, function(r, i) {
        return zeroFill(cols);
    });
}
function CoordinateMatrix(rows, cols) {
    return AbstractMatrix(rows, cols, function(r, i) {
        return zeroFill(cols).map(function(c, j) {
            return [i, j];
        });
    });
}
function AbstractMatrix(rows, cols, rowFn) {
    return zeroFill(rows).map(function(r, i) {
        return rowFn(r, i);
    });
}
/** Matrix functions. */
function formatMatrix(matrix) {
    return matrix.reduce(function (result, row) {
        return result + row.join('\t') + '\n';
    }, '');
}
function copy(matrix) {  
    return zeroFill(matrix.length).map(function(r, i) {
        return zeroFill(getMatrixWidth(matrix)).map(function(c, j) {
            return matrix[i][j];
        });
    });
}
function transpose(matrix) {  
    return zeroFill(getMatrixWidth(matrix)).map(function(r, i) {
        return zeroFill(matrix.length).map(function(c, j) {
            return matrix[j][i];
        });
    });
}
function getMatrixWidth(matrix) {
    return matrix.reduce(function (result, row) {
        return Math.max(result, row.length);
    }, 0);
}
/** Array fill functions. */
function zeroFill(n) {
  return new Array(n+1).join('0').split('').map(Number);
}
function arrayFill(n, defaultValue) {
    return zeroFill(n).map(function(value) {
        return defaultValue || value;
    });
}
/** Print functions. */
function print(str) {
    str = Array.isArray(str) ? str.join(' ') : str;
    return document.getElementById('out').innerHTML += str || '';
}
function println(str) {
    print.call(null, [].slice.call(arguments, 0).concat(['<br />']));
}

#out {
    white-space: pre;
}

<div id="out"></div>

Comments

আপনি লুপ ছাড়া এটি করতে চান না কেন? লুপগুলি ছাড়াই এটি ধীরে ধীরে

— ডাউনগোট

.মুপ কি লুপ নয়? শুধু আপনি দেখতে পাচ্ছেন না? আমি বলতে চাচ্ছি এটা ইনপুট প্রতিটি ওভার যাচ্ছে এবং এটি উপাদান আছে ... এর

— Julix

Answer 13

ES6 1liners হিসাবে:

let invert = a => a[0].map((col, c) => a.map((row, r) => a[r][c]))

অস্কারের মতোই, তবে আপনি এটি বরং ঘড়ির কাঁটার দিকে ঘোরান:

let rotate = a => a[0].map((col, c) => a.map((row, r) => a[r][c]).reverse())

Answer 14

সম্পাদনা করুন: এই উত্তরটি ম্যাট্রিক্স স্থানান্তর করবে না, তবে এটি ঘুরবে। আমি প্রথমে প্রশ্নটি মনোযোগ দিয়ে পড়িনি: ডি

ঘড়ির কাঁটার বিপরীতে এবং ঘড়ির কাঁটার বিপরীতে:

    function rotateCounterClockwise(a){
        var n=a.length;
        for (var i=0; i<n/2; i++) {
            for (var j=i; j<n-i-1; j++) {
                var tmp=a[i][j];
                a[i][j]=a[j][n-i-1];
                a[j][n-i-1]=a[n-i-1][n-j-1];
                a[n-i-1][n-j-1]=a[n-j-1][i];
                a[n-j-1][i]=tmp;
            }
        }
        return a;
    }

    function rotateClockwise(a) {
        var n=a.length;
        for (var i=0; i<n/2; i++) {
            for (var j=i; j<n-i-1; j++) {
                var tmp=a[i][j];
                a[i][j]=a[n-j-1][i];
                a[n-j-1][i]=a[n-i-1][n-j-1];
                a[n-i-1][n-j-1]=a[j][n-i-1];
                a[j][n-i-1]=tmp;
            }
        }
        return a;
    }

Comments

যদিও প্রশ্নের উত্তর দেয় না; ট্রান্সপোসিংয়ের মতো ... তির্যকটি দিয়ে মিররিং করা (ঘোরানো নয়)

— ডারমাইক

@ ডেরমাইককে নির্দেশ করার জন্য ধন্যবাদ। আমি জানি না কেন আমি এই ভুলটি করেছি :) তবে কমপক্ষে আমি দেখতে পাচ্ছি এটি অন্য কিছু ব্যক্তির পক্ষে কার্যকর ছিল।

— আর্যান ফিরোজিয়ান

ম্যাট্রিক্স ঘোরার

— নিতিন যাদব

Answer 15

আমি উপরোক্ত উত্তরগুলি পড়তে খুব কঠিন বা খুব ভার্বোস পেয়েছি, তাই আমি নিজেই একটি লিখি। এবং আমি মনে করি লিনিয়ার বীজগণিতে ট্রান্সপোজ প্রয়োগের এটি সবচেয়ে স্বজ্ঞাত উপায়, আপনি মান বিনিময় করবেন না , তবে প্রতিটি উপাদানকে নতুন ম্যাট্রিক্সে সঠিক জায়গায় সন্নিবেশ করুন:

function transpose(matrix) {
  const rows = matrix.length
  const cols = matrix[0].length

  let grid = []
  for (let col = 0; col < cols; col++) {
    grid[col] = []
  }
  for (let row = 0; row < rows; row++) {
    for (let col = 0; col < cols; col++) {
      grid[col][row] = matrix[row][col]
    }
  }
  return grid
}

Answer 16

আমি মনে করি এটি কিছুটা বেশি পঠনযোগ্য। এটি ব্যবহার করে Array.fromএবং যুক্তিযুক্ত নেস্টেড লুপগুলি ব্যবহার করার মতো ical

var arr = [
  [1, 2, 3, 4],
  [1, 2, 3, 4],
  [1, 2, 3, 4]
];

/*
 * arr[0].length = 4 = number of result rows
 * arr.length = 3 = number of result cols
 */

var result = Array.from({ length: arr[0].length }, function(x, row) {
  return Array.from({ length: arr.length }, function(x, col) {
    return arr[col][row];
  });
});

console.log(result);

আপনি যদি অসম দৈর্ঘ্যের অ্যারে নিয়ে কাজ করে থাকেন তবে আপনাকে arr[0].lengthঅন্য কিছু দিয়ে প্রতিস্থাপন করতে হবে:

var arr = [
  [1, 2],
  [1, 2, 3],
  [1, 2, 3, 4]
];

/*
 * arr[0].length = 4 = number of result rows
 * arr.length = 3 = number of result cols
 */

var result = Array.from({ length: arr.reduce(function(max, item) { return item.length > max ? item.length : max; }, 0) }, function(x, row) {
  return Array.from({ length: arr.length }, function(x, col) {
    return arr[col][row];
  });
});

console.log(result);

Answer 17

function invertArray(array,arrayWidth,arrayHeight) {
  var newArray = [];
  for (x=0;x<arrayWidth;x++) {
    newArray[x] = [];
    for (y=0;y<arrayHeight;y++) {
        newArray[x][y] = array[y][x];
    }
  }
  return newArray;
}

Answer 18

টাইপস্ক্রিপ্টে একটি লাইব্রেরি মুক্ত প্রয়োগ যা কোনও ম্যাট্রিক্স আকারের জন্য কাজ করে যা আপনার অ্যারেগুলি কেটে ফেলবে না:

const rotate2dArray = <T>(array2d: T[][]) => {
    const rotated2d: T[][] = []

    return array2d.reduce((acc, array1d, index2d) => {
        array1d.forEach((value, index1d) => {
            if (!acc[index1d]) acc[index1d] = []

            acc[index1d][index2d] = value
        })

        return acc
    }, rotated2d)
}

Answer 19

ওয়ান-লাইনার যা প্রদত্ত অ্যারে পরিবর্তন করে না।

a[0].map((col, i) => a.map(([...row]) => row[i]))

Answer 20

reverseValues(values) {
        let maxLength = values.reduce((acc, val) => Math.max(val.length, acc), 0);
        return [...Array(maxLength)].map((val, index) => values.map((v) => v[index]));
}

Comments

দয়া করে একটি উত্তর হিসাবে কেবল কোড পোস্ট করবেন না, তবে আপনার কোডটি কী করে এবং কীভাবে এটি সমস্যার সমস্যার সমাধান করে তার একটি ব্যাখ্যা অন্তর্ভুক্ত করুন। একটি ব্যাখ্যা সহ উত্তরগুলি সাধারণত উচ্চমানের এবং উন্নতদের আকর্ষণ করার সম্ভাবনা বেশি।

— মার্ক রোটভিল

Answer 21

const transpose = array => array[0].map((r, i) => array.map(c => c[i]));
console.log(transpose([[2, 3, 4], [5, 6, 7]]));

Answer 22

আমাকে সন্তুষ্ট করে এমন কোনও উত্তর আমি পাইনি, তাই আমি নিজেই একটি লিখেছিলাম, আমি মনে করি এটি বুঝতে এবং বাস্তবায়ন করা সহজ এবং সব পরিস্থিতিতে উপযুক্ত।

    transposeArray: function (mat) {
        let newMat = [];
        for (let j = 0; j < mat[0].length; j++) {  // j are columns
            let temp = [];
            for (let i = 0; i < mat.length; i++) {  // i are rows
                temp.push(mat[i][j]);  // so temp will be the j(th) column in mat
            }
            newMat.push(temp);  // then just push every column in newMat
        }
        return newMat;
    }

Answer 23

যেহেতু এখন পর্যন্ত কেউ এখানে কার্যকরী পুনরাবৃত্ত পদ্ধতির উল্লেখ করেনি তা আমার গ্রহণ। হাস্কেলের একটি অভিযোজন Data.List.transpose।

var transpose = as => as.length ? as[0].length ? [ as.reduce( (rs,a) => a.length ? ( rs.push(a[0])
                                                                                   , rs
                                                                                   )
                                                                                 : rs
                                                            , []
                                                            )
                                                 , ...transpose(as.map(a => a.slice(1)))
                                                 ]
                                               : transpose(as.slice(1))
                                : [],
    mtx       = [[1], [1, 2], [1, 2, 3]];

console.log(transpose(mtx))

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