Kleinstes Vielfaches von 9, gefolgt von einem optionalen Lauf von 0


22

Ermitteln Sie bei einer positiven Ganzzahl das kleinste positive Ganzzahl-Vielfache, dh einen Lauf von 9, gefolgt von einem optionalen Lauf von 0. Mit anderen Worten, ermitteln Sie das kleinste positive Ganzzahl-Vielfache, das mit dem regulären Ausdruck übereinstimmt /^9+0*$/.

Wenn zum Beispiel die angegebene positive Ganzzahl 2 ist, wird 90 zurückgegeben, da 90 ein positives ganzzahliges Vielfaches von 2 ist und das kleinste ist, mit dem der reguläre Ausdruck übereinstimmt /^9+0*$/.

Testfälle:

n  f(n)
1  9
2  90
3  9
4  900
5  90
6  90
7  999999
8  9000
9  9
10 90
11 99
12 900
13 999999
14 9999990
15 90
16 90000

Das ist . Kürzeste Antwort in Bytes gewinnt. Es gelten Standardlücken .


3
Beweis der Klarheit?
Destructible Lemon

2
@DestructibleLemon Dieser Beweis ist ausreichend, da das Ergebnis mit 9 multipliziert werden kann.
xnor

1
Ich denke, mehr Testfälle wären gut, um zu überprüfen, ob die 9 vor der 0 stehen muss.
Xnor

2
@LeakyNun vielleicht nicht, aber 9900099 ist und sollte nicht nach Regeln erlaubt sein.
DrQuarius

2
@koita_pisw_sou Die Regel ist, dass das Programm "theoretisch" für eine beliebige Ganzzahl mit beliebiger Genauigkeit, beliebigem Speicher und beliebiger Zeit arbeiten soll.
Undichte Nonne

Antworten:


6

Jelly , 13 11 Bytes

ṚḌ‘DS=ḍ@ð1#

Probieren Sie es online!

Wie es funktioniert

ṚḌ‘DS=ḍ@ð1#  Main link. Argument: n

        ð    Start a dyadic chain with arguments n and n.
         1#  Execute the chain to the left with left argument k = n, n+1, n+2, ...
             and right argument n until 1 match has been found. Return the match.
Ṛ                Get the decimal digits of k, reversed.
 Ḍ               Convert from base 10 to integer.
                 This essentially removes trailing zeroes. As a side effect, it
                 reverses the digits, which doesn't matter to us.
  ‘              Increment the resulting integer. If and only if it consisted
                 entirely of 9's, the result is a power of 10.
   DS            Compute the sum of the digits. The sum is 1 if and only if the
                 integer is a power of 10. Note that the sum cannot be 0.
      ḍ@         Test k for divisibility by n.
     =           Compare the results.

4
ಠ_ಠ wie hast du es mit keiner 9oder 0in deinem Code gemacht
Pavel

Ich habe eine Erklärung hinzugefügt.
Dennis



5

JavaScript (ES6), 47 43 42 Byte

-4 Byte dank @Arnauld
-1 Byte dank @Luke

n=>eval('for(i=0;!/^9+0*$/.test(i);)i+=n')

Tests

let f=
n=>eval('for(i=0;!/^9+0*$/.test(i);)i+=n')

for(let i=1;i<=16;i++)console.log(`f(${i}) = `+f(i))

Rekursive Lösung (schlägt für 7, 13 und 14 fehl), 38 Byte

n=>g=(i=0)=>/^9+0*$/.test(i+=n)?i:g(i)

Genannt wie f(5)(). Erreicht die max Call - Stack Größe in Chrome und Firefox für n=7, n=13und n=14.


3
Ein Byte kürzer:n=>eval('for(i=0;!/^9+0*$/.test(i);)i+=n')
Luke


4

Java 8, 61 57 Bytes

n->{int r=0;for(;!(""+r).matches("9+0*");r+=n);return r;}

-4 Bytes (und schnellere Ausführung) dank @JollyJoker .

Erläuterung:

Probieren Sie es hier aus.

n->{                              // Method with integer as parameter and return-type
  int r=0;                        //  Result-integer
  for(;!(""+r).matches("9+0*");   //  Loop as long as `r` doesn't match the regex
    r+=n                          //   And increase `r` by the input every iteration
  );                              //  End of loop
  return r;                       //  Return the result-integer
}                                 // End of method

Ja zur Optimierung! ^^
Olivier Grégoire

1
Durch Erhöhen um n wird der r%nScheck vermieden .n->{int r=0;for(;!(""+(r+=n)).matches("9+0*"););return r;}
JollyJoker

