उत्पाद जो एक राशि और इसके विपरीत के बराबर हैं

22

समकक्षों की एक मजेदार जोड़ी 1 + 5 = 2 · 3 और 1 · 5 = 2 + 3 है । ऐसे कई हैं, एक और एक है 1 + 1 + 8 = 1 · 2 · 5 और 1 · 1 · 8 = 1 + 2 + 5 । के सामान्य एक उत्पाद में n धनात्मक पूर्णांक की राशि के बराबर होती है n धनात्मक पूर्णांक, और इसके विपरीत।

इस चुनौती में आपको क्रमपरिवर्तन को छोड़कर इनपुट n> 1 के लिए सकारात्मक पूर्णांक के ऐसे सभी संयोजनों को उत्पन्न करना होगा । आप किसी भी उचित प्रारूप में इनका उत्पादन कर सकते हैं। उदाहरण के लिए, n = 3 के लिए सभी संभव उपाय हैं:

(2, 2, 2) (1, 1, 6)
(1, 2, 3) (1, 2, 3)
(1, 3, 3) (1, 1, 7)
(1, 2, 5) (1, 1, 8)

वह प्रोग्राम जो मेरे 2GB रैम , 64-बिट इंटेल उबंटू लैपटॉप जीत पर एक मिनट में सबसे अधिक एन के लिए सबसे अधिक संयोजन उत्पन्न कर सकता है । यदि आपका उत्तर 2GB से अधिक RAM का उपयोग करता है या किसी ऐसी भाषा में लिखा है जिसे मैं स्वतंत्र रूप से उपलब्ध सॉफ़्टवेयर के साथ परीक्षण नहीं कर सकता, तो मैं आपका उत्तर नहीं दूंगा। मैं अब से दो सप्ताह के समय में उत्तरों का परीक्षण करूंगा और विजेता चुनूंगा। बाद में गैर-प्रतिस्पर्धात्मक उत्तर अभी भी निश्चित रूप से पोस्ट किए जा सकते हैं।

चूंकि यह ज्ञात नहीं है कि सभी n के लिए समाधानों का पूरा सेट क्या है , इसलिए आपको ऐसे उत्तर पोस्ट करने की अनुमति है जो अपूर्ण समाधान उत्पन्न करते हैं। हालाँकि यदि कोई अन्य उत्तर एक (अधिक) पूर्ण समाधान उत्पन्न करता है, भले ही उनका अधिकतम n छोटा हो , वह उत्तर जीत जाता है।

स्पष्ट करने के लिए, यहाँ विजेता को तय करने की स्कोरिंग प्रक्रिया है:

  1. मैं आपके प्रोग्राम को n = 2, n = 3, आदि के साथ टेस्ट करूंगा ... मैं आपके सभी आउटपुट को स्टोर करता हूं और जब आपका प्रोग्राम एक मिनट या 2GB से अधिक रैम का हो जाता है तो रुक जाता हूं। हर बार जब प्रोग्राम किसी दिए गए इनपुट n के लिए चलाया जाता है, तो इसे 1 मिनट से अधिक समय लगने पर समाप्त कर दिया जाएगा।

  2. मैं n = 2 के लिए सभी कार्यक्रमों के लिए सभी परिणामों को देखता हूं। यदि एक प्रोग्राम दूसरे की तुलना में कम वैध समाधान का उत्पादन करता है, तो वह प्रोग्राम समाप्त हो जाता है।

  3. N = 3, n = 4, आदि के लिए चरण 2 को दोहराएं ... अंतिम प्रोग्राम स्थायी जीतता है।

integer  fastest-code 
— orlp
स्रोत
1
तो विंडोज़-अनन्य भाषाओं में कोई जवाब नहीं?
— कॉनर ओ'ब्रायन
3
व्यक्तिगत रूप से, मैं स्कोरिंग मानदंडों को नापसंद करता हूं। यह जानना असंभव है कि क्या हमारे समाधान काम करेंगे और कहां तक ​​थ्रेसहोल्ड सेट करें जब तक कि आपके कंप्यूटर पर परीक्षण से परिणाम न हों। मुझे लगता है कि एक साधारण कोड-गोल्फ एक बेहतर सवाल बना देगा।
— संगीतज्ञ ५२३
2
मुझे लगता है कि हार्डकोडिंग की अनुमति नहीं है। लेकिन तब यह प्रतिबंध अप्राप्य होने के करीब है
— लुइस मेंडू
1
@ user202729 मैं नहीं करता, मुझे प्रत्येक n के लिए प्रत्येक प्रोग्राम को देखने की कोशिश करनी है कि कौन सा प्रोग्राम अधिक समाधान उत्पन्न करता है।
— orlp
2
"अब से दो सप्ताह का समय" 3 दिन पहले है।
— जीबी

