L'entrée ne doit pas être requise et la sortie doit indiquer " All your base are belong to us".

Restrictions

• Pas de ressources externes.

  Plus un minimum de deux des éléments suivants:

• Vous ne pouvez en aucun cas utiliser "a", "b", "t", "u" ou "y" dans votre code (bonus -10 à votre score de golf si vous pouvez le faire)

• Vous ne pouvez en aucun cas utiliser "l", "o", "s", "e" ou "r" dans votre code (bonus -20 à votre score de golf si vous pouvez le faire)

• Vous ne pouvez en aucun cas utiliser "n", "g", "0", "1" ou "2" dans votre code (bonus -30 à votre score de golf si vous pouvez le faire)

Ainsi, par exemple, si vous parvenez à obtenir le code avec 40 caractères et utilisez les règles 1 et 2, votre score de golf est de 40 - 10 - 20 = 10 caractères.

Plus petit score de golf de code gagne ... Bonne chance!

SOGL V0.12 , 15 - 60 = -45

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

Essayez-le ici!

šz█P'zUS½█│β3‘est une chaîne compressée all your base are belong to us, mais parce que cette chaîne exacte comprimé contenu 0, il est divisé en 3 parties: all your base are, , belong to us(qui a coûté un octet , mais a donné un bonus -30 octets). Les première et dernière chaînes sont compressées avec le dictionnaire anglais de SOGL et, implicitement, jointes à des espaces. Le reste ⁾est un cas de phrase simple intégré.
Notez que SOGL post-date ce défi, mais c'est permis maintenant.

GolfScript, -22 (38 caractères, -60 bonus)

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

Déclenchement , −40

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

• = 20 caractères - 60 bonus
• Ne fonctionne que si l'entrée est vide, ce qui, je suppose, est le cas. sinon, ajoutez 丟devant, en changeant le score à -39.
• Si je peux supposer que l'entrée est ce que je veux (comme cette réponse le fait apparemment), alors le programme vide est une solution et mon score est égal à −60.

JavaScript - 140 octets - 60 bonus = 80 points

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

Courir dans Firefox.

Je sais ce que tu penses. Non, ce ne sont pas les personnages énumérés dans la question. Ce sont des personnages avec un caron, ou háček (choisis au hasard dans une liste de signes diacritiques). Même s'ils combinent des marques, ils ne sont pas deux caractères séparés.

APL (43 - 30 - 20 = -7)

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

Cela répond aux règles 2 et 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/

Je pensais que j'étais malin avec le type à l'envers, mais j'ai alors réalisé que je ne pouvais respecter aucune des règles auxiliaires avec le code HTML / CSS. Tant pis.

MISE À JOUR:

User Flame a suggéré une solution plus compatible avec plusieurs navigateurs:

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

http://jsbin.com/EjekuvuF/6

MATLAB, Tous les bonus: Score de -20 (40-60)

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

MODIFIER:

Notez que je ne suis pas sûr de la configuration système requise pour l’exécuter, testé sur Windows. Pour ceux qui ont du mal à copier, un code similaire peut être généré comme ceci:

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

S'il avait été permis de demander quoi que ce soit en entrée, une solution avec moins de caractères (mais manquant également le bonus) serait bien sûr possible.

input('')

k (-7 = 53 - 60)

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

n'inclut pas le retour à la ligne, peut être ajouté au prix d'un caractère supplémentaire:

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

ennuyeux, les seuls compensations qui fonctionnent pour cette astuce sont 154 et 155

modifier:

s'il suffit d'afficher la chaîne (plutôt que de l'imprimer), comme je suppose que la solution APL fonctionne (cela ne fonctionne pas dans http://tryapl.com/ , je ne peux donc pas le tester correctement), c'est

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

qui est -12 = 48 - 60. Puis-je savoir si cela est suffisant?

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

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

Version améliorée (l’idée principale ici est de faire varier la base d’entrée pour augmenter les chances de trouver un grand nombre utile sans chiffres problématiques):

IDi67793554D647F84C836645D6569F69Pi6385C77P9i35PDdi6^I9^+6D59CD83D664D34+P8CPFi98CCF5PCi97P

En base 7, le tout peut devenir un numéro unique! Les bases les plus basses sont naturellement moins compactes, mais le manque d’opérations de réparation le compense.

7i4398873968644388737548444897643735447698675366869556798538985674336396359936458859886P

Ma première solution base utilisée 10. Mon second a utilisé un mélange de base 9, 10, 12, 13 et 15. Celui - ci est dans la base 7. Je me sens vraiment comme toute la base sont appartiennent à moi.

Dernier point, sérieux: la base 13 fait un excellent travail sur le premier segment, puis la base 7 pour le reste.

Di67793554D647F84C836645D6569F69P7i798789699638355733695878558396339387963789536P

Python REPL, 122 116 98 caractères - 30 bonus = 92 86 68 points

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

Je pourrais me débarrasser des zéros de Python 3.3 en remplaçant le mot 'par \40' \N{SP}, mais hélas, le Nn'est pas autorisé.

Edit : Inspiré par cette réponse , je l’ai encore raccourci en le remplaçant \x40par . De plus, depuis que je l'utilise déjà 1, le remplacer \156par net \x67par le graccourcit de 6 autres caractères sans encourir de pénalité supplémentaire.

Brainfuck, 205 203 - 60 = 145 143 octets

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

Version lisible:

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

Calcule les valeurs ascii, puis les imprime. J'ai encore besoin d'essayer d'autres méthodes pour former les nombres pour voir s'il y a des façons plus courtes.

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

Rubis, 121 - 50 = 71

Un peu de force brute, mais la plupart des méthodes mignonnes sont exclues:

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

Enfreint la règle n ° 1 à cause du A dans pack, les deux autres devraient être OK.

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

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

Darn it, s'avère que j'avais un rlà-bas que je n'avais pas remarqué, alors le bonus de 20 ne s'applique pas!

C, 75 octets - 60 = 15

Merci à @gastropner d'avoir réduit le score de 50 à 33 et de 19 à 15!

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

Prend l'adresse d'un tableau de caractères en entrée et écrit la chaîne dans le tableau.

Essayez-le en ligne!

Appeler avec:

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

Sortie:

Ancienne version (90 octets - 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 caractères - 60 bonus = 246) (206 caractères - 50 bonus = 156)

(123 caractères = 173 caractères - 50 bonus)

Une sorte de nooby, pourrait probablement en avoir plus ... Faites-le-moi savoir si j'ai quelque chose en peluche, cela alerte "Toute votre base nous appartient." Ceci est également uniquement en 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")')()

