Definiamo come l'elenco dei resti della divisione euclidea di per , , e .$R_n$$n$$2$$3$$5$$7$

Dato un numero intero , devi capire se esiste un numero intero tale che è una permutazione di .$n\ge0$$0<k<210$$R_{n+k}$$R_n$

Esempi

Il criterio è soddisfatto per , perché:$n=8$

• abbiamo$R_8=(0,2,3,1)$
• per , abbiamo , che è una permutazione di R_8$k=44$$R_{n+k}=R_{52}=(0,1,2,3)$$R_8$

Il criterio non è soddisfatto per $n=48$ , perché:

• abbiamo $R_{48}=(0,0,3,6)$
• il numero intero più piccolo $k>0$ tale che $R_{n+k}$ è una permutazione di $R_{48}$ è $k=210$ (portando anche a $R_{258}=(0,0,3,6)$ )

Regole

• Puoi generare un valore di verità se $k$ esiste e un valore di falsa altrimenti, oppure due valori distinti e coerenti di tua scelta.
• Questo è code-golf .

Suggerimento

Hai davvero bisogno di calcolare $k$ ? Beh forse. O forse no.

Casi test

Alcuni valori di $n$ per cui esiste $k$ :

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

Alcuni valori di $n$ per i quali $k$ non esiste:

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

R , 63 59 byte

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

Provalo online!

-4 byte grazie a Giuseppe

(La spiegazione contiene uno spoiler su come risolvere il problema senza calcolare .)$k$

Spiegazione: Let$s$ è l'elenco dei resti. Nota il vincolo che s [1] <2, s [2] <3, s [3] <5 e s [4] <7. Secondo ilteorema del resto cinese, esiste un$k$ iff esiste una permutazione di$s$ , distinta da$s$ , che verifica il vincolo. In pratica, questo verrà verificato se viene verificata una delle seguenti condizioni:

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

Haskell , 69 byte

Basato sul teorema del resto cinese

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]

Provalo online!

Haskell , 47 byte

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

Provalo online!

Perl 6 , 64 61 59 43 byte

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

Provalo online!

-16 grazie a @Jo King

C # (compilatore interattivo Visual C #) , 125 42 38 36 byte

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

Porta diretta della risposta di @ xnor, che si basa sulla soluzione di @ RobinRyder.

4 byte salvati grazie a @ Ørjan Johansen!

Hai salvato altri 2 grazie a @Arnauld!

Provalo online!

Python 2 , 41 byte

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

Provalo online!

Utilizza la stessa caratterizzazione di Robin Ryder . Il controllo n%2!=n%3<2è abbreviato in -~n%6/4. Scrivere le tre condizioni si è rivelato più breve che scrivere una generale:

46 byte

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

Provalo online!

Wolfram Language (Mathematica) , 67 byte

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

Provalo online!

Rubino , 54 byte

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

Provalo online!

Utilizza la soluzione intelligente di Robin Ryder .

Wolfram Language (Mathematica) , 56 byte

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

Provalo online!

Trova tutte le permutazioni di non identità dei resti dell'input modulo 2, 3, 5, 7 e verifica se uno di essi è inferiore {2,3,5,7}in ciascuna coordinata. Si noti che Or@@{}è False.

Java (JDK) , 36 byte

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

Provalo online!

Titoli di coda

• La soluzione Port of xnor, migliorata da Ørjan Johansen.

R , 72 byte

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

Provalo online!

PHP ,81 78 72 byte

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

Un riff sulla risposta di @Robin Ryder . L'input è via STDIN, l'output è 'T'se vero, e vuoto ''se falso.

$ 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

Provalo online!

O 73 byte con 1o 0risposta

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

Provalo online (tutti i casi di test)!

Risposta originale, 133 127 byte

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

Provalo online!

Python 3 , 69 byte

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

Provalo online!

hardcoded

05AB1E , 16 byte

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

Provalo online o verifica tutti i casi di test .

Spiegazione:

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

Vedere questo 05AB1E punta del mio (sezione Come comprimere grandi numeri interi? ) Per capire il motivo per cui Ƶ.è 209.

J , 40 byte

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

Provalo online!

Forza bruta...

Gelatina , 15 byte

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

Provalo online!

Sono sicuro che ci sia una risposta da golfista. Ho interpretato un valore di verità come qualsiasi cosa che non sia zero, quindi qui è il numero di possibili valori di k. Se deve essere due valori distinti che mi costa un ulteriore byte.

Spiegazione

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