Come si lavora sull'architettura — c'è un architetto nel team, piattaforma, comitato?
Golang
Hai utilizzato cloud pubblici? Se sì, con quali provider e servizi?
Quanto velocemente funzionerà una ricerca lineare di tutti i backend con un alto RPS (ad esempio, 30.000 RPS e 10 backend)?
Hai esperienza nel supporto o nello sviluppo di sistemi distribuiti?
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("Numero di backends nel 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 contengono gli indirizzi di tutte le istanze bilanciate func NewBalancer(addrs []string) *Balancer { // TODO backends := make([]*BackendImplF, len(addrs)) for _, addr := range addrs { implF := BackendImplF{ Backend: NewBackend(addr), } backends = append(backends, &implF) } }
Qual è stato il volume di dati più grande con cui hai lavorato nei database?
Su quanti host è stato eseguito il servizio e quante istanze sono state avviate?
Qual è stato il massimo numero di richieste al secondo nel servizio più trafficato?
Parlami più dettagliatamente del tuo primo lavoro dal 2019 al 2021.
Quanto sono attive le ricerche? Forse ci sono già alcune offerte?
Come verificare rapidamente che nella finestra ci sono tutti i caratteri (confronto di due mappe)?
Quante persone sono state coinvolte nel progetto più grande a cui hai lavorato? Meno di dieci, decine, centinaia?
/** :-))) :-(( "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) }
Come risolvere il problema della limitazione delle richieste parallele in un sistema distribuito con più istanze, se l'utente deve aspettare invece di ricevere un errore?
Esistono metodi più semplici e veloci per bilanciare il carico invece di scegliere il backend meno carico?
Trova errori di sintassi nel codice corretto
Perché i messaggi del Message Service vanno direttamente tramite gRPC, anziché tramite 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 }
Implementa il metodo BulkCreateUsers basato sul file proto: crea la struttura del progetto, la logica di business, il repository e le query SQL seguendo i principi SOLID
""" I posti al cinema sono disposti in una fila. Un spettatore appena arrivato sceglie un posto, per sedersi il più lontano possibile dagli altri spettatori nella fila. Cioè, la distanza dal posto, che occuperà, al più vicino spettatore deve essere massima. Si garantisce che ci siano sempre posti liberi nella fila e che ci sia almeno uno spettatore seduto. Scrivi una funzione che, data una fila di posti (un array di zeri e uno), restituisca la distanza (numero di spazi tra i sedili) dal posto scelto allo spettatore più vicino. [1, 0, 0, 0, 1] -> 2 [1, 0, 1, 0, 0, 1, 0, 0, 1] -> 2 [1, 0, 1, 0] -> 1 [0, 0, 0, 1] -> 3 [1, 0, 0, 0] -> 3 place = ((right - left) / 2) """ func maxPlaces(arr []int) int { }