saldisobi

package strings

import java.util.*

class StringKMP {

    fun matchPattern(pattern: String, text: String): Int {


        var i = 0 //text pointer

saldisobi

package backToBasics;

import java.util.HashMap;
import java.util.Map;

public class MyTrie {

    private TrieNode mRootTrieNode;

    MyTrie() {

saldisobi

package backToBasics;

import java.util.LinkedList;
import java.util.Queue;

public class MyAvlTree {

    private AvlNode mRootNode;

saldisobi

class BlankViewModel : ViewModel() {

    fun testCoroutines() {
        viewModelScope.launch(Dispatchers.IO) {


        }

        runBlocking {
            launch {

saldisobi

package countdown.graphtheory;

import java.util.*;

public class Dijkstra {

    static class Edge {
        int from;
        int to;
        int weight;

saldisobi

interface CommandReceiver {
    fun onAddClicked()
    fun onTextUpdate(newText: String)
    fun onDeleteClicked()
    fun onListClicked()
    fun onSaveClicked(text: String)
    fun processCommand(command: Command) {
        command.execute(this)
    }
}

saldisobi

class MyModelViewModel @Inject constructor(
    private val myModelRepository: MyModelRepository
) : ViewModel(), CommandReceiver {


    override fun onAddClicked() {
        viewModelScope.launch {
            Log.v(TAG, "add command")
        }
    }

saldisobi

               Icon(
                    modifier = Modifier.clickable { commandProcessor(AddCommand()) },
                    imageVector = Icons.Filled.Add,
                    contentDescription = "add"
                )

                Icon(
                    modifier = Modifier.clickable { commandProcessor(TextUpdateCommand(nameMyModel)) },
                    imageVector = Icons.Filled.Edit,
                    contentDescription = "edit"

saldisobi

class Solution {
    fun networkDelayTime(times: Array<IntArray>, n: Int, k: Int): Int {

        val graph = HashMap<Int, LinkedList<IntArray>>()

        // step 1 iterate over given times list & create an adjancy list graph representation
        times.forEach{node->
            val src: Int = node[0]
            val target : Int = node[1]
            val weight : Int = node[2]

saldisobi

fun findTheCity(n: Int, edges: Array<IntArray>, distanceThreshold: Int): Int {

    val graphArr = Array(n){
        IntArray(n)
    }


    for (i in 0 until n) {
        Arrays.fill(graphArr[i], Int.MAX_VALUE)
        graphArr[i][i] = 0