दशमलव प्रतिनिधित्व की अवधि

Question

एक फ़ंक्शन लिखें जो एक एकल सकारात्मक पूर्णांक n लेता है और 1 / n के दशमलव प्रतिनिधित्व की अवधि लौटाता है ।

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

1 -> 1               # 1/1 = 1.0000...... = 1._0
2 -> 1               # 1/2 = 0.5000...... = 0.5_0
3 -> 1               # 1/3 = 0.3333...... = 0._3
7 -> 6               # 1/7 = 0.14285714.. = 0._142857
13 -> 6
14 -> 6
123 -> 5
345 -> 22
654 -> 108
12345 -> 822
67890 -> 120

यह कोड-गोल्फ है । बिल्ट-इन या लाइब्रेरी जो सीधे पीरियड लौटाते हैं उन्हें अनुमति नहीं है। कम से कम 100000 तक की संख्या उचित समय के भीतर (अधिकतम कई मिनट) काम करना चाहिए।

Comments

प्रश्न कहता है कि "कम से कम 100000 तक की संख्या उचित समय के भीतर काम करनी चाहिए", लेकिन क्या प्रोग्राम को इससे बड़ी संख्या के लिए सही उत्तर देना है ? या यह एक एल्गोरिथ्म का उपयोग करने के लिए स्वीकार्य होगा जो केवल 100000 तक सटीक है?

— फायरफली

@ फ़ायरली एल्गोरिदम को सही उत्तर देना होगा।

— हावर्ड

1 क्यों लौटेगा 1? मुझे लगता है कि 0 होगा?

— टाइमटेक

@ टिम्टेक1.00000000000000000000000000000000000

— क्रंचर

@ क्रंचर ओह थैंक्स, मुझे अभी मिल गया है।

— टिमटेक

Answer 1

एपीएल, 19 चार्ट / बाइट्स *

{(↑⍳⍨1∘↓)⌽⍵|10x*⍳⍵}

Nars2000 । पिछला संस्करण कुछ नंबरों पर गलत था, यह सही होना चाहिए। मैंने इसे 50 तक सभी नंबरों पर मैन्युअल रूप से जांचा।

फिर, की अवधि को देखने के विचार के लिए बेन रीच को श्रेय जाता है10^i (mod x)

एक्स्प्लोडेड वीयू

{                     ⍳⍵}   generate all naturals up to the argument ⍵
                 10x*       raise 10 to each of them, with unlimited precision
              ⍵|            compute the respective remainders mod ⍵
            ⌽               reverse the list
 (  ⍳⍨    )                 (fork) find the position of the first occurrence
  ↑                         of the fist element of the list
       1∘↓                  in the remainder of the list

उदाहरण

      {(↑⍳⍨1∘↓)⌽⍵|10x*⍳⍵}¨1 2 3 7 13 14 123 345 654 12345 67890
1 1 1 6 6 6 5 22 108 822 120

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯
^{*: APL को अपनी (विरासत) सिंगल-बाइट चारसेट में लिखा जा सकता है जो APL प्रतीकों को ऊपरी 128 बाइट मानों में मैप करता है। इसलिए, स्कोरिंग के उद्देश्य से, N वर्णों का एक प्रोग्राम जो केवल ASCII वर्णों और APL प्रतीकों का उपयोग करता है, को N बाइट्स माना जा सकता है।}

Comments

मुझे उदाहरण के लिए इनपुट का सही उत्तर नहीं मिला 20। क्या आप कृपया सत्यापित कर सकते हैं?

— हावर्ड

मैंने आपके द्वारा पोस्ट किए गए उदाहरणों का अनुसरण किया। आपके उदाहरण में, 1/2 = 0.5 -> 1, इसलिए स्वाभाविक रूप से 1/20 = 0.05 -> 2. आप क्या प्राप्त कर रहे हैं?

— टोबिया

1/20 = 0.05_0_ के बाद से सही उत्तर 1 होगा।

— हावर्ड

समझा। मुझे थोड़ा सा दो, मैं अपना जवाब संशोधित कर दूंगा।

— टोबिया

4ऐसा लगता है कि यह गलत जवाब भी देगा, क्योंकि 10 != 100 (mod 4)।

— पीटर टेलर

Answer 2

गोल्फक्राफ्ट ( 42 27)

{:x)1\[{.10*x%}*]-1%(?)}:P;

बेंचमार्क समय: 5 सेकंड। बेंचमार्किंग कोड:

'"The time is #{Time.now#1
}"'~ puts
[1 2 3 7 13 14 123 345 654 12345 67890 99991]{[P]p}%
'"The time is #{Time.now#2
}"'~ puts

की अवधि को देखने के मूल विचार के लिए बेन रीच को श्रेय 10^i (mod x) ।

व्याख्या

अवधि pको सबसे छोटे धनात्मक पूर्णांक के रूप में परिभाषित किया गया है, जो कि iहमारे पास पर्याप्त रूप से बड़े हैं frac(10^i * 1/x) = frac(10^(i+p) * 1/x)। हम इसे थोड़ा सरल कर सकते हैं frac(10^i / x) = frac(10^(i+p) / x)। अब, frac(a / x) = frac(b / x)अगर a == b (mod x), तो हम सबसे छोटे सकारात्मक पूर्णांक की तलाश कर रहे हैं, जो कि पर्याप्त रूप से बड़े के लिए हो i:10^i == 10^(i+p) (mod x) ।

मान लीजिए 10^i == 10^(i+p) (mod x)। फिर10^(i+1) == 10 * 10^i == 10 * 10^(i+p) == 10^(i+p+1) (mod x) ; इसलिए एक बार जब हमें पुनरावृत्ति मिलती है, तो हम एक अटूट चक्र में होते हैं।

केवल xविशिष्ट मूल्य हैं (mod x), इसलिए कबूतर सिद्धांत द्वारा हमें पहले x + 1मूल्यों में एक पुनरावृत्ति प्राप्त करनी चाहिए10^i (mod x) ।

तो ऊपर दिए गए कोड के x + 2मूल्यों की गणना करना क्या है10^i (mod x) * के । फिर पिछले एक को पुनरावृत्ति होने की गारंटी दी जाती है, और सूची को उल्टा करके और इसकी खोज करके मैं सबसे हाल की घटना का पता लगा सकता हूं। इसके अलावा, क्योंकि मैं केवल एक खोज कर रहा हूं यह छद्मवेशी समय है।

* अतिरिक्त एक विशेष मामले को संभालने के लिए है x = 1क्योंकि मैं कम नहीं करते हैं, 10^0 (mod x)और इसलिए मैं एक के लिए विचार करना होता 0में [1]।

Comments

बहुत बढ़िया! मैंने बेहतर समाधान के बाद से अपना उत्तर हटा दिया है! -

— बेन रीच

Answer 3

गोल्फस्क्रिप्ट - 26 बाइट्स

{:i.)+.,{;10*i%.}%i>|,}:f;

संपादित करें: 1यदि दशमलव समाप्त होता है, तो दशमलव प्रतिनिधित्व की लंबाई के बजाय आउटपुट पर अपडेट किया जाता है।

एक काफी कुशल संस्करण। मान 67890 लगभग 10 सेकंड और 99991 लगभग 20 सेकंड में चलता है । यह पहले की तुलना में थोड़ा धीमा है (लगभग आधा उपवास के रूप में), क्योंकि जो रेंज पुनरावृत्त है उसे दोगुना कर दिया गया है, जिसमें से पहली छमाही को अनदेखा किया गया है।

वैकल्पिक, 26 बाइट्स भी

{:i.)+.n*{*i%.}%i>)^^,}:f;

यह एक स्ट्रिंग पर पुनरावृत्ति करके काम करता है "\n"*(2*i+1), जहां iफ़ंक्शन को पास किया गया मान है। प्रत्येक बार ब्लॉक को दिया गया मान उस का मूल मान है "\n", जो 10 है ।

)^^एक काम के आसपास का एक सा है। जब आप किसी वर्ण को स्ट्रिंग से हटाते हैं , तो परिणाम उस वर्ण का क्रमिक मान निकाल दिया जाता है, जैसा कि ऊपर बताया गया है। हालाँकि, उस मूल्य को वापस लेने से चरित्र के बजाय उस संख्या के स्ट्रिंग प्रतिनिधित्व को जोड़ दिया जाएगा - काफी निरर्थक व्यवहार, और मेरी राय में एक डिजाइन दोष। यदि आप वास्तव में ऐसा करना चाहते हैं, तो पहले सख्त करने पर केवल एक बाइट का खर्च आएगा।

