उछाल-मोडुलो दो संख्या

Question

मोडुलो ऑपरेशन ( $y = x \mod k$ ) का ग्राफ कुछ इस प्रकार है:

यह एक बहुत ही उपयोगी कार्य है, क्योंकि यह हमें "रैपिंग" व्यवहार बनाने की अनुमति देता है। हालांकि, यह बहुत बोझिल है जब मैं इसे दो दीवारों के बीच "उछल" की उपस्थिति बनाने के लिए उपयोग करना चाहता हूं। "बाउंस" फ़ंक्शन ( $y = \text{bounce} (x, k)$ ) का ग्राफ कुछ इस तरह दिखता है:

अवधि के ग्राफ के है । के ग्राफ की अवधि है , क्योंकि इसके लिए ऊपर की तरफ ले जाता है इकाइयों, और फिर एक और के लिए नीचे की ओर ले जाता है इकाइयों, जहां यह शुरू कर दिया पर लौटने से पहले। दोनों कार्यों के लिए, लिए न्यूनतम मान 0 है, और अधिकतम (वास्तव में, अभिन्न इनपुट के साथ मापांक फ़ंक्शन के लिए, यह )। इसके अलावा, दोनों कार्यों के लिए, मान जहाँ है।कश्मीर y = उछाल ( एक्स , कश्मीर ) 2 कश्मीर कश्मीर कश्मीर y कश्मीर कश्मीर - 1 एक्स = $y = x \mod k$$k$$y = \text{bounce} (x, k)$$2k$$k$$k$$y$$k$$k-1$$x=0$

चुनौती

