Temukan "ukuran yang tidak dibuka" dari daftar

12

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 , jadi program terpendek (dalam byte) menang.

Buah Esolanging
sumber
2
Bisakah input diambil sebagai string, yaitu dengan tanda kutip terlampir? Bisakah kita menggunakan ()bukan []?
Luis Mendo
bisakah kita mengambil input dalam format ini dan [[[]][]]bukan ini [[[]],[]]dalam contoh kedua Anda?
Mukul Kumar
Berapa ukurannya ["This is some text [with square brackets in] ...[& maybe more than one pair]"]?
Jonathan Allan
5
Kemungkinan rangkap dari Temukan kemunculan karakter dalam string input
James
2
@DrMcMoylex Saya tidak setuju. Walaupun menghitung jumlah ]tampaknya merupakan solusi terpendek dalam banyak bahasa, ada juga banyak jawaban yang benar-benar menyelesaikan tantangan ini melalui manipulasi daftar, dan setidaknya di esolang menghitung kemunculan karakter tetap juga sangat berbeda dengan menghitung kemunculan karakter input.
Martin Ender

Jawaban:

23

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

Martin Ender
sumber
1
Alat yang tepat untuk pekerjaan itu!
Cyoce
@ MartinEnder apakah Anda pernah menambahkan fungsi baru ke bahasa Anda untuk menyimpan byte dalam pertanyaan codegolf?
lois6b
5
@ lois6b tidak berlaku surut, tapi saya sesekali memperbaiki bahasa untuk membuatnya lebih kuat untuk penggunaan di masa depan. Yang mengatakan, jawaban ini akan bekerja di versi pertama Retina dari belakang ketika itu hanya cara untuk menjalankan regex tunggal (/ substitusi) terhadap input tanpa overhead sintaksis.
Martin Ender
11

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 .

Martin Ender
sumber
1
Mathematica memiliki
bawaan
2
@ Challenger5 Oy, plagiarisme. : P
Martin Ender
7

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)

<.
Gagang pintu
sumber
5

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
Produksi ETH
sumber
Akan f=a=>a[0]?f(a.pop())+f(a):1bekerja (Jumlah byte yang sama.)
Neil
@Neil Ya, itu salah satu solusi yang sudah saya coba. Saya tidak berpikir itu mungkin untuk mendapatkan lebih pendek ...
ETHproduk
(Ngomong-ngomong, aku akan pergi untuk boros f=a=>a.reduce((n,a)=>n+f(a),1). Sekarang, f=(n,a)=>n+a.reduce(f,1)hanya 24 byte, tapi sayangnya parameternya dalam urutan yang salah.)
Neil
@Neil Saya benar-benar melakukan itu pertama, kecuali memperpendeknya dengan 1 byte:f=a=>a.map(a=>n+=f(a),n=1)&&n
ETHproduksi
Ah, maaf, saya tidak berpikir untuk menelusuri riwayat edit.
Neil
4

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)

Gabriel Benamy
sumber
1
-puntuk menyimpan 1 byte;)
Dada
Anda dapat menggunakan y;[;untuk menyimpan satu byte lagi
Dada
4

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
Luis Mendo
sumber
3

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

Osable
sumber
2
"[[[]],[[[[]],[]]],[[[]],[[[[]],[[],[[]]]]]]]"di input menghapus Ipersyaratan itu, meskipun saya tidak tahu apakah itu diizinkan.
Magic Gurita Guci
1
@carusocomputing: Saat ini tidak diizinkan, tapi itu bisa berubah (saya melihat Luis menanyakan OP pertanyaan yang sama)
Emigna
Dang, 14 jam sebelum saya.
Oliver Ni
3

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.

Martin Ender
sumber
3

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

Buah Esolanging
sumber
6
23 byte:lambda x:`x`.count("[")
acrolith
2

Python, 26 byte

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

Formula rekursif sederhana.

Produksi ETH
sumber
2

C #, 46 41 byte

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

l adalah string daftar bersarang. Uji di sini .

Ave
sumber
Gunakan 4 spasi (sebelum kode) untuk memformatnya menjadi blok kode
user41805
@KritixiLithos oops, saya lupa melakukannya dengan benar. Terima kasih telah menunjukkannya :)
Ave
Dan ini harus menjadi program atau fungsi, ini bukan keduanya.
user41805
@KritixiLithos oops, terima kasih telah menunjukkannya, baru saja memperbaikinya.
Ave
2
Anda dapat menjatuhkan kurung kurawal dan returndengan menggunakan fungsi ekspresi tubuh. Juga charsecara implisit gips untuk intsehingga Anda dapat menggunakan 91bukannya '[': int u(string l)=>l.Count(c=>c==91);Selanjutnya, Anda bisa drop tanda tangan fungsi dan menggunakan metode lambda: l=>l.Count(c=>c==91);.
susu
2

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.
Dennis
sumber
2

Ruby, 13 (+1) byte

p $_.count ?[

Disebut dengan -nargumen:

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

EDIT: Diubah untuk mencetak jawaban

Lee W
sumber
Ini sepertinya tidak mencetak apa pun. (Kecuali jika ini adalah jawaban REPL, dalam hal ini bahasa tersebut harus ditentukan sebagai Ruby REPL.)
Martin Ender
@Martin Ender ♦ Spesifikasi diizinkan mengembalikan nilai alih-alih mencetaknya.
Lee W
Itu mengacu pada pengiriman fungsi. Misalnya ->s{s.count ?[}akan menjadi pengiriman yang valid.
Martin Ender
Apakah itu aturan umum?
Lee W
2

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
<>
James
sumber
1

///, 13 byte

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

Output dalam unary.

Cobalah online!

Penjelasan:

/[/0/          Replace every [ with 0
     /]///,//  Remove every ] and ,
akrolit
sumber
Bagaimana cara mengucapkannya ///?
roblogic
@ropata Slash
acrolith
1

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

gabe3886
sumber
1
Jika Anda menggunakan ]alih-alih [, Anda tidak perlu menghindarinya.
Martin Ender
2
count_chars()[91];melakukan banyak hal yang sama tetapi lebih pendek.
user59178
1

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
juga
sumber
1

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
James
sumber
1

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.

corvus_192
sumber
1

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
kirbyfan64sos
sumber
1

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

Brian Gradin
sumber
1

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:

,
[
  <-[>-<---]
  >------
  [>-<[-]]
  >+<,
]
>.
Mitch Schwartz
sumber
1

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
Cleblanc
sumber
Ubah *v++^91?0:i++ke i+=*v==91untuk menyimpan 3 byte.
kirbyfan64sos
@ kirbyfan64sos Terima kasih! Saya masih perlu meningkatkan v tetapi saya dapat menggunakannya i+=*v++==91untuk menghemat dua byte.
cleblanc
1

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.

DLosc
sumber
1

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
Laikoni
sumber
0

Bash + coreutils, 29 byte

f()(echo $1|tr -d -c [|wc -c)
Angs
sumber
Anda dapat menghapus sebagian besar dari ini dan lakukan tr -d -c [|wc -c, yang secara default akan membaca daftar dari input standar.
kirbyfan64sos
0

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)[[]]
Mama Fun Roll
sumber