text:
Find the shortest unique sublist
Given a list of lists find the shortest list that is a contiguous sublist of exactly one list.
For example if we had
[[1,2,3],
 [1,2,3,4],
 [2,4,5,6],
 [1,2,4,5,6]]

the shortest contiguous sublist would be [3,4] since it only appears in the second list.
If there is no unique contiguous sublist (this requires at least one duplicate entry), output an empty list.  Here is an example
[[1,2,3],
 [1,2,3],
 [1,2]]

If there are multiple contiguous sublists of minimal size, you may output any one of them or a list containing all of them.  For example if the input was
[[1,2,3],[2],[1],[3]]

You could output either [1,2], [2,3] or [[1,2],[2,3]].  If you choose to do the latter option you may output singleton lists for the cases where there is only one solution.
The output may occur in the same list more than once as long as it appears in no other list.  For example
[[1,2,1,2],[2,1]]

should output [1,2] because [1,2] is a sublist of the first list but not the second, even though it is a sublist of the first list in two different ways.
You may take as input a list of lists containing any type so long as that type has more than 100 possible values, i.e. no Booleans.
This is code-golf so answers will be scored in bytes with less bytes being better.
Test Cases
[[1,1]] : [1]
[[1],[1]] : []
[[1,1],[1]] : [1,1]

Husk, 12 14 15 bytes
+3 bytes for case [[1,1]]
Ṡḟȯ¬€Ṡ-uÖLṁȯtuQ

Try it online!
Explaination
          ṁ      -- map and concatenate
           ȯt    --   all but the first
             u   --   unique elements of
              Q  --   contiguous sublist
        ÖL       -- sort by length
Ṡḟ               -- find the first element satisfying this predicate
  ȯ¬€            --   not an element of
     Ṡ-          --   the list of sublists minus
       u         --   its unique elements

Note: Ṡ f g x = f (g x) x and this is hard to explain using the method above.

14 bytes with a lambda.

That fails for [[1,1]]

Hmm, and fixing that makes it over 15 bytes. Oh well.

Pyth, 15 bytes
halDs-M.p.:R)QY

Test suite
First, we generate all substrings of each input list with .:R)Q. Then, we generate all possible orderings, of those substring groups .p.
Now for the tricky part: -M. This folds the - function over each ordering list. It starts with the first substring list, then filters out all occupants of all of the other lists.
Then, the results are concatenated, ordered by length, a [] is appended, and then the first element of the resulting list is extracted with h.
This would be 4 bytes shorter if I could error on no unique sublists rather than output an empty list.

What is your 11-byte version?

@LeakyNun hlDs-M.p.:R is probably what he means.

Pyth - 20 bytes
Ksm.:d)QhalDfq1/KTKY

Test Suite.

Got 16 bytes, but I'm not sure this is correct. Otherwise it's pretty similar.

@FryAmTheEggman cool, you should post it.

Fails for the recently added edge case test [[1,1]].

Java 8, 251 + 19 = 270 bytes
A very gross lambda from, minimally, List<List> to List (best to cast it to Function<List<List<Integer>>, List<Integer>> though). It's a brute force solution that iterates chunk lengths from 1 to the size of the largest list, in each case iterating over every chunk of that length in every list and checking each such chunk against each chunk of equal size in every other list.
Fear me, garbage collector.
import java.util.*;

i->{int x,l=x=0,s,t;for(List z:i)x=Math.max(x,z.size());List r=i;while(l++<=x)for(List a:i)c:for(s=0;s<=a.size()-l;s++){for(List b:i)for(t=0;t<=b.size()-l;)if(b.subList(t,l+t++).equals(r=a.subList(s,s+l))&a!=b)continue c;return r;}return new Stack();}

Ungolfed lambda
i -> {
    int
        x,
        l = x = 0,
        s, t
    ;
    for (List z : i)
        x = Math.max(x, z.size());
    List r = i;
    while (l++ <= x)
        for (List a : i)
            c: for (s = 0; s <= a.size() - l; s++) {
                for (List b : i)
                    for (t = 0; t <= b.size() - l; )
                        if (b.subList(t, l + t++).equals(r = a.subList(s, s + l)) & a != b)
                            continue c;
                return r;
            }
    return new Stack();
}

Try It Online
Java 8, 289 + 45 = 334 bytes
This is a more functional approach using streams. If there were a method on Stream to reduce to only elements that appear once, this solution would have beaten the one above. Assign to the same type as above.
import java.util.*;import java.util.stream.*;

l->{List<List>o=l.stream().flatMap(a->IntStream.range(1,a.size()+1).boxed().flatMap(n->IntStream.range(0,a.size()-n+1).mapToObj(k->a.subList(k,k+n)))).collect(Collectors.toList());o.sort((a,b)->a.size()-b.size());for(List a:o)if(o.indexOf(a)==o.lastIndexOf(a))return a;return new Stack();}

Ungolfed lambda
l -> {
    List<List> o = l.stream()
        .flatMap(a -> IntStream.range(1, a.size() + 1)
            .boxed()
            .flatMap(n -> IntStream.range(0, a.size() - n + 1)
                .mapToObj(k -> a.subList(k, k + n))
            )
        )
        .collect(Collectors.toList())
    ;
    o.sort((a, b) -> a.size() - b.size());
    for (List a : o)
        if (o.indexOf(a) == o.lastIndexOf(a))
            return a;
    return new Stack();
}

Try It Online

Haskell, 149 128 126 113 bytes
import Data.List
f l=[x|x<-l,sum[1|y<-l,y==x]<2]
h[]=[]
h(x:y)=x
i=h.f.sortOn length.(>>=tail.nub.(>>=tails).inits)

Try it online!
Saved 21 bytes thanks to Wheat Wizard, H.PWiz and Bruce Forte.
Saved two more bytes thanks to H.PWiz.
Saved 13 bytes thanks to nimi.
EDIT This was the original explanation:

a is a shortcut for joining lists.
s computes all the continous sublists (all tails from all inits). Note that nub keeps only the first occurence of each element, so tail will remove the empty list from the sublists.
g merges all sublists from all given lists in a big list of sublists, and sort them by length.
f f is a filter on elements that appear only once in the big list
h is a secure version of head
i is the glue

Quite inelegant! There should be a better solution...

It looks like a couple of your functions could be shorter if written as point-free functions.

You also don't have to count the i= at the end of your program because point-free functions do not need to be assigned according to our rules.

Is foldl1(++) just concat?

(length$filter(==x)l) could be shorter as length(filter(==x)l) or even shorter as sum[1|y<-l,y==x]

@H.PWiz Except for [] it is, but >>=id is even shorter ;) Also @jferard: You can inline a lot of functions (eg. f,g etc.) since you only use them once.

@H.PWiz thanks, but I don't understand your last comment. The result is [3,4], as expected. Or do I miss something ?

@jferard No, I just edited your code without realising that I introduced a bug, sorry

@H.PWiz No problem. And thanks for the brackets!

Each time your are using concat, it's followed by map (or <$>), so you can use concatMap or >>= from the list monad instead and drop the definition of a: i=h.f.sortOn length.(>>=tail.nub.(>>=tails).inits).

@nimi thanks. I just started to study monads.

@jferard: the great thing about monads is that you don't have to study them if you want to use them. Whenever you have a map and a concat, you can use either concatMapor >>= (or it's alter ego =<<). >>=/=<< just happen to be the "bind" operation from the list monad. Nevertheless it's useful to understand monads.

You can use sortOn(0<$) instead of sortOn length, see this tip.

Jelly, 15 bytes
Ẇ€Q€ẎɓċỊµÐf⁸LÐṂ

Try it online!
-3 bytes thanks to Jonathan Allan

Can ċ1 be replaced with S?

@ThePirateBay Indeed it can, thanks. I made a different version though. (though it would bring it to the same bytecount)

Your new solution prints [1, 2, 1] for input [[1,2],[1,2,1],[2,1,1]] while [1,1] is shorter.

@ThePirateBay Fixed, thanks.

Ẇ€ẎµċÐ€=1Tị⁸LÐṂ should avoid the register for a byte I think...

@WheatWizard Nah, that's just because Jelly's representation of an empty list is nothing: see a Python representation here

@JonathanAllan Ok thanks!  I thought it might be the case but I wanted to let the people who actually know Jelly look at it.

@JonathanAllan Ah nice. Thanks.

Another two like so: Ẇ€ẎɓċỊµÐf⁸LÐṂ

@JonathanAllan Thanks!

ruh-roh, all the methods fail edge case just added to tests: [[1,1]] (since [1] is a substring of [1,1] twice). EDIT: I think Ẇ€Q€ẎɓċỊµÐf⁸LÐṂ would fix that for two.

@JonathanAllan Oh rip :( well thanks for the fix :D

@JonathanAllan oh um. I can't count whoops. :P

05AB1E, 15 bytes
εŒÙ}€`{γʒg}€`éн

Try it online!

Pyth, 14 bytes
sfq1lT.gksm{.:

Try it here.


text:
Is it a noun or not?
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!

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:

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).
The word starts with one of these letters: bcdfghijklmpqrstvwy

Just as I was about to comment, with JS specifically in mind, that the byte limit was far too restrictive, you post this! I was thinking, without having looked at the list, that a better score than 586 might just be possible by testing the first letter or 2 in each word. Nicely done :)

