Update

exercises.md

@@ -19,9 +19,9 @@ Here you will find suggestions for programming projects, roughly sorted by their
   - 4 points for a completed project in level 1.
   - 16 points for a completed project in level 2.
   - 64 points for a completed project in level 3.
-- If you complete all projects in level *N*, you can automatically consider all projects of all lower levels completed as well, i.e. if you complete level 2, count yourself whole level 1 and 0 as well.
-- A project is considered completed only if you really complete all the requirements! It is not enough to say "mmm, I could do this if I wanted" -- no, you have to REALLY DO IT to count. If the requirement is to make a complete game, a buggy demo doesn't count. Also if you just use some cheat, use 100 libraries to do everything for you, you know you didn't really complete it :) Just be honest with yourself.
-- You CANNOT award yourself partial points, i.e. if you meet 90% of requirements for some project, you CANNOT give yourself 90% points for it, not even one point. Complete it 100%, then get 100% points. Again, it doesn't count to say "mmm, I could finish this if I wanted" -- no, until you finish it, it's not finished. This is part of the challenge and insisting on it also makes you potentially make a nice, tidy program that will increase good in the world ;)
+- If you complete all projects in level *N*, you can automatically consider all projects of all lower levels completed as well, i.e. if you complete whole level 2, count yourself whole level 1 and 0 as well.
+- A project is considered completed only if you really complete all the requirements! It is not enough to say "mmm, I could do this if I wanted" -- no, you have to REALLY DO IT to count. If the requirement is to make a complete game, a buggy demo doesn't count. Also if you just use some cheat, use 100 libraries to do everything for you, you know you didn't really complete it :) If it's obvious implementing something is part of the challenge (for example collision detection in physics engine), you cannot use a library for it, you have to do it yourself. Just be honest with yourself.
+- You CANNOT award yourself partial points, i.e. if you meet 90% of requirements for some project, you CANNOT give yourself 90% points for it, not even one point. Complete it 100%, then get 100% points. Again, it doesn't count to say "mmm, I could finish this if I wanted" -- no, until you finish it it's not finished. This is part of the challenge and insisting on it also makes you potentially make a nice, tidy program that will increase good in the world ;)
 - You may reuse your own code without it counting as third party library, i.e. if you write 3D renderer in one project, you can use it in writing 3D game as another project, with it counting as if you wrote everything from scratch just for that project.
 - Don't [cheat](cheating.md), you're only cheating yourself :)
 
@@ -37,38 +37,38 @@ Here you will find suggestions for programming projects, roughly sorted by their
 
 1. **[fizzbuzz](fizzbuzz.md)**: Write the classic fizzbuzz program.
 2. **[anagram](anagram.md) checker**: Make a program that reads one line of text from the user and checks if it's an anagram (i.e. if it's spelled the same forward and backwards) or not -- you can just output *yes* or *no*.
-3. **number [encyclopedia](encyclopedia.md)**: Make a program that writes number from 0 to 1000 (including both) and about each of which it writes some facts. These facts have to include at least the number's square, square root, sum of its decimal digits, its [binary](binary.md) representation, prime factorization and whether the number is [prime](prime.md), perfect number and [Fibonacci](fibonnaci.md) number.
-4. **[brainfuck](brainfuck.md) interpreter**: Make a program that interprets brainfuck. You may choose to read the input program either from standard input or from a file (the file may have some hardcoded name, e.g. your program will just look for a file `program.bf` in the same directory). If the brainfuck program is invalid or runtime error occurs in it, you may just write out `error` and halt your interpreter. Thumbs up for making the interpreter nicer, e.g. allowing to pass input file name as a CLI argument, reporting more details about errors (e.g. its position in source code) and so on.
-5. **[game of life](game_of_life.md)**: Make a program that simulates game of life on a finite *N * N* grid, with wrapping (i.e. a cell on the very left of the grid is considered a neighbor of the cell on the very right in the same row, same thing with top and bottom). Make *N* configurable at least as a compile time option, draw the world as [ASCII art](ascii_art.md) to terminal, make the user step forward by pressing some key. You can initialize the grid values randomly, but thumbs up for allowing setting the initial world state (e.g. reading it from a file or something).
+3. **number [encyclopedia](encyclopedia.md)**: Make a program that writes numbers from 0 to 1000 (including both) and about each of which it writes some facts. These facts have to include at least the number's square, square root, sum of its decimal digits, its [binary](binary.md) representation, prime factorization and whether the number itself is [prime](prime.md), perfect number and [Fibonacci](fibonnaci.md) number.
+4. **[brainfuck](brainfuck.md) interpreter**: Make a program that interprets brainfuck. You may choose to read the input program either from standard input or from a file (the file may have some hardcoded name, e.g. your program will just look for a file named `program.bf` in the same directory). If the brainfuck program is invalid or runtime error occurs in it, you may just write out `error` and halt your interpreter. Thumbs up for making the interpreter nicer, e.g. allowing to pass input file name as a CLI argument, reporting more details about errors (e.g. its position in source code) and so on.
+5. **[game of life](game_of_life.md)**: Make a program that simulates game of life on a finite *N * N* grid, with wrapping space (i.e. a cell on the very left of the grid is considered a neighbor of the cell on the very right in the same row, same thing with top and bottom). Make *N* configurable at least as a compile time option, draw the world as [ASCII art](ascii_art.md) to terminal, make the user step forward by pressing some key. You can initialize the grid values randomly, but thumbs up for allowing setting the initial world state (e.g. reading it from a file or something).
 6. **text adventure**: Make an interactive [CLI](cli.md) text adventure that will take an average player at least 10 minutes to finish. Part of game mechanics must involve inventory, i.e. picking up items, carrying them around and using them.
