นี่คือตำรวจและโจรปริศนาด้ายโจรสามารถพบได้ที่นี่

งานของคุณจะเป็นสองเขียนสองโปรแกรม (หรือฟังก์ชั่น) เช่นที่พวกเขามีanagramsของแต่ละอื่น ๆ และหนึ่งดำเนินการตรงกันข้ามซ้ายของอีก โปรแกรมเหล่านี้อาจยอมรับและส่งออกเป็นจำนวนเต็มหรือจำนวนเชิงซ้อนตามที่คุณต้องการ หากคุณเลือกใช้ตัวเลขเป็นคะแนนอักขระหรือวิธีการอื่นที่สมเหตุสมผลคุณต้องระบุว่าคุณทำเช่นนั้นในคำตอบของคุณ หากคุณเลือกที่จะ จำกัด โดเมนของฟังก์ชันคุณต้องระบุโดเมนที่ถูก จำกัด ในคำตอบของคุณ

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

โปรแกรมที่แสดงจะต้องใช้ฟังก์ชั่นการฉีด (ไม่อย่างนั้นมันจะเป็นไปไม่ได้สำหรับคำตอบที่ซ่อนอยู่)

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

เป้าหมายคือการสร้างคำตอบที่ไม่แตกสั้นที่สุดเป็นไบต์

ตัวอย่าง

คุณสามารถแสดงโปรแกรมไพ ธ อนต่อไปนี้ที่เพิ่มหนึ่งรายการลงในอินพุต

lambda x:~-x

ทางออกอาจเป็น:

lambda x:-~x

วิธีนี้จะลบหนึ่งรายการจากอินพุต

Python 3, 80 ไบต์ ( แคร็ก )

bhmq = int(input())
print(bhmq ** 2)
(1 or [(sqrt),(specification+of*integerr)])

โดเมน: จำนวนเต็มบวก ฟังก์ชั่นเป็นกำลังสองของตัวเลข อินพุตไปยัง stdin, ส่งออกไปยัง stdout เช่นเดียวกับในฟังก์ชันผกผัน โปรดทราบว่า Python จะไม่สนใจบรรทัดที่สามที่นี่เนื่องจากมีความถูกต้องทางไวยากรณ์และ 1 เป็นค่าจริงดังนั้น Python จึงไม่ได้ดูว่าส่วนที่ถูกต้องของ 'หรือ' ถูกกำหนดไว้อย่างดี

โจรควรเขียนฟังก์ชั่น sqrt ที่จะทำงานได้อย่างถูกต้องในสี่เหลี่ยมที่ไม่เป็นศูนย์ทั้งหมดพิมพ์ค่าจำนวนเต็มตามที่เป็นอยู่โดยไม่มีจุดลอยตัว (ดังนั้นในอินพุต '4' เอาต์พุตควรเป็น '2' หรือ '2 \ n' ไม่ใช่ '2.0' หรือ '2.0 \ n')

Python 3, 46 ไบต์, แคร็ก

lambda x:x*(1999888577766665//844333333222200)

เพิ่มอินพุตเป็นสองเท่า

7 , 9 ไบต์, แคร็ก

โปรแกรมนี้เต็มไปด้วยอักขระที่ไม่สามารถพิมพ์ได้ดังนั้นนี่คือ hexdump:

00000000: 2573 dc01 7e13 dcb6 1f                   %s..~....

หมายเหตุ: สิ่งนี้ใช้รูทีนตัวเลขที่ไม่สามารถป้อนจำนวนลบได้ดังนั้นการส่งนี้ถูก จำกัด ให้เป็นจำนวนเต็มเท่านั้น

ปัญหาหนึ่งที่ท้าทายความสามารถของตำรวจและโจรคือคุณไม่ได้เขียนคำอธิบายของรหัส (เพื่อทำให้การถอดรหัสยากขึ้น) ในทางตรงกันข้ามนี่หมายความว่าฉันไม่ต้องไปที่ปัญหาที่นี่

ฉันเลือกภาษาเป็น 7 เพราะโดยเฉพาะอย่างยิ่งในสัญกรณ์บีบอัดของมันมันค่อนข้างยากที่จะอ่านและฉันไม่เห็นว่าทำไมมันควรจะเป็นเพียงฉันเท่านั้นที่ต้องไปที่ปัญหาในการเคลื่อนย้ายโปรแกรม 8 บิตที่เขียนด้วยภาษา การเข้ารหัส 3 บิต โชคดี!

คำอธิบาย

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

เราจะเริ่มต้นด้วยการเป็นตัวแทนของโปรแกรมในการเข้ารหัสที่เป็นธรรมชาติยิ่งขึ้น ตามปกติหมายเลขตัวหนาบ่งชี้คำสั่งที่ทำงานทันที (ไม่ทุกคนที่อยู่ในที่แทนโปรแกรม; 6และ7มี แต่2จะ5ไม่ได้), ตัวเลข unbolded แทนเทียบเท่าหนีของพวกเขา ( 0ไป5ทั้งหมดที่มีอยู่ในโปรแกรมซึ่งแสดงต้นฉบับ; ทราบ นั่น0คือการหลบหนี6และ1การหลบหนี7):

112 7 1 7 34002 77 023 67 13303

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

772 | 7 | 34662 | 023 | 73363

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

73363 
7       กดองค์ประกอบที่ว่างเปล่าบนกอง
  3      ออกองค์ประกอบบนกองทิ้งองค์ประกอบดังต่อไปนี้
 73      ผลรวมของเหล่านี้: ทิ้งองค์ประกอบด้านบนสแต็ค
   3     ขาออกองค์ประกอบบนกองทิ้งองค์ประกอบดังต่อไปนี้
    6    หนีองค์ประกอบด้านบนสแต็คแล้ว ผนวกเข้ากับองค์ประกอบด้านล่าง
     3   เอาท์พุทองค์ประกอบสแต็คด้านบนทิ้งองค์ประกอบด้านล่าง

กล่าวอีกนัยหนึ่งนี่เป็นเพียงส่วนหนึ่งของคำแนะนำ I / O มาวิเคราะห์รายละเอียดกันดีกว่า:

• 73ทิ้งส่วน73363ที่ยังอยู่ด้านบนของสแต็ก
• 3ผลผลิตและละเว้น023 34662มันสามารถเห็นได้ว่า34662เป็นความคิดเห็นซึ่งถูกใช้ในการจัดเก็บไบต์ที่จำเป็นในรุ่นอื่น ๆ ของโปรแกรม สำหรับสิ่งที่023เมื่อเอาท์พุทมันจะเลือกรูปแบบ I / O 0 (จำนวนเต็ม) จากนั้น23เป็นคำสั่งที่ร้องขอการดำเนินการเพื่อป้อนจำนวนเต็ม (ใน 7 คุณป้อนข้อมูลผ่านรหัสเฉพาะที่ร้องขอการป้อนข้อมูล) การป้อนข้อมูลจะกระทำโดยการทำสำเนาขององค์ประกอบสแต็คที่อยู่ด้านล่างเช่นถ้าจำนวนเต็มใส่เป็น 10 องค์ประกอบสแต็คถัดไป (ปัจจุบัน7) 7777777777จะกลายเป็น ดังนั้นเรายอมรับการป้อนข้อมูลจากผู้ใช้เป็นทศนิยม
• 6escapes องค์ประกอบสแต็คด้านบน (เปลี่ยนแต่ละอินสแตนซ์ของ7เป็น1นี่คือวิธีที่สตริงที่ประกอบด้วย7s ทั้งหมดถูก Escape) จากนั้นผนวกเข้ากับองค์ประกอบสแต็กก่อน ( 772) 7721111111111ดังนั้นข้อมูลของเราในขณะนี้คือสิ่งที่ต้องการ
• ขั้นสุดท้ายให้3ส่งองค์ประกอบสแต็กที่เป็นปัญหา (และดึงองค์ประกอบสแต็กเปล่าที่เป็นส่วนหนึ่งของสแต็กเริ่มต้นเริ่มต้น) ค่าของมันถูกคำนวณโดยใช้จำนวนของ1s และ7s และลบจำนวนของ0s และ6s ( 2ตรงกลางจะถูกละเว้นในกรณีส่วนใหญ่ถ้ามันอยู่ที่ส่วนท้ายของสตริงมันจะกลายเป็นบรรทัดใหม่ต่อท้ายแทนที่จะถูกละเว้น แต่กฎ PPCG ไม่สนใจเรื่องนั้น) ดังนั้นผลลัพธ์เป็นต้นฉบับ อินพุตบวก 2

ณ จุดนี้ไม่มีอะไรที่เป็นประโยชน์ในสแต็กและไม่มีอะไรในโปรแกรมดังนั้นโปรแกรมจึงออก

เราจะย้อนกลับได้อย่างไร มันเป็นเรื่องธรรมดาของการเปลี่ยนแปลง11ไป00เพื่อที่ว่าเรากำลัง prepending ตัวอักษรเพื่อป้อนข้อมูลที่ทำให้มัน 2 ลดลงมากกว่า 2 สูงขึ้น มี00ตัวเลขแปดแปดหลักที่ซ่อนอยู่ในโปรแกรมอย่างสะดวก (เพื่อให้เลขฐานแปดและไบต์เรียงกัน) ดังนั้นเราสามารถสลับกับ11ตอนเริ่มต้นได้

JavaScript (ES6), 21 ไบต์, แคร็ก

นี่เป็นวิธีที่ง่าย

b=>Math.pow(b,torc=3)

ส่งคืนคิวบ์ของอินพุต

Python 2, 83 ไบต์, แคร็ก

#((()))****+,,---/2289;==oppppppqqqqqw~~
lambda n:pow(n,65537,10998167423251438693)

นี่คล้ายกับคำตอบอื่น ๆ ของฉัน อย่างไรก็ตามสิ่งนี้ใช้ RSA 64- บิตและการเข้ารหัสค่อนข้างอ่อนแอ หากคุณสามารถปล้นคำตอบนี้ได้คุณสามารถขโมยอีกคนในทางทฤษฎีได้ด้วย

Python 2, 47 ไบต์, แคร็ก

lambda x:x**2or (iron() and saxifrage.extend())

โดเมนสำหรับฟังก์ชั่นนี้คือ {x ∈ℤ | x> 0} มันกำลังสองอินพุต

nmjcman101พบโซลูชันที่ต้องการ:

lambda x:sorted(a**2for a in range(x)).index(x)

JavaScript (ES6), 46 ไบต์, แคร็ก

x=>Math.log(x+(+String(t=985921996597669)[5]))

ฟังก์ชั่นนี้จะส่งกลับln(x+1)โดยที่xเป็นจำนวนที่ไม่เป็นลบ

การใช้

(x=>Math.log(x+(+String(t=985921996597669)[5])))(5)

หมายเหตุ:เนื่องจากลักษณะของลอยหมายเลขจุดอาจไม่เท่ากับว่าf(g(x)) xตัวอย่าง:f(g(4))=3.9999999999999996

J, 8 ไบต์แตก

อีกหนึ่งอย่างง่ายที่จะเริ่มต้นด้วย

[:]+:[-:

เพิ่มอินพุตเป็นสองเท่า

กำลังประมวลผล.js, 59 ไบต์, แคร็ก!

float igetuwebaoli(int p){return p*(((17*-4*-3)))+0+0;}//,,

ฟังก์ชันนี้คูณอินพุตด้วย204( 17*-4*-3=204) มันใช้เวลาใน int เป็นอินพุทและเอาท์พุทลอย 204เป็นที่คาดหวังผกผันแบ่งการป้อนข้อมูลโดย

ล่ามออนไลน์สำหรับการประมวลผล-js สามารถพบได้ที่นี่

J, 10 ไบต์แตก

1%~<:[@*>:

อีกแบบง่าย ๆ ส่งคืนn ² -1

JavaScript (ES6) 15 ไบต์แตกโดย Emigna

t=>(!!0+~~t+~0)

n-1ฟังก์ชั่นนี้ผลตอบแทน

คุณสามารถทดสอบได้เช่น:

(t=>(!!0+~~t+~0))(6)

Cracked

ทางออกที่ฉันตั้งใจจะแตกต่างจากรอยแตกของ Emigna เล็กน้อย:

t=>t+(+!!~~~00)

J , 29 ไบต์ ( ถอดรหัสเป็นไมล์)

5#.[:,(3 5&#:(-$]-)7)#.inv"0]

นี่เป็นคำกริยาที่ใช้จำนวนเต็มบวกเป็นอินพุตและทำสิ่งต่อไปนี้:

1. แปลงเป็นฐาน 2 และ 4
2. ทำหน้าที่เป็นตัวแทนฐาน 4 ด้วย 0s เพื่อให้มีความยาวเท่ากับตัวแทน 2 ฐาน
3. เชื่อมการรับรองทั้งสองเข้าด้วยกัน (ฐาน -2 ก่อน)
4. ตีความการต่อข้อมูลเป็นตัวแทนพื้นฐาน 5 และแปลงเป็นจำนวนเต็ม

ลองออนไลน์!

ทางออกของฉัน

ตรรกะนั้นค่อนข้างเหมือนกับในรอยร้าว การรวมอันดับ"สามารถติดอยู่ในสถานที่ต่าง ๆ (และฉันใช้เพื่อกำจัดสิ่งที่ไม่จำเป็น0และ3) เนื่องจากมันไม่ได้ทำอะไรเลยในการแก้ปัญหา

(7-5)#.[:(]-:&#$,)5#.inv"0 3]

กำลังประมวลผล (java), 59 ไบต์, ปลอดภัย

float igetuwebaoli(int p){return p*(((17*-4*-3)))+0+0;}//,,

ฟังก์ชันนี้คูณอินพุตด้วย204( 17*-4*-3=204) มันใช้เวลาใน int เป็นอินพุทและเอาท์พุทลอย 204เป็นที่คาดหวังผกผันแบ่งการป้อนข้อมูลโดย หมายเหตุ: โปรแกรมทั้งสองใช้ int เป็นอินพุตและเอาต์พุตลอย

คำตอบนี้เหมือนกับคำตอบอื่น ๆ ของฉันยกเว้นว่าคำตอบอื่น ๆ ของฉันเขียนใน Processing.js Meet Processing-java, ลูกพี่ลูกน้อง verbose น้อยของ Java คุณสามารถดาวน์โหลดการประมวลผลที่นี่ที่ processing.org

รอยแตก

float ap(int i){return i*pow(blue(get(0,0)),-1);}//++7*4*-3

204โปรแกรมนี้จะแบ่งการโต้แย้งโดย แต่อย่างไร เราเข้าไปข้างในฟังก์ชั่นกัน

i *                              //multiply i by
         blue( get(0, 0) )       //this (evaluates to 204)
    pow(                  , -1)  //raises to the -1 power (ie its reciprocal)

ง่ายพอ แต่จะblue( get(0, 0) )กลายเป็น204อย่างไร นี่คือหัวใจของการส่งนี้ ก่อนอื่นget(0,0)รับสีของพิกเซลที่(0,0)(มุมบนซ้ายของหน้าต่างซึ่งจะเปิดในแบบร่างการประมวลผลเสมอ) ถัดไปblue()รับค่าสีน้ำเงินของพิกเซลนั่นคือ204!

get(0,0)ที่จะเกิดขึ้นกับการส่งนี้ผมทดลองโดยการพิมพ์คุณลักษณะที่แตกต่างกันของสีที่ได้จากการ ฉันได้พบว่าสีแดง, สีเขียว, สีฟ้า, ค่าอัลฟามี204, 204, 204และ255ตามลำดับ จากนี้ฉันตัดสินใจที่จะดำเนินการอย่างง่ายด้วยหมายเลขนี้และจบลงด้วยการโพสต์นี้

JavaScript (ES6), 63 ไบต์แตกโดย Ilmari Karonen

x=>eval(atob`eCp4KzEvLyAgfXBModLS4TvEn4wp1iys9YRRKC85KLIhNMC=`)

ถึงเวลาที่ต้องมีเรื่องatobไร้สาระ ฟังก์ชั่นนี้จะส่งกลับx*x+1โดยที่xเป็นจำนวนที่ไม่เป็นลบ

การใช้

(x=>eval(atob`eCp4KzEvLyAgfXBModLS4TvEn4wp1iys9YRRKC85KLIhNMC=`))(5)

ตั้งใจว่า

x=>eval(atob`Lyp5fMRwICAgKi9NYXRoLnBvdyh4LTEsMC41KS8veCp4KzE=`)

มีวิธีแก้ปัญหาที่เป็นไปได้มากมาย แต่ฉันหวังว่าตัวละครนำจะสลัดคำสั่งไบต์ออกไปมากพอที่จะทำให้เรื่องนี้ยากขึ้น C'est laatob

Brain-Flak , 26 ไบต์, แคร็ก

เป็นต้นฉบับ

((((()()())){}[()]){}{}{})

แตกของฉัน

([(((()())){}()){}{}()]{})

รอยแตก1000000000

([(((()())()){}){}{}](){})

Python 2, 225 ไบต์, ถอดรหัสโดย Sp3000

#((()))****+,,---/000555666888;==oppppppqqqqqw~~
lambda n:pow(n,65537,9273089718324971160906816222280219512637222672577602579509954532420895497077475973192045191331307498433055746131266769952623190481881511473086869829441397)

โดเมนของฟังก์ชันนี้คือ [0, n) โดยที่ n คือจำนวนมากข้างต้น ใช่ฟังก์ชั่นนี้ย้อนกลับได้ในโดเมนนี้ และถ้าฉันทำไม่ดีการทำลายคำตอบนี้ยากพอ ๆ กับการทำลาย RSA 512 บิต

J, 15 ไบต์

(".&,'10.')#.#:

รับจำนวนเต็มn ที่ไม่เป็นลบและแปลงเป็นรายการเลขฐานสองและรวมตัวเลขเหล่านั้นเป็นเลขฐาน 10

ลองออนไลน์!