solutions of ds and algo specialization

Author: HUMANIAM

Algorithms Toolbox/W1/APlusB.cpp

@@ -0,0 +1,12 @@
+#include <iostream>
+
+int main(){
+  int a = 0;
+  int b = 0;
+  int sum = 0;
+  std::cin >> a;
+  std::cin >> b;
+  sum = a + b;
+  std::cout << sum;
+  return 0;
+}

Algorithms Toolbox/W1/max_pairwise_product.cpp

@@ -0,0 +1,64 @@
+#include <iostream>
+#include <vector>
+#include <algorithm>
+
+using std::vector;
+using std::cin;
+using std::cout;
+/*
+int Maxvalue(const vector<int>& numbers, int sz)
+{
+    int maxindex = 0;
+
+    for(int i=1; i<sz; i++)
+        if(numbers[maxindex] < numbers[i])
+            maxindex = i;
+
+    return maxindex;
+}
+
+long long MaxPairwiseProduct( vector<int>& numbers)
+{
+  int n = numbers.size();
+
+  int maxindex1 = Maxvalue(numbers , n);
+  int maxvalue1 = numbers[maxindex1];
+  numbers.erase(numbers.begin() + maxindex1);
+
+  int maxindex2 = Maxvalue(numbers , n-1);
+  int maxvalue2 = numbers[maxindex2];
+
+  return (1LL * maxvalue1 * maxvalue2);
+}
+*/
+
+long long MaxPairwiseProduct(const vector<int>& numbers) {
+  int n = numbers.size();
+
+  int max_index1 = 0;
+  for (int i = 1; i < n; ++i)
+    if ((numbers[i] > numbers[max_index1]))
+      max_index1 = i;
+
+  int max_index2 = -1;
+   for (int j = 0; j < n; ++j)
+    if ((numbers[j] != numbers[max_index1]) && ((max_index2 == -1) || (numbers[j] > numbers[max_index2])))
+      max_index2 = j;
+
+  return ((long long)(numbers[max_index1])) * numbers[max_index2];
+}
+int main() {
+
+       int n;
+    cin >> n;
+    vector<int> numbers(n);
+    for (int i = 0; i < n; ++i) {
+        cin >> numbers[i];
+    }
+
+    long long result =  MaxPairwiseProduct(numbers);
+    cout << result << "\n";
+
+
+    return 0;
+}

Algorithms Toolbox/W1/max_pairwise_product.exe

@@ -0,0 +1,77 @@
+#include <cstdlib>
+#include <iostream>
+#include <vector>
+
+using std::vector;
+using std::cin;
+using std::cout;
+
+long long MaxPairwiseProduct(const vector<int>& numbers) {
+  long long result = 0;
+  int n = numbers.size();
+  for (int i = 0; i < n; ++i) {
+    for (int j = i + 1; j < n; ++j) {
+      if (((long long)(numbers[i])) * numbers[j] > result) {
+        result = ((long long)(numbers[i])) * numbers[j];
+      }
+    }
+  }
+  return result;
+}
+
+long long MaxPairwiseProductFast(const vector<int>& numbers) {
+  int n = numbers.size();
+
+  int max_index1 = 0;
+  for (int i = 1; i < n; ++i)
+    if (numbers[i] > numbers[max_index1])
+      max_index1 = i;
+
+  int max_index2 = -1;
+  for (int j = 0; j < n; ++j)
+    if ((j != max_index1) && ((max_index2 == -1) || (numbers[j] > numbers[max_index2])))
+      {
+          max_index2 = j;
+
+      }
+  return ((long long)(numbers[max_index1])) * numbers[max_index2];
+}
+
+int main() {
+    while (true) {
+    int n = rand() % 1000 + 2;
+    cout << n << "\n";
+    vector<int> a;
+    for (int i = 0; i < n; ++i) {
+      a.push_back(rand() % 100000);
+    }
+    for (int i = 0; i < n; ++i) {
+      cout << a[i] << ' ';
+    }
+    cout << "\n";
+    long long res1 = MaxPairwiseProduct(a);
+    long long res2 = MaxPairwiseProductFast(a);
+    if (res1 != res2) {
+      cout << "Wrong answer: " << res1 << ' ' << res2 << "\n";
+      break;
+    }
+    else {
+      cout << "OK\n";
+    }
+  }
+
+  int n;
+  cin >> n;
+  vector<int> numbers(n);
+
+  for (int i = 0; i < n; ++i) {
+    cin >> numbers[i];
+  }
+
+
+  long long result = MaxPairwiseProductFast(numbers);
+  long long result1 = MaxPairwiseProduct(numbers);
+  cout << result << "\n";
+  cout << result1<< "\n";
+  return 0;
+}

Algorithms Toolbox/W1/max_pairwise_product.o