Si vous comptez la console comme sortie, cela comptera également (57 avec 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 octets)

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] Ce programme peut être décodé avec xxd -r.
[2] Oui, la solution lourde est réutilisée ici. Je pense que c'est ... le troisième problème que j'ai résolu de cette façon. Peut-être que je devrais passer à autre chose, mais ce n'est pas que ce ne soit pas génial pour les problèmes qui vous interdisent d'utiliser la plupart des caractères.}

Bash, 52 - 10 - 30 = 12

Ce qui suit doit être exécuté dans un environnement ISO-8859-1 (encore assez courant):

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

Cela appelle tr, qui traduit les caractères de manière appropriée. Je devais soit utiliser la ret enfreindre la règle 2, soit utiliser un chiffre dans l'échappement et enfreindre la règle 3. Puisque 3 donne plus de bonus, j'ai choisi l'ancien.

Pure Bash (pas de ressources externes), 141 caractères - 50 bonus = 91

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

Abandonner intentionnellement le bonus de 10 points pour obtenir un meilleur score global.

Cela fonctionne sur n'importe quelle bashversion 3.00.15 ou ultérieure que j'ai essayée.

Comment ça marche

Il n'y a pas de science de fusée ici - juste des bashextensions d'une forme ou d'une autre:

• Simple extension hexadécimale pour obtenir le caractère requis. Cela fonctionne pour les personnages dont la représentation hexadécimale ne contient pas [012]. par exemple $'\x65'nous donnee
• Pour les autres caractères, nous générons un tableau bash de caractères séquentiels en utilisant le développement d'accolades dans une initialisation de tableau ( Z=({k..v})). Le début du développement de l’accolade est choisi avec soin afin que les index des caractères requis ne soient pas contenus [012]. par exemple ${Z[7]}nous donne r.
• bashest suffisamment souple pour permettre à ses commandes d'être construites à partir du contenu de plusieurs chaînes. Alors $f$'\x63'h$iétend à echo.
• Pour les caractères requis une seule fois, le développement est inséré directement dans la chaîne de commande echo.
• Pour les caractères requis deux fois ou plus, il est plus efficace de les développer en variables, puis de les référencer.

Réponse précédente avec bonus complet, mais score global pire:

Pure Bash (pas de ressources externes), 193 caractères - 60 bonus = 133

Je sais que cela ne gagnera pas, mais je voulais me prouver que c'était possible bash, tout en satisfaisant toutes les exigences:

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

Cela nécessite une version assez récente de bashl' ${c^}extension des paramètres. 4.2.25 c'est bien, mais 3.2.48 est un non-lieu.

Postscript, 364 - 40 = 324

Je ne pourrais pas le faire sans loser, bien sûr. :)

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

Cela commence par encoder le texte sous forme de chaînes en 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

Et puis en enlevant les 1 et les 0 et les 2 arithmétiquement. Les chaînes peuvent ensuite être régénérées avec 36 <string-buf> cvrs, mais ceci produit des lettres majuscules. Nous devons ensuite parcourir et ajouter 0x20 pour les mettre en minuscules.

Les opérateurs cvx execnous permettent d’exécuter des fragments de chaîne de jetons d’opérateurs codés en binaire dans différents codages. Le plus simple est de coder un opérateur en hex <92??>mais il y a un 2 dedans! Le codage de "premier niveau" est donc ascii85. Ensuite, toutes les chaînes contenant encore des caractères interdits passaient par des niveaux supplémentaires d’hex -> ascii85 -> hex -> ascii85.

Brainfuck, 306 - 60 = 246

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

PHP, 186 - 10 - 30 = 146

Je devais avoir un peu de créativité;)

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

[J'utilise la version 2.7.2 YMMV - la commande intégrée a filedisparu de Python 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'

Et score:

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

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

Je ne sais pas si cela aurait pu être fait plus court (globalement) en n'obtenant pas l'un des bonus du code - mon objectif était un peu moins sur la brièveté et un peu plus sur le -60 ... J'ai aimé le défi de ne pas utiliser l'un des caractères restreints.

Et ... je l'ai gaffé - j'ai manqué le commandement de début 'S'. : - /

Quoi qu'il en soit, voici une version "sans règles" - développant les variables.

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

Et cela lui donne un score de 177-60 = 117. Donc, briser la règle du centre me donnait toujours un score global plus bas.

Perl 5, 99 - 50 = 49

Un sous-programme qui renvoie la chaîne requise:

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

Voir le imprimé ainsi:

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