परिचय

बेस एन में एक xenodrome एक पूर्णांक होता है जहां आधार n में इसके सभी अंक अलग-अलग होते हैं। यहाँ xenodromes के कुछ OEIS अनुक्रम हैं।

उदाहरण के लिए, आधार 16 में, FACE, 42और FEDCBA9876543210कुछ xenodromes (जो कर रहे हैं 64206, 66और 18364758544493064720आधार 10 में), लेकिन 11और DEFACEDनहीं कर रहे हैं।

चुनौती

इनपुट बेस को देखते हुए, n , बेस 10 में उस बेस के लिए सभी xenodromes को आउटपुट करता है ।

आउटपुट कम से कम से सबसे बड़ा होना चाहिए। यह स्पष्ट होना चाहिए कि अनुक्रम में एक शब्द कहां समाप्त होता है और एक नया शुरू होता है (उदाहरण [0, 1, 2]स्पष्ट है कि कहां 012नहीं है।)

n 0 से अधिक पूर्णांक होगा।

स्पष्टीकरण

यह चुनौती विशेष रूप से बेस 10 में आईओ को पूर्णांक और स्ट्रिंग के रूप में उनके आधार से बचने के लिए करती है। चुनौती किसी भी आधार को सार-संभाल करने में है। जैसे, मैं यह अतिरिक्त नियम जोड़ रहा हूं:

आधार 10 के अलावा अन्य आधारों में पूर्णांक के रूप में संग्रहीत नहीं किए जा सकते।

आपका कार्यक्रम किसी भाषा के कार्यान्वयन में समय, स्मृति, सटीक या अन्य तकनीकी प्रतिबंध नहीं होने पर सैद्धांतिक रूप से उच्च एन को संभालने में सक्षम होना चाहिए ।

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

उदाहरण इनपुट और आउटपुट

1  # Input
0  # Output

2
0, 1, 2

3
0, 1, 2, 3, 5, 6, 7, 11, 15, 19, 21

4
0, 1, 2, 3, 4, 6, 7, 8, 9, 11, 12, 13, 14, 18, 19, 24, 27, 28, 30, 33, 35, 36, 39, 44, 45, 49, 50, 52, 54, 56, 57, 75, 78, 99, 108, 114, 120, 135, 141, 147, 156, 177, 180, 198, 201, 210, 216, 225, 228

— Artyer
स्रोत

1

क्या n की सीमा है?

— FlipTack

@ Flp.Tkc No. यह यथोचित रूप से उच्च n को संभालने में सक्षम होना चाहिए। मैं नहीं चाहता कि यह चुनौती सीमित हो कि किसी भाषा का बेसिन बेस कन्वर्जन कितना ऊंचा हो सकता है।

— एरियर

@Artyer तब चुनौती पाठ का हिस्सा होना चाहिए था। ऐसा लगता है कि कुछ उत्तर पहले से ही कर रहे हैं

— लुइस मेंडू

मुझे पता है कि पायथ में आधार रूपांतरण उन मानों को बड़ा कर सकता है जो कि 36 हैं , लेकिन चूंकि यह सभी xenodromes चाहता है, सूची में बहुत बड़ा होने पर अंतर्निहित अजगर टूट जाता है, यह कहते हुए कि यह एक मूल्य में फिट नहीं हो सकता है ssize_t। क्या इस तरह से यह स्वीकार्य है?

— FryAmTheEggman

2

किसी को लगता है कि सभी उत्तर जो कि एक अंतर्निहित परिशुद्धता सीमा के कारण बड़े ठिकानों को संभाल नहीं सकते हैं, जो एक एल्गोरिथ्म समस्या के बजाय कार्यान्वयन की तरह लगता है। क्या आप स्पष्ट कर सकते हैं?

— डेनिस

10

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

