Créez le programme le plus court possible qui affiche le texte "Hello World".

Pour être considéré comme un programme obscurci, il doit satisfaire à au moins deux des exigences suivantes:

• Ne contient pas les caractères: h, l, wetd dans tous les cas
• Ne contient pas les caractères: e, o, r, 0et1 dans tous les cas
• Ne contient pas les caractères: 2ou7

Entrée:
aucune

Sortie:
Hello World

GolfScript, 17 caractères

'· Š ““ ?? ߨ ???? “›' {~}%

Lorsque vous testez cette soumission, veuillez enregistrer le fichier en tant que fichier binaire, pas UTF-8. Vous ne parvenez pas à recréer le fichier? Voici l'hexdump de celui-ci:

00000000  27 b7 9a 93 93 90 df a8  90 8d 93 9b 27 7b 7e 7d  |'...........'{~}|
00000010  25                                                |%|

Perl

Puisque la réponse évidente utilise un décalage quelconque, je me sens obligé de publier quelque chose en utilisant Acme :: EyeDrops , mais avec la puissance supplémentaire que je pensais, la mienne devrait être un peu plus amusante.

                            ''=~('('."\?".
                        '{'.('`'|'%').('['^'-'
                    ).('`'|'!').  ("\`"|       ','
                 ).'"'.('['^'.').   (((           '['
              ))^'(').('`'|('%')).(                  '{'
            ^'[').('{'^'/').('`'|')')                  .+(
          '`'|'-').('`'|'%').':'.':'.(                   '`'
         ^'(').('`'|')').('{'^')').(                      '`'
       |((  '%'))).('['^'(').'\\'.'"'                       .+(
      '['   ^'.').('['^'(').("\`"|                           ','
     ).(    '`'|'%').('`'|"\%").(                             '['
    ^((      '+'))).'\\'.'"'.';'.                              (((
   (((        '\\')))))).('$').                                 '|'
   .((         '+')).'+'.(';').                                 (((
  (((           '\\'))))      )                                  ).+
  '$'            .'\\'.                                          '"'
 .((               '=')    ). "'".                                "'"
 .((                (';'))).       '\\'                           .((
'@'                   )).('`'|                                     '#'
).+                        '='                                     .+(
'`'                          |+    "\-").(                         '`'
|((                            '!'))).("\["^                       '+'
).+                              '\\'.'{'."\[".                    (((
(((                              '\\'))))))."\$".                  '_'
.((                             ',')).'\\'.'$'.('`'|               '*'
).+                             ','.('^'^('`'|('+'))).(            '^'
^+(                              '`'|'.')).'+'.('^'^('`'           |((
'+'                               )))).'*'.'\\'.('$').(            '`'
 |((                               '*'))).'+'.'+'.']'.            (((
 (((                                '\\'))))))."\}".(             '['
  ^((                                '('))).('['^'+')            .+(
  '`'                                |',').('`'|')')             .+(
   '['                                ^'/').('/').              '/'
   .((                                ',')).'\\'.               '"'
    .+(                               '`'^'(').                (((
     '`'                              ))|'%')                 .+(
      '`'                             |',').                 (((
       '`'                           ))|','                 ).(
         '`'                         |'/')                .+(
          '{'                        ^'['                ).(
            '{'                      ^((               ','
              )))                     .(  (          '`'
                 )|+                   ((         '/'
                    )))                        .+(
                        '['                ^((
                            ')'))).(('`')|

                            ',').('`'|'$')
                        .((        '\\')).'"'.
                    ';'       .  ('['^',').(('`')|
                 '('         ). ('`'|')').('`'|',').(
              '`'              |'%').'('.('^'^('`'|'/'))
            .((             ')')).'\\'.'{'.('`'|'-').('['^
          '"'             ).((   (  '\\'))).'$'.('`'|('*')).
         ';'             .+(      ( ( '`'))|'-').('['^('"')).
       '\\'              .+            '@'.('['^'(').'='.("\`"|
      '-').             ('`'|'!'           ).('['^'+').'\\'.'{'.
     "'".(             '{'^"\[").   ((     "'")).'\\'.'}'.('(').(
    '^'^(             '`'|'.')).'.'.'.'.('^'^('`'|'+')).('^'^('`'|
   '.'))            .')'.';'.('`'|'&').('`'|'/').('['^')').'('.'\\'
   .'@'            .('`'|'#').')'.'\\'.'{'.'\\'."\$".(   '['^"\(").
  '['              .'\\'.'$'.'_'.'-'.'>'.'['.('^'^('`'     |',') ).+
  ']'             .']'.'='.'\\'.'$'.'_'.'-'.'>'."\[".(      '^'^ (((
 '`'              ))|'.')).']'.('`'|')').('`'|('&')).        (((  (((
 (((             '\\'))))))))).'$'.'_'.'-'.'>'.'['.           +(  '^'
^+(              '`'|',')).']'.'<'.'='.('^'^('`'|         (    (   '+'
)))               ).('^'^('`'|'.')).';'.'\\'.'$'.'_'.     (    (   '-'
)).                '>'.'['.('^'^('`'|'/')).']'."\>".       (       (((
(((                  '\\')   )))))).'$'.'_'.'-'.'>'                .((
'['                           )).('^'^('`'|(','))).                ']'
.((                           '?')).'\\'.'$'.('`'|                 '*'
).((                          '+')).'+'.':'.'\\'.                  '$'
.('_').                        '-'.'>'.'['.('^'^                   (((
'`'))|','                       )).']'.'-'."\-".                   (((
'\\'))).+                       '}'.('['^'+').(                   '['^
 "\)").(                        '`'|')').("\`"|              (   '.')
 ).('['^                        '/').'\\'."\"".                   (((
  '\\'))                        ).'\\'.('['^')'    )             .((
  '\\')).                      '@'.('['^"\(").   ((              (((
   '\\'))                       ))).'"'.';'.(   '['        ^    '.'
   ).('['                        ^'(').('`'|    ((        (     ','
    )))).                         ('`'|'%')     .              (((
     '`')                         )|'%').(                    '['
      ^((                          '+')))                    .((
       '('                         )).                      (((
         '^'                                          )   )^(
          '`'                                         |  '/'
            )).                                       ('`'
              |((                                    '%'
                 )))                              .+(
                    '^'                        ^+(
                        '`'                |((
                            '+')))).(')').

                            ';'.('`'|',').
                        ('`'|'!').('['^    '('
                    ).('['^'/').(('{')^        '['
                 ).('`'|')').("\`"|    (          '&'
              )).'\\'.'$'.('`'|"\*").                '='
            .'='.'\\'.'@'.('`'|"\#").                  (((
          '\\'))).'}'.('['^'+').('['^  (                 ')'
         )).('`'|')').('`'|'.').('['^   (                 '/'
       )).'\\'.'"'.'\\'.'\\'.('`'      |+                   '.'
      ).'\\'.'"'.('!'^'+').'"'.'}'.   ')'                    );(
     $:)='.'^'~';$~='@'|'(';$^=')'^                           '['
    ;$/='`'|'.';$,='('^'}';$\="\`"|                            '!'
   ;$:=')'^'}';$~='*'|'`';$^=('+')^                             '_'
   ;($/)    ='&'|'@';$,='['&'~';$\                              =((
  "\,"))^    '|';$:  ='.'^'~'; $~                                =((
  '@'))|     "\(";    $^=')'^                                    '['
 ;($/)=      '`'|       '.';$,                                    =((
 '(')        )^+         '}';$\                                   =((
'`')          )|          "\!";      (           (                 $:)
)=')'         ^+        (   (         (                   (        '}'
))));          (           (          (                            $~)
))=(                    (   (    (        (                        '*'
))))                     )   |  ((      (                          '`'
)))                      ;     $^=         (                       '+'
)^+                       ((    ((  ((     '_'                     )))
)))                                          ;($/)                 =((
'&'                          ) )               |'@';               $,=
'['                                                                &((
 '~'                                      ))   ;                  $\=
 ','                                  ^"\|";  $:                  =((
  '.'                               ))^"\~"; $~=                 '@'
  |((                              '('));$^=')'^       (         '['
   );(                          $/)='`'|"\.";$,=    (           '('
   )^+                         '}';$\='`'|'!';$:                =((
    ')'                        ))^'}';$~='*'|'`'               ;$^
     =((                       '+'))^'_';$/='&'               |((
      '@'                      ));$,   =('[')&               '~'
       ;$\                              =','^               '|'
         ;$:                              =(      ((      '.'
          )))                                   ^+       '~'
            ;$~                               =(       '@'
              )|+                                    '('
                 ;$^                              =((
                    ')'                        ))^
                        '['                ;$/
                            ='`'|('.');#;#

