I before E except after C: Difference between revisions

{{trans|Python}}

 

 

F plausibility_check(comment, x, y)

print(‘Checking plausibility of "I before E except after C":’)

V (cei, cie, not_c_ie, not_c_ei) = simple_stats()

 

{{out}}

(Indeed, <code>unixdict.txt</code> is 206k.)

 

fcb1: equ 5Ch ; FCB 1 (populated by file on command line)

dma: equ 80h ; Standard DMA location

cei: dw 0 ; E before I when preceded by C

xei: dw 0 ; E before I when not preceded by C

 

{{out}}

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

{{works with|ALGOL 68G|Any - tested with release 2.8.3.win32}} Uses non-standard procedure to lower available in Algol 68G.

 

# implements the plausibility test specified by the task #

show plausibility( "i before e in general", xie + cie, xei + cei );

show plausibility( "e before i in general", xei + cei, xie + cie )

{{out}}

<pre>

===Vanilla===

 

script o

property wordList : words of (read file ((path to desktop as text) & "www.rosettacode.org:unixdict.txt") as «class utf8»)

end ibeeac

 

 

{{output}}

 

===AppleScriptObjC===

 

use framework "Foundation"

use scripting additions

end ibeeac

 

 

{{output}}

 

 

===Functional===

use framework "Foundation"

use scripting additions

end tell

end if

{{Out}}

<pre>[^c]ie > [^c]ei -> 466 / 217 = 2.15 :: plausible

cei > cie -> 13 / 24 = 0.54 :: unsupported</pre>

 

=={{header|AutoHotkey}}==

WordList := RegExReplace(WordList, "i)cie", "", cieN)

WordList := RegExReplace(WordList, "i)cei", "", ceiN)

WebRequest.Send()

return, WebRequest.ResponseText

{{out}}

<pre>"I before E when not preceded by C" is plausible.

 

=={{header|AWK}}==

 

/.ei/ {nei+=cnt($3)}

print "E before I when preceded by C: is"v2" plausible";

print "Overall rule is"v" plausible";

 

Usage:

=={{header|Batch File}}==

Download first the text file, then put it on the same directory with this sample code:

::Batch File Implementation

 

 

pause

{{Out}}

<pre>Plausibility of "I before E when not preceded by C": TRUE (465 VS 213)

Each word is counted once if word has at least one occurrence of test string (word with 2 or more occurrences only counts once).

The same word may count toward different categories.

setlocal enableDelayedExpansion

for /f %%A in ('findstr /i "^ie [^c]ie" unixdict.txt ^| find /c /v ""') do set Atrue=%%A

echo I before E when not preceded by C: True=%Atrue% False=%Afalse% : !Answer%Aresult%!

echo E before I when preceded by C: True=%Btrue% False=%Bfalse% : !Answer%Bresult%!

{{Out}}

<pre>I before E when not preceded by C: True=465 False=213 : Plausible

Each word frequency is included once if word has at least one occurrence of test string (word with 2 or more occurrences only counts once).

The same word frequency may count toward different categories.

setlocal enableDelayedExpansion

set /a Atrue=Afalse=Btrue=Bfalse=0

echo I before E when not preceded by C: True=%Atrue% False=%Afalse% : !Answer%Aresult%!

echo E before I when preceded by C: True=%Btrue% False=%Bfalse% : !Answer%Bresult%!

{{Out}}

<pre>I before E when not preceded by C: True=8192 False=4826 : Implausible

 

=={{header|BASIC}}==

20 OPEN "I",1,"UNIXDICT.TXT": GOTO 60

30 LINE INPUT #1,W$

150 PRINT "E before I when preceded by C: ";

160 IF 2*CE <= XE THEN PRINT "not ";

{{out}}

<pre>CIE: 24

=={{header|BASIC256}}==

{{trans|BASIC}}

open 1, "unixdict.txt"

 

if 2 * CE <= XE then print "not ";

