Sua tarefa é criar o loop infinito mais curto!

O objetivo desse desafio é criar um loop infinito que não produza saída, diferentemente de sua possível duplicata. O motivo disso é que o código pode ser mais curto se nenhuma saída for fornecida.

Regras

• Cada envio deve ser um programa completo.
• Você deve criar o loop infinito mais curto.
• Mesmo que o seu programa fique sem memória eventualmente, ele ainda será aceito desde que esteja em execução o tempo todo, desde o início até quando ficar sem memória. Além disso, quando ficar sem memória, ele ainda não deve imprimir nada no STDERR.
• O programa não deve receber nenhuma entrada (no entanto, a leitura de um arquivo é permitida) e não deve imprimir nada em STDOUT. A saída para um arquivo também é proibida.
• O programa não deve gravar nada no STDERR.
• Sinta-se livre para usar um idioma (ou versão do idioma), mesmo que seja mais novo que esse desafio. -Note que deve haver um intérprete para que a submissão possa ser testada. É permitido (e até encorajado) escrever esse intérprete para um idioma anteriormente não implementado. : D
• As submissões são pontuadas em bytes, em uma codificação apropriada (pré-existente), geralmente (mas não necessariamente) em UTF-8. Alguns idiomas, como o Folders, são um pouco difíceis de pontuar - em caso de dúvida, pergunte no Meta.
• Não se trata de encontrar o idioma com o menor programa de loop infinito. Trata-se de encontrar o programa de loop infinito mais curto em todos os idiomas. Portanto, não aceitarei uma resposta.
• Se o seu idioma de escolha for uma variante trivial de outro idioma (potencialmente mais popular) que já tenha uma resposta (pense em dialetos BASIC ou SQL, shell do Unix ou derivados triviais do Brainf ** como Alphuck), considere adicionar uma nota à existente responda que a mesma solução ou uma solução muito semelhante também é a mais curta no outro idioma.
  
• Deve haver um site como Wikipedia, Esolangs ou GitHub para o idioma. Por exemplo, se o idioma for CJam, é possível vincular ao site no cabeçalho como #[CJam](http://sourceforge.net/p/cjam/wiki/Home/), X bytes.
• As brechas padrão não são permitidas.

(Eu peguei algumas dessas regras do desafio "Hello World" de Martin Büttner)

Por favor, sinta-se livre para postar nos comentários para me dizer como esse desafio pode ser melhorado.

Catálogo

Este é um snippet de pilha que gera um catálogo alfabético dos idiomas usados ​​e um cabeçalho geral. Para garantir que sua resposta seja exibida, inicie-a com este cabeçalho de remarcação:

# Language name, X bytes

Obviamente, substituindo Language namee X bytescom os itens adequados. Se você deseja criar um link para o site dos idiomas, use este modelo, conforme publicado acima:

#[Language name](http://link.to/the/language), X bytes

Agora, finalmente, aqui está o trecho: (Tente pressionar "Página inteira" para ter uma visão melhor.)

