Crea il programma offuscato più breve possibile che visualizzi il testo "Hello World".

Per essere considerato un programma offuscato, deve soddisfare almeno due dei seguenti requisiti:

• Non contiene i caratteri: h, l, we din ogni caso
• Non contiene i caratteri: e, o, r, 0, e 1in ogni caso
• Non contiene i caratteri: 2o7

Input:
nessuno

Produzione:
Hello World

GolfScript, 17 caratteri

'· S ““?? ß ???? “>' {~}%

Durante il test di questo invio, si prega di salvare il file come binario semplice, non UTF-8. Hai problemi a ricreare il file? Ecco il hexdump di esso:

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

Perl

Dal momento che la risposta ovvia usa uno spostamento di qualche tipo, mi sento obbligato a pubblicare qualcosa usando Acme :: EyeDrops , tuttavia con la potenza extra che pensavo dovesse essere un po 'più divertente.

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

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

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

Avvertimento

Dalla versione 5.18 di Perl, il meccanismo che consente l'esecuzione di questo codice è diventato così potente che è stato disabilitato per impostazione predefinita per impedire l'uso improprio. Pertanto, nelle versioni 5.18+ è possibile aggiungere use re 'eval';all'inizio dello script oppure, se lo script è denominato, world.plè possibile eseguirlo come perl -Mre=eval world.pl. È un peccato che questi personaggi sgradevoli debbano essere aggiunti, ma c'est la vie. (Nota: voglio sottolineare che abilitando questa funzione non si utilizza alcuna libreria o componente aggiuntivo, il codice visualizzato è un codice Perl valido, il meccanismo semplicemente non è più abilitato per impostazione predefinita).

C # (175 caratteri)

È stato piuttosto difficile farlo in C # perché le restrizioni precludono qualsiasi uso di molte delle parole chiave comuni. In C # è possibile utilizzare sequenze di escape Unicode \ uxxxx negli identificatori, ma sfortunatamente non nelle parole chiave.

Sospetto che questa soluzione funzioni solo se compilata su .NET 4.0. Vedi la spiegazione del perché.

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

Spiegazione

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

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

Soddisfa tutte le regole ed è sicuramente offuscato.

Javascript, 2595

Questo infrange solo la regola 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 - blocco 10x9

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

Scusate. : D

Non stavo andando per le piccole dimensioni qui, stavo cercando di OBFUSCARE davvero il codice includendo quante più faccine e rumori possibili! : D

Dovrebbe andare con le regole 2 e 3.

Golfscript - 17 caratteri

Più facile da copiare / incollare di Chris '

