समग्र संख्या अनुक्रम

Question

समग्र संख्या अनुक्रम

_{इस सवाल से प्रेरित}

एक सकारात्मक पूर्णांक n को देखते हुए , आपके कोड को पहले n समग्र संख्याओं का उत्पादन करना चाहिए ।

इनपुट आउटपुट

आप एक कार्यक्रम या एक समारोह लिख सकते हैं। इनपुट STDIN या फ़ंक्शन तर्क के माध्यम से होता है और आउटपुट STDOUT, या फ़ंक्शन रिटर्न मान के लिए होता है।

आउटपुट एक सूची, सरणी या स्ट्रिंग हो सकता है।

उदाहरण

 0 -> 
 1 -> 4
 2 -> 4, 6
 3 -> 4, 6, 8
13 -> 4, 6, 8, 9, 10, 12, 14, 15, 16, 18, 20, 21, 22

---

नियम

• जैसा कि हमेशा मानक खामियों को रोक दिया जाता है।

• बिल्ट-इन जो कि प्राइम या कम्पोजिट नंबर जेनरेट करते हैं, उन्हें अनुमति नहीं है।

• प्राइम या कंपोजिट नंबर से संबंधित बिल्ट-इन की अनुमति नहीं है।

Comments

बेशक, यह OEIS पर है: A002808

— NinjaBearMonkey

Answer 1

पायथ - 10 बाइट्स

एक वैध जवाब। विल्सन के प्रमेय का उपयोग करता है ।

.f%h.!tZZQ

इसे यहाँ ऑनलाइन आज़माएँ ।

पुराना उत्तर

अजगर - 6 वर्ण

प्राइम फ़ैक्टर के लिए बिलिन का उपयोग करता है , न कि प्राइम चेकिंग के लिए।

.ftPZQ

इसे यहाँ ऑनलाइन आज़माएँ ।

.f  Q         First n that passes filter of lambda Z, uses input for how many
 t            Tail. This makes all that have len-one prime factorization become empty list, and thus falsey.
  P           Prime factorization - primes have a len-one factorization.
   Z          Lambda var

Comments

हम्म, इस बारे में सोचा जाना चाहिए: /

— डाउनगोट

नियम बदल गए हैं और इस प्रकार यह उत्तर अब मान्य नहीं है।

— orlp

@orlp अपडेटेड उत्तर।

— माल्टसेन

@ माल्टीसेन यह 10 बाइट्स नहीं है?

— kirbyfan64sos

@ kirbyfan64sos: / मैं स्पष्ट रूप से लंबाई काउंटर नहीं पढ़ सकता। फिक्सिंग।

— माल्टसेन

Answer 2

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

<S{*M^tSQ2Q

[2, n] और truncates के सभी संयोजनों के उत्पादों की अत्यधिक बड़ी सूची बनाता है।

Comments

यह इनपुट 1या है तो काम नहीं करता है 2।

— टूथब्रश 20

Answer 3

TeX, 382 बाइट्स

क्योंकि, तुम कर सकते हो।

\newcount\a\newcount\b\newcount\c\newcount\n\newcount\p\newcount\q\let\v\advance\let\e\else\let\z\ifnum
\def\d#1:#2:#3:{\z#1>#2\v#1 by-#2\d#1:#2:#3:\e\z#1=#2#3=1\e#3=0\fi\fi}
\def\i#1:#2:#3:{#3=0\z#1>#2\a=#1\d\a:#2:\c:
\z\c=0\b=#2\v\b by 1\i#1:\the\b:#3:\e#1\par\fi\e#3=1\fi}
\def\l#1:#2:#3:#4:{\i\the#1:2:#4:
\z#4=0\v#2 by 1\fi\z#2<#3\v#1 by 1\l#1:#2:#3:#4:\fi}
\l\p:\n:10:\q:\end

अंतिम पंक्ति की संख्या वह समग्र संख्या है जिसे आप चाहते हैं।

यह एक साधारण भाजक परीक्षक है। \dअगर #2विभाजित करता है #1। सभी संभावित डिवाइडर (यानी < ) के लिए \iकॉल । पहले नंबरों को सूचीबद्ध करता है जिसके लिए 0 देता है।\d#1\l#2\i

Ungolfed (अच्छा, आधा गोल्फ वाला) संस्करण:

\newcount\a
\newcount\b
\newcount\c
\newcount\n
\newcount\p
\newcount\q

\def\div#1:#2:#3:{%
  \ifnum#1>#2 %
    \advance#1 by-#2 %
    \div#1:#2:#3:%
  \else%
    \ifnum#1=#2 %
      #3=1%
    \else%
      #3=0%
    \fi%
  \fi%
}

