Ordered words: Difference between revisions

{{trans|Python}}

 

V maxlen = max(ordered, key' w -> w.len).len

V maxorderedwords = ordered.filter(word -> word.len == :maxlen)

 

{{out}}

<pre>

abbott accent accept access accost almost bellow billow biopsy chilly choosy choppy effort floppy glossy knotty

</pre>

 

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

In the following solution the input file 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 FUNC IsOrderedWord(CHAR ARRAY word)

 

FindWords(fname,max)

{{out}}

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

=={{header|Ada}}==

 

with Ada.Text_IO, Ada.Containers.Indefinite_Vectors;

use Ada.Text_IO;

Close (File);

end Ordered_Words;

 

Output:

 

=={{header|Aime}}==

ordered(data s)

{

 

return 0;

{{out}}

<pre>abbott

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

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

 

THEN

ELSE

STRING word;

 

{{out}}

<pre>

accent

accept

access

accost

bellow

billow

biopsy

floppy

glossy

 

=={{header|APL}}==

Works in NARS2000 APL; ("Objects" menu -> New, paste this in, save. Then run in the main session manager).

 

f←file_path ⎕NTIE 0 ⍝ open file

⍝ find max of word lengths, filter only words with that length

result←ordered_words/⍨lengths=⍨⌈/lengths←≢¨ordered_words

The ordered character filter is a train which uses gradeup to say which order you would have to pick the characters, to put them in order. e.g. ⍋ 'zxy' is 2 3 1 because you'd have to pick the second character, then the third, then the first, to put them in order. If they are in order then the result is the integers 1 2 3 .. to the length of the word.

 

=={{header|AppleScript}}==

 

use sorter : script "Insertion sort" -- https://www.rosettacode.org/wiki/Sorting_algorithms/Insertion_sort#AppleScript.

use scripting additions

-- ignoring white space, punctuation and diacriticals

return longestOrderedWords(wordList)

 

{{output}}

 

=={{header|Arturo}}==

 

w = join sort split w

 

maxl: get first ret 'l

print sort map select ret 'x -> maxl = x\l

 

{{out}}

StringLower could be used. This script assumes a locally downloaded copy of the dictionary, but UrlDownloadToFile could be used.

The purpose of the GUI is simply to display a field where the user can copy the list. MsgBox could be used, or FileAppend.

MaxLen=0

Loop, Read, UnixDict.txt ; Assigns A_LoopReadLine to each line of the file

GUIClose:

ExitApp

Output:

<pre>abbott, accent, accept, access, accost, almost, bellow, billow, biopsy, chilly, choosy, choppy, effort, floppy, glossy, knotty</pre>

 

=={{header|AWK}}==

abc = "abcdefghijklmnopqrstuvwxyz"

}

for (i = 1; i <= best["count"]; i++)

print best[i]

 

You must provide <tt>unixdict.txt</tt> as input.

 

=={{header|BaCon}}==

OPTION COLLAPSE TRUE

 

 

PRINT result$

 

{{out}}

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

An optimisation is that the word isn't checked for being ordered unless it is at least as long as the current maximum.

IF dict%=0 ERROR 100, "Failed to open dictionary file"

CLOSE #dict%

PRINT list$

'''Output:'''

<pre>

Memory usage isn't very efficient - the matching list is stored one word per line - so on a standard Befunge-93 interpreter there is an upper limit of 22 matches. This is not a problem for the unix dictionary, which only requires 16, but it's theoretically possible that other data sets could run out of space.

 

>0#v _$^#::\p04:<^+>#1^#\p01:p02*g02!`\g01:<@$ _ ,#!>#:<$<^<!:g03$<_^#!`\g00:+<

 

{{out}}

knotty</pre>

 

=={{header|Bracmat}}==

= bow result longestLength word character

. 0:?bow

| !result

)

<pre> knotty

glossy

 

=={{header|Burlesque}}==

 

{{Out}}

 

=={{header|C}}==

#include <string.h>

#include <stdio.h>

 

return EXIT_SUCCESS;

Output:

<pre>abbott

knotty</pre>

Alternative version with dynamic array:

#include <string.h>

#include <stdio.h>

 

return EXIT_SUCCESS;

===Mmap===

Shorter and potentially much faster version with <code>mmap (2)</code>. No stinky <code>malloc</code> or <code>scanf</code> calls.

