code changes

Author: KB-perByte

Codepedia.code-workspace

@@ -6,7 +6,20 @@
 	],
 	"settings": {
 		"files.associations": {
-			"iterator": "cpp"
+			"iterator": "cpp",
+			"__node_handle": "cpp",
+			"__split_buffer": "cpp",
+			"array": "cpp",
+			"deque": "cpp",
+			"list": "cpp",
+			"map": "cpp",
+			"queue": "cpp",
+			"set": "cpp",
+			"stack": "cpp",
+			"string": "cpp",
+			"string_view": "cpp",
+			"unordered_map": "cpp",
+			"vector": "cpp"
 		}
 	}
 }

Gen2_0_PP/Homeworks/codeforces_343bB.py

@@ -0,0 +1,20 @@
+s = input().strip()
+a = ['K']
+for i in s:
+    if a[-1]==i:
+        a.pop()
+    else:
+        a.append(i)
+if len(a)==1:
+    print("Yes")
+else:
+    print("No")
+
+
+#try 2
+
+s=[]
+for i in input():
+    if s and s[-1]==i:s.pop()
+    else:s.append(i)
+print('Yneos'[bool(s)::2])

Gen2_0_PP/Homeworks/codeforces_81A.cpp

@@ -0,0 +1,41 @@
+#include <iostream>
+#include <string>
+#include <stack>
+using namespace std;
+ 
+ 
+int main()
+{
+    string s;
+    cin>>s;
+    stack<char> sta;
+    for(int i=0;i<s.length();i++)
+    {
+        if(sta.empty())
+        {
+            sta.push(s.at(i));
+            continue;
+        }
+        char ch = sta.top();
+        if(s.at(i)!=ch)
+        {
+            sta.push(s.at(i));
+        }else
+        {
+            sta.pop();
+        }
+    }
+    stack<char> sta1;
+    while(!sta.empty())
+    {
+        sta1.push(sta.top());
+        sta.pop();
+    }
+    while(!sta1.empty())
+    {
+        cout<<sta1.top();
+        sta1.pop();
+    }
+ 
+    return 0;
+}

Gen2_0_PP/Homeworks/codeforces_81A.py

@@ -0,0 +1,9 @@
+s = []
+for t in raw_input():
+    if len(s) < 1:
+        s.append(t)
+    elif t == s[-1]:
+        s.pop()
+    else:
+        s.append(t)
+print ''.join(s)

Gen2_0_PP/Homeworks/leetcode_customStack.py

@@ -0,0 +1,32 @@
+class CustomStack:
+
+    def __init__(self, maxSize: int):
+        self.item =  []
+        self.size =  0
+        self.maxsize = maxSize
+        
+    def push(self, x: int) -> None:
+        if self.size < self.maxsize:
+            self.item.append(x)
+            self.size+=1
+
+    def pop(self) -> int:
+        if  self.size >0:
+            self.size-=1
+            return self.item.pop()
+        else:
+            return -1
+
+    def increment(self, k: int, val: int) -> None:
+        for i in range(k):
+            if i < self.size:
+                self.item[i] += val
+            else:
+                break
+
+
+# Your CustomStack object will be instantiated and called as such:
+# obj = CustomStack(maxSize)
+# obj.push(x)
+# param_2 = obj.pop()
+# obj.increment(k,val)

Gen2_0_PP/Homeworks/leetcode_minStack.py

@@ -0,0 +1,34 @@
+class Node:
+    def __init__(self, val=None, mini=None, next=None):
+        self.val = val
+        self.minimum = mini
+        self.next = next
+
+class MinStack:
+
+    def __init__(self):
+        self.head = None
+        
+    def push(self, x: int) -> None:
+        if self.head is None:
+            node = Node(x, x)
+            self.head = node
+        else:
+            node = Node(x, min(x, self.head.minimum), self.head)
+            self.head = node
+        
+    def pop(self) -> None:
+        self.head = self.head.next
+        
+    def top(self) -> int:
+        return self.head.val
+
+    def getMin(self) -> int:
+        return self.head.minimum
+
+# Your MinStack object will be instantiated and called as such:
+# obj = MinStack()
+# obj.push(x)
+# obj.pop()
+# param_3 = obj.top()
+# param_4 = obj.getMin()

