temps
5 février 2020
thème
Côté Ali: côté test / code écrit
durée
Une heure
Condition préalable
Avoir passé un entretien téléphonique et se mettre d'accord sur une heure de test écrite
autre
Recrutement social, examen écrit en ligne
résultat
par
Type de question
Problème algorithmique simultané très simple
Questions et réponses soumises à l'époque
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) + " ");
}
}
}Description du processus
Le test écrit en ligne est très simple. L'enquêteur enverra un lien avant l'heure de commencer. Après avoir ouvert la page du test écrit, elle ressemble au bloc de code ci-dessus. Il y a deux questions distinctes, avec des réponses vierges au milieu. Utilisez . Vous pouvez ouvrir votre propre IDE local et le coller après l'écriture. Quand j'ai su que c'était comme ça, j'étais abasourdi, c'était vraiment décontracté.
La condition requise est d'une heure. Lorsque vous êtes prêt à commencer, envoyez un message à l'intervieweur dans la fenêtre de discussion sur la page pour lui dire que vous êtes prêt à commencer, puis l'intervieweur appellera et parlera du code écrit et les idées de solution en 1 heure.
Bien sûr, quand j'ai vu le test écrit, j'ai été choqué et désinvolte. S'il n'y avait pas de vidéosurveillance, je me demande tous si quelqu'un tricherait.
Je suis encore plus abasourdi quand je vois le sujet. Les questions sont également aléatoires: elles semblent vraiment simples et les problèmes qui ne peuvent pas être étudiés ne peuvent pas être résolus.
Parlons de mon processus de résolution de problèmes:
La première question, regardez le problème de la concurrence et de la sécurité des threads dans la première idée de la question. J'ai écrit deux solutions ci-dessus.Au début, je voulais écrire la deuxième solution parce que j'avais l'impression d'avoir vu un type de question similaire dans mon esprit. Ce qui est embarrassant, c'est que j'ai eu l'esprit et j'ai oublié les conditions de synchronisation d'attente et de notification. Après avoir fini d'écrire, j'ai trouvé que le code que j'avais écrit était erroné. J'ai réfléchi pendant un moment, mais je n'y ai pas pensé. le temps s'est écoulé plus de 10 minutes. Je pense que c'était une perte de question. Tant de temps n'en vaut pas la peine. J'ai pensé à une solution très faible, qui est la première façon d'écrire: il y a 3 threads a, l et i. Lorsque les ressources sont disputées, les conditions sont imprimées.
Puis j'ai commencé à regarder la deuxième question, une question algorithmique très simple. La question a été posée très clairement. Je ne sais pas quoi dire, donc je ne le dirai pas.
Il s'avère qu'il reste encore 20 minutes, puis j'ai simplement regardé les commentaires du code source d'attente et de notification du jdk, et j'ai continué à déboguer le deuxième libellé de la première question. Le débogage était correct et la réponse a été publiée. C'était trouvé que c'était moins d'une heure., Juste attendu un moment. À propos, la deuxième façon d'écrire utilise deux objets de tableau de chaînes, mais les littéraux de chaîne auxquels ils font référence sont la même variable dans le pool de constantes, il n'y a donc aucun problème avec la condition du bloc synchronisé.
Une heure plus tard, l'intervieweur a demandé un coup de fil et a parlé de ses idées. Parce qu'il y avait beaucoup de solutions, il a demandé autre chose. Le processus de discussion était très rapide et le test écrit était terminé.
Ensuite, je recevrai un e-mail pour envoyer les questions et réponses du test écrit.
Perception personnelle
Je pense que ce test écrit concerne les normes de codage et la concurrence.
Heureusement, du point de vue du sujet, ce n'est pas spécifiquement pour les problèmes algorithmiques.La programmation dynamique, gourmande, backtracking, bfs, dfs, etc. a beaucoup de choses, car je ne suis vraiment pas douée pour ces derniers. Ce qui est plus regrettable, c'est que ces problèmes algorithmiques ne se sont pas posés, même si je ne sais pas comment faire, je veux vraiment essayer, haha.
ps J'ai trouvé cet e-mail de test écrit lorsque j'ai effacé mon e-mail ce soir et que j'ai fait un enregistrement.