DEV Community: CodeTips

Binary to decimal converter

Si — Tue, 19 May 2020 13:00:00 +0000

CodeTips strives to help beginners, with zero or very little experience, learn to code.

We do cross-post to other sites to reach a wider audience, but why not subscribe to our newsletter and get the newest articles straight to your mailbox?

The original source for this content is CodeTips. The original content is kept up-to-date, but other sources may not be the latest version.

Have you ever seen Binary, those ones and zeros that computers somehow understand, and wondered what it all means? Well,
today we're going to demistify some of if by creating a small application that converts from binary to decimal.

What is decimal?

Decimal is the numbering system that most of us use everyday. We're taught it from a young age, so it may seem like the
only logical way of counting. Let's take a quick look at what it looks like to count in decimal:

1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ..... 1001

Decimal can also be referred to as Base 10. It includes the numbers 0-9 (ten possibilities) and each column in a number
is a power of ten.

Let's look at an example by breaking down the number 5,743, which we know is Five Thousand, Seven Hundred, and Fourty Three.

So, what did I mean when I said each column in a number is a power of ten? If we look at the above image, starting from the right-most box, we can say:

Ten to the power of Zero (10^0) is 1. We have Three in this column, so our calculation is 3x1 (3).
Ten to the power of One (10^1) is 10. We have Four in this column, so our calculation is 4x10 (40).
Ten to the power of Two (10^2) is 100. We have Seven in this column, so our calculation is 7x100 (700).
Ten to the power of Three (10^3) is 1000. We have Five in this column, so our calculation is 5x1000 (5000).

Adding all of the numbers (5000 + 700 + 40 + 3) gives us 5,743.

What is binary?

The above explanation of decimal may seem basic and pointless, but it's going to help to explain what binary is in this
section.

Binary, like decimal, is just a numbering system. Unlike decimal, it is referred to as Base 2, only includes
the numbers 0 and 1 (two possibilities) and each column is a power of two.

Let's look at an example by breaking down the binary number 10100101. Unlike the previous section it's not immediately clear
what this number is, so we're going to walk through the same steps to find out.

We know each column in a binary number is a power of two so, starting from the right-most number, we can say:

Two to the power of Zero (2^0) is 1. We have One in this column, so our calculation is 1x1 (1).
Two to the power of One (2^1) is 2. We have Zero in this column, so our calculation is 0x2 (0).
Two to the power of Two (2^2) is 4. We have One in this column, so our calculation is 1x4 (4).
Two to the power of Three (2^3) is 8. We have Zero in this column, so our calculation is 0x8 (0).
Two to the power of Four (2^4) is 16. We have Zero in this column, so our calculation is 0x16 (0).
Two to the power of Five (2^5) is 32. We have One in this column, so our calculation is 1x32 (32).
Two to the power of Six (2^6) is 64. We have Zero in this column, so our calculation is 0x64 (0).
Two to the power of Seven (2^7) is 128. We have One in this column, so our calculation is 1x128 (128).

Adding all the numbers (128 + 0 + 32 + 0 + 0 + 4 + 0 + 1) gives us 165. So, as you can see, at it's most basic
level, binary is just a numbering system.

What are we building?

In the last two sections we learnt that binary, like decimal, is just a numbering system. We also, unbeknowingly,
detailed how to convert from binary to decimal (notice how we calculated the decimal representation for each binary
digit, and then added them all up).

We're now going to use this knowledge to write a programme that will perform this conversion for us.

The following sections will show you how to write such a programme in JavaScript and Go.

Note: Neither of the following sections are "production ready" - the code is to illustrate how to perform the conversion
from binary to decimal in code, and we have omitted error handling and type checking for brevity.

JavaScript Implementation

We know the best approach, to convert from binary to decimal, is to start with the right-most number/column. Let's start
by writing a simple binaryToDecimal function, which accepts a string (our binary number) and prints it out from the
right-most column to the left-most column.

const binaryToDecimal = binary => {
    for (let i=binary.length-1; i>=0; i--) {
        console.log(binary[i])
    }
}

Because we're only printing out the numbers, our function just contains a simple for loop (see Arrays and Loops
in JavaScript for a JavaScript specific explanation) which starts at end of the input
(binary.length-1), continues while i is less than or equal to 0, and decrements i by one for each loop.

binaryToDecimal("1000101") // 1010001
binaryToDecimal("1110001") // 1000111
binaryToDecimal("1000100") // 0010001

We know that each column, in a binary number, is a power of two so let's change our function to print out the exponent
of each column.

const binaryToDecimal = binary => {
    let pow=0

    for (let i=binary.length-1; i>=0; i--) {
        let r=Math.pow(2, pow)

        console.log(r)

        pow++
    }
}

We initialise a new pow variable to zero because, like we did when calculating manually above, we start with two to
the power of zero (2^0).

On each loop, we work out the result of two to the power of pow (2^pow), log the result and increment pow ready for the next loop.

binaryToDecimal("1000101")

/**
1
2
4
8
16
32
64
*/

We now have a function that accepts a string representation of a binary number, starts at the right-most column and
works out the decimal representation for each column. The last thing to do is to calculate each column, and add the
result together to get our decimal representation.

const binaryToDecimal = (binary) => {
    let result=0
    let pow=0

    for (let i=binary.length-1; i>=0; i--) {
            let r=Math.pow(2, pow)

            result += r * parseInt(binary[i],10)

            pow++
    }

    console.log(result)
}

We've now added a result variable, which we increment based on the result of r * parseInt(binary[i],10) where r is
the result of our power calculation and parseInt will yield either zero or one.

binaryToDecimal("10100101") // 165

And that's all there is to a binary to decimal converter. Keep reading if you'd like to see the Go implementation, or
visit our handy binary to decimal converter, which uses this logic, if you'd like to
test out some numbers.

Go Implementation

Like we discussed above, in the JavaScript implementation, we know the best approach, to convert from binary to decimal, is to start with the right-most number/column.

We'll follow a similar pattern by first creating a simple binaryToDecimal function, which accepts a string (our binary
number) and prints it out from the right-most column to the left-most column.

package main

import (
    "fmt"
)

func main() {
    binaryToDecimal("1000101") // 1010001
    binaryToDecimal("1110001") // 1000111
    binaryToDecimal("1000100") // 0010001
}

func binaryToDecimal(binary string) {
    for i := len(binary) - 1; i >= 0; i-- {
        fmt.Println(string(binary[i]))
    }
}

Because we're only printing out the numbers, our function just contains a simple for loop (see Arrays and Loops
in Go for a Go specific explanation) which starts at end of the input (len(length)-1), continues while i is less than or equal to 0, and decrements i by one for each loop.

Note how we are converting the value (binary[i]) to a string. We have to do this because looping over a string in Go
returns the byte representation of each character (48 for 0, 49 for 1).

Because we are using characters that fit into one byte (0 and 1) this is safe. However, be cautious about using this technique when you cannot guarantee each character
will fit into one byte as you may get skewed results.

We know that each column, in a binary number, is a power of two so let's change our function to print out the exponent
of each column.

package main

import (
    "fmt"
    "math"
)

func main() {
    binaryToDecimal("1000101")
    /**
    1
    2
    4
    8
    16
    32
    64
    */
}

func binaryToDecimal(binary string) {
    var pow float64 = 0

    for i := len(binary) - 1; i >= 0; i-- {
        r := math.Pow(2, pow)

        fmt.Println(r)

        pow++
    }
}

We initialise a new pow variable to zero because, like we did when calculating manually, we start with two to the power of zero (2^0).

On each loop, we work out the result of two to the power of pow (2^pow), log the result and increment pow ready for the next loop.

package main

import (
    "fmt"
    "math"
    "strconv"
)

func main() {
    fmt.Println(binaryToDecimal("1000101"))  // 69
    fmt.Println(binaryToDecimal("10100101")) // 165
}

func binaryToDecimal(binary string) int64 {
    var result int64 = 0
    var pow float64 = 0

    for i := len(binary) - 1; i >= 0; i-- {
        r := math.Pow(2, pow)

        i, _ := strconv.ParseInt(string(binary[i]), 10, 64)
        result += int64(r) * i

        pow++
    }

    return result
}

We've now added a result variable, which we increment based on the result of r * i where r is the result of our power calculation and i is the result of converting our character (0 or 1) to an int.

And that's how to create a binary to decimal converter in Go. Feel free to visit our handy binary to decimal converter, which uses the JavaScript logic, if you'd like to test out some numbers.

CodeTips strives to help beginners, with zero or very little experience, learn to code.

We do cross-post to other sites to reach a wider audience, but why not subscribe to our newsletter and get the newest articles straight to your mailbox?

The original source for this content is CodeTips. The original content is kept up-to-date, but other sources may not be the latest version.

Writing for CodeTips

Si — Fri, 10 Jan 2020 16:32:13 +0000

CodeTips is not a Social Media platform like Dev, it's not an "open for everyone/everything" writing experience like Medium.

I like to see CodeTips as between a personal blog and everything else out there.

