256 तत्वों के साथ एक क्षेत्र को परिभाषित करें

Question

गणित में एक क्षेत्र संख्याओं का एक समूह है, इसके अलावा और उस पर परिभाषित कई गुणा संचालन, जैसे कि वे कुछ स्वयंसिद्धों को संतुष्ट करते हैं (विकिपीडिया में वर्णित है; नीचे भी देखें)।

एक परिमित क्षेत्र में p ⁿ तत्व हो सकते हैं , जहां pएक अभाज्य संख्या है, और nएक प्राकृतिक संख्या है। इस चुनौती में, चलो लेते हैं p = 2और n = 8, इसलिए चलो 256 तत्वों के साथ एक क्षेत्र बनाते हैं।

फ़ील्ड के तत्वों में एक श्रेणी में लगातार पूर्णांक होना चाहिए 0और 1:

• -128 ... 127
• 0 ... 255
• या ऐसी कोई भी रेंज

दो कार्यों (या कार्यक्रमों को परिभाषित करें , यदि यह आसान है), a(x,y)अमूर्त "जोड़" के लिए, और m(x,y)अमूर्त "गुणन" के लिए, जैसे कि वे क्षेत्र स्वयंसिद्धों को संतुष्ट करते हैं:

• संगति: a(x,y)और m(x,y)एक ही परिणाम जब एक ही तर्क के साथ कहा जाता है
• क्लोजनेस: परिणाम aऔर mसंबंधित रेंज में एक पूर्णांक है
• संबद्धता: किसी भी x, yऔर zसीमा में, a(a(x,y),z)के बराबर है a(x,a(y,z)); उसी के लिएm
• कम्यूटिविटी: किसी भी xऔर yरेंज में, a(x,y)के बराबर है a(y,x); उसी के लिएm
• वितरण: किसी भी x, yऔर zसीमा में, m(x,a(y,z))के बराबर हैa(m(x,y),m(x,z))
• तटस्थ तत्व: xसीमा में किसी भी के लिए, a(0,x)के बराबर है xऔर m(1,x)समान हैx
• निषेध: किसी भी के लिए xरेंज में, इस तरह के मौजूद है yकि a(x,y)है0
• उलटा: किसी भी के लिए x≠0रेंज में, इस तरह के मौजूद है yकि m(x,y)है1

नाम aऔर mसिर्फ उदाहरण हैं; आप अन्य नामों या अनाम कार्यों का उपयोग कर सकते हैं। आपके उत्तर के स्कोर के लिए बाइट-लंबाई का योग है aऔर m।

यदि आप एक अंतर्निहित फ़ंक्शन का उपयोग करते हैं, तो कृपया उन शब्दों का भी वर्णन करें जो इसे उत्पन्न करते हैं (जैसे एक गुणन तालिका प्रदान करते हैं)।

Comments

@LeakyNun "जोड़" केवल एक अमूर्त ऑपरेशन है जो उपरोक्त गुणों को संतुष्ट करता है। इसके लिए कोई आवश्यकता नहीं है a(2,1) = 3, आप a(2,1) = 5तब तक कर सकते हैं जब तक कि उपरोक्त स्वयंसिद्ध संतुष्ट न हों। aआपके पास तर्कसंगत संख्याओं के क्षेत्र से उपयोग किए जाने वाले सामान्य जोड़ के साथ कुछ भी करने की आवश्यकता नहीं है।

— मार्टिन एंडर

एक कम्यूटेटिव रिंग तुच्छ है। एक क्षेत्र ... इतना आसान नहीं है।

— नील

क्या कुछ गड़बड़ है a=+ m=×?

— अदम

@ Adám Yes - 2 का उलटा नहीं होगा अगरm=×

— Sp3000

संबंधित

— पीटर टेलर

Answer 1

इंटेल x86-64 + AVX-512 + GFNI, 11 बाइट्स

add:
    C5 F0 57 C0     # vxorps     xmm0, xmm1, xmm0
    C3              # ret
mul:
    C4 E2 79 CF C1  # vgf2p8mulb xmm0, xmm0, xmm1
    C3              # ret

GF2P8MULBआइस लेक सीपीयू पर नए निर्देश का उपयोग करता है ।

निर्देश परिमित फ़ील्ड GF (2 ⁸ ) में तत्वों को पहले स्रोत ऑपरेंड में एक बाइट (फ़ील्ड तत्व) पर और दूसरे स्रोत ऑपरेंड में संबंधित बाइट में गुणा करता है । फ़ील्ड GF (2 ⁸ ) को बहुपद प्रतिनिधित्व में कमी बहुपद x ⁸ + x ⁴ + x ³ + x + 1 के साथ दर्शाया गया है ।

Answer 2

पायथन 2, 11 + 45 = 56 बाइट्स

अतिरिक्त (11 बाइट्स):

int.__xor__

गुणन (45 बाइट्स):

m=lambda x,y:y and m(x*2^x/128*283,y/2)^y%2*x

