आयत कवर

मान लीजिए कि आपके पास बिट्स का एक मैट्रिक्स है, उदाहरण के लिए निम्नलिखित।

1 1 0 0 0 1 1 0
1 1 1 1 0 1 1 1
0 1 1 1 0 1 1 1
1 1 0 1 1 1 1 0
1 1 0 1 1 1 0 1

हम इस मैट्रिक्स के लिए एक आयत कवर खोजना चाहेंगे । यह मैट्रिक्स का आयताकार सबसेट है, जिसमें कोई 0s नहीं होता है, लेकिन सभी 1s होते हैं। उपसमूह को असंतुष्ट होने की आवश्यकता नहीं है। यहाँ उपरोक्त मैट्रिक्स के लिए एक आयत कवर का एक उदाहरण है।

+----+         +----+
|1  1| 0  0  0 |1  1| 0
|    |         |    |
|  +-|-----+   |    |+-+
|1 |1| 1  1| 0 |1  1||1|
+----+     |   |    || |
   |       |   |    || |
 0 |1  1  1| 0 |1  1||1|
   +-------+   |    |+-+
+----+   +-----|-+  |
|1  1| 0 |1  1 |1| 1| 0
|    |   |     +----+
|    |   |       |   +-+
|1  1| 0 |1  1  1| 0 |1|
+----+   +-------+   +-+

इस आवरण में आयतों की संख्या 7 है।

काम

आपका इनपुट बिट्स का एक आयताकार मैट्रिक्स है, जो किसी भी उचित प्रारूप में लिया गया है। आप मान सकते हैं कि इसमें कम से कम 1 शामिल है। आपका आउटपुट मैट्रिक्स के आयत कवर में आयतों की न्यूनतम संख्या है।

सबसे कम बाइट गिनती जीतती है। मानक कोड-गोल्फ नियम लागू होते हैं।

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

[[1]] -> 1
[[1,1]] -> 1
[[1],[1]] -> 1
[[1,0,1]] -> 2
[[1,0],[0,0]] -> 1
[[1,0],[0,1]] -> 2
[[1,0],[1,1]] -> 2
[[1,1,1],[1,0,1]] -> 3
[[0,1,0],[1,1,1],[0,1,0]] -> 2
[[1,1,1],[1,0,1],[1,1,1]] -> 4
[[1,1,0],[1,1,1],[0,1,1]] -> 2
[[1,0,1,0],[1,1,1,1],[1,0,1,0]] -> 3
[[1,1,1,0],[1,0,1,0],[1,1,1,1],[0,0,1,0]] -> 4
[[1,1,1,0],[1,0,1,0],[1,1,1,1],[0,0,1,1]] -> 5
[[1,1,1,0],[1,0,1,0],[1,1,1,1],[0,1,1,1]] -> 4
[[1,1,0,0],[1,1,1,0],[0,1,1,1],[0,0,1,1]] -> 3
[[0,1,0,0],[0,1,1,1],[1,1,1,0],[0,0,1,0]] -> 4
[[0,0,1,0,0],[0,1,1,1,0],[1,1,1,1,1],[0,1,1,1,0],[0,0,1,0,0]] -> 3

code-golf matrix optimization

— Zgarb
स्रोत

क्या यह कर्णघट मानचित्र से प्रेरित है ?

1

@PirateBay अधिक nondeterministic संचार जटिलता द्वारा ।

— ज़र्गब

@ ThePirateBay के-मैप के लिए सभी आयतों में दो-दो आयाम होने चाहिए।

— शुक्राणु

@Sparr। हां, मैं यह जानता हूं। मैंने सिर्फ यह पूछा कि क्या वह इस चुनौती की प्रेरणा थी।

1

लालची दृष्टिकोण के लिए उपयोगी परीक्षण मामला [[0,1,0,0],[0,1,1,1],[1,1,1,0],[0,0,1,0]]

— :,

6

पायथन 2 , 318 315 271 बाइट्स

Mr.Xcoder, ovs और Jonathan Frech ने बहुत से बाइट्स को बचाया

p=range
def f(x,i=0,j=-1):z=len(x[0]);j+=1;i+=j/z;j%=z;return i<len(x)and(x[i][j]and-~min([f([[v,v[:j]+[2]*(r-j)+v[r:]][i<=y<=e]for y,v in enumerate(x)],i,j)for e in p(i,len(x))for r in p(j+1,z+1)if all(all(k[j:r])for k in x[i:e+1])]+[f(x,i,j)-1]*(x[i][j]>1))or f(x,i,j))

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

— हलवार्ड वुल्फ
स्रोत

4

जेली , 25 24 बाइट्स

FJ‘ṁ×⁸ẆZ€Ẇ€ẎŒPFQP$$ÐṀL€Ṃ

इसे ऑनलाइन आज़माएं! एक विशिष्ट गोल्फ-जटिलता समाधान, बड़े परीक्षण मामलों से भी परेशान नहीं होता है, वे समय समाप्त कर देंगे (सभी संभावित आयतों के बिजली सेट का निरीक्षण किया जाता है *)

कैसे?

