Merge pull request ashutosh97#1 from ashutosh97/master

updating my fork

Author: sakshamb2113

.DS_Store

@@ -0,0 +1,6 @@
+Acronym
+Convert a phrase to its acronym.
+
+Techies love their TLA (Three Letter Acronyms)!
+
+Help generate some jargon by writing a program that converts a long name like Portable Network Graphics to its acronym (PNG).

Acronym/instructions.txt

@@ -0,0 +1,13 @@
+def abbreviate(string)
+  string_arr = string.scan(/\b\w/)
+  string_arr.join.upcase
+end
+
+
+# begin
+# >> abbreviate("Portable Network Graphics")
+# => "PNG"
+# >> abbreviate("Ruby on Rails")
+# => "ROR"
+# >> abbreviate("GNU Image Manipulation Program")
+# => "GIMP"

Acronym/ruby_solution.rb

@@ -0,0 +1,39 @@
+# Python3 program to check if two strings are anagram of each other
+
+def are_anagram(s1, s2):
+    """ Check if two strings are anagram of each other.
+
+    Apply XOR to all characters of both strings. If the final value is 0, then
+    there is an even occurence of all characters, ie the two strings are
+    anagram. Otherwise, there are not anagram.
+
+    Args:
+        s1 (str): First string
+        s2 (str): Second string
+
+    Returns:
+        bool: True if the two strings are anagram of each other, otherwise False
+    """
+    # Two strings with different sizes can not be anagram of each other
+    if len(s1) != len(s2):
+        return False
+
+    # Apply XOR to all characters of both strings
+    xor_value = 0
+    for c1, c2 in zip(s1, s2):
+        xor_value = xor_value ^ ord(c1)
+        xor_value = xor_value ^ ord(c2)
+
+    return not bool(xor_value)
+
+def main():
+    """ Driver code """
+    s1 = 'listen'
+    s2 = 'silent'
+    s3 = 'hacktoberfest'
+    print('{} / {} -> {}'.format(s1, s2, are_anagram(s1, s2)))
+    print('{} / {} -> {}'.format(s1, s3, are_anagram(s1, s3)))
+    print('{} / {} -> {}'.format(s2, s3, are_anagram(s2, s3)))
+
+if __name__=='__main__':
+    main()

AnagramChecking/anagram_checking.py

@@ -0,0 +1,3 @@
+Anagram checking
+
+Write a function that check whether two given strings are anagram of each other. An anagram is a word or phrase formed by rearranging the letters of a different word or phrase using all the original letters exactly once. An optimized solution should have a O(n) time complexity and O(1) space complexity.

AnagramChecking/anagram_checking.txt

@@ -0,0 +1,13 @@
+Write a function that counts how many different ways you can make change for an amount of money, given an array of coin denominations. For example, there are 3 ways to give change for 4 if you have coins with denomination 1 and 2:
+
+1+1+1+1, 1+1+2, 2+2.
+The order of coins does not matter:
+
+1+1+2 == 2+1+1
+Also, assume that you have an infinite amount of coins.
+
+Your function should take an amount to change and an array of unique denominations for the coins:
+
+  countChange(4, [1,2]) // => 3
+  countChange(10, [5,2,3]) // => 4
+  countChange(11, [5,7]) //  => 0

Counting-Change-Combinations/counting.txt

@@ -0,0 +1,24 @@
+let countChange = function(money, coins) {
+  if (coins.length === 0) {
+      return 0;
+  }
+
+  coins = coins.slice(0).sort();
+  let result = 0,
+      largestCoin = coins.pop(),
+      maxCount = 0;
+  let maxRemain = money % largestCoin;
+
+  if (maxRemain === 0) {
+      result++;
+      maxCount = money / largestCoin - 1;
+  } else {
+      maxCount = (money - maxRemain) / largestCoin;
+  }
+
+  for (let i = maxCount; i >= 0; i--) {
+      result += countChange(money - largestCoin * i, coins);
+  }
+
+  return result;
+}

Counting-Change-Combinations/solution.js

@@ -0,0 +1,32 @@
+Chef was reading some quotes by great people. Now, he is interested in classifying all the fancy quotes he knows. He thinks that all fancy quotes which contain the word "not" are Real Fancy; quotes that do not contain it are regularly fancy.
+
+You are given some quotes. For each quote, you need to tell Chef if it is Real Fancy or just regularly fancy.
+
+Input
+The first line of the input contains a single integer T denoting the number of test cases. The description of T test cases follows.
+The first and only line of each test case contains a single string S denoting a quote.
+
+Output
+For each test case, print a single line containing the string "Real Fancy" or "regularly fancy" (without quotes).
+
+Constraints
+1≤T≤50
+1≤|S|≤100
+each character of S is either a lowercase English letter or a space
+
+Subtasks
+Subtask #1 (100 points): original constraints
+
+Example Input
+2
+i do not have any fancy quotes
+when nothing goes right go left
+
+Example Output
+Real Fancy
+regularly fancy
+
+Explanation
+Example case 1: "i do not have any fancy quotes"
+
+Example case 2: The word "not" does not appear in the given quote.

FANCY/problem.txt

@@ -0,0 +1,16 @@
+# cook your dish here
+x=int(input())
+p=0
+flag=0
+while(p<x):
+    s=str(input())
+    s=s.split(" ")
+    for i in range(len(s)):
+        if(s[i]=='not'):
+            print("Real Fancy")
+            flag=1
+            break
+    if(flag==0):
+        print("regularly fancy")
+    flag=0
+    p=p+1

FANCY/solution.py

@@ -0,0 +1,13 @@
+main() {
+  for (int i = 1; i <= 100; i++) {
+    if (i % 15 == 0) {
+      print('fizzbuzz');
+    } else if (i % 5 == 0) {
+      print('buzz');
+    } else if (i % 3 == 0) {
+      print('fizz');
+    } else {
+      print(i);
+    }
+  }
+}