Este é o tópico complementar para o desafio principal Desembaralhar o código-fonte . Se você acha que conseguiu decifrar uma das respostas da polícia, deve postar sua solução como resposta a esta discussão.

Como lembrete, você tem uma tentativa de quebrar cada envio. Sua tentativa de quebra será uma versão sem codificação do código-fonte. Se o seu palpite corresponder à descrição (mesmos caracteres, resultado e, é claro, o idioma), e você for o primeiro palpite correto, então ganhará um ponto. É importante observar que o seu programa não precisa corresponder exatamente ao original, basta usar os mesmos caracteres e ter a mesma funcionalidade. Isso significa que pode haver mais de uma resposta correta.

O ladrão com mais pontos (rachaduras bem-sucedidas) vence.

Entre os melhores

Muitos resolve

• Martin Büttner: (Python 3, 16, matsjoyce) , (CJam, 15, Ypnypn) , (Mathematica, 29, Fox Wilson) , (JavaScript, 15, Caridorc) , (CJam, 52, user23013) , (Pyth, 11, isaacg) , (PHP, 22, kenorb) , (PHP, 13, kenorb) , (ruby, 17, maçaneta) , (PHP, 49, bwoebi) , (Mathematica, 35, Tally) , (GolfScript, 13, Peter Taylor ) , (JavaScript, 25, Cris) , (JavaScript, 29, Cris) , (JavaScript, 26, Cris) , (Bash, 33, Debasis) , (JavaScript, 10, Cris), (Lua, 28, ChipperNickel) , (Mathematica, 18, Arcinde) , (JavaScript, 30, Qwertiy) , (CJam, 13, user23013) , (JavaScript, 41, Ismael Miguel) , (Ruby, 38, maçaneta da porta) , (Marbelous, 36, es1024) , (PHP, 33, Ismael Miguel) , (JavaScript, 29, Joe) , (JavaScript, 28, Shawn Holzworth) , (Ruby, 35, histocrata) , (CJam, 19, Ypnypn) , (Ruby, 17, Stephen Touset) , (JavaScript, 36, MegaTom) , (JavaScript, 24, fogcityben) , (Python 3, 21, Reticalidade) ,(JavaScript, 10, Jamie Barker) , (JavaScript, 15, Jamie Barker)

20 resolve

