Die Eingabe muss nicht erforderlich sein und die Ausgabe muss " All your base are belong to us" lauten .

Beschränkungen

• Keine externen Ressourcen.

  Plus mindestens zwei der folgenden:

• Sie können in Ihrem Code auf keinen Fall "a", "b", "t", "u" oder "y" verwenden (Bonus -10 auf Ihre Golfwertung, wenn Sie dies tun können)

• Sie können in Ihrem Code auf keinen Fall "l", "o", "s", "e" oder "r" verwenden (Bonus -20 auf Ihre Golfwertung, wenn Sie dies tun können)

• Sie können in Ihrem Code auf keinen Fall "n", "g", "0", "1" oder "2" verwenden (Bonus -30 auf Ihre Golfwertung, wenn Sie dies tun können)

Wenn Sie beispielsweise den Code mit 40 Zeichen erstellen und die Regeln 1 und 2 verwenden, beträgt Ihr Golf-Score 40 - 10 - 20 = 10 Zeichen.

Kleinster Code Golf Score gewinnt ... Viel Glück!

SOGL V0.12 , 15 - 60 = -45

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

Probieren Sie es hier aus!

šz█P'zUS½█│β3‘ist eine komprimierte String all your base are belong to us, sondern weil die exakte Zeichenfolge enthalten komprimiert 0, es ist in 3 Teile aufgeteilt: all your base are, , belong to us(die ein Byte kosten , aber eine -30 - Byte - Bonus gab). Die erste und die letzte Zeichenfolge werden mit dem englischen SOGL-Wörterbuch komprimiert und implizit mit Leerzeichen verbunden. Der Rest ⁾ist ein einfacher eingebauter Satzfall.
Beachten Sie, dass SOGL diese Herausforderung nachdatiert, dies ist jedoch jetzt zulässig.

GolfScript, -22 (38 Zeichen, -60 Bonus)

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

Sclipting , -40

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

• = 20 Zeichen - 60 Bonus
• Funktioniert nur, wenn die Eingabe leer ist, was ich für den Fall halte; Wenn nicht, fügen Sie 丟vor und ändern Sie die Punktzahl auf -39.
• Wenn ich davon ausgehen kann, dass die Eingabe das ist, was ich will (wie dies anscheinend der Fall ist), ist das leere Programm eine Lösung und meine Punktzahl beträgt -60.

JavaScript - 140 Bytes - 60 Bonus = 80 Punkte

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

Führen Sie in Firefox.

Ich weiß was du denkst. Nein, das sind nicht die Zeichen, die in der Frage aufgeführt sind. Dies sind Zeichen mit einem Caron oder Háček (zufällig aus einer Liste von Diakritika ausgewählt). Obwohl sie Zeichen kombinieren, sind sie keine zwei getrennten Zeichen.

APL (43-30-20 = -7)

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

Dies entspricht den Regeln 2 und 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/

Ich dachte, ich wäre schlau mit dem verkehrten Typ, merkte dann aber, dass ich mit dem tatsächlichen HTML / CSS keine der Zusatzregeln erfüllen konnte. Naja.

AKTUALISIEREN:

User Flame schlug eine browserübergreifendere Lösung vor:

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

http://jsbin.com/EjekuvuF/6

MATLAB, Alle Boni: Score von -20 (40-60)

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

BEARBEITEN:

Beachten Sie, dass ich nicht sicher bin, welche Systemanforderungen dies unter Windows erfüllen soll. Für diejenigen, die Probleme beim Kopieren haben, kann ein ähnlicher Code wie folgt generiert werden:

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

Wenn es erlaubt gewesen wäre, irgendetwas als Eingabe zu verlangen, wäre natürlich eine Lösung mit weniger Zeichen (aber auch ohne den Bonus) möglich.

input('')

k (-7 = 53 - 60)

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

ohne abschließende Zeilenumbrüche, kann gegen ein zusätzliches Zeichen hinzugefügt werden:

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

ärgerlicherweise sind die einzigen Offsets, die für diesen Trick funktionieren, 154 und 155

bearbeiten:

