आपके प्रोग्राम को एक इनपुट ( nविवरण के प्रयोजन के लिए) और एक नंबर के सभी क्रमपरिवर्तन को आउटपुट करना होगा जो कि nकोई दोहराए जाने वाले अंकों के साथ लंबा होता है, जहां अंक और इसके सूचकांक सहित प्रत्येक अंक उस स्थान से विभाज्य होते हैं जहां यह गिरता है ।

आप यहां मैजिक नंबर के बारे में पढ़ सकते हैं ।

नियम:

1 <= n <= 10
कोई अंक दोहराया नहीं जा सकता है
प्रमुख 0 मौजूद होना चाहिए (यदि लागू हो)
xसंख्या के वें अंक के माध्यम से 1 (पहले चरित्र के रूप में 1 के साथ शुरू) से विभाज्य होना चाहिए x, अर्थात 30685, 31 30से विभाज्य है, 2 306से विभाज्य है, 3 3068से विभाज्य है, 4 से विभाज्य है, और 306855 से विभाज्य है ।
प्रोग्राम को इनपुट (कमांड लाइन के माध्यम से, फ़ंक्शन तर्क के रूप में) के रूप में पूर्णांक लेना चाहिए और नियमों को संतुष्ट करने वाले सभी क्रमपरिवर्तन को प्रिंट करना चाहिए।
आउटपुट को 1 या अधिक श्वेत स्थान वर्ण द्वारा अलग किया जाना चाहिए
क्रमपरिवर्तन शुरू हो सकता है और शून्य के साथ (इसलिए वे तकनीकी रूप से जादुई संख्या नहीं हैं)।
आउटपुट का क्रम मायने नहीं रखता
आपको अनपेक्षित इनपुट को संभालने की आवश्यकता नहीं है
बाइट्स में कम से कम अक्षर जीतता है

उदाहरण

1 दिया गया:

2 दिया गया:

10 दिया:

3816547290

पिज्जा हट और करने के लिए क्रेडिट जॉन एच कोनवे के लिए मूल पहेली (विकल्प A)। उनके लिंक के लिए @Mego और @ sp3000 को धन्यवाद ।

code-golf permutations

— DavisDude
स्रोत

संबंधित: codegolf.stackexchange.com/q/63183/42854

— डैनियल

6

@DavisDude "संबंधित" का अर्थ "डुप्लिकेट" नहीं है। संबंधित लिंक पोस्ट करने का उद्देश्य साइडबार में "लिंक्ड" के रूप में दिखाई देने वाली चुनौती के लिए है।

— मार्टिन एंडर 16

1

संबंधित पढ़ना: बहुपत्नी संख्या

— Sp3000

3

क्या प्रमुख 0 को उन आउटपुट नंबरों को शामिल करने की आवश्यकता है जो उनके पास हैं?

— xnor

4

जब आप आउटपुट की बात करते हैं, तो आप मुद्रण और व्हाट्सएप का उल्लेख करते हैं, लेकिन एक फ़ंक्शन के लिए, आउटपुट का सबसे प्राकृतिक रूप संभवतः एक सूची लौटाएगा। क्या इसकी अनुमति है?

— डेनिस

4

जेली , 20 17 16 बाइट्स

QḣQV%S
ØDṗçÐḟRj⁷

यह बहुत धीमा है और स्मृति गहन है ... इसे ऑनलाइन आज़माएं!

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

ØDṗçÐḟRj⁷  Main link. Input: n (integer)

ØD         Yield d := '0123456789'.
  ṗ        Compute the nth Cartesian power of d.
      R    Range; yield [1, ..., n].
    Ðḟ     Filter false; keep strings of digits for which the following yields 0.
   ç         Apply the helper link to each digit string and the range to the right.
       j⁷  Join the kept strings, separating by linefeeds.


QḣQḌ%S     Helper link. Arguments: s (digit string), r (range from 1 to n)

Q          Unique; deduplicate s.
 ḣ         Head; get the prefixes of length 1, ..., n or less.
           If s had duplicates, the final prefixes fill be equal to each other.
  Q        Unique; deduplicate the array of prefixes.
   V       Eval all prefixes.
    %      Compute the residues of the kth prefixes modulo k.
           If s and the array of prefixes have different lengths (i.e., if the
           digits are not unique), some right arguments of % won't have corr. left
           arguments. In this case, % is not applied, and the unaltered right
           argument is the (positive) result.
     S     Add all residues/indices. This sum is zero iff all digits are unique
           and the kth prefixes are divisible by k.

— डेनिस
स्रोत

3

अगर यह धीमा है ... मेरा जवाब एक नींद का सुस्त है

— लुइस मेंडो

6

जावास्क्रिप्ट (फ़ायरफ़ॉक्स 30-57), 77 बाइट्स

f=n=>n?[for(s of f(n-1))for(c of"0123456789")if(s.search(c)+(s+c)%n<0)s+c]:[""]

संपादित करें: @ edc65 के लिए 1 बाइट का धन्यवाद सहेजा गया।

— नील
स्रोत

एक रत्न! बस 1 बाइट ...of"012...

— बचाएं

@ edc65 Ugh, मुझे विश्वास नहीं हो रहा है कि मैंने इसकी अनदेखी की है।

— नील

3

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

jf!s%VsM._TS;.PjkUT

