พื้นหลัง

อะตอมเลขคณิตของเยลลี่เวกเตอร์อัตโนมัติ ในความเป็นจริงแล้วx + yนั้นถูกนิยามไว้อย่างดีเมื่อใดก็ตามที่xและyเป็นตัวเลขหรืออาเรย์ของตัวเลข ซอร์สโค้ดของเยลลี่นำพฤติกรรมนี้ไปใช้โดยใช้ vectorizer ทั่วไป แต่สำหรับความท้าทายนี้เราจะพิจารณาเฉพาะการเพิ่มจำนวนเต็มและอาร์เรย์จำนวนเต็มแบบซ้อน

คำนิยาม

กำหนดความลึกของxเป็น0ถ้าxเป็นจำนวนเต็มเป็น1ถ้ามันเป็น (อาจจะเป็นที่ว่างเปล่า) อาร์เรย์แบนของจำนวนเต็มและเป็น1 + nถ้ามีอย่างน้อยหนึ่งองค์ประกอบของความลึกnและองค์ประกอบของความลึกไม่มีk> n .

วิธีนี้1มีความลึก0 , []และ[1]และ[1, 1]มีความลึก1 , [[], []]และ[[1], [1]]และ[1]และ[1] , []]มีความลึก2 , [1, [1, [1]]]มีความลึก3 , ฯลฯ

การดำเนินการx + yถูกกำหนดไว้ดังนี้

1. หากxและyมีความลึก0ให้ส่งคืนผลรวมของพวกเขา

2. ถ้าxและy ที่มีระดับความลึกเท่ากัน แต่บวกซ้ำใช้+รายการทั้งหมดของxและรายการที่สอดคล้องกันของปี

   หากxและyมีความยาวต่างกันให้ผนวกท้ายของอาร์เรย์ที่ยาวกว่าเข้ากับอาร์เรย์ของผลรวม

   ส่งคืนผลลัพธ์

3. หากความลึกของxน้อยกว่าความลึกของ yอย่างเคร่งครัดให้ใช้+กับxและรายการทั้งหมดของyซ้ำแล้วคืนค่าผลลัพธ์

   ทำตรงข้ามถ้าY 's ลึกเป็นอย่างเคร่งครัดมีขนาดเล็กกว่าx ' s

ตัวอย่างเช่นพิจารณาดำเนินการ[1, [2, 3] [4]] + [[[10, 20], [30], 40, 50], 60]

• ความลึกของอาร์กิวเมนต์ซ้ายคือ2ในขณะที่ความลึกของอาร์กิวเมนต์ที่ถูกต้องคือ3ดังนั้นเราจึงคำนวณ[1, [2, 3], [4]] + [[10, 20], [30], 40, 50 ]และ[1, [2, 3] [4]] + 60

  • [1, [2, 3], [4]]และ[[10, 20], [30], 40, 50]ทั้งคู่มีความลึก2ดังนั้นเราจึงคำนวณ1 + [10, 20] , [2, 3] + [30]และ[4] + 40

    • 1 + [10, 20] = [1 + 10, 1 + 20] = [11, 21]

    • [2, 3] + [30] = [2 + 30, 3] = [32, 3]

      โปรดทราบว่า3ยังคงไม่ถูกแตะต้องเนื่องจากไม่มีองค์ประกอบที่ตรงกัน

    • [4] + 40 = [4 + 40] = [44]

    
    50ไม่ได้มีองค์ประกอบที่ตรงกันดังนั้นผลที่ได้คือ[[[11 21] [32 3], [44], 50]]

  • [1, [2, 3], [4]] + 60 = [1 + 60, [2, 3] + 60, [4] + 60] = [61, [2 + 60, 3 + 60], [ 4 + 60]]ผลใน[61, [62, 63], [64]]

• ผลสุดท้ายคือ[[[11 21] [32 3], [44], 50], [61, [62, 63], [64]]]

งาน

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

หากภาษาของคุณมีประเภทอาเรย์หลายแบบ (รายการ, ทูเปิล, เวกเตอร์และอื่น ๆ ) คุณสามารถเลือกประเภทใดก็ได้สำหรับคำตอบของคุณ ประเภทส่งคืนต้องตรงกับประเภทอาร์กิวเมนต์

