O gráfico da operação do módulo ( $y = x \mod k$ ) fica assim:

Essa é uma função muito útil, pois permite criar um comportamento de "quebra automática". No entanto, é muito complicado quando eu quero usá-lo para criar uma aparência de "saltar" entre duas paredes. O gráfico da função "rejeição" ( $y = \text{bounce} (x, k)$ ) tem a seguinte aparência:

O período do gráfico de é . O período do gráfico de é , porque se move para cima por unidades e depois se move para baixo por outras unidades, antes de retornar ao local onde foi iniciado. Para ambas as funções, o valor mínimo para é 0 e o máximo é (na verdade, para a função de módulo com entradas integrais, é ). Além disso, para ambas as funções, o valor em que é 0.k y = ressalto ( x , k ) 2 k k k y k k - 1 x = $y = x \mod k$$k$$y = \text{bounce} (x, k)$$2k$$k$$k$$y$$k$$k-1$$x=0$

O desafio

Dado um número inteiro e um número inteiro positivo , retorne uma aproximação de número inteiro ou de ponto flutuante de .k y = salto ( x , k $x$$k$$y = \text{bounce} (x, k)$

Isso é código-golfe , portanto, o menor envio válido (contado em bytes) vence.

Casos de teste

  x,  k -> bounce(x, k)
  0, 14 ->            0
  3,  7 ->            3
 14, 14 ->           14
 15, 14 ->           13
-13, 14 ->           13 (12.999997 etc would be an acceptable answer)
-14, 14 ->           14
191,  8 ->            1
192,  8 ->            0

Os pontos de bónus para um Fourier baseados abordagem em Fourier .

Código da máquina x86-64, 18 bytes

97
99
31 D0
29 D0
99
F7 FE
29 D6
A8 01
0F 45 D6
92
C3 

Este código define uma função na linguagem de máquina x86-64 que calcula bounce(x, k). Após a convenção de chamada System64 AMD64 usada nos sistemas Gnu / Unix, o xparâmetro é passado no EDIregistro, enquanto o kparâmetro é passado no ESIregistro. Como em todas as convenções de chamada x86, o resultado é retornado no EAXregistro.

Para chamar isso de C, você deve fazer o protótipo da seguinte maneira:

int Bounce(int x, int k);

Experimente online!

Mnemônicos de montagem não destruídos:

; Take absolute value of input 'x' (passed in EDI register).
; (Compensates for the fact that IDIV on x86 returns a remainder with the dividend's sign,
; whereas we want 'modulo' behavior---the result should be positive.)
xchg   eax, edi      ; swap EDI and EAX (put 'x' in EAX)
cdq                  ; sign-extend EAX to EDX:EAX, effectively putting sign bit in EDX
xor    eax, edx      ; EAX ^= EDX
sub    eax, edx      ; EAX -= EDX

; Divide EDX:EAX by 'k' (passed in ESI register).
; The quotient will be in EAX, and the remainder will be in EDX.
; (We know that EAX is positive here, so we'd normally just zero EDX before division,
; but XOR is 2 bytes whereas CDQ is 1 byte, so it wins out.)
cdq
idiv   esi

; Pre-emptively subtract the remainder (EDX) from 'k' (ESI),
; leaving result in ESI. We'll either use this below, or ignore it.
sub    esi, edx

; Test the LSB of the quotient to see if it is an even number (i.e., divisible by 2).
; If not (quotient is odd), then we want to use ESI, so put it in EDX.
; Otherwise (quotient is even), leave EDX alone.
test   al, 1
cmovnz edx, esi

; Finally, swap EDX and EAX to get the return value in EAX.
xchg   eax, edx
ret

Observe que a primeira seção (que leva o valor absoluto) poderia ter sido escrita de forma equivalente:

; Alternative implementation of absolute value
xchg    eax, edi
neg     eax
cmovl   eax, edi

que é exatamente o mesmo número de bytes (6). O desempenho deve ser semelhante, talvez um pouco mais rápido (exceto em determinados chips da Intel, onde os movimentos condicionais são lentos ).

XCHGé, é claro, relativamente lento e não seria preferido, MOVexceto no código de golfe (que o primeiro tem 1 byte quando um dos operandos é o acumulador, enquanto um registrador MOVé sempre de 2 bytes).

Geléia , 3 bytes

æ%A

Experimente online!

Ftw interno.

Explicação

æ%é um útil embutido aqui. Não sei como descrevê-lo, então fornecerei a saída para algumas entradas:

Como xvai do 0infinito, xæ%4vai para 0,1,2,3,4,(-3,-2,-1,0,1,2,3,4,)onde a parte entre parênteses é repetida até o infinito nos dois sentidos.

Python 2 , 29 27 bytes

lambda x,k:abs(x%k-x/k%2*k)

Experimente online!

Python 3 , 27 bytes

lambda x,k:k-abs(k-x%(k*2))

Experimente online!

Ruby, 40 bytes 32 bytes

b=->(x,k){(x/k+1)%2>0?x%k:k-x%k}

Experimente online!

Explicação

Olá, esta é a minha primeira resposta neste site! Esse código é baseado na observação de que a função de rejeição se comporta exatamente como o módulo quando ( n -1) k <= x < nk e n é ímpar e se comporta como uma operação de módulo invertido quando n é par. (x/k+1)é o menor número inteiro maior que x / k (que é x / k +1 arredondado para um número inteiro). Portanto, (x/k+1)encontra o n mencionado acima. %2>0verifica se n é ímpar ou par. Se n mod 2> 0, então n é ímpar. Se nmod 2 = 0, então n é par. Se n for ímpar, a função de rejeição deve ser igual a x mod k . Se n for par, a função de rejeição deve ser o inverso, igual a k - x mod k . A expressão inteira (x/k+1)%2>0?x%k:k-x%kencontra n , depois executa x mod k, se for ímpar, e executa k - x mod k, caso contrário.

A resposta foi aprimorada com base em uma sugestão da Cyoce .

Mathematica, 19 bytes

Abs@Mod[#,2#2,-#2]&

Pitão , 5 bytes

aa%Ey

Verifique todos os casos de teste.

Garfo da minha resposta Python .

J, 25 bytes

Dica:

Este é apenas um módulo regular nos números da escada. Por exemplo, no caso de 5:0 1 2 3 4 5 4 3 2 1

Aqui está uma solução (ainda não bem-desenvolvida) em J. Tentará melhorar amanhã:

[ ((|~ #) { ]) (i.@>:,}:@i.@-) @ ]

comprimido: [((|~#){])(i.@>:,}:@i.@-)@]

compressed2: [((|~#){])(<:|.|@}.@i:)@]

Experimente online!

QBIC , 25 30 27 bytes

g=abs(:%:)~a'\`b%2|?b-g\?g

Fiz um pouco de reestruturação ...

Explicação

g=abs(   )  let g be the absolute value of 
       %    the (regular) modulo between
      : :   input a read from cmd line, and input b read from cmd line
~a \ b%2    IF the int division of A and B mod 2 (ie parity test) yields ODD
  ' `         (int divisions need to be passed to QBasic as code literals, or ELSE...)
|?b-g       THEN print bouncy mod
\?g         ELSE print regular mod

C89, 40 bytes

t;f(x,k){t=abs(x%k);return x/k%2?k-t:t;}

A porta CA da resposta do meu código de máquina x86 define uma função fque calcula o módulo de rejeição para os parâmetros xe k.

Ele usa a regra implit-int do C89, para que ambos os parâmetros, a variável global te o valor de retorno da função sejam implicitamente do tipo int. A variável global té usada apenas para armazenar um valor temporário, que acaba salvando bytes, em comparação com a repetição da computação nos dois lados do operador condicional.

A absfunção (valor absoluto) é fornecida no <stdlib.h>cabeçalho, mas não precisamos incluí-la aqui, novamente graças à regra implit-int do C89 (onde a função é implicitamente declarada e supõe-se que retorne int).

Experimente online!

Versão não destruída:

#include <stdlib.h>

int Bounce(int x, int k)
{
    int mod = abs(x % k);
    return (x/k % 2) ? k-mod : mod;
}

Olhando isso à luz do meu código de máquina ajustado à mão , os compiladores realmente geram uma saída muito boa para isso. Quero dizer, eles deveriam; é uma função bastante simples de otimizar! No entanto, eu descobri um pequeno bug no otimizador x86-64 do GCC , onde, curiosamente, produz código maior quando você pede para otimizar o tamanho e código menor quando você pede para otimizar a velocidade .

Haskell, 37 bytes

Experimente online!

(!)=mod;x#k|odd$x`div`k=k-x!k|1<2=x!k

Como usar:
Ligue 15#14para argumentos à esquerda não negativos e (-13)#14para argumentos à esquerda negativos, porque Haskell interpretaria -13#14como -(13#14)se você estivesse usando algo parecido ghci. O link TIO simplesmente aceita dois argumentos de linha de comando.

Explicação:
Primeiro redefine o operador de infixo binário !para ser o mesmo que mod. A Haskell modsempre gera um valor não negativo, portanto não precisamos das absoutras soluções aqui. Em seguida, verifica se x/k(divisão inteira) é ímpar e, em caso afirmativo, retorna k-x mod k(ou seja, o retorno) ou então retorna x mod k.

PHP, 40 50 bytes

malditos dólares. maldita sobrecarga de importação. :)

versão inteira:

[,$x,$k]=$argv;$y=abs($x)%$k;echo$x/$k&1?$k-$y:$y;

ou

[,$x,$k]=$argv;echo[$y=abs($x)%$k,$k-$y][$x/$k&1];

versão flutuante, 56 bytes:

Substitua abs($x)%$kpor fmod(abs($x),$k).

editar: resultados fixos para negativos x

JavaScript (ES6), 36 32 bytes

k=>f=x=>x<0?f(-x):x>k?k-f(k-x):x

Bate xcontra recursivamente 0e k, muito no espírito do desafio.

Lisp comum, 41 bytes

(lambda(x k)(- k(abs(-(mod x(* k 2))k))))

Experimente online!

C (gcc), 43 53 bytes

Editar: problema negativo corrigido

int f(int x,int y){return x/y%2?abs(y-x%y):abs(x%y);}

Experimente Online!

R, 28 bytes

pryr::f(abs((x-k)%%(2*k)-k))

Que avalia a função:

function (k, x) 
abs((x - k)%%(2 * k) - k)

Qual parece ser o método usado pela maioria das soluções. Eu não olhei para eles antes de fazer isso.