Contar para sempre


71

Escreva um programa que conta para sempre, começando em um.

Regras:

  • Seu programa deve efetuar logon STDOUTou uma alternativa aceitável, se STDOUTnão estiver disponível.
  • Seu programa deve ser um programa completo e executável, e não uma função ou trecho.
  • Seu programa deve gerar cada número com um caractere separador no meio (uma nova linha, espaço, tabulação ou vírgula), mas isso deve ser consistente para todos os números.
  • Você pode imprimir os números em decimal, em unário ou na base 256, onde cada dígito é representado por um valor de byte .
  • Seu programa deve contar pelo menos até 2 128 (inclusive) sem problemas e sem ficar sem memória em um PC de mesa razoável. Em particular, isso significa que, se você estiver usando unário, não poderá armazenar uma representação unária do número atual na memória.
  • Diferentemente de nossas regras usuais, fique à vontade para usar um idioma (ou versão do idioma), mesmo que seja mais novo que esse desafio. Os idiomas escritos especificamente para enviar uma resposta de 0 byte a esse desafio são um jogo justo, mas não particularmente interessante.

    Observe que deve haver um intérprete para que o envio possa ser testado. É permitido (e até encorajado) escrever esse intérprete para um idioma anteriormente não implementado.

  • Não se trata de encontrar o idioma com a solução mais curta para isso (existem algumas onde o programa vazio faz o truque) - trata-se de encontrar a solução mais curta em todos os idiomas. Portanto, nenhuma resposta será marcada como aceita.

Catálogo

O snippet de pilha na parte inferior desta postagem gera o catálogo a partir das respostas a) como uma lista da solução mais curta por idioma eb) como uma tabela geral de líderes.

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 Nestá 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:

## [><>](http://esolangs.org/wiki/Fish), 121 bytes


29
Não tenho certeza de como combinar deve imprimir cada número com um caractere de separação no meio com pode imprimir os números [...] na base 256 .
Dennis

6
Para desafios futuros, posso recomendar o sandbox para que todos esses detalhes possam ser resolvidos antes que as pessoas comecem a postar respostas? :)
Martin Ender

3
@IlmariKaronen Eu interpreto isso como sendo um limite de memória, não um limite de tempo. possivelmente um limite de tempo por incremento. basta definir o contador para 2 ** 128-10 e ver quanto tempo leva para dar os últimos dez passos.
21415 Sparr

5
Podemos ter zeros à esquerda na saída?
Paŭlo Ebermann 15/11/2015

4
Ugh !!! Tenho uma resposta para a TI-89 (56b), mas não consigo postar b / c. Sou novo no site e não tenho o Rep 10+!
gregsdennis

Respostas:


63

Labirinto , 5 bytes

):
\!

♫ O IP no código dá voltas e voltas ♫

Instruções relevantes:

)       Increment top of stack (stack has infinite zeroes at bottom)
:       Duplicate top of stack
!       Output top of stack
\       Output newline

77
O programa é triste porque não está parando ..
Optimizer

7
@Optimizer def sad (de fato):
YoYoYonnY

11
Por que isso não é de 4 bytes?
Aurel Bílý

2
@ Aurel300 O quinto byte é a nova linha entre :e\
Sp3000

@ Sp3000 Ah, sim. Eu tolo. :)
Aurel Bílý

46

> <> , 8 bytes

01+:nao!

Passos:

  • Empurre 0 na pilha
  • Adicione 1 ao elemento da pilha superior
  • Elemento duplicado da pilha superior
  • Saída da parte superior da pilha como número
  • Saída de uma nova linha
  • Vá para o passo 2, contornando e pulando a próxima instrução (passo 11)

(Um programa menos eficiente em termos de memória (portanto inválido) é llnao.)


66
+1 para os impacientes requerimentos implícitos no voto positivo em uma linha de código que basicamente lê "mais um, agora!".
Janus Bahs Jacquet

24

Haskell, 21 bytes

main=mapM_ print[1..]

Inteiros de precisão arbitrária e listas infinitas facilitam isso :-)

Felizmente mapM_está no Prelúdio. Se Data.Traversablefosse assim, poderíamos reduzi-lo para 19 bytes:

main=for_[1..]print

Não existe um símbolo que generalize map / mapM etc?
JDługosz

@ JDługosz: não que eu saiba
Bergi

Ah, porque ainda teria que ter sequenceo resultado para que a saída realmente acontecesse.
JDługosz

simplesmente não é [1..]permitido, pois imprime todos os números com uma vírgula entre? ou o primeiro [estragar tudo?
Baconaro

@Brasil: é uma lista, não imprime nada. O GHCi imprime o resultado se você digitar o termo no repl, mas esse não é um programa executável. E sim, a liderança [também não é permitida.
Bergi

23

Gol> <> , 3 bytes

P:N

Passos:

  • Adicione 1 ao elemento da pilha superior (no início, é um 0 implícito)
  • Elemento duplicado da pilha superior
  • Pop e produza a parte superior da pilha como número e uma nova linha
  • Enrole para a etapa 1 quando chegamos ao final da linha

21

Marbelous , 11450 4632 bytes

Imprimir decimais é uma dor !!

Definitivamente não ganhei com este, mas pensei em tentar. Espero que seja bom que a saída seja de 40 zeros (para caber 2 ^ 128).

00@0..@1..@2..@3..@4..@5..@6..@7..@8..@9..@A..@B..@C..@D..@E..@F..@G..@H..@I..@J
\\++..00..00..00..00..00..00..00..00..00..00..00..00..00..00..00..00..00..00..00
..EhunEhunEhunEhunEhunEhunEhunEhunEhunEhunEhunEhunEhunEhunEhunEhunEhunEhunEhunEhun
....AddtAddtAddtAddtAddtAddtAddtAddtAddtAddtAddtAddtAddtAddtAddtAddtAddtAddtAddt
..&7..&7..&7..&7..&7..&7..&7..&7..&7..&7..&7..&7..&7..&7..&7..&7..&7..&7..&7..&7\/
../\&8..........................................................................
....@0..........................................................................
....../\&8......................................................................
....//..@1......................................................................
........../\&8..................................................................
......////..@2..................................................................
............../\&8..............................................................
........//////..@3..............................................................
................../\&8..........................................................
..........////////..@4..........................................................
....................../\&8......................................................
............//////////..@5......................................................
........................../\&8..................................................
..............////////////..@6..................................................
............................../\&8..............................................
................//////////////..@7..............................................
................................../\&8..........................................
..................////////////////..@8..........................................
....................................../\&8......................................
....................//////////////////..@9......................................
........................................../\&8..................................
......................////////////////////..@A..................................
............................................../\&8..............................
........................//////////////////////..@B..............................
................................................../\&8..........................
..........................////////////////////////..@C..........................
....................................................../\&8......................
............................//////////////////////////..@D......................
........................................................../\&8..................
..............................////////////////////////////..@E..................
............................................................../\&8..............
................................//////////////////////////////..@F..............
................................................................../\&8..........
..................................////////////////////////////////..@G..........
....................................................................../\&8......
....................................//////////////////////////////////..@H......
........................................................................../\&8..
......................................////////////////////////////////////..@I..
............................................................................../\&8
........................................//////////////////////////////////////..@J
&9&9&9&9&9&9&9&9&9&9&9&9&9&9&9&9&9&9&9&9
Sixteenbytedecimalprintermodulewitharegi

:Sixteenbytedecimalprintermodulewitharegi
}J}J}I}I}H}H}G}G}F}F}E}E}D}D}C}C}B}B}A}A}9}9}8}8}7}7}6}6}5}5}4}4}3}3}2}2}1}1}0}00A
/A%A/A%A/A%A/A%A/A%A/A%A/A%A/A%A/A%A/A%A/A%A/A%A/A%A/A%A/A%A/A%A/A%A/A%A/A%A/A%A
%A..%A..%A..%A..%A..%A..%A..%A..%A..%A..%A..%A..%A..%A..%A..%A..%A..%A..%A..%A..
+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O..
+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O..