सभी संभव आयतों को बनाता है जिन्हें बनाया जा सकता है। उन आयतों का पावर-सेट लेता है और केवल उन सेटों को रखने के लिए उनका निरीक्षण करता है जिनमें दोनों में कोई शून्य नहीं होता है और उनमें से प्रत्येक में कम से कम एक बार होता है।

"उन सेटों को प्राप्त करने के लिए, जिनमें दोनों शून्य नहीं होते हैं और उनमें से प्रत्येक में कम से कम एक बार शामिल होता है" भाग पहले कोड को एक से अधिक अलग पूर्णांकों के एक सेट के लिए जोड़ता है, शून्य को छोड़कर, क्योंकि वे ऐसा हो जाते हैं " अद्वितीय मूल्यों के उत्पाद की अधिकतम सीमा का पता लगाना "।

FJ‘ṁ×⁸ẆZ€Ẇ€ẎŒPFQP$$ÐṀL€Ṃ - Link: list of lists of ones and zeros, M
F                        - flatten M into a single list
 J                       - range of length = [1,2,3,...,len(flattened(M))]
  ‘                      - increment       = [2,3,4,...,len(flattened(M))+1]
   ṁ                     - mould like M - reshapes it just like M again
     ⁸                   - chain's left argument, M
    ×                    - multiply (vectorises) - unique integers > 1 at M's 1s and 0s at M's 0s
      Ẇ                  - non-empty sublists - i.e. row selections
       Z€                - transpose €ach
         Ẇ€              - non-empty sublists of €ach - column selections of those
           Ẏ             - tighten - a flat list of all of the rectangles
            ŒP           - power-set - all possible selections of rectangles
                   ÐṀ    - filter keep those for which the following is maximal:
                  $      -   last two links as a monad:
              F          -     flatten
                 $       -     last two links as a monad:
               Q         -       de-duplicate
                P        -       product
                     L€  - length of €ach - # of rectangles used by each full-cover
                       Ṃ - minimum

_{* M मैट्रिक्स के द्वारा n के लिए यह तरीका है (n, m) = 2 ^ (T (n) × T (m)) , इसलिए ... तरीके (3,2) = 2 ^ ((3 + 2 + 1) × (2 + 1)) = 2 ^ 18 = 262,144 (TIO लिंक) तरीके (3,3) = 2 ^ ((3 + 2 + 1) × (3 + 2 + 1)) = 2 ^ 36 = 68,719,476,736 तरीके (3,4) = 2 ^ ((3 + 2 + 1) × (4 + 3 + 2 + 1)) = 2 ^ 60 = 1,152,921,504,606,846,976 तरीके (5,5) = 2 ^ 225 = = 5.4e + 67 (सबसे बड़ा परीक्षण मामला) तरीके (8,5) = 2 ^ 540 ~ = 3.6e + 162 (उदाहरण)}

— जोनाथन एलन
स्रोत

FJṁ×⁸ẆZ€Ẇ€ẎŒPFQS$$ÐṀL€Ṃ-1 के लिए काम करेंगे ? आरएन परीक्षण करने का समय नहीं।

— २१:४४ बजे

नहीं, क्योंकि एक कवर जो उपेक्षित (केवल) जिस पर किसी ने जोर दिया, 1उसके पास एक वैध कवर के रूप में एक ही उत्पाद होगा (उदाहरण के लिए आठ को पांच उदाहरण आधा मोड़ दें और यह (सिद्धांत 6रूप में ) वापस आ जाएगा क्योंकि यह शीर्ष को कवर करने के लिए उपेक्षा करेगा। सेल सेल और इसे वैध मानते हैं।)

— जोनाथन एलन

... और भी आसान - परीक्षण के मामले के बजाय [[1,0],[0,1]]वापस आ जाएगी । 12

— जोनाथन एलन

1

जावास्क्रिप्ट, 434 बाइट्स

कोड:

for(_='),d=...-1||(,Ad<=a,u[o][n]=d,    =0,(e,r,C,m))&&()=>.map((h((A,n,on<e|o<r|n>C|o>mf=u=>(q(s=(e>C[e,C]=[C,e]r>m[r,m]=[m,r]lk=1,k&=!!A)kl|=&1,=2k&lh=f=>uA,$ABf(B,$))))(($,Bae=r=C=m=,d=to-Bt=n$&n>$e   C=nn+1~ee   C=ttn-$t=oB&o>Br    m=oo+1~rr   m=tq+=sg=[],h((ca||g.push(c)gigb,j(p=1,q+=i<j&&s(b)q)';G=/[-]/.exec(_);)with(_.split(G))_=join(shift());eval(_)

Hexdump (अप्रमाणित वर्णों के कारण):

