Modulo işleminin grafiği ( ) şöyle görünür:$y = x \mod k$

"Sarma" davranışı yaratmamıza izin verdiği için bu çok kullanışlı bir işlevdir. Ancak, iki duvar arasında "zıplayan" bir görünüm oluşturmak için kullanmak istediğim zaman çok hantal. "Sıçrama" fonksiyonunun grafiği ( $y = \text{bounce} (x, k)$ ) şöyle görünür:

Süresi grafiğinin isimli . Grafiğinin süresi bir bunun için yukarı doğru hareket eder, çünkü, birimi ve daha sonra başka bir aşağı doğru hareket eder başladığı yere geri dönmeden önce, birim. Her iki işlev için de için minimum değer 0 ve maksimum değer (Aslında, tümleşik girişli modül işlevi için ). Ayrıca, her iki işlev için değerinin olduğu değer .$y = x \mod k$$k$$y = \text{bounce} (x, k)$$2k$$k$$k$$y$$k$$k-1$$x=0$

Meydan okuma

tamsayısı ve pozitif tamsayısı verildiğinde , tamsayısı veya kayan nokta yaklaşımı .k y = hemen çıkma ( x , k $x$$k$$y = \text{bounce} (x, k)$

Bu kod golf , bu nedenle (bayt cinsinden sayılan) en kısa geçerli gönderim kazanır.

Test Durumları

  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

Bir bonus puan Fourier yaklaşımı tabanlı Fourier .

x86-64 Makine Kodu, 18 bayt

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

Bu kod, x86-64 makine dilinde hesaplanan bir işlevi tanımlar bounce(x, k). Gnu / Unix sistemlerinde kullanılan System V AMD64 çağrı kuralını takiben xparametre EDIkayıt defterine kgeçirilirken parametre ESIkayıt defterine geçirilir . Tüm x86 çağrı kurallarında olduğu gibi, sonuç EAXkayıt defterine döndürülür .

Bunu C'den çağırmak için, prototipini şu şekilde prototiplersiniz:

int Bounce(int x, int k);

Çevrimiçi deneyin!

Ungolfed montaj anımsatıcıları:

; 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

İlk bölümün (mutlak değeri alan) eşzamanlı olarak yazılabileceğini unutmayın:

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

aynı bayt sayısıdır (6). Performans benzer olmalı, belki biraz daha hızlı olmalıdır ( koşullu hareketlerin yavaş olduğu bazı Intel yongaları hariç ).

XCHGtabii ki, nispeten yavaştır ve MOVkod golfü haricinde tercih edilmez (işlenenlerden biri akümülatör olduğunda birincisi 1 bayttır, oysa bir yazmaç-kayıt MOVher zaman 2 bayttır).

Jöle , 3 bayt

æ%A

Çevrimiçi deneyin!

Dahili ftw.

açıklama

æ%burada yararlı bir yerleşiktir. Nasıl tanımlayacağımı bilmiyorum, bu yüzden sadece bazı girdiler için çıktı sağlayacağım:

Gibi xgider 0sonsuza, xæ%4gider 0,1,2,3,4,(-3,-2,-1,0,1,2,3,4,)parantez içinde bölüm iki yönde sonsuza tekrarlanır nerede.

Python 2 , 29 27 bayt

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

Çevrimiçi deneyin!

Python 3 , 27 bayt

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

Çevrimiçi deneyin!

Yakut, 40 bayt 32 bayt

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

Çevrimiçi deneyin!

açıklama

Merhaba, bu sitedeki ilk cevabım! Bu kod, gözleme dayalı olduğu dönen fonksiyonu davranır tam modülo gibi zaman ( n -1) k <= x < nk ve n garip ve bir ters modülo işlemi gibi davranır , n ve eşitlenir. (x/k+1)daha küçük tam sayı olduğu X / k (ki x / k bir tamsayı +1 yuvarlak aşağı). Bu nedenle, yukarıda belirtilen n'yi(x/k+1) bulur . n'nin tek mi yoksa çift mi olduğunu kontrol eder . Eğer n 2> 0 mod, daha sonra n garip. Eğer n%2>0mod 2 = 0, o zaman n eşittir. Eğer n garip, daha sonra sıçrama fonksiyonu eşit olmalıdır x mod k . Eğer n bile olduğunu, sıçrama fonksiyonu ters olmalıdır için eşit k - x mod k . Tüm ifade n'yi(x/k+1)%2>0?x%k:k-x%k bulur , sonra tekse x mod k yürütür ve aksi takdirde k - x mod k yürütür .

Cevap, Cyoce'un bir önerisine dayanarak geliştirildi .

Mathematica, 19 bayt

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

Pyth , 5 bayt

aa%Ey

Tüm test vakalarını doğrulayın.

Python cevabımın çatalı .

J, 25 bayt

İpucu:

Bu, merdiven sayıları üzerindeki düzenli modülondur. Örneğin, 5 durumunda:0 1 2 3 4 5 4 3 2 1

İşte J'de (henüz iyi golf oynamamış) bir çözüm: Yarın gelişmeye çalışacağız:

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

sıkıştırılmış: [((|~#){])(i.@>:,}:@i.@-)@]

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

Çevrimiçi deneyin!

QBIC , 25 30 27 bayt

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

Biraz yeniden yapılanma yaptım ...

açıklama

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 bayt

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

Benim x86 makine kodu yanıtının AC bağlantı noktası , bu fparametreler için bounce-modulo xvek .

C89'un örtük-int kuralını kullanır, böylece her iki parametrenin, global değişkenin tve işlevin dönüş değerinin tümü örtük olarak türdedir int. Global değişkent , koşullu operatörün her iki tarafında hesaplamanın tekrarlanmasına kıyasla, bayt tasarrufu sağlayan geçici bir değeri tutmak için kullanılır.

absFonksiyonu (mutlak değer) sağlanan <stdlib.h>başlığında, ama biz burada tekrar, (işlev dolaylı ilan ve karşılığında kabul edilir C89 örtülü-int kural sayesinde dahil gerekmez int).

Çevrimiçi deneyin!

Ungolfed sürümü:

#include <stdlib.h>

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

Buna elle ayarlanmış makine kodum ışığında bakıldığında , derleyiciler aslında bunun için oldukça iyi bir çıktı üretir . Yani, yapmalılar; optimize etmek oldukça basit bir işlev! GCC'nin x86-64 optimizer'ında küçük bir hatayı ortaya çıkardım , burada , hız için optimize etmenizi söylediğinizde merakla daha büyük kod üretiyor ve hız için optimize etmenizi söylediğinizde daha küçük kod üretiyordum .

Haskell, 37 Bayt

Çevrimiçi deneyin!

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

: Nasıl kullanılır
olarak Çağrı 15#14negatif olmayan sol argümanlar için ve aynı (-13)#14Haskell yorumlamak çünkü negatif için, argümanlar sol -13#14olarak -(13#14)gibi bir şey kullanıyorsanız ghci. TIO bağlantısı iki komut satırı argümanı alır.

Açıklama:
İlk olarak ikili infix işlecini !ile aynı olacak şekilde yeniden tanımlar mod. Haskell'in modher zaman negatif olmayan bir değer üretir, bu nedenle absburadaki diğer çözümlerin yapmasına gerek yoktur. Daha sonra x/k(tamsayı bölümünün) tek olup olmadığını kontrol eder ve eğer öyleyse, geri döner k-x mod k(yani geri sekme) veya geri döner x mod k.

PHP, 40 50 bayt

lanet olası dolar. lanet ithalat yükü. :)

tamsayı sürümü:

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

veya

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

kayan sürüm, 56 bayt:

Değiştir abs($x)%$kile fmod(abs($x),$k).

edit: negatif için sabit sonuçlar x

JavaScript (ES6), 36 32 bayt

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

Recursively sıçramalar xkarşı 0ve kbu nedenle çok zorluk ruhu içinde,.

Ortak Lisp, 41 bayt

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

Çevrimiçi deneyin!

C (gcc), 43 53 bayt

Düzenleme: Sabit negatif sorun

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

Çevrimiçi deneyin!

R, 28 bayt

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

Hangi işlevi değerlendirir:

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

Bu, çoğu çözümün kullandığı yöntem gibi görünüyor. Bunu yapmadan önce onlara bakmadım.