एन के लिए सबसे छोटे रास्तों की संख्या गिनें

Question

इस कोड को चुनौती आप तरीकों तक पहुँचने के लिए की संख्या की गणना करनी होगी $n$ से शुरू $2$ फार्म के नक्शे का उपयोग $x \mapsto x + x^j$ (साथ $j$ एक गैर नकारात्मक पूर्णांक), और चरणों की न्यूनतम संख्या में ऐसा करने से।

(ध्यान दें, यह OEIS अनुक्रम A307092 से संबंधित है ।)

उदाहरण

उदाहरण के लिए, $f(13) = 2$ क्योंकि तीन नक्शे के लिए आवश्यक हैं, और वहाँ तीन नक्शे भेज देंगे कि के दो अलग दृश्यों हैं $2$ करने के लिए $13$ :

$$\begin{array}{c} x \mapsto x + x^0 \\ x \mapsto x + x^2 \\ x \mapsto x + x^0\end{array} \qquad \textrm{or} \qquad \begin{array}{c}x \mapsto x + x^2 \\ x \mapsto x + x^1 \\ x \mapsto x + x^0\end{array}$$

जिसका परिणाम $2 \to 3 \to 12 \to 13$ या $2 \to 6 \to 12 \to 13$ ।

उदाहरण मान

f(2)   = 1 (via [])
f(3)   = 1 (via [0])
f(4)   = 1 (via [1])
f(5)   = 1 (via [1,0])
f(12)  = 2 (via [0,2] or [2,1])
f(13)  = 2 (via [0,2,0] or [2,1,0], shown above)
f(19)  = 1 (via [4,0])
f(20)  = 2 (via [1,2] or [3,1])
f(226) = 3 (via [2,0,2,1,0,1], [3,2,0,0,0,1], or [2,3,0,0,0,0])
f(372) = 4 (via [3,0,1,0,1,1,0,1,1], [1,1,0,2,0,0,0,1,1], [0,2,0,2,0,0,0,0,1], or [2,1,0,2,0,0,0,0,1])

चुनौती

चुनौती यह व्यवस्था एक पूर्णांक लेता है का उत्पादन होता है $n \ge 2$ इनपुट प्रदान करने, और से अलग रास्तों की संख्या आउटपुट $2$ के लिए $n$ फार्म के नक्शे का एक न्यूनतम संख्या के माध्यम से $x \mapsto x + x^j$ ।

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

Comments

मुझे लगता है कि यह स्पष्ट रूप से ध्यान दिया जाना चाहिए कि ^प्रतीक घातांक को दर्शाता है। यह XOR भी हो सकता है (उदाहरण के लिए C बिट बिट ^XOR के लिए उपयोग करता है )।

— रामलीज

@Ramillies शायद इसे MathJax में बदल दिया जाए। Ie बजाय । $x=x+x^j$x -> x + x^j

— केविन क्रूज़सेन

@ केविनक्रूजसेन: अच्छी बात है, यह निश्चित रूप से मदद करेगा।

— रामलीज

मैं के रूप में OEIS को यह जोड़ लिया है A309997 । (यह अनुमोदित होने तक एक मसौदा होगा ।)

— पीटर केजी

Answer 1

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

2+*¥þ³Ḷ¤F$n³Ạ$¿ċ

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

एक पूर्ण कार्यक्रम अपने तर्क $n$ रूप में ले रहा है और न्यूनतम पथ लंबाई का उपयोग करके $n$ तक पहुंचने के तरीकों की संख्या वापस कर रहा है। बड़े $n$ लिए अक्षम ।

Answer 2

जावास्क्रिप्ट (ईएस 6),  111 ... 84  80 बाइट्स

$1$$n=2$

f=(n,j)=>(g=(i,x,e=1)=>i?e>n?g(i-1,x):g(i-1,x+e)+g(i,x,e*x):x==n)(j,2)||f(n,-~j)

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

टिप्पणी की गई

f = (                     // f is the main recursive function taking:
  n,                      //   n = input
  j                       //   j = maximum number of steps
) => (                    //
  g = (                   // g is another recursive function taking:
    i,                    //   i = number of remaining steps
    x,                    //   x = current sum
    e = 1                 //   e = current exponentiated part
  ) =>                    //
    i ?                   // if there's still at least one step to go:
      e > n ?             //   if e is greater than n:
                          //     add the result of a recursive call with:
        g(i - 1, x)       //       i - 1, x unchanged and e = 1
      :                   //   else:
                          //     add the sum of recursive calls with:
        g(i - 1, x + e) + //       i - 1, x + e and e = 1
        g(i, x, e * x)    //       i unchanged, x unchanged and e = e * x
    :                     // else:
      x == n              //   stop recursion; return 1 if x = n
)(j, 2)                   // initial call to g with i = j and x = 2
|| f(n, -~j)              // if it fails, try again with j + 1

Answer 3

हास्केल , 78 75 बाइट्स

यह कार्यान्वयन "ट्री" में सांस-पहले-खोज का उपयोग करता है जो पुनरावृत्त रूप से सभी आवश्यक मैपिंग का उपयोग करता है x -> x + x^j।

