A lista de policiais pode ser encontrada aqui: The Mystery String Printer (Cops)

Seu desafio

• Escolha um envio no tópico da polícia e imprima a sequência a partir de uma resposta nesse tópico.
• O envio que você escolher não deve ser seguro (deve ser mais recente que sete dias).

• Seu programa, função ou script REPL precisa seguir as mesmas regras que o thread da polícia. Apenas para recapitular:

  • Seu programa deve ter ≤128 caracteres (se o envio de um policial estiver em um intervalo menor de tamanhos de programa, seu programa também deverá estar nesse intervalo de comprimento. Por exemplo, se o programa de um policial tiver ≤32 bytes, seu programa deverá ter ≤32 bytes )
  • O programa deve produzir a mesma saída toda vez que é executado.
  • Sem funções criptográficas.
  • O programa não deve receber entrada.
  • Sem brechas padrão.
• Todos os novos envios devem usar o mesmo idioma. Os envios de antes desta regra ser feita são bons, mesmo que não sejam.

Pontuação

A pontuação funciona de maneira semelhante para ladrões, mas é um pouco diferente:

• Quebrar qualquer programa de ≤8 bytes dá 1 ponto.
• Quebrar um programa de ≤16 bytes dá 2 pontos. ≤ 32 bytes fornece 4 pontos, e assim por diante.
• Cada envio adicional, independentemente do tamanho, ganha +5 pontos
• O envio de cada policial só pode ser quebrado uma vez - apenas a primeira pessoa a quebrar cada envio recebe os pontos.

Submissões

Cada resposta deve incluir

• Um link para o envio do policial.
• Seu programa e linguagem de programação.
• Também tenha o comprimento do programa do policial (como potência 2) como o último número no seu cabeçalho.

Além disso, comente o envio do policial com um link para sua resposta.

Aqui está um snippet de pilha para gerar tabelas de classificação. Deixe um comentário se houver algum problema com o snippet. Se você gostaria de ver todos os envios abertos de policiais, consulte o trecho no desafio dos policiais.

/* Configuration */

var QUESTION_ID = 60329; // Obtain this from the url
// It will be like http://XYZ.stackexchange.com/questions/QUESTION_ID/... on any question page
var ANSWER_FILTER = "!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe";
var COMMENT_FILTER = "!)Q2B_A2kjfAiU78X(md6BoYk";

/* App */

var answers = [],
  answers_hash, answer_ids, answer_page = 1,
  more_answers = true,
  comment_page;

function answersUrl(index) {
  return "//api.stackexchange.com/2.2/questions/" + QUESTION_ID + "/answers?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + ANSWER_FILTER;
}

function commentUrl(index, answers) {
  return "//api.stackexchange.com/2.2/answers/" + answers.join(';') + "/comments?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + COMMENT_FILTER;
}

function getAnswers() {

  jQuery.ajax({
    url: answersUrl(answer_page++),
    method: "get",
    dataType: "jsonp",
    crossDomain: true,
    success: function(data) {
      answers.push.apply(answers, data.items);
      answers_hash = [];
      answer_ids = [];
      data.items.forEach(function(a) {
        a.comments = [];
        var id = +a.share_link.match(/\d+/);
        answer_ids.push(id);
        answers_hash[id] = a;
      });
      if (!data.has_more) more_answers = false;
      comment_page = 1;
      getComments();
    }
  });

}

function getComments() {
  jQuery.ajax({
    url: commentUrl(comment_page++, answer_ids),
    method: "get",
    dataType: "jsonp",
    crossDomain: true,
    success: function(data) {
      data.items.forEach(function(c) {

        answers_hash[c.post_id].comments.push(c);

      });

      if (data.has_more) getComments();
      else if (more_answers) getAnswers();
      else process();
    }
  });
}

getAnswers();

var POINTS_REG = /(?:<=|≤|&lt;=)\s?(?:<\/?strong>)?\s?(\d+)/
var POINTS_REG_ALT = /<h\d>.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/;


function getAuthorName(a) {
  return a.owner.display_name;
}

