Code-Bowling

Você foi contratado pela Brunswick Bowling para criar um programa simples para exibir o texto Code Bowlingem seus monitores. Esta empresa vale um centavo bonita e você sente que você pode enganar-los por muito o pouco de dinheiro.

A descrição do trabalho indica claramente que eles pagam com base na pontuação e você está bastante confiante de que pode manipular o sistema de pontuação deles a seu favor e obter o maior cheque de pagamento possível desses caras. Para fazer isso, será necessário que você insira o máximo de código possível em seu programa / função, mesmo que o sistema de pontuação tenha sido projetado para impedir que você faça isso.

Saia dos seus cofrinhos, vamos codificar!

Desafio

O desafio é simplesmente imprimir o texto Code Bowling, exatamente como está escrito aqui, com a maior pontuação possível. (Veja a seção: Sistema de pontuação abaixo)

Novas linhas iniciais e finais (quebras de linha) são aceitáveis.

Seu código pode ser um programa inteiro ou apenas uma função executável.

Regras

Obrigatório: Este desafio está usando o Boliche de Código: Regras Comuns, Revisão 1.0.0 ; Veja Meta para detalhes.

1. Proporção de caracteres: bytes
   No boliche de código, uma contagem de caracteres é preferível a uma contagem de bytes. O raciocínio óbvio para isso é que caracteres unicode de vários bytes (por exemplo, 🁴) podem ser usados ​​no lugar de caracteres unicode de byte único para aumentar a contagem de bytes e tornar o boliche mais sobre quem renomeia a maioria das variáveis ​​com caracteres unicode de byte alto. do que quem estrategicamente cria código complexo e significativo.

2. Nomes de variáveis ​​/ funções / objetos
   Todos os nomes de variáveis ​​(ou ponteiros de objetos, nomes de funções etc.) devem ter 1 caractere. O único momento aceitável para usar nomes de variáveis ​​de 2 caracteres é após todas as variáveis ​​de 1 caractere possíveis terem sido usadas. O único momento aceitável para usar nomes de variáveis ​​de 3 caracteres é depois que todas as variáveis ​​de 2 caracteres possíveis foram usadas. Etc.

3. Código não utilizado
   Todo o código deve ser usado. Significando que o programa deve falhar em sempre sempre concluir a tarefa corretamente, se qualquer caractere individual (ou conjunto (s) de caracteres variável) for / for removido. Naturalmente, um subconjunto do programa não deve ser capaz de concluir a tarefa sozinho, sem o restante do programa.

4. Comentários
   Não são permitidos comentários para contagem de caracteres, a menos que seja utilizado de alguma forma pelo seu programa / função.

Sistema de pontuação:

  Desafio Pangram:

Um pangram é uma frase que usa todas as letras pelo menos uma vez. (A raposa marrom rápida pula sobre o cachorro preguiçoso).

Esse tipo de desafio possui sistemas de pontuação projetados onde um pangram perfeito alcançaria a pontuação máxima teórica (embora você não precise usar todos os personagens pelo menos uma vez.) Além disso, o uso de qualquer personagem mais de uma vez começará a sofrer uma penalidade. Esse desafio também se expande para mais do que apenas os caracteres alfabéticos.

  Métrica de pontuação:

1. Cada personagem usado aumenta sua pontuação em 1.
2. O uso repetido de qualquer caractere alfanumérico (az, AZ, 0-9) resultará em uma dedução de 3 pontos por repetição (o primeiro uso não resulta em dedução).
3. O uso repetido da pontuação básica ([!?.-,":';])- incluindo os colchetes - resultará em uma dedução de 2 pontos por repetição.
4. O uso repetido de outros caracteres ASCII {`~@#$%^&*_+=|\/><}- incluindo os colchetes - resultará em uma dedução de 4 pontos por repetição.
5. O uso de espaços, tabulações e novas linhas resultará em uma dedução de 1 ponto por uso. Ou seja, eles não contam para o total de caracteres.
6. Os caracteres não mencionados acima (caracteres exóticos) resultarão em uma dedução de 1 ponto por uso. Ou seja, eles não contam para o total de caracteres.

  Ferramenta de pontuação:

Um widget de pontuação automatizado foi criado e pode ser encontrado aqui .

Esta é uma variante do código-boliche . O programa com a maior pontuação vence! (Como existe uma pontuação máxima de 94, quem chegar primeiro (se for possível) será marcado como a resposta aceita, embora outros sejam livres para continuar a responder por diversão)

Glypho , 94

O arquivo de origem está codificado no 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{·|}·√ⁿⁿ√~²²²

Experimente online!

Explicação

O Glypho é bastante útil para desafios como esse, porque não se importa com os personagens reais que estão sendo usados. Em vez disso, ele analisa cada parte de 4 caracteres e o comando usado é determinado pelo padrão que esses quatro caracteres formam:

0000 n
0001 i
0010 >
0011 \
0012 1
0100 <
0101 d
0102 [
0110 +
0111 o
0112 *
0120 -
0121 ]
0122 !
0123 e

Isso significa que podemos resolver o problema e preencher caracteres únicos em cada quarteto com os caracteres imprimíveis e todos os repetidos com alguns dos caracteres "exóticos", que são ignorados pela pontuação. O Glypho é suficientemente detalhado para que uma solução manuscrita normal contenha caracteres únicos suficientes para caber todos os 94 caracteres imprimíveis. Na verdade, acabei jogando golfe até ter exatamente 94, apenas para que eu pudesse usar caracteres exóticos exclusivos para os repetidos (espero, para tornar mais difícil a redução do programa).

A forma abreviada do programa acima é esta:

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

Onde cada linha imprime um dos caracteres.

Eu usei esse script Retina para convertê-lo em Glypho usando 0123. Depois, acabei de preencher os caracteres no lugar dos dígitos.

Em teoria, seria possível reduzir ainda mais isso, se alguém conseguisse jogar golfe no programa taquigráfico e depois recombinasse os caracteres para que os padrões certos aparecessem, mas não tenho certeza de como provar ou refutar que isso é possível . Se alguém conseguir formar uma solução válida a partir de um subconjunto do meu programa, informe-me para que eu possa excluir a resposta até que ela seja corrigida. Até lá, terei que assumir que isso é válido.

Python 3, 82 87 88

Obrigado a @JonathanAllan pela pontuação +1

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

Experimente online!

Nada de especial, apenas cortar e pular caracteres. A sequência é invertida para que você não possa remover caracteres e que a sequência original esteja sendo impressa.

> <> , 92 94

Sim, eu fiz isso!

␑é o caractere exótico\x11 com valor decimal 17. O programa sai com um erro após imprimir o resultado (é um estouro de pilha). Eu tive que gerenciar quais espelhos e comandos direcionais usei com cuidado, pois só posso usar cada um uma vez.

   >"vCoUV␑3`h]Z_X
       /a[f+
#$%&'r(!
.0456~8?
:;<=@9l)
ABDEFcGe
HIJKL*
MNOPQ7
RSTWYd
bgijk1
mnqst-
uwxyz2
{|}  ,
     \p^

Experimente online

O programa principal:

   >"vCoUV␑3`h]Z_X
       /a[f+
     r !
     ~ ?
     9 )
     c e
     *
     7
     d
     1
     -
     2
     ,
     \p^

Explicação:

Empurre a corda vCoUV␑3`h]Z_X >(execução envolve). Mover para baixo. Inverta a pilha e remova o v.

Empurre 9e c(12). Multiplique para obter 108( l). Empurre 7. Pressione d(13), subtraia 1, divida por 2para obter 6. Coloque lem (x, y) de (13,6), que está abaixo de e. Eu poderia ter feito esse caminho mais curto, mas isso é prolongado, então eu tenho espaço para colocar mais caracteres ASCII.

Mover para cima em um loop. Empurre o comprimento da pilha com l. Se for maior que 14, caractere de saída, crie uma nova pilha com os 10 principais elementos, adicione 15 e reflita a execução logo em seguida. Isso é usado para impedir que os espaços extras >sejam impressos no final, além de transformar a sequência de aparência aleatória no que precisa ser impresso. Continue dando laços.

Se alguma das linhas for mais curta (removendo um caractere), o programa não funcionará mais, porque as partes verticais do programa não estão mais alinhadas ou porque a sequência a ser impressa não está mais correta. Tentar remover um caractere na frente de cada linha alterará a profundidade da pilha e a llocalização da mesma, causando também problemas.

^_Peixe

Oitava, 20 21 22 25 27 33

O melhor que eu consegui até agora é

g=@()disp(horzcat([67 9583 -412],'e B',"nvkhmf"+!0));

Isso cria uma função anônima fque não recebe entrada. Você pode ligar f(). Eu diria que o ponto e vírgula no final é necessário, para evitar a impressão do corpo da função.

É possível que isso possa ser melhorado combinando evale printf, mas tentei e falhei várias vezes.

Isso usa todos os dígitos uma vez, explorando o fato de o Octave executar uma mod(x,256)operação ao converter implicitamente números em caracteres. Isso significa que podemos usar números negativos, assim como números fora do 32-126intervalo normal . Os seguintes números todos resultam na carta iquando convertido para caracteres: ... -2455 -2199 -1943 ... 105 361 .... Em vez de usar 'owling'no final, usamos "nvkhmf"e adicionamos 1. Isso cria um vetor de números inteiros que são implicitamente convertidos em caracteres. Em vez de 1, usamos !0(ou not(false). Além disso, usamos em "vez de 'evitar dois pontos de penalidade.

Precisamos encontrar o conjunto de números que apresenta a menor pontuação. A sequência Code Bowlingresulta na seguinte matriz, quando subtraímos e adicionamos -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

Então, ['',2627 2415 2148 1893 -2528 66 -1169 -1161 2668 105 -146 103]resulta em ans = Code Bowling. O desafio é encontrar o conjunto de números e caracteres que reduz mais a pontuação. É claro que usar todos os dígitos é bom, mas duplicatas são ruins. Como todos os dígitos são usados ​​e não são usados ​​duas vezes, essa é a melhor combinação possível. Além disso, chegamos a usar -, resultando em um ponto.

Pode-se afirmar que ele pode ser reduzido à linha abaixo (31 pontos), mas não seria mais uma "função executável" e, portanto, teria uma funcionalidade diferente.

disp(horzcat([67 9583 -412],'e B',"nvkhmf"+!0))

QBasic, 34

Este é um código não formatado (sim, para não diferenciar maiúsculas de minúsculas). Você pode executá-lo no QB64 ou no archive.org (observe que o último formatará o código enquanto você o digita). Eu acho que consegui cumprir todas as regras.

CLS
PrINT "C
LOcatE 1, 2 : ? CHR$(957-846); "de Bowling

O CLSnecessário: sem ele, Cnão há garantia de impressão no canto superior esquerdo da tela, onde será alinhado ode Bowling. O LOcatEnecessário: sem ele, ode Bowlingserá impresso na linha abaixo C. Não acredito que exista um subconjunto do programa (exceto espaços em branco) que possa ser excluído e mantenha a mesma saída.

C, 27 29

+2 pontos graças a @ceilingcat!

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

Haskell , pontuação 21 38 46 47 21 70

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

Experimente online! A idéia é obter a liderança Cconstruindo uma sequência de comprimento 67 que contém todos os caracteres não utilizados de outra forma e convertendo o comprimento dessa sequência em um caractere. Comecei com putStr$toEnum(length""):"ode B\x6Fwling"( '\x6F'é hexadecimal para o '\111'qual produz 'o') e calculei todos os caracteres ASCII imprimíveis não contidos no programa:

!#%&'*+,-./012345789;<=>?@ACDGHIJKLMNOPQRTUVWXYZ[]^_`abcfjkqsvyz{|}~

Aliás, permanecem exatamente 67 caracteres ASCII imprimíveis que podem ser inseridos na string, e eles Cmesmos que não podem aparecer na string, porque o programa seria redutível para apenas putStr"Code B\x6Fwling".

Solução anterior: (21 pontos)

f|x<-'C'=mapM putStr[(:)x"ode Bowling"]

Define uma função fque não aceita entrada e imprime a sequência. Experimente online!

JavaScript, 19

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

Não é uma pontuação muito alta.

Jelly , 94

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

Experimente online!

105 caracteres únicos, 11 exóticos ( “¹³⁵⁷°⁹⁻”ḄỌ).

Quão?

Forma a cadeia de caracteres de ASCII invertido de 8 bits, em que cada bit é codificado usando o LSB do valor Unicode de um caractere.

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

Röda , 33

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

Experimente online!

Eu tentei seguir todas as regras. Ele funciona pressionando primeiro a corda ode Bowling!no fluxo e inserindo C= 3 * 4 + 57-2 na frente.

Cardeal 20

23 caracteres não em branco
% #> / NI "CodeB8 ^ o) wl, ing

-3 para "o" repetido

   I
 >\/N
%# "CodeB
 8^o
 ) w
   l
 , i
   n
   g

Caminhos do ponteiro:

Etapa 1:
ponteiro criado em% indo para a direita

Etapa 2: o
ponteiro se divide em # para subir, direita e baixo (P1, P2, P3)

Etapa 3 :
P1 Enviado à direita por>
P2 Indo para a direita
P3 Defina a espera por 3 etapas em 8

Etapa 4:
P1 Refletido em \. \ alterado para /
P2 Defina para o modo de impressão por "
P3 Aguarde 2 tiques às 8

Etapa 5:
P1 Abaixo
P2 Impressão C
P3 Aguarde 1 tiquetaque às 8

Etapa 6:
P1 Enviado por ^
P2 Print o
P3 Conclua a espera em continuar, selecione o valor ASCII de "" (32) em)

