Category:Lua

Lua
This programming language may be used to instruct a computer to perform a task.

Official website

Execution method:	Interpreted
Garbage collected:	Yes
Type safety:	Safe
Type strength:	Strong
Type expression:	Implicit
Type checking:	Dynamic
See Also:	Lua on the HOPL BNF Grammar for Lua Lua compared to other languages

Listed below are all of the tasks on Rosetta Code which have been solved using Lua.

The Lua (pronounced LOO-ah) programming language is a lightweight, reflective, imperative and procedural language, designed as a scripting language with extensible semantics as a primary goal. The name is derived from the Portuguese word for moon.

Lua is commonly described as a "multi-paradigm" language, providing a small set of general features that can be extended to fit different problem types, rather than providing a more complex and rigid specification to match a single paradigm. Lua, for instance, does not contain explicit support for inheritance, but allows it to be implemented relatively easily with metatables. Similarly, Lua allows programmers to implement namespaces, classes, and other related features using its single table implementation; first class functions allow the employment of many powerful techniques from functional programming; and full lexical scoping allows fine-grained information hiding to enforce the principle of least privilege.

In general, Lua strives to provide flexible meta-features that can be extended as needed, rather than supply a feature-set specific to one programming paradigm. As a result, the base language is light—in fact, the full reference interpreter is only about 150KB compiled—and easily adaptable to a broad range of applications.

Citations[edit]

• Wikipedia:Lua (programming language)

Unimplemented programming tasks[edit]

Output from Find_unimplemented_tasks :

Lua has 186 unimplemented programming tasks:

 15 puzzle solver
 2048
 4-rings or 4-squares puzzle
 9 billion names of God the integer
 AKS test for primes
 Active Directory/Connect
 Active Directory/Search for a user
 Active object
 Aliquot sequence classifications
 Anagrams/Deranged anagrams
 Angle difference between two bearings
 Animation
 Append a record to the end of a text file
 Apply a digital filter (direct form II transposed)
 Arbitrary-precision integers (included)
 Archimedean spiral
 Arena storage pool
 Arithmetic-geometric mean/Calculate Pi
 Atomic updates
 Average loop length
 Averages/Mean time of day
 Babbage problem
 Balanced ternary
 Bernoulli numbers
 Best shuffle
 Bitcoin/address validation
 Bitcoin/public point to address
 Bitmap/Bresenham's line algorithm
 Bitmap/Bézier curves/Cubic
 Bitmap/Bézier curves/Quadratic
 Bitmap/Flood fill
 Bitmap/Midpoint circle algorithm
 Bitmap/PPM conversion through a pipe
 Bitmap/Read an image through a pipe
 Bitwise IO
 Brace expansion
 Break OO privacy
 Bulls and cows/Player
 CRC-32
 Call a function in a shared library
 Canny edge detector
 Carmichael 3 strong pseudoprimes
 Casting out nines
 Catmull–Clark subdivision surface
 Chat server
 Check Machin-like formulas
 Checkpoint synchronization
 Chinese remainder theorem
 Chinese zodiac
 Cholesky decomposition
 Circles of given radius through two points
 Closest-pair problem
 Color of a screen pixel
 Color quantization
 Colour bars/Display
 Colour pinstripe/Display
 Colour pinstripe/Printer
 Combinations and permutations
 Commatizing numbers
 Compare sorting algorithms' performance
 Compiler/AST interpreter
 Compiler/code generator
 Compiler/lexical analyzer
 Compiler/syntax analyzer
 Compiler/virtual machine interpreter
 Conjugate transpose
 Constrained random points on a circle
 Continued fraction
 Continued fraction/Arithmetic/Construct from rational number
 Convert decimal number to rational
 Cramer's rule
 Create a file on magnetic tape
 Create an object at a given address
 Cut a rectangle
 DNS query
 Death Star
 Deconvolution/2D+
 Define a primitive data type
 Delegates
 Determine if only one instance is running
 Digital root/Multiplicative digital root
 Dining philosophers
 Discordian date
 Distributed programming
 Documentation
 Doubly-linked list/Definition
 Doubly-linked list/Element definition
 Doubly-linked list/Element insertion
 Doubly-linked list/Traversal
 Draw a cuboid
 Draw a rotating cube
 Dutch national flag problem
 Eertree
 Egyptian division
 Egyptian fractions
 Element-wise operations
 Elementary cellular automaton
 Enforced immutability
 Equilibrium index
 Events
 Executable library
 Extend your language
 Extensible prime generator
 FASTA format
 FTP
 Factors of a Mersenne number
 Find common directory path
 Find largest left truncatable prime in a given base
 Find palindromic numbers in both binary and ternary bases
 Find the intersection of a line with a plane
 Floyd-Warshall algorithm
 Fractran
 Function frequency
 GUI component interaction
 GUI enabling/disabling of controls
 GUI/Maximum window dimensions
 Galton box animation
 Gaussian elimination
 Go Fish
 Greyscale bars/Display
 HTTPS
 HTTPS/Authenticated
 HTTPS/Client-authenticated
 Handle a signal
 Hash join
 Hello world/Line printer
 Hello world/Web server
 Hickerson series of almost integers
 Hofstadter Figure-Figure sequences
 Hofstadter Q sequence
 Hofstadter-Conway $10,000 sequence
 Honeycombs
 Horizontal sundial calculations
 Host introspection
 Hough transform
 Hunt The Wumpus
 Image convolution
 Image noise
 Inheritance/Single
 Integer overflow
 Inverted index
 Inverted syntax
 Jaro distance
 Joystick position
 Julia set
 K-d tree
 K-means++ clustering
 Keyboard input/Flush the keyboard buffer
 Keyboard input/Keypress check
 Keyboard input/Obtain a Y or N response
 Keyboard macros
 Knapsack problem/0-1
 Knapsack problem/Bounded
 Knapsack problem/Continuous
 Knuth's algorithm S
 LU decomposition
 Last letter-first letter
 Long multiplication
 Lucas-Lehmer test
 Lucky and even lucky numbers
 Lychrel numbers
 MD5/Implementation
 Machine code
 Mad Libs
 Main step of GOST 28147-89
 Maze solving
 Median filter
 Memory allocation
 Memory layout of a data structure
 Metered concurrency
 Metronome
 Miller–Rabin primality test
 Minesweeper game
 Modular exponentiation
 Modular inverse
 Mouse position
 Multiple regression
 Multiplicative order
 Narcissist
 Natural sorting
 Nautical bell
 Negative base numbers
 Non-continuous subsequences
 Nonoblock
 Nonogram solver
 Numeric error propagation

See also Reports:Tasks_not_implemented_in_Lua