Caveat

Depuis Perl version 5.18, le mécanisme permettant à ce code de s'exécuter est devenu si puissant qu'il a été désactivé par défaut pour éviter toute utilisation abusive. Par conséquent, sur les versions 5.18+, vous pouvez ajouter use re 'eval';en haut du script ou, si le script est nommé, world.plvous pouvez l'exécuter comme perl -Mre=eval world.pl. Il est regrettable que ces personnages disgracieux doivent être ajoutés, mais c'est la vie. (Remarque: je tiens à souligner que l'activation de cette fonctionnalité n'utilise pas une bibliothèque ou un addon, le code affiché est un code Perl valide, le mécanisme n'est tout simplement plus activé par défaut).

C # (175 caractères)

Cela a été tout un défi de le faire en C #, car les restrictions empêchent toute utilisation d'un grand nombre de mots clés courants. Il est possible en C # d’utiliser des séquences d'échappement Unicode \ uxxxx dans des identifiants, mais malheureusement pas dans des mots-clés.

Je soupçonne que cette solution ne fonctionne que lorsqu'elle est compilée avec .NET 4.0. Voir l'explication pour pourquoi.

using System;struct a{static int Main(){object[]c={"\u0048e\x6c\x6co "+(C\u0068ar)(86+1)+"or\x6c\x64"};typeof(Conso\u006ce).GetMet\u0068o\u0064s()[101].Invoke(c,c);return 0;}}

Explication

// I won’t be able to get anywhere without using “System”.
// Even if I write it as “Syst\u0065m”, it still violates rule 2.
// Therefore, that is the rule we’ll violate.
using System;

// Thus, we can’t use: H L W D 2 7
// We can’t write “class”, so the Main type must be a struct.
struct a
{
    // We can’t write “void”, so Main needs to return an int.
    static int Main()
    {
        // We can’t write “new”, but we can instantiate an array
        // using the initialisation syntax.
        object[] c = {
            "\u0048e\x6c\x6co " + (C\u0068ar) (86 + 1) + "or\x6c\x64"
        };

        // We can use the character escape sequence to write “Console”, but not
        // “Write” because W is \u0057, which contains a 7. Therefore, we have to
        // use Reflection to get it. This relies on the fact that Console.Write(string)
        // is the 102nd method of the type Console in my copy of the framework.
        // Also, the first argument to Invoke can be anything for a static method
        // (needn’t be null). The second one is the actual argument to Console.Write.
        typeof(Conso\u006ce).GetMet\u0068o\u0064s()[101].Invoke(c, c);

        // Since Main returns int, we have to return something.
        return 0;
    }
}

Brainfuck, 106 coups

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

Répond à toutes les règles et il est certainement obscurci.

Javascript, 2595

Cela ne fait que briser la règle 2.

ﾟωﾟﾉ=/｀ｍ´）ﾉ~┻━┻//*´∇｀*/['_'];o=(ﾟｰﾟ)=_=3;c=(ﾟΘﾟ)=(ﾟｰﾟ)-(ﾟｰﾟ);(ﾟДﾟ)=(ﾟΘﾟ)=(o^_^o)/(o^_^o);(ﾟДﾟ)={ﾟΘﾟ:'_',ﾟωﾟﾉ:((ﾟωﾟﾉ==3)+'_')[ﾟΘﾟ],ﾟｰﾟﾉ:(ﾟωﾟﾉ+'_')[o^_^o-(ﾟΘﾟ)],ﾟДﾟﾉ:((ﾟｰﾟ==3)+'_')[ﾟｰﾟ]};(ﾟДﾟ)[ﾟΘﾟ]=((ﾟωﾟﾉ==3)+'_')[c^_^o];(ﾟДﾟ)['c']=((ﾟДﾟ)+'_')[(ﾟｰﾟ)+(ﾟｰﾟ)-(ﾟΘﾟ)];(ﾟДﾟ)['o']=((ﾟДﾟ)+'_')[ﾟΘﾟ];(ﾟoﾟ)=(ﾟДﾟ)['c']+(ﾟДﾟ)['o']+(ﾟωﾟﾉ+'_')[ﾟΘﾟ]+((ﾟωﾟﾉ==3)+'_')[ﾟｰﾟ]+((ﾟДﾟ)+'_')[(ﾟｰﾟ)+(ﾟｰﾟ)]+((ﾟｰﾟ==3)+'_')[ﾟΘﾟ]+((ﾟｰﾟ==3)+'_')[(ﾟｰﾟ)-(ﾟΘﾟ)]+(ﾟДﾟ)['c']+((ﾟДﾟ)+'_')[(ﾟｰﾟ)+(ﾟｰﾟ)]+(ﾟДﾟ)['o']+((ﾟｰﾟ==3)+'_')[ﾟΘﾟ];(ﾟДﾟ)['_']=(o^_^o)[ﾟoﾟ][ﾟoﾟ];(ﾟεﾟ)=((ﾟｰﾟ==3)+'_')[ﾟΘﾟ]+(ﾟДﾟ).ﾟДﾟﾉ+((ﾟДﾟ)+'_')[(ﾟｰﾟ)+(ﾟｰﾟ)]+((ﾟｰﾟ==3)+'_')[o^_^o-ﾟΘﾟ]+((ﾟｰﾟ==3)+'_')[ﾟΘﾟ]+(ﾟωﾟﾉ+'_')[ﾟΘﾟ];(ﾟｰﾟ)+=(ﾟΘﾟ);(ﾟДﾟ)[ﾟεﾟ]='\\';(ﾟДﾟ).ﾟΘﾟﾉ=(ﾟДﾟ+ﾟｰﾟ)[o^_^o-(ﾟΘﾟ)];(oﾟｰﾟo)=(ﾟωﾟﾉ+'_')[c^_^o];(ﾟДﾟ)[ﾟoﾟ]='\"';(ﾟДﾟ)['_']((ﾟДﾟ)['_'](ﾟεﾟ+(ﾟДﾟ)[ﾟoﾟ]+(ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+(ﾟｰﾟ)+(ﾟΘﾟ)+(ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+((ﾟｰﾟ)+(ﾟΘﾟ))+(ﾟｰﾟ)+(ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+(ﾟｰﾟ)+((ﾟｰﾟ)+(ﾟΘﾟ))+(ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+((o^_^o)+(o^_^o))+((o^_^o)-(ﾟΘﾟ))+(ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+((o^_^o)+(o^_^o))+(ﾟｰﾟ)+(ﾟДﾟ)[ﾟεﾟ]+((ﾟｰﾟ)+(ﾟΘﾟ))+(c^_^o)+(ﾟДﾟ)[ﾟεﾟ]+(ﾟｰﾟ)+((o^_^o)-(ﾟΘﾟ))+(ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+(ﾟΘﾟ)+(c^_^o)+(ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+(ﾟｰﾟ)+((ﾟｰﾟ)+(ﾟΘﾟ))+(ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+((ﾟｰﾟ)+(ﾟΘﾟ))+(ﾟｰﾟ)+(ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+((ﾟｰﾟ)+(ﾟΘﾟ))+(ﾟｰﾟ)+(ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+((ﾟｰﾟ)+(ﾟΘﾟ))+((ﾟｰﾟ)+(o^_^o))+(ﾟДﾟ)[ﾟεﾟ]+(ﾟｰﾟ)+(c^_^o)+(ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+((o^_^o)-(ﾟΘﾟ))+((ﾟｰﾟ)+(o^_^o))+(ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+((ﾟｰﾟ)+(ﾟΘﾟ))+((ﾟｰﾟ)+(o^_^o))+(ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+((o^_^o)+(o^_^o))+((o^_^o)-(ﾟΘﾟ))+(ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+((ﾟｰﾟ)+(ﾟΘﾟ))+(ﾟｰﾟ)+(ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+(ﾟｰﾟ)+(ﾟｰﾟ)+(ﾟДﾟ)[ﾟεﾟ]+(ﾟｰﾟ)+((o^_^o)-(ﾟΘﾟ))+(ﾟДﾟ)[ﾟεﾟ]+((ﾟｰﾟ)+(ﾟΘﾟ))+(ﾟΘﾟ)+(ﾟДﾟ)[ﾟoﾟ])(ﾟΘﾟ))('_');

Befunge-93 - bloc 10x9

va:)/v<>#<
9A:)."c:P^
>"iqwt\%"^
bv"Mjq"<.<
c>v<-"x^x]
(C:,3>>^:(
$,9^;)|:O]
>5-^-.--.-
^<_#?>@_@<