'Ifmmp!Xpsme'{(}%

Fondamentalmente una cifra di Cesare che si sposta di 1 carattere

Pitone

Regola I e III (34 caratteri)

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

Regola I e III, alternativa (39 caratteri)

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

Regola II e III (37 caratteri)

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

Regola I e II (50 caratteri)

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

Tutte e tre le regole (58 caratteri)

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

JavaScript, 366 caratteri

Dopo aver visto la soluzione Perl di Joel Berger, mi sono sentito obbligato a fare un po 'di bellezza artistica ASCII da solo ... JavaScript, non usa alfanumerici e, contrariamente all'output di JSFuck, in realtà è di dimensioni ragionevoli.

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

rot13 - 11 caratteri

Uryyb Jbeyq

2019/2/12: questa risposta viene conservata per motivi storici e non è più una risposta valida ai sensi delle attuali regole del sito.

Bash, 30 25 caratteri

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

Grazie a Peter Taylor per il suo utilizzo.

Scala, 39

Soluzioni come print ("Qnuux)` x {um "map (_- 9 toChar)) (35 caratteri) falliscono nelle regole 1 e 2 (" toChar "contiene sia" h "che" r "), il che rende questo un un po 'difficile.

Alla fine è arrivato questo:

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

Suggerimenti per un miglioramento benvenuto

TeX, 95 byte

Rompe la terza regola.

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

Esegui con tex filename.texper ottenere un output DVI o pdftex filename.texper ottenere un pdf.

> <> , 2 × 20 = 40 caratteri

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

Viola la Regola II, dal momento che non posso produrre un personaggio senza usare 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 Regola II.

È molto malvagio che charviola già due regole da solo.

E yike, questo è stato difficile far funzionare.

• La prima riga è impostata $OFSsu ''così quando si esegue il cast di un array in una stringa senza spazi tra gli elementi.
• Fare il casting per chardavvero è stata la parte più difficile di tutte e passo un giorno alla ricerca di un modo. Tutto il resto ha funzionato bene, ma una volta che ho fatto i calcoli su di essi ho ints, non chars. Rimetterli in una stringa era un po 'difficile.

• Ho trovato un modo per invocare Invoke-Expressionsenza aver bisogno eanche del:

  &(gcm i?x)
  

  ma mancavano ancora gli argomenti. E ho già gettato via il mio obiettivo di saturare tutte e tre le regole. Inoltre non mi ha aiutato particolarmente nel casting char.

• Abbreviato un po 'con una versione più recente di PowerShell. Purtroppo, tuttavia, non è emerso un utile modo diverso di creare il risultato.

PHP (16 byte)

Ho notato che il mio precedente esempio di PHP non era abbastanza offuscato, quindi vediamo esempi più palesemente offuscati (attenzione, offuscamento!). Inoltre, copiando palesemente l'esempio di GolfScript, tranne per renderlo più piccolo (è persino possibile?). Questa voce richiede PHP 5.4 o short_open_tagabilitata. Nessuna regola è stata infranta durante questa operazione. In effetti, questa voce non contiene lettere o cifre ASCII.

Questo esempio non infrange nessuna delle regole. Divertiti. Per generare il file, eseguire il comando seguente.

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

Oppure, nel caso in cui non ti fidi dell'esecuzione del printfcomando, ho preparato il dump Base64 del file.

PD89freak5OQ36iQjZObOw==

Se pensi che entrambi i metodi per generarlo rompano le regole, ho anche generato il file su Dropbox .

E per eseguirlo.

php obfus.php

Il file risultante dovrebbe avere 16 byte. Divertiti a gestirlo. Si noti che se sono E_NOTICEabilitati gli avvisi, verrà visualizzato un avviso. Ignoralo e aggiustarlo sprecherebbedue personaggiun personaggio ( @dopo tutto posso usare l' operatore) e renderebbe Base64 meno attraente.

Spazio bianco (167 caratteri)

Per ottenere il programma WS, sostituire un carattere Space, Tab o Linefeed con S, T, L, rispettivamente, nella seguente stringa:

SSSTSSTSSSLTLSSSSSTTSSTSTLTLSSSSSTTSTTSSLTLSSSSSTTSTTSSLTLSSSSSTTSTTTTLTLSSSSSTSSSSSLTLSSSSSTSTSTTTLTLSSSSSTTSTTTTLTLSSSSSTTTSSTSLTLSSSSSTTSTTSSLTLSSSSSTTSSTSSLTLSSLLL

oppure scarica il programma "raw" per soli spazi bianchi nel file di testo hello.ws .

Quando eseguito da questo interprete WS , questo programma stampa "Hello World".

Spiegazione (ignora qui gli spazi bianchi!):

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

Le stringhe "centrali" (ad es. TSSTSSSL) Sono i codici ASCII (in binario, con S0 che Tindica 1 , che indica 1) per le lettere successive in "Hello World". Il prefisso SSSinserisce il numero che lo segue (terminato da un L) nello stack. TLSSgenera il carattere il cui codice ascii è in cima allo stack. Infine, secondo questo tutorial , un programma deve terminare con LLLun'uscita pulita dall'interprete.

NB: Sto inserendo questo come una risposta separata, perché l'altra voce del programma WS è un programma di 1287 caratteri che stampa "Ciao, mondo degli spazi!" invece del richiesto "Hello World".

Rubino - 63 caratteri

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

C, 160 caratteri

Funziona solo su macchine little-endian con int a 4 byte:

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

Soddisfa tutte e tre le regole.

PHP, 28 byte

Non esattamente offuscato, ma molto breve ed evidente :). Dimostrando che anche quando si limitano i caratteri è possibile seguire facilmente i programmi. Seguirono i vincoli 1 e 3. Il vincolo 2 è stato abusato.

<?=str_rot13('Uryyb Jbeyq');

Nota che questo richiede di short_open_tagessere impostato, a meno che tu non stia utilizzando PHP 5.4 o versioni successive. Forse alcuni esempi sono più brevi, ma penso che questo esempio sia piuttosto breve.

bash 28 caratteri:

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

p | MοM ο || ǝH

in alternativa con / bin / echo (18 caratteri) *) vedere la discussione di seguito.

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