• feersum: (Python 3, 44, Sp3000) , (C, 70, es1024) , (MATLAB, 41, COTO) , (Brainfuck, 118, Sp3000) , (C, 30, etirárico) , (C, 28, Mig) , (Python 3, 46, hosch250) , (Java, 70, Rodolvertice) , (C, 29, imallett) , (Java, 226, nhahtdh) , (Computador pequeno, 63, O lobo) , (Python 2, 89 , Beta Decay) , (Python 2, 41, muddyfish) , (C, 63, es1024) , (C ++, 192, Arcinde) , (Java, 108, durron597) , (C #, 604, eshansingh1) ,(C, 44, Art) , (Java, 134, Olavi Mustanoja) , (Bash, 47, Vi.)

15 resolve

• user23013: (CJam, 18, Ypnypn) , (JavaScript, 26, hsl) , (CJam, 12, COTO) , (PHP, 23, bwoebi) , (PHP, 54, Steve Robbins) , (CJam, 32, Dennis) , (CJam, 19, Martin Büttner) , (Bash, 23, The Wolf) , (Ruby, 33, maçaneta da porta ) , (CJam, 34, Dennis) , (JavaScript, 82, Ismael Miguel) , (PHP, 80, Ismael Miguel) , (QBasic, 43, DLosc) , (QBasic, 42, DLosc) , (ECMAScript, 90, Cris)

10 resolve

• ossifrage squeamish: (Python, 44, Caridorc) , (PHP, 52, PleaseStand) , (Befunge-93, 17, user23013) , (BBC BASIC, 187, decaimento beta) , (C, 43, Allbeert) , (Ruby, 58, Rodolvertice) , (JavaScript, 32, hsl) , (PHP, 33, kenorb) , (Python 2, 16, imallett) , (PHP, 53, PleaseStand)
• Sp3000: (Python, 154, Fox Wilson) , (Python, 48, kgull) , (Python, 68, chifres) , (Python 2, 38, FryAmTheEggman) , (Python 2, 57, FryAmTheEggman) , (Python, 74, xnor) , (JavaScript, 66, Cris) , (JavaScript, 70, Cris) , (Python 2, 37, muddyfish) , (Python, 55, FireFly)

7 resolve

• grc: (Python 2, 61, FryAmTheEggman) , (Perl 5, 47, chilemagic) , (Python, 69, Sp3000) , (Perl, 39, GentlePurpleRain) , (Perl, 36, ossifragem sensível) , (Python 3, 110 , Sp3000) , (C, 53, FireFly)

5 resolve

• hsl: (CoffeeScript, 25, Martin Büttner) , (Golfscript, 20, Josiah Winslow) , (Lua, 18, user3155415) , (Python, 54, kgull) , (Aritmética, 31, Cris)
• PleaseStand: (PHP, 14, Tryth) , (C ++, 56, hosch250) , (PHP, 21, kenorb) , (QBasic, 37, DLosc) , (JavaScript, 46, FireFly)

4 resolve

• bwoebi: (PHP, 52, kenorb) , (PHP, 30, Tryth) , (PHP, 27, kenorb) , (PHP, 44, kenorb)
• FireFly: (JavaScript, 94, Shawn Holzworth) , (Python, 34, Sp3000) , (Brainfuck, 39, Mig) , (JavaScript, 69, Shawn Holzworth)

3 resolve

• Otimizador: (JavaScript, 61, jsh) , (JavaScript, 47, palerdot) , (JavaScript, 42, Shawn Holzworth)
• es1024: (PHP, 46, Ismael Miguel) , (shell Python, 15, xnor) , (shell Python, 21, xnor)
• DLosc: (Python, 41, Sp3000) , (Ruby, 37, Rodolvertice) , (CJam, 14, Usuário23013)

2 resolve

• xnor: (Python 3, 37, matsjoyce) , (Python 2, 29, Dennis)
• Daniel Wagner: (Haskell, tamanho 34, Petr Pudlák) , (Haskell, 42, orgulhoso haskeller)
• nneonneo: (Python, 41, Sp3000) , (C, 43, FryAmTheEggman)
• Arte: (C, 51, es1024) , (C, 48, es1024)
• n̴̖̋h̷͉̃a̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳: (Java 6+, 101, Rodolvertice) , (Java, 97, Olavi Mustanoja)

1 resolver

• Ypnypn: (Python 2, 50, Geobits)
• matsjoyce: (Python 3, 12, xnor)
• user1354557: (Python, 56, Fox Wilson)
• Dennis: (CJam, 20 anos, Martin Büttner)
• isaacg: (Pyth, 71, FryAmTheEggman)
• ConMan: (SAS, 17, usuário3490)
• Arcinde: (JavaScript, 285, Decaimento beta)
• Shawn Hotazworth: (Javascript, 82, TrungDQ)
• nooodl: (Ruby, 49, maçaneta da porta )
• Bhante Nandiya: (Python 3, 37, Sp3000)
• Geobits: (APL, 17, user23013)
• histocrata: (Ruby, 23, MegaTom)
• ProgramFOX: (Python, 13, Reticalidade)

CJam, tamanho 20, de Martin Büttner

Hi "petStorm!", mame

Experimente online.

Como funciona

Hi                      "           int(17)                     ";
   "petStorm!",         "                    len('petStorm!')   ";
                ma      "     atan2(       ,                 )  ";
                  me    " exp(                                ) ";
                        " exp(atan2(int(17), len('petStorm!'))) ";

Quebrando o código

A saída desejada,, 2.956177636986737é um Duplo ou um Duplo seguido de um Longo.

Usando apenas os caracteres "Stop, Hammer time!", existem quatro operadores internos que retornam Doubles não inteiros:

• mS, qual é asin
• ma, qual é atan2
• me, qual é exp
• mt, qual é tan

Todos eles contêm um m, para que possamos usar no máximo três deles. Existe apenas um Se um a.

Todos esses operadores precisam de entrada e maé o único que consome duas entradas. Temos apenas três maneiras de empurrar Longs:

• "...",, que aumenta o comprimento da string (estritamente menor que 18).
• H, que empurra 17.
• ...!, que empurra o NOT lógico de ....

Não temos como empurrar algo falso ..., então a última opção sempre empurrará 0.

A saída não começa ou termina com 17ou 0. Como 15 dígitos decimais é o número usual de dígitos para um Double, parecia provável que a saída fosse um Double simples.

Supondo isso, o código deve estar em uma das seguintes categorias:

• <Long> <mS|me|mt>{1,3}
• <Long> <mS|me|mt>{x} <Long> <mS|me|mt>{y} ma <mS|me|mt>{z}.
• Qualquer uma das opções acima, com alguma conversão para Long ( i) ou arredondamento ( mo) aplicada a um Double.

No segundo caso, x + y + zé 1 ou 2 e um dos Longs é 0 ou 17.

O resto era basicamente força bruta. Depois de algumas tentativas,

18 , {H \ ma me 2.956177636986737 =} =

retornado 9, significando que

H 9 ma me

produz a saída desejada.

Tudo o que resta é eliminar todos os caracteres, exceto 9, da string. Os espaços são noops e são longos ino Longs, portanto, "petStorm!"é uma das opções possíveis.

Python 3, tamanho 12, por xnor

()and bciprt

Não faz nada (a expressão produz uma tupla vazia, que não é impressa). Isso funciona devido à avaliação de curto-circuito.

Python, tamanho 74, por xnor

any(print(set is
set)for i in oct(chr is
map))and aeeeeeggiilnnpprrrrrstvw

Bem, isso foi divertido. Obrigado a FryAmTheEggman, hosch250 e isaacg por sugestões / ajuda.

Python 2, tamanho 50, por Geobits

print 2**2**2*2**2-22-2**2**2**2/2**2**2**2**2/2/2

Saídas 42.

GolfScript, tamanho 13, de Peter Taylor

,22,{.4&?+.}/

Teste aqui.

Outro, que eu só rachei com grande ajuda do Sp3000. Obrigado!

Então aqui está como chegamos lá. O Sp3000 notou várias execuções de números consecutivos na saída:

1,2,3,4,[2608852181],4582,4583,4584,4585,4586,[253225388392299],
142924,142925,142926,142927,142928,[302928],497409,497409

Com base nisso, assumimos que essa era uma sequência crescente, que só permitia uma possível divisão dos números restantes:

1,2,3,4,260,885,2181,4582,4583,4584,4585,4586,25322,53883,92299,
142924,142925,142926,142927,142928,302928,497409,497409

São 23 números, o que foi um forte indicador para repetir o bloco 22 vezes, além de terminar o bloco com .(elemento duplicado da pilha superior), para que o resultado anterior seja deixado para trás na pilha e para que a iteração final apareça em a pilha duas vezes. É isso 22,{____.}/.

Agora, olhando para as lacunas, elas acabam sendo o quarto poder (o que é bom, porque temos 4e ?). Mais precisamente, eles são a quarta potência do índice do número atual. Então, em seguida, examinamos quais índices criavam uma lacuna:

4,5,6,7, 12,13,14,15, 20,21,..?

Em binário, esses são

00100
00101
00110
00111
01100
01101
01110
01111
10100
10101

Todos eles têm o terceiro bit definido, o que significa que o índice provavelmente é apenas bit a bit 4(e isso é bom novamente, porque podemos fazer outro 4com .e ter um &). Isso funciona particularmente bem, porque essa operação resulta em um 0ou outro 4, e se o usarmos como expoente, obtemos um 1ou um quarto poder, que é exatamente o que precisamos. Então, vamos juntar isso:

22,{.4&?+.}/

Aqui está o que o bloco faz:

.      # Duplicate current index
 4     # Push a 4
  &    # Bitwise and
   ?   # Raise index to resulting power
    +  # Add to previous result
     . # Duplicate for use in next iteration

Agora, restavam dois problemas: tínhamos um desvio ,que ainda não usamos e a primeira iteração é um caso especial, pois não há valor de uma iteração anterior à qual possamos adicionar coisas ao encontrar +. Descobrimos que, graças a um comentário não relacionado do usuário23013, que mencionou casualmente que o GolfScript começa com uma string vazia na pilha (se não houver nada no STDIN). Assim, poderíamos usar essa outra ,logo no início para transformar essa string em um 0, que era exatamente o que precisávamos como o início da iteração.

Python 3, tamanho 16, por matsjoyce

import __hello__

Ruby, tamanho 17, por Doorknob

p 2,%r~n~i=~'*tN'

Isso foi muito divertido. Agradeço ao Sp3000 por me ajudar com isso! E aprendi que %r?...?literais podem ter delimitadores. :)

