Números de contención principales (edición de golf)


21

Esta es la secuencia A054261 .

El ésimo número de contención prime es el número más bajo que contiene los primeros números primos como subcadenas. Por ejemplo, el número es el número más bajo que contiene los primeros 3 primos como subcadenas, lo que lo convierte en el tercer número de contención de primos.nortenorte235

Es trivial descubrir que los primeros cuatro números de contención primos son , , y , pero luego se vuelve más interesante. Como el próximo número primo es 11, el siguiente número de contención primo no es , pero es ya que se define como el número más pequeño con la propiedad.2232352357235711112357

Sin embargo, el verdadero desafío llega cuando vas más allá de 11. El siguiente número de contención principal es . Tenga en cuenta que en este número, las subcadenas y se superponen. El número también se superpone con el número .1132571113313

Es fácil demostrar que esta secuencia está aumentando, ya que el siguiente número debe cumplir con todos los criterios del número anterior y tener una subcadena más. Sin embargo, la secuencia no está aumentando estrictamente, como lo demuestran los resultados para n=10y n=11.

Entrada

Un solo entero n>0(supongo que también podría tenerlo indexado en 0, luego haciendo n>=0)

Salida

O el nnúmero de contención primo th, o una lista que contiene los primeros nnúmeros de contención primos.

Los números que he encontrado hasta ahora son:

 1 =>             2
 2 =>            23
 3 =>           235
 4 =>          2357
 5 =>        112357
 6 =>        113257
 7 =>       1131725
 8 =>     113171925
 9 =>    1131719235
10 =>  113171923295
11 =>  113171923295
12 => 1131719237295

Tenga en cuenta que n = 10y n = 11son el mismo número, ya que es el número más bajo que contiene todos los números , pero también contiene .113171923295[2,3,5,7,11,13,17,19,23,29]31

Dado que este es el código de golf marcado, ¡juegue al golf! Se permiten soluciones de fuerza bruta, pero su código tiene que funcionar para cualquier entrada en teoría (lo que significa que no puede concatenar los primeros n primos). ¡Feliz golf!

Respuestas:


11

05AB1E , 8 bytes

∞.ΔIÅpåP

Pruébalo en línea!

Explicación

           # from
∞          # a list of infinite positive integers
 .Δ        # find the first which satisfies the condition:
       P   # all
   IÅp     # of the first <input> prime numbers
      å    # are contained in the number

¿El Poperador crea una asignación explícita para verificar los números primos en el número (en lugar de verificar si el número está en la matriz de números primos)? Esta es una solución hermosa, dudo que pueda hacer cualquier solución con menos comandos.
maxb

@maxb Pes producto. Básicamente, multiplica todos los valores en una lista. El Åpcreará una lista con la primera ncantidad de primos, donde nestá la entrada Ien este caso. El åcomprobará para cada número en la lista de números primos si están en el número actual de la lista infinita, donde se dará 1a Truthy y 0para Falsey-. Entonces, el producto básicamente verifica si todos son verdaderos; si todos los números primos están dentro del número actual. Si alguno es 0, los Presultados también falsey. Pero si todo es así 1, los Presultados son verdaderos y el bucle se detiene.
Kevin Cruijssen

@KevinCruijssen Ya veo, ¡gracias por la explicación!
maxb

1
Muy buena solución usando la nueva versión! Tenía 8 bytes así, pero en la versión legado de 05AB1E: 1µNIÅpåP. Para aquellos que no conocen 05AB1E, una explicación para la mía también: - hasta que la variable del contador llegue a 1 (comienza en 0, aumente Ngradualmente en 1 y realice: NIÅpåP- compruebe si aparecen todos los primeros primos <input> Ny , si es así, incremente la variable del contador automáticamente. Devuelve el valor final de N.
Mr. Xcoder

@ Mr.Xcoder: Esa fue en realidad mi primera versión también (con, en Xlugar de 1, por razones), pero cambié a esto ya que nunca tuve la oportunidad de usarla :)
Emigna

5

Jalea , 11 bytes

³ÆN€ẇ€µẠ$1#

Pruébalo en línea!

