Pouvez-vous relever des défis de codage en utilisant le low-code ? Bien sûr ! Mais pourquoi ?

Lors de la candidature à un poste d'ingénieur logiciel, la tendance actuelle en matière de préparation est de relever des défis « LeetCode ». LeetCode est un site composé de problèmes spécialement conçus pour préparer les ingénieurs logiciels aux éventuelles questions d'entretien. Il existe actuellement plus de deux mille défis disponibles, tous conçus pour tester les connaissances d'un candidat en matière d'efficacité, de modèles et de résolution de problèmes.

Nous avons donc ici un site complet rempli de défis de codage spécialement conçus pour tester les compétences de codage dans plusieurs langages. Ayant fait mes preuves en C# et JavaScript, je pourrais facilement essayer de résoudre ces problèmes en utilisant l'un de ces langages, mais ce n'est plus ce que je fais. Je suis désormais un évangéliste du low-code. Je devrais sûrement essayer de résoudre ces problèmes en low-code ?

Certes, le low-code n'est pas spécifiquement conçu pour ce genre de problèmes. Il s'agit d'une plateforme destinée à la création d'applications métier, et non à la résolution de problèmes qui se concentre sur l'efficacité. Cependant, il y a une raison pour laquelle ces défis sont utilisés pour tester les candidats : ils peuvent être appliqués à des applications du monde réel. Alors, essayons de relever ce défi et voyons si nous pouvons le relever. Nous verrons ensuite comment cela pourrait s'appliquer à une application du monde réel et comment Mendix pourrait être utilisé pour le construire.

Défi 1 : Deux Sommes

Ce défi consiste à prendre un tableau de nombres et à trouver l'index des deux nombres qui, une fois additionnés, forment la valeur cible. À première vue, le défi est simple : prendre le tableau et le parcourir en boucle, puis pour chaque valeur, parcourir à nouveau et trouver la valeur dont vous avez besoin pour créer la cible. Inefficace, mais simple. C'est donc par là que nous allons commencer.

Tout d'abord, nous créons une entité simple qui prend une chaîne pour représenter le tableau, un attribut entier représentant une valeur cible et quelques valeurs supplémentaires nécessaires pour stocker les index des éléments qui satisfont aux conditions (indiquées ci-dessous). Nous ajouterons également une heure de début/fin pour suivre l'efficacité.

Une fois cette entité créée, nous pouvons créer un formulaire pour saisir les valeurs et suivre les détails du défi. Rien de compliqué, la praticité est la clé ici. Comme vous pouvez le voir, nous devons également ajouter un bouton pour exécuter un microflux. (Un microflux est ce que Mendix appelle une fonction.)

Problème numéro un : le tableau de chaînes. Mendix n'est pas vraiment conçu pour fonctionner avec des tableaux de chaînes. Si vous abordiez ce problème dans une solution concrète, vous auriez une liste d'objets avec lesquels travailler. Cela ressemble un peu à de la triche à ce stade, alors travaillons simplement avec la chaîne pour l'instant.

Le module Community Commons, disponible sur le Mendix Marketplace fournit une fonction que nous pouvons utiliser pour diviser la chaîne en une liste. Elle étiquette également de manière pratique chaque élément avec un index. Cependant, elle ne convertira pas les valeurs en entiers, nous devrons donc nous en occuper à la volée.

Maintenant que nous avons une liste de valeurs, il s'agit simplement de parcourir la première liste et, en supposant que la première valeur ne dépasse pas la cible, de parcourir à nouveau et de voir s'il existe une autre valeur qui s'additionnera pour former la cible.

Le configurer de cette façon devrait faire l'affaire, alors essayons.

Parfait ! Ça marche à merveille. Le travail est fait, n'est-ce pas ? Non. Pas tout à fait. Il reste un autre défi : pouvez-vous trouver un algorithme dont la complexité temporelle est inférieure à O(n2) ?

Étant donné qu'il y a une boucle imbriquée dans notre solution, ce n'est clairement pas la manière la plus efficace de le faire. Alors, qu'est-ce que c'est ? Des pointeurs. Triez la liste, puis placez un pointeur au début et un pointeur à la fin. Vérifiez la somme des deux éléments et si elle est trop basse, déplacez le premier pointeur vers le haut de la liste et si elle est trop haute, déplacez le dernier pointeur vers le bas de la liste. Répétez jusqu'à ce que vous trouviez la solution ou que vous n'ayez plus de liste.

Il y aura quelques défis majeurs à relever pour y parvenir. Tout d'abord, la liste triée. Notre liste est stockée sous forme de chaînes, donc la trier par valeur ne fonctionnera pas. Nous devrons parcourir et convertir chaque valeur en un entier.

