El ganador aceptado es Isaac, con su respuesta ASCII de 7 bits . Sin embargo, el desafío aún no ha terminado: esta recompensa se otorga a la respuesta más corta. Si, de alguna manera , obtienes todos los primeros caracteres de todas las otras respuestas en 10 bytes, ganarás la recompensa. Esto incluye todos los caracteres de la respuesta GolfScript de la Ronda 2 (más el agregado por esa respuesta). Esta es la ÚNICA vez que te dejaré fuera de servicio; si tienes alguna objeción a esto, házmelo saber en los comentarios.

Me gustaría dar crédito a randomra, que me ayudó con mi vieja idea y me dio esta nueva.

Ganadores anteriores

• Ronda 1: isaacg, con ASCII de 7 bits
  Next bytes: 30 (or 10 if you want that sweet, sweet rep)
  Ya sabes, el golf de código es realmente genial. ¡La gente toma un desafío, y lentamente se hace más pequeño! Pero hagamos esto de otra manera. Entonces, aquí está mi desafío:

• El código imprimirá el primer carácter de todas las respuestas anteriores en el orden en que se publicaron (la primera respuesta no imprime nada)

• El código comienza en 100 bytes y disminuye en 5 cada vez.
• Si dos publicaciones tienen la misma respuesta (es decir, ambas se publicaron dentro de unos pocos segundos una de la otra), la nueva debe agregar el carácter anterior y disminuir en 5 bytes (incluso por unos segundos).
• Se puede usar cualquier idioma.
• Su código no debe producir ningún error.
• Su código debe usar todos los bytes necesarios para el primer paso.
• Su código debe imprimirse en STDOUT.
• Los caracteres no imprimibles están bien, pero:
  • No pueden ser el primer personaje (por el bien de esta pregunta)
  • Debes hacer saber a todos dónde están
• Puede publicar múltiples respuestas, pero:
  • Debe esperar 2 respuestas antes de publicar otra (por lo tanto, si publicó los 100 bytes, tendrá que esperar hasta 85 bytes).
• No puedes:
  • usa más de 10 bytes de comentarios
  • tener variables que no se utilizan para todo el programa
  • llenar el programa con espacios en blanco
  • tener nombres de variables de más de 10 bytes (pero puede tener múltiples variables de menos de 10 bytes)
    (la primera respuesta de EMBLEM es la excepción a estas reglas, porque se publicó antes de estas restricciones).
• No hay lagunas estándar. A menos que quieras sacar toda la diversión del desafío.
• Cuando no se envían más respuestas durante 3 semanas, gana la respuesta que utiliza la menor cantidad de bytes. (En caso de empate, gana el que imprime la cadena más larga).

Ejemplo: La tercera respuesta tiene que ser un código de 90 bytes de longitud con dos caracteres (el primer carácter del código de 100 bytes y el primer carácter del código de 95 bytes). La primera respuesta no genera nada (no hay respuestas anteriores para obtener caracteres).

ASCII de 7 bits, 15 bytes

Actualizado: no me di cuenta de que el relleno debería ocurrir al final.

Versión correcta, acolchada al final:

hexdump (xxd):

