शैतान-Primes

वे कौन है?
वे कर रहे हैं Primesजिसमें 666
इन शैतान-Primes हैं: [46663,266677,666599,666683,616669]
ये हैं नहीं :[462667,665669,36363631,555]

भूखंड

6661 से बड़ी हर संख्या में उसके पीछे शैतान-प्राइम हैं

चुनौती

पूर्णांक को देखते हुए n>6661शैतान-प्राइम को (या बराबर) पीछे पाया जाता है और खुद के सबसे करीब होता है।

उदाहरण

इंटेगर के n=30000पीछे 3 शैतान-प्राइम्स (एसपी) हैं [6661, 16661, 26669]:।
आपके कोड को वापस लौटना चाहिए 26669जो इसके पीछे निकटतम है

परीक्षण के मामलों

इनपुट-> आउटपुट

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

नियम

योर कोड nआपकी भाषा की सीमा में किसी भी कार्य के लिए होना चाहिए ।

यह कोड-गोल्फ है , इसलिए बाइट्स में सबसे कम जवाब जीतता है!

code-golf primes

— झबरा
स्रोत

1

परिभाषित "एक मिनट के बारे में।" क्या यह + - 30 सेकंड है? मैं व्यक्तिगत रूप से लगता है कि 30 मिनट और एक मिनट कि ज्यादा ... इसके अलावा बोनस आम तौर पर सिकोड़ी रहे हैं भिन्न नहीं हैं पर ... भी मुझे लगता है कि यह हो सकता है बेहतर एक के रूप में किया गया है output the nth satan primeचुनौती ...

— सुकराती फीनिक्स

ओके ओके लोग ... बोनस निकाला जाएगा ...

आशा है कि आप चुनौती शीर्षक के लिए किए गए संपादन को बुरा नहीं मानते।

— झबरा

3

@ शिग्गी शीर्षक किस बिंदु पर सेवा करता है ...?

— कॉनर ओ'ब्रायन

3

@ ConorO'Brien Rhyming और दिखने में पुरातन, मुझे लगता है।

— wizzwizz4

7

गणितज्ञ, 82 बाइट्स

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

— J42161217
स्रोत

रुको, तुम्हारा मतलब है कि इस के लिए एक अंतर्निहित नहीं है?

— निधि मोनिका का मुकदमा

7

नीम , 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

इसे ऑनलाइन आज़माएं!

— Okx
स्रोत

तो वास्तव में "66 अंक के लिए तैयार" को आगे बढ़ाने के लिए एक बेसिन है? O_O नीम आगे बढ़ चुका है।

— आउटगॉल्फ

1

+6666 पुश कैसे करता है ? या नीम सिर्फ उस धातु है?

— राबर्ट फ्रेजर

6

@RobertFraser का +xअर्थ है 612 + वर्ण कोड x। होने का कोड 654 है, इसलिए 612 + 54 = 666 है।

— फर्ग्यूस्क

@EriktheOutgolfer खैर, नीम सभी तीन अंकों की संख्या और दो बाइट्स का उपयोग करके कुछ चार अंकों का प्रतिनिधित्व कर सकता है।

— ओकेक्स

2

@EriktheOutgolfer '\+*=100,356,612,868 (निम्नलिखित चार वर्णों का क्रम है)

— जोनाथन एलन

7

जेली , 10 9 बाइट्स

@ डेनिस के लिए 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)

— nmjcman101
स्रोत

वैकल्पिक:ÆRẇ@Ðf666Ṁ

— श्री एक्सकोडर

5

मुझे प्यार है कि टेल (666 के ठीक बाद) एक क्रॉस की तरह दिखता है।

— Kaine

4

wके बजाय काम करना चाहिए ẇ@।

— डेनिस

@ डेनिस एस / श / डब्ल्यू / निश्चित रूप से यह काम करता है: पी

— एरिक आउटगोल्फर

