19

Cree un programa que genere una cadena hello world ("Hello world", "Hello, World", etc.) y el código fuente. La salida se escribe en stdout o equivalente. La cadena Hello World está incrustada en el código fuente.

Por ejemplo, la salida para podría ser

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

Cuando la salida se compila o se vuelve a interpretar, debe crear una salida similar, pero la cadena hello world debe tener una puntuación o mayúscula diferente. Por ejemplo, el ejemplo anterior podría crear el siguiente resultado

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

Cada "(algún código fuente aquí)" en estos ejemplos puede cambiar después de cada ejecución, o puede ser el mismo.

Su salida debe contener una cadena válida de hello world exactamente una vez. Puede contener cualquier cantidad de cadenas inválidas de hello world. El código fuente puede contener cualquier cantidad de comentarios, y la cadena hello world puede estar incrustada en los comentarios. El primer programa puede tener cero o una cadena válida de hello world, pero no más.

La siguiente puntuación es válida:

hello, world
hello world
helloworld

Cualquier capitalización es aceptable. Por ejemplo, estas son cadenas válidas de hello world:

Hello, world
hellO WORld
HELLoworlD

Estas cadenas no son válidas:

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

Su programa falla tan pronto como se cumpla una de las siguientes condiciones:

Produce una cadena hello world que se ha generado durante alguna ejecución anterior,
la salida ya no es código fuente válido en el mismo idioma, o
la salida no contiene exactamente una cadena válida de hello world.

Su programa no es válido para este concurso a menos que al menos dos primeras ejecuciones sean exitosas. Esto significa que la tercera salida puede ser inválida. La salida de su programa puede no ser aleatoria. La primera ejecución siempre debe crear la misma segunda salida, la segunda ejecución siempre debe crear la misma tercera salida, etc.

La puntuación se calcula como la cantidad de bytes en el código fuente del programa inicial. La puntuación más baja gana.

Se aplican los siguientes bonos (hasta -60%):

-5% * (N - 2), donde N es el índice de la ejecución después de la cual su programa produce resultados no válidos. Este bono se limita a -50%. Si su programa tiene éxito 12 veces o más, obtendrá el bono máximo.
-10%, si sus salidas (incluido el primer código fuente) incluyen las tres alternativas de puntuación válidas.

Su envío debe incluir el primer código fuente, y también debe contener los resultados de las ejecuciones exitosas. Si su programa tiene éxito más de 12 veces, agregue la salida para 12 ejecuciones.

Ejemplo

La siguiente línea es el primer código fuente. Cuando lo ejecutamos, es la primera ejecución.

hello world(some source code here)

La siguiente línea es la salida del primer código de código fuente. Es la primera salida.

hello, world(some source code here)

La siguiente línea es la salida de la segunda ejecución. Es la segunda salida.

helloworld(some source code here)

Cuando ejecutamos la primera salida, este programa se convirtió en elegible para el bono de -10%. Eso significa que tenemos dos salidas y un código original, que tienen diferentes puntuaciones. Además, debido a que la segunda salida fue válida, este programa es elegible para este concurso.

La siguiente línea es la salida de la tercera ejecución. Es la tercera salida.

Helloworld(some source code here)

La siguiente línea es la salida de la cuarta ejecución. Es la cuarta salida.

hellworld(some source code here)

Esta salida fue inválida. El índice de la última ejecución válida fue 4. Este programa es elegible para un bono de -5% * (4 - 2) y un bono de -10% de la puntuación. Esto hace un total de -20%. La longitud del primer código fuente ("hola mundo (aquí está el código fuente)") fue de 34 bytes, por lo que el puntaje final es 27.2.

1

¿Se aplican las reglas habituales de quine o se le permite al programa leer su propio archivo fuente?

Martin Ender

1

Se aplican las reglas habituales de quine.

¿Cuenta el código original para las bonificaciones? Del mismo modo, ¿el código original tiene que contener un código válido hello world?

