Nous définissons $R_n$ comme la liste des restes de la division euclidienne de $n$ par $2$ , $3$ , $5$ et $7$ .

Étant donné un entier $n\ge0$ , vous devez déterminer s'il existe un entier $0<k<210$ tel que $R_{n+k}$ est une permutation de $R_n$ .

Exemples

Le critère est rempli pour $n=8$ , car:

• nous avons $R_8=(0,2,3,1)$
• pour $k=44$ , nous avons $R_{n+k}=R_{52}=(0,1,2,3)$ , qui est une permutation de $R_8$

Le critère n'est pas rempli pour $n=48$ , car:

• nous avons $R_{48}=(0,0,3,6)$
• le plus petit entier $k>0$ tel que $R_{n+k}$ est une permutation de $R_{48}$ est $k=210$ (conduisant également à $R_{258}=(0,0,3,6)$ )

Règles

• Vous pouvez soit afficher une valeur véridique si $k$ existe et une valeur fausse sinon, soit deux valeurs distinctes et cohérentes de votre choix.
• C'est du code-golf .

Allusion

Avez-vous vraiment besoin de calculer $k$ ? Eh bien, peut-être. Ou peut être pas.

Cas de test

Quelques valeurs de $n$ pour lesquelles $k$ existe:

3, 4, 5, 8, 30, 100, 200, 2019

Quelques valeurs de $n$ pour lesquelles $k$ n'existe pas:

0, 1, 2, 13, 19, 48, 210, 1999

R , 63 59 octets

s=scan()%%c(2,3,5,7);i=which(s<c(0,2,3,5));any(s[i]-s[i-1])

Essayez-le en ligne!

-4 octets grâce à Giuseppe