function process() {

  var valid = [];
  var open = [];

  answers.forEach(function(a) {

    var body = a.body;
    var cracked = false;

    var points = body.match(POINTS_REG);
    if (!points) points = body.match(POINTS_REG_ALT);

    if (points) {
      var length = parseInt(points[1]);
      var crackedpoints = 0;
      if (length > 64) crackedpoints = 16;
      else if (length > 32) crackedpoints = 8;
      else if (length > 16) crackedpoints = 4;
      else if (length > 8) crackedpoints = 2;
      else crackedpoints = 1;

      valid.push({
        user: getAuthorName(a),
        numberOfSubmissions: 1,
        points: crackedpoints

      });
    }
  });

  var pointTotals = [];
  valid.forEach(function(a) {

    var index = -1;
    var author = a.user;
    pointTotals.forEach(function(p) {
      if (p.user == author) index = pointTotals.indexOf(p);
    });

    if (index == -1) pointTotals.push(a);
    else {
      pointTotals[index].points += a.points;
      pointTotals[index].numberOfSubmissions++;
    }

  });

  pointTotals.forEach(function(a) {
    a.points += +((a.numberOfSubmissions - 1) * 5);
  });

  pointTotals.sort(function(a, b) {
    var aB = a.points,
      bB = b.points;
    return (bB - aB != 0) ? bB - aB : b.numberOfSubmissions - a.numberOfSubmissions;
  });

  pointTotals.forEach(function(a) {


    var answer = jQuery("#answer-template").html();
    answer = answer
      .replace("{{NAME}}", a.user)
      .replace("{{SUBMISSIONS}}", a.numberOfSubmissions)
      .replace("{{POINTS}}", a.points);
    answer = jQuery(answer);
    jQuery("#answers").append(answer);


  });

}

body {
  text-align: left !important
}
#answer-list {
  padding: 20px;
  width: 240px;
  float: left;
}
#open-list {
  padding: 20px;
  width: 450px;
  float: left;
}
table thead {
  font-weight: bold;
  vertical-align: top;
}
table td {
  padding: 5px;
}

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>
<link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b">
<div id="answer-list">
  <h2>Robber's Leaderboard</h2>
  <table class="answer-list">
    <thead>
      <tr>

        <td>Author</td>
        <td>Submissions</td>
        <td>Score</td>
      </tr>
    </thead>
    <tbody id="answers">

    </tbody>
  </table>
</div>

<table style="display: none">
  <tbody id="answer-template">
    <tr>
      <td>{{NAME}}</td>
      <td>{{SUBMISSIONS}}</td>
      <td>{{POINTS}}</td>
    </tr>
  </tbody>
</table>

Este concurso está encerrado.

Vencedor geral: kennytm

Mais envios: Sp3000

(Observe que a quantidade de envios não se traduz exatamente nos pontos, pois a duração do programa com falha é contada no cálculo da pontuação).

Pyth, Dennis, ≤ 8

V./Tp*FN

Porra, isso foi divertido - a parte mais difícil foi descobrir como fazê-lo curto o suficiente em Pyth.

Análise

O 1234no início sugere que provavelmente estamos lidando com uma lista de números impressos sem separador. Vamos tentar dividir os números de uma maneira que faça sentido:

1 2 3 4 4 6 5 8 8 9 6 12 10 12 7 16 16 18 12 15 16 8 24 20 24 14 27 18 20 9 32 32 36 24 30 32 16 36 21 24 25 10

Há algumas dicas de que estamos no caminho certo:

• Todos os números têm fatores primos menores que 10
• Muitos números estão bem próximos do índice na lista

No entanto, existem algumas peculiaridades. O número no índice 23 é 24 e é o único caso em que o número no índice é maior que o próprio índice. No entanto, a pista maior é que alguns números são claramente menores que seus vizinhos, principalmente os 7 no índice 15, os 8 no índice 22 e os 9 no índice 30.

Observando que isso forma um padrão 7-8-9, também podemos ver que o último número é um 10 no índice 42. Dada a recente pergunta de @Dennis sobre grupos abelianos , uma rápida verificação no OEIS revela que 15, 22, 30, 42é uma subsequência da partição números . Pyth tem um builtin para partições, o que nos dá dois dos oito caracteres:./