Pardon. :RÉ

Je ne cherchais pas la petite taille ici, j'essayais de vraiment OBFUSCER le code en incluant le plus de visages souriants et de bruit possibles! :RÉ

Devrait aller avec les règles 2 et 3.

Golfscript - 17 caractères

Plus facile à copier / coller que Chris '

'Ifmmp!Xpsme'{(}%

Fondamentalement, un chiffre de César se déplaçant de 1 caractère

Python

Règle I & III (34 caractères)

print'Uryyb Jbeyq'.decode('rot13')

Règle I & III, alternative (39 caractères)

print"\110e\154\154o %cor\154\144"%~-88

Règle II et III (37 caractères)

input("H\x65ll\x64 W\x64%cld"%(3*38))

Règle I et II (50 caractères)

input('\x48\x65\x6c\x6c\x6f \x57\x6f\x72\x6c\x64')

Les trois règles (58 caractères)

input("\x48\x65\x6c\x6c\x6f %c\x6f%c\x6c\x64"%(84+3,3*38))

JavaScript, 366 caractères

Après avoir vu la solution Perl de Joel Berger, je me suis senti obligé de faire moi-même un peu de joliesse artistique en ASCII ... JavaScript, n'utilise pas de caractères alphanumériques, et contrairement à la sortie JSFuck, il est en fait de taille raisonnable.

                   $$
                  =-~-
                 ~[];$_
                =$$+ $$;
               _$=$$+$$+-
              ~[];_=-~[];$
             =!![]+[];__={}
            +[];$$_=/\\ /+[]
           _$$=(![]+[])[_]+(!
          []+[])[$$]+$[$_+~[]]
         +$[_]+$[+[]];$=__[_$]+
        __[_]+($[$]+[])[_]+(![]+
       [])[$_+~[]]+$[+[]]+$[_]+$[
      $$]+__[_$]+$[+[]]+__[_]+$[_]
     _=$$_[_]+-~[];$[$][$](_$$+'("'
    +_+-~[]+-[]+_+$_+_$+_+_$+$_+_+_$
   +$_+_+_$+[$$+_$]+$$_[-~[]]+$_+-[]+
  _+$$+[$$+_$]+_+_$+[$$+_$]+_+[$$+$_]+
                $$+ _+_$
                +$_+_+$_
                +$_+'")'
                  )($)

rot13 - 11 caractères

Uryyb Jbeyq

2019/2/12: Cette réponse est conservée pour des raisons historiques et n'est plus une réponse valide selon les règles en vigueur sur le site.

Bash, 30 à 25 caractères

tr G-t F-s<<<Ifmmp\ Xpsme

Avec mes remerciements à Peter Taylor pour l’utilisation de herestring.

Scala, 39 ans

Des solutions comme print ("Qnuux)` x {um "map (_- 9 toChar)) (35 caractères) enfreignent les règles 1 et 2 (" toChar "contient à la fois" h "et" r "), ce qui en fait un un peu difficile.

Enfin venu avec ceci:

print("䠀攀氀氀漀 圀漀爀氀搀"map(_.reverseBytes))

Suggestions d'amélioration bienvenue

TeX, 95 octets

Brise la troisième règle.

\^^5pp^^%^^2^^#^^!^^3^^%{^^(}^^%^^,^^,^^/
\^^5pp^^%^^2^^#^^!^^3^^%{^^7}^^/^^2^^,^^$!
\^^%^^.^^$

Exécuter avec tex filename.texpour obtenir une sortie dvi ou pdftex filename.texpour obtenir un pdf.

> <> , 2 × 20 = 40 caractères

'mu{x`)xuunQ'>9-o?v;
            ;^?o-9< 

Enfreint la règle II, car je ne peux pas sortir un caractère sans utiliser o.

Windows PowerShell, 91 95 97 98

($OFS='')+('Qnuux)`x{um'|% t*y|%{"[convert]::"+([convert]|gm -s t*r).name+"($($_-9))"|iex})

N'enfreint que la règle II.

C'est très mal qui charviole déjà deux règles.

Et oui, celui-ci était difficile à faire fonctionner.

• La première ligne est définie $OFSsur ''donc lors du transtypage d'un tableau en chaîne, aucun espace ne s'affiche entre les éléments.
• Le casting charétait en fait la partie la plus difficile de toutes et j'ai passé une journée à chercher un moyen. J'ai tout le reste travaillé bien mais une fois que je fais des calculs sur eux, j'ai ints, pas chars. Remettre ceux-ci dans une ficelle était un peu difficile.

• J'ai trouvé un moyen d'invoquer Invoke-Expressionsans avoir besoin du e:

  &(gcm i?x)
  

  mais cela manquait encore d'arguments. Et j'ai déjà jeté mon objectif de satisfaire aux trois règles d'ici là. De plus, ça ne m'a pas particulièrement aidé à faire le casting char.

• Réduit un peu avec une version plus récente de PowerShell. Aucune autre façon utile de créer le résultat n'a émergé, malheureusement.

PHP (16 octets)

J'ai remarqué que mon précédent exemple PHP n'était pas assez obscurci, voyons donc des exemples plus flagrants (avertissement, obscurcissement!). En outre, copiez de manière flagrante l'exemple GolfScript, sauf en le rendant plus petit (est-ce même possible?). Cette entrée nécessite PHP 5.4 ou short_open_tagactivé. Aucune règle n'a été enfreinte en faisant cela. En fait, cette entrée ne contient aucune lettre ou chiffre ASCII.

Cet exemple n'enfreint aucune des règles. S'amuser. Pour générer un fichier, exécutez la commande suivante.

printf "<?=~\xb7\x9a\x93\x93\x90\xdf\xa8\x90\x8d\x93\x9b;" > obfus.php

Ou, si vous ne faites pas confiance à la printfcommande en cours , j'ai préparé le dump du fichier en Base64.

PD89freak5OQ36iQjZObOw==

Si vous pensez que les deux méthodes pour le générer enfreignent les règles, j'ai également généré un fichier sur Dropbox .

Et pour l'exécuter.

php obfus.php

Le fichier résultant doit avoir 16 octets. Amusez-vous en cours d'exécution. S'il vous plaît noter que si vous avezE_NOTICE activé les avertissements, cela affichera un avis. Ignorez-le, le réparer vous ferait perdredeux personnagesun caractère (je peux utiliser @opérateur, après tout) et rendrait le résultat obtenu en Base64 moins impressionnant.

Espace blanc (167 caractères)

Pour obtenir le programme WS, remplacez les caractères S, T, L par un caractère d'espace, de tabulation ou de saut de ligne, respectivement, dans la chaîne suivante:

SSSTSSTSSSLTLSSSSSTTSSTSTLTLSSSSSTTSTTSSLTLSSSSSTTSTTSSLTLSSSSSTTSTTTTLTLSSSSSTSSSSSLTLSSSSSTSTSTTTLTLSSSSSTTSTTTTLTLSSSSSTTTSSTSLTLSSSSSTTSTTSSLTLSSSSSTTSSTSSLTLSSLLL

ou téléchargez le programme "brut" ne contenant que des espaces dans le fichier texte hello.ws .

Lorsqu'il est exécuté par cet interpréteur WS , ce programme imprime "Hello World".

Explication (ignorez les espaces ici!):

SSS TSSTSSSL TLSS  <-- output H (ascii code 72 in decimal, 1001000 in binary) 
SSS TTSSTSTL TLSS  <-- output e (ascii code 101 in decimal, 1100101 in binary) 
SSS TTSTTSSL TLSS  <-- etc
SSS TTSTTSSL TLSS
SSS TTSTTTTL TLSS
SSS TSSSSSL TLSS
SSS TSTSTTTL TLSS
SSS TTSTTTTL TLSS 
SSS TTTSSTSL TLSS 
SSS TTSTTSSL TLSS
SSS TTSSTSSL TLSS 
LLL                <-- end the program

Les chaînes "intermédiaires" (par exemple TSSTSSSL) sont les codes ascii (en binaire, S0 ( T1)) pour les lettres successives de "Hello World". Le préfixe SSSpousse le numéro qui le suit (terminé par un L) sur la pile. TLSSaffiche le caractère dont le code ASCII se trouve en haut de la pile. Enfin, selon ce tutoriel , un programme doit se terminer par LLLune sortie propre par l'interprète.

NB: J'écris ceci séparément, car l'autre entrée du programme WS est un programme de 1287 caractères qui affiche "Bonjour, le monde des espaces!" au lieu du "Hello World" requis.

Ruby - 63 personnages

puts [%w{G d k k n},%w{V n q k c}].map{|l|l.map(&:succ)*''}*' '

C, 160 caractères

Fonctionne uniquement sur les machines little-endian de 4 octets int:

main(){int a='a',b=a/a,c=b+b,f=c+c,g=f+f,i=g+g,j=i*i,k=j*j,m=a+g+b+c,n=m+b+c;int p[]={a+g-b+(a+f)*j+m*k*(j+b),n+i*c*j+k*(n+g+n*j),a+i+b+m*j+(a+f-b)*k};puts(p);}

Satisfait les trois règles.

PHP, 28 octets

Pas exactement obscurci, mais très court et évident :). En montrant que même lorsque vous limitez les caractères, vous pouvez très facilement suivre les programmes. Les contraintes 1 et 3 ont suivi. La contrainte 2 a été abusée.

