A entrada não deve ser necessária e a saída deve ler " All your base are belong to us".

Restrições

• Nenhum recurso externo.

  Mais um mínimo de dois dos seguintes itens:

• Você não pode usar "a", "b", "t", "u" ou "y" em nenhum caso no seu código (bônus -10 à sua pontuação de golfe, se você puder fazer isso)

• Você não pode usar "l", "o", "s", "e" ou "r" em nenhum caso no seu código (bônus -20 à sua pontuação de golfe, se você puder fazer isso)

• Você não pode usar "n", "g", "0", "1" ou "2" em nenhum caso no seu código (bônus -30 na sua pontuação de golfe, se você puder fazer isso)

Por exemplo, se você conseguir executar o código com 40 caracteres e usar as regras 1 e 2, sua pontuação no golfe será de 40 - 10 - 20 = 10 caracteres.

A menor pontuação de golfe com código vence ... Boa sorte!

SOGL V0.12 , 15 - 60 = -45

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

Experimente aqui!

šz█P'zUS½█│β3‘é uma string comprimida de all your base are belong to us, mas porque essa seqüência exata comprimido contido 0, está dividido em 3 partes: all your base are, , belong to us(que custou um byte, mas deu um bônus -30 byte). A primeira e a última string são compactadas com o dicionário de inglês SOGLs e unidas implicitamente com espaços. O restante ⁾é um caso de sentença simples embutido.
Observe que SOGL pós-data deste desafio, mas isso é permitido agora.

GolfScript, -22 (38 caracteres, -60 de bônus)

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

Sclipting , −40

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

• = 20 caracteres - 60 bônus
• Só funciona se a entrada estiver vazia, o que considero o caso; caso contrário, adicione 丟na frente, alterando a pontuação para -39.
• Se eu puder assumir que a entrada é o que eu quero (como essa resposta aparentemente faz), o programa vazio é uma solução e minha pontuação é −60.

JavaScript - 140 bytes - 60 bônus = 80 pontos

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

Execute no Firefox.

Eu sei o que você está pensando. Não, esses não são os personagens listados na pergunta. Esses são caracteres com um caractere, ou háček (escolhidos aleatoriamente em uma lista de sinais diacríticos). Mesmo combinando marcas, eles não são dois caracteres separados.

APL (43 - 30 - 20 = -7)

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

Isso satisfaz as regras 2 e 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/

Eu pensei que estava sendo inteligente com o tipo de cabeça para baixo, mas depois percebi que não poderia cumprir nenhuma das regras auxiliares com o HTML / CSS real. Ah bem.

ATUALIZAR:

A User Flame sugeriu uma solução mais compatível com vários navegadores:

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

http://jsbin.com/EjekuvuF/6

MATLAB, todos os bônus: Pontuação de -20 (40-60)

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

EDITAR:

Observe que não tenho certeza de quais são os requisitos do sistema para executar isso, testados no Windows. Para aqueles que desejam copiar, um código semelhante pode ser gerado da seguinte maneira:

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

Se fosse permitido pedir algo como entrada, uma solução com menos caracteres (mas também sem o bônus) seria possível.

input('')

k (-7 = 53 - 60)

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

não inclui a nova linha à direita, pode ser adicionada ao custo de um caractere adicional:

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

irritantemente, as únicas compensações que funcionam para esse truque são 154 e 155

editar:

se for suficiente exibir a string (em vez de imprimi-la), como suspeito que a solução APL funcione (ela não funciona em http://tryapl.com/ , por isso não posso testá-la corretamente), é

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

que é -12 = 48 - 60. posso obter uma decisão sobre se isso é suficiente?

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

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

Versão aprimorada (a idéia principal aqui é variar a base de entrada, aumentar as chances de encontrar um número grande e útil, sem dígitos problemáticos):

IDi67793554D647F84C836645D6569F69Pi6385C77P9i35PDdi6^I9^+6D59CD83D664D34+P8CPFi98CCF5PCi97P

Na base 7, a coisa toda pode se tornar um número único! Bases inferiores são naturalmente menos compactas, mas a falta de operações de reparo aqui compensa isso.

7i4398873968644388737548444897643735447698675366869556798538985674336396359936458859886P

Minha base primeira solução utilizada 10. Meu segundo utilizada uma mistura de base 9, 10, 12, 13 e 15. Este é em base de 7. Eu realmente sinto que toda a base são me pertencem.

Último, sério: a Base 13 faz um ótimo trabalho no primeiro segmento, depois a base 7 para o resto.

Di67793554D647F84C836645D6569F69P7i798789699638355733695878558396339387963789536P

Python REPL, 122 116 98 caracteres - 30 bônus = 92 86 68 pontos

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

Eu poderia me livrar dos zeros no Python 3.3 substituindo ' \40' por \N{SP}, mas, infelizmente, isso Nnão é permitido.

Edit : Inspirado por esta resposta , eu a reduzi ainda mais substituindo \x40por . Além disso, uma vez que já utilizam a 1, substituindo \156por ne \x67por gencurta-lo por mais de 6 caracteres, enquanto incorrer nenhuma penalidade extra.

Brainfuck, 205 203 - 60 = 145 143 bytes

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

Versão legível:

++++[->++++<]>[->++++>++>+++++++>++++++>++++++++<<<<<]
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 os valores ascii e os imprime. Eu ainda preciso experimentar outros métodos para formar os números para ver se existem maneiras mais curtas.

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

Ruby, 121 - 50 = 71

Um pouco de força bruta, mas a maioria dos métodos engraçados é descartada:

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

Quebra a regra 1 por causa da entrada A pack, as outras duas devem estar OK.

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

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

Porra, acontece que eu tinha um rlá que eu não tinha notado, então o bônus de 20 não se aplica!

C, 75 bytes - 60 = 15

Obrigado a @gastropner por diminuir a pontuação de 50 para 33 e de 19 para 15!

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

Pega o endereço de uma matriz de caracteres como entrada e grava a sequência na matriz.

Experimente online!

Ligue para:

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

Resultado:

Versão antiga (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 bônus = 246) (206 caracteres - 50 bônus = 156)

(123 caracteres = 173 caracteres - bônus 50)

Tipo de nooby, provavelmente poderia tirar mais proveito ... Informe-me se eu tiver enchido alguma coisa, isso alerta "Toda a sua base nos pertence". Isso também é apenas 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")')()

Se você contar o próprio console como saída, isso também contará (57 com bônus):

'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 pode ser decodificado usando xxd -r.
[2] Sim, solução pesada reutilize aqui. Eu acho que é ... terceiro problema que resolvi dessa maneira. Talvez eu deva mudar para outra coisa, mas isso não é ótimo para problemas que o proíbem de usar a maioria dos personagens.}

