ภาพด้านบนแสดงตารางหกเหลี่ยมเป็นรูปหกเหลี่ยม แต่ละเซลล์ในกริดจะถูกกำหนดดัชนีโดยเริ่มจากศูนย์กลางและหมุนทวนเข็มนาฬิการอบ ๆ ดังที่แสดง โปรดทราบว่าตารางจะดำเนินต่อไปเรื่อย ๆ - รูปภาพด้านบนเป็นเพียงส่วนแรก รูปหกเหลี่ยมถัดไปจะอยู่ติดกับ 60 และ 37

งานของคุณคือการพิจารณาว่ามีสองเซลล์ในตารางนี้อยู่ติดกันหรือไม่

เขียนโปรแกรมหรือฟังก์ชั่นที่ได้รับสองดัชนีเซลล์พิมพ์ / ส่งกลับค่าความจริงหากทั้งสองเซลล์อยู่ติดกันและค่าเท็จถ้าไม่ได้

หากไม่ จำกัด ด้วยเหตุผลที่ปฏิบัติได้จริงรหัสของคุณควรใช้กับอินพุตได้ทุกขนาด

กรณีทดสอบจริง:

0, 1
7, 18
8, 22
24, 45
40, 64
64, 65

กรณีทดสอบปลอม:

6, 57
29, 90
21, 38
38, 60
40, 63
41, 39
40, 40

นี่คือcode-golfดังนั้นคำตอบที่สั้นที่สุดในหน่วยไบต์ชนะ สนับสนุนให้มีการอธิบายแม้กระทั่งภาษาที่ไม่มีความลับ

Elixir , 263 257 264 223 214 218 214 ไบต์

a=fn x,y->i=&(&1*(&1-1)*3+1)
[x,y]=Enum.sort [x,y]
if x<1,do: y in 1..6,else: (y-x==1||fn->a=y-trunc i.((r=(:math.sqrt(12*x-3)+3)/6)+1)
t=trunc r
a in [0,1,rem(b=x-i.(t)+1, t)<1&&b-t*6!=0&&2]||b<2&&a==-1 end.())end

ลองออนไลน์!

รุ่นที่ไม่ได้ถูกดัดแปลง

def get_ring(x) do
    1/6*(:math.sqrt(12*x-3)+3)
end

def inv_get_ring(x), do: x*(x-1)*3+1

def ring_base(x), do: inv_get_ring(trunc(x))

def is_corner(x) do
    ring = trunc(get_ring(x))
    inv_ring = ring_base(ring)
    stuff = (x-inv_ring+1)
    rem(stuff, ring) == 0
end

def is_last(x),do: ring_base(get_ring(x)+1)-1 == x
def is_first(x),do: ring_base(get_ring(x)) == x

def hex_adj(x, y) do
    {x, y} = {min(x,y), max(x,y)}
    cond do 
        x == 0 ->y in 1..6      
        y-x==1 -> true
        true ->
            adj = trunc(inv_get_ring(get_ring(x)+1))
            number = if is_corner(x)&&!is_last(x), do: 2, else: 1
            if y-adj in 0..number do
                true
            else
                is_first(x) && y == adj-1
            end
    end
end

• trunc(number) ส่งคืนส่วนจำนวนเต็มของตัวเลข
• rem(a,b) ส่งคืนส่วนที่เหลือของ a / b
• cond do end สิ่งนี้เทียบเท่ากับกรณีอื่น ๆ หรือเปลี่ยนคำสั่งกรณีในภาษาที่จำเป็นจำนวนมาก

คำอธิบาย

get_ring (ดัชนี)

คำนวณ "แหวน" ของดัชนี

ตัวอย่าง: 1 สำหรับ 1-6, 2 สำหรับ 7-18 เป็นต้น

สิ่งนี้จะใช้เฉพาะในกรณีที่ผลลัพธ์เป็นfloorเอ็ด ตัวเลขต่อท้ายแสดงว่าไทล์นั้นอยู่ใกล้วงแหวนมากแค่ไหน

inv_get_ring (แหวน)

get_ring(index)คำนวณค่าผกผันของ

ring_base (แหวน)

คำนวณดัชนีของไพ่แผ่นแรกในวงแหวน

is_corner (ดัชนี)

