Is it a noun or not?

Question

Given a string as input, determine whether it is a noun or not.

You will be scored on the 1000 most common English words, by how many you correctly label as a noun or not.

The program or function which correctly classifies the most of those words in 50 bytes or less will win.

Nouns

A noun is a word that represents a thing, typically. It gets more complex, but that's the basic idea.

In cases where a word could either be a noun or some other part of speech, I classified it as a noun, even if that's a rare usage. Or actually, I let this site do it for me.

The words you'll be scored on are these 1000 common words, which are from simple Wikipedia, with "two" and "once" added. Of those, these are the 586 nouns, and these are the 414 non-nouns. You can find all three lists here. Note that all of these inputs are in lower case. These lists are final - don't try to argue grammar.

Your program will be considered correct if it outputs a truthy result on an input which is a noun, and a falsy result on an input which is not a noun.

Subtleties:

Programs must have a deterministic output. If you want to use randomness, seed it. Programs are not allowed to use built-in noun lists or other built-in part-of-speech functionality.

Examples:

a: noun
act: noun
active: noun
about: non-noun
above: non-noun
across: non-noun

Please indicate what your program's success rate is in your answer. The program or function of at most 50 bytes with the highest success rate wins. In case of a tie, lowest byte count will determine a winner. Good luck!

Answer 1

JavaScript (ES6), 43 bytes, 622 630 633

Just to get the ball rolling. Returns 1 for nouns, 0 for non-nouns.

s=>2552>>s.length&/^[bcdf-mp-tvwy]/.test(s)

How?

We bet on noun if both following conditions are met:

1. The word length is 3, 4, 5, 6, 7, 8 or 11. This is done by right-shifting the binary number 100111111000 (2552 as decimal).
2. The word starts with one of these letters: bcdfghijklmpqrstvwy

Answer 2

Jelly, 48 bytes, score 731

This is my first ever answer in Jelly and I went to a lot of trouble putting this together. Ah well ... that was fun. :-)

O‘ḅ⁹%⁽€Oæ»4“Ạ$ⱮẊḲḲLÑMṆụ⁻ẉṂ`ŻvḤæɠ5ṭȯƁU*×TdƲḥ`’æ»Ḃ

1 byte saved thanks to @JonathanAllan

Try it online!

Breakdown and test suites

• Non-nouns correctly identified as non-nouns: 265 / 414 (64%)
• Nouns correctly identified as nouns: 466 / 586 (79.5%)

How?

We first compute a hash of the input string by:

• converting it to an integer by interpreting each code point as a base-256 digit
• applying modulo 4080 (chosen as the most efficient value with no more than 12 bits)
• keeping the 8 most significant bits of the result

This leaves us with an index in [0 ... 255] and thus divides all words into 256 groups.

For each group of words, we pre-compute a binary flag which is 1 if the group contains more nouns than non-nouns, and 0 otherwise. This leads to a 256-bit number N that we're going to use as a lookup-table. We store it as a base-250 encoded string.

Below is the binary representation of N.

1000011000001011000101111011111001001101110010101101110010001101
0000010001101010010111110001110010010101110110110010111111010000
0001111010011110000110101011111000011110111011010011011110101100
1010010110101111000010101000101100000001110110100011111000101010

Which can be stored as “Ạ$ⱮẊḲḲLÑMṆụ⁻ẉṂ`ŻvḤæɠ5ṭȯƁU*×TdƲḥ`’ in Jelly.

Hence the code:

O‘ḅ⁹%⁽€Oæ»4“Ạ$ⱮẊḲḲLÑMṆụ⁻ẉṂ`ŻvḤæɠ5ṭȯƁU*×TdƲḥ`’æ»Ḃ    main link

O                                                   convert the input string to a list of
                                                    code points
 ‘                                                  increment each of them
  ḅ⁹                                                convert from base 256 to an integer
    %⁽€O                                            modulo 4080
        æ»4                                         drop the 4 least significant bits
           “Ạ$ⱮẊḲḲLÑMṆụ⁻ẉṂ`ŻvḤæɠ5ṭȯƁU*×TdƲḥ`’æ»     right shift N by this amount
                                               Ḃ    test the least significant bit

Answer 3

Jelly, 50 bytes, score 763