5

अजगर , 15 14 बाइट्स

डेव की मदद से 1 बाइट बचाया ।

969696मेरी मशीन पर मेमोरी त्रुटियां और कुछ भी अधिक हैं, लेकिन यह पर्याप्त है अगर इसे पर्याप्त मेमोरी दी जाए।

ef&/`T*3\6P_TS

इसे यहाँ आज़माएँ या टेस्ट सूट देखें।

कैसे?

अंत में निहित इनपुट (क्यू) के साथ एफई एंड / `टी * 3 \ 6 पी_टीएसक्यू - पूर्ण कार्यक्रम

             SQ - रेंज [1, Q]
 च - फ़िल्टर।
          P_T - प्रधान है?
  & - तथा
   / `टी * 3 \ 6 - इसमें 666 शामिल हैं।
ई - अंतिम तत्व।
                - परिणाम को तुरंत लागू करें।

अजगर , 14 बाइट्स

ef/`T*\63fP_TS

यहाँ कोशिश करो!

— श्री Xcoder
स्रोत

14 बाइट्स:ef&/`T*3\6P_TS

— डेव

मैंने गलती से समाप्त होने वाले क्यू को जोड़ा, इसकी 14

— डेव

"666"स्ट्रिंग 666 का वर्णन करने के लिए एक कम कुशल तरीका है कि*3\6

— डेव

4

05AB1E , 11 बाइट्स

ƒNpN666å*iN

इसे ऑनलाइन आज़माएं!

— आउटगोल्फर को एरिक करें
स्रोत

4

बैश + कोर यूटिल्स, 51 49 बाइट्स

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

कमांड लाइन तर्क देता है। बड़ी संख्या के साथ काफी धीमा हो सकता है।

— markasoftware
स्रोत

यह सभी "शैतानी अपराधों" को 6661 से नीचे कर देता है, लेकिन यह केवल इनपुट के नीचे सबसे निकटतम प्रिंट करना चाहिए: इसे ऑनलाइन आज़माएं । एक फिक्स सिर्फ |head -1अंत तक जोड़ना होगा।

— जस्टिन मेरिनर

@JustinMariner lol,

— whoops

4

गणितज्ञ, 64 62 61 53 बाइट्स

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

-1 बाइट @KellyLowder को धन्यवाद

-8 बाइट्स (वाह) @Notatree को धन्यवाद

व्याख्या

एक इनपुट लें। हम इन शर्तों के तहत इसे घटाते हैं:

इनपुट प्राइम नहीं है, या
इनपुट के अंकों में एक पंक्ति में तीन 6s नहीं होते हैं।

हम दोहराते हैं कि जब तक शैतान प्रधान नहीं हो जाता।

— जंगहवान मिन
स्रोत

2

बहुत अच्छा। आप एक और _ को अंत में खो सकते हैं क्योंकि एक प्राइम 6 में समाप्त नहीं हो सकता है

— केली लोल्डर

@ केलीलौड अच्छा बिंदु

— जुंगहवान मिन

1

यह तार से भी छोटा है:#//.i_/;!PrimeQ@i||ToString@i~StringFreeQ~"666":>i-1&

— पेड़

1

@Notatree वाह! अच्छा!

— जुंगहवान मिन

3

पर्ल 5 , 47 बाइट्स

कोड + 1 के लिए 46 बाइट्स -p

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

इसे ऑनलाइन आज़माएं!

— Xcali
स्रोत

3

जाप , 14 बाइट्स

õ fj w æ_sø666

झसे आज़माओ

देखकर वहाँ के रूप में था कम्प्लिट्स परीक्षण का मामला: एक 50% समय आधारित बोनस 969696आधे सेकंड के तहत में।

व्याख्या

पूर्णांक का निहित इनपुट U।

õ

से पूर्णांकों की एक सरणी उत्पन्न 1करने के लिए U।

fj

फ़िल्टर ( f) primes।

उल्टा।

æ_

1एक फ़ंक्शन के माध्यम से पारित होने पर एक सच्चा मूल्य (इस मामले में ) लौटाता है कि अगर जाँच करता है ...

sø666

पूर्णांक एक स्ट्रिंग ( s) में परिवर्तित होता है ( ø666)।

तेज़ वैकल्पिक, 15 बाइट्स

फिर से, यह देखते हुए कि मूल रूप से एक समय-आधारित बोनस था, यहां एक विकल्प है, और बहुत तेज, समाधान है जो मैं आगे किसी भी गोल्फ को नहीं देख सकता हूं।

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

झसे आज़माओ

— झबरा
स्रोत

2

पावरशेल , 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 -matchजांचते हैं 666कि क्या खिलाफ है और क्या $nप्राइम है (यानी, $nसभी कारकों के मेल खाता है $n)। यदि यह है, तो हम $nपाइपलाइन पर जगह लेते हैं exit, और अंतर्निहित आउटपुट के साथ। अन्यथा, हम $n--लूप को घटाते हैं और जारी रखते हैं।

— AdmBorkBork
स्रोत

छंटनी की खान संस्करण नीचे और बस अपने आधे बाइट गिनती हिट करने में कामयाब रहे: D - codegolf.stackexchange.com/a/140539/571

— TessellatingHeckler

2

पायथन 2 , 77 76 बाइट्स

संपादित करें: -1 बाइट @ मिस्टरकोड के लिए धन्यवाद

धीमी गति से चलने वाला समय, अंदर चलता है 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*

इसे ऑनलाइन आज़माएं!

— हलवार्ड वुल्म
स्रोत

76 बाइट्स: lambda x:max(q for q in range(x+1)if"666"in`q`*all(q%t for t in range(2,q)))- max()इसके बजाय का उपयोग करें[][-1]

— श्री Xcoder

2

पॉवरशेल , 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 मिनट लगते हैं।

— TessellatingHeckler
स्रोत

कारकों को करने का चतुर तरीका।

— AdmBorkBork

2

MATL, 16 बाइट्स

ZqP"@V'666'Xf?@.

इसे MATL ऑनलाइन पर आज़माएं

व्याख्या

         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

— Suever
स्रोत

2

सी ++ 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 की आवश्यकता होगी। (या अपने पसंदीदा ऑनलाइन सी ++ शेल में कॉपी और पेस्ट करें।)
इसे एन -कमांड दे रहे एन -लाइन से चलाएं तर्क के रूप में ।

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

यादृच्छिक संख्या परीक्षण के संदर्भ में शॉर्टकट बनाए गए थे। मूल कोड ने 6661 पर संभावित अपराधों का परीक्षण शुरू किया और दो द्वारा बढ़ाया गया। आपको उस समय (-1) की वजह से एक कंपाइलर की चेतावनी भी मिलेगी।

फिर भी, यह बहुत जल्दी चलता है। मेरे पुराने AMD Sempron 130 पर 1,000,000 से कम 214 शैतानी प्राइम खोजने में केवल 40 सेकंड का समय लगा।

: ^ डी

— Dúthomhas
स्रोत

2

बैश + बीएसडी-गेम पैकेज, 33

2 बाइट ने @FedericoPoloni को धन्यवाद दिया।

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

इसे ऑनलाइन आज़माएं ।

— डिजिटल आघात
स्रोत

यदि आप अंतिम दो आदेशों को प्रतिस्थापित करते हैं तो आप 1 बाइट बचा सकते हैं tail -n1।

— फेडेरिको पोलोनी

@FedericoPoloni duh - विश्वास नहीं कर सकता कि मैं tailयहाँ भूल गया । वास्तव tail -1में 1 भी कम है।

— डिजिटल ट्रामा

1

पायथन 3 , 85 83 80 बाइट्स

Halvard's 4 बाइट्स छोटा है क्योंकि यह पायथन 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)जटिलता के कारण यह बहुत धीमा है।

— श्री Xcoder
स्रोत

1

जावास्क्रिप्ट (ईएस 6), 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)}`))

