L'input non deve essere richiesto e l'output deve leggere " All your base are belong to us".

restrizioni

• Nessuna risorsa esterna.

  Più un minimo di due dei seguenti:

• Non puoi usare "a", "b", "t", "u" o "y" in ogni caso nel tuo codice (bonus -10 al tuo punteggio di golf se puoi farlo)

• Non puoi usare "l", "o", "s", "e" o "r" in ogni caso nel tuo codice (bonus -20 al tuo punteggio di golf se puoi farlo)

• Non puoi usare "n", "g", "0", "1" o "2" in ogni caso nel tuo codice (bonus -30 al tuo punteggio di golf se puoi farlo)

Ad esempio, se riesci a completare il codice con 40 caratteri e usi le regole 1 e 2, il tuo punteggio di golf è 40 - 10 - 20 = 10 caratteri.

Vince il punteggio di golf con il codice più piccolo ... Buona fortuna!

SOGL V0.12 , 15-60 = -45

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

Provalo qui!

šz█P'zUS½█│β3‘è una stringa compressa all your base are belong to us, ma perché la stringa esatta compressa contenuta 0, è diviso in 3 parti: all your base are, , belong to us(che costano un byte, ma ha dato un bonus -30 byte). La prima e l'ultima stringa sono compresse con il dizionario inglese SOGL e implicitamente unite con spazi. Il resto ⁾è un semplice caso di frase incorporato.
Nota che SOGL ha postdatato questa sfida, ma ora è consentito.

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

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

Sclipting , −40

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

• = 20 caratteri - 60 bonus
• Funziona solo se l'input è vuoto, che ritengo essere il caso; in caso contrario, aggiungi 丟in primo piano, cambiando il punteggio in -39.
• Se posso supporre che l'input sia quello che voglio (come apparentemente fa questa risposta ), allora il programma vuoto è una soluzione e il mio punteggio è -60.

JavaScript - 140 byte - 60 bonus = 80 punti

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

Esegui in Firefox.

So cosa stai pensando. No, quelli non sono i personaggi elencati nella domanda. Questi sono personaggi con un caron o háček (scelti a caso da un elenco di segni diacritici). Anche se stanno combinando segni, non sono due personaggi separati.

APL (43-30-20 = -7)

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

Questo soddisfa le regole 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/

Pensavo di essere intelligente con il tipo capovolto, ma poi mi sono reso conto che non potevo soddisfare nessuna delle regole accessorie con il vero HTML / CSS. Oh bene.

AGGIORNARE:

User Flame ha suggerito una soluzione più compatibile con più browser:

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

http://jsbin.com/EjekuvuF/6

MATLAB, Tutti i bonus: punteggio di -20 (40-60)

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

MODIFICARE:

Nota che non sono sicuro di quali siano i requisiti di sistema per eseguire questo, testato su Windows. Per coloro che hanno difficoltà a copiare, un codice simile può essere generato in questo modo:

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

Se fosse stato permesso di chiedere qualsiasi cosa come input, sarebbe ovviamente possibile una soluzione con meno personaggi (ma anche senza il bonus).

input('')

k (-7 = 53-60)

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

non include la nuova riga finale, può essere aggiunta al costo di un carattere aggiuntivo:

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

fastidiosamente, gli unici offset che funzionano per questo trucco sono 154 e 155

modificare:

se è sufficiente visualizzare la stringa (anziché stamparla), come sospetto che la soluzione APL funzioni (non funziona in http://tryapl.com/ , quindi non riesco a testarla correttamente), è

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

che è -12 = 48 - 60. posso ottenere una decisione sul fatto che sia sufficiente?

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

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

Versione migliorata (l'idea principale qui è quella di variare la base di input, per aumentare le possibilità di trovare un numero grande utile senza cifre problematiche):

IDi67793554D647F84C836645D6569F69Pi6385C77P9i35PDdi6^I9^+6D59CD83D664D34+P8CPFi98CCF5PCi97P

Nella base 7, tutto può diventare un singolo numero! Le basi inferiori sono naturalmente meno compatte, ma la mancanza di operazioni di correzione qui compensa.

7i4398873968644388737548444897643735447698675366869556798538985674336396359936458859886P

La mia prima soluzione di base utilizzata 10. Il secondo ha utilizzato un mix di base 9, 10, 12, 13, e 15. Questo è nella base di 7. Mi sento veramente come tutti la base sono appartengono a me.

L'ultimo, sul serio: la Base 13 fa un ottimo lavoro sul primo segmento, quindi la base 7 per il resto.

Di67793554D647F84C836645D6569F69P7i798789699638355733695878558396339387963789536P

Python REPL, 122 116 98 caratteri - 30 bonus = 92 86 68 punti

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

Potrei sbarazzarmi degli zero in Python 3.3 sostituendo " \40" con \N{SP}, ma purtroppo Nnon è permesso.

Modifica : ispirato da questa risposta , l'ho abbreviata ulteriormente sostituendo \x40con . Inoltre, dal momento che già uso il 1, sostituendo \156da ne \x67per gaccorcia con un altro 6 caratteri, mentre incorrere in nessuna penalità supplementare.

Brainfuck, 205 203 - 60 = 145 143 byte

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

Versione leggibile:

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

Calcola i valori ASCII, quindi li stampa. Devo ancora provare altri metodi per formare i numeri per vedere se ci sono modi più brevi.

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

Rubino, 121-50 = 71

Un po 'di forza bruta, ma la maggior parte dei metodi carini è esclusa:

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

Infrange la regola # 1 a causa di A in pack, gli altri due dovrebbero essere OK.

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

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

Dannazione, risulta che avevo un rin là che non avevo notato, quindi il bonus 20 non si applica!

C, 75 byte - 60 = 15

Grazie a @gastropner per aver abbassato il punteggio da 50 a 33 e da 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;}

Prende l'indirizzo di un array di caratteri come input e scrive la stringa nell'array.

Provalo online!

Chiama con:

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

Produzione:

Vecchia versione (90 byte - 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 caratteri - 60 bonus = 246) (206 caratteri - 50 bonus = 156)

(123 caratteri = 173 caratteri - 50 bonus)

Tipo di nooby, probabilmente potrebbe ottenere di più ... Fammi sapere se ho riempito qualcosa, questo avvisa "Tutta la tua base ci appartiene". Anche questo è 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")')()

Se conti la console stessa come output, anche questo conterrebbe (57 con 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 byte)

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] Questo programma può essere decodificato utilizzando xxd -r.
[2] Sì, riutilizza la soluzione pesante qui. Penso che sia ... il terzo problema che ho risolto in questo modo. Forse dovrei passare a qualcos'altro, ma non è che questo non sia ottimo per problemi che ti proibiscono di usare la maggior parte dei personaggi.}

