सरणी तिरछे

Question

मैं एक सरणी है में एक ही मानों का पता लगाएं, मान लीजिए कि

var array = [ [1, 0, 0, 0, 0, 0, 0], 
       [0, 1, 0, 0, 0, 1, 0], 
       [0, 0, 1, 0, 1, 0, 0], 
       [0, 0, 0, 1, 0, 0, 0], 
       [0, 0, 1, 0, 0, 0, 0], 
       [0, 0, 0, 0, 0, 0, 0] 
      ] 

और मैं जहां एक नंबर प्रकट होता है चार बार तिरछे कोई मैच खोजने के लिए एक बनाने के लिए चाहते हैं।

वर्तमान में मैं

function checkDiagonal(array, bottomToTop) { 
    var Ylength = array.length; 
    var Xlength = array[0].length; 
    var maxLength = Math.max(Xlength, Ylength); 
    var temp; 
    var returnArray = []; 
    for (var k = 0; k <= 2 * (maxLength - 1); ++k) { 
     temp = []; 
     for (var y = Ylength - 1; y >= 0; --y) { 
      var x = k - (bottomToTop ? Ylength - y : y); 
      if (x >= 0 && x < Xlength) { 
       temp.push(array[y][x]); 
      } 
     } 
     if(temp.length > 0) { 
      returnArray.push(temp.join('')); 
     } 
    } 
    return returnArray; 
} 

उपयोग कर रहा हूँ लेकिन यह हमेशा सब समाधान

Answer 1

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

आशा इस मदद करता है:

function checkDiagonal(array, matchCount) { 
 
    var result = []; 
 

 
    if(array.length >= matchCount) { 
 
    // Search towards bottom-right. 
 
    result = result.concat(getDiagonalResult(array, matchCount, 1)); 
 

 
    // Search towards top-right. 
 
    result = result.concat(getDiagonalResult(array, matchCount, -1)); 
 
    } else { 
 
    // No use searching if not enough rows are present. 
 
    } 
 

 
    return result; 
 
} 
 

 
function getDiagonalResult(array, matchCount, direction) { 
 
    var result = []; 
 

 
    // Specific from and to points to only search in possible rows (e.g. no use searching top-right on first row). 
 
    var yFrom, yTo; 
 

 
    // Search direction (bottom-right vs top-right). 
 
    switch(direction) { 
 
     // Bottom-right. 
 
    case 1: 
 
     yFrom = 0; 
 
     yTo = (array.length - matchCount); 
 
     break; 
 

 
     // Top-right. 
 
    case -1: 
 
     yFrom = (matchCount - 1); 
 
     yTo = (array.length - 1); 
 
     break; 
 
    } 
 

 
    // Loop through all 'rows'. 
 
    for(var y = yFrom; y <= yTo; y++) { 
 

 
    // Loop through all 'columns'. 
 
    for(var x = 0; x <= (array[y].length - matchCount); x++) { 
 

 
     // Current value to match on. 
 
     var originalValue = array[y][x]; 
 
     var matches = []; 
 

 
     // Get matches. 
 
     for(var i = 0; i < matchCount; i++) { 
 
     // Search direction (row up or down). 
 
     var yDirection = (i * direction); 
 

 
     var value = array[y+yDirection][x+i]; 
 

 
     if(value === originalValue) { 
 
      matches.push(value); 
 
     } 
 
     } 
 

 
     if(matches.length == matchCount) { 
 
     result.push(matches.join("")); 
 
     } 
 
    } 
 

 
    } 
 

 
    return result; 
 
} 
 

 
var array = [ 
 
    [1, 0, 0, 0, 0, 0, 0], 
 
    [0, 1, 0, 0, 0, 1, 0], 
 
    [0, 0, 1, 0, 1, 0, 0], 
 
    [0, 0, 0, 1, 0, 0, 0], 
 
    [0, 0, 1, 0, 0, 0, 0], 
 
    [0, 0, 0, 0, 0, 0, 0] 
 
]; 
 

 
console.log(checkDiagonal(array, 4));

Answer 2

मैं हर subarray घूर्णन ताकि संख्या एक दूसरे को नीचे एक विकर्ण रेखा के गठन से सरणी preprocess होगा। सबसे पहले किसी भी दिशा में n तत्वों द्वारा एक सारिणी का बारी बारी से करने कार्यों को परिभाषित:

const rotateAllLeft = array => array.map(rotateLeft); 
const rotateAllRight = array => array.map(rotateRight); 

आपका सरणी अब तरह दिखेगा:

const rotateLeft  = (array, n) => array.slice(n).concat(array.slice(0, n)); 
const rotateRight = (array, n) => rotateLeft(array, -n); 

और कार्यों किसी भी दिशा में बढ़ती मात्रा द्वारा प्रत्येक subarray को घुमाने के लिए यह, लंबवत रूप से रेखांकित किए गए हैं:

var array = [ [1, 0, 0, 0, 0, 0, 0], 
       [1, 0, 0, 0, 1, 0, 0], 
       [1, 0, 1, 0, 0, 0, 0], 
       [1, 0, 0, 0, 0, 0, 0], 
       [0, 0, 0, 0, 0, 1, 0], 
       [0, 0, 0, 0, 0, 0, 0] 
      ] 

समस्या अब लोगों की लंबवत रेखाओं को खोजने के लिए कम हो गई है। ऐसा करने के लिए, यह सबसे आसान हो जाएगा पहली सरणी है, जो आप कर सकते हैं स्थानांतरित करने के लिए के साथ:

const transpose = array => array[0].map((_, i) => array.map(row => row[i])); 

अब हम एक छोटे से समारोह जो एक सरणी लेता है और एक अन्य सरणी जिनके मान "रनों की लंबाई हैं रिटर्न लिखेंगे "एक विशेष मूल्य की:

