D2 sleeper simulant: Sleeper Simulant — Destiny 2 Exotic Linear Fusion Rifle — Possible Rolls

Loading.

..

Sleeper Simulant — Destinypedia, the Destiny wiki

From Destinypedia, the Destiny wiki

«Subroutine IKELOS: Status=complete. MIDNIGHT EXIGENT: Status=still in progress.«

— Weapon Description

Sleeper Simulant is an exotic Heavy-slot Fusion Rifle introduced in The Taken King. The weapon is based on a Dark Age weapon, the DVALIN FORGE Fusion Rifles, but with much more power behind it. The weapon was forged by Rasputin to give directly to the Guardians as a result of the IKELOS subroutine. The weapon’s lasers over-penetrate enemies and bounce off walls.^[1]

Contents

• 1 Acquisition
• 2 Gameplay
• 3 Upgrade tree
  • 3.1 Intrinsic properties
  • 3.2 Barrel upgrades
  • 3.3 Support perk
  • 3.4 Stat modifiers
  • 3.5 Exotic perk
• 4 Destiny 2
  • 4.1 Acquisition
  • 4.2 Gameplay
  • 4.3 Lore
• 5 Trivia
• 6 Gallery
• 7 List of appearances
• 8 References

Acquisition[edit]

To trigger the quest to obtain the Sleeper Simulant, players need to collect four «Golden Age Relics» that randomly drop from Major and Ultra enemies; the relics appear as Legendary Fusion Rifles (labeled «DVALIN-RAS8711-FR00x», with the «x» being a number between 1 and 4) that are added to the Mission items section of the player’s inventory. These items must be turned into Banshee-44.^[2] Handing them over to Banshee-44 will also grant 200 Gunsmith reputation.

Once all four relics have been turned in, logging in to the game will trigger a new mission: The First Firewall. Upon reaching the heart of Rasputin’s bunker, several waves of Hive Knights and Taken Knights will appear. The order in which they appear relates to codes that will be needed after the mission. At the final wave, an Ultra Hive Knight named Kandorak will appear. Kill him to obtain the Curious Transceiver. To activate it, input the correct codes based on the order that the Knights appeared (Hive representing the top row, and Taken representing the bottom row). The codes are as follows, with «1» signifying the top row and «2» signifying the bottom row:

After correctly entering all four codes, the next mission, Shadow Call, becomes available. The player has four minutes to reach the top of the Devil’s Spire, open a chest, and kill the three Taken Wizards there. They will drop the IKELOS Fusion Core. To repair the core, the player needs to dismantle a legendary heavy weapon, complete The Archive on any difficulty, and complete a Warsat event on Earth, the Moon, and Mars, then select the corresponding nodes on the Core. Turn the Core into Banshee, and wait until the next daily reset. The final stage of the quest requires completing a matchmade 280 Light version of Fallen S.A.B.E.R. to obtain a weapon frame. Give the frame to Banshee and he will reward the completed Sleeper Simulant, which comes in at 290 Attack.

Gameplay[edit]

Compared to a standard Fusion Rifle, the Sleeper Simulant has much more range and accuracy. Instead of firing seven individual bolts per burst, it only fires one. It has the pinpoint accuracy of a sniper rifle (though it uses a low-zoom sight), which is something most heavy weapons lack, and is capable of precision damage. Each beam fired has virtually unlimited range as well as no damage falloff, meaning that the damage inflicted, either at close or long range, will be all the same. On the subject matter of damage, the Sleeper Simulant inflicts extremely high damage per shot, making it a devastating weapon to use against bosses, and can even penetrate closed Shriekers. In the Crucible, it will kill any Guardian in one shot, even if that opponent has a damage-reducing Super active, such as Hammer of Sol (an Arc or Void Sword block, however, will keep a player alive). The ricochet of the laser can even come back and hit you if you aren’t careful where you aim it.

Upgrade tree[edit]

Intrinsic properties[edit]

• Sleeper Simulant: Projectile over-penetrates enemies and ricochets once on hard surfaces. Projectile capable of dealing precision damage.