PHP, tamanho 49, por bwoebi

print@substr(new exception,+~$$a+=++$$m+$$i+2+n);

Isso foi absolutamente mental .

Chegou a

print@substr(new exception,);

muito rapidamente, momento em que eu precisava de algo que -6depois da vírgula, depois de $++$++$++$+=$~main$2sair.

O principal problema é que $a, $me $isão todos NULL, então usá-los indiretamente em variáveis ​​variáveis significa que todos apontam para a mesma variável. No entanto, o PHP parece estar fazendo algumas coisas estranhas na resolução de variáveis ​​variáveis. Com variáveis ​​normais, você pode fazer coisas como

echo $a+$a=2;

que imprime 4(o 2é atribuído $ae depois adicionado a si mesmo). Mas se eu fizer o mesmo com variáveis ​​variáveis:

echo $$a+$$a=2;

Eu entendo 2, porque agora o primeiro $$aé avaliar antes da tarefa.

No final, consegui forçar alguma ordem colocando alguns acréscimos no RHS dos +=quais tinham que ser avaliados antes dessa atribuição de adição. Dessa forma, cheguei ao 5qual poderia apenas complementar um pouco. Ainda assim ... há algumas coisas misteriosas acontecendo, e eu não tenho idéia do porquê metade das coisas que tentei funcionaram e não funcionaram.

