JavaScript में मैट्रिक्स को क्षैतिज रूप से फ्लिप करना और इनवर्ट करना

समस्या

हमें एक JavaScript फ़ंक्शन लिखना है जो एक 2-D बाइनरी सरणी, arr, (एक सरणी जिसमें केवल 0 या 1 होते हैं), को पहला और एकमात्र तर्क के रूप में लेता है।

हमारे फ़ंक्शन को पहले मैट्रिक्स को क्षैतिज रूप से फ्लिप करना चाहिए, फिर उसे इनवर्ट करना चाहिए, और परिणामी मैट्रिक्स वापस करना चाहिए।

मैट्रिक्स को क्षैतिज रूप से फ्लिप करने का मतलब है कि मैट्रिक्स की प्रत्येक पंक्ति उलटी हो जाती है। उदाहरण के लिए, [1, 1, 0] को क्षैतिज रूप से फ्लिप करने पर [0, 1, 1] प्राप्त होता है।

मैट्रिक्स को इनवर्ट करने का मतलब है कि प्रत्येक 0 को 1 से और प्रत्येक 1 को 0 से बदल दिया जाता है। उदाहरण के लिए, [0, 1, 1] को इनवर्ट करने पर [1, 0, 0] प्राप्त होता है।

उदाहरण के लिए, यदि फ़ंक्शन का इनपुट है

इनपुट

const arr = [
  [1, 1, 0],
  [1, 0, 1],
  [0, 0, 0]
];

आउटपुट

const output = [
  [1, 0, 0],
  [0, 1, 0],
  [1, 1, 1]
];

आउटपुट व्याख्या

पहले हम प्रत्येक पंक्ति को उल्टा करते हैं -

[[0,1,1],[1,0,1],[0,0,0]]

फिर, हम मैट्रिक्स को इनवर्ट करते हैं -

[[1,0,0],[0,1,0],[1,1,1]]

उदाहरण

const arr = [
  [1, 1, 0],
  [1, 0, 1],
  [0, 0, 0]
];
const flipAndInvert = (arr = []) => {
  const invert = n => (n === 1 ? 0 : 1);
  for (let i = 0; i < arr.length; i++) {
    for (let j = 0; j < arr[i].length / 2; j++) {
      const index2 = arr[i].length - 1 - j;
      if (j === index2) {
        arr[i][j] = invert(arr[i][j]);
      } else {
        const temp = arr[i][j];
        arr[i][j] = arr[i][index2];
        arr[i][index2] = temp;
        arr[i][j] = invert(arr[i][j]);
        arr[i][index2] = invert(arr[i][index2]);
      }
    }
  }
};
flipAndInvert(arr);
console.log(arr);

आउटपुट

[ [ 1, 0, 0 ], [ 0, 1, 0 ], [ 1, 1, 1 ] ]