एन पर एक नोट!

Question

जेई मैक्सफील्ड ने प्रमेय सिद्ध किया (देखें डीओआई: 10.2307 / 2688966 ):

यदि होने पूर्णांक किसी भी सकारात्मक है अंक, वहाँ एक सकारात्मक पूर्णांक मौजूद ऐसी है कि पहले के अंकोंपूर्णांक गठन करें ।$A$$m$$N$$m$$N!$$A$

चुनौती

आपकी चुनौती को कुछ दिया गया है और इसी N \ geqslant 1 को खोजें ।$A \geqslant 1$$N \geqslant 1$

विवरण

• $N!$तथ्य$N! = 1\cdot 2 \cdot 3\cdot \ldots \cdot N$ प्रतिनिधित्व करता है ! = 1 \ सी-डॉट 2 \ सी-डॉट 3 \ सी-डॉट \ ldots \ सी-डॉट एन के$N$ ।
• हमारे मामले में $A$ अंकों को आधार $10$ में समझा जाता है ।
• आपके प्रस्तुतिकरण को पर्याप्त समय और मेमोरी दिए जाने पर मनमानी $A\geqslant 1$ लिए काम करना चाहिए । पूर्णांक का प्रतिनिधित्व करने के लिए 32-बिट प्रकार जैसे उदाहरण का उपयोग करना पर्याप्त नहीं है।
• जरूरी नहीं कि आप कम से कम संभव $N$ को आउटपुट करें ।

उदाहरण

A            N
1            1
2            2
3            9
4            8
5            7
6            3
7            6
9           96
12           5
16          89
17          69
18          76
19          63
24           4
72           6
841      12745
206591378  314

प्रत्येक ए के लिए कम से कम संभव $N$ https://oeis.org/A076219 में पाया जा सकता है$A$

Comments

मैं ... उसने उस प्रमेय को क्यों साबित किया? क्या वह सिर्फ एक दिन उठता है और कहता है "मैं इसे हल कर दूंगा!" या यह एक उद्देश्य की सेवा था?

— मैजिक ऑक्टोपस Urn

@MagicOctopusUrn इससे पहले आपने कभी किसी सिद्धांतकार के साथ व्यवहार नहीं किया?

— ब्रैडी गिल्ग

यहाँ यह सबूत है कि यह किसी की दिलचस्पी है।

— बजे फल

Answer 1

अजगर 2 , 50 बाइट्स

f=lambda a,n=2,p=1:(`p`.find(a)and f(a,n+1,p*n))+1

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

यह नीचे वर्णित 47-बाइट समाधान का एक भिन्नता है, जिसे 1इनपुट के लिए वापस समायोजित किया गया है '1'। (अर्थात्, हम 1पुनरावर्ती कॉल के बजाय पूर्ण अभिव्यक्ति में जोड़ते हैं , और n==2गहराई की एक परत को हटाने के लिए गिनती शुरू करते हैं, सभी गैर- '1'इनपुट के लिए परिणाम को संतुलित करते हैं।)

पायथन 2 , 45 बाइट्स (मानचित्र 1 से True)

f=lambda a,n=2,p=1:`-a`in`-p`or-~f(a,n+1,p*n)

यह @Jo King और @xnor द्वारा एक और भिन्नता है, जो इनपुट को एक संख्या के रूप में लेता है और Trueइनपुट के लिए देता है 1। कुछ लोगों को लगता है कि यह उचित खेल है, लेकिन मुझे व्यक्तिगत रूप से यह थोड़ा अजीब लगता है।

लेकिन icky बूलियन परिणाम को लपेटने के लिए केवल 3 बाइट्स की लागत होती है +(), जिससे हमें एक छोटा "अच्छा" समाधान मिलता है:

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

f=lambda a,n=2,p=1:+(`-a`in`-p`)or-~f(a,n+1,p*n)

यह मेरा पिछले समाधान है, जो देता है है 0इनपुट के लिए '1'। यदि यह प्रश्न गैर-नकारात्मक हैN तो यह मान्य होगा ।

अजगर 2 , 47 बाइट्स (अमान्य)

f=lambda a,n=1,p=1:`p`.find(a)and-~f(a,n+1,p*n)

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

इनपुट के रूप में एक स्ट्रिंग लेता है, जैसे f('18')।

यहाँ चाल है कि x.find(y) == 0जब ठीक है x.startswith(y)।