Ruby, tamanho 38, por Doorknob

[$><<(!$pece60).to_s[rand($win)].succ]

Tenho certeza de que isso não está nem perto da fonte original. É determinístico apesar de usar rand.

Aqui está como este funciona. $><<é apenas saída. $pece60e $winsão variáveis ​​globais indefinidas, que, portanto, são justas nil(e me permitiram me livrar de alguns caracteres estranhos). !$pece60faz a truee to_sdá a string "true".

Por anos, tentei obter um 2ou -2acessar isso ulá, mas depois percebi que poderia pegar o te chamar .succ(essor) para fazer um u.

randcom um nilparâmetro retorna uma flutuação aleatória no intervalo [0,1). Ao usar floats para indexar em strings, eles são truncados para números inteiros; portanto, isso sempre retornará o primeiro caractere.

Finalmente, eu tinha um par extra, []então apenas envolvi tudo, porque felizmente tudo é uma expressão em Ruby.

Obrigado ao Sp3000 por lançar algumas idéias no chat.

C, 51 por es1024

c=0xf.cp9,hhtaglfor;main() {;; printf("%d",(++c));}

Após 20 anos de programação C hoje, aprendi sobre constantes hexadecimais de ponto flutuante.

Ruby, 45 (histocrata)

%q[zyfnhvjkwudebgmaclprs x].to_i(36)/51074892