\long\def\isprime#1:#2:#3:{%
  #3=0%
  \ifnum#1>#2 %
    \a=#1 %
    \div\a:#2:\c: %
    \ifnum\c=0 %
      \b=#2 %
      \advance\b by 1 %
      \isprime#1:\the\b:#3:%
    \else
      #1\par%
    \fi%
  \else%
    #3=1%
  \fi%
}

\def\listprimes#1:#2:#3:#4:{%
  \isprime\the#1:2:#4: %
  \ifnum#4=0 %
    \advance#2 by 1 %
  \fi
  \ifnum#2<#3 %
    \advance#1 by 1 %
    \listprimes#1:#2:#3:#4: %
  \fi
}

\listprimes\p:\n:11:\q:

\end

Comments

प्रोग्रामिंग पहेलियाँ और कोड गोल्फ में आपका स्वागत है! किसी भाषा में महान पहला उत्तर किसी ने सोचा नहीं कि चुनौती के लिए उपयुक्त होगा। यद्यपि यह बहुत लंबा है, यह TeX में अद्वितीय और साफ-सुथरा उत्तर है और हम निश्चित रूप से ऐसे उत्तरों की सराहना करते हैं।

— तन्माथ

@TanMath गर्मजोशी से स्वागत के लिए धन्यवाद, मुझे लगता है कि यह प्रतिस्पर्धा करने के लिए बहुत लंबा है, लेकिन यह मजेदार था :)

Answer 4

पायथन, 57

lambda n:sorted({(k/n+2)*(k%n+2)for k in range(n*n)})[:n]

कम गोल्फ वाला:

def f(n):
 R=range(n)
 return sorted({(a+2)*(b+2)for a in R for b in R})[:n]

यह विचार है कि 0 और 1. को छोड़कर सभी प्राकृतिक संख्याओं के जोड़ को समग्र संख्याओं के सेट से उत्पन्न किया जाए, फिर इस सेट को क्रमबद्ध करें, और पहले nतत्वों को लें। यह सेट के कार्टेशियन उत्पाद को {2, 3, ..., n+2}अपने साथ लेने के लिए पर्याप्त है, जिसे हम range(n)2 से ऊपर ले जाकर प्राप्त कर सकते हैं ।

गोल्फ के लिए इस है, हम दो मानों को संग्रहीत करने का क्लासिक गोल्फ चाल कर (a,b)में range(n)एकल मान के रूप में kमें range(n*n), और उन्हें निकालने के a=k/n, b=k%n।

Answer 5

जावा 8, 98 97 बाइट्स

i->{int a[]=new int[i],c=3,k=0,d;for(;k<i;c++)for(d=c;d-->2;)if(c%d<1){a[k++]=c;break;}return a;}

बॉयलरप्लेट के साथ विस्तारित:

public class C {
    public static void main(String[] args) {
        Function<Integer, int[]> f = i -> {
            int a[] = new int[i], c = 3;
            for (int k = 0; k < i; c++) {
                for (int d = c; d --> 2;) {
                    if (c % d < 1) {
                        a[k++] = c;
                        break;
                    }
                }
            }
            return a;
        };
        System.out.println(Arrays.toString(f.apply(5)));
    }
}

Answer 6

आर, 53 बाइट्स

n=scan();t=1:(n*n+3);t[factorial(t-1)%%t!=(t-1)][1:n]

यह काम किस प्रकार करता है

यह भी विल्सन की प्रमेय पर आधारित है और यह सब 1:n*nउपरोक्त सीमा के अनुसार समग्र संख्या निकालने और समग्र संख्या निकालने के लिए है। मैंने जोड़ा है +3क्योंकि पूर्णांकों के n*nलिए पर्याप्त बड़ी सीमा नहीं हैn < 3

---

इस समाधान के साथ एकमात्र समस्या यह है कि (दुख की बात है) आर एक बड़े पर्याप्त तथ्य के लिए सटीक खो देता है, इस प्रकार, यह ठीक से काम नहीं करेगा n > 19

