22

সমতুল্যের একটি মজাদার জুটি 1 + 5 = 2 · 3 এবং 1 · 5 = 2 + 3 । এর মতো অনেকগুলি রয়েছে, অন্য একটি হ'ল 1 + 1 + 8 = 1 · 2 · 5 এবং 1 · 1 · 8 = 1 + 2 + 5 । সাধারণ একটি পণ্য সালে এন ধনাত্মক পূর্ণসংখ্যা একটি সমষ্টি সমান এন ধনাত্মক পূর্ণসংখ্যা, এবং তদ্বিপরীত।

এই চ্যালেঞ্জে আপনাকে অনুমতি ছাড়াও একটি ইনপুট এন> 1 এর জন্য ইতিবাচক পূর্ণসংখ্যার এমন সমস্ত সংমিশ্রণ অবশ্যই তৈরি করতে হবে । আপনি যে কোনও যুক্তিসঙ্গত ফর্ম্যাট এ আউটপুট করতে পারেন। উদাহরণস্বরূপ, এন = 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)

যে প্রোগ্রামটি আমার 2 জিবি র‌্যামে এক মিনিটের মধ্যে সর্বাধিক এন এর জন্য সর্বাধিক সংমিশ্রণ তৈরি করতে পারে , 64-বিট ইন্টেল উবুন্টু ল্যাপটপ জিতেছে ins যদি আপনার উত্তরটি 2 গিগাবাইটের বেশি র্যাম ব্যবহার করে বা কোনও ভাষায় লেখা থাকে তবে আমি নির্দ্বিধায় উপলব্ধ সফ্টওয়্যার দিয়ে পরীক্ষা করতে পারি না, আমি আপনার উত্তরটি স্কোর করব না। আমি এখন থেকে দু'সপ্তাহের মধ্যে উত্তরগুলি পরীক্ষা করব এবং বিজয়ীকে বেছে নেব। পরে অ-প্রতিদ্বন্দ্বিতামূলক উত্তরগুলি অবশ্যই পোস্ট করা যেতে পারে।

যেহেতু এটি সমস্ত এন এর সমাধানগুলির সম্পূর্ণ সেটগুলি কী তা জানা যায়নি , তাই আপনাকে এমন উত্তর পোস্ট করার অনুমতি দেওয়া হবে যা অসম্পূর্ণ সমাধান তৈরি করে। তবে যদি অন্য একটি উত্তর একটি (আরও) সম্পূর্ণ সমাধান উত্পন্ন করে, এমনকি তাদের সর্বাধিক এন ছোট হলেও উত্তরটি জিতে যায়।

স্পষ্ট করতে, বিজয়ী সিদ্ধান্ত নেওয়ার জন্য এখানে স্কোরিং প্রক্রিয়া:

আমি আপনার প্রোগ্রামটিকে এন = 2, এন = 3, ইত্যাদি দিয়ে পরীক্ষা করব ... আমি আপনার সমস্ত আউটপুট সংরক্ষণ করি এবং যখন আপনার প্রোগ্রামটি এক মিনিটেরও বেশি সময় নেয় বা 2 জিবি র‌্যামের বেশি লাগে stop প্রতিটি সময় প্রোগ্রাম কোনও প্রদত্ত ইনপুট এন এর জন্য পরিচালিত হয়, এটি যদি 1 মিনিটের বেশি সময় নেয় তবে এটি সমাপ্ত হবে।
আমি এন = ২ এর জন্য সমস্ত প্রোগ্রামের সমস্ত ফলাফলের দিকে নজর রাখছি যদি কোনও প্রোগ্রাম অন্যটির চেয়ে কম বৈধ সমাধান উত্পন্ন করে তবে সেই প্রোগ্রামটি মুছে ফেলা হবে।
এন = 3, এন = 4, ইত্যাদির জন্য পদক্ষেপ 2 পুনরাবৃত্তি করুন ... শেষ প্রোগ্রাম স্থিতি জয়ী।

integer fastest-code

— orlp
সূত্র

1

তাহলে উইন্ডোজ-এক্সক্লুসিভ ভাষায় কোনও উত্তর নেই?

— কনার ও'ব্রায়েন

3

ব্যক্তিগতভাবে, আমি স্কোরিং মানদণ্ড অপছন্দ করি। আমাদের সমাধানগুলি কার্যকর হবে কিনা এবং আপনার কম্পিউটারে পরীক্ষাগুলির ফলাফল না পাওয়া পর্যন্ত আপনার থ্রেশহোল্ডগুলি কোথায় সেট করা যায় তা জানা অসম্ভব। আমি মনে করি একটি সাধারণ কোড-গল্ফ আরও ভাল প্রশ্ন করবে।

