Ciclo aritmetico


13

Ingresso:

Numero intero nche è >=0o >=1( f(0)è facoltativo)

Produzione:

Il n'numero nella sequenza seguente, O la sequenza fino al nnumero compreso.

Sequenza:

(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

Come viene costruita questa sequenza?

f(n=0) = 0(facoltativo)
f(n=1) = f(0) + no 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
ecc.

O in pseudo-codice:

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
}

Ma come avrai notato, ci sono due schemi nella sequenza:

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

quindi qualsiasi altro approccio che porti alla stessa sequenza è ovviamente del tutto soddisfacente.

Regole della sfida:

  • Gli input indicizzati 0 e indicizzati 1 daranno lo stesso risultato (motivo per cui f(0)è facoltativo per gli input indicizzati 0 se si desidera includerlo).
  • È consentito emettere il n'numero numero di questa sequenza. O l'intera sequenza verso l'alto e includendo il n'th numero. (Quindi f(5)può risultare in uno 5o 0,1,-1,-3,0,5.)
    • Se si sceglie di generare la sequenza fino al nnumero compreso, il formato di output è flessibile. Può essere un elenco / matrice, virgola / spazio / stringa delimitata da nuova riga o stampata su STDOUT, ecc.
  • Il divide ( /) è la divisione intero / piano, che viene arrotondata verso 0 (non verso l'infinito negativo come in alcune lingue).

Regole generali:

  • Questo è , 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.
  • Si applicano le regole standardPer la tua risposta , quindi puoi usare STDIN / STDOUT, funzioni / metodo con i parametri corretti e tipo di ritorno, programmi completi. La tua chiamata.
  • Scappatoie predefinite sono vietate.
  • Se possibile, aggiungi un link con un test per il tuo codice.
  • Inoltre, si prega di aggiungere una spiegazione, se necessario.

Casi di prova aggiuntivi sopra n=100:

Input     Output

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

1
Non sono riuscito a trovarlo su oeis.org, quindi potresti voler inviarlo lì. È una sequenza interessante, sono sorpreso che nessuno l'abbia registrata.
pipe

1
@pipe sembra abbastanza arbitrario
qwr

Risposte:


20

JavaScript (ES6), 19 byte

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

Provalo online!

Prova

Supponiamo di avere le seguenti relazioni per alcuni n multipli di 4. Queste relazioni sono banalmente verificate per i primi termini della sequenza.

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

E lascia N = n + 4 . Quindi, per definizione:

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)

Che, per induzione matematica, dimostra che le relazioni valgono per qualsiasi N multiplo di 4 .


2
Poiché la maggior parte delle risposte sono porte di questa soluzione, voglio aggiungere che ho verificato che è provabile.
Erik the Outgolfer


Ah, pazzo, sono stato distratto dal lavoro mentre lavoravo su qualcosa di molto simile. +1
Shaggy,

Per curiosità, c'è un motivo per preferire "n & 3" piuttosto che "n% 4"?
IanF1

2
@ IanF1 Immagino che questa sia solo un'abitudine di programmazione di basso livello (calcolare un bit-bit AND in assembly è più facile e veloce rispetto al calcolo di un modulo). Ma non ha molto senso qui e in realtà ero quasi tentato di cambiarlo in n%4seguito in modo che funzioni con numeri superiori a 32 bit.
Arnauld,

4

05AB1E , 8 byte

Emette il nthnumero

ÎD(®s)sè

Provalo online!

05AB1E , 14 byte

Emette un elenco di numeri fino a N usando i motivi nella sequenza

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

Provalo online!

Spiegazione

Esempio usando 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]

4

Python 2 , 25 byte

La risposta di Port of Arnauld:

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

Provalo online!


Soluzioni ingenue:

Python 3 , 50 49 byte

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

Provalo online!


Python 2 , 78 77 76 58 57 53 52 byte

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

Provalo online!

Utilizzato un sacco di byte su int, perché il pavimento in pitone divide, e non verso 0, come nella domanda.


@KevinCruijssen Sì, grazie :)
TFeld


3

TIS -n 2 1 , 123 byte

Emette il nnumero th per 0 <= n <= 999. (Il limite superiore è dovuto alle limitazioni della lingua).

@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

Provalo online!


TIS -n 2 1 , 124 byte

Emette il nnumero th per 0 <= n <= 999. (Il limite superiore è dovuto alle limitazioni della lingua). nPossono essere forniti multipli , separati da spazi bianchi.

@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

Provalo online!


TIS -n 3 1 , 192 byte

Emette i valori 0..nper 0 <= n <= 999. (Il limite superiore è dovuto alle limitazioni della lingua).

@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

Provalo online!


Tutti usano I / O numerici (il -nflag). Le prime due soluzioni utilizzano due nodi di calcolo, uno posizionato sopra l'altro. Il terzo ha una pila di tre nodi.

