Développement Java
  1. Développement Java
  3. Dans quelle mesure cette question d’entrevue est-elle claire?
Intereting Posts
Lambdas dans l’exemple classique Operation enum Calculer la consommation d’énergie du capteur Android Solution évolutive pour Rock-Paper-Scissor La même instance CriteriaBuilder (JPA 2) peut-elle être utilisée pour créer plusieurs requêtes? Une collection d’une classe abstraite (ou quelque chose comme ça…) Android, Blur Bitmap instantanément? Trier la carte par valeur en utilisant des lambdas et des stream Réorganiser les quatre points d’un rectangle dans le bon ordre Common Lisp a-t-il quelque chose comme Set Interface / Java pour les classes d’implémentation? Analyse des données JSON nestedes à l’aide de GSON Cookies de session et Internet Explorer 8 Vérifiez si l’appareil Android prend en charge la vidéo 4K? Comment démarrer un fil après un délai spécifié en java Comment savoir si les coordonnées X et Y sont à l’intérieur de mon bouton? Java, définir la valeur du champ avec reflection

Dans quelle mesure cette question d’entrevue est-elle claire?

Nous interviewons pour un rôle de développement Java senior et les trois personnes à qui nous avons demandé de répondre à cette question nous ont donné la même réponse incorrecte. La question avait été posée avant l’entrevue, ils avaient donc beaucoup de temps. Leurs solutions semblaient sortinger les entrées par parentId puis childId au lieu de créer un arbre et à partir de l’entrée puis de le parcourir pour trouver le bon ordre. La question n’est-elle pas assez claire?

Question:

Vous trouverez ci-dessous un test de compétences et de présentation simple pour le rôle Développeur Java, qui doit être effectué avant l’entretien téléphonique.

CHAMPS OBLIGATOIRES:

  1. JUnit Test

  2. Implémentation de l’interface NodeSorter

QUESTION:

Nous avons un object Java qui ressemble à ceci: 

public class Node { public int id; public Integer parentId; public Node(int id, Integer parentId) { this.id = id; this.parentId = parentId; } }

Par exemple, la liste suivante de nœuds peut être affichée graphiquement sous la forme:

Node (id: 1, parentId: null), nœud (id: 2, parentId: 1), nœud (id: 3, parentId: 1), nœud (id: 4, parentId: 2), nœud (id: 5, parentId: 3) 

  Node (id: 1) / \ / \ / \ / \ Node (id: 2) Node (id : 3) / \ / \ / \ / \ Node (id: 4) Node (id : 5)

Hypothèses:

  1. Il y aura toujours au moins un nœud

  2. Il y aura un et un seul nœud avec un parentId null

  3. Chaque nœud aura un parentId valide, à l’exception du nœud qui a un parentId nul

Exigences:

  1. Ecrivez une classe qui implémente l’interface suivante qui recevra une liste de nœuds et les classer de haut en bas (les nœuds les plus haut dans l’arborescence doivent se situer avant les nœuds les plus bas dans l’arborescence. Par exemple, le nœud 1 en haut l’arbre doit se situer avant le noeud 4 qui se trouve au bas de l’arbre). Les nœuds du même niveau seront dans l’ordre de leur id. Le nœud avec id = 2 apparaîtra avant le nœud avec id = 3 dans le diagramme ci-dessus.

Interface: 

  public interface NodeSorter { public List sort(List unSortedNodes); }

Données de test:

Cas de test 1:

Diagramme d’entrée: 

  Node (id: 1) / \ / \ / \ / \ Node (id: 2) Node (id : 3) / \ / \ / \ / \ Node (id: 4) Node (id : 5)

Entrée: nœud (id: 2, parentId: 1), nœud (id: 4, parentId: 2), nœud (id: 1, parentId: null), nœud (id: 3, parentId: 1), nœud (id: 5, parentId: 3)

Sortie: Noeud (id: 1, parentId: null), Noeud (id: 2, parentId: 1), Node (id: 3, parentId: 1), Node (4: parentId: 2), Noeud (id: 3) 5, parentId: 3)

Cas de test 2:

Diagramme d’entrée: 

  Node (id: 1) / \ / \ / \ / \ Node (id: 5) Node (id : 2) / \ / \ / \ / \ Node (id: 4) Node (id : 3)

Entrée: nœud (id: 5, parentId: 1), nœud (id: 4, parentId: 5), nœud (id: 1, parentId: null), nœud (id: 3, parentId: 2), nœud (id: 2, parentId: 1)

Sortie: Noeud (id: 1, parentId: null), Noeud (id: 2, parentId: 1), Node (id: 5, parentId: 1), Node (id: 3, parentId: 2), Node (id: 4, parentId: 5)

Je dirais que cela n’est guère douteux. Vous voulez une liste d’entrée non sortingée et une liste sortingée en sortie.

Chaque élément de la liste de sortie est un nœud d’arbre, mais aucun solde n’est imposé sur l’arbre. L’utilisateur ne pourrait-il pas simplement lire les valeurs de tous les nœuds, les sortinger, puis parcourir les valeurs sortingées pour créer de nouveaux nœuds, chacun d’entre eux pointant sur le nœud précédent, et ce, pour l’essentiel … ils ont créé une arbre fortement déséquilibré (pas de twigs), mais qui s’en soucie?

Cela me semble correct, mais si j’interviewais, je ne serais pas très heureux de cette réponse, car je me demanderais pourquoi l’arbre était là.

