19

क्यूआई के एक हालिया एपिसोड में , 142857 की पहली 5 बहुओं को मूल संख्या के रूप में वर्णित किया गया था। बेशक, उस संख्या के पास से अधिक ज्ञान रखने वाले किसी भी व्यक्ति को पता होगा कि वे संख्याएं वास्तव में चक्रीय हैं, न कि केवल एनाग्राम। लेकिन वह मुझे सोच रहा था।

कृपया एक प्रोग्राम या फ़ंक्शन लिखें जो छह या उससे कम अंकों के सभी नंबरों को आउटपुट करता है जिसमें एक उचित कारक होता है जो स्वयं का एक आरेख है। सूची निम्न संख्याओं से शुरू होनी चाहिए:

3105    (divisible by 1035)
7128    (divisible by 1782)
7425    (divisible by 2475)
8316    (divisible by 1386)
8712    (divisible by 2178)
9513    (divisible by 1359)
9801    (divisible by 1089)

यदि आप पसंद करते हैं, तो आप उन संख्याओं का पता लगा सकते हैं जिनके पास एक विपर्यय है जो संख्या का एक उचित कारक है, लेकिन ध्यान रखें कि आपके अनाग्राम से अग्रणी शून्य को बाहर करें।

यह कोड गोल्फ है, इसलिए बाइट्स में सबसे छोटा कोड जो बिना मानक खामियों के जीतता है।

code-golf integer

— नील
स्रोत

यदि पर्याप्त समय दिया जाता है, तो क्या हमारे प्रोग्राम 6 से अधिक अंकों के साथ संख्याओं को आउटपुट कर सकते हैं?

— ब्लू

1

क्या आप कृपया सूची पोस्ट कर सकते हैं?

— xnor

@muddyfish हाँ, यह स्वीकार्य होगा, जब तक कि यह किसी संख्या या आउटपुट को गलत संख्या से बाहर नहीं निकालता क्योंकि यह जाता है।

— नील

@xnor मैंने वास्तव में अभी तक पूरी सूची की गणना करने की जहमत नहीं उठाई है, हालांकि मैं इस पर किसी भी विवाद की उम्मीद नहीं कर रहा हूं।

— नील

1

मैंने अपने (उम्मीद के मुताबिक सही) आउटपुट का पास्टबिन बनाया ।

— ग्रेग मार्टिन

6

गणितज्ञ (आरईपीएल पर्यावरण), 75 74 बाइट्स

यह एक बाइट द्वारा कसने के लिए ngenisis के लिए धन्यवाद!

