Сатана-Прими

хто вони?
вони Primesмістять 666
це Сатани-Прими: [46663,266677,666599,666683,616669]
це НЕ :[462667,665669,36363631,555]

Сюжет

Кожне число, що перевищує 6661, має за собою Сатани-Прими

Змагання

З огляду на ціле число n>6661знайдіть Сатану-Прем'єр за (або рівним) і найближчим до себе.

Приклади

Цілий n=30000має 3 Сатана-Primes (SP) позаду нього: [6661, 16661, 26669].
Ваш код повинен повернути те, 26669що знаходиться найближче за ним

Випробування

Вхід-> Вихід

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

Правила

Йорд-код повинен працювати для будь-якого nдіапазону вашої мови.

Це код-гольф , тому найкоротша відповідь у байтах виграє!

Математика, 82 байти

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

Нейм , 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 байт

Збережено 10% завдяки @Dennis!

Æ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 байт

Збережено 1 байт за допомогою Дейва .

Помилки пам’яті 969696та щось вище на моїй машині, але це добре, якщо їй дано достатньо пам'яті.

ef&/`T*3\6P_TS

Спробуйте тут або перевірити тестовий набір.

Як?

ef & / `T * 3 \ 6P_TSQ - Повна програма, з неявним введенням (Q) в кінці

             SQ - Діапазон [1, Q]
 f - Фільтр.
          P_T - це прем'єр?
  & - І
   / `T * 3 \ 6 - Він містить 666.
e - Останній елемент.
                - Неналежне виведення результату.

Піт , 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'

Бере аргумент командного рядка. Може бути досить повільним при більшій кількості.

Математика, 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 немає вбудованих простих факторів , тому це запозичує код з моєї відповіді на Prime Factors Buddies .

Ми беремо вхід $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 ++.)
Запустіть її з командного рядка, подаючи 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 та збільшити на два. Ви також отримаєте попередження компілятора через те, що (-1) там замість npos.

Все-таки це працює досить швидко. На моєму старому AMD Sempron 130 знадобилося лише 40 секунд, щоб знайти всі 214 сатанових праймерів під 1 000 000.

: ^ D

Пакет Bash + bsd-ігор, 33

• 2 байти збережено завдяки @FedericoPoloni.

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

Спробуйте в Інтернеті .

Python 3 , 85 83 80 байт

Халвардський на 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).

Стакс , 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 Core) , 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 байти збережено, видаливши непотрібні дужки.
• 3 байти, збережені комбінуванням intдекларацій.

Я впевнений, що це можна скоротити; можливо, шляхом рекурсивного виклику 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це викликається знову, але не рахується до байтів. Будь-яке уточнення буде вдячне.