Notes

/*======================READ LINE=================*/
int read_line(char* line, int size){
int i;
int c;
for(i = 0; i < size - 1; i++){
c = getchar();
if(c =='n'){
line[i]=c;
line[i+1]='';
return i;
}
else if(c == EOF){
line[i]='';
return EOF;
}

line[i]=c;

}

line[size]='';
return i;
}


/*==============WORD COUNT===============*/
#include <stdio.h>
#define OUT 0
#define IN 1
unsigned countWords(char *str)
{
int state = OUT;
unsigned wc = 0; // word count
while (*str)
{
if (*str == ' ' || *str == 'n' || *str == 't')
state = OUT;
else if (state == OUT)
{
state = IN;
++wc;
}
++str;
}
return wc;
}
int main(void)
{
char str[] = "marosko je kokot jak repa ";
printf("No of words : %un", countWords(str));
return 0;
}



/*============ENCODING==================*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MAX_RLEN 50


char* encode(char* src)
{
int rLen;
char count[MAX_RLEN];
int len = strlen(src);
char* dest = (char*)malloc(sizeof(char) * (len * 2 + 1));
int i, j = 0, k;

for (i = 0; i < len; i++) {
dest[j++] = src[i];
rLen = 1;
while (i + 1 < len && src[i] == src[i + 1]) {
rLen++;
i++;
}
sprintf(count, "%d", rLen);
for (k = 0; *(count + k); k++, j++) {
dest[j] = count[k];
}
}
dest[j] = '';
return dest;
}


int main()
{
char str[] = "aaaaaaaaabbbbbbbb33333";
char* res = encode(str);
printf("%s", res);
getchar();
}

/*============================================*/



//=======STROM OD HLADEKA ========
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <math.h>

struct node {
struct node* left;
struct node* right;
int height;
int value;
};

struct tree {
struct node* root;
size_t size;
};

struct tree* init_tree(){
return calloc(1,sizeof(struct tree));
}

struct node* create_node(int value){
struct node* node = malloc(sizeof(struct node));
node->left = NULL;
node->right = NULL;
node->value = value;
node->height = 0;
return node;
}

void destroy_node(struct node* node){
if(node != NULL){
destroy_node(node->left);
destroy_node(node->right);
free(node);
}
}

void destroy_tree(struct tree* tree){
destroy_node(tree->root);
free(tree);
}

int height(struct node* node){
int l = 0;
if (node == NULL){
return 0;
}
if (node->left){
l = node->left->height;
}
int r = 0;
if (node->right){
r = node->right->height;
}
if (l > r){
return l + 1;
}
return r + 1;
}

int balance_factor(struct node* node){
if (node == NULL){
return 0;
}
return height(node->right) - height(node->left);
}


//
struct node* rotate_right(struct node* parent){
struct node* pivot = parent->left;
assert(pivot != NULL);
// printf("R %dn",pivot->value);
parent->left = pivot->right;
pivot->right = parent;
parent->height = height(parent);
pivot->height = height(pivot);
return pivot;
}

//
// ROOT PIVOT
// / => /
// A PIVOT ROOT C
// / /
// B C A B
//
//
struct node* rotate_left(struct node* parent){
struct node* pivot = parent->right;
assert(pivot != NULL);
// printf("L %dn",pivot->value);
parent->right = pivot->left;
pivot->left = parent;
parent->height = height(parent);
pivot->height = height(pivot);
return pivot;
}

struct node* balance_tree_node(struct node* node){
assert(node);
node->height = height(node);
// Left heavy
if (balance_factor(node) < -1){
if (balance_factor(node->left) > 1) {
node->left = rotate_left(node->left);
}
node = rotate_right(node);
}
// Right Heavy
else if (balance_factor(node) > 1){
if (balance_factor(node->right) < -1){
node->right = rotate_right(node->right);
}
node = rotate_left(node);
}
return node;
}

struct node* search(struct tree* tree, int value){
struct node* current = tree->root;
while( current != NULL ){
if (value < current->value ){
current = current->left;
}
else if (value > current->value){
current = current->right;
}
else {
break;
}
}
return current;
}

struct node* insert(struct node* node, int value){
if (node == NULL){
return create_node(value);
}
if (value < node->value){
node->left = insert(node->left,value);
}
else if (value > node->value){
node->right = insert(node->right,value);
}
node = balance_tree_node(node);
return node;
}

struct node* minimum(struct node* node){
assert(node);
while(node->left != NULL){
node = node->left;
}
return node;
}

