यह एक ऐसी गणितीय समस्या से प्रेरित था जिसे मैंने इंटरनेट पर कहीं देखा था लेकिन यह याद नहीं है कि कहां (UPDATE: मूल समस्या गणित की पहेलियों पर एक प्रमाण के साथ उपखंड पाया गया था कि यह संभव है, इस गणित एसई पोस्ट को भी देखें ), के लिए पूछ रहा है एक प्रमाण यदि पूर्णांक की किसी भी मनमानी जोड़ी के लिए निम्नलिखित प्रक्रिया संभव है (जो मुझे याद है, वह किसी भी जोड़ी के लिए संभव था):

पूर्णांक, जम्मू और कश्मीर की एक जोड़ी को देखते हुए, उनमें से एक को दोगुना करें और एक को दूसरे में जोड़ें, जिसके परिणामस्वरूप नए पूर्णांकों की एक जोड़ी है, अर्थात (j, k) -> (j + 1, k * 2) या (j * 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] में कुछ भी नहीं होना चाहिए।
  - यदि इनपुट [२, ५] में आउटपुट है [[२, ५], [३, १०], [६, ११], [१२, १२]], जिसमें इनपुट जोड़ी शामिल है, तो इनपुट [४, ४] होना चाहिए। आउटपुट [[४, ४]]।
मानक IO विधियाँ लागू होती हैं और मानक खामियों पर रोक लगाई जाती है
यह कोड गोल्फ है इसलिए बाइट्स जीत में सबसे छोटा जवाब है

— JMigst
स्रोत

13

यह एक अच्छी पहली चुनौती है, BTW। PPCG में आपका स्वागत है!

— अरनौलद

@Arnauld धन्यवाद! त्रुटि को इंगित करने के लिए भी धन्यवाद, मैंने सभी उदाहरणों को हाथ से किया और वास्तव में पहले स्वयं एक समाधान लागू करना चाहिए

— JMigst

क्या आउटपुट रिवर्स में हो सकता है? जैसे [(12,12),(6,11),(3,10),(2,5)]इनपुट के लिए (2,5)?

— लैकोनी

1

@ लिकोनी को ध्यान में रखते हुए आवश्यक सभी कदम अभी भी आउटपुट हैं, मुझे लगता है कि यह ठीक है

— JMigst

1

मैंने इसे O30 में A304027 के रूप में जोड़ा । जोड़ी (34,23) विशेष रूप से कठिन प्रतीत होती है।

— पीटर कैगी

10

जावास्क्रिप्ट (ईएस 6), 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

इसे यहाँ आज़माएँ

व्याख्या

यह बहुत सीधी-पहली खोज है। संभावित अनुक्रमों ( J) की एक कतार रखें , और जब तक हमें एक मिलान जोड़ी नहीं मिलती है, तब तक अगला अनुक्रम लें, प्रत्येक संभावित चाल पर छड़ी करें और उन्हें कतार के अंत में रखें।
संक्षिप्तता के लिए, हम एक फ़ंक्शन y(लैम्ब्डा एक्सप्रेशन का उपयोग करके L) में से किसी एक चाल को परिभाषित करते हैं, और इसे आगे और रिवर्स दोनों में लागू करते हैं।

— स्मृति सहायक
स्रोत

4

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

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

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

— डेनिस
स्रोत

(ध्यान दें: यह एक 2-तत्व सूची की [[2,5]]

— एकल

4

05AB1E , 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
_+
$.&

इसे ऑनलाइन आज़माएं! केवल अंकगणित की सीमाओं के कारण दो परीक्षण मामले। स्पष्टीकरण:

\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

MATL , 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 
]

— गैलेन इवानोव
स्रोत

पूर्णांक की एक जोड़ी को समानता में लाना

चुनौती

विशेष विवरण

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

टिप्पणी की गई

हास्केल, 70 69 बाइट्स

पायथन 3 , 90 74 72 बाइट्स

Ungolfed

पायथ, 41 बाइट्स

व्याख्या

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

05AB1E , 25 22 20 बाइट्स

रेटिना , 72 बाइट्स

MATL , 24 बाइट्स

व्याख्या

स्टेक्स , 29 26 बाइट्स

हास्केल , 95 बाइट्स

लाल , 142 बाइट्स

सख्त इनपुट:

लाल , 214 बाइट्स

स्पष्टीकरण: