Stampa / Stampa tutti i numeri positivi in ​​cui anche ogni sottostringa a più cifre nella sua rappresentazione decimale è primo.


15

Compito

Il tuo compito è stampare o stampare tutti i numeri positivi in cui anche ogni sottostringa a più cifre nella sua rappresentazione decimale è un numero primo. Se il numero ha almeno 2 cifre, ciò implicherebbe che anche il numero stesso deve essere un numero primo.

Esempio

  • 6197è nella sequenza perché ogni più cifre sottostringa in 6197è primo, vale a dire: 61, 19, 97, 619, 197, 6197(stessa).
  • Si noti che 6non è un numero primo ma 6197è ancora nella sequenza perché 6non è una sottostringa a più cifre di 6197.
  • 8è anche nella sequenza perché ogni sottostringa a più cifre 8è primo. Non ci sono sottostringhe a più cifre 8, quindi questo è un caso di verità vacua .

Specifiche

  • Si applicano scappatoie standard , ad eccezione del fatto che è consentito codificare l'output o memorizzare informazioni relative all'output nel programma.
  • I numeri nell'output possono essere in qualsiasi ordine .
  • I numeri nell'output possono avere duplicati.
  • È possibile utilizzare qualsiasi separatore , se si sceglie di stampare anziché l'output.
  • È possibile aggiungere un prefisso e / o postfisso se si sceglie di stampare anziché l'output.
  • Il separatore, il prefisso e il postfisso non possono contenere cifre (da U + 0030 a U + 0039).

Elenco completo (58 articoli)

1
2
3
4
5
6
7
8
9
11
13
17
19
23
29
31
37
41
43
47
53
59
61
67
71
73
79
83
89
97
113
131
137
173
179
197
311
313
317
373
379
419
431
479
613
617
619
673
719
797
971
1373
3137
3797
6131
6173
6197
9719

Riferimento


Come sempre, non esitate a scrivere nei commenti tutto ciò che dovrei chiarire.


2
Darò +300 ricompensa a chiunque tranne @Fatalize che invia la risposta più piccola a questa sfida in Brachylog ( collegamento wiki ) ( collegamento TIO ) ( chat ).
Leaky Nun,

2
Scarso @Fatalize. Questo è ciò che ottieni per la creazione di una lingua
Luis Mendo,