रेंज में इनपुट नंबर लेता है [0 ... 255]। इसके अलावा बस थोड़ा सा XOR है, गुणन रूसी किसान के साथ GF2 में गुणांक के साथ बहुपद का गुणन है ।

और जाँच के लिए:

a=int.__xor__
m=lambda x,y:y and m(x*2^x/128*283,y/2)^y%2*x

for x in range(256):
    assert a(0,x) == a(x,0) == x
    assert m(1,x) == m(x,1) == x

    assert any(a(x,y) == 0 for y in range(256))

    if x != 0:
        assert any(m(x,y) == 1 for y in range(256))

    for y in range(256):
        assert 0 <= a(x,y) < 256
        assert 0 <= m(x,y) < 256
        assert a(x,y) == a(y,x)
        assert m(x,y) == m(y,x)

        for z in range(256):
            assert a(a(x,y),z) == a(x,a(y,z))
            assert m(m(x,y),z) == m(x,m(y,z))
            assert m(x,a(y,z)) == a(m(x,y), m(x,z))

Comments

हममें से एक को बदलना होगा: P

— Mego

@ मेगो हाह, ठीक है ... मैं कोशिश करूँगा और देखूंगा कि क्या मुझे कोई अन्य दृष्टिकोण मिल सकता है। हालांकि हराना मुश्किल हो सकता है।

— Sp3000

यह किस बहुपद पर आधारित है?

— १

@Liceice अब मुझे पता है कि मैं बहुपद को आसानी से पा सकता हूं m(2,128)जिसके परिणाम २ I = २ --३ - २५६ हैं, इसलिए आप सही हैं और बहुपद है x^8 + x^4 + x^3 + x + 1।

— फ़ेरसम

@LSpice नील के जवाब में वह एल्गोरिथ्म के लिए एक स्रोत के रूप में एक विकिपीडिया पृष्ठ देता है, इसलिए शायद हर कोई इसे पढ़ता है। लेकिन यह कोड गोल्फ के लिए वैसे भी सबसे स्पष्ट विकल्प है क्योंकि यह इस प्रतिनिधित्व में डिग्री 8 का सबसे छोटा इरेड्यूसबल बहुपद है।

— feersum

Answer 3

जावास्क्रिप्ट (ईएस 6), 10 + 49 = 59 बाइट्स

a=(x,y)=>x^y
m=(x,y,p=0)=>x?m(x>>1,2*y^283*(y>>7),p^y*(x&1)):p

डोमेन 0 ... 255 है। स्रोत ।

Comments

आपको संभवतः उस सीमा को निर्दिष्ट करना चाहिए जिसका आप उपयोग कर रहे हैं।

— मार्टिन एंडर

Answer 4

हून , 22 बाइट्स

[dif pro]:(ga 8 283 3)

हून में पहले से ही एक फ़ंक्शन ++gaहै जो एईएस कार्यान्वयन में उपयोग के लिए गैलोज़ फील्ड्स बनाता है। यह दो कार्यक्रमों का उपयोग करने के बजाय, दो कार्यों का एक हिस्सा देता है।

डोमेन में कार्य करता है [0...255]

परीक्षण सूट:

=+  f=(ga 8 283 3)
=+  n=(gulf 0 255)

=+  a=dif:f
=+  m=pro:f

=+  %+  turn  n
    |=  x/@
    ?>  =((a 0 x) x)
    ?>  =((m 1 x) x)
    ~&  outer+x

    %+  turn  n
      |=  y/@
      ?>  =((a x y) (a y x))
      ?>  &((lte 0 (a x y)) (lte (a x y) 255))
      ?>  &((lte 0 (m x y)) (lte (m x y) 255))

      %+  turn  n
        |=  z/@
        ?>  =((a (a x y) z) (a x (a y z)))
        ?>  =((m x (a y z)) (a (m x y) (m x z)))
        ~
"ok"

गुणन तालिका पोस्ट करना विशाल होगा, इसलिए यहां कुछ यादृच्छिक परीक्षण किए गए हैं:

20x148=229
61x189=143
111x239=181
163x36=29
193x40=1

Answer 5

IA-32 मशीन कोड, 22 बाइट्स

"गुणन", 18 बाइट्स:

33 c0 92 d1 e9 73 02 33 d0 d0 e0 73 02 34 1b 41
e2 f1

"अतिरिक्त", 4 बाइट्स:

92 33 c1 c3

यह नियम थोड़ा बढ़ाता है: "गुणन" कोड में फ़ंक्शन निकास कोड का अभाव है; यह "जोड़" कोड पर निर्भर करता है कि मेमोरी ठीक इसके बाद में है, इसलिए यह "फॉल-थ्रू" हो सकता है। मैंने इसे कोड आकार में 1 बाइट कम करने के लिए किया था।

स्रोत कोड ( mlMS Visual Studio द्वारा इकट्ठा किया जा सकता है ):

    TITLE   x

PUBLIC @m@8
PUBLIC @a@8

_TEXT   SEGMENT USE32
@m@8    PROC
    xor eax, eax;
    xchg eax, edx;
myloop:
    shr ecx, 1
    jnc sk1
    xor edx, eax
sk1:
    shl al, 1
    jnc sk2
    xor al, 1bh
sk2:
    inc ecx
    loop myloop
@m@8 endp

@a@8 proc
    xchg eax, edx;
    xor eax, ecx
    ret
@a@8    ENDP
_text ENDS
END

एल्गोरिथ्म मानक एक है, जिसमें सामान्य बहुपद शामिल है x^8 + x^4 + x^3 + x + 1, जिसे हेक्साडेसिमल संख्या द्वारा दर्शाया गया है 1b। "गुणन" कोड परिणाम को जमा करता है edx। जब किया जाता है, तो यह अतिरिक्त कोड के माध्यम से गिरता है, जो इसे eax(रिटर्न मान रखने के लिए पारंपरिक रजिस्टर) में ले जाता है; के xorसाथ ecxएक नहीं सेशन है, क्योंकि उस बिंदु परecx पर मंजूरी दे दी है।

एक अजीब विशेषता पाश है। इसके बजाय शून्य के लिए जाँच कर रहा है

cmp ecx, 0
jne myloop

यह समर्पित loopनिर्देश का उपयोग करता है । लेकिन यह निर्देश 0. की तुलना करने से पहले लूप "काउंटर" को कम कर देता है। इसके लिए क्षतिपूर्ति करने के लिए, कोड को loopनिर्देश का उपयोग करने से पहले बढ़ाता है ।

Answer 6

Mathematica 155 बाइट्स

f[y_]:=Total[x^Reverse@Range[0,Log[2,y]]*RealDigits[y,2][[1]]];o[q_,c_,d_]:=FromDigits[Reverse@Mod[CoefficientList[PolynomialMod[q[f@c,f@d],f@283],x],2],2]

कार्यान्वयन

(*
  in: o[Times, 202, 83]    out: 1
  in: o[Plus, 202, 83]     out: 153
*)

अतिरिक्त जाँच:

(*
  in: BitXor[202, 83]      out: 153
*)

अधिक:

(*
  in: o[Times, #, #2] & @@@ {{20, 148}, {61, 189}, {111, 239}, {163, 36}, {193, 40}}
  out: {229, 143, 181, 29, 1}
*)

एनबी के {283, 285, 299, 301, 313, 319, 333, 351, 355, 357, 361, 369, 375, 379, 391, 395, 397, 415, 419, 425, 433, 445, 451, 463, 471, 477, 487, 499, 501, 505}स्थान पर किसी भी उपयोग करने में सक्षम होना चाहिए 283।

Comments

खैर, यहाँ 13 बाइट्स कम हैं: ±y_:=Total[#&@@y~RealDigits~2x^Reverse@Range[0,2~Log~y]];p[q_,c_,d_]:=Fold[#+##&,Reverse@CoefficientList[q[±c,±d]~PolynomialMod~±283,x]~Mod~2](माना जाता है कि स्रोत आईएसओ 8859-1 में इनकोडिंग है)

— मार्टिन एंडर

@MartinEnder नहीं काफी यकीन है कि कैसे अपने सुझाव को लागू करने

— मार्टिन

@martin आप यह वास्तव में पहले की तरह उपयोग कर सकते हैं, मैं सिर्फ का उपयोग किया है ±के बजाय fऔर pके बजाय o(बेशक आप रख सकते हैं कि के रूप में o, मैं सिर्फ इस्तेमाल किया pतो मैं उन दोनों का परीक्षण कर सकते हैं), और उसके बाद बचाया कुछ और मानक के साथ बाइट्स सिंटैक्ट शुगर ट्रिक।

— मार्टिन एंडर

@MartinEnder को वैसे ±ही काम करने को मिल सकता है f, लेकिन नहीं p... मुझे यकीन नहीं है कि मैं कहाँ गलत हूँ

— Martin

यदि आप इसे सीधे टिप्पणी से कॉपी करते हैं, तो आपके ब्राउज़र को टिप्पणी में लाइन ब्रेक प्रदर्शित करने पर कुछ अनपेक्षित वर्ण हो सकते हैं। कॉपी करने के बाद उस स्थिति के चारों ओर के पात्रों को हटा दें और उन्हें फिर से लिखें। अगर वह ऐसा नहीं करता है, तो मुझे यकीन नहीं है कि समस्या कहां है ..

— मार्टिन एंडर

Answer 7

ब्रेनफक, 28 वर्ण

सौभाग्य से, मानक ब्रेनफुक 256 modul सब कुछ करता है।

जोड़: [->+<]मान लेता है कि इनपुट टेप के पहले दो पदों पर हैं, आउटपुट को स्थिति 0 पर रखता है

गुणन:, [->[->+>+<<]>[-<+>]<<]मानता है कि इनपुट टेप के पहले दो पदों पर हैं, आउटपुट को स्थिति 3 में रखता है