for(;!(""+r).matches("9+0*");r+=n)
JollyJoker

Ich habe versucht, und versucht, mit ganzen Zahlen und Mathe auszukommen, aber ich kann das nicht schlagen! Herzlichen Glückwunsch :)
Olivier Grégoire


3

Brachylog , 16 Bytes

;I×≜.ẹḅhᵐc~a₀90∧

Probieren Sie es online!

Das ist ziemlich langsam

Erläuterung

;I×≜.              Output = Input × I
    .ẹḅ            Deconcatenate into runs of consecutive equal digits
       hᵐ          Take the head of each run
         c         Concatenate into a number
          ~a₀90∧   That number is a prefix of 90 (i.e. it's 9 or 90)


2

RProgN 2 , 18 Bytes

x={x*'^9+0*$'E}éx*

Erklärt

x={x*'^9+0*$'E}éx*
x=                  # Set the value of "x" to the input.
  {           }é    # Find the first positive integer in which passing it to the defined function returns truthy.
   x*               # Multiply the index by x, this essentially searches multiples now.
     '^9+0*$'       # A Regex defined by a literal string.
             E      # Does the multiple match the regex?
                x*  # Multiple the outputted index by x, giving the result.

Probieren Sie es online!


2

Mathematik , 71 Bytes

(x=#;While[!StringMatchQ[ToString@x,RegularExpression@"9+0*"],x+=#];x)&

Probieren Sie es online!

Keine sehr interessante Brute-Force-Lösung, aber sie schlägt die andere Mathematica-Antwort, bei der einige clevere Tricks zum Einsatz kommen.

Der einzige Vorteil, den Mathematica in Bezug auf diese Herausforderung hat, ist die Tatsache, StringMatchQdass eine vollständige Übereinstimmung erforderlich ist, sodass ich dies 9+0*eher tun kann als ^9+0*$.


2
Wenn Sie Mathematica anstelle von Mathics verwenden möchten, können Sie ein paar Bytes mit "9"..~~"0"...anstelle von speichern RegularExpression@"9+0*".
Kein Baum

1
@Notatree danke, ich werde es für ein späteres Mal im Hinterkopf behalten, aber ich bleibe bei Mathics. Ich bevorzuge es, keine Syntax zu verwenden, die ich nicht verstehe, und das ist das erste Mal, dass ich solche Syntax gesehen habe.
Pavel

Meinetwegen. (Die Pattern-Matching-Syntax von Mathematica ist ein leistungsstarkes Werkzeug, aber wenn Sie mit regulären Ausdrücken vertraut sind, wissen Sie das wahrscheinlich bereits!)
Kein Baum

2

Batch, 175 Bytes

@set/pn=
@set s=
:g
@set/ag=-~!(n%%2)*(!(n%%5)*4+1)
@if not %g%==1 set s=0%s%&set/an/=g&goto g
@set r=1
:r
@set s=9%s%
@set/ar=r*10%%n
@if %r% gtr 1 goto r
@echo %s%

Übernimmt die Eingabe für STDIN. Keine Brute-Force-Lösung, sondern basiert in der Tat auf meiner Antwort auf Fraction auf die exakte Dezimalzahl, sodass es für 17, 19 usw. funktioniert, die sonst ohnehin die Ganzzahlgrenze überschreiten würden.


2

Mathematica, 127 Bytes

Select[FromDigits/@Select[Tuples[{0,9},c=#],Count[#,9]==1||Union@Differences@Flatten@Position[#,9]=={1}&],IntegerQ[#/c]&][[1]]&


Eingang

[17]

Ausgabe

9999999999999999

Hier sind die ersten 20 Begriffe

{9, 90, 9, 900, 90, 90, 999999, 9000, 9, 90, 99, 900, 999999, 9999990, 90, 90000, 99999999999999, 90, 999999999999999999, 900}


1
Clever, aber die naheliegende Lösung scheint die kürzeste zu sein: codegolf.stackexchange.com/a/130115/60042
Pavel

Ihre offensichtliche Lösung kann nicht 17 tun
;-)

Was soll ich sagen, nicht schnellste-Code
Pavel

Übrigens, Ihre Lösung funktioniert in Mathematik. Sie können dies ändern und einen TIO-Link hinzufügen.
Pavel


2

Haskell , 53 Bytes

f nimmt und gibt eine ganze Zahl zurück.

f n=filter(all(<'1').snd.span(>'8').show)[n,n+n..]!!0

Probieren Sie es online!

Dies ist eine Zeitüberschreitung von 17, was praktisch jenseits der Testfälle liegt. Eine schnellere Version in 56 Bytes:

f n=[x|a<-[1..],b<-[0..a-1],x<-[10^a-10^b],mod x n<1]!!0

Probieren Sie es online!

Wie es funktioniert

  • fgeneriert alle Vielfachen von n, konvertiert jedes in einen String, filtert diejenigen mit dem richtigen Format heraus und nimmt dann das erste.

  • Die schnellere Version verwendet stattdessen , dass die erforderlichen Zahlen der Form sind 10^a-10^b, a>=1, a>b>=0. Für Golfzwecke wird auch die Tatsache ausgenutzt, dass für das Minimum anur eines arbeiten b kann, wodurch es ermöglicht wird, das bs in der etwas kürzeren "falschen" Reihenfolge zu erzeugen .


1

Ruby , 38 + 1 = 39 Bytes

Verwendet -pFlagge.

$_=y=eval$_
1until"#{$_+=y}"=~/^9+0*$/

-p umgibt das Programm mit:

while gets
    ...
end
puts $_

getsspeichert sein Ergebnis in $_. evalwird verwendet, um es in eine Zahl umzuwandeln, da es kürzer ist als .to_i, dann wird rohe Gewalt angewendet, die $ _ inkrementiert, bis es mit dem regulären Ausdruck übereinstimmt. "#{}"Wenn es sich um eine String-Interpolation handelt, ist sie kürzer als ein .to_sAufruf, da dies Klammern erfordern würde $_+=y. Schließlich $_wird gedruckt.

Probieren Sie es online!

Probieren Sie alle Testfälle aus!



1

C ++, 106 Bytes

int main(){long N,T=9,j=10,M;cin>>N;while(T%N){if(T/j){T+=(M/j);j*=10;}else{T=(T+1)*9;j=10;M=T;}}cout<<T;}

Ausführliches Formular:

int main()
{
    long N,T=9,j=10,M;
    cin >> N;

    while (T%N)
    {
        if (T/j)
        {
            T += (M/j);
            j *= 10;
        }
        else
        {
            T = (T+1)*9;
            j = 10;
            M = T;
        }
    } 

    cout << T;
}

Probieren Sie es online!


Besser Golf spielen: Nimmt [](int n){int T=9,j=10,m;while(t%n)if(t/j){t+=m/j;j*=10;}else{t=(t+1)*9;j=10;m=t;}return t;}}94 Bytes. Behandeln Sie es im Wesentlichen als eine Funktionstask zum Speichern von Bytes, zum Speichern nicht benötigter Klammern und zum Speichern von Typnamen und -typen mithilfe der Lambda-Funktion.
6.

kann es nicht mit Lambda kompilieren. Könntest du helfen?
koita_pisw_sou

Es mag der Grund sein, dass ich am Ende zu viele Klammern gesetzt habe.
7.

Darüber hinaus muss Lambda wahrscheinlich nicht im globalen Bereich vorhanden sein, obwohl das Umbrechen in eine reguläre Funktion 97 Byte dauert.
7.

1

Python 2 , 79 Bytes

x=input();n=10;y=9
while y%x:
 b=n
 while(b-1)*(y%x):b/=10;y=n-b
 n*=10
print y

Probieren Sie es online!

Einige Erklärungen Es findet die kleinste natürliche Formen 10**n-10**bmit , n>b>=0dass teilt die Eingabe.

Einige IO

f(1) = 9
f(2) = 90
f(3) = 9
f(4) = 900
f(5) = 90
f(6) = 90
f(7) = 999999
f(8) = 9000
f(9) = 9
f(10) = 90
f(11) = 99
f(12) = 900
f(13) = 999999
f(14) = 9999990
f(15) = 90
f(16) = 90000
f(17) = 9999999999999999
f(18) = 90
f(19) = 999999999999999999


1

Swift 3.0, Bytes: 121

var i=2,m=1,n=""
while(i>0){n=String(i*m)
if let r=n.range(of:"^9+0*$",options:.regularExpression){print(n)
break};m=m+1}

Probieren Sie es online!


Was macht let r=das? Ich sehe rnirgendwo anders erwähnt
Cyoce

@Cyoce let r = prüft, ob der Wert n.range den Wert nil zurückgibt oder nicht. Sie können let _ = verwenden. Ich verwende hier eine optionale Bindung, um die Anzahl der Bytes zu reduzieren.
A. Pooja

1

Python 3 , 62 Bytes

Diese Funktion nimmt eine ganze Zahl nund initialisiert mauf Null. Dann werden alle Nullen an den Enden von entfernt mund geprüft, ob das Ergebnis nur 9 enthält, und es wird zurückgegeben, mwenn dies der Fall ist. Falls nicht, fügt sie nan mund überprüft erneut, usw.

def f(n,m=0):
 while{*str(m).strip('0')}!={'9'}:m+=n
 return m

Probieren Sie es online!


1

Java (OpenJDK 8) , 66 Bytes, drosselt nicht auf 17

n->{long a=10,b=1;for(;(a-b)%n>0;b=(b<10?a*=10:b)/10);return a-b;}

Probieren Sie es online!

Länger als die Lösung von @ KevinCruijssen , kann jedoch etwas größere Zahlen verarbeiten. Es berechnet die Kandidatenzahlen wie 10 ^ 6 - 10 ^ 3 = 999000. 64-Bit-Longs sind immer noch die Obergrenze und brechen für n = 23.

Kann wahrscheinlich ein bisschen golfen werden, aber es hat schon zu lange gedauert, bis es funktioniert ...


1

> <> , 35 Bytes

&a:v ;n-<
:,a/?(1:^!?%&:&-}:{
a*:\~

Probieren Sie es online aus oder schauen Sie es sich auf dem Fischspielplatz an !

Angenommen, die Eingabe befindet sich bereits auf dem Stapel. Suchen Sie nach Zahlen der Form 10 a  - 10 b , wobei a <b (ja, das ist ein Zeichen weniger als - es dauert weniger Bytes!), Bis dies durch die Eingabe teilbar ist, und drucken Sie dann 10 b  - 10 a . Dies ist viel schneller als die Brute-Force-Methode (die in> <> ohnehin schwierig wäre).


1

V , 19-14 Bytes

é0òÀ/[1-8]ü09

Probieren Sie es online!

Erläuterung

é0              ' <m-i>nsert a 0
  ò             ' <m-r>ecursively
   À            ' <m-@>rgument times
               ' <C-A> increment the number (eventually gives all multiples)
     /[1-8]ü09  ' find ([1-8]|09) if this errors, the number is of the form
                ' (9+0*) (because there won't ever be just zeros)
                ' implicitly end the recursion which breaks on the above error

1

JavaScript (ES6), 51 bis 49 Byte

let
f=(n,x=1,y=1)=>(x-y)%n?f(n,x,y*10):x-y||f(n,x*10)
<input type=number value=1 step=1 min=1 oninput=O.value=f(value)>
<input type=number value=9 id=O disabled>

Nicht die kürzeste Annäherung, aber sie ist schnell böse.


1

Mathematica, 82 Bytes

Unter Verwendung des Einreichungsmusters von @Jenny_mathys Antwort ...

(d=x=1;y=0;f:=(10^x-1)10^y;n:=If[y>0,y--;x++,y=d;d++;x=1];While[Mod[f,#]!=0,n];f)&

Eingang:

[17]

Ausgabe:

9999999999999999

Und relativ zu dem Argument in Kommentaren bei @ Jenny_mathys Antwort mit @Phoenix ... RepeatedTiming[]der Anwendung auf den Eingang [17]gibt

{0.000518, 9999999999999999}

also eine halbe Millisekunde. Sich zu einem etwas größeren Eingang [2003]:

{3.78, 99999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999}

etwas unter 4 Sekunden.

Testtabelle: Bei den ersten 30 positiven ganzen Zahlen sind die Ergebnisse

{9, 90, 9, 900, 90, 90, 999999, 9000, 9, 90, 99, 900, 999999, 
9999990, 90, 90000, 9999999999999999, 90, 999999999999999999, 900, 
999999, 990, 9999999999999999999999, 9000, 900, 9999990, 999, 
99999900, 9999999999999999999999999999, 90}

Erläuterung: Die einzige Magie hier ist der benutzerdefinierte Iterator ("Iterator" im CS-Sinne, nicht der M'ma-Sinn).

n := If[ y>0  ,  y-- ; x++  ,  y=d ; d++ ; x=1]

Dies wirkt sich auf die globalen Variablen x, die Anzahl der führenden "9" y, die Anzahl der nachfolgenden "0" und ddie Gesamtzahl der Ziffern aus. Wir möchten die Anzahl der Stellen durchlaufen und für jede Wahl der Anzahl der Stellen mit den meisten "0" und den geringsten "9" beginnen. Daher initialisiert der Code zuerst dauf 1, erzwingt x1 und y0. Der benutzerdefinierte Iterator überprüft, ob die Zeichenfolge der "0" gekürzt werden kann. In diesem Fall wird die Zeichenfolge von "0" um eins gekürzt und die Zeichenfolge von "1" um eins erhöht. Ist dies nicht der Fall, wird die Anzahl der Stellen erhöht, die Anzahl der "0" auf eins weniger als die Anzahl der Stellen gesetzt und die Anzahl der "9" auf 1 gesetzt.dist der gewünschte Wert von y.)


Und doch noch länger als rohe Gewalt und Regex.
Pavel

@Phoenix: Was ist dein Timing für 2003?
Eric Towers

1

Ti-Basic (TI-84 Plus CE), 48 bis 41 Byte

Prompt X
For(K,1,0
For(M,-K+1,0
10^(K)-10^(-M
If 0=remainder(Ans,X
Return
End
End

Die Eingabe erfolgt Promptwährend des Programms; Die Ausgabe wird in gespeichert Ans.

Erläuterung:

Versucht Zahlen der Form (10 n ) (10 m –1) = 10 k –10 m , wobei m + n = k bei 1 beginnt und zunimmt, und für jeden Wert von k wird versucht, m ​​= 1, n = k -1; m = 2, n = k - 2; ... m = k, n = 0; bis es ein Vielfaches von findet X.

Dies funktioniert bis zu 16; 17 gibt einen Domänenfehler aus, da remainder(nur Dividenden bis zu 9999999999999 (13 Neunen) akzeptiert werden und 17 9999999999999999 (16 Neunen) ausgeben sollte.

Prompt X               # 3 bytes, input number
For(K,1,0              # 7 bytes, k in the description above; until a match is found
For(M,-K+1,0           # 10 bytes, start with n=1, m=(k-n)=k-1;
                           # then n=2, m=(k-n)=k-2, up to n=k, m=(k-n)=0
                           # (M=-m because it saved one byte)
10^(K)-10^(-M           # 8 bytes, n=(k-m) nines followed by m zeroes → Ans
If not(remainder(Ans,X # 8 bytes, If X is a factor of Ans (remainder = 0)
Return                 # 2 bytes, End program, with Ans still there
End                    # 2 bytes,
End                    # 1 byte (no newline)

1

QBIC , 53 Bytes

{p=p+1┘o=p*9_F!o$|┘n=!A!~(_l!n$|=_l!n+1$|)-(o%:)|\_Xo

Erläuterung

{        infinitely DO
p=p+1    raise p (starts out as 0)
┘o=p*9   Get the mext multiple of 9 off of p
_F!o$|   Flip a string representation of p*9
┘n=!A!   and set 'n' to be an int version of the flipped p*9 
         (this effectively drops trailing 0's)
~        This IF will subtract two values: the first is either 0 for n=x^10, or -1
         and the second bit does (p*9) modulo 'a' (input number): also 0 for the numbers we want
(
 _l!n$|  the length of n's string representation
=        is equal to
_l!n+1$| the length of (n+1)'s string rep (81 + 1 = 82, both are 2 long; 99 + 1 = 100, there's a difference)
)        The above yields -1 (Qbasic's TRUE value) for non-9 runs, 0 for n=x^10
-        Subtract from that 
(o%:)    (p*9) modulo a     0 for p*9 = a*y
|       THEN (do nothing, since we want 0+0=0 in the conditionals above, execution of the right path jumps to ELSE
\_Xo    ELSE quit, printing (p*9)

1

C (gcc) 126 Bytes

#include<stdio.h>
main(x,n,y,b){n=10;y=9;scanf("%d",&x);while(y%x){b=n;while((b-1)*(y%x)){b/=10;y=n-b;}n*=10;}printf("%d",y);}

Probieren Sie es online!

Einige Erklärungen Es findet die kleinste natürliche Formen 10**n-10**bmit , n>b>=0dass teilt die Eingabe.

Einige IO

f(1) = 9
f(2) = 90
f(3) = 9
f(4) = 900
f(5) = 90
f(6) = 90
f(7) = 999999
f(8) = 9000
f(9) = 9
f(10) = 90
f(11) = 99
f(12) = 900
f(13) = 999999
f(14) = 9999990
f(15) = 90
f(16) = 90000

Durch die Nutzung unserer Website bestätigen Sie, dass Sie unsere Cookie-Richtlinie und Datenschutzrichtlinie gelesen und verstanden haben.
Licensed under cc by-sa 3.0 with attribution required.