CDE

Task/Search-a-list/C++/search-a-list.cpp

@@ -0,0 +1,112 @@
+#include <string>
+#include <algorithm>
+#include <iterator>
+#include <cstddef>
+#include <exception>
+#include <iostream>
+
+// an exception to throw (actually, throwing an exception in this case is generally considered bad style, but it's part of the task)
+class not_found: public std::exception
+{
+public:
+  not_found(std::string const& s): text(s + " not found") {}
+  char const* what() const throw() { return text.c_str(); }
+  ~not_found() throw() {}
+private:
+  std::string text;
+};
+
+// needle search function, C-style interface version using standard library
+std::size_t get_index(std::string* haystack, int haystack_size, std::string needle)
+{
+  std::size_t index = std::find(haystack, haystack+haystack_size, needle) - haystack;
+  if (index == haystack_size)
+    throw not_found(needle);
+  else
+    return index;
+}
+
+// needle search function, completely generic style, needs forward iterators
+// (works with any container, but inefficient if not random-access-iterator)
+template<typename FwdIter>
+ typename std::iterator_traits<FwdIter>::difference_type fwd_get_index(FwdIter first, FwdIter last, std::string needle)
+{
+  FwdIter elem = std::find(first, last, needle);
+  if (elem == last)
+    throw not_found(needle);
+  else
+    return std::distance(first, elem);
+}
+
+// needle search function, implemented directly, needs only input iterator, works efficiently with all sequences
+template<typename InIter>
+ typename std::iterator_traits<InIter>::difference_type generic_get_index(InIter first, InIter last, std::string needle)
+{
+  typename std::iterator_traits<InIter>::difference_type index = 0;
+  while (first != last && *first != needle)
+  {
+    ++index;
+    ++first;
+  }
+  if (first == last)
+    throw not_found(needle);
+  else
+    return index;
+}
+
+// ----------------------------------------------------------------------------------------------------------------------------------
+
+// a sample haystack (content copied from Haskell example)
+std::string haystack[] = { "Zig", "Zag", "Wally", "Ronald", "Bush", "Krusty", "Charlie", "Bush", "Bozo" };
+
+// some useful helper functions
+template<typename T, std::size_t sz> T* begin(T (&array)[sz]) { return array; }
+template<typename T, std::size_t sz> T* end(T (&array)[sz]) { return array + sz; }
+template<typename T, std::size_t sz> std::size_t size(T (&array)[sz]) { return sz; }
+
+// test function searching a given needle with each of the methods
+void test(std::string const& needle)
+{
+  std::cout << "-- C style interface --\n";
+  try
+  {
+    std::size_t index = get_index(haystack, size(haystack), needle);
+    std::cout << needle << " found at index " << index << "\n";
+  }
+  catch(std::exception& exc) // better catch standard exceptions as well; me might e.g. run out of memory
+  {
+    std::cout << exc.what() << "\n";
+  }
+
+  std::cout << "-- generic interface, first version --\n";
+  try
+  {
+    std::size_t index = fwd_get_index(begin(haystack), end(haystack), needle);
+    std::cout << needle << " found at index " << index << "\n";
+  }
+  catch(std::exception& exc) // better catch standard exceptions as well; me might e.g. run out of memory
+  {
+    std::cout << exc.what() << "\n";
+  }
+
+  std::cout << "-- generic interface, second version --\n";
+  try
+  {
+    std::size_t index = generic_get_index(begin(haystack), end(haystack), needle);
+    std::cout << needle << " found at index " << index << "\n";
+  }
+  catch(std::exception& exc) // better catch standard exceptions as well; me might e.g. run out of memory
+  {
+    std::cout << exc.what() << "\n";
+  }
+}
+
+int main()
+{
+  std::cout << "\n=== Word which only occurs once ===\n";
+  test("Wally");
+  std::cout << "\n=== Word occuring multiple times ===\n";
+  test("Bush");
+  std::cout << "\n=== Word not occuring at all ===\n";
+  test("Goofy");
+}

Task/Search-a-list/Common-Lisp/search-a-list.lisp