जवाबों:

4

C (gcc) , n = 50000000 6499 परिणामों के साथ 59 s में

लगभग 1 एस से मिलकर आउटपुट के एक टेराबाइट से अधिक उत्पादन से बचने के लिए, 49999995 1s का एक अनुक्रम संक्षिप्त रूप में है 1x49999995।

#include <stdio.h>
#include <stdlib.h>

static int n, *a1, k1 = 0, *a2, k2 = 0, s1, p1, *factor;

static void out() {
  if (s1 == p1) {
    for (int i = 0; i < k1 && i < k2; i++) {
      if (a1[i] < a2[i])
        return;
      else if (a1[i] > a2[i])
        break;
    }
  }

  for (int i = 0; i < k1; i++)
    printf("%d ", a1[i]);
  printf("1x%d | ", n - k1);
  for (int i = 0; i < k2; i++)
    printf("%d ", a2[i]);
  printf("1x%d\n", n - k2);
}

static void gen2(int p, int s, int m);

static void gen3(int p, int s, int m, int x, int q) {
  int r = s - n + k2 + 2;
  int d = factor[q];
  do {
    if (x * d <= m)
      x *= d;
    q /= d;
  } while (q % d == 0);
  do {
    if (q == 1) {
      a2[k2++] = x;
      gen2(p / x, s - x, x);
      k2--;
    } else {
      gen3(p, s, m, x, q);
    }
    if (x % d != 0)
      break;
    x /= d;
  } while (p / (x * q) >= r - x * q);
}

static void gen2(int p, int s, int m) {
  int n2 = n - k2;
  if (p == 1) {
    if (s == n2)
      out();
  } else if (n2 >= 1 && m > 1) {
    int r = s - n2 + 1;
    if (r < 2 || p < r)
      return;
    if (m > r)
      m = r;
    if (factor[p] <= m)
      gen3(p, s, m, 1, p);
  }
}

static void gen1(int p, int s, int m) {
  int n1 = n - k1;
  p1 = p;
  s1 = s + n1;
  gen2(s1, p1, s + n1 + 1 - n);
  if (n1 != 0) {
    int *p1 = &a1[k1++];
    for (int x = 2; x <= m && p * x <= s + x + n1 - 1; x++) {
      *p1 = x;
      gen1(p * x, s + x, x);
    }
    k1--;
  }
}

int main(int argc, char **argv) {
  if (argc < 2)
    return 1;
  n = atoi(argv[1]);
  if (n < 2)
    return 1;
  a1 = malloc(n * sizeof(int));
  a2 = malloc(n * sizeof(int));
  factor = calloc(4 * n - 1, sizeof(int));
  for (int p = 2; p < 4 * n - 1; p++)
    if (factor[p] == 0) {
      factor[p] = p;
      for (int i = p; i <= (4 * n - 2) / p; i++)
        factor[p * i] = p;
    } else if (factor[p] < factor[p / factor[p]]) {
      factor[p] = factor[p / factor[p]];
    }
  gen1(1, 0, 3 * n - 1);
  return 0;
}

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

— एंडर्स कसीगोर
स्रोत
3

गणितज्ञ, एन = 293 12 समाधानों के साथ

ओपी ने चुनौती को बदल दिया और इनपुट के लिए कहा
यहां नया कोड है जो इनपुट
के रूप में किसी भी n लेता है। n = 293 के लिए आपको 12 समाधान मिलते हैं