Woohoo! Esta é minha primeira falha em um problema de código de golfe, e eu não tenho representante suficiente para comentar a postagem original. Reconheci imediatamente o truque usado, pois encontrei o uso no código de produção com frequência. Demorou cerca de 5 minutos para descobrir a maior parte da estrutura e algumas horas para chegar à resposta completa.

Explicação:

• %q[]é um método alternativo para criar strings. Parênteses e chaves também podem ser usados.
• String#to_i no Ruby aceita números em qualquer base de 2 a 36. Ele ignorará o primeiro caractere na string que não faz parte do número, para que quaisquer caracteres extras possam ser "jogados fora" após o espaço.

E aqui está o código que eu usei para decifrá-lo:

require 'set'

# return true if the string is made up of unique characters
def uniq(s)
  a = s.each_char.to_a
  return a == a.uniq
end

def uniq_while_same(a,b)
  s = Set.new
  a.each_char.zip(b.each_char).each do |ai, bi|
    return true if ai != bi
    return false if s.include? ai
    s << ai
  end
  return true
end

def ungolf(answer)
  # For each base that even makes sense
  [            36, 35, 34,     32, 31, 30,
   29, 28, 27, 26, 25, 24, 23,     21, 20,
   19, 18, 17, 16, 15, 14, 13, 12,     10].each do |base|
    # Ignore bases where it is not possible to create a unique-string number greater than answer
    next if answer > base ** base
    # Pick digits for the denominator that are not duplicates of the digits in base
    denominator_digits = ('1234567890'.each_char.to_a - base.to_s.each_char.to_a)
    # For each permutation of those digits for the denominator
    (1..10).each do |denominator_length|
      denominator_digits.permutation(denominator_length) do |denominator_s|
        # Maybe the denominator is in octal
        denominator_base = 10
        if denominator_s[0] == '0'
          next if denominator_s.include?('8') || denominator_s.include?('9')
          denominator_base = 8
        end
        denominator_s = denominator_s.join
        denominator = denominator_s.to_i denominator_base
        print "#{"\b"*64}(%q[#{(answer * denominator).to_s(base).ljust(36)}].to_i #{base})/#{denominator_s.ljust(10)}" if rand < 0.01
        # Ignore denominators that are definitely impossible to have answers for
        next unless uniq_while_same "qtoi#{base}#{denominator_s}#{(answer * denominator).to_s(base)}",
                                    "qtoi#{base}#{denominator_s}#{((answer + 1) * denominator).to_s(base)}"

        # For each numerator that gives answer when divided by the denominator
        (answer * denominator...(answer + 1) * denominator).each do |numerator|
          print "#{"\b"*64}%q[#{numerator.to_s(base).ljust(36)}].to_i(#{base})/#{denominator_s.ljust(10)}" if rand < 0.01
          # Remove any that are still not unique
          s = "#{numerator.to_s(base)}#{base}#{denominator_s}qtoi"
          next unless uniq s
          # Done. Compute which characters need to be thrown away to fill the remaining space
          remains = ('0123456789abcdefghijklmnopqrstuvwxyz'.each_char.to_a - s.each_char.to_a).join
          print "#{"\b"*64}#{" "*64}#{"\b"*64}"
          return "%q[#{numerator.to_s(base)} #{remains}].to_i(#{base})/#{denominator_s}"
        end
      end
    end
  end
  print "#{"\b"*64}"
  puts "\nnone"
  return nil
end


print ungolf 9410663329978946297999932

Maneira de incorporar um problema de NP dentro de um enigma. Eu fui completamente nerd. Bom trabalho!

Python [any] shell size 44, da Caridorc

__name__[3]  or (enfin_____[42], manager[1])

