So basically he explained something that actually has happened 2 or 3 times already in problem sets. If I want to switch two variables, usually I need to create a temporary variable to hold a value to make the switch possible.

So to switch a to b, you need to do:

tmp = a

a = b

b = tmp

And in class they used an analogy with 3 cups and need to switch from one to another:

Then seems that you can use XOR (^) to swap 2 variables. You can test it by applying XOR to each bit, bit by bit… you will see that it actually works :D!

Important, also learned that you can represent your computers memory like below. Stack is chunck of memory that functions have access when they are called.

Interesting that environment variables (of main) take a chunk of space, but functions take a different one. When I pass variables to a function, those are a COPY of the original. So what if I want a function to affect the  space of the environment variables?

Below is what happens after swaping a and b on function.

This is a very interesting example. Somehow something is wrong.

The interesting thing is that what is stored in any “string” variable, is not the string itself, its the address in memory of that string.

Actually “strings” doesn’t exist. Its just a synonym, for char*. The * is a “pointer”, an “address”.  So from now on, instead of calling the type “string”, we will put “char*”

I just successfully finished pset3 at CS50. It was pretty challenging! The final product is the “game of 15” one inputs a number for how size the board is, then it produces a board with all numbers and it allows the player to select a tile to move (must be adjacent to blank to work) replicating the “switching” that one does in the actual physical game. 🙂

Things I learned / internalized:

• Arrays on C must have a declared size, and this can’t really be adjusted later. An array is a string of memory, and you can’t just print an array like you do on python. To print it you need to do a loop that prints each individual term of the declared Array.
• One needs to be careful not to try access parts of memory not allocated not to get segmentation fault errors.
• Did my first C recursive program and loved it.
• Getting more and more comfortable with the initialization of variables 🙂

Lastly, this blog is being invaluable for me to keep track of where I am, what I have done etc… 1000 times better than taking notes on separate words or on paper or whatever. I am loving it.

 

Today I took a breadk, and discovered checkio.org a site that looks pretty interesting. It basically challenges you with different problems that you need to solve with code, and you earn points etc…

As a side note, the language used there is python. OMG… after doing C for some time coding in python feels like cheating :D! Is like you have a pre-defined function for everything already, seriously XD!

The fun continues.

 

Don’t code before you have conceptualized what you want to code

Binary Search

I am so happy. I have coded binary search from scratch, and this time it feel much much smoother, much quicker even if it was probably the most complex algorithm I have programmed till now.

The main difference is that instead of trying to directly write code, I first of all conceptualized the problem on a word file, and then solved the most complex parts of the algorythm in paper there itslef. Then I only had to pass the code to proper form on the IDE:.

This is how I solved some of the most tricky part. Above you can see what happens when you have an array, and check middle value … how long are the remaining two halfs? This is extremely hard to visualize unless you write it like that. If you do it you realize that, taking advantage of integer division (remainder is lost), you can generalize both halfs to an expression DEPENDING IF the original array is EVEN or ODD.

Below you can also see how I find that integer division can also be used to check if a number is odd or even. This I learned from some of the previous MIT 6.00 classes :). It is great. With integer division you know a number is odd if: (n+1)/2 = n/2 // (remember that in integer division remainder disappears)

And this is how it looked when I passed the code from WORD to my IDE:

And this is my final code. Enjoy :D!

bool binary_search(int value, int values[], int n)
{
    while (n > 0)
    {
        int middle_position = n/2;
        int middle_value = values[middle_position];
        int size_right;
        int size_left;
        
        if (middle_value == value)
        {
            return true;
        }
        else if (value > middle_value)
        {
            if (is_even(n))
            {
                size_right = ((n - 1) / 2);
            }
            else
            {
                size_right = (n / 2);
            }
            
            int values_right [size_right];
            
            for (int i = 0; i < size_right; i++)
            {
                values_right [i] = values [(middle_position) + 1 + i];
            }
            binary_search (middle_value, values_right, size_right);
        }
        else if (value < middle_value)
        {
            size_left = (n / 2);
            int values_left [size_left];
            
            for (int i = 0; i < size_left; i++)
            {
                values_left [i] = values [i];
            }
            binary_search (middle_value, values_left, size_left);
        }
        
    }
    return false;
}


// Function to check if an integer is even or odd

bool is_even(int n)
{
    if ( ((n + 1) / 2) == (n / 2) )
    {
        return true;
    }
    else 
    {
        return false;
    }
}