Decifrar o código-fonte [thread de roubo para tentativas de cracking]

44

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

20 resolve

15 resolve

10 resolve

7 resolve

5 resolve

4 resolve

3 resolve

2 resolve

1 resolver

cops-and-robbers 
— PhiNotPi
fonte
1
Perl 5, tamanho 27, por Morot - print'pin '= ~ tr (a-za) (za-z) r
@ WumpusQ.Wumbley Nós temos tudo estado lá ...;)
— Martin Ender
3
Recuso-me a perder meu tempo tentando apaziguar.
Dado os dois corpos de perguntas, parece que as respostas embaralhadas / desembaralhadas são revertidas
— Mooing Duck
Ruby, 23 por MegaTom = p% ++. Métodos [80] [1 ..- 1] #
— histocrat 11/11/14

Respostas:

32

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.

— Dennis
fonte
1
Isso é loucura - como você descobriu qual era o número?
— Sp3000 6/11/11
1
Pesquisei o logaritmo (e outros) desse número, mas não obtive nenhum resultado. Agora descobri que estava usando uma precisão muito alta.
— jimmy23013
2
@ Sp3000: Eu editei minha resposta.
— Dennis
1
Muito agradável! Eu deveria ter retirado mais dois caracteres da sequência, eu acho. No meu original, eu realmente tinha os espaços ainda dentro da corda, mas mrantes de medir o comprimento. Não que você não tenha percebido isso em algum momento. ;)
— Martin Ender
25

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.

— matsjoyce
fonte
1
No Python 3 IDLE, isso gera ().
— precisa saber é o seguinte
@ hosch250 Como está em um programa (um arquivo python), nada é gerado, pois não existe print.
— precisa saber é o seguinte
Eu vejo. Eu estava fugindo da linha de comando.
— precisa saber é o seguinte
47
... "coisa" ....
— TheDoctor 4/14
4
@Irmay Por causa de curto-circuito - Python carrega a tupla e verifica se o valor da tupla é verdadeiro, uma vez que está vazio, é falso. O código para carregar a variável bciprtnunca é executado, portanto nunca produz um NameError.
— Mateon1
20

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.

— Sp3000
fonte
1
Bom trabalho! Minha solução foi bastante semelhante: list(\nprint(range is range)for aacdeeeeehmppprrrrssvwy in\noct(int is int)).
— Xnor
@xnor LOL esse nome de variável. É ruim que eu nunca tivesse pensado nisso? : P
— FryAmTheEggman 7/11
2
@FryAmTheEggman Acho que todo mundo esperava que eu usasse o truque do meu primeiro policial .
— Xnor
@FryAmTheEggman Não se preocupe, você não é o único: P
— Sp3000 /
13

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.

— Ypnypn
fonte
1
Tenha um ponto :) Para referência, o original era print 2**2**2**2/2**2**2/2**2**2/2-2**2**2*2**2-22, mas não surpreende que mais de uma opção esteja correta.
— Geobits 4/04
13

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.

— Martin Ender
fonte
Spot on. Isso foi inspirado por uma sequência no OEIS que não consigo encontrar agora.
— 22468 Peter
3
E é por isso que ter um tópico separado para ladrões é uma boa ideia. Bom trabalho!
— Dennis
11

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. :)

— Martin Ender
fonte
10
Adereços para a maçaneta da porta por serem incrivelmente enganosos print, apenas para dividi-los em pimpressão, %rregexes e icorrespondência de regex que não diferencia maiúsculas de minúsculas.
— Sp3000 5/05
11

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.

— Martin Ender
fonte
Para referência, meu original:print@substr(new exception,~$$mn+=2+$$a+++$$i++);
— bwoebi 6/11/2014
Btw. Espero que todos os cifrões e o fato de todas as letras maincontidas na cadeia induzam muito a você. Além disso, um método bastante incomum para extrair {main}, acho ;-)
— bwoebi
@bwoebi O mainrealmente não me enganou , depois de detectar exception, newe substr. Eu pensei que eles seriam apenas nomes de variáveis. Demorei um pouco para usar variáveis ​​variáveis ​​e passei a maior parte do tempo descobrindo uma ordem de operações que realmente produziria uma 5que eu poderia complementar sem usar outro conjunto de parênteses.
— Martin Ender
Bem, da próxima vez, se houver mais dólares do que caracteres, geralmente são variáveis ​​variáveis. (Nesse caso, eu também abusei dos varvares para forçar a avaliação da esquerda para a direita.) Quanto tempo você levou para detectar a nova exceção do substr? A propósito, também tenho um conhecimento mais profundo do mecanismo Zend, para que eu possa me explicar perfeitamente por que as coisas são avaliadas em que ordem e isso é bom para esses desafios ;-) Se há algo específico que você não entende, eu ' felizmente vou explicar isso para você.
— bwoebi
@bwoebi Entre no bate-papo amanhã, e podemos conversar sobre isso, mas já gastei bastante tempo hoje. ;) Quanto à sua primeira pergunta, exceptionera óbvio, o que deixava os personagens dispersos substre por newaí. Foi literalmente a primeira coisa que vi ao começar a trabalhar nele.
— Martin Ender
9

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.