If[#<5,Union[Sort/@Select[Tuples[{1,2,3,4,5,6,7,8,9},{#}],Tr@#==Times@@#&]],For[a=1,a<3,a++,For[b=a,b<3,b++,For[c=b,c<5,c++,For[d=c,d<10,d++,For[e=d,e<300,e++,If[Tr[s=Join[Table[1,#-5],{a,b,c,d,e}]]==Times@@s,Print[s]]]]]]]]&


इनपुट

[N]

आप इस एल्गोरिथ्म को वुल्फराम सैंडबॉक्स पर परीक्षण कर सकते हैं जो एक ऑनलाइन स्वतंत्र रूप से उपलब्ध सॉफ्टवेयर है
बस लिंक का पालन करें, कोड के अंत में कोड (सीटीटी + वी) पेस्ट करें , इनपुट इनपुट पेस्ट करें और चलाने के लिए + दबाएं।
आप मेरे सभी समाधान सेकंडों में प्राप्त कर लेंगे

यहाँ भी यह ऑनलाइन कोशिश है! C ++ में (gcc)
(मेरे कोड को निःशुल्क भाषा में समर्थन और अनुवाद करने के लिए @ThePirateBay को बहुत धन्यवाद)

यह कार्यक्रम केवल {a, b, c} {a, b, c} फॉर्म का समाधान उत्पन्न करता है
जिसका अर्थ है a + b + c = a * b * c

गणना करने में 1 सेकंड लगता है

बारह समाधान हैं:

{1,1 ..., 1,1,1,2,293} {1,1 ..., 1,1,1,2,293}
{1,1 ..., 1,1,1,3,147} {1 , 1 ..., 1,1,1,3,147}
{1,1 ..., 1,1,1,5,74} {1,1 ..., 1,1,1,5,74}
{1,1 ..., 1,1,2,2,98} {1,1 ..., 1,1,2,2,98}
{1,1 ..., 1,1,2, 3,59}
{1,1 ..., 1,1,2,3,59} {1,1 ..., 1,1,2,5,33} {1,1 ..., 1,} 1,2,5,33}
{1,1 ..., 1,1,2,7,23} {1,1 ..., 1,1,2,7,23}
{1,1 ।। ।, 1,1,2,8,20} {1,1 ..., 1,1,2,8,20}
{1,1 ..., 1,1,3,3,37} {1 , 1 ..., 1,1,3,3,37}
{1,1 ..., 1,1,3,4,27} {1,1 ..., 1,1,3,4 ... 27}
{1,1 ..., 1,1,3,7,15} {1,1 ..., 1,1,3,7,15}
{1,1 ..., 1,2, 2,6,13} {1,1 ..., 1,2,2,6,13}

— J42161217
स्रोत
1
"अगर आपका जवाब [...] एक ऐसी भाषा में लिखा गया है जिसे मैं स्वतंत्र रूप से उपलब्ध सॉफ़्टवेयर के साथ परीक्षण नहीं कर सकता, तो मैं आपका जवाब नहीं दूंगा।"
— लीक
4
@GB "आपको अपूर्ण समाधान उत्पन्न करने वाले उत्तर पोस्ट करने की अनुमति है"
— user202729
1
मेरा कार्यक्रम ".. एक मिनट में उच्चतम एन के लिए सबसे अधिक संयोजन देता है"। यह हार्डकोड नहीं है। यह सिर्फ एक मिनट के भीतर पहले 12 "सबसे आसान" समाधान पाता है
— J42161217
1
यह स्पष्ट हो सकता है कि n को एक इनपुट माना जाता था। मैंने स्पष्ट किया कि अब। ऐसा नहीं लगता कि आपका प्रोग्राम इनपुट n लेता है ।
— orlp
2
@orlp फिक्स्ड! मेरा कार्यक्रम इनपुट के रूप में किसी भी n लेता है। N = 293 के लिए आपको 12 समाधान मिलते हैं। संयुक्त राष्ट्र-सब कुछ काम करता है, तो कृपया!
— J42161217
2

अजगर 2 , n = 175, 59 में 28 परिणाम

कमी कारक 2 का उपयोग करके इसे थोड़ा धीमा कर दिया, लेकिन n = 83 से शुरू होने वाले अधिक समाधान प्राप्त करता है

मुझे एक ही रन में TIO पर n के लिए 92 तक के परिणाम मिलते हैं।

def submats(n, r):
    if n == r:
        return [[]]
    elif r > 6:
        base = 1
    else:
        base = 2
    mx = max(base, int(n*2**(1-r)))

    mats = []
    subs = submats(n, r+1)
    for m in subs:
        if m:
            mn = m[-1]
        else:
            mn = 1
        for i in range(mn, mx + 1):
            if i * mn < 3*n:
                mats += [m + [i]]
    return mats

