2016 Update

Task/Semordnilap/00DESCRIPTION

@@ -1,8 +1,11 @@
-A '''[[wp:semordnilap|semordnilap]]''' is a word (or phrase) that spells a different word (or phrase) backward. "Semordnilap" is a word that itself is a semordnilap.
-
-Example: <code>''lager'' and ''regal''</code>
+A [[wp:semordnilap|semordnilap]] is a word (or phrase) that spells a different word (or phrase) backward.
+"Semordnilap" is a word that itself is a semordnilap.
 
+Example: ''lager'' and ''regal''
+<br><br>
+;Task
 Using only words from the [http://www.puzzlers.org/pub/wordlists/unixdict.txt unixdict], report the total number of unique semordnilap pairs, and print 5 examples. (Note that lager/regal and regal/lager should be counted as one unique pair.)
-
-;Cf.
+<br><br>
+;Related tasks
 * [[Palindrome_detection|Palindrome detection]]
+<br><br>

Task/Semordnilap/ALGOL-68/semordnilap.alg

@@ -0,0 +1,62 @@
+# find the semordnilaps in a list of words                           #
+# use the associative array in the Associate array/iteration task    #
+PR read "aArray.a68" PR
+
+# returns text with the characters reversed                          #
+OP REVERSE = ( STRING text )STRING:
+     BEGIN
+         STRING reversed  := text;
+         INT    start pos := LWB text;
+         FOR end pos FROM UPB reversed BY -1 TO LWB reversed
+         DO
+             reversed[ end pos ] := text[ start pos ];
+             start pos +:= 1
+         OD;
+         reversed
+    END # REVERSE # ;
+
+# read the list of words and store the words in an associative array #
+# check for semordnilaps                                             #
+IF  FILE input file;
+    STRING file name = "unixdict.txt";
+    open( input file, file name, stand in channel ) /= 0
+THEN
+    # failed to open the file #
+    print( ( "Unable to open """ + file name + """", newline ) )
+ELSE
+    # file opened OK #
+    BOOL at eof := FALSE;
+    # set the EOF handler for the file #
+    on logical file end( input file, ( REF FILE f )BOOL:
+                                     BEGIN
+                                         # note that we reached EOF on the #
+                                         # latest read #
+                                         at eof := TRUE;
+                                         # return TRUE so processing can continue #
+                                         TRUE
+                                     END
+                       );
+    REF AARRAY words := INIT LOC AARRAY;
+    STRING word;
+    INT    semordnilap count := 0;
+    WHILE NOT at eof
+    DO
+        STRING word;
+        get( input file, ( word, newline ) );
+        STRING reversed word = REVERSE word;
+        IF ( words // reversed word ) = ""
+        THEN
+            # the reversed word isn't in the array                   #
+            words // word := reversed word
+        ELSE
+            # we already have this reversed - we have a semordnilap  #
+            semordnilap count +:= 1;
+            IF semordnilap count <= 5
+            THEN
+                print( ( reversed word, " & ", word, newline ) )
+           FI
+        FI
+    OD;
+    close( input file );
+    print( ( whole( semordnilap count, 0 ), " semordnilaps found", newline ) )
+FI

Task/Semordnilap/C-sharp/semordnilap.cs

@@ -0,0 +1,39 @@
+using System;
+using System.Net;
+using System.Collections.Generic;
+using System.Linq;
+using System.IO;
+
+public class Semordnilap
+{
+    public static void Main() {
+        var results = FindSemordnilaps("http://www.puzzlers.org/pub/wordlists/unixdict.txt").ToList();
+        Console.WriteLine(results.Count);
+        var random = new Random();
+        Console.WriteLine("5 random results:");
+        foreach (string s in results.OrderBy(_ => random.Next()).Distinct().Take(5)) Console.WriteLine(s + " " + Reversed(s));
+    }
+
+    private static IEnumerable<string> FindSemordnilaps(string url) {
+        var found = new HashSet<string>();
+        foreach (string line in GetLines(url)) {
+            string reversed = Reversed(line);
+            //Not taking advantage of the fact the input file is sorted
+            if (line.CompareTo(reversed) != 0) {
+                if (found.Remove(reversed)) yield return reversed;
+                else found.Add(line);
+            }
+        }
+    }
+
+    private static IEnumerable<string> GetLines(string url) {
+        WebRequest request = WebRequest.Create(url);
+        using (var reader = new StreamReader(request.GetResponse().GetResponseStream(), true)) {
+            while (!reader.EndOfStream) {
+                yield return reader.ReadLine();
+            }
+        }
+    }
+
+    private static string Reversed(string value) => new string(value.Reverse().ToArray());
+}

Task/Semordnilap/Elixir/semordnilap.elixir

@@ -0,0 +1,7 @@
+words = File.stream!("unixdict.txt")
+        |> Enum.map(&String.strip/1)
+        |> Enum.group_by(&min(&1, String.reverse &1))
+        |> Map.values
+        |> Enum.filter(&(length &1) == 2)
+IO.puts "Semordnilap pair: #{length(words)}"
+IO.inspect Enum.take(words,5)

Task/Semordnilap/Forth/semordnilap.fth

@@ -0,0 +1,35 @@
+wordlist constant dict
+
+: load-dict ( c-addr u -- )
+    r/o open-file throw >r
+    begin
+	pad 1024 r@ read-line throw while
+	    pad swap ['] create execute-parsing
+    repeat
+    drop r> close-file throw ;
+
+: xreverse {: c-addr u -- c-addr2 u :}
+    u allocate throw u + c-addr swap over u + >r begin ( from to r:end)
+	over r@ u< while
+	    over r@ over - x-size dup >r - 2dup r@ cmove
+	    swap r> + swap repeat
+    r> drop nip u ;
+
+: .example ( c-addr u u1 -- )
+    5 < if
+	cr 2dup type space 2dup xreverse 2dup type drop free throw then
+    2drop ;
+
+: nt-semicheck ( u1 nt -- u2 f )
+    dup >r name>string xreverse 2dup dict find-name-in dup if ( u1 c-addr u nt2)
+	r@ < if ( u1 c-addr u ) \ count pairs only once and not palindromes
+	    2dup 4 pick .example
+	    rot 1+ -rot then
+    else
+	drop then
+    drop free throw r> drop true ;
+
+get-current dict set-current s" unixdict.txt" load-dict set-current
+
+0 ' nt-semicheck dict traverse-wordlist cr .
+cr bye

Task/Semordnilap/Kotlin/semordnilap.kotlin

@@ -1,9 +1,6 @@
-import java.nio.file.Files
-import java.nio.file.Paths
-
 fun semordnilap() {
-    val words = Files.readAllLines(Paths.get("unixdict.txt"), Charsets.UTF_8).toSet()
-    val pairs = words.asSequence().map { it to it.reverse() } // Pair(word, reversed word)
+    val words = File("unixdict.txt").readLines().toSet()
+    val pairs = words.asSequence().map { it to it.reversed() } // Pair(word, reversed word)
             .filter { it.first < it.second && it.second in words }.toList() // avoid dupes+palindromes, find matches
     println("Found ${pairs.size()} semordnilap pairs")
     println(pairs.take(5))

Task/Semordnilap/PowerShell/semordnilap.psh

@@ -0,0 +1,35 @@
+function Reverse-String ([string]$String)
+{
+    [char[]]$output = $String.ToCharArray()
+    [Array]::Reverse($output)
+    $output -join ""
+}
+
+[string]$url = "http://www.puzzlers.org/pub/wordlists/unixdict.txt"
+[string]$out = ".\unixdict.txt"
+
+(New-Object System.Net.WebClient).DownloadFile($url, $out)
+
+[string[]]$file = Get-Content -Path $out
+
+[hashtable]$unixDict    = @{}
+[hashtable]$semordnilap = @{}
+
+foreach ($line in $file)
+{
+    if ($line.Length -gt 1)
+    {
+        $unixDict.Add($line,"")
+    }
+
+    [string]$reverseLine = Reverse-String $line
+
+    if ($reverseLine -notmatch $line -and $unixDict.ContainsKey($reverseLine))
+    {
+        $semordnilap.Add($line,$reverseLine)
+    }
+}
+
+$semordnilap
+
+"`nSemordnilap count: {0}" -f ($semordnilap.GetEnumerator() | Measure-Object).Count

Task/Semordnilap/REXX/semordnilap-2.rexx

@@ -1,15 +1,16 @@
-/*REXX program finds palindrome pairs using a dictionary (UNIXDICT.TXT).*/
-#=0                                             /*# palindromes (so far)*/
-parse arg iFID .;  if iFID==''  then iFID='UNIXDICT.TXT'  /*use default?*/
-@.=                                             /*caseless no-duped word*/
-    do while lines(iFID)\==0; _=space(linein(iFID),0); parse upper var _ u
-    if length(_)<2 | @.u\==''  then iterate     /*can't be a unique pal.*/
-    r=reverse(u)                                /*get the reverse of U. */
-    if @.r\==''  then do;     #=#+1             /*found palindrome pair?*/
-                      if #<6  then say @.r',' _ /*only list first 5 pals*/
-                      end                       /* [↑]  bump count, show*/
-    @.u=_                                       /*define palindromic pal*/
-    end   /*while*/                             /* [↑]  read dictionary.*/
+/*REXX program finds  palindrome pairs in a dictionary  (the default is  UNIXDICT.TXT). */
+#=0                                                       /*number palindromes (so far).*/
+parse arg iFID .;  if iFID==''  then iFID='UNIXDICT.TXT'  /*Not specified?  Use default.*/
+@.=                                                       /*uppercase no─duplicated word*/
+    do  while lines(iFID)\==0;  _=space(linein(iFID),0)   /*read a word from dictionary.*/
+    parse upper var _ u                                   /*obtain an uppercase version.*/
+    if length(_)<2 | @.u\==''  then iterate               /*can't be a unique palindrome*/
+    r=reverse(u)                                          /*get the reverse of the word.*/
+    if @.r\==''  then do;  #=#+1                          /*find a palindrome pair ?    */
+                           if #<6  then say  @.r','   _   /*just show 1st 5 palindromes.*/
+                      end                                 /* [↑]  bump palindrome count.*/
+    @.u=_                                                 /*define a unique palindrome. */
+    end   /*while*/                                       /* [↑]  read the dictionary.  */
 say
-say "There're"  #  'unique palindrome pairs in the dictionary file: ' iFID
-                                       /*stick a fork in it, we're done.*/
+say "There're "      #      ' unique palindrome pairs in the dictionary file: '       iFID
+                                                      /*stick a fork in it, we're done. */

Task/Semordnilap/Ruby/semordnilap-2.rb

@@ -0,0 +1,6 @@
+words = File.readlines("unixdict.txt")
+            .group_by{|x| [x.strip!, x.reverse].min}
+            .values
+            .select{|v| v.size==2}
+puts "There are #{words.size} semordnilaps, of which the following are 5:"
+words.take(5).each {|a,b| puts "#{a}   #{b}"}

Task/Semordnilap/SuperCollider/semordnilap-1.supercollider

@@ -0,0 +1,12 @@
+(
+var text, words, sdrow, semordnilap, selection;
+File.use("unixdict.txt".resolveRelative, "r", { |f| x = text = f.readAllString });
+words = text.split(Char.nl).collect { |each| each.asSymbol };
+sdrow = text.reverse.split(Char.nl).collect { |each| each.asSymbol };
+semordnilap = sect(words, sdrow); // converted to symbols so intersection is possible
+semordnilap = semordnilap.collect { |each| each.asString };
+"There are % in unixdict.txt\n".postf(semordnilap.size);
+"For example those, with more than 3 characters:".postln;
+selection = semordnilap.select { |each| each.size >= 4 }.scramble.keep(4);
+selection.do { |each| "% %\n".postf(each, each.reverse); };
+)

Task/Semordnilap/SuperCollider/semordnilap-2.supercollider

@@ -0,0 +1,6 @@
+There are 405 in unixdict.txt
+For example those, with more than 3 characters:
+live evil
+tram mart
+drib bird
+eros sore