Utwórz możliwie najkrótszy zaciemniony program, który wyświetla tekst „Hello World”.

Aby zostać uznanym za zaciemniony program, musi spełniać co najmniej dwa z następujących wymagań:

• Nie zawiera znaki: h, l, wi dw każdym przypadku
• Nie zawiera znaki: e, o, r, 0, i 1w każdym przypadku
• Nie zawiera znaków: 2lub7

Wejście:
brak

Wynik:
Hello World

GolfScript, 17 znaków

'· Š „„ ?? ߨ ???? „› ”{~}%

Podczas testowania tego zgłoszenia proszę zapisać plik jako zwykły plik binarny, a nie UTF-8. Masz problem z odtworzeniem pliku? Oto zrzut heksowy:

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

Perl

Ponieważ oczywista odpowiedź wymaga jakiegoś przesunięcia, czuję się zobowiązana do opublikowania czegoś przy użyciu Acme :: EyeDrops , jednak z dodatkową mocą, którą moim zdaniem powinna być trochę fajniejsza.

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

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

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

Zastrzeżenie

Od wersji 5.18 Perla mechanizm pozwalający na uruchomienie tego kodu stał się tak potężny, że został domyślnie wyłączony, aby zapobiec niewłaściwemu użyciu. Dlatego w wersjach 5.18+ możesz albo dodać use re 'eval';do początku skryptu, albo, jeśli skrypt jest nazwany world.pl, możesz go uruchomić w podobny sposób perl -Mre=eval world.pl. To niefortunne, że te brzydkie postacie muszą zostać dodane, ale c'est la vie. (Uwaga: chcę podkreślić, że włączenie tej funkcji nie wymaga użycia biblioteki lub dodatku, wyświetlany kod jest prawidłowym kodem Perla, mechanizm po prostu nie jest już domyślnie włączony).

C # (175 znaków)

Wykonanie tego w języku C # było sporym wyzwaniem, ponieważ ograniczenia wykluczają jakiekolwiek użycie często używanych słów kluczowych. W języku C # możliwe jest użycie \ uxxxx sekwencji ucieczkowych Unicode w identyfikatorach, ale niestety nie w słowach kluczowych.

Podejrzewam, że to rozwiązanie działa tylko po skompilowaniu z .NET 4.0. Zobacz wyjaśnienie dlaczego.

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

Wyjaśnienie

// 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 uderzeń

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

Spełnia wszystkie zasady i na pewno jest zaciemniony.

JavaScript, 2595

To tylko łamie zasadę 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 - blok 10x9

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

Przepraszam. :RE

Nie zamierzałem tutaj robić małych rozmiarów, starałem się naprawdę OBFUSCATE kod, włączając jak najwięcej uśmiechniętych buziek i hałasu! :RE

Powinny być zgodne z regułami 2 i 3.

Golfscript - 17 znaków

Łatwiej skopiować / wkleić niż Chris

