Eingang:

Ganzzahl, ndie >=0oder ist >=1( f(0)ist optional)

Ausgabe:

Die n'te Nummer in der Folge unten ODER die Folge bis einschließlich der n' ten Nummer.

Reihenfolge:

(0),1,-1,-3,0,5,-1,-7,0,9,-1,-11,0,13,-1,-15,0,17,-1,-19,0,21,-1,-23,0,25,-1,-27,0,29,-1,-31,0,33,-1,-35,0,37,-1,-39,0,41,-1,-43,0,45,-1,-47,0,49,-1,-51,0,53,-1,-55,0,57,-1,-59,0,61,-1,-63,0,65,-1,-67,0,69,-1,-71,0,73,-1,-75,0,77,-1,-79,0,81,-1,-83,0,85,-1,-87,0,89,-1,-91,0,93,-1,-95,0,97,-1,-99

Wie ist diese Sequenz aufgebaut?

f(n=0) = 0(optional)
f(n=1) = f(0) + noder f(n=1) = 1
f(n=2) = f(1) - n
f(n=3) = f(2) * n
f(n=4) = f(3) / n
f(n=5) = f(4) + n
etc.

Oder in Pseudocode:

function f(integer n){
  Integer result = 0
  Integer i = 1
  Loop as long as i is smaller than or equal to n
  {
    if i modulo-4 is 1:
      result = result plus i
    if i modulo-4 is 2 instead:
      result = result minus i
    if i modulo-4 is 3 instead:
      result = result multiplied with i
    if i modulo-4 is 0 instead:
      result = result integer/floor-divided with i
    i = i plus 1
  }
  return result
}

Wie Sie vielleicht bemerkt haben, enthält die Sequenz zwei Muster:

0, ,-1,  ,0, ,-1,  ,0, ,-1,   ,0,  ,-1,   ,0,  ,-1,   ,...
 ,1,  ,-3, ,5,  ,-7, ,9,  ,-11, ,13,  ,-15, ,17,  ,-19,...

Alle anderen Ansätze, die zur gleichen Reihenfolge führen, sind natürlich auch völlig in Ordnung.

Herausforderungsregeln:

0-indizierte und 1-indizierte Eingaben führen zu demselben Ergebnis (daher f(0)ist das optional für 0-indizierte Eingaben, wenn Sie es einschließen möchten).
Sie dürfen die n'te Nummer dieser Sequenz ausgeben . Oder die gesamte Sequenz bis einschließlich der n'ten Nummer. ( f(5)Kann also entweder zu 5oder führen 0,1,-1,-3,0,5.)
- Wenn Sie die Sequenz bis einschließlich der n'ten Zahl ausgeben möchten, ist das Ausgabeformat flexibel. Kann eine durch eine Liste / ein Array, ein Komma / ein Leerzeichen / eine durch eine neue Zeile getrennte Zeichenfolge sein oder nach STDOUT usw. gedruckt werden.
Die Division ( /) ist eine Ganzzahl- / Bodendivision, die gegen 0 rundet (nicht gegen negative Unendlichkeit, wie dies in einigen Sprachen der Fall ist).

Allgemeine Regeln:

Das ist Code-Golf , also gewinnt die kürzeste Antwort in Bytes.
Lassen Sie sich von Code-Golf-Sprachen nicht davon abhalten, Antworten mit Nicht-Codegolf-Sprachen zu veröffentlichen. Versuchen Sie, für jede Programmiersprache eine möglichst kurze Antwort zu finden.
Für Ihre Antwort gelten Standardregeln. Daher dürfen Sie STDIN / STDOUT, Funktionen / Methoden mit den richtigen Parametern und vollständige Programme vom Rückgabetyp verwenden. Ihr Anruf.
Standardlücken sind verboten.
Fügen Sie nach Möglichkeit einen Link mit einem Test für Ihren Code hinzu.
Fügen Sie ggf. auch eine Erklärung hinzu.

Zusätzliche Testfälle oben `n=100`:

Input     Output

1000      0
100000    0
123       -123
1234      -1
12345     12345
123456    0

code-golf number sequence arithmetic integer Kevin Cruijssen
quelle

1

Ich konnte dies auf oeis.org nicht finden, daher möchten Sie es vielleicht dort einreichen. Es ist eine interessante Sequenz, ich bin überrascht, dass niemand sie registriert hat.

Pipe

1

@pipe es scheint ziemlich willkürlich

qwr

20

