LeetCode038 Count and Say

详细见：leetcode.com/problems/count-and-say

Java Solution:
github

package leetcode;

public class P038_CountAndSay {
/*
* 2 ms
* 85.40%
*/
static class Solution {
public String countAndSay(int n) {
if (n < 1) {
return null;
}
String result = "1";
for (int i = 2; i <= n; i++) {
result = countAndSay(result);
}
return result;
}
public String countAndSay(String str) {
StringBuilder builder = new StringBuilder(128);
int count = 1;
for (int i = 1; i < str.length(); i++) {
if (str.charAt(i) == str.charAt(i - 1)) {
count++;
} else {
builder.append(count);
builder.append(str.charAt(i - 1));
count = 1;
}
}
builder.append(count);
builder.append(str.charAt(str.length() - 1));
return builder.toString();
}
}
}

C Solution:
github

/*
url: leetcode.com/problems/count-and-say/
3ms 15.29%
*/

#include <stdlib.h>
#include <stdio.h>
#include <string.h>

//array list start

typedef char T;
typedef struct al sal;
typedef struct al * pal;

struct al {
int capacity;
int size;
T* arr;
};

void al_expand_capacity(pal l) {
T* new_arr = (T*) malloc(sizeof(T) * (l->capacity * 2 + 1));
int i = 0;
for (i = 0; i < l->capacity; i ++)
new_arr[i] = l->arr[i];
free(l->arr);
l->arr = new_arr;
l->capacity = l->capacity * 2 + 1;
}

void al_add_last(pal l, T v) {
if (l->capacity == l->size) al_expand_capacity(l);
l->arr[l->size] = v;
l->size ++;
}

void al_add_first(pal l, T v) {
int i = 0;
if (l->capacity == l->size) al_expand_capacity(l);
for (i = l->size; i > 0; i --)
l->arr[i] = l->arr[i - 1];
l->arr[0] = v;
l->size ++;
}

void al_add_to_index(pal l, T v, int index) {
int i = 0;
if (index < 0 || index > l->size) return;
if (l->capacity == l->size) al_expand_capacity(l);
for (i = l->size - 1; i >= index; i --) {
l->arr[i+1] = l->arr[i];
}
l->arr[index] = v;
l->size ++;
}

void al_set_index(pal l, T v, int index) {
if (index < 0 || index > l->size) return;
if (index == l->size) {
al_add_last(l, v);
return;
}
l->arr[index] = v;
//if T by malloc, need to free
}

//if T is ptr, need to free l->size - 1
void al_remove_last(pal l) {
if (l->size == 0) return;
l->arr[l->size - 1] = 0; //or NULL and free
l->size --;
}

//if T is ptr, need to free 0
void al_remove_first(pal l) {
int i = 0;
if (l->size == 0) return;
l->arr[0] = 0; //or NULL and free
for (i = 1; i < l->size; i ++) {
l->arr[i - 1] = l->arr[i];
}
l->size --;
}

T* al_convert_to_array_free_l(pal l) {
T* arr = l->arr;
free(l);
return arr;
}

T al_val(pal l, int index) {
if (index >= l->size || index < 0) return 0;
return l->arr[index];
}

void al_free_all(pal l) {
free(l->arr);
free(l);
}

void al_print(pal l) {
int i = 0;
if (l->size == 0) return;
for (i = 0; i < l->size; i ++)
printf("%d ", l->arr[i]);
printf("\r\n");
}

//array list end

void itoa_my(int val, char* chs, int radix) {
int ATOA_MY_LEN = 33;
char s[33];
int index = ATOA_MY_LEN;
int negative = val < 0;
//invalid radix
if (radix < 2) return;
s[-- index] = '\0';
while (val != 0) {
s[-- index] = (char)(abs(val % radix) + '0');
val = val / radix;
}
if (negative) {
s[-- index] = '-';
}
//reuse negative as chs index
negative = 0;
while (index < ATOA_MY_LEN) {
*(chs + negative ++) = s[index ++];
}
}

char* check_cap(char* to_check, int* to_check_cap, int to_check_index) {
int new_cap = 0, index = 0;
char* temp = NULL;
if (to_check_index < *to_check_cap) return to_check;
new_cap = to_check_index + 100 > 2 * *to_check_cap ? to_check_index + 100 : 2 * *to_check_cap;
temp = (char*) malloc(sizeof(char) * (new_cap + 1));
for (index = 0; index <= *to_check_cap; index ++) {
*(temp + index) = *(to_check + index);
}
*to_check_cap = new_cap;
free(to_check);
return temp;
}

void swap_pchar(char** a, char** b) {
char* t = * a;
*a = *b;
*b = t;
}

void swap_int(int* a, int *b) {
int t = *a;
*a = *b;
*b = t;
}

void swap_al(pal* a, pal* b) {
pal t = *a;
*a = *b;
*b = t;
}

char* countAndSay(int n) {
int answer_cap = 1, save_cap = 1, ni = 1;
int answer_size = 0, save_size = 0;
int answer_index = 0, save_index = 0, char_count = 0;
int int_char_index = 0;
char int_char[14];
char char_pre = '\0';
pal answer = (pal) malloc(sizeof(sal));
pal save = (pal) malloc(sizeof(sal));
char* temp = NULL;
answer->capacity = 16;
answer->size = 0;
answer->arr = (T*) malloc(sizeof(T) * answer->capacity);
save->capacity = 16;
save->size = 0;
save->arr = (T*) malloc(sizeof(T) * save->capacity);
al_add_last(answer, '1');

while (n != ni) {
//just count
ni ++;
//count answer to save
char_pre = '\0';
char_count = 0;
save_index = 0;
answer_index = 0;
save->size = 0;
while (answer_index <= answer->size) {
//only char_count ++ and continue
if (answer_index != answer->size && al_val(answer, answer_index) == char_pre) {
char_count ++;
answer_index ++;
continue;
}
if (answer_index != 0) {
//save to save
itoa_my(char_count, int_char, 10);
int_char_index = 0;
while (int_char[int_char_index] != '\0') {
al_add_last(save, int_char[int_char_index ++]);
}
al_add_last(save, char_pre);
}
if (answer_index != answer->size) {
char_count = 1;
char_pre = al_val(answer, answer_index ++);
} else break;
}
swap_al(&answer, &save);
}
al_free_all(save);
al_add_last(answer, '\0');
return al_convert_to_array_free_l(answer);
}

int main() {
int n = 15;
char* ans = countAndSay(n);
printf("answer is %s\r\n", ans);
free(ans);
}

Python Solution:
github

#coding=utf-8

'''
url: leetcode.com/problems/count-and-say/
@author: zxwtry
@email: zxwtry@qq.com
@date: 2017年4月5日
@details: Solution: 72ms 13.30%
'''

class Solution(object):
def countAndSay(self, n):
"""
:type n: int
:rtype: str
"""
if n < 1: return ""
if n == 1: return "1"
answer="1"
for i in range(n-1):
record, pre_char, pre_count=[], "ddd", 0
for j in range(len(answer)):
if answer[j] == pre_char:
pre_count += 1
else:
if pre_count != 0:
record.append(str(pre_count))
record.append(pre_char)
pre_char = answer[j]
pre_count = 1
if pre_count != 0:
record.append(str(pre_count))
record.append(pre_char)
answer = "".join(record)
return answer

if __name__ == "__main__":
print(Solution().countAndSay(4))