diff --git a/Conf/lang.yaml b/Conf/lang.yaml index d04bbba4c9..494355cabe 100644 --- a/Conf/lang.yaml +++ b/Conf/lang.yaml @@ -1,7 +1,13 @@ 4D: ext: 4d +ActionScript: + ext: as AWK: ext: awk +B: + ext: b +Babel: + ext: pb BASIC: ext: bas Befunge: @@ -12,6 +18,10 @@ Clojure: ext: clj CoffeeScript: ext: coffee +Dylan: + ext: dylan +Eiffel: + ext: e Erlang: ext: erl Forth: @@ -38,14 +48,26 @@ PicoLisp: ext: l PIR: ext: pir +Prolog: + ext: pro Python: ext: py +R: + ext: r +Racket: + ext: rkt REXX: ext: rexx Ruby: ext: rb +Sather: + ext: sa Scala: ext: scala +Scheme: + ext: ss +Smalltalk: + ext: st SNUSP: ext: snusp Tcl: diff --git a/Lang/ActionScript/0DESCRIPTION b/Lang/ActionScript/0DESCRIPTION new file mode 100644 index 0000000000..14a7dc41bf --- /dev/null +++ b/Lang/ActionScript/0DESCRIPTION @@ -0,0 +1,13 @@ +{{stub}}{{language|ActionScript +|site=http://www.adobe.com/devnet/actionscript.html +|gc=yes +|strength=strong +|safety=safe +|checking=static +|LCT=yes}} + +{{Language programming paradigm|Distributed}} +{{Language programming paradigm|Imperative}} +{{Language programming paradigm|Event-driven}} + +ActionScript is the language that drives [[wp:Adobe Flash|Flash]] behind the scenes. It is based on [[wp:ECMAScript|ECMAscript]], which is also the basis for [[JavaScript]]. \ No newline at end of file diff --git a/Lang/ActionScript/99_Bottles_of_Beer b/Lang/ActionScript/99_Bottles_of_Beer new file mode 120000 index 0000000000..66e5ac7d5d --- /dev/null +++ b/Lang/ActionScript/99_Bottles_of_Beer @@ -0,0 +1 @@ +../../Task/99_Bottles_of_Beer/ActionScript \ No newline at end of file diff --git a/Lang/ActionScript/FizzBuzz b/Lang/ActionScript/FizzBuzz new file mode 120000 index 0000000000..cdd6ba1f91 --- /dev/null +++ b/Lang/ActionScript/FizzBuzz @@ -0,0 +1 @@ +../../Task/FizzBuzz/ActionScript \ No newline at end of file diff --git a/Lang/ActionScript/Infinity b/Lang/ActionScript/Infinity new file mode 120000 index 0000000000..273fa4cc03 --- /dev/null +++ b/Lang/ActionScript/Infinity @@ -0,0 +1 @@ +../../Task/Infinity/ActionScript \ No newline at end of file diff --git a/Lang/ActionScript/Search_a_list b/Lang/ActionScript/Search_a_list new file mode 120000 index 0000000000..9468604d8e --- /dev/null +++ b/Lang/ActionScript/Search_a_list @@ -0,0 +1 @@ +../../Task/Search_a_list/ActionScript \ No newline at end of file diff --git a/Lang/B/0DESCRIPTION b/Lang/B/0DESCRIPTION new file mode 100644 index 0000000000..cbbe315ee3 --- /dev/null +++ b/Lang/B/0DESCRIPTION @@ -0,0 +1,7 @@ +{{language +|site=http://cm.bell-labs.com/cm/cs/who/dmr/kbman.html +|hopl id=492 +}} +B is a computer language intended for recursive, primarily non-numeric applications typified by system programming. B has a small, unrestrictive syntax that is easy to compile. Because of the unusual freedom of expression and a rich set of operators, B programs are often quite compact. + +B takes many features from [[derived from::BCPL]]. B is the ancestor of [[C]]. \ No newline at end of file diff --git a/Lang/Babel/0DESCRIPTION b/Lang/Babel/0DESCRIPTION new file mode 100644 index 0000000000..6e8ba18e2b --- /dev/null +++ b/Lang/Babel/0DESCRIPTION @@ -0,0 +1,6 @@ +{{alertbox|#ffffe0|''Were you looking for the [[Common Lisp]] library? That category has now been [[:Category:Babel (library)|renamed]].''}} +{{language}}Babel is an interpreted language designed by Clayton Bauman. It is an untyped, stack-based, postfix language with support for arrays, lists and hashes (dictionaries). Babel 1.0 will support built-in crypto-based verification of code in order to enable safer remote code execution. + +Babel is implemented in [[C]]. It is still under development with a v0.9 release planned for December 2012, so please excuse the dust and debris in the [https://github.com/claytonkb/Babel current implementation]. + +Check out the README and the doc/ folder on github for more information. \ No newline at end of file diff --git a/Lang/Babel/99_Bottles_of_Beer b/Lang/Babel/99_Bottles_of_Beer new file mode 120000 index 0000000000..cae2f471cf --- /dev/null +++ b/Lang/Babel/99_Bottles_of_Beer @@ -0,0 +1 @@ +../../Task/99_Bottles_of_Beer/Babel \ No newline at end of file diff --git a/Lang/Babel/Comments b/Lang/Babel/Comments new file mode 120000 index 0000000000..890874ed3b --- /dev/null +++ b/Lang/Babel/Comments @@ -0,0 +1 @@ +../../Task/Comments/Babel \ No newline at end of file diff --git a/Lang/Babel/FizzBuzz b/Lang/Babel/FizzBuzz new file mode 120000 index 0000000000..9d9b372e75 --- /dev/null +++ b/Lang/Babel/FizzBuzz @@ -0,0 +1 @@ +../../Task/FizzBuzz/Babel \ No newline at end of file diff --git a/Lang/Dylan/0DESCRIPTION b/Lang/Dylan/0DESCRIPTION new file mode 100644 index 0000000000..6eb93e5d6a --- /dev/null +++ b/Lang/Dylan/0DESCRIPTION @@ -0,0 +1,15 @@ +{{language| +|exec=machine +|strength=strong +|safety=safe +|checking=both +|gc=yes +|LCT=yes +|site=http://www.opendylan.org/}} +{{language programming paradigm|functional}} +{{language programming paradigm|procedural}} +{{language programming paradigm|imperative}} +{{Language programming paradigm|Object-oriented}} +Dylan is an [[:Category:Programming paradigm/Imperative|imperative]], [[:Category:Programming paradigm/Functional|functional]] programming language highly inspired by various [[Lisp]]s. Although original prototypes kept Lisp's s-expr based syntax, modern Dylan is written in a somewhat [[Pascal]]/[[C]]-inspired syntax. It's object system is notable for being CLOS-style (oriented around generic methods) rather than [[Smalltalk]] message-passing style. It allows for a mix of static and dynamic typing. +==Citations== +* [[wp:Dylan|Wikipedia:Dylan]] \ No newline at end of file diff --git a/Lang/Dylan/99_Bottles_of_Beer b/Lang/Dylan/99_Bottles_of_Beer new file mode 120000 index 0000000000..e5daf9786e --- /dev/null +++ b/Lang/Dylan/99_Bottles_of_Beer @@ -0,0 +1 @@ +../../Task/99_Bottles_of_Beer/Dylan \ No newline at end of file diff --git a/Lang/Eiffel/0DESCRIPTION b/Lang/Eiffel/0DESCRIPTION new file mode 100644 index 0000000000..bdfb45c236 --- /dev/null +++ b/Lang/Eiffel/0DESCRIPTION @@ -0,0 +1,7 @@ +{{Stub}}{{language|Eiffel +|strength=strong +|safety=safe +|compat=nominative +|checking=static +|gc=yes +|LCT=yes}} \ No newline at end of file diff --git a/Lang/Eiffel/Infinity b/Lang/Eiffel/Infinity new file mode 120000 index 0000000000..8a0611f99e --- /dev/null +++ b/Lang/Eiffel/Infinity @@ -0,0 +1 @@ +../../Task/Infinity/Eiffel \ No newline at end of file diff --git a/Lang/Prolog/0DESCRIPTION b/Lang/Prolog/0DESCRIPTION new file mode 100644 index 0000000000..da1d69a789 --- /dev/null +++ b/Lang/Prolog/0DESCRIPTION @@ -0,0 +1,14 @@ +{{language|Prolog +|strength=strong +|checking=dynamic +|gc=yes +|exec=both +|LCT=yes +|compat=structural +|parampass=value +|bnf=[http://cdn.bitbucket.org/muspellsson/rosetta/downloads/prolog-bnf.html] +}}{{language programming paradigm|Declarative}}{{language programming paradigm|Logic_Programming}} + + +[[wp:Prolog|Prolog]] is a [[logic programming]] language. It is programmed declaratively, using ''resolution'' and ''backtracking'' to confirm propositions based on declared facts and rules. +
\ No newline at end of file diff --git a/Lang/Prolog/99_Bottles_of_Beer b/Lang/Prolog/99_Bottles_of_Beer new file mode 120000 index 0000000000..4c015cd9be --- /dev/null +++ b/Lang/Prolog/99_Bottles_of_Beer @@ -0,0 +1 @@ +../../Task/99_Bottles_of_Beer/Prolog \ No newline at end of file diff --git a/Lang/Prolog/Anagrams b/Lang/Prolog/Anagrams new file mode 120000 index 0000000000..b9b67264bd --- /dev/null +++ b/Lang/Prolog/Anagrams @@ -0,0 +1 @@ +../../Task/Anagrams/Prolog \ No newline at end of file diff --git a/Lang/Prolog/Bulls_and_cows b/Lang/Prolog/Bulls_and_cows new file mode 120000 index 0000000000..d50d66a71f --- /dev/null +++ b/Lang/Prolog/Bulls_and_cows @@ -0,0 +1 @@ +../../Task/Bulls_and_cows/Prolog \ No newline at end of file diff --git a/Lang/Prolog/Comments b/Lang/Prolog/Comments new file mode 120000 index 0000000000..e59eb68670 --- /dev/null +++ b/Lang/Prolog/Comments @@ -0,0 +1 @@ +../../Task/Comments/Prolog \ No newline at end of file diff --git a/Lang/Prolog/FizzBuzz b/Lang/Prolog/FizzBuzz new file mode 120000 index 0000000000..af2ecb5834 --- /dev/null +++ b/Lang/Prolog/FizzBuzz @@ -0,0 +1 @@ +../../Task/FizzBuzz/Prolog \ No newline at end of file diff --git a/Lang/Prolog/Ordered_words b/Lang/Prolog/Ordered_words new file mode 120000 index 0000000000..aabc8e4e9a --- /dev/null +++ b/Lang/Prolog/Ordered_words @@ -0,0 +1 @@ +../../Task/Ordered_words/Prolog \ No newline at end of file diff --git a/Lang/Prolog/Quine b/Lang/Prolog/Quine new file mode 120000 index 0000000000..2999e24cc2 --- /dev/null +++ b/Lang/Prolog/Quine @@ -0,0 +1 @@ +../../Task/Quine/Prolog \ No newline at end of file diff --git a/Lang/Prolog/Search_a_list b/Lang/Prolog/Search_a_list new file mode 120000 index 0000000000..8a96918829 --- /dev/null +++ b/Lang/Prolog/Search_a_list @@ -0,0 +1 @@ +../../Task/Search_a_list/Prolog \ No newline at end of file diff --git a/Lang/R/0DESCRIPTION b/Lang/R/0DESCRIPTION new file mode 100644 index 0000000000..471e1915ca --- /dev/null +++ b/Lang/R/0DESCRIPTION @@ -0,0 +1,11 @@ +{{language|R +|site=http://www.r-project.org/ +|express=implicit}} + +R is a language and environment for statistical computing and graphics. It is a GNU project which is similar to the S language and environment which was developed at Bell Laboratories (formerly AT&T, now Lucent Technologies) by John Chambers and colleagues. R can be considered as a different implementation of S. There are some important differences, but much code written for S runs unaltered under R.http://www.r-project.org/about.html + +==See Also== +* [[wp:R_%28programming_language%29|Wikipedia:R (programming language)]] + +==References== + \ No newline at end of file diff --git a/Lang/R/99_Bottles_of_Beer b/Lang/R/99_Bottles_of_Beer new file mode 120000 index 0000000000..fc2ed261b6 --- /dev/null +++ b/Lang/R/99_Bottles_of_Beer @@ -0,0 +1 @@ +../../Task/99_Bottles_of_Beer/R \ No newline at end of file diff --git a/Lang/R/Anagrams b/Lang/R/Anagrams new file mode 120000 index 0000000000..f61711c735 --- /dev/null +++ b/Lang/R/Anagrams @@ -0,0 +1 @@ +../../Task/Anagrams/R \ No newline at end of file diff --git a/Lang/R/Bulls_and_cows b/Lang/R/Bulls_and_cows new file mode 120000 index 0000000000..528e4a7c17 --- /dev/null +++ b/Lang/R/Bulls_and_cows @@ -0,0 +1 @@ +../../Task/Bulls_and_cows/R \ No newline at end of file diff --git a/Lang/R/Comments b/Lang/R/Comments new file mode 120000 index 0000000000..351773dec8 --- /dev/null +++ b/Lang/R/Comments @@ -0,0 +1 @@ +../../Task/Comments/R \ No newline at end of file diff --git a/Lang/R/Entropy b/Lang/R/Entropy new file mode 120000 index 0000000000..fc35b3e5b5 --- /dev/null +++ b/Lang/R/Entropy @@ -0,0 +1 @@ +../../Task/Entropy/R \ No newline at end of file diff --git a/Lang/R/FizzBuzz b/Lang/R/FizzBuzz new file mode 120000 index 0000000000..334918c628 --- /dev/null +++ b/Lang/R/FizzBuzz @@ -0,0 +1 @@ +../../Task/FizzBuzz/R \ No newline at end of file diff --git a/Lang/R/Infinity b/Lang/R/Infinity new file mode 120000 index 0000000000..d1724239ea --- /dev/null +++ b/Lang/R/Infinity @@ -0,0 +1 @@ +../../Task/Infinity/R \ No newline at end of file diff --git a/Lang/R/JSON b/Lang/R/JSON new file mode 120000 index 0000000000..35e56b96e0 --- /dev/null +++ b/Lang/R/JSON @@ -0,0 +1 @@ +../../Task/JSON/R \ No newline at end of file diff --git a/Lang/R/Knuth_shuffle b/Lang/R/Knuth_shuffle new file mode 120000 index 0000000000..5834b5c521 --- /dev/null +++ b/Lang/R/Knuth_shuffle @@ -0,0 +1 @@ +../../Task/Knuth_shuffle/R \ No newline at end of file diff --git a/Lang/R/Quine b/Lang/R/Quine new file mode 120000 index 0000000000..bb5d9fdbd0 --- /dev/null +++ b/Lang/R/Quine @@ -0,0 +1 @@ +../../Task/Quine/R \ No newline at end of file diff --git a/Lang/R/Search_a_list b/Lang/R/Search_a_list new file mode 120000 index 0000000000..b664e990ca --- /dev/null +++ b/Lang/R/Search_a_list @@ -0,0 +1 @@ +../../Task/Search_a_list/R \ No newline at end of file diff --git a/Lang/Racket/0DESCRIPTION b/Lang/Racket/0DESCRIPTION new file mode 100644 index 0000000000..611195ed12 --- /dev/null +++ b/Lang/Racket/0DESCRIPTION @@ -0,0 +1,5 @@ +{{language}} +'''Racket''' (at one time called 'PLT Scheme') is a member of the Lisp and Scheme family of languages. The Racket language (like Clojure, for example) draws freely from the various strands of its lineage. + +* [http://racket-lang.org Home page] +* [http://en.wikipedia.org/wiki/Racket_(programming_language) Wikipedia] \ No newline at end of file diff --git a/Lang/Racket/99_Bottles_of_Beer b/Lang/Racket/99_Bottles_of_Beer new file mode 120000 index 0000000000..31b4163399 --- /dev/null +++ b/Lang/Racket/99_Bottles_of_Beer @@ -0,0 +1 @@ +../../Task/99_Bottles_of_Beer/Racket \ No newline at end of file diff --git a/Lang/Racket/Anagrams b/Lang/Racket/Anagrams new file mode 120000 index 0000000000..63ac89e810 --- /dev/null +++ b/Lang/Racket/Anagrams @@ -0,0 +1 @@ +../../Task/Anagrams/Racket \ No newline at end of file diff --git a/Lang/Racket/Comments b/Lang/Racket/Comments new file mode 120000 index 0000000000..5554e9b303 --- /dev/null +++ b/Lang/Racket/Comments @@ -0,0 +1 @@ +../../Task/Comments/Racket \ No newline at end of file diff --git a/Lang/Racket/Entropy b/Lang/Racket/Entropy new file mode 120000 index 0000000000..4b7c4d9942 --- /dev/null +++ b/Lang/Racket/Entropy @@ -0,0 +1 @@ +../../Task/Entropy/Racket \ No newline at end of file diff --git a/Lang/Racket/FizzBuzz b/Lang/Racket/FizzBuzz new file mode 120000 index 0000000000..5ca1c198cd --- /dev/null +++ b/Lang/Racket/FizzBuzz @@ -0,0 +1 @@ +../../Task/FizzBuzz/Racket \ No newline at end of file diff --git a/Lang/Racket/Infinity b/Lang/Racket/Infinity new file mode 120000 index 0000000000..3674f42cbf --- /dev/null +++ b/Lang/Racket/Infinity @@ -0,0 +1 @@ +../../Task/Infinity/Racket \ No newline at end of file diff --git a/Lang/Racket/JSON b/Lang/Racket/JSON new file mode 120000 index 0000000000..03f79ad68c --- /dev/null +++ b/Lang/Racket/JSON @@ -0,0 +1 @@ +../../Task/JSON/Racket \ No newline at end of file diff --git a/Lang/Racket/Pi b/Lang/Racket/Pi new file mode 120000 index 0000000000..e105ec2952 --- /dev/null +++ b/Lang/Racket/Pi @@ -0,0 +1 @@ +../../Task/Pi/Racket \ No newline at end of file diff --git a/Lang/Racket/Search_a_list b/Lang/Racket/Search_a_list new file mode 120000 index 0000000000..ead9d8b6ae --- /dev/null +++ b/Lang/Racket/Search_a_list @@ -0,0 +1 @@ +../../Task/Search_a_list/Racket \ No newline at end of file diff --git a/Lang/Sather/0DESCRIPTION b/Lang/Sather/0DESCRIPTION new file mode 100644 index 0000000000..9c4b46b2b9 --- /dev/null +++ b/Lang/Sather/0DESCRIPTION @@ -0,0 +1,7 @@ +{{stub}} +{{language|Sather +|site=http://www.gnu.org/software/sather/ +|LCT=no +}} + +Sather is an object oriented language designed to be simple, efficient, safe, flexible and non-proprietary. One way of placing it in the "space of languages" is to say that it aims to be as efficient as C, C++, or Fortran, as elegant as and safer than Eiffel, and support higher-order functions and iteration abstraction as well as Common Lisp, CLU or Scheme \ No newline at end of file diff --git a/Lang/Sather/99_Bottles_of_Beer b/Lang/Sather/99_Bottles_of_Beer new file mode 120000 index 0000000000..22f0abb2d0 --- /dev/null +++ b/Lang/Sather/99_Bottles_of_Beer @@ -0,0 +1 @@ +../../Task/99_Bottles_of_Beer/Sather \ No newline at end of file diff --git a/Lang/Sather/Comments b/Lang/Sather/Comments new file mode 120000 index 0000000000..22fb92cca3 --- /dev/null +++ b/Lang/Sather/Comments @@ -0,0 +1 @@ +../../Task/Comments/Sather \ No newline at end of file diff --git a/Lang/Sather/FizzBuzz b/Lang/Sather/FizzBuzz new file mode 120000 index 0000000000..4bc72c99fe --- /dev/null +++ b/Lang/Sather/FizzBuzz @@ -0,0 +1 @@ +../../Task/FizzBuzz/Sather \ No newline at end of file diff --git a/Lang/Sather/Search_a_list b/Lang/Sather/Search_a_list new file mode 120000 index 0000000000..42ebc7bcea --- /dev/null +++ b/Lang/Sather/Search_a_list @@ -0,0 +1 @@ +../../Task/Search_a_list/Sather \ No newline at end of file diff --git a/Lang/Scheme/0DESCRIPTION b/Lang/Scheme/0DESCRIPTION new file mode 100644 index 0000000000..f549eef576 --- /dev/null +++ b/Lang/Scheme/0DESCRIPTION @@ -0,0 +1,21 @@ +{{language|Scheme +|strength=strong +|safety=safe +|express=implicit +|checking=dynamic +|parampass=value +|gc=yes +|LCT=yes +|bnf=http://www.r6rs.org/final/html/r6rs/r6rs-Z-H-7.html#node_chap_4}} +{{codepad}} +{{language programming paradigm|functional}} +'''Scheme''' is a multi-[[:Category:Programming Paradigms|paradigm]] programming language. It is one of the two main dialects of [[derived from::Lisp]] and supports a number of programming paradigms but is best known for its support of [[functional programming]]. It was developed by Guy L. Steele and Gerald Jay Sussman in the 1970s. Scheme was introduced to the academic world via a series of papers now referred to as Sussman and Steele's Lambda Papers. There are two standards that define the Scheme language: the official [[IEEE]] standard, and a de facto standard called the ''Revisedn Report on the Algorithmic Language Scheme'', nearly always abbreviated R''n''RS, where ''n'' is the number of the revision. The current standard is '''R6RS''', and '''R7RS''' is in development. + +Scheme's philosophy is minimalist. Scheme provides as few primitive notions as possible, and, where practical, lets everything else be provided by programming libraries. + +Scheme was the first dialect of Lisp to choose static (a.k.a. lexical) over dynamic variable scope. It was also one of the first programming languages to support first-class continuations. + +==Citations== +* [[wp:Scheme_%28programming_language%29|Wikipedia:Scheme (programming language)]] + +{{implementation|Lisp}} \ No newline at end of file diff --git a/Lang/Scheme/99_Bottles_of_Beer b/Lang/Scheme/99_Bottles_of_Beer new file mode 120000 index 0000000000..312517d613 --- /dev/null +++ b/Lang/Scheme/99_Bottles_of_Beer @@ -0,0 +1 @@ +../../Task/99_Bottles_of_Beer/Scheme \ No newline at end of file diff --git a/Lang/Scheme/Bulls_and_cows b/Lang/Scheme/Bulls_and_cows new file mode 120000 index 0000000000..3c681e7253 --- /dev/null +++ b/Lang/Scheme/Bulls_and_cows @@ -0,0 +1 @@ +../../Task/Bulls_and_cows/Scheme \ No newline at end of file diff --git a/Lang/Scheme/Comments b/Lang/Scheme/Comments new file mode 120000 index 0000000000..50b7e7efaf --- /dev/null +++ b/Lang/Scheme/Comments @@ -0,0 +1 @@ +../../Task/Comments/Scheme \ No newline at end of file diff --git a/Lang/Scheme/FizzBuzz b/Lang/Scheme/FizzBuzz new file mode 120000 index 0000000000..8ef762c9ae --- /dev/null +++ b/Lang/Scheme/FizzBuzz @@ -0,0 +1 @@ +../../Task/FizzBuzz/Scheme \ No newline at end of file diff --git a/Lang/Scheme/Infinity b/Lang/Scheme/Infinity new file mode 120000 index 0000000000..2a367dd508 --- /dev/null +++ b/Lang/Scheme/Infinity @@ -0,0 +1 @@ +../../Task/Infinity/Scheme \ No newline at end of file diff --git a/Lang/Scheme/Knuth_shuffle b/Lang/Scheme/Knuth_shuffle new file mode 120000 index 0000000000..dd920653e3 --- /dev/null +++ b/Lang/Scheme/Knuth_shuffle @@ -0,0 +1 @@ +../../Task/Knuth_shuffle/Scheme \ No newline at end of file diff --git a/Lang/Scheme/Ordered_words b/Lang/Scheme/Ordered_words new file mode 120000 index 0000000000..97e371f544 --- /dev/null +++ b/Lang/Scheme/Ordered_words @@ -0,0 +1 @@ +../../Task/Ordered_words/Scheme \ No newline at end of file diff --git a/Lang/Scheme/Quine b/Lang/Scheme/Quine new file mode 120000 index 0000000000..0f84760452 --- /dev/null +++ b/Lang/Scheme/Quine @@ -0,0 +1 @@ +../../Task/Quine/Scheme \ No newline at end of file diff --git a/Lang/Scheme/Search_a_list b/Lang/Scheme/Search_a_list new file mode 120000 index 0000000000..e5926d0d37 --- /dev/null +++ b/Lang/Scheme/Search_a_list @@ -0,0 +1 @@ +../../Task/Search_a_list/Scheme \ No newline at end of file diff --git a/Lang/Smalltalk/0DESCRIPTION b/Lang/Smalltalk/0DESCRIPTION new file mode 100644 index 0000000000..17206b03cc --- /dev/null +++ b/Lang/Smalltalk/0DESCRIPTION @@ -0,0 +1,288 @@ +{{language|Smalltalk +|exec=bytecode +|strength=strong +|safety=safe +|express=implicit +|checking=dynamic +|parampass=value +|gc=yes +|LCT=yes +|bnf=http://github.com/aquasync/ruby-ometa/blob/60deea23abe7eb07d200233dde4213d74041b81f/smalltalk.syntax}} +{{language programming paradigm|Object-oriented}} +{{language programming paradigm|reflective}} +{{language programming paradigm|Dynamic}} +'''Smalltalk-80''' is an [[object-oriented programming|object-oriented]], dynamically typed, [[reflective programming]] language. It was designed and created in part for educational use, more so for Constructivist teaching, at Xerox PARC by Alan Kay, Dan Ingalls, Ted Kaehler, Adele Goldberg, and others during the 1970s, influenced by Sketchpad and Simula. + +The language was generally released as Smalltalk-80 and has been widely used since. Smalltalk-like languages are in continuing active development, and has gathered a loyal community of users around it. + +'''Smalltalk-80''' is a fully reflective system, implemented in itself. Smalltalk-80 provides both structural and computational reflection. Smalltalk is a structurally reflective system whose structure is defined by Smalltalk-80 objects. The classes and methods that define the system are themselves objects and fully part of the system that they help define. The Smalltalk compiler compiles textual source code into method objects, typically instances of CompiledMethod. These get added to classes by storing them in a class's method dictionary. The part of the class hierarchy that defines classes can add new classes to the system. The system is extended by running Smalltalk-80 code that creates or redefines classes and methods. In this way a Smalltalk-80 system is a "living" system, carrying around the ability to extend itself at run-time. + +==Implementations== +Over time, various implementations ("dialects") of Smalltalk have appeared, some of which target different audiences and/or focus on particular applications. Their internal implementation (evaluation mechanism) may also differ radically, from bytecode interpretation, just-in-time compilation, dynamic optimizing recompilation to cross-language translators (Smalltalk-to-C, Smalltalk-to-JavaScript, Smalltalk-to-Java). + +==Spirit== +Smalltalk consist of both the programming language and a more or less standardized library of classes. Most Smalltalks also include a sophisticated IDE, which supports editing, compiling, refactoring, debugging, tools, source code revisioning and packaging/deployment. With a few exceptions, working in a traditional editor (vi, emacs) or general purpose IDE (eclipse) is usually not recommended, as these cannot make use of all the reflective and dynamic coding features and will make the programmer less productive. For example, typical Smalltalk debuggers allow for code to be changed while the program is running (or halted at a breakpoint), allowing for a "programming in the debugger" style of coding. Code is usually developed and tested incrementally, with breakpoints on unimplemented parts, which are filled as encountered. This makes Smalltalk a perfect environment for rapid prototyping and experimental development. + +Smalltalk environments are open - almost every aspect of the language and IDE can be changed, enhanced and customized. This includes object representation, metaclass and reflection facilities, language syntax, exception handling and the IDE itself. For this reason, Smalltalk has traditionally been a testbed for new language features, mechanisms and patterns. + +Smalltalk is a very high level language, which almost completely hides any underlying machine representation. Implementation details such as integer size, pointer size, byte order etc. are invisible. The numeric tower is highly polymorphic, allowing for transparent use of arbitrary large integers, fractions, floats, complex numbers etc. + +Smalltalk is a very late bound language. Object types, classes, references etc. are resolved at execution time, and can be dynamically changed. + +==Language Syntax== +Smalltalk has a very simple and highly orthogonal syntax, which is based exclusively on message sending (aka pure virtual function calling in C-parlance). The language syntax and semantic only consists of literal (compile-time) constants, variable bindings, message sends and block closures (lambda expression objects). Control flow, loop constructs, exception handling etc. are defined as messages to booleans, blocks or by passing blocks as arguments. This makes it trivial and common practice to add new control constructs. + +=== Grammar === +... to be added ... (for now follow the link at the right...) + +== Language Semantic == + +=== Variables and Scope === +Variables are used to name objects. Actually they are bindings of a name to an object. Objects can only be passed and used by reference, and access to an object's internals is not possible from outside the object's own method implementation, although most classes inherit from Object, which provides some reflection protocol to access instance variables or to query for the class. However, such inherited reflection mechanisms could be overwritten in a class or a class could not inherit from Object, to prevent even access from debuggers and inspectors. + +Smalltalk is lexically scoped, and outer variable bindings are closed over when a block (=lambda closure) is created. + +A rich scoping hierarchy exists, which consists of: +* inner block locals +* inner block arguments +* outer block locals +* outer block arguments +* method locals +* method arguments +* instance variable slots +* inherited instance variable slots +* class variables (static, shared with subclasses; visible in the class-hierarchy only) +* class instance variables (per-class-instance; private to the class) +* pool variables (for constant pools; must be explicitly "imported" to be seen) +* namespaces / globals (for classes to be known by name) + +=== Objects === +In Smalltalk, every object is an instance of some class. Objects are only be referred to by reference. Everything is an object, including integers, booleans, nil (the UndefinedObject), classes, stack frames (continuations), exception handlers and code (block closures/lambda closures and methods). There are no builtin primitive types, which are not part of the class hierarchy, or which cannot be changed/enhanced by the user. + +=== Message Sending === +Message sends are dynamically resolved, by letting the receiver of the message determine the method (aka code to run). The message consist of a selector (= name of the message) and optional arguments. The message syntax as: +receiver selector +a unary message, without arguments. + +receiver part1: arg1 part2: arg2 ... partN: argN +a keyword message; the selector consists of the concatenation of the keyword parts: 'part1:part2:...partN:'. + +receiver op arg +a so called ''binary message''. The selector 'op' consists of one or more special characters, such as '+', -', '@' etc. +These are actually syntactic sugar, especially to make arithmetic look more familiar (i.e. instead of "rcvr add: foo" we can write "rcvr + foo"). + +The precedence rules are unary > binary > keyword, thus +a foo: b bar + c baz is equivalent to a foo:( (b bar) + (c baz) ) + +As messages have no semantic meaning to the compiler (especially, the '+', '*' and other binary messages), the usual precedence rules for arithmetic expressions are not present in Smalltalk. Thus, complex expressions consisting of multiple binary messages usually need to be parenthesized. + +Message lookup is done by traversing the superclass chain, looking for a class providing an implementation (method) for the messages selector. The standard defines single inheritance, with a lookup based on the receiver's class only. However, some Smalltalk implementations allow for that lookup to be redefined and provide more sophisticated mechanisms (selector namespaces, lookup objects, lookup based on argument types etc.). + +If no implementation is found (i.e. no class along the superclass chain provides a corresponding method), the original selector and arguments are packed into a container and a doesNotUnderstand: message is sent instead. This is used for error handling, but can also be used for message forwarding (proxies), delegation or dynamic creation of new code. The default implementation of doesNotUnderstand: raises an exception, which can be cought and handled by the program. + +=== Metaclass Hierarchy === +Classes themself are objects and as such instances of some Metaclass. As classes define and provide the protocol (=set of methods) for their instances, metaclasses define and provide the protocol for their instances, the corresponding class. Every class has its own metaclass and as such can implement new class-side messages. Typically, instance creation and utility code is found on the class side. Most Smalltalk dialects allow for the metaclass to specify and return the type of compiler or other tools to be used when code is to be installed. This allows for DSLs or other programming language syntax to be implemented seamlessly by defining a metaclass which returns a compiler for a non-Smalltalk. Typical examples for this are parser generators (tgen, ometa, petite parser), data representation specs (asn1, xml etc.) and languages (smallRuby, graphical languages in squeak etc.) + +Being objects, classes and metaclasses can be created dynamically, by sending a #subclass:... message to another class, or my instantiating a new metaclass. + +=== Exception Handling === +Smalltalk protects itself completely from any invalid memory references, null-pointer, array bounds or unimplemented message situations, by raising a corresponding exception which can be cought by the program. An unhandled exception leads to the evaluation of a default handler, which usually opens a symbolic debugger, which is always part of the Smalltalk environment. Deployed end-user and production systems usually redefine this handler to show a warning, end the program or dump the state of the system. + +In contrast to most other exception handling systems, Smalltalk exceptions are both restartable and proceedable. The exception handler is evaluated with the calling chain of continuations (stack frames) still being active and alive. The handler is free to repair the situation and proceed. Proceedability allows for queries and notifications to be implemented easily using exceptions; for example, a compiler's warnings or error correction queries can be implemented this way, without a need to pass in logger objects or other state. Also situations like missing files (OpenError) can be resolved in the handler, by opening a dialog, asking the user for a replacement and proceed. + +The exception framework is implemented as part of the class library, and open for change and enhancement. + +== Examples == +As smalltalk code seems to be hard to read for programmers with a C background, some examples are provided below. +=== Literals === + +"a comment - everything in between double quotes" + +"/ an end-of-line comment (dialect specific) + +true false "the two Boolean singleton objects" + +nil "the UndefinedObject singleton object" + +1234 "integer constant; an instance of Integer" + +16rFF00 "integer constant, base 16" + +2r101010 "integer constant, base 2" + +1.234 "float constant; an instance of Float" + +(1/7) "fraction constant; an instance of Fraction" + +123s3 "fixed point constant with precision (somewhat dialect specific) + +'hello' "string constant; an instance of String" + +#'foo' "symbol constant; similar to symbols in lisp, two symbols are identical if they are equal" + +#(1 true $a 16rFF 1.0 (10 20)) "array literal constant; the last element being another array; an instance of Array" + +#[ 10 20 2r1000 16rFE ] "byte-array literal constant; an instance of ByteArray" + +$a "character constant" + +[ ... some code ... ] "a block literal; an instance of BlockClosure (dialect specific); the object represents the piece of code which can be passed around and evaluated later (a lambda closure)" + +[:a1 ... :aN | ... some code ...] "a block literal with arguments." + + +===Message Sends=== + +1000 factorial "send the 'factorial' message to the integer receiver" + +a factorial even "send the 'factorial' message to whatever "a" refers to, then send 'even' to whatever that returned" + +a + 1 "send a '+' message, passing the argument '1' to whatever a refers to" + +(a + 1) squared "send '+' to a, then send 'squared' to whatever we get from it" + +a , b "send the (binary) ',' message, which does collection-concatenation (arrays, strings, etc) + +arr at:1 put:'foo' "send the 'at:put:' message to 'arr', passing two arguments, the integer '1' and a string" + +a > b ifTrue: [ a print ] "send the 'ifTrue:' message to whatever 'a > b' returned (a boolean, usually), passing a block closure as argument. The implementation of boolean will either evaluate or not evaluate the passed block's code" + +a > b ifTrue: [ a ] ifFalse: [b] "send 'ifTrue:ifFalse:' to the object returned by 'a > b', passing two block closures as arguments. The 'ifTrue:ifFalse:' method will evaluate one of them and return that block's return value as its own return value" + +b := [ ... somCode... ]. +... +b value "evaluate the block's code" + + +=== Other === + +expr1 . expr2 "statements within a method or block are separated by a fullstop." + +foo := bar "assignment; let foo refer to the object to which bar refers to (at that particular point in time)" + +^ a + 1 "return; the value of the 'a+1' message send is returned as the value of the current method invocation." + +'hello' print. 'world' print "statements are separated by a period; just like in english" + +|a b c| "local variables; introduces 'a', 'b' and 'c' in the current scope (let-like local bindings)" + +r msg1; msg2 "so called cascade; first send msg1 to r, ignoring the return value, then send msg2. + Value of expression is result from last message. Syntactic sugar for r msg1. r msg2 but an expression, not a statement" + + +=== Class Definition === +Classes are not defined by syntactic constructs, but by sending a message to some class (to create a subclass), a metaclass (to create an instance) or to a namespace (to create a class and install it). The details vary slightly among dialects, but usually wrappers/forwarders are provided or easily added if code is to be ported and any is missing in the target system. + +someClass + subClass: #'nameOfNewClass' + instanceVariableNames: '...list of private slots...' + classVariableNames: '...list of class variables...' + poolDictionaries: '..list of imported pool bindings...' + category: 'for documentation only'. + +Classes can be anonymous, in most systems, you can "Class new new" to create a new anonymous class and an instance of it (but be aware, that the class should contain enough state to properly specify their instances layout, so usually more info is needed (number and names of instance variables, inheritance etc.) + +=== Control Structures === +As mentioned above, these are defined as messages and their implementation is found in the corresponding receiver classes. The following is only a tiny subset - there are virtually hundreds of uses of blocks for control structures in the system. +Typical are: + +boolean ifTrue: [ block providing value if boolean is true ] + +boolean ifFalse: [ block providing value if boolean is false ] + +boolean ifTrue: [ value if boolean is true ] ifFalse: [ value if boolean is false ] + +[ block for condition ] whileTrue: [ block to be looped over ] + +n timesRepeat: [ block to be looped over ] + +start to: stop do: [:i | block to be looped over with index ] + +collection do: [:el | block to be evaluated for each element ] + + +=== Exception Handling === +Originally, Smalltalk used an instance based exception handling scheme, where instances of Signal where created and raised. Now, all implementations have moved to class based exceptions, where the raised exception is a subclass of Exception. As instance based exception handling is still useful in some situations (very lightweight, no need to create a class), some dialects continue to support both. + +Smalltalk supports proceedable exceptions. + + +[ try block to be evaluated ] on: exception do:[:ex | handler ] + +the 'ex' argument to the hander provides detail information (where and why) and also allows control of how to proceed out of the handler (ex proceed, ex return, ex restart, ex reject). +The handler basically has the following options: +* ex return - return out of the try block +* ex restart - restart the try block +* ex reject - handler cannot handle; rethrow the exception for an outer handler +* ex proceedWith: value - proceed after where the exception was raised (after a repair) +Exceptions may be specified to be nonProceedable, to protect code from proceeding handlers, where proceeding is not possible. +Exceptions form a hierarchy, so a handler will also catch any derived exceptions. If an exception is unhandled, the original exception info is packed up and an UnhandledException is raised. Thus (similar to the handling of doesNotUnderstand:). The default handler for UnhandledException opens a debugger for the misbehaving thread (while usually other threads continue to operate as usual). + +Handlers can also be defined to handle a collection of non-related exceptions, by creating an exceptionSet: + +[ try block to be evaluated ] on: ZeroDivide, DomainError do:[:ex | handler ] + +finally, many dialects provide syntactic sugar for common situations: + +exception catch: [ action ] - to return out of the action, without any particular handler action + +exception ignoreIn: [ action ] - to ignore the exception and proceed (for example: a UserInterruptSignal, as generated by the CTRL-C key) + + +=== Unwinding === +Ensure blocks to make sure that cleanup is performed correctly even in exception situations are defined as: + +[ action to be performed ] ensure: [ action to cleanup] - will cleanup in any case (i.e. both in normal and in unwind situations) + +[ action to be performed ] ifCurtailed: [ action to cleanup] - will cleanup only in unwind situations + + +=== Multithreading === +New threads are started by sending 'fork' to a block; this will create a process instance which executes the block's code in a separate thread (within the same address space): + +[ do something ] fork. + +[ do something ] forkAt: priorityLevel + +the scheduling behavior is not standard among dialects; some only manual switches by explicit yield, most provide sctrict priority based scheduling, and some even provide preemtive timeslicing, and dynamic priorities. The details also depend on the underlying operating system. + +== Implementation == +Most Smalltalk implementations are based on a bytecode execution engine. Bytecode is emitted and stored in method objects by a compiler which is part of both the development and runtime environment (in contrast to external tools, like javac). Bytecodes are operations for a virtual stack based machine, which is either interpreted by an interpreter (part of the runtime system), or dynamically compiled to machine code (JITTER). Bytecode is not standardized and usually not compatible among dialects. + +Some implementations support source-to-source compilation to C, JavaScript or Java. These may or may not show some limitations in the support for dynamic changes at execution time. Typically, the full dynamic bytecode is used for development, followed by a compilation phase for deployment/packaging. + +All Smalltalks use and depend on garbage collection for automatic reclamation of unused objects, and most implementations use modern algorithms such as generation scavenging, incremental mark&sweep and finalization support. Imprecise conservative collectors are typically not used. Reference counting was abandoned in the 70s. + +As message send performance is critical in Smalltalk, highly tuned cache mechanisms have been invented and are used: inline caches, polymorph inline caches, dynamic recompilation based on receiver and/or argument types etc. +Also block creation and evaluation, especially the treatment of closed over variables has been in the focus of implementors. Algorithms similar to those found in sophisticated Lisp systems such as lambda lifting, inlining, stack allocation and heap migration etc. are also used in Smalltalk. + +== Influences == +Smalltalk syntax is meant to be read like english sentences. + +Smalltalk's symbols correspond to Lisp symbols, blocks are syntactic sugar for lambda closures. + +ObjectiveC's message send, syntax and keyword format is a direct subset of the corresponding Smalltalk message send syntax. Also the semantic of its classes and instances are similar. However, the reflection and metaclass facilities are a small subset. + +Java's container and stream class hierarchy has similarities to Smalltalk collection classes. MVC as used in many toolkits has been in Smalltalk for a long time. + +Self a descendent of Smalltalk, uses a similar syntax, blocks and exception facilities, but adds instance based inheritance, dynamic slots and mirrors. + +Slate and Newspeak use similar syntax and message send semantics + +JavaScript's functions are a syntactic different but semantically equal to Smalltalk's blocks, including scoping rules (but lack the capability of returning from their containing function). + +==Implementations== + +* Amber Smalltalk +* Dolphin Smalltalk; (still actively developed?) +* GNU Smalltalk; open source +* Pharo; open source, mostly compatible to Squeak +* S# +* Smalltalk/X; free for private and commercial use +* Smalltalk-MT; (still actively developed?) +* Squeak; open source +* VisualAge Smalltalk (Instantiations; formerly known as IBM Smalltalk); free for private use +* VisualWorks (Cincom) Smalltalk; free for private use + +==Citations== +* [[wp:SmallTalk|Wikipedia:Smalltalk]] \ No newline at end of file diff --git a/Lang/Smalltalk/99_Bottles_of_Beer b/Lang/Smalltalk/99_Bottles_of_Beer new file mode 120000 index 0000000000..1c80f9caea --- /dev/null +++ b/Lang/Smalltalk/99_Bottles_of_Beer @@ -0,0 +1 @@ +../../Task/99_Bottles_of_Beer/Smalltalk \ No newline at end of file diff --git a/Lang/Smalltalk/Anagrams b/Lang/Smalltalk/Anagrams new file mode 120000 index 0000000000..7a1cde93b8 --- /dev/null +++ b/Lang/Smalltalk/Anagrams @@ -0,0 +1 @@ +../../Task/Anagrams/Smalltalk \ No newline at end of file diff --git a/Lang/Smalltalk/Bulls_and_cows b/Lang/Smalltalk/Bulls_and_cows new file mode 120000 index 0000000000..4c82b88f2b --- /dev/null +++ b/Lang/Smalltalk/Bulls_and_cows @@ -0,0 +1 @@ +../../Task/Bulls_and_cows/Smalltalk \ No newline at end of file diff --git a/Lang/Smalltalk/Comments b/Lang/Smalltalk/Comments new file mode 120000 index 0000000000..ce5c6f67fe --- /dev/null +++ b/Lang/Smalltalk/Comments @@ -0,0 +1 @@ +../../Task/Comments/Smalltalk \ No newline at end of file diff --git a/Lang/Smalltalk/FizzBuzz b/Lang/Smalltalk/FizzBuzz new file mode 120000 index 0000000000..515eb0b03f --- /dev/null +++ b/Lang/Smalltalk/FizzBuzz @@ -0,0 +1 @@ +../../Task/FizzBuzz/Smalltalk \ No newline at end of file diff --git a/Lang/Smalltalk/Infinity b/Lang/Smalltalk/Infinity new file mode 120000 index 0000000000..7e8942c626 --- /dev/null +++ b/Lang/Smalltalk/Infinity @@ -0,0 +1 @@ +../../Task/Infinity/Smalltalk \ No newline at end of file diff --git a/Lang/Smalltalk/Knuth_shuffle b/Lang/Smalltalk/Knuth_shuffle new file mode 120000 index 0000000000..19a87579cf --- /dev/null +++ b/Lang/Smalltalk/Knuth_shuffle @@ -0,0 +1 @@ +../../Task/Knuth_shuffle/Smalltalk \ No newline at end of file diff --git a/Lang/Smalltalk/Ordered_words b/Lang/Smalltalk/Ordered_words new file mode 120000 index 0000000000..05e05bb115 --- /dev/null +++ b/Lang/Smalltalk/Ordered_words @@ -0,0 +1 @@ +../../Task/Ordered_words/Smalltalk \ No newline at end of file diff --git a/Lang/Smalltalk/Quine b/Lang/Smalltalk/Quine new file mode 120000 index 0000000000..f60456cb72 --- /dev/null +++ b/Lang/Smalltalk/Quine @@ -0,0 +1 @@ +../../Task/Quine/Smalltalk \ No newline at end of file diff --git a/Lang/Smalltalk/Search_a_list b/Lang/Smalltalk/Search_a_list new file mode 120000 index 0000000000..858c723186 --- /dev/null +++ b/Lang/Smalltalk/Search_a_list @@ -0,0 +1 @@ +../../Task/Search_a_list/Smalltalk \ No newline at end of file diff --git a/Task/99_Bottles_of_Beer/ActionScript/99_bottles_of_beer.as b/Task/99_Bottles_of_Beer/ActionScript/99_bottles_of_beer.as new file mode 100644 index 0000000000..38c9afc0f0 --- /dev/null +++ b/Task/99_Bottles_of_Beer/ActionScript/99_bottles_of_beer.as @@ -0,0 +1,7 @@ +for(var numBottles:uint = 99; numBottles > 0; numBottles--) +{ + trace(numBottles, " bottles of beer on the wall"); + trace(numBottles, " bottles of beer"); + trace("Take one down, pass it around"); + trace(numBottles - 1, " bottles of beer on the wall\n"); +} diff --git a/Task/99_Bottles_of_Beer/Babel/99_bottles_of_beer.pb b/Task/99_Bottles_of_Beer/Babel/99_bottles_of_beer.pb new file mode 100644 index 0000000000..2d61ab35e4 --- /dev/null +++ b/Task/99_Bottles_of_Beer/Babel/99_bottles_of_beer.pb @@ -0,0 +1,17 @@ +main: { 99 bottles } + +bottles!: + { x set + { bw + bx cr << + "Take one down, pass it around\n" << + 1 x -= + bw "\n" << } + x times } + +b : " bottles of beer" +bx!: { x %d << b } +w : " on the wall" +bw!: { bx w . cr << } + +x: [0] diff --git a/Task/99_Bottles_of_Beer/Dylan/99_bottles_of_beer.dylan b/Task/99_Bottles_of_Beer/Dylan/99_bottles_of_beer.dylan new file mode 100644 index 0000000000..d27359219f --- /dev/null +++ b/Task/99_Bottles_of_Beer/Dylan/99_bottles_of_beer.dylan @@ -0,0 +1,10 @@ +Module: bottles +define method bottles (n :: ) + for (n from 99 to 1 by -1) + format-out("%d bottles of beer on the wall,\n" + "%d bottles of beer\n" + "Take one down, pass it around\n" + "%d bottles of beer on the wall\n", + n, n, n - 1); + end +end method diff --git a/Task/99_Bottles_of_Beer/Prolog/99_bottles_of_beer-2.pro b/Task/99_Bottles_of_Beer/Prolog/99_bottles_of_beer-2.pro new file mode 100644 index 0000000000..996a5d7fbf --- /dev/null +++ b/Task/99_Bottles_of_Beer/Prolog/99_bottles_of_beer-2.pro @@ -0,0 +1,19 @@ +line1(X):- line2(X),write(' on the wall'). +line2(0):- write('no more bottles of beer'). +line2(1):- write('1 bottle of beer'). +line2(X):- writef('%t bottles of beer',[X]). +line3(1):- write('Take it down, pass it around'). +line3(X):- write('Take one down, pass it around'). +line4(X):- line1(X). + +bottles(0):-!. +bottles(X):- + succ(XN,X), + line1(X),nl, + line2(X),nl, + line3(X),nl, + line4(XN),nl,nl, + !, + bottles(XN). + +:- bottles(99). diff --git a/Task/99_Bottles_of_Beer/Prolog/99_bottles_of_beer.pro b/Task/99_Bottles_of_Beer/Prolog/99_bottles_of_beer.pro new file mode 100644 index 0000000000..2160c6cb06 --- /dev/null +++ b/Task/99_Bottles_of_Beer/Prolog/99_bottles_of_beer.pro @@ -0,0 +1,10 @@ +bottles(0):-!. +bottles(X):- + writef('%t bottles of beer on the wall \n',[X]), + writef('%t bottles of beer\n',[X]), + write('Take one down, pass it around\n'), + succ(XN,X), + writef('%t bottles of beer on the wall \n\n',[XN]), + bottles(XN). + +:- bottles(99). diff --git a/Task/99_Bottles_of_Beer/R/99_bottles_of_beer-2.r b/Task/99_Bottles_of_Beer/R/99_bottles_of_beer-2.r new file mode 100644 index 0000000000..6e1f3d6005 --- /dev/null +++ b/Task/99_Bottles_of_Beer/R/99_bottles_of_beer-2.r @@ -0,0 +1,5 @@ +#only one line! +cat(paste(99:1,ifelse((99:1)!=1," bottles"," bottle")," of beer on the wall\n",99:1,ifelse((99:1)!=1," bottles"," bottle")," of beer\n","Take one down, pass it around\n",98:0,ifelse((98:0)!=1," bottles"," bottle")," of beer on the wall\n\n",sep=""),sep="") + +#alternative +cat(paste(lapply(99:1,function(i){paste(paste(rep(paste(i,' bottle',if(i!=1)'s',' of beer',sep=''),2),collapse =' on the wall\n'),'Take one down, pass it around',paste(i-1,' bottle',if(i!=2)'s',' of beer on the wall',sep=''), sep='\n')}),collapse='\n\n')) diff --git a/Task/99_Bottles_of_Beer/R/99_bottles_of_beer.r b/Task/99_Bottles_of_Beer/R/99_bottles_of_beer.r new file mode 100644 index 0000000000..ff73b7fb20 --- /dev/null +++ b/Task/99_Bottles_of_Beer/R/99_bottles_of_beer.r @@ -0,0 +1,16 @@ +#a naive function to sing for N bottles of beer... + +song = function(bottles){ + + for(i in bottles:1){ #for every integer bottles, bottles-1 ... 1 + + cat(bottles," bottles of beer on the wall \n",bottles," bottles of beer \nTake one down, pass it around \n", + bottles-1, " bottles of beer on the wall \n"," \n" ,sep="") #join and print the text (\n means new line) + + bottles = bottles - 1 #take one down... + + } + +} + +song(99)#play the song by calling the function diff --git a/Task/99_Bottles_of_Beer/Racket/99_bottles_of_beer.rkt b/Task/99_Bottles_of_Beer/Racket/99_bottles_of_beer.rkt new file mode 100644 index 0000000000..1f56319152 --- /dev/null +++ b/Task/99_Bottles_of_Beer/Racket/99_bottles_of_beer.rkt @@ -0,0 +1,11 @@ +#lang racket + +(define (plural n) + (string-append (number->string n) " bottle" (if (equal? n 1) "" "s"))) + +(define (sing bottles) + (printf "~a of beer on the wall\n~a of beer\nTake on down, pass it around\n~a of beer on the wall\n\n" + (plural bottles) (plural bottles) (plural (sub1 bottles)))) + +(for ((i (in-range 100 0 -1))) + (sing i)) diff --git a/Task/99_Bottles_of_Beer/Sather/99_bottles_of_beer.sa b/Task/99_Bottles_of_Beer/Sather/99_bottles_of_beer.sa new file mode 100644 index 0000000000..4c34fe298b --- /dev/null +++ b/Task/99_Bottles_of_Beer/Sather/99_bottles_of_beer.sa @@ -0,0 +1,14 @@ +class MAIN is + main is + s :STR; + p1 ::= "<##> bottle<#> of beer"; + w ::= " on the wall"; + t ::= "Take one down, pass it around\n"; + loop i ::= 99.downto!(0); + if i /= 1 then s := "s" else s := ""; end; + #OUT + #FMT(p1 + w + "\n", i, "s"); + #OUT + #FMT(p1 + "\n", i, "s"); + if i > 0 then #OUT + t; end; + end; + end; +end; diff --git a/Task/99_Bottles_of_Beer/Scheme/99_bottles_of_beer.ss b/Task/99_Bottles_of_Beer/Scheme/99_bottles_of_beer.ss new file mode 100644 index 0000000000..f05d51e6a0 --- /dev/null +++ b/Task/99_Bottles_of_Beer/Scheme/99_bottles_of_beer.ss @@ -0,0 +1,7 @@ +(define (bottles x) + (format #t "~a bottles of beer on the wall~%" x) + (format #t "~a bottles of beer~%" x) + (format #t "Take one down, pass it around~%") + (format #t "~a bottles of beer on the wall~%" (- x 1)) + (if (> (- x 1) 0) + (bottles (- x 1)))) diff --git a/Task/99_Bottles_of_Beer/Smalltalk/99_bottles_of_beer.st b/Task/99_Bottles_of_Beer/Smalltalk/99_bottles_of_beer.st new file mode 100644 index 0000000000..6209118238 --- /dev/null +++ b/Task/99_Bottles_of_Beer/Smalltalk/99_bottles_of_beer.st @@ -0,0 +1,15 @@ +Smalltalk at: #sr put: 0 ; at: #s put: 0 ! +sr := Dictionary new. +sr at: 0 put: ' bottle' ; + at: 1 put: ' bottles' ; + at: 2 put: ' of beer' ; + at: 3 put: ' on the wall' ; + at: 4 put: 'Take one down, pass it around' ! +99 to: 0 by: -1 do: [:v | v print. + ( v == 1 ) ifTrue: [ s := 0. ] + ifFalse: [ s := 1. ]. + Transcript show: (sr at:s) ; show: (sr at:2) ; show: (sr at:3) ; cr. + v print. + Transcript show: (sr at:s) ; show: (sr at:2) ; cr. + (v ~~ 0) ifTrue: [ Transcript show: (sr at:4) ; cr. ]. + ]. diff --git a/Task/Anagrams/Prolog/anagrams.pro b/Task/Anagrams/Prolog/anagrams.pro new file mode 100644 index 0000000000..9611168a5a --- /dev/null +++ b/Task/Anagrams/Prolog/anagrams.pro @@ -0,0 +1,49 @@ +:- use_module(library( http/http_open )). + +anagrams:- + % we read the URL of the words + http_open('http://www.puzzlers.org/pub/wordlists/unixdict.txt', In, []), + read_file(In, [], Out), + close(In), + + % we get a list of pairs key-value where key = a-word value = + % this list must be sorted + msort(Out, MOut), + + % in order to gather values with the same keys + group_pairs_by_key(MOut, GPL), + + % we sorted this list in decreasing order of the length of values + predsort(my_compare, GPL, GPLSort), + + % we extract the first 6 items + GPLSort = [_H1-T1, _H2-T2, _H3-T3, _H4-T4, _H5-T5, _H6-T6 | _], + + % Tnn are lists of codes (97 for 'a'), we create the strings + maplist(maplist(atom_codes), L, [T1, T2, T3, T4, T5, T6] ), + + maplist(writeln, L). + + +read_file(In, L, L1) :- + read_line_to_codes(In, W), + ( W == end_of_file -> + % the file is read + L1 = L + ; + % we sort the list of codes of the line + msort(W, W1), + + % to create the key in alphabetic order + atom_codes(A, W1), + + % and we have the pair Key-Value in the result list + read_file(In, [A-W | L], L1)). + +% predicate for sorting list of pairs Key-Values +% if the lentgh of values is the same +% we sort the keys in alhabetic order +my_compare(R, K1-V1, K2-V2) :- + length(V1, L1), + length(V2, L2), + ( L1 < L2 -> R = >; L1 > L2 -> R = <; compare(R, K1, K2)). diff --git a/Task/Anagrams/R/anagrams.r b/Task/Anagrams/R/anagrams.r new file mode 100644 index 0000000000..428f07e981 --- /dev/null +++ b/Task/Anagrams/R/anagrams.r @@ -0,0 +1,22 @@ +words <- readLines("http://www.puzzlers.org/pub/wordlists/unixdict.txt") +word_group <- sapply( + strsplit(words, split=""), # this will split all words to single letters... + function(x) paste(sort(x), collapse="") # ...which we sort and paste again +) + +counts <- tapply(words, word_group, length) # group words by class to get number of anagrams +anagrams <- tapply(words, word_group, paste, collapse=", ") # group to get string with all anagrams + +# Results +table(counts) +counts + 1 2 3 4 5 +22263 1111 155 31 6 + +anagrams[counts == max(counts)] + abel acert + "abel, able, bale, bela, elba" "caret, carte, cater, crate, trace" + aegln aeglr +"angel, angle, galen, glean, lange" "alger, glare, lager, large, regal" + aeln eilv + "elan, lane, lean, lena, neal" "evil, levi, live, veil, vile" diff --git a/Task/Anagrams/Racket/anagrams-2.rkt b/Task/Anagrams/Racket/anagrams-2.rkt new file mode 100644 index 0000000000..2e7c60f396 --- /dev/null +++ b/Task/Anagrams/Racket/anagrams-2.rkt @@ -0,0 +1,6 @@ +'(("neal" "lena" "lean" "lane" "elan") + ("trace" "crate" "cater" "carte" "caret") + ("regal" "large" "lager" "glare" "alger") + ("elba" "bela" "bale" "able" "abel") + ("lange" "glean" "galen" "angle" "angel") + ("vile" "veil" "live" "levi" "evil")) diff --git a/Task/Anagrams/Racket/anagrams.rkt b/Task/Anagrams/Racket/anagrams.rkt new file mode 100644 index 0000000000..525de8765c --- /dev/null +++ b/Task/Anagrams/Racket/anagrams.rkt @@ -0,0 +1,21 @@ +#lang racket + +(require net/url) + +(define (get-lines url-string) + (define port (get-pure-port (string->url url-string))) + (for/list ([l (in-lines port)]) l)) + +(define (hash-words words) + (for/fold ([ws-hash (hash)]) ([w words]) + (hash-update ws-hash + (list->string (sort (string->list w) < #:key (λ (c) (char->integer c)))) + (λ (ws) (cons w ws)) + (λ () '())))) + +(define (get-maxes h) + (define max-ws (apply max (map length (hash-values h)))) + (define max-keys (filter (λ (k) (= (length (hash-ref h k)) max-ws)) (hash-keys h))) + (map (λ (k) (hash-ref h k)) max-keys)) + +(get-maxes (hash-words (get-lines "http://www.puzzlers.org/pub/wordlists/unixdict.txt"))) diff --git a/Task/Anagrams/Smalltalk/anagrams-2.st b/Task/Anagrams/Smalltalk/anagrams-2.st new file mode 100644 index 0000000000..35dd866cbc --- /dev/null +++ b/Task/Anagrams/Smalltalk/anagrams-2.st @@ -0,0 +1,10 @@ +d := Dictionary new. +'unixdict.txt' asFilename + readingLinesDo:[:eachWord | + (d at:eachWord copy sort ifAbsentPut:[OrderedCollection new]) add:eachWord + ]. + +((d values select:[:s | s size > 1]) + sortBySelector:#size) + reverse + do:[:s | s printCR] diff --git a/Task/Anagrams/Smalltalk/anagrams-3.st b/Task/Anagrams/Smalltalk/anagrams-3.st new file mode 100644 index 0000000000..ed608bdeac --- /dev/null +++ b/Task/Anagrams/Smalltalk/anagrams-3.st @@ -0,0 +1 @@ +'http://www.puzzlers.org/pub/wordlists/unixdict.txt' asURI contents asCollectionOfLines do:[:eachWord | ... diff --git a/Task/Anagrams/Smalltalk/anagrams.st b/Task/Anagrams/Smalltalk/anagrams.st new file mode 100644 index 0000000000..abd141c650 --- /dev/null +++ b/Task/Anagrams/Smalltalk/anagrams.st @@ -0,0 +1,7 @@ +list:= (FillInTheBlank request: 'myMessageBoxTitle') subStrings: String crlf. +dict:= Dictionary new. +list do: [:val| + (dict at: val copy sort ifAbsent: [dict at: val copy sort put: OrderedCollection new]) + add: val. + ]. +sorted:=dict asSortedCollection: [:a :b| a size > b size]. diff --git a/Task/Bulls_and_cows/Prolog/bulls_and_cows.pro b/Task/Bulls_and_cows/Prolog/bulls_and_cows.pro new file mode 100644 index 0000000000..515b367afc --- /dev/null +++ b/Task/Bulls_and_cows/Prolog/bulls_and_cows.pro @@ -0,0 +1,56 @@ +:- use_module(library(lambda)). +:- use_module(library(clpfd)). + +% Parameters of the server + +% length of the guess +proposition(4). + +% Numbers of digits +% 0 -> 8 +digits(8). + + +bulls_and_cows_server :- + proposition(LenGuess), + length(Solution, LenGuess), + choose(Solution), + repeat, + write('Your guess : '), + read(Guess), + ( study(Solution, Guess, Bulls, Cows) + -> format('Bulls : ~w Cows : ~w~n', [Bulls, Cows]), + Bulls = LenGuess + ; digits(Digits), Max is Digits + 1, + format('Guess must be of ~w digits between 1 and ~w~n', + [LenGuess, Max]), + fail). + +choose(Solution) :- + digits(Digits), + Max is Digits + 1, + repeat, + maplist(\X^(X is random(Max) + 1), Solution), + all_distinct(Solution), + !. + +study(Solution, Guess, Bulls, Cows) :- + proposition(LenGuess), + digits(Digits), + + % compute the transformation 1234 => [1,2,3,4] + atom_chars(Guess, Chars), + maplist(\X^Y^(atom_number(X, Y)), Chars, Ms), + + % check that the guess is well formed + length(Ms, LenGuess), + maplist(\X^(X > 0, X =< Digits+1), Ms), + + % compute the digit in good place + foldl(\X^Y^V0^V1^((X = Y->V1 is V0+1; V1 = V0)),Solution, Ms, 0, Bulls), + + % compute the digits in bad place + foldl(\Y1^V2^V3^(foldl(\X2^Z2^Z3^(X2 = Y1 -> Z3 is Z2+1; Z3 = Z2), Ms, 0, TT1), + V3 is V2+ TT1), + Solution, 0, TT), + Cows is TT - Bulls. diff --git a/Task/Bulls_and_cows/R/bulls_and_cows.r b/Task/Bulls_and_cows/R/bulls_and_cows.r new file mode 100644 index 0000000000..6ffdf363c2 --- /dev/null +++ b/Task/Bulls_and_cows/R/bulls_and_cows.r @@ -0,0 +1,19 @@ +target <- sample(1:9,4) +bulls <- 0 +cows <- 0 +attempts <- 0 +while (bulls != 4) + { + input <- readline("Guess a 4-digit number with no duplicate digits or 0s: ") + if (nchar(input) == 4) + { + input <- as.integer(strsplit(input,"")[[1]]) + if ((sum(is.na(input)+sum(input==0))>=1) | (length(table(input)) != 4)) {print("Malformed input!")} else { + bulls <- sum(input == target) + cows <- sum(input %in% target)-bulls + cat("\n",bulls," Bull(s) and ",cows, " Cow(s)\n") + attempts <- attempts + 1 + } + } else {print("Malformed input!")} + } +print(paste("You won in",attempts,"attempt(s)!")) diff --git a/Task/Bulls_and_cows/Scheme/bulls_and_cows.ss b/Task/Bulls_and_cows/Scheme/bulls_and_cows.ss new file mode 100644 index 0000000000..e9e2c24f4d --- /dev/null +++ b/Task/Bulls_and_cows/Scheme/bulls_and_cows.ss @@ -0,0 +1,65 @@ +;generate a random non-repeating list of 4 digits, 1-9 inclusive +(define (get-num) + (define (gen lst) + (if (= (length lst) 4) lst + (let ((digit (+ (random 9) 1))) + (if (member digit lst) ;make sure the new digit isn't in the + ;list + (gen lst) + (gen (cons digit lst)))))) + (string->list (apply string-append (map number->string (gen '()))))) + +;is g a valid guess (that is, non-repeating, four digits 1-9 +;inclusive?) +(define (valid-guess? g) + (let ((g-num (string->number (apply string g)))) + ;does the same digit appear twice in lst? + (define (repeats? lst) + (cond ((null? lst) #f) + ((member (car lst) (cdr lst)) #t) + (else (repeats? (cdr lst))))) + (and g-num + (> g-num 1233) + (< g-num 9877) + (not (repeats? g))))) + +;return '(cows bulls) for the given guess +(define (score answer guess) + ;total cows + bulls + (define (cows&bulls a g) + (cond ((null? a) 0) + ((member (car a) g) (+ 1 (cows&bulls (cdr a) g))) + (else (cows&bulls (cdr a) g)))) + ;bulls only + (define (bulls a g) + (cond ((null? a) 0) + ((equal? (car a) (car g)) (+ 1 (bulls (cdr a) (cdr g)))) + (else (bulls (cdr a) (cdr g))))) + (list (- (cows&bulls answer guess) (bulls answer guess)) (bulls answer guess))) + +;play the game +(define (bull-cow answer) + ;get the user's guess as a list + (define (get-guess) + (let ((e (read))) + (if (number? e) + (string->list (number->string e)) + (string->list (symbol->string e))))) + (display "Enter a guess: ") + (let ((guess (get-guess))) + (if (valid-guess? guess) + (let ((bulls (cadr (score answer guess))) + (cows (car (score answer guess)))) + (if (= bulls 4) + (display "You win!\n") + (begin + (display bulls) + (display " bulls, ") + (display cows) + (display " cows.\n") + (bull-cow answer)))) + (begin + (display "Invalid guess.\n") + (bull-cow answer))))) + +(bull-cow (get-num)) diff --git a/Task/Bulls_and_cows/Smalltalk/bulls_and_cows.st b/Task/Bulls_and_cows/Smalltalk/bulls_and_cows.st new file mode 100644 index 0000000000..2191db7922 --- /dev/null +++ b/Task/Bulls_and_cows/Smalltalk/bulls_and_cows.st @@ -0,0 +1,58 @@ +Object subclass: BullsCows [ + |number| + BullsCows class >> new: secretNum [ |i| + i := self basicNew. + (self isValid: secretNum) + ifFalse: [ SystemExceptions.InvalidArgument + signalOn: secretNum + reason: 'You need 4 unique digits from 1 to 9' ]. + i setNumber: secretNum. + ^ i + ] + BullsCows class >> new [ |b| b := Set new. + [ b size < 4 ] + whileTrue: [ b add: ((Random between: 1 and: 9) displayString first) ]. + ^ self new: (b asString) + ] + BullsCows class >> isValid: num [ + ^ (num asSet size = 4) & ((num asSet includes: $0) not) + ] + setNumber: num [ number := num ] + check: guess [ |bc| bc := Bag new. + 1 to: 4 do: [ :i | + (number at: i) = (guess at: i) + ifTrue: [ bc add: 'bulls' ] + ifFalse: [ + (number includes: (guess at: i)) + ifTrue: [ bc add: 'cows' ] + ] + ]. + ^ bc + ] +]. + +'Guess the 4-digits number (digits from 1 to 9, no repetition)' displayNl. + +|guessMe d r tries| +[ + tries := 0. + guessMe := BullsCows new. + [ + [ + 'Write 4 digits: ' display. + d := stdin nextLine. + (BullsCows isValid: d) + ] whileFalse: [ + 'Insert 4 digits, no repetition, exclude the digit 0' displayNl + ]. + r := guessMe check: d. + tries := tries + 1. + (r occurrencesOf: 'bulls') = 4 + ] whileFalse: [ + ('%1 cows, %2 bulls' % { r occurrencesOf: 'cows'. r occurrencesOf: 'bulls' }) + displayNl. + ]. + ('Good, you guessed it in %1 tries!' % { tries }) displayNl. + 'Do you want to play again? [y/n]' display. + ( (stdin nextLine) = 'y' ) +] whileTrue: [ Character nl displayNl ]. diff --git a/Task/Comments/Babel/comments.pb b/Task/Comments/Babel/comments.pb new file mode 100644 index 0000000000..0f953f8198 --- /dev/null +++ b/Task/Comments/Babel/comments.pb @@ -0,0 +1,7 @@ +-- This is a line-comment + +# + This is a block-comment + It goes until de-dent + +dedent: 0x42 -- The comment block above is now closed diff --git a/Task/Comments/Prolog/comments-2.pro b/Task/Comments/Prolog/comments-2.pro new file mode 100644 index 0000000000..20d77762f5 --- /dev/null +++ b/Task/Comments/Prolog/comments-2.pro @@ -0,0 +1,2 @@ +/* This is a +multi-line comment */ diff --git a/Task/Comments/Prolog/comments.pro b/Task/Comments/Prolog/comments.pro new file mode 100644 index 0000000000..7da8a17906 --- /dev/null +++ b/Task/Comments/Prolog/comments.pro @@ -0,0 +1 @@ +% this is a single-line comment that extends to the end of the line diff --git a/Task/Comments/R/comments.r b/Task/Comments/R/comments.r new file mode 100644 index 0000000000..f487027b61 --- /dev/null +++ b/Task/Comments/R/comments.r @@ -0,0 +1 @@ +# end of line comment diff --git a/Task/Comments/Racket/comments.rkt b/Task/Comments/Racket/comments.rkt new file mode 100644 index 0000000000..3336d7ec7c --- /dev/null +++ b/Task/Comments/Racket/comments.rkt @@ -0,0 +1,2 @@ +; this is a coment +#;(this expression is ignored) diff --git a/Task/Comments/Sather/comments.sa b/Task/Comments/Sather/comments.sa new file mode 100644 index 0000000000..1d0257cfe3 --- /dev/null +++ b/Task/Comments/Sather/comments.sa @@ -0,0 +1 @@ +-- a single line comment diff --git a/Task/Comments/Scheme/comments.ss b/Task/Comments/Scheme/comments.ss new file mode 100644 index 0000000000..01035ebfb2 --- /dev/null +++ b/Task/Comments/Scheme/comments.ss @@ -0,0 +1,9 @@ +; Basically the same as Common Lisp +; While R5RS does not provide block comments, they are defined in SRFI-30, as in Common Lisp : + +#| comment +... #| nested comment +... |# +|# + +; See http://srfi.schemers.org/srfi-30/srfi-30.html diff --git a/Task/Comments/Smalltalk/comments.st b/Task/Comments/Smalltalk/comments.st new file mode 100644 index 0000000000..aa17c24738 --- /dev/null +++ b/Task/Comments/Smalltalk/comments.st @@ -0,0 +1,6 @@ +"Comments traditionally are in double quotes." +"Multiline comments are also supported. + Comments are saved as metadata along with the source to a method. + A comment just after a method signature is often given to explain the + usage of the method. The class browser may display such comments + specially." diff --git a/Task/Entropy/R/entropy.r b/Task/Entropy/R/entropy.r new file mode 100644 index 0000000000..31be1789a4 --- /dev/null +++ b/Task/Entropy/R/entropy.r @@ -0,0 +1,5 @@ +entropy = function(s) + {freq = prop.table(table(strsplit(s, '')[1])) + -sum(freq * log(freq, base = 2))} + +print(entropy("1223334444")) # 1.846439 diff --git a/Task/Entropy/Racket/entropy.rkt b/Task/Entropy/Racket/entropy.rkt new file mode 100644 index 0000000000..23130f36fc --- /dev/null +++ b/Task/Entropy/Racket/entropy.rkt @@ -0,0 +1,17 @@ +#lang racket +(require math) + +(define (log2 x) + (/ (log x) (log 2))) + +(define (digits x) + (for/list ([c (number->string x)]) + (- (char->integer c) (char->integer #\0)))) + +(define (entropy x) + (define ds (digits x)) + (define n (length ds)) + (- (for/sum ([(d c) (in-hash (samples->hash ds))]) + (* (/ d n) (log2 (/ d n)))))) + +(entropy 1223334444) diff --git a/Task/FizzBuzz/ActionScript/fizzbuzz.as b/Task/FizzBuzz/ActionScript/fizzbuzz.as new file mode 100644 index 0000000000..ba07d4e5fa --- /dev/null +++ b/Task/FizzBuzz/ActionScript/fizzbuzz.as @@ -0,0 +1,10 @@ +for (var i:int = 1; i <= 100; i++) { + if (i % 15 == 0) + trace('FizzBuzz'); + else if (i % 5 == 0) + trace('Buzz'); + else if (i % 3 == 0) + trace('Fizz'); + else + trace(i); +} diff --git a/Task/FizzBuzz/Babel/fizzbuzz.pb b/Task/FizzBuzz/Babel/fizzbuzz.pb new file mode 100644 index 0000000000..cf07126592 --- /dev/null +++ b/Task/FizzBuzz/Babel/fizzbuzz.pb @@ -0,0 +1,22 @@ +main: + { { iter 1 + dup + + 15 % + { "FizzBuzz" << + zap } + { dup + 3 % + { "Fizz" << + zap } + { dup + 5 % + { "Buzz" << + zap} + { %d << } + if } + if } + if + + "\n" << } + + 100 times } diff --git a/Task/FizzBuzz/Prolog/fizzbuzz-2.pro b/Task/FizzBuzz/Prolog/fizzbuzz-2.pro new file mode 100644 index 0000000000..67b9c5548c --- /dev/null +++ b/Task/FizzBuzz/Prolog/fizzbuzz-2.pro @@ -0,0 +1,6 @@ +fizzbuzz(X) :- 0 is X mod 15, write('FizzBuzz'). +fizzbuzz(X) :- 0 is X mod 3, write('Fizz'). +fizzbuzz(X) :- 0 is X mod 5, write('Buzz'). +fizzbuzz(X) :- write(X). + +dofizzbuzz :- foreach(between(1, 100, X), (fizzbuzz(X),nl)). diff --git a/Task/FizzBuzz/Prolog/fizzbuzz.pro b/Task/FizzBuzz/Prolog/fizzbuzz.pro new file mode 100644 index 0000000000..077c1b4121 --- /dev/null +++ b/Task/FizzBuzz/Prolog/fizzbuzz.pro @@ -0,0 +1,13 @@ +fizzbuzz :- + foreach(between(1, 100, X), print_item(X)). + +print_item(X) :- + ( 0 is X mod 15 + -> print('FizzBuzz') + ; 0 is X mod 3 + -> print('Fizz') + ; 0 is X mod 5 + -> print('Buzz') + ; print(X) + ), + nl. diff --git a/Task/FizzBuzz/R/fizzbuzz-2.r b/Task/FizzBuzz/R/fizzbuzz-2.r new file mode 100644 index 0000000000..4a49ed548b --- /dev/null +++ b/Task/FizzBuzz/R/fizzbuzz-2.r @@ -0,0 +1,2 @@ +x <- paste(rep("", 100), c("", "", "Fizz"), c("", "", "", "", "Buzz"), sep="") +cat(ifelse(x == "", 1:100, x), "\n") diff --git a/Task/FizzBuzz/R/fizzbuzz-3.r b/Task/FizzBuzz/R/fizzbuzz-3.r new file mode 100644 index 0000000000..4b53d16efe --- /dev/null +++ b/Task/FizzBuzz/R/fizzbuzz-3.r @@ -0,0 +1,4 @@ +x <- 1:100 +ifelse(x %% 15 == 0, 'FizzBuzz', + ifelse(x %% 5 == 0, 'Buzz', + ifelse(x %% 3 == 0, 'Fizz', x))) diff --git a/Task/FizzBuzz/R/fizzbuzz.r b/Task/FizzBuzz/R/fizzbuzz.r new file mode 100644 index 0000000000..ae7832a4ac --- /dev/null +++ b/Task/FizzBuzz/R/fizzbuzz.r @@ -0,0 +1,6 @@ +x <- 1:100 +xx <- as.character(x) +xx[x%%3==0] <- "Fizz" +xx[x%%5==0] <- "Buzz" +xx[x%%15==0] <- "FizzBuzz" +xx diff --git a/Task/FizzBuzz/Racket/fizzbuzz.rkt b/Task/FizzBuzz/Racket/fizzbuzz.rkt new file mode 100644 index 0000000000..20505cf5e9 --- /dev/null +++ b/Task/FizzBuzz/Racket/fizzbuzz.rkt @@ -0,0 +1,7 @@ +(for ([n (in-range 1 101)]) + (displayln + (match (gcd n 15) + [15 "fizzbuzz"] + [3 "fizz"] + [5 "buzz"] + [_ n]))) diff --git a/Task/FizzBuzz/Sather/fizzbuzz.sa b/Task/FizzBuzz/Sather/fizzbuzz.sa new file mode 100644 index 0000000000..e8418212ad --- /dev/null +++ b/Task/FizzBuzz/Sather/fizzbuzz.sa @@ -0,0 +1,14 @@ +class MAIN is + main is + loop i ::= 1.upto!(100); + s:STR := ""; + if i % 3 = 0 then s := "Fizz"; end; + if i % 5 = 0 then s := s + "Buzz"; end; + if s.length > 0 then + #OUT + s + "\n"; + else + #OUT + i + "\n"; + end; + end; + end; +end; diff --git a/Task/FizzBuzz/Scheme/fizzbuzz.ss b/Task/FizzBuzz/Scheme/fizzbuzz.ss new file mode 100644 index 0000000000..03395a7d92 --- /dev/null +++ b/Task/FizzBuzz/Scheme/fizzbuzz.ss @@ -0,0 +1,8 @@ +(do ((i 1 (+ i 1))) + ((> i 100)) + (display + (cond ((= 0 (modulo i 15)) "FizzBuzz") + ((= 0 (modulo i 3)) "Fizz") + ((= 0 (modulo i 5)) "Buzz") + (else i))) + (newline)) diff --git a/Task/FizzBuzz/Smalltalk/fizzbuzz-2.st b/Task/FizzBuzz/Smalltalk/fizzbuzz-2.st new file mode 100644 index 0000000000..2de205f34d --- /dev/null +++ b/Task/FizzBuzz/Smalltalk/fizzbuzz-2.st @@ -0,0 +1,9 @@ +(1 to: 100) do: + [:n | + ((n \\ 3)*(n \\ 5)) isZero + ifFalse: [Transcript show: n]. + (n \\ 3) isZero + ifTrue: [Transcript show: 'Fizz']. + (n \\ 5) isZero + ifTrue: [Transcript show: 'Buzz']. + Transcript cr.] diff --git a/Task/FizzBuzz/Smalltalk/fizzbuzz-3.st b/Task/FizzBuzz/Smalltalk/fizzbuzz-3.st new file mode 100644 index 0000000000..5158ebdec2 --- /dev/null +++ b/Task/FizzBuzz/Smalltalk/fizzbuzz-3.st @@ -0,0 +1,8 @@ +fizzbuzz := Dictionary with: #(true true)->'FizzBuzz' + with: #(true false)->'Fizz' + with: #(false true)->'Buzz'. + +1 to: 100 do: + [ :i | Transcript show: + (fizzbuzz at: {i isDivisibleBy: 3. i isDivisibleBy: 5} + ifAbsent: [ i ]); cr] diff --git a/Task/FizzBuzz/Smalltalk/fizzbuzz-4.st b/Task/FizzBuzz/Smalltalk/fizzbuzz-4.st new file mode 100644 index 0000000000..12bbef1dcd --- /dev/null +++ b/Task/FizzBuzz/Smalltalk/fizzbuzz-4.st @@ -0,0 +1,10 @@ +1 to: 100 do: [:n | |r| + r := n rem: 15. + Transcript show: (r isZero + ifTrue:['fizzbuzz'] + ifFalse: [(#(3 6 9 12) includes: r) + ifTrue:['fizz'] + ifFalse:[((#(5 10) includes: r)) + ifTrue:['buzz'] + ifFalse:[n]]]); + cr]. diff --git a/Task/FizzBuzz/Smalltalk/fizzbuzz-5.st b/Task/FizzBuzz/Smalltalk/fizzbuzz-5.st new file mode 100644 index 0000000000..83e4ca616e --- /dev/null +++ b/Task/FizzBuzz/Smalltalk/fizzbuzz-5.st @@ -0,0 +1,5 @@ +fbz := (1 to: 100) asOrderedCollection. + 3 to: 100 by: 3 do: [:i | fbz at: i put: 'Fizz']. + 5 to: 100 by: 5 do: [:i | fbz at: i put: 'Buzz']. +15 to: 100 by: 15 do: [:i | fbz at: i put: 'FizzBuzz']. +fbz do: [:i | Transcript show: i; cr]. diff --git a/Task/FizzBuzz/Smalltalk/fizzbuzz-6.st b/Task/FizzBuzz/Smalltalk/fizzbuzz-6.st new file mode 100644 index 0000000000..a0c292e114 --- /dev/null +++ b/Task/FizzBuzz/Smalltalk/fizzbuzz-6.st @@ -0,0 +1,5 @@ +1 to: 100 do: [:i | |fb s| + fb := {i isDivisibleBy: 3. i isDivisibleBy: 5. nil}. + fb at: 3 put: (fb first | fb second) not. + s := '<1?Fizz:><2?Buzz:><3?{1}:>' format: {i printString}. + Transcript show: (s expandMacrosWithArguments: fb); cr]. diff --git a/Task/FizzBuzz/Smalltalk/fizzbuzz.st b/Task/FizzBuzz/Smalltalk/fizzbuzz.st new file mode 100644 index 0000000000..713b13961e --- /dev/null +++ b/Task/FizzBuzz/Smalltalk/fizzbuzz.st @@ -0,0 +1,9 @@ +Integer extend [ + fizzbuzz [ + | fb | + fb := '%1%2' % { + self \\ 3 == 0. self \\ 5 == 0 }. + ^fb isEmpty ifTrue: [ self ] ifFalse: [ fb ] + ] +] +1 to: 100 do: [ :i | i fizzbuzz displayNl ] diff --git a/Task/Infinity/ActionScript/infinity.as b/Task/Infinity/ActionScript/infinity.as new file mode 100644 index 0000000000..db665e7eb1 --- /dev/null +++ b/Task/Infinity/ActionScript/infinity.as @@ -0,0 +1,2 @@ +trace(5 / 0); // outputs "Infinity" +trace(isFinite(5 / 0)); // outputs "false" diff --git a/Task/Infinity/Eiffel/infinity.e b/Task/Infinity/Eiffel/infinity.e new file mode 100644 index 0000000000..3a4c3c5887 --- /dev/null +++ b/Task/Infinity/Eiffel/infinity.e @@ -0,0 +1,18 @@ +class + APPLICATION +inherit + ARGUMENTS +create + make +feature {NONE} -- Initialization + number:REAL_64 + make + -- Run application. + do + number := 2^2000 + print(number) + print("%N") + print(number.is_positive_infinity) + print("%N") + end +end diff --git a/Task/Infinity/R/infinity.r b/Task/Infinity/R/infinity.r new file mode 100644 index 0000000000..3202ce54e9 --- /dev/null +++ b/Task/Infinity/R/infinity.r @@ -0,0 +1,11 @@ + Inf #positive infinity + -Inf #negative infinity + .Machine$double.xmax # largest finite floating-point number + is.finite # function to test to see if a number is finite + +# function that returns the input if it is finite, otherwise returns (plus or minus) the largest finite floating-point number + forcefinite <- function(x) ifelse(is.finite(x), x, sign(x)*.Machine$double.xmax) + + forcefinite(c(1, -1, 0, .Machine$double.xmax, -.Machine$double.xmax, Inf, -Inf)) +# [1] 1.000000e+00 -1.000000e+00 0.000000e+00 1.797693e+308 +# [5] -1.797693e+308 1.797693e+308 -1.797693e+308 diff --git a/Task/Infinity/Racket/infinity.rkt b/Task/Infinity/Racket/infinity.rkt new file mode 100644 index 0000000000..197e284879 --- /dev/null +++ b/Task/Infinity/Racket/infinity.rkt @@ -0,0 +1,5 @@ +#lang racket + ++inf.0 ; positive infinity +(define (finite? x) (< -inf.0 x +inf.0)) +(define (infinite? x) (not (finite? x))) diff --git a/Task/Infinity/Scheme/infinity.ss b/Task/Infinity/Scheme/infinity.ss new file mode 100644 index 0000000000..9f6d4ed2c8 --- /dev/null +++ b/Task/Infinity/Scheme/infinity.ss @@ -0,0 +1,3 @@ ++inf.0 ; positive infinity +(define (finite? x) (< -inf.0 x +inf.0)) +(define (infinite? x) (not (finite? x))) diff --git a/Task/Infinity/Smalltalk/infinity-2.st b/Task/Infinity/Smalltalk/infinity-2.st new file mode 100644 index 0000000000..561bfcac26 --- /dev/null +++ b/Task/Infinity/Smalltalk/infinity-2.st @@ -0,0 +1,6 @@ +[ + 1.0 / 0.0 +] on: ZeroDivide do:[:ex | + ex proceedWith: (Float infinity) +] +-> INF diff --git a/Task/Infinity/Smalltalk/infinity.st b/Task/Infinity/Smalltalk/infinity.st new file mode 100644 index 0000000000..e9a05863cd --- /dev/null +++ b/Task/Infinity/Smalltalk/infinity.st @@ -0,0 +1,2 @@ +Float infinity -> INF +1.0 / 0.0 -> "ZeroDivide exception" diff --git a/Task/JSON/R/json-2.r b/Task/JSON/R/json-2.r new file mode 100644 index 0000000000..b8e512e0ef --- /dev/null +++ b/Task/JSON/R/json-2.r @@ -0,0 +1 @@ +cat(toJSON(data)) diff --git a/Task/JSON/R/json.r b/Task/JSON/R/json.r new file mode 100644 index 0000000000..b2d012fb96 --- /dev/null +++ b/Task/JSON/R/json.r @@ -0,0 +1,3 @@ +library(rjson) +data <- fromJSON('{ "foo": 1, "bar": [10, "apples"] }') +data diff --git a/Task/JSON/Racket/json.rkt b/Task/JSON/Racket/json.rkt new file mode 100644 index 0000000000..f0dda62e57 --- /dev/null +++ b/Task/JSON/Racket/json.rkt @@ -0,0 +1,8 @@ +#lang racket + +(require json) + +(string->jsexpr + "{\"foo\":[1,2,3],\"bar\":null,\"baz\":\"blah\"}") + +(write-json '(1 2 "three" #hash((x . 1) (y . 2) (z . 3)))) diff --git a/Task/Knuth_shuffle/R/knuth_shuffle-2.r b/Task/Knuth_shuffle/R/knuth_shuffle-2.r new file mode 100644 index 0000000000..dafbc5b68b --- /dev/null +++ b/Task/Knuth_shuffle/R/knuth_shuffle-2.r @@ -0,0 +1,21 @@ +fisheryatesknuthshuffle <- function(n) +{ + a <- seq_len(n) + while(n >=2) + { + k <- sample.int(n, 1) + if(k != n) + { + temp <- a[k] + a[k] <- a[n] + a[n] <- temp + } + n <- n - 1 + } + a +} + +#Example usage: +fisheryatesshuffle(6) # e.g. 1 3 6 2 4 5 +x <- c("foo", "bar", "baz", "quux") +x[fisheryatesknuthshuffle(4)] # e.g. "bar" "baz" "quux" "foo" diff --git a/Task/Knuth_shuffle/R/knuth_shuffle.r b/Task/Knuth_shuffle/R/knuth_shuffle.r new file mode 100644 index 0000000000..926bd2f164 --- /dev/null +++ b/Task/Knuth_shuffle/R/knuth_shuffle.r @@ -0,0 +1,12 @@ +fisheryatesshuffle <- function(n) +{ + pool <- seq_len(n) + a <- c() + while(length(pool) > 0) + { + k <- sample.int(length(pool), 1) + a <- c(a, pool[k]) + pool <- pool[-k] + } + a +} diff --git a/Task/Knuth_shuffle/Scheme/knuth_shuffle.ss b/Task/Knuth_shuffle/Scheme/knuth_shuffle.ss new file mode 100644 index 0000000000..5982c3f245 --- /dev/null +++ b/Task/Knuth_shuffle/Scheme/knuth_shuffle.ss @@ -0,0 +1,10 @@ +(define (swap vec i j) + (let ([tmp (vector-ref vec i)]) + (vector-set! vec i (vector-ref vec j)) + (vector-set! vec j tmp))) + +(define (shuffle vec) + (for ((i (in-range (- (vector-length vec) 1) 0 -1))) + (let ((r (random i))) + (swap vec i r))) + vec) diff --git a/Task/Knuth_shuffle/Smalltalk/knuth_shuffle-2.st b/Task/Knuth_shuffle/Smalltalk/knuth_shuffle-2.st new file mode 100644 index 0000000000..ae51be6879 --- /dev/null +++ b/Task/Knuth_shuffle/Smalltalk/knuth_shuffle-2.st @@ -0,0 +1,6 @@ +"Test" +|c| +c := OrderedCollection new. +c addAll: #( 1 2 3 4 5 6 7 8 9 ). +Shuffler Knuth: c. +c display. diff --git a/Task/Knuth_shuffle/Smalltalk/knuth_shuffle.st b/Task/Knuth_shuffle/Smalltalk/knuth_shuffle.st new file mode 100644 index 0000000000..90db1d2515 --- /dev/null +++ b/Task/Knuth_shuffle/Smalltalk/knuth_shuffle.st @@ -0,0 +1,22 @@ +"The selector swap:with: is documented, but it seems not + implemented (GNU Smalltalk version 3.0.4); so here it is an implementation" +SequenceableCollection extend [ + swap: i with: j [ + |t| + t := self at: i. + self at: i put: (self at: j). + self at: j put: t. + ] +]. + +Object subclass: Shuffler [ + Shuffler class >> Knuth: aSequenceableCollection [ + |n k| + n := aSequenceableCollection size. + [ n > 1 ] whileTrue: [ + k := Random between: 1 and: n. + aSequenceableCollection swap: n with: k. + n := n - 1 + ] + ] +]. diff --git a/Task/Ordered_words/Prolog/ordered_words.pro b/Task/Ordered_words/Prolog/ordered_words.pro new file mode 100644 index 0000000000..3eb95461b4 --- /dev/null +++ b/Task/Ordered_words/Prolog/ordered_words.pro @@ -0,0 +1,44 @@ +:- use_module(library( http/http_open )). + +ordered_words :- + % we read the URL of the words + http_open('http://www.puzzlers.org/pub/wordlists/unixdict.txt', In, []), + read_file(In, [], Out), + close(In), + + % we get a list of pairs key-value where key = Length and value = + % this list must be sorted + msort(Out, MOut), + + group_pairs_by_key(MOut, POut), + + % we sorted this list in decreasing order of the length of values + predsort(my_compare, POut, [_N-V | _OutSort]), + maplist(mwritef, V). + + +mwritef(V) :- + writef('%s\n', [V]). + +read_file(In, L, L1) :- + read_line_to_codes(In, W), + ( W == end_of_file -> + % the file is read + L1 = L + ; + % we sort the list of codes of the line + % and keep only the "goods word" + ( msort(W, W) -> + length(W, N), L2 = [N-W | L], (len = 6 -> writef('%s\n', [W]); true) + ; + L2 = L + ), + + % and we have the pair Key-Value in the result list + read_file(In, L2, L1)). + +% predicate for sorting list of pairs Key-Values +% if the lentgh of values is the same +% we sort the keys in alhabetic order +my_compare(R, K1-_V1, K2-_V2) :- + ( K1 < K2 -> R = >; K1 > K2 -> R = <; =). diff --git a/Task/Ordered_words/Scheme/ordered_words.ss b/Task/Ordered_words/Scheme/ordered_words.ss new file mode 100644 index 0000000000..40d4d69979 --- /dev/null +++ b/Task/Ordered_words/Scheme/ordered_words.ss @@ -0,0 +1,20 @@ +(define sorted-words + (let ((port (open-input-file "unixdict.txt"))) + (let loop ((char (read-char port)) (word '()) (result '(()))) + (cond + ((eof-object? char) + (reverse (map (lambda (word) (apply string word)) result))) + ((eq? #\newline char) + (loop (read-char port) '() + (let ((best-length (length (car result))) (word-length (length word))) + (cond + ((or (< word-length best-length) (not (apply char>=? word))) result) + ((> word-length best-length) (list (reverse word))) + (else (cons (reverse word) result)))))) + (else (loop (read-char port) (cons char word) result)))))) + +(map (lambda (x) + (begin + (display x) + (newline))) + sorted-words) diff --git a/Task/Ordered_words/Smalltalk/ordered_words.st b/Task/Ordered_words/Smalltalk/ordered_words.st new file mode 100644 index 0000000000..146f44c19d --- /dev/null +++ b/Task/Ordered_words/Smalltalk/ordered_words.st @@ -0,0 +1,17 @@ +|file dict r t| +file := FileStream open: 'unixdict.txt' mode: FileStream read. +dict := Set new. + +"load the whole dict into the set before, 'filter' later" +[ file atEnd ] whileFalse: [ + dict add: (file upTo: Character nl) ]. + +"find those with the sorted letters, and sort them by length" +r := ((dict + select: [ :w | (w asOrderedCollection sort) = (w asOrderedCollection) ] ) + asSortedCollection: [:a :b| (a size) > (b size) ] ). + +"get those that have length = to the max length, and sort alphabetically" +r := (r select: [:w| (w size) = ((r at: 1) size)]) asSortedCollection. + +r do: [:e| e displayNl]. diff --git a/Task/Pi/Racket/pi.rkt b/Task/Pi/Racket/pi.rkt new file mode 100644 index 0000000000..231c361ab3 --- /dev/null +++ b/Task/Pi/Racket/pi.rkt @@ -0,0 +1,4 @@ +#lang racket +(require math/bigfloat) +(bf-precision (exact-floor (/ (* 200 (log 10)) (log 2)))) +pi.bf diff --git a/Task/Quine/Prolog/quine.pro b/Task/Quine/Prolog/quine.pro new file mode 100644 index 0000000000..0de9549c0d --- /dev/null +++ b/Task/Quine/Prolog/quine.pro @@ -0,0 +1,2 @@ +quine :- + listing(quine). diff --git a/Task/Quine/R/quine.r b/Task/Quine/R/quine.r new file mode 100644 index 0000000000..f01e4698c9 --- /dev/null +++ b/Task/Quine/R/quine.r @@ -0,0 +1 @@ +(function(){x<-intToUtf8(34);s<-"(function(){x<-intToUtf8(34);s<-%s%s%s;cat(sprintf(s,x,s,x))})()";cat(sprintf(s,x,s,x))})() diff --git a/Task/Quine/Scheme/quine-2.ss b/Task/Quine/Scheme/quine-2.ss new file mode 100644 index 0000000000..f6ad1f3d87 --- /dev/null +++ b/Task/Quine/Scheme/quine-2.ss @@ -0,0 +1 @@ +((lambda (q) (quasiquote ((unquote q) (quote (unquote q))))) (quote (lambda (q) (quasiquote ((unquote q) (quote (unquote q))))))) diff --git a/Task/Quine/Scheme/quine-3.ss b/Task/Quine/Scheme/quine-3.ss new file mode 100644 index 0000000000..1c99a96583 --- /dev/null +++ b/Task/Quine/Scheme/quine-3.ss @@ -0,0 +1 @@ +((lambda (q) `(,q ',q)) '(lambda (q) `(,q ',q))) diff --git a/Task/Quine/Scheme/quine.ss b/Task/Quine/Scheme/quine.ss new file mode 100644 index 0000000000..0ed3deb3a6 --- /dev/null +++ b/Task/Quine/Scheme/quine.ss @@ -0,0 +1 @@ +((lambda (s) (display (list s (list (quote quote) s)))) (quote (lambda (s) (display (list s (list (quote quote) s)))))) diff --git a/Task/Quine/Smalltalk/quine-2.st b/Task/Quine/Smalltalk/quine-2.st new file mode 100644 index 0000000000..2a38950661 --- /dev/null +++ b/Task/Quine/Smalltalk/quine-2.st @@ -0,0 +1 @@ +' print; displayNl' print; displayNl diff --git a/Task/Quine/Smalltalk/quine.st b/Task/Quine/Smalltalk/quine.st new file mode 100644 index 0000000000..33e86512da --- /dev/null +++ b/Task/Quine/Smalltalk/quine.st @@ -0,0 +1 @@ +[:s| Transcript show: s, s printString; cr ] value: '[:s| Transcript show: s, s printString; cr ] value: ' diff --git a/Task/Search_a_list/ActionScript/search_a_list-2.as b/Task/Search_a_list/ActionScript/search_a_list-2.as new file mode 100644 index 0000000000..32bad083b8 --- /dev/null +++ b/Task/Search_a_list/ActionScript/search_a_list-2.as @@ -0,0 +1,7 @@ +package { + public class StringNotFoundError extends Error { + public function StringNotFoundError(message:String) { + super(message); + } + } +} diff --git a/Task/Search_a_list/ActionScript/search_a_list-3.as b/Task/Search_a_list/ActionScript/search_a_list-3.as new file mode 100644 index 0000000000..ab5d519025 --- /dev/null +++ b/Task/Search_a_list/ActionScript/search_a_list-3.as @@ -0,0 +1,17 @@ +import StringNotFoundError; +var list:Vector. = Vector.(["Zig", "Zag", "Wally", "Ronald", "Bush", "Krusty", "Charlie", "Bush", "Boz", "Zag"]); +function lowIndex(listToSearch:Vector., searchString:String):int +{ + var index:int = listToSearch.indexOf(searchString); + if(index == -1) + throw new StringNotFoundError("String not found: " + searchString); + return index; +} + +function highIndex(listToSearch:Vector., searchString:String):int +{ + var index:int = listToSearch.lastIndexOf(searchString); + if(index == -1) + throw new StringNotFoundError("String not found: " + searchString); + return index; +} diff --git a/Task/Search_a_list/ActionScript/search_a_list.as b/Task/Search_a_list/ActionScript/search_a_list.as new file mode 100644 index 0000000000..a72aac1e46 --- /dev/null +++ b/Task/Search_a_list/ActionScript/search_a_list.as @@ -0,0 +1,16 @@ +var list:Vector. = Vector.(["Zig", "Zag", "Wally", "Ronald", "Bush", "Krusty", "Charlie", "Bush", "Boz", "Zag"]); +function lowIndex(listToSearch:Vector., searchString:String):int +{ + var index:int = listToSearch.indexOf(searchString); + if(index == -1) + throw new Error("String not found: " + searchString); + return index; +} + +function highIndex(listToSearch:Vector., searchString:String):int +{ + var index:int = listToSearch.lastIndexOf(searchString); + if(index == -1) + throw new Error("String not found: " + searchString); + return index; +} diff --git a/Task/Search_a_list/Prolog/search_a_list.pro b/Task/Search_a_list/Prolog/search_a_list.pro new file mode 100644 index 0000000000..65b7b42bfa --- /dev/null +++ b/Task/Search_a_list/Prolog/search_a_list.pro @@ -0,0 +1,23 @@ +search_a_list(N1, N2) :- + L = ["Zig", "Zag", "Wally", "Ronald", "Bush", "Krusty", "Charlie", "Bush", "Boz", "Zag"], + + write('List is :'), maplist(my_write, L), nl, nl, + + ( nth1(Ind1, L, N1) -> + format('~s is in position ~w~n', [N1, Ind1]) + ; format('~s is not present~n', [N1])), + ( nth1(Ind2, L, N2) -> + format('~s is in position ~w~n', [N2, Ind2]) + ; format('~s is not present~n', [N2])), + ( reverse_nth1(Ind3, L, N1) -> + format('~s last position is ~w~n', [N1, Ind3]) + ; format('~s is not present~n', [N1])). + +reverse_nth1(Ind, L, N) :- + reverse(L, RL), + length(L, Len), + nth1(Ind1, RL, N), + Ind is Len - Ind1 + 1. + +my_write(Name) :- + writef(' %s', [Name]). diff --git a/Task/Search_a_list/R/search_a_list-2.r b/Task/Search_a_list/R/search_a_list-2.r new file mode 100644 index 0000000000..48e87ad1e0 --- /dev/null +++ b/Task/Search_a_list/R/search_a_list-2.r @@ -0,0 +1,8 @@ +haystack1 <- c("where", "is", "the", "needle", "I", "wonder") +haystack2 <- c("no", "sewing", "equipment", "in", "here") +haystack3 <- c("oodles", "of", "needles", "needles", "needles", "in", "here") + +find.needle(haystack1) # 4 +find.needle(haystack2) # error +find.needle(haystack3) # 3 +find.needle(haystack3, needle="needles", ret=TRUE) # 3 5 diff --git a/Task/Search_a_list/R/search_a_list.r b/Task/Search_a_list/R/search_a_list.r new file mode 100644 index 0000000000..90e77bd75c --- /dev/null +++ b/Task/Search_a_list/R/search_a_list.r @@ -0,0 +1,6 @@ +find.needle <- function(haystack, needle="needle", return.last.index.too=FALSE) +{ + indices <- which(haystack %in% needle) + if(length(indices)==0) stop("no needles in the haystack") + if(return.last.index.too) range(indices) else min(indices) +} diff --git a/Task/Search_a_list/Racket/search_a_list-2.rkt b/Task/Search_a_list/Racket/search_a_list-2.rkt new file mode 100644 index 0000000000..564fd3948a --- /dev/null +++ b/Task/Search_a_list/Racket/search_a_list-2.rkt @@ -0,0 +1,4 @@ +(define (index-last xs y) + (for/last ([(x i) (in-indexed xs)] + #:when (equal? x y)) + i)) diff --git a/Task/Search_a_list/Racket/search_a_list-3.rkt b/Task/Search_a_list/Racket/search_a_list-3.rkt new file mode 100644 index 0000000000..0c1106c2db --- /dev/null +++ b/Task/Search_a_list/Racket/search_a_list-3.rkt @@ -0,0 +1,7 @@ +(define haystack '("Zig" "Zag" "Wally" "Ronald" "Bush" "Krusty" "Charlie" "Bush" "Bozo")) + +(for/list ([needle '("Bender" "Bush")]) + (index haystack needle)) + +(for/list ([needle '("Bender" "Bush")]) + (index-last haystack needle)) diff --git a/Task/Search_a_list/Racket/search_a_list.rkt b/Task/Search_a_list/Racket/search_a_list.rkt new file mode 100644 index 0000000000..b82d048cd0 --- /dev/null +++ b/Task/Search_a_list/Racket/search_a_list.rkt @@ -0,0 +1,4 @@ +(define (index xs y) + (for/first ([(x i) (in-indexed xs)] + #:when (equal? x y)) + i)) diff --git a/Task/Search_a_list/Sather/search_a_list.sa b/Task/Search_a_list/Sather/search_a_list.sa new file mode 100644 index 0000000000..782d3bf787 --- /dev/null +++ b/Task/Search_a_list/Sather/search_a_list.sa @@ -0,0 +1,14 @@ +class MAIN is + main is + haystack :ARRAY{STR} := |"Zig", "Zag", "Wally", "Ronald", "Bush", "Krusty", "Charlie", "Bush", "Bozo"|; + needles :ARRAY{STR} := | "Washington", "Bush" |; + loop needle ::= needles.elt!; + index ::= haystack.index_of(needle); + if index < 0 then + #OUT + needle + " is not in the haystack\n"; + else + #OUT + index + " " + needle + "\n"; + end; + end; + end; +end; diff --git a/Task/Search_a_list/Scheme/search_a_list.ss b/Task/Search_a_list/Scheme/search_a_list.ss new file mode 100644 index 0000000000..bd55aba697 --- /dev/null +++ b/Task/Search_a_list/Scheme/search_a_list.ss @@ -0,0 +1,16 @@ +(define haystack + '("Zig" "Zag" "Wally" "Ronald" "Bush" "Krusty" "Charlie" "Bush" "Bozo")) + +(define index-of + (lambda (needle hackstack) + (let ((tail (member needle haystack))) + (if tail + (- (length haystack) (length tail)) + (throw 'needle-missing))))) + +(define last-index-of + (lambda (needle hackstack) + (let ((tail (member needle (reverse haystack)))) + (if tail + (- (length tail) 1) + (throw 'needle-missing))))) diff --git a/Task/Search_a_list/Smalltalk/search_a_list.st b/Task/Search_a_list/Smalltalk/search_a_list.st new file mode 100644 index 0000000000..740f398242 --- /dev/null +++ b/Task/Search_a_list/Smalltalk/search_a_list.st @@ -0,0 +1,14 @@ +| haystack | +haystack := + 'Zig,Zag,Wally,Ronald,Bush,Krusty,Charlie,Bush,Bozo' subStrings: $,. +{ 'Washington' . 'Bush' } do: [:i| + |t l| + t := (haystack indexOf: i). + (t = 0) ifTrue: [ ('%1 is not in the haystack' % { i }) displayNl ] + ifFalse: [ ('%1 is at index %2' % { i . t }) displayNl. + l := ( (haystack size) - (haystack reverse indexOf: i) + 1 ). + ( t = l ) ifFalse: [ + ('last occurence of %1 is at index %2' % + { i . l }) displayNl ] + ] +].