Um quebra-cabeça de programação do Mode Golf


43

Sua tarefa é imprimir o texto Good morning, Green orb!, com todos os caracteres repetidos no lugar quantas vezes o byte mais frequente em sua fonte (o modo). Uma nova linha à direita é permitida e não precisa ser repetida.

Por exemplo, se sua fonte foi

print p

Como paparece duas vezes e todos os outros bytes aparecem uma vez que você precisa imprimir

GGoooodd  mmoorrnniinngg,,  GGrreeeenn  oorrbb!!

As respostas serão pontuadas pelo produto de sua contagem de bytes e o número de vezes que a saída é repetida. Por exemplo, o código acima (se funcionou) teria 7 * 2 = 14 . O objetivo deve ser minimizar a pontuação de alguém.

Seu código deve conter pelo menos 1 byte.

Use este programa para verificar se seu código e saída correspondem


Funções são permitidas, certo?
totallyhuman

1
@totallyhuman Sim, desde que não recebam comentários.
Wheat Wizard

1
Isso não deve ser marcado como quine ?
FantaC

A manhã não pode ser capitalizada, pode haha?
Magic Octopus Urn

@magicoctopusurn Não, o texto deve ser o mesmo.
Assistente de trigo

Respostas:


18

Explosão cerebral , 384 * 106 366 * 100 = 36.600

(((((((()()()))))))(()({}{}{}(([(({}{})){}()]((((({}())){})){}{}()(({})<([{}](((({}()())))([{}]([{}]()((()()())(()()({}()([(({})){}()](((((({}))))({}({}{}{}){})(({}){}()))))<((((([]){}){}){}<>)<>)>[])))))))(((((()()())()){}{}){}){})<>(((({})<>)))>{}{})))))<(<>({})<>)>))(<>((({}))()){}{}<>)<>(((({}<>()))))({}{}{}<>)<>{((<>{}<><({}<>)>)<{({}[()]<(({}))>)}{}>)<>}<>{}

Experimente online!

Explicação

A primeira coisa que faço é empurrar a corda

!bro neerG ,gninrom dooG

para a pilha usando táticas bastante comuns de complexidade de Kolmogorov.

(((((((()()()))))))(()({}{}{}(([(({}{})){}()]((((({}())){})){}{}()(({})<([{}](((({}()())))([{}]([{}]()((()()())(()()({}()([(({})){}()](((((({}))))({}({}{}{}){})(({}){}()))))<((((([]){}){}){}<>)<>)>[])))))))(((((()()())()){}{}){}){})<>(((({})<>)))>{}{})))))<(<>({})<>)>))(<>((({}))()){}{}<>)<>({}<>())

Em seguida, empurramos um contador para a pilha off para nos dizer quantas vezes duplicar cada caractere. No entanto, eu não seria capaz de determinar o que era esse contador até terminar de escrever o programa.

Em seguida, invertemos a string simultaneamente e duplicamos cada caractere no lugar, o número correto de vezes. Especificamente, o contador + 1.

{((<>{}<><({}<>)>)<{({}[()]<(({}))>)}{}>)<>}<>{}

Essas duas partes do programa têm um modo de 99 parênteses abertos. No entanto, como certamente precisaremos de pelo menos 1 parêntese. Aqui é onde notei que o último caractere que pressionamos !convenientemente tem o código de caractere 33, o que significa que podemos usá-lo para criar 99, o número exato que queremos usando apenas um parêntese adicional. É uma coincidência, mas funciona.


9
Ah, sim, apenas táticas bastante comuns de complexidade de Kolmogorov. Essas são as coisas.
precisa

Você, meu bom amigo, deve estar louco para tentar isso. Vou apenas marcar com +1 e ir embora antes que meu cérebro exploda ao tentar entender todos os colchetes.
caird coinheringaahing

15

Haskell , 37 bytes × 3 = 111

-20 graças a H.PWiz. -25 graças a nimi.

"Good m\111rning, Green orb!"<*[2..4]

Experimente online!

Operadores da Haskell FTW.

Lembrete automático para nunca jogar golfe no celular. Eu continuo cometendo erros idiotas. Eu posso colocar pelo menos metade da culpa no celular. : P


5
Usando <*para salvar bytes (note que eu não tenho verificado sua validade)
H.PWiz

... Caramba, Haskell quase tem muitos operadores. Obrigado!
totallyhuman

15

brainfuck , 235 x 77 = 18.095 pontos

Edit: -2 bytes graças a @Dennis

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

Experimente online!

Teste TIO

Espere, isso não é boliche de código? \ s

