text:
Closest 7-Distinct-Prime Product
(via chat)
The OEIS entry A123321 lists the sequence of numbers that are the product of seven distinct primes. For brevity, we'll call this a 7DP number. The first few numbers and their corresponding divisors are below:
510510 = 2 * 3 * 5 * 7 * 11 * 13 * 17
570570 = 2 * 3 * 5 * 7 * 11 * 13 * 19
690690 = 2 * 3 * 5 * 7 * 11 * 13 * 23
746130 = 2 * 3 * 5 * 7 * 11 * 17 * 19

The challenge here will be to find the closest 7DP number, in terms of absolute distance, from a given input.
Input
A single positive integer n in any convenient format.
Output
The closest 7DP number to n, again in any convenient format. If two 7DP numbers are tied for closest, you can output either or both.
Rules

Numbers can be assumed to fit in your language's default [int] datatype (or equivalent).
Either a full program or a function are acceptable.
Standard loopholes are forbidden.
This is code-golf, so all usual golfing rules apply, and the shortest code wins.

Examples
5 -> 510510
860782 -> 870870
1425060 -> 1438710 (or 1411410, or both)

Python, 89 86 85 bytes
f=lambda n,k=0:126^sum(1>>n%i<<7*(n/i%i<1)for i in range(2,n))and f(n+k,k%2*2+~k)or n

The algorithm is O(scary) to begin with and the recursion doesn't really help, but it works well as long as n is sufficiently close to a 7DP number.
Thanks to @xnor for golfing off 3 bytes!
Test it on repl.it.
How it works
Python has no primality or factorization built-ins, but we can identify 7DP numbers by the amount and nature of their divisors.
By the multiplication principle, the number of divisors of an integer can be computed as the product of the incremented exponents of its prime factorization. Thus, σ0(n) (divisor function) is 2m whenever n is a mDP number.
σ0(n) = 128 is thus a necessary condition, but it is not sufficient; for example, σ0(2127) = 128, but 2127 is clearly not a 7DP number. However, if both σ0(n) = 128 and no perfect square divides n evenly, then n is a 7DP number.
For the input n, the algorithm consists in inspecting the integers n, n - 1, n + 1, n - 2, n + 2, etc. and returning the first one that is a 7DP number.
When f is called with argument n, the following happens:

The code
126^sum(1>>n%i<<7*(n/i%i<1)for i in range(2,n))

tests if n is not a 7DP number as follows.
For all integers i such that 1 < i < n, 1>>n%i<<7*(n/i%i<1) gets evaluated.

If n is divisible by i but not by i2, 1>>n%i yields 1 and (n/i%i<1) yields 0, resulting in
1 · 27 · 0 = 1.
If n is divisible by i2, 1>>n%i and (n/i%i<1) both yield 1, resulting in 1 · 27 · 1 = 128.
If n not not divisible by i, 1>>n%i yields 0, resulting in 0 · 27 · x = 0.

The sum of the resulting integers will be 2m - 2 if n is a mDP number (its 2m divisors, excluding 1 and n) and a number greater than 127 if n has a perfect square factor. Thus, the sum will be 126 if and only if n is a 7DP number.
For 7DP numbers, the sum is 126, so XORing it with 126 yields 0, which is falsy. Thus, the or part of the lambda is executed and f returns the current value of n.
If n is not a 7DP number, XOR will return a non-zero, truthy value. Thus, the and part of the lambda is executed.
f(n+k,k%2*2+~k)

recursively calls f with updated values of n (the next potential 7DP number) and k (the difference between the the new candidate and the one after that).
If k is an even, non-negative integer, k%2*2 yields 0 and ~k yields -(k + 1). The sum of both results is -(k + 1), which is an odd, negative integer that is 1 greater in absolute value than k.
If k is an odd, negative integer, k%2*2 yields 2 and ~k yields -(k + 1). The sum of both results is 2 - (k + 1) = -(k - 1), which is an even, non-negative integer that is 1 unit greater in absolute value than k.
This means that k takes the values 0, -1, 2, -3, 4, ⋯.
When added cumulatively to n0 (the initial value of n), the resulting integers are

n0 + 0
(n0 + 0) - 1 = n0 - 1
(n0 - 1) + 2 = n0 + 1
(n0 + 1) - 3 = n0 - 2
(n0 - 2) + 4 = n0 + 2
etc.

making sure the first 7DP number we encounter is as close to n0 as possible.

Great idea with the divisor counting! I think you can golf the alternating walk by updating k directly as f(n+k,k%2*2+~k), starting with k=0.

Great improvement. Thanks!

