Seltsam gerade, positiv negativ

36

Bei N wird der N-te Term dieser unendlichen Folge ausgegeben:

-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 kann 0-indiziert oder 1-indiziert sein, wie Sie es wünschen.

Wenn beispielsweise 0-indexiert dann Eingänge 0, 1, 2, 3, 4sollte jeweilige Ausgänge erzeugen -1, 2, -2, 1, -3.

Wenn dann die Eingänge 1-indexieren 1, 2, 3, 4, 5sollte jeweilige Ausgänge erzeugen -1, 2, -2, 1, -3.

Um klar zu sein, wird diese Sequenz erzeugt, indem die Sequenz positiver Ganzzahlen zweimal wiederholt wird

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

und jedes Paar von ungeraden Zahlen neu anzuordnen, um die geraden Zahlen direkt darüber zu umgeben

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

und schließlich jeden anderen Ausdruck zu negieren, beginnend mit dem ersten

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

Der kürzeste Code in Bytes gewinnt.

Calvins Hobbys
quelle
A001057 ohne führende Null?
devRicher
@devRicher nein, die absoluten Werte gehen da 1,1,2,2,3,3,4,4,...aber hier ist es 1,2,2,1,3,4,4,3,....
Martin Ender
6
Könnten Sie eine geschlossene Form für diese Sequenz bereitstellen oder zumindest etwas, das etwas spezifischer ist als nur die ersten Begriffe
0 '
Diese Gleichung für den n-ten Term ergibt niemals einen negativen Wert ... etwas stimmt damit nicht.
Magic Octopus Urn
1
@ 0 'Ich habe das, was ich denke, auf intuitive Weise hinzugefügt, obwohl es keine geschlossene Form ist. Ein Teil der Herausforderung besteht darin, herauszufinden, was das Muster ist und wie man es in Mathematik und Code übersetzt.
Calvins Hobbys

Antworten:

32

Python 2 , 23 Bytes

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

Ungerade Eingaben ergeben ungefähr n/2gerade Eingaben -n/2. Also habe ich angefangen -n/2+n%2*nund von dort aus gezwickt.

Probieren Sie es online!

xnor
quelle
1
Erläuterung? :)
MildlyMilquetoast
17

Mathematica, 29 Bytes

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

Reine Funktion, die einen 1-indizierten Eingang verwendet. Abgesehen von den Wechselzeichen (-1)^#liegt die doppelte Sequenz nahe am Eingang, die Differenzen betragen zyklisch 1, 2, 1, -2. Es ist schön, dass #~GCD~4, der größte gemeinsame Teiler der Eingabe 4, zyklisch 1, 2, 1, 4 ist; also ersetzen wir es einfach manuell 4->-2und nennen es einen Tag. Ich mag diesen Ansatz, weil er die meisten Mathematica-Befehle mit vielen Zeichen vermeidet.

Greg Martin
quelle
9

Pip , 24 22 Bytes

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

Nimmt 1-indizierte Eingaben als Befehlszeilenargument. Versuchen Sie es online oder bestätigen Sie 1-20 .

Erläuterung

Beachten Sie, dass die Sequenz erhalten werden kann, indem drei andere Sequenzen kombiniert werden, eine mit Nullindex und die anderen mit einem Index:

  • Beginnen Sie mit 0 0 0 0 2 2 2 2 4 4 4 4= a//4*2(0-indiziert);
  • Add 1 2 2 1 1 2 2 1 1 2 2 1= aBA2|1, wobei BAbitweises UND und |logisches ODER (1-indiziert) ist;
  • Multiplizieren Sie die Summe mit -1 1 -1 1 -1 1 -1 1 -1 1 -1 1= (-1)**a(1-indiziert).

Wenn wir mit a1-indiziert beginnen, können wir zuerst die 1-indizierten Teile berechnen (den Ausdruck von links nach rechts lesen) und dann afür den 0-indizierten Teil dekrementieren . Mit der eingebauten Variablen erhalten v=-1wir

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

