รับพีระมิดเพิ่มเติมพิจารณาว่าจะสามารถแก้ไขได้ พีระมิดนอกจากนี้ยังประกอบด้วยชั้นซึ่งแต่ละคนมีหนึ่งหมายเลขน้อยกว่าหนึ่งด้านล่าง ชั้นเป็นสัญลักษณ์เป็นP_iเป็นชั้นฐานและเป็นชั้นบนP_iจำนวนวันของจะแสดงเป็นj} เป็นจำนวนซ้ายสุดของและเป็นจำนวนไปทางขวาของj} คุณอาจเห็นภาพอยู่ด้านบนของ$P$$i$$P_i$$P_1$$P_{i+1}$$P_i$$j$$P_i$$P_{i,j}$$P_{i,1}$$P_i$$P_{i,j+1}$$P_{i,j}$$P_{i+1,j}$$P_{i,j}$และอยู่ตรงกลางดังนั้นชื่อ "การเติมพีระมิด "$P_{i,j+1}$

• $\forall P_{i,j},P_{i,j}\in\mathbb N^*$นั่นคือทุกหมายเลขในพีระมิดเป็นจำนวนเต็มบวกที่ไม่เป็นศูนย์
• $\forall i>1,P_{i,j}=P_{i-1,j}+P_{i-1,j+1}$นั่นคือทุกหมายเลขที่ไม่ได้อยู่บนชั้นฐานของพีระมิดคือผลรวมของ ตัวเลขสองตัวข้างล่างนี้
• หากมีตัวเลขมีหมายเลขจึงเป็นจำนวนขวาสุดของP_iในแง่ที่ง่ายกว่าแต่ละเลเยอร์มีหนึ่งหมายเลขน้อยกว่าเลเยอร์ด้านล่าง$P_1$$n$$P_i$$n-i+1$$P_{i,n-i+1}$$P_i$

ปริศนานอกจากพีระมิด เป็นปิรามิดนอกจากนี้ยังมีตัวเลขบางที่ถูกลบ (แทนที่ด้วย ) วิธีแก้ปัญหาคือการเพิ่มพีระมิดโดยที่นั่นคือตัวเลขที่มีอยู่เดิมในปริศนามี ถูกทิ้งให้ไม่เปลี่ยนแปลง ปริศนาดังกล่าวอาจมีทางออกมากกว่าหนึ่งข้อ$Q$$?$$P$$\forall Q_{i,j}\ne{?},P_{i,j}=Q_{i,j}$

งานของคุณคือการเพิ่มตัวต่อปริศนาปิรามิดเพื่อตรวจสอบว่ามันมีทางออกเดียวหรือไม่

อินพุต

คุณสามารถรับอินพุตในฟอร์มใด ๆ ต่อไปนี้ แต่ต้องสอดคล้องกัน:

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

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

เอาท์พุต

หนึ่งในสองค่าที่แตกต่างที่สอดคล้องกันโดยที่หนึ่งแสดงถึงการมีอยู่ของโซลูชันที่ไม่ซ้ำกันและอีกอย่างหนึ่งคือการขาดโซลูชันหรือการมีมากกว่าหนึ่งโซลูชัน

กฎระเบียบ

• $Q_{i+1,j}=Q_{i,j}+Q_{i,j+1}$จะเป็นจริงเสมอถ้านั่นคืออินพุตรับประกันได้ว่าจะไม่มีตัวเลขอยู่ด้านบนของตัวเลขอีกสองตัวที่ไม่ใช่ผลรวมของพวกเขาหากรู้ตัวเลขทั้งสาม$Q_{i,j},Q_{i,j+1},Q_{i+1,j}\in\mathbb N^*$
• $\exists Q_{i,j},Q_{i,j}\ne{?}$นั่นคือปิรามิดจะมีหมายเลขที่รู้จักอย่างน้อยหนึ่งหมายเลข
• ไม่ทำสิ่งเหล่านี้
• นี่คือรหัสกอล์ฟดังนั้นคำตอบที่สั้นที่สุดชนะ! อย่างไรก็ตามอย่าปล่อยให้สิ่งนี้กีดกันคุณไม่ให้โพสต์โซลูชันเพียงเพราะภาษาของคุณ "เกินไป"

กรณีทดสอบ

อาร์เรย์กับชั้นจากด้านบนไปยังฐานที่ใช้สำหรับกรณีทดสอบนี้มี0ตัวแทน.$?$

[[10], [0, 0], [0, 2, 0], [0, 0, 0, 1]] -> True
[[32], [0, 0], [0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0]] -> True
[[0], [1, 1]] -> True
[[1], [0, 0]] -> False
[[10], [5, 5], [2, 3, 2], [0, 0, 0, 0]] -> False
[[5], [0, 0], [0, 0, 0]] -> False

ตัวอย่างการทำงาน

กรณีทดสอบใช้งานได้ที่นี่

ทางออกเฉพาะ 1

$$\begin{array}c&&&10\\&&?&&?\\&?&&2&&?\\?&&?&&?&&1\end{array}$$

