{"id":22509098,"url":"https://github.com/vinislima/42sp_piscine_c02","last_synced_at":"2025-03-28T00:21:24.930Z","repository":{"id":261881846,"uuid":"885621639","full_name":"vinislima/42sp_piscine_c02","owner":"vinislima","description":"These functions primarily focus on string manipulation and aim to strengthen understanding of character operations, memory management, and pointer usage.","archived":false,"fork":false,"pushed_at":"2024-11-22T23:11:31.000Z","size":78,"stargazers_count":0,"open_issues_count":0,"forks_count":0,"subscribers_count":1,"default_branch":"main","last_synced_at":"2025-02-02T02:18:31.556Z","etag":null,"topics":["42born2code","42network","42saopaulo","strings-manipulation"],"latest_commit_sha":null,"homepage":"https://www.linkedin.com/in/viniciusslima/","language":"C","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":"mit","status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/vinislima.png","metadata":{"files":{"readme":"README.md","changelog":null,"contributing":null,"funding":null,"license":"LICENSE","code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null,"governance":null,"roadmap":null,"authors":null,"dei":null,"publiccode":null,"codemeta":null}},"created_at":"2024-11-09T00:45:27.000Z","updated_at":"2024-11-22T23:11:34.000Z","dependencies_parsed_at":null,"dependency_job_id":"4d0551e0-a3d0-4f65-8698-3877a1cd9a58","html_url":"https://github.com/vinislima/42sp_piscine_c02","commit_stats":null,"previous_names":["vinislima/42sp_piscine_c02"],"tags_count":0,"template":false,"template_full_name":null,"repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/vinislima%2F42sp_piscine_c02","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/vinislima%2F42sp_piscine_c02/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/vinislima%2F42sp_piscine_c02/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/vinislima%2F42sp_piscine_c02/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/vinislima","download_url":"https://codeload.github.com/vinislima/42sp_piscine_c02/tar.gz/refs/heads/main","host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":245945011,"owners_count":20698144,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2022-07-04T15:15:14.044Z","host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":["42born2code","42network","42saopaulo","strings-manipulation"],"created_at":"2024-12-07T01:27:28.404Z","updated_at":"2025-03-28T00:21:24.892Z","avatar_url":"https://github.com/vinislima.png","language":"C","funding_links":[],"categories":[],"sub_categories":[],"readme":"## C 02\n\nThese functions primarily focus on string manipulation and aim to strengthen understanding of character operations, memory management, and pointer usage.\n\nThis set of exercises in the C 02 module of the 42 Piscine focuses on string manipulation and memory operations. It involves implementing custom versions of standard library functions (`strcpy`, `strncpy`, `strlcpy`) and utility functions to check string characteristics (e.g., whether strings contain only alphabetic, numeric, printable, uppercase, or lowercase characters). Other tasks include transforming strings (to uppercase, lowercase, or capitalising words), displaying non-printable characters in hexadecimal, and printing memory regions with a formatted representation.\n\nThe exercises increase in difficulty and aim to strengthen understanding of C strings, pointers, and memory management. Students must adhere to strict coding norms verified by the Moulinette and should submit their work as specified to pass the automated tests.\n\n- **`ft_strcpy`** - Replicates the behaviour of the `strcpy` function, copying a source string (`src`) to a destination (`dest`).\n- **`ft_strncpy`** - Replicates the behaviour of the `strncpy` function, copying up to `n` characters from a source string (`src`) to a destination (`dest`).\n- **`ft_str_is_alpha`** - Returns `1` if the string contains only alphabetic characters or is empty, and `0` otherwise.\n- **`ft_str_is_numeric`** - Returns `1` if the string contains only numeric characters or is empty, and `0` otherwise.\n- **`ft_str_is_lowercase`** - Returns `1` if the string contains only lowercase letters or is empty, and `0` otherwise.\n- **`ft_str_is_uppercase`** - Returns `1` if the string contains only uppercase letters or is empty, and `0` otherwise.\n- **`ft_str_is_printable`** - Returns `1` if the string contains only printable characters or is empty, and `0` otherwise.\n- **`ft_strupcase`** - Converts all the letters in a string to uppercase and returns the modified string.\n- **`ft_strlowcase`** - Converts all the letters in a string to lowercase and returns the modified string.\n- **`ft_strcapitalize`** - Capitalises the first letter of each word in a string while converting the rest to lowercase.\n- **`ft_strlcpy`** - Replicates the behaviour of the `strlcpy` function, copying a source string to a destination and returning the length of the source string.\n- **`ft_putstr_non_printable`** - Displays a string to standard output, replacing non-printable characters with their hexadecimal value preceded by `\\`.\n- **`ft_print_memory`** - Displays a memory area formatted into three columns: the hexadecimal address, the content in hexadecimal, and the printable characters.\n\n## Usage\n\nUncomment the main and use the command below.\n\n```c\ncc -Wall -Wextra -Werror {file}\n```\n\n---\n\u003cdetails\u003e\n        \u003csummary\u003eExercises:\u003c/summary\u003e\n    \n- [ex00:](https://github.com/vinislima/42sp_piscine_c02/blob/main/ex00/ft_strcpy.c)\n        \n  ```c\n        /* ************************************************************************** */\n        /*                                                                            */\n        /*                                                        :::      ::::::::   */\n        /*   ft_strcpy.c                                        :+:      :+:    :+:   */\n        /*                                                    +:+ +:+         +:+     */\n        /*   By: vinda-si \u003cvinda-si@student.42.fr\u003e          +#+  +:+       +#+        */\n        /*                                                +#+#+#+#+#+   +#+           */\n        /*   Created: 2024/08/21 10:13:23 by vinda-si          #+#    #+#             */\n        /*   Updated: 2024/08/27 16:31:20 by vinda-si         ###   ########.fr       */\n        /*                                                                            */\n        /* ************************************************************************** */\n        \n        // essa função emula o comportamento da função\n        // strcpy, que copia o conteúdo de uma string\n        // para outra string\n        char\t*ft_strcpy(char *dest, char *src);\n        \n        char\t*ft_strcpy(char *dest, char *src)\n        {\n        \t// usualmente quando formos utilizar laços\n        \t// de repetição, será necessária a utilização\n        \t// de um inteiro como index\n        \tint\tcount_char;\n        \n        \tcount_char = 0;\n        \t// iremos percorrer a string de origem\n        \t// até enquanto o elemento acessado\n        \t// for diferente de nulo\n        \twhile (src[count_char] != '\\0')\n        \t{\n        \t\t// o elemento da string de destino ira\n        \t\t//receber o correspondente da string de origem\n        \t\tdest[count_char] = src[count_char];\n        \t\tcount_char++;\n        \t}\n        \t// no final da string cópiada é incluído o elemento nulo\n        \t// que diz ao interpretador que a string chegou ao final\n        \tdest[count_char] = '\\0';\n        \t// e a função retorna a o ponteiro da string de destino\n        \treturn (dest);\n        }\n        \n        // // início da main\n        // #include \u003cstdio.h\u003e\n        \n        // int\tft_strcmp(char *s1, char *s2);\n        \n        // int\tmain(void)\n        // {\n        // \t// declaramos e atribumos valores à duas strings\n        // \tchar *src_1 = \"Teste\";\n        // \tchar *src_2 = \"Teste\";\n        // \t// chamamos a função e passamos as variáveis\n        // \t// utilizamos a função printf para imprimir a saída\n        // \tprintf(\"Minha: %d\\n\",ft_strcmp(src_1, src_2));\n        // \t//printf(\"Original: %s\\n\",strcmp(src_1, src_2));\n        // \treturn(0);\n        // \t// a partir desse ponto é interessante comparar os\n        // \t// compartamentos das funções criadas, com as originais\n        // }\n        \n  ```\n        \n- [ex01](https://github.com/vinislima/42sp_piscine_c02/blob/main/ex01/ft_strncpy.c):\n        \n  ```c\n        /* ************************************************************************** */\n        /*                                                                            */\n        /*                                                        :::      ::::::::   */\n        /*   ft_strncpy.c                                       :+:      :+:    :+:   */\n        /*                                                    +:+ +:+         +:+     */\n        /*   By: vinda-si \u003cvinda-si@student.42.fr\u003e          +#+  +:+       +#+        */\n        /*                                                +#+#+#+#+#+   +#+           */\n        /*   Created: 2024/08/27 16:27:55 by vinda-si          #+#    #+#             */\n        /*   Updated: 2024/09/03 15:18:57 by vinda-si         ###   ########.fr       */\n        /*                                                                            */\n        /* ************************************************************************** */\n        \n        // parecida com a strcpy, essa função faz a cópia de strins, mas até um limite informado\n        char\t*ft_strncpy(char *dest, char *src, unsigned int n);\n        \n        char\t*ft_strncpy(char *dest, char *src, unsigned int n)\n        {\n        \tint\tcount_size;\n        \tint\tlimit;\n        \n        \tlimit = n;\n        \tcount_size = 0;\n        \t// nesse laço enquanto o contador for menor que o limite informado\n        \t// e elemento do array original for diferente de nulo e ocorrerá\n        \twhile (count_size \u003c limit \u0026\u0026 src[count_size] != '\\0')\n        \t{\n        \t\t// aqui ocorre a cópia, com o elemento do array recebendo o\n        \t\t// seu correspondente do array de origem\n        \t\tdest[count_size] = src[count_size];\n        \t\tcount_size++;\n        \t}\n        \t// esse segundo elemento ocorre para em caso do array de destino\n        \t// ser maior que o origem, os elementos restantes serão preenchidos\n        \t// com nulos\n        \twhile (count_size \u003c limit)\n        \t{\n        \t\tdest[count_size] = '\\0';\n        \t\tcount_size++;\n        \t}\n        \t// ocorre o retorno do array de destino\n        \treturn (dest);\n        }\n        \n        // // início da string\n        // #include \u003cstdio.h\u003e\n        \n        // char\t*ft_strncpy(char *dest, char *src, unsigned int n);\n        \n        // int\tmain(void)\n        // {\n        // \t// declaramos uma string, que será a origem\n        // \tchar *src = \"Teste\";\n        // \t// declaramos uma string que será usada como destino\n        // \t// e colocamos um tamanho nela\n        // \tchar dest[5];\n        // \t// aqui declaramos e atribuimos um valor de limite\n        // \tunsigned int n = 3;\n        // \t// chamamos a funação diretamente dentro do printf para\n        // \t// impressão da saída dela\n        // \tprintf(\"%s\",ft_strncpy(dest, src, n));\n        // \treturn(0);\n        // }\n  ```\n        \n- [ex02:](https://github.com/vinislima/42sp_piscine_c02/blob/main/ex02/ft_str_is_alpha.c)\n        \n  ```c\n        /* ************************************************************************** */\n        /*                                                                            */\n        /*                                                        :::      ::::::::   */\n        /*   ft_str_is_alpha.c                                  :+:      :+:    :+:   */\n        /*                                                    +:+ +:+         +:+     */\n        /*   By: vinda-si \u003cvinda-si@student.42.fr\u003e          +#+  +:+       +#+        */\n        /*                                                +#+#+#+#+#+   +#+           */\n        /*   Created: 2024/08/27 18:10:38 by vinda-si          #+#    #+#             */\n        /*   Updated: 2024/08/27 19:54:20 by vinda-si         ###   ########.fr       */\n        /*                                                                            */\n        /* ************************************************************************** */\n        \n        // nesta função iremos verificar se todos os elementos\n        // de um array são letras\n        int\tft_str_is_alpha(char *str);\n        int\tft_strlen(char *str);\n        \n        // criamos uma função para saber o tamanho da array\n        // pois será utilizado em um dos testes de validação\n        // da função principal\n        int\tft_strlen(char *str)\n        {\n        \tint\ti;\n        \n        \ti = 0;\n        \twhile (str[i] != '\\0')\n        \t{\n        \t\ti++;\n        \t}\n        \treturn (i);\n        }\n        \n        int\tft_str_is_alpha(char *str)\n        {\n        \tint\tcount_str;\n        \t// nesse teste, caso a a string não tenha nenhum elemento\n        \t// retornamos o valor um, conforme solicitado\n        \tif (ft_strlen(str) \u003c= 0)\n        \t\treturn (1);\n        \telse\n        \t{\n        \t\t// assim como em exercícios anteriores, percorreremos os\n        \t\t// elementos do array enquanto ele for diferente de nulo\n        \t\tcount_str = 0;\n        \t\twhile (str[count_str] != '\\0')\n        \t\t{\n        \t\t\t// nesse teste verificamos o elemento junto aos valores\n        \t\t\t// da tabela ascii, caso esteja fora do intervalo de letras\n        \t\t\t// retornaremos o valor zero, que significa que dentro do array\n        \t\t\t// há um elemento difente de letra\n        \t\t\tif (str[count_str] \u003c= 64 || str[count_str] \u003e= 123)\n        \t\t\t\treturn (0);\n        \t\t\t// também verificamos o intervalo correspondente da tabela\n        \t\t\t// ascii entre letras maiscúlas e minúsculas, nesse caso se\n        \t\t\t// o elemento está dentro do intervalo, em caso positivo\n        \t\t\t// retornamos o valor de zero também\n        \t\t\telse if (str[count_str] \u003e= 91 \u0026\u0026 str[count_str] \u003c= 96)\n        \t\t\t\treturn (0);\n        \t\t\tcount_str++;\n        \t\t}\n        \t}\n        \t// caso tenha passado por toda a string sem entrar em nenhuma das condicionais\n        \t// significa que na string há somente letras\n        \treturn (1);\n        }\n        \n        // // início da main\n        // #include \u003cstdio.h\u003e\n        \n        // int\tft_str_is_alpha(char *str);\n        \n        // int\tmain(void)\n        // {\n        // \t// chamando a função diretamente dentro do printf, porque o temos retorno de inteiro\n        // \t// aqui podemos fazer o teste passando uma string com letras\n        // \t// e números e outra apenas com letras, a primeira deve retornar zero e a segunda um\n        // \tprintf(\"%i\\n\", ft_str_is_alpha(\"t134\"));\n        // \tprintf(\"%i\\n\", ft_str_is_alpha(\"teste\"));\n        // \treturn (0);\n        // }\n  ```\n        \n- [ex03:](https://github.com/vinislima/42sp_piscine_c02/blob/main/ex03/ft_str_is_numeric.c)\n        \n  ```c\n        /* ************************************************************************** */\n        /*                                                                            */\n        /*                                                        :::      ::::::::   */\n        /*   ft_str_is_numeric.c                                :+:      :+:    :+:   */\n        /*                                                    +:+ +:+         +:+     */\n        /*   By: vinda-si \u003cvinda-si@student.42.fr\u003e          +#+  +:+       +#+        */\n        /*                                                +#+#+#+#+#+   +#+           */\n        /*   Created: 2024/08/27 19:56:19 by vinda-si          #+#    #+#             */\n        /*   Updated: 2024/08/27 20:14:51 by vinda-si         ###   ########.fr       */\n        /*                                                                            */\n        /* ************************************************************************** */\n        \n        // aqui a função testa se na string recebida há somente caracteres numéricos\n        int\tft_str_is_numeric(char *str);\n        int\tft_strlen(char *str);\n        // função para percorrer e saber o tamanho da string\n        int\tft_strlen(char *str)\n        {\n        \tint\ti;\n        \n        \ti = 0;\n        \twhile (str[i] != '\\0')\n        \t{\n        \t\ti++;\n        \t}\n        \treturn (i);\n        }\n        \n        int\tft_str_is_numeric(char *str)\n        {\n        \tint\tcount_str;\n        \t// caso o tamanho da string for menor ou igual a zero retornamos um\n        \tif (ft_strlen(str) \u003c= 0)\n        \t\treturn (1);\n        \telse\n        \t{\n        \t\tcount_str = 0;\n        \t\t// o laço se repetirá enquanto não encontrar o elemento nulo\n        \t\twhile (str[count_str] != '\\0')\n        \t\t{\n        \t\t\t// se o elemento da string estiver fora do intervalo dos\n        \t\t\t// caracteres númericos, temos o retorno de zero\n        \t\t\tif (str[count_str] \u003c= 47 || str[count_str] \u003e= 58)\n        \t\t\t\treturn (0);\n        \t\t\tcount_str++;\n        \t\t}\n        \t}\n        \t// caso todos elementos estejam dentro do intervalo dos caracteres numéricos\n        \t// o retorno é um\n        \treturn (1);\n        }\n        \n        // // inícios da main\n        // #include \u003cstdio.h\u003e\n        \n        // int\tft_str_is_numeric(char *str);\n        \n        // int\tmain(void)\n        // {\n        // \t// em caso de todos elementos estarem dentro do intervalo\n        // \t// dos caracteres númericos temos a saída igual a um\n        // \tprintf(\"%i\\n\", ft_str_is_numeric(\"123456789\"));\n        // \t// neste caso como temos uma letra, a saída será zero\n        // \tprintf(\"%i\\n\", ft_str_is_numeric(\"1234A6789\"));\n        // \treturn (0);\n        // }\n  ```\n        \n- [ex04:](https://github.com/vinislima/42sp_piscine_c02/blob/main/ex04/ft_str_is_lowercase.c)\n        \n  ```c\n        /* ************************************************************************** */\n        /*                                                                            */\n        /*                                                        :::      ::::::::   */\n        /*   ft_str_is_lowercase.c                              :+:      :+:    :+:   */\n        /*                                                    +:+ +:+         +:+     */\n        /*   By: vinda-si \u003cvinda-si@student.42.fr\u003e          +#+  +:+       +#+        */\n        /*                                                +#+#+#+#+#+   +#+           */\n        /*   Created: 2024/08/28 08:37:40 by vinda-si          #+#    #+#             */\n        /*   Updated: 2024/08/28 09:37:27 by vinda-si         ###   ########.fr       */\n        /*                                                                            */\n        /* ************************************************************************** */\n        \n        // a função verifica se na string todos os elementos são\n        // caracteres alfabéticos minúsculos\n        int\tft_str_is_lowercase(char *str);\n        int\tft_strlen(char *str);\n        // função para saber o tamanho da string\n        int\tft_strlen(char *str)\n        {\n        \tint\ti;\n        \n        \ti = 0;\n        \t// percorre os elementos da string até encontrar\n        \t// o elemento nulo\n        \twhile (str[i] != '\\0')\n        \t{\n        \t\ti++;\n        \t}\n        \treturn (i);\n        }\n        \n        int\tft_str_is_lowercase(char *str)\n        {\n        \tint\tcount_str;\n        \t// se a string não contiver nenhum elemento, retorna um\n        \tif (ft_strlen(str) \u003c= 0)\n        \t\treturn (1);\n        \telse\n        \t{\n        \t\tcount_str = 0;\n        \t\t// o laço ocorre enquanto não encontrar o nulo\n        \t\twhile (str[count_str] != '\\0')\n        \t\t{\n        \t\t\t// verifica se o elemento está fora do intervalo de\n        \t\t\t// caracteres alfabéticos minúsculos, se estiver retorna zero\n        \t\t\tif (str[count_str] \u003c= 96 || str[count_str] \u003e= 123)\n        \t\t\t\treturn (0);\n        \t\t\tcount_str++;\n        \t\t}\n        \t}\n        \t// caso passe por todos os elementos e todos os elementos sejam\n        \t// minúsculos, retorna um\n        \treturn (1);\n        }\n        \n        // // início da main\n        // #include \u003cstdio.h\u003e\n        \n        // int\tft_str_is_lowercase(char *str);\n        \n        // int\tmain(void)\n        // {\n        // \t// passando direto a função como paramêtro da printf\n        // \t// para ver o retorno, no primeiro devemos ter retorno de\n        // \t// um pois só há letras minúsculas\n        // \tprintf(\"%i\\n\", ft_str_is_lowercase(\"aassed\"));\n        // \t// aqui teremos retorno zero, pois há uma maiúscula\n        // \tprintf(\"%i\\n\", ft_str_is_lowercase(\"aaAsed\"));\n        // \t// aqui também o retorno deve ser zero, pois há um numeral\n        // \tprintf(\"%i\\n\", ft_str_is_lowercase(\"aa1sed\"));\n        // }\n  ```\n        \n- [ex05:](https://github.com/vinislima/42sp_piscine_c02/blob/main/ex05/ft_str_is_uppercase.c)\n        \n  ```c\n        /* ************************************************************************** */\n        /*                                                                            */\n        /*                                                        :::      ::::::::   */\n        /*   ft_str_is_uppercase.c                              :+:      :+:    :+:   */\n        /*                                                    +:+ +:+         +:+     */\n        /*   By: vinda-si \u003cvinda-si@student.42.fr\u003e          +#+  +:+       +#+        */\n        /*                                                +#+#+#+#+#+   +#+           */\n        /*   Created: 2024/08/28 09:16:56 by vinda-si          #+#    #+#             */\n        /*   Updated: 2024/08/28 09:37:13 by vinda-si         ###   ########.fr       */\n        /*                                                                            */\n        /* ************************************************************************** */\n        \n        // essa função verifica se todos os elementos da string\n        // são alfabéticos e maiúcuslo\n        int\tft_str_is_uppercase(char *str);\n        int\tft_strlen(char *str);\n        // função para saber o tamanho da string\n        int\tft_strlen(char *str)\n        {\n        \tint\ti;\n        \n        \ti = 0;\n        \t// verifica se o elemento é diferente de nulo\n        \twhile (str[i] != '\\0')\n        \t{\n        \t\ti++;\n        \t}\n        \treturn (i);\n        }\n        \n        int\tft_str_is_uppercase(char *str)\n        {\n        \tint\tcount_str;\n        \t// caso a string não tenha elementos retorna um\n        \tif (ft_strlen(str) \u003c= 0)\n        \t\treturn (1);\n        \telse\n        \t{\n        \t\tcount_str = 0;\n        \t\t// o laço permanece enquanto enquanto o elemento for diferente de nulo\n        \t\twhile (str[count_str] != '\\0')\n        \t\t{\n        \t\t\t// se o elemento estiver fora do intervalo das letras maiúscula\n        \t\t\t// ele retorna zero\n        \t\t\tif (str[count_str] \u003c= 64 || str[count_str] \u003e= 91)\n        \t\t\t\treturn (0);\n        \t\t\tcount_str++;\n        \t\t}\n        \t}\n        \t// caso passe por todos os elementos significa que todos os elementos são\n        \t// letras maiúsculas e retorna um\n        \treturn (1);\n        }\n        \n        // // início da main\n        // #include \u003cstdio.h\u003e\n        \n        // int\tft_str_is_uppercase(char *str);\n        \n        // int\tmain(void)\n        // {\n        // \t// função colocada direto na função printf, pois temos um retorno\n        // \t// no primeito devemos ter um, pois na string só há letras maiúscula\n        // \tprintf(\"%i\\n\", ft_str_is_uppercase(\"TAADASD\"));\n        // \t// neste devemos ter zero, pois há uma letra minúscula\n        // \tprintf(\"%i\\n\", ft_str_is_uppercase(\"TAAaASD\"));\n        // \t// neste devemos ter zero, pois há um numeral\n        // \tprintf(\"%i\\n\", ft_str_is_uppercase(\"TAA1ASD\"));\n        // \treturn (0);\n        // }\n  ```\n        \n- [ex06:](https://github.com/vinislima/42sp_piscine_c02/blob/main/ex06/ft_str_is_printable.c)\n        \n  ```c\n        /* ************************************************************************** */\n        /*                                                                            */\n        /*                                                        :::      ::::::::   */\n        /*   ft_str_is_printable.c                              :+:      :+:    :+:   */\n        /*                                                    +:+ +:+         +:+     */\n        /*   By: vinda-si \u003cvinda-si@student.42.fr\u003e          +#+  +:+       +#+        */\n        /*                                                +#+#+#+#+#+   +#+           */\n        /*   Created: 2024/08/28 09:44:44 by vinda-si          #+#    #+#             */\n        /*   Updated: 2024/09/03 08:37:34 by vinda-si         ###   ########.fr       */\n        /*                                                                            */\n        /* ************************************************************************** */\n        \n        // essa função verifica que os elementos estão dentro da faixa\n        // de caracteres possíveis de impressão\n        int\tft_str_is_printable(char *str);\n        int\tft_strlen(char *str);\n        // função para saber o tamanho da string\n        int\tft_strlen(char *str)\n        {\n        \tint\ti;\n        \n        \ti = 0;\n        \t// percorre os elementos da string enquanto não encontrar nulo\n        \twhile (str[i] != '\\0')\n        \t{\n        \t\ti++;\n        \t}\n        \t// retorna o tamanho da string\n        \treturn (i);\n        }\n        \n        int\tft_str_is_printable(char *str)\n        {\n        \tint\tcount_str;\n        \t// verifica se a string têm elementos, se não tiver, retorna um\n        \tif (ft_strlen(str) \u003c= 0)\n        \t\treturn (1);\n        \telse\n        \t{\n        \t\tcount_str = 0;\n        \t\t// segue no laço enquanto o elemento da string for diferente de nulo\n        \t\twhile (str[count_str] != '\\0')\n        \t\t{\n        \t\t\t// verifica se o elemento não está fora da faixa de caracteres\n        \t\t\t// possíveis de impressão, se estiver retorna zero\n        \t\t\tif (str[count_str] \u003c= 31 || str[count_str] \u003e= 127)\n        \t\t\t\treturn (0);\n        \t\t\t// faz um segundo teste para verificar se o elemento é uma quebra de linha,\n        \t\t\t// sendo o retorno também é zero\n        \t\t\telse if (str[count_str] == '\\n')\n        \t\t\t\treturn (0);\n        \t\t\tcount_str++;\n        \t\t}\n        \t}\n        \t// caso todos os elementos estejam dentro da faixa de caracteres possíveis de impressão\n        \t// o retorno é um\n        \treturn (1);\n        }\n        \n        // // início da main\n        // #include \u003cstdio.h\u003e\n        \n        // int\tft_str_is_printable(char *str);\n        \n        // int\tmain(void)\n        // {\n        // \t// aqui o retorno deve ser um, pois são todos possíveis de impressão\n        // \tprintf(\"%i\\n\", ft_str_is_printable(\"dasdasdasda\"));\n        // \t// aqui o retorno deve ser zero, pois vinte e sete representa escape\n        // \tprintf(\"%i\\n\", ft_str_is_printable(27));\n        // \treturn (0);\n        // }\n  ```\n        \n- [ex07:](https://github.com/vinislima/42sp_piscine_c02/blob/main/ex07/ft_strupcase.c)\n        \n  ```c\n        /* ************************************************************************** */\n        /*                                                                            */\n        /*                                                        :::      ::::::::   */\n        /*   ft_strupcase.c                                     :+:      :+:    :+:   */\n        /*                                                    +:+ +:+         +:+     */\n        /*   By: vinda-si \u003cvinda-si@student.42.fr\u003e          +#+  +:+       +#+        */\n        /*                                                +#+#+#+#+#+   +#+           */\n        /*   Created: 2024/08/28 10:13:26 by vinda-si          #+#    #+#             */\n        /*   Updated: 2024/08/28 12:13:21 by vinda-si         ###   ########.fr       */\n        /*                                                                            */\n        /* ************************************************************************** */\n        \n        // essa função transforma caracteres alfabéticos minúsculos em maiúsculos\n        char\t*ft_strupcase(char *str);\n        int\t\tft_strlen(char *str);\n        // função para saber o tamanho da string\n        int\tft_strlen(char *str)\n        {\n        \tint\ti;\n        \n        \ti = 0;\n        \t// se mantém dentro laço enquanto o elemento do array for diferente de nulo\n        \twhile (str[i] != '\\0')\n        \t{\n        \t\t// ocorre o incremento do contador;\n        \t\ti++;\n        \t}\n        \treturn (i);\n        }\n        \n        char\t*ft_strupcase(char *str)\n        {\n        \tint\tcount_str;\n        \t// caso a string não tenha elementos ela retorna a própria string\n        \tif (ft_strlen(str) \u003c= 0)\n        \t\treturn (str);\n        \telse\n        \t{\n        \t\tcount_str = 0;\n        \t\t// enquanto o elemento for diferente de nulo o laço se mantem\n        \t\twhile (str[count_str] != '\\0')\n        \t\t{\n        \t\t\t// se o elemento estiver dentro da faixa dos caracteres minúsculos\n        \t\t\t// ele entra na condição\n        \t\t\tif (str[count_str] \u003e= 97 \u0026\u0026 str[count_str] \u003c= 122)\n        \t\t\t\t// entrando na condição a ação ira definir o elemento como ele\n        \t\t\t\t// mesmo, mas subtraindo trinta e duas posições para alcançar\n        \t\t\t\t// seu equivalente maiúsculo\n        \t\t\t\tstr[count_str] = str[count_str] - 32;\n        \t\t\tcount_str++;\n        \t\t}\n        \t}\n        \t// ao final o retorno é o ponteiro para o início da string com as transformações\n        \treturn (str);\n        }\n        \n        // //início da main\n        // #include \u003cunistd.h\u003e\n        \n        // char\t*ft_strupcase(char *str);\n        \n        // int\tmain(void)\n        // {\n        // \t// declaro um aray e atribuo um string para ele\n        // \tchar\ta[] = \"Isso é apenas 1 teste\";\n        // \t// declaro um ponteiro e atribuo o retorna da função\n        // \t// pois será um ponteiro\n        // \tchar\t*str = ft_strupcase(a);\n        // \t// somente para estudos optei por utilizar o while, juntamente com\n        // \t// write\n        // \tint\tcount = 0;\n        // \twhile (str[count] != '\\0')\n        // \t{\n        // \t\t// junto com o contador o write imprime cada elemento do array\n        // \t\twrite(1, \u0026str[count], 1);\n        // \t}\n        // \treturn (0);\n        // }\n  ```\n        \n- [ex08:](https://github.com/vinislima/42sp_piscine_c02/blob/main/ex08/ft_strlowcase.c)\n        \n  ```c\n        /* ************************************************************************** */\n        /*                                                                            */\n        /*                                                        :::      ::::::::   */\n        /*   ft_strlowcase.c                                    :+:      :+:    :+:   */\n        /*                                                    +:+ +:+         +:+     */\n        /*   By: vinda-si \u003cvinda-si@student.42.fr\u003e          +#+  +:+       +#+        */\n        /*                                                +#+#+#+#+#+   +#+           */\n        /*   Created: 2024/08/28 12:16:50 by vinda-si          #+#    #+#             */\n        /*   Updated: 2024/08/28 15:16:04 by vinda-si         ###   ########.fr       */\n        /*                                                                            */\n        /* ************************************************************************** */\n        \n        // essa função transforma caracteres maiúsculos de um string para minúsculos\n        char\t*ft_strlowcase(char *str);\n        int\t\tft_strlen(char *str);\n        // função para saber o tamanho da string\n        int\tft_strlen(char *str)\n        {\n        \tint\ti;\n        \n        \ti = 0;\n        \t// laço se mantém enquanto o elemento for diferente de nulo\n        \twhile (str[i] != '\\0')\n        \t{\n        \t\t//ocorre o incremento do contador\n        \t\ti++;\n        \t}\n        \treturn (i);\n        }\n        \n        char\t*ft_strlowcase(char *str)\n        {\n        \tint\tcount_str;\n        \t// se a string não possuir elementos, retorna a string\n        \tif (ft_strlen(str) \u003c= 0)\n        \t\treturn (str);\n        \telse\n        \t{\n        \t\tcount_str = 0;\n        \t\t// enquanto o elemento for diferente de nulo o laço se mantém\n        \t\twhile (str[count_str] != '\\0')\n        \t\t{\t\n        \t\t\t// se o elemento está dentro da faixa dos caracteres alfabéticos maiúsculos\n        \t\t\tif (str[count_str] \u003e= 65 \u0026\u0026 str[count_str] \u003c= 90)\n        \t\t\t\t// caso esteja o elemento recebe ele mesmo com o acrescimo de trinta e duas\n        \t\t\t\t// posições para alcançar o equivalente em minúsculas\n        \t\t\t\tstr[count_str] = str[count_str] + 32;\n        \t\t\tcount_str++;\n        \t\t}\n        \t}\n        \t// retorno a ponteiro para o início da string alterada\n        \treturn (str);\n        }\n        \n        // // início da main\n        // #include \u003cunistd.h\u003e\n        \n        // char\t*ft_strlowcase(char *str);\n        \n        // int\tmain(void)\n        // {\n        // \t// declaro um arraya e atribuo uma string\n        // \tchar\ta[] = \"IsSo é 1 TeSTe\";\n        // \t// declaro um ponteiro e atribuo a função que têm o retorno\n        // \t// apontando o início da string\n        // \tchar\t*str = ft_strlowcase(a);\n        // \t// usando para estudo o while e write\n        // \tint\tcount = 0;\n        // \twhile (str[count] != '\\0')\n        // \t{\n        // \t\twrite(1, \u0026str[count], 1);\n        // \t\tcount++;\n        // \t}\n        // \treturn (0);\n        // }\n  ```\n        \n- ex09:\n        \n  ```c\n        /* ************************************************************************** */\n        /*                                                                            */\n        /*                                                        :::      ::::::::   */\n        /*   ft_strcapitalize.c                                 :+:      :+:    :+:   */\n        /*                                                    +:+ +:+         +:+     */\n        /*   By: vinda-si \u003cvinda-si@student.42sp.org.br\u003e    +#+  +:+       +#+        */\n        /*                                                +#+#+#+#+#+   +#+           */\n        /*   Created: 2024/08/28 15:20:19 by vinda-si          #+#    #+#             */\n        /*   Updated: 2024/11/20 18:38:10 by vinda-si         ###   ########.fr       */\n        /*                                                                            */\n        /* ************************************************************************** */\n        \n        #include \u003cstdio.h\u003e\n        // essa função têm como objetivo normalizar um string\n        // todo letra em início de frase e após algum simbolo\n        // deve ser maiúscla, as demais minúscula, letras após\n        // números devem ser minúsculas.\n        char\t*ft_strcapitalize(char *str);\n        int\t\tft_strlen(char *str);\n        char\t*ft_strlowcase(char *str);\n        // função para sabermos o tamanho da string\n        int\tft_strlen(char *str)\n        {\n        \tint\ti;\n        \n        \ti = 0;\n        \t// percorre a string enquanto o elemento for diferente de nulo\n        \twhile (str[i] != '\\0')\n        \t{\n        \t\t// incrementa o contador\n        \t\ti++;\n        \t}\n        \treturn (i);\n        }\n        // função para transformar todos os caracteres alfabéticos\n        // em minúsculas, ficando mais fácil realizar a transformação\n        // para maiúsculas quando necessário\n        char\t*ft_strlowcase(char *str)\n        {\n        \tint\tcount_str;\n        \n        \tif (ft_strlen(str) \u003c= 0)\n        \t\treturn (str);\n        \telse\n        \t{\n        \t\tcount_str = 0;\n        \t\twhile (str[count_str] != '\\0')\n        \t\t{\t\n        \t\t\tif (str[count_str] \u003e= 65 \u0026\u0026 str[count_str] \u003c= 90)\n        \t\t\t\tstr[count_str] = str[count_str] + 32;\n        \t\t\tcount_str++;\n        \t\t}\n        \t}\n        \treturn (str);\n        }\n        // função que definirá quando o caracter deve ser maiúsculo\n        char\t*ft_strcapitalize(char *str)\n        {\n        \t// declaramos dois contadores\n        \t// um será para percorrer a string\n        \t// outro funcionará como um sinalizador, que quando ativo\n        \t// sinaliza que o caracter seguinte, se alfabético deve ser maiúsculo\n        \tint\tcount;\n        \tint\tbegin_word;\n        \t// contador para percorrer a string se inícia em zero\n        \tcount = 0;\n        \t// sinalizador ínicia em um, porque todo começo de frase\n        \t// têm início com maiúscula\n        \tbegin_word = 1;\n        \t// a string é passada para a função de deixar ela inteira minúscula\n        \tft_strlowcase(str);\n        \t// enquanto o elemento for diferente de zero o laço permanecerá\n        \twhile (str[count] != '\\0')\n        \t{\n        \t\t// se elemento estiver dentro da faixa dos caracteres numéricos\n        \t\t// o sinalizador recebe zero para que o caracter alfabético permaneça\n        \t\t// como minúsculo\n        \t\tif (str[count] \u003e= '0' \u0026\u0026 str[count] \u003c= '9')\n        \t\t\tbegin_word = 0;\n        \t\t// se o elemento não for númerico, verifica se ele e minúsculo e se\n        \t\t// o sinalizador está como o valor de um, que significa ativo\n        \t\telse if ((str[count] \u003e= 'a' \u0026\u0026 str[count] \u003c= 'z') \u0026\u0026 begin_word == 1)\n        \t\t{\n        \t\t\t// se o teste anterior for verdadeiro, testamos novamete se o elemento\n        \t\t\t// está na faixa de caracteres alfabéticos minúsculos\n        \t\t\tif (str[count] \u003e= 'a' \u0026\u0026 str[count] \u003c= 'z')\n        \t\t\t\t// se estiver, transformamos ele para maiúsculo\n        \t\t\t\tstr[count] = str[count] - 32;\n        \t\t\t// colocamos o sinalizador para o valor de zero, pois\n        \t\t\t// a próximo caracter deve seguir como minúsculo\n        \t\t\tbegin_word = 0;\n        \t\t}\n        \t\t// caso as condições anteriores ainda sejam falsas,\n        \t\t// caimos nessa que testa se o elemento for diferente da\n        \t\t// faixa de caracteres minúsculos e diferente da faixa de\n        \t\t// caracteres númericos, significa que é um outro sinal\n        \t\t// sendo assim ativos o sinalizador, pois a seguir a caracter\n        \t\t// alfabético deve ser maiúsculo\n        \t\telse if (!(str[count] \u003e= 'a' \u0026\u0026 str[count] \u003c= 'z')\n        \t\t\t\u0026\u0026 !(str[count] \u003e= '0' \u0026\u0026 str[count] \u003c= '9'))\n        \t\t{\n        \t\t\tbegin_word = 1;\n        \t\t}\n        \t\t// incremento do contador\n        \t\tcount++;\n        \t}\n        \t// se retorna a string alterada\n        \treturn (str);\n        }\n        \n        // int\tmain(void)\n        // {\n        // \t// declaramos e atribuímos uma string à str para\n        // \t// testar a função ft_strcapitalize, contém paralavras no\n        // \t// início com letra minúsculas e palavras com maiúsculas no\n        // \t// meio da string\n        // \tchar\tstr[] = \" salut, comme TU vas ? 42mots.\";\n        // \t// passamos para a função a string\n        // \tft_strcapitalize(str);\n        // \t// realizamos a impressão da string modificada\n        // \tprintf(\"%s\\n\", str);\n        // \treturn (0);\n        // }\n  ```\n\u003c/details\u003e\n","project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fvinislima%2F42sp_piscine_c02","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Fvinislima%2F42sp_piscine_c02","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fvinislima%2F42sp_piscine_c02/lists"}