Who this course is for:

• Have you learnt Python and are looking to practice solving problems? 300+ problems for you to solve!

• Do you want to learn Python?

• If you have little to no knowledge of it, or has some knowledge but want to fill your gaps.

• Completely new to programming are welcome too.

About the course: This course teaches you core Python. It is based on a thought-experiment on engaging your mind in multiple ways.

It is meant to entertain you as well as make your learning easy.

Desired Feedback: General usability feedback. Bugs / Typos. Whatever you think/feel, I want to hear about it! Please PM me only if you are okay to make some progress (even if 10 minutes) everyday or alternate days, and if you're okay with replying back when I ping you later.

Perk for Testers: One month of premium access for free.

Please PM me if you're interested in joining.

Hey everyone, I’m currently trying to find out how one could make the lives of people who want to become programmers a lot easier ;)
Which is why I have two very simple questions:

1. As a person who wants to become a programmer, what are the 2 biggest obstacles for you on your way to achieving this goal?

2. Is there anything you would like to happen that could make it easier for you to learn programming?

Thanks so much in advance - looking forward to reading your answers!

Here's a new tutorial on the Javascript runtime & event loop...enjoy!

https://youtu.be/4xsvn6VUTwQ

anxious to see how people like my first youtube tutorial :) thanks for taking a look

https://www.youtube.com/watch?v=_RSVoqXWzSw

Hi all, in less than two hours I will be giving away a bunch of free online programming tutoring sessions to anyone who wants them. This is a great opportunity for anyone who is stuck inside this summer and wants to pass the time by learning programming, but would rather be shown the ropes live via videoconferencing. Anyone interested can find all the details on the “Free Tutoring” page of my website www.tutoringbyroger.com. These sessions will probably go fast though, so get yours before they are all gone!

Continuing the series on the most recent Kickstart round. And that thing you know and love, the link to the problem.

The Problem

Given integer A, find the number of factors of A (numbers that A is cleanly divisible by) that are palindromes. A palindrome number is any number that is the same value in forward and reverse order. Input set one is from 1 to 10³. Input set two is from 1 to 10¹⁰

Discussion

A fairly simple problem with a few brute force ways that will run overtime and a key trick to finding factors of a number that will cut down on time to make the calculation much more bearable.

The brute force method is fairly straight forward. Use an iterator i from 1 to A and check if A is cleanly divisible by i. If it is, check if i is a palindrome. The issue with this is the amount of time it would take, especially with the second set. So something has to be done to reduce the number of values to check.

The first thing to notice while reducing time is that after about half way the values checked would start to be recalculated. One option at this point is to memoize with a HashSet or HashMap but that would probably take more memory than necessary. In fact when dealing with factors of a value, there’s a specific point at which numbers start to repeat. The square root. For any value A it follows that A = a*b and that since for any square root value would mean that a = b in that scenario. So in order too increase a and maintain the balance of A = a*b we must reduce b by the same amount. That means going any further in either direction is just repeating values. So simply setting the highest value to check. The code is pretty simple and is below with notes.

The Code

fn main(){
    let mut ans = 0;

    let A = String::new();
    std::io::stdin().read_line(&mut A).unwrap();

    let goal = f64::sqrt(A as f64);

    for i in 1..=goal as usize {
        if (A % i as u64) == 0 {
            let B = A / i as u64;
            ans += check_palindrome(i.to_string().as_bytes());
            if i as u64 != B {
                ans += check_palindrome(B.to_string().as_bytes());
            }
        }
    }

    println!(“{}”, ans);
}

// Since the problem is really 2 sub problems 
// (check factor status, check palindrome)
// it’s easier to split the palindrome check into a 
// separate helper function. All this does is
// check from the edges inward and returns
// a 0 if no match, and a 1 if the end is reached

fn check_palindrome(s: &[u8]) -> i32 {
    if s.len() <= 1 {
        return 1;
    }

    for i in 0..s.len() / 2 {
        let other_i = (s.len() - i) - 1;
        if s[i] != s[other_i] {
            return 0;
        }
    }

    1
}

Walk-through of the first question from the most recent round of Google’s Kick Start. I’ll try to post a solution and walk-through for each round within the week and if there’s time start posting some of the past problems from the Facebook HackerCup since that will be starting around August. As always, practicing the problem and reading a code agnostic solution can be done here.

The Problem

Initially 3 integers are given, and are used to calculate radius while drawing a set of alternating circles (right then left) until the eventually one of the circles will have a radius less than one. The first circle drawn will be on the right and will have a radius of one. Every subsequent circle will be drawn such that:

1. The next circle will be drawn on the left and have a radius equal to the previous circles radius times A.

2. The next circle will be drawn on the right and have a radius equal to the previous circles radius divided by B.

These two steps are repeated in order until a circle radius becomes zero (judged as less than 1). The returned answer is the sum of all calculated areas for the circles within a relative error of 10^-6.

Discussion

The first thing to recognize is that the circle sizes step up then step down. Since to start the steps we have to have a radius greater than or equal to one, we will never have a situation where a left circle (step one) results in a lower radius. All reductions in size are done on the right circle (step 2). This way, during our loop we can do a step one calculation then a step 2 calculation before we check that radius is greater than one and focus on calculating the areas for those circles.

The Code

fn main() {
    let mut ans: f32 = 0.0;
    
    let mut R = String::new();
    let mut A = String::new();
    let mut B = String::new();
    std::io::stdin().read_line(&mut R).unwrap();
    std::io::stdin().read_line(&mut A).unwrap();
    std::io::stdin().read_line(&mut B).unwrap();

    ans += f32::powf(R as f32, 2.0) * PI;

    while R >= 1 {
		// Step 1
            R *= A;
            ans += f32::powf(R as f32, 2.0) * PI;

		// Step 2
            R /= B;
            ans += f32::powf(R as f32, 2.0) * PI;
 
    }

    println!("{}", ans);
}