प्रदर्शन

एक जानवर बल समाधान। अनुसरण करने के लिए स्पष्टीकरण। प्रेरणा FryAmTheEggman के लिए धन्यवाद

22 बाइट्स

juf!%sThH{I#sm+LdTGQ]k

प्रदर्शन

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

स्पष्टीकरण:

juf!%sThH{I#sm+LdTGQ]k
 u                 Q]k    Apply the following input many times, starting with ['']
             m    G       For each string at the previous step,
              +LdT        Append each digit to it
            s             Concatenate
         {I#              Filter out strings with repeats
  f                       Filter on
     sT                   The integer
    %  hH                 Mod the 1 indexed iteration number
   !                      Is zero.
j                         Join on newlines.

— isaacg
स्रोत

मैं जिज्ञासु हूं: बस आपको पाइथ सीखने के लिए कितना मर्दाना होना होगा? / एस

— डेविसडू

2

@DavisDude मुझे लगता है कि जब लोग इसे देखते हैं तो लोग जितना सोचते हैं, उससे ज्यादा आसान है। सबसे डरावना हिस्सा शुरू हो रहा है। एक बार जब आप अंदर आ जाते हैं, तो

— FliiFe

1

डिबग मोड आपकी कितनी मदद करता है, यह काफी आसान है। डॉक्स भी बहुत अच्छे हैं, और समझाएं कि आपको क्या जानना चाहिए।

— शुक्र

बस संदर्भ के लिए, मैं एक और अधिक ._सामान और कुछ अन्य सामान के साथ घाव करता हूं , लेकिन यह बड़े इनपुट के लिए धीमी है:jjLkf!s.e%ib10hk._T.PUT

— FryAmTheEggman

3

MATL , 30 बाइट्स

4Y2Z^!"@Sd@!U10G:q^/kPG:\~h?@!

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

यह बहुत धीमा है। इसके input 3लिए ऑनलाइन संकलक में कुछ सेकंड लगते हैं। एक के बाद एक प्रदर्शित होने संख्या देखने के लिए, एक शामिल Dकोड के अंत में ।

व्याख्या

4Y2       % predefined literal: string '0123456789'
Z^        % implicit input. Cartesian power: 2D char array. Each number is a row
!         % transpose
"         % for each column
  @       %   push current column
  Sd      %   sort and compute consecutive differences (*)
  @!U     %   push current column. Convert to number
  10G:q^  %   array [1 10 100 ... 10^(n-1)], where n is the input
  /k      %   divide element-wise. Round down
  P       %   reverse array
  G:      %   array [1 2 ... n]
  \~      %   modulo operation, element-wise. Negate: gives 1 if divisible (**)
  h       %   concatenate (*) and (**). Truthy if all elements are nonzero
  ?       %   if so
    @!    %     current number as a row array of char (string)
          %   implicitly end if
          % implicitly end if
          % implicitly display stack contents

— लुइस मेंडो
स्रोत

आपके कोड में कुछ गड़बड़ है; यह 5 के बाद मेरे लिए उत्पादन करना बंद कर देता है, और 5 के साथ अंतिम संख्या (केवल एक जिसे मैंने जांचने के लिए परेशान किया है) गलत है। 986

— डेविसुड

अपडेट: २ के लिए यह १०, १२, ३२, ३४, ५४, ५६,

— sk६

मुझे लगता है कि आप शीघ्र गलत समझे। खोज रहे हैं पर 3मैं तुम्हें एक जोड़े संकेत (026 जैसे) देख सकते हैं। इसके अलावा एक स्पष्टीकरण की सराहना की जाएगी

— डेविसुड

यह अभी भी काम नहीं करता है- 3 स्किप 021, 024, आदि। पहला सही नंबर 063 है।

— डेविसडू

@ डैडीसुडे एडिटेड, अब जब मैंने चुनौती को और अधिक ध्यान से पढ़ा

— लुइस मेंडू

1

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

मूल पुनरावर्ती समाधान।

f=->n,x="",j=1{j>n ?puts(x):([*?0..?9]-x.chars).map{|i|f[n,x+i,j+1]if((x+i).to_i)%j<1}}

यदि आपको मुद्रण के बजाय क्रमपरिवर्तन की सूची वापस करने की अनुमति है, तो 85 बाइट्स:

f=->n,x="",j=1{j>n ?x:([*?0..?9]-x.chars).map{|i|f[n,x+i,j+1]if((x+i).to_i)%j<1}-[p]}

— मान स्याही
स्रोत

1

पायथन, 132 बाइट्स

lambda n:[x for x in map(("{:0%s}"%n).format,(range(10**n)))if all(int(x[:i])%i<1and len(set(x))==len(x)for i in range(1,len(x)+1))]

छुटकारा पाने के लिए 26 बाइट्स से गिरा दिया itertools, मुझे यह एहसास नहीं होना चाहिए कि मुझे इसका उपयोग नहीं करना चाहिए।

filterटिप के लिए फिर से Sp3000 के लिए धन्यवाद के बजाय एक सूची समझ का उपयोग करके 2 बाइट्स गिरा दिया ।

इसे ऑनलाइन आज़माएं: पायथन 2 , पायथन 3

— मै जाऊं
स्रोत

किसी दिए गए लम्बाई की जादुई संख्या