Merge pull request #1 from codemistic/main

Code Update

Author: Enigma-52

.DS_Store

@@ -0,0 +1,28 @@
+#include<bits/stdc++.h>
+using namespace std;
+int main(){
+
+string s;
+getline(cin,s);
+
+int l=s.length();
+int f=0;
+for (int i=l;i=0;i--){
+if (s[i]!=' ' || s[i]!='?'){
+    if (s[i]=='A' || s[i]=='E' || s[i]=='I' || s[i]=='O' || s[i]=='U' || s[i]=='Y' || s[i]=='a' || s[i]=='e' || s[i]=='i' || s[i]=='o' || s[i]=='u' || s[i]=='y' ){
+       f=1;
+       break;
+
+    }
+    else
+   f=0;}}
+
+   if (f==1){
+        cout<<"YES"<<endl;
+   }
+    else
+    cout<<"NO"<<endl;
+
+   
+    return 0;
+}

49a.cpp

@@ -0,0 +1,166 @@
+
+import java.util.ArrayList;
+
+import java.util.Arrays;
+ 
+// Given two integers a and b. The task is to print
+// sum of all the digits appearing in the
+// integers between a and b
+
+public class AMAN {
+ 
+
+    // Memoization for the state results
+
+    static long dp[][][] = new long[20][180][2];
+ 
+
+    // Stores the digits in x in a vector digit
+
+    static void getDigits(long x, ArrayList<Integer> digit)
+
+    {
+
+        while (x != 0) {
+
+            digit.add((int)(x % 10));
+
+            x /= 10;
+
+        }
+
+    }
+ 
+
+    // Return sum of digits from 1 to integer in
+
+    // digit vector
+
+    static long digitSum(int idx, int sum, int tight,
+
+                         ArrayList<Integer> digit)
+
+    {
+
+        // base case
+
+        if (idx == -1)
+
+            return sum;
+ 
+
+        // checking if already calculated this state
+
+        if (dp[idx][sum][tight] != -1 && tight != 1)
+
+            return dp[idx][sum][tight];
+ 
+
+        long ret = 0;
+ 
+
+        // calculating range value
+
+        int k = (tight != 0) ? digit.get(idx) : 9;
+ 
+
+        for (int i = 0; i <= k; i++) {
+
+            // calculating newTight value for next state
+
+            int newTight
+
+                = (digit.get(idx) == i) ? tight : 0;
+ 
+
+            // fetching answer from next state
+
+            ret += digitSum(idx - 1, sum + i, newTight,
+
+                            digit);
+
+        }
+ 
+
+        if (tight != 0)
+
+            dp[idx][sum][tight] = ret;
+ 
+
+        return ret;
+
+    }
+ 
+
+    // Returns sum of digits in numbers from a to b.
+
+    static int rangeDigitSum(int a, int b)
+
+    {
+
+        // initializing dp with -1
+
+        for (int i = 0; i < 20; i++)
+
+            for (int j = 0; j < 180; j++)
+
+                for (int k = 0; k < 2; k++)
+
+                    dp[i][j][k] = -1;
+ 
+
+        // storing digits of a-1 in digit vector
+
+        ArrayList<Integer> digitA
+
+            = new ArrayList<Integer>();
+
+        getDigits(a - 1, digitA);
+ 
+
+        // Finding sum of digits from 1 to "a-1" which is
+
+        // passed as digitA.
+
+        long ans1
+
+            = digitSum(digitA.size() - 1, 0, 1, digitA);
+ 
+
+        // Storing digits of b in digit vector
+
+        ArrayList<Integer> digitB
+
+            = new ArrayList<Integer>();
+
+        getDigits(b, digitB);
+ 
+
+        // Finding sum of digits from 1 to "b" which is
+
+        // passed as digitB.
+
+        long ans2
+
+            = digitSum(digitB.size() - 1, 0, 1, digitB);
+ 
+
+        return (int)(ans2 - ans1);
+
+    }
+ 
+
+    // driver function to call above function
+
+    public static void main(String[] args)
+
+    {
+
+        int a = 123, b = 1024;
+
+        System.out.println("digit sum for given range : "
+
+                           + rangeDigitSum(a, b));
+
+    }
+}

Add-digit-dp-problem.java

@@ -0,0 +1,35 @@
+#include <bits/stdc++.h>
+using namespace std;
+ 
+// All denominations of Indian Currency
+int deno[] = { 1, 2, 5, 10, 20, 50, 100, 500, 1000 };
+int n = sizeof(deno) / sizeof(deno[0]);
+ 
+// Driver program
+void findMin(int V)
+{
+    // Initialize result
+    vector<int> ans;
+ 
+    // Traverse through all denomination
+    for (int i = n - 1; i >= 0; i--) {
+        // Find denominations
+        while (V >= deno[i]) {
+            V -= deno[i];
+            ans.push_back(deno[i]);
+        }
+    }
+ 
+    // Print result
+    for (int i = 0; i < ans.size(); i++)
+        cout << ans[i] << "  ";
+}
+ 
+// Driver program
+int main()
+{
+    int n = 93;
+    cout << "Following is minimal number of change for " << n << " is ";
+    findMin(n);
+    return 0;
+}

CPP/.DS_Store

@@ -0,0 +1,82 @@
+#include <bits/stdc++.h>
+using namespace std;
+class TextEditor
+{
+private:
+    list<char> a;
+    // If delete, will delete position cur - 1, not position cur.
+    list<char>::iterator cur;
+
+public:
+    TextEditor()
+    {
+        a.clear();
+        // For convenience.
+        a.push_back('A');
+        cur = a.end();
+    }
+
+    void addText(string text)
+    {
+        a.insert(cur, text.begin(), text.end());
+    }
+
+    int deleteText(int k)
+    {
+        int cnt = 0;
+        // Move to the position that will be deleted.
+        cur--;
+        while (k--)
+        {
+            if (cur == a.begin())
+                break;
+            cnt++;
+            a.erase(cur--);
+        }
+        // Adjust the position of the cursor.
+        cur++;
+        return cnt;
+    }
+
+    // Left 10 chars.
+    string solve()
+    {
+        auto tt = cur;
+        tt--;
+        string ret;
+        int k = 10;
+        while (k--)
+        {
+            if (tt == a.begin())
+                break;
+            ret += (*(tt--));
+        }
+        reverse(ret.begin(), ret.end());
+        return ret;
+    }
+
+    string cursorLeft(int k)
+    {
+        while (k--)
+        {
+            auto nxt = cur;
+            nxt--;
+            // Never move the cursor to the first position.
+            if (nxt == a.begin())
+                break;
+            cur = nxt;
+        }
+        return solve();
+    }
+
+    string cursorRight(int k)
+    {
+        while (k--)
+        {
+            if (cur == a.end())
+                break;
+            cur++;
+        }
+        return solve();
+    }
+};

CPP/Greedy_algorithm.cpp

@@ -0,0 +1,30 @@
+class Solution {
+public:
+    double value4(double d)
+{
+    return (log2(d))/2;
+}
+bool is_integer(float k)
+{
+  return std::floor(k) == k;
+}
+    bool isPowerOfFour(int n) {
+        if(n<=0){
+            return false;
+        }
+        if(n==1){
+            return true;
+        }
+        if(n%4!=0){
+            return false;
+        }
+        else{
+             if(is_integer(value4(n))){
+        return true;
+    }
+    else{
+        return false;
+    }
+        }
+    }
+};