Definimos $R_n$ como a lista de remanescentes da divisão euclidiana de $n$ por $2$ , $3$ , $5$ e $7$ .

Dado um número inteiro $n\ge0$ , você deve descobrir se existe um número inteiro $0<k<210$ modo que $R_{n+k}$ seja uma permutação de $R_n$ .

Exemplos

O critério é atendido para $n=8$ , porque:

• temos $R_8=(0,2,3,1)$
• para $k=44$ , temos $R_{n+k}=R_{52}=(0,1,2,3)$ , que é uma permutação de $R_8$

O critério não é atendido para $n=48$ , porque:

• temos $R_{48}=(0,0,3,6)$
• o menor número inteiro $k>0$ modo que $R_{n+k}$ é uma permutação de $R_{48}$ é $k=210$ (levando a $R_{258}=(0,0,3,6)$ )

Regras

• Você pode emitir um valor verdadeiro se $k$ existir e um valor falso, caso contrário, ou dois valores distintos e consistentes de sua escolha.
• Isso é código-golfe .

Sugestão

Você realmente precisa calcular $k$ ? Bem, talvez. Ou talvez não.

Casos de teste

Alguns valores de $n$ para os quais existe $k$ :

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

Alguns valores de $n$ para os quais $k$ não existe:

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

R , 63 59 bytes

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

Experimente online!

-4 bytes graças a Giuseppe

(A explicação contém um spoiler sobre como resolver o problema sem calcular $k$ .)

Explicação: Let $s$ ser a lista de remanescentes. Observe a restrição que s [1] <2, s [2] <3, s [3] <5 es [4] <7. Pelo teorema do restante chinês , existe um $k$ se houver uma permutação de $s$ , distinta de $s$ , que verifica a restrição. Na prática, isso será verificado se uma das seguintes condições for verificada:

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

Haskell , 69 bytes

Baseado no teorema chinês do restante

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]

Experimente online!

Haskell , 47 bytes

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

Experimente online!

Perl 6 , 64 61 59 43 bytes

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

Experimente online!

-16 graças a @Jo King

C # (compilador interativo do Visual C #) , 125 42 38 36 bytes

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

Porta direta da resposta do @ xnor, baseada na solução do @ RobinRyder.

Guardado 4 bytes graças a @ Ørjan Johansen!

Economizou mais 2 graças a @Arnauld!

Experimente online!

Python 2 , 41 bytes

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

Experimente online!

Usa a mesma caracterização que Robin Ryder . A verificação n%2!=n%3<2é encurtada para -~n%6/4. Escrever as três condições ficou mais curto do que escrever uma geral:

46 bytes

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

Experimente online!

Wolfram Language (Mathematica) , 67 bytes

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

Experimente online!

Ruby , 54 bytes

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

Experimente online!

Usa a solução inteligente de Robin Ryder .

Wolfram Language (Mathematica) , 56 bytes

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

Experimente online!

Localiza todas as permutações não identitárias dos demais módulos de entrada 2, 3, 5, 7 e verifica se alguma delas está abaixo {2,3,5,7}em cada coordenada. Note que Or@@{}é False.

Java (JDK) , 36 bytes

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

Experimente online!

Créditos

• Porta da solução xnor, aprimorada por Ørjan Johansen.

R , 72 bytes

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

Experimente online!

PHP ,81 78 72 bytes

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

Um riff na resposta de @Robin Ryder . A entrada é via STDIN, a saída é verdadeira 'T'e vazia ''se for falsa.

$ 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

Experimente online!

Ou 73 bytes com 1ou 0resposta

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

Experimente online (todos os casos de teste)!

Resposta original, 133 127 bytes

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

Experimente online!

Python 3 , 69 bytes

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

Experimente online!

Codificado

05AB1E , 16 bytes

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

Experimente online ou verifique todos os casos de teste .

Explicação:

Ƶ.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)

Veja este 05AB1E ponta do meu (seção Como comprimir grandes inteiros? ) Para entender por que Ƶ.é 209.

J , 40 bytes

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

Experimente online!

Força bruta ...

Gelatina , 15 bytes

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

Experimente online!

Tenho certeza de que há uma resposta para o golfista. Eu interpretei um valor verdadeiro como sendo qualquer coisa que não seja zero, então aqui está o número de valores possíveis de k. Se precisar ser dois valores distintos que me custam mais um byte.

Explicação

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