ArrListLen coding task - Practice Coding

给定一个起始下标为 0 的非空数组 A 用来表示一个链表结构，这个链表遵循如下构造：

链表头（第一个节点）是数组中下标为 0 的元素；

下标为 K 的节点的值为 A[K]；

对于数组中下标为 K 的节点，其下一个节点的下标为 A[K]；

如果一个节点的值为−1，则这个节点是链表的最后一个节点。

例如，对于如下的数组A：

A[0] = 1 A[1] = 4 A[2] = -1 A[3] = 3 A[4] = 2

其对应的链表构造如下：

第一个节点（链表头）的数组下标为 0，其值为 1；

第二个节点的数组下标为 1，其值为 4；

第三个节点的数组下标为 4，其值为 2；

第四个节点的数组下标为 2，其值为 −1；

实现一个函数

int solution(int A[], int N);

对于给定的起始下标为 0、包含 N 个整数的非空数组A，返回按照上述规则所构造的链表的长度。

例如，给出如下的数组A：

A[0] = 1 A[1] = 4 A[2] = -1 A[3] = 3 A[4] = 2

如上述例子所示，该函数应当返回 4 。

假定:

N 是 [1..200,000] 内的整数;

数组 A 每个元素是取值范围 [−1..N-1] 内的整数 ;

输入数据总是保证有解，并且结果数列的长度有限。.

本题仅针对解法的正确性进行评测；解法的时间和空间复杂度并不在评测范围内。

给定一个起始下标为 0 的非空数组 A 用来表示一个链表结构，这个链表遵循如下构造：

链表头（第一个节点）是数组中下标为 0 的元素；

下标为 K 的节点的值为 A[K]；

对于数组中下标为 K 的节点，其下一个节点的下标为 A[K]；

如果一个节点的值为−1，则这个节点是链表的最后一个节点。

例如，对于如下的数组A：

A[0] = 1 A[1] = 4 A[2] = -1 A[3] = 3 A[4] = 2

其对应的链表构造如下：

第一个节点（链表头）的数组下标为 0，其值为 1；

第二个节点的数组下标为 1，其值为 4；

第三个节点的数组下标为 4，其值为 2；

第四个节点的数组下标为 2，其值为 −1；

实现一个函数

int solution(vector<int> &A);

对于给定的起始下标为 0、包含 N 个整数的非空数组A，返回按照上述规则所构造的链表的长度。

例如，给出如下的数组A：

A[0] = 1 A[1] = 4 A[2] = -1 A[3] = 3 A[4] = 2

如上述例子所示，该函数应当返回 4 。

假定:

N 是 [1..200,000] 内的整数;

数组 A 每个元素是取值范围 [−1..N-1] 内的整数 ;

输入数据总是保证有解，并且结果数列的长度有限。.

本题仅针对解法的正确性进行评测；解法的时间和空间复杂度并不在评测范围内。

给定一个起始下标为 0 的非空数组 A 用来表示一个链表结构，这个链表遵循如下构造：

链表头（第一个节点）是数组中下标为 0 的元素；

下标为 K 的节点的值为 A[K]；

对于数组中下标为 K 的节点，其下一个节点的下标为 A[K]；

如果一个节点的值为−1，则这个节点是链表的最后一个节点。

例如，对于如下的数组A：

A[0] = 1 A[1] = 4 A[2] = -1 A[3] = 3 A[4] = 2

其对应的链表构造如下：

第一个节点（链表头）的数组下标为 0，其值为 1；

第二个节点的数组下标为 1，其值为 4；

第三个节点的数组下标为 4，其值为 2；

第四个节点的数组下标为 2，其值为 −1；

实现一个函数

int solution(vector<int> &A);

对于给定的起始下标为 0、包含 N 个整数的非空数组A，返回按照上述规则所构造的链表的长度。

例如，给出如下的数组A：

A[0] = 1 A[1] = 4 A[2] = -1 A[3] = 3 A[4] = 2

如上述例子所示，该函数应当返回 4 。

假定:

N 是 [1..200,000] 内的整数;

数组 A 每个元素是取值范围 [−1..N-1] 内的整数 ;

输入数据总是保证有解，并且结果数列的长度有限。.

本题仅针对解法的正确性进行评测；解法的时间和空间复杂度并不在评测范围内。

给定一个起始下标为 0 的非空数组 A 用来表示一个链表结构，这个链表遵循如下构造：

链表头（第一个节点）是数组中下标为 0 的元素；

下标为 K 的节点的值为 A[K]；

对于数组中下标为 K 的节点，其下一个节点的下标为 A[K]；

如果一个节点的值为−1，则这个节点是链表的最后一个节点。

例如，对于如下的数组A：

A[0] = 1 A[1] = 4 A[2] = -1 A[3] = 3 A[4] = 2

其对应的链表构造如下：

第一个节点（链表头）的数组下标为 0，其值为 1；

第二个节点的数组下标为 1，其值为 4；

第三个节点的数组下标为 4，其值为 2；

第四个节点的数组下标为 2，其值为 −1；

实现一个函数

class Solution { public int solution(int[] A); }

对于给定的起始下标为 0、包含 N 个整数的非空数组A，返回按照上述规则所构造的链表的长度。

例如，给出如下的数组A：

A[0] = 1 A[1] = 4 A[2] = -1 A[3] = 3 A[4] = 2

如上述例子所示，该函数应当返回 4 。

假定:

N 是 [1..200,000] 内的整数;

数组 A 每个元素是取值范围 [−1..N-1] 内的整数 ;

输入数据总是保证有解，并且结果数列的长度有限。.

本题仅针对解法的正确性进行评测；解法的时间和空间复杂度并不在评测范围内。

给定一个起始下标为 0 的非空数组 A 用来表示一个链表结构，这个链表遵循如下构造：

链表头（第一个节点）是数组中下标为 0 的元素；

下标为 K 的节点的值为 A[K]；

对于数组中下标为 K 的节点，其下一个节点的下标为 A[K]；

如果一个节点的值为−1，则这个节点是链表的最后一个节点。

例如，对于如下的数组A：

A[0] = 1 A[1] = 4 A[2] = -1 A[3] = 3 A[4] = 2

其对应的链表构造如下：

第一个节点（链表头）的数组下标为 0，其值为 1；

第二个节点的数组下标为 1，其值为 4；

第三个节点的数组下标为 4，其值为 2；

第四个节点的数组下标为 2，其值为 −1；

实现一个函数

int solution(List<int> A);

对于给定的起始下标为 0、包含 N 个整数的非空数组A，返回按照上述规则所构造的链表的长度。

例如，给出如下的数组A：

A[0] = 1 A[1] = 4 A[2] = -1 A[3] = 3 A[4] = 2

如上述例子所示，该函数应当返回 4 。

假定:

N 是 [1..200,000] 内的整数;

数组 A 每个元素是取值范围 [−1..N-1] 内的整数 ;

输入数据总是保证有解，并且结果数列的长度有限。.

本题仅针对解法的正确性进行评测；解法的时间和空间复杂度并不在评测范围内。

给定一个起始下标为 0 的非空数组 A 用来表示一个链表结构，这个链表遵循如下构造：

链表头（第一个节点）是数组中下标为 0 的元素；

下标为 K 的节点的值为 A[K]；

对于数组中下标为 K 的节点，其下一个节点的下标为 A[K]；

如果一个节点的值为−1，则这个节点是链表的最后一个节点。

例如，对于如下的数组A：

A[0] = 1 A[1] = 4 A[2] = -1 A[3] = 3 A[4] = 2

其对应的链表构造如下：

第一个节点（链表头）的数组下标为 0，其值为 1；

第二个节点的数组下标为 1，其值为 4；

第三个节点的数组下标为 4，其值为 2；

第四个节点的数组下标为 2，其值为 −1；

实现一个函数

func Solution(A []int) int

对于给定的起始下标为 0、包含 N 个整数的非空数组A，返回按照上述规则所构造的链表的长度。

例如，给出如下的数组A：

A[0] = 1 A[1] = 4 A[2] = -1 A[3] = 3 A[4] = 2

如上述例子所示，该函数应当返回 4 。

假定:

N 是 [1..200,000] 内的整数;

数组 A 每个元素是取值范围 [−1..N-1] 内的整数 ;

输入数据总是保证有解，并且结果数列的长度有限。.

本题仅针对解法的正确性进行评测；解法的时间和空间复杂度并不在评测范围内。

给定一个起始下标为 0 的非空数组 A 用来表示一个链表结构，这个链表遵循如下构造：

链表头（第一个节点）是数组中下标为 0 的元素；

下标为 K 的节点的值为 A[K]；

对于数组中下标为 K 的节点，其下一个节点的下标为 A[K]；

如果一个节点的值为−1，则这个节点是链表的最后一个节点。

例如，对于如下的数组A：

A[0] = 1 A[1] = 4 A[2] = -1 A[3] = 3 A[4] = 2

其对应的链表构造如下：

第一个节点（链表头）的数组下标为 0，其值为 1；

第二个节点的数组下标为 1，其值为 4；

第三个节点的数组下标为 4，其值为 2；

第四个节点的数组下标为 2，其值为 −1；

实现一个函数

class Solution { public int solution(int[] A); }

对于给定的起始下标为 0、包含 N 个整数的非空数组A，返回按照上述规则所构造的链表的长度。

例如，给出如下的数组A：

A[0] = 1 A[1] = 4 A[2] = -1 A[3] = 3 A[4] = 2

如上述例子所示，该函数应当返回 4 。

假定:

N 是 [1..200,000] 内的整数;

数组 A 每个元素是取值范围 [−1..N-1] 内的整数 ;

输入数据总是保证有解，并且结果数列的长度有限。.

本题仅针对解法的正确性进行评测；解法的时间和空间复杂度并不在评测范围内。

给定一个起始下标为 0 的非空数组 A 用来表示一个链表结构，这个链表遵循如下构造：

链表头（第一个节点）是数组中下标为 0 的元素；

下标为 K 的节点的值为 A[K]；

对于数组中下标为 K 的节点，其下一个节点的下标为 A[K]；

如果一个节点的值为−1，则这个节点是链表的最后一个节点。

例如，对于如下的数组A：

A[0] = 1 A[1] = 4 A[2] = -1 A[3] = 3 A[4] = 2

其对应的链表构造如下：

第一个节点（链表头）的数组下标为 0，其值为 1；

第二个节点的数组下标为 1，其值为 4；

第三个节点的数组下标为 4，其值为 2；

第四个节点的数组下标为 2，其值为 −1；

实现一个函数

class Solution { public int solution(int[] A); }

对于给定的起始下标为 0、包含 N 个整数的非空数组A，返回按照上述规则所构造的链表的长度。

例如，给出如下的数组A：

A[0] = 1 A[1] = 4 A[2] = -1 A[3] = 3 A[4] = 2

如上述例子所示，该函数应当返回 4 。

假定:

N 是 [1..200,000] 内的整数;

数组 A 每个元素是取值范围 [−1..N-1] 内的整数 ;

输入数据总是保证有解，并且结果数列的长度有限。.

本题仅针对解法的正确性进行评测；解法的时间和空间复杂度并不在评测范围内。

