เครื่องตรวจจับรังสี!

26

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

เขียนโปรแกรมหรือฟังก์ชั่นที่เมื่อลบไบต์เดียวใด ๆออกโปรแกรมที่ได้จะออกไบท์นั้นและไบท์นั้นเท่านั้น ( คุณอาจส่งออกไบต์หลายครั้งตราบใดที่คุณไม่ส่งออกไบต์อื่น ๆ )

กฎ:

  • โปรแกรมจะต้องมีอย่างน้อย 2 ไบต์ที่แตกต่างกัน (ไม่มีวิธีแก้ปัญหาเพียง 0s;)
  • ไม่สำคัญว่าโปรแกรมต้นฉบับจะทำอะไร
  • ไม่อ่านซอร์สโค้ดของคุณเอง
  • รหัสจะได้คะแนนตามจำนวนไบต์ที่แตกต่างกันโดยที่จำนวนสูงสุดชนะ ตัวอย่างเช่นabc= 3 คะแนน, ababba= 2 คะแนนabcชนะ
    • Tie-breaker คือจำนวนไบต์ที่น้อยกว่าตามด้วยเวลาการส่งก่อนหน้า

โชคดี!

code-challenge  radiation-hardening 
— โจคิง
แหล่งที่มา
— Jo King
ฉันพลาดสายนั้น น่าอายจริงๆเรา!
— Mego
5
"รหัสจะได้คะแนนตามจำนวนตัวอักษรที่แตกต่างกันซึ่งจำนวนเงินสูงสุดจะชนะ" ฉันคาดหวังว่าโซลูชันส่วนใหญ่ (ถ้าไม่ใช่ทั้งหมด) จะมีรูปแบบของสตริงบางแห่งซึ่งพวกเขาสามารถใช้อักขระที่ไม่มีกฎเกณฑ์ได้โดยไม่ต้องเปลี่ยนโซลูชัน (ดังนั้นมันจึงลงมาว่าภาษาของคุณ จำกัด ASCII, ASCII แบบขยายหรือ Unicode) .
— Martin Ender
3
... กล่องทรายไม่สมบูรณ์ :( / คุณสามารถวัด "ไบต์ที่แตกต่าง" แทน "อักขระที่แตกต่าง" ได้เนื่องจากตัวอักษรเกี่ยวข้องกับการเข้ารหัสและปัญหาอื่น ๆ
— user202729
1
โปรแกรมสามารถรับอินพุตใด ๆ ได้หรือไม่?
— gggg

คำตอบ:

15

05AB1E , 9 7 ไบต์ (คะแนน 3)

22'''rr

ลองออนไลน์!

การลบ '

กับใด ๆ'ที่ถูกนำออก22''rrจะมีผลในวันที่ 22 เป็นสิ่งแรกในกองและเป็นสิ่งสุดท้ายในสแต็คซึ่งเมื่อย้อนกลับไปสองครั้งในผลการค้นหา''

การลบ r

ด้วยการrลบใด ๆ22'''rส่งผลให้ 22 เป็นสิ่งแรกในกองซ้อน'สิ่งที่สองในกองซ้อนและเป็นrสิ่งสุดท้ายในกองซ้อน นี้rแต่ถูกนำหน้าด้วย'ซึ่งจะทำให้มันสายอักขระตัวอักษร"r"(เมื่อเทียบกับคำสั่งreverse stack) ซึ่งจะมีการพิมพ์โดยปริยาย

การลบ 2

ด้วยการ2ลบใด ๆ2'''rrจะส่งผลให้2เป็นสิ่งที่ 1 ในกอง'เป็นสิ่งที่ 2 ในกองและในที่สุดก็rเป็นสิ่งสุดท้ายในกองซึ่งเมื่อย้อนกลับเมื่อผลลัพธ์2มา

ดังนั้นคำตอบนี้ถูกต้อง ไม่มีสิ่งใดลบออก'ซึ่งเป็นสิ่งที่ไม่เกี่ยวข้อง ใช้งานได้กับหมายเลขใด ๆ ที่ไม่ใช่ 2 เช่นกัน

สร้างตัวตรวจสอบความถูกต้องแล้วคุณสามารถใช้มันเพื่อแข่งขันใน 05AB1E *

* ฉันไม่แน่ใจ 100% ว่ามีวิธีการแก้ปัญหาให้ได้มากแค่ไหนใน 05AB1E ...

โซลูชันที่ถูกต้องมากกว่านั้นคือแย่ลงหรือเหมือนกัน

  • 1 จุด (ไม่ถูกต้อง)
  • 2-Point
    • '''''''VV, '''''''XXหรือ'''''''<any command that pops a without pushing>x2
    • ใด ๆ ที่แปลก ๆ จาก'3 อันดับแรกตามด้วย # คู่ใด ๆsเหนือ 1 (EG '''''''''ssss)
    • '''..ด้วยจำนวนใด ๆ ของช่วงเวลาที่สูงกว่า 1 และจำนวนคี่ใด ๆ ของ'ข้างต้น 2
  • 3-Point
    • '\\'''rr- แนวคิดเดียวกันกับ22'''rrแต่\เป็น 'ลบรายการสแต็กสุดท้าย'
— Magic Octopus Urn
แหล่งที่มา
ผลลัพธ์ปกติของ'กฎไม่เกี่ยวข้องตามที่คุณพูด แต่มันจะทำให้เป้าหมายในการตรวจจับความผิดปกตินั้นเป็นโมฆะซึ่งค่อนข้างตลก
— gggg
1
@gggg ฉันค่อนข้างมั่นใจว่าอย่างน้อยหนึ่งตัวเลือกของฉันไม่มีอะไรพิมพ์ lol
— Magic Octopus Urn
1
@MagicOctopusUrn ไม่เป็นไร แค่คิดว่าฉันอาจแก้ไขได้เช่นกันแทนการแสดงความคิดเห็น
— boboquack
@boboquack แท็กดั้งเดิมของฉัน (@boboquack) ทำงานหรือคุณค้นหาโดยดูโพสต์อีกครั้งหรือไม่ ฉันกำลังพยายามหาวิธีการทำงานของแท็กเมื่อผู้ใช้ไม่เคยแสดงความคิดเห็นฮ่า ๆ
— Magic Octopus Urn
@boboquack ฉันหมายถึงคุณได้รับการแจ้งเตือนจาก "ขอบคุณ" ของฉันหรือไม่? นอกจากนี้เราควรลบเธรดนี้จนถึง +1 สำหรับ "ยินดีต้อนรับ" ของคุณ
— Magic Octopus Urn
9

Brainfuck คะแนน 3

อาจไม่ใช่การคอมไพล์เนื่องจากเอาต์พุตถูกเห็นผ่านการดัมพ์หน่วยความจำเท่านั้น 

+++++++++++++++++++++++++++++++++++++++++++++,-

สมมติว่าอินพุตว่างเปล่าและ EOF จะไม่เปลี่ยนแปลงเซลล์ ใช้ล่ามที่ทิ้งหน่วยความจำไปยังเอาต์พุตเช่นนี้

ลบเครื่องหมายบวกและหน่วยความจำคือค่า Unicode สำหรับ "+" มิฉะนั้นจะเป็นค่า Unicode สำหรับ "," มันเป็นกฎที่ประมาทมากกว่าคำตอบ สวยมากเหมือนกันกับ "-" การละเมิดความจริงที่ว่าอักขระสามตัวเหล่านี้อยู่หลังกันในชุด Unicode

— HåvardNygård
แหล่งที่มา
ฉลาดที่จะซื่อสัตย์อย่างแท้จริงอย่าคิดว่ามันเป็นช่องโหว่
— Magic Octopus Urn
คุณกำลังสมมติว่า EOF ปล่อยเซลล์ไม่เปลี่ยนแปลงใช่ไหม
— Jo King
ใช่และตราบใดที่มีการป้อนข้อมูลไม่ก็ควรจะปรับ😊
— HåvardNygård
ฉันอยากจะอนุญาตสิ่งนี้ แต่คุณมีล่ามที่มีการถ่ายโอนข้อมูลหน่วยความจำที่จะส่งออกเฉพาะเซลล์ที่มีการเปลี่ยนแปลงเท่านั้นและทำให้เซลล์ไม่เปลี่ยนแปลงใน EOF หรือไม่
— Jo King
1
copy.sh/brainfuck อันนี้ควรจะทำงานได้ดี เพียงแค่เรียกใช้และกด "ดูหน่วยความจำ"
— HåvardNygård
9

ต้นแพร์ 256 ไบต์ที่แตกต่างกัน 975 ไบต์

น่าเสียดายที่คำถามนั้นต้องการโซลูชันที่ดีที่สุดในการบรรจุ NUL ไบต์ไว้ที่ใดที่หนึ่ง ซึ่งหมายความว่าก) ฉันไม่สามารถให้ลิงก์ TIO แก่คุณ (เนื่องจาก TIO ไม่ชอบ NUL ในโปรแกรมหรืออย่างน้อยฉันก็ไม่ได้หาวิธีพิมพ์ประเภทที่เบราว์เซอร์ของฉันสามารถรับมือได้) และ b) ฉัน ไม่สามารถวางโปรแกรมลงในการแลกเปลี่ยนสแต็คอย่างแท้จริง ฉันได้วางxxdhexdump ที่สามารถย้อนกลับได้ซึ่งซ่อนอยู่ด้านหลังลิงก์ "ข้อมูลโค้ด" แทน

แสดงตัวอย่างโค้ด

คำอธิบาย

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

แต่ละส่วนเริ่มต้นด้วยการขึ้นบรรทัดใหม่แล้วดำเนินการต่อด้วยรหัสต่อไปนี้ (ฉันได้เพิ่มช่องว่างและความคิดเห็นด้านล่าง):

$z{$/}++;      # In the hash table %z, set the key "\n" to 1
$/=$\=$@;      # Turn off newline handling when reading ($/ = undef);
               # Also don't add newlines when printing ($\ = undef)
               # $@ is set to undef by default
!$z{$_}?       #   If the current character is not in the hash table %z
  $z{$_}=1:    #   place it in the hash table %z
  delete$z{$_} #   else remove it from the hash table %z
for split//,   # for each character in
    <DATA>;    # the text appearing from the line beneath __DATA__ to EOF
print          # Print the following (no newline because $\ was undefined):
  keys%z>5?    # if the hash table %z contains more than 5 elements:
  "\n":        #   a newline; otherwise
  keys%z;      #   every key of %z, separated by spaces
__DATA__       # Start a string literal running from after this line to EOF

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

มีสามกรณีที่แตกต่างกันที่นี่:

  • ตัวละครอื่น ๆ กว่าบรรทัดใหม่ถูกลบ ในกรณีนี้มันจะปรากฏเป็นจำนวนคี่ในส่วนที่สองและสาม นั่นหมายความว่ามันจะถูกเพิ่มและ / หรือลบออกจาก%zจำนวนคี่ในที่สุดก็สิ้นสุดลงในตารางแฮช ในความเป็นจริงมันจะเป็นคีย์เดียวในตารางแฮช (ในขณะที่สตริงเริ่มทำงานหลังจากขึ้นบรรทัดใหม่ของส่วนที่สองไปจนถึงตอนท้ายของส่วนที่สามและตารางแฮชเริ่มต้นด้วยบรรทัดใหม่เพียงบรรทัดเดียว) ดังนั้น ' จะพิมพ์ออกมาเอง
  • ขึ้นบรรทัดใหม่ครั้งแรกหรือครั้งที่สามถูกลบ ในกรณีนี้โปรแกรมจะถูกหมุนจนเป็นบรรทัดที่สามของบรรทัดใหม่ที่หายไปอย่างมีประสิทธิภาพการรวมส่วนที่สองและสามเข้าด้วยกันในบรรทัดเดียว สตริงที่เข้าถึงได้อย่างแท้จริงผ่านทาง<DATA>มีอักขระทุกตัวในจำนวนเท่า ๆ กันดังนั้นตารางแฮชจะมีเนื้อหาดั้งเดิมขึ้นบรรทัดใหม่เดียวและจะพิมพ์ออกมา
  • ขึ้นบรรทัดใหม่สองถูกลบ ในกรณีนี้โปรแกรมจะไม่หมุน (เนื่องจากส่วนแรกมีการตรวจสอบที่ถูกต้อง) ดังนั้นส่วนที่สองจะถูกย้ายไปยังบรรทัดเดียวกันกับส่วนแรก <DATA>เริ่มอ่านจากบรรทัดด้านล่าง__DATA__เท่านั้นจึงจะเห็นเฉพาะส่วนที่สาม มีอักขระมากกว่าห้าตัวที่ปรากฏเป็นจำนวนคี่ดังนั้นมันจะทริกเกอร์กรณีพิเศษเพื่อพิมพ์บรรทัดใหม่

การตรวจสอบ

สิ่งสุดท้ายที่ต้องมีการตรวจสอบสำหรับโปรแกรมใด ๆ ที่ผ่านการแผ่รังสีที่รุนแรงมากขึ้นคือโปรแกรม Pear Tree คือการลบเกิดขึ้นแบบสุ่มทำให้ส่วนที่ไม่ต้องการของรหัสเพื่อตรวจสอบอย่างถูกต้องและหมุนรหัสผิดที่ เนื่องจากเราใช้ checksums 32 บิตสิ่งนี้ไม่น่าจะเป็นไปไม่ได้ แต่เป็นไปไม่ได้ ฉันใช้สคริปต์ brute-force ต่อไปนี้เพื่อให้แน่ใจว่าสิ่งนี้จะไม่เกิดขึ้นสำหรับการลบ:

use 5.010;
use IPC::Run qw/run/;
use warnings;
use strict;
use Data::Dumper;
$Data::Dumper::Useqq=1;
$Data::Dumper::Terse=1;
$Data::Dumper::Indent=0;
undef $/;
$| = 1;
my $program = <>;

for my $x (0 .. (length($program) - 1)) {
    my $p = $program;
    my $removed = substr $p, $x, 1, "";
    alarm 4;
    say Dumper($p);
    run [$^X, '-M5.010', 'apeartree.pl'], '<', \$p, '>', \my $out, '2>', \my $err;
    if ($out ne $removed) {
        print "Unexpected output deleting character $x ($removed)\n";
        print "Output: {{{\n$out}}}\n";
        print "Errors: {{{\n$err}}}\n";
        exit;
    }
}

say $program;
run [$^X, '-M5.010', 'apeartree.pl'], '<', \$program, '>', \my $out, '2>', \my $err;
if ($out ne '') {
    print "Unexpected output not mutating\n";
    print "Output: {{{\n$out}}}\n";
    print "Errors: {{{\n$err}}}\n";
    exit;
}

say "All OK!";

สคริปต์ตรวจสอบยืนยันว่าโปรแกรมนี้ทำงานอย่างถูกต้อง

— ais523
แหล่งที่มา
7

Stax , 11 ไบต์ (คะแนน 4)

'''cc'~~'dd

