21

यहाँ एक आसान अनुक्रम के पहले 100 नंबर:

0,1,0,2,1,4,3,7,6,11,10,16,15,22,21,29,28,37,36,46,45,56,55,67,66,79,78,92,91,106,105,121,120,137,136,154,153,172,171,191,190,211,210,232,231,254,253,277,276,301,300,326,325,352,351,379,378,407,406,436,435,466,465,497,496,529,528,562,561,596,595,631,630,667,666,704,703,742,741,781,780,821,820,862,861,904,903,947,946,991,990,1036,1035,1082,1081,1129,1128,1177,1176,1226

यह क्रम कैसे काम करता है?

n: 0 1     2           3     4     5     6     7     8      9       10      11      12

   0,      1-1=0,      2-1=1,      4-1=3,      7-1=6,       11-1=10,        16-1=15,      
     0+1=1,      0+2=2,      1+3=4,      3+4=7,      6+5=11,        10+6=16,        15+7=22

a(0) = 0
प्रत्येक विषम n(0-अनुक्रमित) के लिए, यह a(n-1) + X(जहां X=1तक पहुँचा जाता है और हर बार 1 तक बढ़ता है)
हर भी n(0-अनुक्रमित) के लिए, यह हैa(n-1) - 1

चुनौती:

में से एक:

एक इनपुट पूर्णांक को देखते हुए n, nअनुक्रम में 'वें नंबर को आउटपुट करता है ।
एक इनपुट पूर्णांक को देखते हुए n, nअनुक्रम की पहली संख्या को आउटपुट करता है ।
इनपुट ( या खाली अप्रयुक्त इनपुट ) लेने के बिना अनुक्रम को अनिश्चित काल तक आउटपुट करें ।

चुनौती नियम:

इनपुट n0- या 1-अनुक्रमित दोनों हो सकते हैं।
यदि आप अनुक्रम का भाग (भाग) करते हैं, तो आप सूची / सरणी का उपयोग कर सकते हैं, किसी भी सीमांकक के साथ प्रिंट कर सकते हैं (स्थान, अल्पविराम, नई पंक्ति, आदि)। तुम्हारा कॉल।
कृपया बताएं कि आपने अपने उत्तर में किन तीन विकल्पों का उपयोग किया है।
आपको कम से कम पहले 10,000 नंबर (10,000 वां नंबर 12,497,501) का समर्थन करना होगा ।

सामान्य नियम:

यह कोड-गोल्फ है , इसलिए बाइट्स जीत में सबसे छोटा जवाब है।
कोड-गोल्फ भाषाओं को गैर-कोडगॉल्फिंग भाषाओं के साथ उत्तर पोस्ट करने से हतोत्साहित न करें। 'किसी भी' प्रोग्रामिंग भाषा के लिए यथासंभव संक्षिप्त उत्तर के साथ आने का प्रयास करें।
मानक नियम आपके उत्तर के लिए लागू होते हैं , इसलिए आपको उचित पैरामीटर और रिटर्न-टाइप, पूर्ण कार्यक्रमों के साथ STDIN / STDOUT, फ़ंक्शन / विधि का उपयोग करने की अनुमति दी जाती है। तुम्हारा कॉल।
डिफ़ॉल्ट ढीले निषिद्ध हैं।
यदि संभव हो, तो कृपया अपने कोड के लिए एक परीक्षण के साथ एक लिंक जोड़ें।
इसके अलावा, यदि संभव हो तो एक स्पष्टीकरण जोड़ें।

परीक्षण के मामलों:

अनुक्रम में पहले 10,001 नंबर के साथ पास्टबिन। जो भी आप चाहते हैं उसे लेने के लिए स्वतंत्र महसूस करें।

कुछ अधिक संख्या:

n (0-indexed)    Output:

68,690           589,772,340
100,000          1,249,975,000
162,207          3,288,888,857
453,271          25,681,824,931
888,888          98,765,012,346
1,000,000        124,999,750,000

— केविन क्रूज़सेन
स्रोत

10

पायथन 2 , 32 28 25 बाइट्स

lambda n:(~-n|1)**2/8+n%2

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

