DEV Community: Rodion Gorkovenko

Any programming challenges with money prizes?

Rodion Gorkovenko — Sat, 16 Sep 2023 07:39:20 +0000

I remember eons ago there were TopCoder which held contests with some money prizes perhaps twice per month, and sometimes marathon games, which ran longer. Then there also were Google-Ai-Challenges, but they were rare...

What is happening nowadays? What coding challenges (sites or events) do you know which offer monetary rewards?

Do you code Games?

Rodion Gorkovenko — Fri, 06 Mar 2020 17:34:18 +0000

Hi Friends!

The question is in the title: do you code games, at least sometimes? Sorry, but it is very short post :)

I can elaborate, however. It's not necessarily about polished-finished games, like silly mobile "jump-jump for the stars" with rich graphics and sound.

Perhaps you code some basic pen-and-pencil games as an exercise, or even puzzles (not necessarily tic-tac-toe, but similar). Or small logic turn-based ones (like evade zombies, travel the maze etc). Perhaps you spent a week to write the code, then play for 20 minutes and forget about it :)

Do you put more attention to game logic - or to look-n-feel and sound? What have you coded, please, feel free to share links if you have something at hand!

Personality Swap - new problem based on Futurama episode

Rodion Gorkovenko — Thu, 05 Mar 2020 17:42:29 +0000

One of episodes of Futurama series (Prisoner of Benda) is about personality-swapping machine - it can exchange two people's bodies, but only once for each given pair.

This makes quite a problem about returning personalities to their bodies. You may test your algorithmic skills trying to solve it :)

Personality Swap @ CodeAbbey

Tesla Hack shows how far AI is from being really intelligent

Rodion Gorkovenko — Thu, 20 Feb 2020 21:34:57 +0000

Recent news about successful "Hack" of Tesla car. It's system of computer vision / optical recognition catches images of road signs to provide "auto-pilot" function. Researches modified shape of the character in speed limit sign (see picture below) and Tesla misread it as 85 instead of 35, while it seems obvious human brain/eye can't make such a mistake.

What does it mean?

We are surrounded nowadays bu "smart" things, including smart tooth-brushes and smart toilet-seats. We are made to believe that computer brain nowadays can do wonders.

But it's not exactly so. Even not close.

During last 50 years humankind come up with many clever (even whimsical) algorithms which allow computers to outperform human brain in many tasks. Siri can find you nearest toilet or correct spelling of any word. Some "robo-babes" can politely talk to audience - while Boston Dynamics robo-dogs open doors by pressing handles - and this impresses!

Nevertheless we still have quite vague idea of how the human brain works and learns. We can teach computer to self-learn in some field (e.g. decision making in some game) - or to extract information about "diapers and beer" from sales logs.

We can teach it letters and digits - but suddenly it appears the underlying algorithm "classifies" them in different, more primitive manner than human. Consider, for example, how dogs recognize other dogs despite being of very different breed, even if never seeing anything alike. Computer (e.g. Neural Network) can't extrapolate knowledge in this way.

And so, in 2020, most of breaking news about using AI, ML, NN or GA anywhere from automotive industry to crime investigation generally has strong smell of marketing. Still those algorithms are clever math functions and methods which astonishingly can achieve goal in many cases - and surprisingly fail in many other cases!

So don't be easily fooled by hype-words. We still have very long way to make machines "clever" in general sense of word. Though still it seems possible.

try Scheme instead of JavaScript for UI

Rodion Gorkovenko — Thu, 20 Feb 2020 17:23:29 +0000

In this tutorial we'll try create animation
LIKE THIS (Bunny image bouncing inside rectangular DIV) - using funny language Scheme instead of JavaScript.

Why trying Scheme?

Besides being fun and with curious syntax, it greatly influences your coding style. It is very hard to write bad code in Scheme/LISP because
you'll get lost in the heaps of parentheses. So it makes you arranging code in small and clever functions (we call it "decomposition").

Also, if you go in depth, it teaches a lot about functional programming, especially with its list data types.

What is Scheme

