Add relative-distance

config.json

@@ -1054,6 +1054,19 @@
         ],
         "difficulty": 5
       },
+      {
+        "slug": "relative-distance",
+        "name": "Relative Distance",
+        "uuid": "a3cf95fd-c7c1-4199-a253-7bae8d1aba9a",
+        "practices": [
+          "maps"
+        ],
+        "prerequisites": [
+          "lists",
+          "maps"
+        ],
+        "difficulty": 5
+      },
       {
         "slug": "robot-name",
         "name": "Robot Name",

exercises/practice/relative-distance/.docs/instructions.md

@@ -0,0 +1,39 @@
+# Instructions
+
+Your task is to determine the degree of separation between two individuals in a family tree.
+This is similar to the pop culture idea that every Hollywood actor is [within six degrees of Kevin Bacon][six-bacons].
+
+- You will be given an input, with all parent names and their children.
+- Each name is unique, a child _can_ have one or two parents.
+- The degree of separation is defined as the shortest number of connections from one person to another.
+- If two individuals are not connected, return a value that represents "no known relationship."
+  Please see the test cases for the actual implementation.
+
+## Example
+
+Given the following family tree:
+
+```text
+      ┌──────────┐            ┌──────────┐     ┌───────────┐
+      │  Helena  │            │  Erdős   ├─────┤  Shusaku  │
+      └───┬───┬──┘            └─────┬────┘     └────┬──────┘
+      ┌───┘   └───────┐             └───────┬───────┘
+┌─────┴────┐     ┌────┴───┐           ┌─────┴────┐
+│   Isla   ├─────┤ Tariq  │           │   Kevin  │
+└────┬─────┘     └────┬───┘           └──────────┘
+     │                │
+┌────┴────┐      ┌────┴───┐
+│   Uma   │      │ Morphy │
+└─────────┘      └────────┘
+```
+
+The degree of separation between Tariq and Uma is 2 (Tariq → Isla → Uma).
+There's no known relationship between Isla and Kevin, as there is no connection in the given data.
+The degree of separation between Uma and Isla is 1.
+
+~~~~exercism/note
+Isla and Tariq are siblings and have a separation of 1.
+Similarly, this implementation would report a separation of 2 from you to your father's brother.
+~~~~
+
+[six-bacons]: https://en.m.wikipedia.org/wiki/Six_Degrees_of_Kevin_Bacon

exercises/practice/relative-distance/.docs/introduction.md

@@ -0,0 +1,12 @@
+# Introduction
+
+You've been hired to develop **Noble Knots**, the hottest new dating app for nobility!
+With centuries of royal intermarriage, things have gotten… _complicated_.
+To avoid any _oops-we're-twins_ situations, your job is to build a system that checks how closely two people are related.
+
+Noble Knots is inspired by Iceland's "[Islendinga-App][islendiga-app]," which is backed up by a database that traces all known family connections between Icelanders from the time of the settlement of Iceland.
+Your algorithm will determine the **degree of separation** between two individuals in the royal family tree.
+
+Will your app help crown a perfect match?
+
+[islendiga-app]: http://www.islendingaapp.is/information-in-english/

exercises/practice/relative-distance/.meta/config.json

@@ -0,0 +1,22 @@
+{
+  "authors": [
+    "BNAndras"
+  ],
+  "files": {
+    "solution": [
+      "src/main/java/RelativeDistance.java"
+    ],
+    "test": [
+      "src/test/java/RelativeDistanceTest.java"
+    ],
+    "example": [
+      ".meta/src/reference/java/RelativeDistance.java"
+    ],
+    "invalidator": [
+      "build.gradle"
+    ]
+  },
+  "blurb": "Given a family tree, calculate the degree of separation.",
+  "source": "vaeng",
+  "source_url": "https://github.com/exercism/problem-specifications/pull/2537"
+}

exercises/practice/relative-distance/.meta/src/reference/java/RelativeDistance.java

@@ -0,0 +1,68 @@
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import java.util.Queue;
+
+class RelativeDistance {
+
+    private final Map<String, HashSet<String>> graph;
+
+    RelativeDistance(Map<String, List<String>>  familyTree) {
+        final HashMap<String, HashSet<String>> connections = new HashMap<>();
+
+        for (Map.Entry<String, List<String>> entry : familyTree.entrySet()) {
+            String parent = entry.getKey();
+            List<String> children = entry.getValue();
+
+            connections.putIfAbsent(parent, new HashSet<>());
+
+            for (String child : children) {
+                connections.putIfAbsent(child, new HashSet<>());
+
+                connections.get(parent).add(child);
+                connections.get(child).add(parent);
+
+                for (String sibling : children) {
+                    if (!sibling.equals(child)) {
+                        connections.get(child).add(sibling);
+                    }
+                }
+            }
+        }
+
+        graph = connections;
+    }
+
+    int degreeOfSeparation(String personA, String personB) {
+        if (!graph.containsKey(personA) || !graph.containsKey(personB)) {
+            return -1;
+        }
+
+        Queue<String> queue = new LinkedList<>();
+        Map<String, Integer> distances = new HashMap<>() {
+            {
+                put(personA, 0);
+            }
+        };
+        queue.add(personA);
+
+        while (!queue.isEmpty()) {
+            String current = queue.poll();
+            int currentDistance = distances.get(current);
+
+            for (String relative : graph.get(current)) {
+                if (!distances.containsKey(relative)) {
+                    if (relative.equals(personB)) {
+                        return currentDistance + 1;
+                    }
+                    distances.put(relative, currentDistance + 1);
+                    queue.add(relative);
+                }
+            }
+        }
+
+        return -1;
+    }
+}

exercises/practice/relative-distance/.meta/tests.toml

@@ -0,0 +1,31 @@
+# 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.
+
+[4a1ded74-5d32-47fb-8ae5-321f51d06b5b]
+description = "Direct parent-child relation"
+
+[30d17269-83e9-4f82-a0d7-8ef9656d8dce]
+description = "Sibling relationship"
+
+[8dffa27d-a8ab-496d-80b3-2f21c77648b5]
+description = "Two degrees of separation, grandchild"
+
+[34e56ec1-d528-4a42-908e-020a4606ee60]
+description = "Unrelated individuals"
+
+[93ffe989-bad2-48c4-878f-3acb1ce2611b]
+description = "Complex graph, cousins"
+
+[2cc2e76b-013a-433c-9486-1dbe29bf06e5]
+description = "Complex graph, no shortcut, far removed nephew"
+
+[46c9fbcb-e464-455f-a718-049ea3c7400a]
+description = "Complex graph, some shortcuts, cross-down and cross-up, cousins several times removed, with unrelated family tree"

exercises/practice/relative-distance/build.gradle

@@ -0,0 +1,25 @@
+plugins {
+    id "java"
+}
+
+repositories {
+    mavenCentral()
+}
+
+dependencies {
+    testImplementation platform("org.junit:junit-bom:5.10.0")
+    testImplementation "org.junit.jupiter:junit-jupiter"
+    testImplementation "org.assertj:assertj-core:3.25.1"
+
+    testRuntimeOnly "org.junit.platform:junit-platform-launcher"
+}
+
+test {
+    useJUnitPlatform()
+
+    testLogging {
+        exceptionFormat = "full"
+        showStandardStreams = true
+        events = ["passed", "failed", "skipped"]
+    }
+}

exercises/practice/relative-distance/gradle/wrapper/gradle-wrapper.properties

@@ -0,0 +1,6 @@
+distributionBase=GRADLE_USER_HOME
+distributionPath=wrapper/dists
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.7-bin.zip
+validateDistributionUrl=true
+zipStoreBase=GRADLE_USER_HOME
+zipStorePath=wrapper/dists