Skip to content

Instantly share code, notes, and snippets.

@youthlin

youthlin/1. UTF8 转 Unicode

Last active September 3, 2016 03:08
Show Gist options
  • Star 0 You must be signed in to star a gist
  • Fork 0 You must be signed in to fork a gist
  • Save youthlin/0b86b71b0379cc85b3feabc2c1ef905d to your computer and use it in GitHub Desktop.
Save youthlin/0b86b71b0379cc85b3feabc2c1ef905d to your computer and use it in GitHub Desktop.
Download ZIP
去哪儿网2017笔试
Raw
1. UTF8 转 Unicode
import java.util.Scanner;
/* UTF8 转 Unicode */
public class A {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
String line;
while (in.hasNextLine()) {
line = in.nextLine();
String[] strs = line.split(" ");
int[] numbers = new int[strs.length];
for (int i = 0; i < strs.length; i++) {
numbers[i] = Integer.parseInt(strs[i]);
}
solve(numbers);
}
}
private static void solve(int[] numbers) {
int cur;
int aMin = 0b00000000;
int aMax = 0b01111111;
int bMin = 0b11000000;
int bMax = 0b11011111;
int cMin = 0b10000000;
int cMax = 0b10111111;
int dMin = 0b11100000;
int dMax = 0b11101111;
int eMin = 0b11110000;
int eMax = 0b11110111;
int fMin = 0b11111000;
int fMax = 0b11111011;
int gMin = 0b11111100;
int gMax = 0b11111101;
StringBuilder sb = new StringBuilder();
int len = numbers.length;
for (int i = 0; i < len; i++) {
log(Integer.toBinaryString(numbers[i]));
}
for (int i = 0; i < len; ) {
cur = numbers[i];
if (cur >= aMin && cur <= aMax) {
sb.append(cur).append(" ");
i++;
log("单字节 " + sb.toString());
continue;
}
if (cur >= bMin && cur <= bMax && i + 1 < len
&& numbers[i + 1] >= cMin && numbers[i + 1] <= cMax) {
cur = cur - bMin;
cur = cur << 6;
cur = cur + numbers[i + 1] - cMin;
cur = cur + 0x00000080;
sb.append(cur).append(" ");
i += 2;
log("双字节 " + sb.toString());
continue;
}
if (cur >= dMin && cur <= dMax && i + 2 < len
&& numbers[i + 1] >= cMin && numbers[i + 1] <= cMax
&& numbers[i + 2] >= cMin && numbers[i + 2] <= cMax) {
log(Integer.toBinaryString(cur));
cur = cur - dMin;
cur = cur << 12;
log(Integer.toBinaryString(cur));
cur = cur + ((numbers[i + 1] - cMin) << 6);
log(Integer.toBinaryString(cur));
cur = cur + (numbers[i + 2] - cMin);
sb.append(cur).append(" ");
i += 3;
log("三字节 " + sb.toString() + " " + Integer.toBinaryString(cur));
continue;
}
if (cur >= eMin && cur <= eMax && i + 3 < len
&& numbers[i + 1] >= cMin && numbers[i + 1] <= cMax
&& numbers[i + 2] >= cMin && numbers[i + 2] <= cMax
&& numbers[i + 3] >= cMin && numbers[i + 3] <= cMax) {
cur = cur - eMin;
cur = cur << 18;
cur = cur + ((numbers[i + 1] - cMin) << 12);
cur = cur + ((numbers[i + 2] - cMin) << 6);
cur = cur + ((numbers[i + 3] - cMin));
sb.append(cur).append(" ");
i += 4;
log("4字节 " + sb.toString());
continue;
}
if (cur >= fMin && cur <= fMax && i + 4 < len
&& numbers[i + 1] >= cMin && numbers[i + 1] <= cMax
&& numbers[i + 2] >= cMin && numbers[i + 2] <= cMax
&& numbers[i + 3] >= cMin && numbers[i + 3] <= cMax
&& numbers[i + 4] >= cMin && numbers[i + 4] <= cMax) {
cur = cur - fMin;
cur = cur << 24;
cur = cur + ((numbers[i + 1] - cMin) << 18);
cur = cur + ((numbers[i + 2] - cMin) << 12);
cur = cur + ((numbers[i + 3] - cMin) << 6);
cur = cur + (numbers[i + 4] - cMin);
sb.append(cur).append(" ");
i += 5;
log("5字节 " + sb.toString());
continue;
}
if (cur >= gMin && cur <= gMax && i + 5 < len
&& numbers[i + 1] >= cMin && numbers[i + 1] <= cMax
&& numbers[i + 2] >= cMin && numbers[i + 2] <= cMax
&& numbers[i + 3] >= cMin && numbers[i + 3] <= cMax
&& numbers[i + 4] >= cMin && numbers[i + 4] <= cMax
&& numbers[i + 5] >= cMin && numbers[i + 5] <= cMax) {
cur = cur - gMin;
cur = cur << 30;
cur = cur + ((numbers[i + 1] - cMin) << 24);
cur = cur + ((numbers[i + 2] - cMin) << 18);
cur = cur + ((numbers[i + 3] - cMin) << 12);
cur = cur + ((numbers[i + 4] - cMin) << 6);
cur = cur + (numbers[i + 5] - cMin);
sb.append(cur).append(" ");
i += 6;
log("6字节 " + sb.toString());
continue;
}
System.out.println("no");
return;
}
System.out.println(sb);
}
private static boolean flag = false;
private static void log(String s) {
if (flag) {
System.out.println(s);
}
}
}
Raw
2. 联通块
import java.util.HashMap;
import java.util.HashSet;
import java.util.Scanner;
import java.util.Set;
public class B {
private static HashMap<Character, Set<Character>> map = new HashMap<>(16);
static {
Set<Character> set = new HashSet<>(2);
set.add('1');
set.add('4');
map.put('0', set);
set = new HashSet<>(3);
set.add('0');
set.add('2');
set.add('5');
map.put('1', set);
set = new HashSet<>(3);
set.add('1');
set.add('3');
set.add('6');
map.put('2', set);
set = new HashSet<>(2);
set.add('2');
set.add('7');
map.put('3', set);
set = new HashSet<>(3);
set.add('0');
set.add('5');
set.add('8');
map.put('4', set);
set = new HashSet<>(4);
set.add('1');
set.add('4');
set.add('6');
set.add('9');
map.put('5', set);
set = new HashSet<>(4);
set.add('2');
set.add('5');
set.add('7');
set.add('a');
map.put('6', set);
set = new HashSet<>(3);
set.add('3');
set.add('6');
set.add('b');
map.put('7', set);
set = new HashSet<>(3);
set.add('4');
set.add('9');
set.add('c');
map.put('8', set);
set = new HashSet<>(4);
set.add('5');
set.add('8');
set.add('a');
set.add('d');
map.put('9', set);
set = new HashSet<>(4);
set.add('6');
set.add('9');
set.add('b');
set.add('e');
map.put('a', set);
set = new HashSet<>(3);
set.add('7');
set.add('a');
set.add('f');
map.put('b', set);
set = new HashSet<>(2);
set.add('8');
set.add('d');
map.put('c', set);
set = new HashSet<>(3);
set.add('9');
set.add('c');
set.add('e');
map.put('d', set);
set = new HashSet<>(3);
set.add('a');
set.add('d');
set.add('f');
map.put('e', set);
set = new HashSet<>(2);
set.add('b');
set.add('e');
map.put('f', set);
}
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
while (in.hasNextLine()) {
solve(in.nextLine());
}
}
private static void solve(String line) {
Set<Character> all = new HashSet<>();
Character first = null;
for (int i = 0; i < line.length(); i++) {
if (line.charAt(i) >= '0' && line.charAt(i) <= 'f') {
all.add(line.charAt(i));
if (first == null) first = line.charAt(i);
}
}
Set<Character> result = new HashSet<>();
result.add(first);
boolean again = true;
while (again) {
again = false;
for (Character c : all) {
if (!result.contains(c)) {
Set<Character> temp = new HashSet<>();
for (Character key : result) {
temp.addAll(map.get(key));
}
if (temp.contains(c)) {
result.add(c);
again = true;
}
}
}
}
if (result.containsAll(all)) {
System.out.println("pong");
} else {
System.out.println("pang");
}
}
}
Raw
3. 循环树（有向图）
import java.util.Scanner;
import java.util.Stack;
public class C {
private static Tree tree = new Tree();
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
while (in.hasNextLine()) {
solve(in.nextLine());
}
}
private static void solve(String line) {
Stack<Node> stack = new Stack<>();
stack.add(tree.node1);
Node cur = tree.node1;
for (int i = 0; i < line.length(); i++) {
switch (line.charAt(i)) {
case 'L':
cur = cur.left;
stack.push(cur);
break;
case 'R':
cur = cur.right;
stack.push(cur);
break;
case 'B':
if (stack.size() > 1) {
stack.pop();
cur = stack.peek();
}
break;
}
}
System.out.println(cur.v);
}
static class Node {
public int v;
public Node left;
public Node right;
}
static class Tree {
public Node node1;
public Node node2;
public Node node3;
public Node node4;
public Node node5;
public Tree() {
node1 = new Node();
node2 = new Node();
node3 = new Node();
node4 = new Node();
node5 = new Node();
node1.v = 1;
node1.left = node2;
node1.right = node3;
node2.v = 2;
node2.left = node3;
node2.right = node4;
node3.v = 3;
node3.left = node4;
node3.right = node5;
node4.v = 4;
node4.left = node5;
node4.right = node1;
node5.v = 5;
node5.left = node1;
node5.right = node2;
}
}
}
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment