Le plus petit multiple en cours d'exécution de 9 suivi par la course facultative de 0


22

Étant donné un entier positif, trouvez son plus petit multiple entier positif qui est une séquence de 9 suivie d'une séquence facultative de 0. En d'autres termes, trouvez son plus petit multiple entier positif qui est mis en correspondance par l'expression régulière /^9+0*$/.

Par exemple, si l'entier positif donné est 2, alors retournez 90, car 90 est un multiple entier positif de 2 et est le plus petit auquel correspond l'expression régulière /^9+0*$/.

Cas de test:

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

C'est du . La réponse la plus courte en octets gagne. Des échappatoires standard s'appliquent.


3
une preuve de bien défini?
Destructible Lemon

2
@DestructibleLemon Cette preuve suffit, car le résultat peut être multiplié par 9.
xnor

1
Je pense que plus de cas de test seraient bons pour vérifier que les solutions nécessitent que les 9 viennent avant les 0.
xnor

2
@LeakyNun peut-être pas, mais 9900099 l'est et ne devrait pas être autorisé selon les règles.
DrQuarius

2
@koita_pisw_sou la règle est que le programme devrait "théoriquement" fonctionner pour tout entier étant donné la précision arbitraire et la mémoire et le temps.
Leaky Nun

Réponses:


6

Gelée , 13 11 octets

ṚḌ‘DS=ḍ@ð1#

Essayez-le en ligne!

Comment ça marche

ṚḌ‘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
ಠ_ಠ comment l'avez-vous fait avec ni l'un 9ni l'autre 0dans votre code
Pavel

J'ai ajouté une explication.
Dennis



5

JavaScript (ES6), 47 43 42 octets

-4 octets grâce à @Arnauld
-1 octets grâce à @Luke

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

Les 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))

Solution récursive (échoue pour 7, 13 et 14), 38 octets

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

Appelé comme f(5)(). Atteint la taille de la pile d'appel max dans Chrome et Firefox n=7, n=13et n=14.


3
Un octet plus court:n=>eval('for(i=0;!/^9+0*$/.test(i);)i+=n')
Luke


4

Java 8, 61 57 octets

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

-4 octets (et exécution plus rapide) grâce à @JollyJoker .

Explication:

Essayez-le ici.

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

Ouais pour l'optimisation! ^^
Olivier Grégoire

1
L'incrémentation de n évite le r%nchèque,n->{int r=0;for(;!(""+(r+=n)).matches("9+0*"););return r;}
JollyJoker

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

J'ai essayé et essayé de continuer avec les nombres entiers et les mathématiques, mais je ne peux pas battre ça! Félicitations :)
Olivier Grégoire


3

Brachylog , 16 octets

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

Essayez-le en ligne!

C'est assez lent

Explication

;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 octets

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

Expliqué

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.

Essayez-le en ligne!


2

Mathématiques , 71 octets

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

Essayez-le en ligne!

Solution de force brute pas très intéressante, mais elle bat l'autre réponse de Mathematica, qui utilise des astuces intelligentes.

La seule qualité qui rachète Mathematica en ce qui concerne ce défi est le fait que cela StringMatchQnécessite une correspondance complète, donc je peux le faire 9+0*plutôt que ^9+0*$.


2
Si vous êtes prêt à utiliser Mathematica au lieu de Mathics, vous pouvez enregistrer quelques octets avec "9"..~~"0"...au lieu de RegularExpression@"9+0*".
Pas un arbre

1
@Notatree merci, je m'en souviendrai plus tard, mais je m'en tiendrai aux mathématiques. Je préfère ne pas utiliser de syntaxe que je ne comprends pas, et c'est la première fois que je vois une syntaxe comme ça.
Pavel

C'est suffisant. (La syntaxe de correspondance de motifs de Mathematica est un outil puissant, mais si vous êtes familier avec les expressions régulières, vous le savez probablement déjà!)
Pas un arbre

2

Lot, 175 octets

@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%

