Contando +1 primos

25

Defina que el número natural p es un primo +1 del número natural n si p es un número primo y la representación binaria estándar (es decir, sin ceros a la izquierda) de p se puede obtener sumando (es decir, anteponiendo, agregando o insertando) un solo 1 a la representación binaria estándar de n .

Por ejemplo, la representación binaria de 17 es 10001 2 . Los distintos números naturales que se pueden formar sumando un 1 a 10001 2 son 110001 2 o 49 , 101001 2 o 41 , 100101 2 o 37 , y 100011 2 o 35 .

Entre estos, 41 y 37 son números primos, entonces 17 tiene dos primos +1 .

Tarea

Escriba un programa o función que acepte un entero estrictamente positivo n como entrada e imprima o devuelva el número de primos +1 distintos de n .

La entrada y la salida deben ser un número entero o su representación de cadena decimal o unaria.

Aplican reglas estándar de código de golf .

Casos de prueba

Input:  4
Output: 0

Input:  1
Output: 1

Input:  17
Output: 2

Input:  33
Output: 3

Input:  553
Output: 4

Input:  3273
Output: 5

Input:  4145
Output: 6

Input:  4109
Output: 7

Input:  196869
Output: 8
code-golf  math  primes  binary 
— Dennis
fuente
1
¡Guay! Si tuviera tiempo esta noche me gustaría responder ahora
— anOKsquirrel

Respuestas:

5

Pyth, 20 bytes

s/LPd{mij\1c.BQ]d2hQ

Banco de pruebas

s/LPd{mij\1c.BQ]d2hQ
                        Q = eval(input())
      m           hQ    For insertion position in [0 ... Q]
            .BQ         Convert Q to binary string
           c   ]d       Chop at insertion position
        j\1             Join on '1'
       i         2      Convert to integer
     {                  Deduplicate
 /LPd                   Map each number to the number of times it occurs in its
                        prime factorization, e.g. whether or not it is prime.
s                       Sum and print.
— isaacg
fuente
1
Huh, "deduplicar" es en realidad una palabra.
— lirtosiast
8

JavaScript ES6, 141 bytes 143 147 160

Ahorra 13 bytes, gracias a @Naouak

n=>[...t=n.toString(2)].map((l,i)=>t.slice(0,v=i+1)+1+t.slice(v)).filter((l,i,a)=>a.indexOf(l)==i&&(p=(n,c)=>n%c&&c>n-2||p(n,++c))('0b'+l,2))

Método similar a mi respuesta de TeaScript, utiliza RegExp (me escuchaste bien) para verificar los números primos.

Sin golf

n=>
   [...t = n.toString(2)]                  // To binary
   .map((l,i)=>                            // Make cycles
               t.slice(0, v = i+1)
               + 1
               + t.slice(v)
   ).filter((l,i,a)=>  
                     a.indexOf(l) == i &&  // Remove Duplicates
                     (p=(n,c)=>            // Prime checking
                               n % c &&
                                 c > n - 2 ||
                                 p(n,++c)
                     )('0b'+l,2)
   ).length
— Downgoat
fuente
Creo que puedes acortar un poco la comprobación de prime como esta: en (p=(n,c)=>n%c!=0?c>=n-1?1:p(n,++c):0)('0b'+l,2)lugar de!Array(+('0b'+l)+1).join(1).match(/^1?$|^(11+?)\1+$/)
— Naouak
@Naouak ¡Impresionante que ahorra 13 bytes! :)
— Downgoat
4

Minkolang 0.11 , 54 52 bytes

