12

นี่เป็นความท้าทายของตำรวจและโจร กระทู้ Cops 'เพื่อความท้าทายนี้อยู่ที่นี่

คำถามที่น่าสนใจที่ต้องคิดคือต่อไปนี้:

หากฉันมีลำดับตัวเลขฉันต้องระบุจำนวนเท่าใดก่อนที่จะชัดเจนว่าฉันกำลังพูดถึงลำดับใด

ตัวอย่างเช่นถ้าฉันต้องการพูดคุยเกี่ยวกับจำนวนเต็มบวกตามลำดับที่เริ่มต้นจากฉันสามารถพูดได้แต่นั่นก็เพียงพอ $1$ $1,2,3, \dots$

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

ท้าทาย

ความท้าทายนี้เป็นตำรวจและโจรท้าทาย ในกรณีที่ตำรวจจะนำเสนอกรณีทดสอบและโจรจะต้องหาวิธีที่สั้นกว่าเพื่อหลอกกรณีทดสอบอื่น ๆ นอกเหนือจากลำดับที่ตั้งใจไว้ ตำรวจจะนำเสนอสิ่งต่อไปนี้:

ชิ้นส่วนของรหัสที่ใช้จำนวนเต็มบวกเป็นอินพุตและสร้างจำนวนเต็มเป็นผลลัพธ์ รหัสนี้สามารถเป็นศูนย์หรือดัชนีหนึ่ง แต่ควรมีความชัดเจนว่าการจัดทำดัชนีคืออะไร รหัสนี้จะกำหนดลำดับของคุณ
ข้อกำหนดแพลตฟอร์มหรือภาษาที่เกี่ยวข้องใด ๆ ที่อาจมีผลต่อเอาต์พุตตัวอย่างเช่นขนาดของ longint
จำนวนพร้อมกับครั้งแรกแง่ของการลำดับตามที่คำนวณได้จากรหัส สิ่งเหล่านี้จะทำหน้าที่เป็น "กรณีทดสอบ" $n$ $n$

โจรจะค้นหาโปรแกรมในภาษาเดียวกันที่สั้นกว่าที่นำเสนอและผ่านกรณีทดสอบทั้งหมด (สร้างเอาต์พุตเดียวกันสำหรับอินพุตแรกเป็นรหัสของตำรวจ) รหัสโม่งก็ต้องแตกต่างกันในการส่งออกจากโปรแกรมของตำรวจสำหรับจำนวนบางส่วนมีขนาดใหญ่กว่าn $n$ $n$

เกณฑ์การให้คะแนน

โจรจะได้คะแนนในจำนวนรอยแตกที่พวกเขาพบว่ามีรอยแตกมากขึ้นจะดีขึ้น คำตอบสามารถแตกอีกครั้งโดยการค้นหาคำตอบที่ถูกต้องสั้นกว่ารอยแตกเดิม หากคำตอบคือรอยร้าวเป็นครั้งที่สองจะให้คะแนนแก่แครกเกอร์ที่สองมากกว่าคำตอบ

sequence cops-and-robbers

— Ad Hoc Garf Hunter
แหล่งที่มา

2

โจรพวกเราจะไม่ปล่อยให้ชนะในแต่ละอื่น ๆ สำหรับการแตกร้าวคำตอบ (เช่นที่สั้นแตกในภาษาที่ชนะ)

— fənɛtɪk

@ fəˈnɛtɪk เสียงดีฉันเพิ่มที่

— Ad Hoc Garf Hunter

6

cQuents , คำตอบของสตีเฟ่น 3 ไบต์

z~$

ลองออนไลน์!

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

z     Last item in the sequence
 ~    Concat
  $   Current index

ดูเหมือนว่าลำดับที่ควรจะเหมือนกัน แต่นี้จะช่วยให้12345678910สำหรับn = 10ในขณะที่ช่วยให้"::$1234567891

— bubbler
แหล่งที่มา

5

JavaScript คำตอบของ fəˈnɛtɪk (17 ไบต์)

x=>"11237"[x]||22

มันเป็นเรื่องง่ายที่ hardcode จะได้คะแนนที่ต่ำกว่ามาก ... แตกต่างจากการใช้งานอ้างอิงสำหรับรายการใด ๆ , 0-indexed สิ่งนี้ใช้เคล็ดลับการเล่นกอล์ฟ JS ที่รู้จักกันดี: การจัดทำดัชนีในลำดับที่มีจำนวนเต็มที่เกินขอบเขตของมันจะส่งกลับค่าเท็จ ( ) ดังนั้นมันสามารถถูก coerced กับค่าเริ่มต้นโดยใช้ตรรกะหรือ ( ) ในสิ่งนี้ กรณีการจัดการคำสุดท้ายของลำดับ แต่ยังต้องปฏิบัติตาม $x\ge 6$ undefined||22

การทดสอบ

let f=x=>"11237"[x]||22

for (x of [1,2,3,4,5,6,7]) {
  console.log(x + ' -> ' + f(x))
}

ขยายตัวอย่างข้อมูล

หรือลองออนไลน์!

— นาย Xcoder
แหล่งที่มา

4

Haskell , คำตอบของ Laikoni 15 ไบต์

b n=n*div(n+1)2

ลองออนไลน์!

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

นี่เป็นเพียงคำตอบของ BMOb 42ลบกรณีพิเศษสำหรับ เนื่องจากต้นฉบับของ Laikoni ต้องผ่านจุดลอยตัวจึงไม่จำเป็นเพียงแค่หาจำนวนที่มากพอที่จะให้ข้อผิดพลาดในการปัดเศษในนั้น แต่ไม่ใช่Integerเลขคณิตที่แน่นอน ตัวอย่างเช่น:

a 100000000000000000000000 = 4999999999999999580569600000000000000000000000
b 100000000000000000000000 = 5000000000000000000000000000000000000000000000

— Ørjan Johansen
แหล่งที่มา

ฉันคิดว่าสิ่งนี้อาจเป็นไปได้ (ด้วยเหตุนี้ฉันจึงเขียนว่าสามารถเขียนใหม่สำหรับคำที่ต้องการ) แต่ไม่พบคุณค่าที่ใช้งานได้ .. ทำได้ดีมาก!

— იოო

4

งูหลาม 2 , คำตอบของ XNOR 43 ไบต์

ความแตกต่างแรกเกิดขึ้นสำหรับ : $n = 69$

f=lambda n,p=2:n<1or-~f(n-(~-2**p%p<2),p+1)

ลองออนไลน์!

เครดิต

เครดิตจำนวนมากสำหรับรอยแตกนี้ต้องไปที่@ Mr.Xcoderซึ่งเป็นคนแรกที่โพสต์ความคิดเห็นเกี่ยวกับการโจมตีที่เป็นไปได้โดยใช้วิธีการนี้และ@PoonLeviที่พบวิธีแก้ปัญหา 44 ไบต์

อย่างไร?

ทฤษฎี

รอยแตกนั้นขึ้นอยู่กับทฤษฎีบทเล็ก ๆ ของแฟร์มาต์ซึ่งระบุว่าถ้าเป็นไพร์มและและค่อนข้างไพเราะดังนั้น: $p$ $a$ $p$

\begin{matrix} (1) & a^{p - 1} \equiv 1 (\mod p) \end{matrix}

$a^{p-1}\equiv 1 \pmod p\tag{1}$

โดยเฉพาะอย่างยิ่งสำหรับ : $a=2$

2^{p - 1} \equiv 1 (\mod p)

$2^{p-1}\equiv 1 \pmod p$

ดังนั้นจึงมีจำนวนเต็มบวกเช่นนั้น: $k$

2^{p - 1} = k p + 1

$2^{p-1}=kp+1$

ซึ่งนำไปสู่:

2^{p} = 2 k p + 2

$2^p=2kp+2$

2^{p} - 1 = 2 k p + 1

$2^p-1=2kp+1$

\begin{matrix} (2) & 2^{p} - 1 \equiv 1 (\mod p) \end{matrix}

$2^p-1\equiv 1 \pmod p\tag{2}$

สูตรสุดท้ายนี้เป็นรหัสที่ได้มาจาก Python และตอนนี้เก็บไว้สำหรับถึงแม้ว่าจะไม่ได้เป็นตัวของตัวเอง $p=2$ $2$

ตอนนี้สำหรับส่วนที่สำคัญที่สุด: การสนทนาของทฤษฎีบทเล็ก ๆ ของแฟร์มาต์ไม่เป็นความจริง เราอาจจะมีสำหรับบางคอมโพสิตจำนวนnตัวเลขดังกล่าวเรียกว่าpseudoprimes แฟร์มาต์ไปยังฐาน pseudoprimes แฟร์มาต์ไปยังฐาน 2 เป็นที่รู้จักกันในชื่อหมายเลขPoulet $a^{n-1}\equiv 1 \pmod n$ $n$ $a$

Fermat pseudoprime ตัวแรกถึงฐาน (หรือหมายเลข Poulet แรก) คือซึ่งเรามี: $2$ $n = 341=11\times 31$

2^{341 - 1} \equiv 1 (\mod 341)

$2^{341-1}\equiv 1 \pmod{341}$

2^{341} - 1 \equiv 1 (\mod 341)

$2^{341}-1\equiv 1 \pmod{341}$

ซึ่งหมายความว่าอัลกอริทึมของเราเป็นไปเพื่อกลับแทนการที่คาดว่าจะ 69 ^วันที่สำคัญ347 $341$ $347$

การดำเนินงาน

@PoonLeviพบวิธีแก้ปัญหา 44- ไบต์ต่อไปนี้ซึ่งจะขึ้นอยู่กับโดยตรง: $(2)$

f=lambda n,p=1:n and-~f(n-(~-2**p%p==1),p+1)

โดยการใช้<2แทน==1เราจะประหยัด 1 ไบต์ แต่เราแนะนำในลำดับเนื่องจาก : $1$ $2^1-1\equiv 0 \pmod 1$

f=lambda n,p=1:n and-~f(n-(~-2**p%p<2),p+1)

ลองออนไลน์!

โดยเริ่มต้นด้วยเราจะได้รับเงื่อนไขที่คาดหวังไว้โดย 1 เพราะเราทำซ้ำได้น้อยลง: $p=2$

f=lambda n,p=2:n and-~f(n-(~-2**p%p<2),p+1)

ลองออนไลน์!

เคล็ดลับสุดท้ายคือการใช้แทนn<1or n andนี่เป็นเวลานาน แต่ทำให้การทำซ้ำครั้งล่าสุดกลับเป็นTrueแทนที่จะเป็น0ดังนั้นการเพิ่มการชดเชยที่ขาดหายไปให้กับแต่ละคำ

— Arnauld
แหล่งที่มา

ขอแสดงความยินดีกับคุณทุกคน! นี่คือทางออกที่ฉันมีอยู่ในใจ ฉันคิดว่ามันตลกที่จากแรงบันดาลใจในการท้าทาย "ถ้าฉันมีลำดับของตัวเลขฉันต้องให้พวกเขาจำนวนเท่าไหร่ก่อนที่จะชัดเจนว่าฉันกำลังพูดถึงลำดับอะไร" 50 ช่วงแรกไม่ชัดเจน - เอเลี่ยนไพ ธ อนกอล์ฟสมมติว่าคุณกำลังพูดถึงลำดับที่แตกต่างกัน

— xnor

@ xnor ฉันชอบความคิดของ "คนต่างด้าว Python-golfing"

— dylnan

3

Python 3 , crashoz , 45 ไบต์

lambda n:int(60*math.sin(n/10-2))
import math

ลองออนไลน์!

นิพจน์x*60-x**3*10+x**5/2-x**7/84คือชุดอนุกรมของจนถึงเทอมคูณด้วย 60 นี่คือความถูกต้องเพียงพอของอินพุตที่ใช้ แต่สำหรับค่าที่สูงกว่าทั้งสองจะแยกจากกันเมื่อเทอมที่ถูกตัดทอนมีความเกี่ยวข้องมากขึ้น $sin(x)$ $x^7$

— XNOR
แหล่งที่มา

3

JavaScript (ES6) คำตอบของ Arnauld (10 ไบต์)

n=>8*n*n|n

ลองออนไลน์!

— NGN
แหล่งที่มา

2

Haskell , คำตอบของ Laikoni , 26 22 ไบต์

