ওলাম নাম্বার তৈরি করুন

Question

একটি পূর্ণসংখ্যা দেওয়া n(যেখানে n < 10001) ইনপুট হিসাবে, এমন একটি প্রোগ্রাম লিখুন যা প্রথম n উলাম সংখ্যাগুলিকে আউটপুট করবে । একটি ওলাম সংখ্যা নিম্নরূপ সংজ্ঞায়িত করা হয়েছে:

1. ইউ ₁ = 1, ইউ ₂ = 2।
2. কারণ n > 2, ইউ _এন হ'ল ক্ষুদ্রতম পূর্ণসংখ্যা যা ইউ _{এন -1 এর} চেয়ে বড় যা হ'ল এক উপায়ে আগের দুটি স্বতন্ত্র পদগুলির যোগফল ।

উদাহরণস্বরূপ, ইউ ₃ হয় 3(2 + 1 টি), ইউ ₄ হয় 4(3 + 1 টি) (দয়া করে মনে রাখবেন (2 +2) যেমন পদ স্বতন্ত্র নয় গণনা করা হয় না), এবং ইউ ₅ হয় 6, (ইউ ₅ 5 নয় কারণ 5 কে 2 + 3 বা 4 + 1 হিসাবে উপস্থাপন করা যেতে পারে)। এখানে প্রথম কয়েকটি ওলাম সংখ্যা রয়েছে:

1, 2, 3, 4, 6, 8, 11, 13, 16, 18, 26, 28, 36, 38, 47, 48, 53, 57, 62, 69, 72, 77, 82, 87, 97, 99

এটি কোড গল্ফ, তাই স্বল্পতম এন্ট্রিতে জয়ী হয়।

Comments

আউটপুটটি কি দেখানো হয়েছে (তালিকাটি কমা ও স্থান দ্বারা পৃথক করা হয়েছে) করতে হবে বা আমরা উদাহরণস্বরূপ, একটি অ্যারে আউটপুট করতে পারি?

— ডেনিস

আমাদের পরিচালনা করতে হবে ন্যূনতম মান n?

— ডেনিস

@ ডেনিস স্পেস বা কমা বা উভয়ই ঠিক আছে। N এর ন্যূনতম মান হল 1.

— সোমরস

যেমনটি হয়, আমার তালিকার চারপাশে বন্ধনী রয়েছে। এটিও ঠিক আছে নাকি আমার সেগুলি সরিয়ে নেওয়া উচিত?

— ডেনিস

@ ডেনিস বন্ধনী ভাল আছে।

— সোমরস

Answer 1

সিজেম, 47 41 37 বাইট

li4,1${__m*{_~<\:+*}%$2/z:^$2=+}*1><`

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

উদাহরণ রান

$ cjam <(echo 'li4,1${__m*{_~<\:+*}%$2/z:^$2=+}*1><`') <<< 26
[1 2 3 4 6 8 11 13 16 18 26 28 36 38 47 48 53 57 62 69 72 77 82 87 97 99]

কিভাবে এটা কাজ করে

এই প্রাথমিক ধারণাটি নিম্নলিখিত:

1. অ্যারে দিয়ে শুরু করুন A := [ 0 U₁ U₂ ... Uₖ ]।

2. গণনা করুন S, x + yএরকম সমস্ত অঙ্কের অ্যারে x,y ∊ Aএবং x < y।

3. এর থেকে সমস্ত অ-অনন্য পরিমাণ ত্যাগ করুন S। যেহেতু 2 এর চেয়ে বড় প্রতিটি ওলাম সংখ্যা দুটি দুটি ছোট সংখ্যার যোগফল এবং শূন্যের যোগফল এবং সেহেতু এটি উলাম সংখ্যাগুলি পৃথক করে দেয় U₃, U₄, ... Uₖ।

4. অবশিষ্ট অ্যারে হয় [ U₁ U₂ Uₖ₊₁ ... ], সুতরাং পরবর্তী উলাম সংখ্যাটি তৃতীয় ক্ষুদ্রতম উপাদান। এটিতে যুক্ত করুন Aএবং পদক্ষেপ 1 এ ফিরে যান।

