რომელი იყო თქვენი ყველაზე დიდი მონაცემთა ბაზის პროექტი, რომელსაც თქვენ უნდა იყო განახორციელეთ ან შეინარჩუნეთ?
Junior — Middle
295
Golang
8373
0
საერთო ორგანიზაციებში ინტერვიუს პროცესის რომელ ეტაპებზე ხშირად სვამენ ამ კითხვას?
Intern — Junior
283
როგორ ხორციელდება მოთხოვნები PostgreSQL მონაცემთა ბაზას?
Junior — Middle
269
შეგიძლიათ ახსნათ gRPC-ის ფუნქციონირების პრინციპი და მისი ძირითადი მახასიათებლები?
Junior — Middle
266
რამდენი წერითი მოთხოვნა მოდიოდა მონაცემებზე წამში?
Senior
254
რამდენი ინстанცია/კონტეინერი მუშაობდა სერვისზე?
Middle+
245
რომელ ფენაში დებენ მომხმარებლებს გარეთ სერვისებისა და სისტემებისთვის?
Intern
244
რა გამოცდილება გაქვთ მრავალმხრივი და პარალელური გამოთვლების გამოყენებით პროგრამების განვითარებაში?
Junior — Middle
236
რის პრინციპით უნდა შემცირდეს ან გაიზარდოს have გამოთვლა?
Senior
235
შეგიძლიათ ჰოსტებზე ინფორმაცია მიაწოდოთ? რამდენი ჰოსტია, რამდენი კონტეინერი მუშაობს?
Senior
232
როგორ ხორციელდება მონაცემების დაკავშირება და ჩვენება Grafana-ში?
Junior — Middle
229
როგორ გამოვლინოთ ვიზუალურად ან ალგორითმულად, რომ ელემენტი უნიკალურია Map მონაცემთა სტრუქტურაში?
Junior — Middle
222
რომელი იყო თქვენი მუშაობის განმავლობაში ყველაზე გრძელი პროექტი?
Junior — Middle
222
""" კინოთერის ადგილები ერთ რიგშია განლაგებული. ახალი მოსული მაყურებელი არჩევს ადგილს, მოსახერხებლად მაქსიმალურად მოშორებით სხვა მაყურებლებს, რიგში. ანუ, ადგილიდან, სადაც ის დაჯდება, ყველაზე ახლოს მყოფ მაყურებელთან მანძილი უნდა იყოს მაქსიმალური. გაიგება, რომ ყოველთვის არსებობს თავისუფალი ადგილები და უკვე დაჯდა მინიმუმ ერთი მაყურებელი. დაწერეთ ფუნქცია, რომელიც მოცემული ადგილების რიგიდან (ნოლებისა და ერთების მასივი) დააბრუნებს მანძილს (სკამებს შორის სვლების რაოდენობას) ადგილიდან ყველაზე ახლოს მყოფ მაყურებელამდე. [1, 0, 0, 0, 1] -> 2 [1, 0, 1, 0, 0, 1, 0, 0, 1] -> 2 [1, 0, 1, 0] -> 1 """
Intern
216
როგორ უნდა ორგანიზდეს არქიტექტურა მოთხოვნისთვის, რომელიც ახორციელებს ბიზნეს-ლოგიკას, მიმართავს გარე სერვისს (Google) და ინახავს შედეგს მონაცემთა ბაზაში? აღწერეთ ზევიდან ქვემოთ ფენებად.
Intern
215
/* අපට මූලාශ්රයකින් දත්ත කිසියම් පරිභෝජකයකුට මාරු කළ යුතුය. මේදී මූලාශ්රය කුඩා කට්ටලවලින් (~ දස ගණනක් වාර්තා) දත්ත ලබා දී ඇති අතර, පරිභෝජකයා විශාල බචක සමඟ වැඩ කිරීම වඩාත් ප්රයෝජනවත් වේ. සත්ය උදාහරණයක් - Kafka වර්ගයේ පෙළගැස්මවලින් දත්ත ලබා දීම Clickhouse දත්තගබඩාවට. මූලාශ්රය: - කොන්දේසි ලෙස අසීමිත. - මූලාශ්රය එක් කැඳවීමකදී MaxItems වඩා වැඩි වාර්තා ආපසු නොදේ. - එක "සෙෂන්" (Pipe ක්රියාවලියක්) තුළ, මූලාශ්රය සෑම කැඳවීමකදී නව දත්ත ආපසු දක්වයි. - එහෙත්, නැවත ආරම්භ කිරීමෙන් පසු, මූලාශ්රය පසුගිය "තහවුරු කළ" තැනින් ආරම්භ වේ, එය cookie මගින් නියමිතයි. එමනිසා, Next කැඳවීමෙන් ආපසු ලැබූ සෑම cookie අගයක්ම, දත්ත සුරක්ෂිත කිරීමෙන් පසු, Commit මඟින් තහවුරු කළ යුතුය, එය ඒම අනුක්රමිකත්වයෙන්, Next විසින් ආපසු ලබා දී ඇත්තේ මෙන්. පරිභෝජක: - MaxItems වඩා වැඩි දේ එකවර සැකසිය නොහැක. මූලික මට්ටම: func Pipe(p Producer, c Consumer) error ක්රියාවලිය ක්රියාත්මක කළ යුතුය, ඒක මූලාශ්රයෙන් දත්ත කියවීම, ඒවා MaxItems අධික නොවන බෲෆරයට සමූහ කිරීම, සහ පසුදා ඒවා පරිභෝජකයට සුරක්ෂිත කිරීම, ඒ අනුව මූලාශ්රයේ ප්රගතිය තහවුරු කිරීම. */ const MaxItems = 9999 type Producer interface { // Next ආපසු දක්වයි: // - සැකසිය යුතු අයිතම කට්ටලයක් // - තහවුරු කිරීම සඳහා cookie // - දෝෂයක් Next() (items []any, cookie int, err error) // Commit යනු, සැකසූ දත්ත කට්ටලය සලකුණු කිරීම සඳහා Commit(cookie int) error } type Consumer interface { Process(items []any) error } func Pipe(p Producer, c Consumer) error { var buf []any var cookies []int for { items, cookie, err := p.Next() if err != nil { return err } buf = append(buf, items...) cookies = append(cookies, cookie) if len(buf) >= MaxItems { if err := c.Process(buf); err != nil { return err } for _, c := range cookies { if err := p.Commit(c); err != nil { return err } } buf = buf[:0] cookies = nil } } if len(buf) > 0 { if err := c.Process(buf); err != nil { return err } for _, c := range cookies { if err := p.Commit(c); err != nil { return err } } } return nil }
Middle
214
რა მაჩვენებლებს იყენებდით თქვენი მუშაობის შეფასებისთვის ბოლო პროექტში?
Junior — Middle
204
ახლა მუშაობთ თუ არა, და რა ფორმატში: ოფისი, ჰიბრიდი, დისტანციური?
Senior
201
func countSubs(s string) int { result := 0 left := 0 hm := make(map[rune]int) n := len(s) for right := 0; right < n; 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 }
Intern
200
/* ჩვენს უნდა გადავცეთ მონაცემები გარკვეული წყაროდან გარკვეულ მომხმარებელს. ამ დროს წყარო მცირე პარტიებს აძლევს (~ ათეულობით ჩანაწერი), ხოლო მომხმარებელი ოპტიმალურად მუშაობს დიდ პარტიებთან (~ ათასობით ჩანაწერი). რეალური მაგალითი - მონაცემების მიწოდება Kafka ტიპის რიგებიდან Clickhouse ბაზაში. წყარო: - პირობითად უსასრულო. - წყარო არასდროს აბრუნებს MaxItems-ზე მეტ ჩანაწერს ერთ გამოძახებაზე Next. - ერთ "სესიაში" (ფუნქცია Pipe-ის ერთ გამოძახებაში) წყარო ყოველ ჯერზე ახალ მონაცემებს აბრუნებს. - თუმცა, გადატვირთვის შემდეგ წყარო დაიწყებს წინა "დადასტურებულ" პოზიციიდან, რომელიც cookie-სით არის განსაზღვრული. ამიტომ, თითოეული მნიშვნელობა cookie-ს, რომელიც Next-ის გამოძახებამ დააბრუნა, უნდა იყოს დადასტურებული Commit-ის გამოძახებით, და ეს უნდა მოხდეს ზუსტად იმავე სერიაში, სადაც Next-მა დააბრუნა. მიღება: - არ შეუძლია ერთდროულად MaxItems-ზე მეტი დამუშავება. ძირითადი დონე: ფუნქცია func Pipe(p Producer, c Consumer) error-ის განხორციელება, რომელიც წყაროდან მონაცემებს კითხულობს, მათ დიდ ბუფერში აგროვებს და შემდეგ იღებს მას მიმღებში, და პროგრესს წყაროსთან ერთად განახლებას. რთულობა: Next, Process და Commit მეთოდები დაკავშირებულია ქსელურ გამოძახებებთან და შეიძლება დიდხანს გაგრძელდეს. მოსწრაფვისთვის, მონაცემების წაკითხვა, ჩაწერა და პროგრესის დადასტურება პარალელურად უნდა მოხდეს. ასე რომ, Process ან Commit-ის გამოძახების დროს, წყაროსგან კითხვა და ახალი ბუფერის შექმნა გაგრძელდეს. */
Senior
196