এটি গণিত সমস্যার দ্বারা অনুপ্রাণিত হয়েছিল যা আমি ইন্টারনেটে কোথাও দেখেছি কিন্তু কোথায় মনে নেই (আপডেট: মূল সমস্যাটি পাওয়া গিয়েছিল এমন একটি প্রমাণ সহ গণিতের ধাঁধাতে সাবরেডডিট পাওয়া গিয়েছিল , এটি সম্ভব কিনা, এই ম্যাথ এসই পোস্টটিও দেখুন ), জিজ্ঞাসা করে একটি প্রমাণ যদি নিম্নলিখিত প্রক্রিয়াটি কোনও যথেচ্ছ জোড় জোড়ের জন্য সম্ভব হয় (যা আমি মনে করি, এটি কোনও প্রদত্ত জোড়ার পক্ষে সম্ভব ছিল):

একজোড়া পূর্ণসংখ্যা দেওয়া, জে এবং কে, এর মধ্যে একটি দ্বিগুণ করুন এবং একটিতে অপরটি যুক্ত করুন, ফলে নতুন জোড় যুক্ত হয়, অর্থাৎ (জে, কে) -> (জে + 1, কে * 2) বা (জে * 2, কে + 1)। তারপরে এই পূর্ণসংখ্যার জোড় সমান হওয়ার লক্ষ্য নিয়ে এই প্রক্রিয়াটি পুনরায় করুন।

এই প্রদত্ত উদাহরণগুলি অপরিহার্যভাবে সর্বোত্তম নয় তবে এই প্রক্রিয়াটি কোনও পূর্ণসংখ্যার, ধনাত্মক, নেতিবাচক বা শূন্যের উপর কীভাবে করা যায় তা দেখান:

(2, 5) -> (3, 10) -> (6, 11) -> (12, 12)

(5, 6) -> (6, 12) -> (7, 24) -> (14, 25) -> (28, 26) -> (56, 27) -> (112, 28) -> (113, 56) -> (226, 57) -> (227, 114) -> (228, 228)

(0, 2) -> (1, 4) -> (2, 5) -> (3, 10) -> (6, 11) -> (12, 12)

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

(3, -1) -> (6, 0) -> (12, 1) -> (13, 2) -> (14, 4) -> (15, 8) -> (16, 16)

(-4, -3) -> (-8, -2) -> (-16, -1) -> (-32, 0) -> (-31, 0) -> ... -> (0, 0)

চ্যালেঞ্জ

একটি প্রোগ্রাম তৈরি করুন যা দুটি পূর্ণসংখ্যা দিয়েছে, বারবার একটি বাড়িয়ে এবং অন্যটিকে দ্বিগুণ করে সেই পূর্ণসংখ্যাগুলি সমান করতে প্রয়োজনীয় পদক্ষেপের তালিকা আউটপুট করে

বিশেষ উল্লেখ

সমাধানটি সর্বোত্তম হতে হবে না তবে এটি যেকোন স্বেচ্ছাসেবী জুটির জন্য সীমাবদ্ধ পদক্ষেপে সমাধান করতে হবে
ইনপুট অবশ্যই দুটি পূর্ণসংখ্যা হতে হবে
আউটপুট কোনও যুক্তিসঙ্গত আউটপুট হতে পারে যা প্রতিটি পদক্ষেপের ফলাফলের পূর্ণসংখ্যাকে স্পষ্টভাবে বোঝায়, উদাহরণস্বরূপ:
- দুটি পৃথক ডিলিমিটারের সাথে একটি স্ট্রিং (যে কোনও চিহ্ন, সাদা স্থান ইত্যাদি), একটি জোড়ের প্রতিটি পূর্ণসংখ্যার জন্য একটি এবং প্রতিটি জোড়ার জন্য একটি
  - উদাহরণস্বরূপ, ইনপুট j, k: 2, 5 -> আউটপুট: 3,10; 6,11; 12,12
