दशमलव प्रतिनिधित्व का दोहराव ज्ञात करें!

12

में इस चुनौती 2 साल पहले, हमने पाया अवधि एक इकाई अंश के ( 1/n where n is a natural number)।

अब, आपका कार्य एक इकाई अंश की पुनरावृत्ति का पता लगाने के लिए एक कार्यक्रम / फ़ंक्शन लिखना है ।

Repetend दशमलव विस्तार जो असीम को दोहराता है, की तरह का हिस्सा है:

  • का दशमलव प्रतिनिधित्व 1/6है 0.16666..., तो पुनरावृत्ति है 6।
  • का दशमलव प्रतिनिधित्व 1/11है 0.090909..., तो पुनरावृत्ति है 09।
  • का दशमलव प्रतिनिधित्व 1/28है 0.0357142857142857142857..., तो पुनरावृत्ति है 571428।

चश्मा

  • किसी भी उचित प्रारूप में इनपुट।
  • दशमलव, स्ट्रिंग या सूची में पुनरावृत्ति को आउटपुट करें ।
  • के लिए 1/7( 0.142857142857...), आप उत्पादन करना चाहिए 142857बजाय 428571।
  • के लिए 1/13( 0.076923076923076923...), आप उत्पादन करना चाहिए 076923बजाय 76923।
  • कोई क्रूर बल, कृपया।

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

Input    Output
1        0
2        0
3        3
7        142857
13       076923
17       0588235294117647
28       571428
70       142857
98       102040816326530612244897959183673469387755
9899     000101020305081321345590463683200323264976260228305889483786241034447924032730578846348115971310233356904737852308313971108192746742095161127386604707546216789574704515607637135064147893726639054449944438832205273259925244974239822204263056874431760783917567431053641781998181634508536215779371653702394181230427315890493989291847661379937367410849580765733912516415799575714718658450348520052530558642287099707041115264168097787655318719062531568845337912920497019901

स्कोरिंग

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

कोई उत्तर स्वीकार नहीं किया जाएगा, क्योंकि लक्ष्य भाषा को सबसे छोटे समाधान का उत्पादन करने में सक्षम नहीं है, बल्कि प्रत्येक भाषा में सबसे छोटा समाधान है।

लीडरबोर्ड

कोड स्निपेट दिखाएं

code-golf  math  arithmetic  number-theory 
— लीक नन
स्रोत
— R
1
आप कैसे तय करते हैं कि 13 के लिए पुनरावृत्ति 076923 है और 769230 नहीं है?
— एडित्सू ने छोड़ दिया क्योंकि SE को EVIL
@aditsu क्योंकि 1/13है 0.076923076923...नहीं0.769230769230...
— लीकी नून
3
खुले तौर पर कहते हैं कि आप कभी भी एक उत्तर को स्वीकार नहीं करेंगे, यह एक सूची बनाता है। बस कुछ भी मत कहो और कभी भी एक उत्तर स्वीकार मत करो।
— डेनिस
1
आप प्रत्येक भाषा के लिए सबसे छोटा समाधान दिखाने के लिए स्टैक स्निपेट जोड़ सकते हैं।
— एडिट्स ने छोड़ दिया क्योंकि SE

जवाबों:

5

जावा, 150 बाइट्स:

String p(int n){int a=1,p;String r="";for(;n%10<1;n/=10);for(;n%2<1;n/=2)a*=5;for(;n%5<1;n/=5)a*=2;for(p=a%=n;;){p*=10;r+=p/n;if(a==(p%=n))return r;}}

जोड़ा गया व्हाट्सएप:

String p(int n){
    int a=1,p;
    String r="";
    for(;n%10<1;n/=10);
    for(;n%2<1;n/=2)
        a*=5;
    for(;n%5<1;n/=5)
        a*=2;
    for(p=a%=n;;){
        p*=10;
        r+=p/n;
        if(a==(p%=n))
            return r;
    }
}

Ungolfed, पूरा कार्यक्रम:

import java.util.Scanner;

