Algoritmos Java

Java: Algoritmos e programas

O conceito de algoritmo é abordado na disciplina apenas de forma informal: uma estratégia para resolver um problema prob lema de forma f orma correta corr eta em tempo t empo finito. fini to. Dado um problema, podemos conceber mais de uma estratégia para resolvê−lo. Se quisermos que o particular problema seja resolvido com o auxílio de um computador, então devemos definir estratégias sob a perspectiva da máquina. Como computadores não entendem descrições de estratégias em linguagem natural, é preciso codificá−las em linguagens artificiais compreensíveis pelas máquinas. Tais linguagens são denominadas linguagens de programação. Uma codificação de uma estratégia em uma particular linguagem de programação é chamada de programa (ou aplicação no jargão Java). Para uma particular estratégia existem múltiplas formas de codificação. O ato de programar, portanto, sempre deve ser precedido por uma atividade de concepção e seleção de estratégias. Se não existe uma estratégia claramente delineada, então não há como codificar programas corretos. Ao se codificar um programa também deve ser considerada, além do algoritmo é claro, a forma de como o usuário vai interagir com o propósito de produzir um programa que seja de fácil uso.

1

Trusted by over 1 million members

Try Scribd FREE for 30 days to access over 125 million titles without ads or interruptions! Start Free Trial Cancel Anytime.







Java: Soma de dois inteiros

Calcular a soma de dois valores inteiros.

Considerações relevantes: Que valores serão somados? Dois valores fornecidos pelo usuário. • Como serão fornecidos tais valores? Via teclado. • A soma de dois valores inteiros é uma operação primitiva. • O que é feito com o valor resultante da soma? Ele é apresentado ao usuário. •

Pelo fato da soma de dois valores já ser uma operação primitiva (isto é, ela não precisa ser descrita em termos de operações mais elementares), o algoritmo para o programa é bastante simples. Se o processo for encarado sob a ótica do computador (já que um algoritmo prescreve os passos a serem executados pelo computador para resolver um particular problema), então o processo para calcular a soma de um valor representado por a com outro representado b b se restringe ao seguinte: por 1. ler um valor do teclado para a e outro para b b 2. somar os valores representados por a e b 3. apresentar o valor resultante ao usuário

Aplicação "minimalista"

001 public class SomaDoisInteiros 002 { 003 004 public static void main(String argv[]) 005 { 006 int a, b, c; 007 a = IO.readInt(); 008 b = IO.readInt(); 009 c = a + b; 010 IO.writeln(c); 011 } 012 013 }







003 004 005 006 007 008 009 010 011 012 013 014 015 016

public static void main(String argv[]) {

int a, b, c; IO.write("a: IO.write("a: "); "); a = IO.readInt(); IO.write("b: IO.write("b: "); "); b = IO.readInt(); IO.write("a IO.write("a + b = "); "); c = a + b; IO.writeln(c); } }







Java: Soma dos n primeiros números naturais − versão 1

Dado n, calcular a soma dos n primeiros números naturais.

Podemos resolver o problema com o cálculo de uma expressão aritmética já que o problema é um caso particular de uma progressão aritmética ( sn = (a1 + an) * n / 2 ), onde, no caso específico a ser resolvido, a1=1 e an=n ). 2), =n). A expressão aritmética a ser calculada, portanto, se reduz a (1 + n) * n / 2 e depende de um valor n a ser fornecido pelo usuário. Um possível algoritmo (processo de resolução do problema sob a ótica do computador), portanto, pode ser descrito como: 1. ler um valor para n 2. calcular o valor resultante da expressão (1 + n) * n / 2 3. apresentar o resultado para o usuário Observação: O algoritmo pressupõe que o usuário irá fornecer um valor válido, isto é, um valor inteiro maior que zero. Se for fornecido um valor menor ou igual a zero o resultado apresentado pelo programa não representa uma resposta válida.

Aplicação

