लेवेंसहाइट पड़ोसी

Question

अधिकांश वर्ग संख्याओं में कम से कम 1 अलग-अलग वर्ग संख्या होती है, जिसके साथ उनकी लेवेन्सहाइट दूरी ठीक 1 होती है। किसी दिए गए वर्ग $x$ , प्रत्येक वर्ग जो इस स्थिति को पूरा करता है, उसे x का एक लेवेंसहाइट पड़ोसी कहा जाता है । उदाहरण के लिए, 36 16 के एक लेवेंसहाइट पड़ोसी है , क्योंकि केवल 1 संपादन ( 1 → 3 ) की आवश्यकता है। हालाँकि, 64 में 16 का लेवेन्सहाइट पड़ोसी नहीं है , क्योंकि इसके लिए न्यूनतम 2 संपादन की आवश्यकता होती है। जिन नंबरों में 0s ( 2025 → 025 ) प्रमुख हैं वे लेवेंसहाइट पड़ोसी नहीं हैं ।$x$$36$$16$$1 \to 3$$64$$16$$2025 \to 025$

आपका काम इनपुट और आउटपुट के रूप में एक वर्ग संख्या लेना है, किसी भी उचित प्रारूप में, इसकी पूरी सूची Levenshtein पड़ोसी। यदि आप चाहें, तो आप सूची में दोहराए गए पड़ोसियों को शामिल कर सकते हैं, लेकिन आप मूल इनपुट को शामिल नहीं कर सकते हैं, क्योंकि यह स्वयं का एक लेवेंसहाइट पड़ोसी नहीं है।

किसी भी उचित प्रारूप में आउटपुट के बीच किसी प्रकार का विभाजक शामिल होना चाहिए, जैसे कि , या एक नई रेखा, और संख्याओं के बजाय संबंधित यूनिकोड मान (यानी ब्रेनफक) के साथ वर्णों को आउटपुट कर सकते हैं। आउटपुट का क्रम मायने नहीं रखता।

यह इनपुट हमेशा एक वर्गाकार संख्या होगी, जो $0$ से अधिक होगी । आपके कार्यक्रम में कोई सैद्धांतिक नहीं होना चाहिए सीमा , लेकिन यदि यह व्यावहारिक कारणों से बड़ी संख्या में विफल रहता है (जैसे कि 32-बिट संख्या से परे), तो यह पूरी तरह से ठीक है।

यदि इनपुट में कोई लेवेनशीन पड़ोसी नहीं है, तो आउटपुट को स्पष्ट रूप से प्रतिबिंबित करना चाहिए, जैसे कि आउटपुट कुछ नहीं, एक खाली सरणी / स्ट्रिंग, एक नकारात्मक पूर्णांक, $0$ , आदि।

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

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

ये $1$ से $20$ तक के वर्गों के परिणाम हैं :

  1: 4, 9, 16, 81
  4: 1, 9, 49, 64
  9: 1, 4, 49
 16: 1, 36, 169, 196
 25: 225, 256, 625
 36: 16, 361
 49: 4, 9
 64: 4
 81: 1, 841
100: 400, 900, 1600, 8100
121: 1521
144: 1444
169: 16, 1369
196: 16, 1296, 1936
225: 25, 625, 1225, 2025, 4225, 7225
256: 25
289: 2809
324: 3249
361: 36, 961
400: 100, 900, 4900, 6400

इसके अलावा, 1024कोई पड़ोसी नहीं है, इसलिए एक अच्छा परीक्षण मामला है।

Comments

अधिक दिलचस्प होगा कि पड़ोसी क्या 2025हैं।

— नील

जब तक मैं कुछ याद कर रहा हूं, 32 * 32 = 1024कोई वर्ग लेवेंसहाइट पड़ोसी नहीं है।

— xnor

@xnor हाँ, मेरा मानना ​​है कि आप सही हैं, 1024किसी भी लेवन्सहाइट पड़ोसी नहीं हैं, मैं उस उदाहरण को संपादित करूँगा

— caird coinheringaahing

"सभी के लिए ..." फॉर्म के सभी कथनों के लिए, यदि एक प्रतिधारण पाया जा सकता है, तो यह कथन का एक कठोर अवरोध है। (लेकिन अगर मैं गलत हूं, तो मैं एक काउंटरप्लस को कठोर डिस्प्रेशन के रूप में स्वीकार करूंगा।)

— नील

क्या हम आउटपुट में मूल संख्या शामिल कर सकते हैं? उदाहरण के लिए 49 -> 4, 9, 49.

— रॉबिन राइडर

Answer 1

05AB1E ,  11 10  6 बाइट्स

-4 ग्रैमी के लिए धन्यवाद !! (वर्ग पहले की बजाय वर्ग की तलाश में 3 बचाता है; 10 ^ n का उपयोग करता है 1 बचाता है)

°Lnʒ.L

एक पूर्णांक लेता है, एक, संभवतः रिक्त, सूची आउटपुट करता है

इसे ऑनलाइन आज़माएं! - यह पागल-धीमी गति के कारण है°, इसलिए कोई भी बिंदु इसके लिए प्रयास नहीं कर रहा है9।
या थोड़ा तेज़ संस्करण आज़माएँ - यह एक के बजाय आठ जोड़ता है8+ एक ही दृष्टिकोण का उपयोग करता है।

कैसे?

°Lnʒ.L - f(integer)    stack = n
°      - push 10^n             10^n
 L     - range                 [1,2,3,...,10^n]
  n    - square                [1,4,9,...,10^2n]
   ʒ   - filter keep if == 1:
    .L -   Levenshtein distance

Comments

9s«अपने 11-byter में हो सकता था 9ì। हालांकि, इस बिंदु पर अच्छा जवाब! मुझ से +1।

— केविन क्रूज़सेन

धीमी 7 т+Lnʒ.L:। धीमे धीमे 6 °Lnʒ.L:। धीरे धीरे 5 ∞nʒ.L:।

— ग्रिमि

@Grimy धन्यवाद - पृथ्वी पर मैंने पहले वर्ग को क्यों नहीं सोचा: /। क्या वह अनंत एक "शो ऑल" प्रश्न के लिए स्वीकार्य है? (मुझे लगता है कि हम जनरेटर को फ़ंक्शन सबमिशन के रूप में प्रस्तुत कर सकते हैं, लेकिन अगर कोई कोडित स्टॉप बिंदु नहीं है, तो हमें पता नहीं चल सकता है कि यह हमें अंतिम मूल्य कब दिया गया है)।

— जोनाथन एलन

मुझे नहीं लगता कि ∞nʒ.Lएक उत्तर के रूप में स्वीकार्य है क्योंकि प्रस्तुतियाँ को समाप्त करना है । असंबंधित: 7-बाइट संस्करण उपयोगों के लिए आपका TIO लिंक 9ì, जो कि T+बड़ी संख्याओं की तुलना में ~ 100x धीमा है । मेरी टिप्पणी का इस्तेमाल т+सुरक्षित होने के लिए (100 जोड़ें), लेकिन यह 8+सभी मामलों में पर्याप्त है।

— ग्रैमी

@ मेरी उफ़, धन्यवाद। मुझे लगा कि 100 ओवरकिल था क्योंकि 1 को पहले 9 वर्गों की जांच करने की आवश्यकता थी।

— जोनाथन एलन

Answer 2

रेटिना 0.8.2 , 142 138 बाइट्स

.?
$'¶$`#$&$'¶$`#$'¶$`$&
#
0$%'¶$%`1$%'¶$%`2$%'¶$%`3$%'¶$%`4$%'¶$%`5$%'¶$%`6$%'¶$%`7$%'¶$%`8$%'¶$%`9
A`^0
Dr`
\d+
$*
-2G`(\b1|11\1)+\b
%`1

इसे ऑनलाइन आज़माएं! स्पष्टीकरण:

.?
$'¶$`#$&$'¶$`#$'¶$`$&

प्रत्येक अंक के लिए, a) इसे हटाकर b) इसे अलग अंक के साथ पूर्ववर्ती करके देखें) इसे अलग अंक में बदलकर। अभी के लिए, अलग अंक एक के साथ चिह्नित है #।

#
0$%'¶$%`1$%'¶$%`2$%'¶$%`3$%'¶$%`4$%'¶$%`5$%'¶$%`6$%'¶$%`7$%'¶$%`8$%'¶$%`9

प्रत्येक संभावित भिन्न अंक के लिए, प्रत्येक संभावित अंक को प्रतिस्थापित करें।

A`^0

उन संख्याओं को निकालें जो अब शून्य से शुरू होती हैं।

Dr`

सभी डुप्लिकेट नंबर हटा दें। (यह सिर्फ लाइनों को खाली छोड़ देता है।)

\d+
$*

यूनीरी में बदलें।

-2G`(\b1|11\1)+\b

अंतिम (जो हमेशा इनपुट नंबर है) को छोड़कर सभी वर्ग संख्या रखें।

%`1

शेष संख्याओं को वापस दशमलव में बदलें।

Answer 3

आर , 42 41 बाइट्स

$(9n)^2$

function(n,y=(1:(9*n))^2)y[adist(n,y)==1]

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

$n$$91n$$1\to 91$$100\to9100$$(9n)^2=81n^2$$n>1$$81n^2>91n$$n=1$$1\to91$$91$ एक वर्ग नहीं है, हम ठीक हैं।

$1$$(9n)^2$

Answer 4

पायथन 2 , 173 167 149 148 147 144 139 138 बाइट्स

lambda n,I=int:{(I(I(v)**.5)**2==I(v))*I(v)for v in[`n`[:i]+`j-1`[:j]+`n`[i+k:]or 0for j in range(11)for i in range(n)for k in 0,1]}-{0,n}

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

19 + 3 + 5 + 1 = 28 ! जोनाथन एलन को बाइट्स thx ।

Comments

