कॉन्टेक्टनेटिंग प्राइम

Question

चुनौती:

आपको एक स्ट्रिंग दी जाती है जिसमें केवल अंक होते हैं। आपका कार्य उन न्यूनतम संख्याओं को आउटपुट करना है जिन्हें स्ट्रिंग बनाने के लिए संक्षिप्त किया जाना चाहिए। यदि यह असंभव है, आउटपुट 0।

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

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

252 -> 3
235 -> 2
92 -> 0
31149 -> 2

Comments

सम्बंधित

— एलेक्स ए।

क्या अग्रणी शून्य हो सकते हैं?

— ज़र्गब

हां, अग्रणी शून्य हो सकते हैं।

— पोई .३०

क्या हम अंकों की सूची ले सकते हैं?

— लीजनमोनमल 978

यदि अग्रणी शून्य हैं तो क्या होता है?

— डेनिस

Answer 1

जावास्क्रिप्ट (ईएस 6), 123 121 120 बाइट्स

f=(s,v)=>(p=n=>--n-1?s%n&&p(n):1)(s)||[...s].map((_,i)=>!(n=i&&(a=f(s.slice(0,i)))&&(b=f(s.slice(i)))&&a+b)|n>v?0:v=n)|v

@Neil को एक बाइट धन्यवाद दिया!

व्याख्या

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

f=(s,v)=>
  (p=n=>--n-1?s%n&&p(n):1)(s) // if s is prime, return 1
  ||[...s].map((_,i)=>        // else for each index in s, split s into 2
    !(n=i&&                   // v = return value (initialised to undefined)
      (a=f(s.slice(0,i)))&&
      (b=f(s.slice(i)))&&
      a+b
    )|n>v?0:v=n               // if i, a, b and n are all > 0 and !(n > v), v = n
  )|v                         // cast v to an integer and return it

// Test
var testCases = [ "252", "235", "92", "3149", "24747" ];
document.write("<pre>" + testCases.map(c => c + ": " + f(c)).join("\n"));

Comments

यह मुझे है या आप बदल सकते हैं i?(a=...)&&(b=...)&&a+b:0करने के लिए i&&(a=...)&&(b=...)&&a+b?

— नील

Answer 2

MATL , 26 24 बाइट्स

0in:"GUtZq@Z^V10ZA=a?x@.

परीक्षण के कुछ मामलों में कुछ सेकंड लगते हैं।

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

व्याख्या

0       % Push 0
in:     % Take input. Generate array [1,2,...,N] where N is input length
"       % For each. In each iteration the number of used primes is increased
  GU    %   Push input. Convert to number
  tZq   %   Duplicate. Array of primes smaller than the input
  @     %   Push number of primes to bes tested in this iteration
  Z^    %   Cartesian power
  V     %   Convert to 2D array. Each row is a combination of primes
  10ZA  %   Convert each row to base 10, disregarding spaces
  =a    %   Do any of the results equal the input number? 
  ?     %   If so
    x   %     Remove the 0 that's at the bottom of the stack
    .   %     Break for each loop
        %   Implicitly end if
        % Implicitly end for each
        % Implicitly display

Answer 3

पायथ, 16 बाइट्स

lhaf!f!P_sYT./zY

परीक्षण सूट

अनुसरण करने की व्याख्या।

Answer 4

पायथ - 19 17 16 बाइट्स

lhf.AmP_sdTa./zY

टेस्ट सूट ।

Comments

अपने नए रूप में, यह एक 0 और 1 को मायने रखता है। हालाँकि, संपादन से पहले, यह नहीं था।

— पोई --३०

@ poi830 ने इसे ठीक किया।

— माल्टसेन

Answer 5

बैश + कोरुटिल्स, 169 158 149 बाइट्स

c()
{
test $1||echo a
for i in `seq ${#1}`
do factor ${1::$i}|grep -q ': \w*$'&&printf b%s\\n `c ${1:$i}`
done
}
c $1|sort|sed '/a/!d;s/..//;q'|wc -c

हम यूनरी में गिनती करते हैं, bप्रत्येक प्राइम के लिए एक के साथ एक लाइन आउटपुट करते हैं और aलाइन के अंत में एक समाप्ति (ताकि printfकाम करने के लिए एक टोकन है)।

प्राइमलिटी टेस्ट है factor $n | grep -q ': \w*$', जो यह निर्धारित करता है कि क्या संख्या में एक ही प्रमुख कारक है।

हम इनपुट को पुन: विभाजन करते हैं; यदि बायां आधा मुख्य है, तो हम प्रत्येक मान में एक जोड़कर दाएं आधे के परिणामों को फ़िल्टर करते हैं। aशून्य-लंबाई इनपुट के लिए वापस आना पुनरावृत्ति को समाप्त करता है।

अंत में, हम सभी परिणामों को लेते हैं और सबसे कम खोजने के लिए छांटते हैं (किसी भी चीज को अनदेखा करते हैं जिसमें aसफलता का संकेत नहीं है ); हमें दो (सम्मिलित किए गए aऔर नई पंक्ति के लिए) को हटाना होगा , फिर परिणाम देने के लिए वर्णों की गणना करें।

टेस्ट

$ for i in 252 235 92 31149 111; do echo "$i:"$'\t'"$(./77623.sh $i)"; done
252:    3
235:    2
92:     0
31149:  2
111:    0

मैंने 111यह दिखाने के लिए परीक्षणों में जोड़ा कि 1सही ढंग से गैर-प्रधान माना जाता है।

Comments

मैं यह सुझाव देने जा रहा था । मेरे अधिकांश संशोधन शायद अब अप्रचलित हैं, लेकिन दूसरों को अभी भी काम करना चाहिए।

— डेनिस

@ डेनिस - मुझे cफाइनल उत्पन्न करना पसंद है 0। हालांकि, प्रचुर मात्रा में स्टैडर के लिए उत्सुक नहीं है। यदि आप चाहें, तो आप अपने जवाब को आधार के रूप में उपयोग करने के लिए आपका स्वागत करते हैं।

— टोबे स्पाइट

Answer 6

मैथेमेटिका, 142 135 बाइट्स

Min[Length/@Select[Join@@@Permutations/@IntegerPartitions@Length[a=#],And@@PrimeQ@*FromDigits/@a~Internal`PartitionRagged~#&]]/.∞->0&

जैसा कि आप देख सकते हैं, इस कार्य के लिए गणितज्ञ का निर्माण नहीं किया गया था। अंकों की एक सूची लेता है।

Comments

के And@@बजाय आप का उपयोग कर सकते हैं AllTrue? 4-5 बाइट बचानी चाहिए।

— कैलक्यूलेटरफेलीन

Flatten[#,1]=Join@@@#

— कैलक्यूलेटरफेलीन

उम ... 133 पर त्रुटि और गलत उत्तर देता है ... आपने सभी परीक्षण मामलों का उपयोग किया है, है ना?

— कैलक्यूलेटरफैलीन

@CatsAreFluffy गोल्फ और स्पष्ट।

— लेजिओनमल 978