Estoy hablando de esta pregunta , échale un vistazo si estás un poco confundido.

Tarea principal

Su tarea es generar enteros concatenados, en orden decreciente, pero aumentando el número entero máximo cada vez que golpea 1 (para esta pregunta, 1 se considerará un número primo) . Si bien esto no suena diferente de la primera pregunta, aquí viene la parte difícil: todos los números generados solo pueden ser primos . Estos se unirán en una sola cadena sin espacios ni líneas nuevas. Su entrada también será un número primo .

Ejemplo:

1
21
321
5321
75321
1175321
Valid output:
1213215321753211175321

Entrada

Su código solo puede tomar una entrada: el primo más alto que se imprimirá. Esta entrada puede provenir de cualquier parte (gráfica, STDIN). Tiene la seguridad de que la entrada es un número primo.

Salida

Tendrá que dar salida al número resultante. Puede obtener este número haciendo una cuenta regresiva, solo cuente el número si es primo, luego conecte todos los resultados a un número. El último número "fila" (por ejemplo 7, 5, 3, 2, 1) debe imprimirse completamente. El resultado puede ser cualquier cosa (números, cadenas, gráficos), siempre que sea legible. Se aplica el mismo patrón Regex para verificar sus casos de prueba:

^(\D*(\d)+\D*|)$

Si su salida no coincide con este patrón, su código no es válido.

Reglas

• Se asegura que la entrada sea primordial, no incluya manejo de errores, a menos que lo desee / necesite.
• La salida solo puede ser un número completamente conectado, por lo tanto, no dividido por nada, ni siquiera por líneas nuevas.
• Su algoritmo no debe comprobar si la primera instancia de Naparecer (por ejemplo, el 17de 1175321), sino más bien para la primera instancia de Nque el número real.
• Su entrada está asegurada para ser positiva, no agregue manejo a menos que desee / necesite.

Casos de prueba