#include <sys/mman.h>

#include <sys/types.h>

close(fd);

return 0;

 

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

using System.Linq;

using System.Net;

return true;

}

 

Output:

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

 

#include <fstream>

#include <iostream>

}

std::copy(words.begin(), words.end(), std::ostream_iterator<std::string>(std::cout, "\n"));

Output:

<pre>

=={{header|Clojure}}==

 

(not-any? pos? (map compare coll (next coll))))

 

take-while-eqcount

(clojure.string/join ", ")

 

Output

 

=={{header|CLU}}==

last: char := '\000'

for c: char in string$chars(s) do

stream$putl(po, word)

end

{{out}}

<pre>accent

 

=={{header|COBOL}}==

PROGRAM-ID. ABC-WORDS.

IF LEN IS EQUAL TO MAXLEN, DISPLAY WORD.

DONE.

{{out}}

<pre>abbott

 

=={{header|CoffeeScript}}==

ordered_word = (word) ->

for i in [0...word.length - 1]

dict_words = file_content.toString().split '\n'

show_longest_ordered_words dict_words, dict_file_name

output

> coffee ordered_words.coffee

Longest Ordered Words (source=unixdict.txt):

glossy

knotty

 

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

(reduce (lambda (prev curr)

(when (char> prev curr) (return-from orderedp nil))

("abbott" "accent" "accept" "access" "accost" "almost" "bellow" "billow"

"biopsy" "chilly" "choosy" "choppy" "effort" "floppy" "glossy" "knotty")

 

=={{header|Cowgol}}==

of the ordered words it finds, and once to actually print the words.

 

include "strings.coh";

include "file.coh";

ForEachLine(&fcb, PrintMaxLenWord);

 

 

{{out}}

=={{header|D}}==

===Simple Procedural Version===

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

 

 

writefln("%-(%s\n%)", result);

{{out}}

<pre>abbott

===Faster Procedural Version===

Faster, same output.

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

 

 

writefln("%-(%s\n%)", result);

 

===Functional Version===

Shorter, same output.

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

 

immutable maxLen = words.map!q{a.length}.reduce!max;

writefln("%-(%s\n%)", words.filter!(w => w.length == maxLen));

 

===Fastest Memory Mapped Version===

Lower level, much faster with large input files (about as fast as the memory mapped C version). The output is the same. It works only with ASCII texts, but unlike the C entry this is portable.

{{trans|C}}

 

const(char)[] findWord(const char[] s) pure nothrow @safe @nogc {

 

txt[0 .. outStart].write;

 

=={{header|Delphi}}==

program POrderedWords;

 

end;

end.

 

Output: dictionary directly processed from the URL

 

abbott accent accept access accost almost bellow billow biopsy chilly choosy choppy effort floppy glossy knotty

 

=={{header|E}}==

{{trans|Python}}

 

 

def words := <http://www.puzzlers.org/pub/wordlists/unixdict.txt>.getText().split("\n")

def maxLen := accum 0 for word in ordered { _.max(word.size()) }

def maxOrderedWords := accum [] for word ? (word.size() <=> maxLen) in ordered { _.with(word) }

 

One-pass procedural algorithm which avoids keeping the entire data set in memory:

 

for `@word$\n` ? (word.sort() <=> word) in <http://www.puzzlers.org/pub/wordlists/unixdict.txt> {

if (best.size() == 0) {

}

}

 

Output: <code>abbott accent accept access accost almost bellow billow biopsy chilly choosy

 

=={{header|EchoLisp}}==

(define (ordered? str)

(for/and ([i (in-range 1 (string-length str))])

;; english

→ (Adelops alloquy beefily begorry billowy egilops)

 

=={{header|Elixir}}==

|> String.split

|> Enum.filter(fn word -> String.codepoints(word) |> Enum.sort |> Enum.join == word end)

|> elem(1)

|> Enum.sort

 

{{out}}

 

=={{header|Erlang}}==

-module( ordered_words ).

 

 

words() -> anagrams_deranged:words_from_url( "http://www.puzzlers.org/pub/wordlists/unixdict.txt" ).

{{out}}

<pre>

 

=={{header|Euphoria}}==

 

type ordered(sequence s)

close(fn)

 

 

Output:

 

=={{header|F Sharp|F#}}==

open System.IO

|> Seq.head |> snd

 

 

Output:

 

=={{header|Factor}}==

USING: grouping http.client io io.encodings.utf8 io.files

io.files.temp kernel math memoize sequences sequences.extras

word-list [ ordered-word? ] filter

all-longest [ print ] each ;

 

Output: <pre>( scratchpad ) USING: ordered-words-main ;

=={{header|Fantom}}==

 

class Main

{

}

}

 

Output:

=={{header|FBSL}}==

Downloads the list from puzzlers.org.

 

FUNCTION RESTfulGET(url)

RETURN TRUE

END FUNCTION

Output

<pre> abbott accent accept access accost almost bellow billow biopsy chilly choosy choppy effort floppy glossy knotty

This program uses a string stack, which means that all matching words are stored on a stack.

The longest word ends up on the top of the stack.

include lib/stmstack.4th \ include string stack library

 

; \ open file, clear the stack, read file

\ read it back and close the file

Since the longest word is on top of the stack, the only thing to be done is to pop

all words from the stack until a shorter word is encountered. Consequently, all

=={{header|Fortran}}==

 

!***************************************************************************************

module ordered_module

end program main

!****************************************************

 

'''Output'''

 

=={{header|FreeBASIC}}==

 

Function isOrdered(s As Const String) As Boolean

Print

Print "Press any key to quit"

 

{{out}}

knotty

</pre>

 

=={{header|Gambas}}==

Dim sDict As String = File.Load(User.Home &/ "unixdict.txt") 'Store the 'Dictionary'

Dim sOrdered As New String[] 'To store ordered words

Print sHold.Join(gb.NewLine) 'Display the result

 

Output:

<pre>

Go has strings and Unicode and stuff, but with the dictionary all ASCII

and lower case, strings and Unicode seem overkill. I just worked with byte slices here, only converting the final result to strings for easy output.

 

import (

fmt.Println(string(bs))

}

Output:

<pre>

=={{header|Groovy}}==

Solution:

assert isOrdered('abbey')

assert !isOrdered('cat')

def owMax = orderedWords*.size().max()

 

 

Output:

 

=={{header|Haskell}}==

-- Words are read from the standard input. We keep in memory only the current

-- set of longest, ordered words.

let ws = longestOrderedWords $ words str

mapM_ putStrLn ws

 

Output:

abbott

accent

glossy

knotty

Alternative version:

 

isSorted wws@(_ : ws) = and $ zipWith (<=) wws ws

let ow = filter isSorted ls

let maxl = foldr max 0 (map length ow)

 

=={{header|Huginn}}==

import Mathematics as math;

import Network as net;

print( "{}\n".format( text.join( algo.sorted( maxOrderedWords ), " " ) ) );

return ( 0 );

 

=={{header|Icon}} and {{header|Unicon}}==

 

procedure main(A)

}

every write(!\maxList)

 

{{libheader|Icon Programming Library}}

 

=={{header|Io}}==

words := file readLines

file close

)

 

{{output}}

<pre>abbott accent accept access accost almost bellow billow biopsy chilly choosy choppy effort floppy glossy knotty

 

=={{header|J}}==

 

Recap:

 

# select the longest ordered words (<code>(#~ (= >./)@:(#@>))oWords</code>)

# format for display (using ;:inv)

{{works with|Java|1.5+}}

This example assumes there is a local copy of the dictionary whose path is given as the first argument to the program.

import java.io.FileReader;

import java.io.IOException;

}

}

Output:

<pre>abbott

glossy

knotty</pre>

 

=={{header|JavaScript}}==

Using [http://nodejs.org/ node.js]:

 

fs.readFile('./unixdict.txt', 'ascii', function (err, data) {

var is_ordered = function(word){return word.split('').sort().join('') === word;},

};

print(longest.sort().join(', ') + '\n');

 

Output:

Alternative version (also using Node.js):

 

 

http.get({

console.log(ordered.join(', '));

});

 

=={{header|jq}}==

{{works with|jq|1.4}}

if length <= 1 then true

else .[0] <= .[1] and (.[1:] | is_sorted)

 

 

{{out}}

["abbott","accent","accept","access","accost","almost","bellow","billow","biopsy","chilly","choosy","choppy","effort","floppy","glossy","knotty"]

 

'''Built-in function''':

 

'''Main''':

filter!(issorted, lst)

filter!(x -> length(x) == maximum(length, lst), lst)

 

{{out}}

 

=={{header|K}}==

("abbott"

"accent"

"floppy"

"glossy"

 

=={{header|Kotlin}}==

 

 

}

 

=={{header|Lambdatalk}}==

{def maxOrderedWords

 

glossy

knotty

 

=={{header|Lang5}}==

"" split

"&'0123456789abcdefghijklmnopqrstuvwxyz" "" split

fh fin filtering fh close ;

 

{{out}}

<pre>[ abbott accent accept access accost almost bellow billow biopsy chilly choosy choppy effort floppy glossy knotty ]</pre>

 

=={{header|Lasso}}==

#f->dowithclose => {

#f->foreachLine => {

with w in #ordered

where #w->size == #maxleng

{{out}}

<pre>abbott accent accept access accost almost bellow billow biopsy chilly choosy choppy effort floppy glossy knotty</pre>

 

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

'Ordered wordsFrom Rosetta Code

open "unixdict.txt" for input as #1

close #1

print wordList$

 

Output:

=={{header|Lingo}}==

Code ported from Lua solution.

on printLongestOrderedWords (words)

res = []

end repeat

put res

{{Out}}

<pre>-- ["abbott", "accent", "accept", "access", "accost", "almost", "bellow", "billow", "biopsy", "chilly", "choosy", "choppy", "effort", "floppy", "glossy", "knotty"]</pre>

 

=={{header|Lua}}==

 

maxlen = 0

end

 

Output:

<pre>abbott

 

=={{header|Maple}}==

longest := 0:

words := Array():

end if;

end do;

{{Out|Output}}

<pre>"abbott"

 

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

data = Select[Import["http://www.puzzlers.org/pub/wordlists/unixdict.txt", "List"],

OrderedQ[Characters[#]] &]},

max = Max[StringLength /@ data];

Select[data, StringLength[#] == max &]]

 

However Mathematica has built in dictionaries for many languages, so here is a more general version...

 

max = Max[StringLength /@ data];

Select[data, StringLength[#] == max &]]

 

<pre>

=={{header|MATLAB}} / {{header|Octave}}==

 

listlen= 0;

fid = fopen('unixdict.txt','r');

end

fclose(fid);

 

Returns:

 

=={{header|Nanoquery}}==

 

def is_ordered(word)

end

end

 

{{out}}

 

=={{header|NetRexx}}==

options replace format comments java crossref savelog symbols binary

 

Arrays.sort(wchars)

return dword.equalsIgnoreCase(String(wchars))

;Output

<pre>

 

=={{header|Nim}}==

 

const DictFile = "unixdict.txt"

mx = word.len

words.add word

{{out}}

<pre>abbott accent accept access accost almost bellow billow biopsy chilly choosy choppy effort floppy glossy knotty</pre>

=={{header|OCaml}}==

 

try Some(input_line ic)

with End_of_file -> None

let ordered_words = List.filter is_ordered lower_words in

let longest_ordered_words = longest_words ordered_words in

 

Output:

=={{header|Oforth}}==

 

| w longest l s |

0 ->longest

s longest > ifTrue: [ s ->longest ListBuffer new ->l ]

l add(w)

 

{{out}}

{{trans|REXX}}

Adapted for ooRexx

iFID= 'UNIXDICT.TXT'

w.=''

End

Exit

{{out}}

Same as REXX'

 

=={{header|PARI/GP}}==

v=select(ordered,readstr("~/unixdict.txt"));

N=vecmax(apply(length,v));

{{out}}

<pre>%1 = ["abbott", "accent", "accept", "access", "accost", "almost", "bellow", "billow", "biopsy", "chilly", "choosy", "choppy", "effort", "floppy", "glossy", "knotty"]</pre>

 

=={{header|Perl}}==

use strict;

use warnings;

close FH;

print "@{$words[-1]}\n";

Output:

<pre>

 

=={{header|Phix}}==

{{out}}

<pre>

</pre>

 

=={{header|Phixmonti}}==

 

0 var maxlen

endwhile

f fclose

Another solution

 

0 var f

endwhile

f fclose

{{out}}

<pre>

["abbott", "accent", "accept", "access", "accost", "almost", "bellow", "billow", "biopsy", "chilly", "choosy", "choppy", "effort", "floppy", "glossy", "knotty"]

</pre>

 

=={{header|PicoLisp}}==

(mapc prinl

(maxi '((L) (length (car L)))

(by length group

(filter '((S) (apply <= S))

Output:

<pre>abbott

 

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

order: procedure options (main); /* 24/11/2011 */

declare word character (20) varying;

end in_order;

end order;

OUTPUT:

<pre>

 

=={{header|PowerShell}}==

$url = 'http://www.puzzlers.org/pub/wordlists/unixdict.txt'

 

($ordered.Words -join ", ")

Remove-Item -Path "$env:TEMP\unixdict.txt" -Force -ErrorAction SilentlyContinue

 

{{Out}}

Works with SWI-Prolog

 

 

ordered_words :-

my_compare(R, K1-_V1, K2-_V2) :-

( K1 < K2 -> R = >; K1 > K2 -> R = <; =).

Output :

<pre> ?- ordered_words.

 

=={{header|PureBasic}}==

Protected Dim letters.c(wordLength)

Protected *letAdr = @letters()

Print(#CRLF$ + #CRLF$ + "Press ENTER to exit"): Input()

CloseConsole()

Sample output:

<pre>abbott accent accept access accost almost bellow billow biopsy chilly

=={{header|Python}}==

===Python: First Solution===

 

url = 'http://www.puzzlers.org/pub/wordlists/unixdict.txt'

maxlen = len(max(ordered, key=len))

maxorderedwords = [word for word in ordered if len(word) == maxlen]

 

===Python: Alternate Solution using one explicit loop===

 

mx, url = 0, 'http://www.puzzlers.org/pub/wordlists/unixdict.txt'

words, mx = [], lenword

words.append(word)

 

'''Sample Output'''

===Python: As a fold===

{{Works with|Python|3.7}}

 

from functools import reduce

import urllib.request

 

return (

(lng, ([w] if n != lng else xs + [w])) if (

) else nxs

) if lng >= n else nxs

 

 

'''True if the word w is ordered.'''

 

 

if __name__ == '__main__':

print(

).read().decode("utf-8").split()

))

{{Out}}

<pre>abbott

=={{header|Quackery}}==

 

 

[ true swap

$ 'unixdict.txt' sharefile drop nest$

task

 

{{out}}

=={{header|R}}==

 

 

ordered = logical()

}

 

{{Out}}

<pre>abbott

=={{header|Racket}}==

 

#lang racket

(require net/url)

(loop len longs words)

(loop wlen (cons word (if (> wlen len) '() longs)) words)))))

 

Output:

 

{{works with|Rakudo|2016.07}}

 

{{out}}

 

=={{header|Red}}==

;; code to read url and save to local file:

;;data: read/binary http://www.puzzlers.org/pub/wordlists/unixdict.txt

]

]

'''Sample Output'''

<pre>["abbott" "accent" "accept" "access" "accost" "almost" "bellow" "billow" "biopsy" "chilly" "choosy" "choppy" "effort" "floppy" "glossy" "knotty"]

<br>but since the word list &nbsp; (in this case) &nbsp; is already in alphabetical order, this would-be improvement is

<br>mostly moot.

iFID= 'UNIXDICT.TXT' /*the filename of the word dictionary. */

m= 1 /*maximum length of an ordered word(s).*/

ghijk

/*──────────────────────────────────────────────────────────────────────────────────────*/

{{out|output|text=&nbsp; when using the default supplied word dictionary:}}

<pre>

 

=={{header|Ring}}==

load "stdlib.ring"

 

 

see nl + "done..." + nl

Output:

<pre>

 

done...

</pre>

 

=={{header|Ruby}}==

ordered_words = open('http://www.puzzlers.org/pub/wordlists/unixdict.txt', 'r').select do |word|

word.strip!

 

grouped = ordered_words.group_by &:size

 

'''Sample Output'''

knotty</pre>

Local version:

 

=={{header|Run BASIC}}==

j = 1

i = instr(a$,chr$(10),j)

if len(a3$) = maxL then print a3$

n = n + 1

<pre>abbott

accent

 

=={{header|Rust}}==

 

fn is_ordered(s: &str) -> bool {

println!("{}", s.to_string());

}

 

=={{header|Scala}}==

 

/**

val ww = orderedWords( wordsAll ).sortBy( -_.length )

 

{{out}}

<pre>

The following implementation uses a <tt>char>=?</tt> procedure that accepts an arbitrary number of arguments. This is allowed, but not required, by R5RS, and is provided by many Scheme implementations. It has been tested under GNU Guile 1.8.8.

 

(define sorted-words

(let ((port (open-input-file "unixdict.txt")))

(newline)))

sorted-words)

 

Output:

 

=={{header|Seed7}}==

 

const func boolean: isOrdered (in string: word) is func

end if;

write(wordList);

 

Output:

 

=={{header|Sidef}}==

var file = %f'unixdict.txt'

 

}

 

{{out}}

<pre>abbott accent accept access accost almost bellow billow biopsy chilly choosy choppy effort floppy glossy knotty</pre>

 

=={{header|Simula}}==

 

BOOLEAN PROCEDURE ISORDERED(W); TEXT W;

 

END.

{{out}}

<pre>

{{works with|GNU Smalltalk}}

 

file := FileStream open: 'unixdict.txt' mode: FileStream read.

dict := Set new.

r := (r select: [:w| (w size) = ((r at: 1) size)]) asSortedCollection.

 

 

Output:

 

=={{header|SPL}}==

max = 0

> i, 1..#.size(words,1)

result += word+#.crlf

<

{{out}}

<pre>

 

=={{header|Standard ML}}==

let

fun loop (i, c) =

o foldr longestOrdereds (0, [])

o String.tokens Char.isSpace

{{out}}

<pre>abbott accent accept access accost almost bellow billow biopsy chilly choosy choppy effort floppy glossy knotty</pre>

=={{header|Swift}}==

 

 

guard

 

maxLengthGroup.forEach { print($0) }

 

{{Out}}

 

=={{header|Tcl}}==

 

# Pick the ordered words (of maximal length) from a list

set t [http::geturl "http://www.puzzlers.org/pub/wordlists/unixdict.txt"]

puts [chooseOrderedWords [http::data $t]]

Output:

<pre>

abbott accent accept access accost almost bellow billow biopsy chilly choosy choppy effort floppy glossy knotty

</pre>

 

=={{header|TUSCRIPT}}==

$$ MODE TUSCRIPT

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

ENDLOOP

ENDCOMPILE

Output:

<pre>

 

=={{header|Ursala}}==

 

#show+

 

* <code>leql</code> is a binary predicate testing a pair of lists for less or equal length

* <code>eql</code> tests for equal length

 

=={{header|VBA}}==

Public Sub orderedwords(fname As String)

' find ordered words in dict file that have the longest word length

End If

End Function

 

Results:

=={{header|VBScript}}==

Note: The input file is in the same folder as the script.

Set infile = objFSO.OpenTextFile(objFSO.GetParentFolderName(WScript.ScriptFullName) & "\" &_

"unixdict.txt",1)

End If

Next

 

{{out}}

 

=={{header|Vedit macro language}}==

#1 = 2 // length of longest word found

Repeat (ALL) {

}

Buf_Quit(OK) // close file

 

<pre>abbott

glossy

knotty </pre>

 

=={{header|Wren}}==

{{libheader|Wren-sort}}

 

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

}

System.print("The %(longest.count) ordered words with the longest length (%(longestLen)) are:")

 

{{out}}

<pre>

The 16 ordered words with the longest length (6) are:

abbott

accent

=={{header|zkl}}==

One pass, dictionary stays on disk:

fcn isLex(word){ word.reduce(fcn(p,c){ (p<=c) and c or T(Void.Stop,False) }) }

File("dict.txt").pump(Void,fcn(w){

})

println("Num words: %d, all size %d\n".fmt(words.len(),sz));

Or, reading dictionary into memory:

lwords:=File("dict.txt").readln(*).apply("strip").filter(isLex);

max:=lwords.reduce(fcn(n,w){ w.len()>n and w.len() or n },0);

lwords=lwords.filter(fcn(w,n){ w.len()==n },max);

println("Num words: %d, all size %d\n".fmt(lwords.len(),max));

{{out}}

<pre>