स्निपेट का विस्तार करें

— जस्टिन मेरिनर
स्रोत

2

आपको ऐसा कभी नहीं करना चाहिए। यह कोड गोल्फ है और प्रदर्शन पूरी तरह से अप्रासंगिक है। मैं दृढ़ता से आपके पिछले 55 बाइट उत्तर को वापस करने का सुझाव देता हूं। इसके अलावा, आप की जगह 54 बाइट्स के लिए इसे कम कर सकते हैं d==1के साथ d<2के बाद से n>6661।

52 बाइट्स: f=n=>/666/.test(n)&(g=d=>n%--d?g(d):d<2)(n)?n:f(n-1)लेकिन बड़ी संख्या के लिए एक पुनरावृत्ति त्रुटि फेंक देंगे।

— शगि

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

— l4m2

1

रूबी, 67 , 66 , 58 , 56 बाइट्स

के +7लिए बाइट्स शामिल हैं-rprime

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

यह बहुत तेज़ है, मानों की गणना करता है ~2^52 एक दूसरे के बारे 2^64में और 5 मिनट (2011 एमबीपी, रूबी 2.3.1) के ।

— माइकल क्लेन
स्रोत

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

— wastl
स्रोत

अच्छा कार्यक्रम है। स्टेक्स आजमाने के लिए धन्यवाद। FYI करें, इस

