mirror of
https://github.com/theoludwig/programming-challenges.git
synced 2024-12-08 00:45:29 +01:00
fix(solutions): memory issues thanks to -fsanitize=address flag with gcc
This commit is contained in:
parent
3b6cc97bb5
commit
0245c7a12c
@ -1,11 +1,16 @@
|
||||
#include "character.h"
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
void character_append(char* string, const char character) {
|
||||
size_t length = string_get_length(string);
|
||||
character_append_at(string, character, length);
|
||||
}
|
||||
|
||||
void character_append(char* string, char character) {
|
||||
size_t length = strlen(string);
|
||||
string[length] = character;
|
||||
void character_append_at(char* string, const char character, const size_t index) {
|
||||
size_t length = string_get_length(string);
|
||||
for (size_t index_string = length; index_string > index; index_string--) {
|
||||
string[index_string] = string[index_string - 1];
|
||||
}
|
||||
string[index] = character;
|
||||
string[length + 1] = '\0';
|
||||
}
|
||||
|
||||
|
@ -1,6 +1,11 @@
|
||||
#ifndef __CHARACTER__
|
||||
#define __CHARACTER__
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
#include "string.h"
|
||||
|
||||
/**
|
||||
* @brief Append a character to a string, assuming string points to an array
|
||||
* with enough space.
|
||||
@ -10,6 +15,15 @@
|
||||
*/
|
||||
void character_append(char* string, char character);
|
||||
|
||||
/**
|
||||
* @brief Append a character to a string at a specific index, assuming string points to an array with enough space.
|
||||
*
|
||||
* @param string
|
||||
* @param character
|
||||
* @param index
|
||||
*/
|
||||
void character_append_at(char* string, const char character, const size_t index);
|
||||
|
||||
/**
|
||||
* @brief Converts the character to uppercase.
|
||||
*
|
||||
|
@ -7,10 +7,11 @@
|
||||
|
||||
int main() {
|
||||
char* string = input();
|
||||
string = string_replace(string, '"', '\0');
|
||||
string = string_to_upper(string);
|
||||
string = string_acronym(string);
|
||||
printf("%s\n", string);
|
||||
string_remove_character(string, '"');
|
||||
string_to_uppercase(string);
|
||||
char* result = string_acronym(string);
|
||||
printf("%s\n", result);
|
||||
free(string);
|
||||
free(result);
|
||||
return EXIT_SUCCESS;
|
||||
}
|
||||
|
@ -1,47 +1,55 @@
|
||||
#include "string.h"
|
||||
|
||||
#include <stdbool.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
#include "character.h"
|
||||
|
||||
char* string_to_upper(const char* string) {
|
||||
size_t string_length = strlen(string);
|
||||
char* result = malloc(sizeof(char) * (string_length + 1));
|
||||
for (size_t index = 0; index < string_length; index++) {
|
||||
character_append(result, character_to_upper(string[index]));
|
||||
size_t string_get_length(const char* string) {
|
||||
size_t length = 0;
|
||||
while (string[length] != '\0') {
|
||||
length++;
|
||||
}
|
||||
return result;
|
||||
return length;
|
||||
}
|
||||
|
||||
char* string_replace(const char* string, char search, char replace) {
|
||||
size_t string_length = strlen(string);
|
||||
char* result = malloc(sizeof(char) * (string_length + 1));
|
||||
void string_to_uppercase(char* string) {
|
||||
size_t string_length = string_get_length(string);
|
||||
for (size_t index = 0; index < string_length; index++) {
|
||||
bool is_search_value = search == string[index];
|
||||
if (is_search_value) {
|
||||
character_append(result, replace);
|
||||
} else {
|
||||
character_append(result, string[index]);
|
||||
string[index] = character_to_upper(string[index]);
|
||||
}
|
||||
string[string_length] = '\0';
|
||||
}
|
||||
|
||||
void string_remove_character(char* string, char search) {
|
||||
size_t string_length = string_get_length(string);
|
||||
for (size_t index = 0; index < string_length; index++) {
|
||||
if (string[index] == search) {
|
||||
for (size_t index_string = index; index_string < string_length; index_string++) {
|
||||
string[index_string] = string[index_string + 1];
|
||||
}
|
||||
string_length--;
|
||||
index--;
|
||||
}
|
||||
}
|
||||
return result;
|
||||
string[string_length] = '\0';
|
||||
}
|
||||
|
||||
char* string_acronym(char* string) {
|
||||
size_t string_length = strlen(string);
|
||||
size_t string_length = string_get_length(string);
|
||||
char* result = malloc(sizeof(char) * (string_length + 1));
|
||||
char* current = malloc(sizeof(char) * (string_length + 1));
|
||||
for (size_t index = 0; index < string_length; index++) {
|
||||
if (string[index] == ' ') {
|
||||
character_append(result, current[0]);
|
||||
memset(current, 0, sizeof(char) * (string_length + 1));
|
||||
} else {
|
||||
character_append(current, string[index]);
|
||||
char current = '\0';
|
||||
size_t result_index = 0;
|
||||
bool is_first_character = true;
|
||||
for (size_t string_index = 0; string_index < string_length; string_index++) {
|
||||
if (string[string_index] == ' ') {
|
||||
result[result_index] = current;
|
||||
result_index += 1;
|
||||
is_first_character = true;
|
||||
} else if (is_first_character) {
|
||||
current = string[string_index];
|
||||
is_first_character = false;
|
||||
}
|
||||
}
|
||||
character_append(result, current[0]);
|
||||
free(current);
|
||||
result[result_index] = current;
|
||||
result_index += 1;
|
||||
result[result_index] = '\0';
|
||||
return result;
|
||||
}
|
||||
|
@ -1,24 +1,37 @@
|
||||
#ifndef __STRING__
|
||||
#define __STRING__
|
||||
|
||||
#include <errno.h>
|
||||
#include <stdbool.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
/**
|
||||
* @brief Return the length of a string (excluding '\0').
|
||||
*
|
||||
* @param string
|
||||
*/
|
||||
size_t string_get_length(const char* string);
|
||||
|
||||
/**
|
||||
* @brief Converts all the alphabetic characters in a string to uppercase.
|
||||
*
|
||||
* @param string
|
||||
* @return char*
|
||||
*/
|
||||
char* string_to_upper(const char* string);
|
||||
|
||||
/**
|
||||
* @brief Replace all the occurrences of search value into replace value in
|
||||
* the string.
|
||||
* NOTE: Mutates the string.
|
||||
*
|
||||
* @param string
|
||||
* @param search_value A character search value.
|
||||
* @param replace_value A character containing the text to replace for match.
|
||||
* @return char*
|
||||
*/
|
||||
char* string_replace(const char* string, char search, char replace);
|
||||
void string_to_uppercase(char* string);
|
||||
|
||||
/**
|
||||
* @brief Removes all the occurrences of a character in a string.
|
||||
*
|
||||
* NOTE: Mutates the string.
|
||||
*
|
||||
* @param string
|
||||
* @param search A character search value.
|
||||
*/
|
||||
void string_remove_character(char* string, char search);
|
||||
|
||||
/**
|
||||
* @brief Converts a string to its acronym.
|
||||
|
@ -1,10 +1,15 @@
|
||||
#include "character.h"
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
void character_append(char* string, const char character) {
|
||||
size_t length = string_get_length(string);
|
||||
character_append_at(string, character, length);
|
||||
}
|
||||
|
||||
void character_append(char* string, char character) {
|
||||
size_t length = strlen(string);
|
||||
string[length] = character;
|
||||
void character_append_at(char* string, const char character, const size_t index) {
|
||||
size_t length = string_get_length(string);
|
||||
for (size_t index_string = length; index_string > index; index_string--) {
|
||||
string[index_string] = string[index_string - 1];
|
||||
}
|
||||
string[index] = character;
|
||||
string[length + 1] = '\0';
|
||||
}
|
||||
|
@ -1,6 +1,11 @@
|
||||
#ifndef __CHARACTER__
|
||||
#define __CHARACTER__
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
#include "string.h"
|
||||
|
||||
/**
|
||||
* @brief Append a character to a string, assuming string points to an array
|
||||
* with enough space.
|
||||
@ -10,4 +15,13 @@
|
||||
*/
|
||||
void character_append(char* string, char character);
|
||||
|
||||
/**
|
||||
* @brief Append a character to a string at a specific index, assuming string points to an array with enough space.
|
||||
*
|
||||
* @param string
|
||||
* @param character
|
||||
* @param index
|
||||
*/
|
||||
void character_append_at(char* string, const char character, const size_t index);
|
||||
|
||||
#endif
|
||||
|
@ -1,8 +1,5 @@
|
||||
#include "input.h"
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
#include "character.h"
|
||||
|
||||
char* input() {
|
||||
|
@ -1,6 +1,9 @@
|
||||
#ifndef __INPUT__
|
||||
#define __INPUT__
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
/**
|
||||
* @brief Read a line from stdin.
|
||||
*
|
||||
|
@ -9,8 +9,9 @@ int main() {
|
||||
char* string = input();
|
||||
int shift;
|
||||
scanf("%d", &shift);
|
||||
string = string_caesar_cipher(string, shift);
|
||||
printf("%s\n", string);
|
||||
char* result = string_caesar_cipher(string, shift);
|
||||
printf("%s\n", result);
|
||||
free(string);
|
||||
free(result);
|
||||
return EXIT_SUCCESS;
|
||||
}
|
||||
|
@ -1,24 +1,27 @@
|
||||
#include "string.h"
|
||||
|
||||
#include <stdbool.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
#include "character.h"
|
||||
|
||||
#define ALPHABET_LENGTH 26
|
||||
size_t string_get_length(const char* string) {
|
||||
size_t length = 0;
|
||||
while (string[length] != '\0') {
|
||||
length++;
|
||||
}
|
||||
return length;
|
||||
}
|
||||
|
||||
char* string_shift_alphabet(int shift) {
|
||||
char* result = malloc(sizeof(char) * (ALPHABET_LENGTH + 1));
|
||||
for (char index = 0; index < ALPHABET_LENGTH; index++) {
|
||||
for (size_t index = 0; index < ALPHABET_LENGTH; index++) {
|
||||
char letter = 'A' + index + shift;
|
||||
if (letter < 'A') {
|
||||
letter = 'Z' + shift + index + 1;
|
||||
} else if (letter > 'Z') {
|
||||
letter = letter - ALPHABET_LENGTH;
|
||||
}
|
||||
character_append(result, letter);
|
||||
result[index] = letter;
|
||||
}
|
||||
result[ALPHABET_LENGTH] = '\0';
|
||||
return result;
|
||||
}
|
||||
|
||||
@ -28,8 +31,8 @@ char* string_caesar_cipher(char* string, int shift) {
|
||||
char* shifted_alphabet = string_shift_alphabet(shift);
|
||||
for (size_t index = 0; index < string_length; index++) {
|
||||
char letter = string[index];
|
||||
if (letter != ' ') {
|
||||
for (int index_alphabet = 0; index_alphabet < ALPHABET_LENGTH; index_alphabet++) {
|
||||
if (letter != ' ' && (letter >= 'A' && letter <= 'Z')) {
|
||||
for (size_t index_alphabet = 0; index_alphabet < ALPHABET_LENGTH; index_alphabet++) {
|
||||
char current_letter = 'A' + index_alphabet;
|
||||
if (string[index] == current_letter) {
|
||||
letter = shifted_alphabet[index_alphabet];
|
||||
@ -37,7 +40,9 @@ char* string_caesar_cipher(char* string, int shift) {
|
||||
}
|
||||
}
|
||||
}
|
||||
character_append(result, letter);
|
||||
result[index] = letter;
|
||||
}
|
||||
result[string_length] = '\0';
|
||||
free(shifted_alphabet);
|
||||
return result;
|
||||
}
|
||||
|
@ -1,8 +1,20 @@
|
||||
#ifndef __STRING__
|
||||
#define __STRING__
|
||||
|
||||
#include <stdbool.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
#define ALPHABET_LENGTH 26
|
||||
#define ALPHABET "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
|
||||
|
||||
/**
|
||||
* @brief Return the length of a string (excluding '\0').
|
||||
*
|
||||
* @param string
|
||||
*/
|
||||
size_t string_get_length(const char* string);
|
||||
|
||||
/**
|
||||
* @brief Shift the alphabet by a given amount.
|
||||
*
|
||||
|
@ -1,20 +1,22 @@
|
||||
#include "character.h"
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
void character_append(char* string, const char character) {
|
||||
size_t length = string_get_length(string);
|
||||
character_append_at(string, character, length);
|
||||
}
|
||||
|
||||
void character_append(char* string, char character) {
|
||||
size_t length = strlen(string);
|
||||
string[length] = character;
|
||||
void character_append_at(char* string, const char character, const size_t index) {
|
||||
size_t length = string_get_length(string);
|
||||
for (size_t index_string = length; index_string > index; index_string--) {
|
||||
string[index_string] = string[index_string - 1];
|
||||
}
|
||||
string[index] = character;
|
||||
string[length + 1] = '\0';
|
||||
}
|
||||
|
||||
char character_to_upper(char character) {
|
||||
char ascii_a = 'a';
|
||||
char ascii_A = 'A';
|
||||
char ascii_z = 'z';
|
||||
if (character >= ascii_a && character <= ascii_z) {
|
||||
return character + (ascii_A - ascii_a);
|
||||
char character_to_upper(const char character) {
|
||||
if (character >= 'a' && character <= 'z') {
|
||||
return character + ('A' - 'a');
|
||||
}
|
||||
return character;
|
||||
}
|
||||
|
@ -1,6 +1,12 @@
|
||||
#ifndef __CHARACTER__
|
||||
#define __CHARACTER__
|
||||
|
||||
#include <errno.h>
|
||||
#include <stdbool.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
#include "string.h"
|
||||
|
||||
/**
|
||||
* @brief Append a character to a string, assuming string points to an array
|
||||
* with enough space.
|
||||
@ -10,12 +16,20 @@
|
||||
*/
|
||||
void character_append(char* string, char character);
|
||||
|
||||
/**
|
||||
* @brief Append a character to a string at a specific index, assuming string points to an array with enough space.
|
||||
*
|
||||
* @param string
|
||||
* @param character
|
||||
* @param index
|
||||
*/
|
||||
void character_append_at(char* string, const char character, const size_t index);
|
||||
|
||||
/**
|
||||
* @brief Converts the character to uppercase.
|
||||
*
|
||||
* @param character
|
||||
* @return char
|
||||
*/
|
||||
char character_to_upper(char character);
|
||||
char character_to_upper(const char character);
|
||||
|
||||
#endif
|
||||
|
@ -1,10 +1,5 @@
|
||||
#include "input.h"
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
#include "character.h"
|
||||
|
||||
char* input() {
|
||||
char character;
|
||||
size_t length = 1;
|
||||
|
@ -1,6 +1,11 @@
|
||||
#ifndef __INPUT__
|
||||
#define __INPUT__
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
#include "character.h"
|
||||
|
||||
/**
|
||||
* @brief Read a line from stdin.
|
||||
*
|
||||
|
@ -7,9 +7,10 @@
|
||||
|
||||
int main() {
|
||||
char* string = input();
|
||||
string = string_trim(string);
|
||||
string = string_camelCase(string);
|
||||
printf("%s\n", string);
|
||||
string_trim(string, ' ');
|
||||
char* result = string_camelCase(string);
|
||||
printf("%s\n", result);
|
||||
free(string);
|
||||
free(result);
|
||||
return EXIT_SUCCESS;
|
||||
}
|
||||
|
@ -1,66 +1,73 @@
|
||||
#include "string.h"
|
||||
|
||||
#include <stdbool.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
size_t string_get_length(const char* string) {
|
||||
size_t length = 0;
|
||||
while (string[length] != '\0') {
|
||||
length++;
|
||||
}
|
||||
return length;
|
||||
}
|
||||
|
||||
#include "character.h"
|
||||
|
||||
char* string_trim_start(char* string) {
|
||||
size_t string_length = strlen(string);
|
||||
char* result = malloc(sizeof(char) * (string_length + 1));
|
||||
void string_trim_start(char* string, char character) {
|
||||
size_t string_length = string_get_length(string);
|
||||
size_t index_space = 0;
|
||||
while (string[index_space] == ' ') {
|
||||
while (string[index_space] == character) {
|
||||
index_space++;
|
||||
}
|
||||
for (size_t index = index_space; index < string_length; index++) {
|
||||
character_append(result, string[index]);
|
||||
for (size_t index = 0; index < string_length - index_space; index++) {
|
||||
string[index] = string[index + index_space];
|
||||
}
|
||||
return result;
|
||||
string[string_length - index_space] = '\0';
|
||||
}
|
||||
|
||||
char* string_trim_end(char* string) {
|
||||
size_t string_length = strlen(string);
|
||||
char* result = malloc(sizeof(char) * (string_length + 1));
|
||||
void string_trim_end(char* string, char character) {
|
||||
size_t string_length = string_get_length(string);
|
||||
size_t index_space = string_length - 1;
|
||||
while (string[index_space] == ' ') {
|
||||
while (string[index_space] == character) {
|
||||
index_space--;
|
||||
}
|
||||
for (size_t index = 0; index < index_space + 1; index++) {
|
||||
character_append(result, string[index]);
|
||||
}
|
||||
return result;
|
||||
string[index_space + 1] = '\0';
|
||||
}
|
||||
|
||||
char* string_trim(char* string) {
|
||||
char* result = string_trim_start(string);
|
||||
result = string_trim_end(result);
|
||||
return result;
|
||||
void string_trim(char* string, char character) {
|
||||
string_trim_start(string, character);
|
||||
string_trim_end(string, character);
|
||||
}
|
||||
|
||||
char* string_capitalize(char* string) {
|
||||
size_t string_length = strlen(string);
|
||||
if (string_length > 0) {
|
||||
void string_capitalize(char* string) {
|
||||
size_t string_length = string_get_length(string);
|
||||
if (string_length == 0) {
|
||||
return;
|
||||
}
|
||||
string[0] = character_to_upper(string[0]);
|
||||
}
|
||||
return string;
|
||||
}
|
||||
|
||||
char* string_camelCase(char* string) {
|
||||
size_t string_length = strlen(string);
|
||||
size_t string_length = string_get_length(string);
|
||||
char* result = malloc(sizeof(char) * (string_length + 1));
|
||||
int words = 0;
|
||||
result[0] = '\0';
|
||||
size_t words = 0;
|
||||
char* current = malloc(sizeof(char) * (string_length + 1));
|
||||
size_t current_index = 0;
|
||||
for (size_t index = 0; index < string_length; index++) {
|
||||
if (string[index] == ' ') {
|
||||
strcat(result, words == 0 ? current : string_capitalize(current));
|
||||
current[current_index] = '\0';
|
||||
if (words > 0) {
|
||||
string_capitalize(current);
|
||||
}
|
||||
strcat(result, current);
|
||||
memset(current, 0, sizeof(char) * (string_length + 1));
|
||||
words++;
|
||||
current_index = 0;
|
||||
words += 1;
|
||||
} else {
|
||||
character_append(current, string[index]);
|
||||
current[current_index] = string[index];
|
||||
current_index += 1;
|
||||
}
|
||||
}
|
||||
strcat(result, words == 0 ? current : string_capitalize(current));
|
||||
if (words > 0) {
|
||||
string_capitalize(current);
|
||||
strcat(result, current);
|
||||
}
|
||||
free(current);
|
||||
return result;
|
||||
}
|
||||
|
@ -1,29 +1,46 @@
|
||||
#ifndef __STRING__
|
||||
#define __STRING__
|
||||
|
||||
/**
|
||||
* @brief Removes all whitespace from the start of a string.
|
||||
*
|
||||
* @param string
|
||||
* @return char*
|
||||
*/
|
||||
char* string_trim_start(char* string);
|
||||
#include <stdbool.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
#include "character.h"
|
||||
|
||||
/**
|
||||
* @brief Removes all whitespace from the end of a string.
|
||||
* @brief Return the length of a string (excluding '\0').
|
||||
*
|
||||
* @param string
|
||||
* @return char*
|
||||
* @return size_t
|
||||
*/
|
||||
char* string_trim_end(char* string);
|
||||
size_t string_get_length(const char* string);
|
||||
|
||||
/**
|
||||
* @brief Removes all whitespace from the start and end of a string.
|
||||
* @brief Removes all `character` from the start of a string.
|
||||
*
|
||||
* NOTE: Mutates the string.
|
||||
*
|
||||
* @param string
|
||||
* @return char*
|
||||
*/
|
||||
char* string_trim(char* string);
|
||||
void string_trim_start(char* string, char character);
|
||||
|
||||
/**
|
||||
* @brief Removes all `character` from the end of a string.
|
||||
*
|
||||
* NOTE: Mutates the string.
|
||||
*
|
||||
* @param string
|
||||
*/
|
||||
void string_trim_end(char* string, char character);
|
||||
|
||||
/**
|
||||
* @brief Removes all `character` from the start and end of a string.
|
||||
*
|
||||
* NOTE: Mutates the string.
|
||||
*
|
||||
* @param string
|
||||
*/
|
||||
void string_trim(char* string, char character);
|
||||
|
||||
/**
|
||||
* @brief Converts a string to camel case.
|
||||
@ -36,9 +53,10 @@ char* string_camelCase(char* string);
|
||||
/**
|
||||
* @brief Capitalizes the string.
|
||||
*
|
||||
* NOTE: Mutates the string.
|
||||
*
|
||||
* @param string
|
||||
* @return char*
|
||||
*/
|
||||
char* string_capitalize(char* string);
|
||||
void string_capitalize(char* string);
|
||||
|
||||
#endif
|
||||
|
@ -1,8 +1,5 @@
|
||||
#include "character.h"
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
void character_append(char* string, char character) {
|
||||
size_t length = strlen(string);
|
||||
string[length] = character;
|
||||
|
@ -1,6 +1,9 @@
|
||||
#ifndef __CHARACTER__
|
||||
#define __CHARACTER__
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
/**
|
||||
* @brief Append a character to a string, assuming string points to an array
|
||||
* with enough space.
|
||||
|
@ -1,10 +1,5 @@
|
||||
#include "input.h"
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
#include "character.h"
|
||||
|
||||
char* input() {
|
||||
char character;
|
||||
size_t length = 1;
|
||||
|
@ -1,6 +1,11 @@
|
||||
#ifndef __INPUT__
|
||||
#define __INPUT__
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
#include "character.h"
|
||||
|
||||
/**
|
||||
* @brief Read a line from stdin.
|
||||
*
|
||||
|
@ -1,8 +1,5 @@
|
||||
#include "character.h"
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
void character_append(char* string, char character) {
|
||||
size_t length = strlen(string);
|
||||
string[length] = character;
|
||||
|
@ -1,6 +1,9 @@
|
||||
#ifndef __CHARACTER__
|
||||
#define __CHARACTER__
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
/**
|
||||
* @brief Append a character to a string, assuming string points to an array
|
||||
* with enough space.
|
||||
|
@ -1,10 +1,5 @@
|
||||
#include "input.h"
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
#include "character.h"
|
||||
|
||||
char* input() {
|
||||
char character;
|
||||
size_t length = 1;
|
||||
|
@ -1,6 +1,11 @@
|
||||
#ifndef __INPUT__
|
||||
#define __INPUT__
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
#include "character.h"
|
||||
|
||||
/**
|
||||
* @brief Read a line from stdin.
|
||||
*
|
||||
|
@ -4,15 +4,11 @@
|
||||
|
||||
#include "input.h"
|
||||
|
||||
int math_power(int base, int power) {
|
||||
int result = 1;
|
||||
for (int iteration = 0; iteration < power; iteration++) {
|
||||
result = result * base;
|
||||
}
|
||||
return result;
|
||||
unsigned long long mathematics_pow(unsigned long long base, unsigned long long exponent) {
|
||||
return exponent == 0 ? 1 : base * mathematics_pow(base, exponent - 1);
|
||||
}
|
||||
|
||||
char* convert_from_base_10_to_base(unsigned long number, unsigned int base) {
|
||||
char* convert_number_from_base_10_to_base(unsigned long long number, unsigned long base) {
|
||||
if (number == 0) {
|
||||
return "0";
|
||||
}
|
||||
@ -34,13 +30,14 @@ char* convert_from_base_10_to_base(unsigned long number, unsigned int base) {
|
||||
}
|
||||
index_result++;
|
||||
}
|
||||
result[index_result] = '\0';
|
||||
return result;
|
||||
}
|
||||
|
||||
int convert_from_base_to_base_10(char* number, unsigned int base) {
|
||||
int length = strlen(number);
|
||||
unsigned long convert_number_from_base_to_base_10(char* number, unsigned long base) {
|
||||
size_t length = strlen(number);
|
||||
int exponent = length - 1;
|
||||
int result = 0;
|
||||
unsigned long result = 0;
|
||||
int index = 0;
|
||||
while (exponent >= 0) {
|
||||
int current_number = (int)(number[index] - '0');
|
||||
@ -49,19 +46,26 @@ int convert_from_base_to_base_10(char* number, unsigned int base) {
|
||||
} else {
|
||||
current_number = (int)(number[index] - '0');
|
||||
}
|
||||
result = result + current_number * math_power(base, exponent);
|
||||
result = result + current_number * mathematics_pow(base, exponent);
|
||||
exponent--;
|
||||
index++;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
char* convert_number_from_base_to_another(char* number, unsigned long base_from, unsigned long base_target) {
|
||||
return convert_number_from_base_10_to_base(convert_number_from_base_to_base_10(number, base_from), base_target);
|
||||
}
|
||||
|
||||
int main() {
|
||||
char* number = input();
|
||||
int base_from;
|
||||
int base_target;
|
||||
scanf("%d", &base_from);
|
||||
scanf("%d", &base_target);
|
||||
printf("%s\n", convert_from_base_10_to_base(convert_from_base_to_base_10(number, base_from), base_target));
|
||||
unsigned long base_from;
|
||||
unsigned long base_target;
|
||||
scanf("%lu", &base_from);
|
||||
scanf("%lu", &base_target);
|
||||
char* result = convert_number_from_base_to_another(number, base_from, base_target);
|
||||
printf("%s\n", result);
|
||||
free(number);
|
||||
free(result);
|
||||
return EXIT_SUCCESS;
|
||||
}
|
||||
|
@ -1,13 +1,13 @@
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
int fibonacci(int number) {
|
||||
unsigned long fibonacci(unsigned long number) {
|
||||
return number < 2 ? number : fibonacci(number - 1) + fibonacci(number - 2);
|
||||
}
|
||||
|
||||
int main() {
|
||||
int number;
|
||||
scanf("%d", &number);
|
||||
printf("%d\n", fibonacci(number));
|
||||
unsigned long number;
|
||||
scanf("%lu", &number);
|
||||
printf("%lu\n", fibonacci(number));
|
||||
return EXIT_SUCCESS;
|
||||
}
|
||||
|
@ -1,8 +1,5 @@
|
||||
#include "character.h"
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
void character_append(char* string, char character) {
|
||||
size_t length = strlen(string);
|
||||
string[length] = character;
|
||||
|
@ -1,6 +1,9 @@
|
||||
#ifndef __CHARACTER__
|
||||
#define __CHARACTER__
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
/**
|
||||
* @brief Append a character to a string, assuming string points to an array
|
||||
* with enough space.
|
||||
|
@ -1,10 +1,5 @@
|
||||
#include "input.h"
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
#include "character.h"
|
||||
|
||||
char* input() {
|
||||
char character;
|
||||
size_t length = 1;
|
||||
|
@ -1,6 +1,11 @@
|
||||
#ifndef __INPUT__
|
||||
#define __INPUT__
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
#include "character.h"
|
||||
|
||||
/**
|
||||
* @brief Read a line from stdin.
|
||||
*
|
||||
|
@ -1,11 +1,5 @@
|
||||
#include "string.h"
|
||||
|
||||
#include <stdbool.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
#include "character.h"
|
||||
|
||||
size_t string_total_occurrences_of_character(char* string, char character) {
|
||||
size_t result = 0;
|
||||
size_t string_length = strlen(string);
|
||||
|
@ -1,7 +1,11 @@
|
||||
#ifndef __STRING__
|
||||
#define __STRING__
|
||||
|
||||
#include <stdbool.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
#include "character.h"
|
||||
|
||||
/**
|
||||
* @brief Returns the total number of occurrences of the given character in the string.
|
||||
|
@ -3,9 +3,9 @@
|
||||
#include <stdlib.h>
|
||||
|
||||
int main() {
|
||||
int length;
|
||||
scanf("%d", &length);
|
||||
for (int number = 1; number <= length; number++) {
|
||||
unsigned long length;
|
||||
scanf("%lu", &length);
|
||||
for (unsigned long number = 1; number <= length; number++) {
|
||||
bool is_divisible_by_3 = number % 3 == 0;
|
||||
bool is_divisible_by_5 = number % 5 == 0;
|
||||
if (is_divisible_by_3 && is_divisible_by_5) {
|
||||
@ -15,7 +15,7 @@ int main() {
|
||||
} else if (is_divisible_by_5) {
|
||||
printf("Buzz\n");
|
||||
} else {
|
||||
printf("%d\n", number);
|
||||
printf("%lu\n", number);
|
||||
}
|
||||
}
|
||||
return EXIT_SUCCESS;
|
||||
|
@ -1,8 +1,5 @@
|
||||
#include "character.h"
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
void character_append(char* string, char character) {
|
||||
size_t length = strlen(string);
|
||||
string[length] = character;
|
||||
|
@ -1,6 +1,9 @@
|
||||
#ifndef __CHARACTER__
|
||||
#define __CHARACTER__
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
/**
|
||||
* @brief Append a character to a string, assuming string points to an array
|
||||
* with enough space.
|
||||
|
@ -1,10 +1,5 @@
|
||||
#include "input.h"
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
#include "character.h"
|
||||
|
||||
char* input() {
|
||||
char character;
|
||||
size_t length = 1;
|
||||
|
@ -1,6 +1,11 @@
|
||||
#ifndef __INPUT__
|
||||
#define __INPUT__
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
#include "character.h"
|
||||
|
||||
/**
|
||||
* @brief Read a line from stdin.
|
||||
*
|
||||
|
@ -1,8 +1,5 @@
|
||||
#include "character.h"
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
void character_append(char* string, char character) {
|
||||
size_t length = strlen(string);
|
||||
string[length] = character;
|
||||
|
@ -1,6 +1,9 @@
|
||||
#ifndef __CHARACTER__
|
||||
#define __CHARACTER__
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
/**
|
||||
* @brief Append a character to a string, assuming string points to an array
|
||||
* with enough space.
|
||||
|
@ -1,10 +1,5 @@
|
||||
#include "input.h"
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
#include "character.h"
|
||||
|
||||
char* input() {
|
||||
char character;
|
||||
size_t length = 1;
|
||||
|
@ -1,6 +1,11 @@
|
||||
#ifndef __INPUT__
|
||||
#define __INPUT__
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
#include "character.h"
|
||||
|
||||
/**
|
||||
* @brief Read a line from stdin.
|
||||
*
|
||||
|
@ -6,5 +6,6 @@
|
||||
int main() {
|
||||
char *string = input();
|
||||
printf("Hello, %s!\n", string);
|
||||
free(string);
|
||||
return EXIT_SUCCESS;
|
||||
}
|
||||
|
@ -1,8 +1,5 @@
|
||||
#include "character.h"
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
void character_append(char* string, char character) {
|
||||
size_t length = strlen(string);
|
||||
string[length] = character;
|
||||
|
@ -1,6 +1,9 @@
|
||||
#ifndef __CHARACTER__
|
||||
#define __CHARACTER__
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
/**
|
||||
* @brief Append a character to a string, assuming string points to an array
|
||||
* with enough space.
|
||||
|
@ -1,10 +1,5 @@
|
||||
#include "input.h"
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
#include "character.h"
|
||||
|
||||
char* input() {
|
||||
char character;
|
||||
size_t length = 1;
|
||||
|
@ -1,6 +1,11 @@
|
||||
#ifndef __INPUT__
|
||||
#define __INPUT__
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
#include "character.h"
|
||||
|
||||
/**
|
||||
* @brief Read a line from stdin.
|
||||
*
|
||||
|
@ -9,8 +9,8 @@
|
||||
|
||||
int main() {
|
||||
char* string = input();
|
||||
string = string_to_upper(string);
|
||||
string = string_replace(string, ' ', '\0');
|
||||
string_to_uppercase(string);
|
||||
string_remove_character(string, ' ');
|
||||
bool is_palindrome = string_is_palindrome(string);
|
||||
free(string);
|
||||
printf("%s\n", is_palindrome ? "true" : "false");
|
||||
|
@ -1,46 +1,67 @@
|
||||
#include "string.h"
|
||||
|
||||
#include <stdbool.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
size_t string_get_length(const char* string) {
|
||||
size_t length = 0;
|
||||
while (string[length] != '\0') {
|
||||
length++;
|
||||
}
|
||||
return length;
|
||||
}
|
||||
|
||||
#include "character.h"
|
||||
|
||||
char* string_to_upper(const char* string) {
|
||||
size_t string_length = strlen(string);
|
||||
char* result = malloc(sizeof(char) * (string_length + 1));
|
||||
void string_to_uppercase(char* string) {
|
||||
size_t string_length = string_get_length(string);
|
||||
for (size_t index = 0; index < string_length; index++) {
|
||||
character_append(result, character_to_upper(string[index]));
|
||||
string[index] = character_to_upper(string[index]);
|
||||
}
|
||||
return result;
|
||||
string[string_length] = '\0';
|
||||
}
|
||||
|
||||
char* string_reverse(const char* string) {
|
||||
size_t string_length = strlen(string);
|
||||
char* result = malloc(sizeof(char) * (string_length + 1));
|
||||
for (int index = string_length - 1; index != -1; index--) {
|
||||
character_append(result, string[index]);
|
||||
void string_remove_character(char* string, char search) {
|
||||
size_t string_length = string_get_length(string);
|
||||
for (size_t index = 0; index < string_length; index++) {
|
||||
if (string[index] == search) {
|
||||
for (size_t index_string = index; index_string < string_length; index_string++) {
|
||||
string[index_string] = string[index_string + 1];
|
||||
}
|
||||
return result;
|
||||
string_length--;
|
||||
index--;
|
||||
}
|
||||
}
|
||||
string[string_length] = '\0';
|
||||
}
|
||||
|
||||
bool string_is_palindrome(const char* string) {
|
||||
char* string_reversed = string_reverse(string);
|
||||
bool is_palindrome = strcmp(string_reversed, string) == 0;
|
||||
char* string_copy(const char* string) {
|
||||
size_t source_length = string_get_length(string);
|
||||
char* copy = malloc(sizeof(char) * (source_length + 1));
|
||||
if (copy == NULL) {
|
||||
perror("Error (string_copy)");
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
size_t index;
|
||||
for (index = 0; index < source_length; index++) {
|
||||
copy[index] = string[index];
|
||||
}
|
||||
copy[index] = '\0';
|
||||
return copy;
|
||||
}
|
||||
|
||||
void string_reverse(char* string) {
|
||||
size_t string_length = string_get_length(string);
|
||||
size_t index_start = 0;
|
||||
size_t index_end = string_length - 1;
|
||||
while (index_start < index_end) {
|
||||
char temporary = string[index_start];
|
||||
string[index_start] = string[index_end];
|
||||
string[index_end] = temporary;
|
||||
index_start++;
|
||||
index_end--;
|
||||
}
|
||||
}
|
||||
|
||||
bool string_is_palindrome(char* string) {
|
||||
char* string_reversed = string_copy(string);
|
||||
string_reverse(string_reversed);
|
||||
bool is_palindrome = strcmp(string, string_reversed) == 0;
|
||||
free(string_reversed);
|
||||
return is_palindrome;
|
||||
}
|
||||
|
||||
char* string_replace(const char* string, char search, char replace) {
|
||||
size_t string_length = strlen(string);
|
||||
char* result = malloc(sizeof(char) * (string_length + 1));
|
||||
for (size_t index = 0; index < string_length; index++) {
|
||||
bool is_search_value = search == string[index];
|
||||
if (is_search_value) {
|
||||
character_append(result, replace);
|
||||
} else {
|
||||
character_append(result, string[index]);
|
||||
}
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
@ -1,23 +1,57 @@
|
||||
#ifndef __STRING__
|
||||
#define __STRING__
|
||||
|
||||
#include <errno.h>
|
||||
#include <stdbool.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
#include "character.h"
|
||||
|
||||
/**
|
||||
* @brief Return the length of a string (excluding '\0').
|
||||
*
|
||||
* @param string
|
||||
* @return size_t
|
||||
*/
|
||||
size_t string_get_length(const char* string);
|
||||
|
||||
/**
|
||||
* @brief Converts all the alphabetic characters in a string to uppercase.
|
||||
*
|
||||
* NOTE: Mutates the string.
|
||||
*
|
||||
* @param string
|
||||
* @return char*
|
||||
*/
|
||||
char* string_to_upper(const char* string);
|
||||
void string_to_uppercase(char* string);
|
||||
|
||||
/**
|
||||
* @brief Reverse the characters in an array.
|
||||
* @brief Removes all the occurrences of a character in a string.
|
||||
*
|
||||
* NOTE: Mutates the string.
|
||||
*
|
||||
* @param string
|
||||
* @param search A character search value.
|
||||
*/
|
||||
void string_remove_character(char* string, char search);
|
||||
|
||||
/**
|
||||
* @brief Reverse the characters in a string.
|
||||
*
|
||||
* NOTE: Mutates the string.
|
||||
*
|
||||
* @param string
|
||||
*/
|
||||
void string_reverse(char* string);
|
||||
|
||||
/**
|
||||
* @brief Return the copy of a string.
|
||||
*
|
||||
* @param string
|
||||
* @return char*
|
||||
*/
|
||||
char* string_reverse(const char* string);
|
||||
char* string_copy(const char* string);
|
||||
|
||||
/**
|
||||
* @brief Returns true if the string is a palindrome (a palindrome is a word,
|
||||
@ -27,17 +61,6 @@ char* string_reverse(const char* string);
|
||||
* @param string The string to check.
|
||||
* @return true if the string is a palindrome, false otherwise.
|
||||
*/
|
||||
bool string_is_palindrome(const char* string);
|
||||
|
||||
/**
|
||||
* @brief Replace all the occurrences of search value into replace value in
|
||||
* the string.
|
||||
*
|
||||
* @param string
|
||||
* @param search_value A character search value.
|
||||
* @param replace_value A character containing the text to replace for match.
|
||||
* @return char*
|
||||
*/
|
||||
char* string_replace(const char* string, char search, char replace);
|
||||
bool string_is_palindrome(char* string);
|
||||
|
||||
#endif
|
||||
|
@ -2,8 +2,8 @@
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
bool is_prime_number(int number) {
|
||||
for (int iteration = 2; iteration < number; iteration++) {
|
||||
bool is_prime_number(unsigned long number) {
|
||||
for (unsigned long iteration = 2; iteration < number; iteration++) {
|
||||
if (number % iteration == 0) {
|
||||
return false;
|
||||
}
|
||||
@ -12,8 +12,8 @@ bool is_prime_number(int number) {
|
||||
}
|
||||
|
||||
int main() {
|
||||
int number;
|
||||
scanf("%d", &number);
|
||||
unsigned long number;
|
||||
scanf("%lu", &number);
|
||||
bool is_prime = is_prime_number(number);
|
||||
printf("%s\n", is_prime ? "true" : "false");
|
||||
return EXIT_SUCCESS;
|
||||
|
@ -1,8 +1,5 @@
|
||||
#include "character.h"
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
void character_append(char* string, char character) {
|
||||
size_t length = strlen(string);
|
||||
string[length] = character;
|
||||
|
@ -1,6 +1,9 @@
|
||||
#ifndef __CHARACTER__
|
||||
#define __CHARACTER__
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
/**
|
||||
* @brief Append a character to a string, assuming string points to an array
|
||||
* with enough space.
|
||||
|
@ -1,10 +1,5 @@
|
||||
#include "input.h"
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
#include "character.h"
|
||||
|
||||
char* input() {
|
||||
char character;
|
||||
size_t length = 1;
|
||||
|
@ -1,6 +1,11 @@
|
||||
#ifndef __INPUT__
|
||||
#define __INPUT__
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
#include "character.h"
|
||||
|
||||
/**
|
||||
* @brief Read a line from stdin.
|
||||
*
|
||||
|
@ -24,5 +24,7 @@ int main() {
|
||||
index += number_of_appearances - 1;
|
||||
}
|
||||
printf("%s\n", result);
|
||||
free(string);
|
||||
free(result);
|
||||
return EXIT_SUCCESS;
|
||||
}
|
||||
|
@ -1,8 +1,5 @@
|
||||
#include "character.h"
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
void character_append(char* string, char character) {
|
||||
size_t length = strlen(string);
|
||||
string[length] = character;
|
||||
|
@ -1,6 +1,9 @@
|
||||
#ifndef __CHARACTER__
|
||||
#define __CHARACTER__
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
/**
|
||||
* @brief Append a character to a string, assuming string points to an array
|
||||
* with enough space.
|
||||
|
@ -1,10 +1,5 @@
|
||||
#include "input.h"
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
#include "character.h"
|
||||
|
||||
char* input() {
|
||||
char character;
|
||||
size_t length = 1;
|
||||
|
@ -1,6 +1,11 @@
|
||||
#ifndef __INPUT__
|
||||
#define __INPUT__
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
#include "character.h"
|
||||
|
||||
/**
|
||||
* @brief Read a line from stdin.
|
||||
*
|
||||
|
@ -1,11 +1,5 @@
|
||||
#include "string.h"
|
||||
|
||||
#include <stdbool.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
#include "character.h"
|
||||
|
||||
bool string_starts_with(char* string, char* prefix) {
|
||||
size_t string_length = strlen(string);
|
||||
size_t prefix_length = strlen(prefix);
|
||||
|
@ -2,6 +2,10 @@
|
||||
#define __STRING__
|
||||
|
||||
#include <stdbool.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
#include "character.h"
|
||||
|
||||
/**
|
||||
* @brief Returns true if the string is a prefix of another string.
|
||||
|
@ -28,8 +28,10 @@ int* get_dividers_list(int number, int* dividers_length) {
|
||||
|
||||
bool is_prime_number(int number) {
|
||||
int dividers_length;
|
||||
get_dividers_list(number, ÷rs_length);
|
||||
return dividers_length == 2;
|
||||
int* dividers_list = get_dividers_list(number, ÷rs_length);
|
||||
bool result = dividers_length == 2;
|
||||
free(dividers_list);
|
||||
return result;
|
||||
}
|
||||
|
||||
int sum_multiply_numbers(int* numbers, int numbers_length) {
|
||||
|
@ -1,9 +1,5 @@
|
||||
#include "character.h"
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
void character_append(char* string, char character) {
|
||||
size_t length = strlen(string);
|
||||
string[length] = character;
|
||||
|
@ -1,7 +1,9 @@
|
||||
#ifndef __CHARACTER__
|
||||
#define __CHARACTER__
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
/**
|
||||
* @brief Append a character to a string, assuming string points to an array
|
||||
|
@ -1,10 +1,5 @@
|
||||
#include "input.h"
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
#include "character.h"
|
||||
|
||||
char* input() {
|
||||
char character;
|
||||
size_t length = 1;
|
||||
|
@ -1,6 +1,11 @@
|
||||
#ifndef __INPUT__
|
||||
#define __INPUT__
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
#include "character.h"
|
||||
|
||||
/**
|
||||
* @brief Read a line from stdin.
|
||||
*
|
||||
|
@ -7,10 +7,10 @@
|
||||
|
||||
int main() {
|
||||
char* type = input();
|
||||
int height;
|
||||
scanf("%d", &height);
|
||||
unsigned long height;
|
||||
scanf("%lu", &height);
|
||||
|
||||
int step = strcmp(type, "normal") == 0 ? 1 : height;
|
||||
unsigned long step = strcmp(type, "normal") == 0 ? 1 : height;
|
||||
while ((strcmp(type, "normal") == 0 && step <= height) || (strcmp(type, "reverse") == 0 && step != 0)) {
|
||||
size_t numberOfStars = (step * 2) - 1;
|
||||
size_t totalNumberOfLocations = (height * 2) - 1;
|
||||
@ -23,5 +23,6 @@ int main() {
|
||||
step = strcmp(type, "normal") == 0 ? step + 1 : step - 1;
|
||||
}
|
||||
|
||||
free(type);
|
||||
return EXIT_SUCCESS;
|
||||
}
|
||||
|
@ -1,8 +1,5 @@
|
||||
#include "character.h"
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
void character_append(char* string, char character) {
|
||||
size_t length = strlen(string);
|
||||
string[length] = character;
|
||||
|
@ -1,6 +1,9 @@
|
||||
#ifndef __CHARACTER__
|
||||
#define __CHARACTER__
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
/**
|
||||
* @brief Append a character to a string, assuming string points to an array
|
||||
* with enough space.
|
||||
|
@ -1,10 +1,5 @@
|
||||
#include "input.h"
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
#include "character.h"
|
||||
|
||||
char* input() {
|
||||
char character;
|
||||
size_t length = 1;
|
||||
|
@ -1,6 +1,11 @@
|
||||
#ifndef __INPUT__
|
||||
#define __INPUT__
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
#include "character.h"
|
||||
|
||||
/**
|
||||
* @brief Read a line from stdin.
|
||||
*
|
||||
|
@ -20,7 +20,7 @@ bool is_integer(char* string) {
|
||||
|
||||
int main() {
|
||||
char* string = input();
|
||||
struct Stack* stack = stack_initialization();
|
||||
struct stack* stack = stack_initialization();
|
||||
char* token = strtok(string, " ");
|
||||
while (token != NULL) {
|
||||
if (is_integer(token)) {
|
||||
@ -45,5 +45,7 @@ int main() {
|
||||
token = strtok(NULL, " ");
|
||||
}
|
||||
printf("%ld\n", (intptr_t)stack_pop(stack));
|
||||
free(string);
|
||||
stack_free(stack);
|
||||
return EXIT_SUCCESS;
|
||||
}
|
||||
|
@ -1,11 +1,9 @@
|
||||
#include "stack.h"
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
struct Stack *stack_initialization() {
|
||||
struct Stack *stack = malloc(sizeof(*stack));
|
||||
struct stack *stack_initialization() {
|
||||
struct stack *stack = malloc(sizeof(struct stack));
|
||||
if (stack == NULL) {
|
||||
perror("Error (stack_initialization)");
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
stack->first = NULL;
|
||||
@ -13,9 +11,15 @@ struct Stack *stack_initialization() {
|
||||
return stack;
|
||||
}
|
||||
|
||||
void stack_push(struct Stack *stack, void *data) {
|
||||
struct Node *node_new = malloc(sizeof(*node_new));
|
||||
if (stack == NULL || data == NULL) {
|
||||
void stack_push(struct stack *stack, void *data) {
|
||||
if (stack == NULL) {
|
||||
errno = EINVAL;
|
||||
perror("Error (stack_push)");
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
struct stack_node *node_new = malloc(sizeof(struct stack_node));
|
||||
if (data == NULL) {
|
||||
perror("Error (stack_push)");
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
node_new->data = data;
|
||||
@ -24,11 +28,13 @@ void stack_push(struct Stack *stack, void *data) {
|
||||
stack->length = stack->length + 1;
|
||||
}
|
||||
|
||||
void *stack_pop(struct Stack *stack) {
|
||||
void *stack_pop(struct stack *stack) {
|
||||
if (stack == NULL) {
|
||||
errno = EINVAL;
|
||||
perror("Error (stack_pop)");
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
struct Node *node = stack->first;
|
||||
struct stack_node *node = stack->first;
|
||||
void *data = NULL;
|
||||
if (node != NULL) {
|
||||
stack->first = node->next;
|
||||
@ -38,3 +44,18 @@ void *stack_pop(struct Stack *stack) {
|
||||
stack->length = stack->length - 1;
|
||||
return data;
|
||||
}
|
||||
|
||||
void stack_free(struct stack *stack) {
|
||||
if (stack == NULL) {
|
||||
errno = EINVAL;
|
||||
perror("Error (stack_free)");
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
struct stack_node *node = stack->first;
|
||||
while (node != NULL) {
|
||||
struct stack_node *node_next = node->next;
|
||||
free(node);
|
||||
node = node_next;
|
||||
}
|
||||
free(stack);
|
||||
}
|
||||
|
@ -1,23 +1,54 @@
|
||||
#ifndef __STACK__
|
||||
#define __STACK__
|
||||
|
||||
#include <errno.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
// LIFO = Last In First Out
|
||||
struct Stack {
|
||||
struct Node *first;
|
||||
/**
|
||||
* @brief Stack structure => LIFO (Last In First Out).
|
||||
*/
|
||||
struct stack {
|
||||
struct stack_node *first;
|
||||
size_t length;
|
||||
};
|
||||
|
||||
struct Node {
|
||||
/**
|
||||
* @brief Stack node structure.
|
||||
*/
|
||||
struct stack_node {
|
||||
void *data;
|
||||
struct Node *next;
|
||||
struct stack_node *next;
|
||||
};
|
||||
|
||||
struct Stack *stack_initialization();
|
||||
/**
|
||||
* @brief Stack initialization.
|
||||
*
|
||||
* @return struct stack*
|
||||
*/
|
||||
struct stack *stack_initialization();
|
||||
|
||||
void stack_push(struct Stack *stack, void *data);
|
||||
/**
|
||||
* @brief Push data to stack.
|
||||
*
|
||||
* @param stack
|
||||
* @param data
|
||||
*/
|
||||
void stack_push(struct stack *stack, void *data);
|
||||
|
||||
void *stack_pop(struct Stack *stack);
|
||||
/**
|
||||
* @brief Pop data from stack.
|
||||
*
|
||||
* @param stack
|
||||
* @return void*
|
||||
*/
|
||||
void *stack_pop(struct stack *stack);
|
||||
|
||||
/**
|
||||
* @brief Frees the stack.
|
||||
*
|
||||
* @param stack
|
||||
*/
|
||||
void stack_free(struct stack *stack);
|
||||
|
||||
#endif
|
||||
|
@ -1,16 +1,10 @@
|
||||
#include "array_2D_int.h"
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
#include "character.h"
|
||||
|
||||
void array_2D_int_print(int **array, size_t number_of_rows, size_t number_of_columns) {
|
||||
for (size_t i = 0; i < number_of_rows; i++) {
|
||||
for (size_t j = 0; j < number_of_columns; j++) {
|
||||
printf("%d", array[i][j]);
|
||||
if (j != number_of_columns - 1) {
|
||||
for (size_t row = 0; row < number_of_rows; row++) {
|
||||
for (size_t column = 0; column < number_of_columns; column++) {
|
||||
printf("%d", array[row][column]);
|
||||
if (column != number_of_columns - 1) {
|
||||
printf(" ");
|
||||
}
|
||||
}
|
||||
@ -19,7 +13,7 @@ void array_2D_int_print(int **array, size_t number_of_rows, size_t number_of_col
|
||||
}
|
||||
|
||||
int **array_2D_int_input(size_t *number_of_rows, size_t *number_of_columns) {
|
||||
int **array = malloc(sizeof(int *));
|
||||
int **array = malloc(sizeof(int));
|
||||
*number_of_rows = 1;
|
||||
*number_of_columns = 1;
|
||||
array[0] = malloc(*number_of_columns * sizeof(int));
|
||||
@ -60,13 +54,13 @@ int **array_2D_int_input(size_t *number_of_rows, size_t *number_of_columns) {
|
||||
}
|
||||
|
||||
int **array_2D_int_reverse_rows(int **array, size_t *number_of_rows, size_t *number_of_columns) {
|
||||
int **rotated_array = malloc(*number_of_columns * sizeof(int *));
|
||||
for (size_t i = 0; i < *number_of_columns; i++) {
|
||||
rotated_array[i] = malloc(*number_of_rows * sizeof(int));
|
||||
int **rotated_array = malloc(*number_of_rows * sizeof(int));
|
||||
for (size_t row = 0; row < *number_of_rows; row++) {
|
||||
rotated_array[row] = malloc(*number_of_columns * sizeof(int));
|
||||
}
|
||||
for (size_t i = 0; i < *number_of_columns; i++) {
|
||||
for (size_t j = 0; j < *number_of_rows; j++) {
|
||||
rotated_array[i][j] = array[*number_of_rows - i - 1][j];
|
||||
for (size_t row = 0; row < *number_of_columns; row++) {
|
||||
for (size_t column = 0; column < *number_of_rows; column++) {
|
||||
rotated_array[row][column] = array[*number_of_rows - row - 1][column];
|
||||
}
|
||||
}
|
||||
return rotated_array;
|
||||
@ -74,12 +68,12 @@ int **array_2D_int_reverse_rows(int **array, size_t *number_of_rows, size_t *num
|
||||
|
||||
int **array_2D_int_rotate_90_degrees_clockwise(int **array, size_t *number_of_rows, size_t *number_of_columns) {
|
||||
int **rotated_array = malloc(*number_of_columns * sizeof(int *));
|
||||
for (size_t i = 0; i < *number_of_columns; i++) {
|
||||
rotated_array[i] = malloc(*number_of_rows * sizeof(int));
|
||||
for (size_t row = 0; row < *number_of_columns; row++) {
|
||||
rotated_array[row] = malloc(*number_of_rows * sizeof(int));
|
||||
}
|
||||
for (size_t i = 0; i < *number_of_columns; i++) {
|
||||
for (size_t j = 0; j < *number_of_rows; j++) {
|
||||
rotated_array[i][j] = array[*number_of_rows - j - 1][i];
|
||||
for (size_t row = 0; row < *number_of_columns; row++) {
|
||||
for (size_t column = 0; column < *number_of_rows; column++) {
|
||||
rotated_array[row][column] = array[*number_of_rows - column - 1][row];
|
||||
}
|
||||
}
|
||||
size_t number_of_rows_temp = *number_of_rows;
|
||||
@ -89,9 +83,28 @@ int **array_2D_int_rotate_90_degrees_clockwise(int **array, size_t *number_of_ro
|
||||
}
|
||||
|
||||
int **array_2D_int_rotate_90_degrees_anticlockwise(int **array, size_t *number_of_rows, size_t *number_of_columns) {
|
||||
int **result = array_2D_int_rotate_90_degrees_clockwise(array, number_of_rows, number_of_columns);
|
||||
result = array_2D_int_rotate_90_degrees_clockwise(result, number_of_rows, number_of_columns);
|
||||
result = array_2D_int_rotate_90_degrees_clockwise(result, number_of_rows, number_of_columns);
|
||||
result = array_2D_int_reverse_rows(result, number_of_rows, number_of_columns);
|
||||
return result;
|
||||
int **result_1 = array_2D_int_rotate_90_degrees_clockwise(array, number_of_rows, number_of_columns);
|
||||
size_t number_of_rows_temp = *number_of_rows;
|
||||
|
||||
int **result_2 = array_2D_int_rotate_90_degrees_clockwise(result_1, number_of_rows, number_of_columns);
|
||||
for (size_t row = 0; row < number_of_rows_temp; row++) {
|
||||
free(result_1[row]);
|
||||
}
|
||||
free(result_1);
|
||||
number_of_rows_temp = *number_of_rows;
|
||||
|
||||
int **result_3 = array_2D_int_rotate_90_degrees_clockwise(result_2, number_of_rows, number_of_columns);
|
||||
for (size_t row = 0; row < number_of_rows_temp; row++) {
|
||||
free(result_2[row]);
|
||||
}
|
||||
free(result_2);
|
||||
number_of_rows_temp = *number_of_rows;
|
||||
|
||||
int **result_4 = array_2D_int_reverse_rows(result_3, number_of_rows, number_of_columns);
|
||||
for (size_t row = 0; row < number_of_rows_temp; row++) {
|
||||
free(result_3[row]);
|
||||
}
|
||||
free(result_3);
|
||||
|
||||
return result_4;
|
||||
}
|
||||
|
@ -1,7 +1,11 @@
|
||||
#ifndef __ARRAY_2D_INT__
|
||||
#define __ARRAY_2D_INT__
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
#include "character.h"
|
||||
|
||||
/**
|
||||
* @brief Prints a 2D array of integers.
|
||||
|
@ -1,8 +1,5 @@
|
||||
#include "character.h"
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
void character_append(char* string, char character) {
|
||||
size_t length = strlen(string);
|
||||
string[length] = character;
|
||||
|
@ -1,6 +1,9 @@
|
||||
#ifndef __CHARACTER__
|
||||
#define __CHARACTER__
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
/**
|
||||
* @brief Append a character to a string, assuming string points to an array
|
||||
* with enough space.
|
||||
|
@ -1,10 +1,5 @@
|
||||
#include "input.h"
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
#include "character.h"
|
||||
|
||||
char* input() {
|
||||
char character;
|
||||
size_t length = 1;
|
||||
|
@ -1,6 +1,11 @@
|
||||
#ifndef __INPUT__
|
||||
#define __INPUT__
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
#include "character.h"
|
||||
|
||||
/**
|
||||
* @brief Read a line from stdin.
|
||||
*
|
||||
|
@ -8,19 +8,20 @@ int main() {
|
||||
size_t number_of_rows = 0;
|
||||
size_t number_of_columns = 0;
|
||||
char *direction = input();
|
||||
int **array = array_2D_int_input(&number_of_rows, &number_of_columns);
|
||||
int **array_input = array_2D_int_input(&number_of_rows, &number_of_columns);
|
||||
|
||||
int **array;
|
||||
if (strcmp(direction, "clockwise") == 0) {
|
||||
array = array_2D_int_rotate_90_degrees_clockwise(array, &number_of_rows, &number_of_columns);
|
||||
array = array_2D_int_rotate_90_degrees_clockwise(array_input, &number_of_rows, &number_of_columns);
|
||||
} else {
|
||||
array = array_2D_int_rotate_90_degrees_anticlockwise(array, &number_of_rows, &number_of_columns);
|
||||
array = array_2D_int_rotate_90_degrees_anticlockwise(array_input, &number_of_rows, &number_of_columns);
|
||||
}
|
||||
array_2D_int_print(array, number_of_rows, number_of_columns);
|
||||
|
||||
for (size_t i = 0; i < number_of_rows; i++) {
|
||||
free(array[i]);
|
||||
free(direction);
|
||||
for (size_t row = 0; row < number_of_rows; row++) {
|
||||
free(array[row]);
|
||||
}
|
||||
free(array);
|
||||
free(direction);
|
||||
return EXIT_SUCCESS;
|
||||
}
|
||||
|
@ -1,9 +1,5 @@
|
||||
#include "character.h"
|
||||
|
||||
#include <stdbool.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
void character_append(char* string, char character) {
|
||||
size_t length = strlen(string);
|
||||
string[length] = character;
|
||||
|
@ -2,6 +2,8 @@
|
||||
#define __CHARACTER__
|
||||
|
||||
#include <stdbool.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
/**
|
||||
* @brief Append a character to a string, assuming string points to an array
|
||||
|
@ -1,10 +1,5 @@
|
||||
#include "input.h"
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
#include "character.h"
|
||||
|
||||
char* input() {
|
||||
char character;
|
||||
size_t length = 1;
|
||||
|
@ -1,6 +1,11 @@
|
||||
#ifndef __INPUT__
|
||||
#define __INPUT__
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
#include "character.h"
|
||||
|
||||
/**
|
||||
* @brief Read a line from stdin.
|
||||
*
|
||||
|
@ -7,11 +7,12 @@
|
||||
|
||||
int main() {
|
||||
char* string = input();
|
||||
string = string_trim(string, ' ');
|
||||
string = string_trim(string, '-');
|
||||
string = string_to_lowercase(string);
|
||||
string = string_slugify(string);
|
||||
printf("%s\n", string);
|
||||
string_trim(string, ' ');
|
||||
string_trim(string, '-');
|
||||
string_to_lowercase(string);
|
||||
char* result = string_slugify(string);
|
||||
printf("%s\n", result);
|
||||
free(string);
|
||||
free(result);
|
||||
return EXIT_SUCCESS;
|
||||
}
|
||||
|
@ -1,66 +1,67 @@
|
||||
#include "string.h"
|
||||
|
||||
#include <stdbool.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
size_t string_get_length(const char* string) {
|
||||
size_t length = 0;
|
||||
while (string[length] != '\0') {
|
||||
length++;
|
||||
}
|
||||
return length;
|
||||
}
|
||||
|
||||
#include "character.h"
|
||||
void string_to_lowercase(char* string) {
|
||||
size_t string_length = string_get_length(string);
|
||||
for (size_t index = 0; index < string_length; index++) {
|
||||
string[index] = character_to_lower(string[index]);
|
||||
}
|
||||
string[string_length] = '\0';
|
||||
}
|
||||
|
||||
char* string_trim_start(char* string, char character) {
|
||||
size_t string_length = strlen(string);
|
||||
char* result = malloc(sizeof(char) * (string_length + 1));
|
||||
void string_trim_start(char* string, char character) {
|
||||
size_t string_length = string_get_length(string);
|
||||
size_t index_space = 0;
|
||||
while (string[index_space] == character) {
|
||||
index_space++;
|
||||
}
|
||||
for (size_t index = index_space; index < string_length; index++) {
|
||||
character_append(result, string[index]);
|
||||
for (size_t index = 0; index < string_length - index_space; index++) {
|
||||
string[index] = string[index + index_space];
|
||||
}
|
||||
return result;
|
||||
string[string_length - index_space] = '\0';
|
||||
}
|
||||
|
||||
char* string_trim_end(char* string, char character) {
|
||||
size_t string_length = strlen(string);
|
||||
char* result = malloc(sizeof(char) * (string_length + 1));
|
||||
void string_trim_end(char* string, char character) {
|
||||
size_t string_length = string_get_length(string);
|
||||
size_t index_space = string_length - 1;
|
||||
while (string[index_space] == character) {
|
||||
index_space--;
|
||||
}
|
||||
for (size_t index = 0; index < index_space + 1; index++) {
|
||||
character_append(result, string[index]);
|
||||
}
|
||||
return result;
|
||||
string[index_space + 1] = '\0';
|
||||
}
|
||||
|
||||
char* string_trim(char* string, char character) {
|
||||
char* result = string_trim_start(string, character);
|
||||
result = string_trim_end(result, character);
|
||||
return result;
|
||||
}
|
||||
|
||||
char* string_to_lowercase(char* string) {
|
||||
size_t string_length = strlen(string);
|
||||
char* result = malloc(sizeof(char) * (string_length + 1));
|
||||
for (size_t index = 0; index < string_length; index++) {
|
||||
character_append(result, character_to_lower(string[index]));
|
||||
}
|
||||
return result;
|
||||
void string_trim(char* string, char character) {
|
||||
string_trim_start(string, character);
|
||||
string_trim_end(string, character);
|
||||
}
|
||||
|
||||
char* string_slugify(char* string) {
|
||||
size_t string_length = strlen(string);
|
||||
char* result = malloc(sizeof(char) * (string_length + 1));
|
||||
int words = 0;
|
||||
result[0] = '\0';
|
||||
size_t words = 0;
|
||||
char* current = malloc(sizeof(char) * (string_length + 1));
|
||||
current[0] = '\0';
|
||||
size_t current_index = 0;
|
||||
for (size_t index = 0; index < string_length; index++) {
|
||||
if (string[index] == ' ' || (string[index] == '-' && strlen(current) > 0)) {
|
||||
strcat(result, current);
|
||||
character_append(result, '-');
|
||||
memset(current, 0, sizeof(char) * (string_length + 1));
|
||||
words++;
|
||||
current_index = 0;
|
||||
words += 1;
|
||||
} else {
|
||||
if (character_is_alphanumeric(string[index])) {
|
||||
character_append(current, string[index]);
|
||||
current[current_index] = string[index];
|
||||
current_index += 1;
|
||||
current[current_index] = '\0';
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -1,37 +1,55 @@
|
||||
#ifndef __STRING__
|
||||
#define __STRING__
|
||||
|
||||
/**
|
||||
* @brief Removes all `character` from the start of a string.
|
||||
*
|
||||
* @param string
|
||||
* @return char*
|
||||
*/
|
||||
char* string_trim_start(char* string, char character);
|
||||
#include <stdbool.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
#include "character.h"
|
||||
|
||||
/**
|
||||
* @brief Removes all `character` from the end of a string.
|
||||
* @brief Return the length of a string (excluding '\0').
|
||||
*
|
||||
* @param string
|
||||
* @return char*
|
||||
* @return size_t
|
||||
*/
|
||||
char* string_trim_end(char* string, char character);
|
||||
|
||||
/**
|
||||
* @brief Removes all `character` from the start and end of a string.
|
||||
*
|
||||
* @param string
|
||||
* @return char*
|
||||
*/
|
||||
char* string_trim(char* string, char character);
|
||||
size_t string_get_length(const char* string);
|
||||
|
||||
/**
|
||||
* @brief Converts all the alphabetic characters in a string to lowercase.
|
||||
*
|
||||
* NOTE: Mutates the string.
|
||||
*
|
||||
* @param string
|
||||
* @return char*
|
||||
*/
|
||||
char* string_to_lowercase(char* string);
|
||||
void string_to_lowercase(char* string);
|
||||
|
||||
/**
|
||||
* @brief Removes all `character` from the start of a string.
|
||||
*
|
||||
* NOTE: Mutates the string.
|
||||
*
|
||||
* @param string
|
||||
*/
|
||||
void string_trim_start(char* string, char character);
|
||||
|
||||
/**
|
||||
* @brief Removes all `character` from the end of a string.
|
||||
*
|
||||
* NOTE: Mutates the string.
|
||||
*
|
||||
* @param string
|
||||
*/
|
||||
void string_trim_end(char* string, char character);
|
||||
|
||||
/**
|
||||
* @brief Removes all `character` from the start and end of a string.
|
||||
*
|
||||
* NOTE: Mutates the string.
|
||||
*
|
||||
* @param string
|
||||
*/
|
||||
void string_trim(char* string, char character);
|
||||
|
||||
/**
|
||||
* @brief Generate a slug from a string.
|
||||
|
@ -1,8 +1,5 @@
|
||||
#include "character.h"
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
void character_append(char* string, char character) {
|
||||
size_t length = strlen(string);
|
||||
string[length] = character;
|
||||
|
@ -1,6 +1,9 @@
|
||||
#ifndef __CHARACTER__
|
||||
#define __CHARACTER__
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
/**
|
||||
* @brief Append a character to a string, assuming string points to an array
|
||||
* with enough space.
|
||||
|
@ -1,10 +1,5 @@
|
||||
#include "input.h"
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
#include "character.h"
|
||||
|
||||
char* input() {
|
||||
char character;
|
||||
size_t length = 1;
|
||||
|
@ -1,6 +1,11 @@
|
||||
#ifndef __INPUT__
|
||||
#define __INPUT__
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
#include "character.h"
|
||||
|
||||
/**
|
||||
* @brief Read a line from stdin.
|
||||
*
|
||||
|
@ -6,5 +6,6 @@
|
||||
int main() {
|
||||
char *string = input();
|
||||
printf("Hello, %s!\n", string);
|
||||
free(string);
|
||||
return EXIT_SUCCESS;
|
||||
}
|
||||
|
Loading…
Reference in New Issue
Block a user