Cree el programa ofuscado más corto posible que muestre el texto "Hola mundo".

Para ser considerado un programa ofuscado, debe cumplir al menos dos de los siguientes requisitos:

• No contiene los caracteres: h, l, wy den cualquier caso
• No contiene los caracteres: e, o, r, 0, y 1en cualquier caso
• No contiene los caracteres: 2o7

Entrada:
ninguna

Salida:
Hello World

GolfScript, 17 caracteres

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

Al probar este envío, guarde el archivo como binario directo, no UTF-8. ¿Tiene problemas para recrear el archivo? Aquí está el hexdump de la misma:

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

Perl

Dado que la respuesta obvia usa el desplazamiento de algún tipo, me siento obligado a publicar algo usando Acme :: EyeDrops , sin embargo, con el poder extra, pensé que el mío debería ser un poco más divertido.

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

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

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

Consideración

Desde la versión 5.18 de Perl, el mecanismo que permite que se ejecute este código se ha vuelto tan poderoso que se ha deshabilitado de forma predeterminada para evitar el mal uso. Por lo tanto, en las versiones 5.18+, puede agregar use re 'eval';a la parte superior de la secuencia de comandos o, si se nombra la secuencia de comandos world.pl, puede ejecutarla como perl -Mre=eval world.pl. Es lamentable que se agreguen estos caracteres antiestéticos, pero c'est la vie (Nota: quiero enfatizar que habilitar esta función no es usar alguna biblioteca o complemento, el código que se muestra es un código Perl válido, el mecanismo simplemente ya no está habilitado de forma predeterminada).

C # (175 caracteres)

Fue todo un desafío hacer esto en C # porque las restricciones impiden el uso de muchas de las palabras clave comunes. Es posible en C # usar \ uxxxx secuencias de escape Unicode en identificadores, pero desafortunadamente no en palabras clave.

Sospecho que esta solución solo funciona cuando se compila contra .NET 4.0. Ver explicación de por qué.

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;}}

Explicación

// 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 golpes

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

Cumple con todas las reglas y seguro está ofuscado.

Javascript, 2595

Esto solo rompe la regla 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 - bloque 10x9

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

Lo siento. :RE

No estaba buscando un tamaño pequeño aquí, estaba tratando de OFUSAR realmente el código al incluir tantas caras sonrientes y ruido como sea posible. :RE

Debería ir con las reglas 2 y 3.

Golfscript - 17 caracteres

Más fácil de copiar / pegar que Chris '

