I before E except after C: Difference between revisions

 

''Show your output here as well as your program.''

 

 

* [http://ucrel.lancs.ac.uk/bncfreq/ Companion website] for the book: "Word Frequencies in Written and Spoken English: based on the British National Corpus".

<br><br>

 

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

e before i in general is not plausible

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

E before I when preceded by C: True=327 False=994 : Implausible

I before E, except after C : Implausible</pre>

 

=={{header|C}}==

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

Overall the rule 'I before E except after C' is implausible

</pre>

 

=={{header|Coco}}==

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

'I before E when not preceded by C' is plausible with evidence 2.147465

'E before I when preceded by C' is not plausible with evidence 0.541667</pre>

 

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

ei is not plausible when preceeded by c, the ratio is 0.5416666666666666

So, the idea is not plausible.</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|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}}==

{{out}}

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

e before i in general (pro: 230, anti: 490) is not plausible

</pre>

 

=={{header|PicoLisp}}==

(let

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

 

(ibEeaC "1_2_all_freq.txt"

Output:

<pre>cie: 24

E before I when after C: is not plausible

Overall rule is not plausible</pre>

 

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

The plausibility of 'E before I when preceded by C' is False

The plausibility of the phrase 'I before E except after C' is False

</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}}

OVERALL IT IS IMPLAUSIBLE!

(To be plausible, one count must exceed another by 2 times)</pre>

 

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

method word($/) {

if $<with_c> + $<no_c> {

} else {

make ();

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

 

 

{{out}}

E before I when preceded by C: NOT PLAUSIBLE (327 vs. 994 ✘)

I before E except after C: NOT PLAUSIBLE</pre>

 

=={{header|REXX}}==

 

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