48 बचाओ । [p for p in...]बेमानी है। हम एक सेट (या डुप्लिकेट) वापस कर सकते हैं। '0'<v[:1]हो सकता है '1'<=v। यह बहुत धीमी है, लेकिन range(len(a)+1)हो सकता है range(n)। राशि से बचने के लिए iऔर i+1स्लाइस के लिए एक चर का उपयोग करें । एक लंबोदर का उपयोग करें। EDIT आपके पिछले से 48 बचाती है।

— जोनाथन एलन

@ जोनाथन एलन: मैंने पहले से ही कुछ बदलाव किए हैं; लेकिन निश्चित रूप से 18 बाइट्स की सराहना करते हैं!

— चास ब्राउन

एक और एक

— जोनाथन एलन

@ जोनाथन एलन: अच्छा! यह अब मुश्किल से पढ़ने योग्य है :)।

— चास ब्राउन

@ जोनाथन एलन: योग्य, मैं अभी अपडेट बंद करने वाला हूं - मैं नहीं रख सकता! :)

— चास ब्राउन

Answer 5

Oracle SQL, 93 बाइट्स

select level*level from t where utl_match.edit_distance(x,level*level)=1connect by level<10*x

SQL * PLus में टेस्ट करें।

SQL> set heading off
SQL> with t(x) as (select 225 from dual)
  2  select level*level from t where utl_match.edit_distance(x,level*level)=1connect by level<10*x
  3  /

         25
        625
       1225
       2025
       4225
       7225

6 rows selected.

Answer 6

PHP , 62 बाइट्स

for(;$argn*92>$n=++$i**2;levenshtein($argn,$n)==1&&print$n._);

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

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

खुशी से PHP में लेवेंसहाइट दूरी के लिए एक अंतर्निहित है ! यह लिपि 1 से लेकर सभी वर्गाकार नंबरों पर लूप होती है input * 91, क्योंकि सभी वैध लेवेंसहाइट पड़ोसी (1 की दूरी) उस सीमा में हैं। फिर उस सीमा में प्रत्येक संख्या को प्रिंट करता है जिसमें इनपुट के साथ 1 की लेवेन्शेटिन दूरी होती है।

Answer 7

जावास्क्रिप्ट (V8) ,  129 125  123 बाइट्स

एक स्ट्रिंग के रूप में इनपुट लेता है। Levenshtein पड़ोसियों को STDOUT में प्रिंट करता है।

s=>{for(t=9+s;t;t--)(t+='')**.5%1||(g=m=>m*n?1+g(m,--n)*(g(--m)-(s[m]==t[n++]))*g(m):m+n)(s.length,n=t.length)-1||print(t)}

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

टिप्पणी की गई

s => {                        // s = input
  for(                        // loop:
    t = 9 + s;                //   start with t = '9' + s
    t;                        //   repeat while t > 0
    t--                       //   decrement t after each iteration
  )                           //
    (t += '')                 //   coerce t to a string
    ** .5 % 1 ||              //   abort if t is not a square
    ( g =                     //   g is a recursive function to test whether the
                              //   Levenshtein distance between s and t is exactly 1
      m =>                    //   m = pointer into s (explicit parameter)
                              //   n = pointer into t (defined in the global scope)
        m * n ?               //     if both m and n are greater than 0:
          1 +                 //       add 1 to the final result and add the product of:
          g(m, --n) * (       //         - a recursive call with m and n - 1
            g(--m) -          //         - a recursive call with m - 1 and n - 1
            (s[m] == t[n++])  //           minus 1 if s[m - 1] = t[n - 1]
          ) *                 //
          g(m)                //         - a recursive call with m - 1 and n
        :                     //       else:
          m + n               //         stop recursion and return m + n
    )(s.length, n = t.length) //   initial call to g with m = s.length, n = t.length
    - 1 ||                    //   abort if the final result is not 1
    print(t)                  //   otherwise, print t
}                             //

Comments

मुझे पता था कि स्पाइडरमोंकी थी, print()लेकिन मुझे नहीं पता था कि नोड के पास भी ...

— नील

@ नील वास्तव में, यह नोड में मौजूद नहीं है। मुझे लगता है कि यह संस्करण V8 का केवल एक शेल बिल्ड है - जो ब्राउज़र संस्करण के बहुत करीब है।

— अरनौलड

Answer 8

जेली , 53 38 बाइट्स

D;Ɱ⁵ṭJœP,œṖjþ⁵Ẏṭ@ḢF${ʋʋ€$ƲẎ%⁵1ị$ƇḌƲƇḟ

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

लेवेंसाइटिन दूरी के लिए कोई बिल्ट-इन नहीं है, इसलिए सभी संभव 1-दूरी के संपादन उत्पन्न करते हैं और फिर अग्रणी शून्य वाले लोगों को छोड़कर केवल सही वर्ग रखते हैं। डुप्लिकेट को फ़िल्टर नहीं करता (अनुमति के अनुसार)।

Answer 9

वोल्फ्राम भाषा (गणितज्ञ) , 62 59 बाइट्स

f@n_:=Select[Range[9n]^2,EditDistance@@ToString/@{n,#}==1&]

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

R उत्तर से बाउंड का उपयोग करना ।