Prend entrée sur STDIN. Ce n'est pas une solution de force brute, mais en fait basée sur ma réponse à Fraction d'exactitude décimale donc cela fonctionnera pour 17, 19, etc. qui autrement dépasserait sa limite entière de toute façon.


2

Mathematica, 127 octets

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


Contribution

[17]

Sortie

9999999999999999

voici les 20 premiers termes

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


1
Intelligent, mais la solution évidente semble être la plus courte: codegolf.stackexchange.com/a/130115/60042
Pavel

votre solution évidente ne peut pas faire 17 ;-)
J42161217

Que puis-je dire, pas le code le plus rapide
Pavel

Soit dit en passant, votre solution fonctionne en mathématiques, vous pouvez la modifier et ajouter un lien TIO.
Pavel


2

Haskell , 53 octets

f prend et retourne un entier.

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

Essayez-le en ligne!

Cela expire pour 17, ce qui est commodément juste au-delà des cas de test. Une version plus rapide en 56 octets:

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

Essayez-le en ligne!

Comment ça marche

  • fgénère tous les multiples de n, convertit chacun en une chaîne, filtre ceux qui ont le bon format, puis prend le premier.

  • La version plus rapide utilise au contraire que le nombre requis sont de la forme 10^a-10^b, a>=1, a>b>=0. À des fins de golf, il utilise également le fait que pour le minimum a, un seul bpeut fonctionner, ce qui lui permet de générer les bs dans un "mauvais" ordre légèrement plus court.


1

Ruby , 38 + 1 = 39 octets

Utilise le -pdrapeau.

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

-p entoure le programme de:

while gets
    ...
end
puts $_

gets stocke son résultat dans $_ . evalest utilisé pour le convertir en nombre, car il est plus court que .to_i, alors la force brute est utilisée, incrémentant $ _ jusqu'à ce qu'elle corresponde à l'expression régulière. "#{}"est une interpolation sttring, elle est plus courte qu'un .to_sappel car cela nécessiterait des parenthèses autour $_+=y. Enfin, $_est imprimé.

Essayez-le en ligne!

Essayez tous les cas de test!



1

C ++, 106 octets

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;}

Formulaire détaillé:

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;
}

ESSAYEZ-LE en ligne!


Mieux golfé:, [](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;}}prend 94 octets. Essentiellement, traitez-le comme une tâche de fonction pour enregistrer des octets, économiser des parenthèses inutiles, utiliser la fonction lambda pour économiser sur la dénomination et le type de type.
enedil

ne peut pas le faire compiler en utilisant lambda. pourriez-vous donner un coup de main?
koita_pisw_sou

C'est peut-être la raison pour laquelle j'ai mis trop de parenthèses à la fin.
enedil

De plus, lambda ne doit probablement pas exister dans une portée globale, même si son encapsulation dans une fonction régulière prend 97 octets.
enedil

1

Python 2 , 79 octets

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

Essayez-le en ligne!

Quelques explications Il trouve le plus petit naturel de forme 10**n-10**bavec n>b>=0qui divise l'entrée.

Certains 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, octets: 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}

Essayez-le en ligne!


Que fait let r=-il? Je ne vois rnulle part ailleurs
Cyoce

@Cyoce let r = vérifie si le n.range renvoie la valeur nil ou non.Vous pouvez utiliser let _ =. J'utilise ici une liaison facultative pour réduire le nombre d'octets.
A. Pooja

1

Python 3 , 62 octets

Cette fonction prend un entier net s'initialise mà zéro. Ensuite, il supprime tous les zéros des extrémités de met vérifie si le résultat ne contient que des 9, et revient msi c'est le cas. Dans le cas contraire, il ajoute nà met vérifie à nouveau, etc.

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

Essayez-le en ligne!


1

Java (OpenJDK 8) , 66 octets, ne s'étouffe pas sur 17

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

Essayez-le en ligne!

Plus longue que la solution de @ KevinCruijssen mais peut gérer des nombres légèrement plus grands. Il calcule les nombres candidats comme 10 ^ 6 - 10 ^ 3 = 999000. Les longs 64 bits sont toujours la limite, cassant pour n = 23.

