Sfida:

Il concetto è abbastanza semplice: scrivere un programma completo per ottenere il proprio punteggio di golf in codice!

L'output dovrebbe essere solo il conteggio dei byte del programma e un trailing bytes.

MA ASPETTA ..... c'è una limitazione:

• Il codice sorgente non può includere nessuna delle cifre del conteggio dei byte
• Quindi, se il tuo punteggio è 186 bytes, il programma non può contenere i caratteri 1, 6o8

Esempio di output:

315 bytes
27 Bytes
49 BYTES

Regole aggiuntive:

• Caratteri, spazi e nuove righe non necessari sono vietati nel codice sorgente, tuttavia gli spazi finali e le nuove righe sono perfettamente accettabili nell'output
• Dovrebbe esserci un solo spazio tra il numero e bytesnell'output
• Le lettere non fanno distinzione tra maiuscole e minuscole
• Nessuna autoispezione o lettura del codice sorgente

• le scappatoie standard non sono ammesse

• questo è code-golf , quindi

Vince il codice più corto in byte!

JavaScript, 19 byte

Octal è stato inventato per due scopi:

• impostazione delle autorizzazioni per i file in Linux
• rispondere a questa sfida

alert(023+' bytes')

Provalo online!

Perl 5 , 16 byte

Ci sono molti altri modi per ottenere, 16ma questo è mio

say afpbytes^PPP

Provalo online!

7 , 23 caratteri, 9 byte

54340045141332401057403

Provalo online!

Questa è una sfida abbastanza difficile in una lingua che consiste interamente di cifre, ma l'ho gestita ...

Sono solo 9 byte nella codifica di 7. (A rigor di termini, sono 8⅜ byte (23 × ⅜ - ¼ perché gli ultimi due bit finali 1 possono essere omessi), ma per la prima volta, il requisito di PPCG di arrotondare per eccesso a un numero intero di byte è in realtà un vantaggio perché significa che i bit di trascinamento extra 1 sono necessari e quindi non vietati dalla domanda.) Una discarica esadecimale reversibile:

00000000: b1c0 2530 b6a0 22f8 1f                   ..%0.."..

La sfida principale di scrivere questo programma in 7 era giocare a golf con meno di 10 byte (come scrivere 7 senza usare 0o 1è piuttosto difficile.) Questo usa la stessa struttura del programma standard "Hello world":