Scheme is functional language with very simple syntax. It is one of main branches of LISP - which is the oldest language still being used widely enough. (Fortran is older, but not used that much nowadays) If you heard of Clojure, Guile, Common Lisp - you know they are variants.

It looks like this:

(alert (+ 5 8))

Note two things:

all language constructions are simply made of list elements inside parentheses, or round brackets, i.e. ( ... )
all function names and operators are put immediately after opening bracket

So our example simply calculates sum of 5 and 8 and shows it with browser alert box (it is for browser version, of course)

We will use Scheme implemented in JS, called BiwaScheme - as we want it for UI tasks. You can try the expression above in the interpreter on this page.

Let's start - Page Setup

I'll do everything in single html file, for clarity - though you can split it later, of course. Let's make <div> with <img> of the bunny inside:

<div id="field">
    <h1>Heeey, I'm Bouncing Bunny!</h1>
    <img id="bunny" src="https://codeabbey.github.io/js-things/bunny/bunny2.png"/>
</div>

And add some coloring and form (you may see, final demo fits any window, but for now let's use fixed size of the DIV):

<style>
    body {
        background: gray;
        text-align: center;
    }
    #field {
        background: cyan;
        margin: 0px auto;
        position: relative;
        width: 640px;
        height: 480px;
    }
    #bunny {
        position: absolute;
        height: 100px;
    }
</style>

At last let's add some stub for script with Scheme. You see, we use biwascheme.js (release from the site mentioned above) in src attribute and the code itself inside tags (which is a bit unorthodox) - but that's not the only method. This code will find H1 element and set its color to red, just as we can do it with jQuery:

<script src="https://codeabbey.github.io/js-things/biwascheme.js">
(set-style! (get-elem "h1") "color" "red")
</script>

Put all three snippets into file and check if it works.

You should see something like this.

Variables and Bunny positioning

Global variables are not very good in functional code, but the task of animation is also not very "functional" one, so let's add X and Y to mark current position of the bunny. This and all the following should be put inside <script> stub we created above:

(define x 0)
(define y 0)