:/A
..}0..}0..
..>>}0....
..>>>>\\..
....//..//
../\>>\\..
....>>..//
....>>\\..
....>>....
\\>>//....
..>>......
..>>......
../\......
..../\<<..
......<<..
..\\<<//..
....~~....
....++....
....\\..//
\\....>9\/
..\\..?0..
......++..
....\\....
......{0..

:%A
@0..
}0..
<A-A
{0@0

:Eg
}0}0}0}0}0}0}0}0
^7^6^5^4^3^2^1^0
~~....~~~~..~~~~
^0^0^0^0^0^0^0^0
{0{0{0{0{0{0{0{0

:Ehun
}0..}0
Eg..&0
=8&0{0
&1\/00
0100&0
&1&1{1
{1{0

:Addt
}0}1
{1{1

O binário de impressão seria mais curto?
SuperJedi224

3
(ou o unário?)
Maçaneta da porta

@Doorknob exibindo a saída não é o problema. É algo sobre o Ehunconselho que é suposto para incrementar o dígito seguinte, mas não funciona correctamente
TheDoctor

11
Você sabia que pode deixar de fora os períodos no final de cada linha e linhas em branco entre os painéis e usar caracteres únicos para os nomes dos painéis? Você apenas precisa repetir esse caractere a quantidade adequada de tempo para chamá-lo. Isso pode reduzir sua resposta a cerca de 3000 bytes.
overactor

Eventualmente, vou enviar um commit ao marbelous.py que inclui tudo include/por padrão
Sparr

18

C (somente arquitetura de 64 bits), 53 bytes

Confia que os ponteiros têm pelo menos 64 bits e os imprime em hexadecimal usando o %pespecificador. O programa retornaria exatamente quando atingir 2 ^ 128.

char*a,*b;main(){for(;++b||++a;)printf("%p%p ",a,b);}

11
Portanto, se esses ponteiros estiverem em cada 64 bits, você poderá contar apenas com 2 ^ 128-1, certo?
flawr

6
Inválida, uma vez que não pode contar até 2 ^ 128
edc65

14
Eu gosto do CodeGolf quando se trata de expressar e recompensar a criatividade. O feersum claramente não está competindo pela vitória aqui. Ver muitos votos negativos sobre o tecnicismo e modificar a redação da pergunta para garantir que sua resposta esteja violando me deixa triste.
flodel

3
Eu pensei que as palavras "pelo menos tanto quanto 2 ^ 128" eram claras o suficiente ...
vrwim

5
@vrwim Você não escreveu isso. Você escreveu "até 2 ^ 128". SuperJedi o editou alguns minutos atrás.
feersum

17

Hexagonia , 12 11 10 7 bytes

Agradecimentos a alephalpha por ajustar o código no comprimento lateral 2.

10})!';

Desdobrado:

 1 0
} ) !
 ' ;

Este é bastante simples. 10grava um 10, ou seja, um avanço de linha na borda da memória inicial. Então })!';é executado repetidamente em um loop:

  • } vá para a próxima borda da memória.
  • ) incrementá-lo.
  • ! imprima-o como um número inteiro.
  • ' volte para o 10.
  • ; imprima-o como um personagem.

Eu acredito que isso é ótimo (embora de longe não seja único). Eu deixei o script força bruta que eu escrevi para esta resposta busca de soluções 6 bytes sob a suposição de que ele teria que conter pelo menos um cada um ;e !e quer (ou ), e não deverá conter ?, ,ou @, e isso não aconteceu encontre soluções.


13

Pitão, 4 bytes

.V1b

Explicação:

.V1    for b in range(1 to infinity):
   b      print b

f!\n( Link TIO ) funcionará por 3 bytes, embora não tenha certeza se está usando algum recurso que foi adicionado após a sua resposta.
Sok

@Sok Clever. No entanto, não vou mudar a resposta, porque acho que essa fera uma característica do Pyth há quatro anos.
Jakube 12/07

Eu também pensava assim, e foi por isso que o deixei como comentário - os novos recursos de linguagem para superar uma resposta mais antiga sempre parecem baratos IMO
Sok

13

bc, 10

for(;;)++i

Incomum que bcé mais curto que dc.

De man bc:

DESCRIÇÃO

bc é uma linguagem que suporta números de precisão arbitrários


Onde isso é impresso?
Bálint

@ Bálint ++ié uma expressão, mas não uma atribuição, e é, portanto, explicitamente produzido. Você tentou executá-lo? echo 'for(;;)++i' | bcno seu terminal Linux mais próximo.
Digital Trauma

Não tenho um único terminal Linux em minha casa. Eu só estava curioso.
Bálint

6
@ Bálint Toda casa deve ter um terminal Linux.
Digital Trauma

11
@ Bálint A execução deste programa é seu uso;)
Insano

12

Java, 139 138 127 123 bytes

class K{public static void main(String[]a){java.math.BigInteger b=null;for(b=b.ZERO;;)System.out.println(b=b.add(b.ONE));}}

2
Um loop infinito menor em java é for(;;)de 3 bytes fáceis.
Ankh-morpork 14/11/2015

Você também pode salvar outros 2 com BigInteger b=null;b=b.ZERO;, infelizmente, o =nullnecessário, mesmo que seja um acesso estático.
TWIStErRob 14/11

E depois outro 9, porque você pode se livrar da importação referenciando BigIntegerpelo FQCN apenas uma vez.
TWIStErRob 14/11

@TWiStErRob De alguma forma, eu não tinha percebido que seria mais curto.
SuperJedi224

2
Para Java 8 ou mais recente, você pode substituir a classe interfacee remover publicda função. Não queira copiar seu código e publicá-lo como uma nova resposta.
Luca H #

10

Mathematica, 22 bytes

i=0;While[Echo[++i]>0]

Echo é uma nova função no Mathematica 10.3.


Echofornece quatro caracteres de separação: nova linha mais ">> ". Não tem certeza se isso é válido - talvez você use Print? Além disso, salve um byte com i=0;While[Echo@++i>0].
Roman

7

Ruby, 15 12 bytes

loop{p$.+=1}
  • p, quando determinado um número inteiro, imprime o número inteiro como está (cortesia de @philomory )
  • $.é uma variável mágica que contém o número de linhas lidas em stdin. Obviamente, é inicializado como 0 e também pode ser atribuído :)

