दूरी की गणना करना mod N

13

आप लंबे समय से एक उन्नत संग्रह डिवाइस नियंत्रक ™ से डेटा एकत्र कर रहे हैं। आप लॉग की जांच करते हैं, और आपके आतंक से आपको पता चलता है कि कुछ बहुत गलत हो गया है: डेटा में केवल संख्या के अंतिम बिट्स होते हैं!

सौभाग्य से, आप शुरुआती मूल्य जानते हैं और यह कि मूल्य कभी भी तेजी से नहीं बदलता है। इसका मतलब है कि आप शुरू से दूरी का पता लगाकर बाकी की वसूली कर सकते हैं।

चुनौती

एक मापांक Nऔर मध्यवर्ती मान modulo की एक सूची दी गई राशि को बदलने के लिए आप एक प्रोग्राम या फ़ंक्शन लिखेंगे N।

प्रत्येक जोड़ी संख्या के बीच परिवर्तन हमेशा की तुलना में कम होता हैN/2 , इसलिए प्रत्येक परीक्षण मामले के लिए केवल एक मान्य उत्तर होगा।

आपको Nअपनी पसंद के प्रारूप में इनपुट पूर्णांक > 2 और मूल्यों की सूची के रूप में दिया जाएगा । इनपुट STDIN या कमांड लाइन या फ़ंक्शन तर्कों के माध्यम से दिया जा सकता है।

आप एक ही पूर्णांक का उत्पादन करेंगे, मूल मूल्य बदल गया है। आउटपुट को STDOUT या मुद्रित किया जा सकता है।

नियम

  • आपका प्रोग्राम किसी भी दूरी और मापांक से कम के लिए काम करना चाहिए 2^20।
  • आप मान सकते हैं कि:
    • Nकम से कम है 3।
    • सूची में कम से कम 2 मान हैं।
    • सूची में सभी मान कम से कम 0 और से कम हैं N।
    • संख्या में सभी परिवर्तन की तुलना में कम हैं N/2।
  • कुछ भी एक अमान्य इनपुट है, और आपका प्रोग्राम जो चाहे कर सकता है।
  • मानक खामियों, किसी भी गैर-मानक पुस्तकालयों और इस सटीक उद्देश्य के लिए अंतर्निहित फ़ंक्शन निषिद्ध हैं।
  • यह कोड-गोल्फ है , इसलिए बाइट्स में सबसे छोटा कार्यक्रम जीत जाता है।

उदाहरण के मामले

इनपुट:

3
0 1 2 2 0 1 0 2 1 2 0 1 2 1 1

आउटपुट:

4

स्पष्टीकरण (उदाहरण मूल्य के साथ):

Value mod 3: 0 1 2 2 0 1 0 2 1 2 0 1 2 1 1
Value:       0 1 2 2 3 4 3 2 1 2 3 4 5 4 4

इनपुट:

10
5 2 8 9 5

आउटपुट:

-10

स्पष्टीकरण (उदाहरण मूल्य के साथ):

Value mod 10:  5  2  8  9  5
Value:        15 12  8  9  5

अमान्य इनपुट:

2
0 0 0 0 0

(बहुत छोटा मापांक)

6
2 5 4 2

(2 और 5 के बीच बहुत बड़ा बदलाव)