li                                    " Read one integer (I) from STDIN.                  ";
  4,                                  " Push the array A = [ 0 1 2 3 ].                   ";
    1${                        }*     " Do the following I times:                         ";
       __m*                           " Push the Cartesian product A × A.                 ";
           {       }%                 " For each pair (x,y) in A × A:                     ";
            _~<\:+*                   " Compute (x + y) * (x < y).                        ";
                     $2               " Sort the resulting array.                         ";
                       /              " Split it into chunks of length 2.                 ";
                        z             " Transpose the resulting two-dimensional array.    ";
                         :^           " Compute the symmetric difference of its rows.     ";
                           $          " Sort the resulting array.                         ";
                            2=        " Extract its third element.                        ";
                              +       " Push it on the array A.                           ";
                                 1>   " Discard the first element of A (0).               ";
                                   <  " Discard all but the first I elements of A.        ";
                                    ` " Push a string representation of A.                ";

Comments

একটি ইনপুট 100ইতিমধ্যে বেশ কয়েক সেকেন্ড সময় নেয়। আমি মনে করি সর্বাধিক ইনপুট 1e5 গণনা করতে বয়সগুলি লাগবে?

— মার্টিন ইন্ডার

@ মার্টিনবাটনার: জাভা দোভাষী খুব দ্রুত, তবে এটি এখনও ধীর গতির। সমস্ত ব্রুট-ফোর্স অ্যালগরিদমগুলি হ'ল (n²) বা আরও খারাপ। অ্যারেগুলির জন্য স্ট্যাক-ওরিয়েন্টেড ভাষা ব্যবহার করা কখনই সুন্দর হয় না (উদাহরণস্বরূপ, অ্যারেগুলির দৈর্ঘ্য গণনা করার জন্য পুরো অ্যারে অনুলিপি করা প্রয়োজন), সুতরাং প্রকৃত মৃত্যুর সময় সম্ভবত ও (এন) হয়।

— ডেনিস

@ মার্টিনব্যাটনার: ওল্ফ্রামআল্ফা , সুতরাং 1e4 (ধন্যবাদ, 1e5 নয়) তিন সপ্তাহেরও কম সময় নিতে হবে।

— ডেনিস

Answer 2

জে - 46 চর

nযুক্তি হিসাবে ফাংশন গ্রহণ ।

_2}.(,]<./@-.~</~({.+_*1<#)/.~@#&,+/~)@[&0&1 2

বিস্ফোরণ দ্বারা ব্যাখ্যা:

    (                                )          NB. procedure for a list:
                                  +/~           NB.   take an addition table
              </~              #&,              NB.   select the top right half (no diag)
                 (        )/.~@                 NB.   for each unique value:
                       1<#                      NB.     if more than one present
                  {.+_*                         NB.     add infinity to it
      ]    -.~                                  NB.   remove existing Ulam numbers
       <./@                                     NB.   take the smallest
     ,                                          NB.   append to Ulam numbers
                                      @[&0      NB. repeat this procedure:
                                          &1 2  NB.   n times starting with [1, 2]
_2}.                                            NB. drop the last two numbers

Comments

আছে +_*...

— টোমসডিং

Answer 3

টি-এসকিউএল, 301 300 288 287

আমি কিছুটা হালকা এসকিউএল অপব্যবহার করেছি।

DECLARE @N INT=100,@T INT=1DECLARE @ TABLE(I INT,U INT)INSERT @ VALUES(1,1),(2,2)#:IF @T>2INSERT @ SELECT TOP 1@T,A.U+B.U FROM @ A,@ B WHERE A.U>B.U GROUP BY A.U+B.U HAVING COUNT(*)=1AND A.U+B.U>ALL(SELECT U FROM @)ORDER BY 2SET @T+=1IF @T<=@N GOTO # SELECT U FROM @ WHERE I<=@N ORDER BY I

SQL সার্ভার 2008 সালে এটি ব্যবহার করে দেখুন এখানে ।

@ এন ইনপুট পূর্ণসংখ্যা রাখে। উদাহরণস্বরূপ "100" কে n হওয়া উচিত Change "10000" সম্ভবত শেষ পর্যন্ত শেষ হবে, তবে আমি এটিকে শেষ করতে দেইনি। এই এন্ট্রিটির চর গণনাটি এক-অঙ্কের ইনপুটটির জন্য। আউটপুট কোয়েরি ফলাফল ফর্ম হয়।

Answer 4

হাস্কেল, 70 67 টি অক্ষর

u n=take n$1:2:[x|x<-[1..],[_]<-[[y|y<-u$n-1,z<-u$n-1,y<z,y+z==x]]]

ব্যবহার:

>u 6
[1,2,3,4,6,8]

Answer 5

গল্ফস্ক্রিপ্ট ( 41 37 বাইট)

~.14*,3,\{1$.{2$1$-.@<*}%&,2=*|}/0-<`

অনলাইন ডেমো

গল্ফস্ক্রিপ্টে কার্টেসিয়ান পণ্যগুলি বেশ দীর্ঘ, তাই এটি একটি পৃথক পদ্ধতির প্রয়োজন। উলামের সংখ্যাগুলির দীর্ঘমেয়াদী বৃদ্ধি হ'ল যে nউলামের সংখ্যা প্রায় 13.5n, তবে প্রথম 10000 পদে থম nউলাম সংখ্যার মধ্যে সর্বাধিক অনুপাত এবং nঠিক এর অধীনে 13.3। সুতরাং প্রদত্ত nআমরা 14nঅনুক্রমের সাথে সম্পর্কিত তাদের সন্ধানের জন্য প্রথম সংখ্যাগুলি ফিল্টার করতে পারি ।

ধন্যবাদ সাথে ডেনিস 41-> 37।

Comments

