Ecco i primi 100 numeri di una sequenza semplice:

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

Come funziona questa sequenza?

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
• Per ogni pari n(0-indicizzato), è a(n-1) + X(dove X=1e aumenta di 1 ogni volta che si accede)
• Per ogni pari n(0-indicizzato), lo èa(n-1) - 1

Sfida:

Uno di:

• Dato un numero intero di input n, emette il n'th numero nella sequenza.
• Dato un numero intero di input n, emette i primi nnumeri della sequenza.
• Emette la sequenza indefinitamente senza prendere un input ( o prendere un input vuoto inutilizzato ).

Regole della sfida:

• L'ingresso npuò essere indicizzato 0 o 1.
• Se si genera (parte di) la sequenza, è possibile utilizzare un elenco / array, stampare su STDOUT con qualsiasi delimitatore (spazio, virgola, newline, ecc.). La tua chiamata.
• Indica quale delle tre opzioni hai utilizzato nella tua risposta.
• Dovrai supportare almeno i primi 10.000 numeri (il 10.000 ° è 12,497,501).

Regole generali:

• Questo è code-golf , quindi vince la risposta più breve in byte.
  Non lasciare che le lingue di code-golf ti scoraggino dal pubblicare risposte con lingue non codegolfing. Prova a trovare una risposta il più breve possibile per "qualsiasi" linguaggio di programmazione.
• Per la tua risposta valgono regole standard , quindi puoi usare STDIN / STDOUT, funzioni / metodo con i parametri corretti e tipo di ritorno, programmi completi. La tua chiamata.
• Sono vietate le scappatoie predefinite .
• Se possibile, aggiungi un link con un test per il tuo codice.
• Inoltre, si prega di aggiungere una spiegazione, se possibile.

Casi test:

Pastebin con i primi 10,001 numeri nella sequenza. Sentiti libero di scegliere quello che desideri.

Alcuni numeri più alti:

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

Python 2 , 32 28 25 byte

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

Provalo online!

Restituisce il -th nnumero ( 0-indexed)

Excel, 31 byte

La risposta è 0indicizzata Emette nil numero.

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

La sequenza descritta è in definitiva solo due sequenze interlacciate:

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

Interaginandoli in una 0sequenza indicizzata si ottiene:

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

Che dà:

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

che golfiamo fino ai 31byte.

Utilizzando lo stesso approccio, 1indicizzato dà 37byte:

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

Gelatina , 6 byte

Rj-ḣ⁸S

Provalo online!

0-indicizzati. Restituisce nil numero.

Spiegazione:

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

JavaScript (Node.js) , 23 byte

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

1-indicizzati. Provalo online!

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

Haskell , 40 38 37 byte

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

Restituisce un elenco infinito, provalo online!

Spiegazione

scanlprende tre argomenti f, inite xs( [ x ₀ , x ₁ ... ] ) e costruisce un nuovo elenco:

[ a ₀ = init , a ₁ = f (a ₀ , x ₀ ) , a ₂ = f (a ₁ , x ₁ ) ... ]

Impostiamo init = 0e utilizziamo l' ($)operatore dell'applicazione capovolto (quindi applica una _i alla funzione x _i ), ora abbiamo solo bisogno di un elenco di funzioni - l'elenco [1..]>>=(:[pred]).(+)è un elenco infinito con le giuste funzioni:

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

Alternativa interessante, 37 byte

flipavendo il tipo (a -> b -> c) -> b -> a -> cche potremmo anche usare id :: d -> dinvece che a ($)causa dell'inferenza del tipo di Haskell il tipo dsarebbe unificato a -> b, dandoci lo stesso.

Provalo online!

modificare

^{-2 byte usando (>>=)invece di do-notation.}

^{-1 byte usando scanlinvece di zipWith.}

Haskell , 25 byte

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

Provalo online!

Crea un elenco infinito.

Haskell , 27 byte

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

Provalo online!

Haskell , 30 byte

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

Provalo online!

05AB1E , 10 byte

ÎF<NÈi¼¾>+

Provalo online!

Spiegazione

Î             # 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

Un altro 10 byte: ÎFNÈN;Ì*<O

Ottava , 32 byte

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

Provalo online!

Emette l'n-esimo numero, indicizzato 0. Utilizza la stessa formula di molte altre risposte.

APL (Dyalog Unicode) , 16 12 byte ^SBCS

Funzione prefisso tacito anonimo. 0-indicizzati.

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

Provalo online!

+/ la somma di

⊢↑ i primi nelementi

∘∊ della ε nlisted (appiattito)

¯1,¨⍨ negativo-one-aggiunto a ciascun

⍳ primi n ɩ ndices (da 0 a n-1

Gelatina , 6 byte

HḶS‘_Ḃ

Un collegamento monadico che accetta (1-indicizzato) nche ritorna a(n).

Provalo online! Oppure vedi la suite di test

Come?

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)

PHP , 73 64 55 51 47 byte

Primo metodo

Risposta per il primo codice golf!
Sono sicuro che ci sono trucchi PHP per renderlo più breve e la matematica può probabilmente essere migliorata.

Prende n come primo argomento e genera l'ennesimo numero nella sequenza.

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

Meno 9 byte rimuovendo "$ x = 0;" e "$ i = 0".

Meno 9 byte grazie a @Kevin Cruijssen migliorando il ciclo for e la perdita del tag end.

Meno 1 byte usando bit a bit o "|" anziché "(int)"

Meno 3 byte grazie a @Dennis poiché puoi rimuovere i tag eseguendolo dalla riga di comando con "php -r 'code here'"