_{-4 ไบต์โดยไม่ใช้มัดdivขอบคุณLaikoni !}

b 42=0;b n=n*div(n+1)2

ลองออนไลน์!

คำอธิบาย

สำหรับคำสามารถเขียนใหม่ซึ่งทำให้เรามีไบต์เพียงพอที่จะจับคู่รูปแบบกับที่นำไปสู่การถอดรหัสภายใน 28 ไบต์: $0 \leq n \leq 20$ ceiling(realToFrac n/2)div(n+1)2 $n > 20$

b 42=0

— ბიმო
แหล่งที่มา

อาฉันไม่คิดอย่างนั้น ฉันมีวิธีการที่แตกต่างกันซึ่งนำไปสู่การแตก 20 ไบต์ในกรณีที่คุณต้องการปริศนาอีกเล็กน้อย นอกจากนี้ยัง->((n+1)`div`2) div(n+1)2

— Laikoni

@Laikoni: ใช่ยังไม่เปิดเผยเลย! อ๊ะใช่แล้วมันค่อนข้างนานแล้วตั้งแต่ฉันเล่นกอล์ฟฉันจะอัพเดท

— ბიმო

2

> <> , crashoz ของคำตอบที่ 203 ไบต์

:l2-$g:0=?;n:





M
-
B
"
BM
",
7M
!"
BBM
!",
7CM
!"-
BBBM
!!",
7BBMM
!!,,
7BBBMM
!!,,
7BBBMM
!!!,,
7BBBBMM
!!!,,
7BBBBMM
!!!!,,
7BBBBBMM
!!!!,,
7BBBBBMM
!!!!!,,
7BBBBBBMM

ลองออนไลน์!

ฉันจะทำสิ่งที่ฉลาดด้วยความจริงที่ว่าเลขคี่ / คู่ข้างบนn=20นั้นเหมือนกันยกเว้นองค์ประกอบที่ทำซ้ำที่กึ่งกลาง แต่มันง่ายกว่าที่จะเขียนโค้ดยากทุกองค์ประกอบ

การป้อนข้อมูลผ่าน-vธง พิมพ์อะไรสำหรับองค์ประกอบที่สูงกว่า 34

— ล้อเล่น
แหล่งที่มา

2

Pascal (FPC) , คำตอบของ AlexRacer , 80 ไบต์

var n,m:word;begin read(n);while n<>0 do begin n:=n div 2;m:=m+n;end;write(m)end.

ลองออนไลน์!

เมื่อผลเหมือนกัน แต่เมื่อเอาท์พุทโค้ดข้างต้นในขณะที่ AlexRacer ของเอาท์พุทรหัส126 $0\le n\le 120$ $n=128$ $127$ $126$

ดูเหมือนว่าจะเป็นคำตอบที่ช้า แต่ขอบคุณ @AlexRacer สำหรับปริศนาที่ดี!

— r_64
แหล่งที่มา

1

ว้าวนี่สั้นกว่าที่ฉันมี ยินดีต้อนรับสู่ PPCG!

— AlexRacer

1

JavaScript คำตอบของ fəˈnɛtɪk (12 ไบต์)

สิ่งนี้ใช้ได้กับค่าที่กำหนด แต่ล้มเหลวสำหรับค่าอื่น ๆ (เช่น ) เนื่องจากข้อผิดพลาดความแม่นยำ $x=6$

x=>2.72**x|0

การทดสอบ

g=
x=>2.72**x|0

tmp=[0,1,2,3,4]
console.log(tmp.map(g).join(','))

ขยายตัวอย่างข้อมูล

หรือลองออนไลน์!

— นาย Xcoder
แหล่งที่มา

1

JavaScript คำตอบของ fəˈnɛtɪk (17 ไบต์)

คุณสามารถมองเห็นในการเชื่อมโยง TIO หรือในผล Stack Snippet ว่ามันล้มเหลวสำหรับรายการที่สูงกว่า15 $15$

x=>2.7182819**x|1

หากต้องการความแม่นยำสำหรับ (ค่าแรก) เท่านั้นก็จะทำงานได้เช่นกันสำหรับ 16 ไบต์ $n\le 14$ $15$ x=>Math.exp(x)|1