Martin Ender

1

El código original cuenta para las bonificaciones. El código original no tiene que contener un hola mundo válido.

¿Estás seguro del último cambio de regla? Junto con "El primer programa no tiene que contener una cadena válida de hello world, o puede contener varias cadenas válidas de hello world". Podría agregar las variaciones que faltan como un comentario al código fuente original para obtener la bonificación (probablemente no valga la pena en la mayoría de los casos, pero aún parece una laguna)

Fabian Schmengler

8

Pyth, 17 bytes

Una solución diferente de Pyth:

"r\"helloworld\"1

Salida:

r"helloworld"1

Segunda salida:

HELLOWORLD

Fabian Schmengler
fuente

Actualmente, las reglas establecen "Su programa falla tan pronto como se cumpla una de las siguientes condiciones: la salida ya no es código fuente válido en el mismo idioma" y "Su programa no es válido para este concurso a menos que al menos tres primeras ejecuciones sean exitosas". . ¿HELLOWORLD es un programa válido en Pyth? En caso afirmativo, publique también su salida o explique lo que hace. Si no, creo que este programa no es válido.

Además, quiero aclarar que este programa no rompe las reglas sobre la repetición de la misma cadena. Esta solución repite "helloworld" que estaba en el primer código fuente. Las reglas solo prohíben repetir una cadena que ha estado en las salidas anteriores. Si la segunda salida es un programa Pyth válido, entonces esta solución es perfectamente válida.

Al momento de responder, las reglas eran "Su programa no es válido para este concurso a menos que al menos dos primeras ejecuciones sean exitosas"

Fabian Schmengler,

Oh tienes razon No estoy seguro de por qué he cambiado eso porque mi ejemplo en la primera publicación dice que dos salidas = solución válida. Corregiré las reglas para reflejar esto. Entonces su solución es válida. También es la mejor solución válida en este 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}]) &

Decidí optimizar el recuento de cadenas aquí. Esto se ejecuta para 1024 programas sin parar, pasando por cada combinación de letras mayúsculas y minúsculas. La ejecución se puede ver aquí .

LegionMammal978
fuente

1

Es una pena que no pueda jugar golf en espacios en blanco y usar la notación de prefijo e infijo en las matinas de Mathematica, ¿no es así? ;) (Esto podría ser lo suficientemente largo como para que funcione el enfoque de quine opuesto, donde almacena el código en una cadena sy lo evalúa ToExpression).

Martin Ender

6

Vitsy, 33-33 * .05 * (11-2) = 18.15 Bytes

Je! ¡Supera eso! Probablemente lo hagas. :C

Primera salida:

'0DV \ {25 ^ -V \}} 1+ {rd3 * Z; helloworld
'Comience a capturar como una cadena
 0DV Empuje 0 a la pila y configúrelo como la variable final.
    \ Repita el siguiente elemento varias veces. (1, 2, 3 ... en las salidas).
     {Gire la pila hacia la izquierda.
      25 ^ Empuje 32 a la pila.
         - Reste el elemento superior por él, esto hará minúsculas mayúsculas.
          V \ Hacer el siguiente elemento veces variables finales.
            } Gire la pila hacia la derecha.
             } Y otra vez...
              1+ Añadir uno. Esto hace que el 0 en este código sea 1, luego 2 ...
                r Invierta la pila.
                 d3 * Obtener el personaje '
                    Z Muestra todos los artículos en la pila.
                     ; Fin de la ejecución.
                      cadena de helloworld para manipular.

Segunda salida:

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

Tercera salida:

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

Cuarta salida:

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

Quinta salida:

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

Sexta salida:

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

Séptimo resultado:

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

Octava salida:

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

Novena salida:

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

Décima salida:

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

Undécimo resultado:

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

Esta es la última salida, ya que causará un error.

Addison Crump
fuente

1

o_o Simplex luchó hasta 21. Sin embargo, ¡trabajaré para vencer a 18.15!

Conor O'Brien

@ CᴏɴᴏʀO'Bʀɪᴇɴ Vitsy fue construido prácticamente para editar su propio código fuente y hacer una manipulación básica de cadenas. XD Creo que esto se puede reducir aún más.

Addison Crump

Pensé que simplex sería increíble, ya que tiene una función de programa externa, pero noooo eso contaría como un solo programa. le sigh

Conor O'Brien

+1 por vencer (o casi vencer) los lenguajes de golf "clásicos"

ev3commander

@ ev3commander Los hubiera derrotado si el bono de iteración fuera mayor. : c

Addison Crump

5

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

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

Esto inicia la siguiente cadena:

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

donde el último ya no contiene un "Hola Mundo" válido.

Pruébalo aquí.

Explicación

{`     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.  
}_~

Tenga en cuenta que el programa inicial no contiene un "Hello, World" válido, pero eso nos permite ir una iteración más allá.

Martin Ender
fuente

¿Esto califica para el bono de -10%? Las salidas solo contienen dos de las tres formas de puntuación válidas.

Mike Bufardeci

@MikeBufardeci Oh, buena pregunta ... asumí que el código original era parte de él.

Martin Ender

1

Aclaré las reglas para que el código original se cuente para la bonificación. Aunque debo admitir que no me di cuenta de que es tan fácil obtener -10%.

5

CJam 69 60 - 50% = 30

Todavía soy principiante, por favor dime cómo jugar golf en CJam.

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

Es tedioso imprimir cada iteración, ya que será válido por 99 iteraciones.

Funciona enumerando la capitalización de hola palabra. El tedio es dividir las cadenas en partes, ya que tanto "hello world" como el contador deben actualizarse.

Explicación

{`_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: No leo la respuesta de Mathematica, lo siento, creo que fue original

Con el reordenamiento y las diferentes mayúsculas, pierdo 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

Esta vez también enumera la puntuación.

{`: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
fuente

Tiene un idioma diferente y una respuesta más corta, por lo que no tiene nada de malo usar el mismo enfoque que la respuesta de Mathematica.

Tenga en cuenta que estamos buscando la puntuación más baja, no el póster más rápido o el algoritmo más novedoso.

@ Ville-ValtteriTiittanen Aún así, la respuesta de Martin Büttner sigue siendo inferior a la mía

Akangka

@ChristianIrwan Yours es interesante porque produce diferentes capitalizaciones (y estoy seguro de que es posible acercarse a la mía o tal vez incluso vencerla, pero no tengo tiempo para mirarla en detalle ahora).

Martin Ender

4

GolfScript, 35 bytes - 50% = 17.5

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

Decidí exagerar el número de ejecuciones antes de repetir. Este programa, con su salida realimentada en el intérprete de GolfScript, producirá 890 cadenas Hello World distintas antes de la primera repetición. Como breve muestra, aquí están las primeras 15 iteraciones:

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&\}%`@".~"}.~

La forma en que funciona es iterando a través de la cadena, volteando las mayúsculas de cada letra (haciendo XOR con su código ASCII con 32) si la letra anterior (después de posiblemente cambiar su mayúscula y minúscula) está en minúscula. La primera letra cambiará de mayúsculas y minúsculas si el número al comienzo del programa es 32 en lugar de 0, y el número de salida para la siguiente iteración será 32 siempre que la última letra de la cadena esté en minúscula, causando cambios al final de la cadena para propagarse al principio en la próxima iteración.

(Este proceso de retroalimentación en particular se obtuvo de una manera totalmente ad hoc . Originalmente quería ejecutar un contador binario simple usando mayúsculas y minúsculas como bits, pero eso tomó demasiados bytes para implementar, así que comencé a ajustarlo para encontrar algo más corto eso todavía produciría una duración de ciclo bastante alta. Dado que el máximo teórico, usando solo mayúsculas y minúsculas, es 2 ¹⁰ = 1024, obtener un ciclo de 890 iteraciones es bastante bueno).

Por desgracia, la bonificación por iteraciones adicionales tiene un límite de −50%; sin el límite, este programa tendría una enorme bonificación de −4440%. ;-)

Ilmari Karonen
fuente

3

Pyth, 18 bytes

"-\"hello world\"d

Que devuelve:

-"hello world"d

Que a su vez imprime:

helloworld

Tenía una solución que hacía las tres ortografías, pero es más larga incluso con la bonificación.

Mike Bufardeci
fuente

Tenga en cuenta que esta respuesta fue inválida brevemente hasta que las reglas se volvieron a requerir dos iteraciones en lugar de tres. Sin embargo, ahora es válido nuevamente.

DLosc

3

Simplex , 21 bytes.

Esto es lo que era Simplex nació . Definitivamente puedo ir más lejos con esto.

(Sigo presionando Ctrl + Enter, lo siento, lo culpo en el teclado de la tableta)

Intento 3, v.0.8 +, 31-5% = 29.45 bytes (me parece que UTF-8)

Ese gesto en el medio se expresa. Algo así como. ¿Por qué hice esto otra vez? ._.

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

2da salida:

"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

3ra salida:

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

Salida final:

HelloworlD

Intento 2, v.0.8 +, 21 bytes (UTF-8, creo)

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

Salida:

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

Salida final:

helloworld

Intento 1, v.0.7 + 28 26 bytes

No estoy seguro de si esto califica para el primer bono ...

"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

Primera salida:

"HELLOWORLD"g

El programa externo se evalúa al final de la ejecución (lo hace por y; así es como se ve el programa externo:

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

Salida final:

HELLOWORLD

Conor O'Brien
fuente

¿Es este programa elegible para el bono de -50%? Parece que podría ser, pero no publicó ninguna salida.

@ Ville-ValtteriTiittanen Solo se ejecuta dos veces. Estoy trabajando en bonos en este momento.

Conor O'Brien

2

Rubí, 81 - 50% = 40.5

Código original:

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

Productos sucesivos:

_="_=%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)

Creo que esto cuenta como el 50% completo? Podría estar fuera por uno. Además, probablemente haya una solución sin bonificación con mejor puntuación en Ruby.

El código original no contiene "helloworld", pero construye un quine que reemplaza la primera letra mayúscula en su código fuente con la versión en minúscula. Por lo tanto, cada ejecución sucesiva del quine genera una letra minúscula menos.

El truco aquí es usar una cadena de formato para interpolar tanto la cadena en sí, para el quining, como la cadena Hello World, para que solo aparezca una vez.

histocrat
fuente

1

PHP, 297 - 40% = 178.2 bytes

No es realmente competitivo pero fue divertido escribir

<?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;});

Es una variación de esta quine:

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

pero también agrega "helloworld" a la salida y reemplaza 0con 0+1(en la próxima iteración 1con 1+1y así sucesivamente). Utilizandosubstr cualquier salida "helloworld" existente se elimina antes de que se agregue el nuevo "helloworld".

Para obtener una salida diferente, una letra de "helloworld" se escribe con mayúscula (determinada por el número creciente). Este es el código relevante:

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

Un desafío era no usar ningún número excepto aquí y para el reemplazo del número

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

Ahí ya ves que +1se realiza como +(int)true.

Para los argumentos de la subcadena que necesitaba 0, 146:

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

La cadena no vacía "i" se coacciona truey se niega. falsees un argumento entero válido y se trata como 0. ord(I)es el valor ASCII de "I": 73

Salida (primera iteración):

<?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

Salida (segunda iteración):

<?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

Salida (10ª iteración):

Esta es la última salida válida pero ya no es un 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

