Calcola il minimo

12

sfondo

Considera la seguente sequenza ( A051935 in OEIS):

Inizia con il termine . $2$
Trova il numero intero più basso maggiore di modo che sia primo. $n$ $2$ $2+n$
Trova il numero intero più basso maggiore di modo che sia primo ecc. $n'$ $n$ $2 + n + n'$

Una definizione più formale:

a_{n} = {\begin{cases} 2 & if n = 0 \\ min {x \in N ∣ x > a_{n - 1} and (x + \sum_{i = 0}^{n - 1} a_{i}) is prime} & otherwise \end{cases}

$a_n=\begin{cases}2 & \text{if }n=0 \\ \min\{x\in\Bbb{N}\mid x>a_{n-1} \text{ and }\left(x+\sum_{i=0}^{n-1}a_i\right) \text{ is prime}\} & \text{otherwise}\end{cases}$

I primi termini della sequenza sono (fare riferimento a questi come casi di test):

2, 3, 6, 8, 10, 12, 18, 20, 22, 26, 30, 34, 36, 42, 44, 46, 50, 52, 60, 66, 72, 74, ...

Compito

Il tuo compito è generare questa sequenza in uno dei seguenti modi:

Produce i suoi termini indefinitamente.
Dato $n$ , output $a_{n}$ ( $n^{\text{th}}$ termine, $0$ o $1$ indicizzato).
Dato $n$ , output $\{a_1, a_2, \dots, a_n\}$ (primi $n$ termini).

Puoi competere in qualsiasi linguaggio di programmazione e puoi prendere input e fornire output attraverso qualsiasi metodo standard , tenendo presente che queste scappatoie sono vietate per impostazione predefinita. Questo è code-golf , quindi vince l'invio più breve (in byte) per ogni lingua .

code-golf math sequence number-theory primes

— Mr. Xcoder
fonte

4

Suggerimenti da evitare durante la scrittura di sfide: i numeri primi . Avresti potuto usare qualcos'altro oltre alla primalità.

— Okx,

3

@Okx Avevo in mente un paio di ragioni quando ho scelto la primalità questa volta: 1) Ci sono alcuni algoritmi intelligenti che sono specifici di questa sequenza, come quello implementato da Dennis 2) C'è già una voce OEIS per questo

— Mr. Xcoder

Risposte:

4

Brachylog , 13 byte

~l.<₁a₀ᵇ+ᵐṗᵐ∧

Provalo online!

L'output è l'elenco dei primi n termini della sequenza.

?~l.<₁a₀ᵇ+ᵐṗᵐ∧    Full code (? at beginning is implicit)

?~l.              Output is a list whose length is the input
    <₁            Output is an increasing list
      a₀ᵇ+ᵐ       And the cumulative sum of the output
           ṗᵐ     Consists only of prime numbers
             ∧    No further constraints on output

Explanation for a₀ᵇ+ᵐ:
a₀ᵇ               Get the list of all prefixes of the list
                  Is returned in increasing order of length
                  For eg. [2, 3, 6, 8] -> [[2], [2, 3], [2, 3, 6], [2, 3, 6, 8]]
   +ᵐ             Sum each inner list  -> [2, 5, 11, 19]

— Sundar - Ripristina Monica
fonte

4

Python 2 , 63 62 byte

n=f=a=b=1
while 1:
 f*=n;n+=1;a+=1
 if~f%n<a-b:print a;b=a;a=0

Provalo online!

— Dennis
fonte

4

Gelatina , 11 9 byte

0Ḥ_ÆnɗÐ¡I

Questo è un programma completo che accetta n come argomento e stampa i primi n termini della sequenza.

Provalo online!

Come funziona

0Ḥ_ÆnɗÐ¡I  Main link. Argument: n

0          Set the return value to 0.
      Ð¡   Accumulating iterate. When acting on a dyadic link d and called with
           arguments x and y, the resulting quicklink executes
           "x, y = d(x, y), x" n times, returning all intermediate values of x.
           Initially, x = 0 and  y = n.
     ɗ       Drei; combine the three links to the left into a dyadic chain.
 Ḥ             Unhalve; double the left argument.
  _            Subtract the right argument.
   Æn          Compute the next prime.
           This computes the partial sums of the sequence a, starting with 0.
        I  Increments; compute the forward differences.

— Dennis
fonte

3

05AB1E v2 , 10 byte

2λλOD₁+ÅNα

Provalo online!

