14

डिहेड्रल समूह है समरूपता समूह वर्ग, है कि चाल है कि रोटेशन और प्रतिबिंब के माध्यम से ही करने के लिए एक वर्ग को बदलने की। इसमें 8 तत्व शामिल हैं: 0, 90, 180 और 270 डिग्री तक घुमाव, और क्षैतिज, ऊर्ध्वाधर और दो विकर्ण कुल्हाड़ियों के प्रतिबिंब। $D_4$

छवियों लैरी पहेली द्वारा इस सुंदर पृष्ठ से सभी कर रहे हैं ।

यह चुनौती इन चालों को तैयार करने के बारे में है: दो चालें दी गई हैं, इस कदम का उत्पादन जो उन्हें एक के बाद एक करने के बराबर है। मिसाल के तौर पर, मूव 4 करने के बाद 7 मूव 5 करने के समान है।

ध्यान दें कि 4 को स्थानांतरित करने के क्रम को फिर से चालू करें 7 के बजाय 7 का उत्पादन करें।

परिणाम नीचे सारणीबद्ध हैं; यह समूह की केली तालिका है । उदाहरण के लिए, इनपुट को आउटपुट का उत्पादन करना चाहिए । $D_4$ $7, 4$ $5$

\begin{matrix} \begin{matrix} 1 & 2 & 3 & 4 & 5 & 6 & 7 & 8 \end{matrix} \\ \begin{matrix} 1 \\ 2 \\ 3 \\ 4 \\ 5 \\ 6 \\ 7 \\ 8 \end{matrix} & \begin{matrix} 1 & 2 & 3 & 4 & 5 & 6 & 7 & 8 \\ 2 & 3 & 4 & 1 & 8 & 7 & 5 & 6 \\ 3 & 4 & 1 & 2 & 6 & 5 & 8 & 7 \\ 4 & 1 & 2 & 3 & 7 & 8 & 6 & 5 \\ 5 & 7 & 6 & 8 & 1 & 3 & 2 & 4 \\ 6 & 8 & 5 & 7 & 3 & 1 & 4 & 2 \\ 7 & 6 & 8 & 5 & 4 & 2 & 1 & 3 \\ 8 & 5 & 7 & 6 & 2 & 4 & 3 & 1 \end{matrix} \end{matrix}

$\begin{array}{*{20}{c}} {} & {\begin{array}{*{20}{c}} 1 & 2 & 3 & 4 & 5 & 6 & 7 & 8 \\ \end{array} } \\ {\begin{array}{*{20}{c}} 1 \\ 2 \\ 3 \\ 4 \\ 5 \\ 6 \\ 7 \\ 8 \\ \end{array} } & {\boxed{\begin{array}{*{20}{c}} 1 & 2 & 3 & 4 & 5 & 6 & 7 & 8 \\ 2 & 3 & 4 & 1 & 8 & 7 & 5 & 6\\ 3 & 4 & 1 & 2 & 6 & 5 & 8 & 7\\ 4 & 1 & 2 & 3 & 7 & 8 & 6 & 5\\ 5 & 7 & 6 & 8 & 1 & 3 & 2 & 4\\ 6 & 8 & 5 & 7 & 3 & 1 & 4 & 2\\ 7 & 6 & 8 & 5 & 4 & 2 & 1 & 3\\ 8 & 5 & 7 & 6 & 2 & 4 & 3 & 1\\ \end{array} }} \\ \end{array}$

चुनौती

आपका लक्ष्य इस ऑपरेशन को यथासंभव कम बाइट्स में लागू करना है, लेकिन कोड के अलावा, आप उन लेबलों को भी चुनते हैं जो चाल 1 का प्रतिनिधित्व करते हैं। 8. लेबल 0 से 255 तक 8 अलग-अलग संख्याएँ होनी चाहिए , या 8 एक -बेटे उनके वर्णों का प्रतिनिधित्व करते हैं।

