Ciclo Aritmético

13

Entrada:

Inteiro nque é >=0ou >=1( f(0)é opcional)

Resultado:

O n'th número na sequência abaixo, OU a sequência até e incluindo o n' th number.

Seqüência:

(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

Como é construída essa sequência?

f(n=0) = 0(opcional)
f(n=1) = f(0) + nou 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.

Ou no pseudo-código:

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
}

Mas como você deve ter notado, existem dois padrões na sequência:

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

portanto, quaisquer outras abordagens que resultem na mesma sequência também são completamente boas.

Regras do desafio:

  • Entradas indexadas a 0 e indexadas a 1 resultarão no mesmo resultado (é por isso que f(0)é opcional para entradas indexadas em 0 se você deseja incluí-las).
  • Você tem permissão para emitir o n'número th desta sequência. Ou a sequência inteira acima e incluindo o n'número th. (Portanto, f(5)pode resultar em um 5ou 0,1,-1,-3,0,5.)
    • Se você optar por imprimir a sequência até o nnúmero número um, o formato de saída será flexível. Pode ser uma lista / matriz, sequência delimitada por vírgula / espaço / nova linha ou ser impressa em STDOUT, etc.
  • A divisão ( /) é a divisão inteiro / piso, que arredonda para 0 (não para o infinito negativo, como é o caso em alguns idiomas).

Regras gerais:

  • Isso é código-golfe , então a resposta mais curta em bytes vence.
    Não permita que idiomas com código de golfe o desencorajem a postar respostas com idiomas que não sejam codegolf. Tente encontrar uma resposta o mais curta possível para 'qualquer' linguagem de programação.
  • As regras padrão se aplicam à sua resposta, para que você possa usar STDIN / STDOUT, funções / método com os parâmetros adequados e programas completos do tipo retorno. Sua chamada.
  • As brechas padrão são proibidas.
  • Se possível, adicione um link com um teste para o seu código.
  • Além disso, adicione uma explicação, se necessário.

Casos de teste adicionais acima n=100:

Input     Output

1000      0
100000    0
123       -123
1234      -1
12345     12345
123456    0
code-golf number sequence arithmetic integer Kevin Cruijssen
fonte
1
Não foi possível encontrar isso no oeis.org, então você pode enviá-lo para lá. É uma sequência interessante, estou surpreso que ninguém a tenha registrado.
pipe
1
@pipe parece arbitrária bastante
QWR

Respostas:

20

JavaScript (ES6), 19 bytes

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

Experimente online!

Prova

Vamos supor que temos as seguintes relações para alguns n múltiplos de 4. Essas relações são trivialmente verificadas para os primeiros termos da sequência.

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

E deixe N = n + 4 . Então, por definição:

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)

O que, por indução matemática, prova que as relações são válidas para qualquer N múltiplo de 4 .

Arnauld
fonte
2
Como a maioria das respostas são portas desta solução, quero acrescentar que verifiquei que é comprovável.
Erik the Outgolfer
Eu tenho uma prova alternativa.
Erik the Outgolfer
Ah, maluco, se distraiu com o trabalho enquanto trabalhava em algo muito semelhante. 1
Shaggy:
Por curiosidade, existe um motivo para preferir "n & 3" a "n% 4"?
IanF1
2
@ IanF1 Acho que esse é apenas um hábito de programação de baixo nível (computar um E bit a bit na montagem é mais fácil e rápido do que calcular um módulo). Mas não faz muito sentido aqui e fiquei realmente meio tentado a alterá-lo para n%4depois, para que funcione com números maiores que 32 bits.
Arnauld
4

05AB1E , 8 bytes

Mostra o nthnúmero

ÎD(®s)sè

Experimente online!

05AB1E , 14 bytes

Produz uma lista de números até N usando os padrões na sequência

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

Experimente online!

Explicação

Exemplo 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]
Emigna
fonte
4

Python 2 , 25 bytes

Resposta de Port of Arnauld:

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

Experimente online!

Soluções ingênuas:

Python 3 , 50 49 bytes

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

Experimente online!

Python 2 , 78 77 76 58 57 53 52 bytes

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

Experimente online!

Utilizou um monte de bytes int, porque o piso python se divide, e não em direção a 0, como na pergunta.

TFeld
fonte
@KevinCruijssen Sim, obrigado :)
TFeld
3

J , 12 bytes

Resposta de Port of Arnauld:

4&|{0,],_1,-

Experimente online!

J , 28 bytes

Solução ingênua:

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

Emite o enésimo número

Experimente online!

Galen Ivanov
fonte
3

TIS -n 2 1 , 123 bytes

Emite o nnúmero th para 0 <= n <= 999. (O limite superior é devido a limitações de idioma).

@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

Experimente online!

TIS -n 2 1 , 124 bytes

Emite o nnúmero th para 0 <= n <= 999. (O limite superior é devido a limitações de idioma). Múltiplos npodem ser fornecidos, separados por espaços em branco.

@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

