पोलिस्ट्रिप की गिनती

Question

पॉलीस्ट्रिप्स निम्नलिखित नियमों के अनुरूप पॉलीओमीनो का एक सबसेट हैं:

• प्रत्येक टुकड़े में 1 या अधिक कोशिकाएँ होती हैं
• किसी भी सेल में दो से अधिक पड़ोसी नहीं हो सकते
• कोशिकाओं में छेद नहीं होना चाहिए

जब किसी का कठोर रूपान्तरण (अनुवाद, परिक्रमण, परावर्तन या ग्लाइड परावर्तन) या किसी दूसरे के टुकड़े (जिसे ऊपर उठाया जा सकता है और फ़्लिप किया जा सकता है) से मुक्त पॉलीओमीनो भिन्न होते हैं। एक मुक्त पॉलीमिनो को प्रतिबिंबित करने, अनुवाद करने, प्रतिबिंबित करने या ग्लाइड करने से इसका आकार ( विकिपीडिया ) नहीं बदलता है

उदाहरण के लिए, 30 मुक्त हेप्टास्ट्रिप्स (लंबाई 7 के साथ पॉलीस्ट्रिप्स) हैं। यहां वे सभी हैं, जिन्हें 14x15 ग्रिड में पैक किया गया है।

छवि क्रेडिट: मिरोस्लाव विचर

लक्ष्य

एक प्रोग्राम / फ़ंक्शन लिखिए जो nइनपुट के रूप में धनात्मक पूर्णांक लेता है और अलग-अलग फ्री- nपॉलीस्टीरिप्स को एन्यूमरेट करता है ।

• n = 1 -> 1 (एक वर्ग)

• n = 2 -> 1 (2 वर्गों से बना केवल एक संभव 2-पॉलीस्ट्रिप है)

• n = 3 -> 2 (एक पंक्ति में शामिल 3 वर्गों से बना है और दूसरा एक एल-आकार का है)

• n = 4 -> 3 (एक सीधा, एक L- आकार और एक Z-आकार)

• । । ।

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

n   polystrips

1   1
2   1
3   2
4   3
5   7
6   13
7   30
8   64
9   150
10  338
11  794
12  1836
13  4313
14  10067
15  23621

स्कोरिंग

यह कोड-गोल्फ है , इसलिए छोटा कोड बेहतर है। मैं एल्गोरिथ्म और कोड की विस्तृत व्याख्या की अत्यधिक सराहना करूंगा।

जे में आंशिक संदर्भ कार्यान्वयन

मैंने "वेक्टर" प्रारूप में प्रत्येक टुकड़े का वर्णन करने का निर्णय लिया और मुझे n-पॉलीस्ट्रिप टुकड़े का वर्णन करने के लिए केवल n-2 ब्लॉक की आवश्यकता है (केवल 1 2-पॉलीस्ट्रिप है और यह स्पष्ट रूप से वापस आ गया है)। ब्लॉक सापेक्ष दिशा का वर्णन करते हैं: 0 - कोई परिवर्तन नहीं; 1 - बाएं मुड़ें; 2 - दाएं मुड़ें। इससे कोई फर्क नहीं पड़ता कि कौन सी दिशा शुरू होगी लेकिन केवल यह इंगित करने के लिए कि अगली सेल कहां रखी जानी है। लगातार 0 s की कोई भी संख्या हो सकती है, लेकिन 1s और 2s हमेशा एकल होते हैं। यह कार्यान्वयन आंशिक है, क्योंकि यह छिद्रों के लिए जिम्मेदार नहीं है - n> 6 के लिए समाधान छेद के साथ टुकड़ों को भी गिनते हैं।

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

Comments

प्रासंगिक OEIS। (लेकिन छेद को बाहर नहीं करता है।)

— मार्टिन एंडर

@ मार्टिन एंडर धन्यवाद, मुझे यह नहीं पता था।

— गैलेन इवानोव

बस सुनिश्चित करने के लिए, मुझे लगता है कि यदि आप केंद्र और एक कोने को छोड़कर एक 3x3 ग्रिड को भरते हैं जो एक छेद के रूप में भी गिना जाता है ( 101010आपके नमूना अंकन में)?

— टन हास्पेल

@ टॉन हास्पेल हां, बिल्कुल - यह एक छेद वाला एकमात्र हेप्टैस्ट्रिप टुकड़ा है।

— गालेन इवानोव

शायद गणित के लिए एक अच्छा सवाल। ईएस

— जोना

Answer 1

पायथन 3 , 480 433 406 364 309 299 295 बाइट्स

मेरे पीपीसीजी कैरियर (या नहीं?) को शुरू करने के लिए एक अच्छे बिंदु की तरह देखा गया।

def C(s):
 S,*a={''},0,1;n=d=r=1
 for c in s:d=c*d*1jor d;n+=d;a+=n,;r*=not{n}&S;x,*a=a;S|={x+t+u*1jfor t in A for u in A}
 return r