Com apenas 8 caracteres utilizáveis, o brainfuck é um dos piores idiomas para fazer essa pergunta. Eu tive que começar minimizando qual personagem apareceria inevitavelmente mais, normalmente um +ou outro -. Depois de escrever a primeira iteração do código, achei-o terrivelmente desequilibrado em favor de +s. Reorganizei partes do código, como a geração de números maiores, para usar mais -. Finalmente, acabei com uma quantidade igual de dois caracteres, com 77 um a menos -que +. Certamente é possível reduzir ainda mais isso, o que terei amanhã.

Mas ei, pelo menos eu venci a resposta Brainflak


Ei, parabéns! Eu não posso acreditar que seja possível fazer isso no BF ... Bem, se isso puder ser feito no ;#idioma (͡ ° ͜ʖ ͡ °) #
RedClover

13

Gelatina , 13 bytes * 1 = 13

“¢Ȧ@XĊ'WÑṭḂ#»

Experimente online!


3
Finalmente, alguém gerencia a resposta * 1 indescritível. Eu tinha um pressentimento que Jelly seria o idioma para fazê-lo ...
ETHproductions

@ETHproductions Haha, reduzi meu código pela metade, mantendo * 1 #
Mr. Xcoder

Haha Dang Eu só descobri que logo depois que você editou
dylnan

Por curiosidade, qual é exatamente a diferença? Como a nova string compactada tem metade do comprimento da antiga?
ETHproductions

@ETHproductions Basicamente, usei inicialmente uma string compactada não ideal, depois usei o compressor Jelly otimizado, que encontrou as correspondências no dicionário.
Sr. Xcoder

10

Alice , 49 bytes * 2 = 98 144

/:G!4o3r8"1=5',0Grey9Z<@
\"b0=dnm 2'i%g<7R6~e.;o/

Experimente online!

Explicação

/...@
\.../

Essa é a estrutura usual para programas lineares que operam inteiramente no modo Ordinal. Desdobrando o fluxo de controle em zigue-zague, obtemos:

"G04d3m821i5g,7G6ee9;<:b!=onr "'=%'<0Rr~y.Zo@

A idéia básica é evitar caracteres que se repitam mais de duas vezes com a ajuda de uma transliteração. A transliteração que vamos fazer é a seguinte:

input: "G04d3m821i5g,7G6ee9;<:b!"
from:  "0123456789:;<"
to:    "onr "

A maneira como a transliteração funciona em Alice é que as strings frome tosão repetidas primeiro para o LCM de seus comprimentos, embora, neste caso, toda a questão seja o comprimento da fromstring, então obtemos:

from:  "0123456789:;<"
to:    "onr onr onr o"

Desta forma, temos quatro personagens diferentes para representar as os, e três para cada n, re o espaço. Podemos gerar a fromstring usando a expansão de intervalo da seguinte maneira:

'<   Push "<".
0    Append a zero.
R    Reverse.
r    Range expansion.

O único problema agora é que precisaríamos de quatro "para inputa tostring e a . Para evitar isso, colocamos os dois em uma única string e dividimos em um =usado como separador.

"G04d3m821i5g,7G6ee9;<:b!=onr "
     Push the string containing both parts.
'=%  Split around "=".

O resto é apenas:

~   Swap "from" and "to".
y   Transliterate.
.Z  Duplicate and interleave. This duplicates each character.
o   Print.
@   Terminate the program.



5

C (gcc) , 68 × 3 = 204

0000000: 6a 3b 6d 61 69 6e 28 29 7b 77 68 69 6c 65 28 6a  j;main(){while(j
0000010: 3c 37 32 29 70 75 74 63 68 61 72 28 7e 22 b8 90  <72)putchar(~"..
0000020: 90 9b df 92 90 8d 91 96 91 98 d3 df b8 8d 9a 9a  ................
0000030: 91 df 5c 32 32 30 8d 9d de 22 5b 6a 2b 2b 2f 33  ..\220..."[j++/3
0000040: 5d 29 3b 7d                                      ]);}

Agradecemos ao @MDXF por economizar 9 pontos e abrir caminho para mais 6!

Experimente online!

Versão alternativa, ASCII imprimível, 69 × 3 = 207

j;main(k){while(j<72)putchar("Gnmg$hiuf`dl -I}ut|3{gt6"[k=j++/3]^k);}

Experimente online!




5

Vim, 42 41 pressionamentos de tecla × 3 = 123

iGod morning, Green orb!<Esc>2|qsyl2pl@sqX0@s

Explicação:

  1. iGod morning, Green orb!<Esc>
    Escreva a string God morning, Green orb!(uma ofaltando).
  2. 2|
    Salte para o primeiro o.
  3. qsyl2pl@sq
    Crie uma macro recursiva s. Como efeito colateral, triplique a corrente o.
  4. X0
    Remova um oe pule para o começo.
  5. @s
    Execute a macro s, que repete cada caractere duas vezes.