var QUESTION_ID=59347;var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe";var COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk";var OVERRIDE_USER=41805;var answers=[],answers_hash,answer_ids,answer_page=1,more_answers=true,comment_page;function answersUrl(index){return"//api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+index+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(index,answers){return"//api.stackexchange.com/2.2/answers/"+answers.join(';')+"/comments?page="+index+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:true,success:function(data){answers.push.apply(answers,data.items);answers_hash=[];answer_ids=[];data.items.forEach(function(a){a.comments=[];var id=+a.share_link.match(/\d+/);answer_ids.push(id);answers_hash[id]=a});if(!data.has_more)more_answers=false;comment_page=1;getComments()}})}function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:true,success:function(data){data.items.forEach(function(c){if(c.owner.user_id===OVERRIDE_USER)answers_hash[c.post_id].comments.push(c)});if(data.has_more)getComments();else if(more_answers)getAnswers();else process()}})}getAnswers();var SCORE_REG=/<h\d>\s*([^\n,<]*(?:<(?:[^\n>]*>[^\n<]*<\/[^\n>]*>)[^\n,<]*)*),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/;var OVERRIDE_REG=/^Override\s*header:\s*/i;function getAuthorName(a){return a.owner.display_name}function process(){var valid=[];answers.forEach(function(a){var body=a.body;a.comments.forEach(function(c){if(OVERRIDE_REG.test(c.body))body='<h1>'+c.body.replace(OVERRIDE_REG,'')+'</h1>'});var match=body.match(SCORE_REG);if(match)valid.push({user:getAuthorName(a),size:+match[2],language:match[1],link:a.share_link,});else console.log(body)});valid.sort(function(a,b){var aB=a.size,bB=b.size;return aB-bB});var languages={};var place=1;var lastSize=null;var lastPlace=1;valid.forEach(function(a){if(a.size!=lastSize)lastPlace=place;lastSize=a.size;++place;var answer=jQuery("#answer-template").html();answer=answer.replace("{{PLACE}}",lastPlace+".").replace("{{NAME}}",a.user).replace("{{LANGUAGE}}",a.language).replace("{{SIZE}}",a.size).replace("{{LINK}}",a.link);answer=jQuery(answer);jQuery("#answers").append(answer);var lang=a.language;lang=jQuery('<a>'+lang+'</a>').text();languages[lang]=languages[lang]||{lang:a.language,lang_raw:lang,user:a.user,size:a.size,link:a.link}});var langs=[];for(var lang in languages)if(languages.hasOwnProperty(lang))langs.push(languages[lang]);langs.sort(function(a,b){if(a.lang_raw.toLowerCase()>b.lang_raw.toLowerCase())return 1;if(a.lang_raw.toLowerCase()<b.lang_raw.toLowerCase())return-1;return 0});for(var i=0;i<langs.length;++i){var language=jQuery("#language-template").html();var lang=langs[i];language=language.replace("{{LANGUAGE}}",lang.lang).replace("{{NAME}}",lang.user).replace("{{SIZE}}",lang.size).replace("{{LINK}}",lang.link);language=jQuery(language);jQuery("#languages").append(language)}}

body{text-align:left!important}#answer-list{padding:10px;width:500px;float:left}#language-list{padding:10px;padding-right:40px;width:500px;float:left}table thead{font-weight:700}table td{padding:5px}

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script> <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"> <div id="language-list"> <h2>Shortest Solution by Language</h2> <table class="language-list"> <thead> <tr><td>Language</td><td>User</td><td>Score</td></tr> </thead> <tbody id="languages"> </tbody> </table> </div> <div id="answer-list"> <h2>Leaderboard</h2> <table class="answer-list"> <thead> <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr> </thead> <tbody id="answers"> </tbody> </table> </div> <table style="display: none"> <tbody id="answer-template"> <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr> </tbody> </table> <table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr> </tbody> </table>

Befunge , 0 bytes

Sim. Existe um programa Befunge em um campo de jogo bidimensional com tamanho fixo que envolve as bordas. Com nada nesse espaço para interferir, o contador do programa é executado em um loop infinito por padrão :)

L00P , 0 bytes

Esse lang foi feito para loop, e é exatamente o que ele fará ...

Código da máquina C64 , 2 bytes

D0 FE

Ramifica para si mesmo se o sinalizador zero não estiver definido.

Ramificações são deslocamentos de byte único a partir do próximo local da instrução e 254 é -2 no complemento de dois ... a instrução BNE (D0) ocupa um byte de memória e o deslocamento ocupa um segundo byte, ramificando dois bytes para trás para trás para si mesmo. O sinalizador zero é sempre limpo quando o código é carregado na memória.

Observe que essa não é uma chamada de sub-rotina recursiva; portanto, você nunca ficará sem memória. Observe também que não há sobrecarga de cabeçalho, compilador ou executável ... é realmente um programa de dois bytes :)

Brainfuck, 3 bytes

+[]

Nunca diminua: nunca termine.

/// , 3 bytes

///

Algum ponto de bônus por usar o nome do idioma como código-fonte?

Java , 53 bytes

class A{public static void main(String[]a){for(;;);}}

Yay requisito de programa completo!

Prolog, 5 bytes

a:-a.

Para saber se o predicado aé verdadeiro, você só precisa verificar se o predicado aé verdadeiro.

_{Você precisa carregar o arquivo e executar a, ambos com argumentos de linha de comando. Observe que a recursão provavelmente será otimizada como um loop infinito e não deve explodir a pilha.}

Além disso, isso parece um smiley, mas não sei como chamá-lo. O ponto parece saliva, então talvez "estado vegetativo" ou "programador infiurado com cabelos encaracolados". Sugestões são bem vindas.

Haskell , 9 bytes

Recursão infinita da função principal. Deve ser compilado em um loop devido à otimização da recursão da cauda.

main=main

Python, 9 bytes

Funciona em 2 e 3.

while 1:0

