次の規則により、uネストされたリストl（リストのみを含む）の「ラップされていないサイズ」関数を定義しましょう。

• lが空の場合、u(l)1です。
• lが空でない場合、u(l)は、のすべての要素のラップされていないサイズの合計にl1を加えたものに等しくなります。

あなたの仕事は、リストを入力として受け取り、リストのラップされていないサイズを出力する（または返す）プログラム（または関数）を書くことです。

テストケース：

[]                                           ->  1
[[[]],[]]                                    ->  4
[[[]],[[[[]],[]]],[[[]],[[[[]],[[],[[]]]]]]] -> 19
[[[[]]]]                                     ->  4

これはcode-golfなので、最短のプログラム（バイト単位）が勝ちます。

網膜、1バイト

]

オンラインでお試しください！（最初の行は、改行で区切られたテストスイートを有効にします。）

デフォルトでは、Retinaは入力内の指定された正規表現の一致数をカウントします。ラップされていないサイズは、単に[]入力のペアの数に等しいため、の数になります]。

Mathematica、9バイト

LeafCount

そのための組み込みがあります...

リストに実際に非リスト要素が含まれている場合、これは機能しないことに注意してください。どのようなLeafCount実際に行うことは、原子の部分式の数をカウントしています。inputの{{}, {{}}}場合、式は実際に読み取ります：

List[List[], List[List[]]]

ここで、アトミック部分式は実際にはヘッド Listです。

Brainfuck、71 61 59バイト

+[>,]<[>-[<->---]+<------[->[-]<]>[-<+>]<[-<[<]<+>>[>]]<]<.

質問で指定された形式でSTDINから入力を取得し、ASCIIコードがリストの「ラップされていないサイズ」である文字を出力します。

私はまだBrainfuckの完全なアマチュアなので、多くの最適化を行うことができます。

オンラインでお試しください！

ゴルフをしていない：

read input to tape
>>+[>,]<
current tape: (0 0 1 a b *c)
where abc represents input and * is IP

now we loop over each character (from the end)
this loops assumes we are starting on the (current) last char
and it zeroes the entire string by the time it finishes
[

  subtract 91 from this character
  technically we only subtract 85 here and correct the answer
  with the 6 minus signs below
  >-[<->---]
  current tape: (0 0 1 a b cminus91 *0)

  invert the result and put that in the next cell
  +<------[->[-]<]>
  current tape: (0 0 1 a b 0 *c==91)

  move that result back to the original cell
  [-<+>]<
  current tape: (0 0 1 a b *c==91)

  if the result is true we found a brace
  increment the very first cell if so
  [-<[<]<+>>[>]]<
  current tape: (count 0 1 a *b)

]
current tape: (count *0)

<.

JavaScript（ES6）、29 27バイト

f=([x,...a])=>x?f(x)+f(a):1

再帰がこれをきれいにしたとき、私はそれが大好きです。これは基本的に入力の深さ優先検索であり、配列の最後に到達するたびに1を追加します。

JSで空の配列が偽である場合、これは24バイトになります。

f=a=>a?f(a.pop())+f(a):1

しかし、悲しいかな、そうではありません。その他の試み：

f=a=>a.reduce((n,x)=>n+f(x),1) // Works, but 3 bytes longer
f=a=>a.map(x=>n+=f(x),n=1)&&n  // Works, but 2 bytes longer
f=a=>(x=a.pop())?f(x)+f(a):1   // Works, but 1 byte longer
f=a=>a[0]?f(a.pop())+f(a):1    // Works, but same byte count
f=a=>a+a?f(a.pop())+f(a):1     // Doesn't work on any array containing 1 sub-array
f=a=>a-1?f(a.pop())+f(a):1     // Same

Perl、9 8 7 + 1 = 8バイト

-pフラグが必要です

