Perigo de PPCG: Ladrões

18

Você conhece bem o site? Vamos descobrir.

Este é um desafio de . A linha do policial .

Como ladrão, você precisa:

  1. Encontre um desafio não excluído e não fechado que corresponda ao envio de um policial. O desafio não pode ter as seguintes marcas: , , , , , , , . O desafio deve ter restrições na saída válida.
  2. Poste o desafio aqui e conecte-se ao policial que você está pirando
  3. Adicione um comentário "Rachado" à postagem da polícia, com um link para esta resposta

Você receberá 1 ponto, mais 1 ponto por cada período de 24 horas em que o envio permaneceu inalterado (máximo 7). O desempatador é o número total de submissões rachadas.

Notas:

  • Se um desafio exigir uma saída de Xe você produzir XYou YXonde Yhouver algo além de espaço em branco, o envio não será válido para esse desafio.
  • Não é permitido um desafio mais recente que 17/11/2016.
  • Reservo-me o direito de proibir certos desafios se eles forem amplamente aplicáveis ​​(podem ser aplicados à maioria de todos os envios).
  • Adicione uma frase ou duas como explicação (também ajuda a converter seu envio em comentário)
  • Obrigado a Daniel pela ideia inicial!
Nathan Merrill
fonte

Respostas:

5

Calcule a probabilidade de obter metade do número de cabeças que os lançamentos de moedas.