from itertools import*;A=-1,0,1;n,y=int(input())-2,0;x={*filter(C,product(*[A]*n))}
while x:s=x.pop();S=*(-u for u in s),;x-={s[::-1],S,S[::-1]}-{s};y+=1
print(y)

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

संपादन:

• Inlined Dऔर X, और कुछ golfable स्थानों पर एक छोटा सा बदलाव किया।
• लागू अधिक चाल, मुख्य रूप से सेट-संबंधित।
• कार्यक्रम के रूप में बदल गया, और मनमानी संख्या के बजाय जटिल संख्याओं का उपयोग करने के लिए बदल गया m। (कॉम्प्लेक्स नंबर वास्तव में एक मजबूत लेकिन अक्सर उपेक्षित गोल्फ की विशेषता है, एक और चुनौती के लिए xnor के समाधान से अनुकूलित )
• टुपल्स के लिए LFRस्ट्रिंग प्रतिनिधित्व को बदल दिया -1,0,1और बाइट कमी (!) की पागल राशि के लिए निष्पादन समय का बलिदान किया। अब समाधान सैद्धांतिक रूप से सही है लेकिन 15 के लिए परिणाम के उत्पादन से पहले टाइमआउट।
• जोनाथन फ्रेच के लिए एक-पंक्ति वाले लूप का धन्यवाद, फिर मुझे गणना के लिए बेहतर विकल्प मिला r। अंतिम रूप से 300 BYTES !!!
• आश्चर्यजनक 1jरूप से पार्सर (-2 बी) को भ्रमित किए बिना किसी और चीज से चिपक सकता है, और notइसमें बहुत कम पूर्वता (-2) है।

अप्रचलित संस्करण (480 बाइट्स):

def C(s):
 m=999;a=[0,1];n=d=1
 D={'F':{},'L':{1:m,m:-1,-1:-m,-m:1},'R':{1:-m,-m:-1,-1:m,m:1}}
 X=lambda x:{x+~m,x-m,x-m+1,x-1,x,x+1,x+m-1,x+m,x-~m}
 for c in s:
  d=D[c].get(d,d);n+=d;a+=n,
  if n in set().union(*map(X,a[:-3])):return 0
 return 1
def f(n):
 if n<3:return 1
 x={*'LF'}
 for _ in range(3,n):x={s+c for s in x for c in({*'LRF'}-{s[-1]})|{'F'}}
 y={*x}
 for s in x:
  if s in y:S=s.translate(str.maketrans('LR','RL'));y-={s[::-1],S,S[::-1]}-{s}
 return sum(map(C,y))

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

टिप्पणियों के साथ असंगठित समाधान:

t = str.maketrans('LR','RL')

# hole checking function
def check(s):
    m = 999   # (imaginary) board size enough to fit all generated polyominoes
    a = [0,1] # previous path
    n = 1     # current cell
    d = 1     # current direction
    # dict for direction change
    D = {'F':{}, 'L':{1:m, m:-1, -1:-m, -m:1}, 'R':{1:-m, -m:-1, -1:m, m:1}}
    # used to 'blur' all cells in path into 3x3
    X = lambda x: {x-m-1,x-m,x-m+1,x-1,x,x+1,x+m-1,x+m,x+m+1}
    for c in s:
        d = D[c].get(d,d) # change direction
        n += d            # move current cell
        # the polyomino has a hole if the current cell touches previous cells (including diagonally; thus the blurring function)
        if n in set().union(*map(X,a[:-2])): return False
        a.append(n)       # add current cell to the path
    return True

# main function
def f(n):
    if n < 3: return 1
    x = {*'LF'}
    # generate all polystrips using the notation similar to the reference
    for _ in range(3, n): x = {s+c for s in x for c in ({*'LRF'}-{s[-1]})|{'F'}}
    y = {*x}
    # remove duplicates (mirror, head-to-tail, mirror of head-to-tail) but retain self
    for s in x:
        if s in y:
            S = s.translate(t)
            y -= {s[::-1], S, S[::-1]} - {s}
    # finally filter out holey ones
    return sum(map(check,y))

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

m = 999इसलिए चुना जाता है क्योंकि सब कुछ गिनने के लिए घातीय समय लगता है, और यह गणना करने के लिए पहले से ही ~ 8 s ले रहा है n = 1..15। हो सकता है कि इसके बजाय 99 का उपयोग करके 1 बाइट बचाना ठीक है। हमें अब इसकी आवश्यकता नहीं है, और अब यह अंतर्निहित इनपुट आकार के लिए सही होने की गारंटी है, जटिल संख्या में अंतर्निहित के लिए धन्यवाद।

Comments

PPCG में आपका स्वागत है! निश्चित रूप से अपने पीपीसीजी कैरियर को शुरू करने का एक प्रभावशाली तरीका है। :)

— मार्टिन एंडर