$_=y;[;

@Dadaに2バイトの節約をありがとう（このセミコロンの悪用を愛しています）

CJam、7 5バイト

2バイトを削除してくれたPeter Taylorに感謝します！（e=代わりにf=:+）

r'[e=

オンラインでお試しください！

r         e# Read input
 '[       e# Push open bracket char
   e=     e# Count occurrences. Implicit display

05AB1E、4バイト

I'[¢

I    Get input as a string
 '[¢ Count the opening square brackets and implicitly print them

オンラインでお試しください！

もっとゴルフができると思いますが、「I」は必須です。そうでなければ、入力は文字列ではなく実際の配列と見なされます

ラビリンス、8バイト

&-
#,(/!

オンラインでお試しください！

説明

これは、ビット単位のマジックを使用して開き括弧をカウントします。我々はビット単位のANDの文字コードの結果を検討した場合[、,および]とし2、我々が得ます：

[ , ]
2 0 0

したがって、文字ごとにこの操作の結果を合計すると、必要な値の2倍になります。

コード自体に関しては、最初の2x2ブロックは小さなループです。最初の反復&-では、スタックの一番下にある暗黙的なゼロの上に明示的なゼロを置くことを除いて、実際には何もしません。これは現在の合計になります（実際には、後でバイトを保存するために負になります）。次に、ループは次のようになります。

,   Read character. At EOF this gives -1 which causes the instruction pointer to
    leave the loop. Otherwise, the loop continues.
#   Push the stack depth, 2.
&   Bitwise AND.
-   Subtract from running total.

ループを抜けると、次の線形ビットが実行されます。

(   Decrement to turn the -1 into a -2.
/   Divide negative running total by -2 to get desired result.
!   Print.

その後、IPは死者にぶつかって向きを変えます。/再度実行しようとすると、ゼロによる除算が試行されたため、プログラムは終了します。

Pythonの3 2、36の 23バイト

lambda x:`x`.count("[")

の文字列表現ののu(l)数に等しいことに気づいたので、このプログラムはそれを試みます。おそらく、これを行う別の方法を見つけることでさらにゴルフをすることができます...[l

Python、26バイト

f=lambda a:sum(map(f,a))+1

単純な再帰式。

C＃、46 41バイト

int u(string l){return l.Count(c=>c=='[');}

lはネストされたリストの文字列です。ここでテストしてください。

ゼリー、4 バイト

߀S‘

文字列操作を使用しません。オンラインでお試しください！または、すべてのテストケースを確認します。

使い方

߀S‘  Main link. Argument: A (array)

߀    Map the main link over A.
  S   Sum. For empty arrays, this yields zero.
   ‘  Increment.

Ruby, 13 (+1) bytes

p $_.count ?[

Called with -n argument:

ruby -ne 'p $_.count ?['

EDIT: Changed to actually print out the answer

Regex, 1 byte

]

Try it online!

Brain-Flak, 63, 61 bytes

{({}[(((()()()){}){}()){({}[()])}{}]){{}(<>{}())(<>)}{}}<>

Try it online! 58 bytes of code, and +3 for the -a flag enabling ASCII input.

Readable version/explanation:

#While non-empty:
{

    #subtract
    ({}[

    #91
    (((()()()){}){}()){({}[()])}{}

    ])

    #if non-zero
    {

        # Remove the difference
        {}

        #Increment the counter on the other stack
        (<>{}())

        #Push a zero onto the main stack
        (<>)
    }

    #pop the left-over zero
    {}

#endwhile
}

#Move back to the stack with the counter, implicitly display
<>

Befunge, 22 18 16 bytes

~:0#@`#.!#$_3%!+

TryItOnline!

Edit: Thanks to Martin Ender for shaving off 4 bytes!

Edit2: Credit to David Holderness for optimizing out two more

///, 13 bytes

/[/0//]///,//

Output in unary.

Try it online!

Explanation:

/[/0/          Replace every [ with 0
     /]///,//  Remove every ] and ,

PHP, 35 bytes

<?=preg_match_all('/\[/',$argv[1]);

preg_match_all finds all of the matching instances of the regular expression and returns a number, which is why the short echo tags are needed.

Like most answers, it counts the number of [ in the input and outputs that number

Racket 82 bytes

(define n 0)(let p((l l))(if(null? l)(set! n(+ 1 n))(begin(p(car l))(p(cdr l)))))n

Ungolfed:

(define (f l)
  (define n 0)
  (let loop ((l l))
    (if (null? l)
        (set! n (add1 n))
        (begin (loop (first l))
               (loop (rest l)))))
  n)

Testing:

(f '[]) 
(f '[[[]] []]) 
(f '[[[]] [[[[]] []]] [[[]] [[[[]] [[] [[]]]]]]]) 
(f '[[[[]]]])  

Output:

1
4
19
4

V, 10 bytes

ÓÛ
ÒC0@"

Try it online!

This contains some unprintable characters, here is the readable version:

ÓÛ
Ò<C-a>C0<esc>@"

<C-a> represents "ctrl-a" (ASCII 0x01) and <esc> represents the escape key (ASCII 0x1b).

ÓÛ              " Remove all '['s
                "
Ò<C-a>          " Replace what's left with '<C-a>' (the increment command)
      C         " Delete this line
       0<esc>   " And replace it with a '0'
             @" " Run what we just deleted as V code (A bunch of increment commands

More fun, less golfy version:

o0kòf]m`jòd

Try it online!

o0<esc>                     " Put a '0' on the line below us
       k                    " Move back up a line
        ò               ò   " Recursively:
         f]                 "   Move to a right-bracket
           m`               "   Add this location to our jumplist
             j              "   Move down a line
              <C-a>         "   Increment this number
                   <C-o>    "   Move to the previous location
                         d  " Delete the bracket line
                            " Implicitly display

Scala, 15 bytes

s=>s.count(92<)

Ungolfed:

s=>s.count(c=>92<c)

count counts how many elements satisfy a predicate, in this case 92<, which is the method < of 92.

O, 15 bytes

i~{1\{nJ+}d}J;J

Try it here!

In the input, any commas must be either removed or replaced by spaces.

Explanation

i~{1\{nJ+}d}J;J
i                Read a line of input.
 ~               Evaluate it.
  {        }J;   Define a function and save it into the `J` variable.
                 Currently, the input array is at the top of the stack.
   1\            Push 1 and swap it with the input array.
     {   }d      For each element in the array...
                 Because the array was popped by `d`, 1 is at the TOS.
      nJ+        Recurse and add the result to 1.
              J  Initiate the function call.
                 The result is printed implicitly.

If we're allowed to take work on a string: 10 bytes

ie\']-e@-p

><>, 21 20 18 bytes

0i:0(90.;n?|3%0=+!

Edit: score 1 for goto statements!

Edit 2: Apparently ><> differs from Befunge in that it allows non-zero IP offset after wrapping (in other words, by using a trampoline instruction, I can wrap to (1, 0) instead of (0, 0)). Interesting.

TryItOnline!

Brainfuck, 28 bytes

,
[
  -
  [
    -
    [
      >+<-
      [->]
    ]
    >[>>]
    <<<
  ]
  ,
]
>.

Try it online.

This counts the number of input characters divisible by 3, i.e. the number of ] characters.

Alternate 34-byte solution counting [ characters directly and relying on 8-bit cells:

,
[
  <-[>-<---]
  >------
  [>-<[-]]
  >+<,
]
>.

C, 48 46 Bytes

Saved two bytes thanks to kirbyfan64sos

i;f(char*v){for(i=0;*v;i+=*v++==91);return i;}

i;f(char*v){for(i=0;*v;*v++^91?0:i++);return i;}

Test code

main()
{
    printf("%d\n", f("[]"));
    printf("%d\n", f("[[[]] []]"));
    printf("%d\n", f("[[[]] [[[[]] []]] [[[]] [[[[]] [[] [[]]]]]]]"));
}

Test cases

a.exe
1
4
19

tinylisp repl, 39 bytes

(d u(q((L)(i L(s(u(h L))(s 0(u(t L))))1

Defines a function u that can be called like (u (q ((())()) )) (for the second test case). Doing it in the repl saves 4 bytes due to auto-closed parentheses.

Explanation

(d u                                      )  Define u as
    (q                                   )    the following, unevaluated
      (                                 )     list (which acts as a function in tinylisp):
       (L)                                   Given arglist of one element, L, return:
          (i L                         )     If L (is nonempty):
              (s(u(h L))             )        Call u on head of L and subtract
                        (s 0        )          0 minus
                            (u(t L))           call u on tail of L
                                      1      Else, 1

The x-(0-y) construct is necessary because tinylisp doesn't have a built-in addition function, only subtraction.

Befunge-98, 12 11 10 9 bytes

~3%!+2j@.

TryItOnline!

Edit: Thanks to Martin Ender for shaving off a byte

Haskell, 20 19 17 bytes

f s=sum[1|']'<-s]

Try it online!

Takes the list as string and puts a 1 in a list for each ], then sums up all the 1s.

Pointfree version: (19 bytes)

length.filter(>'[')

Assumes , [ ] are the only chars in the string. Filters the list to get all chars greater than [, which are all ] and returns the length.

Usage:

Prelude> length.filter(=='[')$"[[[]],[[[[]],[]]],[[[]],[[[[]],[[],[[]]]]]]]"
19

Bash + coreutils, 29 bytes

f()(echo $1|tr -d -c [|wc -c)

DASH, 14 bytes

(ss[len;!> ="]

Simply counts ]'s. Usage:

(ss[len;!> ="]"])"[[]]"

Bonus solution, 15 bytes

a\@+1sum ->#a#0

This one recursively counts from a real list. Usage:

(f\@+1sum ->#f#0)[[]]