Çin Kalan Teoremi modüler aritmetik oldukça yararlı olabilir.

Örneğin, aşağıdaki uyum ilişkileri kümesini göz önünde bulundurun:

Tüm bazların ( 3, 5, 7bu örnekte) birbiriyle ortak olduğu bu gibi uyum ilişkileri kümeleri için, ilişkileri yerine getiren bazların ( bu örnekte) narasında bir ve yalnızca bir tamsayı olacaktır 1( 3*5*7 = 105bu örnekte) .

Bu örnekte, sayı 14şu formülle oluşturulur:

burada 2, 4, and 0yukarıdaki örnekten verilmiştir.

70, 21, 15olan katsayıları , formül ve bazlar bağlıdır 3, 5, 7.

Bir 70, 21, 15grup baz için formülün katsayılarını ( örneğimizde) hesaplamak için aşağıdaki prosedürü kullanırız.

aBir grup kümedeki her sayı için:

1. Olarak belirtilen diğer tüm bazların ürününü bulun P.
2. İlk katı bulmak Po yaprakların bir kalanını 1bölü zaman a. Bu katsayısıdır a.

Örneğin, tabana karşılık gelen katsayıyı hesaplamak için 3, diğer tüm bazların ürününü buluruz (yani 5*7 = 35) ve daha sonra 1bazın bölünmesiyle kalanın kalan ürünün ilk katını buluruz .

Bu durumda, 35bir geri kalan yapraklar 2tarafından bölündüğü zaman 3, fakat 35*2 = 70yaprakların bir kalan 1ile bölündüğü zaman 3, yani 70karşılık gelen katsayısıdır 3. Benzer bir şekilde, 3*7 = 21bir geri kalan yapraklar 1tarafından bölündüğü zaman 5ve 3*5 = 15bir geri kalan yapraklar 1tarafından bölündüğü zaman 7.

Kısaca

Bir sayı akümesindeki her sayı için:

1. Olarak belirtilen diğer tüm numaraların ürününü bulun P.
2. İlk katı bulmak Po yaprakların bir kalanını 1bölü zaman a. Bu katsayısıdır a.

Meydan okuma

• Zorluk, iki veya daha fazla baz kümesi için, karşılık gelen katsayıların kümesini bulmaktır.
• Kaideler setinin ikili eş-üssü olduğu ve her kaidenin 1'den büyük olacağı garanti edilmektedir.
• Girişiniz, girdi [3,4,5]veya boşlukla ayrılmış dize olarak tamsayıların bir listesidir "3 4 5"veya girişleriniz çalışır.
• Çıktınız bir tamsayı listesi veya katsayı kümesini gösteren boşlukla ayrılmış bir dize olmalıdır.

Test senaryoları

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]

Bu zorluğu yazdığı için Leaky Nun'e çok teşekkürler. Her zaman olduğu gibi, sorun net değilse, lütfen bana bildirin. İyi şanslar ve iyi golf!

Haskell, 61 55 53 bayt

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

fGirdiyi alan ve çıktıyı bir tamsayı listesi olarak veren bir işlevi tanımlar .

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

İlk önce girişteki (1) tüm tamsayılar üzerinde döngü yaparız. Sonra tüm tamsayıların (2) çarpımını alır ve sadece ntamsayı olmayanların çarpımını elde etmek için n'ye böleriz , yani P(3).

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

Sonra sonuç ( P) değerini sıfırdan (4) başlayan bir aralık için adım değeri olarak kullanırız . Sonucu alır ve [0, P, 2P, 3P, ...]mod-n işleminin sonucunun bir (5) olduğu değerlere filtre uygularız. Son olarak, tembel değerlendirme sayesinde çalışan ilk unsuru alıyoruz (6).

@Xnor'a 2 bayt için teşekkürler !

Jöle , 11 7 bayt

P:*ÆṪ%P

Çevrimiçi deneyin! veya tüm test senaryolarını doğrulayın .

Arka fon

Let P ve bir kesinlikle pozitif olmak aralarında asal tamsayı.

Söz konusu iki aşamalı işlem - bir çoklu bulma P yaprağı bir kalan bu 1 ile bölünen bir aşağıdaki uyum denklemi ile tanımlanabilir -.

By Euler-Fermat teoremi , elimizdeki

nerede φ belirtir totient . Bu sonuçtan aşağıdakileri çıkarıyoruz.

Son olarak, meydan okuma Px hesaplamamızı gerektirdiğinden ,

nerede Pa tüm modüllerinin ürünü olarak hesaplanabilir.

Nasıl çalışır

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 bayt

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

@Dennis'in şaşırtıcı cevabına dayanarak .

kullanım

Bazı test senaryoları, sonek içeren genişletilmiş tamsayılar olarak girdiye ihtiyaç duyacaktır 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

açıklama

*/|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

Burada deneyin.

Mathematica, 27 bayt

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

Pyth , 14 bayt

mhfq1%Td*R/*FQ

Test odası.

Algoritmanın saf uygulaması.

Jöle, 14 13 bayt

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

@ Dennis sayesinde bir bayt kurtardı !

Meydan okuma özelliğinde açıklanan işlemi kullanır. Girdi bazların bir listesi ve çıktı da katsayıların bir listesidir.

Çevrimiçi deneyin veya tüm test senaryolarını doğrulayın .

açıklama

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 bayt

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

Genişletilmiş Öklid algoritmasını denedim ama 98 bayt sürüyor:

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)

Değerlerin hepsi asalsa, ES7 bunu 56 baytta yapabilir:

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

Python + SymPy, 71 bayt

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

Bu, Jelly cevabımdaki algoritmayı kullanıyor . G / Ç, SymPy numaralarının listesi biçimindedir.

Python 2, 87 84 bayt

Algoritmanın basit bir uygulaması. Golf önerileri hoş geldiniz.

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]

Çedar , 64 bayt

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

GAP , 51 bayt

GAP'ın motive edici örneği ile hesaplayabilen bir işlevi vardır ChineseRem([2,5,7],[2,4,0]), ancak bu hala katsayıları elde etmeyi o kadar kolay hale getirmez. Listeyi n'inci konumda, sıfırı diğer konumlarda ikinci argüman olarak kullanarak n'inci katsayıyı elde edebiliriz. Bu yüzden bu listeleri oluşturmalı ve fonksiyonu hepsine uygulamalıyız:

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

Toplu, 148 bayt

@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%

Aslında 14 bayt

Bu, Dennis'in Jelly cevabındaki algoritmayı kullanır . Python cevabımı temel alan başka bir cevap gelecek. Golf önerileri hoş geldiniz. Çevrimiçi deneyin!

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

Nasıl çalışır

                 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.

22 baytlık Python cevabımı temel alan başka bir cevap. Golf önerileri hoş geldiniz. Çevrimiçi deneyin!

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

Nasıl çalışır

            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.