@ philomory Normalmente, é sugerido que os usuários deixem um comentário sugerindo sua solução de economia de bytes. Além disso, eu gostaria de ver uma explicação para este. c:
Addison Crump

7

Python 3, 33 25 bytes

Tanto quanto eu entendo, inteiros Pythons são precisão arbitrária e print()produz automaticamente novas linhas.

Obrigado por @Jakub e @ Sp3000 e @wnnmaw! Eu realmente não sei muito python, a única coisa que eu sabia era que ele suporta números inteiros de tamanho arbitrário =)

k=1
while 1:print(k);k+=1

1é um valor verdadeiro em Python (e na maioria das outras linguagens). Então while 1:é o suficiente.
Jakube

Além disso, você pode colocar o todo whileem uma linha
Sp3000 14/11

Você pode salvar um byte usando em repr(k)vez de print(k). Além disso, eu conto o seu tamanho em bytes como 25 (sem a minha alteração sugerida)
wnnmaw

11
Você não pode usar em reprvez de print. reprnão produz nada. @wnnmaw
Zach Gates

O que reprfaz então?
flawr

6

Processando , 95 85 71 bytes

java.math.BigInteger i;{i=i.ZERO;}void draw(){println(i=i.add(i.ONE));}

Tentei algo com um loop while, mas ele causou uma falha em todo o Processing, por isso vou continuar com isso por enquanto.

(Obrigado a @ SuperJedi224 e @TWiStErRob por sugestões.)


O que há com os espaços? Tenho certeza que import java.math.*;BigInteger i=BigInteger.ZERO;void draw(){println(i=i.add(BigInteger.ONE));}vai funcionar.
SuperJedi224

