ภารกิจมีดังต่อไปนี้ ได้รับจำนวนเต็มx(เช่นที่xโมดูโล100000000003ไม่เท่ากับ0) นำเสนอให้กับรหัสของคุณในทางที่คุณพบว่าสะดวกเอาท์พุทจำนวนเต็มอีกเพื่อให้y < 100000000003(x * y) mod 100000000003 = 1

รหัสจะต้องใช้เวลาน้อยกว่า 30 นาทีในการทำงานบนเครื่องเดสก์ท็มาตรฐานสำหรับการใด ๆการป้อนข้อมูลดังกล่าวว่าx|x| < 2^40

กรณีทดสอบ

อินพุต: 400000001 เอาต์พุต: 65991902837

อินพุต: 4000000001 เอาต์พุต: 68181818185

อินพุต: 2. เอาต์พุต: 50000000002

อินพุต: 50000000002 เอาต์พุต: 2

อินพุต: 1000000 เอาต์พุต: 33333300001

ข้อ จำกัด

คุณไม่สามารถใช้งานไลบรารีหรือฟังก์ชันบิวด์อินใด ๆ ที่ดำเนินการทางคณิตศาสตร์แบบโมดูโล (หรือการดำเนินการแบบผกผันนี้) ซึ่งหมายความว่าคุณไม่สามารถทำได้a % bโดยไม่ต้องดำเนินการ%เอง คุณสามารถใช้ฟังก์ชั่นทางคณิตศาสตร์อื่น ๆ ที่ไม่ใช่แบบโมดูโลได้

คำถามที่คล้ายกัน

นี้คล้ายกับคำถามนี้แม้ว่าหวังว่าจะแตกต่างกันพอที่จะยังคงเป็นที่สนใจ

Pyth, 24 ไบต์

L-b*/bJ+3^T11Jy*uy^GT11Q

ชุดทดสอบ

สิ่งนี้ใช้ความจริงที่ว่า ^ (p-2) mod p = a ^ -1 mod p

ก่อนอื่นฉันปรับใช้โมดูลัสด้วยตนเองสำหรับกรณีเฉพาะของ mod 100000000003 ฉันใช้สูตรa mod b = a - (a/b)*bซึ่ง/เป็นส่วนที่เป็นพื้น ฉันสร้างโมดูลัสที่มี10^11 + 3การใช้รหัส+3^T11แล้วบันทึกไว้ในJแล้วใช้นี้และสูตรข้างต้นในการคำนวณข mod 100000000003 -b*/bJ+3^T11Jกับ ฟังก์ชั่นนี้ถูกกำหนดให้เป็นด้วยyL

ต่อไปฉันเริ่มด้วยอินพุตจากนั้นนำไปที่กำลังสิบและลด mod 100000000003 และทำซ้ำ 11 ครั้ง y^GTเป็นรหัสที่ดำเนินการในแต่ละขั้นตอนและuy^GT11Qเรียกใช้ 11 ครั้งเริ่มต้นด้วยอินพุต

ตอนนี้ฉันมีQ^(10^11) mod 10^11 + 3และฉันต้องการQ^(10^11 + 1) mod 10^11 + 3ดังนั้นฉันจึงคูณด้วยอินพุตด้วย*ลด mod 100000000003 ด้วยyหนึ่งครั้งสุดท้ายและเอาต์พุต

Haskell , 118 113 105 101 ไบต์

แรงบันดาลใจจากโซลูชันนี้

-12 จากØrjan Johansen

p=10^11+3
k b=((p-2)?b)b 1
r x=x-div x p*p
(e?b)s a|e==0=a|1<2=(div e 2?b$r$s*s)$last$a:[r$a*s|odd e]

ลองออนไลน์!

Haskell , 48 ไบต์

เขียนใหม่ของการแก้ปัญหานี้ ในขณะที่เร็วพอสำหรับเวกเตอร์ทดสอบโซลูชันนี้ช้าเกินไปสำหรับอินพุตอื่น

s x=until(\t->t-t`div`x*x==0)(+(10^11+3))1`div`x

ลองออนไลน์!

Brachylogขนาด 22 ไบต์

∧10^₁₁+₃;İ≜N&;.×-₁~×N∧

ลองออนไลน์!

การดำเนินการนี้ใช้เวลาประมาณ 10 นาทีสำหรับ1000000โค้ดที่แตกต่างกันเล็กน้อย (และนานกว่า) ซึ่งเร็วกว่าสองเท่า (ตรวจสอบเฉพาะค่าบวกของİแทนที่จะเป็นทั้งค่าบวกและค่าลบ) ดังนั้นควรใช้เวลาประมาณ 20 นาทีจึงจะเสร็จสมบูรณ์สำหรับอินพุตนั้น

คำอธิบาย

เราอธิบายอย่างนั้นInput × Output - 1 = 100000000003 × an integerและให้ข้อ จำกัด ทางคณิตศาสตร์หาOutputเรา

