Hello Rocky! I see you're taking your Java lessons earnestly, and it's really encouraging to see learners like you!

And your hunch about type declaration is right on the mark:

Every time you declare a new variable, you need to specify its type. You don't need to specify type for the variable after you've declared it.

Let's clarify this with a modified version of the program you've given:

class Main {
    public static void main(String[] args) {
     
        // Create and print the distance variable
        int distance = 134;
        System.out.println("Original distance = " + distance);
     
        // Create another variable distance2
        int distance2 = 564;
        System.out.println("Original distance2 = " + distance2);
     
        // Assign another value to distance
        // No need to declare type again
        distance = 760;
        System.out.println("\nModified distance = " + distance);
     
        // Assign another value to distance2
        // No need to declare type again
        distance2 = 666;
        System.out.println("Modified distance2 = " + distance2);
     }
}

Output

Original distance = 134
Original distance2 = 564

Modified distance = 760
Modified distance2 = 666

Notice the following blocks of code above:

distance = 760;
System.out.println("\nModified distance = " + distance);
     
distance2 = 666;
System.out.println("Modified distance2 = " + distance2);

You can clearly see that you don't need to redeclare the types of distance and distance2 because they've already been declared when you created the variables:

// Declaration of 'distance' variable
int distance = 134;


// Declaration of 'distance2' variable
int distance2 = 564;

This is true not just for Java, but for other programming languages like C, C++, TypeScript, etc. as well.

Hope that clears things up! Contact us again if you have further questions!

Hello again, Stephen! I'm not exactly clear about what you're asking, but I'm guessing you're asking one of two questions (or both) I've answered below.

Q1) What's the mathematical operation we're performing?

The calculate_sum() function calculates the sum from 1 to n, where n is the argument passed to it.

Here, n = 3, so calculate_sum() should return:

calculate_sum(3) = 1 + 2 + 3 = 6

==============================================

Q2) How does this recursive function work?

Recursion is a confusing topic that even many of us still struggle with from time to time.

What's important to remember about recursion is this:

The recursive function doesn't start returning values until the base case is reached.

In our case, the base case is n == 1.

So, calculate_sum(3) will recursively call itself until calculate_sum(1) is called.

Once we've reached this base case, calculate_sum(1) will return a value to calculate_sum(2), which in turn returns a value to calculate_sum(3).

Here's the sequence of the recursive calls:

calculate_sum(3) --->calculate_sum(2) --->calculate_sum(1)

Here's the sequence of value returns:

calculate_sum(1) --->calculate_sum(2) --->calculate_sum(3)

I'll try to explain it to the best of my abilities. Please try to read this explanation alongside the image we've provided in our Recursion course:

Part 1: Successive Function Calls

1. First, result = calculate_sum(3) is executed, which calls the calculate_sum() function with 3 as argument. Let's simply call this function call as calculate_sum(3)

2. Notice the statement return n + calculate_sum(n - 1);. Inside calculate_sum(3), this statement becomes return 3 + calculate_sum(2).

3. Here, the return statement isn't fully executed. Instead, it calls calculate_sum(2) first.

4. In other words, a separate instance of calculate_sum() is called (with 2 as an argument). Thus, calculate_sum(2) is separate from calculate_sum(3). Please remember that no value has been returned so far.

5. Similarly, calculate_sum(2) executes return 2 + calculate_sum(1). This means a separate function calculate_sum(1) is called without returning any value.

Part 2: Successive Value Returns

1. We left off at when calculate_sum(1) is called. Now, let's pick off right where we left off.

2. calculate_sum(1) directly returns the value 1 without calling any further functions. That's because calculate_sum(1) is the base case where the if (n == 1) statement is executed.

3. This return value of calculate_sum(1) then goes back to calculate_sum(2).

4. Remember that calculate_sum(2) executes return 2 + calculate_sum(1). Since calculate_sum(1) returned 1, this return statement becomes return 2 + 1, i.e., return 3.

5. In other words, calculate_sum(2) returns the value 3 to calculate_sum(3).

6. Then, calculate_sum(3) executes return 3 + calculate_sum(2), which is return 3 + 3, i.e., return 6.

7. Thus, calculate_sum(3) returns the value 6 to result.

And that's how we get 6 as the final result.

Hope that helps! Contact us again if you have further questions.

Hello, Pius! If you want to print \n as part of the string, you'll need to write it as \\n like this:

print ("Hey\\nHow are you")

Just like \n is a special code for entering a new line, \\ is special code for entering a single backslash into the string.

So, Python will interpret \\n as:

Print a single backslash '\' followed by the letter 'n'.

