coproduto

# -*- mode: gitignore; -*-

# This file was mostly stitched together from a bunch of gitignore files 
# found at https://github.com/github/gitignore and is customized for my 
# OS X setup.

# Emacs stuff #
###############
*~
\#*\#

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

defmodule LevelOrderTraversal do
  # Nós da árvore representados como {valor, {filho_direita, filho_esquerda}}
  @type tree :: {term, {tree | nil, tree | nil}}

  # Função que converte a árvore em seus níveis
  @spec traverse(tree) :: [[term]]
  def traverse(nil), do: [[]]

  def traverse({x, {l, r}}) do
    [[x] | Enum.zip_with(traverse(l), traverse(r), &Enum.concat/2)]

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