Hola mundo ofuscado


123

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


66
Supongo que importen Python no está permitido.
Alexandru

26
¿Estas reglas se aplican también a las palabras clave de idioma?
hallvabo 01 de

8
¿son esas restricciones insensibles a mayúsculas y minúsculas?
oenone

20
¿Alguien podría explicar por qué 2 y 7 no están permitidos? Tengo curiosidad ya que no veo por qué fueron elegidos en particular.
Thomas Eding

44
@trinithis, y otros, de caracteres ASCII 72es "H"por lo que he elegido esos dos
Kevin Brown

Respuestas:


51

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                                                |%|

1
Aunque me gustaría pensar que es una solución obvia, si no tiene claro cómo funciona esta entrada, puede leer este spoiler: chat.stackexchange.com/transcript/message/442257#442257 :-)
Chris Jester -Joven 01 de

12
No es ISO-8859-1, en realidad es Windows-1252.
Konrad Borowski

@ GlitchMr: en realidad estoy bastante seguro de que el envío contiene caracteres que también están fuera de Windows-1252. ;-)
Chris Jester-Young

@xfix Realmente tampoco es Windows-1252. Aunque Windows-1252 tiene más caracteres válidos que ISO-8859-1, mi entrada contiene caracteres, como 0x8D y 0x90, que tampoco son válidos en Windows-1252.
Chris Jester-Young

De acuerdo, olvidé que algunos caracteres no están permitidos en Windows-1252.
Konrad Borowski

171

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).


1
¡Lo probé y es genial! +1
Tomás

2
@TomasT. gracias, fue divertido de hacer, ¡y en realidad tomó un poco de golf lograr que se ejecutara en solo 3 fotos!
Joel Berger

1
Para su información, utiliza la función Perge regexp (?{ code })para evaluar el código Perl personalizado mientras coincide con la expresión regular. El código personalizado de Perl imprime el mensaje. Es bueno porque no viola ninguna de las reglas.
pts

55
Usted señor, es el hola rey del mundo!
recursion.ninja

1
¡Guauu! ¡Simplemente guau! Ahora necesito aprender Perl solo para ver cómo demonios hiciste eso.
Gryphon

69

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

Puede usar en Urilugar de objectpara b. Puede usar \xHHen cadenas en lugar de \u00HHdonde no es ambiguo ( \xes de longitud variable). Pensándolo bien, no necesitas bnada y solo puedes reutilizarlo ccomo primer argumento Invoke. MSDN establece que para los métodos estáticos se ignora el primer argumento. Esto lo reduce a 175 para mí.
Joey

@Joey: Whoa, gracias! Aunque si el primer argumento Invokepuede ser algo, ni siquiera tiene que ser c, podría ser 0... :)
Timwi

Sí, noté que cuando intenté en línea c(que lamentablemente no funciona ya que newrequiere un ey .Split('x')es demasiado largo (salió a 177).
Joey

No tenía idea de que esto fuera posible. +1
Igby Largeman

1
Algo muy inteligente que hiciste GetMethods. +1
Soham Chowdhury

51

BrainFuck, 106 golpes

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

Cumple con todas las reglas y seguro está ofuscado.


2
Creo que todavía puedo jugar golf un poco, pero eso tendrá que esperar hasta que pueda dormir un poco.
R. Martinho Fernandes

34
¿BrainFuck no está ofuscado por su definición?
mbx

18
Cualquier programador competente de BF podría reconocer esto ...
Mehrdad

Esto rompe las reglas 1 y 2: D
Thomas Eding

8
Brah, protegido por la comunidad , lo que sea, ++++++++++[>++++++>+++<<-]>++++++++++++.---.+++++++..+++.>++.<++++++++.--------.+++.------.--------.son solo 100 golpes, el mío es mejor que el tuyo
OverCoder

44

Javascript, 2595

Esto solo rompe la regla 2.

゚ω゚ノ=/`m´)ノ~┻━┻//*´∇`*/['_'];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゚])(゚Θ゚))('_');

13
Lo probé en UglifyJS pero ahorró -2574 bytes.
Konrad Borowski

12
No tengo idea de lo que estoy viendo aquí.
Bob

