उलाम संख्या उत्पन्न करें

Question

इनपुट के रूप में एक पूर्णांक n(जहां n < 10001) को देखते हुए , एक प्रोग्राम लिखें जो पहले n उलम संख्याओं को आउटपुट करेगा । एक उल्म संख्या को निम्नानुसार परिभाषित किया गया है:

1. यू ₁ = 1, यू ₂ = 2।
2. के लिए n > 2, U _n सबसे छोटा पूर्णांक है, जो U _n-1 से अधिक है, जो कि पहले एक तरह से दो अलग-अलग शब्दों का योग है ।

उदाहरण के लिए, यू ₃ है 3(2 + 1), यू ₄ है 4(3 + 1) (ध्यान दें कि (2 + 2) की गिनती नहीं है क्योंकि शर्तें अलग नहीं हैं), और यू ₅ है 6, (यू _{5 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. है

— absinthe

जैसा कि यह है, मेरी सूची में चारों ओर कोष्ठक हैं। क्या यह ठीक भी है या मुझे उन्हें हटा देना चाहिए?

— डेनिस

@ डेनिस ब्रैकेट ठीक हैं।

— अनुप

Answer 1

CJam, 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 की गणना करने में उम्र लग जाएगी?

— मार्टिन एंडर

@ मार्टिनबटनर: जावा दुभाषिया बहुत तेज़ है, लेकिन यह अभी भी धीमा है। सभी जानवर बल एल्गोरिदम O (nute) या बदतर हैं। सरणियों के लिए स्टैक-ओरिएंटेड भाषा का उपयोग करना कभी भी सुंदर नहीं होता है (उदाहरण के लिए, सरणियों की लंबाई की गणना करने के लिए संपूर्ण सरणी की प्रतिलिपि बनाने की आवश्यकता होती है), इसलिए वास्तविक निष्पादन समय संभवतः O (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

वहाँ +_*...

— tomsmeding

Answer 3

टी-एसक्यूएल, 301 300 288 287

मैंने थोड़ा हल्का SQL दुरुपयोग किया है।

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 Server 2008 में प्रयास करें ।

@N इनपुट पूर्णांक रखता है। उदाहरण "100" को बदलें कि क्या होना चाहिए। "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

GolfScript ( 41 37 बाइट्स)

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

ऑनलाइन डेमो

गोल्फस्क्रिप्ट में कार्टेशियन उत्पाद काफी लंबे हैं, इसलिए यह एक अलग दृष्टिकोण लेता है। उलम संख्याओं की दीर्घकालिक वृद्धि यह है कि nवें उलम संख्या के बारे में है 13.5n, लेकिन पहले 10000 शब्दों में nवें उल्म संख्या के बीच सबसे बड़ा अनुपात है और nअभी के अधीन है 13.3। इसलिए, nहम पहले 14nनंबरों को फ़िल्टर कर सकते हैं जो कि अनुक्रम में हैं।

41-> 37 के लिए डेनिस के लिए धन्यवाद ।

Comments

यह काफी तेज है। n = 1000GolfScript के साथ एक मिनट के भीतर ले जाता है; CJam के लिए एक बंदरगाह n = 10008 सेकंड में और n = 100001h 20 मीटर में पूरा होता है। - आप अपने दृष्टिकोण के साथ चार बाइट्स बचा सकते हैं, अर्थात् सरणी में 0 सहित और बाद में इसे त्याग दें। यह ब्लॉक के बजाय सेट यूनियन का उपयोग करने की अनुमति देता है और एक चर की आवश्यकता को समाप्त करता है:~.14*,4,\{1$.{2$1$-.@<*}%&,2=*|}/1><`

— डेनिस

@ डेनिस, CJam कितने चार्ट छोटा है? मुझे लगता है कि कोई भी संचालन लंबे समय तक नहीं मिलता है, और मुझे पूरा यकीन है कि इसके लिए एक-चार उपनाम है 14।

— पीटर टेलर

हाँ, 14बस है E। लेकिन आपको STDIN से पढ़ने की जरूरत है, सेट यूनियन (मैं उस बारे में एक बग रिपोर्ट दर्ज करूँगा) प्रदर्शन करने से पहले एक सिंगलटन को पूर्णांक में परिवर्तित कर दूंगा और 2$आंतरिक लूप में काम नहीं करूंगा क्योंकि CJam प्रत्येक पुनरावृत्ति के बाद स्टैक को संशोधित करता है ... I 'कई अलग-अलग तरकीबों की कोशिश की, लेकिन सबसे छोटा 37 बाइट्स था:li4,1$E*{__{I1$-_@<*}%&,2=I*a|}fI1><`

— डेनिस

Answer 6

जावास्क्रिप्ट ईएस 6, 100 ... 93 90 वर्ण

इसे वेब कंसोल या नवीनतम फ़ायरफ़ॉक्स (रात या रिलीज़) के स्क्रैचपैड में चलाएं।

संपादित 8 गोल्फ बहुत कुछ !!! और यह करने के लिए नीचे बना 94 वर्ण 93 90 वर्ण (@openorclose करने के लिए धन्यवाद)। (मेरा पहला उप 100)

यहां मेरा संस्करण है जो बहुत तेज़ है लेकिन 3 वर्णों से अधिक लंबा (107 वर्ण) है और ऊपर के वर्णों की बिल्कुल समान मात्रा है और नीचे दिए गए जानवर बल विधि की तुलना में बहुत छोटा है! (Edc65 के लिए धन्यवाद)

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

मैं इसे और आगे बढ़ाने की कोशिश करता रहूंगा। लेकिन हम इसे JS: P के दायरे से बाहर कर रहे हैं

जब मैं किसी वेबपेज में स्क्रिप्ट टैग के अंदर इसे चलाता हूं तो कुछ नंबर यहां दिए गए हैं:

n समय
10 0.001
100 0.005 है
1000 2.021
10000 236.983
100000       लंबित tldr; बहुत लंबा नहीं चला: पी

---

यह मेरा पहला सबमिशन है जो जावास्क्रिप्ट में @ rink.attenders.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]}

मुझे पता है कि इसे और भी आगे बढ़ाया जा सकता है। मैं एक गैर-जानवर समाधान भी पोस्ट करूंगा, जो और भी छोटा हो सकता है।

EDIT 1 : थोड़ा और अधिक गोल्फ और n = 1 के लिए तय

मुझे कहना होगा कि मैं हर तरह की आवश्यकता के लिए ऐसे सुपर आसान शॉर्टकट के लिए हास्केल और जे से ईर्ष्या करता हूं।

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. मैं अभी भी मुश्किल से समझता हूं कि आपने डबल लूप से कैसे बचा था। कुडोस 2.गॉल्फ टिप: ई 6 में मैं हमेशा बचने की कोशिश करता हूं 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] की कहीं आवश्यकता न हो

