सोमवार संख्या उत्पन्न करें

35

सोमवार संख्या , जैसा कि पज़लिंग के इस सवाल पर गामो द्वारा परिभाषित किया गया है , निम्नलिखित तीन गुणों के साथ सकारात्मक पूर्णांक एन हैं:

  • N के दशमलव प्रतिनिधित्व में अंक 0 नहीं है
  • N के दशमलव प्रतिनिधित्व में दो बार कोई अंक नहीं होता है
  • एन हर अंक डी से विभाज्य है जो उसके दशमलव प्रतिनिधित्व में होता है

ध्यान दें कि इन्हें वैकल्पिक रूप से, OEIS में लिंच-बेल संख्या के रूप में जाना जाता है ।

उदाहरण:

  • 15सोमवार की संख्या है, क्योंकि यह दोनों से विभाज्य है 1और 5अन्य दो स्थितियों को संतुष्ट करता है
  • 16नहीं है, क्योंकि यह विभाज्य नहीं है 6।
  • संख्या 22नहीं है, क्योंकि यद्यपि यह शर्तों 1 और 3 को संतुष्ट करता है, यह स्थिति 2 को विफल करता है।

यहां आपको आरंभ करने के लिए पहले 25 सोमवार की सूची दी गई है (कुल 548 हैं):

1 2 3 4 5 6 7 8 9 12 15 24 36 48 124 126 128 128 132 135 162 168 175 184 216 248

यहाँ चुनौती सबसे छोटे कोड को लिखने की है जो सोमवार संख्याओं का पूर्ण अनुक्रम उत्पन्न करता है, 1 अप करने से लेकर 9867312 तक (उस सवाल पर सबसे बड़ा संभव साबित होता है)।

आपके कोड को कोई इनपुट नहीं लेना चाहिए, और आउटपुट को अपनी पसंद के साथ STDOUT या समतुल्य होना चाहिए। सभी सामान्य कोड-गोल्फ नियम लागू होते हैं, और स्टैंडर्ड लोफॉल्स निषिद्ध हैं।

लीडरबोर्ड

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

code-golf  number  sequence 
— AdmBorkBork
स्रोत
5
— FryAmTheEggman
1
लिंच-बेल नंबर के रूप में भी जाना जाता है ।
— Geobits
@Geobits धन्यवाद - मैं इसे किसी कारण के लिए OEIS पर नहीं पा सका।
— AdmBorkBork
8
आपको कल इस चुनौती को पोस्ट करना चाहिए था ...
— mbomb007
2
@ mbomb007 मैं होता - आज सुबह तक गामो का सवाल नहीं देखा, हालांकि!
— AdmBorkBork

जवाबों:

1

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

ȷ7Dg⁼QƲƇ

आठ मिनट के भीतर स्थानीय रूप से चलता है।

इसे ऑनलाइन आज़माएं! (छह अंकों या उससे कम संख्याओं को खोजने के लिए संशोधित)

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

ȷ7Dg⁼QƲƇ  Main link. No arguments.

ȷ7        Set the return value to 10**7.
       Ƈ  Comb; promote 10**7 to [1, ..., 10**7], then keep only those n in the range
          for which the link to the left returns a truthy value.
      Ʋ     Combine the four links to the left into a monadic chain.
  D           Decimal; yield n's digit array in base 10.
   g          Take the GCD of each digit and n.
     Q        Yield the unique digits of n.
    ⁼         Test both results for equality.
— डेनिस
स्रोत
16

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

print[n for n in range(1,9**9)if(n<10**len(set(`n`)))>any(n%(int(d)or.3)for d in`n`)]

एक सूची प्रिंट करता है।

मैं मूल रूप से पिछली चुनौतियों के लिए अपने दो उत्तर जोड़ रहा हूं:

स्थितियों को बेहतर ढंग से जोड़कर 1 बाइट के लिए xsot का धन्यवाद।

— XNOR
स्रोत
आप एक बाइट बचा सकते हैं:print[n for n in range(1,9**9)if(n<10**len(set(`n`)))>any(n%(int(d)or.3)for d in`n`)]
— xsot
11

पर्ल, 61 47 बाइट्स

46 बाइट्स कोड + 1 बाइट कमांड लाइन पैरामीटर।

/(.).*\1|0/||1*s/./$_%$&/rge||print for 1..1e7

उपयोग:

perl -l entry.pl

व्याख्या

/(.).*\1|0/ 1 रिटर्न देता है अगर नंबर-अंडर-टेस्ट में डुप्लिकेट चरित्र या 0 होता है

s/./$_%$&/rgeप्रत्येक अंक को संख्या-अंडर-परीक्षण% के मान के साथ अंकों को बदलता है। उदाहरण के लिए, 15 -> 00, 16 -> 04 (क्योंकि 16% 6 = 4)। इसका मतलब यह है कि कोई भी इनपुट जो उसके सभी अंकों से विभाज्य है, सभी में 0 अंक शामिल होंगे, अन्यथा इसमें एक अंक> 0 होगा। इसे एक संख्या के रूप में मानने के लिए, हम * 1, जिसका अर्थ है कि कोई भी नंबर-अंडर-टेस्ट इस ब्लॉक के लिए 0 लौटाएगा यदि यह उसके सभी अंकों से विभाज्य है, अन्यथा> 0।

इन दो कथनों और प्रिंट को 'या' के साथ अलग करके, यदि दोनों में से कोई भी पहली स्थिति वापस आती है> 0, स्थिति मैच और अभिव्यक्ति के बाद के भागों का मूल्यांकन नहीं करेगी। यदि और केवल यदि दोनों पिछली स्थितियां 0 हैं, तो प्रिंट निष्पादित होगा। -lझंडा प्रत्येक प्रिंट के बाद एक नई लाइन को जोड़ने के लिए सुनिश्चित करता है।

— Jarmex
स्रोत
बहुत अच्छा। आप इसे पर्ल 5.10 बनाकर और sayइसकी बजाय print+ -l:-)
— xebtl
सलाह के लिये धन्यवाद! मैंने सोचा कि say पहले एक स्पष्ट घोषणा की आवश्यकता है ?
— जरमेक्स
@Jarmex मैंने परंपरा को शुरू करने use feature 'say'या use 5.012मुफ्त में लेने के इर्द-गिर्द शुरू किया होगा - मैं हमेशा इसका उल्लेख करता हूं कि मैं यह कब करता हूं, और किसी ने भी इसे चुनौती नहीं दी है। मैंने देखा है कि कुछ अन्य लोग भी ऐसा ही करते हैं :)
— हॉब्स
2
@hobbs मेटा पर इस उत्तर कहते हैं, "अब इतने पर और यहां के लिए आम सहमति थी" -M5.010, जब जरूरत, नि: शुल्क है ""।
— xebtl
2
का उपयोग करना mapऔर sayयह 43 से नीचे हो जाता है: इसे ऑनलाइन आज़माएं!
— Xcali
10

पायथ, २२ २१

