20

_{এই চ্যালেঞ্জটি এই অ্যাপ্লিকেশন দ্বারা অনুপ্রাণিত । পরীক্ষার কেসগুলি সেই অ্যাপ থেকে নেওয়া হয়।}

এটি একটি দ্রুততম কোড চ্যালেঞ্জ, যেখানে সর্বনিম্ন সময়ের মধ্যে বৃহত্তম পরীক্ষার কেস সমাধান করার উদ্দেশ্য। কিছু ছোট পরীক্ষার কেস সরবরাহ করা হয়েছে, যাতে লোকেরা তাদের অ্যালগোরিদমগুলি দ্রুত পরীক্ষা করতে পারে।

আপনাকে n-by-n মাত্রা যেখানে 9 <= n <= 12 , একটি স্কোয়ার ইনপুট গ্রিড দেওয়া হবে । এই গ্রিডটি n অঞ্চলে বিভক্ত হবে , যেখানে প্রতিটি অঞ্চলের কোষের একটি অনন্য শনাক্তকারী রয়েছে (আমি এখানে লেখায় আল থেকে ছোট ছোট অক্ষর ব্যবহার করব , তবে আপনি যা পছন্দ পছন্দ করতে পারেন, উদাহরণস্বরূপ পূর্ণসংখ্যার 1-12 ) ।