-7. **calculator**: Make an interactive calculator -- it can be a purely [command line](cli.md) program into which user types expressions and your program evaluates them. The functionality must be at least on the level of the most plain physical calculators, i.e. it doesn't have to parse whole complex expressions, but it should be able to add, subtract, multiply, divide and find square roots. Results can be approximate, showing just 3 fractional decimal digits. Thumbs up for more features like handling expressions with brackets, converting between bases and so on.
-8. **[bytebeat](bytebeat.md)**: Make at least two cool sounding bytebeat songs.
+7. **calculator**: Make an interactive calculator -- it can be a purely [command line](cli.md) program into which user types expressions and your program evaluates them. The functionality must be at least on the level of the most plain physical calculators, i.e. it doesn't have to parse whole complex expressions, but it should be able to add, subtract, multiply, divide and find square roots. Results can be approximate, showing just 3 fractional decimal digits. Thumbs up for more features like handling expressions with brackets, having a variable storing last result, converting between bases and so on.
+8. **[bytebeat](bytebeat.md)**: Make at least three cool sounding bytebeat songs.
 
 ### Level 2: Mid, *Hurt Me Plenty*
 
-1. **[chess](chess.md) without AI**: Make a program that allows two human players to play chess, AI is not required. It can be just a CLI program that draw the chessboard to terminal and reads moves by having players type the squares. Of course the program mustn't allow illegal moves, it must know if the game ended, who won (or if it's a draw) and so on. Implement all rules correctly, i.e. don't forget en passant, castling rights and so on. Time controls are not required at all. Thumbs up for some basic recording of games, undos, showing playable squares or even having some kind of stupid AI (can just make random moves).
-2. **2D game**: Make a complete 2D game in which you control a character, with at least 5 levels. Genre is up to you, recommended is e.g. platformer or top-down shooter. Sounds are not required but thumbs up if you have them. If you want, you can try [SAF](saf.md) for this.
+1. **[chess](chess.md) without AI**: Make a program that allows two human players to play chess, AI is not required. It can be just a CLI program that draws the chessboard to terminal and reads moves by having players type the squares. Of course the program mustn't allow illegal moves, it must know if the game ended, who won (or if it's a draw) and so on. Implement all rules correctly, i.e. don't forget en passant, castling rights, stalemates and so on. Time controls are not required at all. Thumbs up for some basic recording of games, undos, showing playable squares or even having some kind of stupid AI (can just make random moves).
+2. **2D game**: Make a complete 2D game in which you control a character, with at least 5 levels. Genre is up to you, recommended is e.g. platformer or top-down shooter. The game must have "real" graphics, i.e. not just terminal ASCII art -- using a library like [SAF](saf.md), Allegro or [SDL](sdl.md) may be a good choice. Sounds are not required but thumbs up if you have them.
 3. **[gopher](gopher.md) browser**: Write interactive gopher browser -- it can be a purely [command line](cli.md) browser. It has to be able to follow links and go back at least one page. The program must include some basic help and ability to save files to disk.