Fuerza bruta simple. No estoy completamente seguro de cómo #funciona el arity, por lo que puede haber margen de mejora.

Cómo funciona

³ÆN€ẇ€µẠ$1#    Main link. Input: Index n.
         1#    Find the first natural number N that satisfies:
³ÆN€             First n primes...
    ẇ€           ...are substrings of N
      µẠ$        All of them are true

"Arreglado bajo filtro con condición" puede funcionar en lugar de "condición verdadera para todos".
usuario202729

2
wⱮẠ¥1#ÆN€Guarda dos bytes.
Dennis

5

Java 8, 143 bytes

n->{int r=1,f=1,c,i,j,k;for(;f>0;r++)for(i=2,f=c=n;c>0;c-=j>1?1+0*(f-=(r+"").contains(j+"")?1:0):0)for(j=i++,k=2;k<j;)j=j%k++<1?0:j;return~-r;}

Pruébalo en línea.
NOTAS

  1. Tiempos de espera arriba n=7.
  2. Dado el tiempo y los recursos suficientes, solo funciona hasta un máximo n=9debido al límite de tamaño de int(máximo de 2,147,483,647).
    • Con +4 bytes cambiando el inta along , el máximo se incrementa a una salida por debajo 9,223,372,036,854,775,807(¿sobre n=20qué creo?)
    • Al usar java.math.BigIntegerel máximo se puede aumentar a cualquier tamaño (en teoría), pero será de alrededor de +200 bytes al menos debido a la verbosidad de java.math.BigIntegerlos métodos.

Explicación:

n->{                   // Method with integer as both parameter and return-type
  int r=1,             //  Result-integer, starting at 1
      f=1,             //  Flag-integer, starting at 1 as well
      c,               //  Counter-integer, starting uninitialized
      i,j,k;           //  Index integers
  for(;f>0;            //  Loop as long as the flag is not 0 yet
      r++)             //    After every iteration, increase the result by 1
    for(i=2,           //   Reset `i` to 2
        f=c=n;         //   Reset both `f` and `c` to the input `n`
        c>0;           //   Inner loop as long as the counter is not 0 yet
        c-=            //     After every iteration, decrease the counter by:
           j>1?        //      If `j` is a prime:
            1          //       Decrease the counter by 1
            +0*(f-=    //       And also decrease the flag by:
                   (r+"").contains(j+"")?
                       //        If the result `r` contains the prime `j` as substring
                    1  //         Decrease the flag by 1
                   :   //        Else:
                    0) //         Leave the flag the same
           :           //      Else:
            0)         //       Leave the counter the same
      for(j=i++,       //    Set `j` to the current `i`,
                       //    (and increase `i` by 1 afterwards with `i++`)
          k=2;         //    Set `k` to 2 (the first prime)
          k<j;)        //    Inner loop as long as `k` is smaller than `j`
        j=j%k++<1?     //     If `j` is divisible by `k`
           0           //      Set `j` to 0
          :            //     Else:
           j;          //      Leave `j` the same
                       //    (If `j` is unchanged after this inner-most loop,
                       //     it means `j` is a prime)
  return~-r;}          //  Return `r-1` as result

5

JavaScript (ES6),  105 ... 92  91 bytes

n=>(k=1,g=(s,d=k++)=>n?k%d--?g(s,d):g(d?s:s+`-!/${n--,k}/.test(n)`):eval(s+';)++n'))`for(;`

Pruébalo en línea!

¿Cómo?

norte

"-!/2/.test(n)-!/3/.test(n)-!/5/.test(n)-!/7/.test(n)-!/11/.test(n)..."

norte

eval('for(;' + <conditions> + ';)++n')

Comentado