n1(2*d0c`,)(0c1c$%$r2*1c*1c++1g2:d1G)rxSI1-[0g2M+]N.

Explicación

n             Get integer from input (let's call it n)
1(       )    Get the smallest power of 2 (say, k) greater than input (starting with 1)
  2*d         Multiply by 2 and duplicate
     0c`,     Copy n and see if it's greater (while loop breaks on 0)

(0c1c$%                       Copy n, copy k, and divmod (pushes n//k, n%k)
       $r                     Swap top two elements
         2*                   Multiply by 2
           1c*                Copy k and multiply
              1c+             Copy k and add
                 +            Add
                  1g2:        Get k and divide by 2
                      d1G)    Duplicate and put one copy back in its former place

rx            Reverse and dump (dumps n and top of stack is now 0)
S             Remove duplicates
I1-[     ]    Check each element for primality
    0g        Get potential prime from bottom of stack
      2M      1 if prime, 0 otherwise
        +     Add (this is why I didn't dump the left-over 0 earlier)
N.            Output as integer and stop.
— El'endia Starman
fuente
Siempre estoy emocionado de decir otra versión de Minkolang.
— Conor O'Brien
4

TeaScript , 22 bytes

x÷¿®x÷E(i¬,1)¤©d¡F(¥)n

TeaScript comienza a parecerse a APL ... Los caracteres especiales se convierten en secuencias más largas y comúnmente repetidas

Intérprete en línea, asegúrese de marcar "Las entradas son números".

Explicación && Ungolfed

xT(2)s``m(#P(xT(2)E(i+1,1),2))d()F($P)n

xT(2)      // Take input, convert to binary
s``m(#     // Loop over input

  P(         // Convert to decimal...
     xT(2)     // Input to binary
     E(i+1,1)  // Inset 1 into (above) at current index in loop
  ,2)    

)d()       // Remove duplicates
F($P)      // Filter items that aren't prime
n          // Grab length.
— Downgoat
fuente
Por cierto, son 31 bytes, usando gedit en Xubuntu
— Glen O
1
Tiene 31 bytes con codificación UTF-8, pero 22 bytes con ISO-8859-1.
— Dennis
4

Julia, 55 52 bytes

n->sum(isprime,∪(2n+(k=2.^(0:endof(bin(n))))-n%k))

k=2.^(0:endof(bin(n)))genera una matriz que contiene las potencias de 2 de 1 a la potencia más alta menor que n. 2n+k-n%kluego usa operaciones de matriz para determinar todos los posibles "números +1". ∪(equivalente a union, que hace lo mismo que uniqueen esta situación) elimina los valores repetidos. Luego sum(isprime,)cuenta el número de primos en la lista.

— Glen O
fuente
4

CJam, 26 bytes

No es un ganador, pero supera las respuestas existentes de CJam con bastante solidez y es la primera vez que uso el comando 0.6.5 e\.

1ri2b+_,{_)e\_}%_&{2bmp},,

Pruébalo aquí.

Explicación

1       e# Push a 1 (this is the 1 we'll be inserting everywhere).
ri      e# Read input and convert to integer.
2b      e# Convert to base 2.
+       e# Prepend the 1.
_,      e# Duplicate and get the number of bits N.
{       e# Map this block over i from 0 to N-1...
  _)    e#   Create a copy and increment to i+1.
  e\    e#   Swap the bits at positions i and i+1, moving the 1 one step through the array.
  _     e#   Duplicate so we keep this version on the stack.
}%
_&      e# Remove duplicates via set intersection with itself.
{       e# Filter the remaining digit lists based on this block...
  2b    e#   Convert bits back to an integer.
  mp    e#   Test for primality.
},
,       e# Get the length of the remaining list.

Una cosa que vale la pena señalar es que intercambiamos los bits en 0y 1antes de hacer la primera copia, por lo que perdemos la matriz original con el 1antepuesto al frente. Sin embargo, la entrada siempre es positiva, por lo que el dígito inicial siempre será uno. Eso significa que después de anteponer otro, la lista de dígitos siempre comenzará, por [1 1 ...]lo que el primer intercambio será no operativo en cualquier caso.

— Martin Ender
fuente
3

Mathematica, 87 bytes

Union[#~FromDigits~2&/@StringReplaceList[#~IntegerString~2,a_:>a<>"1"]]~Count~_?PrimeQ&
— LegionMammal978
fuente
3

Julia, 110 108 104 87 bytes

n->sum(i->isprime(parse(Int,i,2)),(b=bin(n);∪([b[[1:i;1;i+1:end]]for i=1:endof(b)])))

Esto crea una función sin nombre que acepta un número entero y devuelve un número entero. Para llamarlo, dale un nombre, por ejemplo f=n->....

Sin golf:

function f(n::Integer)
    # Get the binary representation of n as a string
    b = bin(n)

    # Construct an array consisting of binary strings with
    # a one prepended, appended, and each insertion
    x = [b[[1:i; 1; i+1:end]] for i = 1:endof(b)]

    # Count the number of primes
    c = sum(i -> isprime(parse(Int, i, 2)), unique(x))

    return c
end

Guardado 17 bytes gracias a Glen O!

— Alex A.
fuente
bintiene que comenzar con un 1, por lo que no necesita manejar por separado "1"b. Y cuándo i=length(b), tendrá b[i+1:end]equivalente a "", por lo que no necesita esa entrada (solo necesita manejar b=bin(n)en algún momento). Y sumhará lo mismo que countpara dos bytes menos.
— Glen O
Además, dado que va a usar un rango que se extiende sobre la longitud de btodos modos, también podría obtenerlo con un poco de truco, b=bin(n)[s=1:end]y luego for i=spara la comprensión.
— Glen O
También puede guardar otro byte utilizando el hecho de que el primer bit bindebe ser 1, y obtendrá esto: n->sum(i->isprime(parse(Int,i,2)),(b=bin(n);unique([b[[1:i;1;i+1:end]]for i=1:endof(b)])))esto reduce la cuenta a 90 bytes.
— Glen O
De hecho, elimine un byte más, reemplazándolo uniquecon union: hará lo mismo, si se le da una sola matriz como entrada. O mejor aún, en ∪lugar de union.
— Glen O
@GlenO Eres el maestro. Gracias 先生!
— Alex A.
2

CJam, 58 bytes

L{:TQ\=A+Q\+TWe\-2<s:~2b}q~2b0+:Q,(%{:BLe=!{B+:L}&}%~:mp:+

Esto me llevó un día, y esta fue mi cuarta iteración.

— anOKsquirrel
fuente
2

Japt -x , 14 11 bytes

ƤiX1Ãâ ®Íj

Pruébalo o ejecuta todos los casos de prueba

ƤiX1Ãâ ®Íj     :Implicit input of integer U
Æ               :Map each X in the range [0,U)
 ¤              :  Convert U to binary string
  iX1           :  Insert "1" at 0-based index X
     Ã          :End map
      â         :Deduplicate
        ®       :Map
         Í      :  Convert to decimal
          j     :  Is prime?
                :Implicit output of array sum
— Lanudo
fuente
1

PHP, 145 bytes

He agregado una nueva línea para facilitar la lectura:

function($n){for($b=base_convert;++$i<=strlen($s=$b($n,10,2));$r+=!$s[$i]&$k<=$j)
for($j=1;($k=$b(substr_replace($s,1,$i,0),2,10))%++$j;);echo$r;}
— Agujero negro
fuente
1

APL, 55

{+/{2=+/0=⍵|⍨⍳⍵}¨∪⍵{2⊥(⍵↑X),1,⍵↓X←⍺⊤⍨N⍴2}¨-1-⍳N←1+⌊2⍟⍵}

Versión específica de Dyalog 2 bytes más corta:

{+/2=+/¨0=|⍨∘⍳⍨¨∪⍵{2⊥⍵(↑,(1∘,↓))⍺⊤⍨N⍴2}¨-1-⍳N←1+⌊2⍟⍵}
— usuario46915
fuente
1

Matlab (120)

n=input('');a=dec2bin(n);g=arrayfun(@(x)bin2dec(cat(2,a(1:x),49,a(x+1:end))),1:log2(n));nnz(unique(g(find(isprime(g)))))
  • Más golf en progreso ...
— Abr001am
fuente
1

Brachylog , 17 bytes

{ḃ~c₂{,1}ʰc~ḃṗ}ᶜ¹

Pruébalo en línea!

Entrada a través de la variable de entrada y salida a través de la variable de salida.

{             }ᶜ¹    Count every unique
             ṗ       prime number
           ~ḃ        the binary representation of which is
 ḃ                   the binary representation of the input
  ~c₂                partitioned into two (possibly empty) lists
     {  }ʰ           with the first list
      ,1             having a 1 appended
          c          and the two lists then being concatenated back into one.
— Cadena no relacionada
fuente
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.