— musicman523

2

আমি ধরে নিয়েছি হার্ডকোডিং অনুমোদিত নয়। তবে তারপরে এই বিধিনিষেধটি অযত্নযোগ্য হওয়ার কাছাকাছি

— লুইস মেন্ডো

1

@ user202729 আমি না, প্রতিটি এন-এর জন্য প্রতিটি প্রোগ্রাম চেষ্টা করে দেখতে হবে যে কোন প্রোগ্রামটি আরও সমাধান তৈরি করে।

— orlp

2

"এখন থেকে দুই সপ্তাহের সময়" 3 দিন আগে।

— জিবি

4

সি ( জিসিসি ) , এন = 50000000 5999 এর ফলাফলের সাথে 6499

প্রায় পুরোপুরি 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

গণিত 12 টি সমাধান সহ এন = 293

ওপি চ্যালেঞ্জ পরিবর্তন করেছে এবং ইনপুট চেয়েছে
এখানে নতুন কোড যা কোনও এনটাকে ইনপুট হিসাবে গ্রহণ করবে
এন = 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]]]]]]]]&

ইনপুট

[এন]

আপনি এই অ্যালগরিদমটি ওল্ফ্রাম স্যান্ডবক্সে পরীক্ষা করতে পারেন যা একটি অনলাইন অবাধে উপলভ্য সফ্টওয়্যার,
কেবলমাত্র লিঙ্কটি অনুসরণ করুন, কোডটি (ctrl + v) পেস্ট করুন, কোডের শেষে ইনপুট আটকান এবং চালনার জন্য শিফট + এন্টার টিপুন।
আপনি আমার সমস্ত সমাধান সেকেন্ডে পেয়ে যাবেন

এখানেও এটি অনলাইনে চেষ্টা করুন! সি ++ (
জিসিসি ) তে (আমার কোডটি একটি বিনামূল্যে ভাষায় সমর্থন ও অনুবাদ করার জন্য @ThePirateBay কে অনেক ধন্যবাদ)

এই প্রোগ্রামটি ফর্মের একমাত্র সমাধান তৈরি করে {a, b, c} form a, b, c}
যার অর্থ a + b + c = a * b * c

এটি গণনা করতে 1 সেকেন্ড সময় নেয়

বারোটি সমাধান হ'ল:

{1,1 ..., 1,1,1,2,293} 1 1,1 ..., 1,1,1,2,293} 1 1,1 ..., 1,1,1,3,147
{{1 , 1 ...,
1,1,1,3,147 {1 1,1 ..., 1,1,1,5,74} 1 1,1 ..., 1,1,1,5,74}
{1,1 ..., 1,1,2,2,98} 1 1,1 ..., 1,1,2,2,98} 1 1,1 ..., 1,1,2
, 3,59} {1,1 ..., 1,1,2,3,59} 1 1,1 ..., 1,1,2,5,33}
1 1,1 ..., 1, 1,2,5,33}
{1,1 ..., 1,1,2,7,23} 1 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 37} 1 , 1 ..., 1,1,3,3,37} 1
1,1 ..., 1,1,3,4,27} 1 1,1 ..., 1,1,3,4, 27}
{1,1 ..., 1,1,3,7,15} 1 1,1 ..., 1,1,3,7,15}
1 1,1 ..., 1,2, 2,6,13} {1,1 ..., 1,2,2,6,13}

— J42161217
সূত্র

1

"যদি আপনার উত্তর [...] কোনও ভাষায় লিখিত হয় তবে আমি নিখরচায় উপলব্ধ সফ্টওয়্যার দিয়ে পরীক্ষা করতে পারি না, আমি আপনার উত্তরটি স্কোর করব না।"

— ফাঁস নুন

4

@ গিগাবাইট "আপনাকে এমন উত্তরগুলি পোস্ট করার অনুমতি দেওয়া হয়েছে যা অসম্পূর্ণ সমাধান উত্পন্ন করে"

— ব্যবহারকারী 202729

1

আমার প্রোগ্রাম ".. এক মিনিটের মধ্যে সর্বাধিক এন এর জন্য সবচেয়ে সংমিশ্রণগুলি জেনারেট করে" hard এটি হার্ডকোডযুক্ত নয় t এটি কেবলমাত্র এক মিনিটের মধ্যে প্রথম 12 "সবচেয়ে সহজ" সমাধান খুঁজে পায়

— J42161217

1

এটি পরিষ্কার হতে পারে যে এন এর একটি ইনপুট হওয়ার কথা ছিল। আমি এখন এটি স্পষ্ট। এটা আপনার প্রোগ্রাম একটি ইনপুট নেয় বলে মনে হচ্ছে না এন ।

