27

बंद हो गया । इस प्रश्न के विवरण या स्पष्टता की आवश्यकता है । यह वर्तमान में उत्तर स्वीकार नहीं कर रहा है।

इस प्रश्न को सुधारना चाहते हैं? विवरण जोड़ें और इस पोस्ट को संपादित करके समस्या को स्पष्ट करें ।

पिछले साल बंद हुआ ।

नियम सरल हैं:

पहले n primes ( n के नीचे primes नहीं ), newlines द्वारा अलग किए गए मानक आउटपुट पर मुद्रित होना चाहिए (primes कोड के भीतर उत्पन्न होना चाहिए)
इनबिल्ट फ़ंक्शन या लाइब्रेरी के माध्यम से प्राइम उत्पन्न नहीं किए जा सकते हैं , अर्थात इनबिल्ट या लाइब्रेरी फ़ंक्शन का उपयोग, जैसे कि, Prime = get_nth_prime (n), is_a_prime (नंबर), या फ़ैक्टरलिस्ट = =all_factors (संख्या) बहुत रचनात्मक नहीं होगा।
स्कोरिंग - कहते हैं, हम स्कोर = f ([कोड में वर्णों की संख्या]), O ( f (n)) को आपके एल्गोरिथ्म की जटिलता के रूप में परिभाषित करते हैं जहां n यह पाया जाने वाले primes की संख्या है। उदाहरण के लिए, यदि आपके पास O (n ^ 2) जटिलता के साथ 300 char कोड है, तो O (n * ln (n)) के साथ 300 वर्णों के लिए स्कोर 300 ^ 2 = 90000 है , स्कोर 300 * 5.7 = 1711.13 ( बन जाता है) आइए सरलता के लिए सभी लॉग को प्राकृतिक लॉग मानें)
किसी भी मौजूदा प्रोग्रामिंग भाषा का उपयोग करें, सबसे कम स्कोर जीतता है

संपादित करें: O (f (n)) में 'n' क्या है, इस बारे में भ्रम के कारण समस्या को 'पहले 1000000 प्राइम' से 'पहले n primes' में बदलने से बदल दिया गया है, n आपके द्वारा खोजे जाने वाले प्राइम की संख्या है (प्रिडिम्स ढूंढना है) यहाँ समस्या और समस्या की इतनी जटिलता पाई गई प्राइम्स की संख्या पर निर्भर करती है)

नोट: जटिलता पर कुछ भ्रमों को स्पष्ट करने के लिए, यदि 'n' आपके द्वारा पाए जाने वाले अपराधों की संख्या है और 'N' n प्रधानमंत्री है, तो n के संदर्भ में जटिलता और N समतुल्य नहीं हैं अर्थात O (f (n))! = ओ (एफ (एन)) के रूप में, एफ (एन)! = निरंतर * एफ (एन) और एन! = निरंतर * एन, क्योंकि हम जानते हैं कि एनटी प्राइम फ़ंक्शन रैखिक नहीं है, हालांकि मैं तब से 'एन' पा रहा था। 'n' के संदर्भ में primes जटिलता आसानी से व्यक्त की जानी चाहिए।

जैसा कि किबी द्वारा बताया गया है, आप अपने समाधानों को सत्यापित करने के लिए इस साइट पर जा सकते हैं ( यहां , पुरानी Google डॉक्स सूची है)

कृपया इन्हें अपने समाधान में शामिल करें -

आपके कार्यक्रम में कौन सी जटिलता है (मूल विश्लेषण शामिल करें यदि तुच्छ नहीं)
कोड की वर्ण लंबाई
अंतिम गणना स्कोर

यह मेरा पहला कोडगॉल्फ प्रश्न है, इसलिए यदि उपरोक्त नियमों में कोई गलती या खामी है तो कृपया उन्हें इंगित करें।

code-challenge primes

— ऑप्टिमस
स्रोत

5

यह codegolf.stackexchange.com/questions/5977/… के समान है ।

— गारेथ

2

