Intro

Invertire e aggiungere è semplice come sembra, prendere ne aggiungerlo alle sue cifre in ordine inverso. (es. 234 + 432 = 666).

Se si applica questo processo ripetutamente, alcuni numeri colpiranno un numero primo e alcuni non raggiungeranno mai un numero primo.

Esempio

Ho attualmente

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!

Questo numero raggiunge un numero primo

Al contrario, qualsiasi multiplo di 3 non raggiungerà mai un numero primo, questo perché tutti i multipli di 3 hanno una somma di cifre che è un multiplo di 3 e viceversa. Pertanto, invertire e aggiungere un multiplo di 3 si tradurrà sempre in un nuovo multiplo di 3 e quindi mai un numero primo.

Compito

Prendi un numero intero positivo ne determina se invertire e aggiungere ripetutamente comporterà mai un numero primo. Emette un valore di verità o falsa. O verità per raggiungere un valore primo e falsa per non o viceversa entrambi sono accettabili.

Si considererà che i numeri primi raggiungano un numero primo in zero iterazioni.

Questo è code-golf quindi cerca di rendere il tuo codice il più breve possibile.

Casi test

Vero per raggiunge un primo falso per non raggiunge mai un primo

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

Suggerimento

Mentre stavo scrivendo questa sfida, ho scoperto un bel trucco che rende questo problema molto più semplice. Non è impossibile senza questo trucco e non è nemmeno banale, ma aiuta. Mi sono divertito molto a scoprirlo, quindi lo lascerò in uno spoiler qui sotto.

La ripetizione inversa e l'aggiunta colpiranno sempre un multiplo di 11 in 6 iterazioni o meno. Se non raggiunge un numero primo prima di un multiplo di 11, non colpirà mai un numero primo.

Rubino , 84 79 77 74 byte

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

Provalo online!

Se ho capito bene, quando raggiungiamo un multiplo di 11 possiamo fermarci (dopo di che otterremo solo multipli di 11)

Haskell , 65 byte

fprende un Integere restituisce un Bool. Truesignifica che raggiunge un numero primo.

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

Provalo online!

Sfortunatamente il primo ma breve test inefficiente significa che i Truecasi di test dell'OP oltre a 11diventare troppo grandi per finire. Ma per esempio 11432 è un Truecaso che finisce.

Puoi anche provare questo più lungo di 3 byte, per il quale TIO può completare tutti i Truecasi di test:

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

Provalo online!

I test primi di entrambe le versioni si interrompono su 1, ma succede che arrivi comunque a un primo (2).

Altrimenti, ho notato la stessa cosa di GB nello spoiler della presentazione di Ruby:

Una volta che un numero aumenta in modo uniforme, la successiva iterazione sarà divisibile per 11. Una volta che un numero è divisibile per 11, lo saranno anche tutte le successive iterazioni.

Python 2, 123 110 byte

Risparmiato 13 byte grazie 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])

Restituisce 1 se raggiunge un numero primo, 0 se non lo fa. Provalo online!

Python 2 , 78 70 69 byte

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

Provalo online!

Spiegazione

Questo programma si basa sul fatto che

Ogni numero che perde per sempre raggiungerà un multiplo di 11 in meno di 6 mosse

Questo programma è un lambda ricorsivo con comparativi logici circoncisi. Prima controlla se n è primo.

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

Se questo è vero, torniamo veri.

Se è falso controlliamo se è un multiplo di 11.

x%11

Se false restituiamo false, altrimenti restituiamo il risultato della fsuccessiva iterazione

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

Gelatina , 11 byte

ṚḌ$+$6СÆPS

Provalo online!

05AB1E , 14 13 byte

EDIT : salvato un byte perché l'input viene riutilizzato se non ci sono abbastanza elementi nello stack

[Dp#D11Ö#R+]p

Provalo online!

Usa il suggerimento nella domanda

Come funziona

[              # 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 byte

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

JavaScript (ES6), 73 byte

Restituisce 0o true.

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

Commentate

Questo si basa sulla formula dello spoiler magico descritta da 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
    )                   //
}                       //

Casi test

Ho rimosso i due input più grandi dallo snippet, poiché richiedono alcuni secondi per il completamento. (Ma funzionano anche loro.)

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 byte

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

Microsoft Sql Server, 826 786 * byte

* Ho ricordato la funzione IIF introdotta in 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)

Controllalo online

La formattazione più accurata

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

Gelatina , 9 byte

ṚḌ+Ɗ6СẒẸ

Provalo online!

Come funziona

ṚḌ+Ɗ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 byte

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

Versione più leggibile:

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

Provalo online!

Ho usato questa cosa per contare i byte.