p or ~p

[Elijah Cardon]

My logic is a little fuzzy. In a legally-inadmissable setting a woman
signed 4 letters to me. Because of recency, the last I can identify as 'e'.
One I could not verify this morning. The other two were either {'r', 'a'}
or {'a', 'r}. Order matters. Has anyone seen a treatment of the word
problem with fuzzy logic in c? EC

[Frederick Gotham]

Elijah Cardon posted:

My logic is a little fuzzy.

So is your language.

In a legally-inadmissable setting a woman
signed 4 letters to me.

Be specific.

(1) A letter of the alphabet
(2) A letter which a person writes to another person

Because of recency, the last I can identify as 'e'.

Makes no sense whatsoever, but I vaguely get the idea that you're trying to
convey that the most recent letter is more memorable than the previous
ones.

One I could not verify this morning.

One of what? The letters?

The other two were either {'r', 'a'} or {'a', 'r'}.

Oh, so you're talking about letters of the alphabet?

Order matters. Has anyone seen a treatment of the word problem with
fuzzy logic in c?

Four letters. One of them is 'e'. There's an 'a' directly beside an 'r'.
Shouldn't be hard to code:

int ContainsE(char const *p)
{
for(;;)
{
switch(*p++)
{
case 'e': return 1;

case 0: return 0;
}
}
}

int HasAbesideR(char const *p)
{
for(;;)
{
switch(*p++)
{
case 'a': if('r' == p[1]) return 1;
case 'r': if('a' == p[1]) return 1;

case 0: return 0;
}
}
}

#include <string.h>

int FitsCriteria(char const *p)
{
return 4==strlen(p) && ContainsE(p) && HasAbesideR(p);
}

Now all you have to do is open a dictionary text file and run every word
through it.

--

Frederick Gotham

[Frederick Gotham]

Frederick Gotham posted:

switch(*p++)
{
case 'a': if('r' == p[1]) return 1;

Wups, I need a "break" there.

case 'r': if('a' == p[1]) return 1;

And here.

--

Frederick Gotham

[Frederick Gotham]

May as well boost the efficiency while I'm at it:

int FitsCriteria(char const *p)
{
char const *const pover = p + 4;

int contains_e = 0, has_a_beside_r = 0;

do
{
switch(*p++)
{
case 'e':
{
if(has_a_beside_r) return 1;

contains_e = 1;
}
break;

case 'a':
{
if('r' == p[1])
{
if(contains_e) return 1;

has_a_beside_r = 1;
}
}
break;

case 'r':
{
if('a' == p[1])
{
if(contains_e) return 1;

has_a_beside_r = 1;
}
}
break;

case 0: return 0;
}
}
while(pover != p);

return 0;
}

--

Frederick Gotham

[jmcgill]

Elijah Cardon wrote:

My logic is a little fuzzy. In a legally-inadmissable setting a woman
signed 4 letters to me. Because of recency, the last I can identify as 'e'.
One I could not verify this morning. The other two were either {'r', 'a'}
or {'a', 'r}. Order matters. Has anyone seen a treatment of the word
problem with fuzzy logic in c? EC

If I had any idea what you were talking about, I think I would say it
sounds like a job for prolog.

[Keith Thompson]

"Elijah Cardon" <in*****@invalid.netwrites:

My logic is a little fuzzy. In a legally-inadmissable setting a woman
signed 4 letters to me. Because of recency, the last I can identify as 'e'.
One I could not verify this morning. The other two were either {'r', 'a'}
or {'a', 'r}. Order matters. Has anyone seen a treatment of the word
problem with fuzzy logic in c? EC

I have no idea what you're talking about. If you want to ask a
question, it's your responsibility to make yourself clear.

Your question, as far as I can tell, seems to be about algorithms, not
C. You might try posting a comprehensible question to
comp.programming.

--
Keith Thompson (The_Other_Keith) ks***@mib.org <http://www.ghoti.net/~kst>
San Diego Supercomputer Center <* <http://users.sdsc.edu/~kst>
We must do something. This is something. Therefore, we must do this.

[Walter Roberson]

In article <12************@corp.supernews.com>,
Elijah Cardon <in*****@invalid.netwrote:

>My logic is a little fuzzy. In a legally-inadmissable setting a woman
signed 4 letters to me. Because of recency, the last I can identify as 'e'.
One I could not verify this morning. The other two were either {'r', 'a'}
or {'a', 'r}. Order matters. Has anyone seen a treatment of the word
problem with fuzzy logic in c? EC

[OT]
$ egrep '^(.are|a.re|ar.e|.rae|r.ae|ra.e)$' /usr/lib/dict/words

acre bare brae care dare fare hare mare pare race rage rake rape rare
rate rave raze ware
--
If you lie to the compiler, it will get its revenge. -- Henry Spencer

[Simon Biber]

Walter Roberson wrote:

In article <12************@corp.supernews.com>,
Elijah Cardon <in*****@invalid.netwrote:

>My logic is a little fuzzy. In a legally-inadmissable setting a woman
signed 4 letters to me. Because of recency, the last I can identify as 'e'.
One I could not verify this morning. The other two were either {'r', 'a'}
or {'a', 'r}. Order matters. Has anyone seen a treatment of the word
problem with fuzzy logic in c? EC

[OT]
$ egrep '^(.are|a.re|ar.e|.rae|r.ae|ra.e)$' /usr/lib/dict/words

acre bare brae care dare fare hare mare pare race rage rake rape rare
rate rave raze ware

Your dictionary is missing the common words 'tare', 'arse' and the
following uncommon words:

Aire arle Arne ayre frae gare lare nare rale rase vare yare

--
Simon.

[Devinandan Rao]

We can make it simpler.

ContainsE: strchr(p,'e')

HasAbesideR : strstr(p,"ar") || strstr(p,"ra")


Frederick Gotham wrote:

Elijah Cardon posted:

My logic is a little fuzzy.

So is your language.

In a legally-inadmissable setting a woman
signed 4 letters to me.

Be specific.

(1) A letter of the alphabet
(2) A letter which a person writes to another person

Because of recency, the last I can identify as 'e'.

Makes no sense whatsoever, but I vaguely get the idea that you're trying to
convey that the most recent letter is more memorable than the previous
ones.

One I could not verify this morning.

One of what? The letters?

The other two were either {'r', 'a'} or {'a', 'r'}.

Oh, so you're talking about letters of the alphabet?

Order matters. Has anyone seen a treatment of the word problem with
fuzzy logic in c?

Four letters. One of them is 'e'. There's an 'a' directly beside an 'r'.
Shouldn't be hard to code:

int ContainsE(char const *p)
{
for(;;)
{
switch(*p++)
{
case 'e': return 1;

case 0: return 0;
}
}
}

int HasAbesideR(char const *p)
{
for(;;)
{
switch(*p++)
{
case 'a': if('r' == p[1]) return 1;
case 'r': if('a' == p[1]) return 1;

case 0: return 0;
}
}
}

#include <string.h>

int FitsCriteria(char const *p)
{
return 4==strlen(p) && ContainsE(p) && HasAbesideR(p);
}

Now all you have to do is open a dictionary text file and run every word
through it.

--

Frederick Gotham

[Rod Pemberton]

"Elijah Cardon" <in*****@invalid.netwrote in message
news:12************@corp.supernews.com...

My logic is a little fuzzy. In a legally-inadmissable setting a woman
signed 4 letters to me.

A) Did she sign four written letters with her signature? (implied by
'legally-inadmissable')
B) Did she sign four alphabetic letters in sign language? (implied by
'signed ... letters' instead of 'wrote ... letters' or 'signed ... legal
documents', etc...)

Yes, fuzzy. I'd say that identifying the correct one of those from context
by a computer is a fuzzy logic problem, but I have no experience with fuzzy
logic. At a minimum, it requires lookahead, and the ability to remember the
prior context of the two questions, until additional context clarifies the
issue. (Have you studied context free grammars?)

Because of recency, the last I can identify as 'e'.
One I could not verify this morning.

So, you forgot the letters, except the last, which she signed with sign
language. Additional context, clarified the fuzzy logic issue.

The other two were either {'r', 'a'}
or {'a', 'r}. Order matters.

'a' 'r' 'e' and an unknown. Determining combinations of 'a' 'r' and 'e'
can be done by brute force lookups. But, determining which single unknown
is valid from multiple potential ones isn't possible without further
information. I'd also take it that "Because of recency" that you forgot the
first letter (prior context, and inference). I'd also take it that "Order
matters" was supposed to be a clue to the correct sequence of letters?
Perhaps, implying, that 'a' and 'r' are to be ordered as they would normally
be when the alphabet is written (this would require context outside the
boundaries of the explicitly stated problem and an assumption which would
need to be confirmed by testing against future deductions). If so, that
would produce "_are", which leaves just about half the alphabet as plausible
first letters... Of those, one could reduce the valid wordset to just ones
which would be used in a "legally-inadmissable setting," i.e., personal,
such as "care", "dare", "rare". These could then be cross-checked against
common known expressions, such as "Take care" or "Dare" (as in "Truth or
Dare"), or "Rare" (How do you want your burger?), etc... Given that one
letter was "forgotten," it's plausible that it was duplicated, i.e., "rare."
But, unless there are some other hidden/implied meanings in the statement of
the problem. It's improbable that the correct response is determinable.

Has anyone seen a treatment of the word
problem with fuzzy logic in c? EC

No. Never heard of it.

[Richard Bos]

Keith Thompson <ks***@mib.orgwrote:

"Elijah Cardon" <in*****@invalid.netwrites:

My logic is a little fuzzy. In a legally-inadmissable setting a woman
signed 4 letters to me. Because of recency, the last I can identify as 'e'.
One I could not verify this morning. The other two were either {'r', 'a'}
or {'a', 'r}. Order matters. Has anyone seen a treatment of the word
problem with fuzzy logic in c? EC

I have no idea what you're talking about.

I don't think we're intended to. But he's a pretty high-quality troll
compared to some of the bozos we've had recently, isn't he?

Richard