example code

### Elixir:

defmodule RunLengthEncoder do
  @doc """
  Generates a string where consecutive elements are represented as a data value and count.
  "HORSE" => "1H1O1R1S1E"
  For this example, assume all input are strings, that are all uppercase letters.
  It should also be able to reconstruct the data into its original form.
  "1H1O1R1S1E" => "HORSE"
  """
  @spec encode(String.t) :: String.t
  def encode(string) do
    string
    |> String.codepoints
    |> chunk_by_letter
    |> count_letters
    |> generate_encoded_string
  end

  @spec chunk_by_letter(String.t) :: [[String.t]]
  defp chunk_by_letter(string_list) do
    Enum.chunk_by(string_list, &(&1))
  end

  @spec count_letters([[String.t]]) :: [{number, String.t}]
  defp count_letters(list) do
    Enum.map(list, fn letters -> {length(letters), hd(letters)} end)
  end

  @spec generate_encoded_string([{number, String.t}]) :: String.t
  defp generate_encoded_string(pairs) do
    Enum.reduce(pairs, "", fn {n, char}, acc -> acc <> Integer.to_string(n) <> char end)
  end

  @spec decode(String.t) :: String.t
  def decode(string) do
    string
    |> chunk_by_number_and_letter
    |> get_heads
    |> split_into_pairs_of_number_and_letter
    |> generate_decoded_string
  end

  @spec chunk_by_number_and_letter(String.t) :: [String.t]
  defp chunk_by_number_and_letter(string) do
    Regex.scan(~r/\d+\p{L}+/, string)
  end

  @spec get_heads([[]]) :: []
  defp get_heads(list_of_lists) do
    Enum.map(list_of_lists, &hd/1)
  end

  @spec split_into_pairs_of_number_and_letter([String.t]) :: [{number, String.t}]
  defp split_into_pairs_of_number_and_letter(elements) do
    Enum.map(elements, &Integer.parse/1)
  end

  @spec generate_decoded_string([{number, String.t}]) :: String.t
  defp generate_decoded_string(pairs) do
    Enum.reduce(pairs, "", fn {n, char}, acc -> acc <> String.duplicate(char, n) end)
  end
end




### Java:
import javafx.geometry.Point3D;

import java.util.ArrayList;
import java.util.List;

import static comets.Gravity.calculateForce;

public class World {
    private List<SpaceObject> spaceObjects = new ArrayList<>();
    private double time = 0;

    public List<SpaceObject> getSpaceObjects() {
        return spaceObjects;
    }

    public void addSpaceObject(SpaceObject object) {
        spaceObjects.add(object);
    }

    public void addSpaceObjects(List<SpaceObject> objects) {
        spaceObjects.addAll(objects);
    }

    public double getTime() {
        return time;
    }

    public void increaseTime(double timeStep) {
        time += timeStep;
    }

    public double getEnergy() {
        double kineticEnergy = 0;
        double potentialEnergy = 0;

        for (int i = 0; i < spaceObjects.size(); i++) {
            kineticEnergy += getKineticEnergy(spaceObjects.get(i));

            for (int j = i+1; j < spaceObjects.size(); j++) {
                potentialEnergy += getPotentialEnergy(spaceObjects.get(i), spaceObjects.get(j));
            }
        }
        potentialEnergy *= Gravity.GRAVITATIONAL_CONSTANT;
        return kineticEnergy + potentialEnergy;
    }

    private double getKineticEnergy(SpaceObject object) {
        double velocity = object.getVelocity().magnitude();
        return object.getMass() * velocity * velocity * 0.5;
    }

    private double getPotentialEnergy(SpaceObject firstObject, SpaceObject secondObject) {
        return -firstObject.getMass() * secondObject.getMass() / firstObject.getPosition().distance(secondObject.getPosition());
    }

    public void calculateForces() {
        spaceObjects.forEach((object) -> object.setForce(Point3D.ZERO));

        for (int i = 0; i < spaceObjects.size(); i++) {
            for (int j = i+1; j < spaceObjects.size(); j++) {
                setForcesBetweenTwoObjects(spaceObjects.get(i), spaceObjects.get(j));
            }
        }

        spaceObjects.forEach(SpaceObject::multiplyForceByGravitationalConstant);
        spaceObjects.forEach(SpaceObject::divideForceByMass);
    }

    private void setForcesBetweenTwoObjects(SpaceObject first, SpaceObject second) {
        Point3D force = calculateForce(first, second);

        first.setForce(first.getForce().add(force));
        second.setForce(second.getForce().subtract(force));
    }
}