Tenho certeza de que deveria haver mais do que isso, mas como __name__equivale a __main__, o quarto caractere 'a' é selecionado e o restante da linha nunca é avaliado.

Perl, tamanho 36, por ossifrage sensível

$_=rof;for$i(1..2129<<7){$_++}print;

Outro difícil.

CJam, tamanho 13, pelo usuário23013

G,Cf#If/sE*K%

Teste aqui.

Resolvido à mão, da seguinte forma:

Primeiro, alguns antecedentes para não-CJammers:

• CEGIKsão todas as variáveis, que são pré-inicializados para 12, 14, 16, 18, 20, respectivamente.
• s converte o elemento da pilha superior em uma sequência.
• As strings são tecnicamente apenas matrizes de caracteres.
• fé muito mágico. Para a finalidade desta resposta, a versão simplificada é que, para uma matriz a, algum outro valor be um operador g, a sequência de abfgmapas g(_,b)para a(onde cada elemento de avai para a _ranhura).
• / é divisão e divisão de matrizes (entre outras coisas).
• * é multiplicação e repetição de array (entre outras coisas).
• %é um módulo e uma operação estranha, que na forma ad%de array ae número inteiro dleva todos os delementos th a(como o fatiamento do Python com a largura do passo d).
• # é exponenciação (entre outras coisas).
• ,transforma números em intervalos (de 0a n-1) e retorna o comprimento de uma matriz.

Ok, isso fora do caminho ...

Era bastante óbvio que precisávamos ,transformar um número em um intervalo, porque a única outra maneira de obter um array seria construir um número maior e transformá-lo em um array de caracteres s- mas não poderíamos ter feito nada. aritmética adicional. E precisamos de uma matriz para fazer algo com os fs.

Primeiro, assumi que os fs foram usados ​​com #e %, mas isso significaria que precisaríamos de um número em torno de 90 para obter a quantidade certa de dígitos no final. Além disso, isso não explicava o que fazer e s, como a resposta parecia realmente desafiadora, duvidei que o user23013 anexasse an scomo um no-op eficaz em algum lugar para afastar as pessoas.

Então eu pensei, talvez ele nem esteja mantendo os números pequenos %, mas em vez disso, ele constrói uma série de grandes números, concatena sua representação de cadeia de caracteres com s, mas só escolhe uma fatia estranha dela %. Então eu brinquei um pouco com a seguinte estrutura:

__*,_f#_f/s_%

(Você não pode fazer _f/primeiro, porque isso renderia zero para pelo menos os 12 primeiros elementos.)

Onde _estão algumas permutações das variáveis. Eu não tentei todos eles antes de ficar entediado, e o principal problema disso era que a sequência de dígitos resultante sempre era longa demais.

Em algum momento, ocorreu-me que não precisaríamos de um intervalo tão grande (ou seja, o produto de dois números), se, em vez disso, usássemos o *para repetir a sequência resultante. Devido à incompatibilidade dos parâmetros de *e %isso não produziria repetição no resultado:

_,_f#_f/s_*_%

Isso produziu resultados muito próximos do que eu estava procurando. Na verdade, eu teria tentado todos os 240 deles, mas rapidamente (terceira ou quarta tentativa), me deparei com

E,Cf#If/sG*K%

que produz

03081942753650251594592190492275006661328850322159030034930530649722385533653290754678977

E imaginei que uma correspondência dos seis primeiros dígitos não seria uma coincidência. Portanto, a questão era como reorganizá-lo sem perturbar o cálculo real:

• Não pude mudar Kporque isso selecionaria dígitos diferentes por completo.
• Não pude mudar Cou Iporque isso mudaria os números resultantes das duas operações do mapa.
• Se eu mudasse, Gisso mudaria apenas o número de repetições, o que não faria nada além de alterar a duração do resultado. (Qual é bom.)
• Se eu mudasse, Eisso mudaria o intervalo da matriz, mas o intervalo ainda começaria [0 1 2 3 ...], para não afetar o cálculo. Ele iria afetar o comprimento da corda de base retornado por s, o que também significa que K%escolhia diferentes dígitos em cima repetições adicionais.