Um zwei weitere Bytes zu rasieren, müssen wir einige Tricks zur Vorrangmanipulation anwenden. Wir können die inneren Klammern durch Ersetzen +durch +:(entspricht +=in vielen Sprachen) beseitigen . Jeder Compute-and-Assign-Operator hat eine sehr niedrige Priorität und aBA2|1+:--a//4*2ist daher äquivalent zu (aBA2|1)+:(--a//4*2). Pip gibt eine Warnung zum Zuweisen zu etwas aus, das keine Variable ist, aber nur, wenn Warnungen aktiviert sind.

Das einzige , was niedrigere Priorität ist als :heißt Y, die yank Operator * Es seines Operanden den Wert auf dem zuweist. yVariable und leitet sie durch unverändert; so können wir die äußeren Klammern als auch durch den Wert zerren , anstatt das einklammern es beseitigen: YaBA2|1+:--a//4*2.

* Print und Output haben die gleiche Priorität wie Yank, sind aber hier nicht nützlich.

DLosc
quelle
9

Gelee , 8 7 Bytes

H^Ḃ~N⁸¡

Hierfür wird der Algorithmus aus meiner Python-Antwort verwendet , der durch @GB erheblich verbessert wurde .

Probieren Sie es online!

Wie es funktioniert

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.
Dennis
quelle
Ich denke, dies sind die Standard-ASCII-Zeichen, die ich in einer Jelly-Einreichung gesehen habe. Ich sehe nur zwei Charaktere, die mich nerven würden (ohne zu zählen ¡)
Esolanging Fruit
9

Java 8, 19 Bytes

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

Java 7, 47 37 Bytes

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

Zum ersten Mal konkurriert Java (8) tatsächlich und ist kürzer als einige andere Antworten. Trotzdem sind die aktuellen Golfsprachen wie Jelly und andere nicht zu übertreffen (duhuh .. was für eine Überraschung ..>.>; P)

0-indizierter
Port aus @Xnors Python 2-Antwort .
-10 Bytes dank @GB

Probieren Sie es hier aus.

Kevin Cruijssen
quelle
2
Sie brauchen die ternäre Prüfung nicht, wenn Sie (n / 2) in Klammern setzen.
GB
1
@GB Ah, das war das Problem. Danke. Ich fühle mich jetzt irgendwie dumm ..>.>
Kevin Cruijssen
Oh, wir dürfen nur Funktionsdefinitionen für Java?
Cruncher
@Cruncher Sofern in der Frage nichts anderes angegeben ist, ist die Standardeinstellung das vollständige Programm oder die Funktion . Also ja, es ist erlaubt, nur eine Methode in Java oder ein Lambda in Java 8 zu posten (ich habe das Java 8-Äquivalent in meiner obigen Antwort hinzugefügt).
Kevin Cruijssen
1
@EricDuminil Die Standardeinstellung ist Programm oder Funktion , sofern in der Abfrage nichts anderes angegeben ist.
Kevin Cruijssen
8

Jelly , 15 12 11 Bytes

Ḷ^1‘ż@N€Fị@

Probieren Sie es online!

Wie es funktioniert

Ḷ^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.
Dennis
quelle
Ich wusste, dass es gegen 10
Uhr
Ich habe es gleich nach dem Posten dieses Kommentars gesehen lol. Eines Tages muss ich wirklich Jelly lernen ... Es ist lustig, wenn man sich die Geschichte der Fragen zu dieser SE ansieht. Früher war alles GolfScript, dann übernahm CJam und jetzt ist es Jelly.
Cruncher
6

RProgN 2 , 31 25 22 Bytes

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

Erklärt

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)

Probieren Sie es online!

Ein Taco
quelle
Netter Ansatz! +1
R. Kap
6

Ruby, 26 23 18 Bytes

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

0-basiert

-3 Bytes, die Greg Martin , Dennis und vielleicht jemand anderem die Idee -1 ^ n stehlen , dann -5 Bytes, die xnor die Idee n | 2 stehlen .

GB
quelle
5

Python 2 ,  44  33 27 Bytes

lambda n:(-1)**n*~(n/2^n%2)

Vielen Dank an @GB für das Abwerfen von 6 Bytes!

Probieren Sie es online!

Dennis
quelle
4

05AB1E, 8 Bytes

