영감을받은 리스트의 "풀어 크기"를 찾습니다 .

재귀 크기를 정의, 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.

파이썬, 42 바이트

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

목록이 아닌 경우 0을 출력합니다. 목록의 경우 길이에 해당 요소의 재귀 출력 합계를 더한 값을 출력하십시오.

파이썬 2 순서에서 목록은 숫자보다 높고 문자열 아래에 있어야합니다 []<=x<''. 대신 숫자 또는 문자열 x*0==[]의 결과를 확인 하는 반면에을 검사 합니다.0''

자바 스크립트 (ES6), 39 37 바이트

@ edc65 덕분에 2 바이트 절약

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

Mathematica, 20 바이트

Length@Level[#,∞]&

익명의 기능. 표현식을 입력으로 받아서 숫자를 출력으로 리턴합니다. 유니 코드 문자는 U + 221E INFINITY for \[Infinity]입니다. Level[#,∞]입력의 하위 표현식 목록을 제공하고 Length@계산합니다.

수학, 14 바이트

LeafCount@#-1&

내 이전 답변 의 사소한 수정 . 내가 설명했듯이 LeafCount이미 중첩 된 원자 값을 처리하지만 결과에서 빼야하는 가장 외부 목록도 계산합니다.

펄, 34 바이트

재귀 함수! 펄은 정규 표현식뿐만 아니라 기능도 가지고 있습니다!

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

테스트하고 싶다면 다음과 같이 실행할 수 있습니다.

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

수학, 32 바이트

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

재귀 기능이 없습니다. 발췌 #0/@#~Select~ListQ는 목록 인 입력의 각 요소에서 함수를 다시 호출하고 Tr해당 값을 합산합니다. 다행히 Mathematica는 빈 목록의 길이를 가져와 빈 목록에서 한정 요소를 검색하는 것이 좋으므로 기본 사례는 필요하지 않습니다.

하스켈, 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와 N1에 요소의 재귀 크기의 합을 더한 것입니다. 전체 합은 1만큼 떨어져 있으므로를 통해 빼십시오 pred.

참고 사항 : 요소의 정확한 유형과 값은 알고리즘에 중요하지 않으므로 추상 요소 만 다루는 다형성을 제거하고 함께 갈 수 있습니다 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 (킨다) :

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

length내장 된 길이를 사용하는 대신 drop 1문자열 및 비 시퀀스를 통해 구현되므로 호출이 없습니다 .

매스 매 티카, 18 바이트

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

또 다른 Mathematica 접근법. 내장을 사용하는 것만 큼 짧지는 LeafCount않지만 여전히 간결합니다. 이것은 표현식의 모든 노드에서 함수를 호출하는 MapAll연산자 //@를 사용하며 카운터를 증가시키기 위해 해당 함수를 사용합니다 c. LeafCount이 경우와 마찬가지로 외부 목록 헤드도 계산하므로 카운터를 시작하기 때문에 필요한 것 이상을 제공합니다 -1.

C # (Visual C # Interactive Compiler) , 50 바이트

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

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

이전에 제출 한 Java answer 와 동일한 기술을 사용 하지만 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. isList05AB1E 에는 명령이 없으므로 목록으로 줄 바꿈, 깊게 평평하게하고 평등을 확인하여이를 확인하기 위해 몇 가지 해결 방법을 사용해야했습니다.
3. 셋째, 한 차원의 다차원 목록에 대한 평평함이 없습니다. flatten 함수 ˜는 모든 레이어를 제거하고 다차원 목록을 가장 안쪽의 모든 값이 포함 된 단일 목록으로 만드는 깊은 병합입니다. (즉 [[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)

맵에는 암시 적 (implicit y)이 있고 foreach-loop에는 명시 적이 필요 하기 때문에 foreach-loop 대신 맵이 사용됩니다 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;}

167f 에서 참조를 사용하여 누출되지 않는 재귀 :

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

언 골프 드 :

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는"(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;
}

지금 여기 살아요 있으며 이것을 사용하려면 해당 저장소가 필요합니다.

또한 libfnv플랫폼 용으로 컴파일 된 Fowler-Noll-Vo 해시 라이브러리가 필요합니다 . 해당 저장소에 있으며 여기에서 가져올 수도 있습니다 .

그럼 넌 할 수있어 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)

언 골프

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}

이것은 'my'Axiom 답변의 문자 그대로의 traslation 일 것입니다 ... APL에서 void 목록은 ´de Zilde가 될 것입니다. 1 2 3´ is ´ [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 함수를 사용하십시오.

  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
└∊──────────────────────────────────────┘

자바, 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 #을 접근 방식은 무관 꽤 짧다.

대안

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]

클로저, 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))

파이썬, 72 바이트

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