Peut probablement être un peu joué au golf mais a déjà pris trop de temps pour le faire fonctionner ...


1

> <> , 35 octets

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

Essayez-le en ligne ou regardez-le au terrain de pêche !

Suppose que l'entrée est déjà sur la pile. Fonctionne en recherchant des nombres de la forme 10 a  - 10 b , avec un <b (oui, c'est un signe inférieur à - cela prend moins d'octets!) Jusqu'à ce que cela soit divisible par l'entrée, puis en imprimant 10 b  - 10 a . C'est beaucoup plus rapide que la méthode de la force brute (ce qui serait difficile dans> <> de toute façon).


1

V , 19 14 octets

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

Essayez-le en ligne!

Explication

é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 49 octets

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>

Ce n'est pas l'approche la plus courte, mais elle est méchante rapidement.


1

Mathematica, 82 octets

Utilisation du modèle de soumission de la réponse de @Jenny_mathy ...

(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)&

Contribution:

[17]

Sortie:

9999999999999999

Et par rapport à l'argument dans les commentaires à la réponse de @ Jenny_mathy avec @Phoenix ... RepeatedTiming[]d'application à l'entrée [17]donne

{0.000518, 9999999999999999}

donc une demi-milliseconde. Aller à une entrée un peu plus grand, [2003]:

{3.78, 99999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999}

un peu moins de 4 secondes.

Tableau de test: Sur les 30 premiers entiers positifs, les résultats sont

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

Explication: La seule magie ici est l'itérateur personnalisé ("itérateur" dans le sens CS, pas le sens M'ma)

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

qui agit sur les variables globales x, le nombre de "9" de tête y, le nombre de "0" de fin et dle nombre total de chiffres. Nous souhaitons parcourir le nombre de chiffres et, pour chaque choix de nombre de chiffres, commencer par le plus de "0" et le moins de "9". Ainsi, la première chose que le code fait est d'initialiser dà 1, le forçage est la valeur souhaitée de .)x à 1 ety à 0. L'itérateur personnalisé vérifie que la chaîne de "0" peut être raccourcie. Si tel est le cas, il raccourcit la chaîne de "0" de un et augmente la chaîne de "1" de un. Sinon, il incrémente le nombre de chiffres, définit le nombre de "0" à un de moins que le nombre de chiffres et définit le nombre de "9" à 1.dy


Et pourtant, encore plus longtemps que la force brute et l'expression régulière.
Pavel

@Phoenix: Alors, quel est votre timing en 2003?
Eric Towers

1

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

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

L'entrée est Prompt-ed pendant le programme; la sortie est stockée dans Ans.

Explication:

Essaie les numéros du formulaire (10 n ) (10 m -1) = 10 k -10 m , où m + n = k commence à 1 et augmente, et pour chaque valeur de k, il essaie m = 1, n = k -1; m = 2, n = k-2; ... m = k, n = 0; jusqu'à ce qu'il trouve un multiple de X.

Cela fonctionne jusqu'à 16; 17 donne une erreur de domaine carremainder( ne peut accepter que des dividendes jusqu'à 9999999999999 (13 neuf), et 17 devrait produire 999999999999999999 (16 neuf).

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 octets

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

Explication

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

#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);}

Essayez-le en ligne!

Quelques explications On trouve le plus petit naturel de forme 10**n-10**bavecn>b>=0qui divise l'entrée.

Certains 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

1

Perl 5 , 23 + 2 (-pa) = 25 octets

Méthode de la force brute

$_+=$F[0]while!/^9+0*$/

Essayez-le en ligne!

C'est lent, mais c'est minuscule.

Méthode plus efficace:

41 + 2 (-pa) = 43 octets

$_=9;s/0/9/||($_=9 .y/9/0/r)while$_%$F[0]

Essayez-le en ligne!

Cela fonctionne bien pour n'importe quelle entrée, mais c'est un code plus long.

En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.