Per le prime due soluzioni, il nodo superiore legge l'input, invia il numero originale, quindi sottrae ripetutamente 4 fino a quando non diventiamo negativi, quindi aggiunge 5 all'indice per la nostra tabella di salto. Questo equivale a (n % 4) + 1.

La terza soluzione ha diviso questo compito su due nodi; quello in alto ripete il limite fino alla fine dei tempi, e il nodo centrale conta in parallelo l'indice (rispetto a quel limite) e il modulo come sopra.

Il nodo inferiore di tutte e tre le soluzioni è lo stesso; ha un tavolo da salto, ed è qui che accade la magia. Noi registriamo il numero originale ACC, allora JRO(probabilmente J UMP R elative O ffset) in avanti per 1, 2, 3, o 4, a seconda di ciò che il nodo di cui sopra dice.

Lavorare all'indietro:

  • 4sarà un ) NEGate ACC, e b ) spostare ACCverso il basso per l'uscita.
  • 3metterà 1in ACC, quindi eseguire i passi 4un e 4b .
  • 2salterà direttamente al passaggio 4b .
  • 1sarà SUBtratto ACCfuori se stesso (in modo efficace azzeramento ACC), poi fare step 2, che salta al 4b .

2

C (gcc) , 62 byte

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;}

Provalo online!


È possibile dimezzare esattamente il conteggio dei byte (31 byte) creando una porta della risposta Java di OlivierGrégoire : f(n){n=n%2>0?n*(2-n%4):n%4/-2;}Vorrei aggiungerla come seconda risposta, perché mi piace anche il tuo approccio ricorsivo. :)
Kevin Cruijssen,

@KevinCruijssen Ho visto la loro soluzione Java 10 e ho notato la sua brevità, anche se non volevo semplicemente copiare la loro soluzione, poiché le sintassi aritmetiche dei due linguaggi sono troppo simili.
Jonathan Frech,



1

Retina , 46 byte

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

_.*
0

Provalo online! Spiegazione:

.+
*

Converti in unario.

r`(____)*$
_$.=

Converti in decimale, ma lascia il n%4+1segno di sottolineatura.

____
-

Nel caso in cui questo sia 4, il risultato è -n.

___.*
-1

Caso 3: -1

__

Caso 2: n

_.*
0

Caso 1: 0


1

Haskell , 50 byte

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

Provalo online!

La soluzione di Arnauld, trasferita su Haskell è di 23 byte:

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

1

APL (Dyalog Classic) , 22 12 byte

Enormi 10 byte salvati grazie alle osservazioni di Erik the Outgolfer. Grazie!

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

Provalo online!

Emette l'ennesimo numero

Non conosco APL, ho appena provato a far funzionare la mia porta J della soluzione di Arnauld in Dyalog APL.


2
Bel tentativo! Alcune osservazioni: 1) È possibile sostituire (0,⍵,¯1,-⍵)con (0⍵¯1,-⍵). 2) È possibile rimuovere 1+presupponendo che la ⎕IOvariabile di sistema sia assegnata a 0(sì, è consentito). 3) Di solito non contiamo la f←parte durante l'invio delle funzioni. 4) È possibile utilizzare la funzione anziché l' []indicizzazione. Tutti insieme formano questo: ⎕IO←0(non contare questo){(4|⍵)⊃0⍵¯1,-⍵}
Erik the Outgolfer

@Erik the Outgolfer Grazie!
Galen Ivanov,

2
Più golf avanzato basato su questo approccio: 4∘|⊃0,⊢,¯1,-.
Erik the Outgolfer

1
@Erik the Outgolfer - Sì, davvero! Penso che la tua 4∘|⊃0,⊢,¯1,- sia esattamente come 4&|{0,],_1,-sarebbe la mia soluzione J in APL. Grazie ancora!
Galen Ivanov,

1
In realtà, J è una variante APL, sebbene più distante di altre più simili a APL come Dyalog e NARS2000.
Erik the Outgolfer

1

Cubix , 20 19 byte

Iun:^>s1ns:u@Ota3s0

Provalo online!

Porta lo stesso approccio a cubix.

Su un cubo:

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

Il primo bit ^Iu:n>s1ns:u0screa lo stack e quindi 3atcopia l'elemento appropriato in TOS, quindi Ogenera e @termina il programma.


0

Spazio bianco, 84 83 byte

[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]

Lettere S(spazio), T(scheda) e N(nuova riga) aggiunti solo come evidenziazione.
[..._some_action]aggiunto solo come spiegazione.

Provalo online (solo con spazi non elaborati, schede e nuove righe).

Porta della risposta JavaScript di @Arnauld .

Spiegazione (input di esempio 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

Si interrompe con errore: uscita non definita.

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.