def mats(n):
    subs = []
    for sub in submats(n, 0):
        sum = 0
        prod = 1
        for m in sub:
            sum += m
            prod *= m
        if prod > n and prod < n*3:
            subs += [[sub, sum, prod]]
    return subs

def sols(n):
    mat = mats(n)
    sol = [
        [[1]*(n-1)+[3*n-1],[1]*(n-2)+[2,2*n-1]],
    ]
    if n > 2:
        sol += [[[1]*(n-1)+[2*n+1],[1]*(n-2)+[3,n]]]
    for first in mat:
        for second in mat:
            if first[2] == second[1] and first[1] == second[2] and [second[0], first[0]] not in sol:
                sol += [[first[0], second[0]]];
    return sol

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

— जीबी
स्रोत
1
"5 तत्व रखें [1..2] और सीमा 3n ..." मुझे खुशी है कि आपको मेरा एल्गोरिथ्म पसंद आया ;-)
— J42161217
मैंने पहले ही रूबी संस्करण में ऐसा ही कुछ किया था, और अब मैं उस सीमा को हटाने की कोशिश कर रहा हूं।
— GB
किसी दिए गए n के लिए, आपके एल्गोरिथ्म में कितने समाधान हार्डकोड किए गए हैं?
— J42161217
वास्तव में हार्डकोड नहीं है: शॉर्टकट का उपयोग करके 2 मानक समाधान उत्पन्न किए जा सकते हैं (एन = 2 को छोड़कर जहां वे एक ही संयोजन हैं), और इन को छोड़ कर, मैं 3n के बजाय 2n तक सीमित कर सकता हूं। अगर इसे हार्डकोड माना जाता है, तो मैं इसे बदल दूंगा।
— जीबी
1
61 के लिए मेरा परिणाम 28 होगा, मुझे याद है कि यह 27 है ... संभवतः मैंने कुछ त्रुटि की है
— RosLuP
1

रूबी , एन = 12 को 6 समाधान मिलते हैं

कम से कम TIO पर, सामान्य परिणाम 1 से 11 तक 

->n{
  arr=[*1..n*3].product(*(0..n-2).map{|x|
    [*1..[n/3**x,2].max]|[1]
  }).select{|a|
    a.count(1) >= n-4
  }.map(&:sort).uniq
  arr.product(arr).map(&:sort).uniq.select{|r|
    r[0].reduce(&:+) == r[1].reduce(&:*) &&
    r[0].reduce(&:*) == r[1].reduce(&:+)
  }
}

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

मेरे लैपटॉप पर n = 13 के लिए एक मिनट में 10 परिणाम प्राप्त होते हैं।

— जीबी
स्रोत
1

गणितज्ञ, 11 समाधान के साथ n = 19

यह ओपी के नए मानदंडों के अनुसार मेरा नया जवाब है 