रिटर्न -th nसंख्या ( 0-indexed)

— TFeld
स्रोत

8

एक्सेल, 31 बाइट्स

उत्तर 0अनुक्रमित है। nसंख्या को आउटपुट करता है।

=(A1^2+IF(ISODD(A1),7,-2*A1))/8

वर्णित क्रम अंत में सिर्फ दो क्रमों के बीच का अंतर है:

ODD:   (x^2+x+2)/2
EVEN:  (x^2-x)/2

इनको एक 0अनुक्रमित अनुक्रम में बदलना

a = (x^2 - 2x)/8 if even
a = (x^2 + 7 )/8 if odd

जो देता है:

=IF(ISODD(A1),(A1^2+7)/8,(A1^2-2*A1)/8)

हम 31बाइट्स के लिए नीचे गोल्फ ।

एक ही दृष्टिकोण का उपयोग, 1अनुक्रमित 37बाइट्स देता है :

=(A1^2-IF(ISODD(A1),4*A1-3,2*A1-8))/8

— Wernisch
स्रोत

6

जेली , 6 बाइट्स

Rj-ḣ⁸S

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

0 अनुक्रमित। nवें नंबर पर लौटाता है ।

स्पष्टीकरण:

Rj-ḣ⁸S Arguments: z
R      [1..x]: z (implicit)
 j-    Join x with y: ^, -1
   ḣ⁸  Take first y of x: ^, z
     S Sum: ^

— आउटगोल्फर को एरिक करें
स्रोत

4

जावास्क्रिप्ट (Node.js) , 23 बाइट्स

x=>(7+(x-2|1)**2)/8-x%2

1 अनुक्रमित। इसे ऑनलाइन आज़माएं!

f(x) = f(x+1) + 1 if x is even
     = SUM{1..(x-3)/2} if x is odd

SUM{1..(x-3)/2}
= (1+(x-3)/2)*((x-3)/2)/2
= (x-1)*(x-3)/8
= ((x-2)^2-1)/8

— TSH
स्रोत

4

हास्केल , 40 38 37 बाइट्स

scanl(flip($))0$[1..]>>=(:[pred]).(+)

एक अनंत सूची देता है, इसे ऑनलाइन आज़माएं!

व्याख्या

scanlतीन तर्क लेता है f, initऔर xs( [ x ₀ , x ₁ ... ] ) और एक नई सूची बनाता है:

[ एक ₀ = init , एक ₁ = f (एक ₀ , एक्स ₀ ) , एक ₂ = f (एक ₁ , एक्स ₁ ) ... ]

हम सेट init = 0और फ़्लिप का उपयोग ($)आवेदन ऑपरेटर (इस प्रकार यह लागू होता है एक _मैं कार्य करने के लिए x _मैं ), अब हम केवल कार्यों की एक सूची की जरूरत है - सूची [1..]>>=(:[pred]).(+)सही कार्यों के साथ एक अनंत सूची है:

[(+1),(-1),(+2),(-1),(+3),(-1),(+4),...

दिलचस्प विकल्प, 37 बाइट्स

flipहास्केल के प्रकार के अनुमान के कारण (a -> b -> c) -> b -> a -> cहम उस प्रकार का उपयोग कर सकते हैं जिसके प्रकार को एक समान किया जाएगा , जिससे हमें समान मिलेगा ।id :: d -> d($)da -> b

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

संपादित करें

^{-नोट के (>>=)बदले उपयोग से -2 बाइट्स do।}

^{के scanlबजाय का उपयोग करके -1 बाइट zipWith।}

— ბიმო
स्रोत

4

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

scanl(+)0$(:[-1])=<<[1..]

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

एक अनंत सूची का निर्माण करता है।

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

0:0%1
a%d=a+1:a:(a+d)%(d+1)

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

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

0:do a<-scanl(+)0[1..];[a+1,a]

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

— XNOR
स्रोत

3

05AB1E , 10 बाइट्स

ÎF<NÈi¼¾>+

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

व्याख्या

Î             # initialize stack with: 0, input
 F            # for N in [0 ... input-1] do:
  <           # decrement the current number
   NÈi        # if N is even
      ¼       # increment a counter
       ¾>     # push counter+1
         +    # add to current number

एक और 10-बटर: ÎFNÈN;Ì*<O

— Emigna
स्रोत

ÎGDN+D<अनुक्रम उत्पन्न करता है, लेकिन nth तत्व को हथियाने लगता है ... 3 बाइट्स में कठिन।

— मैजिक ऑक्टोपस मूत्र

3

ऑक्टेव , 32 बाइट्स

@(x)fix((x-~(m=mod(x,2)))^2/8)+m

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

एन-वें संख्या, 0-अनुक्रमित आउटपुट करता है। कई अन्य उत्तरों के समान सूत्र का उपयोग करता है।

— स्टीवी ग्रिफिन
स्रोत

3

एपीएल (डायलॉग यूनिकोड) , 16 12 बाइट्स^{एसबीसीएस}

बेनामी tacit उपसर्ग समारोह। 0 अनुक्रमित।

+/⊢↑∘∊¯1,¨⍨⍳

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

+/ की राशि

⊢↑ सबसे पहला n तत्व

∘∊ का ϵ nlisted (चपटा)

¯1,¨⍨ नकारात्मक-एक संलग्न करने के लिए प्रत्येक

⍳ पहले n ɩ ndices (0 से n-1)

— एडम
स्रोत

आह, यह मेरा समाधान था ... लगता है कि यह काफी समान था।

— बजे द एग्रीगेटर

3

जेली , 6 बाइट्स

HḶS‘_Ḃ

एक मौद्रिक लिंक जो स्वीकार करता है (1-अनुक्रमित) nजो लौटता हैa(n) ।

इसे ऑनलाइन आज़माएं! या देखें परीक्षण-सूट देखें

कैसे?

HḶS‘_Ḃ - link: n
H      - halve         -> n/2.0
 Ḷ     - lowered range -> [0,1,2,...,floor(n/2.0)-1]
  S    - sum           -> TriangleNumber(floor(n/2.0)-1)
   ‘   - increment     -> TriangleNumber(floor(n/2.0)-1)+1
     Ḃ - bit = 1 if n is odd, 0 if it's even
    _  - subtract      -> TriangleNumber(floor(n/2.0)-1)+isEven(n)

— जोनाथन एलन
स्रोत

हम्म, दिलचस्प दृष्टिकोण वहीं।

— एर्ग आउटफोलर

3

PHP , 73 64 55 51 47 बाइट्स

पहली विधि

पहला कोड गोल्फ उत्तर!
मुझे यकीन है कि इसे छोटा करने के लिए PHP ट्रिक्स हैं और मैथ्स को बेहतर बनाया जा सकता है।

पहले तर्क के रूप में n लेता है और अनुक्रम में nth संख्या को आउटपुट करता है।

$y=$argv[1]/2;for(;$i<$y+1;)$x+=$i++;echo$x-($y|0);

"$ X = 0;" हटाकर माइनस 9 बाइट्स और "$ i = 0"।

माइनस 9 बाइट्स का धन्यवाद @ केविन क्रूज़सेन ने लूप के लिए सुधार किया और अंतिम टैग का नुकसान।

बिटस या "|" का उपयोग करके माइनस 1 बाइट इसके बजाय "(int)"

माइनस 3 बाइट्स @ धन्यवाद का धन्यवाद क्योंकि आप कमांड लाइन से "php -r 'यहाँ' के साथ रन करके टैग हटा सकते हैं"

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

दूसरी विधि

एक पूरी नई विधि के साथ मेरे पिछले उत्तर का मिलान किया!

for(;$i<$argv[1];$i++)$x+=($y^=1)?$i/2+1:-1;echo$x;

लूप में रकम के बीच स्विच करने के लिए XOR और टेनरी ऑपरेटर का उपयोग करना।

संपादित करें: यह n = 0 के लिए काम नहीं करता है और मुझे पता नहीं क्यों। $ i को इसलिए असाइन नहीं किया गया है इसलिए इसे 0 होना चाहिए, इसलिए लूप के ($i<$argv[1])रूप में विफल होना चाहिए (0<0==false), इसलिए एक गैर-असाइन किए गए $ x को 0 और 1 के रूप में आउटपुट होना चाहिए।

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

तीसरी विधि

PHP के लिए बनाया गया excel सूत्र @Wernisch को बदलने से 47 बाइट का समाधान मिलता है

$z=$argv[1];echo(pow($z,2)+(($z&1)?7:-2*$z))/8;

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

— सैम डीन
स्रोत

1

नमस्ते, PPCG में आपका स्वागत है! यदि आपने अभी तक नहीं किया है, तो PHP में गोल्फिंग के लिए युक्तियाँ और <सभी भाषाओं में गोल्फिंग के लिए युक्तियाँ> के माध्यम से पढ़ने के लिए दिलचस्प हो सकता है। गोल्फ के लिए कुछ चीजें: आप ट्रेलिंग को हटा सकते हैं ?>। हटाने $x=0और $i=0वास्तव में अनुमति दी जाती है (यदि नहीं, $x=$i=0तो छोटा भी होता)। इसके अलावा, लूप को छोटा किया जा सकता है for(;$i<$y+1;)$x+=$i++;। जो कुल में -15 बाइट्स है। यहां रहने का आनंद! :)

