บทนำ

ลองสังเกตจตุรัสต่อไปนี้ซึ่งประกอบไปด้วยตัวเลขเท่านั้น0 - 9:

1034
4167
8414
3542

เปลือกนอกของตารางนี้คือ:

1034
4  7
8  4
3542

มันมีค่าศูนย์ดังนั้นเราจำเป็นต้องลอกเปลือกนอกออกจาก:

16
41

เปลือกนอกของตารางนี้คือ:

16
41

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

งาน

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

กรณีทดสอบ

กรณีทดสอบ 1:

Input         Output

1234          1234
2345          2345
3456          3456
4567          4567

กรณีทดสอบ 2:

Input         Output

123           123
204           204
346           346

กรณีทดสอบ 3:

Input         Output

101           1
010           
101           

กรณีทดสอบ 4:

Input         Output

000           (none)
000
000

นี่คือโค้ดกอล์ฟดังนั้นการส่งที่มีจำนวนไบต์น้อยที่สุดจะชนะ!

เยลลี่ , 19 16 ไบต์

Fœ^F}P
ḊṖZµ⁺⁸ßç?

ลองออนไลน์! หรือตรวจสอบกรณีทดสอบทั้งหมด

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

ḊṖZµ⁺⁸ßç?  Main link. Argument: M (2D list)

Ḋ          Dequeue; remove the first row.
 Ṗ         Pop; remove the last row.
  Z        Zip; transpose rows with columns.
   µ       Combine the chain to the left into a link.
    ⁺      Copy the link, executing it twice.
           The copy removes the first and last column and restores the orientation.
       ç?  If the helper link returns a non-zero integer:
     ⁸       Return M unmodified.
      ß      Else, recursively call the main link on the "peeled" M.


Fœ^F}P     Helper link. Arguments: P ("peeled" M), M (unmodified)

F          Flatten P.
   F}      Flatten M.
 œ^        Perform multiset symmetric difference, removing the elements of P from
           the elements of M, respecting multiplicities, leaving precisely the
           elements of the outer shell.
     P     Return the product of the remaining elements.

JavaScript, 105 97 ไบต์

บันทึก 8 ไบต์ด้วย @Patrick Roberts!

l=a=>a.slice(1,-1)
p=a=>l(a).map(l)
c=a=>a.join``.replace(/[^0]/g,"")
s=a=>c(p(a))<c(a)?s(p(a)):a

กำหนดฟังก์ชั่นsซึ่งจะส่งกลับอาร์เรย์จำนวนเต็ม 2D เมื่อระบุอาร์เรย์จำนวนเต็มแบบ 2D เป็นอินพุต

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

• ฟังก์ชั่นl: รับอาร์เรย์aส่งคืนสำเนาโดยไม่มีดัชนีตัวแรกและตัวสุดท้าย

• ฟังก์ชั่นp: รับอาร์เรย์ 2D a, โทรlเพื่อลบแถวแรกและแถวสุดท้ายจากนั้นสำหรับการโทรแถวที่เหลือแต่ละครั้งlเพื่อลบกำปั้นและคอลัมน์สุดท้าย นี่เป็นการปอกเปลือกหัวหอม

• ฟังก์ชั่นc: รับอาร์เรย์ 2D aกลับสตริงที่มีเฉพาะที่อยู่ในรูปแบบของ0 stringifieda

• ฟังก์ชั่นs: รับอาร์เรย์ 2D aเรียกใช้cในรูปแบบที่ปอกเปลือกของอาร์เรย์ที่กำหนดโดยpและในอาร์เรย์เอง เปรียบเทียบสตริงเหล่านี้ด้วยพจนานุกรมเพื่อตรวจสอบว่ารูปแบบที่ปอกเปลือกมี0s น้อยกว่าเดิม หากเป็นเช่นนั้นแสดงว่าต้นฉบับมีการปนเปื้อนดังนั้นให้โทรหาsแบบฟอร์มที่ลอกซ้ำ มิฉะนั้นส่งคืนต้นฉบับ

เรติน่า , 60 57 ไบต์

