แรงบันดาลใจจากค้นหา“ขนาดยังไม่ได้เปิด” ของรายการ

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

ท้าทาย

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

อินพุตเป็นรายการและอาจมีตัวเลขสตริง (หากภาษาของคุณมี) และรายการที่คล้ายกัน

ตัวอย่างเช่น:

RS([]) = 0

RS([[]]) = 1

RS([4, 5, 6]) = 3
RS(["four", "five", "six"]) = 3
RS(["[[[[]]]]", "[][][][][]", "][][[[]]][]["]) = 3

RS([[4, 5, 6]]) = 4
RS([["four", "five", "six"]]) = 4
RS([["[[[[]]]]", "[][][][][]", "][][[[]]][]["]]) = 4

RS([[4], [5], [6]]) = 6
RS([["four"], ["five"], ["six"]]) = 6
RS([["[[[[]]]]"], ["[][][][][]"], ["][][[[]]][]["]]) = 6

RS([[[[[[[[[]]]]]]]]]) = 8

RS([[],[],[],[],[],[],[],[]]) = 8

RS([[],[],[[]],[[[[]]]]]) = 8

RS([0,[-1],[2.3,-4.3],[5,[6]],[7,[8,9,[10,11,[12,13,14]]]]]) = 22

โปรดทราบว่าหากภาษาของคุณไม่มีสตริง แต่มีรายการอักขระตัวอย่างที่มี"strings"อยู่ด้านบนอาจเป็นรายการอักขระและมีผลลัพธ์ที่ใหญ่กว่า ตัวอย่างเช่น:

RS([['f','o','u','r'], ['f','i','v','e'], ['s','i','x']]) = 14

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

อินพุตที่ไม่ใช่รายการอาจสร้างเอาต์พุตใด ๆ
I / O เป็นความยืดหยุ่นตามปกติ

เยลลี่ขนาด 8 ไบต์

߀-ŒḊ?‘S

ลองออนไลน์!

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

߀-ŒḊ?‘S  Main link. Argument: x

   ŒḊ?    If x has non-zero depth:
߀          Recursively map the main link over its elements.
  -         Else, yield -1.
      ‘   Increment all integers in the result.
       S  Compute the sum of the result.
          If x is an array, incrementing before adding is equivalent to computing
          the sum of the elements and the length.
          If x is an integer/character, incrementing -1 yields 0, as desired.

Python ขนาด 42 ไบต์

f=lambda x:x*0==[]and len(x)+sum(map(f,x))

สำหรับรายการที่ไม่ใช่รายการเอาท์พุท 0 สำหรับรายการให้ส่งออกความยาวรวมกับผลรวมของเอาต์พุตแบบเรียกซ้ำสำหรับองค์ประกอบ

รายการตกอยู่ด้านบนและด้านล่างหมายเลขสตริงในหลาม 2 []<=x<''สั่งซื้อที่กำหนด แต่เราจะตรวจสอบx*0==[]ในขณะที่ผลลัพธ์ของ0ตัวเลขหรือ''สตริง

JavaScript (ES6), 39 37 ไบต์

บันทึก 2 ไบต์ขอบคุณ @ edc65

f=a=>a.map&&a.map(x=>a-=~f(x),a=0)&&a

Mathematica ขนาด 20 ไบต์

