20

_{यह चुनौती इस ऐप से प्रेरित है । परीक्षण मामलों को उस ऐप से उधार लिया जाता है।}

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

आपको एक स्क्वेयर इनपुट ग्रिड दिया जाएगा, जिसमें n-by-n आयाम हैं जहां 9 <= n <= 12 है । इस ग्रिड को एन क्षेत्रों में विभाजित किया जाएगा , जहां प्रत्येक क्षेत्र की कोशिकाओं की एक विशिष्ट पहचानकर्ता होती है (मैं यहां पाठ में अल से निम्न केस पत्रों का उपयोग करूंगा , लेकिन आप जो चाहें, जैसे उदाहरण पूर्णांक 1-12 चुन सकते हैं ) ।

इनपुट इस तरह दिख सकता है (वैकल्पिक इनपुट प्रारूप):

aabbbbbcc
adddbbbcc
adeeecccc
adddefgcc
hhhdifggg
hdddifffg
hhhiifffg
hihiifffg
iiiiiiggg

या, कल्पना करना आसान है:

चुनौती:

आप इस नियम के अनुसार इस पार्क में 2 * n पेड़ लगा सकते हैं:

प्रति स्तंभ में ठीक 2 पेड़ और प्रति पंक्ति 2 पेड़ होंगे
सभी क्षेत्रों में ठीक 2 पेड़ होंगे।
कोई भी पेड़ दूसरे पेड़ के पास, लंबवत, क्षैतिज या तिरछे नहीं हो सकता है

ऊपर दिए गए लेआउट का समाधान है:

नोट: प्रत्येक पहेली का केवल एक ही समाधान है

अतिरिक्त नियम:

इनपुट और आउटपुट प्रारूप वैकल्पिक हैं
- उदाहरण के लिए आउटपुट सूचकांकों की एक सूची हो सकती है, 1/0 के साथ एक ग्रिड यह दर्शाता है कि क्या उस स्थिति में कोई पेड़ है, या इनपुट का एक संशोधित संस्करण है जहां पेड़ संकेतित हैं
निष्पादन का समय निर्धारक होना चाहिए
कार्यक्रम को इसाॅक के कंप्यूटर पर 1 मिनट समाप्त करना होगा
- चश्मा: 4 सीपीयू, i5-4300U CPU @ 1.9 GHz, 7.5G RAM।
यदि आपका कार्यक्रम एक मिनट में दो सबसे बड़े परीक्षण मामले को हल नहीं कर सकता है, तो दूसरा सबसे बड़ा समय ( n = 11 ) आपका स्कोर होगा। आप सबसे बड़े मामले को हल करने वाले समाधान के खिलाफ हार जाएंगे।

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

अगर इस परीक्षा के मामलों को फिट करने के लिए सबमिशन को अनुकूलित किया गया लगता है तो मैं इस सूची को संपादित कर सकता हूं।

12-बाई -12 :

--- Input ---
aaaaabccccdd
aaaaabccccdd
aaaaabbbbddd
eeeafffgbghh
eeaafffgbghh
eefffffggghh
eeefijffghhh
iieiijjjjkhh
iiiiijjjjkhk
lljjjjjjjkkk
llllllkkkkkk
llllllkkkkkk
--- Solution ---
aaaaabcccCdD
aaaaaBcCccdd
aAaaabbbbdDd
eeeaffFgBghh
eeAaFffgbghh
eefffffGgGhh
EeefijffghhH
iiEiIjjjjkhh
IiiiijjjjkHk
lljJjJjjjkkk
lLllllkkKkkk
lllLllKkkkkk

11-बाय -11 :

--- Input ---
aaaaaaabbcc
adddabbbbcc
edddbbbbbbc
eddddbbbbbb
effffggghhh
effffgghhii
eefffjjhhii
eeeejjjhhii
eeejjjjkiii
jjjjjjkkiii
jjjjjkkkiii
--- Solution ---
aaAaaaabbCc
adddAbBbbcc
eDddbbbbbbC
eddDdBbbbbb
effffggGhHh
eFfffGghhii
eefFfjjhHii
EeeejjjhhiI
eeEjjjjKiii
JjjjJjkkiii
jjjjjkKkIii

10-दर-10

--- Input ---
aaaaabccdd
aeaabbbccd
aeaabfbgcd
eeeaafggcd
eeeaafghcd
eeeiifghcd
ieiiigghcd
iiijighhcd
jjjjighhcd
jjjggghhdd
--- Solution ---
aaAaabccdD
aeaaBbBccd
aEaabfbgcD
eeeaaFgGcd
eEeAafghcd
eeeiiFghCd
IeiIigghcd
iiijigHhCd
JjJjighhcd
jjjgGghHdd

9-दर-9

