Notas

• Esse encadeamento é aberto e desbloqueado apenas porque a comunidade decidiu abrir uma exceção . Por favor , não use esta pergunta como prova de que você pode fazer perguntas semelhantes aqui. Por favor , não crie perguntas adicionais sobre a vitrine .

• Isso não é mais um concurso de popularidade , nem os comprimentos de trechos são limitados pela contagem de votos. Se você conhece esse tópico antes, certifique-se de se familiarizar com as alterações.

Este tópico é dedicado a exibir recursos interessantes, úteis, obscuros e / ou exclusivos que suas linguagens de programação favoritas têm a oferecer. Isso não é um desafio nem uma competição, mas um esforço de colaboração para mostrar o maior número possível de linguagens de programação.

Como isso funciona

• Todas as respostas devem incluir o nome da linguagem de programação na parte superior da postagem, prefixado por a #.

• As respostas podem conter um (e apenas um) fato, ou seja, algumas frases sem código que descrevem o idioma.

• Além do factóide, as respostas devem consistir em trechos de código, que podem (mas não precisam ser) programas ou funções.

• Os trechos não precisam estar relacionados. De fato, trechos muito relacionados podem ser redundantes.

• Como não se trata de um concurso, todas as linguagens de programação são bem-vindas sempre que criadas.

• As respostas que contêm mais de um punhado de trechos de código devem usar um trecho de pilha para recolher tudo, exceto o factóide e um dos trechos.

• Sempre que possível, deve haver apenas uma resposta por linguagem de programação. Este é um wiki da comunidade, portanto, sinta-se à vontade para adicionar trechos a qualquer resposta, mesmo que você não o tenha criado. Há um snippet de pilha para compactar postagens , o que deve atenuar o efeito do limite de 30.000 caracteres.

As respostas anteriores a essas diretrizes devem ser editadas. Ajude a atualizá-los conforme necessário.

Respostas atuais, ordenadas alfabeticamente pelo nome do idioma

$.ajax({type:"GET",url:"https://api.stackexchange.com/2.2/questions/44680/answers?site=codegolf&filter=withbody",success:function(data){for(var i=0;i<data.items.length;i++){var temp=document.createElement('p');temp.innerHTML = data.items[i].body.split("\n")[0];$('#list').append('<li><a href="/a/' + data.items[i].answer_id + '">' + temp.innerText || temp.textContent + '</a>');}}})

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script><base href="http://codegolf.stackexchange.com"><ul id="list"></ul>

Mathematica

Você pode ler isso de baixo para cima, pois essa é a ordem em que foi escrito, e algumas explicações se referem a trechos anteriores ou assumem explicações mais adiante.

A lista está crescendo bastante. Comecei a remover trechos menos interessantes e começarei a pular trechos agora. Veja o histórico de revisões para obter uma lista completa de trechos de até 41. Para algumas jóias reais, consulte os trechos 81 , 64 , 44 , 23 , 19 , 12 e 8 .

Snippets de comprimento 143 e 144

Finalmente ... estou esperando por isso há um tempo (e jogando golfe há tanto tempo, para não ter que esperar mais). Eu mencionei anteriormente que você também pode equações numericamente e que também pode resolver equações diferenciais. Eu queria mostrar um exemplo não trivial disso.

Considere um pêndulo duplo em uma haste (ou seja, um pêndulo anexado a outro). Cada haste possui comprimento unitário e cada um dos dois pesos pendulares possui massa unitária. Eu também usei a gravidade unitária para encurtar a equação. O seguinte trecho de 143 caracteres resolve as equações de movimento lagrangianas para esse sistema (em termos de ângulos dos pêndulos e momento angular). Uma derivação pode ser encontrada neste PDF , embora seja um exercício bastante direto se você estiver familiarizado com a mecânica lagrangiana.

É bastante ilegível, porque eu tive que jogar muito:

d=θ@t-φ@t;NDSolve[{#''@t==-#4#2''[t]Cos@d-##3#2'@t^2Sin@d-Sin@#@t&@@@{{θ,φ,1,.5},{φ,θ,-1,1}},θ@0==2,φ@0==1,θ'@t==φ'@t==0/.t->0},{θ,φ},{t,0,60}]

O interessante é que o Mathematica exibe imediatamente um gráfico em miniatura de como são as soluções:

Ok, mas isso é um pouco coxo. Queremos saber como é o movimento da pêndula. Então, aqui está um trecho de 144 caracteres, que anima a pêndula enquanto traça a trajetória do pêndulo inferior:

Graphics@{Line@{{0,0},p=θ~(h={Sin@#@#2,-Cos@#@#2}&)~t,p+φ~h~t},White,{0,0}~Circle~2.2}~Show~ParametricPlot[θ~h~u+φ~h~u,{u,0,t}]~Animate~{t,0,60}

A animação resultante é assim:

^{Eu tive que trapacear um pouco: se você traçar além t = 30, ParametricPlotpor padrão, usa muito poucos pontos de plotagem e a linha fica bastante irregular. Mas a maioria das dinâmicas interessantes acontece depois desse período, então usei a opção PlotPoints -> 200para tornar a segunda metade da animação mais suave. Não é nada substancialmente diferente, e a primeira metade pareceria indistinguível de qualquer maneira.}

Eu acho que esse será meu último trecho, a menos que eu crie algo realmente impressionante. Espero que tenham gostado!

Snippet de comprimento 100

GeoGraphics[{GeoStyling[Opacity[0.5]], NightHemisphere[]}, GeoBackground -> GeoStyling["ReliefMap"]]

Eu estava pensando em algumas Geofunções interessantes para o snippet 100, mas no final encontrei algo realmente bacana no Tweet-a-Program , que eu só precisava roubar. O exemplo acima gera um mapa solar bonito da Terra para a hora e o dia atuais, sobrepondo uma forma semi-opaca do hemisfério noturno ao longo de um mapa de relevo:

Snippet de comprimento 81

CellularAutomaton[{{0,2,3,If[0<Count[#,1,2]<3,1,3]}[[#[[2,2]]+1]]&,{},{1,1}},i,n]

Eu prometo que é o último autômato celular. Mas é esse o Wireworld em 81 caracteres. Dessa vez, não codifiquei a regra em um único número, a) porque acho que seria ridiculamente grande (não me incomodei em descobrir isso) eb) para mostrar outro uso CellularAutomaton. Desta vez, a regra é simplesmente especificada como uma função pura, que recebe uma vizinhança de células e retorna o novo valor da célula. Essa é uma abordagem muito mais viável para autômatos celulares com mais de 2 cores / estados.

De qualquer forma, configurei o exemplo da Wikipedia em i(dois relógios gerando sinais e um portão XOR) e o deixei rodar por 50 etapas:

Se você estiver interessado, a plotagem e a animação reais poderiam ter sido o snippet 77:

ListAnimate[ArrayPlot[#,ColorRules->{0->Black,1->Blue,2->Red,3->Yellow}]&/@w]

Fragmento de comprimento 69

DSolve[r^2*R''[r]+2r*R'[r]-R[r]==0&&(R[r]==1&&R'[r]==2/.r->1),R[r],r]

Voltar para algo útil. Além dos sistemas normais de equações, o Mathematica também pode resolver sistemas de equações diferenciais. O acima é tecnicamente apenas uma equação diferencial com condições de contorno, mas você também pode fornecer isso como um sistema de três equações. Semelhante às funções de integração DSolveé para soluções exatas, que NDSolveresolverão o sistema numericamente. O acima exposto produz uma única solução

{{R[r] -> 1/2 r^(-(1/2) - Sqrt[5]/2) (1 - Sqrt[5] + r^Sqrt[5] + Sqrt[5] r^Sqrt[5])}}

que agora pode ser facilmente usado para cálculos adicionais ou plotados.

Fragmento de comprimento 64

CellularAutomaton[{224,{2,{{2,2,2},{2,1,2},{2,2,2}}},{1,1}},i,n]

Eu te prometi mais CellularAutomatonmágica! Esse snippet calcula o Jogo da vida de Conways com a condição inicial ide netapas e fornece o resultado para todos os timesteps intermediários.

Algumas palavras sobre os parâmetros: 2é o número de estados da célula. {{2,2,2},{2,1,2},{2,2,2}}fornece os pesos para as 9 células no bairro 3x3. Ele garante que a própria célula seja distinguível da soma dos 8 vizinhos. {1,1}diz que a regra da autoridade de certificação depende das células a um passo de distância em qualquer direção. Finalmente, 224a regra de atualização real é codificada em um único número. Descobrir esse número pode ser um pouco complicado, mas há um tutorial bastante útil na documentação . Para autômatos mais complicados, um único número não será suficiente (porque o número seria enorme). Talvez cheguemos lá amanhã! ;)

De qualquer forma, se eu alimentar uma grade aleatória ie 200 ne enviar o resultado através de uma animação ArrayPlot, podemos ver que ele está realmente funcionando:

Fragmento de comprimento 59

SphericalPlot3D[Re[Sin[θ]Cos[θ]Exp[2I*φ]],{θ,0,π},{φ,0,2π}]

Lembre-se da trama polar do trecho 26? Nós podemos fazer a mesma coisa em 3D! (De fato, existem duas funções: RevolutionPlot3Dpara polares cilíndricos e polares SphericalPlot3Desféricos.) Assim como Graphics3Dtodos os gráficos tridimensionais são automaticamente rotacionáveis ​​no Mathematica, você não precisa se preocupar com um bom ângulo de câmera. O gráfico acima mostra algo como um harmônico esférico (embora não muito) e se parece com:

Snippet de comprimento 52

Manipulate[Plot[x^2a+x*b,{x,-3,3}],{a,.1,3},{b,0,3}]

Este é bem bacana. Manipulatepega qualquer expressão, a parametriza com várias variáveis ​​e fornece um widget, onde você pode ajustar os parâmetros e ver ao vivo como a expressão muda. Como expressão, você geralmente terá algum tipo de enredo. Isso é particularmente útil se você estiver usando o Mathematica em palestras para demonstrar como as famílias de soluções respondem à modificação dos parâmetros. Os shows acima como os ae bcoeficientes de escala e de mudança de uma parábola:

Snippet de comprimento 48

Import["http://www.google.com/doodles","Images"]

Importé um comando bastante poderoso. É usado para carregar arquivos do disco e da web. Ele conhece vários formatos de arquivo diferentes e, para alguns deles (como páginas HTML), pode realmente extrair dados imediatamente. O acima faz o download de todas as imagens da página de doodle do Google.

Fragmento de comprimento 45

EdgeDetect@ExampleData@{"TestImage","Splash"}

Tempo para algum processamento de imagem. O Mathematica vem com um monte de dados de exemplo, incluindo imagens (como Lena), texturas, modelos 3D e trechos de áudio. Primeiro, carregamos um deles:

Deseja detectar arestas? É uma chamada de função única:

Fragmento de comprimento 44

ArrayPlot@CellularAutomaton[110,{{1},0},100]

Finalmente, tenho caracteres suficientes para usar CellularAutomatone também renderizar o resultado. :) Pelo que sei, CellularAutomatoné a única função no Mathematica relacionada a autoridades de certificação. Mas Stephen Wolfram parece se considerar o número um no autômato celular, então essa função é incrivelmente poderosa. O exemplo acima mostra praticamente seu uso mais simples. Isso simula um autômato celular 1D por 100 etapas - e na verdade retornará o estado do autômato em cada uma dessas etapas, portanto o resultado é bidimensional. A regra é o primeiro parâmetro, que pode ser especificado em detalhes por meio de listas ou apenas codificado em um único número. Para este exemplo, escolhi a famosa Regra 110 de Turing complete . {{1},0}define a condição inicial: um único1na frente de um fundo de zeros. Talvez eu mostre mais alguns recursos CellularAutomatonno futuro quando tiver mais personagens disponíveis: ele pode simular CAs em dimensões mais altas, usando bairros maiores e com mais de dois estados.

ArrayPloté outro bom utilitário de plotagem que apenas plota uma lista 2D como uma grade de cores sólidas indicando seu valor. No caso mais simples, 0é mappend para branco e 1preto. O resultado do snippet é:

Snippet de comprimento 43

HighlightGraph[graph,FindVertexCover@graph]

Já faz um tempo desde que mencionei gráficos. Existem muitos problemas teóricos gráficos comuns no Mathematica, junto com boas ferramentas de visualização. O acima, para um dado graph, encontrará uma cobertura mínima de vértices do gráfico e, em seguida, renderizará o gráfico com esses vértices destacados. Por exemplo, se graphé PetersenGraph[7,2]de volta do trecho de 18, obtemos:

Fragmento de comprimento 42

Animate[Plot[Sin[t-x],{x,0,10}], {t,0,10}]

É muito simples animar as coisas no Mathematica (e elas nem precisam ser imagens). Você apenas fornece a expressão a ser avaliada para cada quadro e vários parâmetros que devem variar sobre os quadros. O texto acima simplesmente anima um gráfico de uma onda senoidal em movimento. A animação será semelhante ao seguinte GIF:

Fragmento de comprimento 40

SortBy[PlanetData[#, "EscapeVelocity"]&]

SortByfaz o que você espera: classifica uma lista com base nos valores obtidos mapeando uma determinada função em cada elemento da lista. Mas espere, a chamada acima não contém uma lista. Desde o Mathematica 10, há suporte para currying ou aplicação parcial para algumas funções. Esse não é um recurso de linguagem, como nas linguagens funcionais mais puristas, mas é implementado apenas manualmente para várias funções em que isso geralmente é útil. Isso significa que o snippet acima retorna uma nova função, que apenas pega uma lista e depois classifica pela função especificada. Isso pode ser muito útil se essa ordem de classificação for algo que você usará com mais frequência em todo o seu código.

E sim, há outra *Datafunção interessante - as opções acima classificarão os nomes dos planetas pelas velocidades de escape dos planetas .

Fragmento de comprimento 39

f[1]=1
f[2]=1
f[n_]:=f[n]=f[n-1]+f[n-2]

Prometi tornar a função Fibonacci mais eficiente. Este trecho mostra como a memória é trivial no Mathematica. Observe que tudo o que mudou é um adicional f[n]=na terceira linha. Então, quando fé chamado para um novo valor (digamos f[3]), então f[3]=f[3-1]+f[3-2]será avaliado. Isso calcula f[2]+f[1], depois o atribui a f[3](with =, not with :=!) E, finalmente, retorna o valor da nossa chamada inicial. Portanto, chamar essa função adiciona uma nova definição para esse valor, que é obviamente mais específica que a regra geral - e, portanto, será usada para todas as chamadas futuras fcom esse valor.

Lembre-se de que a outra função Fibonacci levou 4 segundos para 30 valores? Isso precisa de 3 segundos para 300.000 valores.

Fragmento de comprimento 37

l//.{a___,x_,b___,x_,c___}:>{a,x,b,c}

No último trecho, mencionei padrões. Eles são mais frequentemente usados ​​em regras , que (entre outras coisas) podem ser usadas para modificar estruturas que correspondem a um determinado padrão. Então, vamos olhar para este trecho.

{a___,x_,b___,x_,c___}:>{a,x,b,c}é uma regra. x_com um único sublinhado é um padrão que se refere a um único valor arbitrário (que poderia ser uma lista ou semelhante). a___é um padrão de sequência (consulte também o trecho 15), que se refere a uma sequência de 0 ou mais valores. Observe que estou usando x_duas vezes, o que significa que essas duas partes da lista precisam ter o mesmo valor. Portanto, esse padrão corresponde a qualquer lista que contenha um valor duas vezes, chama esse elemento xe chama as três sequências em torno desses dois elementos a, be c. Isso é substituído por {a,x,b,c}- ou seja, o segundo xé descartado.

Agora //.aplicará uma regra até que o padrão não corresponda mais. Portanto, o trecho acima remove todas as duplicatas de uma lista l. No entanto, é um pouco mais poderoso que isso: //.aplica a regra em todos os níveis. Portanto, se lele próprio contiver listas (com qualquer profundidade), duplicatas dessas sublistas também serão removidas.

Fragmento de comprimento 36

f[1]=1
f[2]=1
f[n_]:=f[n-1] + f[n-2]

Hora de novos recursos de idioma! O Mathematica tem algumas coisas boas sobre a definição de funções. Para começar, você pode fornecer várias definições de função para o mesmo nome, para diferentes números ou tipos de argumentos. Você pode usar padrões para descrever a quais tipos de argumentos uma definição se aplica. Além disso, você pode até adicionar definições para valores únicos. O Mathematica selecionará a definição aplicável mais específica para qualquer chamada de função e deixará as chamadas indefinidas não avaliadas. Isso permite (entre outras coisas) escrever funções recursivas de uma maneira muito mais natural do que usar um Ifcomutador para o caso base.

Outra coisa a ser observada sobre o snippet acima é que estou usando os dois =e :=. A diferença é que o lado direito de =é avaliado apenas uma vez, no momento da definição, enquanto que :=é reavaliado cada vez que o lado esquerdo é referido. De fato :=, funciona mesmo ao atribuir variáveis, que terão um valor dinâmico.

Portanto, o que foi dito acima, é claro, é apenas uma função de Fibonacci. E muito ineficiente nisso. O cálculo dos 30 primeiros números leva cerca de 4 segundos na minha máquina. Veremos em breve como podemos melhorar o desempenho sem precisar nos livrar da definição recursiva.

Fragmento de comprimento 35

StreamPlot[{x^2,y},{x,0,3},{y,0,3}]

Uma plotagem muito elegante, que gera as linhas de fluxo de um campo vetorial 2D. Isso é semelhante a um gráfico vetorial normal, em que cada seta é tangente ao campo vetorial. No entanto, as setas não são colocadas em uma grade fixa, mas unidas em linhas (as linhas de fluxo). O significado dessas linhas é que elas indicam a trajetória de uma partícula (em um fluido, por exemplo) se o campo vetorial for um campo de velocidade. A entrada acima se parece com:

Fragmento de comprimento 34

Solve[a*x^4+b*x^3+c*x^2+d*x==0, x]

O Mathematica também pode resolver equações (ou sistemas de equações, mas só temos tantos caracteres agora). O resultado será, como sempre, simbólico.

{
  {x -> 0}, 
  {x -> -(b/(3 a)) - (2^(1/3) (-b^2 + 3 a c))/(3 a (-2 b^3 + 9 a b c - 27 a^2 d + Sqrt[4 (-b^2 + 3 a c)^3 + (-2 b^3 + 9 a b c - 27 a^2 d)^2])^(1/3)) + (-2 b^3 + 9 a b c - 27 a^2 d + Sqrt[4 (-b^2 + 3 a c)^3 + (-2 b^3 + 9 a b c - 27 a^2 d)^2])^(1/3)/(3 2^(1/3) a)}, 
  {x -> -(b/(3 a)) + ((1 + I Sqrt[3]) (-b^2 + 3 a c))/(3 2^(2/3) a (-2 b^3 + 9 a b c - 27 a^2 d + Sqrt[4 (-b^2 + 3 a c)^3 + (-2 b^3 + 9 a b c - 27 a^2 d)^2])^(1/3)) - ((1 - I Sqrt[3]) (-2 b^3 + 9 a b c - 27 a^2 d + Sqrt[4 (-b^2 + 3 a c)^3 + (-2 b^3 + 9 a b c - 27 a^2 d)^2])^(1/3))/(6 2^(1/3) a)}, 
  {x -> -(b/(3 a)) + ((1 - I Sqrt[3]) (-b^2 + 3 a c))/(3 2^(2/3) a (-2 b^3 + 9 a b c - 27 a^2 d + Sqrt[4 (-b^2 + 3 a c)^3 + (-2 b^3 + 9 a b c - 27 a^2 d)^2])^(1/3)) - ((1 + I Sqrt[3]) (-2 b^3 + 9 a b c - 27 a^2 d + Sqrt[4 (-b^2 + 3 a c)^3 + (-2 b^3 + 9 a b c - 27 a^2 d)^2])^(1/3))/( 6 2^(1/3) a)}
}

Observe que as soluções são fornecidas como regras , as quais provavelmente mostrarei com mais detalhes em algum snippet futuro.

Fragmento de comprimento 33

Dynamic@EdgeDetect@CurrentImage[]

Obrigado ao benwaffle por essa ideia. CurrentImage[]carrega a imagem atual da sua webcam. EdgeDetecttransforma uma imagem em preto-e-branco, onde as bordas são brancas e o restante é preto (veja o trecho 45 para um exemplo). A verdadeira diversão vem com a Dynamicqual a expressão se atualiza. Portanto, o resultado disso transmitirá fotos da sua webcam e a detecção de bordas ao vivo.

Fragmento de comprimento 32

NumberLinePlot[x^2<2^x,{x,-2,5}]

Um tipo bastante incomum de trama. Ele pode traçar um monte de coisas diferentes ao longo da linha numérica, como pontos e intervalos. Você também pode dar a condição e mostrará a região onde essa condição é verdadeira:

A seta indica que a região continua até o infinito. Os círculos brancos indicam que esses são intervalos abertos (os pontos finais não fazem parte do intervalo). Para fins fechados, os círculos seriam preenchidos.

Fragmento de comprimento 28

Graphics3D@{Sphere[],Cone[]}

Hora de alguns gráficos 3D. O exemplo acima renderiza uma esfera e um cone superimpostos com parâmetros padrão, que se parecem com uma bola de cristal:

No Mathematica, você pode clicar e arrastar esse pequeno widget para girá-lo.

Fragmento de comprimento 27

CountryData["ITA", "Shape"]

Mais *Data! CountryDataé muito louco. Obter a forma de um país não é nem a ponta do iceberg. Há tantos dados sobre os países que você provavelmente poderia escrever um livro inteiro sobre essa função. Como ... existe FemaleLiteracyFraction. Você também pode consultar esses dados para diferentes pontos no tempo. Para uma lista completa, consulte a referência.

Snippet de comprimento 26

PolarPlot[Sin[5θ],{θ,0,π}]

Hora de um enredo mais interessante. PolarPloté simplesmente um gráfico em coordenadas polares. Em vez de especificar y para um determinado x, você especifica um raio r para um determinado ângulo θ:

Fragmento de comprimento 25

{{1,5},{2,3},{7,4}}.{8,9}

Finalmente temos caracteres suficientes para algumas matemáticas vetoriais. O acima calcula a multiplicação da matriz de uma matriz 2x3 e o vetor de linha 2:

{53, 43, 92}

Fragmento de comprimento 23

Rotate[Rectangle, Pi/2]

Heh. Ele Ele. Você acha que sabe o que isso faz. Mas você não. Rectanglepor si só é apenas uma função nomeada. Para realmente obter um objeto representando um retângulo, você precisa chamar essa função com alguns parâmetros. Então, o que você acha que acontece quando você tenta girar Rectangle? Este:

Fragmento de comprimento 22

30~ElementData~"Color"

Outra das *Datafunções internas. Sim, para elementos químicos, você não recebe apenas coisas como o número atômico, o ponto de fusão e o nome ... você pode realmente obter a cor à temperatura ambiente. O acima fornece a cor do zinco:

SlateGray

Fragmento de comprimento 21

Integrate[E^(-x^2),x]

Tivemos diferenciação há algum tempo. Hora da integração. O Mathematica pode lidar com integrais definidas e indefinidas. Em particular, Integratefornecerá uma solução exata e pode lidar com uma tonelada de integrais padrão e técnicas de integração (para resultados numéricos, existe NIntegrate). Se você conhece seu cálculo, deve ter notado que a integral gaussiana acima não possui uma integral indefinida de forma fechada ... a menos que você considere a forma fechada da função de erro , ou seja. O Mathematica retorna:

1/2 Sqrt[π] Erf[x]

Fragmento de comprimento 20

"Sun"~StarData~"Age"

Voltar para dados internos . Deve haver pelo menos duas dúzias de *Datafunções para tudo o que você poderia pensar. Cada um deles usa um identificador para a coisa que você deseja que os dados e uma propriedade (ou lista de propriedades) a serem recuperadas. O acima é apenas um dos mais curtos possíveis Sun, Stare Agetodos muito curtos, porque eu mal podia esperar para mostrar esse recurso.

Ah, sim, e eu mencionei que o Mathematica (desde 9) suporta quantidades com unidades? (Mais sobre isso posteriormente.) O item acima avalia como:

Quantity[4.57*10^9, "Years"]

que é exibido como

Fragmento de comprimento 19

MandelbrotSetPlot[]

Sim ... função muito útil ... Eu usá-lo todo o tempo. (Às vezes, o desejo de apoiar qualquer coisa que possa ser computável pode ir um pouco longe ...)

Em sua defesa, a função é um pouco mais útil que isso: você pode fornecer uma seção específica do gráfico que deseja plotar.

Fragmento de comprimento 18

PetersenGraph[7,2]

Desde o Mathematica 8, ele entende o que são grafos, por isso vem com todos os tipos de funções relacionadas à teoria de grafos. E não era o Mathematica se não incluísse uma tonelada de embutidos. O exemplo acima gera os dados do gráfico para um gráfico de Petersen generalizado . Ele produz a estrutura de dados real que pode ser manipulada, mas o Mathematica exibe imediatamente os dados do gráfico ... graficamente:

Fragmento de comprimento 17

Plot[x^x,{x,0,2}]

Finalmente, caracteres suficientes para fazer algumas plotagens. O acima é realmente apenas o exemplo mais simples de um gráfico unidimensional. Prometo mostrar gráficos mais frescos mais tarde

Fragmento de comprimento 15

{##4,#,#2,#3}&

Isso mostra dois dos recursos mais poderosos (e também úteis para jogar golfe). A coisa toda é uma função pura sem nome , comparável com lambdas em Python ou Procs em Ruby. A função pura é simplesmente encerrada por a &. Esse operador tem uma precedência muito baixa, de modo que geralmente inclui quase tudo o que resta dele. Os argumentos de uma função pura são mencionados #, às vezes seguidos por outras coisas. O primeiro argumento é #or #1, o segundo é #2e assim por diante.

O outro recurso é Sequences. São basicamente como splats em outros idiomas. Uma sequência é como uma lista sem a lista ao seu redor - é literalmente apenas uma sequência de valores, que pode ser usada em listas, argumentos de função etc. ##em particular, é uma sequência de todos os argumentos de função pura. ##2é uma sequência de todos os argumentos iniciando no segundo. Então, se nomeamos a função acima fe a chamamos como

f[1,2,3,4,5]

Nós teríamos

{4,5,1,2,3}

então a função gira os argumentos de entrada 3 elementos para a esquerda. Observe que os ##4referidos 4,5foram achatados na lista.

Fragmento de comprimento 12

D[x^y^x,x,y]

Diferenciação parcial. Ddiferenciará a primeira expressão sucessivamente em relação aos outros argumentos, fornecendo uma expressão simbólica como resultado. Portanto, o acima é d² (x ^ y ^ x) / dxdy (onde os d s são parciais), que o Mathematica relata ser

x^y^x (y^(-1 + x) + y^(-1 + x) Log[x] + x y^(-1 + x) Log[x] Log[y]) + 
  x^(1 + y^x) y^(-1 + x) Log[x] (y^x/x + y^x Log[x] Log[y])

Fragmento de comprimento 9

Exp[I*Pi]

Ainda não fizemos nenhuma aritmética complexa! Como você pode ver, πna verdade era apenas um apelido para Pi. De qualquer forma, o acima realmente retornará corretamente o número inteiro -1 .

Fragmento de comprimento 8

Sunset[]

Sim. Fale sobre embutidos malucos. Sem parâmetros que realmente fornecem um objeto datetime do próximo pôr do sol na sua localização atual. Ele também usa parâmetros para outras datas, outros locais etc. Aqui está o que parece para mim agora:

Fragmento de comprimento 7

9!/43!!

Este trecho mostra algumas coisas legais.

O Mathematica não possui apenas um operador fatorial embutido !, ele também possui um fatorial duplo !!(que multiplica todos os outros números de nbaixo para 1). Além disso, ele suporta números inteiros de precisão arbitrária. O valor 43!!será avaliado exatamente, até o último dígito. Além disso, os números racionais também serão avaliados exatamente. Portanto, como numerador e denominador existem números inteiros, o Mathematica reduzirá as frações o máximo possível e apresentará a você

128/198893132162463319205625

Obviamente, você pode usar carros alegóricos quando quiser, mas, em geral, se sua entrada não contiver carros alegóricos, seu resultado será exato.

Fragmento de comprimento 4

Here

Já era hora de começarmos com a riqueza de itens malucos do Mathematica. O acima faz o que diz na lata e (para mim) avalia GeoPosition[{51.51, -0.09}].

Fragmento de comprimento 3

x-x

Apenas para mostrar o Factoid original : o acima funciona mesmo que ainda xnão esteja definido e, na verdade, resultará 0nesse caso.

Fragmento de comprimento 2

3x

Multiplicação via justaposição! Se estiver claro que um identificador termina e outro começa, você não precisa de um *espaço em branco para multiplicá-los. Isso funciona com praticamente tudo, incluindo strings e variáveis ​​que ainda não possuem valores. Muito conveniente para jogar golfe. ;)

Fragmento de comprimento 1

π

Adivinhe, é Pi. E, de fato, não é uma representação aproximada de ponto flutuante, é Pi exatamente - portanto, todos os tipos de funções complexas e trigonométricas em que é usada produzirão resultados exatos se forem conhecidas.

Factóide

O Mathematica pode executar manipulação simbólica, portanto, as variáveis ​​não precisam de valores para trabalhar com elas.

A infame linguagem de programação de Shakespeare

A linguagem de programação de Shakespeare foi criada em 2001 por dois estudantes suecos, Karl Hasselström e Jon Åslund, e combina, como proclamam os autores ,

a expressividade do BASIC com a facilidade de uso da linguagem assembly.

As respostas vão de cima para baixo. Além disso, é comum ver-me consultar trechos mais antigos ou anteriores.

( link para mim: editar )

Factóide:

O código de Shakespeare se assemelha, como seria de esperar, a uma peça de Shakespeare, onde as variáveis ​​são caracteres da peça e seu valor muda à medida que são "insultadas" ou elogiadas ".

Fragmento de comprimento 1:

I

O código de Shakespeare é dividido em Atos, e os atos são divididos em Cenas, para causalidades de "pular para". Definir um ato como Act Isignifica que será a primeira parte do código a ser executada, por exemplo - mas não apenas.

Fragmento de comprimento 2:

as

Utilizado em uma comparação entre dois "caracteres".

Fragmento de comprimento 3:

day

Até agora, você pode estar sentindo que o SPL é muito detalhado. E esquisito. E você ainda não viu nada. day, em SPL, é 1. Todos os substantivos "positivos" e "neutros" são considerados 1, assim como todos os substantivos "negativos" -1.

Fragmento de comprimento 4:

rich

O que é rich? Um adjetivo. No SPL, os adjetivos fazem com que o valor do substantivo ao qual estão anexados se multiplique por dois. Consulte a implementação no snippet 14.

Fragmento de comprimento 5:

Act I

Implementação do primeiro trecho. Todos os atos podem receber um título, como Act I: Hamlet must die!, uma vez que tudo depois do número romano é ignorado pelo analisador.

Fragmento de comprimento 6:

better

Todo idioma tem condições e o SPL não é exceção. Exceto que, como essa é uma linguagem com uma sintaxe longa (e eu a mencionei estranha), suas declarações condicionais serão longas. Ter Ophelia perguntando a Juliet Am I better than you?é como ter if (Ophelia > Juliet)na maioria dos idiomas "normais". E, claro, você pode perguntar o contrário: Am I not better than you?é o equivalente a if (Ophelia < Juliet). E você já pode adivinhar como isso =é traduzido para o SPL: as good as- uso do snippet de código 2.

No entanto, good/betternão é a única maneira de fazer comparações nesse idioma shakesperiano, você pode usar qualquer adjetivo. O mesmo princípio do trecho 3 também se aplica aqui, com adjetivos "positivos" tendo o valor >, enquanto significantes "negativos" significam <.

Fragmento de comprimento 7:

Juliet:

Esta é a invocação de uma variável; depois disso, suas instruções / declarações / o que vier a seguir.

Uma limitação do SPL é que ele tem um número limitado de variáveis: Romeu, Julieta, Hamlet, Ophelia, MacBeth e outros são alguns exemplos de "caracteres" que aparecerão em um programa shakesperiano.

Fragmento de comprimento 8:

[Exeunt]

[Exeunt]é colocado quando todos os "caracteres" saem do "palco". Espero que eu possa elaborar um pouco mais adiante sobre a interação entre os personagens. Geralmente é a última instrução de qualquer programa SPL, embora [Exeunt]não seja especificamente o "caractere" terminal da linguagem. Para outro exemplo, consulte o trecho 27.

Fragmento de comprimento 9:

as bad as

Nove caracteres apenas para representar um mero =- usando o trecho 2. Mencionei que o SPL é estranho? Veja o snippet 30 para exemplos. (e sim, há mais de uma maneira de produzi-lo)

Fragmento de comprimento 10:

difference

Uma maneira elegante de representar -, uma subtração. Você pode ter operações matemáticas no SPL, mesmo que provavelmente precise de um dia inteiro para fazer a correção.

Factoid (desde que consegui chegar a dez trechos de código, vamos fazer uma pausa e ter outro fato sobre o SPL)

Se você deseja executar seu código shakesperiano em toda a sua glória, existe este site - ainda estou testando, desde que o descobri nem cinco minutos atrás. Também há uma maneira de traduzi-lo para C usando um tradutor .

Outro site para executar o código SPL é este que funciona traduzindo internamente o código SPL para outra linguagem esotérica: Oracle PL / SQL.

Fragmento de comprimento 11:

[Exit Romeo]

Sim! Por fim, posso falar sobre a interação entre os personagens! Para ter seu valor alterado ou interagir com outras pessoas, um "personagem" deve estar no palco - entrando com [Enter Romeo]. Se um caractere é endereçado, mas não está presente, há um erro de tempo de execução e o programa para. Porque, na SPL, o valor das variáveis ​​é definido pela quantidade de nomes com os quais são elogiados - ou insultados - pelos outros caracteres no palco. Acho que devo dar um exemplo para esclarecer algumas confusões que minha explicação esfarrapada pode criar, mas talvez seja melhor adiar alguns trechos.

Fragmento de comprimento 12:

Remember me.

O SPL é bastante "básico", tudo bem - mas tem pilhas! Quando, por exemplo, Romeu diz a Julieta para "se lembrar dele", ele está realmente dizendo à sua amada para colocar o valor do Romeu na pilha dela. O aumento do valor é feito com Recall your happy childhood!, ou Recall your love for me, ou basicamente, com qualquer frase que comece com Recall- o resto é apenas um truque artístico, como o trecho 22.

Fragmento de comprimento 13

Let us return

A maneira shakesperiana de ter um goto. E é aqui que os Atos e Cenas são úteis. Se Romeu disser a Julieta we shall return to Act II(sim, novamente, existem várias maneiras de escrevê-lo), o programa passará para essa parte específica do código. Também é visto ao lado de declarações condicionais.

Fragmento de comprimento 14

my little pony

Sim, foi uma série nos anos 80. Aqui está 2*1. Por quê? Porque a ponyé um substantivo (um tanto) positivo e littleé um adjetivo. Então, lembrando os trechos 3 e 4, temos little = "2 *"e pony = "1".

Fragmento de comprimento 15

Speak thy mind!

Em um programa SPL, você verá isso (ou Speak your mind!, o que é o mesmo) muito . Isso basicamente gera o valor de cada "caractere" em dígito, letra ou qualquer outra coisa, dependendo do conjunto de caracteres sendo usado pelo seu computador. Há também o Open your mind.que faz quase a mesma coisa, embora apenas produza em forma numérica.

Fragmento de comprimento 16

You are nothing!

Quando alguém lhe diz isso na vida real, você se sente deprimido. Quando Ophelia diz isso a Hamlet na programação shakespeariana, Hamlet se sente inútil. O que isto significa? Isso Hamlet = 0.

Fragmento de comprimento 17

Ophelia, a wench.

Em um roteiro, antes do início da peça, os personagens devem ser apresentados. Na maioria das linguagens de programação, as variáveis ​​também devem ser declaradas antes do uso. Vendo que SPL é uma linguagem de programação que se assemelha a um roteiro, é assim que você declara suas variáveis, declarando quais são as que aparecem durante o programa.

Mas o que significa "uma moça"? Isso significa que é um nome de tipo de dados específico (e legal)? Bem ... Eu odeio desapontá-lo, mas isso não significa nada: tudo depois que a vírgula é desconsiderada pelo analisador, o que significa que você pode colocar lá a bobagem mais ultrajante que puder imaginar.

Fragmento de comprimento 18

lying sorry coward

-4para todas as criaturas terrenas. Por quê? Porque 2*2*(-1) = -4.

Fragmento de comprimento 19

Romeo:
 Remember me.

Finalmente!!! Finalmente, posso emitir uma instrução de sintaxe correta e completa (embora curta)! É assim que você usa o trecho 12: primeiro declara quem está falando e, na próxima linha, escreve o "diálogo". Normalmente, apenas dois "personagens" estão no palco, para evitar deixar o analisador triste e confuso. Quando você precisar de outro "personagem", você pega um do palco e o substitui pelo novo.

Fragmento de comprimento 20

cube of thy codpiece

Eu queria elaborar um pouco mais para este, mas, verdade seja dita, as coisas que eu invento ainda são muito curtas para esse tamanho de trecho. E, portanto, trago-lhe isso, que acaba sendo -1- porque (-1) ³ = -1 (e codpieceé um substantivo "negativo", pois são desconfortáveis ​​e tudo). SPL entende algumas mais elaboradas operações aritméticas como alguns exponenciação e raízes quadradas.

Factoid (mais um, desde que alcançamos outro marco)

O "Hello World Program" em Shakesperian tem 89 linhas e mais de 2400 caracteres, como pode ser visto aqui .

Fragmento de comprimento 21

Listen to your heart.

No trecho 15, você produziu algo; aqui, você insere um número no programa. Se você deseja inserir um caractere, utilizará Open your mind.. E, escusado será dizer, esse valor será armazenado no "personagem" que está sendo falado.

Fragmento de comprimento 22

Recall your childhood!

Retirar um número inteiro de uma pilha é feito com isso, conforme explicado no trecho 12. Quando, por exemplo, Ophelia diz a Hamlet a frase acima mencionada, faz com que Hamlet pegue um número inteiro de sua pilha e assuma esse valor.

É claro que, desde que a palavra recallcomece a frase, você pode preencher o resto com praticamente qualquer coisa que sua mente shakesperiana criativa desejar.

Fragmento de comprimento 23

Are you better than me?

Implementação do snippet 6. Quando um "personagem" faz uma pergunta como essa para outro, o que ele está fazendo é equivalente às if (x > y)linguagens de programação mais comuns. O acompanhamento desta instrução deve ser adiado até que eu tenha mais caracteres disponíveis.

Fragmento de comprimento 24

[Enter Romeo and Juliet]

Sim, "caracteres" podem entrar em pares. Não é necessário ter um "personagem" entrando no palco, sendo seguido por outro.

Fragmento de comprimento 25

remainder of the quotient

25 caracteres apenas para escrever a %. 25 caracteres para ter o restante de uma divisão. E para usá-lo? Bem, isso é ainda maior - veja o trecho 75.

Snippet de comprimento 26

Let us return to scene II.

Aqui está, a gotono SPL, que funciona como seria de esperar em uma linguagem de programação. Uma coisa é: você pode pular entre cenas no mesmo ato e entre atos; mas você não pode pular entre cenas em atos diferentes.

Fragmento de comprimento 27

[Exeunt Ophelia and Hamlet]

Quando mais de um "personagem" sai do palco, em vez de Exit, e mantendo a tradição da natureza teatral da SPL, é usada a palavra latina "Exeunt". Às vezes, ele pode ser substituído apenas pelo snippet 8.

Fragmento de comprimento 28

Scene I: Ophelia's flattery.

Declarando uma cena. Como você já pode esperar, se você está lidando comigo, o importante é que Scene I, o resto é fluff artístico.

Alguns compiladores foram criados (como este que compila de SPL para C, escritos em Python ) que, em vez disso, se referem ao texto após a numeração do Ato / Cena. Embora mais lógico (afinal de contas, durante uma peça, ter personagens dizendo frases como "vamos voltar ao Ato I" pode ser considerado bobo)), estou seguindo o caminho original.

Fragmento de comprimento 29

You pretty little warm thing!

Sim, mais uma constante (já que precisamos de muito mais caracteres para ter operações aritméticas). Este é igual a 8, porque 2*2*2*1 = 8.

Fragmento de comprimento 30

You are as cowardly as Hamlet!

Dizendo isso para, por exemplo, Romeu, significa isso Romeo = Hamlet. Como o snippet 9.

Factoid (sim, outro marco alcançado!)

Esse idioma foi criado para uma tarefa em um curso de Análise de sintaxe - portanto, nenhum compilador de SPL foi criado pelos autores. Mais: parece que os autores da SPL cortaram seus laços com a criação, já que nada parece ter sido modificado no idioma desde 2001 ...

Fragmento de comprimento 31

Am I as horrid as a flirt-gill?

Sim, eu sei, é um trecho repetitivo de alguma forma 23, embora, aqui, comparemos o "personagem" que fala com um "flerte" (de, se você preferir if (Ophelia == -1)). A coisa é...

Fragmento de comprimento 32

If so, let us return to scene I.

... agora posso introduzir o thenSPL, o salto condicional e a maneira shakesperiana de implementar loops. Você pode, por exemplo, fazer com que Romeo assuma o valor 0, aumente seu valor enquanto realiza outra tarefa e pare quando ele atingir 10, prosseguindo com o programa posteriormente.

Fragmento de comprimento 33

If not, let us return to scene I.

Apenas um lembrete de que, em vez disso, podemos avançar para outra cena se a condição que testamos for falsa .

Fragmento de comprimento 34

Open your mind! Remember yourself.

Duas instruções seguidas, yippie! O primeiro lê um personagem, o segundo o empurra para a pilha de memória do outro personagem.

Fragmento de comprimento 35

Act I: Death!

Scene I: Oh, shit.

A maneira correta de declarar um ato e uma cena. Adicione mingau artístico com bom gosto.

Fragmento de comprimento 36

Thou art as sweet as a summer's day!

Outra maneira de dizer que o "personagem" que está sendo falado receberá o valor 1- porque os dias de verão são agradáveis ​​e agradáveis.

Fragmento de comprimento 37

Art thou more cunning than the Ghost?

Ophelia fazendo esta pergunta a Hamlet significa traduzi-lo para uma linguagem de programação menos legível if (Hamlet > the Ghost). É o trecho 23 de novo, sim - mas isso mostra que não é necessário perguntar aos "personagens" se eles são melhores que os outros: qualquer outra pergunta também funcionará.

Fragmento de comprimento 38

[Enter the Ghost, Romeo and the Ghost]

Sim, estou chamando um "caractere" duas vezes - porque queria que o programa me desse um erro. Chamar um "personagem" que já está no palco ou dizer a um que está ausente para sair causará grande pesar ao analisador / compilador.

Fragmento de comprimento 39

the sum of a fat lazy pig and yourself!

A instrução completa é mais bonita do que isso, eu vou lhe dar isso, mas ... aqui está a nossa primeira operação aritmética! O que tudo isso significa, na verdade? Bem, pigé um animal sujo (embora saboroso), então é equivalente a -1, tem dois adjetivos, ou fat lazy pigseja , iguais 2*2*(-1) = -4. Mas que tal yourself? É um pronome reflexivo, não é um nome nem um adjetivo. Bem, lembre-se que o SPL é baseado em diálogos entre "caracteres"; assim, yourselfrefere-se ao outro "personagem" no palco. Então, chegamos ao final e descobrimos que "a soma de um porco gordo preguiçoso e você" é, de fato -4 + x,.

Fragmento de comprimento 40

the sum of a squirrel and a white horse.

Sim, outra soma, mas essa é mais simples que o trecho 39. Isso é meramente 1 + 2- 3, se minha matemática estiver correta.

Factoid (ainda comigo depois desses quarenta trechos de cotão artístico? Você merece um prêmio.)

O SPL, em sua versão 1.2.1, pode ser baixado aqui .

Fragmento de comprimento 41

Juliet:
 Speak thy mind!

[Exit Romeo]

Às vezes, "personagens" são chamados apenas no palco para ter seu valor alterado - o que, em uma peça real, seria algo bastante bizarro. De qualquer forma, aqui, Julieta faz seu amado Romeu imprimir seu valor armazenado, depois do qual ele sai do palco.

Fragmento de comprimento 42

Speak YOUR mind! You are as bad as Hamlet!

Novamente, duas instruções em uma linha (podemos ter várias, mas o tamanho do trecho ainda não permite); aqui temos um "caractere" dizendo a outro para produzir seu valor e assumir qualquer valor que Hamlet tenha. Confuso? Talvez.

Snippet de comprimento 43

Am I as horrid as a half-witted flirt-gill?

Juliet perguntar isso não significa que ela tem baixa estima (embora possa na vida real); é simplesmente outra if, como os trechos 23 e 37. Ah, quase esqueci: isso se traduz em if (Juliet == -2).

Fragmento de comprimento 44

You are as evil as the square root of Romeo!

Sim, raízes quadradas são más, você não sabia? De qualquer forma, esta instrução é direta o suficiente para entender o que ela faz: atribui o "caractere" sendo falado ao valor da raiz quadrada do valor armazenado em Romeu.

Fragmento de comprimento 45

Hamlet:
 Art thou more cunning than the Ghost?

Trecho 37, escrito corretamente com o personagem que está falando a linha.

Fragmento de comprimento 46

the product of a rural town and my rich purse.

Ok ... de qualquer maneira, o SPL pode ser o único idioma do mundo que permite multiplicar cidades por bolsas. Isso significa (2*1)*(2*1)que, se não estou muito enganado, é igual a 4.

Fragmento de comprimento 47

Romeo:
 Speak your mind.

Juliet:
 Speak YOUR mind!

Vou lhe dizer isso: pode ser um dos diálogos mais bizarros da história. Mas é o que você ganha quando escolhe um idioma estranho para mostrar. Romeu e Julieta estão dizendo um ao outro, em suma, para produzir seus valores.

Snippet de comprimento 48

You lying fatherless useless half-witted coward!

Traduzindo diretamente 2*2*2*2*(-1),. -16, direito?

Fragmento de comprimento 49

Scene V: Closure.

Hamlet:
 Speak your mind!

[Exeunt]

Um exemplo de como encerrar um programa no SPL. Você pode declarar uma cena especificamente para ela (embora não seja necessária), então Hamlet pede a outro "personagem" que mostre seu valor, e todos eles saem do palco. E sim, é necessário que todos saiam do palco.

Snippet de comprimento 50

Othello, a young squire.
Lady Macbeth, an old fart.

Mais apresentação de "personagem", antes das instruções adequadas. Como sempre, a única coisa que importa para o compilador é Othelloe Lady Macbeth, portanto, o restante da linha está em disputa ...

Mais uma coisa: os "personagens" não precisam estar relacionados entre si para aparecer em um programa de SPL - para que você possa ter Romeu, Othello e Hamlet na mesma peça.

Factoid (meio século dessas coisas? Ufa! Depois disso, acho que vou detestar William Shakespeare ...)

O tradutor de SPL para C, mencionado há pouco e desenvolvido pelos criadores de SPL, foi baseado em Flex e Bison .

Fragmento de comprimento 51

Othello:
 Recall your great dreams. Speak your mind!

(Tão cansado de Romeu, Julieta e Hamlet ... vamos trazer Otelo, para variar!)

Recall, como você pode imaginar, é a chave aqui. O "caractere" que Othello está endereçando terá um valor de sua pilha, assumirá esse valor e, posteriormente, o produzirá.

Snippet de comprimento 52

Thou art as pretty as the sum of thyself and my dog!

Outra soma. Bocejar. Supondo que este seja endereçado a Hamlet, significa isso Hamlet = Hamlet + 1. Or Hamlet += 1. Or Hamlet++.

Snippet de comprimento 53

Romeo:
 You are as vile as the sum of me and yourself!

Ah, sim, algo que eu esqueci de mencionar antes: os "personagens" falantes podem se mencionar em suas próprias falas.

Fragmento de comprimento 54

Juliet:
 Is the sum of Romeo and me as good as nothing?

Outro exemplo do snippet anterior, incluído em uma condição. Então, o que temos aqui é if (Romeo + Juliet == 0).

Fragmento de comprimento 55

Juliet:
 You are as lovely as the sweetest reddest rose.

Então, aqui, Julieta está elogiando o "personagem" com quem está falando (vamos assumir que é Romeu, pelo amor de Shakespeare), declarando que ele tem 4 anos. Sim, outra atribuição de valores.

Fragmento de comprimento 56

Othello:
 You lying fatherless useless half-witted coward!

Trecho 48 feito corretamente, com um "caractere". Se você estiver com preguiça de rolar para cima (como eu seria), isso significa que aquele que está sendo insultado está recebendo o valor -16.

Fragmento de comprimento 57

Romeo:
 If not, let us return to Act I. Recall thy riches!

Eu já expliquei como as condições funcionam no SPL em geral; no entanto, é necessária uma análise mais interna. Não temos elseaqui: por exemplo, neste exemplo, se a condição falhar, o programa retornará ao Ato I; mas se fosse verdade, continuaria para a próxima instrução, que é um Recall- um pop da pilha, ou seja.

Fragmento de comprimento 58

Romeo:
 You are as disgusting as the square root of Juliet!

Agarrando o trecho 44 e apresentando como a instrução deve ser apresentada. Se esse era um diálogo entre Romeu e Othello, poderíamos traduzir isso para Java como Othello = Math.sqrt(Juliet).

Fragmento de comprimento 59

Othello:
 You are as vile as the sum of yourself and a toad!

OK, se Otelo estiver conversando com Romeu, isso seria equivalente a Romeo+(-1); Romeo--, abreviado. Bem básico, certo? Isso é SPL para você.

Fragmento de comprimento 60

Is the quotient between the Ghost and me as good as nothing?

Para resumir, if (The Ghost/Hamlet == 0)supondo que o "eu" pertença a Hamlet.

Fragmento de comprimento 61

Thou art as handsome as the sum of yourself and my chihuahua!

Depois de separar as camadas e camadas de palavras e insultos, você percebe que o SPL é basicamente uma coisa básica, sem funções e coisas interessantes. Portanto, temos muitas funções aritméticas no corpo do programa. Portanto, se este fosse endereçado a Juliet, seria equivalente a Juliet++.

Fragmento de comprimento 62

twice the difference between a mistletoe and a oozing blister!

Sim, sim, mais operações aritméticas. Aproximadamente, esses 62 bytes de SPL podem ser traduzidos para 2*(1-2*(-1)). Essa seria uma linguagem incrível de golfe, certo? Direito.

Fragmento de comprimento 63

You lying stupid fatherless rotten stinking half-witted coward!

Trecho de 48 emitido -16, este é igual a -64: 2*2*2*2*2*2*(-1).

Fragmento de comprimento 64

your coward sorry little stuffed misused dusty oozing rotten sky

Pelo que entendi da SPL, isso é perfeitamente legítimo. Você tem muitos adjetivos insultuosos que fazem um substantivo "positivo". Como os adjetivos não têm distinção especial, sejam negativos ou não (seu único valor é multiplicar o número à direita por dois), podemos ter sentenças completamente tolas como essa. O que equivale a 256. Porque 2*2*2*2*2*2*2*2*1=256.

Fragmento de comprimento 65

You are nothing! You are as vile as the sum of thyself and a pig.

Hmm, tanto ódio, não é? Então, o que temos aqui é equivalente a y=0; y=y+(-1);Provavelmente poderia ter sido "jogado" You are a pig!, mas heh.

Fragmento de comprimento 66

You are as beautiful as the difference between Juliet and thyself.

Então subtraia Juliet de si mesmo, hein? Esse é bem simples de decodificar: Romeo=Juliet-Romeo;supondo que Romeo esteja sendo chamado.

Fragmento de comprimento 67

Juliet:
 Am I better than you?

Romeo:
 If so, let us proceed to Act V.

Como a maioria das condições funciona no SPL. Você testa a expressão e, se for verdadeira (ou não: veja o trecho 33), pula para outra parte do programa; caso contrário, você continuará para a próxima frase.

Snippet de comprimento 68

The Ghost:
 You are as small as the sum of yourself and a stone wall!

Sim, sim, estou ficando um pouco monótono. Mas SPL é assim. Como afirmei um pouco antes, suas expressões são uma mistura de operações aritméticas. Portanto, este é mais um incremento - já que stone wallé um "substantivo" neutro.

Fragmento de comprimento 69

Thou art as disgusting as the difference between Othello and thyself!

Em vez de uma soma, temos a subtração entre dois caracteres, Othello e quem está sendo falado.

Fragmento de comprimento 70

You are as handsome as the sum of Romeo and his black lazy squirrel!

Voltamos às adições, sim - me chame de fórmula, heh. Nós traduzimos isso para Romeo + 2*2*1.

Fragmento de comprimento 71

Scene I: Dialogues.

[Enter Juliet]

Othello:
 Speak your mind!

[Exit Juliet]

Uma cena pode ser tão pequena quanto esta. Julietentra no palco, Othello diz a ela para produzir seu valor armazenado e depois sai do palco novamente.

Fragmento de comprimento 72

twice the difference between a mistletoe and an oozing infected blister!

Mais uma operação aritmética - porque o SPL está cheio deles. Podemos traduzir isso para 2*(1-2*2*(-1)).

Fragmento de comprimento 73

You are nothing! Remember me. Recall your unhappy story! Speak your mind!

Quatro instruções seguidas ?! Estou bastante orgulhosa de mim mesma, na verdade. De qualquer forma, vamos assumir que este é um diálogo entre Romeu e Julieta (e ele está falando): isso significa que o valor de Julieta começa em 0; então, Julieta colocará o valor de Romeo em sua pilha de memória, exibirá e exibirá na forma inserida. Simples, certo?

Fragmento de comprimento 74

You are as sweet as the sum of the sum of Romeo and his horse and his cat!

Sim, sim, exemplo chato, eu sei. Mas é isso X = (Romeo + 1) + 1.

Fragmento de comprimento 75

Is the remainder of the quotient between Othello and me as good as nothing?

Bem, isso é bem direto. Se suas habilidades de decodificação estiverem com defeito, isso será traduzido para if (Othello % X == 0).

Fragmento de comprimento 76

Thou art as rich as the sum of thyself and my dog! Let us return to scene I.

O salto do trecho 26 com uma expressão antes dele. Um gotono SPL nem sempre é encontrado perto de uma condição, pode ser assim - e, é claro, esse tipo de gotosempre será encontrado no final de um ato ou cena, pois as instruções depois nunca serão compiladas / executadas. A primeira instrução é bastante simples: x=x+1.

Snippet de comprimento 77

[Exit Hamlet]

[Enter Romeo]

Juliet:
 Open your heart.

[Exit Juliet]

[Enter Hamlet]

Então, temos Juliet e Hamlet no palco; mas precisamos do valor de Romeu. Assim, para poupar o compilador de uma dor de cabeça muito desagradável, primeiro removemos Hamlet do palco (embora possa ter sido Julieta), pedimos a Romeu para subir no palco, Juliet lhe dá uma instrução para produzir uma número (veja a explicação do trecho 21), Romeo sai do palco e Hamlet retorna. Bem direto e simples.

Fragmento de comprimento 78

The Ghost:
 Speak thy mind.

Lady Macbeth:
 Listen to thy heart! Remember thyself.

Então, The Ghost (o falecido pai de Hamlet) está dizendo a Lady Macbeth para mostrar seu valor, enquanto ela ordena que The Ghost leia um número e o empurre para sua pilha.

Piet

Factóide

Piet é uma linguagem de programação em que o código fonte consiste em imagens. O fluxo do programa começa com o pixel superior esquerdo e move-se pela imagem entre pixels e grupos de pixels até terminar.

Para legibilidade, os programas Piet são geralmente exibidos em uma versão ampliada. Nesse caso, o termo codelé usado para descrever um grupo de pixels da mesma cor que corresponde a um pixel individual na imagem de origem.

Para esse desafio, como Piet não usa caracteres, um codel por voto será usado para programas de amostra.

1 codel

Este é um programa válido, não faz nada e termina. O fluxo de controle inicia no pixel superior esquerdo (apenas) e não tem saída, o que encerra o programa.

Nesse caso, o pixel pode ter qualquer cor para o mesmo efeito.

2 Codels

Isso lerá continuamente os caracteres do stdin e manterá um total em execução de seus valores unicode (embora nada seja feito com esse total e ele não seja exibido).

O fluxo do programa progride para frente e para trás entre os 2 codelos, pois a única saída de cada um é para o outro. Os comandos no piet são executados pelo movimento de um codel ou região para outro, dependendo da diferença de tonalidade e leveza das 2 regiões. O inputé o comando que se move da esquerda para a direita e, em seguida, da adddireita para a esquerda. No primeiro addcomando, nada acontecerá, pois existe apenas um valor na pilha, e a especificação diz que os comandos sem valores suficientes disponíveis são ignorados.

Este programa é um loop que nunca termina, pois a maioria dos programas para piet tem tamanhos extremamente pequenos, pois são necessários pelo menos alguns codels para "capturar" corretamente o fluxo do programa e finalizá-lo.

3 Codels

Este é um programa básico do tipo eco, ele lê um caractere de cada vez do stdin e o imprime no stdout.

Novamente, este é um loop infinito. O programa começa viajando da esquerda para a direita, o que faz inputentão output. O programa continuará fluindo na mesma direção sempre que puder. No codel verde claro, a única saída é começar a voltar para o outro lado. Ao voltar da direita para a esquerda, ele tenta executar subtracte addcomandar, mas a pilha está vazia e, portanto, torna-se não operacional.

4 Codels

Imprime 2 para stdout indefinidamente.

Não é um programa particularmente interessante funcionalmente, mas agora que finalmente temos um número composto de codelos, podemos mostrar um fluxo um pouco mais avançado do que da esquerda para a direita. Quando o fluxo do programa tenta sair de um codel, ele primeiro tenta a direção atual. Se não puder (neste caso devido à borda da imagem), ele gira 90 graus no sentido horário e tenta sair novamente. Nesse caso, o programa gira no sentido horário 1 codel de cada vez, inserindo push1 na pilha duas vezes, addunindo os dois e, em seguida, outputobtendo o resultado.

5 codels

Lê repetidamente um caractere de cada vez a partir de stdin e rastreia a soma de seus valores unicode.

Essa é essencialmente a mesma funcionalidade da versão de 2 códigos, mas esse desafio é mostrar a linguagem, e uma das coisas legais da piet é como você pode ter imagens de aparência diferente que fazem a mesma coisa.

Aqui vemos o codel branco pela primeira vez, o que permite que o fluxo do programa deslize por ele sem executar instruções. Os codels magenta e azul fazem todo o trabalho aqui. Viajar de azul para vermelho não faz nada porque cruza o codel branco no meio. Os 2 vermelhos são apenas pusho número 1 na pilha e poprecuam à medida que viaja da esquerda para a direita, da direita para a esquerda e através do codel branco, para que nenhuma instrução seja executada.

6 Codels

Mais uma vez, repetindo a funcionalidade anterior com uma aparência diferente. Este é outro programa de eco que lê um caractere de cada vez, de stdin a stdout.

Aqui vemos o nosso primeiro codel preto. O fluxo do programa não pode entrar em um codel preto; portanto, a partir do codel magenta claro na parte superior direita, o programa falhará ao sair da direita devido à borda da imagem, falhará ao sair do codel preto e retornará à esquerda no codel vermelho . Os codels azul e verde são puramente decorativos, o programa nunca entrará neles.

7 Codels

Mais um programa de eco com uma aparência diferente.

Aqui vemos nossos primeiros blocos de codel maiores que o tamanho 1. Na piet, qualquer bloco contíguo de codéis da mesma cor é tratado como um único bloco. O tamanho do bloco não importa, exceto na execução da pushinstrução, portanto, este programa é tratado exatamente como a versão de 3 códigos, exceto com cores diferentes.

8 Codels

Lê um número de stdin e gera o quadrado para stdout, repetidamente.

O fluxo de controle é um padrão básico no sentido horário, como no programa de 4 códigos. A partir do canto superior esquerdo, as operações na ordem são input, duplicate(empurra uma cópia extra do valor superior da pilha para a pilha), multiply, output. Em seguida, ele coloca pusho valor 1 na pilha, desliza pelo branco para que nenhum comando seja executado e, então, popé o 1 fora da pilha ao passar do codel inferior esquerdo para o superior esquerdo. Isso o retorna ao início do programa com uma pilha vazia e se repete.

9 Codels

Adiciona 1 + 2 = 3 e termina.

Agora que temos um programa com mais de 2 codelos em ambas as dimensões, podemos finalmente configurar uma região que irá interceptar o programa e finalizá-lo em vez de repetir para sempre. A primeira operação movendo-se do codel vermelho para a região vermelha escura é a pushde 1, o programa gira e flui para o codel vermelho claro no meio e pushes um valor de 2. Fluindo do vermelho claro para o amarelo claro é executado uma addoperação. A barra amarela clara inferior faz com que o programa termine, pois não há como fluir, pois todos os cantos estão bloqueados.

Os programas de 1 e 2 altos estão rapidamente se tornando feios e desinteressantes, de agora em diante, vou me concentrar em números que permitem pelo menos alguns codels em cada direção.

12 Codels

Finalmente, um programa que faz algo que pode ser considerado útil (embora ainda seja um pouco exagerado). Lê 2 números de stdin sequencialmente e, em seguida, gera sua soma, e faz isso repetidamente.

O programa flui da esquerda para a direita pelas 4 barras coloridas perfoming 2 inputsseguidas por um addcomando. Em seguida, ele se move para o codel inferior direito e executa um outpute, em seguida, segue para a esquerda na região branca de volta ao início.

Isso poderia ter sido feito em 8 codels, mas como temos espaço extra, podemos criar algo um pouco inspirado em uma tela de TV antiga sem sinal.

15 Codels

Lê um número de stdin e gera seu quadrado.

Isso usa alguns truques para obter uma aparência simétrica de um programa que realmente faz alguma coisa. A barra vermelha mais à esquerda tem uma cor diferente no codel inferior do que as demais, aproveitando o fato de que (pelo menos para mim) esses dois tons de vermelho parecem muito semelhantes. o programa passará da região vermelha mais clara para o codel azul claro e depois atravessará o meio do programa até o verde claro no lado direito onde está preso. Ele executa input, duplicate, multiply, e outputoperações.

O codel vermelho mais escuro, junto com os codels verdes médios na parte superior e inferior da coluna do meio, são decorativos e o programa nunca os alcançará.

20 Codels

Lê números de stdin até que um 0 seja lido; nesse momento, ele gera a soma de todos os números inseridos e sai.

Finalmente, temos espaço suficiente para controlar o fluxo na forma da pointeroperação. Os 4 codels ao longo do topo executar input, duplicatee notoperações, e, em seguida, uma outra notoperação de movimentação do magenta no canto superior direito de amarela em baixo, o 2-CODEL. A notoperação retira o valor superior da pilha e envia 1 se o valor superior for 0 e 1 caso contrário. Portanto, a notsubstitui duas vezes qualquer valor diferente de zero por 1. Mover da barra amarela para o azul escuro executa uma pointeroperação, que retira o valor superior da pilha e move o ponteiro de direção no sentido horário muitas vezes.

Se o valor superior for 1 (ou seja, não inserimos zero), o ponteiro de direção apontará para a esquerda, passando para os codelos magenta para uma addoperação (que será ignorada pela primeira vez devido a apenas um valor na pilha) e depois, pelo branco, de volta ao início do programa.

Se o valor superior da pilha for zero na operação do ponteiro, o ponteiro de direção não será alterado e o programa continuará para baixo. Passando para a faixa azul mais clara, popo 0 foi inserido fora da pilha, deixando apenas a soma dos números acumulados. Mover para a barra ciana na parte inferior irá outputsomar e terminar, pois o fluxo do programa está bloqueado.

25 Codels

Contagem regressiva! Lê um número de stdin e, em seguida, imprime uma contagem regressiva para 1 para excluir um número de cada vez. Por exemplo, se 5 for lido, imprimirá 54321.

A primeira operação de ciano a amarelo é o input. Então o amarelo é onde o programa "loop" começa. Amarelo> Magenta> Azul é um duplicatee output, portanto, imprime o valor superior na pilha, mas mantém uma cópia. Movendo-se para o lado direito, colocamos pusho valor 1 na pilha e, em seguida, executamos a subtraction, diminuindo o valor inserido em 1. Em seguida duplicate, é not, e outro notmovendo-se da magenta clara no canto inferior direito para o amarelo escuro ao lado. Essa é a mesma verificação de zero / diferente de zero do programa anterior. Mover para a esquerda no codel azul claro executa uma pointeroperação que se move para a esquerda no ciano escuro para finalizar o programa, se terminar, ou até o amarelo para reiniciar o loop sem a entrada inicial, mas o valor original diminuiu por 1.

Todos os três codels vermelhos são decorativos e podem ter qualquer cor.

30 Codels

Gerador de Fibonacci. Imprime os termos da sequência de Fibonacci para stdout e não para.

Esta é a primeira introdução do rolloperador, bem como a primeira vez que um tamanho de região maior que 1 é usado com o pushoperador para obter um valor específico na pilha.

Como sempre começa no canto superior esquerdo, movendo-se para a direita. As duas primeiras operações operam pushum 1 na pilha e, depois output, a partir da sequência de Fibonacci começa com dois 1s, mas o loop principal do programa imprime apenas 1 uma vez. Em seguida, são push2 mais 1s na pilha para terminar na magenta escura no canto superior direito para iniciar o loop principal do programa.

Movendo-se para o lado direito we duplicatee outputpara imprimir o próximo termo da sequência, duplicatenovamente para obter uma cópia do valor atual da sequência. Mover para a esquerda na parte inferior executa 2 pushoperações. Como a região vermelha clara no canto inferior direito tem 3 codels de tamanho, o primeiro pushcolocará um 3 na pilha em vez de um 1.

Mover para o azul claro é uma rolloperação. Isso mostra os 2 principais valores da pilha e executa um número de jogadas igual ao primeiro valor exibido, a uma profundidade igual ao segundo valor exibido. Nesse caso, ele executará 1 rolo até uma profundidade de 3. Um rolo para profundidade npega o valor superior da pilha (nosso valor atual duplicado) e enterra-o nprofundamente. Nossa pilha tem apenas 3 de profundidade no momento, então enterrará o valor superior na parte inferior.

Mover para cima mais uma vez executa uma addoperação que soma o valor atual da sequência com o valor anterior. Nossa pilha agora tem o próximo (nova corrente) valor de sequência no topo e o último valor abaixo dele. O programa agora se move através do branco para a magenta escura para iniciar o loop novamente.

O padrão amarelo no meio nunca é usado.

54 Codels

Imprime "oi!" stdout

Não é uma mensagem particularmente longa, mas imprimir em piet exige uma quantidade surpreendente de espaço. A impressão é feita usando valores unicode e os números inteiros são enviados para a pilha usando o tamanho da região que está sendo encerrada. Como temos um número muito limitado de codelos para esse desafio, usamos algumas contas para chegar ao intervalo imprimível que queremos.

O programa começa com um pushde 5 da região ciana à esquerda. A partir daqui, ele flui ao longo do topo com 6 duplicateoperações para preparar a pilha com um monte de 5s. Em seguida é push1, subtractpara colocar um 4 no topo da pilha, depois 2 multiplyoperações para colocar 4 * 5 * 5 = 100 no topo da pilha. Então um duplicatepara 2 100s.

Agora o programa ricocheteia no preto e começa a trabalhar para a esquerda na parte inferior. Pushoperações de 3 e 2 e, em seguida, a rollpara enterrar os 2 100s sob um 5. A seguir push, 1, subtraia e adicione para obter 100 + 5-1 = 104 no topo da pilha, que é o unicode "h". As próximas 2 operações são push1, pointerpara virar a esquina e começar a se mover para a direita no meio e, em seguida, outputimprimir "h".

A seguir, add100 + 5 = 105 no topo da pilha e outputpara imprimir "i". A pilha agora contém dois 5s. Push1, add, multiplyobtém-se (1 + 5) * 5 = 30. Finalmente push3 e add33, e outputno final "!". O programa passa pelo espaço em branco restante para terminar em verde à direita.

> <> (Peixe)

(Observação: alguns trechos são criados com base nos trechos anteriores. Portanto, diferentemente da maioria das respostas, decidi colocá-las do mais antigo para o mais recente.

Factóide:

Como o Befunge,> <> é uma linguagem 2D baseada em pilha. Isso significa que as instruções não são executadas linearmente como a maioria das linguagens tradicionais - o fluxo do programa pode ser superior, inferior, esquerdo ou direito!

Fragmento de comprimento 1:

X

Xé um comando inválido em> <>; portanto, a mensagem de erro something smells fishy...é impressa. De fato, esta é a única mensagem de erro em> <>, seja a causa ser dividida por zero ou tentando exibir uma pilha vazia.

Fragmento de comprimento 2:

1n

O fluxo do programa em> <> começa no canto superior esquerdo e é inicialmente para a direita. 1coloca um 1 na pilha e depois o nimprime como um número (em vez de um caractere ASCII). Mas os programas são toroidais, o que significa que o ponteiro da instrução se volta quando chega ao final de uma linha. Então, depois de nembrulharmos para o começo, pressione 1, imprima, embrulhe para o início, pressione 1, imprima ... e acabamos imprimindo 1s para sempre!

Fragmento de comprimento 3:

"o;

Aqui "está a análise de string, é oexibida como um caractere ASCII e ;finaliza o programa. Mas o que o programa realmente faz como um todo?

Bem, primeiro começamos a análise de strings, pressionando todos os caracteres que vemos na pilha até encontrarmos um fechamento ". Nós pressionamos um o, depois um ;... e envolvemos o ponteiro de instruções de volta ao início. Mas agora estamos em um "modo que parar análise de cadeia e, finalmente, executar o oe ;como normal para imprimir o topo da pilha (a ;) e terminar.

Sim, acabamos de usar o mesmo caractere de cotação para iniciar e terminar uma string!

Fragmento de comprimento 4:

42n;

Com base no que vimos até agora, você pode esperar que isso pressione 42, a saída como um número e depois termine. Mas todas as instruções em> <> são caracteres simples, então, na verdade , isso gera um 4 e um 2 , em seguida, gera a parte superior da pilha como um número (apenas o 2) e termina.

Fragmento de comprimento 5:

<v
;>

Lembre-se,> <> é uma linguagem 2D. Isso significa que deve haver maneiras de mudar a direção do fluxo do programa!

Como o Befunge, uma maneira de fazer isso é através das setas >^v<. Para ilustrar como eles funcionam, vejamos o programa acima:

• O fluxo do programa é inicialmente para a direita
• < faz o programa fluir para a esquerda - nós saímos pela esquerda e enrolamos no v
• v faz o programa fluir para baixo - descemos para o >
• > faz o programa fluir para a direita - saímos da direita e envolvemos o ;
• Finalmente, terminamos.

Fragmento de comprimento 6:

";"00p

Outro recurso interessante de> <> é que é reflexivo - o programa pode modificar seu próprio código-fonte em tempo real!

Aqui pressionamos a ;, seguido de dois zeros. pem seguida, aparece os três principais elementos y, x, v( ysendo a parte superior da pilha) e coloca vna posição x,y. Em outras palavras, o pneste programa coloca um ponto e vírgula na posição 0,0, transformando o código em ;;"00p. Isso permite que o programa seja finalizado, pois o ponteiro da instrução agora envolve e executa o recém-colocado ;.

Fragmento de comprimento 7:

\7*n;
6

Assim como o Befunge,> <> também possui espelhos ( \/|_#) que refletem a direção do fluxo do programa. Então aqui nós:

• Comece para a direita, mas isso nos \reflete para baixo
• Empurre um 6 e envolva
• Bata na parte de trás do \e reflita de volta para a direita
• Empurre um 7
• Multiplique os dois primeiros da pilha
• Saída e término

Mover horizontalmente através de um _espelho ou verticalmente através de um |espelho não é uma opção.

Fragmento de comprimento 8:

"r00g>o<

Muito possivelmente, a mais simples> <> quine se for permitido que um erro seja gerado. As duas novas instruções aqui são:

• r: Inverter a pilha
• g: Get - pop y, xe empurre o caractere na x,yna pilha (contrapartida p)

Usando o truque de quebra de cadeia de antes, o programa empurra inicialmente e r00g>o<depois pressiona a primeira citação novamente. A pilha é então invertida, dando <o>g00r. Depois disso, pressionamos o caractere 0,0, o ", para dar <o>g00r". Finalmente, capturamos uma oentre duas setas, gerando a parte superior da pilha até que não sobrar nada e cometer um erro.

Fragmento de comprimento 9:

x0\>
\1n>

x(minúscula) move o ponteiro da instrução em uma direção aleatória, e o programa mostra essa funcionalidade imprimindo bits aleatórios para sempre. Tente seguir as setas e espelhos para descobrir como isso funciona! (Não se esqueça de verificar todas as quatro direções, inclusive para cima e para a esquerda)

Fragmento de comprimento 10:

;a comment

Não há sintaxe para comentários em> <> - ele não precisa de um. Basta escrever o que deseja em qualquer lugar e garantir que ele não seja executado como código!

Fragmento de comprimento 11:

1!X2!X+!Xn;

!é um trampolim que pula as instruções. É particularmente útil quando usado com ?, um trampolim condicional que aparece no topo da pilha e executa a próxima instrução se o elemento popped for diferente de zero. Veremos como isso funciona mais tarde.

O código acima imprime 3 saltando sobre Xs, apenas executando 1! 2! +! n;.

Fragmento de comprimento 12:

01v
ao>:@+:n

Imprime os números de Fibonacci para sempre a partir do segundo 1, um em cada linha. Os novos comandos são:

• a: Pressione 10, necessário para a nova linha. a-fpressione 10 para 15, respectivamente.
• :: Topo duplicado da pilha
• @: Gire os três principais elementos da pilha, por exemplo [5 4 3 2 1] -> [5 4 1 3 2].

Rastreio para as primeiras iterações:

Fragmento de comprimento 13:

i:d=?v
l?!;o>

Um programa "tac" que lê em uma linha de entrada e produz reversa. Obrigado a @tomsmeding pelo snippet.

=exibe os dois principais elementos e pressiona 1 se forem iguais, 0 caso contrário. A primeira linha continua lendo a entrada até que o caractere ASCII 13 (retorno de carro) seja encontrado; nesse ponto, ele se move para a segunda linha.

O l?!;oloop é uma construção importante em> <> que gera a pilha inteira. Ao contrário >o<, não causa erros. É assim que funciona:

• l empurra o comprimento da pilha
• Verificamos o comprimento com ?:
  • Se o comprimento for diferente de zero, a próxima instrução !será executada, pulando o;
  • Se o comprimento for zero, não executamos !nem terminamos devido ao;

Observe que nenhuma saída realmente acontece até que você atinja o retorno de carro.

Fragmento de comprimento 14:

32.

   X67*n;

Além de alterar a direção do fluxo do programa, você pode realmente mover o ponteiro de instruções para onde quiser!

.pops y, xe se teletransporta o ponteiro de instrução para x,y, mantendo direção. Observe, no entanto, que você precisa mover para um quadrado antes de onde deseja ir - o ponteiro da instrução é atualizado antes da execução da próxima instrução. Portanto, aqui o ponteiro de instrução é inválido X, mas tudo está bem, pois o ponteiro se move para a 6execução antes de continuar.

.torna possível converter a maioria dos programas em uma linha, mas por que você quer perder a diversão do 2D? :)

Fragmento de comprimento 15:

01+:aa*=?;:nao!

Imprime os números 0para 99, um em cada linha. Este programa demonstra um uso limpo do !trampolim - para garantir que o 0 inicial seja pressionado apenas uma vez.

Fragmento de comprimento 16:

"r00g!;oooooooo|

Um quine adequado que não gera erros, inspirado no quine na página esolang .

Se você se perguntou sobre como modificar o quine anterior (snippet # 8) para que não causasse um erro e pensasse "por que não adiciono apenas uma tonelada de oinstruções?", Talvez você perceba que a cada oadição , você precisa produzir outro o! Essa solução resolve o problema colocando um |espelho no final, que permite que cada um oseja usado duas vezes .

Se mudarmos para aspas simples (que também são para análise de string), uma alternativa alternativa que não use gé

'r3d*!;oooooooo|

Fragmento de comprimento 17:

b2,63,.

   17,n;

Temos adição ( +), subtração ( -), multiplicação ( *), módulo ( %) ... mas e a divisão? Está lá, mas como /já é um espelho, foi atribuído o ,símbolo à divisão . Curiosamente, divisão é divisão flutuante , não divisão inteira!

O programa acima explora algum comportamento indefinido, tentando pular para 11/2, 6/3. O intérprete Python parece bom se a primeira coordenada não for um número inteiro (embora pule para o ponto errado), mas sufoque se o segundo não for.

Fragmento de comprimento 18:

123456${{$}nnnnnn;

Vimos rque inverte a pilha e @que gira os três principais elementos. Aqui estão mais alguns comandos que movem elementos na pilha:

• $: Troque os dois principais elementos
• {: Deslocar toda a pilha para a esquerda
• }: Deslocar toda a pilha para a direita

Para mostrar como isso funciona, aqui está o rastreio do programa:

123456 ------> 123465 ------> 234651 ------> 346512 ------> 346521 ------> 134652
       $ Swap        { L shift      { L shift       $ Swap        } R shift

Então nós produzimos, dando 256431.

Fragmento de comprimento 19:

"reward"4[roooo]oo;

Até agora eu venho dizendo "a pilha", "a pilha" ...

Embora a maioria dos programas use apenas uma pilha,> <> pode realmente ter várias pilhas! Aqui estão as instruções relevantes:

• [: Abre xe move os xelementos principais para uma nova pilha
• ]: Remove a pilha atual e move seus valores para a pilha subjacente.

Aqui está o rastreamento para o programa acima:

       [r e w a r d]       Push "reward"
4[     [r e] [w a r d]     Move four elements to a new stack
r      [r e] [d r a w]     Reverse the current stack
oooo   [r e] []            Output "ward"
]      [r e]               Remove the current stack, no values to move
oo     []                  Output "er", giving "warder" altogether

Observe que, basta pressionar rewarde, em seguida, enviá-lo novamente com ooooooseria impresso drawer, devido à natureza "primeiro a entrar, último a sair" das pilhas.

Fragmento de comprimento 20:

aa*5+\
7a*2+\
oo;  \

Um recurso pouco conhecido de> <> é que, como Python, as barras invertidas podem ser usadas para a continuação da linha em muitos casos. *

O código acima é funcionalmente o mesmo que

aa*5+7a*2+oo;

^{* Isenção de responsabilidade: a razão pela qual isso funciona pode ou não ser por uma razão completamente diferente}

Fragmento de comprimento 22:

1&fv ;n&<
&1->:0=?^:&*

Além das pilhas,> <> também possui registradores (um para cada pilha) que podem ser usados ​​para armazenar valores. Ligar &pela primeira vez move o valor superior da pilha para o registrador e a execução &novamente move o valor de volta. Isso pode ser muito útil ao acumular um valor, por exemplo, somas e fatoriais.

O programa acima calcula o fatorial de f(15), imprimindo 1307674368000. Aqui está o rastreio para fsubstituído por 4:

Fragmento de comprimento 24:

"Hello, World!"rl?!;of0.

Temos caracteres suficientes para o programa favorito de todos! Aqui usamos o .teleportador para o loop de saída.

Fragmento de comprimento 25:

0i:0(?v$a*$"0"-+!
   ;n~<

Infelizmente> <> apenas permite a leitura de STDIN um caracter por vez, o que torna a leitura em números um pouco complicada. Para entrada que consiste nos dígitos 0-9, este programa é essencialmente atoi, convertendo uma sequência de dígitos de STDIN em um número na pilha (que é então impressa).

Outra observação é que, no EOF, iempurra -1 na pilha. Isso facilita a verificação do EOF, comparando com 0 usando (, ou "menor que".

Esse snippet também usa ~, que abre e descarta o elemento superior da pilha.

Fragmento de comprimento 33:

i>:nao:1=?;\
 ^  ,2v?%2:/
 ^+1*3<

Até agora, a maioria dos trechos eram relativamente lineares ou eram apenas exemplos simples que demonstravam a funcionalidade de> <>. Agora, posso dar um exemplo que destaca como é fácil visualizar o fluxo do programa em> <> com um programa bem definido.

O programa lê um único caractere ASCII e executa o 3x+1algoritmo em seu ponto de código (em> <>, os caracteres são basicamente números inteiros). Cada etapa do algoritmo é impressa até atingirmos 1.

Aqui está um rastreio para as primeiras iterações com entrada a(ponto de código 97):

Fragmento de comprimento 44:

a&>i:0(?v"+"$\
/&^?=0l< "a*"/
\:1+&2p/\0
n
;

Não acho que tenha feito pjustiça ao comando, tendo usado apenas uma vez no trecho # 6, então aqui está uma função atoi diferente. O que é legal sobre este? O programa grava a expressão necessária para calcular o número enquanto lê a entrada!

Assim, para entradas como 573, depois que todos os caracteres forem lidos, o final da terceira linha será semelhante \0a*5+a*7+a*3+, que é avaliado em 573!

Mais uma vez, espera-se que a entrada seja apenas dígitos. Trace GIF aqui .

Fragmento de comprimento 74:

>i:'A'(?v:'N'(?v:'['(?v\
  :'a'(?v:'n'(?v:'{'(?v\
^      o<    +d<  -d-d<o

Se você conseguiu chegar até aqui, pode concordar comigo quando digo que este é um programa ROT13 muito legível. Dado um caractere c1, encontramos o primeiro caractere c2em AN[an{, de modo que c1 < c2, em seguida, aplique o deslocamento apropriado adicionando / subtraindo d(13). Observe que [e {são os caracteres diretamente após Ze zrespectivamente.

Experimente no console e observe as letras se transformarem enquanto você digita!

^{(Você também pode canalizar a entrada, mas como falta a verificação EOF, :0(?;ela pára com um erro ao tentar imprimir -1 como um caractere)}

C - editar

Obrigado pelos votos! Quando comparado com outros idiomas e o que eles podem fazer em bytes limitados, C parece obsoleto, exigente e muito dependente do desenvolvedor. De várias maneiras, é o seguinte: linguagens de script e de nível superior com gerenciamento automático de memória são muito mais expressivas e mais rápidas de produzir do que C jamais será.

Então, por que o recurso C?

O segredo oculto por trás de todas essas linguagens de script é que os intérpretes provavelmente são escritos em C (ou mais recentemente, C ++ ou Java). Os primeiros compiladores C ++ realmente compilados no código C. De fato, até que haja um mercado para um compilador direto, geralmente é mais econômico escrever um compilador para gerar C e depois compilá-lo.

Se você está trabalhando em plataformas muito pequenas, talvez até sem um sistema operacional disponível, provavelmente está trabalhando em C. Atualmente, praticamente todos os dispositivos têm um microcontrolador embutido, sem dúvida programado em C. Quando eles precisam pequeno e rápido, C é o caminho a percorrer. (Também em quarto lugar, para os masoquistas.)

Conhecer C leva você o mais perto possível do metal sem entrar no assembler e ajuda em outros idiomas. Você tem uma boa idéia de como uma função virtual C ++ provavelmente funciona. Você sabe quando você escreve essas funções recursivas de passagem por valor no PHP, que internamente está fazendo muita alocação e cópia de memória, então você instintivamente tenta passar por referência. Retornos de chamada e referências não assustam os desenvolvedores de C, talvez Haskell o faça.

Como Kernighan e Ritchie mencionaram em seu prefácio da clássica linguagem de programação C , 2ª edição, C não é uma linguagem grande e não é bem servida por um grande livro. Estou tentando seguir este conselho: exemplos de serviço duplo, triplo ou mais, se possível.

Todos os trechos são pelo menos compiláveis ​​por conta própria. Aqueles que são vinculáveis ​​e executáveis ​​são indicados como tal. Eu sei que isso não é um requisito, mas torna mais simples do que tentar explicar a estrutura necessária para fazer qualquer snippet de código funcionar.

Também tentei garantir que cada trecho de código fosse o mais curto possível, para que eu não introduzisse espaços extras apenas para preencher um determinado comprimento. Nos casos em que o código é recuado, os recuos não são incluídos no comprimento, apenas um caractere para cada nova linha.

Factóide

C balança.

Snippet de comprimento 0

O programa de auto-reprodução mais curto do mundo http://www.ioccc.org/1994/smr.hint

Fragmento de comprimento 1

;

C faz uma distinção entre compilar e vincular. Muitas entidades em C são compiladas e vinculadas posteriormente - um exemplo são todas as bibliotecas estáticas e dinâmicas.

Outras entidades são incluídas e não geram código por si mesmas.

O ponto e vírgula acima certamente será compilado no código do objeto e não fará nada!

Fragmento de comprimento 2

x;

C, sendo uma linguagem de programação mais antiga, passou por várias iterações. O primeiro em uso generalizado foi desenvolvido por Kernighan e Ritchie e abreviou K&R. A K&R C é notável por fazer muitas suposições sobre seu código, se você não as fornecer explicitamente.

Em particular, em K&R C, o código acima é considerado um número inteiro global xinicializado como 0. Compilá-lo no modo K&R produzirá um arquivo de objeto que fornece a qualquer programa que vincule essa variável a seu uso.

Fragmento de comprimento 3

??/

C é tão difundido que precisa fornecer recursos de compatibilidade para sistemas que não possuem todos os caracteres usados. A descrição acima é um trigrafo para a barra invertida, usada em C como caractere de continuação de linha. O acima será compilado, provavelmente com um aviso de que não há uma linha a seguir.

Uma cultura comum em C é ignorar os avisos de compilação, e muitas bases de código grandes invariavelmente têm alguns ou mais avisos quando estão sendo construídos.

Fragmento de comprimento 4

f();

Novamente com K&R, o acima é "preenchido" para significar, mediante a compilação, que "Existe, com ligação global, uma função fa ser fornecida posteriormente, que pega um número fixo mas não especificado de argumentos e retorna um número inteiro".

Observe as diferenças fundamentais entre isso e f;.

Fragmento de comprimento 5

s="";

A K&R C é notável por ser verdadeiramente perdoadora. Na compilação, esse código fornecerá um número inteiro spara a ligação global que é inicializado no endereço inicial de uma string vazia (eu acho). K&R lida silenciosamente com todas as coerções, incluindo truncamento se um número inteiro não for grande o suficiente para armazenar o endereço.

São construções como essas que geraram muitos bugs difíceis de encontrar e deram muita inspiração nas competições da IOCCC.

Fragmento de comprimento 6

o=042;

Uma pegadinha de temporizadores antigos, um 0 inicial em um número literal significa que os dígitos a seguir estão na base octal. O código acima, na compilação, fornecerá um número inteiro opara a ligação global inicializada ao decimal 34.

Esse recurso do C tem mordido muitos desenvolvedores que se esforçam para aumentar seus números para torná-los alinhados de forma agradável e uniforme!

Fragmento de comprimento 7

f(){f;}

O código acima é uma função com um corpo. mas o que isso faz? Ele recupera o endereço da função e não faz nada com ela! Normalmente, o que a função retornará é indefinido. Código absurdo como esse geralmente pode compilar sem aviso.

Fragmento de comprimento 8

main(){}

Isso representa o menor código compilável e vinculável em C. Enquanto nas versões modernas de C, as funções geralmente não podem ser definidas implicitamente, por razões históricas essa restrição é relaxada main.

Essa maravilha de um programa, que não faz nada além de retornar 0, será compilada em um tamanho não desprezível e vinculada a várias rotinas de tempo de execução em C. Você pode compilar e vincular com a verbosidade definida como cheia para ver o que está acontecendo sob o capô.

Fragmento de comprimento 9

#define Z

Um dos pilares dos arquivos de cabeçalho C é a #definediretiva de pré - processador. Os programas C são compilados em vários estágios e, em um desses estágios, essas definições são substituídas por seus valores reais.

Quando um argumento está faltando, C implica 1, portanto, o acima substitui 1onde quer que Zseja usado no código-fonte.

O acima mencionado normalmente seria colocado em um arquivo de cabeçalho #includeed conforme necessário.

Fragmento de comprimento 10

enum{P,Q};

A enumpalavra-chave fornece uma maneira às vezes de tipo seguro para definir uma série de constantes. Como define, eles são frequentemente usados ​​em arquivos de cabeçalho. O código acima, quando incluído, definiria Pcomo um número inteiro de 0 e Qde 1.

Fragmento de comprimento 11

volatile v;

A volatilepalavra-chave é informar ao compilador que uma variável pode ser alterada por outros agentes e não fazer suposições de que ela permanecerá constante entre os acessos.

Fragmento de comprimento 12

#pragma once

#pragma once é uma diretiva de pré-processador não padrão, mas amplamente suportada, para indicar que o arquivo de origem atual seja incluído apenas uma vez em uma única compilação.

A técnica tradicional e totalmente suportada é usar #includeguardas com as desvantagens do código adicionado e possíveis conflitos de nome.

Fragmento de comprimento 13

w(){for(;;);}

Existem inúmeras convenções em C, e uma delas é como representar loops infinitos. Nesse caso,for(;;) indica nenhuma inicialização, nenhuma verificação de saída com o padrão 1, o que significa verdadeiro - ou seja, não quebre e nenhum código de loop.

Às vezes é possível fazer tudo dentro do () loop e o próprio loop não precisa de corpo. Nesse caso, um ponto-e-vírgula fictício é adicionado no final.

No código acima, quando compilado, ele fornecerá uma função que entrará em um loop muito ocupado - um dos não-não-no design de software - e nunca retornará.

Fragmento de comprimento 14

int a[]={1,2};

Matrizes em C não precisam dos comprimentos especificados. Os colchetes vazios []dizem ao compilador para "descobrir você mesmo". No entanto, em C, diferentemente de outros idiomas, não existe uma maneira integrada de impedir o acesso a uma matriz fora desses limites, levando à metáfora "atire no pé", pela qual C é conhecido.

O código acima, quando compilado, fornecerá uma matriz mutável global ade dois números inteiros inicializados com 1 e 2.

Fragmento de comprimento 15

const long k=7;

O constespecificador é uma adição posterior ao C emprestado do C ++. Uma pergunta comum da entrevista é "Faz sentido definir uma variável como volatile const?". constjuntamente com enume inlinepretendem reduzir a dependência de #defineproblemas com a segurança de tipo.

Fragmento de comprimento 16

extern void **q;

externé usado para indicar que uma variável é declarada em outro lugar. O void *tipo é o tipo genérico padrão em C, o que significa que não precisa ser explicitamente convertido ou convertido nas instruções de atribuição. A **sequência do operador significa ponteiro para um ponteiro, que muitas vezes impressiona os novatos, mas é perfeitamente válido e costuma ser usado C.

Fragmento de comprimento 17

double d=4/3-1/3;

Se você imprimisse o texto acima, o resultado seria um e você pensaria super! Mude para double d=4/3-2/3;e qual é a resposta? Ainda é um! C está usando aritmética inteira para calcular 4/3 → 1 e 2/3 → 0 e 1 - 0 → 1!

Fragmento de comprimento 18

main(){puts("!");}

Finalmente chegamos a um código que realmente faz alguma coisa! putsé o favorito dos golfistas C porque não requer um arquivo de cabeçalho para usar.

putstambém adicionará um avanço de linha à saída. Por outro lado, sua contraparte getseliminará os avanços da linha. Nunca se deve usar, getsexceto em circunstâncias muito controladas - ele não tem proteção para saturação de buffer e é a causa raiz de muitas explorações.

Fragmento de comprimento 19

#include <stdlib.h>

A inclusão de arquivos de cabeçalho geralmente é uma assinatura pessoal dos desenvolvedores. Muitos incluem libe ioindependentemente de serem necessários. Alguns solicitam os arquivos de cabeçalho para que os comprimentos aumentem ou diminuam. A maioria colocou <>antes "". Pessoalmente, usei essa assinatura nos meus dias de AT para verificar se há trapaça entre os alunos: a mesma assinatura de cabeçalho? Olhe mais de perto!

Fragmento de comprimento 20

char*p=(char*)0x300;

C é projetado para ser usado em plataformas rudimentares de nível muito baixo. Em alguns casos, pode ser necessário acessar diretamente as portas mapeadas na memória especial.

No código acima, o endereço de uma porta é definido como hexadecimal 300. Você acessaria o valor da porta usando *p, como *p=0xff;para ativar todos os bits ou v=*p;recuperar o valor atual.

Fragmento de comprimento 21

int w=sizeof(double);

O sizeofoperador fornece o tamanho em bytes de um tipo. Com nomes de variáveis, os colchetes não são necessários, por exemplo double d;int w=sizeof d;.

Fragmento de comprimento 22

asm("xorl %ecx,%ecx");

Como asmdeve ser usado é definido pelo compilador. O exemplo acima é um exemplo de código em linha do Linux gcc em uma plataforma Intel.

O Unix original tinha uma fração pequena, mas não desprezível, de seu código no assembler. Ainda hoje, se a velocidade é a principal preocupação e a portabilidade não é absolutamente, você a verá usada.

Em sistemas compatíveis, o código acima será compilado e será literalmente uma instrução de montagem isolada sem meios convencionais de acessá-lo! BTW xor R,Ré um idioma comum da linguagem assembly para limpar um registro rapidamente.

Fragmento de comprimento 23

union u{char c;int i;};

A unionfornecerá pelo menos espaço suficiente para o maior elemento. Você pode vê-lo usado em conjunto com void *para fornecer um tipo "opaco" comum em determinadas bibliotecas. Nesse caso, a união normalmente fará parte de uma estrutura maior, com a estrutura tendo um campo para identificar o tipo de união.

Fragmento de comprimento 24

/*INTS*/int i,j,k;//INTS

O comentário original em C foi delimitado como /* comment */e recebeu o // comment to end of lineformato emprestado do C ++.

Fragmento de comprimento 25

int main(void){return 1;}

Esta é a versão mais compatível do snippet de comprimento 8 acima. O tipo de retorno e os tipos de função são especificados e ele possui um valor retornado explicitamente.

A convenção em C é a utilização de um valor de retorno de 0para o sucesso e 1para o fracasso, ou se você quer ser estritamente conformant EXIT_SUCCESSe EXIT_FAILUREconforme definido no stdlib.h.

Snippet de comprimento 26

typedef struct{int x,y;}P;

typedef é extremamente útil, em particular, typedef struct . Em termos modernos, você pode chamá-lo de "luz de orientação a objetos".

Após incluir o acima, o código pode ser usado Pcomo um tipo regular em declarações e funções, com verificação completa de tipo. Porém, diferentemente do C ++, você não pode definir operadores como +, * ou <<, portanto, "luz de orientação a objetos".

Fragmento de comprimento 27

#define C(x,y)(((x)+1)*(y))

C tem uma #definesintaxe de macro conveniente .

Um erro comum de novato é omitir colchetes internos e / ou externos, resultando em erros de precedência do operador difíceis de encontrar.

Fragmento de comprimento 28

struct f{int s:1,e:8,m:23;};

C pode definir explicitamente campos de bits que podem ser atribuídos e lidos e manipulados como qualquer número inteiro.

A descrição acima é uma aproximação de uma estrutura de dados de ponto flutuante de largura única IEEE.

Fragmento de comprimento 36

f(unsigned x){return!!x&!(x&(x-1));}

Em muitos idiomas, você não precisa se preocupar com a forma como os números são representados. Em C, você precisa estar intimamente ciente de sua representação interna.

O melhor exemplo disso que consigo pensar é determinar se um número inteiro é uma potência de dois {1, 2, 4, 8, ...}. Aqueles que não estão familiarizados com C farão loops e turnos e todo tipo de coisas para o tempo de execução de O (log (n)), nada mal, mas acima é uma função que fará o mesmo no tempo de execução de O (1). Vou deixar como um exercício para o leitor confirmar que funciona, mas realmente funciona ...

A !!convenção é frequentemente usada para coagir um número inteiro de diferente de zero e zero a 1 e 0, respectivamente. Muitos desenvolvedores de C gostam de usar esses tipos de truques (geralmente em desacordo com aqueles que valorizam a clareza do código).

Desenvolvedores entusiasmados de C podem confirmar que o acima funcionará em hardware assinado e com complemento de unidades. Para quem está se perguntando, é quase certo que você está trabalhando em hardware com dois complementos agora. Somente os realmente sortudos (ou azarados, dependendo da sua perspectiva) precisam se preocupar com isso!

Snippet de comprimento 48

#include<complex.h>
double complex c=3.0+I*4.0;

O C99 inclui suporte para números complexos. Como você pode ver no código, ele assume a forma de um modificador para um tipo real. Você também pode usar, int complex c=3+I*4;mas internamente obriga a um tipo de ponto flutuante. O código acima será compilado no gcc usando gcc -std=c99 -c length-48.c.

Se você quiser ver mais informações internas, tente compilar com a opção -E. Para minha versão do gcc, a declaração acima se torna double _Complex c=3.0+(__extension__ 1.0iF)*4.0;. Observe que o tipo complexo é uma adição significativa ao idioma, não apenas algumas macros baratas.

Este é apenas um teaser, quando chegamos a mais de 125 caracteres, podemos começar a nos divertir de verdade com números complexos!

Fragmento de comprimento 51

#include <math.h>
main(){double d=sqrt(sin(3.2));}

Por várias razões, C não vincula automaticamente as funções matemáticas padrão, como sin, cos, tan, sqrt, etc. Portanto, se forem usadas, mas não vinculadas, o desenvolvedor receberá a referência indefinida do erro do vinculador para 'sqrt' ou algum outro erro.

No gcc, o código acima será compilado e vinculado usando gcc length-51.c -lm.

A nota sin(3.2)retornará um número negativo, do qual a raiz quadrada não é legal no domínio real. Em C, um valor especial NaNé retornado para indicar esse erro, que o programa pode ignorar!

No C99, existem muitas novas funções de tratamento de exceções para fornecer um controle muito seguro e refinado desses tipos de erros matemáticos, que quase ninguém usa!

Fragmento de comprimento 63

static int w;static int X(int x){static int s=0;s^=x;return s;}

Ou formatado de forma mais saudável:

static int w;
static int X(int x)
{
    static int s=7;
    s^=x;
    return s;
}

Como você deve ter adivinhado, trata-se da palavra-chave staticque tem mais de um significado em C.

Nos dois primeiros casos, staticestá dizendo ao compilador que número inteiro we função Xnão são visíveis fora deste arquivo ou unidade de compilação, ou seja, são internos.

Essas funções não devem ser chamadas externamente, portanto, podem não verificar a validade dos argumentos e cortar outros cantos. Como eles têm escopo interno, você pode redefinir we Xem outros arquivos, e eles geralmente serão separados.

No último caso, staticindica que o número inteiro smantém seu valor entre as chamadas de função. A primeira vez que Xfor chamada, sserá seu valor inicial 7, quando for exclusiva - OU comx , o novo valor será retido.

Internamente, embora seja dependente da implementação, a organização de memória usual é a que sreside no heap, especificamente a memória inicializada, enquanto o argumento xestá na pilha. Onde as variáveis ​​residem é importante se você deseja implementar algoritmos recursivos, por exemplo.

Uma pegadinha em C são conflitos com variáveis ​​globais. Até we Xsão realmente definidos como static, se eles são definidos globalmente em algum lugar, então we Xse referirão às entidades globais.

Aqui qe wnão pode ser inicializado com o mesmo valor, porque um global westá sendo usado para definir q:

static int q = w;
static int w;

Se um global wnão existir, a compilação falhará.

Aqui qe wserá inicializado com o mesmo valor:

static int w;
static int q = w;

Normalmente, os designers reduzem os conflitos de nomes adicionando um prefixo ou sufixo distinto às suas variáveis ​​e funções globais.

Em C99, staticganhou outro uso, por exemplo, o int Y(int a[static 10]);que significa que existe uma função Yque recebe uma matriz de pelo menos 10 números inteiros.

Fragmento de comprimento 74

void f(register int*p,register int*q,register int l){while(l--)*p++=*q++;}

Ou dispostos de maneira agradável:

void f(register int *p, register int *q, register int l)
{
    while (l--)
        *p++ = *q++;
}

A palavra-chave registerfornece uma dica para o compilador de que o uso de registros de hardware seria benéfico aqui. A função acima copiará lnúmeros inteiros de qparap , usando registros de hardware, se possível.

Às vezes, as acelerações podem ser significativas. Por exemplo, na família de microprocessadores de 68K, a linha *p++ = *q++pode ser convertida em uma única instrução MOVE.W (Ap)+,(Aq)+vs. seis ou oito, se você não usar register. O microprocessador 68K teve explícita pós-incremento e modos pré-decremento, então o desenvolvedor mais experiente, se soubesse a plataforma, seria adaptar código usando x++e --yvs. ++xe y--.

Hoje em dia, os compiladores geralmente ignoram register, exceto por não permitir que endereços sejam tirados deles (por exemplo, no exemplo acima &lcausaria um erro do compilador).

Fragmento de comprimento 88

#include<stdio.h>
int f(int x){return(x>1)?x*f(x-1):1;}int main(){printf("%d\n",f(12));}

Ou com um layout mais saudável:

#include <stdio.h>

int f(int x)
{
    return (x > 1)? x * f(x - 1): 1;
}

int main()
{
    printf("%d\n", f(12));
}

Ah, recursão! O trecho é um programa completo para compilar, vincular e executar. A função fcalcula o fatorial de seu argumento xusando a fórmula recursiva f (x) = x * f (x - 1). Os fatoriais aumentam muito rapidamente, portanto, por exemplo, f(12)é o maior valor que você pode obter em um número inteiro de 32 bits assinado.

Para um exemplo de código realmente recursivo, observe as implementações ingênuas da função Ackermann .

Compiladores inteligentes podem otimizar a função, usando a dica inlinee "desenrolando" a função quando constantes são fornecidas como argumentos para que:

f(12)

Torna-se:

12 * 11 * 10 * 9 * 8 * 7 * 6 * 5 * 4 * 3 * 2 * 1

Sem necessidade de chamadas de função!

Outros compiladores podem reorganizar a função:

int f(int x)
{
    return (x < 2)? 1: f(x - 1);
}

E implemente algo chamado recursão de cauda. Com efeito, isso substitui a última chamada de função para um simples goto e permite que essa função lide com o retorno. O benefício é menos pilha, código mais rápido e menor.

Na linguagem assembly, esses tipos de oportunidades de otimização são realmente fáceis de detectar e podem ser implementados por algo chamado "otimizador de fechadura", que basicamente procura pequenos padrões e os substitui por algo mais rápido e / ou menor.

Fragmento de comprimento 117

#include<stdio.h>
int main(int c,char**v){int a,b;sscanf(v[1],"%d%*[\t ,]%d",&a,&b);printf("%d\t%d\n",a,b);return 0;}

Ou:

#include <stdio.h>

int main(int c, char **v)
{
    int a, b;

    sscanf(v[1], "%d%*[\t ,]%d", &a, &b);
    printf("%d\t%d\n", a, b);

    return 0;
}

C tomou emprestado das linguagens contemporâneas da época, o conceito de E / S universal que poderia ser aplicado de maneira consistente a qualquer dispositivo, seja console, cartão perfurado, fita, disco ou impressora, mas na forma C verdadeira, permitiu ao desenvolvedor criar declarações muito concisas mas poderosas.

No trecho acima, ele receberá a entrada da linha de comando, analisará dois números inteiros separados por espaços, tabulações ou vírgulas e os produzirá. Ele tira proveito de um scanfespecificador mais recente %*[\t ,]que: [\t ,]extrai todas as guias, espaços e vírgulas e: *ignora-os.

Lembro-me de revisar algum código C ++ em que o desenvolvedor estava fazendo tudo da maneira "pura" em C ++ <<e um arsenal de métodos como finde substr. Havia pelo menos uma dúzia de linhas e ainda não conseguia manipular vírgulas como delimitadores. Troquei todo esse código desajeitado por uma única sscanflinha como acima!

Snippet de comprimento 132

#include<stdio.h>
int main(int c,char**v){while(--c){++v;printf("|%s|\n|%5s|\n|%-5s|\n|%.5s|\n|%5.5s|\n",*v,*v,*v,*v,*v);}return 0;}

Ou:

#include <stdio.h>

int main(int c, char **v)
{
    while (--c)
    {
        ++v;
        printf("|%s|\n|%5s|\n|%-5s|\n|%.5s|\n|%5.5s|\n", *v, *v, *v, *v, *v);
    }

    return 0;
}

As funções printf, sprintf, fprintfespecificadores etc formato utilização para definir a largura e preenchimento da saída.

Compile e execute o acima usando argumentos de linha de comando para ver as várias saídas:

> main xyz 123456
|xyz|                                                                                                                                                
|  xyz|                                                                                                                                              
|xyz  |                                                                                                                                              
|xyz|                                                                                                                                                
|  xyz|                                                                                                                                 
|123456|                                                                                                                                             
|123456|                                                                                                                                             
|123456|                                                                                                                                             
|12345|                                                                                                                                              
|12345| 

Observe os .5limites de saída do especificador para no máximo cinco caracteres, enquanto o líder 5garante que a saída seja de pelo menos cinco caracteres, -indicando o alinhamento à esquerda. Combiná-los define a saída em exatamente cinco caracteres.

Código da máquina x86

Factóide:

O código de máquina x86 é a versão montada do x86 Assembly que o processador realmente executa. Ele foi desenvolvido quando a memória e o espaço de armazenamento eram caros e foi projetado para ser um pouco compatível com o Intel 8008. Manter um código executável pequeno era um dos objetivos e utiliza instruções de comprimento variável e uma arquitetura CISC para ajudar conseguir isso (que teve a desvantagem de tornar mais complicado melhorar o desempenho dos processadores modernos). Isso, junto com a natureza básica da montagem e do código da máquina em geral, oferece aos programas x86 a capacidade de serem extremamente compactos.

Comprimento 1:

Agora, para o primeiro programa:

0xC3

Abra um editor hexadecimal, insira esse byte e salve-o como test.com.

Agora você tem um programa MS-DOS válido que retorna imediatamente sem fazer nada, pois 0xC3 é a instrução 'RET'. No entanto, isso mostra outro aspecto interessante para jogar golfe com o x86: o formato de arquivo .com. Esse formato executável não tem absolutamente nenhum cabeçalho - o arquivo é simplesmente carregado na memória, começando no endereço 0x100 e, em seguida, a execução é iniciada em 0x100. Isso significa que nenhum bytes desperdiçado nos metadados!

Comprimento 2:

Nosso próximo programa:

0x4D 0x5A

ou 'MZ' em ASCII.

Ok, eu trapacei um pouco, isso realmente não é um programa útil, pois corresponde às instruções

DEC     BP
POP     DX

O que não é realmente útil para iniciar um programa .com. De fato, esse é o objetivo desses dois valores - nenhum arquivo .com razoável deve começar com eles! Os arquivos .com eram limitados a 65280 bytes de tamanho (64KiB - 0x100); portanto, quando programas maiores começaram a ser necessários, um novo formato teve que ser desenvolvido. Este era o formato de arquivo .exe, que possui um cabeçalho. No entanto, o MS-DOS precisava manter a extensão .com em certos componentes para compatibilidade com versões anteriores, portanto, era necessário detectar como um arquivo .com era realmente um .exe. Eles escolheram a picada 'MZ' como esse número mágico e, até hoje, se você abrir um arquivo .exe (ou .dll) do Windows em um editor hexadecimal, verá que eles começam com esses dois bytes. Me diverte que mesmo o programa mais moderno do Windows comece com uma restrição de compatibilidade dos anos 70.

Comprimento 3:

Agora, para um loop infinito:

41 E2 FD

O que se traduz em

start:
inc cx
loop start 

Este programa incrementa o valor de CX (que será> 0 para começar) e depois executa a instrução de loop. Loop é um excelente exemplo de uma instrução CISC, pois combina 3 operações simples em uma operação de finalidade especial: diminui o valor de CX, verifica se é 0 e, se não, salta para o rótulo de destino. Também existem formas de loop que verificam outros sinalizadores além de terminar quando CX é 0. Poderíamos ter feito apenas 'jump start' para um loop infinito de 2 bytes, mas isso foi mais interessante.

Comprimento 4:

Um programa que é minimamente útil:

40 CD 10 C3

Traduzido para montagem:

inc ax    ; 1 byte
int 10h   ; 2 bytes
ret       ; 1 byte

Este programa define o console para 40x25 caracteres, limpa a tela e retorna à linha de comando. O AX está definido no modo de vídeo que queremos (1), então a interrupção do BIOS 10h é chamada para realmente definir o modo de vídeo e limpar a janela, antes de retornar. Espere ver mais dessas interrupções do BIOS no futuro.

Comprimento 5:

Agora podemos implementar um programa de pausa:

B4 01 CD 21 C3

Traduzido para montagem:

mov ah,1  ; 2 bytes
int 21h   ; 2 bytes
ret       ; 1 byte

Este programa instrui o BIOS a aguardar que uma tecla seja pressionada e a repete na tela antes de retornar. Isso também demonstra como, no x86, alguns dos registros podem ser parcialmente lidos ou gravados. Nesse caso, definimos o byte superior do AX (AH) como 1. Nos processadores de 32 bits, você também pode operar com 16 bits baixos sem afetar os 16 bits principais. Essa capacidade de modificar registros parciais pode ser útil para programadores de montagem, mas possui desvantagens para processadores modernos que tentam executar execução fora de ordem , pois podem introduzir falsas dependências de dados.

Comprimento 9:

Agora, para realmente exibir a saída:

68 00 B7 07 AB 40 79 FC C3

Traduzido para montagem:

; These two instructions set up ES, the 'extra segment'
push 0xb700 ; 3 bytes
pop  es     ; 1 byte
label:
stosw       ; 1 byte, Store Word - Copy AX to [ES:DI] then add 2 to DI
inc  ax     ; 1 byte
jns  label  ; 2 bytes, Jump Not Signed - Jump unless the sign flag is set (when inc AX yields 0x8000
ret         ; 1 byte

A saída é o conjunto de caracteres padrão repetido em cores diferentes. O byte baixo do AX é o código de caractere e o byte alto especifica as cores a serem usadas.

Os programas de 16 bits só podiam endereçar até 64KiB diretamente. Para contornar isso, o x86 usava 'segmentos' - registros especiais que seriam multiplicados por 16 e adicionados a todos os acessos à memória para fornecer 20 bits de memória endereçável. Um programa pode alterar os valores desses registradores de segmentos para acessar mais memória - ou áreas especiais de memória: este programa modifica o segmento extra para gravar na memória de vídeo. Diferentes tipos de acesso à memória usavam registros de segmento diferentes, permitindo que código, dados e a pilha fossem acessíveis em diferentes blocos de memória ao mesmo tempo. O segmento padrão também pode ser substituído para muitas instruções.

Comprimento 20:

Vamos tornar algo reconhecível - usaremos a 'Regra 90' para desenhar triângulos de Sierpinski.

B0 13 CD 10 68 0F A0 1F AC 31 C2 88 94 3E 01 87 D3 93 EB F4

Na montagem:

mov al,13h      ; 2b
int 10h         ; 2b - Set the video mode to 13h

push    0xA00F  ; 3b
pop     ds      ; 1b - Set the data segment to video memory

start:          ; This loop runs 'Rule 90' to draw Sierpinski triangles
lodsb           ; 1b - load al with [ds:si] then increment si

xor     dx,ax   ; 2b - xor the left and right values of the previous row of pixels
mov     [si+318],dl ;4b - store result to memory

xchg    dx,bx   ; 2b - swap register values
xchg    ax,bx   ; 1b - swapping with ax is 1 byte shorter

jmp     start   ; 2b - infinite loop

Saída de amostra:

Para este programa, usamos o famoso 'Modo 13' - um modo gráfico que tem uma resolução de 320x200 com 256 cores. Foi usado por muitos jogos populares do DOS , como o Doom.

Comprimento 21

Vamos ver quem fabricou a CPU em que estamos executando.

0F A2 66 60 BB EE FF B9 0C 00 8A 17 43 B4 02 CD 21 E2 F7 FF E1

Traduzido para montagem:

cpuid         ; 2b  CPU ID - retrieve processor information based on the value in AX. For AX=0,
              ;     the 12 bytes in EBX, ECX, and EDX are loaded with a vendor identification string
pushad        ; 2b  Push all registers on the stack (32 bit version)
mov  bx,0xffee; 3b  Start of the vendor identification string on the stack
mov  cx,12    ; 3b  12 characters to print
print:    
mov  dl,[bx]  ; 2b  Character to print
inc  bx       ; 1b  Advance string position
mov  ah,2     ; 2b  Set AH to the 'Print character to STDOUT' value
int  21h      ; 2b  Call the bios interrupt to print
loop print    ; 2b  Decrement CX and jump if it is not zero
jmp  cx       ; 2b  Instead of restoring the stack, just jump right to the exit point

Saída de amostra:

c:\misc>cpuid.com
GenuineIntel

Este programa usa a instrução CPUID para obter informações sobre o processador em que está sendo executado, em particular a sequência de identificação do fornecedor. A maioria das pessoas verá 'GenuineIntel' ou 'AuthenticAMD', a menos que tenha um fabricante incomum de CPU ou esteja executando em determinadas máquinas virtuais.

Comprimento 26

Agora podemos fazer animações interessantes

B0 13 CD 10 C4 07 BB 40 01 59 99 89 F8 F7 F3 31 D0 AA E2 F6 26 FE 05 47 EB FA

Em Assembléia

mov al,13h     ;2b
int 10h        ;2b Enter Video Mode 13h

les ax,[bx]    ;2b Set ES to (roughtly) video memory
mov     bx,320 ;3b Set up  BX asdivisor
pop     cx     ;1b Zeroize CX

start:
cwd            ;1b Sign extend AX to DX, AX will never have the sign bit set so this zeroizes DX in 1 byte
mov     ax,di  ;2b Copy video memory pointer
div     bx     ;2b Divide by width to get AX = Y pos, DX = X pos
xor     ax,dx  ;2b X pos ^ Y pos
stosb          ;1b Store and increment video pointer
loop    start  ;2b CX starts at 0, so this will loop until it wraps around

cycle:
inc     byte [es:di];3b Increment value in video memory to animate
inc     di     ;1b Increment video memory pointer
jmp     cycle  ;2b Infinite loop 

E a saída será assim:

A função X pos ^ Y pos produz um fractal interessante, especialmente quando animado

Comprimento 27

Além de gerar texto e gráficos em um pequeno programa x86 .com, também é possível gerar som e música:

BA 31 03 B0 3F EE BA 30 03 B0 93 EE B4 01 CD 21 3C 1B EE 3C 1B B0 7F EE 75 EC C3

Na montagem:

    mov dx,0x331            ; value for the midi control port
    mov al,0x3F             ; command value to set midi mode to UART
    out dx,al               ; output the command to the midi control port
play_loop:
    mov dx,0x330            ; value for the midi data port
    mov al,0x93             ; midi instrument value (piano)
    out dx,al               ; output to midi data port
    mov ah,1
    int 0x21                ; read character from stdin, with echo
    cmp al,27               ; test if it is escape
    out dx,al               ; output the ascii value as the midi note to play
    mov al,0x7F             ; note duration
    out dx,al               ; output note duration
    jne play_loop           ; loop if escape was not pressed
    ret  

Este programa usa a placa midi para transformar o teclado em um piano. Para fazer isso, o cartão midi está definido no modo UART, que toca notas midi assim que são recebidas. Em seguida, o programa espera que um caractere seja pressionado e envia o valor ASCII como uma nota para o cartão midi. O programa é executado até pressionar escape.

Comprimento 29

Vamos usar um sistema de funções iteradas para gerar um fractal Dragon Curve:

B0 13 CD 10 89 D0 01 CA 29 C1 D1 FA D1 F9 73 03 83 E9 7A B4 01 CD 16 B8 02 0C 74 E6 C3

Traduzido para montagem:

mov  al,13h
start:
int  0x10    ; This does double duty, setting the video mode to 13h at program start,
             ; and calling the 'draw pixel at coordinates' interrupt when looping
mov  ax,dx   ; The next couple instructions are our IFS, the algorithm is aproximately
add  dx,cx   ; f(y) = 0.5x + 0.5y
sub  cx,ax   ; f(x) = 0.5x - 0.5y OR f(x) = 0.5x - 0.5y - 1
sar  dx,1    ;
sar  cx,1    ;
jnc  skip    ; This jump handles pseudo-randomly switching between the two functions for x,
             ; based on if the previous value of x was odd or not.
sub  cx,122  ; Magic number, chosen since it provides sufficent 'randomness' for a filled in
             ; fractal and a good scale to the fractal. 102 and 130 also work.
skip:
mov  ah,1
int  0x16    ; Get keyboard state, zero flag will be set if no key has been pressed
mov  ax,0xC02; Set up AH for the draw pixel function when int 0x10 is executed,
             ; AL = color, CX = column, DX = row
jz   start   ; Loop if a key hasn't been pressed
ret  

Resultado:

Pressionar uma tecla que não seja de controle fará com que o programa saia. Isso é baseado no Fire Coral da Desire no Pouet.net.

Comprimento 52

Esse programa é um recurso duplo, mostra um pouco do coprocessador de ponto flutuante x87 e do código de modificação automática.

B3 07 D9 E8 B1 11 DE 0E 32 01 E2 FA BE 0A 24 56 B1 09 DF 34 AC D4 10 
86 E0 05 30 30 50 E2 F5 44 B4 2E 50 89 E2 B4 09 CD 21 FE 06 03 01 4B
75 D2 CD 20 0A 00

Quando executado, o programa produzirá várias constantes matemáticas:

1.00000000000000000
3.32192809488736235
1.44269504088896341
3.14159265358979324
0.30102999566398120
0.69314718055994531
0.00000000000000000

Estes são Um, Log2 (10), Log2 (e), Pi, Log10 (2), Log e (2) e Zero.

Na montagem:

org 100h

mov     bl,7         ;Counter for the total number of constants to print
start:
fld1                 ;Floating point constant to load on the FP stack,
                     ;start with 1 since it's op-code is the lowest

mov     cl,17        ;Multiply the constant by 10, 17 times to get the
mult:                ;printing part as an integer
fimul   word[ten]
loop    mult

mov     si,10+'$'*256;ASCII new line (10) and the end-of-string ($)
                     ;characters. These are used both as
push    si           ;a constant memory location, and stored to the
                     ;stack to format and printing

mov     cl,9         ;print 18 digits (9 pairs)
fbstp   [si]         ;store the integer part of the floating point
                     ;number on top of the FP stack as a packed
                     ;binary-coded decimal number (1 digit/nibble),
                     ;and then pop the number off the FP stack

convert:
lodsb                ;load a pair of packed digits

db 0xd4,16 ; AAM 16  ;ASCII Adjust For Multiply instruction using
                     ;non-standard base 16. This puts AL/16 in AH,
                     ;and AL%16 in AL, unpacking the digit pair.

xchg    ah,al        ;Swap the digit order
add     ax,'00'      ;Convert the digits to ASCII values
push    ax           ;Store digits on the stack
loop    convert

inc     sp           ;AX now holds the 1st 2 digits to print,
mov     ah,'.'       ;so to insert a decimal point, the 2nd digit
push    ax           ;is replaced with a '.', the stack pointer
                     ;is adjusted to overwrite 1 byte, and then
                     ;AX is pushed on the stack

mov     dx,sp        ;Load DX with the start of the print string
mov     ah,9         ;Load AH with the 'Print String' constant
int     21h          ;Call the 'Print String' interrupt to display
                     ;the constant

inc     byte[start+1];Self-modifying code - increment the load
                     ;floating point constant op-code to iterate
                     ;through all of them

dec     bx
jnz     start        ;Exit when all 7 constants have been printed
int     20h


ten: dw  10

A matemática do ponto flutuante nos sistemas x86 foi originalmente manipulada pelo coprocessador opcional x87, não foi até o 486 que foi movida para o mesmo chip. O x87 também tinha uma arquitetura bastante diferente, era baseada em pilha, com 8 registros de 80 bits disponíveis. Ele também tinha uma variedade de modos de arredondamento, precisão e exceções mascaráveis ​​que podiam ser definidas.

Este programa imprime os valores para sete constantes inseridas nos processadores. Pode parecer estranho que o espaço de instruções seja desperdiçado em constantes simples como 0 e 1, mas lembre-se de que o conjunto de instruções foi criado quando a memória era pequena e essas instruções são tipicamente 2 bytes menores que operações equivalentes. O programa também usa uma instrução obscura, FBSTP - 'Store BCD Integer and Pop'. Na época em que o x86 foi desenvolvido, as operações nos números do BCD eram mais comuns e o x86 / x87 possui várias instruções especificamente para simplificar a matemática do BCD, como a instrução 'ASCII Adjust for Multiple' da AAM, também usada no programa.

No modelo de memória desprotegida usado pelos primeiros programas x86, não há distinção entre dados e código. Por esse motivo, é fácil iterar através das instruções 'Load Constant' codificadas seqüencialmente, simplesmente incrementando o valor apropriado.

Comprimento 64

Cruzando minha entrada para o Desafio Mandelbrot , é possível escrever um programa que exibe um fractal Mandelbrot de 320 x 200 cores em apenas 64 bytes.

B0 13 CD 10 C4 07 99 89 F8 B9 40 01 F7 F1 83 E8 64 FE CE 31 DB 31 F6 
89 F5 0F AF F3 01 F6 0F AF DB 70 19 0F AF ED 70 14 01 EB 70 10 29 EB
29 EB C1 FB 06 01 D3 C1 FE 06 01 C6 E2 DB 91 AA EB C6

Na montagem:

mov al,13h ; set up graphics mode 13
int 10h

les ax,[bx]; trick to set video memory

FillLoop:
cwd
mov ax,di  ; di is the current position on screen
mov cx,320 ; convert di int x,y screen coordinates
div cx     ; CX is the iteration counter, exit the loop if it hits
           ; zero before the value escapes.
sub ax,100 ; center the fractal vertically
dec dh     ; center the fractal horizontally

xor bx,bx
xor si,si

MandelLoop: ; Fairly standard Mandelbrot routine,
mov bp,si   ; exits if the values overflow
imul si,bx
add si,si
imul bx,bx
jo MandelBreak
imul bp,bp
jo MandelBreak
add bx,bp
jo MandelBreak
sub bx,bp
sub bx,bp

sar bx,6   ; We use fixed point math with the lowest 6
add bx,dx  ; bits being the fractional portion, so this
sar si,6   ; rescales the values after multiplication
add si,ax

loop MandelLoop

MandelBreak:
xchg ax,cx ; Write the escape itteraction as the color
stosb
jmp FillLoop

O resultado final é esta imagem:

Este programa usa matemática de ponto fixo para gerar o fractal, pois leva menos bytes. Os 6 bits mais baixos dos registradores de 16 bits são considerados a parte fracionária do número e os valores são redimensionados após serem multiplicados.

Haskell

Você pode querer ler de baixo para cima. Às vezes, refiro-me aos trechos mais baixos, mas nunca aos mais altos, por isso pode ajudar a entender.

Leitores que não conhecem Haskell: estou claro? Quando não estou claro? Não sei dizer.

Fragmento de comprimento 86

Uma instância dobrável para nossa estrutura de dados em árvore (snippet 23). Dobrável é uma classe de tipo - como em, uma classe (/ grupo) de tipos. Eles são paralelos às interfaces em Java. Geralmente generalizam sobre tipos, tipos unificadores que têm características comuns; por exemplo, eles podem ser adicionados juntos (Monoid ), contêineres ( Functor), podem ser impressos como texto ( Showque já encontramos na showfunção) e assim por diante. Este unifica os tipos de dados que são do tipo lista, pois podem ser iterados ou achatados em uma lista.

Nesse snippet, definimos a instância definindo foldr , que itera essencialmente sobre o tipo de dados da direita para a esquerda. Agora, podemos usar um monte de código pré-escrito geral. Primeiro, nós definimos uma função auxiliar para obter uma árvore Singleton, para evitar toda a desordem: s a = N E a E. Agora:

sum (N (s 3) 7 (N E 5 (s 8))     === 23
product (N (s 3) 7 (N E 5 (s 8)) === 840
toList (N (s 3) 7 (N E 5 (s 8))  === [3,7,5,8]

e assim por diante.

Aqui está uma foto da nossa árvore:

7
| \
3  5
    \
     8

Fragmento de comprimento 70

primes=sieve[2..] where
 sieve(p:xs)=p:sieve(filter(\x->x`mod`p/=0)xs)

Esta é uma peneira de primeira qualidade!

(nota: /=é o que!= está em outros idiomas)

Isso funciona definindo uma função sieveque filtra a lista e mantém apenas os números que não são divisíveis por nenhum primo anterior. É definido recursivamente - a sieveé definido como para dividir a lista para um primeiro elemento pe uma cauda, filtro a partir da cauda qualquer número divisível por p, sieveo bit restante, anexar ppara o início do que, e retornar.

Novamente, estamos trabalhando com listas infinitas aqui - mas o cálculo será interrompido com o tempo, desde que você não exija que uma quantidade infinita de números primos seja computada.

take 4 primes === [2,3,5,7]

Snippet de comprimento 68

Finalmente, uma solução!

main=do putStr s;print s where s="main=do putStr s;print s where s="

Na primeira vez que você leu isso, você pode pensar que a saída desse quine estaria faltando as aspas e por que você escreveria putStruma vez e outra vezprint ? Parece o mesmo.

No Haskell, putStré uma função que apenas imprime o conteúdo da string que ele recebe no stdout; print, no entanto, imprime as coisas no stdout. Então, print 4é equivalente a putStr "4\n", mas não putStr 4faz sentido - 4não é uma string! Portanto, quando printobtém um valor, ele primeiro o converte em uma sequência e depois imprime essa sequência. Geralmente, a maneira de converter as coisas em seqüências de caracteres é encontrar a maneira como você as escreveria no código. Portanto, a maneira como você escreveria a string abcem uma string no código Haskell é "abc", print "abc"na verdade "abc", imprime , não abc.

_{Que sorte eu tenho votos suficientes agora, não precisarei jogar essas coisas}

Fragmento de comprimento 33:

main=go 0
go n=do print n;go(n+1)

O importante a ser observado é que não usamos um loop. Haskell não faz loop. Haskell se repete. Haskell não tem loops. É mais profundo que isso: Haskell nem tem fluxo de controle . Como você pode perguntar? Bem, não precisa de nenhum.

Vamos com os detalhes. Este programa imprime uma sequência crescente e infinita de números inteiros, começando em 0., goimprime-os começando com sua entrada e depois o mainchama 0.

doé um poder sintático especial de Haskell. Nesse cenário, ele apenas combina ações de E / S, assim como >>faz (consulte o fragmento 22).

Fragmento de comprimento 26:

map f=foldr(\x y->f x:y)[]

Isso define a mapfunção, provavelmente familiar a todos, usando foldr. Observe que, embora nós não declarar map's tipo, o computador de alguma forma conhece o seu tipo é (a -> b) -> [a] -> [b], ou seja, dada uma função a partir ade b, e uma lista de as, retornar uma lista de bs.

Como soube ?? ;-)

Fragmento de comprimento 25:

main=putStr"Hello World"

O padrão Hello World. Observe os tipos: maintem tipo de IO ()e putStrtem tipo de String -> IO ()(uma função de cadeias de caracteres para ações de E / S que não retornam nada).

Fragmento de comprimento 23:

data T a=E|N(T a)a(T a)

Esta é uma definição padrão de uma árvore. Quão mais fácil do que todas essas linhas necessárias para definir uma árvore em Java, C ou qualquer outra coisa.

(veja o fragmento 10)

Vamos dividir:

data- esta declaração declara um tipo de dados. T a- uma árvore contendo elementos do tipo a. Este é o tipo que estamos definindo. =- todo valor de T aserá qualquer um dos seguintes, separados por um tubo |. E- um dos valores possíveis de T s- a árvore vazia. N (T a) a (T a)- o outro valor possível de uma árvore - um nó. Cada nó consiste no filho esquerdo ( (T a)), no elemento ( a) e no filho direito ( (T a)).

Fragmento de comprimento 22:

main=putStrLn"y">>main

Uma yesfunção Haskell . >>é um operador que combina e sequencia duas ações de E / S. Tem tipo de >> :: IO a -> IO b -> IO b.

mainé definido recursivamente por si só, como a ação de E / S que primeiro imprime "y"e depois faz o que mainfaz.

Fragmento de comprimento 18:

fix f=r where r=f r

Uma melhor definição para fix. (Veja o trecho 14.) O problema com a primeira definição, fix f = f(fix f)é que toda vez que chamamos de fix f fixrecalls fix f, o que é recuperado fix f, gera cópias sem fim da mesma computação. Esta versão corrige-a definindo r(resultado) como o resultado; como tal f r = r,. Então, vamos definir r = f r. Agora voltamos r.

Fragmento de comprimento 17:

f n=product[1..n]

Esta é a maneira funcional de definir fatorial.

Fragmento de comprimento 16:

f n=(\x->x+x+x)n

(\x -> x + x + x)é um lambda (alguém pensou que se \assemelha à letra).

(\x -> x + x + x) né o lambda aplicado a n(isso é exatamente o mesmo que n + n + n).

fé a função multiplicar por três (também f = (*3))

Fragmento de comprimento 15:

sum=foldl (+) 0

Isso define a sumfunção usando uma dobra. Uma dobra é basicamente um loop sobre os elementos de uma lista com um acumulador.
foldltoma como argumento alguma função fe algum valor inicial xpara o acumulador e uma lista xs. A função fdeve obter como entrada o valor anterior do acumulador e o valor atual da lista e retorna o próximo acumulador.
A dobra itera nos valores da lista, aplicando-se fno acumulador anterior e, em seguida, retorna o último acumulador.

Outra maneira de pensar em dobras é como a dobra 'inserida' fentre os valores da lista e com o acumulador inicial em um dos lados. Por exemplo, foldl (*) 1 [4,2,5]avalia como 1 * 4 * 2 * 5.

Fragmento de comprimento 14:

fix f=f(fix f)

O ycombinador. Geralmente, é nomeado fixporque encontra o ponto de correção da equação f x = x. Observe que x = infinite loopàs vezes também pode ser uma solução; portanto fix (\x -> x^2 + 5*x + 7), não resolverá a equação, x^2 + 4*x + 7 = 0mas retornará um loop infinito.

Você também pode observar que nem sempre x = infinite loopé uma solução, devido à preguiça de Haskell.

Esta versão é um vazamento de tempo e espaço; nós o redefiniremos em um trecho mais longo.

Fragmento de comprimento 13:

f=sum.map(^2)

Isso define a função f que, dada uma lista, retorna a soma de seus quadrados. É a função composição da função sum e a funçãomap(^2) , que por sua vez é a função map aplicada à função (^2) (o quadrado da função ), que por sua vez é uma secção da função ^ (secções foram introduzidos no fragmento de 2, e a composição no fragmento 3 )

Como você pode ver, as funções são muito importantes em uma linguagem funcional como Haskell. De fato, foi dito que Haskell é a linguagem com as funções de biblioteca mais padrão que obtêm funções como entradas ou retornam funções como saídas (isso é comumente conhecido como uma função de ordem superior) .

By the way, tecnicamente, a cada dois-ou-mais argumento função é uma função que retorna funções como saídas (isso é chamado currying).

Fragmento de comprimento 10:

data B=T|F

Esta é uma definição de booleanos Haskell com nomes diferentes. O tipo booleano é nomeado B.
Esta definição apresenta dois construtores: true ( T) e false ( F).
Esse trecho de código basicamente diz ao compilador que todo booleano ( B) é verdadeiro ( T) ou falso ( F) ou, em outras palavras B=T|F,.

De fato, todos os tipos de dados podem ser definidos em Haskell, quando em outros idiomas o número, as referências e os tipos de dados da matriz precisam de suporte especial do compilador. Na prática, há suporte especial em Haskell, pois seria muito inconveniente, mas, por exemplo, o Booltipo de dados é definido inteiramente na linguagem.

Fragmento de comprimento 9:

main=main

Este programa sem sentido definirá maincomo principal. Como Haskell é preguiçoso, valores que exigiriam um loop infinito para avaliar podem ser usados ​​livremente se não usarmos seu valor real. Tais valores que contêm loops infinitos, como o nosso main, são chamados de "fundos".

Um fato interessante é que o compilador GHC Haskell pode detectar esses tipos de loops infinitos e lançar uma exceção capturável (!) Quando é executada.

Fragmento de comprimento 8:

f(x:_)=x

Isso define a função fque, dada uma lista não vazia, retornará sua cabeça.

Os padrões em Haskell são como a sequência de descompactação do Python, mas generalizada para todos os tipos. Os padrões podem rejeitar ou corresponder a um valor e, se corresponder, podem vincular variáveis ​​a valores.

Os padrões neste trecho são:

• _: o padrão que corresponde a qualquer coisa e não vincula nenhuma variável.
• x: o padrão que liga qualquer coisa e o vincula à variável x.
• :: esse padrão chega aos padrões filhos, ou seja, um para a cabeça e outro para a cauda. Se a lista não estiver vazia, ela será combinada com a cabeça e a cauda.

A correspondência de padrões é altamente generalizada. De fato, apenas definir novos tipos de dados introduzirá automaticamente padrões para trabalhar com eles.

Fragmento de comprimento 5:

x=2:x

Whoa, há muito o que explicar sobre este.

Primeiro de tudo, Haskell é preguiçoso. Isso significa que as subexpressões serão avaliadas somente quando estritamente necessárias.

Nota: este snippet de código não mostra atribuição, mas definição. Haskell não tem atribuição.

Esse trecho de código definido x, uma lista infinita composta inteiramente por 2. Normalmente, em outros idiomas, xé preciso avaliar antes que 2:xpossa ser avaliado, mas em Haskell, podemos fazer isso.

As listas infinitas Haskell são uma espécie de mistura de iteradores e listas vinculadas regulares: elas agem como ambas (uma iteração em um intervalo usa memória constante, por exemplo).

Fragmento de comprimento 4:

2:[]

Esse trecho apenas codifica a lista de singleton [2]. :é o operador Contras em Haskell. De fato, a sintaxe da lista regular é apenas um açúcar sintático para o operador contras e a lista vazia literal. Isso está intimamente ligado à maneira como Haskell lida com a correspondência de padrões e os tipos de dados (particularmente o conceito de construtor).

Fragmento de comprimento 3:

f.g

Em Haskell, .significa composição da função. O Haskell pode ser escrito em um estilo "sem pontos", caracterizado por não nomear argumentos da função e usar o .operador para manipular o fluxo de dados.

Fragmento de comprimento 2:

1-

Quando esse código é colocado entre parênteses (por razões sintáticas), é chamado de "seção". É então uma função que, dado um número, "preenche" o ponto vazio e retorna um menos esse número. Essa noção às vezes é útil em uma linguagem funcional como Haskell, onde, caso contrário, seria necessário um lambda.

Fragmento de comprimento 1:

1

Em Haskell, 1pode ser tanto um Int, Float, Double, Worde assim por diante. De fato, você pode escrever um código para definir uma versão de 1qualquer tipo e usá-lo livremente.
isso também é feito em JavaScript, Python e assim por diante, mas, diferentemente deles, é feito com segurança de tipo completo.

factóide:

Originalmente, o comitê de Haskell pretendia chamar o idioma "Curry" após o nome de Haskell B. Curry, mas decidiu mudar o nome para Haskell, porque alguns trocadilhos poderiam surgir. Só mais tarde eles notaram a semelhança de Haskell com "Pascal" e "Hassle"!

C #

O C # é uma divertida e louca mistura de recursos de Java, C, Haskell, SQL e várias outras linguagens, além de fornecer muitos recursos e APIs realmente agradáveis. Também é conhecido por ser bem detalhado, mas veremos o que podemos fazer!

Ignorarei o padrão habitual necessário:

class Program { public static void Main(string[] args) { ... } }

Comprimento 1:

;

Os comandos são encerrados com ponto e vírgula em C #! Uma linha vazia é uma sintaxe perfeitamente válida.

Comprimento 5:

x=5f;

Quando você especifica números literais em C #, o compilador assume que eles são ints ou duplos (com base no fato de terem um ponto decimal). Se você deseja usar um float literal, especifique isso anexando 'f' ao número, ou ele será convertido em tempo de execução, incorrendo em um pequeno custo.

Comprimento 7 (bytes):

s=@"
";

Se você prefixar uma string literal com um sinal @, ela se tornará uma string literal "literal". Literais de cadeia normal analisam seqüências de escape como '\ n' em caracteres especiais, mas literais verbatim não, permitindo que você use o caractere de barra invertida sem escapá-lo. Eles também podem incluir retornos de linha, como mostrado. Isso pode economizar alguns bytes no golfe ou tornar os literais de várias linhas mais legíveis. Apenas observe se o recuo está sendo incluído na string.

Comprimento 8:

()=>x=y;

Esta expressão é uma função anônima. Ele retorna um objeto do tipo Actionque pode ser transmitido e também chamado como uma função. As funções anônimas herdam o escopo em que foram declaradas e puxam todas as variáveis ​​locais nesse escopo para onde quer que vão.

Comprimento 9:

(a)=>a.p;

Aqui está outra função anônima que usa um parâmetro e valor de retorno. A expressão retorna um objeto do tipo Func(o próprio Func retorna o tipo de a.p. Você usará Funcmuito para fazer interface com o Linq.

Comprimento 10:

enm.Any();

Esta é a nossa primeira introdução ao Linq! Linq é um conjunto de métodos de extensão que podem ser chamados em qualquer objeto enumerável (implementando a interface IEnumerable) - como Arraye List. O IEnumerable emprega uma avaliação lenta: ele percorre a coleção um item de cada vez, sem conhecer a coleção como um todo - pode até ser infinito!

É aí que Anyentra - ele retorna truese o Enumerable contiver pelo menos 1 item. Muito melhor do que calcular todo o comprimento.

Comprimento 11:

var a=1.5f;

A varpalavra-chave instrui o compilador a determinar automaticamente o tipo de a. aneste caso, será digitado como Single. Muito útil para código de golfe, pois é mais curto do que quase qualquer nome de tipo, embora muitos não gostem de usá-lo no código de produção.

Comprimento 15:

yield return 0;

Aqui está uma afirmação maluca com a qual você pode estar menos familiarizado. Você sabia que os objetos podem ser enumeráveis ​​herdando IEnumerable, mas você sabia que as funções podem ser enumeráveis? Declare uma função com um tipo de retorno IEnumerablee faça-a yield returnquantas vezes quiser. Quando você obtém um Enumerador para a função, cada chamada para GetNextque o programa execute todo o código até o próximo yield return, retorne esse valor e faça uma pausa até avançar novamente. Você usa yield breakpara finalizar a iteração.

Comprimento 16:

[Obsolete]int a;

Este trecho mostra um atributo. Um atributo é um tipo de tag que você pode colar em qualquer declaração do seu código. Alguns instruem o compilador a fazer certas coisas, como esta que emite um aviso obsoleto se você ligar a. Você pode criar seus próprios estendendo Attributee pode consultá-los usando o Reflection (mais sobre isso mais tarde, talvez). Você pode usar uma meta e restringir em que tipo de declaração um atributo pode ser usado com o AttributeUsageatributo.

Comprimento 17

c.Count(t=>t==3);

Aqui está um método útil de golfe. Dado Funcque mapeia um elemento do enumerável cpara bool, ele retorna o número de elementos cpara o qual ele Funcretorna true. Muito melhor do que escrever um loop.

Comprimento 18:

foreach(T t in c);

Este é um loop para cada um. Com toda essa conversa de inúmeras coisas, essa é uma estrutura muito necessária. foreaché o açúcar sintático que configurará um enumerador para c(que deve ser enumerável) e iterará um elemento tpor vez. Você pode alterar ou examinar cada elemento individual, mas alterar a própria coleção invalidará o enumerador.

Comprimento 19

c.Select(t=>t.a/2);

Esta é a sua função 'map', para os fãs de programação funcional. Select é uma maneira concisa e agradável de realizar alguma conversão arbitrária (definida por uma Funcpassagem) em cada elemento de um enumerável. Ele retorna um IEnumerable que cuspirá os elementos "convertidos" quando você o iterar.

Comprimento 21

Console.Write("Hi!");

Esta linha grava algum texto no stdout e é provavelmente um dos principais motivos pelos quais o C # não é muito usado no golfe!

Comprimento 23

typeof(T).GetMethods();

O C # suporta um recurso muito poderoso chamado Reflexão. O Reflection permite examinar a estrutura do seu código em tempo de execução. Por exemplo, esta chamada retornará uma matriz de todos os métodos no tipo especificado. Você pode examinar esses métodos, chamá-los ou até modificar os valores de campos e propriedades. Os atributos (consulte o Comprimento 16) são uma boa maneira de marcar partes do seu código para uso com o Reflection.

Comprimento 25

from t in c select t.a/2;

Isso é SQL? No código C #? Bem perto. Essa expressão faz a mesma coisa que a do comprimento 19.

Comprimento 27

for(var l;;l=new object());

C # é uma linguagem de coleta de lixo, o que significa que qualquer memória que você alocar (usando a newpalavra - chave) pode ser liberada automaticamente desde que não exista nenhuma referência a ela. Esse código funcionará feliz para sempre, mesmo que eu nunca liberte explicitamente a memória criada. Porém, a coleta de lixo tem custos - pesquise na web para saber mais.

Comprimento 29

var e=Enumerable.Range(0,99);

Enumerable.Rangeé uma função de golfe potencialmente útil. Ele retorna uma estrutura que pode ser enumerada e produzirá cada número no intervalo especificado, em ordem. O segundo parâmetro é uma contagem, não um índice.

Comprimento 31

public int pr{get;private set;}

Aqui, podemos mostrar uma 'propriedade' simples, um recurso OOP e outra marca registrada do C #. Se você já usou o Java, provavelmente criou os métodos 'get' e 'set' para um campo para separar sua acessibilidade ou executar o código quando ele é alterado. Bem, o C # permite declarar esse código no topo do campo e também definir modificadores de acesso separados para obter e configurar. Esse snippet específico cria automaticamente um getter e um setter padrão, mas torna o setter privado.

Comprimento 32

public static void m(this T o){}

Esse snippet mostra um recurso C # que é bom para o design da API. Ao aplicar o thismodificador ao primeiro parâmetro de um método estático, esse método se torna um método de "extensão". Uma vez declarado, T.magora pode ser chamado em qualquer objeto do tipo T como se fosse realmente um método de T. Isso pode ser usado para adicionar novas funcionalidades a qualquer classe existente, sem modificar ou mesmo ter acesso ao seu código-fonte.

Comprimento 38

int f(int a,ref int b,out int c){c=0;}

Este método mostra diferentes tipos de passagem de parâmetro que você pode ter em C #. Parâmetros não modificados são passados ​​por valor . Os parâmetros prefixados por refsão passados ​​por referência: você pode atribuir um objeto completamente novo a eles e eles o levarão de volta ao método. Os parâmetros prefixados por outsão como valores de retorno adicionais: é necessário atribuir a eles um valor no método, e eles são executados da mesma forma que os parâmetros ref.

Comprimento 42

Console.Write("It is \{DateTime.Now()}.");

O novo padrão C # 6 pode economizar alguns caracteres quando você precisar gerar cadeias montadas, usando a interpolação de cadeias. Esse recurso permite que você escreva qualquer expressão entre chaves dentro de uma literal de cadeia, e a cadeia será montada automaticamente com os valores dessas expressões em tempo de execução.

Comprimento 48

IEnumerable f(){for(int a=0;;)yield return a++;}

Agora, apenas personagens suficientes para fazer algo com um objetivo real! Esse método usa algumas das idéias que exploramos acima para criar um Enumerable infinito que simplesmente retornará os números inteiros, um por um, começando com 0. Lembre-se de que o C # emprega uma avaliação lenta com Enumerables, portanto, uma sequência infinita é perfeitamente válida - você pode itere a sequência que quiser e saia a qualquer momento.

Comprimento 56

int p{get{return mP;}set{mP=Math.Max(value,0);}};int mP;

Aqui está outro exemplo de uma 'propriedade' (consulte o trecho 31). Aqui, na verdade, defini fragmentos de código diferentes para gete em setvez de usar os automáticos como antes. Este exemplo demonstra como você pode usar uma propriedade para validar o valor atribuído a uma variável - aqui, não é permitido que o valor se torne menor que 0. Outros bons usos das propriedades incluem notificar um evento quando um valor é alterado ou reconstruir valores em cache que pode ser baseado neste.

Comprimento 65

int v;public static implicit operator int(Program o){return o.v;}

Esse recurso é chamado de conversão implícita. É como um método de extensão, pois é um código estático que opera em uma classe específica (veja o fragmento 32). No entanto, a conversão implícita não é usada para chamá-lo - é usada simplesmente tratando um Programobjeto como um número inteiro (por exemplo int i=new Program()). Ao fazer isso, o objeto será convertido silenciosamente no tipo em que você o está usando, com base no código na conversão implícita. A melhor prática diz que isso é feito apenas quando nenhuma informação é perdida como resultado da conversão.

Java

Fragmento de comprimento 44

Object a=System.out.append("Hello, World!");

Imprime Hello, World!em STDOUT.

Snippet de comprimento 43

float[][][][][]a=new float[5][3][7][2][10];

acontém 10 matrizes, cada uma contendo 2 matrizes, cada uma contendo 7 matrizes, cada uma contendo 3 matrizes, cada uma contendo 5 floats.

Fragmento de comprimento 42

interface A{static void main(String[]a){}}

Um programa completo. Como tudo em um interfaceé inerentemente public, podemos omitir a palavra publicdo método principal.

Fragmento de comprimento 36

class A{class B extends A{B.B.B b;}}

Atem uma classe interna B. Isto significa que podemos declarar uma variável do tipo A.B.

Mas Bé uma subclasse de A, o que significa que possui todos os métodos, campos e classes internas de A. Assim, podemos nos referir ao tipo B.Btambém.

Neste código, vamos dar um passo além, e dar Buma variável de instância do tipo B.B.B.

A moral: as perguntas quentes sobre o SO podem ensinar muitas técnicas interessantes, embora sem sentido.

Fragmento de comprimento 35

l.stream().map("a"::equals).count()

Se lé uma lista de Strings, isso nos diz quantas delas são iguais "a".

Fragmento de comprimento 34

public static void main(String[]a)

Assinatura do método do método principal de um programa. Apenas mais 11 personagens e podemos fazer um programa completo!

Fragmento de comprimento 33

enum D {NORTH, EAST, SOUTH, WEST}

NORTH, EAST, SOUTH, E WESTsão todos constantes do tipo D.

Fragmento de comprimento 32

Files.readAllBytes("hello.txt");

Lê um arquivo inteiro, retornando um byte[]conteúdo.

Fragmento de comprimento 31

new String(new char[]{'h','i'})

Equivalente a "hi". Útil se a "chave estiver quebrada.

Fragmento de comprimento 30

new JFrame().setVisible(true);

Cria um novo quadro visível, no qual você pode colocar outros componentes.

Fragmento de comprimento 29

throws ClassNotFoundException

Força todos os métodos que chamam isso a usarem um bloco try- catchou então passam o erro para cima da pilha. As exceções verificadas são uma das decisões mais controversas dos designers de Java.

Fragmento de comprimento 28

int f(int x){return f(x-1);}

Esta função não é executada para sempre; de fato, em um computador típico, leva menos de um segundo. Obrigado, estouro de pilha.

Fragmento de comprimento 27

Object a=new String[]{"a"};

Cria uma nova matriz de seqüências de caracteres.

Snippet de comprimento 26

Object.class.newInstance()

Cria um novo Object.

Fragmento de comprimento 25

((Supplier)()->-~0).get()

É melhor evitar constantes codificadas. Essa é uma maneira orientada a objetos de obter o valor 1sem usar nenhuma constante que não seja 0.

Fragmento de comprimento 24

(Function<Long,?>)x->x+1

A função sucessora.

Fragmento de comprimento 23

l.removeIf(x->x%10==0);

Se lfor uma lista de números inteiros, isso remove todos os valores divisíveis por 10.

Fragmento de comprimento 22

int i=(new int[7])[5];

Cria uma nova matriz de sete números inteiros e obtém o quinto elemento.

Fragmento de comprimento 21

Arrays.asList(2L,"a")

Cria um ArrayList com esses elementos.

Fragmento de comprimento 20

System.out.print(s);

Imprime s.

Fragmento de comprimento 19

import java.util.*;

Permite o uso concisa de classes como List, Map, Scanner, Timer, e Random.

Fragmento de comprimento 18

Math.addExact(x,y)

Adiciona dois números inteiros xe y. Se ocorrer um estouro, o método lança uma exceção em vez de fornecer uma resposta incorreta.

Fragmento de comprimento 17

Double.MIN_NORMAL

O menor valor positivo do tipo double, em que o bit inicial do significando é 0.

Fragmento de comprimento 16

System.in.read()

Lê um único caractere do console.

Fragmento de comprimento 15

Long.reverse(x)

Inverte os bits na representação binária de x.

Fragmento de comprimento 14

int x=050+120;

xagora é 160, pois qualquer coisa que comece com 0é tratada como octal.

Fragmento de comprimento 13

private C(){}

Um construtor privado impede que outras classes o instanciam. Esse padrão é usado pelas classes Systeme Math, entre outros. Um construtor privado também pode ser usado para impor o Padrão Singleton.

Fragmento de comprimento 12

static class

Permite a criação de classes internas sem uma classe externa anexa - uma solução para um problema enfrentado por muitos programadores .

Fragmento de comprimento 11

throw null;

Muitas vezes é necessário jogar um NullPointerException, mas também é bastante prolixo. Essa é uma alternativa muito mais simples.

Fragmento de comprimento 10

int[]a,b[]

Define duas variáveis: ae b. aé do tipo int[]e bé do tipo int[][].

Fragmento de comprimento 9

switch(x)

Vai para um lugar, dependendo do valor de x.

Fragmento de comprimento 8

break a;

Quebra o bloco identificado a.

Fragmento de comprimento 7

goto x;

A gotopalavra-chave está reservada em C, C ++ e Java. Se xfor um rótulo, esse código envia o programa para o rótulo apropriado - em C e C ++. Mas, Java, desencadeia um misterioso RuntimeException. De fato, não há como usar a gotopalavra - chave em Java.

Fragmento de comprimento 6

\u003b

Termina uma declaração. Java é estranho .

Fragmento de comprimento 5

a-=-a

Dobra asubtraindo sua negação.

Fragmento de comprimento 4

a&=b

Define o valor de acomo bit a bit e de ae b.

Fragmento de comprimento 3

...

Qualquer número de argumentos, consolidados em uma matriz.

Fragmento de comprimento 2

<>

Permite que o compilador descubra qual tipo genérico você provavelmente quer dizer. Muito parecido com Java.

Fragmento de comprimento 1

@

Indica uma anotação para permitir que informações adicionais sejam mostradas sobre métodos e classes.

Factóide

Em Java, loops infinitos às vezes causam erros do compilador. Por exemplo, o loop while(true);não pode ser finalizado sem sair do método, portanto, qualquer código depois disso acionará um erro "declaração inacessível". Como o @Optimizer apontou, apenas alguns loops infinitos serão capturados dessa maneira.

Pitão

Agora, começando pelo mais novo para sua conveniência! Para ler o comprimento 30, começando pelo primeiro, vá para o histórico de revisões.

Se alguém tiver sugestões, fique à vontade para comentar.

Comprimento 52:

i=0
while s[i-n:]:print(' '*n+s)[i:n+i];i+=1;i**7**7

Retirado da minha entrada no desafio Fake Marquee Text . se nprecisa ser definido como uma sequência e um número inteiro com antecedência. Na verdade, ele não funciona bem no interpretador gratuito Python 2 que eu estava usando, então adicionei parênteses (' '*n+s)[i:n+i]e você pode vê-lo sendo executado no interpretador Python 3 aqui .

Comprimento 43:

#-*-coding:rot13-*-
cevag h"Una fubg svefg"

No Python, você pode codificar a fonte com um codec específico. Isso mostra como a fonte pode ser escrita no Rot13. A sintaxe geral é esta: # -*- coding: <codec-name-goes-here> -*-.

Aqui está traduzido:

#-*-coding:rot13-*-
print u"Han shot first"

Os uespecifica que a seguinte string literal é uma seqüência de caracteres Unicode. Isso é necessário se você deseja que suas strings também estejam no Rot13, caso contrário, todas as strings na fonte são facilmente legíveis, apesar da criptografia. Como alternativa, você pode usar .encode("Rot13")depois de cada string (não se esqueça de usar o Rot13 também.) Segundo este artigo , algumas codificações alternativas são “base64 ″,“ uuencode ”,“ zlib ”ou“ bz2 ″.

Comprimento 33:

import cmath
print cmath.sqrt(-1)

Este é o módulo do Python para números complexos (imaginários) . Isso é impresso 1j, já que o Python está em conformidade com os padrões de engenharia e usa jcomo unidade imaginária, embora eu prefira i, que é mais comumente usada em matemática, e usando je kalém idos quaternions , mas discordo. Leia a ordem dos erros / alterações aqui (não será alterada).

Comprimento 30:

f=lambda n:n*f(n-1)if n else 1

Agora, definimos nossa própria função fatorial usando recursão e o ternário if-else! Até onde eu sei, isso é tão praticado quanto em Python. Também pode ser escrito desta maneira f=lambda n:n and f(n-1)*n or 1:, mostrando alguns operadores booleanos do Python (e também feitos em 30 caracteres.) Veja o trecho de comprimento 15 para obter informações sobre a lambdasintaxe.

Comprimento 29:

import math
math.factorial(7)

Encontra o fatorial de 7, retornando 5040.

Comprimento 25:

import math
print math.pi

O módulo de matemática do Python fornece muitas funções e constantes úteis. Aqui está o PI. Retorna 3.14159265359. (No código acima, contei a nova linha como um caractere.)

Comprimento 24:

f=lambda y:lambda x:x**y

Este é um exemplo de fechamento. A chamada cube = f(3)criará uma função cúbica que poderá ser chamada com a print cube(24)impressão 13824.

Comprimento 19:

print"Hello World!"

Finalmente, há espaço suficiente para imprimir alguns resultados básicos! O espaço não é necessário aqui, porque aspas e parênteses também são delimitadores. Isso funcionará apenas no Python 2, pois o Python 3 alterou a printfunção para ser chamada como qualquer outra função. No Python 3, use print("Hello World!"). Para obter mais informações sobre a função de impressão e a diferença entre o Python 2 e 3, consulte O que há de novo no Python 3.0 .

Comprimento 16:

[x*3 for x in l]

Mais uma vez, suponha que lseja uma lista ou qualquer outro objeto iterável, como uma string ou gerador. Essa afirmação é conhecida como compreensão de lista . É muito mais curto do que usar o padrão para estrutura de loop. Aqui, ele retorna uma lista com todos os números multiplicados por 3. TAMBÉM, as seqüências de caracteres podem ser multiplicadas! Portanto, qualquer string da lista será adicionada (concatenada a si mesma) esse número de vezes.

Comprimento 15:

import this #:)

Na verdade, esse é um trecho de 11 de comprimento, mas percebi que tinha esquecido de mostrar o ovo de Páscoa (incrível) do Python ! A importação deste módulo imprime o Zen do Python (consulte o Factoid.) Fato interessante: o módulo this.pyfoi codificado no rot13, que espero apresentarei posteriormente.

Comprimento 14:

lambda x:x**.5

Isso define uma função de raiz quadrada usando a lambdasintaxe do Python para uma literal de função. Literais de função em Python podem conter apenas expressões, não instruções. Esse lambda pode ser atribuído a uma variável, passado para uma função ou executado em linha com o (lambda x:x**.5)(9)qual retorna 3.0. O uso de expoentes para uma raiz quadrada é uma alternativa à importação da sqrtfunção no mathmódulo.

Comprimento 13:

1 if x else 0

Este é um exemplo do operador if ternário do Python. Isso foi adicionado no Python 2.5 para desencorajar os codificadores de implementá-lo manualmente com operações booleanas. Aqui, 1é retornado se for xavaliado True, caso contrário, 0será retornado.

Comprimento 12:

s=input(">")

Isso imprimirá >o texto do prompt e permitirá que o usuário insira um valor. Python 2 interpreta qualquer valor digitado, portanto, qualquer string precisa de aspas. O Python 3 mudou isso, para que a entrada inserida não seja automaticamente interpretada. Para inserir entradas sem interpretá-las no Python 2, use raw_input(). No Python 2, input()é equivalente a eval(raw_input()).

Comprimento 11:

eval("2e3")

2e3é uma notação científica para o flutuador 2 x 10³. A evalfunção interpreta e avalia qualquer sequência como uma expressão. Nesse caso, ele tem o mesmo resultado que o literal 2e3ou float("2e3"). Retorna 2000.0.

Comprimento 10:

range(013)

Esta função retorna uma lista de números inteiros de 0para o valor octal 013, que é 11(exclusivo), o que significa que a lista será [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]. A função recebe até três parâmetros semelhantes à slicefunção que analisamos anteriormente: range(start, stop[, step]). A diferença é que, com apenas um parâmetro, o parâmetro representa o valor de parada.

Observe que o Python 3.x não tem equivalente. É rangesemelhante, mas na verdade é o mesmo do Python 2 xrange, retornando um objeto gerador em vez de uma lista.

Comprimento 9:

a,b = b,a

Atribuição múltipla. Esse é um recurso simples, mas elegante, permitindo atribuir vários valores ao mesmo tempo. No snippet fornecido, ele troca ae b. E a ordem da avaliação, você pergunta? Todas as expressões à direita do operador de atribuição são avaliadas antes que qualquer uma das atribuições seja feita. Isso supera muitos idiomas que exigem uma atribuição intermediária a uma variável temporária.

Comprimento 8:

#comment

Você sabe o que é ... Espere, não sabe? Você sabe, aquelas coisas que permitem digitar texto arbitrário para descrever uma linha de código, facilitando o entendimento? Não? Ah tudo bem ...

Comprimento 7:

l[::-1]

Novamente, assumindo que lé uma lista, isso retornará a lista na ordem inversa. O terceiro argumento indica o tamanho da etapa. Como todos os três argumentos podem ser valores negativos, um tamanho de etapa negativo significa iterar na ordem inversa. O primeiro e o segundo argumentos vazios mostram que estamos repetindo a lista inteira.

Estamos chegando ao ponto em que podemos começar a usar algumas construções mais interessantes!

Comprimento 6:

l[-6:]

Isso é chamado de operação de fatia . Se lfor uma lista, isso retornará uma nova lista contendo os últimos seis elementos de lcomo uma lista. -6representa o índice inicial (6 do final), e os dois-pontos pretendem continuar até o índice final depois dele (que deixamos em branco, até o final). Se nossa lista contivesse os números de 1 a 10, isso retornaria [5, 6, 7, 8, 9, 10].

Comprimento 5:

1<x<5

Um dos recursos impressionantes do Python é permitir que você encadeie operadores de comparação. Em muitos outros idiomas, isso seria digitado como 1 < x && x < 5. Fica ainda melhor quando você considera várias comparações: 1 < x < y < 5é perfeitamente válido!

Comprimento 4:

0256

Um número inteiro com um zero à esquerda é um valor octal literal. Esse também é um bom truque para ocultar o código. Isso retorna o valor decimal 174. No Python 3.x, o valor octal seria escrito como 0o256.

Comprimento 3:

`3`

Cercar uma expressão nos backticks é o mesmo que usar repr(), que retorna a representação de string de um objeto. A função tenta retornar a string de forma que, quando passada como argumento para a evalfunção, retornará o objeto original. É não o mesmo que usar str(), embora os resultados são por vezes o mesmo. Para esta entrada, '3'é retornado nos dois casos. Este é um dos meus favoritos para o código de golfe!

Funciona apenas em Python 2!

Comprimento 2:

[]

Uma lista vazia.

Comprimento 1:

_

O caractere sublinhado é um nome de variável descartável muito usado. Se você estiver usando um shell Python (intérprete interativo), no entanto, ele conterá o resultado da última instrução executada (e a retornará novamente.) Além disso, de acordo com esse segmento , ele também é usado para pesquisa de tradução no i18n.

Factoid : Python é uma linguagem semelhante a Java e C. Foi construído com uma filosofia de design específica (extraída de " PEP 20 - O Zen do Python ":

• Bonito é melhor que feio
• Explícito é melhor que implícito
• Simples é melhor que complexo
• Complexo é melhor que complicado
• A legibilidade conta

Por causa disso, embora o ponto-e-vírgula seja permitido como um delimitador de instrução, eles geralmente são omitidos em favor do uso de várias linhas para facilitar a leitura. Além disso, o recuo da linha é muito importante!

Javascript

Isso vai do mais recente ao mais antigo. Link para mim: [ editar ]

Fragmento de comprimento 51:

console.log(require('fs').readFileSync(__filename))

Um Node.JS faz quine dessa vez, embora falhe em qualquer requisito "estrito de quine", devido à leitura de seu próprio código-fonte.

Fragmento de comprimento 50:

a=new XMLHttpRequest;a.open('GET','file');a.send()

Finalmente! Uma solicitação AJAX (usando Vanilla.JS ). Inicializamos, abrimos e enviamos a solicitação, mas fiquei sem espaço para adicionar manipuladores e realmente fazer qualquer coisa com o resultado.

Fragmento de comprimento 49:

msg=new SpeechSynthesisUtterance('Hello World!');

Prepare um vocal "Hello World!". Vai ser um pouco mais trabalhoso realmente falar isso. Também podemos ajustar o volume, afinação, taxa e sotaque. Consulte API de síntese de fala em HTML5Rocks . Ainda não é suportado pelo Firefox, certamente não o IE .

Fragmento de comprimento 48:

function repeat(){setTimeout(repeat,48)}repeat()

Simule ing setIntervalrecursivamente setTimeout.

Fragmento de comprimento 47:

module.exports=function MyModule(a) {this.a=a};

NodeJS novamente, mas o princípio é o mesmo em todo lugar no JS. Esta é uma função construtora muito básica, que cria um objeto com uma propriedade ( a). A configuração module.exportsexporta a função a ser usada, require()pressionando-a.

Fragmento de comprimento 46:

canvas.getContext('2d').fillRect(46,46,46,46);

Isso requer um <canvas id="canvas"></canvas>elemento. Ele tira proveito do fato de que os elementos com IDs são preenchidos como variáveis ​​globais, para que o elemento seja acessível a partir canvasde JS. Em seguida, preenchemos com um quadrado de 46x46 em x = 46, y = 46.

Fragmento de comprimento 45:

JSON.parse(require('fs').readFileSync('jsn'))

Voltar ao nó. Aqui, analisamos um arquivo JSON chamado jsndo diretório atual.

Fragmento de comprimento 44:

(a=document.createElement('a')).href="/url";

Construindo em # 39. Agora criamos um elemento e atribuímos um atributo. Ainda não está no DOM.

Fragmento de comprimento 43:

sq=[1,2,3,4,5].map(function(n){return n*n})

Cria uma matriz dos 5 primeiros quadrados, usando map().

Fragmento de comprimento 42:

six="1+5",nine="8+1";eval(six+' * '+nine);

Isso funciona no mesmo princípio como este , mas JS falta #definee assim acaba mais feia. Ele retorna, é claro, a resposta à vida, ao universo e tudo .

Fragmento de comprimento 41:

c=function(){var i;return function(){}}()

O começo de um fechamento. cagora é uma função (a interna) com acesso à variável interna i, mas não faz nada.

Fragmento de comprimento 40:

$('p').click(function(){$(this).hide()})

Estamos descartando totalmente esses parágrafos e usando o jQuery.

Fragmento de comprimento 39:

script=document.createElement('script')

Este é o começo da adição de um novo script externo. Crie um <script>elemento vazio e mantenha uma referência a ele.

Fragmento de comprimento 38:

document.getElementsByClassName('abc')

Encontre todos os .abcelementos no documento. Claro, com o jQuery, é apenas $('.abc')...

Fragmento de comprimento 37:

b=JSON.parse(JSON.stringify(a={3:7}))

Cria dois objetos idênticos, mas dissociados,, ae b. Se você faria

a={a:1};
b=a;
b.a=3;

você acabaria com a=={a:3}, porque ae bapontaria para o mesmo objeto. Usamos o JSON para dissociá-los.

Fragmento de comprimento 36:

(function f(){return "("+f+")()"})()

Uma solução . Ele imprime seu próprio código fonte.

Fragmento de comprimento 35:

document.body.style.display="none";

Veja # 32. Este apenas oculta o documento, sem substituir o conteúdo.

Fragmento de comprimento 34:

Object.prototype.toString.call(34)

Ligar Object.prototype.toStringé uma boa maneira de dizer o tipo de um objeto. Enquanto 34..toString()estiver "34", o trecho é [object Number].

Fragmento de comprimento 33: (o crédito deste é para um usuário anônimo )

+0%-0.&(v\u0061r=~void[{}<<!(0)])

Acha que este JavaScript não é válido? Melhor experimentá-lo ... (use o Chrome);)

Fragmento de comprimento 32:

document.body.innerHTML="hacked"

Halp! Hazxxors! Onze !! 11!

Fragmento de comprimento 31:

a=[];for(i=0;i<31;i++)a.push(i)

Sem brincadeira, estou esperando há tanto tempo para poder usar um forloop! Este cria uma matriz de 0 a 30.

Fragmento de comprimento 30:

new Date().getDay()==1?"S":"E"

Primeira vez usando o operador ternário. Eu não poderia caber mais do que isso em 30 caracteres, então só sabemos se hoje é domingo ou algo mais. : P

Fragmento de comprimento 29:

Object.keys(window).push('i')

Object.keys(window)obterá uma matriz das variáveis ​​globais (propriedades de window). .push()anexará um item a essa matriz. Acha que isso é equivalente window.i=undefined? Não!

Fragmento de comprimento 28:

setTimeout("a=confirm()",28)

Esperar 28 milissegundos não é tão útil, exceto para a criação de um novo encadeamento.

Fragmento de comprimento 27:

document.querySelector('a')

É uma pena que os nomes DOM sejam tão longos. Eu só consegui um link aqui.

Fragmento de comprimento 26:

JSON.stringify({twenty:6})

Veja o item 16. Agora temos o JSON real - uma string.

Fragmento de comprimento 25:

new Badge("Good Answer");

Assumindo que Badge()é uma função construtora que está usando um argumento ... um emblema de Boa Resposta foi criado!

Fragmento de comprimento 24:

do {alert(24)} while(!1)

Na verdade, eu não uso do..whilemuito, mas alguns usam . Se esse fosse um whileloop comum , não alertaria nada, porque é sempre falso. do..whilesempre será executado pelo menos uma vez, então conseguimos ver 24.

Fragmento de comprimento 23:

window.parent==self.top

Todos eles se referem ao mesmo objeto, geralmente conhecido como window. Se você chamar uma função normalmente, também haverá this. São 5 maneiras de acessar o objeto global!

Fragmento de comprimento 22:

for(i in self)alert(i)

Alerte todas as variáveis ​​globais. Acontece que é isso self==window. (Veja o próximo trecho.)

Fragmento de comprimento 21:

"2"+1==21 && 2+1=="3"

Olha, são as regras de elenco de JS novamente. Esta afirmação é verdadeira, btw.

Fragmento de comprimento 20:

Math.random()<.5?0:1

Escolha um número aleatório de 0-1 e arredonde usando o operador ternário. Embora fosse mais fácil usar Math.round...

Fragmento de comprimento 19:

[1,2,3].map(i=>i*i)

Este é novo. Tipo, realmente novo. Ele usa as funções de seta ES6 para calcular os quadrados de 1, 2 e 3. Atualmente, apenas parece ser suportado pelo Firefox.

Fragmento de comprimento 18:

location.href="/";

Como o # 15, mas desta vez, ele vai para a página inicial do PPCG, não para o SE.

Fragmento de comprimento 17:

(function(){})()

É o trecho de 14, mas melhor! Agora é um IIFE.

Fragmento de comprimento 16:

obj={not:'json'}

Isso explica uma das minhas irritações. Este é um objeto , não JSON ! JSON é um formato de intercâmbio de dados baseado em objetos JavaScript, mas com um formato mais estrito.

Fragmento de comprimento 15:

open('//s.tk/')

Imagine isso. Abra a página inicial do SE, usando o http://s.tk/ redirect.

Fragmento de comprimento 14:

function f(){}

W00t! Funções! Pena que não há espaço para fazer nada.

Fragmento de comprimento 13:

Math.random()

Gere um número aleatório de 0 a 1. Deseja definir seus próprios limites? Muita sorte. (Na verdade, não é fácil.)

Fragmento de comprimento 12:

new Date<=12

Esta afirmação nunca foi verdadeira em JS. O JS não foi criado até '95 (ver factóide), muito depois de 1/1/1970 00: 00: 00.012.

Fragmento de comprimento 11:

Math.PI*121

A área de um círculo com raio 11.

Fragmento de comprimento 10:

if('j')9+1