เรียกใช้และแก้ไขข้อบกพร่องออนไลน์!

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

ในสแตกซ์สตริงตัวอักษรที่ประกอบด้วยอักขระตัวเดียวจะถูกเขียนด้วย'ดังนั้นจึง'', 'c, 'd, '~เป็นตัวอักษรสตริงทั้งหมด คำสั่งที่สอดคล้องกันสำหรับc dและ~หมายถึงการทำซ้ำด้านบนของสแต็กหลักป๊อปอัพด้านบนของสแต็กหลักและป๊อปที่ด้านบนของสแต็กหลักและกดไปที่สแต็กอินพุตตามลำดับ สำหรับความท้าทายนี้อินพุตสแต็กไม่มีผลต่อเอาต์พุตและไม่สำคัญดังนั้นเราจึงสามารถพูดdและ~เหมือนกันได้

คำอธิบาย

เป็นการดีที่สุดที่จะแบ่งรหัสออกเป็นหลายส่วนและพิจารณาแยกต่างหาก

เมื่อมันไม่ได้ดัดแปลงกับ'''ccดันตัวอักษร'และตัวอักษรcที่จะสแต็คหลักและซ้ำด้านบนเพื่อให้สแต็คจะเป็น c,c,'(จากไปที่ด้านล่าง)

เมื่อไม่ได้ดัดแปลงให้'~~กดตัวอักษร~แล้วเปิดมัน (และดันไปที่อินพุตสแต็ก) ซึ่งโดยทั่วไปจะเป็นแบบไม่มี op สำหรับสแต็กหลัก

เมื่อไม่ได้รับการแก้ไขให้'ddกดตัวอักษรdแล้วเปิดขึ้นอีกครั้งหนึ่งไม่มีตัวเลือกสำหรับสแต็กหลัก

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

หากโปรแกรมทำงานตามที่เป็นกองสุดท้ายยังคงเป็นและออกจะc,c,'c

หากส่วนแรกจะกลายเป็น''ccแล้วเรามีตัวอักษรและสองคำแนะนำสำเนากองสุดท้ายจะเป็น' ',','ระบุว่าทั้งสองส่วนอื่น ๆ จะไม่มี-op, 'ผลจะเป็น

หากส่วนแรกกลายเป็น'''cผลลัพธ์จะเหมือนกันกับส่วนที่cไม่ได้รับการแก้ไข แต่จะไม่ซ้ำกัน c,'ดังนั้นสแต็คจะเป็น หลังจากที่ทั้งสองไม่มี-op cเป็นด้านบนของสแต็คเป็น