Sim, apenas consertei isso.
geokavel

O processamento permite BigInteger.ONEque seja alterado para i.ONE?
SuperJedi224

@ SuperJedi224 Sim, faz. Obrigado!
geokavel

Tudo bem, tenha um voto positivo.
SuperJedi224

6

Samau , 2 bytes

N)

Explicação:

N     push the infinite list [0 1 2 ...] onto the stack
 )    increase by 1

Quando a saída de um programa é uma lista, os colchetes extremos são omitidos.


Uma lista não imprime todo o seu conteúdo de uma só vez? Se essa lista for infinita , ela não poderá caber na memória ou na tela e nunca deixará de ser gerada; portanto, nunca será impressa.
cat

11
@cat Samau está escrito em Haskell, e é preguiçoso . Não gerará a lista inteira antes de imprimi-la.
alephalpha

Apenas um aviso. Na página GitHub para Samau, na descrição de @, "push" está incorreto.
Carcigenicate

@Carcigenicate Obrigado.
Alephalpha #

6

JavaScript (ES6), 99 94 67 bytes

for(n=[i=0];;)(n[i]=-~n[i++]%10)&&alert([...n].reverse(i=0).join``)

alerté o STDOUTequivalente geralmente aceito para JavaScript, mas usá-lo significa que números consecutivos são separados automaticamente. Eu assumi que a saída de um caractere após o número não é necessária por causa disso.


12
É por isso que tenho um bloqueador de pop-ups.
Comintern

11
apenas dizendo: for (i = 0 ;;) alert (i ++) Eu não acho que você precisa de todos esses controles
towc

3
@towc Isso não vai funcionar. Todos os números são flutuantes de 64 bits no JavaScript, que possuem um valor inteiro máximo seguro, 2^53mas a pergunta exige que ele seja feito 2^128.
user81655

11
oh, ponto justo ...
towc

5

Matlab, 132 bytes

a=0;while 1;b=a==9;n=find(cumsum(b)-(1:numel(b)),1);a(n)=a(n)+1;a(1:n-1)=0;if ~numel(n);a=[0*a,1];end;disp([a(end:-1:1)+'0','']);end

Ok, acho que esta é a primeira resposta séria que realiza essa tarefa sem um número inteiro de tamanho abitrário interno trivial. Este programa implementa um número inteiro de tamanho arbitrário como uma matriz de números inteiros. Cada número inteiro está sempre entre 0 e 9, portanto, cada elemento da matriz representa um dígito decimal. O tamanho da matriz será aumentado em um assim que estivermos, por exemplo 999. O tamanho da memória não é um problema aqui, pois 2^128requer apenas uma matriz de comprimento 39.

a=0;
while 1
    b=a==9;
    %first number that is not maxed out
    n=find(cumsum(b)-(1:numel(b)),1);
    %increase that number, and sett all maxed out numbers to zero
    a(n)=a(n)+1; 
    a(1:n-1)=0;
    if ~numel(n) %if we maxed out all entries, add another digit
        a=[0*a,1];
    end    
    disp([a(end:-1:1)+'0',''])%print all digits
end

5

C ++, 146 141 138 bytes

Usar uma biblioteca bigint padrão talvez seja a maneira mais chata de responder a essa pergunta, mas alguém precisava fazer isso.

#include<stdio.h>
#include<boost/multiprecision/cpp_int.hpp>
int main(){for(boost::multiprecision::uint512_t i=1;;){printf("%u\n",i++);}}

Ungolfed:

#include<cstdio>
#include<boost/multiprecision/cpp_int.hpp>

int main()
{
    for(boost::multiprecision::uint512_t i=1;;)
    {
        std::printf("%u\n", i++);
    }
}

O motivo pelo qual a versão golfada usa stdio.he não cstdioé evitar o uso do std::espaço para nome.

Esta é minha primeira vez jogando golfe em C ++, deixe-me saber se há algum truque para diminuir ainda mais isso.


Talvez você possa usar em '\n'vez de std::endl, economizaria 8 bytes. Também pode haver uma maneira de usar CPP #define para comprimir alguma repetição,
Kenney

