Questão 03 - Implemente uma função para verificar se um dado ponto está dentro ou fora de um retângulo. Essa função deve receber como argumentos o vértice inferior esquerdo (x 1, y 1) e o vértice superior direito (\mathrm{x} 2, \mathrm{y} 2) que definem o retângulo. A função deve receber também o ponto ( \mathrm{x}, \mathrm{y} ) que será avaliado, retornando 1 se o ponto é interior, ou zero caso contrário. Fazer o módulo principal checando os seguintes casos:
a) Retângulo: (0,0) ;(1,1) \quad - Ponto (0.5,0.1);

Passo 1

O enunciado pede que a gente implemente uma função que verifique se um ponto está dentro ou fora de um retângulo. Precisamos receber como argumentos os vértices que definem o retângulo e o ponto a ser testado, e retornar 1 se o ponto for interior e 0 caso contrário. O enunciado também pede que o módulo principal cheque o caso específico:
Retângulo: (0,0);\,(1,1) — Ponto (0{,}5,\,0{,}1).
Informações relevantes dadas:
  • Vértice inferior esquerdo do retângulo: (x_1,y_1).
  • Vértice superior direito do retângulo: (x_2,y_2).
  • Ponto a verificar: (x,y).
  • Deve retornar 1 se o ponto for interior, ou 0 caso contrário.
  • Caso de teste a) com valores numéricos acima.

Passo 2

O que significa “ponto interior” e como verificar isso com desigualdades (a parte teórica, mastigada):
  • Um retângulo alinhado aos eixos é definido pelos intervalos das coordenadas x e y. Se o vértice inferior esquerdo tem coordenadas (x_1,y_1) e o vértice superior direito tem coordenadas (x_2,y_2), então o conjunto de pontos do retângulo é todos os (x,y) tais que
x_1 \le x \le x_2
e
y_1 \le y \le y_2.
  • Essas desigualdades significam: o ponto tem coordenada x entre os limites horizontais do retângulo e coordenada y entre os limites verticais.
  • Observação importante: há duas interpretações comuns de “interior”:
    • Inclusiva (usada aqui por padrão): aceita pontos na borda; usa desigualdades não estritas ( \le).
    • Estrita: só aceita pontos estritamente dentro, não na borda; usa desigualdades estritas ( <).
  • Se na entrada o programador der x_1>x_2 ou y_1>y_2 por engano, uma boa prática é normalizar trocando os valores para garantir que x_1\le x_2 e y_1\le y_2. Vou mostrar isso no código.

Passo 3

Algoritmo simples (explicando cada linha):
  1. Receber x_1,y_1,x_2,y_2,x,y.
  2. Se x_1>x_2 então trocar x_1 e x_2 (garante ordem).
  3. Se y_1>y_2 então trocar y_1 e y_2.
  4. Verificar as duas condições: x_1 \le x \le x_2e y_1 \le y \le y_2.
  5. Se ambas forem verdadeiras, retornar 1; caso contrário, retornar 0.
Agora mostro uma implementação em C (muito comum neste tipo de exercício). O código é curto e direto; comentários explicam as partes didaticamente.
#include <stdio.h>

int ponto_dentro(double x1, double y1, double x2, double y2, double x, double y) {
    /* Normaliza os vértices para garantir x1<=x2 e y1<=y2 */
    if (x1 > x2) {
        double tmp = x1; x1 = x2; x2 = tmp;
    }
    if (y1 > y2) {
        double tmp = y1; y1 = y2; y2 = tmp;
    }
    /* Verifica inclusão (aqui: inclusão de borda) */
    if (x1 <= x && x <= x2 && y1 <= y && y <= y2) return 1;
    else return 0;
}

int main(void) {
    double x1 = 0.0, y1 = 0.0, x2 = 1.0, y2 = 1.0;
    double x = 0.5, y = 0.1;
    int resultado = ponto_dentro(x1,y1,x2,y2,x,y);
    printf("%d\n", resultado); /* Esperamos imprimir 1 para este caso */
    return 0;
}
Explicação do código linha a linha:
  • A função ponto_dentro recebe os seis valores. Usamos double para aceitar pontos com casas decimais.
  • As trocas if (x1 > x2) e if (y1 > y2) garantem que as desigualdades abaixo façam sentido mesmo se os vértices vierem fora de ordem.
  • A condição x1 <= x && x <= x2 && y1 <= y && y <= y2 implementa exatamente as desigualdades matemáticas que vimos: o ponto está entre os limites horizontais e verticais.
  • A main testa o caso pedido e imprime o resultado.

Passo 4

Como raciocinar isso “na prova” sem código (ou se tiver que explicar rapidamente):
  • Pegue os números e cheque cada desigualdade uma a uma.
  • Para o eixo x: verifique se x_1 \le x \le x_2.
  • Para o eixo y: verifique se y_1 \le y \le y_2.
  • Se ambas verdadeiras, ponto interior; senão, fora.
  • Se pedirem interior estrito, troque \le por <.

Passo 5

Aplicando ao caso específico pedido (fazendo as contas passo a passo e explicando):
  • Retângulo: x_1=0,\;y_1=0,\;x_2=1,\;y_2=1.
  • Ponto: x=0{,}5,\;y=0{,}1.
  • Verificação em x: 0 \le 0{,}5 \le 1
    • 0 \le 0{,}5 é verdadeiro.
    • 0{,}5 \le 1 é verdadeiro.
    • Logo a condição em x é verdadeira.
  • Verificação em y: 0 \le 0{,}1 \le 1
    • 0 \le 0{,}1 é verdadeiro.
    • 0{,}1 \le 1 é verdadeiro.
    • Logo a condição em y é verdadeira.
  • Como ambas são verdadeiras, o ponto é interior (na interpretação inclusiva) e a função retorna 1.

Passo 6

Saída esperada e observações finais:
  • Se você compilar e rodar o programa acima, verá que ele imprime:
    1
    
    indicando que o ponto está dentro do retângulo.
  • Se o enunciado quiser excluir pontos na borda, altere as comparações para x1 < x && x < x2 && y1 < y && y < y2.
  • Dica prática para prova: escreva as desigualdades explicitamente com os números e verifique cada uma; isso evita erros bobos.

Resposta

1

Exercícios relacionados