Hope that helps! Contact us again if you have further queries.

Hi Ambika! It's natural to get confused by the return statement at the very beginning. So I'll try and help clarify your confusion.

For starters, you can think of a Python function as a machine that takes input (these are the function arguments) and spits out an output (this is the return value).

In other words, the return statement tells the function what "output" to give. You can then use this "function output" (return value) to perform some other operation.

For instance, let's say you need to crate two functions:

• One for finding the sum of 3 numbers.

• The other for finding the average from the sum.

Let's see how we can solve this problem.

Bad Practice: Without Using return Statement

# Function to calculate sum of 3 numbers
def calculate_sum(n1, n2, n3):
    total = n1 + n2 + n3
    print(f"Sum = {total}")

# Function to calculate the average of 3 numbers
def calculate_average(n1, n2, n3):
    average = (n1 + n2 + n3) / 3
    print(f"Average = {average}")

calculate_sum(5, 6, 7)
calculate_average(5, 6, 7)

Here, you can't use the sum calculated by the calculate_sum() function inside the calculate_average() function. As a result, we need to calculate the sum all over again inside calculate_average().

There are ways to work around this issue, but they're awkward and unsafe. The most natural and desirable solution is to use the return statement.

Good Practice: Using return Statement

# Function to calculate sum of 3 numbers
def calculate_sum(n1, n2, n3):
    return n1 + n2 + n3

# Function to calculate the average of 3 numbers
def calculate_average(total):
    return total / 3


# Store the return value in my_sum variable
my_sum = calculate_sum(5, 6, 7)

# Print the sum 
print(f"Sum = {my_sum}")

# Pass my_sum as argument to calculate_average()
# And store the return value in my_average
my_average = calculate_average(my_sum)

# Print the average
print(f"Average = {my_average}")

As you can see, using the return statement allows you to use your first calculation in other parts of the program, such as sending it as an argument to the calculate_average() function.

And this is just a small program!

Imagine how handy return values will be when you have to write a large program that has multiple functions, and you need to use the results of those functions in other parts of the program.

This is the true power of the return statement. Hope everything's clear now!

Hello, Daniel. You can't use commas for float numbers in Python (you must use dot). This is because Python recognizes the dot as the standard way to indicate the fractional part of a number.

For example:

print(3.14)  # This is a float
print(2.5)   # This is also a float

Using a comma instead of a dot can lead to errors or unexpected behaviors. For instance:

# This will print 3 and 14 as separate numbers
print(3,14)

In this case, Python treats 3 and 14 as two separate arguments, so it would output them as 3 14 (two numbers), instead of recognizing them as a single float number.

Hope this helps! Let me know if you have more questions!

Hi Ambika!

kebab-case is a popular naming convention used in CSS where words are all lowercased and separated by hyphens, resembling a kind of kebab skewer.

Suppose you have a class you want to call "main header". If you use kebab-case, you'd write it as main-header. There are also other styles of naming, such as camelCase, PascalCase, snake_case, etc.

Here's how you'd write "main header" in these different styles:

• kebab-case: main-header

• camelCase: mainHeader

• PascalCase: MainHeader

• snake_case: main_header

Why use kebab-case for CSS?

• It's considered more readable, especially for CSS class and id names.

• It helps maintain consistency in your code, which makes it easier to work on projects with others or return to your code after some time.

• Using one consistent style helps prevent mistakes and confusion, as you just saw in your lesson's bad example where mixed naming conventions were used.

Hope this made it clear! Feel free to ask if there's anything else you'd like to know. 😊

Hi there!

The problem statement is instructing you to select those rows from the Products table whose price is between 145 and 220, BUT the query should not select those rows whose price is either exactly 145 or 220.

This is basically a trick question because if you use the following query, then your solution will be wrong:

SELECT *
FROM Products
WHERE price BETWEEN 145 AND 220;

It's because BETWEEN will also select those rows whose price is 145 or 220.

So if you want to solve this problem using the BETWEEN operator, you need to use BETWEEN 146 AND 219.

This way, you've successfully excluded 145 and 220.

Correct Solution

SELECT *
FROM Products
WHERE price BETWEEN 146 AND 219;

Hope this helps! Let me know if you have more questions.

Hello, Kartik! You take user input by creating an object of the Scanner class, and then using the object to call the appropriate method, such as nextInt() for integers, nextDouble() for floating-point numbers, and nextLine() for strings.

For example,

import java.util.Scanner;

class Main {
    public static void main(String[] args) {
        
        System.out.println("Enter your age: ");
        
        // Create a Scanner object
        Scanner input = new Scanner(System.in);
        
        // Take user input 
        int age = input.nextInt();
        
        System.out.println("Age is " + age);

    }
}