Provalo online!

Secondo metodo

Ho abbinato la mia precedente risposta a un metodo completamente nuovo!

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

Utilizzo di XOR e dell'operatore tenore per passare da una somma all'altra del ciclo.

Modifica: questo non funziona per n = 0 e non ho idea del perché. $ i non è assegnato, quindi dovrebbe essere 0, quindi il ciclo ($i<$argv[1])dovrebbe fallire come (0<0==false), quindi un $ x non assegnato dovrebbe produrre come 0 e non 1.

Provalo online!

Terzo metodo

La conversione della formula excel @Wernisch creata in PHP offre una soluzione a 47 byte

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

Provalo online!

R , 35 byte

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

Provalo online!

Ho pensato che fosse un'alternativa interessante alla risposta di @ JayCe poiché non porta molto bene alle lingue senza supporto incorporato per le matrici e sembra essere altrettanto golfy.

1-indicizzato, restituisce i primi nelementi della sequenza.

Come funziona:

rbind(n<-1:scan(),-1) costruisce la seguente matrice:

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

Poiché R tiene le matrici in ordine di colonna maggiore, se dovessimo convertirlo in a vector, otterremmo un vettore

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

che se prendessimo una somma cumulativa di, otterremmo

1 0 2 1 4 3 7 6

quale è la sequenza, solo senza il comando 0. diffinvfortunatamente aggiunge lo zero iniziale, quindi prendiamo i primi n-1valori dalla matrice e diffinvloro, ottenendo i primi nvalori della sequenza.

R , 35 34 byte

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

Provalo online!

Prima opzione di output. Formula uguale a molte altre risposte (vorrei indicare la prima risposta che fornisce la formula, non riesco a capire quale sia).

Opzioni seconda e terza uscita di seguito:

R , 43 byte

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

Provalo online!

R , 51 byte

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

Provalo online!

Matlab / Octave, 31 26 byte

5 byte salvati grazie a Luis Mendo!

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

Java (JDK 10) , 20 byte

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

Provalo online!

Port of TFeld's Python 2 anwser , quindi vai a dare loro un voto! ;)

QBasic 1.1 , 49 byte

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

1-indicizzati.

QBasic 1.1 , 30 byte

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

Utilizza l'algoritmo di TFeld. 0-indicizzati.

QBasic, 31 byte

La soluzione just-implement-the-spec è leggermente più lunga della soluzione Erik .

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

Questo produce indefinitamente. Ai fini della sua esecuzione, consiglio di cambiare l'ultima riga in qualcosa del genere LOOP WHILE INPUT$(1) <> "q", che attenderà la pressione di un tasto dopo ogni seconda sequenza di inserimento e uscirà se il tasto è premuto q.

C # (.NET Core) , 56 byte

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

-2 byte grazie a Kevin Crujssen

Provalo online!

1 indicizzato. ritornaa(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;
}

Buccia , 11 9 8 byte

ΘṁṠe→Θ∫N

Salvataggio di un byte grazie a H.PWiz.
Emette come un elenco infinito.
Provalo online!

Spiegazione

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

Dodos , 69 byte

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

Provalo online!

In qualche modo questa è la risposta più lunga.

Spiegazione.

┌────┬─────────────────────────────────────────────────┐
│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.│
└────┴─────────────────────────────────────────────────┘

Carbone , 15 byte

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

Provalo online! 0-indicizzati. Il collegamento è alla versione dettagliata del codice. La formula sarebbe probabilmente più breve, ma qual è il divertimento in questo? Spiegazione:

    Ｎ           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

JavaScript, 49 48 45 byte

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

Provalo online!

Non carino come la risposta di @tsh, ma il mio funziona per numeri più grandi.

E ora grazie @tsh, per la evalsoluzione!

Befunge 93, 26 byte

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

Funziona indefinitamente
Provalo online , anche se l'output diventa un po 'traballante e torna indietro dopo x = 256, presumibilmente TIO non è in grado di gestire caratteri sopra U + 256. Funziona bene su https://www.bedroomlan.org/tools/befunge-playground (solo Chrome, sfortunatamente. Con Firefox, le linee di fondo vengono rimosse in fase di esecuzione, per qualche motivo ...)

J , 17 byte

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

Un porto della soluzione APL di Adám.

Provalo online!

Pyth , 8 byte

s<s,R_1S

Restituisce nil numero nella sequenza, indicizzato 0. Provalo online

Spiegazione, con esempio per 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

Perl 6 ,  38  26 byte

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

Provalo

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

Basato sull'ingegneria inversa della risposta Python di TFeld .
Provalo

allargato

38 byte (generatore di sequenza):

{  # 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
}

Nota che questo ha il vantaggio che puoi passare * per ottenere l'intera sequenza o passare un intervallo per generare più valori in modo più efficiente.

26 byte (calcolo diretto):

{  # 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
}

05AB1E , 8 byte

;L¨O>¹É-

Provalo online!

Basato sull'approccio Jelly di Jonathan Allan (che probabilmente era basato sull'OP che modificava la domanda con un'altra definizione della sequenza), quindi 1-indicizzato.

Convesso , 10 9 byte

_½,ª)\2%-

Provalo online!

Basato sull'approccio Jelly di Jonathan Allan (che probabilmente era basato sull'OP che modificava la domanda con un'altra definizione della sequenza). 1-indicizzati.

Spiegazione:

_½,ª)\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]%]-]

Gelatina , 6 byte

Restituisce i primi nnumeri.

Rj-ÄŻḣ

Provalo online!