मशाल पर चक्र

Question

चुनौती

यह चुनौती आप एक प्रोग्राम है जो दो पूर्णांकों में लेता है लिखना होगा nऔर mऔर पर संख्या को न काटने छोरों आउटपुट nद्वारा mपर शुरू द्वारा किए गए फूल की कुर्सी (0,0)और केवल कदम उठा ऊपर और सही करने के लिए। आप टॉप और नीचे और दोनों तरफ रैपराउंड के साथ ग्रिड के रूप में टोरस के बारे में सोच सकते हैं ।

यह कोड-गोल्फ है इसलिए सबसे कम बाइट जीतती है।

उदाहरण

उदाहरण के लिए, यदि इनपुट है n=m=5, तो एक वैध चलना है

(0,0) -> (0,1) -> (0,2) -> (1,2) -> (2,2) -> (2,3) -> (2,4) -> 
(2,0) -> (3,0) -> (4,0) -> (4,1) -> (4,2) -> (4,3) -> 
(0,3) -> (1,3) -> (1,4) -> 
(1,0) -> (1,1) -> (2,1) -> (3,1) -> (3,2) -> (3,3) -> (3,4) -> (4,4) -> 
(0,4) -> (0,0)

जैसा कि ग्राफिक में दिखाया गया है।

कुछ उदाहरण इनपुट / आउटपुट

f(1,1) = 2 (up or right)
f(1,2) = 2 (up or right-right)
f(2,2) = 4 (up-up, up-right-up-right, right-right, right-up-right-up)
f(2,3) = 7
f(3,3) = 22
f(2,4) = 13
f(3,4) = 66
f(4,4) = 258

Comments

मैं शर्त लगाने के लिए तैयार था कि यह अनुक्रम कम से कम लिए OEIS पर था , लेकिन जाहिर है कि यह (अभी तक) नहीं है। $m=n$

— अरनुलद

मुझे लगता है कि एक टोरस में एक बाएं-दाएं आवरण भी होता है। क्या हमें यह मान लेना चाहिए कि इसके बजाय केवल अप-डाउन रैपराउंड है? उदाहरण छवि का अर्थ ऐसा प्रतीत नहीं होता है।

— निकले आउटगॉल्फ

@EriktheOutgolfer छवि नारंगी पथ को दाईं से बाईं ओर लपेटती हुई दिखाती है, है ना?

— Arnauld