Encurtado por @FryAmTheEggman

x86 ELF executável, 45 bytes

Ao contrário da grande maioria dessas respostas, este é um programa verdadeiramente completo, como em um programa executável independente.

00000000: 7f45 4c46 0100 0000 0000 0000 0000 0100  .ELF............
00000010: 0200 0300 2000 0100 2000 0100 0400 0000  .... ... .......
00000020: ebfe 31c0 40cd 8000 3400 2000 01         ..1.@...4. ..

A essência do programa está no byte 0x20 ebfe, que é apresentado em outra resposta como o menor programa NASM. Se você montar isso com o NASM, no entanto, obterá um executável com milhares de bytes desnecessários. Podemos nos livrar da maioria deles usando a técnica descrita aqui . Você pode notar que este programa não é tão grande quanto o cabeçalho ELF! Esse pouco de golfe executável malforma o cabeçalho ELF e o cabeçalho do programa para que eles possam ocupar os mesmos bytes no arquivo e insere nosso programa em alguns bytes não utilizados no cabeçalho. O Linux ainda lerá felizmente o cabeçalho e começará a execução em offset, 0x20onde gira para sempre.

INTERCAL, 42 18 bytes

(1)DO COME FROM(1)

Ideia retirada do comentário de @ flawr.

EDIT: Caramba, INTERCAL é realmente menor que C #. Eu não sei se isso já aconteceu antes ...

Versão de 42 bytes

DO(1)NEXT
(1)DO FORGET #1
PLEASE DO(1)NEXT

Perl , 6 bytes

perl -e '{redo}'

De perldoc -f redo:

O comando refazer reinicia o bloco de loop sem avaliar novamente o condicional ... Observe que um bloco por si só é semanticamente idêntico a um loop que é executado uma vez. Assim, refazer dentro de um bloco efetivamente o transformará em uma construção em loop.

Não vejo redomuito frequentemente no código de produção, mas é ótimo para o golfe! Comparar o acima para os equivalentes mais curtos com for, whilee goto:

for(;;){} # 9 bytes
1while 1  # 8 bytes
X:goto X  # 8 bytes

> <> , 1 byte

Um único espaço fará com que <<> entre em um loop infinito de NOPs

Outros programas válidos de caracteres únicos (sem requisitos de memória) são os seguintes:

>^v</\|_#x!"'{}r

Além disso, as regras declaram que seu programa pode ficar sem memória. Nesse caso, podemos adicionar os seguintes caracteres à lista de programas válidos de 1 byte:

01234567890abcdefli

Motorola MC14500B Código da máquina , 0.5 0 bytes

Explicação

De acordo com o manual, o sistema está configurado para ter uma estrutura de controle em loop. O contador do programa conta até o valor mais alto, volta a zero e conta novamente.

LOLCODE , 24 bytes

IM IN YR X
IM OUTTA YR X

C, 15 bytes

main(){main();}

Sim, é possível ligar main()recursivamente. Se você tem um compilador que otimiza a chamada de cauda (digamos, gcc com a -O2opção), ele nem sequer é falhado: o compilador é inteligente o suficiente para transformar a chamada de função em goto.

Labirinto , 1 byte

"

Um programa labirinto executa a mesma instrução repetidamente se não houver vizinhos. Eles também não terminarão até que executem a @instrução.

Vim , 7 pressionamentos de teclas

Abra o editor, de preferência sem scripts carregados, por exemplo, na linha de comando: vim -u NONE

qq@qq@q

Vimscript, 15 8 bytes

Adicione-o a um script ou execute-o diretamente pressionando :primeiro a tecla dois pontos ( ) enquanto estiver no modo normal

wh1|endw

Retina , 3 bytes

+`0

Se for fornecido um único arquivo, o Retina utilizará o estágio Count, substituindo a entrada pelo número de correspondências encontradas para o regex especificado. Aqui, o regex é 0. Agora dá uma +volta no palco pelo tempo que o resultado mudar da iteração anterior. Então, o que exatamente está acontecendo?

• 0é comparado com a entrada vazia, fornecendo zero correspondências, portanto o resultado é 0. Isso é diferente da entrada, então executamos isso novamente.
• 0é comparado com a saída anterior 0, que agora fornece uma correspondência ... então o resultado é 1.
• 0é comparado com a saída anterior 1, que falha ... então o resultado é 0.
• ... Você entendeu a ideia.

O resultado da iteração do loop alterna entre 0e 1, que a) garante que o loop nunca termine eb) garante que não estamos ficando sem memória porque a cadeia não cresce.

Por padrão, o Retina é emitido apenas quando o programa é finalizado, portanto, isso não imprime nada (você pode alterar esse comportamento adicionando um >depois de +, que imprimirá os zeros e zeros alternados ).

A partir da versão 1.0, o Retina também possui loops de tempo mais tradicionais, que você pode usar com um estágio mais simples (que não altera a cadeia o tempo todo), mas na verdade exigem mais bytes. Uma opção seria:

//+`

