Satan-Primes

chi sono?
essi sono Primescontenenti 666
questi sono Satana-Prime: [46663,266677,666599,666683,616669]
questi sono NOT :[462667,665669,36363631,555]

Tracciare

Ogni numero superiore a 6661 ha Satan-Primes dietro di lui

La sfida

Dato un numero intero, n>6661trova il Satan-Prime dietro (o uguale) e il più vicino a se stesso.

Esempi

Integer n=30000ha 3 Satan-Primes (SP) alle spalle: [6661, 16661, 26669].
Il codice deve restituire 26669qual è il più vicino dietro di esso

Casi test

Input-> Output

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

Regole

Il tuo codice dovrebbe funzionare per qualsiasi nnella gamma della tua lingua.

Questo è code-golf , quindi vince la risposta più breve in byte!

Mathematica, 82 byte

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

Neim , 9 byte

>ͻ:D+6S𝕚÷

Spiegazione:

>         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

Provalo online!

Gelatina , 10 9 byte

Risparmiato il 10% grazie a @Dennis!

ÆRwÐf666Ṫ

Provalo online!

Spiegazione

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

Salvato 1 byte con l'aiuto di Dave .

Errori di memoria per 969696e qualcosa di più alto sulla mia macchina, ma va bene se viene data memoria sufficiente.

ef&/`T*3\6P_TS

Provalo qui o controlla la Suite di test.

Come?

ef & / `T * 3 \ 6P_TSQ - Programma completo, con input implicito (Q) alla fine

             SQ - Range [1, Q]
 f - Filtro.
          P_T - È primo?
  & - E
   / `T * 3 \ 6 - Contiene 666.
e - Ultimo elemento.
                - Emette implicitamente il risultato.

Pyth , 14 byte

ef/`T*\63fP_TS

Provalo qui!

05AB1E , 11 byte

ƒNpN666å*iN

Provalo online!

Utilità Bash + Core, 51 49 byte

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

Accetta l'argomento della riga di comando. Può essere abbastanza lento con numeri più grandi.

Mathematica, 64 62 61 53 byte

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

-1 byte grazie a @KellyLowder

-8 byte (wow) grazie a @Notatree

Spiegazione

Prendi un input. Lo decrementiamo in queste condizioni:

• l'ingresso non è primo, OR

• le cifre degli ingressi non contengono tre 6 di fila.

Lo ripetiamo fino a raggiungere un numero primo di Satana.

Perl 5 , 47 byte

46 byte di codice + 1 per -p

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

Provalo online!

Japt , 14 byte

õ fj w æ_sø666

Provalo

Visto che non vi era un bonus a base di tempo del 50%: banco di prova completa l' 969696in meno di mezzo secondo.

Spiegazione

Input implicito di numero intero U.

õ

Genera un array di numeri interi da 1a U.

fj

I fprimi di Filter ( ).

w

Inverso.

æ_

Restituisce il primo elemento che restituisce un valore di verità (in questo caso 1) quando viene passato attraverso una funzione che controlla se ...

sø666

Il numero intero convertito in una stringa ( s) contiene ( ø) 666.

Alternativa più veloce, 15 byte

Ancora una volta, visto che in origine c'era un bonus basato sul tempo, ecco una soluzione alternativa, e molto più veloce, che non riesco più a giocare a golf.

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

Provalo

PowerShell , 128 byte

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

Provalo online!

PowerShell non ha alcun fattore di fattorizzazione principale incorporato, quindi questo prende in prestito il codice dalla mia risposta su Amici di Prime Factors .

Prendiamo input $n, quindi dichiariamo un nuovo function fche calcola i fattori di input $a. Se l'ingresso $aè primo, questo restituirà solo $a.

La parte principale del programma è il for()ciclo infinito . All'interno del ciclo, controlliamo se $n -matches è contrario 666e se $nè primo (cioè, $ncorrisponde a tutti i fattori di $n). Se lo è, posizioniamo $nsulla pipeline e exit, con output implicito. Altrimenti, diminuiamo $n--e continuiamo il ciclo.

Python 2 , 77 76 byte

Modificare: -1 byte grazie a @ Mr.Xcoder

Tempo di esecuzione lento, si avvia 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)))

Provalo online!

Un'altra soluzione da 76 byte

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

Provalo online!

Con SymPy 73 byte

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

Provalo online!

PowerShell , 71 69 64 byte

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

Provalo online!

• 328765 impiega ~ 30 secondi sulla mia macchina, ma scade il limite di 60 secondi su Tio.run.

• 678987 richiede ~ 1,5 minuti.

• 969696 richiede ~ 4.5 minuti.

MATL, 16 byte

ZqP"@V'666'Xf?@.

Provalo su MATL Online

Spiegazione

         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 byte

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

Questo è un programma completo!
Avrai bisogno di Boost per compilarlo. (O copia e incolla nella tua shell C ++ online preferita.)
Eseguilo dalla riga di comando dando n come argomento.

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

Scorciatoie sono state fatte in termini di test di numeri casuali. Il codice originale ha iniziato a testare possibili numeri primi a 6661 e incrementato di due. Riceverai anche un avviso del compilatore a causa di quello (-1) lì invece di npos.

Tuttavia, questo funziona abbastanza rapidamente. Ci sono voluti solo circa 40 secondi per trovare tutti i 214 numeri primi di satana sotto i 1.000.000 sul mio vecchio AMD Sempron 130.

: ^ D

Pacchetto Bash + bsd-games, 33

• 2 byte salvati grazie a @FedericoPoloni.

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

Provalo online .

Python 3 , 85 83 80 byte

Halvard è più corto di 4 byte perché è fatto in 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)))

Provalo online!

Dagli un po 'di tempo, è estremamente lento a causa della sua O(n^2)complessità.

JavaScript (ES6), 55 54 byte

-1 byte grazie a @ThePirateBay.

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

Molto lento con ingressi di grandi dimensioni. Test di primalità adattato da questa risposta golf di codice .

Tempi

• L'ingresso 10000ha richiesto 10 secondi
• L'input 328765ha richiesto 3 minuti
• L'input 678987ha richiesto 9 minuti
• L'input 969696ha richiesto 16 minuti

test

Alcuni di questi si bloccheranno il tuo browser per alcuni minuti.

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>

Versione più veloce, 56 byte

Completa ogni test in meno di un secondo.

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

Rubino, 67 , 66 , 58 , 56 byte

Include +7byte per-rprime

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

È piuttosto veloce, calcola i valori fino a ~2^52circa un secondo e 2^64in meno di 5 minuti (2011 MBP, Ruby 2.3.1).

Stax , 10 byte

ü>:Ñb/VP6─

Esegui ed esegui il debug

Spiegazione (non imballata):

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

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

Provalo online!

Perl 6 , 35 byte

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

Provalo online!

Soluzione ricorsiva semplice.

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

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

Provalo online!

• 2 byte salvati rimuovendo le parentesi graffe non necessarie.
• 3 byte salvati combinando le intdichiarazioni.

Sono sicuro che questo potrebbe essere abbreviato; forse chiamando in modo ricorsivo func fe rimuovendo il forloop esterno .

Approccio ricorsivo, 85 byte

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

Provalo online!

Non sono sicuro di come questo approccio rientri nei limiti del code-golf a causa della necessità di impostare il Func<int,int> f = nullprimo, e questo fviene chiamato di nuovo, ma non conteggiato per i byte. Qualsiasi chiarimento sarebbe apprezzato.