लेवी-सिविता प्रतीक


29

त्रि-आयामी लेवी-सिविता प्रतीक एक ऐसा कार्य है fजो (i,j,k)प्रत्येक में {1,2,3}, के {-1,0,1}रूप में परिभाषित संख्याओं के त्रिभुज लेता है :

  • f(i,j,k) = 0जब i,j,kअलग नहीं हैं, यानी i=jया j=kयाk=i
  • f(i,j,k) = 1जब (i,j,k)की एक चक्रीय बदलाव है (1,2,3), कि में से एक है (1,2,3), (2,3,1), (3,1,2)
  • f(i,j,k) = -1जब (i,j,k)की एक चक्रीय बदलाव है (3,2,1), कि में से एक है (3,2,1), (2,1,3), (1,3,2)

परिणाम है संकेत का क्रमपरिवर्तन की (1,2,3), गैर क्रमपरिवर्तन वैकल्पिक रूप से 0. दे रही है, अगर हम मान सहयोगी के साथ 1,2,3ओर्थोगोनल इकाई आधार वैक्टर के साथ e_1, e_2, e_3है, तो f(i,j,k)है निर्धारक कॉलम के साथ 3x3 मैट्रिक्स के e_i, e_j, e_k

इनपुट

{1,2,3}क्रम से प्रत्येक तीन संख्या । या, आप शून्य-अनुक्रमित का उपयोग करना चुन सकते हैं {0,1,2}

उत्पादन

उनकी लेवी-सिविता फंक्शन वैल्यू है {-1,0,1}। यह कोड गोल्फ है।

परीक्षण के मामलों

27 संभावित इनपुट हैं।

(1, 1, 1) => 0
(1, 1, 2) => 0
(1, 1, 3) => 0
(1, 2, 1) => 0
(1, 2, 2) => 0
(1, 2, 3) => 1
(1, 3, 1) => 0
(1, 3, 2) => -1
(1, 3, 3) => 0
(2, 1, 1) => 0
(2, 1, 2) => 0
(2, 1, 3) => -1
(2, 2, 1) => 0
(2, 2, 2) => 0
(2, 2, 3) => 0
(2, 3, 1) => 1
(2, 3, 2) => 0
(2, 3, 3) => 0
(3, 1, 1) => 0
(3, 1, 2) => 1
(3, 1, 3) => 0
(3, 2, 1) => -1
(3, 2, 2) => 0
(3, 2, 3) => 0
(3, 3, 1) => 0
(3, 3, 2) => 0
(3, 3, 3) => 0

जवाबों:


20

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

ṁ4IṠS

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

कलन विधि

आइए मतभेदों पर विचार करें जी, kj, ik

  • तो (i, j, k) के एक रोटेशन है (1, 2, 3) , मतभेद की एक रोटेशन कर रहे हैं (1, 1, -2) । संकेतों का योग लेते हुए, हमें 1 + 1 + (-1) = 1 मिलता है

  • तो (i, j, k) के एक रोटेशन है (3, 2, 1) , मतभेद की एक रोटेशन कर रहे हैं (-1, -1, 2) । संकेतों का योग लेते हुए, हमें (-1) + (-1) + 1 = -1 मिलता है

  • के लिए (i, i, j) (या एक रोटेशन), जहां i और j समान हो सकते हैं, अंतर (0, ji, ij) हैंजी और आईजे के संकेत विपरीत हैं, इसलिए संकेतों का योग 0 + 0 = 0 है

कोड

ṁ4IṠS  Main link. Argument: [i, j, k]

ṁ4     Mold 4; yield [i, j, k, i].
  I    Increments; yield [j-i, k-j, i-k].
   Ṡ   Take the signs, replacing 2 and -2 with 1 and -1 (resp.).
    S  Take the sum.

सुंदर - निश्चित रूप से यह xnor का इच्छित एल्गोरिथ्म था।
ETHproductions

8

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

lambda i,j,k:(i-j)*(j-k)*(k-i)/2

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

कलन विधि

आइए मतभेदों पर विचार करें Ij, jk, ki

  • तो (i, j, k) के एक रोटेशन है (1, 2, 3) , मतभेद की एक रोटेशन कर रहे हैं (-1, -1, 2) । उत्पाद लेते हुए, हमें (-1) × (-1) × 2 = 2 मिलता है

  • तो (i, j, k) के एक रोटेशन है (3, 2, 1) , मतभेद की एक रोटेशन कर रहे हैं (1, 1, -2) । उत्पाद लेते हुए, हमें 1 × 1 × (-2) = -2 मिलता है

  • के लिए (i, i, j) (या एक रोटेशन), जहां i और j समान हो सकते हैं, अंतर (0, ij, ji) हैं । उत्पाद लेते हुए, हमें 0 × (ij) × (ji) = 0 मिलता है

इस प्रकार, मतभेदों के उत्पाद को 2 से विभाजित करने से वांछित परिणाम प्राप्त होता है।


