davidinga

func get_all_shortest_transformation_sequences(start_word: String, target_word: String, words: [String]) -> [[String]] {
    var result: [[String]] = []
    var found = false
    var level = 0
    let words = Set(words)
    var slate: [String] = []
    var parent: [String: Set<String>] = [:]
    var visited: Set<String> = []
    var levels: [String: Int] = [:]
    

davidinga

class Solution {
    func accountsMerge(_ accounts: [[String]]) -> [[String]] {
        var accounts: [Account] = accounts.map {
            var account = Account(name: $0.first!)
            for i in 1 ..< $0.count {
                account.emails.insert($0[i])
            }
            return account
        }
        

davidinga

class Program {
    class BST {
        var value: Int
        var left: BST?
        var right: BST?
        
        init(value: Int) {
            self.value = value
            left = nil
            right = nil

davidinga

/*
Move zeros to end of array in place.

Brute force
Loop through elements n times
  When 0 found
  Bubble up 0 to end, perform swaps until swap performed with last element
O(n^2) time | O(1) space

Loop through elements n times

davidinga

//
//  GameScene.swift
//  project11
//
//  Created by David Inga on 10/23/20.
//

import SpriteKit

class GameScene: SKScene {

davidinga

func depthFirstSearch(from start: Vertex<String>,
                      to end: Vertex<String>,
                      in graph: GraphOP<String> ) -> Stack<Vertex<String>> {
    
    var stack = Stack<Vertex<String>>()
    var visited = Set<Vertex<String>>()
    
    stack.push(start)
    visited.insert(start)
    

davidinga

struct HashTable<Key: Hashable, Value> {
    private typealias Element = (key: Key, value: Value)
    private typealias List = LinkedList<Element>
    
    private var table: [List]
    
    init(size: Int) {
        table = Array<List>()
        
        for _ in 0..<size {

davidinga

public struct GraphAL<Element: Hashable> {
    var adjList = [Element: GraphNode<Element>]()
    
    public mutating func addVertex(_ name: Element) {
        adjList[name] = GraphNode(name)
    }

    @discardableResult public mutating func addEdge(from source: Element, to destination: Element) -> Bool {
        guard adjList[source] != nil, adjList[destination] != nil
            else { return false }

davidinga

public struct GraphAM {
    private var adjMatrix = [[Int?]]()
    private var numberOfVertices: Int {
        return adjMatrix.count
    }

    init(numberOfVertices: Int) {
        adjMatrix = Array(repeating: Array(repeating: nil, count: numberOfVertices), count: numberOfVertices)
    }
    

davidinga

public enum EdgeType {
    case directed, undirected
}

public struct Edge<Element: Hashable> {
    var source: Vertex<Element>
    var destination: Vertex<Element>
    var weight: Double?
}