টরাস উপর চক্র

Question

চ্যালেঞ্জ

এই চ্যালেঞ্জটি আপনাকে এমন একটি প্রোগ্রাম লিখতে দেবে যা দুটি পূর্ণসংখ্যার জন্য গ্রহণ করে nএবং টরাস দ্বারা টরাস দ্বারা শুরু করা এবং কেবল পদক্ষেপ এবং ডানদিকে নিয়ে mঅ-ছেদযুক্ত সংখ্যাটি আউটপুট করে । আপনি টরাসকে উপরের এবং নীচে এবং উভয় দিকের মোড়ক সমেত গ্রিড হিসাবে ভাবতে পারেন ।nm(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

আমি বাজি রাখতে ইচ্ছুক ছিলাম যে এই সিকোয়েনসটি কমপক্ষে জন্য ওইআইএসে ছিল , তবে দৃশ্যত এটি এখনও হয়নি (এখনও)। $m=n$

— আর্নৌল্ড

আমি মনে করি যে একটি টরাসের বাম-ডান মোড়ক রয়েছে। আমাদের কি ধরে নেওয়া উচিত যে এটির পরিবর্তে এটি কেবল কেবলমাত্র ডাউন-র্যাপআরআউন্ডে আছে? উদাহরণ চিত্রটি এর মতো বোঝায় না।

— এরিক আউটগল্ফার

@ এরিকথ আউটগল্ফার চিত্রটি কমলা পথটি ডান থেকে বাম দিকে মোড়ানো দেখায়, তাই না?

— আর্নৌল্ড

@ আর্নল্ড হ্যাঁ, তবে এটি চ্যালেঞ্জের বর্ণনার সাথে সামঞ্জস্যপূর্ণ বলে মনে হচ্ছে না ("আপনি টরাসকে উপরের এবং নীচে উভয়

— অংশের মোড়ক

পছন্দ করুন এবং এখন আপনি এটি উল্লেখ করেছেন, নীল পথটি ভুল। এটি প্রথমে ডান থেকে বাম এবং তারপরে উপরে থেকে নীচে মোড়ক দেওয়া উচিত।

— আর্নৌল্ড

Answer 1

জেলি , 28 বাইট

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

একটি তালিকা লিঙ্ক গ্রহণ করে [m,n], যা গণনা দেয় yield

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

সুন্দরভাবে সম্পন্ন. এফডাব্লুআইডাব্লু, একটি জটিল সংখ্যা ব্যবহার না করে আমার সেরা প্রয়াস পাইথন ৩.৮-তে 91 বাইট ।

— আর্নল্ড

@ আরনাউল্ড এর সাথে আকর্ষণীয় ধারণা k:=x+y*m। এটা আমার ভাবছি যদি এটি ব্যবহার করতে খাটো হবে তোলে kজন্য সরাসরি (x,y)ব্যবহার x+y*mবদলে x+y*1j। খুব খারাপ পাইথন 3 জটিল মডুলাসের অনুমতি দেয় না।

— xnor

@

— আর্নল্ড

এই পদ্ধতির জেএসে 5 বাইট সাশ্রয় হয়। :)

— আরনাউল্ড

Answer 3

জাভাস্ক্রিপ্ট (ES6), 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))``

এটি অনলাইন চেষ্টা করুন!

এটি কোনও ইনপুটটির জন্য কাজ করতে, আমরা by৩ বাইটের জন্য বিগআইন্টস ব্যবহার করতে পারি :

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)

এটি অনলাইন চেষ্টা করুন!

---

জাভাস্ক্রিপ্ট (ES6),  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)এবং loops বা সংখ্যা প্রতি গন্য 0( 0^xসঙ্গে xনন-জিরো) অন্যথায় এবং loops সংখ্যা বাড়ে না।

সম্পাদনা: -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

সিজেএম (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 পর্যন্ত ভাল কাজ করে। পুনরাবৃত্তির গভীরতা সর্বাধিক এমএক্স এন হওয়া উচিত।