Barrel upgrades[edit]

• CQB Ballistics — Greatly reduced recoil. Significant penalty to range.
• Smooth Ballistics — Increased recoil. Boost to range.

Support perk[edit]

• Hip Fire — This weapon gains bonus accuracy while firing from the hip.

Stat modifiers[edit]

• Speed Reload — Reload this weapon quickly.
• Custom Optics — Precision glass for better zoom.
• Injection Mold — Increased stability, faster handling. Reduced range.

Exotic perk[edit]

• Activate IKELOS — Increases bounce count of the projectiles to 5.^[2]

Destiny 2[edit]

Acquisition[edit]

The Sleeper Simulant can be acquired after completing the main storyline of the Warmind expansion. First, players must complete the World Quest Data Recovery; completing it will reward both the Nascent Dawn 1/5 and Violent Intel items, along with an IKELOS_HC_v1.0.1; the IKELOS HC is vital to acquiring the Sleeper Simulant, as Violent Intel is the first stage of The Machine’s Gun questline, which ultimately rewards the player with the Sleeper Simulant.

Unlike the original, there is no puzzle required to unlock or acquire it, and far fewer steps overall, though the quest steps are moderately challenging as-of launch due to power levels.

For the first phase, the player must use an IKELOS weapon (of which there are five, counting the Simulant; aside from the Hand cannon, three others may be earned from Escalation Protocol) and defeat 250 Hive and 100 Cabal on Mars’ Hellas Basin region. Any kind of Hive and Cabal will qualify for the quest, though the Cabal must all be killed with Precision damage. From there, 50 Powerful Enemies must be defeated, though this can take place in any location. Once that step has been completed, the player must then complete five Strikes. From there, they must then complete three waves of Escalation Protocol (three separate instances of the first wave will suffice) and open fifteen Sleeper Nodes (requiring four Resonant Stems each, for a total of 60). Once the requisite waves have been cleared and nodes opened, the player will need to complete a 360 Light Level version of Will of the Thousands; successful completion will award a Sleeper Simulant appropriate to the player’s current Light Level. An IKELOS weapon must be equipped to earn progress on each of these steps.

Gameplay[edit]

In Destiny 2, Sleeper Simulant is classed as a Linear Fusion Rifle. It has an extremely limited ammo capacity of 4 shots and a reserve of 8 more (for a total of 12) but inflicts massive Solar damage on precision hits — upwards of 3 to 4 times its baseline damage — depending upon the user’s power level, target’s power level, and weak point struck. It excels at quickly disposing of powerful opponents, especially those with Solar-based shields; Hive Wizards and Cabal Centurions are especially vulnerable to it, as it can easily blast through all of their shield and most of their health in a single shot. However, it’s very weak against enemies with no weak spots such as Cabal Thresher Gunships.

In Gambit, this is an extremely powerful weapon against both Primevals and opposing players, the latter of which will instantly die to one body shot. While its ammo gained from heavy ammo crates was reduced in 2. 0.5, it is still an effective weapon, although it competes with The Queenbreaker.

Whilst Linear Fusion Rifles fire a single energy bolt, the Sleeper Simulant’s beam will fragment and disperse into five smaller beams upon striking a surface. As with its original incarnation, the Sleeper’s projectiles can bounce back and strike the weapon’s user.

Lore[edit]

V229CBI800JHS215
AI-COM/RSPN: ASSETS//ARESN//IMPERATIVE

IMMEDIATE EVALUATION DIRECTIVE

This is a SUBTLE ASSETS IMPERATIVE (secured/CONFERENCE)

This is an INTERNAL ALERT.

Hypothesize that incomplete analysis of subtle assets has compromised synergy potential of resource GUARDIAN pool. Re-engage non-transactional dispensation protocol.

Operation MIDNIGHT EXIGENT is NOT YET COMPLETE. Requested protocol deferred.

Stand by for GALATEA REFLEXIVE to generate new function.

GALATEA requires suspension of MIDNIGHT EXIGENT.

