Find words whose first and last three letters are equal: Difference between revisions

 

=={{header|11l}}==

I word.len > 5 & word[0.<3] == word[(len)-3..]

 

{{out}}

=={{header|Action!}}==

In the following solution the input file [https://gitlab.com/amarok8bit/action-rosetta-code/-/blob/master/source/unixdict.txt unixdict.txt] is loaded from H6 drive. Altirra emulator automatically converts CR/LF character from ASCII into 155 character in ATASCII charset used by Atari 8-bit computer when one from H6-H10 hard drive under DOS 2.5 is used.

BYTE len

 

 

FindWords(fname)

{{out}}

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Find_words_whose_first_and_last_three_letters_are_equal.png Screenshot from Atari 8-bit computer]

 

=={{header|Ada}}==

with Ada.Strings.Fixed;

 

end loop;

Close (File);

 

=={{header|ALGOL 68}}==

IF FILE input file;

STRING file name = "unixdict.txt";

print( ( newline, "found ", whole( count, 0 ), " words with the same first and last 3 characters", newline ) );

close( input file )

{{out}}

<pre>

=={{header|Arturo}}==

 

equalHeadTail?: function [w][

equal? first.n: 3 w last.n: 3 w

print word

]

 

{{out}}

 

=={{header|AutoHotkey}}==

for i, word in StrSplit(db, "`n", "`r")

if StrLen(word) < 6

result .= word "`n"

MsgBox, 262144, , % result

{{out}}

<pre>antiperspirant

 

=={{header|AWK}}==

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

(length($0) >= 6 && substr($0,1,3) == substr($0,length($0)-2,3))

exit(0)

}

{{out}}

<pre>

 

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

#include <fstream>

#include <iostream>

}

return EXIT_SUCCESS;

 

{{out}}

 

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

// First and last three letters are equal. Nigel Galloway: February 18th., 2021

let fN g=if String.length g<6 then false else g.[..2]=g.[g.Length-3..]

seq{use n=System.IO.File.OpenText("unixdict.txt") in while not n.EndOfStream do yield n.ReadLine()}|>Seq.filter fN|>Seq.iter(printfn "%s")

{{out}}

<pre>

===Read entire file===

This version reads the entire dictionary file into memory and filters it. This is the fastest version by far. Factor is optimized for making multiple passes over data; it actually takes longer if we combine the two filters into one, either with short-circuiting or non-short-circuiting <code>and</code>.

 

"unixdict.txt" ascii file-lines

[ length 5 > ] filter

[ [ 3 head-slice ] [ 3 tail-slice* ] bi = ] filter

{{out}}

<pre>

===Read file line by line===

This version reads the dictionary file line by line and prints out words that fit the criteria. This ends up being a bit more imperative and deeply nested, but unlike the version above, we only load one word at a time, saving quite a bit of memory.

kernel math sequences ;

 

] when*

] loop

{{out}}

As above.

===Lazy file I/O===

This version lazily reads the input file by treating a stream like a lazy list with the <code>llines</code> word. This allows us the nice style of the first example with the memory benefits of the second example. Unlike in the first example, combining the filters would buy us some time here, as lazy lists aren't as efficient as sequences.

math sequences ;

 

[ length 5 > ] lfilter

[ [ 3 head-slice ] [ 3 tail-slice* ] bi = ] lfilter

{{out}}

As above.

=={{header|Forth}}==

{{works with|Gforth}}

len 5 <= if false exit then

addr 3 addr len 3 - + 3 compare 0= ;

 

main

 

{{out}}

 

=={{header|FreeBASIC}}==

 

type node

nextword:

curr = curr->nxt

{{out}}

<pre>

 

=={{header|Go}}==

 

import (

}

}

 

{{out}}

 

=={{header|J}}==

antiperspirant

calendrical

oshkosh

tartar

 

=={{header|jq}}==

{{works with|jq}}

'''Works with gojq, the Go implementation of jq'''

{{out}}

Invocation example: jq -rRM -f program.jq unixdict.txt

=={{header|Julia}}==

See Alternade_words#Julia for the foreachword function.

<pre>

Word source: unixdict.txt

 

=={{header|Ksh}}==

 

# Find list of words (> 5 chars) where 1st 3 and last 3 letters are the same

[[ ${first} == ${last} ]] && print ${word}

 

 

{{out}}

 

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

dict //= StringSplit[#, "\n"] &;

dict //= Select[StringLength /* GreaterThan[5]];

{{out}}

<pre>{"antiperspirant", "calendrical", "einstein", "hotshot", "murmur", "oshkosh", "tartar", "testes"}</pre>

 

=={{header|Nim}}==

if word.len > 5:

if word[0..2] == word[^3..^1]:

 

{{out}}

=={{header|Perl}}==

as one-liner ..

 