Answer 7

सीजाम, 20 18 बाइट्स

li_5*{_,2>f%0&},<`

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

प्राइम या फैक्टराइजेशन ऑपरेटरों में निर्मित किसी का उपयोग नहीं करता है। समग्र रूप से संख्या बल के लिए ब्रूट बल की जांच।

एक अवलोकन जो यहां उपयोग किया जाता है वह यह है कि हम उन नंबरों के लिए एक सुरक्षित ऊपरी सीमा की आसानी से गणना कर सकते हैं जिन्हें हमें परीक्षण करना है। चूंकि हर दूसरी संख्या 4 से बड़ी है, 4 + n * 2इसलिए n-th समग्र संख्या के लिए एक ऊपरी सीमा है।

@ डेनिस के एक सुझाव के आधार पर, नवीनतम कार्यान्वयन वास्तव n * 5में ऊपरी सीमा के रूप में उपयोग करता है, जो बहुत कम कुशल है, लेकिन 2 बाइट्स कम है।

स्पष्टीकरण:

li    Get and convert input.
_     Copy, will need the value to trim the list at the end.
5*    Calculate upper bound.
{     Start of filter.
  _     Copy value.
  ,     Create list [0 .. value-1].
  2>    Slice off the first two, leaving candidate factors [2 .. value-1].
  f%    Apply modulo with all candidate factors to value.
  0&    Check if one of the modulo results is 0.
},    End of filter.
<     Trim output to n values.
`     Convert list to string.

Answer 8

जावास्क्रिप्ट ईएस 6, 88 वर्ण

n=>{r=[];for(q=2;r.length!=n;++q)if(/^(..+)\1+$/.test("-".repeat(q)))r.push(q);return r}

Comments

मेरा मानना ​​है कि वैरिएबल असाइनमेंट f=को हटाना कानूनी है।

— डंकेमेसेस

@ डंकेम्स, लगता है हां। meta.codegolf.stackexchange.com/q/6915/32091

— Qwertiy

यह 83 है:n=>eval('for(r=[],q=2;r.length-n;/^(..+)\\1+$/.test("-".repeat(++q))&&r.push(q))r')

— डंकेमेसेस

@ डंकेमेज़, कूल :)

— क्वर्टी '

@Qwertiy क्षमा करें, मेरा मतलब था n&&!r[n-1]: '| यह उसी लंबाई की है जैसे r.length<n- एक वर्ण से कम r.length!=n- लेकिन यह कोड गोल्फ माना जाता है, है ना? : -]

— टूथब्रश 19

Answer 9

हास्केल, 49 46 बाइट्स

(`take`[x|x<-[4..],or[mod x y<1|y<-[2..x-1]]])

उपयोग उदाहरण:

*Main> (`take`[x|x<-[4..],or[mod x y<1|y<-[2..x-1]]]) 13
[4,6,8,9,10,12,14,15,16,18,20,21,22]

यह काम किस प्रकार करता है

  [x|x<-[4..]    ]           -- keep all x from the integers starting with 4 where
      ,or                    -- where at least one element of the following list is "True"
    [mod x y<1|y<-[2..x-1]]  -- "x mod y < 1" for all y from [2,3,...x-1]
(`take`[   ])                -- take the first n elements from the xes
                             -- where n is the parameter supplied when calling the function

Answer 10

एफ #, 78 बाइट्स

fun n->(Array.filter(fun i->Seq.exists((%)i>>(=)0)[2..i-1])[|2..n*n|]).[..n-1]

व्याख्या की:

fun n->                                                                      
                                                           [|2..n*n|]          // Generate an array of integers from 2 to n * n
        Array.filter(fun i->                              )                    // Filter it using the following function on each element
                                                  [2..i-1]                        // Generate a list of possible divisors (from 2 to i-1)
                            Seq.exists(          )                                // Check if at least one of the divisors is valid, that is
                                       (%)i>>(=)0                                    // That i % it is equal to 0. This is equivalent to (fun d -> i % d = 0)
       (                                                             ).[..n-1] // Take the n first elements of the resulting, filtered array

Comments

