Geben Sie bei einer Ganzzahl Ndie Ndritte positive Zahl Kmit der folgenden Eigenschaft in Dezimalbasis aus:

Für jede Ziffer Ian der Position Pvon Kist die Kdurch Entfernen der Pdritten Ziffer (dh I) gebildete Zahl durch teilbar I.

Beispiel und Bemerkungen

324 ist eine solche Zahl:

• 3 teilt 24
• 2 teilt 34
• 4 teilt 32

Anmerkung 1: Wir gehen davon aus, dass die leere Zahl durch irgendetwas teilbar ist, wie z 0. Daher 1, 2, 3, 4, 5, 6, 7, 8und 9gültig sind.

Hinweis 2: K Kann die Ziffer nicht enthalten 0, da Sie nicht durch dividieren können 0.

Eingänge und Ausgänge

• Sie können die Eingabe als Funktionsargument STDINusw. verwenden.
• Sie können die Ausgabe von einer Funktion über STDOUTusw. zurückgeben.
• Sie können diese Zahlen ab 0(in welchem ​​Fall N >= 0) oder ab 1(in welchem ​​Fall N > 0) indizieren , je nachdem, was für Sie am besten geeignet ist.

Testfälle

Diese Beispiele werden von indiziert. 0Wenn Sie also von indiziert haben 1, fügen Sie sie 1zu den Zahlen in der NSpalte hinzu.

N    Output
0    1
4    5
8    9
15   77
16   88
23   155
42   742
47   1113
121  4244
144  6888
164  9999

Wertung

Dies ist Code-Golf , daher gewinnt die kürzeste Antwort in Bytes.

Gelee , 21 19 Bytes

DLR©œ^€®ịDḌḍ@DPȧµ#Ṫ

Die Eingabe ist 1-indiziert. Probieren Sie es online aus!

Wie es funktioniert

DLR©œ^€®ịDḌḍ@DPȧµ#Ṫ  Main link. No arguments.

                µ    Convert the chain to the left into a link.
                 #   Read n from STDIN and execute the link to the left for
                     k = 0, 1, 2, ... until n value return a truthy value.
D                      Convert D to base 10 (digit array).
 LR                    Construct the range from 1 to the length of the digit array.
   ©                   Copy the range to the register.
       ®               Yield the value of the register.
    œ^€                Take the multiset difference of each element of the range
                       and the range itself.
        ịD             Index into the digit array.
          Ḍ            Convert each list of digits to integer.
                       This yields all numbers with one suppressed digit.
           ḍ@D         Test each of these numbers for divisibility by the
                       suppressed digit from the digit array.
              P        Take the product of the resulting Booleans.
               ȧ       Logical AND with k (k would return 1).
                  Ṫ  Tail; extract the last (nth) element.

Pyth, 20

e.f!s.e.x%s.D`Zksb1`

Probieren Sie es hier aus oder führen Sie die Test Suite aus

N ist für diese Antwort 1-indiziert.

Verwendet weitgehend die gleiche Logik wie mein Python-Skript. Bemerkenswerte Unterschiede bestehen darin .D, die Ziffer während des Tests aus der Zeichenfolge zu löschen und die Ausnahmebehandlung zu verwenden, um mit Nullstellen umzugehen.

Pyth, 26 Bytes

e.f&!/J`Z\0!s%VsM.DLJUJjZT

Testsuite.

e.f&!/J`Z\0!s%VsM.DLJUJjZT
e.f                          The n-th number (Z) where:
    !/J`Z\0                      Z does not contain "0"
   &                             and
           !s                    the following does not contain zero:
               sM.DLJUJ              generate the set of the digits removed
                       jZT           all the digits
             %V                      modulus in parallel
                                     if Z is 324,
                                     the first set would be [24,34,32]
                                     the second set would be [3,2,4]
                                     the third set would be [24%3, 34%2, 32%4]

Python 2, 93 Bytes

n=input();r=0
while n:r+=1;k=t=1;exec't&=(r/k/10*k+r%k)%(r/k%10or r)<1;k*=10;'*r;n-=t
print r

Sehr ineffizient. Die Eingabe ist 1-indiziert. Testen Sie es auf Ideone .

Alternative Version, 100 Bytes

Der obige Code führt ungefähr 10 ^x Teilbarkeitstests durch, bei denen nur x erforderlich sind. Auf Kosten von nur 7 zusätzlichen Bytes , kann die Effizienz erheblich verbessert werden, entweder durch Ersetzen *rmit *len(`r`)oder durch den Code Refactoring wie folgt.

n=input();r=0
while n:
 r+=1;k=t=1
 for _ in`r`:t&=(r/k/10*k+r%k)%(r/k%10or r)<1;k*=10
 n-=t
print r

Dies behandelt alle Testfälle problemlos , auch auf Ideone .

JavaScript (ES6), 82 78 76 Byte

f=(n,k=0)=>n?f(n-!eval(/0/.test(++k)+`${k}`.replace(/./g,"|'$`$''%$&")),k):k