'Ifmmp!Xpsme'{(}%

Básicamente, un cifrado César que cambia por 1 personaje

Pitón

Regla I y III (34 caracteres)

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

Regla I y III, alternativa (39 caracteres)

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

Regla II y III (37 caracteres)

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

Regla I y II (50 caracteres)

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

Las tres reglas (58 caracteres)

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

JavaScript, 366 caracteres

Después de ver la solución Perl de Joel Berger, me sentí obligado a hacer algunas bellezas artísticas ASCII yo mismo ... JavaScript, no utiliza caracteres alfanuméricos, y al contrario de la salida de JSFuck, en realidad tiene un tamaño razonable.

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

rot13 - 11 caracteres

Uryyb Jbeyq

12/02/2019: esta respuesta se mantiene por razones históricas y ya no es una respuesta válida según las reglas actuales del sitio.

Bash, 30 25 caracteres

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

Gracias a Peter Taylor por el uso de herejías.

Scala, 39

Soluciones como print ("Qnuux)` x {um "map (_- 9 toChar)) (35 caracteres) no cumplen con las reglas 1 y 2 (" toChar "contiene" h "y" r "), lo que hace que esto sea un un poco duro

Finalmente se me ocurrió esto:

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

Sugerencias de mejora bienvenida

TeX, 95 bytes

Rompe la tercera regla.

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

Ejecute con tex filename.texpara obtener una salida de dvi o pdftex filename.texpara obtener un pdf.

> <> , 2 × 20 = 40 caracteres

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

Viola la Regla II, ya que no puedo mostrar un personaje sin usarlo o.

Windows PowerShell, 91 95 97 98

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

Viola solo la Regla II.

Es muy malvado que char viole ya dos reglas por sí solo.

Y vaya, este era difícil de conseguir.

• La primera línea define $OFSa ''lo que cuando emitan un arreglo en una cadena sin espacios aparecen entre los elementos.
• Castear en charrealidad fue la parte más difícil de todas y pasé alrededor de un día buscando una manera. Obtuve todo el resto trabajando bien, pero una vez que hago cálculos sobre ellos tengo ints, no chars. Ponerlos de vuelta en una cuerda fue un poco difícil.

• Encontré una forma de invocar Invoke-Expressionsin necesidad de e:

  &(gcm i?x)
  

  pero eso aún carecía de argumentos. Y ya he descartado mi objetivo de satisfacer las tres reglas para entonces. Además, no me ayudó particularmente en el casting char.

• Acortado un poco con una nueva versión de PowerShell. Sin embargo, no surgió ninguna forma útil diferente de crear el resultado, lamentablemente.

PHP (16 bytes)

Me di cuenta de que mi ejemplo anterior de PHP no estaba lo suficientemente ofuscado, así que veamos ejemplos de ofuscación más descarada (¡advertencia, ofuscación!). Además, copia descaradamente el ejemplo de GolfScript, excepto que lo hace más pequeño (¿es posible?). Esta entrada requiere PHP 5.4 oshort_open_tag habilitado. No se rompió ninguna regla al hacer esto. De hecho, esta entrada no contiene letras ni dígitos ASCII.

Este ejemplo no rompe ninguna de las reglas. Que te diviertas. Para generar el archivo, ejecute el siguiente comando.

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

O, en caso de que no confíe en ejecutar el printfcomando, he preparado el volcado Base64 del archivo.

PD89freak5OQ36iQjZObOw==

Si crees que ambos métodos para generarlo rompen las reglas, también he generado un archivo en Dropbox .

Y para ejecutarlo.

php obfus.php

El archivo resultante debe tener 16 bytes. Diviértete ejecutándolo. Tenga en cuenta que si tieneE_NOTICE habilitadas las advertencias, se mostrará un aviso. Solo ignóralo, arreglarlo desperdiciaríados personajesun personaje (puedo usar el @operador, después de todo) y haría que el Base64 resultante se vea menos impresionante.

Espacio en blanco (167 caracteres)

Para obtener el programa WS, sustituya un carácter de espacio, tabulación o salto de línea por S, T, L, respectivamente, en la siguiente cadena:

SSSTSSTSSSLTLSSSSSTTSSTSTLTLSSSSSTTSTTSSLTLSSSSSTTSTTSSLTLSSSSSTTSTTTTLTLSSSSSTSSSSSLTLSSSSSTSTSTTTLTLSSSSSTTSTTTTLTLSSSSSTTTSSTSLTLSSSSSTTSTTSSLTLSSSSSTTSSTSSLTLSSLLL

o descargue el programa "en bruto" de espacios en blanco en el archivo de texto hello.ws .

Cuando lo ejecuta este intérprete de WS , este programa imprime "Hello World".

Explicación (¡ignore el espacio en blanco aquí!):

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

Las cadenas "intermedias" (p TSSTSSSL. Ej. ) Son los códigos ascii (en binario, con Sdenotando 0, Tdenotando 1) para las letras sucesivas en "Hello World". El prefijo SSSempuja el número que le sigue (terminado por un L) en la pila. TLSSgenera el carácter cuyo código ascii está en la parte superior de la pila. Finalmente, de acuerdo con este tutorial , un programa debe terminar con LLLuna salida limpia del intérprete.

NB: Estoy ingresando esto como una respuesta separada, porque la otra entrada del programa WS es un programa de 1287 caracteres que imprime "¡Hola, mundo de espacios!" en lugar del requerido "Hola Mundo".

Ruby - 63 caracteres

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

C, 160 caracteres

Funciona solo en máquinas little endian con 4 bytes 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);}

