Obfuscated Hello World

123

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

Kevin Brown
la source
6
Je suppose importqu'en python n'est pas autorisé.
Alexandru
26
Ces règles s'appliquent-elles également aux mots-clés de langue?
hallvabo
8
Ces restrictions sont-elles sensibles à la casse?
Oenone
20
Quelqu'un pourrait-il expliquer pourquoi 2 et 7 ne sont pas autorisés? Je suis juste curieux car je ne vois pas pourquoi ils ont été choisis en particulier.
Thomas Eding
4
@trinithis, et d'autres, le caractère ASCII 72est "H"ce qui explique pourquoi j'ai choisi ces deux
Kevin Brown

Réponses:

51

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                                                |%|
Chris Jester-Young
la source
1
Bien que j'aimerais penser que c'est une solution évidente, si vous n'êtes pas du tout certain de la manière dont cette entrée fonctionne, vous pouvez lire ce commentaire : chat.stackexchange.com/transcript/message/442257#442257 :-)
Chris Jester -Jeune
12
Ce n'est pas ISO-8859-1, c'est en fait Windows-1252.
Konrad Borowski
@GlitchMr: En fait, je suis presque certain que la soumission contient des caractères extérieurs à Windows-1252. ;-)
Chris Jester-Young le
@xfix Ce n'est vraiment pas Windows-1252 non plus. Bien que Windows-1252 comporte davantage de caractères valides que ISO-8859-1, mon entrée contient des caractères, tels que 0x8D et 0x90, qui ne sont pas non plus valides dans Windows-1252.
Chris Jester-Young
Assez juste, j'ai oublié que certains caractères sont interdits dans Windows-1252.
Konrad Borowski
171

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

Joel Berger
la source
1
J'ai essayé et c'est tout simplement génial! +1
Tomas
2
@TomasT. merci, c'était amusant à faire, et il a effectivement fallu du golf pour que cela fonctionne en seulement 3 images!
Joel Berger
1
FYI Il utilise la fonctionnalité Expression rationnelle Perl (?{ code })pour évaluer le code Perl personnalisé lors de la correspondance d'expressions rationnelles. Le code Perl personnalisé imprime le message. C'est bien parce que cela n'enfreint aucune des règles.
Pts
5
Vous êtes le roi du monde, bonjour!
recursion.ninja
1
Hou la la! Juste wow! Maintenant, j'ai besoin d'apprendre Perl juste pour voir comment vous avez fait cela.
Gryphon
69

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;
    }
}
Timwi
la source
Vous pouvez utiliser Uriau lieu de objectpour b. Vous pouvez utiliser des \xHHchaînes au lieu d’ \u00HHêtre dépourvues d’ambiguïté ( \xlongueur variable). À la réflexion, vous n'avez pas besoin bdu tout et vous pouvez simplement le réutiliser ccomme premier argument Invoke. MSDN indique que pour les méthodes statiques, le premier argument est ignoré. Cela le ramène à 175 pour moi.
Joey
@ Joey: Whoa, merci! Bien que si le premier argument Invokepuisse être quoi que ce soit, il ne devrait même pas l'être c, il pourrait être 0... :)
Timwi
Oui, j'ai remarqué que lorsque j'ai essayé de faire de la ligne c(ce qui malheureusement ne fonctionne pas car cela newnécessite un eet .Split('x')est trop long (sorti à 177).
Joey
Je ne savais pas que c'était possible. +1
Igby Largeman
1
Chose très intelligente vous avez fait avec GetMethods. +1
Soham Chowdhury
51

Brainfuck, 106 coups

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

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

R. Martinho Fernandes
la source
2
Je pense que je peux encore jouer un peu au golf, mais cela devra attendre que je dorme un peu.
R. Martinho Fernandes
34
BrainFuck n'est-il pas obscurci par sa définition?
MBX
18
Tout programmeur BF compétent serait capable de reconnaître cela ...
Mehrdad
Cela enfreint les deux règles 1 et 2: D
Thomas Eding
8
Brah, Protégé par la communauté , peu importe, à ++++++++++[>++++++>+++<<-]>++++++++++++.---.+++++++..+++.>++.<++++++++.--------.+++.------.--------.seulement 100 coups, le mien est meilleur que le vôtre
OverCoder
44

Javascript, 2595

Cela ne fait que briser la règle 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゚])(゚Θ゚))('_');
Peter Olson
la source
13
Je l'ai essayé sur UglifyJS dessus, mais il a enregistré -2574 octets.
Konrad Borowski
12
Je n'ai aucune idée de ce que je regarde ici.
Bob
6
@Bob = Javascript obscurci. Astuce: il commence par assigner un littéral d'expression régulière (à savoir '/ ` m´) ノ ~ ┻━┻ /') à une variable portant le nom `゚ ω ゚. That's followed by a comment and the expression ['_']` dans un contexte vide. Ensuite, la variable o(ainsi que _et (゚ー゚)) se voit attribuer la valeur 3. Elle continue dans cette veine, effectuant de nombreux travaux inoffensifs qui ne sont en réalité aucune opération, et en utilisant des moyens détournés pour effectuer le travail souhaité (appeler alert("Hello world")) de manière non évidente. mode.
Mark Reed
6
Source: utf-8.jp/public/aaencode.html
Jason C
40

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.

