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