public class A036275 {
    public static String period(int a,int n){
        if(n%10==0) return period(a,n/10);
        if(n%2==0) return period(a*5,n/2);
        if(n%5==0) return period(a*2,n/5);
        a %= n;
        int pow = a;
        String period = "";
        while(true){
            pow *= 10;
            period += pow/n;
            pow %= n;
            if(pow == a){
                return period;
            }
        }
    }
    public static String period(int n){
        return period(1,n);
    }
    public static void main(String args[]){
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        sc.close();
        System.out.println(period(n));
    }
}
— लीक नन
स्रोत
for(;;)while(2<3)हालांकि अनंत लूप होते हुए भी कम बाइट्स होंगे ! (( while(1)@Maltysen से भी कम बाइट्स )
— Marv
@Marv मैं इसे कैसे भूल सकता था? धन्यवाद!
— लीक नून
aऔर rछोरों के लिए घोषणाओं को रखो । बाइट्स बचाता है!
— कैलक्यूलेटरफलाइन
1
@CatsAreFluffy यह उन्हें दुर्गम बना देगा ...
— लीक नून
3

सीजेम, 26

riL{_XW$%A*:X|X@-}g_X#>\f/

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

स्पष्टीकरण:

यह कार्यक्रम दशमलव विस्तार की गणना में शामिल लाभांशों की एक श्रृंखला बनाता है, जब तक कि वह ऐसा लाभांश नहीं पाता है जो उसने पहले देखा है। फिर यह उस के साथ शुरू होने वाले सभी लाभांश लेता है, और पुनरावृत्ति के अंक प्राप्त करने के लिए उन्हें एन द्वारा विभाजित करता है।

ri       read the input and convert to integer (n)
L        push an empty array (will add the dividends to it)
{…}g     do … while
  _      copy the current array of dividends
  X      push the latest dividend (initially 1 by default)
  W$     copy n from the bottom of the stack
  %A*    calculate X mod n and multiply by 10
  :X     store in X (this is the next dividend)
  |      perform set union with the array of dividends
  X@     push X and bring the old array to the top
  -      set difference; it is empty iff the old array already contained X
          this becomes the do-while loop condition
_X#      duplicate the array of dividends and find the position of X
>        take all dividends from that position
\f/      swap the array with n and divide all dividends by n
— aditsu छोड़ दिया क्योंकि SE EVIL है
स्रोत
2

जेली , 12 10 बाइट्स

%³×⁵
1ÇÐḶ:

लाभांश का ट्रैक रखकर 2 बाइट्स बचाए , एक विचार जो मैंने @ aditsu के CJam उत्तर से लिया था ।

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

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

%³×⁵     Helper link. Argument: d (dividend)

%³       Yield the remainder of the division of d by n.
  ×⁵     Multiply by 10.


1ÇÐḶ:    Main link. Argument: n

1        Yield 1 (initial dividend).
 ÇÐḶ     Apply the helper link until its results are no longer unique.
         Yield the loop, i.e., everything from the first repeated result
         up to and including the last unique one.
    :    Divide each dividend by n.
— डेनिस
स्रोत
1

गेममेकर भाषा, 152 बाइट्स

केनी के जवाब के आधार पर

n=argument0;a=1r=0while(n mod 2<1){a*=5n/=2}while(n mod 5<1){a*=2n/=5}a=a mod n;p=a;while(1){p*=10r=r*10+p/n;r=r mod $5f5e107;p=p mod n;if(a=p)return r}
— Timtech
स्रोत
मुझे बस अपने दृष्टिकोण में एक बग मिला और इसे ठीक किया, इसलिए शायद आपको इसे अपडेट करने की आवश्यकता होगी।
— लीक नून
1

पर्ल 6 , 37 बाइट्स

{(1.FatRat/$_).base-repeating[1]||~0}
~0 max (1.FatRat/*).base-repeating[1]

अगर आपको इस बात की परवाह नहीं है कि यह केवल उन भाजक के साथ काम करेगा जो 64 बिट पूर्णांक में फिट होते हैं तो आप मेथड कॉल को हटा सकते हैं .FatRat।

स्पष्टीकरण:

# return ｢"0"｣ if ｢.base-repeating｣ would return ｢""｣
~0

# ｢&infix<max>｣ returns the numerically largest value
# or it's first value if they are numerically equal
max

(
  # turn 1 into a FatRat so it will work
  # with denominators of arbitrary size
  1.FatRat

  # divided by
  /

  # the input
  *

# get the second value from calling the
# method ｢.base-repeating｣
).base-repeating[1]

परीक्षा:

#! /usr/bin/env perl6
use v6.c;
use Test;

my &code = ~0 max (1.FatRat/*).base-repeating[1];
# stupid highlighter */
# Perl has never had // or /* */ comments

my @tests = (
  1    => '0',
  2    => '0',
  3    => '3',
  6    => '6',
  7    => '142857',
  11   => '09',
  13   => '076923',
  17   => '0588235294117647',
  28   => '571428',
  70   => '142857',
  98   => '102040816326530612244897959183673469387755',
  9899 => '000101020305081321345590463683200323264976260228305889483786241034447924032730578846348115971310233356904737852308313971108192746742095161127386604707546216789574704515607637135064147893726639054449944438832205273259925244974239822204263056874431760783917567431053641781998181634508536215779371653702394181230427315890493989291847661379937367410849580765733912516415799575714718658450348520052530558642287099707041115264168097787655318719062531568845337912920497019901',
);

plan +@tests;

for @tests -> $_ ( :key($input), :value($expected) ) {
  is code($input), $expected, "1/$input";
}
1..12
ok 1 - 1/1
ok 2 - 1/2
ok 3 - 1/3
ok 4 - 1/6
ok 5 - 1/7
ok 6 - 1/11
ok 7 - 1/13
ok 8 - 1/17
ok 9 - 1/28
ok 10 - 1/70
ok 11 - 1/98
ok 12 - 1/9899
— ब्रैड गिल्बर्ट b2gills
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.