0000000: e1c3 af0e 1438 a8b6 8f37 7a7b 7250 b6    .....8...7z{rP.

Impresiones (no estoy seguro de cuál es la correcta):

�ï8��z{rP�

áï8¨¶7z{rP¶

Versión anterior, incorrectamente acolchada en la parte delantera:

pá×
T[G½=¹([

El idioma / formato aquí es ascii de 7 bits, donde cada grupo de 7 bits corresponde a un carácter ASCII. Se utiliza para transferir datos de SMS. Un decodificador se encuentra aquí.

No existe una decisión ampliamente aceptada sobre si se permiten respuestas a preguntas de salida fija que no están escritas en un lenguaje de programación. Vea esta meta publicación para más información. (Pido disculpas, leí mal esa publicación antes).

Elemento, 80 bytes.

programs do many fun things, like print the letters p`, p`, u`, and p` in a row.

Este es un lenguaje que creé hace más de tres años. Puede encontrar un intérprete, escrito en Perl, aquí . El `operador imprime la parte superior de la pila (las letras). La otra puntuación hace cosas, como la concatenación, pero los resultados nunca se imprimen.

Clip , 20 bytes

[M"ppuppPq([#fwSmdP"

Lisp común, 65 bytes

(print(map 'string #' code-char #(112 112 117 112 #x70 80 #x71)))

Scratch, 45 bytes

when green flag clicked
show
say[ppuppPq([#f]

Recuento de bytes según la representación del texto . Ver meta .

Python 3, 95 bytes

pre='public class f{public static void main(String[] a){System.out.print("");}}'
print(pre[0])

Haskell, 35 bytes

main = putStrLn "\&ppuppPq([#fwS\&"

¡Han pasado 24 horas desde la edición! ¡Hagámoslo! :RE

Java, ronda 2, 100 bytes

public class Bytes{public static void main(String[] args){System.out.print("ppuppPq([#fwSmdP[p");}}

Ronda 2: Ruby, 75 bytes

"ppuppPq([#fwSmdP[ppnvos".chars.each do|character|;print character;end#4444

¡Pensé que sería un poco más difícil comenzar mi respuesta con una cita! >: D

Java, 100 bytes

public class f{public static void main(String[] a){System.out.print("");}}//createdbyEMBLEMasdfghjkl

Mathematica, 75 bytes

Print[StringJoin[First/@Characters/@{"publ","pre=","usin","p1 =","prog"}]];

F #, 60 bytes

[<EntryPoint>]let main arg=System.Console.Write "ppuppPq(";0

F # script, 40 bytes

System.Console.Write "\u0070puppPq([#fw"

Tiene su propio tipo de archivo ( .fsx), así que estoy bastante seguro de que cuenta como un idioma.

Ronda 2: /// , 65 bytes

\p/CodeGolfIsAwesome!/puppPq/CodeGolfIsAwesome!([#fwSmdP[ppnvos"R

Pensé en darle un poco más de sabor con una barra invertida :)

C #, 90 bytes

using System;namespace IAmAwesome{class Program{static void Main(){Console.Write("pp");}}}

Ruby, 70 bytes

q = ["publ", "pre", "usi", "p1 ", "pro", "Pri"]
q.each{|s| print s[0]}

C, 55 bytes

#include<stdio.h>
int main(){return puts("ppuppPq([");}

JavaScript, 50 bytes

function foo() {console.log("ppuppPq([#");}
foo();

MATLAB, 30 bytes

disp([112 112 'uppPq([#fwSm'])

Muy bien muestra cuán flexible es MATLAB con los tipos de datos.

Mathematica, 25 bytes

Print["ppuppPq([#fwSmd"];

Ronda 2: lote, 70 bytes

REM BATCHS
GOTO B
:C
ECHO ppuppPq([#fwSmdP[ppnvos"
GOTO A
:B
GOTO C
:A

Tu cita fue inútil. D:>

Editar: se me ocurrió que iba por tamaño de archivo en lugar de recuento de caracteres, no estoy seguro de cómo se deben contar los bytes: P

Edición 2: se agregó un comentario para completar los bytes. Si verifica el recuento de bytes en una máquina con Windows, solo suponga que "REM BATCHS" es solo "REM", supongo. :PAG

Ronda 2, Mathematica, 40 bytes

Print@"ppuppPq([#fwSmdP[ppnvos\"R\\v(c'"

Yay segunda página!

Ronda 2, > <> , 45 bytes

4 caracteres de comentarios.

'c(v\R"sovnpp[PdmSwf#[(qPppupp'01.uwyz
ol?!;

La cadena ahora contiene ambas "y ', por lo tanto , las respuestas> <> ya no pueden rodearla más (así es como evité cualquier escape).

Ronda 2, Golfscript, 35 bytes

"ppuppPq([#fwSmdP[ppnvos\"R\\v(c'P"

No hay desperdicio de bytes. Comienza con una cita de nuevo!

Python 3, 85 bytes

p1 = 'publ'
p2 = 'pre'
p3 = 'usi'
def cprint():
  print(p1[0], p2[0], p3[0])
cprint()

Ronda 2, C #, 95 bytes

namespace Cool{class Program{static void Main(){System.Console.Write("ppuppPq([#fwSmdP[pp");}}}

Ronda 2, secuencia de comandos F #, 55 bytes

(**)System.Console.Write(@"uppPq([#fwSmdP[ppnvos""R\v")

Vea mi respuesta anterior de script F # para saber por qué creo que es un lenguaje válido.

Ronda 2, R, 50 bytes

cat('ppuppPq([#fwSmdP[ppnvos\"R\\v(',file=stdout())

Ronda 2, Javascript, 60 bytes

var _p = "p"; alerta (_p.repeat (2) + "uppPq ([# fwSmdP [ppnvos \" R \\ ");

Ronda 2: Javascript, 90 bytes

var p = "p"; alerta (p + p + p + "u" + p + p + p.toUpperCase () + "q ([# fwSmd" + p.toUpperCase () + "[" + p + p + " notario público