Satan-Primes

qui sont-ils?
ils Primescontiennent 666
ce sont des Satan-Primes: [46663,266677,666599,666683,616669]
ce ne sont PAS :[462667,665669,36363631,555]

Terrain

Chaque nombre supérieur à 6661 a Satan-Primes derrière lui

Le défi

Étant donné un entier, n>6661trouvez le Satan-Prime derrière (ou égal) et le plus proche de lui-même.

Exemples

Entier n=30000a 3 Satan nombres premiers (SP) derrière: [6661, 16661, 26669].
Votre code doit renvoyer celui 26669qui est le plus proche derrière lui

Cas de test

Entrée-> Sortie

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

Règles

Votre code devrait fonctionner pour n'importe qui ndans la gamme de votre langue.

C'est le code-golf , donc la réponse la plus courte en octets l'emporte!

Mathematica, 82 octets

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

Neim , 9 octets

>ͻ:D+6S𝕚÷

Explication:

>         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

Essayez-le en ligne!

Gelée , 10 9 octets

Économisez 10% grâce à @Dennis!

ÆRwÐf666Ṫ

Essayez-le en ligne!

Explication

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

1 octet enregistré avec l'aide de Dave .

Erreurs de mémoire 969696et quelque chose de plus élevé sur ma machine, mais c'est bien si on lui donne suffisamment de mémoire.

ef&/`T*3\6P_TS

Essayez-le ici ou consultez la suite de tests.

Comment?

ef & / `T * 3 \ 6P_TSQ - Programme complet, avec entrée implicite (Q) à la fin

             SQ - Plage [1, Q]
 f - Filtre.
          P_T - Est premier?
  & - Et
   / `T * 3 \ 6 - Il contient 666.
e - Dernier élément.
                - Sortie implicite du résultat.

Pyth , 14 octets

ef/`T*\63fP_TS

Essayez-le ici!

05AB1E , 11 octets

ƒNpN666å*iN

Essayez-le en ligne!

Bash + Core Utils, 51 49 octets

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

Prend l'argument de ligne de commande. Peut être assez lent avec de plus grands nombres.

Mathematica, 64 62 61 53 octets

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

-1 octet grâce à @KellyLowder

-8 octets (wow) grâce à @Notatree

Explication

Prenez une entrée. Nous le décrémentons dans ces conditions:

• l'entrée n'est pas principale, OU

• les chiffres des entrées ne contiennent pas trois 6 de suite.

Nous répétons cela jusqu'à ce qu'un Satan prime soit atteint.

Perl 5 , 47 octets

46 octets de code + 1 pour -p

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

Essayez-le en ligne!

Japt , 14 octets

õ fj w æ_sø666

Essaye-le

Étant donné qu'il y avait un bonus basé sur le temps de 50%: Complète le cas de test 969696en moins d'une demi-seconde.

Explication

Saisie implicite d'entier U.

õ

Générez un tableau d'entiers de 1à U.

fj

Filter ( f) amorce.

w

Sens inverse.

æ_

Retourne le premier élément qui retourne une valeur véridique (dans ce cas 1) lorsqu'il est passé par une fonction qui vérifie si ...

sø666

L'entier converti en chaîne ( s) contient ( ø) 666.

Alternative plus rapide, 15 octets

Encore une fois, vu qu'il y avait à l'origine un bonus basé sur le temps, voici une solution alternative et beaucoup plus rapide que je n'arrive pas à jouer plus loin.

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

Essaye-le

PowerShell , 128 octets

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

Essayez-le en ligne!

PowerShell n'a pas de facteurs de factorisation principaux intégrés, donc cela emprunte le code de ma réponse sur Prime Factors Buddies .

Nous prenons l'entrée $n, puis déclarons un nouveau function fqui calcule les facteurs d'entrée $a. Si l'entrée $aest principale, alors cela reviendra juste $a.