จำนวนไบต์ถือว่าการเข้ารหัส ISO 8859-1 ตัวป้อนบรรทัดต่อท้ายมีความสำคัญ

+`(?<=(?=.*0|[^_]+(¶0|0¶|0.*$))^[^_]*)(^.+¶|¶.+$|.?\b.?)

ลองออนไลน์!

คำอธิบาย

เนื่องจากการป้อนบรรทัดต่อท้ายสิ่งนี้จะค้นหาการจับคู่ทั้งหมดของ regex หลังจาก`และลบออกจากอินพุต เนื่องจากการนำ+หน้าจะทำซ้ำ ๆ จนกระทั่งเอาต์พุตหยุดการเปลี่ยนแปลง (ซึ่งจะเป็นเพราะ regex จะหยุดการจับคู่)

สำหรับ regex นั้นประกอบด้วยสองส่วน:

(?<=(?=.*0|[^_]+(¶0|0¶|0.*$))^[^_]*)

ส่วนนี้ตรวจสอบว่ามี0ที่ใดก็ได้ในเปลือกนอก มันทำได้โดยการย้าย "เคอร์เซอร์" ของโปรแกรม regex ไปยังจุดเริ่มต้นของสตริงด้วย lookbehind (เราใช้[^_]เพื่อจับคู่ทั้งตัวเลขและ linefeeds):

(?<=...^[^_]*)

แล้วจากตำแหน่งนั้นเราใช้ lookahead เพื่อค้นหา0ทั้งในบรรทัดแรกติดกับ linefeed หรือในบรรทัดสุดท้าย:

(?=.*0|[^_]+(¶0|0¶|0.*$))

จากนั้นการแข่งขันที่แท้จริงจะประกอบด้วยบรรทัดแรก (รวมถึงการป้อนบรรทัดต่อท้าย), บรรทัดสุดท้าย (รวมถึงการป้อนบรรทัดสุดท้าย) หรืออักขระตัวแรกหรือตัวสุดท้ายของบรรทัดที่เราใช้ขอบเขตคำ\bว่าเป็นจุดเริ่มต้น / สิ้นสุดของบรรทัด ผู้ประกาศข่าว:

(^.+¶|¶.+$|.?\b.?)

MATL , 26 21 ไบต์

t"t5LY)y5LZ)h?}6Lt3$)

อินพุตอยู่ในรูปแบบต่อไปนี้

[1 0 3 4; 4 1 6 7; 8 4 1 4; 3 5 4 2]

ดังนั้นอีกสี่กรณีทดสอบคือ

[1 2 3 4; 2 3 4 5; 3 4 5 6; 4 5 6 7]
[1 0 1; 0 1 0; 1 0 1]
[1 2 3; 2 0 4; 3 4 6]
[0 0 0; 0 0 0; 0 0 0]

ข้อผิดพลาดของโปรแกรมในกรณีทดสอบครั้งล่าสุด แต่สร้างเอาต์พุตที่ถูกต้อง (ซึ่งไม่มีอะไร) ขอบคุณ @Dennis ที่สังเกตเห็น!

ลองออนไลน์! . หรือตรวจสอบกรณีทดสอบทั้งหมด (รวมถึงรหัสการตัดคำ)

คำอธิบาย

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

t            % Take a matrix as input. Duplicate
"            % For each column (i.e. repeat that many times)
  t5LY)      %   Duplicate top of the stack. Extract first and last rows
  y5LZ)      %   Duplicate the element below the top. Extract first and last columns
  h          %   Concatenate the two arrays into a row vector
  ?          %   If all its entries are non-zero: do nothing
  }          %   Else
    6Lt3$)   %     Get the central part
             % End if, end for. Implicitly display

Pyth, 19 ไบต์

.W}\0.-`H`JutCPG2HJ

ชุดทดสอบ

