JavaScript में टमाटर सड़ने में लगने वाला समय

समस्या

हमें एक JavaScript फ़ंक्शन लिखना है जो संख्याओं का एक 2-D सरणी arr को एकमात्र आर्गुमेंट के रूप में लेता है।

सरणी में संख्याएं हो सकती हैं -

मान 0 जो एक खाली सेल का प्रतिनिधित्व करता है;
मान 1 जो एक ताजा टमाटर का प्रतिनिधित्व करता है;
मान 2 जो एक सड़ा हुआ टमाटर का प्रतिनिधित्व करता है।

हर मिनट, कोई भी ताजा टमाटर जो सड़े हुए टमाटर के निकट (4-दिशात्मक) है, सड़ जाता है।

हमारे फ़ंक्शन को उन न्यूनतम मिनटों की संख्या वापस करनी चाहिए जो तब तक बीतने चाहिए जब तक किसी सेल में ताजा टमाटर न हो। यदि यह असंभव है, तो हमें -1 वापस करना चाहिए।

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

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

तो आउटपुट होना चाहिए -

const output = 4;

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

बीता समय	टमाटर स्थिति
1	[ [2, 2, 1], [2, 1, 0], [0, 1, 1] ]
2	[ [2, 2, 2], [2, 2, 0], [0, 1, 1] ]
3	[ [2, 2, 2], [2, 2, 0], [0, 2, 1] ]
4	[ [2, 2, 2], [2, 2, 0], [0, 2, 2] ]

उदाहरण

इसके लिए कोड होगा -

const arr = [ 
  [2, 1, 1], 
  [1, 1, 0], 
  [0, 1, 1] 
]; 
const timeToRot = (arr = []) => { 
  let fresh = 0; 
  let count = -1; 
  let curr = []; 
  for(let i = 0; i < arr.length; i++){ 
    for(let j = 0; j < arr[i].length; j++){ 
      if(arr[i][j] === 1){ 
        fresh += 1; 
      }; 
      if(arr[i][j] === 2){ 
        curr.push([i, j]); 
      }; 
    }; 
  }; 
  if(!fresh){ 
    return 0; 
  }; 
  while(curr.length > 0){ 
    count += 1; 
    const next = []; 
    const rotten = (i, j) => { 
      arr[i][j] = 2; 
      next.push([i, j]); 
      fresh -= 1; 
    }; 
    for(const [i, j] of curr){ 
      if (arr[i - 1] && arr[i - 1][j] === 1) { 
        rotten(i - 1, j); 
      }; 
      if (arr[i + 1] && arr[i + 1][j] === 1) { 
        rotten(i + 1, j); 
      }; 
      if (arr[i][j - 1] === 1) { 
        rotten(i, j - 1); 
      }; 
      if (arr[i][j + 1] === 1) { 
        rotten(i, j + 1); 
      }; 
    } 
    curr = next; 
  }; 
  return fresh === 0 ? count : -1; 
}; 
console.log(timeToRot(arr));

आउटपुट

कंसोल में आउटपुट होगा -