Satan-Primes

Wer sind Sie?
sie Primesenthalten 666
diese sind Satan-Primzahlen: [46663,266677,666599,666683,616669]
diese sind NICHT :[462667,665669,36363631,555]

Handlung

Jede Zahl größer als 6661 hat Satan-Primes hinter sich

Die Herausforderung

Bei einer gegebenen Ganzzahl n>6661finden Sie den Satan-Prime hinter (oder gleich) und am nächsten zu sich.

Beispiele

Integer n=30000hat 3 Satan-Primes (SP) dahinter: [6661, 16661, 26669].
Ihr Code muss den Code zurückgeben 26669, der dahinter am nächsten liegt

Testfälle

Eingabe-> Ausgabe

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

Regeln

Ihr Code sollte für jeden nin Ihrem Sprachbereich funktionieren .

Das ist Code-Golf , also gewinnt die kürzeste Antwort in Bytes!

Mathematica, 82 Bytes

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

Neim , 9 Bytes

>ͻ:D+6S𝕚÷

Erläuterung:

>         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

Probieren Sie es online!

Gelee , 10 9 Bytes

Dank @Dennis 10% gespart!

ÆRwÐf666Ṫ

Probieren Sie es online!

Erläuterung

Æ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 bis 14 Bytes

1 Byte mit Hilfe von Dave gespeichert .

Speicherfehler für 969696und irgendetwas höheres auf meinem Computer, aber es ist in Ordnung, wenn genügend Speicher vorhanden ist.

ef&/`T*3\6P_TS

Probieren Sie es hier aus oder schauen Sie sich die Test Suite an.

Wie?

ef & / `T * 3 \ 6P_TSQ - Vollständiges Programm mit impliziter Eingabe (Q) am Ende

             SQ - Bereich [1, Q]
 f - Filter.
          P_T - Ist Primzahl?
  & - Und
   / `T * 3 \ 6 - Es enthält 666.
e - Letztes Element.
                - Das Ergebnis implizit ausgeben.

Pyth , 14 Bytes

ef/`T*\63fP_TS

Probieren Sie es hier aus!

05AB1E , 11 Bytes

ƒNpN666å*iN

Probieren Sie es online!

Bash + Core Utils, 51 49 Bytes

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

Übernimmt das Kommandozeilenargument. Kann bei größeren Zahlen recht langsam sein.

Mathematica, 64 62 61 53 Bytes

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

-1 Byte dank @KellyLowder

-8 Bytes (wow) dank @Notatree

Erläuterung

Nehmen Sie eine Eingabe. Wir dekrementieren es unter diesen Bedingungen:

• Die Eingabe ist nicht prim oder

• Die Ziffern der Eingänge enthalten nicht drei 6er hintereinander.

Wir wiederholen das, bis ein Satan-Prime erreicht ist.

Perl 5 , 47 Bytes

46 Byte Code + 1 für -p

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

Probieren Sie es online!

Japt , 14 Bytes

õ fj w æ_sø666

Probier es aus

Vorausgesetzt, es gab einen zeitabhängigen Bonus von 50%: Beendet den Testfall 969696in weniger als einer halben Sekunde.

Erläuterung

Implizite Eingabe einer Ganzzahl U.

õ

Generieren Sie ein Array von Ganzzahlen von 1bis U.

fj

Filter ( f) Primzahlen.

w

Umkehren.

æ_

Gibt das erste Element zurück, das (in diesem Fall 1) einen Wahrheitswert zurückgibt, wenn es eine Funktion durchläuft, die prüft, ob ...

sø666

Die in eine Zeichenfolge ( s) konvertierte Ganzzahl enthält ( ø) 666.

Schnellere Alternative, 15 Bytes

Da es ursprünglich einen zeitbasierten Bonus gab, ist hier wieder eine alternative und viel schnellere Lösung, die ich nicht weiter Golf spielen kann.

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

Probier es aus

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

Probieren Sie es online!

PowerShell verfügt über keine eingebauten Primfaktor-Funktionen. Dieser Code stammt also aus meiner Antwort auf Prime Factors Buddies .

Wir nehmen Input $nund deklarieren dann einen neuen function f, der die Inputfaktoren berechnet $a. Wenn der Eingang $aprim ist, wird dies nur zurückgegeben $a.