Test di autoverifica:

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

Più duro di teppista! Strumenti, per capovolgere le parole, gli strumenti pensano che una 'H' o 'o' capovolta sia meglio visualizzata come H o o. Ciò sarebbe in conflitto con il gruppo 1 (Hlwd: 27: eor01) rispettivamente 3.

H può essere visualizzato con

echo -e "\0127"

ma anche 01 e 2 sono avvelenati. Gee! Ma l'eco bash-buildin non ha solo la possibilità di visualizzare valori ascii ottali, ma anche esadecimali:

echo -e "\x48"

Ma se usiamo bash come linguaggio di programmazione, il comando echo fa parte del programma, che non solo conta per il conteggio dei caratteri, ma contiene anche i caratteri avvelenati (hlwd: 27: eor01) eho dei gruppi 1 e 3.

Quindi questo è il momento in cui l'eco è morta. Fortunatamente, c'è printf, che conosce "% b" da visualizzare.

R è l'unico personaggio problematico in printf e appartiene al gruppo 3. Dato che 'o' è nell'ultimo gruppo, potremmo lasciarlo in Hello and in World, ma possiamo usare l'omicron ο che assomiglia a una o, oppure ° °.

link:

• strumento capovolto 1
• secondo strumento capovolto

C (94)

Su piccole macchine Endian:

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

Viola la regola II, ma soddisfa il resto.

JavaScript - 132 caratteri

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

Regola di infrazione I

Utilizzo :

• Incolla "javascript: [script]" nella barra degli indirizzi del browser
• Crea una pagina html vuota, incolla lo script in un tag

Dis , 102 83 caratteri

Srotolato il ciclo del codice poiché le lettere possono essere generate con meno di cinque operazioni consecutive. Hai salvato alcuni caratteri riutilizzando il valore dell'accumulatore: due lsono consecutivi, SPACEpossono essere generati oe dgenerati da l.

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

Vecchia versione

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

Con i commenti qui sotto. Sta usando una sequenza di cinque operazioni identiche per generare tutti i caratteri in Hello World: una rotazione e quattro sottrazioni.

^     (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 caratteri (escluse le nuove righe non necessarie)

Ho optato per la leggibilità e la trasparenza durante la scrittura di questo.

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

Soddisfa tutti e tre i requisiti.

Bash, 24 20 caratteri

Devi aver installato il pacchetto "bsdgames".

rot13<<<Uryyb\ Jbeyq

Grazie gnibbler :)

PostScript, 41 caratteri

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

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

JavaScript, 66 caratteri

Un'altra soluzione JavaScript, questa volta infrangendo la regola # 2.

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

Quanto sopra segue il concetto alla base della risposta di Hallvabo. Prima di afferrare quell'approccio, avevo la versione probabilmente più offuscata:

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

che infrange anche la regola n. 2 e arriva a 114 caratteri. (Rimuovere il ritorno a capo in questa seconda soluzione in quanto è lì solo per la leggibilità.)

Haskell, 38

Seguirono i vincoli 1 e 3.

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

Fourier, 39 byte

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

Fourier è sempre offuscato. Questo segue tutte le regole.

Abbattersi:

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.

Questo potrebbe forse essere raffinato un po '.