Satanás-Primes

quem são eles?
eles estão Primescontendo 666
estes são Satanás-Primes: [46663,266677,666599,666683,616669]
estes NÃO são :[462667,665669,36363631,555]

Enredo

Todo número maior que 6661 tem Satanás-Primes atrás dele

O desafio

Dado um número inteiro, n>6661encontre o Satan-Prime atrás (ou igual) e mais próximo de si.

Exemplos

Integer n=30000tem 3 Satan-Primes (SP) por trás dele: [6661, 16661, 26669].
Seu código deve retornar 26669qual é o mais próximo por trás dele

Casos de teste

Entrada-> Saída

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

Regras

Seu código deve funcionar para qualquer um nno intervalo do seu idioma.

Isso é código-golfe , então a resposta mais curta em bytes vence!

Mathematica, 82 bytes

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

Neim , 9 bytes

>ͻ:D+6S𝕚÷

Explicação:

>         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

Experimente online!

Geléia , 10 9 bytes

Economize 10% graças a @Dennis!

ÆRwÐf666Ṫ

Experimente online!

Explicação

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

Pitão , 15 14 bytes

Guardou 1 byte com a ajuda de Dave .

Erros de memória 969696e qualquer coisa maior na minha máquina, mas tudo bem se receber memória suficiente.

ef&/`T*3\6P_TS

Experimente aqui ou confira o Conjunto de Testes.

Quão?

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

             SQ - Intervalo [1, Q]
 f - filtro.
          P_T - É primo?
  & - E
   / `T * 3 \ 6 - Contém 666.
e - último elemento.
                - Saída implícita do resultado.

Pitão , 14 bytes

ef/`T*\63fP_TS

Experimente aqui!

05AB1E , 11 bytes

ƒNpN666å*iN

Experimente online!

Bash + Core Utils, 51 49 bytes

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

Leva argumento de linha de comando. Pode ser bastante lento com números maiores.

Mathematica, 64 62 61 53 bytes

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

-1 byte graças a @KellyLowder

-8 bytes (uau) graças a @Notatree

Explicação

Pegue uma entrada. Nós o diminuímos sob estas condições:

• a entrada não é primária, OU

• os dígitos das entradas não contêm três 6s seguidos.

Repetimos isso até que um primo de Satanás seja alcançado.

Perl 5 , 47 bytes

46 bytes de código + 1 para -p

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

Experimente online!

Japonês , 14 bytes

õ fj w æ_sø666

Teste-o

Visto que não era um bónus baseado no tempo de 50%: caso teste é concluído 969696em menos de meio segundo.

Explicação

Entrada implícita de número inteiro U.

õ

Gere uma matriz de números inteiros de 1até U.

fj

O filtro ( f) inicia.

w

Marcha ré.

æ_

Retorne o primeiro elemento que retorna um valor de verdade (neste caso 1) quando passado por uma função que verifica se ...

sø666

O número inteiro convertido em uma string ( s) contém ( ø) 666.

Alternativa mais rápida, 15 bytes

Novamente, visto que havia originalmente um bônus baseado no tempo, aqui está uma solução alternativa e muito mais rápida, que eu não consigo mais jogar golfe.

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

Teste-o

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

Experimente online!

O PowerShell não possui nenhum fator de fatoração principal incorporado, portanto, isso empresta o código da minha resposta no Prime Factors Buddies .

Tomamos informações $ne declaramos uma nova function fque calcula os fatores de entrada$a . Se a entrada $afor prime, isso retornará apenas $a.

A parte principal do programa é o for()loop infinito . Dentro do loop, verificamos se $n -matches contra 666e se $né primo (ou seja, $ncorresponde a todos os fatores de $n). Se for, colocamos $nno pipeline e exit, com saída implícita. Caso contrário, decrementamos $n--e continuamos o loop.

Python 2 , 77 76 bytes

Edit: -1 byte graças a @ Mr.Xcoder

Tempo de execução lento, é executado em 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)))

Experimente online!

Outra solução 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))

Experimente online!

Com o SymPy 73 bytes

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

Experimente online!

PowerShell , 71 69 64 bytes

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

Experimente online!

• 328765 leva ~ 30 segundos na minha máquina, mas atinge o tempo limite de 60 segundos no Tio.run.

• 678987 leva ~ 1,5 minutos.

• 969696 leva ~ 4,5 minutos.

MATL, 16 bytes

ZqP"@V'666'Xf?@.

Experimente no MATL Online

Explicação

         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

Bytes C ++ 389

#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 é um programa completo!
Você precisará do Boost para compilá-lo. (Ou copie e cole no seu shell C ++ online favorito.)
Execute-o na linha de comando, fornecendo n como argumento.

Ungolfed:

#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 << " ";
}

Atalhos foram feitos em termos de teste de número aleatório. O código original começou a testar possíveis números primos em 6661 e aumentou em dois. Você também receberá um aviso do compilador por causa disso (-1), em vez de npos.

Ainda assim, isso é executado rapidamente. Foram necessários apenas 40 segundos para encontrar todos os 214 satan primos abaixo de 1.000.000 no meu antigo AMD Sempron 130.

: ^ D

Pacote Bash + bsd-games, 33

• 2 bytes salvos graças a @FedericoPoloni.

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

Experimente online .

Python 3 , 85 83 80 bytes

O de Halvard é 4 bytes mais curto porque é feito em 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)))

Experimente online!

Reserve um tempo, é extremamente lento devido à sua O(n^2)complexidade.

JavaScript (ES6), 55 54 bytes

-1 byte graças a @ThePirateBay.

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

Muito lento com entradas grandes. Teste de primazia adaptado a partir deste código resposta de golfe .

Horários

• A entrada 10000levou 10 segundos
• A entrada 328765levou 3 minutos
• A entrada 678987levou 9 minutos
• A entrada 969696levou 16 minutos

Testes

Alguns deles travarão o navegador por vários 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>

Versão mais rápida, 56 bytes

Conclui cada caso de teste em menos de um 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

Inclui +7bytes para-rprime

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

É muito rápido, computando valores de até ~2^52um segundo e 2^64em menos de 5 minutos (2011 MBP, Ruby 2.3.1).

Stax , 10 bytes

ü>:Ñb/VP6─

Execute e depure

Explicação (sem embalagem):

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

Experimente online!

Perl 6 , 35 bytes

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

Experimente online!

Solução recursiva direta.

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

Experimente online!

• 2 bytes salvos removendo chaves desnecessárias.
• 3 bytes salvos combinando intdeclarações.

Tenho certeza de que isso poderia ser reduzido; talvez chamando func fe removendo recursivamente o forloop externo .

Abordagem recursiva, 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);}

Experimente online!

Não tenho certeza de quão bem essa abordagem se encaixa nos limites do código-golfe devido à necessidade de definir a Func<int,int> f = nullprimeira, e isso fé chamado novamente, mas não é contabilizado em bytes. Qualquer esclarecimento seria apreciado.