minion work assignments

• 1.1.1. Minion Work Assignments
• 1.1.2. Languages
• 1.1.3. Test cases

Google foobar challenge level 1 - Minion Work Assignments

Description, minion work assignments.

Commander Lambda’s minions are upset! They’re given the worst jobs on the whole space station, and some of them are starting to complain that even those worst jobs are being allocated unfairly. If you can fix this problem, it’ll prove your chops to Commander Lambda so you can get promoted!

Minions’ tasks are assigned by putting their ID numbers into a list, one time for each day they’ll work that task. As shifts are planned well in advance, the lists for each task will contain up to 99 integers. When a minion is scheduled for the same task too many times, they’ll complain about it until they’re taken off the task completely. Some tasks are worse than others, so the number of scheduled assignments before a minion will refuse to do a task varies depending on the task. You figure you can speed things up by automating the removal of the minions who have been assigned a task too many times before they even get a chance to start complaining.

Write a function called solution(data, n) that takes in a list of less than 100 integers and a number n, and returns that same list but with all of the numbers that occur more than n times removed entirely. The returned list should retain the same ordering as the original list - you don’t want to mix up those carefully-planned shift rotations! For instance, if data was [5, 10, 15, 10, 7] and n was 1, solution(data, n) would return the list [5, 15, 7] because 10 occurs twice, and thus was removed from the list entirely.

To provide a Python solution, edit solution.py To provide a Java solution, edit Solution.java

Your code should pass the following test cases. Note that it may also be run against hidden test cases not shown here.

— Python cases — Input: solution.solution([1, 2, 3], 0) Output:

Input: solution.solution([1, 2, 2, 3, 3, 3, 4, 5, 5], 1) Output: 1,4

— Java cases — Input: Solution.solution({1, 2, 3}, 0) Output:

Input: Solution.solution({1, 2, 2, 3, 3, 3, 4, 5, 5}, 1) Output: 1,4

Use verify [file] to test your solution and see how it does. When you are finished editing your code, use submit [file] to submit your answer. If your solution passes the test cases, it will be removed from your home folder.

배열 안의 모든 숫자의 개수를 세고 해당 배열에서 n회 초과로 나타나는 숫자를 제거해주면 된다.

• Time Complexity : O(n)
• Space Complexity : O(n)

FB1 - Google Foobar - Minion Work Assignments

Level 1: the very first challenge. learn how to do it and find loopholes for easier debugging..

• ls : list directory contents [dir_name]
• cd : change directory [dir_name]
• cat : print file [file_name]
• edit : open file in editor [file_name]
• ⌘ + S : save the open file [when editor is focused]
• verify : runs tests on solution file [file_name]
• submit : submit final solution file for assessment [file_name]
• request : request new challenge

What is the first Google Foobar challenge?

Readme.txt:.

Commander Lambda’s minions are upset! They’re given the worst jobs on the whole space station, and some of them are starting to complain that even those worst jobs are being allocated unfairly. If you can fix this problem, it’ll prove your chops to Commander Lambda so you can get promoted!

Minions’ tasks are assigned by putting their ID numbers into a list, one time for each day they’ll work that task. As shifts are planned well in advance, the lists for each task will contain up to 99 integers. When a minion is scheduled for the same task too many times, they’ll complain about it until they’re taken off the task completely. Some tasks are worse than others, so the number of scheduled assignments before a minion will refuse to do a task varies depending on the task. You figure you can speed things up by automating the removal of the minions who have been assigned a task too many times before they even get a chance to start complaining.

Write a function called solution(data, n) that takes in a list of less than 100 integers and a number n, and returns that same list but with all of the numbers that occur more than n times removed entirely. The returned list should retain the same ordering as the original list - you don’t want to mix up those carefully-planned shift rotations!

For instance, if data was [5, 10, 15, 10, 7] and n was 1, solution(data, n) would return the list [5, 15, 7] because 10 occurs twice, and thus was removed from the list entirely.

