Skip to content

Instantly share code, notes, and snippets.

View coproduto's full-sized avatar

Cast coproduto

View GitHub Profile

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))

#!/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
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 ***/
}
function ifSemElse(lol) {
if (!lol) return 0;
fazUmaCoisa();
return fazMaisCoisas(lol);
}
// Você até poderia escrever essa função assim:
function comElse(lol) {
if (!lol) {
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
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
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.
defmodule BalancedDelimiters do
@openers [
?(,
?[,
?{
]
@closers [
?),
?],
-- 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 ->
-- Imagina que a gente não tivesse recursão. Isso significaria essencialmente que uma expressão não pode se referir ao nome
-- dela mesma dentro da definição dela. Por exemplo, a definição de fatorial abaixo não poderia existir:
factorialRec n = n * factorialRec (n - 1)
-- Como o nome factorialRec é citado na função e estamos proibindo citar o nome da própria função, esse termo se torna
-- ilegal. Então como poderíamos escrever a função fatorial? Bom, uma ideia é trocar a chamada recursiva por um argumento:
factorialOpen f n = n * f (n - 1)