जादुई मोदुलो वर्ग

Question

मैं नंबर थ्योरी का बहुत बड़ा प्रशंसक हूं। संख्या सिद्धांत में एक बड़ी चीज मॉड्यूलर अंकगणित है; परिभाषा जा रहा है $a\equiv b\mod m$ यदि और केवल यदि $m\mid a-b$ । करने के लिए एक मजेदार बात शक्तियों को बढ़ा रही है: खासकर जब मापांक एक प्रमुख संख्या है। विशेष रूप से, यह साबित हो गया है कि यदि $a$ और $m$ अपेक्षाकृत अभाज्य हैं ( $1$ अलावा कोई भी सामान्य कारक साझा नहीं करते हैं ) तो एक नंबर $e$ मौजूद है जैसे कि $a^e\equiv 1\mod m$ ।

मैं बताऊंगा कि व्यायाम एक उदाहरण से क्या होता है। आइए एक मापांक । कार्यक्रम या फ़ंक्शन का एक संभावित आउटपुट होगा:$m=7$

3 2 6 4 5 1
2 4 1 2 4 1
6 1 6 1 6 1
4 2 1 4 2 1
5 4 6 2 3 1
1 1 1 1 1 1

प्रत्येक पंक्ति उस पंक्ति में पहले नंबर की शक्तियों की एक सूची है: पहली पंक्ति , जो बराबर है मोडुलो । ऊपर के वर्ग की दूसरी पंक्ति , वगैरह, अंतिम पंक्ति तक की शक्तियां हैं, जो केवल शक्तियां हैं ।$3, 3^2, 3^3, \cdots, 3^6$$3,2,6,4,5,1$$7$$2$$1$

यह एक जादुई मोड्यूल वर्ग है क्योंकि:

• वर्ग सममित है; अर्थात, th कॉलम th रो के समान है।$i$$i$
• सभी मान से कम से कम एक बार दिखाई देते हैं।$1$$m-1$

नीचे लिए केवल अन्य मान्य आउटपुट है , जो शक्तियों से शुरू होता है :$m=7$$5$

5 4 6 2 3 1
4 2 1 4 2 1
6 1 6 1 6 1
2 4 1 2 4 1
3 2 6 4 5 1
1 1 1 1 1 1

चुनौती

एक फ़ंक्शन या प्रोग्राम बनाएं जो एक प्रमुख pआउटपुट को एक जादुई मोडुलो स्क्वायर देता है, अर्थात, साइड लंबाई के साथ एक वर्ग p-1, जैसे कि प्रत्येक पंक्ति पंक्ति में पहले तत्व की लगातार शक्तियों की एक सूची है, और कॉलम के लिए भी। सभी संख्याओं के बीच 0और pहोना चाहिए, और वर्ग में केवल उस सीमा में संख्याएँ हो सकती हैं।

इनपुट एक संख्या या एक स्ट्रिंग है, और आउटपुट ascii, एक मैट्रिक्स, सरणियों का एक सरणी (कोई भी उचित प्रारूप) हो सकता है।

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

Comments

संबंधित OEIS अनुक्रम: A001918 (शीर्ष-बाएं कोने के लिए सबसे कम वैध मूल्य)।

— अरनौलद

" मैं बताऊंगा कि व्यायाम एक उदाहरण से होता है। " नहीं। इसे अपनी शर्तों में समझाइए और फिर उदाहरण देकर समझाइए। मुझे लगता है कि आप जो पूछ रहे हैं वह एक मैट्रिक्स जैसे कि एक आदिम रूट मोडुलो और , लेकिन यह उस विनिर्देश को सवाल से निकालने का बहुत प्रयास है जैसा कि यह खड़ा है। $A$$A_{1,1}$$p$$A_{i,j} = A_{1,1}{}^{ij} \bmod p$

— पीटर टेलर

@PeterTaylor सच है, और यही मेरा मतलब है, लेकिन सबसे पहले, जो अन्वेषण मज़ा का हिस्सा खराब करता है, और दूसरा, यह आदिम जड़ों और मॉड्यूलर अंकगणित के बारे में ज्ञान पर निर्भर करता है। मैं चाहता था कि यह सवाल व्यापक दर्शकों द्वारा जवाबदेह हो, इसलिए मैंने यह समझाने की कोशिश की कि आसान शब्दों में मेरा क्या मतलब है।

— वृजथेलेल

Answer 1

जेली , 13 10 बाइट्स

