Forem: Lautaro Lobo

How to Install GCC on Windows with w64devkit

Lautaro Lobo — Mon, 16 Feb 2026 16:18:09 +0000

In this post, I’ll go over the process of installing w64devkit, launching its pre-configured environment, and using gcc to compile and run your C programs with some basic flags. Let’s get started!

Installing w64devkit

w64devkit provides an environment to run GCC without the hassle of complex installations.

Download w64devkit from the official GitHub releases page
Look for the most recent release and download the .zip archive. This archive contains everything you need.

You might see .exe installers, but for portability and simplicity, use the .zip file.

Next, extract all the contents of the downloaded .zip file into your chosen folder (could be Downloads, Documents, a new folder you create…).

That’s it! There’s no further setup or complex installation routines.

Opening Your Local Development Environment

With w64devkit extracted, you now have a self-contained environment ready to use.

Locate w64devkit.exe within the folder where you extracted w64devkit (e.g., C:\w64devkit\w64devkit.exe).

Double-click on w64devkit.exe. This will open a pre-configured terminal window. This terminal is a MinGW64 shell.

Once the w64devkit terminal is open, you’ll want to navigate to the directory location where your C source files are. Use the standard cd (change directory) command. For example, if your C project is in C:\Users\YourUser\Documents\MyCProject, you would type:

cd /c/Users/YourUser/Documents/MyCProject

Remember to use forward slashes (/) for paths, as usual in Unix-based shells.

Compiling and Running Your C Program with GCC

Once your environment is ready and you’re in your project directory, the final step is to compile and run your C code.

gcc is the workhorse for compiling C (and C++) code. Its primary job is to take your source code files (.c or .cpp) and turn them into an executable program.

For a simple program, you might use a command like this:

gcc main.c -o main_executable

Here, main.c is your source file, and -o main_executable tells gcc to name the resulting executable main_executable.exe.

Understanding GCC Flags

gcc comes with a lot of flags to help catch errors at compilation time and enforce good practices. Here are some of the most common:

-Wall : This flag stands for “Warning all.” It enables a comprehensive set of warning messages that help you catch potential issues. These aren’t strict errors, but they often point to logical flaws or common programming mistakes that could lead to bugs.
-Wextra : Going a step beyond -Wall, this flag enables even more warnings, often related to niche but still important programming pitfalls. Combining -Wall and -Wextra provides excellent coverage.
-Werror : This is a critical flag for professional development. It treats all compiler warnings as errors. This means if your code triggers even a single warning, the compilation process will fail. This will force you to address every potential issue, leading to more robust and reliable software.
-std=c99 : This flag specifies the C programming language standard to use. c99 refers to the 1999 ISO C standard, which is widely adopted and provides a good balance of features and compatibility. Using a specific standard ensures your code is portable and behaves consistently across different compilers.
-o <output_executable> : As mentioned before, this flag allows you to name the output executable file explicitly. If omitted, gcc will default to a.exe (or a.out on Linux/macOS).

Putting It All Together

For a typical project involving different source files, like a peak_finder algorithm, combining these flags gives you a powerful compilation command:

gcc -Wall -Werror -Wextra -std=c99 main.c array_helpers.c -o peak_finder

This command compiles main.c and array_helpers.c together, applies all the specified warnings (treating them as errors), adheres to the C99 standard, and creates an executable named peak_finder.exe.

Running the Program

Once gcc compiles your program, you can run it from the w64devkit terminal.

To run your executable, type ./ followed by the executable’s name. The ./ prefix is important because it tells the shell to look for the executable in the current directory.
If your program expects command-line arguments, you can pass them directly:

./peak_finder test_array.txt

This command would execute peak_finder.exe and pass test_array.txt as an argument, which your C program can then process.

You can check some of my other posts in my personal blog; lautarolobo.xyz

I hope this post helped you on your development journey. See you in the next post!

Some Notes I Took on Software Architecture

Lautaro Lobo — Fri, 10 Oct 2025 00:00:00 +0000

I watched a few videos, read some stuff online about Software Architecture, and took some notes in the process.

I hope these make sense.

First of all, you want to analyze:

the functional requirements
the non-functional requirements

Functional requirements are the “what”, often captured in use cases, user stories, or a detailed list of features.

Non-functional requirements are the “how”. Like performance, reliability, security, maintainability, etc. You can look into ISO/IEC 25010 as a reference.

When planning a software architecture, you want to put structure over implementation. You need to take into consideration the budget, along with any restrictions you may have, like regulatory constraints (like HIPAA), industry standards, talent pool (the team you have), etc.

Try to spot any conflicting requirements that could be problematic along the way. Catching these earlier will save you tons of time and overhead. If something needs to be rethought, this is the time.

Prioritize the NFRs so you have a better understanding of the core business, what drives the solution, and the necessity behind it. This will make it clearer where you should focus and put more effort into, and what improvements could be added in later stages.

With all this in mind, try to imagine how this system could grow and evolve in time.

Next, you have to choose one.

And remember:

Do not forget about these three core concepts:

You should always keep these in mind.

It has to work, so it needs to be performant.

It has to be scalable , because you never know how big you can get.

Focusing on maintainability is also crucial. Maintainable systems are easier to understand, modify, and fix, benefiting both the dev experience and the client. Instead of creating something that only a few people can handle, you will build a system that is a joy to work with and a gift to those who use it.

When you have a shared state between servers (which happens with a microservices architecture, or any other type of distributed system), the CAP theorem applies.

CAP stands for Consistency, Availability, and Partition Tolerance. The CAP theorem states that Partition Tolerance is required for distributed systems, so you can only choose one of the other two.

The trade-offs usually are:

Consistency > Availability

Often used for banking or in relational databases, when you block new writes to the DB, causing the system to go temporarily unavailable.

Availability > Consistency

When writes happen at the same time, consistency may be lost. You need to implement a sorting or prioritization engine. This is often picked for social media or e-commerce apps.

I believe the most used one is A+P (Availability + Partition tolerance).

You need to manage these trade-offs gracefully, with some strategy to resolve inconsistencies quickly.

With scaling comes latency and slower response times; that’s where cache comes into play.

A cache is a component that stores data so that requests that need the same data will be served faster.

Some examples are in-memory cache, CDNs, Redis, memcached, etc.

Every layer/component of an architecture can, and should, have a cache. But you can add this in later stages, as an optimization.

And finally:

I think that’s pretty much it.

The Manhattan Tourist Problem

Lautaro Lobo — Mon, 10 Feb 2025 00:00:00 +0000

Hi there!

I’ve been looking into some algorithmic problems lately. The Manhattan Tourist Problem is one of the most emblematic problems you could find online.

Want to practice some Dynamic Programming? Let’s dive straight into it!

Statement of the Problem

You and your family are taking a tour through downtown Manhattan. The van will leave you at the northwesternmost corner of the city, and another van will be waiting to pick you up at the southeasternmost corner. But here’s the thing: you can only move either to the south or to the east. You and your family are starting to develop a plan to visit as many attractions as possible, how would you do it?

Input: A weighted grid G of size n*m.

Output: A longest path in G from (0,0) to (n,m).

Here’s an illustrated example:

The weight (we could also call it length) of a path from the source to the sink is the overall number of attractions in the path or the sum of the weights of its edges.

An important thing to remember is that you can’t go upward (to the north) or backward (to the west).

A naive approach would be to calculate all the possible paths in the grid and select the longest path between them all. But this algorithm would be slow even with mid-sized grids, so it’s not an option.

A different approach would be to use a greedy algorithm. But greedy algorithms only consider locally optimal choices at each step, which could lead to missing out on a globally optimal path. So a greedy algorithm is out of the equation.

So let’s begin our analysis to come up with a Dynamic Programming solution.

Finding a Dynamic Programming Solution

At first glance, we can see that to solve the general problem, we need to find the solution to many sub-problems. Precisely to n*m sub-problems: the longest path to (i,j) with 0 <= i <= n and 0 <= j <= m.

So instead of solving the Manhattan Tourist problem directly, we will solve the general problem, which is the longest path from the source vertex to an arbitrary sink vertex.

