fferri

class DirectedGraph:
    def __init__(self, edges={}):
        # copy/cast constructor
        if isinstance(edges, DirectedGraph): edges = edges.label
        self.label = {}
        self.vertex_in = {}
        self.vertex_out = {}
        for edge, label in edges.items():
            self[edge] = label

fferri

from graph import *

def kosaraju(g):
    def dfs(g, start, s, visited=set()):
        for n in g.vertex_out[start]:
            if n in visited: continue
            visited.add(n)
            dfs(g, n, s, visited)
        s.append(start)
    from random import sample

fferri

import Foundation

func emptyGenerator<T>() -> AnyGenerator<T> {
    return anyGenerator{
        return nil
    }
}

func generateOnce<T>(g: () -> T) -> AnyGenerator<T> {
    var first = true

fferri

We couldn’t find that file to show.

fferri

#include <QtCore>

class SignalSpy {
    static QThreadStorage<bool> entered;
    static void signalBegin(QObject *caller, int signalIndex, void **);
    static void slotBegin(QObject *caller, int index, void **);
public:
   static void start();
};

fferri

def dist(x, y):
    return sum((xi-yi)**2 for xi,yi in zip(x,y))

class KDTree:
    class Node:
        def __init__(self, x, payload=None, axis=0):
            self.x, self.axis, self.payload = x, axis, payload
            self.l, self.r = None, None

        def insert(self, x, payload=None):

fferri

from spotipy.oauth2 import SpotifyClientCredentials
import spotipy
import json
import urllib
import urllib.request
import urllib.parse
from bs4 import BeautifulSoup
import re
from unidecode import unidecode
import youtube_dl

fferri

# solution to puzzle https://www.youtube.com/watch?v=LyyHt7NfBxI
# "can you make 24 from 3 3 8 8 using only + - * / ( ) ?"

class Add:
    def __init__(self, a, b):
        self.a, self.b = a, b
    def eval(self):
        return self.a.eval() + self.b.eval()
    def __repr__(self):
        return '({!r} + {!r})'.format(self.a, self.b)

fferri

import Foundation

public protocol KDPoint {
    func distance(other: Self) -> Double
    func dimension() -> Int
    func lessThan(other: Self, dim: Int) -> Bool
}

public enum BinaryTreeVisitOrder {
    case InOrder

fferri

 correct_position(A, B, C, S) :- S = [A, _, _], \+ member(B, S), \+ member(C, S).
 correct_position(A, B, C, S) :- S = [_, B, _], \+ member(A, S), \+ member(C, S).
 correct_position(A, B, C, S) :- S = [_, _, C], \+ member(A, S), \+ member(B, S).

 wrong_position(A, B, C, S) :- (S = [_, A, _] ; S = [_, _, A]), \+ member(B, S), \+ member(C, S).
 wrong_position(A, B, C, S) :- (S = [B, _, _] ; S = [_, _, B]), \+ member(A, S), \+ member(C, S).
 wrong_position(A, B, C, S) :- (S = [C, _, _] ; S = [_, C, _]), \+ member(A, S), \+ member(B, S).

 two_wrong_position(A, B, C, S)  :- S \= [A, _, _], S \= [_, B, _], member(A, S), member(B, S), \+ member(C, S).
 two_wrong_position(A, B, C, S)  :- S \= [A, _, _], S \= [_, _, C], member(A, S), member(C, S), \+ member(B, S).