-3 निक कैनेडी को धन्यवाद

^{की तरह लगता है बार-बार कोड होना चाहिए गोल्फ में सक्षम है, लेकिन मैं है प्रबंधन नहीं किया d यह ...}

*€Ṗ%µQƑƇḢị

इसे ऑनलाइन आज़माएं! (फुटर के रूप में सुंदर प्रारूप)

कैसे?

*€Ṗ%µQƑƇḢị - Link: integer, p
 €         - for each n in [1..p]
*          -   exponentiate with:
  Ṗ        -     pop = [1..p-1]
           - ...i.e [[1^1,1^2,...,1^(p-1)],[2^1,2^2,...,2^(p-1)],...,[....,p^(p-1)]]
   %       - modulo p
    µ      - start a new monadic chain (call that list of lists X)
       Ƈ   - keep those which:
      Ƒ    -   are invariant under:
     Q     -     de-duplicate
        Ḣ  - head
         ị - index into the list of lists X

Comments

: यहाँ एक 10 है tio.run/##ASMA3P9qZWxsef//KuKCrOG5liXCtVHGkcaH4bii4buL/8OHR///...

— निक कैनेडी

आह, अब मुझे धीमा लग रहा है? धन्यवाद!

— जोनाथन एलन

Answer 2

चारकोल , 36 बाइट्स

≔Ｅ…¹θ﹪Ｘι…¹θＩθηＥ⊟Φη⁼¹№ι¹⪫Ｅ§η⊖ι◧ＩλＬ⊖θ 

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। नोट: अनुगामी स्थान। स्पष्टीकरण:

≔Ｅ…¹θ﹪Ｘι…¹θＩθη

एक बनाएं p-1द्वारा p-1की शक्तियों की सरणी 1..p-1सूचकांक करने के लिए 1..p-1(सापेक्ष p)।

Ｅ⊟Φη⁼¹№ι¹

उन पंक्तियों में से एक पर मैप करें जिनमें बिल्कुल एक है 1।

⪫Ｅ§η⊖ι◧ＩλＬ⊖θ 

चयनित पंक्ति द्वारा दिए गए क्रम में पंक्तियों को फिर से व्यवस्थित करें और आउटपुट को प्रारूपित करें।

Answer 3

जे , ^{35 32} 31 बाइट्स