给定一个起始下标为 0 的非空数组 A 用来表示一个链表结构，这个链表遵循如下构造：

链表头（第一个节点）是数组中下标为 0 的元素；

下标为 K 的节点的值为 A[K]；

对于数组中下标为 K 的节点，其下一个节点的下标为 A[K]；

如果一个节点的值为−1，则这个节点是链表的最后一个节点。

例如，对于如下的数组A：

A[0] = 1 A[1] = 4 A[2] = -1 A[3] = 3 A[4] = 2

其对应的链表构造如下：

第一个节点（链表头）的数组下标为 0，其值为 1；

第二个节点的数组下标为 1，其值为 4；

第三个节点的数组下标为 4，其值为 2；

第四个节点的数组下标为 2，其值为 −1；

实现一个函数

function solution(A);

对于给定的起始下标为 0、包含 N 个整数的非空数组A，返回按照上述规则所构造的链表的长度。

例如，给出如下的数组A：

A[0] = 1 A[1] = 4 A[2] = -1 A[3] = 3 A[4] = 2

如上述例子所示，该函数应当返回 4 。

假定:

N 是 [1..200,000] 内的整数;

数组 A 每个元素是取值范围 [−1..N-1] 内的整数 ;

输入数据总是保证有解，并且结果数列的长度有限。.

本题仅针对解法的正确性进行评测；解法的时间和空间复杂度并不在评测范围内。

给定一个起始下标为 0 的非空数组 A 用来表示一个链表结构，这个链表遵循如下构造：

链表头（第一个节点）是数组中下标为 0 的元素；

下标为 K 的节点的值为 A[K]；

对于数组中下标为 K 的节点，其下一个节点的下标为 A[K]；

如果一个节点的值为−1，则这个节点是链表的最后一个节点。

例如，对于如下的数组A：

A[0] = 1 A[1] = 4 A[2] = -1 A[3] = 3 A[4] = 2

其对应的链表构造如下：

第一个节点（链表头）的数组下标为 0，其值为 1；

第二个节点的数组下标为 1，其值为 4；

第三个节点的数组下标为 4，其值为 2；

第四个节点的数组下标为 2，其值为 −1；

实现一个函数

fun solution(A: IntArray): Int

对于给定的起始下标为 0、包含 N 个整数的非空数组A，返回按照上述规则所构造的链表的长度。

例如，给出如下的数组A：

A[0] = 1 A[1] = 4 A[2] = -1 A[3] = 3 A[4] = 2

如上述例子所示，该函数应当返回 4 。

假定:

N 是 [1..200,000] 内的整数;

数组 A 每个元素是取值范围 [−1..N-1] 内的整数 ;

输入数据总是保证有解，并且结果数列的长度有限。.

本题仅针对解法的正确性进行评测；解法的时间和空间复杂度并不在评测范围内。

给定一个起始下标为 0 的非空数组 A 用来表示一个链表结构，这个链表遵循如下构造：

链表头（第一个节点）是数组中下标为 0 的元素；

下标为 K 的节点的值为 A[K]；

对于数组中下标为 K 的节点，其下一个节点的下标为 A[K]；

如果一个节点的值为−1，则这个节点是链表的最后一个节点。

例如，对于如下的数组A：

A[0] = 1 A[1] = 4 A[2] = -1 A[3] = 3 A[4] = 2

其对应的链表构造如下：

第一个节点（链表头）的数组下标为 0，其值为 1；

第二个节点的数组下标为 1，其值为 4；

第三个节点的数组下标为 4，其值为 2；

第四个节点的数组下标为 2，其值为 −1；

实现一个函数

function solution(A)

对于给定的起始下标为 0、包含 N 个整数的非空数组A，返回按照上述规则所构造的链表的长度。

例如，给出如下的数组A：

A[0] = 1 A[1] = 4 A[2] = -1 A[3] = 3 A[4] = 2

如上述例子所示，该函数应当返回 4 。

假定:

N 是 [1..200,000] 内的整数;

数组 A 每个元素是取值范围 [−1..N-1] 内的整数 ;

输入数据总是保证有解，并且结果数列的长度有限。.

本题仅针对解法的正确性进行评测；解法的时间和空间复杂度并不在评测范围内。

给定一个起始下标为 0 的非空数组 A 用来表示一个链表结构，这个链表遵循如下构造：

链表头（第一个节点）是数组中下标为 0 的元素；

下标为 K 的节点的值为 A[K]；

对于数组中下标为 K 的节点，其下一个节点的下标为 A[K]；

如果一个节点的值为−1，则这个节点是链表的最后一个节点。

例如，对于如下的数组A：

A[0] = 1 A[1] = 4 A[2] = -1 A[3] = 3 A[4] = 2

其对应的链表构造如下：

第一个节点（链表头）的数组下标为 0，其值为 1；

第二个节点的数组下标为 1，其值为 4；

第三个节点的数组下标为 4，其值为 2；

第四个节点的数组下标为 2，其值为 −1；

实现一个函数

int solution(NSMutableArray *A);

对于给定的起始下标为 0、包含 N 个整数的非空数组A，返回按照上述规则所构造的链表的长度。

例如，给出如下的数组A：

A[0] = 1 A[1] = 4 A[2] = -1 A[3] = 3 A[4] = 2

如上述例子所示，该函数应当返回 4 。

假定:

N 是 [1..200,000] 内的整数;

数组 A 每个元素是取值范围 [−1..N-1] 内的整数 ;

输入数据总是保证有解，并且结果数列的长度有限。.

本题仅针对解法的正确性进行评测；解法的时间和空间复杂度并不在评测范围内。

给定一个起始下标为 0 的非空数组 A 用来表示一个链表结构，这个链表遵循如下构造：

链表头（第一个节点）是数组中下标为 0 的元素；

下标为 K 的节点的值为 A[K]；

对于数组中下标为 K 的节点，其下一个节点的下标为 A[K]；

如果一个节点的值为−1，则这个节点是链表的最后一个节点。

例如，对于如下的数组A：

A[0] = 1 A[1] = 4 A[2] = -1 A[3] = 3 A[4] = 2

其对应的链表构造如下：

第一个节点（链表头）的数组下标为 0，其值为 1；

第二个节点的数组下标为 1，其值为 4；

第三个节点的数组下标为 4，其值为 2；

第四个节点的数组下标为 2，其值为 −1；

实现一个函数

function solution(A: array of longint; N: longint): longint;

对于给定的起始下标为 0、包含 N 个整数的非空数组A，返回按照上述规则所构造的链表的长度。

例如，给出如下的数组A：

A[0] = 1 A[1] = 4 A[2] = -1 A[3] = 3 A[4] = 2

如上述例子所示，该函数应当返回 4 。

假定:

N 是 [1..200,000] 内的整数;

数组 A 每个元素是取值范围 [−1..N-1] 内的整数 ;

输入数据总是保证有解，并且结果数列的长度有限。.

本题仅针对解法的正确性进行评测；解法的时间和空间复杂度并不在评测范围内。

给定一个起始下标为 0 的非空数组 A 用来表示一个链表结构，这个链表遵循如下构造：

链表头（第一个节点）是数组中下标为 0 的元素；

下标为 K 的节点的值为 A[K]；

对于数组中下标为 K 的节点，其下一个节点的下标为 A[K]；

如果一个节点的值为−1，则这个节点是链表的最后一个节点。

例如，对于如下的数组A：

A[0] = 1 A[1] = 4 A[2] = -1 A[3] = 3 A[4] = 2

其对应的链表构造如下：

第一个节点（链表头）的数组下标为 0，其值为 1；

第二个节点的数组下标为 1，其值为 4；

第三个节点的数组下标为 4，其值为 2；

第四个节点的数组下标为 2，其值为 −1；

实现一个函数

function solution($A);

对于给定的起始下标为 0、包含 N 个整数的非空数组A，返回按照上述规则所构造的链表的长度。

例如，给出如下的数组A：

A[0] = 1 A[1] = 4 A[2] = -1 A[3] = 3 A[4] = 2

如上述例子所示，该函数应当返回 4 。

假定:

N 是 [1..200,000] 内的整数;

数组 A 每个元素是取值范围 [−1..N-1] 内的整数 ;

输入数据总是保证有解，并且结果数列的长度有限。.

本题仅针对解法的正确性进行评测；解法的时间和空间复杂度并不在评测范围内。

给定一个起始下标为 0 的非空数组 A 用来表示一个链表结构，这个链表遵循如下构造：

链表头（第一个节点）是数组中下标为 0 的元素；

下标为 K 的节点的值为 A[K]；

对于数组中下标为 K 的节点，其下一个节点的下标为 A[K]；

如果一个节点的值为−1，则这个节点是链表的最后一个节点。

例如，对于如下的数组A：

A[0] = 1 A[1] = 4 A[2] = -1 A[3] = 3 A[4] = 2

其对应的链表构造如下：

第一个节点（链表头）的数组下标为 0，其值为 1；

第二个节点的数组下标为 1，其值为 4；

第三个节点的数组下标为 4，其值为 2；

第四个节点的数组下标为 2，其值为 −1；

实现一个函数

sub solution { my (@A) = @_; ... }

对于给定的起始下标为 0、包含 N 个整数的非空数组A，返回按照上述规则所构造的链表的长度。

例如，给出如下的数组A：

A[0] = 1 A[1] = 4 A[2] = -1 A[3] = 3 A[4] = 2

如上述例子所示，该函数应当返回 4 。

假定:

N 是 [1..200,000] 内的整数;

数组 A 每个元素是取值范围 [−1..N-1] 内的整数 ;

输入数据总是保证有解，并且结果数列的长度有限。.

本题仅针对解法的正确性进行评测；解法的时间和空间复杂度并不在评测范围内。

给定一个起始下标为 0 的非空数组 A 用来表示一个链表结构，这个链表遵循如下构造：

链表头（第一个节点）是数组中下标为 0 的元素；

下标为 K 的节点的值为 A[K]；

对于数组中下标为 K 的节点，其下一个节点的下标为 A[K]；

如果一个节点的值为−1，则这个节点是链表的最后一个节点。

例如，对于如下的数组A：

A[0] = 1 A[1] = 4 A[2] = -1 A[3] = 3 A[4] = 2

其对应的链表构造如下：

第一个节点（链表头）的数组下标为 0，其值为 1；

第二个节点的数组下标为 1，其值为 4；

第三个节点的数组下标为 4，其值为 2；

第四个节点的数组下标为 2，其值为 −1；

实现一个函数

def solution(A)

对于给定的起始下标为 0、包含 N 个整数的非空数组A，返回按照上述规则所构造的链表的长度。

例如，给出如下的数组A：

A[0] = 1 A[1] = 4 A[2] = -1 A[3] = 3 A[4] = 2

如上述例子所示，该函数应当返回 4 。

假定:

N 是 [1..200,000] 内的整数;

数组 A 每个元素是取值范围 [−1..N-1] 内的整数 ;

输入数据总是保证有解，并且结果数列的长度有限。.

本题仅针对解法的正确性进行评测；解法的时间和空间复杂度并不在评测范围内。

给定一个起始下标为 0 的非空数组 A 用来表示一个链表结构，这个链表遵循如下构造：