— 0914

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 की आवश्यकता लगती है, जो ध्यान देने योग्य हो सकता है। 2. आउटपुट के लिए 1एकल संख्या होनी चाहिए।

— डेनिस

क्या यह 10k का इनपुट संभालता है?

— मार्टिन एंडर

मेरा मानना ​​है कि छोरों के लिए जम्मू और कश्मीर को ब्रेसिज़ की आवश्यकता नहीं है।

— माइकल ईस्टर

जैसा कि मार्टिन का कहना है, मैं भी N = 10K के लिए इस कार्यक्रम का समयबद्ध निष्पादन देखना चाहूंगा।

— माइकल ईस्टर

Answer 9

एपीएल (डायलॉग एक्सटेंडेड) , 36 35 बाइट्स

Adám द्वारा -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\}$

* (Ngn / APL में, एक निरंतर उपयोग किए बिना एक ट्रेन को समाप्त कर सकता है ⍨। लेकिन ngn / APL के पास गिनती नहीं है, इसलिए हमें कहीं / की आवश्यकता है।)

Comments

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

— Adám

Answer 10

PHP 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

हाल ही में मैं गोल्फ को बेहतर बनाने के लिए CoffeeScript का अभ्यास कर रहा हूं, इसलिए यहां मेरा जावास्क्रिप्ट जवाब कॉफीस्क्रिप्ट में संकलित किया गया है:

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 के लिए आउटपुट एक सिंगलटन होना चाहिए।