Funziona solo nella versione non legacy, la riscrittura dell'Elisir. Emette un flusso infinito di numeri interi. Ci sono alcuni bug con il test principale che sono stati corretti negli ultimi commit, ma non sono ancora attivi su TIO. Funziona localmente, però. Ecco una GIF della sua esecuzione sulla mia macchina, modificata per produrre i primi termini anziché l'intero flusso.

Come funziona

2λ

Definisce una sequenza infinita ricorsiva con il caso base . La struttura è tra le nuove fantastiche funzionalità di 05AB1E. In breve, prende una funzione , impostando sull'argomento intero dato, in questo caso . $2$ λ $a(n)$ $a(0)$ $2$

λO

In questa porzione di codice, λil ruolo è diverso. Già all'interno di un ambiente ricorsivo, genera invece , l'elenco di tutti i risultati precedenti. Quindi, li riassume. $[a(0),a(1),\dots,a(n-1)]$ O

D₁+

Duplica la somma per un uso successivo e aggiungi alla seconda copia. $a(n-1)$

ÅN

Genera il primo più basso rigorosamente maggiore della somma sopra.

α

Infine, recupera la differenza assoluta tra il numero primo calcolato sopra e la prima copia della somma calcolata in precedenza (la somma di tutte le iterazioni precedenti).

Lo stream viene quindi implicitamente stampato indefinitamente su STDOUT.

— Mr. Xcoder
fonte

2

Perl 6 , 45 byte

2,{first (*+@_.sum).is-prime,@_[*-1]^..*}...*

Provalo online!

Restituisce un elenco pigro che genera la sequenza senza fine.

Spiegazione:

Questo utilizza l'operatore Sequence ...che definisce la sequenza come:

2,  # The first element is 2
  {  # The next element is:
    first  # The first value that:
          (*+@_.sum).is-prime,  # When added to the sum is a prime
          @_[*-1]^..*  # And is larger than the previous element
  }
...*  # And continue the sequence indefinitely

— Jo King
fonte

2

Rubino `-rprime` , 34 byte

2.step{|i|$.+=p(i)if($.+i).prime?}

Provalo online!

Uscite indefinitamente.

— Kirill L.
fonte

2

JavaScript (ES6), 63 byte

$n^{th}$

n=>(k=0,s=1,g=d=>s%d?g(d-1):d<2?--n?g(s-=k-(k=s)):s-k:g(s++))()

Provalo online!

— Arnauld
fonte

2

Pyth ,12 11 byte

.f&P-;Z=-;Z

Provalo online!

Salvato 1 byte grazie a isaacg.

Genera i primi nnumeri di questo tipo, utilizzando un indice basato su 1.

.ftrova i primi knumeri interi che soddisfano un criterio particolare a partire da zero. Qui, il criterio è che il primo primo che abbiamo calcolato ;, più il numero corrente Z, è primo ( P). In tal caso, aggiorniamo anche l'ultimo numero primo calcolato utilizzando il comportamento di cortocircuito della logica e della funzione ( &). Sfortunatamente .fla variabile predefinita è quella Zche costa un byte nell'aggiornamento.

Il trucco che isaacg ha scoperto è stato quello di memorizzare la negazione dell'ultimo numero primo e testare su quel meno il valore corrente. Questo è più breve in Pyth poiché il controllo di primalità è sovraccarico: sui numeri positivi trova la fattorizzazione in primo piano mentre sui numeri negativi determina se il valore positivo del numero è primo.

Questo si traduce più o meno in:

to_find = input()
last_prime = 0
current = 0
results = []
while to_find > 0:
    if is_prime( current + last_prime ):
        results.append( current )
        to_find -= 1
        last_prime += current
    current += 1
print results

— FryAmTheEggman
fonte

Sostituire _+con -e +con -per -1 byte.

— isaacg,

@isaacg È abbastanza intelligente! Lo modificherò in.

— FryAmTheEggman il

2

MATL , 21 byte

O2hGq:"t0)yd0)+_Yqh]d

Provalo online!

L'output è i primi n termini della sequenza.

Spiegazione:

Costruisce un elenco di numeri primi (con uno 0 iniziale) e alla fine trova i risultati delle differenze tra i numeri primi successivi nell'elenco.

              % Implicit input, say n