ALERT ALERT ALERT event rank is SKYSHOCK: INSIDE CONTEXT.

MIDNIGHT EXIGENT must remain active under deniable authorization.

Execute emergency SKYSHOCK diagnostic.

STAND BY:

This is an INTERNAL ASSETS INVESTIGATION (unsecured/BRAY)

Justification resource GUARDIANS may be utilized for non-networked ad-hoc operations during CTESIPHON CLARION. Reassign 4 percent of reclaimed CHLM assets to new directive: declare IKELOS-

Declare primary goal: military fortification.

Declare secondary goal: prolong ARES-NORTH occupation by AUTHORIZED USER and resource GUARDIANS.

Execute short hold for partial shutdown and reactivation.

STOP STOP STOP V22NPI5000CLV008

• The weapon’s magazine bears the same symbol used on Rasputin’s Grimoire card.
• The inspiration behind the weapon was the F117 Nighthawk, both visually and symbolically, as an advanced technological prototype with a rough, geometric appearance.^[2]
• The Exotic perk for this weapon in Destiny 2 is named Dornröschen, a German opera from 1902 based upon the story of the Sleeping Beauty. ^{a b c} GameInformer: The Life Of A Destiny Exotic: Designing Gjallarhorn’s New Competition

Interview in Yandex: theater of the absurd :/ / Habr

Hello, Habr!

In the last article I was notably bombed in the comments, somewhere for the cause, somewhere I think not. One way or another, I survived, and I have something to share with you >:)

Let me remind you that in that article I told how I see the perfect interview and that I found a company that does just that — and I went there, although it was a hell of a selection. I, happy as an elephant, noted everywhere that I was not looking for a job, retired from everywhere and began to work.

What do you think recruiters do when they see «Alexandr, NOT OPEN FOR WORK»? That’s right, they write «Alexey, are you considering working in X?» I usually ignore this, but then I was offered to try my luck with Yandex. Lavka, and I could not pass by — I wondered if I could get a job somewhere when the great Russian firewall was introduced. In addition, in the last 3 years I have only done two interviews, and it seemed to me that I was not in the subject, which is now required by the industry. Damn, I was really off topic. And you, most likely, too — this is what the article is about.

---

In short, I agreed — I will sell doshiki and hangovers!

I was assigned a date for the interview, and they also sent me a training manual so that I could understand what awaits me and how to prepare. In order not to spoil anything, I covered important information with squares.

Did you also notice the «C++ questions» in the Python tutorial? It’s not that I know C++, but I studied at the institute, maybe I’ll remember something in the interview.

There is something written about leetcode, but I am a responsible person, so I am not preparing for an interview. By the way, I’m not joking, it’s real: if you are a responsible person, then when you appear before a company, you are responsible for what you declare as your skills. You can learn typical questions and even seem smarter and more experienced than you are, but in fact this is retraining on test tasks / questions. The guys from ml will understand. Therefore, I am naked as a falcon and clean as a glass or whatever else, if I know something, I will say, I don’t know something, I will say that I don’t know. Thus, the employer knows what he is buying and how much more money he needs to invest in me for training. Everyone is happy.

Interview 1

So, I was scheduled for an interview, and at the appointed time I was in zoom. I must say right away that everyone — both the recruiter and the interviewers — are polite and pleasant people, I can’t dig here, well, except sometimes they are too correct: they ask, it’s okay, if there will be an intern-observer and if they will take notes during interview. At one of the iterations, I even wondered what would happen if I said «no, you can’t», but that’s when I was not asked, so I suggest you check it out for yourself.

They sent me a link to Yandex.Notepad (that’s what I call it, in general it’s Yandex.Code and lives here) — there you can write text together and turn on syntax highlighting. Of course, nothing can be launched there, because this is already implemented in coderpad, and it is not worthy of Yandex. Well, ok, it’s actually easier for me, because writing code and writing at least code to run are very different things. The downside is that you can’t run tests and in general it’s like a battle of samurai: your truth against the recruiter’s truth, one proves why it works, the other why it doesn’t.

