असीम रूप से कई ℕ
पृष्ठभूमि:
अनंत नलिकाओं का एक अनुक्रम एक अनुक्रम है जिसमें हर प्राकृतिक संख्या में कई बार असीमता होती है।
स्पष्ट करने के लिए, हर संख्या को कई बार मुद्रित किया जाना चाहिए!
चुनौती:
सबसे छोटे कोड के साथ अनंत नटल्स का एक क्रम आउटपुट।
नियम:
- प्रत्येक संख्या को एक (परिमित) दृश्यमान, व्हाट्सएप या नई पंक्ति वर्णों द्वारा अलग किया जाना चाहिए जो एक अंक नहीं हैं।
- कार्यक्रम समाप्त नहीं हो सकता (जब तक कि आपने किसी तरह सभी नंबर नहीं लिखे)।
- इस तरह के अनुक्रम को लिखने का कोई भी तरीका स्वीकार्य है।
उदाहरण:
1
1 2
1 2 3
1 2 3 4
1 2 3 4 5
1 2 3 4 5 6
1 2 3 4 5 6 7
...
1, 1, 2, 1, 2, 3, 1, 2, 3, 4...
ध्यान दें कि हम सभी एन ℕ we के लिए 1 से एन तक सभी नैचुरल लिखते हैं।
प्रश्न का फीडबैक और संपादन स्वागत योग्य है। मेरी पथरी परीक्षा से प्रेरित।
जवाब
स्क्रैच 3.0 , 13 20 ब्लॉक / 121 70 बाइट्स