struct node* delete(struct node* node,int value){
if (node == NULL){
return NULL;
}
struct node* res = node;
if (node->value == value){
if (node->left && node->right){
struct node* min = minimum(node->right);
node->value = min->value;
node->right = delete(node->right,min->value);
}
else if (node->left && node->right == NULL){
res = node->left;
free(node);
}
else if (node->right && node->left == NULL){
res = node->right;
free(node);
}
}
else if (node->value < value){
node->left = delete(node->left,value);
}
else {
node->right = delete(node->right,value);
}
return res;
}

void print_dot_node(struct node* node){
if (node == NULL){
return;
}
print_dot_node(node->left);
printf("%d [label="%d %d"];n",node->value,node->value, node->height);
if (node->left){
printf("%d -> %d;n",node->value,node->left->value);
}
if (node->right){
printf("%d -> %d;n",node->value,node->right->value);
}
print_dot_node(node->right);
}


void print_dot(struct node* node){
printf("digraph G {n");
print_dot_node(node);
printf("}n");
}


int main(){
time_t t;
srand((unsigned) time(&t));
struct node* tree = NULL;
for (int i = 0; i < 100; i++){
tree = insert(tree,rand() % 150);
}
print_dot(tree);
return 0;
}
/*============================================*/


/*========HASOVACIA TABULKA=================*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

struct item {
char key[20];
int value;
struct item* next;
};

struct table {
struct item** slots;
int slot_count;
};

struct table* create_table(){
struct table* tab = malloc(sizeof(struct table));
tab->slot_count = 40;
tab->slots = calloc(tab->slot_count,sizeof(struct item *));
return tab;
}

void destroy_table(struct table* tab){
for (int i = 0; i < tab->slot_count; i++){
struct item* list = tab->slots[i];
while (list != NULL){
struct item* del = list;
list = del->next;
free(del);
}
}
free(tab->slots);
free(tab);
}

int hash_string(const char* word){
int hash = 0;
for (int counter = 0; word[counter]!=''; counter++){
hash = word[counter] + (hash << 6) + (hash << 16) - hash;
}
return hash;
}

int insert(struct table* tab,const char* key,int value){
int hash = hash_string(key);
int slot_index = hash % tab->slot_count;

struct item* slot = tab->slots[slot_index];
while (slot != NULL){
if (strcmp(slot->key,key) == 0) {
slot->value = value;
return 1;
}
slot = slot->next;
}
struct item* new = malloc(sizeof(struct item));
strcpy(new->key,key);
new->value = value;
new->next = slot;
tab->slots[slot_index] = new;
if (new->next){
return 1;
}
return 0;
}

int* find(struct table* tab,const char* key){
int hash = hash_string(key);
int slot_index = hash % tab->slot_count;

struct item* slot = tab->slots[slot_index];
while (slot != NULL){
if (strcmp(slot->key,key) == 0) {
return &(slot->value);
}
slot = slot->next;
}
return NULL;
}

int* delete(struct table* tab,const char* key){
int hash = hash_string(key);
int slot_index = hash % tab->slot_count;

struct item* slot = tab->slots[slot_index];

if(slot != NULL){
struct item* this = slot;
while (this->next != NULL){
if (strcmp(this->next->key,key) == 0) {
}
this = this->next;
}
}
return NULL;
}

int main(){
struct table* tab = create_table();
insert(tab,"ahoj",2);
insert(tab,"svet",4);

int* val = NULL;
val = find(tab,"kluc");

destroy_table(tab);
return 0;
}


/*===============LINKED LIST================*/
#include "linked_list.h"
#include <stdio.h>

struct list {
int data;
struct list* next;
}


struct list* create_list(int value) {
struct list* new_list = (struct list*)malloc(sizeof(struct list));
new_list->value = value;
return new_list;
}

void destroy_list(struct list* list){
if (list!=NULL){
destroy_list(list->next);
free(list);
}
}


struct list* pop_list(struct list* list,int* value){
struct *list current = list;
if(list =! NULL){
while(current->next->next != NULL){
current = current -> next;
}

*value = current -> next -> value;
struct list* delete;
delete -> current->next;
current -> next = NULL;
free (delete);
return list;
}
else
return NULL;
}

struct list* push_list(struct list* list,int value){

struct list* add_end = (struct list*) malloc(sizeof(list));
struct list* current;
add_end -> value = value;
add_end -> next = NULL;

if(list = NULL){
list = add_end ;
}
else {
current = list;
while(current -> next != NULL){
current = current -> next;
}
current -> next = add_end;
}

return list;

}

struct list* shift_list(struct list* list,int value) {

struct list* add_first = (struct list*) malloc(sizeof(list));
add_first -> value = value;
add_first -> next = list ;
list = add_first;
return list;
}

struct list* unshift_list(struct list* list,int* value){

if (list =! NULL){
struct list* delete_first;
struct list* delete_first = list ;
*value = list -> value ;
list = delete_first -> next;
free (delete_first);
return list;
}

else
return NULL;
}