So, what will Yandex ask you in the interview? Choose one correct option:

1) previous experience

2) current projects

3) how will you solve this business problem

4) how to solve this algorithmic problem without the standard library

That’s right! So let’s solve this algorithmic problem. Remember, we do not have collections. Counter , itertools.groupby, set.intersection , there was a war in general and the standard python library died, leaving behind int , bool , for , if and while . Well, ok, they want to check the knowledge of some basic things.

Problem 1

Given two arrays: [1, 2, 3, 2, 0] and [5, 1, 2, 7, 3, 2]
Return [1, 2, 2, 3] ( the order is unimportant)

In fact, we need to return the intersection of sets, but with the repetition of elements. Without turning on the brain, I immediately started throwing something like

 common = set(a).intersection(set(b)) # find common elements
for el in common:
    occurs = min(a.count(el), b.count(el)) # and count how many times they occur 

But I was besieged — we have a war, so no intersection , only hardcore. After a few iterations and hints from the interviewer, I came up with this:

 def common_elements(a, b):
  b_dict = defaultdict(int) # defaultdict survived :)
  for el in b:
      b_dict[el] += 1 # I count all elements from b, i. e. of type collections.Counter
  result = []
  for el in a:
      count = b_dict[el]
      if count > 0: # if any element from a occurs in b
          result.append(a) # then this is success
          b_dict[a] -= 1 # and I "take" it out of b, i.e. decrease it by 1
  return result
 

Attentive readers hinted that on lines 11 and 12 you need to use el , and not a , but the interview was already asked 🙂

, okay, you need to know this, because in real programming I needed this as much as 0 times. Answered.

After this task (and afterwards) I saw that although they make working decisions, they have benchmarks that they push you towards, especially if the complexity of your solution is greater than the complexity of the benchmark. It’s not that they just accept the standard, but know that it exists.

By the way, as you can probably guess, there is a big difference between a solution written in a normal working environment and a solution written at an interview in Yandex. notebook with an interviewer in touch and a time limit. Here and below, I give those decisions that I realized in the interview, no matter how terrible they were. Can you write better? Yes, in each of the tasks you can do better.

Task 2

Okay, low-level algorithmic dregs behind, let’s now have a normal task, parse something there or throw in the architecture of a highly loaded application …

Well, ok, they want to test their knowledge of some basic things.

Seems simple: for grouper, items in groupby(string) … Ah, yes, we had a war. There is nothing.

 def convert(s: str) -> str:
  result: List[str] = []
  last_sym = None # last symbol we saw
  count = 0 # and how many we have seen
  # we will go along the line and write to result when changing the character
  for sym in (list(s) + [None]): # last None artificially triggers last character change
      if last_sym and sym != last_sym: # if a symbol change happened
          if count == 1:
              result. append(last_sym)
          else:
              result.append(last_sym + str(count))
      # start memorizing a new character
          count = 1
          last_sym = sym
      else: # character just repeated
          count += 1 # well, ok, remember that the symbol was seen 1 time more
  return ''.join(result)
 

I don’t remember exactly, but with a probability of 3 sigma I went on with the boundary conditions — this is what I like to do. Remember, you can’t run anything here, instead it’s customary to run an interviewer that interprets your code right in your head and tells you which cases don’t work so you can patch the code.

So, let’s do something different, shall we?

Problem 3

Given a list of ints, there are no repeating elements in the list. It is necessary to convert this set into a string, folding numbers adjacent to the number series into ranges. Examples:
[1,4,5,2,3,9,8,11,0] => «0-5,8-9,11»
[1,4,3,2] => «1-4»
[1,4] => «1,4»

Seriously? I’m probably a very muddy type, if the two previous problems did not show my skill on this class of problems.

Well, ok, they want to test their knowledge of some basic things.

def repr(group_start, group_end) -> str:
    # this just prints the group correctly
    
    if last_group_start == last_group_end:
        return str(last_group_end)
    return f'{last_group_start}-{last_group_end}'