How did I solve the first Google Foobar challenge?

This challenge is a dime a dozen. I know the purpose of this challenge is just to help you to get used to verifying and submitting the solution. 7 days for this challenge is too generous. Feel free to explore and enjoy the new feeling, admiring the beautiful google site you’ve never seen before. LOL

Ok, let’s start cleaning up the tasks for the minions…

Damn, it failed! fail for what? I don’t know why does it rain fail 🤔

Hmmm, seem it’s not as simple as I thought it would be, I tried looking around, and everyone has the same answer as me but they passed and I failed???

When the solution is run by command verify solution.py , it sends the arguments to my server, So I can check the logs on my server.

solution.py:

• Table of contents What is the first Google Foobar challenge? readme.txt:

Google’s FooBar Challenge | See How I Passed Levels 1 to 5 in Real-Time

I just got invited to perform Google’s FooBar challenge. In this article, I want to share with you how I solved the problems in real-time. The purpose of this article is to educate you—and to have some fun. So, are you ready?

Level 1: Prime Numbers

The first goal was to find an identifier for a new employee at the “minions” company.

The identifier is selected base on a random number i. How do we come from the random integer i to the identifier of the new minion employee?

• Create a sequence of prime numbers '23571113...' .
• The identifier is the subsequence starting from index i and ending in index i+4 (included).
• The value i is an integer between 0 and 10000.

Here’s the solution I implemented in the video:

Do you want to develop the skills of a well-rounded Python professional —while getting paid in the process? Become a Python freelancer and order your book Leaving the Rat Race with Python on Amazon ( Kindle/Print )!

Level 2 Challenge 1: Sequence Sum

Here’s the problem posed by Google:

Here’s the first code that I tried:

The code solves the problem but it takes quadratic runtime so I though—can we do better? Yes, we can! There’s a linear runtime solution:

Both solutions work—but the latter is much faster. Here’s the output and the test cases:

After submitting the solution in my browser shell, Google tells me that there is one more challenge to go to reach the next level:

Level 2 Challenge 2: Digits and Remainder Classes

I first went on developing a naive solution (no premature optimization)!

While this code solves the problem, it’s not optimal. It can be painfully slow for large lists because of the many levels of recursion. So I went back and developed a new version based on remainder classes:

Here’s the code of the new idea:

The output is correct. After submitting the solution, Google tells me that I managed to pass the level successfully! Hurray!

I even get to refer a friend…

Level 3 Challenge 1:

Here’s the next challenge:

And my solution:

Level 3 Challenge 2

foobar:~/ xcent.py$ request Requesting challenge… There are a lot of difficult things about being undercover as Commander Lambda’s personal assistant, but you have to say, the personal spa and private hot cocoa bar are pretty awesome. New challenge “Fuel Injection Perfection” added to your home folder. Time to solve: 96 hours.

Level 3 Challenge 3 Baby Bomb

While working as a researcher in distributed systems, Dr. Christian Mayer found his love for teaching computer science students.

To help students reach higher levels of Python success, he founded the programming education website Finxter.com that has taught exponential skills to millions of coders worldwide. He’s the author of the best-selling programming books Python One-Liners (NoStarch 2020), The Art of Clean Code (NoStarch 2022), and The Book of Dash (NoStarch 2022). Chris also coauthored the Coffee Break Python series of self-published books. He’s a computer science enthusiast, freelancer , and owner of one of the top 10 largest Python blogs worldwide.

His passions are writing, reading, and coding. But his greatest passion is to serve aspiring coders through Finxter and help them to boost their skills. You can join his free email academy here.

Minion::Guide - An introduction to Minion

This document contains an introduction to Minion and explains the most important features it has to offer.

# INTRODUCTION

Essentials every Minion developer should know.

# Job queue