Now we also would like to have some auxiliary variables - to hold field and bunny DOM objects - and also for sizes of the field (while sizes of bunny are not calculated before image is loaded, we'll work around this). For such things we have several simple functions which are not in standard Scheme, but were added in BiwaScheme for interoperability with JavaScript:

(define field (getelem "#field"))
(define fieldW (element-width field))
(define fieldH (element-height field))

(define bunny (getelem "#bunny"))

At last let's add function for setting coordinates of the Bunny - and add test-call to it, to check it works. It works just by assigning top and left styles of the bunny element we got above:

(define (bunnyMove left top)
    (set-style! bunny "left" left)
    (set-style! bunny "top" top))

(bunnyMove 50 50)

This code doesn't have a lot of observable changes compared to previous step - but the bunny should be off the center line to prove coordinates and moving works really.

See here how it should look, please.

Timer and Movement

So now we need to setup something like setInterval(...) to change coordinates over time and update bunny position. Final example uses requestAnimationFrame instead, but let's go on with timer now for simplicity. BiwaScheme includes simple analog of setInterval:

(set-timer! updatePosition 0.05)

Here set-timer! specifies delay in seconds (so it is 0.05, i.e. 50ms - 20 frames per second). We are going to call updatePosition function on timer ticks. But we need to add it of course:

(define updatePosition
    (lambda ()
        (set! x (+ x 1))
        (set! y (+ y 1))
        (bunnyMove x y)))

Here we see that syntax for defining function is the same as for variable - we just assign lambda-function (with no arguments) to the updatePosition variable. Scheme also has simplified syntax for the same, as you can see in bunnyMove definition.

Add these snippets to the end of your script and see - bunny should start moving, though ignoring bounds of the field.

Look here for example, please...

Regard Borders and Speed-up

To make Bunny respect borders of the field, we'll need to teach it changing direction. For this we should add something instead of 1 to its
coordinates. Let's create variables for vertical and horizontal speed, and use it in updatePosition:

; put this below x, y definition
(define vx 2)
(define vy 2)

; and later...
(define (updatePosition)
    (set! x (+ x vx))
    (set! y (+ y vy))
    (bunnyMove x y))

Now we just need to check inside the updatePosition for following conditions:

if bunny reaches bottom, i.e. y >= field_height - bunny_height - then switch vy to negative
if bunny reaches top, i.e. y <= 0 - then switch vy back to positive
make two similar checks for x coordinate

(define (updatePosition)
    (if (>= y (- fieldH (element-height bunny))) (set! vy -2))
    (if (>= x (- fieldW (element-width bunny))) (set! vx -2))
    (if (<= y 0) (set! vy 2))
    (if (<= x 0) (set! vx 2))
    (set! x (+ x vx))
    (set! y (+ y vy))
    (bunnyMove x y))

Note that we call function to calculate bunny size every time. This is workaround because we couldn't get it until bunny image is loaded. Of course it could be done in more clever way, but let's keep it simple.

Surprisingly, that's all! Now bunny should bounce of all 4 borders.

Look how it works in the last example

Conclusion

So we see, Scheme looks not too bad when dealing with JavaScript tasks! I can't tell for sure how good it is with larger programs - I just decided to try it myself.

The "final" version of the code, linked at the beginning of this post, is slightly advanced - adapting to various screen sizes and using requestAnimationFrame and time deltas. You may study it, but probably it is too obvious and you even know how to do this better.

I hope that even if you won't write much in LISP/Scheme - you still can try it for amusement, and to learn a bit more about different programming languages!

Thanks for reading that far and Happy Coding!

I award free Certificates at CodeAbbey, Ask Me Anything!

Rodion Gorkovenko — Wed, 19 Feb 2020 15:24:46 +0000

In the fall of 2013 I started building my small web-site with programming problems - CodeAbbey. Soon it become obvious that most users fall off after solving from 5 to 20 tasks - but few are very persistent, doing over 100 and sometimes reaching the top.

So I started awarding free Certificates for solving certain amount of tasks (now 145 - read more). They have unique numbers so they could be checked at user's profile page - or added to LinkedIn by link. Depending on skill some people reach this in a month while others in a year or two...

It appears, people like them - even so that some tried to cheat :) Though it is annoying to verify pretenders' solutions manually, I'm on the other hand usually feel very pleased by such devotion.

I don't mean you need immediately join us :) As these certificates are just funny things and not recognized officially by any University or Company, of course. I just have come to boast a bit, since I'm somewhat proud of this idea of motivating people anyway!

Here is example of certificate for some outstanding colleague:

Finding best post time on DEV (improved version, with PHP)

Rodion Gorkovenko — Wed, 19 Feb 2020 14:30:35 +0000

I explained recently how we can find the hour of the day, in which more posts here at DEV are created. That post was rather exercise in bash.

Let's try to figure out at what hour of the day it is better to publish post to get better chance of reaction and comments - for this I'll refine the code and do this in PHP this time. Python may be better when whimsical analytics is necessary - but in this case I prefer PHP for its simple functions to retrieve and parse json.

Recap

As a brief reminder - we can fetch random articles from DEV API in JSON format and analyze various fields here, extracting time of creation etc. Upon retrieving many articles we can judge at what time there are more users on site. The API link for articles is

https://dev.to/api/articles/

What improvements

Let us use hour of publishing rather hour of creation (i.e. when users first see the article).
Let's not just count how many articles are published in given hour, but add bonus points for articles having enough reactions or comments.

Let's start

