/* Une chaîne de caractères est donnée. Trouver le nombre de paires d'indices i et j (i <= j), entre lesquelles il n'y a pas de caractères répétés. Pour la chaîne "aba", la réponse est 5 : peuvent être ASCII [0, 0] ("a") [0, 1] ("ab") [1, 1] ("b") [1, 2] ("ba") [2, 2] ("a") */
Avez-vous utilisé des clouds publics ? Si oui, quels fournisseurs et services ?
Avez-vous une expérience dans le support ou le développement de systèmes distribués ?
Comment travaillez-vous l'architecture — y a-t-il un architecte dans l'équipe, une plateforme, un comité?
Quelle sera la vitesse d'une recherche linéaire de tous les backends à un RPS élevé (par exemple, 30 000 RPS et 10 backends) ?
type Balancer struct { // TODO backends []*BackendImpl index int mu sync.Mutex N int K time.Duration } var _ Backend = &Balancer{} func (b *Balancer) Invoke(ctx context.Context, req Request) (Response, error) { if len(b.backends) == 0 { return nil, fmt.Errorf("Nombre de backends en el slice 0") } b.mu.Lock() index := b.index for b.backends[index].banned { b.index = (b.index + 1) % len(b.backends) index = b.index } b.index = (b.index + 1) % len(b.backends) b.mu.Unlock() backend := b.backends[index] resp, err := backend.Backend.Invoke(ctx, req) if err != nil && backend.countErrors < b.N { backend.mu.Lock() backend.countErrors += 1 if backend.countErrors == b.N { backend.banned = true go func() { time.Sleep(b.K) backend.mu.Lock() defer backend.mu.Unlock() backend.banned = false backend.countErrors = 0 }() } backend.mu.Unlock() } return resp, err } // addrs contiennent les adresses de toutes les instances équilibrées func NewBalancer(addrs []string) *Balancer { // TODO backends := make([]*BackendImplF, len(addrs)) for _, addr := range addrs { implF := BackendImplF{ Backend: NewBackend(addr), } backends = append(backends, &implF) } }
Sur combien d'hôtes le service fonctionnait-il et combien d'instances étaient lancées?
/** :-))) :-(( "ab :-)" = "ab " "ab :-)))" = "ab " "ab :-)))(" = "ab (" "ab ):-)" = "ab )" ":-)" = "" **/ func deleteP(str string) string { n := len(str) res := make([]byte, 0, n) i := 0 for i < n { if str[i] == ':' && str[i+1] == '-' && (str[i+2] == ')' || str[i+2] == '(') { ch := str[i+2] i += 2 for i < n && str[i] == ch { i++ } } else { res = append(res, str[i]) } } return string(res) }
À quel point les recherches sont-elles actives ? Peut-être y a-t-il déjà des offres ?
Comment vérifier rapidement que la fenêtre contient tous les caractères (comparaison de deux cartes) ?
Quelle a été la plus grande quantité de données avec laquelle vous avez travaillé dans des bases de données ?
Parle-moi plus en détail de ton premier emploi de 2019 à 2021.
Existe-t-il des moyens plus simples et plus rapides d'équilibrer la charge au lieu de choisir le backend le moins chargé?
Combien de personnes ont été impliquées dans le plus grand projet sur lequel vous avez travaillé ? Moins de dix, des dizaines, des centaines ?
Comment résoudre le problème de la limitation des requêtes parallèles dans un système distribué avec plusieurs instances, si l'utilisateur doit attendre plutôt que recevoir une erreur?
Trouver des erreurs de syntaxe dans le code corrigé
Pourquoi les messages du Message Service passent-ils directement par gRPC, plutôt que par Kafka?
func countSubs(s string) int { result := 0 left := 0 hm := make(map[rune]int) for right := 0; right < len(s); right++ { hm[s[right]]++ for hm[s[right]] > 1 { hm[s[left]]-- if hm[s[left]] == 0 { delete(hm, s[left]) } left++ } result += (right - left + 1) } return result }
Implémentez la méthode BulkCreateUsers basée sur le fichier proto : créez la structure du projet, la logique métier, le référentiel et les requêtes SQL en respectant les principes SOLID
Peut-on faire une mémoire constante sans enlever la carte ?
