Learning Zone ✕
Theory Concepts
Cryptography Computer Hardware Computer Networks Algorithms OOP Programming Binary Data Boolean Logic Database ConceptsInteractive Quizzes
View All QuizzesGCSE Computer Science (UK)
1.1 System Architecture 1.2 Memory and Storage 1.3 Computer networks 1.4 Network security 1.5 – Systems software 1.6 – Impacts of digital technology2.1 – Algorithms 2.2 – Programming fundamentals 2.3 – Producing robust programs 2.4 – Boolean logic 2.5 – Programming languages and IDEs
A-Level Computer Science (UK)
1.1 Contemporary processors, input, output and storage devices 1.2 Software and software development 1.3 Exchanging data 1.4 Data types, data structures and algorithms 1.5 Legal, moral, cultural and ethical issues2.1 Elements of computational thinking 2.2 Problem solving and programming 2.3 Algorithms
Coding Challenges ✕
Python Challenges
Online Python IDE Python Challenges - All Levels Python Challenges - Beginner Level Python Challenges - Intermediate Level Python Challenges - Advanced Level Python Turtle Challenges Solved Challenges Online Glowscript IDEHTML / CSS & JavaScript
HTML / CSS & JS Editor HTML / CSS & JS ChallengesLMC
LMC Challenges LMC SimulatorSQL
SQL ChallengesBlock Programming
BBC micro:bit Challenges Scratch ChallengesInteractive Coding Puzzles
Pirate Island Space Explorer Interactive Coding QuizzesOnline Interactive Tools ✕
Coding Tools
Online Python IDE HTML / CSS & JS Editor LMC Simulator Online Glowscript IDE Flowchart Sudio Trace Table 101 Dashboard Difference Engine Emulator Analytical Engine EmulatorDesign Tools
Network Designer Database ERD DesignerLogic Gates Circuits
Logic Gates Circuits Simulator Logic Gates Diagrams Binary Activities Karnaugh MapsMore results...
Member's Area ✕
How old will you be in…
In this challenge we will write a Python program to help us find out hold we will be in the coming years! We have designed the algorithm of our program using both a Flowchart and Pseudocode.
Algorithm
FlowchartPseudocode
year = 2017
age = INPUT("How old are you?")
FOR i FROM 1 TO 50
year = year + 1
age = age + 1
OUTPUT("In " + year + ", you will be " + age + " years old.")
END FOR
Reviewing the Algorithm
Check the above pseudo-code and answer the following questions:
?
What variables are used in this code?
?
On what line is iteration used?
?
What value is used to initialise the variable year?
?
On what line is the variable age incremented?
?
On which line is string concatenation used?
?
How many lines will be displayed on screen once this program has been fully executed?
?
What would be the last line to appear on screen once this program has been fully executed?
Check the above flowchart and answer the following questions:
?
In a flowchart, what shape is used to represent a user INPUT?
?
In a flowchart, what shape is used to represent iteration?
?
In a flowchart, what shape is used to represent an OUTPUT?
Python Code
Your task is to use the algorithm provided above (either Flowchart or Pseudo-code) to code this algorithm using Python.
Solution...
The solution for this challenge is available to full members!Find out how to become a member:
➤ Members' Area
Sampling Sound – Revision
Before attempting this task make sure you understand what is meant by sampling sound.
Complete this drag and drop activity to highlight the key concepts of sound sampling.
digital
large
sampling rate
analogue
quality
Hz
milliseconds
bps
measurements
lower
bits
intervals
Sampling Intervals and Sample Rate
- Sampling sound is the process of converting an sound wave into a signal.
- When sampling sound, the computer takes of the sound wave at regular .
- The sampling interval is the number of between two samples.
- The larger the sampling interval, the the quality and file size of the sound file.
- The is the number of samples in one second. It is measured in .
- A sample interval leads to a low sample rate.
Bit Depth and Bit Rate
- The Bit Depth is the number of used to store one sample into binary.
- A high bit depth leads to a better sound file.
- The Bit Rate is the number of bits used per seconds, measured in .
- A high bit rate leads to a better quality sound file.
Sampling Sound
Sampling is a method of converting an analogue audio signal into a digital signal. While sampling a sound wave, the computer takes measurements of this sound wave at a regular interval called sampling interval. Each measurement is then saved as a number in binary format.
Sampling Interval
The quality and file size of the sound files are linked to the size of the sampling interval (in milliseconds).
Sampling Interval: 15 ms
Sampling Interval: 40ms
A small sampling interval results in a better quality sound file and increases the size of the audio file.
Sample Rate
To describe the quality of a sound file we often use the term sample rate as opposed to the sampling interval.
The sample rate (in Hz) is the number of samples in one seconds.
Sample Rate = 1 / Sampling Interval
Sample Rate: 66Hz
Sample Rate: 25Hz
A small sampling interval results in a high sample rate which results in a better quality sound file and increases the size of the audio file.
Sampling Sound Visualisation using Python
Bit Depth
Bit depth is the number of bits available for each sample. The higher the bit depth, the higher the quality of the audio. Bit depth is usually 16 bits on a CD and 24 bits on a DVD.
Bit Rate
The bit rate of a file tells us how many bits of data are processed every second. Bit rates are usually measured in kilobits per second (kbps). The higher the bit depth, the higher the quality of the audio.
Take the Quiz
Take the Quiz on Sampling Sound
Vanishing Point Perspective
In graphical perspective, a vanishing point is an abstract point on the image plane where 2D projections (or drawings) of a set of parallel lines in 3D space appear to converge. The vanishing point may also be referred to as the “direction point”.
Vanishing Point Perspective is used in Graphic editing and 3D video games. It can be used to render 3D shapes (3D Buildings and objects), add perspective to a background scene (road, train track) or add shadow effects.
The following slideshow, demonstrates the use of vanishing points in computer graphics:
You can read more about Vanishing Point Perspective on Wikipedia.
Vanishing Point Perspective using python Turtle
Falling/Scrolling Object Algorithms
In many arcade video games objects are flying across the screen (either vertically: falling objects, upcoming cars in car racing game) or horizontally (e.g. pipes in Super Mario or flappy bird, cars in Crossy Road).
In frame based games, motions is often implemented by positioning sprites on the screen using (x,y) coordinates and applying a velocity vector (Vx,Vy) to each sprite to indicate the direction and speed of the sprite.
Let’s review the algorithms used to implement three types of motions:
- Vertical Scrolling: Falling objects (e.g. Catch the Fruit game)
- Horizontal Scrolling (Right to left gliding pipes in Super Mario)
- Combination of both Vertical and Horizontal Scrolling in the game of Space Invaders
Vertical Scrolling: Falling objects
Horizontal Scrolling:
Space Invaders: Aliens Motion
–
Tagged with: Coordinates
Computational Features of Video Games
If you are confident enough with your Python skills, you might feel ready to move on to the next stage and start creating your own arcade video game.
To do so you will have to research and investigate existing video games to identify some of the key computational features of these games and see how these can be implemented.
For arcade games we advise you to investigate the classic games including:
- Pacman,
- Pong,
- Space Invaders,
- Breakout,
- Artillery Games (Tanks, Worms, Angry Bird),
- Tetris,
- Platform Games (e.g. Donkey Kong),
- Racing Games (e.g. Outrun, Traffic Racer, Mario Kart),
- Side Scrolling Games (Super Mario, Flappy Bird),
- Quiz Based Games, (Buzz, Who Wants to be a Millionaire…)
- Logic Games & Board Games (Chess, Connect4, Battleships…),
- Logic Puzzle (Rushhour, minesweeper, Sudoku, Maze based games…),
- Card Games (Solitaire, Poker, Blackjack…),
- Educational video Games,
- 3D video Games (minecraft, flight simulators…)
- etc.
When investigating these video games try to identify their main features:
- What are the main sprites of the game,
- How does the player interact with the game / control the main sprite,
- How does the scoring system work,
- Is the game making use of a timer,
- Can the player play against the computer,
- Is the game using real physics,
- Is the game in first-person view,
- How does the computer control the movement of other sprites,
- How does the computer decide what move to play next,
- What information is stored in the game,
- What extra features are included in the games (e.g. leaderboard?),
- What settings can be changed in the game,
- Are there multiple levels of difficulty,
- What makes a level more difficult to complete,
- How is the stage generated,
- What are the main characteristics of the Graphical User Interface,
- etc.
You will then be able to research these characteristics further and identify the computational features that you could use to build your own game.
To help you getting started we have listed here a few blog posts from this blog describing a range of computational features further:
Controlling Movement of Sprites:
Main Program Loop (Frame Based Game)
Controlling a Sprite using the arrow keys
Edge Detection & Bouncing Algorithm
Scrolling/Falling Object Algorithms
Projectile Motion Formula
Pacman Ghost Algorithm
Polar vs. Cartesian Coordinates
Translations and Rotations in a 2D frame based animation
2D Rotation Matrix
Elastic Collision Formulas
Snake Game in Python
Stage Generation:
Random Background Generation Algorithm
Parallax Scrolling Effect
Battleship Grid Initialisation Algorithm
Level Generation using a 2D Array
Pacman Maze using a 2D Array
Snakes & Ladders using a 2D array
Candy Crush – Level Generation
Collision Detection Algorithms:
Collision Detection Algorithm in a game of Curling
Collision Detection between Sprites (PyGame)
Target Detection Algorithm
Bouncing Algorithm (platform game)
Data Structures:
Connect4 Data Structure using a 2D-array
Othello Data Structure using a 2D-array
File Handling (CSV files) in a Monopoly Quiz
Using a 2D-array to implement a game of Tetris
Using Lists/Arrays and Graphs to store/represent data
Using a Dictionary: Chemical Element Quiz
2D array – Minesweeper (Javascript)
Football Results Tracker using a CSV file
Frog Puzzle – Backtracking Algorithm using a Graph Data Structure
Noah’s Ark – A backtracking algorithm based on a 2D array data structure.
Laser Game – 2D array data structure.
Scoring Systems:
Scoring System in a Quiz
Archery Scoring System
Darts Scoring System
Grading System
Data Visualisation
Data Visualisation Algorithms
Artificial Intelligence? When the player plays against the computer!
Tic-Tac-Toe Challenge
Using a Backtracking algorithm to solve a Sudoku Puzzle
Using a backtracking algorithm to explore a maze.
Heuristic approaches to problem solving
Machine learning top trumps game
Rush Hour: Backtracking Algorithm & Heuristics
Connect Flow – Backtracking Algorithm & Heuristics
3D User Interface:
Oblique Projection Formula
3D Rotation Matrix
Vanishing Point Perspective
Additional Features of video games:
Adding a timer in a video game
Sprite Animation using Pygame
Login Algorithm
Leaderboard (using a CSV file)
Off-side Detection Algorithm
Closest Player Detection Algorithm
Manhattan (taxicab) distance calculator
Shuffling Algorithm (Shuffling a deck of cards)
Object-Oriented Programming:
OOP Concepts
Pong (Pygame Tutorial)
Car Racing Game (Pygame Tutorial)
Breakout Game (Pygame Tutorial)
UML Diagrams
Tagged with: PyGame
Pacman Ghost Algorithm
In a game of Pacman a specific algorithm is used to control the movement of the ghosts who are chasing (running towards) Pacman.
For this challenge we will assume that ghosts can walk through walls (as ghosts do!). So we will implement an algorithm that is slightly different to the algorithm used in the real game of Pacman where ghosts can only run alongside the corridors of the maze.
Our algorithm will be used in a frame based game where the sprites (e.g. Pacman, Ghosts) are positioned using (x,y) coordinates. The Pacman movement will be based on the position of the mouse cursor whereas the Ghosts will use a velocity vector (vx,vy) to move/translate between two frames.
Trigonometric Ratios: SOH-CAH-TOA
Our algorithm will use the trigonometric ration to find the angle the Ghost needs to head towards to chase Pacman.
The next step of our algorithm will use this angle to calculate the velocity vector (Vx,Vy) of the ghost:
The final step of our algorithm will update the (x,y) coordinates of our ghost to apply the velocity vector translation before drawing the ghost sprite on the screen.
Python Code
Tagged with: Coordinates
Bouncing Algorithm
Bouncing algorithms are often used in arcade games such as Pong or Breakout.
To understand how to implement a bouncing algorithm, it is essential to understand how the computer controls the trajectory of a sprite (e.g. ball) on the screen. Arcade games are based on a frame based animation where the screen is refreshed every x milliseconds. Moving sprites are positioned using (x,y) coordinates and have a velocity vector (Vx,Vy) which specifies the delta in pixels to apply to the (x,y) coordinates of a sprite between two frames:
- frame n: Sprite Coordinates: (x,y)
- frame n+1: Sprite Coordinates: (x+Vx,y+Vy)
As the sprite moves across the screen, it may need to bounce against another sprite or against the edge of the screen.
Let’s investigate how the velocity vector is affected when the sprite bounces against vertical and horizontal walls/edges.
Right Wall/EdgeLeft Wall/EdgeTop Wall/EdgeBottom Wall/Edge
Python Code
The following Glowscript code implements a bouncing algorithm against all 4 edges of the canvas.
Tagged with: Coordinates
Closest Player Detection Algorithm
Have you ever noticed when playing a team sport video game such as a (football, basketball, rugby game, etc.) the computer often finds out who the closest player to the ball is so that you can run to the ball with the closest player.
To do so the computer uses a specific algorithm to identify who, of all the players in your team, is the closest to the ball. This algorithm can also be used when you already control a player who has the ball to find out who is your closest team player to pass the ball to.
In this blog post we will investigate how this algorithm works and will implement this algorithm using Python.
On a team sport video game, each player is a sprite that is given an x and a y coordinate to be positioned on the pitch/screen.
The ball is also positioned using (x,y) coordinates.
To find out who the closest player is to the ball, we need to calculate the distance between the ball and each player of the team. To do so we will use Pythagoras formula:
We can then use an algorithm to find the shortest distance and highlight the corresponding player.
Python Code
Tagged with: Coordinates
LMC Simulator
Logic Gates Circuits
Network Designer
Flowchart Studio
Online Python IDE