Envie o texto "Code Bowling"

54

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

Albert Renshaw
fonte
37
Consegui obter uma pontuação de -75k. Se essa fosse a pontuação mais baixa, eu estaria fazendo incrivelmente.
ATaco
11
@carusocomputing Tente headsecks. A pontuação provavelmente ainda será péssima. Além disso, você não pode realmente usar o BF, pois qualquer comando não é um comentário e pode ser removido.
mbomb007
11
Delimitar seria bom para isso, porque ele realmente não se importa com o que os caracteres que você usa, apenas o ASCII combinado de um conjunto de caracteres
MildlyMilquetoast
2
O código mais curto seria um bom desempate neste desafio!
Stewie Griffin
2
Talvez alguém pode resolver que através da atribuição de prémios para os outros 94-ers
masterX244

Respostas:

36

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.

Martin Ender
fonte
Coisas boas! Estou aceitando isso por enquanto, já que 94é a pontuação máxima. Todos os outros são livres para continuar enviando respostas por diversão .
Albert Renshaw
Bom trabalho, Martin! Se eu tivesse sido um algumas horas mais rápido ...: D
mbomb007
@AlbertRenshaw Talvez o desempate deva ser contado em bytes? : D
mbomb007 14/03
49

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.

TidB
fonte
2
Woah. isso é bom
Matthew Roh
11
Resposta muito boa, mas por que a ordem embaralhada? Não seria mais simples (para você) tê-lo na ordem em que são naturalmente ( HIJKLMN...), exceto para cada oitavo personagem, é claro?
Stewie Griffin
@ StewieGriffin Teria sido mais fácil, sim. Eu apenas iterava os sets e realmente não me importava com a classificação.
TidB 14/03
Existe uma razão para você preencher os outros personagens em uma ordem tão estranha?
mbomb007
2
Você é como inspiração TidB! Minha nova pergunta :)
Stewie Griffin
17

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

mbomb007
fonte
94! Agradável! Eu não acho que você chegar lá haha
Albert Renshaw
2
Quando comecei a fazer a primeira versão, sabia que poderia reutilizar algumas. Então me livrei do "e lcom bastante trabalho. Quando atingi 92, tive certeza de que havia uma maneira de remover o último o. Demorou um pouco de esforço, no entanto. Você pode dizer pelo histórico de revisões.
mbomb007
16

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))
Stewie Griffin
fonte
Você tentou function q();disp(...)também? Exceto pelo i(), eles não são sobrepostos.
Sanchises 15/03/19
@ Sanches eu posso dar uma olhada. Mas cotna corda horzcate nfna corda diminuirá a pontuação bastante drasticamente. Pode ser melhor, se eu remover horzcate criar a string de outra maneira, mas também não posso usá-la +!0. Eu ficaria surpreso se aumentar a pontuação para ser honesto ... São apenas 7 caracteres a mais do que a resposta atual, e receberei uma penalidade de 7 bytes, além dos que mencionei.
Stewie Griffin
11
Sim, eu não conseguia obter uma pontuação mais alta trivialmente function, mas achei que você já deveria ter tentado isso e estaria perdendo meu tempo (em vez de, você sabe, gastar meu tempo com utilidade no PPCG)
Sanchises
12

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.

DLosc
fonte
11
Você pode compartilhar um link para um intérprete online? Não consigo executar isso no repl.it. Eu recebo #Parse failed: Syntax error at 3:36: Token(Bowling)
Stewie Griffin
11
@StewieGriffin Editado em algumas opções.
DLosc
11
@StewieGriffin, isso tira proveito de uma peculiaridade nas implementações da Microsoft do Basic, em que a cotação de fechamento de uma string é opcional se ela se estender até o final da linha. Espero que a maioria dos intérpretes que não sejam da Microsoft se oponha às aspas ausentes.
Mark
Aparentemente, o QBasic tem uma associação de cheiro muito forte para mim.
Não que Charles seja o
11
@DLosc Cheira como o livro que aprendi e como a sala de computadores da minha casa enquanto crescia. Eu não fazia ideia. Foi LOCATE 1, 2que fez isso
Não que Charles
12

C, 27 29

+2 pontos graças a @ceilingcat!

f(){char q<:]="Code B\157wling";puts(q);%>
betseg
fonte
2
Sugerir em char q<:]vez de char q[]e em puts(q);%>vez deputs(q);}
tetocat 14/03/19
Sugestão: 1.Using funções separadas para a saída de cada segmento da cadeia de caracteres e, em seguida, executá-los todos em função f 2. A mágica do uso de estruturas para tornar o código excessivamente longo
Matthew Roh
11
@MatthewRoh Eu acho que você pode encontrar os pune sistema de pontuação que muito fortemente
Albert Renshaw
11
@AlbertRenshaw Essas são dígrafos
ceilingcat
15
Haha, primeira vez que vejo um+2 points thanks to ...
Kritixi Lithos 14/03
9

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!

Laikoni
fonte
11
Este pode ser reduzido
Leo
@Leo boa captura! Essa abordagem também funciona para a minha versão atualizada com 95na string e subtraindo 4621? (Eu não tenho tempo para verificar isso sozinho agora, mas vou olhar para ele algum tempo depois)
Laikoni
11
Entendi . Me levou mais tempo do que deveria, vendo o quão simples o resultado é :)
Leo
8

JavaScript, 19

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

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

Somente ASCII
fonte
z(){var x=alert('Code \nBowling');}
23717
@AlbertRenshaw, o ponto e vírgula pode ser removido
somente ASCII
11
@sagiksp Não funciona, não tem functionantesf
somente ASCII
11
Damnit onão foi utilizado
apenas ASCII
11
19:prompt('C\157de B\x6fwlin'+"g")
Albert Renshaw 14/03
8

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
Jonathan Allan
fonte
11
A geléia é mais longa que outras, como isso é possível?
Christopher
11
@DownChristopher Na verdade, é mais curto que a resposta em python. A resposta python tem repetição.
f Marnɛtɪk 14/03/19
@DownChristopher, eu detecto o sarcasmo?
Jonathan Allan
@ JonathanAllan no Sim, eu ainda acho engraçado que a geléia seja bem longa aqui #
Christopher
6

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.

fergusq
fonte
6

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

fəˈnɛtɪk
fonte
5

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!

Steadybox
fonte
11
@ceilingcat Então, pode-se remover o 8-código e ainda ter um código válido. 0xA-4+8deve funcionar, no entanto.
DLosc 15/03/19
11
Funcionaria 0xA+32/8? (Sem que algo seja removível, isto é.) #
Ørjan Johansen
@ ØrjanJohansen Eu acho que sim. Nenhum dos +32, +3, +2, +3/8, +2/8, /8ou +8produz a saída direita. Obrigado!
Steadybox
Ah, ou 0xD+4*8/32. Não, espere, isso diminuiria para 0xD+4/3não.
Ørjan Johansen
11
Usar a mesma abordagem da minha resposta Haskell dá uma pontuação de 74, se não for redutível de forma alguma: Experimente on-line!
Laikoni
3

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.

Neil
fonte
3

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 ()
Haydn Dias
fonte
Brainfuck vence algum desafio de PPCG? ; P
Draco18
@ Draco18s provavelmente não hahaha chorar.
Haydn Dias
11
'Divertido escrever', você quer digitar "Code Bowling" em um gerador de texto ?
Jo rei
3

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.

Kevin Cruijssen
fonte
O uso de uma fuga octal no texto aumentaria sua pontuação em 6 em vez dos 2 que você obtém na sua fuga Unicode (ter as duas coisas é pior). Além disso, concatenar o primeiro ou o último caractere aumentará sua pontuação em 1. Finalmente, pense que você pode estar melhor com uma lambda em vez de uma função nomeada.
Neil
@ Neil Weird, eu já inventei Object x(){return"C\157de Bowling";}algumas horas atrás por 17 pontos .. Aparentemente, eu não editei / salvei na minha submissão, no entanto ..: S Quanto ao lambda, eu uso o Java 7, que não ainda tem lambdas. Eu poderia adicionar uma resposta Java 8 com lambda, no entanto.
21717 Kevin Kubijssen
Opa, desculpe, eu não percebi o 7. (Mas não se esqueça a concatenação.)
Neil
11
Usar a mesma abordagem da minha resposta Haskell fornece a esta versão uma pontuação de 77: Experimente online! .
Laikoni
@Laikoni Thanks! +53 pontos graças a você. E uma vez que Java 8 respostas normalmente são respondidas sem o ponto e vírgula à direita, eu poderia remover essa arrastando-e-vírgula e substituir o repetido ,,com ,;a outra +1. Engraçado como a String usando todos os ASCII imprimíveis disponíveis restantes é EXATAMENTE 97 caracteres para código de char C. :)
Kevin Cruijssen 28/02
2

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.

Conor O'Brien
fonte
2

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

charliefox2
fonte
2

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
Toto
fonte
2

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.

Urna de polvo mágico
fonte
2

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.

BradC
fonte
Não tenho certeza, mas acho que isso pode ser reduzido para DECLARE @ char(12)='Code Bowling'PRINT @as regras.
MickyT
@MickyT Isso pode invalidar minha resposta? Alguém no bate-papo disse que ele só precisava suportar a remoção de caracteres aleatórios únicos, não longas porções arbitrárias, eles estavam incorretos?
BradC 21/06
Eu deixá-lo aqui para o momento, é sempre bom ver uma resposta t-SQL
MickyT
@MickyT Eu vou deixar, mas riscar o placar. Melhor eu poderia fazer o contrário é míseros 18 pontos: P
BradC
2

; # , 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; # +.

Khuldraeseth na'Barya
fonte
1

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.

Gato de negócios
fonte
1

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

aditsu
fonte
@Laikoni se você significava que eu quebrou a regra código não utilizado, deve ser corrigido agora
aditsu
@ Laikoni sim, mas se você remover qualquer caractere único em seu código, ele não funcionará corretamente; portanto, porque todo o código é usado, é válido.
Magic Octopus Urn
@carusocomputing As regras mencionam claramente que o código não deve funcionar "se qualquer caractere individual (ou conjuntos variados de caracteres) for / for removido.", portanto, não acho que sua interpretação seja válida. De qualquer forma, o aditsu já corrigiu o problema, então está tudo bem agora.
Laikoni
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.

Ismael Miguel
fonte
1

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'
Value Ink
fonte
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.

MarkSill
fonte
"O USML ainda está bastante adiantado no desenvolvimento e ainda não é capaz de aumentar ainda mais o tamanho do programa. ". Que tal isso por 10 pontos "Code&'Bowling(* Nota: Substitua &por uma quebra de linha, não me permitirá digitá-las nos comentários)
Albert Renshaw
Você também pode adicionar uma barra invertida `` na frente de qualquer uma das letras e ela ainda produzirá a mesma string, já que o compilador a ignora ou escapa o caractere para si próprio. Agora, a pontuação (competitiva) chega a 11!
Albert Renshaw
Você pode adicionar uma quebra de linha e uma minúscula s à próxima linha (obtendo uma subcadeia de nada, sem alterar a saída) para obter sua pontuação competitiva em até 12, a mesma que a pontuação não concorrente, exceto uma pontuação real. apresentação válida: D
Albert Renshaw 9/17
De fato, aqui está uma resposta de 16 pontos no USML, vou postar o rushbin nele, pois é difícil digitar o código de várias linhas nos comentários: rushbin.com/icuguviyax.tex
Albert Renshaw
Sou um idiota e esqueci as regras do meu próprio desafio, lol, um subconjunto do código acima ainda completaria o desafio, desqualificando minha resposta; Ops!
Albert Renshaw
1

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
MickyT
fonte
0

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

chrixbittinx
fonte
11
Não conheço o VB.net, mas isso não pode ser reduzido a cONSOLE.WRITE("Code Bowling")?
Laikoni
11
Sim, pode. Pela publicação,: 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. "Pontuação deve ser 17, eu acredito."
charliefox2
@ charliefox2 Obrigado. Eu não li isso - deve ter ficado muito animado para usar o VB novamente!
chrixbittinx
11
Ei, 17 ainda esmaga minha pontuação de -81!
charliefox2
0

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

Perette
fonte
0

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.

FantaC
fonte
Este é um desafio de boliche, não de golfe, então você deve maximizar a pontuação. Além disso, sua pontuação é incomum. Usando a ferramenta de pontuação acima, seu código obtém uma pontuação negativa.
Ørjan Johansen
11
@ ØrjanJohansen Parece que eles estão tentando maximizar a pontuação (devido a "fiz uso do umulador Acc aqui, mas mal, para aumentar os caracteres"), mas eles simplesmente não a pontuaram corretamente.
LyricLy
@ ØrjanJohansen Ah sim, parece que eu perdi completamente a seção de pontuação. Vou atualizar
FantaC