^{Using a hash now (much like Arnauld's Jelly answer)}

OP%⁽Wpị“!ḋGẠ⁻Ṭȥʋt|Ḥ\⁾°½İ@G2ḂƑ½ịʂ¶ɦḲ⁷³Hz~⁵p9)⁹ƙ¿’B¤

Try It Online!

250 / 414 for Non-Nouns
513 / 586 for Nouns
Total = 250 + 513 = 763.

How?

Builds a table with 308 entries, either 1 (identifying a noun) or 0 (identifying a non noun) and indexes into it using a key provided by a hash function that utilises the product of the ordinals of the input word:

OP%⁽Wpị“!ḋGẠ⁻Ṭȥʋt|Ḥ\⁾°½İ@G2ḂƑ½ịʂ¶ɦḲ⁷³Hz~⁵p9)⁹ƙ¿’B¤ - Link: list of characters, word
O                                                  - convert to ordinals
 P                                                 - product
   ⁽Wp                                             - base 250 number = 22863
  %                                                - modulo (by 22863)
                                                 ¤ - nilad plus link(s) as a nilad:
       “!ḋGẠ⁻Ṭȥʋt|Ḥ\⁾°½İ@G2ḂƑ½ịʂ¶ɦḲ⁷³Hz~⁵p9)⁹ƙ¿’   -   base 250 number
                                                B  -   as a binary list (308 bits)
      ị                                            - index into (1-indexed and modular,
                                                  -   so adds another modulo by 308)

---

Previous:  50  47 bytes, score 684

ḣ3Ẇf“QṘ°ḂżÐŒ#ḍæ09»s2¤Ȧ¬ȧØY⁾niyṖf⁽ż2ị$
0,-2ịE¬ȧÇ

A monadic link taking a word and returning a list of one character (truthy) if the word is identified as a noun, or an empty list or zero (both falsey) if it is not.

Try it online! (the footer performs an if else on the result to print Noun or Non-Noun)
...or see the scoring program (counts up truthy indexes across the two lists and then calculates the score).

Score breakdown: 462 / 586 nouns correctly identified (124 incorrect), 222 / 414 non-nouns correctly identified (192 incorrect) -- total correct = 684 / 1000.

How?

Guess it is not a noun if...

• the last character and the character two before that are equal (with modular and 1-based indexing)
• either of the first two length 2 substrings are in:
  'be', 'th', 'le', 'he', 'm ', 'ev', 'et', 's ', 'fl', 'ax', 'en', 'fo', 'am', 'az' (note: 'm ' and 's ' are only here to ease compression, but they never appear anyway)
• The -299^th index (with modular and 1-based indexing) is any of:
  aenouyz (although this is implemented inversely and with excess capital letters)
  ...since the words all have length between 1 and 11 the -299^th index is equivalent to using the length to index mapping: {7:2; 8:5; 9:7; 11:9; else 1}

