¡Ponte detrás de mí, Satan-Prime!

22

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 , por lo que gana la respuesta más corta en bytes.

Lanudo
fuente
1
definir "aproximadamente un minuto". ¿Es + - 30 segundos? Personalmente, creo que 30 minutos y un minuto no difieren mucho ... También los bonos generalmente están mal vistos ... también creo que esto podría haber sido mejor como un output the nth satan primedesafío ...
Socratic Phoenix
ok ok gente ... la bonificación se eliminará ...
Espero que no te importe la edición que hice al título del desafío.
Shaggy
3
@Shaggy ¿Para qué sirve el cambio de título ...?
Conor O'Brien
3
@ ConorO'Brien Rima y parece arcaico, supongo.
wizzwizz4

Respuestas:

7

Mathematica, 82 bytes

Last@Select[Prime@Range@PrimePi@#,!FreeQ[Subsequences[IntegerDigits@#],{6,6,6}]&]&
J42161217
fuente
Espera, ¿quieres decir que no hay un incorporado para este?
Fondo de la demanda de Mónica
7

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!

Okx
fuente
Entonces, ¿hay realmente una construcción para empujar "66 antepuesto a un dígito"? O_O Neim ha progresado.
Erik the Outgolfer
1
¿Cómo +6empuja 666? ¿O es Neim solo ese metal?
Robert Fraser
66
@RobertFraser Aparentemente +xsignifica 612 + código de caracteres de x. El código de 6pasa a ser 54, entonces 612 + 54 = 666.
fergusq
@EriktheOutgolfer Bueno, Neim puede representar los números de tres dígitos y unos cuatro dígitos usando dos bytes.
Okx
2
@EriktheOutgolfer '\+*=100,356,612,868 (más el ordinal del siguiente personaje que es)
Jonathan Allan el
7

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)
nmjcman101
fuente
Alternativa:ÆRẇ@Ðf666Ṁ
Sr. Xcoder
55
Me encanta que la Cola (justo después del 666) parezca una cruz.
kaine
44
wdebería funcionar en lugar de ẇ@.
Dennis
@Dennis s / sh / w / por supuesto que funciona: p
Erik the Outgolfer
5

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í!

Sr. Xcoder
fuente
14 bytes:ef&/`T*3\6P_TS
Dave
Agregué la Q final por error, es 14
Dave
"666"es una forma menos eficiente de describir la cadena 666 que*3\6
Dave
4

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.

markasoftware
fuente
Esto genera todos los "primos satanás" hasta 6661, pero solo debe imprimir el más cercano debajo de la entrada: pruébelo en línea . Una solución sería simplemente agregar |head -1al final.
Justin Mariner
@JustinMariner lol, whoops, lo arregló
markasoftware
4

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.

JungHwan Min
fuente
2
Muy agradable. Puedes perder uno más _ al final ya que un prime no puede terminar en 6.
Kelly Lowder
@KellyLowder buen punto
JungHwan Min
1
Esto es aún más corto con cadenas:#//.i_/;!PrimeQ@i||ToString@i~StringFreeQ~"666":>i-1&
No es un árbol
1
@Notatree wow! ¡bonito!
JungHwan Min
3

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

Lanudo
fuente
2

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.

AdmBorkBork
fuente
Recorté la versión de la mía y logré alcanzar la mitad de tu número de bytes: D - codegolf.stackexchange.com/a/140539/571
TessellatingHeckler
2

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!

Halvard Hummel
fuente
76 bytes: lambda x:max(q for q in range(x+1)if"666"in`q`*all(q%t for t in range(2,q)))- usar en max()lugar de[][-1]
Sr. Xcoder
2

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.
TessellatingHeckler
fuente
Manera inteligente de hacer los factores.
AdmBorkBork
2

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
Suever
fuente
2

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

Dúthomhas
fuente
2

Paquete Bash + bsd-games, 33

  • 2 bytes guardados gracias a @FedericoPoloni.
primes 2 $[$1+1]|grep 666|tail -1

Pruébalo en línea .

Trauma digital
fuente
Puede guardar 1 byte si reemplaza los dos últimos comandos con tail -n1.
Federico Poloni
@FedericoPoloni duh: no puedo creer que lo haya olvidado tailaquí. De hecho tail -1es incluso 1 menos.
Trauma digital
1

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.

Sr. Xcoder
fuente
1

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.

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)}`))

Justin Mariner
fuente
2
Nunca deberías hacer eso. Este es el código de golf y el rendimiento es totalmente irrelevante. Sugiero volver a su respuesta anterior de 55 bytes. Además, puede reducirlo a 54 bytes reemplazando d==1por d<2desde n>6661.
52 bytes: f=n=>/666/.test(n)&(g=d=>n%--d?g(d):d<2)(n)?n:f(n-1)pero arrojará un error de recursión para números más grandes.
Shaggy
f=n=>/666/.test(d=n)-eval("while(n%--d);d")?f(n-1):n
l4m2
1

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

Michael Klein
fuente
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
wastl
fuente
Buen programa Gracias por probar Stax. Para su información, también es posible hacer múltiples casos usando la opción "Separador" de esta manera
recursivo
@recursive ah, thx
wastl
0

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!

Mic1780
fuente
0

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.

Ayb4btu
fuente