Introdução

Inverter e adicionar é tão simples quanto parece, pegue ne adicione aos seus dígitos na ordem inversa. (por exemplo, 234 + 432 = 666).

Se você aplicar esse processo repetidamente, alguns números atingirão um número primo e outros nunca atingirão um primo.

Exemplo

Eu tenho atualmente

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 atinge um primo

Por outro lado, qualquer múltiplo de 3 nunca alcançará um primo, porque todos os múltiplos de 3 têm uma soma de dígitos que é um múltiplo de 3 e vice-versa. Portanto, reverter e adicionar um múltiplo de 3 sempre resultará em um novo múltiplo de 3 e, portanto, nunca será um primo.

Tarefa

Pegue um número inteiro positivo ne determine se a inversão e a adição repetidas resultarão em um número primo. Emita um valor verdadeiro ou falso. Qualquer verdade para atinge um valor primo e falso para não, ou o contrário é aceitável.

Os números primos serão considerados como atingindo um número primo em zero iterações.

Isso é código-golfe, então tente fazer o seu código o mais curto possível.

Casos de teste

Verdadeiro para atinge um primo falso para nunca atinge um primo

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

Sugestão

Enquanto escrevia esse desafio, descobri um truque interessante que facilita muito esse problema. Não é impossível sem esse truque e também não é trivial, mas ajuda. Eu me diverti muito descobrindo isso, então deixarei em um spoiler abaixo.

A reversão e adição repetidas sempre atingem um múltiplo de 11 em 6 iterações ou menos. Se não atingir um primo antes de atingir um múltiplo de 11, nunca atingirá um 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}

Experimente online!

Se eu acertar, quando atingirmos um múltiplo de 11, podemos parar (só obteremos múltiplos de 11 depois disso)

Haskell , 65 bytes

fpega um Integere retorna um Bool. Truesignifica que atinge um nível máximo.

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

Experimente online!

Infelizmente, o teste inicial curto, mas ineficiente, significa que os Truecasos de teste do OP, que não 11são grandes demais para serem finalizados. Mas, por exemplo, 11432 é um Truecaso que termina.

Você também pode tentar este com mais três bytes, para o qual o TIO pode concluir todos os Truecasos de teste:

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

Experimente online!

Os testes principais das duas versões quebram em 1, mas acontece que chega a um prime (2) de qualquer maneira.

Caso contrário, notei a mesma coisa que GB no spoiler da submissão do Ruby:

Uma vez que um número cresça no mesmo comprimento, a próxima iteração será divisível por 11. Quando um número for divisível por 11, o mesmo ocorrerá com todas as iterações seguintes.

Python 2, 123 110 bytes

Economizou 13 bytes graças a Ørjan Johansen e 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])

Retorna 1 se atingir um prime, 0 se não atingir. Experimente online!

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]))

Experimente online!

Explicação

Este programa baseia-se no fato de que

Todo número dessa perda para sempre atingirá um múltiplo de 11 em menos de 6 movimentos

Este programa é um lambda recursivo com comparativos lógicos em circuitos. Ele primeiro verifica se n é primo.

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

Se isso é verdade, retornamos verdadeiro.

Se for falso, verificamos se é um múltiplo de 11.

x%11

Se false, retornamos false, caso contrário, retornamos o resultado de fna próxima iteração

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

Gelatina , 11 bytes

ṚḌ$+$6СÆPS

Experimente online!

05AB1E , 14 13 bytes

EDIT : salvou um byte porque a entrada é reutilizada se não houver elementos suficientes na pilha

[Dp#D11Ö#R+]p

Experimente online!

Usa a dica na pergunta

Como 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

Retorna 0ou true.

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

Comentado

Isso é baseado na fórmula do spoiler mágico descrita pelo 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 teste

Eu removi as duas maiores entradas do snippet, pois elas levam alguns segundos para serem concluídas. (Mas eles também funcionam.)

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]&

Microsoft Sql Server, 826 786 * bytes

* Lembrei-me da função IIF que foi introduzida no 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)

Verifique on-line

A formatação mais elegante

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);

Geléia , 9 bytes

ṚḌ+Ɗ6СẒẸ

Experimente online!

Como 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');}

Versão mais legível:

<?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 );

Experimente online!

Eu usei isso para contar bytes.