Calcola lacune primi


19

Trovare i numeri primi è un rito programmatico di passaggio e molto spesso un primo programma serio che qualcuno crea (di solito con divisione di prova).

Ma i numeri primi da soli sono già logori. La prossima cosa molto più interessante è quella di ottenere i gap principali: i gap finora più lunghi tra numeri primi consecutivi. Sono piuttosto rari e "preziosi". Alcune prime coppie e le loro differenze sono:

2 3 1
3 5 2
7 11 4
23 29 6
89 97 8
113 127 14
...

Mio padre li calcolava a mano per divertimento fino a 10k. Vediamo quanto è corto un codice che puoi ottenere.

Regole:

  • nessuna funzione incorporata per test primi, generazione primaria o gap primi
  • nessun recupero http://oeis.org/A002386 o simili (posso sentire l'odore dei tuoi imbroglioni da molto lontano :))
  • nessun array precompilato
  • continuare a stampare fino a quando il tipo intero interno non ha esito negativo

Vince il conteggio dei personaggi più basso. +10 caratteri se si stampano solo gli spazi vuoti senza i numeri primi.

Puoi anche mostrare le versioni con funzioni integrate se sono interessanti. Essere creativo.

Chiarimento: passi attraverso i numeri primi e riferisci ogni volta che vedi un divario che è più grande di qualsiasi gap che hai visto prima. Ad esempio, tra 3 e 5, c'è un divario di 2 unità di larghezza. Anche il divario tra 5 e 7 è 2, ma questa è una vecchia notizia, non ci interessa più. Solo quando vedi un nuovo divario maggiore, lo segnali. Ciò riflette come i numeri primi stanno diventando sempre meno frequenti, man mano che gli spazi diventano sempre più ampi.


EDIT : la maggior parte delle risposte sono brillanti e meritano un maggiore riconoscimento. Tuttavia, finora, una voce GolfScript con 48 caratteri è la più breve.


1
Nel tuo esempio 3 è la fine di una coppia e l'inizio della coppia successiva, mentre questo non è il caso di altri numeri. Cosa vuoi?
mmumboss

Non importa, l'ho preso ora.
mmumboss

Potresti voler riscrivere la tua regola come "nessuna funzione incorporata per test primi, calcoli primi o gap primi". Altrimenti una soluzione ovvia userebbe una funzione che restituisce l' n primo, quindi incrementa n , esegue nuovamente la funzione e trova la differenza.
user12205

2
Aww. amo OEIS
TheDoctor

Ho lo stesso dubbio di @mmumboss. Potresti per favore xplain?
Clyde Lobo,

Risposte:


3

GolfScript 66 59 57 49 48