Etapa 7: P1 Subindo
P2 Impressão d
P3 Subindo

Etapa 8: P1 Refletido à direita por \ que foi alterado para /
P2 Print e
P3 Print character com valor ASCII = 32 de, operação

Etapa 9:
P1 Refletido por / alterado para \
P2 Print B
P3 Atingido o final do campo e para

Etapa 10:
P1 Refletido por I
P2 Atingido o final do campo e para

Etapa 11:
P1 Refletido à direita por / que foi alterado para \. Altera de volta para /

Etapa 12:
P1 refletido deixado por N

Etapa 13:
P1 refletido por /

Etapa 14:
P1 Defina o modo de impressão por "

Etapa 15:
P1 Imprimir o

Etapa 16:
Impressão P1 w

Etapa 17:
Impressão P1 l

Etapa 18:
Impressão P1 i

Etapa 19:
Impressão P1 n

Etapa 20:
Impressão P1 g

Etapa 21:
P1 Chega ao final do campo e para.

Experimente Online

C, 73

Obrigado a @Laikoni!

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

Experimente online!

C,  31   33  35

F(){printf("Code B\157wli%cg",96|0xD+3*4/8);}

Obrigado a @ceilingcat e @DLosc por mais dois pontos e obrigado a Ørjan Johansen por mais dois pontos!