— 1:09

@recursive आह, thx

— wastl

0

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

इसे ऑनलाइन आज़माएं!

— Mic1780
स्रोत

0

पर्ल 6 , 35 बाइट्स

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

इसे ऑनलाइन आज़माएं!

सीधा पुनरावर्ती समाधान।

— शॉन
स्रोत

0

सी # (.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 बाइट्स बचाए गए।
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इसे फिर से कहा जाता है, लेकिन बाइट्स की ओर नहीं गिना जाता है। किसी भी स्पष्टीकरण की सराहना की जाएगी।

— Ayb4btu
स्रोत

तुम मेरे पीछे हो जाओ शैतान-प्राइम!

शैतान-Primes

भूखंड

चुनौती

उदाहरण

परीक्षण के मामलों

नियम

गणितज्ञ, 82 बाइट्स

नीम , 9 बाइट्स

जेली , 10 9 बाइट्स

व्याख्या

अजगर , 15 14 बाइट्स

कैसे?

अजगर , 14 बाइट्स

05AB1E , 11 बाइट्स

बैश + कोर यूटिल्स, 51 49 बाइट्स

गणितज्ञ, 64 62 61 53 बाइट्स

व्याख्या

पर्ल 5 , 47 बाइट्स

जाप , 14 बाइट्स

व्याख्या

तेज़ वैकल्पिक, 15 बाइट्स

पावरशेल , 128 बाइट्स

पायथन 2 , 77 76 बाइट्स

एक और 76 बाइट्स समाधान

साथ SymPy 73 बाइट्स

पॉवरशेल , 71 69 64 बाइट्स

MATL, 16 बाइट्स

सी ++ 389 बाइट्स

बैश + बीएसडी-गेम पैकेज, 33

पायथन 3 , 85 83 80 बाइट्स

जावास्क्रिप्ट (ईएस 6), 55 54 बाइट्स

समय

टेस्ट

तेज़ संस्करण, 56 बाइट्स

रूबी, 67 , 66 , 58 , 56 बाइट्स

स्टैक्स , 10 बाइट्स

PHP , 148 बाइट्स

पर्ल 6 , 35 बाइट्स

सी # (.NET कोर) , 117 115 112 बाइट्स

पुनरावर्ती दृष्टिकोण, 85 बाइट्स