Défi

Pour une plage d'entiers positifs donnée, recherchez le premier et le dernier nombre premier entièrement composé de chiffres du nombre premier, exceptionnellement incluant 0 (pour les chiffres , une plage de 0-2 devrait sortir 2-2). La gamme est inclusive. Si aucun nombre n'est trouvé, la sortie attendue est 0. S'il n'y a qu'un seul de ces nombres, la sortie attendue est ce nombre deux fois.

Exemples

• Pour la plage 1–100, le premier nombre premier est 2 et le dernier est 73 (7 et 3 sont des nombres premiers).
• Pour la plage 70–80, le premier nombre premier est 73 et le dernier est également 73 (Puisqu'il n'y a qu'un seul nombre correct dans la plage donnée, nous le renvoyons deux fois).
• Pour la plage 190-200, il n'y a pas de bonne réponse, vous retournez donc 0.
• Pour la plage 2000-2100, le premier nombre premier est 2003 et le dernier est 2053 (nous omettons le chiffre 0, mais tous les autres chiffres sont premiers)

C'est le code-golf , donc le code le plus court en octets gagne!

Toutes les lacunes standard s'appliquent.

Contribution

• Vous êtes libre d'accepter deux entiers en entrée, mais vous pouvez voir fit, stack, argument (s) de fonction, argument CLI, stdin.
• Vous ne devez recevoir que deux entiers.

Production

• Vous devez soit renvoyer le résultat (un tuple, un tableau, plusieurs retours si votre langue le prend en charge), le laisser sur la pile ou l'imprimer (dans ce cas, ils doivent être séparés d'une manière ou d'une autre).
• L'ordre des sorties n'a pas d'importance.
• Vous êtes autorisé à placer des crochets de début / fin et des sauts de ligne.
• Vous devez renvoyer deux nombres, s'il y a une réponse, même s'ils sont identiques.
• Vous devez retourner 0 s'il n'y a pas de réponse.

Python 2 , 123 octets

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

Essayez-le en ligne!

Perl 6, 105 94 90 86 octets

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

JavaScript (ES6), 83 octets

Prend la plage [ab] dans la syntaxe de curry (a)(b). Renvoie un tableau à 2 éléments ou 0 .

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

Cas de test

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 octets

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

Essayez-le en ligne!

Gelée , 14 octets

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

Essayez-le en ligne!

Comment ça fonctionne

æRµDo2ÆPẠµÐf.ị ~ Programme complet.

æR ~ Gamme Prime Inclusive.
  µ µÐf ~ Ne conservez que ceux qui remplissent une condition.
   Do2ÆPẠ ~ La condition du filtre:
   D ~ Les chiffres décimaux du nombre actuel.
    o2 ~ Logique ou avec 2 (mappe 0 à 2 et tout autre chiffre sur lui-même).
      ÆP ~ Est-il premier (élément par élément)?
        Ạ ~ Vérifiez si tous les chiffres satisfont à la condition.
            .ị ~ Récupère l'élément à l'index modulaire 0,5. Quelques détails:
                 ~ Jelly est indexé 1, donc 1 nous donne le premier élément, tandis que 0
                   nous donne le dernier élément.
                 ~ Si le plafond et le plancher du nombre N donné ne correspondent pas, 
                   puis Jelly renvoie les articles aux index plancher (N) et plafond (N).
                 ~ Si la liste est vide, cela donne 0, donc c'est très pratique.

Si prendre toute la plage serait autorisé (bien que je pense que cela ne devrait pas l'être), alors 12 octets:

Do2,ÆPȦµÐf.ị

Essayez-le en ligne!

Brachylog , 16 octets

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

Essayez-le en ligne!

Le complètement non sensé "retourne 0 s'il n'y a pas de nombre premier" nous fait perdre 3 octets ( |∧0) sans raison (il reviendrait false.si nous ne les ajoutions pas)

Explication

⟦₂                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 octets

L'utilisation de mon approche initiale s'avère plus courte.

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

Essayez-le ici!

(Je venais de passer à 23 mais Steven m'a battu )

?KfP#I_M-+TjT;0}FQhM_BK0

Essayez-le ici!

Naturellement, hM_BKpeut être remplacé par ,hKeK.

25 octets

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

Essayez-le ici!

26 octets

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

Essayez-le ici!

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

Essayez-le ici!

Comment ils travaillent

.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 octets

Je sais qu'il existe déjà une réponse similaire, mais l'approche ici est assez différente.

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

Cette réponse de 83 caractères sera collée et exécutée dans Mathematica. Le site TIO ne sait pas interpréter ∞.

Gelée , 14 octets

Do2ÆPẠ
æRÇÐf.ị

Essayez-le en ligne!

æ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

Merci à Erik l'Outgolfer pour l'aide à la correction d'un bug. Merci à M. Xcoder pour l' .ịastuce.

Rubis , 87 octets

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

Essayez-le en ligne!

CJam , 36 octets

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

Essayez-le en ligne!

Perl 6 ,  68 66 65 61  58 octets

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

Essayez-le

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

Essayez-le

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

Essayez-le

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

Essayez-le

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

Essayez-le

Étendu:

{  # 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 octets

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

Essayez-le en ligne!

Java 8, 165 164 octets

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

Explication:

Essayez-le ici.

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

Nettoyer , 142 131 125 octets

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]

Non golfé:

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]

Essayez-le en ligne!

Pyth, 28 25 23 octets

.xhM_BfP#I_M #+TjT;}FQ0

Suite de tests. Renvoie [2003,2053] pour le dernier cas de test, puisque 2053 est premier.