- পূর্ণসংখ্যার তালিকার একটি তালিকা
  - যেমন ইনপুট j, k: 2, 5 -> আউটপুট: [[3, 10], [6, 11], [12, 12]]
যদি ইনপুটটি সমান সংখ্যার একজোড়া হয় তবে আপনি অন্য অনর্থক উত্তরের সাথে সামঞ্জস্য হওয়া অবধি কোনও কিছু আউটপুট করতে পারেন
- উদাহরণ স্বরূপ
  - যদি ইনপুট [2, 5] এর আউটপুট থাকে [[3, 10], [6, 11], [12, 12]], যা ইনপুট জোড়কে অন্তর্ভুক্ত করে না, তবে ইনপুট [4, 4] এর আউটপুট কিছুই হবে না।
  - যদি ইনপুট [2, 5] এর আউটপুট থাকে [[2, 5], [3, 10], [6, 11], [12, 12]], যাতে ইনপুট জোড় অন্তর্ভুক্ত থাকে, তবে ইনপুট [4, 4] হওয়া উচিত আউটপুট [[4, 4]]।
স্ট্যান্ডার্ড আইও পদ্ধতি প্রয়োগ করে এবং মানক লুফোলগুলি নিষিদ্ধ করা হয়
এটি কোড গল্ফ তাই বাইট জিতে সংক্ষিপ্ত উত্তর

— JMigst
সূত্র

13

এটি একটি দুর্দান্ত প্রথম চ্যালেঞ্জ, বিটিডাব্লু। পিপিসিজিতে আপনাকে স্বাগতম!

— আর্নল্ড

@ আরনাউল্ড আপনাকে ধন্যবাদ! ত্রুটিটি চিহ্নিত করার জন্য ধন্যবাদ, আমি সমস্ত উদাহরণ হাতে দিয়েছি এবং সত্যই নিজেকে প্রথমে একটি সমাধান বাস্তবায়ন করা উচিত

— JMigst

আউটপুট কি বিপরীত হতে পারে? [(12,12),(6,11),(3,10),(2,5)]ইনপুট জন্য উদাহরণস্বরূপ (2,5)?

— লাইকনি

1

@ লাইকোনি প্রয়োজনীয় সমস্ত পদক্ষেপগুলি বিবেচনা করে এখনও আউটপুট করা হয়েছে, আমি মনে করি এটি ঠিক আছে

— জেএমগস্ট

1

আমি এটি O30 এ A304027 হিসাবে যুক্ত করেছি । জুটি (34,23) বিশেষত কঠিন বলে মনে হচ্ছে।

— পিটার কেজি

10

জাভাস্ক্রিপ্ট (ES6), 111 90 83 বাইট

f=(a,b,p=q=[],u=[...p,[a,b]])=>a-b?f(...(q=[[a*2,b+1,u],[a+1,b*2,u],...q]).pop()):u

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

f = (                       // f = recursive function taking:
  a, b,                     //   (a, b) = input integers
  p =                       //   p[] = current path
  q = [],                   //   q[] = queue
  u = [...p, [a, b]]        //   u[] = updated path with [a, b] appended to it
) =>                        //
  a - b ?                   // if a is not yet equal to b:
    f(...                   //   recursive call, using spread syntax:
      (q = [                //     prepend the next 2 possible moves in the queue:
        [a * 2, b + 1, u],  //       a * 2, b + 1
        [a + 1, b * 2, u],  //       a + 1, b * 2
        ...q                //
      ]).pop()              //     use the move on the top of the queue
    )                       //   end of recursive call
  :                         // else:
    u                       //   success: return the (updated) path

— Arnauld
সূত্র

9

হাস্কেল, 70 69 বাইট

f(w@((i,j):_):r)|i==j=w|1<2=f$r++[(i+1,j*2):w,(i*2,j+1):w]
g x=f[[x]]

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

একটি সাধারণ বিএফএস জোড়া তালিকার তালিকায় পদক্ষেপগুলি ট্র্যাক করে।

