पायथन 3 , 177 170 163 130 बाइट्स
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
इसे ऑनलाइन आज़माएं!
-14 बाइट्स notjagan को धन्यवाद
-33 बाइट्स लीकी नून (और स्विच किए गए धीरज) के लिए धन्यवाद
मेरे पास पायथन में कुछ भी करने की कोशिश करने वाला कोई व्यवसाय नहीं है, लेकिन मैं लुआ का उपयोग नहीं करना चाहता था क्योंकि इस विधि को उचित लंबाई के डंक पर काम करने के लिए बड़े सटीक पूर्णांक की आवश्यकता होती है। (नोट: एल्गोरिथ्म अभी भी बहुत धीमा है, जब स्ट्रिंग की लंबाई बढ़ जाती है।) यह ज्यादातर सिर्फ एक उत्तर देने के लिए है;)
प्रत्येक स्ट्रिंग आत्म-व्युत्क्रम है, और खाली स्ट्रिंग पहचान है। यह बस स्ट्रिंग और गैर-नकारात्मक पूर्णांकों के बीच एक सरल आक्षेप के तहत एक्सआर करता है। sएक सहायक फ़ंक्शन है जो बायजेस्ट (केवल एक ही रास्ता) की गणना करता है, और dव्युत्क्रम है।
गैर-धीमा संस्करण (148 बाइट्स, लीकी नन के सौजन्य से):
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
इसे ऑनलाइन आज़माएं!
मैं एक समूह-सिद्धांत प्राइमर के लिए भी इसे हाइजैक करने जा रहा हूं।
किसी भी सही उल्टा होता है एक बाईं उलटा: निवेश संबंधी निर्णय निर्माताओं (क) + एक = (निवेश संबंधी निर्णय निर्माताओं (क) + क) + ई = (निवेश संबंधी निर्णय निर्माताओं (क) + एक) + (निवेश संबंधी निर्णय निर्माताओं (क) + निवेश संबंधी निर्णय निर्माताओं (निवेश संबंधी निर्णय निर्माताओं (क))) = inv (a) + (a + inv (a)) + inv (inv (a)) = (inv (a) + e) + inv (निमंत्रण (a)) = inv (a) + inv (निमंत्रण (a) ) = ई
यह भी मतलब है कि एक का एक उल्टा होता है निवेश संबंधी निर्णय निर्माताओं (क) ।
कोई भी सही पहचान एक बाईं पहचान है: e + a = (a + inv (a)) + a = a (inv (a) + a) = a
पहचान विशिष्ट है, जिसे अन्य पहचान f : e = e + f = f दिया गया है
यदि a + x = a तो x = e : x = e + x = ((a) + a + + x = inv (a) + (a + x) = inv (a) + a = e
व्युत्क्रम अद्वितीय हैं, यदि a + x = e फिर: x = e + x = ((a) + a + + x = inv (a) + (a + x) = inv (a) + e = inv (a) )
सबूतों के बाद प्रस्तावित समाधानों के लिए काउंटरटेक्मैंस का निर्माण करना काफी आसान होना चाहिए जो इन प्रस्तावों को संतुष्ट नहीं करते हैं।
यहाँ एक और अधिक प्राकृतिक एल्गोरिथ्म है जिसे मैंने लागू किया (लेकिन गोल्फ नहीं) लुआ में । शायद यह किसी को एक विचार देगा।
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
मूल रूप से इसकी लंबाई के दो-दो घटकों की शक्ति के आधार पर स्ट्रिंग को विभाजित करने के लिए विचार किया जाता है, और फिर इन्हें एक अनुपलब्ध घटक के साथ फ़ील्ड के रूप में माना जाता है, और प्रत्येक गैर-लापता घटक 1 से 256 ^ n तक की संख्या का प्रतिनिधित्व करता है, तो 256 ^ n + 1 मान। फिर इन अभ्यावेदन को घटक-वार मोडुलो 256 ^ n + 1 जोड़ा जा सकता है।
नोट: इस Lua कार्यान्वयन में 7. से अधिक आकार के तारों के लिए संख्यात्मक अतिप्रवाह समस्याएं होंगी। लेकिन 7 या उससे कम लंबाई के तारों का सेट इस अतिरिक्त के तहत बंद है।
इसे ऑनलाइन आज़माएं!