Rien dans cette question ne m’indique que je devrais faire quelque chose comme ce que vous suggérez: “créer un arbre et à partir de l’entrée, puis parcourir l’arbre pour trouver le bon ordre”.

Honnêtement, la question me semble assez claire.

Avez-vous essayé de leur demander pourquoi ils avaient choisi de sortinger par ID de liste, puis par ID de nœud? Pensaient-ils que cela résolvait le problème? Si tel est le cas, quelle est leur réaction face à un intrant pour lequel cela ne fonctionne pas?

Même s’ils n’ont pas répondu correctement à la question, en leur posant ces questions, vous pouvez en apprendre davantage à leur sujet et comprendre ce qui, dans votre question, n’est pas assez clair.

Pourquoi ne pas mettre à jour les cas de test pour append des tests qui échoueraient compte tenu des solutions incorrectes fournies?

Il semble que ce serait un moyen évident de clarifier la question. Et puis, s’ils ne comprennent toujours pas la question ou ne la trouvent pas claire étant donné la question / les cas de test, ils peuvent demander des informations supplémentaires avant de compléter leur solution.

Il me semble que vous leur demandez essentiellement de sortinger une liste en fonction de deux facteurs: l’ID parent, puis l’ID de la liste. Si tel est le cas, vous pouvez simplement simplifier la question sans vous soucier de l’idée “d’arborescence” et leur demander d’écrire une sorte pour une liste basée sur deux facteurs.

La question est claire dans l’entrée / sortie.

La structure de données ou l’algorithme à utiliser dans la mise en œuvre n’est pas spécifié. Par conséquent, vous pouvez en utiliser (ce qui est bien).

Si le code résultant donne la sortie attendue, il est correct, même s’il n’utilise pas d’arborescence (car elle ne figurait pas dans la spécification), si la sortie est incorrecte, la solution est fausse, même s’ils utilisent une arborescence.

Je pense que la question elle-même est assez claire, mais le choix des données dans vos cas de test pousse les gens à essayer une solution incorrecte (sorting par parentid). C’était peut-être délibéré?

Si vous souhaitez augmenter la probabilité que les répondants obtiennent la réponse correcte, vous pouvez inclure un scénario de test démontrant que les identifiants parent peuvent être plus volumineux que les identifiants enfants.

Cependant, je ne suis pas sûr que cela améliorerait la qualité de l’interview: il semble que la question telle qu’elle est écrite présente l’avantage de tester la capacité de quelqu’un à proposer une solution qui corresponde à tous les cas et pas seulement aux échantillons fournis.

Vous pouvez leur demander de sortir les nœuds dans un ordre de niveau de pré-ordre , afin que la question soit parfaitement claire.

Avez-vous donné des exemples d’entrées et de sorties aux personnes interrogées, comme vous l’avez fait dans la publication? Si vous donnez simplement les règles sans exemple, je pense que quelqu’un pourrait être pardonné pour un malentendu.

Personnellement, je pense que c’est une bonne question. C’est assez simple pour que vous ne demandiez pas au demandeur de passer des jours à travailler dessus, le résultat est clair, bien défini et correct, et une solution correcte indique comment savoir manipuler les structures de données, ce qui est assez fondamental pour un bon développeur. Et je vois que vous avez dit que vous avez demandé aux candidats de le faire avant l’entretien téléphonique, ce qui, je suppose, signifie le faire à la maison, afin qu’ils ne soient pas assis dans une pièce avec un entretien les fixant pendant qu’ils se débattent et subissent ainsi une pression artificielle. .

Le seul défaut réel que je vois est qu’il n’est pas clair pour moi ce qu’il en est. Vous dites que l’entrée est une liste de noeuds, apparemment des objects de noeuds, mais comment le programmeur peut-il être assuré que cette liste de noeuds forme réellement un arbre? Est-il supposé supposer simplement que toutes les entrées sont valables? Ou est-il supposé le valider? Je pense que vous feriez mieux de dire que la fonction doit accepter le nœud racine d’un arbre, puis découvrir quels nœuds existent par parcours, plutôt que de créer le double problème de fournir la liste et d’obliger le programmeur à le comprendre.

C’est beaucoup mieux que la plupart des questions d’entrevue que j’ai eues dans ma vie, qui sont généralement des questions telles que “Combien d’années d’expérience avez-vous avec …”, “Quelle est votre plus grande faute en tant qu’employé?” et “Avez-vous déjà utilisé la version 3.9.7.6 de Foobar? Oh, vous n’avez utilisé que la version 3.9.7.5. Désolé, nous utilisons la version 3.9.7.6 ici.”

Mon seul petit reproche est: Qu’est-ce que cette question a à voir avec les tests JUnit? Vous commencez par dire que cela concerne les tests JUnit mais je ne vois pas du tout en quoi cela se rapporte.

La question est claire . Vous demandez alors BFS de l’arbre.

C’est une question intéressante pour examiner 1) les capacités d’abstraction; 2) ordre et style en programmation 3) attention à l’ordre des algorithmes (le big-O).

Ma réponse à tout cela “combien de fois faites-vous cela dans votre travail” commente est:

  • cette question a pour but d’évaluer:
    • la capacité d’abstraction
    • le fond de la théorie
    • utilisation de structures de données et d’algorithmes

Si vous pouvez le faire, alors vous n’êtes pas un simple programmeur de firebase database orienté systèmes .