[2.0{:d{;\;.{).{(1$1$%}do(}do.2$-.d>!}do].p~.}do

Anche se ho problemi a eseguirlo qui http://golfscript.apphb.com/ (forse a quel sito non piace il ciclo infinito?) Ma funziona bene quando lo eseguo sul mio computer con golfscript.rb. Sono abbastanza nuovo su GolfScript, quindi probabilmente questo può essere ulteriormente ridotto. AGGIORNAMENTO: Non credo che questo possa essere risolto molto di più senza cambiare l'algoritmo in qualche modo.

Prime righe stampate (Se non ti piace la "" stampa, puoi aggiungere; all'inizio dello script, ma questo aumenta di 49 caratteri):

[2 3 1]
["" 3 5 2]
["" 7 11 4]
["" 23 29 6]
["" 89 97 8]
["" 113 127 14]
["" 523 541 18]
["" 887 907 20]
["" 1129 1151 22]
...

Idea generale leggibile dall'uomo su come funziona (alcune cose leggermente diverse dal momento che non sto usando uno stack in questa versione):

cur_prime = 2
next_prime = 2
gap = 0        

do {
    do {
        cur_prime = next_prime
        do {
            next_prime = next_prime + 1
            possible_factor = next_prime
            do {
                possible_factor = possible_factor - 1
            } while (next_prime % possible_factor > 0)
        } while (possible_factor != 1)
    } while (next_prime - cur_prime <= gap)

    gap = next_prime - cur_prime
    print [cur_prime next_prime gap]
} while (true)

11

Python, 121 110 109 108 104 103 caratteri

p,n,m=[2],3,0
while 1:
 if all(n%x for x in p):
  c=n-p[0]
  if m<c:m=c;print(p[0],n,c)
  p=[n]+p
 n+=1

La prima volta che ho provato a rispondere qui, spero di averlo fatto bene ... non sono sicuro di aver contato i personaggi nel modo giusto.

Hmmm, potrei salvare un altro personaggio sulla stampa eseguendo il downgrade a Python 2.x ...


121 caratteri, rendi il titolo un titolo #, sul serio non conti i caratteri a mano vero? javascriptkit.com/script/script2/charcount.shtml
user80551

No, non ho contato a mano :) Ma ho visto altre risposte Python ad alcune domande appiattite su una riga in un modo che riduceva gli spazi bianchi, e francamente non sono sicuro che una nuova riga sia contata come 1 o 2 caratteri ...
Tal

1
Contiamo le newline come 1 carattere a meno che le regole della domanda non dichiarino esplicitamente diversamente. Benvenuti in PPCG!
Jonathan Van Matre,

3
Benvenuto! Bella risposta, e ha anche qualche margine di miglioramento. Ad esempio, if all(n%x>0for x in p):è un po 'più breve. È inoltre possibile salvare alcuni caratteri spostando le istruzioni sulla stessa riga (ad es a=1;b=2;f().).
grc

1
L'ultima modifica ha infranto il codice non spingendo [n] in primo piano come indicato.
Orione,

4

JavaScript, 90 85 78 74 caratteri

Codice funzione (compilatore di chiusura di Google - Ottimizzazioni avanzate; alcune modifiche manuali; altre modifiche di @ MT0 )

for(a=b=2,c=0;b++;)for(d=b;b%--d;)d<3&&(c<b-a&&console.log(a,b,c=b-a),a=b)

Codice lungo

var lastPrime = 2,
    curNumber = lastPrime,
    maxDistance = 0,
    i;

// check all numbers
while( curNumber++ ) {

  // check for primes
  i = curNumber;
  while( curNumber % --i != 0 ) {}

  // if prime, then i should be equal to one here
  if( i == 1 ) {

    // calc distance
    i=curNumber-lastPrime;

    // new hit
    if( maxDistance < i ) {
      maxDistance = i;
      console.log( lastPrime, curNumber, maxDistance );
    }

    // remember prime
    lastPrime = curNumber;
  }
}

Produzione

2 3 1
3 5 2
7 11 4
23 29 6
89 97 8
113 127 14
523 541 18
887 907 20
1129 1151 22
1327 1361 34
9551 9587 36
15683 15727 44
19609 19661 52
31397 31469 72
...

Test piuttosto inefficiente per i numeri primi, ma in questo modo utilizza meno caratteri.

Primo post qui, quindi per favore scusa eventuali errori.


78 personaggi -for(a=b=2,c=0;b++;){for(d=b;b%--d;);1==d&&(c<b-a&&console.log(a,b,c=b-a),a=b)}
MT0

@ MT0 Grazie. Non ha individuato quelli. Modificato.
Sirko,

Ancora più inefficiente ma 74 caratteri -for(a=b=2,c=0;b++;)for(d=b;b%--d;)d<3&&(c<b-a&&console.log(a,b,c=b-a),a=b)
MT0

3

Mathematica, 114 108

Consente un output infinito, anche se dopo un certo punto della sequenza la ventola si gira e inizi a sospettare che la tua CPU stia giocando a Freecell mentre fa del suo meglio per sembrare occupata.

p@x_:=NestWhile[#+1&,x+1,Divisors@#≠{1,#}&];m=0;q=1;While[1<2,If[p@q-q>m,Print@{q,p@q,p@q-q};m=p@q-q];q=p@q]

Esempio di output (questi sono quelli raccolti nei primi ~ 30 secondi):

{1,2,1}
{3,5,2}
{7,11,4}
{23,29,6}
{89,97,8}
{113,127,14}
{523,541,18}
{887,907,20}
{1129,1151,22}
{1327,1361,34}
{9551,9587,36}
{15683,15727,44}
{19609,19661,52}
{31397,31469,72}
{155921,156007,86}
{360653,360749,96}
{370261,370373,112}
{492113,492227,114}
{1349533,1349651,118}
{1357201,1357333,132}
{2010733,2010881,148}

Codice non golfato:

p@x_ := NestWhile[
   # + 1 &,
   x + 1,
   Divisors@# ≠ {1, #} &];
m = 0;
q = 1;
While[
 1 < 2,
 If[
  p@q - q > m,
  Print@{q, p@q, p@q - q}; m = p@q - q];
 q = p@q]

Riconosce ?
Riking

Sì, semplicemente non esporta in questo modo, ma lo analizzerà bene quando si incolla il codice nel notebook. L'ho già segnato di conseguenza, ma rivedrò per semplificare.
Jonathan Van Matre,

il numero di caratteri, se si fa uso di Mathematica è built-in funzioni Prime?
Michael Stern,

76. Poiché l'intera definizione p @ x_ è solo una reimplementazione di NextPrime, può essere sostituita da p = NextPrime;
Jonathan Van Matre,

3

Haskell - 122 116 114 112 110

q=[n|n<-[3..],all((>0).rem n)[2..n-1]]
d m((p,q):b)|q-p>m=print(p,q,q-p)>>d(q-p)b|q>p=d m b
main=d 0$zip(2:q)q

(Inefficiente) espressione dell'elenco primo rubata da Will Ness .

-edit- Non ho mai saputo che x|y=z|w=qsarebbe valido.


2

MATLAB 104 89

Ho appena implementato il metodo di base controllando ogni possibile divisione.

a=2;g=0;for n=3:inf;b=n*(sum(mod(n,1:n)<1)<3);h=b-a;if(h>g)g=h;[a,b,h]
end;a=max(a,b);end

Produzione:

  2     3     1
  3     5     2
  7    11     4
 23    29     6
 89    97     8
113   127    14
523   541    18
887   907    20

Sono attivo octavee questa infcosa non funziona (e la stampa viene rinviata fino al termine del ciclo). Matlab ha una valutazione del range pigro?
Orione,

Matlab stampa in tempo reale, ogni iterazione del ciclo. Quando avvio il programma, viene visualizzato un avviso che indica che l'indice massimo è 2147483647 e quindi si avvia. In alternativa, potrei sostituire inf con intmax, ma sono altri tre caratteri.
mmumboss,

2

76 caratteri, dogelang

Convertito dalla mia versione di Python :

g=0
i=l=2
while i+=1=>all$map(i%)(2..i)=>(i-l>g=>(g=i-l),print(l,i,g)),(l=i)

Produzione:

(2, 3, 1)
(3, 5, 2)
(7, 11, 4)
(23, 29, 6)
(89, 97, 8)
(113, 127, 14)
(523, 541, 18)
(887, 907, 20)
(1129, 1151, 22)
...

Dovrebbe essere selezionato come il vincitore!
Sarge Borsch,

2

Golfscript, 59 51 50 caratteri

L'uomo ogni personaggio è estremamente difficile da perdere:

0[2.{).,2>{\.@%!},{.2$-.4$>{].p~\[}{;\;}if..}or}do

Uscita :

[2 3 1]
[3 5 2]
[7 11 4]
[23 29 6]
[89 97 8]
[113 127 14]
...

Spiegazione :

Lo stack è impostato in modo che ogni iterazione inizi con lo stack in questo modo, la parte superiore è a destra. Il [indica il marcatore matrice corrente, cioè quando l'interprete incontra un ], tutto sullo stack dal marchio verso l'alto viene messo in un array.

g [ last | cur

gè il divario massimo finora. Dall'alto in basso:

 command         | explanation
-----------------+----------------------------------------
 0[2.            | initialize vars g=0, last=2, cur=2
 {...}do         | loop forever...

All'interno del ciclo:

 )               | cur += 1
 .,2>{\.@%!},    | put all divisors of cur into a list
 {...}or         | if the list is empty, cur is prime, so
                 | the block is executed. otherwise,
                 | 'do' consumes the stack, sees it is truthy,
                 | and loops again

Come inserisce tutti i divisori in un elenco? Facciamolo passo dopo passo

 Command         | explanation                                  | stack
-----------------+----------------------------------------------+----------------
                 | initial stack                                | n
 .,              | make list of 0..n-1                          | n [0,1,...,n-1]
 2>              | take elements at index 2 and greater         | n [2,3,...,n-1]
 {...},          | take list off stack, then iterate through    |
                 | the list. on each iteration, put the current |
                 | element on the stack, execute the block, and |
                 | pop the top of the stack. if the top is      |
                 | true then keep the element, else drop it.    |
                 | when done, push list of all true elements    |
                 | So, for each element...                      | n x
   \.            |   Swap & dup                                 | x n n 
   @             |   Bring x around                             | n n x
   %             |   Modulo                                     | n (n%x)
   !             |   Boolean not. 0->1, else->0. Thus this is 1 |
                 |   if x divides n.                            | n (x divides n)
                 | So only the divisors of n are kept           | n [divisors of n]

Cosa fa se i divisori sono vuoti?

 Command         | explanation                                  | stack
-----------------+----------------------------------------------+----------------
                 | initial stack                                | g [ last | cur
  .              | dup                                          | g [ l | c | c
  2$             | copy 3rd down                                | g [ l | c | c | l
  -              | sub. This is the current gap, cur-last       | g [ l | c | c-l
  .              | dup                                          | g [ l | c | c-l | c-l
  4$             | copy 4th down                                | g [ l | c | c-l | c-l | g
  >              | is cur gap > max gap so far?                 | g [ l | c | c-l | c-l>g
  {#1}{#2}if..   | #1 if c-l > g, #2 otherwise, and do ".." in  | ... | g [ c | c | c
                 | either situation                             | 

Due percorsi: sì e no. Se sì (nota che ifconsuma il valore più alto nello stack):

 Command         | explanation                                  | stack
-----------------+----------------------------------------------+----------------
                 | initial stack. note that now the old `g` is  | XX [ l | c | g
                 | garbage and `c-l` is the new `g`.            |
 ]               | close the array                              | XX [l, c, g]
 .p              | duplicate it and print it, consuming the dup | XX [l, c, g]
 ~               | pump array back onto the stack. Note now the | XX | l | c | j
                 | array marker [ is gone.                      | 
 \               | swap.                                        | XX | l | g | c                         
 [               | mark the array                               | XX | l | g | c [
 .               | this is the part after the if. dups the top, | XX | l | g [ c | c
                 | but it does this in two steps, first popping | 
                 | c then putting two copies on top, so the     | 
                 | array marker moves                           | 
 .               | dup again                                    | XX | l | g [ c | c | c

Se no:

 Command         | explanation                                  | stack
-----------------+----------------------------------------------+----------------
                 | initial stack. In this case g is still the   | g [ l | c | c-l
                 | max gap so far                               | 
 ;\;             | dump top of stack, swap, and dump again      | g [ c
 ..              | the part after the if. dup twice             | g [ c | c | c

Nota in entrambi i casi, il nostro stack è ora nel modulo ... | g [ c | c | c.

Ora doestrae il valore più alto dallo stack - sempre c- e scorre se è positivo. Da csempre in aumento, questo è sempre vero, quindi giriamo per sempre.

Una volta spuntato, la parte superiore dello stack è g [ c | c, il che significa che l'ultimo è stato aggiornato c, il segno di matrice si trova nello stesso posto ed gè ancora dove ci aspettiamo.

Queste sono le operazioni contorte di GolfScript. Spero ti sia piaciuto seguire!


1
Ottima spiegazione!
Jonathan Van Matre,

1

Ruby, 110

Solo per Ruby 2.0 grazie al lazymetodo:

(2..1.0/0).lazy.select{|n|!(2...n).any?{|m|n%m==0}}.reduce([2,0]){|(l,t),c|d=c-l;p [l,c,d]if d>t;[c,d>t ?d:t]}

Produzione:

[2, 3, 1]
[3, 5, 2]
[7, 11, 4]
[23, 29, 6]
[89, 97, 8]
[113, 127, 14]
[523, 541, 18]
[887, 907, 20]
[1129, 1151, 22]
[1327, 1361, 34]
[9551, 9587, 36]
[15683, 15727, 44]
[19609, 19661, 52]
[31397, 31469, 72]
[155921, 156007, 86]
[360653, 360749, 96]
[370261, 370373, 112]
[492113, 492227, 114]
...

1

Perl, 105 byte

$p=2;$d=0;L:for($i=2;++$i>2;){!($i%$_)&&next L for 2..$i-1;if($i-$p>$d){$d=$i-$p;print"$p $i $d\n"}$p=$i}

Ungolfed:

$p = 2;
$d = 0;
L: for ($i = 2; ++$i > 2; ){
    !($i % $_) && next L for 2..$i-1;
    if ($i - $p > $d) {
        $d = $i - $p;
        print "$p $i $d\n"
    }
    $p = $i
}  

L'algoritmo è semplice, $pricorda il numero primo precedente. Quindi $ipassa da 3a, quando il tipo $ i "fallisce su di me" o diventa negativo a causa dell'overflow. $iviene testato in modo approssimativo controllando tutti i divisori da 2 a $i-1. Viene stampata una linea, se la differenza corrente è maggiore della differenza stampata precedente $d.

Con qualche byte in più il tempo di esecuzione può essere migliorato:

$p = 2;
$d = 0;
L: for ($i=3; $i > 2; $i += 2){
    for ($j=3; $j <= sqrt($i); $j += 2){
        next L if !($i%$j)
    }
    if ($i - $p > $d) {
        $d = $i - $p;
        print "$p $i $d\n"
    }
    $p = $i
}

Il risultato inizia con:

2 3 1
3 5 2
7 11 4
23 29 6
89 97 8
113 127 14
523 541 18
887 907 20
1129 1151 22
1327 1361 34
9551 9587 36
15683 15727 44
19609 19661 52
31397 31469 72
155921 156007 86
360653 360749 96
370261 370373 112
492113 492227 114
1349533 1349651 118
1357201 1357333 132
2010733 2010881 148
4652353 4652507 154
17051707 17051887 180
20831323 20831533 210
47326693 47326913 220
...

1
Non è corretto, è necessario trovare la serie di lacune crescenti. Vedere ad esempio la risposta di Ruby o Matlab per l'output previsto.
mmumboss

1
@mmumboss: Oh, l'ho trascurato. Riparato ora.
Heiko Oberdiek,

Buono per una lingua in cui tutte le variabili richiedono almeno 2 caratteri.
Orione,

1

Python, 93 91 caratteri

Controllo primo ingenuo (controlla se divisibile per qualcosa da 2 a n(meno caratteri rispetto a n/2)):

g=0;i=l=2
while 1:
 i+=1
 if all(i%x for x in range(2,i)):
    if i-l>g:g=i-l;print l,i,g
    l=i

Il secondo livello di rientro è un carattere di tabulazione.

Produzione:

2 3 1
5 7 2
7 11 4
23 29 6
89 97 8
113 127 14
523 541 18
...

Bene, ho dimenticato che vanno fino a un ncontrollo fino an-1
Claudiu,

1

Bash e alcuni Perl per regex primo ( 167 157 143 112 byte)

n=2
c=2
while p=$c
do perl -e\(1x$[++n]')=~/^(11+?)\1+$/&&exit 1'&&c=$n
((c-p>g))&&g=$[c-p]&&echo $p $c $g
done

qualche uscita:

$./golfd.sh
2 3 1
3 5 2
7 11 4
23 29 6
89 97 8
113 127 14
523 541 18
887 907 20
1129 1151 22

L'uso del backtracking NP di regex per aggirare completamente eventuali circuiti e strutture di controllo è pura perfezione. Tuttavia, teststa protestando parecchio e non funziona per me. Si potrebbe anche usare un po ' let n++e let f=c-pe sostituire testcon [. O forse prova (())dove non hai bisogno $o spazi.
Orione,

test -n $drestituito true per una stringa vuota. test -n "$d"andava bene ma più a lungo. Tuttavia, la pagina man dice -n è facoltativo, e risulta che test $dera ok. E quindi [ $d ]anche. E g = 0 doveva essere inizializzato.
Orione,

@orion, scusami per qualche motivo, sembra che una volta si sia rotto anche sulla mia macchina, l'ho ripristinato a 167. Proverò ad aggiungere alcuni dei tuoi altri suggerimenti
Newbrict

Il tuo ambiente potrebbe avere variabili predefinite.
Orione,

@orion per qualche motivo la tua modifica è stata rifiutata, puoi modificare di nuovo?
Newbrict

1

Perl 95 90 byte

for($n=$c=2;$p=$c;$c-$p>$g&&printf"$p $c %d\n",$g=$c-$p){$c=$n if(1x++$n)!~/^(11+?)\1+$/}

vecchia versione Non golf:

$n=$c=2;
while($p=$c){
    $c=$n if (1x++$n)!~/^(11+?)\1+$/;
    if ($c-$p>$g) {$g=$c-$p;print "$p $c $g\n"}
}

Questo è simile alla mia altra presentazione, sans bash.


Non sono fastidioso, voglio solo vedere quanto lontano può andare. Qui:for($n=$c=2;$p=$c;$c-$p>$g&&printf"$p $c %d\n",$g=$c-$p){$c=$n if(1x++$n)!~/^(11+?)\1+$/}
orion,

@orion che è un po 'grave per l'abuso di loop haha!
Newbrict

1

C (100)

Il mio contributo, nessun algoritmo speciale, solo golf:

i,g,r,p=2;main(){for(;r=p;p-r>g?printf("%d %d %d\n",r,p,g=p-r):0)for(i=0;i-p;)for(i=1,++p;p%++i;);}

"+10 caratteri se stampi solo gli spazi vuoti senza i numeri primi." - se rimuovi la stampa di re pavrai meno personaggi e
otterrai

La completezza è piuttosto :)
orion

1

Haskell, 134C

golfed:

c n=null[x|x<-[2..n-1],n`mod`x==0]&&n>1
p=filter c[1..]
g l(m:n:o)
 |(n-m)>l=do print(m,n,n-m);g(n-m)(n:o)
 |True=g l(n:o)
main=g 0 p

Ungolfed:

-- c function checks if n is a prime number
c n=null[x|x<-[2..n-1],n`mod`x==0]&&n>1

-- p is an infinite list of primes
p=filter c[1..]

-- g function prints a list of primes and differences.
--   l is the maximum difference seen so far
--   (m:n:o) is the list of unprocessed primes
g l(m:n:o)
 |(n-m)>l=do print(m,n,n-m);g(n-m)(n:o)
 |True=g l(n:o)

-- main starts the ball rolling with a default max-seen value of 0
main=g 0 p

Adoro quella valutazione pigra!
Jonathan Van Matre,

1

C: 493 302 272 246

int e(int j){for(int i=2;i<j;i++)if(j%i<1)return 0;return 1;}void f(int a,int b,int c){if(e(a)&e(b))if(c<b-a){printf("%d %d %d\n",a,b,b-a);f(a+1,b+1,b-a);}else f(a+1,b+1,c);if(e(b))f(a+1,b,c);if(e(a))f(a,b+1,c);f(a+1,b+1,c);}int main(){f(2,3,0);}

Ho usato la ricorsione non il solito ciclo di foro while.

int isPrime(int num){
    for( int i=2; i<num; i++ )
        if(num%i < 0) return 0;
    return 1;
}
void fun(int n1, int n2, int gap){
   if( isPrime(n1) & isPrime(n2) ){
        if( gap < n2-n1 ){
           printf("%d %d %d\n", n1, n2, n2-n1);
           fun(n1+1, n2+1, n2-n1);
        }else{
           fun(n1+1, n2+1, gap);
        }
   }
   if( isPrime(n2) ){
       fun(n1+1, n2, gap);
   }
   if( isPrime(n1) ){
       fun(n1, n2+1, gap);
   }
   fun(n1+1, n2+1, gap);
}

int main(){
   fun(2,3,0);
}

Produzione:

2 3 1
3 5 2
7 11 4
23 29 6
89 97 8
113 127 14
523 541 18
887 907 20
1129 1151 22
1327 1361 34
9551 9587 36
15683 15727 44
19609 19661 52

Questo non funziona vero / falso non sono definiti, ma anche se lo risolviamo, segnala lacune errate. Ad esempio, ci sono MOLTI numeri primi tra 25219 e 43237. La tua ricorsione è leakingin alto, perché non stai testando isPrime (n2), stai lasciando numeri primi tra n1 e n2. E questo non può davvero essere risolto, perché non puoi aumentare n2 senza incontrare i numeri primi.
Orione,

Hai ragione! È sbagliato! Il mio pensiero era sbagliato dall'inizio.
Loukas,

1
Ora è meglio .. :)
Loukas,

+1 Ora che è stato risolto, mi piace, è piuttosto insolito (anche se non efficiente). Potresti giocare molto a golf. Salta returnin principale. Salta l'ultimo else. Sostituisci &&-> &e num%i==0con num%i<1. E secondo gli antichi standard c (ci saranno avvertimenti), non è necessario specificare i valori di ritorno per le funzioni void e int (i loro argomenti sono anche predefiniti in int).
Orione,

Stavo giocando un po 'e sono arrivato a 151 caratteri, con una sola chiamata ricorsiva incondizionata, un solo identificatore di tipo ( int) e una funzione di test primo molto ridotta: e(j,i){while(j%++i);return i==j;}f(a,b,c){int A=e(a,1),B=e(b,1);if(A&B&&c<b-a)printf("%d %d %d\n",a,b,c=b-a);f(a+(B|!A),b+(A|!B),c);}main(){f(2,3,0);}
orion

1

Oracle SQL, 216 202 196 172 + 10 = 182

Ho appena notato questo nella domanda:

Vince il conteggio dei personaggi più basso. +10 caratteri se si stampano solo gli spazi vuoti senza i numeri primi.

Poiché si tratta di SQL e le parole chiave sono così lunghe, in realtà è meglio prendere la penalità, dando quanto segue. È la stessa idea dell'originale.

with c as(select level+1n from dual connect by level<1e124)select lead(n)over(order by n) from(select*from c a where not exists(select*from c where n<a.n and mod(a.n,n)=0))

che si prefigge di:

with c as ( 
 select level + 1 n 
   from dual 
connect by level < 1e124
        )
select lead(n) over ( order by n ) 
  from ( select *
           from c a 
          where not exists( select * 
                              from c 
                             where n < a.n 
                               and mod(a.n, n) = 0
                                   )
                )

Vecchia risposta (196)

with c as(select level+1n from dual connect by level<1e124)select n,p,p-n from(select n,lead(n)over(order by n)p from(select*from c a where not exists(select*from c where n<a.n and mod(a.n,n)=0)))

e in un formato leggibile:

with c as ( 
 select level + 1 n 
   from dual 
connect by level < 1e124
        )
select n, p, p-n 
  from ( select n, lead(n) over ( order by n ) p 
           from ( select * 
                    from c a 
                   where not exists (
                                select * 
                                  from c
                                 where n < a.n 
                                   and mod(a.n, n) = 0
                                       )
                         )
                )

Questo crea un generatore di numeri c, la sottoselezione più interna crea i numeri primi usando un setaccio di Eratostene, l'esterno elabora il primo precedente e infine l'ultima sottrazione l'una dall'altra.

Questo non restituirà nulla perché sta eseguendo 1 x 10 124 query ricorsive ... Quindi, se vuoi che funzioni abbassando questo numero a qualcosa di sensato.


Quando si tratta di una sfida come questa, penso a SQL non tanto a Turing, quanto a Turing.
Jonathan Van Matre,

Ma si tratta di @Jonathan che sta diventando completo, sebbene a volte ottenerlo sia "interessante" :-)?
Ben

Sapendo che è Turing completo, stavo mirando a scherzare. Mancava il segno, a quanto pare. :) Comunque, ci sono diverse risposte T-SQL nel mio profilo ... porta il tuo Oracle e facciamo un duello!
Jonathan Van Matre,

0

D - 153 + 10 = 163

Prendo volentieri la penalità di +10 qui, perché il conteggio dei caratteri è ancora inferiore a quello che sarebbe stato se avessi stampato anche i numeri primi.

Golfato :

import std.stdio;bool p(int l){int n;foreach(i;1..l+1)n+=l%i==0?1:0;return n==2;}void main(){int g;foreach(l;0..int.max)if(l.p){if(g>0)(l-g).write;g=l;}}

Versione leggibile :

import std.stdio;

bool prime( int number )
{
    int divisors;

    foreach( i; 1 .. number + 1 )
        divisors += number % i == 0 ? 1 : 0;

    return divisors == 2;
}

void main()
{
    int lastPrime;

    foreach( number; 0 .. int.max )
        if( number.prime )
        {
            if( lastPrime > 0 )
                ( number - lastPrime ).write;

            lastPrime = number;
        }
}

0

JAVASCRIPT 174 char

var p=[2],l=2,g=0;
for(var n=3;n>0;n+=2){
  var o=0;
  for(var t=0;t<p.length;++t){
    if(n/p[t] == parseInt(n/p[t])){
      o=1;
    }
  }
  if(o==0){
    p.push(n);
    if(n-l>g){
      g=n-l;
      console.log(l,n,g);
    }
    l=n;
  }
}

versione breve:

var p=[2],l=2,g=0;for(var n=3;n>0;n+=2){var o=0;for(var t=0;t<p.length;++t){if(n/p[t] == parseInt(n/p[t])){o=1;}}if(o==0){p.push(n);if(n-l>g){g=n-l;console.log(l,n,g);}l=n;}}

0

Javascript 138

for(var a=2,b=0,c=0;a++;){var d;a:{for(var e=a,f=2;f<e;f++)if(0==e%f){d=!1;break a}d=!0}d&&(0!=b&&a-b>c&&(c=a-b,console.log(b,a,c)),b=a)}

Copia questo codice sulla tua console del browser. Sarà per sempre come il numero massimo è qualcosa in giro 1.79*10^308.

Ungolfed:

var number = 2;
var lastPrime = 0;
var gap = 0;

while(number++)
{
    if (isPrime(number)) {
        if (lastPrime != 0) {            
            if (number - lastPrime > gap)
            {
                gap = number - lastPrime;
                console.log(lastPrime, number, gap);
            }
        }

        lastPrime = number;
    }
}

function isPrime(n){
    for (var i = 2; i < n; i++) {
        if (n % i == 0)
            return false;
    }
    return true;
}

0

C # 162 161 caratteri

151 caratteri + 10 caratteri penalità = 161 caratteri

Versione breve:

using System;class P{static void Main(){int p=2,g=0;for(int i=3;;i++){for(int j=2;j<i;j++)if(i%j==0)goto e;if(i-p>g)Console.WriteLine(g=i-p);p=i;e:;}}}

Versione lunga:

using System;

class PrimeGaps
{
    private static void Main()
    {
        int lastPrime = 2;
        int largestGap = 0;

        for (int i = 3; true; i++)
        {
            // Prime test
            for (int j = 2; j < i; j++)
                if (i%j == 0)
                    goto nextI; // Skip to next iteration of i

            // Largest gap check
            if (i - lastPrime > largestGap)
            {
                largestGap = i - lastPrime;
                Console.WriteLine(largestGap);
            }

            // Remember last prime
            lastPrime = i;

            nextI:
                ; // Do nothing
        }
    }
}

In realtà era meglio prendere una penalità di 10 caratteri, poiché è una scrittura più breve g(11 caratteri con penalità) rispetto a p+" "+i+" "+g(13 caratteri senza penalità).


0

Rubino 90 86 84 83 caratteri

r,i,g=2,2,0;while i+=1 do(2...i).all?{|j|i%j>0}&&((i-r<=g||p([r,i,g=i-r]))&&r=i)end

Alcuni cortocircuiti booleani, valutazione dell'abuso di espressione, ecc.


0

C 248

Il codice confronta i numeri primi consecutivi a, b e quindi controlla se gli spazi sono maggiori di g, quindi trova la prossima coppia di numeri primi.

#include <cstdio>
void f(int* a, int* b){*a =*b;int t=1;while (*b += 2){t=1;for(int i=3;i<*b;i+=2){if(*b%i==0){t=0; break;}}if(t)break;}}
int main(){int a=2,b=3,g=0;do{(b-a>g)?printf("%d %d %d\n",a,b,(g=b-a)): f(&a,&b);} while(b>=0);return 0;}

Questo è C ++, no?
Zacharý,

0

Haskell, 154 144 137 123

I numeri primi pvengono generati utilizzando il setaccio di erasthotenes #e quindi filtrati e stampati utilizzando %.

p=2:3#1
n#m|all((>0).mod n)$take m p=n:(n+1)#(m+1)|1<2=(n+1)#m
(l:u@(o:_))%k|o-l>k=print(l,o,o-l)>>u%(o-l)|1<2=u%k
main=p%0

L'output è simile

(2,3,1)
(3,5,2)
(7,11,4)
(23,29,6)
(89,97,8)

che spero vada bene.


0

Game Maker Language, 85

Supponendo che tutte le variabili non inizializzate siano 0(questo è il valore predefinito con alcune versioni di Game Maker).

a=2b=2for(d=2;b++;1)for(c<b-a;b mod --d;1)d<3&&(c=b-a&&show_message_ext("",a,b,c)a=b)

0

Game Maker Language, 74 + 55 = 129

Supponendo che tutte le variabili non inizializzate siano 0(questo è il valore predefinito con alcune versioni di Game Maker).

n=2while(n++){if p(n){if l{if n-l>g{g=n-l;show_message_ext("",l,n,g)}}l=n}

Lo script pè di seguito:

r=1a=argument0for(i=2i<a;i++){if a mod i=0r=0}return r}

0

Perl, 87 byte ( usando un modulo )

use Math::Prime::Util":all";$l=2;forprimes{if($_-$l>$m){say"$l $_ ",$m=$_-$l}$l=$_}1e14

Ho scritto il modulo, ma dovremmo aggiungere altri 565.000 caratteri al conteggio. Per lo più invio per divertimento, ma anche per dare un'alternativa alle prestazioni poiché non vedo finora usando i builtin. 4.6s per gap a 1e9, 36s per gap a 1e10, 6.5min per 1e11.

Pari / GP 2.8 può essere fatto sostanzialmente allo stesso modo, anche se oltre 2 volte più lentamente:

l=2;m=0;forprime(p=2,1e14,if(p-l>m,print(l," ",p," ",m=p-l));l=p)

-1

Perl 153

Codice corto:

$i=$a=2;while($a=$i++){if(p($i)){if($m<$m2=$i-$a){$m=$m2;print"$a $i $m$/"}}}sub p{$d=2;$s=sqrt$_[0];while(){return 0if!($_[0]%$d);return 1if$d>$s;$d++}}

facile da leggere:

$i=$a=2;
while($a=$i++){
  if(p($i)){
    if($m<$m2=$i-$a){
      $m=$m2;
      print"$a $i $m$/"
    }
  }
}
sub p {
  $d=2;
  $s=sqrt$_[0];
  while(){
    return 0if!($_[0]%$d);
    return 1if$d>$s;
    $d++;
  }
}

Questo produce tutti i vuoti, non solo il più grande finora.
Orione,
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.