Avez-vous de l'expérience dans le développement ou l'utilisation de processus asynchrones?
Python
Quelle est votre expérience dans le domaine du développement logiciel?
Quand avez-vous résolu pour la dernière fois des problèmes algorithmiques pour la pratique ou des projets?
Comment implémenter un mécanisme simple de verrouillage (lock) en mémoire pour se protéger contre l'accès concurrent sans utiliser de dépendances externes ?
Pouvez-vous évaluer la complexité de cette solution (en temps et en mémoire) ? Et pourquoi la complexité n'est pas O(n^2) ?
# Distributeur automatique chargé avec des cassette de billets, avec notre application à bord # doit pouvoir distribuer des billets pour un montant donné ou répondre par un refus # Lors de la distribution, les billets sont déduits du solde du distributeur. # Denominations autorisées : 50R, 100R, 500R, 1000R, 5000R. class ATM: pass # espace pour le code # Dispositif du distributeur automatique : # - l'argent est placé dans des cassettes à l'intérieur du distributeur, chargées par un agent de collecte et rechargées; # - chaque cassette contient des billets de sa dénomination; # - le distributeur peut compter les billets restants dans les cassettes, mais cette opération prend du temps - il faut l'appeler le moins souvent possible. # API pour interagir avec le matériel du distributeur. # L'interface SDK peut être modifiée/étendue selon l'accord des parties, si nécessaire class SDK(ABC): @abstractmethod def count_banknotes(self, banknote: int) -> int: pass @abstractmethod def move_banknote_to_dispenser(self, banknote: int, count: int) -> None: pass @abstractmethod def open_dispenser(self) -> None: pass
class ATM(SKD): def __init__(self, atm_api: "SKD"): self.atm_api: SKD = atm_api self.bills_count: dict[int:int] = {bill: self.atm_api.count_banknotes(bill) for bill in BILLS} def withdraw(self, amount: int) -> bool: bills_plan: dict[int: int] = {} remaining = amount for bill in BILLS: available = self.bills_count[bill] take = min(remaining // bill, available) if take > 0: bills_plan[bill] = take remaining -= take * bill if remaining != 0: return False bills_count_const = {50: 0, 100: 2, 500: 0, 1000: 0, ...}, expected = True @pytest.mark.parametrize( "bills_count_const,expected", [ ({5000: 0, 1000: 0, 500: 0, 100: 0, 50: 0}, False), ({5000: 100, 1000: 100, 500: 100, 100: 100, 50: 100}, True), ({5000: 1, 1000: 0, 500: 0, 100: 2, 50: 0}, True) ] ) def test_false(bills_count_const, expected): atm = ATM(FakeSDK()) atm.bills_count = bills_count_const amount = 1000 res = atm.withdraw(amount) assert res == expected
# OneEditApart("chat", "chien") -> faux # OneEditApart("chat", "chats") -> vrai # OneEditApart("chat", "cuit") -> vrai # OneEditApart("chat", "cast") -> vrai # OneEditApart("chat", "à") -> vrai # OneEditApart("chat", "actes") -> faux def OneEditApart(s1, s2) -> bool:
Avez-vous de l'expérience dans le support ou le développement de systèmes distribués ?
Dans quels pays envisagez-vous des options de travail ou de collaboration?
À quelle étape en est votre recherche d'emploi ou de projet ?
Avez-vous de l'expérience dans la création et la maintenance de systèmes basés sur des architectures distribuées?
Le candidat demande d'expliquer la solution proposée (pourquoi il faut comparer les produits des paires minimales et maximales).
Avez-vous des questions pour nous concernant le rôle ou l'entreprise?
L'intervieweur précise si le candidat voit la condition du problème.
Quelle a été la taille maximale des données que vous avez jamais stockée ou traitée dans votre pratique?
```python from collections import Counter def min_s(a: str, s: str) -> str: need = set(a) window = Counter() res = "" c = 0 left = 0 best_len = float('inf') for right, char in enumerate(s): if char in need and \ window[char] += 1 if window[char] == 1: c += 1 while c == len(need): if right - left + 1 < best_len: res = s[left:right + 1] best_len = right - left + 1 if s[left] in need: window[s[left]] -= 1 if window[s[left]] == 0: c -= 1 left += 1 return res ```
# Complexification # Nous avons une nouvelle fonctionnalité produit : réserver de l'argent via l'application mobile. # Pour cela, il faut ajouter une nouvelle méthode reserve(amount) dans la classe ATM. Il faut également prendre en compte la possibilité d'une HardwareError dans les méthodes SDK.
Comment représenterions-nous un graphique dont nous avons besoin pour cette tâche et comment en obtenir la réponse (itinéraire) ?