এটি বেশ দ্রুত। n = 1000গল্ফস্ক্রিপ্ট সহ এক মিনিটের মধ্যে সময় নেয়; সিজেমে একটি বন্দর n = 10008 সেকেন্ডে এবং n = 100001 ঘন্টা 20 মিটারে সম্পূর্ণ হয়। - আপনি আমার সাথে আপনার পদ্ধতির সমন্বয় করে চারটি বাইট সংরক্ষণ করতে পারেন, অ্যারেতে 0 যুক্ত করে এবং পরে তা এড়িয়ে দিতে। এটি ব্লকের পরিবর্তে সেট ইউনিয়ন ব্যবহারের অনুমতি দেয় এবং ভেরিয়েবলের প্রয়োজনীয়তা দূর করে:~.14*,4,\{1$.{2$1$-.@<*}%&,2=*|}/1><`

— ডেনিস

@ ডেনিস, সিজেএম কতটি চরিত্রের চেয়ে ছোট? আমি ধরে নিয়েছি যে অপারেশনগুলির কোনওটিই আর দীর্ঘায়িত হয় না এবং আমি নিশ্চিত যে এটির জন্য ওয়ান-চর উরফ রয়েছে 14।

— পিটার টেলর

হ্যাঁ, 14ঠিক হয় E। তবে আপনাকে STDIN থেকে পড়তে হবে, সেট ইউনিয়ন করার আগে পূর্ণসংখ্যাটিকে একক সিলেটে রূপান্তরিত করতে হবে (আমি এটি সম্পর্কে একটি বাগ রিপোর্ট দায়ের করব) এবং 2$অভ্যন্তরীণ লুপে কাজ করবে না যেহেতু সিজোম প্রতিটি পুনরাবৃত্তির পরে স্ট্যাকটি পরিবর্তন করে ... আমি 'বেশ কয়েকটি ভিন্ন কৌশল চেষ্টা করেছিলেন, তবে সংক্ষিপ্ততমটি হ'ল হ'ল 37 বাইট:li4,1$E*{__{I1$-_@<*}%&,2=I*a|}fI1><`

— ডেনিস

Answer 6

জাভাস্ক্রিপ্ট ES6, 100 ... 93 90 টি অক্ষর

ওয়েব কনসোল বা সর্বশেষতম ফায়ারফক্সের স্ক্র্যাচপ্যাডে এটি চালান (নাইটলি বা রিলিজ)।

8 টি গল্ফ এডিট করুন !!! এবং এটি 94 অক্ষর 93 90 টি অক্ষরে নামিয়েছে (@ ওপেনরোক্লোজকে ধন্যবাদ)। (আমার প্রথম সাব 100)

এখানে আমার সংস্করণটি যা খুব দ্রুত তবে এটি 3 অক্ষর দীর্ঘ (107 অক্ষর) এবং ঠিক উপরের বর্ণের সমান পরিমাণ এবং নীচে ব্রাশ ফোর্স পদ্ধতির চেয়ে অনেক ছোট !, (এডসি 65 এর জন্য ধন্যবাদ):

u=n=>(s=>{for(r=[i=l=1];c=l<n;i+=c&&i-2?1:s[r[l++]=i]=1)r.map(j=>c-=j<i/2&s[i-j])})([])||r

আমি এটিকে আরও গল্ফ দেওয়ার চেষ্টা করব। তবে আমরা এটিকে জেএস: পি এর আওতার বাইরে ছিনিয়ে নিচ্ছি

আমি যখন এটি কোনও ওয়েবপৃষ্ঠায় স্ক্রিপ্ট ট্যাগের অভ্যন্তরে চালিত করি তখন এখানে কিছু নম্বর রয়েছে:

এন সময় (গুলি)
10 0.001
100 0.005
1000 2.021
10000 236.983
100000       মুলতুবি tldr; খুব বেশি দিন চলেনি: পি

---

এটি আমার প্রথম জমা যা জাভাস্ক্রিপ্টে @ rink.attendant.6 এর উত্তর দ্বারা ভারীভাবে অনুপ্রাণিত।

u=n=>{for(l=[1,g=2],i=3;g<n;++i){z=1;for(j of l)for(k of l)z-=j<k&j+k==i;!z?l[g++]=i:0}return n>1?l:[1]}

আমি জানি এটি আরও গল্ফ করা যেতে পারে। আমি একটি অ-নিখরচায় সমাধানও পোস্ট করব, এটি আরও কমও হতে পারে।

সম্পাদনা 1 : আরও কিছুটা গল্ফ করা হয়েছে এবং n = 1 এর জন্য স্থির হয়েছে

আমার অবশ্যই বলতে হবে যে আমি প্রতিটি ধরণের প্রয়োজনের জন্য এমন দুর্দান্ত হ্যান্ডসেল শর্টকাটগুলির জন্য হাস্কেল এবং জে vyর্ষা করি __--

Comments

হাস্কেল সম্পর্কে, আমি মনে করি কার্যকরী শৈলী এবং বাক্য

— গঠনটি

দ্রুততর অবশ্যই আরও গল্ফ করা যেতে পারে: (104) u=n=>{for(s=[,1,1],r=[i=1,l=2];c=l<n;!c?s[r[l++]=i]=1:0,i++)for(j of r)c-=j<i/2&s[i-j];return n>1?r:[1]}এবং আরও বেশি হতে পারে