--- Input ---
aabbbbbcc
adddbbbcc
adeeecccc
adddefgcc
hhhdifggg
hdddifffg
hhhiifffg
hihiifffg
iiiiiiggg
--- Solution ---
aAbBbbbcc
adddbbBcC
adEeEcccc
AdddefgCc
hhhDiFggg
hDddifffG
hhhiIfFfg
HiHiifffg
iiiiiIgGg
--- Input ---
aaabbbccc
aaaabbccc
aaaddbcce
ffddddcce
ffffddeee
fgffdheee
fggfhhhee
iggggheee
iiigggggg
--- Solution ---
aaAbBbccc
AaaabbcCc
aaaDdBcce
fFddddcCe
fffFdDeee
fGffdheeE
fggfHhHee
IggggheeE
iiIgggGgg

grid game fastest-code

— स्टीवी ग्रिफिन
स्रोत

"इनपुट और आउटपुट प्रारूप वैकल्पिक हैं, लेकिन समान होना चाहिए" इसका क्या मतलब है? क्या मैं क्षेत्रों की आउटपुट के बारे में परवाह किए बिना पेड़ों और गैर पेड़ों के लिए 1s और 0s वाली सूचियों का उत्पादन नहीं कर सकता हूं?

— घातक

@ निर्धारित करें, संपादित करें। मुझे लगता है कि सूचकांकों या ग्रिड की सूची 1/0 के साथ आउटपुट करना जैसा कि आप सुझाव देते हैं कि यह एक अच्छा विचार है।

— स्टू ग्रिफिन

1

सूचना (यदि मैं सही तरीके से गणना करता हूं): 24 पेड़ लगाने के लिए 3647375398569086976 विन्यास हैं। 12 * 12 ग्रिड केवल (1) को संतुष्ट करते हैं:, There shall be exactly 2 trees per column, and 2 trees per rowतो एक जानवर बल शायद असंभव है।

— user202729