@ Kenney Obrigado por isso! (Ele economiza apenas 5 bytes, e não 8). Eu acho que posso ter uma maneira de ajustar essa seção ainda mais curta.
Felixphew # 1

Eu não sei impulsionar (e eu não diria que é padrão), mas não é iconstruído com o valor de 0? Você poderia, então, retirar definição e interruptor de pós-incremento para preincremet que permitiria poupar 2b
Zereges

E quanto aos preteridos #import?
connectyourcharger

5

C # .NET 4.0, 111 103 102 97 bytes

class C{static void Main(){System.Numerics.BigInteger b=1;for(;;)System.Console.WriteLine(b++);}}

Não encontrei nenhuma resposta em C # aqui, então apenas tive que escrever uma.

O .NET 4.0 é necessário, porque é a primeira versão que inclui o BigInteger . Você precisa fazer referência ao System.Numerics.dll .

Com recuo:

class C
{
    static void Main()
    {   
        System.Numerics.BigInteger b = 1;
        for (;;)
            System.Console.WriteLine(b++);
    }
}

Obrigado a sweerpotato, Kvam, Berend por salvar alguns bytes


Você pode salvar 8 bytes com class C{static void Main(){var b=System.Numerics.BigInteger.One;for(;;)System.Console.WriteLine(b++);}}: ~)!
Sweerpotato

11
Mova a declaração de be Console.WriteLinepara a estrutura do loop:class C{static void Main(){for(var b=System.Numerics.BigInteger.One;;Console.WriteLine(b++));}}
Kvam 15/11

Você ainda precisa System. Isso economiza um byte!
sweerpotato

Sim você está certo.
Kvam

Se você adicionar using System;(13 bytes), poderá eliminar os System.(7 bytes) duas vezes, economizando 1 byte.
Kenney

5

Clojure, 17 bytes

(map prn (range))

Sequências preguiçosas e números inteiros de precisão arbitrários facilitam isso (como Haskell e CL). prneconomiza alguns bytes, pois não preciso imprimir uma string de formato. doseqprovavelmente seria mais idiomático, já que aqui estamos lidando apenas com efeitos colaterais; mapnão faz muito sentido usar, pois criará uma sequência de nil(que é o valor de retorno de cada prnchamada.

Supondo que eu conte para sempre, a sequência de ponteiros nulos resultante dessa operação nunca será retornada.



4

CJam, 7 bytes

0{)_p}h

Explicação:

0         e# Push a zero to the stack
 {        e# Start a block
  )         e# Increment top of stack
   _        e# Duplicate top of stack
    p       e# Print top of stack
     }    e# End block
      h   e# Do-while loop that leaves the condition on the stack

Nota: É necessário usar o interpretador Java.


4

C, 89 bytes

Uma nova abordagem (implementando um incrementador bit a bit) em C:

b[999],c,i;main(){for(;;)for(i=c=0,puts(b);i++<998;)putchar(48+(c?b[i]:(b[i]=c=!b[i])));}

Menos golfe

int b[999], c, i;
main() {
  for(;;)
    for(i=c=0, puts(b); i++ < 998;)
      putchar(48 + (c ? b[i] : (b[i] = c = !b[i])));
}

Terminar

Esta versão tem uma pequena falha, que não termina (o que não é um requisito no momento). Para fazer isso, você teria que adicionar 3 caracteres:

b[129],c=1,i;main(){for(;c;)for(i=c=0,puts(b);i++<128;)putchar(48+(c?b[i]:(b[i]=c=!b[i])));}

4
De fato, não deve terminar. Esse é o significado deforever
edc65 14/11

4

Foo , 6 bytes

(+1$i)

Explicação

(    )    Loop
 +1       Add one to current element
   $i     Output current element as a decimal integer

4

Minkolang , 4 bytes

1+dN

Experimente aqui. (Bem, na verdade, tenha cuidado. 3 segundos de tempo de execução foram suficientes para chegar a ~ 40.000.)

