คุณจะได้รับอาร์เรย์ของnจำนวนเต็มบวกอย่างเคร่งครัดกับn ≥ 2

งานของคุณคือแผนที่แต่ละรายการA _ฉันไปที่:

• 1ถ้าA _j mod A _iนั้นแปลกสำหรับแต่ละjเช่นนั้น1 1 j ≤ nและj ≠ i
• 2ถ้าA _j mod A _iเป็นคู่สำหรับแต่ละjเช่นนั้น1 ≤ j ≤ nและj ≠ i
• 0 เป็นอย่างอื่น (parities แบบผสม)

ตัวอย่าง

สำหรับA = [73, 50, 61]เรามี:

• 50 mod 73 = 50 , 61 mod 73 = 61 →มิกซ์
• 73 mod 50 = 23 , 61 mod 50 = 11 →คี่ทั้งหมด
• 73 mod 61 = 12 , 50 mod 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 ]

Python 2 , 68 67 66 ไบต์

^{-1 ไบต์ขอบคุณ Mr. Xcoder
-1 ไบต์ขอบคุณ ovs}

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

ลองออนไลน์!

ผลตอบแทนแทน1,0,20,1,2

เยลลี่ขนาด 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.

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

C (gcc) , 118 114 97 92 91 ไบต์

• ขอบคุณPeter Cordesสำหรับการแก้ไขข้อผิดพลาด
• บันทึกยี่สิบสี่ไบต์ต้องขอบคุณPeter 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);}}

ลองออนไลน์!

Mathematica, 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 (ทั้งหมดเท่ากัน)

ลองออนไลน์!

สีแดง 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
    ]
]

JavaScript (ES6), 46 ไบต์

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

ส่งคืน -1 (คู่), 1 (คี่) และ 0 (ผสม)

มันทำงานอย่างไร:

ตัวdสะสมจะเป็น:

1. ศูนย์ถ้าทั้งหมดแม้แต่ moduli ( !a[d+1]== false, !d== 1, false - 1== -1 )
2. หนึ่ง^*น้อยกว่าความยาวของอาเรย์ถ้าโมเดอเรนแปลก ๆ ( ^*แอคคูมูเลเตอร์รวมองค์ประกอบที่ปรับเปลี่ยนเองทำให้เกิดโมดูลัสหนึ่งรายการ) ( !a[d+1]== จริง, !d== 0, true - 0== 1 )
3. อย่างน้อยสองความยาวของอาเรย์ถ้ามีการผสม ( !a[d+1]== false, !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 ]

J , 27 20 ไบต์

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

ลองออนไลน์!

ใช้ [1 0] [1] [0] แทน 0 1 2

คำอธิบาย:

|/~ - ทำตารางที่มีเศษ:

  |/~ 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 - เรียงลำดับวางองค์ประกอบสุดท้าย (เสมอศูนย์) รักษาองค์ประกอบ iquenique และกล่องแต่ละแถว:

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

Ruby , 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]สำหรับแบบผสม)

ลองออนไลน์!

Perl, 38 ไบต์

รวม+3สำหรับ-p

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

เอาต์พุต 1 สำหรับทุกค่าเท่ากัน, 2 สำหรับคี่ทั้งหมด, 3 สำหรับผสม

ทำความสะอาด , 95 65 63 ไบต์

import StdEnv

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

ลองออนไลน์!

ในฐานะแลมบ์ดาการถ่าย[Int]และ[Int]การแม็ปกับ:

• 0: ผสม
• 1: ทั้งหมด
• -1: แปลกทั้งหมด

Perl 5 , 71 69 + 1 ( -a) = 70 ไบต์

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

ลองออนไลน์!

Pari / GP , 42 ไบต์

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

ส่งคืน[0, 0], [0, 1], [1, 0]แทน0, 1, 2แทน

ลองออนไลน์!

Java 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)

Clojure, 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)