Stranamente uniforme, positivamente negativo


36

Dato N, genera l'ennesimo termine di questa sequenza infinita:

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

N può essere 0-indicizzato o 1-indicizzato come desideri.

Ad esempio, se 0-indicizzati poi ingressi 0, 1, 2, 3, 4dovrebbe produrre rispettive uscite -1, 2, -2, 1, -3.

Se 1-indicizzato poi ingressi 1, 2, 3, 4, 5dovrebbe produrre rispettive uscite -1, 2, -2, 1, -3.

Per essere chiari, questa sequenza viene generata prendendo la sequenza di numeri interi positivi ripetuti due volte

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

e riordinando ogni coppia di numeri dispari per circondare i numeri pari appena sopra di esso

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

e infine negando ogni altro termine, a cominciare dal primo

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

Vince il codice più breve in byte.


A001057 senza lo zero iniziale?
devRicher

@devRicher no, i valori assoluti ci vanno 1,1,2,2,3,3,4,4,...ma eccolo qui 1,2,2,1,3,4,4,3,....
Martin Ender,

6
Potresti fornire un modulo chiuso per questa sequenza o almeno qualcosa di un po 'più specifico rispetto ai primi termini diversi
0'

Quell'equazione per l'ennesimo termine non valuta mai un valore negativo ... qualcosa non va.
Magic Octopus Urn

1
@ 0 'Ho aggiunto quello che penso in un modo intuitivo di guardarlo, anche se non in una forma chiusa. Parte della sfida è capire qual è lo schema e come tradurlo in matematica e codice.
Calvin's Hobbies,

Risposte:



17

Mathematica, 29 byte