आपके कोड को आपके द्वारा चुने गए 8 में से दो लेबल दिए जाएंगे, और उन्हें उस लेबल को आउटपुट करना होगा जो उनकी संरचना से संबंधित है जो कि समूह । $D_4$

उदाहरण

मान लें कि आपने C, O, M, P, U, T, E, R को क्रमशः 8 से 1 चाल के लिए चुना है। फिर, आपके कोड को इस तालिका को लागू करना चाहिए।

\begin{matrix} \begin{matrix} C & O & M & P & U & T & E & R \end{matrix} \\ \begin{matrix} C \\ O \\ M \\ P \\ U \\ T \\ E \\ R \end{matrix} & \begin{matrix} C & O & M & P & U & T & E & R \\ O & M & P & C & R & E & U & T \\ M & P & C & O & T & U & R & E \\ P & C & O & M & E & R & T & U \\ U & E & T & R & C & M & O & P \\ T & R & U & E & M & C & P & O \\ E & T & R & U & P & O & C & M \\ R & U & E & T & O & P & M & C \end{matrix} \end{matrix}

$\begin{array}{*{20}{c}} {} & {\begin{array}{*{20}{c}} \, C \, & \, O \, & M \, & P \, & U \, & \, T \, & \, E \, & R \, \\ \end{array} } \\ {\begin{array}{*{20}{c}} C \\ O \\ M \\ P \\ U \\ T \\ E \\ R \\ \end{array} } & {\boxed{\begin{array}{*{20}{c}} C & O & M & P & U & T & E & R \\ O & M & P & C & R & E & U & T\\ M & P & C & O & T & U & R & E\\ P & C & O & M & E & R & T & U\\ U & E & T & R & C & M & O & P\\ T & R & U & E & M & C & P & O\\ E & T & R & U & P & O & C & M\\ R & U & E & T & O & P & M & C\\ \end{array} }} \\ \end{array}$

इनपुट्स E और P को देखते हुए, आपको U को आउटपुट करना चाहिए। आपके इनपुट हमेशा C, O, M, P, U, T, E, R में से दो अक्षर होंगे और आपका आउटपुट हमेशा इन अक्षरों में से एक होना चाहिए।

नकल के लिए पाठ तालिका

1 2 3 4 5 6 7 8
2 3 4 1 8 7 5 6
3 4 1 2 6 5 8 7
4 1 2 3 7 8 6 5
5 7 6 8 1 3 2 4
6 8 5 7 3 1 4 2
7 6 8 5 4 2 1 3
8 5 7 6 2 4 3 1

— XNOR
स्रोत

Your choice of labels doesn't count against your code length.विस्तृत मन? जैसा कि यह खड़ा है, मैं अपने कोड में मैट्रिक्स को हार्डकोड कर सकता हूं और दावा कर सकता हूं कि यह मेरे स्कोर के खिलाफ नहीं है।

— बेंजामिन यूरेखर्ट

2

@BenjaminUrquhart मैं कहने की कोशिश कर रहा था कि आपके कोड की लंबाई आपके कोड की लंबाई है, और कहते हैं, मल्टीडिजिट लेबल चुनने से कुछ अतिरिक्त खर्च नहीं होता है। ऐसा लगता है कि लाइन अधिक उपयोगी है, इसलिए मैं इसे हटा दूंगा।

— xnor

10

रूबी , 18 बाइट्स

->a,b{a+b*~0**a&7}

Ungolfed

->a,b{ (a+b*(-1)**a) % 8}  
# for operator precedence reasons, 
#-1 is represented as ~0 in the golfed version

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

निम्न कोडिंग संख्याओं का उपयोग करता है 0 से 7

कोड के मूल निवासी के लिए:

Native     Effect                    Codes per
Code                                 Question
0          rotate 0 anticlockwise    1C
1 /        flip in y=x               7E
2 /|       rotate 90 anticlockwise   2O
3 /|/      flip in x axis            5U
4 /|/|     rotate 180 anticlockwise  3M
5 /|/|/    flip in y=-x              8R
6 /|/|/|   rotate 270 anticlockwise  4P
7 /|/|/|/  flip in y axis            6T