4

C, 78 × 4 = 312

*s=L" ÞÞÈ@ÚÞäÜÒÜÎX@äÊÊÜ@ÞäÄB";main(y){while(*++s)for(;y++%5;putchar(*s/2));}

Experimente online!

356 332


Comentando porque estou cansado de encontrá-lo no histórico do meu navegador toda vez que quero jogar golfe: usei isso para encontrar o número de repetições de caracteres.
MD XF

E isso para codificar a string.
MD XF

3

Japt , 24 bytes * 2 = 48

`Good ¶rÍÁ,
GÎ9 b!`m²·¸

Contém um não imprimível. Teste online!

A maioria do programa é apenas uma sequência compactada, que descompacta para

Good morning,
Green orb!

e então maps cada personagem repetindo-o ²duas vezes bem, isso foi um pouco exagerado . Espaço é o único caractere que aparece 3 vezes na cadeia compactada; Para salvar uma instância, substituí-la por uma nova linha e usar·¸ para dividir em novas linhas e ingressar imediatamente em espaços. Embora mais 2 bytes, reduz substancialmente a pontuação (de 66 para 48).

Agora, se houvesse uma maneira curta de fazê-lo usando nenhum caractere duas vezes ...


Porque não consigo ver: qual personagem está na fonte três vezes? Vejo várias coisas que contam 2, mas não 3.
Draco18s

1
@ Draco18s Nenhum, a pontuação é de 24 * 2.
ETHproductions

Então a saída está errada. Você está imprimindo cada caractere três vezes em vez de duas vezes.
Draco18s

@ Draco18s Dangit, postou o link errado ... Obrigado por apontar isso.
ETHproductions

*salute*E agora que olho para a sua resposta, vejo que tem ², enquanto o link tinha ³ :) #
Draco18s

3

SNOBOL4 (CSNOBOL4) , 97 bytes * 10 = 970

	S ='Good Morning, Green orb!'
y	S	LEN(1) . y rem . s	:f(p)
	x	=x DUPL(y,10)	:(y)
p	OUTPUT	=x
END

Experimente online!

Sim ........ O SNOBOL exige que os operadores sejam separados por espaços em branco, e há requisitos de espaços em branco bastante estranhos. Existem 9 '\t'e 10 ' 'no código, portanto, quaisquer melhorias exigirão uma mudança bastante significativa na abordagem.


3

R , 65 bytes * 5 = 325 59 bytes * 5 = 295 62 bytes * 4 = 248

cat(gsub('(.)',strrep('\\1',4),"Good Mo\x72ning, Green orb!"))

Experimente online!

Existem 4 (or,')caracteres.


2
Eu nunca vi isso strrepantes, isso deve ser útil.
BLT


3

Perl 5 , 59 × 2 = 118 pontos

$_="GSSdYmoVRing,YGVIen orb!";y<H-Z>[d-t ],s<.>[$&x2]eg;say

Experimente online!

Perl 5 , 51 × 3 = 153156 pontos

s""GOOd morning, Green orb!";y'O'o';s/./$&x3/eg;say

Experimente online!

Perl 5 , 43 × 4 = 172 pontos

say"Good morning, Green orb!"=~s/./$&x4/egr

Experimente online!

Economizou 2 bytes em cada solução graças ao @Xcali (algumas alterações atrás). Para todas as otimizações, observe as edições.


Fazer deste um programa em vez de uma função economizaria 2 bytes (4 pontos): Experimente online!
Xcali

@Xcali, mas sua alteração precisa de uma opção fora do padrão -M5.010, o que também conta #
mik


2

V , 35 bytes * 2 = 70

IG²od morning, GreeN ORb!5h3~Óˆ/°°

Experimente online!

Hexdump:

00000000: 4947 b26f 6420 6d6f 726e 696e 672c 2047  IG.od morning, G
00000010: 7265 654e 204f 5262 211b 3568 337e d388  reeN ORb!.5h3~..
00000020: 2fb0 b0                                  /..


2

Python 2 , 62 * 4 = 248

Graças a @ovs e @ Giuseppe!

lambda:"".join(c*4for(c)in"G\x6f\x6fd mor\x6eing, Green orb!")

Experimente online!

Python 2 , 51 * 6 = 306

print"".join(c*6for c in"Good morning, Green orb!")

Experimente online!

Python 2 , 70 * 5 = 350

lambda:"".join(c*5for(c)in"Gxxd mxrning, Green xrb!".replace('x','o'))

Experimente online!

Graças a @Mr. Xcoder para salvar um byte de ambas as versões!


Você pode remover o espaço entre 6e for.
Xcoder

@ Mr.Xcoder Obrigado!
Steadybox


@ovs isso não está certo, acho que você precisa de dois \x6fs, o que ainda é bom para 244
Giuseppe



2

CJam , 32 bytes × 2 = 64

"Gnmg$hiuf`dl -I}ut|3orb!"K,.^:_

Experimente online!

Empurra uma string e, em seguida, XORs o primeiro 20 caracteres com [0, 1, …, 19], e duplica cada caractere.


2

05AB1E , Pontuação: 22 (22 bytes * 1)

…‚¿•´,„ˆ¨èã).ªðý23£'!«

