-63 बाइट्स @Arnauld की बदौलत। वाह।
n=>(E=(x,y,d,k,h)=>V[k=[x+=1-(d%=3),y+=~d%3+1,d]]?0:(V[k]=1,h=H.find(h=>h[0]==x&h[1]==y))?(d^(t=2-h[2])?E(x,y,t)||E(x,y,h[2]*2):E(x,y,t+2)):[x,y,0],I=c=>c.map(([x,y,t])=>[x-g(0),y-g(1),t],g=p=>Math.min(...c.map(h=>h[p]))).sort(),S=e=>(V={},e=E(0,0,0))?(--n&&H.pop(H.push(e),S(),S(e[2]=1),S(e[2]=2)),++n):n-1||E[I(c=H)]||[0,0,0,++N,0,0].map(r=>E[I(c=c.map(([x,y,t])=>[-x-y,r?y:x,(r?t*2:t+1)%3]))]=1))(H=[[N=0,0,1]])&&N
इसे ऑनलाइन आज़माएं!
सबसे पहले, अरनुलद को पछतावा हुआ जिनके जवाब से मुझे गहरी खुदाई करने की प्रेरणा मिली। मैंने अपने एल्गोरिदम के साथ मूल होने की बहुत कोशिश की है, हालांकि मैंने जानबूझकर अपने कुछ कोड को बदलकर Arnauld के समान चर का उपयोग किया है ताकि कोड की तुलना में अधिक आसानी से हो सके।
खाली हेक्स की खोज करना
प्राणियों की खोज है:
- 0,0 पर टाइल 1 के साथ टाइल की प्रारंभिक सूची
- रिकर्सिवली:
- एक खाली हेक्स की खोज करें जो प्राणी को पूरा करने के लिए आवश्यक है
- यदि खाली हेक्स पाया गया
- खाली हेक्स और पुनरावृत्ति करने के लिए प्रत्येक प्रकार की टाइल 0,1,2 जोड़ें
- यदि खाली हेक्स नहीं मिला
- यदि प्राणी सही आकार का है और पहले से ही चिड़ियाघर में नहीं है
- एक के बाद एक अलग-अलग जीवों की बढ़ती संख्या
- प्राणी के सभी घुमावों और प्रतिबिंबों को चिड़ियाघर में जोड़ें
खाली हेक्स की खोज ने एक दिलचस्प समरूपता का खुलासा किया। अर्नुलद ने पाया कि छह दिशाओं में से एक को अनदेखा किया जा सकता है, लेकिन वास्तव में छह में से तीन को अनदेखा किया जा सकता है!
यहां अर्नुल्ड की मूल दिशा और टाइल कुंजी है:
कल्पना करें कि हम ब्लू डॉट पर टाइप 1 के टाइल ए पर शुरू करते हैं। ऐसा लगता है कि हमें d = 0 और d = 5 में पुनरावृत्ति करनी है। हालाँकि, जो भी टाइल d = 0 में रखी गई है, वह निश्चित रूप से d = 4 में एक निकास होगी, जो d = 5 में बाहर निकलने वाली टाइल A के समान ही हेक्स का दौरा करेगी। यही अर्नुल्ड की खोज है, और यही मुझे सोचने लगा है।
नोटिस जो:
- प्रत्येक टाइल जिसमें d = 0 का निकास होता है, d = 5 का निकास होता है
- प्रत्येक टाइल जिसमें d = 2 का निकास होता है, d = 1 का निकास होता है
प्रत्येक टाइल जिसमें d = 4 का निकास होता है, d = 3 का निकास होता है
प्रत्येक टाइल जो d = 0 से दर्ज की जा सकती है, d = 4 में एक निकास है
- प्रत्येक टाइल जो d = 2 से दर्ज की जा सकती है, d = 0 में एक निकास है
- प्रत्येक टाइल जो d = 4 से दर्ज की जा सकती है, d = 2 में एक निकास है
इसका मतलब है कि हमें केवल 0,2,4 दिशाओं पर विचार करने की आवश्यकता है। 1,3,5 दिशाओं में किसी भी निकास को नजरअंदाज किया जा सकता है क्योंकि 1,3,5 दिशाओं में पहुंचता है इसके बजाय 0,2 या 4 दिशाओं का उपयोग करके आसन्न हेक्स से पहुंचा जा सकता है।
कितना मजेदार था वो!?
पुनः निर्देशित दिशाएँ
इसलिए मैं दिशाओं और टाइलों को इस तरह रिले करता हूं (अरनुल्ड की छवि संपादित की गई):
अब हमारे पास टाइलों, प्रविष्टियों और निकास के बीच निम्नलिखित संबंध हैं:
| t=0 | t=1 | t=2
----+-------+-------+-------
d=0 | 0,2 | 1,2 | 2
d=1 | 0,2 | 0 | 0,1
d=2 | 1 | 1,2 | 0,1
तो बाहर निकलें हैं: d + t == 2? (4-टी)% 3: 2-टी और 2 * टी% 3
हेक्सागोनल रोटेशन और प्रतिबिंब
रोटेशन और प्रतिबिंब के लिए, मैंने एक्स, वाई, जेड क्यूब निर्देशांक के बजाय एक्स, वाई हेक्सागोनल अक्षीय निर्देशांक की कोशिश करने का फैसला किया ।
-1,2 0,2 1,2 2,2
0,1 1,1 2,1
0,0 1,0 2,0 3,0
इस प्रणाली में, रोटेशन और परावर्तन मेरी अपेक्षा से अधिक सरल थे:
120 Rotation: x=-x-y y=x t=(t+1)%3
Reflection: x=-x-y y=y t=(t*2)%3
मेरे द्वारा किए गए सभी संयोजनों को प्राप्त करने के लिए: सड़ांध, सड़ांध, सड़ांध, प्रतिबिंबित, सड़ांध, सड़ांध
कोड (मूल 480 बाइट)
f=n=>(
// H:list of filled hexes [x,y,tile] during search for a complete creature
// N:number of distinct creatures of size n
// B:record of all orientations of all creatures already found
H=[[0,0,1]],N=0,B={},
// E: find an empty hex required to complete creature starting in direction d from x,y
E=(x,y,d,k,h)=>(
x+=1-d,
y+=1-(d+1)%3,
// V: list of visited hexes during this search in E
V[k=[x,y,d]] ?
0
: (V[k]=1, h=H.find(h=>h[0]==x&&h[1]==y)) ?
// this hex is filled, so continue search in 1 or 2 directions
(d==2-h[2] ? E(x,y,(4-h[2])%3) : (E(x,y,2-h[2]) || E(x,y,h[2]*2%3)))
: [x,y,0] // return the empty hex
),
// I: construct unique identifier for creature c by moving it so x>=0 and y>=0
I=c=>(
M=[0,1].map(p=>Math.min(...c.map(h=>h[p]))),
c.map(([x,y,t])=>[x-M[0],y-M[1],t]).sort()
),
// A: add complete creature c to B
A=c=>{
n==1&&!B[I(c)]&&(
// creature is correct size and is not already in B
N++,
[0,0,0,1,0,0].map(
// Add all rotations and reflections of creature into B
// '0' marks a rotation, '1' marks a (vertical) reflection
// rotation: x=-x-y y=x t=(t+1)%3
// reflection: x=-x-y y=y t=(t*2)%3
r=>B[I(c=c.map(([x,y,t])=>[-x-y,r?y:x,(r?t*2:t+1)%3]))]=1)
)
},
// S: recursively search for complete creatures starting with hexes H
S=e=>{
V={};
(e=E(0,0,0)) ?
// e is a required empty hex, so try filling it with tiles 0,1,2
(--n && (H.push(e),S(),S(e[2]=1),S(e[2]=2),H.pop()), ++n)
: A(H) // creature is complete, so add it to B
},
S(),
N
)
कोड (अरनौल 417 बाइट)
अरनुल्द ने कृपया 63 बाइट की बचत प्रस्तुत की, जिसमें ट्रिक्स का इस्तेमाल किया गया जिससे मुझे अपना सिर लपेटने में काफी समय लगा। चूंकि इसमें कई दिलचस्प संपादन हैं, इसलिए मुझे लगा कि मैं उसका कोड नीचे रख दूंगा (मैंने अपनी टिप्पणियाँ जोड़ दी हैं) ताकि यह मेरे संस्करण के साथ विपरीत हो सके।
f=n=>(
// E:find an empty hex required to complete creature starting in direction d from x,y
E=(x,y,d,k,h)=>
V[k=[x+=1-(d%=3),y+=~d%3+1,d]] ?
0
:(V[k]=1,h=H.find(h=>h[0]==x&h[1]==y)) ?
(d^(t=2-h[2]) ? E(x,y,t) || E(x,y,h[2]*2) : E(x,y,t+2))
:[x,y,0],
// I: construct unique identifier for creature c by moving it so x>=0 and y>=0
I=c=>c.map(([x,y,t])=>[x-g(0),y-g(1),t],g=p=>Math.min(...c.map(h=>h[p]))).sort(),
// S: recursively search for complete creatures starting with hexes H
S=e=>
(V={},e=E(0,0,0)) ?
(--n&&H.pop(H.push(e),S(),S(e[2]=1),S(e[2]=2)),++n)
:n-1
||E[I(c=H)]
// creature is the correct size and has not been seen before
// so record all rotations and reflections of creature in E[]
||[0,0,0,++N,0,0].map(r=>E[I(c=c.map(([x,y,t])=>[-x-y,r?y:x,(r?t*2:t+1)%3]))]=1)
)
// This wonderfully confusing syntax initializes globals and calls S()
(H=[[N=0,0,1]]) && N
n=10TIO पर संभालने में सक्षम होना चाहिए ।" - यदि यह एक निष्पादन गति की आवश्यकता है, तो कोड-गोल्फ के बजाय कोड-चुनौती का उपयोग करें , बाद में एक शुद्ध बाइट अनुकूलन कार्य का जिक्र है।