First, let’s define our set of vertex S, and S(i,j) as the vertex in the i-th row and j-th column.

Finding S(0,j) is trivial, you and your family can’t go in another direction than to the east. The weight of the path S(0,j) is the sum of weights of the first j city blocks. The same happens with S(i,0) since you can only move south.

Having this in mind we can compute S(1,1), you can arrive at S(1,1) from S(0,1) or S(1,0). The weight of each of these paths is:

S(0,1) + weight of the edge (block) between (0,1) and (1,1)
S(1,0) + weight of the edge (block) between (1,0) and (1,1)

The longest path is the larger of the above values. In the sample grid shown before, that value would be 4 (1+3). We’ve found the longest path from (0,0) to (1,1).

The same logic applies to S(2,1), S(3,1), etc. We can use this logic to compute S(1,2), S(1,3), etc.

In general, having the first row and the entire S(-,j) column allows you to compute S(-,j+1). Knowing that to arrive at S(i,j) we need to go through S(i-1,j) or through S(i,j-1) leads to the following conclusion:

This recurrence allows you to compute every cell of S in a single sweep of the grid.

The following algorithm written in pseudocode implements this procedure.

FUNCTION ManhattanTourist(n, m, down, right)  
// n, m: dimensions of the grid (number of rows and columns)  
// down[i][j]: weight of the edge going down from cell (i, j)  
// right[i][j]: weight of the edge going right from cell (i, j)  
// S[i][j]: maximum path sum to reach cell (i, j)

// Base case: starting cell
S[0][0] = 0

// Initialize first column (moving only down)
FOR i = 1 TO n
  S[i][0] = S[i-1][0] + down[i][0]
ENDFOR

// Initialize first row (moving only right)
FOR j = 1 TO m
  S[0][j] = S[0][j-1] + right[0][j]
ENDFOR

// Fill the rest of the table using dynamic programming
FOR i = 1 TO n
  FOR j = 1 TO m
    IF S[i-1][j] + down[i][j] < S[i][j-1] + right[i][j] THEN
      S[i][j] = S[i][j-1] + right[i][j]
    ELSE
      S[i][j] = S[i-1][j] + down[i][j]
    ENDIF  
  ENDFOR  
ENDFOR

RETURN S[n][m]

You can implement this pseudocode in any programming language of your preference.

I hope you have found the problem interesting, and it helped you get better at Dynamic Programming.

In case you want to dive deeper, try answering the following questions:

How would you change the algorithm if the source vertex differs from (0,0)?
What would happen if downtown Manhattan had diagonal streets (which actually has)? Should you change the algorithm or would still give the correct answer?

See ya in my next blog posts!

Use JavaScript and HTML5 to Code a Fractal Tree

Lautaro Lobo — Thu, 16 Apr 2020 15:40:00 +0000

Fractals, those enigmatic figures that are everywhere, but can not be seen by the untrained eye. Today we’ll draw one of the best-known Fractals, using only Vainilla JS and the HTML5’s Canvas API. Let’s code!

What is a Fractal Tree?

To define a Fractal Tree first we must know the definition of Fractal, of course.

Fractals are never-ending patterns created by repeating mathematical equations, which on any scale, on any level of zoom, look roughly the same. In other words, a geometric object which’s basic structure, rough or fragmented, repites itself in different scales.

So if we split a Fractal, we’ll see a reduced-size copy of the whole.

Benoit Mandelbrot, which coined the term Fractal in 1975, said:

A Fractal is a shape made of parts similar to the whole in some way.

Pretty clear, right?

Here are some examples:

Von Koch Curve

Sierpinski Carpet

Now, what is a Fractal Tree?

Imagine a branch, and branches coming out of it, and then two branches coming out of each branch, and so on… that’s what a Fractal Tree looks like.

Its form comes from the Sierpinski triangle (or Sierpinski gasket).

As you can see, one becomes the other when changing the angle between branches:

Today we’ll end up with a figure similar to the final form of that gif.

Writing the Fractal Tree in Vanilla JS

First of all, here’s the final product (you can tweak it along the way):

Now let’s draw that, step by step.