<?=str_rot13('Uryyb Jbeyq');

Notez que ceci nécessite d' short_open_tagêtre défini, à moins que vous n'utilisiez PHP 5.4 ou supérieur. Certains exemples sont peut-être plus courts, mais je pense que cet exemple est assez court.

bash 28 caractères:

printf 'p|ɹ°M ο||ǝ%b'"\x48"

p | ο || ǝH

alternativement avec / bin / echo (18 caractères) *), voir la discussion ci-dessous.

/bin/echo -e 'p|ɹοM ο||ǝ\0110'

Auto-test:

echo "printf 'p|ɹοM ο||ǝ%b' "\x48"" | egrep -i "[^hlwd27eor01]"

Plus dur que thougth! Outils, pour retourner les mots à l'envers, les outils pensent qu'un «H» ou un «o» renversé est mieux affiché sous la forme H ou o. Cela serait en conflit avec le groupe 1 (Hlwd: 27: eor01) respectivement 3.

H peut être affiché avec

echo -e "\0127"

mais 01 et 2 sont également empoisonnés. Gee! Mais l’écho bash-buildin a non seulement la possibilité d’afficher des valeurs ascii octales, mais aussi des valeurs hexadécimales:

echo -e "\x48"

Mais si nous utilisons bash comme langage de programmation, la commande echo fait partie du programme, qui compte non seulement dans le nombre de caractères, mais contient également les caractères empoisonnés (hlwd: 27: eor01) issus des groupes 1 et 3.