पूर्णांक और धनात्मक पूर्णांक को देखते हुए , पूर्णांक या फ्लोटिंग-पॉइंट सन्निकटन लौटाते हैं ।k y = bounce ( x , k $x$$k$$y = \text{bounce} (x, k)$

यह कोड-गोल्फ है , इसलिए सबसे कम वैध जमा (बाइट्स में गिना जाता है) जीतता है।

परीक्षण के मामलों

  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

एक के लिए बोनस अंक फूरियर में दृष्टिकोण आधारित फूरियर ।

Comments

" दोनों कार्यों के लिए, x का न्यूनतम मान 0 है, और अधिकतम k है " बस सादा गलत है।

— पीटर टेलर

@PeterTaylor वूप्स। मेरा मतलब है परिणाम।

— फल जूला

उफ़, यही मैंने सोचा था कि यह पहले से ही कहा। यह अभी भी गलत है। k % k = 0

— पीटर टेलर

@PeterTaylor ओह, मैं आपके प्रश्न को समझता हूं। मैंने मूल रूप से इसे फ्लोटिंग-पॉइंट को ध्यान में रखते हुए डिज़ाइन किया था, फिर बाद में सिर्फ इनट्स पर स्विच किया। संपादित करेंगे।

— फलन

@PeterTaylor यदि तर्क तैर रहे हैं, तो अधिकतम एक संख्या है जो मनमाने ढंग से करीब है k।

— फ्रूट जूल

Answer 1

x86-64 मशीन कोड, 18 बाइट्स

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

यह कोड x86-64 मशीन भाषा में एक फ़ंक्शन को परिभाषित करता है जो गणना करता है bounce(x, k)। बाद सिस्टम वी AMD64 बुला सम्मेलन जीएनयू / यूनिक्स सिस्टम पर इस्तेमाल किया, xपैरामीटर में पारित हो जाता है EDI, रजिस्टर, जबकि kपैरामीटर में पारित हो जाता है ESIरजिस्टर। सभी x86 कॉलिंग सम्मेलनों के रूप में, परिणाम EAXरजिस्टर में वापस आ गया है ।

C से इसे कॉल करने के लिए, आप इसे इस प्रकार प्रोटोटाइप करेंगे:

int Bounce(int x, int k);

इसे ऑनलाइन आज़माएं!

असेंबली असेंबली mnemonics:

; 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

ध्यान दें कि पहला खंड (पूर्ण मान लेता है) समान रूप से लिखा जा सकता है:

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

जो बाइट्स (6) की सटीक समान संख्या है। प्रदर्शन समान होना चाहिए, शायद थोड़ा तेज ( कुछ इंटेल चिप्स को छोड़कर , जहां सशर्त चाल धीमी है )।

XCHGबेशक, अपेक्षाकृत धीमी गति से और MOVकोड गोल्फिंग को छोड़कर अधिक पसंद नहीं किया जाएगा (यह कि पूर्व 1 बाइट है जब ऑपरेंड में से एक संचायक होता है, जबकि एक रजिस्टर-रजिस्टर MOVहमेशा 2 बाइट्स होता है)।

Answer 2

जेली , 3 बाइट्स

æ%A

इसे ऑनलाइन आज़माएं!

निर्मित- ins ftw।

व्याख्या

æ%यहाँ एक उपयोगी बिल्ट-इन है। मुझे नहीं पता कि इसका वर्णन कैसे करना है, इसलिए मैं कुछ इनपुट के लिए आउटपुट प्रदान करूंगा:

के रूप में xसे चला जाता है 0अनंत को, xæ%4चला जाता है 0,1,2,3,4,(-3,-2,-1,0,1,2,3,4,)जहां कोष्ठक में हिस्सा दोनों तरीकों से अनंत को दोहराया है।

Answer 3

पायथन 2 , 29 27 बाइट्स

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

इसे ऑनलाइन आज़माएं!

Answer 4

पायथन 3 , 27 बाइट्स

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

इसे ऑनलाइन आज़माएं!

Answer 5

रूबी, 40 बाइट्स 32 बाइट्स

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

इसे ऑनलाइन आज़माएं!

व्याख्या

नमस्ते, यह इस साइट पर मेरा पहला जवाब है! इस कोड को अवलोकन के आधार पर की जाती है कि उछाल समारोह बर्ताव करता है वास्तव में सापेक्ष की तरह जब ( एन -1) कश्मीर <= एक्स < nk और n विषम है, और एक उलट सापेक्ष आपरेशन जब की तरह बर्ताव करता है n भी है। (x/k+1)सबसे छोटा पूर्णांक x / k (जो x / k +1 से पूर्णांक तक छोटा होता है) से अधिक होता है । इसलिए, ऊपर उल्लिखित एन को(x/k+1) पाता है। यह देखने के लिए जाँचता है कि n विषम है या नहीं। यदि n mod 2> 0, तो n विषम है। यदि एन%2>0mod 2 = 0, फिर n सम है। यदि n विषम है, तो बाउंस फ़ंक्शन को x mod k के बराबर होना चाहिए । यदि n सम है, तो उछाल फ़ंक्शन k - x mod k के बराबर, रिवर्स होना चाहिए । संपूर्ण अभिव्यक्ति n को(x/k+1)%2>0?x%k:k-x%k ढूँढती है , फिर x mod k को निष्पादित करता है यदि यह विषम है, और k - x mod k को अन्यथा निष्पादित करता है ।

साइओस के एक सुझाव के आधार पर उत्तर में सुधार किया गया था ।

Comments

आप इसे एक लैम्ब्डा में बदल सकते हैं। def b(x,k) ... endउपयोग के बजाय->x,k{...}

— Cyoce

और जब से आप पूर्णांक के साथ काम कर रहे हैं, .to_iआवश्यक नहीं है।

— साइओस

Answer 6

गणितज्ञ, 19 बाइट्स

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

Answer 7

अजगर , 5 बाइट्स

aa%Ey

सभी टेस्टकेस को सत्यापित करें।

मेरे पायथन जवाब का कांटा ।

Answer 8

जे, 25 बाइट्स

संकेत:

यह सीढ़ी संख्याओं पर सिर्फ नियमित मोड्यूल है। उदाहरण के लिए, 5 के मामले में:0 1 2 3 4 5 4 3 2 1

यहाँ जे में एक (अभी तक अच्छी तरह से गोल्फ नहीं) समाधान है कल सुधारने की कोशिश करेंगे:

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

दबा हुआ: [((|~#){])(i.@>:,}:@i.@-)@]

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

इसे ऑनलाइन आज़माएं!

Comments

मुझे लगता है कि i:यहां इस्तेमाल किया जा सकता है, लेकिन मैंने अभी तक एक समाधान की कोशिश नहीं की है

— कॉनर ओ'ब्रायन

@ ConorO'Brien मेरे संपीड़ित 2 संस्करण की जाँच करें, यह कुछ बाइट्स का उपयोग करके बचाता है i:। अभी मुख्य को अपडेट करने और स्पष्टीकरण देने का समय नहीं है। मुझे उम्मीद है कि एक विशेषज्ञ कम से कम एक और 4 या 5 बाइट्स दाढ़ी कर सकता है ...

— जोनाह

((|~#){])]-|@}:@i:18 बाइट्स के लिए

— मील

@ मीलों सुंदर, tyvm

— योना

Answer 9

QBIC , 25 30 27 बाइट्स

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

थोड़ा सा पुनर्गठन किया ...

व्याख्या

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

Comments

क्या QBIC MOD संचालन के लिए कुछ अलग करता है जो अन्य बुनियादी कार्यान्वयन से होता है? अन्य मूल बातें लाभांश के रूप में उसी चिह्न के साथ एमओडी लौटाती हैं; x-13 और 13 है जब विफल हो जाएगा k। 14.

— कोड़ी ग्रे

@ कोडीग्रे नोप, इसने दिया -13। अभी तय किया है।

— स्टीनबेरग

क्या आपको absदोनों समय की आवश्यकता नहीं है ?

— नील

@ क्या आपके पास इसके लिए कोई टेस्टकेस है?

— स्टीनबेरग

@ नील एनवीएम, मैंने इसे पूरी चीज़ के पुनर्गठन से तय किया है।

— स्टीनबेरग

Answer 10

C89, 40 बाइट्स

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

की एसी बंदरगाह मेरी x86 मशीन कोड जवाब है, यह एक समारोह, को परिभाषित करता है f, कि गणना मापदंडों के लिए उछाल-सापेक्ष xऔर k।

यह C89 के इंटेक्ट-इंट-रूल का उपयोग करता है, ताकि दोनों पैरामीटर्स, वैरिएबल वैरिएबल tऔर फंक्शन का रिटर्न वैल्यू सभी निहित प्रकार का हो int। ग्लोबली वैरिएबल tका उपयोग केवल अस्थायी मान रखने के लिए किया जाता है, जो बाइट बचत को समाप्त करता है, सशर्त ऑपरेटर के दोनों तरफ गणना को दोहराने की तुलना में।

absसमारोह (निरपेक्ष मूल्य) में प्रदान की जाती है <stdlib.h>हैडर, लेकिन हम इसे यहाँ, फिर से शामिल करने के लिए C89 का अंतर्निहित-पूर्णांक नियम (जहां समारोह परोक्ष की घोषणा की और वापसी के लिए माना जाता है के लिए धन्यवाद की जरूरत नहीं है int)।

इसे ऑनलाइन आज़माएं!

Ungolfed संस्करण:

#include <stdlib.h>

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

मेरे हाथ से चलने वाले मशीन कोड के प्रकाश में इसे देखते हुए , संकलक वास्तव में इसके लिए बहुत अच्छा आउटपुट उत्पन्न करते हैं। मेरा मतलब है, उन्हें चाहिए; यह अनुकूलन करने के लिए एक बहुत ही सरल कार्य है! मैंने जीसीसी के x86-64 ऑप्टिमाइज़र में एक मामूली बग को उजागर किया , हालांकि, जहां यह उत्सुकता से बड़े कोड का उत्पादन करता है जब आप इसे आकार और छोटे कोड के लिए अनुकूलित करने के लिए कहते हैं जब आप इसे गति के लिए अनुकूलित करने के लिए कहते हैं ।

Comments

m;f(x,k){m=abs(x%k);x=x/k%2?k-m:m;}कम है

— user41805

सिवाय इसके कि यह वास्तव में x86 लक्ष्यों पर जीसीसी कोड जनरेटर के एक क्विक के कारण कुछ निश्चित परिभाषित परिस्थितियों के अलावा, @cows, को वापस नहीं करता है। यह एक ऐसा टेम्प्लेट है जो मैं देख रहा हूं कि लोग यहां उपयोग करते हैं, लेकिन यह मेरे लिए काम नहीं करता है, स्टैक से यादृच्छिक कचरा खींचने से अधिक है जो सिर्फ सही उत्तर होने के लिए होता है।

— कोडी ग्रे

Answer 11

हास्केल, 37 बाइट्स

इसे ऑनलाइन आज़माएं!

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

कैसे उपयोग करें: गैर-नकारात्मक बाएं तर्कों के लिए और नकारात्मक बाईं तर्कों के लिए
कॉल करें , क्योंकि हास्केल व्याख्या करेगा जैसे कि आप कुछ का उपयोग कर रहे हैं । टीआईओ-लिंक बस दो कमांड-लाइन तर्क लेता है।15#14(-13)#14-13#14-(13#14)ghci

स्पष्टीकरण:
पहले बाइनरी इन्फिक्स ऑपरेटर !को उसी के रूप में फिर से परिभाषित करता है mod। हास्केल modहमेशा एक गैर-नकारात्मक मूल्य का उत्पादन करता है, इसलिए हमें absयहां अन्य समाधानों की आवश्यकता नहीं है। यह तब जांचता है कि क्या x/k(पूर्णांक विभाजन) विषम है और यदि हां, तो रिटर्न k-x mod k(यानी बैक-बाउंस) या फिर यह वापस आ जाता है x mod k।

Comments

यह शायद सिर्फ स्वाद की बात है, लेकिन मैं व्यक्तिगत रूप !से परिभाषित नहीं करना चाहता क्योंकि यह किसी भी बाइट को नहीं बचाता हैx#k|odd$x`div`k=k-x`mod`k|1<2=x`mod`k

— मार्क एस।

Answer 12

PHP, 40 50 बाइट्स

लानत डॉलर। लानत आयात ओवरहेड। :)

पूर्णांक संस्करण:

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

या

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

फ्लोट संस्करण, 56 बाइट्स:

बदलें abs($x)%$kके साथ fmod(abs($x),$k)।

---

संपादित करें: नकारात्मक के लिए निश्चित परिणाम x

Comments

"धिक्कार है डॉलर"। हाँ, पैसे की बदबू ...

— steenbergh

कैसे €argvया £argv? वे अच्छे

— लगेंगे

Answer 13

जावास्क्रिप्ट (ईएस 6), 36 32 बाइट्स

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

रिकर्सिवली बाउंस xके खिलाफ 0और k, इसलिए बहुत ज्यादा चुनौती की भावना में।

Answer 14

आम लिस्प, 41 बाइट्स

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

इसे ऑनलाइन आज़माएं!

Answer 15

सी (जीसीसी), 43 53 बाइट्स

संपादित करें: निश्चित नकारात्मक मुद्दा

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

इसे ऑनलाइन आज़माएं!

Comments

यह (-13, 14) (-13 के बजाय -13) के लिए गलत उत्तर प्रदान करता है। मापांक और शेष संचालन नकारात्मक संख्याओं पर भिन्न व्यवहार करते हैं।

— नवंबर को CAD97

Answer 16

आर, 28 बाइट्स

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

जो फ़ंक्शन का मूल्यांकन करता है:

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

जो सबसे अधिक समाधान का उपयोग करने की विधि प्रतीत होती है। मैंने इसे बनाने से पहले उन्हें नहीं देखा।