DEV Community: FTWCougar

Big O Time Complexities

FTWCougar — Fri, 20 Jan 2023 22:57:41 +0000

Big O

A method of expressing an algorithm's complexity, specifically the upper bound of the development of the running time, is known as big O notation. It is frequently used to compare the effectiveness of various algorithms and can be employed to foretell how well a specific algorithm would function with huge inputs.

Using Big O notation, which places a limit on how many operations an algorithm can do, the temporal complexity of an algorithm is frequently discussed. The notation is commonly expressed as O(n), where n is the size of the input. An algorithm that runs in linear time, or O(n), for instance, will have a running time that increases most linearly with the amount of the input.

Time Complexities

There are several common time complexities that are often used in Big O notation, including:

O(1), also known as constant time. No matter how large the input is, a constant-time algorithm will always run in the same amount of time.

O(log n) denotes time in logarithmic terms. If an algorithm runs in logarithmic time, the execution time will gradually increase as the size of the input grows. For algorithms that split the input in half after each iteration, this is frequently the case.

O(n), or linear time, is used as a measure. A linearly scalable method will have a running time that scales linearly with input size.

Log-linear time is represented as O(n log n). A log-linear algorithm's running time will increase quicker than linear time but more slowly than quadratic time. This is frequently true for algorithms that incorporate both linear and logarithmic operations.

O(n^2) is a symbol for quadratic time. An algorithm that operates in quadratic time will experience a sharp increase in running time as the size of the input increases. For algorithms that use nested loops, this is frequently the case.

Finishing up

It is crucial to remember that Big O notation only offers an upper bound on an algorithm's execution time and ignores any lower bounds or worst-case possibilities. Furthermore, Big O notation typically ignores constant factors, which can result in two algorithms with the same time complexity actually operating at vastly different speeds.

In conclusion, Big O notation is a means to define an algorithm's time complexity. This enables us to evaluate the effectiveness of various algorithms and make predictions about how well they will work with huge inputs. O(1), O(log n), O(log n), O(n), O(n log n), and O(n^2) are examples of common time complexity. It's crucial to remember that Big O notation only offers an upper bound and ignores any lower bounds or worst-case possibilities.

Solving FizzBuzz

FTWCougar — Fri, 16 Dec 2022 20:41:00 +0000

A common way to quickly assess a candidate's coding abilities is to use the well-known programming problem FizzBuzz. The objective is to create a program that prints the numbers from 1 to a specified number, but instead of printing the number for multiples of 3, it prints "Fizz," and for multiples of 5, it produces "Buzz." Print "FizzBuzz" when the given number is a multiple of both 3 and 5.

For example, the output of FizzBuzz for the numbers 1 to 15 would be:

1
2
Fizz
4
Buzz
Fizz
7
8
Fizz
Buzz
11
Fizz
13
14
FizzBuzz

Here is a straightforward JavaScript version of FizzBuzz using an if statement:

for (let i = 1; i <= 100; i++) {
  if (i % 3 === 0 && i % 5 === 0) {
    console.log("FizzBuzz");
  } else if (i % 3 === 0) {
    console.log("Fizz");
  } else if (i % 5 === 0) {
    console.log("Buzz");
  } else {
    console.log(i);
  }
}

This program iterates through the numbers from 1 to 100 using a for loop. The loop outputs "FizzBuzz" if the current number is a multiple of 3 and 5 (checked using the modulo operator%). "Fizz" is printed if the number is only a multiple of 3. "Buzz" is printed if the number is just a multiple of 5. If the number is not a multiple of 3 or 5, it is printed as is.

Although this implementation is quite simple, there are a few considerations to keep in mind. The sequence of the if statements is crucial first. A number that is a multiple of both 3 and 5 should be regarded as a "FizzBuzz" rather than a "Fizz" or a "Buzz," so the check for "FizzBuzz" must come before the checks for "Fizz" and "Buzz."

Second, even though the else statements are optional, they can improve readability by indicating clearly what should happen when a number is not a multiple of 3 or 5. The code would continue to function without the else statements, although it could be less evident what is happening.

Conclusion

In this blog we talked about a common way to quickly assess a candidate's coding abilities using a programming problem called FizzBuzz. And showed you a way to solve the programming problem.

React Components

FTWCougar — Wed, 07 Dec 2022 17:38:45 +0000

Today we'll be talking about components built from react.
React is a library built for javascript and is very useful when it comes to building out web applications.

A component built from react looks like this

const ReactComponent = () => {
return(
<div>
<p>Hello World</p>
</div>
)
}

It looks really simple and it is. This is useful because previously in javaScript you would have to write it all out individually telling it what the text content is and where to append it to. This way is faster and much easier to read than basic javaScript. Each component doesn't have to be that simple you can pass down props from the parent and use that to show data to the screen or for forms you can use callback functions to go up to the parent. You can also have what is called useState which can keep track of data from the user and update the web page based on that data.
React is very useful to everyone once you get to know it. React components

The Breakdown 1

FTWCougar — Wed, 16 Nov 2022 16:52:02 +0000

"It is not enough for code to work." - Robert C Martin.

Understanding the code is just the beginning of your long sought out journey. Being able to breakdown every component of your code and explain what each part does and how it does that is a very important skill you'll need to continue with coding. If your not able to do this, it will then likely take you longer to debug you code. You'll get lost and the sauce and stress out over what is going wrong. I'll demonstrate some basic code that can be broken down.

We'll break down a basic function setup

const basicFunction = ("Parameter") => {
//Your Code Goes Here
}

First the const. The const is short for constant and it means the number or in this case function doesn't change.

Secondly the name (basicFunction) of the function is a name that you'll use to invoke that function (basicFunction()) be careful not to put that name in a infinite loop.

Lastly the Parameter is something that you pass in when you invoke the function (basicFunction(parameter)). It's typically data that you want the function to manipulate generally user input triggers functions you wanna manipulate data with.

And that is the breakdown of a function. I hope this helped some of you understand the code a little better and with this knowledge you use it to write better code so that you understand it and others reading it do too.

The importance of Clean Code

FTWCougar — Tue, 25 Oct 2022 17:52:55 +0000

"So if you want to go fast, if you want to get done quickly, if you want your code to be easy to write, make it easy to read." - Robert C Martin

Clean code is very important not just to you but everyone that has to work with the code as-well. Clean coding means writing for your future self and others that will have to go back and read your code. The code is not just for the computer it is for humans to understand too.

If you do not write clean code you will get lost in the sauce as my cohort would say. Code should be written in functions adding modularity and those functions should do one thing. Nested code can be hard to read and make changes to if the programmer can't even understand the code. Writing with variables and functions that have meaningful names can be helpful towards writing clean code. Writing simple code will help with writing clean code for example knowing when to use if statements and when to use ternary statements. Having all these things will lead to clean code as-well as when looking for how to fix a problem it will be solved faster with clean code.

To conclude writing clean code isn't just for yourself but for others too. Just because you understand it now doesn't mean you will later. Writing clean code will allow you to work much faster as-well as anyone you are working with too.