JavaScript (ES6), 19 Byte

n=>[0,n,-1,-n][n&3]

Probieren Sie es online!

Beweis

Nehmen wir an , dass wir die folgenden Beziehungen für einige haben n Vielfachen von 4. Diese Beziehungen trivialerweise für die ersten Glieder der Folge überprüft werden.

f(n)   = 0
f(n+1) = n+1
f(n+2) = -1
f(n+3) = -(n+3)

Und sei N = n + 4 . Dann per definitionem:

f(N)   = f(n+4) = f(n+3) // (n+4) = -(n+3) // (n+4) = 0
f(N+1) = f(n+5) = f(n+4) + (n+5)  = 0 + (n+5)       = N+1
f(N+2) = f(n+6) = f(n+5) - (n+6)  = (n+5) - (n+6)   = -1
f(N+3) = f(n+7) = f(n+6) * (n+7)  = -1 * (n+7)      = -(N+3)

Was durch mathematische Induktion beweist, dass die Beziehungen für ein beliebiges N- Vielfaches von 4 gelten .

Arnauld
quelle

2

Da die meisten Antworten Ports dieser Lösung sind, möchte ich hinzufügen, dass ich überprüft habe, ob sie nachweisbar ist.

Erik der Outgolfer

Ich habe einen alternativen Beweis.

Erik der Outgolfer

Ah, verrückt, wurde von der Arbeit abgelenkt, als ich an etwas sehr Ähnlichem arbeitete. +1

Shaggy

Gibt es aus Neugier einen Grund, "n & 3" gegenüber "n% 4" vorzuziehen?

IanF1

2

@ IanF1 Ich denke, dies ist nur eine Gewohnheit der einfachen Programmierung (das bitweise UND-Rechnen in der Baugruppe ist einfacher und schneller als das Modulo-Rechnen). Aber es macht hier nicht viel Sinn und ich war tatsächlich halb versucht, es n%4danach so zu ändern, dass es mit Zahlen größer als 32-Bit funktioniert.

Arnauld

4

05AB1E , 8 Bytes

Gibt das aus nth Nummer aus

ÎD(®s)sè

Probieren Sie es online!

05AB1E , 14 Bytes

Gibt eine Liste von Zahlen bis N unter Verwendung der Muster in der Sequenz aus

ÅÉāÉ·<*āÉ<‚øí˜

Probieren Sie es online!

Erläuterung

Beispiel mit N = 7

ÅÉ               # List of odd numbers upto N
                 # STACK: [1,3,5,7]
  ā              # Enumerate 1-based
   É             # is odd?
                 # STACK: [1,3,5,7],[1,0,1,0]
    ·<           # double and decrement
                 # STACK: [1,3,5,7],[1,-1,1,-1]
      *          # multiply
                 # STACK: [1,-3,5,-7]
       āÉ<       # enumerate, isOdd, decrement
                 # STACK: [1,-3,5,-7],[0,-1,0,-1]
          ‚ø     # zip
                 # STACK: [[1, 0], [-3, -1], [5, 0], [-7, -1]]
            í    # reverse each
             ˜   # flatten
                 # RESULT: [0, 1, -1, -3, 0, 5, -1, -7]

Emigna
quelle

4

Python 2 , 25 Bytes

Antwort von Port of Arnauld:

lambda n:[0,n,-1,-n][n%4]

Probieren Sie es online!

Naive Lösungen:

Python 3 , 50 49 Bytes

lambda n:n and eval('int(f(n-1)%sn)'%'/+-*'[n%4])

Probieren Sie es online!

Python 2 , 78 77 76 58 57 53 52 Bytes

lambda n:n and eval('int(1.*f(n-1)%sn)'%'/+-*'[n%4])

Probieren Sie es online!

Habe ein paar Bytes verwendet int, weil sich der Python-Stock teilt und nicht in Richtung 0, wie in der Frage.

TFeld
quelle

@ KevinCruijssen Ja, danke :)

TFeld

3

J , 12 Bytes

Antwort von Port of Arnauld:

4&|{0,],_1,-

Probieren Sie es online!

J , 28 Bytes

Naive Lösung:

{(0 _1$~]),@,.(_1^i.)*1+2*i.

Gibt die n-te Zahl aus

Probieren Sie es online!

Galen Ivanov
quelle

3

TIS `-n` `2` `1` , 123 Bytes

Gibt die nth Zahl für aus 0 <= n <= 999. (Die Obergrenze ist auf Spracheinschränkungen zurückzuführen.)