La partie principale du programme est la for()boucle infinie . À l'intérieur de la boucle, nous vérifions si $n -matches est contre 666et s'il $nest premier (c'est-à-dire s'il $ncorrespond à tous les facteurs de $n). Si c'est le cas, nous plaçons $nsur le pipeline et exit, avec une sortie implicite. Sinon, nous décrémentons $n--et continuons la boucle.

Python 2 , 77 76 octets

Edit: -1 octet grâce à @ Mr.Xcoder

Temps de fonctionnement lent, fonctionne 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)))

Essayez-le en ligne!

Une autre solution de 76 octets

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

Essayez-le en ligne!

Avec SymPy 73 octets

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

Essayez-le en ligne!

PowerShell , 71 69 64 octets

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

Essayez-le en ligne!

• 328765 prend ~ 30 secondes sur ma machine, mais expire la limite de 60 secondes sur Tio.run.

• 678987 prend ~ 1,5 minutes.

• 969696 prend environ 4,5 minutes.

MATL, 16 octets

ZqP"@V'666'Xf?@.

Essayez-le sur MATL Online

Explication

         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 octets

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

Ceci est un programme complet!
Vous aurez besoin de Boost pour le compiler. (Ou copiez et collez dans votre shell C ++ en ligne préféré.)
Exécutez-le à partir de la ligne de commande en donnant n comme argument.

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

Des raccourcis ont été effectués en termes de tests de nombres aléatoires. Le code d'origine a commencé à tester des nombres premiers possibles à 6661 et incrémenté de deux. Vous obtiendrez également un avertissement du compilateur à cause de cela (-1) au lieu de npos.

Pourtant, cela fonctionne assez rapidement. Il n'a fallu que 40 secondes environ pour trouver les 214 nombres premiers satan inférieurs à 1000000 sur mon ancien AMD Sempron 130.

: ^ D

Forfait Bash + BSD-Games, 33

• 2 octets enregistrés grâce à @FedericoPoloni.

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

Essayez-le en ligne .

Python 3 , 85 83 80 octets

Halvard est plus court de 4 octets car il est fait 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)))

Essayez-le en ligne!

Donnez-lui un peu de temps, c'est extrêmement lent à cause de sa O(n^2)complexité.

JavaScript (ES6), 55 54 octets

-1 octet grâce à @ThePirateBay.

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

Très lent avec de grandes entrées. Test de primauté adapté de ce code de réponse golf .

Timings

• Contribution 10000 pris 10 secondes
• Contribution 328765 pris 3 minutes
• Contribution 678987 pris 9 minutes
• Contribution 969696 pris 16 minutes

Les tests

Certains d'entre eux bloquent votre navigateur pendant plusieurs minutes.

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>

Version plus rapide, 56 octets

Complète chaque cas de test en moins d'une seconde.

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 octets

Comprend des +7octets pour-rprime

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

C'est assez rapide, calculer des valeurs jusqu'à ~2^52environ une seconde et 2^64en moins de 5 minutes (2011 MBP, Ruby 2.3.1).

Stax , 10 octets

ü>:Ñb/VP6─

Exécuter et déboguer

Explication (déballé):

^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 octets

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

Essayez-le en ligne!

Perl 6 , 35 octets

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

Essayez-le en ligne!

Solution récursive simple.

C # (.NET de base) , 117 115 112 octets

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

Essayez-le en ligne!

• 2 octets enregistrés en supprimant les accolades inutiles.
• 3 octets enregistrés en combinant les intdéclarations.

Je suis sûr que cela pourrait être raccourci; peut-être en appelant func fet en retirant récursivement l'extérieurfor boucle .

Approche récursive, 85 octets

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

Essayez-le en ligne!

Je ne sais pas dans quelle mesure cette approche s'inscrit dans les limites du code-golf en raison de la nécessité de définir le Func<int,int> f = nullpremier, et cela fest appelé à nouveau, mais pas compté dans les octets. Toute clarification serait appréciée.