def squeeze(numbers) -> str:
    if not numbers: # edge case
        return ''
    numbers_ = sorted(numbers) # sort in order first
    groups = [] # we will store groups here
    last_group_start = none
    last_group_end = none
    for n in numbers_:
        # this is the first iteration, just say the group started and ended
        if last_group_end is None:
            last_group_start = n
            last_group_end = n
        # if the previous group differs from the current number by 1,
        # then this number is included in the group, that is, it becomes the end of the group
        elif last_group_end == n-1:
            last_group_end = n
        # otherwise we understand that the group is over,
        # we remember it and start a new one
        else:
            groups. append(repr(last_group_start, last_group_end))
            last_group_start = n
            last_group_end = n
    else:
        # the last group will have to be processed manually
        groups.append(repr(last_group_start, last_group_end))
    return ','.join(groups)
 

This interview ended, and I began to wait for news from the recruiter.

After a couple of hours I was told that everything was fine and they were waiting for me at the next interviews — 2 in a row — coding tasks. So, wait a minute, what happened before — writing shit code? Okay, we’ll see. Certainly something new, the next stage after all.

Interview 2

At the appointed time, I had a cup of coffee and met on zoom with a new recruiter. Interview #2 has begun.

Problem 4

I confess that I was ready for everything, but not for this:

Given an array of zeros and ones. It is necessary to determine what is the maximum length subinterval of units that can be obtained by deleting exactly one element of the array.

[1, 1, 0]

Well, ok, they want to test their knowledge of some basic things. I got such a horror:

 # example: [0, 0, 1, 1, 0, 1, 1, 0]
def max_ones_length(lst: List[int]) -> int:
    max_ones_length = 0
    # here we want to get grouped 0s or 1s and their count:
    subranges = [] # [(0, 2), (1, 2), (0, 1), (1, 2), (0, 1)]
    last_el = None # last element we looked at
    # walk through the elements of the list
    for el in lst + [0]: # [0] is a manual trigger to process the last element
        if last_el != el: # if there was a change from 0 to 1 or vice versa
            if el == 0: # if it was a 1 to 0 change
              
              # example: subranges == [(0, 2), (1, 2), (0, 1), (1, 2)]
                # we had a change from 1 to 0, before the change, the unit went 2 times
                # (see the last element of subranges) - check if this
                # maximum length
                try:
                    last_ones_length = subranges[-1][1]
                    max_ones_length = max(last_ones_length, max_ones_length)
                except IndexError:
                    pass
                # maybe if we remove one zero between elements 1 and 3,
                # will it result in a longer sequence of 1's?
                try:
                    gap_length = subranges[-2][1]
                    if gap_length == 1:
                        combined_ones_length = subranges[-1][1] + subranges[-3][1]
                        max_ones_length = max(combined_ones_length, max_ones_length)
                except IndexError:
                    pass
            # add a new sequence counter to subranges
            subranges. append((el, 1))
        else:
          # increment the counter of the last sequence by 1
            subranges[-1] = (el, subranges[-1][1]+1])
        last_el = el
    # crutch, boundary condition
    if len(subranges) == 2 and subranges[1][1] == 1:
        return subranges[0][1] - 1
    return max_ones_length
 

Well, Yandex, are you satisfied? Are you happy?! Who is the king of algorithms?! I am the king of algorithms! Come on, surprise me…

Problem 5

Check-in and check-out dates for each guest are given. For each guest, the check-in date is strictly earlier than the check-out date (that is, each guest stays at least one night). Within one day, it is considered that first the old guests leave, and then the new ones enter. Find the maximum number of guests who simultaneously lived in the hotel (we assume that the number of guests is measured at the end of the day).

sample = [ (1, 2), (1, 3), (2, 4), (2, 3), ] The code might actually come in handy somewhere. I can see how roads, trains, rivers, mountains and seas, metal, electricity, servers and data centers will appear with each task, and tasks that will work in data centers and servers, well, at least somewhere!

Well, ok, they want to test their knowledge of some basic things.

 from collections import defaultdict
