Strings

A primeira coisa que nós iremos fazer é definir o escopo do programa.

Com o escopo definido, nós iremos declarar as variáveis e vetores que serão úteis para armazenar os dados do nosso programa.

Informações sobre as variáveis e vetores:

• string é um vetor de caracteres que será responsável por armazenar uma cadeia de caracteres;
• invertida é um vetor de caracteres que será responsável por armazenar o conteúdo presente em string em sua forma invertida;
• i e j são variáveis contadoras do programa.

Com as variáveis declaradas e inicializadas, nós podemos agora requisitar os dados de entrada do programa ao usuário.

Esse dado nada mais é do que uma cadeia de caracteres (string).

Antes de começarmos a inverter a cadeira de caracteres, nós precisamos primeiro identificar o índice do terminador nulo no vetor string.

Para isso, podemos utilizar a estrutura de repetição while que incrementará a variável contadora i enquanto o dado armazenado na posição de índice i do vetor string for diferente do terminador nulo.

Ao término desse processo, saberemos exatamente em que índice do vetor string se encontra o terminador nulo. Dessa forma, podemos atribuir ao vetor invertida nesse mesmo índice outro terminador nulo, uma vez que invertida armazenará o mesmo conteúdo que string e ambas devem ter suas cadeias de caracteres terminadas na mesma posição.

Com o vetor invertida pronto para receber uma cadeia de caracteres, nós podemos utilizar um laço de repetição for para atribuirmos os caracteres presentes no vetor string em sua ordem inversa.

A lógica é simples, nós sabemos que nesse momento do programa a variável contadora i está armazenando o índice do terminador nulo do vetor string. Com isso, podemos reiniciá-la com o seu valor atual menos 1 (último caractere do vetor string) juntamente com outra variável contadora j inicializada com o valor 0. A condição de execução desse laço é i maior ou igual a 0. Por fim, as regras de atualização das variáveis contadoras a cada loop são: i é decrementada em uma unidade e j é incrementada em uma unidade.

Com isso, o último caractere de string será atribuído a primeira posição de invertida, o penúltimo a segunda posição e assim por diante.

Ao término do laço de repetição for teremos a cadeia de caracteres presente em string armazenada em sua forma inversa no vetor invertida, bastando apenas realizarmos a sua impressão.

Essa impressão será seguida de uma quebra de linha.

Vamos começar definindo o escopo do nosso programa.

Com o escopo definido, podemos agora declarar as variáveis e os vetores que farão parte do nosso programa.

Informações sobre as variáveis e os vetores:

• stringA e stringB são vetores de caracteres que serão responsáveis por armazenar as duas cadeias de caracteres inseridas pelo usuário, respectivamente;
• stringC é um vetor de caracteres responsável por armazenar a concatenação de stringA e stringB;
• i e j são variáveis contadoras.

Com as variáveis declaradas e devidamente inicializadas, nós podemos requisitar ao usuário os dois dados de entrada do programa.

Esses dados são respectivamente: a primeira e segunda cadeias de caracteres.

Basicamente, nós podemos utilizar uma estrutura de repetição while para preencher o vetor stringC com o conteúdo dos vetores stringA e stringB.

Começando pela primeira string, tudo o que nós temos que fazer é definir a condição do laço while como: enquanto o conteúdo do vetor stringA na posição i for diferente do terminador nulo. Com essa condição, basta adicionarmos a instrução em que a stringC na posição i recebe o conteúdo da stringA nessa mesma posição. Ah! Não podemos esquecer de incrementar i em uma unidade.

Com isso, estamos repassando todo o conteúdo da stringA para a stringC até chegarmos no terminado nulo (que não será atribuído).

O mesmo do passo anterior deve ocorrer com a stringB, ou seja, temos que passar o seu conteúdo para a stringC.

Porém, dessa vez nós temos que percorrer o vetor stringB com uma nova variável contadora j (inicializada em 0) e atribuirmos os caracteres ao vetor stringC na mesma posição que parou no laço anterior.

Dessa forma, pegaremos o conteúdo de stringB desde o começa e atribuiremos na posição seguinte em que o conteúdo de stringA foi armazenado em stringC (isso é a concatenação).

Como a lógica é a mesma do laço anterior, quando o conteúdo de stringB na posição j for igual ao terminado nulo, quer dizer que as duas cadeias de caracteres já estão concatenadas em stringC e basta adicionarmos o terminador nulo desse vetor (linha 20).

Por fim, basta imprimirmos o conteúdo de stringC que obteremos os conteúdos de stringA e stringB concatenados.