Então, eu apenas tentei trocar Ee Ge voila:

030819828850379075460427536222159187897761502517030034671154875945928930530907551421904962649729

Em resumo, aqui está o que o código faz:

G,            "Push [0 1 2 3 ... 13 14 15].";
  Cf#         "Raise each element to the 12th power.";
     If/      "Divide each element by 18.";
        s     "Concatenate all numbers into a string.";
         E*   "Repeat 14 times.";
           K% "Pick every 20th digit.";

APL, tamanho 17, pelo usuário23013

+(3*3)3,(***)\3 3

Passei muito tempo demais tentando quebrar isso. Provavelmente teria sido mais rápido se eu conhecesse a APL entrando.

Experimente aqui

Pyth, tamanho 11, por isaacg

:\\w$ ",d,N

Isso é algum abuso médio de insetos ali. Isso compila para:

Pprint("\n",at_slice("\",input(), ",d,N))

O bug relevante é que ele \\compila em "\"vez de "\\", o que permite compilar Pyth em uma string.

Python, tamanho 69, por Sp3000

print(sum(list(map(ord,str((dict(((str(dict()),list()),)),str()))))))

Isso foi difícil ...

Python 3, 37 bytes, por Sp3000

print(sum(b"a".zfill(len(str(...)))))

Embaraçosamente, de longe, a parte mais difícil foi descobrir a conversão da string em bytes. Eu tive que dormir nele, e à noite percebi 'duh, é um literal de bytes!'

PHP, 53, por PleaseStand

Finalmente rachou:

for($d=57,$o=35;$o+$d<999;)$o+=printf("$d%o",$d+=$o);

A solução veio rapidamente quando notei que a sequência consiste em números decimais e octais alternados:

Dec: 57...92...132...177...228...285...348...417...492....573....661....756....858....
     571349220413226117734422843528553434864141775449210755731225661136475615328581707
Oct: ..134..204...261...344...435...534...641...754...1075...1225...1364...1532...1707
==Dec:  92  132   177   228   285   348   417   492    573    661    756    858    967

Além disso, os intervalos entre cada conjunto de números cresceram a uma taxa igual ao valor retornado por printf()(ou seja, o número de caracteres escritos).

Python 2, tamanho 132, de Vi.

exec('from string import printable as e\nprint "cqance"\x2Ereplace("q",e[len("fgiillmmooprrsstt")])or ",,,\016:::S[]____tuuvyy" ""')

Obrigado por todas as barras invertidas e aspas :)

Edit: A versão atualizada de 96 caracteres:

exec "try:exec'from __future__ import braces\\nt(12)'\nexcept SyntaxError as q:print(q[0][6:])"

Isso foi retirado inteiramente da solução de Alex em https://codegolf.stackexchange.com/a/41451/32353

CJam, tamanho 15, por Ypnypn

98,{7%}%{6+}%:+

A partir dos caracteres fornecidos, imaginei que deveria ser uma das três formas a seguir:

__,{_%}%{_+}%:+
_,{_%}%{__+}%:+
__,{_+}%{_%}%:+

que cria um intervalo de dois dígitos e mapeia uma operação de adição e módulo (em qualquer ordem) no intervalo, antes de somar. Então eu comecei com o primeiro e tentei sistematicamente permutações de6789 nas lacunas.

PHP, tamanho 52, por PleaseStand

for(mt_srand($i=46);$i--;)echo chr(mt_rand()%95+32);

Isso acabou sendo bastante fácil no final. A saída é muito aleatório, e os personagens m, t, _, r, a, ne dtudo apareceu duas vezes ...

Python 2, tamanho 61, por FryAmTheEggman

print(dir('~s]l.c:st_''-p_tp.l]-~.:o:Te[_u[.i_')[10][2:][:3])

