Pronto para encarar problemas clássicas de lógica em PHP e descobrir juntos as melhores soluções?

Compreendendo a lógica de programação em PHP

• Estruturas de controle: permitem direcionar o fluxo do programa, como if/else, switch, for, while e foreach.

• Estruturas de dados: formas de armazenar e manipular dados, como arrays (associativos e indexados) e objetos.

• Paradigmas específicos: PHP suporta Programação Orientada a Objetos (POO) e recursos funcionais, permitindo escrever código modular e reutilizável.

Missão extra: explore o universo PHP!

• PHP: Casos de uso em grandes empresas

• Loops em PHP explicados de forma simples

• Como configurar seu ambiente PHP

• PHP: Como criar e utilizar funções

• Estruturas condicionais em PHP: Guia para iniciantes

Problemas clássicos de lógica e suas soluções

1. Calculadora básica

<?php
echo "Digite o primeiro número: ";
$num1 = (float) fgets(STDIN);

echo "Digite o operador (+, -, *, /): ";
$operador = trim(fgets(STDIN));

echo "Digite o segundo número: ";
$num2 = (float) fgets(STDIN);

$resultado = 0;

switch ($operador) {
    case '+':
        $resultado = $num1 + $num2;
        break;
    case '-':
        $resultado = $num1 - $num2;
        break;
    case '*':
        $resultado = $num1 * $num2;
        break;
    case '/':
        if ($num2 != 0) {
            $resultado = $num1 / $num2;
        } else {
            echo "Erro: Divisão por zero não é permitida!\n";
            exit;
        }
        break;
    default:
        echo "Operador inválido!\n";
        exit;
}

echo "Resultado: $resultado\n";
?>

Explicação do código

1. Entrada de dados: utilizamos fgets(STDIN) para ler a entrada do usuário no terminal.

2. Conversão de tipos: convertendo as entradas para float para permitir cálculos com decimais.

3. Operador: o operador é lido como string e usamos trim() para remover espaços em branco.

4. Estrutura de controle: utilizamos um switch para determinar qual operação será realizada com base no operador fornecido.

5. Divisão por zero: incluímos uma verificação para evitar divisão por zero, exibindo uma mensagem de erro caso aconteça.

6. Saída: exibimos o resultado da operação escolhida.

2. Fatorial de um número

<?php
function calcularFatorial($n) {
    if ($n <= 1) {
        return 1;
    } else {
        return $n * calcularFatorial($n - 1);
    }
}

echo "Digite um número para calcular o fatorial: ";
$numero = (int) fgets(STDIN);

$resultado = calcularFatorial($numero);
echo "O fatorial de $numero é $resultado\n";
?>

Explicação do código

1. Função recursiva: a função calcularFatorial chama a si mesma até que n seja menor ou igual a 1.

2. Caso base: quando n é 0 ou 1, o fatorial é 1.

3. Recursão: multiplicamos n pelo fatorial de n - 1.

4. Entrada e saída: o usuário insere um número, e exibimos o fatorial calculado.

3. Sequência de Fibonacci

<?php
function fibonacci($n) {
    $sequencia = [0, 1];
    for ($i = 2; $i < $n; $i++) {
        $sequencia[$i] = $sequencia[$i - 1] + $sequencia[$i - 2];
    }
    return $sequencia;
}

echo "Quantos termos da sequência de Fibonacci você deseja? ";
$termos = (int) fgets(STDIN);

$sequencia = fibonacci($termos);
echo "Sequência de Fibonacci com $termos termos:\n";
echo implode(", ", $sequencia) . "\n";
?>

Explicação do código

1. Inicialização: começamos a sequência com os valores [0, 1].

2. Loop: utilizamos um for para calcular cada termo adicional, somando os dois anteriores.

3. Função: a função fibonacci retorna um array com a sequência até o termo desejado.

4. Saída: utilizamos implode para exibir a sequência separada por vírgulas.

4. Verificar Palíndromo

<?php
function ePalindromo($texto) {
    // Remover espaços e caracteres especiais
    $textoLimpo = preg_replace('/[^A-Za-z0-9]/', '', strtolower($texto));
    // Inverter o texto
    $textoInvertido = strrev($textoLimpo);
    // Verificar se é palíndromo
    return $textoLimpo === $textoInvertido;
}

