हेक्सागोनल आसन्न

Question

उपरोक्त छवि हेक्सागोन्स के एक हेक्सागोनल ग्रिड को प्रदर्शित करती है। ग्रिड में प्रत्येक सेल को एक सूचकांक सौंपा जाता है, जो केंद्र से शुरू होता है और दिखाए अनुसार चारों ओर वामावर्त घूमता है। ध्यान दें कि ग्रिड अनिश्चित काल तक जारी रहेगा - उपरोक्त चित्र केवल पहला खंड है। अगला षट्भुज 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

यह कोड-गोल्फ है इसलिए बाइट्स जीत में सबसे छोटा जवाब है। गैर-गूढ़ भाषाओं के लिए भी स्पष्टीकरण को प्रोत्साहित किया जाता है।

Answer 1

अमृत , 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

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

ungolfed संस्करण

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-6 के लिए 1, 7-18 के लिए 2, आदि।

यह केवल तभी लागू होता है जब परिणाम floorएड होता है। अनुगामी अंक यह दर्शाता है कि रिंग के चारों ओर कितनी दूर टाइल है।

inv_get_ring (रिंग)

के व्युत्क्रम की गणना करता है get_ring(index)।

ring_base (रिंग)

अंगूठी में पहली टाइल के सूचकांक की गणना करता है।

is_corner (इंडेक्स)

कोनों ऐसी टाइलें होती हैं जिनमें बाहरी रिंग में तीन सहायक टाइलें होती हैं। अंतरतम रिंग में पूरी तरह से कोने होते हैं।

उदाहरण: 21,24,27,30,33,36

is_last (इंडेक्स)

सच है अगर यह सूचकांक अपनी अंगूठी में सबसे अधिक है।

is_first (इंडेक्स)

सही है अगर यह रिंग का बेस-टाइल है।

Comments

मैंने किनारे-केस को ठीक करने के लिए उत्तर को संपादित किया है :)

— गरुणो

मैंने पुनरावृत्तियों के माध्यम से पहले आपके गोल्फ संस्करण का अनुसरण किया लेकिन फिर ऐसा लगा कि आपने अपना दृष्टिकोण बदल दिया है। क्या आपका वर्तमान गोल्फ संस्करण अभी भी अन-गोल्ड संस्करण के बराबर है?

— जॉन माइकल लॉ

हाँ यही है! मैंने अभी-अभी सीखा कि आप एलिक्जिर में वैरिएबल इनलाइन घोषित कर सकते हैं। इससे मुझे कोड की शुरुआत में लंबोदर कार्यों से छुटकारा पाने की क्षमता मिली। मैं बस थोड़ा और अधिक कुशल होने के लिए, चर को थोड़ा फेरबदल करता हूं।

— गरुणो

Answer 2

MATL , 47 45 44 43 41 बाइट्स

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

इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें ।

एक बोनस के रूप में, कोड एक हेक्सागोनल सर्पिल उत्पन्न करता है जो सेल केंद्रों की स्थिति का पता लगाता है, जिसे कोड के अंतिम भाग को संशोधित करके MATL ऑनलाइन पर देखा जा सकता है ।

व्याख्या

सामान्य विचार    कोड पहले इकाई चरण के साथ एक पर्याप्त बड़े हेक्सागोनल सर्पिल बनाता है। सर्पिल को सेल केंद्रों की स्थिति का प्रतिनिधित्व करने वाले जटिल संख्या के वेक्टर के रूप में परिभाषित किया गया है। इनपुट नंबरों के साथ उस वेक्टर में अनुक्रमण करना और निरपेक्ष अंतर की गणना करना दो संकेतित कोशिकाओं के बीच की दूरी देता है। यदि परिणाम 1 ही है तो कोशिकाएं आसन्न हैं। हालांकि, फ्लोटिंग पॉइंट अशुद्धियों के कारण, 1 के साथ तुलना करने से पहले गोलाई आवश्यक है।

सर्पिल    का निर्माण सर्पिल में दो परतों के योग के बराबर "परतें" होंगी। यह आवश्यकता से अधिक (बहुत) है, और यह सुनिश्चित करता है कि इनपुट कोशिकाएं सर्पिल में मौजूद होंगी।

सर्पिल का निर्माण करने के लिए, जटिल संख्या जे ^2/3 (जहां जे काल्पनिक इकाई है) को पहले गणना की जाती है। 6 के माध्यम से 1 को घातांक तक उठाना, विस्थापन का एक मूल सेट देता है, जैसे कि उन विस्थापनों का क्रम में एक षट्भुज का पता लगाना। यह षट्भुज सर्पिल की सबसे भीतरी परत का निर्माण करेगा, सिवाय इसके कि यह "बंद" होगा। असल में, हम चाहते हैं कि हेक्सागोन अंतिम चरण में "विकसित" हो और फिर हम एक बड़े षट्भुज का पता लगाते हैं, जिसमें दो बार कई बिंदुओं (दो के समूहों में संरेखित), सर्पिल की अगली परत बनाने के लिए; चित्रण यहाँ देखें । अगली परत में पहले (तीन के समूहों में) के रूप में कई बिंदु होंगे; यहाँ देखें ।