链表头（第一个节点）是数组中下标为 0 的元素；

下标为 K 的节点的值为 A[K]；

对于数组中下标为 K 的节点，其下一个节点的下标为 A[K]；

如果一个节点的值为−1，则这个节点是链表的最后一个节点。

例如，对于如下的数组A：

A[0] = 1 A[1] = 4 A[2] = -1 A[3] = 3 A[4] = 2

其对应的链表构造如下：

第一个节点（链表头）的数组下标为 0，其值为 1；

第二个节点的数组下标为 1，其值为 4；

第三个节点的数组下标为 4，其值为 2；

第四个节点的数组下标为 2，其值为 −1；

实现一个函数

def solution(a)

对于给定的起始下标为 0、包含 N 个整数的非空数组A，返回按照上述规则所构造的链表的长度。

例如，给出如下的数组A：

A[0] = 1 A[1] = 4 A[2] = -1 A[3] = 3 A[4] = 2

如上述例子所示，该函数应当返回 4 。

假定:

N 是 [1..200,000] 内的整数;

数组 A 每个元素是取值范围 [−1..N-1] 内的整数 ;

输入数据总是保证有解，并且结果数列的长度有限。.

本题仅针对解法的正确性进行评测；解法的时间和空间复杂度并不在评测范围内。

给定一个起始下标为 0 的非空数组 A 用来表示一个链表结构，这个链表遵循如下构造：

链表头（第一个节点）是数组中下标为 0 的元素；

下标为 K 的节点的值为 A[K]；

对于数组中下标为 K 的节点，其下一个节点的下标为 A[K]；

如果一个节点的值为−1，则这个节点是链表的最后一个节点。

例如，对于如下的数组A：

A[0] = 1 A[1] = 4 A[2] = -1 A[3] = 3 A[4] = 2

其对应的链表构造如下：

第一个节点（链表头）的数组下标为 0，其值为 1；

第二个节点的数组下标为 1，其值为 4；

第三个节点的数组下标为 4，其值为 2；

第四个节点的数组下标为 2，其值为 −1；

实现一个函数

object Solution { def solution(a: Array[Int]): Int }

对于给定的起始下标为 0、包含 N 个整数的非空数组A，返回按照上述规则所构造的链表的长度。

例如，给出如下的数组A：

A[0] = 1 A[1] = 4 A[2] = -1 A[3] = 3 A[4] = 2

如上述例子所示，该函数应当返回 4 。

假定:

N 是 [1..200,000] 内的整数;

数组 A 每个元素是取值范围 [−1..N-1] 内的整数 ;

输入数据总是保证有解，并且结果数列的长度有限。.

本题仅针对解法的正确性进行评测；解法的时间和空间复杂度并不在评测范围内。

给定一个起始下标为 0 的非空数组 A 用来表示一个链表结构，这个链表遵循如下构造：

链表头（第一个节点）是数组中下标为 0 的元素；

下标为 K 的节点的值为 A[K]；

对于数组中下标为 K 的节点，其下一个节点的下标为 A[K]；

如果一个节点的值为−1，则这个节点是链表的最后一个节点。

例如，对于如下的数组A：

A[0] = 1 A[1] = 4 A[2] = -1 A[3] = 3 A[4] = 2

其对应的链表构造如下：

第一个节点（链表头）的数组下标为 0，其值为 1；

第二个节点的数组下标为 1，其值为 4；

第三个节点的数组下标为 4，其值为 2；

第四个节点的数组下标为 2，其值为 −1；

实现一个函数

public func solution(_ A : inout [Int]) -> Int

对于给定的起始下标为 0、包含 N 个整数的非空数组A，返回按照上述规则所构造的链表的长度。

例如，给出如下的数组A：

A[0] = 1 A[1] = 4 A[2] = -1 A[3] = 3 A[4] = 2

如上述例子所示，该函数应当返回 4 。

假定:

N 是 [1..200,000] 内的整数;

数组 A 每个元素是取值范围 [−1..N-1] 内的整数 ;

输入数据总是保证有解，并且结果数列的长度有限。.

本题仅针对解法的正确性进行评测；解法的时间和空间复杂度并不在评测范围内。

给定一个起始下标为 0 的非空数组 A 用来表示一个链表结构，这个链表遵循如下构造：

链表头（第一个节点）是数组中下标为 0 的元素；

下标为 K 的节点的值为 A[K]；

对于数组中下标为 K 的节点，其下一个节点的下标为 A[K]；

如果一个节点的值为−1，则这个节点是链表的最后一个节点。

例如，对于如下的数组A：

A[0] = 1 A[1] = 4 A[2] = -1 A[3] = 3 A[4] = 2

其对应的链表构造如下：

第一个节点（链表头）的数组下标为 0，其值为 1；

第二个节点的数组下标为 1，其值为 4；

第三个节点的数组下标为 4，其值为 2；

第四个节点的数组下标为 2，其值为 −1；

实现一个函数

function solution(A: number[]): number;

对于给定的起始下标为 0、包含 N 个整数的非空数组A，返回按照上述规则所构造的链表的长度。

例如，给出如下的数组A：

A[0] = 1 A[1] = 4 A[2] = -1 A[3] = 3 A[4] = 2

如上述例子所示，该函数应当返回 4 。

假定:

N 是 [1..200,000] 内的整数;

数组 A 每个元素是取值范围 [−1..N-1] 内的整数 ;

输入数据总是保证有解，并且结果数列的长度有限。.

本题仅针对解法的正确性进行评测；解法的时间和空间复杂度并不在评测范围内。

给定一个起始下标为 0 的非空数组 A 用来表示一个链表结构，这个链表遵循如下构造：

链表头（第一个节点）是数组中下标为 0 的元素；

下标为 K 的节点的值为 A[K]；

对于数组中下标为 K 的节点，其下一个节点的下标为 A[K]；

如果一个节点的值为−1，则这个节点是链表的最后一个节点。

例如，对于如下的数组A：

A[0] = 1 A[1] = 4 A[2] = -1 A[3] = 3 A[4] = 2

其对应的链表构造如下：

第一个节点（链表头）的数组下标为 0，其值为 1；

第二个节点的数组下标为 1，其值为 4；

第三个节点的数组下标为 4，其值为 2；

第四个节点的数组下标为 2，其值为 −1；

实现一个函数

Private Function solution(A As Integer()) As Integer

对于给定的起始下标为 0、包含 N 个整数的非空数组A，返回按照上述规则所构造的链表的长度。

例如，给出如下的数组A：

A[0] = 1 A[1] = 4 A[2] = -1 A[3] = 3 A[4] = 2

如上述例子所示，该函数应当返回 4 。

假定:

N 是 [1..200,000] 内的整数;

数组 A 每个元素是取值范围 [−1..N-1] 内的整数 ;

输入数据总是保证有解，并且结果数列的长度有限。.

本题仅针对解法的正确性进行评测；解法的时间和空间复杂度并不在评测范围内。

A non-empty array A consisting of N integers is given.

Array A represents a linked list. A list is constructed from this array as follows:

the first node (the head) is located at index 0;

the value of a node located at index K is A[K];

if the value of a node is −1 then it is the last node of the list;

otherwise, the successor of a node located at index K is located at index A[K] (you can assume that A[K] is a valid index, that is 0 ≤ A[K] < N).

For example, for array A such that:

A[0] = 1 A[1] = 4 A[2] = -1 A[3] = 3 A[4] = 2

the following list is constructed:

the first node (the head) is located at index 0 and has a value of 1;

the second node is located at index 1 and has a value of 4;

the third node is located at index 4 and has a value of 2;

the fourth node is located at index 2 and has a value of −1.

Write a function:

int solution(int A[], int N);

that, given a non-empty array A consisting of N integers, returns the length of the list constructed from A in the above manner.

For example, given array A such that:

A[0] = 1 A[1] = 4 A[2] = -1 A[3] = 3 A[4] = 2

the function should return 4, as explained in the example above.

Assume that:

N is an integer within the range [1..200,000];

each element of array A is an integer within the range [−1..N-1];

it will always be possible to construct the list and its length will be finite.

In your solution, focus on correctness. The performance of your solution will not be the focus of the assessment.

A non-empty array A consisting of N integers is given.

Array A represents a linked list. A list is constructed from this array as follows:

the first node (the head) is located at index 0;

the value of a node located at index K is A[K];

if the value of a node is −1 then it is the last node of the list;

otherwise, the successor of a node located at index K is located at index A[K] (you can assume that A[K] is a valid index, that is 0 ≤ A[K] < N).

For example, for array A such that:

A[0] = 1 A[1] = 4 A[2] = -1 A[3] = 3 A[4] = 2

the following list is constructed:

the first node (the head) is located at index 0 and has a value of 1;

the second node is located at index 1 and has a value of 4;

the third node is located at index 4 and has a value of 2;

the fourth node is located at index 2 and has a value of −1.

Write a function:

int solution(vector<int> &A);

that, given a non-empty array A consisting of N integers, returns the length of the list constructed from A in the above manner.

For example, given array A such that:

A[0] = 1 A[1] = 4 A[2] = -1 A[3] = 3 A[4] = 2

the function should return 4, as explained in the example above.

Assume that:

N is an integer within the range [1..200,000];

each element of array A is an integer within the range [−1..N-1];

it will always be possible to construct the list and its length will be finite.

In your solution, focus on correctness. The performance of your solution will not be the focus of the assessment.

A non-empty array A consisting of N integers is given.

Array A represents a linked list. A list is constructed from this array as follows:

the first node (the head) is located at index 0;

the value of a node located at index K is A[K];

if the value of a node is −1 then it is the last node of the list;

otherwise, the successor of a node located at index K is located at index A[K] (you can assume that A[K] is a valid index, that is 0 ≤ A[K] < N).

For example, for array A such that:

A[0] = 1 A[1] = 4 A[2] = -1 A[3] = 3 A[4] = 2

the following list is constructed:

the first node (the head) is located at index 0 and has a value of 1;

the second node is located at index 1 and has a value of 4;

the third node is located at index 4 and has a value of 2;

the fourth node is located at index 2 and has a value of −1.

Write a function:

int solution(vector<int> &A);

that, given a non-empty array A consisting of N integers, returns the length of the list constructed from A in the above manner.

For example, given array A such that:

A[0] = 1 A[1] = 4 A[2] = -1 A[3] = 3 A[4] = 2

the function should return 4, as explained in the example above.

Assume that:

N is an integer within the range [1..200,000];

each element of array A is an integer within the range [−1..N-1];

it will always be possible to construct the list and its length will be finite.

In your solution, focus on correctness. The performance of your solution will not be the focus of the assessment.

A non-empty array A consisting of N integers is given.

Array A represents a linked list. A list is constructed from this array as follows:

the first node (the head) is located at index 0;

the value of a node located at index K is A[K];

if the value of a node is −1 then it is the last node of the list;

otherwise, the successor of a node located at index K is located at index A[K] (you can assume that A[K] is a valid index, that is 0 ≤ A[K] < N).

For example, for array A such that:

A[0] = 1 A[1] = 4 A[2] = -1 A[3] = 3 A[4] = 2