@@ -0,0 +1,6 @@
+(let ((haystack '(Zig Zag Wally Ronald Bush Krusty Charlie Bush Bozo)))
+  (dolist (needle '(Washington Bush))
+    (let ((index (position needle haystack)))
+      (if index
+          (progn (print index) (princ needle))
+          (progn (print needle) (princ "is not in haystack"))))))

Task/Search-a-list/D/search-a-list.d

@@ -0,0 +1,18 @@
+import std.algorithm, std.range, std.string;
+
+auto firstIndex(R, T)(R hay, T needle) {
+  auto i = countUntil(hay, needle);
+  if (i == -1)
+    throw new Exception("No needle found in haystack");
+  return i;
+}
+
+auto lastIndex(R, T)(R hay, T needle) {
+  return walkLength(hay) - firstIndex(retro(hay), needle) - 1;
+}
+
+void main() {
+  auto h = split("Zig Zag Wally Ronald Bush Krusty Charlie Bush Bozo");
+  assert(firstIndex(h, "Bush") == 4);
+  assert(lastIndex(h, "Bush") == 7);
+}

Task/Search-a-list/DWScript/search-a-list.dwscript

@@ -0,0 +1,11 @@
+var haystack : array of String = ["Zig","Zag","Wally","Ronald","Bush","Krusty","Charlie","Bush","Bozo"];
+
+function Find(what : String) : Integer;
+begin
+   Result := haystack.IndexOf(what);
+   if Result < 0 then
+      raise Exception.Create('not found');
+end;
+
+PrintLn(Find("Ronald")); // 3
+PrintLn(Find('McDonald')); // exception

Task/Search-a-list/Delphi/search-a-list.delphi

@@ -0,0 +1,36 @@
+program Needle;
+
+{$APPTYPE CONSOLE}
+
+uses
+  SysUtils, Classes;
+
+var
+  list: TStringList;
+  needle: string;
+  ind: Integer;
+begin
+  list := TStringList.Create;
+  try
+    list.Append('triangle');
+    list.Append('fork');
+    list.Append('limit');
+    list.Append('baby');
+    list.Append('needle');
+
+    list.Sort;
+
+    needle := 'needle';
+    ind := list.IndexOf(needle);
+    if ind < 0 then
+      raise Exception.Create('Needle not found')
+    else begin
+      Writeln(ind);
+      Writeln(list[ind]);
+    end;
+
+    Readln;
+  finally
+    list.Free;
+  end;
+end.

Task/Search-a-list/E/search-a-list.e

@@ -0,0 +1,12 @@
+def haystack := ["Zig","Zag","Wally","Ronald","Bush","Krusty","Charlie","Bush","Bozo"]
+
+/** meet the 'raise an exception' requirement */
+def find(needle) {
+    switch (haystack.indexOf1(needle)) {
+        match ==(-1) { throw("an exception") }
+        match index { return index }
+    }
+}
+
+println(find("Ronald")) # prints 3
+println(find("McDonald")) # will throw

Task/Search-a-list/Euphoria/search-a-list.euphoria

@@ -0,0 +1,46 @@
+include std/search.e
+include std/console.e
+
+--the string "needle" and example haystacks to test the procedure
+sequence searchStr1 = "needle"
+sequence haystack1 = { "needle", "needle", "noodle", "node", "need", "needle  ", "needle" }
+sequence haystack2 = {"spoon", "fork", "hay", "knife", "needle", "barn", "etcetera", "more hay", "needle", "a cow", "farmer", "needle", "dirt"}
+sequence haystack3 = {"needle"}
+sequence haystack4 = {"no", "need le s", "in", "this", "haystack"}
+sequence haystack5 = {"knee", "needle", "dull", "needle"}
+sequence haystack6 = {}
+
+--search procedure with console output
+procedure haystackSearch(sequence hStack)
+    sequence foundNeedles = find_all(searchStr1, hStack)
+    puts(1,"---------------------------------\r\n")
+    if object(foundNeedles) and length(foundNeedles) > 0 then
+        printf(1, "First needle found at index %d \r\n", foundNeedles[1])
+
+        if length(foundNeedles) > 1 then
+            printf(1, "Last needle found at index %d \r\n", foundNeedles[length(foundNeedles)] )
+
+            for i = 1 to length(foundNeedles) do
+                printf(1, "Needle #%d ", i)
+                printf(1, "was at index %d .\r\n", foundNeedles[i])
+            end for
+
+            else
+                puts(1, "There was only one needle found in this haystack. \r\n")
+        end if
+
+        else
+            puts(1, "Simulated exception - No needles found in this haystack.\r\n")
+    end if
+
+end procedure
+
+--runs the procedure on all haystacks
+haystackSearch(haystack1)
+haystackSearch(haystack2)
+haystackSearch(haystack3)
+haystackSearch(haystack4)
+haystackSearch(haystack5)
+haystackSearch(haystack6)
+--wait for user to press a key to exit
+any_key()