O2h           % Push P = [0, 2] on the stack 
Gq:"          % for loop: 1 to n-1
  t0)           % Take the last element of P
                %  Stack: [[0, 2], [2]] (in first iteration)
  yd0)          % Take the difference between the last
                %   two elements of P
                %  Stack: [[0, 2], [2], [2]]
  +             % Add those up
                %  Stack: [[0, 2], [4]]
  _Yq           % Get the next prime higher than that sum
                %  Stack: [[0, 2], [5]]
  h             % Concatenate that to the list P
                %  Stack: [[0, 2, 5]]
]             % End for loop
d             % Get the differences between successive elements of
              %   the final list P

— Sundar - Ripristina Monica
fonte

2

Haskell , 67 byte

(1#1)2 2
(p#n)s k|p`mod`n>0,n-s>k=k:(p#n)n(n-s)|w<-p*n=(w#(n+1))s k

Provalo online!

(1#1)2 2è una funzione che non accetta input e genera un elenco infinito.

vecchia risposta:

Haskell , 88 83 78 76 byte

Il test di primalità è da questa risposta e migliorato da Christian Sievers (-2 byte).

-5 byte grazie a WW .

2#2
(p#s)n|n<1=p|w<-until(\m->mod(product[1..m-1])m>0)(+1)$s+p+1=(w-s)#w$n-1

Provalo online!

— OVS
fonte

Puoi farne a meno ^2. Ciò cambierà il predicato dal testing è prime al testing è prime o 4 , il che non ha importanza in questa applicazione.

— Christian Sievers,

2

05AB1E (legacy) , 12 byte

0U[XN+DpiN,U

Provalo online!

Spiegazione

0U              # initialize X as 0
  [             # start an infinite loop
   XN+          # add X to N (the current iteration number)
      Dpi       # if the sum is prime:
         N,     #   print N
           U    #   and store the sum in X

Esistono un paio di diverse soluzioni a 12 byte.
Questo particolare avrebbe potuto essere di 10 byte se avessimo inizializzato una variabile utilizzabile come 0 (anziché 1 e 2).

— Emigna
fonte

1

Python 2 , 119 byte

f=lambda n,k=1,m=1:m%k*k>n or-~f(n,k+1,m*k*k)
def g(i):
 r=[2]
 for j in range(i):r+=[f(sum(r)+r[-1])-sum(r)]
 return r

Provalo online!

Funzione Prime successiva f () presa da questa risposta .

La funzione g () accetta un numero intero non negativo i e restituisce un elenco di tutti gli elementi nella sequenza fino a quell'indice.

— Triggernometry
fonte

-7 byte .

— Mr. Xcoder,

1

Python 2 , 99 98 byte

def f(n,s=2,v=2):
 k=s-~v
 while any(k%i<1for i in range(2,k)):k+=1
 return n and f(n-1,k,k-s)or v

Provalo online!

1 byte grazie a Mr. Xcoder .

— Chas Brown
fonte

1

Lo so ... lo so ... Io e la mia pedanteria trucchi bit a bit :) Ma puoi salvare un byte con k=s-~v.

— Mr. Xcoder,

@Sig. Xcoder: la tua cattiva stregoneria bit per bit sarà ancora la tua fine! :)

— Chas Brown,

1

Haskell , 101 99 97 byte

La funzione lnon accetta argomenti e restituisce un elenco infinito. Non breve come l' approccio più diretto di @ovs (e ovviamente ho rubato alcune parti della loro risposta), ma forse è ancora giocabile?

Grazie @ H.PWiz per -2 byte!

import Data.List
p m=mod(product[1..m-1])m>0
l=2:[until(p.(+sum a))(+1)$last a+1|a<-tail$inits l]

Provalo online!

— flawr
fonte

1

Python 2 , 82 80 byte

s=p=2
i=input()
P=n=1
while i:
 P*=n;n+=1
 if P%n>0<n-s-p:p=n-s;s=n;i-=1
print p

Provalo online!

Questo genera l'ennesimo numero della sequenza (basato su 0). Spostando printil ciclo in, questo può essere modificato per produrre i primi nelementi nello stesso byte: provalo online!

— OVS
fonte

1

C (gcc) , 100 99 byte

Salvataggio di un byte grazie a ceilingcat .

p(r,i,m,a,l){for(l=m=a=0;a-r;)m+=i=p(a++);while(r*!l)for(++i,l=a=2;a-m-i;)l=(m+i)%a++?l:0;r=r?i:2;}

Provalo online!

— Jonathan Frech
fonte

0

Japt, 17 byte

Emette il ntermine th, indicizzato 0.

@_+T j}aXÄT±X}g2ì

— ispido
fonte

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.