C'est donc le moment où l'écho est mort. Heureusement, il y a printf, qui sait que "% b" doit être affiché.

Le caractère r est le seul caractère problématique dans printf et appartient au groupe 3. Puisque "o" est dans le dernier groupe, nous pourrions le laisser dans Hello et dans World, mais nous pouvons utiliser l'omicron ο qui ressemble à un o, ou ° °.

Liens:

• outil à l'envers 1
• deuxième outil à l'envers

C (94)

Sur les petites machines Endian:

main(){int i[]={1819043144,((0x1bc5c81b|1<<0x14)*4)+3,0xa646c00|(0x39<<1),0};printf("%s",i);}

Enfreint la règle II, mais satisfait le reste.

JavaScript - 132 caractères

(_=(_=[][(f=!!(_='')+_)[3]+(b=({}+_)[(I=-~(z=_-_))])+($=(c=(d=!_+_)[I])+d[z])])())[f[I]+'l'+(a=d[3])+$]("H"+a+'ll'+b+' W'+b+c+'ld')

Règle des pauses I

Utilisation :

• Collez "javascript: [script]" dans la barre d'adresse du navigateur
• Créez une page HTML vierge, collez le script dans une balise

Dis , 102 83 caractères

Déroulé la boucle de code car les lettres peuvent être générées avec moins de cinq opérations consécutives. Vous avez enregistré quelques caractères en réutilisant la valeur de l'accumulateur: deux lsont consécutifs, SPACEpeuvent être générés à partir de oet dpeuvent être générés à partir de l.