Mas observe que o último número é 10, o que é suspeito, porque 10 é uma variável pré-inicializada em Pyth, como T. ./Tfornece uma lista completa das 42 partições do número 10, que parecem úteis.

Agora a impressão é feita sem um separador, portanto, isso sugere um uso de p. Talvez passemos por cada partição, façamos algo e depois imprimimos com p? Isso nos dá o seguinte modelo:

V./Tp??N

em que Vé um loop que circula ao longo de um iteráveis, armazenando cada elemento na variável N.

Uma rápida olhada na segunda última partição (5, 5)deve deixar óbvio que queremos usar um produto. A maneira ingênua de reduzir uma lista por multiplicação é

u*GHd1

Onde destá a lista em questão. No entanto, isso é muito longo.

Infelizmente, foi aqui que tive que retirar um forçador bruto. Não acompanho Pyth há um tempo, então não conhecia muitos dos recursos mais recentes. Restavam apenas dois caracteres, que pareciam totalmente factíveis.

O forçador bruto então retornou:

V./Tp*FN

onde *Fé dobrado por *(multiplicação). Não é à toa que não o encontrei na minha pesquisa - estava pesquisando a palavra-chave "reduzir" em vez de "dobrar"!

Mathematica, alfafa, ≤ 32

GroupOrder[MonsterGroupM[]]

Detesto dizer isso, mas acabei de reconhecer o número no local.

> <>, VTCAKAVSMoACE, ≤ 64

'9?':?!;1-$:'@'+o'3'*'='%$30.

Ironicamente, não só isso é muito mais baixo o limite de alcance, como também é portátil e funciona com o intérprete on - line .

Análise

Vamos começar com a string de destino:

yh[cPWNkz^EKLBiQMuSvI`n\Yw|JVXDUbZmfoRC_xrq{TlpHjGt]OadFAsgeyh[

> <> envia caracteres para a pilha com 'ou" no modo de sequência, mas com 63 caracteres para imprimir e apenas 64 bytes para trabalhar, a presença de letras maiúsculas (instruções inválidas em> <>, para o truque de loop padrão) faz a impressão direta impossível. Portanto, devemos estar fazendo algo com os pontos de código.

Convertendo em pontos de código dá (eu estou usando Python aqui):

>>> L = [ord(c) for c in "yh[cPWNkz^EKLBiQMuSvI`n\Yw|JVXDUbZmfoRC_xrq{TlpHjGt]OadFAsgeyh["]
>>> L
[121, 104, 91, 99, 80, 87, 78, 107, 122, 94, 69, 75, 76, 66, 105, 81, 77, 117, 83, 118, 73, 96, 110, 92, 89, 119, 124, 74, 86, 88, 68, 85, 98, 90, 109, 102, 111, 82, 67, 95, 120, 114, 113, 123, 84, 108, 112, 72, 106, 71, 116, 93, 79, 97, 100, 70, 65, 115, 103, 101, 121, 104, 91]

Observe que os três últimos números são iguais aos três primeiros. Isso sugere um possível loop de módulo acontecendo.

Vamos dar uma olhada em quantos elementos diferentes temos:

>>> len(set(L))
60

Temos 63 elementos L, os três primeiros coincidentes com os três últimos. Isso significa que, além dessa colisão, todos os outros elementos são únicos. Agora, isso sugere algo como tomar poderes módulo um número primo. De fato, 60 + 1 = 61é primo, o que é um bom sinal.

Vamos tentar encontrar o menor elemento

>>> min(L)
65

e use isso para reduzir todos os elementos para que o elemento min seja 1:

>>> M = [x-64 for x in L]
>>> M
[57, 40, 27, 35, 16, 23, 14, 43, 58, 30, 5, 11, 12, 2, 41, 17, 13, 53, 19, 54, 9, 32, 46, 28, 25, 55, 60, 10, 22, 24, 4, 21, 34, 26, 45, 38, 47, 18, 3, 31, 56, 50, 49, 59, 20, 44, 48, 8, 42, 7, 52, 29, 15, 33, 36, 6, 1, 51, 39, 37, 57, 40, 27]

Observe como o elemento depois 1é 51. Se houver algum tipo de coisa de multiplicação / potência, esse é um bom palpite para o nosso multiplicador.

Vamos tentar:

>>> (57*51)%61
40
>>> (40*51)%61
27
>>> all((x*51)%61 == y for x,y in zip(M, M[1:]))
True

Bingo! Agora podemos voltar atrás, fornecendo o seguinte código:

x = 57
for _ in range(63):
    print(chr(x + 64), end="")
    x = (x*51)%61

que foi traduzido para> <>

Pyth, Maltysen, ≤4

C.ZG

A força bruta demorou tanto que eu fiz isso mais rápido manualmente.

Análise

C(converter string para base 256 int) é a maneira mais fácil de gerar um número grande em Pyth, portanto é provavelmente o primeiro caractere. Se convertermos da base 256, obtemos:

xÚKLJNIMKÏÈÌÊÎÉÍË/(,*.)-+¯¨¬ 

Hmm ... não muito iluminador.

Agora Gé a string do alfabeto "abc...z", que parece ser uma fonte para uma string longa ser inserida C. Analisando os documentos, localizo:

.Z    Compresses or decompresses a string.

Se estamos lidando com compressão aqui, não seria surpreendente obter todos os tipos de caracteres ASCII estendidos. Tentando, C.ZGentão, deu a resposta.

Fourier, Decaimento beta, ≤ 32

2~x1~y20(xoy~z*x~yz~xq^~q)

Ou, alternativamente, no CJam:

X0I{_2$+}*]2\f#

Análise

No início, podemos ver muitos poderes de 2:

2
1
2
2
4
8
32
256
8192
2097152
...

Se tomarmos a base de log 2 desses números, obteremos:

1 0 1 1 2 3 5 8 13 21 ...

que é a série Fibonacci, começando em 1, 0.

Caracóis, feersum, ≤2 bytes

z

Na verdade, são 2 bytes; o personagemz seguido por uma nova linha \n.

Não faço ideia de como ele funciona ou o que está fazendo, mas depois de testar todas as entradas possíveis, além de ~+ e ~,, este foi o único programa de 2 bytes que produziu 8como saída.

E levou séculos para obter esse resultado. Não é à toa que se chama "Caracóis" :-D

^{Nota para si mesmo: na próxima vez em que testar um software desconhecido, faça-o dentro de uma VM.}

Ferrugem, Liam Noronha, ≤128 bytes

fn main(){print!("AACAAEGAAACIIMOAAACAAEGQQQSYYDFAAACAAEGAAACIIMOHHHJHHLNXXXAGGKMAAACAAEGAAACIIMOAAACAAEGQQQSYYDFOOO");}

Simplesmente imprimir a string literalmente é de 120 bytes ...

Macarrão 0.0.2, maçaneta da porta, ≤64

set x "................................."print x print x print x

Python 2, pergunta clara com exemplos, <= 64

Uma solução possível:

print ''.join([" `{.~{{~||"[int(c)] for c in str(3**4278)])

( 9**2139, 27**1426e 729**713também fornecer o mesmo resultado)

CoffeeScript, usuário2428118, ≤64

alert 0+(btoa k.substr -2 for k of document.body.style).join ''

(funciona apenas no Chrome 46.0.2490.71, conforme descrito pela Cop.)

A saída é obviamente uma concatenação de seqüências curtas codificadas em base64 devido a todo o "=". Após decodificá-los, encontramos uma lista de cadeias de caracteres de 2 caracteres, como

['nt', 'ms', 'lf', 'ne', 'll', 'on', 'ay', 'on', …

o que não parece fazer sentido. Mas acho alguns itens estranhos, como nXe tY. Depois de filtrá-los, obtemos

>>> # Python
>>>
>>> [i for i in tt if not re.match('[a-z]{2}$', i)]
['nX', 'nY', 'tX', 'tY', 'wX', 'wY', 'r', 'nX', 'nY', 'tX', 'tY', 'nX', 'nY', 'nX', 'nY', 'nZ', 'x', 'y']

Esses X e Y parecem indicar o código fonte original usado como propriedades de posição offsetX/Y. Um nZitem particularmente interessante é o item. Para verificar minha suposição, procurei por todas as propriedades que terminam com "Z":

// CoffeeScript
checked = []
f = (o) ->
    if !(o in checked) 
        for k of o
            if /Z$/.test(k)
                console.log(o, k)
            if o[k] instanceof Object
                f o[k]
f window

que mostra toneladas de CSSStyleDeclaration, "webkitTransformOriginZ". A partir disso, temos uma forte indicação de que a lista é construída pelos últimos 2 caracteres de todas as chaves de um styleobjeto, que o teste acima mostra de fato está correto.

Lua <= 4, Egor Skriptunoff

Muitos usuários estavam ficando agitados com essa resposta no chat, então devo aliviá-los de sua miséria. Não conheço Lua e não pude testá-lo, mas ficaria muito surpreso se isso não funcionar.

4^~9

Isso seria bastante óbvio, mas provavelmente ninguém entendeu porque os operadores bit a bit foram adicionados apenas na versão 5.3; O ideone.com possui apenas a versão 5.2.

Python 2, histocrata, ≤16

[[[51002**3/6]]] 

A maior dica é a promessa de que não funcionará no Python 3. O que mudou no Python 3 ? O maior suspeito é que o operador de divisão retorne um floatno Python 3.

Então, eu suponho que a solução seja da forma ⌊α ^β / n⌋ = c = 22111101102001, pois a exponenciação é a única maneira curta de criar grandes números.

Se {α, β, n} de fato formar uma solução, então (cn) ^{1 / β} ≈ α deve estar muito próximo de um número inteiro. Portanto, eu uso o seguinte para tentar forçar o {α, β} para cada n:

(* Mathematica *)
n=2; Sort[Table[{N[Abs[k - Round@k] /. k -> (22111101102001*n)^(1/b), 12], b}, {b, 2, 50}]]

(* Output: {{0.00262542213622, 7}, ...}

   The first number is the "quality" of the solution, lower is better.
   the second number is β.
   Thus α ≈ (nc)^(1/β) = 89
   But (89^7)/2 = 22115667447764, which is still far away from the answer.

*)

O resultado real sai rapidamente quando n = 6.

MATLAB, StewieGriffin, ≤ 16

[36;87]*' |'*5

Impressões:

ans =
        5760       22320
       13920       53940

Luis Matlab Mendo, ≤16

Eu encontrei, yay!

fix(peaks(9).^2)

Eu não sabia que o Octave também pode fazer isso.

Mathematica, LegionMammal978, ≤64

Print@Nest[Compress,ExampleData[{"Text","ToBeOrNotToBe"}],13]

Python, spacemanjosh, ≤ 64

n=0;d=1;L=[]
exec("L+=[10/(100-n)**.5];n+=d;d+=2;"*10)
print(L)

Calculadora simbólica inversa gloriosa. Não é bem jogado, mas ei, ele se encaixa.

Edit: Eu jogava golfe.

print([10/(100-n*n)**.5for n in range(10)])

JavaScript ES6, Cᴏɴᴏʀ O'Bʀɪᴇɴ, ≤128 bytes

var x=122,s='0037122342526683102122';for(var i=23;i<=505;i+=2)s+=(x+=i);s;

Duvido que esteja exatamente correto, pois não precisava de nada perto de 128 bytes, mas encontrar uma sequência repetida foi um desafio divertido.

Ter, ppperry, <= 64

0::=11
1::=22
2::=33
3::=44
4::=55
a::=bbb
b::=000
::=
aaaaaaa

Decompõe 2016 em seus principais fatores, essencialmente. 62 caracteres, então acho que isso é semelhante ao que você estava procurando.

Python, DLosc, ≤32

(Esta solução usa Python 2)

a=97
while a<4e31:a^=a*2;print a

> <>, Sp3000, <= 8

'l(?; o>

O ponteiro da instrução é contornado e as seguintes etapas ocorrem:

• 'l(?; o>' empurra os valores ASCII de l(?; o> para a pilha
• l empurra o tamanho da pilha na pilha
• ( compare os dois principais elementos da pilha: size of stack eord('>')
• ?; interrompe o programa se o tamanho da pilha for maior
• o gera o elemento superior da pilha como caractere (isso sempre será o )
• > define a direção do IP, aqui está no-op
• voltamos ao primeiro passo

Saída é oooooooooooo .

Podemos obter muitas saídas diferentes mudando [space]para algo que empurra ou aparece na pilha e usando outro caractere válido em vez de >, que também pode empurrar ou estourar.

JavaScript, ev3commander, ≤ 32

console.log(0.1411200080598672)

OK, isso foi fácil.

CJam, Reto Koradi, ≤ 4

HJK#

Empurra 17 e 19 ²⁰ = 37589973457545958193355601 .

Experimente online.

Existem tantas coisas que você pode fazer em quatro bytes. Um número inteiro desse tamanho precisava envolver poderes ou fatoriais de alguma forma, e um fatorial teria zeros à direita.

Pitão <= 4, Dennis

ljyG

Esse é o comprimento da junção nas novas linhas de todos os subconjuntos do alfabeto.

Execução de teste:

$ pyth -cd 'ljyG'
==================== 4 chars =====================
ljyG
==================================================
imp_print(Plen(join(subsets(G))))
==================================================
939524095

Eu descobri que o número era o 2^27 * 7 - 1que é uma forte dica sobre a qual ele se baseia yG, que tem 2^26elementos longos. Eu então imaginei que tinha que ser convertido em uma string e seu comprimento impresso. No entanto, a única maneira de fazer isso em que pude pensar por um tempo foi ``, repr. Então pensei j, o que se encaixa perfeitamente.

C, tucuxi, ≤64

main(i){for(i=0;i<11000;++i)if(!(i&2*i))printf("1%d",!(i&1));}

Os resultados são todos 0 e 1, mas C não pode imprimir binário diretamente, portanto, é muito provável que sejam resultados booleanos.

Há mais de 1s, então eu gravei as posições de 0s ( 3, 9, 13, 19, …), que são OEIS A075318 . Porém, isso não é útil, não existe uma fórmula simples para determinar onde está um número nessa sequência.

Mas observamos que existem todos os números ímpares, portanto, talvez (x-1)/2 = {1, 4, 6, 9, 12, …}tenha informações mais úteis. E este é A003622 .

A003622 pode ser definido como "posições de 1 em A003849 ", que é exatamente o que precisamos decifrar aqui. E A003849 é definido como " A003714 mod 2", onde A003714 são simplesmente todos os números inteiros x & (2*x) == 0. Assim, temos a solução.

OEIS rox.

Dyalog APL, Dennis, ≤4

*⍨⍟8

Calcula ln (8) ^ ln (8). O StackExchange para de converter minhas respostas? Vou digitar várias coisas aqui para que não se transformem em comentários.

Preso, @quartata, ≤8

O seguinte programa Pyth :

^33 9

produz a saída desejada

46411484401953

Método de quebra: Pesquisou no Google o número.

Pitão, xnor, ≤ 4

C`CG

CG(converter a string "abc...z"do alfabeto da base 256) é a maneira típica de Pyth de gerar um número realmente grande. Depois disso, basta restringir e converter da base novamente.

Python 3, Mego, ≤128

(Using Python 3.5.0, not tested on previous versions. 105 98 bytes.)

import sys
a=sys.stdout
sys.stdout=None
from this import*
a.write(s.translate(s.maketrans(d))[4:])

Ruby, Doorknob, ≤64

'@@'=~/(.)(.)/
p$~
test 0 rescue p"#$!@@".gsub //,$!.inspect+$/

Matlab/Octave, Wauzl, ≤16

"234"'*"567"

Using the same idea as Tom Carpenter's answer

(If it did not work, try this:)

[50;51;52]*'567'