Bash, 52 - 10-30 = 12

O seguinte deve ser executado em um ambiente (ainda bastante comum) ISO-8859-1:

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

Isso chama tr, que traduz os caracteres de maneira adequada. Eu tive que usar a rregra 2 e violar a regra 2, ou usar um dígito na regra 3 de fuga e violação. Como 3 dá mais bônus, eu escolhi a primeira.

Pure Bash (sem recursos externos), 141 caracteres - 50 bônus = 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

Eliminar intencionalmente o bônus de 10 pontos para obter uma melhor pontuação geral.

Isso funciona em qualquer bashversão 3.00.15 ou posterior que eu tentei.

Como funciona

Não há ciência de foguetes aqui - apenas bashexpansões de uma forma ou de outra:

• Expansão hexadecimal simples para obter o caractere necessário. Isso funciona para caracteres cuja representação hexadecimal não contém [012]. por exemplo, $'\x65'nos dáe
• Para outros caracteres, geramos uma matriz bash de caracteres seqüenciais usando expansão entre chaves para uma inicialização de matriz ( Z=({k..v})). O início da expansão do colchete é escolhido com cuidado para que os índices dos caracteres necessários não contenham [012]. por exemplo, ${Z[7]}nos dá r.
• bashé flexível o suficiente para permitir que seus comandos sejam construídos a partir do conteúdo de várias seqüências. Então se $f$'\x63'h$iexpande para echo.
• Para caracteres necessários apenas uma vez, a expansão é inserida embutida na cadeia de comando echo.
• Para caracteres necessários duas ou mais vezes, é mais eficiente expandi-los para variáveis ​​e referenciá-las.

Resposta anterior com bônus total, mas pior pontuação geral:

Pure Bash (sem recursos externos), 193 caracteres - 60 bônus = 133

Eu sei que isso não vai ganhar, mas eu queria provar para mim mesmo que isso é possível bash, enquanto satisfaz todos os 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

Isso requer uma versão bastante recente bashpara a ${c^}expansão de parâmetros. 4.2.25 é bom, mas 3.2.48 é um não-go.

Postscript, 364 - 40 = 324

Eu não poderia fazer isso sem loser, é claro. :)

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

Isso começa com a codificação do texto como 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

E depois remover os 1s e 0s e 2s aritmeticamente. As seqüências podem ser regeneradas com 36 <string-buf> cvrs, mas isso gera letras maiúsculas, portanto, precisamos iterar e adicionar 0x20 para torná-las em minúsculas.

Os operadores cvx execnos permitem executar fragmentos de string de tokens de operador codificados em binário em várias codificações. O mais simples é codificar um operador em hexadecimal, <92??>mas há um 2 lá! Portanto, a codificação de "primeiro nível" é ascii85. Em seguida, todas as strings que ainda continham caracteres proibidos passaram por níveis extras de hex -> ascii85 -> hex -> ascii85.

Brainfuck, 306 - 60 = 246

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

PHP, 186 - 10 - 30 = 146

Eu tive que ser um pouco criativo;)

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

[Estou usando a versão 2.7.2 YMMV - o embutido, filefoi lançada no 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'

E pontuação:

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

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

Não tenho certeza se isso poderia ter sido feito mais curto (em geral) se não recebesse um dos bônus de código - meu objetivo era um pouco menos em falta e um pouco mais em -60 ... Gostei do desafio de não usar qualquer um dos caracteres restritos.

E ... eu errei - perdi o comando inicial 'S'. : - /

Enfim, aqui está uma versão "sem regras" - expandindo as variáveis.

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

E isso dá uma pontuação de 177-60 = 117. Então, quebrar a regra do centro ainda me dava uma pontuação geral mais baixa.

Perl 5, 99 - 50 = 49

Uma sub-rotina que retorna a sequência necessária:

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

Veja impresso assim:

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