क्या आप एक हेक्सोमिनो को एक घन में बदल सकते हैं?

24

मेरे बच्चे के पसंदीदा खिलौनों में से एक इस तरह का एक सेट है । वास्तव में मेरे पसंदीदा खिलौनों में से एक - मैं इसके साथ खेल रहा हूं और यह मुझे कुछ पीपीसीजी चुनौती देने वाले विचार दे रहा है। यहां एक है:

एक प्रोग्राम या फ़ंक्शन लिखें जो इनपुट के रूप में एक ASCII लाइन ड्राइंग लेता है और यह तय करता है कि यह एक क्यूब में तह करता है या नहीं।

इनपुट

इनपुट इस तरह से वर्गों से निर्मित वास्तव में एक हेक्सोमिनो से बना होगा:

+-+
| |
+-+

उदाहरण के लिए एक वैध इनपुट हेमिसिनो है:

+-+
| |
+-+-+-+-+
| | | | |
+-+-+-+-+
  | |
  +-+

उत्पादन

  • एक सत्य मूल्य अगर हेक्सोमिनो को एक घन में बांधा जा सकता है, या
  • एक गलत मूल्य।

हमें थोड़ा सा काम बचाने के लिए, विकिपीडिया के अच्छे ग्राफिक्स हैं:

  • सभी 35 हेक्सोमाइनो:

  • सभी 11 हेक्सोमिनोइज जो क्यूब्स में गुना करते हैं:

टिप्पणियाँ

  • इनपुट हेक्सोमीनो में कोई रोटेशन या प्रतिबिंब हो सकता है, न कि केवल ऊपर की छवियों में दिखाया गया है
  • इनपुट हेक्सोमीनो में अग्रणी स्थान हो सकते हैं, लेकिन खुद को सम्मान के साथ सही ढंग से संरेखित किया जाएगा
  • इनपुट हेक्सोमिनोइज़ में लाइनों के अंत में अनुगामी स्थान और इनपुट के अंत में नईलाइन्स अनुगामी हो सकती है
code-golf  ascii-art  kolmogorov-complexity  geometry 
— डिजिटल आघात
स्रोत
1
क्या आप बता सकते हैं कि यहाँ एक इमेज-प्रोसेसिंग टैग क्यों है? चुनौती को हल करने के लिए न तो सवाल, न ही जवाब किसी भी तरह की छवि प्रसंस्करण करना होगा।
— ऑप्टिमाइज़र
अग्रणी / अनुगामी स्थान के बारे में स्पष्टीकरण: प्रत्येक पंक्ति पर अनावश्यक अग्रणी / अनुगामी स्थान हैं और इनपुट में अनुमति दी गई अनावश्यक नईलाइन्स? क्या मुझे 1000+ चार्ट इनपुट का प्रबंधन करने में सक्षम होना चाहिए?
— edc65
@ edc65 हां, आपको बताए गए अनावश्यक सफेद स्थान की अपेक्षा करनी चाहिए। 1000 वर्ण अधिकतम इनपुट आकार उचित लगता है - मैं इसे संपादित करूँगा
— डिजिटल ट्रॉमा
हम्म। मुझे आश्चर्य है कि एक मुद्रित पृष्ठ पर कितने घन हेक्सोमिनोइज़ को निचोड़ा, रस निकाला जा सकता है?
— लूसर ने

जवाबों:

7

पीएमए / घोंघे , 130

