> For the complete documentation index, see [llms.txt](https://jaywin.gitbook.io/leetcode/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://jaywin.gitbook.io/leetcode/solutions/0481-magical-string.md).

# 0481. Magical String

<https://leetcode.com/problems/magical-string>

## Description

A magical string `s` consists of only `'1'` and `'2'` and obeys the following rules:

* The string s is magical because concatenating the number of contiguous occurrences of characters `'1'` and `'2'` generates the string `s` itself.

The first few elements of `s` is `s = "1221121221221121122……"`. If we group the consecutive `1`'s and `2`'s in `s`, it will be `"1 22 11 2 1 22 1 22 11 2 11 22 ......"` and the occurrences of `1`'s or `2`'s in each group are `"1 2 2 1 1 2 1 2 2 1 2 2 ......"`. You can see that the occurrence sequence is `s` itself.

Given an integer `n`, return the number of `1`'s in the first `n` number in the magical string `s`.

**Example 1:**

```
**Input:** n = 6
**Output:** 3
**Explanation:** The first 6 elements of magical string s is "122112" and it contains three 1's, so return 3.
```

**Example 2:**

```
**Input:** n = 1
**Output:** 1
```

**Constraints:**

* `1 <= n <= 105`

## ac

```java
class Solution {
    public int magicalString(int n) {
        // edge cases
        if (n == 0) return 0;
        if (n < 3) return 1;

        int[] nums = new int[n];
        nums[0] = 1; nums[1] = nums[2] = 2;
        int i = 3, cnt1 = 1, countIdx = 2, curr = 1;

        while (i < n) {
            int count = nums[countIdx++];
            while (i < n && count-- > 0) {
                nums[i] = curr;
                if (nums[i] == 1) cnt1++;
                i++;
            }
            curr = 3 - curr; // flip 1 and 2
        }

        return cnt1;
    }
}

/*
1) build the array, when nums[i] is 1 cnt++; 2) flip curr between 1 and 2 each time, get count from array;
*/
```