∧10^₁₁+₃                   100000000003
        ;İ≜N               N = [100000000003, an integer (0, then 1, then -1, then 2, etc.)]
            &;.×           Input × Output…
                -₁         … - 1…
                  ~×N∧     … = the product of the elements of N

ในทางเทคนิคเราไม่จำเป็นต้องมีการติดฉลากอย่างชัดเจน≜แต่ถ้าเราไม่ได้ใช้มัน~×จะไม่ตรวจสอบเคสN = [100000000003,1](เพราะมันมักจะไร้ประโยชน์) ซึ่งหมายความว่ามันจะช้ามากสำหรับการป้อนข้อมูล2เช่นเพราะมันจะต้องค้นหาจำนวนเต็มที่น้อยที่สุด แทนที่จะเป็นคนแรก

Python, 53 51 49 58 53 49 ไบต์

-2 ไบต์ขอบคุณ orlp
-2 ไบต์ขอบคุณ officialaimm
-4 ไบต์ขอบคุณ Felipe Nardi Batist
-3 ไบต์ขอบคุณ isaacg
-1 ไบต์ขอบคุณØrjan Johansen
-2 ไบต์ขอบคุณ Federico Poloni

x=input()
t=1
while t-t/x*x:t+=3+10**11
print t/x

ลองออนไลน์!

ฉันใช้เวลาประมาณ 30 นาทีในการหาอันนี้ วิธีแก้ปัญหาของฉันคือการเริ่มต้นด้วยจำนวนแรกที่จะแก้ไขถึง 1 จำนวนนี้คือ 1 ถ้ามันหารด้วย x แล้ว y คือจำนวนนั้นหารด้วย x ถ้าไม่เพิ่ม 10000000003 ไปยังหมายเลขนี้เพื่อค้นหาหมายเลขที่สองซึ่ง mod 1000000003 จะเท่ากับ 1 และทำซ้ำ

JavaScript (ES6), 153 143 141 ไบต์

แรงบันดาลใจจากคำตอบนี้จาก math.stackexchange.com

ฟังก์ชันแบบเรียกซ้ำตามอัลกอริทึมแบบยุคลิด

f=(n,d=(F=Math.floor,m=1e11+3,a=1,c=n,b=F(m/n),k=m-b*n,n>1))=>k>1&d?(e=F(c/k),a+=e*b,c-=e*k,f(n,c>1&&(e=F(k/c),k-=e*c,b+=e*a,1))):a+d*(m-a-b)

Modulo นำมาใช้โดยการคำนวณ:

quotient = Math.floor(a / b);
remainder = a - b * quotient;

เนื่องจากความฉลาดทางยังต้องการด้วยการทำเช่นนั้นทำให้รู้สึกจริง

กรณีทดสอบ

let f =

f=(n,d=(F=Math.floor,m=1e11+3,a=1,c=n,b=F(m/n),k=m-b*n,n>1))=>k>1&d?(e=F(c/k),a+=e*b,c-=e*k,f(n,c>1&&(e=F(k/c),k-=e*c,b+=e*a,1))):a+d*(m-a-b)

console.log(f(2))
console.log(f(50000000002))
console.log(f(1000000))

C ++ 11 (GCC / Clang, Linux), 104 102 ไบต์

using T=__int128_t;T m=1e11+3;T f(T a,T r=1,T n=m-2){return n?f(a*a-a*a/m*m,n&1?r*a-r*a/m*m:r,n/2):r;}

https://ideone.com/gp41rW

Ungolfed ขึ้นอยู่กับทฤษฎีบทของออยเลอร์และการยกกำลังเลขฐานสอง

using T=__int128_t;
T m=1e11+3;
T f(T a,T r=1,T n=m-2){
    if(n){
        if(n & 1){
            return f(a * a - a * a / m * m, r * a - r * a / m * m, n / 2);
        }
        return f(a * a - a * a / m * m, r, n / 2);
    }
    return r;
}

Mathematica, 49 ไบต์

x/.FindInstance[x#==k(10^11+3)+1,{x,k},Integers]&

PHP, 71 ไบต์

for(;($r=bcdiv(bcadd(bcmul(++$i,1e11+3),1),$argn,9))!=$o=$r^0;);echo$o;

Testcases

ทับทิม 58 ไบต์

ใช้การประยุกต์ใช้ทฤษฎีบทเล็ก ๆ ของแฟร์มาต์ในขณะนี้ในขณะที่ฉันเสร็จสิ้นการกำหนดเวลาวิธีการแก้ปัญหากำลังดุร้าย

->n,x=10**11+3{i=n;11.times{i**=10;i-=i/x*x};i*=n;i-i/x*x}

รุ่นแรงเดรัจฉานปัจจุบันซึ่งเป็น 47 ไบต์ แต่อาจจะ เป็นช้าเกินไป:

->n,x=10**11+3{(1..x).find{|i|i*=n;i-i/x*x==1}}

ลองออนไลน์!