Herausforderung

Suchen Sie für einen bestimmten Bereich positiver Ganzzahlen die erste und letzte Primzahl, die vollständig aus Primzahlen besteht, ausnahmsweise einschließlich 0 (für die Ziffern sollte ein Bereich von 0-2 2-2 ausgeben). Das Sortiment ist inklusive. Wenn keine Nummer gefunden wird, ist die erwartete Ausgabe 0. Wenn es nur eine solche Nummer gibt, ist die erwartete Ausgabe diese Nummer zweimal.

Beispiele

• Für den Bereich von 1 bis 100 ist die erste Primzahl 2 und die letzte 73 (7 und 3 sind Primzahlen).
• Für den Bereich 70–80 ist die erste Primzahl 73 und die letzte ist ebenfalls 73 (Da es in dem angegebenen Bereich nur eine richtige Zahl gibt, geben wir sie zweimal zurück).
• Für den Bereich 190-200 gibt es keine richtige Antwort, daher geben Sie 0 zurück.
• Für den Bereich 2000-2100 ist die erste Primzahl 2003 und die letzte 2053 (wir lassen die Ziffer 0 weg, aber alle anderen Ziffern sind Primzahlen).

Das ist Code-Golf , also gewinnt der kürzeste Code in Bytes!

Es gelten alle Standardlücken.

Eingang

• Es steht Ihnen frei, zwei Ganzzahlen als Eingabe zu akzeptieren, wie auch immer Sie es für richtig halten, Stapel, Funktionsargument (e), CLI-Argument, stdin.
• Sie müssen nur zwei ganze Zahlen erhalten.

Ausgabe

• Sie müssen entweder das Ergebnis zurückgeben (ein Tupel, ein Array, Multi-Return, wenn Ihre Sprache es unterstützt), es auf dem Stapel belassen oder es ausdrucken (in diesem Fall müssen sie irgendwie getrennt sein).
• Die Reihenfolge der Ausgänge spielt keine Rolle.
• Führende / nachfolgende Klammern und Zeilenumbrüche sind erlaubt.
• Sie müssen zwei Zahlen zurückgeben, wenn es eine Antwort gibt, auch wenn sie gleich sind.
• Sie müssen 0 zurückgeben, wenn keine Antwort erfolgt.

Python 2 , 123 Bytes

def f(a,b):r=[i for i in range(a,b+1)if(set(`i`)<=set('02357'))>any(i%k<1for k in range(3,i))];return len(r)and(r[0],r[-1])

Probieren Sie es online!

Perl 6, 105 94 90 86 Bytes

{my @b=grep {is-prime all($_,|.comb>>.Int Xor 2)},$^a..$^b;say @b??"@b[0] @b[*-1]"!!0}

JavaScript (ES6), 83 Byte

Übernimmt den Bereich [ab] in der Currying-Syntax (a)(b). Gibt entweder ein Array mit 2 Elementen oder 0 zurück .

n=>g=(m,a=0)=>n>m?a:g(m-1,(P=d=>m%--d?P(d):d>1|/[14689]/.test(m))(m)?a:[m,a[1]||m])

Testfälle

let f =

n=>g=(m,a=0)=>n>m?a:g(m-1,(P=d=>m%--d?P(d):d>1|/[14689]/.test(m))(m)?a:[m,a[1]||m])

console.log(f(1)(100))
console.log(f(70)(80))
console.log(f(190)(200))

Mathematica, 91 Bytes