Entrada da polícia (publicada por Conor O'Brien): /codegolf//a/100521/8927

Pergunta original: Calcule a probabilidade de obter metade do número de cabeças que os lançamentos de moedas.


A solução postada teve algumas técnicas de ofuscação aplicadas, seguidas por várias camadas da mesma técnica de ofuscação. Após os primeiros truques, tornou-se uma tarefa simples (se entediante!) Extrair a função real:

nCr(a,b) = a! / ((a-b)! * b!)
result = nCr(x, x/2) / 2^x

Demorei um pouco para perceber o que eu estava vendo (durante algum tempo suspeitei de algo a ver com entropia), mas uma vez que ela girou, consegui encontrar a pergunta facilmente procurando por "probabilidade de sorteio".


Como Conor O'Brien desafiou uma explicação detalhada de seu código, aqui está um resumo dos bits mais interessantes:

Começa ofuscando algumas chamadas de função internas. Isso é obtido codificando a base-32 os nomes das funções e atribuindo-os a novos nomes de namespace global de um único caractere. Somente 'atob' é realmente usado; os outros 2 são apenas insensatos (eval usa a mesma abreviação que atob, apenas para ser substituído, e btoa simplesmente não é usado).

_=this;
[
    490837, // eval -> U="undefined"       -> u(x) = eval(x) (but overwritten below), y = eval
    358155, // atob -> U="function (M,..." -> u(x) = atob(x)
    390922  // btoa -> U="function (M,..." -> n(x) = btoa(x), U[10] = 'M'
].map(
    y=function(M,i){
        return _[(U=y+"")[i]] = _[M.toString(2<<2<<2)]
    }
);

Em seguida, existem algumas misturas triviais de strings para ocultar o código. Estes são facilmente revertidos:

u(["","GQ9ZygiYTwyPzE6YSpk","C0tYSki","SkoYSkvZChhLWIpL2QoYikg"].join("K"))
// becomes
'(d=g("a<2?1:a*d(--a)"))(a)/d(a-b)/d(b) '

u("KScpKWIsYShFLCliLGEoQyhEJyhnLGM9RSxiPUQsYT1D").split("").reverse().join("")
// becomes
"C=a,D=b,E=c,g('D(C(a,b),E(a,b))')"

A maior parte da ofuscação é o uso da gfunção, que simplesmente define novas funções. Isso é aplicado recursivamente, com funções retornando novas funções ou exigindo funções como parâmetros, mas eventualmente simplifica. A função mais interessante para sair disso é:

function e(a,b){ // a! / ((a-b)! * b!) = nCr
    d=function(a){return a<2?1:a*d(--a)} // Factorial
    return d(a)/d(a-b)/d(b)
}

Há também um truque final com esta linha:

U[10]+[![]+[]][+[]][++[+[]][+[]]]+[!+[]+[]][+[]][+[]]+17..toString(2<<2<<2)
// U = "function (M,i"..., so U[10] = 'M'. The rest just evaluates to "ath", so this just reads "Math"

Embora o próximo bit seja ".pow (T, a)", sempre foi bem provável que tivesse que ser "Math"!

Os passos que dei ao longo da rota de expansão de funções foram:

// Minimal substitutions:
function g(s){return Function("a","b","c","return "+s)};
function e(a,b,c){return (d=g("a<2?1:a*d(--a)"))(a)/d(a-b)/d(b)}
function h(a,b,c){return A=a,B=b,g('A(a,B(a))')}
function j(a,b,c){return a/b}
function L(a,b,c){return Z=a,Y=b,g('Z(a,Y)')}
k=L(j,T=2);
function F(a,b,c){return C=a,D=b,E=c,g('D(C(a,b),E(a,b))')}
RESULT=F(
    h(e,k),
    j,
    function(a,b,c){return _['Math'].pow(T,a)}
);


// First pass
function e(a,b){
    d=function(a){return a<2?1:a*d(--a)}
    return d(a)/d(a-b)/d(b)
}
function h(a,b){
    A=a
    B=b
    return function(a){
        return A(a,B(a))
    }
}
function j(a,b){ // ratio function
    return a/b
}
function L(a,b){ // binding function (binds param b)
    Z=a
    Y=b
    return function(a){
        return Z(a,Y)
    }
}
T=2; // Number of states the coin can take
k=L(j,T); // function to calculate number of heads required for fairness
function F(a,b,c){
    C=a
    D=b
    E=c
    return function(a,b,c){return D(C(a,b),E(a,b))}
}
RESULT=F(
    h(e,k),
    j,
    function(a){return Math.pow(T,a)}
);


// Second pass
function e(a,b){...}
function k(a){
    return a/2
}
function F(a,b,c){
    C=a
    D=b
    E=c
    return function(a,b,c){return D(C(a,b),E(a,b))}
}
RESULT=F(
    function(a){
        return e(a,k(a))
    },
    function(a,b){
        return a/b
    },
    function(a){return Math.pow(2,a)}
);


// Third pass
function e(a,b) {...}
C=function(a){ // nCr(x,x/2) function
    return e(a,a/2)
}
D=function(a,b){ // ratio function
    return a/b
}
E=function(a){return Math.pow(2,a)} // 2^x function
RESULT=function(a,b,c){
    return D(C(a,b),E(a,b))
}

A estrutura do aninhamento de funções é baseada em utilidade; a função mais externa "D" / "j" calcula uma razão e, em seguida, as funções internas "C" / "h" e "E" (em linha) calculam as contagens de moedas necessárias. A função "F", removida na terceira passagem, é responsável por conectá-las a um todo utilizável. Da mesma forma, a função "k" é responsável por escolher o número de cabeças que precisam ser observadas; uma tarefa que delega à função de proporção "D" / "j" através da função de ligação de parâmetro "L"; usado aqui para corrigir parâmetrob paraT (aqui sempre 2, sendo o número de estados da moeda pode tomar).

No final, obtemos:

function e(a,b){ // a! / ((a-b)! * b!)
    d=function(a){return a<2?1:a*d(--a)} // Factorial
    return d(a)/d(a-b)/d(b)
}
RESULT=function(a){
    return e(a, a/2) / Math.pow(2,a)
}
Dave
fonte
Bom trabalho! Isso está um pouco incorreto - eval está definido como f. Mas o resto está correto! Além disso, um pouco de elaboração de como RESULTé derivado pode ser digno;)
Conor O'Brien
@ ConorO'Brien com certeza; Adicionei minhas anotações e uma explicação da utilidade de cada função antes de recolher todas elas.
Dave
@ ConorO'Brien obrigado pela recompensa!
Dave
Sempre um prazer :)
Conor O'Brien
3

MATL, Luis Mendo , Contar número de decimais robustos entre 2 números

&:"@FYAYm7>vs

Eu descobri o que ele faz tocando com as entradas, mas não consegui descobrir qual desafio você teria para calcular o número de números inteiros em um intervalo cuja soma era maior que 7 vezes o número de dígitos. Depois de ler os documentos do MATL, reuni uma explicação aproximada do que isso faz:

&    % Change default input format
:    % Implictly input two integers, create inclusive range
"    % For each item in this range:
  @    % Push the item
  F    % Push false
  YA   % Convert to base N digits; N is false, so this produces base-10 digits
  Ym   % Calculate arithmetic mean
  7>   % Push 1 if this is greater than 7, 0 otherwise
  v    % Concatenate result into array with previous result
  s    % Sum
     % Implicitly end loop and output

Em seguida, mudei da pesquisa "soma de dígitos maior que 7 vezes o comprimento" para "dígito médio maior que 7", o que gerou o desafio que eu estava procurando.

ETHproductions
fonte
2

Perl, Gabriel Benamy , Verificador conveniente de palíndromo

O código era obviamente algum tipo de palíndromo. Depois de escolher a y- - -estrutura e perceber o que estava sendo transliterado, soube qual era o desafio.

DLosc
fonte
Você venceu o meu por alguns segundos ... mas demorou tanto tempo para baixar o perl.
Laikoni
@Laikoni Honestamente, depois de algumas tentativas no Ideone, desisti de executar o código e tentei lê-lo. ;)
DLosc 18/11/16
1

MATL, Luis Mendo , Calcular o peso do hamming com baixo peso do hamming

dP7EGn:q^1J2/h)ts_hX=Gs[BE]Wd=~>~GBz*

Eu testei a colocação de números e achei a coisa do peso hamming no OEIS .

Então eu procurei no PPCG, tentei colocar as cordas e funcionou.

boboquack
fonte
Como eu comentei no desafio da polícia, isso não quebra minha submissão. Infelizmente, eu acho que esta resposta tem de ser apagado
Luis Mendo
1

Rubi, histocrata , implementa uma máquina da verdade

O código define um sistema de funções iteradas f(n) = n*(3*n-1)/2que é executado até que o nmod 7 seja 0. A entrada de 0portanto termina imediatamente (após a impressão 0uma vez). Entrada de 1doações 1, levando a um loop infinito de impressão 1. Outra entrada termina após 1-3 etapas se a inicial nfor congruente a 0, 2, 3, 5 ou 6 mod 7, ou crescerá para sempre se for congruente a 1 ou 4 mod 7. Mas isso é irrelevante.

DLosc
fonte
1

Hexagony, 548 bytes, Martin Ender

Este é o " Imprima todos os caracteres que seu programa não possui desafio "!

Impressões:

Elizabeth obnoxiously quoted (just too rowdy for my peace): "THE QUICK BROWN FOX JUMPS OVER THE LAZY DOG," giving me a look

O que é muito semelhante à saída deste . A pista aqui era que o último .não foi impresso. Além disso, o código em si não tinha letras e todos sabemos que as frases na saída contêm todas as letras do alfabeto.

Stewie Griffin
fonte
0

Python 3, /codegolf//a/100381/31343

Use a fórmula do xkcd para aproximar a população mundial

Eu apenas procurei por desafios que envolviam anos bissextos (por causa da divisibilidade decodificada por quatro verificadores) e que não receberam nenhuma contribuição.

Maltysen
fonte
Sim! Eu sabia que ia ser óbvio por causa da %4ea strftime, mas bom trabalho para detectar as partes importantes do código (mais do que era o jargão)
FlipTack
Ah, droga, eu também estava chegando perto. Eu tinha percebido que tinha algo a ver com datas, estava ficando em 2005 e 2016/2017. Bom trabalho.
Yodle
Estou surpreso que nenhum de vocês simplesmente executou o código, que gera a saída 7.3 328, e pesquisou isso. O desafio surge imediatamente.
FlipTack
0

Mathematica, JHM , Construção natural

O operador unário ±calcula uma representação baseada em teoria dos conjuntos dos números naturais.

Martin Ender
fonte
0

Ruby, wat , 400ª questão Celebração / Desafio

Essa foi a primeira coisa que encontrei ao pesquisar "400". Dito isto, o desafio parece estar errado e deve ser um popcon e provavelmente também deve ser fechado por não ter requisitos objetivos.

Martin Ender
fonte