2‰`^±¹F(

Probieren Sie es online aus

Erläuterung

2‰          divmod by 2
  `         flatten list
   ^        XOR
    ±       NOT
     ¹F(    Push 1st argument, loop N times, negate
mbomb007
quelle
Wow, ich liebe es, aber es ¹F(scheint teuer für "wenn ungerade, negieren".
Magic Octopus Urn
@carusocomputing Tut es, aber das ist das kürzeste was ich kenne. Dennis 'ähnliche Antwort in Jelly enthält auch 3 Bytes für diesen Teil. Es ist immer noch kürzer als duplizieren, Parität drücken, wenn, negieren.
mbomb007
Ich habe versucht , für 15 Minuten , um es zu schlagen, nur Sache , die nahe beieinander 3 - Byte - Lösung von der Macht kam , war n, der an die Macht 1/n.
Magic Octopus Urn
4

Gelee , 9 8 Bytes

|2×Ḃ+H~$

Probieren Sie es online!

-1 danke an Dennis . Duh float umbauten.

Verwendet den Python 2-Ansatz von @ xnor.

BEARBEITEN : > _>

Erik der Outgolfer
quelle
3
Wenn du glaubst, du gewinnst, wird Dennis mitkommen und dich schlagen.
HyperNeutrino
|2×Ḃ+H~$Speichert ein Byte. tio.run/nexus/jelly#AR0A4v//fDLDl@G4gitIfiT/…
Dennis
@Dennis Ich dachte, das würde einen Fehler auslösen.
Erik der Outgolfer
3

CJam , 16 Bytes

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

1-basierte Eingabe.

Probieren Sie es online!

Erläuterung

Hier ist eine Aufschlüsselung des Codes mit den Werten auf dem Stapel für jede Eingabe von 1bis 4. Die ersten paar Befehle wirken sich nur auf die zwei niedrigstwertigen Bits aus, n-1also 4wird dieses Zeug nur zyklisch wiederholt, wobei die Ergebnisse aufgrund der Halbierung um 2 erhöht werden.

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]
Martin Ender
quelle
2

Perl 6 ,  55 27 24  22 Bytes

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

(Inspiriert von der Haskell- zipWithAntwort)
Probieren Sie es aus

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

(Inspiriert von mehreren Antworten)
Probieren Sie es aus

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

Versuch es

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

Versuch es

Erweitert:

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

(Alle basieren auf 0)

Brad Gilbert b2gills
quelle
Schöne Vorlage!
CraigR8806
2

Haskell , 37 36 Bytes

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

Probieren Sie es online! Dies ist eine anonyme Funktion, die eine Zahl nals Argument verwendet und das 0-indizierte nElement der Sequenz zurückgibt .

Laikoni
quelle
1

Haskell, 56 Bytes

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

0-indiziert

Blex
quelle
1

Perl 5 47 + 1 (für Flag) = 48 Bytes

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

Alte Vorlage 82 Bytes

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

Laufen Sie wie folgt:

perl -n <name of file storing script>  <<<  n
CraigR8806
quelle
Sie können ein Byte speichern, print +((indem Sie das Finale verwenden und entfernen ). Und zwei weitere mit sayund -E. Und noch eins, indem man es ($_%4&1||-1)anstelle des Ternären tut .
Simbabque
1

JavaScript (ES7), 28 Byte

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

1-indiziert. Ich habe mir noch keine anderen Antworten angesehen, daher weiß ich nicht, ob dies der beste Algorithmus ist, aber ich vermute nicht.

ETHproductions
quelle
1

JavaScript, 28 22 Bytes

Vielen Dank an @ETHproductions für das Golfen mit 6 Bytes

x=>x%2?~x>>1:x%4+x/2-1

Probieren Sie es online!

fəˈnəˈtɪk
quelle
Hmm ... würde f=x=>x%2?~x>>1:x/2+x%4-1funktionieren?
ETHproductions
Aus irgendeinem Grund hatte ich das f = vor der anonymen Funktion verlassen: P
fəˈnəˈtɛk
1

Gleichstrom , 98 Bytes

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

Meine Güte, dies ist die längste Antwort hier, hauptsächlich, weil ich den Weg gegangen bin, den Absolutwert jedes Elements der Sequenz nacheinander auf der Grundlage der folgenden rekursiven Formel zu generieren:

Bildbeschreibung hier eingeben

dann Ausgeben (-1)^n * a_n, anstatt das n'te Element direkt zu berechnen . Wie auch immer, dies ist 1indiziert.

Probieren Sie es online!

R. Kap
quelle
1

R, 38 Bytes

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

Erläuterung

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)
user2390246
quelle
1

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

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

TI-Basic ist eine tokenisierte Sprache und jedes hier verwendete Token ist ein Byte, außer remainder(zwei.

Dies verwendet die 1-indizierte Version.

Erläuterung:

Es gibt ein Muster, das alle vier Zahlen wiederholt. In der 1-indizierten Version ist dies: - (x + 1) / 2, (x + 1) / 2, - (x + 1) / 2, (x-1) / 2 für den Eingabewert x. Dies kann als stückweise definierte Funktion dargestellt werden.

f (x) = - (x + 1) / 2, wenn x ≤ 1 mod 4 ist; (x + 1) / 2, wenn x ≤ 2 mod 4 ist; - (x + 1) / 2, wenn x ≤ 3 mod 4 ist; (x-1) / 2, wenn x ≤ 0 mod 4 ist

Da die Teile "x ≡ 1 mod 4" und "x ≡ 3 mod 4" gleich sind, können wir sie zu "x ≡ 1 mod 2" kombinieren.

Nun sind stückweise folgende Funktionen möglich:

f (x) = - (x + 1) / 2, wenn x ≤ 1 mod 2 ist; (x + 2) / 2, wenn x ≤ 2 mod 4 ist; (x-2) / 2, wenn x ≤ 0 mod 4 ist

Hier beginne ich, es in tatsächliche Befehle aufzuteilen. Da der Wert für gerade Indizes positiv und für ungerade Indizes negativ ist, können wir (-1) ^ x verwenden. In TI-Basic ist i^(2X(5 Bytes) jedoch kürzer als (-1)^Ans(6 Bytes). Beachten Sie, dass Klammern aufgrund der Reihenfolge der Operationen erforderlich sind.

Nachdem wir nun die Möglichkeit haben, die ungeraden Eingänge aus dem Weg zu räumen, gehen wir zu den Mods über (und fügen die Negierung später wieder hinzu). Ich habe den Fall einer ungeraden Eingabe zur Standardeinstellung gemacht, also fangen wir mit an .5(Ans+1).

Um den Fall einer geraden Eingabe zu beheben, fügen Sie einfach eine zur Zahl in Klammern hinzu, jedoch nur, wenn x ≡ 0 mod 2 ist. Dies könnte als .5(Ans+1+remainder(Ans+1,2))oder dargestellt werden .5(Ans+1+not(remainder(Ans,2))), aber sie haben die gleiche Byteanzahl, sodass es keine Rolle spielt, welche.

Um den Fall der Eingabe eines Vielfachen von 4 zu beheben, müssen wir 3 von der Zahl in Klammern subtrahieren, aber auch eine weitere 1, da alle Vielfachen von 4 gerade sind, was eine aus unserem vorherigen Schritt hinzufügen würde .5(Ans+1+remainder(Ans+1,2)-4not(remainder(Ans,4))).

Wenden Sie sich nun bis zum Ende an den vorzeichenbestimmenden Teil, um das vollständige Programm zu erhalten.

Pizzapants184
quelle
0

Befunge 93, 25 Bytes

Null indexiert

&4/2*1+&4%3%!!+&2%2*1-*.@

Probieren Sie es online!

Die Nummer ist gegeben durch ((2(n / 4) + 1) + !!((n % 4) % 3)) * (2(n % 2) - 1)

MilderMilquetoast
quelle
0

QBIC , 53 Bytes

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

Erläuterung:

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.
steenbergh
quelle
0

Q, 52 Bytes

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

0 indizierte Lösung.

  1. Ruft die Blocknummer ab, dh. welcher [-x x + 1 - (x + 1) x] Block innerhalb der Sequenz den Index enthält.
  2. Ruft den Index des Werts innerhalb des Blocks basierend auf dem Index des Werts innerhalb der gesamten Sequenz ab.
  3. Erzeugt den Block.
  4. Indexiert über den in Schritt 2 abgeleiteten Index hinein.
Daniel Plainview
quelle