code-golf  math 
— PurkkaKoodari
स्रोत
अपनी पसंद का एक प्रारूप एक फिसलन ढलान है। क्या मेरा गोल्फस्क्रिप्ट समाधान किसी इनपुट सूची पर निर्भर हो सकता है जैसे कि देख रहे हो :^;[5 2 8 9 5](\ ?
— लिन
3
@ मौरिस आम तौर पर, नहीं ... "आपकी पसंद का एक प्रारूप" आमतौर पर "अपनी पसंद की भाषा में एक पारंपरिक प्रतिनिधित्व" का अर्थ माना जाता है।
— मार्टिन एंडर
हालाँकि, आप "10 5 2 8 9 5" या "10,5 2 8 9 5" या "10 5,2,8,9,5" जैसी दिखने वाली इनपुट सूची पर भरोसा कर सकते हैं।
— Sparr

जवाबों:

2

टीआई-बेसिक, 15 बाइट्स

Input N
sum(N/πtan⁻¹(tan(ΔList(πAns/N

से Ansऔर मापांक से सूची लेता है Input।

                       πAns/N    ; Normalize the list to [0,π)
                 ΔList(          ; Take differences, which are in the range (-π,π)
       tan⁻¹(tan(                ; Modulo, but shorter. Now elements are in (-π/2,π/2)
    N/π                          ; Multiply by N/π. These are displacements at each step.
sum(                             ; Add up all the displacements
— lirtosiast
स्रोत
9

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

lambda n,l:sum((b-a+n/2)%n-n/2for a,b in zip(l,l[1:]))

सुपर सीधे आगे जवाब। मुझे आश्चर्य है कि अगर कोई छोटा रास्ता है।

— लिन
स्रोत
मैं उस बिट को याद किया। धन्यवाद।
— लिन
@ जाकुब मैं पहले ही ऐसा कर चुका था - .:_2जब तक मुझे आपका उत्तर नहीं मिला - मैं जिप का उपयोग कर रहा था, तब तक मुझे जोड़े बनाने के बारे में पता नहीं था।
— orlp
1
@ जाकुब मैं इसे 19 को मिला :)
— orlp
7

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

Tr@Mod[Differences@#2,#,-#/2]&

यह एक अनाम फ़ंक्शन है जो दो तर्क देता है। उदाहरण का उपयोग:

Tr@Mod[Differences@#2,#,-#/2]&[3, {0, 1, 2, 2, 0, 1, 0, 2, 1, 2, 0, 1, 2, 1, 1}]
(* 4 *)
Tr@Mod[Differences@#2,#,-#/2]&[10, {5, 2, 8, 9, 5}]
(* -10 *)

यह Differencesक्रमिक तत्वों के बीच ले जाकर , उनके ऑफसेट पैरामीटर के साथ सीमा -n/2तक लपेटकर , फिर कुल (मैट्रिक्स ट्रेस, विकर्ण तत्वों का योग) के साथ काम करता है।+n/2ModTr

ध्यान दें कि यह भी केवल 43 बाइट्स ungolfed है!

f[n_, l_] := Total[Mod[Differences[l], n, -n/2]]
— 2012rcampion
स्रोत
@अनावश्यक है जब आप पहले से ही वर्ग कोष्ठक के साथ फ़ंक्शन को बुला रहे हैं। दोनों में एक वाक्यविन्यास त्रुटि है।
— डेविड झांग
@DavidZhang वूप्स, पता नहीं मैं क्या सोच रहा था। गणितज्ञ को खोले बिना उत्तर देने का प्रयास करने के लिए मुझे अधिकार देता है!
— २०१२ आर्कम्पियन १४'१५
5

जे, 24 बाइट्स

[+/@(]-(>-:)~*[)[|2-~/\]

उपयोग:

   f=:[+/@(]-(>-:)~*[)[|2-~/\]

   3 f 0 1 2 2 0 1 0 2 1 2 0 1 2 1 1
4

   10 f 5 2 8 9 5
_10

अधिक गोल्फ करने की कोशिश करेंगे और उसके बाद कुछ स्पष्टीकरण जोड़ेंगे।

इसे यहाँ ऑनलाइन आज़माएँ।

— randomra
स्रोत
1
ज़रूर इसका J और CJam नहीं? : पी
— ऑप्टिमाइज़र
4

पायथ, 20 19 बाइट्स

sm-J/Q2%+-FdJQ.:vw2

चुराई .:_2Jakube, Mauris से विचार से।

— orlp
स्रोत
3

आर, 38 बाइट्स

function(n,v)sum((diff(v)+n/2)%%n-n/2)

यह एक अनाम फ़ंक्शन बनाता है जो एक पूर्णांक और एक वेक्टर को इनपुट के रूप में स्वीकार करता है और एक पूर्णांक देता है। इसे कॉल करने के लिए, इसे एक नाम दें, जैसे f=function(n,v)...।

असंगठित + स्पष्टीकरण:

f <- function(n, v) {
    # Compute the differences between sequential elements of v
    d <- diff(v)

    # Add n/2 to the differences and get the result modulo n
    m <- (d + n/2) %% n

    # Subtract n/2 then sum the vector
    sum(m - n/2)
}

उदाहरण:

> f(3, c(0, 1, 2, 2, 0, 1, 0, 2, 1, 2, 0, 1, 2, 1, 1))
[1] 4

> f(10, c(5, 2, 8, 9, 5))
[1] -10
— एलेक्स ए।
स्रोत
3

मतलाब, 33 बाइट्स

@(x,y)sum(mod(diff(y)+x/2,x)-x/2)

मेरी क्षमायाचना, इस वेबसाइट पर यह मेरा पहला उत्तर है। MatLab में इसे टाइप करने पर इनपुट का उपयोग ans(modulus_value, [intermediate_values])अनुरोधित मान को लौटाएगा, जहां 'modulus_value' मापांक मान है, और 'मध्यवर्ती_वायु' या तो रिक्त स्थान या अल्पविराम द्वारा अलग किए गए मध्यवर्ती मूल्यों की एक सूची है।

उदाहरण:

ans(3, [0 1 2 2 0 1 0 2 1 2 0 1 2 1 1])

अज्ञात फ़ंक्शन MATLAB के का लाभ लेता है mod, diffऔर sumकार्यों जवाब गणना करने के लिए। सबसे पहले, प्रत्येक मध्यवर्ती मूल्यों के बीच अंतर की गणना की जाती है। फिर परिणाम दो द्वारा विभाजित मापांक द्वारा ऑफसेट किया जाता है, जिसके परिणामस्वरूप अंतर मानों का एक सेट होता है जो [-मॉडुलस / 2 मापांक / 2] से बंधा होता है। परिणाम फिर ऑफसेट और फिर से अभिव्यक्त किया जाता है।

मुझे लगता है कि यह अधिक गोल्फ हो सकता है, मैं जल्द ही एक अपडेट के साथ वापस आऊंगा। विचार के लिए @ 2012 आर्केड के लिए विशेष धन्यवाद।

संपादित करें: मतलाब का unwrapकार्य लगभग यहां काम करता है, लेकिन यह गोल्फ के लिए कठिन है। निम्नलिखित कोड एक सरणी देता है जहां अंतिम मान वह राशि है जिसका पहला मूल्य बदल गया है: @(x,y)unwrap(y/x*2*pi)/2/pi*x-y(1)

मध्यवर्ती मूल्यों को [-पी पीआई] की सीमा तक बढ़ाया जाता है, फिर "अलिखित" ऐसा होता है कि कोई निरंतर मूल्य पीआई से अलग नहीं होता है। इन मानों को फिर से बढ़ाया और स्थानांतरित किया जाता है, जिसके परिणामस्वरूप शुरुआती मूल्य से दूरी की एक सरणी होती है।

दिलचस्प है, लेकिन इस चुनौती के लिए बहुत व्यावहारिक नहीं: डी

— रॉबी
स्रोत
2

पायथ, 29 बाइट्स

+sm**._K-Fdvz>y.aKvz.:Q2-eQhQ

इसे ऑनलाइन आज़माएं: पायथ कंपाइलर / एक्ज़ीक्यूटर

— Jakube
स्रोत
इनपुट अंतरिक्ष-पृथक है, अल्पविराम से अलग नहीं; आपका प्रोग्राम इसे संभालता नहीं दिख रहा है।
— लिन
2
@ मौरिस "मूल्यों की एक सूची, अपनी पसंद के एक प्रारूप में"
— जकुबे
मेरी गलती है! मैं कल्पना के उस हिस्से को पूरी तरह से याद कर रहा था।
— लिन
2

पिप , 39 बाइट्स

Qn$+({a>n/2?a-na<-n/2?a+na}Mg@>1-g@<-1)

कमांड-लाइन तर्क और STDIN पर मापांक के रूप में डेटा की सूची की आवश्यकता है। यदि यह बहुत अधिक खिंचाव है, तो मेरे पास एक संस्करण है जो 5 बाइट्स के लिए दो कमांड-लाइन आर्ग्स लेता है।

स्पष्टीकरण:

                                         g is list of cmdline args (implicit)
Qn                                       Read n from stdin
                            g@>1         All but the first of the cmdline args
                                -g@<-1   ...minus all but the last of the cmdline args
                                         (i.e. a list of the differences of adjacent items)
     {                    }M             ...to which, map the following function:
      a>n/2?a-n                            If diff is too big, subtract n;
               a<-n/2?a+n                  else if too small, add n;
                         a                 else return unchanged
  $+(                                 )  Sum; print (implicit)

और सिर्फ यह साबित करने के लिए कि यह गैर-प्रतिस्पर्धी स्कोर मेरी भाषा की तुलना में मेरे गोल्फ कौशल पर अधिक चिंतनशील है, यहां 30 बाइट्स में मॉरिस के पायथन समाधान का एक बंदरगाह है :

Qn$+({(n/2-$-a)%n-n/2}MgZg@>1)
— DLosc
स्रोत
2

जेली , गैर-प्रतिस्पर्धात्मक

6 बाइट्स यह जवाब गैर-प्रतिस्पर्धात्मक है, क्योंकि चुनौती जेली के निर्माण से पहले की है।

Iæ%H}S

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

यह काम किस प्रकार करता है

Iæ%H}S    Main link. Left input: A (list). Right input: N (integer).

I         Compute the increments (deltas of consecutive elements) of A.
   H}     Halve the right input (N).
 æ%       Mod the increments into (-N/2, N/2].
     S    Take the sum of all results.
— डेनिस
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.