[Question]
  [
# Code-Bowling
You've been hired by Brunswick Bowling to create a simple program to output the text `Code Bowling` on their monitors. This company is worth a pretty penny and you feel you can swindle them for quite the *bit* of cash. 
The job description clearly states that they pay on a scoring basis and you're pretty confident you can manipulate their scoring system to your advantage and get the largest pay check possible from these guys. To do so will require you packing as much *code* as you can into your program/function, even though their scoring system is designed to prevent you from doing so. 
Get out your piggy banks, let's code!
---
# Challenge
The challenge is to simply output the text `Code Bowling`, exactly as it is written here, with the highest score possible. *(See section: **Scoring System** below)*
Leading and trailing new-lines (line-breaks) are acceptable.
Your code may be an entire program or just an executable function.
---
# Rules
*Obligatory: This challenge is using [Code-Bowling: Common Rules, Revision 1.0.0](http://meta.codegolf.stackexchange.com/questions/11737/code-bowling-index); See Meta for details.*
1. **Character : Byte Ratio**  
In Code-Bowling a character-count is preferred over a byte-count. The obvious reasoning for this is that multi-byte unicode characters (e.g. üÅ¥) can be used in place of single-byte unicode characters to fluff up byte count and will make bowling more about who renames the most variables with high-byte unicode characters rather than who most strategically creates meaningful complex code.
2. **Variable/Function/Object Names**  
All variable names (or object pointers, function names, etc) should be 1 character long. The only acceptable time to use 2-character variables names is after all possible 1-character variables have been used. The only acceptable time to use 3-character variables names is after all possible 2-character variables have been used. Etc.
3. **Un-used Code**  
All code must be used. Meaning the program must fail to always properly complete the task if any individual character (or varying set(s) of characters) is/are removed. Naturally, a subset of the program should not be able complete the task on its own without the rest of the program.
4. **Comments**  
Comments are not permitted towards character-count, unless somehow utilized by your program/function.
---
# Scoring System:
### ¬†¬†Pangram Challenge:
[A pangram](https://en.wikipedia.org/wiki/Pangram) is a sentence that uses every letter at least once. (The quick brown fox jumps over the lazy dog).
This challenge-type has a scoring systems designed where a perfect pangram would achieve the theoretical maximum score *(though you are not **required** to use every character at least once.)* Additionally, using any character more than once will start incurring a penalty. This challenge also expands to more than just the alphabetical characters. 
### ¬†¬†Scoring Metric:
> 
> 1. Each character used increases your score by 1.
> 2. Repeated use of any alphanumeric character (a-z, A-Z, 0-9) will result in a deduction of 3 points per repeat (first use does not
>  result in a deduction).
> 3. Repeated use of basic punctuation `([!?.-,":';])` - including the brackets - will result in a deduction of 2 points per repeat.
> 4. Repeated use of other ASCII characters `{`~@#$%^&*_+=|\/><}` - including the curly brackets - will result in a deduction of 4 points
>  per repeat.
> 5. Use of spaces, tabs, and newlines will result in a deduction of 1 point per use. That is, they do not count towards
>  character total.
> 6. Characters not mentioned above *(Exotic Characters)* will result in a deduction of 1 point per use. That is, they do not count towards
>  character total.
> 
> 
> 
### ¬†¬†Scoring Tool:
An **automated** scoring widget has been created and can be found [**here**.](http://jsfiddle.net/96q4q22y/2/) 
---
This is a [code-bowling](/questions/tagged/code-bowling "show questions tagged 'code-bowling'") variant. The program with the highest score wins! (Since there is a maximum score of `94`, whoever reaches it first (if it can be reached) will be marked as the accepted answer, though others are free to keep answering for fun)
  
[Answer]
# Python 3, ~~82~~ ~~87~~ 88
*Thanks to @JonathanAllan for +1 score*
```
print("g!#$%&'*n+,./012i34579;<l=>?@ADEwFGHIJKLoMNOPQRSBTUVWXYZ ^_`abchejkmqsuvdyz{|}~ \x6f       C"[::-8])
```
[Try it online!](https://tio.run/nexus/python3#@19QlJlXoqGUrqisoqqmrpWnraOnb2BolGlsYmpuaW2TY2tn7@Do4lru5u7h6eXtk@/r5x8QGBTsFBIaFh4RGaUQF5@QmJSckZqVnVtYXFqWUllVXVNbpxBTYZamAAHOStFWVroWsZr//wMA)
Nothing special, just slicing and skipping characters. The string is reversed so you can't remove characters and have the original string being printed.
[Answer]
## [Glypho](https://web.archive.org/web/20060621185740/http://www4.ncsu.edu/~bcthomp2/glypho.txt), 94
The source file is encoded in [CP437](https://en.wikipedia.org/wiki/Code_page_437).
```
‚êÄ‚êÄ!"‚ò∫‚ò∫#$‚òª‚ô•‚ô•‚òª‚ô¶‚ô£‚ô¶‚ô£%‚ô†‚ô†&‚Ä¢‚óò‚Ä¢‚óò'‚óã‚óã(‚óô‚ôÇ‚óô‚ôÇ‚ôÄ‚ô™‚ô™‚ôÄ‚ô´‚òº‚ô´‚òº‚ñ∫‚óÑ‚óÑ‚ñ∫‚Üï‚Üï)*‚Äº¬∂¬∂‚Äº¬ß¬ß+,‚ñ¨‚Ü®‚Ü®‚ñ¨‚Üë‚Üì‚Üë‚Üì‚Üí‚Üê‚Üí‚Üê‚àü‚àü-.‚Üî‚ñ≤‚ñ≤‚Üî/‚ñº‚ñº‚ñº‚åÇ√á‚åÇ√á√º√©√©√º√¢√¢01√§√§23√†√•√•√†√ß√™√ß√™4√´√´5√®√Ø√®√Ø√Æ√Æ67√¨√Ñ√Ñ√¨8√Ö√Ö9√â√â:;√¶√Ü√Ü√¶√¥<=√¥√∂√≤√≤√∂√ª√π√ª√π>√ø√ø√ø√ñ√ñ?@√ú√úAB¬¢¬£¬£¬¢¬•‚Çß¬•‚ÇßC∆í∆íD√°√≠√°√≠√≥√≥EF√∫√±√±√∫√ë¬™√ë¬™G¬∫¬∫HI¬ø¬øJ‚åê¬¨‚åê¬¨K¬Ω¬Ω¬Ω¬º¬ºLM¬°¬´¬´¬°N¬ª¬ª¬ª‚ñë‚ñëOP‚ñí‚ñíQR‚ñì‚îÇ‚îÇ‚ñì‚î§‚ï°‚î§‚ï°S‚ï¢‚ï¢T‚ïñ‚ïï‚ïñ‚ïïU‚ï£‚ï£V‚ïë‚ïó‚ïë‚ïó‚ïù‚ïú‚ïú‚ïùW‚ïõ‚ïõ‚ïõ‚îêX‚îê‚îêY‚îî‚îî‚îî‚î¥‚î¨‚î¥‚î¨‚îú‚îÄ‚îú‚îÄZ‚îº‚îº‚îº‚ïû‚ïû[\‚ïü‚ïü]^‚ïö‚ïî‚ïî‚ïö‚ï©‚ï¶‚ï©‚ï¶_‚ï†‚ï†`‚ïê‚ï¨‚ïê‚ï¨‚ïß‚ï®‚ï®‚ïß‚ï§‚ï•‚ï•‚ï§a‚ïô‚ïô‚ïô‚ïò‚ïòbc‚ïí‚ïíde‚ïì‚ïìfg‚ï´‚ï™‚ï™‚ï´‚îò‚îå‚îå‚îò‚ñà‚ñÑ‚ñà‚ñÑ‚ñåhi‚ñå‚ñêj‚ñê‚ñê‚ñÄŒ±Œ±‚ñÄ√üŒì√üŒìœÄŒ£œÄŒ£kœÉœÉœÉ¬µl¬µ¬µœÑmnœÑŒ¶ŒòŒòŒ¶Œ©Œ¥Œ©Œ¥o‚àû‚àû‚àûœÜpœÜœÜŒµŒµqr‚à©‚â°‚â°‚à©¬±¬±st‚â•‚â§‚â§‚â•u‚å†‚å†‚å†‚å°‚å°vw√∑xy√∑‚âà¬∞¬∞‚âà‚àô‚àôz{¬∑|}¬∑‚àö‚Åø‚Åø‚àö~¬≤¬≤¬≤
```
[Try it online!](https://tio.run/nexus/glypho#Nc9XbxpBFAXg35Lee@@99957770XEYI3i8IDZWfZdbANmGJKHGNTFLwR0lzJj8t/OH/EubOAznfO3NeZRtjHZsyE1WSzZsOahJ1V1JGDPdzZObCTbC58acStzs5D/Cebj7gN299d2we76OGjBMvprtlEPKDwoQm2YCF8jqzLunryMr9oMcwytBFFHRFosd5GoYW7qw@xJUuhGTDHFc1YBtPpCvnphzfkUIHjUJrSy1dQhjIrV1GSspwk5amouppKVFpDI/TH6yiNrl1HZQpwyuupj/o2UJCCGzdRjjROjqqbt1CV6jTOqdMk/VXdSi0vJpnbtlOCEjt2yrQc5qRlFv68N7umolPR3ZSi314naGLPXmpShdOkiCyq7pNN2dx/QLZk6yBCYVn25pD858WRzuEjMiVLnNRROakCM8KOHYcZZSdOwozB8CvqyECkOnsKIs1OQ5gQorNnIIbZWYgIRLy3AxAJz8A5iF9dRvg8l12AYfRUYZR7m4Dh6@xFGE6XGGSXLkMMsStXIfohDA8fBYhcZ69BJNl1iDBEubd5iBEPH/yDrCdzA8LusdjNWxBRdvsORIzdvQdRgih6SjAsGCGPBVOHGeht6P4DHpjhh1yPz624FX5oyI2ptn3usOqj9ncVWXssa7LWDjx52g64Odfi5NyCW1V9Bn2wo609b2ttza25tRcvoRcQTCl6QVZk5dVrBLMIZjzZNwgle1Ls7TtqvP9ADQR1OSbH@IFus4@fZOPzF9mA3o9vLUXv/yrHVaan/wM "Glypho ‚Äì TIO Nexus")
### Explanation
Glypho is quite useful for challenges like this because it doesn't care about the actual characters being used at all. Instead it looks at each chunk of 4 characters and the command being used is determined by the pattern these four characters make:
```
0000 n
0001 i
0010 >
0011 \
0012 1
0100 <
0101 d
0102 [
0110 +
0111 o
0112 *
0120 -
0121 ]
0122 !
0123 e
```
That means we can just solve the problem and then fill in unique characters in each quartet with the printable characters and all the repeated ones with some of the "exotic" characters, which are ignored by the scoring. Glypho is sufficiently verbose that a normal handwritten solution contains enough unique characters to fit all the 94 printable ones inside. In fact, I ended up golfing it down until it had exactly 94, just so that I could use unique exotic characters for the repeated ones (hopefully, to make it harder to reduce the program).
The shorthand form of the above program is this:
```
11+d*d*d+d+1+1+dd1+o
d+11+d*d1+*1+-+do
11+d*d1+d**do
1+o
11+d*d*d+o
<o
ddo
11+d*d++o
111++d-<+ddo
<-+do
<1+1+o
1-+1-+o
```
Where each line prints one of the characters.
I've used [this Retina script](https://tio.run/nexus/retina#PYw7DoQwDET7uQVtRpE82TbiIoStTEFD7l@xNhIrR3qZ58@9fXWdfR3Dt7FzluWoOyCYqeEKmOFMCGtKwxhJoSOSwRPC2JINg8GYmonQJdlQA82wJ4Ql0XAkPvct0UsUnYpyFyfi/2ixiJU@8WYvJRNfE4sTPTb@M3x6Ir12pu7PgZ7Xo1MZb/4A) to convert it to Glypho using `0123`. Afterwards, I've just filled in the characters in place of the digits.
In theory it might be possible to reduce this further, if someone managed to golf down the shorthand program and then managed to recombine the characters such that the right patterns show up, but I'm not sure how to prove or disprove that this is possible. If anyone manages to form a valid solution from a subset of my program, please let me know so I can delete the answer until it's fixed. Until then, I'll have to assume that this is valid.
[Answer]
# [><>](https://esolangs.org/wiki/Fish), ~~92~~ 94
**YAY, I DID IT!**
`‚êë` is the *exotic* character `\x11` with decimal value 17. The program exits with an error after printing the result (it's a stack underflow). I had to manage which mirrors and directional commands I used carefully, since I can only use each one once.
```
   >"vCoUV‚êë3`h]Z_X
       /a[f+
#$%&'r(!
.0456~8?
:;<=@9l)
ABDEFcGe
HIJKL*
MNOPQ7
RSTWYd
bgijk1
mnqst-
uwxyz2
{|}  ,
     \p^
```
[**Try it online**](https://tio.run/nexus/fish#@6@goGCnVOacHxomaJyQERsVH8GlAAH6idFp2lzKKqpq6kUailx6BiamZnUW9lxW1ja2DpY5mlyOTi6ubsnuqVwenl7ePlpcvn7@AYHmXEHBIeGRKVxJ6ZlZ2YZcuXmFxSW6XKXlFZVVRlzVNbUKCjoQG2IK4v7/BwA)
**The core program:**
```
   >"vCoUV‚êë3`h]Z_X
       /a[f+
     r !
     ~ ?
     9 )
     c e
     *
     7
     d
     1
     -
     2
     ,
     \p^
```
**Explanation:**
Push the string `vCoUV‚êë3`h]Z_X >` (execution wraps). Move downward. Reverse the stack and remove the `v`.
Push `9` and `c` (12). Multiply to get `108` (`l`). Push `7`. Push `d` (13), subtract `1`, divide by `2` to get `6`. Put `l` at (x,y) of (13,6), which is below the `e`. I could've done this way shorter, but this is lengthened so I have room to put more ASCII characters.
Move up into a loop. Push length of stack with `l`. If greater than 14, output character, otherwise create a new stack with top 10 elements, add 15 then reflect execution right then up and output. This is used to prevent the extra spaces and `>` from being printed at the end, as well as turning the random-looking string into what needs to be printed. Continue looping.
If any of the lines is shorter (by removing a character), the program will no longer work, either because the vertical parts of the program no longer line up, or because the string to print isn't correct anymore. Attempting to remove a character from in front of each line will change the stack depth and where the `l` is placed, also causing problems.
Fish
[Answer]
# Octave, ~~20~~ ~~21~~ ~~22~~ ~~25~~ ~~27~~ 33
The best I've managed this far is
```
g=@()disp(horzcat([67 9583 -412],'e B',"nvkhmf"+!0));
```
This creates an anonymous function `f` that takes no input. You can call it `f()`. I'd say the semicolon at the end is necessary, in order to avoid printing of the function body.
It is possible this can be improved by combining `eval` and `printf`, but I've tried and failed over and over.
This uses all digits once, by exploting the fact that Octave does a `mod(x,256)` operation when implicitly converting numbers to characters. This means that we can use negative numbers, as well as numbers outside the normal `32-126`-range. The following numbers all result in the letter `i` when converted to characters: `... -2455 -2199 -1943 ... 105 361 ...`. Instead of using `'owling'` in the end, we use `"nvkhmf"` and add 1. This creates a vector of integers that are implicitly converted to characters. Instead of `1`, we use `!0` (or `not(false)`. Also, we use `"` instead of `'` to avoid two penalty points.
We need to find the set of numbers that gives the lowest score. The string `Code Bowling` result in the following matrix, when we subtract and add -10\*256 - 10\*256. 
```
  -2493  -2449  -2460  -2459  -2528  -2494  -2449  -2441  -2452  -2455  -2450  -2457
  -2237  -2193  -2204  -2203  -2272  -2238  -2193  -2185  -2196  -2199  -2194  -2201
  -1981  -1937  -1948  -1947  -2016  -1982  -1937  -1929  -1940  -1943  -1938  -1945
  -1725  -1681  -1692  -1691  -1760  -1726  -1681  -1673  -1684  -1687  -1682  -1689
  -1469  -1425  -1436  -1435  -1504  -1470  -1425  -1417  -1428  -1431  -1426  -1433
  -1213  -1169  -1180  -1179  -1248  -1214  -1169  -1161  -1172  -1175  -1170  -1177
   -957   -913   -924   -923   -992   -958   -913   -905   -916   -919   -914   -921
   -701   -657   -668   -667   -736   -702   -657   -649   -660   -663   -658   -665
   -445   -401   -412   -411   -480   -446   -401   -393   -404   -407   -402   -409
   -189   -145   -156   -155   -224   -190   -145   -137   -148   -151   -146   -153
     67    111    100    101     32     66    111    119    108    105    110    103
    323    367    356    357    288    322    367    375    364    361    366    359
    579    623    612    613    544    578    623    631    620    617    622    615
    835    879    868    869    800    834    879    887    876    873    878    871
   1091   1135   1124   1125   1056   1090   1135   1143   1132   1129   1134   1127
   1347   1391   1380   1381   1312   1346   1391   1399   1388   1385   1390   1383
   1603   1647   1636   1637   1568   1602   1647   1655   1644   1641   1646   1639
   1859   1903   1892   1893   1824   1858   1903   1911   1900   1897   1902   1895
   2115   2159   2148   2149   2080   2114   2159   2167   2156   2153   2158   2151
   2371   2415   2404   2405   2336   2370   2415   2423   2412   2409   2414   2407
   2627   2671   2660   2661   2592   2626   2671   2679   2668   2665   2670   2663
```
So, `['',2627 2415 2148 1893 -2528 66 -1169 -1161 2668 105 -146 103]` results in `ans = Code Bowling`. The challenge is then to find the set of numbers and characters that reduces the score the most. Using all digits is of course good, but duplicates are bad. Since all digits are used, and non are used twice, this is the best possible mix. Also, we get to use `-`, resulting in one point.
One could claim that it can be reduced to the line below (31 points), but then it would no longer be an *"executable function"*, and would therefore have a different functionality. 
```
disp(horzcat([67 9583 -412],'e B',"nvkhmf"+!0))
```
[Answer]
# QBasic, 34
This is unformatted code (yay for case-insensitivity). You can run it in [QB64](http://qb64.net) or at [archive.org](http://archive.org/details/msdos_qbasic_megapack) (though note that the latter will format the code as you type it). I *think* I've managed to abide by all the rules.
```
CLS
PrINT "C
LOcatE 1, 2 : ? CHR$(957-846); "de Bowling
```
The `CLS` is necessary: without it, the `C` is not guaranteed to print at the top left corner of the screen, where it will line up with `ode Bowling`. The `LOcatE` is necessary: without it, `ode Bowling` will be printed on the line below `C`. I don't believe there is any subset of the program (except whitespace) that can be deleted and keep the same output.
[Answer]
## C, ~~27~~ 29
*+2 points thanks to @ceilingcat!*
```
f(){char q<:]="Code B\157wling";puts(q);%>
```
[Answer]
# [Haskell](https://www.haskell.org/), score ~~21~~ ~~38~~ ~~46~~ ~~47~~ ~~21~~ 70
```
putStr$toEnum(length"!#%&'*+,-./012345789;<=>?@ADGHIJKLMNOPQRTUVWXYZ[]^_`abcfjkqsvyz{|}~"):"ode B\x6Fwling"
```
[Try it online!](https://tio.run/##y0gszk7Nyfmfm5iZZxvzv6C0JLikSKUk3zWvNFcjJzUvvSRDSVFZVU1dS1tHV0/fwNDI2MTU3MLS2sbWzt7B0cXdw9PL28fXzz8gMCgkNCw8IjIqOjYuPiExKTktK7uwuKyyqrqmtk5J00opPyVVwSmmwsytPCczL13p//9/yWk5ienF/3UjnAMCAA "Haskell ‚Äì Try It Online") The idea is to get the leading `C` by constructing a string of length 67 which contains all not otherwise used characters and converting the length of this string to a character. I started with `putStr$toEnum(length""):"ode B\x6Fwling"` (`'\x6F'` is hexadecimal for `'\111'` which yields `'o'`) and computed all printable ASCII characters not contained in the program:
```
!#%&'*+,-./012345789;<=>?@ACDGHIJKLMNOPQRTUVWXYZ[]^_`abcfjkqsvyz{|}~
```
Incidentally there remain exactly 67 printable ASCII characters which can put into the string, and `C` itself which cannot appear in the string because then the program would be reducible to just `putStr"Code B\x6Fwling"`.
---
**Previous solution:** (score 21)
```
f|x<-'C'=mapM putStr[(:)x"ode Bowling"]
```
Defines a function `f` which takes no input and prints the string. [Try it online!](https://tio.run/nexus/haskell#@59WU2Gjq@6sbpubWOCrUFBaElxSFK1hpVmhlJ@SquCUX56TmZeuFPs/NzEzT8FWIe0/AA "Haskell ‚Äì TIO Nexus") 
[Answer]
# JavaScript, 19
```
prompt('C\157de B\x6fwlin'+"g")
```
Not a very high score.
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 94
```
‚Äú!#"$&('*)+-/,13.0456:79<;>=@B?ADFHJLNCPRTEVXZ\G^IKMQ`SWbY[]d_acfhjegliknmprotquvxwy{z}¬π|¬≥‚Åµ‚Å∑~¬∞‚Åπ‚Åª‚ÄùO%2s8U·∏Ñ·ªå
```
**[Try it online!](https://tio.run/nexus/jelly#AYgAd///4oCcISMiJCYoJyopKy0vLDEzLjA0NTY6Nzk8Oz49QEI/QURGSEpMTkNQUlRFVlhaXEdeSUtNUWBTV2JZW11kX2FjZmhqZWdsaWtubXByb3RxdXZ4d3l7en3CuXzCs@KBteKBt37CsOKBueKBu@KAnU8lMnM4VeG4hOG7jP//9W5vLWNhY2hl)**
105 unique characters, 11 exotics (`‚Äú¬π¬≥‚Åµ‚Å∑¬∞‚Åπ‚Åª‚Äù·∏Ñ·ªå`).
### How?
Forms the string from 8-bit reversed ASCII where each bit is encoded using the LSB of the Unicode value of a character.
```
‚Äú...‚ÄùO%2s8U·∏Ñ·ªå - Main link: no arguments
‚Äú...‚Äù         - the string enclosed            !  #  "  $  &  (  '  *  )  +  -  /  ,  1  3  .  0  4  5  6  :  7  9  <  ;  >  =  @  B  ?  A  D  F  H  J  L  N  C  P  R  T  E  V  X  Z  \  G  ^  I  K  M  Q  `  S  W  b  Y  [  ]   d  _  a  c   f   h   j   e   g   l   i   k   n   m   p   r   o   t   q   u   v   x   w   y   {   z   }   ¬π   |   ¬≥    ‚Åµ    ‚Å∑   ~   ¬∞    ‚Åπ    ‚Åª
     O        - cast to ordinal (vectorises) [33,35,34,36,38,40,39,42,41,43,45,47,44,49,51,46,48,52,53,54,58,55,57,60,59,62,61,64,66,63,65,68,70,72,74,76,78,67,80,82,84,69,86,88,90,92,71,94,73,75,77,81,96,83,87,98,89,91,93,100,95,97,99,102,104,106,101,103,108,105,107,110,109,112,114,111,116,113,117,118,120,119,121,123,122,125,185,124,179,8309,8311,126,176,8313,8315]
      %2      - mod 2 (vectorises)           [ 1, 1, 0, 0, 0, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 0, 0, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1,  0, 1, 1, 1,  0,  0,  0,  1,  1,  0,  1,  1,  0,  1,  0,  0,  1,  0,  1,  1,  0,  0,  1,  1,  1,  0,  1,  1,  0,  1,   1,   1,  0,  0,   1,   1]
        s8    - split into chunks of 8       [[1,1,0,0,0,0,1,0], [1,1,1,1,0,1,1,0], [0,0,1,0,0,1,1,0], [1,0,1,0,0,1,1,0], [0,0,0,0,0,1,0,0], [0,1,0,0,0,0,1,0], [1,1,1,1,0,1,1,0], [1,1,1,0,1,1,1,0], [0,0,1,1,0,1,1,0], [1,0,0,1,0,1,1,0], [0,1,1,1,0,1,1,0], [1,1,1,0,0,1,1]]
          U   - upend (vectorises)           [[0,1,0,0,0,0,1,1], [0,1,1,0,1,1,1,1], [0,1,1,0,0,1,0,0], [0,1,1,0,0,1,0,1], [0,0,1,0,0,0,0,0], [0,1,0,0,0,0,1,0], [0,1,1,0,1,1,1,1], [0,1,1,1,0,1,1,1], [0,1,1,0,1,1,0,0], [0,1,1,0,1,0,0,1], [0,1,1,0,1,1,1,0], [1,1,0,0,1,1,1]]
           ·∏Ñ  - binary to int (vectorises)   [67, 111, 100, 101, 32, 66, 111, 119, 108, 105, 110, 103]
            ·ªå - to character (vectorises)    ['C', 'o', 'd', 'e', ' ', 'B', 'o', 'w', 'l', 'i', 'n', 'g']
              - implicit print               Code Bowling
```
[Answer]
# [R√∂da](https://github.com/fergusq/roda), 33
```
{["ode B\x6fwling"]|push chr(3*4+57-2).._}
```
[Try it online!](https://tio.run/nexus/roda#y03MzFOoVkizjflfHa2Un5Kq4BRTYZZWnpOZl64UW1NQWpyhkJxRpGGsZaJtaq5rpKmnF1/7P02h9j8A "R√∂da ‚Äì TIO Nexus")
I tried to follow all rules. It works by first pushing the string `ode Bowling!` to the stream and then inserting `C`=3\*4+57-2 to the front.
[Answer]
# Cardinal 20
23 non whitespace characters  
%#>/NI"CodeB8^o)wl,ing
-3 for repeated "o"
```
   I
 >\/N
%# "CodeB
 8^o
 ) w
   l
 , i
   n
   g
```
## Pointer paths:
**Step 1:**  
Pointer created at % going right 
**Step 2:**  
Pointer splits at # to go up, right and down (P1,P2,P3)
**Step 3**:  
P1 Sent right by >  
P2 Going right  
P3 Set wait for 3 steps at 8
**Step 4:**  
P1 Reflected down by \. \ changed to /  
P2 Set to print mode by "  
P3 Wait for 2 ticks at 8 
**Step 5:**  
P1 Heading down  
P2 Print C  
P3 Wait for 1 tick at 8
**Step 6:**  
P1 Sent up by ^  
P2 Print o  
P3 Finish wait at continue, pick up ASCII value of " " (32) from )
**Step 7:**
P1 Heading up  
P2 Print d  
P3 Heading down
**Step 8:**
P1 Reflected right by \ which was changed to /  
P2 Print e  
P3 Print character with ASCII value=32 from , operation 
**Step 9:**  
P1 Reflected up by / which is changed to \  
P2 Print B  
P3 Reached end of field and stops
**Step 10:**  
P1 Reflected down by I  
P2 Reached end of field and stops 
**Step 11:**  
P1 Reflected right by / which was changed to \. Changes back to / 
**Step 12:**  
P1 Reflected left by N 
**Step 13:**  
P1 Reflected down by / 
**Step 14:**  
P1 Set to print mode by "
**Step 15:**  
P1 Print o
**Step 16:**  
P1 Print w
**Step 17:**  
P1 Print l
**Step 18:**  
P1 Print i
**Step 19:**  
P1 Print n
**Step 20:**  
P1 Print g
**Step 21:**  
P1 Reaches end of field and stops.
[Try it Online](https://tio.run/nexus/cardinal#@6@goODJpWAXo@/HpaqsoOScn5LqxKVgEZfPpaCpUM4FlM7hUtBRyASx8kBE@v//AA)
[Answer]
# C, 73
*Thanks to @Laikoni!*
```
F(){printf("Code B\157wli%cg",48+strlen("!#$&'*-../2369:<=>?@ADEGHIJKLMNOPQRSTUVWXYZ[]^_`abhjkmquvxyz|~"));}
```
[Try it online!](https://tio.run/##S9ZNT07@/99NQ7O6oCgzryRNQ8k5PyVVwSnG0NS8PCdTNTldScfEQru4pCgnNU9DSVFZRU1dS1dPT9/I2MzSysbWzt7B0cXV3cPTy9vH188/IDAoOCQ0LDwiMio6Ni4@ITEpIys7t7C0rKKyqqZOSVPTuvY/0BqF3MTMPA1NrmouBSAA2m7NVfsfAA)
# C, ~~¬†31¬†~~ ~~¬†33¬†~~ 35
```
F(){printf("Code B\157wli%cg",96|0xD+3*4/8);}
```
*Thanks to @ceilingcat and @DLosc for two more points and thanks to @√òrjan Johansen for another two more points!*
[Try it online!](https://tio.run/##S9ZNT07@/99NQ7O6oCgzryRNQ8k5PyVVwSnG0NS8PCdTNTldScfSrMagwkXbWMtE30LTuvY/UJ1CbmJmnoYmVzWXAhAAtVtz1f4HAA)
[Answer]
# Brainfuck: -204
```
++++[++++>---<]>.+[--->+<]>+++.-----------.+.--[--->+<]>-.+[->++<]>.-[--->+<]>++++.++++++++.-----------.---.+++++.-------.
```
Well, awful score, but was fun to write.
* 122 characters long
* repeated alnum: -0 ()
* repeated punctuation: -134 (--[---].-----------..--[---]-.[-].-[---]..-----------.---..-------.)
* repeated other: -192 (+++++++>+>+<>++++>+<>+>++<>>+<>+++++++++++++++++)
* whitespace characters: -0 ()
* exotic characters: -0 ()
[Answer]
## Batch, 19 characters
```
@echO(Cod%TMP:~5,1% Bowling
```
Starting with Windows Vista, `TMP` begins with `C:\Users\` and therefore `%TMP:~5,1%` is a verbose way of writing `e`, despite requiring a double `%` at -4 penalty.
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 94 points
```
‚ÄùX1234bcde5fghijk68l9<mn>,o.p|q\/{})r(_-+s=tu*vwxyzAB&YDEFG^HI%$ZK#L@!MNO~PQR`ST':UVW[0];"‚Äù‚Ç¨a7√¥JC√ß‚Ç¨?
```
[Try it online!](https://tio.run/##MzBNTDJM/f//UcPcCEMjY5Ok5JRU07T0jMysbDOLHEub3Dw7nXy9gprCGP3qWs0ijXhd7WLbklKtsvKKyipHJ7VIF1c39zgPT1WVKG9lHwdFXz//uoDAoITgEHWr0LDwaINYayWg2Y@a1iSaH97i5Xx4OZBp//8/AA "05AB1E ‚Äì Try It Online")
---
```
- 100 characters long
- repeated alnum:       -0 ()
- repeated punctuation: -0 ()
- repeated other:       -0 ()
- whitespace characters:  -0 ()
- exotic characters:  -6 (‚Äù‚Äù‚Ç¨√¥√ß‚Ç¨)
Total score: 94
```
---
Basically converts (The Binary ASCII of Code Bowling):
```
['1000011', '1101111', '1100100', '1100101', '0100000', '1000010', '1101111', '1110111', '1101100', '1101001', '1101110', '1100111']
```
Into a string of 1's and 0's, then it replaces each 1 with a letter in the alphabet, and each 0 with a space character or a symbol or a digit.
```
‚ÄùX1234bcde5fghijk68l9<mn>,o.p|q\/{})r(_-+s=tu*vwxyzAB&YDEFG^HI%$ZK#L@!MNO~PQR`ST':UVW[0];"‚Äù
```
Is the string, where 1's are letters and 0's are symbols, numbers or anything else. We then iterate through, seeing which are alphabetical, pushing 1 for alphabetical 0 for nonalphabetical. We then split into groups of 7, convert back to ASCII and print each character.
[Answer]
# Java 8, ~~2~~ ~~3~~ ~~5~~ ~~13~~ ~~17~~ ~~18~~ ~~19~~ ~~20~~ ~~21~~ ~~24~~ ~~77~~ 78 points
+53 score (24 ‚Üí 77) thanks to *@Laikoni*.
```
v->(char)"!#$%&'*,/0234689:;<=?@ADEFGHIJKLMNOPQRSTUVWXYZ[]^_`bfjkmpqsuxyz{|}~".length()+"\157de Bowling"
```
104 characters long  
- repeated alnum: -15 (`helng`)  
- repeated punctuation: -10 (`"()""`)  
- repeated other ASCII: none  
- whitespace characters: -1  
SCORE: 78
[Try it online.](https://tio.run/##Lc/ZVoMwEAbg@z7FiFuiFvcV63bctbhU61KrpiFtQ0NAEtBa8dUxHLmZc2bm4v9@n6SkGkZM@t4gp4IoBXXC5agCwKVmcZdQBm6xAjR0zGUPKGqG3IMUO@aaVcxQmmhOwQUJNcjT6g6ifRJja2x8YnJqemZufmFpeWVtY3PL2a7t7u0fHh2fnJ6dX1zW3avrm9vG3X3z4fHpudV@fXvvdP1BEH2o5Gv4PfrJfi1bMNnTfYRnrZfF1XWPwUH4KYzDyp0iO0o6wmSXhLSQBaYA@se22kBwqR8qzQI7TLQdmZdG0qZIJkLgskiW/wE)
---
Old **24 bytes** answer:
```
v->"C\157de Bowlin"+(char)103;
```
30 characters long  
- repeated alnum: -3 (`1`)  
- repeated punctuation: -2 (`"`)  
- repeated other ASCII: none  
- whitespace characters: -1  
SCORE: 24
[Try it online.](https://tio.run/##LY2xCsIwEIZ3n@LolCAtFhGHooPOdhFc1OFMo6aml9KkEZE@e0yxy8Hd/9/31egxNa2kunoFodFaOKCi7wxAkZPdHYWEclwBjq5T9ADBTkZV4HkRr8MsDuvQKQElEGwg@HSb7C/5al1J2Jm3VpTMmXhix/PFsggAbX/TsT59@RHWRCf7889XQD4JP9bJJjO9y9oYOUaZYNRrzSf3EH4)
[Answer]
# [;#](https://codegolf.stackexchange.com/q/121921/73884), score -1163
I don't think this would be much competition even if it could compete.
```
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#
```
[Try it online!](https://tio.run/##K84o@P/fmnKgzGVNX0AfC@nkLcLWUMMhwzSOBtxiOtpG7xClm33K//8DAA ";#+ ‚Äì Try It Online") Note: TIO has no ;# interpreter, only ;#+.
[Answer]
# [stacked](https://github.com/ConorOBrien-Foxx/stacked), 42
```
(67:43,1 ab)2 9*pf sum 8/0\|>+chr'de Bowling',EPS#`
```
[Try it online!](https://tio.run/nexus/stacked#@69hZm5lYqxjqJCYpGmkYKlVkKZQXJqrYKFvEFNjp52cUaSekqrglF@ek5mXrq7jGhCsnPC/oLTkPwA "stacked ‚Äì TIO Nexus")
[Leaves output on stack.](http://meta.codegolf.stackexchange.com/a/8507/31957) Here's the breakdown:
```
length: 51
repeated alnum:        -0 ()
repeated punct:        -4 (',)
repeated other:        -0 ()
whitespace characters: -5 (     )
exotic characters:     -0 ()
total score: 42
```
I could probably make it higher, but it's at 42 soo....
Another contender, 40: 
```
(67:43,sum)9 pf 2%MIN 0\|>+chr'de Bowling',EPS#`
```
---
[I used this script for scoring it.](https://gist.github.com/ConorOBrien-Foxx/7b20c8e2f4e864edaa60b57ede39efc8)
[Answer]
# CJam, score 93
```
"g!#$&'()n*+/0134i5689:;<l=>?@ADEwFGHIJKLoMNOPQRSBTUVWXYZ [\]^_`aebcfhjkmdqrstuvxpyz{|}  C"7~%2,.-
```
[Try it online](http://cjam.aditsu.net/#code=%22g!%23%24%26'()n*%2B%2F0134i5689%3A%3B%3Cl%3D%3E%3F%40ADEwFGHIJKLoMNOPQRSBTUVWXYZ%20%5B%5C%5D%5E_%60aebcfhjkmdqrstuvxpyz%7B%7C%7D%20%20C%227~%252%2C.-)
Inspired from [TidB's Python answer](https://codegolf.stackexchange.com/a/112832/7416).  
Not sure if there's any way to avoid the repetition of the double quotes.
**Explanation:**
The string contains "Cpde Bowling" in reverse, every 8th character.  
`7~%` extracts "Cpde Bowling" (`7~` = `-8`)  
`2,.-` decrements the p character (`2,` = `[0 1]`)
[Answer]
# [evil](https://esolangs.org/wiki/Evil), -81
Better than Brainfuck!
```
aeeaeuwkaaeeuwygaeaeclaaxjlwalusbdgueuewguwpweewpuuuwuuuwpuweew
```
## Explanation
```
aeeaeuw //Write 'C'
k       //Set P[0] to 'C'
aaeeuw  //Write 'O'
y       //Set W[0] to 'O'
gaeae   //Set Accumulator to 'D'
claa    //Create new Wheel cell at index 0, swap with Accumulator, add 2
xj      //Set alternate marker mode and drop marker
lwa     //Write value of W[0], add 1
lu      //Put it back, subtract 1 from Accumulator
sb      //Go to 'j' if Accumulator != 0
d       //Delete W[0]
        //The above loop writes 'D' and 'E'
gueuew  //Write ' '
guw     //Write 'B'
pw      //Write 'o'
eew     //Write 'w'
puuuw   //Write 'l'
uuuw    //Write 'i'
puw     //Write 'n'
eew     //Write 'g'
```
Submitted because nobody does anything in evil but it's kind of fun.
## Score:
Length = 63
```
a*8  = -24
e*12 = -36
g*2  = -6
l*2  = -6
p*2  = -6
u*12  = -36
w*10  = -30
```
[Try it online!](https://tio.run/nexus/evil)
EDIT: TiO seems to incorrectly handle creation and deletion of new Wheel cells - I've filed a bug report on the subject. It won't work properly on there, but I ran it on my own interpreter and it works and you can trust me so I wouldn't worry about it ;)
[Answer]
# Perl: 29, 33
```
$_=OWLING;printf%s,"C\157de".chr(30+8/4).B.lc
```
**Score:**
```
- 46 characters long
- repeated alnum:       -6 (rc)
- repeated punctuation: -6 ("..)
- repeated other:       -0 ()
- whitespace characters:  -1 (
)
- exotic characters:  -0 ()
Total score: 33
```
[Answer]
# T-SQL, ~~65~~ ~~18~~ 32! points
```
PRINT char(78-9605*43%12) + 'ode Bowling'
```
Inspired by a trick in [Dlosc's QBasic answer](https://codegolf.stackexchange.com/a/112833/70172), I found a way to include all 10 digits and most of the mathematical operators (`%` is remainder/modulo, missing only `/`), mostly via trial and error . I don't *think* there is any way to get a 67 by removing any combination of digits/symbols, but you're welcome to try.
**Version 2 (18 points, trivial):**
```
DECLARE @ char(12)='Code Bowling'PRINT @
```
Not a great score, but this is what my first version simplified to (thanks, MickyT). Everything else I tried (encoding and decoding hex64, picking individual elements out of a string, converting ASCII values, etc) all had too many repeated characters (especially `ECR` and symbols `(),@`) that drive it into the negative.
**Version 1 (65 points, invalid):**
```
DECLARE @ char(123)=
'Code Bowling FGHJKMOQSUVWXYZbjkmpqsuvxyz045789 [!?.-":;]{`~#$%^&*_+|\><}'
PRINT left(@,LEN(@)/6)
```
I used the length of the string to determine how many characters I use from the left side, so removing any *single* character from the string will drop the integer division result down to 11, outputting only `Code Bowlin`.
[Answer]
# [Whitespace](https://web.archive.org/web/20150618184706/http://compsoc.dur.ac.uk/whitespace/tutorial.php), score: 0
```
[S S T  T   N
_Push_-1_g][S S S T T   S N
Push_6_n][S S S T   N
Push_1_i][S S S T   S S N
_Push_4_l][S S S T  T   T   T   N
_Push_15_w][S S S T T   T   N
Push_7_o][S S T T   S S T   T   S N
_Push_-38_B][S S T  T   S S T   S S S N
_Push_-71_space][S S T  T   T   N
_Push_-3_e][S S T   T   S S N
_Push_-4_d][S S S T T   T   N
Push_7_o][S S T T   S S T   S T N
_Push_-37_C][N
S S N
_Create_Label_LOOP][S S S T T   S T S S S N
_Push_constant_104][T   S S S _Add_top_two][T   N
S S _Print_as_character][N
S N
N
_Jump_to_Label_LOOP]
```
Letters `S` (space), `T` (tab), and `N` (new-line) added as highlighting only.  
`[..._some_action]` added as explanation only.
[Try it online](https://tio.run/##K8/ILEktLkhMTv3/X0GBk5NLAUQqgCkwoQBhc8KkQBRQAVQRmKWgAGHCpNAUAg3igglCFHNCTedS4OL6/x8A) (with raw spaces, tabs and new-lines only).
Uses [this Whitespace tip of mine](https://codegolf.stackexchange.com/a/158232/52210) to print the output. The optimal constant `104` is generated by [this Java program](https://tio.run/##fZJda9swFIbv@ysO50pCqclgZcyOKM3YhWHpxZxug1KK7KiJOkf2pJOMMPLbPbm289GN3khI7znP@XxWW3X5vPjZNEWpvIeZMvbPBUC9yUtTgCdF4dpWZgHrILGMnLHL@wdQvDUD6D7Aab8pCSSo@/FD8qIYS@DXqiy1b4XUkl5qF81ufjx@u/ly93kEqfxwlZxSBvOvAw2x058qx1qekWliJu@uxokRos/gmINEHNGoloNX55fvSEMedxlGS03T8OEZP7gDkAzwefV9ZYJSq0JPjVVu13FZfml4crB1klGkf21U6VnNrzG7zTAmLtzRpJY0PPb9bZ6Yi0ptl7RiHCaHSk@S@Kf4E@JJH4@Yo5yGf3MesjuznSe9jqoNRXWohUrLsHOXKAaowCQ0FkUqEGJA8VYvUt6HfU1m5@m/WO0vwtGvUD@jt9jtgG3fkK1yYSqYZSiYnYyvcY4xZsjP16GIh62i6gzVqnymaBWp3DPL@f/mTkIWk/cfwwgDe97vTNc3p2njbLDAW@wq2TdN86laaJhWv8sQ4i8). Since all the characters (except for the `o`) are unique, I couldn't use any duplicates or copies to save bytes (copy the value of `o` would be 1 byte longer than pushing the value of `o` again).
**Score:** 117 characters long - 117 whitespace characters = 0  
Still better than some of the negative scoring answers. ;)
[Answer]
# [CJam](https://sourceforge.net/p/cjam), score 47
```
"'#?GyQ2wE(s6&‚êüJI!gF$u*Aq;0p4BvOKkHLhM"3/{:i~-z+c}%
```
Hopefully no problems with this...
Uses one exotic character (Unit Separator, ASCII 31, represented by `‚êü`), and one repeated character (`"`). I think it could be made longer still, but I'll leave it as is for now.
[Try it online!](https://tio.run/nexus/cjam#@6@krmzvXhloVO6qUWwm7@WpmO6mUqrlWGhtUGDiVObvne3hk@GrZKxfbZVZp1ulnVyr@v8/AA "CJam ‚Äì TIO Nexus")
The program works by taking that long string and splitting it into length-3 substrings. Each substring is then mapped to the block, which converts its characters to their ASCII values, dumps the values on the stack, takes the absolute difference of the second two, adds the result with the first, then converts the final result back to an ASCII character.
[Answer]
# PHP, 33 points
This was quite difficult to come up with.
The score may be inproved in the future.
```
<?echo IHASZODECG9F^"
'%6z\r+2/.W!";
```
The newline is assumed to be a Linux-style newline! Windows-style and Old-Mac-Style won't work properly.
[Answer]
# Ruby, 75
Approximately a port of the Python answer, but Ruby doesn't have that cool step function so I use `gsub` instead. Also I decided to have a little fun with the exotic characters by throwing phrases into Google Translate
[Try it online!](https://tio.run/nexus/ruby#AZ8AYP//cHJpbnQiQ2FjaGprbXFceDZmdnl6QURFRmRHSElKS0xNZU5PUFFSU1QgVVZXWFlaMEIyMzQ1ODlbbyE/LTo7XWB3fkBcIyQlXiZsKl8rPXw@PGkg44Kz44O844OJ44K044Or44OVbiAg5Luj56K85L@d6b2h55CDZ866z4nOtM65zrrPjM@CIi5nc3ViIC8oLikuezd9LywnXDEn//8 "Ruby ‚Äì TIO Nexus")
```
print"Cachjkmq\x6fvyzADEFdGHIJKLMeNOPQRST UVWXYZ0B234589[o!?-:;]`w~@\#$%^&l*_+=|><i „Ç≥„Éº„Éâ„Ç¥„É´„Éïn ‰ª£Á¢º‰øùÈΩ°ÁêÉ gŒ∫œâŒ¥ŒπŒ∫œåœÇ".gsub /(.).{7}/,'\1'
```
[Answer]
# USML, 12 or 9 points (non-competing)
```
"Code\tBowling'
```
[Try it online!](https://marksill.github.io/Unnamed-String-Manipulation-Language/?code=%22Code%5CtBowling%27)
This answer cheats a bit by abusing how HTML renders. The string actually created by this is `"Code\tBowling "`. Points are lost for repeating the "o" character.
For a non-cheatsy answer:
```
"Code Bowling
```
USML is still fairly early in development and is not yet capable of increasing the size of the program any further yet.
[Answer]
# [Cubix](https://github.com/ETHproductions/cubix), 85
```
Codeha1spqumtr;$"gnilwoB"Sv"ADEFH%IJK2f!OPUzQ0V3XY&*[-|L:]\T`~#x>MR56cGk'?W<()b4j}.{Z_^/978@
```
[Try it online!](https://tio.run/##Sy5Nyqz4/985PyU1I9GwuKCwNLekyFpFKT0vM6c830kpuEzJ0cXVzUPV08vbKE3RPyC0KtAgzDgiUk0rWrfGxyo2JiShTrnCzjfI1CzZPVvdPtxGQzPJJKtWrzoqPk7f0tzC4f9/AA "Cubix ‚Äì Try It Online")
Cubified with insignificant characters replaced with .
```
        C o d e
        . . . .
        . . u . 
        . . ; . 
" g n i l w o B " S v " . . . .
. . . . . . . ! . . U . . . . .
. . . . . . . L . . \ . . . . .
> . R . . . . . . . W < . . . .
        . . . {
        . . ^ /
        . . . @
        . . . .
```
I think I have made the path fragile enough that removing characters will break it quite badly.
[Watch it run](https://ethproductions.github.io/cubix/?code=ICAgICAgICBDIG8gZCBlCiAgICAgICAgaCBhIDEgcwogICAgICAgIHAgcSB1IG0KICAgICAgICB0IHIgOyAkCiIgZyBuIGkgbCB3IG8gQiAiIFMgdiAiIEEgRCBFIEYKSCAlIEkgSiBLIDIgZiAhIE8gUCBVIHogUSAwIFYgMwpYIFkgJiAqIFsgLSB8IEwgOiBdIFwgVCBgIH4gIyB4Cj4gTSBSIDUgNiBjIEcgayAnID8gVyA8ICggKSBiIDQKICAgICAgICBqIH0gLiB7CiAgICAgICAgWiBfIF4gLwogICAgICAgIDkgNyA4IEAKICAgICAgICAuIC4gLiAuCg==&input=&speed=20)
```
- 92 characters long
- repeated alnum:       -3 (o)
- repeated punctuation: -4 ("")
- repeated other:       -0 ()
- whitespace characters:  -0 ()
- exotic characters:  -0 ()
Total score: 85
```
[Answer]
# [Zsh](https://www.zsh.org/) `--nocaseglob`, score 79
```
>' "%&+,.:<=@ADEGHJKMOQSUVWXYZ^_abfhjkmpqrtuvxyz~'>0
?()${(#)9}*/PRINTF Code\ Bowling;[!] 1 2 3 4 5 6 7 8 `ls|wc -L`
```
[Try it online!](https://tio.run/##BcHnAoFQGADQ/57iswvZe2TvvTcNKaSLIjJe/TrHUCWsChpQCBTEs6ogyojDtBMsdofb402mM7l8qVytNZrtbn84nkxn88Vmy3J76Xg6X6437f54voyfk/absgRpexNWMvF1@XqDemdUgSLaCSsoIF0@KGJqaV5DAIIQgjBEIAoxiAMjqx@dB6rFYPwH "Zsh ‚Äì Try It Online")
Previous version (score 84):
```
>\";?()/*/PRINTF %s g${9:8|#0}
rev <([!-+] A D E G H J K L '&,.=@^_`~1234567MOQSUVWXYZabcfhjkmpqtuxyz nilwoB edoC')
```
[Try it online!](https://tio.run/##BcFVAoJAFADAf0/xTMDC7u7ubkAEFVl1sTCuvs7oWCZY1MCFQEUCh0VJQTxJLUzxNM2wdrbTq7YGJbBikCzvaCzyMXu@hqt4hwQ9N7ocS8hCAYpQhgrUoA4NoGxOdzKzWm9@Xp8/EAyFm@1ufzgaT6Yzjhd28uF4Ol@02/Olg7pXHigH4hblKYaQPw "Zsh ‚Äì Try It Online")
Unfortunately, this wasn't irreducible for a number of reasons. Here is the limit of reducibility:
```
>\";?()/*/PRINTF g$8
rev <([!] A D E G H J K 'nilwoB edoC')
```
[Try it online!](https://tio.run/##qyrO@F@cWqKgm6@Ql5@cWJyanpOf9N8uRsnaXkNTX0s/IMjTL8RNIV3FgqsotUzBRiNaMVbBUcFFwVXBXcFDwUvBW0E9LzOnPN9JITUl31ld8/9/AA "Zsh ‚Äì Try It Online")
[Answer]
# [Acc!!](https://github.com/dloscutoff/Esolangs/tree/master/Acc!!), score -197
```
119
Write _-52
Write _-8
Count i while i-2 {
	Write _-19+i
}
32
Write _
_+34
Write _
_+45
Write _
_+8
Write _
_-11
Write _
Count i while i-2 {
	Write 105+i*5
}
_-5
Write _
```
[Try it online!](https://tio.run/##S0xOTkr6/9/Q0JIrvCizJFUhXtfUCM604HLOL80rUchUKM/IzElVyNQ1Uqjm4oRJG1pqZ3LVchnDNXDFaxubIHFMTJE4Fgi2rqEhnIPHBkMDU@1MLVOgFUBXwTT8/w8A "Acc!! ‚Äì Try It Online")
*Acc*!! works well for this challenge as whitespace is necessary and loops are costly. I made use of the *Acc*umulator here, but poorly, to increase chars. Here is a brief overview from the page:
> 
> `Accumulator` Any expression standing by itself is evaluated and assigned to the accumulator (which is accessible as `_`). Thus, e.g., 3 is a statement that sets the accumulator to 3; \_ + 1 increments the accumulator; and \_ \* N reads a character and multiplies the accumulator by its charcode. (N gets input)
> 
> 
> `Write <charcode>`
> Outputs a single character with the given ASCII/Unicode value to stdout. The charcode can be any expression.
> 
> 
> 
Loops in Acc, at least for golfing, are a pain. They require braces, and all whitespace is necessary.
Otherwise it's pretty self-explanatory.
]