มุมคือแผ่นกระเบื้องที่มีแผ่นกระเบื้องติดกันสามชิ้นในวงแหวนรอบนอก วงแหวนด้านในสุดประกอบด้วยมุมทั้งหมด

ตัวอย่าง: 21,24,27,30,33,36

is_last (ดัชนี)

เป็นจริงถ้าดัชนีนี้สูงที่สุดในแหวน

is_first (ดัชนี)

เป็นจริงถ้านี่คือไพ่พื้นฐานของวงแหวน

MATL , 47 45 44 43 41 ไบต์

s:"JH3/^6:^t5)w5:&)@qY"w@Y"]vYs0hG)d|Yo1=

ลองออนไลน์! หรือตรวจสอบกรณีทดสอบทั้งหมด

เป็นโบนัสรหัสสร้างเกลียวหกเหลี่ยมที่ติดตามตำแหน่งของศูนย์เซลล์ซึ่งสามารถเห็นได้ชัดเจนที่MATL Onlineโดยการแก้ไขส่วนสุดท้ายของรหัส

คำอธิบาย

แนวคิดทั่วไป    รหัสในตอนแรกสร้างเกลียวหกเหลี่ยมที่มีขนาดใหญ่พอกับขั้นตอนหน่วย เกลียวถูกกำหนดให้เป็นเวกเตอร์ของจำนวนเชิงซ้อนที่แสดงถึงตำแหน่งของศูนย์เซลล์ การจัดทำดัชนีในเวกเตอร์นั้นด้วยหมายเลขอินพุตและการคำนวณความแตกต่างแบบสัมบูรณ์จะให้ระยะห่างระหว่างเซลล์ที่ระบุทั้งสอง เซลล์อยู่ติดกันถ้าหากผลลัพธ์เป็น 1 อย่างไรก็ตามเนื่องจากความไม่ถูกต้องของจุดลอยจำเป็นต้องมีการปัดเศษก่อนที่จะเปรียบเทียบกับ 1

การสร้างเกลียว    เกลียวจะมีจำนวน "เลเยอร์" เท่ากับผลรวมของอินพุตทั้งสอง นี่มีขนาดใหญ่เกินความจำเป็นและทำให้แน่ใจว่าเซลล์อินพุตจะปรากฏในเกลียว

ในการสร้างเกลียวจำนวนเชิงซ้อนj ^2/3 (โดยที่jคือหน่วยจินตภาพ) ถูกคำนวณเป็นครั้งแรก การเพิ่มสิ่งนี้เป็นเลขชี้กำลัง 1 ถึง 6 จะให้ชุดการกระจัดพื้นฐานเช่นการติดตามการกระจัดตามลำดับนั้นจะติดตามหกเหลี่ยม รูปหกเหลี่ยมนี้จะก่อตัวเป็นชั้นในสุดของเกลียวยกเว้นว่ามันจะเป็น "ปิด" ที่จริงแล้วเราต้องการให้รูปหกเหลี่ยมนั้น "เติบโต" ในขั้นตอนสุดท้ายและจากนั้นเราติดตามรูปหกเหลี่ยมที่มีขนาดใหญ่ขึ้นโดยมีคะแนนเป็นสองเท่า (จัดเรียงเป็นกลุ่มสองกลุ่ม) เพื่อสร้างชั้นถัดไป ดูภาพประกอบที่นี่ เลเยอร์ถัดไปจะมีสามคะแนนให้มากที่สุดเท่าที่เป็นคนแรก (ในกลุ่มที่สาม); ดูที่นี่

เมื่อต้องการทำสิ่งนี้การกระจัดที่ห้าจากชุดพื้นฐาน (ซึ่งจุดในทิศทางตะวันออกเฉียงใต้) ถูกเลือกเป็นขั้นตอน "เติบโต" เลเยอร์kเริ่มต้นด้วยขั้นตอนนั้นตามด้วยขั้นตอนพื้นฐานห้าขั้นตอนแรกซ้ำแล้วซ้ำอีกครั้งkตามด้วยขั้นตอนที่หก (ทิศตะวันออก) ทำซ้ำk −1 ครั้ง หวังว่านี้จะชัดเจนขึ้นโดยดูตัวเลขสองตัวที่ลิงก์ด้านบน