print "plausible."

 

=={{header|BCPL}}==

 

// Read word from selected input

writef("E before I when preceded by C: %Splausible.*N",

2*ncei > nxei -> "", "not ")

{{out}}

<pre>CIE: 24

This may in turn motivate me to provide a second J solution as a single pass FSM.

Please find the program output hidden at the top of the source as part of the build and example run.

%{

/*

return 0;

}

 

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

{{trans|Java}}

using System.Collections.Generic;

using System.IO;

}

}

{{out}}

<pre>Plausible count: 384

:* (Test used 4.4, so only a limited number of C++11 features were used.)

 

#include <fstream>

#include <string>

return 0;

}

 

{{out}}

The output here was generated with the files as of 21st June 2016.

 

(ns i-before-e.core

(:require [clojure.string :as s])

(with-open [rdr (clojure.java.io/reader "http://ucrel.lancs.ac.uk/bncfreq/lists/1_2_all_freq.txt")]

(i-before-e-except-after-c-plausible? "Word frequencies (stretch goal)" (map format-freq-line (drop 1 (line-seq rdr))))))

 

{{out}}

 

=={{header|CLU}}==

rep = record[cie, xie, cei, xei, words: int]

stream$close(fstream)

stream$puts(po, report$results(r))

{{out}}

<pre>Amount of words: 25104

Now we can do the task:

 

for word of dict.toLowerCase!.match /\S+/g

++ie-npc if /(^|[^c])ie/.test word

console.log '(1) is%s plausible.', if p1 then '' else ' not'

console.log '(2) is%s plausible.', if p2 then '' else ' not'

 

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

 

(defun test-rule (rule-name examples counter-examples)

(let ((plausible (if (> examples (* 2 counter-examples)) 'plausible 'not-plausible)))

(plausibility "Dictionary" #p"unixdict.txt" #'parse-dict)

(plausibility "Word frequencies (stretch goal)" #p"1_2_all_freq.txt" #'parse-freq)

 

{{out}}

=={{header|D}}==

The extra work has not been attempted

import std.stdio;

 

}

return cnt;

 

{{out}}

{{libheader| System.IOUtils}}

{{Trans|C sharp}}

program I_before_E_except_after_C;

 

Writeln('Rule is not plausible.');

 

 

=={{header|Draco}}==

 

/* variables to hold totals for each possibility */

if p then "" else "not " fi,

"plausible.")

{{out}}

<pre>CIE: 24

=={{header|Elixir}}==

{{trans|Ruby}}

def task(path) do

plausibility_ratio = 2

 

path = hd(System.argv)

 

{{out}}

 

=={{header|Erlang}}==

-module(cei).

-export([plaus/0,count/3]).

nomatch -> count(T,Pattern, Acc)

end.

{{output}}

<pre>

 

=={{header|Factor}}==

io.files kernel literals math prettyprint regexp sequences ;

IN: rosetta-code.i-before-e

 

"I before E when not preceded by C"

{{out}}

<pre>

=={{header|Fortran}}==

Please find the linux build instructions along with example run in the comments at the beginning of the f90 source. Thank you.

!-*- mode: compilation; default-directory: "/tmp/" -*-

!Compilation started at Sat May 18 22:19:19

end function plausibility

end program cia

 

=={{header|FreeBASIC}}==

Dim As Integer F = Freefile

Dim As String text,intext

print "So, the idea is not plausible."

 

{{out}}

<pre>The number of words in unixdict.txt 25104

 

=={{header|FutureBasic}}==

 

#plist NSAppTransportSecurity @{NSAllowsArbitraryLoads:YES}

 

end fn

 

void local fn Doit

end fn

 

fn DoIt

 

 

{{output}}

E before I when preceded by C: not plausible.

There are 13 examples and 24 counter-examples for a ratio of 0.541667.</pre>

 

=={{header|Go}}==

 

import (

}

return false

 