First of all, we initialize our index.html file, with a canvas of any reasonable dimensions, and a script tag where all our JS code will be.

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
</head>
<body>
    <canvas id="my_canvas" width="1000" height="800"></canvas>
    <script></script>
</body>
</html>

Then, we start writing our JavaScript.

We initialize our canvas element on JS, by accessing it through the myCanvas variable and creating the 2D rendering context with the ctx (context) variable.

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
</head>
<body>
    <canvas id="my_canvas" width="1000" height="800"></canvas>
    <script>
    var myCanvas = document.getElementById("my_canvas");
    var ctx = myCanvas.getContext("2d");
    </script>
</body>
</html>

So yeah, the getContext method adds properties and methods that allow you to draw, in this case, in 2D.

Now it’s time to think. How can we define the algorithm to draw a Fractal tree? Hm… 🤔

Let’s see, we know that the branches keep becoming smaller. And that each branch ends with two branches coming out of it, one to the left and one to the right.

In other words, when a branch is long enough, attach two smaller branches to it. Repeat.

It kinda sounds like we shall use some recursive statement somewhere, isn’t it?

Back to the code, we now define our function fractalTree that should take at least four arguments: the X and Y coordinates where the branch starts, the length of its branch and its angle.

Inside our function, we begin the drawing with the beginPath() method, and then save the state of the canvas with the save() method.

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
</head>
<body>
    <canvas id="my_canvas" width="1000" height="800"></canvas>
    <script>
    var myCanvas = document.getElementById("my_canvas");
    var ctx = myCanvas.getContext("2d");
    function draw(startX, startY, len, angle) {
        ctx.beginPath();
        ctx.save();
    }        
    </script>
</body>
</html>

The beginPath method is often used when you start a new line or figure that has a fixed style, like the same color along the entire line, or the same width. The save method just saves the entire state of the canvas by pushing the current state onto a stack.

Now we’ll draw our Fractal Tree, by drawing a line (branch), rotating the canvas and drawing the next branch, and so on. It goes like this (I’ll explain each method below the code sample):

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
</head>
<body>
    <canvas id="my_canvas" width="1000" height="800"></canvas>
    <script>
    var myCanvas = document.getElementById("my_canvas");
    var ctx = myCanvas.getContext("2d");
    function draw(startX, startY, len, angle) {
        ctx.beginPath();
        ctx.save();

        ctx.translate(startX, startY);
        ctx.rotate(angle * Math.PI/180);
        ctx.moveTo(0, 0);
        ctx.lineTo(0, -len);
        ctx.stroke();

        if(len < 10) {
            ctx.restore();
            return;
        }

        draw(0, -len, len*0.8, -15);
        draw(0, -len, len*0.8, +15);

        ctx.restore();
    }
    draw(400, 600, 120, 0)       
    </script>
</body>
</html>

So we first add three methods, translate, rotate and moveTo, which ‘moves’ the canvas, its origin and our ‘pencil’ so we can draw the branch in our desired angle. It’s like we are drawing a branch, then centering this branch (by moving the hole canvas) and then drawing a new brand from the end of our previous branch.

The last two methods before the if statement are lineTo and stroke, the first adds a straight line to the current path and the second one renders it, you can think of it like this: lineTo gives the order and stroke executes it.

Now we have an if statement that tells when to stop the recursion, when to stop drawing. The restore method, as stated in the MDN Docs, “restores the most recently saved canvas state by popping the top entry in the drawing state stack”.

After the if statement we have the recursive call, and another call to the restore method. And then a call to the function that we just finished.

Now run the code in your browser. You’ll see, finally, a Fractal Tree!

Awesome, right? Now let’s make it even better.

We’ll add a new parameter to our draw function, branchWidth, to make our Fractal Tree more realistic.

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
</head>
<body>
    <canvas id="my_canvas" width="1000" height="800"></canvas>
    <script>
    var myCanvas = document.getElementById("my_canvas");
    var ctx = myCanvas.getContext("2d");
    function draw(startX, startY, len, angle, branchWidth) {
        ctx.lineWidth = branchWidth;

        ctx.beginPath();
        ctx.save();

        ctx.translate(startX, startY);
        ctx.rotate(angle * Math.PI/180);
        ctx.moveTo(0, 0);
        ctx.lineTo(0, -len);
        ctx.stroke();

        if(len < 10) {
            ctx.restore();
            return;
        }

        draw(0, -len, len*0.8, angle-15, branchWidth*0.8);
        draw(0, -len, len*0.8, angle+15, branchWidth*0.8);

        ctx.restore();
    }
    draw(400, 600, 120, 0, 10)       
    </script>