((#~GCD~4/. 4->-2)+#)/2(-1)^#&

Funzione pura che accetta un input con 1 indice. Oltre ai segni alternati (-1)^#, due volte la sequenza è vicina all'ingresso, le differenze sono 1, 2, 1, -2 ciclicamente. È bello che #~GCD~4, il più grande divisore comune dell'input e 4, sia 1, 2, 1, 4 ciclicamente; quindi sostituiamo manualmente 4->-2e lo chiamiamo un giorno. Mi piace questo approccio perché evita la maggior parte dei comandi Mathematica a molti caratteri.


9

Pip , 24 22 byte

v**a*YaBA2|1+:--a//4*2

Accetta input, indicizzato 1, come argomento della riga di comando. Provalo online o verifica 1-20 .

Spiegazione

Osserva che la sequenza può essere ottenuta combinando altre tre sequenze, una indicizzata con zero e l'altra indicizzata:

  • Inizia con 0 0 0 0 2 2 2 2 4 4 4 4=a//4*2 (0-indicizzato);
  • Aggiungi 1 2 2 1 1 2 2 1 1 2 2 1= aBA2|1, dove BAè bit a bit AND, e| è OR logico (1-indicizzato);
  • Moltiplica la somma per -1 1 -1 1 -1 1 -1 1 -1 1 -1 1= (-1)**a(1-indicizzato).

Se iniziamo con a1 indicizzato, possiamo prima calcolare le parti con 1 indice (leggendo l'espressione da sinistra a destra) e quindi diminuire aper la parte con indice 0. Usando la variabile incorporata v=-1, otteniamo

v**a*((aBA2|1)+--a//4*2)

Per radere altri due byte, dobbiamo usare alcuni trucchi per manipolare la precedenza. Possiamo eliminare le parentesi interne sostituendole +con +:(equivalente a +=in molte lingue). Qualsiasi operatore di calcolo e assegnazione ha una priorità molto bassa, quindi aBA2|1+:--a//4*2è equivalente a (aBA2|1)+:(--a//4*2). Pip emetterà un avviso sull'assegnazione a qualcosa che non è una variabile, ma solo se abbiamo gli avvisi abilitati.

L'unica cosa che ha una precedenza inferiore a quella :è Yl'operatore yank. * Assegna il valore del suo operando alla yvariabile e lo passa invariato; in modo da poter eliminare le parentesi esterne come bene da tirando il valore piuttosto che mettere tra parentesi esso: YaBA2|1+:--a//4*2.

* rint Pe Output hanno la stessa precedenza di Yank, ma qui non sono utili.


9

Gelatina , 8 7 byte

H^Ḃ~N⁸¡

Questo utilizza l'algoritmo della mia risposta Python , che è stato notevolmente migliorato da @GB .

Provalo online!

Come funziona

H^Ḃ~N⁸¡  Main link. Argument: n

H        Halve; yield n/2. This returns a float, but ^ will cast it to int.
  Ḃ      Bit; yield n%2.
 ^       Apply bitwise XOR to both results.
   ~     Take the bitwise NOT.
    N⁸¡  Negate the result n times.

Penso che questo sia il personaggio ASCII più standard che abbia mai visto in una presentazione di Jelly. Vedo solo due personaggi che mi infastidirebbero (senza contare ¡)
Esolanging Fruit


9

Java 8, 19 byte

n->~(n/2)+n%2*(n|2)

Java 7, 47 37 byte

int c(int n){return~(n/2)+n%2*(n|2);}

La prima volta che Java (8) compete effettivamente ed è più breve di alcune altre risposte. Non riesco ancora a battere le attuali lingue del golf come Jelly e simili (duhuh .. che sorpresa ..>.>; P)


Porta a 0 indici dalla risposta Python 2 di @Xnor .
-10 byte grazie a @GB

Provalo qui.


2
You don't need the ternary check if you put (n/2) in parentheses.
G B

1
@GB Ah, so that was the issue.. Thanks. I kinda feel stupid now.. >.>
Kevin Cruijssen

Oh, we're allowed just function definitions for java?
Cruncher

@Cruncher Unless the question states otherwise, the default is full program or function. So yes, it is allowed to just post a method in Java, or a lambda in Java 8 (I've added the Java 8 equivalent in my answer above).
Kevin Cruijssen

1
@EricDuminil The default is program or function, unless the challenge states otherwise.
Kevin Cruijssen

8

Jelly, 15 12 11 bytes

Ḷ^1‘ż@N€Fị@

Try it online!

How it works

Ḷ^1‘ż@N€Fị@  Main link. Argument: n

Ḷ            Unlength; yield [0, 1, 2, 3, ..., n-1].
 ^1          Bitwise XOR 1; yield [1, 0, 3, 2, ..., n-1^1].
   ‘         Increment; yield [2, 1, 4, 3, ..., (n-1^1)+1].
      N€     Negate each; yield [-1, -2, -3, -4, ..., -n].
    ż@       Zip with swapped arguments; 
             yield [[-1, 2], [-2, 1], [-3, 4], [-4, 3], ..., [-n, (n-1^1)+1]].
        F    Flatten, yield [-1, 2, -2, 1, -3, 4, -4, 3, ..., -n, (n-1^1)+1].
         ị@  At-index with swapped arguments; select the item at index n.

I knew there'd be a jelly answer around 10
Cruncher


I saw it right after posting this comment lol. I really need to learn Jelly one of these days... It's funny if you look at the history of questions on this SE. Used to be all GolfScript, then CJam took over, and now it's Jelly.
Cruncher

6

RProgN 2, 31 25 22 bytes

nx=x2÷1x4%{+$-1x^*}#-?

Explained

nx=                         # Convert the input to a number, set x to it.
   x2÷                      # Floor divide x by 2.
      1                     # Place a 1 on the stack.
       x4%{       }#-?      # If x%4 is 0, subtract 1 from x//2, otherwise...
           +                # Add the 1 and the x together.
            $-1             # Push -1
               x^           # To the power of x.
                 *          # Multiply x//2+1 by -1^x. (Invert if odd, do nothing if even)

Try it online!


Nice approach! +1
R. Kap

6

Ruby, 26 23 18 bytes

->n{~n/2+n%2*n|=2}

0-based

-3 bytes stealing the -1^n idea from Greg Martin, Dennis and maybe somebody else, then -5 bytes stealing the n|2 idea from xnor.




4

05AB1E, 8 bytes

2‰`^±¹F(

Try it online

Explanation

2‰          divmod by 2
  `         flatten list
   ^        XOR
    ±       NOT
     ¹F(    Push 1st argument, loop N times, negate

Wow, I love it, but ¹F( seems expensive for "if odd, negate".
Magic Octopus Urn

@carusocomputing It does, but that's the shortest I know of. Dennis's similar answer in Jelly also has 3 bytes for that part. It's still shorter than duplicate, push parity, if, negate.
mbomb007

I tried for 15 minutes to beat it, only thing that came close was another 3 byte solution of to the power of n, to the power of 1/n.
Magic Octopus Urn


3

CJam, 16 bytes

{_(_1&)^2/)W@#*}

1-based input.

Try it online!

Explanation

Here is a breakdown of the code with the values on the stack for each input from 1 to 4. The first few commands only affect the two least significant bits of n-1 so after 4, this stuff just repeats cyclically, with the results incremented by 2, due to the halving.

Cmd             Stack: [1]       [2]       [3]       [4]
_    Duplicate.        [1 1]     [2 2]     [3 3]     [4 4]
(    Decrement.        [1 0]     [2 1]     [3 2]     [4 3]
_    Duplicate.        [1 0 0]   [2 1 1]   [3 2 2]   [4 3 3]
1&   AND 1.            [1 0 0]   [2 1 1]   [3 2 0]   [4 3 1]
)    Increment.        [1 0 1]   [2 1 2]   [3 2 1]   [4 3 2]
^    XOR.              [1 1]     [2 3]     [3 3]     [4 1]
2/   Halve.            [1 0]     [2 1]     [3 1]     [4 0]
)    Increment.        [1 1]     [2 2]     [3 2]     [4 1]
W    Push -1.          [1 1 -1]  [2 2 -1]  [3 2 -1]  [4 1 -1]
@    Rotate.           [1 -1 1]  [2 -1 2]  [2 -1 3]  [1 -1 4]
#    -1^n.             [1 -1]    [2 1]     [2 -1]    [1 1]
*    Multiply.         [-1]      [2]       [-2]      [1]

2

Perl 6,  55 27 24  22 bytes

{(-1,2,-2,1,{|($^a,$^b,$^c,$^d Z+ -2,2,-2,2)}...*)[$_]}

(Inspired by the Haskell zipWith answer)
Try it

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

(Inspired by several answers)
Try it

{+^($_+>1)+$_%2*($_+|2)}

Try it

{+^$_+>1+$_%2*($_+|2)}

Try it

Expanded:

{  # bare block lambda with implicit parameter 「$_」

    +^          # numeric binary invert the following
      $_ +> 1   # numeric bit shift right by one
  +
      $_ % 2    # the input modulo 2
    *
      ($_ +| 2) # numeric binary inclusive or 2
}

(All are 0 based)


Nice submission!
CraigR8806

2

Haskell, 37 36 bytes

(([1,3..]>>= \x->[-x,x+1,-x-1,x])!!)

Try it online! This is an anonymous function which takes one number n as argument and returns 0-indexed the nth element of the sequence.


1

Haskell, 56 bytes

f n=concat(iterate(zipWith(+)[-2,2,-2,2])[-1,2,-2,1])!!n

0-indexed


1

Perl 5 47 + 1 (for flag) = 48 Bytes

print(((sin$_%4>.5)+1+2*int$_/4)*($_%4&1?1:-1))

Old Submission 82 Bytes

@f=(sub{-$_[0]},sub{$_[0]+1},sub{-$_[0]-1},sub{$_[0]});print$f[$_%4](1+2*int$_/4)

Run like so:

perl -n <name of file storing script>  <<<  n

You can save one byte by using print +(( and removing the final ). And two more by using say and -E. And also one more by doing ($_%4&1||-1) instead of the ternary.
simbabque

1

JavaScript (ES7), 28 bytes

n=>(n+2>>2)*2*(-1)**n-!(n&2)

1-indexed. I haven't looked at any other answers yet so I don't know if this is the best algorithm, but I suspect not.



1

dc, 98 bytes

?sa0sb1sq[lq1+dsqla!<i3Q]sf[lb1-lfx]su[lblfx]sx[lb1+dsblfx]sj[lqdd4%d0=u1=j2%1=xljxlfx]dsix_1la^*p

Gosh, this is the longest answer here, mainly because I went the path of generating the absolute value of each element of the sequence one by one based on the following recursive formula:

enter image description here

then outputting (-1)^n * a_n, rather than directly computing the n'th element. Anyways, this is 1-indexed.

Try it online!


1

R, 38 bytes

function(n)floor(n/2+1-2*!n%%4)*(-1)^n

Explanation

floor(n/2+1)                ->  1 2  2 3  3 4  4 5...
floor(n/2+1-2*!n%%4)        ->  1 2  2 1  3 4  4 3... (subtract 2 where n%%4 == 0)
floor(n/2+1-2*!n%%4)*(-1)^n -> -1 2 -2 1 -3 4 -4 3... (multiply odd n by -1)

1

TI-Basic (TI-84 Plus CE), 31 bytes

.5(Ans+1+remainder(Ans+1,2)-4not(remainder(Ans,4)))i^(2Ans

TI-Basic is a tokenized language and each token used here is one byte, except remainder(, which is two.

This uses the 1-indexed version.

Explanation:

There is a pattern that repeats every four numbers. In the 1-indexed version, it is: -(x+1)/2, (x+1)/2, -(x+1)/2, (x-1)/2 for the input value x. This can be represented as a piecewise-defined function.

f(x) = -(x+1)/2 if x ≡ 1 mod 4; (x+1)/2 if x ≡ 2 mod 4; -(x+1)/2 if x ≡ 3 mod 4; (x-1)/2 if x ≡ 0 mod 4

Because the "x ≡ 1 mod 4" and "x ≡ 3 mod 4" parts are the same, we can combine them into "x ≡ 1 mod 2".

Now are piecewise function is:

f(x) = -(x+1)/2 if x ≡ 1 mod 2; (x+2)/2 if x ≡ 2 mod 4; (x-2)/2 if x ≡ 0 mod 4

This is where I start breaking it into actual commands. Since the value is positive for even indexes and negative for odd ones, we can use (-1)^x. However, in TI-Basic i^(2X (5 bytes) is shorter than (-1)^Ans (6 bytes). Note that parentheses are required due to order of operations.

Now that we have the way to negate the odd inputs out of the way, we move on to the mods (adding the negating back on later). I made the case of an odd input the default, so we start with .5(Ans+1).

To fix the case of even input, just add one to the number in the parentheses, but only when x ≡ 0 mod 2. This could be represented as .5(Ans+1+remainder(Ans+1,2)) or .5(Ans+1+not(remainder(Ans,2))), but they have the same byte count, so it doesn't matter which.

To fix the case of multiple-of-4 input, we need to subtract 3 from the number in the parentheses, but also another 1 because all multiples of 4 are even, which would add one from our previous step, so we now have .5(Ans+1+remainder(Ans+1,2)-4not(remainder(Ans,4))).

Now, just tack on the sign-determining part to the end to get the full program.



0

QBIC, 53 bytes

b=1:{[b,b+3|~b=a|_x(-(b%2)*2+1)*(q+(b%4>1)*-1)]]q=q+2

Explanation:

b=1     Set b to a starting value of 1
        QBIC would usually use the pre-initialised variable q, but that is already in use
:       Get an input number from the cmd-line, our term to find
{       Start an infinite loop
[b,b+3| FOR-loop: this runs in groups of 4, incrementing its own bounds between runs
~b=a|   If we've reached the term requested
_x      QUIT the program and print:

(-(b%2)*2+1)   The b%2 gives a 1 or a 0, times 2 (2,0), negged (-2,0) and plus one (-1,1)
*              That gives us the sign of our term. Now the value:
(q+(b%4>1)*-1) This is q + 1 if the inner loop counter MOD 4 (1,2,3,0...) is 2 or 3.
]       Close the IF that checks the term
]       Close the FOR-loop
q=q+2   And raise q by 2 for the next iteration of the DO-loop.


0

Q, 52 bytes

{(1 rotate(,/){x,(-)x}each 1_((_)x%4)+til 3)x mod 4}

0 indexed solution.

  1. Gets the block number ie. which [-x x+1 -(x+1) x] block within the sequence contains the index.
  2. Gets the index of the value within the block based on the index of the value within the whole sequence.
  3. Creates the block.
  4. Indexes into it via index derived in step 2.
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.