BASIC (QBasic 4.5), 10 5 3 bytes

Na linguagem de programação BASIC, o RUN é usado para iniciar a execução do programa no modo direto ou para iniciar um programa de sobreposição de um programa do carregador. - Wikipedia

Edit: Isso funciona sem um número de linha no QBasic 4.5, de acordo com @steenbergh

RUN

Aqui está a primeira versão que publiquei. Loop GOTO infinito. Além disso, são 10 bytes, o que é uma boa coincidência!

10 GOTO 10

Nó TIS Tipo Arquitetura T21, 6 bytes

Os nós do Sistema de Inteligência em mosaico são classificados como nós de "processamento" ou "armazenamento". Nós de armazenamento simplesmente armazenam e recuperam informações e são irrelevantes nesse caso. Restantes são os nós de processamento. O tipo de nó T21, ou nó de execução básica, é o mais comum e simples (como o nome sugere).

Tecnicamente, cada nó pode ser pensado como um computador independente. No caso do T21, é um computador que possui dois registros de armazenamento (um endereçável, outro não) e um conjunto de instruções de 15 comandos. Possui memória suficiente para ser programado com até 15 instruções. Todos os nós do TIS têm quatro portas conectando-os aos nós topologicamente adjacentes. A leitura de uma porta faz com que esse nó seja interrompido até que o nó na outra extremidade seja gravado e a gravação em uma porta seja interrompida até que o nó a leia.

Você já deve saber que os nós do TIS nunca foram feitos para fazer muito por conta própria. Juntos, porém, eles podem ser bastante poderosos ... bem, por seu tempo. Devido a essas limitações, é muito raro ver alguém usar apenas um único nó. De fato, um programa que recebe entrada e fornece saída com base nela deve usar pelo menos três nós, pois os sistemas TIS alimentam a entrada na UPporta de um nó na linha superior e recebem a saída da DOWNporta de um nó na linha inferior. Como existem três linhas, os dados devem passar por pelo menos três nós para chegar ao fundo.

Devido a essas limitações, os nós TIS destinam-se a ser geralmente usados ​​de maneira semelhante a esta:

1. Obter entrada
2. Faça algo para isso
3. Passe adiante
4. Voltar ao passo 1

Por causa disso, o espaço limitado para instruções e o fato de que os nós simplesmente esperam silenciosamente e não causam problemas ao tentar ler as entradas que não estão lá, uma decisão foi tomada em seu design que os torna muito bons para esse desafio. Vou citar o manual de referência do TIS-100:

Depois de executar a última instrução do programa, a execução continua automaticamente para a primeira instrução.

Perfeito! Loops infinitos são padrão para nós TIS.

Eu quase respondi a essa pergunta com uma resposta de 0 byte, alegando que um nó vazio era um loop infinito. No entanto, eu pesquisei mais. Primeiro, a citação acima afirma que o loop ocorre após a execução da última instrução . Além disso, testei a implementação. Cada nó relata um "modo" o tempo todo. Não é acessível programaticamente, mas visa facilitar a depuração. Aqui estão os modos possíveis:

 RUN‌ - I am executing an instruction.
READ - I am reading from a port, waiting for it to be written to.
WRTE - I am writing to a port, waiting for it to be read from.
IDLE - I am doing nothing.

Acontece que, como cada nó é um computador individual, eles são capazes de determinar se têm ou não instruções para executar. Caso contrário, eles permanecerão no IDLEestado (provavelmente economizarão energia). Como tal, eu não podia, em sã consciência, afirmar que estava "dando voltas"; em vez disso, cada nó ficou em silêncio, assumindo que os outros estavam fazendo algo importante.

Este programa que enviei é realmente um loop infinito, pois, ao executá-lo, define o estado do nó RUN. É tão simples como seria de esperar, NOPexecuta No OPperação. Uma vez feito isso sem fazer nada, a execução retorna ao topo do código: NOP.

