È noto che i primi dispari appariranno due volte nel triangolo di Pascal. Tuttavia, non tutti i numeri che appaiono esattamente due volte nel triangolo di Pascal sono primi. Chiameremo questi numeri numeri primi di Pascal.

I numeri primi di Pascal sono numeri compositi che compaiono esattamente due volte nel triangolo di Pascal. I primi numeri Pascal sono

4, 8, 9, 12, 14, 16, 18, ...

La tua sfida è prendere un intero positivo n come input e output vero o falso, a seconda che n sia un primo di Pascal o meno. Questo è code-golf, quindi vince il programma più corto!

Wolfram Language (Mathematica) , 45 byte

CompositeQ@#&&Binomial~Array~{#-1,#}~FreeQ~#&

Provalo online!

Ogni numero composto n appare esattamente due volte sulla riga n e non può apparire in seguito. Quindi la condizione per i numeri primi di Pascal è che non compaiano affatto nelle prime righe n-1 .

Per quanto posso dire, questo è più breve del verificare che appaia esattamente due volte nelle prime n righe e di poterlo usare !PrimeQinvece.

Python 2 , 93 byte

def f(n):l=[1];exec"(n in l)>=any(n%k<1for k in range(2,n))>q;l=map(sum,zip([0]+l,l+[0]));"*n

Provalo online!

Questa è una funzione denominata f , che emette tramite il codice di uscita , 0 per Pascal Primes, 1 altrimenti.

Come funziona?

def f(n):l=[1];                       # Define a function f (arg. n) and a list l = [1].
exec"..."*n                           # Execute n times.
(n in l)                              # Boolean: "n is in l?" is greater than...
   >=any(n%k<1for k in range(2,n))    # the boolean: "Is n composite?"?
            >q;                       # If the boolean comparison returns a falsy
                                      # result, then continue on without any difference.
                                      # Otherwise, evaluate the other part of the
                                      # inequality, thus performing "is greater than q".
                                      # Since we have no variable "q", this terminates
                                      # with exit code 1, throwing a "NameError".
l=map(sum,zip([0]+l,l+[0]));          # Generate the next row in Pascal's triangle,
                                      # By zipping l prepended with a 0 with l appended
                                      # with a 0 and mapping sum over the result.

Questo in sostanza controlla se n si verifica nelle prime n - 1 righe del triangolo di Pascal o se è primo e genera un errore se si verifica una di queste due condizioni.

Salvato 1 byte grazie a ovs .

Jelly , 11 10 9 byte

Grazie a:

• Martin Ender per -1 byte! (un altro approccio, usare’ (+1) evita di usare n2(-2), quindi -1 in generale.
• Jonathan Allan per la correzione di bug.
• Dennis per un altro -1 byte.

Ḷc€ḶFċ=ÆP

Provalo online!

Approccio alternativo , di Jonathan Allan . (imperfetto)

----------- Explanation -----------
Ḷ            Lowered range. [0, 1, ..., n-1]
 c€Ḷ           `c`ombination `€`ach with `Ḷ`owered range [0...n-1]
    F        Flatten.
     ċ       Count the number of occurences of (n) in the list.
       ÆP    Returns 1 if (n) is a prime, 0 otherwise.
      =      Check equality.

Spiegazione per l'ultima riga:

• Come sottolineato da Martin Ender, " nappare due volte nel triangolo di Pascal" equivale a " nnon appare nelle prime n-1file".
• Vogliamo tornare truese il numero non è un numero primo (ovvero, ÆP == 0) e il conteggio cè zero. Da ciò possiamo dedurlo ÆP == c.
  Si può dimostrare che se sono uguali, allora sono uguali a 0, perché:
  • ÆP restituisce un valore booleano, che può essere solo 0 o 1.
  • Se restituisce 1, allora nè un numero primo, quindi non può apparire nelle prime n-1righe (ovvero, c == 0)

Haskell , 86 84 byte

p=[]:[zipWith(+)(1:x)x++[1]|x<-p]
f n=all((>0).rem n)[2..n-1]==any(elem n)(take n p)

Provalo online!

Spiegazione

La funzione pdefinisce ricorsivamente un triangolo degenerato di Pascal:

[]
[1]
[2,1]
[3,3,1]
[4,6,4,1]
[5,10,10,5,1]

Come possiamo vedere (in questa soluzione 1è alquanto speciale) ogni numero nappare esattamente due volte nella n+1riga th e tutti gli elementi delle righe successive diventano solo più grandi, quindi dobbiamo solo verificare se nè da qualche parte fino alla nriga th per vedere se un l'elemento è squalificato:

any(elem n)(take(n-1)p)

Ora abbiamo Trueper tutti gli elementi che appaiono più del doppio (tranne 1), quindi tutto ciò di cui abbiamo bisogno è avere una isPrimefunzione difettosa che ritorni Trueper 1:

all((>0).rem n)[2..n-1]

APL (Dyalog) , 44 34 24 19 byte

5 byte salvati grazie a @Cowsquack

(~0∊⊢|⍨2↓⍳)⍱⊢∊⍳∘.!⍳

Provalo online!

Come?

Facciamo in modo che nessuno dei due lo faccia

⍳- gamma 0.. n-1,

⍳∘.! - sul binomio cartesiano con sé

⊢∊- contenere n,

⍱- nemmeno

⊢|⍨ - n modulo ogni elemento di

2↓⍳- gamma 2..n-1

~0∊- non contenere 0(aka non divisibile)

JavaScript (Node.js) , 103 101 byte

n=>(r=x=>[...Array(n).keys(F=n=>n>0?n*F(n-1):1)].every(x))(i=>r(j=>F(i)/F(j)/F(i-j)-n))>r(i=>i<2|n%i)

Provalo online!

Rubino , ₉₇ 95 byte

->n{c=!r=[1,1]
(2...n).map{|i|c|=1>n%i
[n]&r=[0,*r,0].each_cons(2).map{|a,b|a+b}}&[[n]]==[]&&c}

Provalo online!

Rimozione di un paio di byte.

R , 55 byte

function(n)sum(!n%%1:n)>2&!n%in%outer(1:n-1,1:n,choose)

Provalo online!

sum(!n%%1:n)>2è il composto di prova e outer(1:n-1,1:n,choose)Calcola le righe 0al n-1di triangolo di Pascal, in modo da assicurarsi nnon appare lì.

05AB1E , 10 byte

ÝDδcI¢IpÌQ

Provalo online!

Spiegazione

Ý            # push range [0 ... input]
 D           # duplicate
  δc         # double vectorized command binomial
    I¢       # count occurrences of input
      Ip     # check input for primality
        Ì    # add 2
         Q   # compare for equality

Controlli che si nverificano esattamente due volte nelle prime n + 1 righe del triangolo di Pascal e non sono primi.
Il confronto funziona in quanto non ci sono numeri primi che possono verificarsi 3 volte nel triangolo.

Haskell , 90 byte

f n=2==sum[1|i<-[0..n],j<-[0..i],p[j+1..i]`div`p[1..i-j]==n,mod(p[1..n-1]^2)n<1]
p=product

Provalo online!

Pyth , 10 byte

qP_Q/s.cRU

Provalo online! oppure controlla la suite di test.

JavaScript (Node.js) , 79 133 130 128 byte

f=(n,a=[1])=>n<a.length||[...'0'.repeat(n)].filter((x,i)=>n%i<1).length>1&&a.indexOf(n)<0&&f(n,[...a.map((x,i)=>x+a[i-1]||1),1])

Provalo online!

correttore del male principale +50 byte :(

Python 2 , 105 104 byte

grazie a user202729 per -1 byte

a=q=[1];n=input();r=n<4;p=1
for i in range(2,n):q=a+map(sum,zip(q[1:],q))+a;r+=n in q;p*=n%i
print p+r<1

Provalo online!