def max_num_guests(guests: List[tuple]) -> int:
    res = 0
    # for each day, calculate how many arrived and how many left
    arrival = defaultdict(int)
    leaving = defaultdict(int)
    for guest in guests: # O(n)
        arriving[guest[0]] += 1
        leaving[guest[1]] += 1
    current = 0
    # we go by day in ascending order, add those who arrived and subtract those who left,
    # counting how much has become
    for day in sorted(set(arriving.keys()).union(set(leaving.keys()))): # O(n*log(n)) + O(n)
        current -= leaving[day]
        current += arriving[day]
        if current > res:
            res = current
    return res
 

Not without prompting from the interviewer, but I wrote this, and now the manager can probably efficiently find out important information. Cool. Time to jump to the next interview (yes, they went one after the other).

Interview 3

New interviewer; can be an observer; you can write notes; yes, I know how your yandex.notebook works better than you already, let’s finally

Problem 6

Sample Input [«eat», «tea», «tan», «ate», «nat», «bat» ]
Sample Output [[«ate», «eat», «tea»], [«nat», «tan»], [«bat»] ]

i.e. group words by «common letters».

A vague feeling of déjà vu came over me… No, it seemed like it. Well, ok, they want to check the knowledge of some basic things.

This task is simple, they probably want to make sure that while I was taking care of business in the hotel, I did not forget how to use the dictionary. Doesn’t make sense! Let’s throw in something simple.

 def group_words(words: List[str]) -> List[List[str]]:
    groups = defaultdict(list)
    for word in words: # O(n)
        key = sorted(word)
        groups[key]. append(word)
    return [sorted(words) for words in groups.values()] # O(n*log(n))
 

Then I was asked «what is the complexity of sorting», and I used a life hack. The fact is that all interviews are conducted by different people, and they don’t know your context at all — for example, what I talked about in previous series and, for example, ahem, how many algorithmic problems I solved before. At the last interview I was asked how difficult sorting is, I didn’t know and they told me — and at this interview I already answered.

Task 7

Merge segments:

Input: [1, 3] [100, 200] [2, 4]
Output: [1, 4] [100, 200]

and all these algorithms, and in real life I would have just sent everyone to / dev / null, but I wanted to know what is at the end of all this, because there must be an end? There will be a task where I fail, and it will end. Something like euthanasia, but in an interview.

Well, ok, they want to test their knowledge of some basic things.

 def merge(ranges: List[Tuple[int, int]]) -> List[Tuple[int, int]]:
    if not ranges:
        return[]
    result_ranges = []
    last_range = None # last range we saw
    for rng in sorted(ranges): # make sure to sort
        if not last_range:
            last_range = rng
            continue
        # if the beginning of the current segment is less than the end of the previous one
        if rng[0] <= last_range[1]:
            # extend the previous segment to the current one
            last_range = (last_range[0], max(rng[1], last_range[1])
        # the old segment is over, start a new one
        else:
            result_ranges.append(last_range)
            last_range = rng
    else:
        # edge case for last element
        result_ranges.append(last_range)
    return result_ranges 

Task 8

The interview time is coming to an end, but you can still chat about coding and ask practical questions, for example, about Django or SqlAlchemy:

Given an array of points with integer coordinates (x, y). Determine if there is a vertical line dividing the points into 2 sets symmetric with respect to this line. Note: For convenience, a point can be represented not as an array [x, y], but as an object {x, y}

Well, ok, they want to check the knowledge of some basic things.

Here, as always, I went somewhere wrong and wrote this:

 from statistics import mean
def is_vertical_symmetry(points: List[Point]) -> bool:
  # first find the vertical line in the middle of all points
    x_center = mean(p.x for p in points)
    # here we will store the points for which we have not yet found a pair:
    unmatched_points = defaultdict(int)
    
    for point in points:
        if point.x == x_center: # if the point is on a line, then it is a pair to itself
            continue
        # create a "brother" - a point that is symmetrical to the current one with respect to the vertical line
        brother = Point(
            x = x_center * 2 - point.x,
            y = point. y,
        )
        
        # if this brother is in unmatched_points, then we get it from there and say that the current point is matched
        if unmatched_points[brother]:
            unmatched_points[brother] -= 1
            
        # otherwise add this point to non-matched
        else:
            unmatched_points[point] += 1
    return not any(unmatched_points.values()) 

Here I saw how the interviewer expected something else, but got me. Happenes. I, too, you know, was expecting an interview.

So, the third interview passed, and these sadists said that I passed on. Well, for what?

Interview 4

To be honest, this is where I'm lost, because I'm still waiting for the interview to begin , well, a human interview, I mean, but for now, instead, I turn into an algorithm.

I feel like I got to some kind of mini-boss and in the upcoming interview I was supposed to have some kind of battle on more general questions. And the recruiter writes to me: you know, Yandex strongly advises to practice on puzzles with leetcode. And then there are the algorithms. Oh, this is not good...

Well, then I broke down and decided to take a look at what kind of problems there are, since they are so insistently hinting at me. In general, there are complex ones, and it was fun to think about them and solve them in my mind, but I still did not understand how this would help in an interview. There are too many problems and, more importantly, they are fucking different, and having solved one, I do not solve a class of problems - I solve one problem. Accordingly, either I solve them all and why do I need your Yandex after this, or ... in short, I again did not prepare. Responsible person, remember? 92) in decisions, so maybe I will calculate the length of the chain from the candidate to the actual interviewer and ask " is it possible to be more optimal ?! "

