Hầu hết các số vuông có ít nhất 1 số vuông khác nhau với khoảng cách Levenshtein của chúng là chính xác 1. Với một hình vuông cho trước , mỗi hình vuông đáp ứng điều kiện này được gọi là hàng xóm Levenshtein của . Ví dụ: là hàng xóm của Levenshtein là , vì chỉ cần 1 chỉnh sửa ( ). Tuy nhiên, không phải là hàng xóm của Levenshtein là , vì nó yêu cầu tối thiểu 2 lần chỉnh sửa. Các số có số 0 đứng đầu ( ) không phải là hàng xóm của Levenshtein.$x$$x$$36$$16$$1 \to 3$$64$$16$$2025 \to 025$

Nhiệm vụ của bạn là lấy một số vuông làm đầu vào và đầu ra, ở bất kỳ định dạng hợp lý nào, danh sách đầy đủ của hàng xóm Levenshtein. Bạn có thể bao gồm hàng xóm lặp lại trong danh sách, nếu bạn muốn, nhưng bạn có thể không bao gồm đầu vào ban đầu, vì đó không phải là hàng xóm của Levenshtein.

Bất kỳ định dạng hợp lý nào cũng phải bao gồm một số loại dấu tách giữa các đầu ra, chẳng hạn như ,hoặc một dòng mới và có thể xuất các ký tự có giá trị Unicode tương ứng (ví dụ: brainfuck) thay vì chính các số. Thứ tự của đầu ra không quan trọng.

Đầu vào này sẽ luôn là một số vuông, lớn hơn . Chương trình của bạn không nên có giới hạn lý thuyết , nhưng nếu nó không thành công với số lượng lớn vì lý do thực tế (ví dụ: ngoài số 32 bit), điều đó hoàn toàn tốt.$0$

Nếu đầu vào không có bất kỳ lân cận Levenshtein nào, đầu ra phải phản ánh rõ ràng điều này, chẳng hạn như không xuất ra gì, một mảng / chuỗi trống, một số nguyên âm, , v.v.$0$

Đây là mã golf , vì vậy mã ngắn nhất tính bằng byte sẽ thắng.

Các trường hợp thử nghiệm

Đây là kết quả cho các ô vuông từ đến :$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

Ngoài ra, 1024không có bất kỳ hàng xóm, vì vậy là một trường hợp thử nghiệm tốt.

05AB1E ,  11 10  6 byte

-4 cảm ơn Grimy !! (hình vuông đầu tiên thay vì tìm hình vuông tiết kiệm 3; sử dụng 10 ^ n tiết kiệm 1)

°Lnʒ.L

Lấy một số nguyên, xuất ra một danh sách, có thể trống,

Hãy thử trực tuyến! - Điều này là điên-chậm do°, vì vậy không có điểm nào cố gắng ngay cả cho9.
Hoặc Thử phiên bản nhanh hơn một chút - Cái này thêm tám thay vào8+đó sau đó sử dụng cùng một cách tiếp cận.

Làm sao?

°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

Võng mạc 0.8.2 , 142 138 byte

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

Hãy thử trực tuyến! Giải trình:

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

Đối với mỗi chữ số, hãy thử a) loại bỏ nó b) trước nó với một chữ số khác nhau c) thay đổi nó thành một chữ số khác nhau. Hiện tại, chữ số khác nhau được đánh dấu bằng a #.

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

Đối với mỗi chữ số tiềm năng khác nhau, thay thế từng chữ số có thể.

A`^0

Xóa các số bắt đầu bằng 0.

Dr`

Loại bỏ tất cả các số trùng lặp. (Điều này chỉ để lại các dòng trống.)

\d+
$*

Chuyển đổi sang unary.

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

Giữ tất cả các số vuông trừ số cuối cùng (luôn luôn là số đầu vào).

%`1

Chuyển đổi các số còn lại trở lại thập phân.

R , 42 41 byte

$(9n)^2$

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

Hãy thử trực tuyến!

$n$$91n$$1\to 91$$100\to9100$$(9n)^2=81n^2$$n>1$$81n^2>91n$$n=1$$1\to91$$91$ không phải là một hình vuông, chúng tôi ổn.

$1$$(9n)^2$

Python 2 , 173 167 149 148 147 144 139 138 byte

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}

Hãy thử trực tuyến!

19 + 3 + 5 + 1 = 28! byte thx cho Jonathan Allan .

Oracle SQL, 93 byte

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

Kiểm tra trong 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.

PHP , 62 byte

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

Hãy thử trực tuyến!

Kịch bản lệnh này in các hàng xóm đầu vào của Levenshtein được phân tách bằng _dấu phân cách và nếu không tìm thấy hàng xóm, không in gì cả.

Hạnh phúc là PHP đã tích hợp sẵn khoảng cách Levenshtein ! Tập lệnh này lặp trên tất cả các số vuông từ 1 đến input * 91, vì tất cả các hàng xóm Levenshtein hợp lệ (khoảng cách 1) đều nằm trong phạm vi đó. Sau đó in mọi số trong phạm vi đó có khoảng cách Levenshtein là 1 với đầu vào.

JavaScript (V8) ,  129 125  123 byte

Đưa đầu vào dưới dạng một chuỗi. In hàng xóm Levenshtein sang 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)}

Hãy thử trực tuyến!

Đã bình luận

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
}                             //

Thạch , 53 38 byte

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

Hãy thử trực tuyến!

Không có tích hợp cho khoảng cách Levenshtein để tạo ra tất cả các chỉnh sửa 1 khoảng cách có thể và sau đó loại trừ những khoảng cách có số 0 đứng đầu và chỉ giữ các hình vuông hoàn hảo. Không lọc các bản sao (như được phép).

Ngôn ngữ Wolfram (Mathicala) , 62 59 byte

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

Hãy thử trực tuyến!

Sử dụng các ràng buộc từ câu trả lời R .