La entrada no debe ser necesaria y la salida debe leer " All your base are belong to us".

Restricciones

• Sin recursos externos.

  Más un mínimo de dos de los siguientes:

• No puede usar "a", "b", "t", "u" o "y" en ningún caso en su código (bonificación -10 a su puntaje de golf si puede hacerlo)

• No puede usar "l", "o", "s", "e" o "r" en ningún caso en su código (bonificación -20 a su puntaje de golf si puede hacerlo)

• No puede usar "n", "g", "0", "1" o "2" en ningún caso en su código (bonificación -30 a su puntaje de golf si puede hacerlo)

Entonces, por ejemplo, si logra hacer el código con 40 caracteres y usa las reglas 1 y 2, su puntaje de golf es 40 - 10 - 20 = 10 caracteres.

El puntaje de golf de código más pequeño gana ... ¡Buena suerte!

SOGL V0.12 , 15-60 = -45

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

Pruébalo aquí!

šz█P'zUS½█│β3‘es una cadena comprimida de all your base are belong to us, pero debido a que la cadena exacta comprimido contenido 0, es dividida en 3 partes: all your base are, , belong to us(que cuestan un byte, pero dio un bono -30 byte). La primera y la última cadena se comprimen con el diccionario de inglés SOGL y se unen implícitamente con espacios. El resto ⁾es un caso de oración simple incorporado.
Tenga en cuenta que SOGL es posterior a este desafío, pero eso está permitido ahora.

GolfScript, -22 (38 caracteres, -60 bonus)

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

Sclipting , −40

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

• = 20 caracteres - 60 bonus
• Solo funciona si la entrada está vacía, lo cual considero que es el caso; si no, agregue 丟al frente, cambiando el puntaje a −39.
• Si puedo asumir que la entrada es lo que quiero (como aparentemente hace esta respuesta ), entonces el programa vacío es una solución y mi puntaje es −60.

JavaScript - 140 bytes - 60 bonus = 80 puntos

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

Ejecutar en Firefox

Sé lo que estás pensando. No, esos no son los personajes que figuran en la pregunta. Esos son personajes con un caron o háček (elegidos al azar de una lista de diacríticos). Aunque están combinando marcas, no son dos personajes separados.

APL (43-30-20 = -7)

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

Esto satisface las reglas 2 y 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/

Pensé que estaba siendo inteligente con el tipo invertido, pero luego me di cuenta de que no podía cumplir ninguna de las reglas auxiliares con el HTML / CSS real. Oh bien.

ACTUALIZAR:

User Flame sugirió una solución más compatible con varios navegadores:

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

http://jsbin.com/EjekuvuF/6

MATLAB, Todas las bonificaciones: Puntuación de -20 (40-60)

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

EDITAR:

Tenga en cuenta que no estoy seguro de cuáles son los requisitos del sistema para ejecutar esto, probado en Windows. Para aquellos que luchan por copiar, se puede generar un código similar de esta manera:

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

Si se le hubiera permitido preguntar algo como entrada, por supuesto sería posible una solución con menos caracteres (pero también sin la bonificación).

input('')

k (-7 = 53-60)

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

no incluye la nueva línea final, se puede agregar al costo de un carácter adicional:

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

molestamente, las únicas compensaciones que funcionan para este truco son 154 y 155

editar:

si es suficiente para mostrar la cadena (en lugar de imprimirla), como sospecho que la solución APL funciona (no funciona en http://tryapl.com/ , por lo que no puedo probarla correctamente), es

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

que es -12 = 48 - 60. ¿Puedo obtener una decisión sobre si esto es suficiente?

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

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

Versión mejorada (la idea principal aquí es variar la base de entrada, para aumentar las posibilidades de encontrar un gran número útil sin dígitos problemáticos):

IDi67793554D647F84C836645D6569F69Pi6385C77P9i35PDdi6^I9^+6D59CD83D664D34+P8CPFi98CCF5PCi97P

En la base 7, ¡todo puede convertirse en un solo número! Las bases inferiores son naturalmente menos compactas, pero la falta de operaciones de reparación aquí lo compensa.

7i4398873968644388737548444897643735447698675366869556798538985674336396359936458859886P

Mi primera solución de base utilizada 10. La segunda utiliza una mezcla de base 9, 10, 12, 13 y 15. Éste está en la base 7. verdaderamente siento que toda la base son pertenecen a mí.

El último, en serio: Base 13 hace un gran trabajo en el primer segmento, luego la base 7 para el resto.

Di67793554D647F84C836645D6569F69P7i798789699638355733695878558396339387963789536P

REPL Python, 122 116 98 caracteres - 30 bono = 92 86 68 puntos

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

Podría deshacerme de los ceros en Python 3.3 reemplazando ' \40' con \N{SP}, pero desafortunadamente, Nno está permitido.

Editar : inspirado por esta respuesta , lo acorté aún más al reemplazarlo \x40por . Por otra parte, puesto que ya utilizo el 1, reemplazando \156por ny \x67por glo acorta por otros 6 caracteres, mientras que incurrir en ninguna penalización adicional.

Brainfuck, 205 203 - 60 = 145 143 bytes

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

Versión legible:

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

Calcula los valores ascii, luego los imprime. Todavía necesito probar otros métodos para formar los números para ver si hay formas más cortas.

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

Rubí, 121-50 = 71

Un poco de fuerza bruta, pero se descartan la mayoría de los métodos lindos:

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

Rompe la regla # 1 debido a la A en pack, los otros dos deberían estar bien.

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

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

Maldita sea, resulta que tenía un rallí que no había notado, ¡así que el bono de 20 no se aplica!

C, 75 bytes - 60 = 15

¡Gracias a @gastropner por bajar el puntaje de 50 a 33 y de 19 a 15!

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

Toma la dirección de una matriz de caracteres como entrada y escribe la cadena en la matriz.

Pruébalo en línea!

Llamar con:

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

Salida:

Versión anterior (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 caracteres - 60 bonus = 246) (206 caracteres - 50 bonus = 156)

(123 caracteres = 173 caracteres - 50 bonus)

Nooby, probablemente podría sacar más provecho ... Avíseme si he rellenado algo, esto alerta "Toda su base nos pertenece". Esto también es solo 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 cuenta la consola en sí como salida, esto también contaría (57 con bonificación):

'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] Este programa se puede decodificar usando xxd -r.
[2] Sí, la solución pesada se reutiliza aquí. Creo que es ... el tercer problema que resolví de esta manera. Tal vez debería pasar a otra cosa, pero no es que esto no sea genial para problemas que te prohíben usar la mayoría de los personajes.}

