[RESOLVIDO] Como centralizar uma String através de ponto

Programação
,
#1

Gente eu estou inicando agora na linguagem java e recebi uma lista de exercícios em que o professor não explicou ainda… Até consegui fazer alguns exercícios mas estou em duvida nesse:
Elaborar um programa que leia uma palavra. O programa deve centralizar esta palavra em uma linha com 80 colunas, com pontos nos lados – conforme o exemplo. Palavra: salada
…salada…

Não faço idéia de qual código usar a gente só aprendeu if tivemos apenas 1 aula de java

#2

Basicamente você vai pegar a quantidade de caracteres da String digitada:

int tamanhoPalavra= minhaVariavelString.length();

Depois vai calcular a quantidade de pontos que precisa concatenar à esquerda e à direita:

int quantidadePontos = (80 - tamanhoPalavra) / 2;

Agora é só fazer as concatenações.

1 curtida
#3

Obrigadaa

#4

Na verdade estou muito confusa no final sobre oq fazer… eu estou esse tempo todo tentando transformar o numero que vai sair da quantidadePontos para a quantidade de “.” . Tentei transformar para string para fazer:

if(quantidadedePontos <40){
quantidadedePontos= quantidadedePontos*"."
}
//Depois
System.out.println(quantidadedePontos + palavracentral + quantidadedePontos);

Mas claramente não funcionou kkkk oq eu faço, como transformo a quantidadedePontos em “.”

#5

Há dois operadores que você poderá usar com Strings. O + que implica em concatenação e o += que é um operador composto de atribuição, que fará uma concatenação e uma atribuição.

String s1 = "a";
String s2 = "b";
String s3 = s1 + s2;
String s4 = s3;
s4 += s3;

System.out.println( s1 + " | " + s2 + " | " + s3 + " | " + s4 );

Teste o código acima. Você vai obter na saída:

a | b | ab | abab

Pois, s1 aponta para a String "a", s2 para "b", s3 é a concatenação de s1 e s2 ("ab") e, finalmente, s4 aponta inicialmente para "ab" (s3) e depois "ab" (s3) é concatenado novamente em s4, ficando com "abab".

No seu código, você tenta usar o operador * -que não é aplicável a Strings- para multiplicar a String "." pela quantidade de pontos. Isso você não conseguirá fazer. Para fazer isso, vc teria que ter algo do tipo:

String pontos = "";
for ( int i = 0; i < quantidadePontos; i++ ) {
    pontos += ".";
}
System.out.println( pontos );

Se quantidadePontos for igual a 10, você terá na saída:

..........

Como você quer centralizar uma String em um terminal de 80 colunas, a ideia é colocar o centro da String no centro do terminal. O centro do terminal é, digamos, a coluna 40. Se vc tiver uma String com 11 caracteres, o centro dela será o sexto caractere. Note que o centro de Strings de comprimento par será aproximadamente o caractere que está à esquerda ou a direita do centro. Você precisa então dividir o comprimento da String por 2, subtrair de 40 e o resultado, é a quantidade de espaços (que vc está usando pontos) para “mover” a String para frente. Veja abaixo o esquema:

a
a.png778×606 38.7 KB

Sendo assim:

// string de 11 caracteres, exemplo destacado em verde acima
String s = "abcdefghijk";
int quantidadeEspacos = 40 - s.length() / 2;
String espacos = "";

for ( int i = 0; i < quantidadeEspacos; i++ ) {
    espacos += " ";
}

System.out.println( espacos + s );
1 curtida
#6

Tem um detalhe aí, não basta dividir “80 - tamanho da string” por 2.

Por exemplo, se a string tiver 3 caracteres, e você divide 80 - 3 por 2 (arredondando), dá 38.

Mas se colocar 38 pontos de cada lado da palavra, você terá 38 antes, 38 depois e mais os 3 caracteres da palavra, totalizando 79.

Quando o tamanho da string é ímpar, você tem que adicionar um ponto a mais (aí você decide se vai ser antes ou depois). Não tem jeito, vai ficar desalinhado (pois não tem como alinhar “meio caractere”). Claro, tudo isso assumindo que a quantidade de colunas é par (vamos manter assim para simplificar).

Outro detalhe é que para adicionar os pontos antes e depois, em vez de concatenar strings em um loop, você pode usar StringBuilder, que é mais eficiente em loops (se comparado à concatenação com +). Então ficaria assim:

int colunas = 80; // total de colunas
String palavra = "saladas";
int preenchimento = (colunas - palavra.length()) / 2;
int extra = palavra.length() % 2; // caso o tamanho da string seja ímpar, tem um caractere a mais para adiconar no final

StringBuilder sb = new StringBuilder();
// pontos antes
for (int i = 0; i < preenchimento; i++) {
    sb.append('.');
}

// a própria palavra
sb.append(palavra);

// decidi adicionar o ponto extra no fim (mas poderia ser no início se quiser)
for (int i = 0; i < preenchimento + extra; i++) {
    sb.append('.');
}

System.out.println(sb.toString());

Escolhi uma palavra com tamanho ímpar (“saladas”) para mostrar o que acontece. No caso, a saída é:

....................................saladas.....................................

Ou seja, 36 pontos antes e 37 depois (mais os 7 caracteres da palavra, totalizando 80 colunas). Se quiser que o ponto a mais fique no início, basta trocar os dois for de lugar.

Se o tamanho da palavra for par, aí terá a mesma quantidade de pontos antes e depois. Como já dito, isso só vale se o total de colunas também for par (se for ímpar, aí você teria que fazer outra verificação juntamente com o tamanho da palavra, para saber se a combinação de ambos resultará nesse caractere a mais ou não).

1 curtida