कितने विभाजन में केवल सही वर्ग होते हैं?

Question

एक गैर-नकारात्मक पूर्णांक या अंकों की एक सूची को देखते हुए, यह निर्धारित करें कि वर्ग संख्या को समाप्‍त करने से कितने तरीके हो सकते हैं, जिसमें अग्रणी शून्य हो सकते हैं।

उदाहरण

input -> output # explanation
164 -> 2 # [16, 4], [1, 64]
101 -> 2 # [1, 01], [1, 0, 1]
100 -> 3 # [100], [1, 00], [1, 0, 0]
1 -> 1 # [1]
0 -> 1 # [0]
164900 -> 9 # [1, 64, 9, 0, 0], [1, 64, 9, 00], [1, 64, 900], [16, 4, 900], [16, 4, 9, 0, 0], [16, 4, 9, 00], [16, 49, 0, 0], [16, 49, 00], [16, 4900]

नियम

• स्टैंडर्ड लोफॉल्स लागू होते हैं
• यह कोड-गोल्फ है इसलिए बाइट्स जीत में सबसे छोटा जवाब है

Comments

सैंडबॉक्स पोस्ट

— HyperNeutrino

क्या हम इनपुट को अंकों की सूची के रूप में ले सकते हैं?

— जुआन

1 -> 1 लेकिन 0 -> 0 क्यों है?

— जोनाह

@ जोनाह टाइपो ... xD

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

@totallyhuman ज़रूर

— हाइपरन्यूट्रीनो

Answer 1

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

s x=any((x==).(^2))[0..x]
c(a:b:x)=a*10+b:x
c x=x
h[x]=1>0
h x=(s.head)x
f x@(_:_:_)|y<-until h c x=f(tail y)+f(c y)
f x=sum[1|any s x]

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

शायद अभी तक अच्छी तरह से गोल्फ नहीं हुआ है लेकिन यह आश्चर्यजनक रूप से कठिन समस्या है

Answer 2

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

ŒṖḌƲẠ€S

एक विवादास्पद लिंक अंकों की एक सूची ले रहा है और एक गैर-नकारात्मक पूर्णांक लौटा रहा है।

इसे ऑनलाइन आज़माएं! या परीक्षण सूट देखें।

कैसे?

ŒṖḌƲẠ€S - Link: list of digits              e.g. [4,0,0,4]
ŒṖ       - all partitions                         [[4,0,0,4],[4,0,[0,4]],[4,[0,0],4],[4,[0,0,4]],[[4,0],0,4],[[4,0],[0,4]],[[4,0,0],4],[4,0,0,4]]
  Ḍ      - convert from decimal list (vectorises) [[4,0,0,4],[4,0,   4 ],[4,    0,4],[4,      4],[   40,0,4],[   40,    4],[    400,4],     4004]
   Ʋ    - is square? (vectorises)                [[1,1,1,1],[1,1,   1 ],[1,    1,1],[1,      1],[    0,1,1],[    0,    1],[      1,1],        0]
     Ạ€  - all truthy? for €ach                   [        1,          1,          1,          1           0,            0,          1,        0]
       S - sum                                    5

Answer 3

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

f x=sum[0.5|y<-mapM(\c->[[c],c:" "])x,all((`elem`map(^2)[0..read x]).read).words$id=<<y]

एक फ़ंक्शन को परिभाषित करता है fजो एक स्ट्रिंग लेता है और एक फ्लोट देता है। बहुत धीमी गति से। इसे ऑनलाइन आज़माएं!

व्याख्या

मैं एक स्ट्रिंग के सभी विभाजनों की गणना के लिए अपने हास्केल टिप का उपयोग कर रहा हूं mapMऔर words। स्निपेट स्ट्रिंग के mapM(\c->[[c],c:" "])xप्रत्येक वर्ण 'c'को xया तो एक-तत्व स्ट्रिंग "c"या दो-तत्व स्ट्रिंग के साथ बदलता है "c ", और सभी संभावित संयोजनों की सूची देता है। यदि मैं परिणामों में से एक लेता हूं y, तो इसे संक्षिप्त करें और wordsपरिणाम पर कॉल करें , यह उसके द्वारा डाले गए रिक्त स्थान पर विभाजित हो जाएगा mapM। इस तरह मैं सभी विभाजन प्राप्त करता हूंx सन्निहित पदार्थों के । फिर मैं उन परिणामों को गिनता हूं जहां प्रत्येक विभाजन तत्व एक पूर्ण वर्ग है (इसे सूची में खोजते हैं[0,1,4,9,..,x^2] )। एक चेतावनी यह है कि प्रत्येक विभाजन को एक अनुगामी स्थान के साथ और उसके बिना दो बार गिना जाता है, इसलिए मैं योग करता हूं0.5s के बजाय 1s; यही कारण है कि परिणाम प्रकार एक फ्लोट है।

