Il vincitore accettato è isaacg, con la sua risposta ASCII a 7 bit . Tuttavia, la sfida non è ancora finita: questo premio viene assegnato alla risposta più breve. Se, in qualche modo , ottieni tutti i primi caratteri di tutte le altre risposte in 10 byte, vincerai la taglia. Ciò include tutti i caratteri della risposta GolfScript del Round 2 (più quello aggiunto dalla risposta stessa). Questa è l'UNICA volta che ti lascerò andare fuori servizio - se hai delle obiezioni, fammelo sapere nei commenti.

Vorrei dare credito a randomra, che mi ha aiutato con la mia vecchia idea e mi ha dato questa nuova.

Vincitori precedenti

• Round 1: isaacg, con ASCII a 7 bit
  Next bytes: 30 (or 10 if you want that sweet, sweet rep)
  Sai, il gioco del codice è davvero bello. Le persone prendono una sfida e lentamente si riduce! Ma facciamolo in un altro modo. Quindi, ecco la mia sfida:

• Il codice stamperà il primo carattere di tutte le risposte precedenti nell'ordine in cui sono state pubblicate (la prima risposta non stampa nulla)

• Il codice inizia a 100 byte e diminuisce di 5 ogni volta.
• Se due post ottengono la stessa risposta (ovvero, entrambi vengono pubblicati in pochi secondi l'uno dall'altro), il più recente deve aggiungere il carattere del vecchio e diminuire di 5 byte (anche di pochi secondi).
• È possibile utilizzare qualsiasi lingua.
• Il tuo codice non deve produrre errori.
• Il codice deve utilizzare tutti i byte richiesti per il primo passaggio.
• Il codice deve essere stampato su STDOUT.
• I caratteri non stampabili sono OK, ma:
  • Non possono essere il primo personaggio (per il fine di questa domanda)
  • Devi far sapere a tutti dove sono
• Puoi pubblicare più risposte, ma:
  • Devi aspettare 2 risposte prima di pubblicarne un altro (quindi se hai pubblicato i 100 byte, devi aspettare fino a 85 byte.)
• Non puoi:
  • utilizzare più di 10 byte di commenti
  • hanno variabili che non vengono utilizzate per l'intero programma
  • riempire il programma con spazi bianchi
  • hanno nomi di variabili più lunghi di 10 byte (ma è possibile avere più variabili inferiori a 10 byte)
    (la prima risposta di EMBLEM è l'eccezione a queste regole, perché è stata pubblicata prima di queste restrizioni).
• Nessuna scappatoia standard. A meno che tu non voglia prendere tutto il divertimento dalla sfida.
• Quando non vengono inviate più risposte per 3 settimane, vince la risposta che utilizza il minor numero di byte. (In caso di pareggio, vince chi stampa la stringa più lunga.)

Esempio: la terza risposta deve essere un codice lungo 90 byte che genera due caratteri (il primo carattere del codice di 100 byte quindi il primo carattere del codice di 95 byte). La prima risposta non genera nulla (nessuna risposta precedente per ottenere i caratteri da).

ASCII a 7 bit, 15 byte

Aggiornato: non mi sono reso conto che alla fine dovrebbe avvenire l'imbottitura.

Versione corretta, imbottita alla fine:

hexdump (xxd):

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

Stampe (non sono sicuro di quale sia corretto):

�ï8��z{rP�

áï8¨¶7z{rP¶

Vecchia versione, imbottita in modo errato nella parte anteriore:

pá×
T[G½=¹([

La lingua / formato qui è ASCII a 7 bit, in cui ciascun gruppo di 7 bit corrisponde a un carattere ASCII. Viene utilizzato per il trasferimento di dati SMS. Un decoder si trova qui.

Non esiste una sentenza ampiamente accettata sull'ammissibilità delle risposte a domande sull'output fisso che non sono scritte in un linguaggio di programmazione. Vedi questo meta post per maggiori informazioni. (Chiedo scusa, ho letto male quel post in precedenza.)

Elemento, 80 byte

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

Questa è una lingua che ho creato tre anni fa. Puoi trovare un interprete, scritto in Perl, qui . L' `operatore stampa la prima cosa in pila (le lettere). L'altra punteggiatura fa cose, come la concatenazione, ma i risultati non vengono mai stampati.

Clip , 20 byte

[M"ppuppPq([#fwSmdP"

Lisp comune, 65 byte

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

Scratch, 45 byte

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

Conteggio dei byte come da rappresentazione del testo . Vedi meta .

Python 3, 95 byte

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

Haskell, 35 byte

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

Sono passate 24 ore dalla modifica! Facciamolo! : D

Java, Round 2, 100 byte

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

Round 2: Ruby, 75 byte

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

Ho pensato di renderlo un po 'più stimolante iniziando la mia risposta con un preventivo! >: D

Java, 100 byte

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

Mathematica, 75 byte

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

F #, 60 byte

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

Script F #, 40 byte

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

Ha il suo tipo di file ( .fsx), quindi sono abbastanza sicuro che conta come una lingua.

Round 2: /// , 65 byte

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

Pensavo che lo avrei speziato un po 'di più con una barra rovesciata :)

C #, 90 byte

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

Rubino, 70 byte

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

C, 55 byte

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

JavaScript, 50 byte

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

MATLAB, 30 byte

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

Mostra bene come MATLAB si libera con i tipi di dati.

Mathematica, 25 byte

Print["ppuppPq([#fwSmd"];

Round 2: batch, 70 byte

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

La tua citazione è stata inutile. D:>

Modifica: mi è appena venuto in mente che stavo andando per dimensione del file anziché conteggio dei caratteri, non sono sicuro di come contare i byte: P

Modifica 2: aggiunto un commento per riempire i byte. Se controlli il conteggio dei byte su una macchina Windows, fai solo finta che "REM BATCHS" sia solo "REM", immagino. : P

Round 2, Mathematica, 40 byte

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

Yay seconda pagina!

Round 2, > <> , 45 byte

4 caratteri di commenti.

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

La stringa ora contiene entrambe "e ', quindi> <> le risposte non possono più limitarsi a circondarle (è così che ho evitato qualsiasi evasione).

Round 2, Golfscript, 35 byte

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

Nessun byte di scarto. Inizia di nuovo con un preventivo!

Python 3, 85 byte

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

Round 2, C #, 95 byte

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

Round 2, script F #, 55 byte

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

Vedi il mio precedente script F # anwer per il motivo per cui penso che sia un linguaggio valido.

Round 2, R, 50 byte

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

Round 2, Javascript, 60 byte

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

Round 2: Javascript, 90 byte

var p = "p"; alert (p + p + p + "u" + p + p + p.toUpperCase () + "q ([# fwSmd" + p.toUpperCase () + "[" + p + p + " n "); // p