filename stringlengths 7 140 | content stringlengths 0 76.7M |
|---|---|
code/design_pattern/src/OOP_patterns/observer_pattern/observer_pattern.rs | // Part of Cosmos by OpenGenus Foundation
use std::collections::HashMap;
#[derive(Debug, Clone, Copy)]
enum WeatherType {
Clear,
Rain,
Snow,
}
#[derive(Debug, Clone, Copy)]
enum WeatherObserverMessage {
WeatherChanged(WeatherType),
}
trait WeatherObserver {
fn notify(&mut self, msg: WeatherObserv... |
code/design_pattern/src/OOP_patterns/proxy/demo/demo.java | package demo;
import protection.proxy.User;
import protection.proxy.UserProxy;
import virtual.proxy.UltraHDVideo;
import virtual.proxy.Video;
import virtual.proxy.VideoProxy;
public class Demo {
public void protectionProxyRun() {
User rob = new UserProxy("Robert", "123");
User david = new UserProx... |
code/design_pattern/src/OOP_patterns/proxy/main.java | import demo.Demo;
public class Main {
public static void main(String[] args) throws InterruptedException {
new Demo().protectionProxyRun();
}
}
|
code/design_pattern/src/OOP_patterns/proxy/protection/proxy/registeredusers.java | package protection.proxy;
import java.util.HashMap;
import java.util.Map;
public class RegisteredUsers {
static Map<String, String> registered = new HashMap<String, String>(){
{
put("Robert", "123");
put("David", "pass");
put("Gangplank", "Illaoi");
}
};
}
|
code/design_pattern/src/OOP_patterns/proxy/protection/proxy/user.java | package protection.proxy;
public interface User {
void login();
void download();
void upload();
}
|
code/design_pattern/src/OOP_patterns/proxy/protection/proxy/userproxy.java | package protection.proxy;
import java.util.Objects;
public class UserProxy implements User {
private String username;
private String password;
Boolean isLogged;
private User user;
public UserProxy(String username, String password) {
this.username = username;
this.password = passwo... |
code/design_pattern/src/OOP_patterns/proxy/protection/proxy/validuser.java | package protection.proxy;
class ValidUser implements User {
String username;
String password;
ValidUser(String username, String password) {
this.username = username;
this.password = password;
}
@Override
public void login() {
System.out.println(">" + this.username + ":... |
code/design_pattern/src/OOP_patterns/proxy/virtual/proxy/demo.java | package virtual.proxy;
public class Demo {
}
|
code/design_pattern/src/OOP_patterns/proxy/virtual/proxy/ultrahdvideo.java | package virtual.proxy;
public class UltraHDVideo implements Video {
public String name;
public UltraHDVideo(String path) throws InterruptedException {
this.name = path;
loadVideo();
}
@Override
public void play() {
System.out.println("4k video is being played - " + name);
... |
code/design_pattern/src/OOP_patterns/proxy/virtual/proxy/video.java | package virtual.proxy;
public interface Video {
void play();
}
|
code/design_pattern/src/OOP_patterns/proxy/virtual/proxy/videoproxy.java | package virtual.proxy;
public class VideoProxy implements Video {
public String name;
public Video realVideo;
public VideoProxy(String name) {
this.name = name;
}
@Override
public void play() {
try {
this.realVideo = new UltraHDVideo(name);
} catch (Interr... |
code/design_pattern/src/OOP_patterns/singleton_pattern/singleton_pattern.cpp | #include <string>
#include <iostream>
template<typename T>
class Singleton
{
public:
static T* GetInstance();
static void destroy();
private:
Singleton(Singleton const&)
{
};
Singleton& operator=(Singleton const&)
{
};
protected:
static T* m_instance;
Singleton()
{
... |
code/design_pattern/src/OOP_patterns/singleton_pattern/singleton_pattern.java |
/**
* Singleton Design Pattern
*
* @author Sagar Rathod
* @version 1.0
*
*/
class Singleton {
private volatile transient static Singleton singletonInstance;
private Singleton() {}
public static synchronized Singleton getInstance() {
if ( singletonInstance == null ) {
singletonInstance = new S... |
code/design_pattern/src/OOP_patterns/singleton_pattern/singleton_pattern.php | <?php
/**
* Simple singleton class which could only have one instance
* Part of Cosmos by OpenGenus Foundation
*/
class Singleton
{
}
/**
* Class which creates instance of Singleton if it does not exists
*/
class SingletonInstanter
{
private static $instance;
public static function getInstance() {
... |
code/design_pattern/src/OOP_patterns/singleton_pattern/singleton_pattern.py | # Part of Cosmos by OpenGenus Foundation
class Singleton:
__instance = None
@property
def x(self):
return self.__x
@x.setter
def x(self, value):
self.__x = value
@staticmethod
def instance():
if not Singleton.__instance:
Singleton.__instance = Singlet... |
code/design_pattern/src/__init__.py | |
code/design_pattern/src/builder_pattern/builder.cs | using System;
using System.Collections.Generic;
namespace SandBox
{
/// <summary>
/// Acts as the "Director" class.
///
/// An intermediary between the customer (main) and the manufacturer.
/// Unaware of the intracacies of building each product.
/// </summary>
class Dealer
{
/// <summary>
/// Orders a ve... |
code/design_pattern/src/functional_patterns/README.md | # cosmos
Your personal library of every design pattern code that you will ever encounter
Collaborative effort by [OpenGenus](https://github.com/opengenus)
|
code/design_pattern/src/functional_patterns/functional_patterns/scala/build.sbt | |
code/design_pattern/src/functional_patterns/functional_patterns/scala/project/build.properties | sbt.version = 1.1.0
|
code/design_pattern/src/functional_patterns/functional_patterns/scala/src/main/scala/arrows/arrow/arrow.scala | package arrows.arrow
trait Arrow {
}
|
code/design_pattern/src/functional_patterns/functional_patterns/scala/src/main/scala/functors/applicative/functor/applicativefunctor.scala | package functors.applicative.functor
import scala.language.higherKinds
/**
* Applicative is an intermediate between functor and monad.
*
* Its importance are dominated by:
* - ability to apply functions of more parameters
* For example:
* val f = (x: Int)(y: Int) => x + y
* If we apply... |
code/design_pattern/src/functional_patterns/functional_patterns/scala/src/main/scala/functors/bifunctor/bifunctor.scala | package functors.bifunctor
import scala.language.higherKinds
/**
*
* Similar to a functor, the BiFunctor must satisfy the functor laws:
* 1. bimap f id id = id
* first f id = id
* second f id = id
*
* Applying a function over the identity, should return the identity.
*
* 2. bima... |
code/design_pattern/src/functional_patterns/functional_patterns/scala/src/main/scala/functors/contravariant/contravariant.scala | package functors.contravariant
trait Contravariant {
}
|
code/design_pattern/src/functional_patterns/functional_patterns/scala/src/main/scala/functors/functor/functor.scala | package functors.functor
import scala.language.higherKinds
/**
* ADT which aspires to be a functor must preserve 2 laws:
* 1. fmap over the identity functor of the ADT should coincide with the original ADT
* fmap(identity, adt) === adt
*
* 2. The composition of 2 functions and mapping the resulting ... |
code/design_pattern/src/functional_patterns/functional_patterns/scala/src/main/scala/functors/multifunctor/multifunctor.scala | package functors.multifunctor
trait Multifunctor {
}
|
code/design_pattern/src/functional_patterns/functional_patterns/scala/src/main/scala/functors/profunctor/profunctor.scala | package functors.profunctor
trait Profunctor {
}
|
code/design_pattern/src/functional_patterns/functional_patterns/scala/src/main/scala/main.scala | object Main extends App{
}
|
code/design_pattern/src/functional_patterns/functional_patterns/scala/src/main/scala/monads/comonad/comonad.scala | package monads.comonad
trait Comonad {
}
|
code/design_pattern/src/functional_patterns/functional_patterns/scala/src/main/scala/monads/costate/monad/costatemonad.scala | package monads.costate.monad
trait CostateMonad {
}
|
code/design_pattern/src/functional_patterns/functional_patterns/scala/src/main/scala/monads/free/monad/freemonad.scala | package monads.free.monad
trait FreeMonad {
}
|
code/design_pattern/src/functional_patterns/functional_patterns/scala/src/main/scala/monads/gonad/gonad.scala | package monads.gonad
trait Gonad {
}
|
code/design_pattern/src/functional_patterns/functional_patterns/scala/src/main/scala/monads/io/monad/iomonad.scala | package monads.io.monad
trait IOMonad {
}
|
code/design_pattern/src/functional_patterns/functional_patterns/scala/src/main/scala/monads/monad/monad.scala | package monads.monad
import scala.language.higherKinds
trait Monad[T, M[_]] {
def flatMap[S](fA: T => M[S])(f: M[T]): M[S]
}
object MonadImplicits {
implicit def listMonad[T]: Monad[T, List] = new Monad[T, List] {
override def flatMap[S](fA: T => List[S])(f: List[T]): List[S] = f.flatMap(fA)
}
implicit ... |
code/design_pattern/src/functional_patterns/functional_patterns/scala/src/main/scala/monads/state/monad/statemonad.scala | package monads.state.monad
/**
* The equivalent of Memento design pattern in OOP on steroids,
* state monads deal with maintaining previous states WHILE generating new ones.
*/
trait StateMonad[S, A] {
def apply(f: S => (S, A)): StateMonad[S, A]
}
|
code/design_pattern/src/iterator_pattern/class.java | package iterator;
public class Class {
private Student[] students = new Student[100];
private int i = 0;
private String class_name;
public Class(String n) {
this.class_name = n;
}
public String getName() {
return this.class_name;
}
public void add(String name,int age) {
Student s = new Student(n... |
code/design_pattern/src/iterator_pattern/classiterator.java | package iterator;
public class ClassIterator implements Iterator<Student> {
private Student[] student;
private int i = 0;
public ClassIterator(Student[] s){
this.student = s;
}
@Override
public boolean hasNext() {
if( i < student.length && student[i] != null)
return true;
else
return false;
... |
code/design_pattern/src/iterator_pattern/iterator.java | package iterator;
public interface Iterator<T> {
public boolean hasNext();
public Student next();
}
|
code/design_pattern/src/iterator_pattern/main.java | package iterator;
public class Main {
public static void main(String[] args) {
Class class1 = new Class("class1");
class1.add("student1",12);
class1.add("student2",15);
class1.add("student3",16);
ClassIterator it = class1.iterator();
while (it.hasNext()) {
Student student = it.next();
stud... |
code/design_pattern/src/iterator_pattern/student.java | package iterator;
public class Student {
private String name;
private int age;
public Student(String n, int a) {
this.name = n;
this.age = a;
}
public String getName() {
return this.name;
}
public void print() {
System.out.println("Student: " + this.name + " Age: " + this.age);
}
}
|
code/design_pattern/src/policy_based_design/policy_design.cpp | /*
* policy_design.cpp
*
* Created: 3/15/2018 1:14:41 AM
* Author: n-is
* email: [email protected]
*/
#include <iostream>
class Classical
{
public:
Classical(int a)
{
}
void solve()
{
std::cout << "The differential equation was solved by the classical" <<
... |
code/design_pattern/src/policy_based_design/readme.md | # Policy Based Design
Policy-based design, also known as policy-based class design or policy-based
programming, is a computer programming paradigm based on an idiom for C++ known
as policies.
## Explanation
Wikipedia(<https://en.wikipedia.org/wiki/Policy-based_design>) says:
>Policy-based design has been described ... |
code/design_pattern/src/singleton_pattern/singleton_pattern.cs | // Singleton design pattern using properties
class Singleton
{
private static readonly Singleton _instance = new Singleton();
public static Singleton Instance { get { return _instance; } }
private Singleton()
{
// Initialize object
}
}
class Program
{
static void Main(string[] args)
{
var instance = Single... |
code/design_pattern/src/singleton_pattern/singleton_pattern.js | /* Part of Cosmos by OpenGenus Foundation */
class Singleton {
constructor() {
console.log('New Singleton');
}
static getInstance() {
if (!Singleton.instance) {
Singleton.instance = new Singleton();
}
return Singleton.instance;
}
foo() {
consol... |
code/design_pattern/test/README.md | # cosmos
Your personal library of every algorithm and data structure code that you will ever encounter
|
code/design_pattern/test/__init__.py | |
code/design_pattern/test/test_observer.py | from src.OOP_patterns.observer_pattern import Notifier, Observer
import unittest
from enum import Enum
class Event(Enum):
Earthquake = 0
Joke = 1
class SomeWhere:
def __init__(self):
self._member = {}
def add_member(self, member):
self._member[member] = "is here"
def remove_mem... |
code/divide_conquer/src/README.md | # Divide and conquer
Divide and conquer is an algorithm design paradigm based on multi-branched recursion. A divide and conquer algorithm works by recursively breaking down a problem into two or more sub-problems of the same or related type, until these become simple enough to be solved directly. The solutions to the s... |
code/divide_conquer/src/closest_pair_of_points/closest_pair.cpp | // divide conquer | structure to represent a point | C
// Part of Cosmos by OpenGenus Foundation
#include <vector>
#include <cmath>
#include <iostream>
#include <algorithm>
#include <cfloat>
#define ll long long
using namespace std;
struct point
{
ll x;
ll y;
};
// comparator function to sort points by X c... |
code/divide_conquer/src/closest_pair_of_points/closest_pair.py | # divide conquer | structure to represent a point | Python
# Part of Cosmos by OpenGenus Foundation
import math
def dist(p1, p2):
return math.sqrt((p1[0] - p2[0]) ** 2 + (p1[1] - p2[1]) ** 2)
def closest_pair(ax, ay):
# It's quicker to assign variable
ln_ax = len(ax)
if ln_ax <= 3:
# A c... |
code/divide_conquer/src/factorial/factorial.cpp | #include<iostream>
int factorial(int num) {
if (num == 0 || num == 1) {
return num;
}
return (num * factorial(num - 1));
}
int main() {
int num;
while (true) {
std::cin >> num;
std::cout << "> " << factorial(num) << '\n';
}
return 0;
}
|
code/divide_conquer/src/factorial/factorial.py | """
divide conquer | factorial | Python
part of Cosmos by OpenGenus Foundation
"""
def factorial(num):
"""
Returns the factorial of a given integer num.
Divide and conquer is used here by organizing the function into a base and recursive case.
Parameter: num is the number for which the factorial w... |
code/divide_conquer/src/inversion_count/README.md | # Cosmos
Collaborative effort by [OpenGenus](https://github.com/OpenGenus/cosmos) |
code/divide_conquer/src/inversion_count/count_inversions.c | // divide conquer | inversion count | C
// Part of Cosmos by OpenGenus Foundation
#include <stdlib.h>
#include <stdio.h>
int _mergeSort(int arr[], int temp[], int left, int right);
int merge(int arr[], int temp[], int left, int mid, int right);
int mergeSort(int arr[], int array_size)
{
int *temp = (int *)mal... |
code/divide_conquer/src/inversion_count/inversion_count.cpp | // divide conquer | inversion count | C++
// Part of Cosmos by OpenGenus Foundation
#include <iostream>
using namespace std;
int mergesort(int arr[], int l, int r);
int merge(int arr[], int l, int m, int r);
int main()
{
int n, a[100], i;
cout << "Enter nuber of elements : ";
cin >> n;
cout << "E... |
code/divide_conquer/src/inversion_count/inversion_count.java | // divide conquer | inversion count | Java
// Part of Cosmos by OpenGenus Foundation
import java.util.Scanner;
public class InversionCount {
public static int merge(int a[], int p, int q,int r){
int i = p ,j = q ,k = 0, count = 0;
int temp[] = new int[r-p+1];
while(i<q && j<=r){
... |
code/divide_conquer/src/inversion_count/inversion_count.js | // divide conquer | inversion count | Javascript
// Part of Cosmos by OpenGenus Foundation
function mergeSort(arr, size) {
if (array.length === 0 || array.length === 1) return 0;
var temp = [];
return mergeSortHelper(arr, temp, 0, size - 1);
}
function mergeSortHelper(arr, temp, left, right) {
var inv_count... |
code/divide_conquer/src/inversion_count/inversion_count.py | """
divide conquer | inversion count | Python
part of Cosmos by OpenGenus Foundation
"""
def merge(left, right):
merged_arr = []
i = 0
j = 0
inv_cnt = 0
while i < len(left) and j < len(right):
if left[i] <= right[j]:
merged_arr.append(left[i])
i += 1
else... |
code/divide_conquer/src/karatsuba_multiplication/karatsuba_multiplication.py | #!/usr/bin/env python2
# -*- coding: utf-8 -*-
"""
Created on Tue May 29 11:21:34 2018
@author: Sahit
"""
print("enter the first number")
n1 = input()
print("enter the second number")
n2 = input()
def Correcting(string):
p = len(string)
i = 1
while i < p:
i = i * 2
return i
l = max(Correc... |
code/divide_conquer/src/karatsuba_multiplication/karatsubamultiply.cpp | // Author: Tote93
#include <iostream>
#include <string>
#include <sstream>
#include <cstdlib>
/* Prototypes */
int getBiggerSize(const std::string &number1, const std::string &number2);
void checkNumbers(int size, std::string &number1, std::string &number2);
std::string KaratsubaMultiply(std::string &number1, std::st... |
code/divide_conquer/src/karatsuba_multiplication/multiply.java | // divide conquer | karatsuba multiplication | Java
// Part of Cosmos by OpenGenus Foundation
import java.lang.*;
import java.util.Scanner;
public class Multiply
{
public static String trim(String str,int n)
{
if(str.length()>n)
while(str.charAt(0)=='0' && str.length()>n)
str=str.substring(1);
else
w... |
code/divide_conquer/src/maximum_contiguous_subsequence_sum/maximum_contiguous_subsequence_sum.c | #include <stdio.h>
int
max(int const a, int const b, const int c)
{
if (a > b)
return (a > c ? a : c);
return (b > c ? b : c);
}
int
maximumContiguousSubsequenceSum(const int a[], int beg, int end)
{
if (beg == end)
return (a[beg] > 0 ? a[beg] : 0);
int mid = (beg + end) / 2;
int leftSubProblem = maximum... |
code/divide_conquer/src/merge_sort_using_divide_and_conquer/README.md | # Cosmos
Collaborative effort by [OpenGenus](https://github.com/OpenGenus/cosmos) |
code/divide_conquer/src/merge_sort_using_divide_and_conquer/inversions.c | #include <stdio.h>
const int maxn = 1e6;
typedef long long unsigned llu;
llu merge(int v[], int lo, int mid, int hi) {
llu inv = 0;
int i, j, k;
int n1 = mid - lo + 1, n2 = hi - mid;
int left[n1], right[n2];
for(i = 0; i < n1; i++) left[i] = v[i+lo];
for(j = 0; j < n2; j++) right[j] = v[j+mid+1];
i = 0, j = ... |
code/divide_conquer/src/merge_sort_using_divide_and_conquer/merge_sort_using_divide_and_conquer.cpp | // divide conquer | merge sort using divide and conquer | C++
// Part of Cosmos by OpenGenus Foundation
#include <cstdlib>
#include <cstdio>
int _mergeSort(int arr[], int temp[], int left, int right);
int merge(int arr[], int temp[], int left, int mid, int right);
/* This function sorts the input array and return... |
code/divide_conquer/src/merge_sort_using_divide_and_conquer/merge_sort_using_divide_and_conquer.java | // divide conquer | merge sort using divide and conquer | Java
// Part of Cosmos by OpenGenus Foundation
package mergesort;
/**
*
* @author Yatharth Shah
*/
public class MergeSort {
int array[];
int size;
public MergeSort(int n) {
size=n;
//create array with size n
array=new ... |
code/divide_conquer/src/power_of_a_number/power_of_a_number.cpp | /*
PROBLEM STATEMENT:
Given 2 numbers x and y, you need to find x raise to y.
*/
#include<bits/stdc++.h>
using namespace std;
#define ll long long int
#define FIO ios::sync_with_stdio(0);
ll power(ll a,ll b)
{
ll res=1;
while(b!=0)
{
if(b%2!=0)
{
res=(res*a)%1000000007;
b--;
}
else
{
a=(a*a)%1000... |
code/divide_conquer/src/power_of_a_number/power_of_a_number.py | # Python3 program to check if
# a given number can be expressed
# as power
import math
# Returns true if n can be written as x^y
def isPower(n) :
if (n==1) :
return True
# Try all numbers from 2 to sqrt(n) as base
for x in range(2,(int)(math.sqrt(n))+1) :
y = 2
p = (int)(math.pow(x, y))
# Keep increasing ... |
code/divide_conquer/src/quick_hull/quick_hull.cpp | #include<bits/stdc++.h>
using namespace std;
#define iPair pair<int, int>
set<iPair> hull;// stores the final points to create the convex hull
int findSide(iPair p1, iPair p2, iPair p)// returns the side of the hull joined points p1 and p2
{
int val = (p.second - p1.second) * (p2.first - p1.first) -
... |
code/divide_conquer/src/quick_sort/Quick_Sort.cs | // Part of Cosmos (OpenGenus)
using System;
public class Quick_Sort
{
// Conquer
public static int Parition(int[] array, int left, int right)
{
int pivot = array[left];
int index = right;
int temp;
for(int j = right; j > left; j--)
{
if(array[j] > pivot)
... |
code/divide_conquer/src/quick_sort/README.md | # Cosmos
Collaborative effort by [OpenGenus](https://github.com/OpenGenus/cosmos) |
code/divide_conquer/src/quick_sort/quick_sort.c | // divide conquer | quick sort | C
// Part of Cosmos by OpenGenus Foundation
#include<stdio.h>
// A utility function to swap two elements
void
swap(int* a, int* b)
{
int t = *a;
*a = *b;
*b = t;
}
/* This function takes last element as pivot, places
the pivot element at its correct position in sort... |
code/divide_conquer/src/quick_sort/quick_sort.cpp | // divide conquer | quick sort | C++
// Part of Cosmos by OpenGenus Foundation
#include <cstdio>
using namespace std;
void swap(int* a, int* b)
{
int t = *a;
*a = *b;
*b = t;
}
/* This function takes last element as pivot, places
* the pivot element at its correct position in sorted
* array, and pla... |
code/divide_conquer/src/quick_sort/quick_sort.hs | quicksort :: (Ord a) => [a] -> [a]
quicksort [] = []
quicksort (x:xs) = smaller ++ [x] ++ larger
where smaller = quicksort $ filter (<=x) xs
larger = quicksort $ filter (>x) xs
|
code/divide_conquer/src/quick_sort/quick_sort.py | def partition(arr, low, high):
i = low - 1
pivot = arr[high]
for j in range(low, high):
if arr[j] <= pivot:
i = i + 1
arr[i], arr[j] = arr[j], arr[i]
arr[i + 1], arr[high] = arr[high], arr[i + 1]
return i + 1
def quickSort(arr, low, high):
if low < high:
... |
code/divide_conquer/src/quick_sort/quick_sort.rs | // divide conquer | quick sort | Rust
// Part of Cosmos by OpenGenus Foundation
fn quick_sort(mut arr :Vec<i32>,low :usize, high :usize) -> Vec<i32> {
if low < high {
let mid = partition(&mut arr, low, high);
let arr = quick_sort(arr.clone(),low,mid);
let arr = quick_sort(arr,mid+1,high... |
code/divide_conquer/src/quick_sort/quick_sort.swift | // divide conquer | quick sort | Swift
// Part of Cosmos by OpenGenus Foundation
import Foundation;
func partition(_ arr: inout [UInt32], _ begin: Int, _ end: Int) -> Int {
var i = begin;
var j = end;
let pivot = arr[(i + j) / 2];
while i <= j {
while arr[i] < pivot {
i += 1;
... |
code/divide_conquer/src/quick_sort/quick_sort2.cpp | #include <iostream>
using namespace std;
void swapit(int *x, int *y)
{
int temp;
temp = *x;
*x = *y;
*y = temp;
}
int Mpartition(int arr[], int low, int high)
{
int i = low - 1;
int j = low;
for (; j < high; j++)
if (arr[high] < arr[j])
{
i++;
swapit... |
code/divide_conquer/src/quick_sort/quicksort.java | // divide conquer | quick sort | Java
// Part of Cosmos by OpenGenus Foundation
public class QuickSort {
private int []v;
private int n;
public String toString() {
String result = "";
for(int i = 0; i < n; i++) {
result += v[i] + " ";
}
return result;
}
public void quickSort(QuickSort v, int left... |
code/divide_conquer/src/search_in_a_rotated_array/search_in_a_rotated_array.cpp | /*
Problem statement:
Given a sorted and rotated array A of N distinct elements which is rotated
at some point, and given an element K. The task is to find the index of
the given element K in the array A.
*/
#include <iostream>
#include <vector>
#define ll long long int
ll findPivot(std::vector<ll> &v, ll low, ll hig... |
code/divide_conquer/src/strassen_matrix_multiplication/main.cpp |
//The following program contains the strassen algorithm along with the Currently Fastest Matrix Multiplication Algorithm for sparse matrices
// Developed by Raphael Yuster and Uri Zwick
// I have also included a time calculator in case anyone wanted to check time taken by each algorithms
// Although mathematcially t... |
code/divide_conquer/src/strassen_matrix_multiplication/strassen.py | #!/usr/bin/env python2
# -*- coding: utf-8 -*-
"""
Created on Tue May 29 13:36:32 2018
@author: Sahit
"""
import numpy as np
def Correction(matrix_1, matrix_2):
r = max(matrix_1.shape[0], matrix_1.shape[1], matrix_2.shape[0], matrix_2.shape[1])
i = 1
while i < r:
i = i * 2
return i
"""
... |
code/divide_conquer/src/tournament_method_to_find_min_max/tournament_method_to_find_min_max.c | #include<stdio.h>
struct pair
{
int min;
int max;
};
struct pair
getMinMax(int arr[], int low, int high)
{
struct pair minmax, mml, mmr;
int mid;
if (low == high) {
minmax.max = arr[low];
minmax.min = arr[low];
return (minmax);
}
if (high == low + 1) {
if (arr[l... |
code/divide_conquer/src/warnock_algorithm/warnock_algorithm.pde | /*
divide conquer | warnock's Algorithm | Processing
Part of Cosmos by OpenGenus Foundation
National University from Colombia
Author:Andres Vargas, Jaime
Gitub: https://github.com/jaavargasar
webpage: https://jaavargasar.github.io/
Language: Processing
Description:
This is a implementation of warnock's Algorithm i... |
code/divide_conquer/src/x_power_y/x_power_y.c | #include <stdio.h>
float
power(float x, int y)
{
if (y == 0)
return (1);
float temp = power(x, y / 2);
if (y % 2 == 0)
return (temp * temp);
else {
if (y > 0)
return (x * temp * temp);
else
return (temp * temp / x);
}
}
int
main()
{
... |
code/divide_conquer/test/README.md | # cosmos
Your personal library of every algorithm and data structure code that you will ever encounter
|
code/dynamic_programming/src/Climbing Stairs/solution.cpp | // recursion
// TC - O(2^n) , SC - O(1)
class Solution {
public:
int func(int n){
if(n <= 1){
return n;
}
return func(n-1) + func(n-2);
}
int climbStairs(int n) {
return func(n+1);
}
};
// memoisation
// TC - O(n), SC - O(n) + O(n)
class Solution {
pu... |
code/dynamic_programming/src/Count_Subsequence_Having_Product_Less_Than_K/Solution.cpp | #include<iostream>
#include<cstring>
using namespace std;
int dp[10005][10005];
int helper(int a[], int n, int k , int product)
{
// base case
if(n==0)
{
return 0;
}
if(product > k)
{
return 0;
}
if(dp[n][product] !=-1)
{
return dp[n][product];
}
int... |
code/dynamic_programming/src/README.md | # Dynamic Programming
Dynamic programming approach is similar to divide and conquer in breaking down the problem into smaller and yet smaller possible sub-problems. But unlike, divide and conquer, these sub-problems are not solved independently. Rather, results of these smaller sub-problems are remembered and used fo... |
code/dynamic_programming/src/array_median/array_median.c | #include <stdio.h>
void
swap(int* a, int* b)
{
int t = *a;
*a = *b;
*b = t;
}
int
partition(int arr[], int low, int high)
{
int pivot = arr[high];
int i = (low - 1);
for (int j = low; j <= high- 1; j++) {
if (arr[j] <= pivot) {
i++;
swap(&arr[i], &arr[... |
code/dynamic_programming/src/array_median/array_median.cpp | #include <iostream>
#include <algorithm>
#include <vector>
using namespace std;
float median(vector<int> arr)
{
int n = arr.size();
if (n % 2 != 0)
return (float)arr[n / 2];
return (float)(arr[(n - 1) / 2] + arr[n / 2]) / 2;
}
int main()
{
int n;
cout << "Enter size of the Array";
cin... |
code/dynamic_programming/src/array_median/array_median.exs | defmodule ArrayMedian do
def get_median(array) when is_list(array) do
list_nums = Enum.sort(array)
half = length(list_nums) |> div(2)
if length(list_nums) |> rem(2) != 0 do
# odd length -> middle number
mid = half + 1
Enum.reduce_while(list_nums, 1, fn
el, ^mid ->
{:h... |
code/dynamic_programming/src/array_median/array_median.java | import java.util.*;
// Part of Cosmos by OpenGenus Foundation
public class Median{
public static void main(String[] args) {
int length;
int median;
System.out.print("Enter Length of array ");
Scanner scanner = new Scanner(System.in);
length = scanner.nextInt();
int ar... |
code/dynamic_programming/src/array_median/array_median.php | <?php
/**
* Part of Cosmos by OpenGenus Foundation
*/
/**
* Finds median in array of numbers
*
* @param array $arr array of numbers
* @return int median
*/
function median(array $arr)
{
sort($arr);
$cnt = count($arr);
if ($cnt % 2) {
return $arr[floor(($cnt - 1) / 2)];
}
return ($ar... |
code/dynamic_programming/src/array_median/array_median.py | import sys
# Part of Cosmos by OpenGenus Foundation
def median(nums):
"""
Calculates the median of a list of numbers.
import median from statistics in python 3.4 and above.
"""
sorted_nums = sorted(nums)
len_nums = len(nums)
odd = len_nums % 2
# If the length is odd, the medi... |
code/dynamic_programming/src/array_median/array_median.rb | # Part of Cosmos by OpenGenus Foundation
def median(*nums)
nums.sort!
if nums.size.odd?
nums[(nums.size + 1) / 2 - 1]
else
(nums[nums.size / 2 - 1] + nums[nums.size / 2]).fdiv(2)
end
end
|
code/dynamic_programming/src/array_median/array_median.rs | // Part of Cosmos by OpenGenus Foundation
fn median(arr: &[i32]) -> f64 {
let len = arr.len();
if len % 2 == 0 {
(arr[len / 2] + arr[len / 2 - 1]) as f64 / 2.0
} else {
arr[(len - 1) / 2] as f64
}
}
fn main() {
let arr = vec![1, 3, 3, 4, 5, 6, 8, 9];
let median = median(&arr); ... |
code/dynamic_programming/src/assembly_line_scheduling/assembly_line_scheduling.cpp | // Part of OpenGenus Cosmos
// A C++ program to find minimum possible
// time by the car chassis to complete
#include <bits/stdc++.h>
using namespace std;
#define NUM_LINE 2
#define NUM_STATION 4
// Utility function to find a minimum of two numbers
int min(int a, int b)
{
return a < b ? a : b;
}
int carAs... |
code/dynamic_programming/src/best_time_to_sell_stock_II/best_time_to_sell_stock_II.cpp | // You are given an integer array prices where prices[i] is the price of a given stock on the ith day.
// On each day, you may decide to buy and/or sell the stock. You can only hold at most one share of the stock at any time. However, you can buy it then immediately sell it on the same day.
// Find and return the max... |
code/dynamic_programming/src/binomial_coefficient/README.md | # cosmos
Your personal library of every algorithm and data structure code that you will ever encounter
Collaborative effort by [OpenGenus](https://github.com/opengenus) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.