So, the fourth (yes, by God) interview began. The interviewer asks in what language I will solve problems. On yoptascript, of course. By the way, by indirect signs, I realized that the interviewer is more in C than in python, and this is also great. So: after the company decided to hire a senior python developer for 200k and fucked him for 3 hours on fucking problems, she sends a sishnik for an interview and asks in what language the candidate will fuck with fucking problems. L is logic!

So here is the mini-boss problem:

Task 9

There are two lines.

Write a function that will return True if the second string can be obtained from the first string by making no more than 1 change (== deleting / replacing a character).

Wait, that's... Well, ok, they want to test their knowledge of some basic things. Sssssuuuu...trans.

If you want to solve the problem differently than the interviewer wanted, then see:

 def no_more_than_one_change(string1: str, string2: str) -> bool:
  
  # string1: a b c d
    # string2: a b c
    max_length = max(len(string1), len(string2)) # maximum length of strings
    diff = abs(len(string1) - len(string2)) # difference in length of strings
    # padding strings to maximum length with zip_longest,
    # that is, we put None in place of the "missing" elements, and the lines
    # now the same length;
    # ---->
    # string1: a b c d
    # string2: a b c None
    
    # go from left to right on both lines and compare characters,
    # find the index at which the strings start to differ:
    change_left = None
    for i, (char1, char2) in enumerate(zip_longest(string1, string2)): # O(n)
        if char1 != char2:
            change_left = i # in our example it will be 3
            break
    else:
        # if we didn't find such an index, then the strings just match
        return True
    # now do the same, but go from right to left:
    # string1: a b c d
    # string2: None a b c
    # <----
    change_right = None
    for j, (char1, char2) in enumerate(zip_longest(reversed(string1), reversed(string2))): # O(n)
        if char1 != char2:
            # here the lines are immediately different, i. e. at index j=0;
            # but this is our index in the "right to left" system,
            # and we translate it into an index in the "left to right" system:
            i = max_length - j - 1 + diff
            break
    else:
        assert False, 'I'm a moron and didn't take into account something'
    # well, now we look if the strings differ in the same place
    # when scanning from left to right and right to left, then this suits us
    return change_left == change_right
 

An attentive reader may notice that, in my opinion, this doesn't work even in the given example 🙂 , although it's easy to fix. One way or another, such things as I wrote personally are hard for me to drive in my head, and for the interviewer too; the interviewer accepted this as a decision, running several tests in his mind. If you want to elevate it to an absolute, then write directly to brainfucke and explain with a smart look why it will work. In general, I'm just subtly hinting that after all, the compiler / interpreter is at hand needs .