¡Desplácese hacia la derecha para encontrar las cadenas "Hola mundo"!

Fabian Schmengler
fuente

Acabo de (int)truedarme cuenta de que puedo cambiar a `` !! i` y guardar 12 bytes. Intentaré jugar al golf un poco más tarde

Fabian Schmengler

1

Pip, 48 - 50% = 24

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

que evoluciona de la siguiente manera:

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"

con la última salida no válida porque HELLOWORLDno ha cambiado. (Corrígeme si no he hecho bien la bonificación).

Gracias a esta pregunta, ¡acabo de descubrir una nueva técnica de quine! La base quine es 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

Nuestro código adicional modifica la cadena en y , antes de reproducirla, de la siguiente manera:

Reemplace el mundo hellow actual con uno en el que el extremo izquierdo 0 caracteres estén en mayúsculas;
Reemplace todas las apariciones de 0con o+0(dondeo es una variable integrada que equivale a 1).

La próxima vez alrededor del número en el código es en 1lugar de 0, y así sucesivamente.

DLosc
fuente

1

Javascript, 52 bytes

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

Prueba

=>

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

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

<= 'helloworld'

Fuzzyzilla
fuente

1

///, 23 bytes - 10% = 20.7?

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

Pruébalo en línea!

Primera salida:

/ //hello world

Segunda salida:

helloworld

Sagitario
fuente

La bonificación es por más de dos iteraciones, por lo que su puntaje sigue siendo de 23 bytes

Jo King

1

BBC BASIC, 56 bytes

Tuve una grieta en esto antes de darme cuenta de lo tarde que llegaba al juego. Para lo que vale, aquí está mi versión y mi primer intento en StackExchange code golf.

Aquí, V. repite los caracteres dados por los códigos ASCII en la siguiente lista separada por comas y P. es la abreviatura para imprimir. Hago uso del carácter de retroceso para sobrescribir la cadena existente 'helloworld'.

Codigo de entrada:

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

Primera salida:

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

Segunda salida:

helloworLD

Se puede probar en línea en https://bbc.godbolt.org/

Andrew Paul
fuente

Definitivamente nunca he usado BBC BASIC, pero ¿cómo se puede probar esto? Si pego esto en el emulador vinculado, la última línea parece mostrar "Error" para mí.

mi pronombre es monicareinstate el

Editaré mi respuesta para mayor claridad. Es solo la primera línea que necesita pegarse. La segunda línea generada puede copiarse y ejecutarse en el emulador usando el cursor de la PC y las teclas 'fin'. Se permite que la tercera línea sea inválida de acuerdo con las reglas.

Andrew Paul

"Hola mundo" que crea un programa diferente "Hola mundo"

Ejemplo

Respuestas:

Pyth, 17 bytes

Mathematica, 214 - 50% = 107 bytes

Vitsy, 33-33 * .05 * (11-2) = 18.15 Bytes

Primera salida:

Segunda salida:

Tercera salida:

Cuarta salida:

Quinta salida:

Sexta salida:

Séptimo resultado:

Octava salida:

Novena salida:

Décima salida:

Undécimo resultado:

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

Explicación

CJam 69 60 - 50% = 30

CJam 73 - 60% = 29.2

GolfScript, 35 bytes - 50% = 17.5

Pyth, 18 bytes

Simplex , 21 bytes.

Intento 3, v.0.8 +, 31-5% = 29.45 bytes (me parece que UTF-8)

Intento 2, v.0.8 +, 21 bytes (UTF-8, creo)

Intento 1, v.0.7 + 28 26 bytes

Rubí, 81 - 50% = 40.5

PHP, 297 - 40% = 178.2 bytes

Salida (primera iteración):

Salida (segunda iteración):

Salida (10ª iteración):

Pip, 48 - 50% = 24

Javascript, 52 bytes

Prueba

///, 23 bytes - 10% = 20.7?

BBC BASIC, 56 bytes