├── .github ├── CODE_OF_CONDUCT.md ├── CONTRIBUTING.md ├── FUNDING.yml ├── ISSUE_TEMPLATE │ ├── code-snippet-request.md │ ├── documentation.md │ ├── language-test-request.md │ └── project-test-request.md ├── PULL_REQUEST_TEMPLATE.md ├── PULL_REQUEST_TEMPLATE │ ├── code-snippet.md │ ├── existing-language-tests.md │ ├── new-language-code-snippet.md │ ├── new-project-tests.md │ └── refactor.md ├── README.md └── workflows │ ├── codeql-analysis.yml │ ├── docs.yml │ ├── greetings.yml │ ├── readme.yml │ └── test-suite.yml ├── .gitignore ├── .glotter.yml ├── LICENSE ├── archive ├── a │ ├── ada │ │ ├── README.md │ │ ├── baklava.adb │ │ ├── fizz-buzz.adb │ │ ├── hello-world.adb │ │ └── testinfo.yml │ ├── agda │ │ ├── Baklava.agda │ │ ├── HelloWorld.agda │ │ ├── README.md │ │ └── testinfo.yml │ ├── algol68 │ │ ├── README.md │ │ ├── baklava.alg │ │ ├── base64-encode-decode.alg │ │ ├── binary-search.alg │ │ ├── bubble-sort.alg │ │ ├── capitalize.alg │ │ ├── convex-hull.alg │ │ ├── depth-first-search.alg │ │ ├── dijkstra.alg │ │ ├── duplicate-character-counter.alg │ │ ├── even-odd.alg │ │ ├── factorial.alg │ │ ├── fibonacci.alg │ │ ├── file-input-output.alg │ │ ├── fizz-buzz.alg │ │ ├── fraction-math.alg │ │ ├── hello-world.alg │ │ ├── insertion-sort.alg │ │ ├── job-sequencing.alg │ │ ├── josephus-problem.alg │ │ ├── linear-search.alg │ │ ├── longest-common-subsequence.alg │ │ ├── longest-palindromic-substring.alg │ │ ├── longest-word.alg │ │ ├── maximum-array-rotation.alg │ │ ├── maximum-subarray.alg │ │ ├── merge-sort.alg │ │ ├── minimum-spanning-tree.alg │ │ ├── palindromic-number.alg │ │ ├── prime-number.alg │ │ ├── quick-sort.alg │ │ ├── quine.alg │ │ ├── remove-all-whitespace.alg │ │ ├── reverse-string.alg │ │ ├── roman-numeral.alg │ │ ├── rot13.alg │ │ ├── selection-sort.alg │ │ ├── sleep-sort.alg │ │ ├── testinfo.yml │ │ └── transpose-matrix.alg │ ├── arkscript │ │ ├── README.md │ │ ├── baklava.ark │ │ ├── fizz-buzz.ark │ │ ├── hello-world.ark │ │ └── testinfo.yml │ └── awk │ │ ├── README.md │ │ ├── baklava.awk │ │ ├── base64-encode-decode.awk │ │ ├── binary-search.awk │ │ ├── bubble-sort.awk │ │ ├── capitalize.awk │ │ ├── convex-hull.awk │ │ ├── depth-first-search.awk │ │ ├── dijkstra.awk │ │ ├── duplicate-character-counter.awk │ │ ├── even-odd.awk │ │ ├── factorial.awk │ │ ├── fibonacci.awk │ │ ├── file-input-output.awk │ │ ├── fizz-buzz.awk │ │ ├── fraction-math.awk │ │ ├── hello-world.awk │ │ ├── insertion-sort.awk │ │ ├── job-sequencing.awk │ │ ├── josephus-problem.awk │ │ ├── linear-search.awk │ │ ├── longest-common-subsequence.awk │ │ ├── longest-palindromic-substring.awk │ │ ├── longest-word.awk │ │ ├── maximum-array-rotation.awk │ │ ├── maximum-subarray.awk │ │ ├── merge-sort.awk │ │ ├── minimum-spanning-tree.awk │ │ ├── palindromic-number.awk │ │ ├── prime-number.awk │ │ ├── quick-sort.awk │ │ ├── quine.awk │ │ ├── remove-all-whitespace.awk │ │ ├── reverse-string.awk │ │ ├── roman-numeral.awk │ │ ├── rot13.awk │ │ ├── selection-sort.awk │ │ ├── sleep-sort.awk │ │ ├── testinfo.yml │ │ └── transpose-matrix.awk ├── b │ ├── baik │ │ ├── README.md │ │ ├── baklava.ina │ │ ├── hello-world.ina │ │ └── testinfo.yml │ ├── ballerina │ │ ├── README.md │ │ ├── baklava.bal │ │ ├── fizz-buzz.bal │ │ ├── hello-world.bal │ │ └── testinfo.yml │ ├── bash │ │ ├── README.md │ │ ├── baklava.sh │ │ ├── base64-encode-decode.sh │ │ ├── bubble-sort.sh │ │ ├── capitalize.sh │ │ ├── even-odd.sh │ │ ├── factorial.sh │ │ ├── fibonacci.sh │ │ ├── file-input-output.sh │ │ ├── fizz-buzz.sh │ │ ├── hello-world.sh │ │ ├── prime-number.sh │ │ ├── quick-sort.sh │ │ ├── quine.sh │ │ ├── reverse-string.sh │ │ ├── selection-sort.sh │ │ └── testinfo.yml │ ├── batch │ │ ├── Baklava.cmd │ │ ├── FizzBuzz.cmd │ │ ├── HelloWorld.cmd │ │ ├── README.md │ │ └── testinfo.yml │ ├── beef │ │ ├── Baklava.bf │ │ ├── Base64EncodeDecode.bf │ │ ├── BinarySearch.bf │ │ ├── BubbleSort.bf │ │ ├── Capitalize.bf │ │ ├── ConvexHull.bf │ │ ├── DepthFirstSearch.bf │ │ ├── Dijkstra.bf │ │ ├── DuplicateCharacterCounter.bf │ │ ├── EvenOdd.bf │ │ ├── Factorial.bf │ │ ├── Fibonacci.bf │ │ ├── FileInputOutput.bf │ │ ├── FizzBuzz.bf │ │ ├── FractionMath.bf │ │ ├── HelloWorld.bf │ │ ├── InsertionSort.bf │ │ ├── JobSequencing.bf │ │ ├── JosephusProblem.bf │ │ ├── LinearSearch.bf │ │ ├── LongestCommonSubsequence.bf │ │ ├── LongestPalindromicSubstring.bf │ │ ├── LongestWord.bf │ │ ├── MaximumArrayRotation.bf │ │ ├── MaximumSubarray.bf │ │ ├── MergeSort.bf │ │ ├── MinimumSpanningTree.bf │ │ ├── PalindromicNumber.bf │ │ ├── PrimeNumber.bf │ │ ├── QuickSort.bf │ │ ├── Quine.bf │ │ ├── README.md │ │ ├── RemoveAllWhitespace.bf │ │ ├── ReverseString.bf │ │ ├── RomanNumeral.bf │ │ ├── Rot13.bf │ │ ├── SelectionSort.bf │ │ ├── SleepSort.bf │ │ ├── TransposeMatrix.bf │ │ └── testinfo.yml │ ├── befunge │ │ ├── README.md │ │ ├── baklava.be │ │ ├── fizz-buzz.be │ │ ├── hello-world.be │ │ ├── quine.be │ │ └── testinfo.yml │ ├── boo │ │ ├── README.md │ │ ├── baklava.boo │ │ ├── fibonacci.boo │ │ ├── fizz-buzz.boo │ │ ├── hello-world.boo │ │ └── testinfo.yml │ ├── bracmat │ │ ├── README.md │ │ ├── baklava.bra │ │ ├── hello-world.bra │ │ └── testinfo.yml │ └── brainfuck │ │ ├── README.md │ │ ├── baklava.bf │ │ ├── capitalize.bf │ │ ├── fizz-buzz.bf │ │ ├── hello-world.bf │ │ ├── longest-word.bf │ │ ├── remove-all-whitespace.bf │ │ ├── reverse-string.bf │ │ ├── rot13.bf │ │ └── testinfo.yml ├── c │ ├── c-plus-plus │ │ ├── README.md │ │ ├── baklava.cpp │ │ ├── binary-search.cpp │ │ ├── bubble-sort.cpp │ │ ├── capitalize.cpp │ │ ├── depth-first-search.cpp │ │ ├── dijkstra.cpp │ │ ├── duplicate-character-counter.cpp │ │ ├── even-odd.cpp │ │ ├── factorial.cpp │ │ ├── fibonacci.cpp │ │ ├── file-input-output.cpp │ │ ├── fizz-buzz.cpp │ │ ├── fraction-math.cpp │ │ ├── hello-world.cpp │ │ ├── insertion-sort.cpp │ │ ├── linear-search.cpp │ │ ├── longest-common-subsequence.cpp │ │ ├── longest-word.cpp │ │ ├── merge-sort.cpp │ │ ├── minimum-spanning-tree.cpp │ │ ├── palindromic-number.cpp │ │ ├── prime-number.cpp │ │ ├── quick-sort.cpp │ │ ├── remove-all-whitespace.cpp │ │ ├── reverse-string.cpp │ │ ├── roman-numeral.cpp │ │ ├── rot13.cpp │ │ ├── selection-sort.cpp │ │ └── testinfo.yml │ ├── c-sharp │ │ ├── Baklava.cs │ │ ├── BinarySearch.cs │ │ ├── BubbleSort.cs │ │ ├── Capitalize.cs │ │ ├── DuplicateCharacterCounter.cs │ │ ├── EvenOdd.cs │ │ ├── Factorial.cs │ │ ├── Fibonacci.cs │ │ ├── FileInputOutput.cs │ │ ├── FizzBuzz.cs │ │ ├── FractionMath.cs │ │ ├── HelloWorld.cs │ │ ├── InsertionSort.cs │ │ ├── JobSequencing.cs │ │ ├── JosephusProblem.cs │ │ ├── LinearSearch.cs │ │ ├── LongestCommonSubsequence.cs │ │ ├── LongestPalindromicSubstring.cs │ │ ├── LongestWord.cs │ │ ├── MergeSort.cs │ │ ├── PalindromicNumber.cs │ │ ├── PrimeNumber.cs │ │ ├── QuickSort.cs │ │ ├── Quine.cs │ │ ├── README.md │ │ ├── RemoveAllWhitespace.cs │ │ ├── ReverseString.cs │ │ ├── RomanNumeral.cs │ │ ├── Rot13.cs │ │ ├── SelectionSort.cs │ │ ├── SleepSort.cs │ │ └── testinfo.yml │ ├── c-star │ │ ├── README.md │ │ ├── baklava.cx │ │ ├── hello-world.cx │ │ └── testinfo.yml │ ├── c │ │ ├── README.md │ │ ├── baklava.c │ │ ├── binary-search.c │ │ ├── bubble-sort.c │ │ ├── capitalize.c │ │ ├── convex-hull.c │ │ ├── depth-first-search.c │ │ ├── dijkstra.c │ │ ├── duplicate-character-counter.c │ │ ├── even-odd.c │ │ ├── factorial.c │ │ ├── fibonacci.c │ │ ├── file-input-output.c │ │ ├── fizz-buzz.c │ │ ├── fraction-math.c │ │ ├── hello-world.c │ │ ├── insertion-sort.c │ │ ├── job-sequencing.c │ │ ├── josephus-problem.c │ │ ├── linear-search.c │ │ ├── longest-common-subsequence.c │ │ ├── longest-palindromic-substring.c │ │ ├── longest-word.c │ │ ├── maximum-array-rotation.c │ │ ├── maximum-subarray.c │ │ ├── merge-sort.c │ │ ├── minimum-spanning-tree.c │ │ ├── palindromic-number.c │ │ ├── prime-number.c │ │ ├── quick-sort.c │ │ ├── quine.c │ │ ├── remove-all-whitespace.c │ │ ├── reverse-string.c │ │ ├── roman-numeral.c │ │ ├── rot13.c │ │ ├── selection-sort.c │ │ ├── sleep-sort.c │ │ ├── testinfo.yml │ │ └── transpose-matrix.c │ ├── c2 │ │ ├── README.md │ │ ├── baklava.c2 │ │ ├── hello-world.c2 │ │ └── testinfo.yml │ ├── carp │ │ ├── README.md │ │ ├── baklava.carp │ │ ├── hello-world.carp │ │ └── testinfo.yml │ ├── chaiscript │ │ ├── README.md │ │ ├── baklava.chai │ │ ├── hello-world.chai │ │ └── testinfo.yml │ ├── chapel │ │ ├── Baklava.chpl │ │ ├── FizzBuzz.chpl │ │ ├── HelloWorld.chpl │ │ ├── README.md │ │ └── testinfo.yml │ ├── clojure │ │ ├── README.md │ │ ├── baklava.clj │ │ ├── bubble-sort.clj │ │ ├── capitalize.clj │ │ ├── fizz-buzz.clj │ │ ├── hello-world.clj │ │ ├── reverse-string.clj │ │ └── testinfo.yml │ ├── cobol │ │ ├── README.md │ │ ├── baklava.cbl │ │ ├── even-odd.cbl │ │ ├── factorial.cbl │ │ ├── fizz-buzz.cbl │ │ ├── hello-world.cbl │ │ ├── prime-number.cbl │ │ └── testinfo.yml │ ├── coffeescript │ │ ├── README.md │ │ ├── baklava.coffee │ │ ├── even-odd.coffee │ │ ├── factorial.coffee │ │ ├── fizz-buzz.coffee │ │ ├── hello-world.coffee │ │ ├── longest-word.coffee │ │ ├── quine.coffee │ │ └── testinfo.yml │ ├── commodore-basic │ │ ├── README.md │ │ ├── baklava.bas │ │ ├── base64-encode-decode.bas │ │ ├── binary-search.bas │ │ ├── bubble-sort.bas │ │ ├── capitalize.bas │ │ ├── convex-hull.bas │ │ ├── depth-first-search.bas │ │ ├── dijkstra.bas │ │ ├── duplicate-character-counter.bas │ │ ├── even-odd.bas │ │ ├── factorial.bas │ │ ├── fibonacci.bas │ │ ├── file-input-output.bas │ │ ├── fizz-buzz.bas │ │ ├── fraction-math.bas │ │ ├── hello-world.bas │ │ ├── insertion-sort.bas │ │ ├── job-sequencing.bas │ │ ├── josephus-problem.bas │ │ ├── linear-search.bas │ │ ├── longest-common-subsequence.bas │ │ ├── longest-palindromic-substring.bas │ │ ├── longest-word.bas │ │ ├── maximum-array-rotation.bas │ │ ├── maximum-subarray.bas │ │ ├── merge-sort.bas │ │ ├── minimum-spanning-tree.bas │ │ ├── palindromic-number.bas │ │ ├── prime-number.bas │ │ ├── quick-sort.bas │ │ ├── quine.bas │ │ ├── remove-all-whitespace.bas │ │ ├── reverse-string.bas │ │ ├── roman-numeral.bas │ │ ├── rot13.bas │ │ ├── selection-sort.bas │ │ ├── sleep-sort.bas │ │ ├── testinfo.yml │ │ └── transpose-matrix.bas │ ├── crystal │ │ ├── README.md │ │ ├── baklava.cr │ │ ├── factorial.cr │ │ ├── fizz-buzz.cr │ │ ├── hello-world.cr │ │ └── testinfo.yml │ └── cyclone │ │ ├── README.md │ │ ├── baklava.cyc │ │ ├── hello-world.cyc │ │ └── testinfo.yml ├── d │ ├── d │ │ ├── README.md │ │ ├── baklava.d │ │ ├── factorial.d │ │ ├── fizz_buzz.d │ │ ├── hello_world.d │ │ └── testinfo.yml │ ├── dale │ │ ├── README.md │ │ ├── baklava.dt │ │ ├── hello-world.dt │ │ └── testinfo.yml │ ├── dart │ │ ├── README.md │ │ ├── baklava.dart │ │ ├── bubble-sort.dart │ │ ├── capitalize.dart │ │ ├── even-odd.dart │ │ ├── fibonacci.dart │ │ ├── fizz-buzz.dart │ │ ├── hello-world.dart │ │ ├── quick-sort.dart │ │ ├── reverse-string.dart │ │ ├── roman-numeral.dart │ │ ├── rot13.dart │ │ ├── sleep-sort.dart │ │ └── testinfo.yml │ ├── dg │ │ ├── README.md │ │ ├── baklava.dg │ │ ├── file-input-output.dg │ │ ├── fizz-buzz.dg │ │ ├── hello-world.dg │ │ ├── quine.dg │ │ ├── reverse-string.dg │ │ └── testinfo.yml │ ├── discus │ │ ├── Baklava.ds │ │ ├── HelloWorld.ds │ │ ├── README.md │ │ └── testinfo.yml │ └── dusk │ │ ├── README.md │ │ ├── baklava.dusk │ │ ├── hello-world.dusk │ │ └── testinfo.yml ├── e │ ├── egison │ │ ├── README.md │ │ ├── baklava.egi │ │ ├── hello-world.egi │ │ └── testinfo.yml │ ├── eiffel │ │ ├── README.md │ │ ├── baklava.e │ │ ├── fizz_buzz.e │ │ ├── hello_world.e │ │ └── testinfo.yml │ ├── elena │ │ ├── README.md │ │ ├── baklava.l │ │ ├── hello-world.l │ │ └── testinfo.yml │ ├── elixir │ │ ├── README.md │ │ ├── baklava.ex │ │ ├── bubble-sort.ex │ │ ├── capitalize.ex │ │ ├── even-odd.ex │ │ ├── factorial.ex │ │ ├── fizz-buzz.ex │ │ ├── hello-world.ex │ │ ├── longest-common-subsequence.ex │ │ └── testinfo.yml │ ├── elvish │ │ ├── README.md │ │ ├── baklava.elv │ │ ├── capitalize.elv │ │ ├── even-odd.elv │ │ ├── factorial.elv │ │ ├── fibonacci.elv │ │ ├── file-input-output.elv │ │ ├── fizz-buzz.elv │ │ ├── hello-world.elv │ │ ├── linear-search.elv │ │ ├── palindromic-number.elv │ │ ├── prime-number.elv │ │ ├── remove-all-whitespace.elv │ │ ├── reverse-string.elv │ │ ├── rot13.elv │ │ └── testinfo.yml │ ├── emojicode │ │ ├── README.md │ │ ├── baklava.emojic │ │ ├── hello-world.emojic │ │ └── testinfo.yml │ ├── erlang │ │ ├── README.md │ │ ├── baklava.erl │ │ ├── bubble_sort.erl │ │ ├── factorial.erl │ │ ├── fizz_buzz.erl │ │ ├── hello_world.erl │ │ ├── reverse_string.erl │ │ └── testinfo.yml │ ├── eta │ │ ├── Baklava.hs │ │ ├── HelloWorld.hs │ │ ├── README.md │ │ └── testinfo.yml │ └── euphoria │ │ ├── README.md │ │ ├── baklava.eu │ │ ├── base64_encode_decode.eu │ │ ├── binary_search.eu │ │ ├── bubble_sort.eu │ │ ├── capitalize.eu │ │ ├── convex_hull.eu │ │ ├── depth_first_search.eu │ │ ├── dijkstra.eu │ │ ├── duplicate_character_counter.eu │ │ ├── even_odd.eu │ │ ├── factorial.eu │ │ ├── fibonacci.eu │ │ ├── file_input_output.eu │ │ ├── fizz_buzz.eu │ │ ├── fraction_math.eu │ │ ├── hello_world.eu │ │ ├── insertion_sort.eu │ │ ├── job_sequencing.eu │ │ ├── josephus_problem.eu │ │ ├── linear_search.eu │ │ ├── longest_common_subsequence.eu │ │ ├── longest_palindromic_substring.eu │ │ ├── longest_word.eu │ │ ├── maximum_array_rotation.eu │ │ ├── maximum_subarray.eu │ │ ├── merge_sort.eu │ │ ├── minimum_spanning_tree.eu │ │ ├── palindromic_number.eu │ │ ├── prime_number.eu │ │ ├── quick_sort.eu │ │ ├── quine.eu │ │ ├── remove_all_whitespace.eu │ │ ├── reverse_string.eu │ │ ├── roman_numeral.eu │ │ ├── rot13.eu │ │ ├── selection_sort.eu │ │ ├── sleep_sort.eu │ │ ├── testinfo.yml │ │ └── transpose_matrix.eu ├── f │ ├── f-sharp │ │ ├── Baklava.fs │ │ ├── HelloWorld.fs │ │ ├── README.md │ │ ├── RemoveAllWhitespace.fs │ │ └── testinfo.yml │ ├── f-star │ │ ├── Baklava.fst │ │ ├── HelloWorld.fst │ │ ├── README.md │ │ └── testinfo.yml │ ├── factor │ │ ├── README.md │ │ ├── baklava.factor │ │ ├── hello-world.factor │ │ └── testinfo.yml │ ├── felix │ │ ├── README.md │ │ ├── baklava.flx │ │ ├── hello-world.flx │ │ └── testinfo.yml │ ├── fennel │ │ ├── README.md │ │ ├── baklava.fnl │ │ ├── fizz-buzz.fnl │ │ ├── hello-world.fnl │ │ └── testinfo.yml │ ├── ferret │ │ ├── README.md │ │ ├── baklava.clj │ │ ├── hello-world.clj │ │ └── testinfo.yml │ ├── fetlang │ │ ├── README.md │ │ ├── baklava.fet │ │ ├── fizz-buzz.fet │ │ ├── hello-world.fet │ │ └── testinfo.yml │ ├── flix │ │ ├── README.md │ │ ├── baklava.flix │ │ ├── hello-world.flix │ │ └── testinfo.yml │ ├── formality │ │ ├── README.md │ │ ├── baklava.fm │ │ ├── hello-world.fm │ │ └── testinfo.yml │ ├── forth │ │ ├── README.md │ │ ├── baklava.fth │ │ ├── fizz-buzz.fth │ │ ├── hello-world.fth │ │ └── testinfo.yml │ ├── fortran │ │ ├── README.md │ │ ├── baklava.f95 │ │ ├── capitalize.f95 │ │ ├── even-odd.f95 │ │ ├── factorial.f95 │ │ ├── fibonacci.f95 │ │ ├── fizz-buzz.f95 │ │ ├── hello-world.f95 │ │ ├── prime-number.f95 │ │ ├── reverse-string.f95 │ │ └── testinfo.yml │ └── frege │ │ ├── Baklava.fr │ │ ├── HelloWorld.fr │ │ ├── README.md │ │ └── testinfo.yml ├── g │ ├── gerbil │ │ ├── README.md │ │ ├── baklava.ss │ │ ├── hello_world.ss │ │ └── testinfo.yml │ ├── gluon │ │ ├── README.md │ │ ├── baklava.glu │ │ ├── hello-world.glu │ │ └── testinfo.yml │ ├── gnu-make │ │ ├── README.md │ │ ├── baklava.mk │ │ ├── file-input-output.mk │ │ ├── fizz-buzz.mk │ │ ├── hello-world.mk │ │ ├── prime-number.mk │ │ ├── quine.mk │ │ └── testinfo.yml │ ├── go │ │ ├── README.md │ │ ├── baklava.go │ │ ├── base64-encode-decode.go │ │ ├── binary-search.go │ │ ├── bubble-sort.go │ │ ├── capitalize.go │ │ ├── duplicate-character-counter.go │ │ ├── even-odd.go │ │ ├── factorial.go │ │ ├── fibonacci.go │ │ ├── file-input-output.go │ │ ├── fizz-buzz.go │ │ ├── fraction-math.go │ │ ├── hello-world.go │ │ ├── insertion-sort.go │ │ ├── job-sequencing.go │ │ ├── josephus-problem.go │ │ ├── linear-search.go │ │ ├── longest-common-subsequence.go │ │ ├── longest-palindromic-substring.go │ │ ├── longest-word.go │ │ ├── maximum-array-rotation.go │ │ ├── merge-sort.go │ │ ├── palindromic-number.go │ │ ├── prime-number.go │ │ ├── quick-sort.go │ │ ├── quine.go │ │ ├── remove-all-whitespace.go │ │ ├── reverse-string.go │ │ ├── roman-numeral.go │ │ ├── rot13.go │ │ ├── selection-sort.go │ │ ├── sleep-sort.go │ │ ├── testinfo.yml │ │ └── transpose-matrix.go │ ├── goby │ │ ├── README.md │ │ ├── baklava.gb │ │ ├── hello-world.gb │ │ └── testinfo.yml │ ├── golo │ │ ├── README.md │ │ ├── baklava.golo │ │ ├── hello-world.golo │ │ └── testinfo.yml │ ├── gosu │ │ ├── README.md │ │ ├── baklava.gsp │ │ ├── hello-world.gsp │ │ └── testinfo.yml │ ├── grain │ │ ├── README.md │ │ ├── baklava.gr │ │ ├── hello-world.gr │ │ └── testinfo.yml │ ├── granule │ │ ├── README.md │ │ ├── baklava.gr │ │ ├── hello-world.gr │ │ └── testinfo.yml │ ├── gravity │ │ ├── README.md │ │ ├── baklava.gravity │ │ ├── fizz-buzz.gravity │ │ ├── hello-world.gravity │ │ └── testinfo.yml │ └── groovy │ │ ├── Baklava.groovy │ │ ├── Capitalize.groovy │ │ ├── EvenOdd.groovy │ │ ├── Factorial.groovy │ │ ├── Fibonacci.groovy │ │ ├── FizzBuzz.groovy │ │ ├── HelloWorld.groovy │ │ ├── MergeSort.groovy │ │ ├── README.md │ │ ├── ReverseString.groovy │ │ └── testinfo.yml ├── h │ ├── hack │ │ ├── README.md │ │ ├── baklava.hack │ │ ├── hello-world.hack │ │ └── testinfo.yml │ ├── haskell │ │ ├── README.md │ │ ├── baklava.hs │ │ ├── bubble-sort.hs │ │ ├── capitalize.hs │ │ ├── even-odd.hs │ │ ├── factorial.hs │ │ ├── fibonacci.hs │ │ ├── file-input-output.hs │ │ ├── fizz-buzz.hs │ │ ├── hello-world.hs │ │ ├── insertion-sort.hs │ │ ├── job-sequencing.hs │ │ ├── longest-common-subsequence.hs │ │ ├── merge-sort.hs │ │ ├── prime-number.hs │ │ ├── quick-sort.hs │ │ ├── quine.hs │ │ ├── reverse-string.hs │ │ ├── roman-numeral.hs │ │ ├── rot13.hs │ │ ├── selection-sort.hs │ │ └── testinfo.yml │ ├── haxe │ │ ├── Baklava.hx │ │ ├── FizzBuzz.hx │ │ ├── HelloWorld.hx │ │ ├── README.md │ │ └── testinfo.yml │ └── hobbes │ │ ├── README.md │ │ ├── baklava.hob │ │ ├── hello-world.hob │ │ └── testinfo.yml ├── i │ ├── idris │ │ ├── Baklava.idr │ │ ├── HelloWorld.idr │ │ ├── README.md │ │ └── testinfo.yml │ └── io │ │ ├── Baklava.io │ │ ├── FizzBuzz.io │ │ ├── HelloWorld.io │ │ ├── README.md │ │ └── testinfo.yml ├── j │ ├── janet │ │ ├── README.md │ │ ├── baklava.janet │ │ ├── fizz-buzz.janet │ │ ├── hello-world.janet │ │ └── testinfo.yml │ ├── java │ │ ├── Baklava.java │ │ ├── BinarySearch.java │ │ ├── BubbleSort.java │ │ ├── Capitalize.java │ │ ├── ConvexHull.java │ │ ├── DepthFirstSearch.java │ │ ├── DuplicateCharacterCounter.java │ │ ├── EvenOdd.java │ │ ├── Factorial.java │ │ ├── Fibonacci.java │ │ ├── FileInputOutput.java │ │ ├── FizzBuzz.java │ │ ├── HelloWorld.java │ │ ├── InsertionSort.java │ │ ├── JobSequencing.java │ │ ├── LinearSearch.java │ │ ├── LongestCommonSubsequence.java │ │ ├── LongestWord.java │ │ ├── MergeSort.java │ │ ├── PalindromicNumber.java │ │ ├── PrimeNumber.java │ │ ├── QuickSort.java │ │ ├── Quine.java │ │ ├── README.md │ │ ├── ReverseString.java │ │ ├── Rot13.java │ │ ├── SelectionSort.java │ │ └── testinfo.yml │ ├── javascript │ │ ├── README.md │ │ ├── baklava.js │ │ ├── binary-search.js │ │ ├── bubble-sort.js │ │ ├── capitalize.js │ │ ├── convex-hull.js │ │ ├── dijkstra.js │ │ ├── even-odd.js │ │ ├── factorial.js │ │ ├── fibonacci.js │ │ ├── file-input-output.js │ │ ├── fizz-buzz.js │ │ ├── hello-world.js │ │ ├── insertion-sort.js │ │ ├── job-sequencing.js │ │ ├── josephus-problem.js │ │ ├── linear-search.js │ │ ├── longest-common-subsequence.js │ │ ├── longest-palindromic-substring.js │ │ ├── longest-word.js │ │ ├── merge-sort.js │ │ ├── palindromic-number.js │ │ ├── prime-number.js │ │ ├── quick-sort.js │ │ ├── quine.js │ │ ├── remove-all-whitespace.js │ │ ├── reverse-string.js │ │ ├── roman-numeral.js │ │ ├── rot13.js │ │ ├── selection-sort.js │ │ ├── sleep-sort.js │ │ ├── testinfo.yml │ │ └── transpose-matrix.js │ └── julia │ │ ├── README.md │ │ ├── baklava.jl │ │ ├── bubble-sort.jl │ │ ├── capitalize.jl │ │ ├── even-odd.jl │ │ ├── factorial.jl │ │ ├── fibonacci.jl │ │ ├── file-input-output.jl │ │ ├── fizz-buzz.jl │ │ ├── hello-world.jl │ │ ├── longest-word.jl │ │ ├── palindromic-number.jl │ │ ├── prime-number.jl │ │ ├── remove-all-whitespace.jl │ │ ├── reverse-string.jl │ │ ├── selection-sort.jl │ │ └── testinfo.yml ├── k │ ├── kitten │ │ ├── README.md │ │ ├── baklava.ktn │ │ ├── hello-world.ktn │ │ └── testinfo.yml │ ├── koka │ │ ├── README.md │ │ ├── baklava.kk │ │ ├── hello_world.kk │ │ └── testinfo.yml │ └── kotlin │ │ ├── Baklava.kt │ │ ├── BinarySearch.kt │ │ ├── BubbleSort.kt │ │ ├── Capitalize.kt │ │ ├── EvenOdd.kt │ │ ├── Factorial.kt │ │ ├── Fibonacci.kt │ │ ├── FileInputOutput.kt │ │ ├── FizzBuzz.kt │ │ ├── HelloWorld.kt │ │ ├── JobSequencing.kt │ │ ├── LinearSearch.kt │ │ ├── LongestCommonSubsequence.kt │ │ ├── LongestWord.kt │ │ ├── MergeSort.kt │ │ ├── PalindromicNumber.kt │ │ ├── PrimeNumber.kt │ │ ├── QuickSort.kt │ │ ├── Quine.kt │ │ ├── README.md │ │ ├── ReverseString.kt │ │ ├── Rot13.kt │ │ └── testinfo.yml ├── l │ ├── latte │ │ ├── README.md │ │ ├── baklava.lt │ │ ├── hello-world.lt │ │ └── testinfo.yml │ ├── lily │ │ ├── README.md │ │ ├── baklava.lily │ │ ├── hello-world.lily │ │ └── testinfo.yml │ ├── lisp │ │ ├── README.md │ │ ├── baklava.lsp │ │ ├── capitalize.lsp │ │ ├── even-odd.lsp │ │ ├── factorial.lsp │ │ ├── fibonacci.lsp │ │ ├── fizz-buzz.lsp │ │ ├── hello-world.lsp │ │ ├── prime-number.lsp │ │ ├── quick-sort.lsp │ │ ├── reverse-string.lsp │ │ └── testinfo.yml │ ├── little │ │ ├── README.md │ │ ├── baklava.l │ │ ├── hello-world.l │ │ └── testinfo.yml │ ├── livescript │ │ ├── README.md │ │ ├── baklava.ls │ │ ├── hello-world.ls │ │ └── testinfo.yml │ ├── lobster │ │ ├── README.md │ │ ├── baklava.lobster │ │ ├── hello-world.lobster │ │ └── testinfo.yml │ ├── lolcode │ │ ├── README.md │ │ ├── baklava.lol │ │ ├── fizz-buzz.lol │ │ ├── hello-world.lol │ │ └── testinfo.yml │ ├── lua │ │ ├── README.md │ │ ├── baklava.lua │ │ ├── bubble-sort.lua │ │ ├── capitalize.lua │ │ ├── duplicate-character-counter.lua │ │ ├── even-odd.lua │ │ ├── factorial.lua │ │ ├── fibonacci.lua │ │ ├── file-input-output.lua │ │ ├── fizz-buzz.lua │ │ ├── hello-world.lua │ │ ├── longest-word.lua │ │ ├── prime-number.lua │ │ ├── reverse-string.lua │ │ ├── roman-numeral.lua │ │ ├── rot13.lua │ │ └── testinfo.yml │ └── lucee │ │ ├── README.md │ │ ├── baklava.cfm │ │ ├── hello-world.cfm │ │ └── testinfo.yml ├── m │ ├── malbolge │ │ ├── README.md │ │ ├── baklava.malbolge │ │ ├── hello-world.malbolge │ │ └── testinfo.yml │ ├── mathematica │ │ ├── README.md │ │ ├── baklava.nb │ │ ├── binary-search.nb │ │ ├── bubble-sort.nb │ │ ├── capitalize.nb │ │ ├── convex-hull.nb │ │ ├── depth-first-search.nb │ │ ├── dijkstra.nb │ │ ├── duplicate-character-counter.nb │ │ ├── even-odd.nb │ │ ├── factorial.nb │ │ ├── fibonacci.nb │ │ ├── file-input-output.nb │ │ ├── fizz-buzz.nb │ │ ├── fraction-math.nb │ │ ├── hello-world.nb │ │ ├── insertion-sort.nb │ │ ├── job-sequencing.nb │ │ ├── josephus.nb │ │ ├── linear-search.nb │ │ ├── longest-common-subsequence.nb │ │ ├── longest-palindromic-substring.nb │ │ ├── longest-word.nb │ │ ├── maximum-array-rotation.nb │ │ ├── maximum-subarray.nb │ │ ├── merge-sort.nb │ │ ├── minimum-spanning-tree.nb │ │ ├── palindromic-number.nb │ │ ├── prime.nb │ │ ├── quick-sort.nb │ │ ├── quine.nb │ │ ├── remove-all-whitespace.nb │ │ ├── reverse-string.nb │ │ ├── roman-numeral.nb │ │ ├── rot13.nb │ │ ├── selection-sort.nb │ │ ├── transpose-matrix.nb │ │ └── untestable.yml │ ├── mirth │ │ ├── README.md │ │ ├── baklava.mth │ │ ├── hello-world.mth │ │ └── testinfo.yml │ ├── modula2 │ │ ├── Baklava.mod │ │ ├── HelloWorld.mod │ │ ├── README.md │ │ └── testinfo.yml │ ├── mojiscript │ │ ├── README.md │ │ ├── baklava.mjs │ │ ├── hello-world.mjs │ │ └── testinfo.yml │ └── moonscript │ │ ├── README.md │ │ ├── baklava.moon │ │ ├── fibonacci.moon │ │ ├── fizz-buzz.moon │ │ ├── hello-world.moon │ │ ├── reverse-string.moon │ │ └── testinfo.yml ├── n │ ├── never │ │ ├── README.md │ │ ├── baklava.nev │ │ ├── hello-world.nev │ │ ├── reverse-string.nev │ │ └── testinfo.yml │ ├── nim │ │ ├── README.md │ │ ├── baklava.nim │ │ ├── fibonacci.nim │ │ ├── fizz_buzz.nim │ │ ├── hello_world.nim │ │ ├── reverse_string.nim │ │ └── testinfo.yml │ └── nit │ │ ├── README.md │ │ ├── baklava.nit │ │ ├── hello_world.nit │ │ └── testinfo.yml ├── o │ ├── objective-c │ │ ├── README.md │ │ ├── baklava.m │ │ ├── capitalize.m │ │ ├── even-odd.m │ │ ├── factorial.m │ │ ├── fibonacci.m │ │ ├── file-input-output.m │ │ ├── fizz-buzz.m │ │ ├── hello-world.m │ │ ├── merge-sort.m │ │ ├── quick-sort.m │ │ ├── reverse-string.m │ │ └── testinfo.yml │ ├── ocaml │ │ ├── README.md │ │ ├── baklava.ml │ │ ├── fizz-buzz.ml │ │ ├── hello-world.ml │ │ └── testinfo.yml │ ├── octave │ │ ├── README.md │ │ ├── baklava.m │ │ ├── bubble_sort.m │ │ ├── capitalize.m │ │ ├── even_odd.m │ │ ├── factorial.m │ │ ├── fibonacci.m │ │ ├── file_input_output.m │ │ ├── fizz_buzz.m │ │ ├── hello_world.m │ │ ├── insertion_sort.m │ │ ├── merge_sort.m │ │ ├── prime_number.m │ │ ├── reverse_string.m │ │ ├── selection_sort.m │ │ └── testinfo.yml │ ├── odin │ │ ├── README.md │ │ ├── baklava.odin │ │ ├── even-odd.odin │ │ ├── file-input-output.odin │ │ ├── fizz-buzz.odin │ │ ├── hello-world.odin │ │ ├── longest-word.odin │ │ ├── prime-number.odin │ │ ├── reverse-string.odin │ │ └── testinfo.yml │ ├── opa │ │ ├── README.md │ │ ├── baklava.opa │ │ ├── hello-world.opa │ │ └── testinfo.yml │ ├── orc │ │ ├── README.md │ │ ├── baklava.orc │ │ ├── hello-world.orc │ │ └── testinfo.yml │ └── owl-lisp │ │ ├── README.md │ │ ├── baklava.scm │ │ ├── hello-world.scm │ │ └── testinfo.yml ├── p │ ├── pascal │ │ ├── README.md │ │ ├── baklava.pas │ │ ├── capitalize.pas │ │ ├── even_odd.pas │ │ ├── factorial.pas │ │ ├── fibonacci.pas │ │ ├── fizz_buzz.pas │ │ ├── hello_world.pas │ │ ├── palindromic_number.pas │ │ ├── prime_number.pas │ │ ├── reverse_string.pas │ │ └── testinfo.yml │ ├── perl │ │ ├── README.md │ │ ├── baklava.pl │ │ ├── bubble-sort.pl │ │ ├── capitalize.pl │ │ ├── even-odd.pl │ │ ├── factorial.pl │ │ ├── fibonacci.pl │ │ ├── file-input-output.pl │ │ ├── fizz-buzz.pl │ │ ├── hello-world.pl │ │ ├── insertion-sort.pl │ │ ├── linear-search.pl │ │ ├── longest-word.pl │ │ ├── merge-sort.pl │ │ ├── palindromic-number.pl │ │ ├── prime-number.pl │ │ ├── quick-sort.pl │ │ ├── quine.pl │ │ ├── reverse-string.pl │ │ ├── rot13.pl │ │ ├── selection-sort.pl │ │ └── testinfo.yml │ ├── phix │ │ ├── README.md │ │ ├── baklava.exw │ │ ├── hello_world.exw │ │ └── testinfo.yml │ ├── php │ │ ├── README.md │ │ ├── baklava.php │ │ ├── base64-encode-decode.php │ │ ├── binary-search.php │ │ ├── bubble-sort.php │ │ ├── capitalize.php │ │ ├── convex-hull.php │ │ ├── depth-first-search.php │ │ ├── dijkstra.php │ │ ├── duplicate-character-counter.php │ │ ├── even-odd.php │ │ ├── factorial.php │ │ ├── fibonacci.php │ │ ├── file-input-output.php │ │ ├── fizz-buzz.php │ │ ├── fraction-math.php │ │ ├── hello-world.php │ │ ├── insertion-sort.php │ │ ├── job-sequencing.php │ │ ├── josephus-problem.php │ │ ├── linear-search.php │ │ ├── longest-common-subsequence.php │ │ ├── longest-palindromic-substring.php │ │ ├── longest-word.php │ │ ├── maximum-array-rotation.php │ │ ├── maximum-subarray.php │ │ ├── merge-sort.php │ │ ├── minimum-spanning-tree.php │ │ ├── palindromic-number.php │ │ ├── prime-number.php │ │ ├── quick-sort.php │ │ ├── quine.php │ │ ├── remove-all-whitespace.php │ │ ├── reverse-string.php │ │ ├── roman-numeral.php │ │ ├── rot13.php │ │ ├── selection-sort.php │ │ ├── sleep-sort.php │ │ ├── testinfo.yml │ │ └── transpose-matrix.php │ ├── picolisp │ │ ├── README.md │ │ ├── baklava.l │ │ ├── hello-world.l │ │ ├── reverse-string.l │ │ └── testinfo.yml │ ├── piet │ │ ├── README.md │ │ ├── baklava.png │ │ ├── hello-world.png │ │ └── testinfo.yml │ ├── pineapple │ │ ├── README.md │ │ ├── baklava.pine │ │ ├── fizz-buzz.pine │ │ ├── hello-world.pine │ │ └── testinfo.yml │ ├── pinecone │ │ ├── README.md │ │ ├── baklava.pn │ │ ├── fizz_buzz.pn │ │ ├── hello_world.pn │ │ └── testinfo.yml │ ├── pony │ │ ├── README.md │ │ ├── baklava.pony │ │ ├── fizz-buzz.pony │ │ ├── hello-world.pony │ │ └── testinfo.yml │ ├── powershell │ │ ├── Baklava.ps1 │ │ ├── Base64EncodeDecode.ps1 │ │ ├── Capitalize.ps1 │ │ ├── DuplicateCharacterCounter.ps1 │ │ ├── EvenOdd.ps1 │ │ ├── Factorial.ps1 │ │ ├── Fibonacci.ps1 │ │ ├── FileInputOutput.ps1 │ │ ├── FizzBuzz.ps1 │ │ ├── HelloWorld.ps1 │ │ ├── JosephusProblem.ps1 │ │ ├── LongestWord.ps1 │ │ ├── PalindromicNumber.ps1 │ │ ├── PrimeNumber.ps1 │ │ ├── Quine.ps1 │ │ ├── README.md │ │ ├── ReverseString.ps1 │ │ ├── Rot13.ps1 │ │ └── testinfo.yml │ ├── prolog │ │ ├── README.md │ │ ├── baklava.pl │ │ ├── fizz-buzz.pl │ │ ├── hello-world.pl │ │ └── testinfo.yml │ ├── purescript │ │ ├── README.md │ │ ├── baklava.purs │ │ ├── hello-world.purs │ │ └── testinfo.yml │ ├── pyret │ │ ├── README.md │ │ ├── baklava.arr │ │ ├── even-odd.arr │ │ ├── fizz-buzz.arr │ │ ├── hello-world.arr │ │ └── testinfo.yml │ └── python │ │ ├── README.md │ │ ├── baklava.py │ │ ├── base64_encode_decode.py │ │ ├── binary_search.py │ │ ├── bubble_sort.py │ │ ├── capitalize.py │ │ ├── convex_hull.py │ │ ├── depth_first_search.py │ │ ├── dijkstra.py │ │ ├── duplicate_character_counter.py │ │ ├── even_odd.py │ │ ├── factorial.py │ │ ├── fibonacci.py │ │ ├── file_input_output.py │ │ ├── fizz_buzz.py │ │ ├── fraction_math.py │ │ ├── hello_world.py │ │ ├── insertion_sort.py │ │ ├── job_sequencing.py │ │ ├── josephus_problem.py │ │ ├── linear_search.py │ │ ├── longest_common_subsequence.py │ │ ├── longest_palindromic_substring.py │ │ ├── longest_word.py │ │ ├── maximum_array_rotation.py │ │ ├── maximum_subarray.py │ │ ├── merge_sort.py │ │ ├── minimum_spanning_tree.py │ │ ├── palindromic_number.py │ │ ├── prime_number.py │ │ ├── quick_sort.py │ │ ├── quine.py │ │ ├── remove_all_whitespace.py │ │ ├── reverse_string.py │ │ ├── roman_numeral.py │ │ ├── rot13.py │ │ ├── selection_sort.py │ │ ├── sleep_sort.py │ │ ├── testinfo.yml │ │ └── transpose_matrix.py ├── q │ └── quackery │ │ ├── README.md │ │ ├── baklava.qky │ │ ├── hello-world.qky │ │ └── testinfo.yml ├── r │ ├── r │ │ ├── README.md │ │ ├── baklava.R │ │ ├── capitalize.R │ │ ├── even-odd.R │ │ ├── factorial.R │ │ ├── file-input-output.R │ │ ├── fizz-buzz.R │ │ ├── hello-world.R │ │ ├── longest-word.R │ │ ├── prime-number.R │ │ ├── reverse-string.R │ │ └── testinfo.yml │ ├── racket │ │ ├── README.md │ │ ├── baklava.rkt │ │ ├── fibonacci.rkt │ │ ├── fizz-buzz.rkt │ │ ├── hello-world.rkt │ │ └── testinfo.yml │ ├── raku │ │ ├── README.md │ │ ├── baklava.raku │ │ ├── fizz_buzz.raku │ │ ├── hello_world.raku │ │ └── testinfo.yml │ ├── red │ │ ├── README.md │ │ ├── baklava.red │ │ ├── fizz-buzz.red │ │ ├── hello-world.red │ │ └── testinfo.yml │ ├── rexx │ │ ├── README.md │ │ ├── baklava.rexx │ │ ├── even-odd.rexx │ │ ├── hello-world.rexx │ │ ├── prime-number.rexx │ │ ├── reverse-string.rexx │ │ └── testinfo.yml │ ├── ring │ │ ├── Baklava.ring │ │ ├── HelloWorld.ring │ │ ├── README.md │ │ └── testinfo.yml │ ├── ruby │ │ ├── README.md │ │ ├── baklava.rb │ │ ├── binary-search.rb │ │ ├── bubble-sort.rb │ │ ├── capitalize.rb │ │ ├── duplicate-character-counter.rb │ │ ├── even-odd.rb │ │ ├── factorial.rb │ │ ├── fibonacci.rb │ │ ├── file-input-output.rb │ │ ├── fizz-buzz.rb │ │ ├── hello-world.rb │ │ ├── josephus-problem.rb │ │ ├── longest-word.rb │ │ ├── palindromic-number.rb │ │ ├── prime-number.rb │ │ ├── quine.rb │ │ ├── remove-all-whitespace.rb │ │ ├── reverse-string.rb │ │ ├── roman-numeral.rb │ │ └── testinfo.yml │ └── rust │ │ ├── README.md │ │ ├── baklava.rs │ │ ├── base64-encode-decode.rs │ │ ├── binary-search.rs │ │ ├── bubble-sort.rs │ │ ├── capitalize.rs │ │ ├── convex-hull.rs │ │ ├── depth-first-search.rs │ │ ├── dijkstra.rs │ │ ├── duplicate-character-counter.rs │ │ ├── even-odd.rs │ │ ├── factorial.rs │ │ ├── fibonacci.rs │ │ ├── file-input-output.rs │ │ ├── fizz-buzz.rs │ │ ├── fraction-math.rs │ │ ├── hello-world.rs │ │ ├── insertion-sort.rs │ │ ├── job-sequencing.rs │ │ ├── josephus-problem.rs │ │ ├── linear-search.rs │ │ ├── longest-common-subsequence.rs │ │ ├── longest-palindromic-substring.rs │ │ ├── longest-word.rs │ │ ├── maximum-array-rotation.rs │ │ ├── maximum-subarray.rs │ │ ├── merge-sort.rs │ │ ├── minimum-spanning-tree.rs │ │ ├── palindromic-number.rs │ │ ├── prime-number.rs │ │ ├── quick-sort.rs │ │ ├── quine.rs │ │ ├── remove-all-whitespace.rs │ │ ├── reverse-string.rs │ │ ├── roman-numeral.rs │ │ ├── rot13.rs │ │ ├── selection-sort.rs │ │ ├── sleep-sort.rs │ │ ├── testinfo.yml │ │ └── transpose-matrix.rs ├── s │ ├── sather │ │ ├── README.md │ │ ├── baklava.sa │ │ ├── hello-world.sa │ │ └── testinfo.yml │ ├── scala │ │ ├── Baklava.scala │ │ ├── BubbleSort.scala │ │ ├── Capitalize.scala │ │ ├── EvenOdd.scala │ │ ├── Factorial.scala │ │ ├── Fibonacci.scala │ │ ├── FileInputOutput.scala │ │ ├── FizzBuzz.scala │ │ ├── HelloWorld.scala │ │ ├── QuickSort.scala │ │ ├── README.md │ │ ├── ReverseString.scala │ │ ├── SleepSort.scala │ │ └── testinfo.yml │ ├── scheme │ │ ├── README.md │ │ ├── baklava.scm │ │ ├── hello-world.scm │ │ ├── reverse-string.scm │ │ └── testinfo.yml │ ├── scilab │ │ ├── README.md │ │ ├── baklava.sce │ │ ├── hello-world.sce │ │ └── testinfo.yml │ ├── shen │ │ ├── README.md │ │ ├── baklava.shen │ │ ├── hello-world.shen │ │ └── testinfo.yml │ ├── smalltalk │ │ ├── README.md │ │ ├── baklava.st │ │ ├── fizz-buzz.st │ │ ├── hello-world.st │ │ └── testinfo.yml │ ├── solidity │ │ ├── Baklava.sol │ │ ├── HelloWorld.sol │ │ ├── README.md │ │ └── testinfo.yml │ ├── solisp │ │ ├── README.md │ │ ├── baklava.solisp │ │ ├── fizz-buzz.solisp │ │ ├── hello-world.solisp │ │ └── testinfo.yml │ ├── spry │ │ ├── README.md │ │ ├── baklava.sy │ │ ├── hello-world.sy │ │ └── testinfo.yml │ └── swift │ │ ├── README.md │ │ ├── baklava.swift │ │ ├── duplicate-character-counter.swift │ │ ├── even-odd.swift │ │ ├── fibonacci.swift │ │ ├── fizz-buzz.swift │ │ ├── fraction-math.swift │ │ ├── hello-world.swift │ │ ├── longest-word.swift │ │ ├── palindromic-number.swift │ │ ├── reverse-string.swift │ │ └── testinfo.yml ├── t │ ├── tcl │ │ ├── README.md │ │ ├── baklava.tcl │ │ ├── hello-world.tcl │ │ └── testinfo.yml │ ├── terra │ │ ├── README.md │ │ ├── baklava.t │ │ ├── hello-world.t │ │ └── testinfo.yml │ ├── tex │ │ ├── README.md │ │ ├── baklava.tex │ │ ├── fizz-buzz.tex │ │ ├── hello-world.tex │ │ └── testinfo.yml │ ├── ti-basic │ │ ├── README.md │ │ ├── baklava.8xp.txt │ │ ├── capitalize.8xp.txt │ │ ├── duplicate-character-counter.8xp.txt │ │ ├── even-odd.8xp.txt │ │ ├── factorial.8xp.txt │ │ ├── fibonacci.8xp.txt │ │ ├── fizz-buzz.8xp.txt │ │ ├── hello-world.8xp.txt │ │ ├── josephus-problem.8xp.txt │ │ ├── palindromic-number.8xp.txt │ │ ├── prime-number.8xp.txt │ │ ├── reverse-string.8xp.txt │ │ ├── rot13.8xp.txt │ │ └── testinfo.yml │ └── typescript │ │ ├── README.md │ │ ├── baklava.ts │ │ ├── binary-search.ts │ │ ├── bubble-sort.ts │ │ ├── capitalize.ts │ │ ├── duplicate-character-counter.ts │ │ ├── even-odd.ts │ │ ├── factorial.ts │ │ ├── fibonacci.ts │ │ ├── file-input-output.ts │ │ ├── fizz-buzz.ts │ │ ├── hello-world.ts │ │ ├── insertion-sort.ts │ │ ├── linear-search.ts │ │ ├── longest-word.ts │ │ ├── merge-sort.ts │ │ ├── palindromic-number.ts │ │ ├── prime-number.ts │ │ ├── quick-sort.ts │ │ ├── reverse-string.ts │ │ ├── roman-numeral.ts │ │ ├── rot13.ts │ │ ├── selection-sort.ts │ │ ├── testinfo.yml │ │ └── transpose-matrix.ts ├── u │ └── unicat │ │ ├── README.md │ │ ├── baklava.cat │ │ ├── fizz-buzz.cat │ │ ├── hello-world.cat │ │ ├── reverse-string.cat │ │ └── testinfo.yml ├── v │ ├── v │ │ ├── README.md │ │ ├── baklava.v │ │ ├── even-odd.v │ │ ├── factorial.v │ │ ├── fizz-buzz.v │ │ ├── hello-world.v │ │ ├── reverse-string.v │ │ └── testinfo.yml │ ├── verilog │ │ ├── README.md │ │ ├── baklava.v │ │ ├── hello-world.v │ │ └── testinfo.yml │ ├── verve │ │ ├── README.md │ │ ├── baklava.vrv │ │ ├── fizz-buzz.vrv │ │ ├── hello-world.vrv │ │ └── testinfo.yml │ ├── vimscript │ │ ├── README.md │ │ ├── baklava.vim │ │ ├── fizz-buzz.vim │ │ ├── hello-world.vim │ │ ├── reverse-string.vim │ │ └── testinfo.yml │ └── visual-basic │ │ ├── README.md │ │ ├── baklava.vb │ │ ├── bubble-sort.vb │ │ ├── fizz-buzz.vb │ │ ├── hello-world.vb │ │ ├── longest-word.vb │ │ ├── reverse-string.vb │ │ └── testinfo.yml ├── w │ ├── whitespace │ │ ├── README.md │ │ ├── baklava.ws │ │ ├── fizz-buzz.ws │ │ ├── hello-world.ws │ │ ├── quine.ws │ │ └── testinfo.yml │ ├── wren │ │ ├── README.md │ │ ├── baklava.wren │ │ ├── duplicate-character-counter.wren │ │ ├── even-odd.wren │ │ ├── factorial.wren │ │ ├── file-input-output.wren │ │ ├── fizz-buzz.wren │ │ ├── hello-world.wren │ │ ├── palindromic-number.wren │ │ ├── prime-number.wren │ │ ├── remove-all-whitespace.wren │ │ ├── reverse-string.wren │ │ └── testinfo.yml │ ├── wu │ │ ├── README.md │ │ ├── baklava.wu │ │ ├── hello-world.wu │ │ └── testinfo.yml │ └── wyvern │ │ ├── README.md │ │ ├── baklava.wyv │ │ ├── hello-world.wyv │ │ └── testinfo.yml ├── x │ └── x86-64 │ │ ├── README.md │ │ ├── baklava.asm │ │ ├── even-odd.asm │ │ ├── fizz-buzz.asm │ │ ├── hello-world.asm │ │ ├── reverse-string.asm │ │ └── testinfo.yml ├── y │ └── yoix │ │ ├── README.md │ │ ├── baklava.yx │ │ ├── hello_world.yx │ │ └── testinfo.yml └── z │ └── zig │ ├── README.md │ ├── baklava.zig │ ├── base64-encode-decode.zig │ ├── fizz-buzz.zig │ ├── hello-world.zig │ └── testinfo.yml ├── needs-attention └── archive │ └── x │ └── x86-64 │ └── sleep-sort.asm ├── poetry.lock ├── pyproject.toml ├── repo-config.yml ├── scripts ├── build_codeql_language.py ├── get_codeql_languages.py └── run_tests.py └── test └── __init__.py /.gitignore: -------------------------------------------------------------------------------- 1 | .idea/ 2 | *.class 3 | *.java~ 4 | .vscode/ 5 | .history/ 6 | *.swp 7 | .pytest_cache/ 8 | __pycache__/ 9 | .scratch 10 | *.beam 11 | .DS_Store 12 | venv/ 13 | generated/ 14 | 15 | # Object directory 16 | obj/ 17 | 18 | # Project files 19 | *.fsproj 20 | .*project 21 | .*proj 22 | .*targets 23 | 24 | # Node.js 25 | node_modules/ 26 | package.json 27 | package-lock.json 28 | 29 | # F# 30 | Program.fs 31 | 32 | # scala 33 | .metals 34 | .scala-build 35 | -------------------------------------------------------------------------------- /archive/a/ada/hello-world.adb: -------------------------------------------------------------------------------- 1 | with Text_IO; 2 | procedure Hello_World is 3 | 4 | begin 5 | Text_IO.Put_Line("Hello, World!"); 6 | end Hello_World; 7 | -------------------------------------------------------------------------------- /archive/a/ada/testinfo.yml: -------------------------------------------------------------------------------- 1 | folder: 2 | extension: ".adb" 3 | naming: "hyphen" 4 | 5 | container: 6 | image: "tomekw/ada-gnat" 7 | tag: "12.2.0" 8 | build: "gnatmake {{ source.name }}{{ source.extension }}" 9 | cmd: "./{{ source.name }}" 10 | -------------------------------------------------------------------------------- /archive/a/agda/HelloWorld.agda: -------------------------------------------------------------------------------- 1 | module HelloWorld where 2 | 3 | open import Agda.Builtin.IO using (IO) 4 | open import Agda.Builtin.Unit using (⊤) 5 | open import Agda.Builtin.String using (String) 6 | 7 | postulate putStrLn : String → IO ⊤ 8 | {-# FOREIGN GHC import qualified Data.Text as T #-} 9 | {-# COMPILE GHC putStrLn = putStrLn . T.unpack #-} 10 | 11 | main : IO ⊤ 12 | main = putStrLn "Hello, World!" 13 | -------------------------------------------------------------------------------- /archive/a/agda/testinfo.yml: -------------------------------------------------------------------------------- 1 | folder: 2 | extension: ".agda" 3 | naming: "pascal" 4 | 5 | container: 6 | image: "zyasserd/agda" 7 | tag: "2.6.4.3-compiled-haskell" 8 | build: "agda --compile {{ source.name }}{{ source.extension }}" 9 | cmd: "./{{ source.name }}" 10 | -------------------------------------------------------------------------------- /archive/a/algol68/baklava.alg: -------------------------------------------------------------------------------- 1 | FOR n FROM -10 TO 10 2 | DO 3 | INT num spaces := ABS n; 4 | printf(($gl$, " " * num spaces + "*" * (21 - 2*num spaces))) 5 | OD 6 | -------------------------------------------------------------------------------- /archive/a/algol68/capitalize.alg: -------------------------------------------------------------------------------- 1 | PROC usage = VOID: printf(($gl$, "Usage: please provide a string")); 2 | 3 | PROC capitalize = (STRING s) STRING: 4 | ( 5 | # Capitalize first letter if lowercase # 6 | toupper(s[1]) + s[2:] 7 | ); 8 | 9 | # Get 1st command-line argument. Exit if empty # 10 | STRING s := argv(4); 11 | IF UPB s = 0 12 | THEN 13 | usage; 14 | stop 15 | FI; 16 | 17 | # Capitalize string and show it # 18 | s := capitalize(s); 19 | printf(($gl$, s)) 20 | -------------------------------------------------------------------------------- /archive/a/algol68/fizz-buzz.alg: -------------------------------------------------------------------------------- 1 | FOR n FROM 1 TO 100 2 | DO 3 | STRING s := (n MOD 3 = 0 | "Fizz" | ""); 4 | s +:= (n MOD 5 = 0 | "Buzz" | ""); 5 | printf(($gl$, (s /= "" | s | whole(n, 0)))) 6 | OD 7 | -------------------------------------------------------------------------------- /archive/a/algol68/hello-world.alg: -------------------------------------------------------------------------------- 1 | printf(($gl$, "Hello, World!")) 2 | -------------------------------------------------------------------------------- /archive/a/algol68/quine.alg: -------------------------------------------------------------------------------- 1 | STRINGs:="STRINGs:="";printf(($gl$,s[:10]*2+s[10:]*2))";printf(($gl$,s[:10]*2+s[10:]*2)) 2 | -------------------------------------------------------------------------------- /archive/a/algol68/reverse-string.alg: -------------------------------------------------------------------------------- 1 | PROC reverse string = (STRING s) STRING: 2 | ( 3 | STRING t; 4 | FOR n FROM UPB s DOWNTO 1 5 | DO 6 | t +:= s[n] 7 | OD; 8 | 9 | t 10 | ); 11 | 12 | # Get 1st command-line argument # 13 | STRING s := argv(4); 14 | 15 | # Reverse string and show result # 16 | s := reverse string(s); 17 | printf(($gl$, s)) 18 | -------------------------------------------------------------------------------- /archive/a/algol68/testinfo.yml: -------------------------------------------------------------------------------- 1 | folder: 2 | extension: ".alg" 3 | naming: "hyphen" 4 | 5 | container: 6 | image: "rzuckerm/algol68" 7 | tag: "2.8.4-1" 8 | cmd: "a68g {{ source.name }}{{ source.extension }} -" 9 | -------------------------------------------------------------------------------- /archive/a/arkscript/fizz-buzz.ark: -------------------------------------------------------------------------------- 1 | (mut i 1) 2 | ( 3 | while (<= i 100) { 4 | ( 5 | if (= 0 (mod i 15)) (print "FizzBuzz") ( 6 | if (= 0 (mod i 5)) (print "Buzz") 7 | (if (= 0 (mod i 3)) (print "Fizz") 8 | (print i)))) 9 | (set i (+ i 1)) 10 | } 11 | ) 12 | -------------------------------------------------------------------------------- /archive/a/arkscript/hello-world.ark: -------------------------------------------------------------------------------- 1 | (print "Hello, World!") -------------------------------------------------------------------------------- /archive/a/arkscript/testinfo.yml: -------------------------------------------------------------------------------- 1 | folder: 2 | extension: ".ark" 3 | naming: "hyphen" 4 | 5 | container: 6 | image: "arkscript/stable" 7 | tag: "sha-962de17" 8 | cmd: "arkscript {{ source.name }}{{ source.extension }}" 9 | -------------------------------------------------------------------------------- /archive/a/awk/baklava.awk: -------------------------------------------------------------------------------- 1 | function repeat_string(n, s, result, k) { 2 | result = "" 3 | for (k = 1; k <= n; k++) { 4 | result = result s 5 | } 6 | 7 | return result 8 | } 9 | 10 | BEGIN { 11 | for (i = -10; i <= 10; i++) { 12 | num_spaces = (i >= 0) ? i : -i 13 | num_stars = 21 - 2 * num_spaces 14 | print repeat_string(num_spaces, " ") repeat_string(num_stars, "*") 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /archive/a/awk/capitalize.awk: -------------------------------------------------------------------------------- 1 | function usage() { 2 | print "Usage: please provide a string" 3 | exit(1) 4 | } 5 | 6 | function capitalize(s) { 7 | return toupper(substr(s, 1, 1)) substr(s, 2) 8 | } 9 | 10 | BEGIN { 11 | if (ARGC < 2 || !ARGV[1]) { 12 | usage() 13 | } 14 | 15 | print capitalize(ARGV[1]) 16 | } 17 | -------------------------------------------------------------------------------- /archive/a/awk/fizz-buzz.awk: -------------------------------------------------------------------------------- 1 | BEGIN { 2 | for (i = 1; i <= 100; i++) { 3 | result = "" 4 | if (i % 3 == 0) { 5 | result = result "Fizz" 6 | } 7 | 8 | if (i % 5 == 0) { 9 | result = result "Buzz" 10 | } 11 | 12 | if (!result) { 13 | result = result sprintf("%d", i) 14 | } 15 | 16 | print result 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /archive/a/awk/hello-world.awk: -------------------------------------------------------------------------------- 1 | BEGIN { 2 | print "Hello, World!" 3 | } 4 | -------------------------------------------------------------------------------- /archive/a/awk/quine.awk: -------------------------------------------------------------------------------- 1 | BEGIN{s="BEGIN{s=%c%s%c;printf(s,34,s,34,10)}%c";printf(s,34,s,34,10)} 2 | -------------------------------------------------------------------------------- /archive/a/awk/remove-all-whitespace.awk: -------------------------------------------------------------------------------- 1 | function usage() { 2 | print "Usage: please provide a string" 3 | exit(1) 4 | } 5 | 6 | function remove_whitespace(s, arr, result) { 7 | split(s, arr, /\s+/) 8 | result = "" 9 | for (k in arr) { 10 | result = result arr[k] 11 | } 12 | 13 | return result 14 | } 15 | 16 | BEGIN { 17 | if (ARGC < 2 || !ARGV[1]) { 18 | usage() 19 | } 20 | 21 | print remove_whitespace(ARGV[1]) 22 | } 23 | -------------------------------------------------------------------------------- /archive/a/awk/reverse-string.awk: -------------------------------------------------------------------------------- 1 | function reverse_string(s, result, i) { 2 | result = "" 3 | for (i = length(s); i > 0; i--) { 4 | result = result substr(s, i, 1) 5 | } 6 | 7 | return result 8 | } 9 | 10 | BEGIN { 11 | if (ARGC > 1) { 12 | print reverse_string(ARGV[1]) 13 | } 14 | } 15 | -------------------------------------------------------------------------------- /archive/a/awk/testinfo.yml: -------------------------------------------------------------------------------- 1 | folder: 2 | extension: ".awk" 3 | naming: "hyphen" 4 | 5 | container: 6 | image: "cicirello/gnu-on-alpine" 7 | tag: "3.21.0" 8 | cmd: "gawk -f {{ source.name }}{{ source.extension }} --" 9 | -------------------------------------------------------------------------------- /archive/b/baik/hello-world.ina: -------------------------------------------------------------------------------- 1 | tulis "Hello, World!\n" 2 | -------------------------------------------------------------------------------- /archive/b/baik/testinfo.yml: -------------------------------------------------------------------------------- 1 | folder: 2 | extension: ".ina" 3 | naming: "hyphen" 4 | 5 | container: 6 | image: "rzuckerm/baik" 7 | tag: "9.5.2-1" 8 | cmd: "baik {{ source.name }}{{ source.extension }}" 9 | -------------------------------------------------------------------------------- /archive/b/ballerina/baklava.bal: -------------------------------------------------------------------------------- 1 | import ballerina/io; 2 | 3 | public function main(string... args) { 4 | foreach int n in int:range(-10, 11, 1) { 5 | int numSpaces = int:abs(n); 6 | int numStars = 21 - 2 * numSpaces; 7 | io:println("".padEnd(numSpaces, " ") + "".padEnd(numStars, "*")); 8 | } 9 | } 10 | -------------------------------------------------------------------------------- /archive/b/ballerina/fizz-buzz.bal: -------------------------------------------------------------------------------- 1 | import ballerina/io; 2 | 3 | public function main() { 4 | foreach int i in int:range(1, 101, 1) { 5 | if i % 15 == 0 { 6 | io:println("FizzBuzz"); 7 | } else if i % 5 == 0 { 8 | io:println("Buzz"); 9 | } else if i % 3 == 0 { 10 | io:println("Fizz"); 11 | } else { 12 | io:println(i); 13 | } 14 | } 15 | } 16 | -------------------------------------------------------------------------------- /archive/b/ballerina/hello-world.bal: -------------------------------------------------------------------------------- 1 | import ballerina/io; 2 | public function main(string... args) { 3 | io:println("Hello, World!"); 4 | } 5 | -------------------------------------------------------------------------------- /archive/b/ballerina/testinfo.yml: -------------------------------------------------------------------------------- 1 | folder: 2 | extension: ".bal" 3 | naming: "hyphen" 4 | 5 | container: 6 | image: "ballerina/ballerina" 7 | tag: "2201.6.1" 8 | build: "bal build {{ source.name }}{{ source.extension }}" 9 | cmd: "bal run {{ source.name }}.jar" 10 | -------------------------------------------------------------------------------- /archive/b/bash/baklava.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | for i in {0..9}; do 4 | printf " %.0s" $(seq 1 $(( 10 - $i ))) 5 | printf "*%.0s" $(seq 1 $(( $i * 2 + 1 ))) 6 | echo 7 | done 8 | 9 | printf "*%.0s" {1..21} 10 | echo 11 | 12 | for i in {9..0}; do 13 | printf " %.0s" $(seq 1 $(( 10 - $i ))) 14 | printf "*%.0s" $(seq 1 $(( $i * 2 + 1 ))) 15 | echo 16 | done 17 | -------------------------------------------------------------------------------- /archive/b/bash/capitalize.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | if [ -z "$1" ]; then 4 | echo "Usage: please provide a string" 5 | exit 1 6 | fi 7 | 8 | echo ${1^} 9 | -------------------------------------------------------------------------------- /archive/b/bash/even-odd.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | count=$1 3 | 4 | [[ $count =~ ^[-+]?[0-9]+$ ]] || { echo "Usage: please input a number"; exit 1; } 5 | 6 | rem=$(( $count % 2 )) 7 | 8 | if [ $rem -eq 0 ] 9 | then 10 | echo "Even" 11 | else 12 | echo "Odd" 13 | fi 14 | -------------------------------------------------------------------------------- /archive/b/bash/factorial.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | number=$1 4 | 5 | if [[ -z "$number" ]] 6 | then 7 | echo "Usage: please input a non-negative integer" 8 | exit 1 9 | fi 10 | 11 | if ! [[ "$number" =~ ^[0-9]+$ ]] 12 | then 13 | echo "Usage: please input a non-negative integer" 14 | exit 1 15 | fi 16 | 17 | value=1 18 | 19 | while [ $number -gt 1 ] 20 | do 21 | 22 | value=$((value * number)) 23 | 24 | number=$((number - 1)) 25 | 26 | done 27 | 28 | echo $value 29 | -------------------------------------------------------------------------------- /archive/b/bash/fibonacci.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | count=$1 4 | 5 | [[ $count =~ ^[0-9]+$ ]] || { echo "Usage: please input the count of fibonacci numbers to output"; exit 1; } 6 | 7 | n=1 8 | n_minus_1=1 9 | [[ $count < 1 ]] && exit 0 10 | 11 | echo "1: 1" 12 | for i in $(seq 2 $count); do 13 | echo "$i: $n" 14 | tmp=$n 15 | n=$[$n+$n_minus_1] 16 | n_minus_1=$tmp 17 | done 18 | -------------------------------------------------------------------------------- /archive/b/bash/file-input-output.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | read_file () { 4 | cat output.txt 5 | } 6 | 7 | write_file () { 8 | echo -e "$1" > output.txt 9 | } 10 | 11 | write_file "File text line 1\nFile text line 2\nFile text line 3" 12 | read_file 13 | -------------------------------------------------------------------------------- /archive/b/bash/fizz-buzz.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | for i in {1..100}; do 4 | if (( $i % 15 == 0 )); then 5 | echo "FizzBuzz" 6 | elif (( $i % 5 == 0 )); then 7 | echo "Buzz" 8 | elif (( $i % 3 == 0 )); then 9 | echo "Fizz" 10 | else 11 | echo $i 12 | fi 13 | done 14 | -------------------------------------------------------------------------------- /archive/b/bash/hello-world.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | echo Hello, World! 4 | -------------------------------------------------------------------------------- /archive/b/bash/quine.sh: -------------------------------------------------------------------------------- 1 | echo $BASH_COMMAND 2 | -------------------------------------------------------------------------------- /archive/b/bash/reverse-string.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | string=$1 4 | strLength=${#string} 5 | 6 | for ((i=$strLength-1;i>-1;i--)); 7 | do 8 | reverseStr+=${string:i:1} 9 | done 10 | echo $reverseStr -------------------------------------------------------------------------------- /archive/b/bash/testinfo.yml: -------------------------------------------------------------------------------- 1 | folder: 2 | extension: ".sh" 3 | naming: "hyphen" 4 | 5 | container: 6 | image: "bash" 7 | tag: "5" 8 | cmd: "bash {{ source.name }}{{ source.extension }}" 9 | -------------------------------------------------------------------------------- /archive/b/batch/FizzBuzz.cmd: -------------------------------------------------------------------------------- 1 | @ECHO OFF 2 | SETLOCAL ENABLEDELAYEDEXPANSION 3 | 4 | for /l %%i in (1,1,100) do ( 5 | set /A "m3=%%i %% 3" 6 | set /A "m5=%%i %% 5" 7 | set /A "m15=%%i %% 15" 8 | 9 | if !m15! equ 0 ( 10 | echo FizzBuzz 11 | ) else if !m3! equ 0 ( 12 | echo Fizz 13 | ) else if !m5! equ 0 ( 14 | echo Buzz 15 | ) else ( 16 | echo %%i 17 | ) 18 | ) 19 | 20 | ENDLOCAL 21 | -------------------------------------------------------------------------------- /archive/b/batch/HelloWorld.cmd: -------------------------------------------------------------------------------- 1 | @echo off 2 | echo Hello, World! 3 | -------------------------------------------------------------------------------- /archive/b/batch/testinfo.yml: -------------------------------------------------------------------------------- 1 | folder: 2 | extension: ".cmd" 3 | naming: "pascal" 4 | 5 | container: 6 | image: "rzuckerm/batch" 7 | tag: "9.0-20250112-2" 8 | cmd: "wine {{ source.name }}{{ source.extension }}" 9 | -------------------------------------------------------------------------------- /archive/b/beef/HelloWorld.bf: -------------------------------------------------------------------------------- 1 | using System; 2 | 3 | namespace HelloWorld; 4 | 5 | class Program 6 | { 7 | public static int Main(String[] args) 8 | { 9 | Console.WriteLine("Hello, World!"); 10 | return 0; 11 | } 12 | } 13 | -------------------------------------------------------------------------------- /archive/b/beef/testinfo.yml: -------------------------------------------------------------------------------- 1 | folder: 2 | extension: ".bf" 3 | naming: "pascal" 4 | 5 | container: 6 | image: "rzuckerm/beef" 7 | tag: "0.43.5a7-9" 8 | build: | 9 | sh -c "BeefBuild -new -workspace={{ source.name }} && \ 10 | cp {{ source.name }}{{ source.extension }} {{ source.name }}/src/Program.bf && \ 11 | beef_build_workaround -- -workspace={{ source.name }} -config=Release" 12 | cmd: "{{ source.name }}/build/Release_Linux64/{{ source.name }}/{{ source.name }}" 13 | -------------------------------------------------------------------------------- /archive/b/befunge/baklava.be: -------------------------------------------------------------------------------- 1 | 56+0 v > 84*, v 2 | > > : 55+\-: | :-1 < 3 | v < < v *2 :$< 4 | : + - > 1+ > 67*, v 5 | 1 1 1 | :-1 < 6 | + \ \ > $\ v 7 | ^_@^_^# `0 :-1 ,*25 < 8 | 9 | -------------------------------------------------------------------------------- /archive/b/befunge/fizz-buzz.be: -------------------------------------------------------------------------------- 1 | 1 > :3% v 2 | v \0 _ "zziF",,,,v 3 | v \1 < 4 | > :5% v 5 | v _v#\ _ "zzuB",,,,v 6 | v >:. v $\ < 7 | v < @ 8 | > :25* ::, *1-` | 9 | ^ +1 < 10 | 11 | -------------------------------------------------------------------------------- /archive/b/befunge/hello-world.be: -------------------------------------------------------------------------------- 1 | 0"!dlroW ,olleH"v 2 | > , v 3 | | : < 4 | @ 5 | -------------------------------------------------------------------------------- /archive/b/befunge/quine.be: -------------------------------------------------------------------------------- 1 | :0g,:66+`#@_1+ -------------------------------------------------------------------------------- /archive/b/befunge/testinfo.yml: -------------------------------------------------------------------------------- 1 | folder: 2 | extension: ".be" 3 | naming: "hyphen" 4 | 5 | container: 6 | image: "esolang/befunge98" 7 | tag: "latest" 8 | cmd: "befunge98 {{ source.name }}{{ source.extension }}" 9 | -------------------------------------------------------------------------------- /archive/b/boo/baklava.boo: -------------------------------------------------------------------------------- 1 | for n in range(-10, 11): 2 | numSpaces = System.Math.Abs(n) 3 | numStars = 21 - 2 * numSpaces 4 | print " " * numSpaces + "*" * numStars 5 | -------------------------------------------------------------------------------- /archive/b/boo/fizz-buzz.boo: -------------------------------------------------------------------------------- 1 | for n in range(1, 101): 2 | s = "" 3 | s += "Fizz" if n % 3 == 0 4 | s += "Buzz" if n % 5 == 0 5 | s += "$(n)" if not s 6 | print s 7 | -------------------------------------------------------------------------------- /archive/b/boo/hello-world.boo: -------------------------------------------------------------------------------- 1 | print "Hello, World!" 2 | -------------------------------------------------------------------------------- /archive/b/boo/testinfo.yml: -------------------------------------------------------------------------------- 1 | folder: 2 | extension: ".boo" 3 | naming: "hyphen" 4 | 5 | container: 6 | image: "rzuckerm/boo" 7 | tag: "0.9.7.0-1" 8 | cmd: | 9 | booi "{{ source.name }}{{ source.extension }}" 10 | -------------------------------------------------------------------------------- /archive/b/bracmat/hello-world.bra: -------------------------------------------------------------------------------- 1 | put$"Hello, World!" -------------------------------------------------------------------------------- /archive/b/bracmat/testinfo.yml: -------------------------------------------------------------------------------- 1 | folder: 2 | extension: ".bra" 3 | naming: "hyphen" 4 | 5 | container: 6 | image: "rzuckerm/bracmat" 7 | tag: "6.26.2-2" 8 | cmd: | 9 | bracmat 'get$"{{ source.name }}{{ source.extension }}"' 10 | -------------------------------------------------------------------------------- /archive/b/brainfuck/hello-world.bf: -------------------------------------------------------------------------------- 1 | >++++++++[<+++++++++>-]<.>++++[<+++++++>-]<+.+++++++..+++.>>++++++[<+++++++>-]<+ 2 | +.------------.>++++++[<+++++++++>-]<+.<.+++.------.--------.>>>++++[<++++++++>- 3 | ]<+. 4 | -------------------------------------------------------------------------------- /archive/b/brainfuck/reverse-string.bf: -------------------------------------------------------------------------------- 1 | >,[>,]<[.<] 2 | -------------------------------------------------------------------------------- /archive/b/brainfuck/testinfo.yml: -------------------------------------------------------------------------------- 1 | folder: 2 | extension: ".bf" 3 | naming: "hyphen" 4 | 5 | container: 6 | image: "rzuckerm/brainf" 7 | tag: "1.2.0-2build2-1" 8 | build: | 9 | sh -c '(echo "#!/bin/sh"; \ 10 | echo "printf \"%s\0\" \"\$@\" | beef {{ source.name }}{{ source.extension }}" \ 11 | ) >{{ source.name }}' 12 | cmd: sh {{ source.name }} 13 | -------------------------------------------------------------------------------- /archive/c/c-plus-plus/fizz-buzz.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() 4 | { 5 | for (int i = 1; i <= 100; i++) 6 | { 7 | if (i % 15 == 0) 8 | std::cout << "FizzBuzz\n"; 9 | else if (i % 5 == 0) 10 | std::cout << "Buzz\n"; 11 | else if (i % 3 == 0) 12 | std::cout << "Fizz\n"; 13 | else 14 | std::cout << i << "\n"; 15 | } 16 | return 0; 17 | } 18 | -------------------------------------------------------------------------------- /archive/c/c-plus-plus/hello-world.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int main() 5 | { 6 | cout << "Hello, World!"; 7 | return 0; 8 | } 9 | -------------------------------------------------------------------------------- /archive/c/c-plus-plus/reverse-string.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | int main(int argc, char *argv[]) 6 | { 7 | if (argc < 2) 8 | return 0; 9 | 10 | std::string s = argv[1]; 11 | std::reverse(s.begin(), s.end()); 12 | 13 | std::cout << s << "\n"; 14 | } -------------------------------------------------------------------------------- /archive/c/c-plus-plus/testinfo.yml: -------------------------------------------------------------------------------- 1 | folder: 2 | extension: ".cpp" 3 | naming: "hyphen" 4 | 5 | container: 6 | image: "gcc" 7 | tag: "8.3" 8 | build: "g++ -o {{ source.name }} {{ source.name }}{{ source.extension }}" 9 | cmd: "./{{ source.name }}" 10 | -------------------------------------------------------------------------------- /archive/c/c-sharp/HelloWorld.cs: -------------------------------------------------------------------------------- 1 | namespace SamplePrograms 2 | { 3 | public class HelloWorld 4 | { 5 | static void Main() 6 | { 7 | System.Console.WriteLine("Hello, World!"); 8 | } 9 | } 10 | } 11 | -------------------------------------------------------------------------------- /archive/c/c-sharp/Quine.cs: -------------------------------------------------------------------------------- 1 | class Quine { static void Main() { var s = "class Quine {{ static void Main() {{ var s = {0}{1}{0}; System.Console.WriteLine(s, (char)34, s); }} }}"; System.Console.WriteLine(s, (char)34, s); } } -------------------------------------------------------------------------------- /archive/c/c-sharp/testinfo.yml: -------------------------------------------------------------------------------- 1 | folder: 2 | extension: ".cs" 3 | naming: "pascal" 4 | 5 | container: 6 | image: "mcr.microsoft.com/dotnet/sdk" 7 | tag: "9.0" 8 | build: | 9 | bash -c "dotnet new console --language 'C#' && \ 10 | mv {{ source.name }}{{ source.extension }} Program.cs && \ 11 | dotnet build --sc" 12 | cmd: "dotnet run --sc --no-restore" 13 | -------------------------------------------------------------------------------- /archive/c/c-star/baklava.cx: -------------------------------------------------------------------------------- 1 | void main() 2 | { 3 | for (int n in -10..11) { 4 | int num_spaces = abs(n); 5 | int num_stars = 21 - 2 * num_spaces; 6 | println(" ".repeat(num_spaces) + string("*".repeat(num_stars))); 7 | } 8 | } 9 | -------------------------------------------------------------------------------- /archive/c/c-star/hello-world.cx: -------------------------------------------------------------------------------- 1 | void main() 2 | { 3 | println("Hello, World!"); 4 | } 5 | -------------------------------------------------------------------------------- /archive/c/c-star/testinfo.yml: -------------------------------------------------------------------------------- 1 | folder: 2 | extension: ".cx" 3 | naming: "hyphen" 4 | 5 | container: 6 | image: "rzuckerm/c-star" 7 | tag: "2023.05.17-1" 8 | build: "cx -o {{ source.name }} {{ source.name }}{{ source.extension }}" 9 | cmd: "./{{ source.name }}" 10 | -------------------------------------------------------------------------------- /archive/c/c/fizz-buzz.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main(void) 4 | { 5 | for (unsigned int i = 1; i <= 100; i++) { 6 | if (i % 15 == 0) { 7 | puts("FizzBuzz"); 8 | } else if (i % 3 == 0) { 9 | puts("Fizz"); 10 | } else if (i % 5 == 0) { 11 | puts("Buzz"); 12 | } else { 13 | printf("%u\n", i); 14 | } 15 | } 16 | return 0; 17 | } 18 | -------------------------------------------------------------------------------- /archive/c/c/hello-world.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() 4 | { 5 | puts("Hello, World!"); 6 | return 0; 7 | } 8 | -------------------------------------------------------------------------------- /archive/c/c/quine.c: -------------------------------------------------------------------------------- 1 | #include "stdio.h" 2 | int main() { char* s="#include %cstdio.h%c%cint main() { char* s=%c%s%c; printf(s,34,34,10,34,s,34,10); return 0; }%c"; printf(s,34,34,10,34,s,34,10); return 0; } 3 | -------------------------------------------------------------------------------- /archive/c/c/testinfo.yml: -------------------------------------------------------------------------------- 1 | folder: 2 | extension: ".c" 3 | naming: "hyphen" 4 | 5 | container: 6 | image: "gcc" 7 | tag: "8.3" 8 | build: "gcc -o {{ source.name }} {{ source.name }}{{ source.extension }} -pthread -lm" 9 | cmd: "./{{ source.name }}" 10 | -------------------------------------------------------------------------------- /archive/c/c2/hello-world.c2: -------------------------------------------------------------------------------- 1 | module hello_world; 2 | 3 | import stdio as io; 4 | 5 | public fn i32 main(i32 argc, char** argv) { 6 | io.printf("Hello, World!\n"); 7 | return 0; 8 | } 9 | -------------------------------------------------------------------------------- /archive/c/c2/testinfo.yml: -------------------------------------------------------------------------------- 1 | folder: 2 | extension: ".c2" 3 | naming: "hyphen" 4 | 5 | container: 6 | image: "rzuckerm/c2" 7 | tag: "2025.01.20-2" 8 | build: "c2c -f {{ source.name }}{{ source.extension }}" 9 | cmd: "output/dummy/dummy" 10 | -------------------------------------------------------------------------------- /archive/c/carp/baklava.carp: -------------------------------------------------------------------------------- 1 | (defn main[] 2 | (for [n -10 11] 3 | (do 4 | (let [ 5 | num-spaces (abs n) 6 | num-stars (- 21 (* 2 num-spaces)) 7 | ] 8 | (println* (String.repeat num-spaces " ") (String.repeat num-stars "*")) 9 | ) 10 | ) 11 | ) 12 | ) 13 | -------------------------------------------------------------------------------- /archive/c/carp/hello-world.carp: -------------------------------------------------------------------------------- 1 | (defn main[] 2 | (println* "Hello, World!") 3 | ) 4 | -------------------------------------------------------------------------------- /archive/c/carp/testinfo.yml: -------------------------------------------------------------------------------- 1 | folder: 2 | extension: ".carp" 3 | naming: "hyphen" 4 | 5 | container: 6 | image: "carplang/carp" 7 | tag: "2020-04-23" 8 | cmd: "carp -x {{ source.name }}{{ source.extension }}" 9 | -------------------------------------------------------------------------------- /archive/c/chaiscript/baklava.chai: -------------------------------------------------------------------------------- 1 | def repeat_string(s, n) { 2 | var result = ""; 3 | for (var i = 0; i < n; ++i) { 4 | result += s; 5 | } 6 | 7 | return result; 8 | } 9 | 10 | for (var n = -10; n <= 10; ++n) { 11 | var num_spaces = (n < 0) ? -n : n; 12 | var num_stars = 21 - 2 * num_spaces; 13 | print(repeat_string(" ", num_spaces) + repeat_string("*", num_stars)); 14 | } 15 | -------------------------------------------------------------------------------- /archive/c/chaiscript/hello-world.chai: -------------------------------------------------------------------------------- 1 | print("Hello, World!") 2 | -------------------------------------------------------------------------------- /archive/c/chaiscript/testinfo.yml: -------------------------------------------------------------------------------- 1 | folder: 2 | extension: ".chai" 3 | naming: "hyphen" 4 | 5 | container: 6 | image: "rzuckerm/chaiscript" 7 | tag: "6.1.0-1" 8 | cmd: "chai {{ source.name }}{{ source.extension }}" 9 | -------------------------------------------------------------------------------- /archive/c/chapel/Baklava.chpl: -------------------------------------------------------------------------------- 1 | for n in -10..10 { 2 | var num_spaces = abs(n); 3 | var num_stars = 21 - 2 * num_spaces; 4 | writeln(" " * num_spaces + "*" * num_stars); 5 | } 6 | -------------------------------------------------------------------------------- /archive/c/chapel/FizzBuzz.chpl: -------------------------------------------------------------------------------- 1 | for i in 1..100 do 2 | if (i % 15 == 0) { 3 | writeln("FizzBuzz"); 4 | } else if (i % 5 == 0) { 5 | writeln("Buzz"); 6 | } else if (i % 3 == 0) { 7 | writeln("Fizz"); 8 | } else { 9 | writeln(i); 10 | } 11 | -------------------------------------------------------------------------------- /archive/c/chapel/HelloWorld.chpl: -------------------------------------------------------------------------------- 1 | writeln("Hello, World!"); 2 | -------------------------------------------------------------------------------- /archive/c/chapel/testinfo.yml: -------------------------------------------------------------------------------- 1 | folder: 2 | extension: ".chpl" 3 | naming: "pascal" 4 | 5 | container: 6 | image: "chapel/chapel" 7 | tag: "2.3.0" 8 | build: "chpl -o {{ source.name }} {{ source.name }}{{ source.extension }}" 9 | cmd: "./{{ source.name }}" 10 | -------------------------------------------------------------------------------- /archive/c/clojure/baklava.clj: -------------------------------------------------------------------------------- 1 | (ns baklava 2 | (:gen-class) 3 | (:require [clojure.string :refer [join]]) 4 | ) 5 | 6 | (defn repeat-string [n, s] 7 | (join (repeat n s)) 8 | ) 9 | 10 | (defn baklava-line [n] 11 | (def num-spaces (abs (- n 10))) 12 | (def num-stars (- 21 (* 2 num-spaces))) 13 | (str (repeat-string num-spaces " ") (repeat-string num-stars "*")) 14 | ) 15 | 16 | (defn baklava [n] 17 | (join "\n" (map baklava-line (range 0 n))) 18 | ) 19 | 20 | (println (baklava 21)) 21 | -------------------------------------------------------------------------------- /archive/c/clojure/hello-world.clj: -------------------------------------------------------------------------------- 1 | (ns hello-world 2 | (:gen-class)) 3 | 4 | (defn main 5 | "Hello World" 6 | [& args] 7 | (println "Hello, World!")) 8 | 9 | (main) 10 | 11 | -------------------------------------------------------------------------------- /archive/c/clojure/reverse-string.clj: -------------------------------------------------------------------------------- 1 | (ns reverse-string 2 | (:gen-class)) 3 | 4 | (defn main [args] 5 | (if (not= (count args) 0) 6 | (println(clojure.string/reverse (first args))) 7 | )) 8 | 9 | (main *command-line-args*) 10 | -------------------------------------------------------------------------------- /archive/c/clojure/testinfo.yml: -------------------------------------------------------------------------------- 1 | folder: 2 | extension: ".clj" 3 | naming: "hyphen" 4 | 5 | container: 6 | image: "clojure" 7 | tag: "tools-deps" 8 | cmd: "clojure -M ./{{ source.name}}{{ source.extension }}" 9 | -------------------------------------------------------------------------------- /archive/c/cobol/hello-world.cbl: -------------------------------------------------------------------------------- 1 | IDENTIFICATION DIVISION. 2 | PROGRAM-ID. HELLO-WORLD. 3 | PROCEDURE DIVISION. 4 | DISPLAY "Hello, World!" 5 | STOP RUN. 6 | -------------------------------------------------------------------------------- /archive/c/cobol/testinfo.yml: -------------------------------------------------------------------------------- 1 | folder: 2 | extension: ".cbl" 3 | naming: "hyphen" 4 | 5 | container: 6 | image: "esolang/cobol" 7 | tag: "latest" 8 | build: "cobc -x {{ source.name}}{{ source.extension }}" 9 | cmd: "./{{ source.name}}" 10 | -------------------------------------------------------------------------------- /archive/c/coffeescript/baklava.coffee: -------------------------------------------------------------------------------- 1 | for i in [0...10] 2 | pattern = " ".repeat (10 - i) 3 | pattern += "*".repeat (i * 2 + 1) 4 | console.log pattern 5 | 6 | for i in [10..0] 7 | pattern = " ".repeat (10 - i) 8 | pattern += "*".repeat (i * 2 + 1) 9 | console.log pattern -------------------------------------------------------------------------------- /archive/c/coffeescript/even-odd.coffee: -------------------------------------------------------------------------------- 1 | USAGE = "Usage: please input a number" 2 | main = (arg) -> 3 | numberParsed = parseInt(arg) 4 | isNumber = Number.isInteger(numberParsed) 5 | if isNumber 6 | if numberParsed % 2 == 0 then "Even" else "Odd" 7 | else 8 | USAGE 9 | 10 | console.log main(process.argv[2]) -------------------------------------------------------------------------------- /archive/c/coffeescript/factorial.coffee: -------------------------------------------------------------------------------- 1 | factorial = (n) -> 2 | return usage() if n < 0 3 | return 1 if n == "0" 4 | [1..n].reduce (x, y) -> x * y 5 | 6 | usage = () -> 7 | "Usage: please input a non-negative integer" 8 | 9 | main = () -> 10 | args = process.argv 11 | return factorial(args[2]) if args.length == 3 and isFinite(args[2]) and args[2] != "" 12 | usage() 13 | 14 | console.log main() 15 | -------------------------------------------------------------------------------- /archive/c/coffeescript/fizz-buzz.coffee: -------------------------------------------------------------------------------- 1 | for i in [1..100] 2 | if i % 15 is 0 3 | console.log "FizzBuzz" 4 | else if i % 3 is 0 5 | console.log "Fizz" 6 | else if i % 5 is 0 7 | console.log "Buzz" 8 | else 9 | console.log i -------------------------------------------------------------------------------- /archive/c/coffeescript/hello-world.coffee: -------------------------------------------------------------------------------- 1 | console.log("Hello, World!") 2 | -------------------------------------------------------------------------------- /archive/c/coffeescript/quine.coffee: -------------------------------------------------------------------------------- 1 | a="a=%j; console.log a,a"; console.log a,a 2 | -------------------------------------------------------------------------------- /archive/c/coffeescript/testinfo.yml: -------------------------------------------------------------------------------- 1 | folder: 2 | extension: ".coffee" 3 | naming: "hyphen" 4 | 5 | container: 6 | image: "codesignal/coffeescript" 7 | tag: "v7.1" 8 | cmd: "coffee {{ source.name }}{{ source.extension }}" 9 | -------------------------------------------------------------------------------- /archive/c/commodore-basic/baklava.bas: -------------------------------------------------------------------------------- 1 | 10 FOR I = -10 TO 10 2 | 20 NSP% = ABS(I) 3 | 30 SP$ = "" 4 | 40 IF NSP% = 0 GOTO 80 5 | 50 FOR J = 1 TO NSP% 6 | 60 SP$ = SP$ + " " 7 | 70 NEXT J 8 | 80 ST$ = "" 9 | 90 FOR J = 1 TO 21 - 2 * NSP% 10 | 100 ST$ = ST$ + "*" 11 | 110 NEXT J 12 | 120 PRINT SP$ + ST$ 13 | 130 NEXT I 14 | -------------------------------------------------------------------------------- /archive/c/commodore-basic/file-input-output.bas: -------------------------------------------------------------------------------- 1 | 10 OPEN 1, 1, 1, "output.txt" 2 | 20 PRINT#1, "Hello from Commodore Basic" 3 | 30 PRINT#1, "This is a line" 4 | 40 PRINT#1, "This is another line" 5 | 50 PRINT#1, "Goodbye!" 6 | 60 CLOSE 1 7 | 70 OPEN 1, 1, 0, "output.txt" 8 | 80 INPUT#1, A$ 9 | 90 PRINT A$ 10 | 100 IF ST = 0 THEN GOTO 80 11 | 110 CLOSE 1 12 | -------------------------------------------------------------------------------- /archive/c/commodore-basic/fizz-buzz.bas: -------------------------------------------------------------------------------- 1 | 10 FOR I = 1 TO 100 2 | 20 S$ = "" 3 | 30 IF (I - INT(I / 3) * 3) = 0 THEN S$ = S$ + "Fizz" 4 | 40 IF (I - INT(I / 5) * 5) = 0 THEN S$ = S$ + "Buzz" 5 | 45 REM STR$(I) prepends a space for positive numbers. MID$ removes it 6 | 50 IF S$ = "" THEN S$ = S$ + MID$(STR$(I), 2) 7 | 60 PRINT S$ 8 | 70 NEXT I 9 | -------------------------------------------------------------------------------- /archive/c/commodore-basic/hello-world.bas: -------------------------------------------------------------------------------- 1 | 10 PRINT "Hello, World!" 2 | -------------------------------------------------------------------------------- /archive/c/commodore-basic/quine.bas: -------------------------------------------------------------------------------- 1 | 10 LIST 2 | -------------------------------------------------------------------------------- /archive/c/crystal/baklava.cr: -------------------------------------------------------------------------------- 1 | a = -1 2 | loop do 3 | a += 1 4 | puts ((" " * (10 - a)) + ("*" * (a * 2 + 1))) 5 | break if a == 10 6 | end 7 | 8 | b = 10 9 | loop do 10 | b -= 1 11 | puts ((" " * (10 - b)) + ("*" * (b * 2 + 1))) 12 | break if b == 0 13 | end 14 | -------------------------------------------------------------------------------- /archive/c/crystal/fizz-buzz.cr: -------------------------------------------------------------------------------- 1 | i = 1 2 | while i < 101 3 | if i % 3 == 0 && i % 5 == 0 4 | puts "FizzBuzz" 5 | elsif i % 3 == 0 6 | puts "Fizz" 7 | elsif i % 5 == 0 8 | puts "Buzz" 9 | else 10 | puts i 11 | end 12 | i = i + 1 13 | end -------------------------------------------------------------------------------- /archive/c/crystal/hello-world.cr: -------------------------------------------------------------------------------- 1 | puts "Hello, World!" 2 | -------------------------------------------------------------------------------- /archive/c/crystal/testinfo.yml: -------------------------------------------------------------------------------- 1 | folder: 2 | extension: ".cr" 3 | naming: "hyphen" 4 | 5 | container: 6 | image: "crystallang/crystal" 7 | tag: "1.9.2-alpine" 8 | cmd: "crystal {{ source.name }}{{ source.extension }}" 9 | -------------------------------------------------------------------------------- /archive/c/cyclone/hello-world.cyc: -------------------------------------------------------------------------------- 1 | #include 2 | int main() { 3 | puts("Hello, World!"); 4 | return 0; 5 | } 6 | -------------------------------------------------------------------------------- /archive/c/cyclone/testinfo.yml: -------------------------------------------------------------------------------- 1 | folder: 2 | extension: ".cyc" 3 | naming: "hyphen" 4 | 5 | container: 6 | image: "rzuckerm/cyclone" 7 | tag: "1.0-1" 8 | build: "cyclone -o {{ source.name }} {{ source.name }}{{ source.extension }}" 9 | cmd: "./{{ source.name }}" 10 | -------------------------------------------------------------------------------- /archive/d/d/baklava.d: -------------------------------------------------------------------------------- 1 | import std.stdio, std.array; 2 | 3 | void main (string[ ] args) 4 | { 5 | 6 | for (byte i = 0; i < 10; i++) 7 | writeln ( 8 | " ".replicate (10 - i), "*".replicate (i * 2 + 1) 9 | ); 10 | 11 | for (byte i = 10; -1 < i; i--) 12 | writeln ( 13 | " ".replicate (10 - i), "*".replicate (i * 2 + 1) 14 | ); 15 | 16 | } 17 | -------------------------------------------------------------------------------- /archive/d/d/fizz_buzz.d: -------------------------------------------------------------------------------- 1 | import std.stdio; 2 | 3 | void main() 4 | { 5 | for (int i = 1; i <= 100; i++) { 6 | if (i % 15 == 0) writeln("FizzBuzz"); 7 | else if (i % 5 == 0) writeln("Buzz"); 8 | else if (i % 3 == 0) writeln("Fizz"); 9 | else writeln(i); 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /archive/d/d/hello_world.d: -------------------------------------------------------------------------------- 1 | import std.stdio; 2 | 3 | void main() 4 | { 5 | writeln("Hello, World!"); 6 | } 7 | -------------------------------------------------------------------------------- /archive/d/d/testinfo.yml: -------------------------------------------------------------------------------- 1 | folder: 2 | extension: ".d" 3 | naming: "underscore" 4 | 5 | container: 6 | image: "dlanguage/dmd" 7 | tag: "2.080.0" 8 | cmd: "rdmd {{ source.name }}{{ source.extension }}" 9 | -------------------------------------------------------------------------------- /archive/d/dale/hello-world.dt: -------------------------------------------------------------------------------- 1 | (import cstdio) 2 | 3 | (def main (fn extern-c int (void) 4 | (printf "Hello, World!\n"))) 5 | -------------------------------------------------------------------------------- /archive/d/dale/testinfo.yml: -------------------------------------------------------------------------------- 1 | folder: 2 | extension: ".dt" 3 | naming: "hyphen" 4 | 5 | container: 6 | image: "tomhrr/dale" 7 | tag: "0.3" 8 | build: "dalec -o {{ source.name }} {{ source.name }}{{ source.extension }}" 9 | cmd: "./{{ source.name }}" 10 | -------------------------------------------------------------------------------- /archive/d/dart/baklava.dart: -------------------------------------------------------------------------------- 1 | main() { 2 | for (var i = 0; i < 10; i++) { 3 | print(" " * (10 - i) + "*" * (i * 2 + 1)); 4 | } 5 | for (var i = 10; 0 <= i; i--) { 6 | print(" " * (10 - i) + "*" * (i * 2 + 1)); 7 | } 8 | } 9 | -------------------------------------------------------------------------------- /archive/d/dart/capitalize.dart: -------------------------------------------------------------------------------- 1 | import 'dart:io'; 2 | 3 | main(List args) { 4 | 5 | if (args.isEmpty || args[0].isEmpty) { 6 | print("Usage: please provide a string"); 7 | exit(1); 8 | } 9 | 10 | print(capitalize(args[0])); 11 | } 12 | 13 | String capitalize(String input) => 14 | '${input[0].toUpperCase()}${input.substring(1)}'; 15 | -------------------------------------------------------------------------------- /archive/d/dart/even-odd.dart: -------------------------------------------------------------------------------- 1 | void main(List args) { 2 | try{ 3 | (int.parse(args[0])%2 == 0)?print("Even"):print("Odd"); 4 | } 5 | catch(e){ 6 | print("Usage: please input a number"); 7 | } 8 | } 9 | 10 | 11 | -------------------------------------------------------------------------------- /archive/d/dart/fibonacci.dart: -------------------------------------------------------------------------------- 1 | void main(List args) { 2 | try{ 3 | int first = 0; 4 | int second = 1; 5 | int val = 1; 6 | for(int i=1; i print('Hello, World!'); 2 | -------------------------------------------------------------------------------- /archive/d/dart/reverse-string.dart: -------------------------------------------------------------------------------- 1 | // Run using : dart reverse-string.dart hello-world 2 | void main(List args) { 3 | if ( args.length > 0 ) { 4 | print( reverse(args[0]) ); 5 | } 6 | } 7 | String reverse(input) { 8 | return input.split('').reversed.join(); 9 | } -------------------------------------------------------------------------------- /archive/d/dart/testinfo.yml: -------------------------------------------------------------------------------- 1 | folder: 2 | extension: ".dart" 3 | naming: "hyphen" 4 | 5 | container: 6 | image: "google/dart" 7 | tag: "2.5" 8 | cmd: "dart {{ source.name }}{{ source.extension }}" 9 | -------------------------------------------------------------------------------- /archive/d/dg/baklava.dg: -------------------------------------------------------------------------------- 1 | for n in range -10 11 => 2 | num_spaces = abs n 3 | line = (" " * num_spaces) + ("*" * (21 - 2 * num_spaces)) 4 | print line 5 | -------------------------------------------------------------------------------- /archive/d/dg/fizz-buzz.dg: -------------------------------------------------------------------------------- 1 | fizz_buzz = n -> if 2 | n % 15 == 0 => "FizzBuzz" 3 | n % 3 == 0 => "Fizz" 4 | n % 5 == 0 => "Buzz" 5 | otherwise => n 6 | 7 | main = start end ruleset -> 8 | for i in range start (end + 1) => 9 | print <| ruleset i 10 | 11 | main 1 100 fizz_buzz 12 | -------------------------------------------------------------------------------- /archive/d/dg/hello-world.dg: -------------------------------------------------------------------------------- 1 | print "Hello, World!" 2 | -------------------------------------------------------------------------------- /archive/d/dg/quine.dg: -------------------------------------------------------------------------------- 1 | s = 's = %r\nprint $ s%%s' 2 | print $ s%s 3 | -------------------------------------------------------------------------------- /archive/d/dg/reverse-string.dg: -------------------------------------------------------------------------------- 1 | import "/sys/argv" 2 | 3 | snd_if_exists = xs -> if 4 | (len xs) > 1 => snd xs 5 | otherwise => "" 6 | 7 | reverse = s -> if 8 | len s => last s + (init s |> reverse) 9 | otherwise => "" 10 | 11 | print $ reverse <| snd_if_exists argv 12 | -------------------------------------------------------------------------------- /archive/d/dg/testinfo.yml: -------------------------------------------------------------------------------- 1 | folder: 2 | extension: ".dg" 3 | naming: "hyphen" 4 | 5 | container: 6 | image: "rzuckerm/dg" 7 | tag: "1.1.0-1" 8 | cmd: python -m dg {{ source.name }}{{ source.extension }} 9 | -------------------------------------------------------------------------------- /archive/d/discus/Baklava.ds: -------------------------------------------------------------------------------- 1 | module Main 2 | import System.IO.Console 3 | import Data.List 4 | import Data.Text.List 5 | 6 | where 7 | 8 | baklavaLine (n: Nat): Text 9 | = (textOfCharList (replicate num_spaces ' ')) % (textOfCharList (replicate num_stars '*')) 10 | where 11 | num_spaces = if n > 10 then n - 10 else 10 -n 12 | num_stars = 21 - 2 * num_spaces 13 | 14 | main () 15 | = forS (enumFromTo 0 20) $ λn 16 | -> writel $ baklavaLine n 17 | -------------------------------------------------------------------------------- /archive/d/discus/HelloWorld.ds: -------------------------------------------------------------------------------- 1 | module Main 2 | import System.IO.Console 3 | 4 | where 5 | 6 | main () 7 | = do writel "Hello, World!" 8 | -------------------------------------------------------------------------------- /archive/d/discus/testinfo.yml: -------------------------------------------------------------------------------- 1 | folder: 2 | extension: ".ds" 3 | naming: "pascal" 4 | 5 | container: 6 | image: "rzuckerm/discus" 7 | tag: "0.5.1-1" 8 | build: | 9 | sh -c 'cp {{ source.name }}{{ source.extension }} /opt/ddc/Main.ds && \ 10 | cd /opt/ddc && \ 11 | bin/ddc -make Main.ds' 12 | cmd: "/opt/ddc/Main" 13 | -------------------------------------------------------------------------------- /archive/d/dusk/baklava.dusk: -------------------------------------------------------------------------------- 1 | let repeat_string = |s, n| join(alloc(n, s), '') 2 | 3 | let n = -10 4 | while n < 11 { 5 | let num_spaces = n 6 | if num_spaces < 0: num_spaces = -num_spaces 7 | let num_stars = 21 - 2 * num_spaces 8 | n += 1 9 | println(repeat_string(' ', num_spaces) + repeat_string('*', num_stars)) 10 | } 11 | -------------------------------------------------------------------------------- /archive/d/dusk/hello-world.dusk: -------------------------------------------------------------------------------- 1 | println("Hello, World!") 2 | -------------------------------------------------------------------------------- /archive/d/dusk/testinfo.yml: -------------------------------------------------------------------------------- 1 | folder: 2 | extension: ".dusk" 3 | naming: "hyphen" 4 | 5 | container: 6 | image: "rzuckerm/dusk" 7 | tag: "0.1-1" 8 | cmd: "dusk {{ source.name }}{{ source.extension }}" 9 | -------------------------------------------------------------------------------- /archive/e/egison/baklava.egi: -------------------------------------------------------------------------------- 1 | def stringRepeat s n := 2 | (S.concat (take n (repeat1 s))) 3 | 4 | def baklavaLine n := 5 | let numSpaces := abs (n - 10) 6 | numStars := 21 - 2 * numSpaces in 7 | (S.concat [(stringRepeat " " numSpaces), (stringRepeat "*" numStars), "\n"]) 8 | 9 | def baklava n := 10 | (S.concat (map baklavaLine [0..n])) 11 | 12 | def main args := do 13 | write (baklava 20) 14 | -------------------------------------------------------------------------------- /archive/e/egison/hello-world.egi: -------------------------------------------------------------------------------- 1 | -- Prints "Hello, World!" to the standard output. 2 | def main args := do 3 | write "Hello, World!\n" 4 | -------------------------------------------------------------------------------- /archive/e/egison/testinfo.yml: -------------------------------------------------------------------------------- 1 | folder: 2 | extension: ".egi" 3 | naming: "hyphen" 4 | 5 | container: 6 | image: "esolang/egison" 7 | tag: "latest" 8 | cmd: egison {{ source.name }}{{ source.extension }} 9 | -------------------------------------------------------------------------------- /archive/e/eiffel/hello_world.e: -------------------------------------------------------------------------------- 1 | class 2 | hello_world 3 | 4 | create 5 | make 6 | 7 | feature 8 | 9 | make 10 | do 11 | print ("Hello, World!%N") 12 | end 13 | 14 | end 15 | -------------------------------------------------------------------------------- /archive/e/eiffel/testinfo.yml: -------------------------------------------------------------------------------- 1 | folder: 2 | extension: ".e" 3 | naming: "underscore" 4 | 5 | container: 6 | image: "rzuckerm/eiffel" 7 | tag: "13.11-1" 8 | build: "ec -stop {{ source.name }}{{ source.extension }}" 9 | cmd: "./EIFGENs/{{ source.name }}/W_code/{{ source.name }}" 10 | -------------------------------------------------------------------------------- /archive/e/elena/baklava.l: -------------------------------------------------------------------------------- 1 | import extensions; 2 | import extensions'text; 3 | import extensions'math; 4 | 5 | public program() 6 | { 7 | int space := " "[0].toInt(); 8 | int star := "*"[0].toInt(); 9 | for (int n := -10; n <= 10; n++) { 10 | int num_spaces := abs(n); 11 | int num_stars := 21 - 2 * num_spaces; 12 | console.writeLine(String.fill(num_spaces, space) + String.fill(num_stars, star)); 13 | } 14 | } 15 | -------------------------------------------------------------------------------- /archive/e/elena/hello-world.l: -------------------------------------------------------------------------------- 1 | public program() 2 | { 3 | console.writeLine("Hello, World!"); 4 | } 5 | -------------------------------------------------------------------------------- /archive/e/elena/testinfo.yml: -------------------------------------------------------------------------------- 1 | folder: 2 | extension: ".l" 3 | naming: "hyphen" 4 | 5 | container: 6 | image: "rzuckerm/elena" 7 | tag: "6.6.1-3" 8 | build: "elena64-cli {{ source.name }}{{ source.extension }}" 9 | cmd: "./{{ source.name }}" 10 | -------------------------------------------------------------------------------- /archive/e/elixir/fizz-buzz.ex: -------------------------------------------------------------------------------- 1 | 1..100 2 | |> Enum.map(fn 3 | n when rem(n, 3) == 0 and rem(n, 5) == 0 -> "FizzBuzz" 4 | n when rem(n, 3) == 0 -> "Fizz" 5 | n when rem(n, 5) == 0 -> "Buzz" 6 | n -> Integer.to_string(n) 7 | end) 8 | |> Enum.each(&IO.puts/1) 9 | -------------------------------------------------------------------------------- /archive/e/elixir/hello-world.ex: -------------------------------------------------------------------------------- 1 | IO.puts "Hello, World!" 2 | -------------------------------------------------------------------------------- /archive/e/elixir/testinfo.yml: -------------------------------------------------------------------------------- 1 | folder: 2 | extension: ".ex" 3 | naming: "hyphen" 4 | 5 | container: 6 | image: "elixir" 7 | tag: "1.9.2-alpine" 8 | cmd: "elixir {{ source.name }}{{ source.extension }}" 9 | 10 | -------------------------------------------------------------------------------- /archive/e/elvish/baklava.elv: -------------------------------------------------------------------------------- 1 | # By github.com/Kaamkiya 2 | 3 | for i [(range 11) (range 9 -1)] { 4 | var line = '' 5 | 6 | range (- 10 $i) | each { |_| set line = $line' '} 7 | range (+ 1 (* 2 $i)) | each { |_| set line = $line'*' } 8 | 9 | echo $line 10 | } 11 | -------------------------------------------------------------------------------- /archive/e/elvish/capitalize.elv: -------------------------------------------------------------------------------- 1 | use str 2 | 3 | fn die { 4 | echo 'Usage: please provide a string' 5 | exit 1 6 | } 7 | 8 | if (> 1 (count $args)) { 9 | die 10 | } 11 | 12 | var s = $args[0] 13 | 14 | if (> 1 (count $s)) { 15 | die 16 | } 17 | 18 | echo (str:join '' [(str:to-upper $s[0]) $s[1..]]) 19 | -------------------------------------------------------------------------------- /archive/e/elvish/even-odd.elv: -------------------------------------------------------------------------------- 1 | use re 2 | 3 | if (> 1 (count $args)) { 4 | echo "Usage: please input a number" 5 | exit 1 6 | } 7 | 8 | if (not (re:match '^[+-]?[0-9]+(\.[0-9]+)?$' $args[0])) { 9 | echo "Usage: please input a number" 10 | exit 1 11 | } 12 | 13 | if (== 0 (% $args[0] 2)) { 14 | echo Even 15 | } else { 16 | echo Odd 17 | } 18 | -------------------------------------------------------------------------------- /archive/e/elvish/file-input-output.elv: -------------------------------------------------------------------------------- 1 | echo "Hello, world!" >> output.txt # Write to output.txt 2 | cat output.txt # Print the contents of output.txt 3 | -------------------------------------------------------------------------------- /archive/e/elvish/fizz-buzz.elv: -------------------------------------------------------------------------------- 1 | for i [(range 1 101)] { 2 | if (== (% $i 15) 0) { 3 | echo FizzBuzz 4 | } elif (== (% $i 5) 0) { 5 | echo Buzz 6 | } elif (== (% $i 3) 0) { 7 | echo Fizz 8 | } else { 9 | echo $i 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /archive/e/elvish/hello-world.elv: -------------------------------------------------------------------------------- 1 | echo "Hello, World!" 2 | -------------------------------------------------------------------------------- /archive/e/elvish/remove-all-whitespace.elv: -------------------------------------------------------------------------------- 1 | use re 2 | 3 | if (> 1 (count $args)) { 4 | echo "Usage: please provide a string" 5 | exit 1 6 | } 7 | 8 | if (> 1 (count $args[0])) { 9 | echo "Usage: please provide a string" 10 | exit 1 11 | } 12 | 13 | echo (re:replace '\s' '' $args[0]) 14 | -------------------------------------------------------------------------------- /archive/e/elvish/reverse-string.elv: -------------------------------------------------------------------------------- 1 | if (> 1 (count $args)) { 2 | echo '' 3 | exit 4 | } 5 | 6 | echo $args[0] | rev 7 | -------------------------------------------------------------------------------- /archive/e/elvish/rot13.elv: -------------------------------------------------------------------------------- 1 | use str 2 | 3 | if (> 1 (count $args)) { 4 | echo "Usage: please provide a string to encrypt" 5 | exit 1 6 | } 7 | if (== 0 (str:compare $args[0] '')) { 8 | echo "Usage: please provide a string to encrypt" 9 | exit 1 10 | } 11 | 12 | echo $@args | tr 'A-Za-z' 'N-ZA-Mn-za-m' 13 | -------------------------------------------------------------------------------- /archive/e/elvish/testinfo.yml: -------------------------------------------------------------------------------- 1 | folder: 2 | extension: ".elv" 3 | naming: "hyphen" 4 | 5 | container: 6 | image: "ghcr.io/elves/elvish" 7 | tag: "v0.21.0" 8 | cmd: "elvish {{ source.name }}{{ source.extension }}" 9 | -------------------------------------------------------------------------------- /archive/e/emojicode/hello-world.emojic: -------------------------------------------------------------------------------- 1 | 🏁 🍇 2 | 😀 🔤Hello, World!🔤❗️ 3 | 🍉 4 | -------------------------------------------------------------------------------- /archive/e/emojicode/testinfo.yml: -------------------------------------------------------------------------------- 1 | folder: 2 | extension: ".emojic" 3 | naming: "hyphen" 4 | 5 | container: 6 | image: "esolang/emojicode" 7 | tag: "latest" 8 | build: "emojicodec {{ source.name }}{{ source.extension }}" 9 | cmd: "./{{ source.name }}" 10 | -------------------------------------------------------------------------------- /archive/e/erlang/hello_world.erl: -------------------------------------------------------------------------------- 1 | -module(hello_world). 2 | -export([main/1]). 3 | 4 | main(_) -> 5 | io:format("Hello, World!~n"). 6 | -------------------------------------------------------------------------------- /archive/e/erlang/testinfo.yml: -------------------------------------------------------------------------------- 1 | folder: 2 | extension: ".erl" 3 | naming: "underscore" 4 | 5 | container: 6 | image: "erlang" 7 | tag: "26.1.2.0-slim" 8 | cmd: "escript {{ source.name }}{{ source.extension }}" 9 | -------------------------------------------------------------------------------- /archive/e/eta/Baklava.hs: -------------------------------------------------------------------------------- 1 | module Main where 2 | 3 | baklavaLine :: Int -> String 4 | baklavaLine n = (replicate numSpaces ' ') ++ (replicate numStars '*') ++ "\n" 5 | where 6 | numSpaces = abs(n - 10) 7 | numStars = 21 - 2 * numSpaces 8 | 9 | baklava :: String -> Int -> String 10 | baklava s 0 = s ++ baklavaLine 0 11 | baklava s n = s ++ baklavaLine n ++ baklava s (n - 1) 12 | 13 | main :: IO () 14 | main = putStr (baklava "" 20) 15 | -------------------------------------------------------------------------------- /archive/e/eta/HelloWorld.hs: -------------------------------------------------------------------------------- 1 | module Main where 2 | main :: IO () 3 | main = putStrLn "Hello, World!" 4 | -------------------------------------------------------------------------------- /archive/e/eta/testinfo.yml: -------------------------------------------------------------------------------- 1 | folder: 2 | extension: ".hs" 3 | naming: "pascal" 4 | 5 | container: 6 | image: "typelead/eta" 7 | tag: "c3d2cb6" 8 | build: eta {{ source.name }}{{ source.extension }} 9 | cmd: java -jar Run{{ source.name }}.jar 10 | -------------------------------------------------------------------------------- /archive/e/euphoria/baklava.eu: -------------------------------------------------------------------------------- 1 | include std/io.e 2 | include std/math.e 3 | 4 | for n = -10 to 10 5 | do 6 | integer num_spaces = abs(n) 7 | integer num_stars = 21 - 2 * num_spaces 8 | printf(STDOUT, "%s%s\n", {repeat(' ', num_spaces), repeat('*', num_stars)}) 9 | end for 10 | -------------------------------------------------------------------------------- /archive/e/euphoria/fizz_buzz.eu: -------------------------------------------------------------------------------- 1 | include std/io.e 2 | include std/math.e 3 | include std/utils.e 4 | 5 | for n = 1 to 100 6 | do 7 | sequence s = "" 8 | s &= iif(mod(n, 3) = 0, "Fizz", "") 9 | s &= iif(mod(n, 5) = 0, "Buzz", "") 10 | s &= iif(length(s) = 0, sprintf("%d", n), "") 11 | printf(STDOUT, "%s\n", {s}) 12 | end for 13 | -------------------------------------------------------------------------------- /archive/e/euphoria/hello_world.eu: -------------------------------------------------------------------------------- 1 | include std/io.e 2 | 3 | puts(STDOUT, "Hello, World!\n") 4 | -------------------------------------------------------------------------------- /archive/e/euphoria/quine.eu: -------------------------------------------------------------------------------- 1 | constant s="constant s=%s%s%sprintf(1,s&10,{34,s,34})"printf(1,s&10,{34,s,34}) 2 | -------------------------------------------------------------------------------- /archive/e/euphoria/reverse_string.eu: -------------------------------------------------------------------------------- 1 | include std/io.e 2 | include std/sequence.e 3 | 4 | -- Parse 1st command-line argument 5 | sequence argv = command_line() 6 | sequence s = "" 7 | if length(argv) >= 4 8 | then 9 | s = argv[4] 10 | end if 11 | 12 | -- Show reversed string 13 | sequence t = reverse(s) 14 | printf(STDOUT, "%s\n", {t}) 15 | -------------------------------------------------------------------------------- /archive/e/euphoria/testinfo.yml: -------------------------------------------------------------------------------- 1 | folder: 2 | extension: ".eu" 3 | naming: "underscore" 4 | 5 | container: 6 | image: "openeuphoria/euphoria" 7 | tag: "4.1.0" 8 | cmd: "eui {{ source.name }}{{ source.extension }} -" 9 | -------------------------------------------------------------------------------- /archive/f/f-sharp/HelloWorld.fs: -------------------------------------------------------------------------------- 1 | printf "Hello, World!" 2 | -------------------------------------------------------------------------------- /archive/f/f-sharp/testinfo.yml: -------------------------------------------------------------------------------- 1 | folder: 2 | extension: ".fs" 3 | naming: "pascal" 4 | 5 | container: 6 | image: "fsharp" 7 | tag: "10-netcore" 8 | build: "fsharpc --standalone -o {{ source.name }} {{ source.name}}{{ source.extension }}" 9 | cmd: "mono {{ source.name }}" 10 | -------------------------------------------------------------------------------- /archive/f/f-star/HelloWorld.fst: -------------------------------------------------------------------------------- 1 | module HelloWorld 2 | 3 | open FStar.IO 4 | 5 | let main = print_string "Hello, World!\n" 6 | -------------------------------------------------------------------------------- /archive/f/f-star/testinfo.yml: -------------------------------------------------------------------------------- 1 | folder: 2 | extension: ".fst" 3 | naming: "pascal" 4 | 5 | container: 6 | image: "rzuckerm/f-star" 7 | tag: "2022.01.15-1" 8 | build: | 9 | sh -c "fstar --odir . --codegen OCaml --extract {{ source.name }} {{ source.name }}{{ source.extension }} && \ 10 | ocamlfind opt -package fstarlib -linkpkg -thread -o {{ source.name }} {{ source.name }}.ml" 11 | cmd: "./{{ source.name }}" 12 | -------------------------------------------------------------------------------- /archive/f/factor/hello-world.factor: -------------------------------------------------------------------------------- 1 | USE: io 2 | 3 | "Hello, World!" print 4 | -------------------------------------------------------------------------------- /archive/f/factor/testinfo.yml: -------------------------------------------------------------------------------- 1 | folder: 2 | extension: ".factor" 3 | naming: "hyphen" 4 | 5 | container: 6 | image: "rzuckerm/factor" 7 | tag: "0.100-2" 8 | cmd: "factor {{ source.name }}{{ source.extension }}" 9 | -------------------------------------------------------------------------------- /archive/f/felix/baklava.flx: -------------------------------------------------------------------------------- 1 | for i in -10..10 do 2 | var num_spaces = abs(i); 3 | var num_stars = 21 - 2 * num_spaces; 4 | println$ " " * num_spaces + "*" * num_stars; 5 | done 6 | -------------------------------------------------------------------------------- /archive/f/felix/hello-world.flx: -------------------------------------------------------------------------------- 1 | println$ "Hello, World!"; 2 | -------------------------------------------------------------------------------- /archive/f/felix/testinfo.yml: -------------------------------------------------------------------------------- 1 | folder: 2 | extension: ".flx" 3 | naming: "hyphen" 4 | 5 | container: 6 | image: "rzuckerm/felix" 7 | tag: "2019.01.06-1" 8 | build: "flx --static -o {{ source.name }} -c {{ source.name }}{{ source.extension }}" 9 | cmd: "./{{ source.name }}" 10 | -------------------------------------------------------------------------------- /archive/f/fennel/baklava.fnl: -------------------------------------------------------------------------------- 1 | (for [i -10 10] 2 | (let [ 3 | num-spaces (math.abs i) 4 | num-stars (- 21 (* 2 num-spaces)) 5 | ] 6 | (print (.. (string.rep " " num-spaces) (string.rep "*" num-stars))) 7 | ) 8 | ) 9 | -------------------------------------------------------------------------------- /archive/f/fennel/fizz-buzz.fnl: -------------------------------------------------------------------------------- 1 | (for [i 1 100] 2 | (if (= 0 (% i 15)) 3 | (print "FizzBuzz") 4 | (if (= 0 (% i 5)) 5 | (print "Buzz") 6 | (if (= 0 (% i 3)) 7 | (print "Fizz") 8 | (print i))))) 9 | -------------------------------------------------------------------------------- /archive/f/fennel/hello-world.fnl: -------------------------------------------------------------------------------- 1 | (print "Hello, World!") 2 | -------------------------------------------------------------------------------- /archive/f/fennel/testinfo.yml: -------------------------------------------------------------------------------- 1 | folder: 2 | extension: ".fnl" 3 | naming: "hyphen" 4 | 5 | container: 6 | image: "rzuckerm/fennel" 7 | tag: "1.3.1-1" 8 | cmd: "fennel {{ source.name }}{{ source.extension }}" 9 | -------------------------------------------------------------------------------- /archive/f/ferret/hello-world.clj: -------------------------------------------------------------------------------- 1 | (do 2 | (println "Hello, World!")) 3 | -------------------------------------------------------------------------------- /archive/f/ferret/testinfo.yml: -------------------------------------------------------------------------------- 1 | folder: 2 | extension: ".clj" 3 | naming: "hyphen" 4 | 5 | container: 6 | image: "rzuckerm/ferret" 7 | tag: "0.4.0-1" 8 | build: "sh -c 'ferret -i {{ source.name }}{{ source.extension }} && g++ -std=c++11 -pthread {{ source.name }}.cpp -o {{ source.name }}'" 9 | cmd: "./{{ source.name }}" 10 | -------------------------------------------------------------------------------- /archive/f/fetlang/hello-world.fet: -------------------------------------------------------------------------------- 1 | make slave scream "Hello, World!" 2 | -------------------------------------------------------------------------------- /archive/f/fetlang/testinfo.yml: -------------------------------------------------------------------------------- 1 | folder: 2 | extension: ".fet" 3 | naming: "hyphen" 4 | 5 | container: 6 | image: "esolang/fetlang" 7 | tag: "latest" 8 | cmd: "fetlang {{ source.name }}{{ source.extension }}" 9 | -------------------------------------------------------------------------------- /archive/f/flix/baklava.flix: -------------------------------------------------------------------------------- 1 | def baklavaLine(n: Int32): String = 2 | let numSpaces = Int32.abs(n); 3 | let numStars = 21 - 2 * numSpaces; 4 | String.repeat(numSpaces, " ") + String.repeat(numStars, "*") 5 | 6 | def main(): Unit \ IO = 7 | List.range(-10, 11) |> 8 | List.map(baklavaLine) |> 9 | List.forEach(println) 10 | -------------------------------------------------------------------------------- /archive/f/flix/hello-world.flix: -------------------------------------------------------------------------------- 1 | def main(): Unit \ IO = println("Hello, World!") -------------------------------------------------------------------------------- /archive/f/formality/hello-world.fm: -------------------------------------------------------------------------------- 1 | Main: IO(Unit) 2 | do IO { 3 | IO.print("Hello, World!") 4 | } 5 | -------------------------------------------------------------------------------- /archive/f/formality/testinfo.yml: -------------------------------------------------------------------------------- 1 | folder: 2 | extension: ".fm" 3 | naming: "hyphen" 4 | 5 | container: 6 | image: "rzuckerm/formality" 7 | tag: "2021.02.19-1" 8 | build: | 9 | sh -c 'cp {{ source.name }}{{ source.extension }} /opt/formality/src/Main.fm && \ 10 | cd /opt/formality/src && \ 11 | fmjs Main.fm' 12 | cmd: | 13 | sh -c "cd /opt/formality/src && fmjs Main --run" 14 | -------------------------------------------------------------------------------- /archive/f/forth/fizz-buzz.fth: -------------------------------------------------------------------------------- 1 | : divisible 2 | mod 0= 3 | ; 4 | 5 | : fizz-buzz 6 | dup 15 divisible if 7 | drop 8 | ." FizzBuzz" 9 | else 10 | dup 5 divisible if 11 | drop 12 | ." Buzz" 13 | else 14 | dup 3 divisible if 15 | drop 16 | ." Fizz" 17 | else 18 | . 19 | endif 20 | endif 21 | endif 22 | ; 23 | 24 | : fizz-buzz-loop 25 | 101 1 do i fizz-buzz cr loop 26 | ; 27 | 28 | fizz-buzz-loop 29 | bye 30 | -------------------------------------------------------------------------------- /archive/f/forth/hello-world.fth: -------------------------------------------------------------------------------- 1 | .( Hello, World!) CR 2 | bye 3 | -------------------------------------------------------------------------------- /archive/f/forth/testinfo.yml: -------------------------------------------------------------------------------- 1 | folder: 2 | extension: ".fth" 3 | naming: "hyphen" 4 | 5 | container: 6 | image: "mtrute/gforth-container" 7 | tag: "0.7.9_20190627" 8 | cmd: "gforth {{ source.name }}{{ source.extension }}" 9 | -------------------------------------------------------------------------------- /archive/f/fortran/baklava.f95: -------------------------------------------------------------------------------- 1 | program Baklava 2 | do i = 0, 10, 1 3 | print '(10a)', repeat (" ", (10 - i)), repeat ("*", (i * 2 + 1)) 4 | end do 5 | do i = 9, 0, -1 6 | print '(10a)', repeat (" ", (10 - i)), repeat ("*", (i * 2 + 1)) 7 | end do 8 | end program Baklava 9 | -------------------------------------------------------------------------------- /archive/f/fortran/hello-world.f95: -------------------------------------------------------------------------------- 1 | PROGRAM HELLOWORLD 2 | PRINT *, 'Hello, World!' 3 | END 4 | -------------------------------------------------------------------------------- /archive/f/fortran/reverse-string.f95: -------------------------------------------------------------------------------- 1 | program reversestring 2 | character(len=100) :: argument 3 | character(len=:), allocatable :: buff, reversed 4 | integer :: i, n 5 | call GET_COMMAND_ARGUMENT(1,argument) 6 | allocate (buff, mold=argument) 7 | n = len(argument) 8 | do i = 0, n - 1 9 | buff(n-i : n-i) = argument(i+1 : i+1) 10 | end do 11 | reversed = adjustl(trim(buff)) 12 | write(*,'(g0.8)')reversed 13 | end program reversestring 14 | -------------------------------------------------------------------------------- /archive/f/fortran/testinfo.yml: -------------------------------------------------------------------------------- 1 | folder: 2 | extension: ".f95" 3 | naming: "hyphen" 4 | 5 | container: 6 | image: "gcc" 7 | tag: "8.3" 8 | build: "gfortran -o {{ source.name }} {{ source.name }}{{ source.extension }}" 9 | cmd: "./{{ source.name }}" 10 | -------------------------------------------------------------------------------- /archive/f/frege/Baklava.fr: -------------------------------------------------------------------------------- 1 | module Baklava where 2 | 3 | main :: IO () 4 | main = putStr (baklava "" 20) 5 | 6 | baklava :: String -> Int -> String 7 | baklava s n 8 | | n < 0 = "" 9 | | otherwise = s ++ baklavaLine n ++ baklava s (n - 1) 10 | 11 | baklavaLine :: Int -> String 12 | baklavaLine n = do 13 | let num_spaces = abs (n - 10) 14 | let num_stars = 21 - 2 * num_spaces 15 | packed (replicate num_spaces ' ') ++ packed (replicate num_stars '*') ++ "\n" 16 | -------------------------------------------------------------------------------- /archive/f/frege/HelloWorld.fr: -------------------------------------------------------------------------------- 1 | module HelloWorld where 2 | 3 | main :: IO () 4 | main = do putStrLn "Hello, World!" -------------------------------------------------------------------------------- /archive/f/frege/testinfo.yml: -------------------------------------------------------------------------------- 1 | folder: 2 | extension: ".fr" 3 | naming: "pascal" 4 | 5 | container: 6 | image: "agocorona/frege" 7 | tag: "alias" 8 | build: "java -Xss1m -jar /root/frege3.24-7.100.jar -d . -target 1.7 {{ source.name }}{{ source.extension }}" 9 | cmd: "java -Xss1m -cp .:/root/frege3.24-7.100.jar {{ source.name }}" 10 | -------------------------------------------------------------------------------- /archive/g/gerbil/baklava.ss: -------------------------------------------------------------------------------- 1 | (import :std/iter) 2 | (import :std/misc/func) 3 | 4 | (export main) 5 | 6 | (def (string-repeat n str) 7 | (string-join (repeat str n) "") 8 | ) 9 | 10 | (def (main . args) 11 | (for (i (in-range -10 11)) 12 | (def num-spaces (abs i)) 13 | (def num-stars (- 21 (* 2 num-spaces))) 14 | (displayln (string-repeat num-spaces " ") (string-repeat num-stars "*")) 15 | ) 16 | ) 17 | -------------------------------------------------------------------------------- /archive/g/gerbil/hello_world.ss: -------------------------------------------------------------------------------- 1 | (export main) 2 | (def (main . args) 3 | (displayln "Hello, World!") 4 | ) 5 | -------------------------------------------------------------------------------- /archive/g/gerbil/testinfo.yml: -------------------------------------------------------------------------------- 1 | folder: 2 | extension: ".ss" 3 | naming: "underscore" 4 | 5 | container: 6 | image: "gerbil/gerbil" 7 | tag: "x86_64-v0.18" 8 | build: | 9 | sh -c 'echo "(package: {{ source.name }})" >gerbil.pkg && gxc -exe -o {{ source.name }} {{ source.name }}{{ source.extension }}' 10 | cmd: "./{{ source.name }}" 11 | -------------------------------------------------------------------------------- /archive/g/gluon/hello-world.glu: -------------------------------------------------------------------------------- 1 | let io = import! std.io 2 | io.print "Hello, World!\n" 3 | -------------------------------------------------------------------------------- /archive/g/gluon/testinfo.yml: -------------------------------------------------------------------------------- 1 | folder: 2 | extension: ".glu" 3 | naming: "hyphen" 4 | 5 | container: 6 | image: "rzuckerm/gluon" 7 | tag: "0.18.2-1" 8 | cmd: "gluon {{ source.name }}{{ source.extension }}" 9 | -------------------------------------------------------------------------------- /archive/g/gnu-make/file-input-output.mk: -------------------------------------------------------------------------------- 1 | define TEXT 2 | Hello from GNU Make 3 | Here are some lines: 4 | This is line 1 5 | This is line 2 6 | Goodbye! 7 | endef 8 | 9 | $(file >output.txt,$(TEXT)) 10 | $(info $(file = 0 n else -n end 3 | num_stars = 21 - 2 * num_spaces 4 | puts(" " * num_spaces + "*" * num_stars) 5 | end 6 | -------------------------------------------------------------------------------- /archive/g/goby/hello-world.gb: -------------------------------------------------------------------------------- 1 | puts("Hello, World!") 2 | -------------------------------------------------------------------------------- /archive/g/goby/testinfo.yml: -------------------------------------------------------------------------------- 1 | folder: 2 | extension: ".gb" 3 | naming: "hyphen" 4 | 5 | container: 6 | image: "gobylang/goby" 7 | tag: "v0.1.10" 8 | cmd: "goby {{ source.name }}{{ source.extension }}" 9 | -------------------------------------------------------------------------------- /archive/g/golo/baklava.golo: -------------------------------------------------------------------------------- 1 | module baklava 2 | 3 | function main = |args| { 4 | for (var n = -10, n <= 10, n = n + 1) { 5 | let numSpaces = Math.abs(n) 6 | let numStars = 21 - 2 * numSpaces 7 | println(" " * numSpaces + "*" * numStars) 8 | } 9 | } 10 | -------------------------------------------------------------------------------- /archive/g/golo/hello-world.golo: -------------------------------------------------------------------------------- 1 | module hello.World 2 | 3 | function main = |args| { 4 | println("Hello, World!") 5 | } 6 | -------------------------------------------------------------------------------- /archive/g/golo/testinfo.yml: -------------------------------------------------------------------------------- 1 | folder: 2 | extension: ".golo" 3 | naming: "hyphen" 4 | 5 | container: 6 | image: "jponge/golo-lang" 7 | tag: "release_3.3.0" 8 | build: | 9 | sh -c '(echo "#!/bin/sh"; \ 10 | echo "if [ \$# -gt 0 ]; then ARGS=--args; fi"; \ 11 | echo "golo golo --files {{ source.name }}{{ source.extension }} \${ARGS}" \ 12 | ) >{{ source.name }}' 13 | cmd: sh {{ source.name }} 14 | -------------------------------------------------------------------------------- /archive/g/gosu/baklava.gsp: -------------------------------------------------------------------------------- 1 | for ( n in -10..10) { 2 | var numSpaces = Math.abs(n) 3 | var numStars = 21 - 2 * numSpaces 4 | print(" ".repeat(numSpaces) + "*".repeat(numStars)) 5 | } 6 | -------------------------------------------------------------------------------- /archive/g/gosu/hello-world.gsp: -------------------------------------------------------------------------------- 1 | print("Hello, World!") 2 | -------------------------------------------------------------------------------- /archive/g/gosu/testinfo.yml: -------------------------------------------------------------------------------- 1 | folder: 2 | extension: ".gsp" 3 | naming: "hyphen" 4 | 5 | container: 6 | image: "rzuckerm/gosu" 7 | tag: "1.17.4-1" 8 | cmd: "gosu {{ source.name }}{{ source.extension }}" 9 | -------------------------------------------------------------------------------- /archive/g/grain/hello-world.gr: -------------------------------------------------------------------------------- 1 | module Main 2 | 3 | print("Hello, World!") 4 | -------------------------------------------------------------------------------- /archive/g/grain/testinfo.yml: -------------------------------------------------------------------------------- 1 | folder: 2 | extension: ".gr" 3 | naming: "hyphen" 4 | 5 | container: 6 | image: "ghcr.io/grain-lang/grain" 7 | tag: "0.6.6-slim" 8 | cmd: "grain {{ source.name }}{{ source.extension }}" 9 | -------------------------------------------------------------------------------- /archive/g/granule/hello-world.gr: -------------------------------------------------------------------------------- 1 | main : () <{Stdout}> 2 | main = toStdout "Hello, World!\n" 3 | -------------------------------------------------------------------------------- /archive/g/granule/testinfo.yml: -------------------------------------------------------------------------------- 1 | folder: 2 | extension: ".gr" 3 | naming: "hyphen" 4 | 5 | container: 6 | image: "rzuckerm/granule" 7 | tag: "0.9.6.0-6" 8 | cmd: "gr --no-info --no-print-return-value --include-path=/usr/local/lib {{ source.name }}{{ source.extension }}" 9 | -------------------------------------------------------------------------------- /archive/g/gravity/baklava.gravity: -------------------------------------------------------------------------------- 1 | func main() { 2 | for (var n in -10...10) { 3 | var numSpaces = Math.abs(n) 4 | var numStars = 21 - 2 * numSpaces 5 | var spaces = (numSpaces > 0) ? " ".repeat(numSpaces) : "" 6 | var stars = "*".repeat(numStars) 7 | System.print(spaces + stars) 8 | } 9 | } 10 | -------------------------------------------------------------------------------- /archive/g/gravity/fizz-buzz.gravity: -------------------------------------------------------------------------------- 1 | func main() { 2 | for (var i in 1...100) { 3 | if (i % 15 == 0) { 4 | System.print("FizzBuzz") 5 | } else if (i % 5 == 0) { 6 | System.print("Buzz") 7 | } else if (i % 3 == 0) { 8 | System.print("Fizz") 9 | } else { 10 | System.print(i) 11 | } 12 | } 13 | } 14 | -------------------------------------------------------------------------------- /archive/g/gravity/hello-world.gravity: -------------------------------------------------------------------------------- 1 | func main() { 2 | System.print("Hello, World!"); 3 | } 4 | -------------------------------------------------------------------------------- /archive/g/gravity/testinfo.yml: -------------------------------------------------------------------------------- 1 | folder: 2 | extension: ".gravity" 3 | naming: "hyphen" 4 | 5 | container: 6 | image: "rzuckerm/gravity" 7 | tag: "0.8.5-1" 8 | cmd: "gravity -q {{ source.name }}{{ source.extension }}" 9 | -------------------------------------------------------------------------------- /archive/g/groovy/Baklava.groovy: -------------------------------------------------------------------------------- 1 | (0..10).each{ index -> 2 | println "${' ' * (10 - index)}${'*' * (index * 2 + 1)}" 3 | } 4 | (9..0).each{ index -> 5 | println "${' ' * (10 - index)}${'*' * (index * 2 + 1)}" 6 | } -------------------------------------------------------------------------------- /archive/g/groovy/Capitalize.groovy: -------------------------------------------------------------------------------- 1 | class Capitalize { 2 | static void main(String... args) { 3 | if(args?.length >= 1 && args[0]?.length() >= 1) { 4 | println args[0]?.capitalize() 5 | } 6 | else { 7 | println "Usage: please provide a string" 8 | } 9 | } 10 | } 11 | -------------------------------------------------------------------------------- /archive/g/groovy/EvenOdd.groovy: -------------------------------------------------------------------------------- 1 | class EvenOdd { 2 | static void main(String... args) { 3 | if(args?.length != 1 || !args[0]?.isInteger()) { 4 | println 'Usage: please input a number' 5 | } else { 6 | println args[0].toInteger() % 2 == 0 ? 'Even' : 'Odd' 7 | } 8 | } 9 | } 10 | -------------------------------------------------------------------------------- /archive/g/groovy/FizzBuzz.groovy: -------------------------------------------------------------------------------- 1 | 1.upto(100) { 2 | if (it % 15 == 0) { 3 | println("FizzBuzz") 4 | } else if (it % 5 == 0) { 5 | println("Buzz") 6 | } else if (it % 3 == 0){ 7 | println("Fizz") 8 | } else { 9 | println(it) 10 | } 11 | }; 12 | -------------------------------------------------------------------------------- /archive/g/groovy/HelloWorld.groovy: -------------------------------------------------------------------------------- 1 | println "Hello, World!" 2 | -------------------------------------------------------------------------------- /archive/g/groovy/ReverseString.groovy: -------------------------------------------------------------------------------- 1 | class ReverseString { 2 | static void main(String... args) { 3 | if(args?.length >= 1 && args[0]?.length() >= 1) { 4 | println args[0]?.reverse() 5 | } 6 | } 7 | } 8 | -------------------------------------------------------------------------------- /archive/g/groovy/testinfo.yml: -------------------------------------------------------------------------------- 1 | folder: 2 | extension: ".groovy" 3 | naming: "pascal" 4 | 5 | container: 6 | image: "groovy" 7 | tag: "4.0.13-jdk11-alpine" 8 | cmd: groovy {{ source.name }}{{ source.extension }} 9 | -------------------------------------------------------------------------------- /archive/h/hack/baklava.hack: -------------------------------------------------------------------------------- 1 | use namespace HH\Lib\Str; 2 | 3 | <<__EntryPoint>> 4 | function main(): void { 5 | for ($n = -10; $n <= 10; $n++) { 6 | $numSpaces = abs($n); 7 | $numStars = 21 - 2 * $numSpaces; 8 | echo Str\repeat(" ", $numSpaces) . Str\repeat("*", $numStars) . "\n"; 9 | } 10 | } 11 | -------------------------------------------------------------------------------- /archive/h/hack/hello-world.hack: -------------------------------------------------------------------------------- 1 | <<__EntryPoint>> 2 | function main(): void { 3 | echo "Hello, World!"; 4 | } 5 | -------------------------------------------------------------------------------- /archive/h/hack/testinfo.yml: -------------------------------------------------------------------------------- 1 | folder: 2 | extension: ".hack" 3 | naming: "hyphen" 4 | 5 | container: 6 | image: "hhvm/hhvm" 7 | tag: "2023.02.17" 8 | cmd: "hhvm {{ source.name }}{{ source.extension }}" 9 | -------------------------------------------------------------------------------- /archive/h/haskell/fizz-buzz.hs: -------------------------------------------------------------------------------- 1 | module Main where 2 | 3 | fizzbuzz :: Int -> String 4 | fizzbuzz x 5 | | x `mod` 15 == 0 = "FizzBuzz" 6 | | x `mod` 3 == 0 = "Fizz" 7 | | x `mod` 5 == 0 = "Buzz" 8 | | otherwise = show x 9 | 10 | main = mapM (putStrLn . fizzbuzz) [1..100] 11 | -------------------------------------------------------------------------------- /archive/h/haskell/hello-world.hs: -------------------------------------------------------------------------------- 1 | module Main where 2 | 3 | main = putStrLn "Hello, World!" 4 | -------------------------------------------------------------------------------- /archive/h/haskell/quine.hs: -------------------------------------------------------------------------------- 1 | main = putStrLn $ (++) <*> show $ "main = putStrLn $ (++) <*> show $ " 2 | -------------------------------------------------------------------------------- /archive/h/haskell/reverse-string.hs: -------------------------------------------------------------------------------- 1 | module Main where 2 | 3 | import System.Environment 4 | 5 | main :: IO () 6 | main = do 7 | args <- getArgs 8 | if null args then 9 | putStrLn "" 10 | else 11 | putStrLn $ reverse $ head args 12 | -------------------------------------------------------------------------------- /archive/h/haskell/testinfo.yml: -------------------------------------------------------------------------------- 1 | folder: 2 | extension: ".hs" 3 | naming: "hyphen" 4 | 5 | container: 6 | image: "haskell" 7 | tag: "8.6" 8 | build: "ghc {{ source.name }}{{ source.extension }}" 9 | cmd: "./{{ source.name }}" 10 | -------------------------------------------------------------------------------- /archive/h/haxe/Baklava.hx: -------------------------------------------------------------------------------- 1 | import StringTools; 2 | 3 | class Baklava { 4 | static private function repeatString(s:String, n:Int): String { 5 | return StringTools.rpad("", s, n); 6 | } 7 | 8 | static public function main() { 9 | for (n in -10...11) { 10 | var numSpaces = Std.int(Math.abs(n)); 11 | var numStars = 21 - 2 * numSpaces; 12 | trace(repeatString(" ", numSpaces) + repeatString("*", numStars)); 13 | } 14 | } 15 | } 16 | -------------------------------------------------------------------------------- /archive/h/haxe/FizzBuzz.hx: -------------------------------------------------------------------------------- 1 | class FizzBuzz { 2 | static public function main():Void { 3 | for (i in 1...101) { 4 | var div3 = (i % 3 == 0); 5 | var div5 = (i % 5 == 0); 6 | Sys.println(div3 ? (div5 ? "FizzBuzz" : "Fizz") : (div5 ? "Buzz" : '$i')); 7 | } 8 | } 9 | } 10 | -------------------------------------------------------------------------------- /archive/h/haxe/HelloWorld.hx: -------------------------------------------------------------------------------- 1 | class HelloWorld { 2 | static public function main() { 3 | trace("Hello, World!"); 4 | } 5 | } 6 | -------------------------------------------------------------------------------- /archive/h/haxe/testinfo.yml: -------------------------------------------------------------------------------- 1 | folder: 2 | extension: ".hx" 3 | naming: "pascal" 4 | 5 | container: 6 | image: "haxe" 7 | tag: "4.3-bookworm" 8 | build: "haxe --main {{ source.name }} --python {{ source.name }}.py" 9 | cmd: "python3 {{ source.name }}.py" 10 | -------------------------------------------------------------------------------- /archive/h/hobbes/hello-world.hob: -------------------------------------------------------------------------------- 1 | putStrLn("Hello, World!") 2 | -------------------------------------------------------------------------------- /archive/h/hobbes/testinfo.yml: -------------------------------------------------------------------------------- 1 | folder: 2 | extension: ".hob" 3 | naming: "hyphen" 4 | 5 | container: 6 | image: "rzuckerm/hobbes" 7 | tag: "2023.08.14-1" 8 | cmd: "hi -s -x {{ source.name }}{{ source.extension }}" 9 | -------------------------------------------------------------------------------- /archive/i/idris/Baklava.idr: -------------------------------------------------------------------------------- 1 | module Main 2 | 3 | repeatString : String -> Int -> String 4 | repeatString s n = if n < 1 then "" else s ++ repeatString s (n - 1) 5 | 6 | baklavaLine : Int -> String 7 | baklavaLine n = repeatString " " numSpaces ++ repeatString "*" numStars 8 | where 9 | numSpaces = abs n 10 | numStars = 21 - 2 * numSpaces 11 | 12 | main : IO () 13 | main = sequence_ $ map (putStrLn . baklavaLine) [-10..10] 14 | -------------------------------------------------------------------------------- /archive/i/idris/HelloWorld.idr: -------------------------------------------------------------------------------- 1 | module Main 2 | 3 | main : IO () 4 | main = putStrLn "Hello, World!" 5 | -------------------------------------------------------------------------------- /archive/i/idris/testinfo.yml: -------------------------------------------------------------------------------- 1 | folder: 2 | extension: ".idr" 3 | naming: "pascal" 4 | 5 | container: 6 | image: "snazzybucket/idris2" 7 | tag: "v0.6.0-265-gbadf1e98c" 8 | build: "idris2 {{ source.name }}{{ source.extension }} -o {{ source.name }}" 9 | cmd: "./build/exec/{{ source.name }}" 10 | -------------------------------------------------------------------------------- /archive/i/io/Baklava.io: -------------------------------------------------------------------------------- 1 | baklavaLine := method(n, 2 | num_spaces := n abs 3 | num_stars := 21 - (2 * num_spaces) 4 | (" " repeated(num_spaces)) .. ("*" repeated(num_stars)) 5 | ) 6 | 7 | for(n, -10, 10, baklavaLine(n) println) 8 | -------------------------------------------------------------------------------- /archive/i/io/FizzBuzz.io: -------------------------------------------------------------------------------- 1 | for (a, 1, 100, 2 | if ((a % 3) != 0 and (a % 5) != 0, 3 | a print 4 | ) 5 | 6 | if ((a % 3) == 0, 7 | "Fizz" print 8 | ) 9 | 10 | if ((a % 5) == 0, 11 | "Buzz" print 12 | ) 13 | 14 | "\n" print 15 | ) 16 | -------------------------------------------------------------------------------- /archive/i/io/HelloWorld.io: -------------------------------------------------------------------------------- 1 | "Hello, World!" println 2 | -------------------------------------------------------------------------------- /archive/i/io/testinfo.yml: -------------------------------------------------------------------------------- 1 | folder: 2 | extension: ".io" 3 | naming: "pascal" 4 | 5 | container: 6 | image: "kraftdorian/iolanguage" 7 | tag: "2015.11.11" 8 | cmd: "io {{ source.name }}{{ source.extension }}" 9 | -------------------------------------------------------------------------------- /archive/j/janet/baklava.janet: -------------------------------------------------------------------------------- 1 | (for n -10 11 2 | (let [num_spaces (math/abs n) 3 | num_stars (- 21 (* 2 num_spaces))] 4 | (print (string/repeat " " num_spaces) (string/repeat "*" num_stars)) 5 | ) 6 | ) 7 | -------------------------------------------------------------------------------- /archive/j/janet/fizz-buzz.janet: -------------------------------------------------------------------------------- 1 | (loop [n :range [1 101]] 2 | (print (cond 3 | (zero? (% n 15)) "FizzBuzz" 4 | (zero? (% n 5)) "Buzz" 5 | (zero? (% n 3)) "Fizz" 6 | n))) 7 | -------------------------------------------------------------------------------- /archive/j/janet/hello-world.janet: -------------------------------------------------------------------------------- 1 | (print "Hello, World!") 2 | -------------------------------------------------------------------------------- /archive/j/janet/testinfo.yml: -------------------------------------------------------------------------------- 1 | folder: 2 | extension: ".janet" 3 | naming: "hyphen" 4 | 5 | container: 6 | image: "leafgarland/janet" 7 | tag: "v1.30.0" 8 | cmd: "janet {{ source.name }}{{ source.extension }}" 9 | -------------------------------------------------------------------------------- /archive/j/java/HelloWorld.java: -------------------------------------------------------------------------------- 1 | class HelloWorld { 2 | public static void main(String[] args) { 3 | System.out.println("Hello, World!"); 4 | } 5 | } -------------------------------------------------------------------------------- /archive/j/java/Quine.java: -------------------------------------------------------------------------------- 1 | public class Quine{public static void main(String[] args){char quote=34;String code="public class Quine{public static void main(String[] args){char quote=34;String code=;System.out.println(code.substring(0,84)+quote+code+quote+code.substring(84));}}";System.out.println(code.substring(0,84)+quote+code+quote+code.substring(84));}} 2 | -------------------------------------------------------------------------------- /archive/j/java/ReverseString.java: -------------------------------------------------------------------------------- 1 | public class ReverseString { 2 | public static void main(String args[]) { 3 | if (args.length > 0) { 4 | StringBuilder builder = new StringBuilder(args[0]); 5 | String reversed = builder.reverse().toString(); 6 | System.out.println(reversed); 7 | } 8 | } 9 | } 10 | -------------------------------------------------------------------------------- /archive/j/java/testinfo.yml: -------------------------------------------------------------------------------- 1 | folder: 2 | extension: ".java" 3 | naming: "pascal" 4 | 5 | container: 6 | image: "openjdk" 7 | tag: "23-slim" 8 | build: "javac {{ source.name}}{{ source.extension }}" 9 | cmd: "java {{ source.name }}" 10 | -------------------------------------------------------------------------------- /archive/j/javascript/baklava.js: -------------------------------------------------------------------------------- 1 | for (var i = 0; i < 10; i++) 2 | console.log ( 3 | " ".repeat (10 - i) + "*".repeat (i * 2 + 1) 4 | ); 5 | 6 | for (var i = 10; -1 < i; i--) 7 | console.log ( 8 | " ".repeat (10 - i) + "*".repeat (i * 2 + 1) 9 | ); 10 | -------------------------------------------------------------------------------- /archive/j/javascript/capitalize.js: -------------------------------------------------------------------------------- 1 | function capitalize(stringToCapitalize) { 2 | return stringToCapitalize[0].toUpperCase() + stringToCapitalize.slice(1); 3 | } 4 | 5 | function main() { 6 | if (process.argv.length == 3 && process.argv[2].length > 0) { 7 | let input = process.argv[2]; 8 | console.log(capitalize(input)); 9 | } else { 10 | console.log("Usage: please provide a string"); 11 | } 12 | } 13 | 14 | main(); 15 | -------------------------------------------------------------------------------- /archive/j/javascript/even-odd.js: -------------------------------------------------------------------------------- 1 | const input = process.argv[2] != '' ? Number(process.argv[2]) : null; //coerce the input into a number, ignore empty string 2 | if(!Number.isInteger(input)){ //if there is no input, input = undefined and the statement still prints 3 | console.log('Usage: please input a number'); 4 | } else { 5 | console.log(input%2 === 0 ? 'Even' : 'Odd'); 6 | } 7 | -------------------------------------------------------------------------------- /archive/j/javascript/fizz-buzz.js: -------------------------------------------------------------------------------- 1 | function fizzbuzz(num){ 2 | for(let i=1; i <= num; i++){ 3 | if(i % 15 == 0){ 4 | console.log("FizzBuzz"); 5 | } 6 | else if(i % 5 == 0){ 7 | console.log("Buzz"); 8 | } 9 | else if(i % 3 == 0){ 10 | console.log("Fizz"); 11 | } 12 | else console.log(i); 13 | } 14 | } 15 | 16 | fizzbuzz(100); 17 | -------------------------------------------------------------------------------- /archive/j/javascript/hello-world.js: -------------------------------------------------------------------------------- 1 | console.log("Hello, World!"); 2 | -------------------------------------------------------------------------------- /archive/j/javascript/quine.js: -------------------------------------------------------------------------------- 1 | (function(){console.log('('+arguments.callee.toString()+')();')})(); 2 | -------------------------------------------------------------------------------- /archive/j/javascript/remove-all-whitespace.js: -------------------------------------------------------------------------------- 1 | const die = () => { 2 | console.log("Usage: please provide a string"); 3 | process.exit(1); 4 | } 5 | 6 | if (process.argv.length != 3) { 7 | die(); 8 | } 9 | 10 | process.argv[2].length > 0 11 | ? console.log(process.argv[2].replace(/\s/g, '')) 12 | : die(); 13 | -------------------------------------------------------------------------------- /archive/j/javascript/reverse-string.js: -------------------------------------------------------------------------------- 1 | const reverse = s => s.split('').reverse().join(''); 2 | 3 | if (process.argv.length > 2) { 4 | console.log(reverse(process.argv[2])); 5 | } 6 | -------------------------------------------------------------------------------- /archive/j/javascript/testinfo.yml: -------------------------------------------------------------------------------- 1 | folder: 2 | extension: ".js" 3 | naming: "hyphen" 4 | 5 | container: 6 | image: "node" 7 | tag: "20-alpine" 8 | cmd: "node {{ source.name }}{{ source.extension }}" 9 | -------------------------------------------------------------------------------- /archive/j/julia/baklava.jl: -------------------------------------------------------------------------------- 1 | #!/usr/bin/julia 2 | 3 | function main() 4 | for i = 0:10 5 | print(" "^(10 - i)) 6 | println("*"^(i * 2 + 1)) 7 | end 8 | 9 | for i = 9:-1:0 10 | print(" "^(10 - i)) 11 | println("*"^(i * 2 + 1)) 12 | end 13 | end 14 | 15 | main() 16 | -------------------------------------------------------------------------------- /archive/j/julia/capitalize.jl: -------------------------------------------------------------------------------- 1 | #!/usr/bin/julia 2 | # Capitalize first character of the input string 3 | # Function to print Error message 4 | function err() 5 | println("Usage: please provide a string") 6 | end 7 | # Function to capitalize the input string 8 | function capitalize(n) 9 | if (length(n) in [0,1]) 10 | err() 11 | else 12 | println(uppercasefirst(n)) 13 | end 14 | end 15 | 16 | try 17 | capitalize(ARGS[1]) 18 | catch e 19 | err() 20 | end 21 | -------------------------------------------------------------------------------- /archive/j/julia/even-odd.jl: -------------------------------------------------------------------------------- 1 | 2 | #!/usr/bin/julia 3 | 4 | function err() 5 | println("Usage: please input a number") 6 | end 7 | 8 | function even_odd(n) 9 | 10 | if (n % 2 == 0 ) 11 | return "Even" 12 | else 13 | return "Odd" 14 | end 15 | end 16 | 17 | try 18 | println(even_odd(parse(Int, ARGS[1]))) 19 | catch e 20 | err() 21 | end 22 | -------------------------------------------------------------------------------- /archive/j/julia/factorial.jl: -------------------------------------------------------------------------------- 1 | #!/usr/bin/julia 2 | 3 | function err() 4 | println("Usage: please input a non-negative integer") 5 | end 6 | 7 | function fac(n) 8 | if n < 0 9 | err() 10 | exit() 11 | end 12 | 13 | out = 1 14 | for i = 1:n 15 | out = out * i 16 | end 17 | return out 18 | end 19 | 20 | try 21 | println(fac(parse(Int, ARGS[1]))) 22 | catch e 23 | err() 24 | end 25 | -------------------------------------------------------------------------------- /archive/j/julia/fibonacci.jl: -------------------------------------------------------------------------------- 1 | #!/usr/bin/julia 2 | 3 | function fib(n) 4 | f = BigInt[1 1; 1 0] 5 | for i = 1:n 6 | fn = f ^ i 7 | println(i, ": ", fn[2, 1]) 8 | end 9 | end 10 | 11 | function error() 12 | println("Usage: please input the count of fibonacci numbers to output") 13 | end 14 | 15 | try 16 | fib(parse(Int, ARGS[1])) 17 | catch e 18 | error() 19 | end 20 | 21 | -------------------------------------------------------------------------------- /archive/j/julia/file-input-output.jl: -------------------------------------------------------------------------------- 1 | function readfile(file) 2 | open(file) do f 3 | read(f, String) 4 | end 5 | end 6 | 7 | function writefile(file, text) 8 | open(file, "w") do f 9 | write(f, text) 10 | end 11 | end 12 | 13 | function main() 14 | writefile("output.txt", "Hello, world!") 15 | println(readfile("output.txt")) 16 | end 17 | 18 | main() -------------------------------------------------------------------------------- /archive/j/julia/fizz-buzz.jl: -------------------------------------------------------------------------------- 1 | #!/usr/bin/julia 2 | 3 | for i = 1:100 4 | str = i % 3 == 0 ? "Fizz" : "" 5 | str *= i % 5 == 0 ? "Buzz" : "" 6 | if isempty(str) 7 | str = i 8 | end 9 | println(str) 10 | end 11 | -------------------------------------------------------------------------------- /archive/j/julia/hello-world.jl: -------------------------------------------------------------------------------- 1 | println("Hello, World!") 2 | -------------------------------------------------------------------------------- /archive/j/julia/reverse-string.jl: -------------------------------------------------------------------------------- 1 | #!/usr/bin/julia 2 | # Reverse the Input String 3 | # Function to reverse the input string 4 | function reverse_string(n) 5 | println(reverse(n)) 6 | end 7 | 8 | if (length(ARGS) > 0) 9 | reverse_string(ARGS[1]) 10 | end 11 | -------------------------------------------------------------------------------- /archive/j/julia/testinfo.yml: -------------------------------------------------------------------------------- 1 | folder: 2 | extension: ".jl" 3 | naming: "hyphen" 4 | 5 | container: 6 | image: "julia" 7 | tag: "1.1" 8 | cmd: "julia {{ source.name }}{{ source.extension }}" 9 | -------------------------------------------------------------------------------- /archive/k/kitten/hello-world.ktn: -------------------------------------------------------------------------------- 1 | "Hello, World!" say 2 | -------------------------------------------------------------------------------- /archive/k/kitten/testinfo.yml: -------------------------------------------------------------------------------- 1 | folder: 2 | extension: ".ktn" 3 | naming: "hyphen" 4 | 5 | container: 6 | image: "rzuckerm/kitten" 7 | tag: "0.1.0.0-1" 8 | cmd: "kitten {{ source.name }}{{ source.extension }}" 9 | -------------------------------------------------------------------------------- /archive/k/koka/baklava.kk: -------------------------------------------------------------------------------- 1 | fun repeat_string(s : string, n : int) { 2 | var result := "" 3 | list(1, n).foreach(fn(_) { result := result + s }) 4 | result 5 | } 6 | 7 | fun main() { 8 | list(-10, 10).foreach(fn(n) { 9 | var num_spaces := abs(n) 10 | var num_stars := 21 - 2 * num_spaces 11 | println(repeat_string(" ", num_spaces) + repeat_string("*", num_stars)) 12 | }) 13 | } 14 | -------------------------------------------------------------------------------- /archive/k/koka/hello_world.kk: -------------------------------------------------------------------------------- 1 | fun main() 2 | { 3 | println("Hello, World!") 4 | } 5 | -------------------------------------------------------------------------------- /archive/k/koka/testinfo.yml: -------------------------------------------------------------------------------- 1 | folder: 2 | extension: ".kk" 3 | naming: "underscore" 4 | 5 | container: 6 | image: "kokalang/koka" 7 | tag: "v2.0.16" 8 | build: "koka -c {{ source.name }}{{ source.extension }} -o out" 9 | cmd: "./out/gcc-debug/{{ source.name | replace('_', '__') }}" 10 | -------------------------------------------------------------------------------- /archive/k/kotlin/Baklava.kt: -------------------------------------------------------------------------------- 1 | fun main (args: Array) 2 | { 3 | for (i in 0..9) 4 | println (" ".repeat (10 - i) + "*".repeat (i * 2 + 1)); 5 | 6 | for (i in 10 downTo 0) 7 | println (" ".repeat (10 - i) + "*".repeat (i * 2 + 1)); 8 | } 9 | -------------------------------------------------------------------------------- /archive/k/kotlin/Capitalize.kt: -------------------------------------------------------------------------------- 1 | fun main(args: Array) { 2 | if (args.isNullOrEmpty() || args[0].isBlank()) { 3 | println("Usage: please provide a string") 4 | } else { 5 | // Kotlin provides a simple `capitalize()` function in the standard 6 | // library for all String objects 7 | println(args[0].capitalize()) 8 | } 9 | } 10 | -------------------------------------------------------------------------------- /archive/k/kotlin/EvenOdd.kt: -------------------------------------------------------------------------------- 1 | fun main(args: Array) { 2 | if (args.isNullOrEmpty() || args[0].toIntOrNull() == null) { 3 | println("Usage: please input a number") 4 | return 5 | } 6 | val num = args[0].toInt() 7 | if (num % 2 == 0) { 8 | println("Even") 9 | } else { 10 | println("Odd") 11 | } 12 | } -------------------------------------------------------------------------------- /archive/k/kotlin/FizzBuzz.kt: -------------------------------------------------------------------------------- 1 | fun main(args: Array){ 2 | for (i in 1..100){ 3 | when { 4 | (i % 3 == 0 && i % 5 == 0) -> println("FizzBuzz") 5 | i % 3 == 0 -> println("Fizz") 6 | i % 5 == 0 -> println("Buzz") 7 | else -> println("$i") 8 | } 9 | } 10 | } -------------------------------------------------------------------------------- /archive/k/kotlin/HelloWorld.kt: -------------------------------------------------------------------------------- 1 | fun main(args: Array) { 2 | println("Hello, World!") 3 | } 4 | -------------------------------------------------------------------------------- /archive/k/kotlin/Quine.kt: -------------------------------------------------------------------------------- 1 | fun main(args: Array) { //Prints out it's own code 2 | val s = """fun main(args: Array) { //Prints out it's own code 3 | val s = """ 4 | 5 | val a = """^s\"\"\"^s\"\"\"\n\n\tval a = \"\"\"^a\"\"\"\n\tprint(\"^{a.replace(']' + 1, '$')}\")\n}\n""" 6 | print("$s\"\"\"$s\"\"\"\n\n\tval a = \"\"\"$a\"\"\"\n\tprint(\"${a.replace(']' + 1, '$')}\")\n}\n") 7 | } -------------------------------------------------------------------------------- /archive/k/kotlin/ReverseString.kt: -------------------------------------------------------------------------------- 1 | fun main(args: Array){ 2 | // Get input, or use default value 3 | val targetValue = when (args.size > 0 && !args[0].isNullOrBlank()) { 4 | true -> args[0] 5 | false -> "" 6 | } 7 | 8 | // Kotlin provides a simple `reversed()` function in the standard 9 | // library for all String/CharSequence objects 10 | println(targetValue.reversed()) 11 | } -------------------------------------------------------------------------------- /archive/k/kotlin/testinfo.yml: -------------------------------------------------------------------------------- 1 | folder: 2 | extension: ".kt" 3 | naming: "pascal" 4 | 5 | container: 6 | image: "zenika/kotlin" 7 | tag: "1.4.20" 8 | build: "kotlinc {{ source.name }}{{ source.extension }} -include-runtime -d {{ source.name }}.jar" 9 | cmd: "java -jar {{ source.name }}.jar" 10 | -------------------------------------------------------------------------------- /archive/l/latte/baklava.lt: -------------------------------------------------------------------------------- 1 | def printRepeatString(s:String, n:int) 2 | if n > 0 3 | for i in 1.to(n) 4 | print(s) 5 | 6 | for i in (-10).to(10) 7 | numSpaces:int = i 8 | if numSpaces < 0 9 | numSpaces = -numSpaces 10 | 11 | printRepeatString(" ", numSpaces) 12 | printRepeatString("*" , 21 - 2*numSpaces) 13 | println() 14 | -------------------------------------------------------------------------------- /archive/l/latte/hello-world.lt: -------------------------------------------------------------------------------- 1 | println('Hello, World!') 2 | -------------------------------------------------------------------------------- /archive/l/latte/testinfo.yml: -------------------------------------------------------------------------------- 1 | folder: 2 | extension: ".lt" 3 | naming: "hyphen" 4 | 5 | container: 6 | image: "rzuckerm/latte" 7 | tag: "0.0.10-1" 8 | cmd: "latte -s {{ source.name }}{{ source.extension }}" 9 | -------------------------------------------------------------------------------- /archive/l/lily/hello-world.lily: -------------------------------------------------------------------------------- 1 | "Hello, World!" |> print 2 | -------------------------------------------------------------------------------- /archive/l/lily/testinfo.yml: -------------------------------------------------------------------------------- 1 | folder: 2 | extension: ".lily" 3 | naming: "hyphen" 4 | 5 | container: 6 | image: "rzuckerm/lily" 7 | tag: "2.0-1" 8 | cmd: "lily {{ source.name }}{{ source.extension }}" 9 | -------------------------------------------------------------------------------- /archive/l/lisp/baklava.lsp: -------------------------------------------------------------------------------- 1 | (defparameter space_list '(#\space)) 2 | (defparameter star_list '(#\*)) 3 | (dotimes (run 9) 4 | (push #\space space_list)) 5 | (dotimes (run 10) 6 | (write-line (concatenate 'string space_list star_list)) 7 | (pop space_list) 8 | (push #\* star_list) 9 | (push #\* star_list) 10 | ) 11 | (dotimes (run 11) 12 | (write-line (concatenate 'string space_list star_list)) 13 | (pop star_list) 14 | (pop star_list) 15 | (push #\space space_list) 16 | ) -------------------------------------------------------------------------------- /archive/l/lisp/fizz-buzz.lsp: -------------------------------------------------------------------------------- 1 | (defun divides-by (num divisor) 2 | (= (mod num divisor) 0)) 3 | 4 | (dotimes (num 100) 5 | (write-line 6 | (cond 7 | ((and (divides-by (+ num 1) 3) (divides-by (+ num 1) 5)) "FizzBuzz") 8 | ((divides-by (+ num 1) 3) "Fizz") 9 | ((divides-by (+ num 1) 5) "Buzz") 10 | (t (write-to-string (+ num 1)))))) -------------------------------------------------------------------------------- /archive/l/lisp/hello-world.lsp: -------------------------------------------------------------------------------- 1 | (format t "Hello, World!") -------------------------------------------------------------------------------- /archive/l/lisp/reverse-string.lsp: -------------------------------------------------------------------------------- 1 | (defparameter input (cadr *posix-argv*)) 2 | (cond 3 | ((null input) ()) 4 | (t (write-line (reverse input))) 5 | ) 6 | -------------------------------------------------------------------------------- /archive/l/lisp/testinfo.yml: -------------------------------------------------------------------------------- 1 | folder: 2 | extension: ".lsp" 3 | naming: "hyphen" 4 | 5 | container: 6 | image: "daewok/lisp-devel" 7 | tag: "ql" 8 | cmd: "sbcl --script ./{{ source.name }}{{ source.extension }}" 9 | -------------------------------------------------------------------------------- /archive/l/little/baklava.l: -------------------------------------------------------------------------------- 1 | string repeat_string(string s, int n) { 2 | int i; 3 | string result = ""; 4 | for (i = 0; i < n; i++) { 5 | result[END + 1] = s; 6 | } 7 | 8 | return result; 9 | } 10 | 11 | int n, numSpaces, numStars; 12 | for (n = -10; n <= 10; n++) { 13 | numSpaces = abs(n); 14 | numStars = 21 - 2 * numSpaces; 15 | printf("%s%s\n", repeat_string(" ", numSpaces), repeat_string("*", numStars)); 16 | } 17 | -------------------------------------------------------------------------------- /archive/l/little/hello-world.l: -------------------------------------------------------------------------------- 1 | puts("Hello, World!"); 2 | -------------------------------------------------------------------------------- /archive/l/little/testinfo.yml: -------------------------------------------------------------------------------- 1 | folder: 2 | extension: ".l" 3 | naming: "hyphen" 4 | 5 | container: 6 | image: "rzuckerm/little" 7 | tag: "1.0-1" 8 | cmd: "L {{ source.name }}{{ source.extension }}" 9 | -------------------------------------------------------------------------------- /archive/l/livescript/baklava.ls: -------------------------------------------------------------------------------- 1 | for n from -10 to 10 2 | num_spaces = Math.abs(n) 3 | num_stars = 21 - 2 * num_spaces 4 | console.log ' '.repeat(num_spaces) + '*'.repeat(num_stars) 5 | -------------------------------------------------------------------------------- /archive/l/livescript/hello-world.ls: -------------------------------------------------------------------------------- 1 | console.log 'Hello, World!' 2 | -------------------------------------------------------------------------------- /archive/l/livescript/testinfo.yml: -------------------------------------------------------------------------------- 1 | folder: 2 | extension: ".ls" 3 | naming: "hyphen" 4 | 5 | container: 6 | image: "cromo/livescript" 7 | tag: "latest" 8 | cmd: "lsc {{ source.name }}{{ source.extension }}" 9 | -------------------------------------------------------------------------------- /archive/l/lobster/baklava.lobster: -------------------------------------------------------------------------------- 1 | for (21) n: 2 | let num_spaces = abs(n - 10) 3 | let num_stars = 21 - 2 * num_spaces 4 | let spaces = repeat_string(" ", num_spaces) 5 | let stars = repeat_string("*", num_stars) 6 | print "{spaces}{stars}" 7 | -------------------------------------------------------------------------------- /archive/l/lobster/hello-world.lobster: -------------------------------------------------------------------------------- 1 | print "Hello, World!" 2 | -------------------------------------------------------------------------------- /archive/l/lobster/testinfo.yml: -------------------------------------------------------------------------------- 1 | folder: 2 | extension: ".lobster" 3 | naming: "hyphen" 4 | 5 | container: 6 | image: "rzuckerm/lobster" 7 | tag: "2023.11-1" 8 | cmd: "lobster {{ source.name }}{{ source.extension }}" 9 | -------------------------------------------------------------------------------- /archive/l/lolcode/hello-world.lol: -------------------------------------------------------------------------------- 1 | HAI 1.2 2 | VISIBLE "Hello, World!" 3 | KTHXBYE 4 | -------------------------------------------------------------------------------- /archive/l/lolcode/testinfo.yml: -------------------------------------------------------------------------------- 1 | folder: 2 | extension: ".lol" 3 | naming: "hyphen" 4 | 5 | container: 6 | image: "esolang/lolcode" 7 | tag: "latest" 8 | cmd: "lolcode {{ source.name }}{{ source.extension }}" 9 | -------------------------------------------------------------------------------- /archive/l/lua/capitalize.lua: -------------------------------------------------------------------------------- 1 | if (#arg < 1 or arg[1] == '') 2 | then 3 | print('Usage: please provide a string') 4 | else 5 | str = {...} 6 | s = "" 7 | for i,v in pairs(str) do 8 | s = s .. v .. " " 9 | end 10 | s, _ = s:gsub("^%l", string.upper) 11 | print(s) 12 | end 13 | -------------------------------------------------------------------------------- /archive/l/lua/even-odd.lua: -------------------------------------------------------------------------------- 1 | main = function(input) 2 | usage = "Usage: please input a number" 3 | 4 | if tonumber(input) ~= nil then 5 | if input % 2 == 0 then 6 | print("Even") 7 | else 8 | print("Odd") 9 | end 10 | else 11 | print(usage) 12 | end 13 | end 14 | 15 | main(arg[1]) -------------------------------------------------------------------------------- /archive/l/lua/fibonacci.lua: -------------------------------------------------------------------------------- 1 | function fib(n) 2 | local a, b = 0, 1 3 | for k = 1, n do 4 | a, b = b, a + b 5 | print(k .. ": " .. a) 6 | end 7 | end 8 | 9 | if tonumber(arg[1]) ~= nil then 10 | n = tonumber(arg[1]) 11 | print(fib(n)) 12 | else 13 | print("Usage: please input the count of fibonacci numbers to output") 14 | end 15 | -------------------------------------------------------------------------------- /archive/l/lua/file-input-output.lua: -------------------------------------------------------------------------------- 1 | function writer() 2 | file_to_be_written = io.open("output.txt","w+") 3 | io.output(file_to_be_written) 4 | io.write("text to be written into output.txt") 5 | io.close(file_to_be_written) 6 | end 7 | 8 | 9 | function reader() 10 | file_to_be_read = io.open("output.txt","r") 11 | io.input(file_to_be_read) 12 | print(io.read()) 13 | io.close(file_to_be_read) 14 | end 15 | 16 | writer() 17 | reader() 18 | -------------------------------------------------------------------------------- /archive/l/lua/fizz-buzz.lua: -------------------------------------------------------------------------------- 1 | for i = 1, 100 do 2 | output = "" 3 | 4 | if i % 3 == 0 then 5 | output = output .. "Fizz" 6 | end 7 | 8 | if i % 5 == 0 then 9 | output = output .. "Buzz" 10 | end 11 | 12 | if output == "" then 13 | output = i 14 | end 15 | 16 | print(output) 17 | end 18 | -------------------------------------------------------------------------------- /archive/l/lua/hello-world.lua: -------------------------------------------------------------------------------- 1 | print("Hello, World!") 2 | -------------------------------------------------------------------------------- /archive/l/lua/reverse-string.lua: -------------------------------------------------------------------------------- 1 | if #arg > 0 then 2 | print(string.reverse(arg[1])) 3 | end 4 | -------------------------------------------------------------------------------- /archive/l/lua/testinfo.yml: -------------------------------------------------------------------------------- 1 | folder: 2 | extension: ".lua" 3 | naming: "hyphen" 4 | 5 | container: 6 | image: "nickblah/lua" 7 | tag: "5.4-alpine" 8 | cmd: "lua {{ source.name }}{{ source.extension }}" 9 | -------------------------------------------------------------------------------- /archive/l/lucee/baklava.cfm: -------------------------------------------------------------------------------- 1 | 2 | 3 | Baklava 4 | 5 | 6 | 

 7 | for (n = -10; n <= 10; n++) {
 8 |     numSpaces = abs(n);
 9 |     numStars = 21 - 2 * numSpaces;
10 |     spaces = repeatString(" ", numSpaces);
11 |     stars = repeatString("*", numStars);
12 |     writeOutput(spaces & stars & "
");
13 | }
14 |
15 | 16 | 17 | -------------------------------------------------------------------------------- /archive/l/lucee/hello-world.cfm: -------------------------------------------------------------------------------- 1 | 2 | 3 | My first page 4 | 5 | 6 | 7 | 
Hello, World!
8 | 9 | 10 | 11 | -------------------------------------------------------------------------------- /archive/l/lucee/testinfo.yml: -------------------------------------------------------------------------------- 1 | folder: 2 | extension: ".cfm" 3 | naming: "hyphen" 4 | 5 | container: 6 | image: "rzuckerm/lucee" 7 | tag: "5.4.4.38-3" 8 | cmd: "run_lucee {{ source.name }}{{ source.extension }}" 9 | -------------------------------------------------------------------------------- /archive/m/malbolge/hello-world.malbolge: -------------------------------------------------------------------------------- 1 | ('&%:9]!~}|z2Vxwv-,POqponl$Hjihf|B@@>,= {0, 0}] &[10] -------------------------------------------------------------------------------- /archive/m/mathematica/hello-world.nb: -------------------------------------------------------------------------------- 1 | Print["Hello, World!"]; 2 | -------------------------------------------------------------------------------- /archive/m/mathematica/quine.nb: -------------------------------------------------------------------------------- 1 | (* Code *) 2 | 3 | (* Credit to https://mathematica.stackexchange.com/a/6110/61814 for this answer: *) 4 | 5 | Print[ToString[#0][]] &[] 6 | -------------------------------------------------------------------------------- /archive/m/mathematica/untestable.yml: -------------------------------------------------------------------------------- 1 | - reason: "Mathematica requires a commercial license, so it cannot be tested" 2 | -------------------------------------------------------------------------------- /archive/m/mirth/hello-world.mth: -------------------------------------------------------------------------------- 1 | module sample-programs.hello-world 2 | 3 | import std.prelude 4 | import std.world 5 | 6 | def main { 7 | "Hello, World!" print 8 | } 9 | -------------------------------------------------------------------------------- /archive/m/modula2/HelloWorld.mod: -------------------------------------------------------------------------------- 1 | MODULE HelloWorld; 2 | 3 | FROM StrIO IMPORT WriteString, WriteLn; 4 | 5 | BEGIN 6 | WriteString('Hello, World!'); 7 | WriteLn; 8 | END HelloWorld. 9 | -------------------------------------------------------------------------------- /archive/m/modula2/testinfo.yml: -------------------------------------------------------------------------------- 1 | folder: 2 | extension: ".mod" 3 | naming: "pascal" 4 | 5 | container: 6 | image: "rzuckerm/modula2" 7 | tag: "11.4.0-1" 8 | build: "gm2 -fiso {{ source.name }}{{ source.extension }} -o {{ source.name }}" 9 | cmd: "./{{ source.name }}" 10 | -------------------------------------------------------------------------------- /archive/m/mojiscript/hello-world.mjs: -------------------------------------------------------------------------------- 1 | import log from 'mojiscript/console/log' 2 | import pipe from 'mojiscript/core/pipe' 3 | import run from 'mojiscript/core/run' 4 | 5 | const state = 'Hello, World!' 6 | 7 | const main = pipe ([ 8 | log 9 | ]) 10 | 11 | run ({ state, main }) -------------------------------------------------------------------------------- /archive/m/moonscript/baklava.moon: -------------------------------------------------------------------------------- 1 | string_repeat = (s, n) -> 2 | result = "" 3 | for i = 1, n 4 | result ..= s 5 | return result 6 | 7 | for i = -10, 10 8 | num_spaces = math.abs i 9 | num_stars = 21 - 2 * num_spaces 10 | print string_repeat(" ", num_spaces) .. string_repeat("*", num_stars) 11 | -------------------------------------------------------------------------------- /archive/m/moonscript/fizz-buzz.moon: -------------------------------------------------------------------------------- 1 | for i = 1, 100 2 | if i % 3 == 0 and i % 5 == 0 3 | print "FizzBuzz" 4 | continue 5 | if i % 3 == 0 6 | print "Fizz" 7 | continue 8 | if i % 5 == 0 9 | print "Buzz" 10 | continue 11 | else 12 | print i -------------------------------------------------------------------------------- /archive/m/moonscript/hello-world.moon: -------------------------------------------------------------------------------- 1 | print "Hello, World!" 2 | -------------------------------------------------------------------------------- /archive/m/moonscript/reverse-string.moon: -------------------------------------------------------------------------------- 1 | -- Function to reverse a string 2 | reverse_string = (str) -> 3 | if str == '' then return '' 4 | 5 | result = '' 6 | 7 | for i = #str, 1, -1 8 | result = result .. str\sub(i, i) 9 | 10 | return result 11 | 12 | -- Main executable section 13 | 14 | if not arg or #arg == 0 15 | print '' 16 | else 17 | input_str = arg[1] 18 | reversed_str = reverse_string(input_str) 19 | print reversed_str 20 | 21 | -------------------------------------------------------------------------------- /archive/m/moonscript/testinfo.yml: -------------------------------------------------------------------------------- 1 | folder: 2 | extension: ".moon" 3 | naming: "hyphen" 4 | 5 | container: 6 | image: "adamfgreen/moonscript" 7 | tag: "0.4" 8 | cmd: "moon {{ source.name }}{{ source.extension }}" 9 | -------------------------------------------------------------------------------- /archive/n/never/hello-world.nev: -------------------------------------------------------------------------------- 1 | func main() -> int { 2 | prints("Hello, World!\n"); 3 | 0 4 | } 5 | -------------------------------------------------------------------------------- /archive/n/never/reverse-string.nev: -------------------------------------------------------------------------------- 1 | func reverse(s: string) -> string 2 | { 3 | let n = length(s); 4 | (n > 0) ? s[n - 1 .. 0] : "" 5 | } 6 | 7 | func main(argv[argc]: string) -> int 8 | { 9 | let s = (argc > 0) ? argv[0] : ""; 10 | prints(reverse(s) + "\n"); 11 | 0 12 | } 13 | -------------------------------------------------------------------------------- /archive/n/never/testinfo.yml: -------------------------------------------------------------------------------- 1 | folder: 2 | extension: ".nev" 3 | naming: "hyphen" 4 | 5 | container: 6 | image: "rzuckerm/never" 7 | tag: "2.3.9-4" 8 | cmd: "never -f {{ source.name }}{{ source.extension }}" 9 | -------------------------------------------------------------------------------- /archive/n/nim/baklava.nim: -------------------------------------------------------------------------------- 1 | import strutils 2 | 3 | for n in -10..10: 4 | var numSpaces: int = abs(n) 5 | var numStars: int = 21 - 2 * numSpaces 6 | echo repeat(" ", numSpaces), repeat("*", numStars) 7 | -------------------------------------------------------------------------------- /archive/n/nim/fizz_buzz.nim: -------------------------------------------------------------------------------- 1 | for i in 1..100: 2 | if i mod 15 == 0: 3 | echo "FizzBuzz" 4 | elif i mod 5 == 0: 5 | echo "Buzz" 6 | elif i mod 3 == 0: 7 | echo "Fizz" 8 | else: 9 | echo i 10 | -------------------------------------------------------------------------------- /archive/n/nim/hello_world.nim: -------------------------------------------------------------------------------- 1 | echo "Hello, World!" 2 | -------------------------------------------------------------------------------- /archive/n/nim/reverse_string.nim: -------------------------------------------------------------------------------- 1 | # For reversing a string passed in as a parameter 2 | import os 3 | import strutils 4 | 5 | var text: string 6 | try: 7 | text = paramStr(1) 8 | except IndexError: 9 | quit(0) 10 | 11 | var reversed_text: string 12 | for i in countdown(len(text)-1, 0): 13 | reversed_text = reversed_text & text[i] 14 | 15 | echo reversed_text 16 | 17 | -------------------------------------------------------------------------------- /archive/n/nim/testinfo.yml: -------------------------------------------------------------------------------- 1 | folder: 2 | extension: ".nim" 3 | naming: "underscore" 4 | 5 | container: 6 | image: "nimlang/nim" 7 | tag: "1.0.0-alpine" 8 | build: "nim c {{ source.name }}{{ source.extension }}" 9 | cmd: "./{{ source.name }}" 10 | -------------------------------------------------------------------------------- /archive/n/nit/baklava.nit: -------------------------------------------------------------------------------- 1 | for n in [-10..10] do 2 | var num_spaces = n.abs 3 | var num_stars = 21 - 2 * num_spaces 4 | print " " * num_spaces + "*" * num_stars 5 | end 6 | -------------------------------------------------------------------------------- /archive/n/nit/hello_world.nit: -------------------------------------------------------------------------------- 1 | print "Hello, World!" 2 | -------------------------------------------------------------------------------- /archive/n/nit/testinfo.yml: -------------------------------------------------------------------------------- 1 | folder: 2 | extension: ".nit" 3 | naming: "underscore" 4 | 5 | container: 6 | image: "nitlang/nit" 7 | tag: "latest" 8 | cmd: "nit {{ source.name }}{{ source.extension }}" 9 | -------------------------------------------------------------------------------- /archive/o/objective-c/hello-world.m: -------------------------------------------------------------------------------- 1 | #import 2 | 3 | int main (int argc, const char * argv[]) 4 | { 5 | NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; 6 | NSString *s = @"Hello, World!"; 7 | printf("%s\n", [s UTF8String]); 8 | [pool drain]; 9 | return 0; 10 | } 11 | -------------------------------------------------------------------------------- /archive/o/objective-c/testinfo.yml: -------------------------------------------------------------------------------- 1 | folder: 2 | extension: ".m" 3 | naming: "hyphen" 4 | 5 | container: 6 | image: "rzuckerm/objective-c" 7 | tag: "11.4.0-1" 8 | build: "gcc -o {{ source.name }} {{ source.name }}{{ source.extension }} -I /usr/include/GNUstep -lgnustep-base -lobjc -fconstant-string-class=NSConstantString -fobjc-exceptions" 9 | cmd: "./{{ source.name }}" 10 | -------------------------------------------------------------------------------- /archive/o/ocaml/baklava.ml: -------------------------------------------------------------------------------- 1 | (** https://rosettacode.org/wiki/Repeat_a_string#OCaml **) 2 | let string_repeat n s = 3 | String.concat "" (Array.to_list (Array.make n s));; 4 | 5 | for n = -10 to 10 do 6 | let num_spaces = abs n in 7 | let num_stars = 21 - 2 * num_spaces in 8 | Printf.printf "%s%s\n" (string_repeat num_spaces " ") (string_repeat num_stars "*"); 9 | done 10 | -------------------------------------------------------------------------------- /archive/o/ocaml/fizz-buzz.ml: -------------------------------------------------------------------------------- 1 | let fizzbuzz i = 2 | if i mod 15 == 0 3 | then "FizzBuzz" 4 | else if i mod 5 == 0 5 | then "Buzz" 6 | else if i mod 3 == 0 7 | then "Fizz" 8 | else string_of_int i 9 | ;; 10 | 11 | for i = 1 to 100 do 12 | print_string (fizzbuzz(i) ^ "\n") 13 | done;; 14 | -------------------------------------------------------------------------------- /archive/o/ocaml/hello-world.ml: -------------------------------------------------------------------------------- 1 | print_string "Hello, World!\n";; 2 | -------------------------------------------------------------------------------- /archive/o/ocaml/testinfo.yml: -------------------------------------------------------------------------------- 1 | folder: 2 | extension: ".ml" 3 | naming: "hyphen" 4 | 5 | container: 6 | image: "ocaml/ocaml" 7 | tag: "centos-7" 8 | build: "ocamlc -o {{ source.name }} {{ source.name }}{{ source.extension }}" 9 | cmd: "./{{ source.name }}" 10 | -------------------------------------------------------------------------------- /archive/o/octave/baklava.m: -------------------------------------------------------------------------------- 1 | function baklava() 2 | for n = -10:10 3 | num_spaces = abs(n); 4 | num_stars = 21 - 2 * num_spaces; 5 | disp([repmat(' ', 1, num_spaces), repmat('*', 1, num_stars)]); 6 | end 7 | end 8 | -------------------------------------------------------------------------------- /archive/o/octave/capitalize.m: -------------------------------------------------------------------------------- 1 | function capitalize() 2 | usage = 'Usage: please provide a string'; 3 | arg_list = argv(); 4 | nargin = length(arg_list); 5 | if nargin == 0 6 | disp(usage); 7 | return; 8 | end 9 | 10 | string = arg_list{1}; 11 | if length(string) == 0 12 | disp(usage); 13 | return; 14 | end 15 | 16 | disp(strcat(upper(string(1:1)), string(2:end))); 17 | end 18 | -------------------------------------------------------------------------------- /archive/o/octave/hello_world.m: -------------------------------------------------------------------------------- 1 | disp('Hello, World!'); 2 | -------------------------------------------------------------------------------- /archive/o/octave/reverse_string.m: -------------------------------------------------------------------------------- 1 | function reverse_string() 2 | arg_list = argv(); 3 | nargin = length(arg_list); 4 | if nargin ~= 0 5 | disp(fliplr(arg_list{1})); 6 | end 7 | end 8 | -------------------------------------------------------------------------------- /archive/o/odin/baklava.odin: -------------------------------------------------------------------------------- 1 | package main; 2 | 3 | import "core:fmt" 4 | import "core:strings" 5 | 6 | main :: proc() { 7 | for i := -10; i <= 10; i += 1 { 8 | num_spaces := abs(i) 9 | num_stars := 21 - 2 * num_spaces 10 | spaces, _ := strings.repeat(" ", num_spaces) 11 | stars, _ := strings.repeat("*", num_stars) 12 | fmt.println(strings.concatenate({spaces, stars})) 13 | } 14 | } 15 | -------------------------------------------------------------------------------- /archive/o/odin/fizz-buzz.odin: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "core:fmt" 4 | 5 | main :: proc() { 6 | for i in 1..=100 { 7 | if i % 15 == 0 { 8 | fmt.println("FizzBuzz") 9 | } else if i % 5 == 0 { 10 | fmt.println("Buzz") 11 | } else if i % 3 == 0 { 12 | fmt.println("Fizz") 13 | } else { 14 | fmt.println(i) 15 | } 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /archive/o/odin/hello-world.odin: -------------------------------------------------------------------------------- 1 | package main; 2 | 3 | import "core:fmt"; 4 | 5 | main :: proc() { 6 | fmt.println("Hello, World!"); 7 | } 8 | -------------------------------------------------------------------------------- /archive/o/odin/reverse-string.odin: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "core:fmt" 4 | import "core:strings" 5 | import "core:os" 6 | 7 | reverse_string :: proc(str : string) { 8 | sb := strings.builder_make(0, len(str)) 9 | #reverse for ch in str { 10 | strings.write_rune(&sb, ch) 11 | } 12 | fmt.println(strings.to_string(sb)) 13 | } 14 | 15 | main :: proc() { 16 | if len(os.args) < 2 { 17 | return 18 | } 19 | reverse_string(os.args[1]) 20 | } 21 | -------------------------------------------------------------------------------- /archive/o/odin/testinfo.yml: -------------------------------------------------------------------------------- 1 | folder: 2 | extension: ".odin" 3 | naming: "hyphen" 4 | 5 | container: 6 | image: "rzuckerm/odin" 7 | tag: "2024-09-1" 8 | build: "odin build {{ source.name }}{{ source.extension }} -file -out:{{ source.name }}" 9 | cmd: "./{{ source.name }}" 10 | -------------------------------------------------------------------------------- /archive/o/opa/hello-world.opa: -------------------------------------------------------------------------------- 1 | function page() { 2 | 
Hello, World!
3 | } 4 | 5 | Server.start( 6 | Server.http, 7 | {~page, title: "SPEPL"} 8 | ) 9 | -------------------------------------------------------------------------------- /archive/o/opa/testinfo.yml: -------------------------------------------------------------------------------- 1 | folder: 2 | extension: ".opa" 3 | naming: "hyphen" 4 | 5 | container: 6 | image: "rzuckerm/opa" 7 | tag: "1.1.1-3" 8 | build: "opa {{ source.name }}{{ source.extension }}" 9 | cmd: "run_opa {{ source.name }}.js" 10 | -------------------------------------------------------------------------------- /archive/o/orc/baklava.orc: -------------------------------------------------------------------------------- 1 | def Baklava(start, end) = 2 | Ift(start <= end) >> 3 | Println(BaklavaLine(start)) >> 4 | Baklava(start + 1, end) 5 | 6 | def BaklavaLine(n) = 7 | val num_spaces = abs(n) 8 | val num_stars = 21 - 2 * num_spaces 9 | RepeatString(" ", num_spaces) + RepeatString("*", num_stars) 10 | 11 | def RepeatString(s, n) = if n <: 1 then "" else s + RepeatString(s, n - 1) 12 | 13 | Baklava(-10, 10) >> 14 | stop 15 | -------------------------------------------------------------------------------- /archive/o/orc/hello-world.orc: -------------------------------------------------------------------------------- 1 | Println("Hello, World!") >> 2 | stop 3 | -------------------------------------------------------------------------------- /archive/o/orc/testinfo.yml: -------------------------------------------------------------------------------- 1 | folder: 2 | extension: ".orc" 3 | naming: "hyphen" 4 | 5 | container: 6 | image: "rzuckerm/orc" 7 | tag: "2.1.2-1" 8 | cmd: "java -cp '/opt/orc/orc.jar:/opt/orc/lib/*' orc.Main {{ source.name }}{{ source.extension }}" 9 | -------------------------------------------------------------------------------- /archive/o/owl-lisp/hello-world.scm: -------------------------------------------------------------------------------- 1 | (λ (args) (print "Hello, World!")) 2 | -------------------------------------------------------------------------------- /archive/o/owl-lisp/testinfo.yml: -------------------------------------------------------------------------------- 1 | folder: 2 | extension: ".scm" 3 | naming: "hyphen" 4 | 5 | container: 6 | image: "rzuckerm/owl-lisp" 7 | tag: "0.2.1-1" 8 | build: "sh -c 'ol -o {{ source.name }}.c {{ source.name }}{{ source.extension }} && gcc -o {{ source.name }} {{ source.name }}.c'" 9 | cmd: "./{{ source.name }}" 10 | -------------------------------------------------------------------------------- /archive/p/pascal/capitalize.pas: -------------------------------------------------------------------------------- 1 | program Capitalise(input, output, stdErr); 2 | (* Accept a String from commandline, convert first character to upper case 3 | Pascal Strings begins with 1, not 0 4 | *) 5 | var 6 | buf: string; 7 | begin 8 | buf := paramStr(1); 9 | if buf = '' then 10 | writeln('Usage: please provide a string') 11 | else 12 | buf[1] := UpCase(buf[1]); 13 | writeln(buf); 14 | end. 15 | -------------------------------------------------------------------------------- /archive/p/pascal/fizz_buzz.pas: -------------------------------------------------------------------------------- 1 | program FizzBuzz(output); 2 | var 3 | i : integer; 4 | begin 5 | for i := 1 to 100 do 6 | if i mod 15 = 0 then 7 | writeln('FizzBuzz') 8 | else if i mod 3 = 0 then 9 | writeln('Fizz') 10 | else if i mod 5 = 0 then 11 | writeln('Buzz') 12 | else 13 | writeln(i) 14 | end. 15 | -------------------------------------------------------------------------------- /archive/p/pascal/hello_world.pas: -------------------------------------------------------------------------------- 1 | program HelloWorld(output); 2 | begin 3 | writeln('Hello, World!'); 4 | end. 5 | -------------------------------------------------------------------------------- /archive/p/pascal/reverse_string.pas: -------------------------------------------------------------------------------- 1 | program reversestring(input, output, stdErr); 2 | (*Accept a String from Command Line, Reverse it & Print it*) 3 | var 4 | i, j: Integer; 5 | buf, result: String; 6 | begin 7 | buf := paramStr(1); 8 | setlength(result,length(buf)); 9 | i:=1; 10 | j:=length(buf); 11 | while (i<=j) do 12 | begin 13 | result[i]:=buf[j-i+1]; 14 | inc(i); 15 | end; 16 | writeln(result); 17 | end. 18 | -------------------------------------------------------------------------------- /archive/p/pascal/testinfo.yml: -------------------------------------------------------------------------------- 1 | folder: 2 | extension: ".pas" 3 | naming: "underscore" 4 | 5 | container: 6 | image: "cyberdojofoundation/freepascal" 7 | tag: "5550730" 8 | build: "fpc {{ source.name }}{{ source.extension }}" 9 | cmd: "./{{ source.name }}" 10 | -------------------------------------------------------------------------------- /archive/p/perl/baklava.pl: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env perl 2 | use strict; 3 | use warnings; 4 | 5 | my $size = 10; 6 | 7 | for my $i (1..$size){ 8 | print " "x($size + 1 - $i), "*"x($i*2 - 1), "\n"; 9 | } 10 | 11 | for my $j (0..$size){ 12 | print " "x($j), "*"x($size*2 - $j*2 + 1), "\n"; 13 | } -------------------------------------------------------------------------------- /archive/p/perl/capitalize.pl: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env perl 2 | use strict; 3 | use warnings; 4 | 5 | # accept input as argument 6 | my ($string) = @ARGV; 7 | 8 | if (!defined $string || length $string == 0) { 9 | print "Usage: please provide a string\n"; 10 | exit; 11 | } 12 | 13 | print ucfirst $string, "\n"; 14 | -------------------------------------------------------------------------------- /archive/p/perl/even-odd.pl: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env perl 2 | use strict; 3 | use warnings; 4 | 5 | # accept input as argument 6 | my ($number) = @ARGV; 7 | 8 | if (!defined $number || $number !~ /^\-?\d+$/) { 9 | print "Usage: please input a number\n"; 10 | exit; 11 | } 12 | 13 | if ($number % 2 == 0) { 14 | print "Even\n"; 15 | } else { 16 | print "Odd\n"; 17 | } 18 | -------------------------------------------------------------------------------- /archive/p/perl/fizz-buzz.pl: -------------------------------------------------------------------------------- 1 | #!/usr/bin/perl 2 | # 3 | # FizzBuzz in Perl 4 | 5 | use strict; 6 | use warnings; 7 | use diagnostics; 8 | use 5.10.0; 9 | 10 | for my $n (1..100) { 11 | !($n % 15) ? say "FizzBuzz" : 12 | !($n % 3) ? say "Fizz" : 13 | !($n % 5) ? say "Buzz" : 14 | say "$n"; 15 | } 16 | -------------------------------------------------------------------------------- /archive/p/perl/hello-world.pl: -------------------------------------------------------------------------------- 1 | print "Hello, World!"; 2 | -------------------------------------------------------------------------------- /archive/p/perl/longest-word.pl: -------------------------------------------------------------------------------- 1 | #!/usr/bin/perl 2 | my $args = join(" ", @ARGV); 3 | if($args eq "" || $args eq " ") 4 | { 5 | die "Usage: please provide a string\n" 6 | } 7 | my $total = 0; 8 | my @storage = split(" ", $args); 9 | foreach my $loop (@storage) 10 | { 11 | if(length($loop) >= $total) 12 | { 13 | $total = length($loop); 14 | } 15 | } 16 | print $total; 17 | -------------------------------------------------------------------------------- /archive/p/perl/quine.pl: -------------------------------------------------------------------------------- 1 | $s='$s=%c%s%c;printf($s,39,$s,39,10);%c';printf($s,39,$s,39,10); 2 | -------------------------------------------------------------------------------- /archive/p/perl/reverse-string.pl: -------------------------------------------------------------------------------- 1 | 2 | my ($str) = @ARGV; 3 | 4 | if (defined $str) { 5 | print scalar reverse $str; 6 | } 7 | -------------------------------------------------------------------------------- /archive/p/perl/rot13.pl: -------------------------------------------------------------------------------- 1 | my ($str) = @ARGV; 2 | 3 | 4 | if (not defined $str or not length $str) { 5 | die "Usage: please provide a string to encrypt\n"; 6 | } 7 | 8 | $str =~ tr/ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz/NOPQRSTUVWXYZABCDEFGHIJKLMnopqrstuvwxyzabcdefghijklm/; 9 | print $str . "\n"; 10 | -------------------------------------------------------------------------------- /archive/p/perl/testinfo.yml: -------------------------------------------------------------------------------- 1 | folder: 2 | extension: ".pl" 3 | naming: "hyphen" 4 | 5 | container: 6 | image: "perl" 7 | tag: "5.28-slim" 8 | cmd: "perl {{ source.name }}{{ source.extension }}" 9 | -------------------------------------------------------------------------------- /archive/p/phix/baklava.exw: -------------------------------------------------------------------------------- 1 | for i=-10 to 10 do 2 | printf(1,"%s%s\n",{repeat(' ',abs(i)),repeat('*',21-abs(i)*2)}) 3 | end for 4 | -------------------------------------------------------------------------------- /archive/p/phix/hello_world.exw: -------------------------------------------------------------------------------- 1 | puts(1, "Hello, World!") 2 | -------------------------------------------------------------------------------- /archive/p/phix/testinfo.yml: -------------------------------------------------------------------------------- 1 | folder: 2 | extension: ".exw" 3 | naming: "underscore" 4 | 5 | container: 6 | image: "rzuckerm/phix" 7 | tag: "1.0.2-ubuntu22-1" 8 | cmd: "p {{ source.name }}{{ source.extension }} -" 9 | -------------------------------------------------------------------------------- /archive/p/php/baklava.php: -------------------------------------------------------------------------------- 1 | = 1; $x--) { 17 | $factorial = $factorial * $x; 18 | } 19 | 20 | echo ("$factorial\n"); 21 | -------------------------------------------------------------------------------- /archive/p/php/fibonacci.php: -------------------------------------------------------------------------------- 1 | %c'; printf($s,39,$s,39,10); ?> 2 | -------------------------------------------------------------------------------- /archive/p/php/remove-all-whitespace.php: -------------------------------------------------------------------------------- 1 | 1) { 3 | $input = $argv[1]; 4 | echo strrev($input); 5 | } 6 | -------------------------------------------------------------------------------- /archive/p/php/rot13.php: -------------------------------------------------------------------------------- 1 | N 0) 3 | (pack S (repeat_string S (- N 1))) 4 | "" 5 | ) 6 | ) 7 | 8 | (for X 21 9 | (setq N (- X 11)) 10 | (setq NSP (abs N)) 11 | (setq NST (- 21 (* 2 NSP))) 12 | (prinl (pack (repeat_string " " NSP) (repeat_string "*" NST))) 13 | ) 14 | (bye) 15 | -------------------------------------------------------------------------------- /archive/p/picolisp/hello-world.l: -------------------------------------------------------------------------------- 1 | (prinl "Hello, World!") 2 | (bye) 3 | -------------------------------------------------------------------------------- /archive/p/picolisp/reverse-string.l: -------------------------------------------------------------------------------- 1 | (let Str (argv A) 2 | (prinl 3 | (pack 4 | (reverse 5 | (chop A))))) 6 | (bye) 7 | -------------------------------------------------------------------------------- /archive/p/picolisp/testinfo.yml: -------------------------------------------------------------------------------- 1 | folder: 2 | extension: ".l" 3 | naming: "hyphen" 4 | 5 | container: 6 | image: "progit/pil-alpine-minimal" 7 | tag: "latest" 8 | cmd: "/picoLisp/pil {{ source.name }}{{ source.extension }}" 9 | -------------------------------------------------------------------------------- /archive/p/piet/baklava.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TheRenegadeCoder/sample-programs/3c57c7a8d3d3e59d4b158a437da9d709448e4948/archive/p/piet/baklava.png -------------------------------------------------------------------------------- /archive/p/piet/hello-world.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TheRenegadeCoder/sample-programs/3c57c7a8d3d3e59d4b158a437da9d709448e4948/archive/p/piet/hello-world.png -------------------------------------------------------------------------------- /archive/p/piet/testinfo.yml: -------------------------------------------------------------------------------- 1 | folder: 2 | extension: ".png" 3 | naming: "hyphen" 4 | 5 | container: 6 | image: "esolang/piet" 7 | tag: "latest" 8 | cmd: "piet {{ source.name }}{{source.extension}}" 9 | -------------------------------------------------------------------------------- /archive/p/pineapple/fizz-buzz.pine: -------------------------------------------------------------------------------- 1 | def .main 2 | let i mutable = 1 3 | while i <= 100 4 | if i % 15 == 0 5 | "FizzBuzz".show 6 | elif i % 3 == 0 7 | "Fizz".show 8 | elif i % 5 == 0 9 | "Buzz".show 10 | else 11 | i.show 12 | 13 | i = i + 1 14 | -------------------------------------------------------------------------------- /archive/p/pineapple/hello-world.pine: -------------------------------------------------------------------------------- 1 | def .main 2 | "Hello, World!".show 3 | -------------------------------------------------------------------------------- /archive/p/pineapple/testinfo.yml: -------------------------------------------------------------------------------- 1 | folder: 2 | extension: ".pine" 3 | naming: "hyphen" 4 | 5 | container: 6 | image: "rzuckerm/pineapple" 7 | tag: "0.0.7-1" 8 | cmd: "pine {{ source.name }}{{ source.extension }}" 9 | -------------------------------------------------------------------------------- /archive/p/pinecone/baklava.pn: -------------------------------------------------------------------------------- 1 | repeatStr :: {n: Int, c: String} -> {String}: ( 2 | s: "" 3 | i: 0 | i < in.n | i: i + 1 @ ( 4 | s: s + in.c 5 | ) 6 | 7 | s 8 | ) 9 | 10 | i: 0 - 10 | i <= 10 | i: i + 1 @ ( 11 | numSpaces: i 12 | i < 0 ? ( 13 | numSpaces: 0 - i 14 | ) 15 | print: (repeatStr: numSpaces, " ") + (repeatStr: 21 - 2 * numSpaces, "*") 16 | ) 17 | -------------------------------------------------------------------------------- /archive/p/pinecone/fizz_buzz.pn: -------------------------------------------------------------------------------- 1 | i: 1 | i <= 100 | i: i + 1 @ ( 2 | i % 15 = 0 ? ( 3 | print: "FizzBuzz" 4 | ) | 5 | i % 3 = 0 ? ( 6 | print: "Fizz" 7 | ) | 8 | i % 5 = 0 ? ( 9 | print: "Buzz" 10 | ) | ( 11 | print: i 12 | ) 13 | ) 14 | -------------------------------------------------------------------------------- /archive/p/pinecone/hello_world.pn: -------------------------------------------------------------------------------- 1 | print: "Hello, World!" 2 | -------------------------------------------------------------------------------- /archive/p/pinecone/testinfo.yml: -------------------------------------------------------------------------------- 1 | folder: 2 | extension: ".pn" 3 | naming: "underscore" 4 | 5 | container: 6 | image: "rzuckerm/pinecone" 7 | tag: "0.5.1-1" 8 | cmd: "pinecone {{ source.name }}{{ source.extension }}" 9 | -------------------------------------------------------------------------------- /archive/p/pony/fizz-buzz.pony: -------------------------------------------------------------------------------- 1 | use "collections" 2 | 3 | actor Main 4 | new create(env: Env) => 5 | for i in Range[I32](1, 101) do 6 | env.out.print(fizzbuzz(i)) 7 | end 8 | 9 | fun fizzbuzz(n: I32): String => 10 | if (n % 15) == 0 then 11 | "FizzBuzz" 12 | elseif (n % 5) == 0 then 13 | "Buzz" 14 | elseif (n % 3) == 0 then 15 | "Fizz" 16 | else 17 | n.string() 18 | end 19 | -------------------------------------------------------------------------------- /archive/p/pony/hello-world.pony: -------------------------------------------------------------------------------- 1 | actor Main 2 | new create(env: Env) => 3 | env.out.print("Hello, World!") 4 | -------------------------------------------------------------------------------- /archive/p/pony/testinfo.yml: -------------------------------------------------------------------------------- 1 | folder: 2 | extension: ".pony" 3 | naming: "hyphen" 4 | 5 | container: 6 | image: "ponylang/ponyc" 7 | tag: "0.55.1-alpine" 8 | build: "ponyc . --bin-name {{ source.name }}" 9 | cmd: "./{{ source.name }}" 10 | -------------------------------------------------------------------------------- /archive/p/powershell/Baklava.ps1: -------------------------------------------------------------------------------- 1 | for ($X = -10; $X -le 10; $X++) { 2 | $NumSpaces = [Math]::Abs($X) 3 | $Line = " " * $NumSpaces + "*" * (21 - 2 * $NumSpaces) 4 | Write-Output $Line 5 | } 6 | -------------------------------------------------------------------------------- /archive/p/powershell/Capitalize.ps1: -------------------------------------------------------------------------------- 1 | function Show-Usage() { 2 | Write-Host "Usage: please provide a string" 3 | Exit 1 4 | } 5 | 6 | function Get-Capitalize([string]$Str) { 7 | ([string]$Str[0]).ToUpper() + (-join $Str[1..$Str.Length]) 8 | } 9 | 10 | if ($args.Length -lt 1 -or -not $args[0]) { 11 | Show-Usage 12 | } 13 | 14 | Write-Host (Get-Capitalize $args[0]) 15 | -------------------------------------------------------------------------------- /archive/p/powershell/EvenOdd.ps1: -------------------------------------------------------------------------------- 1 | function Show-Usage() { 2 | Write-Host "Usage: please input a number" 3 | Exit 1 4 | } 5 | 6 | function Test-IsEven([int]$Value) { 7 | $Value % 2 -eq 0 8 | } 9 | 10 | if ($args.Length -lt 1) { 11 | Show-Usage 12 | } 13 | 14 | try { 15 | $Value = [int]::Parse($args[0]) 16 | } catch { 17 | Show-Usage 18 | } 19 | 20 | Write-Host ((Test-IsEven $Value) ? "Even" : "Odd") 21 | -------------------------------------------------------------------------------- /archive/p/powershell/HelloWorld.ps1: -------------------------------------------------------------------------------- 1 | Write-Host "Hello, World!" 2 | -------------------------------------------------------------------------------- /archive/p/powershell/LongestWord.ps1: -------------------------------------------------------------------------------- 1 | function Show-Usage() { 2 | Write-Host "Usage: please provide a string" 3 | Exit 1 4 | } 5 | 6 | function Get-LongestWord([string]$Str) { 7 | ($Str -split "\s+" | ForEach-Object { $_.Length } | Measure-Object -Maximum).Maximum 8 | } 9 | 10 | if ($args.Length -lt 1 -or -not $args[0]) { 11 | Show-Usage 12 | } 13 | 14 | Write-Host (Get-LongestWord $args[0]) 15 | -------------------------------------------------------------------------------- /archive/p/powershell/Quine.ps1: -------------------------------------------------------------------------------- 1 | $S='$S={0}{1}{0}{2}Write-Host ($S -f [string][char]39,$S,[string][char]10)' 2 | Write-Host ($S -f [string][char]39,$S,[string][char]10) 3 | -------------------------------------------------------------------------------- /archive/p/powershell/testinfo.yml: -------------------------------------------------------------------------------- 1 | folder: 2 | extension: ".ps1" 3 | naming: "pascal" 4 | 5 | container: 6 | image: "mcr.microsoft.com/powershell" 7 | tag: "7.5-alpine-3.20" 8 | cmd: "pwsh -file {{ source.name }}{{ source.extension }}" 9 | -------------------------------------------------------------------------------- /archive/p/prolog/baklava.pl: -------------------------------------------------------------------------------- 1 | :- initialization(main). 2 | 3 | baklava(N, NE) :- 4 | forall(between(N, NE, X), baklava_line(X)). 5 | 6 | baklava_line(N) :- 7 | NSP is abs(N), 8 | NST is 21 - 2 * NSP, 9 | output_repeat(" ", NSP), 10 | output_repeat("*", NST), 11 | nl. 12 | 13 | output_repeat(S, N) :- 14 | forall(between(1, N, _), write(S)). 15 | 16 | main() :- 17 | baklava(-10, 10), 18 | halt. 19 | -------------------------------------------------------------------------------- /archive/p/prolog/hello-world.pl: -------------------------------------------------------------------------------- 1 | :- initialization(main). 2 | main():- 3 | write("Hello, World!\n"), 4 | halt. 5 | -------------------------------------------------------------------------------- /archive/p/prolog/testinfo.yml: -------------------------------------------------------------------------------- 1 | folder: 2 | extension: ".pl" 3 | naming: "hyphen" 4 | 5 | container: 6 | image: "swipl" 7 | tag: "stable" 8 | cmd: "swipl -s {{ source.name }}{{ source.extension }}" -------------------------------------------------------------------------------- /archive/p/purescript/hello-world.purs: -------------------------------------------------------------------------------- 1 | module Main where 2 | 3 | import Prelude 4 | import Effect (Effect) 5 | import Effect.Console (log) 6 | 7 | main :: Effect Unit 8 | main = do 9 | log "Hello, World!" 10 | -------------------------------------------------------------------------------- /archive/p/pyret/baklava.arr: -------------------------------------------------------------------------------- 1 | fun print-row(n :: Number): 2 | spaces = string-repeat(" ", 10 - n) 3 | stars = string-repeat("*", (n * 2) + 1) 4 | print(spaces + stars + "\n") 5 | end 6 | 7 | range-by(0, 11, 1).each(print-row) 8 | range-by(9, -1, -1).each(print-row) -------------------------------------------------------------------------------- /archive/p/pyret/even-odd.arr: -------------------------------------------------------------------------------- 1 | import cmdline-lib as CL 2 | 3 | usage = "Usage: please input a number\n" 4 | args = CL.command-line-arguments() 5 | cases(Option) string-to-number(if args.length() > 1: args.get(1) else: "" end): 6 | | none => print(usage) 7 | | some(n) => 8 | if not(num-is-integer(n)): print(usage) 9 | else if num-modulo(n, 2) == 0: print("Even\n") 10 | else: print("Odd\n") 11 | end 12 | end 13 | -------------------------------------------------------------------------------- /archive/p/pyret/hello-world.arr: -------------------------------------------------------------------------------- 1 | print("Hello, World!") 2 | -------------------------------------------------------------------------------- /archive/p/pyret/testinfo.yml: -------------------------------------------------------------------------------- 1 | folder: 2 | extension: ".arr" 3 | naming: "hyphen" 4 | 5 | container: 6 | image: "rzuckerm/pyret" 7 | tag: "0.0.27-2" 8 | build: "pyret -qkc {{ source.name }}{{ source.extension }}" 9 | cmd: "node {{ source.name }}.jarr" 10 | -------------------------------------------------------------------------------- /archive/p/python/baklava.py: -------------------------------------------------------------------------------- 1 | for i in range(0, 10, 1): 2 | print((" " * (10 - i)) + ("*" * (i * 2 + 1))) 3 | 4 | for i in range(10, -1, -1): 5 | print((" " * (10 - i)) + ("*" * (i * 2 + 1))) 6 | -------------------------------------------------------------------------------- /archive/p/python/capitalize.py: -------------------------------------------------------------------------------- 1 | import sys 2 | 3 | 4 | def capitalize(input): 5 | if len(input) > 0: 6 | print(input[0].capitalize() + input[1:]) 7 | 8 | 9 | if __name__ == '__main__': 10 | if(len(sys.argv) == 1 or len(sys.argv[1]) == 0): 11 | print('Usage: please provide a string') 12 | else: 13 | capitalize(sys.argv[1]) 14 | -------------------------------------------------------------------------------- /archive/p/python/even_odd.py: -------------------------------------------------------------------------------- 1 | import sys 2 | 3 | 4 | def even_odd(x): 5 | return "Even" if x % 2 == 0 else "Odd" 6 | 7 | 8 | def exit_with_error(): 9 | print('Usage: please input a number') 10 | sys.exit(1) 11 | 12 | 13 | def main(args): 14 | try: 15 | num = int(args[0]) 16 | print(even_odd(num)) 17 | except (IndexError, ValueError): 18 | exit_with_error() 19 | 20 | 21 | if __name__ == "__main__": 22 | main(sys.argv[1:]) 23 | -------------------------------------------------------------------------------- /archive/p/python/fizz_buzz.py: -------------------------------------------------------------------------------- 1 | for n in range(1, 101): 2 | if n % 3 == 0: 3 | print("FizzBuzz" if n % 5 == 0 else "Fizz") 4 | continue 5 | print("Buzz" if n % 5 == 0 else n) 6 | -------------------------------------------------------------------------------- /archive/p/python/hello_world.py: -------------------------------------------------------------------------------- 1 | print('Hello, World!') 2 | -------------------------------------------------------------------------------- /archive/p/python/longest_word.py: -------------------------------------------------------------------------------- 1 | import sys 2 | 3 | error = "Usage: please provide a string" 4 | 5 | if len(sys.argv) == 1 or sys.argv[1] == "": 6 | print(error) 7 | sys.exit(1) 8 | 9 | input_string = sys.argv[1] 10 | longest_word = max(len(word) for word in input_string.split()) 11 | print(longest_word) 12 | -------------------------------------------------------------------------------- /archive/p/python/quine.py: -------------------------------------------------------------------------------- 1 | s='s=%r;print(s%%s)';print(s%s) 2 | -------------------------------------------------------------------------------- /archive/p/python/remove_all_whitespace.py: -------------------------------------------------------------------------------- 1 | import sys 2 | 3 | error = "Usage: please provide a string" 4 | 5 | if len(sys.argv) == 1 or sys.argv[1] == "": 6 | print(error) 7 | sys.exit(1) 8 | 9 | input_string = sys.argv[1] 10 | print("".join(input_string.split())) 11 | -------------------------------------------------------------------------------- /archive/p/python/reverse_string.py: -------------------------------------------------------------------------------- 1 | import sys 2 | 3 | if len(sys.argv) > 1: 4 | print(sys.argv[1][::-1]) 5 | -------------------------------------------------------------------------------- /archive/p/python/testinfo.yml: -------------------------------------------------------------------------------- 1 | folder: 2 | extension: ".py" 3 | naming: "underscore" 4 | 5 | container: 6 | image: "python" 7 | tag: "3.12-alpine" 8 | cmd: "python {{ source.name }}{{ source.extension }}" 9 | -------------------------------------------------------------------------------- /archive/q/quackery/baklava.qky: -------------------------------------------------------------------------------- 1 | 21 times [ 2 | i^ 10 - abs dup 3 | times [ say " " ] 4 | -2 * 21 + times [ say "*" ] 5 | cr 6 | ] 7 | -------------------------------------------------------------------------------- /archive/q/quackery/hello-world.qky: -------------------------------------------------------------------------------- 1 | say "Hello, World!" 2 | -------------------------------------------------------------------------------- /archive/q/quackery/testinfo.yml: -------------------------------------------------------------------------------- 1 | folder: 2 | extension: ".qky" 3 | naming: "hyphen" 4 | 5 | container: 6 | image: "rzuckerm/quackery" 7 | tag: "2024.10.22-2" 8 | cmd: "run_quackery {{ source.name }}{{ source.extension }}" 9 | -------------------------------------------------------------------------------- /archive/r/r/baklava.R: -------------------------------------------------------------------------------- 1 | for (i in -10:10) { 2 | numSpaces = abs(i) 3 | s <- strrep(" ", numSpaces) 4 | s = paste0(s, strrep("*", 21 - 2 * numSpaces)) 5 | cat(s, "\n", sep="") 6 | } 7 | -------------------------------------------------------------------------------- /archive/r/r/even-odd.R: -------------------------------------------------------------------------------- 1 | args<-commandArgs(TRUE) 2 | number = args[1] 3 | 4 | if (length(args) < 1 || !suppressWarnings(!is.na(as.numeric(number)))) { 5 | cat("Usage: please input a number") 6 | }else { 7 | number = as.numeric(number) 8 | if (number %% 2 == 0) { 9 | cat("Even") 10 | }else { 11 | cat("Odd") 12 | } 13 | } 14 | -------------------------------------------------------------------------------- /archive/r/r/fizz-buzz.R: -------------------------------------------------------------------------------- 1 | fizz_buzz <- function(){ 2 | for (x in 1:100){ 3 | out<-'' 4 | mod3<- x%%3==0 5 | mod5 <- x%%5==0 6 | if (!mod3 && !mod5){ 7 | out=x 8 | } 9 | if (mod3){ 10 | out='Fizz' 11 | } 12 | if (mod5){ 13 | out=paste0(out,'Buzz') 14 | } 15 | cat(out, "\n") 16 | } 17 | } 18 | 19 | fizz_buzz() 20 | -------------------------------------------------------------------------------- /archive/r/r/hello-world.R: -------------------------------------------------------------------------------- 1 | cat("Hello, World!") 2 | -------------------------------------------------------------------------------- /archive/r/r/longest-word.R: -------------------------------------------------------------------------------- 1 | longest_word_length <- function(input_string) { 2 | # Checking input 3 | args <- commandArgs(trailingOnly = TRUE) 4 | 5 | if (length(args) == 0 || args == "") { 6 | cat("Usage: please provide a string\n") 7 | } else { 8 | # Split the string by whitespace and find the maximum word length in one line 9 | cat(max(nchar(unlist(strsplit(args[1], "[ \t\n\r]+")))), "\n") 10 | } 11 | } 12 | 13 | longest_word_length() -------------------------------------------------------------------------------- /archive/r/r/reverse-string.R: -------------------------------------------------------------------------------- 1 | args<- commandArgs(TRUE) 2 | if(length(args) > 0 ){ 3 | if (args[1] != ""){ 4 | splits <- strsplit(args, "")[[1]] 5 | reversed <- rev(splits) 6 | reversed <-as.character(rev(splits)) 7 | j <- paste(reversed, collapse = '') 8 | cat(noquote(j)) 9 | } 10 | } 11 | -------------------------------------------------------------------------------- /archive/r/r/testinfo.yml: -------------------------------------------------------------------------------- 1 | folder: 2 | extension: ".R" 3 | naming: "hyphen" 4 | 5 | container: 6 | image: "r-base" 7 | tag: "4.3.0" 8 | cmd: "Rscript {{ source.name }}{{ source.extension }}" 9 | -------------------------------------------------------------------------------- /archive/r/racket/baklava.rkt: -------------------------------------------------------------------------------- 1 | #lang racket 2 | (for ([i (in-range -10 11)]) 3 | (define numSpaces (abs i)) 4 | (define numStars (- 21 (* numSpaces 2))) 5 | (define s (make-string numSpaces #\ )) 6 | (define t (make-string numStars #\*)) 7 | (printf "~a~a\n" s t) 8 | ) 9 | -------------------------------------------------------------------------------- /archive/r/racket/fizz-buzz.rkt: -------------------------------------------------------------------------------- 1 | ;fizzbuzz in racket 2 | ;Author: Emblazion 3 | 4 | #lang racket 5 | (for ([i (in-range 1 101)]) 6 | (cond 7 | [(and 8 | (equal? 0 (modulo i 3)) 9 | (equal? 0 (modulo i 5))) 10 | (printf "FizzBuzz\n")] 11 | [(equal? 0 (modulo i 3)) (printf "Fizz\n")] 12 | [(equal? 0 (modulo i 5)) (printf "Buzz\n")] 13 | [else (printf "~a\n" i)])) 14 | -------------------------------------------------------------------------------- /archive/r/racket/hello-world.rkt: -------------------------------------------------------------------------------- 1 | #lang racket/base 2 | "Hello, World!" 3 | -------------------------------------------------------------------------------- /archive/r/racket/testinfo.yml: -------------------------------------------------------------------------------- 1 | folder: 2 | extension: ".rkt" 3 | naming: "hyphen" 4 | 5 | container: 6 | image: "racket/racket" 7 | tag: "8.2" 8 | cmd: "racket {{ source.name }}{{ source.extension }}" 9 | -------------------------------------------------------------------------------- /archive/r/raku/baklava.raku: -------------------------------------------------------------------------------- 1 | for -10 .. 10 { 2 | my $numSpaces = $_.abs; 3 | say (" " x $numSpaces) ~ ("*" x (21 - 2 * $numSpaces)); 4 | } 5 | -------------------------------------------------------------------------------- /archive/r/raku/fizz_buzz.raku: -------------------------------------------------------------------------------- 1 | for 1..100 -> $i { 2 | if $i % 3 == 0 && $i % 5 == 0 { 3 | say "FizzBuzz" 4 | } 5 | elsif $i % 5 == 0 { 6 | say "Buzz" 7 | } 8 | elsif $i % 3 == 0 { 9 | say "Fizz" 10 | } 11 | else { 12 | say $i 13 | } 14 | } -------------------------------------------------------------------------------- /archive/r/raku/hello_world.raku: -------------------------------------------------------------------------------- 1 | say 'Hello, World!' 2 | -------------------------------------------------------------------------------- /archive/r/raku/testinfo.yml: -------------------------------------------------------------------------------- 1 | folder: 2 | extension: ".raku" 3 | naming: "underscore" 4 | 5 | container: 6 | image: "rakudo-star" 7 | tag: "alpine" 8 | cmd: "raku {{ source.name }}{{ source.extension }}" 9 | -------------------------------------------------------------------------------- /archive/r/red/baklava.red: -------------------------------------------------------------------------------- 1 | Red [Title: "Bakalava"] 2 | 3 | s: "" 4 | repeat i 21 [ 5 | numSpaces: i - 11 6 | if numSpaces < 0 [numSpaces: 0 - numSpaces] 7 | clear s 8 | insert/dup tail s " " numSpaces 9 | insert/dup tail s "*" (21 - (2 * numSpaces)) 10 | print s 11 | ] 12 | -------------------------------------------------------------------------------- /archive/r/red/fizz-buzz.red: -------------------------------------------------------------------------------- 1 | ; Source: https://rosettacode.org/wiki/FizzBuzz#Red 2 | Red [Title: "FizzBuzz"] 3 | 4 | repeat i 100 [ 5 | print case [ 6 | i % 15 = 0 ["FizzBuzz"] 7 | i % 5 = 0 ["Buzz"] 8 | i % 3 = 0 ["Fizz"] 9 | true [i] 10 | ] 11 | ] 12 | -------------------------------------------------------------------------------- /archive/r/red/hello-world.red: -------------------------------------------------------------------------------- 1 | Red [Title: "Hello World in Red"] 2 | 3 | print "Hello, World!" 4 | -------------------------------------------------------------------------------- /archive/r/red/testinfo.yml: -------------------------------------------------------------------------------- 1 | folder: 2 | extension: ".red" 3 | naming: "hyphen" 4 | 5 | container: 6 | image: "rebolek/red" 7 | tag: "latest" 8 | cmd: "red {{ source.name }}{{ source.extension }}" 9 | -------------------------------------------------------------------------------- /archive/r/rexx/baklava.rexx: -------------------------------------------------------------------------------- 1 | do i = -10 to 10 2 | numSpaces = abs(i) 3 | say strRepeat(numSpaces, " ") || strRepeat(21 - 2 * numSpaces, "*") 4 | end 5 | 6 | strRepeat: 7 | arg n, s 8 | result = "" 9 | do while n > 0 10 | result = result || s 11 | n = n - 1 12 | end 13 | 14 | return result 15 | -------------------------------------------------------------------------------- /archive/r/rexx/even-odd.rexx: -------------------------------------------------------------------------------- 1 | /* ARG with source string named in REXX program invocation */ 2 | arg number 3 | If (DATATYPE(number, 'W') == 0) then signal err 4 | if (number // 2 == 0) then 5 | say "Even" 6 | else 7 | say "Odd" 8 | ;exit 9 | 10 | Err: 11 | say 'Usage: please input a number'; exit 12 | -------------------------------------------------------------------------------- /archive/r/rexx/hello-world.rexx: -------------------------------------------------------------------------------- 1 | say "Hello, World!" 2 | -------------------------------------------------------------------------------- /archive/r/rexx/reverse-string.rexx: -------------------------------------------------------------------------------- 1 | /* Reverse-String */ 2 | 3 | parse arg inputString 4 | if inputString = "" then exit /* exits right away if there is no input! */ 5 | 6 | say reverseString(inputString) 7 | exit 8 | 9 | reverseString: 10 | parse arg str 11 | length = length(str) 12 | reversed = "" 13 | 14 | do i = length to 1 by -1 15 | reversed = reversed || substr(str, i, 1) 16 | end 17 | 18 | return reversed 19 | /* Req: Hello, World Expected Res: dlroW ,olleH */ 20 | -------------------------------------------------------------------------------- /archive/r/rexx/testinfo.yml: -------------------------------------------------------------------------------- 1 | folder: 2 | extension: ".rexx" 3 | naming: "hyphen" 4 | 5 | container: 6 | image: "rzuckerm/rexx" 7 | tag: "3.6-5.00-1" 8 | cmd: "rexx ./{{ source.name }}{{ source.extension }}" 9 | -------------------------------------------------------------------------------- /archive/r/ring/Baklava.ring: -------------------------------------------------------------------------------- 1 | for i = -10 to 10 2 | numSpaces = fabs(i) 3 | see copy(" ", numSpaces) + copy("*", 21 - 2 * numSpaces) + nl 4 | next 5 | -------------------------------------------------------------------------------- /archive/r/ring/HelloWorld.ring: -------------------------------------------------------------------------------- 1 | see "Hello, World!" 2 | -------------------------------------------------------------------------------- /archive/r/ring/testinfo.yml: -------------------------------------------------------------------------------- 1 | folder: 2 | extension: ".ring" 3 | naming: "pascal" 4 | 5 | container: 6 | image: "esolang/ring" 7 | tag: "latest" 8 | cmd: "ring {{ source.name }}{{ source.extension }}" 9 | -------------------------------------------------------------------------------- /archive/r/ruby/baklava.rb: -------------------------------------------------------------------------------- 1 | 10.times {|n| 2 | print " " * (10 - n) 3 | puts "*" * (2 * n + 1) 4 | } 5 | 6 | for i in 10.downto(0) do 7 | puts ((" " * (10 - i)) + ("*" * (i * 2 + 1))) 8 | end 9 | -------------------------------------------------------------------------------- /archive/r/ruby/capitalize.rb: -------------------------------------------------------------------------------- 1 | def capitalize_str(str) 2 | s = str.split(' ') 3 | s[0][0] = s[0][0].upcase 4 | s.join(' ') 5 | end 6 | 7 | if ARGV.length == 0 || ARGV[0] == '' 8 | puts 'Usage: please provide a string' 9 | else 10 | puts capitalize_str(ARGV[0]) 11 | end 12 | -------------------------------------------------------------------------------- /archive/r/ruby/fibonacci.rb: -------------------------------------------------------------------------------- 1 | def fibonacci(number) 2 | a = 0 3 | b = 1 4 | c = 0 5 | 6 | i = 0 7 | while i < number 8 | c = a + b 9 | b = a 10 | a = c 11 | 12 | print("#{i+1}: #{c}\n") 13 | i += 1 14 | end 15 | end 16 | 17 | num = Integer(ARGV[0]) rescue -1 18 | if num >= 0 19 | fibonacci(num) 20 | else 21 | print("Usage: please input the count of fibonacci numbers to output") 22 | end -------------------------------------------------------------------------------- /archive/r/ruby/file-input-output.rb: -------------------------------------------------------------------------------- 1 | def write_file 2 | out = File.new("output.txt", "w") 3 | 4 | out << "This is a line written by a Ruby program\n" 5 | out << "This line also" 6 | 7 | out.flush() 8 | out.close() 9 | end 10 | 11 | 12 | def read_file 13 | in_file = File.open("output.txt", "r") 14 | 15 | in_file.each_line do |line| 16 | puts line 17 | end 18 | 19 | in_file.close() 20 | end 21 | 22 | write_file() 23 | read_file() -------------------------------------------------------------------------------- /archive/r/ruby/fizz-buzz.rb: -------------------------------------------------------------------------------- 1 | def fizzbuzz(number) 2 | divisibleBy3 = (number % 3 == 0) 3 | divisibleBy5 = (number % 5 == 0) 4 | 5 | case 6 | when divisibleBy3 && divisibleBy5 7 | puts "FizzBuzz" 8 | when divisibleBy3 9 | puts "Fizz" 10 | when divisibleBy5 11 | puts "Buzz" 12 | else 13 | puts number 14 | end 15 | end 16 | 17 | (1..100).each {|n| fizzbuzz n} 18 | -------------------------------------------------------------------------------- /archive/r/ruby/hello-world.rb: -------------------------------------------------------------------------------- 1 | puts 'Hello, World!' 2 | -------------------------------------------------------------------------------- /archive/r/ruby/longest-word.rb: -------------------------------------------------------------------------------- 1 | input_str = ARGV.join(" ").strip 2 | 3 | if input_str.empty? 4 | puts "Usage: please provide a string" 5 | exit 6 | end 7 | 8 | words = input_str.split 9 | max_length = 0 10 | 11 | words.each do |word| 12 | if word.length > max_length 13 | max_length = word.length 14 | end 15 | end 16 | 17 | puts max_length 18 | -------------------------------------------------------------------------------- /archive/r/ruby/quine.rb: -------------------------------------------------------------------------------- 1 | s="s=%c%s%c; printf s,34,s,34,10%c"; printf s,34,s,34,10 2 | -------------------------------------------------------------------------------- /archive/r/ruby/remove-all-whitespace.rb: -------------------------------------------------------------------------------- 1 | if ARGV.length == 0 || ARGV[0] == '' 2 | puts 'Usage: please provide a string' 3 | else 4 | a = ARGV[0].gsub(/ /, '').gsub(/\t/, '').gsub(/\r/, '').gsub(/\n/, '') 5 | puts a 6 | end 7 | -------------------------------------------------------------------------------- /archive/r/ruby/reverse-string.rb: -------------------------------------------------------------------------------- 1 | if ARGV.length >= 1 2 | string = ARGV[0] 3 | 4 | puts string.reverse 5 | end -------------------------------------------------------------------------------- /archive/r/ruby/testinfo.yml: -------------------------------------------------------------------------------- 1 | folder: 2 | extension: ".rb" 3 | naming: "hyphen" 4 | 5 | container: 6 | image: "ruby" 7 | tag: "2-alpine" 8 | cmd: "ruby {{ source.name }}{{ source.extension }}" 9 | -------------------------------------------------------------------------------- /archive/r/rust/baklava.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | for i in -10i32..11i32 { 3 | let num_spaces: usize = i.abs() as usize; 4 | println!("{}{}", " ".repeat(num_spaces), "*".repeat(21 - 2 * num_spaces)); 5 | } 6 | } 7 | -------------------------------------------------------------------------------- /archive/r/rust/fizz-buzz.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | for number in 1..101 { 3 | if number % 3 == 0 && number % 5 == 0 { 4 | println!("FizzBuzz"); 5 | } else if number % 3 == 0 { 6 | println!("Fizz"); 7 | } else if number % 5 == 0 { 8 | println!("Buzz"); 9 | } else { 10 | println!("{}", number); 11 | } 12 | } 13 | } 14 | -------------------------------------------------------------------------------- /archive/r/rust/hello-world.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | println!("Hello, World!"); 3 | } 4 | -------------------------------------------------------------------------------- /archive/r/rust/quine.rs: -------------------------------------------------------------------------------- 1 | fn main(){println!("fn main(){{println!({0:?},{0:?})}}","fn main(){{println!({0:?},{0:?})}}")} 2 | -------------------------------------------------------------------------------- /archive/r/rust/reverse-string.rs: -------------------------------------------------------------------------------- 1 | use std::env; 2 | 3 | fn main() { 4 | let mut strings: Vec = env::args().collect(); 5 | strings.remove(0); //Removes path to executable from argument vector. 6 | for string in &strings { 7 | println!("{}", string.chars().rev().collect::()); 8 | } 9 | } 10 | -------------------------------------------------------------------------------- /archive/r/rust/testinfo.yml: -------------------------------------------------------------------------------- 1 | folder: 2 | extension: ".rs" 3 | naming: "hyphen" 4 | 5 | container: 6 | image: "rust" 7 | tag: "1.68.2-alpine3.17" 8 | build: "rustc {{ source.name }}{{ source.extension }}" 9 | cmd: "./{{ source.name }}" 10 | -------------------------------------------------------------------------------- /archive/s/sather/hello-world.sa: -------------------------------------------------------------------------------- 1 | class HELLO_WORLD is 2 | main is 3 | #OUT+"Hello, World!"; 4 | end; 5 | end; 6 | -------------------------------------------------------------------------------- /archive/s/sather/testinfo.yml: -------------------------------------------------------------------------------- 1 | folder: 2 | extension: ".sa" 3 | naming: "hyphen" 4 | 5 | container: 6 | image: "rzuckerm/sather" 7 | tag: "1.2.3-1" 8 | build: "sacomp -main {{ source.name | replace('-', '_') | upper }} -o {{ source.name }} {{ source.name }}{{ source.extension}}" 9 | cmd: "./{{ source.name }}" 10 | -------------------------------------------------------------------------------- /archive/s/scala/Baklava.scala: -------------------------------------------------------------------------------- 1 | import scala.math.abs 2 | 3 | object Baklava { 4 | def main(args: Array[String]): Unit = { 5 | for (i <- -10.until(11)) { 6 | var numSpaces = abs(i) 7 | println(" " * numSpaces + "*" * (21 - 2 * numSpaces)) 8 | } 9 | } 10 | } 11 | -------------------------------------------------------------------------------- /archive/s/scala/Capitalize.scala: -------------------------------------------------------------------------------- 1 | object Capitalize { 2 | def main(args: Array[String]) { 3 | val inputStr: Option[String] = args.length match { 4 | case 0 => Some("") 5 | case _ => Some(args(0)) 6 | } 7 | if (inputStr.get.length < 1) { 8 | println("Usage: please provide a string") 9 | } 10 | else { 11 | inputStr.map(_.capitalize).map(println) 12 | } 13 | } 14 | } 15 | -------------------------------------------------------------------------------- /archive/s/scala/FizzBuzz.scala: -------------------------------------------------------------------------------- 1 | object FizzBuzz { 2 | 3 | def main(args: Array[String]): Unit = { 4 | for (i <- 1.until(101)) { 5 | var output: String = "" 6 | if (i % 3 == 0) { 7 | output += "Fizz" 8 | } 9 | if (i % 5 == 0) { 10 | output += "Buzz" 11 | } 12 | if (output.isEmpty) { 13 | output += i 14 | } 15 | println(output) 16 | } 17 | } 18 | 19 | } -------------------------------------------------------------------------------- /archive/s/scala/HelloWorld.scala: -------------------------------------------------------------------------------- 1 | object HelloWorld extends App { 2 | println("Hello, World!") 3 | } 4 | -------------------------------------------------------------------------------- /archive/s/scala/testinfo.yml: -------------------------------------------------------------------------------- 1 | folder: 2 | extension: ".scala" 3 | naming: "pascal" 4 | 5 | container: 6 | image: "sbtscala/scala-sbt" 7 | tag: "eclipse-temurin-jammy-8u352-b08_1.8.3_2.13.10" 8 | build: "scalac {{ source.name }}{{ source.extension }}" 9 | cmd: "scala {{ source.name }}" 10 | -------------------------------------------------------------------------------- /archive/s/scheme/baklava.scm: -------------------------------------------------------------------------------- 1 | (define (string-repeat n str) 2 | (fold string-append "" (make-list n str)) 3 | ) 4 | 5 | (define (baklava-line i) 6 | (define numSpaces (abs i)) 7 | (define numStars (- 21 (* 2 numSpaces))) 8 | (when (<= i 10) 9 | (display (string-repeat numSpaces " ")) 10 | (display (string-repeat numStars "*")) 11 | (newline) 12 | (baklava-line (+ i 1)) 13 | ) 14 | ) 15 | 16 | (baklava-line -10) 17 | -------------------------------------------------------------------------------- /archive/s/scheme/hello-world.scm: -------------------------------------------------------------------------------- 1 | (display "Hello, World!") 2 | -------------------------------------------------------------------------------- /archive/s/scheme/reverse-string.scm: -------------------------------------------------------------------------------- 1 | (define (reverse-string x) 2 | (list->string (reverse (string->list x)))) 3 | 4 | (if (> (length (command-line)) 1) 5 | (display (reverse-string (list-ref (command-line) 1))) 6 | ) 7 | -------------------------------------------------------------------------------- /archive/s/scheme/testinfo.yml: -------------------------------------------------------------------------------- 1 | folder: 2 | extension: ".scm" 3 | naming: "hyphen" 4 | 5 | container: 6 | image: "schemers/gauche" 7 | tag: "0" 8 | cmd: "gosh {{ source.name }}{{ source.extension }}" 9 | -------------------------------------------------------------------------------- /archive/s/scilab/baklava.sce: -------------------------------------------------------------------------------- 1 | function [result] = strRepeat(n, s) 2 | result = '' 3 | for i = 1:n 4 | result = result + s 5 | end 6 | endfunction 7 | 8 | for i = -10:10 9 | numSpaces = abs(i) 10 | mprintf('%s%s\n', strRepeat(numSpaces, ' '), strRepeat(21 - 2 * numSpaces, '*')) 11 | end 12 | -------------------------------------------------------------------------------- /archive/s/scilab/hello-world.sce: -------------------------------------------------------------------------------- 1 | mprintf('%s', 'Hello, World!') 2 | -------------------------------------------------------------------------------- /archive/s/scilab/testinfo.yml: -------------------------------------------------------------------------------- 1 | folder: 2 | extension: ".sce" 3 | naming: "hyphen" 4 | 5 | container: 6 | image: "rzuckerm/scilab" 7 | tag: "6.1.1-2" 8 | cmd: "scilab-cli -args -nb -quit -f {{ source.name }}{{ source.extension }}" 9 | -------------------------------------------------------------------------------- /archive/s/shen/hello-world.shen: -------------------------------------------------------------------------------- 1 | (output "Hello, World!~%") 2 | -------------------------------------------------------------------------------- /archive/s/shen/testinfo.yml: -------------------------------------------------------------------------------- 1 | folder: 2 | extension: ".shen" 3 | naming: "hyphen" 4 | 5 | container: 6 | image: "rzuckerm/shen" 7 | tag: "0.39-2" 8 | cmd: "shen-scheme script {{ source.name }}{{ source.extension }}" 9 | -------------------------------------------------------------------------------- /archive/s/smalltalk/baklava.st: -------------------------------------------------------------------------------- 1 | -10 to: 10 do: [ :i | 2 | numSpaces := i abs. 3 | numSpaces timesRepeat: [ ' ' display ]. 4 | (21 - (2 * numSpaces)) timesRepeat: [ '*' display ]. 5 | Character nl display. 6 | ] 7 | -------------------------------------------------------------------------------- /archive/s/smalltalk/hello-world.st: -------------------------------------------------------------------------------- 1 | Transcript show: 'Hello, World!'. 2 | -------------------------------------------------------------------------------- /archive/s/smalltalk/testinfo.yml: -------------------------------------------------------------------------------- 1 | folder: 2 | extension: ".st" 3 | naming: "hyphen" 4 | 5 | container: 6 | image: "codesignal/smalltalk" 7 | tag: "v9.4.0" 8 | cmd: "gst --no-gc {{ source.name }}{{ source.extension }}" 9 | -------------------------------------------------------------------------------- /archive/s/solidity/HelloWorld.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT 2 | pragma solidity ^0.8; 3 | 4 | contract HelloWorld { 5 | function main (string memory) public pure returns (string memory) { 6 | return 'Hello, World!\n'; 7 | } 8 | } 9 | -------------------------------------------------------------------------------- /archive/s/solidity/testinfo.yml: -------------------------------------------------------------------------------- 1 | folder: 2 | extension: ".sol" 3 | naming: "pascal" 4 | 5 | container: 6 | image: "rzuckerm/solidity" 7 | tag: "0.8.21-2" 8 | build: "compile_solidity {{ source.name }}{{ source.extension }}" 9 | cmd: "run_solidity {{ source.name }}" 10 | -------------------------------------------------------------------------------- /archive/s/solisp/baklava.solisp: -------------------------------------------------------------------------------- 1 | (JoinD newline (Map x (Append (Seq 0 10) (Reverse (Seq 0 9))) 2 | (Append 3 | (Clone (- 10 x) " ") 4 | (Clone (+ (* x 2) 1) (Force Char 42)) 5 | ) 6 | )) -------------------------------------------------------------------------------- /archive/s/solisp/fizz-buzz.solisp: -------------------------------------------------------------------------------- 1 | (Join (Map num (Seq 1 100) 2 | (Switch 3 | {(== (% num 3) (% num 5) 0) "FizzBuzz"} 4 | {(== (% num 3) 0) "Fizz"} 5 | {(== (% num 5) 0) "Buzz"} 6 | {true num} 7 | ) 8 | ) "\n") -------------------------------------------------------------------------------- /archive/s/solisp/hello-world.solisp: -------------------------------------------------------------------------------- 1 | "Hello, World!" -------------------------------------------------------------------------------- /archive/s/solisp/testinfo.yml: -------------------------------------------------------------------------------- 1 | folder: 2 | extension: ".solisp" 3 | naming: "hyphen" 4 | 5 | container: 6 | image: "rzuckerm/solisp" 7 | tag: "1.1.0-2" 8 | cmd: "solisp {{ source.name }}{{ source.extension }}" 9 | -------------------------------------------------------------------------------- /archive/s/spry/baklava.sy: -------------------------------------------------------------------------------- 1 | abs = func [:x 2 | ($x >= 0) then: [ $x ] else: [ 0 - $x ] 3 | ] 4 | 5 | repeat_string:times: = func [:s :n 6 | ($n > 0) then: [ $s, repeat_string: $s times: ($n - 1) ] else: [ "" ] 7 | ] 8 | 9 | -10 to: 10 do: [ 10 | num_spaces = abs :i 11 | num_stars = (21 - (num_spaces * 2)) 12 | echo (repeat_string: " " times: num_spaces, repeat_string: "*" times: num_stars) 13 | ] 14 | -------------------------------------------------------------------------------- /archive/s/spry/hello-world.sy: -------------------------------------------------------------------------------- 1 | echo "Hello, World!" 2 | -------------------------------------------------------------------------------- /archive/s/spry/testinfo.yml: -------------------------------------------------------------------------------- 1 | folder: 2 | extension: ".sy" 3 | naming: "hyphen" 4 | 5 | container: 6 | image: "thalesmg/spry" 7 | tag: "20180326" 8 | cmd: "spry {{ source.name }}{{ source.extension }}" 9 | -------------------------------------------------------------------------------- /archive/s/swift/baklava.swift: -------------------------------------------------------------------------------- 1 | func baklava(maxWidth: Int) -> Void { 2 | for number in 0...maxWidth { 3 | print(String(repeatElement(" ", count:maxWidth-number)) + String(repeatElement("*", count:number*2+1))) 4 | } 5 | for number in (0...maxWidth-1).reversed() { 6 | print(String(repeatElement(" ", count:maxWidth-number)) + String(repeatElement("*", count:number*2+1))) 7 | } 8 | } 9 | baklava(maxWidth: 10) 10 | -------------------------------------------------------------------------------- /archive/s/swift/even-odd.swift: -------------------------------------------------------------------------------- 1 | // for System.exit() 2 | import Foundation 3 | 4 | 5 | /* 6 | Check if there is exactly one argument and if it can be parsed as an integer 7 | */ 8 | guard CommandLine.argc == 2, let number = Int(CommandLine.arguments[1]) else { 9 | print("Usage: please input a number") 10 | exit(0) 11 | } 12 | 13 | let is_even = number % 2 == 0 14 | 15 | if is_even { 16 | print("Even") 17 | } else { 18 | print("Odd") 19 | } -------------------------------------------------------------------------------- /archive/s/swift/hello-world.swift: -------------------------------------------------------------------------------- 1 | print("Hello, World!") 2 | -------------------------------------------------------------------------------- /archive/s/swift/reverse-string.swift: -------------------------------------------------------------------------------- 1 | import Foundation 2 | 3 | guard CommandLine.argc > 1 else { 4 | exit(0) 5 | } 6 | 7 | let usersString = CommandLine.arguments[1] 8 | let reversedCollection = usersString.reversed() 9 | let reversedString = String(reversedCollection) 10 | 11 | print(reversedString) 12 | -------------------------------------------------------------------------------- /archive/s/swift/testinfo.yml: -------------------------------------------------------------------------------- 1 | folder: 2 | extension: ".swift" 3 | naming: "hyphen" 4 | 5 | container: 6 | image: "swift" 7 | tag: "5.3" 8 | build: "swiftc -o {{ source.name }} {{ source.name }}{{ source.extension }}" 9 | cmd: "./{{ source.name }}" 10 | -------------------------------------------------------------------------------- /archive/t/tcl/baklava.tcl: -------------------------------------------------------------------------------- 1 | for {set i -10} {$i <= 10} {incr i} { 2 | set numSpaces [expr { abs($i) }] 3 | set numStars [expr 21 - 2 * $numSpaces] 4 | puts "[string repeat { } $numSpaces][string repeat * $numStars]" 5 | } 6 | -------------------------------------------------------------------------------- /archive/t/tcl/hello-world.tcl: -------------------------------------------------------------------------------- 1 | puts "Hello, World!" 2 | -------------------------------------------------------------------------------- /archive/t/tcl/testinfo.yml: -------------------------------------------------------------------------------- 1 | folder: 2 | extension: ".tcl" 3 | naming: "hyphen" 4 | 5 | container: 6 | image: "esolang/tcl" 7 | tag: "latest" 8 | cmd: "tclsh {{ source.name }}{{ source.extension }}" 9 | -------------------------------------------------------------------------------- /archive/t/terra/baklava.t: -------------------------------------------------------------------------------- 1 | local function strRepeat(n, s) 2 | local r = "" 3 | for i = 1, n do 4 | r = r .. s 5 | end 6 | 7 | return r 8 | end 9 | 10 | local function baklava() 11 | for i = -10, 10 do 12 | local numSpaces = i 13 | if i < 0 then 14 | numSpaces = -numSpaces 15 | end 16 | 17 | print(strRepeat(numSpaces, " ") .. strRepeat(21 - 2 * numSpaces, "*")) 18 | end 19 | end 20 | 21 | baklava() 22 | -------------------------------------------------------------------------------- /archive/t/terra/hello-world.t: -------------------------------------------------------------------------------- 1 | print("Hello, World!") 2 | -------------------------------------------------------------------------------- /archive/t/terra/testinfo.yml: -------------------------------------------------------------------------------- 1 | folder: 2 | extension: ".t" 3 | naming: "hyphen" 4 | 5 | container: 6 | image: "rzuckerm/terra" 7 | tag: "1.2.0-2" 8 | cmd: "terra {{ source.name }}{{ source.extension }}" 9 | -------------------------------------------------------------------------------- /archive/t/tex/hello-world.tex: -------------------------------------------------------------------------------- 1 | \newwrite\out 2 | \immediate\openout\out=hello-world.txt 3 | \immediate\write\out{Hello, World!} 4 | \end 5 | -------------------------------------------------------------------------------- /archive/t/ti-basic/baklava.8xp.txt: -------------------------------------------------------------------------------- 1 | For(N,0,20) 2 | abs(10-N)->S 3 | 21-2*S->T 4 | ""->Str1 5 | For(I,1,S) 6 | Str1+" "->Str1 7 | End 8 | For(I,1,T) 9 | Str1+"*"->Str1 10 | End 11 | Disp Str1 12 | End 13 | -------------------------------------------------------------------------------- /archive/t/ti-basic/capitalize.8xp.txt: -------------------------------------------------------------------------------- 1 | Input "",Str1 2 | "abcdefghijklmnopqrstuvwxyz"->Str2 3 | "ABCDEFGHIJKLMNOPQRSTUVWXYZ"->Str3 4 | If length(Str1)=0 Then Disp "Usage: please provide a string" 5 | Else 6 | inString(Str2,sub(Str1,1,1))->N 7 | If N>0 Then Disp sub(Str3,N,1)+sub(Str1,2,length(Str1)-1) 8 | Else Disp Str1 9 | End 10 | End 11 | -------------------------------------------------------------------------------- /archive/t/ti-basic/fizz-buzz.8xp.txt: -------------------------------------------------------------------------------- 1 | For(N,1,100) 2 | If remainder(N,15)=0 Then Disp("FizzBuzz") 3 | Else 4 | If remainder(N,3)=0 Then Disp("Fizz") 5 | Else 6 | If remainder(N,5)=0 Then Disp("Buzz") 7 | Else Disp(N) 8 | End 9 | End 10 | End 11 | End 12 | -------------------------------------------------------------------------------- /archive/t/ti-basic/hello-world.8xp.txt: -------------------------------------------------------------------------------- 1 | Disp "Hello, World!" 2 | -------------------------------------------------------------------------------- /archive/t/ti-basic/reverse-string.8xp.txt: -------------------------------------------------------------------------------- 1 | Input "",Str1 2 | ""->Str2 3 | For(N,length(Str1),1,-1) 4 | Str2+sub(Str1,N,1)->Str2 5 | End 6 | Disp Str2 7 | -------------------------------------------------------------------------------- /archive/t/ti-basic/testinfo.yml: -------------------------------------------------------------------------------- 1 | folder: 2 | extension: ".8xp.txt" 3 | naming: "hyphen" 4 | 5 | container: 6 | image: "rzuckerm/ti-basic" 7 | tag: "2025.03.08.2-10" 8 | cmd: "ti-basic {{ source.name }}{{ source.extension }}" 9 | -------------------------------------------------------------------------------- /archive/t/typescript/baklava.ts: -------------------------------------------------------------------------------- 1 | for (var i = 0; i < 10; i++) 2 | console.log ( 3 | " ".repeat (10 - i) + "*".repeat (i * 2 + 1) 4 | ); 5 | 6 | for (var i = 10; -1 < i; i--) 7 | console.log ( 8 | " ".repeat (10 - i) + "*".repeat (i * 2 + 1) 9 | ); 10 | -------------------------------------------------------------------------------- /archive/t/typescript/capitalize.ts: -------------------------------------------------------------------------------- 1 | if (process.argv.length < 3 || process.argv[2].length < 1) { 2 | console.log("Usage: please provide a string") 3 | process.exit(0) 4 | } 5 | 6 | let myStr: string = process.argv[2]; 7 | 8 | const capitalize = (str: string) => str[0].toUpperCase() + str.slice(1); 9 | 10 | console.log(capitalize(myStr)); 11 | -------------------------------------------------------------------------------- /archive/t/typescript/even-odd.ts: -------------------------------------------------------------------------------- 1 | const error_msg: string = "Usage: please input a number" 2 | let num_str:string = (process.argv.length == 3) ? process.argv[2] : ""; 3 | let num:number = parseInt(num_str); 4 | if (isNaN(num)) { 5 | console.log(error_msg); 6 | process.exit(1); 7 | } 8 | let is_even:boolean = (num % 2 == 0); 9 | console.log(is_even ? "Even" : "Odd"); -------------------------------------------------------------------------------- /archive/t/typescript/factorial.ts: -------------------------------------------------------------------------------- 1 | let error_msg: string = "Usage: please input a non-negative integer" 2 | let num_str: string = (process.argv.length == 3) ? process.argv[2] : "" 3 | let num: number = parseInt(num_str); 4 | if (isNaN(num) || num < 0) { 5 | console.log(error_msg); 6 | process.exit(1); 7 | } 8 | let factorial: number = 1; 9 | for (let i = 1; i <= num; i++) { 10 | factorial *= i; 11 | } 12 | console.log(factorial); 13 | -------------------------------------------------------------------------------- /archive/t/typescript/fizz-buzz.ts: -------------------------------------------------------------------------------- 1 | let line: string; 2 | 3 | for (let i = 1; i <= 100; i++) { 4 | if (i % 3 == 0 && i % 5 == 0) { 5 | line = "FizzBuzz"; 6 | } else if (i % 3 == 0) { 7 | line = "Fizz"; 8 | } else if (i % 5 == 0) { 9 | line = "Buzz"; 10 | } else { 11 | line = String(i); 12 | } 13 | console.log(line); 14 | } 15 | -------------------------------------------------------------------------------- /archive/t/typescript/hello-world.ts: -------------------------------------------------------------------------------- 1 | console.log("Hello, World!"); 2 | -------------------------------------------------------------------------------- /archive/t/typescript/reverse-string.ts: -------------------------------------------------------------------------------- 1 | let myString: string = (process.argv.length >= 3) ? process.argv[2] : ""; 2 | 3 | const reverse = (str: string) => str.split("").reverse().join(""); 4 | 5 | console.log(reverse(myString)); 6 | -------------------------------------------------------------------------------- /archive/t/typescript/testinfo.yml: -------------------------------------------------------------------------------- 1 | folder: 2 | extension: ".ts" 3 | naming: "hyphen" 4 | 5 | container: 6 | image: "rzuckerm/typescript" 7 | tag: "5.3.3-20.11.9-1" 8 | build: "tsc --types /usr/local/lib/node_modules/@types/node {{ source.name }}{{ source.extension }}" 9 | cmd: "node {{ source.name }}.js" 10 | -------------------------------------------------------------------------------- /archive/u/unicat/testinfo.yml: -------------------------------------------------------------------------------- 1 | folder: 2 | extension: ".cat" 3 | naming: "hyphen" 4 | 5 | container: 6 | image: "esolang/unicat" 7 | tag: "latest" 8 | build: | 9 | sh -c '(echo "#!/bin/sh"; \ 10 | echo "echo \"\$@\" | unicat {{ source.name }}{{ source.extension }}" \ 11 | ) >{{ source.name }}' 12 | cmd: "sh {{ source.name }}" 13 | -------------------------------------------------------------------------------- /archive/v/v/baklava.v: -------------------------------------------------------------------------------- 1 | module main 2 | 3 | fn str_repeat(n int, s string) string { 4 | mut result := "" 5 | for _ in 0 .. n { 6 | result += s 7 | } 8 | 9 | return result 10 | } 11 | 12 | fn main() { 13 | for i in -10 .. 11 { 14 | num_spaces := if i >= 0 { i } else { -i } 15 | println(str_repeat(num_spaces, " ") + str_repeat(21 - 2 *num_spaces, "*")) 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /archive/v/v/even-odd.v: -------------------------------------------------------------------------------- 1 | module main 2 | 3 | import os 4 | import strconv 5 | 6 | fn main() { 7 | if os.args.len < 2 { 8 | println('Usage: please input a number') 9 | exit(1) 10 | } 11 | 12 | num := strconv.atoi(os.args[1]) or { 13 | println('Usage: please input a number') 14 | exit(1) 15 | } 16 | 17 | print(match num % 2 { 18 | 0 { 'Even' } 19 | 1, -1 { 'Odd' } 20 | else { 'Usage: please input a number' } 21 | }) 22 | } 23 | -------------------------------------------------------------------------------- /archive/v/v/fizz-buzz.v: -------------------------------------------------------------------------------- 1 | module main 2 | 3 | fn main() { 4 | for i in 1..101 { 5 | println(match true { 6 | i % 15 == 0 { "FizzBuzz" } 7 | i % 5 == 0 { "Buzz" } 8 | i % 3 == 0 { "Fizz" } 9 | else { i.str() } 10 | }) 11 | } 12 | } 13 | -------------------------------------------------------------------------------- /archive/v/v/hello-world.v: -------------------------------------------------------------------------------- 1 | module main 2 | 3 | fn main(){ 4 | println('Hello, World!') 5 | } 6 | -------------------------------------------------------------------------------- /archive/v/v/reverse-string.v: -------------------------------------------------------------------------------- 1 | module main 2 | 3 | import os 4 | 5 | fn main() { 6 | if os.args.len == 2 { 7 | println(os.args[1].reverse()) 8 | } 9 | } 10 | -------------------------------------------------------------------------------- /archive/v/v/testinfo.yml: -------------------------------------------------------------------------------- 1 | folder: 2 | extension: ".v" 3 | naming: "hyphen" 4 | 5 | container: 6 | image: "thevlang/vlang" 7 | tag: "alpine-dev" 8 | build: "v -prod {{ source.name }}{{ source.extension }}" 9 | cmd: "./{{ source.name }}" 10 | -------------------------------------------------------------------------------- /archive/v/verilog/hello-world.v: -------------------------------------------------------------------------------- 1 | module main; 2 | initial 3 | begin 4 | $display("Hello, World!"); 5 | $finish(0); 6 | end 7 | endmodule 8 | -------------------------------------------------------------------------------- /archive/v/verilog/testinfo.yml: -------------------------------------------------------------------------------- 1 | folder: 2 | extension: ".v" 3 | naming: "hyphen" 4 | 5 | container: 6 | image: "0x01be/iverilog" 7 | tag: "latest" 8 | build: "iverilog -o {{ source.name }} {{ source.name }}{{ source.extension }}" 9 | cmd: "./{{ source.name }}" 10 | -------------------------------------------------------------------------------- /archive/v/verve/fizz-buzz.vrv: -------------------------------------------------------------------------------- 1 | fn fizz_buzz_line(n: Int) -> String { 2 | match [n % 3, n % 5] { 3 | case [0, 0]: "FizzBuzz" 4 | case [0, _]: "Fizz" 5 | case [_, 0]: "Buzz" 6 | case _: to_string(n) 7 | } 8 | } 9 | 10 | fn fizz_buzz(start: Int, end: Int) { 11 | if not(start > end) { 12 | print(fizz_buzz_line(start)) 13 | fizz_buzz(start + 1, end) 14 | } 15 | } 16 | 17 | fizz_buzz(1, 100) 18 | -------------------------------------------------------------------------------- /archive/v/verve/hello-world.vrv: -------------------------------------------------------------------------------- 1 | print("Hello, World!") 2 | -------------------------------------------------------------------------------- /archive/v/vimscript/baklava.vim: -------------------------------------------------------------------------------- 1 | func! Baklava() 2 | for l:i in range(-10, 10) 3 | let l:numSpaces = abs(l:i) 4 | echo repeat(' ', l:numSpaces) . repeat('*', 21 - 2 * l:numSpaces) 5 | endfor 6 | endfunc 7 | 8 | func! Main() 9 | call Baklava() 10 | endfunc 11 | -------------------------------------------------------------------------------- /archive/v/vimscript/fizz-buzz.vim: -------------------------------------------------------------------------------- 1 | func! FizzBuzz() 2 | for l:i in range(1, 100) 3 | if l:i % 15 == 0 4 | let l:str = 'FizzBuzz' 5 | elseif l:i % 5 == 0 6 | let l:str = 'Buzz' 7 | elseif l:i % 3 == 0 8 | let l:str = 'Fizz' 9 | else 10 | let l:str = l:i 11 | endif 12 | 13 | echo l:str 14 | endfor 15 | endfunc 16 | 17 | func! Main() 18 | call FizzBuzz() 19 | endfunc 20 | -------------------------------------------------------------------------------- /archive/v/vimscript/hello-world.vim: -------------------------------------------------------------------------------- 1 | func! Main() 2 | echo "Hello, World!" 3 | endfunc 4 | -------------------------------------------------------------------------------- /archive/v/vimscript/reverse-string.vim: -------------------------------------------------------------------------------- 1 | func! Reverse(str) 2 | return join(reverse(split(a:str, '\zs')), '') 3 | endfunc 4 | 5 | func! Main(...) 6 | echo Reverse(a:0 > 0 ? a:1 : '') 7 | endfunc 8 | -------------------------------------------------------------------------------- /archive/v/vimscript/testinfo.yml: -------------------------------------------------------------------------------- 1 | folder: 2 | extension: ".vim" 3 | naming: "hyphen" 4 | 5 | container: 6 | image: "rzuckerm/vimscript" 7 | tag: "8.2-2" 8 | cmd: "run_vim {{ source.name }}{{ source.extension }}" 9 | -------------------------------------------------------------------------------- /archive/v/visual-basic/baklava.vb: -------------------------------------------------------------------------------- 1 | Public Module Baklava 2 | Public Sub Main() 3 | Dim numSpaces As Integer 4 | For i As Integer = -10 To 10 5 | numSpaces = Math.Abs(i) 6 | System.Console.WriteLine(StrDup(numSpaces, " ") + StrDup(21 - 2 * numSpaces, "*")) 7 | Next i 8 | End Sub 9 | End Module 10 | -------------------------------------------------------------------------------- /archive/v/visual-basic/hello-world.vb: -------------------------------------------------------------------------------- 1 | Public Module HelloWorld 2 | Public Sub Main() 3 | System.Console.WriteLine("Hello, World!") 4 | End Sub 5 | End Module 6 | -------------------------------------------------------------------------------- /archive/v/visual-basic/testinfo.yml: -------------------------------------------------------------------------------- 1 | folder: 2 | extension: ".vb" 3 | naming: "hyphen" 4 | 5 | container: 6 | image: "mono" 7 | tag: "6.12.0.182" # Cannot use slim because it does not contain vbnc for compilation 8 | build: "vbnc {{ source.name }}{{ source.extension }}" 9 | cmd: "mono {{ source.name }}.exe" 10 | -------------------------------------------------------------------------------- /archive/w/whitespace/testinfo.yml: -------------------------------------------------------------------------------- 1 | folder: 2 | extension: ".ws" 3 | naming: "hyphen" 4 | 5 | container: 6 | image: "esolang/whitespace" 7 | tag: "latest" 8 | cmd: "whitespace {{ source.name }}{{ source.extension }}" 9 | -------------------------------------------------------------------------------- /archive/w/wren/baklava.wren: -------------------------------------------------------------------------------- 1 | for (i in (-10..10)) { 2 | var numSpaces = (i >= 0) ? i : -i 3 | System.print(" " * numSpaces + "*" * (21 - 2 *numSpaces)) 4 | } 5 | -------------------------------------------------------------------------------- /archive/w/wren/file-input-output.wren: -------------------------------------------------------------------------------- 1 | import "io" for File 2 | 3 | File.create("output.txt") {|f| 4 | f.writeBytes("My brain has too many tabs open.") 5 | } 6 | 7 | System.print(File.read("output.txt")) 8 | -------------------------------------------------------------------------------- /archive/w/wren/fizz-buzz.wren: -------------------------------------------------------------------------------- 1 | for (i in (1..100)) { 2 | if (i % 15 == 0) { 3 | System.print("FizzBuzz") 4 | } else if (i % 5 == 0) { 5 | System.print("Buzz") 6 | } else if (i % 3 == 0) { 7 | System.print("Fizz") 8 | } else { 9 | System.print(i) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /archive/w/wren/hello-world.wren: -------------------------------------------------------------------------------- 1 | System.print("Hello, World!") 2 | -------------------------------------------------------------------------------- /archive/w/wren/remove-all-whitespace.wren: -------------------------------------------------------------------------------- 1 | import "os" for Process 2 | 3 | var args = Process.arguments 4 | 5 | if (args.count < 1 || args[0].count < 1) { 6 | System.print("Usage: please provide a string") 7 | Fiber.suspend() 8 | } 9 | 10 | var s = "" 11 | 12 | for (c in args[0]) { 13 | if (c != " " && c != "\n" && c != "\t" && c != "\r" && c != "\f") { 14 | s = s + c 15 | } 16 | } 17 | 18 | System.print(s) 19 | -------------------------------------------------------------------------------- /archive/w/wren/reverse-string.wren: -------------------------------------------------------------------------------- 1 | import "os" for Process 2 | 3 | var args = Process.arguments 4 | 5 | if (args.count < 1) { 6 | args.add("") 7 | } 8 | 9 | var rev = "" 10 | 11 | for (c in args[0]) { 12 | rev = c + rev 13 | } 14 | 15 | System.print(rev) 16 | -------------------------------------------------------------------------------- /archive/w/wren/testinfo.yml: -------------------------------------------------------------------------------- 1 | folder: 2 | extension: ".wren" 3 | naming: "hyphen" 4 | 5 | container: 6 | image: "rzuckerm/wren" 7 | tag: "0.4.0-1" 8 | cmd: "wren_cli {{ source.name }}{{ source.extension }}" 9 | -------------------------------------------------------------------------------- /archive/w/wu/baklava.wu: -------------------------------------------------------------------------------- 1 | repeatString: fun(c: str, count: int) -> str { 2 | s: str = "" 3 | while count > 0 { 4 | s ++= c 5 | count -= 1 6 | } 7 | 8 | s 9 | } 10 | 11 | i: int = -10 12 | while i <= 10 { 13 | numSpaces: int = if i >= 0 { i } else { -i } 14 | print(repeatString(" ", numSpaces) ++ repeatString("*", 21 - 2 * numSpaces)) 15 | i += 1 16 | } 17 | -------------------------------------------------------------------------------- /archive/w/wu/hello-world.wu: -------------------------------------------------------------------------------- 1 | print("Hello, World!\n") 2 | -------------------------------------------------------------------------------- /archive/w/wu/testinfo.yml: -------------------------------------------------------------------------------- 1 | folder: 2 | extension: ".wu" 3 | naming: "hyphen" 4 | 5 | container: 6 | image: "rzuckerm/wu" 7 | tag: "0.1.0-1" 8 | build: "wu {{ source.name }}{{ source.extension }}" 9 | cmd: "lua {{ source.name }}.lua" 10 | -------------------------------------------------------------------------------- /archive/w/wyvern/hello-world.wyv: -------------------------------------------------------------------------------- 1 | require stdout 2 | 3 | stdout.print("Hello, World!") 4 | -------------------------------------------------------------------------------- /archive/w/wyvern/testinfo.yml: -------------------------------------------------------------------------------- 1 | folder: 2 | extension: ".wyv" 3 | naming: "hyphen" 4 | 5 | container: 6 | image: "rzuckerm/wyvern" 7 | tag: "20180325-1" 8 | cmd: "wyvern {{ source.name }}{{ source.extension }}" 9 | -------------------------------------------------------------------------------- /archive/y/yoix/baklava.yx: -------------------------------------------------------------------------------- 1 | import yoix.stdio.putchar; 2 | import yoix.math.abs; 3 | 4 | printRepeat(int c, int count) { 5 | int i; 6 | for (i = 0; i < count; i++) { 7 | putchar(c); 8 | } 9 | } 10 | 11 | int i; 12 | for (i = -10; i <= 10; i++) { 13 | int numSpaces = abs(i); 14 | int numStars = 21 - 2 * numSpaces; 15 | printRepeat(' ', numSpaces); 16 | printRepeat('*', numStars); 17 | putchar('\n'); 18 | } 19 | -------------------------------------------------------------------------------- /archive/y/yoix/hello_world.yx: -------------------------------------------------------------------------------- 1 | import yoix.stdio.printf; 2 | 3 | printf("Hello, World!\n"); 4 | -------------------------------------------------------------------------------- /archive/y/yoix/testinfo.yml: -------------------------------------------------------------------------------- 1 | folder: 2 | extension: ".yx" 3 | naming: "underscore" 4 | 5 | container: 6 | image: "rzuckerm/yoix" 7 | tag: "2.3.1-1" 8 | cmd: "java -jar /opt/yoix/yoix.jar {{ source.name }}{{ source.extension }}" 9 | -------------------------------------------------------------------------------- /archive/z/zig/baklava.zig: -------------------------------------------------------------------------------- 1 | const std = @import("std"); 2 | 3 | pub fn main() !void { 4 | const stdout = std.io.getStdOut().writer(); 5 | const spaces = " " ** 10; 6 | const stars = "*" ** 21; 7 | var i: i32 = -10; 8 | while (i <= 10): (i += 1) { 9 | const numSpaces: usize = @intCast(@abs(i)); 10 | const numStars: usize = 21 - numSpaces * 2; 11 | try stdout.print("{s}{s}\n", .{spaces[0..numSpaces], stars[0..numStars]}); 12 | } 13 | } 14 | -------------------------------------------------------------------------------- /archive/z/zig/hello-world.zig: -------------------------------------------------------------------------------- 1 | const std = @import("std"); 2 | 3 | pub fn main() !void { 4 | const stdout = std.io.getStdOut().writer(); 5 | try stdout.writeAll("Hello, World!\n"); 6 | } 7 | -------------------------------------------------------------------------------- /archive/z/zig/testinfo.yml: -------------------------------------------------------------------------------- 1 | folder: 2 | extension: ".zig" 3 | naming: "hyphen" 4 | 5 | container: 6 | image: "guilledk/zig" 7 | tag: "0.13.0" 8 | build: "zig build-exe {{ source.name }}{{ source.extension }}" 9 | cmd: "./{{ source.name }}" 10 | -------------------------------------------------------------------------------- /repo-config.yml: -------------------------------------------------------------------------------- 1 | poetry-version: "2.1.3" 2 | python-version: "3.12" 3 | num-batches: 6 4 | -------------------------------------------------------------------------------- /test/__init__.py: -------------------------------------------------------------------------------- 1 | from enum import Enum, auto 2 | 3 | 4 | class ProjectType(Enum): 5 | Placeholder = auto() 6 | # Add new project types here for projects that cannot use auto-generated tests 7 | 8 | @property 9 | def key(self): 10 | return self.name.lower() 11 | --------------------------------------------------------------------------------