Wenn es ausreicht, den String anzuzeigen (anstatt ihn auszudrucken), wie ich es bei der APL-Lösung vermutet habe (es funktioniert nicht unter http://tryapl.com/ , daher kann ich ihn nicht richtig testen), ist es

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

Welches ist -12 = 48 - 60. Kann ich eine Entscheidung darüber treffen, ob dies ausreicht?

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

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

Verbesserte Version (die Hauptidee hier ist, die Eingabebasis zu variieren, um die Chancen zu erhöhen, eine nützliche große Zahl ohne problematische Ziffern zu finden):

IDi67793554D647F84C836645D6569F69Pi6385C77P9i35PDdi6^I9^+6D59CD83D664D34+P8CPFi98CCF5PCi97P

In der Basis 7 kann das Ganze eine einzige Zahl werden! Niedrigere Sockel sind natürlich weniger kompakt, aber das Fehlen von Reparaturarbeiten macht dies wieder wett.

7i4398873968644388737548444897643735447698675366869556798538985674336396359936458859886P

Meine erste Lösung verwendet Basis 10 My verwendet zweite eine Mischung aus Basis 9, 10, 12, 13 und 15. Dieser ist in der Basis 7. Ich fühle mich wie all die Basis wirklich sind , gehören zu mir.

Letzteres im Ernst: Base 13 macht einen großartigen Job im ersten Segment, dann Base 7 für den Rest.

Di67793554D647F84C836645D6569F69P7i798789699638355733695878558396339387963789536P

Python REPL, 122 116 98 Zeichen - 30 Bonus = 92 86 68 Punkte

>>> '\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'

Ich könnte die Nullen in Python 3.3 loswerden, indem ich ' \40' durch ' ' ersetze \N{SP}, aber leider ist das Nnicht erlaubt.

Bearbeiten : Inspiriert von dieser Antwort habe ich es weiter verkürzt durch Ersetzen \x40durch . Da ich die bereits verwenden 1, ersetzt \156durch nund \x67durch gverkürzt sie um weitere 6 Zeichen , während keine zusätzliche Strafe entstehen.

Brainfuck, 205 203 - 60 = 145 143 Bytes

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

Lesbare Version:

++++[->++++<]>[->++++>++>+++++++>++++++>++++++++<<<<<]
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,@

Berechnet die ASCII-Werte und druckt sie dann aus. Ich muss noch andere Methoden zur Bildung der Zahlen ausprobieren, um zu sehen, ob es kürzere Wege gibt.

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

Ein bisschen rohe Gewalt, aber die meisten der niedlichen Methoden sind ausgeschlossen:

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

Verstößt Regel Nr. 1 wegen des A-Eingangs pack, sollten die anderen beiden in Ordnung sein.

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

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

Verdammt noch mal, es stellte sich heraus, rdass ich einen drin hatte , den ich nicht bemerkt hatte, also gilt der 20-Bonus nicht!

C, 75 Bytes - 60 = 15

Vielen Dank an @gastropner, der die Punktzahl von 50 auf 33 und von 19 auf 15 gesenkt hat!

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

Nimmt die Adresse eines Zeichen-Arrays als Eingabe und schreibt die Zeichenfolge in das Array.

Probieren Sie es online!

Rufen Sie an mit:

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

Ausgabe:

Alte Version (90 Bytes - 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 Zeichen - 60 Bonus = 246) (206 Zeichen - 50 Bonus = 156)

(123 Zeichen = 173 Zeichen - 50 Bonus)

Irgendwie keine Ahnung, könnte wahrscheinlich mehr rausholen ... Lass es mich wissen, wenn ich etwas vollgestopft habe. Dieser Alarm warnt "Alle deine Basen gehören uns". Dies ist auch nur in ASCII möglich.

(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")')()

Wenn Sie die Konsole selbst als Ausgabe zählen, zählt dies auch (57 mit Bonus):

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

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] Dieses Programm kann mit dekodiert werden xxd -r.
[2] Ja, schwere Lösung hier wiederverwenden. Ich denke, es ist ... das dritte Problem, das ich auf diese Weise gelöst habe. Vielleicht sollte ich zu etwas anderem übergehen, aber es ist nicht so, dass dies nicht gut für Probleme ist, die es Ihnen verbieten, die meisten Zeichen zu verwenden.}

Bash, 52-10-30 = 12

Das Folgende soll in einer (immer noch recht verbreiteten) ISO-8859-1-Umgebung ausgeführt werden:

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

Dies ruft auf tr, was die Zeichen in geeigneter Weise übersetzt. Ich musste entweder die rund Regel 2 verletzen, oder eine Ziffer in der Escape-Taste verwenden und Regel 3 verletzen. Da 3 mehr Bonus gibt, entschied ich mich für die erstere.

Pure Bash (keine externen Ressourcen), 141 Zeichen - 50 Bonus = 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 $ h $ i $ {Z [3]} $' \ x67 't $ iu $ k