कि एक के लिए मेरा जवाब था 1[\p:i.78498इस लिए मेरा उत्तर होगा 1[\p:i.1000000। यहां तक कि यह मानते हुए कि J का आंतरिक प्रधान एल्गोरिथ्म O (n ^ 2) है, मेरा स्कोर अभी भी केवल 196 होगा।

— गारेथ

2

किसी को भी उनकी जटिलता की सही ढंग से गणना करने का प्रबंधन नहीं लगता है। इस बात nको लेकर भ्रम है कि क्या प्राइम की संख्या है या अधिकतम प्राइम है, और हर कोई इस तथ्य को नजरअंदाज करता है कि रेंज में संख्याओं का जोड़ 0..nहै O(logn), और गुणा और भाग भी अधिक महंगा है। मेरा सुझाव है कि आप उनकी सही जटिलता के साथ कुछ उदाहरण एल्गोरिदम दें।

— बदसूरत

3

के-बिट संख्या के लिए वर्तमान में जाना जाने वाला सबसे अच्छा परीक्षण है O-tilde(k^6)। इससे यह संकेत निकलता है कि जो कोई दौड़ने के समय से बेहतर होने O-tilde(n ln n (ln(n ln n))^6)का दावा करता है, उसे समस्या का कुछ हिस्सा गलत समझ में आता है; और इस सवाल के रूप में कि कैसे O-tildeस्कोरिंग में जटिलताओं को संभाला जाना चाहिए।

— पीटर टेलर

2

किसी ने ध्यान नहीं दिया, कि O (n) जटिलता शब्दों में O (kn) (निरंतर k के लिए) के बराबर है, लेकिन स्कोर के संदर्भ में नहीं है। उदाहरण के लिए, मान लीजिए कि मेरी जटिलता O (n ^ 10) है। यह O (n ^ 10 * 1E-308) के बराबर है, और मैं अभी भी भयानक जटिलता के साथ एक विशाल कार्यक्रम के साथ चुनौती जीत सकता हूं।

— JDL

10

पायथन (129 वर्ण, O (n * लॉग लॉग एन), 203.948 का स्कोर)

मैं कहूंगा कि Sieve of Eratosthenes जाने का रास्ता है। बहुत सरल और अपेक्षाकृत तेज।

N=15485864
a=[1]*N
x=xrange
for i in x(2,3936):
 if a[i]:
  for j in x(i*i,N,i):a[j]=0
print [i for i in x(len(a))if a[i]==1][2:]

पहले से बेहतर कोड।

पाइथन ( 191 156 152 वर्ण, O (n * लॉग लॉग एन) (?), 252.620 का स्कोर? ()

मैं सभी जटिलता की गणना नहीं कर सकता, यह सबसे अच्छा अनुमान है जो मैं दे सकता हूं।

from math import log as l
n=input()
N=n*int(l(n)+l(l(n)))
a=range(2,N)
for i in range(int(n**.5)+1):
 a=filter(lambda x:x%a[i] or x==a[i],a)
print a[:n]

n*int(l(n)+l(l(n)))वें अभाज्य संख्या की शीर्ष सीमा है n।

— beary605
स्रोत

1

जटिलता (और इस प्रकार स्कोर) गणना ऊपरी बाध्य पर आधारित है, nलेकिन primes की संख्या पर नहीं। इस प्रकार, मुझे लगता है कि स्कोर अधिक होना चाहिए। ऊपर मेरी टिप्पणी देखें।

— हॉवर्ड

ऊपरी बाउंड n? वह क्या है?

— beary605

यहां ऊपरी सीमा है N=15485864। पर आधारित जटिलता गणना के लिए n=1000000, आप कह सकते हैं N=n*log(n)(primes के घनत्व के कारण)।

— बदसूरत

यदि मेरे स्कोर को ठीक करने की आवश्यकता है, तो कृपया इसे मेरे लिए ठीक करें, मुझे अभी भी स्कोरिंग सिस्टम की अच्छी समझ नहीं है।

— beary605

अगर मैं पहले n primes खोजने के लिए समस्याओं को संशोधित करता तो @ beary605 ठीक होता? यह जटिलता पर बहुत सारे भ्रम को हल करेगा और O (f (n)) में क्या n है

— ऑप्टिमस

7

हास्केल, एन ^ 1.1 अनुभवजन्य विकास दर, 89 वर्ण, स्कोर 139 (?)

GHCi प्रॉम्प्ट पर निम्नलिखित कार्य करता है जब सामान्य पुस्तकालय जो इसका उपयोग करता है, पहले लोड हो चुका है। प्रिंट n -th प्राइम, 1-आधारित:

let s=3:minus[5,7..](unionAll[[p*p,p*p+2*p..]|p<-s])in getLine>>=(print.((0:2:s)!!).read)

यह ऑर्डर की गई सूचियों के लिए एक सामान्य-उपयोग वाली लाइब्रेरी का उपयोग करते हुए, इरैटोस्थनीज की अनबाउंड छलनी है। 100,000 और 200,000 अपराधों के बीच अनुभवजन्य जटिलता O(n^1.1)। के लिए फिट बैठता है O(n*log(n)*log(log n))।

जटिलता के अनुमान के बारे में

मैंने 100k और 200k primes के लिए रन समय मापा, फिर गणना की logBase 2 (t2/t1), जो उत्पादन किया n^1.09। परिभाषित करना g n = n*log n*log(log n), गणना करना logBase 2 (g 200000 / g 100000)देता है n^1.12।

फिर, 89**1.1 = 139यद्यपि g(89) = 600। --- (?)

ऐसा लगता है कि स्कोरिंग के लिए अनुमानित विकास दर का उपयोग जटिलता कार्य के बजाय स्वयं किया जाना चाहिए। उदाहरण के लिए, g2 n = n*((log n)**2)*log(log n)की तुलना में बहुत बेहतर है n**1.5, लेकिन 100 वर्णों के लिए क्रमशः के दो उत्पादन स्कोर 3239और 1000। यह सही नहीं हो सकता। 200k / 100k रेंज पर अनुमान देता है logBase 2 (g2 200000 / g2 100000) = 1.2और इस प्रकार स्कोर करता है 100**1.2 = 251।

इसके अलावा, मैं सभी अपराधों को प्रिंट करने का प्रयास नहीं करता, सिर्फ n -th प्राइम के बजाय।

कोई आयात नहीं, 240 चार्ट। n ^ 1.15 अनुभवजन्य विकास दर, स्कोर 546।

main=getLine>>=(print.s.read)
s n=let s=3:g 5(a[[p*p,p*p+2*p..]|p<-s])in(0:2:s)!!n
a((x:s):t)=x:u s(a$p t)
p((x:s):r:t)=(x:u s r):p t
g k s@(x:t)|k<x=k:g(k+2)s|True=g(k+2)t
u a@(x:r)b@(y:t)=case(compare x y)of LT->x:u r b;EQ->x:u r t;GT->y:u a t

— विल नेस
स्रोत

5

हास्केल, 72 89 वर्ण, हे (n ^ 2), स्कोर 7921

प्रति काउंट जीत का उच्चतम स्कोर सही है? पहले एन के लिए संशोधित। इसके अलावा, मैं जाहिरा तौर पर एक कैलकुलेटर का उपयोग नहीं कर सकता, इसलिए मेरा स्कोर उतना बुरा नहीं है जितना मैंने सोचा था। (बेसिक ट्रायल डिवीजन के लिए जटिलता का उपयोग करके जैसा कि नीचे स्रोत में पाया गया है)।

के अनुसार विल नेस नीचे एक पूर्ण हास्केल कार्यक्रम नहीं है (यह वास्तव में आरईपीएल पर निर्भर करता है)। निम्नलिखित एक छद्म छलनी के साथ एक अधिक संपूर्ण कार्यक्रम है (आयात वास्तव में एक चार को बचाते हैं, लेकिन मैं कोड गोल्फ में आयात को नापसंद करता हूं)।

main=getLine>>= \x->print.take(read x).(let s(x:y)=x:s(filter((>0).(`mod`x))y)in s)$[2..]

यह संस्करण निस्संदेह (एन ^ 2) है। एल्गोरिथ्म भोले `` छलनी 'का सिर्फ एक गोल्फ संस्करण है, जैसा कि यहां देखा गया है कि पुराना घी 1 लाइनर है

getLine>>= \x->print.take(read x)$Data.List.nubBy(\x y->x`mod`y==0)[2..]

पुराने, धोखा देने वाले जवाब को छोड़ दें क्योंकि पुस्तकालय जो इसे जोड़ता है वह बहुत अच्छा है।

print$take(10^6)Data.Numbers.Primes.primes

कार्यान्वयन और समय जटिलता के लिंक के लिए यहां देखें । दुर्भाग्य से पहियों में एक लॉग (n) लुकअप समय होता है, जो हमें एक कारक द्वारा धीमा कर देता है।

— walpen
स्रोत

• इनबिल्ट एक इनबिल्ट फंक्शनलन या लाइब्रेरी के माध्यम से उत्पन्न नहीं किया जा सकता है

— भालू

@walpen मुझे खेद है कि मैंने अधिसूचना के बिना नियमों को संशोधित किया है, कृपया बदलाव देखें जैसा कि आप फिट देखते हैं

— ऑप्टिमस

क्या ओ ((n ln n) ^ 1.5 ln (n ln n) ^ 0.585) की तरह जटिलता कुछ नहीं होगी? (या ओ ((n ln n) ^ 1.5 ln (n ln n)) यदि हास्केल भोले विभाजन का उपयोग करता है, जैसा कि मैंने माना है, करतसुबा)

— पीटर टेलर

नहीं, क्योंकि यह मुझे एक भयावह स्कोर देता है: /। लेकिन मुझे यकीन है कि तुम सही हो। यह सिर्फ ट्रायल डिवीजन की तरह लग रहा था, और यह ट्रायल डिवीजन की समय की जटिलता है (शायद, मेरे खराब रीडिंग कॉम्प्रिहेंशन के अनुसार संभवतः गलत स्रोत के कारण) इसलिए मैंने उसे चुना। अभी के लिए मैं अपना स्कोर NaN कहूंगा, जो सुरक्षित लगता है।

— Walpen

मैं मान रहा हूं (मेरा हास्केल नगण्य है, लेकिन मुझे पता है कि यह एसएमएल में कैसे करना स्वाभाविक होगा ...) कि आप केवल छोटे अपराधों द्वारा परीक्षण प्रभाग कर रहे हैं, जिस स्थिति में P पर परीक्षण विभाजन O करता है ( पी ^ 0.5 / एलएन पी) विभाजन। लेकिन अगर P के k बिट्स हैं, तो एक डिवीजन O (k ^ 1.585) (Karatsuba) या O (k ^ 2) (na ,ve) समय लेता है, और आपको O (n lg n) संख्या O (ln () के माध्यम से चलाने की आवश्यकता है n lg n)) बिट्स।

— पीटर टेलर

5

C #, 447 अक्षर, बाइट्स 452, स्कोर?

using System;namespace PrimeNumbers{class C{static void GN(ulong n){ulong primes=0;for (ulong i=0;i<(n*3);i++){if(IP(i)==true){primes++;if(primes==n){Console.WriteLine(i);}}}}static bool IP(ulong n){if(n<=3){return n>1;}else if (n%2==0||n%3==0){return false;}for(ulong i=5;i*i<=n;i+=6){if(n%i==0||n%(i+2)==0){return false;}}return true;}static void Main(string[] args){ulong n=Convert.ToUInt64(Console.ReadLine());for(ulong i=0;i<n;i++){GN(i);}}}}

स्क्रिप्ट्स वेरिएंट, 381 अक्षर, 385 बाइट्स, स्कोर?

using System;static void GetN(ulong n){ulong primes=0;for (ulong i=0;i<(n*500);i++){if(IsPrime(i)==true){primes++;if(primes==n){Console.WriteLine(i);}}}}public static bool IsPrime(ulong n){if(n<=3){return n>1;}else if (n%2==0||n%3==0){return false;}for(ulong i=5;i*i<=n;i+=6){if(n%i==0||n%(i+2)==0){return false;}}return true;}ulong n=Convert.ToUInt64(Console.ReadLine());for(ulong i=0;i<n;i++){GetN(i);}

यदि आप स्क्रिप्ट स्थापित करते हैं तो आप इसे चला सकते हैं।

PS मैंने यह विम में लिखा है :D

— XiKuuKy
स्रोत

2

आप कुछ अनावश्यक व्हाट्सएप को हटाकर कुछ पात्रों को बचा सकते हैं। उदाहरण के लिए, व्हाट्सएप को ए =और <साइन के आसपास रखना जरूरी नहीं है । इसके अलावा, मुझे नहीं लगता कि इस कोड के लिए बाइट्स और वर्णों में कोई अंतर है - यह 548 वर्ण और 548 बाइट्स है।

— प्रोग्रामफॉक्स

2

ओह धन्यवाद, यह मेरा पहला CodeGolf है!

— XiKuuKy

4

गोल्फस्क्रिप्ट (45 वर्ण, स्कोर दावा ~ 7708)

~[]2{..3${1$\%!}?={.@\+\}{;}if)1$,3$<}do;\;n*

यह सरल परीक्षण प्रभागों द्वारा करता है। यदि रूबी के कटिंग किनारे (यानी 1.9.3.0 का उपयोग करके) अंकगणित में टोम-कुक 3 गुणन का उपयोग किया जाता है, तो एक परीक्षण विभाजन ओ (n ^ 1.465) है और डिवीजनों की कुल लागत of है O((n ln n)^1.5 ln (n ln n)^0.465) = O(n^1.5 (ln n)^1.965)। हालाँकि, गोल्फस्क्रिप्ट में सरणी में एक तत्व जोड़ने के लिए सरणी की प्रतिलिपि बनाने की आवश्यकता होती है। मैंने इसे प्राइम की सूची को कॉपी करने के लिए अनुकूलित किया है, जब यह एक नया प्राइम पाता है, तो केवल nकुल समय में। प्रत्येक कॉपी ऑपरेशन O(n)आकार is के आइटम है O(ln(n ln n)) = O(ln n), दे रहा है O(n^2 ln n)।

और यह, लड़कों और लड़कियों, यही कारण है कि गंभीर प्रोग्रामिंग के लिए गोल्फस्क्रिप्ट गोल्फिंग के लिए उपयोग किया जाता है।

† O(ln (n ln n)) = O(ln n + ln ln n) = O(ln n)। मुझे विभिन्न पोस्ट पर टिप्पणी करने से पहले इसे देखना चाहिए था ...

— पीटर टेलर
स्रोत

4

यह इतना आसान है कि मेरे पाठ संपादक भी ऐसा कर सकते हैं!

विम: 143 कीस्ट्रोक्स (115 क्रियाएं): ओ (एन ^ 2 * लॉग (एन)): स्कोर: 101485.21

प्रस्तुत करने:

qpqqdqA^V^Ayyp<Esc>3h"aC@a<Esc>0C1<Esc>@"ddmpqdmd"bywo^Ra ^Rb 0 0 `pj@p ^Ra 0 ^R=@a%@b<Enter> `pdd@p 0 `dj@d<Esc>0*w*wyiWdd@0qqpmp"aywgg@dqgg@p

इनपुट: एन एक रिक्त दस्तावेज़ की पहली पंक्ति पर होना चाहिए। यह समाप्त होने के बाद, 2 से N तक प्रत्येक प्राइम एक अलग लाइन होगी।

कमांड चलाना:

सबसे पहले, ध्यान दें कि उनके सामने एक कैरेट के साथ कोई भी कमांड का मतलब है कि आपको Ctrl रखने की जरूरत है और अगला अक्षर टाइप करें (जैसे ^ V है Ctrl-vऔर ^ R है Ctrl-r)।

यह आपके @a, @b, @d, और @p रजिस्टरों में कुछ भी लिख देगा।

क्योंकि यह qकमांड का उपयोग करता है , इसे सिर्फ एक मैक्रो में नहीं रखा जा सकता है। हालाँकि, इसे चलाने के लिए कुछ सुझाव दिए गए हैं।

qpqqdq सिर्फ रजिस्टरों को साफ करता है
A^V^Ayyp<Esc>3h"aC@a<Esc>0C1<Esc>@"dd2 से N + 1 की संख्या बनाएगा। यह दो मुख्य भागों के बीच का विराम है, इसलिए एक बार ऐसा करने के बाद, आपको इसे दोबारा करने की आवश्यकता नहीं है
mpqdmd"bywo^Ra ^Rb 0 0 `pj@p ^Ra 0 ^R=@a%@b<Enter> `pdd@p 0 `dj@d<Esc>0*w*wyiWdd@0qqpmp"aywgg@dqgg@pएक बार में टाइप करने की जरूरत है। बैकस्पेस से बचने की कोशिश करें क्योंकि इससे कुछ खराब हो सकता है।
- यदि आप कोई गलती करते हैं, qdqqpqतो इस पंक्ति को फिर से आज़माएँ।

बड़े एन के लिए, यह बहुत धीमा है। N = 5000 को चलाने में लगभग 27 मिनट लगे; अपने आप को चेतावनी दी।

कलन विधि:

यह primes खोजने के लिए एक बुनियादी पुनरावर्ती एल्गोरिथ्म का उपयोग करता है। 1 और ए के बीच सभी अपराधों की एक सूची को देखते हुए, A + 1 अभाज्य है यदि यह primes की सूची में किसी भी संख्या से विभाज्य नहीं है। A = 2 पर प्रारंभ करें और सूची में जैसे वे पाए जाते हैं, उन्हें जोड़ दें। N पुनरावर्ती के बाद, सूची में N तक के सभी प्राइम होंगे।

जटिलता

इस एल्गोरिथ्म में O (nN) की एक जटिलता है, जहाँ N इनपुट संख्या है और n, N तक के अपराधों की संख्या है। प्रत्येक पुनरावर्तन परीक्षण n संख्याएँ, और N पुनरावर्ती परीक्षण किए जाते हैं, जिससे O (nN) प्राप्त होता है।

हालाँकि, N ~ n * log (n), O (n ² * log (n)) ( https://en.wikipedia.org/wiki/Prime_number_theorem#Approximations_for_the_nth_prime_number ) के रूप में अंतिम जटिलता देते हुए

व्याख्या

यह vim कमांड से प्रोग्राम फ्लो को समझना आसान नहीं है, इसलिए मैंने उसी प्रवाह के बाद इसे पायथन में फिर से लिखा। विम कोड की तरह, जब यह अंतिम छोर तक पहुंच जाएगा तो पायथन कोड त्रुटि करेगा। अजगर को बहुत अधिक पुनरावृत्ति पसंद नहीं है; यदि आप इस कोड को N> 150 या इसके साथ आज़माते हैं, तो यह अधिकतम पुनरावृत्ति गहराई तक पहुंच जाएगा

N = 20
primes = range(2, N+1)

# Python needs these defined.
mark_p = b = a = -1

# Check new number for factors. 
# This macro could be wrapped up in @d, but it saves space to leave it separate.
def p():
    global mark_d, mark_p, primes, a
    mark_d = 0
    print(primes)
    a = primes[mark_p]
    d()      

# Checks factor and determine what to do next
def d():
    global mark_d, mark_p, a, b, primes
    b = primes[mark_d]
    if(a == b): # Number is prime, check the next number
        mark_p += 1
        p()
    else:
        if(a%b == 0): # Number is not prime, delete it and check next number
            del(primes[mark_p])
            p()
        else: # Number might be prime, try next possible factor
            mark_d += 1
            d()

mark_p = 0 #Start at first number         
p()

अब, वास्तविक कीस्ट्रोक्स को तोड़ने के लिए!

qpqqdq@D और @p रजिस्टरों को साफ करता है। यह सुनिश्चित करेगा कि इन पुनरावर्ती मैक्रो को स्थापित करते समय कुछ भी न चले।
A^V^Ayyp<Esc>3h"aC@a<Esc>0C1<Esc>@"ddइनपुट को 2 से N + 1 तक की संख्या की सूची में बदल देता है। N + 1 प्रविष्टि @d मैक्रो को सेट करने के साइड इफेक्ट के रूप में हटा दी जाती है।
- विशेष रूप से, एक मैक्रो लिखता है जो एक संख्या बढ़ाता है, फिर उसे अगली पंक्ति पर कॉपी करता है, फिर यह 1 लिखता है और इस मैक्रो एन बार निष्पादित करता है।
mpqdmd"bywo^Ra ^Rb 0 0 `pj@p ^Ra 0 ^R=@a%@b<Enter> `pdd@p 0 `dj@d<Esc>0*w*wyiWdd@0q@d मैक्रो लिखते हैं, जो ऊपर d () फ़ंक्शन को लागू करता है। "यदि" कथन विम में लागू करने के लिए दिलचस्प हैं। खोज ऑपरेटर * का उपयोग करके, अनुसरण करने के लिए एक निश्चित मार्ग चुनना संभव है। आगे की आज्ञा को तोड़ते हुए हम आगे बढ़ते हैं
- mpqdयहां p मार्क सेट करें और @d मैक्रो को रिकॉर्ड करना शुरू करें। P चिह्न को सेट करने की आवश्यकता है इसलिए इस रन के रूप में कूदने के लिए एक ज्ञात बिंदु है
- o^Ra ^Rb 0 0 `pj@p ^Ra 0 ^R=@a%@b<Enter> `pdd@p 0 `dj@d<Esc> यदि / अन्यथा कथन पाठ लिखता है
- 0*w*wyiWdd@0 वास्तव में अगर इस कथन को निष्पादित करता है।
- इस कमांड को निष्पादित करने से पहले, लाइन में शामिल होगा @a @b 0 0 `pj@p @a 0 (@a%@b) `pdd@p 0 `dj@d
- 0 कर्सर को लाइन की शुरुआत में ले जाता है
- *w*w कोड को अगले निष्पादित करने के लिए कोड में ले जाता है
  1. अगर @a == @ बी `pj@p, जो कि @a के लिए अगले नंबर पर जाता है और उस पर @p चलता है।
  2. अगर @a! = @b और @ a% @ b == 0, यानी `pdd@p, जो वर्तमान संख्या @a को हटाता है, तो अगले पर @p चलाता है।
  3. if @a! = @b और @ a %% b! = 0, अर्थात `dj@d, जो @b के लिए अगला नंबर चेक करता है , यह देखने के लिए कि क्या वह @a का कारक है
- yiWdd@0 कमांड को 0 रजिस्टर में जमा करता है, लाइन हटाता है और कमांड चलाता है
- q @ मैक्रो की रिकॉर्डिंग समाप्त करता है
जब यह पहली बार चलाया जाता है, तो `pdd@pकमांड + N + 1 लाइन को हटाकर चलाया जाता है।
qpmp"aywgg@dq @p मैक्रो लिखता है, जो कर्सर के नीचे की संख्या को बचाता है, फिर पहली प्रविष्टि पर जाता है और उस पर @d चलाता है।
gg@p वास्तव में @p निष्पादित करता है ताकि यह पूरी फ़ाइल पर पुनरावृत्त हो जाए।

— डोमिनिक ए।
स्रोत

3

QBASIC, 98 चार्ट, जटिलता N Sqrt (N), अंक 970

I=1
A:I=I+2
FOR J=2 TO I^.5
    IF I MOD J=0 THEN GOTO A
NEXT
?I
K=K+1
IF K=1e6 THEN GOTO B
GOTO A
B:

— Kibbee
स्रोत

मैंने समस्या कथन को थोड़ा संशोधित किया है, अब इसके पहले 'एन' प्राइम ढूंढते हैं, मुझे बिना किसी नोटिफिकेशन के खेद है

— ऑप्टिमस

मुझे लगता है कि हम इस कार्यक्रम के लिए "इन-सोर्स" इनपुट मान सकते हैं; यानी, इनपुट अंक के ठीक बाद है IF K=(इसलिए प्रोग्राम की लंबाई में अंक शामिल नहीं होगा)। जैसा कि यह खड़ा है, कार्यक्रम पहले n primes को 2 सहित नहीं प्रिंट करता है, जिसे ?2शुरुआत में जोड़कर और बदलकर तय किया जा सकता K=...है K=...-1। कार्यक्रम भी से बाहर रिक्त स्थान लेने के द्वारा एक सा golfed किया जा सकता है J=2 TO, J=0 THEN, K=...-1 THEN, और indenting को हटाने के द्वारा। मेरा मानना है कि यह 96-चरित्र कार्यक्रम में परिणाम है।

— रेस

3

स्कला २६३ वर्ण

नई आवश्यकताओं के लिए फिट करने के लिए अद्यतन किया गया। नीचे दिए गए अपराधों की गणना के लिए एक उचित ऊपरी सीमा खोजने के साथ कोड का 25% सौदा।

object P extends App{
def c(M:Int)={
val p=collection.mutable.BitSet(M+1)
p(2)=true
(3 to M+1 by 2).map(p(_)=true)
for(i<-p){
var j=2*i;
while(j<M){
if(p(j))p(j)=false
j+=i}
}
p
}
val i=args(0).toInt
println(c(((math.log(i)*i*1.3)toInt)).take(i).mkString("\n"))
}

मुझे एक छलनी भी मिली।

यहाँ गणना की लागत का एक अनुभवजन्य परीक्षण है, विश्लेषण के लिए अपुष्ट:

object PrimesTo extends App{
    var cnt=0
    def c(M:Int)={
        val p=(false::false::true::List.range(3,M+1).map(_%2!=0)).toArray
        for (i <- List.range (3, M, 2)
            if (p (i))) {
                var j=2*i;
                while (j < M) {
                    cnt+=1
                    if (p (j)) 
                        p(j)=false
                    j+=i}
            }
        (1 to M).filter (x => p (x))
    }
    val i = args(0).toInt
    /*
        To get the number x with i primes below, it is nearly ln(x)*x. For small numbers 
        we need a correction factor 1.13, and to avoid a bigger factor for very small 
        numbers we add 666 as an upper bound.
    */
    val x = (math.log(i)*i*1.13).toInt+666
    println (c(x).take (i).mkString("\n"))
    System.err.println (x + "\tcount: " + cnt)
}
for n in {1..5} ; do i=$((10**$n)); scala -J-Xmx768M P $i ; done

निम्नलिखित मायने रखता है:

List (960, 1766, 15127, 217099, 2988966)

मुझे यकीन नहीं है कि स्कोर की गणना कैसे की जाएगी। क्या 5 और अक्षर लिखना लायक है?

scala> List(4, 25, 168, 1229, 9592, 78498, 664579, 5761455, 50847534).map(x=>(math.log(x)*x*1.13).toInt+666) 
res42: List[Int] = List(672, 756, 1638, 10545, 100045, 1000419, 10068909, 101346800, 1019549994)

scala> List(4, 25, 168, 1229, 9592, 78498, 664579, 5761455, 50847534).map(x=>(math.log(x)*x*1.3)toInt) 
res43: List[Int] = List(7, 104, 1119, 11365, 114329, 1150158, 11582935, 116592898, 1172932855)

बड़े एन के लिए यह उस सीमा में लगभग 16% की गणना को कम कर देता है, लेकिन स्कोर फॉर्मूला के लिए हम निरंतर कारकों पर विचार नहीं करते हैं?

नए बिग-ओ विचार:

1 000, 10 000, 100 000 primes और इतने पर खोजने के लिए, मैं primes x => (math.log (x) * x * 1.3 के घनत्व के बारे में एक सूत्र का उपयोग करता हूं जो बाहरी लूप को निर्धारित करता है जो मैं चला रहा हूं।

तो मानों के लिए मैं 1 से 6 => NPrimes (10 ^ i) में 9399, 133768 ... बार बाहरी लूप चलाता है।

मुझे पीटर ओ की टिप्पणी से मदद के साथ यह ओ-फंक्शन पुनरावृति से मिला, जिन्होंने एक्सप्रेशन के लिए बहुत अधिक मूल्य का सुझाव दिया था, 1.01 के बजाय उन्होंने 1.5 का सुझाव दिया:

def O(n:Int) = (math.pow((n * math.log (n)), 1.01)).toLong

O: (n: Int) लॉन्ग

val ns = List(10, 100, 1000, 10000, 100000, 1000*1000).map(x=>(math.log(x)*x*1.3)toInt).map(O)

ns: सूची [लंबी] = सूची (102, 4152, 91532, 1612894, 25192460, 364664351)

 That's the list of upper values, to find primes below (since my algorithm has to know this value before it has to estimate it), send through the O-function, to find similar quotients for moving from 100 to 1000 to 10000 primes and so on: 

(ns.head /: ns.tail)((a, b) => {println (b*1.0/a); b})
40.705882352941174
22.045279383429673
17.62109426211598
15.619414543051187
14.47513863274964
13.73425213148954

यह उद्धरण हैं, अगर मैं घातांक के रूप में 1.01 का उपयोग करता हूं। यह वही है जो काउंटर अनुभवजन्य रूप से पाता है:

ns: Array[Int] = Array(1628, 2929, 23583, 321898, 4291625, 54289190, 660847317)

(ns.head /: ns.tail)((a, b) => {println (b*1.0/a); b})
1.799140049140049
8.051553431205189
13.649578085909342
13.332251210010625
12.65003116535112
12.172723833234572

पहले दो मूल्य आउटलेयर हैं, क्योंकि मैंने छोटे मूल्यों (1000 तक) के लिए अपने अनुमान सूत्र के लिए निरंतर सुधार किया है।

1.5 के पीटर टेलर के सुझाव से ऐसा लगेगा:

245.2396265560166
98.8566987153728
70.8831374743478
59.26104390040363
52.92941829568069
48.956394784317816

अब मैं अपने मूल्य के साथ:

O(263)
res85: Long = 1576

लेकिन मैं अनिश्चित हूं, मैं अपने ओ-फंक्शन के कितने करीब आ सकता हूं।

— अज्ञात उपयोगकर्ता
स्रोत

क्षमा करें, मैंने जटिलता से संबंधित कुछ अस्पष्टता को कम करने के लिए समस्या कथन में कुछ बदलाव किए, (मुझे यकीन है कि आपका समाधान ज्यादा नहीं बदलेगा)

— ऑप्टिमस

यह प्रभावी रूप से primes द्वारा डिवीजन का परीक्षण है। आंतरिक लूप के माध्यम से समय की संख्या होती है O(M^1.5 / ln M), और हर बार जब आप O(ln M)काम करते हैं (जोड़), तो यह कुल मिलाकर होता है O(M^1.5) = O((n ln n)^1.5)।

— पीटर टेलर

With 1.5 के बजाय ^ 1.02 के साथ, def O(n:Int) = (math.pow((n * math.log (n)), 1.02)).toLongमैं मूल्यों के बहुत करीब हूं, अनुभवजन्य रूप से मेरे काउंटर के साथ मिला। मैं अपनी पोस्ट में अपने निष्कर्ष सम्मिलित करता हूं।

— उपयोगकर्ता अज्ञात

3

रूबी 66 वर्ण, O (n ^ 2) स्कोर - 4356

lazyरूबी 2.0 के बाद से उपलब्ध है, और 1.0/0एक अनंत सीमा पाने के लिए एक शांत चाल है:

(2..(1.0/0)).lazy.select{|i|!(2...i).any?{|j|i%j==0}}.take(n).to_a

— उड़ी अगासी
स्रोत

1

आप इसे बदल कर एक शेव कर सकते हैं(2..(1.0/0)).lazy.select{|i|!(2...i).any?{|j|i%j<1}}.take(n).to_a

— Qqwy

या यहां तक कि: (यह समाधान को कम कुशल बनाता है, लेकिन यह ऊपरी O (n bound) बाध्य नहीं बदलता है) (2..(1.0/0)).lazy.select{|i|(2..i).one?{|j|i%j<1}}.take(n).to_a। यह दो और पात्रों को हिलाता है।

— Qqwy

अच्छी तरह से इसे बदलने के (2..(1.0/0)).lazy.select{|i|!(2...i).any?{|j|i%j<1}}.first(n)परिणामस्वरूप 61 वर्ण होंगे।

— रिची

2

रूबी, 84 चार्ट, 84 बाइट, स्कोर?

यह शायद इन हिस्सों के लिए थोड़ा बहुत नौसिखिया है, लेकिन मुझे ऐसा करने में एक मजेदार समय था। यह बस तब तक लूप करता है जब तक कि f(primes पाया गया) बराबर है n, वांछित संख्या में primes पाए जाते हैं।

मज़े की बात यह है कि प्रत्येक लूप के लिए यह 2 से एक से कम संख्या का निरीक्षण करता है। फिर यह सरणी में प्रत्येक तत्व को मूल संख्या और तत्व का मापांक बनाता है, और यह देखने के लिए जांचता है कि क्या कोई परिणाम शून्य है।

इसके अलावा, मुझे नहीं पता कि इसे कैसे बनाया जाए।

अद्यतन करें

कोड को कॉम्पैक्ट किया गया और इसमें (पूरी तरह से मनमाना) मूल्य शामिल था n

n,f,i=5**5,0,2
until f==n;f+=1;p i if !(2...i).to_a.map{|j|i%j}.include?(0);i+=1;end

मूल

f, i = 0, 2
until f == n
  (f += 1; p i) if !(2...i).to_a.map{|j| i % j}.include?(0)
  i += 1
end

i += 1बिट और untilपाश सुधार के लिए क्षेत्रों के रूप में मुझ पर बाहर कूद की तरह हैं, लेकिन इस ट्रैक पर मैं अटक की तरह कर रहा हूँ। वैसे भी, यह सोचने में मज़ा आया।

— tydotg
स्रोत

2

स्काला, 124 वर्ण

object Q extends App{Stream.from(2).filter(p=>(2 to p)takeWhile(i=>i*i<=p)forall{p%_!= 0})take(args(0)toInt)foreach println}

वर्गमूल तक सरल परीक्षण विभाजन। इसलिए जटिलता O (n ^ (1.5 + epsilon)) होनी चाहिए

124 ^ 1.5 <1381, ताकि मेरा स्कोर मेरे हिसाब से हो?

— जिन
स्रोत

1

पर्ल - 94 अक्षर, O (n लॉग (n)) - स्कोर: 427

perl -wle '$n=1;$t=1;while($n<$ARGV[0]){$t++;if((1x$t)!~/^1?$|^(11+?)\1+$/){print $t;$n++;}}'

पायथन - 113 वर्ण

import re
z = int(input())
n=1
t=1
while n<z:
    t+=1
    if not re.match(r'^1?$|^(11+?)\1+$',"1"*t):
        print t
        n+=1

— alfasin
स्रोत

1

AWK, 96 86 बाइट्स

उपशीर्षक: माँ देखो! केवल जोड़ना और कुछ बहीखाता!

फ़ाइल fsoe3.awk:

{for(n=2;l<$1;){if(n in L)p=L[n]
else{print p=n;l++}
for(N=p+n++;N in L;)N+=p
L[N]=p}}

चलाएँ:

$ awk -f fsoe3.awk <<< 5
2
3
5
7
11
$ awk -f fsoe3.awk <<< 1000 | wc -l
1000

BASH, 133 बाइट्स

फ़ाइल x.bash:

a=2
while((l<$1));do if((b[a]))
then((c=b[a]));else((c=a,l++));echo $a;fi;((d=a+c))
while((b[d]));do((d+=c));done
((b[d]=c,a++));done

चलाएँ:

$ bash x.bash 5
2
3
5
7
11
$ bash x.bash 1000 | wc -l
1000

"सकारात्मक पूर्णांक के टेप" पर पहले से ही पाए गए कूदने की अनुमति देकर अपराधों की गणना की जाती है। मूल रूप से यह एराटोस्थनीज की क्रमबद्ध छलनी है।

from time import time as t

L = {}
n = 2
l = 0

t0=t()

while l<1000000:

        if n in L:
                P = L[n]
        else:
                P = n
                l += 1
                print t()-t0

        m = n+P
        while m in L:
                m += P
        L[m] = P

        n += 1

... पाइथन में एक ही एल्गोरिदम है और उस समय को प्रिंट करता है जब lप्राइम के बजाय -थ प्राइम पाया गया था।

gnuplotनिम्नलिखित पैदावार के साथ प्लॉट किए गए आउटपुट :

जंपर्स को डिस्क में बफर डेटा लिखने के कारण फ़ाइल i / o देरी के साथ कुछ करना है ...

खोजने के लिए बहुत अधिक संख्या में अपराधों का उपयोग करते हुए, खेल में अतिरिक्त प्रणाली पर निर्भर देरी लाएगा, उदाहरण के लिए "सकारात्मक पूर्णांक के टेप" का प्रतिनिधित्व करने वाला सरणी लगातार बढ़ता है और जल्दी या बाद में प्रत्येक कंप्यूटर को अधिक रैम (या बाद में स्वैप) के लिए रो देगा।

... तो प्रायोगिक आंकड़ों को देखकर जटिलता का अंदाजा लगाना वास्तव में बहुत मदद नहीं करता है ... :-(

अब nprimes खोजने के लिए आवश्यक परिवर्धन की गिनती :

cells = {}
current = 2
found = 0

additons = 0

while found < 10000000:

        if current in cells:
                candidate = cells[current]
                del cells[current] # the seen part is irrelevant
        else:
                candidate = current
                found += 1 ; additons += 1
                print additons

        destination = current + candidate ; additons += 1
        while destination in cells:
                destination += candidate ; additons += 1
        cells[destination] = candidate

        current += 1 ; additons += 1

आप उन रेखांकन को कैसे बनाएंगे?

— बिल्ली

1

Gnuplotके साथ set term xtermऔर फिर xtermग्राफिक्स-विंडो (शायद एक भूल सुविधा के पास) के स्क्रीनशॉट । ;-)

0

स्काला 121 (मुख्य वर्ग के बॉयलर के बिना 99)

object Q extends App{Stream.from(2).filter{a=>Range(2,a).filter(a%_==0).isEmpty}.take(readLine().toInt).foreach(println)}

— क्रिज़्सटॉफ़ वेंडे
स्रोत

0

पायथन 3, 117 106 बाइट्स

यह समाधान थोड़ा तुच्छ है, क्योंकि यह 0 को आउटपुट करता है जहां कोई संख्या प्रधान नहीं है, लेकिन मैं इसे वैसे भी पोस्ट करूंगा:

r=range
for i in[2]+[i*(not 0 in[i%j for j in r(3,int(i**0.5)+1,2)])for i in r(3,int(input()),2)]:print(i)

इसके अलावा, मुझे यकीन नहीं है कि एक एल्गोरिथ्म की जटिलता को कैसे काम किया जाए। कृपया इसकी वजह से न करें। इसके बजाय, अच्छा बनो और टिप्पणी करो कि मैं इसे कैसे काम कर सकता हूं। इसके अलावा, मुझे बताएं कि मैं इसे कैसे छोटा कर सकता हूं।

— 0WJYxW9FMN
स्रोत

मुझे लगता है कि आप रख सकते हैं print(i)पाश के लिए के रूप में एक ही लाइन पर और पर रिक्त स्थान को हटा दें in [2], 0 if, 0 in [i%jऔर +1,2)] else।

— एक्रोलिथ

@daHugLenny वाह, बहुत बहुत धन्यवाद! मैं अपनी पोस्ट एक सेकंड में संपादित करूँगा। :-D

— 0WJYxW9FMN

@daHugLenny क्या आप जानते हैं कि किसी भी मौके पर दक्षता की गणना कैसे की जा सकती है?

— 0WJYxW9FMN

कोई खेद नहीं। (टिप्पणियाँ कम से कम 15 वर्ण लंबी होनी चाहिए)

— एक्रोलिथ

फिर भी धन्यवाद। आपने मेरे कार्यक्रम को सबसे छोटा बना दिया है!

— 0WJYxW9FMN

0

हास्केल (52ask = 2704)

52`take`Data.List.nubBy(((1<).).gcd)[2..]`forM_`print

— रोमन Czyborra
स्रोत

0

पर्ल 6, 152 बाइट्स, ओ (एन लॉग एन लॉग (एन लॉग एन) लॉग (लॉग (एन लॉग एन)))?), 9594.79 अंक?

इस पृष्ठ के अनुसार , n तक सभी primes को खोजने की थोड़ी जटिलता हे (n लॉग एन लॉग लॉग एन); उपरोक्त जटिलता इस तथ्य का उपयोग करती है कि nth प्रधानमंत्री n लॉग एन के समानुपाती है।

my \N=+slurp;my \P=N*(N.log+N.log.log);my @a=1 xx P;for 2..P.sqrt ->$i {if @a[$i] {@a[$_*$i]=0 for $i..P/$i}};say $_[1] for (@a Z ^P).grep(*[0])[2..N+1]

— bb94
स्रोत

अर्हता प्राप्त नहीं करता है, यह अर्हता प्राप्त करने के लिए वेन्टेल में करते हैं

— noɐɹƆz

क्षमा करें, लेकिन आपका क्या मतलब है?

— बीबी 94

इनाम के लिए (fiiiiiiiiilerrrrr)

— noɐɹƆz

0

ग्रूवी (50 बाइट्स) - O (n * sqrt (n)) - स्कोर 353.553390593

{[1,2]+(1..it).findAll{x->(2..x**0.5).every{x%it}}}

N में लेता है और 1 से n तक के सभी नंबरों को आउटपुट करता है जो कि प्राइम हैं।

एल्गोरिथ्म को मैंने केवल n> 2 आउटपुट के लिए चुना है, इसलिए शुरुआत में 1,2 जोड़ना आवश्यक है।

टूट - फूट

x%it - यदि यह विभाज्य नहीं है, तो मिथ्या सत्य है, यदि यह सत्य है।

(2..x**0.5).every{...}- 2 और sqrt (एक्स) बीच के सभी मानों के लिए, सुनिश्चित करें कि उनका विभाज्य नहीं कर रहे हैं कि यह सच वापस जाने के लिए के लिए के लिए सच लौटना चाहिए हर ।

(1..it).findAll{x->...} - 1 और n के बीच के सभी मानों के लिए, 2 और sqrt (n) के बीच गैर-विभाजक होने के मानदंड को फिट करें।

{[1,2]+...} - जोड़ें और 2, क्योंकि वे हमेशा प्रमुख होते हैं और एल्गोरिथ्म द्वारा कभी भी कवर नहीं किए जाते हैं।

— जादू ऑक्टोपस Urn
स्रोत

0

रैकेट 155 बाइट्स

(let p((o'(2))(c 3))(cond[(>=(length o)n)(reverse o)][(ormap(λ(x)(= 0(modulo c x)))
(filter(λ(x)(<= x(sqrt c)))o))(p o(add1 c))][(p(cons c o)(add1 c))]))