Se você achar que é insatisfatório que estou abusando da arquitetura T21 para criar um loop, eu ofereço uma solução alternativa ao custo de 2 bytes: JRO 0. JROsignifica Jump Runc elative Onditionally. Ou algo assim, eu acho. Não há forma expandida acordada das instruções. De qualquer forma, JROpega um argumento numérico e salta a execução por esse valor em relação à posição atual. Por exemplo, JRO 2pula a instrução que a segue (útil se essa instrução for saltada de outro lugar). JRO 1pula uma instrução adiante, tornando-a a NOP. JRO -1retrocede uma instrução, executando efetivamente a instrução anterior uma vez a cada dois ciclos até que o programa seja interrompido. E claro,JRO 0 pula para si mesmo, executando-se para sempre.

Neste ponto, você pode estar pensando:

Claro, monotrilho, tudo isso faz sentido, mas sua resposta é simples NOP. Por que sua pontuação é de 6 bytes?

Boa pergunta, obrigado por perguntar. Pode-se pensar ingenuamente que os programas TIS devem ser contados da mesma maneira que contamos os programas em vários arquivos: o número de bytes em todos os nós, mais 1 byte para cada nó adicional após o primeiro. No entanto, a comunidade de golfe do TIS decidiu que isso seria injusto pelo simples motivo de ignorar algumas das informações necessárias para recriar soluções. Os vizinhos de um nó são muito importantes e esse método de pontuação fornece informações posicionais gratuitamente. Em vez disso, adotamos o formato usado pelo emulador TIS mais comum, o TIS-100 de nome confuso. (Observação: por favor, não cite os emuladores de acordo com o sistema que eles imitam. Não é inteligente, é apenas irritante e faz com que todos tenham que esclarecer constantemente o que estão falando.) É muito simples: os 12 nós de um TIS-100 o dispositivo é numerado, da esquerda para a direita e de cima para baixo, ignorando os nós de armazenamento instalados pelo sistema emulado. Um nó numerado Ncontendo # CODE\n# CODE\n CODEé salvo da seguinte forma:

@N
# CODE
# CODE
# CODE

E assim, um nó numerado 0 contendo NOPé pontuado de acordo com sua representação neste formato:

@0
NOP

Seis bytes.

Como muitas vezes incluo minhas respostas em idiomas visualmente interessantes, você pode assistir ao emulador TIS-100 executar este programa no YouTube . Embora, considerando qual seja esse desafio, não sei o que você espera ver ...

C # , 38 37 36 bytes

class B{static int Main(){for(;;);}}

Loop for sem condição de parada.

O retorno de main deve ser um int, mas como nunca chegará ao fim, isso deve ser compilado. (Testado no VS 2015 e 2013, também funciona em Ideone ). Obrigado Geobits e MichaelS .

Uma versão mais curta, 35 bytes, pode ser obtida, mas as impressões Process is terminated due to StackOverflowExceptionque acredito violam o terceiro ponto de não imprimir nada no stderr. Crédito para MichaelB

class B{static int Main()=>Main();}

Foo, 3 bytes

(1)

Linguagem de programação favorita de todos! : D

Hexagonia , 1 byte

.

Não conheço muito essa linguagem incrível criada por @ MartinBüttner, mas pelo que vi, isso deve repetir-se infinitamente, pois não há @como interromper o programa. .é simplesmente um não-op.

Perl, 4 bytes

do$0

Executa-se repetidamente.

Gammaplex , 0 bytes

No Gammaplex, não é possível escrever um programa que não seja um loop infinito. Então, acabei de escrever um programa que não usa entrada / saída.

Pitão, 2 bytes

# 

Pyth espera tokens após o operador forever. (Isso é um espaço.)

bash + coreutils BSD, 23 22 14 6 5 6 bytes

yes>&-

yesgera "y" para sempre; >&-fecha STDOUT.

Obrigado @Dennis e @ThisSuitIsBlackNot pela ajuda na redução do tamanho!

Lisp comum, 6 caracteres

(loop)

Fissão , 1 byte

Existem exatamente 4 soluções de um byte:

R

L

U

D

Essas quatro letras indicam que um átomo começa ali (na direção correspondente). Um deles é necessário porque, sem um átomo, o programa termina imediatamente. Como o código-fonte possui apenas um caractere, o átomo será contornado imediatamente e executará a mesma célula novamente. No entanto, após o início do programa, UDLRbasta agir para desviar um átomo de entrada na direção correspondente, de modo que eles se tornem não operacionais nesse caso.