Essa impressão será seguida de uma quebra de linha.

Vamos começar definindo o escopo do nosso programa.

Com o escopo definido, nós agora podemos declarar a variável e o vetor que serão úteis em nosso programa.

Informações sobre as declarações realizadas:

• i é uma variável contadora;
• string é um vetor de caracteres que será responsável por armazenar uma cadeia de caracteres inserida pelo usuário.

Em seguida, nós devemos requisitar o dado de entrada do programa ao usuário.

Esse dado nada mais é do que uma cadeia de caracteres que será armazenada em string.

Para efetivamente realizarmos a conversão, nós podemos utilizar uma estrutura de repetição while para percorrer o veto em busca de letras minúsculas.

Para isso utilizaremos a seguinte condição de execução: enquanto o conteúdo de string na posição i for diferente do terminador nulo. Tal condição é seguida das instruções condicionais que verificam se o caractere presente nessa posição é minúsculo (deve estar no intervalo entre 97 e 122, incluindo os extremos, da tabela ASCII). Caso seja, uma subtração desse caractere por 32 é realizada (as letras maiúsculas vêm antes das minúsculas na tabela ASCII), o que faz com que ele assuma sua forma maiúscula.

Vale ressaltar que enquanto a condição for verdadeira e os loops forem executados, a variável i estará sendo incrementada em uma unidade por loop.

Ao término do laço de repetição, todas as letras de string são maiúsculas. Basta agora apenas imprimirmos esse vetor:

Essa impressão será seguida de uma quebra de linha.

A primeira coisa que devemos fazer para desenvolver esse programa, é definir seu o escopo.

Com o escopo definido, podemos declarar os vetores necessários para o desenvolvimento desse programa.

Informações sobre os vetores:

• primeiroNome é um vetor de caracteres que será responsável por armazenar o primeiro nome do nome completo inserido pelo usuário;
• intermediario é um vetor de caracteres que será responsável por armazenar o nome do meio (que será ignorado);
• ultimoNome é um vetor de caracteres que será responsável por armazenar o último nome do nome completo inserido pelo usuário.

Basicamente, nós utilizaremos expressões regulares na função scanf para definir apenas aquilo que desejamos ler.

Devemos estabelecer duas leituras até o primeiro espaço em branco digitado, ignorando esses espaços logo em seguida para que eles não afetem as leituras posteriores. Dessa forma, teremos o primeiro nome e o nome intermediário (que sempre são seguidos de espaço em branco, por isso a expressão regular).

Porém, a leitura do último nome deve ser realizada usando como parâmetro de parada na expressão regular a quebra de linha. Isso fará com que a tecla enter de confirmação seja o gatilho para a obtenção do último nome.

Após a leitura, basta imprimirmos os nomes no formato exigido pelo enunciado:

Vamos começar o nosso desenvolvimento definindo o escopo do programa.

Com o escopo definido, está na hora de declararmos e inicializarmos as variáveis e o vetor que serão essenciais para o programa.

Informações sobre as declarações:

• i e j são variáveis contadoras;
• flag variável booleana representativa que marcará se a palavra é ou não um palíndromo, sendo 0 para verdadeiro e 1 para falso;
• string é um vetor de caracteres que será responsável por armazenar uma cadeia de caracteres inseridas pelo usuário.

Nesse momento, podemos requisitar o dado de entrada do programa ao usuário.

Esse dado nada mais é do que a cadeia de caracteres que será verificada como sendo ou não um palíndromo.

Antes de iniciar a verificação, nós precisamos encontrar o último caractere do vetor string.

Para isso basta utilizarmos um laço de repetição while com a condição: enquanto o conteúdo do vetor string na posição j for diferente do terminador nulo. Tal condição deve ser seguida do incremento da variável j a cada loop, isso fará que ao encerramento do laço o valor armazenado por j seja exatamente uma unidade a mais que a posição onde se encontra o último caractere de string.

Sendo assim, basta utilizarmos a estrutura de repetição for para verificarmos se string é uma palavra palíndromo ou não.

Essa verificação só é possível, pois estabelecemos na inicialização as duas variáveis contadoras dos dois diferentes extremos de string. Além disso, a regra de atualização delas são opostas, enquanto i é incrementada j é decrementada, ambas em 1 unidade.

Tendo em vista o comando condicional nas instruções da estrutura, nós podemos concluir que esse laço de repetição irá verificar a igualdade do primeiro termo de string com o último, do segundo com o penúltimo e assim por diante. Caso alguma verificação de igualdade seja falha, a variável flag é atribuída com o valor 1.