@0
MOV UP ACC
MOV ACC ANY
L:SUB 4
JGZ L
JEZ L
ADD 5
JRO -5
@1
MOV UP ACC
JRO UP
SUB ACC
JRO 3
MOV 1 ACC
NEG
MOV ACC ANY
HCF

Probieren Sie es online!

TIS `-n` `2` `1` , 124 Bytes

Gibt die nth Zahl für aus 0 <= n <= 999. (Die Obergrenze ist auf Spracheinschränkungen zurückzuführen.) Es nkönnen mehrere durch Leerzeichen getrennte Zeichen angegeben werden.

@0
MOV UP ACC
MOV ACC ANY
L:SUB 4
JGZ L
JEZ L
ADD 5
MOV ACC ANY
@1
MOV UP ACC
JRO UP
SUB ACC
JRO 3
MOV 1 ACC
NEG
MOV ACC ANY

Probieren Sie es online!

TIS `-n` `3` `1` , 192 Bytes

Gibt die Werte für 0..naus 0 <= n <= 999. (Die Obergrenze ist auf Spracheinschränkungen zurückzuführen.)

@0
MOV UP ACC
ADD 1
MOV ACC ANY
JRO -1
@1
SUB UP
JLZ C
HCF
C:ADD UP
MOV ACC ANY
ADD 1
SWP
ADD 1
MOV ACC ANY
SUB 4
JEZ W
ADD 4
W:SWP
@2
MOV UP ACC
JRO UP
SUB ACC
JRO 3
MOV 1 ACC
NEG
MOV ACC ANY

Probieren Sie es online!

Alle verwenden numerische E / A (die -n Flag). Die ersten beiden Lösungen verwenden zwei Rechenknoten, die übereinander positioniert sind. Der dritte hat einen Stapel von drei Knoten.

Bei den ersten beiden Lösungen liest der obere Knoten die Eingabe, sendet die ursprüngliche Zahl weiter und subtrahiert dann wiederholt 4, bis wir negativ werden, und addiert dann 5 zum Index für unsere Sprungtabelle. Dies ist äquivalent zu(n % 4) + 1 .

Die dritte Lösung hat diese Aufgabe auf zwei Knoten aufgeteilt. Die oberste wiederholt nur das Limit bis zum Ende der Zeit, und der mittlere Knoten zählt parallel den Index (verglichen mit diesem Limit) und das Modulo wie oben.

Der untere Knoten aller drei Lösungen ist derselbe. Es hat einen Sprungtisch, und hier geschieht die Magie. Wir speichern die Zahl wieder in ACC, dann JRO(wahrscheinlich J ump R Elativ O ffset) nach vorne durch 1, 2, 3, oder4 , je nachdem , was der Knoten oben sagt.

Rückwärts arbeiten:

4wird a ) NEGaßen ACCund b ) ACCfür die Ausgabe nach unten bewegen .
3gesetzt wird , 1in ACC, führt dann die Schritte 4a und 4b .
2springt direkt zu Schritt 4b .
1wird SUBTrakt ACCaus selbst (effektiv Nullstellung ACC), dann Schritt tun 2, was springt 4b .

Phlarx
quelle

2

C (gcc) , 62 Bytes

f(n,k){k=~-n;n=n?n%4?k%4?n-2&3?f(k)*n:f(k)-n:f(k)+n:f(k)/n:0;}

Probieren Sie es online!

Jonathan Frech
quelle

Sie könnten Ihre Byteanzahl (31 Bytes) genau halbieren, indem Sie einen Port von OlivierGrégoires Java-Antwort erstellen : f(n){n=n%2>0?n*(2-n%4):n%4/-2;}Ich würde es jedoch als zweite Antwort hinzufügen, da ich auch Ihren rekursiven Ansatz mag. :)

Kevin Cruijssen

@KevinCruijssen Ich habe ihre Java 10-Lösung gesehen und ihre Kürze bemerkt, obwohl ich ihre Lösung nicht einfach kopieren wollte, da die arithmetischen Syntaxen der beiden Sprachen zu ähnlich sind.

Jonathan Frech

1

Gelee , 8 Bytes

,-;N;0⁸ị

Probieren Sie es online!

-1 danke an Lynn .

Was andere tun (Port von Arnauld's Lösung), unterstützt 0.

Gelee , 17 Bytes

A:A}××Ṡ¥
R_×ç+4ƭ/

Probieren Sie es online!