— डेनिस

@ डेनिस धन्यवाद, सही किया।

— रिंक.टेंडेंट .6

1. यदि आप z=0लूप के अंदर जाते हैं , तो आपको केवल एक बार इसकी आवश्यकता होती है। 2. दृष्टिकोण for(j in l)for(k in l)z+=l[j]<l[k]&l[j]+l[k]==i;से बहुत छोटा है l.forEach।

— डेनिस

Answer 14

गणितज्ञ, १०hem ९ १ बाइट्स

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]

उपयोग:

OCaml दुभाषिया के भीतर:

# 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 और 9 सेwhile t[i]-2:i+=1

— जेम्स वाल्डबी - jwpat7

सलाह के लिये धन्यवाद! मैंने भी लूप को एक इंडेक्स में बदल दिया था लेकिन यह उतने पात्रों को नहीं बचा पाया जितना मैं उम्मीद कर रहा था।

— क्वाडमास्टरएक्सएलआईआई

2 और वर्ण: init U [[1] तक, और पंक्ति 7 को उसके बाद ले जाएँ for

— जेम्स वाल्डबी - jwpat7

तुम अब भी बदलकर 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

LINQ का उपयोग करते हुए जानवर बल दृष्टिकोण:

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));}}

Ungolfed, टेस्ट हार्नेस के साथ

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

बहुत धीमी गति से: n के लिए 46s = 500, n के लिए 6 मी = 1000, एन के लिए 50 मीटर = 2000। उस घातीय दर पर, मेरा मानना ​​है कि n = 10K को संसाधित करने में 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;}

Tio में अब 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

देखें कि क्या मैं कुछ कम कर सकता हूं ...

— RosLuP

मुझे कुछ कहना है कि प्रोग्रामिंग में गोल्फ ठीक है, लेकिन यह सब नहीं है ...

— RosLuP

328 बाइट्स

— छत

मेरे लिए @ceilingcat "z = k" गलत है क्योंकि बाइनरी सर्च (bs) (फंक्शन या आपका B () फंक्शन) मुझे लगता है कि तर्क रेंज के रूप में चाहिए (मुझे नहीं पता कि यह सही है ...) फ़ंक्शन जिसे बिन खोज कहते हैं, उसे z = k-1 होना है

— RosLuP

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
∇

यह मेरे द्वारा भेजे गए सी के एपीएल में अनुवाद होगा। ऐसा लगता है कि मुझे समझ में नहीं आता है कि कब ∇∇ का उपयोग करना है ∇∇ ... संभव when का उपयोग तब किया जाता है जब एक तर्क होता है एक फ़ंक्शन (और एक अन्य प्रकार नहीं)। "यू बी एस एक्स, ए, बी" को रेंज में "यू" सरणी में "एक्स" श्रेणी में बिन खोज होना चाहिए। यह 1, indexWhereFind या 0, indexWhereEndOfsearch लौटाएगा। 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

∇∇एक डोप ऑपरेटर को ∇संदर्भित करता है, जबकि ऑपरेटर को उसके ऑपरेंड (ओं) के साथ व्युत्पन्न फ़ंक्शन से संदर्भित करता है। तो एक monadic ऑपरेटर ∇में एक ही है (⍺⍺∇∇)जबकि एक dyadic ऑपरेटर में इसका मतलब है (⍺⍺∇∇⍵⍵)।

— एडम