An explanation would be nice, for people less familiar with Javascript. As far as I can tell, this checks whether the word length is 3, 4, 5, 6, 7, 8 or 11, and the word also starts with one of a set of letters?

@isaacg That's correct. Explanation added.

Note that the character class [bcdf-mp-tvwy] is equivalent to the class [^aenouxz]. A change would save 4 bytes, which could be capitalized on.

@fireflame241 Very true. And that can even be shortened to [^aenouz] because we don't have any word starting with a x.

I wonder (again, without having looked at the list): could you use the bytes fireflame saved you to add a check for the 2nd letter and increase your score. I'm coming off the back of an 80 hour week so I'm not even sure that makes sense to me! Just thought it was worth the suggestion.

I think y does not improve the score at all (I think bcdfghijklmpqrstvw suffice). Maybe you can do something with that byte.

@Shaggy I was too tired to work on that one any further yesterday evening. Rick has since done a much better work in JS, so I've switched to Jelly instead. ;-)

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:

a, o, u, or z as the first letter.
th as the first two letters.
Two letters only.  [Think pronouns (me, we, us, he, it) and prepositions (of, to, in, on, by, at, up, ...).]
e, followed by one or more letters, followed by e or y.
f, l, or o, followed by any letter, followed by r.
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');

I believe you can save a byte by changing the first regex to /h|n/ (or by doing /^.[hn]/.test(s)), and another by changing s[2]>'' to either !!s[2] or 2 in s.

Thanks, @ETHproductions. I can use your suggestions and combine the two tests to save a bunch of bytes, which allowed me to add code to improve my score.

Isn't a.p redundant since you already have [aouz]?

@AdmBorkBork, the a in [aouz] is matched only when at the beginning of the string.  For whatever reason, testing for a.p anywhere in the string improves the score.

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

Nice job! Save a byte to boot with O‘ḅ⁹%⁽€Oæ»4“Ạ$ⱮẊḲḲLÑMṆụ⁻ẉṂ`ŻvḤæɠ5ṭȯƁU*×TdƲḥ`’æ»Ḃ (also note you can use the footer on TIO, I'd go with Ç€¬S,L and Ç€S,L for your two test suites.

@JonathanAllan Thanks for the tips!

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 -299th 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 -299th 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ị$

0,-2 doesn't mean pair zero with -2 it means literal [0, -2]

But it's the very same effect :p

no it's not 0,-2 is a nilad, not separate (0)(,)(-2)...of course it's the same effect in this case but not always. I learned that the hard way...and whatever the case I'd anyways prefer to explain what actually happens instead of something with the same effect or something.

If I'd written "join" rather than "pair" would you have commented "no join is j"?

I might be a little bit pedantic, but pair or join are obviously wrong ways to phrase it, since 0,-2,-6 for example doesn't mean pair 0 with -2 and then pair that with -6 = [[0, -2], -6] but it rather means literal [0, -2, -6]. I get it, the , atom and the ...,...(,...(...)) literal are confusing...but stilll 0,-2,-6 isn't quite the same as 0,-2;-6 since the former is 1 link and the latter is 3 links.

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.

Best solution ;)

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)

Hi, welcome to the site. While this is interesting, submissions are required to either be fuctions or full programs. This is a snippet, which is not allowed. See this Try it online! link for a way to convert this snippet to a function while still executing the same code.

Haskell, 36 bytes, 626 631
f x=length x>2&&x!!0`notElem`"aenou"

643 if anyone has a shorter language: length x>2&&(x!!0`notElem`"aenou"||x!!1`elem`"acqrsty")

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"])

source: Stack Exchange

license: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/3.0/

sort: votes


text:
Generate a congruent list with the smallest sum
Two lists A and B are congruent if they have the same length, and elements that compare equal in A compare equal in B.
In other words, given any two valid indices x and y:

If A[x] = A[y], then B[x] = B[y].
If A[x] != A[y], then B[x] != B[y].

For example, the lists [1, 2, 1, 4, 5] and [0, 1, 0, 2, 3] are congruent.
The Task
Given a nonempty list of nonnegative integers A, return a new list of nonnegative integers B such that is congruent to A, while minimizing the sum of the integers in B.
There are potentially many possible valid outputs. For example, in the list [12, 700, 3], any permutation of [0, 1, 2] would be considered valid output.
Test Cases
Format:
input ->
one possible valid output

[1 2 1 4 5] ->
[0 1 0 2 3] (this is the example given above)

[3 2 2 1 5 7 2] ->
[1 0 0 2 3 4 0]

[8 8 8 8 8] ->
[0 0 0 0 0]

[2] ->
[0]

[8 6 8 4 6 8 2 4 6 8 0 2 4 6 8] ->
[0 1 0 2 1 0 3 2 1 0 4 3 2 1 0]

[14 1] ->
[1 0]

[19 6 4 9 14 17 10 9 6 14 8 14 6 15] ->
[8 0 3 2 1 7 5 2 0 1 4 1 0 6]

[15] ->
[0]

[1 18 4 8 6 19 12 17 6 13 7 6 8 1 6] ->
[1 8 3 2 0 9 5 7 0 6 4 0 2 1 0]

[9 10 11 9 7 11 16 17 11 8 7] ->
[2 4 0 2 1 0 5 6 0 3 1]

[1 3 16 19 14] ->
[0 1 3 4 2]

[18 8] ->
[1 0]

[13 4 9 6] ->
[3 0 2 1]

[16 16 18 6 12 10 4 6] ->
[1 1 5 0 4 3 2 0]

[11 18] ->
[0 1]

[14 18 18 11 9 8 13 3 3 4] ->
[7 1 1 5 4 3 6 0 0 2]

[20 19 1 1 13] ->
[3 2 0 0 1]

[12] ->
[0]

[1 14 20 4 18 15 19] ->
[0 2 6 1 4 3 5]

[13 18 20] ->
[0 1 2]

[9 1 12 2] ->
[2 0 3 1]

[15 11 2 9 10 19 17 10 19 11 16 5 13 2] ->
[7 2 0 5 1 3 9 1 3 2 8 4 6 0]

[5 4 2 2 19 14 18 11 3 12 20 14 2 19 7] ->
[5 4 0 0 2 1 9 7 3 8 10 1 0 2 6]

[9 11 13 13 13 12 17 8 4] ->
[3 4 0 0 0 5 6 2 1]

[10 14 16 17 7 4 3] ->
[3 4 5 6 2 1 0]

[2 4 8 7 8 19 16 11 10 19 4 7 8] ->
[4 1 0 2 0 3 7 6 5 3 1 2 0]

[15 17 20 18 20 13 6 10 4 19 9 15 18 17 5] ->
[0 1 3 2 3 9 6 8 4 10 7 0 2 1 5]

[15 14 4 5 5 5 3 3 19 12 4] ->
[5 4 2 0 0 0 1 1 6 3 2]

[7 12] ->
[0 1]

[18 5 18 2 5 20 8 8] ->
[2 0 2 3 0 4 1 1]

[4 6 10 7 3 1] ->
[2 3 5 4 1 0]

[5] ->
[0]

[6 12 14 18] ->
[0 1 2 3]

[7 15 13 3 4 7 20] ->
[0 4 3 1 2 0 5]

[10 15 19 14] ->
[0 2 3 1]

[14] ->
[0]

[19 10 20 12 17 3 6 16] ->
[6 2 7 3 5 0 1 4]

[9 4 7 18 18 15 3] ->
[4 2 3 0 0 5 1]

[7 4 13 7] ->
[0 1 2 0]

[19 1 10 3 1] ->
[3 0 2 1 0]

[8 14 20 4] ->
[1 2 3 0]

[17 20 18 11 1 15 7 2] ->
[5 7 6 3 0 4 2 1]

[11 4 3 17] ->
[2 1 0 3]

[1 9 15 1 20 8 6] ->
[0 3 4 0 5 2 1]

[16 13 10] ->
[2 1 0]

[17 20 20 12 19 10 19 7 8 5 12 19] ->
[7 2 2 1 0 6 0 4 5 3 1 0]

[18 11] ->
[1 0]

[2 16 7 12 10 18 4 14 14 7 15 4 8 3 14] ->
[3 9 2 7 6 10 1 0 0 2 8 1 5 4 0]

[5 7 2 2 16 14 7 7 18 19 16] ->
[3 0 1 1 2 4 0 0 5 6 2]

[8 6 17 5 10 2 14] ->
[3 2 6 1 4 0 5]

This is code-golf, so the shortest valid submission (counted in bytes) wins.

Related: Check if words are isomorphs

Python 2, 62 54 bytes
lambda L:map(sorted(set(L),key=L.count)[::-1].index,L)

Try it online!
Edit: saved 8 bytes via map thanx to Maltysen

less bytes: lambda L:map(sorted(set(L),key=L.count)[::-1].index,L)