001 public class SomaNaturais1 002 { 003 004 public static void main(String argv[]) 005 { 006 int n, s; 007 n = IO.readInt(); 008 s = (1 (1 + n) * n / 2; 009 IO.writeln(s); 010 } 011 012 }







Java: Soma dos n primeiros números naturais − versão 2

Dado n, calcular a soma dos n primeiros números naturais.

Se não identificarmos o problema como sendo um caso particular de uma progressão aritmética, então uma outra forma de resolvê−lo poderia ser através de somas sucessivas, isto é, enquanto enumeramos os naturais de 1 a n, nós vamos somando tais valores conforme vão sendo enumerados. Isto, é, a cada ciclo do processo é determinado o próximo número natural que é, então, somado ao valor das somas já acumuladas dos valores enumerados até então. Com esta estratégia, se no meio do processo de cálculo tivermos atingido, em um particular ciclo, o valor i durante a enumeração, então já teremos acumulado acumulado a soma de todos os valores de 1 a i−1 e a tal valor acumulado é somado, então, o valor i para obtermos o valor da soma de todos os valores entre 1 e i. Conseqüentemente, ao final do processo, o valor das somas acumuladas representa o valor que procuramos, isto é, a soma de todos os valores entre 1 e n. Como iniciamos o processo? Inicialmente definimos o valor da variável s que utilizamos para representar o valor das somas acumuladas como sendo zero (o elemento neutro da soma), pois nenhum valor ainda foi acumulado, e definimos o valor do i utilizado para representar o valor do número natural atingido no processo de enumeração também com o valor zero. A cada ciclo do processo incrementamos o valor de i em uma unidade (no primeiro passo i deve passar a valer 1, isto é, o primeiro valor da seqüência dos naturais a serem enumerados e, por esta razão, o valor inicial de i dve ser o predecessor de 1) e atualizamos o valor da variável s que representa a soma dos até então enumerados valores naturais com um novo valor obtido a partir da soma do valores correntes de s e i . Com tal atualização (dizemos que um novo valor foi "atribuído" a s) o valor de s fica consistente com o uso pretendido da variável, isto é, manter o valor da soma de todos os naturais já enumerados. Este ciclo de dois passos (determinação do próximo natural e atualização do valor das somas acumuladas) é repetido até i atingir o valor n e este último valor de i estiver agregado ao valor de s. O algoritmo, portanto, se resume a: 1. leia o valor de n 2. faça com que s assuma o valor zero 3. faça com que i assumam o valor zero 4. enquanto i






obtido pela operação de soma).

Aplicação

001 public class SomaNaturais2 002 { 003 004 public static void main(String argv[]) 005 { 006 int n, s, i; 007 n = IO.readInt(); 008 s = 0; 009 i = 0; 010 while (i < n) 011 { 012 i = i + 1; 013 s = s + i; 014 } 015 IO.writeln(s); 016 } 017 018 }









Java: Máximo divisor comum − versão 1

b. Calcular o máximo divisor comum de dois inteiros a e b.

Um algoritmo para determinar o máximo divisor comum é baseado em divisões sucessivas: a cada ciclo é calculado o resto da divisão do maior valor pelo menor e, a seguir, são substituídos o maior pelo menor e o menor pelo resto da divisão efetuada. Esse ciclo é repetido até que o valor menor passe a ser zero. Neste caso, o máximo divisor comum é o que sobrou como maior valor. Exemplo: a 195 150 45 15

b 150 45 15 0

b, então a=n*k e b=m*k . O resto da Por que este algoritmo funciona? Se k é o máximo divisor comum de a e b, divisão a mod b também é múltiplo de k, pois a mod b = a−a÷b*b = n*k−((n*k)÷(m*k))*m*k = n*k−(n÷m)*m*k = (n−(n÷m)*m)*k , onde ÷ é usado para representar a operação de divisão inteira. O processo forçosamente converge para a solução, pois o maior valor sempre é substituído pelo menor e o menor pelo resto da divisão que sempre é menor que o valor do menor do ciclo anterior. Supondo que o usuário forneça inicialmente o valor do maior e depois o valor do menor. Neste caso o algoritmo pode ser descrito como sendo 1. leia a e b 2. enquanto b<>0 faça 1. r <− a mod b 2. a <− b 3. b <− r 3. apresente a E se o usuário inverter a ordem dos valores fornecidos, o que acontece com o processo descrito? Se a representa o