(L'explication contient un spoiler sur la façon de résoudre le problème sans calculer $k$ .)

Explication: Soit $s$ la liste des restes. Notez la contrainte que s [1] <2, s [2] <3, s [3] <5 et s [4] <7. Selon le théorème du reste chinois , il existe un $k$ iff s'il y a une permutation de $s$ , distincte de $s$ , qui vérifie la contrainte. En pratique, cela sera vérifié si l'une des conditions suivantes est vérifiée:

• s [2] <2 et s [2]! = s [1]
• s [3] <3 et s [3]! = s [2]
• s [4] <5 et s [4]! = s [3]

Haskell , 69 octets

Basé sur le théorème du reste chinois

m=[2,3,5,7]
f x|s<-mod x<$>m=or[m!!a>b|a<-[0..2],b<-drop a s,s!!a/=b]

Essayez-le en ligne!

Haskell , 47 octets

g.mod
g r|let p?q=r p/=r q&&r q<p=2?3||3?5||5?7

Essayez-le en ligne!

Perl 6 , 64 61 59 43 octets

{map($!=(*X%2,3,5,7).Bag,^209+$_+1)∋.&$!}

Essayez-le en ligne!

-16 grâce à @Jo King

C # (Visual C # Interactive Compiler) , 125 42 38 36 octets

n=>n%7<5&5<n%35|n%5<3&3<n%15|-~n%6>3

Port direct de la réponse de @ xnor, qui est basé sur la solution de @ RobinRyder.

4 octets enregistrés grâce à @ Ørjan Johansen!

Enregistré 2 de plus grâce à @Arnauld!

Essayez-le en ligne!

Python 2 , 41 octets

lambda n:n%5!=n%7<5or n%3!=n%5<3or-~n%6/4

Essayez-le en ligne!

Utilise la même caractérisation que Robin Ryder . Le chèque n%2!=n%3<2est raccourci -~n%6/4. La rédaction des trois conditions s'est avérée plus courte que la rédaction d'une condition générale:

46 octets

lambda n:any(n%p!=n%(p+1|1)<p for p in[2,3,5])

Essayez-le en ligne!

Wolfram Language (Mathematica) , 67 octets

!FreeQ[Sort/@Table[R[#+k],{k,209}],Sort@R@#]&
R@n_:=n~Mod~{2,3,5,7}

Essayez-le en ligne!

Rubis , 54 octets

->n{[2,3,5,7].each_cons(2).any?{|l,h|n%l!=n%h&&n%h<l}}

Essayez-le en ligne!

Utilise la solution intelligente de Robin Ryder .

Wolfram Language (Mathematica) , 56 octets

Or@@(Min[s-#]>0&/@Rest@Permutations@Mod[#,s={2,3,5,7}])&

Essayez-le en ligne!

Recherche toutes les permutations non identitaires des restes du module d'entrée 2, 3, 5, 7 et vérifie si l'une d'entre elles est en dessous {2,3,5,7}dans chaque coordonnée. Notez que Or@@{}c'est False.

Java (JDK) , 36 octets

n->n%7<5&5<n%35|n%5<3&3<n%15|-~n%6>3

Essayez-le en ligne!

Crédits

• Port de la solution de xnor, amélioré par Ørjan Johansen.

R , 72 octets

n=scan();b=c(2,3,5,7);for(i in n+1:209)F=F|all(sort(n%%b)==sort(i%%b));F

Essayez-le en ligne!

PHP ,81 78 72 octets

while($y<3)if($argn%($u='235'[$y])!=($b=$argn%'357'[$y++])&$b<$u)die(T);

Un riff sur la réponse de @Robin Ryder . L'entrée est via STDIN, la sortie est 'T'si véridique et vide ''si elle est fausse.

$ echo 3|php -nF euc.php
T
$ echo 5|php -nF euc.php
T
$ echo 2019|php -nF euc.php
T
$ echo 0|php -nF euc.php

$ echo 2|php -nF euc.php

$ echo 1999|php -nF euc.php

Essayez-le en ligne!

Ou 73 octets avec 1ou 0réponse

while($y<3)$r|=$argn%($u='235'[$y])!=($b=$argn%'357'[$y++])&$b<$u;echo$r;

$ echo 2019|php -nF euc.php
1
$ echo 1999|php -nF euc.php
0

Essayez-le en ligne (tous les cas de test)!

Réponse originale, 133 127 octets

function($n){while(++$k<210)if(($r=function($n){foreach([2,3,5,7]as$d)$o[]=$n%$d;sort($o);return$o;})($n+$k)==$r($n))return 1;}

Essayez-le en ligne!

Python 3 , 69 octets

lambda x:int('4LR2991ODO5GS2974QWH22YTLL3E3I6TDADQG87I0',36)&1<<x%210

Essayez-le en ligne!

Hardcoded

05AB1E , 16 octets

Ƶ.L+ε‚ε4Åp%{}Ë}à

Essayez-le en ligne ou vérifiez tous les cas de test .

Explication:

Ƶ.L          # Create a list in the range [1,209] (which is k)
   +         # Add the (implicit) input to each (which is n+k)
    ε        # Map each value to:
     ‚       #  Pair it with the (implicit) input
      ε      #  Map both to:
       4Åp   #   Get the first 4 primes: [2,3,5,7]
          %  #   Modulo the current number by each of these four (now we have R_n and R_n+k)
           { #   Sort the list
      }Ë     #  After the inner map: check if both sorted lists are equal
     }à      # After the outer map: check if any are truthy by taking the maximum
             # (which is output implicitly as result)

Voir cette astuce de mes 05AB1E (section Comment compresser les grands entiers? ) Pour comprendre pourquoi Ƶ.est 209.

J , 40 octets

1 e.(>:+i.@209)-:&(/:~)&(2 3 5 7&|"1 0)]

Essayez-le en ligne!

Force brute...

Gelée , 15 octets

8ÆR©PḶ+%Ṣ¥€®ċḢ$

Essayez-le en ligne!

Je suis sûr qu'il y a une réponse de golfeur. J'ai interprété une valeur véridique comme étant tout ce qui n'est pas nul, alors voici le nombre de valeurs possibles de k. S'il doit s'agir de deux valeurs distinctes, cela me coûte un octet supplémentaire.

Explication

8ÆR             | Primes less than 8 [2,3,5,7]
   ©            | Copy to register
    P           | Product [210]
     Ḷ          | Lowered range [0, 1, ..., 208, 209]
      +         | Add to input
         ¥€     | For each of these 210 numbers...
       %   ®    |   Modulo 2, 3, 5, 7
        Ṣ       |   And sort
            ċḢ$ | Count how many match the first (input) number’s remainders