1+adiciona 1 ao topo da pilha, dduplica-o e Ngera o topo da pilha como um número inteiro com um espaço à direita. Isso faz um loop porque Minkolang é toroidal; portanto, quando o contador de programa sai pela borda direita, ele reaparece à esquerda.


4

Conjunto Intel 8086+, 19 bytes

68 00 b8 1f b9 08 00 31 ff f9 83 15 00 47 47 e2 f9 eb f1

Aqui está um detalhamento:

68 00 b8                push   0xb800             # CGA video memory
1f                      pop    ds                 # data segment
b9 08 00           L1:  mov    cx, 8              # loop count
31 ff                   xor    di, di             # ds:di = address of number
f9                      stc                       # set carry
83 15 00           L2:  adc    word ptr [di], 0   # add with carry
47                      inc    di
47                      inc    di
e2 f9                   loop   L2
eb f1                   jmp    L1

Ele gera o número de 128 bits nas 8 posições da tela superior esquerda. Cada posição da tela contém um caractere ASCII de 8 bits e duas cores de 4 bits.

Nota: gira em torno de 2 128 ; simplesmente mudar o 8em mov cx, 8para 9mostrar um número 144 bit, ou mesmo 80*25para mostrar números até 2 32000 .

Corrida

1.44Mb bzip2 comprimido, disquete inicializável codificado em base64

Gere a imagem de disquete copiando e colando o seguinte

QlpoOTFBWSZTWX9j1uwALTNvecBAAgCgAACAAgAAQAgAQAAAEABgEEggKKAAVDKGgAaZBFSMJgQa
fPsBBBFMciogikZcWgKIIprHJDS9ZFh2kUZ3QgggEEh/i7kinChIP7HrdgA=

nesta linha de comando:

base64 -d | bunzip2 > floppy.img

e corra com, por exemplo, qemu -fda floppy.img -boot a

ISO inicializável de 1,8 Mb

Esta é uma imagem ISO compactada bzip2 codificada em base64. Gere o iso colando

QlpoOTFBWSZTWZxLYpUAAMN/2//fp/3WY/+oP//f4LvnjARo5AAQAGkAEBBKoijAApcDbNgWGgqa
mmyQPU0HqGCZDQB6mQ0wTQ0ZADQaAMmTaQBqekyEEwQaFA0AA0AxBoAAA9Q0GgNAGg40NDQ0A0Bi
BoDIAANNAA0AyAAABhFJNIJiPSmnpMQDJpp6nqeo0ZDQaAANB6IA0NAGj1EfIBbtMewRV0acjr8u
b8yz7cCM6gUUEbDKcCdYh4IIu9C6EIBehb8FVUgEtMIAuvACCiO7l2C0KFaFVABcpglEDCLmQqCA
LTCAQ5EgnwJLyfntUzNzcooggr6EnTje1SsFYLFNW/k+2BFABdH4c4vMy1et4ZjYii1FbDgpCcGl
mhZtl6zX+ky2GDOu3anJB0YtOv04YISUQ0JshGzAZ/3kORdb6BkTDZiYdBAoztZA1N3W0LJhITAI
2kSalUBQh60i3flrmBh7xv4TCMEHTIOM8lIurifMNJ2aXr0QUuLDvv6b9HkTQbKYVSohRPsTOGHi
isDdB+cODOsdh31Vy4bZL6mnTAVvQyMO08VoYYcRDC4nUaGGT7rpZy+J6ZxRb1b4lfdhtDmNwuzl
E3bZGU3JTdLNz1uEiRjud6oZ5kAwqwhYDok9xaVgf0m5jV4mmGcEagviVntDZOKGJeLjyY4ounyN
CWXXWpBPcwSfNOKm8yid4CuocONE1mNqbd1NtFQ9z9YLg2cSsGQV5G3EhhMXKLVC2c9qlqwLRlw4
8pp2QkMAMIhSZaSMS4hGb8Bgyrf4LMM5Su9ZnKoqELyQTaMAlqyQ3lzY7i6kjaGsHyAndc4iKVym
SEMxZGG8xOOOBmtNNiLOFECKHzEU2hJF7GERK8QuCekBUBdCCVx4SDO0x/vxSNk8gKrZg/o7UQ33
Fg0ad37mh/buZAbhiCIAeeDwUYjrZGV0GECBAr4QVYaP0PxP1TQZJjwT/EynlkfyKI6MWK/Gxf3H
V2MdlUQAWgx9z/i7kinChITiWxSo

para dentro

base64 -d bunzip2 > cdrom.iso

e configure uma máquina virtual para inicializá-la.

DOS .COM

Este é um executável .COM do DOS codificado em base64 :

aAC4H7kIADH/+YMVAEdH4vnr8Q==

Gere um arquivo .COM usando

/bin/echo -n aAC4H7kIADH/+YMVAEdH4vnr8Q== | base64 -d > COUNTUP.COM

e execute-o no DOS (gratuito).


4

Perl , 34 32 30 28 26 23 bytes

-Mbigint -E '{say$_+=1;redo}'

Teste com

perl -Mbigint -E '{say$_+=1;redo}'

Você pode substituir for(,,){...}com {...;redo}para dois.
primo

Sim, eu vi (perl 5.18+), mas pensei que poderia estar trapaceando; então as respostas seriam as mesmas. Eu sou novo aqui, então ;-)
Kenney

11
As referências escalares serão vivificadas automaticamente como SV UNDEF, as quais, quando incrementadas, não acionarão a BigIntsobrecarga - porque não é uma BigInt. Literais inteiros, no entanto, são criados como BigInts. Não é tão estranho realmente;)
primo

11
Você poderia usar $-para mantê-lo como um número inteiro e retornar ao uso ++$-?
Dom Hastings

11
Testei com @DomHastings perl -Mbigint -E '{say++$-;$-+=$-;redo}' | moree ele chega a 1. Ele permanece int mas bigint não entra, infelizmente.
Kenney

4

Marbelous, 358 bytes

..@F..@E..@D..@C..@B..@A..@9..@8..@7..@6..@5..@4..@3..@2..@1..@001@Z01
..AddoAddoAddoAddoAddoAddoAddoAddoAddoAddoAddoAddoAddoAddoAddoAddo/\&I
00&I00&I00&I00&I00&I00&I00&I00&I00&I00&I00&I00&I00&I00&I00&I00&I....@Z
@FHd@EHd@DHd@CHd@BHd@AHd@9Hd@8Hd@7Hd@6Hd@5Hd@4Hd@3Hd@2Hd@1Hd@0Hd
0A@N
..&I
@N/\..
:Hd
}0
Hp
}0
..
{<
#include hex_out.mbl
#include arithmetic.mbl

16 semi-adutores encadeados, o mais à direita executando N ++ a cada ciclo e cada adicionador alimentando seu excesso (00 ou 01) para o próximo na cadeia. A saída está em hexadecimal.

O interpretador python possui um erro no qual a saída das funções memorizadas é perdida; portanto, você deve executá-lo com "-m 0" para que funcione corretamente. Sem esse parâmetro, você pode ver o quão rápido ele será executado sem o bug, mas a saída não funcionará corretamente.

Nota para self: corrija esse bug no marbelous.py Este bug foi corrigido na versão mais recente do marbelous.py


4

R, 52 bytes

a=gmp::as.bigz(1);repeat{cat(paste(a,""));a=a+1}

(Nota: gmpé uma biblioteca externa, pode ser necessário fazer o download para que esta solução funcione)


11
+1 ... desculpe por todos os extras. Para conseguir um par de volta, você poderia tentar a=gmp::as.bigz(0);repeat{cat(paste(a<-a+1,''))}. Você pode fazer uma anotação que gmpé uma biblioteca externa que pode precisar de download.
MickyT


4

BotEngine, 128 120 112 8x13 = 104

v2 2 01
>e>S SS
   e1e1
   e2 e0 12
   > > S SS P
  ^   <e0e1 R
     ^ < <lC^
^         <

A saída está em binário.

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.