and-Expression होगा पर शॉर्ट सर्किट `p`.find(a)परिणाम के साथ 0जैसे ही `p`साथ शुरू होता है a; अन्यथा, यह मूल्यांकन करेगा -~f(a,n+1,p*n), आईडी स्था 1 + f(a,n+1,p*n)।

अंतिम परिणाम है 1 + (1 + (1 + (... + 0))), nगहरी परतें, इसलिए n।

Comments

वैसे अच्छा समाधान। मैं एक ही तरीके पर काम कर रहा था लेकिन प्रत्येक पुनरावृत्ति पर भाज्य की गणना कर रहा था; अपने दृष्टिकोण को लागू करने से मुझे कुछ बाइट्स +1वैसे भी बच गए ।

— झबरा

अपने True-for-1 संस्करण के लिए, आप आधारa संख्या स्थिति को एक संख्या के रूप में लेते हुए छोटा कर सकते हैं ।

— xnor

@xnor मैंने `` -aमें -p`के बारे में नहीं सोचा होगा , यह एक साफ चाल है :)

— लिन

यदि प्रमाण अभी भी धारण करता है यदि एन भी मूल्यों तक सीमित है, तो यह 45 बाइट समाधान हमेशा एक नंबर आउटपुट करेगा।

— नकारात्मक सात

Answer 2

ब्रेकीलॉग , 3 5 बाइट्स

ℕ₁ḟa₀

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

इसके आउटपुट चर के माध्यम से इनपुट लेता है, और इसके इनपुट चर के माध्यम से आउटपुट करता है। (दूसरे तरीके से, यह सिर्फ इनपुट के फैक्टरियल के मनमाने ढंग से उपसर्गों को पाता है, जो काफी दिलचस्प नहीं है।) टीआईओ पर दूसरे-से-आखिरी परीक्षण मामले पर टाइम्स आउट करें, लेकिन पिछले एक पर ठीक करता है । मैं इसे लिखने के समय कई मिनटों के लिए अपने लैपटॉप पर 841 पर चला रहा हूं, और यह वास्तव में अभी तक एक उत्तर नहीं दे पाया है, लेकिन मुझे इसमें विश्वास है।

         The (implicit) output variable
   a₀    is a prefix of
  ḟ      the factorial of
         the (implicit) input variable
ℕ₁       which is a positive integer.

चूंकि एकमात्र इनपुट ḟa₀1 के लिए काम नहीं करता है, और 1 1 का एक सकारात्मक उपसर्ग है! = 1, 1|ḟa₀बस के रूप में अच्छी तरह से काम करता है।

इसके अलावा, इस संपादन के रूप में, 841 लगभग तीन घंटे से चल रहा है और इसने अभी भी कोई आउटपुट नहीं दिया है। मुझे लगता है कि 1 से 12745 तक के प्रत्येक पूर्णांक के भाज्य की गणना करना बिल्कुल तेज नहीं है।

Comments

ब्रैकीलॉग में फैक्टोरियल प्रेडिक्ट का कार्यान्वयन थोड़ा जटिल है, ताकि इसे स्वीकार्य दक्षता के साथ दोनों तरीकों से इस्तेमाल किया जा सके। एक बहुत तेजी से एल्गोरिथ्म को लागू करने के लिए भाज्य की गणना कर सकता है, लेकिन यह बहुत धीमी गति से दूसरे तरीके से चल रहा होगा (यानी तथ्य से मूल संख्या का पता लगाना)।

— घातक

ओह बढ़िया! इसके लिए स्रोत को देखते हुए, मैं नहीं बता सकता कि यह सब क्या कर रहा है, लेकिन मैं आपको बता सकता हूं कि इसमें बहुत सारे अच्छे विचार रखे गए हैं।

— असंबंधित स्ट्रिंग

Answer 3

C ++ (gcc) , 107 95 बाइट्स, का उपयोग करके -lgmpऔर-lgmpxx

कुछ मूर्खतापूर्ण हादसों को इंगित करने के लिए टिप्पणियों में लोगों को धन्यवाद।

#import<gmpxx.h>
auto f(auto A){mpz_class n,x=1,z;for(;z!=A;)for(z=x*=++n;z>A;z/=10);return n;}

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

गणनागुणा करके द्वारा , फिर बार-बार इसे विभाजित करता है जब तक कि यह पारित किए गए पूर्णांक से अधिक नहीं हो। इस बिंदु पर, लूप समाप्त हो जाता है यदि फैक्टोरियल पास किए गए पूर्णांक के बराबर होता है, या अगले पर आगे बढ़ता है अन्यथा।$n!$$(n-1)!$$n$$10$$n$

Comments

आपको अब झंडे की गिनती करने की आवश्यकता नहीं है, इसलिए यह 107बाइट्स है।

— AdmBorkBork

आपको पहले दूसरे अर्धविराम की आवश्यकता क्यों है return?

— रुसलान

आप फ़ंक्शन के लिए एकल वर्ण नाम का उपयोग कर सकते हैं, बाइट्स के एक जोड़े को बचा सकते हैं।

— झबरा

Answer 4

जेली , 8 बाइट्स

1!w⁼1ʋ1#

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

पूर्णांक बनाता है और एक सिंगलटन लौटाता है।

Answer 5

05AB1E , 7 बाइट्स

∞.Δ!IÅ?

इसे ऑनलाइन आज़माएं या सत्यापित करें-सभी परीक्षण मामलों ( 841बार-बार, इसलिए बाहर रखा गया है)।

स्पष्टीकरण:

∞.Δ      # Find the first positive integer which is truthy for:
   !     #  Get the factorial of the current integer
    IÅ?  #  And check if it starts with the input
         # (after which the result is output implicitly)

Answer 6

पायथ - 8 बाइट्स

f!x`.!Tz