ขั้นตอนที่ 1: 1$x+y=2\leftrightarrow x=y=1$

$$\begin{array}c&&&10\\&&?&&?\\&?&&2&&?\\?&&\color{red}1&&\color{red}1&&1\end{array}$$

ขั้นตอนที่ 2: 2$x=y=1\leftrightarrow x+y=2$

$$\begin{array}c&&&10\\&&?&&?\\&?&&2&&\color{red}2\\?&&1&&1&&1\end{array}$$

ขั้นตอนที่ 3: 4$x=y=2\rightarrow x+y=4$

$$\begin{array}c&&&10\\&&?&&\color{red}4\\&?&&2&&2\\?&&1&&1&&1\end{array}$$

ขั้นตอนที่ 4: 6$x+4=10\leftrightarrow x=6$

$$\begin{array}c&&&10\\&&\color{red}6&&4\\&?&&2&&2\\?&&1&&1&&1\end{array}$$

ขั้นตอนที่ 5-6 คล้ายกับ 4

$$\begin{array}c&&&10\\&&6&&4\\&\color{red}4&&2&&2\\\color{red}3&&1&&1&&1\end{array}$$

ดังนั้นที่นี่เรามีทางออกที่เป็นเอกลักษณ์ของเรา

ทางออกเฉพาะ 2

$$\begin{array}c&&&&&32\\&&&&?&&?\\&&&?&&?&&?\\&&?&&?&&?&&?\\&?&&?&&?&&?&&?\\?&&?&&?&&?&&?&&?\end{array}$$

ขั้นตอนที่ 1: ไม่มีแนวทางที่ชัดเจนที่นี่ดังนั้นลองใช้ค่าต่ำสุดที่เป็นไปได้

$$\begin{array}c&&&&&32\\&&&&?&&?\\&&&?&&?&&?\\&&?&&?&&?&&?\\&?&&?&&?&&?&&?\\\color{red}1&&\color{red}1&&\color{red}1&&\color{red}1&&\color{red}1&&\color{red}1\end{array}$$

ขั้นตอนที่ 2-5: ดูเหมือนว่าผลลัพธ์ขั้นต่ำจะทำให้เกิดโซลูชันดังนั้นนี่จึงเป็นโซลูชันเดียวและไม่ซ้ำกัน

$$\begin{array}c&&&&&32\\&&&&\color{red}{16}&&\color{red}{16}\\&&&\color{red}8&&\color{red}8&&\color{red}8\\&&\color{red}4&&\color{red}4&&\color{red}4&&\color{red}4\\&\color{red}2&&\color{red}2&&\color{red}2&&\color{red}2&&\color{red}2\\1&&1&&1&&1&&1&&1\end{array}$$

คำแนะนำ: มีทฤษฎีบทเกี่ยวกับการเพิ่มปริศนาปิรามิดที่เกี่ยวข้องกับปริศนานี้ที่คุณสามารถพิสูจน์ได้ว่าคุณคิดหนักพอ

ทางออกเฉพาะ 3

$$\begin{array}c&?\\1&&1\end{array}$$

$x=y=1\rightarrow x+y=2$

$$\begin{array}c&\color{red}2\\1&&1\end{array}$$

นี่เป็นทางออกที่ไม่เหมือนใคร

ไม่มีวิธีแก้ปัญหา 1

$$\begin{array}c&1\\?&&?\end{array}$$

$\min\mathbb N^*=1\rightarrow x,y\ge1\rightarrow x+y\ge2>1$

ไม่มีวิธีแก้ปัญหา 2

$$\begin{array}c&&&10\\&&5&&5\\&2&&3&&2\\?&&?&&?&&?\end{array}$$

$x+y=2\leftrightarrow x=y=1$

$$\begin{array}c&&&10\\&&5&&5\\&2&&3&&2\\\color{red}1&&\color{red}1&&\color{red}1&&\color{red}1\end{array}$$

$1+1=3$

โซลูชันที่ไม่ซ้ำกัน

$$\begin{array}c&&5\\&?&&?\\?&&?&&?\end{array}$$

สองวิธี:

$$\begin{array}c&&5&&&&&&&5\\&2&&3&&&&&3&&2\\1&&1&&2&&&2&&1&&1\end{array}$$

เนื่องจากมีวิธีแก้ไขปัญหาอย่างน้อยสองวิธีจึงไม่มีวิธีแก้ปัญหาเฉพาะ

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

FṀ‘ṗLSƝƬ€Ṗ€a@ċ⁼1

ลองออนไลน์!

ลิงก์ monadic ที่ใช้พีระมิดในลำดับย้อนกลับและส่งคืน 1 สำหรับจริงและ 0 สำหรับเท็จ สร้างปิรามิดที่เป็นไปได้ทั้งหมดด้วยฐานจนถึงจำนวนสูงสุดในปิรามิดและตรวจสอบว่ามีการจับคู่ที่ไม่ซ้ำกันหนึ่งรายการ

ขอขอบคุณที่ @Arnauld สำหรับการชี้ให้เห็นว่านี้ล้มเหลวสำหรับ[[1,0],[0]]; แก้ไขแล้ว