j#x=x+x^j
f n=[sum[1|x<-l,x==n]|l<-iterate((#)<$>[0..n]<*>)[2],n`elem`l]!!0

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

व्याख्या

-- computes the mapping x -> x + x^j
j#x=x+x^j                          
--iteratively apply this function for all exponents [0,1,...,n] (for all previous values, starting with the only value [2])
                            iterate((#)<$>[0..n]<*>)[2] 
-- find each iteration where our target number occurs
    [                   |l<-...........................,n`elem`l] 
-- find how many times it occurs
     sum   [1|x<-l,x==n] 
-- pick the first entry
f n=.............................................................!!0

Answer 4

05AB1E , 17 बाइट्स

2¸[˜DIå#εIÝmy+]I¢

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

Answer 5

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

f=lambda n,l=[2]:l.count(n)or f(n,[x+x**j for x in l for j in range(n)])

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

Comments

BFS को पुनरावर्ती रूप से लागू करने का अच्छा तरीका है।

— जोएल

Answer 6

पर्ल 5 ( -lp), 79 बाइट्स

$e=$_;@,=(2);@,=map{$x=$_;map$x+$x**$_,0..log($e)/log$x}@,until$_=grep$_==$e,@,

TIO

Answer 7

CJam (27 बाइट्स)

qi2a{{_W$,f#f+~2}%_W$&!}ge=

ऑनलाइन डेमो

चेतावनी: यह बहुत तेजी से स्मृति-गहन हो जाता है।

विच्छेदन:

qi            e# Read input and parse to int n (accessed from the bottom of the stack as W$)
2a            e# Start with [2]
{             e# Loop
  {           e#   Map each integer x in the current list
    _W$,f#f+~ e#     to x+x^i for 0 <= i < n
    2         e#   and add a bonus 2 for the special case
  }%          e#   Gather these in the new list
  _W$&!       e#   Until the list contains an n
}g
e=            e# Count occurrences

बोनस 2s (इनपुट के विशेष मामले को संभालने के लिए2 , क्योंकि whileलूप्स छोरों से अधिक महंगे हैं do-while) का मतलब है कि सूची का आकार बहुत तेजी से बढ़ता है, और एक्सपोजर का उपयोग करने का n-1मतलब है कि सूची में बड़ी संख्याओं के मान बढ़ते हैं बहुत तेज़।

Answer 8

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

([2]%)
l%n|elem n l=sum[1|x<-l,x==n]|1>0=[x+x^k|x<-l,k<-[0..n]]%n

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

गोल्फिंग दोष की चौड़ाई-पहली-खोज । मैंने भी पीछे से जाने की कोशिश की n, लेकिन यह लंबा था:

73 बाइट्स

q.pure
q l|elem 2l=sum[1|2<-l]|1>0=q[x|n<-l,x<-[0..n],i<-[0..n],x+x^i==n]

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

Answer 9

आर , 78 77 बाइट्स

function(n,x=2){while(!{a=sum(x==n)})x=rep(D<-x[x<n],n+1)+outer(D,0:n,'^')
a}

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

एक सरलीकृत चौड़ाई-पहली खोज का उपयोग करना

स्पष्टीकरण के साथ अनियंत्रित कोड:

function(n){                              # function taking the target value n

  x=2                                     # initialize vector of x's with 2

  while(!(a<-sum(x==n))) {                # count how many x's are equal to n and store in a
                                          # loop while a == 0

    x=rep(D<-x[x<n],n+1)+outer(D,0:n,'^') # recreate the vector of x's 
                                          # with the next values: x + x^0:n
  }
a                                         # return a
}   

---

विशाल मेमोरी आवंटन के साथ छोटा संस्करण (बड़े मामलों के लिए असफल):

आर , 70 69 बाइट्स

function(n,x=2){while(!{a=sum(x==n)})x=rep(x,n+1)+outer(x,0:n,'^')
a}

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

-1 बाइट @RobinRyder के लिए धन्यवाद

Comments

!(a<-sum(x==n))!{a=sum(x==n)}दोनों मामलों में -1 बाइट के लिए हो सकता है ।

— रॉबिन राइडर

Answer 10

अजगर , 24 बाइट्स

VQIJ/mu+G^GHd2^U.lQ2NQJB

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

यह सही आउटपुट का उत्पादन करना चाहिए, लेकिन बहुत धीमा है (372 टेस्ट केस टाइम आउट TIO पर)। मैं इसे बदल कर कम कर सकता है .lQ2के साथ Qहै, लेकिन इस क्रम खराब होगा।

नोट: अगम्य संख्याओं के लिए कोई आउटपुट नहीं देता है $(n \leq 1)$

व्याख्या

VQ                        # for N in range(Q (=input)):
   J                      #   J =
     m                    #     map(lambda d:
      u                   #       reduce(lambda G,H:
       +G^GH              #         G + G^H,
            d2            #         d (list), 2 (starting value) ),
              ^U.lQ2N     #       cartesian_product(range(log(Q, 2)), N)
    /                Q    #     .count(Q)
  IJ                  JB  #   if J: print(J); break