@Arnauld हाँ, लेकिन यह चुनौती के विवरण के अनुरूप नहीं है ("आप शीर्ष और निचले दोनों

— तरफ रैपराउंड के

@EriktheOutgolfer यह सच है। और अब जब आप इसका उल्लेख करते हैं, तो नीला रास्ता गलत है। इसे पहले दाएं से बाएं और फिर ऊपर से नीचे की ओर लपेटना चाहिए।

— Arnauld

Answer 1

जेली , 28 बाइट्स

ạƝ§=1Ȧ
²‘p/’ŒPÇƇḢÐṂ%⁸QƑƇṪÐṂL

एक मोनडिक लिंक एक सूची को स्वीकार करता है [m,n], जो गिनती की पैदावार देता है।

TIO-jt1qe1v9 ... हालांकि थोड़ा बिंदु है, यह बहुत अक्षम है।
(मैं भी नहीं चला सकता[2,3] 16 जीबी रैम के साथ स्थानीय रूप से )!

कैसे?

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

ạƝ§=1Ȧ - Link 1: all neighbours differ by 1 in exactly one direction
 Ɲ     - for neighbours:
ạ      -   absolute difference
  §    - sum each
   =1  - equal to one (vectorises)
     Ȧ - any and all? (falsey if empty or contains a falsey value when flattened)

²‘p/’ŒPÇƇḢÐṂ%⁸QƑƇṪÐṂL - Main Link: list of integers, [m,n]
²                     - square (vectorises) -> [m*m, n*n]
 ‘                    - increment (vectorises) -> [m*m+1, n*n+1]
   /                  - reduce with:
  p                   -   Cartesian product
    ’                 - decrement (vectorises) -> all the coordinates of an m*m by n*n grid
                      -                           including [0, 0] and [m*m, n*n] 
     ŒP               - power-set -> all paths going either up OR right at each step, but not
                      -              necessarily by only 1, and
                      -              necessarily both up and right (e.g. [...[1,3],[5,7],[6,2],...])
        Ƈ             - filter keep those for which:
       Ç              -   call last Link (1) as a monad
                      -              ...now all remaining paths do only go in steps
                      -              of one up or one right
          ÐṂ          - filter keep those minimal under:
         Ḣ            -   head - removes the 1st coordinate from each and yields them for the filter
                      -          ...so only those which started at [0,0] but without it
            %⁸        - modulo by the left argument ([m,n]) (vectorises)
                Ƈ     - filter keep those for which:
               Ƒ      -   is invariant when:
              Q       -     de-duplicated
                      -          ...so no repetitions of torus coordinates (and we already removed
                      -          the first [0,0] which must be present exactly twice)
                  ÐṂ  - filter keep those minimal under:
                 Ṫ    -   tail
                      -          ...so only those which ended at [0,0] 
                    L - length

Answer 2

पायथन 2 , 87 बाइट्स

f=lambda m,n,z=0,l=[]:z==0if z in l else sum(f(m,n,(z+d)%m%(n*1j),l+[z])for d in(1,1j))

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

यहां दिलचस्प बात यह है zकि वर्तमान स्थिति के समन्वय को संग्रहीत करने के लिए एक जटिल संख्या का उपयोग किया जाता है । हम जोड़कर आगे बढ़ सकते हैं 1और सही जोड़कर आगे बढ़ सकते हैं 1j। मेरे आश्चर्य के लिए, मोडुलो जटिल संख्याओं पर काम करता है जो हमें प्रत्येक आयाम के लिए अलग से लपेटने की सुविधा देता है: %mवास्तविक हिस्से %(n*1j)पर कार्य करता है , और काल्पनिक भाग पर कार्य करता है।

Comments

अच्छी तरह से किया। FWIW, एक जटिल संख्या का उपयोग किए बिना मेरा सबसे अच्छा प्रयास पायथन 3.8 में 91 बाइट्स है।

— अरनुलद

@ अरनल्ड के साथ दिलचस्प विचार k:=x+y*m। यह मुझे आश्चर्य है कि अगर इसका इस्तेमाल करने में कम होगा बनाता है kके लिए सीधे (x,y), का उपयोग कर x+y*mके बजाय x+y*1j। बहुत बुरा अजगर 3 जटिल मापांक की अनुमति नहीं देता है।

— xnor

@Arnauld 87 बाइट्स: tio.run/##XckxDoIwFIDh3VN0wfTRR0JbBkMsJ@ASGGkry0NspgYC14HDHHf/…

— xnor

यह दृष्टिकोण JS में 5 बाइट्स बचाता है। :)

— अरनौलद

Answer 3

जावास्क्रिप्ट (ईएस 6), 67 बाइट्स

$m\times n<32$

के रूप में इनपुट लेता है (m)(n)।

m=>n=>(g=(k,l)=>l>>k&1?!k:g((k+m)%(m*n),l|=1<<k)+g(k-~k%m-k%m,l))``

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

इसे किसी भी इनपुट के लिए काम करने के लिए, हम BigInts को 73 बाइट्स के लिए उपयोग कर सकते हैं :

m=>n=>(g=(k,l=k)=>l&(b=1n<<k)?!k:g((k+m)%(m*n),l|=b)+g(k-~k%m-k%m,l))(0n)

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

---

जावास्क्रिप्ट (ईएस 6),  76 73  72 बाइट्स

के रूप में इनपुट लेता है (m)(n)।

m=>n=>(g=(x,y)=>g[x+=y*m]?!x:g(-~x%m,y,g[x]=1)+g(x%m,-~y%n)+--g[x])(0,0)

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

टिप्पणी की गई

m => n => (         // m = width; n = height
  g = (             // g is a recursive function taking:
        x, y        //   the current coordinates (x, y) on the torus
      ) =>          //
    g[              // the surrounding object of g is also used for storage
      x += y * m    // turn x into a key for the current coordinates
    ] ?             // if this cell was already visited:
      !x            //   return 1 if we're back to (0, 0), or 0 otherwise
    :               // else:
      g(            //   first recursive call:
        -~x % m,    //     move to the right
        y,          //     leave y unchanged
        g[x] = 1    //     mark the current cell as visited by setting the flag g[x]
      ) +           //   add the result of
      g(            //   a second recursive call:
        x % m,      //     restore x in [0...m-1]
        -~y % n     //     move up
      ) +           //
      --g[x]        //   clear the flag on the current cell
)(0, 0)             // initial call to g with (x, y) = (0, 0)

