Countdown
BrainF*ck
Interpreter
Number Sets
(Sudoku)
Interactive Map UI
ROS Robot
Patroller
Pacman
Evil Wordle
Shogun
Team Management
Site
String Construction
Derivative
Regex Matcher
Foodfa
InfOS
Scroll + Drag
Scroll + Drag
Countdown
BrainF*ck
Interpreter
Number Sets
(Sudoku)
Interactive Map UI
ROS Robot
Patroller
Pacman
Evil Wordle
Shogun
Team Management
Site
String Construction
Derivative
Regex Matcher
Foodfa
InfOS
As the front-end developer for a collaborative task management platform, I contributed
to
creating a web application designed to streamline team coordination and task tracking.
Our
application, built using Django, offers a suite of features aimed at
enhancing productivity and facilitating collaboration among team members.
Secure Login System: Implements advanced security measures for user authentication and
authorization, ensuring data protection and privacy.
Account Management: Intuitive interface for account creation, login, and profile
management.
Collaborative Workspace: Enables users to form teams
Task Assignment: Users can create, assign, and delegate tasks to specific team members,.
Personalized User Dashboard: Each user gets a personalized dashboard, providing a centralized
view of their assigned tasks and activities.
Team Dashboard: A dedicated team dashboard offers an overview of ongoing projects and tasks,
enabling effective coordination and task tracking.
The Countdown solver is crafted to tackle the
and solve Countdown problens. This solver
automates
the process, finding solutions that bring you as close as possible to the target number, using
addition,
subtraction, multiplication, and division.
Automated Solution Finder: Explores possible combinations
of
the given numbers and operations to find the best solution.
Efficient Calculation: Optimizes the search process to efficiently handle the vast space of
potential solutions, ensuring quick response times.
Features a TurtleBot3 robot programmed to enforce specific house rules during parties, ensuring a
safe and orderly environment. It autonomously navigates rooms A, B, and D to monitor and enforce two
main rules: no humans in the kitchen (Room D) and preventing the family cat and dog from being in
the same room.
ROS Service Integration: Enables the robot to move across designated rooms, ensuring
flexibility in patrol routes.
Actionlib Server: Facilitates decision-making based on action specifications, including rule
enforcement actions.
SMACH State Machine: Manages the robot's tasks, from patrolling and navigation to rule
enforcement, using Text-to-Speech for interactions.
YOLO Detection: Employs the YOLO algorithm for real-time detection of rule violations during
navigation, triggering immediate enforcement actions.
Feedback and Logging: Provides real-time feedback on rule violations and logs the count of
infractions for review.
The Brzozowski Derivative Regular Expression Matcher is a sophisticated Scala-based tool crafted to
revolutionize text pattern matching. By employing the advanced concept of Brzozowski's derivatives
of regular expressions, this matcher offers efficiency and accuracy in searching, editing, and
analyzing text patterns.
At the heart of this matcher is the principle of Brzozowski's derivatives for regular expressions.
This method focuses on dynamically recalculating regular expressions as derivatives concerning
specific characters.
This program is coded to select the most difficult words
for
players to guess in wordle. By
analysing
a list of potential words and the player's guesses, the Evilizer calculates the difficulty of
each word to ensure the player faces the most challenging game possible.
Strategic Word Choice: Employs an algorithm to choose words that maximize
difficulty, making the game significantly harder to solve.
Custom Difficulty Levels: Words are selected based on their calculated difficulty scores,
ensuring that each game is as evil as the player can handle.
Obscure Letter Prioritization: Analyzes the frequency of each letter in the words
list,
giving preference to less common and therefore more obscure letters in the word selection
process.
This project introduces a Scala-based interpreter for Brainf***, an esoteric programming language
known for its extreme minimalism and the challenge it presents to programmers.
Minimalistic Instruction Set: Embraces Brainf***'s original design philosophy, focusing on
its eight-character instruction set.
Memory Management: Implements efficient memory cell manipulation and pointer movement,
allowing for the execution of Brainf*** code.
ASCII Output: Supports ASCII character output, enabling the creation of text-based outputs
from Brainf*** programs.
Complex Program Examples: The repository includes examples of sophisticated Brainf***
programs, such as generators for the Sierpinski triangle and the Mandelbrot set, showcasing the
language's capabilities despite its minimalism.
Dynamic Interactive Map UI project transforms traditional web navigation into an immersive, game-like experience. Built using HTML, CSS, and JavaScript, this interactive map leverages SVG technology to create a detailed, customisable map interface. Users can zoom in and out through scrolling, drag to navigate across different sections, and click on specific areas to uncover more information or navigate to other pages. This project is designed to enhance user engagement by providing a visually rich and intuitive interface that goes beyond conventional website navigation.
NumberSets is a captivating number puzzle game, reminiscent of Sudoku, but with its unique twist.
Played on a traditional 9x9 board, it distinguishes itself with a mix of white and black cells, some
of which are pre-filled with numbers. The essence of the game lies in filling the empty white cells
by following a set of rules that challenge the player's logical reasoning and puzzle-solving
skills.
The board's design divides rows and columns into compartments, each defined as a series of
uninterrupted white cells. To successfully complete the puzzle, players must adhere to the following
guidelines:
Compartment Filling: Each compartment must be filled with a non-repeating and unordered set
of numbers ranging from 1 to 9. The sequence of numbers within a compartment does not need to follow
any particular order, offering a unique challenge in strategising moves.
Number Uniqueness: A number must not repeat in any row or column, maintaining the traditional
Sudoku principle of uniqueness.
This software solution automates the process of filling the board's empty white cells, strictly
adhering to the game's rules.
StringConstruction is a utility designed to calculate the most cost-effective method of
constructing a target string from scratch. The
utility
offers two operations: appending a new character to the string for a fixed append cost, and
cloning any existing substring to append for a specific clone cost.
Dynamic Programming: Employs dynamic programming to efficiently explore possible construction
strategies, reducing computation time by avoiding redundant calculations.
Backtracking: Integrates backtracking algorithms to determine the most
cost-effective path through construction possibilities.
This Shogun move program is designed to determine valid moves for each piece on the Shogun board, ensuring all game rules are followed. The program evaluates potential moves for each piece, identifies legal destinations on the board, and ensures that the King is never moved into a position where it would be endangered.
This food tracking app is designed to help users set and achieve their calorie and macronutrient goals. It incorporates gamification, rewarding users for completing goals. The app is compatible with both Android and iOS, making it accessible to a wide range of users who are looking to stay motivated and track their nutrition effectively.
This project is focused on maintaining and improving a basic
operating system called InfoOS. This project provided hands-on experience with operating system
concepts and advanced C++ programming techniques.
Page Fault Handling:
Implemented robust page fault handling mechanisms to ensure the operating system could efficiently
manage memory access errors.
Designed algorithms to identify and resolve page faults, improving system stability and performance.
Lazy Allocation:
Integrated lazy allocation techniques to optimize memory usage.
Ensured memory is allocated only when necessary, reducing the overhead and enhancing system
efficiency.
Stack Tracing:
Developed stack tracing functionality to help debug and analyze program execution.
Implemented features to capture and display call stacks, aiding in the identification of errors and
performance bottlenecks.