007 008 009 010 011 012 013 014 015 016 017

b = IO.readInt(); while (b != 0) { r = a % b; a = b; b = r; } IO.writeln(a); } }









Um algoritmo baseado em subtrações sucessivas é conhecido por "algoritmo de Euclides" e consiste no seguinte: a cada ciclo o maior valor é substituído pelo valor da diferença entre o maior valor e o menor valor até que os dois valores passam a ser iguais; quando passam a ser iguais, o máximo divisor comum procurado é um deles (tanto faz qual já que são iguais). Exemplo: a 195 45 45 45 45 30 15

b 150 150 105 60 15 15 15

b, então a=n*k e b=m*k b=m*k.. Se a é diferente Por que este algoritmo funciona? Se k é o máximo divisor comum de a e b, de b, b, então a diferença a−b também é múltiplo do máximo divisor comum, pois a−b = n*k−m*k = (n−m)*k . O algoritmo converge para a solução, pois a cada ciclo o maior valor é substituído pela diferença entre tal valor e o menor valor. A diferença é forçosamente menor do que o valor a ser substituído. O algoritmo pode ser descrito sucintamente como sendo: 1. leia a e b 2. enquanto a<>b faça 1. se a>b então 1. a <− a − b senão







008 009 010 011 012 013 014 015

b = IO.readInt(); while (a != b) if (a > b) a = a − b; else b = b − a; IO.writeln(a); } }









Cada número inteiro pode ser decomposto em fatores primos. Por exemplo: 150 75 25 5 1

| | | | |

2 3 5 5

E assim, 150 = 2*3*5*5 O máximo divisor comum pode ser obtido através da multiplicação dos fatores primos que os dois valores considerados têm em comum. Por exemplo: a 195

b 150

|

2

195

75

|

65 13 13 1

25 5 1 1

3 5

| | 5 | 13 |

mdc(195,150) 150) = 3*5 = 15. 15. Logo, mdc(195, Uma possível idéia para obter o máximo divisor comum baseada em decomposição em fatores primos até que um dos dois valores considerados seja reduzido ao valor um é a seguinte: Dado um número primo (o primeiro a ser considerado é o valor 2) verificamos se a e/ou b são divisíveis por tal número primo. Em caso afirmativo, o valor que é divisível é substituído pelo









65 13 13

25 5 1

| | |

5 5

15 15 ^ resultado

Se usarmos o símbolo ÷ para indicar a divisão inteira e o símbolo <> para indicar o operador de comparação que verifica se os valores de seus dois operandos são diferentes entre si, então o algoritmo pode ser descrito como sendo: 1. primo <− <− 2 2. res <− 1 3. leia a e b b<>1 faça 4. enquanto a<>1 OU 1. se a é divisível por primo primo então 1. a <− a÷primo 2. se b b é divisível por primo primo então 1. b <− b÷primo b÷primo 2. res <− res*primo senão 1. se b b é divisível por primo primo então 1. b <− b÷primo b÷primo senão 1. calcule o próximo primo 5. apresente res Resta ainda um problema a resolver: como vamos calcular o próximo número primo? Uma maneira rasteira de fazer isto é aumentar o valor do candidato a primo em uma unidade a cada ciclo e testar se existe algum valor entre 2 e o valor de candidato a primo menos 1 que divida o candidato a primo. Se existir repetimos o ciclo. Em caso contrário,







Aplicação

001 public class Mdc3 002 { 003 004 public static void main(String argv[]) 005 { 006 int a, b, p, limite, primo = 2, mdc = 1; 007 a = IO.readInt(); 008 b = IO.readInt(); 009 while (a != 1 || b != 1) 010 { 011 if (a % primo == 0) 012 { 013 a = a / primo; 014 if (b % primo == 0) 015 { 016 b = b / primo; 017 mdc = mdc * primo; 018 } 019 } else 020 if (b % primo == 0) b = b / primo; 021 // achar proximo primo else 022 (primo == 2) primo = 3; if 023 else

Algoritmos Java

Recommend Documents