Aurel Bílý
la source
18
"@_@" J'ai ri.
Wug
35

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

gnibbler
la source
4
+1 Bien pour être plus simple à copier. Le mien a l'avantage de ne pas enfreindre les règles, et aussi (probablement, selon que les caractères à fort bit comptent comme des symboles) remplissant également le symbole golf. :-)
Chris Jester-Young le
Comment cela enfreint-il une règle?
d -_- b
11
@sims, il y a ededans
gnibbler
2
Deux des trois. : D
Rob
30

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))
hallvabo
la source
1
supprimé ma réponse, je pense que la vôtre est plus complète.
St0le
+ 1, grande pièce , mais sans surprise je vous ai vu jouer au golf :-)
Quixotic
Vous devez import codecsavant de pouvoircodecs.decode
chat
Vous pouvez supprimer les parens dans la première solution
Cyoce
23

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.

                   $$
                  =-~-
                 ~[];$_
                =$$+ $$;
               _$=$$+$$+-
              ~[];_=-~[];$
             =!![]+[];__={}
            +[];$$_=/\\ /+[]
           _$$=(![]+[])[_]+(!
          []+[])[$$]+$[$_+~[]]
         +$[_]+$[+[]];$=__[_$]+
        __[_]+($[$]+[])[_]+(![]+
       [])[$_+~[]]+$[+[]]+$[_]+$[
      $$]+__[_$]+$[+[]]+__[_]+$[_]
     _=$$_[_]+-~[];$[$][$](_$$+'("'
    +_+-~[]+-[]+_+$_+_$+_+_$+$_+_+_$
   +$_+_+_$+[$$+_$]+$$_[-~[]]+$_+-[]+
  _+$$+[$$+_$]+_+_$+[$$+_$]+_+[$$+$_]+
                $$+ _+_$
                +$_+_+$_
                +$_+'")'
                  )($)
Luciole
la source
Pourriez-vous s'il vous plaît afficher le nombre de caractères de votre code dans l'en-tête? Je suis curieux de voir combien vous en avez eu pour ...
WallyWest
@ Eliseod'Annunzio Voilà, j'ai oublié que c'était du code-golf. La longueur est donnée avec les espaces réduits et le dernier ($)transformé ()(parce que j'ai ajouté $pour la symétrie).
FireFly
Merci pour vos conseils ... J'ai dû redimensionner mon code pour prendre en compte le "W", puis l'a réduit en utilisant vos conseils ...
WallyWest
21

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.

gnibbler
la source
3
Est-ce que rot13 est une langue? : /
Santosh Kumar
3
oui et je peux créer son interprète: P
oddcoder
6
Techniquement, rot13 n'est qu'un chiffre . C'est autant une langue qu'un chiffre de Vigenère.
XiKuuKy
19

Bash, 30 à 25 caractères

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

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

Anon
la source
2
Vous pouvez sauvegarder 5 caractères en utilisant la chaîne here:tr G-t F-s<<<Ifmmp\ Xpsme
Peter Taylor
18

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

Luigi Plinge
la source
18

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.

Bruno Le Floch
la source
1
Wow, je ne savais jamais que TeX pouvait être aussi obscur!
Gar
14

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

Joey
la source
11

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.