Eu ficaria muito surpreso se isso corresponder ao original.

Python 3, Sp3000, tamanho 44

print(~(~(()<((),))<<(()<((),))))<<((()<()))

O Python 3 me ajudou aqui, pois pude causar um erro (deslocar a esquerda para Nonealguma coisa) depois de imprimir a resposta.

PHP, tamanho 52, por kenorb

_:@print_r(chr(@++$i+pow(3<<5,1)));if($i<2*4)goto _;

(Deus, quanto tempo demorei para descobrir o que fazer com o _rsufixo restante . Até eu perceber que não era print, mas print_r...)

PHP, tamanho 54, de Steve Robbins

echo(21<<($$$$$$${$aaaabbbbbbehi==$l&$w^2}^1==1));;;;

Não é a solução original, eu acho.

C, es1024, comprimento 70

e='C',f;main(g){Chorkil:f=printf("40%.d",e+e-  -g);}hAx;*hotpoCkats();

A parte difícil acabou sendo acompanhar todos os personagens desnecessários ... seriamente ... eu tive que refazê-los cerca de 10 vezes. O único que me preocupou foi o, .mas de alguma forma eu coloquei no meio da printfstring de formato e ficou invisível!

Python 3, tamanho 110, por Sp3000

import sys,io
u=sys.stdout;sys.stdout=_=io.StringIO()
import this
u.write(" ".join(_.getvalue().split()[::9]))

Essa foi engraçada :)

Haskell, tamanho 34, de Petr Pudlák

main=print(0xb2f3d5^0x7f1f27::Int)

Observe que este programa deve ser executado em uma máquina de 32 bits. Se você deseja verificar se este é o programa correto e se possui uma máquina de 64 bits, use-o:

import Data.Int
main=print(0xb2f3d5^0x7f1f27::Int32)

Era muito fácil adivinhar o "quadro" do programa main=print(0x<hex digits>^0x<hex digits>::Int). Toda a mágica estava em procurar o caminho certo para particionar e ordenar os dígitos. Não fui muito esperto aqui, apenas uma busca por força bruta ... embora tenha tomado o cuidado de abusar do fato de alguns dígitos serem duplicados, provavelmente havia um número igual de dígitos na base e no expoente, e o último dígito da base quase certamente não era o mesmo. O código de pesquisa completo está incluído abaixo; ele usa o pacote multiset-comb . A pesquisa completa leva cerca de 10:33 na minha máquina (e produz apenas uma resposta certa, é claro).

{-# LANGUAGE NoMonomorphismRestriction #-}
import Control.Monad
import Data.Int
import Data.List (inits, tails, group)
import Numeric
import Math.Combinatorics.Multiset

main = print (searchFor (-1121766947))

searchFor n = do
    nl <- [6,5,7,4,8,3,9,2,10,1,11]
    (l_, r_)  <- chooseSubbag nl digits
    l <- perms l_
    guard (last l /= '2')
    r <- perms r_
    guard ((fromString l :: Int32) ^ (fromString r :: Integer) == n)
    return (l, r)

chooseSubbag n = chooseSubbag' n . group
chooseSubbag' n xss = go (drop (n-1) (concat xss)) n xss where
    go _  n xss | n < 0 = []
    go _  0 xss = [([],concat xss)]
    go [] n xss = []
    go m  n (xs:xss) = do
        (kx, tx) <- zip (tails xs) (inits xs)
        (k , t ) <- go (drop (length tx) m) (n-length kx) xss
        return (kx++k, tx++t)

digits = "1223577bdfff"
fromString = fst . head . readHex
perms = permutations . fromList

Javascript, 82, por TrungDQ

b=/v/[0]+' ';b[0]+b[9]+b[6]+b[7]+'v'+b[7]+((0==0)+b)[1]+b[9]+b[4]+b[5]+b[6]+b[2];

Levou uma eternidade para acertar os índices.