Semordnilap: Difference between revisions

{{trans|Python}}

V revlist = wordset.map(word -> reversed(word))

V pairs = Set(zip(wordset, revlist).filter((wrd, rev) -> wrd < rev & rev C :wordset))

print(pairs.len)

{{out}}

=={{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>

=={{header|Arturo}}==

pairs: []

loop words 'wrd [

unique 'pairs

=={{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>

} else

return 1; // couldn't open input file

{{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)

=={{header|Crystal}}==

UNIXDICT = File.read("unixdict.txt").lines

# print out the size, and 5 random pairs

puts final_results.size, final_results.sample(5)

{{out}}

=={{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

{{libheader| System.StrUtils}}

{{libheader| System.Diagnostics}}

program Semordnilap;

end.

{{out}}

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

(lib 'struct)

(lib 'sql)

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}}

=={{header|Ksh}}==

#!/bin/ksh

done

done

{{out}}<pre>

Examples:

=={{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">

=={{header|Mathematica}}/{{header|Wolfram Language}}==

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>

=={{header|NewLisp}}==

;;; Get the words as a list, splitting at newline

(setq data

(dolist (x res)

(if (> (length x) 4) (println x " -- " (get-reverse x))))

{{out}}

<pre>

=={{header|Nim}}==

proc reversed(s: string): string =

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

pairs = pairs.sortedByIt(it[0].len)

{{out}}

=={{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}}==

<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>

<span style="color: #004080;">sequence</span> <span style="color: #000000;">words</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">unix_dict</span><span style="color: #0000FF;">(),</span> <span style="color: #000000;">semordnilap</span><span style="color: #0000FF;">={}</span>

<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"%s - %s\n"</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">semordnilap</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">],</span><span style="color: #7060A8;">reverse</span><span style="color: #0000FF;">(</span><span style="color: #000000;">semordnilap</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">])})</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>

{{out}}

<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}}

=={{header|PureBasic}}==

If ReadFile(0,"./Data/unixdict.txt")=0 : End 2 : EndIf

NewList dict$()

PrintN(Space(15)+StringField(res$,k,#LF$))

Next

{{out}}

<pre>Semordnilap pairs found: 158

=={{header|Python}}==

===Idiomatic===

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

>>> 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

if __name__ == '__main__':

main(*sys.argv[1:])

{{Out}}

=={{header|Quackery}}==

$ "rosetta/unixdict.txt" sharefile drop

nest$

witheach

[ dup echo$ say "<->"

{{out}}

=={{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>

The (first five) semordnilap pairs are shown as they are specified/defined (respective to case) in the dictionary.

parse arg n iFID . /*obtain optional argument from the CL.*/

if n=='' | n=="," then n= 5 /*Not specified? Then use the default.*/

end /*while*/ /*stick a fork in it, we're all done. */

say

{{out|output|text=&nbsp; when using the default inputs:}}

<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|Rust}}==

{{trans|Java}}

use std::fs::File;

use std::io::{self, BufRead};

Err(error) => eprintln!("{}", error),

}

{{out}}

</pre>

===A Shortened Version===

fn reverse(x: &str) -> String {

println!("{}, {}", candidats[ind], reverse(candidats[ind]));

}

{{out}}

<pre>Numbers of pairs found: 158

=={{header|Scala}}==

scala.io.Source.

fromURL("http://wiki.puzzlers.org/pub/wordlists/unixdict.txt").

println( s"${ss.size} matches, including: \n" )

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

{{out}}

<pre>158 matches, including:

=={{header|Seed7}}==

include "gethttp.s7i";

writeln;

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

{{out}}

=={{header|Sidef}}==

{{trans|Perl}}

var seen = Hash()

}

{{out}}

<pre>

=={{header|SNOBOL4}}==

{{works with|SNOBOL4, SPITBOL for Linux}}

* Program: semordnilap.sbl

* To run: sbl semordnilap.sbl < unixdict.txt

output = 'The number of semordnilap pairs is: ' outcount

END

{{out}}

<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>

=={{header|Transd}}==

MainModule: {

(lout "Random five: " Range(in: v 0 5))))

)

{{out}}

<pre>

=={{header|TUSCRIPT}}==

$$ MODE TUSCRIPT,{}

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

ENDLOOP

ENDCOMPILE

{{out}}

<pre>

=={{header|VBScript}}==

Set objFSO = CreateObject("Scripting.FileSystemObject")

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

Set objUnixDict = Nothing

Set objSemordnilap = Nothing

{{out}}

=={{header|Wren}}==

var dict = File.read("unixdict.txt").split("\n")

for (i in 0..4) System.print(" %(pairs[i][0]), %(pairs[i][1])")

System.print("\nand the last five are:")

{{out}}

=={{header|XPL0}}==

string 0; \use zero-terminated strings

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

];

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

{{out}}

=={{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>