(SOL = {};
For[a = 1, a < 3, a++, 
For[b = a, b < 3, b++, 
For[c = b, c < 5, c++, 
 For[d = c, d < 6, d++, 
  For[e = d, e < 3#, e++, 
   For[k = 1, k < 3, k++, 
    For[l = k, l < 3, l++, 
     For[m = l, m < 5, m++, 
      For[n = m, n < 6, n++, For[o = n, o < 3#, o++,
        s = Join[Table[1, # - 5], {a, b, c, d, e}];
        t = Join[Table[1, # - 5], {k, l, m, n, o}];            
        If[Tr[s[[-# ;;]]] == Times @@ t[[-# ;;]] && 
          Tr[t[[-# ;;]]] == Times @@ s[[-# ;;]], 
         AppendTo[SOL,{s[[-#;;]],t[[-#;;]]}]]]]]]]]]]]];
Union[SortBy[#,Last]&/@SOL])&

यदि आप अंत में एक इनपुट देते हैं, तो प्रोग्राम समाधान प्रदर्शित करता है

यहाँ मेरे परिणाम हैं (मेरे पुराने लैपटॉप पर 64-बिट 2.4GHz)

n-> समाधान
2 -> 2
3 -> 4
4 -> 3
5 -> 5
6 -> 4
7 -> 6
8 -> 5
9 -> 7
10 -> 7
11 -> 8
12 -> 6 (में 17 सेकंड)
13 -> 10 (20 सेकंड में)
14 -> 7 (25 सेकंड में)
15 -> 7 (29 सेकंड में)
16 -> 9 (34 सेकंड में)
17 -> 10 (39 सेकंड में)
18 - > 9 (45 सेकंड में)
19 -> 11 (51 सेकंड में)
20 -> 7 (58 सेकंड में)

— J42161217
स्रोत
1

हास्केल, बहुत सारे समाधान तेजी से

import System.Environment

pr n v = prh n v v

prh 1 v l = [ [v] | v<=l ]
prh n 1 _ = [ take n $ repeat 1 ]
prh _ _ 1 = []
prh n v l = [ d:r | d <-[2..l], v `mod` d == 0, r <- prh (n-1) (v`div`d) d ]

wo n v = [ (c,k) | c <- pr n v, let s = sum c, s>=v,
                   k <- pr n s, sum k == v, s>v || c>=k ]

f n = concatMap (wo n) [n+1..3*n]

main = do [ inp ] <- getArgs
          let results = zip [1..] $ f (read inp)
          mapM_ (\(n,s) -> putStrLn $ (show n) ++ ": " ++ (show s)) results

fसमाधान की गणना करता है, mainफ़ंक्शन कमांड लाइन से इनपुट प्राप्त करता है और कुछ स्वरूपण और गिनती करता है।

— क्रिश्चियन सिवर्स
स्रोत
इस तरह संकलित करें: ghc -O3 -o prodsum prodsum.hsऔर कमांड लाइन तर्क के साथ चलाएं:./prodsum 6
— क्रिश्चियन सेवर्स
0

हास्केल , 2 समाधान के साथ एन = 10


import           Data.List

removeDups = foldl' (\seen x -> if x `elem` seen then seen else x : seen) []
removeDups' = foldl' (\seen x -> if x `elem` seen then seen else x : seen) []

f n= removeDups $ map sort filterSums
  where maxNumber = 4
        func x y = if (((fst x) == (fst.snd$y)) && ((fst y) == (fst.snd$x)))
                     then [(snd.snd$x),(snd.snd$y)]
                     else [[],[]]
        pOf = removeDups' $ (map sort (mapM (const [1..maxNumber]) [1..n]))
        sumOf = map (\x->((sum x),((product x), x))) pOf
        filterSums = filter (\x-> not$(x == [[],[]])) (funcsumOfsumOf)

यह बकवास की तरह करता है, लेकिन मैंने कम से कम इसे ठीक कर दिया है इसलिए मैं वास्तव में अब चुनौती को संबोधित कर रहा हूं!

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

— maple_shaft
स्रोत
n = 2 के लिए आपको ["[3,3] [2,3]", "[2,2] [2,2]", "[1,3] [2,2]", "[1] 2] [1,3] "," [1,1] [1,2] "] जो कि गलत है
— J42161217
सभी समाधान वास्तव में गलत प्रतीत होते हैं
— GB
@ जेनी_मथी यह कैसे गलत है? 3 + 3 6 है और 2 * 3 है। 6. क्या मुझे सवाल गलत है।
— मेपल_शाफ्ट
आपको "इसके विपरीत" याद आ रही है
— J42161217
@ जेनी_मथी मेरी तरफ से गूंगी गलती! मैंने इसे ठीक किया, अब काम करना चाहिए।
— मेपल_शाफ्ट
0

यहाँ 59 सेकंड में Axiom, n = 83

-- copy the below text in the file name "thisfile.input" 
-- and give something as the command below in the Axiom window:
-- )read C:\Users\thisuser\thisdirectory\thisfile

)cl all
)time on

-- controlla che l'array a e' formato da elementi  a.i<=a.(i+1)
tv(a:List PI):Boolean==(for i in 1..#a-1 repeat if a.i> a.(i+1) then return false;true)

-- funzione incremento: incrementa a, con #a=n=b/3,sotto la regola di "reduce(+,a)+#a-1>=reduce(*,a)"
-- e che n<reduce(*,a)<3*n ed reduce(+,a)<3*n 
inc3(a:List PI):INT==
   i:=1; n:=#a; b:=3*n
   repeat
      if i>n  then return 0
      x:=reduce(*,a)
      if x>=b then a.i:=1
      else
          y:=reduce(+,a)
          if y>b then a.i=1
          else if y+n-1>=x then
                      x:=x quo a.i
                      a.i:=a.i+1
                      x:=x*a.i
                      if tv(a) then break
                      else a.i:=1
          else a.i:=1
      i:=i+1
   if x<=n then return inc3(a) -- x<=n non va
   x

-- ritorna una lista di liste di 4 divisori di n
-- tali che il loro prodotto e' n
g4(n:PI):List List PI==
  a:=divisors(n)
  r:List List PI:=[]
  for i in 1..#a repeat
     for j in i..#a repeat
        x:=a.i*a.j
        if x*a.j>n then break
        for k in j..#a repeat
            y:=x*a.k
            if y*a.k>n then break
            for h in k..#a repeat
                z:=y*a.h
                if z=n  then r:=cons([a.h,a.k,a.j,a.i],r)
                if z>=n then break 
  r

-- ritorna una lista di liste di 3 divisori di n
-- tali che il loro prodotto e' n
g(n:PI):List List PI==
  a:=divisors(n)
  r:List List PI:=[]
  for i in 1..#a repeat
     for j in i..#a repeat
        x:=a.i*a.j
        if x*a.j>n then break
        for k in j..#a repeat
            y:=x*a.k
            if y=n  then r:=cons([a.k,a.j,a.i],r)
            if y>=n then break
  r

-- cerca che [a,b] nn si trovi gia' in r
searchr(r:List List List PI,a:List PI,b:List PI):Boolean==
  aa:=sort(a); bb:=sort(b)
  for i in 1..#r repeat
      x:=sort(r.i.1);y:=sort(r.i.2)
      if x=aa and y=bb then return false
      if x=bb and y=aa then return false
  true

-- input n:PI
-- ritorna r, tale che se [a,b] in r
-- allora #a=#b=n
--        ed reduce(+,a)=reduce(*,b) ed reduce(+,b)=reduce(*,a)
f(n:PI):List List List PI==
  n>100000 or n<=1 =>[]
  a:List PI:=[]; b:List PI:=[]; r:List List List PI:=[]
  for i in 1..n repeat(a:=cons(1,a);b:=cons(1,b))
  if n~=72 and n<86 then  m:=min(3,n)
  else                    m:=min(4,n) 
  q:=reduce(*,a) 
  repeat
    w:=reduce(+,a)
    if n~=72 and n<86 then x:= g(w)
    else                   x:=g4(w)
    if q=w then r:=cons([copy a, copy a],r)
    for i in 1..#x repeat
           for j in 1..m repeat
                  b.j:=(x.i).j
           -- per costruzione abbiamo che reduce(+,a)= prodotto dei b.i=reduce(*,b)
           -- manca solo di controllare che reduce(+,b)=reduce(*,a)=q
           if reduce(+,b)=q and searchr(r,a,b) then r:=cons([copy a, copy b],r)
    q:=inc3(a)
    if q=0 then break
  r

परिणाम:

 for i in 2..83 repeat output [i, # f(i)]
   [2,2][3,4][4,3][5,5][6,4][7,6][8,5][9,7][10,7][11,8][12,6][13,10][14,7][15,7]
   [16,10][17,10][18,9][19,12][20,7][21,13][22,9][23,14][24,7][25,13][26,11]
   [27,10][28,11][29,15][30,9][31,16][32,11][33,17][34,9][35,9][36,13][37,19]
   [38,11][39,14][40,12][41,17][42,11][43,20][44,12][45,16][46,14][47,14][48,13]
   [49,16][50,14][51,17][52,11][53,20][54,15][55,17]
   [56,14][57,20][58,17][59,16][60,15][61,28][62,15][63,16][64,17][65,18]
   [66,14][67,23][68,20][69,19][70,13][71,18][72,15][73,30][74,15][75,17][76,18]
   [77,25][78,16][79,27][80,9][81,23][82,17][83,26]


 f 3
    [[[1,2,5],[8,1,1]],[[1,3,3],[7,1,1]],[[1,2,3],[1,2,3]],[[2,2,2],[6,1,1]]]
                                     Type: List List List PositiveInteger
                                   Time: 0.07 (IN) + 0.05 (OT) = 0.12 sec

Axiom में पाठ के ऊपर चलाने का तरीका, एक फ़ाइल में उस सभी पाठ की प्रतिलिपि बनाएँ, नाम के साथ फ़ाइल सहेजें: Name.input, Axiom विंडो उपयोग में ")" निरपेक्षता / नाम पढ़ें "।
परिणाम: (# f (i) सरणी की लंबाई को ज्ञात करता है f (i), जो कि समाधानों की संख्या है)

— RosLuP
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.