# Count and Say

## Problem

The count-and-say sequence is a sequence of digit strings defined by the recursive formula:

- countAndSay(1) = “1”
- countAndSay(n) is the run-length encoding of countAndSay(n - 1).

Run-length encoding (RLE) is a string compression method that works by replacing consecutive identical characters (repeated 2 or more times) with the concatenation of the character and the number marking the count of the characters (length of the run). For example, to compress the string “3322251” we replace “33” with “23”, replace “222” with “32”, replace “5” with “15” and replace “1” with “11”. Thus the compressed string becomes “23321511”.

Given a positive integer n, return the nth element of the count-and-say sequence.

Example 1:

```
Input: n = 4
Output: "1211"
Explanation:
countAndSay(1) = "1"
countAndSay(2) = RLE of "1" = "11"
countAndSay(3) = RLE of "11" = "21"
countAndSay(4) = RLE of "21" = "1211"
```

Example 2:

```
Input: n = 1
Output: "1"
Explanation:
This is the base case.
```

Constraints:

- 1 <= n <= 30

Follow up: Could you solve it iteratively?

## Solution

```
class Solution {
public String countAndSay(int n) {
if (n == 1) {
return "1";
}
var result = countAndSay(n - 1).toCharArray();
var sb = new StringBuilder();
var curr = 'a';
var quan = 0;
for (var c : result) {
if (curr == c) {
quan += 1;
} else {
if (curr != 'a') {
sb.append(String.valueOf(quan));
sb.append(curr);
}
curr = c;
quan = 1;
}
}
sb.append(String.valueOf(quan));
sb.append(curr);
return sb.toString();
}
}
```

### Another Approach

```
public String countAndSay(int n) {
var str = "1";
for (var i = 2; i <= n; i++) {
var newStr = "";
// we want to overwrite the string
// iterate over the current string
var count = 1;
for (var x = 0; x < str.length(); x++) {
// there are two cases: the this char is the same as the next, or it isn't. if it isn't, it might be because we're out of bounds
// bounds check always first
if (x + 1 < str.length() && str.charAt(x + 1) == str.charAt(x)) {
// match!
count += 1;
} else {
// no match
newStr = newStr + count + str.charAt(x);
count = 1;
}
}
str = newStr;
}
return str;
}
```

### Extension

Reverse count and say

```
public void reverse(String s, int index, String prev, String curr, List<String> ans) {
if (index == s.length()) {
if (curr.isEmpty()) {
ans.add(prev);
}
return;
}
// keep building the chain
reverse(s, index + 1, prev, curr + s.charAt(index), ans);
if (!curr.isEmpty()) {
var quantity = Integer.valueOf(curr);
var character = s.charAt(index);
for (int i = 0; i < quantity; i++) {
prev = prev + character;
}
// we can consume this
reverse(s, index + 1, prev, "", ans);
}
}
```