O desafio
Escreva um programa completo que grave duas vezes mais bytes na saída padrão do que o tamanho do programa.
Regras
O programa deve gravar caracteres ASCII na saída padrão.
O conteúdo da saída não importa.
A saída, medida em bytes, deve ter exatamente o dobro do tamanho do programa, também medida em bytes, a menos que você cumpra o bônus.
Qualquer nova linha à direita é incluída na contagem de bytes da saída.
Bônus
Seu programa pode opcionalmente pegar um número n
, como entrada. Nesse caso, a saída deve ser exatamente n * program length
bytes. Você pode assumir que n sempre será um número inteiro positivo. Se nenhuma entrada for fornecida, o n
padrão será 2.
Se você fizer isso, poderá subtrair 25 bytes da sua pontuação.
O programa mais curto vence.
Restrições
Sem brechas padrão.
O programa deve ter pelo menos 1 byte de comprimento.
Não é necessário adicionar espaço em branco desnecessário ao código-fonte para alterar seu comprimento. Da mesma forma, os comentários não contam.
A menos que você cumpra o bônus, o programa não deve aceitar nenhuma entrada. Se você cumprir o bônus, o número inteiro deverá ser a única entrada.
A pontuação mais baixa (tamanho do programa em bytes - bônus) vence.
A resposta mais curta para cada idioma vence para esse idioma .
Classificação
Aqui está um snippet de pilha para gerar uma classificação regular e uma visão geral dos vencedores por idioma.
Para garantir que sua resposta seja exibida, inicie-a com um título, usando o seguinte modelo de remarcação:
# Language Name, N bytes
onde N
está o tamanho do seu envio. Se você melhorar sua pontuação, poderá manter as pontuações antigas no título, identificando-as. Por exemplo:
# Ruby, <s>104</s> <s>101</s> 96 bytes
Se você quiser incluir vários números no cabeçalho (por exemplo, porque sua pontuação é a soma de dois arquivos ou você deseja listar as penalidades do sinalizador de intérpretes separadamente), verifique se a pontuação real é o último número no cabeçalho:
# Perl, 43 + 2 (-p flag) = 45 bytes
Você também pode transformar o nome do idioma em um link que será exibido no snippet do placar de líderes:
# [><>](http://esolangs.org/wiki/Fish), 121 bytes
fonte
n * program length
bytes ou isso é mínimo?Respostas:
HQ9 + , 2 bytes
saídas
Eu acho que não é proibido aqui.
fonte
QQ
em um intérprete.Shakespeare, 768
Sim, Shakespeare não é um idioma de golfe. Produz 1.536 espaços.
Editar: 256
Ok, eu vou jogar golfe. Observe que o acima exposto não é compilado em nenhuma implementação existente de Shakespeare porque eu a escrevi minuciosamente à mão (mas estou preparado para defender sua correção.)
O abaixo é traduzido para C com um aviso no spl-1.2.1 e gera 512 espaços:
fonte
Lembre-se, 17 bytes
16 NOOPs. Em seguida, o depurador
!
é chamado e despeja a memória no console. A memória está vazia, mas o cabeçalho tem 34 bytes:Experimente aqui .
fonte
Mathematica REPL, 1 byte
Imprime
#1
.fonte
CJam, -17 bytes
O código fonte tem 8 bytes de comprimento e se qualifica para o bônus de -25 bytes .
Experimente online no intérprete CJam .
Como funciona
fonte
Python 2.6, 10
Imprime
-0.10000000000000001
, que é de 20 caracteres.Observe que a sequência repr mostra mais precisão.
print-.1
apenas fornece-.1
eprint.1/3
fornece0.0333333333333
apenas 13 dígitos de precisão.fonte
print`+.1`
?Semente , 10 bytes
Isso é compilado no programa Befunge (encontrado pela força bruta)
que produz os seguintes 20 bytes quando executado (testado no CCBI, observe o espaço à direita):
Por não estar familiarizado com o Befunge 98, tive que verificar as especificações algumas vezes para este:
k
parece bastante danificado para mim, executando mais uma vez do que o pretendido, devido à passagem do IP para a instrução repetida.
saídas como um número, seguido por um espaçofonte
R,
32 bytesCódigo
Saídas
Uau, finalmente R, finalmente.
Parece que
{}
também funciona, geraNULL
Bônus
3316 bytes:Código
Saídas
fonte
Matlab,
75 bytes2 bytes a menos graças ao @flawr!
Resultado:
A saída contém , portanto, 10 bytes.
newline
ans =
newline
newline
3
newline
fonte
format compact
como padrão :)format loose
é a preferência padrão123;4
? É três bytes mais curtos =)JavaScript, 2 bytes!
Ainda menor que a solução de 3 bytes:
Retorna
true
após a execução.fonte
Python 2, 11
Imprima a representação de sequência do built-in
id
, que é 22 caracteres:O
*1
é obter o código para 11 caracteres. Você também poderia fazerprint id;00
.Alternativas mais chatas 11 são:
fonte
print.8/-9j
é um caractere curtoprint id,;1
suficiente para suprimir a nova linha à direita. Também não adiciona um espaço à direita.print 9**21
não funciona. São 21 caracteres.print 9**23
funciona emboradc, 10 - 25 = -15
Toma uma linha em branco para "sem entrada".
Calcula 10 ^ (10 * n) - 1, onde n é a entrada ou 2 se a entrada estiver vazia. Imprime uma sequência de
9
s do comprimento necessário.2
pressione 2 para a pilha, caso a entrada esteja vazia?
enviar entrada para a pilhaA
pressione 10 para a pilha (dc tem atalhosA
-F
para 10 - 15)*
pop duas vezes e multiplique (multiplique a entrada por 10)A
empurre 10 para a pilhar
dois elementos da pilha superior reversa^
exponenciada 10 ^ (10 * entrada)1-
subtrair 1 do topo da pilhan
imprima sem nova linha.fonte
n
vez dep
.TI-Basic, 3 bytes
Imprime
100000
.fonte
0
por 1 byte.ᴇ3
? E @lirtosiast, já que o TI-Basic não tem novas linhas, sou cético quanto a isso.Brainfuck, 14 bytes
Este é um pequeno exercício matemático. Vamos denotar o número de
+
caracteres no código pora
e o número de.
caracteres porb
.O código gera
a*b
bytes, com valores dea
baixo a1
(estes são bytes não ASCII, mas parece OK de acordo com as especificações). O comprimento do código éa+b+3
. Então nós temosTentando valores diferentes para
a
eb
, vemos que o mínimo paraa+b+3
é alcançado parafonte
+[[>....]-<<+]
opção.gs2 , -18 bytes
CP437 :
W↕0!↨.2
Despejo hexagonal:
57 12 30 21 17 2e 32
W
lê números de STDIN em uma lista.↕0
anexa um 2 à lista e!
extrai o primeiro elemento. Então↨.
(a lista[0,1,2,3,4,5,6]
) é repetida (2
) várias vezes.Isso é muito semelhante à resposta CJam de Dennis - o gs2 apenas combina
r
ei
em um byte.Nota : Eu tive que corrigir um erro na
gs2
implementação para que isso funcionasse: anteriormente, cada programa tinha uma nova linha oculta anexada à sua saída, o que era totalmente involuntário. Ele só veio à tona depois que tentei resolver esse programa (o idioma foi desenvolvido para o golfe anárquico, que ignora novas linhas em todos os problemas), e eu só instalei uma correção para dominar agora, fique à vontade para responder a essa pergunta com um pouco de sal.fonte
Perl 5, 16 bytes - 25 = -9
Esta é uma abordagem ímpar para o problema.
Execute com o
-p
argumento da linha de comandos.Eu vi uma resposta Perl abaixo que usava uma variável especial para imprimir mais texto - e, assim, reduzir sua contagem de bytes. Então, eu usei uma variável especial muito mais detalhada. Imprime 8 caracteres com um nome de variável de 2 caracteres. Assim, com uma contagem de bytes de 16 (preenchida com um caractere de espaço em branco para torná-lo 16), ela imprime
2 * $]
, onde$]
a versão do Perl é impressa como5.xxxxxx
, dependendo da sua versão do Perl. Sem entrada, ele a imprime quatro vezes, igual8*4
ou32
, que é o dobro da contagem de bytes do código.Eu amo Perl.
fonte
pop
eshift
trabalhar@ARGV
(em umsub
trabalho@_
), para que você possa fazer algo como$n=pop||2
baixar o primeiro bloco de código e ter;}
no final , que quase sempre pode ser apenas}
para salvar outro. Algo que pode ajudá-lo a economizar mais caracteres é o operador de repetição de stringx
, considereprint 1x20
ou algo nesse sentido ... :) Espero que ajude!print"n"x(21*pop||42)
. Execute na linha de comando comperl -e'print"n"x(21*pop||42)' 3 | wc -c
Pitão ,
109-25 = -16-1 por Dennis
Imprime [entrada] * 9 caracteres de aspas ou 2 * 9 se a entrada estiver vazia.
isaacg tem uma resposta mais curta aqui
Pitão , 1 byte
Imprime
10
. É uma variável incorporada que inicializa em 10.fonte
Q
faz com que Pyth avalie a entrada antes que o código real seja executado.**N9.xvz2
funciona como esperado, mas não é mais curto que**N9?zvz2
.T
saídas10
e uma nova linha. Used
, é um espaço que recebe uma nova linha acrescentadaMacarrão 0.0.2 , 23 caracteres
Imprime 32 9 em binário, o que resulta convenientemente com 46 caracteres (é
1000000000000000000000000000000000000000000000
), sem uma nova linha à direita.fonte
JavaScript, 4 bytes
Eu acho que essa é a solução JS mais curta possível sem o ES6: P
fonte
v0.10.40
não imprime nada, porque não há comando de impressão. Você tem uma versão diferente do Node.js ou isso funciona apenas em um shell que imprime a avaliação de uma linha? (nesse caso, não acho que essa resposta seja válida).C,
2725• Obrigado @Titus por interromper 2 bytes
E para a minha solução não concorrente de 16 bytes em C, acesse aqui: https://codegolf.stackexchange.com/a/111330/16513
^ Eu digo não concorrente porque o código de erro pode depender do seu compilador. Observe também que estou usando o GCC nessa solução. Também não tenho certeza se ele infringe a regra 1 ou não, acho que provavelmente o fez.
fonte
main(){printf("%0.XXf",0);}
funciona.#include
. O compilador emitirá um aviso e, às vezes, trava, mas geralmente funciona .V , 2 bytes
Isso gera
Experimente online!
Explicação
Esta é uma resposta realmente hacky, e funciona abusando dos elementos internos do V. Essencialmente, como ele funciona
ÿ
é um comando em V que indica que o programa acabou, e todos os comandos pendentes devem ser concluídos. Caso contrário, alguns finais implícitos não funcionariam e a interpretação seria interrompida com mais frequência. Este comando é enviado automaticamente várias vezes no final do programa e, na maioria das vezes, não afeta a saída.é
é um comando que insere um único caractere. No entanto, ele faz isso pegando um byte bruto, para que não interpreteÿ
como "final", interpreta como "esse é o caractere que você precisa inserir".4é
faz com que ele insira esse caractere 4 vezes em vez de um.fonte
bash, 11 bytes
Aqui está um uso agradavelmente irônico de uma ferramenta de compactação de dados :) ...
gzip -f<<<2
Aqui está um dump hexadecimal da saída (22 bytes) ...
fonte
dc, 19 - 25 = -6
Pega um número (2 é enviado para a pilha como backup) e o multiplica por 19. Imprime a
1
(sem nova linha) e diminui o número. Loops enquanto o número for maior que 0.fonte
C ++, 80 bytes
observe que o caractere de nova linha possui dois caracteres. (se você não quiser, altere i <20 para i <= 19 para voltar à mesma contagem de bytes.)
Saída de amostra (sempre será alterada)
mesmo endereço de memória de 8 caracteres 20 vezes.
fonte
for
loop é mais curto que umwhile
loop e permite que você largue o aparelho, é um pouco mais barato de usarcstdio
e apenasprintf
uma corda, e você não precisa retornar nada.#include<iostream> int main(){for(int i=10;--i;)std::cout<<&i;}
Mas já existe uma resposta mais curta com uma abordagem ligeiramente diferente.CJam, -9
Explicação
q_,
Lê toda a entrada e a pressiona, depois pressiona o comprimento.
{i}{;2}?
Se o comprimento da entrada estiver acima de zero, converta-o em um número inteiro. Caso contrário, pop a entrada e pressione 2.
G*
Empurra 16 (o comprimento do programa) e depois multiplica por 2 se não houver entrada ou pela entrada.
'X*
Empurra X e multiplica pelo topo da pilha.
fonte
q2e|i
fornecerá o número desejador_{i}2?SB**
.> <> , 19 + 2 (sinalizador -v) - 25 = -4 bytes
teste aqui!
Obrigado Cole e Sp3000
Primeiro, verifique o comprimento da pilha, se for 0, coloque 2 na pilha. Multiplica por 21 (comprimento do código), emite a representação unicode desse número e a diminui em 1, faz um loop até 0. (você terá que inspecionar a saída para ver os caracteres, pois o navegador não os exibirá)
fonte
l0=?2f6+*v
como a primeira linha e1-::0=?;o>
a segunda devem corrigir.?!
normalmente é melhor que0=?
JavaScript (ES5), 68 bytes - 25 bônus = 43
(caso seu navegador não permita a execução do snippet por motivos de segurança, tente este violão http://jsfiddle.net/thePivottt/c3v20c9g/ )
Esse script funciona apenas em um navegador que segue pelo menos DOM3 (com
Node.textContent
) e ECMAScript 5 (ou talvez uma versão mais antiga). Eu tentei fazer é o mais padrão possível e compatível. Ele também pressupõe que o script esteja no primeiroscript
elemento do documento.Na verdade, concatena várias cópias do próprio script, o que é bastante impressionante . Observe que a ferramenta de snippet no SE coloca espaço em branco extra em torno do script. Poderíamos ignorar esse espaço em branco,
.trim()
mas não acho necessário, considerando que o programa é perfeito sem a intromissão da SE. Salve este arquivo HTML5 se quiser vê-lo funcionar perfeitamente.Esse script usa
prompt
ealert
porqueconsole.log
não faz parte de nenhum padrão, mesmo que a maioria dos navegadores modernos o utilize. Se o número de repetições passadas não for um número válido ou estiver vazio, o padrão será 2. Se a entrada for um número decimal, o programa trava devido ao comprimento inválido da matriz.O código usa alguns recursos interessantes do JavaScript:
Array(1+(+prompt()||2))
Array(INT)
cria uma matriz de células INT.+prompt()
pega uma entrada e a transforma em um número. Se passássemos a entrada como uma string, aArray
função simplesmente a envolveria em uma matriz de um elemento.+prompt()||2
Retorna a entrada se for truthy , senão ele retorna 2.Todo esse código cria uma matriz de N elementos vazios, em que N é mais um que a quantidade de repetições solicitadas.
.join(document.scripts[0].textContent)
O
join(STRING)
método da matriz cria uma string concatenando todas as células, colocando a STRING fornecida entre os valores. Neste programa, há N + 1 elementos vazios na matriz ou exatamente N pontos intermediários. O resultado será uma sequência contendo N vezes a STRING fornecida.document.scripts[o]
é o primeiro<script>
elemento do documento.As instâncias
textContent
ofNode
retornam o texto inteiro encontrado dentro deles e em seus nós filhos, incluindo scripts.fonte
str.repeat
e ainda gera o código em si, ele reduz a pontuação para 26, mas é um pouco chato: PJavaScript ES6, 33 - 25 = 8
Experimente online!
fonte
33
é, na verdade, o comprimento do código. Ele cria uma nova matriz com comprimento,33*a
ondea
é o parâmetro de entrada padrão 2, conforme o OP, preenche e retorna uma sequência de caracteres unida.Arrary(1+a*<length>)
ejoin`0`
Julia, 42 bytes - 25 = 17
Isso lê uma linha de STDIN usando
readline()
. Se estiver vazio, ou seja, nenhuma entrada foi fornecida, então n é definido como a entrada convertida em um número inteiro. Caso contrário, n é 2. Em seguida, imprimir 42 n@
s para STDOUT.fonte
Perl, 18-25 = -7
A variável especial
$=
, aka$FORMAT_LINES_PER_PAGE
, inicia sua vida útil60
e, portanto, só precisa ser duplicada pela metade do número de bytes necessário.fonte
print$=x9x(pop||2)
legal!