PPCG में आपका स्वागत है और इस समाधान के लिए धन्यवाद! मैंने पहले ही एक समाधान देखने की उम्मीद छोड़ दी थी :)

— गैलेन इवानोव

मेरे पीपीसीजी कैरियर (या नहीं?) को शुरू करने के लिए एक अच्छे बिंदु की तरह देखा गया । खैर, यह एक आश्चर्यजनक रूप से संक्षिप्त समाधान है, हम में से अधिकांश ने कभी सोचा भी नहीं हो सकता है, यहां तक ​​कि अनगुल्ड संस्करण आश्चर्यजनक रूप से सरल दिखता है, लेकिन, एह, शायद यह आपके पीपीसीजी कैरियर को शुरू करने का एक औसत तरीका है, है ना? :)

— Out में आउटगॉल्फ को एरिक करें

@ एरिक उस रेखा का आधा मज़ाक था :) लेकिन हाँ, समाधान मेरे लिए और भी आश्चर्य की बात है - मैंने कभी भी अपने आप से यह उम्मीद नहीं की थी कि मैं मूल सबमिशन से 36% की कमी कर सकता हूँ।

— Bubbler

संभावित 303 बाइट्स ।

— जोनाथन फ्रीच

Answer 2

एपीएल (डायलॉग यूनिकोड) , ⁷⁰ 65 बाइट्स

+/{∧/∊2≤|(⊢-¯3↓¨,\)+\0 1,×\0j1*⍵}¨∪{(⊃∘⍋⊃⊢)(⊢,⌽¨)⍵(-⍵)}¨2-,⍳2↓⎕⍴3

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

नीचे दिए गए कोड का पूर्ण कार्यक्रम संस्करण, Adám के लिए धन्यवाद।

---

एपीएल (डायलॉग यूनिकोड) , 70 बाइट्स

{+/{∧/∊2≤|(⊢-¯3↓¨,\)+\0 1,×\0j1*⍵}¨∪{(⊃∘⍋⊃⊢)(⊢,⌽¨)⍵(-⍵)}¨2-,⍳3⍴⍨0⌈⍵-2}

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

यह काम किस प्रकार करता है

उपरोक्त कोड निम्नलिखित परिभाषा के बराबर है:

gen←{2-,⍳3⍴⍨0⌈⍵-2}
canonicalize←{(⊃∘⍋⊃⊢)(⊢,⌽¨)⍵(-⍵)}
test←{(∧/⊢{∧/2≤|⍺-¯3↓⍵}¨,\)+\0 1,×\0j1*⍵}
{+/test¨∪canonicalize¨gen⍵}

यह पायथन समाधान की तरह काम करता है, लेकिन एक अलग क्रम में। यह generates LFRलंबाई की -strips n-2, canonicalizeप्रत्येक पट्टी है, लेता है ∪nique स्ट्रिप्स, testप्रत्येक पट्टी है, तो वह खुद को छू लेती है (1 अगर छू नहीं, अन्यथा 0), और योग +/बूलियन परिणाम।

gen

{2-,⍳3⍴⍨0⌈⍵-2}
{            }  ⍝ ⍵←input number n
        0⌈⍵-2   ⍝ x←max(0, n-2)
     3⍴⍨        ⍝ x copies of 3
   ,⍳           ⍝ multi-dimensional indexes; x-th cartesian power of [1,2,3]
                ⍝ (`⍳` gives x-dimensional hypercube; `,` flattens it)
 2-             ⍝ compute 2-k for each k in the array

⍝ in each strip, ¯1, 0, 1 corresponds to R, F, L respectively

canonicalize

{(⊃∘⍋⊃⊢)(⊢,⌽¨)⍵(-⍵)}
{                  }  ⍝ ⍵←single strip
              ⍵(-⍵)   ⍝ nested array of ⍵ and its LR-flip
        (⊢,⌽¨)        ⍝ concatenate their head-to-tail flips to the above
 (⊃∘⍋  )              ⍝ find the index of the lexicographically smallest item
     ⊃⊢               ⍝ take that item

test

{(∧/⊢{∧/2≤|⍺-¯3↓⍵}¨,\)+\0 1,×\0j1*⍵}
{                                  }  ⍝ ⍵←single strip
                              0j1*⍵   ⍝ power of i; direction changes
                            ×\        ⍝ cumulative product; directions
                        0 1,    ⍝ initial position(0) and direction(1)
                      +\        ⍝ cumulative sum; tile locations
 (  ⊢{           }¨,\)   ⍝ test with current tile(⍺) and all tiles up to ⍺(⍵):
             ¯3↓⍵        ⍝ x←⍵ with last 3 tiles removed
           ⍺-            ⍝ relative position of each tile of x from ⍺
        2≤|              ⍝ test if each tile of x is at least 2 units away
      ∧/                 ⍝ all(...for each tile in x)
  ∧/        ⍝ all(...for each position in the strip)

Comments

-5

— अडाम