Golpe, 52-10-30 = 12

Lo siguiente debe ejecutarse en un entorno ISO-8859-1 (todavía bastante común):

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

Esto llama tr, que traduce los caracteres de una manera adecuada. Tuve que usar ry violar la regla 2, o usar un dígito en el escape y violar la regla 3. Como 3 da más bonificación, elegí la primera.

Pure Bash (sin recursos externos), 141 caracteres - 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 $ f $ h $ i $ {Z [3]} $' \ x67 't $ iu $ k

Dejar caer intencionalmente el bono de 10 puntos para obtener una mejor puntuación general.

Esto funciona en cualquier bashversión 3.00.15 o posterior que he probado.

Como funciona

Aquí no hay ciencia de cohetes, solo bashexpansiones de una forma u otra:

• Expansión hexadecimal simple para obtener el personaje requerido. Esto funciona para personajes cuya representación hexadecimal no contiene [012]. por ejemplo $'\x65'nos dae
• Para otros caracteres, generamos una matriz bash de caracteres secuenciales usando la expansión de llaves en una inicialización de matriz ( Z=({k..v})). El inicio de la expansión de llaves se elige cuidadosamente para que los índices de los caracteres que requerimos no contengan [012]. por ejemplo ${Z[7]}nos da r.
• bashes lo suficientemente flexible como para permitir que sus comandos se construyan a partir del contenido de múltiples cadenas. Entonces se $f$'\x63'h$iexpande a echo.
• Para los caracteres que se requieren solo una vez, la expansión se inserta en línea en la cadena de comando echo.
• Para los caracteres que se requieren dos veces o más, es más eficiente expandirlos a variables, luego hacer referencia a las variables.

Respuesta anterior con bonificación completa, pero peor puntaje general:

Pure Bash (sin recursos externos), 193 caracteres - 60 bonus = 133

Sé que esto no ganará, pero quería demostrarme a mí mismo que esto es posible bash, mientras satisfago todos los requisitos:

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

Esto requiere una versión bastante reciente de bashpara la ${c^}expansión de parámetros. 4.2.25 está bien, pero 3.2.48 está prohibido.

Postdata, 364-40 = 324

No podría hacerlo sin loser, por supuesto. :)

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

Esto comienza con la codificación del texto como cadenas de 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

Y luego eliminando los 1s y 0s y 2s aritméticamente. Las cadenas se pueden regenerar con 36 <string-buf> cvrs, pero esto produce letras mayúsculas, por lo que debemos iterar y agregar 0x20 para ponerlas en minúsculas.

Los operadores cvx execnos permiten ejecutar fragmentos de cadena de tokens de operador codificados en binario en varias codificaciones. ¡Lo más simple es codificar un operador en hexadecimal <92??>pero hay un 2 allí! Entonces, la codificación de "primer nivel" es ascii85. Luego, las cadenas que aún contenían caracteres prohibidos pasaron por niveles adicionales de hexadecimal -> ascii85 -> hex -> ascii85.

Brainfuck, 306-60 = 246

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

PHP, 186-10-30 = 146

Tuve que ser un poco creativo;)

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

Pitón, 181-40 = 141

[Estoy usando la versión 2.7.2 YMMV - el incorporado, filese fue en 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'

Y anotar:

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

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

No estoy seguro de si podría haberse hecho más corto (en general) al no obtener uno de los bonos de código: mi objetivo era un poco menos en la falta y un poco más en el -60 ... Me gustó el desafío de no usar cualquiera de los caracteres restringidos

Y ... lo hice tonto, me perdí el comando inicial 'S'. : - /

De todos modos, aquí hay una versión "sin reglas": expandir las 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

Y eso le da un puntaje de 177-60 = 117. Así que romper la regla central todavía me dio un puntaje general más bajo.

Perl 5, 99-50 = 49

Una subrutina que devuelve la cadena requerida:

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

Véalo impreso así:

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