เวกเตอร์ที่ได้รวมถึงเลเยอร์ทั้งหมดแสดงถึงการกระจัดที่ซับซ้อนที่จะติดตามเกลียว ผลรวมสะสมจะให้พิกัดที่แท้จริงของศูนย์เซลล์

สุดท้ายเซลล์เริ่มต้นซึ่งอยู่ที่ 0 จะถูกแนบกับส่วนท้ายของเวกเตอร์นี้ นี่เป็นเพราะ MATL ใช้การทำดัชนีแบบโมดูลาร์ 1 และดัชนี 0 อ้างถึงรายการสุดท้ายของอาร์เรย์

การทดสอบ adjacency    เลือกสองเซลล์ที่กำหนดโดยหมายเลขอินพุทพิกัดของมันจะถูกลบออกและค่าสัมบูรณ์จะถูกปัดเศษและเปรียบเทียบกับ 1

รหัสแสดงความคิดเห็น

s         % Implicitly input array of two numbers. Push their sum, say S
:         % Range [1 2 ... S]
"         % For each k in [1 2 ... S]
  J       %   Push 1j
  H3/     %   Push 2, then 3, then divide: gives 2/3
  ^       %   Power
  6:      %   Push [1 2 ... 6]
  ^       %   Element-wise power. This is the array of 6 basic displacements
  t5)     %   Duplicate. Get 5th entry
  w5:&)   %   Swap. Push subarray with entries 1st to 5th, then push 6th
  @qY"    %   Repeat the 6th displacement k-1 times
  w@Y"    %   Swap. Repeat 1st to 5th displacements k times
]         % End
v         % Concatenate everything into a column vector
Ys        % Cumulative sum. This gives the cell center coordinates
0h        % Append a 0
G)        % Index by the input vector
d|        % Absolute difference
Yo        % Round to nearest integer
1=        % Does it equal 1? Implicitly display

05AB1E (ดั้งเดิม) , 30 29 27 ไบต์

α2‹i1q}1ݹ+v12y*3-tîÌy+}Ÿ²å

ลองออนไลน์!

คำอธิบายของรหัส:

α2‹i1q}                     : if the absolute diff of the two number is 1 or 0 return 1
                          ²å: return that the second number is in
                         Ÿ  : range of {
       1Ý                   :  create [0, 1]
         ¹+                 :  add the first number to the elements
           v            }   :  map that list
            12y*3-tîÌy+     :  calculate the corresponding value where it's an adjacency
                                }

คำอธิบายของคณิตศาสตร์:

ฉันเสียเวลาทำกอล์ฟประมาณ 5 ชั่วโมง ในระยะสั้นฉันเริ่มทำกราฟ 2 มิติของอินพุตและวาดXว่าพวกเขาอยู่ตรงไหนกัน จากนั้นฉันก็พบรูปแบบ ฉันค้นหามันในOEISและ bingo! ฉันพบว่าลำดับและฉันใช้สูตรที่กำหนดบนเว็บไซต์

C (gcc) , 175 173 ไบต์

ขอบคุณPeter Taylor ที่จับข้อผิดพลาด

ขอบคุณceilingcatสำหรับ -2 ไบต์ โอเปอร์เรเตอร์นั้นยังคงเป็นจุดบอดหลักของฉันต่อไป

c,r,C,L;y(a){a=a<L*2?L-a:a<L*3?-L:a<5*L?a-L*4:L;}z(a){L=ceil(sqrt(a/3.+.25)-.5);C=y(a-=3*L*~-L);L?L=y((L+a)%(L*6)):0;}f(a,b){z(a);c=C,r=L;z(b);a=a-b&&(abs(c-C)|abs(r-L))<2;}

ลองออนไลน์!