g x=f[[x]]                -- start with a single list where the only
                          -- step is the starting pair
f (w@((i,j):_):r) =       -- let w be the first list of steps
                          --     (i,j) the last pair of the first list of steps
                                       ('last' as in last operated on. As we store
                                        the steps in reverse order it's the
                                        first element in the list)
                          --     r all other lists of steps
   i==j=w                 -- if i==j stop and return the first list
   1<2= f                 -- else make a recursive call
          r++             -- where the new input list is r followed by
                          -- the first list extended one time by
          [(i+1,j*2):w,         (i+1,j*2) and one time by
             (i*2,j+1):w]       (i*2,j+1)

— nimi
সূত্র

7

পাইথন 3 , 90 74 72 বাইট

-2 বাইটস ডেনিসকে ধন্যবাদ ।

def f(a,*x):j,k=a[0];return(j==k)*a or f(*x,[(2*j,k+1)]+a,[(j+1,2*k)]+a)

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

সিঙ্গেলটন তালিকা হিসাবে ইনপুট নেয় ।

Ungolfed

def f(a,*x):              # function taking at least one argument
                          # a is the first argument, all other are stored in x
  j, k = a[0]             # get the newest values of the current path
  return (j==k)*a         # if j is equal to k return the current path
                  or      # else ...
   f(                     # continue ...
     *x,                  # with the remaining paths ...
     [(2*j,k+1)]+a        # and split the current path ...
     [(j+1,2*k)]+a        # in two new ones
    )

— ovs
সূত্র

4

পাইথ, 41 বাইট

J]]QL,hhb*2ebWt{KehJ=J+tJm+hJ]d,yK_y_K)hJ

এখানে চেষ্টা করুন

ব্যাখ্যা

এটি বেশ সোজা প্রস্থের প্রথম অনুসন্ধান is সম্ভাব্য সিক্যুয়েন্সগুলির একটি সারি রাখুন ( J), এবং যতক্ষণ না আমরা কোনও মিলের জুড়ি না পেয়ে পরবর্তী সিকোয়েন্সটি গ্রহণ করি, সম্ভাব্য প্রতিটি পদক্ষেপের উপর আটকে থাকি এবং সেগুলি সারির শেষে রাখি।
বংশবৃদ্ধির স্বার্থে, আমরা একটি ক্রিয়া y(ল্যাম্বডা এক্সপ্রেশন ব্যবহার করে L) একটি চলন সম্পাদন করতে সংজ্ঞায়িত করি এবং এটি এগিয়ে এবং বিপরীত উভয়ই প্রয়োগ করি।

— স্মৃতিসংক্রান্ত
সূত্র

4

জেলি , 20 বাইট

ḃ2d2;@+*¥\
0çṪEɗ1#Ḣç

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

— ডেনিস
সূত্র