— केविन क्रूज़सेन

@KevinCruijssen बहुत बहुत धन्यवाद!

— सैम डीन

आपका स्वागत है। Btw, आपका TIO वर्तमान में 58 के बजाय अभी भी 60 बाइट्स है। और सुनिश्चित नहीं है कि आपने 57 क्यों कहा है। इसे ऑनलाइन आज़माएं।

— केविन क्रूज़सेन

@KevinCruijssen मैं गलत TIO पोस्ट करता रहा! TIO अब 58 कहता है, लेकिन मैंने 55 पोस्ट किया है क्योंकि आप "php" को शुरुआती टैग से हटा सकते हैं, सिर्फ TIO में नहीं

— सैम डीन

@Ernisch आपके सूत्र के लिए धन्यवाद!

— सैम डीन

3

आर , 35 बाइट्स

diffinv(rbind(n<-1:scan(),-1)[n-1])

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

मैंने सोचा कि यह @ जेसी के जवाब का एक दिलचस्प विकल्प था क्योंकि यह मैट्रिसेस के लिए बिल्ट-इन सपोर्ट के बिना भाषाओं को बहुत अच्छी तरह से पोर्ट नहीं करता है, और सिर्फ गोल्फ के रूप में होता है।

1-अनुक्रमित, nअनुक्रम के पहले तत्वों को लौटाता है ।

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

rbind(n<-1:scan(),-1) निम्नलिखित मैट्रिक्स का निर्माण करता है:

     [,1] [,2] [,3] [,4]
[1,]    1    2    3    4
[2,]   -1   -1   -1   -1

क्योंकि R कॉलम-प्रमुख क्रम में मैट्रिसेस रखता है, अगर हम इसे a में बदलना vectorचाहते हैं, तो हम एक वेक्टर प्राप्त करेंगे

1 -1 2 -1 3 -1 4 -1

अगर हम एक संचयी राशि लेते हैं, तो हमें मिलेगा

1 0 2 1 4 3 7 6

यह अनुक्रम है, सिर्फ अग्रणी के बिना 0। diffinvसौभाग्य से अग्रणी शून्य को जोड़ता है, इसलिए हम n-1मैट्रिक्स के पहले मूल्यों और diffinvउन्हें, nअनुक्रम के पहले मूल्यों को प्राप्त करते हैं ।

— ग्यूसेप
स्रोत

2

मैं आपके 'डिफिन्व' उत्तरों का बहुत बड़ा प्रशंसक हूं।

— JayCe

मेरा परिचय कराने के लिएdiffinv

— ग्यूसेप

3

आर , 35 34 बाइट्स

(u=(n=scan())-n%%2-1)-n+(15+u^2)/8

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

पहला आउटपुट विकल्प। कई अन्य उत्तरों के रूप में सूत्र। (मैं सूत्र प्रदान करने वाले पहले उत्तर को इंगित करना चाहता हूं, मैं यह नहीं समझ सकता कि यह कौन है)।

नीचे दूसरा और तीसरा आउटपुट विकल्प:

आर , 43 बाइट्स

function(m,n=1:m,u=n%%2+1)((n-u)^2-1)/8+2-u

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

आर , 51 बाइट्स

while(T){cat(((T-(u=T%%2+1))^2-1)/8+2-u," ");T=T+1}

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

— Jayce
स्रोत

3

मतलाब / ऑक्टेव, 31 26 बाइट्स

5 बाइट्स ने लुक्स मेंडो को बचाया!

@(n)sum(1:n/2+.5)-fix(n/2)

— लिएंडर मोइस्िंगर
स्रोत

1

आप शायद fixइसके बजाय का उपयोग कर सकते हैं floorऔर n/2+.5इसके बजायceil(n/2)

— लुइस मेंडू

@LuisMendo Ty! के बारे में पता नहीं fix()था और 1:n/2+.5काम करने की उम्मीद नहीं थी - इतनी सारी चीजें जो गलत हो सकती थीं, लेकिन वे वास्तव में नहीं करते हैं :)

— लिएंडर मोसिंजर

3

जावा (JDK 10) , 20 बाइट्स

x->x%2+(x=~-x|1)*x/8

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

TFeld के पायथन 2 एवर का पोर्ट , तो उन्हें एक उत्थान दें! ;)

— ओलिवियर ग्रेजायर
स्रोत

3

QBasic 1.1 , 49 बाइट्स

INPUT N
R=1
FOR I=1TO N\2-1
R=R+I
NEXT
?R-N MOD 2

1 अनुक्रमित।

— आउटगोल्फर को एरिक करें
स्रोत

3

QBasic 1.1 , 30 बाइट्स

INPUT N
?(N-1OR 1)^2\8+N MOD 2

TFeld के एल्गोरिथ्म का उपयोग करता है। 0 अनुक्रमित।

— आउटगोल्फर को एरिक करें
स्रोत

3

QBasic, 31 बाइट्स

एरिक के समाधान की तुलना में जस्ट -इम्प्लीमेंट-टू-स्पेक समाधान थोड़ा लंबा आता है ।

DO
?n
i=i+1
n=n+i
?n
n=n-1
LOOP

यह अनिश्चित काल के लिए आउटपुट करता है। इसे चलाने के प्रयोजनों के लिए, मैं अंतिम पंक्ति को कुछ इस तरह बदलने की सलाह देता हूं LOOP WHILE INPUT$(1) <> "q", जो कि हर दूसरे अनुक्रम में प्रवेश के बाद एक कुंजीपट के लिए प्रतीक्षा करेगा और कुंजी दबाए जाने पर बाहर निकल जाएगा q।

— DLosc
स्रोत

2

सी # (.NET कोर) , 56 बाइट्स

n=>{int a=0,i=0;for(;++i<n;)a+=i%2<1?-1:i/2+1;return a;}

-2 बाइट्स केविन क्रूजसेन को धन्यवाद

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

1 अनुक्रमित। रिटर्नa(n)

Ungolf'd:

int f(int n)
{
    // a needs to be outside the for loop's scope,
    // and it's golfier to also define i here
    int a = 0, i = 1;
    // basic for loop, no initializer because we already defined i
    for (; ++i < n;)
    {
        if (i%2 < 1) {
            // if i is even, subtract 1
            a -= 1;
        }
        else
        {
            // if i is odd, add (i / 2) + 1
            // this lets us handle X without defining another int
            a += i / 2 + 1;
        }
    }
    // a is the number at index n
    return a;
}

— Skidsdev
स्रोत

1

i=1;for(;i<n;i++)हो सकता है i=0;for(;++i<n;)और i%2==0हो सकता है i%2<1।

— केविन क्रूज़सेन

@ केविनक्रूजसेन तो मैं कर सकता हूं, धन्यवाद! मुझे दूसरा देखना चाहिए था, लेकिन मैंने पहले वाले को काम नहीं दिया क्योंकि मैंने सोचा था कि लूप के लिए पहले लूप के बाद केवल सशर्त की जांच की जाएगी। टीआईएल

— स्काइड्सडेव