Main loop of the script is like this - we get top article ID from env this time (you've seen we can take it from API itself instead - but now I want some manual control). Then we pick some random articles with ids between this one and 32000 earlier. Some of them do not exists (perhaps were removed). Others we can count:

<?php

$max = getenv('MAX'); // 263822
$url = 'https://dev.to/api/articles/';

$count = 0;

while ($count < 100) {
    $id = $max - rand(0, 32000);
    $resp = @file_get_contents($url . $id); // sending HTTP get to API
    if ($resp === false) {
        echo "$id - error\n";
        continue;
    }
    $json = json_decode($resp);
    $pub = $json->published_at;  // not created_at!
    $hour = substr($pub, 11, 2); // date format is 2020-01-02T11:22:33Z
    $count += 1;
    echo "$id -> $hour\n";
}

This code will print article IDs we have tried - and either hour of publishing, or word error.

Let's add an array of flags to mark which IDs we have already tried, so we don't repeat:

$seen = array();

//... and in the loop
while ($count < 1000) {
    $id = $max - rand(0, 32000);
    if (isset($seen[$id])) {
        continue;
    }
    $seen[$id] = true;
//...

And counters for every hour:

$hours = array_fill(0, 24, 0);

    //... and inside loop
    $hours[$hour + 0] += 1;

At the end we can print out results (you can do pretty chart of course):

echo implode(" ", $hours) . "\n";

Ok, the code will work. You can try it and see distribution of article publishing hours. But that's not exactly what we want!

Bonus for reactions and comments

Now we add 1 point for every article published in given hour. Let's add 1 bonus point if that article has over 5 comments, for example - and another 1 bonus point if that article has at least one comment.

    $cmn = $json->comments_count;
    $rct = $json->positive_reactions_count;
    $hours[$hour + 0] += 1 + ($cmn > 0 ? 1 : 0) + ($rct > 10 ? 2 : 0);

Of course you can change these thresholds and assign different bonus values. I won't spoil you fun of doing this small research yourself - but in general you can get distribution similar to one shown above.

Good luck and happy coding to everyone! Thanks for reading that far!

Loop detection - Google interview question

Rodion Gorkovenko — Tue, 18 Feb 2020 20:53:58 +0000

My friend (really former student) wrote me about interview he had recently - as I understand for "intern QA" position at some of Google departments (probably Adwords/Adsense but not sure). One of the questions puzzled him the most, though I think it was more due to slight panic, rather than difficulty. Here I'll share this question and then put few details he told about interview itself for those curious.

Detecting Loop in Numeric Sequence

It was a kind of brief "practical exercise" after long "theoretical part". Fellow was proposed to write small snippet of code in Python or Java (languages he manifested to know).

Suppose, we develop function, which on every call yields some number (it is ok to think of it as of random generator) - and we need to check how many calls we can do until sequence starts to repeat.

I.e. we want to:

make sure sequence won't enter loop (repetitions) too soon;
if possible, tell at which step it enters loop and how many steps loop take.

Some "fake" example of such function was provided (it was not remembered well, but by his recollections I reconstructed it as von Neumann random generator with improvement:

x = ... # some starting value, e.g. 1776

n = 100
nn = n * n
w = 0
s = nn // 2 - 1917

def next_num():
    w = (w + s) % nn
    x = ((x * x + w) // n) % nn
    return x

Now what my friend was proposing and their objections:

Let us create dict and put every value x into it, and after each call check, if new x is in this dict already. (they pointed out the state of sequence depends on w either - but this is rather minor detail)
Let's do the same, but use tuples (x, w) as keys of our dict. (they said it works for n = 100 but he should increase to n = 10000 - his program was not ending)
He said program is not finishing because of too large number of iterations. However they explained it is about nn iterations and so would end in a few minutes unless something bad happens.
After some thought he understand dict becomes very large (up to 100 mln elements here) - and process takes all memory and (as I suppose, hits the swap and performance degrades greatly).
He offered to save memory, by replacing tuples with w * nn + x and using bitset instead of dict.

They agreed it is workaround, but said with n = 100000 or more program anyway may eat up all memory. I thought it may too long to calculate to be reasonable anyway - but then thought, this could be rewritten in Go or Java with 10 mln iterations per second speed - so running time may be about hour, not too long to be "unreasonable".

So he was told though he did well enough, they expected solution which won't depend on having gigabytes of memory.

What is your opinion? I think I understand what they mean. My idea is described in the end of this post.

About Interview

This happened in Google office in Canada (haven't asked where exactly but perhaps it could be googled), this fellow moved here with his parents year ago and completed education here or something like this. They had some Google employees visiting their college (?) and telling about possible internship or something like this. I believe there was some application process and eventually he was invited for interview.

Interview had the following parts:

many questions about languages he said he know (Java, Python) - though only about standard libraries and syntax, no tools, frameworks etc
few very shallow questions about other technologies, mainly SQL and HTML - i.e. checking "general understanding" about them
logic puzzles (I believe at least some are well-known, e.g. "how to put digits on two dice so that any day number between 01 and 31 could be represented)
practical exercise (single question, as described above)

I'm not sure about order of all other parts, but he said they, besides exercise, took somewhat over 1 hour and then exercise was the last and he spent "almost hour" on it solely.

He haven't shared anything about interview results yet - I suppose he have no response still.

My idea

Here it is, encoded in ROT13 (google to decode if you don't know it) - just to avoid you seeing it unintentionally and spoiling your fun.

Jr arrq gb fgber pheerag (j,k), gura eha sbe x vgrengvbaf, vs jr qba'g rapbhagre gur fnzr, jr fgber arj pheerag (j,k) naq eha sbe x*2 vgrengvbaf, naq fb ba - fb jr qba'g eryl ba qvpg ohg gel qrgrpgvat ybbc ol fvatyr "fgngr", vg znl gnxr gjb gvzrf zber vgrengvbaf, ohg jr fnir gvzr ba trggvat evq bs qvpg.

Ads or Donations - what you prefer to gain money with your site?

Rodion Gorkovenko — Sun, 16 Feb 2020 06:39:18 +0000

After you get, say, your first steady 1000 daily pageviews with your web-site, you become curious - is there a way to make some profit from it?

At least to return money paid for hosting, domain name etc.

If you have some experience in this - please share! If not - welcome to read about mine :)

results of survey about ads - people either hate them or block them

Approach tried - Ads from Google

So I started thinking about CodeAbbey - my hobby web-site with coding exercises - after about a year and half after its start.

I read about Google Adsense and after some efforts added small ad banner to top-right corner, shown on most of pages. I just didn't want to annoy my users with something larger. However even with this I found that:

only about half pageviews load ads - obviously many people use ad-blockers!
my users are of specific category - mostly techies and many of them studying - who don't pay much attention to ads at all
some ads are quite inappropriate, silly or embarrassing, especially on mobile (so I switched them off on mobile);
in total, return is small - in best times it generated about 10-15 bucks per month (with hosting currently about 13 per month);
during last one or two years ads have become even more silly and their revenue dropped to about 7-8 per month.

That's just ain't no good! Of course Google Adsense proposes "to improve your revenue" by putting large (half-screen) ads on pages, but I feel it will look like "damned boolsheet" for our users. And we value our users more than few bucks, right? :)

Considering Donations

So currently I'm thinking about turning off ads at all and switching to donations. I previously had few occasional transfers from some kind people - notably one fellow affectionately sent me $100 after he have impressed his opponent while being interviewed for some developer job - by showing his profile at my site and explaining solution of some advanced tasks.

I've tried survey about people's feeling and it seems to be favorable:

However there seem to be several things to care about yet:

seemingly I need "business"-type account at paypal - correct me if I'm wrong
and as I'm going to send some small gifts (mugs, t-shirts) in case of too generous donations - it is important to get notified timely - and arrange some way of asking people for their postal address
and obviously it is important to come up with some design for any gift postcards, mugs or t-shirts - and find out where to produce them and how to pack them.
last but not least, I'm sure I'll need to figure out how to properly pay taxes according to our local laws (taxes from normal salary in our country are deducted automatically and we never need to care of this).

So I'm still working to this switch. If you have any advice - please share!

Detecting DEV peak hours via API (bash study)

Rodion Gorkovenko — Sat, 15 Feb 2020 19:23:19 +0000

It may be interesting, when there are more people reading DEV - for example, perfect timing is important for those who is obsessed with idea to get more likes and comments, right? :)

example of histogram produced as result of experiments described below

Let's do a simple exercise of collecting stats - for example from DEV, though this could be used for most similar sites and forums. I will use bash for amusement, and because it is useful to know more about it. Though you can easily do all steps in other language (Python or PHP will suit best in my opinion). You may briefly refer to my previous post about coding projecteuler problem in bash if you are not well acquainted with this popular linux command line processor.

Plan is like this:

few words about DEV API at all
getting max id (or total amount) of articles
getting about 100 random articles before this id
collecting their publication hours
and making small chart of it

Few words about DEV API

This wonderful site has REST API - simply urls which return JSON with data about articles, users, comments etc. A bit of documentation could be found here but it is quite incomplete. Luckily, we can also refer in the source code, particularly here.

Root for API is at dev.to/api. For example, let's look at endpoint listing articles...

Getting total number of articles

Open the link https://dev.to/api/articles in your browser. You'll see JSON, obviously - array containing articles data.

[
    {
        "type_of":"article",
        "id":261930,
        "title":"An Open..."
        //...
    },
    { /*... another article data*/ },
    //...
]

Note, we have several latest articles returned. And each has numeric id, so seemingly now DEV hosts over 200k articles.

Now I want to make request from command line, which will return me just this number. I do requests with curl tool. Try running following commands, one by one:

curl https://dev.to/api/articles/

curl https://dev.to/api/articles/ | grep -oP '(?<=\"id\"\:)\d+'

curl https://dev.to/api/articles/ | grep -oP '(?<=\"id\"\:)\d+' | head -n 1

What's happening? The first line is very simple - curl fetches json data from API endpoint - and dumps them to console. Second line redirects this output to grep tool, which applies regular expression to find all "id"=1234567 fragments and prints only numeric ids, one per line (a bit about it further). The third line applies yet another command to the produced list of ids - head just takes several top lines (one in this case).

What this regular expression means? Look at the end, we search for sequence \d+ which means "digit, repeated 1 or more times". Before this fragment should be something enclosed in (?<=...) pattern, called "look-behind". I.e. we shall find only those digits, which are preceded by \"id\":, though this prefix is not included into "matching" part.

So at last let's put this single top id number into variable:

total=$(curl https://dev.to/api/articles/ | grep -oP '(?<=\"id\"\:)\d+' | head -n 1)

Commands inside $(...) are executed and their output is stored into variable total.

Getting single article by ID

Now we are going to fetch about 100 random articles. For this we are going to take random number with $RANDOM function, subtract it from max id and fetch specific article by this id.

To get article by id we just add this id to the link used above, e.g.
https://dev.to/api/articles/123456 - note here we get not array, but single object describing an article:

{
    "type_of":"article",
    "id":123456,
    //...
    "created_at":"2019-06-13T14:31:50Z"
}

The object includes creation timestamp, we'll use it bit later. For now let's complete the code which fetches 100 articles at random:

i=0
while [[ $i -lt 100 ]] ; do
    random_id=$(($total - $RANDOM))
    atext=$(curl -sf https://dev.to/api/articles/$random_id)
    if [[ $? -eq 0 ]] ; then
        i=$(($i + 1))
        echo "$random_id - ok"
    else
        echo "$random_id - FAIL"
    fi
done

We don't use received text yet - just print out whether article could be loaded or not. Some fails with 404 (which could be checked manually) - seemingly they were saved to draft and never published or deleted afterwards.

If you want run this snippet right now, I recommend changing 100 to 10 for test purposes - otherwise it may take significant time.

Collecting timestamp data (hour)

So we have json for every article in atext variable. Let's extract created_at or more precisely the hour part of this field only. Instead of grep let's try sed - another cool default command, just for practice. It works like this, let's redirect curl output to it:

curl https://dev.to/api/articles/246755 | sed -r 's/.*created_at\"\:\".{11}(..).*/\1/'

Here sed just does substitution by regexp. Regexp is made so that it captures whole document (thanks to .* at start and end) with created_at\"\:\".{11}(..) fragment inside. In this fragment we skip quotes, semicolon, then 11 symbols (like 2020-01-02T) and capture two symbols with parentheses. We use the value of the first (and only) captured group with \1 reference to replace whole string. So output is like 20 - i.e. hour part.

We add such line in our script (under if) in the form:

hour=$(echo "$atext" | sed -r 's/.*created_at\"\:\".{11}(..).*/\1/')

A kind of histogram

Now we want to collect results into array. Let's initiate array with 24 zeroes - and we'll increment the element corresponding to given hour on every article found:

result=($(for i in {0..23}; do echo 0; done))   # creates 24 zeroes
# ... and below in the loop
result[$hour]=$(($result[$hour] + 1))

I will leave to yourself to figure out how to pretty-print histogram, like one shown at the beginning of the article. Simplified code, as a shell file could look like one below. It simply prints counters for every hour:

#!/usr/bin/env bash

arts=`curl https://dev.to/api/articles`
total=`echo "$arts" | grep -oP '(?<=\"id\"\:)\d+' | head -n 1`

result=($(for i in {0..23}; do echo 0; done))
i=0
while [[ $i -lt 100 ]] ; do
    random_id=$(($total - $RANDOM))
    atext=$(curl -sf https://dev.to/api/articles/$random_id)
    if [[ $? -eq 0 ]] ; then
        i=$(($i + 1))
        hour=$(echo "$atext" | sed -r 's/.*created_at\"\:\".{11}(..).*/\1/')
        hour=$(echo $hour | sed 's/^0//')
        (( result[hour]++ ))
        echo "$random_id - ok, $hour ($i)"  # remove leading zero
    else
        echo "$random_id - FAIL"
    fi
done

for i in {0..23} ; do
    echo "$i: ${result[i]}"
done

Conclusion

This is rather introductory material. You may at once see several things to improve:

we should check that randomly chosen pages have no repeating ids
requests are taking few seconds and often fail, so it would be better to learn running them in parallel
most active hours probably are not determined by just the hours when articles were created - probably it is better to regard only those articles, which have enough comments and likes
we can also use authorization for API (don't know yet if this affects speed).

Thanks for reading so far, and excuse me for bash - probably further experiments with API I'll publish using PHP/Python!

Is DEV skewed to web-dev mainly? Are you in for something else?

Rodion Gorkovenko — Thu, 13 Feb 2020 16:47:59 +0000

Hi Friends!

I enjoy being here, at dev.to for some time already. By and by I start wondering - is it really so, that most posts here are about web-dev (and even more so - many of them about frontend, UI) - or it's just a kind of hallucination?

Drop a note, if not secret, if your interests are in programming-related but different fields, e.g.:

Mobile development - I really don't see that many posts like "Is Kotlin the best for Android development" or "Have you heard about yet another cross-platform tool for iPhones and Android both".
Computer Science - I've seen here such tag, but usually it is used along with some introductory level stuff only, like "Learn about Stack and List in 2020" which looks amusing :)
Embedded Development - where are all those discussions like "Forget about your Arduino and start doing it with STM32 like a pro".
Competitive Programming - and all those who knew what is Facebook Hackercup, Google Code Jam, TopCoder and CodeForces.
Whatever I may forgot which is not about web-dev - popular branches of Data-Science and Data-Engineering, some Scientific-related programming, Robotics etc.

P.S. Be sure I don't mean it is wrong to be more dedicated to web-dev. It is the field where zounds of projects are nowadays, so it is quite ok. I'm just curious. Thanks! :)

Hacking Random Generator (linear congruential generator)

Rodion Gorkovenko — Wed, 12 Feb 2020 20:56:05 +0000

New problem: Cracking "LCG" Random Generator @ CodeAbbey

Default random generators in some languages (Python, PHP7, JavaScript) switched to XorShift or Mersenne Twister. However in others - most notably, Java and linux/posix rand used in C/C++ - it still uses linear congruential generator in very simple form:

X_next = (A * X_cur + C) % M

The new problem at CodeAbbey is dedicated to exercise of hacking such generator. I.e. about predicting next results after observing few first ones.

This both helps to get better understanding of modular arithmetic - and to remember that default random generators shouldn't be used for hashing or encrypting sensitive data - or building online casinos :)