परिचय

संकेत एक नंबर के लिए या तो एक है +, या एक -हर गैर शून्य पूर्णांक के लिए। शून्य स्वयं साइनलेस है ( +0जैसा है -0)। निम्नलिखित अनुक्रम में, हम सकारात्मक संकेत , शून्य और नकारात्मक संकेत के बीच वैकल्पिक रूप से जा रहे हैं । अनुक्रम शुरू होता है 1, इसलिए हम 1एक सकारात्मक संकेत के साथ लिखते हैं , शून्य के साथ (यह एक अजीब है, लेकिन हम सिर्फ संख्या को 0 से गुणा करते हैं) और नकारात्मक संकेत:

1, 0, -1

अगला नंबर है 2, और हम फिर से वही काम करते हैं:

2, 0, -2

अनुक्रम अंततः है:

1, 0, -1, 2, 0, -2, 3, 0, -3, 4, 0, -4, 5, 0, -5, 6, 0, -6, 7, 0, -7, ...

या अधिक पठनीय रूप:

a(0) = 1
a(1) = 0
a(2) = -1
a(3) = 2
a(4) = 0
a(5) = -2
a(6) = 3
a(7) = 0
a(8) = -3
a(9) = 4
...

काम

एक गैर-नकारात्मक पूर्णांक n को देखते हुए , उपरोक्त अनुक्रम के n ^वें शब्द को आउटपुट करें । यदि आप शून्य-अनुक्रमित या एक-अनुक्रमित संस्करण का उपयोग करते हैं, तो आप चुन सकते हैं ।

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

शून्य अनुक्रमित:

a(0) = 1
a(11) = -4
a(76) = 0
a(134) = -45
a(296) = -99

या यदि आप एक-अनुक्रमित पसंद करते हैं:

a(1) = 1
a(12) = -4
a(77) = 0
a(135) = -45
a(297) = -99

यह कोड-गोल्फ है , इसलिए सबसे कम संख्या में बाइट्स जीतता है!

— अदनान
स्रोत

