def lopUselessLeaves(cls, pn): """ generated source for method lopUselessLeaves """ usefulComponents = HashSet() toAdd = Stack() toAdd.add(pn.getTerminalProposition()) usefulComponents.add(pn.getInitProposition()) for goalProps in pn.getGoalPropositions().values(): toAdd.addAll(goalProps) for legalProps in pn.getLegalPropositions().values(): toAdd.addAll(legalProps) while not toAdd.isEmpty(): if usefulComponents.contains(curComp): continue usefulComponents.add(curComp) toAdd.addAll(curComp.getInputs()) allComponents = ArrayList(pn.getComponents()) for c in allComponents: if not usefulComponents.contains(c): pn.removeComponent(c)
def __init__(self, theRandom): """ generated source for method __init__ """ super(MappingGdlScrambler, self).__init__() self.random = theRandom self.scrambleMapping = HashMap() self.unscrambleMapping = HashMap() self.scrambledPrefix = 0 self.scrambledTokens = Stack() for word in WordList.words: self.scrambledTokens.add(word) Collections.shuffle(self.scrambledTokens, self.random)
def removeUnreachableBasesAndInputs(cls, pn, basesTrueByInit): """ generated source for method removeUnreachableBasesAndInputs """ reachability = Maps.newHashMap() numTrueInputs = HashMultiset.create() numFalseInputs = HashMultiset.create() toAdd = Stack() legalsToInputs = Maps.newHashMap() for legalProp in Iterables.concat(pn.getLegalPropositions().values()): if inputProp != None: legalsToInputs.put(legalProp, inputProp) for c in pn.getComponents(): ConcurrencyUtils.checkForInterruption() if isinstance(c, (Constant, )): if c.getValue(): toAdd.add(Pair.of(c, cls.Type.TRUE)) else: toAdd.add(Pair.of(c, cls.Type.FALSE)) for p in pn.getInputPropositions().values(): toAdd.add(Pair.of(p, cls.Type.FALSE)) for baseProp in pn.getBasePropositions().values(): if basesTrueByInit.contains(baseProp): toAdd.add(Pair.of(baseProp, cls.Type.TRUE)) else: toAdd.add(Pair.of(baseProp, cls.Type.FALSE)) initProposition = pn.getInitProposition() toAdd.add(Pair.of(initProposition, cls.Type.BOTH)) while not toAdd.isEmpty(): ConcurrencyUtils.checkForInterruption() if oldType == None: oldType = cls.Type.NEITHER if isinstance(curComp, (Proposition, )): typeToAdd = newInputType elif isinstance(curComp, (Transition, )): typeToAdd = newInputType elif isinstance(curComp, (Constant, )): typeToAdd = newInputType elif isinstance(curComp, (Not, )): typeToAdd = newInputType.opposite() elif isinstance(curComp, (And, )): if newInputType.hasTrue: numTrueInputs.add(curComp) if numTrueInputs.count(curComp) == curComp.getInputs().size(): typeToAdd = cls.Type.TRUE if newInputType.hasFalse: typeToAdd = typeToAdd.with_(cls.Type.FALSE) elif isinstance(curComp, (Or, )): if newInputType.hasFalse: numFalseInputs.add(curComp) if numFalseInputs.count(curComp) == curComp.getInputs().size(): typeToAdd = cls.Type.FALSE if newInputType.hasTrue: typeToAdd = typeToAdd.with_(cls.Type.TRUE) else: raise RuntimeException("Unhandled component type " + curComp.__class__) if oldType.includes(typeToAdd): continue reachability.put(curComp, typeToAdd.with_(oldType)) typeToAdd = typeToAdd.minus(oldType) if typeToAdd == cls.Type.NEITHER: raise RuntimeException("Something's messed up here") for output in curComp.getOutputs(): toAdd.add(Pair.of(output, typeToAdd)) if legalsToInputs.containsKey(curComp): if inputProp == None: raise IllegalStateException() toAdd.add(Pair.of(inputProp, typeToAdd)) trueConst = Constant(True) falseConst = Constant(False) pn.addComponent(trueConst) pn.addComponent(falseConst) for entry in reachability.entrySet(): if type_ == cls.Type.TRUE or type_ == cls.Type.FALSE: if isinstance(c, (Constant, )): continue for input in c.getInputs(): input.removeOutput(c) c.removeAllInputs() if type_ == cls.Type.TRUE ^ (isinstance(c, (Not, ))): c.addInput(trueConst) trueConst.addOutput(c) else: c.addInput(falseConst) falseConst.addOutput(c) cls.optimizeAwayTrueAndFalse(pn, trueConst, falseConst)
Input: " 3+5 / 2 " Output: 5 Note: You may assume that the given expression is always valid. Do not use the eval built-in library function. 先保存数字,再保存运算符 import java.util.Stack; class Solution { public static int calculate(String s) { char[] chars = s.replace(" ", "").toCharArray(); long res = 0, num = 0; char op = '+'; Stack<Long> st = new Stack(); for (int i = 0; i < chars.length; i++) { if (chars[i] >= '0') num = num * 10 + chars[i] - '0'; if (chars[i] < '0' || i == chars.length - 1) { //switch case if (op == '+') st.push(num); else if (op == '-') st.push(-num); else if (op == '*' || op == '/') { Long tmp = (op == '*') ? st.pop() * num : st.pop() / num; st.push(tmp); } op = chars[i]; num = 0;
# https://www.facebook.com/prayash.mohapatra.376/posts/391656181833378 # Subscribed by Code House # Program to check palindrome string import java.util.Stack; import java.util.Scanner; class PalindromeTest { public static void main(String[] args) { System.out.print("Enter any string:"); Scanner in=new Scanner(System.in); String inputString = in.nextLine(); Stack stack = new Stack(); for (int i = 0; i < inputString.length(); i++) { stack.push(inputString.charAt(i)); } String reverseString = ""; while (!stack.isEmpty()) { reverseString = reverseString+stack.pop(); } if (inputString.equals(reverseString)) System.out.println("The input String is a palindrome."); else System.out.println("The input String is not a palindrome."); } }
# -*- coding: utf-8 -*- from __future__ import unicode_literals from java.util import Stack a = Stack() for k in range(10): a.push(k) print(a.search(7)) print(a.peek()) print(a.pop()) print(type(a)) print(a)
class MappingGdlScrambler(GdlScrambler): """ generated source for class MappingGdlScrambler """ scrambleMapping = Map() unscrambleMapping = Map() random = Random() scrambledPrefix = int() scrambledTokens = Stack() def __init__(self, theRandom): """ generated source for method __init__ """ super(MappingGdlScrambler, self).__init__() self.random = theRandom self.scrambleMapping = HashMap() self.unscrambleMapping = HashMap() self.scrambledPrefix = 0 self.scrambledTokens = Stack() for word in WordList.words: self.scrambledTokens.add(word) Collections.shuffle(self.scrambledTokens, self.random) class ScramblingRenderer(GdlRenderer): """ generated source for class ScramblingRenderer """ def renderConstant(self, constant): """ generated source for method renderConstant """ return scrambleWord(constant.getValue()) def renderVariable(self, variable): """ generated source for method renderVariable """ return scrambleWord(variable.__str__()) class UnscramblingRenderer(GdlRenderer): """ generated source for class UnscramblingRenderer """ def renderConstant(self, constant): """ generated source for method renderConstant """ return unscrambleWord(constant.getValue()) def renderVariable(self, variable): """ generated source for method renderVariable """ return unscrambleWord(variable.__str__()) def scramble(self, x): """ generated source for method scramble """ return self.ScramblingRenderer().renderGdl(x) def unscramble(self, x): """ generated source for method unscramble """ return GdlFactory.create(self.UnscramblingRenderer().renderGdl(GdlFactory.create(x))) def scrambles(self): """ generated source for method scrambles """ return True def scrambleWord(self, realWord): """ generated source for method scrambleWord """ if not shouldMap(realWord): return realWord if not self.scrambleMapping.containsKey(realWord): if realWord.startsWith("?"): fakeWord = "?" + fakeWord self.scrambleMapping.put(realWord, fakeWord) self.unscrambleMapping.put(fakeWord, realWord) return self.scrambleMapping.get(realWord) def unscrambleWord(self, fakeWord): """ generated source for method unscrambleWord """ if not shouldMap(fakeWord): return fakeWord fakeWord = fakeWord.lower() if not self.unscrambleMapping.containsKey(fakeWord): return fakeWord return self.unscrambleMapping.get(fakeWord) def getRandomWord(self): """ generated source for method getRandomWord """ if self.scrambledTokens.isEmpty(): for word in WordList.words: self.scrambledTokens.add(word + self.scrambledPrefix) Collections.shuffle(self.scrambledTokens, self.random) self.scrambledPrefix += 1 return self.scrambledTokens.pop() @classmethod def shouldMap(cls, token): """ generated source for method shouldMap """ if GdlPool.KEYWORDS.contains(token.lower()): return False try: Integer.parseInt(token) return False except NumberFormatException as e: return True