ऐसा करने के लिए, मूल सेट (जो दक्षिण-पूर्व दिशा में इंगित करता है) से पांचवें विस्थापन को "बढ़ते" कदम के रूप में चुना जाता है। लेयर k की शुरुआत उस स्टेप से होती है, उसके बाद पहले पाँच बेसिक स्टेप्स को k बार दोहराया जाता है, उसके बाद छठे स्टेप (पूर्व दिशा) को k repeated1 बार दोहराया जाता है । उपरोक्त लिंक किए गए दो आंकड़ों को देखकर यह उम्मीद साफ हो जाती है।

सभी परतों सहित परिणामी वेक्टर, जटिल विस्थापन का प्रतिनिधित्व करता है जो सर्पिल का पता लगाएगा। संचयी योग कोशिका केंद्रों के वास्तविक निर्देशांक देता है।

अंत में, प्रारंभिक सेल, 0 पर स्थित है, इस वेक्टर के अंत से जुड़ा हुआ है । ऐसा इसलिए है क्योंकि MATL 1-आधारित अनुक्रमणिका का उपयोग करता है, और अनुक्रमणिका 0 एक सरणी के अंतिम प्रविष्टि को संदर्भित करता है ।

निकटता के लिए परीक्षण    इनपुट संख्याओं द्वारा दी गई दो कोशिकाओं को चुना जाता है, उनके निर्देशांक घटाए जाते हैं, और निरपेक्ष मान को गोल किया जाता है और 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

Comments

क्या आप एक स्पष्टीकरण जोड़ सकते हैं?

— झबरा

@ शैगी मैंने एक सामान्य स्पष्टीकरण जोड़ा। मुझे बताएं कि क्या यह स्पष्ट है (यह समझाना मुश्किल है)। मैं बाद में टिप्पणी कोड जोड़ दूंगा

— लुइस मेंडू

Answer 3

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 घंटे बर्बाद किए। संक्षेप में, मैंने इनपुट्स का 2d ग्राफ बनाना शुरू किया, और ड्रा किया Xजहां वे एक-दूसरे के निकट थे। तब मुझे एक पैटर्न मिला। मैंने इसे OEIS और बिंगो पर खोजा ! मुझे वह अनुक्रम मिला और मैंने वेबसाइट पर दिए गए सूत्र का उपयोग किया।

Answer 4

सी (जीसीसी) , 175 173 बाइट्स

बग पकड़ने के लिए पीटर टेलर का शुक्रिया ।

छत के लिए धन्यवाद -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 _{इंडेक्स} = C - L _{स्टार्ट मिलता है} ।

अगला, हम देखते हैं कि प्रत्येक परत में छह खंड शामिल हैं, प्रत्येक की लंबाई एल। उत्तर-पूर्व में शुरू होती है और काउंटर-क्लॉकवाइज होती है, हम देखते हैं कि पहले दो खंडों के लिए (1 <= L _{सूचकांक} <= 2 * L) , हम एल - एल _{इंडेक्स} से कॉलम प्राप्त करते हैं । अगले भाग L * 2 <L _{इंडेक्स} <= L * 3 में सभी सेल एक एकल कॉलम -L साझा करते हैं। दो अगले खंड L * 3 <L _{इंडेक्स} <= L * 5 हैं जिनके कॉलम L _{इंडेक्स} - L * के अनुसार हैं । 4. और अंतिम रूप से छठे सेक्शन में कॉलम L पर इसकी कोशिकाएँ हैं। हम ऊपरी सीमा को एक चरण में स्थानांतरित कर सकते हैं। कोड में कुछ बाइट्स को बचाने के लिए।

तो फिर पंक्तियों का क्या? कोड का पुन: उपयोग करने के लिए, हम ग्रिड को चालू करते हैं ताकि सेल 44 सीधा हो। फिर हम उसी तर्क को स्तंभों के लिए चलाते हैं लेकिन इस बार परिणामों को "पंक्तियों" के रूप में कहते हैं। बेशक, वास्तव में एक ग्रिड को मोड़ने के बजाय, हम बस इसके चारों ओर एक गोद के 1/6 चलते हैं।

Comments

@PeterTaylor अच्छा पकड़, धन्यवाद!

— गैस्ट्रोपनर

Answer 5

पायथन 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