— Martin Ender
fonte
8
Ruby é uma linguagem de aparência assustadora.
— precisa saber é
8

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.

— Arte
fonte
8

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!

— charredUtensil
fonte
Adicionei um comentário à resposta original para você.
— FireFly
Isso é incrível (e próximo da resposta pretendida), mas tecnicamente não é válido porque não possui saída.
— histocrat
* facepalm Bem, eu ainda me diverti.
— usar o seguinte código
2
@charredUtensil Se você não se importa em rodar seu script mais um pouco, acho que a impressão está apenas mudando o ppara antes da expressão. Presumivelmente, os caracteres restantes podem ser usados ​​para formar as constantes como você fez.
— FireFly
Na verdade, não preciso executá-lo novamente. Os últimos caracteres da cadeia podem ser reorganizados sem alterar o resultado - p %q[zyfnhvjkwudebgmaclrsx].to_i(36)/51074892Eu sei que eu quebrei minha tentativa rachaduras real embora :)
— charredUtensil
7

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.";
— Martin Ender
fonte
6

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.

— Martin Ender
fonte
Deve Pprintser print, ou pelo menos pprint?
— FireFly
@ FireFly Isso é o que a saída de depuração declarou. Talvez o intérprete Pyth defina seu próprio Pprint?
— Martin Ender
Oh, ok, não importa então.
— FireFly
6

Python, tamanho 69, por Sp3000

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

Isso foi difícil ...

— grc
fonte
1
Agradável! Para referência, o original era print(sum(map(ord,str((dict(list(((str(),str(dict())),))),list()))))), mas obviamente muitas permutações diferentes de palavras-chave funcionariam.
— Sp3000 5/11
2
Esse é um nível LISP de parênteses lá!
— Xnor
6

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!'

— Blake Walsh
fonte
Ahaha bem feito, eu pensei que o Reticências pode tropeçar pessoas, mas eu não acho
— SP3000
Vi as reticências e o zfill, mas não sabia sobre os objetos de bytes. Esses podem ser úteis em conjuntos de números inteiros para o golfe!
— feersum
Bom trabalho! Eu só vi a impressão e o .zfill, e sabia que a soma poderia fazer parte, mas não consegui resolver. Tenha um +1.
— precisa saber é o seguinte
6

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).

— ossifrage melindroso
fonte
3
Uau, bom trabalho de detetive!
— Sp3000 8/08
6

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

— kennytm
fonte
Heh, legal. Quer saber o que a solução indended era ...
— FireFly
Esta não é uma solução pretendida. A solução original não possui itens "descartáveis" como fgiillmmooprrssttou ,,,\016:::S[]____tuuvyy.
— Vi.
exec? Meu código deve ter sido mais curto ... Eu o emulei com compile+ evalporque esqueci exec...
— Vi.
Implementou a versão mais curta. Tente descobrir o truque original.
— Vi.
5

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.

— Martin Ender
fonte
Droga, eu também resolvi: /
— Optimizer
5

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.

— grc
fonte
Não, mas parabéns de qualquer maneira! Meu código era:print''.__doc__[::2][::3].split()[1].split('.')[0][:-~-~True]
— FryAmTheEggman 5/11/2014
Em retrospectiva, não deveria ter incluído as aspas ...;)
— FryAmTheEggman
@FryAmTheEggman Oh uau - bom programa! Eu estava convencido de que você pelo menos costumava dir()encontrar o 'get'. E sim, teria sido muito difícil sem as aspas.
— grc
5

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.

— feersum
fonte
Hmm ... parece que eu era um grande desperdício com meus parênteses. Tinha print(~(~(()<())<<((()<((),))<<(()<((),)))))originalmente.
— Sp3000 #
5

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...)

— bwoebi
fonte
E eu não sei como é que você descobrir isso :) Original: _:print_r(chr(3*pow(2,5)+@++$i));if(@$i<4<<1)goto _;.
— Kenorb
3
@kenorb a) você precisa imprimir algo, então echonão é possível; printpermaneceu; b) você precisa de algum loop, mas, para um forloop, não havia ponto e vírgula suficiente, e bem, há dois pontos ... então provavelmente um rótulo lá em combinação com goto; c) então é necessário um if para abortar o goto-loop. Tendo agora X:print($Y);if($Y)goto X;(X e Y sendo espaços reservados); d) há um ++, mas não =, então provavelmente alguns ++$Zde 1 a 8; e) para obter letras de um número inteiro, precisamos chr()(geralmente) - estava lá; f) agora eu só precisava encontrar os números 96 e 8 para chr e if. Em seguida, preencha espaços reservados e volià.
— bwoebi
5

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!

— feersum
fonte
5

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
— Daniel Wagner
fonte
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.