Wir definieren als die Liste der Reste der euklidischen Division von durch , , und .$R_n$$n$$2$$3$$5$$7$

Bei einer gegebenen Ganzzahl müssen Sie herausfinden, ob eine Ganzzahl so dass eine Permutation von .$n\ge0$$0<k<210$$R_{n+k}$$R_n$

Beispiele

Das Kriterium ist für erfüllt , weil:$n=8$

• wir haben$R_8=(0,2,3,1)$
• für haben wir , was eine Permutation von$k=44$$R_{n+k}=R_{52}=(0,1,2,3)$$R_8$

Das Kriterium ist für nicht erfüllt , weil:$n=48$

• wir haben$R_{48}=(0,0,3,6)$
• die kleinste ganze Zahl so dass eine Permutation von ist, ist (was auch zu )$k>0$$R_{n+k}$$R_{48}$$k=210$$R_{258}=(0,0,3,6)$

Regeln

• Sie können entweder einen Wahrheitswert ausgeben, wenn existiert, und einen falschen Wert, oder zwei unterschiedliche und konsistente Werte Ihrer Wahl.$k$
• Das ist Code-Golf .

Hinweis

Müssen Sie wirklich berechnen ? Vielleicht. Oder vielleicht nicht.$k$

Testfälle

Einige Werte von für die existiert:$n$$k$

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

Einige Werte von für die nicht existiert:$n$$k$

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

Probieren Sie es online!

-4 Bytes dank Giuseppe

(Die Erklärung enthält einen Spoiler, wie man das Problem löst, ohne $k$ zu berechnen .)

Erläuterung: Let $s$ die Liste der Reste sein. Beachten Sie die Einschränkung, dass s [1] <2, s [2] <3, s [3] <5 und s [4] <7. Durch den chinesischen Restsatz existiert ein $k$ iff eine Permutation ist $s$ , die sich von $s$ , die die Bedingung überprüft. In der Praxis wird dies überprüft, wenn eine der folgenden Bedingungen überprüft wird:

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

Haskell , 69 Bytes

Basierend auf dem chinesischen Restsatz

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]

Probieren Sie es online!

Haskell , 47 Bytes

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

Probieren Sie es online!

Perl 6 , 64 61 59 43 Bytes

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

Probieren Sie es online!

-16 danke an @Jo King

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

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

Direkter Port von @ xnors Antwort, die auf der @ RobinRyder-Lösung basiert.

4 Bytes gespart dank @ Ørjan Johansen!

2 weitere dank @Arnauld gespart!

Probieren Sie es online!

Python 2 , 41 Bytes

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

Probieren Sie es online!

Verwendet die gleiche Charakterisierung wie Robin Ryder . Der Scheck n%2!=n%3<2wird auf gekürzt -~n%6/4. Das Aufschreiben der drei Bedingungen fiel kürzer aus als das Aufschreiben einer allgemeinen:

46 Bytes

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

Probieren Sie es online!

Wolfram Language (Mathematica) , 67 Byte

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

Probieren Sie es online!

Ruby , 54 Bytes

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

Probieren Sie es online!

Verwendet die clevere Lösung von Robin Ryder .

Wolfram Language (Mathematica) , 56 Byte

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

Probieren Sie es online!

Findet alle Nichtidentitätspermutationen der Reste des Eingabemoduls 2, 3, 5, 7 und prüft, ob eine davon {2,3,5,7}in jeder Koordinate darunter liegt . Beachten Sie, dass Or@@{}ist False.

Java (JDK) , 36 Byte

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

Probieren Sie es online!

Credits

• Port of Xnors Lösung, verbessert von Ø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

Probieren Sie es online!

PHP ,81 78 72 Bytes

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

Ein Riff über die Antwort von @Robin Ryder . Die Eingabe erfolgt über STDIN, die Ausgabe ist 'T'wahr und leer, ''wenn sie falsch ist.

$ 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

Probieren Sie es online!

Oder 73 Bytes mit 1oder 0Antwort

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

Probieren Sie es online aus (alle Testfälle)!

Ursprüngliche Antwort, 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;}

Probieren Sie es online!

Python 3 , 69 Bytes

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

Probieren Sie es online!

Hardcoded

05AB1E , 16 Bytes

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

Probieren Sie es online aus oder überprüfen Sie alle Testfälle .

Erläuterung:

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

Sehen Sie sich meinen Tipp 05AB1E (Abschnitt Wie komprimiere ich große ganze Zahlen? ) An, um zu verstehen, warum dies so Ƶ.ist 209.

J , 40 Bytes

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

Probieren Sie es online!

Rohe Gewalt...

Gelee , 15 Bytes

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

Probieren Sie es online!

Ich bin sicher, es gibt eine golferische Antwort. Ich habe einen Wahrheitswert als etwas interpretiert, das nicht Null ist, also ist es hier die Anzahl der möglichen Werte von k. Wenn es zwei unterschiedliche Werte sein müssen, kostet mich das ein weiteres Byte.

Erläuterung

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