ดังนั้นเราสามารถตรวจจับรังสีในส่วนแรก

ส่วนที่สองและส่วนที่สามทำงานในลักษณะเดียวกัน ฉันจะเอาส่วนที่สามเป็นตัวอย่าง

หากส่วนที่สามถูกแก้ไขส่วนที่สองจะถูกเก็บไว้ตามเดิมและสแต็กก่อนที่จะเรียกใช้ส่วนที่สามคือ c,c,'

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

หากส่วนที่สามกลายเป็นddสององค์ประกอบจะถูกผุดขึ้นมาจากกองหลักและตอนนี้ด้านบนของสแต็คเป็น'และเป็นผลลัพธ์

ดังนั้นเราสามารถตรวจจับรังสีในส่วนที่สาม ด้วยเหตุผลเดียวกันเราสามารถตรวจจับรังสีในส่วนที่สอง

— Weijun Zhou
แหล่งที่มา
5

05AB1Eคะแนน 2, 6 ไบต์

„"""„„

พิมพ์อักขระที่ลบออกเป็นสองเท่าในบางครั้ง 'ไม่ได้มี

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

การลบครั้งแรก „

"""„„

ลองออนไลน์!

ก่อนอื่นเราจะผลักสตริงว่างตามตัวอักษรไปยังสแต็ก จากนั้นเราก็ดัน„„ซึ่งพิมพ์ออกมาโดยปริยาย

