Este é o fio dos ladrões. A discussão dos policiais está aqui .

Seu desafio é pegar um envio sem rachaduras do tópico da polícia e encontrar, para quais entradas ou entradas, o programa será impresso Hello, World!e uma nova linha. Letras maiúsculas, espaçamento e pontuação devem ser exatas.

Por favor, comente a submissão do policial quando você tiver decifrado o código.

Bash por Sisyphus

Código original:

[[ ! "${1////x}" =~ [[:alnum:]] ]]&&[[ $# = 1 ]]&&bash -c "$1"

Entrada:

__=; (( __++, __-- ));
(( ___        = __,        ___++));
(( ____       = ___,       ____++));
(( _____      = ____,      _____++));
(( ______     = _____,     ______++));
(( _______    = ______,    _______++));
(( ________   = _______,   ________++));
(( _________  = ________,  _________++));

${!__##-} <<<\$\'\\$___$______$_______\\$___$______$_____\\$___$_______$__\\$___$_______$_________\'\ \$\'\\$___$___$__\\$___$______$_______\\$___$_______$______\\$___$_______$______\\$___$_______$_________,\ \\$___$____$_________\\$___$_______$_________\\$___$________$____\\$___$_______$______\\$___$______$______\\$__$______$___\'

Explicação:

Isso codifica "eco Olá, mundo!" como seqüências de escape octais (\ xxx).

Exceto que você também não pode usar números, então a primeira parte cria variáveis ​​para os números de 0 a 7. Você pode usá-los para criar uma sequência com sequências octais que serão avaliadas para fornecer o comando real.

Mas evaltambém é alfanumérico. Então, ao invés disso, isso canaliza essa string como entrada para outra instância de bash. $0contém o nome do comando usado para chamar o Bash, que normalmente é apenas bash(ou -bashpara um shell de login) se você o estiver executando normalmente (por meio do TIO ou colando-o em um terminal). (Isso significa que, se você tentar executar isso colando-o em um script, as coisas darão terrivelmente errado ao tentar se bifurcar várias vezes.)

Mas de qualquer maneira, você não pode dizer $0diretamente. Em vez disso, $__contém o nome de $0("0") e você pode usar a expansão indireta para acessá-lo ( ${!__}refere-se ao conteúdo de $0).

E isso, finalmente, fornece todas as peças necessárias.

05AB1E , Adnan

•GG∍Mñ¡÷dÖéZ•2ô¹βƵ6B

-107

Experimente online!

Quão?

•GG∍Mñ¡÷dÖéZ•        - big number
             2ô      - split into twos (base-10-digit-wise)
               ¹β    - to base of input
                   B - convert to base (using 012...ABC...abc...):
                 Ƶ6  -   107 (ToBase10(FromBase255(6))+101 = 6+101 = 107)

totalmente humano , Python 2

Uma solução é

'Uryyb, Jbeyq!' 

Pyth : Sr. Xcoder

"abcdefghijklmnopqrstuvwxyz"

Gé o built-in para o alfabeto em minúsculas. O código verifica a igualdade em relação a isso.

Geléia: EriktheOutgolfer

〡㋄ⶐ✐сᑀ⟙ⶐⶐ〡ސЀᶑ〡㋄ⶐ✐сᑀ⟙ⶐⶐ〡ސЀᶑ〡㋄ⶐ✐сᑀ⟙ⶐⶐ〡ސЀᶑ〡㋄ⶐ✐сᑀ⟙ⶐⶐ〡ސЀᶑ〡㋄ⶐ✐сᑀ⟙ⶐⶐ〡ސЀᶑ〡㋄ⶐ✐сᑀ⟙ⶐⶐ〡ސЀᶑ〡㋄ⶐ✐сᑀ⟙ⶐⶐ〡ސЀᶑ〡㋄ⶐ✐сᑀ⟙ⶐⶐ〡ސЀᶑ〡㋄ⶐ✐сᑀ⟙ⶐⶐ〡ސЀᶑ〡㋄ⶐ✐сᑀ⟙ⶐⶐ〡ސЀᶑ〡㋄ⶐ✐сᑀ⟙ⶐⶐ〡ސЀᶑ〡㋄ⶐ✐сᑀ⟙ⶐⶐ〡ސЀᶑ〡㋄ⶐ✐сᑀ⟙ⶐⶐ〡ސЀᶑ

Gelatina , 11 bytes

sLƽ$Xṙ5O½Ọ

Experimente online!

Explicação

O código original pode ser explicado da seguinte forma:

sLƽ$Xṙ5O½Ọ  Main link; argument is z
s            Split z into n slices, where n is:
    $
  ƽ         The integer square root of
 L                                      the length of z
     X       Random of a list. Returns a random row of the input put into a square
      ṙ5     Rotate the list left 5 times
        O    Get codepoints
         ½   Floating-point square root
          Ọ  From codepoints

Então, basta pegar "Olá, mundo!" e obtenha pontos de código, ajuste-os ao quadrado, jogue de volta aos pontos de código, gire para a direita 5 vezes e, em seguida, aplique o quadrado e achatar o resultado.

Oitava por Stewie Griffin

Não tenho certeza se esta é a solução correta (no TIO ele imprime o \00personagem), mas no meu octave-clishell fica assim:

Também no desafio original, ele diz que imprima nada (ou o caractere nulo) ; portanto, se nada for o mesmo, \00então tudo ficará bem.

[72, 101, 108, 108, 111, 44, 32, 87, 111, 114, 108, 100, 33, 0]

Experimente online!

Python 3 por rexroni

print("Hello, World!") or __import__('sys').exit(0)

Evite erros ao sair mais cedo.

Experimente online!

JavaScript (ES6) Por Ephellon Dantzler

{length:1, charCodeAt:()=>(e='Hello, World!', String.fromCharCode=()=>'')}

Experimente online!

Isso foi bem fácil.

Eu notei que nenhuma entrada de string não seria possível produzir, Hello, World!porque a coisa toda dentro String.fromCharCoderetornará apenas múltiplos de 4 e !tem um código de caractere 33. Então, claramente, precisamos apenas hackear o programa inteiro. Hackear embutidos em JavaScript é trivial se não tentarmos impedi-los (e mesmo se o fizermos, geralmente existem muitas soluções alternativas ...).

JavaScript (ES6), Voile

Proxy simples que retorna o caractere desejado apenas a cada 3 vezes.

var i = 0;
var string = "Hello, World!";
var proxy = new Proxy([], {
  get: function(target, property) {
    if (!(++i%3)) {
      return string[property];
    }
    return [1];
  }
});

Experimente online!

Ruby, de Histocrat

A entrada mágica é: 1767707618171221 30191World!

Experimente online.

Explicação:

• o número 1767707618171221é primo e, escrito na base 36, é "hello". Quando em maiúscula, isso produz "Hello", que é impresso usando$><<
• a linha $><<", #$'"if/30191/procura o número 30191na entrada e grava em stdout uma string composta por vírgula, espaço e o que estiver na entrada após a 30191(usando o $POSTMATCH, que é referido aqui por sua variante curta $').

Lua 5.1 por tehtmi

Passe isso como o primeiro argumento:

C=("").char;_G[C(112,114,105,110,116)](C(72,101,108,108,111,44,32,87,111,114,108,100,33))

Supondo que o código original esteja em um arquivo tehtmi.lua, execute (no bash ou em um shell semelhante):

lua tehtmi.lua 'C=("").char;_G[C(112,114,105,110,116)](C(72,101,108,108,111,44,32,87,111,114,108,100,33))'

Também funciona no Lua 5.3, que é o que o TIO usa. Por que você não tenta online ? Eu não testei em uma implementação que usa o núcleo "5.1 da Lua da PUC-Rio" (porque realmente não consigo encontrar nenhuma informação), mas minha solução provavelmente também funciona lá.

Quão?

Ele executa o primeiro argumento como código, mas apenas se contiver menos de 5 caracteres em minúsculas.

O truque é correr print("Hello, World!"). Outra maneira de executar isso é usando _G["print"]("Hello, World!"), que usa apenas strings.

Mas não podemos usar a string diretamente devido à restrição de contagem em minúsculas; no entanto, você pode executar ("").charpara obter a função string.char, que pode converter de uma série de bytes em uma string. Eu o atribuai a uma variável maiúscula (para não atingirmos o limite), para que possamos usá-la para construir printas Hello, World!strings e as strings que podem ser usadas como acima.

JavaScript (ES6) por Voile

A entrada deve ser uma sequência que contenha isso:

e(
`\
_\
=\
>\
"\
H\
e\
l\
l\
o\
,\
 \
W\
o\
r\
l\
d\
!\
"\
+\
\`
\`
`)

Experimente usando o seguinte:

const e=eval,p=''.split,c=''.slice,v=[].every,f=s=>(t=c.call(s),typeof s=='string'&&t.length<81&&v.call(p.call(t,`\n`),l=>l.length<3)&&e(t)(t))

input='e(\n`\\\n_\\\n=\\\n>\\\n\"\\\nH\\\ne\\\nl\\\nl\\\no\\\n,\\\n \\\nW\\\no\\\nr\\\nl\\\nd\\\n!\\\n\"\\\n+\\\n\\`\n\\`\n`)'
console.log(f(input))

Se você não se importa com o requisito de nova linha à direita para a saída, substitua as últimas 6 linhas por:

!"
`)

Como eu fiz isso

As restrições na entrada são que é uma sequência, cada linha tem dois bytes de comprimento ou menos e que o comprimento total é de 80 bytes ou menos. Minha primeira tentativa depois de entender que foi corretamente:

_
=>
`\
H\
e\
l\
l\
o\
,\
 \
W\
o\
r\
l\
d\
!
`

^{Nota: os \s devem ignorar as novas linhas na string na entrada. Isso é incrivelmente crucial para a resposta, e não acredito que me deparei com ela por acidente. (Eu estava familiarizado com isso antes, mas esqueci)}

Mas isso não funcionou, pois =>o argumento deve estar na mesma linha. Felizmente, tive a ideia de agrupar algo semelhante em uma string e colocar uma avaliação em minha opinião para reduzi-la a uma linha, resultando em minha resposta final. Após a avaliação na entrada, o seguinte é gerado como uma sequência (que é avaliada para uma função e depois executada):

_=>"Hello, World!"+`
`

Foi realmente difícil de entender, mas eu consegui no final.

^{Além disso, o primeiro crack de todos os tempos!}

Cubically por MD XF

Eu imagino que isso seja sempre perigoso, mas acho que tenho uma rachadura, enquanto estou correto, pois há um erro no intérprete (que acabei de compilar).

Minha entrada

0 1 0 1 0 1 0 1 1 0 1 0 0

A saída é Hello, World!\n\n\n\n\n\n\n\n\n\n.....com novas linhas intermináveis.

Mas notei a última seção do código:

:1/1+1$(@6)7

define o bloco de notas para 0x0A(nova linha) de forma assustadora, lê a entrada na face 7 (a face de entrada) e imprime as 6 faces (face do bloco de notas) repetidamente até que a face 7 seja zero. Se você definir a face 7 como zero, deverá receber apenas uma nova linha. No entanto, recebi novas linhas infinitas e minha 13ª entrada foi zero, e posso verificar se a face 7 é sempre zero inserindo um "número de impressão da face 7" no loop:

:1/1+1$(@6%7)7

depois imprime \n0pares intermináveis .

Eu estou olhando as especificações na página do github cubicamente e esse comportamento se parece muito com um bug. Alterar o último caractere do programa original de a 7para um 0resulta no comportamento esperado. O intérprete TIO exibe o mesmo comportamento incorreto.

CJam , Erik , o Outgolfer

q5/:i:c

00072001010010800108001110004400032000870011100114001080010000033

Experimente online!

Quão?

q       - Take input (string)
 5/     - split into chunks of five
   :i   - cast to integers
     :c - cast to characters

C # (.NET Core) , Grzegorz Puławski

A solução que encontrei faz uso muito substancial de caracteres não imprimíveis, portanto, tentar colá-lo aqui não funcionou bem. Os valores de bytes para a entrada são:

109, 89, 4, 121, 3, 11, 8, 29, 37, 38, 27, 25, 72, 4, 4, 4, 3, 3, 3, 4, 4, 37, 3, 27, 4, 3

Ou a versão da sequência está disponível no campo de entrada do link TIO.

Experimente online!

O programa original pegaria os caracteres distintos na entrada, depois reverteria a entrada e multiplicaria os elementos das duas listas. Assim, criei uma string com 26 caracteres, onde os 13 primeiros caracteres eram distintos, todos os 13 últimos também apareceram nos 13 primeiros, e cada par de índices [i, 26-i]multiplicado pelo valor de byte do i-ésimo caractere Hello, World!.

Ly , LyricLy

n[>n]<[8+o<]

2 25 92 100 106 103 79 24 36 103 100 100 93 64

Experimente aqui (embora a página não renderize a nova linha).

nrecebe entrada, tenta dividir em espaços e converter em entradas, essas são colocadas na pilha. oimprime pontos ordinais e 8+faz o que alguém poderia pensar. Portanto, a entrada precisa ser 8 a menos que os pontos de código na ordem inversa, dividida por espaços.

C (gcc), de Felix Palmen

Código original:

#define O(c)(((char**)v)+c)
#define W(c)*(O(c)-**O(2)+x)
main(x,v){puts(W(42));}

Argumentos:

"Hello, World!" ","

Experimente online!

Explicação:

W(c)está calculando o endereço de uma string da lista de argumentos a ser impressa. Começa com o endereço do césimo argumento ( O(c)), que é o 42º argumento neste caso, e subtrai o primeiro caractere do segundo argumento ( **O(2)) como um deslocamento inteiro, e depois adiciona x, que é o número de argumentos.

W(c)usa o segundo argumento, para que você saiba que precisa haver pelo menos três deles (0, 1, 2). Então "Olá, mundo!" pode ir no primeiro argumento e, para abordá-lo, você precisa de um caractere cujo valor ASCII se encaixe na equação "42-x + 3 = 1". Isso passa a ser ",".

JavaScript: ThePirateBay

Eu substituo os métodos valueOf()e toString()dos objetos analisados ​​para que a coerção falhe com a TypeError.

{"valueOf": 7, "toString": 7}

6502 Assembly (C64) - Felix Palmen

A resposta correta é 52768,23

A explicação está um pouco envolvida.

00 c0                          ;load address
20 fd ae      jsr $aefd        ; checks for comma
20 eb b7      jsr $b7eb        ; reads arguments

O código primeiro verifica uma vírgula (necessidade de sintaxe) e, em seguida, lê dois argumentos, o primeiro dos quais é uma PALAVRA, armazenado little-endian nos locais de memória 0014 e 0015, o último dos quais é armazenado no registro X.

8a              TXA            ;Store second argument into A (default register)
0a              ASL            ; bitshifts the second argument left (doubles it)
45 14           EOR $14        ; XOR that with the low byte of first argument
8d 21 c0        STA $c021      ; Drop that later in the program

Isso é bastante inteligente, usando nossa entrada para reescrever o programa. Eventualmente, reescreve o contador para o loop de saída no final do programa.

45 15           EOR $15        ; XOR that with the high byte of the first argument
85 15           STA $15        ; Put the result in $15
49 e5           EOR #$e5       ; XOR that with the number $e5
85 14           STA $14        ; Put that in $14

Aí vem a parte desonesta:

8e 18 d0        STX $d018      ; stores the original second argument in d018

no C64, o d018 é um byte muito importante. Ele armazena os pontos de referência para itens que envolvem a saída da tela. Veja aqui para mais informações. Se isso der um valor errado, ele travará o seu C64. Para imprimir as letras maiúsculas e minúsculas necessárias, é necessário US $ 17.

Agora começamos nosso loop de saída:

a0 00               ldy #$00       ; zeroes out the Y register
b1 14               lda ($14),y    ; puts the memory referenced by the byte
                                   ;   starting at $14 (remember that byte?)
                                   ;   into the default register
20 d2 ff            jsr $ffd2      ; calls the kernal routine to print the char stored in A
c8                  iny            ; increment Y
c0 0e               cpy #$0e       ; test for equality with the constant $0e

Essa constante é o que foi escrito antes. Determina claramente quanto tempo o loop é executado. Já é o valor certo, mas precisamos manter 0e lá novamente.

d0 f6                   bne *-8        ; jump back 8 bytes if y and that constant weren't equal
60                      rts            ; ends the program

O restante é apenas a informação que precisamos imprimir, começando no endereço de memória c025.

Então, é só seguir a matemática a partir daí.

Código 6502 da máquina (C64) - Felix Palmen

A resposta correta é

8bitsareenough

O código é bastante complicado, envolvendo muita auto-modificação. Então, em vez de fazer a engenharia totalmente reversa, você pode usá-lo para se quebrar.

Aqui está uma desmontagem do código um pouco mais útil, para ajudar a entender o que aconteceu. A sintaxe é para o KickAssembler.

*=$c000       // LOAD ADDRESS
jsr $aefd     //checks for a comma
jsr $ad9e     /*Reads in an argument. Stores length of it into
                $61, with the address of the stored arg in $62-3*/
jsr $b6a3     /*Evaluates the string, leaving the pointer on $22-3
                and the length on A*/ //I think

ldy #$00
loop: lda thedata,y   
cpy #$01
beq shuffle
cpy #$07
beq shuffle
cpy #$0b
beq shuffle
tricks: jsr output
iny
bne loop
output: eor ($22),y      //XOR's A with the y-eth letter of our input
jmp $ffd2               //good old CHROUT, returns to tricks above
thedata: .byte $f0,$48,$fa,$a2, $1c,$6d,$72,$30
.byte $06,$a9,$03,$48,$7c,$a3
shuffle: sta $c048      //drops A in mystery+4, over the constant
lda $c026,y
sta $c045               //overwrites the low byte of mystery
lda $c027,y
sta $c046               //overwrites the high byte of mystery
ldx #$00
mystery: lda $aefd,x              
eor #$23
jsr output
iny
inx
cpx #$03
bne mystery
cpy #$0e
bne loop
eor #$1a
sta $d018                
rts

Rotulá-lo dessa forma foi suficiente para eu ver que o código XORs um monte de constantes que estão ocultas para imprimir o que precisamos. Como o XOR é reversível, se você inserir a saída desejada, ele informará qual é a chave.

Então eu mudei a última linha

/*from sta $d018 
to*/ jsr $ffd2

para imprimir a última entrada necessária em vez de travar em uma entrada errada.

E é isso!

Se houver algum interesse, decifrarei mais o código.

Explode , Passo Galinha

@_?&4_-j>5&f^~c>&6\|4>7

Rh / qi?, Wcr + du

Experimente online!

• Tentar descobrir o que todos os "exploradores" estão realmente machucando a cabeça de alguém, então eu simplesmente fiz a engenharia reversa (literalmente: p - começando pelo caractere mais à direita, eu compenso cada um por sua vez [ao redor] do intervalo de caracteres imprimíveis) .

C (tcc) por Joshua

int puts(const char *s)
{
    printf("Hello, World!%s", s);
}

Experimente online!

MATL by Luis Mendo

tsZp?x

Experimente online!

Geléia por Jonathan Allan

Código original:

œ?“¥ĊɲṢŻ;^»œ?@€⁸ḊFmṪ⁷

Experimente online!

Entrada:

1,2586391,2949273,3312154,3312154,1134001,362881,2223505,766081,1134001,1497601,3312154,1860601,140

Explicação:

Principalmente, é necessário entender o que o código faz. A primeira coisa que faz é pegar a corda"!,Word Hel"(com todos os caracteres necessários, exceto nova linha) e cria várias permutações deles. As entradas especificam números de permutação e cada par de permutações da entrada é aplicado aos strings que excluem pares onde a primeira permutação é aplicada primeiro. Basicamente, P2 (P1 (S)), P2 (P2 (S), P2 (P3 (S)), ..., P2 (PN (S)), P3 (P1 (S)), ..., P3 (PN (S)), ... ..., PN (P1 (S)), ..., PN (PN (S)) Tudo isso é concatenado, então a última entrada é reutilizada para cada PNth caractere dessa string grande. Então, eu pego PN = len (S) * N = 10 * N. Isso significa que pegaremos o primeiro caractere de P2 (P1 (S)), o primeiro caractere de P3 (P1 (S )), até o primeiro caractere de PN (P1 (S)) .Para simplificar, deixei P1 = 1, que é a permutação de identidade.Em seguida, basta escolher qualquer P2 que permita "H" no primeiro posição, um P3 que permite "e" na primeira posição e assim por diante. Felizmente, pequenos números de permutação como o já escolhido para PN não afetam os caracteres anteriores da string, portanto o PN deixa "!" no início da string. (Se isso não fosse verdade, ainda seria possível resolver escolhendo um P1 diferente.)

C (GCC no TIO) por MD XF

4195875

Experimente online!

Quão?

Ele tenta imprimir o segundo argumento como uma string, que é um ponteiro que podemos determinar na entrada. Acontece que no local a memória 4195875inicia a "Hello, World!\n"string.

O número foi determinado adicionando print("%p", "Hello, World!");antes de printf, convertendo o número hexadecimal em decimal e testando-o no TIO original. No entanto, ele me mostrou a printfstring de formato. Ao experimentar alguns números, descobri que a string está localizada antes da string de formato.

Portanto, na memória, ficaria assim (como uma string C):

Hello, World!\n\0%2$s\0

Isso também significa que qualquer atualização no compilador pode interromper a solução.

JavaScript (Node.js) por Voile

['Hello, World!','','','','','','','','','','','','']

Experimente online!

Röda por fergusq

[1, "HH", 1, "eellloo", 1, ",,", 1, "  WWoo", 1, "rr", 1, "ll", 1, "dd", 1, "!!"]

Experimente online!

Explicação em breve ...

JavaScript (ES6), Voile

var i = 0;
var string = `"${t}"`;
var answer = "i++?0:q=string";
console.log( f(answer) );

Experimente online!

PHP por LP154

PDO,FETCH_CLASSTYPE

Experimente online!

(O TIO não tem a classe PDO definida, portanto, a demonstração acima usa um teclado de código que faz)

Outra solução:

ReflectionFunction,IS_DEPRECATED

Experimente online!

JavaScript (ES6), Voile

Dado o limite de 81 caracteres, essa provavelmente não é a solução pretendida

global.g = ()=>"Hello, World!";
var str = "g";

Experimente online!