66 6F 72 28 5F 3D 27 29 2C 13 13 64 3D 12 2E 2E 2E 11 2D 31 10 7C 7C 28 0F 2C 41 0F 64 3C 3D 0E 61 2C 0C 75 5B 6F 5D 5B 6E 5D 0B 3D 64 2C 09 3D 30 2C 08 28 65 2C 72 2C 43 2C 6D 07 29 29 13 06 26 26 28 05 29 3D 3E 04 2E 6D 61 70 28 28 03 68 28 28 41 2C 6E 2C 6F 04 02 02 6E 3C 65 7C 6F 3C 72 7C 6E 3E 43 7C 6F 3E 6D 0F 01 66 3D 75 3D 3E 28 71 08 28 73 3D 07 04 28 65 3E 43 05 5B 65 2C 43 5D 3D 5B 43 2C 65 5D 13 72 3E 6D 05 5B 72 2C 6D 5D 3D 5B 6D 2C 72 5D 13 6C 08 6B 3D 31 2C 01 6B 26 3D 21 21 41 29 13 6B 05 01 6C 7C 3D 0B 26 31 2C 0B 3D 32 06 6B 26 6C 13 68 3D 66 3D 3E 75 03 41 2C 24 04 41 03 0C 42 04 66 28 0C 42 2C 24 29 29 29 29 28 28 0C 24 2C 42 04 61 10 0F 65 3D 72 3D 43 3D 6D 3D 10 2C 64 3D 74 08 02 6F 2D 42 0F 74 3D 6E 0E 24 26 6E 3E 24 05 65 09 43 3D 6E 10 12 6E 2B 31 06 7E 65 0F 65 09 43 3D 74 12 74 08 02 6E 2D 24 0F 74 3D 6F 0E 42 26 6F 3E 42 05 72 09 6D 3D 6F 10 12 6F 2B 31 06 7E 72 0F 72 09 6D 3D 74 13 71 2B 3D 73 07 06 67 3D 5B 5D 2C 68 28 28 0C 11 63 04 61 10 7C 7C 67 2E 70 75 73 68 28 63 29 13 67 03 0C 69 04 67 03 62 2C 6A 04 28 70 3D 31 2C 71 2B 3D 69 3C 6A 26 26 73 28 11 0C 11 62 29 06 71 29 27 3B 47 3D 2F 5B 01 2D 13 5D 2F 2E 65 78 65 63 28 5F 29 3B 29 77 69 74 68 28 5F 2E 73 70 6C 69 74 28 47 29 29 5F 3D 6A 6F 69 6E 28 73 68 69 66 74 28 29 29 3B 65 76 61 6C 28 5F 29

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

यह बहुत गोल्फ नहीं है, लेकिन कम से कम यह बहुत तेजी से काम करता है। सभी परीक्षण मामलों की गणना कुछ मिलीसेकंड में की जा सकती है।

Ungolfed

f=mat=>(
  iterate=f=>mat.map((A,x)=>A.map((a,y)=>f(a,y,x))),
  fill=(x1,y1,x2,y2)=>(
    x1>x2&&([x1,x2]=[x2,x1]),
    y1>y2&&([y1,y2]=[y2,y1]),
    isFilled=0,

    canBeFilled=1,
    iterate((A,X,Y)=>X<x1|Y<y1|X>x2|Y>y2||(
      canBeFilled&=!!A
    )),

    canBeFilled&&(
      iterate((A,X,Y)=>X<x1|Y<y1|X>x2|Y>y2||(
        isFilled|=mat[Y][X]&1,
        mat[Y][X]=2
      ))
    ),

    canBeFilled&isFilled
  ),

  rectangles=0,

  iterate((a,x,y)=>a-1||(
    x1=y1=x2=y2=-1,

    start=end=0,
    iterate((A,X,Y)=>Y-y||(
      end=X,
      A||(
        start<=x&X>x&&(x1=start,x2=X-1),
        start=X+1
      )
    )),
    ~x1||(x1=start,x2=end),

    start=end=0,
    iterate((A,X,Y)=>X-x||(
      end=Y,
      A||(
        start<=y&Y>y&&(y1=start,y2=Y-1),
        start=Y+1
      )
    )),
    ~y1||(y1=start,y2=end),

    rectangles+=fill(x1,y1,x2,y2)
  )),


  ones=[],
  iterate((a,...c)=>a-1||ones.push(c)),
  ones.map((a,i)=>ones.map((b,j)=>(
    M=1,
    rectangles+=i<j&&fill(...a,...b)
  ))),

  rectangles
)

व्याख्या

यह समान एल्गोरिथ्म का उपयोग करता है जैसे कि कर्णघ मानचित्रों को हल करने के लिए। सबसे पहले यह कम से कम एक खोजने की कोशिश करता है 1जो ठीक एक गैर-एक्स्टेंसिबल आयत का हिस्सा हो सकता है। गैर-एक्स्टेंसिबल से मेरा मतलब है कि अगर हम इसे किसी भी दिशा में बढ़ाते हैं (ऊपर, बाएं, दाएं, नीचे) तो इसमें कम से कम एक 0(या मैट्रिक्स सीमा से परे) शामिल होगा। जब ऐसा 1पाया जाता है, तो सबसे बड़ी आयत ढूंढें जिसमें यह शामिल हो और 1उस आयत में सभी s को चिह्नित करें । तब तक दोहराएं जब तक कि कोई और गैर-ध्वजांकित 1s न हो जो इन स्थितियों को पूरा करता है।

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

न्यूनतम आयत कवर