If[(s=Select[Range@##,(p=PrimeQ)@#&&And@@((p@#||#<1)&/@IntegerDigits@#)&])!={},MinMax@s,0]&

Probieren Sie es online!

Gelee , 14 Bytes

æRµDo2ÆPẠµÐf.ị

Probieren Sie es online!

Wie es funktioniert

æRµDo2ÆPƵẠf.Ð ~ Volles Programm.

æR ~ Inclusive Prime Range.
  µ µÐf ~ Nur solche aufbewahren, die eine Bedingung erfüllen.
   Do2ÆPẠ ~ Die Filterbedingung:
   D ~ Die Dezimalstellen der aktuellen Nummer.
    o2 ~ Logisch oder mit 2 (ordnet 0 bis 2 und jede andere Ziffer sich selbst zu).
      ÆP ~ Ist prim (elementweise)?
        Ạ ~ Prüfen Sie, ob alle Ziffern die Bedingung erfüllen.
            .ị ~ Liefert das Element mit dem modularen Index 0.5. Ein paar Details:
                 ~ Jelly ist 1-indiziert, also gibt 1 uns das erste Element, während 0
                   gibt uns das letzte Element.
                 ~ Wenn die Decke und der Boden der angegebenen Nummer N nicht übereinstimmen, 
                   dann gibt Jelly die Gegenstände auf dem Indexboden (N) und zurück ceil (N) zurück.
                 ~ Wenn die Liste leer ist, ergibt dies 0, was sehr praktisch ist.

Wenn der gesamte Bereich zulässig wäre (obwohl ich denke, dass dies nicht der Fall sein sollte), dann 12 Bytes:

Do2,ÆPȦµÐf.ị

Probieren Sie es online!

Brachylog , 16 Bytes

⟦₂{ṗṗᵐ}ˢ⟨⌋≡⌉⟩|∧0

Probieren Sie es online!

Die völlig unsinnige "return 0 wenn es keine Primzahl gibt" lässt uns 3 Bytes ( |∧0) ohne Grund verlieren (es würde zurückkehren, false.wenn wir sie nicht addieren)

Erläuterung

⟦₂                Range from the smallest element of the input to the biggest
  {   }ˢ          Select on that range:
   ṗ                Numbers that are primes
    ṗᵐ              And whose digits are primes
        ⟨   ⟩     Fork on this new list:
         ⌋          Minimum
           ⌉        maximum
          ≡         Do nothing and return [Minimum, Maximum]
             |∧0  If all of this fails (i.e. the list after selection is empty), return 0

Pyth , 24 Bytes

Die Verwendung meines anfänglichen Ansatzes fällt kürzer aus.

.x,eKfP#I_M-+TjT;0}EQhKZ

Probieren Sie es hier aus!

(Ich habe gerade auf 23 aktualisiert, aber Steven hat mich geschlagen )

?KfP#I_M-+TjT;0}FQhM_BK0

Probieren Sie es hier aus!

Natürlich, hM_BK kann durch ersetzt werden ,hKeK.

25 Bytes

.x,eKf.AmP_|d2+TjT;}EQhKZ

Probieren Sie es hier aus!

26 Bytes

|>2.<f.AmP_|d2+TjT;*2}EQ1Z

Probieren Sie es hier aus!

|>2.<fP#I_M|R2+TjT;*2}EQ1Z

Probieren Sie es hier aus!

Wie sie arbeiten

.x,eKfP#I_M-+TjT;0}EQhKZ ~ Full program. Q, E = first, second inputs

.x                     Z ~ Try-catch block. If the code errors, output 0.
     f            }EQ    ~ Filter the range [E ... Q] for (uses a variable T):
            +TjT;          ~ Append T to the list of its digits.
           -     0         ~ Remove the zeros.
         _M                ~ Multiply each by -1 (for primality testing).
        I                  ~ Check if the result is invariant over...
      P#                   ~ Removing non-prime items.
    K                    ~ Assigned the filtered range to a variable K.
  ,e                     ~ Pair the last element of K with...
                     hK  ~ Its first element.