.W}\0.-`H`JutCPG2HJ
.W                     While the first function returns true, apply the second
                       function, starting with the input.
           u    2H     Apply the following twice to the input:
              PG       Remove the last row
             C         Transpose
            t          Remove the first row
                       This removes the outermost shell.
          J            Save it to J
         `             Stringify the matrix
       `H              Stringify the input
     .-                Multiset difference
  }\0                  Check if there is a '0' in the resulting string.
                  J    If that succeeds, update the current value to J.
                       When it fails, return the current value.

JavaScript (ES6), 74 ไบต์

f=s=>/^.*0|0\n|\n0|0.*$/.test(s)?f(s.replace(/^.*\n?|.(.*).|\n.*$/g,"$1")):s

รับอินพุตในรูปแบบของสตริงที่มีบรรทัดใหม่คั่นแต่ละแถว (แต่ไม่มีบรรทัดใหม่ที่นำหน้าหรือต่อท้าย) คำอธิบาย: /^.*0|0\n|\n0|0.*$/เป็น regexp ที่ตรงกับสี่เหลี่ยมที่ปนเปื้อนในขณะที่/^.*\n?|.(.*).|\n.*$/ตรงกับส่วนของจัตุรัสที่ต้องถูกลบยกเว้น(.*)ที่จะต้องเก็บไว้ (ซึ่งสั้นกว่าการมองไปข้างหน้าหรือข้างหลังสำหรับอักขระขึ้นบรรทัดใหม่)

Perl 5, 63 + 3 = 66 ไบต์

$_=<>;s/\A.*\n?|^.|.$|\n.*\Z//mg while/\A.*0|0$|^0|0.*\Z/;print

ต้องใช้-0ธง อินพุตไม่ควรมีอักขระขึ้นบรรทัดใหม่ที่ต่อท้าย

Pyke, 29 ไบต์

"D3lt%sBR,"2*ER3*I
/)tOmtmOr;

ลองที่นี่!

ยัง 29 ไบต์

QeQhQmhQme]4sBI
/)QtOmtmO=Qr;

ลองที่นี่!

Pyth , 31 30 ไบต์

L+hbeb.W!*F+1iRTs+yHyMHPtmPtdZ

ชุดทดสอบ (ข้อผิดพลาด testcase ล่าสุด)

การปรับปรุง: ทำส่วนหนึ่งให้กับฟังก์ชันตัวแยกวงรอบนอก ( L+hbeb)

รุ่น 31 ไบต์ก่อนหน้า:

.W!*F+1iRTs++hHm+hdedHeHPtmPtdZ

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

รหัสนั้นเป็นพื้น: ในขณะที่ผลิตภัณฑ์ของ outershell เป็นศูนย์ปอกมัน

ให้เราวิเคราะห์รหัสหลัก (Q เป็นนัยที่นี่):

.W<lambda:H><lambda:Z>Q

เริ่มต้นจากQ(อินพุต) whileแลมบ์ดาแรกทำการแลมบ์ดาที่สอง

ส่วนแรกจะเป็นแลมบ์ดาในH:

!*F+1iRTs++hHm+hdedHeH

ส่วนที่สองจะเป็นแลมบ์ดาในZ:

PtmPtdZ

ส่วนแรก

!*F+1iRTs++hHm+hdedHeH

ให้เราวิเคราะห์สิ่งนี้:

s++hHm+hdedHeH

s++             Concatenate:
   hH              1. the first row
     m+hdedH       2. the first and last item of each row
            eH     3. the last row

เนื่องจาก Pyth ใช้เครื่องหมายคำนำหน้าสิ่งนี้จะได้รับการประเมิน:

!*F+1iRT

     iRT  Convert each to integer
 *F+1     Product
!         Negate. If any element of the outer shell is zero, this would return 1.

ส่วนที่สอง

PtmPtdZ
  mPtdZ   the inner of each row
Pt        the inner rows

Mathematica, 78 ไบต์

NestWhile[#[[a=2;;-2,a]]&,#,Count[{#[[b={1,-1}]],#[[;;,b]]},0,3]>0&]~Check~{}&

ฟังก์ชั่นนิรนามรับอินพุตเป็นเมทริกซ์ ละเว้นข้อผิดพลาดใด ๆ ที่อาจเกิดขึ้นระหว่างการดำเนินการ