'Ifmmp!Xpsme'{(}%

Zasadniczo przesunięcie szyfru cesarskiego o 1 znak

Pyton

Reguła I i III (34 znaki)

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

Reguła I i III, alternatywa (39 znaków)

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

Reguła II i III (37 znaków)

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

Reguła I i II (50 znaków)

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

Wszystkie trzy zasady (58 znaków)

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

JavaScript, 366 znaków

Po zobaczeniu rozwiązania Perla Joela Bergera poczułem się zmuszony, by sam zrobić trochę piękna ASCII ... JavaScript, nie używa alfanumerycznych i w przeciwieństwie do wyjścia JSFuck jest właściwie rozsądny.

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

rot 13 - 11 znaków

Uryyb Jbeyq

2019/2/12: Ta odpowiedź jest przechowywana z powodów historycznych i nie jest już prawidłową odpowiedzią zgodnie z obowiązującymi zasadami witryny.

Bash, 30 25 znaków

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

Z podziękowaniami dla Petera Taylora za użycie sznurka.

Scala, 39

Rozwiązania takie jak print (mapa „Qnuux)„ x {um ”(_- 9 toChar)) (35 znaków) nie spełniają reguł 1 i 2 („ toChar ”zawiera zarówno„ h ”, jak i„ r ”), co sprawia, że ​​jest to trochę trudne.

Wreszcie wymyślił:

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

Sugestie dotyczące ulepszeń mile widziane

TeX, 95 bajtów

Łamie trzecią zasadę.

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

Uruchom z, tex filename.texaby uzyskać wyjście DVI lub pdftex filename.texplik PDF.

> <> , 2 × 20 = 40 znaków

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

Narusza Regułę II, ponieważ nie mogę wydać postaci bez użycia o.

Windows PowerShell, 91 95 97 98

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

Narusza tylko zasadę II.

To bardzo złe, które już samo charnarusza dwie zasady.

I tak, ten ciężko pracował.

• Pierwsza linia ustawia $OFSsię ''tak podczas rzucania tablicę na ciąg znaków bez spacji między pojawiają przedmiotów.
• Przesyłanie do charfaktycznie było najtrudniejsze ze wszystkich i spędziłem około dnia na poszukiwaniu sposobu. Cała reszta działała ładnie, ale kiedy wykonam na nich obliczenia, mam, inta nie chars. Umieszczenie ich z powrotem w sznurku było trochę trudne.

• Znalazłem sposób na wywołanie Invoke-Expressionbez potrzeby e:

  &(gcm i?x)
  

  ale wciąż brakowało argumentów. Do tego czasu odrzuciłem swój cel, jakim jest spełnienie wszystkich trzech zasad. Nie pomogło mi to również w castowaniu do char.

• Trochę skrócono dzięki nowszej wersji PowerShell. Niestety nie pojawił się żaden użyteczny inny sposób tworzenia wyniku.

PHP (16 bajtów)

Zauważyłem, że mój poprzedni przykład PHP nie był wystarczająco zaciemniony, więc zobaczmy bardziej rażąco zaciemnione przykłady (ostrzeżenie, zaciemnianie!). Również rażąco kopiuje przykład GolfScript, z wyjątkiem zmniejszania go (czy to w ogóle możliwe?). Ten wpis wymaga PHP 5.4 lub jest short_open_tagwłączony. Dokonując tego, nie złamano żadnej zasady. W rzeczywistości ten wpis nie zawiera żadnych liter ani cyfr ASCII.

Ten przykład nie łamie żadnej reguły. Baw się dobrze. Aby wygenerować plik, uruchom następujące polecenie.

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

Lub, jeśli nie ufasz uruchomieniu printfpolecenia, przygotowałem zrzut pliku Base64.

PD89freak5OQ36iQjZObOw==

Jeśli uważasz, że obie metody generowania go łamią reguły, wygenerowałem również plik na Dropbox .

I żeby to uruchomić.

php obfus.php

Wynikowy plik powinien mieć 16 bajtów. Miłej zabawy. Pamiętaj, że jeśli masz E_NOTICEwłączone ostrzeżenia, pojawi się powiadomienie. Po prostu zignoruj ​​to, naprawienie go zmarnujedwie postaciejedna postać (w końcu mogę użyć @operatora) i sprawiłaby, że wynikowy Base64 wyglądałby mniej niesamowicie.

Biała spacja (167 znaków)

Aby uzyskać program WS, zamień odpowiednio znaki S, T, L na spację, tabulator lub liniowy w następującym ciągu:

SSSTSSTSSSLTLSSSSSTTSSTSTLTLSSSSSTTSTTSSLTLSSSSSTTSTTSSLTLSSSSSTTSTTTTLTLSSSSSTSSSSSLTLSSSSSTSTSTTTLTLSSSSSTTSTTTTLTLSSSSSTTTSSTSLTLSSSSSTTSTTSSLTLSSSSSTTSSTSSLTLSSLLL

lub pobierz „surowy” program tylko do białych znaków w pliku tekstowym hello.ws .

Po uruchomieniu przez tego interpretera WS , program ten wypisuje „Hello World”.

Objaśnienie (zignoruj ​​tutaj białe znaki!):

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

„Środkowe” ciągi znaków (np. TSSTSSSL) To kody ascii (binarnie, z Soznaczeniem 0, Toznaczeniem 1) dla kolejnych liter w „Hello World”. Prefiks SSSwypycha następującą po nim liczbę (zakończoną znakiem an L) na stos. TLSSwypisuje znak, którego kod ascii znajduje się na górze stosu. Wreszcie, zgodnie z tym samouczkiem , program musi kończyć LLLsię czystym wyjściem przez tłumacza.

NB: Podaję to jako osobną odpowiedź, ponieważ druga pozycja programu WS to program o długości 1287 znaków, który wypisuje „Witaj, świecie przestrzeni!” zamiast wymaganego „Hello World”.

Ruby - 63 znaki

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

C, 160 znaków

Działa tylko na maszynach little-endian z 4-bajtowym 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);}