Den 10-Punkte-Bonus absichtlich fallen lassen, um eine bessere Gesamtpunktzahl zu erzielen.

Dies funktioniert mit jeder bashVersion 3.00.15 oder höher, die ich ausprobiert habe.

Wie funktioniert es

Hier gibt es keine Raketenwissenschaft - nur bashErweiterungen der einen oder anderen Form:

• Einfache Hex-Erweiterung, um den gewünschten Charakter zu erhalten. Dies funktioniert für Zeichen, deren Hex-Darstellung nicht enthält [012]. zB $'\x65'gibt unse
• Für andere Zeichen generieren wir ein Bash-Array sequentieller Zeichen, indem wir die geschweifte Klammer zu einer Array-Initialisierung ( Z=({k..v})) erweitern. Der Beginn der geschweiften Klammer wird sorgfältig ausgewählt, damit die Indizes der Zeichen, die wir benötigen, nicht enthalten [012]. zB ${Z[7]}gibt uns r.
• bashist flexibel genug, um zuzulassen, dass seine Befehle aus dem Inhalt mehrerer Zeichenfolgen erstellt werden. Erweitert $f$'\x63'h$isich also zu echo.
• Für Zeichen, die nur einmal erforderlich sind, wird die Erweiterung in die Echo-Befehlszeichenfolge eingefügt.
• Bei Zeichen, die zweimal oder öfter benötigt werden, ist es effizienter, sie zu Variablen zu erweitern und dann auf die Variablen zu verweisen.

Vorherige Antwort mit vollem Bonus, aber schlechterer Punktzahl:

Pure Bash (keine externen Ressourcen), 193 Zeichen - 60 Bonus = 133

Ich weiß, dass dies nicht gewinnen wird, aber ich wollte mir beweisen, dass dies möglich ist bash, und dabei alle Anforderungen erfüllen:

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 $' \ x79 'i $ m $ j $ d $ c $ k $ f $ c $ j $ f $ d $ f $ h $ i $ {Z [49]} $ '\ x67' $ '\ x74' $ i $ m $ k

Dies erfordert eine relativ aktuelle Version von bashfür die ${c^}Parametererweiterung. 4.2.25 ist in Ordnung, aber 3.2.48 ist ein No-Go.

Postscript, 364 - 40 = 324

Ich könnte es losernatürlich nicht ohne tun . :)

/${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 + -

Dies beginnt mit der Codierung des Texts als Base-36-Zeichenfolge:

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

Und dann die 1s und 0s und 2s arithmetisch entfernen. Die Zeichenfolgen können dann mit neu generiert werden 36 <string-buf> cvrs, dies führt jedoch zu Großbuchstaben. Daher müssen wir sie durchlaufen und 0x20 hinzufügen, um sie in Kleinbuchstaben umzuwandeln.

Die Operatoren cvx execermöglichen es uns, Zeichenfolgenfragmente von binär codierten Operatortoken in verschiedenen Codierungen auszuführen. Am einfachsten ist es, einen Operator in Hex zu kodieren, <92??>aber da ist eine 2 drin! Die "First-Level" -Codierung lautet also ascii85. Dann durchliefen alle Zeichenfolgen, die noch verbotene Zeichen enthielten, zusätzliche Ebenen von hex -> ascii85 -> hex -> ascii85.

Brainfuck, 306 - 60 = 246

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

PHP, 186-10-30 = 146

Ich musste ein wenig kreativ werden;)

 <?=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

[Ich verwende Version 2.7.2 YMMV - das eingebaute, fileist in Python 3.X verschwunden]

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'

Und Punktzahl:

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

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

Ich bin mir nicht sicher, ob es (insgesamt) kürzer hätte sein können, wenn ich keinen der Code-Boni bekommen hätte - mein Ziel war ein bisschen weniger auf Shortness und ein bisschen mehr auf -60 ... Ich mochte die Herausforderung, nicht zu verwenden eines der eingeschränkten Zeichen.

Und ... ich habe es vermasselt - den beginnenden 'S'-Befehl verpasst. : - /

Wie auch immer, hier ist eine "keine Regeln" -Version - die Variablen erweitern.

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

Und das ergibt eine Punktzahl von 177-60 = 117. Wenn ich also gegen die Mittelregel verstoße, habe ich immer noch eine niedrigere Gesamtpunktzahl.

Perl 5, 99 - 50 = 49

Eine Unterroutine, die die erforderliche Zeichenfolge zurückgibt:

{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"}

Sehen Sie es so gedruckt:

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