" मुझे कोई बड़ी समस्या नहीं होनी चाहिए" : मुझे व्यक्तिगत रूप से लगता है कि यह है। मेरा वर्तमान कार्यान्वयन ~ 150 मी और 5 में 3 में से एक में पहले परीक्षण के मामले को हल करता है, लेकिन किसी भी उचित समय में पिछले एक (जो 'केवल' 11x11 ') को हल करने में विफल रहता है। यह शायद कुछ और अधिक आक्रामक आगे छंटाई की आवश्यकता होगी - और इसलिए अतिरिक्त कोड की एक महत्वपूर्ण राशि - 1 मिनट के भीतर पूरा करने के लिए।

— अरनुलद

1

@ अर्नुलड, मैंने अधिकतम 11 को बदला क्योंकि यह सबसे बड़ा परीक्षण मामला है। आप अपना समाधान पोस्ट कर सकते हैं (एक मान्य, प्रतिस्पर्धी सबमिशन के रूप में), लेकिन यह नहीं जीतेगा यदि कोई ऐसा समाधान पोस्ट करता है जो सभी टेस्ट मामलों को हल करता है, कोड लंबाई की परवाह किए बिना। मेला?

— स्टेवि ग्रिफिन

7

जावास्क्रिप्ट (ईएस 6), 271 बाइट्स

वर्णों के सरणियों के एक सरणी के रूप में इनपुट लेता है। प्रत्येक पंक्ति पर पेड़ों की स्थिति का वर्णन करते हुए बिटमास्क (पूर्णांक) की एक सरणी देता है, जहां सबसे कम महत्वपूर्ण बिट बाईं स्थिति है।

f=(a,p=0,r=[S=y=0],w=a.length)=>a.some((R,y)=>a.some((_,x)=>r[y]>>x&1&&(o[k=R[x]]=-~o[k])>2),o=[])?0:y<w?[...Array(1<<w)].some((_,n)=>(k=n^(x=n&-n))<=x*2|k&-k^k|n&(p|p/2|p*2)||r.some((A,i)=>r.some((B,j)=>A&B&n&&i<y&j<i))?0:(w=r[y],f(a,r[y++]=n,r),r[--y]=w,S))&&S:S=[...r]

प्रारूपित और टिप्पणी की गई

f = (                                           // given:
  a,                                            //   - a = input matrix
  p = 0,                                        //   - p = previous bitmask
  r = [                                         //   - r = array of tree bitmasks
        S = y = 0 ],                            //   - S = solution / y = current row
  w = a.length                                  //   - w = width of matrix
) =>                                            //
  a.some((R, y) => a.some((_, x) =>             // if there's at least one area with more
    r[y] >> x & 1 && (o[k = R[x]] = -~o[k]) > 2 // than two trees:
  ), o = []) ?                                  //
    0                                           //   abort right away
  :                                             // else:
    y < w ?                                     //   if we haven't reached the last row:
      [...Array(1 << w)].some((_, n) =>         //     for each possible bitmask n:
        (k = n ^ (x = n & -n)) <= x * 2 |       //       if the bitmask does not consist of
        k & - k ^ k |                           //       exactly two non-consecutive bits,
        n & (p | p / 2 | p * 2) ||              //       or is colliding with the previous
        r.some((A, i) => r.some((B, j) =>       //       bitmask, or generates more than two
          A & B & n && i < y & j < i            //       trees per column:
        )) ?                                    //
          0                                     //         yield 0
        :                                       //       else:
          (                                     //
            w = r[y],                           //         save the previous bitmask
            f(a, r[y++] = n, r),                //         recursive call with the new one
            r[--y] = w,                         //         restore the previous bitmask
            S                                   //         yield S
          )                                     //
      ) && S                                    //     end of some(): return false or S
    :                                           //   else:
      S = [...r]                                //     this is a solution: save a copy in S

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

इस स्निपेट में अधिक पठनीय प्रारूप में परिणाम प्रदर्शित करने के लिए एक अतिरिक्त फ़ंक्शन शामिल है। अंतिम परीक्षण मामले को हल करना बहुत धीमा है।

अपेक्षित रनटाइम: ~ 5 सेकंड।

कोड स्निपेट दिखाएं

f=(a,p=0,r=[S=y=0],w=a.length)=>a.some((R,y)=>a.some((_,x)=>r[y]>>x&1&&(o[k=R[x]]=-~o[k])>2),o=[])?0:y<w?[...Array(1<<w)].some((_,n)=>(k=n^(x=n&-n))<=x*2|k&-k^k|n&(p|p/2|p*2)||r.some((A,i)=>r.some((B,j)=>A&B&n&&i<y&j<i))?0:(w=r[y],f(a,r[y++]=n,r),r[--y]=w,S))&&S:S=[...r]

format = (a, w) => a.map(n => [...('0'.repeat(w) + n.toString(2)).slice(-w)].reverse().join('')).join('\n')

console.log(format(f([
  [..."aabbbbbcc"],
  [..."adddbbbcc"],
  [..."adeeecccc"],
  [..."adddefgcc"],
  [..."hhhdifggg"],
  [..."hdddifffg"],
  [..."hhhiifffg"],
  [..."hihiifffg"],
  [..."iiiiiiggg"]
]), 9));

console.log(format(f([
  [..."aaabbbccc"],
  [..."aaaabbccc"],
  [..."aaaddbcce"],
  [..."ffddddcce"],
  [..."ffffddeee"],
  [..."fgffdheee"],
  [..."fggfhhhee"],
  [..."iggggheee"],
  [..."iiigggggg"]
]), 9));

console.log(format(f([
  [..."aaaaabccdd"],
  [..."aeaabbbccd"],
  [..."aeaabfbgcd"],
  [..."eeeaafggcd"],
  [..."eeeaafghcd"],
  [..."eeeiifghcd"],
  [..."ieiiigghcd"],
  [..."iiijighhcd"],
  [..."jjjjighhcd"],
  [..."jjjggghhdd"]
]), 10));

स्निपेट का विस्तार करें

— Arnauld
स्रोत

ओपी का नोट: यह सबमिशन तब किया गया था जब चुनौती एक कोड-गोल्फ चुनौती थी। इसलिए यह पूरी तरह से मान्य है, भले ही यह मौजूदा विजेता मानदंड के लिए अनुकूलित नहीं है!

— स्टू ग्रिफिन

टाइमिंग: 11x11 पर एक मिनट से अधिक समय लगता है।

— ईसैक

हम अचार में हैं, शायद आप मदद कर सकें। क्या आप nontrivial बड़ा पहेली उदाहरण उत्पन्न करने का कोई तरीका सोच सकते हैं?

— ईसैक

7

सी, आधिकारिक समय: 12x12 के लिए 5 मी

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <omp.h>

#define valT char
#define posT int

#ifndef _OPENMP
#  warning Building without OpenMP support
#  define omp_get_max_threads() 1
#  define omp_get_num_threads() 1
#  define omp_get_thread_num() 0
#endif

#define MIN_THREADED_SIZE 11

static void complete(posT n, valT *workspace) {
    const posT s = n * 3 + 2;

    const valT *regions = workspace;
    valT *output = &workspace[n*2+1];

    for(posT y = 0; y < n; ++ y) {
        for(posT x = 0; x < n; ++ x) {
//          putchar(output[y*s+x] ? '*' : '-');
            putchar(regions[y*s+x] + (output[y*s+x] ? 'A' : 'a'));
        }
        putchar('\n');
    }

    _Exit(0);
}

static void solveB(const posT n, valT *workspace, valT *pops, const posT y) {
    const posT s = n * 3 + 2;

    const valT *regions = workspace;
    const valT *remaining = &workspace[n];
    valT *output = &workspace[n*2+1];

    for(posT r = 0; r < n; ++ r) {
        if(pops[r] + remaining[r] < 2) {
            return;
        }
    }

    for(posT t1 = 0; t1 < n - 2; ++ t1) {
        posT r1 = regions[t1];
        if(output[t1+1-s]) {
            t1 += 2;
            continue;
        }
        if(output[t1-s]) {
            ++ t1;
            continue;
        }
        if((pops[t1+n] | pops[r1]) & 2 || output[t1-1-s]) {
            continue;
        }
        output[t1] = 1;
        ++ pops[t1+n];
        ++ pops[r1];
        for(posT t2 = t1 + 2; t2 < n; ++ t2) {
            posT r2 = regions[t2];
            if(output[t2+1-s]) {
                t2 += 2;
                continue;
            }
            if(output[t2-s]) {
                ++ t2;
                continue;
            }
            if((pops[t2+n] | pops[r2]) & 2 || output[t2-1-s]) {
                continue;
            }
            output[t2] = 1;
            ++ pops[t2+n];
            ++ pops[r2];
            if(y == 0) {
                complete(n, &workspace[-s*(n-1)]);
            }
            solveB(n, &workspace[s], pops, y - 1);
            output[t2] = 0;
            -- pops[t2+n];
            -- pops[r2];
        }
        output[t1] = 0;
        -- pops[t1+n];
        -- pops[r1];
    }
}

static void solve(const posT n, valT *workspace) {
    const posT s = n * 3 + 2;

    valT *regions = workspace;
    valT *remaining = &workspace[n];
    valT *pops = &workspace[n*s];
//  memset(&remaining[n*s], 0, n * sizeof(valT));

    for(posT y = n; (y --) > 0;) {
        memcpy(&remaining[y*s], &remaining[(y+1)*s], n * sizeof(valT));
        for(posT x = 0; x < n; ++ x) {
            valT r = regions[y*s+x];
            valT *c = &remaining[y*s+r];
            valT *b = &pops[r*3];
            if(*c == 0) {
                *c = 1;
                b[0] = y - 1;
                b[1] = x - 1;
                b[2] = x + 1;
            } else if(x < b[1] || x > b[2] || y < b[0]) {
                *c = 2;
            } else {
                b[1] = b[1] > (x - 1) ? b[1] : (x - 1);
                b[2] = b[2] < (x + 1) ? b[2] : (x + 1);
            }
        }
//      memset(&output[y*s], 0, (n+1) * sizeof(valT));
    }
    memset(pops, 0, n * 2 * sizeof(valT));

    posT sz = (n + 1) * s + n * 3;
    if(n >= MIN_THREADED_SIZE) {
        for(posT i = 1; i < omp_get_max_threads(); ++ i) {
            memcpy(&workspace[i*sz], workspace, sz * sizeof(valT));
        }
    }

#pragma omp parallel for if (n >= MIN_THREADED_SIZE)
    for(posT t1 = 0; t1 < n - 2; ++ t1) {
        valT *workspace2 = &workspace[omp_get_thread_num()*sz];
        valT *regions = workspace2;
        valT *output = &workspace2[n*2+1];
        valT *pops = &workspace2[n*s];

        posT r1 = regions[t1];
        output[t1] = pops[t1+n] = pops[r1] = 1;
        for(posT t2 = t1 + 2; t2 < n; ++ t2) {
            posT r2 = regions[t2];
            output[t2] = pops[t2+n] = 1;
            ++ pops[r2];
            solveB(n, &regions[s], pops, n - 2);
            output[t2] = pops[t2+n] = 0;
            -- pops[r2];
        }
        output[t1] = pops[t1+n] = pops[r1] = 0;
    }
}

int main(int argc, const char *const *argv) {
    if(argc < 2) {
        fprintf(stderr, "Usage: %s 'grid-here'\n", argv[0]);
        return 1;
    }

    const char *input = argv[1];
    const posT n = strchr(input, '\n') - input;
    const posT s = n * 3 + 2;

    posT sz = (n + 1) * s + n * 3;
    posT threads = (n >= MIN_THREADED_SIZE) ? omp_get_max_threads() : 1;
    valT *workspace = (valT*) calloc(sz * threads, sizeof(valT));
    valT *regions = workspace;

    for(posT y = 0; y < n; ++ y) {
        for(posT x = 0; x < n; ++ x) {
            regions[y*s+x] = input[y*(n+1)+x] - 'a';
        }
    }

    solve(n, workspace);

    fprintf(stderr, "Failed to solve grid\n");
    return 1;
}

जीसीसी 7 के साथ -O3और -fopenmpझंडे का उपयोग करके संकलित किया गया । OpenMP स्थापित के साथ GCC के किसी भी संस्करण पर समान परिणाम होना चाहिए।

gcc-7 Trees.c -O3 -fopenmp -o Trees

इनपुट और आउटपुट प्रारूप प्रश्न में दिए गए हैं।

मेरी मशीन पर यह 12x12 उदाहरण के लिए ~~0.009s~~ ~~0.008s~~ 0.005s, और ~~0.022s~~ ~~0.020 लेता है~~ सभी उदाहरणों को चलाने के लिए 0.019s। बेंचमार्क मशीन पर, isaacg कोड के मूल (गैर-थ्रेडेड) संस्करण का उपयोग करके 12x12 उदाहरण के लिए 5ms की रिपोर्ट करता है।

उपयोग:

./Trees 'aaabbbccc
aaaabbccc
aaaddbcce
ffddddcce
ffffddeee
fgffdheee
fggfhhhee
iggggheee
iiigggggg'

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

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

दूसरा अद्यतन उपलब्ध प्रोसेसर (ओपनएमपी का उपयोग करके) के पार के सबसे बाहरी लूप को रैखिक गति को बढ़ावा देता है। यह केवल n> = 11 के लिए सक्षम है, क्योंकि स्प्रेडिंग थ्रेड्स का ओवरहेड छोटे ग्रिड के लिए लाभ को बढ़ा देता है।

— डेव
स्रोत

आधिकारिक समय: 12x12 के लिए 5 मी। यदि कोई और पास हो जाता है, तो हमें बड़े परीक्षण मामलों की आवश्यकता होगी।

— इसहाक

हम अचार में हैं, शायद आप मदद कर सकें। क्या आप nontrivial बड़ा पहेली उदाहरण उत्पन्न करने का कोई तरीका सोच सकते हैं?

— ईसैक

@ आइसाकग उदाहरण से स्पष्ट है, ऐसा लगता है कि मूल ग्रिड पहले पेड़ लगाकर बनाए गए थे (उस उदाहरण में मामूली बदलाव के साथ एक नाइट पैटर्न में, लेकिन मुझे लगता है कि प्रति पंक्ति और स्तंभ 2 पेड़ों के साथ कोई भी पैटर्न काम करेगा) फिर फिटिंग क्षेत्रों के आसपास उन्हें ताकि प्रत्येक क्षेत्र में 2 पेड़ हों। ऐसा लगता है कि मानव के लिए मनमाने ढंग से बड़े ग्रिड का पालन करने के लिए एक सरल पर्याप्त तरीका होना चाहिए।

— डेव

वास्तव में, फिर से देखना, यह मामूली बदलाव के साथ एक नाइट पैटर्न नहीं है, लेकिन एक रैपिंग पैटर्न है जहां प्रत्येक पेड़ पिछले से ऑफसेट (1,2) है। एक बार जब आपके पास एक पैटर्न होता है, तो आप कम संरचित समाधान बनाने के लिए पंक्तियों और स्तंभों की अनुमति दे सकते हैं, जब तक कि यह आसन्न पेड़ों को नहीं छोड़ता है।

— डेव

5

जावा (ओपनजेडके 8) , आधिकारिक समय: 12x12 पर 1.2s

संपादित करें: अब कोड गोल्फ नहीं है

import java.util.*;

// Callable method, takes an int[][] and modifies it
static void f(int[][] areas){
    List<List<BitSet>> areaBitSets = new ArrayList<>();
    List<List<BitSet>> areaTreeBitSets = new ArrayList<>();
    for(int i = 0; i < areas.length; i++){
        areaBitSets.add(new ArrayList<BitSet>());
        areaTreeBitSets.add(new ArrayList<BitSet>());
    }

    // Add a bitset to our list representing each possible square, grouped by area
    for(int i=0; i < areas.length; i++){
        for(int j=0; j < areas.length; j++){
            BitSet b = new BitSet();
            b.set(i*areas.length + j);
            areaBitSets.get(areas[i][j]).add(b);
        }
    }

    // Fold each set onto itself so each area bitset has two trees
    for(int i=0; i < areas.length; i++){
        for(int j=0; j<areaBitSets.get(i).size()-1; j++){
            for(int k=j+1; k <areaBitSets.get(i).size(); k++){
                if(canFoldTogether(areaBitSets.get(i).get(j),areaBitSets.get(i).get(k), areas.length)){
                    BitSet b = (BitSet)areaBitSets.get(i).get(j).clone();
                    b.or(areaBitSets.get(i).get(k));
                    areaTreeBitSets.get(i).add(b);
                }
            }
        }
    }

    // Starting with area 0 add each area one at a time doing Cartesian products
    Queue<BitSet> currentPossibilities = new LinkedList<>();
    Queue<BitSet> futurePossibilities = new LinkedList<>();
    currentPossibilities.addAll(areaTreeBitSets.get(0));

    for(int i=1; i < areaTreeBitSets.size(); i++){
        while(!currentPossibilities.isEmpty()){
            BitSet b= (BitSet)currentPossibilities.poll().clone();

            for(BitSet c: areaTreeBitSets.get(i)){
                if(canFoldTogether(b,c,areas.length)){
                    BitSet d=(BitSet)b.clone();
                    d.or(c);
                    futurePossibilities.add(d);
                }
            }
        }
        currentPossibilities.addAll(futurePossibilities);
        futurePossibilities.clear();
    }

    // Get final output and modify the array
    BitSet b = currentPossibilities.poll();
    for(int i=0; i<areas.length*areas.length; i++){
        areas[i/areas.length][i%areas.length] = b.get(i)?1:0;
    }
}

// Helper method which determines whether combining two bitsets
// will still produce a valid output
static boolean canFoldTogether(BitSet a, BitSet b, int size){

    // See if there are trees too close to each other
    int c=-1;
    while((c=a.nextSetBit(c+1))>=0){
        int d=-1;
        while((d=b.nextSetBit(d+1))>=0){
            int r1=c/size;
            int r2=d/size;
            int c1=c%size;
            int c2=d%size;

            int rDifference = r1>r2 ? r1-r2 : r2-r1;
            int cDifference = c1>c2 ? c1-c2 : c2-c1;
            if(rDifference<2 && cDifference<2)
                return false;
        }
    }

    // Check for row and column cardinality
    BitSet f,g;
    for(int i=0; i<size; i++){
        f = new BitSet();
        f.set(i*size,(i+1)*size);
        g=(BitSet)f.clone();
        f.and(a);
        g.and(b);
        f.or(g);
        if(f.cardinality()>2){
            return false;
        }


        f=new BitSet();
        for(int j = 0; j<size; j++){
            f.set(j*size+i);
        }
        g=(BitSet)f.clone();
        f.and(a);
        g.and(b);
        f.or(g);
        if(f.cardinality()>2){
            return false;
        }
    }

    return true;
}

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

TIO लिंक 12x12 टेस्ट केस के लिए है। TIO रन टाइम के लिए 2.429s रिपोर्ट करता है।

इनपुट के रूप में पूर्णांकों की एक सरणी लेता है और पेड़ों के लिए 1s और गैर-पेड़ों के लिए 0s समाहित करने के लिए सरणी को संशोधित करता है।

यह सभी टेस्टकेस के लिए चलता है। सबसे बड़ा टेस्टकेस एक सेकंड से भी कम समय में मेरी मशीन पर चलता है, हालांकि मेरे पास एक बहुत शक्तिशाली मशीन है

12x12 के लिए टेस्ट कोड, दूसरों के लिए संशोधित कर सकते हैं

public static void main(String[] args){
    int[][] test = {{0,  0,  0,  0,  0,  1,  2,  2,  2,  2,  3,  3}, 
            {0,  0,  0,  0,  0,  1,  2,  2,  2,  2,  3,  3}, 
            {0,  0,  0,  0,  0,  1,  1,  1,  1,  3,  3,  3}, 
            {4,  4,  4,  0,  5,  5,  5,  6,  1,  6,  7,  7}, 
            {4,  4,  0,  0,  5,  5,  5,  6,  1,  6,  7,  7}, 
            {4,  4,  5,  5,  5,  5,  5,  6,  6,  6,  7,  7}, 
            {4,  4,  4,  5,  8,  9,  5,  5,  6,  7,  7,  7}, 
            {8,  8,  4,  8,  8,  9,  9,  9,  9,  10,  7,  7}, 
            {8,  8,  8,  8,  8,  9,  9,  9,  9,  10,  7,  10}, 
            {11,  11,  9,  9,  9,  9,  9,  9,  9,  10,  10,  10}, 
            {11,  11,  11,  11,  11,  11,  10,  10,  10,  10,  10,  10}, 
            {11,  11,  11,  11,  11,  11,  10,  10,  10,  10,  10,  10}};

    long l = System.currentTimeMillis();
    f(test);
    System.out.println("12x12: " + (System.currentTimeMillis() - l) + "ms");

    for(int[] t : test){
        System.out.println(Arrays.toString(t));
    }

}

मेरी मशीन पर इसका उत्पादन करता है:

12x12: 822ms
[0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1]
[0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0]
[0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0]
[0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0]
[0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0]
[0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0]
[1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1]
[0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0]
[1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0]
[0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0]
[0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0]
[0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0]

— PunPun1000
स्रोत

ओपी का नोट: यह सबमिशन तब किया गया था जब चुनौती एक कोड-गोल्फ चुनौती थी। यह पूरी तरह से वैध है, भले ही यह (केवल) वर्तमान विजेता मानदंड के लिए अनुकूलित नहीं है!

— स्टू ग्रिफिन

@StewieGriffin टिप्पणी के लिए धन्यवाद। जब मुझे मौका मिलता है तो मैं इसे साफ करने के लिए काम करूंगा क्योंकि यह अब कोड गोल्फ नहीं है और यह देखने के लिए कि क्या मैं इसे कुछ गति के लिए अनुकूलित कर सकता हूं

— PunPun1000

आधिकारिक समय: 12x12 पर 1.2 सेकंड।

— इसहाक

हम अचार में हैं, शायद आप मदद कर सकें। क्या आप nontrivial बड़ा पहेली उदाहरण उत्पन्न करने का कोई तरीका सोच सकते हैं?

— ईसैक

4

क्लिंगो , 12 × 12, 116 बाइट्स के लिए for 7 एमएस

{t(X,Y):c(X,Y,Z)}=2:-Z=1..n.
:-X=1..n,{t(X,1..n)}!=2.
:-Y=1..n,{t(1..n,Y)}!=2.
:-t(X,Y),t(X+1,Y;X+1,Y+1;X,Y+1;X-1,Y+1).

(Newlines वैकल्पिक हैं और गिने नहीं जाते हैं।)

ग्रिड आकार clingo plant.lp - -c n=<n>कहां <n>है, इसके साथ चलाएँ । इनपुट प्रारूप 1 ( , ≤ , वैकल्पिक व्हाट्सएप द्वारा अलग किए गए c(X,Y,Z).प्रत्येक सेल ( X, Y) के लिए स्टेटमेंट की एक सूची है । आउटपुट में प्रत्येक पेड़ के लिए ( , ) शामिल हैं।ZXYZnt(X,Y)XY

समय बहुत ही व्यर्थ है क्योंकि यह मूल रूप से सिर्फ स्टार्टअप समय है, इसलिए इसे बड़े परीक्षण मामलों के लिए एक वोट मानें।

डेमो

$ clingo plant.lp -c n=12 - <<EOF
> c(1,1,1). c(2,1,1). c(3,1,1). c(4,1,1). c(5,1,1). c(6,1,2). c(7,1,3). c(8,1,3). c(9,1,3). c(10,1,3). c(11,1,4). c(12,1,4).
> c(1,2,1). c(2,2,1). c(3,2,1). c(4,2,1). c(5,2,1). c(6,2,2). c(7,2,3). c(8,2,3). c(9,2,3). c(10,2,3). c(11,2,4). c(12,2,4).
> c(1,3,1). c(2,3,1). c(3,3,1). c(4,3,1). c(5,3,1). c(6,3,2). c(7,3,2). c(8,3,2). c(9,3,2). c(10,3,4). c(11,3,4). c(12,3,4).
> c(1,4,5). c(2,4,5). c(3,4,5). c(4,4,1). c(5,4,6). c(6,4,6). c(7,4,6). c(8,4,7). c(9,4,2). c(10,4,7). c(11,4,8). c(12,4,8).
> c(1,5,5). c(2,5,5). c(3,5,1). c(4,5,1). c(5,5,6). c(6,5,6). c(7,5,6). c(8,5,7). c(9,5,2). c(10,5,7). c(11,5,8). c(12,5,8).
> c(1,6,5). c(2,6,5). c(3,6,6). c(4,6,6). c(5,6,6). c(6,6,6). c(7,6,6). c(8,6,7). c(9,6,7). c(10,6,7). c(11,6,8). c(12,6,8).
> c(1,7,5). c(2,7,5). c(3,7,5). c(4,7,6). c(5,7,9). c(6,7,10). c(7,7,6). c(8,7,6). c(9,7,7). c(10,7,8). c(11,7,8). c(12,7,8).
> c(1,8,9). c(2,8,9). c(3,8,5). c(4,8,9). c(5,8,9). c(6,8,10). c(7,8,10). c(8,8,10). c(9,8,10). c(10,8,11). c(11,8,8). c(12,8,8).
> c(1,9,9). c(2,9,9). c(3,9,9). c(4,9,9). c(5,9,9). c(6,9,10). c(7,9,10). c(8,9,10). c(9,9,10). c(10,9,11). c(11,9,8). c(12,9,11).
> c(1,10,12). c(2,10,12). c(3,10,10). c(4,10,10). c(5,10,10). c(6,10,10). c(7,10,10). c(8,10,10). c(9,10,10). c(10,10,11). c(11,10,11). c(12,10,11).
> c(1,11,12). c(2,11,12). c(3,11,12). c(4,11,12). c(5,11,12). c(6,11,12). c(7,11,11). c(8,11,11). c(9,11,11). c(10,11,11). c(11,11,11). c(12,11,11).
> c(1,12,12). c(2,12,12). c(3,12,12). c(4,12,12). c(5,12,12). c(6,12,12). c(7,12,11). c(8,12,11). c(9,12,11). c(10,12,11). c(11,12,11). c(12,12,11).
> EOF
clingo version 5.1.0
Reading from plant.lp ...
Solving...
Answer: 1
c(1,1,1) c(2,1,1) c(3,1,1) c(4,1,1) c(5,1,1) c(6,1,2) c(7,1,3) c(8,1,3) c(9,1,3) c(10,1,3) c(11,1,4) c(12,1,4) c(1,2,1) c(2,2,1) c(3,2,1) c(4,2,1) c(5,2,1) c(6,2,2) c(7,2,3) c(8,2,3) c(9,2,3) c(10,2,3) c(11,2,4) c(12,2,4) c(1,3,1) c(2,3,1) c(3,3,1) c(4,3,1) c(5,3,1) c(6,3,2) c(7,3,2) c(8,3,2) c(9,3,2) c(10,3,4) c(11,3,4) c(12,3,4) c(1,4,5) c(2,4,5) c(3,4,5) c(4,4,1) c(5,4,6) c(6,4,6) c(7,4,6) c(8,4,7) c(9,4,2) c(10,4,7) c(11,4,8) c(12,4,8) c(1,5,5) c(2,5,5) c(3,5,1) c(4,5,1) c(5,5,6) c(6,5,6) c(7,5,6) c(8,5,7) c(9,5,2) c(10,5,7) c(11,5,8) c(12,5,8) c(1,6,5) c(2,6,5) c(3,6,6) c(4,6,6) c(5,6,6) c(6,6,6) c(7,6,6) c(8,6,7) c(9,6,7) c(10,6,7) c(11,6,8) c(12,6,8) c(1,7,5) c(2,7,5) c(3,7,5) c(4,7,6) c(5,7,9) c(6,7,10) c(7,7,6) c(8,7,6) c(9,7,7) c(10,7,8) c(11,7,8) c(12,7,8) c(1,8,9) c(2,8,9) c(3,8,5) c(4,8,9) c(5,8,9) c(6,8,10) c(7,8,10) c(8,8,10) c(9,8,10) c(10,8,11) c(11,8,8) c(12,8,8) c(1,9,9) c(2,9,9) c(3,9,9) c(4,9,9) c(5,9,9) c(6,9,10) c(7,9,10) c(8,9,10) c(9,9,10) c(10,9,11) c(11,9,8) c(12,9,11) c(1,10,12) c(2,10,12) c(3,10,10) c(4,10,10) c(5,10,10) c(6,10,10) c(7,10,10) c(8,10,10) c(9,10,10) c(10,10,11) c(11,10,11) c(12,10,11) c(1,11,12) c(2,11,12) c(3,11,12) c(4,11,12) c(5,11,12) c(6,11,12) c(7,11,11) c(8,11,11) c(9,11,11) c(10,11,11) c(11,11,11) c(12,11,11) c(1,12,12) c(2,12,12) c(3,12,12) c(4,12,12) c(5,12,12) c(6,12,12) c(7,12,11) c(8,12,11) c(9,12,11) c(10,12,11) c(11,12,11) c(12,12,11) t(1,7) t(1,9) t(2,3) t(2,11) t(3,5) t(3,8) t(4,10) t(4,12) t(5,5) t(5,8) t(6,2) t(6,10) t(7,4) t(7,12) t(8,2) t(8,6) t(9,4) t(9,11) t(10,1) t(10,6) t(11,3) t(11,9) t(12,1) t(12,7)
SATISFIABLE

Models       : 1+
Calls        : 1
Time         : 0.009s (Solving: 0.00s 1st Model: 0.00s Unsat: 0.00s)
CPU Time     : 0.000s

इससे निपटने के लिए इनपुट / आउटपुट प्रारूप को आसान बनाने के लिए, यहां से और चुनौती में दिए गए प्रारूप में बदलने के लिए पायथन प्रोग्राम हैं।

इनपुट

import sys
print(' '.join("c({},{},{}).".format(x + 1, y + 1, ord(cell) - ord('a') + 1) for y, row in enumerate(sys.stdin.read().splitlines()) for x, cell in enumerate(row)))

उत्पादन

import re
import sys
for line in sys.stdin:
    c = {(int(x), int(y)): int(z) for x, y, z in re.findall(r'\bc\((\d+),(\d+),(\d+)\)', line)}
    if c:
        t = {(int(x), int(y)) for x, y in re.findall(r'\bt\((\d+),(\d+)\)', line)}
        n, n = max(c)
        for y in range(1, n + 1):
            print(''.join(chr(ord('aA'[(x, y) in t]) + c[x, y] - 1) for x in range(1, n + 1)))
        print()

— एंडर्स कसीगोर
स्रोत

लगता है कि हम एक बड़े परीक्षण मामले की जरूरत है। Btw, आप इस सवाल का गोल्फ संस्करण जीत रहे होंगे - बस 2s को 1s में बदलने की आवश्यकता है।

— डेव

आधिकारिक समय 12x12 पर 18 मिलीसेकंड है, मैं माफी मांगता हूं। 1 वर्ण टाइपो, यह संक्षिप्त रूप में परेशानी है।

— ईसैक

हम अचार में हैं, शायद आप मदद कर सकें। क्या आप nontrivial बड़ा पहेली उदाहरण उत्पन्न करने का कोई तरीका सोच सकते हैं?

— ईसैक

एक पार्क में पेड़ लगाओ - जितनी जल्दी हो सके!

चुनौती:

अतिरिक्त नियम:

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

जावास्क्रिप्ट (ईएस 6), 271 बाइट्स

प्रारूपित और टिप्पणी की गई

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

सी, आधिकारिक समय: 12x12 के लिए 5 मी

जावा (ओपनजेडके 8) , आधिकारिक समय: 12x12 पर 1.2s

क्लिंगो , 12 × 12, 116 बाइट्स के लिए for 7 एमएस

डेमो

इनपुट

उत्पादन