Pyth - 12 11 10 bytes
XQ_o/QN{QU

Test Suite.

Damn, that was quick! I'd only just managed to figure out what was being asked of us!

You can save a byte with mx_o/QN{Q.

Japt, 11 bytes
£â ñ@è¦XÃbX

Test it online!
Explanation
 £   â ñ@  è¦ XÃ bX
UmX{Uâ ñX{Uè!=X} bX}   Ungolfed
                       Implicit: U = input array
UmX{               }   Map each item X in the input to:
    Uâ                   Take the unique items of U.
       ñX{     }         Sort each item X in this by
          Uè!=X            how many items in U are not equal to X.
                         This sorts the items that occur most to the front of the list.
                 bX      Return the index of X in this list.
                       Implicit: output result of last expression

J, 11 bytes
i.~~.\:#/.~

Try it online!
Explanation
i.~~.\:#/.~  Input: array A
       #/.~  Frequency of each unique character, sorted by first appearance
   ~.        Unique, sorted by first appearance
     \:      Sort down the uniques using their frequencies
i.~          First index in that for each element of A

Röda, 55 bytes
{|l|l|indexOf _,[sort(l)|count|[[-_2,_1]]|sort|_|[_2]]}

Try it online!

Haskell, 93 91 85 bytes
import Data.List
f a=[i|x<-a,(i,y:_)<-zip[0..]$sortOn((0-).length)$group$sort a,x==y]

Try it online!
EDIT: Thanks to @Laikoni for taking off 6 bytes!
Not very short but I can't think of anything else. The idea is to iterate over the array (x<-a) and perform a lookup in a tuple list ((i,y:_)<-...,x==y) that assigns a nonnegative integer to each unique element in the input based on how common it is. That tuple list is generated by first sorting the input, grouping it into sublists of equal elements, sorting that list by the length of the sublists (sortOn((0-).length); length is negated to sort into "descending" order), then finally zipping it with an infinite list incrementing from 0. We use pattern matching to extract the actual element fromm the sublist into y.

You can match on the pattern (i,y:_) and drop the head<$> part and replace the parenthesis by $.

TI-BASIC, 66 bytes
Ans+max(Ans+1)seq(sum(Ans=Ans(I)),I,1,dim(Ans→A
cumSum(Ans→B
SortD(∟A,∟B
cumSum(0≠ΔList(augment({0},∟A→A
SortA(∟B,∟A
∟A-1

Explanation
seq(sum(Ans=Ans(I)),I,1,dim(Ans    Calculates the frequency of each element of Ans.
                                   Comparing a value to a list returns a list of booleans,
                                   so taking the sum will produce the number of matches.

Ans+max(Ans+1)                     Multiplies each frequency by one more than the max element,
                                   then adds each original value.
                                   This ensures that identical values with the same frequency
                                   will be grouped together when sorting.
                                   Additionally, all resulting values will be positive.

→A                                 Stores to ∟A.

cumSum(Ans→B                       Stores the prefix sum of the result into ∟B.
                                   Since ∟A has only positive values, ∟B is guaranteed
                                   to be strictly increasing.

SortD(∟A,∟B                        Sort ∟A in descending order (by frequency), grouping
                                   identical values together. Also, dependently sort ∟B
                                   so the original ordering can be restored.

       0≠ΔList(augment({0},∟A      Prepends a 0 to ∟A and compares each consecutive difference
                                   to 0. This places a 1 at each element that is different
                                   from the previous element, and 0 everywhere else.
                                   The first element is never 0, so it is considered different.

cumSum(                      →A    Takes the prefix sum of this list and stores to ∟A.
                                   Since there is a 1 at each element with a new value,
                                   the running sum will increase by 1 at each value change.
                                   As a result, we've created a unique mapping.

SortA(∟B,∟A                        Sorts ∟B in ascending order with ∟A as a dependent,
                                   restoring the original element ordering.

∟A-1                               Since we started counting up at 1 instead of 0,
                                   subtract 1 from each element in ∟A and return it.

Perl 5, 77 + 1 (-a) = 78 bytes
$c{$_}++for@F;%r=map{$_=>$i++.$"}sort{$c{$b}<=>$c{$a}}keys%c;print$r{$_}for@F

Try it online!

CJam, 17 14 bytes
-3 bytes thanks to Peter Taylor
This is a golfed version of the program I used to generate the testcases.
{_$e`$W%1f=f#}

This is an anonymous block that expects input as an array on top of the stack and outputs an array on top of the stack.
Explanation:
{_$e`$W%1f=f#} Stack:                  [1 2 1 4 5]
 _             Duplicate:              [1 2 1 4 5] [1 2 1 4 5]
  $            Sort:                   [1 2 1 4 5] [1 1 2 4 5]
   e`          Run-length encode:      [1 2 1 4 5] [[2 1] [1 2] [1 4] [1 5]]
     $         Sort lexicographically: [1 2 1 4 5] [[1 2] [1 4] [1 5] [2 1]]
      W%       Reverse:                [1 2 1 4 5] [[2 1] [1 5] [1 4] [1 2]]
        1f=    Second element of each: [1 2 1 4 5] [1 5 4 2]
           f#  Vectorized indexing:    [0 3 0 2 1]

You can sort in reverse order for only three bytes by splitting it up: $W%.

@PeterTaylor Ah, I keep forgetting lexicographic comparison for arrays is a thing. Thanks.

Mathematica, 94 bytes
(s=First/@Reverse@SortBy[Tally[j=#],Last];For[i=1,i<=Length@s,j=j//.s[[i]]->i+5!;i++];j-5!-1)&

Try it online!

JavaScript (ES6), 91 bytes
Using a list of unique values, sorted by frequency.
x=>x.map(x=>Object.keys(C).sort((a,b)=>C[b]-C[a]).indexOf(x+''),C={},x.map(v=>C[v]=-~C[v]))

Test

var F=
x=>x.map(x=>Object.keys(C).sort((a,b)=>C[b]-C[a]).indexOf(x+''),C={},x.map(v=>C[v]=-~C[v]))

Test=`[1 2 1 4 5] -> [0 1 0 2 3]
[3 2 2 1 5 7 2] -> [1 0 0 2 3 4 0]
[8 8 8 8 8] -> [0 0 0 0 0]
[2] -> [0]
[8 6 8 4 6 8 2 4 6 8 0 2 4 6 8] -> [0 1 0 2 1 0 3 2 1 0 4 3 2 1 0]
[14 1] -> [1 0]
[19 6 4 9 14 17 10 9 6 14 8 14 6 15] -> [8 0 3 2 1 7 5 2 0 1 4 1 0 6]
[15] -> [0]
[1 18 4 8 6 19 12 17 6 13 7 6 8 1 6] -> [1 8 3 2 0 9 5 7 0 6 4 0 2 1 0]
[9 10 11 9 7 11 16 17 11 8 7] -> [2 4 0 2 1 0 5 6 0 3 1]
[1 3 16 19 14] -> [0 1 3 4 2]
[18 8] -> [1 0]
[13 4 9 6] -> [3 0 2 1]
[16 16 18 6 12 10 4 6] -> [1 1 5 0 4 3 2 0]
[11 18] -> [0 1]
[14 18 18 11 9 8 13 3 3 4] -> [7 1 1 5 4 3 6 0 0 2]
[20 19 1 1 13] -> [3 2 0 0 1]
[12] -> [0]
[1 14 20 4 18 15 19] -> [0 2 6 1 4 3 5]
[13 18 20] -> [0 1 2]
[9 1 12 2] -> [2 0 3 1]
[15 11 2 9 10 19 17 10 19 11 16 5 13 2] -> [7 2 0 5 1 3 9 1 3 2 8 4 6 0]
[5 4 2 2 19 14 18 11 3 12 20 14 2 19 7] -> [5 4 0 0 2 1 9 7 3 8 10 1 0 2 6]
[9 11 13 13 13 12 17 8 4] -> [3 4 0 0 0 5 6 2 1]
[10 14 16 17 7 4 3] -> [3 4 5 6 2 1 0]
[2 4 8 7 8 19 16 11 10 19 4 7 8] -> [4 1 0 2 0 3 7 6 5 3 1 2 0]
[15 17 20 18 20 13 6 10 4 19 9 15 18 17 5] -> [0 1 3 2 3 9 6 8 4 10 7 0 2 1 5]
[15 14 4 5 5 5 3 3 19 12 4] -> [5 4 2 0 0 0 1 1 6 3 2]
[7 12] -> [0 1]
[18 5 18 2 5 20 8 8] -> [2 0 2 3 0 4 1 1]
[4 6 10 7 3 1] -> [2 3 5 4 1 0]
[5] -> [0]
[6 12 14 18] -> [0 1 2 3]
[7 15 13 3 4 7 20] -> [0 4 3 1 2 0 5]
[10 15 19 14] -> [0 2 3 1]
[14] -> [0]
[19 10 20 12 17 3 6 16] -> [6 2 7 3 5 0 1 4]
[9 4 7 18 18 15 3] -> [4 2 3 0 0 5 1]
[7 4 13 7] -> [0 1 2 0]
[19 1 10 3 1] -> [3 0 2 1 0]
[8 14 20 4] -> [1 2 3 0]
[17 20 18 11 1 15 7 2] -> [5 7 6 3 0 4 2 1]
[11 4 3 17] -> [2 1 0 3]
[1 9 15 1 20 8 6] -> [0 3 4 0 5 2 1]
[16 13 10] -> [2 1 0]
[17 20 20 12 19 10 19 7 8 5 12 19] -> [7 2 2 1 0 6 0 4 5 3 1 0]
[18 11] -> [1 0]
[2 16 7 12 10 18 4 14 14 7 15 4 8 3 14] -> [3 9 2 7 6 10 1 0 0 2 8 1 5 4 0]
[5 7 2 2 16 14 7 7 18 19 16] -> [3 0 1 1 2 4 0 0 5 6 2]
[8 6 17 5 10 2 14] -> [3 2 6 1 4 0 5]`

Test.split(`\n`).forEach(row => {
  row=row.match(/\d+/g)
  var nv = row.length/2
  var tc = row.slice(0,nv)
  var exp = row.slice(nv)
  var xsum = eval(exp.join`+`)
  var result = F(tc)
  var rsum = eval(result.join`+`)
  var ok = xsum == rsum
  console.log('Test ' + (ok ? 'OK':'KO')
  + '\nInput [' + tc
  + ']\nExpected (sum ' + xsum + ') ['+ exp
  + ']\nResult (sum ' + rsum + ') [' + result + ']')

})

Jelly, 10 bytes
Qċ@Þ⁸UiⱮµ’

Try it online!
I'm certain there's a way to remove at least one byte, but I've spend an hour not finding it so...
How it works
Qċ@Þ⁸UiⱮµ’ - Main link. Takes A on the left
Q          - Remove duplicates in A
   Þ       - Sort by the following function:
 ċ         -   Number of times...
  @ ⁸      -   ...in A
     U     - Reverse. Call this l
       Ɱ   - Over each element in A...
      i    -   Find its index in l
        µ’ - Decrement to account for Jelly's 1-indexing

R, 58 bytes
x=scan();cat(match(x,names(z<-table(x))[rev(order(z))])-1)

Try it online!
Port of Chas Brown's Python answer.
table computes the counts of each element in x (storing the values as the names attribute), order returns a permutation of the indices in z, and match returns the index of the first match of x in names(z). Then it subtracts 1 because R indices are 1-based.

PHP, 92 bytes
$b=array_unique($a);print_r(array_map(function($v)use($b){return array_search($v,$b);},$a));

Try it online!

all_licenses: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/3.0/

all_licenses: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/4.0/


text:
Save humanity from annihilation
Aliens have arrived, and they aren't friendly.
Turns out, they've been in the process of converting all matter in the universe into compute capability so they can have more fun in their VR simulations.
Our solar system is the last bit of space they haven't converted yet, and they're about to remedy this oversight.
However! As "payment" for the use of our matter, the aliens are generously allowing us to run one computation on their universe-sized compute cluster before they convert us to compute units.
After world leaders conferred on how to handle this crisis, you were tasked with creating an algorithm to run on the alien cluster which will not complete before the heat death of the universe, thus forestalling our demise.
However, internally the aliens charge back the cost of using the cluster by the number of bytes of code submitted, so the alien philanthropy division which is making us this generous offer and footing the bill is incentivizing us to keep our code short by glassing one of our cities (in descending population order) for every byte of code we submit. Thus, your orders are to code-golf the algorithm to as few bytes as possible.
Submission Rules
The aliens are smart. They will not allow you to submit code which you cannot prove complies with the following properties:

Must halt, eventually™. The burden of proving this is on you. (Yes, the halting problem is impossible in the general case. Pick one where it isn't.)
Must meaningfully utilize the entire cluster. If any cores would be idle or doing unnecessary computation for over half of the total runtime of the algorithm, the aliens will reject the algorithm (unnecessary means that the result would not change if that computation were skipped. Feel free to compute things in all manner of inefficient fashion).
Must produce a result which will fit in the combined storage capacity of all human computers (assume one zettabyte is available) so we can appreciate the resulting data before we are annihilated. Write the result to stdout.
Must produce a result that is deterministic (so take no input) and at least a little bit mathematically interesting (determining if the googolplexth digit of pi is odd is interesting; producing 42 is not).

To satisfy your bosses (the world leaders) your program must not halt until after the heat death of the universe (10¹⁰⁰ years from now).
System Specifications
The alien cluster is abstracted behind an API which makes it seem like a single enormous SMT x86_512 CPU.

Every atom in the universe besides ours (10⁸⁰) functions as a 512 bit CPU core running at 900 petahertz
Due to black holes, there is infinite zero-latency non-volatile RAM available for use during the computation, but you are still limited to the 512 bit address space (that's just under 8×10¹⁶³ yottabytes of space) and the end product has to fit within one ZB.
Wormholes are used to address cache coherency and atomicity issues with zero latency, as long as the appropriate language-level features are used to indicate their necessity

Answer Validation
Regrettably, I have neither access to a comparable system for testing submissions, nor the patience to see if they do in fact take until the heat death of the universe to halt. Thus, the following will be expected of a submission (please number them in your answers):

An English-language overview of what your algorithm computes, how it works, and why the output is mathematically interesting.
An ungolfed and scaled-down version of your problem/algorithm which can run to completion in seconds or less on normal human hardware (such as ideone). This is not scored, but used to demonstrate that you have a working algorithm.
The golfed solution you want to submit to the aliens. This is what bytes will be scored on / cities glassed.
An explanation of the modifications taken to increase the runtime of your 2. code to the runtime of your 3. code.
An argument for why neither the aliens nor your bosses will reject your submission. Some hand-waving is allowed here, though formal proofs earn major kudos. At a minimum, show some math relating to your loops or recursion depth against the clock speed and core count of the alien system, along with commentary on your work-breakdown strategy to saturate all the cores.

There are no programming language restrictions, as long as the resulting program can meet the constraints of the challenge. Minor kudos for use of language-level features (such as size_t) which can run through the aliens' 512 bit compiler without requiring any work on their end.

Does a backstory involving aliens and a large cluster really make a case for adding new tags? Looks like site-clutter to me.

@JonathanAllan Removed.

Yet the new tags still exist - probably only mods who can delete those.

Can we theoretically extend size of integers or doubles in some languages which have constant-sized numerical variables? For example in JavaScript integer is 32-bit by spec definition no matter if you're running it on 32-bit or 64-bit machine.

@ThePirateBay Yes, that is allowed. Be sure to point out any language level changes in part 4 of your answer.

I think the conditions are much too vague and the competition will largely be in justifying being somewhat mathematically interesting and meaningfully using many threads.


text:
No co-prime neighbors
Given a list of positive integers, output whether every adjacent pair of integers in it shares a prime factor. In other words, output truthy if and only if no two neighboring integers in the list are co-prime.
In yet other terms: given a list of positive integers [a1 a2 … an], output whether
　　　　　　　gcd(a1, a2) > 1 && gcd(a2, a3) > 1 && … && gcd(an−1, an) > 1.
The list will always contain at least two elements (n ≥ 2).
However…
This challenge is also restricted-source: the codepoints in your answer (whatever codepage it may be in) must satisfy the condition your program checks for.
For example, print 2 is a valid program. As a list of Unicode codepoints it is [112 114 105 110 116 32 50], which satisfies this condition: 112 and 114 share a factor of 2; and 114 and 105 share a factor of 3, etc.
However, main can not occur in a valid program (sorry!), as the Unicode codepoints of m and a, namely 109 and 97, are coprime. (Thankfully, your submission needn’t be a full program!)
Your program isn’t allowed to contain codepoint 0.
Test cases
Truthy:
[6 21] -> 1
[502 230 524 618 996] -> 1
[314 112 938 792 309] -> 1
[666 642 658 642 849 675 910 328 320] -> 1
[922 614 530 660 438 854 861 357 477] -> 1

Falsy:
[6 7] -> 0
[629 474 502 133 138] -> 0
[420 679 719 475 624] -> 0
[515 850 726 324 764 555 752 888 467] -> 0
[946 423 427 507 899 812 786 576 844] -> 0

This is code-golf: the shortest code in bytes wins.

For anyone attempting this challenge in a normal programming language, this is a list of characters that have prime codepoints in ASCII: %)+/5;=CGIOSYaegkmq\DEL.

@Lynn Do Truthys have to be consistent?

@H.PWiz Nope! —

I actually intended this to be doable for some normal (non-golf) langs, and I was feeling hopeful when I noticed that print 2 was valid, but );=ae being prime is really tough, I didn’t consider that… I wonder if something like Haskell can compete?

This restriction is easier than the reverse of this question, assume no-one use 0x02 byte. That question get nongolf valid answer in Mathematica, Logo, Haskell, Python, Perl, TI-BASIC. This one already got a Haskell, I think Mathematica is impossible, but Logo looks very likely to be possible, although I've not yet done constructing the solution.

@user202729 In the end, the Logo solution turns out to be too tedious to write (similar to JSF), and certainly not very golfy.

MATL, 14 bytes
!TM1*Zdl2$Xdl-

This outputs a non-empty column vector of nonzero numbers as truthy, or a vector containing at least a zero entry as falsy.

Try it online!
Verify all test cases. The footer code contains an if branch to test truthyness/falsyness.
Since MATL uses ASCII, the source code is encoded as
[33 84 77 49 42 90 100 108 50 36 88 100 108 45]

which satisfies the requirement.

Explanation
!     % Implicit input. Transpose
TM    % Push input to latest function again
1*    % Multiply by 1 (does nothing, but matches factors)
Zd    % Compute gcd with broadcast: matrix of gcd of all pairs
l     % Push 1
2$    % The next function will use 2 inputs
Xd    % Extract diagonal 1 (i.e. that below the main diagonal) from the matrix
l-    % Subtract 1 from each entry. Implicitly display

Congratulations on an answer which does satisfy the [tag:restricted-source] requirement!

Haskell, 103 100 bytes
EDIT:

-3 bytes: Used a d<-fz guard to merge and shorten the last two lines.

f is the main function, which takes a list of integers and returns a Bool.
Note that the first two ԁs (only) are Cyrillic (Komi) Unicode characters, and there's a tab character before the first one.
f	ԁ=zb[ԁ]id
zb[h:p:l]fz=z h p&&zb[p:l]fz
zb l fz=z 0 2
z 0z=z>z^0
z f fz|f<fz=z fz f|d<-fz=z d$f-d

Try it online!
or test it on itself.
How it works

f is the main function. All it does is wrap its argument ԁ in a singleton list (because the prime ASCII value of ) makes parentheses much more awkward to use than square brackets) and call zb with that and a dummy argument (the Haskell function id happens to have just the right characters to fit here).

Getting the same character to fit besides both of =] is impossible with plain ASCII, so the argument is named with the 2-byte Unicode character CYRILLIC SMALL LETTER KOMI DE (ԁ), codepoint value 3*7*61=U+0501, which fits with all of those and [.

Since the codepoint is not even (the smallest option that is a legal identifier and also even uses three bytes), this required using a tab character instead of a space before it.
A seven bytes longer plain ASCII option is to rename the argument: f fz|bf<-fz=zb[bf]fz.

zb takes two arguments, a singleton list whose element is the real list of numbers being recursed on, and a dummy argument fz needed only to get a z before the function's =s.

When the inner list has at least two elements, the function z is called with the first two (named h and p), and if that returns True, zb recurses on the tail p:l of the list.
If the inner list has fewer than two elements, zb returns True. Since = needs to be followed by the character z, the simplest way to do this is to use a call of the z function that itself is known to return True.

z takes two arguments and recursively calculates their greatest common divisor using subtraction (every other relevant integer division or gcd function is unavailable), returning True if it's greater than one.

The recursion ends when the first argument is 0, with the second argument being the gcd. On this line the second argument is also named z. The character 1 is awkward here so z^0 is used to get the number one.
Otherwise, if the first argument f is smaller than the second fz, they are swapped and z recurses.
Otherwise, the smaller argument is subtracted from the larger, then z recurses (also swapping the arguments, although that's just to avoid parentheses.)

I knew there had to be some non-golf language that could pull it off!

@Lynn It really helps Haskell in this kind of challenge that it has a fairly expressive syntactic subset with just single-character tokens. Which is about halfway to a golfing language, I guess.

Because of the Cyrillic, is this really 100 bytes? The Code Golf Graduation userscript reports 102 UTF-8 bytes, but I don't know if it's accurate/that's the right way to count the bytes here. No matter how many bytes, it's really impressive!

@MarkS. TIO reports 100 bytes (and 98 chars). I suspect you got caught out by the tab character, which SE displays as 3 spaces (which then gets copied as such). I think I've seen someone use pre tags to avoid that, let me try to fix it.

@MarkS. Done. Although I suspect that might just confuse that userscript even more.

Husk, 8 bytes
For Truthy inputs it returns a positive integer, for Falsy it returns 0
←▼`Ṡt(ż⌋

Try it online! and Tested on its own codepoints
Uses Husk's codepage
Source -- [ ←  , ▼  , `  , Ṡ  , t  , (  , ż  , ⌋  ]
Hex    -- [0x06,0xbd,0x60,0xd0,0x74,0x28,0xeb,0x8d]
Dec    -- [6   ,189 ,96  ,208 ,116 ,40  ,235 ,141]

Explanation
          -- implicit input, e.g                                  [63,36,18,3]
  `       -- flip the args of the next function
   Ṡ      -- some combinator (Ṡ f g x = f (g x) x)
    t     -- tail                                                 [36,18,3]
      ż   -- zipWith (note, keeps trailing elems of longer list)  [(63,36),(36,18),(18,3),(3)]
       ⌋  -- gcd                                                  [9,9,3,3]
     (    -- used just to match restricted source criteria
 ▼        -- minimum of the list                                    3
←         -- minus 1                                                2

What is the notation called you use in the explanation for Ṡ? I see it on the docs too in the "type" column on the commands page and can't get my head around it so want to look it up so I might be able to learn it.

@JonathanAllan That's the definition of the function Ṡ in Haskell's syntax. It translates roughly to Ṡ(f,g,x) = f(g(x),x) in more mainstream languages.

source link

Although, when flipped, it becomes \Ṡ g f x = Ṡ f g x = f (g x) x`

Right, so I'd need to learn Haskell. The x you refer to above is the input then? ...and it is on the left of the Ṡ?

The x is the input, It is on the right of Ṡ, its third argument

I'm confused, the third (ignoring the parenthesis) is the gcd atom, no?

No, the first is t, the second is ż⌋. The second is not ż because the second arg of \Ṡmust have the type(x -> y -> z)`

@JonathanAllan If you join the Husk chatroom, we can try to explain it better there.

05AB1E, 8 bytes
Code
ü‚ÒüÃP≠P

Uses the 05AB1E encoding, which gives us the following list of code points:
hex: [0xFC, 0x82, 0xD2, 0xFC, 0xC3, 0x50, 0x16, 0x50]
dec: [252,  130,  210,  252,  195,  80,   22,   80]

Try it online! or Verify the source code!
Explanation
Since the gcd operator (¿) has a prime code point I had to look for other ways to check coprimality:
ü‚          # Get an array of adjacent pairs of the input
  Ò         # Factorize both elements of each pair in the array
   üÃ       # For each pair, get the intersection of both prime factorization lists
     P      # Product of each intersection (this leaves 1 when there is no intersection)
      ≠     # Check for each element whether it does not equal 1
       P    # Product of the booleans

What code points does this have in 05AB1E's code page? Can you add them into the answer?

@Mr.Xcoder added

Any reason for Ò over f?

TI-BASIC, 38 bytes
Input L1:ΔList(cumSum(L1:augment(Ans+V,V+{0:2>sum(AnsL1=lcm(Ans+V,V+L1

TI-BASIC is tokenized into one- or two-byte tokens, as listed here.
The trickiest parts of this solution were:

The comma token is a prime number (43), forcing me to surround it with multiples of 43 (in this case the V token, which is 86).
The gcd( token is a large prime number (47881), which means it couldn't be used at all.

The tokens for this program come out to:
token     hex     dec
Input     0xDC    220
L1        0x5D00  23808
:         0x3E    62
ΔList(    0xBB2C  47916
cumSum(   0xBB29  47913
L1        0x5D00  23808
:         0x3E    62
augment(  0x14    20
Ans       0x72    114
+         0x70    112
V         0x56    86
,         0x2B    43
V         0x56    86
+         0x70    112
{         0x08    8
0         0x30    48
:         0x3E    62
2         0x32    50
>         0x6C    106
sum(      0xB6    182
Ans       0x72    114
L1        0x5D00  23808
=         0x6A    106
lcm(      0xBB08  47880
Ans       0x72    114
+         0x70    112
V         0x56    86
,         0x2B    43
V         0x56    86
+         0x70    112
L1        0x5D00  23808

Explanation
Input L1:                   Prompt the user to input L1.

ΔList(cumSum(L1:            Take the differences of the prefix sum of L1,
                            which in effect removes the first element (result in Ans).

augment(Ans+V,V+{0:         Append a 0 to the end of Ans.
                            V defaults to 0, so adding it is a no-op.
                            Ans now holds L1 shifted to the left by one element,
                            with a 0 shifted in.

      AnsL1=lcm(Ans+V,V+L1  Take the least common multiple of each corresponding element
                            of Ans and L1, and check if each is equal to their product.
                            This returns a list of booleans, each 1 corresponding to
                            a co-prime pair. The last element (having been paired with 0)
                            will always be 1.

2>sum(                      Returns 1 if there is at most one 1 in the list, else 0.
                            Since the last element is always 1, this means
                            we return 1 only if there are no co-prime pairs.

Japt, 8 7 bytes
äj d¹¥Z

Test it online!
Code points:
Char    ä   j       d   ¹   ¥   Z
Hex    e4  6a  20  64  b9  a5  5a
Dec   228 106  32 100 185 165  90

Explanation
 äj d¹ ¥ Z
Uäj d) ==Z
             Implicit: U = input array, Z = 0
Uä           For each pair of items in the array:
  j            Return whether the two items are coprime.
    d)       Return true if any items are truthy, false otherwise.
       ==Z   Return whether this is equal to 0 (false -> true, true -> false).
             Implicit: output result of last expression

Jelly, 11 9 bytes
,Pnælð2\P

Saved 2 bytes thanks to @Jonathan Allan.
Try it online!
Jelly has its own code-page and the codepoints of each character are
Chr Hex Dec
,   2c   44
P   50   80
n   6e  110
æ   16   22
l   6c  108
ð   18   24
2   32   50
\   5c   92
P   50   80

This tests for non-coprime numbers by checking if lcm(a, b) != a*b. There might be a shorter solution as I just filtered for characters with even codepoints.
Explanation
,Pnælð2\P  Input: array A
      2\   For each overlapping sublist of size 2
     ð       Reduce it using this dyad
,              Pair
 P             Product
  n            Not equals, 1 if true else 0
   æl          LCM
        P  Product

Genius! This is incredible :O

, is even so you can do æln,P¥ð2\ for two less. Edit: I dropped the trailing P, make that one less :p)

Oh yeah, swap the arguments even :)

Pyth, 15 bytes
&F.bPiFNP.TtBQQ

Try it here or Check out Test Suite.
This is a collaborative effort between Erik the Outgolfer and Mr. Xcoder. Returns an inconsistent value (non-empty list) for truthy, and the empty list for falsy.

ASCII-values
[38, 70, 46, 98, 80, 105, 70, 78, 80, 46, 84, 116, 66, 81, 81]

Which share the following factors:
[2, 2, 2, 2, 5, 35, 2, 2, 2, 2, 4, 2, 3, 81]

Explanation
&F.bPiFNP.TtBQQ
           tBQ   Return [Q, Q[1:]] (Q = eval first line of input)
         .T      Transpose ^ without cropping absences
        P        Remove last element of ^
  .b          Q  Map in parallel on ^ (N) and Q (Y, ignored)
     iFN           GCD of N
    P              Prime factors of ^ (P(1) = [])
&F               Left fold (reduce) the result of the map with Logical AND (short-circuiting)

Without the restricted-source requirement, this would've been a 7 5-byte version accomplishing the same task (-2 thanks to FryAmTheEggman):
-1iVt

Explanation
-1iVtQQ  Implicit QQ at the end
    tQ   Return Q[1:]
  iV  Q  Vectorized GCD on ^ and Q
-1       Remove every element of ^ from [1] (implicit singleton)

Out of curiosity, why do you need the Qs at the end?

@ETHproductions Because .b has variable arities, and using implicit input means it will pick the lowest (1) instead of then intended (2).

Vyxal 3 g, 5 bytes
ϩĠ∑ȧv

Try it Online!
I could save a byte with codepoint zero... Outputs 0 if falsy, any other number is truthy in vyxal


text:
Happy New Year 0409!
The date 0409·01·MO is New Year’s Day in the Ceres Calendar. Wish everyone and everything in the Asteroid Belt, Jupiter, Saturn and beyond a belated Happy New Year by writing a program to convert Julian Dates (JD) to Ceres Dates using these helpful landmarks:
                                                JD           CMJD      Ceres Date (& Time*)  ISO 8601 (approx.)
Start of Ceres calendar                     2309103.500         0.000   0000·01·MO 00:00     1610
Start of JD calendar                              0.000  -2309103.500  -6344·17·MO           4713 BCE
Earliest recorded eclipse                    501822.000  -1807281.500  -4966·49·SU           3339 BCE
Battle of Megiddo                           1189360.000  -1119743.500  -3077·41·FR           1456 BCE
Battle of Halys                             1507900.000   -801203.500  -2202·47·WE            584 BCE
Alexander the Great (b)                     1591596.000   -717507.500  -1972·43·SU            355 BCE
Crab Nebula supernova                       2106216.000   -202887.500  -0558·33·MO           1054
Discovery of Galilean moons                 2309107.000         3.500   0000·01·TH           1610
Discovery of Titan by Huygens               2325616.000     16512.500   0045·19·SU           1655
Discovery of Uranus by Herschel             2371629.000     62525.500   0171·41·TU           1781
Discovery of Ceres by Piazzi                2378862.000     69758.500   0191·34·TH           1801
Discovery of Pallas by Olbers               2379313.000     70209.500   0192·46·SU           1802
Discovery of Juno by Harding                2380201.000     71097.500   0195·17·SA           1804
Discovery of Vesta by Olbers                2381140.000     72036.500   0197·47·SU           1807
Discovery of Astraea by Hencke              2395274.000     86170.500   0236·39·MO           1845
Discovery of Neptune by Galle & Le Verrier  2395563.000     86459.500   0237·28·WE           1846
First Nobel Prizes awarded                  2415729.000    106625.500   0292·49·TU           1901-12-10
Archduke Franz Ferdinand (d)                2420312.000    111208.500   0305·27·SU           1914-06-28
Discovery of Pluto by Tombaugh              2426054.000    116950.500   0321·16·TU           1930-03-18
Hiroshima bombing                           2431673.469    122569.969   0336·38·SU 23:15     1945-08-05
Dawn probe started exploration of Ceres     2457088.028    147984.528   0406·29·FR 12:40     2015-03-06
Gravitational waves first detected by LIGO  2457279.910    148176.410   0407·05·MO 09:50     2015-09-14
New Year’s Day 0409                         2457980.000    148876.500   0409·01·MO 12:00     2017-08-14

CMJD stands for Ceres Modified JD, a convenient offset. CMJD is related to JD by the formula:
CMJD = JD - 2309103.5

The Ceres Calendar has 52 weeks (01 - 52) of seven days, with Monday (MO) as the first day of the week, the rest are TU, WE, TH, FR, SA, & SU and the time synchronized to UTC formatted as HH:MM or HH:MM:SS. There are no leap days in the Ceres Calendar.
* The Ceres Dates lacking times are only known to the day, so as a convention the middle of the day 12:00 is chosen as the time. Displaying 12:00 for these cases is perfectly acceptable.
Note that the Calendar starts on the Monday before Galileo discovered his satellites, that’s to have the start of the calendar on a Monday to correspond to the ISO 8601 start of the week. The discovery of the Galilean Satellites is more important to them than the Discovery of Ceres but not so important as to mess up the start of the week or the start of the year! That’s just how they roll!
Your program must convert JD ≥ 0.000 to Ceres Date in the format above, using - (U+2212 MINUS SIGN) and · (U+00B7 MIDDLE DOT) as required. Especially for those using ASCII-only languages, you can substitute ~ (U+007E TILDE) and * (U+002A ASTERISK) for the minus sign and middle dot, respectively. The format for dates beyond 9999·52·SU is undefined.
Here’s a handy page to convert to Julian Dates and lots of other useful information.
This is code-golf, so shortest answer in bytes wins.

Bonus points for doing it in Ceres: TIO

"with seven days" lists only six EDIT: I see SU in the landmarks list, so must be that that is missing.

The requirement for a subtraction sign is rather strange for a negative number, hyphen-minus (U+002D) would be more appropriate.

@JonathanAllan - thanks for catching missed SU, and apparently the dedicated MINUS SIGN is “more correct” for subtraction operations and negative numbers!

I agree that "The difference is significant", but I would say the opposite: using the minus sign as a negative sign looks clunky and awkward (the left table looks far nicer to me); no mater though.

The Unicode characters also mean that languages which only handle ASCII can't compete. That seems unfair, when comparable ASCII characters exist.

@Notatree - Have added provisions to allow substitutions of ~ (U+007E TILDE) and * (U+002A ASTERISK) for the minus sign and middle dot, respectively.

I'd suggest 2309103.500  ->  0000·01·MO 00:00 as a test case, as it should specifically not yield −0000·01·MO 00:00.

Also all the ... .000 test cases should yield ... 12:00.

@JonathanAllan - have added a note regarding 12:00.

Jelly, 92 bytes
Definitely beatable by languages with built-in time-formatting or even just better string-formatting.
%1×⁽¢Ẓd60
_“#ḟf’_.µd364Ad0¦7Ẏ;ÇḞ‘2¦ị3¦“TUWETHFRSASUMO”s2¤Ṛ€o0ẋ⁽¡Ḳḃ4¤¤U⁽œọ;“ṢṢ :‘¤Ọ¤żFḊ⁸Ṡ>-¤¡

A full program accepting a single argument (decimal number representation) and printing the result.
Try it online!
How?
%1×⁽¢Ẓd60 - Link 1, get hours and minutes portion of days: number (of days)
%1        - modulo by one - get the fractional part
   ⁽¢Ẓ    - base 250 number = 1440 (that's 60*24)
  ×       - multiply
      d60 - divmod 60 (integer divide by sixty and yield result and remainder)

_“#ḟf’_.µd364Ad0¦7Ẏ;ÇḞ‘2¦ị3¦“TUWETHFRSASUMO”s2¤Ṛ€o0ẋ⁽¡Ḳḃ4¤¤U⁽œọ;“ṢṢ :‘¤Ọ¤żFḊ⁸Ṡ>-¤¡
          - Main link: number, JulianDate -- breaking this down into parts...

_“#ḟf’_.µ - Main link part 1 (get the CMJD): number, JulianDate
 “#ḟf’    - base 250 number = 2309103
_         - subtract from JulianDate
      _.  - subtract a half
        µ - monadic chan separation, call that CMJD

d364Ad0¦7Ẏ;ÇḞ‘2¦ - Main link part 2 (get the numeric parts): number, CMJD
d364             - divmod 364 (integer divide by 364 and yield result and remainder)
    A            - absolute value (removes the sign from the year part)
       ¦         - sparse application:
      0          - ...to index: zero (rightmost - the remainder)
     d  7        - ...action: divmod 7 (integer divide by 7 and yield result and remainder)
         Ẏ       - tighten (to a list of three items)
           Ç     - call the last link (1) as a monad with argument CMJD
          ;      - concatenate (now we have floats [abs(Y.0), W.0, D.0, H.0, M.x])
            Ḟ    - floor (vectorises) (yielding ints [abs(Y), W, D, H, M]
               ¦ - sparse application:
              2  - ...to index: 2 (W)
             ‘   - ...action: increment (CD weeks are 1-indexed, W is 0 indexed)

ị3¦“TUWETHFRSASUMO”s2¤ - Main link part 3 (make the day-string): result of part 2
  ¦                    - sparse application:
 3                     - ...to index: 3 (D)
ị                      - ...action: index into:
                     ¤ -   nilad followed by link(s) as a nilad:
   “TUWETHFRSASUMO”    -     list of characters = "TUWETHFRSASUMO"
                   s2  -     split into chunks of length two
                       -     (note: D=0 yields "MO" due to 1-based & modular indexing)

Ṛ€o0ẋ⁽¡Ḳḃ4¤¤U - Main link part 4 (pad parts with zeros): result of part 3
Ṛ€            - reverse each (implicit decimal-list, so reverse of 289 is [9,8,2])
           ¤  - nilad followed by link(s) as a nilad:
   0          -   zero
          ¤   -   nilad followed by link(s) as a nilad:
     ⁽¡Ḳ      -     base 250 number = 1178
        ḃ4    -     convert to bijective-base 4 = [4,2,1,2,2]
    ẋ         -   repeat = [[0,0,0,0],[0,0],[0],[0,0],[0,0]]
  o           - logical or (vectorises) (yielding the reversed zero padded entries)
            U - upend (reverse each - everything is already a list so not Ṛ€)
              -   now we have something like: [[Ya,Yb,Yc,Yd],[Wa,Wb],['Da','Db'],[ha,hb],[ma,mb]]

⁽œọ;“ṢṢ :‘¤Ọ¤ż - Main link part 5 (include the separators): result of part 4
            ¤  - nilad followed by link(s) as a nilad:
          ¤    -   nilad followed by link(s) as a nilad:
⁽œọ            -     base 250 literal = 8722
    “ṢṢ :‘     -     code-page indices = [183,183,32,58]
   ;           -     concatenate = [8722,183,183,32,58]
           Ọ   -   covert ordinals to characters = "−·· :"
             ż - zip with the result from part 4, i.e. [['−',[Ya,Yb,Yc,Yd]],['·',[Wa,Wb]],['·',['Da','Db']],[' ',[ha,hb]],[':',[ma,mb]]]

FḊ⁸Ṡ>-¤¡ - Main link part 6 (remove the sign if need be): result from part 5
F        - flatten the result from part 5 into a single list: ['−',Ya,Yb,Yc,Yd,'·',Wa,Wb,'·','Da','Db',' ',ha,hb,':',ma,mb]
       ¡ - repeat:
 Ḋ       - ...action: dequeue (remove first element)
      ¤  - ...number of times: nilad followed by link(s) as a nilad:
  ⁸      -   chain's left argument = CMJD
   Ṡ     -  sign (-1 if less than 0, 0 if equal to 0, 1 if greater than 0)
    >-   -  greater than -1?
         - implicit print

92 bytes 0.o this isn't the Jelly I'm used to

Me neither, many things lacking really: not just the (mentioned) time formatting and string formatting, but also mixed-radix conversion which is the reason for repeatedly using sparse application of divmod here.

TUWETHFRSASUMO - TUESDAY! WEDNESDAY! THURSDAY! FRIDAY! SATURDAY! SUMO! SUMO! SUMO!

Funnily enough I tried using dictionary compressions, and the word sumo, but can't actually get fewer bytes (need to uppercase it usually for 2 bytes). Mmmm Satsumos.

Ruby, 120 bytes
Despite being a language with built-in time formatting and string formatting, I still can't beat the Jelly answer...
->n{n-=2309103.5;Time.at((n%7+4)*86400).strftime('%04d·%02d·%%^a %%H:%%M'%[n/364,n%364/7+1]).sub(/. /,' ').tr ?-,?−}

Try it online!

license: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/4.0/


text:
Easy binary triangle
Given as input a positive integer n>=1, output the first n rows of the following triangle:
                  1
                1 0 1
              0 0 1 0 0
            1 1 1 0 1 1 1
          0 0 0 0 1 0 0 0 0
        1 1 1 1 1 0 1 1 1 1 1
      0 0 0 0 0 0 1 0 0 0 0 0 0
    1 1 1 1 1 1 1 0 1 1 1 1 1 1 1
  0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0
1 1 1 1 1 1 1 1 1 0 1 1 1 1 1 1 1 1 1

The rows alternate between all zeroes and all ones, except the center column is flipped.
Test cases

Input: 3
Output:
    1
  1 0 1
0 0 1 0 0

Input: 10
Output:
                  1
                1 0 1
              0 0 1 0 0
            1 1 1 0 1 1 1
          0 0 0 0 1 0 0 0 0
        1 1 1 1 1 0 1 1 1 1 1
      0 0 0 0 0 0 1 0 0 0 0 0 0
    1 1 1 1 1 1 1 0 1 1 1 1 1 1 1
  0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0
1 1 1 1 1 1 1 1 1 0 1 1 1 1 1 1 1 1 1

Your code must work for any n<100. This is code-golf, hence the shortest code in bytes wins!
Trailing spaces / newlines and leading newlines are allowed!

Is excess white space acceptable and if so, which (leading lines / leading / trailing / training lines)?

I recommend allowing trailing space/newline and leading newline or consistent leading whitespace.

Can we return a a list of lists of numbers?

@StepHen Right, but are you sure that's supposed to be part of the challenge?

@EriktheOutgolfer list of lists is fine!

Since a list of lists is fine, I'm assuming that the centered alignment is not required, is it?

@LuisMendo List of lists is a list of lists, otherwise you must output what you see.Center aligment IS required.

It's your challenge, but in my opinion if you are flexible enough to allow a list of lists it doesn't make any sense to be strict with the formatting

Jelly, 7 bytes
Ṭ=Ḃµ€ŒB

Try it online!
-1 byte thanks to Erik the Outgolfer
Explanation
Ṭ=Ḃµ€ŒB  Main link
    €    For each element in (implicit range of) the input:
Ṭ        List 1s and 0s with 1s in the indices in the left argument (generates `[0, 0, ..., 1]`)
 =Ḃ      Is this equal to `(z % 2)` where `z` is the range number? (Every other row is flipped)
     ŒB  Reflect each row

You can replace ¶Ç with µ for -1.

@EriktheOutgolfer ooh thanks!

Python 2, 50 bytes
lambda n:[i*`i%2`+`~i%2`+i*`i%2`for i in range(n)]

Try it online!
This returns the rows as a list of Strings.
Python 2, 67 65 63 bytes (formatted)
n=input()
for i in range(n):k=i*`i%2`;print(n-i)*" "+k+`~i%2`+k

Try it online!
This outputs with a trailing space on each line.

Jelly, 8 bytes
⁼€=ḂŒḄµ€

Try it online!
-2 thanks to HyperNeutrino.

Oh seriously.... split second ninjad :p

@JonathanAllan It was really a rule change...btw I think this is golfable too...

yeah I had a 15 byte grid then the 10 byte lists...

@JonathanAllan Hyper is being good...

¬^Ḃ can become =Ḃ because NOT (XOR (A B)) is just IFF (A B) edit apparently I golfed more than I thought I had o_O lol

Python 2, 50 bytes
lambda n:[[i%2]*i+[~i%2]+i*[i%2]for i in range(n)]

Try it online!
Python 2, 53 bytes
lambda n:[(([i%2]*i+[~i%2])*2)[:-1]for i in range(n)]

Try it online!
Python 2, 67 bytes
lambda n:[[[i%2,~i%2][j==i]for j in range(2*i+1)]for i in range(n)]

Try it online!

Haha, now we're tied :)

65 bytes (for the longer one)

Japt, 12 9 bytes
õÈÇ¥Y^uÃê

Test it online!
Quite Slightly sad compared to Jelly, but Japt doesn't have anything like Ṭ so I must make do with what I have...
Explanation
 õÈ   Ç   ¥ Y^ uÃ ê
UõXY{XoZ{Z==Y^Yu} ê}      Ungolfed
                          Implicit: U = input number
Uõ                        Create the range [1..U].    [1, 2, 3, 4]
  XY{              }      Map each item X and 0-index Y in this to
     Xo                     Create the range [0..X).  [[0], [0, 1], [0, 1, 2], [0, 1, 2, 3]]
       Z{      }            Map each item Z in this to
         Z==Y                 Z is equal to Y         [[1], [0, 1], [0, 0, 1], [0, 0, 0, 1]]
             ^Yu              XORed with Y % 2.       [[1], [1, 0], [0, 0, 1], [1, 1, 1, 0]]
                  ê         Bounce.                   [[1],
                                                       [1, 0, 1],
                                                       [0, 0, 1, 0, 0],
                                                       [1, 1, 1, 0, 1, 1, 1]]
                          Implicit: output result of last expression

Hooray for builtins :P :P :P

Yaay, someone broke the chain Python-Jelly-Python-Jelly!

@Mr.Xcoder Where Jelly is really implemented in Python. :p

Pyth, 14 bytes
Thanks to @Jakube for saving 2 bytes!
ms_+Bm%d2d%hd2

Try it here!
Pyth, 15 bytes
Thanks a lot to @Jakube for -1 byte
m++K*d]%d2%td2K

Try it here.
Pyth, 16 bytes
m++K*d`%d2`%td2K

Try it here.

Remove the second ] in the first code.

@Jakube Yeah, thanks. Forgot about auto-listification for appending elements to lists.

And here is a 14 bytes solution: ms_+Bm%d2d%hd2

@Jakube Yes, I was thinking of bifurcation right now, but I couldn't do it since I am on mobile. Thanks a lot again!

R, 73 bytes
Thanks to Giuseppe! Nice catch.
n=scan();for(i in 1:n)cat(c(rep(" ",n-i),x<-rep(1-i%%2,i-1)),i%%2,x,"\n")

Try it online!
R, 78 bytes
n=scan();for(i in 1:n)cat(x<-c(rep(" ",n-i),rep(1-i%%2,i-1)),i%%2,rev(x),"\n")

Try it online!
R, 82 bytes
n=scan();for(i in 1:n){j=i%%2;x=c(rep(" ",n-i),rep(1-j,i-1));cat(x,j,rev(x),"\n")}

Try it online!
R, 110 bytes - output to stdout
m=matrix(x<-rep_len(0:1,n<-scan()),n,n-1);m[upper.tri(m,T)]=" ";for(i in 1:n)cat(rev(m[i,]),1-x[i],m[i,],"\n")

Try it online!
R, 130 bytes - output to a file
m=matrix(x<-rep_len(0:1,n<-scan()),n,n-1);m[upper.tri(m,T)]=" ";for(i in 1:n)cat(rev(m[i,]),1-x[i],m[i,],"\n",file="a",append=i>1)

Try it online!
Writing out to a file as I do not know how to fit it in the console if n==99 (see the result here).

I don't think you need to worry about the console wrapping it for larger n's.  Personally I would ditch the ,file="a" as the output to STDOUT is correct.

73 bytes

Mathematica, 77 bytes
Table[CellularAutomaton[51,{{1},0},#,{All,All}][[i]][[#-i+2;;-#+i-2]],{i,#}]&

@Not a tree golfed it down to 48 bytes!
Mathematica, 48 bytes
#&@@@NestList[CellularAutomaton@51,{{1},0},#-1]&

Huh I didn't think of considering it a cellular automata. Nice!

The same thing but golfier: #&@@@NestList[CellularAutomaton@51,{{1},0},#-1]&, 48 bytes

Perl 5, 58 + 1 (-n) = 59 bytes
say$"x(2*--$_).($/=$i%2 .$")x$i.(1-$i%2).$".$/x$i++while$_

Try it online!
# Perl 5, 59 + 1 (-n) = 60 bytes
say$"x(2*--$_).($i%2 .$")x$i.(1-$i%2).($".$i%2)x$i++while$_

Try it online!

05AB1E, 24 21 18 bytes
FNÉN×NÈJûIN>-úˆ}¯»

Try it online!

Edit: Well, it is my first 05AB1E golf so I'm not surprised things can be golfed. Edit history:

18 (see above)

So there is a intersect mirror (both .∞ and û), which eases up things a lot
As do È and É, making 2% and 2%_ a lot shorter

21: FN2%DN×Dr_sJIN>-úˆ}¯»

Removed implicit stuff: IF -> F, )J -> J
baa to aab can be done by .À (rotating) but also by r (reversing) (shorter)

24: IFN2%DN×D.À_s)JIN>-úˆ}¯»

Pascal, 181 154 bytes
27 bytes saved thanks to @ThePirateBay
procedure f(n:integer);var i,j:integer;begin for i:=1to n do begin write(' ':(n-i+1)*2);for j:=1to i*2-1do write((ord(j<>i)+i)mod 2,' ');writeln()end end;

Try it online!
Unglofed
procedure f (n: integer);
    var i, j: integer;
    begin
        for i := 1 to n do
        begin
            write(' ': (n-i+1) * 2);
            for j := 1 to i*2-1 do
                write((ord(j<>i) + i) mod 2, ' ')
            writeln()
        end
    end;

126 bytes

Retina, 25 bytes
.+
$*0
0
1$`¶
T`d`10`¶.*¶

Try it online! Explanation: The first stage converts the input into a string of zeros of that length. The second stage then takes all of the prefixes of that string (not including the string itself) and prefixes a 1 to them. The third stage then toggles the bits on alternate lines.

Mathematica, 90 bytes
Array[(x=Table[1,f=(2#-1)];x[[⌈f/2⌉]]=0;If[#==1,{1},If[OddQ@#,x/.{1->0,0->1},x]])&,#]&

Haskell, 54 bytes
Straight forward list comprehension:
f n=[k++[mod i 2]++k|i<-[1..n],k<-[mod(i+1)2<$[2..i]]]

Try it online!

J, 32 bytes
3 :'-.^:(2|y)(=|.)i.>:+:y'&.>@i.

Try it online! This is an anonymous function that returns a boxed list of values.
I like to imagine that the explicit function definition saves bytes by virtue of removing caps and such, but it probably adds a few bytes in comparison to a tacit answer.
Explanation
3 :'-.^:(2|y)(=|.)i.>:+:y'&.>@i.
                              i. For i = 0 ... input - 1
3 :'-.^:(2|y)(=|.)i.>:+:y'        Explicit function: compute nth row
                    >:+:y          2n+1
                  i.               Range [0,2n+1)
             (=|.)                 Equate range to reversed range
                                    (yield 0 0 0 ... 1 ... 0 0 0)
                                   If
                                    n = 1 (mod 2)
                                   Then
                                    Negate each value
                          &.>     Box

05AB1E, 11 bytes
FN°SRNF_}ûˆ

Try it online!
Explanation
F             # for N in range [0 ... input-1] do:
 N°           # push 10^N
   S          # split to list of digits
    R         # reverse
     NF_}     # N times do: logical negation
         û    # palendromize
          ˆ   # add to global list
              # implicitly display global list

J, 17 bytes
(2&|~:0=i:)&.>@i.

Try it online!
Outputs a list of boxed arrays.
Explanation
(2&|~:0=i:)&.>@i.  Input: n
               i.  Range from 0 to n, exclusive end
           & >     Unbox each and perform on each x
        i:           Range from -x to x, inclusive
      0=             Equal to 0
    ~:               Not equal
 2&|                 x mod 2
           &.>       Perform inverse of unbox (box)

Java 8, 121 111 109 101 bytes
n->{String r[]=new String[n],t;for(int i=0,j;i<n;r[i++]=t+i%2+t)for(j=0,t="";j++<i;t+=i%2);return r;}

My current byte-score (101) is also a row of the binary triangle. :)
Explanation:
Try it here.
n->{                         // Method with integer parameter and String-array return-type
  String r[]=new String[n],  //  Result String-array
         t;                  //  Temp String
  for(int i=0,j;             //  Some index-integers
      i<n;                   //  Loop (1) from 0 to `n` (exclusive)
      r[i++]=                //    After every iteration, set the next row to:
        t+                   //     `t` +
        i%2                  //     Center digit (`i` has already been raised by 1 now)
        +t)                  //     + `t` again
    for(j=0,t="";            //   Reset index `j` and the temp-String `t`
        j++<i;               //   Inner loop (2) from 0 to `i` (exclusive)
      t+=i%2                 //    Append `t` with an outer digit
    );                       //   End of inner loop (2)
                             //  End of loop (1) (implicit / single-line body)
  return r;                  //  Return resulting String-array
}                            // End of method

GolfScript, 49 bytes
~.:a;0\{..1+2%.!""+@*+" "a(:a*+.1>-1%\+"\n"+\)}*;

Try it online!

SOGL V0.12, 13 bytes
∫:2\r*Kr1κ+╥T

Try it Here!

Charcoal, 18 bytes
ＥＮ⪫ＩＥ⁺¹ι﹪⁺ι¬λ² ‖Ｏ←

Try it online! Link is to verbose version of code. Explanation:
ＥＮ              For each of the input number of rows
  ⪫             Join with spaces
   Ｉ            Convert to string
    Ｅ⁺¹ι        For each column
        ﹪⁺ι¬λ²  Calculate the digit
‖Ｏ←             Reflect to the left

JavaScript, 140 132 bytes (with proper formatting)
n=>{A=Array;a='';b=0;for(x of A(n)){for(c of A(n-b))a+=' ';for(c of A(b))a+=b%2;a+=(b+1)%2;for(c of A(b))a+=b%2;a+='\n';b++}return a}

Try It Online

If you didn't know, you can use A=Array to save 8 bytes.

Good point, I didn't think of that

You can save at least 3 more bytes by: 1) Instead of A=Array; you can init variable A on first array call (ie. for(x of(A=Array)(n))) which saves 1 byte, 2) Replace '\n' with literal new line (use grave accents), 3) You don't need parentheses in (b+1)%2 because it is equivalent to b+1&1.

JavaScript (ES6), 74 73 71 68 64 bytes
-7 bytes by @Neil
f=n=>n--?[...f(n), [...Array(n-~n)].map((v,i)=>(n+(i==n))%2)]:[]

Try it online!
Simple recursive function that generates the lines one by one. Outputs as array of array of numbers.

Outputs as formatted string:
JavaScript (ES6), 122 119 118 bytes
f=(n,w=2*n+1,N=n,s=" ".repeat((N-n)*2))=>(--n?f(n,w,N)+s+[...Array(n-~n)].map((v,i)=>(n+(i==n))%2).join(" "):s+1)+"\n"

Try it online!

(n%2+(i==n))%2 can be simplified to (n+(i==n))%2.

Or 1&n^i==n might work, but I haven't tested it.

Also try n--?...:[]. (And you don't need the ; in code golf.)

2*n+1 might be n-~n, but I can never remember for sure.

@Neil Thanks! Added the ones I could get working

Perhaps n%2^i==n works?