public static void main(String[] args) { // String output; Ball BigBall = new Ball(5); JFrame frame1 = new JFrame(); frame1.setTitle("Welcome to Ship!"); frame1.setSize(300, 300); frame1.setLocation(200, 100); frame1.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); JComboBox<String> box = new JComboBox<String>(new String[] {"Casey", "Connolly", "Nielson"}); JPanel panel = new JPanel(); panel.add(box); frame1.add(panel); frame1.setVisible(true); TV tv1 = new TV(); tv1.turnOn(); tv1.setChannel(30); tv1.setVolume(3); System.out.println(tv1.toString()); Stack stacker = new Stack(); for (int i = 0; i < 10; i++) stacker.push(i); while (!stacker.empty()) System.out.println(stacker.pop() + " "); System.out.println(BigBall.toString()); System.out.println("Finished"); }
public StringBuffer translate() { for (index = 0; index < line.length(); index++) { char c = line.charAt(index); if (Character.isDigit(c)) { dealWithOperand(); } else if (isOperator(c)) { dealWithOperator(c); } else if (c == '(') { stack.push(new Character(c)); } else if (c == ')') { dealWithCloser(); } else if (Character.isSpaceChar(c)) { // do nothing } else { System.out.println("Error: unknown character" + c); } } // pop and output all the operators left on the stack while (!stack.empty()) { out.append(popChar()); } return out; }
public void reorderList(ListNode head) { if (head == null || head.next == null || head.next.next == null) { return; } ListNode oneStep = head; ListNode twoStep = head; while (twoStep != null && twoStep.next != null) { twoStep = twoStep.next.next; oneStep = oneStep.next; } ListNode half = oneStep.next; oneStep.next = null; Stack<ListNode> stack = new Stack<ListNode>(); while (half != null) { stack.push(half); half = half.next; } ListNode tmp = head; while (head != null) { ListNode oldRight = head.next; if (stack.empty()) { break; } head.next = stack.pop(); head.next.next = oldRight; head = oldRight; } head = tmp; }
/** * Get the ISchemaElement corresponding to this IDocumentElementNode * * @param node * @param extensionPoint the extension point of the schema, if <code>null</code> it will be * deduced * @return the ISchemaElement for <code>node</code> */ public static ISchemaElement getSchemaElement(IDocumentElementNode node, String extensionPoint) { if (extensionPoint == null) { IMonitorObject obj = getTopLevelParent(node); if (!(obj instanceof IMonitorExtension)) return null; extensionPoint = ((IMonitorExtension) obj).getPoint(); } ISchema schema = MDECore.getDefault().getSchemaRegistry().getSchema(extensionPoint); if (schema == null) return null; // Bug 213457 - look up elements based on the schema in which the parent is found if (schema.getIncludes().length == 0 || "extension".equals(node.getXMLTagName())) // $NON-NLS-1$ return schema.findElement(node.getXMLTagName()); // if element is not "extension" & has multiple sub-schemas, // Then search for the element in the same schema in which the parent element if found. Stack stack = new Stack(); while (node != null) { String tagName = node.getXMLTagName(); if ("extension".equals(tagName)) // $NON-NLS-1$ break; stack.push(node.getXMLTagName()); node = node.getParentNode(); } ISchemaElement element = null; while (!stack.isEmpty()) { element = schema.findElement((String) stack.pop()); if (element == null) return null; schema = element.getSchema(); } return element; }
public static boolean isPalindrome(Node n) { Node slow = n; Node fast = n; Stack<Integer> stack = new Stack<Integer>(); while (fast != null && fast.next != null) { stack.push(slow.data); slow = slow.next; fast = fast.next.next; } // odd number, skip the middle one if (fast != null) { slow = slow.next; } while (!stack.empty()) { int top = stack.pop(); if (slow.data != top) { return false; } slow = slow.next; } return true; }
public void parseStyleDeclaration(CSSStyleDeclaration sd, InputSource source) throws IOException { Stack nodeStack = new Stack(); nodeStack.push(sd); CSSOMHandler handler = new CSSOMHandler(nodeStack); _parser.setDocumentHandler(handler); _parser.parseStyleDeclaration(source); }
public boolean visit(Assignment assignment) throws Exception { Expression left = assignment.getVariable(); if (left instanceof FieldAccess) { // class variable ($this->a = .) FieldAccess fieldAccess = (FieldAccess) left; Expression dispatcher = fieldAccess.getDispatcher(); if (dispatcher instanceof VariableReference && "$this".equals(((VariableReference) dispatcher).getName())) { // $NON-NLS-1$ Expression field = fieldAccess.getField(); if (field instanceof SimpleReference) { SimpleReference var = (SimpleReference) field; int modifiers = Modifiers.AccPublic; int offset = var.sourceStart(); int length = var.sourceEnd() - offset; StringBuilder metadata = new StringBuilder(); if (fCurrentQualifier != null) { metadata.append(fCurrentQualifierCounts.get(fCurrentQualifier)); metadata.append(";"); // $NON-NLS-1$ } modifyDeclaration( assignment, new DeclarationInfo( IModelElement.FIELD, modifiers, offset, length, offset, length, '$' + var.getName(), metadata.length() == 0 ? null : metadata.toString(), null, fCurrentQualifier, fCurrentParent)); } } } else if (left instanceof VariableReference) { int modifiers = Modifiers.AccPublic | Modifiers.AccGlobal; if (!declarations.empty() && declarations.peek() instanceof MethodDeclaration && !methodGlobalVars.peek().contains(((VariableReference) left).getName())) { return visitGeneral(assignment); } int offset = left.sourceStart(); int length = left.sourceEnd() - offset; modifyDeclaration( assignment, new DeclarationInfo( IModelElement.FIELD, modifiers, offset, length, offset, length, ((VariableReference) left).getName(), null, null, null, null)); } return visitGeneral(assignment); }
// check that algorithm computes either the topological order or finds a directed cycle private void dfs(Digraph G, int v) { onStack[v] = true; marked[v] = true; for (int w : G.adj(v)) { // short circuit if directed cycle found if (cycle != null) return; // found new vertex, so recur else if (!marked[w]) { edgeTo[w] = v; dfs(G, w); } // trace back directed cycle else if (onStack[w]) { cycle = new Stack<Integer>(); for (int x = v; x != w; x = edgeTo[x]) { cycle.push(x); } cycle.push(w); cycle.push(v); } } onStack[v] = false; }
/** * Returns a path between the source vertex <tt>s</tt> and vertex <tt>v</tt>, or <tt>null</tt> if * no such path. * * @param v the vertex * @return the sequence of vertices on a path between the source vertex <tt>s</tt> and vertex * <tt>v</tt>, as an Iterable */ public Iterable<Integer> pathTo(int v) { if (!hasPathTo(v)) return null; Stack<Integer> path = new Stack<Integer>(); for (int x = v; x != s; x = edgeTo[x]) path.push(x); path.push(s); return path; }
public Node peek() { if (s2 == null) s2 = new Stack(); if (s2.peek() == null) { transfer(); } return s2.peek(); }
public int poll() { if (s2 == null) s2 = new Stack(); if (s2.peek() == null) { transfer(); } return s2.pop(); }
public XNStackFrame getCurrentStackFrame() { if (!callStack.isEmpty()) { return callStack.peek(); } else { return null; } }
public XNResponder getCurrentResponder() { if (!responderStack.isEmpty()) { return responderStack.peek(); } else { return null; } }
private void initStack(XNContext parent) { initStack(); firstResponder = parent.firstResponder; responderStack.addAll(parent.responderStack); callStack.addAll(parent.callStack); result = parent.result; }
/** * Adds a new cell to the table with the specified actors in a {@link Stack}. * * @param actors May be null to add a stack without any actors. */ public Cell stack(Actor... actors) { Stack stack = new Stack(); if (actors != null) { for (int i = 0, n = actors.length; i < n; i++) stack.addActor(actors[i]); } return add(stack); }
private void dfs(Digraph G ,int v){ onStack[v] = true ; marked[v] = true ; for(int w:G.adj(v)) if(this.hasCycle()) { } if(!marked[v]){ edgeTo[w] = v; dfs(G,w); } else{ if(onStack[w]){ cycle = new Stack<Integer>(); for(int x = v; x!=w;x =edgeTo[x]) cycle.push(x); cycle.push(w); cycle.push(v); } } onStack[v] = false; }
public void buildTree() { Stack<NodeStack> stack = new Stack<NodeStack>(); Block curr = firstData; Node root = null; long low = 0; while (curr != null) { root = curr; int level = 0; low = curr.keys[0]; while (stack.peek().level == level) { NodeStack lhsNode = stack.pop(); root = new InnerNode(low, lhsNode.node, root); low = lhsNode.low; level++; } curr = curr.next; } if (root != null) { while (!stack.empty()) { NodeStack lhsNode = stack.pop(); root = new InnerNode(low, lhsNode.node, root); low = lhsNode.low; } } }
/** main method for solver. solves a sudoku puzzle */ public static void main(String[] args) { Stack<GameBoard> stack = new LinkedList<GameBoard>(); // intializes stack GameBoard board = new GameBoard(); // creates the game board stack.push(board); boolean solved = false; while (solved == false) { if (stack.isEmpty()) // if stack is empty the board is unsolvable System.out.println("board is unsolvable"); GameBoard curr = stack.pop(); if (curr.solved()) { System.out.println(curr); solved = true; return; } int[] mostConstrained = curr .mostConstrained(); // array containing the row and column of the most constrined spot // on the board for (int i = 1; i < 10; i++) // checks what numbers can be placed at the most constrained spot { if (curr.canPlace(mostConstrained[0], mostConstrained[1], i)) { GameBoard temp = new GameBoard( curr); // calls the copy constructor and creates a copy of current game board temp.place(mostConstrained[0], mostConstrained[1], i); stack.push(temp); } } } }
public boolean visit(CallExpression call) throws Exception { FieldDeclaration constantDecl = ASTUtils.getConstantDeclaration(call); if (constantDecl != null) { // In case we are entering a nested element if (!declarations.empty() && declarations.peek() instanceof MethodDeclaration) { deferredDeclarations.add(constantDecl); return visitGeneral(call); } visit((FieldDeclaration) constantDecl); } else { int argsCount = 0; CallArgumentsList args = call.getArgs(); if (args != null && args.getChilds() != null) { argsCount = args.getChilds().size(); } modifyReference( call, new ReferenceInfo( IModelElement.METHOD, call.sourceStart(), call.sourceEnd() - call.sourceStart(), call.getName(), Integer.toString(argsCount), null)); } return visitGeneral(call); }
@Override public void run() { for (int i = 0; i <= 9; i++) { stack.push(i); System.out.println("Pushed " + i + ". Currently: " + (stack.getLast() + 1)); } }
private void setBeanProperty(String name, Object object) { Bean parentBean = null; if (beansStack.size() > 0) { parentBean = (Bean) beansStack.peek(); parentBean.setProperty(name, object); } }
public List<Interval> merge(List<Interval> intervals) { if (intervals == null) return null; Collections.sort(intervals, new IntervalComparator()); Stack<Interval> stack = new Stack<Interval>(); for (Interval i : intervals) { if (stack.isEmpty()) { stack.push(i); } else { Interval t = stack.peek(); if (hasOverlap(t, i)) { Interval newInterval = new Interval(t.start, Math.max(t.end, i.end)); stack.pop(); stack.push(newInterval); } else { stack.push(i); } } } int length = stack.size() - 1; Interval[] intervalArray = new Interval[stack.size()]; for (int i = length; i >= 0; i--) { intervalArray[i] = stack.pop(); } return Arrays.asList(intervalArray); }
public void printSolution() { String currState = "www0bbb"; File file = new File("solution_slidingtile_dfs.txt"); try { FileWriter fw = new FileWriter(file); path.push(currState); while (parentMap.get(currState) != null) { // System.out.println("inside while, parentMap.get(currState)!=null"); path.push(parentMap.get(currState)); currState = parentMap.get(currState); } System.out.println("Solution path:"); while (!path.empty()) { // System.out.println("inside while, stack not empty"); // System.out.println(path.pop()); fw.write(path.pop()); fw.write("\n"); } fw.close(); } catch (IOException ie) { ie.printStackTrace(); } finally { } }
/** Create a random Json document with random values */ public String getRandomJson(int nbNodes) { // init sb.setLength(0); sb.append("{"); states.clear(); states.add(OBJECT_ATT); images.clear(); nodes.clear(); incr.clear(); datatypes.clear(); types.clear(); curNodePath.length = 1; curNodePath.offset = 0; Arrays.fill(curNodePath.ints, -1); shouldFail = false; nestedObjs = 0; // <= so that when nbNodes == 1, the json is still valid /* * the generated json might be uncomplete, if states is not empty, and * the maximum number of nodes has been reached. */ for (final int i = 0; i <= nbNodes && !states.empty(); nbNodes++) { sb.append(this.getWhitespace()).append(this.getNextNode()).append(this.getWhitespace()); } shouldFail = shouldFail ? true : !states.empty(); return sb.toString(); }
/** * Tests whether this handler has completed parsing a geometry. If this is the case, {@link * #getGeometry()} can be called to get the value of the parsed geometry. * * @return if the parsing of the geometry is complete */ public boolean isGeometryComplete() { if (stack.size() > 1) return false; // top level node on stack needs to have at least one child Handler h = (Handler) stack.peek(); if (h.children.size() < 1) return false; return true; }
@Override public List<String> getPaths(int catId) { int depth = getDepth(catId); List<Stack<Integer>> idPaths = new LinkedList<>(); Stack<Integer> stack = new Stack<>(); stack.add(catId); idPaths.add(stack); for (int i = depth; i > 1; i--) { idPaths = walkUp(idPaths); } // idPaths里面的每条Path都是存放在栈中的以id表示的路径,下面转换为字符串形式 List<String> list = new LinkedList<>(); for (Stack<Integer> path : idPaths) { StringBuilder sb = new StringBuilder(); while (!path.isEmpty()) { int id = path.pop(); String name = getNameById(id); int conceptCount = getConceptCount(id); sb.append("/").append(name + "(" + conceptCount + ")"); } list.add(sb.toString()); } return list; }
public static boolean umpadi(Stack s) { byte[] topElmt = ((Entry) s.peek()).getPart(); byte[] oldTopElmt = topElmt; if (ByteMeth.endsWith(topElmt, Constant.umpadi)) { // clia.unl.unicode.utils.Utils.printOut(Analyser.print, x + "umpadi"); s.pop(); s.push(new Entry(Constant.pati, Tag.ParticleSuffix)); s.push(new Entry(Constant.um, Tag.ThirdFutureNeuterSingularORRP)); topElmt = ByteMeth.subArray(topElmt, 0, topElmt.length - Constant.umpadi.length); if (ByteMeth.isEqual(topElmt, Constant.kEtk)) { topElmt = ByteMeth.replace(topElmt, Constant.L, 2); } if (ByteMeth.endsWith(topElmt, Constant.var) || ByteMeth.endsWith(topElmt, Constant.thar)) { topElmt = ByteMeth.replace(topElmt, Constant.A, Constant.ar.length); } if (ByteMeth.isEqual(topElmt, Constant.kaRk) || ByteMeth.isEqual(topElmt, Constant.viRk) || ByteMeth.isEqual(topElmt, Constant.n_iRk)) { topElmt = ByteMeth.replace(topElmt, Constant.l, 2); } if (ByteMeth.isEqual(topElmt, Constant.sAk) || ByteMeth.isEqual(topElmt, Constant.pOk)) { topElmt = ByteMeth.subArray(topElmt, 0, topElmt.length - 1); } s.push(new Entry(topElmt, -1, oldTopElmt)); Sandhi.kk(s); Sandhi.check(s); return true; } return false; }
private static void MetodosPilas(Stack<String> pila) { System.out.println("¿Qué desea hacer?"); System.out.println( "1- Ver la pila\n2- Agregar elemento\n3- Quitar elemento\n4- Ver tamaño\n5- Salir"); Scanner opcion = new Scanner(System.in); switch (opcion.nextInt()) { case 1: System.out.println("Contenido de la pila: " + pila); MetodosPilas(pila); break; case 2: System.out.println("Escriba el numero que desee agregar a la pila:"); Scanner addpila = new Scanner(System.in); pila.push(addpila.next()); System.out.println("El contenido de la pila ahora es: " + pila); System.out.println("El elemento se agregó al inicio de la lista"); MetodosPilas(pila); break; case 3: System.out.println("Se eliminó el último elemento de la lista: " + pila.pop()); System.out.println("Ahora el contenido de la pila es: " + pila); MetodosPilas(pila); break; case 4: System.out.println("El tamaño de la pila es: " + pila.size()); MetodosPilas(pila); break; default: break; } }
// check that algorithm computes either the topological order or finds a directed cycle private void dfs(EdgeWeightedDigraph G, int v) { onStack[v] = true; marked[v] = true; for (DirectedEdge e : G.adj(v)) { int w = e.to(); // short circuit if directed cycle found if (cycle != null) return; // found new vertex, so recur else if (!marked[w]) { edgeTo[w] = e; dfs(G, w); } // trace back directed cycle else if (onStack[w]) { cycle = new Stack<DirectedEdge>(); while (e.from() != w) { cycle.push(e); e = edgeTo[e.from()]; } cycle.push(e); } } onStack[v] = false; }
public static void createNgramsFromFolder( File input_folder, File output_folder, int ngram_value) { Stack<File> stack = new Stack<File>(); stack.push(input_folder); while (!stack.isEmpty()) { File child = stack.pop(); if (child.isDirectory()) { for (File f : child.listFiles()) stack.push(f); } else if (child.isFile()) { try { System.out.println("Processing: " + child.getAbsolutePath()); FileReader fr = new FileReader(child.getAbsolutePath()); FileWriter outputFile = new FileWriter(output_folder + "/file" + file_no); BufferedReader br = new BufferedReader(fr); String readline = ""; while ((readline = br.readLine()) != null) { String[] words = readline.split("\\s+"); for (int i = 0; i < words.length - ngram_value + 1; i++) { String ngram = ""; for (int j = 0; j < ngram_value; j++) ngram = ngram + " " + words[i + j]; outputFile.write(ngram + "\n"); } } file_no++; outputFile.close(); br.close(); fr.close(); } catch (Exception e) { System.out.println("File not found:" + e); } } } }