Introducción

Invertir y agregar es tan simple como parece, toma n y agregarlo a sus dígitos en orden inverso. (por ejemplo, 234 + 432 = 666).

Si aplica este proceso repetidamente, algunos números finalmente alcanzarán un número primo, y algunos nunca llegarán a un primo.

Ejemplo

Actualmente tengo

11431 rep.

11431 is not prime
11431 + 13411 = 24842 which is not prime
24842 + 24842 = 49684 which is not prime
49684 + 48694 = 98378 which is not prime
98378 + 87389 = 185767 which is prime!

Este número alcanza un primer

En contraste, cualquier múltiplo de 3 nunca alcanzará un primo, esto se debe a que todos los múltiplos de 3 tienen una suma de dígitos que es un múltiplo de 3 y viceversa. Por lo tanto, invertir y agregar un múltiplo de 3 siempre dará como resultado un nuevo múltiplo de 3 y, por lo tanto, nunca un primo.

Tarea

Toma un entero positivo n y determine si invertir y sumar repetidamente resultará en un número primo. Salida de un valor verdadero o falso. O la verdad para alcanza un valor primo y falso para no, o al revés, ambas son aceptables.

Se considerará que los números primos alcanzan un número primo en cero iteraciones.

Esto es código golf así que trate de hacer su código lo más corto posible.

Casos de prueba

Verdadero para alcanza una prima falsa para nunca alcanza una prima

11 -> True
11431 -> True
13201 -> True
13360 -> True
13450 -> True
1019410 -> True
1019510 -> True
22 -> False
1431 -> False
15621 -> False
14641 -> False

Insinuación

Mientras escribía este desafío descubrí un truco genial que hace que este problema sea mucho más fácil. No es imposible sin este truco y tampoco es trivial, pero ayuda. Me divertí mucho descubriendo esto, así que lo dejaré en un spoiler a continuación.

Repetir y agregar repetidamente siempre alcanzará un múltiplo de 11 en 6 iteraciones o menos. Si no alcanza un primo antes de alcanzar un múltiplo de 11, nunca alcanzará un primo.

Ruby , 84 79 77 74 bytes

->x{y=1;x+="#{x}".reverse.to_i while(2...x).any?{|z|0==y=x%z}&&x%11>0;y>0}

Pruébalo en línea!

Si acerté, cuando alcanzamos un múltiplo de 11 podemos detenernos (solo obtendremos múltiplos de 11 después de eso)

Haskell , 65 bytes

ftoma un Integery devuelve un Bool. Truesignifica que alcanza una prima.

f n=gcd(product[2..n-1])n<2||gcd 33n<2&&f(n+read(reverse$show n))

Pruébalo en línea!

Desafortunadamente, la prueba principal corta pero ineficiente significa que los Truecasos de prueba del OP que no sean 11demasiado grandes para terminar. Pero, por ejemplo, 11432 es un Truecaso que termina.

También puede probar este 3 bytes más largo, para lo cual TIO puede finalizar todos los Truecasos de prueba:

f n=and[mod n i>0|i<-[2..n-1]]||gcd 33n<2&&f(n+read(reverse$show n))

Pruébalo en línea!

Las pruebas principales de ambas versiones se rompen en 1, pero sucede que de todos modos llega a un número primo (2).

De lo contrario, noté lo mismo que GB en el spoiler de la presentación de Ruby:

Una vez que un número crece a una longitud par, la siguiente iteración será divisible por 11. Una vez que un número sea divisible por 11, también lo serán las siguientes iteraciones.

Python 2, 123110 bytes

¡Ahorró 13 bytes gracias a Ørjan Johansen y Wheat Wizard !

n=input()
while 1:
 if all(n%m for m in range(2,n)):print 1;break
 if n%11==0:print 0;break
 n+=int(`n`[::-1])

Devuelve 1 si alcanza un primo, 0 si no lo hace. Pruébalo en línea!

Python 2 , 78 70 69 bytes

f=lambda x:all(x%a for a in range(2,x))or x%11and f(x+int(`x`[::-1]))

Pruébalo en línea!

Explicación

Este programa se basa en el hecho de que

Cada número que pierda para siempre alcanzará un múltiplo de 11 en menos de 6 movimientos.

Este programa es un lambda recursivo con comparativas lógicas en circuito. Primero verifica si n es primo.

all(x%a for a in range(2,x))

Si esto es cierto, volveremos cierto.

Si es falso, verificamos si es un múltiplo de 11.

x%11

Si es falso, devolvemos falso; de lo contrario, devolvemos el resultado de fla próxima iteración.

f(x+int(`x`[::-1]))

Jalea , 11 bytes

ṚḌ$+$6СÆPS

Pruébalo en línea!

05AB1E , 14 13 bytes

EDITAR : se guardó un byte porque la entrada se reutiliza si no hay suficientes elementos en la pila