const run = (array, val, cnt = 0) => array.map(elt => cnt = elt === val ? ++cnt : 0; 

[1, 1, 1, 1, 0, 0] इसके लिए [1, 2, 3, 4, 0, 0] लौट आते हैं। 4 उस बिंदु तक चार 1 मानों का एक रन इंगित करता है। अब आप कर सकते हैं

const hasRunOf = (array, val, n) => run(array, val).some(len => len >= n); 
const hasAnyRunOf = (array, val, n) => array.some(subarray => hasRunOf(subarray, val, n)); 

:

एक सारिणी में कुछ न्यूनतम लंबाई की एक विशेष मूल्य का एक रन या किसी subarray में कुछ न्यूनतम लंबाई की एक विशेष मूल्य का एक रन के लिए परीक्षण करने के लिए थोड़ा कार्यों लिखें

hasAnyRunOf(transpose(rotateAllLeft(array)), 1, 4) || 
    hasAnyRunOf(transpose(rotateAllRight(array)), 1, 4)   

साथ चार या उससे अधिक लोगों के किसी भी रन की उपस्थिति के लिए परीक्षण के बारे में हुई कहां विकर्ण रन एक व्यायाम के रूप में छोड़ दिया जाता है जानकारी कैप्चरिंग।

Answer 3

वैसे यह मेरे जैसा सबसे अच्छा है।यह प्रत्येक तत्व को n आकार समूह में केवल एक बार गिना जाता है। दूसरे शब्दों में एक समूह में मौजूद तत्व एक दूसरे में मौजूद नहीं हो सकता है।

यह सूचकांक शुरू करने के x और y इष्टतम संख्या का उपयोग करने का एक गेम है और उसके बाद प्रत्येक तत्व के सूचकांक को विकर्ण रूप से आगे और पीछे रहने के लिए उस प्रारंभिक बिंदु से गणना करता है। जाहिर है, हमें दाएं x और y सूचकांक पर शुरू करना और रोकना चाहिए जहां हम n तत्वों की संख्या को विकर्ण रूप से पा सकते हैं। n बढ़ने के बाद यह काम की मात्रा को कम कर देगा। इसलिए प्रति समूह 12 तत्वों वाला एक 100x100 सरणी प्रति समूह 4 तत्वों के साथ एक से अधिक तेज़ी से गणना की जाएगी।

function getDiagonals(a,rep){ 
 
    var xLen = a[0].length,   // x dimension 
 
     yLen = a.length,   // y dimension 
 
     xMin = rep-1,    // minimum x value to start testing from 
 
     xMax = xLen-rep,   // maximum x value to test up until 
 
     yMin = rep-1,    // minimum y value to start testing from 
 
     yMax = yLen-rep,   // maximum y value to test up until 
 
    minDim = Math.min(yLen,xLen), // the smallest dimensison 
 
    quadros = [],     // the resutls array 
 
    temp1 = [],     // utility array #1 
 
    temp2 = [],     // utility array #2 
 
    item1,      // current element on the slash test 
 
    item2;      // current element on the backslash test 
 

 
    for (var x = xMin; x < xLen; x++){ 
 
    \t for(var y = 0; y <= x && y < minDim; y++){ 
 
    \t item1 = a[y][x-y];   // slash test on x axis 
 
    \t item2 = a[yLen-1-y][x-y]; // backslash test on x axis 
 
    \t temp1[0] === item1 ? temp1.length < rep-1 ? temp1.push(item1) 
 
    \t            : (temp1.push(item1), quadros.push(temp1), temp1 = []) 
 
    \t      : temp1 = [item1]; 
 
    \t temp2[0] === item2 ? temp2.length < rep-1 ? temp2.push(item2) 
 
    \t            : (temp2.push(item2), quadros.push(temp2), temp2 = []) 
 
    \t      : temp2 = [item2]; 
 
    \t } 
 
    \t temp1 = []; 
 
    \t temp2 = []; 
 
    } 
 
    for (var y = 1; y <= yMax; y++){ 
 
    \t for(var x = xLen-1; x >= xLen - minDim + y; x--){ 
 
    \t item1 = a[y-x+xLen-1][x]; // slash test on y axis 
 
    \t item2 = a[yLen-y-xLen+x][x];// backslash test on y axis 
 
    \t temp1[0] === item1 ? temp1.length < rep-1 ? temp1.push(item1) 
 
    \t            : (temp1.push(item1), quadros.push(temp1), temp1 = []) 
 
    \t      : temp1 = [item1]; 
 
    \t temp2[0] === item2 ? temp2.length < rep-1 ? temp2.push(item2) 
 
    \t            : (temp2.push(item2), quadros.push(temp2), temp2 = []) 
 
    \t      : temp2 = [item2]; 
 
    \t } 
 
    \t temp1 = []; 
 
    \t temp2 = []; 
 
    } 
 
    return quadros; 
 
} 
 

 
var arr = [ [1, 0, 0, 0, 0, 0, 0], 
 
      [0, 1, 0, 0, 0, 1, 0], 
 
      [0, 0, 1, 0, 1, 0, 0], 
 
      [0, 0, 0, 1, 0, 0, 0], 
 
      [0, 0, 1, 0, 0, 0, 0], 
 
      [0, 0, 0, 0, 0, 0, 0] 
 
      ], 
 
    brr = Array(100).fill().map(_ => Array(100).fill().map(e => ~~(Math.random()*2))), 
 
result = getDiagonals(arr,4); 
 
console.log(JSON.stringify(result),result.length); 
 
result = getDiagonals(brr,12); 
 
console.log(JSON.stringify(result),result.length);