Job queues allow you to process time and/or computationally intensive tasks in background processes, outside of the request/response lifecycle of web applications. Among those tasks you'll commonly find image resizing, spam filtering, HTTP downloads, building tarballs, warming caches and basically everything else you can imagine that's not super fast.

They are not to be confused with time based job schedulers, such as cron or systemd timers. Both serve very different purposes, and cron jobs are in fact commonly used to enqueue Minion jobs that need to follow a schedule. For example to perform regular maintenance tasks.

# Mojolicious

You can use Minion as a standalone job queue or integrate it into Mojolicious applications with the plugin Mojolicious::Plugin::Minion .

Background worker processes are usually started with the command Minion::Command::minion::worker , which becomes automatically available when an application loads Mojolicious::Plugin::Minion .

The worker process will fork a new process for every job that is being processed. This allows for resources such as memory to be returned to the operating system once a job is finished. Perl fork is very fast, so don't worry about the overhead.

By default up to four jobs will be processed in parallel, but that can be changed with configuration options or on demand with signals.

Jobs can be managed right from the command line with Minion::Command::minion::job .

You can also add an admin ui to your application by loading the plugin Mojolicious::Plugin::Minion::Admin . Just make sure to secure access before making your application publicly accessible.

# Deployment

To manage background worker processes with systemd, you can use a unit configuration file like this.

# Consistency

Every new job starts out as inactive , then progresses to active when it is dequeued by a worker, and finally ends up as finished or failed , depending on its result. Every failed job can then be retried to progress back to the inactive state and start all over again.

The system is eventually consistent and will preserve job results for as long as you like, depending on "remove_after" in Minion . But be aware that failed results are preserved indefinitely, and need to be manually removed by an administrator if they are out of automatic retries.

While individual workers can fail in the middle of processing a job, the system will detect this and ensure that no job is left in an uncertain state, depending on "missing_after" in Minion . Jobs that do not get processed after a certain amount of time, depending on "stuck_after" in Minion , will be considered stuck and fail automatically. So an admin can take a look and resolve the issue.

Minion has many great features. This section is still very incomplete, but will be expanded over time.

# Priorities

Every job enqueued with "enqueue" in Minion has a priority. Jobs with a higher priority get performed first, the default priority is 0 . Priorities can be positive or negative, but should be in the range between 100 and -100 .

You can use "retry" in Minion::Job to raise or lower the priority of a job.

# Job results

The result of a job has two parts. First there is its state, which can be finished for a successfully processed job, and failed for the opposite. And second there's a result data structure, that may be undef , a scalar, a hash reference, or an array reference. You can check both at any time in the life cycle of a job with "job" in Minion , all you need is the job id.

While the state will be assigned automatically by Minion , the result for finished jobs is usually assigned manually with "finish" in Minion::Job .

For jobs that failed due to an exception, that exception will be assigned as result .

But jobs can also fail manually with "fail" in Minion::Job .

Retrieving job results is of course completely optional, and it is very common to have jobs where the result is unimportant.

# Named queues

Each job can be enqueued with "enqueue" in Minion into arbitrarily named queues, independent of all their other properties. This is commonly used to have separate classes of workers, for example to ensure that free customers of your web service do not negatively affect your service level agreements with paying customers. The default named queue is default , but aside from that it has no special properties.

For every named queue you can start as many workers as you like with the command Minion::Command::minion::worker . And each worker can process jobs from multiple named queues. So your workers can have overlapping responsibilities.

There is one special named queue called minion_foreground that you should avoid using directly. It is reserved for debugging jobs with "foreground" in Minion .

# Job progress

Progress information and other job metadata can be stored in notes at any time during the life cycle of a job with "note" in Minion::Job . The metadata can be arbitrary data structures constructed with scalars, hash references and array references.

Notes, similar to job results, can be retrieved with "job" in Minion , all you need is the job id.

You can also use notes to store arbitrary metadata with new jobs when you create them with "enqueue" in Minion .

The admin ui provided by Mojolicious::Plugin::Minion::Admin allows searching for jobs containing a certain note, so you can also use them to tag jobs.