अंतिम मूल्य की एक अतिरिक्त प्रतिलिपि पहले से ही स्टैक पर है, इसलिए मैं फिर से अंतिम मान को हटाता हूं ), इसे स्ट्रिंग के साथ xor करता हूं , और फिर इसे फिर से xor करता हूं , ताकि जो भी अक्षर पहले xor द्वारा जोड़े गए या हटाए गए हैं उन्हें पुनर्स्थापित किया जाए। यदि int op stringइसके स्ट्रिंग प्रतिनिधित्व के बजाय एक चरित्र के रूप में व्यवहार किया जाता है, )^^तो इसे प्रतिस्थापित किया जा सकता है |।

ध्यान दें कि स्ट्रिंग्स के दौरान (जो कि गोल्फस्क्रिप्ट में इन्टस की एक सरणी के रूप में संग्रहीत किया जाता है) प्रत्येक वर्ण मॉड के मूल्य को प्रदर्शित करेगा 256 का मान का मान स्वयं इस सीमा के बाहर हो सकता है। जब विशिष्टता (सेट संचालन के माध्यम से) या समता (माध्यम से ?) के लिए परीक्षण किया जाता है, तो यह वास्तविक मूल्य है जिसकी तुलना प्रदर्शन मूल्य के बजाय की जाती है।

के लिए एक पैच फ़ाइल वर्तमान गोल्फस्क्रिप्ट दुभाषिया के :

61c61
<       to_gs
---
>       Gstring.new([self])

