Étant donné un grand nombre (en base 10), tel que 1234567891011121314151617, y trouver des "sous-numéros" principaux.
Un "sous-numéro" premier est une séquence consécutive de chiffres (tirés de l'entrée), qui représente un nombre premier (en base 10).

• Entrée : un nombre (soit une chaîne, un fichier ou tout ce que vous voulez).
• Sortie : tous les sous-nombres principaux sont séparés d'une manière ou d'une autre (soit dans une liste, un fichier, des chaînes séparées par des virgules ...) Si le résultat est vide, vous pouvez prendre toutes les conventions que vous souhaitez (chaîne codée en dur, chaîne vide, charabia, mais le programme ne doit pas crash.
• Exemple
  1234 -> 2, 3, 23
  6542 -> 5, 2
  14 -> [.. sortie vide]

C'est du code-golf. Le programme le plus court gagne!
[modifier]: règle supplémentaire, le programme doit être expliqué! Tout le monde ne parle pas couramment Jelly :)

05AB1E (hérité) , 3 octets

Œʒp

Essayez-le en ligne!

Sous-chaînes de l'entrée qui sont premières.

Perl 6 , 28 octets

{grep &is-prime,+«m:ex/.+/}

Essayez-le en ligne!

L' :exindicateur ("exhaustif") de l'opérateur de correspondance lui mfait renvoyer toutes les correspondances possibles .+(c'est-à-dire, chaque sous-chaîne d'un ou plusieurs caractères), même celles qui se chevauchent. L'hyperopérateur +«transforme cette liste d' Matchobjets en nombres, qui sont ensuite filtrés par ordre de primauté grep &is-prime.

Brachylog , 4 octets

-1 octet grâce à Kroppeb .

sᶠṗˢ

Essayez-le en ligne!

ᶠdans toutes les scordes, ˢélisez les ṗrimes

Python 2 , 66 65 octets

P=k=1
n=input()
while~n+k:
 if`k`in`n`>0<P%k:print k
 P*=k*k;k+=1

Essayez-le en ligne!

Japt , 13 10 octets

Merci @Shaggy -3 octets

ò fj f@søX

ò fj f@søX              Full program
                        implicity input
ò                       inclusive range [this - 1]
  fj                    filter primes and
     f@søX              values contained in input

Essayez-le en ligne!

Gelée ,  5  4 octets

-1 merci à Kevin Cruijssen ( Ẓest un alias pour ÆP)

ẆḌẒƇ

Un lien monadique acceptant une liste de chiffres * qui donne une liste d'entiers premiers.

^{* en utilisant "soit une chaîne, un fichier ou tout ce que vous voulez" - pour prendre un entier, préfixez le code avec un D}

Essayez-le en ligne!

Comment?

ẆḌẒƇ - Link: list of integers (digits)   e.g. [1,2,3,4]
Ẇ    - non-empty contiguous substrings        [[1],[2],[3],[4],[1,2],[2,3],[3,4],[1,2,3],[2,3,4],[1,2,3,4]]
 Ḍ   - convert to decimal (vectorises)        [1,2,3,4,12,23,34,123,234,1234]
   Ƈ - filter keep if:
  Ẓ  -   is prime?                            [2,3,23]

Java 8, 148 147 octets

n->{for(int l=n.length(),i=l,j;i-->0;)for(j=l;j>i;){long k=2,x=new Long(n.substring(i,j--));for(;k<x;x=x%k++<1?0:x);if(x>1)System.out.println(x);}}

Essayez-le en ligne.

Explication:

n->{                     // Method with String parameter and no return-type
  for(int l=n.length(),  //  Length of the input-String
          i=l,j;         //  Temp-integers
      i-->0;)            //  Loop `i` in the range [length, 0)
    for(j=l;j>i;){       //   Inner loop `j` in the range [length, 0)
      for(long k=2,      //    Set `k` to 2
               x=new Long(n.substring(i,j--)
                         //    Take the substring [`i`, `j`) from the input,
            );           //    convert it to a long, and set it as `x`
          k<x;           //    Inner loop as long as `k` is still smaller than `x`
        x=x%k++<1?       //     If `x` is divisible by `k`:
           0             //      Set `x` to 0
          :              //     Else:
           x);           //      Leave `x` unchanged
      if(x>1)            //    If `x` is now larger than 1 (a.k.a. If `x` is a prime):
        System.out.println(x);}}
                         //     Print `x` with a trailing newline to STDOUT

MATL , 9 octets

&XfXUtZp)

Essayez-le en ligne!

Explication

&Xf   % Implicit input: string. Push cell array of non-empty substrings
XU    % Convert to number. Vectorizes
t     % Duplicate
Zp    % Isprime. Vectorizes.
)     % Index. Keeps substrings indicated by the previous result. Implicit display

Utilitaires Bash + GNU Core: 80 77 octets

for i in $(seq `tee a|wc -c`)
{
grep -oE .{$i}<a|factor|grep -oP ': \K\d+$'
}

Cela ne peut pas être le plus court, mais j'ai du mal à trouver quoi que ce soit de mieux. Demander de l'aide!

En ne m'en tenant qu'à POSIX, j'en ai obtenu 82:

for i in $(seq `tee a|wc -c`)
{
grep -oE .{$i}<a|factor|awk -F\  'NF<3{print$2}'
}

R , 60 octets

function(v)Filter(function(i)grepl(i,v)&sum(!i%%1:i)==2,1:v)

Essayez-le en ligne!

Pas vraiment efficace, inspiré par la réponse @ovs python 2

Python 2 , 115 114 octets

f=lambda s:s and[n for n in[int(s[j:])for j in range(len(s))]if n>1and all(n%i for i in range(2,n))]+f(s[:-1])or[]

Essayez-le en ligne!

Husk , 5 octets

foṗiQ

Essayez-le en ligne!

Nettoyer , 108 octets

import StdEnv,Data.List
$s=nub[n\\u<-inits s,n<-map(toInt o toString)(tails u)|n>1&&all(\m=n/m*m<n)[2..n-1]]

Essayez-le en ligne!

Pyth, 8 octets

fP_TsM.:

Suite de tests

Prend l'entrée sous forme de chaîne, affiche une liste d'entiers. Peut également prendre une entrée int en ajoutant` à la fin pour un octet supplémentaire.

fP_TsM.:  | Full code
fP_TsM.:Q |  with implicit variables added
          | Print (implicit)
      .:Q |  list of all substrings of the input
    sM    |   converted to integers
fP_T      |    filtered for prime numbers

Et `se convertit simplement inten str.

Wolfram Language (Mathematica) , 40 octets

Select[PrimeQ@*FromDigits]@*Subsequences

Essayez-le en ligne!

L'entrée et la sortie sont des listes de chiffres. Dans le cas où il n'y a pas de sous-nombres premiers, la liste vide {}est renvoyée.

Utilise @*pour Compositiondes fonctions. Subsequencesdonne une liste de toutes les sous-séquences de l'entrée, et Select[PrimeQ@*FromDigits]est une forme d'opérateur Selectdont retourne une liste de tous les éléments pour lesquels PrimeQ@*FromDigitsretourne True.

Matlab, 89 octets

function[m]=f(x),m=1;for i=1:length(x),m=[m;str2num(combnk(x,i))];end,m=m(isprime(m));end

Essayez-le en ligne!