Operadores // e % (Divisão inteira e Resto)

Operador	Nome	Explicação	Exemplos
//	Divisão Inteira	Retorna a parte inteira do quociente	4 // 3 retorna 1
%	Módulo	Retorna o resto da divisão	8% 3 retorna 2

Exemplo:

Dados um número inteiro n, n>0, e uma sequência com n números inteiros, determinar quantos números da sequência são pares e quantos são ímpares. Por exemplo, para a sequência

    6    -2    7   0    -5    8   4

o seu programa deve escrever o número 4 para o número de pares e 2 para o de ímpares.

  n = int(input("Digite o tam da seq: "))
  contap = 0
  contai = 0
  i = 1
  while i <= n:
      num = int(input("Digite um num da seq: "))
      if num%2 == 0: #par
          contap = contap + 1
      else: #ímpar
          contai = contai + 1
      i = i + 1
  print(contap,"números pares")
  print(contai,"números ímpares")

Problema 1:

Dados um número inteiro n, n > 0, e um dígito d (0<=d<=9), determinar quantas vezes d ocorre em n. Por exemplo, 3 ocorre 2 vezes em 63453.

  n = int(input("Digite o valor de n: "))
  d = int(input("Digite um dígito [0,9]: "))
  num = n
  cont = 0
  while n != 0:
      r = n % 10
      if r == d:
          cont = cont + 1
      n = n // 10

  print(d,"ocorre",cont,"vezes em",num)

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:

Qualquer número natural de quatro algarismos pode ser dividido em duas dezenas formadas pelos seus dois primeiros e dois últimos dígitos.
Exemplos:

1297: 12 e 97.
5314: 53 e 14.

Escreva um programa que imprime todos os milhares (4 algarismos) cuja raiz quadrada seja a soma das dezenas formadas pela divisão acima.

Exemplo: raiz de 9801 = 99 = 98 + 01.
Portanto 9801 é um dos números a ser impresso.

  i = 1000
  while i<=9999:
      d1 = i%100
      d2 = i//100
      if (d1+d2)*(d1+d2) == i:
          print(i)
      i = i + 1