撒旦·普里姆斯

他们是谁？
它们Primes包含666
以下内容：撒旦-总理：[46663,266677,666599,666683,616669]
这些不是：[462667,665669,36363631,555]

情节

每个大于6661的数字后面都有撒旦·普里姆斯

挑战

给定一个整数，n>6661可以找到（或相等）和自己最近的撒旦素数。

例子

整数n=30000有3撒旦素数（SP）背后：[6661, 16661, 26669]。
您的代码必须返回26669最接近它的代码

测试用例

输入->输出

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

规则

您的代码应适用于n您语言范围内的任何代码。

这是代码高尔夫球，因此最短答案以字节为单位！

Mathematica，82个字节

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

Neim，9个字节

>ͻ:D+6S𝕚÷

说明：

>         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

在线尝试！

果冻，10 9字节

@Dennis节省了10％！

ÆRwÐf666Ṫ

在线尝试！

说明

Æ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字节

在Dave的帮助下保存了1个字节。

内存错误969696以及我机器上的所有错误，但是如果有足够的内存，那很好。

ef&/`T*3\6P_TS

在这里尝试或查看测试套件。

怎么样？

ef＆/`T * 3 \ 6P_TSQ-完整程序，结尾处带有隐式输入（Q）

             SQ-范围[1，Q]
 f-过滤器。
          P_T-是素数吗？
  --并且
   /`T * 3 \ 6-包含666。
e-最后一个元素。
                -隐式输出结果。

Pyth，14个字节

ef/`T*\63fP_TS

在这里尝试！

05AB1E，11个字节

ƒNpN666å*iN

在线尝试！

Bash + Core Utils，51个 49字节

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

接受命令行参数。较大的数字可能会很慢。

Mathematica，64 62 61 53字节

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

-1个字节感谢@KellyLowder

-8个字节（哇），感谢@Notatree

说明

进行输入。在以下情况下，我们将其递减：

• 输入不是素数，或

• 输入的数字连续不包含三个6。

我们重复一遍，直到达到撒旦的盛世为止。

Perl 5，47个字节

46个字节的代码+ 1个 -p

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

在线尝试！

Japt，14个字节

õ fj w æ_sø666

测试一下

看到，因为那里是一个基于时间的50％的奖金：完成对测试用例969696在半秒下。

说明

整数的隐式输入U。

õ

从1到生成一个整数数组U。

fj

过滤器（f）素数。

w

相反。

æ_

返回1通过检查以下内容的函数时返回真实值的第一个元素（在本例中为）：

sø666

转换为字符串（s）的整数包含（ø）666。

更快的替代方法，15字节

再一次，因为原来是基于时间的奖金，所以这是一个替代方案，而且速度更快，我似乎再也无法打高尔夫了。

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

测试一下

PowerShell，128字节

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

在线尝试！

PowerShell没有内置的素数分解，因此这是从我对素数好友的回答中借用的代码。

我们接受输入$n，然后声明一个新的function f计算出输入因子的变量$a。如果输入$a为素数，则将仅返回$a。

该程序的主要部分是无限for()循环。在循环内部，我们检查$n -matches 666是否反对以及是否$n为质数（即，$n匹配的所有因子$n）。如果是的话，我们将$n在管道和上放置exit隐式输出。否则，我们递减$n--并继续循环。

Python 2中，77 76个字节

编辑： -1字节感谢@ Mr.Xcoder

运行时间慢，正在运行 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)))

在线尝试！

另一个76字节的解决方案

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

在线尝试！

使用SymPy 73字节

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

在线尝试！

PowerShell，71 69 64字节

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

在线尝试！

• 328765在我的计算机上花费了约30秒，但超过了Tio.run的60秒限制。

• 678987大约需要1.5分钟。

• 969696需要〜4.5分钟。

MATL，16个字节

ZqP"@V'666'Xf?@.

在MATL Online上尝试

说明

         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字节

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

这是一个完整的程序！
您将需要Boost进行编译。（或复制并粘贴到您最喜欢的在线C ++ shell中。）
从命令行运行它，并以n作为参数。

取消高尔夫：

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

捷径是根据随机数测试得出的。原始代码从6661开始测试可能的素数，并加​​2。您还会收到编译器警告，因为那里是（-1）而不是npos。

不过，这运行得很快。在我的旧AMD Sempron 130上，仅用了大约40秒的时间就找到了所有1,000,000以下的214撒旦素数。

：^ D

Bash + bsd游戏包，33

• @FedericoPoloni节省了2个字节。

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

在线尝试。

Python 3中，85个83 80字节

Halvard的长度缩短了4个字节，因为它是在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)))

在线尝试！

给它一些时间，由于它的O(n^2)复杂性，它非常慢。

JavaScript（ES6），55 54字节

-1个字节感谢@ThePirateBay。

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

输入大时非常慢。原始性测试改编自此代码高尔夫球答案。

时机

• 输入10000花了10秒
• 输入328765花了3分钟
• 输入678987耗时9分钟
• 输入969696耗时16分钟

测验

其中一些将使您的浏览器挂起几分钟。

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>

更快的版本，56字节

一秒钟内完成每个测试用例。

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

红宝石，67，66，58，56个字节

包含+7用于-rprime

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

它的速度非常快，可以在不到~2^52一秒钟的2^64时间内计算出价值，并且不到5分钟即可完成操作（2011 MBP，Ruby 2.3.1）。

Stax，10 个字节

ü>:Ñb/VP6─

运行并调试

说明（未包装）：

^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字节

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

在线尝试！

Perl 6、35个字节

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

在线尝试！

简单的递归解决方案。

C＃（.NET核心），117个 115 112字节

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

在线尝试！

• 删除不必要的花括号可节省2个字节。
• 通过合并int声明节省了3个字节。

我敢肯定，这可以做得更短一些。可能是通过递归调用func f并删除外部循环for。

递归方法，85字节

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

在线尝试！

我不确定由于必须设置第Func<int,int> f = null一个方法，这种方法在代码高尔夫球的范围内的适应程度如何，f因此需要再次调用，但不计入字节数。任何澄清将不胜感激。