the following list is constructed:

the first node (the head) is located at index 0 and has a value of 1;

the second node is located at index 1 and has a value of 4;

the third node is located at index 4 and has a value of 2;

the fourth node is located at index 2 and has a value of −1.

Write a function:

class Solution { public int solution(int[] A); }

that, given a non-empty array A consisting of N integers, returns the length of the list constructed from A in the above manner.

For example, given array A such that:

A[0] = 1 A[1] = 4 A[2] = -1 A[3] = 3 A[4] = 2

the function should return 4, as explained in the example above.

Assume that:

N is an integer within the range [1..200,000];

each element of array A is an integer within the range [−1..N-1];

it will always be possible to construct the list and its length will be finite.

In your solution, focus on correctness. The performance of your solution will not be the focus of the assessment.

A non-empty array A consisting of N integers is given.

Array A represents a linked list. A list is constructed from this array as follows:

the first node (the head) is located at index 0;

the value of a node located at index K is A[K];

if the value of a node is −1 then it is the last node of the list;

otherwise, the successor of a node located at index K is located at index A[K] (you can assume that A[K] is a valid index, that is 0 ≤ A[K] < N).

For example, for array A such that:

A[0] = 1 A[1] = 4 A[2] = -1 A[3] = 3 A[4] = 2

the following list is constructed:

the first node (the head) is located at index 0 and has a value of 1;

the second node is located at index 1 and has a value of 4;

the third node is located at index 4 and has a value of 2;

the fourth node is located at index 2 and has a value of −1.

Write a function:

int solution(List<int> A);

that, given a non-empty array A consisting of N integers, returns the length of the list constructed from A in the above manner.

For example, given array A such that:

A[0] = 1 A[1] = 4 A[2] = -1 A[3] = 3 A[4] = 2

the function should return 4, as explained in the example above.

Assume that:

N is an integer within the range [1..200,000];

each element of array A is an integer within the range [−1..N-1];

it will always be possible to construct the list and its length will be finite.

In your solution, focus on correctness. The performance of your solution will not be the focus of the assessment.

A non-empty array A consisting of N integers is given.

Array A represents a linked list. A list is constructed from this array as follows:

the first node (the head) is located at index 0;

the value of a node located at index K is A[K];

if the value of a node is −1 then it is the last node of the list;

otherwise, the successor of a node located at index K is located at index A[K] (you can assume that A[K] is a valid index, that is 0 ≤ A[K] < N).

For example, for array A such that:

A[0] = 1 A[1] = 4 A[2] = -1 A[3] = 3 A[4] = 2

the following list is constructed:

the first node (the head) is located at index 0 and has a value of 1;

the second node is located at index 1 and has a value of 4;

the third node is located at index 4 and has a value of 2;

the fourth node is located at index 2 and has a value of −1.

Write a function:

func Solution(A []int) int

that, given a non-empty array A consisting of N integers, returns the length of the list constructed from A in the above manner.

For example, given array A such that:

A[0] = 1 A[1] = 4 A[2] = -1 A[3] = 3 A[4] = 2

the function should return 4, as explained in the example above.

Assume that:

N is an integer within the range [1..200,000];

each element of array A is an integer within the range [−1..N-1];

it will always be possible to construct the list and its length will be finite.

In your solution, focus on correctness. The performance of your solution will not be the focus of the assessment.

A non-empty array A consisting of N integers is given.

Array A represents a linked list. A list is constructed from this array as follows:

the first node (the head) is located at index 0;

the value of a node located at index K is A[K];

if the value of a node is −1 then it is the last node of the list;

otherwise, the successor of a node located at index K is located at index A[K] (you can assume that A[K] is a valid index, that is 0 ≤ A[K] < N).

For example, for array A such that:

A[0] = 1 A[1] = 4 A[2] = -1 A[3] = 3 A[4] = 2

the following list is constructed:

the first node (the head) is located at index 0 and has a value of 1;

the second node is located at index 1 and has a value of 4;

the third node is located at index 4 and has a value of 2;

the fourth node is located at index 2 and has a value of −1.

Write a function:

class Solution { public int solution(int[] A); }

that, given a non-empty array A consisting of N integers, returns the length of the list constructed from A in the above manner.

For example, given array A such that:

A[0] = 1 A[1] = 4 A[2] = -1 A[3] = 3 A[4] = 2

the function should return 4, as explained in the example above.

Assume that:

N is an integer within the range [1..200,000];

each element of array A is an integer within the range [−1..N-1];

it will always be possible to construct the list and its length will be finite.

In your solution, focus on correctness. The performance of your solution will not be the focus of the assessment.

A non-empty array A consisting of N integers is given.

Array A represents a linked list. A list is constructed from this array as follows:

the first node (the head) is located at index 0;

the value of a node located at index K is A[K];

if the value of a node is −1 then it is the last node of the list;

otherwise, the successor of a node located at index K is located at index A[K] (you can assume that A[K] is a valid index, that is 0 ≤ A[K] < N).

For example, for array A such that:

A[0] = 1 A[1] = 4 A[2] = -1 A[3] = 3 A[4] = 2

the following list is constructed:

the first node (the head) is located at index 0 and has a value of 1;

the second node is located at index 1 and has a value of 4;

the third node is located at index 4 and has a value of 2;

the fourth node is located at index 2 and has a value of −1.

Write a function:

class Solution { public int solution(int[] A); }

that, given a non-empty array A consisting of N integers, returns the length of the list constructed from A in the above manner.

For example, given array A such that:

A[0] = 1 A[1] = 4 A[2] = -1 A[3] = 3 A[4] = 2

the function should return 4, as explained in the example above.

Assume that:

N is an integer within the range [1..200,000];

each element of array A is an integer within the range [−1..N-1];

it will always be possible to construct the list and its length will be finite.

In your solution, focus on correctness. The performance of your solution will not be the focus of the assessment.

A non-empty array A consisting of N integers is given.

Array A represents a linked list. A list is constructed from this array as follows:

the first node (the head) is located at index 0;

the value of a node located at index K is A[K];

if the value of a node is −1 then it is the last node of the list;

otherwise, the successor of a node located at index K is located at index A[K] (you can assume that A[K] is a valid index, that is 0 ≤ A[K] < N).

For example, for array A such that:

A[0] = 1 A[1] = 4 A[2] = -1 A[3] = 3 A[4] = 2

the following list is constructed:

the first node (the head) is located at index 0 and has a value of 1;

the second node is located at index 1 and has a value of 4;

the third node is located at index 4 and has a value of 2;

the fourth node is located at index 2 and has a value of −1.

Write a function:

function solution(A);

that, given a non-empty array A consisting of N integers, returns the length of the list constructed from A in the above manner.

For example, given array A such that:

A[0] = 1 A[1] = 4 A[2] = -1 A[3] = 3 A[4] = 2

the function should return 4, as explained in the example above.

Assume that:

N is an integer within the range [1..200,000];

each element of array A is an integer within the range [−1..N-1];

it will always be possible to construct the list and its length will be finite.

In your solution, focus on correctness. The performance of your solution will not be the focus of the assessment.

A non-empty array A consisting of N integers is given.

Array A represents a linked list. A list is constructed from this array as follows:

the first node (the head) is located at index 0;

the value of a node located at index K is A[K];

if the value of a node is −1 then it is the last node of the list;

otherwise, the successor of a node located at index K is located at index A[K] (you can assume that A[K] is a valid index, that is 0 ≤ A[K] < N).

For example, for array A such that:

A[0] = 1 A[1] = 4 A[2] = -1 A[3] = 3 A[4] = 2

the following list is constructed:

the first node (the head) is located at index 0 and has a value of 1;

the second node is located at index 1 and has a value of 4;

the third node is located at index 4 and has a value of 2;

the fourth node is located at index 2 and has a value of −1.

Write a function:

fun solution(A: IntArray): Int

that, given a non-empty array A consisting of N integers, returns the length of the list constructed from A in the above manner.

For example, given array A such that:

A[0] = 1 A[1] = 4 A[2] = -1 A[3] = 3 A[4] = 2

the function should return 4, as explained in the example above.

Assume that:

N is an integer within the range [1..200,000];

each element of array A is an integer within the range [−1..N-1];

it will always be possible to construct the list and its length will be finite.

In your solution, focus on correctness. The performance of your solution will not be the focus of the assessment.

A non-empty array A consisting of N integers is given.

Array A represents a linked list. A list is constructed from this array as follows:

the first node (the head) is located at index 0;

the value of a node located at index K is A[K];

if the value of a node is −1 then it is the last node of the list;

otherwise, the successor of a node located at index K is located at index A[K] (you can assume that A[K] is a valid index, that is 0 ≤ A[K] < N).

For example, for array A such that:

A[0] = 1 A[1] = 4 A[2] = -1 A[3] = 3 A[4] = 2

the following list is constructed:

the first node (the head) is located at index 0 and has a value of 1;

the second node is located at index 1 and has a value of 4;

the third node is located at index 4 and has a value of 2;

the fourth node is located at index 2 and has a value of −1.

Write a function:

function solution(A)

that, given a non-empty array A consisting of N integers, returns the length of the list constructed from A in the above manner.

For example, given array A such that:

A[0] = 1 A[1] = 4 A[2] = -1 A[3] = 3 A[4] = 2

the function should return 4, as explained in the example above.

Assume that:

N is an integer within the range [1..200,000];

each element of array A is an integer within the range [−1..N-1];

it will always be possible to construct the list and its length will be finite.

In your solution, focus on correctness. The performance of your solution will not be the focus of the assessment.

Note: All arrays in this task are zero-indexed, unlike the common Lua convention. You can use #A to get the length of the array A.

A non-empty array A consisting of N integers is given.

Array A represents a linked list. A list is constructed from this array as follows:

the first node (the head) is located at index 0;

the value of a node located at index K is A[K];

if the value of a node is −1 then it is the last node of the list;

otherwise, the successor of a node located at index K is located at index A[K] (you can assume that A[K] is a valid index, that is 0 ≤ A[K] < N).

For example, for array A such that:

A[0] = 1 A[1] = 4 A[2] = -1 A[3] = 3 A[4] = 2

the following list is constructed:

the first node (the head) is located at index 0 and has a value of 1;

the second node is located at index 1 and has a value of 4;

the third node is located at index 4 and has a value of 2;

the fourth node is located at index 2 and has a value of −1.

Write a function:

int solution(NSMutableArray *A);

that, given a non-empty array A consisting of N integers, returns the length of the list constructed from A in the above manner.

For example, given array A such that:

A[0] = 1 A[1] = 4 A[2] = -1 A[3] = 3 A[4] = 2

the function should return 4, as explained in the example above.

Assume that:

N is an integer within the range [1..200,000];

each element of array A is an integer within the range [−1..N-1];

it will always be possible to construct the list and its length will be finite.

In your solution, focus on correctness. The performance of your solution will not be the focus of the assessment.

A non-empty array A consisting of N integers is given.

Array A represents a linked list. A list is constructed from this array as follows:

the first node (the head) is located at index 0;

the value of a node located at index K is A[K];

if the value of a node is −1 then it is the last node of the list;