{{out}}

This solution does not attempt the stretch goal.

 

import Text.Regex.TDFA

import Text.Printf

rule2Plausible = numTrueRule2 > (2*numFalseRule2)

printf "Rule 2 is correct for %d\n incorrect for %d\n" numTrueRule2 numFalseRule2

 

{{out}}

same input line should all be tested.

 

 

procedure main(a)

 

if \showCounts then every write(phrase := !phrases,": ",totals[phrase])

 

{{out}} of running with <tt>--showcounts</tt> flag:

=== stretch goal ===

 

 

procedure main(a)

 

if \showCounts then every write(phrase := !phrases,": ",totals[phrase])

 

{{out}}

After downloading unixdict to /tmp:

 

 

Investigating the rules:

 

24

+/'cei' E. dict

490

+/'ei' E. dict

 

So, based on unixdict.txt, the "I before E" rule seems plausible (490 > 230 by more than a factor of 2), but the exception does not make much sense (we see almost twice as many i before e after a c as we see e before i after a c).

After downloading 1_2_all_freq to /tmp, we can read it into J, and break out the first column (as words) and the third column as numbers:

 

 

words=: >0 { allfreq

 

With these definitions, we can define a prevalence verb which will tell us how often a particular substring is appears in use:

 

(y +./@E."1 words) +/ .* freqs

 

Investigating our original proposed rules:

 

 

A generic "i before e" rule is not looking quite as good now - words that have i before e are used less than twice as much as words which use e before i.

 

 

An "except after c" variant is looking awful now - words that use the cie sequence are three times as likely as words that use the cei sequence. So, of course, if we modified our original rule with this exception it would weaken the original rule:

 

 

 

=={{header|Java}}==

Download and save wordlist to unixdict.txt.

 

import java.io.BufferedReader;

import java.io.FileReader;

}

}

 

{{out}}

 

WARNING: The problem statement is misleading as the rule only applies to syllables that rhyme with "see".

 

# scan/2 produces a stream of matches but the first match of a segment (e.g. cie)

as ratio = \($x)/\($y) ~ \($ratio * 100 |round)%" ;

 

{{out}}

Using http://www.puzzlers.org/pub/wordlists/unixdict.txt as of June 2015:

Using the problematic criterion specified in the task requirements:

-- the rule "E before I when preceded by C" is implausible

as ratio = 13/24 ~ 54%

-- the rule "I before E when not preceded by C" is plausible

 

=={{header|Julia}}==

 

open("unixdict.txt") do txtfile

print("Plausibility of \"E before I when preceded by C\":")

println(rule2 > 2 * notrule2 ? "PLAUSIBLE" : "UNPLAUSIBLE")

 

{{out}}

 

=={{header|Kotlin}}==

 

import java.net.URL

println()

printResults("British National Corpus", counts2)

 

{{out}}

 

=={{header|Lasso}}==

local(cie,cei,ie,ei) = (:0,0,0,0)

 

)