*>|||{>|||{>||{{>|{|||{>||{>|{>|||{>||{||{!!>**_!!}|_}!^__}|__>*__}|_}|_>!!|_}!^__!

Ancienne version

^}!>^^_^!__!>_^!^^**_^!^^**_
^_!{**_^__!{>_^__{>>!^_!{**_
^_!>^*_^!^^**_^_^^**_*______
___________>||||{^

Avec des commentaires ci-dessous. Il utilise une séquence de cinq opérations identiques pour générer tous les caractères dans Hello Worldune rotation et quatre soustractions.

^     (move code pointer to data pointer value '^')
}!>^^ (store 'H' in accumulator)
_     (no-op)
^     (data pointer value used by code pointer jump)
!__!> (store 'e' in accumulator)
_     (no-op)
^     (data pointer value used by code pointer jump)
!^^** (store 'l' in accumulator)
_     (no-op)
^     (data pointer value used by code pointer jump)
!^^** (store 'l' in accumulator)
_     (no-op)
^     (data pointer value used by code pointer jump)
_!{** (store 'o' in accumulator)
_     (no-op)
^     (data pointer value used by code pointer jump)
__!{> (store ' ' in accumulator)
_     (no-op)
^     (data pointer value used by code pointer jump)
__{>> (store 'W' in accumulator)
!     (program termination)
^     (data pointer value used by code pointer jump)
_!{** (store 'o' in accumulator)
_     (no-op)
^     (data pointer value used by code pointer jump)
_!>^* (store 'r' in accumulator)
_     (no-op)
^     (data pointer value used by code pointer jump)
!^^** (store 'l' in accumulator)
_     (no-op)
^     (data pointer value used by code pointer jump)
_^^** (store 'd' in accumulator)
_     (no-op)
*     (data pointer value used by code pointer jump to reach '!' between 'W' and 'o')
________________ (no-ops)
_     (no-op, address '^')
>|||| (rotate data value and perform four subtractions)
{     (print value in accumulator)
^     (move code pointer to data pointer value '^' except for the last jump '*')

C: 162 caractères (excluant les nouvelles lignes inutiles)

J'ai opté pour la lisibilité et la transparence lors de l'écriture.

a[3],b;main(){b=99
+9;b+=b<<8;b=b<<8|
97|4;b=b<<8|64|8;a
[3^3]=b;b=78+33<<8
;b+=87;b=b<<8|35^3
;b=b<<8|64|47;a[5^
4]=b;b=97+3<<8;b+=
99+9;b=b<<8|66|48;
a[6^4]=b;puts(a);}

Il répond aux trois exigences.

Bash, 24 à 20 caractères

Vous devez avoir le paquet "bsdgames" installé.

rot13<<<Uryyb\ Jbeyq

Merci gnibbler :)

PostScript, 41 caractères

<64><~+BNK%C]~><48656c6c6f>3{print}repeat

Usage: $ gs -q -dNOPROMPT -dNODISPLAY filename.ps

JavaScript, 66 caractères

Une autre solution JavaScript, enfreignant cette fois la règle n ° 2.

top[(U=unescape)('a%6cert')](U('%48e%6c%6co %5'+(6+1)+'or%6c%64'))

Ce qui précède suit le concept de la réponse de hallvabo. Avant d’accepter cette approche, j’avais la version plus obscure:

top[8680439[n='toString'](30)]((16+1)[n](z=8*4)[u='toUpperCase']()
+15960[n](33)+'o '+z[n](33)[u]()+1155505[n](36))

qui enfreint également la règle n ° 2 et se situe à 114 caractères. (Supprimez le retour chariot dans cette deuxième solution, car il n’est là que pour la lisibilité.)

Haskell, 38 ans

Les contraintes 1 et 3 ont suivi.

main=putStr$map succ"G\x64kkn\USVnqkc"

Fourier, 39 octets

8*9a99^^a+6^aa~q+3a33va86^aq+3a+3aqa-8a

Fourier est toujours obscurci. Cela suit toutes les règles.

Panne:

8*9a    Set the accumulator to 8, multiply it by 9, and print the 
        corresponding ASCII code.

99^^a   Set the accumulator to 99, increment it twice, and print the
        corresponding ASCII code.

+6^aa   Add 6 to the accumulator, increment it, and print the
        corresponding ASCII code twice.

~q      Set the variable q to the current value of the accumulator.

+3a     Add 3 to the accumulator and... I think you get the idea.

33va    Set the accumulator to 33, decrement it, and print ASCII.

86^a    Yes, okay, I think it's obvious by this point.

q+3a    Set the accumulator to the value of q (earlier set to 108),
        add 3, and print ASCII.

+3a     ...

qa      Invoke q again and print ASCII.

-8a     Subtract 8 from the accumulator and print ASCII.

Cela pourrait peut-être être affiné un peu.