_{(ผ่านการแชท )}

รายการ OEIS A123321แสดงลำดับของตัวเลขที่เป็นผลคูณของเจ็ดช่วงเวลาที่แตกต่างกัน เพื่อความกระชับเราจะเรียกหมายเลข7DPนี้ ตัวเลขสองสามตัวแรกและตัวหารที่เกี่ยวข้องมีดังนี้:

510510 = 2 * 3 * 5 * 7 * 11 * 13 * 17
570570 = 2 * 3 * 5 * 7 * 11 * 13 * 19
690690 = 2 * 3 * 5 * 7 * 11 * 13 * 23
746130 = 2 * 3 * 5 * 7 * 11 * 17 * 19

ความท้าทายที่นี่จะค้นหาหมายเลข 7DP ที่ใกล้เคียงที่สุดในแง่ของระยะทางที่แน่นอนจากอินพุตที่กำหนด

อินพุต

เดียวจำนวนเต็มบวกnในรูปแบบที่สะดวก

เอาท์พุต

หมายเลข 7DP ที่ใกล้เคียงที่สุดถึงnอีกครั้งในรูปแบบที่สะดวก หากมีการเชื่อมโยงตัวเลข 7DP สองตัวใกล้เคียงกันคุณสามารถส่งออกอย่างใดอย่างหนึ่งหรือทั้งสองอย่าง

กฎระเบียบ

• ตัวเลขสามารถสันนิษฐานได้ว่าเหมาะสมกับ[int]ประเภทข้อมูลเริ่มต้นของภาษาของคุณ(หรือเทียบเท่า)
• ยอมรับได้ทั้งโปรแกรมหรือฟังก์ชั่น
• ช่องโหว่มาตรฐานเป็นสิ่งต้องห้าม
• นี่คือรหัส - กอล์ฟดังนั้นกฎการเล่นกอล์ฟตามปกติทั้งหมดจึงนำมาใช้และรหัสที่สั้นที่สุดชนะ

ตัวอย่าง

5 -> 510510
860782 -> 870870
1425060 -> 1438710 (or 1411410, or both)

Python, 89 86 85 ไบต์

f=lambda n,k=0:126^sum(1>>n%i<<7*(n/i%i<1)for i in range(2,n))and f(n+k,k%2*2+~k)or n

อัลกอริทึมคือO (น่ากลัว) ที่จะเริ่มต้นด้วยและการเรียกซ้ำไม่ได้ช่วย แต่มันทำงานได้ดีตราบใดที่nใกล้พอกับจำนวน 7DP

ขอบคุณ @xnor สำหรับการเล่นกอล์ฟ 3 ไบต์!

ทดสอบบนrepl.it

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

Python ไม่มีบิวด์อินแบบดั้งเดิมหรือการแยกตัวประกอบ แต่เราสามารถระบุหมายเลข 7DP ตามจำนวนและลักษณะของตัวหาร

โดยหลักการคูณจำนวนตัวหารของจำนวนเต็มสามารถคำนวณเป็นผลคูณของเลขชี้กำลังที่เพิ่มขึ้นของการแยกตัวประกอบเฉพาะ ดังนั้นσ ₀ (n) ( ฟังก์ชันตัวหาร ) คือ2 ^mเมื่อใดก็ตามที่nคือหมายเลข mDP

σ ₀ (n) = 128จึงเป็นเงื่อนไขที่จำเป็น แต่ไม่เพียงพอ ตัวอย่างเช่นσ ₀ (2 ¹²⁷ ) = 128แต่2 ¹²⁷ไม่ชัดเจนว่าเป็นตัวเลข 7DP อย่างไรก็ตามถ้าทั้งσ ₀ (n) = 128และไม่มีการหารกำลังสองที่สมบูรณ์แบบnเท่ากันดังนั้นnคือตัวเลข 7DP

สำหรับอินพุตnอัลกอริทึมประกอบด้วยการตรวจสอบจำนวนเต็มn , n - 1 , n + 1 , n - 2 , n + 2และอื่น ๆ และส่งกลับค่าแรกที่เป็นตัวเลข 7DP

เมื่อfถูกเรียกด้วยอาร์กิวเมนต์nจะเกิดสิ่งต่อไปนี้:

• รหัส

  126^sum(1>>n%i<<7*(n/i%i<1)for i in range(2,n))

  การทดสอบถ้าnเป็นไม่ได้เป็นจำนวน 7DP ดังต่อไปนี้

  สำหรับจำนวนเต็มทั้งหมดฉันดังกล่าวที่1 <i <n , 1>>n%i<<7*(n/i%i<1)ได้รับการประเมิน

  • ถ้าnหารด้วยฉันแต่ไม่ใช่ฉัน² , 1>>n%iอัตราผลตอบแทน1และ(n/i%i<1)อัตราผลตอบแทน0ผลใน
    1 · 2 ^{7 · 0} = 1

  • ถ้าnหารด้วยฉัน² , 1>>n%iและ(n/i%i<1)ทั้งอัตราผลตอบแทน1ผลใน1 · 2 ^{7 · 1} = 128

  • ถ้าnไม่ได้ไม่หารด้วยฉัน , 1>>n%iอัตราผลตอบแทน0ผลใน0 · 2 ^{7 · x} = 0

  
  ผลรวมของจำนวนเต็มผลจะ2 ^เมตร - 2ถ้าnเป็นจำนวน MDP (ของ2 ^เมตรหารไม่รวม1และn ) และมากกว่าจำนวนกว่า127ถ้าnมีปัจจัยตารางที่สมบูรณ์ ดังนั้นผลรวมจะเป็น126ถ้าหากว่าnเป็นตัวเลข 7DP เท่านั้น

• สำหรับตัวเลข 7DP ผลรวมคือ126ดังนั้น XORing ด้วย126อัตราผลตอบแทน0ซึ่งเป็นเท็จ ดังนั้นการหรือเป็นส่วนหนึ่งของแลมบ์ดาจะถูกดำเนินการและฉผลตอบแทนมูลค่าปัจจุบันของn

• ถ้าnไม่ใช่ตัวเลข 7DP XOR จะส่งกลับค่าที่ไม่ใช่ศูนย์ ดังนั้นแลมบ์ดาและบางส่วนถูกดำเนินการ

  f(n+k,k%2*2+~k)

  เรียกfซ้ำด้วยค่าที่อัพเดตของn (หมายเลข 7DP ที่เป็นไปได้ถัดไป) และk (ความแตกต่างระหว่างตัวเลือกใหม่กับหนึ่งหลังจากนั้น)

  ถ้าkเป็นจำนวนเต็มแม้ไม่ใช่เชิงลบ, k%2*2อัตราผลตอบแทน0และ~kอัตราผลตอบแทน- (k + 1) ผลรวมของผลทั้งเป็น- (k + 1)ซึ่งเป็นที่แปลกจำนวนเต็มลบที่เป็น1มากขึ้นในค่าสัมบูรณ์กว่าk

  ถ้าkเป็นเลขคี่จำนวนเต็มลบk%2*2ผลตอบแทนถัวเฉลี่ยที่ 2และ~kอัตราผลตอบแทน- (k + 1) ผลรวมของผลทั้งเป็น2 - (k + 1) = - (k - 1)ซึ่งเป็นจำนวนเต็มแม้ไม่ใช่เชิงลบที่เป็น1หน่วยมากขึ้นในค่าสัมบูรณ์กว่าk

  ซึ่งหมายความว่าkการใช้ค่า0, -1, 2, -3, 4, ⋯

  เมื่อเพิ่มเข้ากับn ₀ (ค่าเริ่มต้นของn ) จำนวนเต็มที่ได้คือ

  • n ₀ + 0
  • ( n ₀ + 0) - 1 = n ₀ - 1
  • ( n ₀ - 1) + 2 = n ₀ + 1
  • ( n ₀ + 1) - 3 = n ₀ - 2
  • ( n ₀ - 2) + 4 = n ₀ + 2
  • เป็นต้น

  
  ทำให้แน่ใจว่าจำนวน 7DP แรกที่เราพบจะใกล้เคียงกับn ₀ที่เป็นไปได้