ইনপুটটি দেখতে দেখতে ((চ্ছিক ইনপুট ফর্ম্যাট):

aabbbbbcc
adddbbbcc
adeeecccc
adddefgcc
hhhdifggg
hdddifffg
hhhiifffg
hihiifffg
iiiiiiggg

বা, কল্পনা করা সহজ:

চ্যালেঞ্জ:

আপনি স্থাপন করতে হয় 2 * এন নিম্নলিখিত নিয়ম অনুযায়ী, এই পার্কে গাছ:

সেখানে ঠিক হইবে 2 কলাম প্রতি গাছ, এবং 2 সারি প্রতি গাছ
সমস্ত অঞ্চলে ঠিক 2 টি গাছ থাকবে।
কোনও গাছ উলম্বভাবে, অনুভূমিকভাবে বা ত্রিভুজভাবে অন্য গাছের সংলগ্ন হতে পারে না

উপরের লেআউটটির সমাধানটি হ'ল:

দ্রষ্টব্য: প্রতিটি ধাঁধাটির একটিমাত্র সমাধান রয়েছে

অতিরিক্ত নিয়ম:

ইনপুট এবং আউটপুট ফর্ম্যাটগুলি alচ্ছিক
- উদাহরণস্বরূপ আউটপুট সূচকগুলির তালিকা হতে পারে, 1/0 সমেত একটি গ্রিড নির্দেশ করে যে সেই অবস্থানে কোনও গাছ আছে কিনা, বা গাছগুলি নির্দেশিত ইনপুটটির পরিবর্তিত সংস্করণ রয়েছে
ফাঁসির সময়টি অবশ্যই নির্দোষ হতে হবে
প্রোগ্রামটি অবশ্যই @ ইস্যাকের কম্পিউটারে 1 মিনিটের সাথে শেষ করতে হবে
- স্পেস: 4 সিপিইউ, i5-4300U সিপিইউ @ 1.9 গিগাহার্টজ, র‌্যামের 7.5 জি।
যদি আপনার প্রোগ্রামটি এক মিনিটের মধ্যে দুটি বৃহত্তম টেস্ট কেস সমাধান করতে না পারে তবে দ্বিতীয় বৃহত্তম ( এন = 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

— স্টিও গ্রিফিন
সূত্র

"ইনপুট এবং আউটপুট ফর্ম্যাটগুলি alচ্ছিক, তবে একই হওয়া উচিত" এর অর্থ কী? অঞ্চলগুলি আউটপুট দেওয়ার বিষয়ে চিন্তা না করে আমি গাছ এবং নন গাছের জন্য 1s এবং 0 এর তালিকাভুক্ত তালিকা আউটপুট করতে পারি না?

— ফ্যাটালাইজ করুন

@ ফ্যাটালাইজ, সম্পাদিত। আপনার পরামর্শ অনুসারে 1/0 সহ সূচকের একটি তালিকা বা গ্রিড আউটপুট আউট করা ভাল ধারণা is

— স্টিভি গ্রিফিন

1

তথ্য (যদি আমি সঠিকভাবে গণনা করি): 12 * 12 গ্রিডে কেবলমাত্র (1) সন্তুষ্ট করে 24 টি গাছ লাগানোর জন্য 3647375398569086976 কনফিগারেশন রয়েছে: There shall be exactly 2 trees per column, and 2 trees per rowসুতরাং একটি প্রাণশক্তি সম্ভবত অসম্ভব।

— ব্যবহারকারী 202729

"একটি বড় সমস্যা হওয়া উচিত নয়" : আমি ব্যক্তিগতভাবে মনে করি যে এটি। আমার বর্তমান বাস্তবায়ন test 150ms এ প্রথম পরীক্ষার কেস এবং 5-এর মধ্যে তৃতীয়টি সমাধান করে তবে কোনও যুক্তিসঙ্গত সময়ে শেষটি (যা 'কেবল' 11x11) সমাধান করতে ব্যর্থ হয়। এটি সম্ভবত আরও অনেক বেশি আক্রমণাত্মক ফরোয়ার্ড ছাঁটাই প্রয়োজন হবে - এবং তাই অতিরিক্ত কোডের উল্লেখযোগ্য পরিমাণে - 1 মিনিটের মধ্যে শেষ করতে।

— আর্নল্ড

1

@ আর্নল্ড, এটি সবচেয়ে বড় পরীক্ষার ক্ষেত্রে যেহেতু আমি সর্বোচ্চ 11 এ পরিবর্তন করেছি। আপনি আপনার সমাধান পোস্ট করতে পারেন (বৈধ, প্রতিযোগিতামূলক জমা হিসাবে) তবে কোডের দৈর্ঘ্য নির্বিশেষে কেউ যদি কোনও টেস্ট কেস সমাধান করে এমন কোনও সমাধান পোস্ট করে তবে তা জিতবে না। ফেয়ার?

— স্টিভি গ্রিফিন

7

জাভাস্ক্রিপ্ট (ES6), 271 বাইট

অক্ষরের অ্যারের অ্যারে হিসাবে ইনপুট নেয়। প্রতিটি সারিতে গাছের অবস্থান বর্ণনা করে বিটমাস্কের একটি পূর্ণসংখ্যা (পূর্ণসংখ্যা) প্রদান করে, যেখানে সর্বনিম্ন উল্লেখযোগ্য বিটটি বামতম অবস্থান position

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
সূত্র

ওপির দ্রষ্টব্য: এই জমা দেওয়া যখন চ্যালেঞ্জটি কোড-গল্ফ চ্যালেঞ্জ ছিল made এটি বর্তমানে পুরোপুরি বৈধ, যদিও এটি বর্তমান বিজয়ী মানদণ্ডের জন্য অনুকূল নয়!

— স্টিভি গ্রিফিন

সময়: 11x11 এ এক মিনিট সময় নেয়।

— isaacg

আমরা একটি আচারে আছি, সম্ভবত আপনি সাহায্য করতে পারেন। অনর্থক বৃহত্তর ধাঁধা দৃষ্টান্ত উত্পন্ন করার কোনও উপায় আপনি কী ভাবতে পারেন?

— isaacg

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পতাকাগুলি ব্যবহার করে সংকলিত । ওপেনএমপি ইনস্টল থাকা জিসিসির যে কোনও সংস্করণে একই ফলাফল থাকতে হবে।

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

ইনপুট এবং আউটপুট ফর্ম্যাট প্রশ্নে দেওয়া আছে।

আমার মেশিনে এই নেয় ~~0.009s~~ ~~0.008s~~ 12x12 উদাহরণস্বরূপ 0.005s এবং ~~0.022s~~ ~~0.020s~~ সব উদাহরণ চালানোর জন্য 0.019s। বেঞ্চমার্ক মেশিনে, আইএসএএজি কোডটির মূল (নন-থ্রেডড) সংস্করণ ব্যবহার করে 12x12 উদাহরণের জন্য 5 মিমি রিপোর্ট করে।

ব্যবহার:

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

একসাথে এক সারিতে কাজ করা কেবল একটি সাধারণ ব্রুট-ফোর্স সলভার। অসম্ভব পরিস্থিতিতে তাড়াতাড়ি স্বীকৃতি দিয়ে এটি একটি ভাল গতিতে চলবে (যেমন কোনও অঞ্চল কোষ অবশিষ্ট নেই, তবে অঞ্চলে 2 টিরও কম গাছ রয়েছে)।

প্রথম আপডেটটি সম্পর্কিত ডেটা মেমরির সাথে একত্রে রাখার মাধ্যমে ক্যাশে হিটগুলিকে উন্নত করে এবং সম্ভাব্য-গাছ-অবশিষ্ট-ইন-সেগমেন্টের গণনাগুলি সামান্য চৌকস করে তোলে (এখন গাছগুলি সংলগ্ন হতে পারে না তার জন্য অ্যাকাউন্ট) accounts এটি বাইরেরতম লুপটিও বের করে যাতে অ্যালগরিদমের সবচেয়ে উষ্ণতম অংশে কম বিশেষ ক্ষেত্রে প্রয়োজন হয়।

দ্বিতীয় আপডেটটি বহিরাগত লুপকে সমান্তরালভাবে উপলব্ধ প্রসেসরের (ওপেনএমপি ব্যবহার করে) সমান্তরালভাবে চালিত করে, একটি রৈখিক গতি বৃদ্ধি দেয়। এটি কেবলমাত্র n> = 11 এর জন্যই সক্ষম, যেহেতু স্পাডিং থ্রেডের ওভারহেডটি ছোট গ্রিডের সুবিধার চেয়ে বেশি।

— ডেভ
সূত্র

অফিসিয়াল সময়: 12x12 এর জন্য 5 এস এম। অন্য কেউ যদি কাছাকাছি আসে, আমাদের আরও বড় কেসের ক্ষেত্রে প্রয়োজন।

— isaacg

আমরা একটি আচারে আছি, সম্ভবত আপনি সাহায্য করতে পারেন। অনর্থক বৃহত্তর ধাঁধা দৃষ্টান্ত উত্পন্ন করার কোনও উপায় আপনি কী ভাবতে পারেন?

— isaacg

@ আইস্যাকগ ওয়েল ইলাস্ট্রেটেড উদাহরণ থেকে মনে হয়, মূল গ্রিডগুলি প্রথমে গাছ লাগিয়ে তৈরি করা হয়েছিল (উদাহরণে ছোট্ট পরিবর্তন সহ একটি নাইট প্যাটার্নে, তবে আমি অনুমান করি যে সারি ও কলামে 2 টি গাছের সাথে কোনও প্যাটার্ন কাজ করবে) তারপরে আশেপাশের ফিটিং অঞ্চলগুলি তাদের যাতে প্রতিটি অঞ্চলে 2 টি গাছ থাকে। মনে হয় এটি একটি সাধারণ যথেষ্ট পরিমাণ পদ্ধতি হওয়া উচিত যথেচ্ছ বৃহত গ্রিডগুলির জন্য অনুসরণ করা।

— ডেভ

প্রকৃতপক্ষে, আবার তাকান, এটি ছোটখাটো পরিবর্তনগুলি সহ একটি নাইট প্যাটার্ন নয়, তবে একটি মোড়ানোর ধরণ যেখানে প্রতিটি গাছ পূর্ববর্তী থেকে অফসেট হয় (1,2)। আপনার প্যাটার্নটি একবার হয়ে গেলে, আপনি যতক্ষণ না গাছগুলি সংলগ্ন না রাখেন ততক্ষণ কম কাঠামোগত সমাধান তৈরি করতে সারি এবং কলামগুলিকে অনুমতি দিতে পারেন।

— ডেভ

5

জাভা ( ওপেনজেডিকে 8) , অফিসিয়াল সময়: 12x12-তে 1.2

সম্পাদনা: আর কোড গল্ফ নেই

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;
}

এটি অনলাইন চেষ্টা করুন!

টিআইও লিঙ্কটি 12x12 পরীক্ষার ক্ষেত্রে। টিআইও রান সময়ের জন্য ২.৪২৯ এর রিপোর্ট করেছে।

ইনপুট হিসাবে পূর্ণসংখ্যার একটি অ্যারে নেয় এবং গাছের জন্য 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
সূত্র

ওপির দ্রষ্টব্য: এই জমা দেওয়া যখন চ্যালেঞ্জটি কোড-গল্ফ চ্যালেঞ্জ ছিল made এটি তাই পুরোপুরি বৈধ, যদিও এটি বর্তমান বিজয়ী মানদণ্ডের জন্য (কেবল) অনুকূলিত নয়!

— স্টিভি গ্রিফিন

@ স্টেভিগ্রিফিন মন্তব্যের জন্য ধন্যবাদ। আমি যখন সুযোগ পাব তখন আমি এটি পরিষ্কার করার কাজ করব কারণ এটি এখন আর কোনও কোড গল্ফ নয় এবং আমি এটি কিছু গতির জন্য অনুকূল করতে পারি কিনা তা দেখুন

— PunPun1000

অফিসিয়াল সময়: 12x12 এ 1.2 সেকেন্ড।

— isaacg

আমরা একটি আচারে আছি, সম্ভবত আপনি সাহায্য করতে পারেন। অনর্থক বৃহত্তর ধাঁধা দৃষ্টান্ত উত্পন্ন করার কোনও উপায় আপনি কী ভাবতে পারেন?

— isaacg

4

ক্লিঙ্গো , 12 × 12, 116 বাইটের জন্য 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).

