Teacup rim text: Difference between revisions

 

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

R s[1..]‘’s[0]

 

print()

 

 

{{out}}

=={{header|Arturo}}==

 

 

rotateable?: function [w][

root: first result

print join.with: " -> " map 1..size root 'i [ rotate.left root i]

 

{{out}}

 

=={{header|AutoHotkey}}==

oWord := [], oRes := [], n := 0

for i, w in StrSplit(wList, "`n", "`r")

rotate(w){

return SubStr(w, 2) . SubStr(w, 1, 1)

result := ""

for i, v in Teacup_rim_text(wList)

result .= v "`n"

MsgBox % result

{{out}}

<pre>apt,pta,tap

 

=={{header|AWK}}==

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

#

exit(0)

}

{{out}}

<p>using UNIXDICT.TXT</p>

 

=={{header|BaCon}}==

 

dict$ = LOAD$(DIRNAME$(ME$) & "/unixdict.txt")

 

PRINT result$

{{out}}

Using 'unixdict.txt':

=={{header|C}}==

{{libheader|GLib}}

#include <stdio.h>

#include <stdlib.h>

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.List (groupBy, intercalate, sort, sortOn)

import Data.Ord (comparing)

rotated :: [a] -> [a]

rotated [] = []

{{Out}}

<pre>arc -> rca -> car

 

=={{header|J}}==

apt

arc

 

In other words, group words by their canonical rotation (from all rotations: the earliest, alphabetically), select groups with at least three different words, where the word count matches the letter count, then extract the first word from each group.

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

`keys`; this slows it down a lot.

 

def read_teacup:

. as $in

# The task:

teacup_words

{{out}}

Invocation example: jq -nRc -f teacup-rim.jq unixdict.txt

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

 

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

TeacuppableHelper[set_List] := Module[{f, s},

f = First[set];

s = s[[All, All, 1]];

s //= Select[StringLength[First[#]] <= Length[#] &];

{{out}}

<pre>{{"apt", "pta", "tap"}, {"arc", "car", "rca"}, {"ate", "eat", "tea"}}</pre>

=={{header|Nim}}==

 

 

let words = collect(initHashSet, for word in "unixdict.txt".lines: {word})

w.rotate()

stdout.write " → ", w

 

{{out}}

=={{header|Perl}}==

{{trans|Raku}}

use warnings;

use feature 'say';

}

 

{{out}}

<pre>ARC, RCA, CAR

=={{header|Phix}}==

Filters anagram lists

<span style="color: #008080;">procedure</span> <span style="color: #000000;">filter_set</span><span style="color: #0000FF;">(</span><span style="color: #004080;">sequence</span> <span style="color: #000000;">anagrams</span><span style="color: #0000FF;">)</span>

<span style="color: #000080;font-style:italic;">-- anagrams is a (small) set of words that are all anagrams of each other

--teacup(join_path({"demo","rosetta","words.txt"}),4,true)

-- Note that allow_mono is needed to display eg {"agag","gaga"}</span>

{{out}}

<pre>

 

=={{header|PicoLisp}}==

(let W (chop W)

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

Lst )

Lst ) ) )

{{out}}

<pre>

 

=={{header|PureBasic}}==

dname:

Data.s "./Data/unixdict.txt"

bset="" : res="" : cw=0

Read.s dn

{{out}}

<pre>apt pta tap

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

 

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;

Err(error) => eprintln!("Cannot open file {}: {}", &args[1], error),

}

 

{{out}}

 

=={{header|Swift}}==

 

func loadDictionary(_ path: String) throws -> Set<String> {

} catch {

print(error)

 

{{out}}

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