3
Ho una risposta di 50 byte :(
Fatalizza il

1
Il programma deve terminare?
Fatalizza il

2
@LeakyNun Sembra che qualcuno otterrà quella taglia!
Giordania,

Risposte:



7

05AB1E , 15 13 byte

Codice:

4°GN§ŒD9›ÏpP–

Spiegazione:

  G            # For N in range 1,
4°             #   10000
   N           # Push N
    §          # Convert that to string
     Œ         # Get all substrings
      D9›Ï     # Keep all substrings that are greater than 9
          p    # Check each of them if they are prime
           P   # Product
            –  # If 1, print N

Utilizza la codifica CP-1252 . Provalo online! (potrebbe richiedere alcuni secondi).


5

Brachylog , 18 17 15 16 15 byte

ℕ₁<l4&≜sᶠ{Ḋ|ṗ}ᵐ

Provalo online!

-1 byte dopo una discussione con Fatalize mi ha ispirato a vedere cosa succede se cambio il le il <giro.

Questo predicato genera l'output attraverso la variabile di input, purché la variabile di output rimanga senza vincoli. Poiché i duplicati sono consentiti, ogni numero viene generato con una molteplicità pari a 2 alla potenza del numero delle sue cifre che sono numeri primi.

ℕ₁                 The input variable is a natural number
  <                less than
   l4              some number with length 4 (maximized as 9999).
     &≜            Assign a number to the input, and assert that
       sᶠ          every substring of it
         { | }ᵐ    is either
            ṗ      a prime number
          Ḋ        or a single digit.

Versioni precedenti:

{≜ℕsᶠ{Ḋ!|ṗ}ᵐ&}ᶠ⁵⁹b
7^₅⟦₁{sᶠ{Ḋ|ṗ}ᵐ&}ˢ
8ḟ⟦₁{sᶠ{Ḋ|ṗ}ᵐ&}ˢ
∧8ḟ>?ℕ₁≜sᶠ{Ḋ|ṗ}ᵐ

Sono 16 byte, ma non testati, perché controllare tutto fino a 40320 non è esattamente veloce:8ḟ⟦₁{sᶠ{Ḋ|ṗ}ᵐ&}ˢ
Stringa non correlata

Termina bene dato invece un limite superiore di 10000, tuttavia: tio.run/##SypKTM6ozMlPN/r/39AACB7NX/…
Unrelated String

4

Brachylog , 18 byte

Un'altra soluzione di Brachylog. Non potrei farlo più corto della soluzione Brachylog di Erik The Outgolfer; è della stessa identica lunghezza, ma si avvicina alla generazione dalla direzione opposta.

{≜ℕ{sℕ₁₀}ᶠṗᵐ&}ᶠ⁵⁹b

Sembra che Unrelated String lo abbia battuto da molti personaggi, a cui mi congratulo.

Spiegazione:

{≜ℕ                Brute force all nonnegative integers to find any that match the constraints
   {s               Create a predicate that finds all subsequences of digits of said integer
     ℕ₁₀            Constrains those subsequences to be >= 10
        }ᶠ          Finds all possible values of that predicate: all multi-digit subsequences
          ṗᵐ        Apply a primality constraint to all of those subsequences
            &       Make the predicate output the input integer rather than a prime subsequence
             }ᶠ⁵⁹   Find the first 59 results (all of the puzzle's solutions, and zero)
                 b  Remove the first element of the list, i.e. 0

Provalo online!


3

Gelatina , 17 byte

DẆṖÐfḌÆP€Ạ
³²RÇÐf

La mia prima risposta Jelly! Salvato 3 byte grazie a @Leaky Nun !

Provalo online

Spiegazione:

DẆṖÐfḌÆP€Ạ      The helper link, which checks if a given number satisfy the conditions.
DẆ              Convert the argument to a list of its digits and get all its substrings.
  ṖÐf           Remove all lists of length 1.
     ḌÆP€Ạ      Convert back each element to an integer and check if all of them are prime.

³²RÇÐf          Main link.
³²              Create a 100 and square it, which gives 10000.
  R             Create a list from 1 to it.
   ÇÐf          Filter out all the elements where the helper link gives false.

Congratulazioni per la tua prima risposta Jelly!
Leaky Nun,

2
RÇÐfpuò essere sostituito con Ç€T. ṖÐfḌÆP€può essere sostituito con ḌḟDÆP.
Dennis,

3

Java 8, 182 byte

v->{for(int n=0;++n<1e4;)if(P(n)>0)System.out.println(n);}int p(int n){for(int i=2;i<n;n=n%i++<1?0:n);return n;}int P(int n){return n>99?p(n)*p(n%100)*p(n%1000)*P(n/10):n<10?n:p(n);}

La risposta C (gcc) di Port of gastropner , quindi assicurati di votare la sua risposta!

Provalo online.

Spiegazione:

// Loop in range [1,10000), and print any primes corresponding to the challenge description
v->{for(int n=0;++n<1e4;)if(P(n)>0)System.out.println(n);}

// Checks if the given integer is a prime (return unchanged input if prime, 0 if not)
int p(int n){for(int i=2;i<n;n=n%i++<1?0:n);return n;}

// Recursive method that checks if every part of length 2+ is a prime, or is below 10
int P(int n){return n>99?p(n)*p(n%100)*p(n%1000)*P(n/10):n<10?n:p(n);}

2

PowerShell v2 +, 107 104 byte

1..10+(11..1e4|?{($x=11..($i=$_)|?{"$i"-match$_}).count-eq($x|?{'1'*$_-match'^(?!(..+)\1+$)..'}).count})

Avvertenza: Kinda Slow

Loop da 11a 1e4(cioè 10000) ed estrae numeri utilizzando il Where-Objectselettore ( |?{...}). La clausola è 11composta da due componenti: il primo passa dal numero corrente al numero corrente e lo utilizza Where-Objectper estrarre quei numeri che formano una sottostringa del numero corrente (tramite l' -matchoperatore regex). Conserviamo quelle sottostringhe in $x. La seconda porzione scorre attraverso $xe usa Where-Objectper estrarre tutti i numeri primi usando il regex primo . Quindi prendiamo .countentrambi e il controllo è in realtà se quelli sono -eqreali. Ad esempio, 971avrà $x = (71,97,971)e ognuno di questi sono primi, così 3-eq3è $TRUEe quindi 971sarà selezionato.

Tale risultato è concatenato da array con un intervallo 1..10. L'array risultante viene lasciato sulla pipeline e l'output è implicito, con una nuova riga tra gli elementi per impostazione predefinita.



2

C (gcc) , 144 142 140 136 134 132 byte

-2 grazie a Kevin Cruijssen. -2 grazie a ceilingcat

... E ispirato da ciò, possiamo ottenere altri 2 byte da quello per il loop.

Inoltre ha spudoratamente soprannominato il miglior checker piuttosto migliore dalla risposta di Kevin Cruijssen per un altro -4.

p(n,i){for(i=2;i<n;)n*=n%i++||n<10;i=n;}P(n){n=p(n)*(n<99||p(n%100)*p(n%1000)*P(n/10));}f(n){for(n=1e4;--n;)P(n)&&printf("%d\n",n);}

Provalo online!


||n<10può essere |n<10e for(n=1;n<1e4;n++)può essere for(n=0;++n<1e4;)per -2 byte.
Kevin Cruijssen,

@KevinCruijssen Cheers!
Gastropner

2

Malbolge Unshackled (variante a rotazione da 20 trit), 2.5254e7 byte o 1.9809e7 byte

La dimensione di questa risposta supera la dimensione massima del programma disponibile (eh), quindi il codice si trova nel mio repository GitHub (nota: non copiare il codice usando CTRL + A e CTRL + C, basta fare clic con il tasto destro e fare clic su "Salva elemento di destinazione come. .. ").

Come eseguirlo?

Questa potrebbe essere una parte difficile, perché l'ingenuo interprete di Haskell impiegherà anni e secoli per eseguire questo. TIO ha un discreto interprete Malbogle Unshackled, ma purtroppo non sarò in grado di usarlo (limitazioni).

La migliore che ho trovato è la variante con larghezza di rotazione fissa di 20 trit, che funziona molto bene.

Per rendere l'interprete un po 'più veloce, ho rimosso tutti i controlli dall'interprete Malbolge Unshackled di Matthias Lutter.

#include <malloc.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

const char* translation = "5z]&gqtyfr$(we4{WP)H-Zn,[%\\3dL+Q;>U!pJS72Fh"
        "OA1CB6v^=I_0/8|jsb9m<.TVac`uY*MK'X~xDl}REokN:#?G\"i@";

typedef struct Word {
    unsigned int area;
    unsigned int high;
    unsigned int low;
} Word;

void word2string(Word w, char* s, int min_length) {
    if (!s) return;
    if (min_length < 1) min_length = 1;
    if (min_length > 20) min_length = 20;
    s[0] = (w.area%3) + '0';
    s[1] = 't';
    char tmp[20];
    int i;
    for (i=0;i<10;i++) {
        tmp[19-i] = (w.low % 3) + '0';
        w.low /= 3;
    }
    for (i=0;i<10;i++) {
        tmp[9-i] = (w.high % 3) + '0';
        w.high /= 3;
    }
    i = 0;
    while (tmp[i] == s[0] && i < 20 - min_length) i++;
    int j = 2;
    while (i < 20) {
        s[j] = tmp[i];
        i++;
        j++;
    }
    s[j] = 0;
}

unsigned int crazy_low(unsigned int a, unsigned int d){
    unsigned int crz[] = {1,0,0,1,0,2,2,2,1};
    int position = 0;
    unsigned int output = 0;
    while (position < 10){
        unsigned int i = a%3;
        unsigned int j = d%3;
        unsigned int out = crz[i+3*j];
        unsigned int multiple = 1;
        int k;
        for (k=0;k<position;k++)
            multiple *= 3;
        output += multiple*out;
        a /= 3;
        d /= 3;
        position++;
    }
    return output;
}

Word zero() {
    Word result = {0, 0, 0};
    return result;
}

Word increment(Word d) {
    d.low++;
    if (d.low >= 59049) {
        d.low = 0;
        d.high++;
        if (d.high >= 59049) {
            fprintf(stderr,"error: overflow\n");
            exit(1);
        }
    }
    return d;
}

Word decrement(Word d) {
    if (d.low == 0) {
        d.low = 59048;
        d.high--;
    }else{
        d.low--;
    }
    return d;
}

Word crazy(Word a, Word d){
    Word output;
    unsigned int crz[] = {1,0,0,1,0,2,2,2,1};
    output.area = crz[a.area+3*d.area];
    output.high = crazy_low(a.high, d.high);
    output.low = crazy_low(a.low, d.low);
    return output;
}

Word rotate_r(Word d){
    unsigned int carry_h = d.high%3;
    unsigned int carry_l = d.low%3;
    d.high = 19683 * carry_l + d.high / 3;
    d.low = 19683 * carry_h + d.low / 3;
    return d;
}

// last_initialized: if set, use to fill newly generated memory with preinitial values...
Word* ptr_to(Word** mem[], Word d, unsigned int last_initialized) {
    if ((mem[d.area])[d.high]) {
        return &(((mem[d.area])[d.high])[d.low]);
    }
    (mem[d.area])[d.high] = (Word*)malloc(59049 * sizeof(Word));
    if (!(mem[d.area])[d.high]) {
        fprintf(stderr,"error: out of memory.\n");
        exit(1);
    }
    if (last_initialized) {
        Word repitition[6];
        repitition[(last_initialized-1) % 6] =
                ((mem[0])[(last_initialized-1) / 59049])
                    [(last_initialized-1) % 59049];
        repitition[(last_initialized) % 6] =
                ((mem[0])[last_initialized / 59049])
                    [last_initialized % 59049];
        unsigned int i;
        for (i=0;i<6;i++) {
            repitition[(last_initialized+1+i) % 6] =
                    crazy(repitition[(last_initialized+i) % 6],
                        repitition[(last_initialized-1+i) % 6]);
        }
        unsigned int offset = (59049*d.high) % 6;
        i = 0;
        while (1){
            ((mem[d.area])[d.high])[i] = repitition[(i+offset)%6];
            if (i == 59048) {
                break;
            }
            i++;
        }
    }
    return &(((mem[d.area])[d.high])[d.low]);
}

unsigned int get_instruction(Word** mem[], Word c,
        unsigned int last_initialized,
        int ignore_invalid) {
    Word* instr = ptr_to(mem, c, last_initialized);
    unsigned int instruction = instr->low;
    instruction = (instruction+c.low + 59049 * c.high
            + (c.area==1?52:(c.area==2?10:0)))%94;
    return instruction;
}

int main(int argc, char* argv[]) {
    Word** memory[3];
    int i,j;
    for (i=0; i<3; i++) {
        memory[i] = (Word**)malloc(59049 * sizeof(Word*));
        if (!memory) {
            fprintf(stderr,"not enough memory.\n");
            return 1;
        }
        for (j=0; j<59049; j++) {
            (memory[i])[j] = 0;
        }
    }
    Word a, c, d;
    unsigned int result;
    FILE* file;
    if (argc < 2) {
        // read program code from STDIN
        file = stdin;
    }else{
        file = fopen(argv[1],"rb");
    }
    if (file == NULL) {
        fprintf(stderr, "File not found: %s\n",argv[1]);
        return 1;
    }
    a = zero();
    c = zero();
    d = zero();
    result = 0;
    while (!feof(file)){
        unsigned int instr;
        Word* cell = ptr_to(memory, d, 0);
        (*cell) = zero();
        result = fread(&cell->low,1,1,file);
        if (result > 1)
            return 1;
        if (result == 0 || cell->low == 0x1a || cell->low == 0x04)
            break;
        instr = (cell->low + d.low + 59049*d.high)%94;
        if (cell->low == ' ' || cell->low == '\t' || cell->low == '\r'
                || cell->low == '\n');
        else if (cell->low >= 33 && cell->low < 127 &&
                (instr == 4 || instr == 5 || instr == 23 || instr == 39
                    || instr == 40 || instr == 62 || instr == 68
                    || instr == 81)) {
            d = increment(d);
        }
    }
    if (file != stdin) {
        fclose(file);
    }
    unsigned int last_initialized = 0;
    while (1){
        *ptr_to(memory, d, 0) = crazy(*ptr_to(memory, decrement(d), 0),
                *ptr_to(memory, decrement(decrement(d)), 0));
        last_initialized = d.low + 59049*d.high;
        if (d.low == 59048) {
            break;
        }
        d = increment(d);
    }
    d = zero();

    unsigned int step = 0;
    while (1) {
        unsigned int instruction = get_instruction(memory, c,
                last_initialized, 0);
        step++;
        switch (instruction){
            case 4:
                c = *ptr_to(memory,d,last_initialized);
                break;
            case 5:
                if (!a.area) {
                    printf("%c",(char)(a.low + 59049*a.high));
                }else if (a.area == 2 && a.low == 59047
                        && a.high == 59048) {
                    printf("\n");
                }
                break;
            case 23:
                a = zero();
                a.low = getchar();
                if (a.low == EOF) {
                    a.low = 59048;
                    a.high = 59048;
                    a.area = 2;
                }else if (a.low == '\n'){
                    a.low = 59047;
                    a.high = 59048;
                    a.area = 2;
                }
                break;
            case 39:
                a = (*ptr_to(memory,d,last_initialized)
                        = rotate_r(*ptr_to(memory,d,last_initialized)));
                break;
            case 40:
                d = *ptr_to(memory,d,last_initialized);
                break;
            case 62:
                a = (*ptr_to(memory,d,last_initialized)
                        = crazy(a, *ptr_to(memory,d,last_initialized)));
                break;
            case 81:
                return 0;
            case 68:
            default:
                break;
        }

        Word* mem_c = ptr_to(memory, c, last_initialized);
        mem_c->low = translation[mem_c->low - 33];

        c = increment(c);
        d = increment(d);
    }
    return 0;
}

Note sulle prestazioni

L'applicazione ha funzionato per circa 40 minuti sulla mia macchina, producendo numeri esadecimali della sequenza. L'ho fermato circa un'ora di calcoli, ed è finito su 0x11.

Nota che questa risposta differisce dalla mia altra, perché questa in realtà calcola i numeri e può essere fatta in modo che li calcoli indefinitamente.

L'applicazione alloca il buffer di spinup, che è grande circa 7 gigabyte, quindi prepara meglio la tua RAM libera.

Variante alternativa

La variante alternativa utilizza circa 2 gigabyte di memoria in meno, ma produce l'output in forma di caratteri ASCII (0 = ASCII (0x0), 10 = newline, ecc ...) ed è disponibile qui . Tuttavia, non è in concorrenza, a causa dei requisiti della sfida


Il golf del codice consiste nel dare risposte brevi.
Alfe,

2
@Alfe Malbolge è una lingua progettata per essere estremamente difficile da programmare (link Wikipedia) ; il fatto che ciò sia persino possibile è piuttosto impressionante.
Giuseppe,

4
Quindi, in effetti, questa è una risposta breve. Solo gli standard sono cambiati. Leggermente.
Alfe,

3
@Alfe sei il benvenuto per provare a radere qualche byte! ;-)
Giuseppe

2

Python 3 , 118 byte

r=range(9720)
for n in r[1:]:all(all(l%k+9//l for k in r[2:l])for l in(n%10**(i%5)//10**(i//5)for i in r))and print(n)

Provalo online!

Spiegazione

Avvertenza: nessuna stringa effettiva coinvolta in questa soluzione.

r=range(9720)
for n in r[1:]:                                        # For each positive integer up to 9720
 all( ... for l in(n%10**(i%5)//10**(i//5)for i in r)) # Check for all its substrings
  all(l%k ... for k in r[2:l])                         # If it is either prime
   +9//l                                               # Or smaller than 10
and print(n)                                           # Then print

1

Rubino, 81 + 8 = 89 byte

+8 byte per -rprime.

puts (?1..?9*4).select{|m|(r=2..m.size).all?{|i|r.all?{|j|m[i-2,j].to_i.prime?}}}

Guardalo su repl.it: https://repl.it/CniR/2


1

Perl 6 ,  47 44  43 byte

for 1..9719 {all(m:ex/..+/).Int.is-prime&&.say}
put grep {is-prime +all(m:ex/..+/):},1..9719
put grep {is-prime +all m:ex/..+/:},1..9719

Spiegazione:

# print the values space separated, with trailing newline
put

# that match
grep -> $_ {

  # call the method 「.is-prime」 ( that is what 「:」 is for )
  # (autothreaded)
  is-prime

  # convert following to numeric (autothreaded)
  +
  # a junction of
  all(
    # all substrings 2 characters or greater
    $_ ~~ m :exhaustive / . .+ /
  )

  # needed to indicate that 「is-prime」 is a method call
  :

},

# in this Range
1..9719

1

C #, 261 249 247 byte

Risparmiato 12 byte grazie a Leaky Nun

()=>{Action<int>w=System.Console.WriteLine;int i=0,n,j,k,p,m,b;for(;++i<10001;){n=(i+"").Length;if(n<2)w(i);else{b=1;for(j=1;++j<=n;)for(k=0;k+j<=n;){p=int.Parse((i+"").Substring(k++,j));if(p%2<1)b=0;for(m=3;m<p;m+=2)if(p%m<1)b=0;}if(b>0)w(i);}}};

Questo si compila in a Func<List<int>>.

La versione formattata è simile a:

() =>
{
    Action<int> w = System.Console.WriteLine;

    int i = 0, n, j, k, p, m, b;

    for (; ++i < 10001;)
    {
        n = (i + "").Length;

        if (n < 2)
            w(i);

        else
        {
            b = 1;
            for (j = 1; ++j <= n; )
                for (k = 0; k + j <= n; )
                {
                    p = int.Parse((i + "").Substring(k++, j));

                    if (p % 2 < 1)
                        b = 0;

                    for (m = 3; m < p; m += 2)
                        if (p % m < 1)
                            b = 0;
                }

            if (b > 0)
                w(i);
        }
    }
};

Basta stamparlo direttamente senza utilizzare un elenco
Leaky Nun,

Invece di falseo true, usa 0>1e0<1
Leaky Nun il

Puoi fare riferimento a questo per ulteriori suggerimenti sul golf.
Leaky Nun,

@LeakyNun Grazie per i suggerimenti, di solito mi piace pubblicare una versione da golf e poi spostarmi da lì.
TheLethalCoder

1

Swift 4 , 144 byte

let p={n in !(2..<n).contains{n%$0<1}}
print((1...971).filter{$0<10||p($0)&&($0<100||p($0/10)&&p($0%100))}+[1373,3137,3797,6131,6173,6197,9719])

Provalo online!

Spiegazione

let p={n in !(2..<n).contains{n%$0<1}} // Helper function p, tests if a number is prime
print((1...971).filter{                // Print every number n in the range 1 to 971
 $0<10                                 //  that is less than 10
 ||p($0)&&                             //  or a prime and
 ($0<100                               //   is less than 100 or
  ||p($0/10)&&p($0%100))}              //   n/10 and n%100 are primes
+[1373,3137,3797,6131,6173,6197,9719]) // Print the four digit numbers

1

JavaScript (Node.js) , 130 byte

se posso assumere pila infinita i*i<=n&&può essere rimosso e i*i>nturno i>=nche riduce il codice 9 byte e forse convertire principale funzione ricorsiva: https://tio.run/##LYpBDoIwEEX33AMyAxVbXUmccgX2xkWDRYeQaSPqyrvXkrj5ef/lze7j1vHJ8bWTcPMpTQRMWjm6XJFs0/DZ@EM/ASunBmCsKtfG9/rIiJ0rIoEoJpNbKXPdx@1jx5akGEiytqdNYp2nNFr / wR @ xHkD2Rn81dpLGIGtYfLuEO0yAmH4 (119 byte)

_=>eval(`for(a=[i=1];++i<1e4;)P(i)&&a.push(i)`)||a
p=(n,i=1)=>i*i<=n&&n%++i?p(n,i):n%i
P=n=>n>9?p(n)*p(n%100)*p(n%1e3)*P(n/10|0):n

Provalo online!


1

Malbolge , 1361 byte

Versione semplice e noiosa. Visualizza i numeri dal più alto.

D'`r^"!=[YG3yUCvA-csNqp-nJ$HYFgDC#AbQ,|*)\rwvutm3kSonmlkdihg`&dc\aZ_X|V[ZYXQPt7SRQPOHGkKJIHG@d>=<A:98\}|:981U5.-2+0/.'K%$#G!E}e#z!~}v<]yxwpun4rkj0nmfN+ihaf_^$\a`_XW{>=YXWVONrLKPINGkE-IBAe(>=<;_?>=}|:3W1w543,P0).-&J*)(!E}|B"!~}|{zyr8potml2jongfkjibg`&d]\"`_XW{>=YXWVONr54JIHMFj-,HGF?>b%A@?87[;:981w543,P0).-&J*j(!EfeB"!~}_u;yrqpun4rqpihmlkjihg`&d]\"`_X|\[ZYXQuUNMLQJnH0LKJIBAe(>=<`#"8\<5Y9270T43,Pqp.-&J$)"!~D|#"y~}|u;s9qvotsrk1inglkdihg`&d]\"Z~XWVUZYXQu87SLKo2NGFjDIHGF?>bBA#"8\6;:981Uv.32+*)Mnm%$)('~D|{A!xwv{zyr8vXnsrkjoh.fNdchg`ed]#aC_^WVz=YXQPt7SRQPOHGkK-IHGF?>bBA#"8\6;:981Uv.32+*)Mnm%*#"F&%$#cy?}v<]\xwpun4rqSonmf,diha'eG]#a`_X|V[ZYXWPt76LKoIHGLEiCHGFED=aA:?>7[;:981w/4-,PO)o'&J*j(!E%edz@~}_u;yxqpo5mrqpoh.f,jibgf_%]\[!_XW{[ZYXQu87SLKo2NGFjJIHAF?c=BA@?>=<5Y38765.-Q10)o'&J*j(!E%e{z@~}|{ts9qpotsrk1oQglkd*)gIed]#DZ_^]VzZYRQuONMRKJnNGLEJCgG)(D=aA:?>=<;4X816/43,P0).-&+$H('gf|Bcb~w|u;yxwYutmrqj0nmleMib(fH%cba`_X|VUZYXWPt7SRQPOHGkEDIHG@dDC<;@?8\6|:32V0T43,+O)o'&J*)('&}C{"yxwv<tyr8vun4Ukpoh.fN+c)gIed]#DZ_^]VzTSRWPtTSLQJnH0LKJIBAe(>=BA@987[;:381Uv.32+*)Mnm%$)('~D${"y?}_uzyxqpo5srqSonmf,jihgfeG]#a`_X|V[ZYXWPt76LKo2NGFjJIH*)ED=a;@?>76;4X816/43,P*).',%I)('~Ded"y~}|u;srqvo5mlqpih.fN+cba`&d]\aZ~^]VUZSwWPUTSLpJ2NGLEiCHGFED=a;:?>7<5YX876v43,+O).-,+$H('&feBz!x}v{zsr8punsrk1inglkdihg`&d]\"Z~X]V[ZSwQVUTMRKo2NGFjDIHGF?>b%A@?87[;{921U5.3210)M-,%k#(!EfeB"y~}v{zyr8%

Provalo online!


0

TI-83/84 BASIC, 124 byte

For(A,1,E4
DelVar Nint(log(A→P
Ans→Q
While Ans
For(I,0,Q-Ans
10^(P+1
AnsfPart(iPart(A/10^I)/Ans→S
min(Ans={2,3,5
If S≥7 and fPart(.5S
min(remainder(S,3+2cumSum(not(binompdf(int(.5√(S)),0
N+not(Ans→N
End
P-1→P
End
If not(N
Disp A
End

Passa sopra i primi numeri interi da 10k. Imposta un contatore in N per controllare ogni sottostringa primo e int (log (A recupera uno in meno del numero di cifre nel numero corrente. Quindi mettiamo da parte quel numero in una seconda variabile in modo da poter far scorrere P in giù per ogni lunghezza sottostringa di almeno 2 cifre. 10 ^ ... e AnsfPart (iPart (,,, genera la sottostringa corrente per verificare la primalità, quindi le 3 righe seguenti eseguono il controllo della primalità su 1 o 0 in Ans. Se la sottostringa non è primaria , incrementiamo N e dopo aver controllato tutte le sottostringhe se N è ancora 0 stampiamo il numero corrente.

Forse è possibile apportare alcune modifiche per aumentare l'efficienza del controllo di primalità verso questo test? Sono contento di aver trovato un algoritmo in meno byte rispetto alla memorizzazione dell'output direttamente nella formattazione TI-83!


0

Python 3.8 (pre-release) , 194 byte

r=range
s=str
l=lambda _:len(s(_))
[*map(print,[t for t in r(1,10**4) if all(all(int(x)%b for b in r(2,int(x))) for x in [s(t)[i:j+1] for i in r(l(t)) for j in r(i,l(t)) if l(s(t)[i:j+1])>1])])]

Provalo online!


0

PHP , 135 byte

for(;++$n<1e4;$p||print"$n
")for($p=$i=0;$i<$l=strlen($n);$i++)for($j=1;$j++<$l-$i;$p|=$k)for($k=($m=substr($n,$i,$j))-1;$k&&$m%$k--;);

Provalo online!

for(;                         // level 1 loop on
  ++$n<1e4;                   // all numbers from 1 to 10,000, $n is current number
  $p||print"$n\n"             // at the end of loop for each number, print $n if all multi digit sub strings were prime ($p=0)
)
  for(                        // level 2 loop on each digit of $n
    $p=                       // $p is a flag for all sub string primes and is set to 0 for each new $n
      $i=0;                   // $i is position of current digit (and sub string start position)
    $i<$l=strlen($n);         // $l is the total digits count in $n
    $i++                      // increment $i by one
  )
    for(                      // level 3 loop to create sub strings
      $j=1;                   // $j is length of sub string, we only care about multi digit sub strings so it starts from 1
      $j++<$l-$i;             // continue the loop as long as $j has not reached last digit and increment it by one
      $p|=$k                  // THIS IS RUN AFTER LOOP LEVEL 4: update $p flag based on value of $k
                              //     $p will be left at 0 only if all of the sub strings are prime (if $k is always 0)
    )
      for(                    // level 4 loop to check each sub string to be prime
        $k=(                  // $k is set to current sub string minus 1
          $m=substr($n,$i,$j) // $m is current sub string
        )-1;                  // 
        $k && $m%$k--;        // as long as $k is more than 0 and $m%$k is not zero, decrement $k by one and continue
                              //     a prime number will only get a 0 remainder, when $k gets to 1
                              //     so $k will be 0 for primes and more than 0 for non-primes
      );
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.