Update from repo

.gitignore

@@ -2,3 +2,4 @@
 .idea
 node_modules
 *.o
+vendor

Readme.md → README.md

@@ -1,29 +1,33 @@
 # Code Problems
 
-This is my repo full of code problems that I have completed prior to or during an interview, as well as general problem snippets. I hope that all these problems (and solutions) are useful to others for practice and review. Feel free to contribute any solutions and optimisations, and add your own problems that you find as well, as I would love to see them.
+> Looking for a new job? Take Triplebyte's [quiz](https://triplebyte.com/a/QW7kzKo/d) and have top tech companies pitch you!
+
+This is an incomplete repo full of code problems used prior to or during an interview. I hope these problems will be useful for you to practice and review. If you have practiced on or designed an interesting problem, we'd love to see it! Open a PR or issue with your suggestions or optimizations.
 
 ## Problems
 
-### Sorting Algorithms
+View [all problems](./problems), or start here:
+
+**Sorting Algorithms**
 
 * [Quick Sort](https://github.com/blakeembrey/code-problems/tree/master/problems/quick-sort)
 * [Bubble Sort](https://github.com/blakeembrey/code-problems/tree/master/problems/bubble-sort)
 * [Merge Sort](https://github.com/blakeembrey/code-problems/tree/master/problems/merge-sort)
 * [Selection Sort](https://github.com/blakeembrey/code-problems/tree/master/problems/selection-sort)
 * [Insertion Sort](https://github.com/blakeembrey/code-problems/tree/master/problems/insertion-sort)
 
-### Data Structures
+**Data Structures**
 
 * [Stack](https://github.com/blakeembrey/code-problems/tree/master/problems/stack)
 * [Queue](https://github.com/blakeembrey/code-problems/tree/master/problems/queue)
 * [Linked List](https://github.com/blakeembrey/code-problems/tree/master/problems/linked-list)
 * [Binary Search Tree Check](https://github.com/blakeembrey/code-problems/tree/master/problems/binary-search-tree-check) *Not an implementation, checks for a valid implementation*
 
-### DOM Problems
+**DOM Problems**
 
 * [Get Elements By Class Name](https://github.com/blakeembrey/code-problems/tree/master/problems/get-elements-by-class-name)
 
-### Shortest Code Problems
+**Shortest Code Problems**
 
 * [Shortest Fizz Buzz](https://github.com/blakeembrey/code-problems/tree/master/problems/shortest-fizz-buzz)
 
@@ -33,3 +37,7 @@ This is my repo full of code problems that I have completed prior to or during a
 npm install # Installs `mocha` and any other dependencies needed to run
 npm test    # Runs the testing scripts
 ```
+
+## Contributing
+
+If you have a problem or solution that's not currently not included, please open an issue or pull request! If you're including new content, please make sure you have permission to publish the content you are adding. Under no circumstance should you copy problems online without a visible license or attribution, or from coding interview websites such as [Codility](https://codility.com/).

composer.json

@@ -0,0 +1,5 @@
+{
+    "require": {
+        "phpunit/phpunit": "5.5.*"
+    }
+}

package.json

@@ -1,17 +1,13 @@
 {
   "name": "code-problems",
-  "version": null,
   "private": true,
-  "description": "Repository full of code problems and common solutions.",
-  "main": null,
-  "dependencies": {},
+  "description": "Repository full of code problems and common solutions",
   "devDependencies": {
-    "mocha": "~1.16.2",
-    "jshint": "~2.4.0",
-    "chai": "~1.8.1"
+    "chai": "^3.5.0",
+    "mocha": "^3.2.0"
   },
   "scripts": {
-    "test": "jshint solutions/javascript && mocha tests/javascript"
+    "test": "mocha tests/javascript"
   },
   "repository": {
     "type": "git",

phpunit.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<testsuites > 
+  <testsuite name="code-problom test suites">
+    <directory suffix="Test.php">tests/php</directory>
+  </testsuite>
+</testsuites>

problems/array-pair-sum/Readme.md

@@ -1,14 +1,15 @@
 # Array Pair Sum
 
-Given an integer array, output all pairs that sum up to a specific value k. Consider the fact that the same number can add up to `k` with its duplicates in the array.
+Given an integer array, output all distinct pairs that sum up to a specific value k. Consider the fact that the same number can add up to `k` with its duplicates in the array.
 
 > For example the array is [1, 1, 2, 3, 4] and the desired sum is 4. Should we output the pair (1, 3) twice or just once? Also do we output the reverse of a pair, meaning both (3, 1) and (1, 3)? Let’s keep the output as short as possible and print each pair only once. So, we will output only one copy of (1, 3). Also note that we shouldn’t output (2, 2) because it’s not a pair of two distinct elements.
 
 ## Example
 
 ```
-f(10, [3, 4, 5, 6, 7]) // [ [6, 4], [7, 3] ]
+f(10, [3, 4, 5, 6, 7]) // [ [4, 6], [3, 7] ]
 f(8, [3, 4, 5, 4, 4]) // [ [3, 5], [4, 4], [4, 4], [4, 4] ]
+f(10, [3, 5, 6, 8]) // []
 ```
 
 ## Source

problems/balanced-brackets/Readme.md

@@ -1,6 +1,6 @@
 # Balanced Brackets
 
-Write a function that accepts a string consisting entiring of brackets (`[](){}`) and returns whether it is balanced. Every "opening" bracket must be followed by a closing bracket of the same type. There can also be nested brackets, which adhere to the same rule.
+Write a function that accepts a string consisting entirely of brackets (`[](){}`) and returns whether it is balanced. Every "opening" bracket must be followed by a closing bracket of the same type. There can also be nested brackets, which adhere to the same rule.
 
 ```js
 f('()[]{}(([])){[()][]}') // true

problems/closest-sum/problem.txt

@@ -0,0 +1,9 @@
+Given an array S of n integers, find three integers in S such that the sum is closest to a given number, target. 
+Return the sum of the three integers. 
+You may assume that each input would have exactly one solution.
+
+Example: 
+given array S = {-1 2 1 -4}, 
+and target = 1.
+
+The sum that is closest to the target is 2. (-1 + 2 + 1 = 2)

problems/shop-in-candy-store/Readme.md

@@ -0,0 +1,41 @@
+# Shop in Candy Store
+
+In a candy store there are N different types of candies available  and the prices of all the N different types of candies are provided to you.
+You are now provided with an attractive offer.
+You can buy a single candy from the store and get atmost K other candies ( all are different types ) for free.
+Now you have to answer two questions. Firstly, you have to tell what is the minimum amount of money you have to spend to buy all the N different candies. Secondly, you have to tell what is the maximum amount of money you have to spend to buy all the N different candies.
+In both the cases you must utilize the offer i.e. you buy one candy and get K other candies for free.
+
+
+# Input  
+The first line of the input contains T the number of test cases. Each test case consists of two lines. The first line of each test case contains the values of N and K as described above.  Then in the next line N integers follow denoting the price of each of the N different candies.
+
+
+# Output
+For each test case output a single line containing 2 space separated integers , the first denoting the minimum amount of money required to be spent and the second denoting the maximum amount of money to be spent.
+Remember to output the answer of each test case in a new line.
+
+# Constraints      
+1 <= T <= 50
+1 <= N <= 1000
+ 0 <= K <= N-1
+1 <= Ai <= 100
+
+# Example:
+Input    
+ 1
+ 4  2
+ 3 2 1 4
+
+Output
+ 3 7
+
+# Explanation
+As according to the offer if you but one candy you can take atmost two more for free.
+So in the first case you buy the candy which costs 1 and take candies worth 3 and 4 for free, also you buy candy worth 2 as well.
+So min cost = 1+2 =3.
+In the second case I buy the candy which costs 4 and take candies worth 1 and 2 for free, also I  buy candy worth 3 as well.
+So max cost = 3+4 =7.
+
+# Topics : 
+Greedy || Sorting

problems/skiing-in-singapore/README.md

@@ -0,0 +1,31 @@
+# Skiing in Singapore
+Sometimes it's nice to take a break and code up a solution to a small, fun problem. Here is one some of our engineers enjoyed recently called Skiing In Singapore.
+
+Well you can’t really ski in Singapore. But let’s say you hopped on a flight to the Niseko ski resort in Japan. Being a software engineer you can’t help but value efficiency, so naturally you want to ski as long as possible and as fast as possible without having to ride back up on the ski lift. So you take a look at the map of the mountain and try to find the longest ski run down.
+
+In digital form the map looks like the number grid below.
+
+4 4  
+4 8 7 3  
+2 5 9 3  
+6 3 2 5  
+4 4 1 6 
+
+The first line (4 4) indicates that this is a 4x4 map. Each number represents the elevation of that area of the mountain. From each area (i.e. box) in the grid you can go north, south, east, west - but only if the elevation of the area you are going into is less than the one you are in. I.e. you can only ski downhill. You can start anywhere on the map and you are looking for a starting point with the longest possible path down as measured by the number of boxes you visit. And if there
+are several paths down of the same length, you want to take the one with the steepest vertical drop, i.e. the largest difference between your starting elevation and your ending elevation.
+
+On this particular map the longest path down is of length=5 and it’s highlighted in bold below: 9-5-3-2-1.
+
+4 4  
+4 8 7 3   
+2 5 9 3  
+6 3 2 5  
+4 4 1 6  
+
+There is another path that is also length five: 8-5-3-2-1. However the tie is broken by the first path being steeper, dropping from 9 to 1, a drop of 8, rather than just 8 to 1, a drop of 7.
+
+Your challenge is to write a program in your favorite programming language to find the longest (and then steepest) path on this map specified in the format above. It’s 1000x1000 in size, and all the numbers on it are between 0 and 1500.
+
+Send your code or a github link (and a resume if you like) to [?????? at redmart dot com], replacing “??????” with the concatenation of the length of the longest path with the largest drop, and the size of the drop. So in the simple example above length=5, drop=8, so the email address would be [58 at redmart dot com]. If your e-mail gets through - you got the right answer.
+
+Good luck and have fun!

problems/spreadsheet/README.md

@@ -0,0 +1,27 @@
+# Programming Challenge
+
+A spreadsheet consists of a two-dimensional array of cells, labeled A1, A2, etc. Rows are  identified using letters, columns by numbers. Each cell contains either an integer (its value) or  an expression. Expressions contain integers, cell references, and the operators '+', '-', '\*', '/'  with the usual rules of evaluation – note that the input is RPN and should be evaluated in stack  order.
+
+The spreadsheet input is defined as follows:
+
+1. Line 1: two integers, defining the width and height of the spreadsheet (n, m)
+
+2. n\*m lines each containing an expression which is the value of the corresponding cell (cells enumerated in the order A1, A2, A<n>, B1, ...) 
+
+## The Input
+3 2  
+A2  
+4 5 *   
+A1  
+A1 B2 / 2 +  
+3  
+39 B1 B2 * /  
+
+## The Output
+3 2  
+20.00000  
+20.00000  
+20.00000  
+8.66667  
+3.00000  
+1.50000  

problems/stack-machine/Readme.md

@@ -0,0 +1,53 @@
+# Stack Machine
+
+A stack machine is a simple system that performs arithmetic operations on an input string of numbers and operators. It contains a stack that can store an arbitrary number of 12-bit unsigned integers. Initially the stack is empty. The machine processes a string of characters in the following way:
+
+- the characters of the string are processed one by one;
+- if the current character is a digit `[0-9]`, the machine pushes the value of that digit onto its stack;
+- if the current character is `+`, the machine pops the two topmost values from its stack, adds them and pushes the result onto the stack;
+- if the current character is `*`, the machine pops the two topmost values from its stack, multiplies them and pushes the result onto the stack;
+- after the machine has processed the whole string it returns the topmost value of its stack as the result;
+- the machine reports an error if any operation it performs (addition or multiplication) results in an overflow;
+- the machine reports an error if it tries to pop an element from its stack when the stack is empty, or if the stack is empty after the machine has processed the whole string.
+
+For example, given the string "13+62*7+*" the machine will perform the following operations:
+```
+character 	| comment                | stack
+ -----------------------------------------------
+            |                        | [empty]
+ '1'        | push 1 onto the stack  |
+            |                        | 1
+ '3'        | push 3 onto the stack  |
+            |                        | 1, 3
+ '+'        | perform addition       |
+            |                        | 4
+ '6'        | push 6 onto the stack  |
+            |                        | 4, 6
+ '2'        | push 2 onto the stack  |
+            |                        | 4, 6, 2
+ '*'        | perform multiplication |
+            |                        | 4, 12
+ '7'        | push 7 onto the stack  |
+            |                        | 4, 12, 7
+ '+'        | perform addition       |
+            |                        | 4, 19
+ '*'        | perform multiplication |
+            |                        | 76
+```
+
+The machine will return `76` as the result as it is the topmost element of its stack.
+
+Write a function:
+class Solution { public int solution(string S); }
+
+that, given a string S consisting of N characters containing input for the stack machine, returns the result the machine would return if given this string. The function should return −1 if the machine would report an error when processing the string.
+
+For example, given `String S = "13+62*7+*"` the function should return `76`, as explained in the example above. Given `String S = "11++"` the function should return `-1`.
+
+Assume that:
+- the length of S is within the range [0..200,000];
+- string S consists only of the following characters: "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "+" and/or "*".
+
+In your solution, focus on **correctness**. The performance of your solution will not be the focus of the assessment.
+
+**Solution:** https://github.com/AntonioRedondo/CodingInterviewProblems/blob/master/src/StackMachine.java

problems/transitive-dependencies/Readme.md

@@ -0,0 +1,35 @@
+# Transitive Dependencies
+
+A class that calculates how dependencies propagate between things such as classes in a program. One of the insidious things about dependencies is that they are transitive—if A depends on B and B depends on C, then A also depends on C. So, this code that calculates the full set of dependencies for a group of items. Example class for test:
+
+```php
+
+<?php
+
+require_once 'transitive-dependencies.php';
+
+ class Dependencies_Test {
+
+     public $dependencies;
+
+     public function __construct() {
+         $this->dependencies = new DependenciesList();
+     }
+
+     public function add_direct_test() {
+         $this->dependencies->add_direct('A', 'B,C');
+          $this->dependencies->add_direct('B', 'C,E');
+          $this->dependencies->add_direct('C', 'G');
+          $this->dependencies->add_direct('D', 'A,F');
+          $this->dependencies->add_direct('E', 'F');
+         $this->dependencies->add_direct('F', 'H');
+     }
+
+ }
+
+$test = new Dependencies_Test();
+$test->add_direct_test();
+$resultado = $test->dependencies->dependencies_for("A");
+
+//print dependencies array in screen
+var_dump($resultado);

solutions/c/find-missing-element.c

@@ -0,0 +1,20 @@
+#include <stdio.h>
+#include <stdlib.h>
+// The differnce in sum of two arrays will give us the  desired value.
+// The other approach could be to look up for element each time but that will increase the time complexity of the program.
+ int find_missing(int orig[],int On,int shuffled[])
+{
+	int i,sum=0;
+	for(i=0;i<On-1;i++)
+		sum+=orig[i]-shuffled[i];
+	return sum+orig[On-1];
+}
+
+int main()
+{
+	int arr[]={1,3,5,6,2,5,6,8,9,23,45,67,87};
+	int shuffled_arr[]={1,2,5,6,8,9,3,45,87,6,67,5};
+	int On=sizeof(arr) / sizeof(arr[1]);
+	printf("The missing value is:%d\n",find_missing(arr,On,shuffled_arr));
+	return 0;
+}

solutions/c/multiples-of-3-and-5.c

@@ -0,0 +1,13 @@
+#include <stdio.h>
+
+int sum_of_multiples(int n)
+{	int sum=0;  
+	n=n-1;
+    sum=((n/3)*((n/3)*3 +3))/2 + ((n/5)*((n/5)*5 +5))/2 - ((n/15)*((n/15)*15 + 15))/2; // sum of airthmetic progressions & De-Morgan's Law
+    return sum;
+}
+int main()
+{
+	printf("%d\n",sum_of_multiples(1000));
+ 	return 0;
+}