.!(z\ |o{c..!(z\ }3){w=(..!(z\ )|b..!(z\ )o{..!(z\ }2|c{..!(z\ }1,2w..!(z\ )|w{..!(z\ }1,2c..!(z\ }4o..!(z\ )(..!(z\ )|n..!(z\ )`2

या अधिक "आसानी से",

?
.!(z\  | o{c..!(z\ }3  )
{w =( ..!(z\ ) | b ..!(z\ ) o {..!(z\ }2  | c {..!(z\ }1,2w..!(z\ ) | w {..!(z\ }1,2c..!(z\  }4
o  ..!(z\ ) ( ..!(z\ ) | n ..!(z\ ) `2

असामान्य रूप से, एक समस्या यह आई कि सीमित सुविधाओं को अब तक लागू किया जा सकता है। !(z\ )पैटर्न को निर्धारित करता है एक वर्ग एक नकारात्मक अभिकथन कुछ "octilinear" दिशा में एक जगह नहीं है का उपयोग कर के बीच में अंतरिक्ष में है कि वर्तमान स्थिति। सामान्य विचार उस पैटर्न की जांच करना है जो उस मैच के शुरू होने वाले वर्ग के सापेक्ष 5 आवश्यक स्थानों में से प्रत्येक पर एक वर्ग रखता है। इसके अलावा, यह जांचने की जरूरत है कि यह वर्गों के 2x2 ब्लॉक में नहीं है। इससे पहले कि कार्यक्रम काम करेगा, मुझे कोष्ठक के पार्सिंग के साथ एक बग को ठीक करना होगा।

यदि हेक्सोमिनो एक घन का नक्शा नहीं करता है, 0तो मुद्रित किया जाता है। यदि ऐसा होता है, तो कुछ सकारात्मक पूर्णांक मुद्रित होते हैं (मैचों की संख्या)।

मैंने सभी संभव परीक्षण मामलों को बनाने के लिए इस पॉलोमिनो जनरेटर को अनुकूलित किया :

n=input()
r=range
T=lambda P:set(p-min(p.real for p in P)-min(p.imag for p in P)*1j for p in P)
A=[]
for i in r(1<<18):
 P=[k%3+k/3*1j for k in r(18)if i>>k&1]
 C=set(P[:1])
 for x in P:[any(p+1j**k in C for k in r(4))and C.add(p)for p in P]
 P=T(P)
 if not(C^P or P in A or len(P)-n):
  #for y in r(4):print''.join(' *'[y+x*1j in P] for x in r(6))
  o = [ [' ']*13 for _ in r(9)]
  for y in r(4):
   for x in r(6):
    if y+x*1j in P: X=2*x;Y=2*y; o[Y][X]=o[Y+2][X]=o[Y][X+2]=o[Y+2][X+2]='+'; o[Y][X+1]=o[Y+2][X+1]='-';o[Y+1][X+2]=o[Y+1][X]='|'
  print '\n'.join(map(''.join,o))
  A+=[T([p*1j**k for p in P])for k in r(4)]
— feersum
स्रोत
हाहाहाहाहाहा और अधिक "आसानी से"
— ऑप्टिमाइज़र
5

रूबी, 173 148 145 143 बाइट्स

h=->b,c{[c.count(c.max),c.count(c.min),3].max*2<b.max-b.min}
->s{x=[];y=[];i=j=0
s.bytes{|e|e==43&&x<<i|y<<j;i=e<32?0*j+=1:i+1}
h[x,y]||h[y,x]}

नवीनतम परिवर्तन: /2दाईं ओर बाईं ओर से <प्रतिस्थापित किया *2गया। के एक सेट को खत्म करने की अनुमति देता है()

व्याख्या

कोड दो भागों में है: एक मुख्य अनाम फ़ंक्शन जो पार्सिंग करता है, और एक सहायक अनाम फ़ंक्शन जो चर hको चेक करता है।

स्ट्रिंग के माध्यम से मुख्य समारोह स्कैन bytewise, x और y निर्देशांक जोड़ने i,jसभी के +प्रतीकों को पाया x[]और y[]। इसके बाद hदो बार फोन किया। पहली बार यह मानता है कि हेक्सोमिनो क्षैतिज है ( x[]लंबाई और y[]चौड़ाई शामिल है) और दूसरी बार यह मानता है कि यह लंबवत है।

फ़ंक्शन hसरणी में लंबाई के अनुसार निर्देशांक लेता है, bफिर चौड़ाई में सरणी में समन्वय करता है c। यह अभिव्यक्ति द्वारा लंबाई (वर्गों में) की गणना करता है (b.max.b.min)/2। यदि यह 3 से कम या इसके बराबर है, तो हेक्सोमिनो का मूल्यांकन दूसरी दिशा में किया जाना चाहिए ताकि hरिटर्न मिले false।

हेक्सोमिनो के निरीक्षण से पता चलेगा कि यदि लंबाई 4 है, तो उन हेक्सोमिनोस जो एक घन में बदल जाएंगे +, पहली और आखिरी पंक्ति में 2 से अधिक वर्ग (3 प्रतीक) नहीं हैं । अधिकांश वर्ग मध्य पंक्ति पर केंद्रित हैं, जो घन का भूमध्य रेखा बन जाएगा। यह स्थिति लंबाई 4 के हेक्सोमिनो के लिए आवश्यक और पर्याप्त हो जाती है जो घन में बदल जाएगी।

लंबाई 5 की केवल एक हेक्सोमिनो है जो एक घन में बदल जाएगी। +इसकी पहली और आखिरी पंक्तियों में 3 वर्ग (4 प्रतीक) हैं। लंबाई 5 के अन्य सभी षट्कोणों में +पहली या अंतिम पंक्ति में 5 या अधिक चिह्न हैं।

लंबाई का केवल एक हेक्सोमिनो है 6. इसमें +प्रत्येक पंक्ति पर 7 प्रतीक हैं।

यह सब एक साथ रखकर, यह जांचने के लिए पर्याप्त है कि हेक्सोमिनो की लंबाई 3 से अधिक है, और +पहली और आखिरी पंक्तियों (जो भी अधिक हो) पर प्रतीकों की संख्या लंबाई से कम है।

परीक्षण कार्यक्रम में अपराजित

#checking function as explained in text
h=->b,c{[c.count(c.max),c.count(c.min),3].max<(b.max-b.min)/2}

#main function for parsing
f=->s{
  x=[]                 #separate assignments required, 
  y=[]                 #otherwise we get 2 pointers to the same array
  i=j=0                #start coordinates 0,0
  s.bytes{|e|          #scan string bytewise
    e==43&&x<<i|y<<j     #if byte is a + symbol (ascii 43) add the coordinates to arrays x and y
    i=e<32?0*j+=1:i+1    #if byte is before ascii 32 assume newline, increment j and zero i. Otherwise increment i
  }
  h[x,y]||h[y,x]       #call h twice, with x and y in each possible order
}



#VALID INPUTS
puts f["
+-+
| |
+-+-+-+-+
| | | | |
+-+-+-+-+
| |
+-+"]

puts f["
+-+
| |
+-+-+-+-+
| | | | |
+-+-+-+-+
  | |
  +-+"]

puts f["
+-+
| |
+-+-+-+-+
| | | | |
+-+-+-+-+
    | |
    +-+"]
puts f["
+-+
| |
+-+-+-+
| | | |
+-+-+-+-+
    | | |
    +-+-+"]

puts f["
+-+
| |
+-+-+-+-+
| | | | |
+-+-+-+-+
      | |
      +-+"]

puts f["
    +-+
    | |
+-+-+-+-+
| | | | |
+-+-+-+-+
    | |
    +-+"]
puts f["
    +-+
    | |
+-+-+-+
| | | |
+-+-+-+-+
    | | |
    +-+-+"]


puts f["
  +-+
  | |
+-+-+-+-+
| | | | |
+-+-+-+-+
    | |
    +-+"]
puts f["
  +-+
  | |
+-+-+-+
| | | |
+-+-+-+-+
    | | |
    +-+-+"]  
puts f["
+-+-+
| | |
+-+-+-+
  | | |
  +-+-+-+
    | | |
    +-+-+"]

puts f["
  +-+-+-+
  | | | |
  +-+-+-+-+-+
      | | | |
      +-+-+-+
"]


#INVALID INPUTS

puts f["
  +-+-+-+
  | | | |
  +-+-+-+
  | | | |
  +-+-+-+
"]


puts f["
  +-+-+-+-+-+-+
  | | | | | | |
  +-+-+-+-+-+-+

"]


puts f["
  +-+-+
  | | |
  +-+-+
  | |
  +-+
  | |
  +-+
  | |
  +-+
  | |
  +-+
"]

puts f["
  +-+-+-+-+-+
  | | | | | |
  +-+-+-+-+-+
    | |
    +-+
"]

puts f["
      +-+
      | |
  +-+-+-+-+-+
  | | | | | |
  +-+-+-+-+-+
"]

puts f["
  +-+-+-+-+
  | | | | |
  +-+-+-+-+-+
        | | |
        +-+-+"]

puts f["
  +-+-+-+-+
  | | | | |
  +-+-+-+-+
      | | |
      +-+-+
"] 


puts f["
  +-+-+-+-+
  | | | | |
  +-+-+-+-+
  | | | |
  +-+ +-+
"]

puts f["
 +-+   +-+
 | |   | |
 +-+-+-+-+
 | | | | |
 +-+-+-+-+
"]

puts f["
   +-+-+
   | | |
 +-+-+-+-+
 | | | | |
 +-+-+-+-+
"]

puts f["
  +-+
  | |
  +-+
  | |
  +-+-+-+-+
  | | | | |
  +-+-+-+-+
"]

puts f["
  +-+
  | |
  +-+-+-+
  | | | |
  +-+-+-+
  | |
  +-+
  | |
  +-+
"]

puts f["
  +-+
  | |
+-+-+-+
| | | |
+-+-+-+
| |
+-+
| |
+-+"]

puts f["
  +-+-+
  | | |
  +-+-+
  | |
  +-+-+
  | | |
  +-+-+
    | |
    +-+
"]

puts f["
  +-+-+-+
  | | | |
  +-+-+-+-+
    | | | |
    +-+-+-+
"]

puts f["
  +-+-+-+
  | | | |
  +-+-+-+
      | |
      +-+-+
      | | |
      +-+-+
"]


puts f["
  +-+-+-+
  | | | |
  +-+-+-+-+
      | | |
      +-+-+
        | |
        +-+
"]
— स्तर नदी सेंट
स्रोत
pentonimo → अपने पाठ में hexonimo?
— पाओलो एबरमन
3

जावास्क्रिप्ट (ईएस 6), 443 431

बग फिक्स को संपादित करें , इनपुट पार्स के दौरान समस्या, खाली कॉलम को हटा दें 

F=t=>(a=b=c=d=e=f=g=h=0,M=Math.min,
t=t.split('\n').filter(r=>r.trim()>''),
t=t.map(r=>r.slice(M(...t.map(r=>r.search(/\S/))))),
t.map((r,i)=>i&1&&[...r].map((_,j)=>j&1&&r[j-1]==r[j+1]&t[i-1][j]==t[i+1][j]&r[j-1]=='|'
&&(y=i>>1,x=j>>1,z=y*5,w=x*5,a|=1<<(z+x),e|=1<<(w+y),b|=1<<(4+z-x),f|=1<<(4+w-y),c|=1<<(20-z+x),g|=1<<(20-w+y),d|=1<<(24-z-x),h|=1<<(24-w-y)
))),~[1505,2530,3024,4578,252,6552,2529,4577,2499,4547,7056].indexOf(M(a,b,c,d,e,f,g,h)))

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

अगर मैं दिया गया इनपुट 11 वियरेबल हेक्सोमीनो में से एक है, तो मैं क्या करता हूं

प्रत्येक फोल्डेबल हेक्सोमिनो को कुछ 5x5 बिटमैप (8 भिन्न तक, समरूपता और घुमाव के साथ) में मैप किया जा सकता है। 25 बिट संख्या के रूप में बिटमैप ले लिया, मैंने निम्न कोड (बहुत सरल इनपुट प्रारूप के साथ) का उपयोग करते हुए 11 विख्यात हेक्सोमीनो के लिए न्यूनतम मान पाया है।

h=[ // Foldable hexominoes
'o\noooo\no', ' o\noooo\n o', // pink
'o\noooo\n   o', ' o\noooo\n  o', 'ooo\n  ooo', 'oo\n oo\n  oo', //blue
'o\noooo\n o', 'o\noooo\n  o', 'oo\n ooo\n o', 'oo\n ooo\n  o', 'o\nooo\n  oo' // gray
]
n=[]
h.forEach(t=>(
  a=[],
  t.split('\n')
    .map((r,y)=>[...r]
      .map((s,x)=>s>' '&&(
         a[0]|=1<<(y*5+x),a[1]|=1<<(x*5+y),  
         a[2]|=1<<(y*5+4-x),a[3]|=1<<(x*5+4-y),  
         a[4]|=1<<(20-y*5+x),a[5]|=1<<(20-x*5+y),  
         a[6]|=1<<(24-y*5-x),a[7]|=1<<(24-x*5-y))
     )
  ),
n.push(Math.min(...a))
))

देता है कि [1505,2530,3024,4578,252,6552,2529,4577,2499,4547,7056]

इसलिए, इनपुट स्ट्रिंग को देखते हुए, मुझे बिट बिटमैप को खोजने के लिए भी ऐसा ही करना होगा, फिर वापस लौटना होगा यदि यह नंबर मेरी प्रीलैक लिस्ट में मौजूद है।

// Not so golfed 

F=t=>(  
  a=b=c=d=e=f=g=h=0,M=Math.min,
  t=t.split('\n').filter(r=>r.trim()>''), // remove blank lines
  t=t.map(r=>r.slice(M(...t.map(r=>r.search(/\S/))))), // remove blank colums to the left
  t.map((r,i)=>i&1&&[...r] // only odd rows
   .map((_,j)=>j&1&& // only odd columns
      r[j-1]==r[j+1]&t[i-1][j]==t[i+1][j]&r[j-1]=='|' // found a cell
         &&(y=i>>1,x=j>>1,z=y*5,w=x*5, // find bitmaps for 8 rotations/simmetries
            a|=1<<(z+x),e|=1<<(w+y),  
            b|=1<<(4+z-x),f|=1<<(4+w-y),  
            c|=1<<(20-z+x),g|=1<<(20-w+y),  
            d|=1<<(24-z-x),h|=1<<(24-w-y)  
    ))),
   ~[1505,2530,3024,4578,252,6552,2529,4577,2499,4547,7056].indexOf(Math.min(a,b,c,d,e,f,g,h)) // look for min
)

फ़ायरफ़ॉक्स में परीक्षण करने के लिए स्निपेट चलाएं

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

— edc65
स्रोत
मुझे माफ कर दो अगर मुझे कुछ याद आ रहा है, लेकिन क्या आप ,\nt=tदूसरी पंक्ति के अंत से / तीसरी पंक्ति की शुरुआत नहीं कर सकते ?
— कोनोर ओ'ब्रायन
@ C @O'Bʀɪᴇɴ छह महीने बाद समीक्षा कर रहा है कि पार्सिंग कोड 10 ... 15 बाइट्स कम किया जा सकता है। जैसा कि, मुझे पंक्ति 2 में t को असाइन करने की आवश्यकता है और पंक्ति 3 में फिर से क्योंकि पंक्ति 3 में इसका उपयोग बाईं ओर काटने के लिए रिक्त वर्णों की संख्या ज्ञात करने के लिए किया जाता है।
— edc65
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.