Input: -2, 0
Output: Any, or none (number isn't positive)

Input: 9
Output: Any, or none (number isn't prime)

Input: 1
Output: 1

Input: 7
Output: 121321532175321

Input: 23
Output: 1213215321753211175321131175321171311753211917131175321231917131175321

Ganador

Este es el código de golf , por lo que gana el autor del código con la menor longitud en bytes.

Jalea , 9 bytes

ÆR1;;\UFV

Pruébalo en línea!

Cómo funciona

ÆR1;;\UFV  Main link. Argument: n

ÆR         Prime range; yield all primes up to n.
  1;       Prepend the "prime" 1.
    ;\     Cumulative concatenation; yield all prefixes of the prime range.
      U    Upend; reverse each prefix.
       F   Flatten the resulting 2D array.
        V  Eval. This casts the integer array to string first, thus concatenating
           the integers.

Procesamiento, 161 bytes

int p(int n){for(int k=1;++k<=sqrt(n);)if(n%k<1)return 0;return 1;}void t(int n){for(int i=1,j;i<=n;i++){if(p(i)<1)continue;for(j=i;j>0;j--)print(p(j)<1?"":j);}}

Una función realiza la comprobación de primalidad, la otra realiza la impresión. Llámalo port(7)

Sin golf

La primera función hace la comprobación de primalidad. Devuelve un en intlugar de un booleanya que de esta manera se guardan más bytes. (en intlugar de boolean, en 0lugar de false, en 1lugar de true)

int Q103891p(int n){
  for(int k=1;++k<=sqrt(n);)
    if(n%k<1)return 0;
  return 1;
}

La segunda función imprime la cadena. Se itera a través de cada número, si no es primo, salte a la siguiente iteración. Si es un primo, continúa hasta la impresión dentro de otro forbucle. Nuevamente, si el número es primo, lo imprimimos, de lo contrario no.

void Q103891(int n){
  for(int i=1,j;i<=n;i++){
    if(p(i)<1)continue;
    for(j=i;j>0;j--)
      print(p(j)<1?"":j);
  }
}

Jalea , 12 bytes

ÆR;@1
ÇÇ€UVV

Pruébalo en línea!

Si no hubiera sido por 1s, mi código solo habría sido ÆRÆRUVVpor 7 bytes.

Explicación mejorada:

ÇÇ€UVV Main link. Arguments: z.
Ç      Run link1 on z.
 ǀ    Run link1 on z's elements.
   U   Reverse z's elements.
    V  Flatten z.
     V Concatenate z's elements.

ÆR;@1 Link 1. Arguments: z.
ÆR    Range of primes [2..z].
    1 Integer: 1.
  ;@  Concatenate x to y.

El tipo irlandés (llamado Dennis?) De alguna manera me superó jajaja.

05AB1E , 19 bytes

LDpÏX¸ì€Lí˜ÐXQsp+ÏJ

Pruébalo en línea!

Explicación

L                     # range [1 ... input]
 DpÏ                  # keep only primes
    X¸ì               # prepend a 1
       €L             # map: range [1 ... n]
         í            # reverse each sublist
          ˜           # flatten list to 1D
           Ð          # triplicate
            XQ        # check elements in one copy for equality with 1
              sp      # check elements in one copy for primality
                +     # add the above lists giving a list with true values at indices
                      # comtaining 1 or a prime
                 Ï    # keep only those elements of the unmodified copy of the list
                  J   # join

Brachylog , 17 bytes

y:{e1|e#p}f@[rcw\

Pruébalo en línea!

Parece que no puede acortarse más que eso ...

Explicación

y                      The list [0, ..., Input]
 :{      }f            Find all...
   e1                     ...elements that are 1 (there is 1)...
     |                    ...or...
      e#p                 ...elements that are prime...
           @[          Take a prefix of the result
             rc        Reverse it and concatenate it into a number
               w       Write to STDOUT
                  \    Backtrack: try another prefix

GameMaker Language, 169 bytes

Función principal (68 bytes)

b=""for(i=1;i<=argument0;i++){c=i while(j)b+=string(p(c--))}return b

Función p (46 bytes)

for(a=0;a<argument0;a++)while q(++b){}return b

Función q (55 bytes)

n=argument0 for(i=2;i<n;i++)if!(n mod i)p=1return p|n=1

MATL , 15 bytes

Zq"1@ZqP]1v!VXz

Pruébalo en línea!

Zq      % Implicit input. Push array of primes up to that value
"       % For each prime in that array
  1     %   Push 1
  @     %   Push current prime
  Zq    %   Push array of primes up to that
  P     %   Reverse
]       % End
1       % Push 1
&h      % Concatenate all stack horizontally
V       % Convert to string
Xz      % Remove spaces. Implicit display

Perl 6 , 41 bytes

{[~] flat [\R,] 1,|grep *.is-prime,2..$_}

( Pruébelo en línea )

Explicación:

• 1, |grep(*.is-prime, 2..$_): Secuencia de 1 y primos ... (1 2 3 5)
• [,] ...: Reducir ("doblar") sobre el operador de coma ... (1 2 3 5)
• [\,] ...: Con resultados intermedios ( reducción triangular ) ...((1) (1 2) (1 2 3) (1 2 3 5))
• [\R,] ...: Aplicar el metaoperador de inversión a la coma ...((1) (2 1) (3 2 1) (5 3 2 1))
• [~] flat ...: Eliminar el anidamiento de la lista y doblar sobre el operador de cadena concat 1213215321

(Esto se basa en mi respuesta para el desafío anterior ).

Mathematica, 61 bytes

ToString/@(1<>Prime@Range[Range@PrimePi@#,0,-1]/.Prime@0->1)&

Función sin nombre que toma un argumento entero y devuelve una cadena. (Si la entrada no es un primo, simplemente lo "redondea" al primo más cercano; si la entrada no es positiva, pretende que es 1.)

Esta implementación utiliza el truco desagradable de la respuesta de Martin Ender al desafío anterior similar (¿quién dice que este viejo perro no puede aprender nuevos trucos?): Abusar <>de aplanar una lista anidada de enteros.

La lista anidada en cuestión comienza generando una lista anidada similar a la de esa respuesta, con la longitud apropiada (dada por PrimePi@#el número de primos hasta e incluyendo la entrada); entonces Primese aplica a cada elemento. Por ejemplo, para la entrada 5que es el 3er primo, el código Range[Range@PrimePi@#,0,-1]rinde {{1,0},{2,1,0},{3,2,1,0}}, y la aplicación Primea cada elemento rinde {{2,Prime[0]},{3,2,Prime[0]},{5,3,2,Prime[0]}}ya que el 1er, 2do y 3er primos son 2, 3 y 5, respectivamente. Me siento orgulloso de haber logrado agregar aún más errores al enfoque de Martin Ender: Mathematica se queja cada vez que escribe Prime[0].

Prime[0]no es una cosa, pero está bien: los /.Prime@0->1convierte a todos en 1s. Y también queremos un 1frente, por lo que reemplazamos el ""de la respuesta de Martin Ender con simplemente 1, lo que realmente ahorra un byte.

PHP, 72 bytes

for(;$n<$argv[1];print$s=$n.$s)for($i=2;$i>1;)for($i=++$n;--$i&&$n%$i;);

Corre ingenio -r

Descompostura

for(;$n<$argv[1];               // loop $n up to argument:
    print$s=$n.$s)                  // 2. prepend $n to $s, print $s
    for($i=2;$i>1;)                 // 1. find next prime: break if $i<2
        for($i=++$n;--$i&&$n%$i;);      // if $n is prime, $i is 1 after loop (0 for $n=1)

Pyth - 12 bytes

jkf!tPTs}R1S

Test Suite .