otherwise, the successor of a node located at index K is located at index A[K] (you can assume that A[K] is a valid index, that is 0 ≤ A[K] < N).

For example, for array A such that:

A[0] = 1 A[1] = 4 A[2] = -1 A[3] = 3 A[4] = 2

the following list is constructed:

the first node (the head) is located at index 0 and has a value of 1;

the second node is located at index 1 and has a value of 4;

the third node is located at index 4 and has a value of 2;

the fourth node is located at index 2 and has a value of −1.

Write a function:

function solution(A: array of longint; N: longint): longint;

that, given a non-empty array A consisting of N integers, returns the length of the list constructed from A in the above manner.

For example, given array A such that:

A[0] = 1 A[1] = 4 A[2] = -1 A[3] = 3 A[4] = 2

the function should return 4, as explained in the example above.

Assume that:

N is an integer within the range [1..200,000];

each element of array A is an integer within the range [−1..N-1];

it will always be possible to construct the list and its length will be finite.

In your solution, focus on correctness. The performance of your solution will not be the focus of the assessment.

A non-empty array A consisting of N integers is given.

Array A represents a linked list. A list is constructed from this array as follows:

the first node (the head) is located at index 0;

the value of a node located at index K is A[K];

if the value of a node is −1 then it is the last node of the list;

otherwise, the successor of a node located at index K is located at index A[K] (you can assume that A[K] is a valid index, that is 0 ≤ A[K] < N).

For example, for array A such that:

A[0] = 1 A[1] = 4 A[2] = -1 A[3] = 3 A[4] = 2

the following list is constructed:

the first node (the head) is located at index 0 and has a value of 1;

the second node is located at index 1 and has a value of 4;

the third node is located at index 4 and has a value of 2;

the fourth node is located at index 2 and has a value of −1.

Write a function:

function solution($A);

that, given a non-empty array A consisting of N integers, returns the length of the list constructed from A in the above manner.

For example, given array A such that:

A[0] = 1 A[1] = 4 A[2] = -1 A[3] = 3 A[4] = 2

the function should return 4, as explained in the example above.

Assume that:

N is an integer within the range [1..200,000];

each element of array A is an integer within the range [−1..N-1];

it will always be possible to construct the list and its length will be finite.

In your solution, focus on correctness. The performance of your solution will not be the focus of the assessment.

A non-empty array A consisting of N integers is given.

Array A represents a linked list. A list is constructed from this array as follows:

the first node (the head) is located at index 0;

the value of a node located at index K is A[K];

if the value of a node is −1 then it is the last node of the list;

otherwise, the successor of a node located at index K is located at index A[K] (you can assume that A[K] is a valid index, that is 0 ≤ A[K] < N).

For example, for array A such that:

A[0] = 1 A[1] = 4 A[2] = -1 A[3] = 3 A[4] = 2

the following list is constructed:

the first node (the head) is located at index 0 and has a value of 1;

the second node is located at index 1 and has a value of 4;

the third node is located at index 4 and has a value of 2;

the fourth node is located at index 2 and has a value of −1.

Write a function:

sub solution { my (@A) = @_; ... }

that, given a non-empty array A consisting of N integers, returns the length of the list constructed from A in the above manner.

For example, given array A such that:

A[0] = 1 A[1] = 4 A[2] = -1 A[3] = 3 A[4] = 2

the function should return 4, as explained in the example above.

Assume that:

N is an integer within the range [1..200,000];

each element of array A is an integer within the range [−1..N-1];

it will always be possible to construct the list and its length will be finite.

In your solution, focus on correctness. The performance of your solution will not be the focus of the assessment.

A non-empty array A consisting of N integers is given.

Array A represents a linked list. A list is constructed from this array as follows:

the first node (the head) is located at index 0;

the value of a node located at index K is A[K];

if the value of a node is −1 then it is the last node of the list;

otherwise, the successor of a node located at index K is located at index A[K] (you can assume that A[K] is a valid index, that is 0 ≤ A[K] < N).

For example, for array A such that:

A[0] = 1 A[1] = 4 A[2] = -1 A[3] = 3 A[4] = 2

the following list is constructed:

the first node (the head) is located at index 0 and has a value of 1;

the second node is located at index 1 and has a value of 4;

the third node is located at index 4 and has a value of 2;

the fourth node is located at index 2 and has a value of −1.

Write a function:

def solution(A)

that, given a non-empty array A consisting of N integers, returns the length of the list constructed from A in the above manner.

For example, given array A such that:

A[0] = 1 A[1] = 4 A[2] = -1 A[3] = 3 A[4] = 2

the function should return 4, as explained in the example above.

Assume that:

N is an integer within the range [1..200,000];

each element of array A is an integer within the range [−1..N-1];

it will always be possible to construct the list and its length will be finite.

In your solution, focus on correctness. The performance of your solution will not be the focus of the assessment.

A non-empty array A consisting of N integers is given.

Array A represents a linked list. A list is constructed from this array as follows:

the first node (the head) is located at index 0;

the value of a node located at index K is A[K];

if the value of a node is −1 then it is the last node of the list;

otherwise, the successor of a node located at index K is located at index A[K] (you can assume that A[K] is a valid index, that is 0 ≤ A[K] < N).

For example, for array A such that:

A[0] = 1 A[1] = 4 A[2] = -1 A[3] = 3 A[4] = 2

the following list is constructed:

the first node (the head) is located at index 0 and has a value of 1;

the second node is located at index 1 and has a value of 4;

the third node is located at index 4 and has a value of 2;

the fourth node is located at index 2 and has a value of −1.

Write a function:

def solution(a)

that, given a non-empty array A consisting of N integers, returns the length of the list constructed from A in the above manner.

For example, given array A such that:

A[0] = 1 A[1] = 4 A[2] = -1 A[3] = 3 A[4] = 2

the function should return 4, as explained in the example above.

Assume that:

N is an integer within the range [1..200,000];

each element of array A is an integer within the range [−1..N-1];

it will always be possible to construct the list and its length will be finite.

In your solution, focus on correctness. The performance of your solution will not be the focus of the assessment.

A non-empty array A consisting of N integers is given.

Array A represents a linked list. A list is constructed from this array as follows:

the first node (the head) is located at index 0;

the value of a node located at index K is A[K];

if the value of a node is −1 then it is the last node of the list;

otherwise, the successor of a node located at index K is located at index A[K] (you can assume that A[K] is a valid index, that is 0 ≤ A[K] < N).

For example, for array A such that:

A[0] = 1 A[1] = 4 A[2] = -1 A[3] = 3 A[4] = 2

the following list is constructed:

the first node (the head) is located at index 0 and has a value of 1;

the second node is located at index 1 and has a value of 4;

the third node is located at index 4 and has a value of 2;

the fourth node is located at index 2 and has a value of −1.

Write a function:

object Solution { def solution(a: Array[Int]): Int }

that, given a non-empty array A consisting of N integers, returns the length of the list constructed from A in the above manner.

For example, given array A such that:

A[0] = 1 A[1] = 4 A[2] = -1 A[3] = 3 A[4] = 2

the function should return 4, as explained in the example above.

Assume that:

N is an integer within the range [1..200,000];

each element of array A is an integer within the range [−1..N-1];

it will always be possible to construct the list and its length will be finite.

In your solution, focus on correctness. The performance of your solution will not be the focus of the assessment.

A non-empty array A consisting of N integers is given.

Array A represents a linked list. A list is constructed from this array as follows:

the first node (the head) is located at index 0;

the value of a node located at index K is A[K];

if the value of a node is −1 then it is the last node of the list;

otherwise, the successor of a node located at index K is located at index A[K] (you can assume that A[K] is a valid index, that is 0 ≤ A[K] < N).

For example, for array A such that:

A[0] = 1 A[1] = 4 A[2] = -1 A[3] = 3 A[4] = 2

the following list is constructed:

the first node (the head) is located at index 0 and has a value of 1;

the second node is located at index 1 and has a value of 4;

the third node is located at index 4 and has a value of 2;

the fourth node is located at index 2 and has a value of −1.

Write a function:

public func solution(_ A : inout [Int]) -> Int

that, given a non-empty array A consisting of N integers, returns the length of the list constructed from A in the above manner.

For example, given array A such that:

A[0] = 1 A[1] = 4 A[2] = -1 A[3] = 3 A[4] = 2

the function should return 4, as explained in the example above.

Assume that:

N is an integer within the range [1..200,000];

each element of array A is an integer within the range [−1..N-1];

it will always be possible to construct the list and its length will be finite.

In your solution, focus on correctness. The performance of your solution will not be the focus of the assessment.

A non-empty array A consisting of N integers is given.

Array A represents a linked list. A list is constructed from this array as follows:

the first node (the head) is located at index 0;

the value of a node located at index K is A[K];

if the value of a node is −1 then it is the last node of the list;

otherwise, the successor of a node located at index K is located at index A[K] (you can assume that A[K] is a valid index, that is 0 ≤ A[K] < N).

For example, for array A such that:

A[0] = 1 A[1] = 4 A[2] = -1 A[3] = 3 A[4] = 2

the following list is constructed:

the first node (the head) is located at index 0 and has a value of 1;

the second node is located at index 1 and has a value of 4;

the third node is located at index 4 and has a value of 2;

the fourth node is located at index 2 and has a value of −1.

Write a function:

function solution(A: number[]): number;

that, given a non-empty array A consisting of N integers, returns the length of the list constructed from A in the above manner.

For example, given array A such that:

A[0] = 1 A[1] = 4 A[2] = -1 A[3] = 3 A[4] = 2

the function should return 4, as explained in the example above.

Assume that:

N is an integer within the range [1..200,000];

each element of array A is an integer within the range [−1..N-1];

it will always be possible to construct the list and its length will be finite.

In your solution, focus on correctness. The performance of your solution will not be the focus of the assessment.

A non-empty array A consisting of N integers is given.

Array A represents a linked list. A list is constructed from this array as follows:

the first node (the head) is located at index 0;

the value of a node located at index K is A[K];

if the value of a node is −1 then it is the last node of the list;

otherwise, the successor of a node located at index K is located at index A[K] (you can assume that A[K] is a valid index, that is 0 ≤ A[K] < N).

For example, for array A such that:

A[0] = 1 A[1] = 4 A[2] = -1 A[3] = 3 A[4] = 2

the following list is constructed:

the first node (the head) is located at index 0 and has a value of 1;

the second node is located at index 1 and has a value of 4;

the third node is located at index 4 and has a value of 2;

the fourth node is located at index 2 and has a value of −1.

Write a function:

Private Function solution(A As Integer()) As Integer

that, given a non-empty array A consisting of N integers, returns the length of the list constructed from A in the above manner.

For example, given array A such that:

A[0] = 1 A[1] = 4 A[2] = -1 A[3] = 3 A[4] = 2

the function should return 4, as explained in the example above.

Assume that:

N is an integer within the range [1..200,000];

each element of array A is an integer within the range [−1..N-1];

it will always be possible to construct the list and its length will be finite.

In your solution, focus on correctness. The performance of your solution will not be the focus of the assessment.

N個の整数からなる空ではない0から始まる配列Aが与えられる。