ขอบคุณ @JonathanAlan ที่ประหยัด 2 ไบต์!

คำอธิบาย

F                | Flatten
 Ṁ               | Maximum
  ‘              | Increase by 1
   ṗ             | Cartesian power of this with:
    L            | - Length of input
        €        | For each:
       Ƭ         | - Repeat the following until no change
     SƝ          |   - Sum of neighbours
         Ṗ€      | Remove last element from each list
           a@    | Logical and input with each list
             ċ   | Count times input appears
              ⁼1 | Check if equal to 1

C # (Visual C # Interactive Compiler) , 303 227 ไบต์

n=>{int i=n.Max(x=>x.Max()),j=n.Count,t=0,k,m=0,z;for(;t<Math.Pow(i,j);){k=t++;var s=n.Select(_=>(a:k%i+1,k/=i).a).ToList();if(n.All(x=>(z=0,b:x.All(o=>o==s[z++]|o<1),s=s.Skip(1).Select((a,b)=>a+s[b]).ToList()).b))m++;}m/=m-1;}

โยนข้อยกเว้นถ้าเป็นจริงทำงานตามปกติถ้าเป็นเท็จ

ลองออนไลน์!

ภาษา Wolfram (Mathematica) , 85 88 ไบต์

Count[l=Length@#;NestList[2#~MovingMedian~2&,#,l-1]&/@Range@Max@#~Tuples~l,#/. 0->_]==1&

ลองออนไลน์!

+3 คงที่

กำลังดุร้าย: สำหรับทุกฐานที่มีค่าดูว่าพีระมิดที่ได้นั้นตรงกับรูปแบบที่กำหนดหรือไม่และตรวจสอบว่าจำนวนการแข่งขันทั้งหมดเป็น 1 หรือไม่ใช้อินพุตเป็นรายการของระดับฐานแรกโดยแสดงตัวเลขที่หายไป1..(sum of all numbers)0

05AB1E , 25 ไบต์

ZÌLsgãε©.Γü+}¨®š.S*˜O_}OΘ

นำเลเยอร์ปิรามิดตามลำดับกลับหัวลงไปจนถึงฐาน (เช่น[[0,0,0,1],[0,2,0],[0,0],[10]])

นอกจากนี้ดูเหมือนว่าจะมีข้อผิดพลาดบางแห่งใน 05AB1E .Γภายในแผนที่ .. ©...®šควรอยู่ที่...yš-1 ไบต์ ..

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

รองลงมาเท่ากับไบต์ทางเลือกสำหรับการ©.ΓüO}®šอาจจะ[Ðg#üO}\): ลองออนไลน์

คำอธิบาย:

Z        # Get the flattened maximum of the (implicit) input (without popping)
 Ì       # Increase it by 2
  L      # Create a list in the range [1, max+2]
   sg    # Swap to get the input again, and get the length (amount of layers)
     ã   # Create a cartesian product of this list repeated that many times
ε        # Map each inner list to:
 ©       #  Store it in variable `®` (without popping)
  .Γ     #  Collect all results until the following doesn't change anymore:
    ü    #   Get the pairwise:
     +   #    Sums
   }®š   #  After we've collected all, prepend the original list `®`
 .S      #  Now compare this potential pyramid with the (implicit) input-pyramid
         #  (-1 if a<b; 0 if a==b; 1 if a>b)
   *     #  Multiply that with the (implicit) input-pyramid
    ˜O   #  Then take the flattened sum
      _  #  And check that this sum equals 0 (1 if truhy; 0 if falsey)
}O       # After the map, take the sum to get the amount of truthy values
  Θ      # And trutify it (== 1), since we must output distinct values instead of truthy/falsey
         # (after which the result is output implicitly)

Haskell, 106 ไบต์

z=zipWith
a#b=a*b==a*a
f x=[1|t<-mapM(\_->[1..sum(sum<$>x)])x,all and$z(z(#))x$iterate(z(+)=<<tail)t]==[1]

[[0,0,0,1],[0,2,0],[0,0],[10]]ใช้เวลาปิรามิดคว่ำลงเช่น

ลองออนไลน์!

แรงเดรัจฉานใน Haskell:

• สร้างเลเยอร์ฐานที่เป็นไปได้ทั้งหมดt( mapM(\_->[1..sum(sum<$>x)])x) ซึ่งตัวเลขเริ่มจาก 1 ถึงผลรวมของตัวเลขทั้งหมดในปิรามิดอินพุต
• สร้างปิรามิดจากt( iterate(z(+)=<<tail)t)
• เปรียบเทียบแต่ละองค์ประกอบเลเยอร์ที่ชาญฉลาดกับอินพุต ( z(z(#))x) ฟังก์ชั่นการเปรียบเทียบa # bจะคืนค่าTrueถ้าตัวเลขทั้งสองเท่ากันหรือaเป็นศูนย์ ( a*b==a*a)
• ใช้สำหรับปิรามิดที่ตรงกับทุกคนและเปรียบเทียบรายการผลลัพธ์ในรายการเดี่ยว 1[1]