मेरा समाधान मूल रूप से लुइस मेंडो के ऊपर विचार की एक ही पंक्ति का अनुसरण करता है। यदि अधिक पठनीय लिखा जाता है, तो कोड बहुत आत्म-व्याख्यात्मक है:

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. जबकि-लूप में, प्रत्येक पुनरावृत्ति में एक नया वलय जोड़ा जाता है। यह पता लगाने के बजाय कि हमें कितने छल्ले चाहिए, हम बस सूची बनाना जारी रखते हैं जब तक कि यह + b शामिल करने के लिए पर्याप्त लंबा न हो, तो निश्चित रूप से उनमें से किसी एक को शामिल करने के लिए पर्याप्त लंबा है।
5. 'रिंग-लिस्ट' l, चरण-सदिश काल के 6 सूचियों का एक संयोजन है, जहाँ चरण-सदिश 1j ** (2/3) कुछ शक्ति है। सीमा 0 से शुरू नहीं होती है लेकिन 4 पर होती है, जो पूरे ग्रिड के रोटेशन का कारण बनती है। यह मुझे करने की अनुमति देता है:
6. l[0]+=1 पंक्ति 6 ​​में, जो कि एक रिंग से दूसरी रिंग तक है।
7. L+=l संपूर्ण सूची और रिंग-सूची को संक्षिप्त करता है।
8. सूची L में केवल चरण वैक्टर होते हैं, जिन्हें अभी भी स्थिति प्राप्त करने के लिए सम्‍मिलित (एकीकृत) किया जाना चाहिए। यहाँ एक साफ-सुथरी विशेषता यह है कि हम सिर्फ स्लाइस का योग कर सकते हैं दूरी पाने के लिए सबसे कम संख्या से सबसे अधिक ! राउंडऑफ़ त्रुटियों के कारण, परिणाम ठीक 1 नहीं होगा, इसलिए .9 <... <1.1। दिलचस्प बात यह है कि शून्य मामले h(0,0)या एच (0,1) का ध्यान रखा जाता है, क्योंकि खाली सूची का योग शून्य है। मुझे यकीन है कि हो सकता है a<b, यानी तर्क बढ़ते क्रम में आते हैं, मैं की जगह एक और 14 बाइट्स बंद दाढ़ी सकता है L[min(a,b):max(a,b)]के साथ L[a:b]है, लेकिन अफसोस!

पुनश्च: मुझे नहीं पता था कि यह इतनी पुरानी चुनौती थी, यह कुछ दिन पहले शीर्ष पर दिखा, और मेरे बाद से मुझ पर नाज करता रहा :)

Comments

यह एक महान जवाब है! देर से जवाब के बारे में चिंता न करें, हमारे पास पीपीसीजी पर यहाँ कोई समस्या नहीं है।

— Rɪᴋᴇʀ

Answer 6

गणितज्ञ, 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 = 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 रिंग 2 की तीसरी सेल है, इसलिए r[9]2 और आउटपुट होगा#+3r@#-3(r@#)^2&[9] आउटपुट 3 होगा।

ऊपर के फ़ंक्शन के साथ हम क्या कर सकते हैं इसका उपयोग ध्रुवीय कोण खोजने के लिए किया जाता है , काउंटर-क्लॉकवाइज कोण "सेल 0, सेल 17, सेल 58" किरण से सेल में प्रश्न पूछने के लिए किया जाता है। हर रिंग की आखिरी सेल हमेशा कोण Pi / 6 पर होती है, और हम Pi / / (3 * ring_number) की वृद्धि में एक अंगूठी के चारों ओर जाते हैं। तो, सिद्धांत रूप में, हमें पाई / 6 + (who_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@#]&

अब जब हमारे पास रिंग नंबर और कोण है, तो हम एक सेल (केंद्र) की स्थिति का पता लगा सकते हैं ताकि हम आसन्नता के लिए परीक्षण कर सकें। वास्तविक स्थिति का पता लगाना कष्टप्रद है क्योंकि रिंग्स हेक्सागोनल हैं, लेकिन हम केवल यह कह सकते हैं कि रिंग्स सही सर्कल हैं ताकि हम रिंग नंबर को सेल के केंद्र की दूरी के रूप में मानें। 0. यह एक समस्या नहीं होगी क्योंकि सन्निकटन सुंदर है बंद करे। एक जटिल संख्या के ध्रुवीय रूप का उपयोग करते हुए , हम एक साधारण फ़ंक्शन के साथ जटिल विमान में इस अनुमानित स्थिति का प्रतिनिधित्व कर सकते हैं :p = r@#*Exp[I*t@#] &;

जटिल विमान पर दो जटिल संख्याओं के बीच की दूरी उनके अंतर के निरपेक्ष मान द्वारा दी गई है , और फिर हम सन्निकटन से किसी भी त्रुटि का ध्यान रखने के लिए परिणाम को गोल कर सकते हैं, और जांच सकते हैं कि यह 1 के बराबर है। अंत में फ़ंक्शन क्या इस काम में नाम नहीं है, लेकिन है Round@Abs[p@#-p@#2]==1&।

---

आप निम्न और क्लिक गियर की तरह कोड चिपकाकर वुल्फराम क्लाउड सैंडबॉक्स में इसे ऑनलाइन आज़मा सकते हैं -> "सेल का मूल्यांकन करें" या Shift + 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}}]]&