(দ্রষ্টব্য: এটি একটি 2-উপাদান তালিকার একটি [[2,5]]

— সিঙ্গলটন

4

05 এ বি 1 ই , 25 22 20 বাইট

ইনপুট হিসাবে দ্বিগুণ নেস্টেড তালিকা গ্রহণ করে এবং একটি নীড়-গভীরতায় প্রতিটি পদক্ষেপের সাথে একটি দাগযুক্ত তালিকা আউটপুট দেয়।

[ć¤Ë#¤xs>R‚ø`R‚s¸sâ«

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

ব্যাখ্যা

[                      # start a loop
 ć                     # extract the first element of the current list (current path)
  ¤Ë#                  # break if all elements in the head are equal
     ¤xs>              # duplicate one copy of the head and increment another
         R             # reverse the incremented copy
          ‚ø           # zip them together
            `R‚        # reverse the tail of the zipped list
               s¸sâ    # cartesian product with the rest of the current path
                   «   # append to the list of all current paths

— Emigna
সূত্র

4

রেটিনা , 72 বাইট

\d+
*
/\b(_+),\1\b/^+%`(_+),(_+)$
$&;_$&$2¶$=;$1$&_
G`\b(_+),\1\b
_+
$.&

এটি অনলাইন চেষ্টা করুন! অ্যানারি গণিতের সীমাবদ্ধতার কারণে মাত্র দুটি পরীক্ষার মামলা cases ব্যাখ্যা:

\d+
*

অ্যানারিতে রূপান্তর করুন।

/\b(_+),\1\b/^+

ইনপুটটিতে এক জোড়া অভিন্ন সংখ্যার উপস্থিতি নেই ...

%`(_+),(_+)%

... প্রতিটি লাইনে শেষ জোড়াটি মিলিত করুন ...

$&;_$&$2¶$=;$1$&_

... এবং রেখাকে দুটি লাইনে পরিণত করুন, প্রথমটির সংখ্যার সাথে প্রত্যয়টি প্রথম এবং দ্বিতীয় দ্বিগুণ, অন্যটির প্রত্যয়টি প্রথম সংখ্যার দ্বিগুণ এবং দ্বিতীয় বর্ধিত।

G`\b(_+),\1\b

ম্যাচিং জুটির সাথে লাইনটি রাখুন।

_+
$.&

দশমিকের দিকে ফিরে রূপান্তর করুন। 89 88-বাইট স্বাক্ষরযুক্ত দশমিক গাণিতিক সংস্করণ (0 এর সাথেও কাজ করে):

/\b(\d+),\1\b/^+%`(\d+),(\d+)$
$&;$.(_$1*),$.(2*$2*)¶$=;$.(2*$1*),$.(_$2*
G`\b(\d+),\1\b

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

— নিল
সূত্র

4

এমএটিএল , 24 বাইট

`vxG1r/q:"tt1rEk(+]td0=~

চলমান সময় এলোমেলো, তবে এটি সম্ভাব্যতা 1 দিয়ে সীমাবদ্ধ।

কোডটি খুব অদক্ষ। 4 বা 5 টিরও বেশি পদক্ষেপের জন্য ইনপুটগুলির অনলাইন দোভাষীগুলিতে সময় নির্ধারণের বড় সম্ভাবনা থাকে।

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

ব্যাখ্যা

`         % Do...while
  vx      %   Concatenate stack and delete. This clears the stack from contents
          %   of previous iterations   
  G       %   Push input
  1       %   Push 1
  r       %   Push random number uniformly distributed on (0,1)
  /       %   Divide
  q       %   Subtract 1. The result is a random number, t, that has nonzero
          %   probability of being arbitrarily large. Specifically, t is in
          %   the interval (0,1) with probability 1/2; in (1,2) with probability
          %   1/6; ... in (k,k+1) with probability 1/((k+1)*(k+2).
  :       %   Range [1 2 ... floor(t)]
  "       %   For each (that is: do thw following floor(t) times)
    tt    %     Duplicate twice
    1     %     Push 1
    rEk   %     Random number in (0,1), times 2, round down. This produces a 
          %     number i that equals 0 or 1 with probability 1/2
    (     %     Write 1 at entry i. So if the top of the stack is [a b], this
          %     transforms it into either [1 b] or [a 1]
    +     %     Add, element-wise. This gives either [a+1 2*b] or [2*a b+1] 
  ]       %   End for each
  td      %   Duplicate, consecutive difference between the two entries
  0=~     %   Is it not zero? If so, the do...while loop continues with a new
          %   iteration. Normally the code 0=~ could be omitted, because a
          %   nonzero consecutive difference is truthy. But for large t the
          %   numbers a, b may have gone to infinity, and then the consecutive
          %   difference gives NaN
          % End do...while (implicit). Display (implicit)

— লুইস মেন্ডো
সূত্র

3

স্ট্যাক্স , 29 26 বাইট

ä⌠|Tô&cm♂NV↓↔╗╣¢♠╜╒█¡Φ≈ñY@

এটি চালান এবং এটি ডিবাগ করুন

এটি প্রথম প্রস্থের অনুসন্ধান। এটি যুক্তিসঙ্গতভাবে দ্রুত বলে মনে হচ্ছে।

এটিতে দ্বিগুণ-অ্যারে-মোড়ানো সংখ্যার পূর্ণসংখ্যা লাগে। আউটপুট মানগুলির একটি স্থান বিভাজিত তালিকা। প্রতিটি দুটি মান সমাধানের পথে একজোড়া প্রতিনিধিত্ব করে।

— রিকার্সিভ
সূত্র

2

হাস্কেল , 95 বাইট

g s|a:_<-[a|a@((x,y):_)<-s,x==y]=a
g s=g$do a@((x,y):_)<-s;[(x*2,y+1):a,(x+1,y*2):a]
h t=g[[t]]

এটি অনলাইন চেষ্টা করুন! বিপরীত ক্রমে আউটপুট, যেমন h(2,5)ফলন [(12,12),(6,11),(3,10),(2,5)]।

— Laikoni
সূত্র

2

লাল , 142 বাইট

লাল এর ফর্ম্যাটে (2, 5)-> বিন্যাসে জোড়ের জোড়ের দ্বিগুণ নেস্টেড ব্লক হিসাবে ইনপুট নেয়2x5

উদাহরণস্বরূপ, লাল জোড়গুলির তালিকা হিসাবে ফলাফলটি দেখায় 2x5 3x10 6x11 12x12। প্রাথমিক জুটি অন্তর্ভুক্ত।

func[c][a: copy[]foreach d c[l: last d if l/1 = l/2[return d]do replace/all{%+ 1x0 * 1x2
%* 2x1 + 0x1}"%""append/only a append copy d l "]f a]

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

কঠোর ইনপুট:

উদাহরণস্বরূপ ইনপুট দুটি সংখ্যা 2 5

লাল , 214 বাইট

func[a b][g: func[c][a: copy[]foreach d c[l: last d if l/1 = l/2[return d]append/only a append copy d l + 1x0 * 1x2
append/only a append copy d l * 2x1 + 0x1]g a]c: copy[]insert/only c reduce[do rejoin[a 'x b]]g c]

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

ব্যাখ্যা:

f: func[a b][                 
g: func[c][                                   ; recursive helper function
  a: copy[]                                   ; an empty block
  foreach d c[                                ; for each block of the input 
    l: last d                                 ; take the last pair
    if l/1 = l/2[return d]                    ; if the numbers are equal, return the block 
    append/only a append copy d l + 1x0 * 1x2 ; in place of each block append two blocks
    append/only a append copy d l * 2x1 + 0x1 ; (j+1, k*2) and (j*2, k+1)
  ]                                           ; using Red's arithmetic on pairs
  g a                                         ; calls the function anew
]
c: copy[]insert/only c reduce[do rejoin[a 'x b]]; prepares a nested block from the input
g c                                           ; calls the recursive function 
]

— গ্যালেন ইভানভ
সূত্র

সমতাতে একজোড়া পূর্ণসংখ্যা আনয়ন

চ্যালেঞ্জ

বিশেষ উল্লেখ

জাভাস্ক্রিপ্ট (ES6), 111 90 83 বাইট

মন্তব্য

হাস্কেল, 70 69 বাইট

পাইথন 3 , 90 74 72 বাইট

Ungolfed

পাইথ, 41 বাইট

ব্যাখ্যা

জেলি , 20 বাইট

05 এ বি 1 ই , 25 22 20 বাইট

রেটিনা , 72 বাইট

এমএটিএল , 24 বাইট

ব্যাখ্যা

স্ট্যাক্স , 29 26 বাইট

হাস্কেল , 95 বাইট

লাল , 142 বাইট

কঠোর ইনপুট:

লাল , 214 বাইট

ব্যাখ্যা: