एन से गुणा या विभाजित करें
यहाँ एक सरल चुनौती है, इसलिए उम्मीद है कि बहुत सारी भाषाएँ भाग ले सकेंगी।
एक सकारात्मक पूर्णांक को देखते हुए \$n\$, आउटपुट \$A076039(n)\$से OEIS ।
यह है, \ के साथ शुरू$a(1)=1\$। फिर के लिए \$n>1\$:
$$a(n)=\left\{ \begin{array}{ll} n\cdot a(n-1), & \text{if } n>a(n-1) \\ \lfloor a(n-1)/n \rfloor, & \text{otherwise.}\end{array} \\ \right. $$
परीक्षण के मामलों:
1 -> 1
2 -> 2 (2 > 1, so multiply)
3 -> 6 (3 > 2, so multiply)
4 -> 1 (4 < 6, so divide and take the integer part)
5 -> 5
6 -> 30
17 -> 221
99 -> 12
314 -> 26
अधिक परीक्षण मामलों को OEIS पृष्ठ पर पाया जा सकता है।
सामान्य अनुक्रम नियमों के अनुसार, आप आम तौर पर स्वीकृत तरीके से इनपुट और आउटपुट कर सकते हैं: 1- या 0-आधारित अनुक्रमण, आउटपुट एक अनंत अनुक्रम, पहला \ आउटपुट$n\$मान, आउटपुट केवल \$n^\text{th}\$ मूल्य, और इसके आगे, लेकिन यह निर्दिष्ट करें कि आपके उत्तर में।
यह कोड-गोल्फ है , इसलिए प्रत्येक भाषा में बाइट्स में सबसे छोटा कोड जीत जाता है!
जवाब
जेली , 6 बाइट्स
R×:<?/
एक monadic लिंक एक सकारात्मक पूर्णांक को स्वीकार करने, \$n\$, जो एक सकारात्मक पूर्णांक देता है, \$a(n)\$।
इसे ऑनलाइन आज़माएं! या परीक्षण-सूट देखें ।
कैसे?
R×:<?/ - Link:
R - range -> [1..n]
/ - reduce by (i.e. evaluate f(f(...f(f(f(1,2),3),4),...),n) with this f(a,b):
? - if...
< - ...condition: (a) less than (b)?
× - ...then: multiply -> a×b
: - ...else: integer divide -> a//b
अनुक्रम को \ _ तक आउटपुट करें$a(n)\$ साथ में:
R×:<?\
स्क्रैच 3.0, 29 27 ब्लॉक / 234 167 बाइट्स
एसबी सिंटैक्स के रूप में:
define f(n)
if<(n)=(1)>then
add(1)to[v v
else
f((n)-(1
set[d v]to(item(length of[v v])of[v v
if<(n)>(d)>then
add((n)*(d))to[v v
else
add([floor v] of ((n)/(d)))to[v v]
end
end
when gf clicked
delete all of [v v
ask()and wait
f(answer)
मैं कुछ इनपुट / आउटपुट विधियों का थोड़ा अनिश्चित हूं, इसलिए मैंने सोचा कि मैं सुरक्षित रहूंगा और बस इसे एक हेल्पर फ़ंक्शन के साथ पूरा कार्यक्रम बनाऊंगा।
इसका उत्तर देने से मेरे खाते को "नए" से "मानक" तक प्रचारित किया जा सकता है, इसलिए यह हमेशा मजेदार होता है।
-67 बाइट्स @ @ धन्यवाद
शेक्सपियर प्रोग्रामिंग लैंग्वेज , 221 बाइट्स
,.Ajax,.Puck,.
Act I:.Scene I:.[Enter Ajax and Puck]
Ajax:You cat.
Scene V:.
Puck:You is the sum ofYou a cat.
Ajax:Open heart.Is I nicer you?If notYou is the quotient betweenyou I.
If soYou is the product ofyou I.Let usScene V.
अनंत सूची को आउटपुट करता है। ध्यान दें कि आउटपुट मानों के बीच कोई विभाजक नहीं है, इसलिए आउटपुट को पढ़ना मुश्किल है।
एक विभाजक (एक अशक्त बाइट) को जोड़ने का मेरा सबसे अच्छा प्रयास नीचे आता है
शेक्सपियर प्रोग्रामिंग लैंग्वेज , 297 बाइट्स
,.Ajax,.Puck,.Page,.
Act I:.Scene I:.
[Enter Ajax and Puck]
Ajax:You cat.
Scene V:.[Exit Puck][Enter Page]
Ajax:Speak thy.
Page:You is the sum ofYou a cat.
Scene X:.[Exit Page][Enter Puck]
Ajax:Open heart.Is I nicer you?If notYou is the quotient betweenyou I.
If soYou is the product ofyou I.Let usScene V.
पायथन 2 , 47 43 39 बाइट्स
बचाया 4 बाइट्स के लिए धन्यवाद xnor !!!
बच गया 4 बाइट्स नील की बदौलत !!!
r=i=1
while 1:r=r/i or r*i;print r;i+=1
प्रिंट्स \ _$\{a(n)\mid n \in \mathbb{N}\}\$ अनंत अनुक्रम के रूप में।
आर , 43 39 बाइट्स
-4 बाइट्स ग्यूसेप के लिए धन्यवाद।
for(i in 1:scan())T=T%/%i^(2*(i<T)-1);T
आउटपुट \$n\$वें पद, 1-अनुक्रमित।
अनुक्रम को \ के साथ प्रारंभ करना$a(0)=1\$यह भी काम करता है, सूत्र के रूप में तब \ देता है$a(1)=1\$जैसी इच्छा। चर Tपूर्णांक के लिए बाध्य है 1, और हम बार-बार सूत्र का अधिक कॉम्पैक्ट संस्करण लागू करते हैं:
$$a(n)=\left\lfloor \frac{a(n-1)}{n^{2\mathbb{I_{n<a(n-1)}} -1}}\right\rfloor $$
(साथ \$\mathbb I\$सूचक समारोह)। इसमें मूल परिभाषा के दोनों मामले शामिल हैं।
एपीएल (डायलॉग यूनिकोड) , 18 बाइट्स (SBCS)
{⍺>⍵:⍺×⍵⋄⌊⍵÷⍺}/⌽ö⍳
एक बमुश्किल गोल्फ वाले लेकिन सुरक्षित कार्य जो अनुक्रम के nth तत्व को आउटपुट करते हैं।
एपीएल (डायलॉग यूनिकोड) , 15 14 बाइट्स (SBCS)
@ Adám को 1 बाइट धन्यवाद दिया
(⌊⊢×⊣*∘×-)/⌽ö⍳
अनुक्रम के nth तत्व को आउटपुट करता है। मुझे बस एहसास हुआ कि यह काम नहीं करेगा अगर \$n = a(n-1)\$क्योंकि यह \ N की शक्ति को बढ़ाता है$n - a(n-1)\$और उस से पलता \$a\$, हालांकि जहां तक मैं बता सकता हूं , यह फ़ंक्शन कम से कम n = 2,000,000 तक काम करता है।
(⌊⊢×⊣*∘×-)/⌽ö⍳
⍳ ⍝ Make a range to n
⌽ö ⍝ Then reverse it and
(⌊⊢×⊣*∘×-)/ ⍝ reduce it with a train:
× ⍝ Multiply
⊢ ⍝ a(n-1) with
⊣ ⍝ n
*∘× ⍝ to the power of the sign of
- ⍝ n - a(n-1)
⌊ ⍝ Floor it
हास्केल , 40 बाइट्स
a#n|n>a=a*n|1>0=a`div`n
a=scanl1(#)[1..]
- आउटपुट अनंत अनुक्रम।
Infix ऑपरेटर # अगले कार्यकाल की गणना करता है, हम इसका उपयोग सभी सकारात्मक पूर्णांक [1 ..] को मोड़ने के लिए करते हैं, लेकिन इसके बजाय scanl1 का उपयोग करते हैं जो सभी चरणों को देता है।
आर , 41 बाइट्स
for(m in 1:scan())T=`if`(m>T,T*m,T%/%m);T
खुद को इस पर जाने से पहले रॉबिन राइडर के आर जवाब को देखने के लिए मजबूर नहीं किया । खुशी से हम एक-दूसरे के लिए अलग-अलग दृष्टिकोणों के साथ आए, हालांकि दोनों (अब तक) प्रतीत होते हैं कि बाइट्स में एक ही लंबाई मेरे लिए दुख की बात है कि अब उनका 2 बाइट्स छोटा है ...
सी (जीसीसी) , 35 बाइट्स
1-आधारित शुरुआती सूचकांक लेता है और nth अनुक्रम मान लौटाता है।
f(i,j){i=i?i>(j=f(i-1))?j*i:j/i:1;}
फोर्थ (gforth) , 82 बाइट्स
: f 2dup 2dup > if * else swap / then dup . swap drop swap 1+ swap recurse ;
1 1 f
एक अनंत अनुक्रम आउटपुट करता है, जो रिक्त स्थान से अलग होता है।
पर्ल 5 -Minteger -061 , 36 , 27 बाइट्स
-9 बाइट्स @Abigail और @Sisyphus को धन्यवाद।
एक अनंत अनुक्रम का उत्पादन करता है
say$/while$/=$//++$i||$/*$i
पायथन 3.8+ , 45 39 बाइट्स
-2 शुक्रिया xnor ( while print(...)!=0:→ while[print(...)]:)
-4 धन्यवाद नील ( [a*n,a//n][a>n]→ a//n or a*n)
a=n=1
while[print(a:=a//n or a*n)]:n+=1
एक पूर्ण कार्यक्रम जो प्रिंट करता है \$a(n)\$ सभी प्राकृतिक संख्याओं के लिए।
एक पुनरावर्ती कार्य के रूप में, 49:
f=lambda v,n=1,a=1:a*(v<n)or f(v,n+1,a//n or a*n)
जावास्क्रिप्ट (Node.js) , 38 35 बाइट्स
3 बाइट्स @Neil की बदौलत सहेजे गए
रिटर्न \$n\$-तब्द, 1-अनुक्रमित।
f=(n,k=i=1n)=>i++<n?f(n,k/i||k*i):k
फैक्टर , 45 बाइट्स
[ [1,b] 1 [ 2dup < [ * ] [ /i ] if ] reduce ]
सीधी कमी। 1-आधारित इंडेक्स लेता है और एन-वें टर्म देता है।
[ ! anonymous lambda
[1,b] 1 [ ... ] reduce ! reduce {1..n} by the following, starting with 1:
2dup < ! ( an n -- an n an<n)
[ * ] [ /i ] if ! ( a_n+1 ) multiply if an < n, int-divide otherwise
]
भूसी , 11 बाइट्स
Fμ?*`÷<¹³)ḣ
F # Fold a function over
ḣ # sequence from 1..input;
μ?*`÷<¹³) # function with 2 arguments:
? # if
<¹³ # arg 2 is smaller than arg 1
* # arg 1 times arg 2
`÷ # else arg 1 integer divided by arg 2
पर्ल 5 -Minteger -p , 35 बाइट्स
map$.=$_>$.?$.*$_:$./$_,2..$_;$_=$.
nइनपुट के रूप में लेता है और nthसूची में आइटम प्रिंट करता है ।
05AB1E , 12 10 बाइट्स
अनंत क्रम को छापता है।
λN>₁N›i÷ë*
टिप्पणी की :
λ # infinite list generation
# implicitly push a(n-1) (initially 1)
N> # push n, since N is 0-indexed, this needs to be incremented
₁N› # is a(n-1) > n-1?
i÷ # if this is true, integer divide a(n-1) by n
ë* # else multiply a(n-1) and n
के (ओके) , 22 20 बाइट्स
{_x*(1%y;y)y>x}/1+!:
उपयोग करने के बजाय $[y>x;y;1%y], युगल बाइट को बचाने के (1%y;y)लिए बूलियन स्थिति का उपयोग करके सूची में अनुक्रमित किया जाता है y>x।
फोर्थ (gforth) , 51 बाइट्स
: f 1+ 1 tuck ?do i 2dup <= if * else / then loop ;
कोड स्पष्टीकरण
: f \ start word definition
1+ \ add 1 to n
1 tuck \ set up accumulator and loop parameters
?do \ loop from 1 to n (if n > 1)
i 2dup \ set up top two stack values and duplicate
<= if \ if a(n-1) <= n
* \ multiply
else \ otherwise
/ \ divide
then \ end if
loop \ end loop
; \ end word definition
जावा (JDK) , 52 बाइट्स
n->{int i,a=i=1;for(;i++<n;)a=i>a?i*a:a/i;return a;}
नोट: -1 बाइट के लिए @RedwolfPrograms और -10 (?) बाइट के लिए @ धन्यवाद।
जेली , 11 बाइट्स
1’ß×:>@?$Ị?
यह काम किस प्रकार करता है
1’ß×:>@?$Ị? - Main link f(n). Takes n on the left
? - If statement:
Ị - If: n ≤ 1
1 - Then: Yield 1
$ - Else:
’ - n-1
ß - f(n-1)
? - If statement:
>@ - If: n > f(n-1)
× - Then: n × f(n-1)
: - Else: n : f(n-1)
ब्रेकीलॉग , 10 बाइट्स
⟦₁{÷ℕ₁|×}ˡ
N = 1 के [1]बजाय सिंगलटन सूची देता है 1, लेकिन सामान्य से बाहर कुछ भी नहीं।
ˡ Reduce
⟦₁ 1 .. n
{ } by:
÷ integer division
ℕ₁ if the result is 1 or greater,
|× multiplication if not.
गैया , 9 बाइट्स
┅⟪<₌×/?⟫⊢
मूल रूप से छोटे जेली जवाब के रूप में ही है। 1-अनुक्रमित, प्रिंट a(n), हालांकि इसके बजाय पहले तत्वों को प्राप्त करने के लिए ⊢स्वैप किया जा सकता है ।⊣n
# implicit input n
┅ # push 1...n
⟪ ⟫⊢ # reduce the list by the following function:
<₌ # push an extra copy of a(i-1) and i and check if less than?
× ? # if true, then multiply
/ # else integer divide
# implicitly print top of stack
रेटिना , 58 बाइट्स
K`_ _
"$+"+L$`(^_+|_)(?<=(\1)+) (\1)+
_$`$1 $#3*$#2*
r`_\G
इसे ऑनलाइन आज़माएं! स्क्रिप्ट के इतिहास का उपयोग करने के तरीके के कारण कोई परीक्षण सूट नहीं। स्पष्टीकरण:
K`_ _
इनपुट को 1s (युग्म में) के साथ बदलें। पहला लूप इंडेक्स है जबकि दूसरा आउटपुट है।
"$+"+
लूप nसमय।
L$`(^_+|_)(?<=(\1)+) (\1)+
विभाजन और लूप इंडेक्स दोनों को लूप इंडेक्स या 1 से विभाजित करें यदि विभाजन शून्य होगा।
_$`$1 $#3*$#2*
लूप इंडेक्स में वृद्धि करें और दो उद्धरणों को एक साथ गुणा करें। यह output/index*index/indexया output/1*index/1क्रमशः में परिणाम है ।
r`_\G
अंतिम आउटपुट को दशमलव में बदलें।
CQuents , 14 बाइट्स
=1:$>Z?$Z:Z_/$
व्याख्या
=1 first term is 1
: mode sequence: given n, output nth term; otherwise, output indefinitely
each term equals:
$>Z? : if n > seq(n - 1) else
$Z n * seq(n - 1)
Z_/$ seq(n - 1) // n
रैकेट , 66 बाइट्स
(λ(n)(foldl(λ(x y)((if(< y x)* quotient)y x))1(range 1(+ 1 n))))
जे , 21 बाइट्स
[:(]<.@*[^*@-)/1+i.@-
@User एपीएल समाधान का एक जे पोर्ट - इसे अपग्रेड करने के लिए मत भूलना!
मठगोल्फ , 11 9 बाइट्स
1k{î`<¿*/
-2 बाइट्स थैंक्स टू @ovs ।
आउटपुट \$n^{th}\$ मूल्य।
स्पष्टीकरण:
1 # Push 1
k{ # Loop the input amount of times:
î # Push the 1-based loop index
` # Duplicate the top two items
<¿ # If the current value is smaller than the 1-based loop index: a(n-1)<n:
* # Multiply the value by the 1-based loop index
# Else:
/ # Integer-divide instead
# (after the loop, the entire stack joined together is output implicitly)