ऊपर केवल string op int(और इसके विपरीत) के व्यवहार को प्रभावित करेगा , जहांop एक है
+-|&^। के व्यवहार सहित बाकी सब अप्रभावित रहता है Gint`।

निम्नलिखित 24 बाइट समाधान तब मान्य हो जाएगा:

{:i.)+.n*{*i%.}%i>|,}:f;

और यह बहुत सारे अन्य को भी ठीक करता है वास्तव में बदसूरत काम के आसपास ।

---

पायथन - 48 बाइट्स

f=lambda n:len(set(10**-~i%n for i in range(n)))

सबसे कुशल समाधान नहीं है, लेकिन इससे कम मूल्यों के लिए उचित है 100000 ।

FWIW, मूल तत्व मेरे समाधान के लिए समान है दशमलव में उत्पन्न चक्रीय संख्या के ।

एक ही कोड का एक अधिक कुशल संस्करण ( 70 बाइट्स) ):

 def f(n):
  a=[];i=10%n
  while i not in a:a+=i,;i=i*10%n
  return len(a)

99991 का मूल्य एक सेकंड से भी कम समय लेता है।

Comments

@PeterTaylor यह orएक खाली स्ट्रिंग पर सरणी है। क्योंकि यह एक सेट-वार ऑपरेशन है, सभी डुप्लिकेट को पहले ही हटा दिया जाता है।

— प्राइमो

लेकिन खाली तार कहां से आता है? यदि फ़ंक्शन स्व-निहित होना है, तो मुझे लगता है कि आपको एक अतिरिक्त बाइट खर्च करना होगा और इसे बनाना होगा .|।

— पीटर टेलर

@PeterTaylor तय किया गया ।

— प्रिमो

के व्यवहार को बदलने से बहुत सारे कार्यक्रम string int +टूट जाएंगे । मुझे यकीन नहीं है कि उस प्रकार की जोड़ी पर कितनी बार अन्य ऑप्स का उपयोग किया जाता है।

— पीटर टेलर

@PeterTaylor मैं सहमत हूं, यह होगा। लेकिन विचार करें: चार को परिवर्तित पूर्णांक: []+''+बनाम ''+। Int, char के रूप में int, स्ट्रिंग: []++बनाम में जोड़ें +। स्ट्रिंग के रूप में प्रतिनिधित्व int, स्ट्रिंग के लिए: +बनाम `+। यह वर्तमान कार्यान्वयन में int''+है int`, जिसका पर्यायवाची शब्द है , जो सरणी के लिए ज़बरदस्ती करने की क्रियात्मकता को देखते हुए बेकार लगता है, और यदि आप आरसीआई चर चाहते हैं तो एक स्ट्रिंग के लिए ज़बरदस्ती करें।

— प्रिमो

Answer 4

गोल्फस्क्रिप्ट, 48 47 46

@PeterTaylor को धन्यवाद दो चरखा काटने के लिए।

{2{1$1$%!{.@\/\d}*}:d~;5d;9{2$%}{10*9+}/+,}:f;

मैंने J का उपयोग करने की कोशिश की, लेकिन यह मुझे हर तरह के अजीब परिणाम देता रहा।

ऑनलाइन टेस्ट करें

यह मूल रूप से संख्या से 2 और 5 को विभाजित करता है (2 और 5 10 के प्रमुख कारक हैं, और उनके पारस्परिक समाप्त होते हैं, और एल्गोरिथ्म को सामान करते हैं), फिर सबसे कम पूर्णांक n जैसे कि परिणामी संख्या 10 ^ n - 1 को विभाजित करती है। काल।

Comments

यदि आप जानते हैं कि आपके फ़ंक्शन का पहला कॉल कौन सा होगा तो आप वहां परिभाषा को इनलाइन कर सकते हैं। Ie की बजाय {...}:d;...dआप 1 char को बचाएं...{...}:d~

— पीटर टेलर

@PeterTaylor धन्यवाद, उस के बारे में नहीं सोचा था

— अस्थिरता

बेन fको स्टैक पर नहीं छोड़ने के बारे में टिप्पणी करने के बाद , मुझे लगता है कि आप इसे भी कर रहे हैं। आपको ;अन्य भाषाओं के साथ निष्पक्ष तुलना के लिए फ़ंक्शन को पॉप करने के लिए वास्तव में जोड़ना चाहिए ।

— पीटर टेलर

एक और माइक्रो-ऑप्टिमाइज़ेशन: int array ,)\;को छोटा किया जा सकता है int array +,।

— पीटर टेलर

Answer 5

पर्ल, 52 अक्षर

sub f{($p,%r)=1;1until$r{$p=$p*10%$_[0]}++;~~keys%r}

यह प्रत्यक्ष दृष्टिकोण का एक सरल कार्यान्वयन है। (सौभाग्य से प्रत्यक्ष दृष्टिकोण भी काफी कुशल है: मॉडुलो अंकगणित के लिए धन्यवाद, गणित को कभी भी इनपुट मूल्य से 10 गुना अधिक संख्या के साथ सौदा नहीं करना पड़ता है।)

चूंकि चुनौती ने एक फ़ंक्शन को निर्दिष्ट किया, इसलिए मैंने अपने चर को फिर से शुरू करने के लिए मजबूर किया (पुनः) महसूस किया, कुछ ऐसा है जो मैं एक संपूर्ण कार्यक्रम के लिए परेशान नहीं करूंगा। इसी तरह, ~~अंतिम कथन अनावश्यक है अगर फ़ंक्शन निश्चित हो सकता है तो इसे स्केलर संदर्भ में लागू किया जाएगा।

Comments

इनपुट पर प्रयास करें 20जहां यह गलत परिणाम देता है।

— हावर्ड

Answer 6

Clojure, 102, 117, 115, 106

unformated:

(defn r([n](r{}(iterate #(mod(* % 10)n)10)0))([a[f & s]i](if(a f)(- i(a f))(recur(assoc a f i)s(inc i)))))

स्वरूपित:

(defn r
  ([n] (r {} (iterate #(mod (* % 10) n) 10) 0))
  ([a [f & s] i]
    (if (a f)
      (- i (a f))
      (recur
        (assoc a f i)
        s
        (inc i)))))

रनिंग टाइम पीरियड के साथ। नमूना मूल्यों के लिए मेरे कंप्यूटर पर लगभग तात्कालिक।

मूल रूप से, यह लंबे विभाजन में प्रत्येक चरण के बाद घटाव के परिणाम की गणना करता है। एक चक्र का पता लगाया जाता है यदि किसी भी बिंदु पर वह संख्या एक समान है जो कि इससे पहले गणना की गई है।

Comments

इनपुट के साथ कोड टूट जाता है 20। क्या आप कृपया सत्यापित कर सकते हैं?

— हावर्ड

आप सही हैं, उपरोक्त समाधान दोषपूर्ण है। यह देखने के लिए कि क्या मैं इसे ठीक कर सकता हूं।

— RedDeckWins

20 के लिए अपेक्षित आउटपुट क्या है?

— RedDeckWins

सही उत्तर होगा 1.

— हावर्ड

जाने के लिए अच्छा होना चाहिए, पहला एल्गोरिथ्म बहुत सारे इनपुट पर विफल होगा, उदाहरण के लिए 12 और 20.

— RedDeckWins

Answer 7

(गैर-प्रतिस्पर्धी) पायथ

fq.^;yTQ.^;TQ

कछुए और हरे एल्गोरिथ्म ( अधिक जानकारी ) का उपयोग करता है ।

देखो यह हर परीक्षा पास है।