"Hello world", que cria um programa diferente "Hello world"

19

Crie um programa que produza uma sequência de hello world ("Olá, mundo", "Olá, mundo" etc.) e o código-fonte. A saída é gravada em stdout ou equivalente. A cadeia Hello world está incorporada no código fonte.

Por exemplo, a saída para pode ser

(some source code here)hello world(some source code here)

Quando a saída é compilada ou interpretada novamente, ela deve criar uma saída semelhante, mas a cadeia hello world deve ter uma pontuação ou capitalização diferentes. Por exemplo, o exemplo anterior pode criar a seguinte saída

(some source code here)hello, wORld(some source code here)

Cada "(algum código-fonte aqui)" nesses exemplos pode mudar após cada execução ou pode ser a mesma.

Sua saída deve conter uma sequência válida de hello world exatamente uma vez. Pode conter qualquer quantidade de seqüências inválidas de hello world. O código-fonte pode conter qualquer quantidade de comentários e a string hello world pode ser incorporada nos comentários. O primeiro programa pode ter zero ou uma sequência de hello world válida, mas não mais.

A pontuação a seguir é válida:

hello, world
hello world
helloworld

Qualquer capitalização é aceitável. Por exemplo, estas são cadeias de caracteres hello world válidas:

Hello, world
hellO WORld
HELLoworlD

Essas strings não são válidas:

Hello     world
Hello(newline)world
Hello,world
Hello, Steve

Seu programa falha assim que uma das seguintes condições é atendida:

  • Ele gera uma string hello world que foi produzida durante alguma execução anterior,
  • a saída não é mais um código fonte válido no mesmo idioma ou
  • a saída não contém exatamente uma sequência válida de hello world.

Seu programa não é válido para este concurso, a menos que pelo menos duas primeiras execuções tenham êxito. Isso significa que a terceira saída pode ser inválida. A saída do seu programa pode não ser aleatória. A primeira execução deve sempre criar a mesma segunda saída, a segunda execução deve sempre criar a mesma terceira saída, etc.

A pontuação é calculada como a quantidade de bytes no código-fonte do programa inicial. Menor pontuação ganha.

Os seguintes bônus se aplicam (até -60%):

  • -5% * (N - 2), em que N é o índice da execução após o qual o seu programa produz uma saída inválida. Esse bônus é limitado em -50%. Se o seu programa for bem-sucedido 12 vezes ou mais, você recebe o bônus máximo.
  • -10%, se suas saídas (incluindo o primeiro código-fonte) incluírem todas as três alternativas de pontuação válidas.

Seu envio deve incluir o primeiro código-fonte e também deve conter os resultados das execuções bem-sucedidas. Se o seu programa tiver êxito mais de 12 vezes, adicione a saída para 12 execuções.

Exemplo

A próxima linha é o primeiro código fonte. Quando o executamos, é a primeira execução.

hello world(some source code here)

A próxima linha é a saída do primeiro código-fonte. É a primeira saída.

hello, world(some source code here)

A próxima linha é a saída da segunda execução. É a segunda saída.

helloworld(some source code here)

Quando executamos a primeira saída, esse programa se tornou elegível ao bônus de -10%. Isso significa que temos duas saídas e um código original, todos com pontuação diferente. Além disso, como a segunda saída foi válida, este programa é elegível para este concurso.

A próxima linha é a saída da terceira execução. É a terceira saída.

Helloworld(some source code here)

A próxima linha é a saída da quarta execução. É a quarta saída.

hellworld(some source code here)

