Initial data commit
This commit is contained in:
Ingy döt Net
parent
72d218235f
commit
f23f22d71c
199087 changed files with 3378941 additions and 0 deletions
6
Task/Determine-sentence-type/00-META.yaml
Normal file
6
Task/Determine-sentence-type/00-META.yaml
Normal file
|
|
@ -0,0 +1,6 @@
|
|||
---
|
||||
category:
|
||||
- Recursion
|
||||
- String manipulation
|
||||
from: http://rosettacode.org/wiki/Determine_sentence_type
|
||||
note: Text processing
|
||||
18
Task/Determine-sentence-type/00-TASK.txt
Normal file
18
Task/Determine-sentence-type/00-TASK.txt
Normal file
|
|
@ -0,0 +1,18 @@
|
|||
Use these sentences:
|
||||
"hi there, how are you today? I'd like to present to you the washing machine 9001. You have been nominated to win one of these! Just make sure you don't break it."
|
||||
|
||||
;Task
|
||||
: Search for the last used punctuation in a sentence, and determine its type according to its punctuation.
|
||||
|
||||
; Output one of these letters: "E" (Exclamation!), "Q" (Question?), "S" (Serious.), "N" (Neutral).
|
||||
|
||||
;Extra
|
||||
: Make your code able to determine multiple sentences.
|
||||
|
||||
|
||||
Don't leave any errors!
|
||||
|
||||
|
||||
{{Template:Strings}}
|
||||
<br><br>
|
||||
|
||||
20
Task/Determine-sentence-type/11l/determine-sentence-type.11l
Normal file
20
Task/Determine-sentence-type/11l/determine-sentence-type.11l
Normal file
|
|
@ -0,0 +1,20 @@
|
|||
F sentenceType(s)
|
||||
I s.empty
|
||||
R ‘’
|
||||
|
||||
[Char] types
|
||||
L(c) s
|
||||
I c == ‘?’
|
||||
types.append(Char(‘Q’))
|
||||
E I c == ‘!’
|
||||
types.append(Char(‘E’))
|
||||
E I c == ‘.’
|
||||
types.append(Char(‘S’))
|
||||
|
||||
I s.last !C ‘?!.’
|
||||
types.append(Char(‘N’))
|
||||
|
||||
R types.join(‘|’)
|
||||
|
||||
V s = ‘hi there, how are you today? I'd like to present to you the washing machine 9001. You have been nominated to win one of these! Just make sure you don't break it’
|
||||
print(sentenceType(s))
|
||||
|
|
@ -0,0 +1,38 @@
|
|||
BEGIN # determuine the type of a sentence by looking at the final punctuation #
|
||||
CHAR exclamation = "E"; # classification codes... #
|
||||
CHAR question = "Q";
|
||||
CHAR serious = "S";
|
||||
CHAR neutral = "N";
|
||||
# returns the type(s) of the sentence(s) in s - exclamation, question, #
|
||||
# serious or neutral; if there are multiple sentences #
|
||||
# the types are separated by | #
|
||||
PROC classify = ( STRING s )STRING:
|
||||
BEGIN
|
||||
STRING result := "";
|
||||
BOOL pending neutral := FALSE;
|
||||
FOR s pos FROM LWB s TO UPB s DO
|
||||
IF pending neutral := FALSE;
|
||||
CHAR c = s[ s pos ];
|
||||
c = "?"
|
||||
THEN result +:= question + "|"
|
||||
ELIF c = "!"
|
||||
THEN result +:= exclamation + "|"
|
||||
ELIF c = "."
|
||||
THEN result +:= serious + "|"
|
||||
ELSE pending neutral := TRUE
|
||||
FI
|
||||
OD;
|
||||
IF pending neutral
|
||||
THEN result +:= neutral + "|"
|
||||
FI;
|
||||
# if s was empty, then return an empty string, otherwise remove the final separator #
|
||||
IF result = "" THEN "" ELSE result[ LWB result : UPB result - 1 ] FI
|
||||
END # classify # ;
|
||||
# task test case #
|
||||
print( ( classify( "hi there, how are you today? I'd like to present to you the washing machine 9001. "
|
||||
+ "You have been nominated to win one of these! Just make sure you don't break it"
|
||||
)
|
||||
, newline
|
||||
)
|
||||
)
|
||||
END
|
||||
30
Task/Determine-sentence-type/AWK/determine-sentence-type.awk
Normal file
30
Task/Determine-sentence-type/AWK/determine-sentence-type.awk
Normal file
|
|
@ -0,0 +1,30 @@
|
|||
# syntax: GAWK -f DETERMINE_SENTENCE_TYPE.AWK
|
||||
BEGIN {
|
||||
str = "hi there, how are you today? I'd like to present to you the washing machine 9001. You have been nominated to win one of these! Just make sure you don't break it"
|
||||
main(str)
|
||||
main("Exclamation! Question? Serious. Neutral")
|
||||
exit(0)
|
||||
}
|
||||
function main(str, c) {
|
||||
while (length(str) > 0) {
|
||||
c = substr(str,1,1)
|
||||
sentence = sentence c
|
||||
if (c == "!") {
|
||||
prn("E")
|
||||
}
|
||||
else if (c == ".") {
|
||||
prn("S")
|
||||
}
|
||||
else if (c == "?") {
|
||||
prn("Q")
|
||||
}
|
||||
str = substr(str,2)
|
||||
}
|
||||
prn("N")
|
||||
print("")
|
||||
}
|
||||
function prn(type) {
|
||||
gsub(/^ +/,"",sentence)
|
||||
printf("%s %s\n",type,sentence)
|
||||
sentence = ""
|
||||
}
|
||||
|
|
@ -0,0 +1,16 @@
|
|||
Sentence := "hi there, how are you today? I'd like to present to you the washing machine 9001. You have been nominated to win one of these! Just make sure you don't break it"
|
||||
Msgbox, % SentenceType(Sentence)
|
||||
|
||||
SentenceType(Sentence) {
|
||||
Sentence := Trim(Sentence)
|
||||
Loop, Parse, Sentence, .?!
|
||||
{
|
||||
N := (!E && !Q && !S)
|
||||
, S := (InStr(SubStr(Sentence, InStr(Sentence, A_LoopField)+StrLen(A_LoopField), 3), "."))
|
||||
, Q := (InStr(SubStr(Sentence, InStr(Sentence, A_LoopField)+StrLen(A_LoopField), 3), "?"))
|
||||
, E := (InStr(SubStr(Sentence, InStr(Sentence, A_LoopField)+StrLen(A_LoopField), 3), "!"))
|
||||
, type .= (E) ? ("E|") : ((Q) ? ("Q|") : ((S) ? ("S|") : "N|"))
|
||||
, D := SubStr(Sentence, InStr(Sentence, A_LoopField)+StrLen(A_LoopField), 3)
|
||||
}
|
||||
return (D = SubStr(Sentence, 1, 3)) ? RTrim(RTrim(type, "|"), "N|") : RTrim(type, "|")
|
||||
}
|
||||
53
Task/Determine-sentence-type/CLU/determine-sentence-type.clu
Normal file
53
Task/Determine-sentence-type/CLU/determine-sentence-type.clu
Normal file
|
|
@ -0,0 +1,53 @@
|
|||
% This iterator takes a string and yields one of 'E', 'Q',
|
||||
% 'S' or 'N' for every sentence found.
|
||||
% Because sentences are separated by punctuation, only the
|
||||
% last one can be 'N'.
|
||||
|
||||
sentence_types = iter (s: string) yields (char)
|
||||
own punct: string := "!?." % relevant character classes
|
||||
own space: string := " \t\n"
|
||||
own types: string := "EQS" % sentence type characters
|
||||
|
||||
prev_punct: bool := false % whether the previous character was punctuation
|
||||
last_punct: int := 0 % index of last punctuation character encountered
|
||||
sentence: bool := true % whether there are words since the last punctuation
|
||||
|
||||
for c: char in string$chars(s) do
|
||||
pu: int := string$indexc(c, punct)
|
||||
sp: int := string$indexc(c, space)
|
||||
if pu ~= 0 then
|
||||
prev_punct := true
|
||||
last_punct := pu
|
||||
elseif sp ~= 0 then
|
||||
if prev_punct then
|
||||
% a space after punctuation means a sentence has ended here
|
||||
yield(types[last_punct])
|
||||
sentence := false
|
||||
end
|
||||
prev_punct := false
|
||||
sentence := false
|
||||
else
|
||||
sentence := true
|
||||
end
|
||||
end
|
||||
|
||||
% handle the last sentence
|
||||
if prev_punct then yield(types[last_punct])
|
||||
elseif sentence then yield('N')
|
||||
end
|
||||
end sentence_types
|
||||
|
||||
% Test
|
||||
start_up = proc ()
|
||||
po: stream := stream$primary_output()
|
||||
test: string :=
|
||||
"hi there, how are you today? I'd like to " ||
|
||||
"present to you the washing machine 9001. You " ||
|
||||
"have been nominated to win one of these! Just " ||
|
||||
"make sure you don't break it"
|
||||
|
||||
% print the type of each sentence
|
||||
for c: char in sentence_types(test) do
|
||||
stream$putc(po, c)
|
||||
end
|
||||
end start_up
|
||||
|
|
@ -0,0 +1,34 @@
|
|||
const TestStrings = 'hi there, how are you today? I''''d like to present to you the washing machine 9001. You have been nominated to win one of these! Just make sure you don''''t break it';
|
||||
|
||||
procedure AnalyzeSentenceType(Memo: TMemo; S: string);
|
||||
{Extract sentences from string and analyze terminating punctuation}
|
||||
var I: integer;
|
||||
var Sent,SType: string;
|
||||
begin
|
||||
Sent:='';
|
||||
for I:=1 to Length(S) do
|
||||
begin
|
||||
Sent:=Sent+S[I];
|
||||
{Look terminating char or condition}
|
||||
if (S[I] in ['?','!','.']) or (I>=Length(S)) then
|
||||
begin
|
||||
{If found, determine sentence type}
|
||||
case Sent[Length(Sent)] of
|
||||
'?': SType:=' (Q)';
|
||||
'!': SType:=' (E)';
|
||||
'.': SType:=' (S)';
|
||||
else SType:=' (N)';
|
||||
end;
|
||||
{Display it}
|
||||
Memo.Lines.Add(Trim(Sent)+SType);
|
||||
Sent:='';
|
||||
end;
|
||||
end;
|
||||
end;
|
||||
|
||||
|
||||
procedure TestSentenceTypes(Memo: TMemo);
|
||||
{Analyze some test sentences}
|
||||
begin
|
||||
AnalyzeSentenceType(Memo, TestStrings);
|
||||
end;
|
||||
|
|
@ -0,0 +1,25 @@
|
|||
const SentenceTypes: {
|
||||
["?"]:"Q",
|
||||
["."]:"S",
|
||||
["!"]:"E"
|
||||
}
|
||||
|
||||
fn DetermineSentenceType(Char)
|
||||
return SentenceTypes[Char]||"N"
|
||||
cls
|
||||
|
||||
fn GetSentences(Text)
|
||||
var Sentences: [],
|
||||
Index: 0,
|
||||
Length: #Text
|
||||
loop i:0;i<Length;i+:1 do
|
||||
var Char: string.subs(Text,i,1)
|
||||
var Type: DetermineSentenceType(Char)
|
||||
if Type != "N" || i==Length-1 then
|
||||
log(string.sub(Text,Index,i+1)+" ("+Type+")")
|
||||
Index:i+2;
|
||||
cls
|
||||
cls
|
||||
cls
|
||||
|
||||
GetSentences("hi there, how are you today? I'd like to present to you the washing machine 9001. You have been nominated to win one of these! Just make sure you don't break it")
|
||||
|
|
@ -0,0 +1,58 @@
|
|||
USING: combinators io kernel regexp sequences sets splitting
|
||||
wrap.strings ;
|
||||
|
||||
! courtesy of https://www.infoplease.com/common-abbreviations
|
||||
|
||||
CONSTANT: common-abbreviations {
|
||||
"A.B." "abbr." "Acad." "A.D." "alt." "A.M." "Assn."
|
||||
"at. no." "at. wt." "Aug." "Ave." "b." "B.A." "B.C." "b.p."
|
||||
"B.S." "c." "Capt." "cent." "co." "Col." "Comdr." "Corp."
|
||||
"Cpl." "d." "D.C." "Dec." "dept." "dist." "div." "Dr." "ed."
|
||||
"est." "et al." "Feb." "fl." "gal." "Gen." "Gov." "grad."
|
||||
"Hon." "i.e." "in." "inc." "Inst." "Jan." "Jr." "lat."
|
||||
"Lib." "long." "Lt." "Ltd." "M.D." "Mr." "Mrs." "mt." "mts."
|
||||
"Mus." "no." "Nov." "Oct." "Op." "pl." "pop." "pseud." "pt."
|
||||
"pub." "Rev." "rev." "R.N." "Sept." "Ser." "Sgt." "Sr."
|
||||
"St." "uninc." "Univ." "U.S." "vol." "vs." "wt."
|
||||
}
|
||||
|
||||
: sentence-enders ( str -- newstr )
|
||||
R/ \)/ "" re-replace
|
||||
" " split harvest
|
||||
unclip-last swap
|
||||
[ common-abbreviations member? ] reject
|
||||
[ last ".!?" member? ] filter
|
||||
swap suffix ;
|
||||
|
||||
: serious? ( str -- ? ) last CHAR: . = ;
|
||||
: neutral? ( str -- ? ) last ".!?" member? not ;
|
||||
: mixed? ( str -- ? ) "?!" intersect length 2 = ;
|
||||
: exclamation? ( str -- ? ) last CHAR: ! = ;
|
||||
: question? ( str -- ? ) last CHAR: ? = ;
|
||||
|
||||
: type ( str -- newstr )
|
||||
{
|
||||
{ [ dup serious? ] [ drop "S" ] }
|
||||
{ [ dup neutral? ] [ drop "N" ] }
|
||||
{ [ dup mixed? ] [ drop "EQ" ] }
|
||||
{ [ dup exclamation? ] [ drop "E" ] }
|
||||
{ [ dup question? ] [ drop "Q" ] }
|
||||
[ drop "UNKNOWN" ]
|
||||
} cond ;
|
||||
|
||||
: sentences ( str -- newstr )
|
||||
sentence-enders [ type ] map "|" join ;
|
||||
|
||||
: show ( str -- )
|
||||
dup sentences " -> " glue 60 wrap-string print ;
|
||||
|
||||
"Hi there, how are you today? I'd like to present to you the washing machine 9001. You have been nominated to win one of these! Just make sure you don't break it" show
|
||||
nl
|
||||
"(There was nary a mouse stirring.) But the cats were going
|
||||
bonkers!" show
|
||||
nl
|
||||
"\"Why is the car so slow?\" she said." show
|
||||
nl
|
||||
"Hello, Mr. Anderson!" show
|
||||
nl
|
||||
"Are you sure?!?! How can you know?" show
|
||||
|
|
@ -0,0 +1,30 @@
|
|||
function sentype( byref s as string ) as string
|
||||
'determines the sentence type of the first sentence in the string
|
||||
'returns "E" for an exclamation, "Q" for a question, "S" for serious
|
||||
'and "N" for neutral.
|
||||
'modifies the string to remove the first sentence
|
||||
for i as uinteger = 1 to len(s)
|
||||
if mid(s, i, 1) = "!" then
|
||||
s=right(s,len(s)-i)
|
||||
return "E"
|
||||
end if
|
||||
if mid(s, i, 1) = "." then
|
||||
s=right(s,len(s)-i)
|
||||
return "S"
|
||||
end if
|
||||
if mid(s, i, 1) = "?" then
|
||||
s=right(s,len(s)-i)
|
||||
return "Q"
|
||||
end if
|
||||
next i
|
||||
'if we get to the end without encountering punctuation, this
|
||||
'must be a neutral sentence, which can only happen as the last one
|
||||
s=""
|
||||
return "N"
|
||||
end function
|
||||
|
||||
dim as string spam = "hi there, how are you today? I'd like to present to you the washing machine 9001. You have been nominated to win one of these! Just make sure you don't break it"
|
||||
|
||||
while len(spam)>0
|
||||
print sentype(spam)
|
||||
wend
|
||||
31
Task/Determine-sentence-type/Go/determine-sentence-type.go
Normal file
31
Task/Determine-sentence-type/Go/determine-sentence-type.go
Normal file
|
|
@ -0,0 +1,31 @@
|
|||
package main
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"strings"
|
||||
)
|
||||
|
||||
func sentenceType(s string) string {
|
||||
if len(s) == 0 {
|
||||
return ""
|
||||
}
|
||||
var types []string
|
||||
for _, c := range s {
|
||||
if c == '?' {
|
||||
types = append(types, "Q")
|
||||
} else if c == '!' {
|
||||
types = append(types, "E")
|
||||
} else if c == '.' {
|
||||
types = append(types, "S")
|
||||
}
|
||||
}
|
||||
if strings.IndexByte("?!.", s[len(s)-1]) == -1 {
|
||||
types = append(types, "N")
|
||||
}
|
||||
return strings.Join(types, "|")
|
||||
}
|
||||
|
||||
func main() {
|
||||
s := "hi there, how are you today? I'd like to present to you the washing machine 9001. You have been nominated to win one of these! Just make sure you don't break it"
|
||||
fmt.Println(sentenceType(s))
|
||||
}
|
||||
21
Task/Determine-sentence-type/Jq/determine-sentence-type.jq
Normal file
21
Task/Determine-sentence-type/Jq/determine-sentence-type.jq
Normal file
|
|
@ -0,0 +1,21 @@
|
|||
# Input: a string
|
||||
# Output: a stream of sentence type indicators
|
||||
def sentenceTypes:
|
||||
def trim: sub("^ +";"") | sub(" +$";"");
|
||||
def parse:
|
||||
capture("(?<s>[^?!.]*)(?<p>[?!.])(?<remainder>.*)" )
|
||||
// {p:"", remainder:""};
|
||||
def encode:
|
||||
if . == "?" then "Q"
|
||||
elif . == "!" then "E"
|
||||
elif . == "." then "S"
|
||||
else "N"
|
||||
end;
|
||||
trim
|
||||
| select(length>0)
|
||||
| parse
|
||||
| (.p | encode), (.remainder | sentenceTypes);
|
||||
|
||||
def s: "hi there, how are you today? I'd like to present to you the washing machine 9001. You have been nominated to win one of these! Just make sure you don't break it";
|
||||
|
||||
s | sentenceTypes
|
||||
|
|
@ -0,0 +1,12 @@
|
|||
const text = """
|
||||
Hi there, how are you today? I'd like to present to you the washing machine 9001.
|
||||
You have been nominated to win one of these! Just make sure you don't break it"""
|
||||
|
||||
haspunctotype(s) = '.' in s ? "S" : '!' in s ? "E" : '?' in s ? "Q" : "N"
|
||||
|
||||
text = replace(text, "\n" => " ")
|
||||
parsed = strip.(split(text, r"(?:(?:(?<=[\?\!\.])(?:))|(?:(?:)(?=[\?\!\.])))"))
|
||||
isodd(length(parsed)) && push!(parsed, "") # if ends without pnctuation
|
||||
for i in 1:2:length(parsed)-1
|
||||
println(rpad(parsed[i] * parsed[i + 1], 52), " ==> ", haspunctotype(parsed[i + 1]))
|
||||
end
|
||||
|
|
@ -0,0 +1,5 @@
|
|||
text = "hi there, how are you today? I'd like to present to you the washing machine 9001. You have been nominated to win one of these! Just make sure you don't break it"
|
||||
p2t = { [""]="N", ["."]="S", ["!"]="E", ["?"]="Q" }
|
||||
for s, p in text:gmatch("%s*([^%!%?%.]+)([%!%?%.]?)") do
|
||||
print(s..p..": "..p2t[p])
|
||||
end
|
||||
31
Task/Determine-sentence-type/Nim/determine-sentence-type.nim
Normal file
31
Task/Determine-sentence-type/Nim/determine-sentence-type.nim
Normal file
|
|
@ -0,0 +1,31 @@
|
|||
type SentenceType {.pure.} = enum Q, E, S, N
|
||||
|
||||
func sentenceType(s: string): SentenceType =
|
||||
## Return the type of a sentence.
|
||||
if s.len == 0: return
|
||||
result = case s[^1]
|
||||
of '?': Q
|
||||
of '!': E
|
||||
of '.': S
|
||||
else: N
|
||||
|
||||
iterator sentences(text: string): string =
|
||||
## Cut a text into sentences.
|
||||
var sentence = ""
|
||||
for ch in text:
|
||||
if ch == ' ' and sentence.len == 0: continue
|
||||
sentence.add ch
|
||||
if ch in "?!.":
|
||||
yield sentence
|
||||
sentence.reset()
|
||||
if sentence.len > 0:
|
||||
yield sentence
|
||||
|
||||
|
||||
const Text = "hi there, how are you today? " &
|
||||
"I'd like to present to you the washing machine 9001. " &
|
||||
"You have been nominated to win one of these!" &
|
||||
"Just make sure you don't break it"
|
||||
|
||||
for sentence in Text.sentences():
|
||||
echo sentence, " → ", sentenceType(sentence)
|
||||
27
Task/Determine-sentence-type/Perl/determine-sentence-type.pl
Normal file
27
Task/Determine-sentence-type/Perl/determine-sentence-type.pl
Normal file
|
|
@ -0,0 +1,27 @@
|
|||
use strict;
|
||||
use warnings;
|
||||
use feature 'say';
|
||||
use Lingua::Sentence;
|
||||
|
||||
my $para1 = <<'EOP';
|
||||
hi there, how are you today? I'd like to present to you the washing machine
|
||||
9001. You have been nominated to win one of these! Just make sure you don't
|
||||
break it
|
||||
EOP
|
||||
|
||||
my $para2 = <<'EOP';
|
||||
Just because there are punctuation characters like "?", "!" or especially "."
|
||||
present, it doesn't necessarily mean you have reached the end of a sentence,
|
||||
does it Mr. Magoo? The syntax highlighting here for Perl isn't bad at all.
|
||||
EOP
|
||||
|
||||
my $splitter = Lingua::Sentence->new("en");
|
||||
for my $text ($para1, $para2) {
|
||||
for my $s (split /\n/, $splitter->split( $text =~ s/\n//gr ) {
|
||||
print "$s| ";
|
||||
if ($s =~ /!$/) { say 'E' }
|
||||
elsif ($s =~ /\?$/) { say 'Q' }
|
||||
elsif ($s =~ /\.$/) { say 'S' }
|
||||
else { say 'N' }
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,11 @@
|
|||
(phixonline)-->
|
||||
<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>
|
||||
<span style="color: #008080;">constant</span> <span style="color: #000000;">s</span> <span style="color: #0000FF;">=</span> <span style="color: #008000;">`hi there, how are you today? I'd like to present
|
||||
to you the washing machine 9001. You have been nominated to win
|
||||
one of these! Just make sure you don't break it`</span>
|
||||
<span style="color: #004080;">sequence</span> <span style="color: #000000;">t</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">split_any</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">trim</span><span style="color: #0000FF;">(</span><span style="color: #000000;">s</span><span style="color: #0000FF;">),</span><span style="color: #008000;">"?!."</span><span style="color: #0000FF;">),</span>
|
||||
<span style="color: #000000;">u</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">substitute_all</span><span style="color: #0000FF;">(</span><span style="color: #000000;">s</span><span style="color: #0000FF;">,</span><span style="color: #000000;">t</span><span style="color: #0000FF;">,</span><span style="color: #7060A8;">repeat</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"|"</span><span style="color: #0000FF;">,</span><span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">t</span><span style="color: #0000FF;">))),</span>
|
||||
<span style="color: #000000;">v</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">substitute_all</span><span style="color: #0000FF;">(</span><span style="color: #000000;">u</span><span style="color: #0000FF;">,{</span><span style="color: #008000;">"|?"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"|!"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"|."</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"|"</span><span style="color: #0000FF;">},</span><span style="color: #008000;">"QESN"</span><span style="color: #0000FF;">),</span>
|
||||
<span style="color: #000000;">w</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">join</span><span style="color: #0000FF;">(</span><span style="color: #000000;">v</span><span style="color: #0000FF;">,</span><span style="color: #008000;">'|'</span><span style="color: #0000FF;">)</span>
|
||||
<span style="color: #0000FF;">?</span><span style="color: #000000;">w</span>
|
||||
<!--
|
||||
|
|
@ -0,0 +1,15 @@
|
|||
import re
|
||||
|
||||
txt = """
|
||||
Hi there, how are you today? I'd like to present to you the washing machine 9001.
|
||||
You have been nominated to win one of these! Just make sure you don't break it"""
|
||||
|
||||
def haspunctotype(s):
|
||||
return 'S' if '.' in s else 'E' if '!' in s else 'Q' if '?' in s else 'N'
|
||||
|
||||
txt = re.sub('\n', '', txt)
|
||||
pars = [s.strip() for s in re.split("(?:(?:(?<=[\?\!\.])(?:))|(?:(?:)(?=[\?\!\.])))", txt)]
|
||||
if len(pars) % 2:
|
||||
pars.append('') # if ends without punctuation
|
||||
for i in range(0, len(pars)-1, 2):
|
||||
print((pars[i] + pars[i + 1]).ljust(54), "==>", haspunctotype(pars[i + 1]))
|
||||
114
Task/Determine-sentence-type/Python/determine-sentence-type-2.py
Normal file
114
Task/Determine-sentence-type/Python/determine-sentence-type-2.py
Normal file
|
|
@ -0,0 +1,114 @@
|
|||
'''Grouping and tagging by final character of string'''
|
||||
|
||||
from functools import reduce
|
||||
from itertools import groupby
|
||||
|
||||
|
||||
# tagGroups :: Dict -> [String] -> [(String, [String])]
|
||||
def tagGroups(tagDict):
|
||||
'''A list of (Tag, SentenceList) tuples, derived
|
||||
from an input text and a supplied dictionary of
|
||||
tags for each of a set of final punctuation marks.
|
||||
'''
|
||||
def go(sentences):
|
||||
return [
|
||||
(tagDict.get(k, 'Not punctuated'), list(v))
|
||||
for (k, v) in groupby(
|
||||
sorted(sentences, key=last),
|
||||
key=last
|
||||
)
|
||||
]
|
||||
return go
|
||||
|
||||
|
||||
# sentenceSegments :: Chars -> String -> [String]
|
||||
def sentenceSegments(punctuationChars):
|
||||
'''A list of sentences delimited by the supplied
|
||||
punctuation characters, where these are followed
|
||||
by spaces.
|
||||
'''
|
||||
def go(s):
|
||||
return [
|
||||
''.join(cs).strip() for cs
|
||||
in splitBy(
|
||||
sentenceBreak(punctuationChars)
|
||||
)(s)
|
||||
]
|
||||
return go
|
||||
|
||||
|
||||
# sentenceBreak :: Chars -> (Char, Char) -> Bool
|
||||
def sentenceBreak(finalPunctuation):
|
||||
'''True if the first of two characters is a final
|
||||
punctuation mark and the second is a space.
|
||||
'''
|
||||
def go(a, b):
|
||||
return a in finalPunctuation and " " == b
|
||||
return go
|
||||
|
||||
|
||||
# ------------------------- TEST -------------------------
|
||||
# main :: IO ()
|
||||
def main():
|
||||
'''Join, segmentation, tags'''
|
||||
|
||||
tags = {'!': 'E', '?': 'Q', '.': 'S'}
|
||||
|
||||
# Joined by spaces,
|
||||
sample = ' '.join([
|
||||
"Hi there, how are you today?",
|
||||
"I'd like to present to you the washing machine 9001.",
|
||||
"You have been nominated to win one of these!",
|
||||
"Might it be possible to add some challenge to this task?",
|
||||
"Feels as light as polystyrene filler.",
|
||||
"But perhaps substance isn't the goal!",
|
||||
"Just make sure you don't break off before the"
|
||||
])
|
||||
|
||||
# segmented by punctuation,
|
||||
sentences = sentenceSegments(
|
||||
tags.keys()
|
||||
)(sample)
|
||||
|
||||
# and grouped under tags.
|
||||
for kv in tagGroups(tags)(sentences):
|
||||
print(kv)
|
||||
|
||||
|
||||
# ----------------------- GENERIC ------------------------
|
||||
|
||||
# last :: [a] -> a
|
||||
def last(xs):
|
||||
'''The last element of a non-empty list.'''
|
||||
return xs[-1]
|
||||
|
||||
|
||||
# splitBy :: (a -> a -> Bool) -> [a] -> [[a]]
|
||||
def splitBy(p):
|
||||
'''A list split wherever two consecutive
|
||||
items match the binary predicate p.
|
||||
'''
|
||||
# step :: ([[a]], [a], a) -> a -> ([[a]], [a], a)
|
||||
def step(acp, x):
|
||||
acc, active, prev = acp
|
||||
|
||||
return (acc + [active], [x], x) if p(prev, x) else (
|
||||
(acc, active + [x], x)
|
||||
)
|
||||
|
||||
# go :: [a] -> [[a]]
|
||||
def go(xs):
|
||||
if 2 > len(xs):
|
||||
return xs
|
||||
else:
|
||||
h = xs[0]
|
||||
ys = reduce(step, xs[1:], ([], [h], h))
|
||||
# The accumulated sublists, and the final group.
|
||||
return ys[0] + [ys[1]]
|
||||
|
||||
return go
|
||||
|
||||
|
||||
# MAIN ---
|
||||
if __name__ == '__main__':
|
||||
main()
|
||||
|
|
@ -0,0 +1,13 @@
|
|||
#lang racket
|
||||
|
||||
(define input "hi there, how are you today? I'd like to present to you the washing machine 9001. You have been nominated to win one of these! Just make sure you don't break it")
|
||||
|
||||
(define sentence-types #hash((#\. . "S") (#\? . "Q") (#\! . "E")))
|
||||
(define punctuation (hash-keys sentence-types))
|
||||
|
||||
(let ([characters (string->list input)])
|
||||
(for ([i characters])
|
||||
(when (member i punctuation)
|
||||
(printf "~a|" (hash-ref sentence-types i))))
|
||||
(unless (member (last characters) punctuation)
|
||||
(printf "N")))
|
||||
|
|
@ -0,0 +1,23 @@
|
|||
use Lingua::EN::Sentence;
|
||||
|
||||
my $paragraph = q:to/PARAGRAPH/;
|
||||
hi there, how are you today? I'd like to present to you the washing machine
|
||||
9001. You have been nominated to win one of these! Just make sure you don't
|
||||
break it
|
||||
|
||||
|
||||
Just because there are punctuation characters like "?", "!" or especially "."
|
||||
present, it doesn't necessarily mean you have reached the end of a sentence,
|
||||
does it Mr. Magoo? The syntax highlighting here for Raku isn't the best.
|
||||
PARAGRAPH
|
||||
|
||||
say join "\n\n", $paragraph.&sentences.map: {
|
||||
/(<:punct>)$/;
|
||||
$_ ~ ' | ' ~ do
|
||||
given $0 {
|
||||
when '!' { 'E' };
|
||||
when '?' { 'Q' };
|
||||
when '.' { 'S' };
|
||||
default { 'N' };
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,68 @@
|
|||
see "working..." + nl
|
||||
sType = []
|
||||
sent = "hi there, how are you today? I'd like to present to you the washing machine 9001. You have been nominated to win one of these! How do you like this washing machine? Buy it, don't hesitate! You will be satisfied with it. Just make sure you don't break it"
|
||||
|
||||
ind = 1
|
||||
while true
|
||||
pos = substring(sent,"?",ind)
|
||||
if pos > 0
|
||||
add(sType,pos)
|
||||
ind = pos+1
|
||||
else
|
||||
exit
|
||||
ok
|
||||
end
|
||||
|
||||
ind = 1
|
||||
while true
|
||||
pos = substring(sent,"!",ind)
|
||||
if pos > 0
|
||||
add(sType,pos)
|
||||
ind = pos+1
|
||||
else
|
||||
exit
|
||||
ok
|
||||
end
|
||||
|
||||
ind = 1
|
||||
while true
|
||||
pos = substring(sent,".",ind)
|
||||
if pos > 0
|
||||
add(sType,pos)
|
||||
ind = pos+1
|
||||
else
|
||||
exit
|
||||
ok
|
||||
end
|
||||
|
||||
if pos < len(sent)
|
||||
neut = "N"
|
||||
else
|
||||
neut = ""
|
||||
ok
|
||||
|
||||
sType = sort(sType)
|
||||
|
||||
text = ""
|
||||
for n = 1 to len(sType)
|
||||
if sent[sType[n]] = "?"
|
||||
text = text + "Q" + "|"
|
||||
ok
|
||||
if sent[sType[n]] = "!"
|
||||
text = text + "E" + "|"
|
||||
ok
|
||||
if sent[sType[n]] = "."
|
||||
text = text + "S" + "|"
|
||||
ok
|
||||
next
|
||||
see text + neut + nl
|
||||
see "done..." + nl
|
||||
|
||||
func substring str,substr,n
|
||||
newstr=right(str,len(str)-n+1)
|
||||
nr = substr(newstr, substr)
|
||||
if nr = 0
|
||||
return 0
|
||||
else
|
||||
return n + nr -1
|
||||
ok
|
||||
|
|
@ -0,0 +1,24 @@
|
|||
fn sentence_type(s string) string {
|
||||
if s.len == 0 {
|
||||
return ""
|
||||
}
|
||||
mut types := []string{}
|
||||
for c in s.split('') {
|
||||
if c == '?' {
|
||||
types << "Q"
|
||||
} else if c == '!' {
|
||||
types << "E"
|
||||
} else if c == '.' {
|
||||
types << "S"
|
||||
}
|
||||
}
|
||||
if s[s.len-1..s.len].index_any('?!.') == -1 {
|
||||
types << "N"
|
||||
}
|
||||
return types.join("|")
|
||||
}
|
||||
|
||||
fn main() {
|
||||
s := "hi there, how are you today? I'd like to present to you the washing machine 9001. You have been nominated to win one of these! Just make sure you don't break it"
|
||||
println(sentence_type(s))
|
||||
}
|
||||
|
|
@ -0,0 +1,18 @@
|
|||
var sentenceType = Fn.new { |s|
|
||||
if (s.count == 0) return ""
|
||||
var types = []
|
||||
for (c in s) {
|
||||
if (c == "?") {
|
||||
types.add("Q")
|
||||
} else if (c == "!") {
|
||||
types.add("E")
|
||||
} else if (c == ".") {
|
||||
types.add("S")
|
||||
}
|
||||
}
|
||||
if (!"?!.".contains(s[-1])) types.add("N")
|
||||
return types.join("|")
|
||||
}
|
||||
|
||||
var s = "hi there, how are you today? I'd like to present to you the washing machine 9001. You have been nominated to win one of these! Just make sure you don't break it"
|
||||
System.print(sentenceType.call(s))
|
||||
|
|
@ -0,0 +1,28 @@
|
|||
import "./pattern" for Pattern
|
||||
import "./iterate" for Indexed
|
||||
|
||||
var map = { "?": "Q", "!": "E", ".": "S", "": "N" }
|
||||
var p = Pattern.new("[? |! |. ]")
|
||||
var paras = [
|
||||
"hi there, how are you today? I'd like to present to you the washing machine 9001. You have been nominated to win one of these! Just make sure you don't break it",
|
||||
"hi there, how are you on St.David's day (isn't it a holiday yet?), Mr.Smith? I'd like to present to you (well someone has to win one!) the washing machine 900.1. You have been nominated by Capt.Johnson('?') to win one of these! Just make sure you (or Mrs.Smith) don't break it. By the way, what the heck is an exclamatory question!?"
|
||||
]
|
||||
|
||||
for (para in paras) {
|
||||
para = para.trim()
|
||||
var sentences = p.splitAll(para)
|
||||
var endings = p.findAll(para).map { |m| m.text[0] }.toList
|
||||
var lastChar = sentences[-1][-1]
|
||||
if ("?!.".contains(lastChar)) {
|
||||
endings.add(lastChar)
|
||||
sentences[-1] = sentences[-1][0...-1]
|
||||
} else {
|
||||
endings.add("")
|
||||
}
|
||||
for (se in Indexed.new(sentences)) {
|
||||
var ix = se.index
|
||||
var sentence = se.value
|
||||
System.print("%(map[endings[ix]]) <- %(sentence + endings[ix])")
|
||||
}
|
||||
System.print()
|
||||
}
|
||||
|
|
@ -0,0 +1,18 @@
|
|||
include xpllib; \for StrLen
|
||||
int Sentence, N, Len;
|
||||
char Str;
|
||||
[Sentence:= ["hi there, how are you today?",
|
||||
"I'd like to present to you the washing machine 9001.",
|
||||
"You have been nominated to win one of these!",
|
||||
"Just make sure you don't break it"];
|
||||
for N:= 0 to 3 do
|
||||
[Str:= Sentence(N);
|
||||
Len:= StrLen(Str);
|
||||
case Str(Len-1) of
|
||||
^!: ChOut(0, ^E);
|
||||
^?: ChOut(0, ^Q);
|
||||
^.: ChOut(0, ^S)
|
||||
other ChOut(0, ^N);
|
||||
if N < 3 then ChOut(0, ^|);
|
||||
];
|
||||
]
|
||||
Loading…
Add table
Add a link
Reference in a new issue