प्रश्न के अनुसार

Native     Effect                    Codes per
Code                                 Question
0          rotate 0 anticlockwise    1C
2 /|       rotate 90 anticlockwise   2O
4 /|/|     rotate 180 anticlockwise  3M
6 /|/|/|   rotate 270 anticlockwise  4P
3 /|/      flip in x axis            5U
7 /|/|/|/  flip in y axis            6T
1 /        flip in y=x               7E
5 /|/|/    flip in y=-x              8R

व्याख्या

/लाइन में एक फ्लिप का प्रतिनिधित्व करता है y=xऔर |y अक्ष में एक फ्लिप प्रतिनिधित्व करता है।

यह इन दो पंक्तियों में समूह D4 की समानताएं के किसी भी उत्पन्न करने के लिए बारी-बारी से flipping द्वारा उदाहरण के लिए संभव है /इसके बाद से |देता है /|जो 90 डिग्री घड़ी की विपरीत दिशा से एक रोटेशन है।

लगातार फ़्लिप की कुल संख्या अंकगणितीय हेरफेर के लिए बहुत सुविधाजनक प्रतिनिधित्व देती है।

यदि पहला कदम एक घूर्णन है, तो हम बस फ़्लिप की संख्या जोड़ सकते हैं:

Rotate 90 degrees   +  Rotate 180 degrees = Rotate 270 degrees
/|                     /|/|                 /|/|/|

Rotate 90 degress   +  Flip in y=x        = Flip in x axis   
/|                    /                     /|/

यदि पहली चाल एक प्रतिबिंब है, तो हम पाते हैं कि हमारे पास कुछ समान प्रतिबिंब /और |प्रतीक हैं जो एक दूसरे के बगल में हैं। जैसा कि प्रतिबिंब स्वयं विलोम है हम एक-एक करके इन फ़्लिप को रद्द कर सकते हैं। इसलिए हमें एक चाल को दूसरे से घटाना होगा

Flip in x axis     +  Flip in y=x        = Rotate 90 degrees
/|/                   /                    /|/ / (cancels to) /|

Flip in x axis     +  Rotate 90 degrees  = Flip in y=x
/|/                   /|                   /|/ /| (cancels to ) /

— स्तर नदी सेंट
स्रोत

1

आप मॉड्यूलर अंकगणित के कारण के ~0साथ बदल सकते हैं 7।

— निएडजेककोब

महान विधि और स्पष्टीकरण! जिस तरह से फ़्लिप रद्द होता है वह वास्तव में स्पष्ट करता है कि लेबल या तो जोड़ते हैं या घटाते हैं।

— xnor

7

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

पूर्णांक को लेबल के रूप में उपयोग करना। $0, 5, 2, 7, 1, 3, 6, 4$

BitXor[##,2Mod[#,2]⌊#2/4⌋]&

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

स्पष्टीकरण:

group फ़ील्ड पर डिग्री तीन के यूनिट्रीअंगुलर मैट्रिक्स समूह के लिए आइसोमोर्फिक है : $D_4$ $\mathbb{F}_2$

D_{4} ≅ U (3, 2) := {(\begin{matrix} 1 & a & b \\ 0 & 1 & c \\ 0 & 0 & 1 \end{matrix}) ∣ a, b, c \in F_{2}} .

$D_4 \cong U(3,2) := \left\{\begin{pmatrix} 1 & a & b \\ 0 & 1 & c \\ 0 & 0 & 1 \end{pmatrix} \mid a,b,c \in \mathbb{F}_2\right\}.$

और हमारे पास है

(\begin{matrix} 1 & a_{1} & b_{1} \\ 0 & 1 & c_{1} \\ 0 & 0 & 1 \end{matrix}) \cdot (\begin{matrix} 1 & a_{2} & b_{2} \\ 0 & 1 & c_{2} \\ 0 & 0 & 1 \end{matrix}) = (\begin{matrix} 1 & a_{1} + a_{2} & b_{1} + b_{2} + a_{1} c_{2} \\ 0 & 1 & c_{1} + c_{2} \\ 0 & 0 & 1 \end{matrix}),

$\begin{pmatrix} 1 & a_1 & b_1 \\ 0 & 1 & c_1 \\ 0 & 0 & 1 \end{pmatrix} \cdot \begin{pmatrix} 1 & a_2 & b_2 \\ 0 & 1 & c_2 \\ 0 & 0 & 1 \end{pmatrix} = \begin{pmatrix} 1 & a_1+a_2 & b_1+b_2+a_1c_2 \\ 0 & 1 & c_1+c_2 \\ 0 & 0 & 1 \end{pmatrix},$

जिसे आसानी से बिटवाइज़ ऑपरेशन्स में लिखा जा सकता है।

— alephalpha
स्रोत

एक सुंदर व्युत्पत्ति - मुझे इस समरूपता के बारे में पता नहीं था।

— xnor

5

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

⌊#/4^IntegerDigits[#2,4,4]⌋~Mod~4~FromDigits~4&

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

लेबल का उपयोग करना {228, 57, 78, 147, 27, 177, 198, 108}।

ये {3210, 0321, 1032, 2103, 0123, 2301, 3012, 1230}आधार में हैं 4. सौभाग्य से, 256 = 4 ^ 4।

निचले स्तर के कार्यान्वयन, भी 51 बाइट्स

Sum[4^i⌊#/4^⌊#2/4^i⌋~Mod~4⌋~Mod~4,{i,0,3}]&

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

— attinat
स्रोत

4

पायथन 2 , 22 बाइट्स

मेरे गणितज्ञ उत्तर का एक बंदरगाह । पूर्णांक को लेबल के रूप में उपयोग करना। $0, 6, 1, 7, 2, 3, 5, 4$

lambda a,b:a^b^a/2&b/4

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

— alephalpha
स्रोत

4

पायथन 2 , 26 23 21 बाइट्स

lambda x,y:y+x*7**y&7

$D_3$ andxnor

 id | r1 | r2 | r3 | s0 | s1 | s2 | s3 
----+----+----+----+----+----+----+----
 0  | 2  | 4  | 6  | 1  | 3  | 5  | 7

— नील
स्रोत

2

आप बदल सकते हैं (-1)के साथ 7-3 बाइट्स के लिए मॉड्यूलर अंकगणितीय की वजह से।

— निएडजेककोब

@NieDzejkob धन्यवाद! शर्म की बात है कि alephalpha ने अपने जवाब को 28 से 22 बाइट्स तक नीचे गिरा दिया ...

— नील

अच्छा समाधान! आप ऑपरेटर की पूर्वता को बदलकर y+x*7**y&7

— पार्न्स

@ एक्सनोर थैंक्स, मैं फिर से एलिफेल्फा से आगे हूं!

— नील

3

टीआई-बेसिक, 165 बाइट्स

Ans→L₁:{.12345678,.23417865,.34126587,.41238756,.58671342,.67583124,.75862413,.86754231→L₂:For(I,1,8:10fPart(.1int(L₂(I)₁₀^(seq(X,X,1,8:List▶matr(Ans,[B]:If I=1:[B]→[A]:If I-1:augment([A],[B]→[A]:End:[A](L₁(1),L₁(2

इनपुट लंबाई दो की एक सूची है Ans।
आउटपुट (row, column)तालिका में सूचकांक में संख्या है ।

एक बेहतर संपीड़न विधि हो सकती है जो बाइट्स को बचाएगी, लेकिन मुझे उस पर गौर करना होगा।

उदाहरण:

{1,2
           {1 2}
prgmCDGF1B
               2
{7,4
           {7 4}
prgmCDGF1B
               5

स्पष्टीकरण:
(पठनीयता के लिए नई कड़ियाँ जोड़ी गई हैं।)

Ans→L₁                              ;store the input list into L₁
{.123456 ... →L₂                    ;store the compressed matrix into L₂
                                    ; (line shortened for brevity)
For(I,1,8                           ;loop 8 times
10fPart(.1int(L₂(I)₁₀^(seq(X,X,1,8  ;decompress the "I"-th column of the matrix
List▶matr(Ans,[B]                   ;convert the resulting list into a matrix column and
                                    ; then store it into the "[B]" matrix variable
If I=1                              ;if the loop has just started...
[B]→[A]                             ;then store this column into "[A]", another matrix
                                    ; variable
If I-1                              ;otherwise...
augment([A],[B]→[A]                 ;append this column onto "[A]"
End
[A](L₁(1),L₁(2                      ;get the index and keep it in "Ans"
                                    ;implicit print of "Ans"

यहां एक 155 बाइट समाधान है, लेकिन यह केवल मैट्रिक्स को हार्डकोड करता है और इंडेक्स प्राप्त करता है।
मुझे यह अधिक उबाऊ लगा, इसलिए मैंने इसे अपनी आधिकारिक प्रस्तुति नहीं बनाया:

Ans→L₁:[[1,2,3,4,5,6,7,8][2,3,4,1,8,7,5,6][3,4,1,2,6,5,8,7][4,1,2,3,7,8,6,5][5,7,6,8,1,3,2,4][6,8,5,7,3,1,4,2][7,6,8,5,4,2,1,3][8,5,7,6,2,4,3,1:Ans(L₁(1),L₁(2

नोट: TI-BASIC एक टोकन भाषा है। कैरेक्टर काउंट बाइट काउंट नहीं के बराबर होता है ।

— ताउ
स्रोत

आप का उपयोग करके एक बाइट की तरह दाढ़ी नहीं किया जा सका 0-7करने के लिए1-8

— ASCII-केवल

मैं कर सकता था, लेकिन फिर मुझे मैट्रिक्स के प्रत्येक तत्व में एक को जोड़ने के लिए दो और का उपयोग करना होगा। हालांकि, अच्छा लगा!

— ताऊ

गलत, आप अक्षरों के किसी भी सेट का उपयोग कर सकते हैं, इसलिए आपके पास दो और उपयोग करने के लिए hasv नहीं है

— ASCII-only

यह सच हो सकता है, लेकिन TI-BASIC के मैट्रिक्स 1-अनुक्रमित हैं। यह सबकुछ उस पर निर्भर करता है ताकि वांछित मूल्य प्राप्त किया जा सके (यदि ऐसा है जो आप पर थोप रहे हैं। मुझे गलत

— ताऊ

आह, इस बारे में भूल गए

— केवल

3

जेली , 6 बाइट्स

N⁹¡+%8

एक डाईएडिक लिंक जो दाईं ओर पहले परिवर्तन को स्वीकार करता है और दूसरा परिवर्तन बाईं तरफ जो समग्र परिवर्तन को जन्म देता है।

जहां परिवर्तन हैं:

as in question:  1    2    3    4    5    6    7    8
transformation: id  90a  180  90c  hor  ver  +ve  -ve
  code's label:  0    2    4    6    1    5    7    3

इसे ऑनलाइन आज़माएं! ... या प्रश्न में लेबल पर वापस मैप की गई तालिका देखें।

(तर्क 6 बटर का उपयोग करके दूसरे क्रम में लिया जा सकता है _+Ḃ?%8)

कैसे?

प्रत्येक लेबल प्रत्यावर्तन के एक क्रम की लंबाई horऔर +veरूपांतर है जो परिवर्तन के बराबर है (उदाहरण 180के बराबर hor, +ve, hor, +ve)।

रचना A,Bदो समतुल्य अनुक्रमों के समतुल्य के बराबर है, और घटाव या इसके अलावा modulo आठ को सरलीकरण की अनुमति देता है ...

प्रश्न के 7, 4उदाहरण का उपयोग करना +ve, 90cजो हमारे पास है:
hor, +ve, hor, +ve, hor, +ve, hor , hor, +ve, hor, +ve, hor, +ve

... लेकिन जब hor, horसे idहमारे पास है:
hor, +ve, hor, +ve, hor, +ve , +ve, hor, +ve, hor, +ve

... और जब से +ve, +veहै idहमने:
hor, +ve, hor, +ve, hor , hor, +ve, hor, +ve

... और हम इन रद्दीकरणों को दोहरा सकते हैं:
hor
.. लंबाई के घटाव के लिए असमान ( 7-6=1)।

90a, 180 $\rightarrow$ 2+4=6 $\rightarrow$ 90c

अंत में, ध्यान दें कि लंबाई आठ का एक क्रम है idइसलिए हम परिणामी अनुक्रम लंबाई मोडुलो आठ ले सकते हैं।

N⁹¡+%8 - Link: B, A
  ¡    - repeat (applied to chain's left argument, B)...
 ⁹     - ...times: chain's right argument, A
N      - ...action: negate  ...i.e. B if A is even, otherwise -B
   +   - add (A)
    %8 - modulo eight

यह लेक्सोग्राफ़िक क्रमपरिवर्तन अनुक्रमित का उपयोग करके इस कार्यान्वयन से 1 बाइट छोटा है :

œ?@ƒ4Œ¿

... [first, second]लेबल के साथ एक मानवीकृत लिंक स्वीकार करना :

as in question:  1    2    3    4    5    6    7    8
transformation: id  90a  180  90c  hor  ver  +ve  -ve
  code's label:  1   10   17   19   24    8   15    6

— जोनाथन एलन
स्रोत

3

जावास्क्रिप्ट (Node.js) , 22 17 बाइट्स

(x,y)=>y+x*7**y&7

$D_3$

 id | r1 | r2 | r3 | s0 | s1 | s2 | s3 
----+----+----+----+----+----+----+----
 0  | 2  | 4  | 6  | 1  | 3  | 5  | 7

जावास्क्रिप्ट के पुराने संस्करणों को 22 बाइट्स के लिए कई तरीकों से समर्थित किया जा सकता है:

(x,y)=>(y&1?y-x:y+x)&7
(x,y)=>y-x*(y&1||-1)&7
(x,y)=>y+x*(y<<31|1)&7

— नील
स्रोत

छोटा सुधार - इनपुट के द्वारा बाइट को सेव x=>y=>(y&1?y-x:y+x)&7करें फिर अपने फ़ंक्शन का उपयोग करके कॉल करें f(x)(y)।

— दाना

2

जंग , 16 बाइट्स

|a,b|a^b^a/2&b/4

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

एलेफल्फा के पायथन उत्तर का पोर्ट। लेकिन छोटा है।

— NieDzejkob
स्रोत

2

एल्म , 42 बाइट्स 19 बाइट्स

\a b->and 7<|b+a*7^b

नील के Node.js संस्करण का पोर्ट

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

पुराना वर्जन:

\a b->and 7<|if and 1 a>0 then a-b else a+b

— एवगेनी माल्युटिन
स्रोत

1

अच्छा पहला जवाब! मुझे नहीं पता कि एल्म में कैसे कार्यक्रम करना है, लेकिन क्या रिक्त स्थान को निकालना संभव है?

— मिल्कीवेय 90

@ मिल्कीवे 90 नॉप, यह एमएल-आधारित भाषाओं के मुख्य अंतरों में f xसे एक है, जो एक फ़ंक्शन कॉल है, जैसे f(x)सी-जैसी भाषाओं में इसका क्या मतलब है। और आप इसकी मदद नहीं कर सकते। लेकिन यह कई गैर-गोल्फ परिदृश्यों में वास्तव में अच्छा और कम बरबाद हो सकता है। एल्म में बिटवाइज़ ऑपरेटर्स नहीं होते (जैसे &) तो and x yबस एक सादे फ़ंक्शन कॉल यहाँ है।

— एवगेनी मैय्युटिन

मैं देख रहा हूँ, समझाने के लिए धन्यवाद!

— दूधियावय 90

@ MilkyWay90 वास्तव में, मैं <|कोष्ठक के बजाय पाइप ऑपरेटर का उपयोग करके एक स्थान (और एक बाइट) को काटने में कामयाब रहा । सवाल करने के लिए धन्यवाद!

— एवगेनी माल्युटिन

आपका स्वागत है! यदि आप एक नया समाधान बनाने में रुचि रखते हैं, तो आप मदद के लिए उन्नीसवीं बाइट (हमारे एसई चैटरूम) पर पूछ सकते हैं। यदि आप एक कोडिंग चुनौती बना रहे हैं, तो आप इसे सैंडबॉक्स में पोस्ट कर सकते हैं (मेटा पर) और हर दिन निन्यानवे बाइट पर सवाल का लिंक पोस्ट कर सकते हैं।

— मिल्कीवेय 90

1

पायथन, 82 71 बाइट्स

4-7

-11 बाइट्स ASCII-only को धन्यवाद

lambda a,b:int("27pwpxvfcobhkyqu1wrun3nu1fih0x8svriq0",36)>>3*(a*8+b)&7

TIO

— बेंजामिन अर्कहार्ट
स्रोत

80, अजगर 2 , 76, अजगर 2

— केवल

यह भी 76 , और -2 f=को हटाया जा सकता है क्योंकि यह पुनरावर्ती नहीं है

— केवल

प्रतीक्षा चीर, यह काम नहीं करता है

— केवल

2

यहाँ हम जाते हैं, 71

— केवल

ऐसा लगता है कि आप int.from_bytesगैर-यूटीएफ एन्कोडिंग के साथ बेहतर कर सकते हैं , लेकिन ... यह सुनिश्चित नहीं करें कि टीआईओ पर कैसे करें

— एएससीआईआई-केवल

0

स्काला , 161 बाइट्स

कंप्यूटर को लेबल के रूप में चुनना ।

val m="0123456712307645230154763012675446570213574620316574310274651320"
val s="COMPUTER"
val l=s.zipWithIndex.toMap
def f(a: Char, b: Char)=s(m(l(a)*8+l(b))-48)

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

— पीटर
स्रोत

1

यह कोड गोल्फ है: | आप इसे यथासंभव छोटा करने वाले हैं

— ASCII-only

88

— केवल

हाँ, मैंने अपने आप को चुनौती दी कि केवल देशी 4-7 नहीं, बल्कि स्केला और असली लेबल के साथ जाऊँ। इसे हराकर देखें।

— पीटर

133

— केवल

118: पी

— एएससीआईआई-केवल

0

स्काला , 70 बाइट्स

लेबल के रूप में 4-7 देशी पूर्णांक चुनना।

मैट्रिक्स को 32 बाइट ASCII स्ट्रिंग में संकलित किया गया है, प्रत्येक जोड़े की संख्या n0, n1 में 1 वर्ण c = n0 + 8 * n1 + 49 है। 49 से शुरू होकर हम एन्कोडेड स्ट्रिंग में \ n नहीं है।

(a:Int,b:Int)=>"9K]oB4h]K9Vh4BoVenAJne3<_X<AX_J3"(a*4+b/2)-49>>b%2*3&7

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

— पीटर
स्रोत

0

सी # (विजुअल सी # इंटरएक्टिव कंपाइलर) , 17 बाइट्स

a=>b=>a^b^a/2&b/4

एलेफाल्फा के पायथन उत्तर का बंदरगाह।

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

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

0

पर्ल 6 , 19 बाइट्स

{($^x*7**$^y+$y)%8}

नील के पायथन समाधान का बंदरगाह ।

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

— bb94
स्रोत

-3

वोल्फ्राम भाषा (गणितज्ञ), 7 बाइट्स (UTF-8 एन्कोडिंग)

#⊙#2&

दो तर्कों को लेते हुए एक शुद्ध कार्य। यहां दिए गए प्रतीक के रूप ⊙में वास्तव में गणितज्ञ का निजी यूनिकोड प्रतीक F3DE (3 बाइट्स) है, जो फ़ंक्शन का प्रतिनिधित्व करता है PermutationProduct।

मैथेमेटिका डायडरल समूहों के बारे में जानता है, और यह विभिन्न समूहों के तत्वों को क्रमबद्धता के रूप में दर्शाता है, जो Cyclesकमांड का उपयोग करके लिखा गया है । उदाहरण के लिए, कमांड चलाना

GroupElements[DihedralGroup[4]]

पैदावार उत्पादन:

{Cycles[{}], Cycles[{{2, 4}}], Cycles[{{1, 2}, {3, 4}}], 
 Cycles[{{1, 2, 3, 4}}], Cycles[{{1, 3}}], Cycles[{{1, 3}, {2, 4}}], 
 Cycles[{{1, 4, 3, 2}}], Cycles[{{1, 4}, {2, 3}}]}

PermutationProduct वह फ़ंक्शन है जो इस रूप में लिखे जाने पर समूह तत्वों को गुणा करता है।

चूंकि हमें अपने लेबल चुनने की अनुमति है, यह फ़ंक्शन समूह तत्वों के लिए इन लेबल को मानता है; समस्या लेबल में इन लेबलों और लोगों के बीच का मेल निम्नानुसार है:

Cycles[{}] -> 1
Cycles[{{1, 2, 3, 4}}] -> 2
Cycles[{{1, 3}, {2, 4}}] -> 3
Cycles[{{1, 4, 3, 2}}] -> 4
Cycles[{{2, 4}}] -> 5
Cycles[{{1, 3}}] -> 6
Cycles[{{1, 2}, {3, 4}}] -> 7
Cycles[{{1, 4}, {2, 3}}] -> 8

tl; डॉ। एक बिलिन है।

— ग्रेग मार्टिन
स्रोत

8

लेबल को 0 से 255 या एकल बाइट्स के लिए नंबर होना चाहिए।

— xnor

पर्याप्त रूप से उचित (मुझे इस समारोह की परवाह किए बिना खुशी हुई)। क्या आप स्पष्ट कर सकते हैं कि ओपी में? अभी यह पढ़ता है जैसे "अपने खुद के लेबल चुनें" (जोर दिया गया), फिर कुछ संभावित विकल्प ("आप हो सकता है ...")।

— ग्रेग मार्टिन

1

ओह, मैं देख रहा हूं कि आप इसे कैसे पढ़ रहे हैं; यहाँ अस्पष्ट होने और आपको गलत मार्ग पर ले जाने के लिए क्षमा करें। मुझे इसे पुनः बनाने का प्रयास करने दें।

— xnor

कस्टम लेबल के साथ डायहड्राल समूह डी 4 रचना

रूबी , 18 बाइट्स

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

स्पष्टीकरण:

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

पायथन 2 , 22 बाइट्स

पायथन 2 , 26 23 21 बाइट्स

टीआई-बेसिक, 165 बाइट्स

जेली , 6 बाइट्स

कैसे?

जावास्क्रिप्ट (Node.js) , 22 17 बाइट्स

जंग , 16 बाइट्स

एल्म , 42 बाइट्स 19 बाइट्स

पायथन, 82 71 बाइट्स

स्काला , 161 बाइट्स

स्काला , 70 बाइट्स

सी # (विजुअल सी # इंटरएक्टिव कंपाइलर) , 17 बाइट्स

पर्ल 6 , 19 बाइट्स

वोल्फ्राम भाषा (गणितज्ञ), 7 बाइट्स (UTF-8 एन्कोडिंग)