— edc65

1. আমি এখনও সবে বুঝতে কিভাবে আপনি ডবল loop.Kudos 2.Golf ডগা এড়িয়ে: E6 আমি সবসময় এড়িয়ে চলার চেষ্টা মধ্যে return। 100:u=n=>(s=>{for(r=[i=1,l=2];c=l<n;i+=!c?s[r[l++]=i]=1:1)for(j of r)c-=j<i/2&s[i-j]})([,1,1])|n>1?r:[1]

— edc65

সেখানে আরও একটি চর:u=n=>(s=>{for(r=[i=l=1];c=l<n;i+=c&&i-2?1:s[r[l++]=i]=1)for(j of r)c-=j<i/2&s[i-j]})([,1])||r

— ওপেনর ক্লোজ

90 টি অক্ষর: u=n=>(s=>{for(r=[i=l=1];c=l<n;i+=c&&i-2?1:s[r[l++]=i]=1)r.map(j=>c-=j<i/2&s[i-j])})([])||r যদি না কোথাও [, 1] এর প্রয়োজন হয় না

— ওপেনরোক্লোস

Answer 7

পার্ল - 71 বাইট

#!perl -p
@a=$b[2]=1;1while$b[++$a]^1||$_>map(++$b[$_+$a],@a)&&push@a,$a;$_="@a"

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

এক হিসাবে শেবাংকে গণনা করা হচ্ছে।
অঙ্কগুলি সঞ্চয় করতে দ্বিতীয় অ্যারে ব্যবহার করা হ্যাশের তুলনায় উল্লেখযোগ্যভাবে দ্রুত বলে মনে হয়। স্মৃতি ব্যবহারও কম, যা আমি আশা করি না।

নমুনা ব্যবহার:

$ echo 30 | perl ulam.pl

নমুনা আউটপুট:

1 2 3 4 6 8 11 13 16 18 26 28 36 38 47 48 53 57 62 69 72 77 82 87 97 99 102 106 114 126

আনুমানিক রানটাইম:

n = 100     0.015s
n = 1000    0.062s
n = 10000   4.828s

Comments

8.6 এর জন্য n == 1e4। অ্যামেজিং! এর জন্য আউটপুট n == 1যদিও ভুল; এটি একটি একক সংখ্যা মুদ্রণ করা উচিত।

— ডেনিস

@ ডেনিস এখন ঠিক।

— প্রিমো

Answer 8

জাভা, 259

import java.util.*;class C{public static void main(String[]a){List<Integer>l=new ArrayList<>();l.add(1);l.add(2);for(int i=3,z=0;l.size()<new Long(a[0]);i++,z=0){for(int j:l){for(int k:l){if(j<k&j+k==i)z++;}}if(z==1)l.add(i);}l.forEach(System.out::println);}}

ব্রুট ফোর্স এর জন্য ভাল কাজ করে।

import java.util.*;
class C {
    public static void main(String[] a) {
        List<Integer>l = new ArrayList<>();
        l.add(1);
        l.add(2);
        for (int i = 3, z = 0; l.size() < new Long(a[0]); i++, z = 0) {
            for (int j : l) {
                for (int k : l) {
                    if (j < k & j + k == i)
                        z++;
                }
            }
            if (z == 1)
                l.add(i);
        }
        l.forEach(System.out::println);
    }
}

Comments

1. ফলাফলটি মুদ্রণের জন্য জাভা 8 লাগবে বলে মনে হচ্ছে এটি উল্লেখযোগ্য। ২. এর আউটপুট 1একক সংখ্যা হওয়া উচিত।

— ডেনিস

এটি কি 10 কে একটি ইনপুট পরিচালনা করে?

— মার্টিন এন্ডার

আমি বিশ্বাস করি যে লুপগুলির জন্য জে এবং কে এর জন্য ধনুর্বন্ধনী প্রয়োজন নেই।

— মাইকেল ইস্টার

মার্টিনের সূত্রে, আমিও N = 10K এর জন্য এই প্রোগ্রামটির একটি সময় নির্বাহ দেখতে চাই।

— মাইকেল ইস্টার

Answer 9

এপিএল (ডায়ালগ প্রসারিত) , 36 35 বাইট

-1 বাইট অ্যাডাম দ্বারা

{⍵↑{⍵,⊃∧(∊⊢⊆⍨⍧⍨∊2 3⍨)⍵~⍨,+⍀⍨⍵}⍣⍵⍳2}

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

{⍵↑{⍵,⊃∧(∊⊢⊆⍨⍧⍨∊2 3⍨)⍵~⍨,+⍀⍨⍵}⍣⍵⍳2}      Monadic function taking an argument n:

{⍵,⊃∧(∊⊢⊆⍨⍧⍨∊2 3⍨)⍵~⍨,+⍀⍨⍵}   Helper function to compute the next Ulam number
                                    given ⍵ (the first few Ulam numbers)
                        +⍀⍨⍵      Make an addition table from ⍵.
                       ,          Flatten into a list.
                   ⍵~⍨            Remove all entries already in ⍵.

     (∊⊢⊆⍨2 3∊⍨⍧⍨)               Helper function taking an argument x:
                ⍧⍨                  The count of elts of x in itself                 
           2 3∊⍨                    1s where those counts are in (2 3), else 0s.*
       ⊢⊆⍨                          Partition x, removing values corresponding to 0s.
      ∊                             Join the partitions into a single list.

    (∊⊢⊆⍨⍧⍨∊2 3⍨)                Keep all elements that occur exactly 2 or 3 times.
                                  (i.e. that occur once as a
                                  sum of distinct elements of ⍵).
    ∧                         Sort ascending.
   ⊃                          Take the first value (the next Ulam #).
 ⍵,                           Append that value to ⍵.

{⍵↑{...}⍣⍵⍳2}
{  {...}⍣⍵  }                 Call the helper function n times
           ⍳2                 starting with (1 2). First n+2 Ulam numbers.
 ⍵↑                           Keep the first n elements.

$x$$x$$x$$2a+b$$a$$x$$b$$x$$a=1$$2a+b \in \{ 2, 3\}$

* (এনএনজি / এপিএলতে, একটি ধ্রুবক ব্যবহার না করেই ট্রেনটি শেষ ⍨করতে পারে n তবে এনএনজি / এপিএল এর গণনা হয় না, তাই আমাদের কোথাও দরকার))

Comments

{(2 3∊⍨⍵⍧⍵)/⍵}→(∊⊢⊆⍨⍧⍨∊2 3⍨)

— আদম

Answer 10

পিএইচপি 5.4+, 164

আমার উত্তর হিসাবে একই পদ্ধতির:

<?function u($n){for($l=[1,2],$i=3;count($l)<$n;++$i){$z=0;foreach($l as $j){foreach($l as $k){$z+=$j<$k&$j+$k==$i;}}if($z==1)$l[]=$i;}return array_slice($l,0,$n);}

Answer 11

জেলি , 20 বাইট

Œc§ḟµḟœ-Q$Ṃɓ;
2RÇ⁸¡ḣ

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

Œc§ḟµḟœ-Q$Ṃɓ;    Helper link that appends the next number to x, a list of Ulam numbers:
Œc                  All unordered pairs of x
  §                 Sum each pair
   ḟ                Filter out the numbers already present in x.
    µ               Let this list be y. Then apply the following chain:

     œ-Q$Ṃ          Find the minimum of all unique elements.
     ḟ                Take y and filter out the elements in
      œ-Q$            the multiset difference between y and its unique elements.
          Ṃ           Then find the Ṃinimum of the result.

           ɓ;    Append (ɓ reverses argument order) the result to 


2RÇ⁸¡ḣ           Main link:
2R               Start with [1,2].
  Ç⁸¡            Apply the helper link (Ç) n (⁸) times to generate n+2 Ulam #s.
     ḣ           Keep the first n values.

Answer 12

কফিস্ক্রিপ্ট, 119 114

ইদানীং আমি গল্ফিং জাভাস্ক্রিপ্ট উন্নত করতে কফি স্ক্রিপ্ট অনুশীলন করেছি, সুতরাং আমার জাভাস্ক্রিপ্ট উত্তর কফি স্ক্রিপ্ট মধ্যে সংকলিত:

u=(n)->l=[1,2];i=3;z=0;(for j in l
 for k in l
  z+=j<k&j+k==i
l.push(i) if z==1;++i;z=0)while l.length<n;l[..n-1]

আমি কফিস্ক্রিপ্টের লুপগুলি এবং বোধগম্যতাগুলি খুব ভালভাবে বুঝতে পারি না তাই সম্ভবত এটি আরও গল্ফ করা যেতে পারে তবে এটি এখন আমার কাছে। নিউলাইনগুলি একটি অক্ষর (ইউনিক্স শৈলী) হিসাবে গণনা করা হয়।

Answer 13

জাভাস্ক্রিপ্ট, 147 154 150 (136)

@ Ypnypn এর জন্তু-সমাধান জাভা সমাধান দ্বারা ভারীভাবে অনুপ্রাণিত আগে পোস্ট করা:

function u(n){for(l=[1,2],i=3;l.length<n;++i){z=0;l.forEach(function(j){l.forEach(function(k){z+=j<k&j+k==i})});if(z==1)l.push(i)}return l.slice(0,n)}

আমার মূল সংস্করণটি 4 থেকে 18 বাইট শেভ করার জন্য @ ডেনিসকে ধন্যবাদ

বিপজ্জনক সংস্করণ ( for..inলুপ ব্যবহার করে )

আমি এটি চালানোর পরামর্শ দেব না কারণ একটি লুপ ব্যবহার করে এমন কোনও বস্তুর মধ্য দিয়ে লুপ করা আপনার মেশিনটিকে শিখায় ফেটে এবং / অথবা একটি ক্রুদ্ধ হত্যাযন্ত্রে রূপান্তরিত করতে পারে, তবে এখানে এটি রয়েছে:instanceof Arrayfor..in