[Dp#D11Ö#R+]p

Pruébalo en línea!

Utiliza la pista en la pregunta

Cómo funciona

[              # begin infinite loop
               # implicit input
 D             # duplicate input
  p            # push primality of input
   #           # if prime, break
    D          # duplicate input
     11        # push 11
       Ö       # push input % 11 == 0
        #      # if multiple of 11, break
               # implicit push input
          R    # reverse input
           +   # add both numbers
            ]  # end infinite loop
             p # push primality of result; 1 if prime, 0 if multiple of 11
               # implicit print

MATLAB, 88 81 bytes

function r=f(n);r=0;for i=1:7 r=r+isprime(n);n=n+str2num(fliplr(num2str(n)));end;

JavaScript (ES6), 73 bytes

Devoluciones 0o true.

f=n=>{for(d=n;n%--d;);return d<2||n%11&&f(+[...n+''].reverse().join``+n)}

Comentado

Esto se basa en la fórmula de spoiler mágico descrita por Wheat Wizard.

f = n => {              // given n:
  for(d = n; n % --d;); // find the highest divisor d of n
  return                //
    d < 2 ||            // if this divisor is 1, return true (n is prime)
    n % 11 &&           // else: if 11 is a divisor of n, return 0
    f(                  // else: do a recursive call with
      +[...n + '']      // the digits of n
      .reverse().join`` // reversed, joined,
      + n               // coerced to a number and added to n
    )                   //
}                       //

Casos de prueba

He eliminado las dos entradas más grandes del fragmento, ya que tardan unos segundos en completarse. (Pero también funcionan).

f=n=>{for(d=n;n%--d;);return d<2||n%11&&f(+[...n+''].reverse().join``+n)}

console.log(f(11))      // -> True
console.log(f(11431))   // -> True
console.log(f(13201))   // -> True
console.log(f(13360))   // -> True
console.log(f(13450))   // -> True
console.log(f(22))      // -> False
console.log(f(1431))    // -> False
console.log(f(15621))   // -> False
console.log(f(14641))   // -> False

Mathematica, 45 bytes

Or@@PrimeQ@NestList[#+IntegerReverse@#&,#,6]&

Servidor SQL de Microsoft, 826 786 * bytes

* He recordado sobre la función IIF que se introdujo en Microsoft Sql Server 2012

set nocount on
use rextester
go
if object_id('dbo.n','IF')is not null drop function dbo.n
go
create function dbo.n(@ bigint,@f bigint)returns table as return
with a as(select 0 c union all select 0),b as(select 0 c from a,a t),c as(select 0 c from b,b t),
d as(select 0 c from c,c t),e as(select 0 c from d,d t),f as(select 0 c from e,e t),
v as(select top(@f-@+1)0 c from f)select row_number()over(order by(select 0))+@-1 n from v
go
with u as(select cast(a as bigint)a from(values(11),(11431),(13201),(13360),(13450),(1019410),(1019510),(22),(1431),
(15621),(14641))u(a)),v as(select a,a c from u union all select a,c+reverse(str(c,38))from v
where 0=any(select c%n from dbo.n(2,c/2))and c%11>0)select a,iif(0=any(select max(c)%n from dbo.n(2,max(c)/2)),0,1)
from v group by a option(maxrecursion 0)

Compruébalo en línea

El formato más ordenado

SET NOCOUNT ON;
USE rextester;
GO
IF OBJECT_ID('dbo.n', 'IF') IS NOT NULL DROP FUNCTION dbo.n;
GO
CREATE FUNCTION dbo.n(@ BIGINT,@f BIGINT)RETURNS TABLE AS RETURN
  WITH
    a AS(SELECT 0 c UNION ALL SELECT 0),
    b AS(SELECT 0 c FROM a,a t),
    c AS(SELECT 0 c FROM b,b t),
    d AS(SELECT 0 c FROM c,c t),
    e AS(SELECT 0 c FROM d,d t),
    f AS(SELECT 0 c FROM e,e t),
    v AS(SELECT TOP(@f-@+1)0 c FROM f)
    SELECT ROW_NUMBER()OVER(ORDER BY(SELECT 0))+@-1 n FROM v;
GO
WITH u AS(
  SELECT CAST(a AS BIGINT) a
  FROM(VALUES (11), (11431), (13201), (13360), (13450), (1019410), (1019510),
              (22), (1431), (15621), (14641)) u(a)
),
v AS(
  SELECT a, a c FROM u
    UNION ALL
  SELECT a, c + reverse(str(c, 38))
  FROM v
  WHERE 0 = ANY(SELECT c % n FROM dbo.n(2, c / 2)) AND c % 11 > 0
)
SELECT a, IIF(0 = ANY(SELECT MAX(c) % n FROM dbo.n(2, MAX(c) / 2)), 0, 1)
FROM v
GROUP BY a
OPTION (MAXRECURSION 0);

Jalea , 9 bytes

ṚḌ+Ɗ6СẒẸ

Pruébalo en línea!

Cómo funciona

ṚḌ+Ɗ6СẒẸ    Monadic main link.
ṚḌ+Ɗ         Monad: Reverse and add to original.
    6С      Repeatedly apply the above 6 times, collecting all iterations
       ẒẸ    Is any of them a prime?

PHP 114 bytes

<?php function f($n){$n1=strrev((string)$n);$r=$n+(int)$n1;for($i=2;$i<$r;$i++){if($r%$i==0){die('0');}}die('1');}

Versión más legible:

<?php function f($n)
{
    $n1 = strrev((string)$n);
    $r = $n + (int)$n1;
    for ($i = 2; $i < $r; $i++) {
        if ($r % $i == 0) {
            die('0');
        }
    }
    die('1');
}

f(11431 );

Pruébalo en línea!

Usé esto para contar bytes.