New practice exercise variable-length-quantity

config.json

@@ -2593,6 +2593,29 @@
           "errors"
         ],
         "difficulty": 8
+       },
+       {
+        "slug": "variable-length-quantity",
+        "name": "Variable Length Quantity",
+        "uuid": "2e8b9b75-609d-4c99-947c-28274a9dbf27",
+        "prerequisites": [
+          "atoms",
+          "tuples",
+          "lists",
+          "enum",
+          "case",
+          "cond",
+          "if",
+          "multiple-clause-functions",
+          "pattern-matching",
+          "guards",
+          "integers",
+          "bit-manipulation"
+        ],
+        "practices": [
+          "bit-manipulation"
+        ],
+        "difficulty": 6
       }
     ],
     "foregone": [

exercises/practice/variable-length-quantity/.docs/instructions.md

@@ -0,0 +1,32 @@
+# Description
+
+Implement variable length quantity encoding and decoding.
+
+The goal of this exercise is to implement [VLQ](https://en.wikipedia.org/wiki/Variable-length_quantity) encoding/decoding.
+
+In short, the goal of this encoding is to encode integer values in a way that would save bytes.
+Only the first 7 bits of each byte is significant (right-justified; sort of like an ASCII byte).
+So, if you have a 32-bit value, you have to unpack it into a series of 7-bit bytes.
+Of course, you will have a variable number of bytes depending upon your integer.
+To indicate which is the last byte of the series, you leave bit #7 clear.
+In all of the preceding bytes, you set bit #7.
+
+So, if an integer is between `0-127`, it can be represented as one byte.
+Although VLQ can deal with numbers of arbitrary sizes, for this exercise we will restrict ourselves to only numbers that fit in a 32-bit unsigned integer.
+Here are examples of integers as 32-bit values, and the variable length quantities that they translate to:
+
+```text
+ NUMBER        VARIABLE QUANTITY
+00000000              00
+00000040              40
+0000007F              7F
+00000080             81 00
+00002000             C0 00
+00003FFF             FF 7F
+00004000           81 80 00
+00100000           C0 80 00
+001FFFFF           FF FF 7F
+00200000          81 80 80 00
+08000000          C0 80 80 00
+0FFFFFFF          FF FF FF 7F
+```

exercises/practice/variable-length-quantity/.formatter.exs

@@ -0,0 +1,4 @@
+# Used by "mix format"
+[
+  inputs: ["{mix,.formatter}.exs", "{config,lib,test}/**/*.{ex,exs}"]
+]

exercises/practice/variable-length-quantity/.meta/config.json

@@ -0,0 +1,18 @@
+{
+  "authors": ["jiegillet"],
+  "contributors": [],
+  "files": {
+    "example": [
+      ".meta/example.ex"
+    ],
+    "solution": [
+      "lib/variable_length_quantity.ex"
+    ],
+    "test": [
+      "test/variable_length_quantity_test.exs"
+    ]
+  },
+  "blurb": "Implement variable length quantity encoding and decoding.",
+  "source": "A poor Splice developer having to implement MIDI encoding/decoding.",
+  "source_url": "https://splice.com"
+}

exercises/practice/variable-length-quantity/.meta/example.ex

@@ -0,0 +1,49 @@
+defmodule VariableLengthQuantity do
+  @seven_bits Bitwise.<<<(1, 7) - 1
+  @eight_bit Bitwise.<<<(1, 7)
+
+  @doc """
+  Encode integers into a series of VLQ encoded bytes
+  """
+  @spec encode(integers :: [integer]) :: [integer]
+  def encode(integers) when is_list(integers) do
+    Enum.map(integers, &encode/1)
+    |> Enum.map(&Enum.reverse/1)
+    |> Enum.concat()
+  end
+
+  def encode(0), do: [0]
+  def encode(int, leading \\ 0)
+  def encode(0, _), do: []
+
+  def encode(int, leading) do
+    byte =
+      int
+      |> Bitwise.band(@seven_bits)
+      |> Bitwise.bor(leading)
+
+    rest = Bitwise.>>>(int, 7)
+    [byte | encode(rest, @eight_bit)]
+  end
+
+  @doc """
+  Decode a series of VLQ encoded bytes into a series of integers
+  """
+  @spec decode(bytes :: [integer]) :: {:ok, [integer]} | {:error, String.t()}
+  def decode(bytes, _status \\ :complete, acc \\ 0)
+  def decode([], :complete, _), do: {:ok, []}
+  def decode([], :incomplete, _), do: {:error, "incomplete sequence"}
+
+  def decode([byte | bytes], _status, acc) do
+    acc =
+      Bitwise.<<<(acc, 7)
+      |> Bitwise.bor(Bitwise.band(byte, @seven_bits))
+
+    if byte > @seven_bits do
+      decode(bytes, :incomplete, acc)
+    else
+      with {:ok, result} <- decode(bytes, :complete),
+           do: {:ok, [acc | result]}
+    end
+  end
+end

exercises/practice/variable-length-quantity/.meta/tests.toml

@@ -0,0 +1,87 @@
+# This is an auto-generated file.
+#
+# Regenerating this file via `configlet sync` will:
+# - Recreate every `description` key/value pair
+# - Recreate every `reimplements` key/value pair, where they exist in problem-specifications
+# - Remove any `include = true` key/value pair (an omitted `include` key implies inclusion)
+# - Preserve any other key/value pair
+#
+# As user-added comments (using the # character) will be removed when this file
+# is regenerated, comments can be added via a `comment` key.
+[35c9db2e-f781-4c52-b73b-8e76427defd0]
+description = "Encode a series of integers, producing a series of bytes. -> zero"
+
+[be44d299-a151-4604-a10e-d4b867f41540]
+description = "Encode a series of integers, producing a series of bytes. -> arbitrary single byte"
+
+[ea399615-d274-4af6-bbef-a1c23c9e1346]
+description = "Encode a series of integers, producing a series of bytes. -> largest single byte"
+
+[77b07086-bd3f-4882-8476-8dcafee79b1c]
+description = "Encode a series of integers, producing a series of bytes. -> smallest double byte"
+
+[63955a49-2690-4e22-a556-0040648d6b2d]
+description = "Encode a series of integers, producing a series of bytes. -> arbitrary double byte"
+
+[29da7031-0067-43d3-83a7-4f14b29ed97a]
+description = "Encode a series of integers, producing a series of bytes. -> largest double byte"
+
+[3345d2e3-79a9-4999-869e-d4856e3a8e01]
+description = "Encode a series of integers, producing a series of bytes. -> smallest triple byte"
+
+[5df0bc2d-2a57-4300-a653-a75ee4bd0bee]
+description = "Encode a series of integers, producing a series of bytes. -> arbitrary triple byte"
+
+[f51d8539-312d-4db1-945c-250222c6aa22]
+description = "Encode a series of integers, producing a series of bytes. -> largest triple byte"
+
+[da78228b-544f-47b7-8bfe-d16b35bbe570]
+description = "Encode a series of integers, producing a series of bytes. -> smallest quadruple byte"
+
+[11ed3469-a933-46f1-996f-2231e05d7bb6]
+description = "Encode a series of integers, producing a series of bytes. -> arbitrary quadruple byte"
+
+[d5f3f3c3-e0f1-4e7f-aad0-18a44f223d1c]
+description = "Encode a series of integers, producing a series of bytes. -> largest quadruple byte"
+
+[91a18b33-24e7-4bfb-bbca-eca78ff4fc47]
+description = "Encode a series of integers, producing a series of bytes. -> smallest quintuple byte"
+
+[5f34ff12-2952-4669-95fe-2d11b693d331]
+description = "Encode a series of integers, producing a series of bytes. -> arbitrary quintuple byte"
+
+[7489694b-88c3-4078-9864-6fe802411009]
+description = "Encode a series of integers, producing a series of bytes. -> maximum 32-bit integer input"
+
+[f9b91821-cada-4a73-9421-3c81d6ff3661]
+description = "Encode a series of integers, producing a series of bytes. -> two single-byte values"
+
+[68694449-25d2-4974-ba75-fa7bb36db212]
+description = "Encode a series of integers, producing a series of bytes. -> two multi-byte values"
+
+[51a06b5c-de1b-4487-9a50-9db1b8930d85]
+description = "Encode a series of integers, producing a series of bytes. -> many multi-byte values"
+
+[baa73993-4514-4915-bac0-f7f585e0e59a]
+description = "Decode a series of bytes, producing a series of integers. -> one byte"
+
+[72e94369-29f9-46f2-8c95-6c5b7a595aee]
+description = "Decode a series of bytes, producing a series of integers. -> two bytes"
+
+[df5a44c4-56f7-464e-a997-1db5f63ce691]
+description = "Decode a series of bytes, producing a series of integers. -> three bytes"
+
+[1bb58684-f2dc-450a-8406-1f3452aa1947]
+description = "Decode a series of bytes, producing a series of integers. -> four bytes"
+
+[cecd5233-49f1-4dd1-a41a-9840a40f09cd]
+description = "Decode a series of bytes, producing a series of integers. -> maximum 32-bit integer"
+
+[e7d74ba3-8b8e-4bcb-858d-d08302e15695]
+description = "Decode a series of bytes, producing a series of integers. -> incomplete sequence causes error"
+
+[aa378291-9043-4724-bc53-aca1b4a3fcb6]
+description = "Decode a series of bytes, producing a series of integers. -> incomplete sequence causes error, even if value is zero"
+
+[a91e6f5a-c64a-48e3-8a75-ce1a81e0ebee]
+description = "Decode a series of bytes, producing a series of integers. -> multiple values"

exercises/practice/variable-length-quantity/lib/variable_length_quantity.ex

@@ -0,0 +1,15 @@
+defmodule VariableLengthQuantity do
+  @doc """
+  Encode integers into a series of VLQ encoded bytes
+  """
+  @spec encode(integers :: [integer]) :: [integer]
+  def encode(integers) do
+  end
+
+  @doc """
+  Decode a series of VLQ encoded bytes into a series of integers
+  """
+  @spec decode(bytes :: [integer]) :: {:ok, [integer]} | {:error, String.t()}
+  def decode(bytes) do
+  end
+end

exercises/practice/variable-length-quantity/mix.exs

@@ -0,0 +1,28 @@
+defmodule VariableLengthQuantity.MixProject do
+  use Mix.Project
+
+  def project do
+    [
+      app: :variable_length_quantity,
+      version: "0.1.0",
+      # elixir: "~> 1.8",
+      start_permanent: Mix.env() == :prod,
+      deps: deps()
+    ]
+  end
+
+  # Run "mix help compile.app" to learn about applications.
+  def application do
+    [
+      extra_applications: [:logger]
+    ]
+  end
+
+  # Run "mix help deps" to learn about dependencies.
+  defp deps do
+    [
+      # {:dep_from_hexpm, "~> 0.3.0"},
+      # {:dep_from_git, git: "https://github.com/elixir-lang/my_dep.git", tag: "0.1.0"}
+    ]
+  end
+end

exercises/practice/variable-length-quantity/test/test_helper.exs

@@ -0,0 +1,2 @@
+ExUnit.start()
+ExUnit.configure(exclude: :pending, trace: true)