配列Aとは、Linked listであり、与えられた配列から下記のようにして構成される。

最初のノード（head）のインデックスは、0である。

インデックスがKのノードの値とは、A[K]である。

ノードの値が−1の場合、そのノードはリストの最後のノードである。

それ以外の場合、インデックスがKのノードの次のノードのインデックスはA[K]（A[K]は有効なインデックスであると仮定してよい、すなわち0≤A[K] <N）。

たとえば、次のような配列Aを考える：

A[0] = 1 A[1] = 4 A[2] = -1 A[3] = 3 A[4] = 2

配列Aから以下のリストが構成される。

最初のノード（head）はindex0に位置し、1の値を持つ。

第2のノードは、index1に位置し、4の値を持つ。

第3のノードは、index4に位置し、2の値を持つ。

第4のノードは、index2に位置し、−1の値を持つ。

以下の関数を書きなさい：

int solution(int A[], int N);

ただし、Aは非空の0から始まる配列であり、その要素数はNである。返り値はAによって構成されるリストの長さである。

例えば、次の配列Aを考える：

A[0] = 1 A[1] = 4 A[2] = -1 A[3] = 3 A[4] = 2

上の図で説明したとおり、関数は4を返す必要がある。

前提条件：

N は [1..200,000] の範囲の整数とする。

配列 A の各要素は [−1..N-1] の範囲の整数とする。

リストを構成することは必ず可能であり、その長さは有限である。

尚、解答にあたっては、正確さを重視してください。あなたの解答のパフォーマンスは、評価の対象にはなりません。

N個の整数からなる空ではない0から始まる配列Aが与えられる。

配列Aとは、Linked listであり、与えられた配列から下記のようにして構成される。

最初のノード（head）のインデックスは、0である。

インデックスがKのノードの値とは、A[K]である。

ノードの値が−1の場合、そのノードはリストの最後のノードである。

それ以外の場合、インデックスがKのノードの次のノードのインデックスはA[K]（A[K]は有効なインデックスであると仮定してよい、すなわち0≤A[K] <N）。

たとえば、次のような配列Aを考える：

A[0] = 1 A[1] = 4 A[2] = -1 A[3] = 3 A[4] = 2

配列Aから以下のリストが構成される。

最初のノード（head）はindex0に位置し、1の値を持つ。

第2のノードは、index1に位置し、4の値を持つ。

第3のノードは、index4に位置し、2の値を持つ。

第4のノードは、index2に位置し、−1の値を持つ。

以下の関数を書きなさい：

int solution(vector<int> &A);

ただし、Aは非空の0から始まる配列であり、その要素数はNである。返り値はAによって構成されるリストの長さである。

例えば、次の配列Aを考える：

A[0] = 1 A[1] = 4 A[2] = -1 A[3] = 3 A[4] = 2

上の図で説明したとおり、関数は4を返す必要がある。

前提条件：

N は [1..200,000] の範囲の整数とする。

配列 A の各要素は [−1..N-1] の範囲の整数とする。

リストを構成することは必ず可能であり、その長さは有限である。

尚、解答にあたっては、正確さを重視してください。あなたの解答のパフォーマンスは、評価の対象にはなりません。

N個の整数からなる空ではない0から始まる配列Aが与えられる。

配列Aとは、Linked listであり、与えられた配列から下記のようにして構成される。

最初のノード（head）のインデックスは、0である。

インデックスがKのノードの値とは、A[K]である。

ノードの値が−1の場合、そのノードはリストの最後のノードである。

それ以外の場合、インデックスがKのノードの次のノードのインデックスはA[K]（A[K]は有効なインデックスであると仮定してよい、すなわち0≤A[K] <N）。

たとえば、次のような配列Aを考える：

A[0] = 1 A[1] = 4 A[2] = -1 A[3] = 3 A[4] = 2

配列Aから以下のリストが構成される。

最初のノード（head）はindex0に位置し、1の値を持つ。

第2のノードは、index1に位置し、4の値を持つ。

第3のノードは、index4に位置し、2の値を持つ。

第4のノードは、index2に位置し、−1の値を持つ。

以下の関数を書きなさい：

int solution(vector<int> &A);

ただし、Aは非空の0から始まる配列であり、その要素数はNである。返り値はAによって構成されるリストの長さである。

例えば、次の配列Aを考える：

A[0] = 1 A[1] = 4 A[2] = -1 A[3] = 3 A[4] = 2

上の図で説明したとおり、関数は4を返す必要がある。

前提条件：

N は [1..200,000] の範囲の整数とする。

配列 A の各要素は [−1..N-1] の範囲の整数とする。

リストを構成することは必ず可能であり、その長さは有限である。

尚、解答にあたっては、正確さを重視してください。あなたの解答のパフォーマンスは、評価の対象にはなりません。

N個の整数からなる空ではない0から始まる配列Aが与えられる。

配列Aとは、Linked listであり、与えられた配列から下記のようにして構成される。

最初のノード（head）のインデックスは、0である。

インデックスがKのノードの値とは、A[K]である。

ノードの値が−1の場合、そのノードはリストの最後のノードである。

それ以外の場合、インデックスがKのノードの次のノードのインデックスはA[K]（A[K]は有効なインデックスであると仮定してよい、すなわち0≤A[K] <N）。

たとえば、次のような配列Aを考える：

A[0] = 1 A[1] = 4 A[2] = -1 A[3] = 3 A[4] = 2

配列Aから以下のリストが構成される。

最初のノード（head）はindex0に位置し、1の値を持つ。

第2のノードは、index1に位置し、4の値を持つ。

第3のノードは、index4に位置し、2の値を持つ。

第4のノードは、index2に位置し、−1の値を持つ。

以下の関数を書きなさい：

class Solution { public int solution(int[] A); }

ただし、Aは非空の0から始まる配列であり、その要素数はNである。返り値はAによって構成されるリストの長さである。

例えば、次の配列Aを考える：

A[0] = 1 A[1] = 4 A[2] = -1 A[3] = 3 A[4] = 2

上の図で説明したとおり、関数は4を返す必要がある。

前提条件：

N は [1..200,000] の範囲の整数とする。

配列 A の各要素は [−1..N-1] の範囲の整数とする。

リストを構成することは必ず可能であり、その長さは有限である。

尚、解答にあたっては、正確さを重視してください。あなたの解答のパフォーマンスは、評価の対象にはなりません。

N個の整数からなる空ではない0から始まる配列Aが与えられる。

配列Aとは、Linked listであり、与えられた配列から下記のようにして構成される。

最初のノード（head）のインデックスは、0である。

インデックスがKのノードの値とは、A[K]である。

ノードの値が−1の場合、そのノードはリストの最後のノードである。

それ以外の場合、インデックスがKのノードの次のノードのインデックスはA[K]（A[K]は有効なインデックスであると仮定してよい、すなわち0≤A[K] <N）。

たとえば、次のような配列Aを考える：

A[0] = 1 A[1] = 4 A[2] = -1 A[3] = 3 A[4] = 2

配列Aから以下のリストが構成される。

最初のノード（head）はindex0に位置し、1の値を持つ。

第2のノードは、index1に位置し、4の値を持つ。

第3のノードは、index4に位置し、2の値を持つ。

第4のノードは、index2に位置し、−1の値を持つ。

以下の関数を書きなさい：

int solution(List<int> A);

ただし、Aは非空の0から始まる配列であり、その要素数はNである。返り値はAによって構成されるリストの長さである。

例えば、次の配列Aを考える：

A[0] = 1 A[1] = 4 A[2] = -1 A[3] = 3 A[4] = 2

上の図で説明したとおり、関数は4を返す必要がある。

前提条件：

N は [1..200,000] の範囲の整数とする。

配列 A の各要素は [−1..N-1] の範囲の整数とする。

リストを構成することは必ず可能であり、その長さは有限である。

尚、解答にあたっては、正確さを重視してください。あなたの解答のパフォーマンスは、評価の対象にはなりません。

N個の整数からなる空ではない0から始まる配列Aが与えられる。

配列Aとは、Linked listであり、与えられた配列から下記のようにして構成される。

最初のノード（head）のインデックスは、0である。

インデックスがKのノードの値とは、A[K]である。

ノードの値が−1の場合、そのノードはリストの最後のノードである。

それ以外の場合、インデックスがKのノードの次のノードのインデックスはA[K]（A[K]は有効なインデックスであると仮定してよい、すなわち0≤A[K] <N）。

たとえば、次のような配列Aを考える：

A[0] = 1 A[1] = 4 A[2] = -1 A[3] = 3 A[4] = 2

配列Aから以下のリストが構成される。

最初のノード（head）はindex0に位置し、1の値を持つ。

第2のノードは、index1に位置し、4の値を持つ。

第3のノードは、index4に位置し、2の値を持つ。

第4のノードは、index2に位置し、−1の値を持つ。

以下の関数を書きなさい：

func Solution(A []int) int

ただし、Aは非空の0から始まる配列であり、その要素数はNである。返り値はAによって構成されるリストの長さである。

例えば、次の配列Aを考える：

A[0] = 1 A[1] = 4 A[2] = -1 A[3] = 3 A[4] = 2

上の図で説明したとおり、関数は4を返す必要がある。

前提条件：

N は [1..200,000] の範囲の整数とする。

配列 A の各要素は [−1..N-1] の範囲の整数とする。

リストを構成することは必ず可能であり、その長さは有限である。

尚、解答にあたっては、正確さを重視してください。あなたの解答のパフォーマンスは、評価の対象にはなりません。

N個の整数からなる空ではない0から始まる配列Aが与えられる。

配列Aとは、Linked listであり、与えられた配列から下記のようにして構成される。

最初のノード（head）のインデックスは、0である。

インデックスがKのノードの値とは、A[K]である。

ノードの値が−1の場合、そのノードはリストの最後のノードである。

それ以外の場合、インデックスがKのノードの次のノードのインデックスはA[K]（A[K]は有効なインデックスであると仮定してよい、すなわち0≤A[K] <N）。

たとえば、次のような配列Aを考える：

A[0] = 1 A[1] = 4 A[2] = -1 A[3] = 3 A[4] = 2

配列Aから以下のリストが構成される。

最初のノード（head）はindex0に位置し、1の値を持つ。

第2のノードは、index1に位置し、4の値を持つ。

第3のノードは、index4に位置し、2の値を持つ。

第4のノードは、index2に位置し、−1の値を持つ。

以下の関数を書きなさい：

class Solution { public int solution(int[] A); }

ただし、Aは非空の0から始まる配列であり、その要素数はNである。返り値はAによって構成されるリストの長さである。

例えば、次の配列Aを考える：

A[0] = 1 A[1] = 4 A[2] = -1 A[3] = 3 A[4] = 2

上の図で説明したとおり、関数は4を返す必要がある。

前提条件：

N は [1..200,000] の範囲の整数とする。

配列 A の各要素は [−1..N-1] の範囲の整数とする。

リストを構成することは必ず可能であり、その長さは有限である。

尚、解答にあたっては、正確さを重視してください。あなたの解答のパフォーマンスは、評価の対象にはなりません。

N個の整数からなる空ではない0から始まる配列Aが与えられる。

