"Olá Mundo!" (Fio dos ladrões)


11

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.

Respostas:


12

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.


Bem-vindo à programação de quebra-cabeças e código de golfe! Deixei um comentário sobre a resposta policial. Link do TIO para os interessados: tio.run/##jc/…
Dennis

Agradável! Minha solução parecia diferente, mas utilizava a mesma idéia: construir uma cadeia octal e usar a sintaxe de aspas simples e usar indiretamente. Bem feito =)
Sísifo

4

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)

Base negativa ... bonita ...
Erik the Outgolfer



3

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.


3

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:

Oitava concha

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!



Mas não é assim que o desafio se parece, se assim for, seria muito mais fácil (substitua o último 0por a 10).
ბიმო

@BruceForte Isso é que o desafio pede: "Seu desafio é escrever um programa ou função que, com uma certa entrada, imprime a cadeia exata Hello, World!e uma nova linha." é uma citação exata do desafio. E, de fato, isso torna a resposta trivial.
hvd

@ hvd Sim, mas se você olhar para a imagem do OP, a solução dele não é, é daí que vem a principal confusão.
ბიმო

1
@HyperNeutrino FWIW este é o que eu acho que o estilo pretendido de solução é.
Jonathan Allan


3

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


3

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!


2
Sim, esta é a solução pretendida :) O proxy precisa de mais amor.
Voile

3

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

3

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.


Ah, muito bem! Eu estava pensando em usar em nextvez de charque não funciona no Lua 5.3 devido à randomização da ordem de iteração.
Tehtmi

3

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!


3

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.


Deve ser corrigido agora, assim que Dennis puxar Cubically, será corrigido no TIO.
MD XF


2

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


Bom trabalho! Você conseguiu omitir a armadilha Take (a.First () - 33). Isso também me fez perceber que esqueci Disctinct no verso, mas tudo bem, ainda assim, foi um bom desafio, eu acho. Também tinha% 255 para que você pudesse usar números mais altos, em ASCII imprimível.
Grzegorz Puławski

2

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.


Isso não imprime uma nova linha à direita, não é?
usar o seguinte código

Ah, opa, facilmente retificável!
Jonathan Allan

... é mesmo? Eu teria pensado 2que funcionaria - isso é apenas a página herokuapp não a processando?
Jonathan Allan

1
Sim, adicionando 2 trabalhos. A página simplesmente não processa as novas linhas à direita.
precisa saber é o seguinte

2

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 ",".


Grande explicação, eu vou editar meu post assim que eu estou em um PC :)
Felix Palmen

2

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}

12
Umm, eu não consigo entender. Por favor, elaborado ou algo assim? Especialmente a parte dalksdjalkdjaS djalksdjalksdja , isso me confunde um pouco.
Erik the Outgolfer

@EriktheOutgolfer Eu editei a parte de spam, mas não tenho idéia do por que estava lá.
NoOneIsHere

@EriktheOutgolfer oh lol. Isso estava passando para impedir que minha resposta se convertesse automaticamente em um comentário.
Maltysen 12/08/19

1
@Maltysen Bem, há uma edição botão direito lá que pode ser útil na próxima vez;)
Erik o Outgolfer

2

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


Absolutamente correto, parabéns. Pode demorar um pouco para editar corretamente minha postagem, estou no celular agora.
Felix Palmen

O d018 foi muito inteligente e eu gosto de como você postou uma dica secretamente.
Um homem de ouro

d018 era o abridor de portas pretendido ... a dica foi acidental, eu quis dizer $FFlá, mas depois decidi deixá-la.
Felix Palmen

2

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.


Uau, isso é de fato um atalho enorme, eu provavelmente deveria ter forçado uma falha na entrada errada no início do processamento. Havia outro atalho possível, usando o depurador de vice. Mas seja como for, é a solução correta.
Felix Palmen

Eu não sabia que o vício tem um depurador. É isso que recebo por aprender um idioma apenas para decifrar respostas.
Um homem de ouro

Editou minha postagem, com algumas explicações. Bom trabalho, apenas modificar o programa para não travar, é claro, é uma maneira bastante óbvia, não pensei nisso.
Felix Palmen

Nitpick: " drops A in mystery+1, over the constant" <- esse é realmente o mystery+4seu rótulo. As ofensas estão em bytes :) e no FWIW, a auto-modificação é bastante comum mesmo no código 6502 sério , desde que o código seja executado a partir da RAM.
Felix Palmen

1

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

Good job :) Vou acrescentar uma explicação em algumas horas quando estou de volta ao meu PC
Stephen

1

C (tcc) por Joshua

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

Experimente online!


Droga. Eu tinha esse crack exato, mas não consegui fazê-lo funcionar no TIO. +1
MD XF

Desculpa aí. Fwiw está consertado agora.
Dennis

Você sabe qual era o problema?
MD XF

Sei como corrigi-lo (o tcc teve que ser construído com o suporte ao SELinux), mas não sei ao certo o que isso faz ou por que era necessário.
Dennis


1

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


São necessárias 14 permutações da lista das 14 permutações, aplainam, desenfileiram e, em seguida, recebem todos os 140 caracteres.
Jonathan Allan

1

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.






1

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!


Genious. passando uma string de caracteres com manipulação global. Parece que ele é a solução pretendida #
72817

Essa não é a solução destinada :(
Voile

Agora que estou pensando sobre isso, acho que não é permitido fazer muitas coisas assim antes de passar a entrada em uma função, a menos que essas coisas também possam ser compostas como parte da entrada (por exemplo, dentro da função que será avaliadas internamente), já que o desafio exige que você faça uma entrada que resultará em 'Olá, Mundo!', não em um programa completo. Caso contrário, praticamente nada pode ser seguro. Então eu acho que esse crack pode ser inválido?
Voile

@ Voil Pode muito bem ser. Eu acho que é justo ler a tarefa como se a entrada devesse ficar sozinha (ou seja, sem alterações no sistema externo) - especialmente se essa não for a solução pretendida :) Não há necessidade de marcar seu policial como rachado.
precisa saber é o seguinte

1
Eu fiz um meta post discutindo sobre isso. Sinta-se livre para deixar algumas discussões lá.
Voile
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.