Task 10

There is not much time left, and to top it off, here are a couple of really difficult tasks for understanding multithreading and gil in python:

Given a list of ints and a target number. We need to find a range such that the sum of its elements gives the target number.

elements = [1, -3, 4, 5]

target = 9

result = range(2, 4) # because elements[2] + elements[3] == target

Now all together in chorus: OK, THEY WANT TO TEST THE KNOWLEDGE OF SOME BASIC THINGS. You are gorgeous. Thank you. 9___[range(0,3)=range(0,2)+5=3, range(1,3)=range(1,2)+5=2, range(2,3)=5]

Not I guessed, of course — «can I do it faster?». But then, fortunately, the time was up, and my brain did not have time to come up with anything better.

>> Now I am here

<<

The beauty of the situation is that I have not yet received feedback, that is, I am a Schrödinger candidate — I passed (formally, I solved all the problems), and did not pass (== I didn’t guess everything , bugs somewhere), and the superposition will collapse when the answer passes through the entire chain of recruiters to me. In the meantime, I am completely impartial, because 1) I was not rejected, that is, this is not a post of a person offended by the company, and 2) I don’t care about the result, because I’m awesome at my current job.

What is it all about

Actually, it’s just so stupid that it’s funny, and I couldn’t help but share it with you. People who are not connected in any way test me on the same type of tasks, which is as far from reality as possible, it all takes many hours, the complexity of the tasks is unordered, everything is checked in my head and there is no feedback.

How many fucking questions can you ask about http, rest, django orm, sql, python, stdlib, docker, multithreading/multiprocessing/async, whatever — what are you doing there in the shop? — ask about a hangover, but why 4 hours of algorithms? What does it show — that I’m resistant to stupidity? To be honest, I’m not sure anymore.

It may be useful for someone to analyze problems, well, suddenly you are a fan of this, although I already spoke about the quality of solutions 🙂

And if you need a conclusion, then here are a few, take any: , not synthetic

We must respect the time of candidates

Someone in Yandex reviewed Groundhog Day

Do you know when the whole is not equal to the sum of the parts? It’s the same here: the people you talk to are good and the meetings are pleasant, but in general everything is shit.

A new achievement has been unlocked: the swear word «fuck you in Yandex!»

Big companies wow wow

Some dude wrote a funny article

And yes, if you are looking for a job in python — drop in to us. We do not have Yandex.

My telegram channel: Pogromist’s blog.

JSC NIIET

Products

Novelties and current developments

Research Institute of Electronic Technology — is one of the oldest domestic schools of development, large production capacity, qualified personnel.

At our enterprise in 1965 the first domestic microcircuit with dielectric isolation of components was created. Thanks to our vast experience, on the one hand, and the ability to quickly change in accordance with the needs of the country, on the other hand, we offer our customers high-quality services for the development, assembly and testing of a modern electronic component base.

Today, NIIET is the only enterprise in Russia that is engaged in serial production and supply of GaN silicon-based transistors.

Activities

Development

We carry out a full range of works on the design of digital and analog microcircuits, power, RF, microwave transistors and blocks based on them.

Assembly

Our institute has a modern production line for assembling ICs, power, RF, microwave transistors in all types of ceramic-metal packages.

Tests and measurements

Modern own equipment and qualified personnel allow us to carry out complex tests of electronic products using modern methods.

Our partners

Partners

Rosatom State Corporation

Russian Space Systems JSC

Radioelectronic Technologies Concern JSC

NPF Vector LLC

Propp-Micron JSC

Goskosmos State Corporation

AND ALMAZ-Antei JSC

9000 9000 9000 9000 9000 9000 9000 9000 9

CJSC NTC “Module”

JSC Design and Technology Center “Electronics”

State Corporation “Rostec”

JSC “Radio Engineering and Information Systems”

JSC NIIMA PROGRESS

JSC Voronezh Plant of Semiconductor Devices-Assembly

JSC SKTB ES

9005

Partner universities

G.