@Test
public void testIsEmpty() {
assertTrue(deque.isEmpty());
deque.addFront(3);
assertFalse(deque.isEmpty());
deque.removeFront();
assertTrue(deque.isEmpty());
}
public int[] maxSlidingWindow(int[] nums, int k) {
if (nums == null || nums.length == 0) return new int[0];
int[] result = new int[nums.length + 1 - k];
Deque<Integer> dq = new LinkedList<Integer>();
for (int i = 0, j = 1 - k; i < nums.length; i++, j++) {
if (!dq.isEmpty() && dq.peekFirst() <= i - k) dq.removeFirst();
while (!dq.isEmpty() && nums[dq.peekLast()] <= nums[i]) dq.removeLast();
dq.addLast(i);
if (j >= 0) result[j] = nums[dq.peekFirst()];
}
return result;
}
// unit testing
public static void main(String[] args) {
Deque<Integer> deq = new Deque<Integer>();
boolean res;
res = deq.isEmpty();
res = deq.isEmpty();
res = deq.isEmpty();
deq.addFirst(3);
// deq.addFirst(5);
int a = deq.removeFirst();
for (int i : deq) {
StdOut.println(i);
}
}
@Test
public void Deque_addLast_removeLast_AddsRemovesTwo() {
deque.addLast("firstString");
deque.addLast("secondString");
assertFalse(deque.isEmpty());
assertEquals(deque.size(), 2);
String returnedString = deque.removeLast();
assertEquals(returnedString, "secondString");
assertFalse(deque.isEmpty());
assertEquals(deque.size(), 1);
returnedString = deque.removeLast();
assertEquals(returnedString, "firstString");
assertTrue(deque.isEmpty());
assertEquals(deque.size(), 0);
}
public static void main(String[] args) {
Deque<Integer> ints = new Deque<Integer>();
assert ints.size() == 0;
assert ints.isEmpty();
ints.addFirst(1);
assert ints.size() == 1;
assert !ints.isEmpty();
int val = ints.removeFirst();
assert val == 1;
assert ints.size() == 0;
assert ints.isEmpty();
ints.addFirst(2);
assert ints.size() == 1;
assert !ints.isEmpty();
val = ints.removeLast();
assert val == 2;
assert ints.size() == 0;
assert ints.isEmpty();
ints.addFirst(3);
ints.addFirst(2);
ints.addFirst(1);
ints.addLast(4);
ints.addLast(5);
ints.addLast(6);
assert ints.size() == 6;
assert !ints.isEmpty();
for (int value : ints) {
StdOut.print(value + " ");
}
StdOut.println();
while (!ints.isEmpty()) {
StdOut.println(ints.removeLast());
}
assert ints.size() == 0;
assert ints.isEmpty();
for (int i = 0; i < 10; ++i) {
ints.addFirst(i);
}
for (int i = 0; i < 10; ++i) {
assert ints.size() == 10 - i;
ints.removeLast();
}
assert ints.size() == 0;
}
// Method 2: BFS Solution
public boolean validTreeII(int n, int[][] edges) {
int[] visited = new int[n];
List<List<Integer>> adjList = new ArrayList<>();
for (int i = 0; i < n; ++i) {
adjList.add(new ArrayList<Integer>());
}
for (int[] edge : edges) {
adjList.get(edge[0]).add(edge[1]);
adjList.get(edge[1]).add(edge[0]);
}
Deque<Integer> q = new LinkedList<Integer>();
q.addLast(0);
visited[0] = 1; // vertex 0 is in the queue, being visited
while (!q.isEmpty()) {
Integer cur = q.removeFirst();
for (Integer succ : adjList.get(cur)) {
if (visited[succ] == 1) {
return false;
} // loop detected
if (visited[succ] == 0) {
q.addLast(succ);
visited[succ] = 1;
}
}
visited[cur] = 2; // visit completed
}
for (int v : visited) {
if (v == 0) {
return false;
}
} // # of connected components is not 1
return true;
}
/**
* @param instanceFrame instance frame
* @return iterable over instance members of the frame, including those nested in namespaces
*/
public static Iterable<? extends INamedElement> instanceMembers(
final IInstanceFrame instanceFrame) {
final List<INamedElement> members = new ArrayList<>();
// Iterate over the member functions of the frame, including those nested in namespaces.
final Deque<INamedElement> queue = new LinkedList<>();
queue.addLast(instanceFrame);
while (!queue.isEmpty()) {
final INamedElement cur = queue.getFirst();
queue.removeFirst();
final INamedElementContainer contCur = (INamedElementContainer) cur;
for (final INamedElement member : contCur.members())
if (Ast.membership(member)
== (contCur == instanceFrame
? ScopeMembership.InstanceMember
: ScopeMembership.StaticMember)) {
members.add(member);
if (member instanceof INamedElementContainer) {
// Tail-recursively treat this nested namespace.
queue.addLast(member);
}
}
}
return members;
}
@Override
public void visitAssignmentStatement(AssignmentStatement assignmentStatement) {
LocalReference localReference = assignmentStatement.getLocalReference();
String referenceName = localReference.getName();
if (!localReference.isModuleState()) {
if (!stack.isEmpty()) {
assignmentStatement.setLocalReference(
context().referenceTableStack.peek().get(referenceName));
}
if (assignmentStatement.isDeclaring()) {
locallyDeclared(referenceName);
}
} else {
locallyDeclared(referenceName);
}
locallyAssigned(referenceName);
assignmentStatement.getExpressionStatement().accept(this);
if (assignmentStatement.getExpressionStatement() instanceof ClosureReference) {
ClosureReference closure = (ClosureReference) assignmentStatement.getExpressionStatement();
GoloFunction target = closure.getTarget();
if (target.getSyntheticParameterNames().contains(referenceName)) {
target.removeSyntheticParameter(referenceName);
target.setSyntheticSelfName(referenceName);
}
}
}
@Test
public void Deque_addLast_AddsTwo() {
deque.addLast("firstString");
deque.addLast("secondString");
assertFalse(deque.isEmpty());
assertEquals(deque.size(), 2);
}
public void performIncludes(ModuleChain inclusionPoint, Deque<DynamicObject> moduleAncestors) {
while (!moduleAncestors.isEmpty()) {
DynamicObject mod = moduleAncestors.pop();
assert RubyGuards.isRubyModule(mod);
inclusionPoint.insertAfter(mod);
Layouts.MODULE.getFields(mod).addDependent(rubyModuleObject);
}
}
/*
* stack contains all ancestors of the node, stack.peek() is its parent.
*/
private void mutateUp(@NotNull final Deque<ChildReferenceTransient> stack, MutableNode node) {
while (!stack.isEmpty()) {
final ChildReferenceTransient parent = stack.pop();
final MutableNode mutableParent = parent.mutate(this);
mutableParent.setChild(parent.firstByte, node);
node = mutableParent;
}
}
@Test
public void testIsEmpty() {
Deque<String> deque = new Deque<String>();
assertTrue(deque.isEmpty());
deque.addFirst(new String("test first"));
deque.addLast(new String("test last"));
deque.addLast(new String("test last"));
deque.addFirst(new String("test first"));
deque.addLast(new String("test last"));
assertFalse(deque.isEmpty());
deque.removeFirst();
deque.removeFirst();
deque.removeFirst();
deque.removeLast();
deque.removeLast();
assertTrue(deque.isEmpty());
}
/**
* Returns all values since last check and removes values from the queue.
*
* @return a new array with the value; never null
*/
@Override
public List<T> getValue() {
synchronized (buffer) {
if (buffer.isEmpty()) return Collections.emptyList();
return new ArrayList<T>(buffer);
}
}
private void prune() {
// Remove all values that are too old
TimeInterval periodAllowed = cachedPeriod.before(buffer.getLast().getTimestamp());
while (!buffer.isEmpty() && !periodAllowed.contains(buffer.getFirst().getTimestamp())) {
// Discard value
buffer.removeFirst();
}
}
private void definedInBlock(Set<String> references, Block block) {
if (!stack.isEmpty()) {
for (String ref : references) {
context().definingBlock.put(ref, block);
}
context().allReferences.addAll(references);
}
}
@Test
public void testAddThenRemove() {
deque.addBack(3);
assertEquals(new Integer(3), deque.removeBack());
deque.addFront(7);
assertEquals(new Integer(7), deque.removeBack());
assertTrue(deque.isEmpty());
}
private void pushBlockTable(Block block) {
if (!stack.isEmpty()) {
if (!context().referenceTableStack.isEmpty()) {
block.getReferenceTable().relink(context().referenceTableStack.peek());
}
context().referenceTableStack.push(block.getReferenceTable());
}
}
@Test
public void testAddition() {
Deque<String> deque = new Deque<String>();
deque.addFirst(new String("test"));
assertFalse(deque.isEmpty());
deque.addFirst(new String("test first"));
deque.addLast(new String("test last"));
assertEquals(deque.size(), 3);
}
private int findMaxArea(int[] height) {
if (height == null || height.length == 0) return 0;
int[] h = Arrays.copyOf(height, height.length + 1);
int maxArea = 0;
Deque<Integer> stack = new LinkedList();
int k = 0;
while (k < h.length) {
if (stack.isEmpty() || h[stack.peek()] <= h[k]) {
stack.push(k++);
} else {
int t = stack.pop();
int leftIndex = (stack.isEmpty()) ? -1 : stack.peek();
int rightIndex = k;
int tmpArea = h[t] * (rightIndex - leftIndex - 1);
maxArea = Math.max(maxArea, tmpArea);
}
}
return maxArea;
}
@Override
public void run() {
while (!myDisposed) {
boolean isEmpty;
synchronized (filesToResolve) {
isEmpty = filesToResolve.isEmpty();
}
if (enableVetoes.get() > 0
|| isEmpty
|| !resolveProcess.isDone()
|| HeavyProcessLatch.INSTANCE.isRunning()
|| PsiDocumentManager.getInstance(myProject).hasUncommitedDocuments()) {
try {
waitForQueue();
} catch (InterruptedException e) {
break;
}
continue;
}
final Set<VirtualFile> files = pollFilesToResolve();
if (files.isEmpty()) continue;
upToDate = false;
myApplication.invokeLater(
() -> {
if (!resolveProcess.isDone()) return;
log("Started to resolve " + files.size() + " files");
Task.Backgroundable backgroundable =
new Task.Backgroundable(myProject, "Resolving files...", false) {
@Override
public void run(@NotNull final ProgressIndicator indicator) {
if (!myApplication.isDisposed()) {
processBatch(indicator, files);
}
}
};
ProgressIndicator indicator;
if (files.size() > 1) {
// show progress
indicator = new BackgroundableProcessIndicator(backgroundable);
} else {
indicator = new MyProgress();
}
resolveProcess =
((ProgressManagerImpl) ProgressManager.getInstance())
.runProcessWithProgressAsynchronously(backgroundable, indicator, null);
},
myProject.getDisposed());
flushLog();
}
}
@Override
public boolean add(@NotNull final ByteIterable key, @NotNull final ByteIterable value) {
final ByteIterator it = key.iterator();
NodeBase node = root;
MutableNode mutableNode = null;
final Deque<ChildReferenceTransient> stack = new ArrayDeque<>();
while (true) {
final NodeBase.MatchResult matchResult = node.matchesKeySequence(it);
final int matchingLength = matchResult.matchingLength;
if (matchingLength < 0) {
final MutableNode prefix =
node.getMutableCopy(this).splitKey(-matchingLength - 1, matchResult.keyByte);
if (matchResult.hasNext) {
prefix.hang(matchResult.nextByte, it).setValue(value);
} else {
prefix.setValue(value);
}
if (stack.isEmpty()) {
root = new MutableRoot(prefix, root.sourceAddress);
} else {
final ChildReferenceTransient parent = stack.pop();
mutableNode = parent.mutate(this);
mutableNode.setChild(parent.firstByte, prefix);
}
break;
}
if (!it.hasNext()) {
if (node.hasValue()) {
return false;
}
mutableNode = node.getMutableCopy(this);
mutableNode.setValue(value);
break;
}
final byte nextByte = it.next();
final NodeBase child = node.getChild(this, nextByte);
if (child == null) {
mutableNode = node.getMutableCopy(this);
if (mutableNode.hasChildren() || mutableNode.hasKey() || mutableNode.hasValue()) {
mutableNode.hang(nextByte, it).setValue(value);
} else {
mutableNode.setKeySequence(new ArrayByteIterable(nextByte, it));
mutableNode.setValue(value);
}
break;
}
stack.push(new ChildReferenceTransient(nextByte, node));
node = child;
}
++size;
mutateUp(stack, mutableNode);
TreeCursorMutable.notifyCursors(this);
return true;
}
public static boolean bfsIterative(TreeNode root, int val) {
Deque<TreeNode> s = new LinkedList<>();
s.push(root);
while (!s.isEmpty()) {
TreeNode curr = s.removeFirst();
if (curr.left != null) s.addLast(curr.left);
if (curr.right != null) s.addLast(curr.right);
if (curr.value == val) return true;
}
return false;
}
public int pop() {
stack.pollLast();
size--;
if (stack.isEmpty()) {
// System.out.println("EMPTY");
return 0;
}
int result = stack.peekLast();
return result;
}
private void reverseChangeLog() throws InvalidOperationException {
Deque<Operation> operations = new LinkedList<>(this.changeLog);
while (!operations.isEmpty()) {
Operation operation = operations.pop();
if (!TokenHook.TokenType.Word.equals(operation.tokenType)) {
Operation inverse = operation.getInverse();
Collection<Operation> c = new LinkedList<>();
c.add(inverse);
this.applyOperations(c, false);
}
}
}
// 检测是否合法:合法 0,不合法 -1
public int checkValid(String s) {
Deque<Integer> q = new ArrayDeque<>();
for (int i = 0; i < s.length(); i++) {
char c = s.charAt(i);
switch (c) {
case '(':
q.push(i);
break;
case ')':
if (q.isEmpty()) {
return -1;
} else {
q.pop();
}
break;
default:
break;
}
}
return q.isEmpty() ? 0 : -1;
}
public int[] maxSlidingWindow(int[] nums, int k) {
if (nums == null || k <= 0) return new int[0];
Deque<Integer> deque = new ArrayDeque<Integer>();
int n = nums.length;
int[] r = new int[n - k + 1];
int ri = 0;
for (int i = 0; i < n; i++) {
while (!deque.isEmpty() && deque.peek() < i - k + 1) {
deque.poll();
}
while (!deque.isEmpty() && nums[i] > nums[deque.peekLast()]) {
deque.pollLast();
}
deque.offer(i);
if (i >= k - 1) r[ri++] = nums[deque.peek()];
}
return r;
}
public String removeDuplicateLetters(String s) {
Deque<Character> stack = new LinkedList<>();
Map<Character, Integer> count = new HashMap<>();
for (int i = 0; i < s.length(); i++) {
count.compute(
s.charAt(i),
(key, val) -> {
if (val == null) {
return 1;
} else {
return val + 1;
}
});
}
Set<Character> visited = new HashSet<>();
for (int i = 0; i < s.length(); i++) {
char ch = s.charAt(i);
count.put(ch, count.get(ch) - 1);
if (visited.contains(ch)) {
continue;
}
while (!stack.isEmpty() && stack.peekFirst() > ch && count.get(stack.peekFirst()) > 0) {
visited.remove(stack.peekFirst());
stack.pollFirst();
}
stack.offerFirst(ch);
visited.add(ch);
}
StringBuffer buff = new StringBuffer();
while (!stack.isEmpty()) {
buff.append(stack.pollLast());
}
return buff.toString();
}
/**
* Runs the server. The server will wait for some match info (which specifies the teams and set of
* maps to run) and then begin running matches.
*/
public void run() {
int aWins = 0, bWins = 0;
while (!matches.isEmpty()) {
Match match = matches.peek();
if (!finished.isEmpty())
match.setInitialTeamMemory(finished.getLast().getComputedTeamMemory());
try {
debug("running match " + match);
match.initialize();
runMatch(match, proxyWriter);
finished.add(match);
matches.remove(match);
if (match.getWinner() == Team.A) aWins++;
else if (match.getWinner() == Team.B) bWins++;
match.finish();
// Allow best of three scrimmages -- single game scrims should still work fine
// TODO:This "win mode" should probably be something from the database
if (mode == Mode.TOURNAMENT || mode == Mode.SCRIMMAGE) {
if (aWins == 2 || bWins == 2) break;
}
} catch (Exception e) {
ErrorReporter.report(e);
error("couldn't run match: ");
this.state = State.ERROR;
}
}
proxyWriter.terminate();
}
private List<List<Integer>> help1(TreeNode root) {
List<List<Integer>> res = new ArrayList<List<Integer>>();
if (root == null) {
return res;
}
Deque<TreeNode> current = new LinkedList<>();
Deque<TreeNode> next = new LinkedList<>();
boolean isOdd = true;
current.add(root);
while (!current.isEmpty()) {
int size = current.size();
List<Integer> level = new LinkedList<Integer>();
if (isOdd) {
for (int i = 0; i < size; i++) {
TreeNode top = current.removeFirst();
level.add(top.val);
if (top.left != null) {
next.addLast(top.left);
}
if (top.right != null) {
next.addLast(top.right);
}
}
} else {
for (int i = 0; i < size; i++) {
TreeNode top = current.removeLast();
level.add(top.val);
if (top.right != null) {
next.addFirst(top.right);
}
if (top.left != null) {
next.addFirst(top.left);
}
}
}
isOdd = !isOdd;
current = next;
res.add(level);
}
return res;
}
@Override
protected AFCalculationResult computeLog10PNonRef(
final VariantContext vc,
final int defaultPloidy,
final double[] log10AlleleFrequencyPriors,
final StateTracker stateTracker) {
Utils.nonNull(vc, "vc is null");
Utils.nonNull(log10AlleleFrequencyPriors, "log10AlleleFrequencyPriors is null");
Utils.nonNull(stateTracker, "stateTracker is null");
final int numAlternateAlleles = vc.getNAlleles() - 1;
final List<double[]> genotypeLikelihoods = getGLs(vc.getGenotypes(), true);
final int numSamples = genotypeLikelihoods.size() - 1;
final int numChr = 2 * numSamples;
// queue of AC conformations to process
final Deque<ExactACset> ACqueue = new LinkedList<>();
// mapping of ExactACset indexes to the objects
final Map<ExactACcounts, ExactACset> indexesToACset = new HashMap<>(numChr + 1);
// add AC=0 to the queue
final int[] zeroCounts = new int[numAlternateAlleles];
final ExactACset zeroSet = new ExactACset(numSamples + 1, new ExactACcounts(zeroCounts));
ACqueue.add(zeroSet);
indexesToACset.put(zeroSet.getACcounts(), zeroSet);
while (!ACqueue.isEmpty()) {
// compute log10Likelihoods
final ExactACset set = ACqueue.remove();
calculateAlleleCountConformation(
set,
genotypeLikelihoods,
numChr,
ACqueue,
indexesToACset,
log10AlleleFrequencyPriors,
stateTracker);
// clean up memory
indexesToACset.remove(set.getACcounts());
}
return getResultFromFinalState(vc, log10AlleleFrequencyPriors, stateTracker);
}