</body>
</html>

So in every iteration, we are making each branch thinner. I’ve also changed the angle paramater in the recursive call, to make a more “open” tree.

Now, let’s add some color! And shadows, why not.

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
</head>
<body>
    <canvas id="my_canvas" width="1000" height="800"></canvas>
    <script>
    var myCanvas = document.getElementById("my_canvas");
    var ctx = myCanvas.getContext("2d");
    function draw(startX, startY, len, angle, branchWidth) {
        ctx.lineWidth = branchWidth;

        ctx.beginPath();
        ctx.save();

        ctx.strokeStyle = "green";
        ctx.fillStyle = "green";

        ctx.translate(startX, startY);
        ctx.rotate(angle * Math.PI/180);
        ctx.moveTo(0, 0);
        ctx.lineTo(0, -len);
        ctx.stroke();

        ctx.shadowBlur = 15;
        ctx.shadowColor = "rgba(0,0,0,0.8)";

        if(len < 10) {
            ctx.restore();
            return;
        }

        draw(0, -len, len*0.8, angle-15, branchWidth*0.8);
        draw(0, -len, len*0.8, angle+15, branchWidth*0.8);

        ctx.restore();
    }
    draw(400, 600, 120, 0, 10)       
    </script>
</body>
</html>

Both color methods are self-explanatory (strokeStyle and fillStyle). Also the shadow ones, shadowBlur and shadowColor.

And that’s it! Save the file and open it with your browser to see the final product.

Now I encourage you to play with the code! Change the shadowColor, the fillStyle, make a shorter or longer Fractal Tree, change the angle or try to add leaves, that should be challenging 😉

Beyond the Fractal Tree

As I showed you at the beginning of this post, there are different Fractals. Ain’t gonna be easy to make all them with the Canvas API, but it should be possible. I made some of those in the C programming language, and I’ve also played around with p5.js.

p5.js is an Open Source JavaScript library made by artists, for artists, based in the Processing language. You can draw, or animate, anything imaginable. If you are interested in making art with code, it’s a must. They have a great get-started page that you can check out here.

I’ve also found recently a website that makes a Fractal Tree in JS using L-Systems. Really cool. Take a look into The Fractal Zone! Code is here 🤓

Well, that’s it for now! Thanks for reading, comment any questions and see you in my next post! 🧔

Cover by socialtrendspr0 from Pixabay

February of Fortran

Lautaro Lobo — Sat, 29 Feb 2020 18:07:00 +0000

What is Fortran?

Fortran is a 63 y.o. programming language developed by IBM for scientific and engineering applications. Its name is an acronym from FORmula TRANslation , and still being in use for that purpose.

It’s a general-purpose programming language, but best suited for computationally intensive areas like computational physics, computational chemistry, high-performance computing and so.

Many programming languages were based on or influenced by, Fortran. And it has received many updates among the years, last one in 2018.

It was originally conceived as FORTRAN, all uppercase, in 1956. 5 updates later, in the 90s, it became Fortran. The update also added many other changes like free-form source, inline comments, modules, recursive procedures, dynamic memory allocation and many other changes that make the language modern-er.

How to Compile and Run a Fortran Program

Let’s say you want to compile and run your first Fortran program, like this one:

program HelloWorld
  implicit none
  print*, "hello world"
  write(*,*) "hello world"
end program

! it should return:
! hello world
! hello world

Well, you should make a series of things:

Install gfortran, which is a Fortran compiler.
Save your code with .f90 extension (even if you are writing in Fortran 2015, .f90 it’s the standard file extension).
Compile with gfortran.
Run your program as you would run any C program.

And that’s how you do it!

What is Fortran Used For