Satisface las tres reglas.

PHP, 28 bytes

No exactamente ofuscado, pero muy corto y obvio :). Mostrando que incluso cuando se limitan los caracteres, puede hacer que los programas sean muy fáciles de seguir. Las restricciones 1 y 3 siguieron. La restricción 2 fue abusada.

<?=str_rot13('Uryyb Jbeyq');

Tenga en cuenta que esto requiere short_open_tagser configurado, a menos que esté usando PHP 5.4 o superior. Quizás algunos ejemplos son más cortos, pero creo que este ejemplo es bastante corto.

bash 28 caracteres:

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

p | ɹοM ο || ǝH

alternativamente con / bin / echo (18 caracteres) *) vea la discusión a continuación.

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

Autotest:

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

¡Más duro de lo que piensas! Herramientas, para voltear las palabras al revés, las herramientas piensan que una 'H' u 'o' al revés se muestra mejor como H o o. Esto estaría en conflicto con el grupo 1 (Hlwd: 27: eor01) respectivamente 3.

H se puede mostrar con

echo -e "\0127"

pero 01 y 2 también están envenenados. ¡Caramba! Pero el eco bash-buildin no solo tiene la opción de mostrar valores ascii octales, sino también hexadecimales:

echo -e "\x48"

Pero si usamos bash como lenguaje de programación, el comando echo es parte del programa, que no solo cuenta para el recuento de caracteres, sino que también contiene los caracteres envenenados (hlwd: 27: eor01) eho de los grupos 1 y 3.

Así que en este momento el eco murió. Afortunadamente, hay printf, que sabe "% b" para mostrar.

La r es el único carácter problemático en printf, y pertenece al grupo 3. Como 'o' está en el último grupo, podríamos dejarlo en Hello y en World, pero podemos usar el omicron ο que parece una o, o ° °.

Enlaces:

• herramienta invertida 1
• segunda herramienta invertida

C (94)

En pequeñas máquinas Endian:

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

Viola la regla II, pero satisface el resto.

JavaScript: 132 caracteres

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

Rompe la regla I

Uso :

• Pegue "javascript: [script]" en la barra de direcciones del navegador
• Haga una página html en blanco, pegue el script en una etiqueta

Dis , 102 83 caracteres

Desenrolló el bucle de código ya que las letras se pueden generar con menos de cinco operaciones consecutivas. Se guardaron algunos caracteres al reutilizar el valor del acumulador: dos lson consecutivos, SPACEse pueden generar desde oy ddesde l.

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

Versión antigua

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

Con comentarios a continuación. Utiliza una secuencia de cinco operaciones idénticas para generar todos los caracteres en Hello World: una rotación y cuatro restas.

^     (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 caracteres (excluyendo nuevas líneas innecesarias)

Opté por la legibilidad y la transparencia al escribir esto.

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);}

Cumple los tres requisitos.

Bash, 24 20 caracteres

Necesita tener instalado el paquete "bsdgames".

rot13<<<Uryyb\ Jbeyq

Gracias gnibbler :)

PostScript, 41 caracteres

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

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

JavaScript, 66 caracteres

Otra solución de JavaScript, esta vez rompiendo la regla # 2.

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

Lo anterior sigue el concepto detrás de la respuesta de hallvabo. Antes de comprender ese enfoque, tenía la versión posiblemente más ofuscada:

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

que también infringe la regla n. ° 2 y tiene 114 caracteres. (Retire el retorno de carro en esta segunda solución, ya que está allí para facilitar la lectura).

Haskell, 38

Las restricciones 1 y 3 siguieron.

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

Fourier, 39 bytes

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

Fourier siempre está ofuscado. Esto sigue todas las reglas.

Descompostura:

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.

Esto podría ser refinado un poco.