Experimente online.

Explicação:

NOTA 1: A pilha de quebra automática na lista interna )é usada em vez do par incorporado , porque ela já faz parte da palavra do dicionário good.
NOTA 2: As duas vírgulas no código e ,podem ter a mesma aparência, mas são caracteres unicode diferentes . O primeiro normalmente é usado para o par incorporado e o segundo para a impressão incorporada em STDOUT com nova linha à direita . Nesse caso, eles são usados ​​para a palavra do dicionário goode a vírgula esperada na saída.

…‚¿•´,        # 3-word dictionary string "good morning," (the comma counts as the third word)
„ˆ¨èã         # 2-word dictionary string "green orbit"
)             # Wrap everything on the stack into a list: ["good morning,","green orbit"]
            # Sentence capitalize all strings: ["Good morning,","Green orbit"]
   ðý         # Join by spaces: "Good morning, Green orbit"
     23£      # Only leave the first 23 characters: "Good morning, Green orb"
        '!«  '# Append a "!": "Good morning, Green orb!" (and output the result implicitly)

Veja esta dica 05AB1E (seção Como usar o dicionário? ) Para entender por que …‚¿•´,é "good morning,"e „ˆ¨èãé "green orbit".




1

Gelatina , 31 bytes × 2 = 62 pontos

“2ðƈZ(Øṡdȷ¿Ɱ’ṃ“God mrnig,eb!”x2

Experimente online!

Explicação

“2ðƈZ(Øṡdȷ¿Ɱ’ṃ“God mrnig,eb!”x2
“2ðƈZ(Øṡdȷ¿Ɱ’                     Base 250 number
              “God mrnig,eb!”     Unique characters of "Good morning..."
             ṃ                    Convert the base 250 number in base 13 then index into the string "God mr..."
                             x2   Repeat each character twice because “ occurs twice in the source (and now 2)

1

JavaScript (ES6), 61 bytes * 3 = 183

_=>'Good morning, Gr\145en \x6f\x72b!'.replace(/./g,"$&$&$&")

JavaScript (ES6), 51 bytes * 4 = 204

_=>'Good morning, Green orb!'.replace(/./g,'$&$&$&$&')

Resposta sugerida por @ETHproductions .

JavaScript (ES6), 73 bytes * 4 = 292

_=>`G00d mo1ning, G244n orb!`.replace(/./g,_=>(('o'+!0)[_]||_).repeat(4))

JavaScript (ES6), 58 bytes * 6 = 348

_=>'Good morning, Green orb!'.replace(/./g,_=>_.repeat(6))


Como alternativa, altere _=>_para'$&'
ETHproductions

1
Como alternativa, acho que você pode simplesmente fazer '$&$&$&$&$&$&'a substituição, o que, então, permite remover duas instâncias e passar a ter vários caracteres empatados em 4, reduzindo drasticamente a pontuação ...
ETHproductions

@ETHproductions Obrigado, não sabia sobre esse padrão de substituição!
darrylyeo


1

Ruby, 55x4 = 220 pontos

"Good morning, Green orb!".split(//).each{|x|print x*4}

Estou bastante irritado que o uso de each_char faça a contagem de 5 de r.


1

Pushy , 36 * 2 = 72

`GXVWOP^4W_[afdc\hiB`N$29+L-''.

Experimente online!

O princípio principal desta resposta é que cada caractere né armazenado n + index - 29para evitar a repetição na string original. Esse mapeamento criou a string nos backticks. O restante do programa simplesmente decodifica isso e imprime cada caractere duas vezes:

` ... `              \ Push the encoded string
       N             \ Remove printing delimiter
        $            \ While there are items left on stack:
         29+         \   Add 29 to top of stack
            L-       \   Subtract current length from top of stack
              ''.    \   Print twice, then pop

Bytes usados ​​duas vezes: `'W

Changelog

  • Comprimento de golfe de 41 a 38, alterando o método de decodificação.
  • Comprimento de golfe de 38 a 37, subtraindo 29 de cada caractere codificado para evitar caracteres multibyte.
  • Comprimento de golfe de 37 a 36 usando o 'loop final' implícito
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.