Joey
la source
Il y a encore beaucoup de "o" et de "e" ici et un "r". Je ne suis pas sûr que j'aurais beaucoup plus de chance de nettoyer cela, cependant. Peut-être encore avoir à tenter sa chance un jour.
Iszi
Il suffit de relire les règles - il suffisait que deux des trois règles soient remplies, ce qui est admissible. Bon spectacle! Ce serait génial si nous pouvions en trouver un qui prenne 3/3, mais je doute que ce soit très possible.
Iszi
J'ai déjà pris beaucoup de temps pour en arriver à ce point et je doute qu'il soit possible de respecter toutes les règles.
Joey
10

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.

Konrad Borowski
la source
9

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.

res
la source
8

Ruby - 63 personnages

puts [%w{G d k k n},%w{V n q k c}].map{|l|l.map(&:succ)*''}*' '
Nemo157
la source
Pause # 1, cependant
John Dvorak
Et même plus courte: puts "Gdkkn~Vnqkc".split("").map(&:succ)*''- 43
Biketire
7

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.

grep
la source
1
Vous pouvez simplement utiliser des constantes numériques sans 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 caractères.
1
Une veine similaire (en réalité, aborde le problème de différentes manières avant de s’y atteler). x[]={45483*39994-3958,48465*38543-5584,6584695-3333};main(){puts(x);}- 69 caractères. Je suis sûr que je pourrais en économiser un peu plus si je disposais de plus de temps pour mathématiser davantage les littéraux. C'était une façon amusante de passer quelques heures quand même :)
Cole Cameron
7

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.

Konrad Borowski
la source
7

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

Liens:

Utilisateur inconnu
la source
Souhaitez-cela, mais votre réputation est trop mauvaise.
Konrad Borowski
@GlitchMr: Maintenant vous pouvez - j'ai voté en faveur de quelque chose, et vous devriez voir 500N. :)
Utilisateur inconnu
dl.dropbox.com/u/63913412/stilltooleet.png . En outre, les questions de vote négatif ne diminuent pas la réputation. Le vote négatif reste quand même.
Konrad Borowski
@ GlitchMr: Ah, c'est ça! :)
Utilisateur inconnu
6

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.

Hoa Long Tam
la source
6

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
M0sa
la source
Rompre les règles 1 et 2. Vous utilisez le nombre 1 pour les tableaux.
Kevin Brown
Vous pouvez remplacer 1par !![]+![]et 0par ""-""pour ne pas casser la règle n ° 2.
HoLyVieR
Merci @ Bass5098 et @HoLyVieR, j'ai un peu manqué les 1 et 0 pour minimiser le script. J'ai remplacé 0 par z = _-_ et 1 par I = - ~ z, je pourrais aussi utiliser ++ z, mais - ~ est plus joli :)
m0sa
3
Hein? !![]+![]? Pourquoi pas juste 4-3?
Timwi
4
@Timwi: Encore de l'obscurcissement
Thomas Eding
6

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 '*')
Mark Jayxcela
la source
6

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.

Fors
la source
1
J'aime ça, mais malheureusement, il ne satisfait pas à toutes les règles, car il contient le chiffre 7, enfreignant la règle n ° 3. Mais il serait facile de s'en débarrasser 7. De plus, en ajoutant quelques intsecondes, en ajoutant quelques parenthèses supplémentaires et en ajoutant int puts(int*);au début, il compile gcc -ansi -W -Wallavec un seul avertissement: le contrôle atteint la fin de la fonction non-vide .
Pts
5

Bash, 24 à 20 caractères

Vous devez avoir le paquet "bsdgames" installé.

rot13<<<Uryyb\ Jbeyq

Merci gnibbler :)

Veuillez vous lever
la source
5

PostScript, 41 caractères

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

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

KirarinSnow
la source
1
vous pouvez aussi l'exécuter comme:gsnd -q -- filename.ps
luser droog
5

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

DocMax
la source
4
Je lis que R unescape.
Mateen Ulhaq
@MateenUlhaq Je l'ai toujours lu en tant que R unescapeet je n'ai joué que pendant un an, il y a plus de dix ans ... Qu'est-ce qui ne va pas avec moi?
Mwr247
5

Haskell, 38 ans

Les contraintes 1 et 3 ont suivi.

main=putStr$map succ"G\x64kkn\USVnqkc"
Thomas Eding
la source
4

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.

bkul
la source
Woah, je viens juste de réaliser que quelqu'un d'autre a utilisé Fourier: D Nice one, +1
Beta Decay