एक ग्रिड में सबसे बड़ा वर्ग [बंद]

Question

चुनौती

इस तरह एक ग्रिड दिया,

  1 2 3 4 5 6 7 8
1 . . . . . . . .
2 . # . . . # . .
3 . . . . . . . .
4 . . . . . . . .
5 . . . . . . . .
6 . . # . . . . .
7 . . . . . . . .
8 . . . . . . . .

कोड का एक टुकड़ा लिखें जो सबसे बड़े वर्ग के आकार को निर्धारित कर सकता है जिसमें '#' शामिल नहीं है। (इस इनपुट का उत्तर 5x5 है क्योंकि नीचे दाईं ओर 5x5 ग्रिड संभव सबसे बड़ा वर्ग है)।

वर्ग में भुजाएँ x और y कुल्हाड़ियों के समानांतर होनी चाहिए।

कुछ छोटे विवरणों के रूप में: मूल ग्रिड हमेशा एक वर्ग होता है और इसकी साइड की लंबाई आपको दी जाती है। '#' प्रतीकों के निर्देशांक भी आपको दिए गए हैं।

इनपुट विवरण

पहली पंक्ति: एन (1 <= एन <= 1000), वर्ग ग्रिड की ओर की लंबाई, और टी (1 <= टी <= 10,000) '#' संकेतों की संख्या।

अगली टी लाइन्स: टी # के प्रत्येक में से निर्देशांक

परीक्षण के मामलों

इनपुट # 1:

8 3
2 2
2 6
6 3

परिणाम # 1: 5

================

इनपुट # 2:

8 4
1 1
1 8
8 1
8 8

परिणाम # 2: 6

================

इनपुट # 3:

5 1
3 3

परिणाम # 3: 2

यह सबसे तेज़-कोड समस्या है, इसलिए रेक्सटेस्टर कंपाइलर जीत पर सबसे तेज़ कोड का परीक्षण किया जाता है ।

मज़े करो!

Comments

संबंधित ।

— user202729

के लिए fastest-code1000x1000 हालांकि, बहुत छोटा है

— l4m2

लेकिन rextester जेली या Hexagony का समर्थन नहीं करता है।

— user202729

जैसा कि रेक्सटेस्टर सक्षम है, क्या मैं इसके बजाय ऑनलाइन कोशिश करने की सलाह दे सकता हूं ? इसमें कई और लँगुआ होते हैं, और सामुदायिक रूप से चलता है।

— ATaco

"सबसे तेज़ कोड जो कि रेक्सटेस्टर कम्पाइलर जीत पर परीक्षण किया गया है" - सबसे तेज़ किस इनपुट पर?

— नथनियल

Answer 1

Node.js

इनपुट (w, l) के रूप में लेता है , जहां w चौड़ाई है और l निर्देशांक की एक सरणी है [x, y] । (यदि इनपुट प्रारूप वास्तव में वर्णित के अनुसार सख्त है तो इसे बदला जा सकता है।) O (w be) में काम करता है ।

f = (w, l) => {
  var x, y,
      W = w * w,
      a = new Uint16Array(W),
      best = 0;

  l.forEach(([x, y]) => a[(y - 1) * w + x - 1] = 1);

  for(y = w; y < W; y += w) {
    for(x = y + 1; x < y + w; x++) {
      if(a[x]) {
        a[x] = 0;
      }
      else {
        best = Math.max(
          best,
          a[x] = Math.min(a[x - 1], a[x - w], a[x - w - 1]) + 1
        );
      }
    }
  }

  return best;
}

इसे ऑनलाइन आज़माएं!

Comments

console.log(f( 1000, [...Array(10000)].map(_=>[Math.random()*1000+1|0,Math.random()*1000+1|0]) )); लागत 114ms, हालांकि यह भाषा की कम दक्षता हो सकती है

— l4m2

यह JIT संकलन के बाद f () के अंदर 8ms की तरह है । (लेकिन हाँ ... जवाब उस तरह से नहीं बनाए जा रहे हैं।)

— अरनौलड

मुझे संदेह है कि ओपी एक और अधिक उद्देश्यपूर्ण मानदंड जोड़ देगा ...

— user202729

Answer 2

सी (जीसीसी)

यहां कोई फैंसी एल्गोरिदम नहीं है, बस लगभग bruteforce ... लेकिन हे, सी तेज है।

इनपुट: स्टड से इनपुट लेता है ।

आउटपुट: आउटपुट को stdout में लिखता है ।

#include <stdio.h>
#include <stdint.h>

int main(void) {
    uint_fast16_t n, t, i, j, h, x, y, flag, biggest = 0;
    scanf("%hi %hi", &n, &t);
    uint_fast8_t m[n][n];
    for (uint_fast16_t c = 0; c < t; ++c) {
        scanf("%hi %hi", &i, &j);
        m[i-1][j-1] = '#';
    }
    for (i = 0; i < n - 1; ++i) {
        for (j = 0; j < n - 1; ++j) {
            flag = 1;
            for (h = 1; flag && i + h < n + 1 && j + h < n + 1; ++h) {
                for (y = i; flag && y < i + h; ++y) {
                    for (x = j; flag && x < j + h; ++x) {
                        if (m[y][x] == '#') flag = 0;
                    }
                }
                if (flag && h > biggest) biggest = h;
            }
        }
    }
    printf("%d", biggest);
}

इसे ऑनलाइन आज़माएं!