यह ठीक है अगर आप के साथ शुरू[0, 0, 0, -1, 0, 1...

— ब्लू

@ मुड्डीफ़िश नो सॉरी, इसके साथ शुरुआत करनी होगी 1।

— अदनान

6

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

+6d3’PN

शून्य अनुक्रमित। यहां टेस्ट केस।

स्पष्टीकरण:

+6      Add 6:     x+6
d3      Divmod:    [(x+6)/3, (x+6)%3]
’       Decrement: [(x+6)/3-1, (x+6)%3-1]
P       Product    ((x+6)/3-1) * ((x+6)%3-1)

— लिन
स्रोत

6

जावास्क्रिप्ट ईएस 6, 18 बाइट्स

n=>-~(n/3)*(1-n%3)

@ LeakyNun के उत्तर के समान ही निकला, लेकिन मैंने अपना पोस्ट करने के बाद तक उसे नहीं देखा।

व्याख्या और असंगति

-~के लिए आशुलिपि है Math.ceil, या राउंडिंग:

n =>               // input in var `n`
    Math.ceil(n/3) // Get every 3rd number 1,1,1,2,2,2, etc.
    *
    (1-n%3)        // 1, 0, -1, 1, 0, -1, ...

कोड स्निपेट दिखाएं

function f(n){n=i.value;o.value=-~(n/3)*(1-n%3);}

Input: <input id=i oninput="f()"/><br /><br />
Output: <input id=o readable/>

स्निपेट का विस्तार करें

— Downgoat
स्रोत

1

(मैं इस बात पर ध्यान देता हूं कि उन्होंने अपना समाधान पोस्ट करने से पहले मेरा समाधान नहीं देखा था)

— लीकी नून

Math.ceilऔर -~अलग हैं; Math.ceil(1) == 1जबकि-~1 == 2

— साइओस

1

1 बाइट छोटी:n=>~(n/3)*~-(n%3)

— साइओस

6

MarioLANG, 93 81 बाइट्स

एक अनुक्रमित

यह ऑनलाइन की कोशिश करो

;(-))+(-
"============<
>:(![<:![<:)![
 !=#="!#="!=#=
!  < !-< !- <
#==" #=" #=="

स्पष्टीकरण:

हम थोप लेने से शुरू करते हैं

जो हमें दे

          v
... 0 0 input 0 0 ...

हम फिर बाईं बाइट को घटाते हैं और दाएं बाइट को बढ़ाते हैं

;(-))+(
=======

हम साथ समाप्त करते हैं

           v
... 0 -1 input +1 0 ...

हम फिर लूप सेट करते हैं

;(-))+(-
"============<
>  ![< ![<  ![
   #=" #="  #=
!  < !-< !- <
#==" #=" #=="

लूप तब तक चलेगा जब तक मेमोरी दिखती नहीं है

         v 
... 0 -X 0 +X 0 ...

हमें केवल परिणाम का उत्पादन करने की आवश्यकता है

;(-))+(-
"============<
>:(![<:![<:)![
 !=#="!#="!=#=
!  < !-< !- <
#==" #=" #=="

— ईथर मेंढक
स्रोत

2

अच्छा! आप मारियोलैंग को पसंद करते हैं।

— R

@EasterlyIrk यह अहसास मारियोलैंग से एथरफ्रॉग तक आपसी नहीं लगता, हालांकि: ;(और >:(। हालांकि, दो बार [<:थोड़ा खुश माना जा सकता था। ; पी

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

4

पायथन 2, 24 बाइट्स

lambda n:(n/3+1)*(1-n%3)

पूरा कार्यक्रम:

a=lambda n:(n/3+1)*(1-n%3)

print(a(0))   #   1
print(a(11))  #  -4
print(a(76))  #   0
print(a(134)) # -45
print(a(296)) # -99

— लीक नन
स्रोत

4

MATL, 15 12 बाइट्स

3/XkG3X\2-*_

यह एक आधारित अनुक्रमण का उपयोग करता है।

इसे ऑनलाइन आज़माएं! या परीक्षण मामलों की पुष्टि करें

स्पष्टीकरण:

    G          #Input
     3X\       #Modulus, except multiples of 3 give 3 instead of 0
        2-     #Subtract 2, giving -1, 0 or 1
3/Xk           #Ceiling of input divided by 3.
          *    #Multiply 
           _   #Negate

— DJMcMayhem
स्रोत

ज्यादातर मुद्दों पर ध्यान रखने के लिए कुछ Q3/Xk-1:1G_)*बेहतर काम कर सकते हैं। यह शायद 1-आधारित अनुक्रमण के बजाय आगे कभी भी संशोधित किया जा सकता है।

— स्वेवर

4

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

f x=div(x+3)3*(1-mod(x+3)3)

थोड़ा और अधिक दिलचस्प 28 बाइट समाधान:

(((\i->[i,0,-i])=<<[1..])!!)

(दोनों हैं 0-सुविधाएँ)

— माइकल क्लेन
स्रोत

3

MATL , 8 बाइट्स

:t~y_vG)

परिणाम 1-आधारित है।

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

व्याख्या

यह 2D सरणी बनाता है

 1  2  3  4  5 ...
 0  0  0  0  0 ...
-1 -2 -3 -4 -5 ...

और फिर वांछित शब्द निकालने के लिए रैखिक अनुक्रमण का उपयोग करता है। रैखिक अनुक्रमण साधन सूचकांक नीचे है, तो भर में (ताकि ऊपर सरणी में रेखीय क्रम में पहले प्रविष्टियां हैं 1, 0, -1, 2, 0, ...)

:     % Vector [1 2 ... N], where N is implicit input
t~    % Duplicate and logical negate: vector of zeros
y_    % Duplicate array below the top and negate: vector [-1 -2 ... -N]
v     % Concatenate all stack contents vertically
G)    % Index with input. Implicit display

— लुइस मेंडो
स्रोत

3

पर्ल 5, 22 बाइट्स

21 प्लस एक के लिए -p:

$_=(-$_,$_+2)[$_%3]/3

1-आधारित अनुक्रमण का उपयोग करता है।

स्पष्टीकरण:

-p$_इनपुट के बराबर चर सेट करता है । फिर कोड इसे $_%30-आधारित सूची (-$_,$_+2)(जहां %मॉडुलो है) के 3 से विभाजित होकर वें तत्व के बराबर सेट करता है । ध्यान दें कि यदि $_%3दो है, तो ऐसा कोई तत्व नहीं है, और बाद के विभाजन को 3 को अपरिभाषित 0. 0. -pफिर प्रिंट करता है $_।

— msh210
स्रोत

3

बैश, 28 25 बाइट्स

echo $[(1+$1/3)*(1-$1%3)]

— rexkogitans
स्रोत

@DigitalTrauma, tkx, यह नहीं जानते ...

— rexkogitans

2

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

{({|(++$,0,--$)}...*)[$_]}
{($_ div 3+1)*(1-$_%3)}

(छोटे को अन्य उत्तरों से अनुवादित किया गया था)

स्पष्टीकरण (पहले एक का):

{ # bare block with implicit parameter ｢$_｣
  (

    # start of sequence generator

    { # bare block
      |(  # slip ( so that it flattens into the outer sequence )
        ++$, # incrementing anon state var =>  1, 2, 3, 4, 5, 6
        0,   # 0                           =>  0, 0, 0, 0, 0, 0
        --$  # decrementing anon state var => -1,-2,-3,-4,-5,-6
      )
    }
    ...  # repeat
    *    # indefinitely

    # end of sequence generator

  )[ $_ ] # get the nth one (zero based)
}

परीक्षा:

#! /usr/bin/env perl6
use v6.c;
use Test;

# store it lexically
my &alt-seq-sign = {({|(++$,0,--$)}...*)[$_]}
my &short-one = {($_ div 3+1)*(1-$_%3)}

my @tests = (
    0 =>   1,
   11 =>  -4,
   76 =>   0,
  134 => -45,
  296 => -99,
  15..^30  => (6,0,-6,7,0,-7,8,0,-8,9,0,-9,10,0,-10)
);

plan @tests * 2 - 1;

for @tests {
  is alt-seq-sign( .key ), .value, 'alt-seq-sign  ' ~ .gist;

  next if .key ~~ Range; # doesn't support Range as an input
  is short-one(    .key ), .value, 'short-one     ' ~ .gist;
}

1..11
ok 1 - alt-seq-sign  0 => 1
ok 2 - short-one     0 => 1
ok 3 - alt-seq-sign  11 => -4
ok 4 - short-one     11 => -4
ok 5 - alt-seq-sign  76 => 0
ok 6 - short-one     76 => 0
ok 7 - alt-seq-sign  134 => -45
ok 8 - short-one     134 => -45
ok 9 - alt-seq-sign  296 => -99
ok 10 - short-one     296 => -99
ok 11 - alt-seq-sign  15..^30 => (6 0 -6 7 0 -7 8 0 -8 9 0 -9 10 0 -10)

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

2

जे, 19 15 बाइट्स

>.@(%&3)*1-3|<:

शायद यह आगे गोल्फ की जरूरत है ...

1 अनुक्रमित।

Ungolfed:

>> choose_sign      =: 1-3|<:      NB. 1-((n-1)%3)
>> choose_magnitude =: >.@(%&3)    NB. ceil(n/3)
>> f                =: choose_sign * choose_magnitude
>> f 1 12 77
<< 1 _4 0

जहाँ >>इनपुट (STDIN) और <<आउटपुट का मतलब (STDOUT) है।

— लीक नन
स्रोत

2

Pyke, 8 7 बाइट्स (पुराना संस्करण)

3.DeRt*

यहाँ यह कोशिश करो! - ध्यान दें कि लिंक संभवतः लंबे समय तक नहीं रहेगा

3.D      - a,b = divmod(input, 3)
   e     - a = ~a -(a+1)
     t   - b -= 1
      *  - a = a*b
         - implicit output a

नवीनतम संस्करण

3.DhRt*_

यहाँ यह कोशिश करो!

3.D      - a,b = divmod(input, 3)
   h     - a+=1
     t   - b-=1
      *  - a = a*b
       _ - a = -a
         - implicit output a

— नीला
स्रोत

आप (पुराना संस्करण) के लिए एक लिंक प्रदान कर सकते हैं

— Downgoat

नवीनतम प्रतिबद्ध जहां पुराना कोड यहां काम करता है (यह आज पहले है)

— ब्लू

2

जे, 27 बाइट्स

जबकि गोल्फ के लिए, मुझे यह पसंद नहीं है, क्योंकि यह एक एजेंडा का उपयोग करता है।

>.@(>:%3:)*1:`0:`_1:@.(3|])

यहां पेड़ का अपघटन होता है:

         ┌─ >.      
  ┌─ @ ──┤    ┌─ >: 
  │      └────┼─ %  
  │           └─ 3: 
  ├─ *              
──┤           ┌─ 1: 
  │      ┌────┼─ 0: 
  │      │    └─ _1:
  └─ @. ─┤          
         │    ┌─ 3  
         └────┼─ |  
              └─ ]

यह केनी के जे उत्तर के समान है, इसमें वह परिमाण और चिन्ह को चुनता है, लेकिन यह अलग है कि मैं संकेत चुनने के लिए एक एजेंडा का उपयोग करता हूं।

— कोनोर ओ ब्रायन
स्रोत

2

MATL, 8 बाइट्स

_3&\wq*_

यह समाधान अनुक्रम में 1-आधारित अनुक्रमण का उपयोग करता है।

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

सभी परीक्षण मामलों को दिखाने वाला संशोधित संस्करण

व्याख्या

        % Implicitly grab the input
_       % Negate the input
3&\     % Compute the modulus with 3. The second output is floor(N/3). Because we negated
        % the input, this is the equivalent of ceil(input/3)
w       % Flip the order of the outputs
q       % Subtract 1 from the result of mod to turn [0 1 2] into [-1 0 1]
*       % Take the product with ceil(input/3)
_       % Negate the result so that the sequence goes [N 0 -N] instead of [-N 0 N]
        % Implicitly display the result

— Suever
स्रोत

2

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

*h/Q3-1%Q3

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

स्पष्टीकरण:

*     : Multiply following two arguments
h/Q3  : 1 + Input/3
-1%Q3 : 1 - Input%3

नोट: मैंने शून्य अनुक्रमित अनुक्रम मान लिया है।

— जॉन रेड
स्रोत

1

आप शायद इस लिंक को शामिल करना चाहेंगे। इसके अलावा, PPCG में आपका स्वागत है!

— लीक नन

मैं आपके समाधान के काफी करीब *@(1ZtZ)%Q3h/Q3

— पहुँच

@ फ़लीफ़े (1ZtZ)=-L1 2

— लीक नन

2

दरअसल, 10 बाइट्स

3@│\u)%1-*

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

स्पष्टीकरण:

3@│\u)%1-*
3@│         push 3, swap, duplicate entire stack ([n 3 n 3])
   \u)      floor division, increment, move to bottom ([n 3 n//3+1])
      %1-   mod, subtract from 1 ([1-n%3 n//3+1])
         *  multiply ([(1-n%3)*(n//3+1)])

— मै जाऊं
स्रोत

2

05AB1E, 7 बाइट्स

कोड:

(3‰`<*(

व्याख्या की:

(           # negate input: 12 -> -12
 3‰         # divmod by 3: [-4, 0]
   `        # flatten array: 0, -4
    <       # decrease the mod-result by 1: -1, -4
     *      # multiply: 4
      (     # negate -4

— Emigna
स्रोत

2

जप, 44 बाइट्स

Element[Flatten[Sequence[{t,0,-t},t,1,n]],n]

कहाँ पे nएक-अनुक्रमित है।

स्पष्टीकरण:

Element[                      , n] # Return the nth element of the list                  .
 Flatten[                    ]     # Strip all the unnecessary braces from the list     /|\
  Sequence[{t,0,-t}, t, 1, n]      # Generate a list of lists of the form {t, 0, -t}     |
                             # This list will start with {1,0,-1} and end with {n,0,-n}  |

के माध्यम से सभी ट्रिपल उत्पन्न करने के लिए आवश्यक नहीं है {n, 0, -n}, लेकिन यह लेखन ceil(n/3)या उस प्रभाव से कुछ की तुलना में कम है । ध्यान दें कि nइस ऑब्जेक्ट को बनाने के लिए इसे परिभाषित किया जाना चाहिए (यदि यह इस समय चलने पर परिभाषित नहीं किया गया है, तो आप इसके लिए स्लाइडर बनाने के लिए संकेत देंगे n)।

— जो
स्रोत

नमस्ते और PPCG में आपका स्वागत है! क्या आपके पास एक लिंक है जो मैं इसका परीक्षण कर सकता हूं (अधिमानतः ऑनलाइन)?

— R

@ E @sᴀIʀᴋ, धन्यवाद! यहां एक ऑनलाइन एपलेट बातमबोब का लिंक दिया गया है। पृष्ठ थोड़ी देर के लिए रिक्त दिखता था, लेकिन फिर यह दिखा।

— जो

ओह बढ़िया। लेकिन मैं सूत्र में कैसे डालूं? > _> मैंने इसे रिक्त में चिपकाने की कोशिश की, और इसने एक स्लाइडर बनाने का संकेत दिया, लेकिन कुछ और नहीं हुआ।

— R

@ E @s handIʀᴋ: बायीं ओर, जहां यह कहता है "इनपुट ..." सबसे पहले, आरंभ करने के लिए n, कुछ ऐसा दर्ज करें n=297(यह आपको एक स्लाइडर देगा जो अच्छी तरह से कॉन्फ़िगर किया गया है)। फिर सूत्र को इनपुट बॉक्स में पेस्ट करें, जो अब नीचे होना चाहिए n। (रिटर्न हिट करना सुनिश्चित करें;) सूत्र को nअनुक्रम के वें शब्द का मूल्यांकन करना चाहिए , और स्लाइडर को स्थानांतरित करने पर इसे बदलना चाहिए।

— जो

2

भूलभुलैया , 17 15 14 बाइट्स

के 1-(n%3)बजाय का उपयोग करने के सोक के विचार का उपयोग कर 3 बाइट्स सहेजे ~(n%3-2)।

1?:#/)}_3%-{*!

कार्यक्रम एक त्रुटि (शून्य से विभाजन) के साथ समाप्त होता है, लेकिन त्रुटि संदेश STDERR को जाता है।

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

व्याख्या

कार्यक्रम पूरी तरह से रैखिक है, हालांकि कुछ कोड को अंत में रिवर्स में निष्पादित किया जाता है।

1     Turn top of stack into 1.
?:    Read input as integer and duplicate.
#     Push stack depth (3).
/)    Divide and increment.
}     Move over to auxiliary stack.
_3%   Take other copy modulo 3.
-     Subtract from 1. This turns 0, 1, 2 into 1, 0, -1, respectively.
{*    Move other value back onto main stack and multiply.
!     Output as integer.

निर्देश सूचक अब एक मृत अंत को हिट करता है और चारों ओर मुड़ता है, इसलिए यह कोड को अंत से निष्पादित करना शुरू करता है:

*     Multiply two (implicit) zeros.
{     Pull an (implicit) zero from the auxiliary to the main stack.
-     Subtract two (implicit) zeros from one another.
      Note that these were all effectively no-ops due to the stacks which are
      implicitly filled with zeros.
%     Attempt modulo, which terminates the program due to a division-by-zero error.

— मार्टिन एंडर
स्रोत

2

एर्लैंग, 40 बाइट्स

F=fun(N)->trunc((N/3+1)*(1-N rem 3))end.

अफसोस की बात यह है कि एर्लैंग के पास '%' मॉडुलो ऑपरेटर नहीं है और 'रेम' को 3 से पहले भी रिक्त स्थान की आवश्यकता होती है।

— fxk8y
स्रोत

2

हेक्सागोनी , 25 बाइट्स

?'+}@/)${':/3$~{3'.%(/'*!

या, गैर-लघु प्रारूप में:

    ? ' + }
   @ / ) $ {
  ' : / 3 $ ~
 { 3 ' . % ( /
  ' * ! . . .
   . . . . .
    . . . .

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

हेक्सागोनी में मेरा पहला रास्ता, इसलिए मुझे यकीन है कि मैंने इसे कहीं भी कुशलतापूर्वक नहीं किया है क्योंकि यह किया जा सकता है ...

-(n%3 - 1)एक मेमोरी किनारे n/3 + 1पर, आसन्न एक पर गणना करता है, फिर उन्हें एक साथ गुणा करता है।

— सोक
स्रोत

वाह, यह देखने के लिए बहुत दिलचस्प है! :)

— अदनान

2

आर, 28 बाइट्स

-((n=scan())%%3-1)*(n%/%3+1)

ऐसा लगता है कि यहां अधिकांश उत्तरों में भिन्नता है। शून्य आधारित।

   n=scan()                  # get input from STDIN
  (        )%%3-1            # mod by 3 and shift down (0,1,2) -> (-1,0,1)
-(               )           # negate result (1,0,-1), this handles the alternating signs
                  *(n%/%3+1) # integer division of n by 3, add 1, multiply by previous

इसके बारे में अच्छी बात यह है कि यह कई इनपुट को संभालता है

> -((n=scan())%%3-1)*(n%/%3+1)
1: 0 3 6 9 1 4 7 10 2 5 8 11
13: 
Read 12 items
 [1]  1  2  3  4  0  0  0  0 -1 -2 -3 -4
>

मूल रूप से मैं निम्नलिखित कार्य करना चाहता था, लेकिन अतिरिक्त बाइट्स को रोक नहीं सका।

rbind(I<-1:(n=scan()),0,-I)[n]

rbind1 की सीमा में 0 और नकारात्मक जोड़ने के लिए उपयोग करता है, nफिर n'वें शब्द (एक आधारित) वापस करने के लिए।

# for n = 5
rbind(                    )    # bind rows 
            n=scan()           # get input from STDIN and assign to n
      I<-1:(        )          # build range 1 to n and assign to I
                     ,0        # add a row of zeros (expanded automatically)
                       ,-I     # add a row of negatives
                           [n] # return the n'th term

— MickyT
स्रोत

2

बैच (विंडोज), 86 बाइट्स

Alternate.bat

SET /A r=%1%%3
SET /A d=(%1-r)/3+1
IF %r%==0 ECHO %d%
IF %r%==1 ECHO 0
IF %r%==2 ECHO -%d%

इस कार्यक्रम के रूप में चलाया जाता Alternate.bat nहै, जहां nआप जिस नंबर पर समारोह कॉल करना चाहते हैं है।

— क्रिश्चियन को आकर्षित किया
स्रोत

2

एपीएल, 12 वर्ण

-×/1-0 3⊤6+⎕

0 3⊤एपीएल है divmod 3।

— lstefano
स्रोत

2

जावा 7, 38 37 36 बाइट्स

मेरा पहला गोल्फ, कोमल होना

int a(int i){return(1+i/3)*(1-i%3);}

यहाँ यह कोशिश करो! (परीक्षण मामलों में शामिल हैं)

संपादित करें: मैंने दुस्साहस किया, और (-i%3+1)साथ में एक और चरित्र को भी बदल दिया (1-i%3)।

— स्टीवन एच।
स्रोत

1

नमस्कार, और PPCG में आपका स्वागत है! आप के बाद अंतरिक्ष को हटा सकते हैं return, और जावा 8 लैम्ब्डा का उपयोग कर सकते हैं ।

— NoOneIsHere

मुझे यह निर्दिष्ट करना चाहिए कि यह जावा 7 था। मैं उस स्थान को हटा दूँगा, हालाँकि। धन्यवाद!

— स्टीवन एच।

1

रेटिना, 45 बाइट्स

.+
11$&$*
(111)+(1)*
$#2$#1
T`d`+0-`^.
^0.+
0

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

परीक्षण सूट।

बेस-दस में इनपुट / आउटपुट लेता है। 1 अनुक्रमित।

Unary input, base-ten output, 1-indexed: 40 बाइट्स

$
11
(111)+(1)*
$#2$#1
T`d`+0-`^.
^0.+
0

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

परीक्षण सूट।

— लीक नन
स्रोत

1

MATLAB / ऑक्टेव, 27 बाइट्स

@(n)ceil(n/3)*(mod(-n,3)-1)

यह एक अनाम फ़ंक्शन बनाता है जिसे उपयोग करके बुलाया जा सकता है ans(n) । यह समाधान 1-आधारित अनुक्रमण का उपयोग करता है।

सभी परीक्षण मामले

— Suever
स्रोत

1

गणितज्ञ 26 बाइट्स

4 बाइट्स के साथ मार्टिन एंडर को धन्यवाद दिया।

⎡#/3⎤(-#~Mod~3-1)&

Suever के समान दृष्टिकोण का उपयोग करता है।

— DavidC
स्रोत

1

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

कोई मॉड विपक्ष के साथ ...

@(n)(-[-1:1]'*[1:n])(n)

1-आधारित अनुक्रमण जादू का उपयोग करता है।

व्याख्या

एक अनाम फ़ंक्शन बनाता है जो:

(-[-1:1]'*[1:n])(n)
  [-1:1]              % make a row vector [-1 0 1]
 -      '             % negate and take its transpose making a column vector
          [1:n]       % make a row vector [1..n], where n is the input
         *            % multiply with singleton expansion
               (n)    % use linear indexing to get the nth value

गुणन चरण के बाद हमारे पास एक 3xn मैट्रिक्स होगा जैसे (n = 12 के लिए):

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

nकॉलम बनाना ओवरकिल है, लेकिन यह एक सुविधाजनक संख्या है जिसकी गारंटी काफी बड़ी है। रैखिक अनुक्रमण बाएं से दाएं प्रत्येक स्तंभ को गिनता है, इसलिए रैखिक सूचकांक में तत्व 4होगा 2।

Ideone पर सभी परीक्षण मामले ।

— बीकर
स्रोत

1

डीसी, १०

?2+3~1r-*p

1-आधारित अनुक्रमण का उपयोग करता है।

?              # Push input to stack
 2+            # Add 2
   3~          # divmod by 3
     1r-       # subtract remainder from 1
        *      # multiply by quotient
         p     # print

— डिजिटल आघात
स्रोत

वैकल्पिक साइन अनुक्रम

परिचय

काम

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

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

जावास्क्रिप्ट ईएस 6, 18 बाइट्स

व्याख्या और असंगति

MarioLANG, 93 81 बाइट्स

पायथन 2, 24 बाइट्स

पूरा कार्यक्रम:

MATL, 15 12 बाइट्स

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

MATL , 8 बाइट्स

व्याख्या

पर्ल 5, 22 बाइट्स

बैश, 28 25 बाइट्स

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

स्पष्टीकरण (पहले एक का):

परीक्षा:

जे, 19 15 बाइट्स

Ungolfed:

Pyke, 8 7 बाइट्स (पुराना संस्करण)

जे, 27 बाइट्स

MATL, 8 बाइट्स

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

दरअसल, 10 बाइट्स

05AB1E, 7 बाइट्स

जप, 44 बाइट्स

भूलभुलैया , 17 15 14 बाइट्स

व्याख्या

एर्लैंग, 40 बाइट्स

हेक्सागोनी , 25 बाइट्स

आर, 28 बाइट्स

बैच (विंडोज), 86 बाइट्स

Alternate.bat

एपीएल, 12 वर्ण

जावा 7, 38 37 36 बाइट्स

रेटिना, 45 बाइट्स

Unary input, base-ten output, 1-indexed: 40 बाइट्स

MATLAB / ऑक्टेव, 27 बाइट्स

गणितज्ञ 26 बाइट्स

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

डीसी, १०