Prefacio:
Cerca del Día Nacional, mis amigos en un pequeño círculo del grupo de WeChat publicaron una foto del código de preguntas de la entrevista que supera los bytes que circulaba en Internet. Lo pensé cuando no tenía nada que hacer. No fue difícil de encontrar, se trataba de lo básico. Consideración del conocimiento matemático. ¡Toma la foto primero!
Por supuesto, no puedo codificar dos preguntas en 40 minutos. Solo conozco la idea general de resolver el problema. Lo único de lo que puedo estar seguro es que puedo codificar la segunda pregunta en 20 minutos dentro del tiempo especificado de la entrevista.
Tema
Tema uno
El conocimiento básico es el plano del sistema de coordenadas cartesianas de la escuela secundaria, ideas analíticas:
- Calcule la circunferencia total;
- Calcule y encapsule las coordenadas frontal y posterior de la longitud de cada lado y utilícelo en el cuarto paso;
- Calcule la longitud media del segmento de acuerdo con el valor del segmento K;
- Luego, haz un bucle K veces y calcula las coordenadas de los puntos de bisección de acuerdo con la longitud promedio.
No hay mucho que decir, el código:
Primero defina la clase de coordenadas Point
class Point {
float x;
float y;
public Point() {
}
public Point(float x, float y) {
this.x = x;
this.y = y;
}
public Point(Point point) {
this(point.x, point.y);
}
@Override
public String toString() {
return "Point, x：" + x + " y：" + y;
}
}
N边形的边封装类
class Line {
Point begin;
Point end;
float length;
public Line() {
}
public Line(Point begin, Point end, float length) {
this.begin = begin;
this.end = end;
this.length = length;
}
}
Clases que implementan cálculos ahora
En la primera versión de este código, cuando el cuadrado se dividió en números pares, el cálculo del punto de coordenadas no era exacto. Esta noche, miré el código durante 10 minutos y lo cambié ligeramente. No existe tal error temporalmente. ¡Esperamos descubrir otros errores y corregirlos!
public class Polygon {
/**
* 计算边的长度
*
* @return
*/
private static float lineLength(Point a, Point b) {
float length;
if (a.x == b.x) {
// 垂直线条
length = Math.abs(a.y - b.y);
} else {
length = Math.abs(a.x - b.x);
}
return length;
}
/**
* 计算 周长
*
* @return
*/
private static float totalSideLength(Point[] points, Line[] lines) {
float side = 0;
for (int i = 1; i < points.length; i++) {
Point prev = points[i - 1];
Point point = points[i];
float length = lineLength(prev, point);
side += length;
lines[i - 1] = new Line(prev, point, length);
if (i == points.length - 1) {
length = lineLength(point, points[0]);
side += length;
lines[i] = new Line(point, points[0], length);
}
}
return side;
}
public static Point[] division(Point[] points, int divisionNum) {
Point[] divisionPoint = new Point[divisionNum];
// 计算周长
Line[] lines = new Line[points.length];
float side = totalSideLength(points, lines);
// 等分长度
float divisionLength = side / divisionNum;
int lineIndex = -1;
float sumLength = 0;
for (int i = 0; i < divisionNum; i++) {
if (i == 0) {
// 第一个等分点直接是起始点坐标
divisionPoint[i] = new Point(points[0]);
continue;
}
divisionPoint[i] = new Point();
float lineLength = divisionLength * i;
while (true) {
Line line;
if (sumLength < lineLength) {
lineIndex++;
line = lines[lineIndex];
sumLength += line.length;
} else
line = lines[lineIndex];
if (sumLength >= lineLength) {
float temp = sumLength - lineLength;
if (line.begin.x == line.end.x) {
// begin和end的坐标点垂直
divisionPoint[i].x = line.begin.x;
if (line.end.y > line.begin.y)
divisionPoint[i].y = line.end.y - temp;
else
divisionPoint[i].y = line.end.y + temp;
} else {
// begin和end的坐标点水平
divisionPoint[i].y = line.end.y;
if (line.end.x > line.begin.x)
divisionPoint[i].x = line.end.x - temp;
else
divisionPoint[i].x = line.end.x + temp;
}
break;
}
}
}
return divisionPoint;
}
private static void print(Point[] points) {
for (int i = 0; i < points.length; i++) {
System.out.println("第" + (i + 1) + "等分点, x：" + points[i].x + "，y：" + points[i].y);
}
}
public static void main(String[] args) {
Point[] points = new Point[] {
new Point(0, 0), new Point(0, 1), new Point(1, 1), new Point(1, 0) };
Point[] divPoints = division(points, 8);
print(divPoints);
}
}
Tema dos
Ideas de resolución de problemas:
La suma de los dígitos correspondientes nunca excederá de 18. Por lo tanto, primero calculamos la suma de las posiciones correspondientes, y luego repetidamente recorremos para encontrar el número mayor que 9, y lo llevamos al dígito más alto.
Esto es relativamente simple, solo examine el detalle de que la suma de números enteros positivos de un solo dígito nunca es mayor que 18.
En el código:
public class LinkAddition {
static class NumNode {
public int num;
public NumNode next;
public NumNode() {
}
public NumNode(int num) {
this.num = num;
};
public NumNode(int num, NumNode next) {
this(num);
this.next = next;
}
}
private static int length(NumNode num) {
int length = 0;
NumNode temp = num;
while (temp != null) {
length++;
temp = temp.next;
}
return length;
}
private static NumNode calc(NumNode a, NumNode b, int aLength, int bLength) {
NumNode aNode = a;
NumNode bNode = b;
NumNode result = new NumNode();
NumNode resultNode = result;
// 计算b链表再a中的起始索引
int aStartIndex = aLength - bLength;
for (int i = 0; i < aLength; i++) {
if (i >= aStartIndex) {
resultNode.num = aNode.num + bNode.num;
bNode = bNode.next;
} else
resultNode.num = aNode.num;
aNode = aNode.next;
if (aNode != null) {
resultNode.next = new NumNode();
resultNode = resultNode.next;
}
}
return result;
}
public static NumNode addition(NumNode a, NumNode b) {
NumNode result = null;
// 计算位数
int aLength = length(a);
int bLength = length(b);
if (aLength > bLength) {
result = calc(a, b, aLength, bLength);
} else {
result = calc(b, a, bLength, aLength);
}
boolean isGreater9 = true;
while (isGreater9) {
isGreater9 = false;
NumNode node = result;
while (node != null) {
// 检查是否有大于9的节点
if (node.num > 9) {
isGreater9 = true;
break;
}
node = node.next;
}
// 没有大于9且需要进位的节点
if (!isGreater9)
break;
node = result;
if (node.num > 9) {
// 头节点的内容跟大于9，需要进位
result = new NumNode(1, node);
node.num = node.num - 10;
}
while (node.next != null) {
if (node.next.num > 9) {
node.num += 1;
node.next.num = node.next.num - 10;
}
node = node.next;
}
}
return result;
}
private static void print(NumNode num) {
NumNode node = num;
while (node != null) {
System.out.print(node.num);
node = node.next;
}
}
public static void main(String[] args) {
NumNode a = new NumNode(9);
a.next = new NumNode(9, new NumNode(9));
NumNode b = new NumNode(9);
// b.next = new NumNode(9, new NumNode(9));
NumNode result = addition(a, b);
print(result);
}
}
Tema tres
La primera versión que escribí solo se ajusta al ejemplo de la clase, y luego la anulé en un instante. Finalmente, me senté y pensé en la clase durante 10 minutos y la analicé como una matriz bidimensional.
Encuentre primero el punto más alto y luego use el punto más alto como una dimensión para calcular la cantidad de agua en un ciclo. Agreguemos el código:
public class Water {
public static int waterNum(int[] steps) {
int waterNum = 0;
int max = steps[0];
for (int i = 1; i < steps.length; i++) {
if (max < steps[i])
max = steps[i];
}
for (int i = 0; i < max; i++) {
int num = 0, index = 0;
for (int n = 0; n < steps.length; n++) {
if (steps[n] - i > 0) {
if (num > 0) {
waterNum += n - index - 1;
}
num = steps[n] - i;
index = n;
}
}
}
return waterNum;
}
public static void main(String[] args) {
int[] steps = new int[] {
0, 1, 0, 2, 1, 0, 1, 3, 2, 1, 2, 3, 0, 1 };
int water = waterNum(steps);
System.out.println(water);
}
}
para resumir:
De hecho, los puntos de conocimiento de estas preguntas no son difíciles, todos se usan en tiempos ordinarios, depende de cómo convertirlos en código.
La primera pregunta examina cómo calcular la longitud del lado en el sistema de coordenadas rectangulares y luego caminar desde el primer lado para calcular las coordenadas correspondientes de acuerdo con la longitud igual. Este punto de conocimiento se aprendió en la escuela secundaria.
La segunda pregunta es investigar el número máximo de sumas enteras positivas en cada bit. Siempre que comprenda este punto, después de sumar cada bit, puede realizar un proceso de acarreo unificado.
La cantidad de código para la tercera pregunta es la mínima Mi idea de resolver el problema es una matriz de dos dígitos, que no es demasiado difícil.
Recientemente, es el mejor momento para encontrar un trabajo. He recopilado algunas preguntas de entrevistas de los principales fabricantes y los datos más recientes de este año (2020). A continuación, se muestran algunas capturas de pantalla de los datos (todos los datos se han integrado en los documentos y en formato PDF comprimido y empaquetado) .
Si tiene un amigo que lo necesita, puede hacer clic aquí para obtener información, código: qf