-4. **simple text [compression](compression.md)**: Write a program that can compress and decompress plain [ASCII](ascii.md) text files using some very simple technique like [run length encoding](rle.md) (RLE) or dictionary methods (you can even use a fixed dictionary, e.g. have a list of common English words that you will represent by some shorter symbols). You can assume input characters will only have 7bit ASCII codes, so you can compress the text also by dropping the 8th unused bit. You don't have to achieve great compression ratio (you can even enlarge some files), but you must pass the following test: take the program's source code, this article's plain text and Wikipedia main page plain text, your program must compress at least two of these to a smaller size (and of course successfully decompress them into identical files). The program must work as a [filter](filter.md), i.e. it mustn't load the whole file into memory, it has to use approximately same amount of RAM for input of any size.
-5. **stupid chatbot**: Make an entertaining chatbot that can react to basic sentences like "how are you?", "are you a robot?" and so on. It must give a human-like answer to at least 20 different sentences. It has to deal with typos and text variability a little bit and has to have some kind of memory (for example it can remember the name of its chatting partner). Test the bot by having it chat with itself.
-6. **arbitrary size [rational numbers](rational_number.md)**: Make a library that allows working with arbitrary size rational numbers, i.e. represent each number as a pair of numerator and denominator, the number will be automatically allocating itself as much memory as it needs for storing the two numbers. It mustn't waste too much memory, i.e. whenever it changes, it will try to reallocate its memory and decrease its size if possible. Size of the number will only be limited by amount of RAM your program can use. Furthermore implement these operations with the numbers: converting to/from the language's native numbers (with rounding if necessary), comparisons (equal, greater, greater or equal, smaller, smaller or equal), addition, subtraction, multiplication, division and printing and/or converting the number to string (at least decimal -- if the number has infinitely many fractional digits, just cut it somewhere).
-7. **image to [ASCII art](ascii_art.md)**: Make a program that takes an RGB bitmap image and renders it with ASCII characters (i.e. prints it out to console). You can support loading the image from just one file format of your choice, possibly something simple like PPM, BMP or Farbfeld. The program must support resizing the image and it must allow to just set one dimension with keeping the aspect ratio.
+4. **simple text [compression](compression.md)**: Write a program that can compress and decompress plain [ASCII](ascii.md) text files using some very simple technique like [run length encoding](rle.md) (RLE) or dictionary methods (you can even use a fixed dictionary, e.g. have a list of common English words that you will represent by some shorter symbols). You can assume input characters will only have 7bit ASCII codes, so you can compress the text also by dropping the 8th unused bit. You don't have to achieve great compression ratio (you can even enlarge some files), but you must pass the following test: take the program's source code, this article's plain text and Wikipedia main page plain text, your program must compress at least two of these to a smaller size (and of course successfully decompress them into identical files). The program must work as a [filter](filter.md), i.e. it mustn't load the whole file into memory or perform multiple passes, it has to use approximately same amount of RAM for input of any size.
+5. **stupid chatbot**: Make an entertaining chatbot that can react to basic sentences like "how are you?", "are you a robot?" and so on. It must give a human-like answer to at least 20 different sentences. It has to deal with typos and text variability a little bit (for example multiple spaces in a row mustn't confuse it) and has to have some kind of memory (for example it can remember the name of its chatting partner or it can have something like mood meter). Test the bot by having it chat with itself.
+6. **arbitrary size [rational numbers](rational_number.md)**: Make a library that allows working with arbitrary size rational numbers, i.e. represent each number as a pair of numerator and denominator, the number will be automatically allocating itself as much memory as it needs for storing the two numbers. It mustn't waste too much memory, i.e. whenever it changes, it will try to reallocate its memory and decrease its size if possible. Size of the number will only be limited by amount of RAM your program can use. Furthermore implement these operations with the numbers: converting to/from the language's native numbers (with rounding if necessary), comparisons (equal, greater, greater or equal, smaller, smaller or equal), addition, subtraction, multiplication, division and printing and/or converting the number to string (at least decimal -- if the number has infinitely many fractional digits, just cut the output somewhere).
+7. **image to [ASCII art](ascii_art.md)**: Make a program that takes an RGB bitmap image and renders it with ASCII characters (i.e. prints it out to console). You can support loading the image from just one file format of your choice, possibly something simple like PPM, BMP or Farbfeld. The program must support resizing the image and it must allow to just set one dimension with keeping the aspect ratio. Thumbs up for extra features like setting brightness/contrast and so on.
 8. **educational [sorting](sorting.md) visualization**: Make a program for visualizing sorting algorithms -- it may draw real graphics (either directly to the screen or by outputting animation file) or just render ASCII art graphics, but it has to clearly show what the sorting algorithm is doing, i.e. which elements are being compared, which are swapped and if it makes good sense to highlight something else (like the pivot or already sorted part of the array), you should do it. Implement at least bubble sort, insertion sort, selection sort and quick sort. Also offer benchmark mode in which all algorithms race in sorting the same array (this can be without advanced visualization, just show e.g. number of steps for each).
-9. **3D model of [fractal](fractal.md)**: Make a program that outputs 3D model of either Sieprinski triangle or Koch snowflake fractal. The output shall be some simple 3D format like obj or Collada. The model can be primitive, i.e. it can be just flat shape made of triangles which don't have to really be connected, but the program must allow specifying the number of iterations of the fractal (during invocation, e.g. as a CLI flag). Check that the model is correct by opening it in some 3D editor such as Blender.
+9. **3D model of [fractal](fractal.md)**: Make a program that outputs 3D model of either Siepinski triangle or Koch snowflake fractal. The output shall be some simple 3D format like obj or Collada. The model can be primitive, i.e. it can be just flat shape made of triangles which don't have to really be connected, but the program must allow specifying the number of iterations of the fractal (during invocation, e.g. as a CLI flag). Check that the model is correct by opening it in some 3D editor such as Blender.
 10. **[sudoku](sudoku.md) solver**: Create a program to which the user somehow passes a sudoku puzzle (in a file, through a CLI flag, interactively... the choice is yours, but passing a new puzzle mustn't require program recompilation) and the program attempts to solve it. It must first employ some basic reasoning, at very least it has to repeatedly try the elimination method, i.e. marking a set of possible values in each empty square and then reducing these sets by crossing out values that can't be in that square because the same value is in its column/row/minisquare -- wherever only one value remains in the set, it is filled in as final; this has to be repeated until no more progress is being made. If you want, you can employ other techniques as well. After this if the puzzle is still not solved, the program will resort to [brute force](brute_force.md) which has to eventually lead to solution (even if it would take too long). If the program finds that the puzzle is unsolvable, it has to report it.
 
 ### Level 3: Hard, *Ultra Violence*
 
-1. **non-trivial [programming language](programming_language.md)**: Design language *L* and make an interpreter for it. *L* must be [Turing complete](turing_complete.md) and you have to provide mathematical proof of it. *L* must allow [recursive](recursion.md) function calls. It must not support native [OOP](oop.md). *L* must be usable for programming very basic things -- show it is so by writing [bubble sort](bubble_sort.md) in it. Write [quine](quine.md) in it.
+1. **non-trivial [programming language](programming_language.md)**: Design language *L* and make an interpreter for it. *L* must be [Turing complete](turing_complete.md) and you have to provide mathematical proof of it. *L* must allow [recursive](recursion.md) function calls. It must not support native [OOP](oop.md). *L* must be usable for programming very basic things -- show it is so by writing [bubble sort](bubble_sort.md) in it. Write [quine](quine.md) in it. Thumbs up for also making a compiler.
 2. **radiation hardened quine**: Without looking it up, write radiation hardened [quine](quine.md) in some language. Quine is a program that outputs its own source code (don't cheat, you can't read it from the source file), radiation hardened quine is a quine that remains a quine if you remove any single character from the program.
-3. **3D game**: Make a complete game with 3D graphics from 1st or 3rd man perspective that will have at least half an hour worth of gameplay time -- the gameplay can really be 2D (e.g. like [wolf3D](wolf3d.md)) but the graphics must be judged as 3D by average guy who sees the game. If your platform allows it at all, it must have basic sounds (no need for music, but e.g. shooting should at least make beeps and so on). The genre is up to you, it can be a shooter, platformer, RPG or anything where you control a character moving through 3D world. For the 3D graphics you can either use a 3D library, in which case you HAVE TO implement textured graphics (the textures may be [procedural](procgen.md) if you want), or you can write your own renderer. If you write custom renderer, then if it's a "true 3D", it can have just flat, untextured graphics; if it's a "[pseudo 3D](pseudo3d.md)" (like raycasting or BSP, ...), it must have at least some texturing (e.g. walls).
-4. **textured 3D [software renderer](software_rendering.md)**: Make 3D software renderer that rasterizes triangles (just like for example [OpenGL](ogl.md)), with texturing. Affine texture mapping (i.e. the easier, incorrect texturing by linear interpolation of texturing coordinates in screen space) will pass, but thumbs up for perspective correct texture mapping. Implement some basic [shading](shading.md) like, e.g. Goraud with ambient and diffuse light. You have to handle visibility even of non-convex shapes, e.g. with z-buffer or at least approximately by sorting triangles. It's enough if you can display some textured model with setting camera position and rotation somehow. You don't have to handle any 3D formats, 3D models can just be passed as arrays of numbers. It is enough if you output static images e.g. to a file, but thumbs up for being able to handle real-time rendering, animation and having extra features like transparency, scene graph and so on. Extra thumbs up for not using [float](float.md).
+3. **3D game**: Make a complete game with 3D graphics from 1st or 3rd man perspective that will have at least half an hour worth of gameplay time -- the gameplay can really be 2D (e.g. like [wolf3D](wolf3d.md)) but the graphics must be judged as 3D by average guy who sees the game. If your platform allows it at all, it must have basic sounds (no need for music, but e.g. shooting should at least make beeps and so on). The genre is up to you, it can be a shooter, platformer, RPG or anything where you control a character. For the 3D graphics you can either use a 3D library, in which case you HAVE TO implement textured graphics (the textures may be [procedural](procgen.md) if you want), or you can write your own renderer. If you write custom renderer, then if it's a "true 3D", it can have just flat, untextured graphics; if it's a "[pseudo 3D](pseudo3d.md)" (like raycasting or BSP, ...), it must have at least some texturing (e.g. walls).
+4. **textured 3D [software renderer](sw_rendering.md)**: Make 3D software renderer that rasterizes triangles (just like for example [OpenGL](ogl.md)), with texturing. Affine texture mapping (i.e. the easier, incorrect texturing by linear interpolation of texturing coordinates in screen space) will pass, but thumbs up for perspective correct texture mapping. Implement some basic [shading](shading.md) like, e.g. Goraud with ambient and diffuse light. You have to handle visibility even of non-convex shapes, e.g. with z-buffer or at least approximately by sorting triangles. It's enough if you can display some textured model with setting camera position and rotation somehow. You don't have to handle any 3D formats, 3D models can just be passed as arrays of numbers (same with textures). It is enough if you output static images e.g. to a file, but thumbs up for being able to handle real-time rendering, animation and having extra features like transparency, scene graph and so on. Extra thumbs up for not using [float](float.md).
 5. **[regular expression](regex.md) library**: Make a library for working with regular expressions. Implement at least the following operations: search of regular expression, substitution of regular expressions WITH capture groups and generating random strings by regular expression.
-6. **[chess](chess.md) [AI](ai.md)**: Use any sane approach to write a chess engine of reasonable strength. No, you can't just fork stockfish, write it from scratch. It has to support xboard or UCI interface, the strength must be such that it beats [smolchess](smallchesslib.md), Maia 1500, GNU chess, Dreamer, Stockfish or similar engine in a 10 game match with both engines having equivalent settings (search depth, time for move etc.); alternatively it can pass by getting stable rating over 1600 on lichess or by beating someone with FIDE rating over 1500 in a 10 game match. You get the idea.
-7. **bitmap image editor**: [GIMP](gimp.md) is bloated! You have to save us by writing a GUI image editor that's at least a bit more advanced than the original MS paint. It has to be able to save and load images (supporting just one format is enough), draw basic shapes (at least a line, rectangle and circle), copy/paste parts of the image (with rectangle select), resize the image as a whole (with scaling it), have fill bucket and adjust brightness and contrast of the whole image. It should be reasonably user friendly, i.e. upon quitting it should ask if you want to save the work etc. Thumbs up for extra features like filters (blur, invert, edge detect, ...), layers and so on.
-8. **64K intro**: Make an impressive [demoscene](demoscene.md)-style 3D intro with music that's at least 1 minute long and fits into 64 KB. It has to be good enough so that an average demoscener would approve it as not completely laughable.
+6. **[chess](chess.md) [AI](ai.md)**: Use any sane approach to write a chess engine of reasonable strength. No, you can't just fork stockfish, write it from scratch. It has to support xboard or UCI interface, the strength must be such that in usually wins at least once in a 10 game match against [smolchess](smallchesslib.md), Maia 1500, GNU chess, Dreamer, ChessMaster, Stockfish or similar engine with equivalent settings (search depth, time for move etc.); alternatively it can pass by getting stable rating over 1600 on lichess or by beating someone with FIDE rating over 1500 in a 10 game match. You get the idea.
+7. **bitmap image editor**: [GIMP](gimp.md) is bloated! You have to save us by writing a GUI image editor that's at least a bit more advanced than the original MS paint. It has to be able to save and load images (supporting just one format is enough), draw basic shapes (at least a line, rectangle and circle), copy/paste parts of the image (with rectangle select), resize the image as a whole (with scaling it), have fill bucket and adjust brightness and contrast of the whole image. It should be reasonably user friendly, i.e. upon quitting it should ask if you want to save the work, it must have some basic help etc. Thumbs up for extra features like filters (blur, invert, edge detect, ...), layers and so on.
+8. **64K intro**: Make an impressive [demoscene](demoscene.md)-style 3D intro with music. It must have duration of at least 1 minute and fit into a 64 KB executable. It has to be good enough so that an average demoscener would approve it as not completely laughable.
 9. **3D [path tracer](path_tracing.md) without [floating point](float.md)**: Write a path tracer (NOT a mere [ray tracer](ray_tracing.md)) without using floating point. It can only produce static images that may just be saved to a file in some simple format (no need to draw real time animation to the screen). It must be possible to position and rotate the camera arbitrarily and to set its field of view. It has to support several shapes of objects in the scene: at least a sphere, plane and cylinder, and it must support transparent objects. Thumbs up for supporting polygonal models, depth of field and loading scene description from a file.
-10. **[gopher](gopher.md) fulltext search engine**: Create a whole search engine (with crawler, index creator, user frontend, ...) for the gopher network. It can store its database just to flat files (no need to use SQL or something like that). It has to allow at least very basic fulltext search, i.e. about each gopher site you'll have to remember which words it contains (and possibly their count), so that if the user searched e.g. for `cats dogs`, you'll give him sites that contain both of these words somewhere in their text. Besides this you can make simplifications (ignore case, don't support Unicode, special characters etc.). Thumbs up for additional features like creating a graphical map of the crawled gopherspace along the way.
+10. **[gopher](gopher.md) fulltext search engine**: Create a whole search engine (with crawler, index creator, user frontend, ...) for the gopher network. It can store its database just to flat files (no need to use SQL or something like that). It has to allow at least very basic fulltext search, i.e. about each gopher site you'll have to remember which words it contains (and possibly their count), so that if the user searched e.g. for `cats dogs`, you'll give him sites that contain both of these words somewhere in their text -- offer options to search either for sites containing all searched words or just some of them. Besides this you can make simplifications (ignore case, don't support Unicode, special characters etc.). Thumbs up for additional features like creating a graphical map of the crawled gopherspace along the way.
 
 ### Level 4: God Tier, *!Nightmare!*
 
@@ -96,6 +96,7 @@ Here are some questions to test your LRS related knowledge :D
 10. We have two gears, each of same size and same number of teeth. Gear A is fixed in place, it can't move or rotate, gear B runs around gear A so that it keeps touching it (and therefore rotates along the way) until it gets to the place where it started. How many revolutions around its own axis (from your stationary point of view) has gear B made?
 11. What's the worst socioeconomic system in the world? You don't even have to say why because that would take too long.
 12. Manually convert the [binary](binary.md) numeral 10110000000010110101 to hexadecimal.
+13. How would you compute the circumference of a circle with radius *r* without using floating point? Consider just the approximate value of pi ~= 3.14, i.e. write the formula multiplying *2 * r* by 3.14 only using whole numbers (of course the result will be rounded to whole number too).
 
 ### Answers
 
@@ -110,4 +111,5 @@ Here are some questions to test your LRS related knowledge :D
 9. third
 10. two (try it, see coin rotation paradox)
 11. [capitalism](capitalism.md)
-12. B00B5
+12. B00B5
+13. *(2 * r * 314) / 100*

history.md

@@ -16,7 +16,7 @@ Around 50 AD Heron of Alexandria, an Egyptian mathematician, created a number of
 
 In the 3rd century Chinese mathematician Liu Hui describes operations with **negative numbers**, even though negative numbers have already appeared before. In 600s AD an Indian astronomer Brahmagupta first used the number **[zero](zero.md)** in a systematic way, even though hints on the number zero without deeper understanding of it appeared much earlier. In 9th century the Mayan empire is [collapsing](collapse.md), though it would somewhat recover and reshape.
 
-Year 476 is set to mark the fall of Roman empire (last roman emperor deposed) and by this the end of Antiquity and **start of Middle Ages**, a time during which technological [progress](progress.md) and [art](art.md) is seen to stagnate a bit. Rome had been [collapsing](collapse.md) slowly but in its downfall it greatly resembled our [current western society](21st_century.md), it became split, people got spoiled, lost sense of morality, women started to demand [more power](feminism.md) and so on -- Roman empire was basically like the ancient times [US](usa.md) (with a similar relationship to Greece as US has to the older, wiser Europe) with highly [capitalist](capitalism.md) practices ([free trade](free_trade.md), ads, banks, insurance, even industries that achieved quite high mass production, ...), imperialism, [military](military.md) obsession, fascism, constant political fights, pragmatic thinking (e.g. rhetoric, the art of manipulation, was greatly preferred over excellence in [art](art.md)), mass entertainment and huge competitiveness -- this all led to its demise.
+Year 476 is set to mark the fall of Roman empire (last roman emperor deposed) and by this the end of Antiquity and **start of Middle Ages**. Rome had been [collapsing](collapse.md) slowly but in its downfall it greatly resembled our [current western society](21st_century.md), it became split, people got spoiled, lost sense of morality, women started to demand [more power](feminism.md) and so on -- Roman empire was basically like the ancient times [US](usa.md) (with a similar relationship to Greece as US has to the older, wiser Europe) with highly [capitalist](capitalism.md) practices ([free trade](free_trade.md), ads, banks, insurance, even industries that achieved quite high mass production, ...), imperialism, [military](military.md) obsession, fascism, constant political fights, pragmatic thinking (e.g. rhetoric, the art of manipulation, was greatly preferred over excellence in [art](art.md)), mass entertainment and huge competitiveness -- this all led to its demise.
 
 In 1429 Persian mathematician al-Kashi computed [pi](pi.md) to about 14 digit accuracy which was a great leap in this discipline.
 

how_to.md

@@ -178,7 +178,7 @@ You should look like this:
 
 ## How Not To Get Depressed Living In This Shitty Dystopia
 
-I don't know lol, you tell me. Becoming more independent of this system really helps though, just accept everything will get destroyed in a few years -- yes, all you ever liked is basically already dead, just deal with it and find new things to like such as reading books instead of scrolling through facebook etc. Unconditional love and [altruism](altruism.md) helps too, just let go of the hate and fight, help people selflessly without expecting rewards. One of the big challenges is also dealing with the *Cassandra complex*, i.e. the fact that only you know the truth but you can't communicate it to others, they don't listen, it's like a nightmare but real, you have to deal with this by mediation.
+I don't know lol, you tell me. Becoming more independent of this system really helps though, just accept everything will get destroyed in a few years -- yes, all you ever liked is basically already dead, just deal with it and find new things to like such as reading books instead of scrolling through facebook etc. Unconditional love and [altruism](altruism.md) helps too, just let go of the hate and fight, help people selflessly without expecting rewards. One of the big challenges is also dealing with the *Cassandra complex*, i.e. the fact that only you know the truth but you can't communicate it to others, they don't listen, it's like a nightmare but real, you have to deal with this by meditation.
 
 ## Other
 

liberalism.md

@@ -4,4 +4,4 @@
 
 Liberalism is a political ideology whose definition is not greatly clear (we may find branches that differ a lot) but which usually aims for "liberty", focus on individuals who ought to be protected by the state and have equal opportunities, which leads to obsession with all kinds of "[rights](rights_culture.md)" and "[social justice](social_revenge.md)" (i.e. social revenge of minorities); as one of worst imaginable ideologies it is no surprise it's the prevailing [US](usa.md) ideology and ideology of [SJW](sjw.md)s -- liberalism is taking over the whole western world and it's destroying everything. It basically tries to take the worst of all other ideologies: liberalism supports things such as [state](state.md) and strong laws (to "protect" people), [capitalism](capitalism.md) (to give them "opportunities"), [censorship](censorship.md), [political correctness](political_correctness.md) and violence; supporting concepts connected to both [right and (pseudo)left](left_right.md), it is said to be a "centrist" stance, however [we](lrs.md) just call it confused -- they just try to combine absolutely incompatible things, they want a competitive environment in which "everyone wins". Liberalism is highly [harmful](harmful.md), retarded and should never be supported.
 
-Libertarianism is associated with the [color](color.md) yellow (same as with libertarianism), which symbolized piss.
+Liberalism is associated with the [color](color.md) yellow (same as with [libertarianism](libertarianism.md) and [capitalism](capitalism.md)), which symbolized piss.

pi.md

@@ -1,6 +1,6 @@
 # Pi
 
-Pi (normally written with a Greek alphabet symbol with [Unicode](unicode.md) value U+03C0) is one of the most important and famous [numbers](number.md), equal to approximately 3.14, most popularly defined as the ratio of a circle's circumference to its diameter (but also definable in other ways). It is one of the most fundamental mathematical constants of our universe and appears extremely commonly in [mathematics](math.md), nature and, of course, [programming](programming.md). When written down in traditional decimal system, its digits go on and on without end and show no repetition or simple pattern, appearing "random" and [chaotic](chaos.md) -- as of 2021 pi has been evaluated by [computers](computer.md) to 62831853071796 digits. In significance and properties pi is similar to another famous number: [e](e.md). Pi day is celebrated on March 14.
+Pi (normally written with a Greek alphabet symbol with [Unicode](unicode.md) value U+03C0) is one of the most important and famous [numbers](number.md), equal to approximately 3.14, most popularly defined as the ratio of a circle's circumference to its diameter (but also definable in other ways). It is one of the most fundamental mathematical constants of our universe and appears extremely commonly in [mathematics](math.md), nature and, of course, [programming](programming.md). When written down in traditional decimal system, its digits go on and on without end and show no repetition or simple pattern, appearing "random" and [chaotic](chaos.md) -- as of 2021 pi has been evaluated by [computers](computer.md) to 62831853071796 digits, although approximate values have been known from very early times (e.g. the value (16/9)^2 ~= 3.16 has been known as early as around 1800 BC). In significance and properties pi is similar to another famous number: [e](e.md). Pi day is celebrated on March 14.
 
 { Very nice site about pi: http://www.pi314.net. ~drummyfish }
 
@@ -24,12 +24,16 @@ Additionally contrary to what's sometimes claimed **it is also unproven (though
 
 What makes pi special then? Well, mostly its significance as one of the most fundamental constants that seems to appear extremely commonly in math and nature, it seems to stand very close to the root of description of our universe -- not only does pi show that circles are embedded everywhere in nature, even in very abstract ways, but we find it in [Euler's identity](eulers_identity.md), one of the most important equations, it is related to [complex exponential](complex_exponential.md) and so to [Fourier transform](fourier_transform.md), waves, oscillation, trigonometry ([sin](sin.md), [cos](cos.md), ...) and angles ([radians](radian.md) use pi), it even starts appearing in [number theory](number_theory.md), e.g. the probability of two numbers being relative primes is 6/(pi^2), and so on.
 
-## Approximations And Programming
+## Approximations, Estimations, Measuring And Programming
 
 Evaluating many digits of pi is mathematically [interesting](interesting.md), programs for computing pi are sometimes used as [CPU](cpu.md) [benchmarks](benchmark.md). There are programs that can search for a position of arbitrary string encoded in pi's digits. However in practical computations we can easily get away with pi approximated to just a few decimal digits, **you will NEVER need more than 20 decimal digits**, not even for space flights (NASA said they use 15 places).
 
 One way to judge the quality of pi approximation can be to take the number of pi digits it accurately represents versus how many digits there are in the approximation formula -- this says kind of the approximation's [compression](compression.md) ratio. But other factors may be important too, e.g. simplicity of evaluation, functions used etc.
 
+Also remember, **you can measure pi in real life** by many methods: you can draw a big circle, measure its radius and circumference and then make the division, you can also manually perform the Monte Carlo algorithm (see below) by drawing a circle and then throwing objects around, counting how many fall inside and outside (just watch out to do it correctly, for example you must have the fall spot probability as random as possible, not biased in any way), or you can similarly make a square from wood, then cut out its inscribed circle, weight both parts and compute pi (with the same formula as for Monte Carlo).
+
+{ I tried this -- I took a pizza box, cut out four squares, then  used a pencil on string to draw quarter circles on each, cut them and weighted both groups. All the circle parts weighted 61 grams, the rest weighted 16 grams, this gives me a nice estimate value of pi of about 3.16. ~drummyfish }
+
 An ugly engineering [approximation](approximation.md) that's actually usable sometimes (e.g. for fast rough estimates with integer-only hardware) is just (something like this was infamously almost made the legal value of pi by the so called Indiana bill in 1897)
 
 pi ~= 3

wiki_stats.md

@@ -3,9 +3,9 @@
 This is an autogenerated article holding stats about this wiki.
 
 - number of articles: 569
-- number of commits: 758
-- total size of all texts in bytes: 3548047
-- total number of lines of article texts: 27883
+- number of commits: 759
+- total size of all texts in bytes: 3552622
+- total number of lines of article texts: 27886
 - number of script lines: 262
 - occurences of the word "person": 8
 - occurences of the word "nigger": 71
@@ -35,60 +35,72 @@ longest articles:
 
 top 50 5+ letter words:
 
-- which (2041)
+- which (2043)
 - there (1524)
-- people (1339)
-- other (1105)
-- example (1062)
+- people (1343)
+- other (1107)
+- example (1066)
 - software (1042)
 - number (976)
-- about (922)
-- program (817)
-- their (765)
-- called (715)
-- because (691)
-- would (690)
+- about (923)
+- program (822)
+- their (766)
+- called (716)
+- because (694)
+- would (691)
 - computer (690)
 - simple (666)
-- being (661)
-- numbers (649)
-- things (644)
+- being (664)
+- numbers (650)
+- things (646)
 - language (637)
 - without (622)
 - programming (613)
 - function (611)
 - however (589)
-- something (582)
-- these (576)
+- something (583)
+- these (577)
 - different (565)
+- system (533)
 - world (532)
-- system (532)
 - should (525)
 - games (524)
-- point (519)
+- point (518)
 - society (504)
 - doesn (498)
 - though (493)
-- memory (488)
+- memory (490)
 - drummyfish (467)
 - while (466)
 - using (462)
 - technology (454)
-- course (447)
+- course (448)
+- still (446)
 - similar (446)
-- still (445)
 - simply (443)
-- possible (436)
-- https (426)
+- possible (437)
+- https (428)
 - really (408)
 - computers (398)
-- extremely (395)
-- usually (392)
-- value (388)
+- extremely (396)
+- usually (393)
+- value (391)
 
 latest changes:
 
 ```
+Date:   Wed Apr 3 22:57:42 2024 +0200
+  exercises.md
+  interesting.md
+  main.md
+  money.md
+  often_confused.md
+  random_page.md
+  real_number.md
+  soyence.md
+  trolling.md
+  wiki_pages.md
+  wiki_stats.md
 Date:   Wed Apr 3 17:16:51 2024 +0200
   bloat.md
   disease.md
@@ -110,18 +122,6 @@ Date:   Tue Apr 2 22:47:48 2024 +0200
   future_proof.md
   how_to.md
   javascript.md
-  main.md
-  python.md
-  random_page.md
-  wiki_pages.md
-  wiki_stats.md
-  yes_they_can.md
-  youtube.md
-Date:   Sun Mar 31 20:21:22 2024 +0200
-  3d_model.md
-  acronym.md
-  anarch.md
-  bootstrap.md
 ```
 
 most wanted pages:
@@ -154,7 +154,7 @@ most popular and lonely pages:
 - [capitalism](capitalism.md) (198) 
 - [bloat](bloat.md) (197) 
 - [free_software](free_software.md) (163) 
-- [game](game.md) (134) 
+- [game](game.md) (135) 
 - [suckless](suckless.md) (131) 
 - [proprietary](proprietary.md) (114) 
 - [kiss](kiss.md) (91)