एसबी सिंटैक्स के रूप में:
define(n)(i
say(i
((n)+<(i)=(n)>)((1)+((i)*<(i)<(n
यह प्रत्येक पद क्रम में कहता है। एक देरी को जोड़ा जा सकता है ताकि संख्या तेजी से आग न करें।
मैंने कभी खरोंच को इतना गाली देते नहीं देखा। आप खाली नाम फ़ंक्शन को खाली मापदंडों के साथ कहते हैं । हे भगवान। जो कुछ भी बाइट्स बचाता है!
-51 धन्यवाद @ @
इसे स्क्रैच पर आज़माएं
स्पष्टीकरण जल्द ही आ रहा है।
भूसी , 2 बाइट्स
ḣN
इसे ऑनलाइन आज़माएं!
पहले हुस्क जवाब! प्रश्न में अनुक्रम का भी उपयोग करता है
यह काम किस प्रकार करता है
ḣN - Main program
N - The infinite list [1, 2, 3, ...]
ḣ - Prefixes; [[1], [1, 2], [1, 2, 3], ...]
05AB1E , 2 बाइट्स
∞L
इसे ऑनलाइन आज़माएं! पाद लेख आउटपुट को पोस्ट से उदाहरण की तरह प्रारूपित करता है।
∞
सभी प्राकृतिक संख्याओं की सूची को आगे बढ़ाता है, प्रत्येक संख्या के लिए L
सीमा लेता है [1 .. n]
।
आर , 26 25 24 बाइट्स
डोमिनिक वैन एसेन को -1 बाइट
repeat cat(rpois(9,9)+1)
इसे ऑनलाइन आज़माएं!
पूर्णांक का एक यादृच्छिक अनंत अनुक्रम आउटपुट, \ से तैयार$Poisson(9)\$वितरण (किसी भी 0s outputting से बचने के लिए +1)। वे एक समय में 9 के बैच में आउटपुट होते हैं, अधिक "दक्षता" के लिए। माध्य का कोई सकारात्मक मूल्य काम करेगा; 9 के एक माध्यम का उपयोग करके 1-वर्ण संख्या के लिए भिन्नता को अधिकतम किया जाता है।
सभी संख्याएं अक्सर इस अर्थ में दिखाई देती हैं कि किसी भी पूर्णांक के लिए \ _$k\$होने की अपेक्षित संख्या \ _$k\$पहले \ में$n\$अहसास \ _ को जाता है$\infty\$के रूप में \$n\to\infty\$:
$$E\left[\sum_{i=1}^n\mathbb{I}_{X_i=k}\right]\xrightarrow[n\to\infty]{}\infty.$$
कॉल का cat
मतलब है कि 9 के एक बैच के भीतर पूर्णांक रिक्त स्थान से अलग हो जाते हैं, लेकिन बैचों के बीच कोई विभाजक नहीं है। आउटपुट में 3- और 4-अंकीय संख्याओं का विशाल बहुमत इस कलाबाजी के कारण है, लेकिन एक सैद्धांतिक गारंटी है कि इस तरह की संख्याएँ (और बड़ी संख्याएँ) अंततः आउटपुट होंगी, कम से कम अगर हम मानते हैं कि अंतर्निहित यादृच्छिक संख्या जनरेटर पूर्ण है।
एक बड़े संस्करण के लिए, हम एक ही बाइट गिनती के लिए Giuseppe के सुझाव का पालन कर सकते हैं:
repeat cat(1%/%runif(9))
इसे ऑनलाइन आज़माएं!
यह अधिक 1
एस और अधिक बड़ी संख्याओं को प्रेरित करता है (कुछ बहुत बड़ी संख्याओं के लिए धन्यवाद सहित cat
)। फिर से, किसी भी पूर्णांक की घटनाओं की संख्या अनंत तक जाती है जब आउटपुट का आकार अनंत तक जाता है।
दो अन्य आर उत्तर निर्धारक तरीकों का उपयोग करते हुए कम निकलते हैं: Giuseppe's और Dominic van Essen's
पायथन 2 , 31 बाइट्स
R=1,
while 1:print R;R+=len(R),
इसे ऑनलाइन आज़माएं!
यहाँ एक बाइट को बचाने के लिए @ डानीस को धन्यवाद R+=R[-1]+1,
। यह
प्रिंट:
(1,)
(1, 1)
(1, 1, 2)
(1, 1, 2, 3)
(1, 1, 2, 3, 4)
(1, 1, 2, 3, 4, 5)
...
प्रत्येक बार अंतिम तत्व को जोड़ते हुए 1 से n (1 को छोड़कर दो बार दिखाई देता है) की संख्या की सूची तैयार करता है।
32 बाइट्स
R=[1]
for x in R:print R;R+=x+1,
इसे ऑनलाइन आज़माएं!
अजगर 2 , 30 बाइट्स (अनुमान)
n=2
while 1:print~-2**n%n;n+=1
इसे ऑनलाइन आज़माएं!
के अनुक्रम \$2^n \bmod n\$( A015910 ) सभी मानों पर लेने के लिए अनुमान लगाया गया है \$k \geq 0\$सिवाय \$k=1\$। मुझे नहीं पता कि क्या यह भी अनुमान लगाया गया है कि प्रत्येक मूल्य कई बार असीम रूप से प्रकट होता है, लेकिन यह विशिष्ट मूल्यों के लिए ज्ञात समाधानों के अनुरूप है ।
हम बजाय गणना \$(2^n-1) \bmod n\$है, जो बनाता है \$0\$इसके बजाय \$1\$ केवल लापता मान (यदि अनुमान रखता है)।
आउटपुट को देखते हुए, आप सोच सकते हैं कि \$2\$कभी आउटपुट नहीं होता है, लेकिन वास्तव में यह पहली बार \ _ के लिए दिखाई देता है$n=4700063497\$और A050259 में उत्तरोत्तर उच्च मूल्यों के लिए ।
पायथन 2 , 33 बाइट्स
R=[1]
for x in R:print x;R+=x+1,1
इसे ऑनलाइन आज़माएं!
यह लंबे समय तक है, लेकिन यह बहुत सुंदर है, ABACABA अनुक्रम को मुद्रित करता है ।
हास्केल , 17 बाइट्स
[[1..x]|x<-[1..]]
इसे ऑनलाइन आज़माएं!
चूंकि चुनौती गैर-फ्लैट आउटपुट की अनुमति देने के लिए लगती है, हम केवल सूची की एक सूची उत्पन्न कर सकते हैं [1],[1,2],[1,2,3,],...
, जैसा कि @AZTECCO द्वारा सुझाया गया है।
हास्केल , 19 बाइट्स
l=1:do x<-l;[x+1,1]
इसे ऑनलाइन आज़माएं!
ABACABA अनुक्रम 1,2,1,3,1,2,1,4,...
( A001511 ) के साथ एक पुनरावर्ती रूप से परिभाषित अनंत फ्लैट सूची ।
एक समान-लंबाई वाला संस्करण:
l=(:[1]).succ=<<0:l
इसे ऑनलाइन आज़माएं!
20 बाइट्स
l=do x<-[1..];[1..x]
इसे ऑनलाइन आज़माएं!
गिनती हो रही है 1,1,2,1,2,3,1,2,3,4,...
, लेकिन एक फ्लैट सूची के रूप में।
बैश + जीएनयू कोरुटिल्स, 20
seq -fseq\ %g inf|sh
इसे ऑनलाइन आज़माएं! - 60 सेकंड के बाद टाइम्स आउट।
सेड 4.2.2 , 20
:;s/(1*).*/1\1 &/p;b
इसे ऑनलाइन आज़माएं!
इस सर्वसम्मति के अनुसार आउटपुट एकात्मक है ।
बैश , 20 बाइट्स
seq inf|xargs -l seq
इसे ऑनलाइन आज़माएं!
आर , 21 बाइट्स
(साथ ही रॉबिन राइडर द्वारा पहचाना गया)
while(T<-T+1)cat(T:0)
इसे ऑनलाइन आज़माएं!
उदाहरण अनुक्रम के समान है, लेकिन प्रत्येक उप-श्रृंखला उलट है, और प्रत्येक उपश्रेणी में प्रारंभिक मूल्य एक प्रारंभिक शून्य (इसलिए, 03
3 के लिए, उदाहरण के लिए) के साथ दर्शाया गया है ।
यदि आप प्रारंभिक शून्य पसंद नहीं करते हैं, तो पिछले संस्करण का उपयोग करके show
(नीचे), या ग्यूसेप के उत्तर को देखें ।
आर , 23 22 बाइट्स
संपादित करें: रॉबिन राइडर को -1 बाइट धन्यवाद
while(T<-T+1)show(1:T)
इसे ऑनलाइन आज़माएं!
उदाहरण में उपयोग किए गए अनुक्रम को आउटपुट करता है, साथ ही संख्या की प्रतियों की एक अतिरिक्त अनंत संख्या 1
।
प्रत्येक संख्या को या तो एक स्थान "
", एक नई रेखा प्लस ब्रैकेट, " \n[
", या एक ब्रैकेट प्लस स्थान " [
" द्वारा अलग किया जाता है ।
2-बाइट्स गोल्फर (पोस्टिंग के समय, कम से कम ...) अन्य दो आर उत्तरों की तुलना में ...
जेली , 4 बाइट्स
‘RṄß
इसे ऑनलाइन आज़माएं!
मुझे लगता है कि यह सभी संख्याओं को एक अनंत बार संख्या में बदल देता है, लेकिन क्योंकि यह एक अलग आउटपुट प्रारूप है, इसलिए मुझे 100% यकीन नहीं है
यह काम किस प्रकार करता है
‘RṄß - Main link. Left argument is initially n = 0
‘ - Increment
R - Range
Ṅ - Print
ß - Recursively run the main link
के लिए n = 0
, ‘RṄ
आउटपुट [1]
। हम फिर से उपयोग करते हैं n = [1]
। ‘RṄ
तब आउटपुट [[1, 2]]
, और हम पुन: उपयोग करते हैं n = [[1, 2]]
, जो आउटपुट [[[1, 2], [1, 2, 3]]]
आदि।
ऑक्टेव , 29 28 बाइट्स
do disp(fix(1/rand)) until 0
इसे ऑनलाइन आज़माएं!
यह एक अनुक्रम आउटपुट करता है \$(x_k)\$स्वतंत्र, समान रूप से यादृच्छिक प्राकृतिक संख्याओं का वितरण किया। प्रत्येक मान \$x_k\$के रूप में प्राप्त किया जाता है \$1/r\$शून्य की ओर गोल, जहां \$r\$अंतराल पर एक समान वितरण है \$(0,1)\$।
किसी दिए गए सूचकांक \ के लिए$k\$, और किसी भी के लिए \$n \in \mathbb N\$एक गैर-संभावना है कि \$x_k=n\$(फ्लोटिंग-पॉइंट अशुद्धि की अनदेखी)। इसलिए, संभावना के साथ \$1\$हर \ _$n\$अक्सर अनुक्रम में असीम रूप से प्रकट होता है \$(x_k)\$।
आर , 25 21 बाइट्स
repeat T=print(T:0+1)
इसे ऑनलाइन आज़माएं!
प्रिंट 2..1, 3..1, 4..1
और आगे।
-4 बाइट्स के लिए रॉबिन राइडर को धन्यवाद।
यह काम करता है क्योंकि print
अदृश्य रूप से अपना पहला तर्क देता है।
Befunge , 5 बाइट्स
>1+?.
इसे ऑनलाइन आज़माएं!
प्रत्येक आउटपुट पर, 50% संभावना होती है कि वर्तमान संख्या प्रिंट हो जाएगी और 1 पर रीसेट हो जाएगी, और 50% मौका जो 2
प्रिंट होगा और वर्तमान संख्या कुछ यादृच्छिक विषम संख्या (एक घातांक वितरण के बाद) बढ़ जाएगी। यह कई बार हो सकता है, इसलिए विषम संख्याओं को भी आउटपुट किया जा सकता है।
हर प्राकृतिक संख्या में होने की संभावना न के बराबर होती है, इसलिए यह अंततः कई बार असीम रूप से छपी होगी।
व्याख्या
>1+?.
> # Go east.
1+ # Initialize a counter to 1.
? # Go in a random direction.
# If the instruction pointer goes west:
+ # Add the top two stack elements together.
# If there is a 2 on top, this adds it to the counter.
# If not, this does nothing.
1 # Create a new 1 on the top of the stack.
> # Go east.
1+ # Add 1 to get 2, which remains on top of the counter.
? # Repeat.
? # If the IP goes east:
. # Print and delete the top of the stack.
> # Go east.
1+ # Add 1.
# If there was a 2 that was printed and the counter remains, the 1 gets added to it.
# If the counter was printed instead, this creates a new 1.
? # Repeat.
? # If the IP goes north or south, it wraps around to the ? instruction and repeats.
Befunge-98 , 14 बाइट्स
]:.1-:0`j
]:+!
इसे ऑनलाइन आज़माएं!
एक निर्धारक समाधान, प्रत्येक श्रेणी को n
अवरोही क्रम में 1 से प्रिंट करना ।
व्याख्या
] # Turn right (to the south) and go to the second line.
]:+!
] # Turn right again (to the west).
! # Take the logical NOT of the secondary counter (which is now 0) to get 1.
+ # Add the 1 to the main counter.
: # Duplicate the main counter to form a secondary counter.
] # Turn right (to the north) and go to the first line.
]:.1-:0`j
] # Turn right (to the east).
: # Duplicate the secondary counter.
. # Print and delete the duplicate.
1- # Subtract 1 from the secondary counter.
0` # Is the secondary counter greater than 0?
j # If so, jump over the ] instruction and repeat the first line.
] # If not, turn right (to the south) and go to the second line.
संदेश , 27 बाइट्स
>v
1","@"}
^+^<#-1
1+<<<
इसे ऑनलाइन आज़माएं!

यह क्रमिक संख्या से नीचे गिना जाता है।
वोल्फ्राम लैंग्वेज (गणितज्ञ) , 25 बाइट्स
Do[Print@n,{m,∞},{n,m}]
इसे ऑनलाइन आज़माएं!
-1 बाइट @ट
ब्रेकीलॉग , 4 बाइट्स
⟦₁ẉ⊥
इसे ऑनलाइन आज़माएं!
ẉ Print with a newline
⟦₁ the range from 1 to something,
⊥ then try again.
जे , 13 बाइट्स
$:@,~[echo@#\
इसे ऑनलाइन आज़माएं!
आउटपुट 1
, 1 2
, 1 2 3 4
, 1 2 3 4 5 6 7 8
, आदि, अपनी पंक्ति में हर नंबर के साथ।
echo@#\
वर्तमान सूची की उपसर्ग लंबाई को आउटपुट करें, यानी1..n
n जहां वर्तमान सूची की लंबाई है। यह एक साइड इफेक्ट के रूप में किया जाता है।$:@,~
सूची को अपने आप में जोड़ें,~
और फ़ंक्शन को पुनरावर्ती रूप से कॉल करें$:@
।
जंग , 54 बाइट्स
(2..).for_each(|x|(1..x).for_each(|y|print!("{} ",y)))
इसे ऑनलाइन आज़माएं
रूबी , 17 बाइट्स
loop{p *1..$.+=1}
इसे ऑनलाइन आज़माएं!
चारकोल , 8 बाइट्स
W¹«I⊕ⅉD⸿
इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। बार-बार अगले नंबर को कैनवास पर प्रिंट करके काम करता है और फिर पूरे कैनवास को डंप करता है।
2 एक संस्करण है कि प्रिंट के लिए बाइट्स \$ n \$एक अनुक्रम की अवधि:
IΣ
इसे ऑनलाइन आज़माएं! स्पष्टीकरण: बस इनपुट के डिजिटल योग को प्रिंट करता है। किसी भी प्राकृतिक संख्या को देखते हुए \$ n \$, फॉर्म के सभी मूल्य \$ \frac { 10 ^ n - 1 } 9 10 ^ m \$की एक डिजिटल योग है \$ n \$हर के लिए \$ m \$, इस प्रकार प्रत्येक प्राकृतिक संख्या अक्सर असीम रूप से प्रकट होती है।
सी (जीसीसी) , 43 बाइट्स
i;main(j){for(;;)printf("%d ",j=--j?:++i);}
इसे ऑनलाइन आज़माएं!
जावास्क्रिप्ट (V8) , 26 बाइट्स
for(a=b='';;)write(a+=--b)
इसे ऑनलाइन आज़माएं!
चरित्र -
एक विभाजक के रूप में उपयोग किया जाता है और आउटपुट इसके साथ शुरू होता है, इसलिए यदि यह स्वीकार्य है तो मैं वास्तव में निश्चित नहीं हूं।
सी (जीसीसी) , 52 49 44 बाइट्स
AZTECCO के लिए धन्यवाद 5 बाइट्स बचाया !!!
f(i,j){for(j=1;printf("%d ",j--);)j=j?:++i;}
इसे ऑनलाइन आज़माएं!
जावा (JDK) , 61 बाइट्स
v->{for(int i,j=2;;j++)for(i=0;++i<j;)System.out.println(i);}
इसे ऑनलाइन आज़माएं!
संपादित करें: धन्यवाद @user कुछ बाइट्स शेविंग और आज मुझे कुछ सीखने में मदद करने के लिए! -2 बाइट्स के लिए @KevinCruijssen को बड़ा धन्यवाद।
बैश, 21 बाइट्स
s(){ seq $[++n];s;};s
1
1
2
1
2
3
…
ऑनलाइन प्रयास करें पर 21B संस्करण चलाएँ
यह एक समारोह को परिभाषित करता है s
कि रन seq NUMBER
जहां NUMBER
पर शुरू होता है 1
प्रत्येक रन के साथ और वेतन वृद्धि, तो यह अपने आप में रिकर्सिवली चलाता है। परिभाषा के बाद, हम चलाते हैं s
।
निर्दिष्ट करने के लिए 5B की लागत के लिए -s\
(विभाजक एक अंतरिक्ष वर्ण है), इसे 26 बाइट्स पर प्रति पंक्ति समाधान एक उत्तर के लिए अनुकूलित किया जा सकता है :
s(){ seq -s\ $[++n];s;};s
1
1 2
1 2 3
…
ऑनलाइन प्रयास करें पर 26B संस्करण चलाएँ
Zsh, 29 .. 19 बाइट्स
@AdamKatz द्वारा समाधान: इसे ऑनलाइन आज़माएं!
for ((;++i;))seq $i
19 बाइट्स, बैश से पोर्ट: s(){seq $[++n];s};s
25 बाइट्स (प्रति @ एडाम्काट्ज): for ((;++i;))echo {1..$i}
25 बाइट्स : for ((;;i++))shuf -i 1-$i
26 बाइट्स (प्रति @ एड्मकजेट): for ((;;))echo {1..$[++i]}
29 बाइट्स : for ((i=1;;))echo {1..$[i++]}
मैंने /dev/random
एक विकल्प के लिए उपयोग करने की कोशिश की, लेकिन यह गड़बड़ थी!
पर्ल 5 , 22 20 बाइट्स
say while$_.=++$i.$"
इसे ऑनलाइन आज़माएं!
AWK , 34 बाइट्स
{for(;;++i)for(j=0;j++<i;)print j}
इसे ऑनलाइन आज़माएं!
APL (Dyalog Unicode) , 12 11 बाइट्स (SBCS)
@ ब्वॉयज को 1 बाइट धन्यवाद दिया
{∇1+⍴⎕←⍳⍵}1
इसे ऑनलाइन आज़माएं!
यह प्रश्न से अनुक्रम का उपयोग भी करता है।