Infinite Golfing, 92 points

ŸCode Bowling😍!"#$%&'()*+,-./0123456789:;<=>?@ADEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcfhjkmpqrstuvxyz{|}~

Where characters affect the ! sign is ignored. And the 05AB1E's compressed string writen in normal, which still allowed, not must to be compressed.

Malbolge, -18 points

A character in code turned into a bad markdown in my answer and you cannot view the code correctly. View it in a external page.

Unary, -\$10^{111}\$ points

Unary is only using 0s which means you'll get unbelievable penalties when attempting this challenge. It's impossible to get a good score in this language. The value of score is:

-579,809,555,048,597,636,242,893,454,262,269,912,958,917,199,157,898,485,376,687,513,913,432,932,082,006,165,360,567,833,363,297,486,652,989,580,433

;#, score -1163

I don't think this would be much competition even if it could compete.

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#

Try it online! Note: TIO has no ;# interpreter, only ;#+.

Lenguage, 94

Reduced by 450947698176028388843917607537842418986035722486451998047037459476165368967293205287214703816225093120721837128 bytes thanks to @ovs.

!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                    ...238120765277364887435892673116228159402534303033563968545104627044479808894 spaces omitted...                    

This gets converted to the brainf*** program +[[-<+<+>>>]>+<<<<+]>>>>>>++++.<<+.<<--.+.>>>>>--.<-.<<.>++++.<---.---.+++++.<<++. using the algorithm described here, which outputs Code Bowling. This gets the maximum score achievable for this challenge and at the same time is the longest program here!

Zsh --nocaseglob, score 79

>' "%&+,.:<=@ADEGHJKMOQSUVWXYZ^_abfhjkmpqrtuvxyz~'>0
?()${(#)9}*/PRINTF Code\ Bowling;[!] 1 2 3 4 5 6 7 8 `ls|wc -L`

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!

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!

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!

Acc!! works well for this challenge as whitespace is necessary and loops are costly. I made use of the Accumulator 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.

Whitespace, 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 (with raw spaces, tabs and new-lines only).

Uses this Whitespace tip of mine to print the output. The optimal constant 104 is generated by this Java program. 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. ;)

C, 73

Thanks to @Laikoni!

F(){printf("Code B\157wli%cg",48+strlen("!#$&'*-../2369:<=>?@ADEGHIJKLMNOPQRSTUVWXYZ[]^_`abhjkmquvxyz|~"));}

Try it online!

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!

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.

---

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.

Haskell, score 21 38 46 47 21 70

putStr$toEnum(length"!#%&'*+,-./012345789;<=>?@ADGHIJKLMNOPQRTUVWXYZ[]^_`abcfjkqsvyz{|}~"):"ode B\x6Fwling"

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!

T-SQL, 65 18 32! points

PRINT char(78-9605*43%12) + 'ode Bowling'

Inspired by a trick in Dlosc's QBasic answer, 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.

Cubix, 85

Codeha1spqumtr;$"gnilwoB"Sv"ADEFH%IJK2f!OPUzQ0V3XY&*[-|L:]\T`~#x>MR56cGk'?W<()b4j}.{Z_^/978@

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

- 92 characters long
- repeated alnum:       -3 (o)
- repeated punctuation: -4 ("")
- repeated other:       -0 ()
- whitespace characters:  -0 ()
- exotic characters:  -0 ()

Total score: 85

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!

---

- 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.

USML, 12 or 9 points (non-competing)

"Code\tBowling'

Try it online!

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.

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!

print"Cachjkmq\x6fvyzADEFdGHIJKLMeNOPQRST UVWXYZ0B234589[o!?-:;]`w~@\#$%^&l*_+=|><i コードゴルフn 代碼保齡球 gκωδικός".gsub /(.).{7}/,'\1'

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.

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

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!

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 ;)

CJam, score 93

"g!#$&'()n*+/0134i5689:;<l=>?@ADEwFGHIJKLoMNOPQRSBTUVWXYZ [\]^_`aebcfhjkmdqrstuvxpyz{|}  C"7~%2,.-

Try it online

Inspired from TidB's Python answer.
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])

stacked, 42

(67:43,1 ab)2 9*pf sum 8/0\|>+chr'de Bowling',EPS#`

Try it online!

Leaves output on stack. 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.

><>, 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

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

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 ()

Jelly, 94

“!#"$&('*)+-/,13.0456:79<;>=@B?ADFHJLNCPRTEVXZ\G^IKMQ`SWbY[]d_acfhjegliknmprotquvxwy{z}¹|³⁵⁷~°⁹⁻”O%2s8UḄỌ

Try it online!

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

Python 3, 82 87 88

Thanks to @JonathanAllan for +1 score

print("g!#$%&'*n+,./012i34579;<l=>?@ADEwFGHIJKLoMNOPQRSBTUVWXYZ ^_`abchejkmqsuvdyz{|}~ \x6f       C"[::-8])

Try it online!

Nothing special, just slicing and skipping characters. The string is reversed so you can't remove characters and have the original string being printed.

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

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.

Glypho, 94

The source file is encoded in CP437.

␀␀!"☺☺#$☻♥♥☻♦♣♦♣%♠♠&•◘•◘'○○(◙♂◙♂♀♪♪♀♫☼♫☼►◄◄►↕↕)*‼¶¶‼§§+,▬↨↨▬↑↓↑↓→←→←∟∟-.↔▲▲↔/▼▼▼⌂Ç⌂Çüééüââ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!

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 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.

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

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!

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.

C, 27 29

+2 points thanks to @ceilingcat!

f(){char q<:]="Code B\157wling";puts(q);%>

Röda, 33

{["ode B\x6fwling"]|push chr(3*4+57-2).._}

Try it online!

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.

QBasic, 34

This is unformatted code (yay for case-insensitivity). You can run it in QB64 or at archive.org (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.

JavaScript, 19

prompt('C\157de B\x6fwlin'+"g")

Not a very high score.