配列Aとは、Linked listであり、与えられた配列から下記のようにして構成される。

最初のノード（head）のインデックスは、0である。

インデックスがKのノードの値とは、A[K]である。

ノードの値が−1の場合、そのノードはリストの最後のノードである。

それ以外の場合、インデックスがKのノードの次のノードのインデックスはA[K]（A[K]は有効なインデックスであると仮定してよい、すなわち0≤A[K] <N）。

たとえば、次のような配列Aを考える：

A[0] = 1 A[1] = 4 A[2] = -1 A[3] = 3 A[4] = 2

配列Aから以下のリストが構成される。

最初のノード（head）はindex0に位置し、1の値を持つ。

第2のノードは、index1に位置し、4の値を持つ。

第3のノードは、index4に位置し、2の値を持つ。

第4のノードは、index2に位置し、−1の値を持つ。

以下の関数を書きなさい：

class Solution { public int solution(int[] A); }

ただし、Aは非空の0から始まる配列であり、その要素数はNである。返り値はAによって構成されるリストの長さである。

例えば、次の配列Aを考える：

A[0] = 1 A[1] = 4 A[2] = -1 A[3] = 3 A[4] = 2

上の図で説明したとおり、関数は4を返す必要がある。

前提条件：

N は [1..200,000] の範囲の整数とする。

配列 A の各要素は [−1..N-1] の範囲の整数とする。

リストを構成することは必ず可能であり、その長さは有限である。

尚、解答にあたっては、正確さを重視してください。あなたの解答のパフォーマンスは、評価の対象にはなりません。

N個の整数からなる空ではない0から始まる配列Aが与えられる。

配列Aとは、Linked listであり、与えられた配列から下記のようにして構成される。

最初のノード（head）のインデックスは、0である。

インデックスがKのノードの値とは、A[K]である。

ノードの値が−1の場合、そのノードはリストの最後のノードである。

それ以外の場合、インデックスがKのノードの次のノードのインデックスはA[K]（A[K]は有効なインデックスであると仮定してよい、すなわち0≤A[K] <N）。

たとえば、次のような配列Aを考える：

A[0] = 1 A[1] = 4 A[2] = -1 A[3] = 3 A[4] = 2

配列Aから以下のリストが構成される。

最初のノード（head）はindex0に位置し、1の値を持つ。

第2のノードは、index1に位置し、4の値を持つ。

第3のノードは、index4に位置し、2の値を持つ。

第4のノードは、index2に位置し、−1の値を持つ。

以下の関数を書きなさい：

function solution(A);

ただし、Aは非空の0から始まる配列であり、その要素数はNである。返り値はAによって構成されるリストの長さである。

例えば、次の配列Aを考える：

A[0] = 1 A[1] = 4 A[2] = -1 A[3] = 3 A[4] = 2

上の図で説明したとおり、関数は4を返す必要がある。

前提条件：

N は [1..200,000] の範囲の整数とする。

配列 A の各要素は [−1..N-1] の範囲の整数とする。

リストを構成することは必ず可能であり、その長さは有限である。

尚、解答にあたっては、正確さを重視してください。あなたの解答のパフォーマンスは、評価の対象にはなりません。

N個の整数からなる空ではない0から始まる配列Aが与えられる。

配列Aとは、Linked listであり、与えられた配列から下記のようにして構成される。

最初のノード（head）のインデックスは、0である。

インデックスがKのノードの値とは、A[K]である。

ノードの値が−1の場合、そのノードはリストの最後のノードである。

それ以外の場合、インデックスがKのノードの次のノードのインデックスはA[K]（A[K]は有効なインデックスであると仮定してよい、すなわち0≤A[K] <N）。

たとえば、次のような配列Aを考える：

A[0] = 1 A[1] = 4 A[2] = -1 A[3] = 3 A[4] = 2

配列Aから以下のリストが構成される。

最初のノード（head）はindex0に位置し、1の値を持つ。

第2のノードは、index1に位置し、4の値を持つ。

第3のノードは、index4に位置し、2の値を持つ。

第4のノードは、index2に位置し、−1の値を持つ。

以下の関数を書きなさい：

fun solution(A: IntArray): Int

ただし、Aは非空の0から始まる配列であり、その要素数はNである。返り値はAによって構成されるリストの長さである。

例えば、次の配列Aを考える：

A[0] = 1 A[1] = 4 A[2] = -1 A[3] = 3 A[4] = 2

上の図で説明したとおり、関数は4を返す必要がある。

前提条件：

N は [1..200,000] の範囲の整数とする。

配列 A の各要素は [−1..N-1] の範囲の整数とする。

リストを構成することは必ず可能であり、その長さは有限である。

尚、解答にあたっては、正確さを重視してください。あなたの解答のパフォーマンスは、評価の対象にはなりません。

N個の整数からなる空ではない0から始まる配列Aが与えられる。

配列Aとは、Linked listであり、与えられた配列から下記のようにして構成される。

最初のノード（head）のインデックスは、0である。

インデックスがKのノードの値とは、A[K]である。

ノードの値が−1の場合、そのノードはリストの最後のノードである。

それ以外の場合、インデックスがKのノードの次のノードのインデックスはA[K]（A[K]は有効なインデックスであると仮定してよい、すなわち0≤A[K] <N）。

たとえば、次のような配列Aを考える：

A[0] = 1 A[1] = 4 A[2] = -1 A[3] = 3 A[4] = 2

配列Aから以下のリストが構成される。

最初のノード（head）はindex0に位置し、1の値を持つ。

第2のノードは、index1に位置し、4の値を持つ。

第3のノードは、index4に位置し、2の値を持つ。

第4のノードは、index2に位置し、−1の値を持つ。

以下の関数を書きなさい：

function solution(A)

ただし、Aは非空の0から始まる配列であり、その要素数はNである。返り値はAによって構成されるリストの長さである。

例えば、次の配列Aを考える：

A[0] = 1 A[1] = 4 A[2] = -1 A[3] = 3 A[4] = 2

上の図で説明したとおり、関数は4を返す必要がある。

前提条件：

N は [1..200,000] の範囲の整数とする。

配列 A の各要素は [−1..N-1] の範囲の整数とする。

リストを構成することは必ず可能であり、その長さは有限である。

尚、解答にあたっては、正確さを重視してください。あなたの解答のパフォーマンスは、評価の対象にはなりません。

N個の整数からなる空ではない0から始まる配列Aが与えられる。

配列Aとは、Linked listであり、与えられた配列から下記のようにして構成される。

最初のノード（head）のインデックスは、0である。

インデックスがKのノードの値とは、A[K]である。

ノードの値が−1の場合、そのノードはリストの最後のノードである。

それ以外の場合、インデックスがKのノードの次のノードのインデックスはA[K]（A[K]は有効なインデックスであると仮定してよい、すなわち0≤A[K] <N）。

たとえば、次のような配列Aを考える：

A[0] = 1 A[1] = 4 A[2] = -1 A[3] = 3 A[4] = 2

配列Aから以下のリストが構成される。

最初のノード（head）はindex0に位置し、1の値を持つ。

第2のノードは、index1に位置し、4の値を持つ。

第3のノードは、index4に位置し、2の値を持つ。

第4のノードは、index2に位置し、−1の値を持つ。

以下の関数を書きなさい：

int solution(NSMutableArray *A);

ただし、Aは非空の0から始まる配列であり、その要素数はNである。返り値はAによって構成されるリストの長さである。

例えば、次の配列Aを考える：

A[0] = 1 A[1] = 4 A[2] = -1 A[3] = 3 A[4] = 2

上の図で説明したとおり、関数は4を返す必要がある。

前提条件：

N は [1..200,000] の範囲の整数とする。

配列 A の各要素は [−1..N-1] の範囲の整数とする。

リストを構成することは必ず可能であり、その長さは有限である。

尚、解答にあたっては、正確さを重視してください。あなたの解答のパフォーマンスは、評価の対象にはなりません。

N個の整数からなる空ではない0から始まる配列Aが与えられる。

配列Aとは、Linked listであり、与えられた配列から下記のようにして構成される。

最初のノード（head）のインデックスは、0である。

インデックスがKのノードの値とは、A[K]である。

ノードの値が−1の場合、そのノードはリストの最後のノードである。

それ以外の場合、インデックスがKのノードの次のノードのインデックスはA[K]（A[K]は有効なインデックスであると仮定してよい、すなわち0≤A[K] <N）。

たとえば、次のような配列Aを考える：

A[0] = 1 A[1] = 4 A[2] = -1 A[3] = 3 A[4] = 2

配列Aから以下のリストが構成される。

最初のノード（head）はindex0に位置し、1の値を持つ。

第2のノードは、index1に位置し、4の値を持つ。

第3のノードは、index4に位置し、2の値を持つ。

第4のノードは、index2に位置し、−1の値を持つ。

以下の関数を書きなさい：

function solution(A: array of longint; N: longint): longint;

ただし、Aは非空の0から始まる配列であり、その要素数はNである。返り値はAによって構成されるリストの長さである。

例えば、次の配列Aを考える：

A[0] = 1 A[1] = 4 A[2] = -1 A[3] = 3 A[4] = 2

上の図で説明したとおり、関数は4を返す必要がある。

前提条件：

N は [1..200,000] の範囲の整数とする。

配列 A の各要素は [−1..N-1] の範囲の整数とする。

リストを構成することは必ず可能であり、その長さは有限である。

尚、解答にあたっては、正確さを重視してください。あなたの解答のパフォーマンスは、評価の対象にはなりません。

N個の整数からなる空ではない0から始まる配列Aが与えられる。

配列Aとは、Linked listであり、与えられた配列から下記のようにして構成される。

最初のノード（head）のインデックスは、0である。

インデックスがKのノードの値とは、A[K]である。

ノードの値が−1の場合、そのノードはリストの最後のノードである。

それ以外の場合、インデックスがKのノードの次のノードのインデックスはA[K]（A[K]は有効なインデックスであると仮定してよい、すなわち0≤A[K] <N）。

たとえば、次のような配列Aを考える：

A[0] = 1 A[1] = 4 A[2] = -1 A[3] = 3 A[4] = 2

配列Aから以下のリストが構成される。

最初のノード（head）はindex0に位置し、1の値を持つ。

第2のノードは、index1に位置し、4の値を持つ。

第3のノードは、index4に位置し、2の値を持つ。

第4のノードは、index2に位置し、−1の値を持つ。

以下の関数を書きなさい：

function solution($A);

ただし、Aは非空の0から始まる配列であり、その要素数はNである。返り値はAによって構成されるリストの長さである。

例えば、次の配列Aを考える：

A[0] = 1 A[1] = 4 A[2] = -1 A[3] = 3 A[4] = 2

上の図で説明したとおり、関数は4を返す必要がある。

前提条件：

N は [1..200,000] の範囲の整数とする。

配列 A の各要素は [−1..N-1] の範囲の整数とする。

リストを構成することは必ず可能であり、その長さは有限である。

尚、解答にあたっては、正確さを重視してください。あなたの解答のパフォーマンスは、評価の対象にはなりません。

N個の整数からなる空ではない0から始まる配列Aが与えられる。

