डिजिटल विविधता

16

एक पूर्णांक आधार में एक सकारात्मक पूर्णांक का प्रतिनिधित्व किया जा सकता है 1 <= b < inf।

जब उस आधार में परिवर्तित किया जाता है तो उसमें कुछ विशिष्ट अंक होते हैं।

आधार में किसी भी धनात्मक पूर्णांक 1का 1अलग-अलग अंक होता है।

अधिकांश सकारात्मक पूर्णांक आधार 2में 2अलग-अलग अंक होते हैं, अपवाद फॉर्म के होते हैं 2^n - 1, जो केवल होते हैं 1।

तो पहला पॉजिटिव पूर्णांक जिसे 1विशिष्ट अंकों के साथ पूर्णांक बेस में दर्शाया जा सकता है 1और पहला जो 2अलग अंकों के साथ दर्शाया जा सकता है 2।

हम कह सकते हैं कि 1डिजिटल विविधता के साथ पहली पूर्णांक है 1और 2डिजिटल विविधता के साथ पहली पूर्णांक है 2।

चुनौती:

एक सकारात्मक पूर्णांक को देखते हुए nपहला धनात्मक पूर्णांक (बेस दस * में) है जिसमें डिजिटल विविधता है n।

* यदि आपकी भाषा केवल एक विशिष्ट आधार (जैसे एकात्मक या द्विआधारी) का समर्थन करती है तो आप उस आधार में आउटपुट कर सकते हैं।

आपके एल्गोरिथ्म को किसी भी सकारात्मक पूर्णांक इनपुट के लिए सिद्धांत रूप में काम करना चाहिए : यह विफल हो सकता है क्योंकि आपकी भाषा के पूर्णांक की सटीकता आउटपुट के लिए बहुत छोटी है; लेकिन विफल नहीं हो सकता क्योंकि आधार रूपांतरण केवल कुछ सीमा तक परिभाषित है।

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

input  output
   1     1
   2     2
   3     11
   4     75
   5     694
   6     8345
   7     123717
  17     49030176097150555672
  20     5271200265927977839335179
  35     31553934355853606735562426636407089783813301667210139
  63     3625251781415299613726919161860178255907794200133329465833974783321623703779312895623049180230543882191649073441
 257     87678437238928144977867204156371666030574491195943247606217411725999221158137320290311206746021269051905957869964398955543865645836750532964676103309118517901711628268617642190891105089936701834562621017362909185346834491214407969530898724148629372941508591337423558645926764610261822387781382563338079572769909101879401794746607730261119588219922573912353523976018472514396317057486257150092160745928604277707892487794747938484196105308022626085969393774316283689089561353458798878282422725100360693093282006215082783023264045094700028196975508236300153490495688610733745982183150355962887110565055971546946484175232

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

OEIS: A049363 - आधार n में सबसे छोटी पंडितजी संख्या भी।

code-golf  sequence  number-theory  base-conversion 
— जोनाथन एलन
स्रोत

जवाबों:

11

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

ṖaWḅ

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

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

ṖaWḅ  Main link. Argument: n

Ṗ     Pop; yield [1, 2, 3, ..., n-1].
  W   Wrap; yield [n].
 a    Logical AND; yield [n, 2, 3, ..., n-1].
   ḅ  Convert the result from base n to integer.
— डेनिस
स्रोत
मैं जगह के मूल्यों को भूल गया, मेरी lousy 7 को हरा सकता है :)
— जोनाथन एलन
काश कोडगुल्फ़ पर प्रति उपयोगकर्ता प्रति चार्ट बनाम बाइट्स का उपयोग होता। हो सकता है कि कुल बाइट्स का एक प्लॉट बनाम वर्तमान प्रतिनिधि का उपयोग किया गया हो।
— फिलिप हगलुंड
मुझे थोड़ा समझ में आया कि यह क्यों काम करता है ... चुपके से किया!
— ग्रेग मार्टिन
9

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

f=lambda n,k=1:n*(n<k+2)or-~f(n,k+1)*n-k

Ideone पर इसका परीक्षण करें ।

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

N अलग अंकों के साथ एक संख्या स्पष्ट रूप से आधार b । N में व्यक्त की जानी चाहिए । चूंकि हमारा लक्ष्य संख्या को कम करने के लिए है, ख भी संभव के रूप में छोटे इतनी के रूप में किया जाना चाहिए ख = n तार्किक विकल्प है।

जो अंकों को यथासंभव छोटा बनाने के लिए अंक 0,…, n-1 की व्यवस्था के साथ हमें छोड़ देता है, जिसका अर्थ है कि सबसे महत्वपूर्ण अंकों को यथासंभव छोटा रखा जाना चाहिए। चूंकि पहला अंक कैनोनिकल प्रतिनिधित्व में 0 नहीं हो सकता है , इसलिए सबसे छोटी संख्या
(1) (0) (2) ... (n-2) (n-1) n = n n-1 + 2n n-3 है + ... + (n-2) n + (n-1) , जो च computes रिकर्सिवली।

— डेनिस
स्रोत
6

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

यह एक बहुत बहुत है ! तेज, पुनरावृत्त समाधान।

n=r=input();k=2
while k<n:r=r*n+k;k+=1
print r

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

कोई पुनरावृत्ति नहीं है, इसलिए यह बड़े इनपुट के लिए काम करता है। यहां n = 17000(1-2 सेकंड में) का परिणाम है :

http://pastebin.com/UZjgvUSW

— mbomb007
स्रोत
इनपुट 17000 में कितना समय लगा? मेरी मशीन पर 26 सेकंड लगते हैं, जो कि जेली के 0.9 सेकंड की तुलना में धीमा लगता है ...
— डेनिस
तीन बाइट्स के लिए इसी तरह के लेकिन अन्य तरीके से कम:lambda n:n**~-n+sum(i*n**(n+~i)for i in range(2,n))
— जोनाथन एलन
2
46 बाइट्स और बहुत तेज:n=r=input();k=2\nwhile k<n:r=r*n+k;k+=1\nprint r
— डेनिस
हां, यह आश्चर्यजनक है कि पायथन में समझ की तुलना में लूप्स कितनी तेज हैं।
— जोनाथन एलन
@JonathanAllan इसका कारण नहीं है। शक्तियों का कम्प्यूटिंग बहुत धीमा है, जबकि लूप केवल गुणा और जोड़ का उपयोग करता है।
— डेनिस
5

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

f=(b,n=b)=>n>2?f(b,--n)*b+n:b
— नील
स्रोत
5

जे, 9 बाइट्स

#.],2}.i.

@ डेनिस विधि के आधार पर ।

प्रयोग

   f =: #.],2}.i.
   (,.f"0) >: i. 7
1      1
2      2
3     11
4     75
5    694
6   8345
7 123717
   f 17x
49030176097150555672

व्याख्या

#.],2}.i.  Input: n
       i.  Get range, [0, 1, ..., n-1]
    2}.    Drop the first 2 values, [2, 3, ...., n-1]
  ]        Get n
   ,       Prepend it, [n, 2, 3, ..., n-1]
#.         Convert that to decimal from a list of base-n digits and return

क्रमपरिवर्तन सूचकांक के उपयोग के आधार पर एक वैकल्पिक समाधान है। इनपुट n को देखते हुए , अंकों की सूची बनाएं [0, 1, ..., n], और n के एक सूचकांक का उपयोग करके क्रमचय ज्ञात करें ! और इसे आधार- n अंकों की सूची के रूप में परिवर्तित करें । 12 बाइट्स के लिए जम्मू में इसी समाधान