5434004514133240105 7 403
5434004514133240105 comandi 0-5 aggiungono valori letterali allo spazio dati
                   7      avvia una nuova sezione di spazio dati
                    403 un altro letterale aggiunto allo spazio dati
                         {implicito: valuta l'ultima sezione come comandi}
                    4     scambia la 1a e la 2a sezione con una sezione vuota tra
                      6    ricostruisci i comandi che creerebbero l'   output della 1a sezione
                       3 (+ alcuni altri effetti che non ci interessano)

In altre parole, iniziamo creando due sezioni dello spazio dati; abbiamo due letterali, ognuno dei quali invia una sequenza di comandi lì. La seconda sezione (sono spinti in stile stack quindi primo push = ultimo pop) è una sequenza di comandi abbastanza arbitraria ma è spinta usando la sequenza di comandi 5434004514133240105(producendo così la sequenza di dati 5434664574733246765; quando parlo di 7 nel testo, normalmente uso un carattere normale per un comando che spinge un valore letterale e grassetto per il valore letterale risultante corrispondente). La prima sezione viene spinta usando la sequenza di comandi 403, producendo 463. Quindi la prima sezione viene copiata nuovamente nel programma (un comportamento implicito di 7).

Il 463è ora composto di comandi (in grassetto) che fanno subito qualcosa, piuttosto che (non in grassetto) comandi che solo letterali push. 4riorganizza le sezioni per ottenere il nostro "string letterale" nella prima sezione. Quindi 0esegue l'operazione per cui 7 è più noto: prendere una sezione dello spazio dati e ricostruire la sequenza di comandi che molto probabilmente l'ha creata. Nel caso in cui la sequenza di comandi originale fosse tutta 0- 5, questo è accurato al 100% (non sorprende, poiché quei comandi trasmettono puramente i dati e quindi lasciano evidenti prove di ciò che hanno fatto), e quindi otteniamo la nostra sequenza originale 5434004514133240105. Alla fine, lo 3stampa.

Quindi la cosa rimanente da guardare qui è la codifica della stringa. Questo ha il suo linguaggio specifico del dominio:

5434004514133240105
5                    change encoding: 6 bits per character
 43                  select character set: digits and common symbols
   40                '9'
     04              space
       51            select character set: uppercase letters
         4133240105  'B' 'Y' 'T' 'E' 'S'

(Non esiste un "set di caratteri selezionato: lettere minuscole" nel set di caratteri "cifre e simboli comuni" - devi prima passare con un set di caratteri diverso - quindi ho dovuto usare maiuscole per giocare a golf così brevemente da inserirle sotto l'effettivo 10 -byte limit.)

Tela , 8 byte

８ bytes＋

Provalo qui!

Una soluzione più interessante di 20 byte:

bytecount.innerText＃

Provalo qui!

brainfuck , 53 BYTES

+[[<+>->->++>----<<<]>-]>-.--.<<<+.<.<.-----.>+++.<-.

Provalo online!

Un'altra presentazione con maiuscole bytes. Trovato con l'aiuto dell'eccellente aiutante BF-crunch di Primo.

PHP, 14 byte

<?=7*2?> bytes

PHP più vecchio di 7.2 , 13 byte

Presuppone le impostazioni predefinite (avvisi E_NOTICE disabilitati) e la versione di PHP precedente alla 7.2.

Deve essere decodificato xxd -r

00000000: 3c3f 3d7e cecc df9d 868b 9a8c 3b         <?=~........;

O se preferisci Base64

PD89fs7M352Gi5qMOw==

Provalo online!

Stax , 5 byte

╗↑╞ô╝

Esegui ed esegui il debug

Disimballato, sembra così. La modalità sorgente compressa rende questo tipo di banale e poco interessante.

5p     print 5 with no line break
`5l@   print the compressed string " bytes"

Se non si desidera utilizzare la modalità sorgente compressa, 6^p`5l@funziona per 7 byte.

R , 16 byte

cat(4*4,"bytes")

Provalo online!

Python 3 , 25 24 18 byte

print(6*3,'bytes')

Provalo online!

05AB1E , 6 byte

₂¤“ÿ¡Ï

Provalo online!

₂      # [26]        | Pushes 26 (many other alternatives).
 ¤     # [2, 6]      | Split out tail.
  “ÿ¡Ï # ['6 bytes'] | ÿ = "Interpolate top of stack.", ¡Ï = "bytes" (compressed)

Alternative per ₂¤comprendono: 5>, ₁¤,3·

Bash, 21 byte

"Leggi il tuo codice sorgente" non è chiaramente il vincitore qui, ma nessun altro ha inviato uno, quindi che diamine.

echo `wc -c<$0` bytes

Provalo online!

Retina , 15 byte

 bytes
*>w`..+

Questo programma conta il numero di sottostringhe con almeno due caratteri nella stringa "byte", quindi stampa questo conteggio e la stringa stessa.

Provalo online!

PHP + HTML, 16 byte

16 bytes

Sì, questo si sta avvicinando abbastanza all'abuso di scappatoia, ma ho sentito che doveva essere pubblicato. E l'uso di PHP significa che questa risposta è tecnicamente scritta in un linguaggio di programmazione completo di Turing. Naturalmente, qualsiasi altro linguaggio di template HTML simile funzionerebbe altrettanto bene.

Demo live (senza PHP):

16 bytes

dc , 14 11 byte

[ bytes]Bnn

Provalo online!

-3 byte di @Cows quack

MATL , 13 byte

'57$f}xiw'4-c

Provalo online!

Questo spinge la stringa '57 $ f} xiw 'e sottrae 4, per ottenere 13 bytes. Questo viene convertito in caratteri usando c.

Ottava , 22 byte

disp([50 50 ' bytes'])

Provalo online!

Ottava , 23 byte

printf('%i bytes',9+14)

Provalo online!

E questo:

disp(['','67$f}xiw'-4])

Provalo online!

Petit Computer BASIC, 11 byte

?9+2,"bytes

L'uso di una virgola in un'istruzione di stampa sposta il cursore sul multiplo successivo della dimensione della scheda corrente. In SmileBASIC, che è 4 per impostazione predefinita, quindi questo produrrebbe 11 bytes(2 spazi) ma PTC BASIC usava invece 3, quindi l'output ha la spaziatura corretta.

APL (Dyalog Unicode) , 12 byte

Programma completo che stampa implicitamente su STDOUT.

'bytes',⍨3×4

Provalo online!

,⍨ Aggiunge la stringa al risultato della moltiplicazione. La visualizzazione predefinita di APL di dati di tipo misto inserisce uno spazio tra un numero e il testo successivo.

Brain-Flak , 100 BYTES

((((((<>))))))(((()[[]]((((()()((((([][]){}){}())[()]))[[][]])()){})()[][]))[()()[]])[]){({}<>)<>}<>

Provalo online!

Emette la bytesparte in maiuscolo. Qualcuno che abbia familiarità con Brain-Flak potrebbe essere davvero confuso con tutto ((<>))all'inizio, ma state tranquilli, sono lì solo per abusare dell'altezza della pila nilad ( []) e nessuna delle 0s che producono sono stampate.

Haskell , 26 byte

main=putStr$"\50\54 bytes"

Provalo online!

29 byte

main=putStr$pred<$>"3:!czuft"

Provalo online!

Spazio bianco , 112 byte

Solo perché nessuno lo ha ancora fatto:

Provalo online!

Stampa "BYTES" in maiuscolo, poiché le lettere maiuscole hanno codici ASCII binari più corti. I comandi nel programma, nella mia notazione inventata, sono:

Push 112
PrintNum
Push 0
Push 0x53
Push 0x45
Push 0x54
Push 0x59
Push 0x42
Push 0x20
Label _
PrintChr
Dup
JumpZ S
Jump _
Label S
End

Java 5 o 6, 44 byte (programma completo)

enum A{A;{System.out.print(0x2C+" bytes");}}

Nessun collegamento TIO, perché Java 5/6 è vecchio .. In Java 5/6 era possibile avere un enum con codice anziché il mainmetodo obbligatorio , rendendolo più breve per le sfide complete del programma.

Anche errori con java.lang.NoSuchMethodError: main\nException in thread "main"STDERR dopo la stampa su STDOUT, che va bene secondo il meta (ma se la sfida non avrebbe consentito ulteriori errori a STDERR, è System.exit(0);possibile aggiungere (e i numeri ottali devono essere aggiornati) per evitare l'errore.

Suggerito da @ OlivierGrégoire (e il suo suggerimento Java pertinente ).

Java 8+, 74 byte (programma completo)

interface M{static void main(String[]a){System.out.print(0112+" bytes");}}

Provalo online.

Java 8+, 16 15 byte (funzione lambda)

v->0xF+" bytes"

-1 byte grazie a @ OliverGégoire .

Provalo online.

FerNANDo , 79 byte

3 3
1
2 2
0 1 3 3 1 2 2 3
0 1 3 3 2 1 0 2
0 1 3 0 0 1 0 1
0 3 3 1 0 0 3 1
1 1
1

Provalo online!

Applescript, 15 byte

Sì, ci vado.

9+6&”bytes”

Forth (gforth) , 14 13 byte

$d . ." bytes

Provalo online!

> <>, 13 byte

#o<" bytes"nd

Provalo online!

Lotto, 32 byte

@@echo %COMSPEC:~-10,-010% bytes

COMSPECè di solito %WINDIR%\system32\cmd.exequindi estraggo la sottostringa da 10 a 8 caratteri dalla fine. Vecchia versione autoreferenziale a 16 byte:

@echo %~z0 bytes

Fortunatamente il conteggio dei byte non era un multiplo di 10.

JavaScript, 16 15 byte

x=>0xf+' bytes'