वर्गों का दशमलव संयोजन

Question

परिसर

एक रात, मैं सिर्फ संख्याओं पर विचार कर रहा था। मुझे 7, 10, 12, 13 और अधिक जैसे नंबरों के बारे में कुछ अनोखा पता चला। वे वर्गों के वर्ग हैं! मतलब, कि जब चुकता किया जाता है, तो स्वयं वर्ग शामिल होते हैं। OEIS उन्हें वर्ग कहता है जो दो या दो से अधिक वर्गों का एक दशमलव संयोजन है।

ऐसी संख्याओं के उदाहरणों में 7 (49 में 2 ² और 3 ² ) 13 (169 में 4 ² और 3 ² ) और 20 (400 में 2 ² और 0 ² ) शामिल हैं। अन्य उदाहरणों में 37 शामिल हैं, क्योंकि 1369 एक शब्द है क्योंकि इसे 1, 36 के रूप में विभाजित किया जा सकता है और 9. 1444 (38 ² ) एक शब्द है क्योंकि इसे 1, 4, 4, 4 के रूप में विभाजित किया जा सकता है। मैंने इसके बारे में मठ से पूछा .SE, और यह मेरे नाम पर रखा गया था!

चुनौती

एक प्रोग्राम डिज़ाइन करें जो TanMath नंबर को प्रिंट करता है। संख्या n को देखते हुए (1 से शुरू), nth TanMath नंबर, T (n) प्रिंट करें।

एक कोड उदाहरण के रूप में:

>> 1
>> 7

या

>> 4
>> 13

संदर्भ पायथन कार्यान्वयन (धन्यवाद @ मार्टिनबटनर और @ Sp3000!):

from math import sqrt

n = input()

def r(digits, depth):
    z = len(digits)
    if z < 1:
        return (depth > 1)
    else:
        for i in range(1, z+1):
            t = int(digits[:i])
            if sqrt(t).is_integer() and r(digits[i:], depth+1):
                return True
        return False


i=0
t=0
while t < n:
    i += 1

    if r(str(i**2), 0):
        t += 1

print i

यहां पहले 100 नंबरों की सूची दी गई है:

१० १२ १३ १ ९ २० २० ३५ ३५ ३ 38 ३ 12 ४० ४० ४४ ५० ६० ६० ६० 20० 13० १०० ९ ५० १०५ १०५ १०५ ११० १२० १२० १२० १२० १२० १२० १०० १ 20० १ ९ ० १ ९ ० २०१० २०५ २० ९ २०१ २१२ २२० २२३ २३० २३० २५० २५० २५० २ 22० २५० २०५ ३०६ ३०६ ३०५ ३१५ ३२५ ३४५ ३४५ ३४४ ३४४ ३४४ ३६५ ३६० ३ ९ ३ ३ 3 ९ ३9 ९ ३ 390 ९ ३ 39 ९ ४०४ ४०५ ४०४ ४०४ ४५४ ४५० ४५ 480० ४ 480५ ४ 480० ४ 480 480४ 240 240 में ४२० ३ 240४ ३५ 240 ३५४ ३५० ३३५ ३५० ३३० ३५० ३३० ३५० ३३० ३५० ३४०४ ४५ 420४ ४५४70० ४५४70५ ४ 480० ४ 480० 480४ 240४ 240 240४ 240४ 240 240 240

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

सौभाग्य!

Comments

38 को बेशक 12² & 2² लिखा जा सकता है।

— नील

@ नील हां ... c यह पहले 100 नंबरों की सूची में है।

— तन्माथ

क्षमा करें यदि मैंने आपको भ्रमित किया है, लेकिन मैं सिर्फ 38² के अपघटन के विकल्प पर 1² & 2² & 2² & 2² के रूप में टिप्पणी कर रहा था।

— नील

@ नील ओह .. मैं देख रहा हूँ। मैं इसे इस तरह से छोड़ दूंगा, मुझे लगता है कि यह दूसरों के लिए है कि 12 ^ 2 को अपघटन में शामिल किया जा सकता है।

— तन्माथ

Answer 1

पायथ, 23 21 20 बाइट्स

e.ff!-sMT^R2Z./`^Z2Q

1 बाइट से गोल्फिंग के लिए @isaacg को धन्यवाद!

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

यह काम किस प्रकार करता है

                      (implicit) Store the evaluated input in Q.
 .f                Q  Filter; find the first Q positive integers Z such that:
                ^Z2     Compute the square of Z.
               `        Cast to string.
             ./         Compute all partitions of the string.
   f                    Filter; find all partitions T such that:
      sMT                 Cast all elements of T to integer.
         ^R2Z             Compute the squares of all integers in [0, ..., Z-1].
     -                    Remove the squares from the integers in T.
    !                     Compute the logical NOT of the result. This returns True
                          iff all integers in T are squares of numbers less than Z.
                        Keep T if `!' returned True.
                      Keep Z if `!' returned True for at least one T.
e                     Retrieve the last of the Q matches.

Comments

भागो समय जटिलता भयावह है। मैं ऑनलाइन दुभाषिया के साथ 60 से अधिक इनपुट की कोशिश नहीं कर रहा हूँ ।

— डेनिस

tअनावश्यक है, क्योंकि ^R2Zइच्छा को शामिल नहीं ^Z2। यह पायथन की सीमा के समान है, इसमें शीर्ष छोर शामिल नहीं है।

— isaacg

हां, मुझे एहसास हुआ कि जैसे ही मैंने आपका जवाब पढ़ा। यह पिछले दृष्टिकोण से एक बचा था ... धन्यवाद!

— डेनिस

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

— isaacg

कोई चिंता नहीं। मैंने मान लिया कि यह कुछ ऐसा ही था। आपने पहले भी कई बार मेरी मदद की है। (और मैं हूँ परिचित धीमी गति से इंटरनेट की समस्या से परिचित: पी।)

— डेनिस

Answer 2

जूलिया, 189 145 बाइट्स

n->(c=m=0;while c<n m+=1;d=["$(m^2)"...];for p=partitions(d) d==[p...;]&&!any(√map(parse,map(join,p))%1.>0)&&endof(p)>1&&(c+=1;break)end;end;m)

यह एक अनाम फ़ंक्शन बनाता है जो पूर्णांक को स्वीकार करता है और पूर्णांक देता है। इसे कॉल करने के लिए, इसे एक नाम दें, जैसे f=n->...।

Ungolfed:

function tanmath(n::Integer)
    # Initialize the number to check (c) and the nth TanMath
    # number (m) both to 0
    c = m = 0

    # While we've generated fewer than n TanMath numbers...
    while c < n
        # Increment the TanMath number
        m += 1

        # Get the digits of m^2 as characters
        d = ["$(m^2)"...]

        # Loop over the unordered partitions of the digits
        for p in partitions(d)
            # Convert the partition of digits to parsed numbers
            x = map(parse, map(join, p))

            # If the partition is in the correct order, none of the
            # square roots of the digits are non-integral, and p is
            # of length > 1...
            if d == [p...;] && !any(sqrt(x) % 1 .> 0) && endof(p) > 1
                # Increment the check
                c += 1

                # Leave the loop
                break
            end
        end
    end

    # Return the nth TanMath number
    return m
end

कुछ मदद और विचारों के लिए डेनिस के लिए धन्यवाद और 44 बाइट्स बचाने के लिए ग्लेन ओ के लिए धन्यवाद!

Answer 3

जावास्क्रिप्ट ईएस 6, 126 127

संदर्भ कार्यान्वयन, कुछ गोल्फ चाल के साथ जावास्क्रिप्ट में परिवर्तित हो गया।

स्पष्ट वापसी से बचने के लिए eval का उपयोग करना।

प्रसार संचालक, डिफ़ॉल्ट पैरामीटर और एरो फ़ंक्शंस (मैं उपयोग करते हैं) के साथ एक एक्मास्क्रिप्ट 6 अनुरूप ब्राउज़र में नीचे स्निपेट का परीक्षण कर रहा हूं

F=n=>eval('for(i=t=0;t<n;t+=k([...i*i+""]))++i',k=(s,l=1,n="")=>s[0]?s.some((d,i)=>Math.sqrt(n+=d)%1?0:k(s.slice(i+1),l-1)):l)

// Less golfed

U=n=>{
  k = (s,l=1,n="") =>
    s[0]
    ? s.some((d,i) => 
             Math.sqrt(n+=d)%1 ? 0 : k(s.slice(i+1),l-1)
            )
    : l;
  for(i=t=0; t<n; ) {
    ++i;
    t += k([...i*i+""])
  }  
  return i
}

function test() { R.innerHTML=F(+I.value) }

test()

<input id=I value=100><button onclick='test()'>-></button>
<span id=R></span>

Answer 4

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

f=n=>{for(i=c=0;c<n;c+=1<g(++i*i+""))g=s=>{for(var l=0;s[l++];)if(!(Math.sqrt(s.slice(0,l))%1)&&!s[l]|(r=!!g(s.slice(l))))return 1+r};return i}

प्रयोग

f(100)
=> 487

व्याख्या

f=n=>{
  for(
    i=                     // i = current number to check
      c=0;                 // c = number of TanMath numbers found so far
    c<n;                   // keep looping until we have found the required TanMath number
    c+=1<                  // increment the count if it has multiple squares in the digits
      g(++i*i+"")          // check if the current number is a TanMath number
  )
    g=s=>{                 // this function is passed a number as a string and returns the
                           //     number of squares found (max 2) or undefined if 0
      for(var l=0;s[l++];) // loop through each digit
                           // ('var' is necessary because the function is recursive)
        if(
          !(Math.sqrt(     // check if the square root of the digits is a whole number
            s.slice(0,l)   // get the digits to check
          )%1)&&
          !s[l]|           // finish if there are no more digits left to check
          (r=!!            // r = true if number of squares in remaining digits > 0
            g(s.slice(l))  // get number of squares in remaining digits
          )
        )
          return 1+r       // return number of squares found
    };
  return i                 // return the number that the loop finished at
}

Answer 5

लुआ, 148 बाइट्स

c=...r=load"a=a or...==''for p=0,...and n-1or-1 do p='^'..p*p..'(.*)'r(p.match(...,p))end"n=-1repeat
n=n+1r(n*n)c,a=c-(a and 1or 0)until c<1print(n)

लुआ 5.3 आवश्यक है

$ lua program.lua 1
7
$ lua program.lua 10
37
$ lua program.lua 100
487

Answer 6

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

यह एक क्रूर बल कार्यान्वयन है। गोल्फ सुझाव का स्वागत करते हैं।

from itertools import*
def t(n):
 a=m=0
 while a<n:m+=1;d=str(m*m);r=range(1,len(d));c=[i*i for i in range(m)];a+=any(all(p in c for p in q)for q in[[int(d[x:y])for x,y in zip((0,)+j,j+(None,))]for i in r for j in combinations(r,i)])
 return m

Ungolfed:

import itertools
def tanmath(n):
    a = 0
    m = 0
    while a < n:
        m += 1
        d = str(m*m)
        squares = [i*i for i in range(m)]
        z = []
        # partitions code
        for i in range(1, len(d)):
            for j in itertools.combinations(range(1, len(d)), i):
                partition_indices = zip((0,)+j, j+(None,))
                z.append([int(d[x:y]) for x, y in partition_indices]
        # end partitions code
        if any(all(p in squares for p in q) for q in z):
            a += 1
    return m