เพื่อป้องกันการแก้ปัญหาที่น่าเบื่อและไม่สามารถเอาชนะได้หากภาษามีการดำเนินการที่แน่นอนนี้ในตัวคุณไม่สามารถใช้ภาษานั้นได้

บิวด์อินทั้งหมดของภาษาอื่น ๆ ทั้งหมดได้รับอนุญาต หากภาษาที่คุณเลือกอนุญาตให้ทำเช่นนี้ได้คุณอาจโอเวอร์โหลดและ / หรือกำหนดใหม่เพิ่มเติมในตัว

นี่คือโค้ดกอล์ฟดังนั้นโค้ดที่สั้นที่สุดในหน่วยไบต์ชนะ

กรณีทดสอบ

0 + 0                           = 0
[-1, 0, -1] + [1]               = [0, 0, -1]
[] + [0]                        = [0]
[] + 0                          = []
[] + []                         = []
[[], 0] + []                    = [[], []]
[1, 2, 3] + 10                  = [11, 12, 13]
[1, 2, 3] + [10]                = [11, 2, 3]
[1, 2, 3] + [10, [20]]          = [[11, 12, 13], [21, 2, 3]]
[1, 2, 3, []] + [10, [20]]      = [11, [22], 3, []]
[1, [2, [3, [4]]]] + [10, [20]] = [[11, [21]], [[12, [22]], [13, [24]]]]

เพื่อสร้างกรณีทดสอบเพิ่มเติมคุณสามารถใช้โปรแกรม Jellyนี้

Pyth, 42 ไบต์

L?sIb0heSyM+b0M?qFyMJ,GH?yGgM.tJ0+GHgLFyDJ

ชุดทดสอบ

4 ไบต์สุดท้ายเพียงเรียกใช้ฟังก์ชันบนอินพุต

L?sIb0heSyM+b0M?qFyMJ,GH?yGgM.tJ0+GHgLFyDJ

L?sIb0heSyM+b0
                  Define y(b), a helper function to calculate the depth.
 ?                Ternary:
  sIb             If b is invariant under the s function, which is only the case
                  if s is an int.
     0            The depth is 0.
           +b0    Add a 0 on to b. This handles the edge case where b is [].
         yM       Map each to their depth
       eS         Take the max.
      h           Add one.

M?qFyMJ,GH?yGgM.tJ0+GHgLFyDJ
M                               Define g(G, H), which calculates the Jelly +.
 ?                              Ternary:
       ,GH                      Form [G, H].
      J                         Save it to J.
    yM                          Map each to its depth.
  qF                            Check if they are equal.
          ?yG                   If so, check if the depth is nonzero.
               .tJ0             If so, transpose J, pairing each element of each
                                argument with the corresponding element of the
                                other. Pad with zeroes.
             gM                 Map each to its Jelly +.
                   +GH          If the depths are zero, return the normal sum.
                         yDJ    If the depths are different, order J by depth.
                      gLF       Apply the function which left-maps the Jelly +
                                function to the two values. The first is
                                treated as a constant, while the second varies
                                over elements over the second values.

APL, 44 ไบต์

{1=≡⍺⍵:⍺+⍵⋄=/∆←|≡¨⍺⍵:⊃∇¨/↓↑⍺⍵⋄</∆:⍺∘∇¨⍵⋄⍵∇⍺}

APL ของ +กระจายไปทั่วอาร์เรย์เช่นกัน แต่ในลักษณะที่แตกต่างกันพอที่จะไม่สามารถใช้งานได้จริง อย่างไรก็ตามมีฟังก์ชั่นความลึกในตัว ( ≡)

คำอธิบาย:

• 1=≡⍺⍵:⍺+⍵: ถ้าระดับความลึกของ ⍺ ⍵ทั้งคู่เป็นศูนย์ (และความลึกของ⍺ ⍵เท่ากับ 1) ให้เพิ่ม
• ∆←|≡¨⍺⍵ใช้ความลึกของทั้งสอง⍺และ⍵∆และเก็บไว้ใน ( ≡ให้ค่าลบหากองค์ประกอบทั้งหมดไม่มีความลึกเท่ากัน)
• =/∆: หากมีความลึกเท่ากัน:
  • ↓↑⍺⍵: วางอาร์เรย์ที่สั้นที่สุดด้วยเลขศูนย์เพื่อจับคู่อาร์เรย์ที่ยาวกว่า
  • ⊃∇¨/: กระจายฟังก์ชั่นทั้งสองอาร์เรย์