We're never going to have hundreds of writers, nor do we want to, that can write whatever they want like FreeCodeCamp. We want a handful of regular writers, that decide what to write about.

If you are interested in writing for CodeTips please leave a comment, or get in Contact.

How To create a CRUD API, using Node.js and Express, on Ubuntu 18.04

Si — Thu, 19 Dec 2019 12:25:51 +0000

CodeTips strives to help beginners, with zero or very little experience, learn to code.

We do cross-post to other sites to reach a wider audience, but why not subscribe to our newsletter and get the newest articles straight to your mailbox?

The original source for this content is CodeTips. The original content is kept up-to-date, but other sources may not be the latest version.

Introduction

An API (Application Programming Interface) is a way of interacting with a service, through a series of predefined requests.

Express is an open source web framework, for Node.js, designed to make developing websites, web apps, and API's easier.

In this tutorial, you will create a simple CRUD API on a single Ubuntu 18.04 server. The API will be accessible through a public IP address, allowing you to access it from anywhere with an internet connection.

To get started, sign-up for Digital Ocean using this referral link and get $100 credit!

Prerequisites

An Ubuntu 18.04 server setup, as described in the initial server setup guide for Ubuntu 18.04. You should have a non-root user with sudo privileges and an active firewall.
Node.js and PM2 installed on your Ubuntu 18.04 server, as described in How To Set Up a Node.js Application for Production on Ubuntu 18.04.
A basic understanding of CURL

Step 1 — Create a simple Express App that serves "Hello World"

In this step, we’ll create a very simple API, with one endpoint, that we’ll then build on in future steps.

To begin, create a new directory in a location of your choosing, and create a default package.json file, by running the following command in a terminal:

npm init -y

In the same terminal, install the express dependency:

npm i express

Next, open the project in a code editor of your choice and create a new server.js file.

Within the new file, add the following code:

const express = require('express')
const app = express()
const port = 3000

app.get('/hello', (req, res) => res.send('Hello World!'))

app.listen(port, () => console.log(`App listening on port ${port}!`))

Using the express application, we define a /hello endpoint, that will return the text Hello World!, and run our application on port 3000.

Note that the /hello endpoint will only match for GET requests, as we've defined it using the app.get method.

In your terminal, run the following command to start the application:

node index.js

You should see the following output as a result:

$ node index.js
App listening on port 3000!

Now open your favourite browser, and navigate to localhost:3000/hello. If everything worked successfully, Hello World! should be displayed in your browser.

Congratulations - you have created an API, and you can communicate with it via the /hello endpoint. We’ll build on this structure in the following steps, and make our API even better!

Step 2 — Extend the application to get a property from in-memory state.

At this point we have one endpoint, /hello, that returns the text Hello World!. While it’s awesome that we’ve created an API, as far as functionality goes it’s not that helpful.

In this step we’ll take our API and have it return some useful data. We’ll be using an example of employee details.

First, let's add another endpoint to our application that will retrieve a record.

const express = require('express')
const app = express()
const port = 3000

app.get('/hello', (req, res) => res.send('Hello World!'))

app.get('/employee/:id', (req, res) => {
  console.log(req.params.id)
  res.sendStatus(200)
})

app.listen(port, () => console.log(`App listening on port ${port}!`))

We define a new /employee endpoint, just like we did for the /hello endpoint, but we're also using a query parameter.

Query parameters are defined using a colon, and the preceding text is used to reference that parameter. In our /employee endpoint, we've defined a query parameter called id, and our console.log statement shows how we reference the value.

Stop and start the application, so the new code changes take effect, open your browser and navigate to http://localhost:3000/employee/wiggly.

You should see the following output in your terminal, as a result:

$ node index.js
App listening on port 3000!
wiggly

Notice how wiggly was printed to the terminal, which is what we used in the URL (/employee/wiggly). Change wiggly to anything you like, and you should see that printed in the terminal.

The power of this technique enables us to define one route, which can be used for many different scenarios. For example, an endpoint that can retrieve an employees details using a unique identifier, which is exactly what we're going to do now!

Let's create an Object, to act as in-memory state for our application, and add some fictional employees:

/**  
We'll use the Object key as the unique identifier, made up of the
first letter of the employees first name and whole of their last name.
*/
const employees = {
  'sbrown': {
    firstName: 'Steve',
    lastName: 'Brown',
    department: 'Engineering'      
  },
  'jsmith': {
    firstName: 'Janine',
    lastName: 'Smith',
    department: 'Marketing'      
  },
  'kjones': {
    firstName: 'Karen',
    lastName: 'Jones',
    department: 'Sales'      
  },
  'bwilliams': {
    firstName: 'Ben',
    lastName: 'Williams',
    department: 'Administration'
  }
}

Now, instead of logging out the id parameter value, let's return the employee details from our Object:

app.get('/employee/:id', (req, res) => {
  res.json(employees[req.params.id])
})

As we'll be returning a JSON object we're using the res.json method which, among other things, sets all of the correct headers and returns the response in JSON.

Restart the application and navigate to http://localhost:3000/employee/kjones in your browser.

You should see the following response in your browser:

{"firstName":"Karen","lastName":"Jones","department":"Sales"}

Try changing kjones to any of the other unique identifiers, in the employees object, and see the returned values change.