ḣ3Ẇf“QṘ°ḂżÐŒ#ḍæ09»s2¤Ȧ¬ȧØY⁾niyṖf⁽ż2ị$ - Link 1: list of characters, word
ḣ3                                    - head to index 3 (1st 3 characters, like 'abc')
  Ẇ                                   - all sublists (['a','b','c','ab','bc','abc']
                    ¤                 - nilad followed by link(s) as a nilad:
    “QṘ°ḂżÐŒ#ḍæ09»                    - compression of "bethlehem evets flaxenfoamaz"
                  s2                  - split into chunks of 2:
                                      -   be,th,le,he,m ,ev,et,s ,fl,ax,en,fo,am,az
   f                                  - filter keep (can only match 'ab' or 'bc')
                     Ȧ                - any and all (0 if empty, 1 if not)
                      ¬               - logical not
                        ØY            - consonant -y yield = "BCD...WXZbcd...wxz"
                          ⁾ni         - character pair = "ni" (no shrubbery for you!)
                             y        - translate (exchange the n for an i)
                              Ṗ       - pop (remove the z)
                       ȧ              - logical and
                                    $ - last two links as a monad:
                                ⁽ż2   -   base 250 literal = -299
                                   ị  -   index into the word
                               f      - filter keep

0,-2ịE¬ȧÇ - Main link: list of characters, word
0,-2      - pair zero with -2 = [0,-2]
    ị     - index into the word (last character and the one before the one before that)
     E    - all (both) equal?
      ¬   - logical not
        Ç - call the last link (1) as a monad
       ȧ  - logical and

---

13 bytes, score: 638

A first quick bash (extended above)

ØY⁾niyṖf⁽ż2ị$

Answer 4

JavaScript (ES6), 50 bytes, score 693

s=>!/^([aouz]|th|..$)|e.+[ey]|[flo].r|a.p/.test(s)

Just looking for any possible patterns that non-nouns have that nouns don't.

Non-nouns more often contain:

1. a, o, u, or z as the first letter.
2. th as the first two letters.
3. Two letters only. [Think pronouns (me, we, us, he, it) and prepositions (of, to, in, on, by, at, up, ...).]
4. e, followed by one or more letters, followed by e or y.
5. f, l, or o, followed by any letter, followed by r.
6. a, followed by any letter, followed by p.

Snippet:

var nouns = ['a','act','active','activity','age','air','amount','answer','anything','apple','area','arm','army','art','ask','attack',
             'baby','back','bad','bag','ball','bank','base','basket','bath','bear','beautiful','bed','bedroom','beer','bell','big','bird','birth','birthday','bit','bite','black','block','blood','blow','blue','board','boat','body','bone','book','border','bottle','bottom','bowl','box','boy','branch','brave','bread','break','breakfast','bridge','brother','brown','brush','burn','business','bus','buy',
             'cake','call','can','candle','cap','car','card','care','carry','case','cat','catch','chair','chance','change','chicken','child','chocolate','choice','city','class','clock','clothes','cloud','coffee','coat','cold','comfortable','common','computer','condition','control','cook','corner','cost','count','country','course','cover','crash','cross','cry','cup','cut',
             'dance','dark','daughter','day','dead','deep','desk','dinner','direction','dish','dog','door','double','draw','dream','dress','drink','drive','drop','dust','duty',
             'ear','earth','east','eat','education','effect','egg','end','equal','entrance','escape','evening','event','examination','example','exercise','eye',
             'face','fact','fail','fall','family','farm','father','fat','fault','fear','feed','feel','female','few','fight','fill','film','finger','finish','fire','fish','fix','floor','flower','fly','fold','food','foot','football','force','form','freedom','friend','front','fruit','fun','funny','future',
             'game','garden','gate','general','gift','give','glad','glass','go','god','gold','good','grandfather','grandmother','grass','great','green','ground','group',
             'hair','half','hall','hand','hat','hate','head','heavy','heart','height','hello','help','hide','high','hit','hold','hole','holiday','home','hope','horse','hospital','hotel','house','hour','hurry','husband','hurt',
             'ice','idea','if','increase','inside','iron','invite','island','it',
             'job','join','juice','jump',
             'keep','key','kill','kind','king','kitchen','knee','knife',
             'ladder','lady','land','laugh','lead','leave','leg','length','lesson','let','letter','library','lie','life','light','lip','list','listen','lock','long','look','love','low','luck',
             'machine','main','make','male','man','many','map','mark','market','matter','meal','meat','medicine','meet','member','mention','method','middle','milk','mind','minute','miss','mistake','mix','model','moment','money','month','morning','most','mother','mountain','mouth','move','music',
             'name','nation','nature','neck','net','news','newspaper','night','noise','north','nose','nothing','notice','number',
             'object','offer','office','oil','one','opposite','orange','order','other','outside','page','pain','paint','pair','paper','parent','park','part','partner','party','pass','past','path','pay','peace','pen','people','period','person','piano','pick','picture','piece','pin','place','plane','plant','plastic','plate','play','plenty','point','police','pool','position','possible','potato','power','present','press','price','private','prize','problem','produce','promise','public','pull','push','put',
             'queen','question','quiet',
             'radio','rain','raise','reach','read','record','red','remove','rent','repair','repeat','reply','report','rest','restaurant','result','return','rice','rich','ride','ring','rise','road','rock','room','round','rule','run','rush',
             'sad','safe','sail','salt','sand','save','school','science','search','seat','second','sell','sentence','serve','sex','shake','shape','share','she','shine','ship','shirt','shoe','shoot','shop','shoulder','show','sick','side','signal','silly','silver','simple','single','sing','sink','sister','size','skill','skin','skirt','sky','sleep','slip','smell','smile','smoke','snow','sock','soft','son','sound','soup','south','space','special','speed','spell','spend','sport','spread','spring','square','stand','star','start','station','stay','steal','step','still','stomach','stop','store','storm','story','street','structure','student','study','stupid','subject','substance','sugar','summer','sun','support','surprise','sweet','swim',
             'table','talk','taste','tea','teach','team','tear','telephone','television','tell','tennis','test','thing','tie','title','today','toe','tomorrow','tonight','tool','tooth','top','total','touch','town','train','travel','tree','trouble','trust','try','turn','type',
             'uncle','unit','use','usual',
             'vegetable','village','voice','visit',
             'wait','wake','walk','wash','watch','water','way','wear','weather','wedding','week','weight','welcome','west','wheel','while','white','wife','will','win','wind','window','wine','winter','wish','woman','wonder','word','work','world','worry',
             'yard','yesterday','you','young',
             'two'],
   nonNouns=['about','above','across','add','afraid','after','again','ago','agree','all','alone','along','already','always','am','an','and','angry','another','any','anyone','anytime','appear','are','around','arrive','as','at','aunt','autumn','away',
             'be','bean','behave','before','begin','behind','below','besides','best','better','between','bleed','boil','born','borrow','both','breathe','bright','bring','build','busy','but','by',
             'careful','careless','central','century','certain','chase','cheap','cheese','children','choose','circle','clever','clean','clear','climb','cloth','cloudy','close','coin','collect','colour','comb','compare','come','complete','continue','cool','copper','corn','correct','contain','cupboard',
             'dangerous','decide','decrease','deer','depend','destroy','develop','die','different','difficult','dirty','discover','do','down','dry','duck',
             'each','early','earn','easy','eight','either','electric','elephant','else','empty','enemy','enjoy','enough','enter','even','ever','every','everyone','exact','everybody','except','excited','expect','expensive','explain','extremely',
             'false','famous','far','fast','fever','find','fine','first','fit','five','flag','flat','float','flour','fool','for','foreign','forest','forget','forgive','fork','fox','four','free','freeze','fresh','friendly','from','full','furniture','further',
             'gentleman','get','goat','goodbye','grave','gray','grow','gun',
             'hammer','happen','happy','hard','have','he','healthy','hear','heaven','hen','her','here','hers','hill','him','his','hobby','hot','how','hundred','hungry',
             'i','important','in','into','introduce','invent','is','its',
             'jelly','just',
             'knock','know',
             'lamp','large','last','late','lately','lazy','leaf','learn','left','lend','less','like','lion','little','live','lonely','lose','lot','lower',
             'marry','may','me','mean','measure','million','modern','monkey','moon','more','much','must','my',
             'narrow','near','nearly','need','needle','neighbour','neither','never','new','next','nice','nine','no','noble','none','nor','not','now',
             'obey','ocean','of','off','often','old','on','only','open','or','our','out','over','own',
             'pan','pencil','pepper','per','perfect','petrol','photograph','pig','pink','please','pleased','pocket','poison','polite','poor','popular','pour','pretty','prevent','prince','prison','probably','proper','protect','provide','punish','pupil',
             'quick','quite',
             'rainy','ready','real','really','receive','remember','remind','right','rob','rubber','rude','ruler',
             'same','say','scissors','see','seem','send','seven','several','shade','shadow','sharp','sheep','sheet','shelf','short','should','shout','silence','similar','since','sit','six','slow','small','so','soap','some','someone','something','sometimes','soon','sorry','speak','spoon','stamp','steam','stone','strange','strong','successful','such','sudden','suitable','sunny','sure','sword',
             'take','tall','taxi','ten','terrible','than','that','the','their','then','there','therefore','these','thick','thin','think','third','this','though','threat','three','tidy','to','together','too','tram','true','twice',
             'ugly','under','understand','until','up','useful','usually',
             'very',
             'want','warm','was','waste','we','weak','were','well','wet','what','when','where','which','who','why','wide','wild','wire','wise','with','without',
             'yell','yet','your',
             'zero','zoo',
             'once'];

f=
s=>!/^([aouz]|th|..$)|e.+[ey]|[flo].r|a.p/.test(s)

//truthy:
tnoun = 0;
nouns.forEach(s=>tnoun += f(s));
console.log('Nouns: ' + tnoun + ' correct');

//falsy:
tnonNoun = 0;
nonNouns.forEach(s=>tnonNoun += !f(s));
console.log('Non-nouns: ' + tnonNoun + ' correct');
console.log('Total: ' + (tnoun + tnonNoun) + ' correct');

Answer 5

Julia 34bytes, 609

f(w)=hash(w)&0x0800000000004808>0

I wanted to save on characters by using the in-built hash. I feel like there must be a way to do this better. Julia is just not friendly enough with the bit-banging operations I want to use to make this better I think.

Finding suitable bitmasks for the hash to separate them, is an interesting game.

Answer 6

2-level logic gate implementation, not 50 bytes, score 1000

1. Just plug the binary representation of the given word to the 88 inputs

   1. complete the input word by spaces at right if the length of the word is less than 11
   2. 8-bits ASCII code for each letter of the input word

2. The circuit returns 1 if the word is a noun, and returns 0 if not

3. The blue dashed lines are for never used inputs

This implementation needs

1. 48 transistors to encode all inverters gates
2. 1100 transistors to encode all AND gates
3. 154 transistors to encode the OR gate
4. Total of 1302 transistors which represents less than 28 bytes.

Some measurements

1. An inverter gate needs 1 transistor
2. A 2-inputs simple OR gate needs 2 transistors
3. A 2-inputs simple AND gate needs 2 transistors
4. One bit need 6 transistors

Full resolution Circuit.pdf here

Full resolution Circuit.png here

Answer 7

Python 2, 50 bytes, accuracy: 596

lambda x:2<len(x)<7 or x[0]in"abcgmprs"or"st" in x

Try it online!

Simply checks first letter, length, and whether "st" is in the word Code assumes that word is defined as x (Edit: Thanks to issacg for fixing code from snippet to function)

Answer 8

Haskell, 36 bytes, 626 631

f x=length x>2&&x!!0`notElem`"aenou"

Answer 9

Python 3, 50 bytes, score 602

Python isn't the most verbose language, but 50 bytes is tough.

lambda x:all(x.count(y)<1for y in["ful","y","er"])