Aula 06: Indicadores de passagem

Tópicos

Indicadores de passagem

Problema 1:

Dados um número inteiro n, n>0, e uma sequência com n números inteiros, verificar se a sequência está em ordem crescente. 
  n = int(input("Digite o tam da seq: "))
  ant = int(input("Digite um num da seq: "))
  cresce = True
  i = 2
  while i <= n and cresce:
      num = int(input("Digite um num da seq: "))
      if num <= ant:
          cresce = False
      ant = num
      i = i + 1

  if cresce:
      print("Sequência crescente")
  else:
      print("Sequência não é crescente")

Problema 2:

Dado um número inteiro n>0, verificar se este número contém dois dígitos adjacentes iguais. 
  n = int(input("Digite o valor de n: "))
  adjiguais = False
  ant = n%10
  n = n//10
  while n > 0:
      r = n%10
      if ant == r:
          adjiguais = True
      ant = r
      n = n//10
  if adjiguais:
      print("Contém adjacentes iguais")
  else:
      print("Não contém adjacentes iguais")
Uma segunda solução usando uma condição extra de parada do laço.
Quando adjiguais recebe True, seu valor não é mais alterado, logo não há necessidade de continuar o laço nesse caso: 
  n = int(input("Digite o valor de n: "))
  adjiguais = False
  ant = n%10
  n = n//10
  while n > 0 and not adjiguais:
      r = n%10
      if ant == r:
          adjiguais = True
      ant = r
      n = n//10
  if adjiguais:
      print("Contém adjacentes iguais")
  else:
      print("Não contém adjacentes iguais")
Outra solução alternativa, inicializando a variável ant com um dígito inválido, ao invés de ler o primeiro dígito de n fora do laço. Com essa alteração, a condição do laço ant == r nunca será verdadeira na primeira iteração do laço. 
  n = int(input("Digite o valor de n: "))
  adjiguais = False
  ant = 10
  while n > 0 and not adjiguais:
      r = n%10
      if ant == r:
          adjiguais = True
      ant = r
      n = n//10
  if adjiguais:
      print("Contém adjacentes iguais")
  else:
      print("Não contém adjacentes iguais")

Problema 3:

Dados um número inteiro n, n>0, e uma sequência com n números inteiros, verificar se a sequência é uma progressão aritmética. 
n = int(input("Digite n: "))

a1 = int(input("Digite um num: "))
i = 1
if n > 1:
    a2 = int(input("Digite um num: "))
    i = 2
    r = a2 - a1 #razão da PA
    ant = a2

pa = True
while i < n:
    ai = int(input("Digite um num: "))
    if ai - ant != r:
        pa = False
    ant = ai
    i += 1    

if pa and n > 1:
    print("A sequência é uma P.A. de razão",r)
elif pa:
    print("A sequência é uma P.A.")
else:    
    print("A sequência não é uma P.A.")

Problema 4:

Dado um número inteiro n, n>0, verificar se n é primo.

Um número natural é um número primo quando ele tem exatamente dois divisores naturais distintos: o número um e ele mesmo. Por definição, 0 e 1 não são números primos.

Primeira solução: Um número primo n não pode ser divisível por nenhum outro número no intervalo [2,n-1]. Logo, testamos todos candidatos a divisores possíveis no intervalo [2,n-1], e usamos um indicador de passagem (variável primo) para sinalizar a ocorrência desse evento (divisão). Ao final do programa vale que primo == False se e somente se o número dado não é primo. 

  print("Teste de primalidade")
  n = int(input("Digite um inteiro: "))

  # o número é primo até que se prove o contrário
  primo = True #indicador de passagem
  d = 2 #os candidatos a divisores positivos de n
  while d < n:
      if n%d == 0:
          primo = False # não é primo!
      d += 1

  if n <= 1: #nenhum número natural <= 1 é primo.
      primo = False

  if primo:
      print("O número é primo")
  else:
      print("O número não é primo")

Segunda solução: Reduz o espaço de busca, testando apenas os candidatos a divisores positivos de n no intervalo 2,3,4,...,n/2. 

  print("Teste de primalidade")
  n = int(input("Digite um inteiro: "))

  if n <= 1: #nenhum número natural <= 1 é primo.
      primo = False
  else:
      # o número é primo até que se prove o contrário.
      primo = True #indicador de passagem

  d = 2 #os candidatos a divisores positivos de n.
  while d <= n//2 and primo:
      if n%d == 0:
          primo = False # não é primo!
      d += 1

  if primo:
      print("O número é primo")
  else:
      print("O número não é primo")

Terceira solução: Reduz o espaço de busca ainda mais. Testa se o número é par fora do laço principal. Dentro do while só testa candidatos a divisores ímpares. 

  print("Teste de primalidade")
  n = int(input("Digite um inteiro: "))

  if n <= 1: #nenhum número natural <= 1 é primo.
      primo = False
  elif n%2 == 0 and n > 2:
      primo = False #nenhum número par > 2 é primo.
  else:
      # o número é primo até que se prove o contrário
      # vale que n é um ímpar maior que 1 ou é 2.
      primo = True #indicador de passagem

  d = 3 #os candidatos a divisores positivos de n são 3,5,7,...,n/2
  while d <= n//2 and primo:
      if n%d == 0:
          primo = False # não é primo!
      d += 2

  if primo:
      print("O número é primo")
  else:
      print("O número não é primo")
Outras possíveis otimizações podem ser encontradas aqui.