coproduto

Roadmap de estudos de SQL

Aviso: Muitas vezes detalhes de várias operações podem variar de banco para banco. Em questões onde fiquei em dúvida, este documento segue o funcionamento do PostgreSQL, pois é o banco que conheço melhor.

Pré-requisito: Álgebra Relacional básica

Antes de começar a escrever SQL, você precisa entender o modelo de como um banco de dados relacional funciona. Não precisa se aprofundar muito, mas você precisa entender como que dados e relacionamentos entre eles são representados. (Nota importante: Relacionamento e relação não são a

coproduto

Toda Monad é um tipo genérico. Para um tipo genérico ser uma monad, ele tem que suportar a seguinte "interface":

Dado que nossa monad é o tipo M onde A é algum tipo de parâmetro, devem existir as seguintes funçÕes:

function pure(A): M<A>
function bind<B>(M<A>, A -> M<B>): M<B>

A função pure "injeta" um valor dentro da monad com contexto "neutro".

coproduto

/* A função reduce é capaz de representar uma grande quantidade de loops imperativos. 
 * Por que isso é possível? Reduce não é só pra extrair um valor primitivo de um array?
 *
 * Bom, não exatamente. Na verdade, o reduce *encapsula* uma lógica que representa muitos
 * dos loops que fazemos.
 *
 * Os argumentos do reduce são:
 *   * Um array de algum tipo Elem de elementos;
 *   * Um acumulador inicial de algum tipo Acc;
 *   * Uma função que recebe um acumulador (tipo Acc), um elemento (tipo Elem) e retorna um novo acumulador;

coproduto

Esboço de prova

As duas taças começam com volumes iguais V de cada um dos seus vinhos. Representamos cada taça como um par onde o primeiro valor é a quantidade de vinho tinto e a segunda é a quantidade de vinho branco na taça. As duas taças são representadas como um par de pares.

Então o estado inicial é:

((V, 0), (0, V))

coproduto

#!/bin/bash
trap : SIGTERM SIGINT # : é um noop - só estamos dizendo que queremos receber os sinais

echo $$ # $$ contém o PID do próprio script

find / >/dev/null 2>&1 &
FIND_PID=$! # $! contém o PID do último processo iniciado

wait $FIND_PID # Esperamos até o PID encerrar ou recebermos um sinal

coproduto

function ifSemElse(lol) {
  if (!lol) return 0;
  
  fazUmaCoisa();
  return fazMaisCoisas(lol);
}

// Você até poderia escrever essa função assim:
function comElse(lol) {
  if (!lol) {

coproduto

int do_something(int arg) {
  if (arg > 0) {
    printf("%d", arg);
    do_something(arg - 1);
  } else { 
    /*** if arg <= 0 ***/
    return 0;
  }
  /*** END if arg > 0 ***/
}

coproduto

defmodule Parens do
  def generate(n) do
    n
    |> generate_trees()
    |> Enum.map(&IO.iodata_to_binary/1)
  end

  defp generate_trees(0), do: []
  defp generate_trees(1), do: [["()"]]
  defp generate_trees(n) do

coproduto

defmodule Primality do
  # O jeito "ingênuo" de checar por primalidade é você simplesmente verificar
  # se o número tem divisores. Ou seja, você pega todos os números menores
  # que o seu número-alvo (começando em 2, pois 1 divide todos os números)
  # e verifica se eles dividem o número (ou seja, se o resto da divisão -
  # função `rem/1` - é igual a 0).
  #
  # Também precisamos de um caso especial para 1, que não tem divisores mas não
  # é primo.
  def check_naive(1), do: false

coproduto

defmodule Change do
  # A intuição para resolver este problema é entender que
  # quando você vai fazer troco para um valor, dado um certo
  # conjunto de moedas, você tem duas escolhas:
  #
  # 1. Você pode usar a moeda de maior valor que você tem
  # 2. Você pode fazer troco sem usar essa moeda.
  #
  # Se você escolher a opção 1, você está implicitamente dizendo
  # que você vai usar pelo menos 1 moeda daquele tipo.