วิธีการนี้มุ่งเน้นไปที่การค้นหาแถวและคอลัมน์ของเซลล์ทั้งสองและเปรียบเทียบ เพื่อนบ้านใด ๆ ไม่สามารถมีพิกัดที่สอดคล้องกันได้มากกว่า 1 การเคลื่อนที่จากจุดศูนย์กลางออกไปข้างนอกเราสังเกตว่าแต่ละชั้นมีเซลล์มากกว่า 6 เซลล์ก่อนหน้านี้ ซึ่งหมายความว่า "ดัชนี" สูงสุดในแต่ละเลเยอร์ L อยู่ในรูปแบบ 6 * (L * (L - 1) * (L - 2) ... ) หรือ C = 6 * (L ² + L) / 2 โดยที่ C คือจำนวนเซลล์ "ทั่วโลก" สิ่งที่สับไปมาเราจะได้ L ² + L - C / 3 = 0 ซึ่งให้ผลย้อนหลังทางคณิตศาสตร์ระดับมัธยมปลาย จากนั้นเราจะได้สูตรเพดาน (sqrt (1/4 + C / 3) + 0.5) การเสียบดัชนีโกลบอลเซลล์เข้ากับมันเราจะได้รับเลเยอร์เซลล์ที่อยู่

เนื่องจากเซลล์แรกในแต่ละเลเยอร์เป็นธรรมชาติหนึ่งสูงกว่าสูงสุดของเลเยอร์ก่อนหน้าเราจึงพบ L _start = (6 * (L - 1) ² + (L - 1)) / 2 ซึ่งลดความซับซ้อนของ 3 * (L ² - L) จากที่เราได้รับ L ดัชนีชั้น_{ดัชนี} = C - L เริ่มต้น

ต่อไปเราจะเห็นว่าแต่ละเลเยอร์ประกอบด้วยหกส่วนแต่ละความยาวแอลเริ่มต้นที่ทิศตะวันออกเฉียงเหนือและทวนเข็มนาฬิกาเราจะเห็นว่าในสองส่วนแรก (1 <= _{ดัชนี} L <= 2 * L) ที่เราได้รับจากคอลัมน์ L - L ดัชนี ส่วนถัดไป L * 2 <L _index <= L * 3 มีเซลล์ทั้งหมดที่แชร์คอลัมน์เดียว -L สองส่วนถัดไปคือ L * 3 <L _index <= L * 5 ที่มีคอลัมน์ตาม_{ดัชนี} L - L * 4 และสุดท้ายส่วนที่หกทั้งหมดมีเซลล์ในคอลัมน์ L เราสามารถเลื่อนขอบเขตบนหนึ่งขั้นตาม เพื่อบันทึกไบต์ในรหัส

แล้วแถวล่ะล่ะ? ในการใช้รหัสซ้ำเราเปิดกริดเพื่อให้เซลล์ 44 ตรงขึ้น จากนั้นเราเรียกใช้ตรรกะเดียวกันกับคอลัมน์ แต่เรียกผลลัพธ์เป็น "แถว" ในเวลานี้ แน่นอนแทนที่จะเปลี่ยนกริดจริงๆเราแค่เดิน 1/6 ของรอบตัก

Python 3, 150 ไบต์

def h(a,b):
 L=[];i=1
 while len(L)<a+b:r=sum((i*[1j**(k/3)]for k in range(4,16,2)),[]);r[0]+=1;L+=r;i+=1
 return.9<abs(sum(L[min(a,b):max(a,b)]))<1.1

วิธีการแก้ปัญหาของฉันเป็นไปตามแนวความคิดเดียวกันกับ Luis Mendo หากเขียนอ่านได้มากขึ้นรหัสจะอธิบายได้ด้วยตนเอง:

def h(a,b):
    L=[]
    i=1
    while len(L)<a+b:
        l=sum((i*[1j**(k/3)]for k in range(4,16,2)),[])
        l[0]+=1
        L+=l
        i+=1
return .9<abs(sum(L[min(a,b):max(a,b)]))<1.1