नहींं, यह पहले पुनरावृत्ति से पहले ही जाँच करता है। ए do-whileपहले पुनरावृत्ति को पूरा करने के बाद जांच करेगा। :)

— केविन क्रूज़सेन

बहुत ही दुर्लभ मामलों में आप ifएक for-लूप के साथ भी विलय कर सकते हैं । उदाहरण के लिए: if(t>0)for(i=0;i<l;i++)से for(i=0;t>0&i<l;i++)। मैं लगभग कभी भी अपने उत्तरों में इसका उपयोग नहीं कर पाया।

— केविन क्रूज़सेन

यह बहुत बढ़िया है, मुझे निश्चित रूप से यह ध्यान रखना होगा कि अगली बार मैं सी # गोल्फिंग करूं, जो कि इन दिनों काफी दुर्लभ है: पी मेरे अधिकांश सी # काम निश्चित रूप से अधकचरे हैं

— स्काइड्सडेव

2

भूसी , 11 9 8 बाइट्स

ΘṁṠe→Θ∫N

H.PWiz को एक बाइट धन्यवाद दिया।
एक अनंत सूची के रूप में आउटपुट।
इसे ऑनलाइन आज़माएं!

व्याख्या

ΘṁṠe→Θ∫N
      ∫N   Cumulative sum of natural numbers (triangular numbers).
     Θ     Prepend 0.
 ṁṠe→      Concatenate [n + 1, n] for each.
Θ          Prepend 0.

2

Dodos , 69 बाइट्स

	. w
w
	. h
	+ r . ' dab h '
h
	h ' '
	. dab
r
	
	r dip
.
	dot
'
	dip

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

किसी तरह यह सबसे लंबा जवाब है।

स्पष्टीकरण।

┌────┬─────────────────────────────────────────────────┐
│Name│Function                                         │
├────┼─────────────────────────────────────────────────┤
│.   │Alias for "dot", computes the sum.               │
├────┼─────────────────────────────────────────────────┤
│'   │Alias for "dip".                                 │
├────┼─────────────────────────────────────────────────┤
│r   │Range from 0 to n, reversed.                     │
├────┼─────────────────────────────────────────────────┤
│h   │Halve - return (n mod 2) followed by (n/2) zeros.│
└────┴─────────────────────────────────────────────────┘

— user202729
स्रोत

1

चारकोल , 15 बाइट्स

Ｉ∨ΣＥＮ⎇﹪ι²±¹⊕⊘ι⁰

इसे ऑनलाइन आज़माएं! 0 अनुक्रमित। लिंक कोड के वर्बोज़ संस्करण के लिए है। सूत्र शायद कम होगा, लेकिन इसमें क्या मजा है? स्पष्टीकरण:

    Ｎ           Input as a number
   Ｅ            Map over implicit range
     ⎇          Ternary
      ﹪ι²       Current value modulo 2
         ±¹     If true (odd) then -1
           ⊕⊘ι  Otherwise calculate X as i/2+1
  Σ             Take the sum
 ∨            ⁰ If the sum is empty then use zero
Ｉ               Cast to string and implicitly print

— नील
स्रोत

1

जावास्क्रिप्ट, 49 48 45 बाइट्स

x=>eval('for(i=0,r=1;++i<x+2;)r+=i%2?-1:i/2')

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

@Tsh उत्तर के रूप में सुंदर नहीं है, लेकिन मेरा बड़ी संख्या के लिए काम करता है।

और अब धन्यवाद @tsh, evalसमाधान के लिए!

— यादृच्छिक आदमी
स्रोत

<=x+1 हो सकता है <x+2

— केविन क्रूज़सेन

x=>eval('for(i=0,r=1;++i<x+2;)r+=i%2?-1:i/2')कम होना चाहिए।

— tsh

क्या evalअंतिम संशोधित मूल्य लौटाता है? मुझे अभी भी पूरी तरह से समझ नहीं आ रहा है कि यह क्या कर सकता है।

— यादृच्छिक आदमी

यह कथन का मान लौटाता है (जिसे बाद के संस्करण में कथन में शामिल किया जा सकता है do)।

— tsh

1

बेफुज 93, 26 बाइट्स

<v0p030
 >:.130g+:30p+:.1-