Select[Range[10!],Most@#~MemberQ~Last@#&[Sort/@IntegerDigits@Divisors@#]&]

Sort/@IntegerDigits@Divisors@#अपने तर्क के प्रत्येक भाजक के लिए अंकों की एक क्रमबद्ध सूची तैयार करता है; इनपुट संख्या स्वयं एक भाजक है, इसलिए अंकों की क्रमबद्ध सूची अंतिम है। Most@#~MemberQ~Lastयह पता लगाता है कि अंकों की अंतिम सॉर्ट की गई सूची अंतिम तत्व से पहले की सूची में भी दिखाई देती है या नहीं। और Select[Range[10!],...]केवल 3,628,800 तक के उन पूर्णांकों को बरकरार रखता है जो इस परीक्षा को पास करते हैं (जो कि चुना हुआ है क्योंकि यह एक बाइट 10 ⁶ से कम है )। यह मेरे कंप्यूटर पर लगभग 5 मिनट में चलता है, 494 नंबरों की एक सूची देता है, जिसमें से सबसे बड़ा 3,427,191 है; १० ^६ तक ३६२ संख्याएँ हैं , जिनमें से ९ 01 ^९ , ९ ०१ है।

— ग्रेग मार्टिन
स्रोत

खैर, यह उत्सुक नहीं है: 857142 और 571428 दो नंबर हैं, जिनमें दो स्पष्ट समुचित विभाजक हैं।

— नील

वास्तव में, 857142 में तीन उचित विभाजक एनाग्राम हैं, है ना?

— नील

लगता है कि तुम सही हो!

— ग्रेग मार्टिन

आप एक बाइट का उपयोग करके बचा सकते हैं IntegerDigits@Divisors@#।

— ngenisis

3

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

ÆḌṢ€ċṢ
ȷ6ÇÐf

इसे ऑनलाइन आज़माएं! (TIO की समय सीमा के कारण पाँच या उससे कम अंकों का उपयोग करता है)

सत्यापन

$ time jelly eun 'ÆḌṢ€ċṢ¶ȷ6ÇÐf'
[3105, 7128, 7425, 8316, 8712, 9513, 9801, 30105, 31050, 37125, 42741, 44172, 67128, 70416, 71208, 71253, 71280, 71328, 71928, 72108, 72441, 74142, 74250, 74628, 74925, 78912, 79128, 80712, 81816, 82755, 83160, 83181, 83916, 84510, 85725, 86712, 87120, 87132, 87192, 87912, 89154, 90321, 90801, 91152, 91203, 93513, 94041, 94143, 95130, 95193, 95613, 95832, 98010, 98091, 98901, 251748, 257148, 285174, 285714, 300105, 301050, 307125, 310284, 310500, 321705, 341172, 342711, 370521, 371142, 371250, 371628, 371925, 372411, 384102, 403515, 405135, 410256, 411372, 411723, 415368, 415380, 415638, 419076, 419580, 420741, 421056, 423711, 425016, 427113, 427410, 427491, 428571, 430515, 431379, 431568, 435105, 436158, 441072, 441720, 449172, 451035, 451305, 458112, 461538, 463158, 471852, 475281, 501624, 502416, 504216, 512208, 512820, 517428, 517482, 517725, 525771, 527175, 561024, 562104, 568971, 571428, 571482, 581124, 589761, 615384, 619584, 620379, 620568, 623079, 625128, 641088, 667128, 670416, 671208, 671280, 671328, 671928, 672108, 678912, 679128, 681072, 691872, 692037, 692307, 704016, 704136, 704160, 704196, 705213, 705321, 706416, 711342, 711423, 712008, 712080, 712503, 712530, 712800, 713208, 713280, 713328, 713748, 714285, 716283, 717948, 719208, 719253, 719280, 719328, 719928, 720108, 720441, 721068, 721080, 721308, 721602, 723411, 724113, 724410, 724491, 728244, 730812, 731892, 732108, 741042, 741285, 741420, 742284, 742500, 744822, 746280, 746928, 749142, 749250, 749628, 749925, 753081, 754188, 755271, 760212, 761082, 761238, 761904, 771525, 772551, 779148, 783111, 786912, 789120, 789132, 789192, 789312, 790416, 791208, 791280, 791328, 791928, 792108, 798912, 799128, 800712, 806712, 807120, 807132, 807192, 807912, 814752, 816816, 818160, 818916, 820512, 822744, 823716, 824472, 825174, 825714, 827550, 827658, 827955, 829467, 830412, 831117, 831600, 831762, 831810, 831831, 839160, 839181, 839916, 840510, 841023, 841104, 843102, 845100, 845910, 847422, 851148, 851220, 851742, 852471, 857142, 857250, 857628, 857925, 862512, 862758, 862947, 865728, 866712, 867120, 867132, 867192, 867912, 871200, 871320, 871332, 871425, 871920, 871932, 871992, 874125, 879120, 879132, 879192, 879912, 888216, 891054, 891540, 891594, 891723, 892755, 894510, 895725, 899154, 900801, 901152, 903021, 903210, 903231, 904041, 908010, 908091, 908901, 909321, 910203, 911043, 911358, 911520, 911736, 911952, 912030, 912093, 912303, 916083, 920241, 920376, 923076, 923580, 925113, 925614, 930321, 931176, 931203, 933513, 934143, 935130, 935193, 935613, 935832, 940410, 940491, 941430, 941493, 941652, 943137, 943173, 951300, 951588, 951930, 951993, 952380, 956130, 956193, 956613, 958032, 958320, 958332, 958392, 958632, 958716, 959832, 960741, 962037, 962307, 970137, 971028, 980100, 980910, 980991, 989010, 989091, 989901]

real    2m10.819s
user    2m10.683s
sys     0m0.192s

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

ȷ6ÇÐf   Main link. No arguments.

ȷ6      Yield 1e6 = 1,000,000.
  ÇÐf   Filter; keep numbers in [1, ..., 1e6] for which the helper link returns
        a truthy value.


ÆḌṢ€ċṢ  Helper link. Argument: n

ÆḌ      Compute all proper divisors of n.
  Ṣ€    Sort each proper divisor's digits.
     Ṣ  Sort n's digits.
   ċ    Count the occurrences of the result to the right in the result to the left.

— डेनिस
स्रोत

1

इस टिप्पणी के कारण आप 10.7 के ÆḌṢ€ċṢµȷ#लिए धीमी गति से भी कर सकते हैं । i7 कोर पर चलने के लिए 27 मिनट लगते हैं (यूनिक्स पर, कोई अच्छा नहीं time); सबसे बड़ा परिणाम था 6671928।

— जोनाथन एलन

मुझे लगता है कि आप जेली को प्रति प्रश्न के आधार पर संशोधित करना शुरू कर रहे हैं bert

— अल्बर्ट रेनशॉ

3

ब्रेकीलॉग , 12 बाइट्स

ℕf{k∋p.!}?ẉ⊥

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

हालांकि, कुछ भी छापने से पहले यह समय समाप्त हो सकता है (और यदि ऐसा नहीं है तो यह केवल 3105 प्रिंट करना होगा)।

व्याख्या

यह उन संख्याओं को अनिश्चित काल के लिए प्रिंट करता है, जैसा कि लेखक ने कहा था कि यह स्वीकार्य था कि यह कार्यक्रम 6 अंकों से बड़ा होगा।

यह रास्ता बहुत धीमा है; आप इस कार्यक्रम का उपयोग कर सकते हैं (और 8300किसी भी तरह से बदल सकते हैं N) की संख्या को सख्ती से अधिक से छपाई शुरू करने के लिए N।

ℕ               Natural number: The Input is a natural number
 f              Factors: compute the factors of the Input
  {     }?      Call a predicate with the main Input as its output and the factors as Input
   k            Knife: remove the last factor(which is the Input itself)
    ∋           In: take one of those factors
     p.         Permute: the Output is a permutation of that factor
       !        Cut: ignore other possible permutations
         ?ẉ     Writeln: write the Input to STDOUT, followed by a line break
           ⊥    False: backtrack to try another value for the Input

जैसा कि @ ais523 ने बताया, हमें कई बार छपाई से बचने के लिए एक कट की आवश्यकता होती है यदि इसके कई कारक इसके क्रमपरिवर्तन हैं।

— Fatalize
स्रोत

मेरे पास एक मसौदा के रूप में सहेजा गया समान उत्तर है। दुर्भाग्य से, मुझे नहीं लगता कि यह काम करता है क्योंकि यह 857142 जैसी संख्याओं को एक से अधिक बार प्रिंट करेगा, और लेखक ने कहा कि यह अस्वीकृत है। मुझे लगता है कि कार्यक्रम में कहीं न कहीं कटौती की जरूरत है, तीन पात्रों को जोड़ने की संभावना है।

वास्तव में 4 वर्ण जोड़ना ... धन्यवाद, इसके बारे में भूल गए।

— घातक

3

जावास्क्रिप्ट (ईएस 6), 103 … 96 94 बाइट्स

एक अनाम फ़ंक्शन जो मिलान पूर्णांक की सरणी देता है।

_=>[...Array(1e6).keys(F=i=>[...i+''].sort()+0)].filter(n=>n*(R=i=>F(n/i--)==F(n)||R(i)%i)(9))

प्रारूपित और टिप्पणी की गई

_ =>                                // main function, takes no input
  [...Array(1e6).keys(              // define an array of 1,000,000 entries
    F = i => [...i + ''].sort() + 0 // define F: function used to normalize a string by
  )]                                // sorting its characters
  .filter(n =>                      // for each entry in the array:
    n * (                           // force falsy result for n = 0
      R = i =>                      // define R: recursive function used to test if
        F(n / i--) == F(n) ||       // n/i is an anagram of n, with i in [1 … 9]
        R(i) % i                    // F(n/1) == F(n) is always true, which allows to stop
    )                               // the recursion; but we need '%i' to ignore this result
    (9)                             // start recursion with i = 9
  )                                 //

विभाजक आँकड़े

6 अंकों पूर्णांक के लिए, से प्रत्येक अनुपात 2को 9कोई मिलता-जुलता पूर्णांक के बीच nऔर उसके अनाग्राम एक बार कम से कम का सामना करना पड़ा है। लेकिन उनमें से कुछ बस कुछ ही बार दिखाई देते हैं:

 divisor | occurrences | first occurrence
---------+-------------+---------------------
    2    |    12       | 251748 / 2 = 125874
    3    |    118      | 3105   / 3 = 1035
    4    |    120      | 7128   / 4 = 1782
    5    |    4        | 714285 / 5 = 142857
    6    |    34       | 8316   / 6 = 1386
    7    |    49       | 9513   / 7 = 1359
    8    |    2        | 911736 / 8 = 113967
    9    |    23       | 9801   / 9 = 1089

परीक्षा

नीचे दिया गया परीक्षण सीमा तक सीमित है [1 ... 39999]ताकि इसे पूरा करने में बहुत अधिक समय न लगे।

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

let f =

_=>[...Array(4e4).keys(F=i=>[...i+''].sort()+0)].filter(n=>n*(R=i=>F(n/i--)==F(n)||R(i)%i)(9))

console.log(f())

स्निपेट का विस्तार करें

— Arnauld
स्रोत

बहुत तेज़ संस्करण, लेकिन कुछ अधिक लंबा _=>[...Array(1e6).keys()].filter(n=>n&&![...Array(9)].every(_=>n%++i||(F=i=>[...i+''].sort()+'')(n/i)!=F(n),i=1)):।

— नील

@ आपके सुझाव ने मुझे अद्यतन संस्करण के लिए प्रेरित किया जो बहुत तेज़ और 1 बाइट छोटा है। दुःख की बात से सभी divisors 2के लिए 9आवश्यक हैं ( 8के लिए केवल दो बार इस्तेमाल किया जा रहा 911736है और 931176)।

— अर्नुलद

2

पाइके, 14 बाइट्स

~1#`Sili-m`mS{

यहाँ कोशिश करो!

इस तरह से सभी संख्याओं का उत्पादन करना चाहिए लेकिन कई बार।

यहाँ एल्गोरिथ्म का परीक्षण करें!

— नीला
स्रोत

2

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

{grep {grep .comb.Bag===*.comb.Bag,grep $_%%*,2..^$_}

बहुत धीमी गति से बल समाधान।

यह एक आलसी अनुक्रम देता है, इसलिए मैं पहले कुछ परिणामों की जांच कर सकता था, लेकिन यह उचित समय में सभी परिणामों तक नहीं पहुंचेगा। (क्या मुझे इसे गैर-प्रतिस्पर्धी के रूप में चिह्नित करना चाहिए?)

— SMLS
स्रोत

2

शुद्ध बैश , 128 126 122 121 120 बाइट्स

for((;n<6**8;)){
c=0
for((j=++n;j;j/=10)){((c+=8**(j%10)));}
for k in ${a[c]};{((n%k))||{ echo $n;break;};}
a[c]+=\ $n
}

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

(यह कार्यक्रम यथोचित रूप से तेज़ है - मेरे मैकबुक पर सभी 6-अंकीय संख्याओं के माध्यम से चलने के लिए केवल 14 मिनट लगते हैं। दुर्भाग्य से TIO बार बाहर है क्योंकि यह 1 मिनट की रनिंग-टाइम सीमा लगाता है, जिससे गुजरने के लिए केवल पर्याप्त समय है 5-अंकीय संख्या या तो।)

बैश + यूनिक्स उपयोगिताओं, 117 बाइट्स

for n in {1..999999}
{
c=$(bc<<<0`sed 's/\(.\)/+8^\1/g'<<<$n`)
for k in ${a[c]};{((n%k))||echo $n;}
a[c]+=\ $n
}|uniq

यह शुद्ध बैश संस्करण की तुलना में छोटा है, लेकिन थोड़ा सा धीमा होने के कारण सभी भाग में अच्छा है।

— मिशेल स्पेक्टर
स्रोत

1

05AB1E , 15 बाइट्स

[¼¾œJv¾Ñ¨Dyåi¾,

स्पष्टीकरण:

[               # Start of infinite loop
 ¼              # Increase counter_variable by 1
  ¾œJv          # Loop through all the permutations of counter_variable
      ¾Ñ¨Dyå    # Check if a divisor of counter_variable is a permutation of counter_variable
            i¾, # If so, print counter_variable

इसे ऑनलाइन आज़माएं! (यह काम नहीं करेगा, यह समय समाप्त हो जाएगा)

— Okx
स्रोत

1

जाप , 23 बाइट्स

L³o f_ì á ¤fg mì f!vZ l

इसे ऑनलाइन आज़माएं! ध्यान दें कि लिंक किए गए कोड केवल 1e4 तक की गणना करते हैं क्योंकि TIO पर 1e6 बार।

— ओलिवर
स्रोत

0

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

s=sorted;print filter(None,[[x for i in range(x)if s(`x`)==s(`i`)and x%i<1]for x in range(10**6)])

— Trelzevir
स्रोत

ऐसा नहीं होना चाहिए 10**6?

— नील

हाँ धन्यवाद।

— ट्रेलज़ेविर

1

मुझे लगता है कि x%i==0बस हो सकता है x%i<1।

— यति

0

05AB1E , 12 10 बाइट्स

अनंत लूप के कारण TIO पर टाइम्स आउट।
2 बाइट्स सहेजे गए क्योंकि हम ओपीएस टिप्पणी के अनुसार 6-अंकीय संख्याओं से अधिक उत्पादन कर सकते थे।

[NÑ¨€{N{å–

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

व्याख्या

[            # infinite loop with iteration index N
 NÑ          # get a list of all divisors of N
   ¨         # remove N from that list
    €{       # sort each entry in the list of divisors
      N{     # sort N
        å–   # output N if N is in the list

— Emigna
स्रोत

0

बैच, 263 बाइट्स

@echo off
set e=exit/b
for /l %%n in (1,1,999999)do call:n %%n
%e%
:n
call:c %1 1 0
for /l %%f in (2,1,9)do call:c %1 %%f %c%&&echo %1&&%e%
%e%
:c
set/ar=%1%%%2,d=%1/%2,c=-%3
if %r% gtr 0 %e%1
:l
set/ac+=1^<^<d%%10*3,d/=10
if %d% gtr 0 goto l
%e%%c%

धीरे। जैसा कि, मेरे पीसी पर समाप्त होने में एक दिन लगता है। स्पष्टीकरण: cसबरूटीन अपने पहले दो तर्कों को विभाजित करता है। यदि शेष शून्य है, तो यह प्रत्येक अंक के लिए 8 की nth शक्तियों के योग की गणना करके परिणाम के हैश की गणना करता है। यह हैश फ़ंक्शन, बैश उत्तर से चोरी हो जाता है, केवल एनाग्राम पर टकराता है। (यह सात अंकों की संख्या के लिए काम करेगा, लेकिन मेरे पास सभी पखवाड़े नहीं हैं।) तीसरा तर्क घटाया गया है, और यदि यह शून्य है तो उप-सत्य एक सत्य परिणाम के साथ बाहर निकलता है। nसबरूटीन कॉल cसबरूटीन हैश आठ गुना अधिक हैश तुलना करने के लिए गणना करने के लिए एक बार, तो; यदि यह एक टक्कर पाता है, तो यह प्रिंट करता है nऔर सबरूटिन को जल्दी से बाहर निकालता है।

— नील
स्रोत

विपर्यय कारक

गणितज्ञ (आरईपीएल पर्यावरण), 75 74 बाइट्स

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

सत्यापन

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

ब्रेकीलॉग , 12 बाइट्स

व्याख्या

जावास्क्रिप्ट (ईएस 6), 103 … 96 94 बाइट्स

प्रारूपित और टिप्पणी की गई

विभाजक आँकड़े

परीक्षा

पाइके, 14 बाइट्स

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

शुद्ध बैश , 128 126 122 121 120 बाइट्स

बैश + यूनिक्स उपयोगिताओं, 117 बाइट्स

05AB1E , 15 बाइट्स

जाप , 23 बाइट्स

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

05AB1E , 12 10 बाइट्स

बैच, 263 बाइट्स