Mari kita mendefinisikan fungsi "ukuran tidak terbuka" udari daftar bersarang l(hanya berisi daftar) dengan aturan berikut:

• Jika lkosong, berarti u(l)1.
• Jika ltidak kosong, u(l)sama dengan jumlah ukuran setiap elemen yang terbuka l, ditambah satu.

Tugas Anda adalah menulis sebuah program (atau fungsi) yang menggunakan daftar sebagai input dan output (atau mengembalikan) ukuran daftar yang terbuka.

Kasus uji:

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

Ini adalah kode-golf , jadi program terpendek (dalam byte) menang.

Retina , 1 byte

]

Cobalah online! (Baris pertama memungkinkan suite tes yang dipisahkan dengan linefeed.)

Secara default, Retina menghitung jumlah kecocokan dari regex yang diberikan pada input. Ukuran yang tidak dibungkus sama dengan jumlah []pasangan pada input dan karenanya untuk jumlah ].

Mathematica, 9 byte

LeafCount

Ternyata ada built-in untuk itu ...

Perhatikan bahwa ini tidak akan berfungsi jika daftar benar-benar berisi elemen non-daftar. Yang LeafCountbenar-benar dilakukan adalah menghitung jumlah subekspresi atom. Untuk input {{}, {{}}}, ekspresi sebenarnya berbunyi:

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

Di sini subekspresi atom sebenarnya adalah kepala List .

Brainfuck, 71 61 59 byte

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

Mengambil input dari STDIN dalam format yang diberikan dalam pertanyaan, dan mengeluarkan karakter yang kode ASCII -nya adalah "ukuran yang tidak dibuka."

Saya masih amatir di Brainfuck, jadi ada banyak kemungkinan optimisasi yang masih bisa dilakukan.

Cobalah online!

Tidak Disatukan:

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 byte

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

Saya suka ketika rekursi ternyata bersih. Ini pada dasarnya adalah pencarian input yang paling mendalam, menambahkan 1 setiap kali akhir array tercapai.

Jika array kosong salah dalam JS, ini bisa menjadi 24 byte:

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

Tapi sayang sekali, tidak. Upaya lain:

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 byte

Membutuhkan -pbendera