यह पहले से पाए गए अपराधों द्वारा प्राप्त की गई प्रमुख संख्याओं की एक सूची रखता है और प्रत्येक अगले नंबर की विभाज्यता की जांच करता है। इसके अलावा, यह जाँच करता है कि संख्या का वर्गमूल केवल इतना है कि पर्याप्त है।

Ungolfed:

(define(nprimes n)
  (let loop ((outl '(2))                   ; outlist having primes being created
             (current 3))                  ; current number being tested
  (cond
    [(>= (length outl) n) (reverse outl)]  ; if n primes found, print outlist.
    [(ormap (λ(x) (= 0 (modulo current x))) ; test if divisible by any previously found prime
            (filter                         ; filter outlist till sqrt of current number
             (λ(x) (<= x (sqrt current)))
             outl))
     (loop outl (add1 current)) ]           ; goto next number without adding to prime list
    [else (loop (cons current outl) (add1 current))] ; add to prime list and go to next number
    )))

परिक्षण:

(nprimes 35)

आउटपुट:

'(2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97 101 103 107 109 113 127 131 137 139 149)

— rnso
स्रोत

0

जाग 45 (जटिलता एन ^ 2)

एक और awk, इस तरह के उपयोग के लिए 100 तक के लिए

awk '{for(i=2;i<=sqrt(NR);i++) if(!(NR%i)) next} NR>1' <(seq 100)

कोड गोल्फ गिना भाग है

{for(i=2;i<=sqrt(NR);i++)if(!(NR%i))next}NR>1

जिसे एक स्क्रिप्ट फ़ाइल में रखा जा सकता है और जैसा कि चलाया जा सकता है awk -f prime.awk <(seq 100)

— karakfa
स्रोत

0

जावास्क्रिप्ट, 61 वर्ण

f=(n,p=2,i=2)=>p%i?f(n,p,++i):i==p&&n--&alert(p)||n&&f(n,++p)

O (n ^ 2) से थोड़ा खराब, बड़े n के लिए स्टैक स्पेस से बाहर चलेगा।

— SudoNhim
स्रोत

पहले n अभाज्य संख्याओं की सूची सबसे कुशलता से और सबसे छोटे कोड में [बंद]

पायथन (129 वर्ण, O (n * लॉग लॉग एन), 203.948 का स्कोर)

पाइथन ( 191 156 152 वर्ण, O (n * लॉग लॉग एन) (?), 252.620 का स्कोर? ()

हास्केल, एन ^ 1.1 अनुभवजन्य विकास दर, 89 वर्ण, स्कोर 139 (?)

जटिलता के अनुमान के बारे में

कोई आयात नहीं, 240 चार्ट। n ^ 1.15 अनुभवजन्य विकास दर, स्कोर 546।

हास्केल, 72 89 वर्ण, हे (n ^ 2), स्कोर 7921

C #, 447 अक्षर, बाइट्स 452, स्कोर?

स्क्रिप्ट्स वेरिएंट, 381 अक्षर, 385 बाइट्स, स्कोर?

गोल्फस्क्रिप्ट (45 वर्ण, स्कोर दावा ~ 7708)

विम: 143 कीस्ट्रोक्स (115 क्रियाएं): ओ (एन ^ 2 * लॉग (एन)): स्कोर: 101485.21

प्रस्तुत करने:

कमांड चलाना:

कलन विधि:

जटिलता

व्याख्या

स्कला २६३ वर्ण

नए बिग-ओ विचार:

रूबी, 84 चार्ट, 84 बाइट, स्कोर?

अद्यतन करें

मूल

स्काला, 124 वर्ण

पर्ल - 94 अक्षर, O (n लॉग (n)) - स्कोर: 427

पायथन - 113 वर्ण

AWK, 96 86 बाइट्स

BASH, 133 बाइट्स

स्काला 121 (मुख्य वर्ग के बॉयलर के बिना 99)

पायथन 3, 117 106 बाइट्स

हास्केल (52ask = 2704)

पर्ल 6, 152 बाइट्स, ओ (एन लॉग एन लॉग (एन लॉग एन) लॉग (लॉग (एन लॉग एन)))?), 9594.79 अंक?

ग्रूवी (50 बाइट्स) - O (n * sqrt (n)) - स्कोर 353.553390593

टूट - फूट

रैकेट 155 बाइट्स

जावास्क्रिप्ट, 61 वर्ण