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

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

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

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

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.

coproduto

defmodule BalancedDelimiters do
  @openers [
    ?(,
    ?[,
    ?{
  ] 

  @closers [
    ?),
    ?],

coproduto

-- Notar que Haskell não usa parênteses pra chamar funções, então `f a b` seria `f(a, b)` em 
-- outras linguagens

-- suponhamos um joguinho estilo space invaders
-- aí em cada frame você verifica se uma bala tá colidindo com algum inimigo
-- e se tiver colisões isso causa atualizações específicas do estado
evalFrame gameState =
  case getBulletCollisions gameState of
    [] -> continueEvalFrame gameState -- lista vazia, nenhuma colisão, só executamos outros updates
    collisions ->