Length@Level[#,∞]&

ฟังก์ชั่นไม่ระบุชื่อ รับค่านิพจน์เป็นอินพุตและส่งคืนตัวเลขเป็นเอาต์พุต อักขระ Unicode เป็น U + 221E INFINITY \[Infinity]สำหรับ Level[#,∞]ให้รายการของนิพจน์ย่อยของอินพุตและLength@นับมัน

Mathematica ขนาด 14 ไบต์

LeafCount@#-1&

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

Perl, 34 ไบต์

ฟังก์ชั่นวนซ้ำ! ใช่ Perl ไม่เพียงมี regex แต่ยังมีฟังก์ชั่น!

sub f{@_+f(map ref?@$_:(),@_)if@_}

หากคุณต้องการทดสอบคุณสามารถเรียกใช้สิ่งต่อไปนี้:

perl -pE 'sub f{@_+f(map ref?@$_:(),@_)if@_}$_=f@{+eval}' <<< '[["four"], ["five"], ["six"]]'

Mathematica ขนาด 32 ไบต์

Length@#+Tr[#0/@#~Select~ListQ]&

ฟังก์ชันเรียกซ้ำไม่มีชื่อ ข้อความที่ตัดตอนมาจะ#0/@#~Select~ListQเรียกใช้ฟังก์ชันอีกครั้งในแต่ละองค์ประกอบของอินพุตซึ่งเป็นรายการและTrรวมค่าเหล่านั้นด้วย โชคดีที่ Mathematica ใช้ความยาวของรายการว่างและค้นหาองค์ประกอบที่มีคุณสมบัติจากรายการว่างดังนั้นไม่จำเป็นต้องใช้ตัวพิมพ์ใหญ่

Haskell, 52 ไบต์

data L a=E a|N[L a]
r(N n)=1+sum(r<$>n)
r _=1
pred.r

ตัวอย่างการใช้งาน:

*Main> pred.r $ N[E 0,N[E(-1)],N[E 2.3,E(-4.3)],N[E 5,N[E 6]],N[E 7,N[E 8,E 9,N[E 10,E 11,N[E 12,E 13,E 14]]]]] 
22

Haskell ไม่สนับสนุนรายการผสม (เช่น Int และรายการของ Int) ดังนั้นฉันจึงไปกับประเภทรายการที่กำหนดเองLซึ่งเป็นองค์ประกอบของประเภท (-> E a) หรือรายการ Ls (-> N[L a]) อื่น ๆ การคำนวณ RS เป็นการเรียกซ้ำแบบง่ายที่Eจำนวน1และNหนึ่งบวกกับผลรวมของขนาดที่เรียกซ้ำขององค์ประกอบ ผลรวมทั้งปิดโดย 1 predดังนั้นฉันลบมันผ่าน

บันทึก Side: ประเภทที่แน่นอนและค่าขององค์ประกอบที่ไม่ได้เป็นสิ่งสำคัญสำหรับขั้นตอนวิธีการเพื่อให้เราสามารถลบ polymorphism data L=E|N[L]การจัดการกับองค์ประกอบนามธรรมเท่านั้นและไปกับ

ตัวคูณ 105 ไบต์

ฟังก์ชันเรียกซ้ำ g.

: g ( o -- l ) [ dup [ sequence? ] [ string? not ] bi and [ [ g ] map sum 1 + ] [ drop 1 ] if ] map sum ;

Ungolfed (kinda):

: g ( o -- l ) 
[ dup 
  [ sequence? ] 
  [ string? not ] 
  bi and 
  [ [ g ] map sum 1 + ] 
  [ drop 1 ] 
  if 
] map sum ;

คุณจะพบว่าไม่มีการเรียกlengthเพราะแทนที่จะใช้ความยาวบิวด์อินมันจะถูกนำไปใช้drop 1กับสตริงและลำดับที่ไม่ใช่

Mathematica ขนาด 18 ไบต์

(c=-1;++c&//@#;c)&

อีกวิธีการทางคณิตศาสตร์ ไม่สั้นเท่ากับการใช้งานในตัวLeafCountแต่ยังค่อนข้างรัดกุม นี้จะทำให้การใช้งานของMapAllผู้ประกอบการซึ่งเรียกฟังก์ชั่นบนโหนดของการแสดงออกทุกและเราจะใช้ฟังก์ชั่นที่เพิ่มเคาน์เตอร์//@ cเช่นเดียวกับในกรณีนี้จะช่วยให้หนึ่งเกินกว่าที่เราต้องการเพราะมันจะนับหัวรายการนอกเช่นกันดังนั้นเราจะเริ่มต้นนับจากLeafCount-1

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

int f(Array a)=>a.Length+a.OfType<Array>().Sum(f);

ลองออนไลน์!

ใช้เทคนิคเดียวกับคำตอบ Java ที่ส่งไปก่อนหน้านี้แต่ใช้ประโยชน์จาก LINQ เพื่อลดความยาวคำตอบ

คำอธิบาย:

// f is a method that a accepts
// an array of any underlying type
int f(Array a)=>
  // include the length of the
  // current array in the total
  a.Length+
  // filter the current list to elements
  // that are also arrays
  a.OfType<Array>()
    // recursively call f on each child
    // array and add to cumulative total
    .Sum(f);

05AB1E (ดั้งเดิม), 22 17 ไบต์

"ε¼D¸D˜Êi®.V"©.V¾

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

คำอธิบาย:

ความท้าทายนี้ทำให้เกิดความท้าทายหลายประการเพื่อเอาชนะใน 05AB1E:

1. แม้ว่า 05AB1E จะมีฟังก์ชั่นวนซ้ำตั้งแต่ Elixir rewrite ( λ) แต่ก็มีประโยชน์สำหรับลำดับเลขจำนวนเต็มเท่านั้น นี่คือคำตอบของฉันเป็นตัวอย่างของฟังก์ชั่นซ้ำ 05AB1E ด้วยเหตุนี้ฉันจึงต้องหาทางเลือกอื่นในการโทรซ้ำซึ่งฉันทำโดยใส่ส่วนหนึ่งของรหัสลงในสตริงและเรียกใช้สตริงนั้นเป็นรหัส 05AB1E ซ้ำ
2. นอกจากนี้ยังไม่มีisListคำสั่งใน 05AB1E ดังนั้นฉันจึงต้องใช้วิธีแก้ไขปัญหาบางอย่างเพื่อตรวจสอบสิ่งนี้โดยใช้การตัดคำในรายการแบนราบลึกและตรวจสอบความเท่าเทียมกัน
3. และประการที่สามไม่มีแบนสำหรับรายการหลายมิติเพียงระดับเดียว ฟังก์ชั่นการแบน˜เป็นระดับการแบนที่ลึกซึ่งจะลบเลเยอร์ทั้งหมดและทำให้รายการหลายมิติเป็นรายการเดียวที่มีค่าภายในมากที่สุด (เช่น[[1,2],[[[3]],4]]จะกลายเป็น[1,2,3,4])

ฉันลงเอยด้วยรหัสที่ด้านบนเพื่อเอาชนะปัญหาทั้งสามข้อข้างต้น มันแบ่งออกเป็นสามส่วนหลัก ก่อนอื่นเรามีดังต่อไปนี้:

"..."        # Create a string with 05AB1E code
     ©       # Save this string in the register (without popping)
      .V     # Execute the string as 05AB1E code

สตริงมีรหัสต่อไปนี้:

ε            # Map each value in the given list by:
             # (this uses the input-list implicitly with the initial call)
 ¼           #  Increase the counter_variable by 1
 D           #  Duplicate the map-value
             #   i.e. STACK "A" becomes "A","A"
             #   i.e. STACK [["B","C"]] becomes [["B","C"]],[["B","C"]]
  ¸          #  Wrap it into a list
             #   i.e. "A" → ["A"]
             #   i.e. [["B","C"]] → [[["B","C"]]]
   D         #  Duplicate that again
             #   i.e. STACK "A",["A"] becomes "A",["A"],["A"]
             #   i.e. STACK [["B","C"]],[[["B","C"]]]
             #    becomes [["B","C"]],[[["B","C"]]],[[["B","C"]]]
    ˜        #  Flatten it
             #   i.e. ["A"] → ["A"]
             #   i.e. [[["B","C"]]] → ["B","C"]
     Ê       #  Check if the wrapped and wrapped+flattened lists are NOT equal
             #   i.e. ["A"] and ["A"] → 0 (falsey)
             #   i.e. [[["B","C"]]] and ["B","C"] → 1 (truthy)
      i      #  If they are:
       ®     #   Push the string from the register
        .V   #   Execute it as 05AB1E code
             #   (this is basically our recursive call, mapping the current value
             #    we duplicated initially again)

แผนที่จะใช้แทน foreach ห่วงเพราะแผนที่มีนัยyและ foreach yวงต้องชัดเจน เราแค่ใส่ใจcounter_variableแต่

และในที่สุดหลังจากทำแผนที่และแผนที่ภายในทั้งหมดเสร็จแล้วเราจะ:

¾           # Push the counter_variable (which is output implicitly as result)

R , 65 ไบต์

R=function(L,`*`=sapply)"if"(any(L*is.list),sum(1+L*R),length(L))

ลองออนไลน์!

การใช้งานสเปคซ้ำอย่างชัดเจน

C, 174 167 152 ไบต์

ฟังก์ชั่นวนซ้ำfซึ่งหน่วยความจำรั่ว ( 152 ):

#include"object.h"
size_t f(array_t*a){size_t t=0,i=0;for(;i<array_length(a);i++){object_t*o=array_get_copy(a,i,0);t+=o->type==6?f(o->ary):1;}return t;}

แบบเรียกซ้ำfที่ไม่รั่วไหลโดยใช้การอ้างอิงที่167 :

#include"object.h"
size_t f(array_t*a){size_t t=0,i=0;for(;i<array_length(a);i++){object_t**o=array_get_ref(a,i,0);t+=*o->type==t_array?f(*o->ary):1;}return t;}

Ungolfed:

size_t get_recursize (const array_t* const a) {
  pfn();

  object_failnull(a);

  size_t out = 0;

  for (size_t i = 0; i < array_length(a); i++) {

    object_t** o = array_get_ref(a, i, NULL);

    if ( (*o)->type == t_array ) {

      out += get_recursize((*o)->ary);

    } else {
      ++out;
    }
  }
  return out;
}

"แต่อย่างไร" คุณถามว่า "สามารถตอบคำถามนี้ใน C ได้ไหมไม่มีอาร์เรย์ที่จัดการใน C และคุณไม่มีอาร์เรย์ที่แตกต่างกันจริงๆ ... ?"

"Aha," I reply, "สำหรับฉันได้ทำงานในระบบ" object "สำหรับ (GNU-ish) C11 และ ISO C ++ 11"

โปรแกรมสาธิตเต็มรูปแบบสำหรับฟังก์ชั่นนี้คือ:

#include "../calc/object/object.h"

size_t get_recursize (const array_t* const a);

define_array_new_fromctype(ssize_t);

int main (void) {

  size_t len = 6;

  static const ssize_t h[6] = { -1, 3, -5, 7, -9, 11 };

  array_t* a = array_new_from_ssize_t_lit(h, len, t_realint);

  size_t rsize = get_recursize(a);

  printf("Recursive size of a: %zu\n", rsize);

  object_t* asobj = object_new(t_array, a);
  array_destruct(a);

  array_t* b = array_new(NULL, -1);

  for (size_t j = 0; j < 10; j++) {
    array_append(b, asobj);
  }

  object_destruct(asobj);

  rsize = get_recursize(b);

  printf("Recursive size of b: %zu\n", rsize);

  asobj = object_new(t_array, b);
  array_destruct(b);

  array_t* c = array_new(NULL, -1);

  for (size_t i = 0; i < 100; i++) {
    array_append(c, asobj);
  }

  object_destruct(asobj);

  rsize = get_recursize(c);

  printf("Recursive size of c: %zu\n", rsize);

  array_destruct(c);

  return EXIT_SUCCESS;
}

size_t get_recursize (const array_t* const a) {
  pfn();

  object_failnull(a);

  size_t out = 0;

  for (size_t i = 0; i < array_length(a); i++) {

    object_t** o = array_get_ref(a, i, NULL);

    if ( (*o)->type == t_array ) {

      out += get_recursize((*o)->ary);

    } else {
      ++out;
    }
  }
  return out;
}

ตอนนี้มันอยู่ที่นี่และคุณจะต้องซื้อคืนเพื่อใช้สิ่งนี้

คุณจะต้องใช้ไลบรารีแฮช Fowler-Noll-Vo libfnvซึ่งรวบรวมไว้สำหรับแพลตฟอร์มของคุณ มันอยู่ในพื้นที่เก็บข้อมูลที่และคุณยังสามารถคว้ามันนี่

cc -DNODEBUG size.c path/to/libfnv.a -o sizeจากนั้นคุณสามารถทำได้

การใช้งานไม่จำเป็นต้องมีประสิทธิภาพ:

$ valgrind --leak-check=full --track-origins=yes --show-leak-kinds=all ./size
==24127== Memcheck, a memory error detector
==24127== Copyright (C) 2002-2015, and GNU GPL'd, by Julian Seward et al.
==24127== Using Valgrind-3.12.0.SVN and LibVEX; rerun with -h for copyright info
==24127== Command: ./size
==24127== 
Recursive size of a: 6
Recursive size of b: 60
Recursive size of c: 6000
==24127== 
==24127== HEAP SUMMARY:
==24127==     in use at exit: 0 bytes in 0 blocks
==24127==   total heap usage: 22,900 allocs, 22,900 frees, 615,584 bytes allocated
==24127== 
==24127== All heap blocks were freed -- no leaks are possible
==24127== 
==24127== For counts of detected and suppressed errors, rerun with: -v
==24127== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)

แต่มันใช้งานได้! การส่งข้อมูลครั้งสุดท้ายไปยังต้นแบบ (ซึ่งโปรแกรมนี้รวบรวมไว้) คือ 2 วันที่ผ่านมาซึ่งหมายความว่าการส่งนี้ถูกต้อง

ความจริง 118 ไบต์

RS(a:Union(List(Any),Any)):INT==(a case List(Any)=>(g:List(Any):=a;leaf? g=>0;r:=#g;for i in g repeat r:=r+RS(i);r);0)

ungolfed

RS(a:Union(List(Any),Any)):INT==
  a case List(Any)=>
          g:List(Any):=a
          leaf? g=>0
          r:=#g
          for i in g repeat r:=r+RS(i)
          r
  0

ผล

(25) -> RS([])=0
   (25)  0= 0
                                        Type: Equation NonNegativeInteger
(26) -> RS([[]]) = 1
   (26)  1= 1
                                           Type: Equation PositiveInteger
(27) -> RS([4, 5, 6]) = 3
   (27)  3= 3
                                           Type: Equation PositiveInteger
(28) -> RS(["four", "five", "six"]) = 3
   (28)  3= 3
                                           Type: Equation PositiveInteger
(29) -> RS(["[[[[]]]]", "[][][][][]", "][][[[]]][]["]) = 3
   (29)  3= 3
                                           Type: Equation PositiveInteger
(30) -> RS([[4, 5, 6]]) = 4
   (30)  4= 4
                                           Type: Equation PositiveInteger
(31) -> RS([["four", "five", "six"]]) = 4
   (31)  4= 4
                                           Type: Equation PositiveInteger
(32) -> RS([["[[[[]]]]", "[][][][][]", "][][[[]]][]["]]) = 4
   (32)  4= 4
                                           Type: Equation PositiveInteger
(33) -> RS([[4], [5], [6]]) = 6
   (33)  6= 6
                                           Type: Equation PositiveInteger
(34) -> RS([["four"], ["five"], ["six"]]) = 6
   (34)  6= 6
                                           Type: Equation PositiveInteger
(35) -> RS([["[[[[]]]]"], ["[][][][][]"], ["][][[[]]][]["]]) = 6
   (35)  6= 6
                                           Type: Equation PositiveInteger
(36) -> RS([[[[[[[[[]]]]]]]]]) = 8
   (36)  8= 8
                                           Type: Equation PositiveInteger
(37) -> RS([[],[],[],[],[],[],[],[]]) = 8
   (37)  8= 8
                                           Type: Equation PositiveInteger
(38) -> RS([[],[],[[]],[[[[]]]]]) = 8
   (38)  8= 8
                                           Type: Equation PositiveInteger
(39) -> RS([0,[-1],[2.3,-4.3],[5,[6]],[7,[8,9,[10,11,[12,13,14]]]]]) = 22
   (39)  22= 22
                                           Type: Equation PositiveInteger
(40) -> RS([['f','o','u','r'], ['f','i','v','e'], ['s','i','x']]) = 14
   (40)  14= 14
                                           Type: Equation PositiveInteger

APL (NARS), 24 ตัวอักษร, 48 ไบต์

{⍬≡⍵:0⋄×≡⍵:(≢⍵)++/∇¨⍵⋄0}

นี่จะเป็นการสรุปความจริงของคำตอบ 'ฉัน' ที่นี่ ... ใน APL รายการโมฆะจะเป็น´⍬´ Zilde ที่คุณระบุด้วย with [] ´,´⊂⍬´ คือ´ [[]] 1 2 3´คือ ´[1,2,3]´ ecc การทดสอบบางอย่าง:

  RS←{⍬≡⍵:0⋄×≡⍵:(≢⍵)++/∇¨⍵⋄0}
  RS ⍬
0
  RS ⊂⍬
1
  RS  4 5 6
3
  RS ("four")("five")("six")
14
  RS ('f' 'o' 'u' 'r') ('f' 'i' 'v' 'e') ('s' 'i' 'x')
14
  RS ("(((())))")("()()()()()")(")()((()))()(")
33
  RS (⊂4 5 6)
4
  RS (⊂("four")("five")("six")) 
15
  RS (⊂("(((())))")("()()()()()")(")()((()))()(") )
34
  RS (,4) (,5) (,6)
6
  RS ⊂¨("four")("five")("six")
17
  RS ⊂¨("(((())))")("()()()()()")(")()((()))()(") 
36
  RS ⊂⊂⊂⊂⊂⊂⊂⊂⍬
8
  RS ⍬⍬⍬⍬⍬⍬⍬⍬
8
  RS ⍬⍬(⊂⍬)(⊂(⊂(⊂⍬)))
8
  RS 0(,¯1)(2.3 ¯4.3)(5 (,6))(7 (8 9 (10 11 (12 13 14))))  
22     

สำหรับการพิมพ์ผลลัพธ์ประเภทอื่น ๆ แบบฝึกหัดเสนอเราต้องการอีกฟังก์ชั่นหนึ่ง (ทั้งฟังก์ชั่น RS และ Rs ควรจะโอเคสำหรับการฝึกหัด)

  Rs←{⍬≡⍵:0⋄(''≡0↑⍵)∨0=≡⍵:0⋄(≢⍵)++/∇¨⍵}
  Rs ("four")("five")("six")
3
  Rs ("(((())))")("()()()()()")(")()((()))()(")
3
  Rs (⊂("four")("five")("six"))
4
  Rs (⊂("(((())))")("()()()()()")(")()((()))()(") )
4
  Rs ⊂¨("four")("five")("six")
6
  Rs ⊂¨("(((())))")("()()()()()")(")()((()))()(")
6
  Rs 0(,¯1)(2.3 ¯4.3)(5 (,6))(7 (8 9 (10 11 (12 13 14))))
22
  Rs ('f' 'o' 'u' 'r') ('f' 'i' 'v' 'e') ('s' 'i' 'x')
3

เพื่อดูว่าเราใช้ฟังก์ชั่นป้อนเสียงอย่างไร:

  o←⎕fmt
  o 0(,¯1)(2.3 ¯4.3)(5 (,6))(7 (8 9 (10 11 (12 13 14))))
┌5─────────────────────────────────────────────────────────┐
│  ┌1──┐ ┌2────────┐ ┌2─────┐ ┌2──────────────────────────┐│
│0 │ ¯1│ │ 2.3 ¯4.3│ │  ┌1─┐│ │  ┌3──────────────────────┐││
│~ └~──┘ └~────────┘ │5 │ 6││ │7 │    ┌3────────────────┐│││
│                    │~ └~─┘2 │~ │8 9 │      ┌3────────┐││││
│                    └∊─────┘ │  │~ ~ │10 11 │ 12 13 14│││││
│                             │  │    │~~ ~~ └~────────┘2│││
│                             │  │    └∊────────────────┘3││
│                             │  └∊──────────────────────┘4│
│                             └∊──────────────────────────┘5
└∊─────────────────────────────────────────────────────────┘

พิมพ์ Zilde นี้และหนึ่งรายการ 8 Zilde:

  o ⍬
┌0─┐
│ 0│
└~─┘
  o ⍬⍬⍬⍬⍬⍬⍬⍬
┌8──────────────────────────────────────┐
│┌0─┐ ┌0─┐ ┌0─┐ ┌0─┐ ┌0─┐ ┌0─┐ ┌0─┐ ┌0─┐│
││ 0│ │ 0│ │ 0│ │ 0│ │ 0│ │ 0│ │ 0│ │ 0││
│└~─┘ └~─┘ └~─┘ └~─┘ └~─┘ └~─┘ └~─┘ └~─┘2
└∊──────────────────────────────────────┘

Java, 96 ไบต์

int c(Object[]a){int r=a.length;for(var i:a)r+=i instanceof Object[]?c((Object[])i):0;return r;}

ลองออนไลน์

คำอธิบาย:

int c(Object[]a){  // Recursive method with Object-array parameter and integer return-type
  int r=a.length;  //  Result-sum, starting at the size of the input-array
  for(var i:a)     //  Loop over the input-array:
    r+=            //   Increase the result-sum by:
       i instanceof Object[]?
                   //    If the current item is an array:
        c((Object[])i) 
                   //     A recursive call with this item
       :           //    Else:
        0;         //     0 (so leave the result-sum the same)
  return r;}       //  Return the result-sum

ทูต , 21 ไบต์

{#_+Sum!$=>IsArray\_}

ลองออนไลน์!

เปลี่ยนวิธีการของC #ค่อนข้างสั้นใน Attache

ทางเลือก

25 ไบต์ f[x]:=#x+Sum!f=>IsArray\x

26 ไบต์ f[x]:=#x+Sum[f=>IsArray\x]

35 ไบต์ f:=Sum##{If[IsArray@_,1+f@_,1]}=>Id

35 ไบต์ f:=Sum@Map[{If[IsArray@_,1+f@_,1]}]

37 ไบต์ f[x]:=Sum[{If[IsArray@_,1+f@_,1]}=>x]

Clojure, 79 77 51 ไบต์

อินพุตต้องเป็นรายการไม่ใช่เวกเตอร์ sequential?ทั้งสองฝ่ายจะได้รับการสนับสนุนโดยการใช้

(defn f[i](if(seq? i)(apply +(count i)(map f i))0))

ก่อนหน้านี้:

(defn f[i](if(seq? i)(if(some seq? i)(apply +(count i)(map f i))(count i))0))

Python ขนาด 72 ไบต์

l=lambda a:0if len(a)==0else len(a)+sum(l(i)for i in a if type(i)==list)