การลบ "

„""„„

ลองออนไลน์!

อันดับแรกเราดัน""ไปที่สแต็กด้วย2-char stringคำสั่ง จากนั้นเราพยายามที่จะรับสายอักขระ 2 ตัวอีกครั้ง แต่สิ่งนี้ถูกยกเลิก (ฉันไม่แน่ใจว่าทำไม) และ""มีการพิมพ์

การลบที่สองหรือสาม „

„"""„

ลองออนไลน์!

อันดับแรกเราดัน""ไปที่สแต็กด้วย2-char stringคำสั่ง จากนั้นเราก็ดัน„ซึ่งพิมพ์ออกมาโดยปริยาย

— boboquack
แหล่งที่มา
5

เยลลี่ 5 ไบต์คะแนน 2

”””ḷḷ

ลองออนไลน์!

ด้วยการ”ลบใด ๆ:

””ḷḷ

ลองออนไลน์!

อักขระ”เริ่มต้นด้วยตัวอักษรหนึ่งไบต์ โปรแกรมนี้เริ่มต้นด้วยที่ทำให้สตริง”” คู่ใช้เวลาโต้แย้งซ้ายของมัน สตริงเพียงแค่ได้รับผ่านสองกรณีของ”ḷ”ḷ

ด้วยการḷลบใด ๆ:

”””ḷ

ลองออนไลน์!

ในโปรแกรมนี้””ให้ผลอักขระ”แล้ว”ḷให้อักขระḷและนี่คือผลลัพธ์เท่านั้น

โซลูชั่นอื่น ๆ

  • ตัวละครอื่น ๆ อีกมากมายเช่นaหรือoอาจใช้งานแทนḷการส่งนี้
  • ⁾⁾⁾⁾FFF. วิธีนี้ทำงานในลักษณะที่คล้ายกัน ⁾มันเป็นเหมือน”แต่มันจะเริ่มต้นสตริงตัวอักษรสองไบต์ โปรแกรม "ฉายรังสี" จะแสดงผลลบไบต์ที่ถูกลบสองครั้ง

นี่คือตัวตรวจสอบความถูกต้องของ Magic Octopus Urn (มีน้อยกว่าแฟนซี) คอลัมน์ด้านซ้ายของผลลัพธ์เป็นอักขระที่ถูกลบและคอลัมน์ด้านขวาคือผลลัพธ์ของโปรแกรมที่เกิดขึ้น

— dylnan
แหล่งที่มา
ตรวจสอบความถูกต้องของฉันไม่ได้thaaatแฟนซี มันล้มเหลวสำหรับการแก้ปัญหาอื่น ๆ โพสต์;)
— Magic Octopus Urn
โดยการใช้ไซต์ของเรา หมายความว่าคุณได้อ่านและทำความเข้าใจนโยบายคุกกี้และนโยบายความเป็นส่วนตัวของเราแล้ว
Licensed under cc by-sa 3.0 with attribution required.