Answer 4

हास्केल, 88 80 बाइट्स

n#m|let(x!y)a|elem(x,y)a=0^(x+y)|b<-(x,y):a=(mod(x+1)n!y)b+(x!mod(y+1)m)b=0!0$[]

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

सरल जानवर बल: सभी अप / राइट संयोजनों का प्रयास करें, जो कि प्रतिच्छेदन (हम सभी पदों को हमने सूची में रखा है a) को छोड़ते हैं और उन लोगों को गिनते हैं जो अंततः सकारात्मकता को मारते हैं (0,0)।

पुनरावृत्ति का आधार मामला तब होता है जब हम किसी स्थिति (दूसरी बार elem(x,y)a) पर जाते हैं। परिणाम 0^0= है, 1जब स्थिति है (0,0)और छोरों की संख्या की ओर गिना जाता है 0( या 0^x, xगैर-शून्य के साथ) अन्यथा और छोरों की संख्या में वृद्धि नहीं करता है।

संपादित करें: -8 बाइट्स @xnor के लिए धन्यवाद।

Comments

आधार मामलों को संयुक्त किया जा सकता है |elem(x,y)a=0^(x+y), और (0!0)[]हो सकता है 0!0$[]।

— xnor

Answer 5

जेली , 44 बाइट्स

×ƝṪ2*Ḥ_2Rḃ€2ċⱮؽ%³¬ẠƲƇịØ.Ṛ,Ø.¤ZÄZ%€ʋ€³ŒQẠ$€S

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

$O({2^m}^n)$

$mn$

Answer 6

जावा 8, 120 बाइट्स

n->m->g(n,m,0,0);int g(int n,int m,int k,int l){return(l>>k)%2>0?k<1?1:0:g(n,m,(k+m)%(m*n),l|=1<<k)+g(n,m,k-~k%m-k%m,l);}

$n*m<32$ ।

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

Answer 7

CJam (50 वर्ण)

q~]:M:!a{9Yb2/\f{_W=@.+M.%a+_)a#g"WAR"=~}}:R~e_We=

ऑनलाइन डेमो । यह एक प्रोग्राम है जो स्टडिन से दो इनपुट लेता है।

अंत में हमारे पास प्रश्न का उत्तर है

युद्ध, हुह, यह किसके लिए अच्छा है?

---

विच्छेदन

q~]:M        e# Parse input, collect in array, store in M (for moduli)
:!a          e# Zero and wrap in array for starting position (0, 0)
{            e# Define recursive block R
  9Yb2/      e#   Push [[1 0][0 1]], an array of movements
  \f{        e#   For each of those movements, with the current path,
    _W=@.+   e#     Add the movement to the last position in the path
    M.%      e#     Apply the wrapping
    a+       e#     Add to one copy of the path
    _)a#     e#     And find its index in another copy
    g"WAR"=~ e#     Switch on the sign of the index:
             e#       If the sign is -1, position not found, make a recursive call
             e#       If the sign is 0, found at start, push -1 to the stack
             e#       If the sign is 1, we have a self-intersection. We push 10 to
             e#       the stack for no other reason than to make the bad joke above
  }
}:R
~            e# Execute R
e_We=        e# Count the -1s which we pushed as sentinels

Answer 8

जेली , 54 39 बाइट्स

ḣ2æ.2ị³¤+4
‘Ç;¥¦%³Ç=4ƊÑÇị$?
çⱮؽS
’Ñ0xÇ

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

मैंने इसे अपने अन्य जेली एक के लिए एक अलग उत्तर के रूप में पोस्ट किया है क्योंकि यह पूरी तरह से अलग विधि है। यह @ अरनुलद के उत्तर के सिद्धांत के करीब है। यह एक पुनरावर्ती फ़ंक्शन का उपयोग करता है जो तब तक हर संभव पथ के माध्यम से काम करता है जब तक कि यह उस बिंदु तक नहीं पहुंचता जो इसे पहले ही मिल चुका है, और फिर एक चेक का परिणाम देता है कि क्या यह शुरू में वापस आ गया है। मुझे संदेह है कि कुछ और बाइट्स का मुंडन किया जा सकता है। अब स्लाइस ऑपरेटर का उपयोग करने के लिए बदल दिया गया है। यह 5x5 तक अच्छा काम करता है। पुनरावृत्ति की गहराई अधिकतम mx n पर होनी चाहिए।