Spełnia wszystkie trzy zasady.

PHP, 28 bajtów

Nie do końca zaciemnione, ale bardzo krótkie i oczywiste :). Pokazując, że nawet przy ograniczaniu znaków możesz bardzo łatwo śledzić programy. Przestrzegano ograniczeń 1 i 3. Ograniczenie 2 zostało naruszone.

<?=str_rot13('Uryyb Jbeyq');

Pamiętaj, że wymaga short_open_tagto ustawienia, chyba że używasz PHP 5.4 lub nowszego. Może niektóre przykłady są krótsze, ale myślę, że ten przykład jest dość krótki.

bash 28 znaków:

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

p | MοM ο || ǝH

alternatywnie z / bin / echo (18 znaków) *) patrz dyskusja poniżej.

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

Autotest:

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

Trudniej niż myślisz! Narzędzia do obracania słów do góry nogami, narzędzia uważają, że „H” lub „o” odwrócony do góry nogami najlepiej wyświetla się jako H lub o. Byłoby to w konflikcie z grupą 1 (Hlwd: 27: eor01) odpowiednio 3.

H można wyświetlić za pomocą

echo -e "\0127"

ale 01 i 2 są również zatrute. Ojej! Ale echo kompilacji bash ma nie tylko opcję wyświetlania ósemkowych wartości ascii, ale także szesnastkową:

echo -e "\x48"

Ale jeśli użyjemy bash jako języka programowania, polecenie echo jest częścią programu, który nie tylko liczy się do liczby znaków, ale także zawiera zatrute znaki (hlwd: 27: eor01) eho z grup 1 i 3.

To jest moment, w którym echo umarło. Na szczęście istnieje printf, który zna „% b” do wyświetlenia.

R jest jedyną problematyczną postacią w printf i należy do grupy 3. Ponieważ „o” jest w ostatniej grupie, moglibyśmy zostawić go w Hello i in World, ale możemy użyć omicronu ο, który wygląda jak o, lub ° °.

Spinki do mankietów:

• narzędzie do góry nogami 1
• drugie narzędzie do góry nogami

C (94)

Na małych komputerach Endian:

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

Narusza regułę II, ale spełnia resztę.

JavaScript - 132 znaki

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

Łamie zasadę I.

Zastosowanie :

• Wklej „javascript: [script]” w pasku adresu przeglądarki
• Utwórz pustą stronę HTML, wklej skrypt do tagu

Dis , 102 83 znaków

Rozwinięto pętlę kodu, ponieważ litery można wygenerować za pomocą mniej niż pięciu kolejnych operacji. Zapisano kilka znaków, ponownie wykorzystując wartość akumulatora: dwa lsą kolejno, SPACEmogą być generowane z oi dmogą być generowane z l.

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

Stara wersja

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

Z komentarzami poniżej. Używa sekwencji pięciu identycznych operacji do wygenerowania wszystkich znaków Hello World: jeden obrót i cztery odejmowania.

^     (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 znaków (bez niepotrzebnych znaków nowej linii)

Podczas pisania wybrałem czytelność i przejrzystość.

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

Spełnia wszystkie trzy wymagania.

Bash, 24 20 znaków

Musisz mieć zainstalowany pakiet „bsdgames”.

rot13<<<Uryyb\ Jbeyq

Dzięki gnibbler :)

PostScript, 41 znaków

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

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

JavaScript, 66 znaków

Kolejne rozwiązanie JavaScript, tym razem łamiące zasadę nr 2.

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

Powyższe jest zgodne z ideą stojącą za odpowiedzią hallvabo. Zanim przyjąłem to podejście, miałem znacznie bardziej zaciemnioną wersję:

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

co również łamie zasadę nr 2 i występuje przy 114 znakach. (Usuń powrót karetki w tym drugim rozwiązaniu, ponieważ jest ono tam tylko dla czytelności).

Haskell, 38

Przestrzegano ograniczeń 1 i 3.

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

Fourier, 39 bajtów

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

Fourier jest zawsze zaciemniony. Jest to zgodne ze wszystkimi zasadami.

Awaria:

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.

Można to trochę ulepszyć.