Gen2_0_PP/Homeworks/leetcode_simplyfyPath.py

@@ -0,0 +1,18 @@
+class Solution:
+    def simplifyPath(self, path: str) -> str:
+        stack = []
+        l = path.split('/')
+        for i in range(len(l)):
+            if(l[i]=='..' and len(stack)!=0):
+                stack.pop()
+            else:
+                if(len(l[i])!=0 and l[i]!='.' and l[i]!='..'):
+                    stack.append(l[i])
+                else:
+                    continue
+        if(len(stack)==0):
+            return "/"
+        string = ""
+        while(len(stack)!=0):
+            string = '/' + stack.pop() + string 
+        return string

Gen2_0_PP/Homeworks/spoj_STPAR.py

@@ -0,0 +1,42 @@
+n = int(input())
+queue = list(map(int,input().split()))
+
+stack = []
+fix_order = 1
+keep_tracking = True
+is_order = True
+
+while (keep_tracking):
+    q1 = queue[0] if len(queue) > 0 else -1
+    s1 = stack[-1] if len(stack) > 0 else -1
+
+    if q1 == fix_order:
+        del queue[0]
+        fix_order = fix_order + 1
+        continue
+
+    if s1 == fix_order:
+        stack.pop()
+        fix_order = fix_order + 1
+        continue
+
+    if q1 != -1:
+        del queue[0]
+        stack.append(q1)
+        continue
+
+    # DONE
+    if q1 == -1 and s1 == -1:
+        keep_tracking = False
+        continue
+
+    #Can't order
+    if q1 == -1 and s1 != fix_order:
+        keep_tracking = False
+        is_order = False
+        
+if is_order == False:
+    print('no')
+else:
+    print('yes')
+

Leetcode_31daysJuly/day30_wordBreakII.py

@@ -0,0 +1,28 @@
+class Solution:
+    def wordBreak(self, s: str, wordDict: List[str]) -> List[str]:
+        d = {0: [], len(s): []}
+		#values contain arrays of indices of all words that end at key index
+        for ind, c in enumerate(s):
+            if not ind in d: #we considered all indices before ind so skipping
+                continue
+            for w in wordDict:
+                if s.startswith(w, ind):
+                    ind1 = ind + len(w)
+                    ar1 = d.get(ind1, [])
+                    if not ar1:
+                        d[ind1] = ar1
+                    ar1.append(ind)
+        d1 = {0: [], len(s) : []}
+		#Reconstruct all possible combinations back to index 0
+        for ind in range(len(s), 0, -1):
+            if not ind in d1:
+                continue
+            res = d1.get(ind, [])
+            for i in d[ind]:
+                res1 = [s[i: ind] + ' ' + ns for ns in res] if res else [s[i: ind]]
+                res2 = d1.get(i, [])
+                if not res2:
+                    d1[i] = res1
+                else:
+                    res2.extend(res1)
+        return d1[0]

Leetcode_31daysJuly/day31_climbingStairs.py

@@ -0,0 +1,13 @@
+class Solution:
+    def climbStairs(self, n: int) -> int:
+        dp = [0]*n
+        
+        for i in range(n):
+            if (i == 0):
+                dp[i] = 1
+            elif (i == 1):
+                dp[i] = 2
+            else:
+                dp[i] = dp[i-1]+dp[i-2]
+                
+        return dp[-1]

Notebooks/TestNotebookCode.ipynb

@@ -14,7 +14,7 @@
   },
   "orig_nbformat": 2,
   "kernelspec": {
-   "name": "python_defaultSpec_1596048486366",
+   "name": "python_defaultSpec_1596114798131",
    "display_name": "Python 3.7.3 64-bit"
   }
  },
@@ -507,6 +507,33 @@
     "min(1,1)"
    ]
   },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "a = [1,2,3,4,5]\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "output_type": "execute_result",
+     "data": {
+      "text/plain": "5"
+     },
+     "metadata": {},
+     "execution_count": 9
+    }
+   ],
+   "source": [
+    "a[-1]"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": null,