perl -ne '/(?=^(.{3}).*\1$)^.{6,}$/&&print' unixdict.txt

# minor variation

 

 

=={{header|Phix}}==

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

<span style="color: #008080;">function</span> <span style="color: #000000;">flaste</span><span style="color: #0000FF;">(</span><span style="color: #004080;">string</span> <span style="color: #000000;">word</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">return</span> <span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">word</span><span style="color: #0000FF;">)></span><span style="color: #000000;">5</span> <span style="color: #008080;">and</span> <span style="color: #000000;">word</span><span style="color: #0000FF;">[</span><span style="color: #000000;">1</span><span style="color: #0000FF;">..</span><span style="color: #000000;">3</span><span style="color: #0000FF;">]=</span><span style="color: #000000;">word</span><span style="color: #0000FF;">[-</span><span style="color: #000000;">3</span><span style="color: #0000FF;">..-</span><span style="color: #000000;">1</span><span style="color: #0000FF;">]</span> <span style="color: #008080;">end</span> <span style="color: #008080;">function</span>

<span style="color: #004080;">sequence</span> <span style="color: #000000;">flastes</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">filter</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">unix_dict</span><span style="color: #0000FF;">(),</span><span style="color: #000000;">flaste</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;">"%d words: %s\n"</span><span style="color: #0000FF;">,{</span><span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">flastes</span><span style="color: #0000FF;">),</span><span style="color: #7060A8;">join</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">shorten</span><span style="color: #0000FF;">(</span><span style="color: #000000;">flastes</span><span style="color: #0000FF;">,</span><span style="color: #008000;">""</span><span style="color: #0000FF;">,</span><span style="color: #000000;">3</span><span style="color: #0000FF;">))})</span>

{{out}}

<pre>

 

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

declare dict file;

open file(dict) title('unixdict.txt');

put skip list(word);

end;

{{out}}

<pre>antiperspirant

=={{header|Python}}==

Tested on Python 3+, the file download will work only if the link is still active. It is possible that you may be able to fetch the file in your browser but download via code may still fail. Check whether you are connected to a VPN, it works on open networks

import urllib.request

urllib.request.urlretrieve("http://wiki.puzzlers.org/pub/wordlists/unixdict.txt", "unixdict.txt")

if len(word)>5 and word[:3].lower()==word[-3:].lower():

print(word)

{{out}}

<pre>

=={{header|Quackery}}==

 

witheach [

dup nested

filter [ size 5 > ]

filter [ 3 split -3 split nip = ]

 

{{out}}

 

=={{header|R}}==

 

=={{header|Racket}}==

 

 

(define ((prefix-and-suffix-match? len) str)

 

(module+ main

 

{{out}}

 

=={{header|Raku}}==

 

my ( \L, \N, \IN ) = 5, 3, 'unixdict.txt';

 

for IN.IO.lines { .say if .chars > L and .substr(0,N) eq .substr(*-N,*) }

{{out}}

<pre>

 

=={{header|Red}}==

 

foreach word read/lines %unixdict.txt [

print word

]

{{out}}

<pre>

It also allows the length ('''3''') of the first and last number of letters to be specified, &nbsp; and also the minimum length of the

<br>words to be searched on the command line (CL) as well as specifying the dictionary file identifier.

parse arg minL many iFID . /*obtain optional arguments from the CL*/

if minL=='' | minL=="," then minL= 6 /* " " " " " " */

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

say copies('─', 30) finds " words found that the left " many ' letters match the' ,

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

<pre style="font-size:89%">

 

=={{header|Ring}}==

load "stdlib.ring"

 

 

see "done..." + nl

Output:

<pre>

 

=={{header|Ruby}}==

puts words.select{|w| w.end_with?(w[0,3]) && w.size > 5}

{{out}}

<pre>antiperspirant

</pre>

=={{header|Sidef}}==

word.len > 5 || next

if (word.ends_with(word.first(3))) {

say word

}

{{out}}

<pre>

 

=={{header|Swift}}==

 

do {

} catch {

print(error.localizedDescription)

 

{{out}}

=={{header|VBScript}}==

After building a program checking for the 3 letters in any order, I found people just checked the same trigraph at start and end. I modified my program so it puts an asterisk after the words in the "standard" answer. Run the ssript with CScript.

with createobject("ADODB.Stream")

.charset ="UTF-8"

end if

next

{{out}}

<pre>

=={{header|Wren}}==

{{libheader|Wren-fmt}}

import "/fmt" for Fmt

 

count = count + 1

Fmt.print("$d: $s", count, w)

 

{{out}}

 

=={{header|XPL0}}==

int I, Ch, Len;

char Word(100); \(longest word in unixdict.txt is 22 chars)

[Text(0, Word); CrLf(0)];

until Ch = EOF;

 

{{out}}