Dane wejściowe nie mogą być wymagane, a dane wyjściowe muszą zawierać tekst „ All your base are belong to us”.

Ograniczenia

• Brak zasobów zewnętrznych.

  Plus co najmniej dwa z poniższych:

• W żadnym wypadku nie możesz używać „a”, „b”, „t”, „u” ani „y” w kodzie (premia -10 do wyniku golfa, jeśli możesz to zrobić)

• Nie możesz w żadnym wypadku używać kodu „l”, „o”, „s”, „e” lub „r” (bonus -20 do wyniku golfa, jeśli możesz to zrobić)

• Nie możesz w żadnym wypadku używać kodu „n”, „g”, „0”, „1” lub „2” (jeśli to możliwe, premia -30 do wyniku golfa)

Na przykład, jeśli uda ci się wykonać kod z 40 znakami i użyjesz reguł 1 i 2, twój wynik w golfa wynosi 40 - 10 - 20 = 10 znaków.

Wygrywa najmniejszy wynik golfowy kod ... Powodzenia!

SOGL V0.12 , 15–60 = -45

šz█P'zUS½█│β3‘⁾

Wypróbuj tutaj!

šz█P'zUS½█│β3‘Jest to skompresowany ciąg all your base are belong to us, ale dlatego, że dokładny ciąg sprężone zawarte 0, to podzielone na 3 części: all your base are, , belong to us(który kosztował jeden bajt, ale dał premię -30 bajtów). Pierwszy i ostatni ciąg są kompresowane ze słownikiem angielskim SOGL i domyślnie łączone spacjami. Pozostała część ⁾jest prostym wbudowanym przypadkiem zdania.
Pamiętaj, że SOGL publikuje datę tego wyzwania, ale jest to dozwolone teraz.

GolfScript, -22 (38 znaków, -60 bonus)

"„¯¯c¼²¸µc¥¤¶¨c¤µ¨c¥¨¯²±ªc·²c¸¶"{67-}%

Sclipting , −40

뀖롬긇땯덗긠눦굳뉒걡댦넠눦녬닶멧긇끯긇녳

• = 20 znaków - 60 premii
• Działa tylko wtedy, gdy dane wejściowe są puste, co uważam za przypadek; jeśli nie, dodaj 丟z przodu, zmieniając wynik na -39.
• Jeśli mogę założyć, że dane wejściowe są tym, czego chcę (jak najwyraźniej robi to odpowiedź ), to pusty program jest rozwiązaniem, a mój wynik to -60.

JavaScript - 140 bajtów - 60 premii = 80 punktów

(x="Ǎľľ y̌ǒǔř b̌ǎšě ǎřě b̌ěľǒňǧ ťǒ ǔš")[x[3*9]+x[34]+"p"+x[4]+x[5*5]+"c"+x[34]]("̌","",x[6*7])

Uruchom w przeglądarce Firefox.

Wiem, o czym myślisz. Nie, to nie są znaki wymienione w pytaniu. Są to postacie z karonem lub háčkiem (wybierane losowo z listy znaków diakrytycznych). Mimo że łączą znaki, nie są dwiema osobnymi postaciami.

APL (43–30–20 = -7)

⎕AV['⊥┤┤ ø┼&┐ `∣┘û ∣┐û `û┤┼─ù ´┼ &┘'⍳⍨⌽⎕AV]

Spełnia to zasady 2 i 3.

Brainfuck, 267 - 60 = 207

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

HTML / CSS 70

<p style="transform:rotate(.5turn)">sn oʇ ƃuoləq əɹɐ əsɐq ɹnoʎ llɐ</p>

http://jsbin.com/EjekuvuF/1/

Pomyślałem, że jestem sprytny z typem do góry nogami, ale potem zdałem sobie sprawę, że nie jestem w stanie spełnić żadnej z pomocniczych reguł z faktycznym HTML / CSS. No cóż.

AKTUALIZACJA:

Użytkownik Flame zasugerował rozwiązanie bardziej zgodne z różnymi przeglądarkami:

<p style="transform:rotate(180deg)">sn oʇ ƃuoləq əɹɐ əsɐq ɹnoʎ llɐ</p>  

http://jsbin.com/EjekuvuF/6

MATLAB, Wszystkie bonusy: Wynik -20 (40-60)

['' '¤ÏÏèÜÒØÕèÅÄÖÈèÄÕÈèÅÈÏÒÑÊè×ÒèØÖ'-99]

EDYTOWAĆ:

Pamiętaj, że nie jestem pewien, jakie są wymagania systemowe, aby to uruchomić, przetestowane w systemie Windows. Dla tych, którzy próbują kopiować, można wygenerować podobny kod:

char('All your base are belong to us' + 99)

Gdyby można było prosić o cokolwiek jako dane wejściowe, oczywiście byłoby możliwe rozwiązanie z mniejszą liczbą postaci (ale także z brakiem premii).

input('')

k (-7 = 53 - 60)

(#`)"c"$(465%3)-6h$"Z//{\",&){9:(6{:)6{96/,-4{',{&(";

nie zawiera końcowego nowego wiersza, można go dodać kosztem jednego dodatkowego znaku:

(-#`)"c"$(465%3)-6h$"Z//{\",&){9:(6{:)6{96/,-4{',{&(";

irytujące, jedyne przesunięcia, które działają dla tej lewy to 154 i 155

edytować:

jeśli wystarczy wyświetlić ciąg (zamiast go wydrukować), jak podejrzewam, że działa rozwiązanie APL (nie działa w http://tryapl.com/ , więc nie mogę go poprawnie przetestować), to

  "c"$(465%3)-6h$"Z//{\",&){9:(6{:)6{96/,-4{',{&("
"All your base are belong to us"

czyli -12 = 48 - 60. czy mogę uzyskać orzeczenie, czy to wystarczy?

dc, 97 - 60 = 37 91 - 60 = 31 88 - 60 = 28 81 - 60 = 21

3C87596P4d^8/P7958389P7479394P6386533P7C89P749698CP644848CP459 8^699 7^3849736388974773333 86-++P

Ulepszona wersja (głównym pomysłem jest tutaj zróżnicowanie bazy danych wejściowych, aby zwiększyć szanse na znalezienie przydatnej dużej liczby bez problematycznych cyfr):

IDi67793554D647F84C836645D6569F69Pi6385C77P9i35PDdi6^I9^+6D59CD83D664D34+P8CPFi98CCF5PCi97P

W bazie 7 całość może stać się pojedynczą liczbą! Dolne podstawy są naturalnie mniej kompaktowe, ale nadrabia to brak operacji naprawczych.

7i4398873968644388737548444897643735447698675366869556798538985674336396359936458859886P

Moje pierwsze rozwiązanie stosowane podstawa 10. Mój drugi używany mieszankę podstawą 9, 10, 12, 13 i 15. Ten jest w bazie 7. Ja naprawdę czuję jak cała baza są należą do mnie.

Ostatni, poważnie: baza 13 wykonuje świetną robotę w pierwszym segmencie, a następnie baza 7 w pozostałej części.

Di67793554D647F84C836645D6569F69P7i798789699638355733695878558396339387963789536P

Python REPL, 122 116 98 znaków - 30 bonusów = 92 86 68 punktów

>>> '\x41\x6c\x6c \x79\x6f\x75\x72 \x62\x61\x73\x65 \x61\x72\x65 \x62\x65\x6c\x6fng \x74\x6f \x75\x73'

'All your base are belong to us'

Mogłem pozbyć się zer w Pythonie 3.3, zastępując „ \40” \N{SP}, ale niestety Nnie jest to dozwolone.

Edycja : Zainspirowany tą odpowiedzią skróciłem ją dalej, zastępując \x40ją . Ponadto, ponieważ ja już używać 1, zastępując \156przez ni \x67przez gskrócenie go o kolejne 6 znaków podczas ponoszenia żadnych dodatkowych kary.

Brainfuck, 205 203 - 60 = 145 143 bajtów

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

Wersja do odczytu:

++++[->++++<]>[->++++>++>+++++++>++++++>++++++++<<<<<]
64 32 112 96 128

>+.>>----..<.                     All                 65 108 108  32
>>>-------.<<+++.>>----.---.<<<.  your           121 111 117 114  32
>>++.-.>+.<++++.<<.               base            98  97 115 101  32
>>----.>-.<++++.<<.               are                 97 114 101  32
>>---.+++.<---.>>---.-.<<-----.<. belong  98 101 108 111 110 103  32
>>>++++++.-----.<<<.              to                     116 111  32
>>>++++++.--.                     us                     117 115

Befunge 98: 122 - 60 = 62

5f8+*:53-+:' \6-:5+' 91+:*3+::7+\8+:3-:7-:3-:' \3+::3-4+',' -+\4-:' \:4+\6+c+:f3+-:4+3-' '&3*:3+:6-:f+5-:' \d-:' '!+ff+k,@

Oblicza wartości ascii, a następnie je drukuje. Nadal muszę wypróbować inne metody formowania liczb, aby sprawdzić, czy istnieją krótsze sposoby.

Python, 195–40 = 155

x,w,y,z,v=4*8,55,56,57,58;exec(("%c"*38)%(y+y,z+z,49+y,w+w,v+v,39-7,34,65,54+54,54+54,x,v+63,48+63,48+69,z+z,x,98,97,59+y,45+y,x,97,z+z,45+y,x,98,45+y,54+54,w+y,w+w,45+v,x,v+v,w+y,x,v+59,z+v,34))

Rubin, 121-50 = 71

Trochę brutalnej siły, ale większość uroczych metod jest wykluczona:

$><<[65,c=36*3,c,d=8*4,363/3,f=c+3,c+9,c+6,d,x=98,97,j=c+7,k=3+x,d,97,c+6,k,d,x,k,c,f,j-5,5+x,d,c+8,f,d,c+9,j].pack('C*')

Łamie zasadę nr 1 z powodu wejścia A pack, pozostałe dwa powinny być w porządku.

{ba, z} sh, 67 - 40 72 - 60 61 - 40 = 21

$'\x74r' K-~\#-\; _@-~\^-j<<<'Mxx ){%~ 3m#q m~q 3qx{z8 ${ %#'

Cholera, okazuje się, że miałem rtam coś, czego nie zauważyłem, więc bonus 20 nie ma zastosowania!

C, 75 bajtów - 60 = 15

Dzięki @gastropner za obniżenie wyniku z 50 do 33 i z 19 do 15!

*q,i;f(p){(*(q=p)="\v&&j3%?8j(+9/j+8/j(/&%$-j>%j?9J"[i++]^74)?i=!f(++p):i;}

Pobiera na wejściu adres tablicy char i zapisuje ciąg do tablicy.

Wypróbuj online!

Zadzwoń z:

int main()
{
    char s[128];
    f(s);
    puts(s);
}

Wynik:

Stara wersja (90 bajtów - 40 = 50):

*q,i,j;f(p){for(i=3-3;j="Epp$}s v$fewi$evi$fipsrk$xs$ w"[i++];*q=j!=35-3?j-4:353/3)q=p++;}

JavaScript

(306 znaków - 60 bonus = 246) (206 znaków - 50 bonus = 156)

(123 znaki = 173 znaki - 50 bonusów)

Niby nooby, prawdopodobnie może uzyskać więcej ... Daj mi znać, jeśli coś wypchnąłem, to ostrzega: „Cała twoja baza należy do nas”. Dotyczy to również ASCII.

(c=(''+!'')[4-3],x=([][3]+c)[6])[a='c\x6F'+x+'\x73t'+c+'uct\x6F'+c][a]('a\x6C\x65'+c+'t("A\x6C\x6C y\x6Fu'+c+' ba\x73\x65 a'+c+'\x65 b\x65\x6C\x6F'+x+'\x67 t\x6F u\x73")')()

Jeśli policzysz samą konsolę jako dane wyjściowe, to też się liczy (57 z bonusem):

'A\x6C\x6C y\x6Fu'+(c=(''+!'')[4-3])+' ba\x73\x65 a'+c+'\x65 b\x65\x6C\x6F'+([][3]+c)[6]+'\x67 t\x6F u\x73'

Brainfuck, (227 - 60 = 167)

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

PHP (35–60 = -25 bajtów)

HOW LOW CAN YOU GET ?^{[1] [2]}

$ xxd yourbase.php 
0000000: 3c3f 3d7e be93 93df 8690 8a8d df9d 9e8c  <?=~............
0000010: 9adf 9e8d 9adf 9d9a 9390 9198 df8b 90df  ................
0000020: 8a8c 3b                                  ..;

^{[1] Ten program można odkodować za pomocą xxd -r.
[2] Tak, ciężkie rozwiązanie ponownie tutaj. Myślę, że to ... trzeci problem, który rozwiązałem w ten sposób. Być może powinienem przejść do czegoś innego, ale to nie jest tak, że nie jest to świetne w przypadku problemów, które zabraniają ci używania większości postaci.}

Bash, 52-10-30 = 12

Poniższe należy wykonać w (wciąż dość powszechnym) środowisku ISO-8859-1:

$'\x74r' À-þ  @-~<<<'Áìì ùïõò âáóå áòå âåìïîç ôï õó'

To wywołuje tr, co tłumaczy znaki w odpowiedni sposób. Musiałem albo użyć ri złamać zasadę 2, albo użyć cyfry w ucieczce i złamać zasadę 3. Ponieważ 3 daje więcej premii, wybrałem tę pierwszą.

Pure Bash (bez zasobów zewnętrznych), 141 znaków - 50 bonusów = 91

Z = ({k..v})
f = $ '\ x65'
h = $ '\ x6c'
i = $ '\ x6f'
j = $ {Z [7]}
k = $ '\ x73'
m = $ '\ x75'
$ f $ '\ x63'h $ i A $ h $ hy $ i $ m $ j ba $ k $ fa $ j $ fb $ f $ h $ i $ {Z [3]} $' \ x67 't $ iu $ k

Celowe upuszczenie 10-punktowej premii, aby uzyskać lepszy ogólny wynik.

Działa to na każdej bashwersji 3.00.15 lub nowszej, której próbowałem.

Jak to działa

Nie ma tu nauki o rakietach - po prostu bashrozszerzenia takiej czy innej formy:

• Proste rozwinięcie heksów w celu uzyskania wymaganej postaci. Działa to dla znaków, których reprezentacja szesnastkowa nie zawiera [012]. np. $'\x65'daje name
• W przypadku innych znaków generujemy tablicę skrótów znaków sekwencyjnych, stosując rozwinięcie nawiasu klamrowego do inicjalizacji tablicy ( Z=({k..v})). Początek rozszerzenia nawiasu jest wybierany ostrożnie, aby indeksy wymaganych przez nas znaków nie zawierały [012]. np. ${Z[7]}daje nam r.
• bashjest wystarczająco elastyczny, aby umożliwić konstruowanie jego poleceń z zawartości wielu ciągów. Tak $f$'\x63'h$irozszerza się echo.
• W przypadku znaków, które są wymagane tylko raz, rozwinięcie jest wstawiane w wierszu polecenia echo.
• W przypadku znaków, które są wymagane dwa lub więcej, bardziej efektywne jest rozwinięcie ich do zmiennych, a następnie odwołanie się do zmiennych.

Poprzednia odpowiedź z pełnym bonusem, ale gorszym wynikiem ogólnym:

Pure Bash (bez zasobów zewnętrznych), 193 znaków - 60 premii = 133

Wiem, że to nie wygra, ale chciałem udowodnić sobie, że jest to możliwe bash, jednocześnie spełniając wszystkie wymagania:

Z = ({3..8} {C..z})
c = $ {Z [36]}
d = $ {Z [37]}
f = $ '\ x65'
h = $ '\ x6c'
i = $ '\ x6f'
j = $ {Z [53]}
k = $ '\ x73'
m = $ '\ x75'
$ f $ '\ x63'h $ i $ {c ^} $ h $ h $' \ x79 '$ i $ m $ j $ d $ c $ k $ f $ c $ j $ f $ d $ f $ h $ i $ {Z [49]} $ '\ x67' $ '\ x74' $ i $ m $ k

To wymaga dość najnowszej wersji bashdla ${c^}ekspansji parametrów. 4.2.25 jest w porządku, ale 3.2.48 nie da rady.

Postscriptum, 364 - 40 = 324

Oczywiście nie mógłbym tego zrobić loser. :)

/${cvx exec}def
/+{<3C7E4F6F597E3E>$ $}def
/*{<~P&(~>$}def
/-{( )<3C7E4F754E7E3E>$ $ 3 4<~P#;~>$ 4 3<~P)#3FP'-~>$}def
/_{36(      )<~OoP~><3C7E4F754E7E3E>$ $ 4 3<~P,S~>$ 48<~P'?~>$
${96 3<~P#;~>$ + -}<~P">~>$}def
/.{_ 96 3<~P#;~>$ -}def
65 - 777 .
895 353 + _ 774 333 + .
74933 333 + 7 * 3 + 333 + .
9593 4353 + .
689653949 335 + .
735 333 + .
775 333 + _ 5 5 + -

Zaczyna się od kodowania tekstu jako ciągów base-36:

%-=Encoding strings as base-36 numbers=-
%All your base are belong to us
% handle uppercase A separately
%36#ll = %777
%36#your = %1618515
%36#yo = 36#ur = 36#base = 36#are = 36#belong = 36#to = 36#us =
%1248 1107 527198 13946 689654284 1068 1108

A następnie arytmetycznie usuwając jedynki i jedynki oraz jedynki. Ciągi mogą być następnie zregenerowane 36 <string-buf> cvrs, ale daje to duże litery, więc musimy iterować i dodać 0x20, aby były małe.

Operatory cvx execpozwalają nam wykonywać fragmenty łańcuchów tokenów operatora kodowanych binarnie w różnych kodowaniach. Najprostszym jest zakodowanie operatora w trybie szesnastkowym, <92??>ale jest tam 2! Tak więc kodowanie „pierwszego poziomu” to ascii85. Następnie wszelkie ciągi znaków, które nadal zawierały zabronione znaki, przechodziły dodatkowe poziomy hex -> ascii85 -> hex -> ascii85.

Brainfuck, 306 - 60 = 246

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

PHP, 186–10–30 = 146

Musiałem być trochę kreatywny;)

 <?=chr(65).'ll '.chr(88+33).'o'.chr(39*3).'r '.chr(98).chr(97).'s'.chr(68+33).' '.chr(97).chr(38*3).chr(68+33).' '.chr(98).'elo'.chr(77+33).chr(69+34).' '.chr(83+33).'o '.chr(39*3).'s'?>

Python, 181–40 = 141

[Używam wersji 2.7.2 YMMV - wbudowanej, filenie ma jej w Pythonie 3.X]

f=file.__doc__;c=5-3;l=f[c];s=' ';e=f[3];h=f[6+7];i=f[c*87];j=3**3;f[j*c*5]+l+l+s+f[-57]+h+f[j-7]+f[j-3]+s+f[j-8]+f[6]+i+e+s+f[6]+f[j-3]+e+s+f[j-8]+e+l+h+f[5]+f[j]+s+f[45]+h+s+f[j-7]+i

Python (104-30 = 74)

>>> '\x41\x6c\x6c \x79\x6f\x75\x72 \x62\x61\x73\x65 \x61\x72\x65 \x62\x65\x6c\x6f\156\x67 \x74\x6f \x75\x73'
'All your base are belong to us'

I ocena:

>>> len(r"'\x41\x6c\x6c \x79\x6f\x75\x72 \x62\x61\x73\x65 \x61\x72\x65 \x62\x65\x6c\x6f\156\x67 \x74\x6f \x75\x73'")-30
74

Świnka, 150–60 = 90. 40 = 110

S J=" ",Z=36*3,C=37*3,D=38*3,Q=39*3,I=35*3-4 W *65,*Z,*Z,J,*484/4,*C,*Q,*D,J,*98,*97,*C+4,*I,J,*97,*D,*I,J,*98,*I,*Z,*C,*D-4,*Z-5,J,*C+5,*C,J,*Q,*C+4

Nie jestem pewien, czy można by to zrobić krócej (ogólnie), nie otrzymując jednego z bonusów kodowych - moim celem było trochę mniej w przypadku krótkości i nieco więcej w przypadku -60 ... Podobało mi się wyzwanie nieużywania dowolny z ograniczonych znaków.

I ... poprawiłem to - przegapiłem początkowe polecenie „S”. : - /

Tak czy inaczej, oto wersja „bez reguł” - rozszerzanie zmiennych.

W *65,*36*3,*36*3," ",*484/4,*37*3,*39*3,*38*3," ",*98,*97,*37*3+4,*35*3-4," ",*97,*38*3,*35*3-4," ",*98,*35*3-4,*36*3,*37*3,*38*3-4,*36*3-5," ",*37*3+5,*37*3," ",*39*3,*37*3+4

A to daje wynik 177-60 = 117. Więc złamanie reguły środkowej wciąż dawało mi niższy ogólny wynik.

Perl 5, 99-50 = 49

Podprogram, który zwraca wymagany ciąg:

{A.($c=h|d)."$c y".($f=f|k).u.($k=p|b)." ba".($j=c|p).($d=d|a)." a$k$d b$d$c$f".(jf|fc)." t$f u$j"}

Zobacz wydrukowane w ten sposób:

perl -e'print sub{...}->().$/'

BF-RLE , 146–30 = 116

+5[>+5<-]>+.<+4[>+3<-]>+..>>+3[<+2>-]<++.<+A.-7.+3.-0.>.<<+1[>-1<-]>.-.<+0[>+3<-]>.-B.>.<-1.<+1[>+1<-]>+.-A.>.<-0.+0.+4.+0.-.-4.>.<+A.-2.>.<+3.--.