Eine positive Ganzzahl kann in einer Ganzzahlbasis dargestellt werden 1 <= b < inf.

Bei der Konvertierung in diese Basis weist sie eine Reihe von unterschiedlichen Ziffern auf.

Jede positive Ganzzahl in der Basis 1hat eine 1eindeutige Ziffer.

Die meisten positiven Ganzzahlen in der Basis 2haben 2unterschiedliche Ziffern, mit Ausnahme derjenigen der Form 2^n - 1, die nur eine haben 1.

Die erste positive Ganzzahl, die in einer Ganzzahlbasis mit einer 1eindeutigen Ziffer dargestellt werden kann, ist also 1und die erste, die mit 2unterschiedlichen Ziffern dargestellt werden kann, ist 2.

Wir können sagen, dass dies 1die erste Ganzzahl mit digitaler Diversität 1und 2die erste Ganzzahl mit digitaler Diversität ist 2.

Herausforderung:

Bei einer positiven Ganzzahl wird ndie erste positive Ganzzahl (in Basis 10 *) mit einer digitalen Diversität von zurückgegeben n.

* Wenn Ihre Sprache nur eine bestimmte Basis unterstützt (z. B. unär oder binär), können Sie in dieser Basis ausgeben.

Ihr Algorithmus muss theoretisch für jede positive Ganzzahleingabe funktionieren : Er kann fehlschlagen, weil die Genauigkeit der Ganzzahl Ihrer Sprache für die Ausgabe zu gering ist. Dies kann jedoch nicht scheitern, da die Basiskonvertierung nur bis zu einem gewissen Grad definiert ist.

Testfälle

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

Dies ist Code-Golf , die kürzeste Lösung in Bytes gewinnt.

OEIS: A049363 - auch kleinste pandigitale Zahl in Basis n.

Gelee , 4 Bytes

ṖaWḅ

Probieren Sie es online! oder überprüfen Sie alle Testfälle

Wie es funktioniert

Ṗ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.

Python, 40 Bytes

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

Teste es auf Ideone .

Wie es funktioniert

Eine Zahl mit n verschiedenen Ziffern muss eindeutig in der Basis b ≥ n ausgedrückt werden . Da es unser Ziel ist, die Anzahl zu minimieren, sollte b auch so klein wie möglich sein, so dass b = n die logische Wahl ist.

Das lässt uns die Ziffern 0,…, n-1 so anordnen , dass eine möglichst kleine Zahl entsteht, was bedeutet, dass die höchstwertigen Ziffern so klein wie möglich gehalten werden müssen. Da die erste Ziffer in der kanonischen Darstellung keine 0 sein kann , ist die kleinste Zahl
(1) (0) (2) ... (n-2) (n-1) _n = ^nn-1 + 2nn ^-3 +… + (N-2) n + (n-1) , was f rekursiv berechnet.

Python 2, 54 46 Bytes

Das ist ein sehr sehr sehr ! schnelle, iterative Lösung.

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

Probieren Sie es online aus

Es gibt keine Rekursion, daher funktioniert es bei großen Eingaben. Hier ist das Ergebnis von n = 17000(dauert 1-2 Sekunden):

http://pastebin.com/UZjgvUSW

JavaScript (ES6), 29 Byte

f=(b,n=b)=>n>2?f(b,--n)*b+n:b

J 9 Bytes

#.],2}.i.

Basierend auf der @ Tennis- Methode .

Verwendung

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

Erläuterung

#.],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

Es gibt eine alternative Lösung, die auf der Verwendung des Permutationsindex basiert. Wenn Sie n eingeben , erstellen Sie die Liste der Ziffern [0, 1, ..., n]und suchen Sie die Permutation mit einem Index von n ! Und konvertieren Sie diesen als Liste der Basis- n- Ziffern. Die entsprechende Lösung in J für 12 Bytes

#.]{.!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

Ruby, 37 35 34 Bytes

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

Die Antwort für eine gegebene nnimmt die Form 10234...(n-1)in der Basis an n. Am n=10Beispiel:

Beginnen Sie mit n:10

Multiplizieren Sie mit nund addieren Sie 2:102

Multiplizieren Sie mit nund addieren Sie 3:1023

Und so weiter.

EDIT: Kürzere Karte verwenden, wie es scheint.

EDIT 2: Danke für den Tipp, m-chrzan!

CJam , 9 Bytes

ri__,2>+b

Probieren Sie es online!

Erläuterung

ri   e# Read input N.
__   e# Make two copies.
,    e# Turn last copy into range [0 1 2 ... N-1].
2>   e# Discard up to two leading values.
+    e# Prepend a copy of N.
b    e# Treat as base-N digits.

CJam (9 Bytes)

qi_,X2$tb

Online-Demo

Präparation

Offensichtlich die kleinste Nummer mit digitaler Vielfalt n durch Basisumwandlung [1 0 2 3 ... n-1]in Basis gefunden n. Beachten Sie jedoch, dass für die integrierte Basiskonvertierung nicht erforderlich ist, dass die Ziffern im Bereich liegen 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

Beachten Sie, dass in dem speziellen Fall n = 1wir geben bekommen 1 [0] 1 1 tb, 1 [0 1] bwas ist 1.

Haskell, 31 Bytes

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

Konvertiert die Liste [n,2,3,...,n-1]in eine Basisn mithilfe der Horner-Methode durch Falten . Eine weniger Golf-Version davon finden Sie auf der OEIS-Seite .

Danke an nimi für 3 Bytes!

05AB1E , 9 Bytes

DL¦¨v¹*y+

Probieren Sie es online!

Erläuterung

n = 4 zum Beispiel verwendet.

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

C ++ - 181 55

Wollte diese wirklich coole Lösung posten mit <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;});}

und dann wurde mir klar, dass es viel einfacher ist:

int g(int n){int r=n,j=2;for(;j<n;)r=r*n+j++;return r;}

Perl 6 ,  34 31  30 Bytes

Übersetzt aus dem Haskell-Beispiel auf der OEIS-Seite .

{(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

• [&(…)] wendet sich … in einen In-Place-Infix-Operator
• Das […]oben gezeigte verwandelt ein Infix-Op in eine Falte (links oder rechts, abhängig von der Assoziativität des Operators)

Erweitert:

{
  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
    )
}

Verwendung:

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

Brain-Flak , 84 76 Bytes

Dank an Wheat Wizard für das Golfen von 8 Bytes

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

Probieren Sie es online!

Erläuterung

Das Programm überträgt die Werte von 0bis n-1zum Stapel und ersetzt das obere 0und 1mit 1und 0. Dann multipliziert es die Oberseite des Stapels mitn und addiert den Wert darunter, bis nur noch ein Wert auf dem Stapel vorhanden ist.

Im Wesentlichen findet es die Ziffern für die kleinste Zahl in der Basis n, die nverschiedene Ziffern enthält (für n> 1 ist es immer von der Form 1023...(n-1)). Anschließend berechnet es die Zahl anhand der Ziffern und der Basis.

Kommentierter Code

(({})<>)       # 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

Julia, 26 Bytes

\(n,k=n)=k<3?n:n\~-k*n+~-k

Probieren Sie es online!

ShapeScript , 25 Byte

_0?1'1+@2?*1?+@'2?2-*!#@#

Die Eingabe ist unär, die Ausgabe erfolgt dezimal. Probieren Sie es online!

PHP, 78 Bytes

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

Online Version

60 Bytes funktionieren nur bis n = 16 mit der Genauigkeit in den Testfällen

Für n = 144 INF

n = 145 NAN

for(;$j<$a=$argn;)$t+=($j<2?1-$j:$j)*$a**($a-1-$j++);echo$t;

k, 12 Bytes

Basierend auf Dennis 'Antwort .

{x/x,2+!x-2}

JavaScript (ES6), 39 Byte

Verwendet nicht =>

function f(b,n){throw f(b,n>2?--n:1)*b}