JavaScript में लक्ष्य से छोटा सबसे बड़ा आयत योग

समस्या

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

हमारे फ़ंक्शन को उस आयत का पता लगाना चाहिए जिसका योग सरणी में सभी आयतों में सबसे बड़ा है लेकिन दूसरे आर्गुमेंट द्वारा निर्दिष्ट लक्ष्य योग से कम या बराबर है।

फ़ंक्शन को अंत में वह सबसे बड़ा योग वापस करना चाहिए। उदाहरण के लिए, यदि फ़ंक्शन का इनपुट है -

const arr = [ 
  [1, 0, 1], 
  [0, -2, 3] 
]; 
const num = 2;

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

const output = 2;

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

क्योंकि सबसे छोटा आयत है -

[ 
  [0, 1] 
  [-2, 3] 
]

उदाहरण

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

const arr = [ 
  [1, 0, 1], 
  [0, -2, 3] 
]; 
const num = 2; 
const maxSum = (arr = [], num = 1) => { 
  const rows = arr.length; 
  const cols = arr[0].length; 
  let maxSum = -Infinity; 
  for(let l = 0; l < rows; l++) { 
    const dp = Array(cols).fill(0); 
    for(let r = l; r < rows; r++) { 
      let sum = 0, max = -Infinity; 
      for(let c = 0; c < cols; c++) { 
        dp[c] += arr[r][c]; 
        if(sum < 0) sum = 0; 
        sum += dp[c]; 
        max = Math.max(max, sum); 
      } 
      if(max <= num) maxSum = Math.max(max, maxSum); 
      else { 
        max = -Infinity; 
        for(let c = 0; c < cols; c++) { 
          sum = 0; 
          for(let d = c; d < cols; d++) { 
            sum += dp[d]; 
            if(sum <= num) max = Math.max(sum, max); 
          } 
        } 
        maxSum = Math.max(max, maxSum); 
      } 
      if(maxSum === num) return num; 
    } 
  } 
  return maxSum; 
}; 
console.log(maxSum(arr, num));

आउटपुट

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

2