$_=y;[;

Terima kasih kepada @Dada untuk menghemat dua byte (saya suka btw exploit titik koma ini)

CJam , 7 5 byte

Terima kasih kepada Peter Taylor untuk menghapus 2 byte! ( e=bukannya f=:+)

r'[e=

Cobalah online!

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

05AB1E , 4 byte

I'[¢

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

Cobalah online!

Saya pikir itu bisa golf lebih tetapi bahwa 'saya' wajib, jika input dianggap sebagai array yang sebenarnya, bukan string

Labirin , 8 byte

&-
#,(/!

Cobalah online!

Penjelasan

Ini menghitung kurung pembuka melalui sedikit bitwise magic. Jika kita mempertimbangkan hasil dari kode karakter bitwise AND of [, ,dan ]with 2, kita mendapatkan:

[ , ]
2 0 0

Jadi jika kita meringkas hasil operasi ini untuk setiap karakter, kita mendapatkan dua kali nilai yang kita inginkan.

Adapun kode itu sendiri, blok 2x2 di awal adalah lingkaran kecil. Pada iterasi pertama &-tidak benar-benar melakukan apa pun kecuali bahwa mereka meletakkan nol eksplisit di atas yang implisit di bagian bawah tumpukan. Ini akan menjadi total yang berjalan (dan itu sebenarnya akan negatif untuk menyimpan byte nanti). Maka loopnya adalah sebagai berikut:

,   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.

Setelah kami meninggalkan loop, bit linear berikut dijalankan:

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

IP kemudian mengenai yang mati dan berbalik. Ketika mencoba dieksekusi /lagi, program berakhir karena pembagian yang dicoba dengan nol.

Python 3 2, 36 23 byte

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

Saya perhatikan itu u(l)sama dengan jumlah [dalam representasi string l, jadi program ini mencoba melakukan itu. Mungkin bisa bermain golf lebih jauh dengan menemukan cara lain untuk melakukan ini, meskipun ...

Python, 26 byte

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

Formula rekursif sederhana.

C #, 46 41 byte

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

l adalah string daftar bersarang. Uji di sini .

Jelly , 4 byte

߀S‘

Tidak menggunakan manipulasi string. Cobalah online! atau verifikasi semua kasus uji .

Bagaimana itu bekerja

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

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

Ruby, 13 (+1) byte

p $_.count ?[

Disebut dengan -nargumen:

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

EDIT: Diubah untuk mencetak jawaban

Regex, 1 byte

]

Cobalah online!

Brain-Flak , 63 , 61 byte

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

Cobalah online! 58 byte kode, dan +3 untuk -aflag yang mengaktifkan input ASCII.

Versi / penjelasan yang dapat dibaca:

#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 byte

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

TryItOnline!

Sunting: Terima kasih kepada Martin Ender karena mencukur 4 byte!

Edit2: Kredit ke David Holderness untuk mengoptimalkan dua lagi

///, 13 byte

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

Output dalam unary.

Cobalah online!

Penjelasan:

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

PHP, 35 byte

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

preg_match_all menemukan semua contoh yang cocok dari ekspresi reguler dan mengembalikan nomor, itulah sebabnya tag gema pendek diperlukan.

Seperti kebanyakan jawaban, ia menghitung jumlah [input dan output nomor itu

Racket 82 byte

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

Tidak Disatukan:

(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)

Pengujian:

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

Keluaran:

1
4
19
4

V , 10 byte

ÓÛ
ÒC0@"

Cobalah online!

Ini mengandung beberapa karakter yang tidak dapat dicetak, berikut ini adalah versi yang dapat dibaca:

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

<C-a>mewakili "ctrl-a" (ASCII 0x01) dan <esc>mewakili kunci keluar (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

Versi yang lebih menyenangkan, lebih tidak golf:

o0kòf]m`jòd

Cobalah 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 byte

s=>s.count(92<)

Tidak Disatukan:

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

countjumlah berapa banyak elemen memuaskan predikat, dalam hal ini 92<, yang merupakan metode <dari 92.

O , 15 byte

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

Coba di sini!

Dalam input, koma apa pun harus dihapus atau diganti dengan spasi.

Penjelasan

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.

Jika kami diizinkan untuk mengerjakan string: 10 byte

ie\']-e@-p

> <> , 21 20 18 byte

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

Sunting: skor 1 untuk pernyataan goto!

Sunting 2: Rupanya> <> berbeda dari Befunge karena ini memungkinkan offset IP non-nol setelah pembungkus (dengan kata lain, dengan menggunakan instruksi trampolin, saya dapat membungkus ke (1, 0) alih-alih (0, 0)). Menarik.

TryItOnline!

Brainfuck, 28 byte

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

Cobalah online.

Ini menghitung jumlah karakter input yang dapat dibagi 3, yaitu jumlah ]karakter.

Alternatif solusi 34-byte yang menghitung [karakter secara langsung dan mengandalkan sel 8-bit:

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

C, 48 46 Bytes

Disimpan dua byte berkat 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;}

Kode uji

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

Uji kasus

a.exe
1
4
19

penggantian tinylisp , 39 byte

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

Menentukan fungsi uyang dapat disebut seperti (u (q ((())()) ))(untuk kasus uji kedua). Melakukannya di repl menghemat 4 byte karena tanda kurung ditutup otomatis.

Penjelasan

(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)membangun diperlukan karena tinylisp tidak memiliki built-in fungsi Selain itu, hanya pengurangan.

Befunge-98 , 12 11 10 9 byte

~3%!+2j@.

TryItOnline!

Sunting: Terima kasih kepada Martin Ender karena telah memangkas satu byte

Haskell, 20 19 17 byte

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

Cobalah online!

Mengambil daftar sebagai string dan menempatkan sebuah 1dalam daftar untuk masing-masing ], lalu meringkas semua 1.

Versi pointfree: (19 byte)

length.filter(>'[')

Asumsikan , [ ]adalah satu-satunya karakter dalam string. Memfilter daftar untuk mendapatkan semua karakter lebih besar dari [, yang semuanya ]dan mengembalikan panjangnya.

Pemakaian:

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

Bash + coreutils, 29 byte

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

DASH , 14 byte

(ss[len;!> ="]

Cukup dihitung ]. Pemakaian:

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

Solusi bonus, 15 byte

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

Yang ini secara rekursif dihitung dari daftar nyata. Pemakaian:

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