Experimente online!

Lote, 19 caracteres

@echO(Cod%TMP:~5,1% Bowling

A partir do Windows Vista, TMPcomeça com C:\Users\e, portanto, %TMP:~5,1%é uma maneira detalhada de escrever e, apesar de exigir uma %penalidade dupla com -4.

Brainfuck: -204

++++[++++>---<]>.+[--->+<]>+++.-----------.+.--[--->+<]>-.+[->++<]>.-[--->+<]>++++.++++++++.-----------.---.+++++.-------.

Bem, pontuação horrível, mas foi divertido de escrever.

• 122 caracteres
• alnum repetido: -0 ()
• pontuação repetida: -134 (- [---]. ----------- ..-- [---] -. [-] .- [---] ..-- ---------. --- ..-------.)
• outro repetido: -192 (+++++++> +> + <> ++++> + <> +> ++ <>> + <> ++++++++++++++ ++++)
• caracteres de espaço em branco: -0 ()
• caracteres exóticos: -0 ()

Java 8, 2 3 5 13 17 18 19 20 21 24 77 78 pontos

+53 pontos (24 → 77) graças a @Laikoni .

v->(char)"!#$%&'*,/0234689:;<=?@ADEFGHIJKLMNOPQRSTUVWXYZ[]^_`bfjkmpqsuxyz{|}~".length()+"\157de Bowling"

104 caracteres
- alnum repetido: -15 ( helng)
- pontuação repetida: -10 ( "()"")
- outro ASCII repetido: nenhum
- caracteres em branco: -1
PONTUAÇÃO: 78

Experimente online.

Resposta antiga de 24 bytes :

v->"C\157de Bowlin"+(char)103;

30 caracteres
- alnum repetido: -3 ( 1)
- pontuação repetida: -2 ( ")
- outro ASCII repetido: nenhum
- caracteres em branco: -1
PONTUAÇÃO: 24

Experimente online.

empilhadas , 42

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

Experimente online!

Deixa a saída na pilha. Aqui está o detalhamento:

length: 51
repeated alnum:        -0 ()
repeated punct:        -4 (',)
repeated other:        -0 ()
whitespace characters: -5 (     )
exotic characters:     -0 ()
total score: 42

Eu provavelmente poderia aumentar, mas é de 42 soo ....

Outro candidato, 40:

(67:43,sum)9 pf 2%MIN 0\|>+chr'de Bowling',EPS#`

Eu usei esse script para marcá-lo.

mal , -81

Melhor que Brainfuck!

aeeaeuwkaaeeuwygaeaeclaaxjlwalusbdgueuewguwpweewpuuuwuuuwpuweew

Explicação

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'

Enviado porque ninguém faz nada no mal, mas é meio divertido.

Ponto:

Comprimento = 63

a*8  = -24
e*12 = -36
g*2  = -6
l*2  = -6
p*2  = -6
u*12  = -36
w*10  = -30

Experimente online!

EDIT: TiO parece manipular incorretamente a criação e exclusão de novas células Wheel - eu arquivei um relatório de bug sobre o assunto. Não funcionará corretamente lá, mas eu o executei no meu próprio intérprete e funciona e você pode confiar em mim para que eu não me preocupe;)

Perl: 29 , 33

$_=OWLING;printf%s,"C\157de".chr(30+8/4).B.lc

Ponto:

- 46 characters long
- repeated alnum:       -6 (rc)
- repeated punctuation: -6 ("..)
- repeated other:       -0 ()
- whitespace characters:  -1 (
)
- exotic characters:  -0 ()

Total score: 33

05AB1E , 94 pontos

”X1234bcde5fghijk68l9<mn>,o.p|q\/{})r(_-+s=tu*vwxyzAB&YDEFG^HI%$ZK#L@!MNO~PQR`ST':UVW[0];"”€a7ôJCç€?

Experimente online!

- 100 characters long
- repeated alnum:       -0 ()
- repeated punctuation: -0 ()
- repeated other:       -0 ()
- whitespace characters:  -0 ()
- exotic characters:  -6 (””€ôç€)

Total score: 94

Basicamente converte (o ASCII binário do boliche de código):

['1000011', '1101111', '1100100', '1100101', '0100000', '1000010', '1101111', '1110111', '1101100', '1101001', '1101110', '1100111']

Em uma sequência de 1 e 0, substitui cada 1 por uma letra do alfabeto e cada 0 por um caractere de espaço ou símbolo ou dígito.

”X1234bcde5fghijk68l9<mn>,o.p|q\/{})r(_-+s=tu*vwxyzAB&YDEFG^HI%$ZK#L@!MNO~PQR`ST':UVW[0];"”

É a string, onde 1 é letras e 0 são símbolos, números ou qualquer outra coisa. Em seguida, iteramos, vendo quais são alfabéticos, pressionando 1 para alfabético 0 para não alfabético. Em seguida, dividimos em grupos de 7, convertemos novamente em ASCII e imprimimos cada caractere.

T-SQL, 65 18 32! pontos

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

Inspirado por um truque na resposta QBasic de Dlosc , encontrei uma maneira de incluir todos os 10 dígitos e a maioria dos operadores matemáticos ( %restante / módulo, faltando apenas /), principalmente por tentativa e erro. Eu não acho que exista uma maneira de obter um 67 removendo qualquer combinação de dígitos / símbolos, mas você pode tentar.

Versão 2 (18 pontos, trivial):

DECLARE @ char(12)='Code Bowling'PRINT @

Não é uma pontuação excelente, mas é para isso que minha primeira versão foi simplificada (obrigado, MickyT). Tudo o que eu tentei (codificar e decodificar hex64, escolher elementos individuais de uma string, converter valores ASCII etc.), todos tinham muitos caracteres repetidos (especialmente ECRsímbolos e (),@) que o direcionavam para o negativo.

Versão 1 (65 pontos, inválida):

DECLARE @ char(123)=
'Code Bowling FGHJKMOQSUVWXYZbjkmpqsuvxyz045789 [!?.-":;]{`~#$%^&*_+|\><}'
PRINT left(@,LEN(@)/6)

Eu usei o comprimento da string para determinar quantos caracteres eu uso no lado esquerdo; portanto, remover qualquer caractere único da string reduzirá o resultado da divisão inteira para 11, produzindo apenas Code Bowlin.

; # , pontuação -1163, não competidor

Eu não acho que isso seria muita competição, mesmo que pudesse competir.

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

Experimente online! Nota: O TIO não possui; # intérprete, apenas; # +.

CJam , pontuação 47

"'#?GyQ2wE(s6&␟JI!gF$u*Aq;0p4BvOKkHLhM"3/{:i~-z+c}%

Espero que não haja problemas com isso ...

Usa um caractere exótico (Separador de Unidade, ASCII 31, representado por ␟) e um caractere repetido ( "). Eu acho que poderia demorar ainda mais, mas vou deixar como está por enquanto.

Experimente online!

O programa funciona pegando essa cadeia longa e dividindo-a em substrings de comprimento 3. Cada substring é mapeada para o bloco, que converte seus caracteres em seus valores ASCII, despeja os valores na pilha, pega a diferença absoluta dos dois segundos, adiciona o resultado ao primeiro e depois converte o resultado final em ASCII personagem.

CJam, pontuação 93

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

Experimente online

Inspirado na resposta Python do TidB .
Não tenho certeza se existe alguma maneira de evitar a repetição das aspas duplas.

Explicação:

A string contém "Cpde Bowling" no sentido inverso, a cada 8 caracteres.
7~%extrai "Cpde Bowling" ( 7~= -8)
2,.-diminui o caractere p ( 2,= [0 1])

PHP, 33 pontos

Isso foi bastante difícil de conseguir.

A pontuação pode ser melhorada no futuro.

<?echo IHASZODECG9F^"
'%6z\r+2/.W!";

A nova linha é assumida como uma nova linha no estilo Linux! O estilo Windows e o estilo Mac antigo não funcionarão corretamente.

Ruby, 75

Aproximadamente uma porta da resposta do Python, mas Ruby não tem essa função de etapa legal, então eu uso gsub. Também decidi me divertir um pouco com os personagens exóticos, lançando frases no Google Tradutor

Experimente online!

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

USML, 12 ou 9 pontos (não concorrente)

"Code\tBowling'

Experimente online!

Essa resposta engana um pouco, abusando da maneira como o HTML é renderizado. A string realmente criada por isso é "Code\tBowling ". Pontos são perdidos por repetir o caractere "o".

Para uma resposta não enganosa:

"Code Bowling

O USML ainda está bastante adiantado no desenvolvimento e ainda não é capaz de aumentar ainda mais o tamanho do programa.

Cubix , 85

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

Experimente online!

Cubificado com caracteres insignificantes substituídos por.

        C o d e
        . . . .
        . . u . 
        . . ; . 
" g n i l w o B " S v " . . . .
. . . . . . . ! . . U . . . . .
. . . . . . . L . . \ . . . . .
> . R . . . . . . . W < . . . .
        . . . {
        . . ^ /
        . . . @
        . . . .

Eu acho que tornei o caminho frágil o suficiente para que a remoção de caracteres o interrompa bastante.

Assista correr

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

Total score: 85

VB.net, 68

cONSOLE.WRITE("Code BowlingADEFGHJKQUVXYZfhjkmpqyz`!@#$%^&*9876543~][{}\|';:<>?+=-_".subStrinG(0,12))

Um teste rápido aproveitando a insensibilidade do caso do VB e a falta de "sistema".

Shell: 17 pontos

#!/bin/bash
echo "CODE BoWLING" | tr D-X d-x

• 44 caracteres
• alnum repetido: -12 (bhoD)
• pontuação repetida: -4 ("-)
• outro repetido: -4 (/)
• caracteres em branco: -7 ()
• caracteres exóticos: -0 ()

Pontuação total: 17

Acc !! , 171 caracteres

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 _

Experimente online!

Acc !! funciona bem para esse desafio, pois o espaço em branco é necessário e os loops são caros. Usei o simulador Acc aqui, mas mal, para aumentar os caracteres. Aqui está uma breve visão geral da página:

AccumulatorQualquer expressão autônoma é avaliada e atribuída ao acumulador (acessível como _). Assim, por exemplo, 3 é uma afirmação que define o acumulador como 3; _ + 1 incrementa o acumulador; e _ * N lê um caractere e multiplica o acumulador por seu código. (N recebe entrada)

Write <charcode> Gera um único caractere com o valor ASCII / Unicode fornecido para stdout. O código pode ser qualquer expressão.

Loops em Acc, pelo menos para o golfe, são uma dor. Eles exigem chaves e todo o espaço em branco é necessário. Caso contrário, é bastante auto-explicativo.