1. ฟังก์ชันhทำสิ่งต่อไปนี้:
2. รายการ L จะมีตำแหน่ง (ซับซ้อน) ของแต่ละหมายเลข
3. i คือหมายเลขแหวน
4. ใน while-loop วงแหวนใหม่จะถูกเพิ่มทุกการวนซ้ำ แทนที่จะหาจำนวนแหวนที่เราต้องการเราเพียงแค่สร้างรายการต่อไปจนกว่ามันจะยาวพอที่จะมี + b จากนั้นมันก็ยาวพอที่จะมีทั้งสองอย่าง
5. 'ring-list' lคือการเรียงต่อกันของ 6 รายการ len (i) คูณ step-vector ซึ่ง step-vector เป็น 1j ** (2/3) ต่อกำลังบางส่วน ช่วงไม่ได้เริ่มต้นที่ 0 แต่ที่ 4 ซึ่งทำให้เกิดการหมุนของตารางทั้งหมด สิ่งนี้ทำให้ฉัน:
6. l[0]+=1 ในบรรทัดที่ 6 ซึ่งเป็นขั้นตอนจากหนึ่งเสียงเรียกเข้าต่อไป
7. L+=l เชื่อมรายชื่อทั้งหมดและรายการต่อเข้าด้วยกัน
8. รายการ L มีเพียงเวกเตอร์ขั้นตอนเดียวซึ่งยังคงต้องถูกรวม (รวมไว้) เพื่อให้ได้ตำแหน่ง คุณลักษณะที่เรียบร้อยที่นี่คือเราสามารถสรุปผลรวมจากจำนวนต่ำสุดไปสูงสุดเพื่อให้ได้ระยะทาง! เนื่องจากข้อผิดพลาดของ roundoff ผลลัพธ์จะไม่เท่ากับ 1 ดังนั้น. 9 <... <1.1 ที่น่าสนใจกรณีศูนย์h(0,0)หรือ h (0,1) ได้รับการดูแลโดยปริยายเพราะผลรวมของรายการที่ว่างเปล่าเป็นศูนย์ ถ้าฉันมั่นใจได้ว่านั่นa<bคือข้อโต้แย้งจะเพิ่มมากขึ้นฉันสามารถโกนทิ้งอีก 14 ไบต์ด้วยการแทนที่L[min(a,b):max(a,b)]ด้วยL[a:b]แต่ก็ดี!

PS: ฉันไม่รู้ว่านี่เป็นความท้าทายแบบเก่ามันปรากฏตัวขึ้นเมื่อสองสามวันก่อนและจู้จี้กับฉันตั้งแต่ :)

Mathematica, 111 105 104 ไบต์