f&.{`T!f%T|vY.3`TS^T7

अनावश्यक स्वरूपण के 1 बाइट को बंद करने के लिए जकुबे का धन्यवाद।

संबंधित प्रश्न के इस सीडब्ल्यू जवाब से भारी प्रेरित ।

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

जब तक आप 7 से छोटे नंबर का उपयोग नहीं करते हैं, मैं इसे ऑनलाइन नहीं करने की सलाह दूंगा ... मैंने इसे इस लिंक में 2 पर सेट किया है।

से फिल्टर 1करने के लिए 10^7-1जो सभी आवश्यक मूल्यों को शामिल किया गया। यह संस्करण स्मृति त्रुटि का कारण बन सकता है अगर यह सूची नहीं बना सकता है S^T7, जो कि list(range(1,10**7))अजगर 3 में समान है (हालांकि, यह मेरे लिए ठीक काम करता है)। यदि हां, तो आप कोशिश कर सकते हैं:

.f&.{`Z.x!s%LZjZT0548

जो पहले 548 सोमवार संख्याओं का पता लगाता है। यह 0संख्या में s के लिए जाँच करने के लिए एक और तरीका भी प्रदर्शित करता है, इसके स्थान पर उन्हें बदलने की .3कोशिश करता है। इस संस्करण का श्रेय पूरी तरह से जकुबे को जाता है। (ध्यान दें कि यह अभी भी ऑनलाइन दुभाषिया के लिए धीमा है)

— FryAmTheEggman
स्रोत
1
यहां एक अलग समाधान है: .f&.{`Z.x!s%LZjZT0548यह आपके समय-लूप दृष्टिकोण की तुलना में काफी अधिक तेज (4x - 5x) है और इसकी लंबाई भी केवल 21 बाइट्स है।
— जक्यूब
1
@Jakube Backticks टिप्पणियों में एक दर्द है कि वे नहीं हैं? : P बहुत बहुत धन्यवाद!
— FryAmTheEggman 18
उम्म .. आपका समाधान काम नहीं लगता है .. 100 की सीमा में आपके TIO लिंक में, यह दिखाता है 55, 66, 77, 88, 99, डुप्लिकेट अंकों के साथ सभी नंबर ..
— केविन क्रूज़सेन
1
@KevinCruijssen दुर्भाग्य से, पायथ को कई बार अपडेट किया गया है क्योंकि मैंने इस पोस्ट को बनाया है, मुझे नहीं पता कि क्या बदल गया है। आप पेस्ट में देख सकते हैं कि यह पहले स्पष्ट रूप से काम करता था। मुझे लगता है कि इसे .{बदल दिया गया हो सकता है , क्योंकि इसकी जगह यह {Iकाम करने लगता है।
— FryAmTheEggman
@FryAmTheEggman आह, मैंने पेस्ट नहीं देखा था। यह वास्तव में लगभग तीन साल है, इसलिए कोई आश्चर्य नहीं कि चीजें बदल गई हैं। उस मामले में +1, क्योंकि पेस्ट साबित होता है कि यह काम कर रहा है। :)
— केविन क्रूज़सेन
9

जीएस 2 , 20 19 बाइट्स

gs2 बाइट्स की एक विस्तृत श्रृंखला का उपयोग करता है, न कि केवल प्रिंट करने योग्य ascii chracters। मैं हेक्स में अपना समाधान प्रस्तुत करूंगा।

17 7d 2f 24 65 f1 c8 24 d8 62 e9 65 f4 24 40 90 71 f3 54

यहाँ कुछ स्पष्टीकरण है। gs2 एक स्टैक आधारित भाषा है, इसलिए कोई चर नहीं हैं। (4 रजिस्टरों से अलग, मैं इनमें से एक का उपयोग करता हूं)

17         # push constant 7
7d         # 10 raised to the power
2f         # create an array of numbers from 1 to n

    24     # get digits of number into array
    65     # calculate product of array
f1         # filter array by previous block of 2 instructions

    c8     # save top of stack to register a
    24     # get digits of number into array
        d8 # tuck register a under top of stack
        62 # boolean divisibility test 
    e9     # map array using previous block of 2 instructions
    65     # calculate product of array
f4         # filter array by previous block of 5 instructions 

    24     # get digits of number into array
    40     # duplicate top of stack
    90     # remove duplicates from array
    71     # test equality
f3         # filter array by previous block of 4 instructions
54         # show contents of array separated by line breaks
— पुनरावर्ती
स्रोत
8

पायथन 3, 132 128 114 111 111 बाइट्स

i=0
while i<1e8:
 j=str(i)
 if len(set(j))+2==len(j)+('0'in j)+all(i%int(k)<1 for k in j):print(i)
 i+=1

548 सोमवार नंबर हैं।

— Zach गेट्स
स्रोत
1
आप के 1e8बजाय भी इस्तेमाल कर सकते हैं 9**9?
— डोम हेस्टिंग्स
में जगह निकालें '0' not। इसके अलावा, i%int(k)==0शायद हो सकता है i%int(k)<1?
— mbomb007
धन्यवाद। मेरा मतलब है कि वापस जोड़ने के लिए @ mbomb007
— Zach गेट्स
आप उपयोग कर सकते हैं j=`i`।
— mbomb007
एक और -6 उपयोग के लिएif len(set(j))+2==len(j)+('0'in j)+all(i%int(k)<1 for k in j)
— lirtosiast
7

एपीएल, 44 39 37 बाइट्स

{0=+/(⊢|∘⍵,0∘∊,⍴∘⊢≠⍴∘∪)⍎¨⍕⍵:⍵⋄⍬}¨⍳1e7

Ungolfed:

{
 x ← ⍎¨⍕⍵⋄                    ⍝ Define x to be a vector of the digits of ⍵
 0=+/(⊢|∘⍵,0∘∊,⍴∘⊢≠⍴∘∪)x:   ⍝ No zeros, all digits divide ⍵, all unique?
 ⍵⋄⍬                          ⍝ If so, return the input, otherwise null
}¨⍳1e7                        ⍝ Apply to the integers 1..1E7

मोरिस ज़ुक्का के लिए धन्यवाद 7 बाइट्स सहेजे गए!

— एलेक्स ए।
स्रोत
मुझे एपीएल से प्यार है। इसलिए।
— कॉनर ओ'ब्रायन
मुझे लगता है कि आप इसे फ़ंक्शन ट्रेनों का उपयोग करके 5 बाइट्स बचा सकते हैं: {0 = + / / (can | ∘⍵, 0 it, ⍴∘∪ ⍴∘⊢ ⍴∘∪) x ⍎¨⍕⍵ ⍵⋄⍬: ⍵⋄⍬} it 1e7
— मोरिस ज़ुका
@MorisZucca बहुत बढ़िया, सुझाव के लिए धन्यवाद!
— एलेक्स ए।
मैंने अभी देखा कि इस रूप में x ← की कोई आवश्यकता नहीं है, इसलिए 2 और बाइट्स बचाए गए हैं! :-)
— मोरिस ज़ूका
@MorisZucca आप एक एपीएल गोल्फ मशीन हैं! एक बार फिर धन्यवाद!
— एलेक्स ए।
6

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

For(X,1,ᴇ7
int(10fPart(X10^(-randIntNoRep(1,1+int(log(X->D
SortA(∟D
If X>9
If not(max(remainder(X,Ans+2Xnot(Ansmin(ΔList(∟D
Disp X
End

∟Dअंकों की सूची है, जो गणित और randIntNoRep(कमांड (सभी 1और पूर्णांकों के बीच यादृच्छिक क्रमांकन) का उपयोग करके उत्पन्न होती है 1+int(log(X। सभी स्थितियों के संतुष्ट होने की जांच करने के लिए मैं बयानों की एक जटिल श्रृंखला का उपयोग करता हूं:

   min(ΔList(∟D        ;Zero if repeated digit, since ∟D was sorted ascending
Ans                    ;Multiplies the unsorted copy of ∟D by the minimum from above
                       ;(Lists are different dimensions; we can't elementwise AND)
                       ;Will contain a 0 if there's a 0 digit or a repeated digit
      not(             ;If there's a zero,
Ans+2X                 ;Add 2X to that pos. in the list, failing the test:

    max(remainder(X,   ;Zero iff all digits divide X and 2X wasn't added
not(

उन अंकों को विफल करने के लिए जो बार-बार अंक या शून्य अंक हैं, मैं शून्य को प्रतिस्थापित करता हूं 2X, क्योंकि Xकभी भी विभाज्य नहीं होता है 2X।

विशेष-मामले के लिए 1 ~ 9 (क्योंकि ΔList(एक-तत्व सूची त्रुटियों पर) मैं Ifचौथी पंक्ति में कथन का उपयोग पांचवें पंक्ति में चेक को छोड़ने के लिए करता Xहूं , स्वचालित रूप से सभी .9 प्रदर्शित करता है ।

आउटपुट संख्या को नईलाइनों द्वारा अलग किया जाता है।

— lirtosiast
स्रोत
5

गणितज्ञ १०५

l=Length;Cases[Range@9867312,n_ /;(FreeQ[i=IntegerDigits@n,0]&&l@i== l@Union@i&&And@@(Divisible[n,#]&/@i))]
  • IntegerDigitsको तोड़ता है n, अपने अंकों की एक सूची में i।
  • FreeQ[i,0] जाँच करता है कि सूची में कोई शून्य हैं या नहीं।
  • Length[i]==Length[Union[i]] जाँच करता है कि कोई दोहराया अंक नहीं हैं।
  • And@@(Divisible[n,#]&/@i)जाँचता है कि प्रत्येक अंक एक भाजक है n।

{1, 2, 3, 4, 5, 6, 7, 8, 9, 12, 15, 24, 36, 48, 124, 126, 128, 132, 135, 162, 168, 175, 184, 216, 248 , 264, 312, 315, 324, 384, 396, 412, 432, 612, 624, 648, 672, 728, 735, 784, 816, 824, 864, 864, 936, 1236, 1248, 1296, 1326, 1326, 1362, 1368, 1368, 1368, 1368, 1368, 1368, 1368 , 1395, 1632, 1692, 1764, 1824, 1926, 1935, 1962, 2136, 2184, 2196, 2316, 2364, 2436, 2916, 3126, 3162, 3168, 3195, 3116, 3216, 3264, 3276, 3492, 3612, 3624, 3624, 3624। , 3648, 3816, 3864, 3915, 3924, 4128, 4172, 4236, 4368, 4392, 4632, 4872, 4896, 4896, 4932, 4968, 6132, 6192, 6312, 6324, 6384, 6432, 6912, 6984, 8136, 8496, 8496। , 8736, 9126, 9135, 9162, 9216, 9315, 9324, 9432, 9612, 9648, 9864, 12384, 12648, 12768, 12864, 13248, 13824, 13896, 13968, 14328, 14728, 14832, 16248, 16824, 17248, 17248 , 18264, 18432, 18624, 18936, 19368, 21384, 21648, 21784, 21864, 23184, 24168, 24816, 26184, 27384, 28716, 29736, 31248, 31824, 31896, 31968, 32964, 34184, 34128, 3412837128, 37296, 37926, 38472, 39168, 39816, 41328, 41832, 42168, 42816, 43128, 43176, 46128, 46872, 48216, 48312, 61248, 61824, 62184, 64876, 68712, 72184, 73164, 73164, 73164। 73962, 78624, 79128, 79632, 81264, 81432, 81624, 81936, 82416, 84216, 84312, 84672, 87192, 89136, 89712, 91368, 91476, 91728, 92736, 93168, 98386, 98136, 89136, 89136 124368, 126384, 129384, 132648, 132864, 132984, 134928, 136248, 136824, 138264, 138624, 139248, 139824, 142368, 143928, 146328, 146832, 148392, 148632, 149868, 149832, 168432, 168432, 168432 164832, 167328, 167832, 168432, 172368, 183264, 183624, 184392, 184632, 186432, 189432, 192384, 193248, 194248, 194328, 198432, 213648, 213864, 2184, 2184, 2184, 2184, 2184, 2184, 2184। 231864, 231984, 234168, 234816, 236184, 238416, 239184, 241368, 243168, 243768, 243816, 247916, 248136,248976, 261384, 263184, 273168, 281736, 283416, 284136, 291384, 293184, 297864, 312648, 312864, 312984, 314928, 316248, 316824, 318224, 3186248, 319248, 319248, 319248 326184, 328416, 329184, 341928, 342168, 342816, 346128, 348192, 348216, 348912, 349128, 361248, 361824, 361872, 362184, 364128, 367288, 377248, 38686, 38126, 38126, 38616, 38616, 38616, 38616, 38616, 386163 391248, 391824, 392184, 394128, 412368, 413928, 416328, 416832, 418632, 418632, 419832, 419832, 421368, 423816, 427816, 427896, 428136, 428136, 43,288, 43,288, 43,288,188,188,188,188,183,173,333 है। 438912, 439128, 461328, 461832, 463128, 468312, 469728, 478296, 478632, 481392, 481632, 482136, 483192, 483216, 483672, 483912, 486312, 499332, 49328, 49328, 49328, 4932328, 4932328 613872, 614328, 614832, 618432, 621384, 623184, 614784,627984, 631248, 631824, 632184, 634128, 634872, 641328, 641832, 643128, 648312, 671328, 671832, 681432, 684312, 689472, 732648, 732816, 744696, 624628, 624628, 6246,288, 62,288, 62,288,288,288,278,278,273,278,278,278,273,278,273,278,273 है। 813624, 814392, 814632, 816432, 819432, 823416, 824136, 824376, 831264, 831624, 832416, 834192, 834916, 834912, 836472, 841392, 841692, 842136, 843136, 843132, 84436, 843132 873264, 891432, 894312, 897624, 912384, 913248, 913824, 914832, 914832, 918432, 921384, 923184, 912864, 931248, 932184, 934184, 941188, 94328, 943232, 9413328, 94328, 9413124 1289736, 1293768, 1369872, 1372896, 1376928, 1382976, 1679328, 1687832, 1638396, 1738296, 1823976, 1863792, 1876392, 1923768, 1936872, 198276, 2187676, 2138986, 2138886, 2138886, 2138886, 2138886 2937816, 2978136, 2983176,3186792, 3187296, 3196872, 3271968, 3297168, 3298176, 3619728, 3678192, 3712968, 3768912, 3796128, 3816292, 3817292, 3867192, 3869712, 3927168, 3928176, 617176, 617176, 617617 6893712, 6913872, 6971328, 6971832, 7168392, 7198632, 7231896, 7291368, 7329168, 7361928, 7392168, 7398216, 7613928, 7839136, 7829136, 7829196, 7829192, 78298322, 78298322 8163792, 8176392, 8219736, 8312976, 8367912, 8617392, 8731296, 8796312, 8912736, 8973216, 9163728, 9176328, 9182376, 9231768, 9237868, 923717, 9277339, 9277337 9812376, 9867312}6387192, 6389712, 6391728, 6719328, 6719832, 6731928, 6893712, 6913872, 6971328, 6971832, 7168392, 7198632, 7291368, 7299168, 7329168, 7369168, 7398287, 7398287, 7398287, 739828 7891632, 7892136, 7916328, 7916832, 7921368, 8123976, 8163792, 8176392, 8219736, 8312976, 8367912, 8617392, 8731296, 8979712, 897712, 897716, 9167166, 9166169, 9617832, 9678312, 9718632, 9723168, 9781632, 9782136, 9812376, 9867312}6387192, 6389712, 6391728, 6719328, 6719832, 6731928, 6893712, 6913872, 6971328, 6971832, 7168392, 7198632, 7291368, 7299168, 7329168, 7369168, 7398287, 7398287, 7398287, 739828 7891632, 7892136, 7916328, 7916832, 7921368, 8123976, 8163792, 8176392, 8219736, 8312976, 8367912, 8617392, 8731296, 8979712, 897712, 897716, 9167166, 9166169, 9617832, 9678312, 9718632, 9723168, 9781632, 9782136, 9812376, 9867312}8796312, 8912736, 8973216, 9163728, 9176328, 9176832, 9182376, 9231768, 9237816, 9278136, 9283176, 9617328, 9667832, 9718632, 9718632, 9723616, 978168, 9781688796312, 8912736, 8973216, 9163728, 9176328, 9176832, 9182376, 9231768, 9237816, 9278136, 9283176, 9617328, 9667832, 9718632, 9718632, 9723616, 978168, 978168

Length[%]

548

— DavidC
स्रोत
मैं की तरह उम्मीद वहाँ mathematica में एक तरह से कम बाइट में बड़ी संख्या प्राप्त करने के लिए है, 9^9या 1e8या कुछ और
— FryAmTheEggman
मुझे आश्चर्य है कि Mathematica के पास इसके लिए अंतर्निहित नहीं है ;-)। Unionडुप्लिकेट के लिए जाँच करने के साथ अच्छी चाल ।
— AdmBorkBork
@FryAmTheEggman, आप 9 ^ 9 के लिए गणितज्ञ की अनुमति के बारे में सही हैं। लेकिन यह 548 सोमवार संख्या से अधिक नहीं लौटेगा?
— डेविड सी.पी.
जैसा कि प्रश्न में कहा गया है, ऊपरी सीमा के रूप में दिए गए सोमवार से अधिक संभव नहीं है।
— FryAmTheEggman
5

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

[x|x<-[1..9^9],all(\a->a>'0'&&mod x(read[a])+sum[1|y<-show x,y==a]<2)$show x]

उपयोग उदाहरण (पहले 20 नंबर):

take 20 $ [x|x<-[1..9^9],all(\a->a>'0'&&mod x(read[a])+sum[1|y<-show x,y==a]<2)$show x]

[1,2,3,4,5,6,7,8,9,12,15,24,36,48,124,126,128,132,135,162]

यह कैसे काम करता है: 1 से 9 ^ 9 तक सभी नंबरों पर पुनरावृति और शर्तों की जांच करें। वर्तमान संख्या xको show xवर्णों की सूची के रूप में संचालित करने के लिए इसे स्ट्रिंग प्रतिनिधित्व ( ) में बदल दिया गया है ।

— nimi
स्रोत
5

आर, 99 बाइट्स

for(n in 1:1e8){i=1:nchar(n);if(all(table(d<-(n%%10^i)%/%10^(i-1))<2)&!0%in%d&all(!n%%d))cat(n,"")}

थोड़ा कम गोल्फ:

for(n in 1:1e8){
    i = 1:nchar(n)
    d = (n%%10^i)%/%10^(i-1) # Digits of n
    if(all(table(d)<2) # No digits is present more than once 
      & !0%in%d        # 0 is not one of the digits
      & all(!n%%d))    # All digits are divisors of n
    cat(n,"")
    }
— plannapus
स्रोत
5

पर्ल, 90 75 70 बाइट्स

print+($_,$/)x(grep(!/(\d).*\1|0/,$_)&s/./!$&||$_%$&/ger<1)for 1..1e7
— स्टीव
स्रोत
1
आह, मैं ठगने की जाँच के लिए \ 1 चाल को याद किया, अच्छा। क्या आप एक बयान संशोधक और एक टर्नरी प्रिंट के साथ अधिक बचत कर सकते हैं?
— डोम हेस्टिंग्स
@DomHastings धन्यवाद, अब आपके सुझाव का उपयोग करते हुए और अधिक गोल्फ
— स्टीव
अच्छा, मुझे लगता है कि आप कुछ और भी बचा सकते हैं, क्योंकि आपको ^और आपके $आस-पास की आवश्यकता नहीं है , आप पहले वाले को एक के साथ बदल सकते हैं और मुझे लगता है कि अंतिम बेकार है (हालांकि केवल परीक्षण किया गया है । ..)। अच्छी तरह से और वास्तव में मेरा स्कोर पिटाई! :)0grep&&s/./&|01e3
— डोम हेस्टिंग्स
1
@DomHastings धन्यवाद, अपने गोल्फ सुझावों के साथ 70 से नीचे।
— स्टीव
Grep से छुटकारा पाकर इसे थोड़ा और नीचे ले जाना (अनावश्यक - पैटर्न मैच बिना grep का ध्यान रखता है) और बाकी को एक नक्शे में फिर से व्यवस्थित करना: इसे ऑनलाइन आज़माएं!
— Xcali
4

सीजेएम, 25 बाइट्स

1e7{_Ab__&0-_@=@@f%1b>},`

इसे ऑनलाइन आज़माएं । ध्यान दें कि ऑनलाइन लिंक केवल 10,000 तक चलता है। मुझे यकीन नहीं है कि अगर आप पर्याप्त रोगी हैं तो यह ऑनलाइन खत्म हो जाएगा। इसने सीजेएम के ऑफ़लाइन संस्करण के साथ इसका परीक्षण नहीं किया है, लेकिन मुझे उम्मीद है कि यह समाप्त हो जाएगा।

स्पष्टीकरण:

1e7     Upper limit.
{       Start filter loop.
  _Ab     Copy and convert to list of decimal digits.
  __&     Intersect list with itself to remove duplicates.
  0-      Remove zero.
  _       Make a copy of unique non-zero digits. Will use these as divisors.
  @=      Compare unique non-zero digits to all digits. Must be true for Monday numbers.
  @@      Rotate original number and list of non-zero digits to top.
  f%      Remainders of original number with all non-zero digits.
  1b      Sum up the remainders. Since they all must be zero for Monday numbers,
          their sum must be zero.
  >       Check that first part of condition was 1, and sum of remainders 0.
},      End filter loop.
`       Convert resulting list to string.
— रेटो कोराडी
स्रोत
4

सी #, 230 227

यह एक समय हो गया है क्योंकि मैंने हल किया है इसलिए मैं शायद कुछ चालें भूल गया था कि नीचे बायटेकाउंट प्राप्त करूं। जब मैं उनके बारे में सोचूंगा तो सुधार होगा ... अभी के लिए:

using System.Linq;class P{static void Main(){System.Console.Write(string.Join(",",Enumerable.Range(0,1<<24).Where(i=>{var s=i.ToString();return!s.Contains('0')&&s.Length==s.Distinct().Count()&&s.All(x=>i%(48-(int)x)==0);})));}}

Ungolfed:

using System.Linq;
class P
{
    static void Main()
    {
        System.Console.Write(                                       //Output...
            string.Join(                                            //...all results...
                ",",                                                //...comma separated...
                Enumerable.Range(0, 1<<24)                          //...from 0 to 16777216...
                    .Where(i => {                                   //...where...
                        var s = i.ToString();                       //...the digits as char array (what we usually call a string)...
                        return !s.Contains('0')                     //...for which none of the digits is 0...
                            && s.Length == s.Distinct().Count()     //...and the number of distinct digits equals the total number of digits (e.g. all unique)...
                            && s.All(x => i % (48 - (int)x) == 0);  //...and the number is divisible by each of the digits (after 'ASCII-correction')
                    })
            )
        );
    }
}

1,2,3,4,5,6,7,8,9,12,15,24,36,48,124,126,128,132,135,162,168,175,184,216,248,264,312,315,324,384,396,412,432,612,624,648,672,728,735,784,816,824,864,936,1236,1248,1296,1326,1362,1368,1395,1632,1692,1764,1824, 1926,1935,1962,2136,2184,2196,2316,2364,2436,2916,3126,3162,3168,3195,3216,3264,3276,3492,3612,3624,3648,3816,3864,3915,3924, 4128,4172,4236,4368,4392,4632,4872,4896,4932,4968,6132,6192,6312,6324,6384,6432,6912,6984,8136,8496,8736,9126,9135,9162,9216, 9315,9324,9432,9612,9648,9864,12384,12648,12768,12864,13248,13824,13896,13968,14328,14728,14832,16248,16824,17248,18264,18432,18624,18936,19368, 21384,21648,21784,21864,23184,24168,24816,26184,27384,28416,29736,31248,31824,31896,31968,32184,34128,36792,37128,37296,37926,38472,39168,39816,41328, 41832,42168,42816,43128,43176,46128,46872,48216,48312,61248,61824,62184,64128,68712,72184,73164,73248,73416,73962,78624,79128,79632,81264,81432,81624,81936,82416,84216,84312,84672,87192,89136,89712,91368,91476,91728,92736,93168,93816,98136,123648,123864,123984, 124368,126384,129384,132648,132864,132984,134928,136248,136824,138264,138624,139248,139824,142368,143928,146328,146832,148392,148632,149328,149832,162384,163248,163824,164328, 164832,167328,167832,168432,172368,183264,183624,184392,184632,186432,189432,192384,193248,193824,194328,194832,198432,213648,213864,213984,214368,216384,218736,219384,231648, 231864,231984,234168,234816,236184,238416,239184,241368,243168,243768,243816,247968,248136,248976,261384,263184,273168,281736,283416,284136,291384,293184,297864,312648,312864, 312984,314928,316248,316824,318264,318624,319248,319824,321648,321864,321984,324168,324816,326184,328416,329184,341928,342168,342816,346128,348192,348216,348912,349128,361248, 361,824,361872,362184,364128,364728,367248,376824,381264,381624,382416,384192,384216,384912,391248,391824,392184,394128,412368,413928,416328,416832,418392,418632,419328,419832,421368, 423168,423816,427896,428136,428736,431928,432168,432768,432816,436128,438192,438216,438912,439128,461328,461832,463128,468312,469728,478296,478632,481392,481632,482136,483192, 483216,483672,483912,486312,489312,491328,491832,493128,498312,612384,613248,613824,613872,614328,614832,618432,621384,623184,623784,627984,631248,631824,632184,634128,634872, 641328,641832,643128,648312,671328,671832,681432,684312,689472,732648,732816,742896,746928,762384,768432,783216,789264,796824,813264,813624,814392,814632,816432,819432,823416, 824136,824376,831264,831624,832416,834192,834216,834912,836472,841392,841632,842136,843192,843216,843912,846312,849312,861432,864312,873264,891432,894312,897624,912384,913248,913824,914328,914832,918432,921384,923184,927864,931248,931824,932184,934128,941328,941832,943128,948312,976248,978264,981432,984312,1289736,1293768,1369872, 1372896,1376928,1382976,1679328,1679832,1687392,1738296,1823976,1863792,1876392,1923768,1936872,1982736,2137968,2138976,2189376,2317896,2789136,2793168,2819376,2831976,2931768,2937816,2978136,2983176, 3186792,3187296,3196872,3271968,3297168,3298176,3619728,3678192,3712968,3768912,3796128,3816792,3817296,3867192,3869712,3927168,3928176,6139728,6379128,6387192,6389712,6391728,6719328,6719832,6731928, 6893712,6913872,6971328,6971832,7168392,7198632,7231896,7291368,7329168,7361928,7392168,7398216,7613928,7639128,7829136,7836192,7839216,7861392,7863912,7891632,7892136,7916328,7916832,7921368,8123976, 8163792,8176392,8219736,8312976,8367912,8617392,8731296,8796312,8912736,8973216,9163728,9176328,9176832,9182376,9231768,9237816,9278136,9283176,9617328,9617832,9678312,9718632,9723168,9781632,9782136,9812376,9867312

— RobIII
स्रोत
(int) 1e7 1 << 24 हो सकता है?
— lirtosiast
@ThomasKwa हाँ, यह हो सकता है। वास्तव में। धन्यवाद!
— रॉबथ 8
4

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

यह थॉमस केवा के उत्तर का अपेक्षाकृत छोटा संपादन है , लेकिन मैं इसे एक नए उत्तर के रूप में प्रस्तुत कर रहा हूं क्योंकि मैंने सुना है कि उसने अपने TI-BASIC उत्तरों को गोल करने के लिए इनाम रखा है।

For(X,1,ᴇ7
int(10fPart(X10^(-randIntNoRep(0,1+int(log(X->D
SortA(∟D
If not(sum(remainder(X,Ans+Xnot(Ansmin(ΔList(∟D
Disp X
End

मेरा मुख्य परिवर्तन है से randIntNoRep(1,करने के लिए randIntNoRep(0,अर्थ है कि वहाँ होगा अब अंक के हर उत्पन्न सूची में एक शून्य।

number  |  randIntNoRep  |  digits  |  sorted
9       |  1,0           |  9,0     |  0,9
102     |  3,1,0,2       |  1,2,0,0 |  0,0,1,2

चूँकि अंकों के प्रत्येक सेट में अब एक शून्य है, इस कारण शेष राशि प्रभावित होती है। आम तौर पर अवशेषों का योग 0 होता है, लेकिन अब, एक अतिरिक्त शून्य की उपस्थिति हमारे विभाजन परीक्षण की विफलता का कारण बनती है।
इसका प्रतिकार करने के लिए, मैं बदल 2Xnot(गया Xnot(। 2 मूल रूप से 0 पर परीक्षण को विफल करने के लिए था, लेकिन अब यह शून्य पर गुजरता है। वे संख्याएँ, जिनमें उनके अंकों में एक शून्य होता है, हालाँकि, अब min(ΔList(∟Dशून्य शून्य (उनकी सूचियों में 2 या अधिक शून्य होने के बाद) होता है, इसलिए इस परिवर्तन से परीक्षण को पारित करने के लिए कोई अतिरिक्त संख्या उत्पन्न नहीं होती है।

इस पद्धति का लाभ यह है कि, चूंकि 1-9 नंबर से उत्पादित "दो अंक" होते हैं, ΔList(फ़ंक्शन एक त्रुटि उत्पन्न नहीं करता है, जिससे हमें एकल-अंकों की संख्या के लिए एक विशेष स्थिति से छुटकारा मिल सकता है।

— PhiNotPi
स्रोत
4

05AB1E , 30 22 21 18 14 13 12 9 बाइट्स

@Enigma और @ Mr.Xcoder की मदद और प्रोत्साहन के लिए -9 बाइट । मुझे यह बताने के लिए धन्यवाद कि यह पहले से ही 30 साल की उम्र में था, तब भी आपके मन में 12-बाइट का समाधान होने के बावजूद, मैंने इस चुनौती से 05AB1E के बारे में बहुत कुछ सीखा!
-3 बाइट्स @Grimy के लिए धन्यवाद

7°LʒÐÑÃÙQ

इसे ऑनलाइन आज़माएं (केवल 60 सेकंड के बाद टाइमआउट को रोकने के लिए 10 7 के बजाय 10 3 से नीचे की संख्याओं को आउटपुट करता है )।

स्पष्टीकरण:

7°L        # Generate a list in the range [1, 10^7]
   ʒ       # Filter, so only the numbers that evaluated to 1 (truthy) remain:
    Ð      #  Triplicate the current number
     Ñ     #  Get the divisors of this number
           #   i.e. 128 → [1,2,4,8,16,32,64,128]
           #   i.e. 1210 → [1,2,5,10,11,22,55,110,121,242,605,1210]
      Ã    #  Only keep those digits/numbers in the original number (which is checked in
           #  order, so it will only keep the digits and ignores the later numbers)
           #   i.e. 128 → 128
           #   i.e. 1210 → 121
       Ù   #  Uniquify the number, removing any duplicated digits
           #   i.e. 128 → 128
           #   i.e. 121 → 12
        Q  #  Check if the number is unchanged after this
           #   i.e. 128 and 128 → 1 (truthy)
           #   i.e. 1210 and 12 → 0 (falsey)

पिछला 12 बटर संस्करण (मेरे पहले 05AB1E उत्तरों में से एक):
नोट: केवल 05AB1E के विरासत संस्करण में काम करता है।

7°LʒÐSÖPsDÙQ*

इसे ऑनलाइन आज़माएं (केवल 60 सेकंड के बाद टाइमआउट को रोकने के लिए 10 7 के बजाय 10 3 से नीचे की संख्याओं को आउटपुट करता है )।

स्पष्टीकरण:

7°L        # Generate a list in the range [1, 10^7]
   ʒ       # Filter, so only the numbers that evaluated to 1 (true) remain:
    Ð      #  Triplicate the current number N
     Ù     #  Remove all duplicated digits of the second N
           #   i.e. 1210 → 120
      Q    #  Check if the last two numbers are still the same (1 or 0 as result)
    *      #  Multiply this result with remaining third number from the triplication
     D     #  Duplicate this number, so we have two again
      S    #  Separate all the digits of the second one
           #   i.e. 128 → ['1', '2', '8']
       Ö   #  Check if (the second) N is divisible by each of its digits
           #   i.e. 128 and ['1', '2', '8'] → [1, 1, 1]
           #   (NOTE: If the number contains a '0', it won't error on division by 0,
           #          but instead return the number N itself in the list)
           #   i.e. 105 and ['1', '0', '5'] → [1, 105, 1]
        P  #  Take the product of this list (if the divisible test for one
           #  of the digits was 0, this will be 0 as well)
           #   i.e. [1, 1, 1] → 1
           #   i.e. [1, 105, 1] → 105 (only 1 is truthy in 05AB1E)
— केविन क्रूज़सेन
स्रोत
आपका उत्तर प्रिंट करता है 297, जो लिंच-बेल नंबर के अनुक्रम में नहीं है।
— श्री Xcoder
@ Mr.Xcoder Sigh .. अगर किसी संख्या को उसके सभी अंको द्वारा विभाज्य किया गया है, तो जाँच के लिए पहले कुछ समय था, लेकिन उस तरह की चुनौती का पता लगा लिया। ऐसा लगता है कि यह उत्तर इसलिए भी अमान्य है .. और यहाँ आप और एनिग्मा 12-15 बाइट के उत्तर के बारे में बात कर रहे हैं, जबकि मेरा 30-बाइट का उत्तर भी काम नहीं करता है, योग्य .. कहीं कोई ट्यूटोरियल नहीं है? ; पी
— केविन क्रूज़सेन
1
9 बाइट्स:7°LʒÐÑÃÙQ
— ग्रैमी
@ मेरी पहली 05AB1E उत्तर में से एक। :) अच्छा तरीका!
— केविन क्रूज़सेन
3

जूलिया, 88 बाइट्स

print(join(filter(i->(d=digits(i);0∉d&&d==unique(d)&&all(j->i%j<1,d)),1:9867312)," "))

यह केवल सभी नंबरों को 1 से सबसे बड़े लिंच-बेल नंबर तक ले जाता है और उन्हें केवल लिंच-बेल नंबरों तक फ़िल्टर करता है।

Ungolfed:

lynch = filter(i -> (d = digits(i);
                     0 ∉ d &&
                     d == unique(d) &&
                     all(j -> i % j == 0, d)),
               1:9867312)

print(join(lynch, " "))
— एलेक्स ए।
स्रोत
3

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

print[i for i in range(6**9)if'0'not in`i`and len(set(`i`))==len(`i`)and all(i%int(k)==0for k in`i`)]

आप printइंटरप्रेटर में 96 तक प्राप्त कर सकते हैं। 6**9क्योंकि यह 8 अंकों का है, जबकि सबसे बड़ा सोमवार संख्या केवल 7 अंक है, ऐसा कुछ 9**9संभवत: लंबा समय लगेगा, 6 ** 9 केवल 10 सेकंड लगते हैं।

— Rohcana
स्रोत
जैसा कि सवालों के एक जोड़े पर बताया गया 1e7 दोनों से छोटा है
— Holloway
@ ट्रेंगोट 1e7एक फ्लोट है, रेंज पूर्णांक लेता है।
— रोहकाना
सच सच। कि नहीं सोचा था
— होलोवे
3

पर्ल, 97 बाइट्स

print+($n=$_,$/)x(!/0/&(y///c==grep{2>eval"$n=~y/$_//"}/./g)&&y///c==grep!($n%$_),/./g)for 1..1e7

चलाने के लिए कुछ समय लगता है, लेकिन आवश्यक आउटपुट पैदा करता है, 1e3एक तेज़ उदाहरण के लिए बदल जाता है !

— डोम हेस्टिंग्स
स्रोत
मैं इस समय इसे आज़माने की स्थिति में नहीं हूँ, लेकिन, इसके बजाय y///c==grep{2>eval"$n=~y/$_//"}/./g, क्या आप कुछ का उपयोग कर सकते हैं !/(.).*\1/?
— msh210
@ msh210 लगभग निश्चित रूप से! मुझे लगता है कि यह अब मेरा डिफ़ॉल्ट होगा, लेकिन इसे बदलने से यह केवल स्टीव या जरमेक्स के उत्तरों के करीब हो जाएगा , जो बहुत बेहतर हैं! हालांकि एक नज़र लेने के लिए धन्यवाद!
— डोम हेस्टिंग्स
3

MATLAB, 100

o=49;for n=2:1e7 a=num2str(n);if all([diff(sort(a)) a~=48 ~mod(n,a-48)]) o=[o ',' a];end;end;disp(o)

और अधिक पठनीय प्रारूप में:

o=49;  %1 is always in there, so add the ASCII value. This prevents there being a ',' prefixed.
for n=2:1e7 
    a=num2str(n);
    if (all([diff(sort(a)) a~=48 ~mod(n,a-48)]))
        o=[o ',' a];
    end
end
disp(o)

11×107

जाँच इस प्रकार हैं:

  1. यदि कोई डुप्लिकेट हैं, तो पहले जांचें। सरणी को छांटकर, यदि किसी भी लगातार अंकों के बीच अंतर शून्य है, तो डुप्लिकेट हैं

    diff(sort(a))

  2. जाँच करें कि क्या कोई शून्य हैं। 0 के लिए ASCII 48 है, इसलिए हम जांचते हैं कि सभी अंक इसके बराबर नहीं हैं।

    a~=48

  3. जांचें कि क्या यह अपने सभी अंकों से विभाज्य है। हम जाँचते हैं कि प्रत्येक अंक (ASCII से दशमलव में परिवर्तित, इसलिए -48) से विभाजित होने पर शेष शून्य है।

    ~mod(n,a-48)

अंत में हम सुनिश्चित करते हैं कि all()चेक सही हैं, और यदि ऐसा है तो हम इसे कॉमा से अलग आउटपुट स्ट्रिंग में जोड़ते हैं।

MATLAB का कोई STDOUT नहीं है, इसलिए इसके बजाय मैं परिणाम स्ट्रिंग का उपयोग करके अंत में प्रिंट करता हूं disp()

यह कोड SLOW है! मैं अभी भी यह सुनिश्चित करने के लिए इसे चला रहा हूं कि यह सभी सोमवार संख्याओं को सही ढंग से पाता है, लेकिन अब तक अच्छा लग रहा है।

अद्यतन करें:

कोड चल रहा है। यह निम्नलिखित प्रिंट करता है:

1,2,3,4,5,6,7,8,9,12,15,24,36,48,124,126,128,132,135,162,168,175,184,216,248,264,312,315,324,384,396,412,432,612,624,648,672,728,735,784,816,824,864,936,1236,1248,1296,1326,1362,1368,1395,1632,1692,1764,1824,1926,1935,1962,2136,2184,2196,2316,2364,2436,2916,3126,3162,3168,3195,3216,3264,3276,3492,3612,3624,3648,3816,3864,3915,3924,4128,4172,4236,4368,4392,4632,4872,4896,4932,4968,6132,6192,6312,6324,6384,6432,6912,6984,8136,8496,8736,9126,9135,9162,9216,9315,9324,9432,9612,9648,9864,12384,12648,12768,12864,13248,13824,13896,13968,14328,14728,14832,16248,16824,17248,18264,18432,18624,18936,19368,21384,21648,21784,21864,23184,24168,24816,26184,27384,28416,29736,31248,31824,31896,31968,32184,34128,36792,37128,37296,37926,38472,39168,39816,41328,41832,42168,42816,43128,43176,46128,46872,48216,48312,61248,61824,62184,64128,68712,72184,73164,73248,73416,73962,78624,79128,79632,81264,81432,81624,81936,82416,84216,84312,84672,87192,89136,89712,91368,91476,91728,92736,93168,93816,98136,123648,123864,123984,124368,126384,129384,132648,132864,132984,134928,136248,136824,138264,138624,139248,139824,142368,143928,146328,146832,148392,148632,149328,149832,162384,163248,163824,164328,164832,167328,167832,168432,172368,183264,183624,184392,184632,186432,189432,192384,193248,193824,194328,194832,198432,213648,213864,213984,214368,216384,218736,219384,231648,231864,231984,234168,234816,236184,238416,239184,241368,243168,243768,243816,247968,248136,248976,261384,263184,273168,281736,283416,284136,291384,293184,297864,312648,312864,312984,314928,316248,316824,318264,318624,319248,319824,321648,321864,321984,324168,324816,326184,328416,329184,341928,342168,342816,346128,348192,348216,348912,349128,361248,361824,361872,362184,364128,364728,367248,376824,381264,381624,382416,384192,384216,384912,391248,391824,392184,394128,412368,413928,416328,416832,418392,418632,419328,419832,421368,423168,423816,427896,428136,428736,431928,432168,432768,432816,436128,438192,438216,438912,439128,461328,461832,463128,468312,469728,478296,478632,481392,481632,482136,483192,483216,483672,483912,486312,489312,491328,491832,493128,498312,612384,613248,613824,613872,614328,614832,618432,621384,623184,623784,627984,631248,631824,632184,634128,634872,641328,641832,643128,648312,671328,671832,681432,684312,689472,732648,732816,742896,746928,762384,768432,783216,789264,796824,813264,813624,814392,814632,816432,819432,823416,824136,824376,831264,831624,832416,834192,834216,834912,836472,841392,841632,842136,843192,843216,843912,846312,849312,861432,864312,873264,891432,894312,897624,912384,913248,913824,914328,914832,918432,921384,923184,927864,931248,931824,932184,934128,941328,941832,943128,948312,976248,978264,981432,984312,1289736,1293768,1369872,1372896,1376928,1382976,1679328,1679832,1687392,1738296,1823976,1863792,1876392,1923768,1936872,1982736,2137968,2138976,2189376,2317896,2789136,2793168,2819376,2831976,2931768,2937816,2978136,2983176,3186792,3187296,3196872,3271968,3297168,3298176,3619728,3678192,3712968,3768912,3796128,3816792,3817296,3867192,3869712,3927168,3928176,6139728,6379128,6387192,6389712,6391728,6719328,6719832,6731928,6893712,6913872,6971328,6971832,7168392,7198632,7231896,7291368,7329168,7361928,7392168,7398216,7613928,7639128,7829136,7836192,7839216,7861392,7863912,7891632,7892136,7916328,7916832,7921368,8123976,8163792,8176392,8219736,8312976,8367912,8617392,8731296,8796312,8912736,8973216,9163728,9176328,9176832,9182376,9231768,9237816,9278136,9283176,9617328,9617832,9678312,9718632,9723168,9781632,9782136,9812376,9867312

यदि आप इनपुट के रूप में इस कोड को चलाते हैं:

nums = length(strsplit(stdout,','))

येइल्ड्स 548।

— टॉम बढ़ई
स्रोत
3

रूबी,, ९

?1.upto(?9*7){|s|a=s.chars;a.uniq!||a.any?{|x|x<?1||0<eval([s,x]*?%)}||puts(s)}

एक रेगेक्स के साथ अधिक दिलचस्प लेकिन थोड़ा लंबा समाधान:

?1.upto(?9*7){|s|s[/(.).*\1|[0#{(1..9).map{|*x|x*eval([s,x]*?%)}*''}]/]||puts(s)}

प्रत्येक मामले में, हम रूबी की क्षमता का उपयोग स्ट्रिंग्स पर पुनरावृति करने के लिए कर रहे हैं जैसे कि वे दशमलव पूर्णांक थे: ?1.upto(?9*7)के बराबर है 1.upto(9999999).map(&:to_s).each। हम modulo ऑपरेटर का उपयोग करके प्रत्येक नॉनजेरो अंक में स्ट्रिंग को मिलाते हैं, और परिणाम को निकालने के लिए, विभाज्यता की जांच करते हैं।

बोनस रूबी 1.8 समाधान ( -lउचित आउटपुट के लिए ध्वज की आवश्यकता है ):

'1'.upto('9'*7){|$_|~/(.).*\1|[0#{(1..9).map{|*x|x*eval("#$_%#{x}")}}]/||print}

1.8 ब्लॉक अवरोधक को एक वैश्विक चर होने की अनुमति देता है। असाइन करना $_इसे स्ट्रिंग ऑपरेशन के लिए निहित रिसीवर बनाता है। हम नियमित अभिव्यक्ति में सरणियों को अधिक आसानी से प्रक्षेपित करने के लिए भी प्राप्त करते हैं: 1.8 में, /[#{[1,2]}]/मूल्यांकन करता है /[12]/।

— histocrat
स्रोत
अब जब रूबी 2.4 का digitsपूर्णांक पर एक फ़ंक्शन है , तो आप बाइट को eval हैक से बचा सकते हैं क्योंकि आप स्ट्रिंग्स पर काम नहीं कर रहे हैं! 63 बाइट्स।
— वैल्यू इंक
3

पिप , 25 बाइट्स

Fa,t**7Ia#=UQa&0=$+a%^aPa

प्रत्येक संख्या को अपनी लाइन पर आउटपुट करता है। यह लगभग 10 मिनट से चल रहा है और अब तक 984312 तक चला गया है, लेकिन मुझे पूरा यकीन है कि यह सही है। (संपादित करें: कुछ घंटे बाद ... कोड समाप्त हो गया, उन्हें सभी 548 उत्पन्न हुए।)

यहाँ एक पायथन-एस्के स्यूडोकोड गायन है:

for a in range(10**7):
  if lengthEqual(a, set(a)) and 0 == sum(a%d for d in digits(a)):
    print(a)

#=ऑपरेटर लंबाई से दो iterables तुलना करती है। की संख्या तो Uनी Qमें ue पात्रों aमें वर्णों की संख्या के रूप में ही है a, वहाँ कोई दोहराता है।

विभाज्य-दर-प्रत्येक-अंक मेरी पिप उदाहरण कार्यक्रमों में से एक से है। मैंने इसे पहले की चुनौती को देखकर लिखा था, लेकिन इसे पोस्ट नहीं किया क्योंकि भाषा प्रश्न की तुलना में नई थी। अन्यथा, 8 बाइट्स में, यह उस प्रश्न का विजयी उत्तर होगा। यहां चरण-दर-चरण स्पष्टीकरण दिया गया है:

      ^a   Split num into an array of its digits
    a%     Take num mod each of those digits; if a digit is zero, the result will be nil
  $+       Sum the resulting list (note: summing a list containing nil results in nil!)
0=         Iff the sum equals 0, return 1 (true); otherwise (>0 or nil), return 0 (false)
— DLosc
स्रोत
यह एक बहुत साफ भाषा है! स्टैक-आधारित गोल्फिंग के अलावा कुछ और देखकर अच्छा लगा।
— AdmBorkBork
1
@TimmyD यदि आप गैर-स्टैक आधारित गोल्फिंग देखना चाहते हैं, तो चारों ओर काफी पाइंट होता है।
— रेटो कोराडी
@RetoKoradi लेकिन अगर आप infix ऑपरेटरों के साथ नॉन-स्टैक-आधारित गोल्फिंग देखना चाहते हैं , तो Pip आपके लिए है। ; ^)
— DLosc
Couple hours laterयह एक अच्छी बात है कि प्रदर्शन को ध्यान में नहीं रखा गया है।
— होलोते
3

जावास्क्रिप्ट (ईएस 6), 106 90 83 बाइट्स

बच्चों, घर पर यह कोशिश मत करो; जेएस रेगेक्स के साथ एक से दस मिलियन तक के प्रत्येक पूर्णांक के प्रत्येक अंक के माध्यम से लूपिंग की संभावना से खुश नहीं होगा।

for(i=0;i<1e7;i++)/(.).*\1|0/.test(i)||+`${i}`.replace(/./g,j=>i%j)||console.log(i)

यदि पहला trueनंबर डुप्लिकेट अंक या शून्य है, तो पहला regex (@Jarmex पर वापस जाता है) । यदि यह पता चलता है false, तो कार्यक्रम दूसरे पर आगे बढ़ता है, जो प्रत्येक अंक jको बदलता है i%j। परिणाम सभी शून्य है यदि यह सभी अंकों से विभाज्य है, तो यह किस स्थिति में आगे बढ़ता है console.log(i)।

सुझावों का स्वागत है!

— ETHproductions
स्रोत
3

जावास्क्रिप्ट (ईएस 6), 76

/* Answer below. For testing purpose, redirect consoloe.log */ console.log=x=>document.write(x+' ')

for(i=0;i++<1e7;)/0|(.).*\1/.test(i)||[...i+''].some(d=>i%d)||console.log(i)
स्निपेट का विस्तार करें

0 या दोहराया अंकों के लिए regexp परीक्षण। फिर अंकों के सरणी को किसी भी अंक के लिए गैर-शून्य मॉडुलो की तलाश में चेक किया जाता है।

यहाँ 7 अंकीय अधिकतम की व्याख्या है।

— edc65
स्रोत
3

रूबी, 130 बाइट्स

... व्हॉट्सएप की गिनती नहीं

प्रोग्रामिंग में नया, बस भाग लेना चाहता था

c=0
(0..10**7).each do |x| 
  a=x.to_s.split('')
  c+=1 if !a.include?('0')&& a.uniq!.eql?(nil)&&a.all?{|y| x.modulo(y.to_i).zero?} 
end
p c
— skeezy_D
स्रोत
2
PPCG में आपका स्वागत है! रूबी के लिए कुछ अतिरिक्त युक्तियों की जाँच करें ताकि उस कोड की लंबाई कम हो सके।
— AdmBorkBork
3

सी, 122 बाइट्स

i,j,m,a;void f(){for(i=1;i<1e8;++i){for(m=0,j=i;j;j/=10){a=j%10;if(!a||m&(1<<a)||i%a)goto n;m|=1<<a;}printf("%d ",i);n:;}}

खूबसूरत:

i,j,m,a;
void f()
{
    for (i=1; i<1e8; ++i){
        for (m=0, j=i;  j;  j/=10) {
            a = j%10;
            if (!a || m&(1<<a) || i%a)
                goto n;
            m|=1<<a;
        }
        printf("%d ",i);
    n:;
    }
}

प्रत्येक उम्मीदवार के लिए i, हम aबिट-एंडियन क्रम में इसके अंकों को अंकित करते हैं, बिट्स में देखे गए अंकों पर नज़र रखते हैं m। यदि लूप पूरा हो जाता है, तो सभी अंक इसके कारक हैं iऔर हमने कोई शून्य या दोहराया अंक नहीं देखा, इसलिए इसे प्रिंट करें, अन्यथा हम बाहरी लूप को जारी रखने के लिए जल्दी निकल जाते हैं।

— टोबी स्पाईट
स्रोत
gotoकमांड का अच्छा इस्तेमाल किया जा रहा है।
— शॉन बेयबर्स
2

लूआ, 129 बाइट्स

मैंने शुद्ध डिजिट-क्रंचिंग के लिए स्ट्रिंग दृष्टिकोण को बढ़ा दिया है, जो थोड़ा तेज़ लगता है और शायद मुझे कुछ बाइट्स के रूप में भी बचाया है। (मैं उस सिद्धांत का परीक्षण करूंगा, लेकिन कुछ अन्य भाषाओं की तुलना में लुआ स्ट्रिंग हैंडलिंग बहुत ही क्रियात्मक है।)

for i=1,1e7 do t={[0]=1}j=i while j>0 do c=j%10 if t[c]or i%c>0 then break end t[c]=1 j=(j-c)/10 if j==0 then print(i)end end end
— criptych मोनिका के साथ खड़ा है
स्रोत
2

gawk, 99 बाइट्स

BEGIN{for(;8>(l=split(++i,a,_));printf f?f=_:i RS)for(j in a)f=i~0||i%(d=a[j])||i-d*10^(l-j)~d?1:f}

अगर मैं ENDइसके बजाय मैं का उपयोग करने के लिए 97 को कम कर सकता हैBEGIN , लेकिन फिर आपको वास्तविक आउटपुट शुरू करने के लिए Ctrl-D दबाना होगा, यह दर्शाता है कि कोई इनपुट नहीं होगा।

मैं 94 के लिए भी यह कम हो सकता है अगर मैं कुछ भी नहीं के बजाय लिखते थे की BEGINयाEND है, लेकिन फिर आप कुंजी दबाएं होने के बाद उसे शुरू करने के लिए है, जो इनपुट के रूप में गिना जा सकता होगा।

यह बस प्रत्येक संख्या और परीक्षणों के अंकों के ऊपर जाता है यदि मानदंड पूरा होता है।

i ~ 0: संख्या में एक `0` शामिल हैं? -> कचरा
i% (d = [[j]): वर्तमान अंक से विभाज्य संख्या नहीं है? -> कचरा
आईडी * 10 ^ (lj) ~ d: मैंने वर्तमान अंक को अभी तक संख्या से हटा दिया है
                  : अभी भी इसमें शामिल है? -> कचरा

मेरे कोर 2 डुओ पर समाप्त करने के लिए 140 सेकंड लगते हैं।

— Cabbie407
स्रोत
2

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

9œ!ṖẎgḌ$ƑƇḌ

यह दो सप्ताह पुराने œ!परमाणु का उपयोग करता है । वास्तव में तेजी से TIO पर चलने के लिए।

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

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

9œ!ṖẎgḌ$ƑƇḌ  Main link. No arguments.

9            Set the return value to 9.
   R         Pop; yield [1, ..., 8].
 œ!          Promote 9 to [1, ..., 9] and generate all permutations of length k,
             each k in the right argument [1, ..., 8].
    Ẏ        Tighten; dump all digit lists in a single array.
         Ƈ   Comb; keep only digit lists for which the link to the left returns 1.
        Ƒ      Fixed; return 1 iff calling the link to the left returns its argument.
       $         Combine the two links to the left into a monadic chain.
      Ḍ            Undecimal; convert the digit list into an integer.
     g             Take the GCD of each digit and the integer.
— डेनिस
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.