Now, try changing the id to something non-existent (e.g. http://localhost:3000/employee/wiggly) in the browser. Nothing is returned, which is correct, but we're not giving the user any indication why; did something go wrong, or does the employee just not exist?

Let's update the endpoint to check if the given employee id exists and, if not, we'll return a 404 Not Found response, otherwise we'll return the employee details.

app.get('/employee/:id', (req, res) => {
  const employee = employees[req.params.id]

  if (!employee) {
    return res.sendStatus(404)
  }

  res.json(employee)
})

Restart your application, and try the same URL in the browser. The response should now be Not Found, which is a lot more informative to the user.

In this step, we took a very simple and not very helpful API and transformed it into one that queries data using query parameters. We also learnt how to handle situations where a non-existent employee is queried.

Step 2 — Extend the application to add/delete a property from in-memory state.

We now have an API that can retrieve an employee, based on the employee id, but what if an employee joins/leaves the company? We need a way to add/remove them from our employees list, which is what we’ll achieve in this step.

Let’s focus on people joining the company first. When someone joins, we want to add them to our employees object so they can be queried later on.

To do this we will use a POST request, which we declare in the same way as our GET requests above.

app.post('/employee', (req, res) => {
  res.sendStatus(200)
})

Restart your application to apply our code changes.

Our new route doesn’t do anything, other than return a 200 OK status because, before we get into writing the logic, I want to talk a bit about how we can make a POST request.

When you enter an address into a browser, like we did in the previous steps ( e.g. http://localhost:3000/hello ), we are requesting a resource by making a GET request.

We can’t use the same mechanism to make any other type of request (POST, PUT, DELETE etc), so how do we reach these endpoints? There are quite a few different methods, but we’re only going to focus on one - CURL.

To make a POST request, to our new endpoint, using CURL, run the following command in a terminal:

curl -X POST 'http://localhost:3000/employee'

The only functionality we added to our new endpoint was to return a 200 OK status, which is what you should see as a response in your terminal.

$ curl -X POST 'http://localhost:3000/employee'
OK

Let’s build this logic out to add an employee to our employees object.

The first thing we need to do is to get the new employees details. If we look at our existing employees, we need three pieces of information - firstName, lastName and department.

In the last section we used the req.params property to extract the id URL parameter. When dealing with a POST request, we have the ability to use a request body.

Using CURL, we can combine the Header (-H) flag to specify a content type, which informs the server what format the request content is in, and the Data (--data) flag to pass through a JSON object.

We’ll sending a JSON object so we’ll set a Content-Type header or application/json, to tell the server we’re sending JSON, and we’ll specify our new employee as data:

CURL -X POST 'http://localhost:3000/employee' -H 'content-type: application/json' --data '{"firstName": "John", "lastName": "Doe", "department": "engineering"}'

We are now making a POST request, to http://localhost:3000/employee, with the above JSON object as our Request Body.

By default, our Express application won’t parse this JSON object, so we need to enable some middleware to enable it.

const express = require('express')
const app = express()
const port = 3000

/**
-- Employee object
*/

/** 
Middleware that looks at requests with an application/json 
Content-Type header and stores the request body, as JSON,
in req.body
*/
app.use(express.json())

/**
-- Other endpoints
*/

app.post('/employee', (req, res) => {
  console.log(req.body)
  res.sendStatus(200)
})

Before defining any of your routes, tell your app to use the express.json middleware. Then, in our new endpoint, log the Request Body.

Restart the application and make the request, with the JSON request body, using CURL. You should see the following output in the terminal running your application:

$ node index.js
App listening on port 3000!
{ firstName: 'John', lastName: 'Doe', department: 'engineering' }

We can now receive a new employee object from our new POST endpoint, so let’s build out our logic to ensure we get all three required fields (firstName, lastName and department), construct the id from the firstName and lastName, and then add it to our employee object if that id isn’t already in use.

app.post('/employee', (req, res) => {
  const { firstName, lastName, department } = req.body

  if (!firstName || !lastName || !department) {
    // 400 = bad request. It indicates to the user that
    // there was something wrong with their request.
    return res.status(400).send('One or more required fields are missing')
  }

  const id = (firstName[0] + lastName).toLowerCase()

  if (employees[id]) {
    // Provide a custom message so the user knows what the
    // problem with the request is.
    return res.status(400).send('A user with that id already exists')
  }

  // We set the employee properties explicitly, just in case
  // the user sends other fields through that we're not interested
  // in storing.
  employees[id] = { firstName, lastName, department }

  res.sendStatus(200)
})

Restart the application and try the following scenarios:

Make a POST request without one or more of the required fields.
Make a POST request with a firstName and lastName that makes an id which already exists (e.g. Sarah Brown which would conflict with Steve Brown).
Make a POST request that succeeds and then make a GET request that retrieves the new employees details.

Now, let’s use what we’ve learnt so far to create a new DELETE endpoint that takes an employees id and removes it from our employees object.

app.delete('/employee/:id', (req, res) => {
  const employee = employees[req.params.id]

  if (!employee) {
    return res.sendStatus(404)
  }

  delete employees[req.params.id];

  res.sendStatus(200)
})

You’ll notice this is very similar to our GET employee endpoint; we’re using the URL parameter, checking that the employee exists and returning a 200 status if everything succeeds. The only difference is we delete the employee, from the employees object, by their id.

Making a DELETE request in CURL is very similar to the POST request we saw above:

curl -X DELETE 'http://localhost:3000/employee/sbrown'

Restart the application and try the following:

Make a DELETE request to our new endpoint, with an existing employee id (e.g. http://localhost:3000/employees/sbrown).
Make a GET request to our employees endpoint, with the same employee id (e.g. http://localhost:3000/employees/sbrown) and see that you now get a 404 Not Found response.

Congratulations - you’ve created a CRUD API!

In this step we really took our API to the next level, by allowing our users to add and delete employees, and we learnt how to deal with POST data by enabling the express.json middleware.

Step 3 — Deploy the API to Digital Ocean

We now have an API that can create, delete and retrieve an employee. What we’ve done so far is awesome, but it only lives on our laptop. To take our application to the next level, we need to host it on a publicly accessible server that we can access it from anywhere in the world.

As per our prerequisites, you should have a Digital Ocean server. First, make a new directory on your server.

$ mkdir ~/simple-crud

Next, using a terminal in your local project directory, copy the necessary files to your server by running the following command:

$ scp package-lock.json package.json server.js ubuntu@YOUR_IP:./simple-crud/

Replace ubuntu with the user you created, and YOUR_IP` with your servers public IP address.

We’ve now copied our package-lock.json, package.json and server.js file to our new simple-crud folder on our server.

Next, while in the simple-crud folder on your server, install the applications dependencies:

`
$ npm i

Lastly, start the application using PM2:

`
$ pm2 start server.js --name "simple-crud"

To make sure the application has started correctly, you can run pm2 logs and ensure you see the following log line:

`
$ pm2 logs
0|simple-c | App listening on port 3000!

Next, we’ll amend the default NGINX server block to forward all requests to our application.

Use vi to edit the default configuration:

`
$ sudo vi /etc/nginx/sites-available/default

Then, replace the root location (location /) with the following code, which will forward any HTTP requests to our application.

`
location / {
proxy_pass http://localhost:3000;
proxy_http_version 1.1;
proxy_set_header Upgrade $http_upgrade;
proxy_set_header Connection 'upgrade';
proxy_set_header Host $host;
proxy_cache_bypass $
}

In this step we took our application from only running on our laptop, to running on a Digital Ocean server, meaning our application can be accessed from anywhere in the world!

Step 4 — Use our new API, hosted on Digital Ocean, instead of localhost

We now have an application running on a Digital Ocean server, that can be accessed from anywhere in the world. We know how to access our API locally, but how do we interact with it now?

We just replace localhost with our public IP address in our CURL commands:

`
$ curl -X GET 'http://157.245.243.1/employee/sbrown'
{"firstName":"Steve","lastName":"Brown","department":"Engineering"}

$ curl -X POST 'http://157.245.243.1/employee' -H 'content-type: application/json' --data '{"firstName": "John", "lastName": "Doe", "department": "engineering"}'
OK

$ curl -X DELETE 'http://157.245.243.1/employee/jsmith'
OK

Conclusion

You have successfully created a CRUD API, with in-memory state, and you deployed it to a Digital Ocean server meaning you can interact with it from anywhere using a public IP address.

CodeTips strives to help beginners, with zero or very little experience, learn to code.

We do cross-post to other sites to reach a wider audience, but why not subscribe to our newsletter and get the newest articles straight to your mailbox?

The original source for this content is CodeTips. The original content is kept up-to-date, but other sources may not be the latest version.

Two Sum

Si — Tue, 17 Dec 2019 18:01:57 +0000

CodeTips strives to help beginners, with zero or very little experience, learn to code.

We do cross-post to other sites to reach a wider audience, but why not subscribe to our newsletter and get the newest articles straight to your mailbox?

The original source for this content is CodeTips. The original content is kept up-to-date, but other sources may not be the latest version.

In this article, we bring you another challenge from AlgoDaily called Two Sum.

We recommend trying to complete the challenge yourself, before reading our explanation, here.

The Challenge

Given an array of integers, return the indices of the two numbers in it that add up to a specific goal number.

So let's say our goal number was 10. Our numbers to sum to it would be 3 and 7, and their indices 1 and 3 respectively.

let arr = [1, 3, 6, 7, 9];
let goal = 10;
twoSum(arr, goal); // [1, 3]

You may assume that each input would have exactly one solution. Additionally, you may not use the same element twice. For example, if given a slice of [1,3] and a goal of 2, you cannot use 1 twice and return [0,0] as your answer.

Test Cases

Expect twoSum([1,9,13,20,47], 10) to equal [0,1].
Expect twoSum([3,2,4,1,9], 12) to equal [0,4].
Expect twoSum([], 10) to equal [].

Learn to complete this challenge using:

if you don’t see your favourite language here, feel free to leave a comment and tell us which one you’d like us to cover or check back at another time and see if we’ve added it.

The solutions and test cases for this challenge can be found on our GitHub account.

Go

First, let’s define our test cases in a file called twosum_test.go. We’ll use a Table Driven Test to keep our test cases free of unnecessary duplication and keep them easy to read/maintain.

// twosum_test.go

package twosum

import (
    "fmt"
    "reflect"
    "testing"
)

func TestTwoSum(t *testing.T) {
    testCases := []struct {
        nums []int
        goal int
        expected []int
    }{
        {
            nums: []int{1, 9, 13, 20, 47},
            goal: 10,
            expected: []int{0, 1},
        },
        {
            nums: []int{3, 2, 4, 1, 9},
            goal: 12,
            expected: []int{0, 4},
        },
        {
            nums: []int{},
            goal: 10,
            expected: []int{},
        },
    }
    for ix, tC := range testCases {
        t.Run(fmt.Sprintf("test %d - TwoSum should return expected output", ix), func(t *testing.T) {
            output := TwoSum(tC.nums, tC.goal)

            if !reflect.DeepEqual(tC.expected, output) {
                t.Errorf("expected '%+v' to equal '%+v', but it did not", output, tC.expected)
            }

        })
    }
}

Next, let’s create our TwoSum function declaration. We already know from the test description that we expect a slice of indices and a goal, as input, and that we should return a slice of indices that sum up to the goal, or an empty slice if a match isn’t found.

package twosum

// TwoSum takes a slice of ints and an expected goal, and returns the
// indices that sum together to reach that goal, or an empty slice otherwise.
func TwoSum(nums []int, goal int) []int {
    return []int{}
}

Note: going forward we will omit the package and import statements, but they can be found on our GitHub account.

Running our tests we get two expected failures, and one passing test (because we hardcoded a response of an empty slice).

go test -v ./...
=== RUN TestTwoSum
=== RUN TestTwoSum/test_0_-_TwoSum_should_return_expected_output
=== RUN TestTwoSum/test_1_-_TwoSum_should_return_expected_output
=== RUN TestTwoSum/test_2_-_TwoSum_should_return_expected_output
--- FAIL: TestTwoSum (0.00s)
    --- FAIL: TestTwoSum/test_0_-_TwoSum_should_return_expected_output (0.00s)
        twosum_test.go:36: expected '[]' to equal '[0 1]', but it did not
    --- FAIL: TestTwoSum/test_1_-_TwoSum_should_return_expected_output (0.00s)
        twosum_test.go:36: expected '[]' to equal '[0 4]', but it did not
    --- PASS: TestTwoSum/test_2_-_TwoSum_should_return_expected_output (0.00s)
FAIL

We need to compare two indices at a time, to see if they sum up to the goal. For example, when given an input of [0,1,12,20,9] and 10 we could write down the logic like so:

Take the number at index 0 (0)
- Take the number at index 1 (1), do the numbers equal 10? No, continue.
- Take the number at index 2 (12), do the numbers equal 10? No, continue.
- Take the number at index 3 (20), do the numbers equal 10? No, continue.
- Take the number at index 4 (9), do the numbers equal 10? No, continue.
Take the number at index 1 (1)
- Take the number at index 2 (12), do the numbers equal 10? No, continue.
- Take the number at index 3 (20), do the numbers equal 10? No, continue.
- Take the number at index 4 (9), do the numbers equal 10? Yes! Return index 1 and index 4 ([1,4]).

Let’s print the indices out first, to make sure we’re getting the expected behaviour.

func TwoSum(nums []int, goal int) []int {
    for ix := range nums {
        for i := ix + 1; i < len(nums)-1; i++ {
            fmt.Printf("Outer index: %d, Inner index: %d \n", ix, i)
        }
    }

    return []int{}
}

Now let’s add another test case to our Table Driven Test (below).

{
    nums: []int{0, 1, 12, 20, 9},
    goal: 10,
    expected: []int{1, 4},
},

And we’ll comment out the rest of the tests just to observe the Printf statements for our new test case:

go test -v ./...
=== RUN TestTwoSum
=== RUN TestTwoSum/test_0_-_TwoSum_should_return_expected_output
Outer index: 0, Inner index: 1 
Outer index: 0, Inner index: 2 
Outer index: 0, Inner index: 3 
Outer index: 0, Inner index: 4 
Outer index: 1, Inner index: 2 
Outer index: 1, Inner index: 3 
Outer index: 1, Inner index: 4 
Outer index: 2, Inner index: 3 
Outer index: 2, Inner index: 4 
Outer index: 3, Inner index: 4

Excellent, now all we need to do is check to see if the values equal our goal and, if they do, return the indices. If we never reach our goal (i.e. our loops end), we return an empty slice to signify that a match wasn’t found.

func TwoSum(nums []int, goal int) []int {
    for ix := range nums {
        for i := ix + 1; i < len(nums); i++ {
            if nums[ix]+nums[i] == goal {
                return []int{ix, i}
            }
        }
    }

    return []int{}
}

Let’s uncomment and run all of our test cases and make sure they all pass

go test -v ./...
=== RUN TestTwoSum
=== RUN TestTwoSum/test_0_-_TwoSum_should_return_expected_output
=== RUN TestTwoSum/test_1_-_TwoSum_should_return_expected_output
=== RUN TestTwoSum/test_2_-_TwoSum_should_return_expected_output
=== RUN TestTwoSum/test_3_-_TwoSum_should_return_expected_output
--- PASS: TestTwoSum (0.00s)
    --- PASS: TestTwoSum/test_0_-_TwoSum_should_return_expected_output (0.00s)
    --- PASS: TestTwoSum/test_1_-_TwoSum_should_return_expected_output (0.00s)
    --- PASS: TestTwoSum/test_2_-_TwoSum_should_return_expected_output (0.00s)

Four passing test cases! But we’re not done yet! Although this solution works, we need to consider if it’s a “good” solution.

Because we’re using two loops, we’ve introduced the possibility that our code will need to process every element in our nums slice n number of times (where n is the length of the slice)!

Imagine if someone passed in a slice with a million elements, and how many loops we’d be running! We can characterise this Algorithmic Complexity as Quadratic or O(n^2), which is very well described here. Luckily, there is a better way!

First, let’s comment out all of our tests, like we did before, apart from the one below:

{
    nums: []int{0, 1, 12, 20, 9},
    goal: 10,
    expected: []int{1, 4},
},

Next, we’re going to make a map of processed elements and will be constructed of the following:

Our key will be the result of the goal minus the current element.
Out value will be the index of the current element.

func TwoSum(nums []int, goal int) []int {
    processed := make(map[int]int)

    for index, currentValue := range nums {
        currentSubtraction := goal - currentValue

        processed[currentSubtraction] = index
    }

    fmt.Printf("%+v", processed)

    return []int{}
}

Running our tests again will fail, because we’ve not implemented all of our logic yet, but we should see the output of our processed map.

=== RUN TestTwoSum/test_0_-_TwoSum_should_return_expected_output
map[-10:3 -2:2 1:4 9:1 10:0]--- FAIL: TestTwoSum (0.00s)

Here we see the outputs of the goal (10) minus each element (0, 1, 12, 20 and 9) as the keys and their index positions as the values.

So how does this actually help us? Well, we know what the subtraction is of the current element, therefore we know what value we need in order to make the goal, we also know the subtractions of the elements that have come before it, so we can work out if we have an index that satisfies the TwoSum requirement.

That’s a really confusing statement, so let’s break it down step-by-step. First, let’s define what we mean by these statements:

Current subtraction - goal - currentValue
Required value to satisfy requirement - goal - currentSubtraction

Now, let’s go through the slice we’re using in our test case ([0, 1, 12, 20, 9] step-by-step:

Index 0, Value 0
- Current subtraction ( 10 - 0) = 10
- Required value to satisfy requirement (10 - 10) = 0
- Do we have an element in our map with a key of 0? No.
Index 1, Value 1
- Current subtraction (10 - 1) = 9
- Required value to satisfy requirement (10 - 9) = 1
- Do we have an element in our map with a key of 1? No.
Index 2, Value 12
- Current subtraction (10 - 12) = -2
- Required value to satisfy requirement (10 - -2) = 12
- Do we have an element in our map with a key of 12? No.
Index 3, Value 20
- Current subtraction (10 - 20) = -10
- Required value to satisfy requirement (10 - -10) = 20
- Do we have an element in our map with a key of 20? No.
Index 4, Value 9
- Current subtraction (10 - 9) = 1
- Required value to satisfy requirement (10 - 1) = 9
- Do we have an element in our map with a key of 9? Yes! So we return [1,4] which represents the index of the found item (1) and the current index (4).

And we can write this in code, using exactly the same logic, like so:

func TwoSum(nums []int, goal int) []int {
    processed := make(map[int]int)

    for index, currentValue := range nums {
        currentSubtraction := goal - currentValue
        requiredValue := goal - currentSubtraction

        ix, ok := processed[requiredValue]
        if ok {
            return []int{ix, index}
        }

        processed[currentSubtraction] = index
    }

    return []int{}
}

Now, let’s uncomment all of our test cases and run them one final time:

$ go test -v ./...
=== RUN TestTwoSum
=== RUN TestTwoSum/test_0_-_TwoSum_should_return_expected_output
=== RUN TestTwoSum/test_1_-_TwoSum_should_return_expected_output
=== RUN TestTwoSum/test_2_-_TwoSum_should_return_expected_output
map[]=== RUN TestTwoSum/test_3_-_TwoSum_should_return_expected_output
=== RUN TestTwoSum/test_4_-_TwoSum_should_return_expected_output
=== RUN TestTwoSum/test_5_-_TwoSum_should_return_expected_output
--- PASS: TestTwoSum (0.00s)
    --- PASS: TestTwoSum/test_0_-_TwoSum_should_return_expected_output (0.00s)
    --- PASS: TestTwoSum/test_1_-_TwoSum_should_return_expected_output (0.00s)
    --- PASS: TestTwoSum/test_2_-_TwoSum_should_return_expected_output (0.00s)
    --- PASS: TestTwoSum/test_3_-_TwoSum_should_return_expected_output (0.00s)
    --- PASS: TestTwoSum/test_4_-_TwoSum_should_return_expected_output (0.00s)
    --- PASS: TestTwoSum/test_5_-_TwoSum_should_return_expected_output (0.00s)
PASS

And now, we only ever loop through our nums slice once! We can characterise this Algorithmic Complexity as Linear or O(n), which is a much better solution.

CodeTips strives to help beginners, with zero or very little experience, learn to code.

We do cross-post to other sites to reach a wider audience, but why not subscribe to our newsletter and get the newest articles straight to your mailbox?

The original source for this content is CodeTips. The original content is kept up-to-date, but other sources may not be the latest version.

Table Driven Tests

Si — Tue, 03 Dec 2019 15:48:30 +0000

In this article, we’re going to discuss the table-driven test strategy in Go, although this could easily be applied to other languages. Before reading, you should have an understanding of what Testing is.

Let’s start by creating a function that takes a string, and returns the reverse of it.

// ReverseString takes an input string and returns it reversed
func ReverseString(input string) string {
    runes := []rune(input)
    for i, j := 0, len(runes)-1; i < j; i, j = i+1, j-1 {
        runes[i], runes[j] = runes[j], runes[i]
    }

    return string(runes)
}

As is common practice when we want to ensure a function does what we expect it to do, we'll add some tests.

If we weren't going to use the table-driven test approach, we might write our tests like the below (using subtests to break each test up into its own section):

func TestReverseString(t *testing.T) {
    t.Run("abiglongsentence should return ecnetnesgnolgiba", func(t *testing.T) {
        input := "abiglongsentence"
        expected := "ecnetnesgnolgiba"

        output := ReverseString(input)

        if output != expected {
            t.Errorf("Expected %s to return %s, but got %s", input, expected, output)
        }
    })

    t.Run("word should return drow", func(t *testing.T) {
        input := "word"
        expected := "drow"

        output := ReverseString(input)

        if output != expected {
            t.Errorf("Expected %s to return %s, but got %s", input, expected, output)
        }

    })

    t.Run("山上的人 should return 人的上山", func(t *testing.T) {
        input := "山上的人"
        expected := "人的上山"

        output := ReverseString(input)

        if output != expected {
            t.Errorf("Expected %s to return %s, but got %s", input, expected, output)
        }

    })

    t.Run("The quick brown 狐 jumped over the lazy 犬 should return 犬 yzal eht revo depmuj 狐 nworb kciuq ehT", func(t *testing.T) {
        input := "The quick brown 狐 jumped over the lazy 犬"
        expected := "犬 yzal eht revo depmuj 狐 nworb kciuq ehT"

        output := ReverseString(input)

        if output != expected {
            t.Errorf("Expected %s to return %s, but got %s", input, expected, output)
        }
    })
}

This doesn’t look great; we’re duplicating a lot of code and it’s not exactly easy to see all of our test cases in one glance. If we extended this test to 100 different permutations, we’d have to scroll down the entire test looking for the different input strings.

Luckily, our ReverseString method is small and simple so our tests are also simple, even if we are duplicating a lot of code.

Adding additional tests is straightforward, but we’ll be adding at least eleven lines of code for each new test case. Let’s look at how we can utilise the table-driven test approach to reduce the duplication and make it more readable.

func TestReverseString(t *testing.T) {
    testCases := []struct {
        input string
        expected string
    }{
        {input: "abiglongsentence", expected: "ecnetnesgnolgiba"},
        {input: "word", expected: "drow"},
        {input: "山上的人", expected: "人的上山"},
        {input: "The quick brown 狐 jumped over the lazy 犬", expected: "犬 yzal eht revo depmuj 狐 nworb kciuq ehT"},
    }
    for _, tC := range testCases {
        t.Run(fmt.Sprintf("'%s' should return '%s'", tC.input, tC.expected), func(t *testing.T) {
            output := ReverseString(tC.input)

            if output != tC.expected {
                t.Errorf("Expected %s to return %s, but got %s", tC.input, tC.expected, output)
            }
        })
    }
}

First, we make a slice of structs, that specify the input into our ReverseString function, and the expected result. Then, we loop over the items in the slice and run the same test logic we had before, except this time we only need to define it once.

Adding a new test is as simple as creating a new item in our slice, and our for range loop will handle the rest.

CodeTips is Changing

Si — Mon, 02 Dec 2019 18:02:04 +0000

Today, we're happy to announce three important changes to CodeTips.

No More Ads

We've come to the decision to remove all the Ads from CodeTips. Although we received no negative feedback, we feel they were getting in the way and we didn't think there was enough benefits to keeping them.

Instead, we've launched a Patreon page. If you'd like to contribute, we'd be very grateful, but there is no pressure whatsoever.

Comment Integration

We've added Disqus integration, so you'll be able to interact with the CodeTips writers directly through their articles.

No More Journeys

When CodeTips started, we wanted to provide a place for absolute beginners to come and learn the fundamentals of programming.

Originally, we thought the best way to do this was to create a specific "journey" that each programming language would follow. That meant that learning Go and JavaScript would follow a very similar path, and should help our readers understanding.

We are now changing that plan. We believe the articles we have already created provide a solid foundation for anybody wanting to pick up the basics, and now we're going to focus on each language individually. Our writers will now be able to create the content they want to create, for the language(s) they want to create it for. This means that our Go articles will move at a completely different pace to our Python articles, and may be on completely different topics, but we believe we'll be able to provide more quality articles this way.

Basically, we're moving towards a more traditional "blog" approach. This week you might read about Go pointers, next week you might learn the difference between the double equals (==) and triple equals (===) operators in JavaScript.

What does this mean for our readers? Hopefully this means more quality articles, on topics that you want to read about.

CodeTips strives to help beginners, with zero or very little experience, learn to code.

We do cross-post to other sites to reach a wider audience, but why not subscribe to our newsletter and get the newest articles straight to your mailbox?

The original source for this content is CodeTips. The original content is kept up-to-date, but other sources may not be the latest version.

I don't code outside of work

Si — Sat, 30 Nov 2019 08:52:24 +0000

I've been a developer for about 6 years now, and I love my job. I've found a decent company, an awesome working environment, and I actually enjoy being a software engineer.

Unfortunately, in this industry, there can be an expectation that you'll be doing it in your own time, on your own projects, to keep up with new technologies.

Well, I'm here to tell you it's not a requirement to being successful.

Sure I've done my own projects, with varying levels of success, but they were born out of interest not requirement.

I have a young family, so any time not spent working goes on them. I could have probably learnt {insert newest JavaScript framework here}, but personal life is important.

Put whatever time you can into it, and don't feel guilty if you can't give more.

CodeTips strives to help beginners, with zero or very little experience, learn to code.

We do cross-post to other sites to reach a wider audience, but why not subscribe to our newsletter and get the newest articles straight to your mailbox?

The original source for this content is CodeTips. The original content is kept up-to-date, but other sources may not be the latest version.

CodeTips first Open Source Project

Si — Wed, 18 Sep 2019 11:57:22 +0000

CodeTips are proud to announce our first Open Source project, RSS-Twitter.

Take one or more RSS feeds and automatically tweet new articles.

There is still a way to go (e.g. improving the README), but it's officially "live".

https://github.com/RealCodeTips/RSS-Twitter

Fizz Buzz

Si — Sun, 25 Aug 2019 17:36:00 +0000

CodeTips strives to help beginners, with zero or very little experience, learn to code.

We do cross-post to other sites to reach a wider audience, but why not subscribe to our newsletter and get the newest articles straight to your mailbox?

The original source for this content is CodeTips. The original content is kept up-to-date, but other sources may not be the latest version.

In this article, we bring you a challenge called Fizz Buzz, which was provided by AlgoDaily.

We recommend trying to complete the challenge yourself, before reading our explanation, here.

The Challenge

We're given a number n.

Write a function that returns the string representation of all numbers from 1 to n based on the following rules:

If it's a multiple of three, represent it as "fizz".
If it's a multiple of five, represent it as "buzz".
If it's a multiple of both three and five, represent it as "fizzbuzz".
If it's neither, just return the number itself.

As such, fizzBuzz(15) would result in '12fizz4buzzfizz78fizzbuzz11fizz1314fizzbuzz'.

Test Cases

Expect fizzBuzz(0) to equal ''
Expect fizzBuzz(1) to equal '1'
Expect fizzBuzz(15) to equal '12fizz4buzzfizz78fizzbuzz11fizz1314fizzbuzz'

Learn how to complete this challenge using:

JavaScript
Go

The solutions and test cases for this challenge can be found on our GitHub account.

JavaScript

First, we'll create the fizzBuzz function and a loop that prints the numbers from 0 to the parameter value n.

const fizzBuzz = n => {
  for (let i = 0; i < n; i++) {
    console.log(i)
  }
}

fizzBuzz(4) // prints 0, 1, 2, 3
fizzBuzz(10) // prints 0, 1, 2, 3, 4, 5, 6, 7, 8, 9
fizzBuzz(1) // prints 0

We already know, from the test cases above, that this is not the expected behaviour, as the numbers should start from 1, not 0.

The loop should also continue until we reach the value of n, whereas it's currently stopping one number short (e.g. fizzBuzz(4) stops at 3 instead of 4).

We can fix these issues by:

Assigning the value of i to 1 in the initialisation statement (let i = 1).
Amending the condition expression from "i is less than n" (i < n) to "i is less than or equal to n" (i <= n).

const fizzBuzz = n => {
  for (let i = 1; i <= n; i++) {
    console.log(i)
  }
}

fizzBuzz(4) // prints 1, 2, 3, 4
fizzBuzz(10) // prints 1, 2, 3, 4, 5, 6, 7, 8, 9, 10
fizzBuzz(1) // prints 1

Next, let's work out if each number is a multiple of three and/or five. To do that, we're going to use the modulus (%) operator:

const fizzBuzz = n => {
  for (let i = 1; i <= n; i++) {
    if (i % 3 === 0) {
      console.log(`${i} is a multiple of three`)
    }
    if (i % 5 === 0) {
      console.log(`${i} is a multiple of five`)
    }
  }
}

fizzBuzz(4)
/**
3 is a multiple of three
*/
fizzBuzz(15)
/**
3 is a multiple of three
5 is a multiple of five
6 is a multiple of three
9 is a multiple of three
10 is a multiple of five
12 is a multiple of three
15 is a multiple of three
15 is a multiple of five
*/
fizzBuzz(1) 
/**
*/

Now, let's add a new result variable which we'll use to append the correct representation for each number; as per the challenge description:

const fizzBuzz = n => {
  let result = ''
  for (let i = 1; i <= n; i++) {
    if (i % 3 === 0) {
      result += 'fizz'
    } else if (i % 5 === 0) {
      result += 'buzz'
    } else {
      result += i
    }
  }
  return result
}

console.log(fizzBuzz(4)) // 12fizz4
console.log(fizzBuzz(15)) // 12fizz4buzzfizz78fizzbuzz11fizz1314fizz
console.log(fizzBuzz(1)) // 1

It might look like we've finished, but there is one thing missing. See if you can figure out what isn't right, using the challenge test cases, before we move on.

You should have seen that fizzbBuzz(15) didn't return the correct value. The reason is the third challenge requirement:

If it's a multiple of both three and five, represent it as "fizzbuzz".

We're representing fifteen, which is a multiple of both three and five, as fizz instead of fizzbuzz, because we're not checking if a number matches both conditions. Let's add that now:

const fizzBuzz = n => {
  let result = ''
  for (let i = 1; i <= n; i++) {
    if (i % 3 === 0 && i % 5 === 0) {
      result += 'fizzbuzz'
    } else if (i % 3 === 0) {
      result += 'fizz'
    } else if (i % 5 === 0) {
      result += 'buzz'
    } else {
      result += i
    }
  }
  return result
}

console.log(fizzBuzz(4)) // 12fizz4
console.log(fizzBuzz(15)) // 12fizz4buzzfizz78fizzbuzz11fizz1314fizzbuzz
console.log(fizzBuzz(1)) // 1

As the last step, let's make our code more readable, and reduce duplication, by using variables:

const fizzBuzz = n => {
  let result = ''
  for (let i = 1; i <= n; i++) {
    const multipleOfThree = i % 3 === 0
    const multipleOfFive = i % 5 === 0

    if (multipleOfThree && multipleOfFive) {
      result += 'fizzbuzz'
    } else if (multipleOfThree) {
      result += 'fizz'
    } else if (multipleOfFive) {
      result += 'buzz'
    } else {
      result += i
    }
  }
  return result
}

We've now completed the FizzBuzz challenge in JavaScript! Keep reading to learn how to complete it using Go.

Go

First, we'll create the fizzBuzz function and a loop that prints the numbers from 0 to the parameter value n.

package main

import "fmt"

func fizzBuzz(n int) {
    for i := 0; i < n; i++ {
        fmt.Println(i)
    }
}

func main() {
    fizzBuzz(4) // prints 0, 1, 2, 3
    fizzBuzz(10) // prints 0, 1, 2, 3, 4, 5, 6, 7, 8, 9
    fizzBuzz(1) // prints 0
}

In the challenge description, we were given an example output of 12fizz4buzzfizz78fizzbuzz11fizz1314fizzbuzz, when provided an input of 15.

Notice how the expected output starts at 1 and ends with the value of n (i.e. 15 or in this case fizzbuzz).

If we look at what our fizzBuzz function is printing, we're starting at 0 and ending one number short of n.

We can fix these issues by:

Assigning the value of i to 1 in the init statement (i := 1).
Amending the condition expression from "i is less than n" (i < n) to "i is less than or equal to n" (i <= n).

package main

import "fmt"

func fizzBuzz(n int) {
    for i := 1; i <= n; i++ {
        fmt.Println(i)
    }
}

func main() {
    fizzBuzz(4) // prints 1, 2, 3, 4
    fizzBuzz(10) // prints 1, 2, 3, 4, 5, 6, 7, 8, 9, 10
    fizzBuzz(1) // prints 1
}

Next, let's work out if each number is a multiple of three and/or five. To do that, we're going to use the modulus (%) operator:

package main

import "fmt"

func fizzBuzz(n int) {
    for i := 1; i <= n; i++ {
        if i%3 == 0 {
            fmt.Printf("%d is a multiple of three\n", i)
        }
        if i%5 == 0 {
            fmt.Printf("%d is a multiple of five\n", i)
        }
    }
}

func main() {
    fizzBuzz(4)
    /**
    3 is a multiple of three
    */
    fizzBuzz(15)
    /**
    3 is a multiple of three
    5 is a multiple of five
    6 is a multiple of three
    9 is a multiple of three
    10 is a multiple of five
    12 is a multiple of three
    15 is a multiple of three
    15 is a multiple of five
    */
    fizzBuzz(1)
    /**
     */
}

Now, let's add a new result variable which we'll use to append the correct representation for each number; as per the challenge description:

package main

import "strconv"

func fizzBuzz(n int) {
    var result string
    for i := 1; i <= n; i++ {
        if i%3 == 0 {
            result += "fizz"
        } else if i%5 == 0 {
            result += "buzz"
        } else {
            result += strconv.Itoa(i)
        }
    }
}

func main() {
    fizzBuzz(4)
    fizzBuzz(15)
    fizzBuzz(1)
}

Because Go is a strongly-typed language, we have to convert the type of i from an int to a string, using the Itoa method from the strconv package, to match the type of the result variable.

Next, we need to update our fizzBuzz function to return our result variable. To do this we add a return type of string and add the return statement at the end of the function.

package main

import (
    "fmt"
    "strconv"
)

func fizzBuzz(n int) string {
    var result string
    for i := 1; i <= n; i++ {
        if i%3 == 0 {
            result += "fizz"
        } else if i%5 == 0 {
            result += "buzz"
        } else {
            result += strconv.Itoa(i)
        }
    }
    return result
}

func main() {
    fmt.Println(fizzBuzz(4)) // 12fizz4
    fmt.Println(fizzBuzz(15)) // 12fizz4buzzfizz78fizzbuzz11fizz1314fizz
    fmt.Println(fizzBuzz(1)) // 1
}

It might look like we've finished, but there is one thing missing. See if you can figure out what isn't right, using the challenge test cases, before we move on.

You should have seen that fizzbBuzz(15) didn't return the correct value. The reason is the third challenge requirement:

If it's a multiple of both three and five, represent it as "fizzbuzz".

We're representing fifteen, which is a multiple of both three and five, as fizz instead of fizzbuzz, because we're not checking if a number matches both conditions. Let's add that now:

package main

import (
    "fmt"
    "strconv"
)

func fizzBuzz(n int) string {
    var result string
    for i := 1; i <= n; i++ {
        if i%3 == 0 && i%5 == 0 {
            result += "fizzbuzz"
        } else if i%3 == 0 {
            result += "fizz"
        } else if i%5 == 0 {
            result += "buzz"
        } else {
            result += strconv.Itoa(i)
        }
    }
    return result
}

func main() {
    fmt.Println(fizzBuzz(4)) // 12fizz4
    fmt.Println(fizzBuzz(15)) // 12fizz4buzzfizz78fizzbuzz11fizz1314fizzbuzz
    fmt.Println(fizzBuzz(1)) // 1
}

As the last step, let's make our code more readable, and reduce duplication, by using variables:

package main

import (
    "fmt"
    "strconv"
)

func fizzBuzz(n int) string {
    var result string
    for i := 1; i <= n; i++ {
        multipleOfThree := i%3 == 0
        multipleOfFive := i%5 == 0

        if multipleOfThree && multipleOfFive {
            result += "fizzbuzz"
        } else if multipleOfThree {
            result += "fizz"
        } else if multipleOfFive {
            result += "buzz"
        } else {
            result += strconv.Itoa(i)
        }
    }
    return result
}

func main() {
    fmt.Println(fizzBuzz(4)) // 12fizz4
    fmt.Println(fizzBuzz(15)) // 12fizz4buzzfizz78fizzbuzz11fizz1314fizzbuzz
    fmt.Println(fizzBuzz(1)) // 1
}

Congratulations - we've completed the FizzBuzz challenge in Go! Why not try and solve it using JavaScript too?

Modulus (%) operator

The modulo operation finds the remainder after division of one number by another.

You'd be forgiven if you're still none the wiser about what it means, that "official" explanation isn't exactly clear, so let's look at some examples.

Let's start with some simple division; what is eight divided by four (8 / 4)? That's easy - 2 - because four goes into eight twice.

What is ten divided by four (10 / 4)? This time our result is a fraction, 2.5, because four doesn't go into ten an exact number of times.

Another way of answering ten divided by four, is four goes into ten twice (8) with a remainder of two (10 - 8 = 2). And that's exactly what modulus is; it returns the remainder, so ten modulus four (10 % 4) is two.

How can this help us with Fizz Buzz? Well, if we need to find the numbers which are divisible by three and/or five, we can check for the modulus/remainder value.

For example, to check whether a number is divisible by three:

1 % 3 - three goes into one zero times, so the remainder is one (1 - 0 = 1).
2 % 3 - three goes into two zero times, so the remainder is two (2 - 0 = 2).
3 % 3 - three goes into three one time, so the remainder is zero (3 - 3 = 0).
4 % 3 - four goes into three one time, with a remainder of one (4 - 3 = 1).

Notice how, when the number is divisible by three, the remainder is zero. Therefore, we can say when the remainder is zero the number is a multiple of three.

If anything in this article wasn't clear, feel free to reach out to us!

CodeTips strives to help beginners, with zero or very little experience, learn to code.

We do cross-post to other sites to reach a wider audience, but why not subscribe to our newsletter and get the newest articles straight to your mailbox?

The original source for this content is CodeTips. The original content is kept up-to-date, but other sources may not be the latest version.

An introduction to Coding Challenges

Si — Sun, 25 Aug 2019 17:35:37 +0000

CodeTips strives to help beginners, with zero or very little experience, learn to code.

We do cross-post to other sites to reach a wider audience, but why not subscribe to our newsletter and get the newest articles straight to your mailbox?

The original source for this content is CodeTips. The original content is kept up-to-date, but other sources may not be the latest version.

Welcome to CodeTips newest section - Coding Challenges!

We wanted to give you an introduction to this section because it's completely different from everything we've done up to this point.

Up to now, we've covered general beginner and intermediate programming concepts, and we've covered language-specific tutorials for Go, JavaScript and Python.

One skill programmers must have is problem-solving, which is why you'll often find coding challenges in interviews. A big part of our role is to take a problem/requirement and find the best way to fix/implement it. That's exactly what this section is about.

In each article, we'll look at a different coding challenge, and we'll show you how to complete it using different languages.

The articles in this section expect some prior knowledge of programming, so be sure to refer to the beginner and language-specific articles if you get stuck.

If there's a specific coding challenge you'd like us to write about, you get stuck along the way, or you have any feedback about this section, you can always get in touch with us!

CodeTips strives to help beginners, with zero or very little experience, learn to code.

We do cross-post to other sites to reach a wider audience, but why not subscribe to our newsletter and get the newest articles straight to your mailbox?

The original source for this content is CodeTips. The original content is kept up-to-date, but other sources may not be the latest version.

An interview with Kevin Ball

Si — Tue, 13 Aug 2019 08:23:33 +0000

CodeTips strives to help beginners, with zero or very little experience, learn to code.

We do cross-post to other sites to reach a wider audience, but why not subscribe to our newsletter and get the newest articles straight to your mailbox?

The original source for this content is CodeTips. The original content is kept up-to-date, but other sources may not be the latest version.

In this interview, we speak to Kevin Ball (@kbal11), founder of ZenDev and creator of the Friday Frontend newsletter, about his experiences in the industry.

Could you introduce yourself (name, years in the tech industry, favourite languages etc) and why you agreed to do this interview?

Sure. I'm Kevin Ball (often go by KBall), and I've been in the tech industry since 2004, so 15 years now. I'm pretty pragmatic in terms of language choice, varying what I use based on project/client.

Right now, with my main client, I'm doing a lot of coding in golang, some python, and some JavaScript. That said, my favourite language for pure fun programming is Ruby.

I agreed to do this interview for a couple of reasons. Working in tech has been great for me, making it possible to live a great life & have all sorts of opportunities, and it's important to me to help others get access to that. I also enjoy teaching, do a lot of writing & speaking, and find my best ideas/those that end up resonating best with others often come from questions other people ask, so this is an opportunity to get asked some questions that may turn into great ideas for content. :)

Thanks for the great introduction, and for agreeing to do this interview! After 15 years in the industry, you will have gained a lot of knowledge and seen a lot of changes. What has been the biggest change in the last 15 years, and what one thing do you know now that you wish you could tell yourself 15 years ago?

I think the biggest change is the availability of cloud computing and the vast explosion of open-source software, which has made it infinitely easier to launch and scale software. To give a short example, I remember working for months on a database sharding project because one of our key tables was about to outgrow the *massive* (64GB ram, maybe 512GB disk?) server we had it living on. We needed to split the table across multiple machines, but it had 3 distinct lookup patterns, so it wasn't straightforward to do so. And we had to buy and rack up new servers in our colo to do it. These days, I can simply allocate a cloud SQL server, scale it up via a web interface to a massive 400+GB RAM and 30 freaking TB of disk... but if that's not enough at the click of a button I can spin up a cluster of elasticsearch instances that can scale almost infinitely. All without ever having to touch a single real piece of hardware.

In terms of things I wish I could tell myself, one thing I'd recommend to myself is to worry more about going deep than going wide, especially early on. There are way more things in the tech ecosystem than you could ever learn about, and if you jump around all the time it's hard to build enough expertise to have a big impact. I did that early on, just wanting to try everything. And I see a lot of folks doing that now, they're just getting started and they want to learn React, AND Vue, AND Node.js, AND databases, AND all sorts of other things.

Instead, I recommend (especially early on): pick something and become an expert on it. To advance in your career you need to build up a specialisation in an area where you understand how to get stuff done. And the great thing about software is that there are a lot of concepts in common, so going deep can help you go broad later. If you take the time to master React and understand good component design and how routing works and all of those things, that knowledge will port to Vue or Angular or Svelte or whatever when you decide to move to later on. And if you understand data management and how data flows from an API through different parts of a client application, and what makes APIs easier and harder to work with, that knowledge will help you later when you expand into working on the server and building those APIs. But if you try to learn everything all at once, you end up flailing and it takes a lot longer to learn those deeper concepts.

Cloud computing has changed everything. I consider myself fortunate that it was already a "thing" when I got into the development world, but do you think that has hindered the software developers of today? We can spin up and shut down a server with a button, but is there a negative in there somewhere? Is it now producing experienced developers, that wouldn't know how to install an OS for example? Is that even a bad thing? Should the developers, learning right now, be bothered about learning about the hardware side?

I don't think so, I think it's moving us up a level of abstraction and productivity. To the extent that the abstractions don't leak, you shouldn't need to learn about them.

Back when programming languages like C were first introduced and folks no longer had to learn assembly, there was a lot of belly-aching about how that would lead to lower-quality developers, but I think it instead led to people who think naturally in higher levels of abstraction. Today I don't think anyone would argue you should start your programming experience with assembly, and the same is true of dealing with OS installation etc. If that stuff interests you, great, but I don't believe there is any harm in ignoring it as long as you can.

Trying to learn everything, all at once, is something every developer can relate to I think, so that's a great choice! For developers that are using CodeTips or any medium, to learn how to programme, they will probably get very overwhelmed with all of the choices out there today. There are so many languages to choose from, and new web frameworks popping up every other week, what would you advise to someone, just starting, to learn?

It depends a lot on your personal circumstances and interests. I wrote out a 3-part decision-making framework called "the 3 Mos" for this last year that emphasises 3 considerations: Motivation, Momentum, and Money. Essentially - when deciding what to learn, pay attention to what gets you excited, what will set you up for future learning, and what will either pay for you to learn it or set you up to make an income from it quickly.

If you're in the front-end space for most people Momentum and Money both speak in favour of deep diving on React, there's a tremendous number of jobs and freelance opportunities out there for React, and the core concepts are very aligned with the broader trends in front-end development so you're also set up well for any future changes. That said if it doesn't get you excited you're not going to learn well so take a look at other options. I love Vue.js and find it is easier for a lot of folks to learn over React, especially if you're coming from a less traditional programming or more visual background. If you've already got a job, look for opportunities around what is being used there (or what they're interested in) so you can get paid to learn.

It's very tempting to try to follow "the flavour of the week" but, especially when you're starting, that is a path to being overwhelmed. I'm a big advocate of pragmatism and compounding growth. Focus on things that give you momentum for the future and where you can either get paid to learn right away or very quickly so you're not having to split time between paid "non-learning" and unpaid learning.

Is there anything else you'd like to add, for anyone reading this interview?

I think it’s important to highlight that software can be a great career even if you don’t want to spend every minute coding. You do need to invest more time than most career paths in staying up to date and continually learning, but the hype about having to be “super passionate” about coding and code all the time is bogus. You can craft a great work-life balance and use this to support your life even if it isn’t your life. I know people who have used freelance web dev to support their passions as pro musicians, actors, and travellers.

Other than that if folks are interested in frontend they might like my newsletter, and if they have questions my Twitter DMs are open or my email is easy to find on my website.

CodeTips strives to help beginners, with zero or very little experience, learn to code.

We do cross-post to other sites to reach a wider audience, but why not subscribe to our newsletter and get the newest articles straight to your mailbox?

The original source for this content is CodeTips. The original content is kept up-to-date, but other sources may not be the latest version.

Arrays and Loops in JavaScript

Si — Thu, 18 Jul 2019 15:07:55 +0000

Before reading this article, you should have an understanding of arrays, types and loops.

In "writing your first JavaScript programme”, we wrote a programme that outputted my name, age and profession.

You were asked to complete two challenges at the end of the "writing your first JavaScript programme” article (below).

Change the variables so the programme prints out your name, age and profession, instead of mine.
Add a new variable, favoriteAnimal, and incorporate that into your outputted sentence.

To complete the second challenge, you should have ended up with something like the following:

const name = "Simon"
const age = 29
const profession = "Developer"
const favouriteAnimal = "dog"

console.log(`
  Welcome to my first JavaScript programme. 
  My name is ${name}. 
  I am ${age} years old. 
  I work as a ${profession}.
  My favourite animal is a ${favouriteAnimal}`
)

In this article, we’re going to extend our programme and have it print out all of our hobbies.

I have three main hobbies, so the obvious thing is to create three new variables just like we did with our name, age etc variables.

const name = "Simon"
const age = 29
const profession = "Developer"
const favouriteAnimal = "dog"

const hobby1 = "Coding"
const hobby2 = "Walking"
const hobby3 = "Watching TV"

console.log(`
  Welcome to my first JavaScript programme. 
  My name is ${name}. 
  I am ${age} years old. 
  I work as a ${profession}.
  My favourite animal is a ${favouriteAnimal}`
)

console.log(`
  My hobbies are: ${hobby1}, ${hobby2}, ${hobby3}
`)

Running our programme now, using the node index.js command we discussed previously, will output the following:

$ node index.js

Welcome to my first JavaScript programme. 
My name is Simon. 
I am 29 years old. 
I work as a Developer.
My favourite animal is a dog

My hobbies are: Coding, Walking, Watching TV

We’ve added a second console.log statement, which prints our hobbies.

That’s all we wanted to do in this article so we’re done, right? Nope! While this may look acceptable for three hobbies, what if we had ten?

const name = "Simon"
const age = 29
const profession = "Developer"
const favouriteAnimal = "dog"

const hobby1 = "Coding"
const hobby2 = "Walking"
const hobby3 = "Watching TV"
const hobby4 = "example4"
const hobby5 = "example5"
const hobby6 = "example6"
const hobby7 = "example7"
const hobby8 = "example8"
const hobby9 = "example9"
const hobby10 = "example10"

console.log(`
  Welcome to my first JavaScript programme. 
  My name is ${name}. 
  I am ${age} years old. 
  I work as a ${profession}.
  My favourite animal is a ${favouriteAnimal}`
)

console.log(`
  My hobbies are: ${hobby1}, ${hobby2}, ${hobby3}, ${hobby4}, ${hobby5}, ${hobby6}, ${hobby7}, ${hobby8}, ${hobby9}, ${hobby10}
`)

It’s not looking so clean now, is it? Can you imagine what it would look like if we had one hundred hobbies?

This method is also very error-prone. Imagine typing out 100 variables and adding them to our console.log statement. Are you confident that you wouldn’t make a mistake? Even a simple spelling mistake could cause unforeseen circumstances in the future.

Surely there’s a better way then!? Thankfully, there is! Arrays!

In JavaScript, arrays can contain any combination of types and are declared using square brackets ([]).

Note: multi-type arrays, like mixedArr in the below example, can lead to unforeseen circumstances if you think you are dealing with one type, but are dealing with another, so apply extra caution if you need to use them.

const stringArr = ['string1', 'string2', 'string3']
const intArr = [1, 2, 3]
const boolArr = [true, false, false]

const mixedArr = ['string1', 2, false, 'string2', 5, true]

Before we continue with the article, try to complete the following challenges:

Take the ten hobby variables (hobby1, hobby2 etc) and convert them into one hobbies array.
Change the console.log statement to print out new array, instead of the ten variables.

Done? Excellent, well done. You should have ended up with something pretty similar to this:

const name = "Simon"
const age = 29
const profession = "Developer"
const favouriteAnimal = "dog"

const hobbies = ["Coding", "Walking", "Watching TV", "example4", "example5", "example6", "example7", "example8", "example9", "example10"]

console.log(`
  Welcome to my first JavaScript programme. 
  My name is ${name}. 
  I am ${age} years old. 
  I work as a ${profession}.
  My favourite animal is a ${favouriteAnimal}`
)

console.log(`
  My hobbies are: ${hobbies}
`)

Running the application now (node index.js) should give you the following output:

$ node index.js

Welcome to my first JavaScript programme. 
My name is Simon. 
I am 29 years old. 
I work as a Developer.
My favourite animal is a dog

My hobbies are: Coding,Walking,Watching TV,example4,example5,example6,example7,example8,example9,example10

We now have an array that we can add hobbies to, or remove from, without having to create new variables or amend the console.log statement.

What would be nice is to log each hobby on a different line.

Remember from the “what are arrays” article, that array elements have a corresponding number called an index.

JavaScript array indexing start at 0, so our hobbies array could be represented like so:

index = [0 , 1 , 2 , ...]
array = ["Coding", "Walking", "Watching TV", ...]

So we could log each of our hobbies on different lines by targeting the respective indexes.

const name = "Simon"
const age = 29
const profession = "Developer"
const favouriteAnimal = "dog"

const hobbies = ["Coding", "Walking", "Watching TV", "example4", "example5", "example6", "example7", "example8", "example9", "example10"]

console.log(`
  Welcome to my first JavaScript programme. 
  My name is ${name}. 
  I am ${age} years old. 
  I work as a ${profession}.
  My favourite animal is a ${favouriteAnimal}`
)

console.log(`
  My hobbies are:

  ${hobbies[0]}
  ${hobbies[1]}
  ${hobbies[2]}
  ${hobbies[3]}
  ${hobbies[4]}
  ${hobbies[5]}
  ${hobbies[6]}
  ${hobbies[7]}
  ${hobbies[8]}
  ${hobbies[9]}
`)

But now, if we add or remove an item from the hobbies array, we then have to update the console.log statement. We’ve gone backwards!

But, don’t worry; all is not lost! We can use loops to solve this problem.

We’ll have all of our hobbies printed on a different line and everything will be controlled via the hobbies array. That means no more manually editing the console.log statement for every change!

Before we jump into creating a loop in our programme, let’s make a simple example of a loop to understand the concept.

If we wanted to log the numbers 1-10 we could write 10 different console.log statements, which is very tedious, or we could write a loop to do it for us. In the following example:

The initialization statement. Evaluated once, before the loop begins. We define a new variable ( i ) and assign the value 1 to it ( let i = 1 ).
The condition expression. An expression to be evaluated before each loop iteration. It checks if the expression (i <= 10 - is i less than or equal to 10?) evaluates to true and, if so, executes the statement (see below).
The final-expression. An expression to be evaluated at the end of each loop iteration. This occurs before the next evaluation of the condition. We simply increment the value of i (e.g. if the value of i is 5, running i++ would increment it and it would now be 6).
The statement. A statement that is executed as long as the condition expression evaluates to true. We use this to log out the value of i to the screen.

for (let i = 1; i <= 10; i++) {
  console.log(i)
}

We can now use this new technique to print our hobbies. In the following example:

We have added a new console.log statement, that prints out how many hobbies we have. We achieve this by using the length property of our hobbies array which, as the name suggests, returns the length or the number of elements in an array.
We define our initialization statement, in which we set the value of our variable i to 0. We have set it to 0, instead of 1, because JavaScript arrays start at zero as we discussed earlier.
We define our condition expression, in which we state that the loop should continue while i is less than the length of our hobbies array (i < hobbies.length).
We define our final-expression, in which we increment the value of i (i++) as we did in the previous example.
We then print each element of our hobbies array, using the element indexes.

const name = "Simon"
const age = 29
const profession = "Developer"
const favouriteAnimal = "dog"

const hobbies = ["Coding", "Walking", "Watching TV", "example4", "example5", "example6", "example7", "example8", "example9", "example10"]

console.log(`
Welcome to my first JavaScript programme. 
My name is ${name}. 
I am ${age} years old. 
I work as a ${profession}.
My favourite animal is a ${favouriteAnimal}
`)

console.log(`I have ${hobbies.length} hobbies, and they are as follows...`)

for (let i = 0; i < hobbies.length; i++) {
  console.log(hobbies[i])
}

When explaining each step, I said the condition expression states the loop should continue while i is less than the length of our hobbies array.

But why should it be less than the length (i < hobbies.length, and not less than or equal to the length (i <= hobbies.length)? Because JavaScript array indexes start at zero.

Let’s go back to our array representation from earlier:

index = [0 , 1 , 2]
array = ["Coding", "Walking", "Watching TV"]

We only want to access the 0, 1 and 2 index elements, when looping through this array, which is why our initialization statement sets i to 0.

However, the length of the array (array.length) is 3 (i.e. 3 elements).

So, if we declared our condition expression as less than or equal to the length (i <= hobbies.length), we would try and access the elements at index positions 0, 1, 2 AND 3. As you can see from the array representation, there is no 3rd index!

If we run our programme now, we’ll see the following output:

$ node index.js

Welcome to my first JavaScript programme. 
My name is Simon. 
I am 29 years old. 
I work as a Developer.
My favourite animal is a dog

I have 10 hobbies, and they are as follows...
Coding
Walking
Watching TV
example4
example5
example6
example7
example8
example9
example10

We can add and remove elements from our hobbies array, and our programme will figure out the rest!

We appreciate this was a lot of information to take in, so feel free to reach out to us if anything doesn't make sense.

CodeTips strives to help beginners, with zero or very little experience, learn to code.

We do cross-post to other sites to reach a wider audience, but why not subscribe to our newsletter and get the newest articles straight to your mailbox?

The original source for this content is CodeTips. The original content is kept up-to-date, but other sources may not be the latest version.