f{IjTQU^

आधार एन में कोई डुप्लिकेट तत्व नहीं होने पर [0, n ^ n - 1] में संख्याओं को फ़िल्टर करता है । पायथ में आधार रूपांतरण किसी भी आधार के साथ काम करेगा, लेकिन चूंकि यह संख्याओं की बहुत तेज़ी से बढ़ती सूची को देखता है, इसलिए यह अंततः स्मृति में मूल्यों को संग्रहीत करने में असमर्थ होगा।

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

स्पष्टीकरण:

f{IjTQU^QQ    - Auto-fill variables
      U^QQ    - [0, n^n-1]
f             - keep only those that ...
 {I           - do not change when deduplicated
   jTQ        - are converted into base n

— FryAmTheEggman
स्रोत

वाह, एक समाधान जो जेली समाधान से कम है जो डेनिस ने बनाया था! : 'पी

— हाइपरनेत्रिनो

3

कोई जैली की पिटाई नहीं करता। ¶:

— रोमन ग्रैफ

5

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

n=input()
for x in range(n**n):
 s={n};a=x
 while{a%n}|s>s:s|={a%n};a/=n
 print-~-a*`x`

गैर- xenodromes के लिए अतिरिक्त रिक्त लाइनें प्रिंट करता है:

golf % python2.7 xenodromes.py <<<3
0
1
2
3

5
6
7



11



15



19

21

— लिन
स्रोत

5

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

ð*ḶbQ€Qḅ

1 बाइट को बंद करने के लिए @JonathanAllan को धन्यवाद!

इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें ।

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

ð*ḶbQ€Qḅ  Main link. Argument: n

ð         Make the chain dyadic, setting both left and right argument to n.
          This prevents us from having to reference n explicitly in the chain.
 *        Compute nⁿ.
  Ḷ       Unlength; yield A := [0, ..., nⁿ - 1].
   b      Convert each k in A to base n.
    Q€    Unique each; remove duplicate digits.
      Q   Unique; remove duplicate digit lists.
       ḅ  Convert each digit list from base n to integer.

— डेनिस
स्रोत

4

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

*`ḶbµQ⁼$Ðfḅ³

TryItOnline!

किसी भी के लिए काम करेंगे n, पर्याप्त स्मृति को देखते हुए, जेली का आधार रूपांतरण प्रतिबंधात्मक नहीं है।

कैसे?

*`ḶbµQ⁼$Ðfḅ³ - Main link: n
    µ        - monadic chain separation
*            - exponentiation with
 `           - repeated argument, i.e. n^n
  Ḷ          - lowered range, i.e. [0,1,2,...,n^n-1]
   b         - covert to base n (vectorises)
        Ðf   - filter keep:
       $     -     last two links as a monad
     Q       -         unique elements
      ⁼      -         equals input (no vectorisation)
           ³ - first program argument (n)
          ḅ  - convert from base (vectorises)

— जोनाथन एलन
स्रोत

3

जावास्क्रिप्ट (ईएस 7), 86 बाइट्स

n=>{a=[];for(i=n**n;i--;j||a.unshift(i))for(j=i,b=0;(b^=f=1<<j%n)&f;j=j/n|0);return a}

— नील
स्रोत

के लिए विफल रहता है 1(उत्पादन होना चाहिए [0], लेकिन रेंजरियर्स।)

— Artyer

वास्तव में मेरे पास क्या था, लेकिन यह सैद्धांतिक रूप से विफल हो जाता है 37अगर परिशुद्धता एक मुद्दा नहीं था, जो मुझे लगता है कि इसे अमान्य बना देता है ...

— ETHproductions

@Artyer मैं अपने बैच संस्करण पोर्ट किया है, इसलिए अब इस बात के लिए काम करेंगे nसे 1करने 13से पहले फ्लोटिंग प्वाइंट परिशुद्धता यह मारता है।

— नील

मुझे पसंद है कि कैसे समाधान वास्तव में कम शुरू होते हैं, और फिर अचानक परिमाण के एक क्रम को कूदते हैं।

— निसा

2

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

{(0..$_**$_).grep: !*.polymod($_ xx*).repeated}

एक Seq देता है । ( Seq एक बुनियादी है Iterable के लिए आवरण इटरेटर रों)

इसके इनपुट के साथ 16Seq ( 87887) के 53905 वें तत्व की गणना करने में 20 सेकंड लगते हैं ।

विस्तारित:

{       # bare block lambda with implicit parameter ｢$_｣

  ( 0 .. ($_ ** $_) )    # Range of values to be tested

  .grep:                 # return only those values

    !\                   # Where the following isn't true
    *\                   # the value
    .polymod( $_ xx * )  # when put into the base being tested
    .repeated            # has repeated values
  }
}

— ब्रैड गिल्बर्ट b2gills
स्रोत

2

बैच, 204 200 बाइट्स

@set/an=%1,m=1
@for /l %%i in (1,1,%1)do @set/am*=n
@for /l %%i in (0,1,%m%)do @set/ab=0,j=i=%%i&call:l
@exit/b
:l
@set/a"f&=b^=f=1<<j%%n,j/=n"
@if %f%==0 exit/b
@if %j% gtr 0 goto l
@echo %i%

N> 9 के लिए काम नहीं करेगा क्योंकि बैच में केवल 32-बिट अंकगणित है। आसानी से, बैच f &= b ^= f = 1 << j % nके f = 1 << j % n, b = b ^ f, f = f & bबजाय मूल्यांकन करता है f = f & (b = b ^ (f = 1 << j % n))।

— नील
स्रोत

2

गणितज्ञ, ५ ९ ४ 59 बाइट्स

Select[Range[#^#]-1,xMax[x~DigitCount~#]==1]&

इसमें U + F4A1 "निजी उपयोग" वर्ण शामिल है

व्याख्या

Range[#^#]-1

उत्पन्न करना {1, 2, ..., n^n}। घटाना 1. (पैदावार {0, 1, ..., n^n - 1})

xMax[x~DigitCount~#]==1

एक बूलियन फ़ंक्शन: Trueयदि प्रत्येक अंक बेस में एक बार सबसे अधिक होता है n।

Select[ ... ]

सूची से {0, 1, ..., n^n - 1}, उन लोगों का चयन करें Trueजो उपरोक्त बूलियन फ़ंक्शन लागू होने पर देते हैं।

59 बाइट संस्करण

Select[Range[#^#]-1,xDuplicateFreeQ[x~IntegerDigits~#]]&

— जंगहवान मिन
स्रोत

2

मैथेमेटिका, 48 55 बाइट्स

Union[(x   x~FromDigits~#)/@Permutations[Range@#-1,#]]&

( xकोड काम करने के लिए 3-बाइट कैरेक्टर \ uF4A1 द्वारा प्रतिस्थापित किए जाने की जरूरत है।

एक ही तर्क है। Xenodromicity के लिए पूर्णांक का परीक्षण करने के बजाय, यह बस अनुमत अंकों के सबसेट के सभी संभावित क्रमचय उत्पन्न करता है (जो स्वचालित रूप से पुनरावृत्ति से बचा जाता है) और संगत पूर्णांक को आधार में परिवर्तित करता है। प्रत्येक xenodrome एक अग्रणी 0 के साथ और बिना दोनों के दो बार उत्पन्न होता है; Unionडुप्लिकेट निकालता है और सूची को बूट करने के लिए सॉर्ट करता है।

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

1

के लिए विफल रहता है 2। फ़ंक्शन देता है {0, 1}। मेरा मानना है कि आपको इसकी Permutations[Range@#-1, #]बजाय जरूरत है Subsets[Range@#-1]।

— जंगवान मिन

वाह, क्या गलती हो गई। इसका अवलोकन करने के लिए, और सही समाधान के लिए धन्यवाद देने के लिए धन्यवाद!

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

सभी Xenodromes