Tempo
5 de fevereiro de 2020
tema
Ali lado: teste escrito / lado do código
duração
Uma hora
Condição prévia
Ter passado por uma entrevista por telefone e concordar com um tempo de teste escrito
de outros
Recrutamento social, exame escrito online
resultado
por
Tipo de pergunta
Problema algorítmico simultâneo muito simples
Perguntas e respostas enviadas na época
1、(JDK1.8)线程A打印a，线程B打印l，线程C打印i，三个线程交替打印，各打印102次，alialiali……
public class ThreadPrint {
private static volatile int integer = 0;
private static String[] strs = {"a", "l", "i"};
public static void main(String[] args) {
for (int i = 0; i < 3; i++) {
new Thread(new Print(strs[i], i)).start();
}
}
static class Print implements Runnable {
String content;
int order;
public Print(String content, int order) {
this.content = content;
this.order = order;
}
@Override
public void run() {
for (int i = 0; i < 102; ) {
synchronized (ThreadPrint.class) {
if (integer == order) {
System.out.print(content);
integer = (integer + 1) % strs.length;
i++;
}
}
}
}
}
}
// 使用wait notify
public class ThreadPrint2 {
private static String[] strs = {"a", "l", "i"};
private static String[] plocks = {"i", "a", "l"};
public static void main(String[] args) {
for (int i = 0; i < 3; i++) {
new Thread(new Print(strs[i], plocks[i])).start();
}
}
static class Print implements Runnable {
String content;
String plock;
public Print(String content, String plock) {
this.content = content;
this.plock = plock;
}
@Override
public void run() {
for (int i = 0; i < 102; i++) {
synchronized (plock) {
synchronized (content) {
System.out.print(content);
content.notify();
}
try {
plock.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
}
2、小b有一个计数器，其计数规则如下：
-计数从1开始，每过1秒数字+1
-第一次计数周期上限值为5，下一次计数周期上限值为上一次计数周期的两倍
-每次计数到上限值，触发计数重置，即下一个计数重新从1开始
以下是前20秒计数器上显示的数字举例：
1 2 3 4 5 1 2 3 4 5 6 7 8 9 10 1 2 3 4 5
请实现一个方法，输入第n秒，返回计数器上这个时刻的数字
举例1:
输入：1
输出：1
举例2:
输入：15
输出：10
public class Counter {
/**
* @param n 第n秒
* @return 计数器上这个时刻的数字
*/
public int count(int n) {
int limit = 5;
int count = 0;
for (int i = 0; i < n; i++) {
if (count++ == limit) {
count = 1;
limit <<= 1;
}
}
return count;
}
public static void main(String[] args) {
Counter counter = new Counter();
for (int i = 1; i < 50; i++) {
System.out.print(counter.count(i) + " ");
}
}
}Descrição do processo
O teste escrito online é muito fácil. O entrevistador enviará um link antes do horário de início. Depois de abrir a página do teste escrito, ela se parece com o bloco de código acima. Existem duas perguntas separadas, com algumas respostas em branco no meio. Use . Você pode abrir seu próprio IDE local e colá-lo após escrever. Quando eu soube que era assim, fiquei chocado, foi muito casual.
O requisito é de 1 hora. Quando estiver pronto para começar, envie uma mensagem ao entrevistador na janela de bate-papo da página para dizer ao entrevistador que você está pronto para começar e, em seguida, o entrevistador ligará e falará sobre o código escrito e as idéias de solução em 1 hora.
Claro, quando vi o teste escrito, fiquei chocado e casual. Se não fosse por uma vigilância por vídeo, eu estou me perguntando se alguém trapacearia.
Fico ainda mais surpreso quando vejo o assunto. As perguntas também são aleatórias: parecem muito simples, e os problemas que não podem ser investigados não podem ser obtidos.
Vamos falar sobre meu processo de resolução de problemas:
A primeira questão, olhe para o problema de concorrência e segurança de thread na primeira ideia da questão. Eu escrevi duas soluções acima. No início, eu queria escrever a segunda solução porque tive a impressão de ter visto um tipo de pergunta semelhante em minha mente. O constrangedor é que me lembrei e esqueci as condições de sincronização de esperar e notificar. Depois de terminar de escrever, descobri que o código que escrevi estava errado. Pensei um pouco, mas não pensei nisso. o tempo passou mais de 10 minutos. Acho que foi uma perda de tempo. Tanto tempo não vale a pena. Pensei em uma solução muito baixa, que é a primeira maneira de escrever: há 3 threads a, l e i. Quando os recursos são contestados, as condições são impressas.
Então comecei a olhar para a segunda pergunta, uma pergunta algorítmica muito simples. A pergunta foi dita muito claramente. Não sei o que dizer, então não vou dizer.
Acontece que ainda faltam 20 minutos, e então eu simplesmente olhei para os comentários de espera e notificação do código-fonte do jdk e continuei a depurar o segundo texto da primeira pergunta. A depuração estava correta e a resposta foi postada. descobriu que era menos de 1 hora., Apenas esperei um pouco. A propósito, a segunda maneira de escrever usa dois objetos de array de string, mas os literais de string que eles referenciam são a mesma variável no pool constante, então não há problema com a condição do bloco sincronizado.
Uma hora depois, o entrevistador pediu um telefonema e falou sobre suas ideias. Como havia muitas soluções, ele perguntou outra coisa. O processo de chat foi muito rápido e a prova escrita acabou.
Em seguida, receberei um e-mail para enviar as perguntas e respostas do teste escrito.
Percepção pessoal
Eu sinto que este teste escrito é sobre padrões de codificação e simultaneidade.
Felizmente, do ponto de vista do tópico, não é especificamente para problemas algorítmicos.Programação dinâmica, ganância, retrocesso, bfs, dfs, etc. tem um monte de coisas, porque eu realmente não sou bom nisso. O que é mais lamentável é que esses problemas algorítmicos realmente não surgiram. Embora eu não saiba como fazer isso, eu realmente quero tentar, haha.
ps Eu encontrei este e-mail de teste escrito quando limpei meu e-mail esta noite, e faço um registro.