[:(/:0/:@{]\:#@~."1)]|^/~@}.@i.

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

Answer 4

वोल्फ्राम लैंग्वेज (गणितज्ञ) , 46 43 बाइट्स

Mod[PrimitiveRoot@#^Array[1##&,{#,#}-1],#]&

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

-3 एलेफाल्फा के लिए धन्यवाद

Answer 5

जावास्क्रिप्ट (ईएस 7),  91  86 बाइट्स

सापेक्ष लागू करने से पहले शक्तियों गणना करने के लिए इस संस्करण में प्रयास और के लिए असफल हो जायेगी $p\ge11$ परिशुद्धता के नुकसान की वजह से। यह अन्यथा नीचे टिप्पणी संस्करण के रूप में एक ही तर्क का उपयोग कर रहा है।

f=(p,k)=>(g=k=>[...Array(i=p-1)].map(_=>k**++i%p))(k).sort()[1]>1?g(k).map(g):f(p,-~k)

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

---

जावास्क्रिप्ट (ईएस 6),  92  87 बाइट्स

यह संस्करण उच्च इनपुट मूल्यों का समर्थन करने के लिए मॉड्यूलर घातांक का उपयोग करता है।

f=(p,k)=>(g=k=>[...Array(p-1)].map(_=>n=n*k%p,n=1))(k).sort()[1]>1?g(k).map(g):f(p,-~k)

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

कैसे?

पहली पंक्ति ढूँढना

$1\le k<p$$g$$a_k(n)=k^n\bmod p$$1\le n<p$

g = k =>              // k = input
  [...Array(p - 1)]   // generate an array of size p - 1
  .map(_ =>           // for each entry in there:
    n = n * k % p,    //   update n to (n * k) mod p
    n = 1             //   starting with n = 1
  )                   // end of map()

$k$$n$$a_k(n)=1$$1$

g(k).sort()[1] > 1

यह शाब्दिक क्रम में भी काम करता है - जो कि डिफ़ॉल्ट व्यवहार है sort()- क्योंकि:

• $1$
• $1$$1$

उदाहरण:

$p=17$

• $k=1$
  • $a_1=[ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 ]$
  • [ 1 , 1 के रूप में क्रमबद्ध$[ 1, \color{red}1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 ]$
• $k=2$
  • $a_2=[ 2, 4, 8, 16, 15, 13, 9, 1, 2, 4, 8, 16, 15, 13, 9, 1 ]$
  • [ 1 , 1 , 13 के रूप में क्रमबद्ध$[ 1, \color{red}1, 13, 13, 15, 15, 16, 16, 2, 2, 4, 4, 8, 8, 9, 9 ]$
• $k=3$
  • $a_3=[ 3, 9, 10, 13, 5, 15, 11, 16, 14, 8, 7, 4, 12, 2, 6, 1 ]$
  • [ 1 , 10 , 11 , 12 के रूप में क्रमबद्ध$[ 1, \color{red}{10}, 11, 12, 13, 14, 15, 16, 2, 3, 4, 5, 6, 7, 8, 9 ]$

मैट्रिक्स का निर्माण

$k$$g(k)$$g$$g(k)$

इस भाग को केवल इस प्रकार लिखा जा सकता है:

g(k).map(g)

Comments

.indexOf(1)>p-33 बाइट्स बचाता है .every।

— नील

@ नील धन्यवाद। लेकिन मुझे एक अच्छी रात की नींद के बाद एक छोटा रास्ता मिल गया है। :)

— अरनौल

Answer 6

Zsh , 117 90 बाइट्स

b=$1
c=(eval set -- '$[x**'{1..$[b-1]}%b\])
for ((;${#${(u)@}}-b+1;++x))$c
for x;$c&&<<<$@

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

भगवान मेरी आत्मा पर दया करे। यहाँ बहुत सारे बुरे व्यवहार हैं जो मुझे लपेटे हुए हैं, मुझे कम से कम सबसे बड़े अपराधी की व्याख्या करने दें:

c=(eval set -- '$[x**'{1..$[b-1]}%b\])
                      {1..$[b-1]}        # brace expansion, expands immediately
               '$[x**'           %b\]    # string literals, expand during eval
   eval set --                           # sets the positional parameters
c=(                                   )  # defines c to the words contained

इसके लिए उदाहरण b=4:

c=(eval set -- '$[x**'{1..$[b-1]}%b\])
c=(eval set -- '$[x**'{1..3}%b\]     )                # $[b-1] => 3
c=(eval set -- '$[x**1%b]' '$[x**2%b]' '$[x**3%b]' )  # brace expansion

अंत में, जहां $cकार्यक्रम के बाकी हिस्सों में दिखाई देता है, सरणी तत्वों का मूल्यांकन किया जाता है eval set -- ....।

अंत में, ${#${(u)@}}अनूठे तत्वों को गिनता है जो कि अंतरमानीय मापदंडों को मापता है (यानी: क्या कोई चक्र है / क्या वहाँ हैं 1?)

नीचे 117 बाइट उत्तर के लिए प्रासंगिक टिप्पणियां।

---

हमें दूर करने के लिए चुनौतियां:

• कोई बहुआयामी या नेस्टेड सरणियाँ नहीं। इसके बजाय हम स्ट्रिंग्स को प्रिंट करते हैं क्योंकि हम उन्हें एक लूप में प्राप्त करते हैं।
• यदि किसी पंक्ति में एकाधिक 1s हैं तो परीक्षण के विकल्प:
  • ${#${(M)a:#1}: :#मिलान हटाता है, और (M)मैच को उलट देता है। तो, यह सरणी में s की संख्या ( ${# }) के लिए विस्तारित होगा 1। दुर्भाग्य से यह विस्तार हमारे द्वारा उपयोग किए जाने वाले लूप के लिए अंकगणित के साथ अच्छी तरह से नहीं खेलता है। यदि यह किया जाता है, तो यह संभावित रूप से एक बाइट को बचा सकता है।
  • ${${:-1}:*a}: यह सिंगलटन 1और सेट के बीच का सेट चौराहा है a। 1यदि यह सरणी में पाया जाता है तो यह एकल तक विस्तृत होगा । इस विकल्प का उपयोग करते हुए, हम यहां एक चरित्र को बचाते हैं, लेकिन 1अंतिम पंक्ति और कॉलम में अंत तक एस को जोड़ने के लिए कुल मिलाकर 1 खो देते हैं ।

f(){ # f [element] [modular base], puts powers up to n-2 into array $a
    a=()
    for i ({1..$[$2-2]})
        a+=($[$1**i%$2])
}
a=(1)                     # put 1 in a to force first loop iteration
for ((;${${:-1}:*a};))    # test for 1 in array $a
    f $[++x] $1           # increment x, iterate through all elements mod $1
for y ($a 1){             # for all elements in the [last array, 1]
    f $y $1               # put that row in $a
    <<<$a\ 1              # print out $a with 1 appended (space-delimited string)
}

Answer 7

पर्ल 6 , 65 57 बाइट्स

{.[|.first(*.Set+2>$_)]}o{.&{@=(($++X**1..^$_)X%$_)xx$_}}

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

संभवत: स्क्वायर को स्वयं आउटपुट करने का कोई तरीका है, लेकिन यह इस प्रक्रिया को प्रश्न में उल्लिखित करता है, पहली सूची में उनके पदों द्वारा सूचियों को क्रमबद्ध करता है जो केवल 1 से इनपुट -1 का क्रमचय है। सूचियों की सूची के रूप में लौटाता है।

BTW, आसपास बहुत सी जॉकींग है, जो पर्ल बनाम एरेस और अनाम चरों से जुड़े पर्ल 6 की कुछ कष्टप्रद सीमाओं के आसपास जाने की कोशिश कर रही है।

स्पष्टीकरण:

                               $++               xx$_    # Map 0 to i-1 to
                              (   X**1..^$_)             # n, n^2, n^3... n^(i-1)
                             (              X%$_)        # All modulo i
{                      }o{.&{                        }}  # Pass to the next function
 .[                   ]    # Index into that list of lists
   |.first(          )     # The list of the first list that
           *.Set+2>$_        # Has all the elements in the range 1 to i-1

Answer 8

अजगर 2 , 108 बाइट्स

def f(p):R=range(1,p);return[m for m in[[[j**(k*i)%p for i in R]for k in R]for j in R]if sorted(m[0])==R][0]

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

Comments

क्या आप printवापसी के बजाय नहीं कर सकते ?

— अज्ञानता का अवतार

Answer 9

05AB1E , 19 16 बाइट्स

LεI<LmI%}ÐΘOÏн<è

-3 बाइट्स @Emigna की बदौलत ।

इसे ऑनलाइन आज़माएं (पाद 2 डी सूची को सुंदर रूप से प्रिंट करने के लिए है)।

स्पष्टीकरण:

L          # Create a list in the range [1, (implicit) input]
 ε         # Map each number `y` in the list to:
  I<L      #  Create a list in the range [1, input-1]
     m     #  Get number `y` to the power of each number in this list
      I%   #  Take modulo-input on each number
 }Ð        # After the map: triplicate this modified matrix
   ΘO      # Get the amount of 1s in each row
     Ï     # And only leave the rows with exactly one 1
      н    # Then only leave the first row which contains a single 1
       <   # Decrease each value by 1 to make it 0-indexed
        è  # And index each into the rows of the modified matrix to create a new matrix
           # (which is output implicitly as result)

Comments

LεI<LmI%}ÐΘOÏн<è16 बाइट्स के लिए।

— एमिग्ना

@Emigna धन्यवाद! मुझे एहसास नहीं था <èकि मेरे पास पर्याप्त UΣXykथा।

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

Answer 10

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

(s=Thread@Mod[x^#&/@(x=Range[#-1]),#])[[#&@@Select[s,Sort@#==x&]]]&

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

Answer 11

परी / जीपी , 48 बाइट्स

n->lift(matrix(n-1,n-1,i,j,znprimroot(n)^(i*j)))

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

Answer 12

एपीएल (एनएआरएस), 29 चार्ट, 58 बाइट्स

{k←⍵∣⍺*⍳⍵-1⋄⊃{m∣k*⍵}¨⍳¯1+m←⍵}

परीक्षा:

  f←{k←⍵∣⍺*⍳⍵-1⋄⊃{m∣k*⍵}¨⍳¯1+m←⍵}
  3 f 7
3 2 6 4 5 1
2 4 1 2 4 1
6 1 6 1 6 1
4 2 1 4 2 1
5 4 6 2 3 1
1 1 1 1 1 1
  5 f 7
5 4 6 2 3 1
4 2 1 4 2 1
6 1 6 1 6 1
2 4 1 2 4 1
3 2 6 4 5 1
1 1 1 1 1 1