# Delayed jobs

The delay option of "enqueue" in Minion can be used to delay the processing of a job by a certain amount of seconds (from now).

You can use "retry" in Minion::Job to change the delay.

# Expiring jobs

The expire option of "enqueue" in Minion can be used to limit for how many seconds (from now) a job should be valid before it expires and gets deleted from the queue.

You can use "retry" in Minion::Job to reset the expiration time.

# Custom workers

In cases where you don't want to use Minion together with Mojolicious , you can just skip the plugins and write your own worker scripts.

The method "run" in Minion::Worker contains all features you would expect from a Minion worker and can be easily configured with "status" in Minion::Worker . For even more customization options Minion::Worker also has a very rich low level API you could for example use to build workers that do not fork at all.

# Task plugins

As your Mojolicious application grows, you can move tasks into application specific plugins.

Which are loaded like any other plugin from your application.

# Task classes

For more flexibility, or if you are using Minion as a standalone job queue, you can also move tasks into dedicated classes. Allowing the use of Perl features such as inheritance and roles. But be aware that support for task classes is still EXPERIMENTAL and might change without warning!

Task classes are registered just like any other task with "add_task" in Minion and you can even register the same class with multiple names.

You can continue with Mojolicious::Guides now or take a look at the Mojolicious wiki , which contains a lot more documentation and examples by many different authors.

If you have any questions the documentation might not yet answer, don't hesitate to ask in the Forum or the official IRC channel #mojo on irc.libera.chat ( chat now! ).

Google Foobar 2020

Recently, a few weeks ago, I was browsing on the internet and searching for some C++ related concepts and got prompted with a link to the foobar challenge by google. This challenge acts as a recruiting tool for google. This Google foobar site allows access to questions only for people with a invite.

In this post, I’ll write about the challenge, the problems that were posed for me in the challenge and my approach.

The Google Foobar challenge consisted of 5 Levels . Level 1 consisted of a single question.                     [48 hours/question] Level 2 consisted of two questions.                               [72 hours/question] Level 3 consisted of three questions.                         [96 hours/question] Level 4 consisted of two questions.                               [15 days/question] Lastly, Level 5 consisted of one question.         [24 days/question]