(নিউলাইনগুলি alচ্ছিক এবং গণনা করা হয় না))

গ্রিডের আকার clingo plant.lp - -c n=<n>যেখানে <n>রয়েছে তার সাথে চালান । ইনপুট ফর্ম্যাট একটি তালিকা রয়েছে c(X,Y,Z).(প্রতিটি কক্ষের জন্য বিবৃতি X, Y) রঙ্গিন Z, সঙ্গে 1 ≤ X, Y, Z≤ n, ঐচ্ছিক হোয়াইটস্পেস দ্বারা পৃথক। আউটপুট t(X,Y)প্রতিটি গাছের জন্য ( X, Y) এ অন্তর্ভুক্ত ।

সময়টি মূলত নিখরচায় সময়টি অর্থহীন, সুতরাং বৃহত্তর পরীক্ষার ক্ষেত্রে এটি একটি ভোট বিবেচনা করুন।

ডেমো

$ 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()

— অ্যান্ডারস ক্যাসরগ
সূত্র

দেখে মনে হচ্ছে আমাদের আরও বড় কেসের কেস দরকার। বিটিডব্লিউ, আপনি এই প্রশ্নের গল্ফ সংস্করণ জিতে যাবেন - কেবলমাত্র 2s এর 1s তে পরিবর্তিত হওয়া দরকার।

— ডেভ

12x12 এ অফিসিয়াল সময়কাল 18 মিলিসেকেন্ড, আমি ক্ষমা চাইছি। 1 টি অক্ষর টাইপ, সংক্ষেপে এটাই সমস্যা।

— isaacg

আমরা একটি আচারে আছি, সম্ভবত আপনি সাহায্য করতে পারেন। অনর্থক বৃহত্তর ধাঁধা দৃষ্টান্ত উত্পন্ন করার কোনও উপায় আপনি কী ভাবতে পারেন?

— isaacg

একটি পার্কে গাছ লাগান - আপনি যতটা দ্রুত পারেন!

চ্যালেঞ্জ:

অতিরিক্ত নিয়ম:

পরীক্ষার কেস:

জাভাস্ক্রিপ্ট (ES6), 271 বাইট

ফর্ম্যাট এবং মন্তব্য

পরীক্ষার মামলা

সি, অফিসিয়াল সময়: 12x12 এর জন্য 5 এস এম

জাভা ( ওপেনজেডিকে 8) , অফিসিয়াল সময়: 12x12-তে 1.2

ক্লিঙ্গো , 12 × 12, 116 বাইটের জন্য 7 ডলার

ডেমো

ইনপুট

আউটপুট