r=Floor[(1+Sqrt[(4#-1)/3])/2]&;t=Limit[Pi(#/(3x)+1-x),x->r@#]&;p=r@#*Exp[I*t@#]&;Round@Abs[p@#-p@#2]==1&

คำอธิบาย:

r=Floor[(1+Sqrt[(4#-1)/3])/2]&กำหนดฟังก์ชั่นrที่รับอินพุต#และคำนวณระยะทาง (ในจำนวนเซลล์) ไปยังเซลล์ 0 มันทำเช่นนี้โดยการหารูปแบบในเซลล์สุดท้ายของแต่ละระยะทาง / วงแหวน: 0 = 3 (0 ^ 2 + 0), 6 = 3 (1 ^ 2 + 1), 18 = 3 (2 ^ 2 + 2), 36 = 3 (3 ^ 2 + 3), ... และสลับสูตรสำหรับรูปแบบนั้น โปรดทราบว่าสำหรับเซลล์ 0 จริง ๆ แล้วใช้พื้นของ (1/2) + i * (sqrt (3) / 6) ซึ่งคำนวณส่วนประกอบที่ชาญฉลาดเพื่อรับ 0 + 0 * i = 0

ด้วยการrกำหนดr@#เป็นวงแหวนสำหรับเซลล์#(ภายในนิยามของฟังก์ชันอื่น) #+3r@#-3(r@#)^2&ไม่ปรากฏในรหัสอย่างแน่นอน แต่ใช้จำนวนเซลล์และลบจำนวนสูงสุดของเซลล์ในวงแหวนด้านในถัดไปเพื่อที่จะให้คำตอบสำหรับคำถาม "เซลล์ใดของวงแหวนปัจจุบันคืออะไร" ตัวอย่างเช่นเซลล์ 9 เป็นเซลล์ที่ 3 ของวงแหวน 2 ดังนั้นr[9]จะมีเอาต์พุต 2 และ#+3r@#-3(r@#)^2&[9]จะเป็นเอาต์พุต 3

สิ่งที่เราสามารถทำได้กับฟังก์ชั่นด้านบนคือใช้เพื่อค้นหามุมขั้ว , มุมทวนเข็มนาฬิกาจาก "เซลล์ 0, เซลล์ 17, เซลล์ 58," รังสีกับเซลล์ที่มีปัญหา เซลล์สุดท้ายของวงแหวนทุกวงจะอยู่ที่มุม Pi / 6 และเราไปรอบ ๆ วงแหวนด้วยการเพิ่มขึ้นของ Pi / (3 * ring_number) ดังนั้นในทางทฤษฎีเราจำเป็นต้องคำนวณบางสิ่งเช่น Pi / 6 + (which_cell_of_the_current_ring) * Pi / (3 * ring_number) อย่างไรก็ตามการหมุนของภาพไม่ส่งผลกระทบอะไรเลยดังนั้นเราสามารถละส่วน Pi / 6 (เพื่อบันทึก 6 ไบต์) การรวมสิ่งนี้เข้ากับสูตรก่อนหน้านี้และทำให้เราเข้าใจง่ายขึ้นPi(#/(3r@#)+1-r@#)&

น่าเสียดายที่นี่ไม่ได้กำหนดไว้สำหรับเซลล์ 0 เนื่องจากหมายเลขแหวนเป็น 0 ดังนั้นเราจึงต้องแก้ไข t=If[#==0,0,Pi(#/(3r@#)+1-r@#)]&วิธีการแก้ปัญหาธรรมชาติจะเป็นสิ่งที่ชอบ แต่เนื่องจากเราไม่สนใจมุมของเซลล์ 0 และเนื่องจากr@#ซ้ำเราจึงสามารถบันทึกไบต์ที่นี่ด้วยได้t=Limit[Pi(#/(3x)+1-x),x->r@#]&

ตอนนี้เรามีหมายเลขแหวนและมุมแล้วเราสามารถค้นหาตำแหน่งของเซลล์ (จุดศูนย์กลาง) เพื่อที่เราจะได้ทดสอบการ adjacency การค้นหาตำแหน่งที่แท้จริงนั้นน่ารำคาญเพราะวงแหวนนั้นเป็นรูปหกเหลี่ยม แต่เราสามารถแกล้งวงแหวนนั้นเป็นวงกลมที่สมบูรณ์แบบเพื่อที่เราจะรักษาหมายเลขแหวนเป็นระยะทางไปยังศูนย์กลางของเซลล์ 0 นี่จะไม่เป็นปัญหาเนื่องจากการประมาณนั้นค่อนข้างสวย ปิด. การใช้รูปแบบขั้วของจำนวนเชิงซ้อนเราสามารถแสดงตำแหน่งโดยประมาณนี้ในระนาบเชิงซ้อนด้วยฟังก์ชันง่าย ๆ :p = r@#*Exp[I*t@#] &;

ระยะห่างระหว่างจำนวนเชิงซ้อนสองจำนวนบนระนาบเชิงซ้อนนั้นกำหนดโดยค่าสัมบูรณ์ของความแตกต่างและจากนั้นเราสามารถปัดเศษผลลัพธ์เพื่อดูแลข้อผิดพลาดใด ๆ จากการประมาณและตรวจสอบว่านี่เท่ากับ 1 ฟังก์ชันที่สุดท้าย ไม่ทำงานนี้ไม่ได้มีชื่อ Round@Abs[p@#-p@#2]==1&แต่เป็น

คุณสามารถลองออนไลน์ได้ในกล่องทดลองWolfram Cloudโดยการวางโค้ดเช่นต่อไปนี้แล้วคลิก Gear -> "Evaluate cell" หรือกด Shift + Enter หรือ Enter numpad:

r=Floor[(1+Sqrt[(4#-1)/3])/2]&;t=Limit[Pi(#/(3x)+1-x),x->r@#]&;p=r@#*Exp[I*t@#]&;Round@Abs[p@#-p@#2]==1&[24,45]

หรือสำหรับกรณีทดสอบทั้งหมด:

r=Floor[(1+Sqrt[(4#-1)/3])/2]&;t=Limit[Pi(#/(3x)+1-x),x->r@#]&;p=r@#*Exp[I*t@#]&;Round@Abs[p@#-p@#2]==1&//MapThread[#,Transpose[{{0,1},{7,18},{8,22},{24,45},{40,64},{64,65},{6,57},{29,90},{21,38},{38,60},{40,63},{41,39},{40,40}}]]&