stdoutnl(`Overall the rule is ` + (#ie_plausible and #cei_plausible ? `` | `NOT-`) + `PLAUSIBLE`)

{{out}}

<pre>

 

=={{header|Lua}}==

local http = require("socket.http")

 

io.write("Overall the phrase is ")

if not (sub1 and sub2) then io.write("not ") end

{{out}}

<pre>I before E when not preceded by C: PLAUSIBLE

 

=={{header|Maple}}==

lst := StringTools:-Split(words[2],"\n"):

xie, cie, cei, xei := 0, 0, 0, 0:

printf("The first phrase is %s with supporting features %d, anti features %d\n", piecewise(p1, "plausible", "not plausible"), xie, xei);

printf("The seond phrase is %s with supporting features %d, anti features %d\n", piecewise(p2, "plausible", "not plausible"), cei, cie);

{{Out|Output}}

<pre>The first phrase is plausible with supporting features 465 and anti features 213

 

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

Import["http://wiki.puzzlers.org/pub/wordlists/unixdict.txt",

"Words"];

ToString[N[cei/cie]]]

Print["Overall the rule is " <>

 

{{out}}

The rule "I before E when not preceded by C" is PLAUSIBLE

There were 465 examples and 213 counter examples, for a ratio of 2.1831

There were 13 examples and 24 counter examples, for a ratio of 0.541667

Overall the rule is NOT PLAUSIBLE

 

 

 

cei = 0;

 

end

end

 

 

=={{header|Modula-2}}==

IMPORT SeqIO;

IMPORT Texts;

WriteString("plausible.");

WriteLn;

{{out}}

<pre>Amount of words: 50209

 

=={{header|Nim}}==

 

const

let p1 = plausibility(Rule1, nie, nei)

let p2 = plausibility(Rule2, cei, cie)

 

{{out}}

=={{header|Objeck}}==

{{trans|Seed7}}

use HTTP;

use Collection;

}

}

 

{{out}}

(To be plausible, one word count must exceed another by 2 times)

</pre>

 

=={{header|Perl}}==

use warnings;

use strict;

$result += result($support, $against);

 

 

{{out}}

===Perl: Stretch Goal===

Just replace the while loop with the following one:

my @columns = split;

next if 3 < @columns;

$count{$k} += $freq if -1 != index $word, $k;

}

{{out}}

<pre>I before E when not preceded by C: 8148 / 4826 = 1.69. NOT PLAUSIBLE

=={{header|Phix}}==

Kept dirt simple, difficult to imagine any other approach being faster than this.

<span style="color: #000080;font-style:italic;">-- demo\rosetta\IbeforeE.exw</span>

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

