coding_problems.py

coding_problems = {
    "Python": "In Python, write a function to reverse a string, for example, turning input 'hello' into 'olleh'.",
    "Java": "In Java, implement a simple calculator class that supports addition, subtraction, multiplication, and division.",
    "C++": "In C++, implement an efficient sorting algorithm (e.g., quicksort or mergesort) to sort an array of integers.",
    "JavaScript": "In JavaScript, create a simple web page interaction with a button that, when clicked, displays the current time.",
    "C#": "In C#, implement a simple Windows Forms application featuring a text box and a button that displays the text box content when clicked.",
    "Ruby": "In Ruby, implement a simple web server using Ruby on Rails that returns 'Hello, World!'",
    "PHP": "In PHP, create a dynamic web page that displays the current date and time.",
    "Swift": "In Swift, implement a simple iOS app interface with a label and a button that updates the label to 'Clicked!' when pressed.",
    "Go": "In Go, implement a concurrent program using goroutines to calculate the square and cube of two numbers simultaneously.",
    "R": "In R, read data from a CSV file, calculate the average, and plot a bar chart.",
    "SQL": "In SQL, write a query to retrieve the total number of orders for each user from 'users' and 'orders' tables.",
    "Kotlin": "In Kotlin, implement a simple Android app feature with an input field and a button that displays the input content when clicked.",
    "Scala": "In Scala, implement a functional programming example with a function that takes a list of integers and returns their sum.",
    "Perl": "In Perl, implement a text processing script to extract all email addresses from a text file.",
    "Haskell": "In Haskell, implement a pure functional program to calculate the nth Fibonacci number.",
    "Lua": "In Lua, implement a game script to control a character's simple movements (e.g., up, down, left, right).",
    "MATLAB": "In MATLAB, implement matrix multiplication and visualize the result.",
    "Objective-C": "In Objective-C, implement a simple iOS app feature with a button that shows an alert with 'Welcome!' when clicked.",
    "Rust": "In Rust, implement a safe concurrent program to calculate the sum of all elements in an array using multiple threads.",
    "TypeScript": "In TypeScript, implement a type-safe function that takes an array of numbers and returns the maximum value.",
    "Bash": "In Bash, write a shell script to backup a specified directory to a compressed file.",
    "PowerShell": "In PowerShell, implement a system management script to list all running processes.",
    "Dart": "In Dart, implement a simple Flutter app interface with a counter button.",
    "Groovy": "In Groovy, implement a simple script to read and print the content of a JSON file.",
    "F#": "In F#, implement a functional programming example with a function to calculate the product of all elements in an integer list.",
    "Erlang": "In Erlang, implement a simple distributed chat server that supports multiple client connections.",
    "COBOL": "In COBOL, implement a business calculation program to compute an employee's total salary (base salary + bonus).",
    "Fortran": "In Fortran, implement a scientific computing program to calculate a definite integral (e.g., using the rectangle method).",
    "Ada": "In Ada, implement an embedded system program to simulate controlling an LED light (on/off).",
    "Prolog": "In Prolog, implement a logic reasoning program to solve a simple puzzle, such as 'Who is the murderer?'",
    "Lisp": "In Lisp, implement a symbolic computation program to evaluate a simple mathematical expression, e.g., '(add 2 3)'.",
    "Scheme": "In Scheme, implement a recursive function to calculate the factorial of n.",
    "Smalltalk": "In Smalltalk, implement an object-oriented program to simulate bank account deposits and withdrawals.",
    "VHDL": "In VHDL, design a simple digital circuit, such as an adder.",
    "Verilog": "In Verilog, implement a hardware module for a simple sequential logic circuit, like a counter.",
    "Assembly": "In Assembly, write a low-level program to compute the sum of two numbers.",
    "Clojure": "In Clojure, implement a concurrent program using concurrency primitives to compute the sum of squares of an array.",
    "Elixir": "In Elixir, implement a simple distributed counter.",
    "Julia": "In Julia, implement a high-performance computing program for matrix multiplication and measure execution time.",
    "Crystal": "In Crystal, implement a web application that returns a JSON response.",
    "Nim": "In Nim, implement a command-line tool that accepts arguments and prints the content of a file.",
    "D": "In D, implement a system-level program to list all files in a directory.",
    "Pascal": "In Pascal, implement a teaching program demonstrating if-else and loop structures.",
    "Forth": "In Forth, implement a stack-based addition calculator.",
    "APL": "In APL, implement an array processing program to sort an array and calculate its average.",
    "J": "In J, implement a data analysis program to compute the standard deviation of a dataset.",
    "K": "In K, implement a high-performance data processing program to compute the sum of a large array.",
    "Q": "In Q, implement a database query to retrieve data from a time-series database for a specific period.",
    "Tcl": "In Tcl, implement a script to automate file renaming.",
    "Awk": "In Awk, implement a text processing script to extract the second field from each line of a log file.",
    "Sed": "In Sed, implement a text replacement script to replace 'cat' with 'dog' in a text file.",
    "Grep": "In Grep, implement a pattern matching script to find lines containing 'error' in a file.",
    "Makefile": "In Makefile, write a build script to compile a C program and generate an executable file.",
    "CMake": "In CMake, implement a cross-platform build system configuration.",
    "Dockerfile": "In Dockerfile, write a container configuration file to build a Docker image with a Python environment.",
    "YAML": "In YAML, implement a configuration file for a web application, specifying port and database connection.",
    "JSON": "In JSON, implement a data exchange format to represent a user's personal information.",
    "XML": "In XML, implement a markup language document to describe a book's title and author.",
    "HTML": "In HTML, implement a simple web page with a title and a paragraph.",
    "CSS": "In CSS, implement a style sheet to add background color and font styles to an HTML page.",
    "Sass": "In Sass, implement a CSS preprocessor script to generate nested style sheets.",
    "Less": "In Less, implement a CSS preprocessor script using variables to define colors and generate CSS.",
    "PostScript": "In PostScript, implement a print script to generate a circle graphic.",
    "TeX": "In TeX, implement a typesetting document that includes mathematical formulas.",
    "ABAP": "In ABAP, implement a report program to retrieve and display customer data from an SAP database.",
    "ActionScript": "In ActionScript, create an interactive animation where a ball moves across the screen when a button is clicked.",
    "ALGOL": "In ALGOL, implement a procedure to calculate the greatest common divisor (GCD) of two numbers.",
    "Ballerina": "In Ballerina, implement a simple REST API service that returns a greeting message.",
    "Basic": "In Basic, write a program to calculate and display the area of a rectangle based on user input.",
    "BCPL": "In BCPL, implement a simple memory allocation function for dynamic arrays.",
    "Chapel": "In Chapel, implement a parallel program to compute the dot product of two large vectors.",
    "ColdFusion": "In ColdFusion, create a dynamic webpage that displays a list of products from a database.",
    "Datalog": "In Datalog, write a query to determine family relationships (e.g., 'Who is the grandparent?') from a set of facts.",
    "Elm": "In Elm, implement a simple counter web app with increment and decrement buttons.",
    "Hack": "In Hack, implement a type-safe function to validate and process a user registration form.",
    "Icon": "In Icon, write a program to generate all permutations of a given string.",
    "Io": "In Io, implement a prototype-based object system to simulate a simple car with start and stop methods.",
    "J#": "In J#, implement a console application to sort a list of names alphabetically.",
    "LabVIEW": "In LabVIEW, create a virtual instrument to measure and display the voltage from a simulated sensor.",
    "Ladder Logic": "In Ladder Logic, design a PLC program to control a traffic light sequence.",
    "LiveScript": "In LiveScript, implement a functional pipeline to process and filter an array of numbers.",
    "Logo": "In Logo, write a script to draw a square using turtle graphics.",
    "Mercury": "In Mercury, implement a type-safe program to solve a Sudoku puzzle.",
    "Modula-2": "In Modula-2, implement a module to manage a simple inventory system.",
    "OCaml": "In OCaml, implement a function to balance a binary search tree.",
    "PL/I": "In PL/I, write a program to calculate monthly loan payments based on principal and interest rate.",
    "Processing": "In Processing, create a visual sketch where circles follow the mouse cursor.",
    "Puppet": "In Puppet, write a manifest to configure a web server with specific ports and packages.",
    "Racket": "In Racket, implement a simple interpreter for a custom arithmetic language.",
    "REXX": "In REXX, write a script to parse and reformat a log file into a report.",
    "SAS": "In SAS, implement a data analysis program to compute summary statistics from a dataset.",
    "Scratch": "In Scratch, create a simple game where a sprite moves to avoid obstacles.",
    "Solidity": "In Solidity, implement a smart contract for a voting system on the Ethereum blockchain.",
    "SPARK": "In SPARK, implement a verified program to control an elevator��s floor selection safely.",
    "Squirrel": "In Squirrel, write a script to manage a simple game character��s health and inventory.",
    "Stan": "In Stan, implement a Bayesian model to fit a linear regression to sample data.",
    "Vala": "In Vala, implement a GTK application with a window and a button that changes color when clicked.",
    "VBA": "In VBA, automate an Excel task to sum a column and highlight cells above a threshold.",
    "Zig": "In Zig, implement a memory-safe program to reverse an array without using extra space.",
    "Apex": "In Apex, implement a Salesforce trigger to automatically update a contact��s status when an opportunity is closed.",
    "B": "In B, write a low-level function to swap two integer values without using a temporary variable.",
    "Brainfuck": "In Brainfuck, implement a program to print 'Hello, World!' using its minimalistic syntax.",
    "Ceylon": "In Ceylon, implement a type-safe class hierarchy for a library system with books and borrowers.",
    "CFML": "In CFML, create a dynamic page to display a user��s profile fetched from a database.",
    "Chisel": "In Chisel, design a hardware module for a simple 4-bit counter.",
    "Clarion": "In Clarion, implement a database application to manage customer orders and invoices.",
    "Clean": "In Clean, implement a purely functional program to compute the greatest common divisor (GCD) of two numbers.",
    "Clipper": "In Clipper, write a program to manage a simple inventory database with add and delete functions.",
    "Common Lisp": "In Common Lisp, implement a symbolic differentiation function for basic algebraic expressions.",
    "Dafny": "In Dafny, implement a verified program to sort an array with provable correctness.",
    "Delphi": "In Delphi, create a desktop application with a form to calculate and display a factorial.",
    "Eiffel": "In Eiffel, implement a class with design-by-contract to manage a stack with push and pop operations.",
    "Elm": "In Elm, build a simple web app with a text input that displays the character count in real-time.",
    "Factor": "In Factor, implement a stack-based program to calculate the sum of numbers from 1 to n.",
    "Falcon": "In Falcon, write a script to process and format a CSV file into a readable report.",
    "Frink": "In Frink, implement a unit conversion program to convert between miles and kilometers.",
    "GAMS": "In GAMS, model an optimization problem to minimize the cost of a production process.",
    "GAP": "In GAP, implement a group theory computation to find the order of a permutation group.",
    "Genie": "In Genie, create a simple GTK application with a button that toggles a label��s text.",
    "Haxe": "In Haxe, implement a cross-platform program to draw a animated bouncing ball.",
    "Hy": "In Hy, write a Lisp-style program to filter even numbers from a list.",
    "Idris": "In Idris, implement a dependently-typed function to append two lists with length preservation.",
    "Inform": "In Inform, create a simple text adventure game where the player navigates a room.",
    "JCL": "In JCL, write a job control script to execute a COBOL program on a mainframe.",
    "Jython": "In Jython, implement a Python script to interact with a Java library and print system properties.",
    "KRL": "In KRL, design a rule-based system to send a notification when a sensor value exceeds a threshold.",
    "LFE": "In LFE, implement a Lisp-based concurrent program to calculate factorials using actors.",
    "MQL4": "In MQL4, write a trading script for MetaTrader to calculate moving averages of stock prices.",
    "Nemerle": "In Nemerle, implement a macro-based program to generate boilerplate code for a class.",
    "Oberon": "In Oberon, write a modular program to simulate a simple file system.",
    "Opa": "In Opa, implement a full-stack web app with a chat interface running on both client and server.",
    "OpenCL": "In OpenCL, write a parallel program to perform matrix addition on a GPU.",
    "Oz": "In Oz, implement a multi-paradigm program to solve a constraint satisfaction problem like Sudoku.",
    "Pike": "In Pike, create a simple network server that echoes back client messages.",
    "Pony": "In Pony, implement an actor-based program to simulate a bank with concurrent transactions.",
    "Pure": "In Pure, write a term-rewriting program to simplify algebraic expressions.",
    "Q#": "In Q#, implement a quantum algorithm to generate a random bit using superposition.",
    "Red": "In Red, create a lightweight GUI app with a button that changes the window��s title.",
    "Ring": "In Ring, implement a simple game loop to move a character across the screen.",
    "RPG": "In RPG, write a business program to calculate employee payroll with tax deductions.",
    "S-Lang": "In S-Lang, implement a script to process astronomical data and compute averages.",
    "Simula": "In Simula, simulate a queueing system for customers in a bank.",
    "Standard ML": "In Standard ML, implement a functional program to reverse a list using pattern matching.",
    "SuperCollider": "In SuperCollider, create a synthesizer script to generate a sine wave sound.",
    "Turing": "In Turing, write an educational program to draw a spiral using turtle graphics.",
    "UnrealScript": "In UnrealScript, implement a simple game mechanic to spawn an enemy in Unreal Engine.",
    "Wolfram Language": "In Wolfram Language, create a visualization of a 3D mathematical function.",
    "X10": "In X10, implement a distributed program to compute the sum of an array across multiple nodes.",
    "ZPL": "In ZPL, write a parallel program to perform a stencil computation on a 2D grid.",
    "A#": "In A#, implement a simple audio processing script to generate a square wave tone.",
    "ABC": "In ABC, write a program to calculate and display the first 10 numbers of the Fibonacci sequence.",
    "Accent": "In Accent, implement a reactive system to update a counter based on incoming events.",
    "Agora": "In Agora, create an object-oriented program to simulate a simple online auction.",
    "Alef": "In Alef, implement a concurrent program to manage multiple threads printing numbers.",
    "Alice": "In Alice, design a 3D animation where a character walks across a scene.",
    "Amiga E": "In Amiga E, write a program to draw a colorful pattern on an Amiga-style display.",
    "AngelScript": "In AngelScript, implement a game scripting function to handle player movement in a 2D game.",
    "APL2": "In APL2, write an array-based program to compute the transpose of a matrix.",
    "Arc": "In Arc, implement a minimal web server that serves a custom HTML page.",
    "AspectJ": "In AspectJ, add logging functionality to an existing Java class using aspects.",
    "Ateji PX": "In Ateji PX, implement a parallel program to compute the sum of a large array.",
    "AutoHotkey": "In AutoHotkey, create a script to automate repetitive keyboard and mouse actions.",
    "Befunge": "In Befunge, write a 2D program to print the numbers from 1 to 10.",
    "BLISS": "In BLISS, implement a low-level routine to optimize bit manipulation in a system program.",
    "Boo": "In Boo, create a simple scripting program to process and sort a list of strings.",
    "C--": "In C--, implement an intermediate language function to multiply two integers.",
    "Caml": "In Caml, write a functional program to compute the depth of a binary tree.",
    "Charity": "In Charity, implement a purely functional program to process a stream of integers.",
    "ChucK": "In ChucK, create a real-time audio program to play a repeating drum pattern.",
    "Cilk": "In Cilk, implement a parallel program to compute the factorial of a number using spawn and sync.",
    "COMAL": "In COMAL, write an educational program to teach loops by printing a multiplication table.",
    "Curl": "In Curl, implement a rich internet application with a clickable button that changes text.",
    "DASL": "In DASL, design a dataflow program to filter and transform a stream of sensor data.",
    "DIBOL": "In DIBOL, write a business application to calculate total sales from a list of transactions.",
    "E": "In E, implement a secure distributed system to exchange encrypted messages between two nodes.",
    "Ease": "In Ease, create a visual programming script to animate a bouncing ball.",
    "Euphoria": "In Euphoria, write a simple interpreter for a custom command language.",
    "Fantom": "In Fantom, implement a cross-platform program to read and display a configuration file.",
    "Ferite": "In Ferite, create a lightweight script to simulate a dice-rolling game.",
    "FL": "In FL, implement a functional logic program to solve a simple puzzle like Towers of Hanoi.",
    "Focal": "In Focal, write a scientific calculator program to compute trigonometric functions.",
    "GameMaker Language": "In GameMaker Language, implement a simple platformer mechanic for jumping.",
    "GML": "In GML, design a graph manipulation program to find the shortest path between nodes.",
    "Hope": "In Hope, implement a lazy functional program to generate an infinite list of primes.",
    "ICI": "In ICI, write a script to process and reformat a text file into a table.",
    "INTERCAL": "In INTERCAL, create a humorous program to compute '2 + 2' with unnecessary complexity.",
    "Joy": "In Joy, implement a stack-based program to reverse a sequence of numbers.",
    "Kodu": "In Kodu, design a simple game where a character collects objects in a 3D world.",
    "Leda": "In Leda, write a multi-paradigm program combining imperative and functional styles to sort a list.",
    "Limbo": "In Limbo, implement a concurrent program for a distributed system running on Inferno OS.",
    "Miranda": "In Miranda, create a lazy functional program to compute the sum of squares up to n.",
    "MUMPS": "In MUMPS, implement a database application to store and retrieve patient records.",
    "Nial": "In Nial, write an array-oriented program to compute the average of nested arrays.",
    "Obliq": "In Obliq, implement a distributed GUI application with a button that updates remotely.",
    "OmniMark": "In OmniMark, create a text-processing script to convert XML to HTML.",
    "Opal": "In Opal, implement a functional program to manipulate algebraic data types like lists.",
    "PILOT": "In PILOT, write an educational script to quiz users on basic math problems.",
    "Self": "In Self, implement a prototype-based object system to model a simple car with behaviors.",
    "TOM": "In TOM, create a pattern-matching program to transform a string based on rules."    	    	
}