function u(n){for(l=[1,2],i=3;l.length<n;++i){z=0;for(j in l)for(k in l)z+=l[j]<l[k]&l[j]+l[k]==i;if(z==1)l.push(i)}return l.slice(0,n)}

Ungolfed

function u(n) {
    var l = [1, 2],
        i = 3,
        j, k, z;

    for (; l.length < n; ++i) {
        z = 0; 
        l.forEach(function (j) {
            l.forEach(function (k) {
                if (j < k & j + k === i) {
                    z++;
                }
            });
        });
        if (z === 1) {
            l.push(i);
        }
    }

    return l.slice(0, n);
}

Comments

1 এর আউটপুট একটি সিঙ্গলটন হওয়া উচিত।

— ডেনিস

@ ডেনিস ধন্যবাদ, সংশোধন হয়েছে।

— rink.attendant.6

1. আপনি যদি লুপটির z=0ভিতরে যান তবে আপনার এটি একবারেই প্রয়োজন only 2. পদ্ধতির for(j in l)for(k in l)z+=l[j]<l[k]&l[j]+l[k]==i;চেয়ে অনেক খাটো l.forEach।

— ডেনিস

Answer 14

গণিত, 107 91 বাইট

Nest[#~Append~Min@Cases[Tally[Tr/@#~Subsets~2],{n_,1}:>n]&,{1,2},i=Input[]]~Drop~{3}~Take~i

এটি অনুমানটির একটি প্রত্যক্ষ বাস্তবায়ন।

• সব জোড়া খুঁজে।
• সমস্ত সদৃশ মুছুন।
• শেষ উলাম সংখ্যার চেয়ে কম সমস্ত সংখ্যা মুছুন।
• সর্বনিম্ন তালিকায় যুক্ত করুন।

আমি ডেনিসের অঙ্কগুলি যোগ করে দেওয়ার কৌশলটিও প্রয়োগ করছি 0, তবে ধরা 0পড়ল যে এটি প্রত্যাশা মতো পুনরায় শুরু করার আগে তালিকার তৃতীয় উপাদানটি তৈরি করে , সুতরাং তালিকা থেকে আমার সেই উপাদানটি সরিয়ে ফেলতে হবে।

এটি 1000কয়েক সেকেন্ডের মধ্যে একটি ইনপুট পরিচালনা করে তবে আমি সন্দেহ করি যে আপনি 10k এর জন্য একটি যুক্তিসঙ্গত সময়ে একটি ফলাফল পাবেন। তবে আমি মনে করি না যে অন্য কেউ এর মধ্যেও ভাল অভিনয় করে।

Answer 15

OCaml - 254 অক্ষর

কোডটি তালিকার বর্তমান উপাদানগুলির সমষ্টি সঞ্চয় করতে একটি হ্যাশ টেবিল ব্যবহার করে এবং প্রতিবার একটি নতুন উপাদান গণনা করা হলে এটি আপডেট করে।

open Hashtbl let h=create 7 let()=add h 3 1 let rec r n i l=if n=0then List.rev l else if mem h i&&find h i=1then(List.iter(fun x->if mem h(x+i)then replace h(x+i)2else add h(x+i)1)l;r(n-1)(i+1)(i::l))else r n(i+1)l let u n=if n=1then[1]else r(n-2)3[2;1]

ব্যবহার:

ওসিএএমএল দোভাষী এর মধ্যে:

# u 26;;
- : int list =
[1; 2; 3; 4; 6; 8; 11; 13; 16; 18; 26; 28; 36; 38; 47; 48; 53; 57; 62; 69;
 72; 77; 82; 87; 97; 99]

Ungolfed

open Hashtbl
let h = create 7
let() = add h 3 1
let rec r n i l =
  if n=0 then List.rev l
  else if mem h i && find h i=1 then
    begin
      List.iter
        (fun x-> if mem h(x+i) then replace h (x+i) 2 else add h (x+i) 1)
        l;
      r (n-1) (i+1) (i::l)
    end
  else r n (i+1) l

let u n = if n=1 then [1] else r (n-2) 3 [2;1]

Answer 16

পাইথন, 137 128 126 টি অক্ষর।

U,i=[1,2],2
for _ in [[0]]*(input()-2):
 t=_*3*i
 for a in U:
  for b in U:t[a+b]+=a!=b
 i=t[i+1:].index(2)+i+1;U+=[i]
print U

এটি আমার প্রথম গল্ফ, এবং আমি এটিকে 250 ডলার থেকে নামিয়ে এনেছি, আমি বেশ খুশি তবে কীভাবে উন্নতি করতে হবে তার পরামর্শগুলি পছন্দ করতে চাই!

Comments

ক্ষুদ্র, কিন্তু উপযুক্ত: লাইন 5 & 6 মেশা for b in U:t[a+b]+=a!=bপ্রয়োজন এবং লাইন 8 এবং 9while t[i]-2:i+=1

— jwpat7 - জেমস Waldby

পরামর্শের জন্য ধন্যবাদ! আমি ওয়েল লুপটিও একটি সূচকে পরিবর্তন করেছি তবে এটি যতটা অক্ষর প্রত্যাশা করেছিল তা সেভ করে নি।

— QuadmasterXLII

আরও for

— দুটি চরিত্র

আপনি এখনও পরিবর্তন করে 2 অক্ষর পরিত্রাণ পেতে পারেন U,i=[1,2],2করতে U,i=[1],2এবং input()-2করতে input()-1এবং t=_*3*iকরতে t=_*3*i;U+=[i]এবং অপসারণ ;U+=[i]জন্য শেষে

— জেমস Waldby - jwpat7

Answer 17

সি #, 257

লিনকিউ ব্যবহার করে ব্রুট ফোর্স এপ্রোচ:

using System.Linq;class U{void F(int n){var u=n<2?new int[]{1}:new int[]{1,2};for(int i=3;u.Length<n;++i)if(u.SelectMany(x=>u,(a,b)=>new{A=a,B=b}).Count(x=>x.A>x.B&&x.A==i-x.B)==1)u=u.Union(new int[]{i}).ToArray();System.Console.Write(string.Join("",u));}}

অসম্পূর্ণ, টেস্ট হারনেস সহ

using System.Linq;
class Ulam
{
    void F(int n)
    {
        //handle special case where n = 1 (ugh)
        var u = n < 2 ? new int[] { 1 } : new int[] { 1, 2 };
        for (int i=3; u.Length<n; ++i)
            if (u.SelectMany(x => u, (a, b) => new { A = a, B = b })
                     .Count(x => x.A > x.B && x.A == i - x.B) == 1)
                u = u.Union(new int[] { i }).ToArray();
        System.Console.Write(string.Join(" ",u));
    }
    public static void Main(string[] args)
    {
        new Ulam().F(1);
        System.Console.WriteLine();
        new Ulam().F(2);
        System.Console.WriteLine();
        new Ulam().F(3);
        System.Console.WriteLine();
        new Ulam().F(26);
        System.Console.WriteLine();
    }
}

Comments

খুব ধীর: এন = 500 এর জন্য 46 এস, এন = 1000 এর 6 মি, এন = 2000 এর জন্য 50 মি। তাত্পর্যপূর্ণ হারে, আমি বিশ্বাস করি যে এন = 10 কে প্রসেস করতে 5 বা 6 দিন সময় লাগবে।

— রিচার্ড দ্বিতীয়

Answer 18

পাইথ, 27 25 বাইট

<uaGh-sfq1lT.gksM.cG2GQS2

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

<uaGh-sfq1lT.gksM.cG2GQS2Q   Implicit: Q=eval(input())
                             Trailing Q inferred
 u                    Q      Perform the following Q times...
                       S2    ... with G initialised to [1,2]:
                 .cG2          Get all 2-element combinations of G
               sM              Sum each pair
            .gk                Group them by value
                                 The groups are sorted by the result of the sum
       f                       Filter the groups, as T, keeping those where:
          lT                     Length of T
        q1                       Equal to 1
      s                        Flatten list
     -               G         Remove elements of the above which are already in G
    h                          Take the first of the remaining elements
                                 This is the smallest, as the grouping also sorted them
  aG                           Append this to G
<                        Q   Take the first Q elements, implicit print

সম্পাদনা করুন: গ্রুপিংয়ের আগে সংক্ষেপণ সম্পাদন করে 2 বাইট গল্ফ করেছেন। পূর্ববর্তী সংস্করণ:<uaGh-mssdfq1lT.gsk.cG2GQS2

Answer 19

সি, 478 বাইট

#define R return
bs(x,v,l,h,r)unsigned x,*v,l,h,*r;{unsigned m;for(;l<=h;){m=(l+h)/2;if(x<v[m])h=m-1;else if(x>v[m])l=m+1;else{*r=m;R 1;}}*r=m;R 0;}
#include<stdlib.h>
unsigned*f(unsigned w){unsigned*u=0,i,k,m,y,z;if(w>1E6||w==0)R u;u=malloc(w*sizeof*u);if(!u)R u;k=0;u[k++]=1;if(w==1)R u;m=u[k++]=2;if(w==2)R u;l:for(i=0,y=0,z=k-1,++m;i<k;y+=bs(m-u[i],u,i+1,z,&z),++i)if(y>1||u[i]+(i+1!=k?u[i+1]:0)>m)break;if(m==0){free(u);u=0;R u;}if(y!=1)goto l;u[k++]=m;if(k< w)goto l;R u;}

টিওতে এখন 9 সেকেন্ডের মধ্যে এটি 10000 মান (এবং সেখানে প্রথম 100 টি মান মুদ্রণ করবে)। কৌশলটি অভ্যন্তরীণ লুপে লিনিয়ার অনুসন্ধান নয় তবে বাইনারি অনুসন্ধান ব্যবহার করছে ... এগুলি নীচে ফাংশনগুলি হ'ল ভালভাবে যুক্ত এবং পূর্ণ পাঠযোগ্য (আমার জন্য শেষ পর্যন্ত):

bsCopy(x,v,l,h,r)unsigned x,*v,l,h,*r;
{unsigned m;
 for(;l<=h;){m=(l+h)/2;if(x<v[m])h=m-1;else if(x>v[m])l=m+1;else{*r=m;R 1;}}
 *r=m;R 0;// in *r if return 0 the min index that fail else the index of find x
}

unsigned*fCopy(unsigned w)
{unsigned*u=0,i,k,m,y,z;
 if(w>1E6||w==0)R u;
 u=malloc(w*sizeof*u);
 if(!u)R u;
 k=0;u[k++]=1;if(w==1)R u;
   m=u[k++]=2;if(w==2)R u;//below I suppose m-u[i] is in the range (if exist in u) (i+1)..z 
 l: for(i=0,y=0,z=k-1,++m;i<k;y+=bsCopy(m-u[i],u,i+1,z,&z),++i)
          if(y>1||u[i]+(i+1!=k?u[i+1]:0)>m)break;
   if(m==0){free(u);u=0;R u;}
          if(y!=1)goto l;
   u[k++]=m;if(k< w)goto l;
 R u;
}

Comments

আমি কিছু হ্রাস করতে পারি কিনা তা দেখুন ...

— রোজলুপ

আমাকে কিছু বলুন যে প্রোগ্রামিংয়ে গল্ফিং ঠিক আছে তবে এটি সব কিছু নয় ...

— রোজলুপুর

328 বাইট

— সিলিংক্যাট

আমার জন্য @ এসিলিংক্যাট "জেড = কে" ভুল কারণ বাইনারি অনুসন্ধান (বিএস () ফাংশন বা আপনার বি () ফাংশন) আমার কাছে মনে হয় আর্গুমেন্ট রেঞ্জ হিসাবে চান (এটি ঠিক আছে কিনা আমি জানি না ...) যে ফাংশনটি বিন অনুসন্ধানে এটি কল করে তা z = k-1

— রোজলুফ

Answer 20

এপিএল (এনএআরএস), 278 চর, 556 বাইট

∇u←p w;m;y;i;k;z;r;bs
bs←{(x l h)←⍵⋄l>h:0,h⋄x<⍺[t←⌊2÷⍨l+h]:⍺∇x,l,t-1⋄x>⍺[t]:⍺∇x,(t+1),h⋄1,t}
u←⍬  ⋄→0×⍳(w>1E6)∨w≤0
u←u,1⋄→0×⍳w=1
u←u,2⋄→0×⍳w=2⋄k←m←2
i←1⋄y←0⋄m+←1⋄z←k
→7×⍳(y>1)∨i>k⋄→7×⍳m<u[i]+{i=k:0⋄u[i+1]}⋄r←u bs(m-u[i]),(i+1),z⋄y+←↑r⋄z←2⊃r⋄i+←1⋄→6
→5×⍳y≠1⋄u←u,m⋄k+←1⋄→5×⍳k<w
∇

এটি আমি প্রেরিত সি এর এপিএলে অনুবাদ হবে। মনে হয় কখন বুঝতে পারছি না কখন ∇ ... সম্ভাব্য of এর জায়গায় ব্যবহার করতে হবে যখন একটি যুক্তি থাকে তখন একটি ফাংশন হয় (এবং অন্য কোনও ধরণের নয়)। "u বিএস এক্স, ক, বি" এর মধ্যে "ইউ" অ্যারেতে "x" মান a..b রেঞ্জের বিন অনুসন্ধান করা উচিত; এটি 1, ইনডেক্সওয়্যারফাইন্ড বা 0, ইনডেক্সওয়্যারইন্ডঅফসার্কে ফিরে আসবে। যুক্তি দিয়ে 200 পি ফাংশনটি গ্রহণ করুন - এক মিনিট এখানে ...

  p 100
1 2 3 4 6 8 11 13 16 18 26 28 36 38 47 48 53 57 62 69 72 77 82 87 97 99 102 106 114 126 
  131 138 145 148 155 175 177 180 182 189 197 206 209 219 221 236 238 241 243 253 
  258 260 273 282 309 316 319 324 339 341 356 358 363 370 382 390 400 402 409 412 
  414 429 431 434 441 451 456 483 485 497 502 522 524 544 546 566 568 585 602 605 
  607 612 624 627 646 668 673 685 688 690 
  p¨1 2 3 4
1  1 2  1 2 3  1 2 3 4 

Comments

∇∇একটি ডপ বলতে অপারেটরকেই ∇বোঝায় যখন অপারেটর (গুলি) সহ অপারেটর সমন্বিত উদ্ভূত ফাংশনকে বোঝায়। তাই কোনও মোনাডিক অপারেটরে ∇যেমন (⍺⍺∇∇)ডায়াডিক অপারেটর থাকে তার অর্থ একই (⍺⍺∇∇⍵⍵)।

— অ্যাডাম