private void doesEatRegime() {
if (isEnd) return;
if (Math.abs(blocks.peekFirst().getX() - regimeRectangle.getX()) < 10
&& Math.abs(blocks.peekFirst().getY() - regimeRectangle.getY()) < 10
&& System.currentTimeMillis() - currentTime <= 10000) {
regimeRectangle.setX(1200);
isRegime = false;
++score;
scoreLabel.setText(String.valueOf(score));
blocks.pollLast();
blocks.pollLast();
blocks.pollLast();
group.getChildren().remove(rectangles.peekLast());
rectangles.pollLast();
group.getChildren().remove(rectangles.peekLast());
rectangles.pollLast();
group.getChildren().remove(rectangles.peekLast());
rectangles.pollLast();
}
if (System.currentTimeMillis() - currentTime > 10000) {
regimeRectangle.setX(1200);
isRegime = false;
}
}
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;
}
private void play() {
if (isReload) reloadGame();
if (isEnd || isPause) return;
addFeed();
doesEatFeed();
addRegime();
doesEatRegime();
crossBorder();
head = blocks.peekFirst();
Block newHead = new Block(head.getX() + dx[inputDirection], head.getY() + dy[inputDirection]);
Rectangle headRect = new Rectangle(head.getX(), head.getY(), 10, 10);
if (isEnd(newHead)) {
isEnd = true;
// Image image = new Image(this.getClass().getResourceAsStream("/gameOver.png"));
// ImageView imageView = new ImageView(image);
// group.getChildren().add(imageView);
// scene.setOnKeyPressed(null);
saveRecord();
showRecord();
return;
} else {
blocks.push(newHead);
rectangles.push(headRect);
blocks.pollLast();
updateGui();
}
}
private void doesEatFeed() {
if (isEnd) return;
if (Math.abs(blocks.peekFirst().getX() - feedRectangle.getX()) < 10
&& Math.abs(blocks.peekFirst().getY() - feedRectangle.getY()) < 10) {
feedRectangle.setX(1200);
isFeed = false;
++feedCounter2;
++score;
scoreLabel.setText(String.valueOf(score));
head = blocks.peekFirst();
Block newHead = new Block(head.getX() + dx[inputDirection], head.getY() + dy[inputDirection]);
Rectangle headRect = new Rectangle(head.getX(), head.getY(), 10, 10);
blocks.push(newHead);
rectangles.push(headRect);
}
}
@Nullable
@Override
public DataNode<ProjectData> resolveProjectInfo(
@NotNull final ExternalSystemTaskId id,
@NotNull final String projectPath,
final boolean isPreviewMode,
@Nullable final GradleExecutionSettings settings,
@NotNull final ExternalSystemTaskNotificationListener listener)
throws ExternalSystemException, IllegalArgumentException, IllegalStateException {
final GradleProjectResolverExtension projectResolverChain;
if (settings != null) {
myHelper.ensureInstalledWrapper(id, projectPath, settings, listener);
List<ClassHolder<? extends GradleProjectResolverExtension>> extensionClasses =
settings.getResolverExtensions();
Deque<GradleProjectResolverExtension> extensions =
new ArrayDeque<GradleProjectResolverExtension>();
for (ClassHolder<? extends GradleProjectResolverExtension> holder : extensionClasses) {
final GradleProjectResolverExtension extension;
try {
extension = holder.getTargetClass().newInstance();
} catch (Throwable e) {
throw new IllegalArgumentException(
String.format(
"Can't instantiate project resolve extension for class '%s'",
holder.getTargetClassName()),
e);
}
final GradleProjectResolverExtension previous = extensions.peekLast();
if (previous != null) {
previous.setNext(extension);
}
extensions.add(extension);
}
projectResolverChain = extensions.peekFirst();
} else {
projectResolverChain = new BaseGradleProjectResolverExtension();
}
return myHelper.execute(
projectPath,
settings,
new Function<ProjectConnection, DataNode<ProjectData>>() {
@Override
public DataNode<ProjectData> fun(ProjectConnection connection) {
try {
return doResolveProjectInfo(
new ProjectResolverContext(
id, projectPath, settings, connection, listener, isPreviewMode),
projectResolverChain);
} catch (RuntimeException e) {
LOG.info("Gradle project resolve error", e);
throw projectResolverChain.getUserFriendlyError(e, projectPath, null);
}
}
});
}
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();
}
/**
* @param nums: A list of integers.
* @return: The maximum number inside the window at each moving.
*/
public ArrayList<Integer> maxSlidingWindow(int[] nums, int k) {
// write your code here
ArrayList<Integer> ans = new ArrayList<Integer>();
Deque<Integer> deque = new ArrayDeque<Integer>();
int i = 0;
for (int now : nums) {
i++;
while (!deque.isEmpty() && now > deque.peekLast()) {
deque.pollLast();
}
deque.offer(now);
if (i > k && deque.peekFirst() == nums[i - k - 1]) {
deque.pollFirst();
}
if (i >= k) {
ans.add(deque.peekFirst());
}
}
return ans;
}
public CommentsCollection parse(final InputStream in, final String charsetName)
throws IOException, UnsupportedEncodingException {
boolean lastWasASlashR = false;
BufferedReader br = new BufferedReader(new InputStreamReader(in, charsetName));
CommentsCollection comments = new CommentsCollection();
int r;
Deque prevTwoChars = new LinkedList<Character>(Arrays.asList('z', 'z'));
State state = State.CODE;
LineComment currentLineComment = null;
BlockComment currentBlockComment = null;
StringBuffer currentContent = null;
int currLine = 1;
int currCol = 1;
while ((r = br.read()) != -1) {
char c = (char) r;
if (c == '\r') {
lastWasASlashR = true;
} else if (c == '\n' && lastWasASlashR) {
lastWasASlashR = false;
continue;
} else {
lastWasASlashR = false;
}
switch (state) {
case CODE:
if (prevTwoChars.peekLast().equals('/') && c == '/') {
currentLineComment = new LineComment();
currentLineComment.setBeginLine(currLine);
currentLineComment.setBeginColumn(currCol - 1);
state = State.IN_LINE_COMMENT;
currentContent = new StringBuffer();
} else if (prevTwoChars.peekLast().equals('/') && c == '*') {
currentBlockComment = new BlockComment();
currentBlockComment.setBeginLine(currLine);
currentBlockComment.setBeginColumn(currCol - 1);
state = State.IN_BLOCK_COMMENT;
currentContent = new StringBuffer();
} else if (c == '"') {
state = State.IN_STRING;
} else {
// nothing to do
}
break;
case IN_LINE_COMMENT:
if (c == '\n' || c == '\r') {
currentLineComment.setContent(currentContent.toString());
currentLineComment.setEndLine(currLine);
currentLineComment.setEndColumn(currCol);
comments.addComment(currentLineComment);
state = State.CODE;
} else {
currentContent.append(c);
}
break;
case IN_BLOCK_COMMENT:
if (prevTwoChars.peekLast().equals('*')
&& c == '/'
&& !prevTwoChars.peekFirst().equals('/')) {
// delete last character
String content =
currentContent.deleteCharAt(currentContent.toString().length() - 1).toString();
if (content.startsWith("*")) {
JavadocComment javadocComment = new JavadocComment();
javadocComment.setContent(content.substring(1));
javadocComment.setBeginLine(currentBlockComment.getBeginLine());
javadocComment.setBeginColumn(currentBlockComment.getBeginColumn());
javadocComment.setEndLine(currLine);
javadocComment.setEndColumn(currCol + 1);
comments.addComment(javadocComment);
} else {
currentBlockComment.setContent(content);
currentBlockComment.setEndLine(currLine);
currentBlockComment.setEndColumn(currCol + 1);
comments.addComment(currentBlockComment);
}
state = State.CODE;
} else {
currentContent.append(c == '\r' ? '\n' : c);
}
break;
case IN_STRING:
if (!prevTwoChars.peekLast().equals('\\') && c == '"') {
state = State.CODE;
}
break;
default:
throw new RuntimeException("Unexpected");
}
switch (c) {
case '\n':
case '\r':
currLine += 1;
currCol = 1;
break;
case '\t':
currCol += COLUMNS_PER_TAB;
break;
default:
currCol += 1;
}
prevTwoChars.remove();
prevTwoChars.add(c);
}
if (state == State.IN_LINE_COMMENT) {
currentLineComment.setContent(currentContent.toString());
currentLineComment.setEndLine(currLine);
currentLineComment.setEndColumn(currCol);
comments.addComment(currentLineComment);
}
return comments;
}