7

x86, 15 बाइट्स

में तर्क लेता है %al, %dl, %bl, में रिटर्न %al। डेनिस के फार्मूले का उपयोग करते हुए सीधा कार्यान्वयन।

 6: 88 c1                   mov    %al,%cl
 8: 28 d0                   sub    %dl,%al
 a: 28 da                   sub    %bl,%dl
 c: 28 cb                   sub    %cl,%bl
 e: f6 e3                   mul    %bl
10: f6 e2                   mul    %dl
12: d0 f8                   sar    %al
14: c3                      retq 

एक तरफ: मुझे लगता है कि मैं समझता हूं कि %eaxअब "संचायक" क्यों है ...


मुझे लगता है कि आपका मतलब sarनहीं था shr
जस्टर

@ जेस्टर अच्छा कैच। नियत
qwr

6

ऑक्टेव, 20 बाइट्स

@(v)det(eye(3)(:,v))

निर्धारक सूत्र का सुंदर प्रत्यक्ष कार्यान्वयन। पहचान मैट्रिक्स के कॉलम को अनुमति देता है, फिर निर्धारक को लेता है।


5

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

Signature

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


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

मार्टिन एंडर के लिए धन्यवाद 2 बाइट्स सहेजे गए।

Det@{#^0,#,#^2}/2&

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



2
Vandermonde निर्धारक अच्छा है। वहाँ भी है Det@IdentityMatrix[3][[#]]&(अब, लेकिन कम टोकन)।
काइल मिलर

1
#^1सिर्फ है #;)
मार्टिन एंडर







1

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

->t{t.uniq!? 0:(0..2).any?{|r|t.sort==t.rotate(r)}?1:-1}

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

एक बार जब हम उन मामलों को खारिज कर देते हैं, जहां ट्रिपल के मान अद्वितीय नहीं हैं, t.sortतो ( [1,2,3]या उससे कम) के बराबर या है[*1..3]

->t{
  t.uniq! ? 0                     # If applying uniq modifies the input, return 0
          : (0..2).any?{|r|       # Check r from 0 to 2:
              t.sort==t.rotate(r) #   If rotating the input r times gives [1,2,3],
            } ? 1                 #     return 1;
              :-1                 #     else return -1
}

1

भूसी , 7 बाइट्स

ṁ±Ẋ-S:←

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

व्याख्या

डेनिस के जेली उत्तर का सीधा पोर्ट । S:←सूची के प्रमुख को अंत तक कॉपी करता है, Ẋ-आसन्न मतभेदों को ṁ±लेता है , और प्रत्येक तत्व का संकेत लेता है और परिणाम को बताता है।




0

शेल , 44 बाइट्स

 F(){ bc<<<\($2-$1\)*\($3-$1\)*\($3-$2\)/2;}

परीक्षण:

 F 1 2 3
 1

 F 1 1 2
 0

 F  2 3 1
 1

 F 3 1 2
 1

 F 3 2 1
 -1

 F 2 1 3
 -1

 F 1 3 2
 -1

 F 1 3 1
 0

स्पष्टीकरण:

 The formula is : ((j - i)*(k - i)*(k - j))/2

ईसा पूर्व , 42 बाइट्स

 define f(i,j,k){return(j-i)*(k-i)*(k-j)/2}

परीक्षण:

 f(3,2,1)
 -1
 f(1,2,3)
 1
 f(1,2,1)
 0

1
क्या यह संभव है कि भाषा का दावा bcकरने के लिए बाहर की कॉल / फ़ंक्शन घोषणा से बचा जाए?
केयर्ड कॉइनरहाइडिंग

1
यह किस खोल में काम करता है?
डेनिस


0

जे , 12 बाइट्स

1#.2*@-/\4$]

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

उरीएल के एपीएल समाधान का सीधा अनुवाद जे।

स्पष्टीकरण:

4$] सूची को उसके पहले आइटम के साथ बढ़ाता है

2 /\ सूची में सभी अतिव्यापी जोड़े के लिए निम्नलिखित करें:

*@- उनके अंतर का संकेत पाते हैं

1#. जोड़ें


1
मैं इस वन्देमोंडे-निर्धारक आधारित समाधान को यहाँ एक टिप्पणी के रूप में छोड़ दूँगा कि कोई भी यह पता लगा सके कि इसे कैसे नीचे गिराया जाए:(-/ .*)@:(^&(i.3)"0)%2:
काइल मिलर

0

जाप , 7 बाइट्स

änUÌ xg

कोशिश करो


व्याख्या

            :Implicit input of array U
ä           :Get each consecutive pair of elements
 n          :Reduce by subtracting the first from the last
  UÌ        :But, before doing that, prepend the last element in U
     g      :Get the signs
    x       :Reduce by addition

विकल्प

अलग-अलग पूर्णांकों के रूप में इनपुट लेता है।

NänW ×z

कोशिश करो



हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.