echo "Digite uma palavra ou frase: ";
$entrada = fgets(STDIN);

if (ePalindromo($entrada)) {
    echo "É um palíndromo!\n";
} else {
    echo "Não é um palíndromo.\n";
}
?>

Explicação do código

1. Limpeza do texto: usamos preg_replace para remover espaços e caracteres não alfanuméricos, e strtolower para deixar tudo em minúsculas.

2. Inversão: utilizamos strrev para inverter o texto limpo.

3. Comparação: verificamos se o texto limpo é igual ao invertido.

4. Entrada e saída: o usuário digita uma palavra ou frase, e informamos se é um palíndromo.

5. Máximo divisor comum (MDC)

<?php
function calcularMDC($a, $b) {
    while ($b != 0) {
        $resto = $a % $b;
        $a = $b;
        $b = $resto;
    }
    return $a;
}

echo "Digite o primeiro número: ";
$num1 = (int) fgets(STDIN);
echo "Digite o segundo número: ";
$num2 = (int) fgets(STDIN);

$mdc = calcularMDC($num1, $num2);
echo "O MDC de $num1 e $num2 é $mdc\n";
?>

Explicação do código

1. Algoritmo de Euclides: repetimos o processo de dividir a por b e atribuir b ao resto até que b seja zero.

2. Função: a função calcularMDC retorna o MDC dos dois números fornecidos.

3. Entrada e saída: o usuário insere dois números, e exibimos o MDC calculado.

6. Ordenação com bubble sort

<?php
function bubbleSort($array) {
    $tamanho = count($array);
    for ($i = 0; $i < $tamanho - 1; $i++) {
        for ($j = 0; $j < $tamanho - $i - 1; $j++) {
            if ($array[$j] > $array[$j + 1]) {
                // Troca
                $temp = $array[$j];
                $array[$j] = $array[$j + 1];
                $array[$j + 1] = $temp;
            }
        }
    }
    return $array;
}

echo "Digite números separados por vírgula: ";
$entrada = fgets(STDIN);
$numeros = array_map('intval', explode(',', $entrada));

$numerosOrdenados = bubbleSort($numeros);
echo "Números ordenados: " . implode(', ', $numerosOrdenados) . "\n";
?>

Explicação do código

1. Entrada de dados: o usuário insere números separados por vírgula, que são convertidos em um array de inteiros.

2. Algoritmo bubble sort: compara elementos adjacentes e os troca se estiverem fora de ordem, repetindo o processo até que o array esteja ordenado.

3. Saída: exibimos os números ordenados.

7. Ordenação com quick sort

<?php
function quickSort($array) {
    if (count($array) < 2) {
        return $array;
    }
    $pivo = $array[0];
    $esquerda = [];
    $direita = [];

    for ($i = 1; $i < count($array); $i++) {
        if ($array[$i] <= $pivo) {
            $esquerda[] = $array[$i];
        } else {
            $direita[] = $array[$i];
        }
    }

    return array_merge(quickSort($esquerda), [$pivo], quickSort($direita));
}

echo "Digite números separados por vírgula: ";
$entrada = fgets(STDIN);
$numeros = array_map('intval', explode(',', $entrada));

$numerosOrdenados = quickSort($numeros);
echo "Números ordenados: " . implode(', ', $numerosOrdenados) . "\n";
?>

Explicação do código

1. Recursão: o Quick Sort é um algoritmo recursivo que divide o array em subarrays menores.

2. Pivô: escolhemos o primeiro elemento como pivô e separamos os demais em arrays esquerda e direita.

3. Concatenação: utilizamos array_merge para juntar os arrays ordenados.

4. Entrada e Saída: o usuário insere números, e exibimos os números ordenados.

Dicas para Resolver Problemas de Lógica em PHP

• Decomponha o problema: divida em partes menores e resolva uma de cada vez.

• Use ferramentas de depuração: utilize var_dump, print_r e debuggers para inspecionar variáveis e fluxo do programa.

• Escreva testes unitários: use frameworks como PHPUnit para validar seu código.

• Explore bibliotecas e frameworks: Ferramentas como Composer e frameworks como Laravel podem simplificar muito o desenvolvimento.

• Pratique regularmente: a prática leva à perfeição. Continue desafiando a si mesmo com novos problemas.

Conclusão