"Hello World" dans moins de 20 octets

Question

Nous avons eu un intéressant concours qu'une seule fois, où tout le monde serait d'écrire leur mise en œuvre du programme "hello world". Une exigence qui doit être de moins de 20 octets en forme compilée. le gagnant sera celui dont la version est la plus petite...

Quelle serait votre solution? :)

Plate-forme: 32 bits, x86

Système d'exploitation: DOS, windows, GNU/Linux, *BSD

Langue: Asm, C, ou quoi que ce soit d'autre qui compile en binaire exécutable (pas de scripts bash et trucs ;)

Answer 1

20 octets

        .MODEL  TINY
        .CODE
CODE    SEGMENT BYTE PUBLIC 'CODE'
        ASSUME  CS:CODE,DS:CODE
        ORG     0100H
        DB  'HELLO WORLD$', 0
        INC DH
        MOV AH,9
        INT 21H
        RET

Assembler avec Microsoft Macro Assembler à l'aide de:

ML /AT HELLO.ASM

Taille du fichier: 20 octets

C'est aussi court que ça va arriver et d'être toujours bien comportés programme.

Maintenant, si vous voulez juste plus court et ne se soucient pas de quelques caractères supplémentaires de sortie sur l'écran, vous pouvez le faire de cette façon:

17 octets et il n' sortie BONJOUR tout le MONDE, avant de quitter gentiment dos à DOS.

	.MODEL  TINY
	.CODE
CODE    SEGMENT BYTE PUBLIC 'CODE'
	ASSUME  CS:CODE,DS:CODE
	ORG     0100H
	MOV    AH,9
	INT    21H
	RET
	DB    'HELLO WORLD$'
CODE    ENDS

Answer 2

henk@korhal ~ $ xxd Hello\ World\! 
0000000: 00                                       .
henk@korhal ~ $ ./Hello\ World\! 
bash: ./Hello World!: cannot execute binary file
henk@korhal ~ $

1 octet binaire, affiche " hello world!

Answer 3

J'ai gagné!

1 octet!

ret                  ; C3

Mais! Vous devez d'abord installer ce petit vecteur d'interruption, de sorte que nous sommes une partie du système d'exploitation :) Fonctionne parfaitement sous la NTVDM trop.

Les binaires et le code source ici pour un exemple. D'abord exécuter "hw_hook.com", puis "hello.com".

Le RET sera à la fin de l'invocation de la INT 20h, donc je crochet INT 20h avec mon "Hello World" vecteur d'interruption.

%macro sethook 3
 push es
 push ds
 xor ax, ax
 mov es, ax
 mov ds, ax
 mov di, (%1 * 4)    ; calculate IDT offset
 mov si, di
 cli
 lodsd               ; get the old handler
 mov [cs:%3], eax    ; save the old handler
 mov ax, %2          ; and the offset to the new handler
 rol eax, 16
 push cs
 pop ax
 rol eax, 16
 stosd               ; set the new handler
 sti
 pop ds
 pop es
%endmacro

 bits 16
 org 100h
_start:
 int 12h             ; get total free memory in ax
 dec ax              ; reserve one kilobyte
 push ds
 push 40h
 pop ds
 mov [ds:13h], ax    ; store the new memory size
 pop ds
 ; now relocate
 push cs
 pop ds
 mov si, hook_size 
 shl ax, 6
 mov es, ax
 xor di, di
 mov cx, hook_size
 rep movsb
 ; setup "hello world" hook :)
 sethook 20h, hello_hook, orig_vector
 mov ax, 4c00h
 int 21h

hello_hook:
 pusha
 pushf
 mov ah, 09h
 mov dx, msg
 int 21h
 popf
 popa
 pushf
 call far [cs:orig_vector]
 iret
 msg db "Hello World$"
 orig_vector dd 0
 hook_size equ $ - hello_hook

Answer 4

Voici une de 32 octets à l'aide de la version Linux du système d'appels:

.globl _start
_start:
        movb $4, %al
        xor %ebx, %ebx
        inc %ebx
        movl $hello, %ecx
        xor %edx, %edx
        movb $11, %dl
        int $0x80               ;;; sys_write(1, $hello, 11)
        xor %eax, %eax
        inc %eax
        int $0x80               ;;; sys_exit(something)
hello:
        .ascii "Hello world"

Lorsqu'il est compilé en un minimum de ELF, le fichier complet de l'exécutable est 116 octets:

00000000 7f 45 4c 46 01 01 01 00 00 00 00 00 00 00 00 00 |.ELF............|
00000010 02 00 03 00 01 00 00 00 54 80 04 08 34 00 00 00 |........T...4...|
00000020 00 00 00 00 00 00 00 00 34 00 20 00 01 00 00 00 |........4. .....|
00000030 00 00 00 00 01 00 00 00 00 00 00 00 00 80 04 08 |................|
00000040 00 80 04 08 74 00 00 00 74 00 00 00 05 00 00 00 |....t...t.......|
00000050 00 10 00 00 b0 04 31 db 43 b9 69 80 04 08 31 d2 |......1.C.je...1.|
00000060 b2 0b cd 80 31 c0 40 cd 80 48 65 6c 6c 6f 20 77 |....1.@..Hello w|
00000070 6f 72 6c 64 |ondial|
00000074

Answer 5

Il est très peu probable que la réelle exécutable compilé serait jamais à seulement 20 octets. Vous avez normalement beaucoup d'OS spécifique code de chargement, ELF-têtes sont énormes comme il est.

La seule façon d'obtenir quelque chose en cours d'exécution dans le court laps de un espace pourrait être un "nouveau" format compilé qui était simplement la chaîne de caractères "hello world", qui pourrait être injecté directement dans le parent de l'OS, et en quelque sorte l'OS juste "savaient" que ce fichier devait être imprimé.

Mais alors, vous êtes de plus dans la technicité, parce que vous êtes, par procuration, de l'appel d'un noyau entier pour faire le vrai travail, et que les moyennes entre 2 et 8 MO.

Si vous allez faire quelque chose qui fonctionne sans un OS, alors vous avez routines d'initialisation que vous avez à faire juste pour le faire fonctionner.

Et puis la question évolue, ne "20 octets" inclure ou d'exclure le byte-code dans le bios?

Si vous voulez vraiment le faire, peut-être que vous devriez avoir un matériel dédié à l'architecture, avec un câblé puce rom avec le "20 octets de code programmé électroniquement.

En dehors de ces étranges contraintes techniques, je vous dirais que j'ai mon propre "langage interprété", connu comme le "chat".

"chat" est aussi mon os, et je l'utilise pour créer le fichier source initiale

1) le Codage, et la compilation de mon code binaire:

 cat > helloworld.txt 
 Hello World^D^D

2) l'Exécution de la "compilé" bytecode

 cat helloworld.txt 
 Hello World

voir. merveilleux. Je vais prendre la médaille d'or merci :)

Seulement 11 octets.

La fin de linux truc

$ cd /tmp
$ echo '#!/bin/echo' >> hello
$ chmod u+x hello
$ ./hello world
> ./hello world
$ wc -c ./hello
> 12 ./hello