Welcome to the Lounge

BillWoodruff wrote:

I am interested in modeling reciprocal relationships

lw@zi wrote:

Trust me, one sided relationships are way better.

Jon McKee wrote:

Don't forget about relationship direction

CREATE (p1:Person)-[:KNOWS]->(p2:Person)

//Matches both p1 and p2
MATCH (p:Person)-[:KNOWS]-(:Person)
RETURN p

//Matches only p1
MATCH (p:Person)-[:KNOWS]->(:Person)
RETURN p

var friendsOfFriendsofJoe = friendsOfJoe
    .SelectMany(name => friendsByPerson.TryGetValue(name, out var myFriends) ? myFriends : Enumerable.Empty<string>())
    .Except(friendsOfJoe)
    .Where(name => name != "Joe");

static class GraphExtensions
{
    public static IReadOnlyDictionary<string, IEnumerable<string>> FriendsByPerson(this IEnumerable<(string n1, string n2)> source)
    {
        return source.GroupBy(p => p.n1).ToDictionary(g => g.Key, g => g.Select(p => p.n2));
    }
    
    public static Func<string, IEnumerable<string>> FriendsOfFriends(this IReadOnlyDictionary<string, IEnumerable<string>> friendsByPerson)
    {
        return name =>
        {
            if (!friendsByPerson.TryGetValue(name, out var friends)) 
            {
                return Enumerable.Empty<string>();
            }
            
            return friends
                .SelectMany(f => friendsByPerson.TryGetValue(f, out var foaf) ? foaf : Enumerable.Empty<string>())
                .Except(friends)
                .Where(f => f != name);
        };
    }
}

...

Func<string, IEnumerable<string>> foafByPerson = people.FriendsByPerson().FriendsOfFriends();
foreach (string foaf in foafByPerson("Anna"))
{
    Console.WriteLine(foaf);
}

public static IReadOnlyDictionary<string, IEnumerable<string>> FriendsByPerson(this IEnumerable<(string n1, string n2)> source)
{
    return source
        .Concat(source.Select(p => (n1: p.n2, n2: p.n1)))
        .GroupBy(p => p.n1)
        .ToDictionary(group => group.Key, group => group.Select(p => p.n2));
}