Teacup rim text: Difference between revisions

{{task}}

 

 

 

 

 

Display one line for each set of teacup rim words.

 

=={{header|AWK}}==

# syntax: GAWK -f TEACUP_RIM_TEXT.AWK UNIXDICT.TXT

#

exit(0)

}

{{out}}

<p>using UNIXDICT.TXT</p>

ips psi sip

10000 words, 5 circular

</pre>

 

=={{header|C}}==

{{libheader|GLib}}

#include <stdio.h>

#include <stdlib.h>

#include <glib.h>

 

int string_compare(gconstpointer p1, gconstpointer p2) {

}

 

return NULL;

}

GPtrArray* dict = g_ptr_array_new_full(1024, g_free);

GString* line = g_string_sized_new(64);

g_string_free(line, TRUE);

return dict;

}

return EXIT_FAILURE;

}

return EXIT_FAILURE;

find_teacup_words(dictionary);

g_ptr_array_free(dictionary, TRUE);

return EXIT_SUCCESS;

 

{{out}}

 

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

#include <fstream>

#include <iostream>

}

return EXIT_SUCCESS;

 

{{out}}

 

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

// Teacup rim text. Nigel Galloway: August 7th., 2019

let N=System.IO.File.ReadAllLines("dict.txt")|>Array.filter(fun n->String.length n=3 && Seq.length(Seq.distinct n)>1)|>Set.ofArray

let fG z=Set.map(fun n->System.String(Array.ofSeq (Seq.permute(fun g->(g+z)%3)n))) N

Set.intersectMany [N;fG 1;fG 2]|>Seq.distinctBy(Seq.sort>>Array.ofSeq>>System.String)|>Seq.iter(printfn "%s")

{{out}}

<pre>

 

=={{header|Factor}}==

http.client kernel math prettyprint sequences sequences.extras

sets sorting splitting ;

"\n" split [ { [ length 3 < ] [ all-equal? ] } 1|| ] reject

[ [ all-rotations ] map ] [ >hash-set ] bi

{{out}}

<pre>

 

=={{header|Go}}==

 

import (

fmt.Println()

}

 

{{out}}

===Using Data.Set===

Circular words of more than 2 characters in a local copy of a word list.

import qualified Data.Set as S

import Data.Ord (comparing)

filter

((1 <) . length)

{{Out}}

<pre>arc -> car -> rca

 

Or taking a different approach, we can avoid the use of Data.Set by obtaining the groups of anagrams (of more than two characters) in the lexicon, and filtering out a circular subset of these:

import Data.Ord (comparing)

 

main :: IO ()

main =

 

anagrams :: [String] -> [[String]]

anagrams ws =

 

circularOnly :: [String] -> [[String]]

 

isRotation :: String -> String -> Bool

 

rotated :: [a] -> [a]

rotated [] = []

{{Out}}

<pre>arc -> rca -> car

 

=={{header|J}}==

 

 

=={{header|Java}}==

{{trans|C++}}

import java.util.*;

 

return ch;

}

 

{{out}}

Reading a local dictionary with the macOS JS for Automation library:

{{Works with|JXA}}

'use strict';

 

// MAIN ---

return main();

{{Out}}

<pre>arc -> car -> rca

Reading a local dictionary with the macOS JS for Automation library:

{{Works with|JXA}}

'use strict';

 

// MAIN ---

return main();

{{Out}}

<pre>arc -> rca -> car

asp -> spa -> pas

ips -> psi -> sip</pre>

 

=={{header|Julia}}==

Using the MIT 10000 word list, and excluding words of less than three letters, to reduce output length.

rotate(s, n) = String(circshift(Vector{UInt8}(s), n))

foreach(println, getteawords("https://www.mit.edu/~ecprice/wordlist.10000"))

<pre>

["aim", "ima", "mai"]

Using https://www.mit.edu/~ecprice/wordlist.10000 as per the Julia example.

 

const wc = new CS.System.Net.WebClient();

const lines = wc.DownloadString("http://wiki.puzzlers.org/pub/wordlists/unixdict.txt");

.filter(key => collection[key].length > 1)

.forEach(key => console.log("%s", collection[key].join(", ")));

<pre>

apt, pta, tap

ate, eat, tea

</pre>

 

=={{header|Perl}}==

{{trans|Raku}}

use warnings;

use feature 'say';

}

 

{{out}}

<pre>ARC, RCA, CAR

=={{header|Phix}}==

Filters anagram lists

{{out}}

<pre>

 

=={{header|PicoLisp}}==

(let W (chop W)

(unless (or (apply = W) (not (cddr W)))

Lst )

Lst ) ) )

{{out}}

<pre>

("ips" "sip" "psi")

</pre>

 

=={{header|Python}}==

===Functional===

Composing generic functions, and considering only anagram groups.

 

from itertools import chain, groupby

# MAIN ---

if __name__ == '__main__':

{{Out}}

<pre>arc -> rca -> car

Defaults to unixdict.txt, minimum 3 characters and mono-character 'words' disallowed. Feed a file name to use a different word list, an integer to --min-chars and/or a truthy value to --mono to allow mono-chars.

 

 

unit sub MAIN ( $dict = 'unixdict.txt', :$min-chars = 3, :$mono = False );

}

 

{{out|Defaults}}

Command line: <tt>raku teacup.p6</tt>

=={{header|REXX}}==

All words that contained non─letter (Latin) characters &nbsp; (periods, decimal digits, minus signs,

 

 

All words in the dictionary are treated as caseless.

 

The dictionary wasn't assumed to be sorted in any way.

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

if iFID==''|iFID=="," then iFID= 'wordlist.10k' /*Not specified? Then use the default.*/

end /*j*/

say

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

<pre>

 

5 circular words were found.

</pre>

 

=={{header|Rust}}==

use std::collections::HashSet;

use std::fs::File;

use std::iter::FromIterator;

 

let file = File::open(filename)?;

let mut dict = BTreeSet::new();

for line in io::BufReader::new(file).lines() {

}

Ok(dict)

}

 

for word in dict {

let len = word.len();

teacup_words.clear();

let mut is_teacup_word = true;

for _ in 1..len {

chars.rotate_left(1);

is_teacup_word = false;

break;

}

}

}

print!("{}", word);

for w in &teacup_words {

print!(" {}", w);

}

 

fn main() {

if args.len() != 2 {

eprintln!("Usage: teacup dictionary");

match dict {

Ok(dict) => find_teacup_words(&dict),

}

 

{{out}}

ate tea eat

ips psi sip

</pre>

 

{{libheader|Wren-str}}

{{libheader|Wren-sort}}

 

var readWords = Fn.new { |fileName|

}

System.print()

 

{{out}}

 

=={{header|zkl}}==

// This is limited to the max items a Dictionary can hold

fcn teacut(wordFile){

}

}

{{out}}

<pre>

arc car rca

</pre>