Esta saída foi inválida. O índice da última execução válida foi 4. Este programa é elegível para bônus de -5% * (4-2) e bônus de -10% da pontuação. Isso totaliza -20%. O comprimento do primeiro código fonte ("olá mundo (algum código fonte aqui)" foi de 34 bytes; portanto, a pontuação final é 27,2.

code-golf string quine hello-world
fonte
11
As regras habituais de quine se aplicam ou o programa pode ler seu próprio arquivo de origem?
27530 Martin Ender5
11
Regras de quine usuais se aplicam.
O código original conta para os bônus? Da mesma forma, o código original precisa conter um válido hello world?
22815 Martin Ender #
11
O código original conta para bônus. O código original não precisa conter um olá mundo válido.
Você tem certeza da última alteração de regra? Juntamente com "O primeiro programa não precisa conter uma sequência válida de hello world ou pode conter várias seqüências válidas de hello world". Eu poderia adicionar as variações desaparecidas como um comentário ao código fonte original para obter o bônus (provavelmente não vale a pena na maioria dos casos, mas ainda se parece com uma brecha)
Fabian Schmengler

Respostas:

8

Pitão, 17 bytes

Uma solução Pyth diferente:

"r\"helloworld\"1

Resultado:

r"helloworld"1

Segunda saída:

HELLOWORLD
Fabian Schmengler
fonte
As regras atualmente declaram "Seu programa falha assim que uma das seguintes condições é atendida: a saída não é mais um código-fonte válido no mesmo idioma" e "Seu programa não é válido para este concurso, a menos que pelo menos três primeiras execuções sejam bem-sucedidas". . O HELLOWORLD é um programa válido em Pyth? Se sim, por favor, publique sua saída também ou explique o que ela faz. Caso contrário, acho que este programa é inválido.
Além disso, quero esclarecer que este programa não quebra regras sobre a repetição da mesma seqüência de caracteres. Esta solução repete "helloworld" que estava no primeiro código-fonte. As regras proíbem apenas a repetição de uma sequência que esteve nas saídas anteriores. Se a segunda saída for um programa Pyth válido, essa solução será perfeitamente válida.
Na hora de responder, as regras eram "Seu programa não é válido para este concurso, a menos que pelo menos duas primeiras execuções são bem sucedidos"
Fabian Schmengler
Oh, você está certo. Não sei por que mudei isso, porque meu exemplo no primeiro post afirma que duas saídas = solução válida. Vou corrigir as regras para refletir isso. Portanto, sua solução é válida. É também a melhor solução válida no momento.
9

Mathematica, 214 - 50% = 107 bytes

(a = Characters[StringJoin["helloworl", "d"]]; b = Apply[StringJoin, Tuples[Transpose[{a, ToUpperCase[a]}]], {1}]; StringReplacePart[ToString[#0, InputForm], b[[FirstPosition[b, "helloworld"] + 1]], {180, 189}]) &

Decidi otimizar a contagem de cadeias aqui. Isso funciona para 1024 programas sem parar, passando por todas as combinações de letras maiúsculas e minúsculas. A execução pode ser vista aqui .

LegionMammal978
fonte
11
Uma pena que você não possa jogar fora do espaço em branco e usar notação de prefixo e infixo nos quines do Mathematica, não é? ;) (Este pode ser o tempo suficiente para a abordagem oposta Quine ao trabalho, onde armazenar o código em uma corda s, e avaliá-lo com ToExpression).
Martin Ender
6

Vitsy, 33 - 33 * .05 * (11-2) = 18,15 bytes

Heh! Bata isso! Você provavelmente vai. : c

Primeira saída:

'0DV \ {25 ^ -V \}} 1+ {rd3 * Z; helloworld
Comece a capturar como uma sequência
 0DV Pressione 0 na pilha e defina-a como a variável final.
    \ Repita o próximo item várias vezes. (1, 2, 3 ... nas saídas.)
     {Gire a pilha para a esquerda.
      25 ^ Pressione 32 para a pilha.
         - Subtraia o item superior por ele - isso fará maiúsculas em minúsculas.
          V \ Faça o próximo item final vezes variáveis.
            } Gire a pilha para a direita.
             } E de novo...
              1+ Adicione um. Isso faz com que 0 neste código seja 1, depois 2 ...
                r Inverta a pilha.
                 d3 * Pegue o personagem '
                    Z Gera todos os itens da pilha.
                     ; Finalize a execução.
                      helloworld String para manipular.

Segunda saída:

'1DV \ {25 ^ -V \}} 1+ {rd3 * Z; helloworlD

Terceira saída:

'2DV \ {25 ^ -V \}} 1+ {rd3 * Z; helloworLD

Quarta saída:

'3DV \ {25 ^ -V \}} 1+ {rd3 * Z; hellowoRLD

Quinta saída:

'4DV \ {25 ^ -V \}} 1+ {rd3 * Z; hellowORLD

Sexta saída:

'5DV \ {25 ^ -V \}} 1+ {rd3 * Z; helloWORLD

Sétima saída:

'6DV \ {25 ^ -V \}} 1+ {rd3 * Z; hellOWORLD

Oitava saída:

'7DV \ {25 ^ -V \}} 1+ {rd3 * Z; helLOWORLD

Nona saída:

'8DV \ {25 ^ -V \}} 1+ {rd3 * Z; heLLOWORLD

Décima saída:

'9DV \ {25 ^ -V \}} 1+ {rd3 * Z; hELLOWORLD

Décima primeira saída:

': DV \ {25 ^ -V \}} 1+ {rd3 * Z; HELLOWORLD

Esta é a última saída, pois causará um erro.

Addison Crump
fonte
11
o_o Simplex lutou até 21. Vou trabalhar para vencer as 18h15!
Conor O'Brien
@ CᴏɴᴏʀO'Bʀɪᴇɴ Vitsy foi praticamente construído para editar seu próprio código fonte e fazer manipulação básica de strings. XD Eu acho que isso pode ser mais desvalorizado.
Addison Crump #
Eu pensei que simplex seria incrível, uma vez que tem uma função de programa externo, mas nãoooo que contaria como um programa. le suspiro
Conor O'Brien
+1 para derrotar (ou quase derrotar) os idiomas "clássicos" do golfe
ev3commander 5/11/15
@ ev3commander Eu os venceria se o bônus de iteração fosse maior. : c
Addison Crump
5

CJam, N = 3 4, 28 bytes - 10% - 10% = 22,4

{`_E=-"_~Hello!, World"2<}_~

isso inicia a seguinte cadeia:

{`_E=-"_~Hello, World"2<}_~
{`_E=-"_~Hello World"2<}_~
{`_E=-"_~HelloWorld"2<}_~
{`_E=-"_~Helloorld"2<}_~

onde o último não contém mais um "Olá, mundo" válido.

Teste aqui.

Explicação

{`     e# Quine framework. Leaves a string representation of the block on the stack.
  _E=  e# Make a copy and get the 14th element, which is the character of the first 'o'.
  -    e# Remove that character from the string.
  "_~Hello!, World" e# Push this string, so the "Hello, World!" is part of the code.
  2<   e# Truncate to just "_~" to get the output right.  
}_~

Observe que o programa inicial não contém um "Olá, Mundo" válido, mas isso nos permite avançar uma iteração.

Martin Ender
fonte
Isso se qualifica para o bônus de -10%? As saídas contêm apenas dois dos três formulários de pontuação válidos.
Mike Bufardeci
@ MikeBufardeci Oh, boa pergunta ... Eu meio que assumi que o código original fazia parte dele.
22815 Martin Ender #
11
Esclarei as regras para que o código original seja contabilizado para o bônus. Embora eu deva admitir que não percebi que é fácil obter -10%.
5

CJam 69 60 - 50% = 30

Eu ainda sou iniciante, por favor me diga como jogar golfe no CJam.

{`_40>\40<_38>~)`2Te[\25<"helloworld"00YbATe[.{{el}{eu}?}`+]W%"_~"}_~

É entediante imprimir cada iteração, pois será válido por 99 iterações.

Ele funciona enumerando a capitalização da palavra hello. O tédio é dividir as cordas em partes, já que o "olá mundo" e o contador precisam ser atualizados.

Explicação

{`_40>\40<_38>~)`2Te[\25<"helloworld"00YbATe[.{{el}{eu}?}`+]W%"_~"}_~
{`                                                                      e# standard quine framework. Thanks for Dennis.
  _40>                                                                  e# get the Yb11..
      \40<                                                              e# get those that not included in top
          _38>~)`2Te[                                                   e# get the accumulator and increment it
                     \25<                                               e# get those before "hello world"
                         "helloworld"                                   e# the Hello World
                                     00                                 e# accumulator
                                        YbATe[                          e# convert to binary and align right.
                                              .{{el}{eu}?}              e# Uppercase if the corresponding bit is 0
                                                          `             e# add quote
                                                           +]W%         e# reorder stack
"_~"}_~

NOTA: Não li a resposta do Mathematica, desculpe, acho que era original

Com a reordenação e com letras maiúsculas diferentes, perco 9 bytes.

{`_6<\"helloworld"01YbW%.{{eu}{el}?}`\I>_2<~)`2Te[\2>"_~"}_~
{`                                                   "_~"}_~ e# Standard quine framework
  _6<\                                                       e# Get "{~_6<\"
      "helloworld"                                            e# The helloworld
                  01                                          e# The accumulator
                    Yb                                        e# Convert to base 2
                      W%                                      e# Reverse the binary
                        .{{eu}{el}?}                          e# Convert to uppercase while the corresponding bit is 1.
                                    `                         e# Add quote
                                     _2<                      e# Get accumulator
                                        ~)`2Te[               e# Increment the accumulator
                                               \2>            e# get the rest

CJam 73 - 60% = 29,2

Desta vez, também enumere a pontuação.

{`:Z6<"HELLOWORLD"0:AYbW%.{{eu}{el}?}`", ":B-_6<BA3%>@6>A)ZW%52<W%"_~"}_~
{`:Z                                                              "_~"}_~ e# Standard Quine Framework
    6<                                                                    e# take the first 6 character
      "HELLOWORLD"                                                        e# Hello, world
                  0:A                                                     e# Accumulator
                     YbW%.{{eu}{el}?}`                                    e# See above
                                      ", ":B                              e# Punctuation
                                            -                             e# Delete punctuation
                                             _6<                          e# "hello
                                                BA3%>                     e# punctuation
                                                     @6>                  e# world"
                                                        A)                e# incremented accumulator
                                                          ZW%52<W%        e# Remaining part
Akangka
fonte
Você tem um idioma diferente e uma resposta mais curta; portanto, não há nada errado usando a mesma abordagem da resposta do Mathematica.
Observe que estamos procurando a pontuação mais baixa, não o pôster mais rápido ou o algoritmo mais recente.
@ Ville-ValtteriTiittanen Ainda assim, a resposta de Martin Büttner ainda é menor do que eu
Akangka
O @ChristianIrwan Yours é interessante porque, embora produza letras maiúsculas diferentes (e tenho certeza de que é possível jogar perto da minha ou talvez até vencê-la, mas não tenho tempo para analisá-la em detalhes agora).
Martin Ender
4

GolfScript, 35 bytes - 50% = 17,5

0"HelloWorld"{@@{^.32&\}%`@".~"}.~

Decidi exagerar no número de execuções antes de repetir. Este programa, com sua saída retornada ao intérprete GolfScript, produzirá 890 seqüências distintas do Hello World antes da primeira repetição. Como uma breve amostra, aqui estão as 15 primeiras iterações:

0"HelloWorld"{@@{^.32&\}%`@".~"}.~
0"HeLlOWoRlD"{@@{^.32&\}%`@".~"}.~
0"HelLOWorLD"{@@{^.32&\}%`@".~"}.~
0"HeLLOWoRLD"{@@{^.32&\}%`@".~"}.~
0"HellowORLD"{@@{^.32&\}%`@".~"}.~
32"HeLlOworld"{@@{^.32&\}%`@".~"}.~
0"hELloWoRlD"{@@{^.32&\}%`@".~"}.~
32"helLowORld"{@@{^.32&\}%`@".~"}.~
0"HeLLoWORlD"{@@{^.32&\}%`@".~"}.~
32"HellOWORld"{@@{^.32&\}%`@".~"}.~
0"hElLOWORlD"{@@{^.32&\}%`@".~"}.~
32"heLLOWORld"{@@{^.32&\}%`@".~"}.~
32"HelloworLd"{@@{^.32&\}%`@".~"}.~
32"hElLoWoRLd"{@@{^.32&\}%`@".~"}.~
0"HEllOWorlD"{@@{^.32&\}%`@".~"}.~

A maneira como funciona é iterando a string, invertendo a capitalização de cada letra (XORing seu código ASCII com 32) se a letra anterior (depois de possivelmente ter seu caso invertido) estiver em minúscula. A primeira letra terá sua caixa invertida se o número no programa inicial for 32 em vez de 0 - e o número de saída para a próxima iteração será 32 sempre que a última letra da string for minúscula, causando alterações no final de a sequência a propagar de volta ao início na próxima iteração.

(Esse processo de feedback em particular foi obtido de uma maneira totalmente ad hoc . Inicialmente, eu queria apenas executar um contador binário simples usando maiúsculas e minúsculas como bits, mas isso levou muitos bytes para implementar, então comecei a ajustá-lo para encontrar algo mais curto isso ainda produziria um comprimento de ciclo bastante alto. Como o máximo teórico, usando apenas inversão de maiúsculas e minúsculas, é 2 10 = 1024, é muito bom obter um ciclo de 890 iterações.)

Infelizmente, o bônus para iterações adicionais é limitado em -50%; sem o limite, este programa teria um enorme bônus de -4440%. ;-)

Ilmari Karonen
fonte
3

Pitão, 18 bytes

"-\"hello world\"d

Que retorna:

-"hello world"d

Por sua vez, imprime:

helloworld

Eu tive uma solução que fez todas as três grafias, mas é mais longa, mesmo com o bônus.

Mike Bufardeci
fonte
Observe que esta resposta foi inválida brevemente até que as regras foram revertidas para exigir duas iterações em vez de três. Agora é válido novamente, no entanto.
DLosc
3

Simplex , 21 bytes.

Foi para isso que nasceu a Simplex . Definitivamente, posso ir mais longe com isso.

(Continuo pressionando Ctrl + Enter, desculpe! Eu culpo o teclado do tablet)

Tentativa 3, v.0.8 +, 31 -5% = 29.45 bytes (métodos UTF-8)

Aquele emote no meio me expressa. Tipo de. Por que eu fiz isso de novo? ._.

"\"f[helloworld]-:D-``\"§R'Hg"g
"                            "  ~~ write that string
 \"f[helloworld]-:D-``\"§R'Hg   ~~ escaped quotes
                              g ~~ output that string

2ª saída:

"f[helloworld]-:D-``"§R'Hg
"                   "      ~~ write that string
 f[helloworld]-:D-``       ~~ string to be written
                     §R    ~~ go to second cell
                       'H  ~~ set it to H charcode
                         g ~~ output that string

3ª saída:

f[Helloworld]-:D-``
f                   ~~ turns off safety mode (heck yeah error suppression!)
 [          ]-      ~~ write inside to outer program
  H                 ~~ sort strip
   e                ~~ write e = 2.718281828459045... to the strip
    ll              ~~ writes 1 twice to the cell
      o             ~~ outputs 1
       wo           ~~ apply o backwards through the strip (outputs 1)
         r          ~~ error! tries to access register for modification. nope!
          l         ~~ write 1 to to the current cell
           d        ~~ reverse the strip (NOP)
              :     ~~ removes last char of outer program
               D    ~~ double the current byte (2)
                -   ~~ writes previous char to outer program
                 `` ~~ suppress outer program evaluation and instead output it

Saída final:

HelloworlD

Tentativa 2, v.0.8 +, 21 bytes (UTF-8, eu acho)

"\"helloworld\"§'Hg"g
"                  "  ~~ write that string
 \"helloworld\"§'Hg   ~~ escaped quotes
                    g ~~ output that string

Resultado:

"helloworld"§'Hg
"          "     ~~ write that string
 helloworld      ~~ string to be written
            §    ~~ go to first cell
             'H  ~~ set it to H charcode
               g ~~ output that string

Saída final:

helloworld

Tentativa 1, v.0.7 + 28 26 bytes

Não tenho certeza se isso se qualifica para o primeiro bônus ...

"BhelloworldB"t[s32S;]'gs;
"            "             ~~ write that string
 BhelloworldB              ~~ the string
              t[     ]     ~~ apply the inner from left to right
                s          ~~ output as character
                 32S       ~~ subtract 32 ("capitalize")
                    ;      ~~ add the current byte's char to the outer program
                      'g;s ~~ add g to the outer program

Primeira saída:

"HELLOWORLD"g

O programa externo é avaliado no final da execução (ele faz isso por y; é assim que o programa externo se parece:

"HELLOWORLD"g
"          "  ~~ write that string
            g ~~ output that string as string characters

Saída final:

HELLOWORLD
Conor O'Brien
fonte
Este programa é elegível para o bônus de -50%? Parece que poderia ser, mas você não publicou nenhuma saída.
@ Ville-ValtteriTiittanen Só funciona duas vezes. Estou trabalhando em bônus no momento.
Conor O'Brien
2

Rubi, 81 - 50% = 40,5

Código original:

_='_=%p;puts (_%%[_,%p]).sub(/[[:upper:]]/,&:swapcase)';puts _%[_,'HELLOWORL'+?D]

Saídas sucessivas:

_="_=%p;puts (_%%[_,%p]).sub(/[[:upper:]]/,&:swapcase)";puts (_%[_,"HELLOWORLD"]).sub(/[[:upper:]]/,&:swapcase)

_="_=%p;puts (_%%[_,%p]).sub(/[[:upper:]]/,&:swapcase)";puts (_%[_,"hELLOWORLD"]).sub(/[[:upper:]]/,&:swapcase)

_="_=%p;puts (_%%[_,%p]).sub(/[[:upper:]]/,&:swapcase)";puts (_%[_,"heLLOWORLD"]).sub(/[[:upper:]]/,&:swapcase)

_="_=%p;puts (_%%[_,%p]).sub(/[[:upper:]]/,&:swapcase)";puts (_%[_,"helLOWORLD"]).sub(/[[:upper:]]/,&:swapcase)

_="_=%p;puts (_%%[_,%p]).sub(/[[:upper:]]/,&:swapcase)";puts (_%[_,"hellOWORLD"]).sub(/[[:upper:]]/,&:swapcase)

_="_=%p;puts (_%%[_,%p]).sub(/[[:upper:]]/,&:swapcase)";puts (_%[_,"helloWORLD"]).sub(/[[:upper:]]/,&:swapcase)

_="_=%p;puts (_%%[_,%p]).sub(/[[:upper:]]/,&:swapcase)";puts (_%[_,"hellowORLD"]).sub(/[[:upper:]]/,&:swapcase)

_="_=%p;puts (_%%[_,%p]).sub(/[[:upper:]]/,&:swapcase)";puts (_%[_,"hellowoRLD"]).sub(/[[:upper:]]/,&:swapcase)

_="_=%p;puts (_%%[_,%p]).sub(/[[:upper:]]/,&:swapcase)";puts (_%[_,"helloworLD"]).sub(/[[:upper:]]/,&:swapcase)

_="_=%p;puts (_%%[_,%p]).sub(/[[:upper:]]/,&:swapcase)";puts (_%[_,"helloworlD"]).sub(/[[:upper:]]/,&:swapcase)

_="_=%p;puts (_%%[_,%p]).sub(/[[:upper:]]/,&:swapcase)";puts (_%[_,"helloworld"]).sub(/[[:upper:]]/,&:swapcase)

Eu acho que isso conta como os 50% completos? Pode estar fora de um. Além disso, provavelmente existe uma solução sem bônus com melhor pontuação no Ruby.

O código original não contém "helloworld", mas cria um quine que substitui a primeira letra maiúscula em seu código-fonte pela versão em minúscula. Assim, cada execução sucessiva do quine produz uma letra menos maiúscula.

O truque aqui é usar uma string de formato para interpolar a própria string, para quining, e a string Hello World, para que apareça apenas uma vez.

histocrata
fonte
1

PHP, 297 - 40% = 178,2 bytes

Não é realmente competitivo, mas foi divertido escrever

<?ob_start(function($s){$s=substr(str_replace(0,0+(int)true,$s),!i,ord(I)+ord(I));$h=hello.world;$h[0]=$h[0]^' ';return "<"."?".$s."?".">".$s.$h;});?>ob_start(function($s){$s=substr(str_replace(0,0+(int)true,$s),!i,ord(I)+ord(I));$h=hello.world;$h[0]=$h[0]^' ';return "<"."?".$s."?".">".$s.$h;});

É uma variação deste quine:

<?
ob_start(function($b){ return "<"."?\n$b?".">\n$b"; });?>
ob_start(function($b){ return "<"."?\n$b?".">\n$b"; });

mas também adiciona "helloworld" à saída e substitui 0por 0+1(na próxima iteração 1por 1+1e assim por diante). O uso de substrqualquer saída "helloworld" existente é removido antes que o novo "helloworld" seja adicionado.

Para obter resultados diferentes, uma letra de "helloworld" é maiúscula (determinada pelo número crescente). Este é o código relevante:

$h=hello.world;$h[0]=$h[0]^' '

Um desafio era não usar nenhum número, exceto aqui e para a substituição do número

str_replace(0,0+(int)true,$s)

Lá você já vê que +1é realizado como +(int)true.

Para os argumentos de substring, eu precisava 0, 146:

!i, ord(I)+ord(I)

A cadeia não vazia "i" é coagida truee negada. falseé um argumento inteiro válido e é tratado como 0. ord(I)é o valor ASCII de "I": 73

Saída (1ª iteração):

<?ob_start(function($s){$s=substr(str_replace(1,1+(int)true,$s),!i,ord(I)+ord(I));$h=hello.world;$h[1]=$h[1]^' ';return "<"."?".$s."?".">".$s.$h;});?>ob_start(function($s){$s=substr(str_replace(1,1+(int)true,$s),!i,ord(I)+ord(I));$h=hello.world;$h[1]=$h[1]^' ';return "<"."?".$s."?".">".$s.$h;});Helloworld

Saída (2ª iteração):

<?ob_start(function($s){$s=substr(str_replace(2,2+(int)true,$s),!i,ord(I)+ord(I));$h=hello.world;$h[2]=$h[2]^' ';return "<"."?".$s."?".">".$s.$h;});?>ob_start(function($s){$s=substr(str_replace(2,2+(int)true,$s),!i,ord(I)+ord(I));$h=hello.world;$h[2]=$h[2]^' ';return "<"."?".$s."?".">".$s.$h;});hElloworld

Saída (10ª iteração):

Esta é a última saída válida, mas não é mais um programa válido

<?ob_start(function($s){$s=substr(str_replace(10,10+(int)true,$s),!i,ord(I)+ord(I));$h=hello.world;$h[10]=$h[10]^' ';return "<"."?".$s."?".">".$s.$h?>ob_start(function($s){$s=substr(str_replace(10,10+(int)true,$s),!i,ord(I)+ord(I));$h=hello.world;$h[10]=$h[10]^' ';return "<"."?".$s."?".">".$s.$hhelloworlD

Role para a direita para encontrar as seqüências "Hello world"!

Fabian Schmengler
fonte
só percebi que eu posso mudar (int)truepara `` !! i` e salvar 12 bytes. Vai tentar golf um pouco mais tarde
Fabian Schmengler
1

Pip, 48 - 50% = 24

V Y"`V Y`.RPyRh:ST`helloworld`UCh@<0.h@>0R0o+0"

que evolui da seguinte maneira:

V Y"`V Y`.RPyRh:ST`helloworld`UCh@<1.h@>1R1o+1"
V Y"`V Y`.RPyRh:ST`Helloworld`UCh@<2.h@>2R2o+2"
V Y"`V Y`.RPyRh:ST`HElloworld`UCh@<3.h@>3R3o+3"
V Y"`V Y`.RPyRh:ST`HELloworld`UCh@<4.h@>4R4o+4"
V Y"`V Y`.RPyRh:ST`HELLoworld`UCh@<5.h@>5R5o+5"
V Y"`V Y`.RPyRh:ST`HELLOworld`UCh@<6.h@>6R6o+6"
V Y"`V Y`.RPyRh:ST`HELLOWorld`UCh@<7.h@>7R7o+7"
V Y"`V Y`.RPyRh:ST`HELLOWOrld`UCh@<8.h@>8R8o+8"
V Y"`V Y`.RPyRh:ST`HELLOWORld`UCh@<9.h@>9R9o+9"
V Y"`V Y`.RPyRh:ST`HELLOWORLd`UCh@<10.h@>10R10o+10"
V Y"`V Y`.RPyRh:ST`HELLOWORLD`UCh@<11.h@>11R11o+11"
V Y"`V Y`.RPyRh:ST`HELLOWORLD`UCh@<12.h@>12R12o+12"

com a última saída inválida porque HELLOWORLDnão foi alterada. (Corrija-me se eu não tiver feito o bônus corretamente.)

Graças a esta pergunta, acabei de descobrir uma nova técnica de quine! A base quine é V Y"`V Y`.RPy":

  Y"         "  Yank that string into the variable y
V               Evaluate it as a Pip expression:
          RPy   y wrapped in double quotes (repr)
    `V Y`.      Prepend that regex pattern
                When this is evaluated, it returns a pattern object, which is
                auto-printed--conveniently, without the `` delimiters

Nosso código extra modifica a string yantes de reproduzi-la da seguinte maneira:

  • Substitua o mundo hellow atual por um em que os 0caracteres mais à esquerda estejam em maiúsculas;
  • Substitua todas as ocorrências de 0por o+0(onde oé uma variável interna que é igual a 1).

A próxima vez em que o número no código for em 1vez de 0, e assim por diante.

DLosc
fonte
1

Javascript, 52 bytes

function(){return '("hello world").replace(" ","")'}

Teste

=>

<='("hello world").replace(" ","")'

=> eval('("hello world").replace(" ","")')

<= 'helloworld'

Fuzzyzilla
fonte
1

///, 23 bytes - 10% = 20,7?

/,//\/ \/\/hello, world

Experimente online!

Primeira saída:

/ //hello world

Segunda saída:

helloworld
Sagitário
fonte
O bônus é para mais de duas iterações, portanto sua pontuação ainda é de 23 bytes
Jo King
1

BBC BASIC, 56 bytes

Eu tive um problema nisso antes de perceber o quão atrasado para o jogo eu estou. Pelo que vale, aqui está minha versão e minha primeira tentativa no código de golfe StackExchange.

Aqui, V. ecoa os caracteres fornecidos pelos códigos ASCII na seguinte lista separada por vírgulas e P. é uma abreviação de impressão. Utilizo o caractere backspace para substituir a string 'helloworld' existente.

Código de entrada:

V.80,46,34:P."helloworld";:V.8,68,34,59:P.":V.8,8,76,68"

Primeira saída:

P."helloworlD";:V.8,8,76,68

Segunda saída:

helloworLD

Pode ser testado online em https://bbc.godbolt.org/

Andrew Paul
fonte
Definitivamente, nunca usei o BBC BASIC, mas como isso pode ser testado? Se eu colar isso no emulador vinculado, a última linha parecerá "Mistake" para mim.
meu pronome é monicareinstate 12/12
Vou editar minha resposta para maior clareza. É apenas a primeira linha que precisa ser colada. A segunda linha gerada pode ser copiada e executada no emulador usando o cursor do PC e as teclas 'final'. A terceira linha pode ser inválida de acordo com as regras.
Andrew Paul