다음 규칙에 따라 u중첩 목록 l( 목록 만 포함) 의 "포장 해제 된 크기"기능 을 정의 해 보겠습니다 .

• l비어 있으면 u(l)1입니다.
• l비어 있지 않은 경우 u(l)의 모든 요소에 래핑되지 않은 크기의 합에 l1을 더한 값과 같습니다.

당신의 임무는리스트를 입력으로 취하고리스트의 랩핑되지 않은 크기를 출력 (또는 리턴)하는 프로그램 (또는 함수)을 작성하는 것입니다.

테스트 사례 :

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

이것은 code-golf 이므로 가장 짧은 프로그램 (바이트)이 이깁니다.

망막 , 1 바이트

]

온라인으로 사용해보십시오! 첫 번째 줄은 줄 바꿈으로 구분 된 테스트 스위트를 활성화합니다.

기본적으로 Retina는 입력에서 주어진 정규 표현식의 일치 횟수를 계산합니다. 래핑되지 않은 크기는 []입력 의 쌍 수와 같으 므로의 수와 같습니다 ].

수학, 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)

<.

자바 스크립트 (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

펄, 9 8 7 + 1 = 8 바이트

-p깃발이 필요합니다

$_=y;[;

2 바이트 절약을위한 @Dada 덕분에 (이 세미콜론 익스플로잇 btw를 좋아합니다)

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

따라서 각 문자에 대해이 작업의 결과를 요약하면 원하는 값의 두 배를 얻습니다.

코드 자체의 시작 부분의 2x2 블록은 작은 루프입니다. 첫 번째 반복 &-에서 스택 맨 아래의 암시 적 위에 명시 적 0을 두는 것 외에는 실제로 아무것도하지 않습니다. 이것은 누계가 될 것입니다 (그리고 나중에 바이트를 저장하는 것은 음수입니다). 그런 다음 루프는 다음과 같이 진행됩니다.

,   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가 사망하고 돌아 서게됩니다. /다시 실행을 시도하면 0으로 나누려고 시도하여 프로그램이 종료됩니다.

파이썬 3 2, 36 23 바이트

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

나는 의 문자열 표현의 u(l)수와 동일하다는 것을 알았 으므로이 프로그램 [은 l그렇게하려고합니다. 그래도 다른 방법을 찾아서 더 골프를 칠 수는 있지만 ...

파이썬, 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.

루비, 13 (+1) 바이트

p $_.count ?[

-n인수 와 함께 호출 :

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

편집 : 실제로 답변을 인쇄하도록 변경되었습니다.

정규식, 1 바이트

]

온라인으로 사용해보십시오!

Brain-Flak , 63 , 61 바이트

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

온라인으로 사용해보십시오! 58 바이트의 코드, -aASCII 입력을 활성화 하는 플래그의 경우 +3

읽을 수있는 버전 / 설명 :

#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 바이트

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

TryItOnline!

편집 : 4 바이트를 깎아 준 Martin Ender 에게 감사드립니다 !

Edit2 : David Holderness 에게 2 가지 이상의 최적화

///, 13 바이트

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

단항으로 출력합니다.

온라인으로 사용해보십시오!

설명:

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

PHP, 35 바이트

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

preg_match_all 일치하는 정규 표현식의 모든 인스턴스를 찾고 숫자를 리턴하므로 짧은 에코 태그가 필요합니다.

대부분의 답변과 마찬가지로 [입력 의 수를 세고 해당 숫자를 출력합니다.

라켓 82 바이트

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

언 골프 드 :

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

테스트 :

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

산출:

1
4
19
4

V , 10 바이트

ÓÛ
ÒC0@"

온라인으로 사용해보십시오!

여기에는 인쇄 할 수없는 문자가 포함되어 있습니다. 다음은 읽을 수있는 버전입니다.

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

<C-a>"ctrl-a"(ASCII 0x01)를 <esc>나타내고 이스케이프 키 (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

더 재미 있고 덜 골프적인 버전 :

o0kòf]m`jòd

온라인으로 사용해보십시오!

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

스칼라, 15 바이트

s=>s.count(92<)

언 골프 드 :

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

count술어를 만족하는 요소 수를 계산합니다 (이 경우 92<의 방법 <) 92.

O , 15 바이트

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

여기 사용해보십시오!

입력시 쉼표를 제거하거나 공백으로 바꿔야합니다.

설명

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.

문자열에 대한 작업이 허용되는 경우 : 10 바이트

ie\']-e@-p

> <> , 21 20 18 바이트

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

편집 : goto 문의 1 점!

편집 2 : 분명히> <>는 랩핑 후 0이 아닌 IP 오프셋을 허용한다는 점에서 Befunge와 다릅니다 (즉, 트램폴린 명령을 사용하여 (0, 0) 대신 (1, 0)으로 줄 바꿈 할 수 있음). 흥미 롭군

TryItOnline!

Brainfuck, 28 바이트

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

온라인으로 사용해보십시오.

3으로 나눌 수있는 입력 문자 수, 즉 문자 수를 계산합니다 ].

[문자를 직접 계산 하고 8 비트 셀에 의존하는 대체 34 바이트 솔루션 :

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

C, 48 46 바이트

kirbyfan64sos 덕분에 2 바이트 절약

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;}

테스트 코드

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

테스트 사례

a.exe
1
4
19

tinylisp repl, 39 바이트

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

(두 번째 테스트 사례) u와 같이 호출 할 수 있는 함수 를 정의합니다 (u (q ((())()) )). repl에서 수행하면 자동 닫는 괄호로 인해 4 바이트가 절약됩니다.

설명

(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

x-(0-y)tinylisp가 내장 된 추가 기능 만 뺄셈이 없기 때문에 구조가 필요하다.

Befunge-98 , 12 11 10 9 바이트

~3%!+2j@.

TryItOnline!

편집 : 바이트를 깎아 준 Martin Ender 에게 감사드립니다.

하스켈, 20 19 17 바이트

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

온라인으로 사용해보십시오!

목록을 문자열 로 가져와 1각각에 대한 목록에 a을 넣은 ]다음 모든 1s 를 요약합니다 .

포인트 프리 버전 : (19 바이트)

length.filter(>'[')

, [ ]문자열에서 유일한 문자라고 가정 합니다. 목록을 필터링하는 것보다 모든 문자가 더 얻기 위해 [모든있는, ]반환 길이.

용법:

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

배쉬 + coreutils, 29 바이트

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

DASH , 14 바이트

(ss[len;!> ="]

간단히 계산합니다 ]. 용법:

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

보너스 솔루션, 15 바이트

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

이것은 실제 목록에서 재귀 적으로 계산됩니다. 용법:

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