<span style="color: #000000;">show_plausibility</span><span style="color: #0000FF;">(</span> <span style="color: #008000;">"i before e in general"</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">xie</span> <span style="color: #0000FF;">+</span> <span style="color: #000000;">cie</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">xei</span> <span style="color: #0000FF;">+</span> <span style="color: #000000;">cei</span> <span style="color: #0000FF;">);</span>

<span style="color: #000000;">show_plausibility</span><span style="color: #0000FF;">(</span> <span style="color: #008000;">"e before i in general"</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">xei</span> <span style="color: #0000FF;">+</span> <span style="color: #000000;">cei</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">xie</span> <span style="color: #0000FF;">+</span> <span style="color: #000000;">cie</span> <span style="color: #0000FF;">)</span>

{{out}}

Although the output matches, I decided to use different metrics from ALGOL 68 for the middle two conclusions.<br>

 

=={{header|Picat}}==

Words = read_file_lines("unixdict.txt"),

IEWords = [Word : Word in Words, find(Word,"ie",_,_)],

False := [Word|False]

end

 

{{out}}

 

=={{header|PicoLisp}}==

(let

(Cie (let N 0 (in File (while (from "cie") (run Prg))))

 

(ibEeaC "1_2_all_freq.txt"

Output:

<pre>cie: 24

 

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

declare dict file;

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

if ^(ieNotC & eiC) then put list('not');

put list('plausible.');

{{out}}

<pre>CIE: 24

 

=={{header|PowerShell}}==

$Words = $web.DownloadString('http://wiki.puzzlers.org/pub/wordlists/unixdict.txt')

if ($Clause1 -and $Clause2)

{$MainClause = $True}

{{out}}

<pre>

 

==={{header|Alternative Implementation}}===

$Words = $web.DownloadString('http://wiki.puzzlers.org/pub/wordlists/unixdict.txt')

if ($Clause1 -and $Clause2)

{$MainClause = $True}

{{out}}

<pre>

==={{header|Alternative Implementation 2}}===

A single pass through the wordlist using the regex engine.

 

$cie, $cei, $_ie, $_ei = 0, 0, 0, 0

"I before E when not preceded by C is plausible: $($_ie -gt $_ei)"

"E before I when preceded by C is plausible: $($cei -gt $cie)"

{{out}}

<pre>

 

=={{header|PureBasic}}==

While Not Eof(1)

wl$+ReadString(1)+";"

Print("Overall the rule is : ")

If cei>cie And ie>ei : PrintN("PLAUSIBLE") : Else : PrintN("NOT PLAUSIBLE") : EndIf

{{out}}

<pre>

 

=={{header|Python}}==

import re

 

 

print('Checking plausibility of "I before E except after C":')

 

{{out}}

===Python: Stretch Goal===

Add the following to the bottom of the previous program:

freq = [line.strip().lower().split()

for line in urllib.request.urlopen(url)

print('\n\nChecking plausibility of "I before E except after C"')

print('And taking account of word frequencies in British English:')

 

{{out|Produces this extra output}}

=={{header|QBasic}}==

{{trans|BASIC}}

DIM W AS STRING

CLS

PRINT "E before I when preceded by C: ";

IF 2 * CE <= XE THEN PRINT "not ";

 

=={{header|R}}==

ie.npc = sum(grepl("(?<!c)ie", words, perl = T))

ei.npc = sum(grepl("(?<!c)ei", words, perl = T))

message("(1) is ", (if (p1) "" else "not "), "plausible.")

message("(2) is ", (if (p2) "" else "not "), "plausible.")

 

{{out}}

 

=={{header|Racket}}==

 

(define (get-tallies filename line-parser . patterns)

 

(plausibility "Dictionary" "unixdict.txt" (λ (line) (list line 1))) (newline)

 

{{out}}

(formerly Perl 6)

This solution uses grammars and actions to parse the given file, the <tt>Bag</tt> for tallying up occurrences of each possible thing we're looking for ("ie", "ei", "cie", and "cei"), and junctions to determine the plausibility of a phrase from the subphrases. Note that a version of rakudo newer than the January 2014 compiler or Star releases is needed, as this code relies on a recent bugfix to the <tt>make</tt> function.

token TOP {

[^^ <word> $$ \n?]+

plausible($results<cei>, $results<cie>, "E before I when preceded by C");

 

 

{{out}}

 

This solution requires just a few modifications to the grammar and actions from the non-stretch goal.

token TOP {

^^ \t Word \t PoS \t Freq $$ \n

plausible($results<cei>, $results<cie>, "E before I when preceded by C");

 

 

{{out}}

The script processes both the task and the stretch goal.

In the stretch goal, "rows with three space or tab separated words only" (7574 out of 7726) are processed, excluding all expressions like "out of".

 

testlist: function [wordlist /wfreq] [

keep seq/1 keep to-integer seq/3

]]]

 

{{out}}

 

===unweighted version===

/*───────────────────────────────────── "E before I" when preceded by C. */

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

else #.x.z=#.x.z + 1

s=_ + 1 /*handle the cases of multiple finds. */

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

<pre>

 

A cursory look at the file seems to indicate that the use of the tilde and/or asterisk doesn't affect the rules for the mantra phrases.

/*───────────────────────────────────── "E before I" when preceded by C, using a */

/*───────────────────────────────────── weighted frequency for each word. */

if substr(u, _ - 1 + (_==1)*999, 1)=='C' then #.x.c=#.x.c + one

else #.x.z=#.x.z + one

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

<pre>

 

=={{header|Ring}}==

# Project : I before E except after C

 

end

return sum

Output:

<pre>

 

=={{header|Ruby}}==

 

plausibility_ratio = 2

 

puts "Overall: #{overall_plausible ? 'Plausible' : 'Implausible'}."

{{out}}

<pre>

 

=={{header|Rust}}==

use std::ops::AddAssign;

 

);

}

<pre>

Counting Feature {

 

=={{header|Scala}}==

val testIE1 = "(^|[^c])ie".r // i before e when not preceded by c

val testIE2 = "cie".r // i before e when preceded by c

println("E before I when preceded by C: "+plausibility(countsCEI))

println("Overall: "+plausibility(plausible(countsIE) && plausible(countsCEI)))

{{out}}

<pre>I before E when not preceded by C: plausible

 

=={{header|Seed7}}==

include "gethttp.s7i";

include "float.s7i";

writeln("(To be plausible, one word count must exceed another by " <& PLAUSIBILITY_RATIO <& " times)");

end if;

 

{{out}}

(To be plausible, one word count must exceed another by 2 times)

</pre>

 

=={{header|Swift}}==

Using [https://github.com/johnno1962/SwiftRegex/blob/master/SwiftRegex.swift SwiftRegex] for easy regex in strings.

 

let request = NSURLRequest(URL: NSURL(string: "http://wiki.puzzlers.org/pub/wordlists/unixdict.txt")!)

}

 

{{out}}

<pre>

E before I when preceded by C is not plausable

I before E except after C is not plausible</pre>

 

=={{header|True BASIC}}==

{{trans|BASIC}}

IF END #f THEN LET EOF = -1 ELSE LET EOF = 0

END DEF

IF 2*ce <= xe THEN PRINT "not ";

PRINT "plausible."

 

=={{header|Tcl}}==

{{trans|Python}}<!-- very approximately, mainly for the messages -->

 

variable PLAUSIBILITY_RATIO 2.0

}

puts "\n(To be plausible, one word count must exceed another by\

{{out}}

<!-- note that checking the pronunciation of the words indicates a key guard on the real rule that isn't normally stated -->

 

=={{header|TUSCRIPT}}==

$$ MODE TUSCRIPT,{}

words=REQUEST("http://wiki.puzzlers.org/pub/wordlists/unixdict.txt")

 

TRAcE *check1,check2,checkall

Output:

<pre>

checkall = not plausible

</pre>

 

=={{header|UNIX Shell}}==

 

matched() {

echo "Overall, the rule is not plausible"

fi

{{out}}

<pre>

=={{header|VBScript}}==

The sample text was downloaded and saved in the same folder as the script.

Set objFSO = CreateObject("Scripting.FileSystemObject")

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

srcFile.Close

Set objFSO = Nothing

 

{{Out}}

Regex implementation does not technically conform to specification because it counts the number of occurrences of "ie" and "ei" instead of the number of words.

 

Option Explicit On

Option Infer On

End Sub

End Module

 

{{out|case=Loop implementation}}

 

Rule thus overall IS NOT plausible.</pre>

 

=={{header|Wren}}==

 

Also there are seven words which fall into two categories and which have therefore been double-counted.

 

var yesNo = Fn.new { |b| (b) ? "yes" : "no" }

Fmt.print(" Plausible : $s", yesNo.call(plaus2))

 

 

{{out}}

And the code and results for the 'stretch goal' which has just the one double-counted word:

 

 

var yesNo = Fn.new { |b| (b) ? "yes" : "no" }

Fmt.print(" Plausible : $s", yesNo.call(plaus2))

 

 

{{out}}

Plausible overall: no

</pre>

 

=={{header|Yabasic}}==

{{trans|BASIC}}

 

repeat

if 2 * CE <= XE then print "not "; : fi

print "plausible."

 

 

=={{header|zkl}}==

a:=wordList.reduce('wrap(cnt,word){ cnt+word.holds(altrs) },0) - aAdjust;

b:=wordList.reduce('wrap(cnt,word){ cnt+word.holds(bltrs) },0) - bAdjust;

return(a,b,ratio);

}

_,_,r2:=wcnt(wordList,"ie",b,"ei",a, "I before E when not preceded by C");

{{out}}

<pre>

</pre>

Stretch

a,b:=wordList.reduce('wrap(cnts,line){

// don't care if line is "Word PoS Freq" or "as yet Adv 14"

return(a,b,ratio);

}

{{out}}

<pre>