.css-qybmnr{word-break:keep-all;font-size:18px;line-height:1.45;font-weight:bold;color:var(--theme-ui-colors-primary,#000);font-family:'Merriweather',Georgia,Serif;}@media (max-width:33.75em){.css-qybmnr{font-size:16px;}} Please Note : The Code Solutions In This Post Are Written Entirely In Python.

Problem a : ‘The cake is not a lie!’

Commander Lambda has had an incredibly successful week: she completed the first test run of her LAMBCHOP doomsday device, she captured six key members of the Bunny Rebellion, and she beat her personal high score in Tetris. To celebrate, she’s ordered cake for everyone - even the lowliest of minions! But competition among minions is fierce, and if you don’t cut exactly equal slices of cake for everyone, you’ll get in big trouble.

The cake is round, and decorated with M&Ms in a circle around the edge. But while the rest of the cake is uniform, the M&Ms are not: there are multiple colors, and every minion must get exactly the same sequence of M&Ms. Commander Lambda hates waste and will not tolerate any leftovers, so you also want to make sure you can serve the entire cake.

To help you best cut the cake, you have turned the sequence of colors of the M&Ms on the cake into a string: each possible letter (between a and z) corresponds to a unique color, and the sequence of M&Ms is given clockwise (the decorations form a circle around the outer edge of the cake).

Write a function called solution(s) that, given a non-empty string less than 200 characters in length describing the sequence of M&Ms, returns the maximum number of equal parts that can be cut from the cake without leaving any leftovers.

• To provide a Python solution, edit solution.py
• To provide a Java solution, edit Solution.java

Your code should pass the following test cases. Note that it may also be run against hidden test cases not shown here.

Python Cases

To solve this, The first thing I did was to visualize the problem, so as to get a better understanding. I just imagined watching a round cake from top view and assigned few letters (a,b,c,d) to different sections of it in a repeating pattern.

Now that we have visualized it. We can easily infer that, basically all we have to do is to look for repeating sub-strings in the string.

Of course, We need to keep important things in mind before we begin actually writing the code, The function would need to return 0 if the cake could not be cut without leftovers or if the string was empty. We need to identify possible M&M patterns from the input string. The pattern surely could not be longer than half the length of the string. We need to check to see if there were remainders when chopping the string with the possible patterns and discard those results.

and Voila! just like that we have completed the first Level of Foobar Challenge!

Problem a : ‘Lovely Lucky Lambs’

Being a henchman isn’t all drudgery. Occasionally, when Commander Lambda is feeling generous, she’ll hand out Lucky LAMBs (Lambda’s All-purpose Money Bucks). Henchmen can use Lucky LAMBs to buy things like a second pair of socks, a pillow for their bunks, or even a third daily meal!

However, actually passing out LAMBs isn’t easy. Each henchman squad has a strict seniority ranking which must be respected - or else the henchmen will revolt and you’ll all get demoted back to minions again!

There are 4 key rules which you must follow in order to avoid a revolt:

• The most junior henchman (with the least seniority) gets exactly 1 LAMB. (There will always be at least 1 henchman on a team.)
• A henchman will revolt if the person who ranks immediately above them gets more than double the number of LAMBs they do.
• A henchman will revolt if the amount of LAMBs given to their next two subordinates combined is more than the number of LAMBs they get. (Note that the two most junior henchmen won’t have two subordinates, so this rule doesn’t apply to them. The 2nd most junior henchman would require at least as many LAMBs as the most junior henchman.)
• You can always find more henchmen to pay - the Commander has plenty of employees. If there are enough LAMBs left over such that another henchman could be added as the most senior while obeying the other rules, you must always add and pay that henchman.

Note that you may not be able to hand out all the LAMBs. A single LAMB cannot be subdivided. That is, all henchmen must get a positive integer number of LAMBs.

Write a function called solution(total_lambs), where total_lambs is the integer number of LAMBs in the handout you are trying to divide. It should return an integer which represents the difference between the minimum and maximum number of henchmen who can share the LAMBs (that is, being as generous as possible to those you pay and as stingy as possible, respectively) while still obeying all of the above rules to avoid a revolt. For instance, if you had 10 LAMBs and were as generous as possible, you could only pay 3 henchmen (1, 2, and 4 LAMBs, in order of ascending seniority), whereas if you were as stingy as possible, you could pay 4 henchmen (1, 1, 2, and 3 LAMBs). Therefore, solution(10) should return 4-3 = 1.

To keep things interesting, Commander Lambda varies the sizes of the Lucky LAMB payouts. You can expect total_lambs to always be a positive integer less than 1 billion (10 ^ 9).

At first glance, this question seems a bit tricky. Basically, they are asking the difference between no. of Fibonacci numbers whose sum is less than total_lambs and no. of powers of 2 whose sum is less than total_lambs ( * a catch in the rule number 4).

Once we grasp the hold of the question, coming up with the solution is pretty easy.

Problem b : ‘Hey! I already did that.’

Commander Lambda uses an automated algorithm to assign minions randomly to tasks, in order to keep her minions on their toes. But you’ve noticed a flaw in the algorithm - it eventually loops back on itself, so that instead of assigning new minions as it iterates, it gets stuck in a cycle of values so that the same minions end up doing the same tasks over and over again. You think proving this to Commander Lambda will help you make a case for your next promotion.

You have worked out that the algorithm has the following process:

• Start with a random minion ID n, which is a nonnegative integer of length k in base b
• Define x and y as integers of length k. x has the digits of n in descending order, and y has the digits of n in ascending order
• Define z = x - y. Add leading zeros to z to maintain length k if necessary
• Assign n = z to get the next minion ID, and go back to step 2

For example, given minion ID n = 1211, k = 4, b = 10, then x = 2111, y = 1112 and z = 2111 - 1112 = 0999. Then the next minion ID will be n = 0999 and the algorithm iterates again: x = 9990, y = 0999 and z = 9990 - 0999 = 8991, and so on.

Depending on the values of n, k (derived from n), and b, at some point the algorithm reaches a cycle, such as by reaching a constant value. For example, starting with n = 210022, k = 6, b = 3, the algorithm will reach the cycle of values [210111, 122221, 102212] and it will stay in this cycle no matter how many times it continues iterating. Starting with n = 1211, the routine will reach the integer 6174, and since 7641 - 1467 is 6174, it will stay as that value no matter how many times it iterates.

Given a minion ID as a string n representing a nonnegative integer of length k in base b, where 2 <= k <= 9 and 2 <= b <= 10, write a function solution(n, b) which returns the length of the ending cycle of the algorithm above starting with n. For instance, in the example above, solution(210022, 3) would return 3, since iterating on 102212 would return to 210111 when done in base 3. If the algorithm reaches a constant, such as 0, then the length is 1.

Input : Solution.solution(‘1211’, 10) Output : 1

This seemed quite difficult to grasp when I first read the question, I just got puzzled with all that ’ mumble-jumble ’. So, I read the problem again, for a few times & then just started coding my way to achieve the desired results, as stated by the algorithm process above.

Please note that the functions 'dTob' & 'bTod' actually represent decimal to binary and binary to decimal conversions respectively.

With the above problems out of the way, we can actually proceed to much more interesting challenges.

Problem a : ‘Fuel Injection Perfection’

Commander Lambda has asked for your help to refine the automatic quantum antimatter fuel injection system for her LAMBCHOP doomsday device. It’s a great chance for you to get a closer look at the LAMBCHOP - and maybe sneak in a bit of sabotage while you’re at it - so you took the job gladly.

Quantum antimatter fuel comes in small pellets, which is convenient since the many moving parts of the LAMBCHOP each need to be fed fuel one pellet at a time. However, minions dump pellets in bulk into the fuel intake. You need to figure out the most efficient way to sort and shift the pellets down to a single pellet at a time.

The fuel control mechanisms have three operations:

• Add one fuel pellet
• Remove one fuel pellet
• Divide the entire group of fuel pellets by 2 (due to the destructive energy released when a quantum antimatter pellet is cut in half, the safety controls will only allow this to happen if there is an even number of pellets)

Write a function called solution(n) which takes a positive integer as a string and returns the minimum number of operations needed to transform the number of pellets to 1. The fuel intake control panel can only display a number up to 309 digits long, so there won’t ever be more pellets than you can express in that many digits.

For example: solution(4) returns 2: 4 -> 2 -> 1 solution(15) returns 5: 15 -> 16 -> 8 -> 4 -> 2 -> 1

I believe this problem statement is quite easy to grasp and doesn’t need much explanation, basically we have an input number and we have to change that number to 1, by performing any of the three operations defined above.

We have to return the minimum possible number of operations required to achieve the same.

Problem b : ‘Bomb, Baby!’

You’re so close to destroying the LAMBCHOP doomsday device you can taste it! But in order to do so, you need to deploy special self-replicating bombs designed for you by the brightest scientists on Bunny Planet. There are two types: Mach bombs (M) and Facula bombs (F). The bombs, once released into the LAMBCHOP’s inner workings, will automatically deploy to all the strategic points you’ve identified and destroy them at the same time.

But there’s a few catches. First, the bombs self-replicate via one of two distinct processes: Every Mach bomb retrieves a sync unit from a Facula bomb; for every Mach bomb, a Facula bomb is created; Every Facula bomb spontaneously creates a Mach bomb.

For example, if you had 3 Mach bombs and 2 Facula bombs, they could either produce 3 Mach bombs and 5 Facula bombs, or 5 Mach bombs and 2 Facula bombs. The replication process can be changed each cycle.

Second, you need to ensure that you have exactly the right number of Mach and Facula bombs to destroy the LAMBCHOP device. Too few, and the device might survive. Too many, and you might overload the mass capacitors and create a singularity at the heart of the space station - not good!

And finally, you were only able to smuggle one of each type of bomb - one Mach, one Facula - aboard the ship when you arrived, so that’s all you have to start with. (Thus it may be impossible to deploy the bombs to destroy the LAMBCHOP, but that’s not going to stop you from trying!)

You need to know how many replication cycles (generations) it will take to generate the correct amount of bombs to destroy the LAMBCHOP. Write a function solution(M, F) where M and F are the number of Mach and Facula bombs needed. Return the fewest number of generations (as a string) that need to pass before you’ll have the exact number of bombs necessary to destroy the LAMBCHOP, or the string “impossible” if this can’t be done! M and F will be string representations of positive integers no larger than 10^50. For example, if M = “2” and F = “1”, one generation would need to pass, so the solution would be “1”. However, if M = “2” and F = “4”, it would not be possible.

From the first look, what I can infer is that I basically have to find the number of subtractions that are required to find the Greatest Common Divisor of M & F.

Problem c : ‘Queue To Do’

You’re almost ready to make your move to destroy the LAMBCHOP doomsday device, but the security checkpoints that guard the underlying systems of the LAMBCHOP are going to be a problem. You were able to take one down without tripping any alarms, which is great! Except that as Commander Lambda’s assistant, you’ve learned that the checkpoints are about to come under automated review, which means that your sabotage will be discovered and your cover blown - unless you can trick the automated review system.

To trick the system, you’ll need to write a program to return the same security checksum that the guards would have after they would have checked all the workers through. Fortunately, Commander Lambda’s desire for efficiency won’t allow for hours-long lines, so the checkpoint guards have found ways to quicken the pass-through rate. Instead of checking each and every worker coming through, the guards instead go over everyone in line while noting their security IDs, then allow the line to fill back up. Once they’ve done that they go over the line again, this time leaving off the last worker. They continue doing this, leaving off one more worker from the line each time but recording the security IDs of those they do check, until they skip the entire line, at which point they XOR the IDs of all the workers they noted into a checksum and then take off for lunch. Fortunately, the workers’ orderly nature causes them to always line up in numerical order without any gaps.

For example, if the first worker in line has ID 0 and the security checkpoint line holds three workers, the process would look like this:

where the guards’ XOR (^) checksum is 0^1^2^3^4^6 == 2 .

Likewise, if the first worker has ID 17 and the checkpoint holds four workers, the process would look like:

All worker IDs (including the first worker) are between 0 and 2000000000 inclusive, and the checkpoint line will always be at least 1 worker long.

With this information, write a function solution(start, length) that will cover for the missing security checkpoint by outputting the same checksum the guards would normally submit before lunch. You have just enough time to find out the ID of the first worker to be checked (start) and the length of the line (length) before the automatic review occurs, so your program must generate the proper checksum with just those two values.

and with that out of the way, we have finally now succesfully completed Level 3 of the Foobar Challenge.

Let’s get some rest and we’ll move to much more interesting & ‘mind-boggling’ challenges, afterwards.

To be updated…

Join my mailing list and get notified about new blogs.

Be the first to receive my latest content with the ability to opt-out at anytime. Of course, I promise that I won't spam your inbox or share your email with any third parties.

More articles from Ishan Sharma

2023 - Year In Review

A look back at the highs and lows of 2023, and the lessons I've learnt along the way

The Culinary Code - From bytes to bites

From novice to kitchen enthusiast – my culinary journey in Bangalore. Unexpected delights and flavorful discoveries

Minion Work Assignments - Python

• # Minion Work Assignments
• # =======================
• # Commander Lambda's minions are upset! They're given the worst jobs on the whole space station, and some of them are starting to complain that even those worst jobs are being allocated unfairly. If you can fix this problem, it'll prove your chops to Commander Lambda so you can get promoted!
• # Minions' tasks are assigned by putting their ID numbers into a list, one time for each day they'll work that task. As shifts are planned well in advance, the lists for each task will contain up to 99 integers. When a minion is scheduled for the same task too many times, they'll complain about it until they're taken off the task completely. Some tasks are worse than others, so the number of scheduled assignments before a minion will refuse to do a task varies depending on the task. You figure you can speed things up by automating the removal of the minions who have been assigned a task too many times before they even get a chance to start complaining.
• # Write a function called solution(data, n) that takes in a list of less than 100 integers and a number n, and returns that same list but with all of the numbers that occur more than n times removed entirely. The returned list should retain the same ordering as the original list - you don't want to mix up those carefully-planned shift rotations! For instance, if data was [5, 10, 15, 10, 7] and n was 1, solution(data, n) would return the list [5, 15, 7] because 10 occurs twice, and thus was removed from the list entirely.
• # # 1st attempt (tests 5, 7, and 9 fail)
• # from collections import defaultdict
• # def solution(data, n):
• #     count = defaultdict(int)
• #     for num in data:
• #         count[num] += 1
• #     return [k for k, v in count.items() if v <= n]
• # # ChatGpt (GPT 3.5) (tests 5, 7, and 9 fail)
• #     # Create a dictionary to count the occurrences of each number in the list
• #     count_dict = {}
• #     # Count occurrences of each number in the list
• #         if num in count_dict:
• #             count_dict[num] += 1
• #         else:
• #             count_dict[num] = 1
• #     # Use a list comprehension to filter out numbers that occur more than n times
• #     filtered_data = [num for num in data if count_dict[num] <= n]
• #     return filtered_data
• # # 2nd attempt (tests 5, and 9 fail)
• # from collections import OrderedDict
• #     d = OrderedDict()
• #     for i in data:
• #         d[i] = d.get(i, 0) + 1
• #     return [k for k, v in d.items() if v <= n]
• # 3rd attempt (all tests pass)
• from collections import Counter
• def solution ( data , n ) :
•     count = Counter ( data )
•     return [ i for i in data if count [ i ] <= n ]
• assert solution ( [ 5 , 10 , 15 , 10 , 7 ] , 1 ) == [ 5 , 15 , 7 ]
• assert solution ( [ 1 , 2 , 3 ] , 0 ) == [ ]
• assert solution ( [ 1 , 2 , 2 , 3 , 3 , 3 , 4 , 5 , 5 ] , 1 ) == [ 1 , 4 ]
• Itemtime Stream #2 C# | 2 min ago | 5.74 KB
• CHART LABELS RANK PERCENTILE for Thinkorswim C++ | 4 min ago | 3.91 KB
• Online Offline Semua Script JSON | 28 min ago | 0.05 KB
• 🤑 G2A.com Free Gift Card Guide Jun 2024 FIX 🎁 GetText | 34 min ago | 0.36 KB
• 🤑 G2A.com Free Gift Card Guide Jun 2024 FIX 🤑 GetText | 35 min ago | 0.39 KB
• ❤️G2A.com Free Gift Card Guide June 2024 Fix🎁 Python | 46 min ago | 0.38 KB
• 💸G2A.com Free Gift Card Guide 2024 May🚀 Python | 46 min ago | 0.34 KB
• keys JSON | 1 hour ago | 0.51 KB

Navigation Menu

Search code, repositories, users, issues, pull requests..., provide feedback.

We read every piece of feedback, and take your input very seriously.

Saved searches

Use saved searches to filter your results more quickly.

To see all available qualifiers, see our documentation .

• Notifications You must be signed in to change notification settings