f x=                       -- Define f x as
 sum[0.5|                  -- the sum of 0.5 for
  y<-                      -- every y drawn from
  mapM(\c->[[c],c:" "])x,  -- this list (explained above)
                           -- (y is a list of one- and two-element strings)
  all(...)                 -- such that every element of
                 id=<<y]   -- concatenated y
          .words$          -- split at spaces satisfies this:
                           -- (the element is a string)
   (...).read              -- if we convert it to integer
    `elem`                 -- it is an element of
    map(^2)                -- the squares of
    [0..read x]            -- the numbers in this list.

Answer 4

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

lf!f!sI@sjkY2T./

टेस्ट सूट ।

Answer 5

पायथन 3 , 148 139 135 134 बाइट्स

अर्नोल्ड पामर को 10 बाइट्स धन्यवाद।

def f(a):
 s=[a[:1]]
 for i in a[1:]:s=sum([[x+[i],x[:-1]+[x[-1]*10+i]]for x in s],[])
 return sum({n**.5%1for n in x}=={0}for x in s)

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

Comments

मैं इसे दोबारा जाँचूँगा, लेकिन मेरा मानना ​​है कि यह काम करता है। 140 अक्षर।

— अर्नोल्ड पामर

मैं goofed और के बीच एक रिक्ति छोड़ दिया %1और for...

— अर्नाल्ड पामर

के [[a[0]]]साथ बदलने से [a[:1]]एक बाइट बच जाएगी

— अर्नोल्ड पामर

हम दोनों ने मिलकर हास्केल को बाहर कर दिया।

— लीकी नून

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

— अर्नोल्ड पामर

Answer 6

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

Count[FreeQ[IntegerQ/@Sqrt[FromDigits/@#],1<0]&/@(FoldPairList[TakeDrop,s,#]&/@Flatten[Permutations/@IntegerPartitions[Length[s=#]],1]),1>0]&

इनपुट (अंकों की एक सूची)

[{1,6,4}]

Comments

मुझे लगता है कि यह 1649 के लिए गलत जवाब देता है: मैं तीन भागों की गणना करता हूं जो वर्ग बनाते हैं (अर्थात् {1,64,9}, {16,4,9}और {16,49}) लेकिन आपका फ़ंक्शन 4. वापस करता है

— एक पेड़ नहीं

इसके अलावा, मैंने आपको Table[(function of s[[i]]),{i,Length[s=(stuff)]}]कुछ समय की तरह निर्माणों का उपयोग करते हुए देखा है; आप आमतौर पर इसे नीचे गोल्फ कर सकते हैं (function of #)&/@(stuff)।

— एक पेड़ नहीं

@Notatree आप बिल्कुल सही हैं! मैंने कई बदलाव किए, आपके निर्देशों का पालन किया और यह एक आकर्षण की तरह काम करता है! धन्यवाद

— J42161217

Answer 7

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

lambda s:len([l for l in[''.join(sum(zip(s,[','*(n>>i&1)for i in range(len(s))]+['']),())).split(',')for n in range(2**~-len(s))]if {int(x)**.5%1for x in l}=={0}])

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

संपादित करें: अर्नोल्डप्लेमर के कारण 10 बाइट्स सहेजे गए

Comments

क्या आप .5इसके बजाय का उपयोग करके एक बाइट बचा सकते हैं 0.5?

— नंबरमानस

आप ऐसा कर सकते हैं। आप उसी बाइट के साथ कुछ बाइट्स भी बचा सकते हैं, जो मैंने लीक नून के पायथन 3 पोस्ट पर खींची थी। साथ ही, आपके उत्तर ने तत्वों की संख्या को मुद्रित नहीं किया, लेकिन तत्वों को स्वयं, इसलिए मैंने इसमें जोड़ा। यदि आप अपने पास आउटपुट रखना चाहते हैं, तो यह एक अतिरिक्त 5 बाइट्स है। 163 बाइट्स

— अर्नोल्ड पामर

सेट की समझ के साथ अच्छी चाल, अर्नोल्ड।

— चास ब्राउन