0 wird nicht unterstützt.

Erik der Outgolfer
quelle

1

Java (JDK 10) , 25 Byte

n->n%2>0?n*(2-n%4):n%4/-2

Probieren Sie es online!

Kürzer als der Konkurrentenalgorithmus in anderen Sprachen mit 28 Bytes

n->new int[]{0,n,-1,-n}[n%4]

Probieren Sie es online!

Olivier Grégoire
quelle

1

Netzhaut , 46 Bytes

.+
*
r`(____)*$
_$.=
____
-
___.*
-1
__

_.*
0

Probieren Sie es online! Erläuterung:

.+
*

In Unary konvertieren.

r`(____)*$
_$.=

Zurück in Dezimalzahl konvertieren, aber n%4+1Unterstreichungen lassen.

____
-

In dem Fall, dass das 4 ist, ist das Ergebnis -n.

___.*
-1

Fall 3: -1

__

Fall 2: n

_.*
0

Fall 1: 0

Neil
quelle

1

Haskell , 50 Bytes

f 0=0
f n=([(+),(-),(*),quot]!!mod(n-1)4)(f(n-1))n

Probieren Sie es online!

Arnauld's Lösung, portiert nach Haskell, ist 23 Bytes:

z n=cycle[0,n,-1,-n]!!n

Angs
quelle

1

APL (Dyalog Classic) , 22 12 Bytes

Durch die Äußerungen von Erik the Outgolfer wurden enorme 10 Byte eingespart. Vielen Dank!

4∘|⊃0,⊢,¯1,-

Probieren Sie es online!

Gibt die n-te Zahl aus

Ich kenne APL nicht, ich habe nur versucht, meinen J-Port von Arnauld's Lösung in Dyalog APL zum Laufen zu bringen.

Galen Ivanov
quelle

2

Netter Versuch! Einige Bemerkungen: 1) Sie können ersetzen (0,⍵,¯1,-⍵)mit (0⍵¯1,-⍵). 2) Sie können das entfernen, 1+indem Sie annehmen, dass die ⎕IOSystemvariable zugewiesen ist 0(ja, das ist erlaubt). 3) Wir zählen das f←Teil normalerweise nicht, wenn wir Funktionen einreichen. 4) Sie können die ⊃Funktion anstelle der []Indizierung verwenden. Alle zusammen ergeben folgendes: ⎕IO←0(nicht mitzählen){(4|⍵)⊃0⍵¯1,-⍵}

Erik the Outgolfer

@Erik der Outgolfer Danke!

Galen Ivanov

2

Fortgeschrittenere Golf auf der Grundlage dieses Ansatzes: 4∘|⊃0,⊢,¯1,-.

Erik der Outgolfer

1

@Erik der Outgolfer - Ja, in der Tat! Ich denke, Sie sehen 4∘|⊃0,⊢,¯1,- genau so aus, wie meine J-Lösung 4&|{0,],_1,-in APL aussehen würde. Danke noch einmal!

Galen Ivanov

1

Tatsächlich ist J eine APL-Variante, obwohl sie weiter entfernt ist als andere APL-ähnliche Varianten wie Dyalog und NARS2000.

Erik der Outgolfer

1

Cubix , 20 bis 19 Bytes

Iun:^>s1ns:u@Ota3s0

Probieren Sie es online!

Portiert den gleichen Ansatz zu Cubix.

Auf einem Würfel:

    I u
    n :
^ > s 1 n s : u
@ O t a 3 s 0 .
    . .
    . .

Das erste Bit erstellt ^Iu:n>s1ns:u0sden Stapel und 3atkopiert dann das entsprechende Element nach TOS. Anschließend wird das Programm Oausgegeben und @beendet.

Giuseppe
quelle

0

Leerzeichen, 84 83 Bytes

[S S S N
_Push_0][S N
S _Duplicate_0][T   T   S _Store][S S S T   S N
_Push_2][S S T  T   N
_Push_-1][T T   S _Store][S S S T   N
_Push_1][S N
S _Duplicate_1][T   N
T   T   _Read_STDIN_as_integer][S S S T T   N
_Push_3][S S S T    N
_Push_1][T  T   T   ][S S T T   N
_Push_-1][T S S N
_Multiply][T    T   S _Store][T T   T   _Retrieve_input][S S S T    S S N
_Push_4][T  S T T   _Modulo][T  T   T   _Retrieve_result][T N
S T _Print_as_integer]