n => (                             // main function taking n
  k = 1,                           // k = current prime candidate, initialized to 1
  g = (s,                          // g = recursive function taking the code string s
          d = k++) =>              //     and the divisor d
    n ?                            // if n is not equal to 0:
      k % d-- ?                    //   if d is not a divisor of k:
        g(s, d)                    //     recursive call to test the next divisor
      :                            //   else:
        g(                         //     recursive call with s updated and d undefined:
          d ?                      //       if d is not equal to 0 (i.e. k is composite):
            s                      //         leave s unchanged
          :                        //       else (k is prime):
            s +                    //         decrement n and add to s
            `-!/${n--,k}/.test(n)` //         the next condition based on the prime k
                                   //       the lack of 2nd argument triggers 'd = k++'
        )                          //     end of recursive call
    :                              // else (n = 0):
      eval(s + ';)++n')            //   complete and evaluate the code string
)`for(;`                           // initial call to g with s = [ "for(;" ]


4

Pyth , 14 bytes

norte>5 5

f@I`M.fP_ZQ1y`

Pruébalo en línea!

f@I`M.fP_ZQ1y`     Full program. Q is the input.
f                  Find the first positive integer that fulfils the condition.
 @I`M.fP_ZQ1y`     Filtering condition, uses T to refer to the number being tested.
     .f   Q1       Starting at 1, find the first Q positive integers (.f...Q1) that
       P_Z         Are prime.
   `M              Convert all of those primes to strings.
  I                Check whether the result is invariant (i.e. doesn't change) when...
 @          y`     Intersecting this list with the powerset of T as a string.

Pyth , 15 bytes

Ligeramente más rápido pero 1 byte más largo.

f.A/L`T`M.fP_ZQ

Pruébalo en línea!

f.A/L`T`M.fP_ZQ     Full program. Q is the input.
f                   Find the first positive integer that fulfils the condition.
 .A/L`T`M.fP_ZQ     Filtering condition, uses T to refer to the number being tested.
         .f   Q     Starting at 1, find the first Q positive integers (.f...Q) that
           P_Z      Are prime.
       `M           Convert all of those primes to strings.
 .A/L               And make sure that they all (.A) occur in (/L)...
     `T             The string representation of T.


3

Carbón , 42 bytes

≔¹ηW‹LυIθ«≦⊕η¿¬Φυ¬﹪ηκ⊞υη»≔¹ηWΦυ¬№IηIκ≦⊕ηIη

Pruébalo en línea! El enlace es a la versión detallada del código. Explicación:

≔¹ηW‹LυIθ«≦⊕η¿¬Φυ¬﹪ηκ⊞υη»

Construya los primeros nnúmeros primos por división de prueba de todos los enteros por todos los números primos encontrados previamente.

≔¹ηWΦυ¬№IηIκ≦⊕η

Recorre todos los enteros hasta encontrar uno que contenga todos los números primos como subcadenas.

Iη

Transmita el resultado a una cadena e imprima implícitamente.

La velocidad del programa se puede duplicar a un costo de un byte reemplazando el último ≦⊕ηcon, ≦⁺²ηpero aún es demasiado lento para calcular n>6.


3

Perl 6 , 63 59 bytes

-4 bytes gracias a nwellnhof

{+(1...->\a{!grep {a~~!/$^b/},(grep &is-prime,2..*)[^$_]})}

Pruébalo en línea!

Una solución de fuerza bruta que agota el tiempo en TIO para números superiores a 5, pero estoy bastante seguro de que funciona correctamente. Encuentra el primer número positivo que contiene los primeros nnúmeros primos. Aquí hay una solución que no se agota n=6.

Explicación:

{                                                             } # Anonymous code block
 first                                                    2..*  # Find the first number
       ->\a{                                            }       # Where:
            !grep     # None of
                                                   [^$_]  # The first n
                              (grep &is-prime,2..*)       # primes
                  {a~~!/$^b/},   # Are not in the current number

¿Tiene alguna forma de verificar la salida para números más grandes o agregar una explicación? No soy fluido en Perl, y ciertamente no soy fluido en golf-Perl. Tengo un tiempo de espera en TIO para la entrada 5, por lo que realmente no puedo verificar que no solo concatene primos.
maxb

@maxb He agregado un enlace a una solución que genera los números primos de antemano en lugar de repetidamente y una explicación.
Jo King


2

Python 2 , 91 bytes

n=input();l=[]
P=k=1
while~-all(`x`in`k`for x in(l+[l])[:n]):P*=k*k;k+=1;l+=P%k*[k]
print k