Fortran is still in use in HPC (High Performace Computing). All that is mathematical chunk is probably done with Fortran. It’s widely used in scientific computing from Chemistry and Physics to Astronomy and Mathematics.

I can almost hear the masses… why not Python?

In fact, you can use Python in those areas. But even if Python is a better choice in many cases, you wouldn’t use it in HPC, since Fortran is performant-er. It may take more time to write, but sometimes code performance means everything.

You know, even that Python has evolved, wasn’t born exclusively for Physicists and Mathematicians.

As I’ve read somewhere:

At the end of the day, Physicists are writing very different programs than Computer Scientists with very different goals and concerns.

You may say that Physicists are not willing to change, or that there’s a lot of Fortran legacy code out there, but even then, Fortran keeps being the best choice for some HPC projects, or Physics calculations.

But that doesn’t mean that you can only use Fortran. Other programming languages used in HPC are C and C++, both being faster than Fortran in many cases, or the somehow-new Julia that is slowly entering the market, is also faster than Fortran and it was developed by MIT exclusively for HPC and all scientific computing.

If you want to see a detailed comparison between Python, C++, and Fortran on scientific computing, check out this amazing paper.

January of JavaScript

Lautaro Lobo — Wed, 22 Jan 2020 14:01:00 +0000

It’s January. Time to talk about JavaScript. How was it born? Why is it called like that? Is it really that popular? Let’s find out!

A Little Bit Of History

JavaScript was born in December of 1995 when Netscape announced it’s rollout. The guy behind the work? Brendan Eich, a Computer Scientist working at that time in Netscape. He’s known as the father of JavaScript, because of his titanic work on the language before it’s rollout.

Fun fact: JavaScript was named Mocha, then LiveScript, and finally they changed it once and for all to the name that we all know now.

And why is it called ‘Java’-‘Script’? Well, quoting Brendan:

[…] It was all within six months from May till December (1995) that it was Mocha and then LiveScript. And then in early December, Netscape and Sun did a license agreement and it became JavaScript. And the idea was to make it a complementary scripting language to go with Java, with the compiled language.

A co-marketing deal between Netscape and Sun.

In fact, Oracle acquired Sun Microsystems in 2009, so “JAVASCRIPT” is a trademark of Oracle. How crazy is that?

In 1997, ECMAScript was born. But what is ECMAScript? It’s a standard, a specification of a programming language, published by ECMA (European Computer Manufacturers Association) International. So JavaScript is a dialect of the ECMAScript standard.

That’s right, ECMAScript defines a programming language, and JavaScript is the programming language.

There were different versions of the standard since it first came out. Today, every modern web browser supports ECMAScript 5.1, and almost everyone supports the latest version, ECMAScript 6. Newer versions are still in the early stages of development.

Are you confused yet? To make it simpler, ECMAScript is like the version, and JavaScript is the language itself.

For a more-of-a-timeline of the history of JavaScript, check:

The Weird History of JavaScript

Weird Stuff

When using JS, you may find some weird stuff going one, like that NaN (which stands for Not a Number) it’s a… number:

console.log(typeof(NaN)) // number

And NaN it’s not NaN ¿?

console.log(NaN === NaN) // false

And that NaN is an infinite number. Wait… what?

console.log(isFinite(NaN)) // false

And you know what’s the weirdest part? You should expect JS to behave like this! I mean, this is all on the specs.

You can take a look at more weird stuff here:

Do you know these weird parts of JavaScript?

What’s Next?

As I said before, there are some newer versions of the ECMAScript standard on development. But in so early stages that we shouldn’t expect JS to change much anytime soon.

After all, you can already use JS on almost anything: Videogames, AI, Back-End, Front-End, Art, Data Analytics…

And many frameworks and libraries are popping up every day. Svelte has changed the paradigm of website rendering. There’s this thing called CSS-in-JS. You can even write Artificial Neural Networks with Tensorflow.js, develop videogames with Babylon.js, make art using p5.js, automate stuff with NodeJS, even make charts based on .csv files!

Dang that’s broad, right?