Buchstaben S(Leerzeichen), T(Tabulator) und (Zeilenvorschub) werden Nnur als Hervorhebungen hinzugefügt.
[..._some_action]nur als Erklärung hinzugefügt.

Probieren Sie es online aus (nur mit Leerzeichen, Tabulatoren und Zeilenumbrüchen).

Port von @Arnauld 's JavaScript Antwort .

Erklärung (Beispieleingabe n=7):

Command   Explanation         Stack        Heap                  STDIN   STDOUT   STDERR

SSSN      Push 0              [0]
SNS       Duplicate top (0)   [0,0]
TTS       Store               []           {0:0}
SSSTSN    Push 2              [2]          {0:0}
SSTTN     Push -1             [2,-1]       {0:0}
TTS       Store               []           {0:0,2:-1}
SSSTN     Push 1              [1]          {0:0,2:-1}
SNS       Duplicate top (1)   [1,1]        {0:0,2:-1}
TNTT      Read STDIN as nr    [1]          {0:0,1:7,2:-1}        7
SSSTTN    Push 3              [1,3]        {0:0,1:7,2:-1}
SSSTN     Push 1              [1,3,1]      {0:0,1:7,2:-1}
TTT       Retrieve input      [1,3,7]      {0:0,1:7,2:-1}
SSTTN     Push -1             [1,3,7,-1]   {0:0,1:7,2:-1}
TSSN      Multiply (-1*7)     [1,3,-7]     {0:0,1:7,2:-1}
TTS       Store               [1]          {0:0,1:7,2:-1,3:-7}
TTT       Retrieve input      [7]          {0:0,1:7,2:-1,3:-7}
SSSTSSN   Push 4              [7,4]        {0:0,1:7,2:-1,3:-7}
TSST      Modulo (7%4)        [3]          {0:0,1:7,2:-1,3:-7}
TTT       Retrieve            [-7]         {0:0,1:7,2:-1,3:-7}
TNST      Print as integer    []           {0:0,1:7,2:-1,3:-7}           -7
                                                                                  error

Stopps mit Fehler: Exit nicht definiert.

Kevin Cruijssen
quelle

Arithmetischer Zyklus

Eingang:

Ausgabe:

Reihenfolge:

Herausforderungsregeln:

Allgemeine Regeln:

Zusätzliche Testfälle oben `n=100`:

Antworten:

JavaScript (ES6), 19 Byte

Beweis

05AB1E , 8 Bytes

05AB1E , 14 Bytes

Python 2 , 25 Bytes

Python 3 , 50 49 Bytes

Python 2 , 78 77 76 58 57 53 52 Bytes

J , 12 Bytes

J , 28 Bytes

TIS `-n` `2` `1` , 123 Bytes

TIS `-n` `2` `1` , 124 Bytes

TIS `-n` `3` `1` , 192 Bytes

C (gcc) , 62 Bytes

Gelee , 8 Bytes

Gelee , 17 Bytes

Java (JDK 10) , 25 Byte

Netzhaut , 46 Bytes

Haskell , 50 Bytes

APL (Dyalog Classic) , 22 12 Bytes

Cubix , 20 bis 19 Bytes

Leerzeichen, 84 83 Bytes

Arithmetischer Zyklus

Eingang:

Ausgabe:

Reihenfolge:

Herausforderungsregeln:

Allgemeine Regeln:

Zusätzliche Testfälle oben n=100:

Antworten:

JavaScript (ES6), 19 Byte

Beweis

05AB1E , 8 Bytes

05AB1E , 14 Bytes

Python 2 , 25 Bytes

Python 3 , 50 49 Bytes

Python 2 , 78 77 76 58 57 53 52 Bytes

J , 12 Bytes

J , 28 Bytes

TIS -n 2 1 , 123 Bytes

TIS -n 2 1 , 124 Bytes

TIS -n 3 1 , 192 Bytes

C (gcc) , 62 Bytes

Gelee , 8 Bytes

Gelee , 17 Bytes

Java (JDK 10) , 25 Byte

Netzhaut , 46 Bytes

Haskell , 50 Bytes

APL (Dyalog Classic) , 22 12 Bytes

Cubix , 20 bis 19 Bytes

Leerzeichen, 84 83 Bytes

Zusätzliche Testfälle oben `n=100`:

TIS `-n` `2` `1` , 123 Bytes

TIS `-n` `2` `1` , 124 Bytes

TIS `-n` `3` `1` , 192 Bytes