Brachylog , 44 40 16 ไบต์

_{ข้ามไป 44 ยังคงเป็นปกติ 44; (}

:I=+.>0,.$pPdPl7

ตัวอย่าง:

?- run_from_atom(':I=+.>0,.$pPdPl7',1425060,Z).
Z = 1438710 .

เป็นไปได้ไหมว่าภาษานี้อาจไม่ได้ดูดเสมอไป? ฉันชนะ Jelly และ MATL!

เคสทดสอบ5ยาวที่สุดและใช้เวลาประมาณ 10 วินาทีบนเครื่องของฉัน

นี่จะเป็น 12 ไบต์ถ้า$pไม่ถูกบั๊ก (เราไม่ต้องการ>0,.ส่วน)

คำอธิบาย

Brachylog ใช้การโปรแกรมแบบลอจิก จำกัด โดยค่าเริ่มต้นสำหรับเลขจำนวนเต็มทั้งหมด ยิ่งไปกว่านั้นการติดฉลากในตัว=ทำงานบนโดเมนที่ไม่มีที่สิ้นสุด

มันรวมตัวแปรอย่างต่อเนื่องโดยไม่มีข้อ จำกัด (เช่นใน(-inf, inf)) เช่น: 0, 1, -1, 2, -2, 3, ….

ดังนั้นเราสามารถรับหมายเลข 7DP ที่ใกล้เคียงที่สุดโดยค้นหาหมายเลขแรกที่Iรวมเป็นหนึ่ง(-inf, inf)(โดยใช้การย้อนรอยอัตโนมัติ) ซึ่งInput + Iเป็นหมายเลข 7DP

:I=                Label variables in [Input, I]. I has no constraints and Input is known
   +.              Unify Output with Input + I
     >0,           Output > 0 (wouldn't be needed if $p failed for numbers less than 1)
        .$pP       Unify P with the list of prime factors of Output
            dP     Check that P with duplicates removed is still P
              l7   Check that the length of P is 7

เยลลี่ขนาด 17 ไบต์

Pµạ³,
×⁹ÆRœc7Ç€ṂṪ

ทำงานในทฤษฎี แต่ใช้เวลาหลายปีกว่าจะเสร็จสมบูรณ์

นี่คือรุ่นที่ใช้งานได้จริงกับอินพุตที่กำหนด แต่ในทางทฤษฎีแล้วล้มเหลวสำหรับอินพุตขนาดใหญ่:

Pµạ³,
50ÆRœc7Ç€ṂṪ

ลองที่นี่ สิ่งนี้จะสร้างช่วงเวลาทั้งหมดได้สูงสุด 50 รายการจากนั้นค้นหาช่วงเวลา 7 ช่วงทั้งหมดในรายการนั้นจากนั้นจึงแสดงผลิตภัณฑ์ทั้งหมด ในที่สุดมันก็หาองค์ประกอบที่ใกล้เคียงที่สุดจากรายการที่จะโต้แย้งที่กำหนด

แน่นอนเมื่อ 7DP ของเรามีช่วงเวลาที่สูงกว่า 50 ครั้งสิ่งนี้จะล้มเหลว เวอร์ชันทางทฤษฎีสร้างช่วงเวลาทั้งหมดได้ถึง256nสำหรับอินพุตnแต่จะทำงานในลักษณะเดียวกัน

พิสูจน์

ขอแสดงว่าหลังจากที่นายกรัฐมนตรีต่อไปp(x) xขอบเขตบน (หลวมมาก) สำหรับผลิตภัณฑ์ 7DP ที่ใกล้เคียงที่สุดกับ x คือ:

p(x) * p(p(x)) * p(p(p(x))) * ... * p(p(p(p(p(p(p(x)))))))

ดังนั้นเราจะต้องตรวจสอบเฉพาะใน[2 ... พี (พี (พี (พี (พี (พี (P (x)))))))] สัจพจน์ของเบอร์แทรนด์กล่าวว่าP (x) ≤ 2xดังนั้นจึงพอเพียงที่จะตรวจสอบเฉพาะทั้งหมดขึ้นอยู่กับ128X

MATL , 21 17 16 14 13 ไบต์

ขอบคุณ Dennis สำหรับคำแนะนำที่ลบ 4 ไบต์และอีกหนึ่งรายการที่บันทึกไว้ 1 ไบต์!

t17*Zq7XN!pYk

ทฤษฎีนี้ใช้งานได้ แต่หน่วยความจำ6ไม่เพียงพอสำหรับอินพุตด้านบน(คอมไพเลอร์ออนไลน์)

รุ่นที่มีประสิทธิภาพยิ่งขึ้นใช้21 ไบต์และคำนวณกรณีทดสอบทั้งหมดในเวลาประมาณหนึ่งวินาที:

t3e4/k16+_YqZq7XN!pYk

ลองออนไลน์!

• รุ่นที่ไม่มีประสิทธิภาพของหน่วยความจำ
• รุ่นที่มีประสิทธิภาพของหน่วยความจำ
• รุ่นที่มีประสิทธิภาพหน่วยความจำทุกกรณีทดสอบ

คำอธิบาย

รุ่นที่มีประสิทธิภาพของหน่วยความจำ

รับอินพุตN = 860782เป็นตัวอย่าง มันพอเพียงที่จะต้องพิจารณาถึงช่วงเวลาที่M = 29ซึ่งเป็นครั้งแรกที่สำคัญนั้นคูณด้วย2*3*5*7*11*13เกินกว่า N ในตัวอย่าง2*3*5*7*11*13*29 = 870870นี้ 31นายกต่อไปคือ ผลิตภัณฑ์ใด ๆ ที่เกี่ยวข้องกับ Prime หรือมากกว่านั้นอย่างน้อยที่สุด2*3*5*7*11*13*31 = 930930และดังนั้นจึงรับประกันได้ว่าจะไม่เป็นทางออกเพราะเกิน870870กว่าN N

Mmax(N/(2*3*5*7*11*13), 16)คำนวณเป็นมากขึ้นที่สำคัญกว่าครั้งแรก maxฟังก์ชั่นที่ใช้สำหรับการสร้างความมั่นใจว่าอย่างน้อย17จะเลือก หากต้องการบันทึกสองสามไบต์โค้ดจะถูกแทนที่2*3*5*7*11*13 = 30030ด้วย30000และทำงานmaxตามการเพิ่ม การเปลี่ยนแปลงเหล่านี้ถูกต้องเพราะให้ค่าที่มากกว่า

t      % Take input implicitly. Duplicate
3e4/k  % Divide input by 30000 and round down (rounding here is only needed
       % due to a bug in the "next prime" function)
16+    % Add 16
_Yq    % Next prime
Zq     % Prime numbers up to that value
7XN    % Combinations of those primes taken 7 at a time. Gives a 2D array
       % with each combination on a different row
!p     % Product of each row
Yk     % Output product that is closest to the input. Implicitly display

รุ่นที่ไม่มีประสิทธิภาพของหน่วยความจำ

หากต้องการลดจำนวนไบต์ให้มากขึ้นการหารสามารถลบออกได้ ในความเป็นจริงมันพอเพียงที่จะคูณด้วย17(ขอบคุณ @Dennis) เพื่อให้แน่ใจว่านี้ที่สำคัญต่อไปคือการรวม (โดยสัจพจน์ของเบอร์แทรนด์ ) 17และผลที่ได้คืออย่างน้อย ทฤษฎีนี้ใช้งานได้ แต่หน่วยความจำ6ไม่เพียงพอสำหรับอินพุตที่ใหญ่กว่า

ในรหัสส่วน

3e4/k  % Divide input by 30000 and round down (rounding here is only needed
       % due to a bug in the "next prime" function)
16+    % Add 16
_Yq    % Next prime

ถูกแทนที่ด้วย

17*    % Multiply by 17

Pyke, 32 ไบต์

#PDl 7q.ID}lRlqi*(#)DF-X,)R],She

ลองที่นี่!

โปรดทราบว่านี่ไม่ได้ผลออนไลน์ - หมดเวลา รุ่นนี้จะตรวจสอบเฉพาะ 2 ช่วงเวลาที่แตกต่างกันและควรทำงานได้เร็วขึ้น เมื่อมีระยะห่างจากเป้าหมายเท่ากับ 2 หมายเลขจะเป็นการเลือกช่วงล่าง

สิ่งนี้จะผ่านตัวเลขทั้งหมดจนกว่าจะพบว่ามีขนาดใหญ่กว่าอินพุตและเป็น 7DP สำหรับแต่ละหมายเลขมันจะทำการลบหากไม่ใช่ 7DP จากนั้นจะมีรายการของ 7DPs ขึ้นอยู่กับอินพุทที่มีขนาดใหญ่กว่า จากนั้นจะเลือกอันที่ใกล้กับอินพุตมากที่สุด

Julia ขนาด 59 ไบต์

!n=sort(map(prod,combinations(17n|>primes,7))-n,by=abs)[]+n

สิ่งนี้ไม่มีประสิทธิภาพมากแต่มันใช้ได้กับกรณีทดสอบครั้งแรกในทางปฏิบัติและสำหรับคนอื่น ๆ ในทางทฤษฎี

ด้วยค่าใช้จ่าย 5 ไบต์ขึ้นไป - รวม64 ไบต์ - สามารถปรับปรุงประสิทธิภาพได้อย่างมาก

!n=sort(map(prod,combinations(n>>14+17|>primes,7))-n,by=abs)[]+n

ลองออนไลน์!

พื้นหลัง

ดังที่ได้กล่าวไว้ในคำตอบของ @ LuisMendoชุดของช่วงเวลาที่เราต้องพิจารณาสำหรับหมายเลข 7DP ที่ใกล้ที่สุดนั้นค่อนข้างเล็ก มันเพียงพอสำหรับการตั้งค่าให้มีหมายเลข 7DP ที่ใหญ่กว่าอินพุทnซึ่งจะเป็นจริงถ้าหากมีเฉพาะไพร์ม17 such เช่น30300p = 2 · 3 · 5 · 7 · 11 · 13 · p ≥ nn

ในช่วงเวลาที่มีอย่างน้อยหนึ่งจำนวนเฉพาะพิสูจน์ให้เห็นว่าช่วง[x, 1.5x)มีอย่างน้อยหนึ่งจำนวนเฉพาะเมื่อใดก็ตามที่x ≥ 8 ตั้งแต่30030/16384 ≈ 1.83นั่นหมายความว่าจะต้องมีนายกพีใน(n / 30030, n / 16384)เมื่อใดก็ตามที่n> 8 · 30300 = 242400

สุดท้ายเมื่อn <510510 , p = 17ก็เพียงพอแล้วอย่างชัดเจนดังนั้นเราจะต้องพิจารณาถึงช่วงเวลาn / 16384 + 17

ด้วยค่าใช้จ่ายที่มีประสิทธิภาพเราสามารถพิจารณาเฉพาะช่วงเวลาได้ถึง17nแทน งานนี้เมื่อn = 1และเป็นอย่างมากมายใหญ่กว่าn / 16384 + 17สำหรับค่าขนาดใหญ่ของn

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

17n|>primesและn>>14+17|>primes(bitshift เทียบเท่ากับการหารด้วย2 ¹⁴ = 16384 ) คำนวณช่วงที่สำคัญที่กล่าวถึงในย่อหน้าก่อนหน้า จากนั้นcombinations(...,7)คำนวณอาร์เรย์ทั้งหมดของเจ็ดจำนวนเฉพาะที่แตกต่างกันในช่วงนั้นและการแมปprodกับตัวเลขที่คำนวณผลิตภัณฑ์ของพวกเขาเช่นตัวเลข 7DP ที่เราจะเลือกคำตอบ

ถัดไป-nลบn prom แต่ละหมายเลข 7DP แล้วsort(...,by=abs)เรียงลำดับความแตกต่างเหล่านั้นด้วยค่าสัมบูรณ์ สุดท้ายเราเลือกที่แตกต่างกันครั้งแรกกับ[]และคำนวณจำนวน 7DP ที่สอดคล้องกันโดยการเพิ่มn+nกับ

Pyth, 30 ไบต์

L&{IPbq7lPby#.W!syMH,hhZa0teZ,

ลองออนไลน์!

ชุดทดสอบ

(5 ใช้เวลานานเกินไปที่จะเรียกใช้)

คำอธิบาย

L&{IPbq7lPby#.W!syMH,hhZa0teZ,

L&{IPbq7lPb     Defines a function y, whose argument is b:
 &                  Return if both the following are true:
  {IPb                  the prime factorization contains no duplicate; and:
      q7lPb             the number of prime factors is 7

           y#.W!syMH,hhZa0teZ,   The main programme. Input as Q.
                             ,QQ Implicit arguments, yield [Q,Q].
             .W                  While
               !syMH                   both numbers do not satisfy y:
                    ,hhZ             increment the first number
                          teZ        and decrement the second number
                        a0           while making it non-negative.

Mathematica 136 80 75 ไบต์

nนี่คือวิธีการที่ตรงไปตรงมาในการทำงานออกจาก

nเป็นผลิตภัณฑ์ 7 แบบที่แตกต่างกันหากจำนวนของปัจจัยสำคัญคือ 7 ( PrimeNu@#==7) และไม่มีปัจจัยเหล่านี้ปรากฏมากกว่าหนึ่งครั้ง ( SquareFreeQ@#&)

g@n_:=(k=1;While[!(PrimeNu@#==7&&SquareFreeQ@#&)⌊z=n-⌊k/2](-1)^k⌋,k++];z)

ส่งก่อนหน้านี้ของฉัน (136 ไบต์) พบทั้งผลิตภัณฑ์ที่แตกต่างกัน 7-prime แรกข้างต้นnและถ้ามันมีอยู่แล้วผลิตภัณฑ์ที่แตกต่างกัน 7-prime nแรกด้านล่าง nจากนั้นก็เพียงแค่กำหนดซึ่งเป็นผู้ใกล้ชิดกับ หากผลิตภัณฑ์มีความยาวเท่ากันมันจะส่งคืนทั้งสอง

เวอร์ชันปัจจุบันตรวจสอบ n-1, n + 1, n-2, n + 2 ... จนกว่าจะถึงผลิตภัณฑ์ 7-prime-prime แรกที่ชัดเจน รุ่นที่มีประสิทธิภาพมากกว่านี้ใช้วิธีการของเดนนิส

ความก้าวหน้าหลักคือการใช้⌊k/2](-1)^k⌋เพื่อส่งคืนซีรีย์ 0, 1, -1, 2, -2 ... ศูนย์ใช้เพื่อตรวจสอบว่าnตัวเองเป็นผลิตภัณฑ์ที่แตกต่างกัน 7 แบบหรือไม่ ด้วยเหตุนี้Floor(นั่นคือ⌊...⌋) Ceilingถูกนำมาใช้แทน

g[5]
g[860782]
g[1425060]

510510

870870

1438710

05AB1E , 10 ไบต์

°Åp7.ÆPs.x

ลองออนไลน์!

ลองชุดค่าผสมทั้งหมดของ 7 จาก 10 อินพุตแรกเข้า ** หน่วยความจำหมดสำหรับอินพุตที่มากกว่า 1

เวอร์ชัน 14 ไบต์มีประสิทธิภาพมากขึ้น:

5°/7+Åp7.ÆPs.x

ลองออนไลน์!

ใช้ช่วงแรก (อินพุต / 100000 + 7)