Semordnilap: Difference between revisions

{{task}}

 

 

Example: ''lager'' and ''regal''

<br><br>

;Task

<br><br>

 

=={{header|8th}}==

We're using a map to keep track of what's been seen, and an array to store the results. We load the "unixdict.txt" as an "asset", meaning a file stored alongside the program code:

[] var, results

 

a:shuffle

( a:shift dup . " is the reverse of " . s:rev . cr ) 5 times bye

 

{{out}}

Before tackling the real problem, we specify a package String_Vectors and a class String_Vectors.Vec, to store the list of words in the dictionary:

 

 

package String_Vectors is

-- checks if Word is in List(Start .. Stop);

-- requirement: the words in List are sorted alphabetically

 

The specified class String_Vectors.Vec has been derived from Ada.Containers.Indefinite_Vectors.Vector and provides two additional primitive operations Read and Is_In. Here is the implementation:

 

 

function Is_In(List: Vec;

end Read;

 

 

This is the main program:

 

 

procedure Semordnilap is

Ada.Text_IO.New_Line;

Ada.Text_IO.Put("pairs found:" & Integer'Image(Semi_Counter));

 

{{out}}

 

=={{header|Aime}}==

record r;

file f;

}

 

{{out}}

<pre>ca ac

{{works with|ALGOL 68G|Any - tested with release 2.8.3.win32}}

The Algol 68 G "read" PRAGMA is used to include the associative array code from Associative_array/Iteration.

# use the associative array in the Associate array/iteration task #

PR read "aArray.a68" PR

close( input file );

print( ( whole( semordnilap count, 0 ), " semordnilaps found", newline ) )

{{out}}

<pre>

158 semordnilaps found

</pre>

 

=={{header|AutoHotkey}}==

{{works with|AutoHotkey_L}}

 

FileRead, dict, unixdict.txt

r := A_LoopField . r

return r

{{out}}

<pre>5 Examples:

 

=={{header|AWK}}==

# syntax: GAWK -f SEMORDNILAP.AWK unixdict.txt

{ arr[$0]++ }

exit(0)

}

{{out}}

<pre>

=={{header|BBC BASIC}}==

{{works with|BBC BASIC for Windows}}

Sort% = FN_sortinit(0,0)

SWAP P%?I%, L%?(P%-I%)

NEXT

{{out}}

<pre>

 

=={{header|Bracmat}}==

& new$hash:?H

& 0:?p

& out$(semordnilap !N dnuoF)

)

{{out}}

<pre>tv vt

=={{header|C}}==

 

#include <stdlib.h>

#include <alloca.h> /* stdlib.h might not have obliged. */

printf("Semordnilap pairs: %d\n", sem);

return 0;

 

{{out}}

 

=={{header|C sharp}}==

using System.Net;

using System.Collections.Generic;

private static string Reversed(string value) => new string(value.Reverse().ToArray());

{{out}}

<pre>

 

=={{header|C++}}==

#include <iostream>

#include <set>

#include <string>

 

std::ifstream input("unixdict.txt");

 

}

}

{{out}}

<pre>

 

=={{header|Clojure}}==

(:require [clojure.string :as str])

[clojure.java.io :as io ]))

dict-file)

 

 

{{out}}

 

=={{header|Common Lisp}}==