Ensuite, vous ne pouvez pas accéder à une liste à l’aide de valeurs d’index avec Mendix nous ne pouvons donc pas avoir simplement deux pointeurs d'index. Il existe cependant une solution simple, en utilisant l'action « Head » de l'opération de liste pour obtenir le premier objet de la liste. Nous pouvons alors simplement conserver deux copies de la liste : une triée par ordre croissant et une par ordre décroissant. Au fur et à mesure que nous parcourons la liste, nous supprimons simplement l'élément que nous vérifions actuellement de la liste correspondante s'il était trop haut ou trop bas.

L'application fonctionne comme prévu mais est moins efficace que l'approche par force brute de deux boucles pour des listes de nombres plus petites. Cependant, lorsque le nombre de valeurs augmente, elle devient beaucoup plus efficace.

Cela montre simplement que ce que vous faites avec du code traditionnel est possible avec du low-code avec un peu de créativité. Maintenant, allons un peu plus loin : que se passerait-il si c'était un problème commercial réel ?

Supposons que nous travaillons pour une entreprise qui emballe des produits et que nous souhaitons les emballer par deux dans une boîte. Nous devons cependant respecter la limite de poids de la boîte, ni plus ni moins. Pour ce faire, nous devons trouver deux produits dans notre inventaire qui, une fois emballés ensemble, correspondent à notre valeur cible. Cela vous semble familier ?

Tout d'abord, faisons ceci Mendix et chargeons les données dans une entité appropriée dès le départ. Nous allons générer une liste de valeurs aléatoires et la lier à l'entité de résultat que nous avons créée précédemment. Nous allons également la rendre persistante afin de pouvoir suivre les produits.

Maintenant que nous avons une liste avec laquelle commencer, nous pouvons simplement refactoriser le code que nous avons obtenu lors de la deuxième tentative. Cette section de notre Microflow d'origine peut être facilement extraite dans un sous-Microflow et utilisée à la fois dans notre fonction d'origine et dans la nouvelle fonction.

Nous avons maintenant trois manières différentes de traiter les données (lorsque la liste de nombres est générée, elle remplit également le tableau de chaînes, donc les deux premières fonctions fonctionnent toujours).

Cela nous permettra de trouver la première correspondance exacte. Nous allons avoir besoin d'un moyen de suivre les produits qui ont été emballés et le produit auquel ils sont associés. Il existe de nombreuses façons de procéder, mais nous allons utiliser une auto-association sur le produit ; de cette façon, nous pouvons facilement passer d'un produit à l'autre si nous en avons besoin. J'ai également défini l'association entre les entités pour supprimer automatiquement tous les produits si le lot principal est supprimé et vous remarquerez que j'ai renommé les entités « Lot » et « Produit » pour essayer de garder les choses claires.

Nous allons également devoir modifier la manière dont Microflow fonctionne pour trouver des correspondances, car nous ne recherchons plus seulement une correspondance exacte. Nous voulons maintenant trouver toutes les correspondances exactes. Nous pouvons également ajouter une optimisation supplémentaire en transférant l'effort de tri de la liste sur la base de données.

Comme vous pouvez le voir, lorsqu'une correspondance est trouvée, les deux produits sont désormais liés entre eux, puis supprimés des listes en cours de vérification. Il passe ensuite aux deux produits suivants.

Vous trouverez ci-dessous une capture d'écran de l'application terminée. Nous pouvons voir que dans le lot présenté, nous avons réussi à associer 764 produits. Ce n'est pas la meilleure façon d'afficher les données, car cela montre effectivement tous les produits deux fois car ils sont affichés de chaque côté de l'association, mais cela montre que cela fonctionne !

En fait, cela met en évidence le fait que la meilleure façon de structurer ces données serait probablement d'avoir une troisième entité appelée « Box » et de l'associer aux deux produits à partir de là. Vous pourriez alors générer des identifiants de boîte uniques et n'afficher chaque produit qu'une seule fois.

À partir de là, il suffit de quelques étapes simples pour relier cela aux clients, aux coursiers et même à une vitrine. Mendix peut facilement être utilisé pour créer n'importe laquelle de ces applications, et pas seulement des formulaires de dépenses ou des systèmes de demande de congés. Nous sommes peut-être une plateforme « low-code », mais cela ne signifie pas que vous ne pouvez pas l'utiliser pour créer des applications qui résolvent des problèmes complexes. Et lorsque le low-code ne suffit pas, il existe toujours la possibilité d'étendre une application avec des actions Java.

Restez à l'écoute pour mon prochain post où je m'attaque à l'un des défis les plus difficiles : « Récipient avec le plus d'eau », qui consiste à prendre un ensemble de hauteurs de colonnes et à déterminer quelle paire de colonnes forme un récipient qui peut contenir le plus d'eau ou qui a la plus grande surface rectangulaire entre elles.