आप एक सरणी दिया जाता है एक के एन के साथ सख्ती से धनात्मक पूर्णांक, एन ≥ 2 ।

आपका काम प्रत्येक प्रविष्टि मैप करने के लिए है एक _मैं करने के लिए:

1 यदि A _j mod A _i प्रत्येक j के लिए विषम है जैसे कि 1 ≤ j j n और j। I
2 अगर A _j mod A _i प्रत्येक j के लिए भी है जैसे कि 1 ≤ j j n और j। I
0 अन्यथा (मिश्रित समानताएं)

उदाहरण

के लिए एक = [73, 50, 61] , हमने:

50 मॉड 73 = 50 , 61 मॉड 73 = 61 → मिश्रित
73 मॉड 50 = 23 , 61 मॉड 50 = 11 → सभी विषम
73 मॉड 61 = 12 , 50 मॉड 61 = 50 → सभी भी

इसलिए, अपेक्षित आउटपुट [0, 1, 2] है ।

नियम

जब तक वे सुसंगत हों , आप 0 , 1 और 2 के बजाय किसी भी तीन अलग-अलग मानों का उपयोग कर सकते हैं । यदि आप चुनौती में वर्णित एक का उपयोग नहीं कर रहे हैं तो कृपया अपनी मैपिंग निर्दिष्ट करें ।
क्या इसके बारे में कोई संदेह होना चाहिए, शून्य भी है ।
यह कोड-गोल्फ है , इसलिए बाइट्स में सबसे कम जवाब जीतता है!

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

[ 1, 2 ] --> [ 2, 1 ]
[ 3, 4 ] --> [ 1, 1 ]
[ 1, 2, 3 ] --> [ 2, 1, 0 ]
[ 4, 4, 4 ] --> [ 2, 2, 2 ]
[ 73, 50, 61 ] --> [ 0, 1, 2 ]
[ 941, 459, 533 ] --> [ 1, 0, 0 ]
[ 817, 19, 928, 177 ] --> [ 1, 2, 1, 1 ]
[ 312, 463, 336, 729, 513 ] --> [ 0, 2, 0, 0, 0 ]
[ 53, 47, 33, 87, 81, 3, 17 ] --> [ 0, 0, 0, 1, 0, 2, 0 ]

code-golf array-manipulation number-theory

— Arnauld
स्रोत

पायथन 2 , 68 67 66 बाइट्स

^{-1 बाइट थैंक्स टू मिस्टर एक्सकोडर}
^{-1 बाइट थैंक्स टू ओव्स}

x=input()
for j in x:k=sum(i%j%2for i in x);print(k<len(x)-1)+0**k

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

1,0,2इसके बदले लौटता है 0,1,2।

— छड़ी
स्रोत

-1 बाइट के (k<1)साथ बदलें 0**k।

— ओवी

4

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

%þœ-€0Ḃ‘Ṭ

रिटर्न [1, 1], [0, 1], [1] 0, 1, 2 के बजाय ।

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

यह काम किस प्रकार करता है

%þœ-€0Ḃ‘Ṭ  Main link. Argument: A (array)

%þ           Build the modulus table.
  œ-€0       Remove one 0 from each list of moduli.
      Ḃ      Take the last bit of each.
       ‘     Increment, mapping 0 and 1 to 1 and 2.
        Ṭ    Untruth; map each array to an aray of 1's at the specified indices.
             This yields:
                 [1] if the array contains only 1's (all even).
                 [0, 1] if the array contains only 2's (all odd).
                 [1, 1] if the array contains 1's and 2's.

— डेनिस
स्रोत

आप की जगह किया जा सका ‘ṬUḄके साथ Q€Ḅएक बाइट को बचाने के लिए?

— जोनाथन एलन

दुख की बात है नहीं। Q€लौट सकता था [0, 1]या [1, 0]।

— डेनिस

अरे हाँ। मुझे लगता है [1], [1,1]और [0,1]तीन अलग-अलग मूल्य हैं इसलिए %þœ-€0Ḃ‘Ṭ9 के लिए स्वीकार्य होना चाहिए। EDIT - आह मुझे लगता है कि आपने यह सटीक सवाल पूछा :)

— जोनाथन एलन

एक और 9 बाइट विकल्प है¹-Ƥ%"%2‘Ṭ

— मील

3

MATL , 12 बाइट्स

!G\o~tAws1=-

यह उपयोग करता है 0,-1 , 1बजाय 0, 1, 2क्रमशः।

इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें ।

व्याख्या

!    % Implicit input: row vector. Transpose into a column
G    % Push input again
\    % Modulus, element-wise with broadcast. Gives a square matrix
o    % Parity: gives 1 for odd, 0 for even
~    % Logical negate: 0 for odd, 1 for even
t    % Duplicate
A    % All: gives 1 for columns that contain only 1
w    % Swap
s    % Sum of each column
1    % Push 1
=    % Is equal? Gives 1 if the column sum was 1, 0 otherwise
-    % Subtract, element-wise. Implicit display

— लुइस मेंडो
स्रोत

3

सी (जीसीसी) , 118 114 97 92 91 बाइट्स

करने के लिए धन्यवाद बगफिक्सिंग पीटर कॉर्ड्स का ।
सहेजा गया ~~चार~~ इक्कीस बाइट्स धन्यवाद पीटर Cordes ; एक अलग आउटपुट वैल्यू मैपिंग का उपयोग करने का सुझाव; [0 1 2] ~ [3 2 1]।
पांच बाइट्स बचाए; अभी तक एक और मानचित्रण का उपयोग करना; [0 1 2] ~ [  ]।
एक बाइट को बचाया; को गोल्फ for(i=0;i<n;i++,putchar...दिया for(i=~0;++i<n;putchar...।

i,j,r;f(A,n)int*A;{for(i=~0;++i<n;putchar(r)){for(j=r=0;j<n;j++)j-i&&(r|=1<<A[j]%A[i]%2);}}

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

— जोनाथन फ्रेच
स्रोत

टीआईओ पर आपके परीक्षण कार्य पर्याप्त आर्गन पास नहीं करते हैं, और यह अपरिभाषित व्यवहार पिछले परीक्षण मामले से शून्य (एसआईजीएफपीई) द्वारा विभाजन की ओर जाता है। f(I,7)अधिलेखित कर देता है के पहले तत्व I[]( A[]च में ()) आर्ग में से एक यह है कि आप स्थानीय लोगों के रूप में प्रयोग कर रहे हैं के साथ। f()मान लें कि कॉल करने वाले द्वारा स्टैक पर आर्ग पारित किया गया था, लेकिन कॉल करने वाले को यह पता नहीं था, और रिटर्न एड्रेस के ऊपर स्टैक पर वास्तव में क्या है A[0]। (यानी यह यूबी के कारण tऔर A[0]एक ही पता है)। वैसे भी, यह केवल TIO पर आपके परीक्षण समारोह में UB है ।

— पीटर कॉर्डेस

और BTW, मैं दुर्घटना को स्थानीय रूप से नहीं दोहरा सकता था, इसलिए मुझे execlp("/usr/bin/objdump", "objdump", "-drwC", "-Mintel", argv[0], 0);TIO की gcc 7.2.1 से asm पाने के लिए मुख्य में जोड़ना पड़ा , जो मेरे Arch Linux gcc 7.2.1 से बिल्कुल मेल नहीं खाता। कॉलिंग फ़ंक्शन के लिए उस डिस्प्रेशन को वापस एएसएम स्रोत में बदलने के बाद, मैं इसे स्थानीय रूप से जीडीबी के अंदर रीप्रो कर सकता था और वास्तव में यह पुष्टि कर सकता था कि क्या हो रहा था।

— पीटर कॉर्डेस

आप एक अलग मैपिंग का उपयोग करके बाइट्स को बचा सकते हैं, जैसे 1 के लिए, विषम के लिए 2, मिश्रित के लिए 3, इसलिए आप o|=1<<(A[j]%A[i]%2)बिना किसी फैंसी डिकोडिंग की आवश्यकता के बिना कर सकते हैं o।

— पीटर कॉर्ड्स

@PeterCordes ध्यान देने के लिए धन्यवाद, भले ही मुझे अभी भी पूरी तरह से समझ में नहीं आया है कि पहली सरणी प्रविष्टि अधिलेखित क्यों हो जाती है। मैंने अब अपरिभाषित व्यवहार को हटाते हुए स्थानीय लोगों के बजाय वैश्विक चर का उपयोग करना चुना।

— जोनाथन फ्रीच

@PeterCordes मैंने आपका गोल्फ सुझाव भी लिया और चार बाइट्स बचाने में कामयाब रहा। हालाँकि, मुझे नहीं पता कि यह वास्तव में आप क्या सुझाव दे रहे थे, जैसा कि आपने o|=1<<...कुछ के बजाय लिखा था o|=1<<(t=...।

— जोनाथन फ्रीच

3

मैथेमेटिका, 57 49 48 बाइट्स

(s=#;And@@#.Or@@#&@OddQ@Rest@Sort[s~Mod~#]&)/@#&

यह रिटर्न:

False.Trueके लिए 0 (मिश्रित)
True.Trueके लिए 1 (सभी विषम)
False.Falseके लिए 2 (सभी भी)

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

यहां थोड़ा लंबा विकल्प है (49 बाइट्स):

Sign[(s=#;Tr@Mod[s~Mod~#,2]&)/@#/.Tr[1^#]-1->-1]&

यह एक रिटर्न:

1के लिए 0 (मिश्रित)
-1के लिए 1 (सभी विषम)
0के लिए 2 (सभी भी)

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

— डेविड बेवन
स्रोत

2

लाल , 101 बाइट्स

g: func[b][foreach n b[a: copy[]foreach m b[append a m % n % 2]sort a a: copy next a print unique a]]

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

1 0मिश्रित के लिए, 1विषम के लिए और 0यहां तक कि के लिए रिटर्न

g: func[b] [
    foreach n b [
        a: copy []
        foreach m b [
            append a m % n % 2
        ]
        sort a
        a: copy next a
        print unique a
    ]
]

— गैलेन इवानोव
स्रोत

2

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

a=>a.map(A=>a.map(B=>d+=B%A%2,d=0)|!a[d+1]-!d)

रिटर्न -1 (सम), 1 (विषम), और 0 (मिश्रित)।

यह काम किस प्रकार करता है:

dसंचायक हो जाएगा:

शून्य अगर सभी भी moduli। ( !a[d+1]== असत्य, !d== १, false - 1== -1 )
सरणी की लंबाई की तुलना में एक ^* कम यदि सभी विषम मोडुली। ( ^* संचायक में स्वयं के विरुद्ध एक तत्व शामिल होता है, जिसके परिणामस्वरूप एक भी मापांक होता है।) ( !a[d+1]== true, !d== 0, true - 0== 1 )
मिक्स अगर सरणी की लंबाई से दो या अधिक कम है। ( !a[d+1]== असत्य, !d== 0, false - 0== 0 )

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

कोड स्निपेट दिखाएं

let f=

a=>a.map(A=>a.map(B=>d+=B%A%2,d=0)|!a[d+1]-!d)

console.log(f([ 1, 2 ] ) + ''); // [ -1, 1 ]
console.log(f([ 3, 4 ] ) + ''); // [ 1, 1 ]
console.log(f([ 1, 2, 3 ] ) + ''); // [ -1, 1, 0 ]
console.log(f([ 4, 4, 4 ] ) + ''); // [ -1, -1, -1 ]
console.log(f([ 73, 50, 61 ] ) + ''); // [ 0, 1, -1 ]
console.log(f([ 941, 459, 533 ] ) + ''); // [ 1, 0, 0 ]
console.log(f([ 817, 19, 928, 177 ] ) + ''); // [ 1, -1, 1, 1 ]
console.log(f([ 312, 463, 336, 729, 513 ] ) + ''); // [ 0, -1, 0, 0, 0 ]
console.log(f([ 53, 47, 33, 87, 81, 3, 17 ] ) + ''); // [ 0, 0, 0, 1, 0, -1, 0 ]

Expand snippet

— रिक हिचकॉक
स्रोत

1

जे , 27 20 बाइट्स

[:<@~.@}:@\:"1~2||/~

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

1 1 2 के बजाय [1 0] [1] [0] का उपयोग करता है

स्पष्टीकरण:

|/~ - अवशेषों के साथ एक तालिका बनाता है:

  |/~ 73 50 61 
 0 50 61
23  0 11
12 50  0

2|विषम या सम? :

   2||/~ 73 50 61 
0 0 1
1 0 1
0 0 0

<@~.@}:@\:"1 - नीचे क्रमबद्ध करें, अंतिम तत्व (हमेशा शून्य) छोड़ें, andnique तत्वों को रखें और प्रत्येक पंक्ति को बॉक्स में रखें:

   <@~.@}:@\:"1~2||/~ 73 50 61 
┌───┬─┬─┐
│1 0│1│0│
└───┴─┴─┘

— गैलेन इवानोव
स्रोत

1

16 बाइट्स के साथ 2/:~@:|"1]|1]\.]जोड़े की सूची लौटाते हुए।

— मील

@ मील धन्यवाद! क्या यह आउटपुट स्वीकार्य है?

— गैलन इवानोव

वास्तव में नहीं, मैंने उस हिस्से को अलग-अलग मूल्यों के बारे में याद किया। मैं इसे थोड़ा सा वापस करूँगा।

— मील

1

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

->r{r.map{m=r.shift;s=r.map{|e|e%m%2}.uniq.sort;r<<m;s}}

रिटर्न [0, 1], [1], [0] के बजाय 0, 1, 2 (यानी [0] सभी के लिए, [1] सभी विषम के लिए, और [0, 1] मिश्रित के लिए।

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

— मोनिका को बहाल करना - notmaynard
स्रोत

1

पर्ल, 38 बाइट्स

के लिए शामिल +3है-p

#!/usr/bin/perl -p
s/\d+/$@|=$_%$&%2+1for<$`$'>;$@/gee

सभी के लिए आउटपुट 1, विषम के लिए 2, मिश्रित के लिए 3

— टन हास्पेल
स्रोत

1

स्वच्छ , 95 65 63 बाइट्स

import StdEnv

\l=[sum(removeDup[-1^(j rem i)\\j<-l|j<>i])\\i<-l]

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

लैम्बडा के रूप में, लेना [Int]और लौटना [Int], मानचित्रण करना:

0: मिश्रित
1: सब भी
-1: सब विषम

— Οurous
स्रोत

1

पर्ल 5 , 71 69 + 1 ( `-a`) = 70 बाइट्स

map{//;$j=$s='';$j++-$i&&($s+=$_%$'&1)for@F;say$s?0|$s==$#F:2;$i++}@F

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

— Xcali
स्रोत

1

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

a->[[!s=vecsum([x%y%2|x<-a]),s>#a-2]|y<-a]

के [0, 0], [0, 1], [1, 0]बदले लौटता है0, 1, 2 ।

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

— alephalpha
स्रोत

1

जावा 8, 91 89 बाइट्स

a->{for(int z:a){int s=1;for(int y:a)s+=y%z%2;System.out.print(" "+(s<a.length)+(s<2));}}

के truetrueबजाय के 2लिए भी उपयोग करना
विषम के falsefalseबजाय का उपयोग करना1
मिश्रित के truefalseबजाय का उपयोग करना0

स्पष्टीकरण:

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

a->{                      // Method with integer-array parameter and no return-type
  for(int z:a){           //  Loop over the array
    int s=1;              //   Sum-integer, starting at 1
    for(int y:a)          //   Inner loop over the array again
      s+=y%z%2;           //    Increase the sum by `y` modulo-`z` modulo-2
    System.out.print(" "  //   Print a space
      +(s<a.length)       //    + "true" if the sum is smaller than the length of the array
                          //      (this means there is at least one even)
      +(s<2));}}          //    + "true" if the sum is still 1
                          //      (this means all are even)

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

0

क्लोजर, 82 बाइट्स

#(for[R[(range(count %))]i R](set(for[j R :when(not= i j)](odd?(mod(% j)(% i))))))

आउटपुट रूपांतरण के साथ एक पूर्ण उदाहरण:

(def f #(for[R[(range(count %))]i R](set(for[j R :when(not= i j)](odd?(mod(% j)(% i)))))))
(->> [ 53, 47, 33, 87, 81, 3, 17] f
     (map {#{true} 1, #{false} 2, #{true false} 0}))
; (0 0 0 1 0 2 0)

— NikoNyrh
स्रोत

मोडुलो पैरिटी पार्टी

उदाहरण

नियम

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

पायथन 2 , 68 67 66 बाइट्स

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

यह काम किस प्रकार करता है

MATL , 12 बाइट्स

व्याख्या

सी (जीसीसी) , 118 114 97 92 91 बाइट्स

मैथेमेटिका, 57 49 48 बाइट्स

लाल , 101 बाइट्स

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

जे , 27 20 बाइट्स

स्पष्टीकरण:

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

पर्ल, 38 बाइट्स

स्वच्छ , 95 65 63 बाइट्स

पर्ल 5 , 71 69 + 1 ( -a) = 70 बाइट्स

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

जावा 8, 91 89 बाइट्स

क्लोजर, 82 बाइट्स

पर्ल 5 , 71 69 + 1 ( `-a`) = 70 बाइट्स