การทดสอบ

f=x=>2.7182819**x|1
g=x=>(3-(5/63)**.5)**x|1

tmp=[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21]
console.log(tmp.map(f).join(","))
console.log(tmp.map(g).join(","))

ขยายตัวอย่างข้อมูล

หรือลองออนไลน์!

— นาย Xcoder
แหล่งที่มา

1

แกลบแตกบีเอ็ม 5 ตัวด้วย 3 2 ไบท์

-1 ขอบคุณที่ BMO ( LdΣ-> LΣตั้งแต่เมื่อได้รับTnum, L"ความยาวของการแสดงสตริง" ดำเนินการ)

LΣ

ลองออนไลน์!

ความยาวดิจิตอลของตัวเลขสามเหลี่ยม * ตรงกับ $a(0)\cdots a(23)$ $a(24)$
LΣ $3$ ←d+16 $4$

_{$T(0)=0$ $1$ $0$}

— Jonathan Allan
แหล่งที่มา

ขอแสดงความยินดีนั่นเป็นคำตอบที่ถูกต้องของฉัน! แต่ฉันเพียงแค่ตั้งข้อสังเกตว่าสำหรับTNum s LและLd เทียบเท่าประหยัดคุณไบต์;)

— ბიმო

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

— Jonathan Allan

(โปรดทราบว่าพวกเขาจะเทียบเท่ากับจำนวนเต็มไม่เป็นลบ - ดีพอสำหรับเรื่องนี้)

— Jonathan Allan

1

> <> , ไอเอฟเพียร์ซของคำตอบที่ 36 ไบต์

v101786
i5844
419902
%
>l{:}g:0=?;o:

ลองออนไลน์!

วิธีการแก้ปัญหาอื่นที่มีแต่ละค่า hardcoded ต่อบรรทัด เนื่องจากคำตอบดั้งเดิมส่วนใหญ่เป็นรหัสยากฉันไม่รู้สึกผิดเกี่ยวกับเรื่องนี้

— ล้อเล่น
แหล่งที่มา

0

JavaScript คำตอบของ fəˈnɛtɪkขนาด 23 ไบต์

$0$ $n\ge 14$

x=>14-`${73211e9}`[x]|0

ลองออนไลน์!

อย่างไร?

นิพจน์`${73211e9}`จะขยายไปยังสตริง"73211000000000"โดยระบุตารางการค้นหาที่มีค่า 14 ค่าที่ถูกลบออกจาก 14 ซึ่งให้ลำดับที่คาดไว้

$n\ge 14$

(14 - undefined) | 0
=== NaN | 0
=== 0

21 ไบต์

NaN $n\ge 14$

x=>14-`${73211e9}`[x]

ลองออนไลน์!

— Arnauld
แหล่งที่มา

Hardcoding the Cops and Robbers (โจร)

ท้าทาย

เกณฑ์การให้คะแนน

cQuents , คำตอบของสตีเฟ่น 3 ไบต์

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

JavaScript คำตอบของ fəˈnɛtɪk (17 ไบต์)

การทดสอบ

Haskell , คำตอบของ Laikoni 15 ไบต์

งูหลาม 2 , คำตอบของ XNOR 43 ไบต์

เครดิต

อย่างไร?

ทฤษฎี

การดำเนินงาน

Python 3 , crashoz , 45 ไบต์

JavaScript (ES6) คำตอบของ Arnauld (10 ไบต์)

Haskell , คำตอบของ Laikoni , 26 22 ไบต์

คำอธิบาย

> <> , crashoz ของคำตอบที่ 203 ไบต์

Pascal (FPC) , คำตอบของ AlexRacer , 80 ไบต์

JavaScript คำตอบของ fəˈnɛtɪk (12 ไบต์)

การทดสอบ

JavaScript คำตอบของ fəˈnɛtɪk (17 ไบต์)

การทดสอบ

แกลบแตกบีเอ็ม 5 ตัวด้วย 3 2 ไบท์

> <> , ไอเอฟเพียร์ซของคำตอบที่ 36 ไบต์

JavaScript คำตอบของ fəˈnɛtɪkขนาด 23 ไบต์

อย่างไร?

21 ไบต์