• </∆: หากความลึกของ⍺น้อยกว่า⍵ :
  • ⍺∘∇¨⍵: ผูก⍺แล้วทำแผนที่⍵
• ⍵∇⍺: หากไม่มีสิ่งใด ( ⍵ลึกกว่า⍺) ให้สลับข้อโต้แย้งและลองอีกครั้ง

Mathematica, 122 ไบต์

d=Depth
x_~f~y_/;d@x>d@y:=y~f~x
x_~f~y_/;d@x<d@y:=x~f~#&/@y
x_List~f~y_:=MapThread[f,{x,y}~PadRight~Automatic]
x_~f~y_=x+y

กำหนดฟังก์ชั่นวนซ้ำfซึ่งคำนวณผลรวม การใช้การจับคู่รูปแบบของ Mathematica ฟังก์ชันนี้ประกอบด้วยคำจำกัดความที่แยกกันสี่ประการ:

x_~f~y_/;d@x>d@y:=y~f~x

หากความลึกxมากกว่านั้นyให้สลับอาร์กิวเมนต์เพื่อให้เราจัดการการกระจายในทิศทางเดียว (ซึ่งเราสามารถทำได้

x_~f~y_/;d@x<d@y:=x~f~#&/@y

ถ้าความลึกของxน้อย Thann ที่yแทนค่าแต่ละ#ในyด้วยf[x,#]ซึ่งจะดูแลการกระจายสำหรับข้อโต้แย้งของความลึกไม่เท่ากัน

x_List~f~y_:=MapThread[f,{x,y}~PadRight~Automatic]

มิฉะนั้นถ้าอาร์กิวเมนต์หนึ่งเป็นรายการ (ซึ่งบอกเป็นนัยว่าอีกรายการนั้นเป็นรายการเนื่องจากเรารู้ว่าพวกเขามีความลึกเท่ากัน) เราจึงใส่อาร์กิวเมนต์ทั้งสองไว้ในรายการแล้ววางลงในความยาวเดียวกันด้วยPadRight[..., Automatic](ซึ่งเติมให้เต็ม ragged array ที่มีเลขศูนย์เพื่อให้เป็นสี่เหลี่ยม) จากนั้นใช้MapThreadเพื่อใช้fกับคู่ที่สอดคล้องกันจากรายการทั้งสอง

และในที่สุดกรณีฐาน:

x_~f~y_=x+y

หากไม่มีรูปแบบอื่นใดที่ตรงกันเราต้องพยายามเพิ่มตัวเลขสองตัวดังนั้นเราแค่ทำเช่นนั้น

Haskell 150 ไบต์

data L=S Int|V{v::[L]}
d(V z)=1+maximum(d<$>S 0:z);d _=0
S x!S y=S$x+y
x!y|d x<d y=V$(x!)<$>v y|d x>d y=y!x|1<2=V$v x#v y
(x:a)#(y:b)=x!y:a#b;a#b=a++b

คำอธิบาย

บรรทัดแรกกำหนดประเภทข้อมูลเกี่ยวกับพีชคณิตLซึ่งเป็นทั้งScalar (ที่มีInt) หรือVector (ที่มีรายการของLs, เข้าถึงได้โดยใช้บันทึกทะเยอทะยานvซึ่งเป็นฟังก์ชั่นบางส่วนL → [L])

บรรทัดที่สองกำหนดฟังก์ชั่นความลึก : ความลึกของVector คือหนึ่งบวกความลึกสูงสุด ฉันย่อหน้ากับค่าในเวกเตอร์เพื่อให้S 0 depth [] == 1 + maximum [depth (S 0)] == 1ความลึกของ“สิ่งอื่น” (เกลา) 0เป็น

บรรทัดที่สามกำหนดเคสพื้นฐานสำหรับ!(ฟังก์ชันเพิ่ม): ผลรวมของสเกลาร์เป็นเพียงสเกลาร์

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

บรรทัดที่สี่แบ่งออกเป็นสามกรณี:

x!y | d x<d y = V$(x!)<$>v y
    | d x>d y = y!x
    | True    = V$v x#v y

• ถ้าความลึกของxเป็นอย่างเคร่งครัดน้อยกว่าความลึกของyแผนที่มากกว่าองค์ประกอบของ(x!) y(การใช้งานvนั้นรับประกันว่าถูกต้องตามd(y) ≥ 1)

• หากความลึกของxมีค่ามากกว่าอย่างเคร่งครัดให้พลิกอาร์กิวเมนต์และรีสตาร์ท

• ถ้าความลึกของพวกเขามีค่าเท่ากัน zip (!)การขัดแย้งกันด้วย (การใช้vรับประกันได้ว่าถูกต้องตามกรณีd(x) = d(y) = 0ถูกจัดการเป็นกรณีฐาน)

กรณีทดสอบ

instance Show L where
  show (S x) = show x
  show (V x) = show x

lArg = V [S 1, V [S 2, V [S 3, V [S 4]]]]
rArg = V [S 10, V [S 20]]

show (lArg ! rArg) == "[[11,[21]],[[12,[22]],[13,[24]]]]"แล้วก็

Java, 802 794 754 746 ไบต์

ฉันตัดสินใจที่จะรับ @ Dennis ♦สำหรับความท้าทายในการใช้งานสตริง "เป็นทางเลือกสุดท้าย" เพราะอาจเป็น "ซับซ้อนเกินไป" นอกจากนี้ในภาษาที่เลวร้ายที่สุดในการเล่นกอล์ฟ

อาร์เรย์ในอินพุตถูกคั่นด้วยเครื่องหมายจุลภาคล้อมรอบด้วยวงเล็บเหลี่ยมและไม่มีช่องว่าง

โปรแกรมเต็มรูปแบบที่มีฟังก์ชั่นห่อไว้ในชั้นเรียนและกรณีทดสอบ

import java.util.*;
List<String>p(String s){List r=new ArrayList<String>();String p="";int l=0;for(char c:s.substring(1,s.length()-1).toCharArray()){l+=c=='['?1:c==']'?-1:0;if(c==','&&l<1){r.add(p);p="";}else p+=c;}if(p!="")r.add(p);return r;}
int d(String s){int l=0;if(s.contains("[")){for(String c:p(s))l=d(c)>l?d(c):l;l++;}return l;}
String f(String x,String y){int i=0;String r="";if(d(x)<1&&d(y)<1)r+=Integer.valueOf(x)+Integer.valueOf(y);else{r="[";if(d(x)<d(y))for(String k:p(y))r+=(i++<1?"":",")+f(x,k);else if(d(x)>d(y))for(String k:p(x))r+=(i++<1?"":",")+f(k,y);else for(;i<p(x).size()||i<p(y).size();i++)r+=(i<1?"":",")+(i<p(x).size()&&i<p(y).size()?f(p(x).get(i),p(y).get(i)):i<p(x).size()?p(x).get(i):p(y).get(i));r+="]";}return r;}

ฉันอาจย้ายสิ่งนี้ไปยัง C ++ ในภายหลังเนื่องจากเป็นภาษาอื่นที่ฉันรู้ว่าไม่รองรับอาเรย์ที่ขาดเนื่องจากฉันค่อนข้างมั่นใจว่าเกือบจะแน่ใจว่ามันจะสั้นกว่าคำตอบนี้ นี่เป็นส่วนใหญ่เป็นหลักฐานของแนวคิด แต่เคล็ดลับการเล่นกอล์ฟจะยังคงได้รับการชื่นชม!

-31 ไบต์จาก @ user902383 แนะนำให้ใช้ foreach กับอาร์เรย์อักขระที่แปลงแล้วจากนั้นฉันบันทึกอีกเล็กน้อยจากการจัดเรียงบล็อกในส่วนสุดท้ายอีกครั้ง

Python 2.7, 261 209 202 198 191 185 197 181 ไบต์

FGITW แก้ปัญหาเรื่องไม่สำคัญ

แก้ไข: แน่นอน @Dennis เต้นมัน

ขอบคุณ @LeakyNun สำหรับการบันทึก 57 ไบต์พร้อมด้วยเคล็ดลับในการแสดงออกแลมบ์ดาและอีก 2 ไบต์จากวงเล็บเหลี่ยมที่ไม่จำเป็น

ขอบคุณ @Adnan เป็นเวลา 4 ไบต์เนื่องจากมีข้อเสนอแนะให้ใช้typeแทนisinstance

ขอบคุณ @Lynn เป็นเวลา 7 ไบต์ด้วย-~และmap

ขอบคุณ @FryAmTheEggman z>=[]แทนtype

+12 ไบต์เพื่อแปลงแลมบ์ดาให้เป็นอย่างอื่นและแก้ไขข้อผิดพลาดที่สำคัญ

-16 ไบต์ขอบคุณ @Kevin Lau - ไม่ใช่ Kenny

ลองออนไลน์

d=lambda z:z==[]or z>[]and-~max(map(d,z))
p=lambda x,y:p(y,x)if d(x)>d(y)else(x+y if d(x)<1 else[p(a,b)for a,b in zip(x,y)]+x[len(y):]+y[len(x):])if d(x)==d(y)else[p(a,x)for a in y]

Python 2, 145 136 ไบต์

d=lambda t:t>{}and-~max(map(d,t+[0]))
s=lambda x,y:s(y,x)if d(y)<d(x)else map(s,(x,[x]*len(y))[d(x)<d(y)],y)if d(y)else(x or 0)+(y or 0)

ทดสอบบนIdeone

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

ใน Python 2 จำนวนเต็มทั้งหมดมีค่าน้อยกว่าพจนานุกรมทั้งหมด แต่รายการทั้งหมดมีค่ามากกว่า dคำนวณซ้ำความลึกของtโดยส่งกลับ0สำหรับจำนวนเต็มหรือเพิ่มความลึกสูงสุดขององค์ประกอบและ 0 t+[0]หลีกเลี่ยงการสร้างรายการว่างเปล่าเป็นพิเศษ

sซ้ำคำนวณผลรวมเยลลี่ของxและy ที่

หากY 's ลึกเกินกว่าx ' s, s(y,x)โทรsมีข้อโต้แย้งสลับการทำให้แน่ใจว่าd (x) ≤ d (y)

หากYมีความลึกในเชิงบวกmap(s,(x,[x]*len(y))[d(x)<d(y)],y)ไม่ดังต่อไปนี้

• ถ้าx 'และY ' s ความลึกตรงจะรันmap(s,x,y)ทำแผนที่sมากกว่าองค์ประกอบทั้งหมดของxและองค์ประกอบที่สอดคล้องกันของปี

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

• ถ้าx 's ลึกต่ำกว่าปี ' s จะรันmap(s,[x]*len(y),y)ทำแผนที่s (x, ·)ในช่วงปี

ถ้าy (และดังนั้น, x ) มีความลึก0 , (x or 0)+(y or 0)แทนที่อาร์กิวเมนต์เท็จ ( ไม่มีหรือ0 ) ด้วยค่าศูนย์และส่งกลับผลรวมของจำนวนเต็มที่เกิดขึ้น

JavaScript (ES6) 152 ไบต์

f=(a,b,g=a=>a.map?1+Math.max(0,...a.map(g)):0)=>g(a)<g(b)?f(b,a):g(b)<g(a)?a.map(e=>f(e,b)):g(a)?a.length<b.length?f(b,a):a.map((e,i)=>f(e,b[i]||0)):a+b
;t=(x,y,z)=>o.textContent+=`
${JSON.stringify(x)}
${JSON.stringify(y)}
${JSON.stringify(z)}
${JSON.stringify(f(x,y))}
`;`
0 + 0                           = 0
[-1, 0, -1] + [1]               = [0, 0, -1]
[] + [0]                        = [0]
[] + 0                          = []
[] + []                         = []
[[], 0] + []                    = [[], []]
[1, 2, 3] + 10                  = [11, 12, 13]
[1, 2, 3] + [10]                = [11, 2, 3]
[1, 2, 3] + [10, [20]]          = [[11, 12, 13], [21, 2, 3]]
[1, 2, 3, []] + [10, [20]]      = [11, [22], 3, []]
[1, [2, [3, [4]]]] + [10, [20]] = [[11, [21]], [[12, [22]], [13, [24]]]]`.slice(1).split`
`.map(l=>t(...l.split(/ [+=] /).map(a=>JSON.parse(a))));

<pre id=o></pre>

ทับทิม 2.3, 143 145 148 149 ไบต์

Ruby มีนิสัยzipแปลกๆ เล็กน้อยเหล่านี้ในการทำงานกับอาร์เรย์ที่มีความยาวต่างกันและmapฟังก์ชั่นที่มีหลายอาร์กิวเมนต์ทำให้การเล่นกอล์ฟลงไปอย่างสนุกสนาน

f=->x,y{d=->a{-~(a.map(&d).max||0)rescue 0}
d[x]<d[y]?y.map{|e|f[x,e]}:d[x]>d[y]?x.map{|e|f[e,y]}:d[x]<1?x+(y||0):[*x.zip(y).map(&f),*y[x.size..-1]]}

Julia, 113 ไบต์

~=endof;!t=0t!=0&&1+maximum(!,[t;0])
x::Array+y::Array=(!x,~x)>(!y,~y)?y+x:!x<!y?map(t->x+t,y):~x<~y?[x;0]+y:x.+y

ลองออนไลน์!

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

~=endof

สร้างนามแฝง 1 ไบต์สำหรับendofซึ่งส่งคืนความยาวของอาร์เรย์

!t=0t!=0&&1+maximum(!,[t;0])

กำหนดฟังก์ชั่นความลึก ความลึกของtเป็นศูนย์ถ้าหาก0t == 0เท่านั้น ถ้าไม่ตันเป็นอาร์เรย์และความลึกของมันจะถูกคำนวณเป็นค่าสูงสุดที่เพิ่มขึ้นของระดับความลึกขององค์ประกอบและของ0 [t;0]ผนวก0เข้ากับอาร์เรย์tดังนั้นหลีกเลี่ยงความจำเป็นที่จะต้องใช้อาร์เรย์ว่างเปล่าเป็นกรณีพิเศษ

ผลรวมในตัวของ Julia +ทำตัวเหมือนผลรวมของ Jelly หากอาร์กิวเมนต์ (หรือทั้งคู่) เป็นจำนวนเต็ม อย่างไรก็ตามผลรวมของสองอาร์เรย์ ( + ) ต้องการอาร์เรย์ที่มีรูปร่างเดียวกันและแม้แต่ผลรวม vectorized ( . + ) จำเป็นต้องใช้อาร์เรย์ที่สามารถออกอากาศไปยังรูปร่างทั่วไปได้

เรากำหนด+ อีกครั้งสำหรับอาร์เรย์หนึ่งคู่ผ่าน

x::Array+y::Array=(!x,~x)>(!y,~y)?y+x:!x<!y?map(t->x+t,y):~x<~y?[x;0]+y:x.+y

สิ่งนี้ไม่ส่งผลกระทบต่อคำจำกัดความของ+สำหรับอาร์กิวเมนต์จำนวนเต็ม / จำนวนเต็มอาร์เรย์ / จำนวนเต็มหรืออาร์กิวเมนต์จำนวนเต็ม / อาร์เรย์

(!x,~x)>(!y,~y)lexicographically เปรียบเทียบคู่ของความลึกและความยาวของทั้งxและy ที่ ถ้าx 's ลึกเกินY ' s หรือหากการแข่งขันของพวกเขาและความลึกx 's มีความยาวเกินY ' s, y+xโทรซ้ำ+กับการขัดแย้งสลับ

มิฉะนั้น!x<!yทดสอบว่าความลึกของxต่ำกว่าของyหรือไม่ ถ้าเป็นmap(t->x+t,y)แผนที่x + ·กว่าปี

หากความลึกตรงกันให้~x<~yทดสอบว่าxสั้นกว่าyหรือไม่ ถ้าเป็นแบบนั้นจะ[x;0]+yเรียก+ซ้ำหลังจากผนวก0เข้ากับอาร์กิวเมนต์ด้านซ้าย

สุดท้ายหากทั้งความลึกและความยาวเหมือนx.+yแผนที่+มากกว่าองค์ประกอบทั้งหมดของxและองค์ประกอบที่สอดคล้องกันของปี