Experimente online!

TIS -n 3 1 , 192 bytes

Emite os valores para 0..npara 0 <= n <= 999. (O limite superior é devido a limitações de idioma).

@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

Experimente online!

Todos usam E / S numérica (o -nsinalizador). As duas primeiras soluções usam dois nós de computação, um posicionado acima do outro. O terceiro possui uma pilha de três nós.

Nas duas primeiras soluções, o nó superior lê a entrada, envia o número original e subtrai repetidamente 4 até ficarmos negativos, depois adiciona 5 ao índice da nossa tabela de salto. Isso é equivalente a (n % 4) + 1.

A terceira solução dividiu essa tarefa em dois nós; o primeiro repete o limite até o final dos tempos, e o nó do meio conta em paralelo o índice (comparado com esse limite) e o módulo como acima.

O nó inferior das três soluções é o mesmo; tem uma mesa de salto, e é aí que a mágica acontece. Nós armazenamos o número original ACC, em seguida, JRO(provavelmente J UMP R elative O ffset) para a frente por 1, 2, 3ou 4, dependendo do que o nó acima diz.

Trabalhando para trás:

  • 4vai a ) NEGcomeu ACC, e b ) se mover ACCpara baixo para a saída.
  • 3vai colocar 1em ACC, em seguida, execute os passos 4a e 4b .
  • 2pulará diretamente para o passo 4b .
  • 1 vai SUB trato ACCoff em si (efetivamente zeroing ACC), em seguida, fazer o passo 2, que salta para 4b .
Phlarx
fonte
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;}

Experimente online!

Jonathan Frech
fonte
Você pode reduzir pela metade a contagem de bytes (31 bytes) criando uma porta da resposta Java do OlivierGrégoire : f(n){n=n%2>0?n*(2-n%4):n%4/-2;}eu a adicionaria como segunda resposta, porque também gosto da sua abordagem recursiva. :)
Kevin Cruijssen
@KevinCruijssen Eu vi a solução Java 10 e notei sua brevidade, embora não quisesse simplesmente copiar a solução, pois as sintaxes aritméticas das duas linguagens são muito semelhantes.
Jonathan Frech
1

Retina , 46 bytes

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

_.*
0

Experimente online! Explicação:

.+
*

Converta para unário.

r`(____)*$
_$.=

Converta de volta para decimal, mas deixe n%4+1sublinhados.

____
-

No caso de 4, o resultado é -n.

___.*
-1

Caso 3: -1

__

Caso 2: n

_.*
0

Caso 1: 0

Neil
fonte
1

Haskell , 50 bytes

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

Experimente online!

A solução de Arnauld, portada para Haskell, tem 23 bytes:

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

APL (Dyalog Classic) , 22 12 bytes

10 bytes maciços salvos devido às observações de Erik the Outgolfer. Obrigado!

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

Experimente online!

Emite o enésimo número

Não conheço o APL, apenas tentei fazer com que minha porta J da solução de Arnauld funcionasse no Dyalog APL.

Galen Ivanov
fonte
2
Boa tentativa! Algumas observações: 1) Você pode substituir (0,⍵,¯1,-⍵)por (0⍵¯1,-⍵). 2) Você pode remover o 1+assumindo que a ⎕IOvariável do sistema está atribuída 0(sim, isso é permitido). 3) Normalmente, não contamos a f←parte ao enviar funções. 4) Você pode usar a ⊃função em vez de []indexar. Todos aqueles juntos formam o seguinte: ⎕IO←0(não conte isso){(4|⍵)⊃0⍵¯1,-⍵}
Erik o Outgolfer
@Erik the Outgolfer Obrigado!
Galen Ivanov
2
Mais de golfe avançado com base nesta abordagem: 4∘|⊃0,⊢,¯1,-.
Erik the Outgolfer
1
@Erik the Outgolfer - Sim, de fato! Eu acho que você 4∘|⊃0,⊢,¯1,- é exatamente o que minha solução J 4&|{0,],_1,-seria no APL. Obrigado novamente!
Galen Ivanov
1
Na verdade, J é uma variante de APL, embora mais distante do que outras mais semelhantes a APL, como Dyalog e NARS2000.
Erik the Outgolfer
1

Cubix , 20 19 bytes

Iun:^>s1ns:u@Ota3s0

Experimente online!

Portos a mesma abordagem para cubix.

Em um cubo:

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

O primeiro bit ^Iu:n>s1ns:u0scria a pilha e, em seguida, 3atcopia o item apropriado para o TOS, Oemite e @termina o programa.

Giuseppe
fonte
0

Espaço em branco, 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]

Letras S(espaço), T(guia) e N(nova linha) adicionadas apenas como destaque.
[..._some_action]adicionado apenas como explicação.

Experimente online (apenas com espaços brutos, guias e novas linhas).

Porto da resposta JavaScript de @Arnauld .

Explicação (exemplo de entrada 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

Para com erro: Saída não definida.

Kevin Cruijssen
fonte