Die Eingabe ist 1-indiziert. Baut auf, indem eine Zeichenfolge des Formulars erstellt false|'24'%3|'34'%2|'32'%4und ausgewertet wird. Zeichenfolgen werden verwendet, da sie im einstelligen Fall noch syntaktisch gültig sind.

Die Rekursion begrenzt dies auf ungefähr n = 119. Iterative Version für 88 84 82 Bytes:

n=>{for(k=0;n;n-=!eval(/0/.test(++k)+`${k}`.replace(/./g,"|'$`$''%$&")));return l}

Bearbeiten: 2 Bytes dank @ Dennis ♦ gespeichert.

Ruby, 90

f=->n,s=?0{0while s.next![?0]||s[1]&&/t/=~s.gsub(/\d/){eval"#$`#$'%#$&>0"};n<1?s:f[n-1,s]}

Ähnliche Herangehensweise an Neils Javascript-Antwort, jedoch aufgrund längerer impliziter Typkonvertierung erheblich länger (außer dass Boolesche Werte von durch in Zeichenfolgen konvertiert werden gsub, was sehr schön ist).

Ruby, 109 Bytes

->n{i=s=1;n.times{s=?0;s="#{i+=1}"while s[?0]||(0...x=s.size).any?{|i|(s[0,i]+s[i+1,x]).to_i%s[i].to_i>0}};s}

Hoon , 246 Bytes

=+
x=0
|=
n/@
=+
k=<x>
=+
%+
levy
%+
turn
(gulf 0 (dec (lent k)))
|=
a/@
=+
(trim +(a) k)
=+
(rash (snag a p) dit)
?:
=(- 0)
|
=(0 (mod (fall (rust (weld (scag a p) q) dem) x) -))
(curr test &)
?:
=(- &)
?:
=(0 n)
x
$(n (dec n), x +(x))
$(x +(x))

Ungolfed:

=+  x=0
|=  n/@
=+  k=<x>
=+  %+  levy
  %+  turn  (gulf 0 (dec (lent k)))
  |=  a/@
  =+  (trim +(a) k)
  =+  (rash (snag a p) dit)
  ?:  =(- 0)
    |
  =(0 (mod (fall (rust (weld (scag a p) q) dem) x) -))
(curr test &)
?:  =(- &)
  ?:  =(0 n)
    x
  $(n (dec n), x +(x))
$(x +(x))

Das ... ist wirklich schrecklich. Ich fühle mich schmutzig, weil ich das gepostet habe.

Stellen Sie kdie Zeichenfolgenform der aktuellen Nummer ein und ordnen Sie sie der Liste zu [0...(length k)-1], die die Zeichenfolge an diesem Index aufteilt ( a). Holen Sie sich das aZeichen, analysieren Sie es auf eine Zahl, und wenn es 0Nein zurückgibt . Holen Sie sich das Präfix von aund schweißen Sie es an die andere Hälfte der Teilung, analysieren Sie eine Zahl und prüfen Sie, ob der Index sie gleichmäßig teilt.

++levygibt yes zurück, wenn der Aufruf der Funktion für alle Elemente der Liste ebenfalls yes ist. In diesem Fall ist die Funktion ++testmit yes verknüpft, sodass überprüft wird, ob alle Zeichen kfunktionieren.

Wenn wir den 0. Wert haben, geben wir die aktuelle Zahl zurück, oder wir wiederholen mit n dekrementiert (und inkrementiert x).