66
@Bob = Javascript ofuscado. Sugerencia: comienza asignando un literal de expresión regular (a saber, '/ ` m´) ノ ~ ┻━┻ /') a una variable con el nombre '゚ ω ゚ ノ. That's followed by a comment and the expression [' _ '] `en contexto vacío. Luego, a la variable o(junto con _y (゚ー゚)) se le asigna el valor 3. Continúa en esa línea, haciendo mucho trabajo inofensivo adicional que es efectivamente no operatorio, y usando formas indirectas para hacer el trabajo previsto (llamada alert("Hello world")) de una manera no obvia Moda.
Mark Reed


40

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.


18
"@_@" Me reí.
Wug

35

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


44
+1 Agradable por ser más simple de copiar. El mío tiene la ventaja de no romper ninguna de las reglas y también (probablemente, dependiendo de si los caracteres de alto bit cuentan como símbolos) también cumple el golf de símbolos. :-)
Chris Jester-Young

¿Cómo rompe esto una regla?
d -_- b

11
@sims, tiene una een ella
gnibbler

2
DOS de los tres. : D
Rob el

30

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

1
borré mi respuesta, creo que la tuya es más completa.
st0le

+ 1, gran pieza, pero no es de extrañar que te haya visto jugando al golf :-)
Quixotic

Necesitas hacerlo import codecsantes de podercodecs.decode
gato

Puede eliminar los parens en la primera solución
Cyoce

23

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.

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

¿podría mostrar el número de caracteres en su código en el encabezado? Tengo curiosidad por ver cuántos lo conseguiste ...
WallyWest

@ Eliseod'Annunzio ahí tienes, olvidé que esto era código golf. La longitud se da con espacios en blanco despojados y el último ($)convertido ()(porque agregué $por simetría).
FireFly

Gracias por sus consejos ... Tuve que cambiar el tamaño de mi código para dar cuenta de la "W" y luego
reducirlo

21

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.


3
¿Rot13 es un idioma? : /
Santosh Kumar

3
sí y puedo crear su intérprete: P
oddcoder

66
Técnicamente, rot13 es solo una cifra . Es tanto un lenguaje como un cifrado Vigenère.
XiKuuKy

19

Bash, 30 25 caracteres

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

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


2
Puede guardar 5 caracteres usando una cadena aquí:tr G-t F-s<<<Ifmmp\ Xpsme
Peter Taylor

18

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


18

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.


1
¡Guau, nunca supe que TeX puede estar tan ofuscado!
gar

14

> <> , 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.


11

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.


Todavía hay muchas "o" y "e" s aquí, y una "r". Sin embargo, tampoco estoy seguro de tener mucha mejor suerte limpiando eso. Puede que tenga que intentarlo alguna vez.
Iszi

Simplemente vuelva a leer las reglas: solo se necesitan dos de los tres conjuntos de reglas cumplidos, y esto califica. ¡Buen espectaculo! Sería increíble si pudiéramos llegar a uno que tome 3/3, pero dudo que sea muy posible.
Iszi

Me tomó mucho tiempo llegar a este punto, y todavía dudo que sea posible seguir todas las reglas.
Joey

10

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.


9

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".


8

Ruby - 63 caracteres

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

rompe # 1, sin embargo
John Dvorak

Y aún más corto: puts "Gdkkn~Vnqkc".split("").map(&:succ)*''- 43
Biketire

7

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.


1
Podrías usar constantes numéricas sin 0,1,2,7: p[];main(){p={(5*5*5*5*5*64+96696)*(443+5688),(5*3*4*3+4-3)*(66*45*6-6*6-4+3)*8‌​3*(3+4),6544494+36868};puts(p);}- 111 caracteres.

1
Vena similar (en realidad abordó el problema de diferentes maneras antes de decidirse por esto). x[]={45483*39994-3958,48465*38543-5584,6584695-3333};main(){puts(x);}- 69 caracteres. Estoy seguro de que podría ahorrarme un poco más si tuviera más tiempo para matematizar los literales un poco más. Fue una forma divertida de pasar un par de horas, de todos modos :)
Cole Cameron

7

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.


7

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 ° &deg;.

Enlaces:


Votaría esto, pero tu reputación es demasiado profunda.
Konrad Borowski

@ GlitchMr: Ahora puedes: voté algo en contra y debería ver 500N. :)
usuario desconocido

dl.dropbox.com/u/63913412/stilltooleet.png . Además, las preguntas de voto negativo no disminuyen la reputación. Las respuestas a votos negativos, sin embargo.
Konrad Borowski

@ GlitchMr: ¡Ah, eso es! :)
usuario desconocido

6

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.


6

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

Rompe las reglas 1 y 2. Está utilizando el número 1 para las matrices.
Kevin Brown

Se puede reemplazar 1por !![]+![]y 0por ""-""que no infringe la regla # 2.
HoLyVieR

Gracias @ Bass5098 y @HoLyVieR, me perdí el 1 y el 0 al minimizar el script. Reemplacé 0 con z = _-_ y 1 con I = - ~ z, también podría usar ++ z, pero - ~ se ve mejor :)
m0sa

3
¿Eh? !![]+![]? ¿Por qué no solo 4-3?
Timwi

44
@Timwi: Más ofuscación
Thomas Eding

6

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 '*')

6

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.


1
Me gusta esto, pero desafortunadamente no cumple con todas las reglas, porque contiene el dígito 7, violando la regla # 3. Pero sería fácil deshacerse de él 7. Además, al agregar algunos intsy agregar algunos paréntesis adicionales y agregar int puts(int*);al principio, se compila gcc -ansi -W -Wallsolo con una sola advertencia: el control llega al final de la función no nula .
pts

5

Bash, 24 20 caracteres

Necesita tener instalado el paquete "bsdgames".

rot13<<<Uryyb\ Jbeyq

Gracias gnibbler :)


5

PostScript, 41 caracteres

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

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


1
también puedes ejecutarlo como: gsnd -q -- filename.ps
luser droog

5

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).


44
He leído que como R unescape.
Mateen Ulhaq

@MateenUlhaq Siempre lo leí como R unescape, y solo jugué durante un año hace más de una década ... ¿Qué me pasa?
Mwr247

5

Haskell, 38

Las restricciones 1 y 3 siguieron.

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

4

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.


Woah, me acabo de dar cuenta de que alguien más ha usado Fourier: D Nice one, +1
Beta Decay
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.