Brachylog, 44 40 16 bytes
Crossed out 44 is still regular 44 ;(
:I=+.>0,.$pPdPl7

Example:
?- run_from_atom(':I=+.>0,.$pPdPl7',1425060,Z).
Z = 1438710 .

Could it be that this language doesn't always suck? I beat Jelly and MATL!
The test case with 5 is the longest and takes about 10 seconds on my machine.
This would be 12 bytes if $p was not bugged (we wouldn't need the >0,. part)
Explanation
Brachylog uses constraint logic programming by default for all integer arithmetic. Moreover, the labeling built-in = works on possibly infinite domains.
It successively unifies a variable with no constraints (i.e. in (-inf, inf)) as such: 0, 1, -1, 2, -2, 3, ….
Therefore, we can get the closest 7DP number by looking for the first number I unified in (-inf, inf) (using automatic backtracking), for which Input + I is a 7DP number.
:I=                Label variables in [Input, I]. I has no constraints and Input is known
   +.              Unify Output with Input + I
     >0,           Output > 0 (wouldn't be needed if $p failed for numbers less than 1)
        .$pP       Unify P with the list of prime factors of Output
            dP     Check that P with duplicates removed is still P
              l7   Check that the length of P is 7

I beat Jelly and MATL! But only by 0 bytes :-P

@LuisMendo It would be 13 bytes if I fix a bug with $p. In theory I don't need the >0,, but my implementation is buggy :P

...down to 14 now!

Does it suffice to state N #> 0 in brachylog_math_prime_decomposition/2?

By the way, I think you can compute a better upper bound using CLP(FD) constraints: SN*SN #=< N, SN #> 0, and take the upper limit of SN.

@mat It should suffice, yes. I don't know why I never tested this predicate for 0 or negative inputs.

This apparently checks whether a number is a 7-distinct-prime product. But does it find the product closest to n?

@DavidC Yes, because it starts at the input and then tries all numbers as such: Input+1, Input-1, Input+2, Input-2, Input+3, ... therefore the first 7DP found with that method will be the closest.

Only one question: Why still 16?

@mat Fixing bugs after the challenge was posted makes the answer non-competing, so I'll leave it at 16, even though now it could be 12 bytes (>0,. not needed)

http://codegolf.stackexchange.com/a/111998/59995 Crossed-out 444 is still 444. I'll be impressed when we see crossed-out 4444.

Jelly, 17 bytes
Pµạ³,
×⁹ÆRœc7Ç€ṂṪ

Works in theory, but takes many years to complete.

Here is a version that actually works for the given inputs, but theoretically fails for large inputs:
Pµạ³,
50ÆRœc7Ç€ṂṪ

Try it here. This generates all primes up to 50, then finds all 7-combinations of primes in that list, and then all their products. Finally, it simply finds the closest element from that list to the given argument.
Of course, once our 7DPs contain primes higher than 50, this will fail. The theoretical version generates all primes up to 256n for an input n, but otherwise works the same way.
Proof
Let p(x) denote the next prime after x. An (extremely loose) upper bound for the closest 7DP product to x is:
p(x) * p(p(x)) * p(p(p(x))) * ... * p(p(p(p(p(p(p(x)))))))

So we only need to check primes in [2…p(p(p(p(p(p(p(x)))))))]. Bertrand's
postulate says that p(x) ≤ 2x, so it suffices to check all primes up to 128x.

×⁹ÆRœc7P€µạ³ỤḢị or ×⁹ÆRœc7P€µạ³NMị (printing the array of all solutions) saves a couple of bytes. Also, ×⁹ can be changed to +⁴ to improve efficiency.

MATL, 21 17 16 14 13 bytes
Thanks to Dennis for a suggestion that removed 4 bytes, and another that saved 1 more byte!
t17*Zq7XN!pYk

This works in theory, but runs out of memory for inputs above 6 (online compiler).
A more efficient version uses 21 bytes, and computes all test cases in about one second:
t3e4/k16+_YqZq7XN!pYk

Try it online!

Memory-inefficient version
Memory-efficient version
Memory-efficient version, all test cases

Explanation
Memory-efficient version
Take input N = 860782 as an example. It suffices to consider primes up to M = 29, which is the first prime that multiplied by 2*3*5*7*11*13 exceeds N. In this example, 2*3*5*7*11*13*29 = 870870. The next prime is 31. Any product involving that prime or greater will be at least 2*3*5*7*11*13*31 = 930930, and so it's guaranteed not to be the solution, because it exceeds 870870 which exceeds N.
M is computed as the first prime greater than max(N/(2*3*5*7*11*13), 16). The max function is used for ensuring that at least 17 is picked. To save a few bytes, the code replaces 2*3*5*7*11*13 = 30030 by 30000, and function max by addition. These changes are valid because they give a larger value.
t      % Take input implicitly. Duplicate
3e4/k  % Divide input by 30000 and round down (rounding here is only needed
       % due to a bug in the "next prime" function)
16+    % Add 16
_Yq    % Next prime
Zq     % Prime numbers up to that value
7XN    % Combinations of those primes taken 7 at a time. Gives a 2D array
       % with each combination on a different row
!p     % Product of each row
Yk     % Output product that is closest to the input. Implicitly display

Memory-inefficient version
To further reduce the number of bytes the division can be removed; in fact, it suffices to multiply by 17 (thanks, @Dennis). This ensures that the next prime is included (by Bertrand's postulate) and that the result is at least 17. This works in theory, but runs out of memory for inputs larger than about 6.
In the code, the section
3e4/k  % Divide input by 30000 and round down (rounding here is only needed
       % due to a bug in the "next prime" function)
16+    % Add 16
_Yq    % Next prime

is replaced by
17*    % Multiply by 17

Pyke, 32 bytes
#PDl 7q.ID}lRlqi*(#)DF-X,)R],She

Try it here!
Note this doesn't work online - it times out. This Version only checks for 2 distinct primes and should work faster. When there are 2 numbers of the same distance away from the target, it chooses the lower one.
This goes through all the numbers until it finds one that is bigger than the input and is a 7DP. For each number, it gets rid of it if it isn't a 7DP. It then has a list of 7DPs up to the input with one that is bigger. It then picks the one that is closest to the input.

Julia, 59 bytes
!n=sort(map(prod,combinations(17n|>primes,7))-n,by=abs)[]+n

This is very inefficient, but it works for the first test case in practice and for the others in theory.
At the cost of 5 more bytes – for a total of 64 bytes – efficiency can be improved dramatically.
!n=sort(map(prod,combinations(n>>14+17|>primes,7))-n,by=abs)[]+n

Try it online!
Background
As mentioned in @LuisMendo's answer, the set of primes we have to consider for the nearest 7DP number is quite small. It suffices for the set to contains a 7DP number that is bigger than the input n, which will be true if and only if it contains a prime p ≥ 17 such that 30300p = 2·3·5·7·11·13·p ≥ n.
In On the interval containing at least one prime number proves that the interval [x, 1.5x) contains at least one prime number whenever x ≥ 8. Since 30030 / 16384 ≈ 1.83, that means there must be a prime p in (n/30030, n/16384) whenever n > 8 · 30300 = 242400.
Finally, when n < 510510, p = 17 is clearly sufficient, so we only need to consider primes up to n/16384 + 17.
At the cost of efficiency, we can consider primes up to 17n instead. This works when n = 1 and is vastly bigger than n/16384 + 17 for larger values of n.
How it works
17n|>primes and n>>14+17|>primes (the bitshift is equivalent to dividing by 214 = 16384) compute the prime ranges mentioned in the previous paragraph. Then, combinations(...,7) computes all arrays of seven different prime numbers in that range, and mapping prod over those calculates their products, i.e., the 7DP numbers from which we'll choose the answer.
Next, -n subtracts n prom each 7DP number, then sort(...,by=abs) sorts those differences by their absolute values. Finally, we select the first difference with [] and compute the corresponding 7DP number by adding n with +n.

Pyth, 30 bytes
L&{IPbq7lPby#.W!syMH,hhZa0teZ,

Try it online!
Test suite.
(5 takes too long to run)
Explanation
L&{IPbq7lPby#.W!syMH,hhZa0teZ,

L&{IPbq7lPb     Defines a function y, whose argument is b:
 &                  Return if both the following are true:
  {IPb                  the prime factorization contains no duplicate; and:
      q7lPb             the number of prime factors is 7

           y#.W!syMH,hhZa0teZ,   The main programme. Input as Q.
                             ,QQ Implicit arguments, yield [Q,Q].
             .W                  While
               !syMH                   both numbers do not satisfy y:
                    ,hhZ             increment the first number
                          teZ        and decrement the second number
                        a0           while making it non-negative.

Mathematica 136 80 75 bytes
This is a straightforward approach, working outwards from n.
n is a 7-distinct-prime product iff the number of prime factors is 7 (PrimeNu@#==7) and none of these factors appears more than once (SquareFreeQ@#&).
g@n_:=(k=1;While[!(PrimeNu@#==7&&SquareFreeQ@#&)⌊z=n-⌊k/2](-1)^k⌋,k++];z)

My earlier submission (136 bytes) found both the first 7-distinct-prime product above n and, if it exists, the first 7-distinct-prime product below n. It then simply determined which was closer to n.  If the products were equidistant, it returned both.
The current version checks n-1,n+1,n-2,n+2... until it reaches the first 7-distinct-prime product.  This more efficient version adopts the approach Dennis took.
The key advance was in using ⌊k/2](-1)^k⌋ to return the series, 0, 1, -1, 2, -2... The zero is used to check whether n is itself a 7-distinct-prime product. For this reason, Floor(that is, ⌊...⌋) is used instead of Ceiling.

g[5]
g[860782]
g[1425060]

510510
870870
1438710

05AB1E, 10 bytes
°Åp7.ÆPs.x

Try it online!
Tries all combinations of 7 of the first 10**input primes. Runs out of memory for inputs greater than 1.
Considerably more efficient 14 bytes version:
5°/7+Åp7.ÆPs.x

Try it online!
Uses the first (input / 100000 + 7) primes.


text:
Geobitsian Language
Geobitsian language is a new perversion of English where a word is broken into segments that each must start with a different letter. Then every time one of those starting letters appears in another string, it is replaced with its entire corresponding segment, maintaining capitalization.
This process is called Geobitsizing.
For example the word "Geobits" could be broken into geo bits, and the nonsense poem
Algy met a Bear
A Bear met Algy
The Bear was bulgy
The bulge was Algy

would be Geobitsized with it as
Algeoy met a Bitsear
A Bitsear met Algeoy
The Bitsear was bitsulgeoy
The bitsulgeoe was Algeoy

because every g becomes geo, every G (though there are none) becomes Geo, every b becomes bits, and every B becomes Bits.
Note that each substitution is performed with respect to the original string, not any intermediate step. e.g. if geo had been gbo instead, the b's created would not replaced with bits.
Challenge
Write a program or function that can generate Geobitsian language.
Take in a single-line string made of lowercase letters (a-z) and spaces. This will be the word used as the Geobitsizing argument, with the spaces separating the segments. You can assume:

Segments will not be empty. So spaces will not neighbor each other nor be at the start or end of the string.
Each segment starts with a different letter. Thus there cannot be more than 26.

For example, some valid segmented strings you must support are geo bits, butt ner, alex, and do o r k nob (single letter segments have no effect but are valid). But geo , butt   ner, Alex, and do o r k n ob are invalid.
Your program or function also needs to take in another arbitrary string to apply the Geobitsizing to, and print or return the resulting Geobitsian language.

You can assume this string only contains newlines and printable ASCII.

Remember that letter cases must be preserved from the input to the output.

Here are some more examples using no pro gr am m ing as the Geobitsizing argument:
[empty string] → [empty string]
i → ing
I → Ing
Mmmm, mmm... MmmmMMM: m&m! → Mmmm, mmm... MmmmMMM: m&m! (no change)
People think bananas are great, don't you? → Proeoprole thingnok bamnoamnoams amre grreamt, dono't you?
Pet a Puppy
Google Wikipedia

↓
Proet am Prouproproy
Groogrle Wingkingproedingam

Note that the results should be identical no matter how the argument is arranged, e.g. ing pro m no am gr should yield the same results as above.
The shortest code in bytes wins.

Can we take the "Geobitsizing argument" as an array? e.g. ["no", "pro", "gr", "am", "m", "ing"]

@Upgoat Sorry but no.

@Upgoat Try \\b${l}(\\S+) although that does cost you 5 bytes.

Some advice on test cases that may interest you :P

You say that butt ner is valid, then later say it isn't. Could you clarify what the difference is between the two apparently identical copies?

-1 for arbitrary input requirement of a space-separated string.

@QPaysTaxes The second one has 3 spaces.

Oh, I see. They don't render differently at all on mobile.

Suggested test case: abra cadabra, !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ That should cover all edge cases, and there are a lot of them if one tries to use regexes...

Jelly, 18 bytes
ṣ⁶;Œu1¦€$;©ZḢiÐ€ị®

Try it online!
Alternative version, 15 bytes
Jelly's title case function had a bug; it didn't capitalize the first word. That has been fixed, so the following works now.
ṣ⁶;Œt$;©ZḢiÐ€ị®

This code does the same as in the competing version, except that Œt (title case) replaces the conditional uppercasing achieved by Œu1¦€.
How it works
ṣ⁶;Œu1¦€$;©ZḢiÐ€ị®  Main link. Left argument: w (words). Right argument: s (string)

ṣ⁶                  Split w at spaces.
        $           Combine the two links to the left into a monadic chain.
       €              Map over the words.
   Œu1¦                 Uppercase the item at index 1.
  ;                   Append the result to the unmodified words.
         ;          Append all characters in s to the list of words.
          ©         Copy the result to the register.
           Z        Zip/transpose, grouping the first chars into the first list.
            Ḣ       Head; extract the list of first characters.
             iÐ€    Find the first index of each character in s.
                ị®  Select the characters/strings from the list in the register
                    that are at those indices.

Python 3, 71 bytes
lambda w,s:s.translate({ord(t[0]):t for t in(w+' '+w.title()).split()})

Test it on Ideone.
How it works
In Python 3, the built-in str.translate takes a string and a dictionary, and replaces each character in the string whose code point is a key of that dictionary with the corresponding value, which may be a string, an integer or None (equivalent to the empty string).
Converting the string of words w to title case (i.e., capitalizing the first letter of each word) and appending it to the result of w+' ' creates a string of space separated words with lower- and uppercase version (first letter). Without a second argument, str.split splits at whitespace, so (w+' '+w.title()).split() creates the list of all words.
Finally, the dictionary comprehension {ord(t[0]):t for t in...} turns each word t into a dictionary entry with key ord(t[0]) (code point of the first letter) and value t, so str.translate will perform the intended substitutions.

Python, 126 99 95 81 bytes
Alot thanks to Dennis:
lambda G,S,j=''.join:j(s+j(g[1:]for g in G.split()if g[0]==s.lower())for s in S)

Edit1: don't need to append to a temporary
Edit2: S may contain uppercase...
Edit3: don't duplicate G
Edit4: compressed a little bit more and shoved it into one line
Edit5: using unnamed lambda and j=join' '

Pyth, 19 bytes
.rzsC_hMBsm,rd0rd3c

Try it online!

We can't take the geobitsizing argument as an array, unfortunetly

Sorry, didn't notice.

Vim, 46 keystrokes
Ugly, and Hacky.
A <esc>:s/\<\w/:%s\/\0\\c\/\\0/g<cr>:s/ /eg<C-v><Cr>/g<cr>dgg@"

Why not in V? D:

@Upgoat Cause it's a buggy mess.

Python 2, 83 78 bytes
lambda w,s:''.join(c+w[(' '+w).find(' '+c.lower()):].split()[0][1:]for c in s)

Test it on Ideone.
How it works
We iterate over all characters c in the string s.
We prepend a space to the string of words w, then search for a occurrence of lowercased c, preceded by a space.

If such an occurrence exists, find will return the index of the space in the string ' '+w, which matches the index of c in w.
w[...:] thus returns the tail of w, starting from the word with first letter c. split() splits the tail at spaces, [0] selects the first chunk (the word) and [1:] removes its first letter.
After prepending c to the previous result, we obtain the correctly cased word that starts with c.
If no word begins with c, find will return -1.
Thus, w[...:] yields the last character of w, split() wraps it in an array, [0] undoes the wrapping, and [1:] removes the only character from the string.
After prepending c, we obtain the singleton string whose character is c, so the whole operation is a no-op.

Finally, ''.join concatenates all resulting strings, returning the Geobitsized version of s.

Retina, 36 bytes
Byte count assumes ISO 8859-1 encoding.
i`(?<=^.*\b\2(\w+)[^·]*?(\w))
$1
A1`

Try it online!

Pyth, 18 16
MsXGhMJcjdrBH3)J

Try it here
Defines a function g that performs the geobitsising. As a program this would be a bit shorter if the second string is single line, but multiline input isn't worth it:
sXwhMJcjdrBz3)J

The general idea here was to title case the geobitsian string and append that to the original string. Then split that on spaces and for each string, take the first letter and map it to the string it represents. That way X will turn the first letter of each word into the full word.

Did you just... outgolf Dennis?

@BojidarMarinov If you count Dennis using some other language that had a bug in it as outgolfing, then yes ;)

JavaScript ES6, 67 63 70 bytes
g=>s=>s.replace(/\S/g,l=>l+(g.match(`\\b\\${l}(\\S+)`,'i')||[,""])[1])

Test this on Firefox. bugs are making this longer than I'd like
Explanation
function(gbarg, str) {
   return str.replace(/\S/g, function(chr) { // Replace non-whitespace w/...
        return chr + (
         gbarg.match(`\\b\\${l}(\\S+)`,'i')  // That word in the gbstr
        ||[,""])[1]                          // if not in gbstr, use blank str
   });
}

f("abracadabra")("1Dbw") returns "1abracadabraDbracadabrababracadabrawbracadabra".

Julia, 72 68 bytes
w%s=prod(c->"$c"join((W=w|>split)[find(t->t[1]==c|' ',W)])[2:end],s)

Try it online!

CJam, 19 bytes
lq\S/_32af.^+_:c\er

Test it here.
Explanation
l       e# Read first line of input (list of words).
q\      e# Read remaining input and swap with first line.
S/      e# Split around spaces.
_       e# Duplicate.
32af.^  e# Convert the first letter of each word to upper case by taking
        e# the element-wise XOR with the list [32].
+       e# Append the upper-cased words to the original ones.
_:c     e# Duplicate and convert each word to its first character.
\       e# Swap characters with words.
er      e# Transliteration, replacing each character with the corresponding word.

Ruby, 65 60 58 bytes
->w,s{s.gsub(/\w/){|c|w=~/\b#{c}(\w+)/i;c+($1||c)[1..-1]}}

Try it online!

source: Stack Exchange

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

sort: votes


text:
Display a cribbage score in ASCII
Cribbage is an interesting game, because you need a specific board to score your game.
A cribbage board looks like this:

Notice how the first column is on the left as it goes up, then on the right as it goes down, then back on the left as it goes up again.
And here is what a poorly drawn rendered ASCII art of a cribbage board looks like:
                     * * *
   -----------      -------
  /     *     \     |*|*|*|
 /*     *     *\    |*|*|*|
/   *   *   *   \   |*|*|*|
|     *   *     |   |*|*|*|
|* * *     * * *|   |*|*|*|
-------   -------   -------
|*|*|*|   |*|*|*|   |*|*|*|
|*|*|*|   |*|*|*|   |*|*|*|
|*|*|*|   |*|*|*|   |*|*|*|
|*|*|*|   |*|*|*|   |*|*|*|
|*|*|*|   |*|*|*|   |*|*|*|
-------   -------   -------
|*|*|*|   |*|*|*|   |*|*|*|
|*|*|*|   |*|*|*|   |*|*|*|
|*|*|*|   |*|*|*|   |*|*|*|
|*|*|*|   |*|*|*|   |*|*|*|
|*|*|*|   |*|*|*|   |*|*|*|
-------   -------   -------
|*|*|*|   |*|*|*|   |*|*|*|
|*|*|*|   |*|*|*|   |*|*|*|
|*|*|*|   |*|*|*|   |*|*|*|
|*|*|*|   |*|*|*|   |*|*|*|
|*|*|*|   |*|*|*|   |*|*|*|
-------   -------   -------
|*|*|*|   |*|*|*|   |*|*|*|
|*|*|*|   |*|*|*|   |*|*|*|
|*|*|*|   |*|*|*|   |*|*|*|
|*|*|*|   |*|*|*|   |*|*|*|
|*|*|*|   |*|*|*|   |*|*|*|
-------   -------   -------
|*|*|*|   |*|*|*|   |*|*|*|
|*|*|*|   |*|*|*|   |*|*|*|
|*|*|*|   |*|*|*|   |*|*|*|
|*|*|*|   |*|*|*|   |*|*|*|
|*|*|*|   |*|*|*|   |*|*|*|
-------   -------   -------
|*|*|*|   |*|*|*|   |*|*|*|
|*|*|*|   |*|*|*|   |*|*|*|
|*|*|*|   |*|*|*|   |*|*|*|
|*|*|*|   |*|*|*|   |*|*|*|
|*|*|*|   |*|*|*|   |*|*|*|
-------   -------   -------
|*|*|*|   |*|*|*|   |*|*|*|
|*|*|*|   |*|*|*|   |*|*|*|
|*|*|*|   |*|*|*|   |*|*|*|
|*|*|*|   |*|*|*|   |*|*|*|
|*|*|*|   |*|*|*|   |*|*|*|
-------   -------   -------
 * * *    |* * *     * * *|
          |     *   *     |
          \   *   *   *   /
           \*     *     */
            \     *     /
             -----------

Here is your challenge:
Step 1: Draw this ASCII art of a cribbage board. Trailing whitespace is OK, provided that there is no visible difference.
Step 2: Given three integers as input, display each peg in the correct hole. The pegs can be 0-indexed or 1-indexed. The inputs will be in [0-121] inclusive. You can take these inputs in any reasonable manner, for example, 3 separate inputs, an array, command line arguments, etc. Here's an example for the input (0, 37, 100) (1-indexed):
                     * * *
   -----------      -------
  /     *     \     |*|*|*|
 /*     *     *\    |*|*|*|
/   2   *   *   \   |*|*|*|
|     *   *     |   |*|*|*|
|* * *     * * *|   |*|*|*|
-------   -------   -------
|*|*|*|   |*|*|*|   |*|*|*|
|*|*|*|   |*|*|*|   |*|*|*|
|*|*|*|   |*|*|*|   |*|*|*|
|*|*|*|   |*|*|*|   |*|*|*|
|*|*|*|   |*|*|*|   |*|*|*|
-------   -------   -------
|*|*|*|   |*|*|*|   |*|*|*|
|*|*|*|   |*|*|*|   |*|*|*|
|*|*|*|   |*|*|*|   |*|*|*|
|*|*|*|   |*|*|*|   |*|*|*|
|*|*|*|   |*|*|*|   |*|*|*|
-------   -------   -------
|*|*|*|   |*|*|*|   |*|*|*|
|*|*|*|   |*|*|*|   |*|*|*|
|*|*|*|   |*|*|*|   |*|*|*|
|*|*|*|   |*|*|*|   |*|*|*|
|*|*|*|   |*|*|*|   |*|*|*|
-------   -------   -------
|*|*|*|   |*|*|*|   |*|*|3|
|*|*|*|   |*|*|*|   |*|*|*|
|*|*|*|   |*|*|*|   |*|*|*|
|*|*|*|   |*|*|*|   |*|*|*|
|*|*|*|   |*|*|*|   |*|*|*|
-------   -------   -------
|*|*|*|   |*|*|*|   |*|*|*|
|*|*|*|   |*|*|*|   |*|*|*|
|*|*|*|   |*|*|*|   |*|*|*|
|*|*|*|   |*|*|*|   |*|*|*|
|*|*|*|   |*|*|*|   |*|*|*|
-------   -------   -------
|*|*|*|   |*|*|*|   |*|*|*|
|*|*|*|   |*|*|*|   |*|*|*|
|*|*|*|   |*|*|*|   |*|*|*|
|*|*|*|   |*|*|*|   |*|*|*|
|*|*|*|   |*|*|*|   |*|*|*|
-------   -------   -------
|*|*|*|   |*|*|*|   |*|*|*|
|*|*|*|   |*|*|*|   |*|*|*|
|*|*|*|   |*|*|*|   |*|*|*|
|*|*|*|   |*|*|*|   |*|*|*|
|*|*|*|   |*|*|*|   |*|*|*|
-------   -------   -------
 1 * *    |* * *     * * *|
          |     *   *     |
          \   *   *   *   /
           \*     *     */
            \     *     /
             -----------

Step 3: Output the whole thing.
Test IO:
Since each of these is pretty vertically tall, I will only include 2, but you can see more at this github gist.
#Input: (56, 56, 56)
#Output:
                     * * *
   -----------      -------
  /     *     \     |*|*|*|
 /*     *     *\    |*|*|*|
/   *   *   *   \   |*|*|*|
|     *   *     |   |*|*|*|
|* * *     * * *|   |*|*|*|
-------   -------   -------
|*|*|*|   |*|*|*|   |*|*|*|
|*|*|*|   |*|*|*|   |*|*|*|
|*|*|*|   |*|*|*|   |*|*|*|
|*|*|*|   |*|*|*|   |*|*|*|
|*|*|*|   |*|*|*|   |*|*|*|
-------   -------   -------
|*|*|*|   |*|*|*|   |*|*|*|
|*|*|*|   |*|*|*|   |*|*|*|
|*|*|*|   |*|*|*|   |*|*|*|
|*|*|*|   |*|*|*|   |*|*|*|
|*|*|*|   |*|*|*|   |*|*|*|
-------   -------   -------
|*|*|*|   |*|*|*|   |*|*|*|
|*|*|*|   |*|*|*|   |*|*|*|
|*|*|*|   |*|*|*|   |*|*|*|
|*|*|*|   |*|*|*|   |*|*|*|
|*|*|*|   |*|*|*|   |*|*|*|
-------   -------   -------
|*|*|*|   |3|2|1|   |*|*|*|
|*|*|*|   |*|*|*|   |*|*|*|
|*|*|*|   |*|*|*|   |*|*|*|
|*|*|*|   |*|*|*|   |*|*|*|
|*|*|*|   |*|*|*|   |*|*|*|
-------   -------   -------
|*|*|*|   |*|*|*|   |*|*|*|
|*|*|*|   |*|*|*|   |*|*|*|
|*|*|*|   |*|*|*|   |*|*|*|
|*|*|*|   |*|*|*|   |*|*|*|
|*|*|*|   |*|*|*|   |*|*|*|
-------   -------   -------
|*|*|*|   |*|*|*|   |*|*|*|
|*|*|*|   |*|*|*|   |*|*|*|
|*|*|*|   |*|*|*|   |*|*|*|
|*|*|*|   |*|*|*|   |*|*|*|
|*|*|*|   |*|*|*|   |*|*|*|
-------   -------   -------
|*|*|*|   |*|*|*|   |*|*|*|
|*|*|*|   |*|*|*|   |*|*|*|
|*|*|*|   |*|*|*|   |*|*|*|
|*|*|*|   |*|*|*|   |*|*|*|
|*|*|*|   |*|*|*|   |*|*|*|
-------   -------   -------
 * * *    |* * *     * * *|
          |     *   *     |
          \   *   *   *   /
           \*     *     */
            \     *     /
             -----------

#Input: (120, 89, 23)
#Output:
                     * * *
   -----------      -------
  /     *     \     |1|*|*|
 /*     *     *\    |*|*|*|
/   *   *   *   \   |*|*|*|
|     *   *     |   |*|*|*|
|* * *     * * *|   |*|*|*|
-------   -------   -------
|*|*|*|   |*|*|*|   |*|*|*|
|*|*|*|   |*|*|*|   |*|*|*|
|*|*|*|   |*|*|*|   |*|*|*|
|*|*|*|   |*|*|*|   |*|*|*|
|*|*|*|   |*|*|*|   |*|*|*|
-------   -------   -------
|*|*|*|   |*|*|*|   |*|*|*|
|*|*|*|   |*|*|*|   |*|*|*|
|*|*|*|   |*|*|*|   |*|*|*|
|*|*|*|   |*|*|*|   |*|*|*|
|*|*|*|   |*|*|*|   |*|*|*|
-------   -------   -------
|*|*|*|   |*|*|*|   |*|*|*|
|*|*|*|   |*|*|*|   |*|*|*|
|*|*|3|   |*|*|*|   |*|*|*|
|*|*|*|   |*|*|*|   |*|*|*|
|*|*|*|   |*|*|*|   |*|*|*|
-------   -------   -------
|*|*|*|   |*|*|*|   |*|*|*|
|*|*|*|   |*|*|*|   |*|*|*|
|*|*|*|   |*|*|*|   |*|*|*|
|*|*|*|   |*|*|*|   |*|*|*|
|*|*|*|   |*|*|*|   |*|*|*|
-------   -------   -------
|*|*|*|   |*|*|*|   |*|*|*|
|*|*|*|   |*|*|*|   |*|*|*|
|*|*|*|   |*|*|*|   |*|*|*|
|*|*|*|   |*|*|*|   |*|*|*|
|*|*|*|   |*|*|*|   |*|*|*|
-------   -------   -------
|*|*|*|   |*|*|*|   |*|*|*|
|*|*|*|   |*|*|*|   |*|2|*|
|*|*|*|   |*|*|*|   |*|*|*|
|*|*|*|   |*|*|*|   |*|*|*|
|*|*|*|   |*|*|*|   |*|*|*|
-------   -------   -------
|*|*|*|   |*|*|*|   |*|*|*|
|*|*|*|   |*|*|*|   |*|*|*|
|*|*|*|   |*|*|*|   |*|*|*|
|*|*|*|   |*|*|*|   |*|*|*|
|*|*|*|   |*|*|*|   |*|*|*|
-------   -------   -------
 * * *    |* * *     * * *|
          |     *   *     |
          \   *   *   *   /
           \*     *     */
            \     *     /
             -----------

Standard loopholes apply, and the shortest answer in bytes wins!

Sorta related: http://codegolf.stackexchange.com/questions/5515/score-a-cribbage-hand

The bottom "curve" isn't symmetrical.  Is that intentional?

@ChuckMorris No, that was not intentional. Fixed now. Thanks for pointing that out!

Python 3, 496 bytes
z=r"""SSSWT
WOSY
  /UR\UZ
 /RR*\W Z
/WQQQ\WZ
MWZ
NWZVVVVVVV
YWYWY
 TW NPW MPW \WQQQ/PU\RR*/ PS\UR/PS O"""
for y in'M|UQR|,N|TUT|,OY----,P\nS,Q*W,R*U,SWW,T* * *,UW  ,V\nYWYWYXXXXX,W   ,X\nZ   Z   Z,Y-------,Z|*|*|*|'.split(','):z=z.replace(y[0],y[1:])
L=list(range(50,-1,-1))
del L[1::6]
def f(*s):
 b=list(z)
 for p in(0,1,2):b[(L[:-5]+[3+p,2+p,3+p]+L[-6::-1]+[51+p,52+p,51+p]+L)[s[p]]*28+([2*p+1]*37+[2+2*p,8,14-2*p]+[15-2*p]*37+[16-2*p,18,20+2*p]+[21+2*p]*42)[s[p]]]=str(p+1)
 print(*b,sep='')

Running (or importing) the code creates a function that is called with the three players scores: f(5, 38, 53).
Somewhat ungolfed version
z=r"""SSSWT
WOSY
  /UR\UZ
 /RR*\W Z
/WQQQ\WZ
MWZ
NWZVVVVVVV
YWYWY
 TW NPW MPW \WQQQ/PU\RR*/ PS\UR/PS O"""

subs='M|UQR|,N|TUT|,OY----,P\nS,Q*W,R*U,SWW,T* * *,UW  ,V\nYWYWYXXXXX,W   ,X\nZ   Z   Z,Y-------,Z|*|*|*|'

for y in subs.split(','):
   z=z.replace(y[0],y[1:])

L=list(range(50,-1,-1))
del L[1::6]

def f(*s):
 b=list(z)
 for p in(0,1,2):
  R = L[:-5] + [3+p,2+p,3+p] + L[-6::-1] + [51+p,52+p,51+p] + L
  C = [2*p+1]*37 + [2+2*p,8,14-2*p] + [15-2*p]*37 + [16-2*p,18,20+2*p] + [21+2*p]*42
  b[R[s[p]]*28+C[s[p]]] = str(p)

 print(*b,sep='')

z is a coded/compressed version of the empty cribbage board.
subs contains a comma separated list of substitutions to decode/uncompress z.  In each substitution, the first letter is the substring to replace and the remainder of the string is the replacement.  The for y in subs.split(','): loop does the substitutions.  For example, Z|*|*|*| causes all 'Z's to be replaced by |*|*|*|.  The compression method was used for its simplicity and effectiveness (its better than the stdlib).  But it could probably be improved or replaced with something better.
Because, Python strings are immutable, b is a list of the characters in the game board.
R is a list mapping a player and score to a row in the ascii game board.  It uses 'L', which is a list or row numbers from which row numbers corresponding to '-------'-rows have been deleted.
Similarly, C maps a player and score to a column in the ascii game board.
Using R and C, the proper peg hole in the game board can be set to the player's number.
Lastly, print(*b,sep='') prints each character in b without inserting a space between adjacent characters.  (Saves a few bytes over using ''.join)

That's a nifty way to do multiple substitutions.

Matricks, 1441 980 bytes
Hooray for esolangs!
Edit: compressed checking each number into a loop to save a ton of bytes. Also made the bottom part "copy" the top (I need a reverse function). I also replaced most ascii characters with their raw values to save a few more. Also, I fixed a bug in the interpreter where number input wasn't working right.
a45;u[m"|;:5:1;];a[a45;u[m42:5:1;];];a{};a{};z:1;a[m32:6:1;a{a{};};];a{a{};};u{};u{};u{};z5:;v[mic%2:42:32;:1:17;s::"|;;s:16:"|;;s:7:32;s:9:32;v[m32:4:7;s1:2:42;s2:4:42;s3:6:42;a[mi(re3)&(c=1):42:32;:4:3;];a[m32:4:7;s3::42;s2:2:42;s1:4:42;];];s3::"|;;s3:16:"|;;s2::47;s1:1:47;s:2:47;s2:16:92;s1:15:92;s:14:92;v[mi(cT3)&(cE13)&(r=1):45:32;:2:17;];a[m32:7:3;];a[a45;u[m"|;:5:1;];a[a45;u[m42:5:1;];];a{};a{};z:1;v[mic%2:42:32;:1:7;];];];u{z43:10;q1:;u{q5:;};u{q4:;z2:;};u{q3:;z4:;};u{q2:;z6:;};u{q1:;z8:;};u{z10:;};q6:;s2::92;s3:1:92;s4:2:92;s2:16:47;s3:15:47;s4:14:47;b[mi(c%2)&(ce6):42:32;:1:10;];};s:1:48;s:2:-1;j1;
s:1:g:1;+1;s:2:g:2;+1;s::n;;ig:;E36:s(40-g:;)*1.2+2:1+g:2;*2:g:1;;:ig:;T80:s(120-g:;)*1.2+2:21+g:2;*2:g:1;;:i(g:;E76)&(g:;T40):s(g:;-31)*1.2-4:15-g:2;*2:g:1;;:ig:;=37:s3+g:2;:2+g:2;*2:g:1;;:ig:;=38:s2+g:2;:8:g:1;;:ig:;=39:s3+g:2;:14-g:2;*2:g:1;;:ig:;=77:s51+g:2;:16-g:2;*2:g:1;;:ig:;=78:s52+g:2;:18:g:1;;:s51+g:2;:20+g:2;*2:g:1;;;;;;;;;;ig:2;e2:j1;:s::;s:1:;;s:2:;

Takes input on command line: python matricks.py <filename> [[]] <num1>,<num2>,<num3> --asciiprint
Matricks is a language of my own creation. Documentation is on the Github page. The most recent update was a bugfix, no new features added or anything.
Breakdown of this solution:

First block created
Block copied to fill entire board
Top curve
Bottom curve
Checking the placement of each number

Python 2, 615 bytes
def f(a):
 D="-";S=" ";A=S*55+D+S;B="|/4 /41/4 - 2  -4-3   -|/4 /43/4 - 2  -4-1   -".replace("4","    ");C=B.replace("/","\\");s=t=u="";d={"1":0,"2":0,"3":0}
 for i in range(23):j=15>i>7;k=i-i/8;x=k%7*5;y=(6-k%7)*5;M=A+S*52+("123","321")[i<8]+D+S+A;N=chr((x,y)[j]/10+49);Q=("|"+N)[i%2]*5+D;s+=(S+S*5*(i<7)+C[x+39:x+34:-1]*j+B[y+39:y+34:-1]*(i>15)+("| "[i<7]+N)[i%2]+D+Q*(7+(i>15))+("|"+N)[i%2]+B[x:x+5]*(i<7)+C[y:y+5]*j+S*(i<16),(M[::-1],M)[i<8])[i%8==7]
 for x in s:
    if "4">x>"0":d[x]+=1;x=("*"+x)[d[x]==a[x]+1]
    t+=x
 for i in range(1512):j=i/27;k=i%27;u+=t[k*57+(56-j,j)[16>k>10and 51>j>5]]+"\n"*(k>25)
 print u

The function is called by passing in a dictionary that contains the scores.  For example:
f({"1":40, "2":70, "3":76})

The byte count reflects indenting the "for x" loop with tabs instead of spaces.
Explanation
The first loop builds the board horizontally into a 57x27 string, with track numbers instead of "holes".
       -|||||-|||||-|||||-|||||-|||||-|||||-|||||-||/
      1-11111-11111-11111-11111-11111-11111-11111-1  /
       -|||||-|||||-|||||-|||||-|||||-|||||-|||||-|  1/
      2-22222-22222-22222-22222-22222-22222-22222-2    -
       -|||||-|||||-|||||-|||||-|||||-|||||-|||||-| 2  -
      3-33333-33333-33333-33333-33333-33333-33333-3    -
       -|||||-|||||-|||||-|||||-|||||-|||||-|||||-|3   -
                                                       -
                                                    321-
                                                       -
    \||-|||||-|||||-|||||-|||||-|||||-|||||-|||||-|3   -
   \  3-33333-33333-33333-33333-33333-33333-33333-3    -
  \3  |-|||||-|||||-|||||-|||||-|||||-|||||-|||||-| 2  -
 -    2-22222-22222-22222-22222-22222-22222-22222-2    -
 -  2 |-|||||-|||||-|||||-|||||-|||||-|||||-|||||-|  1\
 -    1-11111-11111-11111-11111-11111-11111-11111-1  \
 -   1|-|||||-|||||-|||||-|||||-|||||-|||||-|||||-||\
 -
 -321
 -
 -   1|-|||||-|||||-|||||-|||||-|||||-|||||-|||||-|||||-|
 -    1-11111-11111-11111-11111-11111-11111-11111-11111-1
 -  2 |-|||||-|||||-|||||-|||||-|||||-|||||-|||||-|||||-|
 -    2-22222-22222-22222-22222-22222-22222-22222-22222-2
  /3  |-|||||-|||||-|||||-|||||-|||||-|||||-|||||-|||||-|
   /  3-33333-33333-33333-33333-33333-33333-33333-33333-3
    /||-|||||-|||||-|||||-|||||-|||||-|||||-|||||-|||||-|

The second loop copies the string, replacing the numbers with asterisks except at the scoring peg locations.  The peg locations in the straight lines in the middle of the track come out backward.
The third loop changes the orientation to vertical, correcting the pegs in the middle track and adding newline characters.
Try it here

Batch, 1302 1099 1096 1079 bytes
@set s= set
@%s%o=echo
@%o%off
%s%x=41
%s%y=35
%s%z=121
%s%m=-------
%s%w=
%s%p=if %1==
%s%q=if %2==
%s%r=if %3==
%s%l=call:l
%l%
%o%%w%%w%%w%%w% %g% %h% %i%
%o%   %m%---- %w%%m%
%l%
%p%38%s%j=1
%o%  /%w%%j%%w%\  %n%
%l%
%q%38%s%j=2
%o% /%f%%w%%j%%w%%a%\ %n%
%l%
%q%37%s%j=2
%q%39%s%k=2
%o%/   %j%   %c%   %k%   \%n%
%l%
%o%^|%w%%c%   %d%%w%^|%n%
%l%
%o%^|%a% %b% %c%%w%%d% %e% %f%^|%n%
%l%
for /l %%a in (1,1,7)do call:b
%o%%m%   %m%   %m%
%o% %a% %b% %c%    ^|%d% %e% %f%%w%%g% %h% %i%^|
%l%
%o%%w%%w%^|%w%%f%   %g%%w%^|
%l%
%q%77%s%j=2
%q%79%s%k=2
%o%%w%%w%\   %j%   %g%   %k%   /
%l%
%q%78%s%j=2
%o%%w%%w% \%i%%w%%j%%w%%d%/
%r%78%s%j=3
%o%%w%%w%  \%w%%j%%w%/
%o%%w%%w%   %m%----
exit/b
:b
%o%%m%   %m%   %m%
for /l %%a in (1,1,4)do call:o
:o
%o%^|%a%^|%b%^|%c%^|   ^|%d%^|%e%^|%f%^|%n%
:l
for %%a in (a b c d e f g h i j k) do%s%%%a=*
%p%%x%%s%a=1
%q%%x%%s%b=2
%r%%x%%s%c=3
%r%%y%%s%d=3
%q%%y%%s%e=2
%p%%y%%s%f=1
%p%%z%%s%g=1
%q%%z%%s%h=2
%r%%z%%s%i=3
%s%n=   ^^^|%g%^^^|%h%^^^|%i%^^^|
set/ax-=1,y+=1,z-=1

Ungolfed:
@echo off
@rem values that pegs at the very top of each column would be
set x=41
set y=35
set z=121
rem deal with the four custom pegs on the top curve
call :loop
echo                      %g% %h% %i%
echo    -----------      -------
call :loop
if %1==38 (set j=1) else set j=*
echo   /     %j%     \     ^|%g%^|%h%^|%i%^|
call :loop
if %2==38 (set j=2) else set j=*
echo  /%f%     %j%     %a%\    ^|%g%^|%h%^|%i%^|
call :loop
if %2==37 (set j=2) else set j=*
if %2==39 (set k=2) else set k=*
echo /   %j%   %c%   %k%   \   ^|%g%^|%h%^|%i%^|
call :loop
echo ^|     %c%   %d%     ^|   ^|%g%^|%h%^|%i%^|
call :loop
echo ^|%a% %b% %c%     %d% %e% %f%^|   ^|%g%^|%h%^|%i%^|
call :loop
rem deal with the 7 sets of 5 standard rows
call :block
call :block
call :block
call :block
call :block
call :block
call :block
rem deal with the four custom pegs on the bottom curve
echo -------   -------   -------
echo  %a% %b% %c%    ^|%d% %e% %f%     %g% %h% %i%^|
call :loop
echo           ^|     %f%   %g%     ^|
call :loop
if %2==77 (set j=2) else set j=*
if %2==79 (set k=2) else set k=*
echo           \   %j%   %g%   %k%   /
call :loop
if %2==78 (set j=2) else set j=*
echo            \%i%     %j%     %d%/
if %3==78 (set j=3) else set j=*
echo             \     %j%     /
echo              -----------
exit/b
:block
echo -------   -------   -------
call :output
call :output
call :output
call :output
:output
rem prints each of the 35 main rows
echo ^|%a%^|%b%^|%c%^|   ^|%d%^|%e%^|%f%^|   ^|%g%^|%h%^|%i%^|
:loop
rem check for pegs in the current row, also works for some of the curve
if %1==%x% (set a=1) else set a=*
if %2==%x% (set b=2) else set b=*
if %3==%x% (set c=3) else set c=*
if %3==%y% (set d=3) else set d=*
if %2==%y% (set e=2) else set e=*
if %1==%y% (set f=1) else set f=*
if %1==%z% (set g=1) else set g=*
if %2==%z% (set h=2) else set h=*
if %3==%z% (set i=3) else set i=*
rem decrement the first and third columns, increment the second column
set/a x-=1
set/a y+=1
set/a z-=1

Dang, I need to beat this

Very impressive for a batch file.

Java, 1059 1035 bytes
class C{static int[]i=new int[3];String d="-------",l=d+"----";<T>void p(String s,T...o){System.out.format(s+"\n",o);}C(){p("%26s\n%14s%13s\n  /%6s     \\%15s\n /%s%6s%6s\\%14s\n/%4s%4s%4s   \\%13s\n|%6s%4s     |%13s\n|%s%10s|%13s",o(121,0),l,d,s(38,0),t(120,0),s(37,0),s(38,1),s(39,0),t(119,0),s(37,1),s(38,2),s(39,1),t(118,0),s(37,2),s(39,2),t(117,0),o(36,0),o(40,2),t(116,0));for(int j=0;j<7;)g(j++*5);d();p(" %s    |%s%10s|\n%11s%6s%4s     |\n%11s%4s%4s%4s   /\n%12s%s%6s%6s/\n%13s%6s     /\n%24s",o(0,0),o(76,2),o(80,0),"|",s(77,0),s(79,0),"\\",s(77,1),s(78,0),s(79, 1),"\\",s(77,2),s(78,1),s(79,2),"\\",s(78,2),l);}String s(int r,int c){return r==i[c]?c+"":"*";}String t(int r,int d){return l.format("|%s|%s|%s|   ",s(r,d),s(r,1),s(r,2-d));}void r(int r){p(t(35-r,0)+t(41+r,2)+t(115-r,0));}void d(){p(d+"%10s%10s",d,d);}void g(int r){d();for(int j=0;j<5;)r(r+j++);}String o(int r,int d){return l.format("%s %s %s",s(r,d),s(r,1),s(r,2-d));}public static void main(String[]a){for(int j=0;j<3;)i[j]=Integer.decode(a[j++]);new C();}}

Ungolfed:
class Crib {

    static int[] input = new int[3];
    String divider = "-------", longDivider = divider + "----";

    <T> void p(String s, T...o) {
        System.out.format(s+"\n",o);
    }

    Crib() {

        p("%26s", troika(121,0));
        p("%14s%13s", longDivider, divider);
        p("  /%6s     \\%15s", star(38,0), trio(120,0));
        p(" /%s%6s%6s\\%14s", star(37,0), star(38,1), star(39,0), trio(119,0));
        p("/%4s%4s%4s   \\%13s", star(37,1), star(38,2), star(39,1), trio(118,0));
        p("|%6s%4s     |%13s", star(37,2), star(39,2), trio(117,0));
        p("|%s%10s|%13s", troika(36,0), troika(40,2), trio(116,0));
        for(int i = 0; i < 7;)
            group(i++*5);
        printDivider();
        p(" %s    |%s%10s|", troika(0,0), troika(76,2), troika(80,0));
        p("%11s%6s%4s     |", "|", star(77,0), star(79,0));
        p("%11s%4s%4s%4s   /", "\\", star(77,1), star(78,0), star(79, 1));
        p("%12s%s%6s%6s/", "\\", star(77,2), star(78,1), star(79,2));
        p("%13s%6s     /", "\\", star(78,2));
        p("%24s", longDivider);
    }

    String star(int row, int cell) {
        return row == input[cell] ? cell+"" : "*";
    }

    String trio(int row, int diff) {
        return longDivider.format("|%s|%s|%s|   ", star(row, diff), star(row, 1), star(row, 2-diff));
    }

    void printRow(int row) {
        p(trio(35-row, 0) + trio(41+row, 2) + trio(115-row, 0));
    }

    void printDivider() {
        p(divider + "%10s%10s", divider, divider);
    }

    void group(int row) {
        printDivider();
        for(int i = 0; i < 5;)
            printRow(row+i++);
    }

    String troika(int row, int diff) {
        return longDivider.format("%s %s %s", star(row, diff), star(row, 1), star(row, 2-diff));
    }

    public static void main(String[] args) {
        for(int i = 0; i < 3;)
            input[i] = Integer.decode(args[i++]);
        new Crib();
    }
}

Abuses formats (printfs) like mad, which is probably why it's not as small as it could be.

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


text:
N-chotomize a list
Given a list of integers L, and an integer N, output L splitted in N sublists of equal lenghts.
Non-divisible lengths
If N does not divide the length of L, then it is not possible that all sublists have equal length.
In any case, the last sublist of the output is the one that adapts its length to contain the remainder of the list.
This means that all sublists of L except for the last one should be of length length(L) // N, where // is floored division (e.g. 3//2 = 1).
Some rules

L can be empty.
N >= 1.
You may use any built-in you want.
You may take the input through STDIN, as a function argument, or anything similar.
You may print the output to STDOUT, return it from a function, or anything similar.
You may chose any format for the lists and the integer as long as it is the most natural representation of lists and integers in your language.

Test cases
Input:  [1,2,3,4], 2
Output: [[1,2],[3,4]]

Input:  [-1,-2,3,4,-5], 2
Output: [[-1,-2],[3,4,-5]]

Input:  [1,2,3,4], 1
Output: [[1,2,3,4]]

Input:  [4,8,15,16,23,42], 5
Output: [[4],[8],[15],[16],[23,42]]

Input:  [4,8,15,16,23,42], 7
Output: [[],[],[],[],[],[],[4,8,15,16,23,42]]

Input:  [2,3,5,7,11,13,17,19,23], 3
Output: [[2,3,5],[7,11,13],[17,19,23]]

Input:  [], 3
Output: [[],[],[]]

Input:  [1,2,3,4,5,6,7,8], 3
Output: [[1,2],[3,4],[5,6,7,8]]

Scoring
This is code-golf, so the shortest answer in bytes wins.

Related

Also related

Only positive integers? Or maybe add a test case

@LuisMendo No. I changed a test case to reflect that.

A list of length 8 with length n=3 (suggested by user2357112) would be a good test case -- it broke my method.

Pyth, 11 10 bytes
1 byte thanks to @FryAmTheEggman.
cJEt*R/lJQ

Test suite.
Takes inputs in reversed order.
Sample input:
5
[1,2,3,4,5,6,7]

Sample output:
[[1], [2], [3], [4], [5, 6, 7]]

Explanation
cJEt*R/lJQ     Main function, first input:Q, second input:E.
cJEt*R/lJQQ    Implicit arguments.

c              The function c is special.
               It can chop arrays.
               If the second argument is a list of integers,
               then it chops the first array at the indices
               specified by the second array.

 JE            The first argument is the second input, stored
               to the variable J.

   t*R/lJQQ    This is the second argument.
      /lJQ     Yield length of J, integer-divided by Q.
    *R    Q    Multiply it to the following respectively:
                   [0,1,2,3,...,Q-1]
   t           Then throw away the first element.
               For example, if Q=3 and E=[1,2,3,4,5,6,7,8],
               we would now have [3,6].

JavaScript (ES6), 63 bytes
(a,n,l=a.length/n|0)=>[...Array(n)].map(_=>--n?a.splice(0,l):a)

K (ngn/k), 18 17 bytes
-1 thanks to @coltim
{*[!y;(-y)!#x]_x}

Try it online!

Can trim a byte by using the M-expression form of *, i.e. {*[!y;(-y)!#x]_x}

@coltim Do you have a link to or explanation of M-expressions?

It's taken from (early) lisp, per https://en.wikipedia.org/wiki/M-expression . basically, x*y is equivalent to *[x;y] (the brackets bind tightly). it's also how K handles calling functions with more than two args, e.g. f4[a;b;c;d].

Haskell, 69 67 bytes
a%b=a#b where l#1=[l];l#n|(h,t)<-splitAt(div(length a)b)l=h:t#(n-1)

Usage example: [1,2,3,4] % 3 -> [[1],[2],[3,4]].
A simple recursive approach, similar to @xnor's answer.
Edit: @Will Ness saved 2 bytes. Thanks!

h:t#(n-1) also works.

Python, 76 73 bytes
lambda L,N:list(map(lambda x,r=len(L)//N:L[x*r:][:r+(x>N-2)*N],range(N)))

Basically an unnamed function that performs the task.
Thanks to LeakyNun for the bytes saved!

Also, welcome to PPCG!

@LeakyNun Nun It's 73 I think actually. Also it's mostly my fault as I wasn't paying much attention while editing. Perils of codegolfing at work :P

@LeakyNun - to the first point - it doesn't work. The expression basically is [:r] for regular items and [:r+N] for the last item, which is supposed to catch all the remaining elements. The second point - I tried but all the ways I know that let me assign r make it longer than my code.

It would, but in the case of r*(x>N-2) it's [:0] , not [:].

Well, here

You don't need the list(...) for python 2

Even with the nice trick of saving r as an optional argument, it's shorter to just do a  list comp and repeat the expression: lambda L,N:[L[len(L)//N*x:][:len(L)//N+(x>N-2)*N]for x in range(N)]. In Python 2, the // can be /.

Common Lisp, 114 bytes
(defun f(l n &optional(p(floor(length l)n))(i 1))(if(= i n)(list l)(cons(subseq l 0 p)(f(subseq l p)n p(+ i 1)))))

Ungolfed:
(defun f (l n &optional (p (floor (length l) n)) (i 1))
  (if (= i n) (list l)
              (cons (subseq l 0 p)
                    (f (subseq l p) n p (+ i 1))))
  )

Example call:
(format t "~A~C~C" (f (read) (read)) #\return #\newline)

Try it here!
Basically:

If we are cutting the last group, return whatever's left of the initial list.
Otherwise take p = |L| / N elements out of the list and join that to the result of a recursive call on the remainder. i is an iteration counter used for the stop condition.

I had misunderstood the challenge at first, thinking the program should build groups of N elements rather than N groups. Anyway, this version does the job for an extra 10 bytes. LisP won't win this time but I couldn't really miss the opportunity :')

J, 29 bytes
-@[{.(I.@(<.@%~+-@[{.|)#)</.]

Attempt This Online!
-2 thanks to Jonah for noticing that </. (grouping) followed by -@[{. (add enough empty groups) works. Why it works with an empty vector input is a mystery...

J, 31 bytes
]<@#~i.@[=/(I.@(<.@%~+-@[{.|)#)

Attempt This Online!
After all sorts of approaches tried and thrown away, I finally settled with the one that creates a boolean matrix and gives the chunks via #. Most others suffered badly when the "regular buckets" are empty.
For the input of 3 and [1 2 3 4 5 6 7 8],
]<@#~i.@[=/(I.@(<.@%~+-@[{.|)#)
           (                 #)    call inner function with 3 and length of array (8):
               (<.@%~       )      size of regular bucket (2)
                           |       number of extra elements (2)
                      -@[{.        left-pad with zeros to the length of 3; [0 0 2]
                     +             elementwise add; [2 2 4]
            I.@    copy each index by the element; [0 0 1 1 2 2 2 2]
     i.@[          range of 3; [0 1 2]
         =/        outer product by equality;
                   [[1 1 0 0 0 0 0 0]
                    [0 0 1 1 0 0 0 0]
                    [0 0 0 0 1 1 1 1]]
]<@#~    for each row of the above, keep places corresponding to 1s;
         {[1 2] [3 4] [5 6 7 8]}

If I don't need to handle the cases where empty buckets are present, i.@[=/ can be golfed to =@.

Using the boolean matrix to group is cool but you can actually take just the right part of your answer with a normal /. for 29: -@[{.(I.@(<.@%~+-@[{.|)#)</.].  It's weird I thought I had tried that myself but must not have landed on that exact phrasing.  I think <.@%~+-@[{.| is a bit golfier than what I must have had.

Vyxal, 67 bitsv2, 8.375 bytes
L>ßwṘÞ÷RṘ

Try it Online!
Bitstring:
0110000000101110001001111010001000011101011000101111111101011010001

J, 34 bytes
](],#@;@]<@}.[)<:@[{.-@(<.@%~#)<\]

Try it online!
This was way harder than it should have been, and I threw away two approaches before getting this, which still feels long.

(<.@%~#) Integer divide list size by n.  This will be the "regular" bucket size (ie, the size of buckets which are not the final, variable bucket).
-@...<\] Break up the list into buckets of those size.  This will result in an extra bucket when the list is not evenly divisible.
<:@[{. From that list of buckets, take one less than n.  This many buckets are guaranteed to be the regular size.  Note that if size of the original list is less than n, these regular buckets will have size 0.
(],#@;@]<@}.[) To these regular elements append ], all the remaining elements #@;@]<@}.[.  That is, if there are r regular elements, kill the first r elements of the original list and put everything that remains into a single bucket.  That is the final bucket which we'll append to the regular buckets.  In the case of an evenly divisible list, it will be just one more regular element.  Otherwise it will be a final jumbo element.

J, 34 bytes, K answer port (ish)
-@[{.]<;.1~i.@#@]<@e.i.@[*(<.@%~#)

Try it online!
bstrat's K answer inspired me to revisit an earlier approach of mine, which at a high-level was almost identical.
The difference in length between the J and K answers highlights  interesting differences between K's cut primitive (which specifies cut points by indexes) and J's (which requires a boolean array where ones specify cut points).  The J approach fares quite poorly in this problem, and requires additional post processing to make the empty cells match the problem specification.
Another approach I tried was using J's "remove the fret points" cut option to get the empty cells correct in a natural way, but doing this requires you to duplicate the fret points just-so, and thus incurs a heavy pre-processing cost.

Prolog, 100 99 bytes.
n(A,B):-length(B,A).
p(L,K,G):-n(K,G),append(A,[_],G),n(N,L),M is N//K,maplist(n(M),A),append(G,L).

Call e.g.

?- p( [1,2,3,4,5,6,7], 3, X).
  X = [[1, 2], [3, 4], [5, 6, 7]] .

F#, 100 98 bytes
fun n l->
let a=List.length l/n
List.init n (fun i->if i<n-1 then l.[a*i..a*i+a-1] else l.[a*i..])

Using F# list slicing, with an if clause deciding whether to pick a elements or all remaining elements.

PowerShell v2+, 125 bytes
param($l,$n)if($p=[math]::Floor(($c=$l.count)/$n)){1..$n|%{$l[(($_-1)*$p)..((($_*$p-1),$c)[!($_-$n)])]}}else{(,''*($n-1))+$l}

Feels too long, but I can't seem to come up with a way to get the slicing to work happily if there are empty arrays in the output, so I need the encapsulating if/else to handle those cases. Additionally, since PowerShell's default .ToString() for arrays via console output can look a little weird, you can tack on a -join',' to show the arrays as comma-separated rather than newline-separated on the console. I've done that in the examples below to make the output more clear, but you won't want to do that if you're leaving the output on the pipeline for another command to pick up.
Explanation
Takes input param($l,$n) for the list and number of partitions, respectively. We then enter an if/else statement. If the size of each partition, $p is non-zero (setting helper $c to be the .count along the way), we're in the if.
Inside the if, we loop from 1 to $n with |%{...}, and each iteration we're doing a pretty complex-looking array slice $l[(($_-1)*$p)..((($_*$p-1),$c)[!($_-$n)])]. The first parens is our start index, based on what partition we're on and how big our partition size is. We range that .. with our end index, which is formed from a pseudo-ternary. Here, we're choosing between either $c (the literal end of the array), or the length of our partition, based on whether we're in the last chunk $_-$n or not.
Otherwise, we're in the else. We construct an empty array with the comma-operator ,''* equal to one fewer partitions than requested, and then tack on the input array as the final element.
Examples
Here I'm showing the partitions separated with newlines and each individual element separated with ,, as described above.
PS C:\Tools\Scripts\golfing> .\n-chotomize-a-list.ps1 (1,2,3,4) 2
1,2
3,4

PS C:\Tools\Scripts\golfing> .\n-chotomize-a-list.ps1 (-1,-2,3,4,-5) 2
-1,-2
3,4,-5

PS C:\Tools\Scripts\golfing> .\n-chotomize-a-list.ps1 (1,2,3,4) 1
1,2,3,4

PS C:\Tools\Scripts\golfing> .\n-chotomize-a-list.ps1 (4,8,15,16,23,42) 5
4
8
15
16
23,42

PS C:\Tools\Scripts\golfing> .\n-chotomize-a-list.ps1 (4,8,15,16,23,42) 7

4,8,15,16,23,42

PS C:\Tools\Scripts\golfing> .\n-chotomize-a-list.ps1 (2,3,5,7,11,13,17,19,23) 3
2,3,5
7,11,13
17,19,23

PS C:\Tools\Scripts\golfing> .\n-chotomize-a-list.ps1 $null 3

PS C:\Tools\Scripts\golfing>

JavaScript (Node.js), 56 bytes
f=(a,n,l=a.length/n|0)=>[a,...--n?f(a.splice(l),n,l):[]]

Try it online!

PHP, 109 Bytes
<?for($n=(count($a=$_GET[0]))/($d=$_GET[1])^0;$i<$d;)$r[]=array_slice($a,$i*$n,++$i==$d?NULL:$n);print_r($r);

All Testcases


text:
Shortest simple regex matching a binary word
Task
Define a simple regex as a non-empty regular expression consisting only of

characters 0 and 1,
grouping parentheses ( and ),
one-or-more repetition quantifier +.

Given a non-empty string of 0s and 1s, your program should find the shortest simple regex matching the full input string. (That is, when matching a simple regex, pretend it’s bookended by ^ and $.) If there are multiple shortest regexes, print any or all of them.)
code-golf, so the shortest submission (in bytes) wins.
Test cases
1 -> 1
00 -> 00 or 0+
010 -> 010
1110 -> 1+0
01010 -> 01010
0101010 -> 0(10)+ or (01)+0
011111 -> 01+
10110110 -> (1+0)+
01100110 -> (0110)+ or (01+0)+
010010010 -> (010)+
111100111 -> 1+001+ or 1+0+1+
00000101010 -> 0+(10)+ or (0+1)+0
1010110001 -> 1(0+1+)+ or (1+0+)+1

You should clarify that you want us to write a program that writes the regex, not write the regex ourself. But this looks interesting.

In my testing, 01100110 is an interesting case... a naïve algorithm would write 01+0+1+0 or (0+1+)+0 which aren't optimal.

Related.

Pyth, 20 bytes
hf.x}z:zT1Zy*4"()01+

This takes approximately 30 seconds to run, so it needs to be run offline.
Explanation:
hf.x}z:zT1Zy*4"()01+
                        Implicit: z is the input string.
              "()01+    "()01+"
            *4          Repeated 4 times
           y            All subsequences in length order
hf                      Output the first one such that
      :zT1              Form all regex matches of z with the candidate string
    }z                  Check if the input is one of the strings
  .x      Z             Discard errors

I'm not completely sure that every shortest string is a subsequence of "()01+" * 4, but 4 can be increased to 9 at no byte cost if needed.

JavaScript (ES6), 488 341 bytes
s=>[s.replace(/(.)\1+/g,'$1+'),...[...Array(60)].map((_,i)=>`(${(i+4).toString(2).slice(1)})+`),...[...Array(1536)].map((_,i)=>`${i>>10?(i>>8&1)+(i&2?'+':''):''}(${i&1}${i&4?i>>4&1:i&16?'+':''}${i&8?''+(i>>7&1)+(i&64?i>>5&1:i&32?'+':''):''})+${i&512?(i>>8&1)+(i&2?'+':''):''}`)].filter(r=>s.match(`^${r}$`)).sort((a,b)=>a.length-b.length)[0]

Explanation: Since six regexes can express all possible binary words, and the longest two are nine characters long, it suffices to check those and all shorter regexes. One candidate is obviously the string with "run length encoding" (i.e. all digit runs replaced with appropriate +s), but also strings with one set of ()s need to be checked. I generate 1596 such regexes (this includes duplicates and useless regexes but they'll just be eliminated) and test all 1597 to see which is the shortest match. The generated regexes fall into two types: \(\d{2,5}\)\+ (60 regexes) and (\d\+?)?\(\d[\d+]?(\d[\d+]?)?\)(\d\+?)? (1536 regexes as I avoid generating regexes with both leading and trailing digit).

@LeakyNun Originally I thought there were 4 regexes of length 9 but this is obviously incorrect so I've clarified my explanation.

Pyth - 31 30 29 bytes
Brute force! Can probably golf the iterator a little.
 f=+Yf.x:zjY"^$")Z^"10+()"T1Y

Test Suite.

Ruby, 109 bytes
It's the boring brute force approach. Works because no regex ever need be longer than 9 characters (as Neil notes) and no individual character needs to be repeated more than 4 times (trying it with '01()+'.chars*9 made my CPU unhappy).

10.times{|i|('01()+'.chars*4).combination(i).map{|s|begin
/^#{s*''}$/=~$*[0]&&[puts(s*''),exit]
rescue
end}}

$ for word in `grep -Po '^\S+' test_cases.txt`; do nice -n20 ruby sre.rb $word; done
1
0+
010
1+0
01010
0(10)+
01+
(1+0)+
(01+0)+
(010)+
1+0+1+
0+(10)+
1(0+1+)+

Python 3, 186 bytes
I'm investigating whether there is an approach to this problem besides brute-forcing, but here is a Python brute-force solution for now.
import re,itertools
def a(b):
 for z in range(10):
  for i in itertools.combinations("01()+"*4,z):
   j=''.join(i)
   try:
    if re.fullmatch(j,b)and len(j)<=len(b):return j
   except:1


text:
The happy Ender problem
The happy ending problem (actually a theorem) states that

Any set of five points in the plane in general position has a subset of four points that form the vertices of a convex quadrilateral.

The problem was so named by Paul Erdős when two mathematicians who first worked on the problem, Ester Klein and George Szekeres, became engaged and subsequently married.
Clarifications:

General position here means that no three points are collinear.
The quadrilateral formed by the four vertices will always be considered to be non-intersecting, irrespective of the order of the points. For example, given the four points [1 1], [1 2], [2 1], [2 2] the intended quadrilateral is the square, not the bow-tie:

A non-intersecting quadrilateral is convex if no interior angle exceeds 180 degrees; or equivalently if both diagonals lie inside the quadrilateral.

The challenge
Given 5 points with positive integer coordinates, output 4 of those points that form a convex quadrilateral.
Rules
If there are several solutions (that is, several sets of 4 points), you can consistently choose to output one of them or all.
Input and output formats are flexible as usual (arrays, lists, list of lists, strings with reasonable separators, etc).
Code golf, fewest bytes wins.
Test cases

Input:
[6 8] [1 10] [6 6] [5 9] [8 10]

There is only one possible output:
[6 8] [1 10] [6 6] [5 9]

Input:
[3 8] [7 5] [6 9] [7 8] [5 1]

There are five solutions:
[3 8] [7 5] [6 9] [7 8]
[3 8] [7 5] [6 9] [5 1]
[3 8] [7 5] [7 8] [5 1]
[3 8] [6 9] [7 8] [5 1]
[7 5] [6 9] [7 8] [5 1]

Input:
[4 8] [1 9] [9 9] [10 2] [1 6]

There are three solutions:
[4 8] [1 9] [10 2] [1 6]
[4 8] [9 9] [10 2] [1 6]
[1 9] [9 9] [10 2] [1 6]

To illustrate, here are the three solutions to this case:

I'm expecting an answer from Martin with a positive emotion expressed therein.

The happy ending problem is not to be confused with the happy Ender problem, which is to find a way to prevent military recruits from discovering the simulations they're playing are real.

CJam, 37 34 32 bytes
{e!Wf<{2*3ew{)f.-~W%.*:-V>},!}=}

Not sure if :-V is happy enough, but as K Zhang points out, there's the =} at the end. :)
This only prints one solution because removing duplicates would be more expensive.
Test it here.
Explanation
The idea is fairly simple. We generate all possible quadrilaterals (including all orderings of the points) and then just select the convex ones. We test convexity by looking at every pair of edges and checking that they're all turning in the same direction.
The turning sense can be obtained quite easily from a dot product. If you take the three consecutive points on a quadrilateral, and draw lines from the first to the second, and the first to the third, and then project the latter onto the perpendicular of the former... you get a number whose sign tells you whether these three points turn left or right. (I should probably add a diagram for this.) This "projecting onto the perpendicular" is sounds quite involved, but really just means that we reverse one of the two vectors and subtract the components after multiplication instead of adding them. So here's the code...
e!       e# Generate all permutations of the five input points.
Wf<      e# Discard the fifth point in each permutations, giving all
         e# possible quadrilaterals.
{        e# Select the first for which this block gives a truthy result...
  2*     e#   Double the list of points, so that it includes each cyclically
         e#   adjacent set of three points.
  3ew    e#   Get all sublists of length 3, i.e. all sets of three consecutive
         e#   points (with two duplicates).
  {      e#   Filter these sets of three points...
    )    e#     Pull off the last point.
    f.-  e#     Subtract it from the other two, giving vectors from it to
         e#     to those.
    ~    e#     Unwrap the array dumping both vectors on the stack.
    W%   e#     Reverse one of them.
    .*   e#     Element-wise multiplication.
    :-   e#     Subtract the second element from the first. This completes
         e#     the projection.
    V>   e#     Check whether it's greater than 0. This is *false* for right-
         e#     turning sets of three points.
  },     e#   If all corners are right-turning, this will result
         e#   in an empty array.
  !      e#   Logical NOT - hence, only quadrilaterals where all corners
         e#   are right-turning give something truthy.
}=

Sure, a happy duck!

@LuisMendo I think the last two characters look more like a smiley =}

!} could be considered a wink too

Jon Skeet of CodeGolf.. this is amazing

MATLAB, 67 bytes
I=input('');for k=~eye(5);if nnz(convhull(I(k,:)))>4;I(k,:),end;end

Input is in the form of a 2D matrix where the columns are X and Y respectively:
[6 8; 1 10; 6 6; 5 9; 8 10]
[3 8; 7 5; 6 9; 7 8; 5 1]
[4 8; 1 9; 9 9; 10 2; 1 6]

All sets of 4 points that create convex quadrilaterals are displayed in the same format.
Here is a demo that is slightly modified to work with Octave
Explanation
This solution takes all subsets of 4 points of the input (order doesn't matter). To do this, we create the identity matrix and negate it: ~eye(5). We loop through the columns of this matrix and k (the loop index) is a logical array which specifies which of the 4 points to consider. We then use this to grab these 4 XY points from the input (I(k,:)).
We then compute the convex hull of these 4 points (convhull). The output of convhull is the indices of the input that correspond with the points that make up the convex hull (with the first index duplicated to close the hull).
For a convex quadrilateral, all four points will be part of the convex hull of the same points (nnz(convhull(points)) > 4). If we detect that this is the case, we display the points that were used for this particular iteration.

Mathematica 105 96 bytes
Select[#~Subsets~{4},f@#&]& selects, from a list of (5) points, those subsets of 4 points that satisfy f.
f is satisfied when each point, of the 4 points in a set, lies on the RegionBoundary of the ConvexHull of the 4 points.
f@p_:=Apply[And,RegionBoundary@ConvexHullMesh@p~RegionMember~#&/@p];
Select[#~Subsets~{4},f@#&]&

Test Cases
1. Let's look at at the 5 convex hulls of subsets (each of 4 points) of {{6, 8}, {1, 10}, {6, 6}, {5, 9}, {8, 10}}.
Select[#~Subsets~{4},f@#&[{{6, 8}, {1, 10}, {6, 6}, {5, 9}, {8, 10}}]

{{{6, 8}, {1, 10}, {6, 6}, {5, 9}}}

{{6, 8}, {1, 10}, {6, 6}, {5, 9}}  is the only solution; each of the four points serves as a vertex of the convex hull (of the same 4 points).

{{6, 8}, {1, 10}, {6, 6},{8, 10}} is not a solution; the convex hull has only 3 vertices.  {6, 8} lies within the hull.

The remaining subsets also are not solutions:

2. {{4, 8}, {1, 9}, {9, 9}, {10, 2}, {1, 6}} has three solutions.
Select[#~Subsets~{4},f@#&[{{4, 8}, {1, 9}, {9, 9}, {10, 2}, {1, 6}}]

{
{{4, 8}, {1, 9}, {10, 2}, {1, 6}},
{{4, 8}, {9, 9}, {10, 2}, {1, 6}},
{{1, 9}, {9, 9}, {10, 2}, {1, 6}}
}

3. {{3, 8}, {7, 5}, {6, 9}, {7, 8}, {5, 1}} has 5 solutions.
Select[#~Subsets~{4},f@#&[{{3, 8}, {7, 5}, {6, 9}, {7, 8}, {5, 1}}]

{
{{3, 8}, {7, 5}, {6, 9}, {7, 8}},
{{3, 8}, {7, 5}, {6, 9}, {5, 1}},
{{3, 8}, {7, 5}, {7, 8}, {5, 1}},
{{3, 8}, {6, 9}, {7, 8}, {5, 1}},
{{7, 5}, {6, 9}, {7, 8}, {5, 1}}
}
Note that each of the five points lies on the boundary of the convex hull of all points.
If any one of the points is removed, the remaining 4 points will each be vertices of the reduced convex hull.

Javascript (ES6), 306 293 283 bytes
c=(v,w,x)=>(w[0]-v[0])*(w[1]-x[1])-(w[1]-v[1])*(w[0]-x[0])>0?1:0
i=(v,w,x,y)=>(c(v,w,x)+c(w,x,y)+c(x,y,v)+c(y,v,w))%4==0&&r.push([v,w,x,y])
j=(v,w,x,y)=>{i(v,w,x,y);i(v,w,y,x);i(v,x,w,y)}
k=(v,w,x,y,z)=>{j(v,w,x,y);j(v,w,x,z);j(v,w,y,z);j(v,x,y,z);j(w,x,y,z)}
f=(v)=>(r=[],k(...v),r)

Explanation:
The function c computes the cross product of the vector between 3 adjacent points of the polygon and returns 1 if it is positive and 0 otherwise (note: the cross product cannot be zero as the points cannot be co-linear).
j=(v,w,x,y)=>{i(v,w,x,y);i(v,w,y,x);i(v,x,w,y)}
k=(v,w,x,y,z)=>{j(v,w,x,y);j(v,w,x,z);j(v,w,y,z);j(v,x,y,z);j(w,x,y,z)}

The function k and j generate all cyclic permutations (ignoring reversing the order) of the input array.
i=(v,w,x,y)=>(c(v,w,x)+c(w,x,y)+c(x,y,v)+c(y,v,w))%4==0&&r.push([v,w,x,y])

The function 'i' is then called for each cyclic permutation to calculate the sum of the function c for each of the 4 triplets of adjacent co-ordinates. If the cross products all have the same sign then they will all either be 0 or 1 and total to 0 (modulo 4) and the polygon is concave and is pushed into the output array. If any triplet has a different sign then the total will be non-zero (modulo 4) and the polygon is convex.
f=(v)=>(r=[],k(...v),r)

The function f is used to initialise the output array and then call the above functions before returning the output.
Tests:

c=(v,w,x)=>(w[0]-v[0])*(w[1]-x[1])-(w[1]-v[1])*(w[0]-x[0])>0?1:0
i=(v,w,x,y)=>(c(v,w,x)+c(w,x,y)+c(x,y,v)+c(y,v,w))%4==0&&r.push([v,w,x,y])
j=(v,w,x,y)=>{i(v,w,x,y);i(v,w,y,x);i(v,x,w,y)}
k=(v,w,x,y,z)=>{j(v,w,x,y);j(v,w,x,z);j(v,w,y,z);j(v,x,y,z);j(w,x,y,z)}
f=(v)=>(r=[],k(...v),r)

tests = [
  [[6,8],[1,10],[6,6],[5,9],[8,10]],
  [[3,8],[7,5],[6,9],[7,8],[5,1]],
  [[4,8],[1,9],[9,9],[10,2],[1,6]]
];

tests.forEach(
  (test,i)=>{
    console.log( "Test " + (i+1) );
    f(test).forEach(
      (x)=>console.log( "  " + x.map((e)=>"("+e[0]+","+e[1]+")").join(','))
    );
  }
);

Edit:
Can also handle co-linear points using the original version and changing the first two lines to:
t=(a,b,c)=>Math.sign((b[0]-a[0])*(b[1]-c[1])-(b[1]-a[1])*(b[0]-c[0]))
p=(a,b,c,d)=>[t(a,b,c),t(b,c,d),t(c,d,a),t(d,a,b)].filter(x=>x).reduce((p,c,i,a)=>p&c==a[0],1)
q=(a,m,n,o)=>[a[0],a[m],a[n],a[o]]
f=(a)=>{r=[];for(i=0;i<5;i++){b=a.slice();b.splice(i,1);r.push(q(b,1,2,3));r.push(q(b,1,3,2));r.push(q(b,2,1,3))}return r.filter((a)=>p(...a))}

However, since that case is specifically excluded in the question then the extra characters aren't necessary.


text:
Calculate the 3BV of a Minesweeper Board
The 3BV of a Minesweeper board represents the minimum number of left clicks required to solve the board if you already know the solution. It stands for "Bechtel's Board Benchmark Value". Here's his site explaining it.
Below is a solved Minesweeper board. The flags indicate mines; tiles without mines indicate the count of adjacent mines, including diagonally, except that tiles that should have "0" are left blank instead. The image shows which tiles need to be clicked in order to solve the board.

Clicks counted towards the 3BV are:

One for each flood-filled area of blank tiles (zero mines adjacent) and their non-blank neighbors.
One for each other non-mine tile.

Another Example (3BV = 39)

Given a 2D array of values, 0 for clear and 1 for a mine (or a boolean), return the 3BV.
A board's dimensions will be at least 8x8, and at most 24x30, inclusive. Your program should handle all possible boards, not just the examples.
Note: A board will never contain only mines.
Example I/O:
[[0,0,0,0,0,0,0,0],
[0,0,0,1,0,0,0,0],
[0,0,0,1,0,0,1,0],
[0,1,0,0,1,0,0,0],
[0,0,1,0,0,0,0,1],
[0,0,0,1,0,0,0,0],
[0,0,0,0,0,0,1,0],
[0,0,0,0,0,0,0,1]]

23

[[0,0,1,0,0,0,1,1,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0],
[0,0,0,0,0,1,1,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0],
[0,1,0,0,0,0,1,0,0,1,0,1,0,0,1,0,0,1,0,1,1,0,0,0,1,0,1,0,1,0],
[0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,1,0,0,0],
[0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0],
[0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,1,0,1],
[0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,1],
[0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0],
[0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0],
[0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,1,0,0,0],
[1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,1,1],
[0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,1,0,1,1,0,0,0,0,1,1,0,0],
[0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,1,0,1,1,0,0,0,1,0,0,0,1,1,0,0],
[0,1,1,1,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0],
[0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0],
[0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0]]

187

Is an array of integers okay as input? Each integer codes one row.

@KarlNapf No. The input should be recognizable as a board as shown.

Could you provide more test cases, possibly including the input based on the displayed images, and maybe a max dimensions test case?

MATLAB, 92 90 86 83 79 74 72 bytes
x=input('');I=@(x)~imdilate(x,ones(3));[C,N]=bwlabel(I(x));nnz(I(C)-x)+N

This solution accepts the input in the form of a 2D matrix of 0's and 1's and will display the 3BV value for the provided input.
Here is slightly modified demo in Octave for those of you without MATLAB.
Explanation
The input matrix is dilated using a 3 x 3 matrix of 1's and then inverted (using ~) which identifies all of the points that do not have mines as neighbors (1) or do (0). To determine the number of connected regions, we use bwlabel to label each connected region of 1's. The first output is the label matrix (0 where the input was zero and any value in the range 1...N where there was a 1 in the input where N is the index of the connected group that it belongs to). The second output is the number of regions (the number of clicks required to open them). The result of the bwlabel is shown in the image on the left.

We expand the first output of bwlabel using imdilate (all non-zeros are expanded) using a 3 x 3 matrix of 1's. The result is shown in the image in the middle.
To determine the remaining clicks, we then count the squares that are not in this expanded region (~imdilate()) and not a mine (-x) (white squares in the image on the right) and add this to the total number of open regions (the number of different colors in the image on the left) to get the 3BV.

Octave, 86 84 79 66 bytes
@(x)nnz(~imdilate(c=imerode(~x,o=ones(3)),o)-x)+max(bwlabel(c)(:))

This solution creates an anonymous function named ans which can then be passed a 2D matrix of 0's and 1's. The logic is the same as my MATLAB answer but uses a few tricks that Octave has to offer to save space.
This solution requires that the image package is installed.
Demo here

MATL, 24 22 21 bytes
1 byte saved thanks to @Luis
4Y6Z+~l2#ZIw7MZ+G+~z+

Try it at MATL Online
Explanation
Again, this is similar to my MATLAB and Octave answers to this question.
        % Implicitly grab input array
4Y6     % Push the literal [1 1 1; 1 1 1; 1 1 1] to the stack
Z+      % Perform 2D convolution of the input with this array
~       % Negate the result
l2#ZI   % Call bwlabeln which dilates each open region and the second output
        % returns the number of open regions
w       % Flip the top two stack elements
7M      % Push the literal [1 1 1; 1 1 1; 1 1 1] to the stack again
Z+      % Perform 2D convolution
G+      % Explicitly grab the input and add it to the result
~z      % Count the number of 0's in the result (the remaining number of clicks)
+       % Add the total number of remaining clicks to the number of open regions

Noncompeting why?

@CalculatorFeline Unfortunately the bwlabeln functionality was introduced to MATL after the challenge was posted.


text:
Write a program that always prints N when it is shifted N times up the ASCII alphabet
Write a program using only printable ASCII characters that takes no input. For reference, here are the 95 printable ASCII characters in order:
 !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~

When your program is run it should print 0 (plus an optional trailing newline) to stdout, then terminate normally.
When each character in your program is replaced by the character N spaces to its right in printable ASCII, looping around from ~ to space, the resulting printable ASCII string will ideally be a program runnable in the same language that takes no input and outputs N (plus an optional trailing newline) to stdout, then terminates normally, for N = 1 to 94.
For example, if your original program was
@Cat~(88 !)

running it should output 0 and shifting all the characters up the printable ASCII scale by one
ADbu )99!"*

should result in another program that outputs 1. Doing so again will ideally result in another program that outputs 2
BEcv!*::"#+

and so on with 3 and 4, etc. up to the point of shifting 94 times
?B`s}'77~ (

which ideally is a program that outputs 94.
The relief is that this is only the ideal behavior. Your program and its 94 derivatives do not all need to work, but the more that consecutively do from the start the better. (Programs that do not work may have any behavior whatsoever.)
Scoring
Your score is the number of consecutive programs starting from the original (the one that outputs 0) that do work, i.e. correctly output their corresponding N. The answer with the highest score (a maximum of 95) wins. If there's a tie then the program with the shortest length in bytes wins.
For example, if @Cat~(88 !) output 0 and ADbu )99!"* output 1 but BEcv!*::"#+ errored, then your score would be 2. It's 2 even if ?B`s}'77~ ( accurately outputs 94 and even if all the programs for N = 30 to 40 worked. Only the consecutive number of working programs, starting at zero, are counted.
Notes

To combat potential contention and loopholes, competing answers must output their numbers in decimal with no leading zeroes or signs or decimal points (i.e. plain 0 1 2 ... 94).
Languages that use different bases or number formats are allowed but are not eligible to win.
The presence of an optional trailing newline does not need to be consistent across programs.
Functions and REPL commands are not allowed, only full programs.

Is it OK to have ans = 0?

@StewieGriffin Sorry but to go along with the first note it should be plain 0 printed to stdout. You can do a noncompetitive answer though.

I think we should repost this problem with the following two additional restrictions: 1) The program must be written in a language whose compiler or interpreter does not ignore invalid syntax without explicit comment delimiters, and 2) every iteration of the program must use an explicit print statement to write out the answer. This would make the challenge more meaningful and, I would suspect, result in more answers in C-like languages, which I assume was what you desired from this challenge.

As it is, all the answers seem to be some variation of "repeat the same statement 95 times except 94 of them are ignored due to some syntactic quirk". That's not interesting.

@JoeZ. Yeah. When writing it I didn't consider that type of program. You're welcome to post a new similar challenge.

Ook!, 95 programs, 19992 14066 bytes
Ook!Ook!Ook!Ook?Ook.Ook?Ook.Ook.Ook?Ook.Ook!Ook!Ook!Ook!Ook!Ook!Ook!Ook!Ook!Ook!Ook?Ook!Ook.Ook?Ook!Ook!Ook!Ook!Ook!Ook!Ook!Ook.NJ_.NJ_.NJ_.NJ}.NJl.NJ}.NJl.NJl.NJ}.NJl.NJ_.NJ_.NJ_.NJ_.NJ_.NJ_.NJ_.NJ_.NJ_.NJ_.NJ}.NJ_.NJl.NJ}.NJ_.NJl.NJ_.NJl-)>l-)>l-)>l-)\l-)Kl-)\l-)Kl-)Kl-)\l-)Kl-)>l-)>l-)>l-)>l-)>l-)>l-)>l-)>l-)>l-)>l-)\l-)>l-)Kl-)\l-)Kl-)Kl-)Kl-)Kl-)Kl-)Kl-)>l-)Kl-)>l-)Kkg|Kkg|Kkg|Kkg;Kkg*Kkg;Kkg*Kkg*Kkg;Kkg*Kkg|Kkg|Kkg|Kkg|Kkg|Kkg|Kkg|Kkg|Kkg|Kkg|Kkg;Kkg|Kkg*Kkg;Kkg*Kkg*Kkg|Kkg*JF[*JF[*JF[*JFy*JFh*JFy*JFh*JFh*JFy*JFh*JF[*JF[*JF[*JF[*JF[*JF[*JF[*JF[*JF[*JF[*JFy*JF[*JFh*JFy*JF[*JFh*JFh*JFh*JFh*JFh*JFh*JFh*JFh*JFh*JF[*JFh)%Gh)%Xh)%:h)%:h)%:h)%Xh)%Gh)%Gh)%Gh)%Gh)%Gh)%Xh)%Gh)%Gh)%:h)%Xh)%Gh)%Gh)%Xh)%Gh)%Xh)%:h)%Gh)%Xh)%Xh)%:h)%Gh)%Xh)%:h)%:h)%:h)%Gh)%:h)%:h)%:h)%:h)%:h)%:h)%:h)%:h)%:h)%:h)%:h)%:h)%:h)%:h)%:h)%Ggc&Ggc7GgcxGgcxGgcxGgc7Ggc&Ggc&Ggc&Ggc&Ggc&Ggc7Ggc&Ggc&GgcxGgc7Ggc&Ggc&Ggc7Ggc&Ggc7GgcxGgc&Ggc7Ggc7GgcxGgc&Ggc7GgcxGgc&FBW&FBW&FBW&FBu&FBd&FBu&FBd&FBd&FBu&FBd&FBW&FBW&FBW&FBW&FBW&FBW&FBW&FBW&FBW&FBW&FBu&FBW&FBd&FBu&FBd&FBd&FBW&FBd&FBW&FBW&FBW&FBW&FBW&FBW&FBW&FBd%!Cd%!Td%!6d%!6d%!6d%!Td%!Cd%!Cd%!Cd%!Cd%!Cd%!Td%!Cd%!Cd%!6d%!Td%!Cd%!Cd%!Td%!Cd%!Td%!6d%!Cd%!Td%!Td%!6d%!Cd%!Td%!6d%!6d%!6d%!Cd%!6d%!6d%!6d%!6d%!6d%!6d%!6d%!Cc_tCc_tCc_tCc_3Cc_"Cc_3Cc_"Cc_"Cc_3Cc_"Cc_tCc_tCc_tCc_tCc_tCc_tCc_tCc_tCc_tCc_tCc_3Cc_tCc_"Cc_3Cc_tCc_tCc_tCc_tCc_tCc_"Cc_"Cc_"Cc_tCc_"B>S"B>S"B>S"B>q"B>`"B>q"B>`"B>`"B>q"B>`"B>S"B>S"B>S"B>S"B>S"B>S"B>S"B>S"B>S"B>S"B>q"B>S"B>`"B>q"B>`"B>`"B>S"B>`"B>`"B>`"B>S"B>`!|?`!|P`!|2`!|2`!|2`!|P`!|?`!|?`!|?`!|?`!|?`!|P`!|?`!|?`!|2`!|P`!|?`!|?`!|P`!|?`!|P`!|2`!|?`!|P`!|P`!|2`!|?`!|P`!|2`!|2`!|2`!|?`!|?`!|?`!|2`!|?_[p?_[p?_[p?_[/?_[}?_[/?_[}?_[}?_[/?_[}?_[p?_[p?_[p?_[p?_[p?_[p?_[p?_[p?_[p?_[p?_[/?_[p?_[}?_[/?_[p?_[p?_[p?_[p?_[p?_[}?_[}?_[}?_[}?_[}?_[}?_[}?_[}?_[}?_[}?_[}?_[p?_[}>:O}>:O}>:O}>:m}>:\}>:m}>:\}>:\}>:m}>:\}>:O}>:O}>:O}>:O}>:O}>:O}>:O}>:O}>:O}>:O}>:m}>:O}>:\}>:m}>:\}>:\}>:O}>:\}>:\}>:\}>:\}>:\}>:\}>:\}>:\}>:\}>:\}>:\}>:O}>:\|x;\|xL\|x.\|x.\|x.\|xL\|x;\|x;\|x;\|x;\|x;\|xL\|x;\|x;\|x.\|xL\|x;\|x;\|xL\|x;\|xL\|x.\|x;\|xL\|xL\|x.\|x;\|xL\|x.\|x;\|x.\|x.\|x.\|x.\|x.\|x.\|x.\|x.\|x.\|x.\|x.\|x.\|x.\|x;[Wl;[Wl;[Wl;[W+;[Wy;[W+;[Wy;[Wy;[W+;[Wy;[Wl;[Wl;[Wl;[Wl;[Wl;[Wl;[Wl;[Wl;[Wl;[Wl;[W+;[Wl;[Wy;[W+;[Wl;[Wl;[Wl;[Wy;[Wl;[Wl;[Wl;[Wl;[Wl;[Wy:6Ky:6Ky:6Ky:6iy:6Xy:6iy:6Xy:6Xy:6iy:6Xy:6Ky:6Ky:6Ky:6Ky:6Ky:6Ky:6Ky:6Ky:6Ky:6Ky:6iy:6Ky:6Xy:6iy:6Xy:6Xy:6Xy:6Xy:6Ky:6Xy:6Ky:6Ky:6Ky:6Ky:6Ky:6Xxt7XxtHXxt*Xxt*Xxt*XxtHXxt7Xxt7Xxt7Xxt7Xxt7XxtHXxt7Xxt7Xxt*XxtHXxt7Xxt7XxtHXxt7XxtHXxt*Xxt7XxtHXxtHXxt*Xxt7XxtHXxt*Xxt7Xxt*Xxt*Xxt*Xxt*Xxt*Xxt7WSh7WSh7WSh7WS'7WSu7WS'7WSu7WSu7WS'7WSu7WSh7WSh7WSh7WSh7WSh7WSh7WSh7WSh7WSh7WSh7WS'7WSh7WSu7WS'7WSh7WSh7WSh7WSu7WSu7WSu7WSu7WSu7WSh7WSu62Gu62Gu62Gu62eu62Tu62eu62Tu62Tu62eu62Tu62Gu62Gu62Gu62Gu62Gu62Gu62Gu62Gu62Gu62Gu62eu62Gu62Tu62eu62Tu62Tu62Tu62Tu62Gu62Tu62Tu62Tu62Tu62Tu62Gu62Ttp3TtpDTtp&Ttp&Ttp&TtpDTtp3Ttp3Ttp3Ttp3Ttp3TtpDTtp3Ttp3Ttp&TtpDTtp3Ttp3TtpDTtp3TtpDTtp&Ttp3TtpDTtpDTtp&Ttp3TtpDTtp3Ttp3Ttp&Ttp3Ttp&Ttp&Ttp&Ttp&Ttp&Ttp&Ttp&Ttp&Ttp&Ttp&Ttp&Ttp&Ttp&Ttp&Ttp&Ttp&Ttp&Ttp&Ttp&Ttp3SOd3SOd3SOd3SO#3SOq3SO#3SOq3SOq3SO#3SOq3SOd3SOd3SOd3SOd3SOd3SOd3SOd3SOd3SOd3SOd3SO#3SOd3SOq3SO#3SOd3SOd3SOd3SOq3SOq3SOq3SOq3SOq3SOq3SOq3SOq3SOq3SOq3SOq3SOq3SOq3SOd3SOq2.Cq2.Cq2.Cq2.aq2.Pq2.aq2.Pq2.Pq2.aq2.Pq2.Cq2.Cq2.Cq2.Cq2.Cq2.Cq2.Cq2.Cq2.Cq2.Cq2.aq2.Cq2.Pq2.aq2.Pq2.Pq2.Pq2.Pq2.Pq2.Pq2.Cq2.Pq2.Cq2.Cq2.Cq2.Cq2.Cq2.Cq2.Cq2.Cq2.Cq2.Cq2.Cq2.Ppl/Ppl@Ppl"Ppl"Ppl"Ppl@Ppl/Ppl/Ppl/Ppl/Ppl/Ppl@Ppl/Ppl/Ppl"Ppl@Ppl/Ppl/Ppl@Ppl/Ppl@Ppl"Ppl/Ppl@Ppl@Ppl"Ppl/Ppl@Ppl/Ppl/Ppl"Ppl/Ppl"Ppl"Ppl"Ppl"Ppl"Ppl"Ppl"Ppl"Ppl"Ppl"Ppl"Ppl/OK`/OK`/OK`/OK~/OKm/OK~/OKm/OKm/OK~/OKm/OK`/OK`/OK`/OK`/OK`/OK`/OK`/OK`/OK`/OK`/OK~/OK`/OKm/OK~/OK`/OKm/OK`/OK`/OK`/OKm.*?m.*?m.*?m.*]m.*Lm.*]m.*Lm.*Lm.*]m.*Lm.*?m.*?m.*?m.*?m.*?m.*?m.*?m.*?m.*?m.*?m.*]m.*?m.*Lm.*]m.*Lm.*Lm.*Lm.*Lm.*Lm.*Lm.*?m.*Lm.*?m.*?m.*?m.*Llh}Llh}Llh}Llh<Llh+Llh<Llh+Llh+Llh<Llh+Llh}Llh}Llh}Llh}Llh}Llh}Llh}Llh}Llh}Llh}Llh<Llh}Llh+Llh<Llh}Llh+KG\+KG\+KG\+KGz+KGi+KGz+KGi+KGi+KGz+KGi+KG\+KG\+KG\+KG\+KG\+KG\+KG\+KG\+KG\+KG\+KGz+KG\+KGi+KGz+KG\+KGi+KGi+KGi+KGi+KGi+KGi+KGi+KG\+KGi*&;i*&;i*&;i*&Yi*&Hi*&Yi*&Hi*&Hi*&Yi*&Hi*&;i*&;i*&;i*&;i*&;i*&;i*&;i*&;i*&;i*&;i*&Yi*&;i*&Hi*&Yi*&Hi*&Hi*&Hi*&Hi*&Hi*&Hi*&;i*&Hi*&Hi*&Hi*&Hi*&Hi*&Hi*&Hi*&;i*&Hhd'Hhd8HhdyHhdyHhdyHhd8Hhd'Hhd'Hhd'Hhd'Hhd'Hhd8Hhd'Hhd'HhdyHhd8Hhd'Hhd'Hhd8Hhd'Hhd8HhdyHhd'Hhd8Hhd8HhdyHhd'Hhd8HhdyHhdyHhdyHhd'GCX'GCX'GCX'GCv'GCe'GCv'GCe'GCe'GCv'GCe'GCX'GCX'GCX'GCX'GCX'GCX'GCX'GCX'GCX'GCX'GCv'GCX'GCe'GCv'GCe'GCe'GCX'GCe'GCX'GCX'GCX'GCX'GCX'GCX'GCX'GCX'GCX'GCe&"De&"Ue&"7e&"7e&"7e&"Ue&"De&"De&"De&"De&"De&"Ue&"De&"De&"7e&"Ue&"De&"De&"Ue&"De&"Ue&"7e&"De&"Ue&"Ue&"7e&"De&"Ue&"7e&"7e&"7e&"De&"7e&"7e&"7e&"7e&"7e&"7e&"7e&"7e&"7e&"Dd`uDd`uDd`uDd`4Dd`#Dd`4Dd`#Dd`#Dd`4Dd`#Dd`uDd`uDd`uDd`uDd`uDd`uDd`uDd`uDd`uDd`uDd`4Dd`uDd`#Dd`4Dd`uDd`uDd`uDd`uDd`uDd`#Dd`uDd`#C?T#C?T#C?T#C?r#C?a#C?r#C?a#C?a#C?r#C?a#C?T#C?T#C?T#C?T#C?T#C?T#C?T#C?T#C?T#C?T#C?r#C?T#C?a#C?r#C?a#C?a#C?T#C?a#C?T#C?a"}@a"}Qa"}3a"}3a"}3a"}Qa"}@a"}@a"}@a"}@a"}@a"}Qa"}@a"}@a"}3a"}Qa"}@a"}@a"}Qa"}@a"}Qa"}3a"}@a"}Qa"}Qa"}3a"}@a"}Qa"}3a"}3a"}3a"}@a"}3a"}@`\q@`\q@`\q@`\0@`\~@`\0@`\~@`\~@`\0@`\~@`\q@`\q@`\q@`\q@`\q@`\q@`\q@`\q@`\q@`\q@`\0@`\q@`\~@`\0@`\q@`\q@`\q@`\q@`\q@`\~@`\~@`\~@`\~@`\~@`\~@`\~@`\~@`\~@`\q@`\~?;P~?;P~?;P~?;n~?;]~?;n~?;]~?;]~?;n~?;]~?;P~?;P~?;P~?;P~?;P~?;P~?;P~?;P~?;P~?;P~?;n~?;P~?;]~?;n~?;]~?;]~?;P~?;]~?;]~?;]~?;]~?;]~?;]~?;]~?;]~?;]~?;P~?;]}y<]}yM]}y/]}y/]}y/]}yM]}y<]}y<]}y<]}y<]}y<]}yM]}y<]}y<]}y/]}yM]}y<]}y<]}yM]}y<]}yM]}y/]}y<]}yM]}yM]}y/]}y<]}yM]}y/]}y<]}y/]}y/]}y/]}y/]}y/]}y/]}y/]}y/]}y/]}y/]}y/]}y/]}y/]}y/]}y/]}y<\Xm<\Xm<\Xm<\X,<\Xz<\X,<\Xz<\Xz<\X,<\Xz<\Xm<\Xm<\Xm<\Xm<\Xm<\Xm<\Xm<\Xm<\Xm<\Xm<\X,<\Xm<\Xz<\X,<\Xm<\Xm<\Xm<\Xm<\Xm<\Xz<\Xz<\Xz<\Xz<\Xz<\Xz<\Xz<\Xz<\Xz<\Xz<\Xz<\Xz<\Xz<\Xz<\Xz<\Xz<\Xz<\Xm<\Xz;7Lz;7Lz;7Lz;7jz;7Yz;7jz;7Yz;7Yz;7jz;7Yz;7Lz;7Lz;7Lz;7Lz;7Lz;7Lz;7Lz;7Lz;7Lz;7Lz;7jz;7Lz;7Yz;7jz;7Yz;7Yz;7Yz;7Yz;7Lz;7Yz;7Lz;7Lz;7Lz;7Lz;7Lz;7Lz;7Lz;7Yyu8YyuIYyu+Yyu+Yyu+YyuIYyu8Yyu8Yyu8Yyu8Yyu8YyuIYyu8Yyu8Yyu+YyuIYyu8Yyu8YyuIYyu8YyuIYyu+Yyu8YyuIYyuIYyu+Yyu8YyuIYyu+Yyu8Yyu+Yyu+Yyu+Yyu+Yyu+Yyu+Yyu+Yyu8XTi8XTi8XTi8XT(8XTv8XT(8XTv8XTv8XT(8XTv8XTi8XTi8XTi8XTi8XTi8XTi8XTi8XTi8XTi8XTi8XT(8XTi8XTv8XT(8XTi8XTi8XTi8XTv8XTv8XTv8XTi8XTv73Hv73Hv73Hv73fv73Uv73fv73Uv73Uv73fv73Uv73Hv73Hv73Hv73Hv73Hv73Hv73Hv73Hv73Hv73Hv73fv73Hv73Uv73fv73Uv73Uv73Uv73Uv73Hv73Uv73Uv73Uv73Hv73Uuq4UuqEUuq'Uuq'Uuq'UuqEUuq4Uuq4Uuq4Uuq4Uuq4UuqEUuq4Uuq4Uuq'UuqEUuq4Uuq4UuqEUuq4UuqEUuq'Uuq4UuqEUuqEUuq'Uuq4UuqEUuq'Uuq4Uuq4Uuq4Uuq'Uuq4TPe4TPe4TPe4TP$4TPr4TP$4TPr4TPr4TP$4TPr4TPe4TPe4TPe4TPe4TPe4TPe4TPe4TPe4TPe4TPe4TP$4TPe4TPr4TP$4TPe4TPe4TPe4TPr4TPr4TPr4TPr4TPr4TPr4TPr4TPr4TPr4TPr4TPr4TPe4TPr3/Dr3/Dr3/Dr3/br3/Qr3/br3/Qr3/Qr3/br3/Qr3/Dr3/Dr3/Dr3/Dr3/Dr3/Dr3/Dr3/Dr3/Dr3/Dr3/br3/Dr3/Qr3/br3/Qr3/Qr3/Qr3/Qr3/Qr3/Qr3/Dr3/Qr3/Dr3/Dr3/Dr3/Dr3/Dr3/Dr3/Dr3/Dr3/Dr3/Dr3/Dr3/Dr3/Dr3/Qqm0QqmAQqm#Qqm#Qqm#QqmAQqm0Qqm0Qqm0Qqm0Qqm0QqmAQqm0Qqm0Qqm#QqmAQqm0Qqm0QqmAQqm0QqmAQqm#Qqm0QqmAQqmAQqm#Qqm0QqmAQqm0Qqm0Qqm#Qqm0Qqm#Qqm#Qqm#Qqm#Qqm#Qqm#Qqm#Qqm#Qqm#Qqm#Qqm#Qqm#Qqm#Qqm0PLa0PLa0PLa0PL 0PLn0PL 0PLn0PLn0PL 0PLn0PLa0PLa0PLa0PLa0PLa0PLa0PLa0PLa0PLa0PLa0PL 0PLa0PLn0PL 0PLa0PLn0PLa0PLa0PLa0PLa0PLa0PLn/+@n/+@n/+@n/+^n/+Mn/+^n/+Mn/+Mn/+^n/+Mn/+@n/+@n/+@n/+@n/+@n/+@n/+@n/+@n/+@n/+@n/+^n/+@n/+Mn/+^n/+Mn/+Mn/+Mn/+Mn/+Mn/+Mn/+@n/+Mn/+@n/+@n/+@n/+@n/+@n/+Mmi~Mmi~Mmi~Mmi=Mmi,Mmi=Mmi,Mmi,Mmi=Mmi,Mmi~Mmi~Mmi~Mmi~Mmi~Mmi~Mmi~Mmi~Mmi~Mmi~Mmi=Mmi~Mmi,Mmi=Mmi~Mmi~Mmi~Mmi,LH],LH],LH],LH{,LHj,LH{,LHj,LHj,LH{,LHj,LH],LH],LH],LH],LH],LH],LH],LH],LH],LH],LH{,LH],LHj,LH{,LH],LHj,LHj,LHj,LHj,LHj,LH],LHj+'<j+'<j+'<j+'Zj+'Ij+'Zj+'Ij+'Ij+'Zj+'Ij+'<j+'<j+'<j+'<j+'<j+'<j+'<j+'<j+'<j+'<j+'Zj+'<j+'Ij+'Zj+'Ij+'Ij+'Ij+'Ij+'Ij+'Ij+'<j+'Ij+'Ij+'Ij+'Ij+'Ij+'<j+'IiezIiezIiezIie9Iie(Iie9Iie(Iie(Iie9Iie(IiezIiezIiezIiezIiezIiezIiezIiezIiezIiezIie9IiezIie(Iie9Iie(Iie(Iie(Iie(Iie(Iie(IiezIie(HDY(HDY(HDY(HDw(HDf(HDw(HDf(HDf(HDw(HDf(HDY(HDY(HDY(HDY(HDY(HDY(HDY(HDY(HDY(HDY(HDw(HDY(HDf(HDw(HDY(HDf(HDf(HDf(HDf(HDf(HDf(HDf(HDf(HDf(HDf(HDf(HDf(HDf(HDY(HDf'#Ef'#Vf'#8f'#8f'#8f'#Vf'#Ef'#Ef'#Ef'#Ef'#Ef'#Vf'#Ef'#Ef'#8f'#Vf'#Ef'#Ef'#Vf'#Ef'#Vf'#8f'#Ef'#Vf'#Vf'#8f'#Ef'#Vf'#8f'#8f'#8f'#Ef'#8f'#8f'#8f'#8f'#8f'#8f'#8f'#8f'#8f'#8f'#8f'#EeavEeavEeavEea5Eea$Eea5Eea$Eea$Eea5Eea$EeavEeavEeavEeavEeavEeavEeavEeavEeavEeavEea5EeavEea$Eea5EeavEeavEeavEeavEeavEea$EeavEeavEeavEea$D@U$D@U$D@U$D@s$D@b$D@s$D@b$D@b$D@s$D@b$D@U$D@U$D@U$D@U$D@U$D@U$D@U$D@U$D@U$D@U$D@s$D@U$D@b$D@s$D@b$D@b$D@U$D@b$D@U$D@U$D@U$D@b#~Ab#~Rb#~4b#~4b#~4b#~Rb#~Ab#~Ab#~Ab#~Ab#~Ab#~Rb#~Ab#~Ab#~4b#~Rb#~Ab#~Ab#~Rb#~Ab#~Rb#~4b#~Ab#~Rb#~Rb#~4b#~Ab#~Rb#~4b#~4b#~4b#~Ab#~4b#~4b#~4b#~Aa]rAa]rAa]rAa]1Aa] Aa]1Aa] Aa] Aa]1Aa] Aa]rAa]rAa]rAa]rAa]rAa]rAa]rAa]rAa]rAa]rAa]1Aa]rAa] Aa]1Aa]rAa]rAa]rAa]rAa]rAa] Aa] Aa] Aa] Aa] Aa] Aa] Aa]rAa] @<Q @<Q @<Q @<o @<^ @<o @<^ @<^ @<o @<^ @<Q @<Q @<Q @<Q @<Q @<Q @<Q @<Q @<Q @<Q @<o @<Q @<^ @<o @<^ @<^ @<Q @<^ @<^ @<^ @<^ @<^ @<^ @<^ @<Q @<^~z=^~zN^~z0^~z0^~z0^~zN^~z=^~z=^~z=^~z=^~z=^~zN^~z=^~z=^~z0^~zN^~z=^~z=^~zN^~z=^~zN^~z0^~z=^~zN^~zN^~z0^~z=^~zN^~z0^~z=^~z0^~z0^~z0^~z0^~z0^~z0^~z0^~z0^~z0^~z0^~z0^~z0^~z0^~z0^~z0^~z0^~z0^~z=]Yn=]Yn=]Yn=]Y-=]Y{=]Y-=]Y{=]Y{=]Y-=]Y{=]Yn=]Yn=]Yn=]Yn=]Yn=]Yn=]Yn=]Yn=]Yn=]Yn=]Y-=]Yn=]Y{=]Y-=]Yn=]Yn=]Yn=]Yn=]Yn=]Y{=]Y{=]Y{=]Y{=]Y{=]Y{=]Y{=]Y{=]Y{=]Y{=]Y{=]Y{=]Y{=]Y{=]Y{=]Yn=]Y{<8M{<8M{<8M{<8k{<8Z{<8k{<8Z{<8Z{<8k{<8Z{<8M{<8M{<8M{<8M{<8M{<8M{<8M{<8M{<8M{<8M{<8k{<8M{<8Z{<8k{<8Z{<8Z{<8Z{<8Z{<8M{<8Z{<8M{<8M{<8M{<8M{<8M{<8M{<8M{<8M{<8M{<8Zzv9ZzvJZzv,Zzv,Zzv,ZzvJZzv9Zzv9Zzv9Zzv9Zzv9ZzvJZzv9Zzv9Zzv,ZzvJZzv9Zzv9ZzvJZzv9ZzvJZzv,Zzv9ZzvJZzvJZzv,Zzv9ZzvJZzv,Zzv9Zzv,Zzv,Zzv,Zzv,Zzv,Zzv,Zzv,Zzv,Zzv,Zzv9YUj9YUj9YUj9YU)9YUw9YU)9YUw9YUw9YU)9YUw9YUj9YUj9YUj9YUj9YUj9YUj9YUj9YUj9YUj9YUj9YU)9YUj9YUw9YU)9YUj9YUj9YUj9YUw9YUj9YUw84Iw84Iw84Iw84gw84Vw84gw84Vw84Vw84gw84Vw84Iw84Iw84Iw84Iw84Iw84Iw84Iw84Iw84Iw84Iw84gw84Iw84Vw84gw84Vw84Vw84Vw84Vw84Iw84Vw84Iw84Vvr5VvrFVvr(Vvr(Vvr(VvrFVvr5Vvr5Vvr5Vvr5Vvr5VvrFVvr5Vvr5Vvr(VvrFVvr5Vvr5VvrFVvr5VvrFVvr(Vvr5VvrFVvrFVvr(Vvr5VvrFVvr(Vvr5Vvr(Vvr5UQf5UQf5UQf5UQ%5UQs5UQ%5UQs5UQs5UQ%5UQs5UQf5UQf5UQf5UQf5UQf5UQf5UQf5UQf5UQf5UQf5UQ%5UQf5UQs5UQ%5UQf5UQf5UQf5UQs5UQs5UQs5UQs5UQs5UQs5UQs5UQs5UQs5UQf5UQs40Es40Es40Es40cs40Rs40cs40Rs40Rs40cs40Rs40Es40Es40Es40Es40Es40Es40Es40Es40Es40Es40cs40Es40Rs40cs40Rs40Rs40Rs40Rs40Es40Rs40Rs40Rs40Rs40Rs40Rs40Rs40Rs40Rs40Es40Rrn1RrnBRrn$Rrn$Rrn$RrnBRrn1Rrn1Rrn1Rrn1Rrn1RrnBRrn1Rrn1Rrn$RrnBRrn1Rrn1RrnBRrn1RrnBRrn$Rrn1RrnBRrnBRrn$Rrn1RrnBRrn1Rrn1Rrn$Rrn1Rrn$Rrn$Rrn$Rrn$Rrn$Rrn$Rrn$Rrn$Rrn$Rrn$Rrn$Rrn$Rrn$Rrn$Rrn$Rrn1QMb1QMb1QMb1QM!1QMo1QM!1QMo1QMo1QM!1QMo1QMb1QMb1QMb1QMb1QMb1QMb1QMb1QMb1QMb1QMb1QM!1QMb1QMo1QM!1QMb1QMo1QMb1QMb1QMb1QMb1QMb1QMb1QMb1QMo0,Ao0,Ao0,Ao0,_o0,No0,_o0,No0,No0,_o0,No0,Ao0,Ao0,Ao0,Ao0,Ao0,Ao0,Ao0,Ao0,Ao0,Ao0,_o0,Ao0,No0,_o0,No0,No0,No0,No0,No0,No0,Ao0,No0,Ao0,Ao0,Ao0,Ao0,Ao0,Ao0,Ao0,Nnj Nnj Nnj Nnj>Nnj-Nnj>Nnj-Nnj-Nnj>Nnj-Nnj Nnj Nnj Nnj Nnj Nnj Nnj Nnj Nnj Nnj Nnj>Nnj Nnj-Nnj>Nnj Nnj Nnj Nnj Nnj Nnj-MI^-MI^-MI^-MI|-MIk-MI|-MIk-MIk-MI|-MIk-MI^-MI^-MI^-MI^-MI^-MI^-MI^-MI^-MI^-MI^-MI|-MI^-MIk-MI|-MI^-MIk-MIk-MIk-MI^-MIk,(=k,(=k,(=k,([k,(Jk,([k,(Jk,(Jk,([k,(Jk,(=k,(=k,(=k,(=k,(=k,(=k,(=k,(=k,(=k,(=k,([k,(=k,(Jk,([k,(Jk,(Jk,(Jk,(Jk,(Jk,(Jk,(=k,(Jk,(Jk,(Jk,(=k,(Jjf{Jjf{Jjf{Jjf:Jjf)Jjf:Jjf)Jjf)Jjf:Jjf)Jjf{Jjf{Jjf{Jjf{Jjf{Jjf{Jjf{Jjf{Jjf{Jjf{Jjf:Jjf{Jjf)Jjf:Jjf)Jjf)Jjf)Jjf)Jjf{Jjf)IEZ)IEZ)IEZ)IEx)IEg)IEx)IEg)IEg)IEx)IEg)IEZ)IEZ)IEZ)IEZ)IEZ)IEZ)IEZ)IEZ)IEZ)IEZ)IEx)IEZ)IEg)IEx)IEZ)IEg)IEg)IEg)IEg)IEg)IEg)IEg)IEg)IEg)IEg)IEg)IEZ)IEg($Fg($Wg($9g($9g($9g($Wg($Fg($Fg($Fg($Fg($Fg($Wg($Fg($Fg($9g($Wg($Fg($Fg($Wg($Fg($Wg($9g($Fg($Wg($Wg($9g($Fg($Wg($9g($9g($9g($Fg($9g($9g($9g($9g($9g($9g($9g($9g($9g($9g($9g($9g($9g($Ffb%Ffb6FfbwFfbwFfbwFfb6Ffb%Ffb%Ffb%Ffb%Ffb%Ffb6Ffb%Ffb%FfbwFfb6Ffb%Ffb%Ffb6Ffb%Ffb6FfbwFfb%Ffb6Ffb6FfbwFfb%Ffb6Ffb%Ffb%FfbwFfb%EAV%EAV%EAV%EAt%EAc%EAt%EAc%EAc%EAt%EAc%EAV%EAV%EAV%EAV%EAV%EAV%EAV%EAV%EAV%EAV%EAt%EAV%EAc%EAt%EAc%EAc%EAV%EAc%EAV%EAV%EAV%EAV%EAV%EAc$ Bc$ Sc$ 5c$ 5c$ 5c$ Sc$ Bc$ Bc$ Bc$ Bc$ Bc$ Sc$ Bc$ Bc$ 5c$ Sc$ Bc$ Bc$ Sc$ Bc$ Sc$ 5c$ Bc$ Sc$ Sc$ 5c$ Bc$ Sc$ 5c$ 5c$ 5c$ Bc$ 5c$ 5c$ 5c$ 5c$ 5c$ Bb^sBb^sBb^sBb^2Bb^!Bb^2Bb^!Bb^!Bb^2Bb^!Bb^sBb^sBb^sBb^sBb^sBb^sBb^sBb^sBb^sBb^sBb^2Bb^sBb^!Bb^2Bb^sBb^sBb^sBb^sBb^sBb^!Bb^!Bb^!Bb^!Bb^!Bb^sBb^!A=R!A=R!A=R!A=p!A=_!A=p!A=_!A=_!A=p!A=_!A=R!A=R!A=R!A=R!A=R!A=R!A=R!A=R!A=R!A=R!A=p!A=R!A=_!A=p!A=_!A=_!A=R!A=_!A=_!A=_!A=_!A=_!A=R!A=_ {>_ {O_ {1_ {1_ {1_ {O_ {>_ {>_ {>_ {>_ {>_ {O_ {>_ {>_ {1_ {O_ {>_ {>_ {O_ {>_ {O_ {1_ {>_ {O_ {O_ {1_ {>_ {O_ {1_ {1_ {1_ {>_ {>_ {>_ {>_ {>_ {1_ {>^Zo>^Zo>^Zo>^Z.>^Z|>^Z.>^Z|>^Z|>^Z.>^Z|>^Zo>^Zo>^Zo>^Zo>^Zo>^Zo>^Zo>^Zo>^Zo>^Zo>^Z.>^Zo>^Z|>^Z.>^Zo>^Zo>^Zo>^Zo>^Zo>^Z|>^Z|>^Z|>^Z|>^Z|>^Z|>^Z|>^Z|>^Z|>^Z|>^Z|>^Z|>^Z|>^Zo>^Z|=9N|=9N|=9N|=9l|=9[|=9l|=9[|=9[|=9l|=9[|=9N|=9N|=9N|=9N|=9N|=9N|=9N|=9N|=9N|=9N|=9l|=9N|=9[|=9l|=9[|=9[|=9[|=9[|=9N|=9[|=9N|=9N|=9N|=9N|=9N|=9N|=9N|=9N|=9N|=9N|=9N|=9[{w:[{wK[{w-[{w-[{w-[{wK[{w:[{w:[{w:[{w:[{w:[{wK[{w:[{w:[{w-[{wK[{w:[{w:[{wK[{w:[{wK[{w-[{w:[{wK[{wK[{w-[{w:[{wK[{w-[{w:[{w-[{w-[{w-[{w-[{w-[{w-[{w-[{w-[{w-[{w-[{w-[{w:ZVk:ZVk:ZVk:ZV*:ZVx:ZV*:ZVx:ZVx:ZV*:ZVx:ZVk:ZVk:ZVk:ZVk:ZVk:ZVk:ZVk:ZVk:ZVk:ZVk:ZV*:ZVk:ZVx:ZV*:ZVk:ZVk:ZVk:ZVx:ZVk:ZVk:ZVk:ZVx95Jx95Jx95Jx95hx95Wx95hx95Wx95Wx95hx95Wx95Jx95Jx95Jx95Jx95Jx95Jx95Jx95Jx95Jx95Jx95hx95Jx95Wx95hx95Wx95Wx95Wx95Wx95Jx95Wx95Jx95Jx95Jx95Wws6WwsGWws)Wws)Wws)WwsGWws6Wws6Wws6Wws6Wws6WwsGWws6Wws6Wws)WwsGWws6Wws6WwsGWws6WwsGWws)Wws6WwsGWwsGWws)Wws6WwsGWws)Wws6Wws)Wws)Wws)Wws6VRg6VRg6VRg6VR&6VRt6VR&6VRt6VRt6VR&6VRt6VRg6VRg6VRg6VRg6VRg6VRg6VRg6VRg6VRg6VRg6VR&6VRg6VRt6VR&6VRg6VRg6VRg6VRt6VRt6VRt6VRt6VRt6VRt6VRt6VRg6VRt51Ft51Ft51Ft51dt51St51dt51St51St51dt51St51Ft51Ft51Ft51Ft51Ft51Ft51Ft51Ft51Ft51Ft51dt51Ft51St51dt51St51St51St51St51Ft51St51St51St51St51St51St51St51Ft51Sso2SsoCSso%Sso%Sso%SsoCSso2Sso2Sso2Sso2Sso2SsoCSso2Sso2Sso%SsoCSso2Sso2SsoCSso2SsoCSso%Sso2SsoCSsoCSso%Sso2SsoCSso2Sso2Sso%Sso2Sso%Sso%Sso%Sso%Sso%Sso%Sso%Sso%Sso%Sso%Sso%Sso%Sso%Sso%Sso%Sso%Sso%Sso2RNc2RNc2RNc2RN"2RNp2RN"2RNp2RNp2RN"2RNp2RNc2RNc2RNc2RNc2RNc2RNc2RNc2RNc2RNc2RNc2RN"2RNc2RNp2RN"2RNc2RNc2RNc2RNp2RNp2RNp2RNp2RNp2RNp2RNp2RNp2RNp2RNp2RNp2RNp2RNp2RNp2RNp2RNc2RNp1-Bp1-Bp1-Bp1-`p1-Op1-`p1-Op1-Op1-`p1-Op1-Bp1-Bp1-Bp1-Bp1-Bp1-Bp1-Bp1-Bp1-Bp1-Bp1-`p1-Bp1-Op1-`p1-Op1-Op1-Op1-Op1-Op1-Op1-Bp1-Op1-Bp1-Bp1-Bp1-Bp1-Bp1-Bp1-Bp1-Bp1-Bp1-O