|>2.<f.AmP_|d2+TjT;*2}EQ1Z ~ Full program.

                   *2}EQ   ~ Inclusive range, repeated twice..
     f                     ~ Filter, using T as the current number.
                jT;        ~ Base-10 digits of T.
              +T           ~ Concatenated with T.
        mP_|d2             ~ Prime check after performing OR 2 (makes 0 be treated as prime)
      .A                   ~ Do all satisfy this condition?
   .<                   1  ~ Rotate by one place cyclically to the left.
 >2                        ~ Last two elements (ignored if there aren't enough)
|                        Z ~ Logical or with 0.

Mathematica 85 Bytes

Ich weiß, dass es bereits eine ähnliche Antwort gibt, aber der Ansatz hier ist ganz anders.

MinMax@Cases[Range@##,x_/;PrimeQ@x&&DisjointQ@@IntegerDigits/@{x,14689}]/.{_,∞}->0&

Diese Antwort mit 83 Zeichen wird in Mathematica eingefügt und ausgeführt. Die TIO-Site kann ∞ nicht interpretieren.

Gelee , 14 Bytes

Do2ÆPẠ
æRÇÐf.ị

Probieren Sie es online!

æRÇÐf.ị            Main link
æR                 Prime range
   Ðf              Filter the range with...
  Ç                The helper link
      ị            At index (decimal, returns [xs[floor], xs[ceil]], otherwise 0)
     .             0.5

Do2ÆPẠ             Helper link
D                  For each decimal
 o2                Replace 0s with 2s, an actual prime prime (could be 3, 5, or 7).
   ÆP              Filter primes (1 if true, 0 if false)
     Ạ             Check if all are true

Vielen Dank an Erik den Outgolfer für die Hilfe bei der Behebung eines Fehlers. Danke an Mr. Xcoder für den .ịTrick.

Ruby , 87 Bytes

->a,b{(z=(a..b).select{|x|(2...x).none?{|r|x%r<1}&&/[14689]/!~"%d"%x})[0]?(z.minmax):0}

Probieren Sie es online!

CJam , 36 Bytes

),>{mp},{s{_!\~mp|}%1-!},_{_0=\W=}0?

Probieren Sie es online!

Perl 6 ,  68 66 65 61  58 Bytes

{($_=($^a..$^b).grep({.is-prime&&/^<[02357]>+$/})[0,*-1])[1]??$_!!0}

Versuch es

{($_=($^a..$^b).grep({.is-prime&&!/<[14689]>/})[0,*-1])[1]??$_!!0}

Versuch es

{($_=($^a..$^b).grep({.is-prime*!/<[14689]>/})[0,*-1])[1]??$_!!0}

Versuch es

{($_=($^a..$^b).grep({.is-prime*!/<[14689]>/}))??.[0,*-1]!!0}

Versuch es

{($_=grep {.is-prime*!/<[14689]>/},$^a..$^b)??.[0,*-1]!!0}

Versuch es

Erweitert:

{  # bare block lambda with two placeholder parameters ｢$a｣ and ｢$b｣

  (
    $_ =  # store the list in ｢$_｣ for later use

      grep {
          .is-prime

        *              # True * True == 1 (all others equal 0)

          !/<[14689]>/ # doesn't contain a non-prime other than 0
      },

      $^a .. $^b       # inclusive Range

  )            # is the list Truish (not empty)
  ?? .[0,*-1]  # if so output the first and last values (from ｢$_｣)
  !! 0         # otherwise return 0
}

Perl 5 , 79 + 2 ( -ap) = 81 Bytes

map{$f=0|sqrt;1while$_%$f--;$s||=$_,$\=-$_ if!$f&&!/[14689]/}$F[0]..$F[1];$_=$s

Probieren Sie es online!

Java 8, 165 164 Bytes

(a,b)->{for(;a<=b&!p(a);a++);for(;b>a&!p(b);b--);return a>b?"0":a+" "+b;}boolean p(int n){int N=n,i=2;for(;i<N;N=N%i++<1?0:N);return(n+"").matches("[02357]+")&N>1;}

Erläuterung:

Probieren Sie es hier aus.

(a,b)->{            // Method with two integer parameters and String return-type
                    //  (Input `a` is the lowest input, input `b` is the highest input)
  for(;a<=b         //  Increase `a` as long as it's smaller than or equal to `b`,
       &!p(a);a++); //   and it's not a prime, and not all of its digits are prime-digits
  for(;b>a          //  Decrease `b` as long as it's larger than `a`,
       &!p(b);b--); //   and it's not a prime, and not all of its digits are prime-digits
  return a>b?       //  If `a` is now larger than `b`:
    "0"             //   Return 0, because nothing is found
   :                //  Else:
    a+" "+b;}       //   Return the resulting `a` and `b`

boolean p(int n){int N=n,i=2;for(;i<N;N=N%i++<1?0:N);return(n+"").matches("[02357]+")&N>1;}
                    // Separate method that returns whether the input integer is a prime,
                    //  and all of its digits are also primes (or 0)

Sauber , 142 131 125 Bytes

import StdEnv
@a b#l=[n\\n<-[a..b]|and[gcd p n<2&&or[c==k\\k<-:"02357"]\\p<-[1..n-1],c<-:toString n]]
|l>[]=[hd l,last l]=[0]

Ungolfed:

import StdEnv
fn start finish
    # primes
        = [ n
            \\
            n <- [start..finish]
            | and [ gcd p n == 1 && isMember c ['0','2','3','5','7'] 
                \\
                p <- [1..n-1],
                c <-: toString n
            ]
        ]
    | isEmpty primes
        = [0]
    = [hd primes, last primes]

Probieren Sie es online!

Pyth, 28 25 23 Bytes

.xhM_BfP#I_M #+TjT;}FQ0

Testsuite. Gibt [2003,2053] für den letzten Testfall zurück, da 2053 die Primzahl ist.