So yeah, it’s a smart move to learn JavaScript. It’s used all around the web and even in non-web environments, for good or bad. In fact, from the Stack Overflow Developer Survey of 2019 we can say that it’s the most commonly used programming language. And the top Libraries and Frameworks are also JS-based.

It seems like JS is staying with us for a while.

Hey, thanks for reading until this far! If you are starting your journey on JavaScript, or just want to train yourself a bit, check my #7DaysJS Challenge!

See ya!

#7DaysJS: Primes Until n

Lautaro Lobo — Thu, 05 Dec 2019 11:16:00 +0000

Welcome to day 7 of 7 Days of JavaScript!

Today, on the last day of this challenge, we will tackle a hard one.

Write a function that takes a Natural number n, which returns all the primes from 0 to n and a string at the end with some phrase.

Example:

primesUntil(7)
...
2
3
5
'Why the string?'

Hint: you may want to use a helper function.

Give it time. If you feel frustrated, go take a walk and then sit down to try it again.

And then, read the solution here.

#7DaysJS: myElement + n

Lautaro Lobo — Wed, 04 Dec 2019 12:25:00 +0000

Welcome to day 6 of 7 Days of JavaScript!

Let’s see, I got a nice one for today.

Given an array and a number n, return the array with each element summed to n.

Here’s an example:

sumToArray(5,[1,2,3,4])
...
[6,7,8,9]

If you want, you can also return the output as a string - If that makes it easier for you, it’s OK.

You can check out the solution algorithm here.

#7DaysJS: Where is My Element

Lautaro Lobo — Tue, 03 Dec 2019 20:20:00 +0000

Welcome to day 5 of 7 Days of JavaScript! Today we will code a classic function that:

Takes two parameters: an element and an array of elements
Returns the position of the element inside the array. If the element is not in the array, returns -1.

Wish you luck!

You can see the solution here.

#7DaysJS: Reverse a String

Lautaro Lobo — Mon, 02 Dec 2019 17:43:00 +0000

Welcome to day 4 of 7 Days of JavaScript!

Today we will see how to reverse a string. It’s probably the most asked question ever on technical interviews.

So the statement is quite simple, although the problem has an unexpected complexity when you face it for the first time: write a function that takes a string and returns the string reversed.

Here’s an example:

reverseString('Japan')
...
'napaJ'

Give it a try.

You can see the solutions I made here.

#7DaysJS: Read My Sign

Lautaro Lobo — Sun, 01 Dec 2019 21:22:00 +0000

Welcome to day 3 of 7 of Days of JavaScript!

Today’s challenge is to write a function that takes an array and says how many numbers are positives, how many numbers are negatives, and how many are zeros.

Example:

[1,3,0,-1,0,5,-5]
...
{
zeros: 2,
positives: 3,
negatives: 2 
}

Good luck!

You can see the solution here.

#7DaysJS: Even or Odd

Lautaro Lobo — Sat, 30 Nov 2019 15:17:00 +0000

Welcome to day 2 of 7 Days of JavaScript!

Let’s begin our journey today. We need to write a function that takes an array and gives back two values: one with the sum of all the odd numbers of the array, and other with the sum of all the even numbers on the array.

It can’t be that hard right?

You can read the solution to today’s challenge here.

Forem: Lautaro Lobo

How to Install GCC on Windows with w64devkit

Installing w64devkit

Opening Your Local Development Environment

Compiling and Running Your C Program with GCC

Understanding GCC Flags

Putting It All Together

Running the Program

Some Notes I Took on Software Architecture

The Manhattan Tourist Problem

Statement of the Problem

Finding a Dynamic Programming Solution

Related Content

Use JavaScript and HTML5 to Code a Fractal Tree

What is a Fractal Tree?

Writing the Fractal Tree in Vanilla JS

Beyond the Fractal Tree

February of Fortran

What is Fortran?

How to Compile and Run a Fortran Program

What is Fortran Used For

January of JavaScript

A Little Bit Of History

Weird Stuff

What’s Next?

#7DaysJS: Primes Until n

#7DaysJS: myElement + n

#7DaysJS: Where is My Element

#7DaysJS: Reverse a String

#7DaysJS: Read My Sign

#7DaysJS: Even or Odd