The Sisa Cina Teorema bisa sangat berguna dalam aritmatika modular.

Misalnya, pertimbangkan rangkaian hubungan kongruensi berikut:

Untuk set hubungan harmoni seperti ini, di mana semua basis ( 3, 5, 7dalam contoh ini) adalah co-prime satu sama lain, akan ada satu dan hanya satu bilangan bulat nantara 1dan produk dari basis ( 3*5*7 = 105dalam contoh ini) inklusif yang memenuhi hubungan .

Dalam contoh ini, angkanya akan 14, dihasilkan oleh rumus ini:

dimana 2, 4, and 0diberikan dari contoh di atas.

70, 21, 15adalah koefisien rumus dan mereka tergantung pada basis 3, 5, 7,.

Untuk menghitung koefisien rumus ( 70, 21, 15dalam contoh kami) untuk satu set pangkalan, kami menggunakan prosedur berikut.

Untuk setiap nomor adalam satu set pangkalan:

1. Temukan produk dari semua pangkalan lain, dilambangkan sebagai P.
2. Temukan kelipatan pertama Pyang meninggalkan sisa 1saat dibagi a. Ini adalah koefisien a.

Misalnya, untuk menghitung koefisien yang sesuai dengan basis 3, kami menemukan produk dari semua basis lainnya (yaitu 5*7 = 35) dan kemudian menemukan kelipatan pertama dari produk yang meninggalkan sisa 1ketika dibagi dengan basis.

Dalam hal ini, 35meninggalkan sisa 2saat dibagi dengan 3, tetapi 35*2 = 70meninggalkan sisa 1saat dibagi dengan 3, demikian 70juga koefisien yang sesuai untuk 3. Demikian pula, 3*7 = 21meninggalkan sisa 1saat dibagi oleh 5dan 3*5 = 15meninggalkan sisa 1saat dibagi oleh 7.

Pendeknya

Untuk setiap nomor adalam satu set angka:

1. Temukan produk dari semua nomor lainnya, dilambangkan sebagai P.
2. Temukan kelipatan pertama Pyang meninggalkan sisa 1saat dibagi a. Ini adalah koefisien a.

Tantangan

• Tantangannya adalah, untuk satu set dua atau lebih pangkalan, untuk menemukan set koefisien yang sesuai.
• Himpunan basis dijamin co-prime berpasangan dan setiap basis dijamin lebih besar dari 1.
• Input Anda adalah daftar bilangan bulat sebagai input [3,4,5]atau string yang dipisahkan ruang "3 4 5"atau bagaimanapun input Anda bekerja.
• Output Anda harus berupa daftar bilangan bulat atau string yang dipisahkan oleh spasi yang menunjukkan set koefisien.

Uji kasus

input             output
[3,5,7]           [70,21,15]
[2,3,5]           [15,10,6]
[3,4,5]           [40,45,36]
[3,4]             [4,9]
[2,3,5,7]         [105,70,126,120]
[40,27,11]        [9801,7480,6480]
[100,27,31]       [61101,49600,56700]
[16,27,25,49,11]  [363825,2371600,2794176,5583600,529200]

Terima kasih banyak kepada Leaky Nun atas bantuannya dalam menulis tantangan ini. Seperti biasa, jika masalahnya tidak jelas, beri tahu saya. Semoga berhasil dan bermain golf dengan baik!

Haskell, 61 55 53 byte

f x=[[p|p<-[0,product x`div`n..],p`mod`n==1]!!0|n<-x]

Menentukan fungsi fyang mengambil input dan memberikan output sebagai daftar bilangan bulat.

f x=[                                          |n<-x]  (1)
              product x                                (2)
                       `div`n                          (3)

Pertama kita mengulang semua bilangan bulat di input (1). Kemudian kita mengambil produk dari semua bilangan bulat (2) dan membaginya dengan n untuk mendapatkan produk dari bukan- nbilangan bulat, yaitu P(3).

           [0,               ..]                       (4)
     [p|p<-                     ,p`mod`n==1]           (5)
                                            !!0        (6)

Kemudian kami menggunakan hasil ( P) sebagai nilai langkah untuk rentang mulai dari nol (4). Kami mengambil hasilnya,, [0, P, 2P, 3P, ...]dan memfilternya pada nilai yang hasil dari operasi mod-n adalah satu (5). Akhirnya, kami mengambil elemen pertama, yang berfungsi berkat evaluasi malas (6).

Terima kasih kepada @xnor untuk 2 byte!

Jelly , 11 7 byte

P:*ÆṪ%P

Cobalah online! atau verifikasi semua kasus uji .

Latar Belakang

Biarkan P dan a benar-benar positif, bilangan bulat koprime .

Proses dua langkah dalam pertanyaan - menemukan kelipatan P yang meninggalkan sisa 1 ketika dibagi dengan a - dapat dijelaskan dengan persamaan kongruensi berikut.

Dengan teorema Euler-Fermat , kita miliki

di mana φ menunjukkan fungsi total Euler . Dari hasil ini, kami menyimpulkan sebagai berikut.

Akhirnya, karena tantangan mengharuskan kita untuk menghitung Px , kami mengamati itu

di mana Pa dapat dihitung sebagai produk dari semua moduli.

Bagaimana itu bekerja

P:*ÆṪ%P  Main link. Argument: A (list of moduli)

P        Yield the product of all moduli.
 :       Divide the product by each modulus in A.
   ÆṪ    Apply Euler's totient function to each modulus.
  *      Raise each quotient to the totient of its denominator.
     %P  Compute the remainder of the powers and the product of all moduli.

J, 13 byte

*/|5&p:^~*/%]

Berdasarkan jawaban luar biasa @Dennis .