The easy way to do this challenge is with a tokenised language which doesn't need newlines and ignores invalid tokens.
Tested using this interpreter*. Assumes 8-bit cells for extra golfiness. Programs are also overlapped slightly to save some bytes.
*This interpreter has a strange quirk whereby the last token needs a char after it to be registered, which affects n = 62. There's offline 8-bit interpreters without this quirk, but this was the best online one I could find.

Well... so much for a race to 95 :|

I was in the midst of doing something similar in Brainfuck… oh well. Wouldn't have been as good as in Ook!

I was also working on BF when I realized it didnt work I started looking for BF derivatives.

Not often we see an improvement of over 5000 bytes in an optimization step... #awkward

thanks for paying tribute to my language ppl! :)

PHP, 95 programs, 2439 2063 bytes
<?=0;die?>;></*na^bkd`m'(:chd>=:=;/)m`]ajc_l&'9bgc=<9<:/(l_\`ib^k%&8afb<;8;9/'k^[_ha]j$%7`ea;:7:8/&j]Z^g`\i#$6_d`:9697/%i\Y]f_[h"#5^c_98586/$h[X\e^Zg!"4]b^87475/#gZW[d]Yf !3\a]76364/"fYVZc\Xe~ 2[`\65253/!eXUYb[Wd}~1Z_[54142&% dWTXaZVc|}0Y^Z43031%%~cVSW`YUb{|/X]Y32/20$%}bURV_XTaz{.W\X21.1/#%|aTQU^WS`yz-V[W10-0."'}`SPT]VR_xy,UZV0/,/-!%z_ROS\UQ^wx+TYU/.+., %y^QNR[TP]vw*SXT.-*-+~%x]PMQZSO\uv)RWS-,),*}%w\OLPYRN[tu(QVR,+(+)|%v[NKOXQMZst'PUQ+*'*(|zuZMJNWPLYrs&OTP*)&)'{ztYLIMVOKXqr%NSO)(%(&zzsXKHLUNJWpq$MRN('$'%yzrWJGKTMIVop#LQM'&#&$xzqVIFJSLHUno"KPL&%"%#w|rUHEIRKGTmn!JOK%$!$"vzoTGDHQJFSlm INJ$# #!uznSFCGPIERkl~HMI#"~" tzmREBFOHDQjk}GLH"!}!~szlQDAENGCPij|FKG! | }spkPC@DMFBOhi{EJF ~{~|rpjOB?CLEANghzDIE~}z}{qpiNA>BKD@MfgyCHD}|y|zpphM@=AJC?LefxBGC|{x{yopgL?<@IB>KdewAFB{zwzxnpfK>;?HA=Jcdv@EAzyvywmrgJ=:>G@<Ibcu?D@yxuxvlpdI<9=F?;Habt>C?xwtwukpcH;8<E>:G`as=B>wvsvtjpbG:7;D=9F_`r<A=vurusjfaF96:C<8E^_q;@<utqtrif`E859B;7D]^p:?;tspsqhf_D748A:6C\]o9>:srorpgf^C637@95B[\n8=9rqnqoff]B526?84AZ[m7<8qpmpnef\A415>73@YZl6;7polomdf[@304=62?XYk5:6onknlch\?2/3<51>WXj495nmjmkbfY>1.2;40=VWi384mliljafX=0-1:3/<UVh273lkhkia\W</,092.;TUg162kjgjh`\V;.+/81-:STf051jifig_\U:-*.70,9RSe/40ihehf^\T9,)-6/+8QRd.3/hgdge]\S8+(,5.*7PQc-2.gfcfd\\R7*'+4-)6OPb,1-febec[\Q6)&*3,(5NOa+0,edadbZ\P5(%)2+'4MN`*/+dc`caZTQ4'$(1*&3LM_).*cb_b`X\N3&#'0)%2KL^(-)ba^a_XRM2%"&/($1JK]',(a`]`^WRL1$!%.'#0IJ\&+'`_\_]VRK0# $-&"/HI[%*&_^[^\URJ/"~#,%!.GHZ$)%^]Z][TRI.!}"+$ -FGY#($]\Y\ZSRH- |!*#~,EFX"'#\[X[YRRG,~{ )"}+DEW!&"[ZWZXQRF+}z~(!|*CDV %!ZYVYWPRE*|y}' {)BCU~$ YXUXVPJF){x|&~z(ABT}#~XWTWUOHC(zw{%}y'@AS|"}WVSVTNHB'yvz$|x&?@R{!|VURUSMHA&xuy#{w%>?Qz {UTQTRLH@%wtx"zv$=>Py~zTSPSQKH?$vsw!yu#<=Ox}ySRORPJH>#urv xt";<Nw|xRQNQOIH="tqu~ws!:;Mv{wQPMPNHH<!spt}vr 9:LuzvPOLOMGH; ros|uq~89KtyuONKNLFH:~qnr{tp}78JsxtNMJMKF>9}pmqzso|67IrwsMLILJE>8|olpyrn{56HqvrLKHKID>7{nkoxqmz45GpuqKJGJHC>6zmjnwply34FotpJIFIGB>5ylimvokx23EnsoIHEHFA>4xkhlunjw12DmrnHGDGE@>3wjgktmiv01ClqmGFCFD?>2vifjslhu/0BkplFEBEC>>1uheirkgt./AjokEDADB=>0tgdhqjfs-.@injDC@CA=4/sfcgpier,-?hmiCB?B@<4.rebfohdq+,>glhBA>A?;4-qdaengcp*+=fkgA@=@>:4,pc`dmfbo)*<