अनिश्चित काल तक
इसे ऑनलाइन चलाएं, हालांकि आउटपुट थोड़ा विस्की हो जाता है और x = 256 के बाद वापस चला जाता है, संभवतः TIO U + 256 से ऊपर के वर्णों को संभाल नहीं सकता है। Https://www.bedroomlan.org/tools/befunge-playground (केवल दुर्भाग्यवश, Chrome से ठीक काम करता है । फ़ायरफ़ॉक्स के साथ, एंडलाइन किसी कारण से रनटाइम पर हटा दी जाती हैं ...)

— karhell
स्रोत

1

जे , 17 बाइट्स

1#.[{._1,@,.~1+i.

Adám के APL समाधान का एक बंदरगाह।

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

— गैलेन इवानोव
स्रोत

1

पायथ , 8 बाइट्स

s<s,R_1S

nअनुक्रम में वें नंबर देता है , 0-अनुक्रमित। इसे ऑनलाइन आज़माएं

उदाहरण के लिए, स्पष्टीकरण n=5:

s<s,R_1SQQ   Final 2 Q's are implicit, Q=eval(input())

       SQ    1-indexed range        [1,2,3,4,5]
   ,R_1      Map each to [n,-1]     [[1,-1],[2,-1],[3,-1],[4,-1],[5,-1]]
  s          Sum (Flatten)          [1,-1,2,-1,3,-1,4,-1,5,-1]
 <       Q   Take 1st Q             [1,-1,2,-1,3]
s            Sum, implicit output   4

— सोक
स्रोत

1

पर्ल 6 , 38 26 बाइट्स

{(0,{$_+(($+^=1)??++$ !!-1)}...*)[$_]}

कोशिश करो

{(+^-$_+|1)**2 div 8+$_%2}

रिवर्स इंजीनियरिंग TFeld के पायथन जवाब पर आधारित है ।
कोशिश करो

विस्तारित

38 बाइट (अनुक्रम जनरेटर):

{  # bare block lambda with implicit parameter $_

  (
    # generate a new sequence everytime this function is called

    0,    # seed the sequence

    {     # bare block that is used to generate the rest of the values

      $_  # parameter to this inner block (previous value)

      +

      (
          # a statement that switches between (0,1) each time it is run
          ( $ +^= 1 )

        ??     # when it is 1 (truish)
          # a statement that increments each time it is run
          ++$ # &prefix:« ++ »( state $foo )

        !!     # or else subtract 1
          -1
      )
    }

    ...  # keep generating until:

    *    # never stop

  )[ $_ ] # index into the sequence
}

ध्यान दें कि यह वह लाभ है जिसे आप पास कर सकते हैं * पूरे अनुक्रम को प्राप्त करने के लिए , या एक रेंज में अधिक कुशलता से कई मान उत्पन्न करने के लिए हैं।

26 बाइट (प्रत्यक्ष गणना):

{  # bare block lambda with implicit parameter $_

  (

    +^     # numeric binary negate
      -$_  # negative of the input
      +|   # numeric binary or
      1

  ) ** 2   # to the power of 2

  div 8     # integer divide it by 8

  + $_ % 2  # add one if it is odd
}

— ब्रैड गिल्बर्ट b2gills
स्रोत

1

05AB1E , 8 बाइट्स

;L¨O>¹É-

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

जोनाथन एलन के जेली दृष्टिकोण पर आधारित (जो संभवतः ओपी के अनुक्रम की एक और परिभाषा के साथ प्रश्न को संपादित करने पर आधारित था), इसलिए 1-अनुक्रमित।

— आउटगोल्फर को एरिक करें
स्रोत

+1। मेरे पास 05AB1E में एक समान दृष्टिकोण तैयार किया गया था जिसे मैंने कुछ दिनों में पोस्ट करने की योजना बनाई थी अगर कोई और किसी को पोस्ट नहीं करता। यह थोड़ा अलग है (मैं सूची बनाने से पहले हल को कम करता हूं, पूंछ को हटाने के बजाय; और मैं Iइसके बजाय का उपयोग करता हूं ¹), लेकिन सामान्य दृष्टिकोण और बाइट-काउंट बिल्कुल समान है:;<LO>IÉ-