— orlp

2

@ অরলপ ফিক্সড! আমার প্রোগ্রাম ইনপুট হিসাবে কোনও এন লাগে। এন = 293 এর জন্য আপনি 12 টি সমাধান পান। আন-ডাউনভোট দয়া করে যদি সবকিছু কাজ করে!

— J42161217

2

পাইথন 2 , এন = 175, 28 এর ফলাফল 59 এর দশকে

হ্রাস ফ্যাক্টর 2 ব্যবহার করে এটি কিছুটা ধীরে তৈরি করা হয়েছে তবে এন = 83 দিয়ে আরও সমাধান পাওয়া যায়

আমি একক রানে টিআইও-তে 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

আমি ইতিমধ্যে রুবি সংস্করণে অনুরূপ কিছু করেছি এবং এখন আমি এই সীমাবদ্ধতাটি সরিয়ে দেওয়ার চেষ্টা করছি।

— জিবি

প্রদত্ত এন এর জন্য, আপনার অ্যালগোরিদমে কয়টি সমাধান হার্ডকোড করা আছে?

— J42161217

আসলেই হার্ডকোডযুক্ত নয়: 2 স্ট্যান্ডার্ড সমাধানগুলি একটি শর্টকাট ব্যবহার করে তৈরি করা যেতে পারে (এন = 2 বাদে যেখানে তারা একই সংমিশ্রণ রয়েছে) এবং এগুলি এড়িয়ে গিয়ে আমি 3n এর পরিবর্তে 2n পর্যন্ত সীমাটি সীমাবদ্ধ করতে পারি। এটি হার্ডকডযুক্ত হিসাবে বিবেচনা করা হলে, আমি এটি পরিবর্তন করব।

— জিবি

1

61 এর জন্য আমার ফলাফলটি 28 হবে আপনার মনে আছে এটি 27 ... সম্ভবত আমি কিছু ত্রুটি করেছি

— রোজলুপি

1

রুবি , এন = 12 6 টি সমাধান পান

কমপক্ষে টিআইও-তে, সাধারণ ফলাফল 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 = 11 টি সমাধান সহ 19

এটি ওপির নতুন মানদণ্ড অনুসারে আমার নতুন উত্তর answer

(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৪-বিট ২.৪ গিগাহার্টজ)

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
সূত্র

এন = 2 এর জন্য আপনি ["[3,3] [2,3]", "[2,2] [2,2]", "[1,3] [2,2]", "[1, 2] [1,3] "," [1,1] [1,2] "] যা ভুল

— J42161217

সমস্ত সমাধানগুলি আসলে ভুল বলে মনে হচ্ছে

— জিবি

@ জেনি_ম্যাথি এটি কীভাবে ভুল? 3 + 3 হ'ল 6 এবং 2 * 3 হ'ল আমি কি প্রশ্নটি ভুল বুঝি।

— ম্যাপেল_শ্যাফ্ট

আপনি "বিপরীতে" মিস করছেন

— J42161217

@ জেনি_মাথি বোবা আমার পক্ষে ভুল! আমি এটা ঠিক করেছি, এখন কাজ করা উচিত।

— ম্যাপেল_শ্যাফ্ট

0

Axiom, n = 83 এখানে 59 সেকেন্ড

-- 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

অ্যাক্সিয়মে উপরের পাঠ্যটি চালনার উপায়টি হ'ল, সেই সমস্ত পাঠ্য কোনও ফাইলে অনুলিপি করুন, নামটি দিয়ে ফাইলটি সংরক্ষণ করুন: নেম.ইনপুট, অ্যাক্সিয়াম উইন্ডোতে ") পড়ুন পরমপথ / নাম"।
ফলাফল: (# চ (i) অ্যারের দৈর্ঘ্য খুঁজে পাবে f (i), এটি সমাধানের সংখ্যা)

— RosLuP
সূত্র

সমষ্টি এবং বিপরীতে সমান পণ্য

স্পষ্ট করতে, বিজয়ী সিদ্ধান্ত নেওয়ার জন্য এখানে স্কোরিং প্রক্রিয়া:

সি ( জিসিসি ) , এন = 50000000 5999 এর ফলাফলের সাথে 6499

গণিত 12 টি সমাধান সহ এন = 293

পাইথন 2 , এন = 175, 28 এর ফলাফল 59 এর দশকে

রুবি , এন = 12 6 টি সমাধান পান

গণিত, 11 = 11 টি সমাধান সহ 19

হাস্কেল, প্রচুর সমাধান দ্রুত

হাস্কেল , 2 সমাধান সহ এন = 10

Axiom, n = 83 এখানে 59 সেকেন্ড