Der Hauptteil des Programms ist die for()Endlosschleife. Innerhalb der Schleife prüfen wir, ob $n -matches dagegen steht 666und ob $nes Primzahl ist (dh $nmit allen Faktoren von übereinstimmt $n). Wenn ja, platzieren wir sie $nin der Pipeline und geben sie exitimplizit aus. Ansonsten dekrementieren wir $n--die Schleife und setzen sie fort.

Python 2 , 77 76 Bytes

Edit: -1 Byte dank @ Mr.Xcoder

Langsame Laufzeit, läuft ein 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)))

Probieren Sie es online!

Eine weitere 76-Byte-Lösung

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

Probieren Sie es online!

Mit SymPy 73 Bytes

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

Probieren Sie es online!

PowerShell , 71 69 64 Byte

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

Probieren Sie es online!

• 328765 benötigt ~ 30 Sekunden auf meinem Computer, überschreitet jedoch das 60-Sekunden-Limit für Tio.run.

• 678987 dauert ca. 1,5 Minuten.

• 969696 dauert ca. 4,5 Minuten.

MATL, 16 Bytes

ZqP"@V'666'Xf?@.

Probieren Sie es bei MATL Online aus

Erläuterung

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

Dies ist ein volles Programm!
Sie benötigen Boost, um es zu kompilieren. (Oder kopieren Sie sie und fügen Sie sie in Ihre bevorzugte Online-C ++ - Shell ein.)
Führen Sie sie über die Befehlszeile aus und geben Sie n als Argument an.

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

Abkürzungen wurden in Bezug auf Zufallszahlentests vorgenommen. Der ursprüngliche Code begann mit dem Testen möglicher Primzahlen bei 6661 und wurde um zwei erhöht. Sie erhalten auch eine Compiler-Warnung, weil dort (-1) anstelle von npos steht.

Trotzdem läuft das ziemlich schnell. Bei meinem alten AMD Sempron 130 dauerte es nur etwa 40 Sekunden, um alle 214 Satan-Primzahlen unter 1.000.000 zu finden.

: ^ D

Bash + BSD-Spiele-Paket, 33

• 2 Bytes gespart dank @FedericoPoloni.

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

Probieren Sie es online aus .

Python 3 , 85 83 80 Bytes

Halvards ist 4 Bytes kürzer, weil es in Python 2 gemacht wird.

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

Probieren Sie es online!

Nehmen Sie sich etwas Zeit, es ist aufgrund seiner O(n^2)Komplexität extrem langsam .

JavaScript (ES6), 55 54 Byte

-1 Byte dank @ThePirateBay.

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

Sehr langsam mit großen Eingaben. Primalitätstest angepasst von diesem Code Golf Antwort .

Timings

• Die Eingabe 10000dauerte 10 Sekunden
• Die Eingabe 328765dauerte 3 Minuten
• Die Eingabe 678987dauerte 9 Minuten
• Die Eingabe 969696dauerte 16 Minuten

Tests

Einige davon lassen Ihren Browser für einige Minuten hängen.

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>

Schnellere Version, 56 Bytes

Beendet jeden Testfall in weniger als einer Sekunde.

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

Beinhaltet +7Bytes für-rprime

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

Es ist ziemlich schnell und berechnet Werte ~2^52in 2^64weniger als 5 Minuten (2011 MBP, Ruby 2.3.1).

Stax , 10 Bytes

ü>:Ñb/VP6─

Führen Sie es aus und debuggen Sie es

Erklärung (ausgepackt):

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

Probieren Sie es online!

Perl 6 , 35 Bytes

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

Probieren Sie es online!

Einfache rekursive Lösung.

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

Probieren Sie es online!

• Durch Entfernen unnötiger Klammern werden 2 Byte gespart.
• Durch das Kombinieren von intDeklarationen werden 3 Bytes gespart .

Ich bin sicher, dass dies kürzer gemacht werden könnte; Vielleicht durch rekursives Aufrufen func fund Entfernen der äußeren forSchleife.

Rekursiver Ansatz, 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);}

Probieren Sie es online!

Ich bin mir nicht sicher, wie gut dieser Ansatz in die Grenzen des Code-Golfs passt, weil ich den Func<int,int> f = nullersten setzen muss, und das fwird erneut aufgerufen, aber nicht zu den Bytes gezählt. Jede Klarstellung wäre dankbar.