Pruébalo en línea!


Si no supiera que su código generó números primos, nunca habría podido descubrir que lo hizo. ¡Gran trabajo!
maxb

2

SAS, 149 bytes

data p;input n;z:i=1;a=0;v+1;do while(a<n);i+1;do j=2 to i while(mod(i,j));end;if j=i then do;a+1;if find(cat(v),cat(i))=0 then goto z;end;end;cards; 

La entrada se ingresa después de la cards;declaración, así:

data p;input n;z:i=1;a=0;v+1;do while(a<n);i+1;do j=2 to i while(mod(i,j));end;if j=i then do;a+1;if find(cat(v),cat(i))=0 then goto z;end;end;cards; 
1
2
3
4
5
6
7

Da salida a un conjunto de datos p , con el resultado v, con una fila de salida para cada valor de entrada. Técnicamente debería funcionar para todos los casos de prueba dados (el número entero máximo con precisión total en SAS es 9,007,199,254,740,992), pero me di por vencido después de dejarlo pensar durante 5 minutos en n = 8.

Explicación:

data p;
input n; /* Read a line of input */

z: /* Jump label (not proud of this) */
    i=1; /* i is the current value which we are checking for primality */
    a=0; /* a is the number of primes we've found so far */
    v+1; /* v is the final output value which we'll look for substrings in */ 

    do while(a<n); /* Loop until we find the Nth prime */
        i+1; 
        do j=2 to i while(mod(i,j));end; /* Prime sieve: If mod(i,j) != 0 for all j = 2 to i, then i is prime. This could be faster by only looping to sqrt(i), but would take more bytes */
        if j=i then do; /* If i is prime (ie, we made it to the end of the prime sieve)... */
            a+1;
            if find(cat(v),cat(i))=0 then goto z; /* If i does not appear as a substring of v, then start all over again with the next v */
        end;
    end;

/* Input values, separated by newlines */
cards; 
1
2
3
4
5
6
7

1

Haskell , 102 bytes

import Data.List
f n|x<-[2..n*n]=[a|a<-[2..],all(`isInfixOf`show a).take n$show<$>x\\((*)<$>x<*>x)]!!0

Pruébalo en línea!

Explicación / Ungolfed

Como ya hemos Data.Listimportado, también podríamos usarlo: en lugar de lo viejo take n[p|p<-[2..],all((>0).mod p)[2..p-1]], podemos usar otra forma de generar todos los números primos que necesitamos. Es decir, generamos una cantidad suficiente de compuestos y los utilizamos junto con (\\):

[2..n*n] \\ ( (*) <$> [2..n*n] <*> [2..n*n] )

Usar n*nbasta porqueπ(norte)<norte2Iniciar sesión(norte2). El resto es solo una simple lista de comprensión:

[ a | a <- [2..], all (`isInfixOf` show a) . take n $ enoughPrimes ] !!0

1

Japt, 20 18 bytes

Lejos de mi mejor trabajo, estaba feliz de hacerlo funcionar después del día que tuve. ¡Estoy seguro de que terminaré golpeándolo en el alcohol más tarde!

_õ fj ¯U e!øZs}aUÄ

Pruébelo : tarda 13 segundos en ejecutarse para una entrada de 7, arroja un tambaleante después de eso (la versión actualizada es una mierda 5para mí, pero ese podría ser mi teléfono).


@ Oliver, Hmm ... yo también. Definitivamente estaba funcionando cuando lo publiqué. Acabo de ejecutar una prueba usando F.h()solo y parece estar roto; ETH debe haber cambiado algo.
Shaggy

@Oliver, no, la última confirmación fue hace 2 días, así que nada ha cambiado desde que publiqué esto. ¡Extraño!
Shaggy

¡Está funcionando ahora! ¯ \ _ (ツ) _ / ¯
Oliver

@ Oliver, todavía no funciona para mí. Más raro y más raro!
Shaggy

Ha estado funcionando para mí desde que pasé de la computadora de mi trabajo a la computadora de mi casa. Extraño de verdad!
Oliver
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.