Requires the option output_buffering to be On or some values such as 4096. It defaults to 4096 for the web service (but not CLI) at least for my installation.
The doc says ob_clean doesn't return anything. But it returned true nevertheless.
Shifted programs look like these:
9:  ...dmfbo)*<ejf@?<?=8+ob_clean();die?>;><8*na^bkd`m(:chd>=:=;/.)...
15: ...dmfbo)*<ejf@?<?=16-ob_clean();die?>;><04*na^bkd`m'(:chd>=:=;...
94: ...dmfbo)*<ejf@?<?=93+ob_clean();

Generated using this CJam program:
"<?=0;die?>"95,(;{["<?="1$(_Ab:--3={))'-}'+?"ob_clean();die?>"]sf{i\- 95+ 32- 95% ' +}}%s-5<

My first tries were Foo and Gammaplex. Then I realized that I should find a language with 2 or more characters denoting the starting point...

CJam, 10 programs, 1 byte
I thought I'd better add this right off the bat before someone else gets cheeky and does it :P
0

A CJam program with just a plain number outputs that number, so this is an easy way to get 10 programs that work, namely:
0, 1, 2, 3, 4, 5, 6, 7, 8, and 9.
The next program : unsurprisingly does not output 10 but gives an "unfinished operator" error.
This undoubtedly works in many languages.

You can also add MATL to the title of your submission=)

And Pyth, and GolfScript, and looooots of other golfing langs. =) You can just say: "Polyglot".

Works in non-golfing languages, too. For example, this is completely valid PowerShell.

Works in Seriously and Actually, also.

Mathematica too.

Also Jelly and 05AB1E work too.