#.]{.!A.i.,]  Input: n
        i.    Make range [0, 1, ..., n-1]
           ]  Get n
          ,   Join, makes [0, 1, ..., n-1, n]
     !        Factorial of n
      A.      Permutation index using n! into [0, 1, ..., n]
  ]           Get n
   {.         Take the first n values of that permutation
              (This is to handle the case when n = 1)
#.            Convert that to decimal from a list of base-n digits and return
— मील की दूरी पर
स्रोत
यह निर्माण करने के लिए छोटा हो सकता है [1,0,2,3,...,n-1]?
— जोनाथन एलन
1
@JonathanAllan मुझे कोई रास्ता नहीं मिल रहा है, लेकिन मैंने नोटिस किया कि उन लोगों के क्रमपरिवर्तन सूचकांकों ( n -1) होंगे!
— मील
4

रूबी, 37 35 34 बाइट्स

->n{s=n;(2...n).map{|d|s=s*n+d};s}

किसी दिए गए उत्तर का आधार में रूप nलेता है । एक उदाहरण के रूप में उपयोग करना :10234...(n-1)nn=10

इसके साथ शुरू करें n:10

n2 से गुणा करें और जोड़ें:102

इसके द्वारा परस्पर जुड़कर n3 जोड़ें:1023

और इसी तरह।

संपादित करें: मानचित्र का उपयोग करने के लिए छोटा, ऐसा लगता है।

संपादित 2: टिप के लिए धन्यवाद, एम- chrzan!

— ली डब्ल्यू
स्रोत
(2...n)एक बाइट कम होगी।
— m-chrzan
3

CJam (9 बाइट्स)

qi_,X2$tb

ऑनलाइन डेमो

विच्छेदन

जाहिर है डिजिटल विविधता के साथ सबसे छोटी संख्या nआधार को परिवर्तित करके पाया जाता है [1 0 2 3 ... n-1]आधार में n। हालाँकि, ध्यान दें कि बिल्ट-इन बेस को डिजिट की सीमा में होना आवश्यक नहीं है 0 .. n-1।

qi    e# Read integer from stdin
_,    e# Duplicate and built array [0 1 ... n-1]
X2$t  e# Set value at index 1 to n
b     e# Base conversion

ध्यान दें कि विशेष मामले में n = 1हम 1 [0] 1 1 tbदे रहे हैं 1 [0 1] bजो है 1।

— पीटर टेलर
स्रोत
3

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

f n=foldl((+).(*n))n[2..n-1]

तह के माध्यम से हॉर्नर की विधि का उपयोग करके सूची [n,2,3,...,n-1]को आधार में परिवर्तित करता है n। इसका एक कम गोल्फ वाला संस्करण OEIS पेज पर दिया गया है ।

3 बाइट्स के लिए nimi को धन्यवाद!

— XNOR
स्रोत
मैं हास्केल को अच्छी तरह से नहीं जानता, क्या गुना fको एक गोल्फ समाधान के रूप में नाम ( ?) रखने की आवश्यकता है? (यह सिर्फ fकोड में बाद में संदर्भित नहीं है)
— जोनाथन एलन
@ जोनाथनअल्लन हास्केल में लैम्ब्डा फंक्शन फॉर्म है \n->fold1..., जो कि नामकरण के रूप में लंबा है। आप एक बिंदु-मुक्त फ़ंक्शन लिख सकते हैं, जहां इनपुट चर का नाम उप-कार्यों के संयोजन से नहीं है, लेकिन यहां तीन संदर्भों के साथ भयानक होगा n।
— xnor
कूल, स्पष्टीकरण के लिए धन्यवाद। हास्केल सिंटैक्स मुझे कुछ हद तक भ्रमित करता है।
— जोनाथन एलन
आप का उपयोग कर सकते हैं foldlऔर इसके साथ शुरू कर सकते हैं n:f n=foldl((+).(*n))n[2..n-1]
— nimi
3

05AB1E , 9 बाइट्स

DL¦¨v¹*y+

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

व्याख्या

n = 4 उदाहरण के लिए इस्तेमाल किया।

D           # duplicate input
            # STACK: 4, 4
 L          # range(1, a)
            # STACK: 4, [1,2,3,4]
  ¦¨        # remove first and last element of list
            # STACK: 4, [2,3]
    v       # for each y in list
     ¹*     # multiply current stack with input
       y+   # and add y
            # STACK, first pass: 4*4+2 = 18
            # STACK, second pass: 18*4+3 = 75
— Emigna
स्रोत
2

सी ++ - 181 55

का उपयोग कर के बारे में था कि असली शांत समाधान पोस्ट करने के लिए <numeric>:

#import <vector>
#import <numeric>
using namespace std;int f(int n){vector<int> v(n+1);iota(v.begin(),v.end(),0);swap(v[0],v[1]);return accumulate(v.begin(),v.end()-1,0,[n](int r,int a){return r*n+a;});}

और उसके बाद मैं महसूस किया कि यह है जिस तरह से आसान:

int g(int n){int r=n,j=2;for(;j<n;)r=r*n+j++;return r;}
— Anedar
स्रोत
2

पर्ल 6 ,  34 31  30 बाइट्स

OEIS पृष्ठ पर हास्केल उदाहरण से अनुवादित ।

{(1,0,|(2..^$^n)).reduce: $n×*+*}        # 34
{(1,0,|(2..^$^n)).reduce: $n* *+*}       # 34

{reduce $^n×*+*,1,0,|(2..^$n)}           # 31
{[[&($^n×*+*)]] 1,0,|(2..^$n)}           # 31

{reduce $_×*+*,1,0,|(2..^$_)}            # 30
  • [&(…)]…इन-प्लेस इनफ़िक्स ऑपरेटर में बदल जाता है
  • […]बारी-बारी से ऊपर (या दाएँ से बाएँ ऑपरेटर संबद्धता के आधार पर) एक गुना में एक इन्फ़िक्स सेशन से पता चला

विस्तारित:

{
  reduce

    # declare the blocks only parameter ｢$n｣ ( the ｢^｣ twigil )
    # declare a WhateverCode lambda that takes two args ｢*｣
    $^n × * + *

    # a list that always contains at least (1,0)
    1, 0,
    # with a range slipped in
    |(
      2 ..^ $n # range from 2 up-to and excluding ｢$n｣
               # it is empty if $n <= 2
    )
}

उपयोग:

my &code = {reduce $_×*+*,1,0,|(2..^$_)}

say code 1; # 1
say code 2; # 2
say code 3; # 11
say code 4; # 75
say code 7; # 123717

# let's see how long it takes to calculate a largish value:

my $start-time = now;
$_ = code 17000;
my $calc-time = now;
$_ = ~$_; # 25189207981120412047...86380901260421982999
my $display-time = now;

say "It takes only { $calc-time - $start-time } seconds to calculate 17000";
say "but { $display-time - $calc-time } seconds to stringify"

# It takes only 1.06527824 seconds to calculate 17000
# but 5.3929017 seconds to stringify
— ब्रैड गिल्बर्ट b2gills
स्रोत
2

ब्रेन-फ्लैक , 84 76 बाइट्स

8 बाइट गोल्फिंग के लिए गेहूं जादूगर के लिए धन्यवाद

(({})<>){(({}[()]))}{}(<{}{}>)((())){{}({<({}[()])><>({})<>}{}{})([][()])}{}

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

व्याख्या

कार्यक्रम से मूल्यों को धक्का 0करने n-1के लिए ढेर शीर्ष बदल देता है 0और 1साथ 1और 0। फिर यह ढेर के शीर्ष को गुणा करता हैn और इसके नीचे के मूल्य को जोड़ता है जब तक कि स्टैक पर केवल एक मूल्य शेष न हो।

मूल रूप से यह आधार में सबसे छोटी संख्या के लिए अंक पाता nहै जिसमें nअलग-अलग अंक होते हैं ( n> 1 के लिए यह हमेशा फॉर्म का होता है 1023...(n-1))। इसके बाद अंकों और आधार को दिए गए संख्या की गणना करता है।

एनोटेट कोड

(({})<>)       # Pushes a copy of n to the right stack and switches to right stack
{(({}[()]))}{} # While the top of the stack != 0 copy the top of the stack-1
               #   and push it
(<{}{}>)       # Discard the top two values (0 and 1 for n > 1) and push 0
((()))         # Push 1 twice (second time so that the loop is works properly)
{{}            # Loop while stack height > 1
  (            #   Push...
    {<({}[()])><>({})<>}{} # The top value of the stack * n
    {}         #     Plus the value below the top of the stack
  )            #   End push
([][()])}{}    # End loop
— 0 '
स्रोत
आप बदल सकते हैं {}{}(()(<()>))([][()])के साथ (<{}{}>)([(())][])करने के लिए बचाने चार बाइट्स
— पोस्ट रॉक Garf हंटर
इसके बाद आप (<{}{}>)((()))चार और बाइट्स को बचाने के लिए बदल सकते हैं
— पोस्ट रॉक गार्फ हंटर
1

PHP, 78 बाइट्स

for(;$i<$a=$argn;)$s=bcadd($s,bcmul($i<2?1-$i:$i,bcpow($a,$a-1-$i++)));echo$s;

ऑनलाइन संस्करण

60 बाइट्स टेस्टेसिस में सटीकता के साथ केवल n = 16 तक काम करते हैं

एन = 144 इंफो के लिए

n = 145 नान

for(;$j<$a=$argn;)$t+=($j<2?1-$j:$j)*$a**($a-1-$j++);echo$t;
— जार्ग हुल्सरमन
स्रोत
0

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

उपयोग नहीं करता है =>

function f(b,n){throw f(b,n>2?--n:1)*b}
— user71511
स्रोत
PPCG में आपका स्वागत है!
— स्टीफन
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.