Esta é a pergunta complementar das palavras cruzadas de código . As respostas dos ladrões estão aqui.

Consulte Onde devemos colocar ladrões? para meta-informação.

Solução do quebra-cabeça C de es1024

Eu tive que enganar um pouco o 7-Down invocando um comportamento indefinido. es1024 indicou que esse uso do UB era a solução pretendida. Porém, ele funcionará nos computadores da maioria das pessoas. Eu vim com várias expressões alcançar o resultado desejado, como -1 << 30, 3 << 30, 6 << 29e, ~(~0U/4)mas todos eles tornou impossível para mim para obter 5-Em todo. Então, usei a propriedade específica da arquitetura Intel, que apenas os 5 bits menos significativos são usados ​​para determinar o tamanho de um turno à esquerda. Observe que ele precisa ser ~_e não ~1para que a quantidade a ser alterada não seja uma constante em tempo de compilação. Testei as expressões com o seguinte código:

#define T(X) _ = c; _ = X; printf("%d\n", _);
z[4] = {9};
int main(c)
{
    int _;

    T("01"[0])
    T(-8)
    T(-2)
    T(11<-328111)
    T(+2+71)
    T(9+0)
    T(0**z)
    T(5;)
    T(0<-000)
    T(2+~3)
    T(!91)
    T(!_)
    T(2**z)
    T('_T;')

    T("11"?5*9:2)
    T(15<<9)
    T(0+22)
    T(-211*0-97;)
    T(-17*0)
    T(3+0<<~_)
    T(8+000)
    T(+0)
    T(42)
    T(+!z)
    T(~_)
}

professorfish, CJam, 41 darks

(Na verdade, essa solução requer vários espaços, portanto não é o que o professorfish estava procurando.)

#K###I#'32
#HDJ*s\ ##
2##2#`#`#-
4Zm*`##L#3
m##6##]`' 
f####e#`#'
`#0#'d1+eu
## #!####9
## '{;'"'m
C5(#}####q

Isso foi muito divertido. Observe que #abaixo do 6código é realmente e não uma célula escura. Vamos passar por isso:

Através

Dica 2: [[4 3]]. Essa foi uma das mais complicadas, porque eu realmente fiquei presa em tentar 4Z]]`ou algo parecido. Acontece que você pode usar o produto cartesiano m*em coisas que não são uma matriz e isso fará uma matriz para você. Então aqui está:

4Zm*`

Dica 4: 24717. Até o momento em que cheguei a este, o H, J, se à direita espaço já estavam no local. A Hdoação que eu provavelmente poderia reutilizar 17e fazer \no final. O Jempurra a 19e 247 == 13 * 19, então:

HDJ*s\ 

Dica 7: 32. Há um monte de maneiras de fazer isso: Y5#, 3 2, ZY, YZ\, 4(2, 2)2, '32. Eu fui com o último, porque começar com um personagem parecia promissor para 7-down, e isso acabou sendo certo.

Dica 8: E. Eu já tinha o 'dquando cheguei lá, então foi entre a escolha 'd1+eu, 'deu1+ou uma variante em que eu usei )e um espaço em vez de 1+(para as pessoas não-CJam, esta tomando o dcaráter e incremento e superior da embalagem-lo, em qualquer ordem) . No entanto, a ucoluna final parecia útil para A-down. Então eu escolhi o primeiro deles. No final, 'd) euteria funcionado também.

Dica 9: "". Bem, isso tinha que ser "string vazia, obter representação de string, empurrar um espaço". Mas também precisava do `para representação de strings em 7-down, e um espaço em A-down também parecia útil, então eu escolhi

]`' 

Observe que ]também pode ter sido um dos LMOQR.

Dica B: "m. Eu realmente tive que encaixar esse aqui com o resto, mas havia poucos personagens que importavam. Eu já tinha o {e o m. Então, em vez de usar um bloco, eu me transformei {em um personagem, descartei-o e pressionei os dois caracteres necessários:

 '{;'"'m

Dica D: 124. Resolvi esse problema com o C-down, que foi mais fácil com um decréscimo no final. Então eu pressiono um 12, um 5 e diminuo o último:

C5(

Baixa

Dica 1: [2 2 2 3]. Isso parecia muito desconfiado como uma fatoração primordial para não ser uma. :)

24mf`

Dica 3: 3010936384. Factoring isso mostrou que é realmente 38 ⁶ . A única questão era como obter a 38conformidade com o 2-across. No final, eu precisava de um *em terceiro lugar, então dobrando 19foi:

J2*6#

Dica 5: 2017. Dois caracteres para um número tão grande? Basta usar variáveis ​​internas de dois dígitos:

KH

Dica 6: "18". Eu acho que há apenas uma maneira de fazer isso em três caracteres. Use o 18 interno, converta-o em uma sequência e, em seguida, em sua representação de sequência.

Is`

Dica 7: ' "\"\"". Provavelmente a parte mais difícil do quebra-cabeça. Em particular, eu precisava inserir "\"\""apenas três caracteres. O truque era obter a representação da string vazia duas vezes. Isso levou a:

' `L``+

THe +não é necessário, mas era necessário por 8 de largura.

Dica 8: !{}. O bloco precisava ser inserido no código, deixando apenas dois caracteres !, o que significava usar outro literal:

'!{}

Dica A: -3u3. Com o uem lugar de 8-across, comecei a colocar -3e 3nos cantos onde nenhuma outra dica se preocupava com eles. Mas então eu precisava de um mna parte inferior. Eu acho que existem várias maneiras de obter um 3com _m_, mas a mais simples estava tomando a raiz quadrada de 9:

-3 'u9mq

Dica C: -1. Eu já tinha o decréscimo lá, então apenas coloquei um local 0onde ninguém mais se importava:

0  (

Dica E: Stack: "". Bem, esse foi o mais simples. Basta chamar o depurador:

ed

COTO, Javascript ES4, 37 Darks

 __________
|{}=51###6#|
|a##.#I-9<4|
|:##-##"#<#|
|5+Math.PI#|
|}##+##.#+#|
|["9"+0][0]|
|'##p##"###|
|a+-a#a=-10|
|'##c##=###|
|]##"\x48I"|
 ¯¯¯¯¯¯¯¯¯¯

• 6 transversalmente é 5+Math.PIou Math.PI+5; mas o último deixaria 'M' e 'h' cruzando para outras expressões, parecia improvável.
• Um outro lado tinha que ser uma corda; com 4 no meio, parecia uma fuga, a única maneira de ter espaço para isso é "\x48I".
• 2 abaixo agora termina em uma string, então provavelmente "pac" é anexado a um número; nós voltaremos a isso.
• 8 ac agora está xxxaavaliando como zero, então -a + a? a + -a? 3 + -a? a+-aparecia melhor, pois me deu o que parecia um char em uma string em 1dn.
• 1 abaixo contém: 5, que só pode ser gramática legal em {x:5}xxa'x. Como o valor retornado é 5, ele deve ser retirado do objeto, o {x:5}['a']que significa que o caractere final ausente também é:{a:5}['a']
• 1 agora tem {no início. Imaginei que fosse uma tarefa de arenque vermelho, tentei t={}=51e funcionou. Não sabia isso!
• 2 abaixo agora tem 5xxax"pac"=> "2pac". Isso tem que ser 5-a+"pac", de alguma forma, para que o segundo caractere tenha que ser '.' para o literal de ponto flutuante.
• 7 ac está agora [xx"xxxx], retornando "90". Portanto, isso deve ser uma matriz literal com o valor retirado; só há espaço para um valor, então temos [xx"xx][0]. Não há espaço para duas cordas lá, mas é adequado "9"+0ou não 9+"0".
• 3 dn; 3072 é 3 * 1024; o poder de 2 é suspeito, e eu já tinha 'eu' lá bloqueando outras maneiras de obter números grandes (como 1eX). Então, adivinhou bitshift; 6<<Iacabou por ser a resposta, deixando +0 para adicionar até o final.
• 4 ac agora continha um operador de comparação; e o segundo caractere precisava ser um operador unário válido (para encaixar depois de 't =' e 'I'). Imaginei '-', e há várias soluções possíveis esquerda ( I-I<4, I-6<4, etc)
• 5 dn agora contido -x..]xxx4. O ".." me impressionou - há apenas algumas maneiras que podem ser sintaxe legal e é por isso que perguntei se o ES4 era o que se pretendia - isso era algum recurso estranho dessa especificação abandonada? Mas então vi que isso era um arenque vermelho; -""é NaN, então -"..]"xx4deve estar lá - uma comparação com NaN, retornando false; '==' serve, mas é preciso olhar para a última resposta para confirmação ...
• 9ac tinha várias soluções possíveis, mas a restrição de caracteres que seria permitida para 5dn me fez pensar que essa era mais uma tarefa de arenque vermelho; algo =-10. Para ser sincero, também observei a versão anterior do 9dn e percebi que isso deveria ser algo =top(para recuperar uma janela). A variável atribuída a poderia ser a ou I, não importa.

Enigma complicado!

quebra-cabeça de Python do grc

Para todas as longas expressões de ponto flutuante, criei um programa em C ++ para gerar expressões matemáticas do Python à força e as avalia. Ele assume que todos os números são de ponto flutuante e suporta apenas os operadores +, -, *, /, //, ** e ~. Eu o usei para obter todas as pistas com mais de 5 caracteres, exceto a**9*27%bo hash. Com 6 espaços em branco ou menos, ele termina em alguns segundos, enquanto espera um pouco para 7.

Solução do quebra-cabeça do MATLAB da COTO

Eu acho que joguei este bem, pois há 14 espaços.

Este script de teste:

g=4;
o=magic(3);
D=@disp;

D(max([  2]));
D( i^3);
D(o^0);
D(6 -7+eye  );
D((i));
D(.1  ^5* g );
D(~2);
D(diag(~o)  );

D(asin (1)*i);
D((93+7) +~g);
D(  10e15);
D(2*ones (2));
D(02 ^  9 );
D(-i );
D(~o);

produz a seguinte saída:

     2

        0 - 1.0000i

     1     0     0
     0     1     0
     0     0     1

     0

        0 + 1.0000i

   4.0000e-05

     0

     0
     0
     0

        0 + 1.5708i

   100

   1.0000e+16

     2     2
     2     2

   512

        0 - 1.0000i

     0     0     0
     0     0     0
     0     0     0