配列Aとは、Linked listであり、与えられた配列から下記のようにして構成される。

最初のノード（head）のインデックスは、0である。

インデックスがKのノードの値とは、A[K]である。

ノードの値が−1の場合、そのノードはリストの最後のノードである。

それ以外の場合、インデックスがKのノードの次のノードのインデックスはA[K]（A[K]は有効なインデックスであると仮定してよい、すなわち0≤A[K] <N）。

たとえば、次のような配列Aを考える：

A[0] = 1 A[1] = 4 A[2] = -1 A[3] = 3 A[4] = 2

配列Aから以下のリストが構成される。

最初のノード（head）はindex0に位置し、1の値を持つ。

第2のノードは、index1に位置し、4の値を持つ。

第3のノードは、index4に位置し、2の値を持つ。

第4のノードは、index2に位置し、−1の値を持つ。

以下の関数を書きなさい：

sub solution { my (@A) = @_; ... }

ただし、Aは非空の0から始まる配列であり、その要素数はNである。返り値はAによって構成されるリストの長さである。

例えば、次の配列Aを考える：

A[0] = 1 A[1] = 4 A[2] = -1 A[3] = 3 A[4] = 2

上の図で説明したとおり、関数は4を返す必要がある。

前提条件：

N は [1..200,000] の範囲の整数とする。

配列 A の各要素は [−1..N-1] の範囲の整数とする。

リストを構成することは必ず可能であり、その長さは有限である。

尚、解答にあたっては、正確さを重視してください。あなたの解答のパフォーマンスは、評価の対象にはなりません。

N個の整数からなる空ではない0から始まる配列Aが与えられる。

配列Aとは、Linked listであり、与えられた配列から下記のようにして構成される。

最初のノード（head）のインデックスは、0である。

インデックスがKのノードの値とは、A[K]である。

ノードの値が−1の場合、そのノードはリストの最後のノードである。

それ以外の場合、インデックスがKのノードの次のノードのインデックスはA[K]（A[K]は有効なインデックスであると仮定してよい、すなわち0≤A[K] <N）。

たとえば、次のような配列Aを考える：

A[0] = 1 A[1] = 4 A[2] = -1 A[3] = 3 A[4] = 2

配列Aから以下のリストが構成される。

最初のノード（head）はindex0に位置し、1の値を持つ。

第2のノードは、index1に位置し、4の値を持つ。

第3のノードは、index4に位置し、2の値を持つ。

第4のノードは、index2に位置し、−1の値を持つ。

以下の関数を書きなさい：

def solution(A)

ただし、Aは非空の0から始まる配列であり、その要素数はNである。返り値はAによって構成されるリストの長さである。

例えば、次の配列Aを考える：

A[0] = 1 A[1] = 4 A[2] = -1 A[3] = 3 A[4] = 2

上の図で説明したとおり、関数は4を返す必要がある。

前提条件：

N は [1..200,000] の範囲の整数とする。

配列 A の各要素は [−1..N-1] の範囲の整数とする。

リストを構成することは必ず可能であり、その長さは有限である。

尚、解答にあたっては、正確さを重視してください。あなたの解答のパフォーマンスは、評価の対象にはなりません。

N個の整数からなる空ではない0から始まる配列Aが与えられる。

配列Aとは、Linked listであり、与えられた配列から下記のようにして構成される。

最初のノード（head）のインデックスは、0である。

インデックスがKのノードの値とは、A[K]である。

ノードの値が−1の場合、そのノードはリストの最後のノードである。

それ以外の場合、インデックスがKのノードの次のノードのインデックスはA[K]（A[K]は有効なインデックスであると仮定してよい、すなわち0≤A[K] <N）。

たとえば、次のような配列Aを考える：

A[0] = 1 A[1] = 4 A[2] = -1 A[3] = 3 A[4] = 2

配列Aから以下のリストが構成される。

最初のノード（head）はindex0に位置し、1の値を持つ。

第2のノードは、index1に位置し、4の値を持つ。

第3のノードは、index4に位置し、2の値を持つ。

第4のノードは、index2に位置し、−1の値を持つ。

以下の関数を書きなさい：

def solution(a)

ただし、Aは非空の0から始まる配列であり、その要素数はNである。返り値はAによって構成されるリストの長さである。

例えば、次の配列Aを考える：

A[0] = 1 A[1] = 4 A[2] = -1 A[3] = 3 A[4] = 2

上の図で説明したとおり、関数は4を返す必要がある。

前提条件：

N は [1..200,000] の範囲の整数とする。

配列 A の各要素は [−1..N-1] の範囲の整数とする。

リストを構成することは必ず可能であり、その長さは有限である。

尚、解答にあたっては、正確さを重視してください。あなたの解答のパフォーマンスは、評価の対象にはなりません。

N個の整数からなる空ではない0から始まる配列Aが与えられる。

配列Aとは、Linked listであり、与えられた配列から下記のようにして構成される。

最初のノード（head）のインデックスは、0である。

インデックスがKのノードの値とは、A[K]である。

ノードの値が−1の場合、そのノードはリストの最後のノードである。

それ以外の場合、インデックスがKのノードの次のノードのインデックスはA[K]（A[K]は有効なインデックスであると仮定してよい、すなわち0≤A[K] <N）。

たとえば、次のような配列Aを考える：

A[0] = 1 A[1] = 4 A[2] = -1 A[3] = 3 A[4] = 2

配列Aから以下のリストが構成される。

最初のノード（head）はindex0に位置し、1の値を持つ。

第2のノードは、index1に位置し、4の値を持つ。

第3のノードは、index4に位置し、2の値を持つ。

第4のノードは、index2に位置し、−1の値を持つ。

以下の関数を書きなさい：

object Solution { def solution(a: Array[Int]): Int }

ただし、Aは非空の0から始まる配列であり、その要素数はNである。返り値はAによって構成されるリストの長さである。

例えば、次の配列Aを考える：

A[0] = 1 A[1] = 4 A[2] = -1 A[3] = 3 A[4] = 2

上の図で説明したとおり、関数は4を返す必要がある。

前提条件：

N は [1..200,000] の範囲の整数とする。

配列 A の各要素は [−1..N-1] の範囲の整数とする。

リストを構成することは必ず可能であり、その長さは有限である。

尚、解答にあたっては、正確さを重視してください。あなたの解答のパフォーマンスは、評価の対象にはなりません。

N個の整数からなる空ではない0から始まる配列Aが与えられる。

配列Aとは、Linked listであり、与えられた配列から下記のようにして構成される。

最初のノード（head）のインデックスは、0である。

インデックスがKのノードの値とは、A[K]である。

ノードの値が−1の場合、そのノードはリストの最後のノードである。

それ以外の場合、インデックスがKのノードの次のノードのインデックスはA[K]（A[K]は有効なインデックスであると仮定してよい、すなわち0≤A[K] <N）。

たとえば、次のような配列Aを考える：

A[0] = 1 A[1] = 4 A[2] = -1 A[3] = 3 A[4] = 2

配列Aから以下のリストが構成される。

最初のノード（head）はindex0に位置し、1の値を持つ。

第2のノードは、index1に位置し、4の値を持つ。

第3のノードは、index4に位置し、2の値を持つ。

第4のノードは、index2に位置し、−1の値を持つ。

以下の関数を書きなさい：

public func solution(_ A : inout [Int]) -> Int

ただし、Aは非空の0から始まる配列であり、その要素数はNである。返り値はAによって構成されるリストの長さである。

例えば、次の配列Aを考える：

A[0] = 1 A[1] = 4 A[2] = -1 A[3] = 3 A[4] = 2

上の図で説明したとおり、関数は4を返す必要がある。

前提条件：

N は [1..200,000] の範囲の整数とする。

配列 A の各要素は [−1..N-1] の範囲の整数とする。

リストを構成することは必ず可能であり、その長さは有限である。

尚、解答にあたっては、正確さを重視してください。あなたの解答のパフォーマンスは、評価の対象にはなりません。

N個の整数からなる空ではない0から始まる配列Aが与えられる。

配列Aとは、Linked listであり、与えられた配列から下記のようにして構成される。

最初のノード（head）のインデックスは、0である。

インデックスがKのノードの値とは、A[K]である。

ノードの値が−1の場合、そのノードはリストの最後のノードである。

それ以外の場合、インデックスがKのノードの次のノードのインデックスはA[K]（A[K]は有効なインデックスであると仮定してよい、すなわち0≤A[K] <N）。

たとえば、次のような配列Aを考える：

A[0] = 1 A[1] = 4 A[2] = -1 A[3] = 3 A[4] = 2

配列Aから以下のリストが構成される。

最初のノード（head）はindex0に位置し、1の値を持つ。

第2のノードは、index1に位置し、4の値を持つ。

第3のノードは、index4に位置し、2の値を持つ。

第4のノードは、index2に位置し、−1の値を持つ。

以下の関数を書きなさい：

function solution(A: number[]): number;

ただし、Aは非空の0から始まる配列であり、その要素数はNである。返り値はAによって構成されるリストの長さである。

例えば、次の配列Aを考える：

A[0] = 1 A[1] = 4 A[2] = -1 A[3] = 3 A[4] = 2

上の図で説明したとおり、関数は4を返す必要がある。

前提条件：

N は [1..200,000] の範囲の整数とする。

配列 A の各要素は [−1..N-1] の範囲の整数とする。

リストを構成することは必ず可能であり、その長さは有限である。

尚、解答にあたっては、正確さを重視してください。あなたの解答のパフォーマンスは、評価の対象にはなりません。

N個の整数からなる空ではない0から始まる配列Aが与えられる。

配列Aとは、Linked listであり、与えられた配列から下記のようにして構成される。

最初のノード（head）のインデックスは、0である。

インデックスがKのノードの値とは、A[K]である。

ノードの値が−1の場合、そのノードはリストの最後のノードである。

それ以外の場合、インデックスがKのノードの次のノードのインデックスはA[K]（A[K]は有効なインデックスであると仮定してよい、すなわち0≤A[K] <N）。

たとえば、次のような配列Aを考える：

A[0] = 1 A[1] = 4 A[2] = -1 A[3] = 3 A[4] = 2

配列Aから以下のリストが構成される。

最初のノード（head）はindex0に位置し、1の値を持つ。

第2のノードは、index1に位置し、4の値を持つ。

第3のノードは、index4に位置し、2の値を持つ。

第4のノードは、index2に位置し、−1の値を持つ。

以下の関数を書きなさい：

Private Function solution(A As Integer()) As Integer

ただし、Aは非空の0から始まる配列であり、その要素数はNである。返り値はAによって構成されるリストの長さである。

例えば、次の配列Aを考える：

A[0] = 1 A[1] = 4 A[2] = -1 A[3] = 3 A[4] = 2

上の図で説明したとおり、関数は4を返す必要がある。

前提条件：

N は [1..200,000] の範囲の整数とする。

配列 A の各要素は [−1..N-1] の範囲の整数とする。

リストを構成することは必ず可能であり、その長さは有限である。

尚、解答にあたっては、正確さを重視してください。あなたの解答のパフォーマンスは、評価の対象にはなりません。

ArrListLen

Developer Training

Sign up for our newsletter:

Social: