| 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." | |
| } | |