f              filter. With no second arg, it searches 1.. for first truthy
 !             logical not, here it checks for zero
  x    z       indexof. z is input as string
   `           string repr
    .!T        Factorial of lambda var

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

Answer 7

जावास्क्रिप्ट, 47 43 बाइट्स

एक BigInt के रूप में आउटपुट।

n=>(g=x=>`${x}`.search(n)?g(x*++i):i)(i=1n)

यह ऑनलाइन की कोशिश करो!

लिन के दृष्टिकोण को "बिल्डिंग" के रूप में लेने के बजाय प्रत्येक पुनरावृत्ति पर गणना करने के बजाय "इमारत" को सहेज कर रखा ताकि कृपया उसके समाधान को बढ़ाएँ और यदि आप इसे बढ़ा रहे हैं।

Comments

अफसोस की बात है कि _Ês bU}f1जाप में काम नहीं करता है

— अज्ञानता

@EododimentofIgnorance, हाँ, मेरे पास भी यही था। आप बाद में जगह निकाल सकते हैं s।

— झबरा

@EmbodimentofIgnorance, आप भी हटा सकते हैं 1यदि के 0लिए वापस किया जा सकता है n=1।

— झबरा

3 बाइट्स कम:x=i=1n;f=n=>`${x*=++i}`.search(n)?f(n):i

— vrugtehagel

@vrugtehagel, यह पुन: प्रयोज्य नहीं होगा।

— झबरा

Answer 8

सी # (.NET कोर) , 69 + 22 = 91 बाइट्स

a=>{var n=a/a;for(var b=n;!(b+"").StartsWith(a+"");b*=++n);return n;}

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

उपयोग System.Numerics.BigIntegerजो एक usingबयान की आवश्यकता है ।

-1 बाइट @ @ थर्डडिटा के लिए धन्यवाद!

Comments

69 + 22

— डेटा

Answer 9

जेली , 16 बाइट्स

‘ɼ!³;D®ß⁼Lḣ@¥¥/?

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

व्याख्या

‘ɼ                | Increment the register (initially 0)
  !               | Factorial
   ³;             | Prepend the input
     D            | Convert to decimal digits
        ⁼   ¥¥/?  | If the input diguts are equal to...
         Lḣ@      | The same number of diguts from the head of the factorial
      ®           | Return the register
       ß          | Otherwise run the link again

Answer 10

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

{+([\*](1..*).../^$_/)}

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

व्याख्या

{                     }  # Anonymous code block
   [\*](1..*)            # From the infinite list of factorials
             ...         # Take up to the first element
                /^$_/    # That starts with the input
 +(                  )   # And return the length of the sequence

Answer 11

चारकोल , 16 बाइट्स

⊞υ¹Ｗ⌕ＩΠυθ⊞υＬυＩ⊟υ

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। स्पष्टीकरण:

⊞υ¹

1खाली सूची पर पुश करें ताकि यह एक परिभाषित उत्पाद के साथ शुरू हो।

Ｗ⌕ＩΠυθ

सूची के उत्पाद की शुरुआत में इनपुट नहीं मिलने पर दोहराएं ...

⊞υＬυ

... सूची की लंबाई को स्वयं पर धकेलें।

Ｉ⊟υ

अंतिम मूल्य सूची में धकेल दिया।

Answer 12

पर्ल 5 -Mbigint -p , 25 बाइट्स

1while($.*=++$\)!~/^$_/}{

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

Answer 13

जे , ²⁸ 22 बाइट्स

-6 बाइट्स FrownyFrog के लिए धन्यवाद

(]+1-0{(E.&":!))^:_&1x

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

मूल उत्तर J , 28 बाइट्स

>:@]^:(-.@{.@E.&":!)^:_ x:@1

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

• >:@] ... x:@1एक विस्तारित परिशुद्धता के साथ शुरू 1करते हुए, इसे बढ़ाते रहें ...
• -.@ यह मामला नहीं है कि ...
• {.@ पहला एल्म एक शुरुआती मैच है ...
• E.&":&":मूल इनपुट की खोज करने के लिए सभी सबरिंग मैच (दोनों तर्कों पर सख्ती करने के बाद ) ...
• ! हम जिस संख्या में वृद्धि कर रहे हैं, उसका भाज्य

Comments

(]+1-0{(E.&":!))^:_&1x

— FrownyFrog

मैं पारंपरिक समय से बचने के लिए "निश्चित बिंदु" का उपयोग करता हूं।

— योना

Answer 14

सी (जीसीसी) -lgmp, 161 बाइट्स

#include"gmp.h"
f(a,n,_,b)char*a,*b;mpz_t n,_;{for(mpz_init_set_si(n,1),mpz_init_set(_,n);b=mpz_get_str(0,10,_),strstr(b,a)-b;mpz_add_ui(n,n,1),mpz_mul(_,_,n));}

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

Comments

के strstr(b=mpz_get_str(0,10,_),a)-b;mpz_mul(_,_,n))mpz_add_ui(n,n,1)बजाय सुझावb=mpz_get_str(0,10,_),strstr(b,a)-b;mpz_add_ui(n,n,1),mpz_mul(_,_,n))

— छत

Answer 15

पायथन 3 , 63 बाइट्स

f=lambda x,a=2,b=1:str(b).find(str(x))==0and a-1or f(x,a+1,b*a)

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

-24 बाइट्स जो किंग को धन्यवाद

चास ब्राउन को -3 बाइट्स धन्यवाद

Comments

@JoKing अच्छा, धन्यवाद

— हाइपरनेट्रिनो

61 बाइट्स

— चास ब्राउन

@ChasBrown धन्यवाद

— हाइपरनेट्रिनो

मुझे लगता है f=कि हेडर में आपको जो मिला है, वह आपकी बिट काउंट की ओर गिनना है।

— mypetlion

@mypetlion आप सही हैं; उस पकड़ने के लिए धन्यवाद।

— HyperNeutrino

Answer 16

जेली , 11 बाइट्स

‘ɼµ®!Dw³’µ¿

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

Answer 17

साफ , 88 बाइट्स

import StdEnv,Data.Integer,Text
$a=hd[n\\n<-[a/a..]|startsWith(""<+a)(""<+prod[one..n])]

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

परिभाषित करता है $ :: Integer -> Integer।

Data.IntegerIO के लिए मनमाने आकार के पूर्णांक का उपयोग करता है ।

Answer 18

वोल्फ्राम लैंग्वेज (गणितज्ञ) , 62 बाइट्स

(b=1;While[⌊b!/10^((i=IntegerLength)[b!]-i@#)⌋!=#,b++];b)&

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

Answer 19

रूबी , 40 बाइट्स

->n{a=b=1;a*=b+=1until"%d"%a=~/^#{n}/;b}

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

Answer 20

आइकन , 65 63 बाइट्स

procedure f(a);p:=1;every n:=seq()&1=find(a,p*:=n)&return n;end

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

Answer 21

हास्केल, 89 बाइट्स

import Data.List
a x=head$filter(isPrefixOf$show x)$((show.product.(\x->[1..x]))<$>[1..])

अगर किसी को पता है कि आवश्यक आयात को कैसे दरकिनार करना है, तो मुझे बताएं।

Comments

$N!$$N$