The basics of user input has already been explained in the Taking Input lesson of Chapter 1: Introduction.

Please review that lesson again before proceeding further.

Hope that helps! Contact us again if you have further questions.

Hi there!

Your confusion is completely natural because there are a lot of advanced and deeper aspects of C programming that we haven't taught yet (because they're beyond the scope of our course).

Basically, you're asking why we don't need to print \n right after printing employee1.name, right? That's because of how fgets works.

Basically, fgets not only stores the name that you entered inside employee1.name, but it also stores the newline character \n.

How does this happen?

To give the name input, we type the name and then press the Enter key. Hitting the enter key inputs the newline character \n into the input stream, which fgets ends up storing inside employee1.name.

So if you've entered Brad Pitt as input, fgets will store it like this:

employee1.name = "Brad Pitt\n\0"

Note: Please remember that \0 is the null terminator that's present at the end of all strings in C.

So when you print employee1.name, the \n is already included in that variable. That's why you use

printf("%s %d", employee1.name, employee1.age);

instead of

printf("%s\n%d", employee1.name, employee1.age);

But scanf("%s", string_var) behaves differently

On the other hand, if you use something like this:

scanf("%s", employee1.name) 

then the newline character does not get stored inside employee1.name because scanf throws out everything that comes after a whitespace (including the whitespace itself).

The drawback here is that you can only store a single word.

What's the solution?

The solution I gave you before is good enough, but it's still not perfect because employee1.name stores \n at the end.

This can cause a lot of problems in more complex programs because a name string (or any other string) should only contain the required data (i.e., the name) without unnecessary whitespaces.

So the solution is to trim the string after using fgets.

You can remove/trim the string by following the steps below:

1. Import the string.h header file by using #include .

2. Use strcspn() to get the index of the \n character in the string.

3. Then, replace the character at that index with the null terminating character \0 so that \n gets completely removed.

Here's how to do this:

Using strcspn() to get index of \n

// Get the index of \n
int newline_index = strcspn(employee1.name, "\n");

Here, strcspn(employee1.name, "\n") compares two strings: employee1.name and "\n", and gives the index of the first occurrence of the second string i.e., "\n".

Since employee1.name has only one instance of \n in it, strcspn() effectively gives us the position of the extra line at the end of this string.

Then, we remove this newline character by replacing it with \0:

// Replace the \n with \0
employee1.name[newline_index] = '\0';

You can also simply combine the two steps like this:

employee1.name[strcspn(employee1.name, "\n")] = '\0';

Here's the FULL SOLUTION:

#include 
#include 

// create Person struct
struct Employee {
  int age;
  char name[50];
};

int main() {

  // create struct variable
  struct Employee employee1;

  // get age input for employee1's age
  scanf("%d", &employee1.age);
  getchar();

  // get name input for employee1's name
  fgets(employee1.name, sizeof(employee1.name), stdin);

  // Get the index of \n
  int newline_index = strcspn(employee1.name, "\n");

  // Replace the \n with \0
  employee1.name[newline_index] = '\0';
  
  // print name and age
  printf("%s\n", employee1.name);
  printf("%d", employee1.age);

  return 0;
}

Note: It's better to use employee1.name[strcspn(employee1.name, "\n")] = '\0'; instead of storing the \n index in a separate variable. The whole point of C programming is to be memory-efficient.

Why is this not included in the course (or in my previous answers)?

I wanted to inform you about this issue yesterday but thought the answer might get too long and confusing.

So I'm thankful that you asked this followup question.

Currently, our course cannot go into such deep detail because it's aimed at absolute beginners.

For now, I can only tell learners how to properly deal with it when they ask questions, as you've done here.

I hope you found this helpful! Please don't hesitate to ask further questions if you're still confused.

Hi again! You don't need null terminators for an array of numbers. You only need to add null terminators at the end of strings.

This is because strings in C are just character arrays. But how do you know if a char array is a string or just an ordinary group of characters?

For example, suppose you have the following arrays:

// not a C string, just a simple char array
char vowels[5] = { 'a', 'e', 'i', 'o', 'u' };

// is a C string because of \0
char greeting1[6] = { 'H', 'e', 'l', 'l', 'o', '\0' };

// also a C string (compiler adds '\0')
char greeting2[] = "Hello";

Basically, normal char arrays don't have \0 at the end, but strings do. The presence of \0 is how C knows whether something is a string or not.

So, you don't need to put \0 in arrays except for strings.

Hope that helps!