Por fim, é a variável flag que será verificada. Se ela possuir o valor 1, quer dizer que uma das posições extremas correspondentes não são iguais e a palavra não é um palíndromo. No entanto, se flag possuir o valor 0, a palavra se trata de um palíndromo.

Em ambos os casos, uma impressão seguida de uma quebra de linha será feita.

A primeira coisa que nós vamos fazer é definir o escopo do nosso programa.

Com o escopo definido, nós podemos declarar e inicializar algumas variáveis e vetores que serão úteis.

Informações:

• é uma variável contadora;
• é uma variável responsável por armazenar a quantidade de letras maiúsculas da string inserida pelo usuário do programa;
• é um vetor de caracteres com 100 posições.

Com as variáveis já declaradas e devidamente inicializadas, podemos requisitar a entrada da string ao usuário do programa.

Essa entrada nada mais é do que a string que verificaremos a quantidade de letras maiúsculas.

Ao lermos a string podemos em seguida utilizar um laço de repetição para percorrê-la com o objetivo de verificar se tais letras são maiúsculas ou não. Para isso, utilizaremos a estrutura de repetição while.

Basicamente, enquanto a posição sendo processada no vetor não for igual ao operador nulo (sendo essa a condição do laço), verificaremos se o caractere armazenado na posição sendo processada está no intervalo entre 65 (inclusive) e 90 (inclusive), pois esse é o intervalo das letras maiúsculas na tabelas ASCII. Caso o caractere daquela posição esteja nesse intervalo, a variável será incrementada em uma unidade.

A posição do vetor é incrementada sempre em uma unidade a cada loop, uma vez que esse é o valor acrescido a também a cada loop (linha 14).

Por fim, basta imprimirmos a variável , pois ao fim da execução do laço de repetição ela armazenará exatamente a quantidade de letras maiúsculas da string.

Vale ressaltar que essa impressão será seguida de uma quebra de linha.

A primeira coisa que nós devemos fazer é definir o escopo do nosso programa. Vale lembrar que além da biblioteca stdio, nós devemos incluir a biblioteca string, pois utilizaremos uma das funções disponibilizadas por ela.

Com o escopo definido, podemos iniciar a declaração das variáveis e constantes que serão úteis para nós.

No caso desse exercício, nós precisamos apenas declarar dois vetores de caracteres que serão responsáveis por armazenar as sequências inseridas pelo usuário, são eles: e .

Com os vetores declarados, podemos requisitar ao usuário do programa a entrada de duas sequências de caracteres que serão armazenadas nos dois vetores anteriormente declarados.

Fique atendo em utilizar o comando %*c, pois isso fará com que a tecla enter seja ignorada ao fim da leitura da primeira sequência de caracteres e não interfira a leitura da segunda.

Por fim, basta verificarmos se as duas strings são iguais. Para isso, utilizaremos uma estrutura condicional if else.

A condição dessa estrutura consiste em verificar se o resultado da função strcmp na comparação da com a é igual a 0, pois isso significa que ambas são iguais.

PARA TUDO!

A utilização da função strcmp é bastante simpres, basta escrevermos o comando strcmp e abrirmos e fecharmos parênteses, em seguida e dentro dos parênteses colocaremos as duas strings que queremos comparar, nesse caso e . Isso sempre nos dará um retorno, por isso igualamos a utilização dessa função a 0, pois esse retorno indica igualdade.

Logo, se a verificação for verdadeira será impressa na tela que elas são iguais, caso contrário que não são iguais.

Vamos começar o nosso programa definindo o seu escopo.

Não se esqueça que como iremos utilizar funções da biblioteca string devemos inclui-la em nosso programa. Além é claro, da nossa querida amiga biblioteca stdio.

Com o escopo definido, nós podemos declarar os dois vetores que serão responsáveis por armazenar as strings.

Onde:

• é o vetor de caracteres responsável por armazenar a string que será copiada;
• é o vetor de caracteres responsável por armazenar a cópia da string.

Nesse momento do desenvolvimento, podemos requisitar ao usuário que digite a string que será copiada.

A lógica de utilização da função strycpy é bastante simples.

Basicamente, devemos codificar o comando strcpy e entre parênteses colocarmos a string que armazenará a cópia seguida da que contém o conteúdo que será copiado (os vetores devem ser separados por vírgula).

Por fim, basta imprimirmos o vetor para conferirmos se a string base foi copiada com êxito pelo programa.