Python 3 , 177 170 163 130 byte
lambda a,b:s(d(a)^d(b))
def s(n,x=0,s=''):
while n:n-=1;s+=chr(n%256);n>>=8
return s
def d(n,c=0):
while s(c)!=n:c+=1
return c
Hãy thử trực tuyến!
-14 byte nhờ notjagan
-33 byte nhờ Leaky Nun (và chuyển đổi endianness)
Tôi không có kinh doanh cố gắng chơi bất cứ thứ gì trong Python, nhưng tôi không muốn sử dụng Lua vì phương pháp này cần các số nguyên chính xác lớn để hoạt động trên các đoạn dài hợp lý. (Lưu ý: thuật toán vẫn thực sự chậm khi tăng độ dài chuỗi.) Điều này chủ yếu chỉ để cung cấp câu trả lời;)
Mỗi chuỗi là tự đảo ngược và chuỗi trống là danh tính. Điều này chỉ đơn giản là thực hiện xor dưới một mệnh đề đơn giản giữa các chuỗi và số nguyên không âm. slà một hàm trợ giúp tính toán mệnh đề (chỉ một chiều) và dlà nghịch đảo.
Phiên bản không chậm (148 byte, lịch sự của Leaky Nun):
lambda a,b:s(d(a)^d(b))
def s(n,x=0,s=''):
while n:n-=1;s=chr(n%256)+s;n>>=8
return s
def d(n,c=0):
while n:c=c*256+ord(n[0])+1;n=n[1:]
return c
Hãy thử trực tuyến!
Tôi cũng sẽ chiếm đoạt điều này cho một mồi theo lý thuyết nhóm.
Bất kỳ nghịch đảo đúng là một nghịch đảo trái: inv (a) + a = (inv (a) + a) + e = (inv (a) + a) + (inv (a) + inv (inv (a))) = inv (a) + (a + inv (a)) + inv (inv (a)) = (inv (a) + e) + inv (inv (a)) = inv (a) + inv (inv (a) ) = e
Điều này cũng có nghĩa là a là nghịch đảo của inv (a) .
Bất kỳ danh tính bên phải là một danh tính bên trái: e + a = (a + inv (a)) + a = a + (inv (a) + a) = a
Danh tính là duy nhất, được cung cấp danh tính khác f : e = e + f = f
Nếu a + x = a thì x = e : x = e + x = (inv (a) + a) + x = inv (a) + (a + x) = inv (a) + a = e
Nghịch đảo là duy nhất, nếu a + x = e thì: x = e + x = (inv (a) + a) + x = inv (a) + (a + x) = inv (a) + e = inv (a )
Việc làm theo các bằng chứng sẽ giúp việc xây dựng các mẫu đối với các giải pháp được đề xuất không thỏa mãn các đề xuất này trở nên khá dễ dàng.
Đây là một thuật toán tự nhiên hơn mà tôi đã thực hiện (nhưng không chơi gôn) ở Lua . Có lẽ nó sẽ cho ai đó một ý tưởng.
function string_to_list(s)
local list_val = {}
local pow2 = 2 ^ (math.log(#s, 2) // 1) -- // 1 to round down
local offset = 0
list_val.p = pow2
while pow2 > 0 do
list_val[pow2] = 0
if pow2 & #s ~= 0 then
for k = 1, pow2 do
list_val[pow2] = 256 * list_val[pow2] + s:byte(offset + k)
end
list_val[pow2] = list_val[pow2] + 1
offset = offset + pow2
end
pow2 = pow2 // 2
end
return list_val
end
function list_to_string(list_val)
local s = ""
local pow2 = list_val.p
while pow2 > 0 do
if list_val[pow2] then
local x = list_val[pow2] % (256 ^ pow2 + 1)
if x ~= 0 then
x = x - 1
local part = ""
for k = 1, pow2 do
part = string.char(x % 256) .. part
x = x // 256
end
s = s .. part
end
end
pow2 = pow2 // 2
end
return s
end
function list_add(list_val1, list_val2)
local result = {}
local pow2 = math.max(list_val1.p, list_val2.p)
result.p = pow2
while pow2 > 0 do
result[pow2] = (list_val1[pow2] or 0) + (list_val2[pow2] or 0)
pow2 = pow2 // 2
end
return result
end
function string_add(s1, s2)
return list_to_string(list_add(string_to_list(s1), string_to_list(s2)))
end
Ý tưởng về cơ bản là phân tách chuỗi dựa trên các thành phần sức mạnh của hai chiều dài của nó, và sau đó coi chúng là các trường có thành phần bị thiếu đại diện cho 0 và mỗi thành phần không bị thiếu biểu thị các số từ 1 đến 256 ^ n, vì vậy tổng 256 ^ n + 1 giá trị. Sau đó, các đại diện này có thể được thêm modulo khôn ngoan thành phần 256 ^ n + 1.
Lưu ý: Việc triển khai Lua này sẽ có các vấn đề tràn số đối với các chuỗi có kích thước lớn hơn 7. Nhưng bộ chuỗi có độ dài 7 trở xuống được đóng lại dưới phần bổ sung này.
Hãy thử trực tuyến!