@@ -0,0 +1,17 @@
+import java.util.Scanner;
+
+public class Fibonacci {
+  private static long calc_fib(int n) {
+    if (n <= 1)
+      return n;
+
+    return calc_fib(n - 1) + calc_fib(n - 2);
+  }
+
+  public static void main(String args[]) {
+    Scanner in = new Scanner(System.in);
+    int n = in.nextInt();
+
+    System.out.println(calc_fib(n));
+  }
+}

Algorithms Toolbox/W1/pairewiseproductstresstest.cpp

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+# by Andronik Ordian
+
+def calc_fib(n)
+  return n if n <= 1
+  # slow
+  # fix me
+  calc_fib(n - 1) + calc_fib(n - 2)
+end
+
+if __FILE__ == $0
+  n = gets.to_i
+  puts "#{calc_fib(n)}"
+end

Algorithms Toolbox/W2/fibonacci/Fibonacci.java

@@ -0,0 +1,56 @@
+#include <iostream>
+#include <cassert>
+
+// The following code calls a naive algorithm for computing a Fibonacci number.
+//
+// What to do:
+// 1. Compile the following code and run it on an input "40" to check that it is slow.
+//    You may also want to submit it to the grader to ensure that it gets the "time limit exceeded" message.
+// 2. Implement the fibonacci_fast procedure.
+// 3. Remove the line that prints the result of the naive algorithm, comment the lines reading the input,
+//    uncomment the line with a call to test_solution, compile the program, and run it.
+//    This will ensure that your efficient algorithm returns the same as the naive one for small values of n.
+// 4. If test_solution() reveals a bug in your implementation, debug it, fix it, and repeat step 3.
+// 5. Remove the call to test_solution, uncomment the line with a call to fibonacci_fast (and the lines reading the input),
+//    and submit it to the grader.
+
+int fibonacci_naive(int n) {
+    if (n <= 1)
+        return n;
+
+    return fibonacci_naive(n - 1) + fibonacci_naive(n - 2);
+}
+
+int fibonacci_fast(int n) {
+    // write your code here
+       if (n <= 1)
+        return n;
+
+   int f1=0, f2=1, temp;
+
+   for(int i=2; i<n; i++)
+   {
+       temp = f2;
+       f2 = f1+f2;
+       f1=temp;
+
+   }
+        return f1+f2;
+}
+
+void test_solution() {
+    assert(fibonacci_fast(3) == 2);
+    assert(fibonacci_fast(10) == 55);
+    for (int n = 0; n < 20; ++n)
+        assert(fibonacci_fast(n) == fibonacci_naive(n));
+}
+
+int main() {
+    int n = 0;
+
+    std::cin >> n;
+
+    std::cout << fibonacci_fast(n) << '\n';
+
+    return 0;
+}

Algorithms Toolbox/W2/fibonacci/by_learners/fibonacci.rb

@@ -0,0 +1,41 @@
+-- by Kirill Elagin
+
+import Control.Exception (assert)
+
+-- The following code calls a naive algorithm for computing a Fibonacci number.
+--
+-- What to do:
+-- 1. Compile the following code and run it on an input "40" to check that it is slow.
+--    You may also want to submit it to the grader to ensure that it gets the "time limit exceeded" message.
+-- 2. Implement the fibonacci_fast procedure.
+-- 3. Remove the line that prints the result of the naive algorithm, comment the lines reading the input,
+--    uncomment the line with a call to test_solution, compile the program, and run it.
+--    This will ensure that your efficient algorithm returns the same as the naive one for small values of n.
+-- 4. If test_solution reveals a bug in your implementation, debug it, fix it, and repeat step 3.
+-- 5. Remove the call to test_solution, uncomment the line with a call to fibonacci_fast (and the lines reading the input),
+--    and submit it to the grader.
+
+fibonacci_naive :: Int -> Int
+fibonacci_naive 0 = 0
+fibonacci_naive 1 = 1
+fibonacci_naive n = fibonacci_naive (n - 1) + fibonacci_naive (n - 2)
+
+fibonacci_fast :: Int -> Int
+fibonacci_fast n = 0  -- write your code here
+
+test_solution :: IO ()
+test_solution = and tests `seq` return ()
+  where
+    tests =
+      [ assert (fibonacci_fast 3  == 2)  True
+      , assert (fibonacci_fast 10 == 55) True
+      ] ++ map (\i -> assert (fibonacci_fast i == fibonacci_naive i) True) [0..20]
+
+main :: IO ()
+main = do
+  [w] <- fmap words getLine
+  let n = read w
+
+  print $ fibonacci_naive n
+  --test_solution
+  --print $ fibonacci_fast n

Algorithms Toolbox/W2/fibonacci/fibonacci.cpp

@@ -0,0 +1,9 @@
+# Uses python3
+def calc_fib(n):
+    if (n <= 1):
+        return n
+
+    return calc_fib(n - 1) + calc_fib(n - 2)
+
+n = int(input())
+print(calc_fib(n))