Pemakaian

Beberapa test case memerlukan input sebagai bilangan bulat yang diperluas yang memiliki akhiran x.

   f =: */|5&p:^~*/%]
   f 3 5 7
70 21 15
   f 40x 27 11
9801 7480 6480
   f 16x 27 25 49 11
363825 2371600 2794176 5583600 529200

Penjelasan

*/|5&p:^~*/%]  Input: list B
         */    Reduce B using multiplication to get the product of the values
            ]  Identity function, get B
           %   Divide the product by each value in B, call the result M
   5&p:        Apply the totient function to each value in B, call the result P
       ^~      Raise each value in M to the power of its corresponding value in P
*/             The product of the values in B
  |            Compute each power modulo the product and return

Coba di sini.

Mathematica, 27 byte

PowerMod[a=LCM@@#/#,-1,#]a&

Pyth , 14 byte

mhfq1%Td*R/*FQ

Suite uji.

Implementasi algoritma yang naif.

Jelly, 14 13 byte

P:×"Ḷð%"’¬æ.ḷ

Menyimpan satu byte berkat @ Dennis !

Menggunakan proses yang dijelaskan dalam spec tantangan. Input adalah daftar pangkalan dan output adalah daftar koefisien.

Cobalah secara online atau Verifikasi semua kasus uji .

Penjelasan

P:×"Ḷð%"’¬æ.ḷ  Input: a list B
P              Get the product of the list
 :             Divide it by each value in the B, call it M
    Ḷ          Get a range from 0 to k for k in B
  ×"           Vectorized multiply, find the multiples of each M
     ð         Start a new dyadic chain. Input: multiples of M and B
      %"       Vectorized modulo, find the remainders of each multiple by B
        ’      Decrement every value
               If the remainder was 1, decrementing would make it 0
         ¬     Logical NOT, zeros become one and everything else becomes 0
            ḷ  Get the multiples of M
          æ.   Find the dot product between the modified remainders and the multiples
               Return

JavaScript (ES6), 80 byte

a.map(e=>[...Array(e).keys()].find(i=>p*i/e%e==1)*p/e,p=a.reduce((i,j)=>i*j))

Saya mencoba algoritma Euclidean yang diperluas tetapi membutuhkan 98 byte:

a=>a.map(e=>(r(e,p/e)+e)%e*p/e,p=a.reduce((i,j)=>i*j),r=(a,b,o=0,l=1)=>b?r(b,a%b,t,o-l*(a/b|0)):o)

Jika semua nilai prima, ES7 dapat melakukannya dalam 56 byte:

a=>a.map(e=>(p/e%e)**(e-2)%e*p/e,p=a.reduce((i,j)=>i*j))

Python + SymPy, 71 byte

from sympy import*
lambda x:[(prod(x)/n)**totient(n)%prod(x)for n in x]

Ini menggunakan algoritma dari jawaban Jelly saya . I / O adalah dalam bentuk daftar nomor SymPy.

Python 2, 87 84 byte

Implementasi sederhana dari algoritma. Saran bermain golf diterima.

a=input();p=1
for i in a:p*=i
print[p/i*j for i in a for j in range(i)if p/i*j%i==1]

Cheddar , 64 byte

n->n.map(i->(|>i).map(j->(k->k%i>1?0:k)(n.reduce((*))/i*j)).sum)

GAP , 51 byte

GAP memiliki fungsi yang dapat menghitung contoh yang memotivasi ChineseRem([2,5,7],[2,4,0]), tetapi itu masih tidak membuatnya mudah untuk mendapatkan koefisien. Kita bisa mendapatkan koefisien ke-n dengan menggunakan daftar dengan satu di posisi ke-n dan nol di posisi lain sebagai argumen kedua. Jadi kita perlu membuat daftar ini dan menerapkan fungsinya untuk semuanya:

l->List(Basis(Integers^Size(l)),b->ChineseRem(l,b))

Batch, 148 byte

@set p=%*
@set/ap=%p: =*%
@for %%e in (%*)do @for /l %%i in (1,1,%%e)do @call:l %%e %%i
@exit/b
:l
@set/an=p/%1*%2,r=n%%%1
@if %r%==1 echo %n%

Sebenarnya, 14 byte

Ini menggunakan algoritma dalam jawaban Dennis's Jelly . Jawaban lain berdasarkan pada jawaban Python saya akan datang. Saran bermain golf diterima. Cobalah online!

;π;)♀\;♂▒@♀ⁿ♀%

Bagaimana itu bekerja

                 Implicit input a.
;                Duplicate a.
 π;)             Take product() of a, duplicate and rotate to bottom.
    ♀\           Integer divide the product by each element of a. Call this list b.
      ;♂▒        Take that list, duplicate, and get the totient of each element.
         @♀ⁿ     Swap and take pow(<item in b>, <corresponding totient>)
            ♀%   Modulo each item by the remaining duplicate product on the stack.
                 Implicit return.

Jawaban lain berdasarkan pada jawaban Python saya sebesar 22 byte. Saran bermain golf diterima. Cobalah online!

;π╖`╝╛╜\╛r*"╛@%1="£░`M

Bagaimana itu bekerja

            Implicit input a.
;π╖         Duplicate, take product of a, and save to register 0.
`...`M      Map over a.
  ╝           Save the item, b, in register 1.
  ╛╜\         product(a) // b. Call it P.
  ╛r          Take the range [0...b].
  *           Multiply even item in the range by P. Call this list x.
  "..."£░     Turn a string into a function f.
              Push values of [b] where f returns a truthy value.
    ╛@%         Push b, swap, and push <item in x> % b.
    1=          Does <item> % b == 1?
            Implicit return.