6ku_2
PI approximation
https://www.codewars.com/kata/550527b108b86f700000073f
defmodule Piapprox do
def iter_pi(epsilon) do
Stream.iterate(1, fn x -> x + 1 end)
|> Enum.reduce_while(4, fn x, acc ->
if abs(:math.pi() - acc) > epsilon do
if rem(x, 2) == 0 do
{:cont, acc + 1 / (x * 2 + 1) * 4}
else
{:cont, acc - 1 / (x * 2 + 1) * 4}
end
else
{:halt, [x, trunc(acc * 1.0e10) / 1.0e10]}
end
end)
end
end
Piapprox.iter_pi(0.01)
# 1315929035
# :math.pi()
Calculate the area of a regular n sides polygon inside a circle of radius r
https://www.codewars.com/kata/5a58ca28e626c55ae000018a
defmodule Kata do
def area_of_polygon_inside_circle(circle_radius, number_of_sides) do
Float.round(
circle_radius * circle_radius * number_of_sides *
:math.sin(:math.pi() / number_of_sides * 2) /
2,
3
)
end
end
Kata.area_of_polygon_inside_circle(3, 3)
Array.diff
https://www.codewars.com/kata/523f5d21c841566fde000009
defmodule ArrayDiff do
def array_diff(a, b), do: Enum.reject(a, &(&1 in b))
end
# [2,2]
ArrayDiff.array_diff([1, 2, 2], [1])
Roman Numerals Decoder
https://www.codewars.com/kata/51b6249c4612257ac0000005
defmodule Solution do
@digit %{"I" => 1, "V" => 5, "X" => 10, "L" => 50, "C" => 100, "D" => 500, "M" => 1000}
def decode(roman) do
roman = roman |> String.graphemes()
roman
|> Enum.map(&@digit[&1])
|> Enum.with_index()
|> Enum.reduce(0, fn {x, y}, acc ->
if Enum.at(roman, y + 1) != nil and @digit[Enum.at(roman, y + 1)] > x,
do: acc - x,
else: acc + x
end)
end
end
Solution.decode("XLVI")
Esolang Interpreters #1 - Introduction to Esolangs and My First Interpreter (MiniStringFuck)
https://www.codewars.com/kata/586dd26a69b6fd46dd0000c0
defmodule MiniStringFuck do
@moduledoc false
def execute(command) do
command
|> String.codepoints()
|> Enum.reduce({0, []}, fn
"+", {255, out} -> {0, out}
"+", {x, out} -> {x + 1, out}
".", {x, out} -> {x, [out | [x]]}
_cp, acc -> acc
end)
|> elem(1)
|> List.to_string()
end
end
# function myFirstInterpreter(code) {
# let out = "",
# byte = 0;
# [...code].forEach(cmd => {
# switch (cmd) {
# case "+":
# byte = (byte + 1) % 256;
# break;
# case ".":
# out += String.fromCharCode(byte);
# break;
# }
# });
# return out;
# }
alphabet_program = String.duplicate("+", 65) <> String.duplicate(".+", 25) <> "."
# == "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
MiniStringFuck.execute(alphabet_program)
Statistics for an Athletic Association
https://www.codewars.com/kata/55b3425df71c1201a800009c
defmodule AthleticAssociation do
def stat(""), do: ""
def stat(string) do
ts =
string
|> String.split(", ")
|> Enum.map(&String.split(&1, "|"))
|> Enum.map(&Enum.map(&1, fn x -> String.to_integer(x) end))
|> Enum.map(fn [h, m, s] -> h * 60 * 60 + m * 60 + s end)
|> Enum.sort()
"Range: #{format(range(ts))} Average: #{format(avg(ts))} Median: #{format(median(ts))}"
end
defp range(ts), do: Enum.min_max(ts) |> (fn {min, max} -> max - min end).()
defp avg(ts), do: Enum.sum(ts) |> div(Enum.count(ts))
defp median(ts), do: ts |> length() |> div_rem(2) |> median(ts)
defp median({half, 0}, ts), do: avg(Enum.slice(ts, half - 1, 2))
defp median({half, 1}, ts), do: Enum.at(ts, half)
defp div_rem(dividend, divisor), do: {div(dividend, divisor), rem(dividend, divisor)}
defp format(t) do
{h, x} = div_rem(t, 60 * 60)
{m, s} = div_rem(x, 60)
[h, m, s]
|> Enum.map(&Integer.to_string/1)
|> Enum.map_join("|", &String.pad_leading(&1, 2, "0"))
end
end
AthleticAssociation.stat("01|15|59, 1|47|16, 01|17|20, 1|32|34, 2|17|17")
Are they the “same”?
https://www.codewars.com/kata/550498447451fbbd7600041c
defmodule Aretheythesame do
@spec comp([number], [number]) :: boolean
def comp(a, b) do
a |> Enum.map(&(&1 * &1)) |> Enum.sort() == b |> Enum.sort()
end
end
a = [121, 144, 19, 161, 19, 144, 19, 11]
b = [11 * 11, 121 * 121, 144 * 144, 19 * 19, 161 * 161, 19 * 19, 144 * 144, 19 * 19]
Aretheythesame.comp(a, b)
Disguised sequences (II)
https://www.codewars.com/kata/56fe17fcc25bf3e19a000292
defmodule Disguised2 do
def v1(n, p) do
Stream.iterate(0, fn x -> x + 1 end)
|> Enum.reduce_while(0, fn x, result ->
if x <= n do
# IO.inspect(pow(-1, x))
# IO.inspect(:math.pow(-1, x))
# IO.inspect(pow(4, n - x))
# IO.inspect(n-x)
# IO.inspect(:math.pow(4, n - x))
part = :math.pow(-1, x) * p * :math.pow(4, n - x)
IO.inspect(part)
abc = n * 2 - x
{:cont, result + part * div(factorial(abc), factorial(abc - x) * factorial(x))}
else
{:halt, result}
end
end)
end
def u1(n, p) do
Stream.iterate(0, fn x -> x + 1 end)
|> Enum.reduce_while(0, fn x, result ->
if x <= n do
part = :math.pow(-1, x) * p * :math.pow(4, n - x)
abc = n * 2 - x + 1
{:cont, result + part * div(factorial(abc), factorial(abc - x) * factorial(x))}
else
{:halt, result}
end
end)
end
def v_eff(n, p) do
v1(n, p)
end
def u_eff(n, p) do
u1(n, p)
end
def pow(n, x) do
Enum.reduce(1..x, 1, fn _, acc -> n * acc end)
end
def factorial(n) when n <= 1, do: 1
def factorial(n) when n > 1, do: n * factorial(n - 1)
end
Disguised2.v1(1, 14)