Satanás Primes

¿Quienes son?
que se Primescontienen 666
estos son Satanás-Primes: [46663,266677,666599,666683,616669]
estos son NO :[462667,665669,36363631,555]

Trama

Cada número mayor que 6661 tiene Satan-Primes detrás

El reto

Dado un número entero, n>6661encuentra a Satan-Prime detrás (o igual) y más cerca de sí mismo.

Ejemplos

Número entero n=30000tiene 3 Satanás-Primes (SP) detrás de él: [6661, 16661, 26669].
Su código debe devolver 26669cuál es el más cercano detrás de él

Casos de prueba

Entrada-> Salida

6662->6661    
10000->6661    
66697->66697 (a SP returns himself)  
328765->326663  
678987->676661
969696->966677

Reglas

Su código debería funcionar para cualquiera nen el rango de su idioma.

Este es el código de golf , por lo que gana la respuesta más corta en bytes.

Mathematica, 82 bytes

Last@Select[Prime@Range@PrimePi@#,!FreeQ[Subsequences[IntegerDigits@#],{6,6,6}]&]&

Neim , 9 bytes

>ͻ:D+6S𝕚÷

Explicación:

>         Increment input
 ͻ        Start infinite loop
  :        Previous prime
   D       Duplicate
    +6     Push 666
      S    Swap
       𝕚   See if 666 is a substring of the top of the stack
        ÷  If true, break

Pruébalo en línea!

Jalea , 10 9 bytes

¡Ahorrado 10% gracias a @Dennis!

ÆRwÐf666Ṫ

Pruébalo en línea!

Explicación

ÆR          # All primes in range [2, input]
   Ðf      # Keep those which satisfy
  w        # truthy if y is in x
     666   #           ^ (this is y)
        Ṫ  # Tail (take the last element)

Pyth , 15 14 bytes

Guardado 1 byte con la ayuda de Dave .

Errores de memoria para 969696y cualquier cosa superior en mi máquina, pero está bien si se le da suficiente memoria.

ef&/`T*3\6P_TS

Pruébalo aquí o echa un vistazo a Test Suite.

¿Cómo?

ef & / `T * 3 \ 6P_TSQ - Programa completo, con entrada implícita (Q) al final

             SQ - Rango [1, Q]
 f - Filtro.
          P_T - ¿Es primo?
  & - Y
   / `T * 3 \ 6 - Contiene 666.
e - Último elemento.
                - Salida implícita del resultado.

Pyth , 14 bytes

ef/`T*\63fP_TS

Pruébalo aquí!

05AB1E , 11 bytes

ƒNpN666å*iN

Pruébalo en línea!

Bash + Core Utils, 51 49 bytes

seq $1|tac|factor|awk 'NF==2&&/666/&&!a--&&$0=$2'

Toma el argumento de la línea de comando. Puede ser bastante lento con números más grandes.

Mathematica, 64 62 61 53 bytes

#//.i_/;!PrimeQ@i||ToString@i~StringFreeQ~"666":>i-1&

-1 byte gracias a @KellyLowder

-8 bytes (wow) gracias a @Notatree

Explicación

Toma una entrada. Lo decrementamos bajo estas condiciones:

• la entrada no es primo, O

• Los dígitos de las entradas no contienen tres 6s seguidos.

Repetimos eso hasta que se alcance un primer Satanás.

Perl 5 , 47 bytes

46 bytes de código + 1 para -p

{$f=0|sqrt;1while$_%$f--;/666/*!$f||$_--*redo}

Pruébalo en línea!

Japt , 14 bytes

õ fj w æ_sø666

Pruébalo

En vista de que no era un bono basado en el tiempo 50%: caso de prueba finaliza969696 en menos de medio segundo.

Explicación

Entrada implícita de entero U.

õ

Genere una matriz de enteros de 1a U.

fj

Filtrar ( f) primos.

w

Marcha atrás.

æ_

Devuelve el primer elemento que devuelve un valor verdadero (en este caso 1) cuando se pasa por una función que comprueba si ...

sø666

El entero convertido en una cadena ( s) contiene ( ø) 666.

Alternativa más rápida, 15 bytes

Una vez más, ya que originalmente había un bono basado en el tiempo, aquí hay una solución alternativa y mucho más rápida, que parece que no puedo seguir jugando.

U-@j *U´sø666}a

Pruébalo

PowerShell , 128 bytes

param($n)function f($a){for($i=2;$a-gt1){if(!($a%$i)){$i;$a/=$i}else{$i++}}}for(){if($n-match666-and($n-eq(f $n))){$n;exit}$n--}

Pruébalo en línea!

PowerShell no tiene incorporados factores de factorización primarios, por lo que toma prestado el código de mi respuesta en Prime Factors Buddies .

Tomamos información $n, luego declaramos una nueva function fque calcula los factores de entrada $a. Si la entrada $aes primo, esto devolverá solo$a .

La parte principal del programa es el for()bucle infinito . Dentro del ciclo, verificamos si $n -matches contra 666y si $nes primo (es decir, $ncoincide con todos los factores de $n). Si es así, lo colocamos $nen la tubería y exit, con salida implícita. De lo contrario, disminuimos $n--y continuamos el ciclo.

Python 2 , 77 76 bytes

Editar: -1 byte gracias a @ Mr.Xcoder

Tiempo de ejecución lento, corre en O(n^2)

lambda x:max(q for q in range(x+1)if"666"in`q`*all(q%t for t in range(2,q)))

Pruébalo en línea!

Otra solución de 76 bytes

lambda x:max(q*("666"in`q`*all(q%t for t in range(2,q)))for q in range(x+1))

Pruébalo en línea!

Con SymPy 73 bytes

lambda x:max(q for q in primerange(0,x+1)if"666"in`q`)
from sympy import*

Pruébalo en línea!

PowerShell , 71 69 64 bytes

param($s)for(;$s-notmatch666-or(2..($s/2)|?{!($s%$_)});$s--){}$s

Pruébalo en línea!

• 328765 tarda ~ 30 segundos en mi máquina, pero agota el límite de 60 segundos en Tio.run.

• 678987 toma ~ 1.5 minutos.

• 969696 toma ~ 4.5 minutos.

MATL, 16 bytes

ZqP"@V'666'Xf?@.

Pruébalo en MATL Online

Explicación

         Implicitly grab input (n)
Zq       Compute the primes up to n (output is in increasing order)
P        Flip the array (so larger primes come first)
"        For each prime
  @V     Convert it to a string
  '666'  Push the string literal '666' to the stack
  Xf     Find the location of '666' in the prime
  ?      If it was present...
    @.   Push it to the stack and break
         Implicitly display the stack contents

C ++ 389 bytes

#include <iostream>
#include <boost/multiprecision/cpp_int.hpp>
#include <boost/multiprecision/miller_rabin.hpp>
using namespace boost::random;typedef boost::multiprecision::cpp_int Z;int main(int,char**v){mt19937 m(clock());independent_bits_engine<mt11213b,256,Z>g(m);Z n{v[1]},p;while(p++<=n)if(miller_rabin_test(p,25,g)&&p.convert_to<std::string>().find( "666" )!=-1)std::cout<<p<<" ";}

Este es un programa completo!
Necesitarás Boost para compilarlo. (O copie y pegue en su shell favorito de C ++ en línea).
Ejecútelo desde la línea de comandos dando n como argumento.

Sin golf:

#include <iostream>
#include <boost/multiprecision/cpp_int.hpp>
#include <boost/multiprecision/miller_rabin.hpp>
using namespace boost::random;

typedef boost::multiprecision::cpp_int integer;

int main( int argc, char** argv )
{
  mt19937 mt( clock() );
  independent_bits_engine <mt11213b, 256, integer> rng( mt );

  integer input {argv[ 1 ]};
  integer possible;

  while (possible++ <= input)
    if (
      // is_prime( possible )
      miller_rabin_test( possible, 25, rng )
    && 
      // possible has "666" in it
      (possible.convert_to <std::string> ().find( "666" ) != std::string::npos))

    std::cout << possible << " ";
}

Los atajos se hicieron en términos de pruebas de números aleatorios. El código original comenzó a probar posibles primos en 6661 y se incrementó en dos. También recibirá una advertencia del compilador debido a eso (-1) allí en lugar de npos.

Aún así, esto funciona bastante rápido. Solo me llevó unos 40 segundos encontrar los 214 primos de Satanás por debajo de 1,000,000 en mi viejo AMD Sempron 130.

: ^ D

Paquete Bash + bsd-games, 33

• 2 bytes guardados gracias a @FedericoPoloni.

primes 2 $[$1+1]|grep 666|tail -1

Pruébalo en línea .

Python 3 , 85 83 80 bytes

Halvard es 4 bytes más corto porque se hace en Python 2.

lambda k:max(x for x in range(k+1)if"666"in str(x)*all(x%i for i in range(2,x)))

Pruébalo en línea!

Dale algo de tiempo, es extremadamente lento debido a su O(n^2)complejidad.

JavaScript (ES6), 55 54 bytes

-1 byte gracias a @ThePirateBay.

f=n=>/666/.test(d=n)&eval("while(n%--d);d<2")?n:f(n-1)

Muy lento con grandes entradas. Prueba de primaria adaptada de esta respuesta de golf de código .

Tiempos

• Entrada 10000 tomó 10 segundos
• Entrada 328765 tomó 3 minutos
• Entrada 678987 tomó 9 minutos
• La entrada 969696tomó 16 minutos

Pruebas

Algunos de estos colgarán su navegador por varios minutos.

f=n=>/666/.test(d=n)&eval("while(n%--d);d<2")?n:f(n-1)

function test(n) {
  O.value="Working..."
  setTimeout(_=>{
    let t = Date.now()
    O.value=`f(${n}) = ${f(n)} in ${(Date.now()-t)/1000}s`
  }, 10)
}

Tests<br>
<button onclick="test(6662)">6662</button>
<button onclick="test(10000)">10000</button>
<button onclick="test(328765)">328765</button>
<button onclick="test(678987)">678987</button>
<button onclick="test(969696)">6662</button><br>
Result<br>
<input id=O type=text size=25 readonly>

Versión más rápida, 56 bytes

Completa cada caso de prueba en menos de un segundo.

f=n=>/666/.test(n)&&eval("for(d=2;n%d++;);d>n")?n:f(n-1)

;[6662, 10000, 328765, 678987, 969696].forEach(n=>console.log(`f(${n}) -> ${f(n)}`))

Ruby, 67 , 66 , 58 , 56 bytes

Incluye +7bytes para-rprime

->z{z.downto(1).find{|x|/666/=~x.to_s&&x.prime?}}

Es bastante rápido, calcula valores ~2^52en aproximadamente un segundo y 2^64en menos de 5 minutos (2011 MBP, Ruby 2.3.1).

Stax , 10 bytes

ü>:Ñb/VP6─

Ejecutar y depurarlo

Explicación (sin embalaje):

^w:pc$666$#! Full program, implicit input-parsing
^            Increment input
 w           do-while:
  :p           Previous prime
    c$         Copy and stringify
      666$     Push "666"
          #    Number of occurences
           !   Logical not
             Implicit output

PHP , 148 bytes

<?php $p=[2];$s=[];for($i=3;$i<=$argv[1];$i++){foreach($p as $q)if($i%$q===0)continue 2;$p[]=$i;if(strpos($i,'666')!==false)$s[]=$i;}echo end($s);?>

Pruébalo en línea!

Perl 6 , 35 bytes

my&f={/666/&&.is-prime??$_!!f $_-1}

Pruébalo en línea!

Solución recursiva directa.

C # (.NET Core) , 117 115 112 bytes

f=>{for(int i=f;i>1;i--){int p=1,j=2;while(j<i)if(i%j++<1)p=0;if(p>0&$"{i}".Contains("666"))return i;}return 0;}

Pruébalo en línea!

• 2 bytes guardados al eliminar llaves innecesarias.
• 3 bytes guardados combinando intdeclaraciones.

Estoy seguro de que esto podría hacerse más corto; tal vez llamando func fy retirando recursivamente el exteriorfor bucle .

Enfoque recursivo, 85 bytes

i=>{int p=1,j=2;while(j<i)if(i%j++<1)p=0;return p>0&$"{i}".Contains("666")?i:f(--i);}

Pruébalo en línea!

No estoy seguro de qué tan bien se ajusta este enfoque dentro de los límites del golf de código debido a tener que establecer el Func<int,int> f = nullprimero, y eso fse llama nuevamente, pero no se cuenta para los bytes. Cualquier aclaración sería apreciada.