(let ((word-map (make-hash-table :test 'equal)))

(loop for word in word-list do

for word in words

do (print word)))

{{out}}

<pre>* (main)

("ah" . "ha")

("al" . "la")</pre>

 

=={{header|D}}==

===Simple Imperative Version===

import std.stdio, std.file, std.string, std.algorithm;

 

 

writeln("\nSemordnilap pairs: ", pairCount);

{{out}}

<pre>ca ac

 

===A More Functional Version===

import std.stdio, std.file, std.algorithm, std.string, std.range;

 

.zip(0.repeat).assocArray;

writeln(pairs.length, "\n", pairs.byKey.take(5));

{{out}}

<pre>158

[Tuple!(string, char[])("bag", "gab"), Tuple!(string, char[])("pat", "tap"), Tuple!(string, char[])("avis", "siva"), Tuple!(string, char[])("haw", "wah"), Tuple!(string, char[])("rot", "tor")]</pre>

 

=={{header|EchoLisp}}==

We use the '''words''' library, and the french dictionary delivered with EchoLisp.

 

(lib 'struct)

(lib 'sql)

(writeln 'pairs '→ (length semordnilap))

(writeln 'longest '→ (take semordnilap 5)))

 

{{out}}

(task)

pairs → 345

longest → (rengager tresser strasse reveler retrace)

 

=={{header|Eiffel}}==

First the programm reads the wordlist into an array.

Then it mirrors each word and searchs for it across the array using binary search.

class

SEMORDNILAP

 

end

Test:

class

APPLICATION

 

end

{{out}}

<pre>

 

=={{header|Elixir}}==

|> Enum.map(&String.strip/1)

|> Enum.group_by(&min(&1, String.reverse &1))

|> Enum.filter(&(length &1) == 2)

IO.puts "Semordnilap pair: #{length(words)}"

 

{{out}}

=={{header|Erlang}}==

{{trans|Clojure}}

main([]) -> main(["unixdict.txt"]);

 

[X||{_,X} <- lists:sort([ {random:uniform(), N} || N <- List])].

 

 

{{out}}

=={{header|F_Sharp|F#}}==

Using a mutable dictionary.

 

let seen = new System.Collections.Generic.Dictionary<string,bool>()

let s = Seq.toList sems

printfn "%d" s.Length

{{out}}

<pre>158

 

=={{header|Factor}}==

io.encodings.utf8 io.files kernel literals locals make

prettyprint random sequences ;

]

] H{ } make >alist

{{out}}

<pre>

The code uses two Gforth-specific words: EXECUTE-PARSING (implementable in standard Forth, but not easy) for allowing to provide the name of the defined word on the stack; and FIND-NAME-IN to look up the reversed word (could be replaced with a use of the standard SEARCH-WORDLIST, but the code would become a little more complicated).

 

wordlist constant dict

 

0 ' nt-semicheck dict traverse-wordlist cr .

cr bye

 

{{out}}

 

 

!-*- mode: compilation; default-directory: "/tmp/" -*-

!Compilation started at Sun May 19 21:50:08

 

end program Semordnilap

 

=={{header|FreeBASIC}}==

' compile with: fbc -s console

 

Print : Print "Hit any key to end program"

Sleep

{{out}}

<pre>Start reading unixdict.txt ... Done

 

=={{header|Go}}==

 

import (

fmt.Println(" ", e)

}

{{out}}

<pre>

 

=={{header|Groovy}}==

def words = [] as Set

def semordnilaps = []

}

semordnilaps

Test Code

println "Found ${semordnilaps.size()} semordnilap words"

{{out}}

<pre>Found 158 semordnilap words

 

=={{header|Haskell}}==

 

semordnilaps

let l = semordnilaps (lines s)

print $ length l

{{out}}

<pre>158

 

The following solution works in both Icon and Unicon:

words := set()

found := 0

write("\nFound ",found," semordnilap words")

end

 

Sample run with unixdict:

We find all semordnilaps by filtering only words which, when reversed, are a member of the set of dictionary words and are not palindromes. We then find only unique semordnilaps by pairing them with their reversed instance, sorting each pair, and eliminating duplicates pairs:

 

unixdict=: <;._2 freads 'unixdict.txt'

#semordnilaps=: ~. /:~"1 (,. |.&.>) (#~ isSemordnilap) unixdict

 

We see that there are 158 semordnilaps.

Here's 5 of them, picked arbitrarily:

 

┌────┬────┐

│kay │yak │

├────┼────┤

│caw │wac │

 

=={{header|Java}}==

{{trans|D}}

{{works with|Java|7+}}

import java.util.*;

 

System.out.println("\nSemordnilap pairs found: " + count);

}

<pre>ca ac

dab bad

===Node.js===

{{trans|Clojure}}

var fs = require('fs');

var sys = require('sys');

for (var i=0; i<5; ++i) {

sys.puts(semordnilaps[indices[i]]);

 

===Rhino===

{{works with|Rhino|1.7}}

 

 

importPackage (java.io)

for (var i=0; i<5; ++i) {

print(semordnilaps[indices[i]]);

 

{{out}}

===macOS JavaScript for Automation===

{{Trans|Python}}

'use strict';

 

// MAIN ---

return main();

{{Out}}

<pre>158

* time /usr/local/bin/jq -M -s -R -r -f semordnilap.jq unixdict.txt

user 0m0.440s; sys 0m0.010s

# Produce a stream

def report:

| (. < $rev and $dict[$rev]) );

 

{{Out}}

able

 

=={{header|Julia}}==

inter = intersect(raw,map(reverse,raw)) #find the matching strings/revstrings

res = String[b == 1 && a != reverse(a) && a < reverse(a) ? a : reverse(a) for a in inter, b in 1:2] #create pairs

<pre>julia> length(res[:,1])

158

=={{header|Kotlin}}==

{{trans|D}}

 

import java.io.File

println("Found ${pairs.size} semordnilap pairs")

println(pairs.take(5))

 

{{out}}

[(able, elba), (abut, tuba), (ac, ca), (ah, ha), (al, la)]

</pre>

 

=={{header|Lasso}}==

words = string(include_url('http://www.puzzlers.org/pub/wordlists/unixdict.txt')) -> split('\n'),

semordnilaps = array,

#found_size

'<br />'

{{out}}

<pre>Total found: 158

 

=={{header|Liberty BASIC}}==

print "Loading dictionary."

open "unixdict.txt" for input as #1

Next i

End Function

{{out}}

<pre>

 

=={{header|Lua}}==

-- allow dictionary file and sample size to be specified on command line

local dictfile = arg[1] or "unixdict.txt"

semordnilaps[j] = nil

print(f .. " -> " .. r)

 

{{out}}

 

=={{header|M2000 Interpreter}}==

Module semordnilaps {

Document d$

}

semordnilaps

{{out}}

<pre style="height:30ex;overflow:scroll">

</pre >

 

result = DeleteDuplicates[ Select[data, MemberQ[data, StringReverse[#]]

&& # =!= StringReverse[#] &], (# ===StringReverse[#2]) &];

{{out}}

<pre>158 {able,abut,ac,ah,al}</pre>

=={{header|Nanoquery}}==

{{trans|Java}}

 

def reverse_str(string)

end

 

{{out}}

<pre>ca ac

=={{header|NetRexx}}==

{{Trans|REXX}}

options replace format comments java crossref symbols nobinary

 

Say pi 'words in' fid 'have a palindrome' /* total number found */

return

{{out}}

<pre>

bard drab

158 words in unixdict.txt have a palindrome

</pre>

 

=={{header|Nim}}==

 

result = newString(s.len)

result[s.high - i] = c

 

let

var pairs = zip(words, revs).filterIt(it[0] < it[1] and it[1] in wordset)

 

echo "Total number of semordnilaps: ", pairs.len

{{out}}

<pre>Total number of semordnilaps: 158

 

=={{header|OCaml}}==

 

let str_rev s =

let (word, rev) = List.nth pairs (Random.int len) in

Printf.printf " %s %s\n" word rev

 

{{out}}

 

=={{header|Octave}}==

a = intersect(a, cellfun(@fliplr, a, "UniformOutput", false));

a = a(arrayfun(@(i) ismember(fliplr(a{i}), a(i+1:length(a))), 1:length(a)));

length(a)

 

'''Output:'''

=={{header|Oforth}}==

 

| w wr wrds |

ListBuffer new ->wrds

wrds include(w reverse dup ->wr) ifTrue: [ [wr, w] over add ]

w wr < ifTrue: [ wrds add(w) ]

 

{{out}}

 

=={{header|Perl}}==

chomp;

my $r = reverse;

}

 

 

=={{header|Phix}}==

{{out}}

<pre>

</pre>

 

=={{header|PHP}}==

{{trans|Raku}}

// Read dictionary into array

$dictionary = array_fill_keys(file(

// array_rand() returns keys, not values

foreach (array_rand($words, 5) as $word)

{{out}}

<pre>158

 

=={{header|PicoLisp}}==

(mapcon

'((Lst)

(cons (pack (car Lst))) ) )

(make (in "unixdict.txt" (while (line) (link @)))) )

{{out}}

<pre>158 ("able" "abut" "ac" "ah" "al")</pre>

 

=={{header|PL/I}}==

find: procedure options (main); /* 20/1/2013 */

declare word character (20) varying controlled;

end;

end find;

<pre>

There are 158 pairs.

 

=={{header|PowerShell}}==

function Reverse-String ([string]$String)

{

 

"`nSemordnilap count: {0}" -f ($semordnilap.GetEnumerator() | Measure-Object).Count

 

{{Out}}

Semordnilap count: 158

</pre>

 

=={{header|Python}}==

===Idiomatic===

wordset = set(f.read().strip().split())

 

>>> revlist = (''.join(word[::-1]) for word in wordset)

>>> len(pairs)

158

>>> sorted(pairs, key=lambda p: (len(p[0]), p))[-5:]

[('damon', 'nomad'), ('lager', 'regal'), ('leper', 'repel'), ('lever', 'revel'), ('kramer', 'remark')]

 

===As a fold, using reduce===

{{Works with|Python|3.7}}

 

from functools import (reduce)

 

if __name__ == '__main__':

{{Out}}

<pre>Dictionary words paired by equivalence under reversal:

Requires the <code>requests</code> library.

 

import random

import requests

print(

* ['%s %s' % p for p in example_pairs]+['...'],

sep='\n'

if __name__ == '__main__':

main(*sys.argv[1:])

 

{{Out}}

<pre>

mug gum

revel lever

...

</pre>

 

=={{header|Racket}}==

#lang racket

(define seen (make-hash))

(for ([s (take (sort semordnilaps > #:key (compose1 string-length car)) 5)])

(apply printf " ~s ~s\n" s))

 

{{out}}

(formerly Perl 6)

{{works with|rakudo|2015-10-26}}

 

my @sems = gather for $words.flat -> $word {

}

 

{{out}}

<pre>abut tuba

=={{header|REXX}}==

===version 1===

* 07.09.2012 Walter Pachl

**********************************************************************/

End

End

{{out}}

<pre>

===version 2===

This REXX version makes use of sparse (stemmed) arrays.

say

<pre>

 

</pre>

 

=={{header|Ring}}==

# Project : Semordnilap

 

nr = find(aList,bString)

return nr

{{out}}

<pre>

=={{header|Ruby}}==

Note: An alternative (old fashioned) method of solving this task (not using a Set as done by other solutions) is to produce 2 sorted files and walk through them. This can be done entirly on disk if required, when done in memory it is faster than a set for large samples.--[[User:Nigel Galloway|Nigel Galloway]] 11:12, 17 September 2012 (UTC)

i = 0

res = dict.collect(&:reverse).sort.select do |z|

end

puts "There are #{res.length} semordnilaps, of which the following are 5:"

{{out}}

<pre>

 

Another way

.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:"

output is the same above.

 

=={{header|Scala}}==

 

/**

* words are different.

*/

 

zipWithIndex. // index will be needed to eliminate duplicate

i < j && w != w.reverse // save the matches which are not palindromes

}

}

 

 

{

println( ss.take(5).mkString( "\n" ) )

{{out}}

<pre>158 matches, including:

 

=={{header|Seed7}}==

include "gethttp.s7i";

 

const proc: main is func

var integer: count is 0;

begin

for word range wordList do

drow := reverse(word);

writeln;

writeln("Semordnilap pairs: " <& count);

 

{{out}}

=={{header|Sidef}}==

{{trans|Perl}}

var seen = Hash()

 

}

 

{{out}}

<pre>

drab bard

158

</pre>

 

=={{header|Stata}}==

 

import delimited http://www.puzzlers.org/pub/wordlists/unixdict.txt, clear

save temp, replace

| nit tin |

| ku uk |

 

=={{header|SuperCollider}}==

{{incorrect|SuperCollider|The number of pairs should be 158.}}

var text, words, sdrow, semordnilap, selection;

File.use("unixdict.txt".resolveRelative, "r", { |f| x = text = f.readAllString });

selection = semordnilap.select { |each| each.size >= 4 }.scramble.keep(4);

selection.do { |each| "% %\n".postf(each, each.reverse); };

 

Answers:

There are 405 in unixdict.txt

For example those, with more than 3 characters:

drib bird

eros sore

 

This seems wrong, but perhaps the test file has changed?

=={{header|Swift}}==

 

fatalError()

}

 

print("Found \(pairs.count) pairs")

 

{{out}}

 

=={{header|Tcl}}==

package require http

 

puts "Example: $pair"

if {[incr i]>=5} break

{{out}}

<pre>

Example: eros/sore

Example: bard/drab

</pre>

 

=={{header|TUSCRIPT}}==

$$ MODE TUSCRIPT,{}

requestdata = REQUEST ("http://www.puzzlers.org/pub/wordlists/unixdict.txt")

ENDLOOP

ENDCOMPILE

{{out}}

<pre>

4. ah'ha

5. al'la

</pre>

 

=={{header|VBScript}}==

Set objFSO = CreateObject("Scripting.FileSystemObject")

Set objInFile = objFSO.OpenTextFile(objFSO.GetParentFolderName(WScript.ScriptFullName) &_

Set objUnixDict = Nothing

Set objSemordnilap = Nothing

 

{{out}}

drab - bard

Total Count: 158

</pre>

 

=={{header|XPL0}}==

string 0; \use zero-terminated strings

def LF=$0A, CR=$0D, EOF=$1A;

];

IntOut(0, Count); CrLf(0);

 

{{out}}

158

</pre>

 

=={{header|zkl}}==

File("dict.txt").howza(11).pump(Dictionary().howza(8).add.fp1(True));

ss:=words.pump(List, // push stripped unixdict words through some functions

 

ss.len().println(); //--> 158

{{out}}

<pre>

 

 

{{omit from|Brlcad}}

{{omit from|GUISS}}

{{omit from|Openscad}}

{{omit from|TPP}}

{{omit from|ZX Spectrum Basic}}