Bash, 52-10-30 = 12

Quanto segue deve essere eseguito in un ambiente (ancora abbastanza comune) ISO-8859-1:

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

Questo chiama tr, che traduce i caratteri in modo adeguato. Ho dovuto usare la re violare la regola 2, oppure usare una cifra nell'evasione e violare la regola 3. Dato che 3 dà più bonus, ho scelto la prima.

Pure Bash (senza risorse esterne), 141 caratteri - 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

Rilascio intenzionale del bonus da 10 punti per ottenere un punteggio complessivo migliore.

Funziona su qualsiasi bashversione 3.00.15 o successive che ho provato.

Come funziona

Non c'è scienza missilistica qui - solo bashespansioni di una forma o dell'altra:

• Espansione esadecimale semplice per ottenere il carattere richiesto. Funziona con personaggi la cui rappresentazione esadecimale non contiene [012]. ad es. $'\x65'ci dàe
• Per altri caratteri, generiamo un array bash di caratteri sequenziali usando l'espansione del controvento in un'inizializzazione dell'array ( Z=({k..v})). L'inizio dell'espansione del controvento viene scelto con cura in modo che gli indici dei caratteri richiesti non contengano [012]. ad es . ${Z[7]}ci dà r.
• bashè abbastanza flessibile da consentire la costruzione dei suoi comandi dal contenuto di più stringhe. Quindi si $f$'\x63'h$iespande a echo.
• Per i caratteri richiesti solo una volta, l'espansione viene inserita in linea con la stringa di comando echo.
• Per i caratteri richiesti due o più volte, è più efficiente espanderli alle variabili, quindi fare riferimento alle variabili.

Risposta precedente con bonus completo, ma punteggio complessivo peggiore:

Pure Bash (senza risorse esterne), 193 caratteri - 60 bonus = 133

So che non vincerà, ma volevo dimostrare a me stesso che è possibile bash, soddisfacendo al contempo tutti i requisiti:

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

Ciò richiede una versione abbastanza recente di bashper l' ${c^}espansione dei parametri. 4.2.25 va bene, ma 3.2.48 è un no-go.

Postscript, 364-40 = 324

loserOvviamente non potrei farcela . :)

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

Questo inizia con la codifica del testo come stringhe 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 quindi rimuovendo aritmeticamente 1 e 0 e 2. Le stringhe possono quindi essere rigenerate con 36 <string-buf> cvrs, ma ciò produce lettere maiuscole, quindi è necessario scorrere ripetutamente e aggiungere 0x20 per renderle minuscole.

Gli operatori cvx execci consentono di eseguire frammenti di stringa di token operatore con codifica binaria in varie codifiche. Il più semplice è codificare un operatore in esadecimale <92??>ma c'è un 2 lì dentro! Quindi la codifica "di primo livello" è ascii85. Quindi tutte le stringhe che contenevano ancora caratteri proibiti hanno attraversato livelli extra di hex -> ascii85 -> hex -> ascii85.

Brainfuck, 306 - 60 = 246

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

PHP, 186-10-30 = 146

Ho dovuto diventare un po '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'?>

Python, 181 - 40 = 141

[Sto usando la versione 2.7.2 YMMV - il builtin, fileè andato in 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 segna:

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

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

Non sono sicuro che avrebbe potuto essere abbreviato (nel complesso) non ottenendo uno dei bonus del codice - il mio obiettivo era un po 'meno sulla carenza e un po' di più sul -60 ... Mi piaceva la sfida di non usare uno dei personaggi con restrizioni.

E ... l'ho preso in giro - ho perso il comando "S" iniziale. : - /

Comunque, ecco una versione "senza regole" - espandendo le variabili.

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 questo gli dà un punteggio di 177-60 = 117. Quindi infrangere la regola centrale mi ha comunque dato un punteggio complessivo più basso.

Perl 5, 99-50 = 49

Una subroutine che restituisce la stringa richiesta:

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

Guardalo stampato così:

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