यह एक महान जवाब है, हालांकि यह थोड़ा भ्रमित है कि आप iदो बार चर का उपयोग करते हैं । मैं F # से परिचित नहीं हूं, लेकिन क्या आप शायद इस्तेमाल नहीं कर सकते j?

— wizzwizz4

सही, यह स्पष्ट करता है। यह छायांकन के कारण काम करता था, लेकिन मुझे लगता है कि मैं चीज़ को गोल करते हुए पठनीयता के बारे में भूल गया था। ^ _ ^ '

— रज्जो

मैं उस तरह की गलती कभी नहीं करता । संभवतः इसलिए मैं गोल्फिंग में अच्छा नहीं हूं d: -D

— wizzwizz4

Answer 11

सी ++ 109

int main(){int n,i,x=4;cin>>n;while(n){for(i=2;i<x-1;i++){if(x%i==0){cout<<x<<' ';n--;break;}}x++;}return 0;}

Ungolfed

int main(){
int n,i,x=4;cin>>n;
while(n)
{
for(i=2;i<x-1;i++)
{
if(x%i==0){cout<<x<<' ';n--;break;}
}
x++;
}
return 0;
}

Comments

1. क्यों नहीं ungolfed संस्करण के लिए एक अच्छा स्वरूपण? 2. लगता है कि आपके पास दोनों कोड में अतिरिक्त ब्रेसिज़ हैं। 3. आप whileद्वारा प्रतिस्थापित कर सकते हैं for।

— क्वाटर्ली

Answer 12

जूलिया, 103 बाइट्स

n->(n>0&&println(4);n>1&&(i=0;c=big(6);while i<n-1 mod(factorial(c-1),c)<1&&(i+=1;println(c));c+=1end))

इसमें विल्सन के प्रमेय का उपयोग किया गया है।

Ungolfed:

function f(n::Int)
    # Always start with 4
    n > 0 && println(4)

    # Loop until we encounter n composites
    if n > 1
        i = 0
        c = big(6)
        while i < n-1
            if mod(factorial(c-1), c) == 0
                i += 1
                println(c)
            end
            c += 1
        end
    end
end

Answer 13

ECMAScript 6 - 107 91 84 बाइट्स

n=>eval('for(a=[],x=4;n&&!a[~-n];x++)for(y=2;y*2<=x;)if(x%y++<1){a.push(x);break}a')

फ़ंक्शन पहले nसमग्र संख्याओं की एक सरणी देता है ।

~-nलेखन का एक फैंसी तरीका है n-1; एक ही लंबाई, लेकिन बहुत अधिक मज़ा, सही?
मेरे द्वारा उपयोग किया जाने वाला एकमात्र कारण evalयह है कि टेम्पलेट n=>eval('...returnValue')1 वर्ण से छोटा है n=>{...return returnValue}।

पुराने संस्करणों

n=>eval('for(a=[],x=4;n&&!a[~-n];x++){for(z=0,y=2;y*2<=x;)if(x%y++<1)z=1;if(z)a.push(x)}a')

---

n=>eval('for(a=[],i=4;a.length<n;i++)if((x=>{for(y=2,z=1;y*2<=x;)if(x%y++<1)z=0;return!z})(i))a.push(i);a')

उत्पादन

 0 -> []
 1 -> [4]
 2 -> [4, 6]
 3 -> [4, 6, 8]
13 -> [4, 6, 8, 9, 10, 12, 14, 15, 16, 18, 20, 21, 22]

Answer 14

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

भारी रूप से निम्मी के पहले उत्तर से प्रेरित होकर , anyएक नेस्टेड सूची समझ के बजाय पॉइंटफ्री लैम्ब्डा के आधार पर 2-बाइट वाले छोटे के साथ विधेय की जगह ।

(`take`[x|x<-[4..],any((<)1.gcd x)[2..x-1]])

इसे ऑनलाइन आज़माएं!
( सटीक TIO लिंक के लिए लाइकोनी का धन्यवाद )

स्पष्टीकरण:

[x|x<-[4..],       -- consider all integers x >=4
[2..x-1]           -- consider all integers smaller than x
any((<)1.gcd x)    -- if for any of them 
    (<)1           -- 1 is smaller than
        .gcd x     -- the gcd of x and the lambda input
                   -- then we found a non-trivial factor and thus the number is composite
(`take`[  ])       -- take the first <argument> entries