— केविन क्रूज़सेन

@ केविनक्रूजसेन ने कल पोस्ट किया होता अगर मेरे पास अधिक गहराई से सोचने की क्षमता होती, लेकिन, ठीक है, यह फाइनल अवधि है, इस बारे में बहुत गहराई से सोचना मना है। : P

— आउटगोल्फर

आह, मुझे खुशी है कि मेरे पास अब फाइनल नहीं है। मैं काम के साथ-साथ बहुत व्यस्त हूं, और कोड-गोल्फ को कभी-कभी अधिक बार स्थगित करना पड़ता है जितना मैं चाहूंगा। ; आपकी परीक्षा के साथ शुभकामनाएँ!

— केविन क्रूज़सेन

1

उत्तल , 10 9 बाइट्स

_½,ª)\2%-

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

जोनाथन एलन के जेली दृष्टिकोण पर आधारित (जो संभवतः ओपी के अनुक्रम की एक और परिभाषा के साथ प्रश्न को संपादित करने पर आधारित था)। 1 अनुक्रमित।

स्पष्टीकरण:

_½,ª)\2%- Stack: [A]
_         Duplicate. Stack: [A A]
 ½        Halve. Stack: [A [A]½]
  ,       Range, [0..⌊N⌋). Stack: [A [[A]½],]
   ª      Sum. Stack: [A [[A]½],]ª]
    )     Increment. Stack: [A [[[A]½],]ª])]
     \    Swap. Stack: [[[[A]½],]ª]) A]
      2   2. Stack: [[[[A]½],]ª]) A 2]
       %  Modulo. Stack: [[[[A]½],]ª]) [A 2]%]
        - Minus. Stack: [[[[[A]½],]ª]) [A 2]%]-]

— आउटगोल्फर को एरिक करें
स्रोत

1

जेली , 6 बाइट्स

पहले nनंबर पर लौटें ।

Rj-ÄŻḣ

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

— user202729
स्रोत

EriktheOutgolfer के उत्तर के समान।

— user202729

एक्स स्टेप्स फॉरवर्ड, 1 स्टेप बैक

चुनौती:

चुनौती नियम:

सामान्य नियम:

परीक्षण के मामलों:

पायथन 2 , 32 28 25 बाइट्स

एक्सेल, 31 बाइट्स

जेली , 6 बाइट्स

जावास्क्रिप्ट (Node.js) , 23 बाइट्स

हास्केल , 40 38 37 बाइट्स

व्याख्या

दिलचस्प विकल्प, 37 बाइट्स

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

05AB1E , 10 बाइट्स

ऑक्टेव , 32 बाइट्स

एपीएल (डायलॉग यूनिकोड) , 16 12 बाइट्स एसबीसीएस

जेली , 6 बाइट्स

कैसे?

PHP , 73 64 55 51 47 बाइट्स

पहली विधि

दूसरी विधि

तीसरी विधि

आर , 35 बाइट्स

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

आर , 35 34 बाइट्स

आर , 43 बाइट्स

आर , 51 बाइट्स

मतलाब / ऑक्टेव, 31 26 बाइट्स

जावा (JDK 10) , 20 बाइट्स

QBasic 1.1 , 49 बाइट्स

QBasic 1.1 , 30 बाइट्स

QBasic, 31 बाइट्स

सी # (.NET कोर) , 56 बाइट्स

भूसी , 11 9 8 बाइट्स

व्याख्या

Dodos , 69 बाइट्स

चारकोल , 15 बाइट्स

जावास्क्रिप्ट, 49 48 45 बाइट्स

बेफुज 93, 26 बाइट्स

जे , 17 बाइट्स

पायथ , 8 बाइट्स

पर्ल 6 , 38 26 बाइट्स

विस्तारित

38 बाइट (अनुक्रम जनरेटर):

26 बाइट (प्रत्यक्ष गणना):

05AB1E , 8 बाइट्स

उत्तल , 10 9 बाइट्स

जेली , 6 बाइट्स

एपीएल (डायलॉग यूनिकोड) , 16 12 बाइट्स^{एसबीसीएस}