2009-05-27 - freenode:#esoteric

←2009-05-26 2009-05-27 2009-05-28→ ↑2009 ↑all

00:03:33 <ehird> if you tall likk thii, all worr can be redd to fouu lett.

00:05:20 <AnMaster> um... shouldn't that be "cann", "beee" and "tooo"?

00:05:50 <AnMaster> oh and alll, ifff (stands for: if and only iff)

00:06:08 <AnMaster> night

00:06:44 -!- oerjan has joined.

00:07:19 <ehird> AnMaster: only words >=4 letters

00:08:06 <AnMaster> ah

00:08:08 <AnMaster> still, I like ifff

00:08:12 <ehird> iffffffffffffffffffff

00:09:02 <AnMaster> indeed! :D

00:12:09 -!- KingOfKarlsruhe has quit (Remote closed the connection).

00:13:02 <pikhq> I like using punctuation at random."“»›‹¡¿‽’—–

00:13:19 <ehird> ‽‽‽‽‽“º-ß•ªˆ´•¶þ̂‡†›‹̂†‡°̂*(~↙‽↘⁴⁵⁴⁵

00:13:35 <pikhq> Touché.

00:13:45 <pikhq> (douché)

00:14:29 <ehird> New favourite word: Douché

00:14:42 <ehird> French

00:14:42 <ehird> [edit]Verb

00:14:43 <ehird> douché

00:14:45 <ehird> Past participle of doucher.

00:14:47 <ehird> "To shower"

00:14:54 <ehird> pikhq: you've showered?

00:14:57 <ehird> *you

00:15:07 <pikhq> LMAO

00:19:06 * oerjan tends to smirk whenever he sees the company name Deloitte Touche

00:19:18 <oerjan> the reason, now, should be obvious.

00:20:09 <pikhq> LMAO

00:21:03 * oerjan didn't know about the tohmatsu at the end. it doesn't really help.

00:23:30 <pikhq> Touché, douché™©®.

00:25:01 * oerjan notes that he is not alone

00:25:32 <pikhq> Indeed. Ørjan.

00:25:54 * oerjan gives pikhq a spelling bee medal

00:26:25 <pikhq> SPËLLÏNG BËË!

00:26:54 * pikhq has been abusing the Compose key

00:28:52 <oerjan> Höw rúdê

00:31:06 <ehird> Ï’ḿ ābüßïñg tḧẽ őþtıøñ ké¥

00:55:29 -!- Patashu has joined.

01:06:20 -!- nescience has joined.

01:07:20 -!- inurinternet has quit (No route to host).

01:14:50 <nescience> in this bfjoust thing, values are 8 bits right? (256 = 0)

01:15:03 <ehird> yes

01:15:11 <ehird> nescience: http://codu.org/eso/bfjoust/report.txt

01:15:16 <ehird> and !bfjoust name program

01:15:21 <ehird> omit your name, it adds it automatically

01:15:35 <ehird> nescience: program sources at http://codu.org/eso/bfjoust/in_egobot/

01:15:41 <nescience> i submitted it already

01:15:43 <nescience> :>

01:15:43 <ehird> ah

01:15:45 <ehird> i didn't notice :)

01:15:50 <nescience> but i apparently miscalculated

01:15:57 <nescience> i need more details on how [] works

01:16:03 <ehird> ehm

01:16:09 <ehird> [a] is while (*ptr) a

01:16:16 <ehird> as in, while the current cell is not 0, run a

01:16:20 <nescience> my understanding was that when it reaches ] it checks if 0

01:16:23 <ehird> nescience: a loop takes two iterations, iirc

01:16:29 <ehird> so [a][a][a]

01:16:38 <nescience> so if it was 0 when it executes [, it will still execute the code inside the brackets, yes?

01:16:39 <ehird> that is, ] jumps back to [ if the cell isn't 0, I believe

01:16:42 <ehird> nescience: no

01:16:45 <nescience> whoops

01:16:48 <nescience> :P

01:16:50 <ehird> both [ and ] could be said to check

01:17:02 <nescience> annoying, ok trying again

01:17:03 <ehird> nescience: let's say your a runs 3 times before setting it to 0

01:17:05 <ehird> the cycles used are:

01:17:13 <ehird> [a][a][a]b

01:17:15 <ehird> where b is the program after

01:17:17 <ehird> I believe.

01:17:24 <ehird> that's only relevant if you're counting cyclse

01:17:25 <ehird> *cycles

01:17:38 <nescience> if [ checks, that explains what happened

01:17:42 <nescience> fixing now :>

01:17:52 <nescience> so wait

01:17:55 <nescience> if your poiner is on a 0

01:18:06 <nescience> and your code is [+], for example

01:18:10 -!- Corun has changed nick to Corun|away.

01:18:12 <nescience> nothing gets incremented, and it takes one cycle?

01:18:18 <oerjan> ehird: not two iterations, the ] jumps to _after_ the [

01:18:27 <ehird> oerjan: oh, right

01:18:32 <ehird> nescience: it'd use [a]a]a]b

01:18:38 * nescience nods

01:18:38 <ehird> nescience: and correct

01:18:48 <nescience> ok

01:18:55 <nescience> i can remove one wait instruction at least then :)

01:19:04 <ehird> if your code is [-] and your pointer is 3, [-]-]-] is executed

01:19:21 <nescience> i'm just wanting to know about the case where pointer is 0 atm

01:19:34 <ehird> nescience: then [ is executed

01:19:44 <nescience> but not +]

01:20:06 <nescience> and the 0-check, for the purposes of both programs executing at once, happens before instructions are executed

01:20:28 <ehird> nescience: here's some exact semantics for you

01:20:37 <ehird> note that these all happen on the tick - nothing happens before or after a tick

01:20:48 <ehird> [ if the current cell is 0, jump to the instruction after the matching ]. otherwise, nop.

01:20:56 <ehird> ] if the current cell is 0, nop. otherwise, jump to the instruction after the matching [.

01:21:03 <nescience> thanks

01:21:12 <ehird> welcome

01:21:47 <nescience> knowing my luck the 'fixed' version will probably score worse, but we'll see

01:21:49 -!- Corun|away has changed nick to Corun.

01:22:01 <nescience> nope, did better :>

01:22:19 <nescience> and beats defend6, like it was supposed to

01:22:19 <ehird> nescience: btw, you should try it in channel

01:22:23 <nescience> that chart is hard to read

01:22:23 <ehird> as it reports the score immediately

01:22:28 <nescience> ah

01:22:40 <nescience> it only runs one matchup?

01:22:41 <ehird> and it saves us going to the file list :-)

01:22:45 <ehird> nescience: right, then updates the report

01:23:06 <nescience> since the board is random, that seems like a bad idea

01:23:15 <ehird> nescience: 'the board is random'?

01:23:15 <nescience> err, the "tape"

01:23:17 <ehird> ah

01:23:19 <ehird> not really

01:23:23 <ehird> it doesn't change the scores much.

01:23:26 <ehird> no, wait

01:23:27 <nescience> the length of the playing field

01:23:28 <ehird> nescience: it runs many matchups

01:23:32 <ehird> but only (yourprog,*)

01:23:36 <ehird> the actual report has to run (*,*)

01:23:39 <ehird> although it -does- cache

01:23:40 <nescience> mk

01:23:51 <nescience> thought that would be how it works, but i don't get the +/- then

01:23:58 <oerjan> ehird: it didn't cache before today, at least

01:24:02 <nescience> i guess it just tells you overall if you won >50% or something?

01:24:03 <oerjan> reruns all matches

01:24:08 <ehird> nescience: + is "won against this program"

01:24:11 <ehird> - is "lost against this program"

01:24:18 <ehird> 0 is "draw"

01:24:21 <ehird> space is "this IS that prorgam!"

01:24:24 <ehird> oerjan: it doesn ow

01:24:34 <ehird> nescience: a random tape length is picked for each matchup

01:24:54 <nescience> yes, the "won" or "lost" was apparent, but made it seem like each pair only battled once

01:24:59 <ehird> nescience: they do

01:25:00 <nescience> which, for a random length field seems like a bad idea

01:25:04 <nescience> ah.

01:25:05 <ehird> why?

01:25:09 <ehird> it doesn't matter in 90% of cases

01:25:14 <ehird> nescience: it's just to stop this degenerate strategy:

01:25:18 <nescience> because either 1) random length doesn't matter, in which case it shouldn't be random

01:25:19 <ehird> (>)*tapelength[-]

01:25:29 <ehird> nescience: which is provably perfect for a given constant tapelength N

01:25:31 <nescience> or 2) it matters, which means it affects the outcome and you can get "lucky"

01:25:42 <nescience> yeah, i follow

01:25:52 <ehird> nescience: you can get lucky ONCE by guessing the tape length correctly in advance. However, that length will be different for every other matchup.

01:26:02 <nescience> i don't mean get lucky that way

01:26:04 <ehird> And the probability is incredibly high that it will fail hard on the others.

01:26:10 <nescience> i mean, some strategies are likely to be faster or slower than others

01:26:20 <nescience> and thus the tape length might cause a given matchup to win or lose

01:26:22 <ehird> nescience: Yes, but the statistical difference is incredibly minimal.

01:26:37 <nescience> it doesn't seem fair to give only one chance if the random selection is what determines the outcome

01:26:39 * nescience shrugs

01:26:40 <ehird> +/- 10 points in one uncommon case in my tests.

01:26:44 <ehird> er, score

01:26:57 <ehird> which is just 10% error, really quite irrelevant

01:27:02 <ehird> nescience: remember that whenever someone adds a new warrior,

01:27:04 <nescience> well since there's <10 points difference between the top entries.. :P

01:27:06 <ehird> it will battle against every one

01:27:08 <ehird> with a new tape length

01:27:23 <ehird> nescience: remember, that was an odd cas

01:27:23 <ehird> e

01:27:29 <ehird> I imagine +/- 3-5 points is the most common case

01:27:32 <ehird> it's Good Enough

01:27:33 <nescience> yes, i'm doing a lot of remembering :)

01:27:37 <oerjan> if caching is working, then it would be feasible to battle _all_ possible tape lengths

01:27:42 <nescience> and if #1 is -5 and #2 is +5?

01:27:50 <oerjan> and take the average

01:27:54 <nescience> oerjan: that would be pretty nice

01:28:11 <ehird> oerjan: that would be over 10x slower

01:28:17 <nescience> i didn't really consider that the randomness is so narrow that an exhaustive test is feasible

01:28:18 <ehird> as there is over 10 variations in tape length

01:28:21 <ehird> it's slow enough as is

01:28:24 <ehird> ANYWAY

01:28:27 <ehird> This really doesn't matter.

01:28:29 <nescience> seemed pretty fast to me :P

01:28:38 <nescience> do like corewars stuff and queue up the entries, who cares about instant results!

01:28:44 <nescience> hehe

01:28:52 <oerjan> ehird: 10..30 isn't it? so only 20 times, which is half made up for by the hill now caching the rest

01:28:57 <ehird> nescience: it took ~25-35 seconds to generate the report previously

01:28:59 <ehird> which is lame

01:29:09 <ehird> (w/o caching)

01:29:20 <oerjan> ok i guess that's not so nice

01:29:47 <nescience> 25-35 seconds to run 10 battles

01:29:55 <nescience> so it'd take a minute to run 20, w

01:29:59 <nescience> not that bad :P

01:30:01 <ehird> !bfjoust et_tu_brute (>)*9((-)*128.>)*20

01:30:06 <EgoBot> Score for ehird_et_tu_brute: 12.0

01:30:13 <ehird> hm that did really terribly

01:30:16 <ehird> -7 points

01:30:19 <ehird> I wonder why?

01:30:36 <ehird> It goes the minimum length, then bruteforcedly decrements 128, sleeps a cycle, then steps onward.

01:30:51 <ehird> !bfjoust et_tu_brute (>)*9((-)*128.>)*21

01:30:53 <EgoBot> Score for ehird_et_tu_brute: 12.0

01:30:55 <oerjan> ehird: because you don't stop when it gets to 0?

01:31:02 <nescience> run off the end

01:31:07 <ehird> no no no

01:31:09 <nescience> maybe

01:31:23 <ehird> nescience: it decrements 128 (the default tape value, and nobody seems to tamper with it), then sleeps one cycle

01:31:27 <nescience> yeah, i can see it

01:31:34 <ehird> so if it hits the opponents' flag, it wins immediately

01:31:37 <ehird> as long as it's 128

01:31:46 <nescience> seems like some sort of bug

01:31:55 <ehird> oerjan: stop when it gets to 0? I don't follow

01:32:00 <ehird> it sleeps one cycle after decimating

01:32:01 <nescience> well, defend6 will beat it

01:32:07 <ehird> so it wins, if it's got the opponent's flag

01:32:15 <ehird> and it's 128 beforehand

01:32:15 <nescience> i haven't read all the rest but most of them don't "turn back" and do anything

01:32:16 <oerjan> ehird: it will be horrible for all spots that _aren't_ 128

01:32:25 <nescience> yeah, i guess it just takes too long

01:32:29 <ehird> oerjan: ah, probably

01:32:29 <nescience> since it doesn't skip over the 0s fast

01:32:40 * ehird looks up the "if not 0" thing on the wiki

01:32:51 <nescience> oh? i'm interested

01:32:58 <nescience> i was just pondering that earlier

01:33:07 <oerjan> hm...

01:33:14 <ehird> nescience: http://esolangs.org/wiki/Brainfuck_algorithms#if_.28x_.3D.3D_0.29_.7B_code_.7D

01:33:16 <ehird> you need two temporaries

01:33:18 <ehird> which is a pain

01:34:04 <ehird> ooh

01:34:25 <ehird> nescience: http://esolangs.org/wiki/Brainfuck_algorithms#x_.3D_not_x_.28boolean.2C_logical.29

01:34:28 <ehird> perhaps

01:34:48 <ehird> argh

01:34:50 <ehird> it's inefficient

01:35:05 <nescience> i kinda like my solution, it exploits defend6 and makes it kill itself :>

01:35:33 <nescience> i score less than impomatic's though

01:35:40 <nescience> and i have 2 losses and a tie, while his has 3 losses

01:35:42 <nescience> i r confus?

01:36:28 <oerjan> !bfjoust mi_fili (>)*9(+[--[(-)*127]]>)*21

01:36:42 <ehird> !bfjoust et_tu_brute (>)*9(>[-]>[-]<<[>+>+<<-]>[<+>-]+>[<->[-]]<[<(-)*128.>-])*19

01:36:44 <EgoBot> Score for ehird_et_tu_brute: 12.0

01:36:49 <ehird> haha bollocks.

01:36:50 <EgoBot> Score for oerjan_mi_fili: 14.9

01:36:54 <oerjan> oh wait

01:36:57 <ehird> I BEAT OERJAN YAY

01:36:58 <nescience> what is this stuff on the wiki

01:37:05 <oerjan> i'm not checking it it's _already_ 0

01:37:05 <ehird> nescience: whatya mean

01:37:05 <nescience> temp0[-]

01:37:13 <ehird> In the interest of generality, the algorithms will use variable names in place of the < and > instructions. Temporary cells are denoted "temp". When using an algorithm in a program, replace the variable names with the correct number of < or > instructions to position the pointer at the desired memory cell.

01:37:14 <ehird> Example:

01:37:16 <ehird> If "a" is designated to be cell 1, "b" is cell 4, and the pointer is currently at cell 0, then:

01:37:18 <ehird> nescience: that

01:37:24 <ehird> so, if you say x=cell 0, temp0=cell 1, temp1=cell 2

01:37:31 <ehird> x temp0 x temp1

01:37:32 <ehird> would be

01:37:34 <nescience> ah

01:37:36 <ehird> (starting on cell 1)

01:37:42 <ehird> <><>>

01:37:44 <oerjan> !bfjoust mi_fili2 (>)*9([+[--[(-)*127]]]>)*21

01:37:47 <ehird> (>)*9(>[-]>[-]<<[>+>+<<-]>[<+>-]+>[<->[-]]<[<(-)*128.>-])*19

01:37:48 <ehird> should be

01:37:48 <nescience> i follow

01:37:49 <EgoBot> Score for oerjan_mi_fili2: 41.0

01:37:54 <oerjan> huh

01:37:59 <oerjan> O_O

01:38:06 <nescience> woot 2nd place

01:38:08 <nescience> ZR

01:38:10 <nescience> :P

01:38:21 * nescience studies the competition

01:38:24 <ehird> "Go right 9 times. cell = (cell == 0) (using temps cell+1, cell+2). If it is not zero, decrement 128.

01:38:25 <ehird> hm wait

01:38:27 <ehird> I may have it the other way around

01:38:28 <ehird> whatever

01:38:44 <ehird> http://codu.org/eso/bfjoust/in_egobot/impomatic_kicks_ehird.bfjoust

01:38:48 <ehird> nescience: oerjan: try and beat t hat one

01:38:51 <ehird> it's really good for some reason

01:39:13 <ehird> it was just designed to beat http://codu.org/eso/bfjoust/in_egobot/ehird_flux_a_counteracting_monomorphism_cocktails.bfjoust, which is my copy of impomatic_flux.bfjoust swapping + and -

01:39:24 <nescience> !bfjoust creep (>-+[-].++>-+[-].--)*15

01:39:25 <EgoBot> Score for nescience_creep: 64.0

01:39:44 <nescience> wait what just happened

01:39:51 <nescience> 824.69-5nescience_creep.bfjoust

01:39:57 <ehird> ha

01:39:59 <nescience> also i think i musta had a bug

01:40:02 <ehird> nescience: tape length dependent?

01:40:05 <nescience> no

01:40:13 <nescience> that as the 2nd plac entry, just changed to decs instead of incs

01:40:20 <nescience> 'cause impomatic's leaves cells with 1

01:40:28 <nescience> lemme think for a sec

01:40:52 <nescience> i dunno, putting it back :P

01:40:58 <nescience> !bfjoust creep (>-+[+].++>-+[+].--)*15

01:41:00 <EgoBot> Score for nescience_creep: 24.7

01:41:04 <ehird> !bfjoust flux_a_revolutionary_perspective_and_et_tu_brute (>)*8(>[(+)*128.])*21

01:41:06 <nescience> the bot says the old score

01:41:07 <EgoBot> Score for ehird_flux_a_revolutionary_perspective_and_et_tu_brute: 24.0

01:41:07 <nescience> not the new one

01:41:17 <nescience> now i was at 4th plac

01:41:18 <ehird> nescience: it takes a little to generate the report.

01:41:20 <nescience> on the same hill

01:41:20 <ehird> refresh

01:41:28 <nescience> talk about random lengths not affecting it eh? :)

01:41:38 <ehird> !bfjoust flux_a_revolutionary_perspective_and_et_tu_brute (>)*8(>[(+)*255.])*21

01:41:40 <EgoBot> Score for ehird_flux_a_revolutionary_perspective_and_et_tu_brute: 24.0

01:41:55 <nescience> i wonder, maybe something's just wrong

01:42:03 <ehird> !bfjoust flux_a_revolutionary_perspective_and_et_tu_brute (>)*8([(+)*128.]>)*21

01:42:05 <EgoBot> Score for ehird_flux_a_revolutionary_perspective_and_et_tu_brute: 24.0

01:42:10 <ehird> !bfjoust flux_a_revolutionary_perspective_and_et_tu_brute (>)*8([(+)*128..]>)*21

01:42:12 <EgoBot> Score for ehird_flux_a_revolutionary_perspective_and_et_tu_brute: 24.0

01:42:18 <nescience> i assumed that submitting it would give the same result against the same hill where it was already sitting there

01:42:21 <nescience> true/not true?

01:42:28 <ehird> nescience: wut

01:42:29 <ehird> ?

01:42:56 <nescience> i'm referring to toggling between 2nd and 4th(5th? didn't get a very good look) place with the same code

01:43:04 <ehird> !bfjoust hangup >(+)*20001

01:43:12 <ehird> nescience: odd. oh well

01:43:18 <EgoBot> Score for ehird_hangup: 6.0

01:43:20 <ehird> mwahaha, hangup is the slow

01:43:24 <ehird> wow that's bad

01:43:28 <nescience> lol

01:43:36 <ehird> nescience: submit a warrior - any warrior - just to get rid of hangup :D

01:43:57 <nescience> !bfjoust hangup2 >(-)*20001

01:44:00 * nescience grins

01:44:06 <ehird> ha

01:44:12 <EgoBot> Score for nescience_hangup2: 6.0

01:44:16 <ehird> and it replaces me!

01:44:17 <ehird> !bfjoust chopsueyside (-)*128

01:44:21 <EgoBot> Score for ehird_chopsueyside: 6.0

01:44:24 <ehird> baha

01:44:26 <ehird> *bahaha

01:44:31 <ehird> i bet 6.0 is the worst possible score

01:44:39 <ehird> GregorR-L: why does it add .0 and .00 if it's always whole?

01:45:43 <nescience> !bfjoust creep (>--[+]+>--[+]-)*15

01:45:44 <EgoBot> Score for nescience_creep: 60.0

01:45:51 <nescience> didn't do much for it did it :P

01:46:09 <ehird> !bfjoust risktaker (>)*20[>[-].+]

01:46:09 <nescience> oh crap, i wanted to do slightly different

01:46:13 <nescience> but i guess we're bein all spammy in here so

01:46:13 <EgoBot> Score for ehird_risktaker: 6.0

01:46:30 <ehird> hahaha

01:46:34 <ehird> nescience: what the hell is up with my progs :)

01:46:41 <nescience> also i broke the exploitation of defend6 again

01:47:32 <ehird> !bfjoust defend6_a_parody_or_just_plain_ripoff_question_mark http://pastie.org/490821.txt?key=w47xqyyhmkklmhegqzsog

01:47:37 <nescience> !bfjoust creep (>-+[-]+>-+[+]-)*15

01:47:39 <EgoBot> Score for nescience_creep: 52.0

01:47:47 <EgoBot> Score for ehird_defend6_a_parody_or_just_plain_ripoff_question_mark: 76.0

01:47:55 <ehird> IDScorePtsProgram

01:47:55 <ehird> 276.006ehird_defend6_a_parody_or_just_plain_ripoff_question_mark.bfjoust

01:47:55 <nescience> wtfwtf

01:47:56 <ehird> 772.004impomatic_kicks_ehird.bfjoust

01:47:58 <ehird> 862.004impomatic_shortsword.bfjoust

01:48:00 <ehird> 158.001ais523_defend6.bfjoust

01:48:02 <ehird> nescience: i just swapped + to -

01:48:04 <ehird> in defend6

01:48:06 <ehird> :-D

01:48:07 <nescience> i guess i should just stick to not changing anything

01:48:08 <ehird> AND NOW I AM KING OF THE HILL!!!!

01:48:11 <nescience> har

01:48:20 <nescience> i didn't know it took a url

01:48:20 <ehird> nescience: try and beat both defend6 and defend6_a_parody_or_just_plain_ripoff_question_mark

01:48:21 <ehird> >:)

01:48:27 <nescience> luls

01:48:28 <nescience> ok

01:48:28 <ehird> and yeah, that's how ais523 entered defend6

01:48:31 <ehird> since it was too long

01:48:34 <nescience> first let me find my working code

01:48:44 <ehird> 01:45 nescience: !bfjoust creep (>--[+]+>--[+]-)*15

01:48:44 <ehird> 01:45 EgoBot: Score for nescience_creep: 60.0

01:49:02 <ehird> fun fact: flux_a_counteracting_monomorphism_cocktails did quite well

01:49:05 <ehird> when impomatic_flux was in the hill

01:49:07 <ehird> I swapped + and -

01:49:10 <ehird> just like I did with defend6

01:49:13 <ehird> it's a sure-fire strategy!

01:49:30 <nescience> but i'm writing my warrior to be sign ambiguous

01:49:31 <nescience> :>

01:50:59 <nescience> oh, i looked at the code

01:51:00 <nescience> you dick :P

01:51:22 <ehird> sry 'bout that

01:51:25 <nescience> hehe

01:51:28 <ehird> mah internet did broke

01:51:31 <nescience> no worries, i will just submit a different one

01:51:36 <nescience> that does something different!

01:51:40 <ehird> ofc since I'm on a bouncer you all didn't notice

01:51:46 <ehird> thus you, nescience, think I am referring to bf joust!

01:51:57 <ehird> 17:49:31 <nescience> :>

01:51:57 <ehird> 17:50:59 <nescience> oh, i looked at the code

01:51:59 <ehird> 17:51:00 <nescience> you dick :P

01:52:01 <ehird> didn't notice that

01:52:03 <ehird> but er I just said I did that :

01:52:05 <ehird> D

01:52:07 <nescience> aha?

01:52:07 <ehird> :D

01:52:14 <nescience> yeah, but i forgot quite what it entailed

01:52:24 <nescience> my solution can't be as elegant now

01:52:34 <nescience> or i could just submit two eaters

01:52:34 <nescience> :P

01:52:41 <Patashu> how do I look at the current hill's status?

01:52:43 <ehird> !bfjoust im_a_creep_im_a_weirdo_im_a_ripoff_lolradiohead (>--[-]->--[-]+)*15

01:52:46 <ehird> Patashu: http://codu.org/eso/bfjoust/report.txt

01:52:52 <nescience> !bfjoust creep (>-+[+]++>-+[+]--)*15

01:52:53 <EgoBot> Score for nescience_creep: 27.0

01:53:01 <EgoBot> Score for ehird_im_a_creep_im_a_weirdo_im_a_ripoff_lolradiohead: 26.0

01:53:04 <ehird> hahaha

01:53:05 <nescience> !bfjoust inverse_creep (>+-[-]++>+-[-]--)*15

01:53:10 <EgoBot> Score for nescience_inverse_creep: 58.0

01:53:12 <ehird> nescience: that's not inverse

01:53:14 <ehird> the last one should be +

01:53:15 <ehird> like mine

01:53:17 <nescience> no

01:53:37 <nescience> whatever, it doesn't matter about that part

01:53:48 <nescience> you swapped it wrong :)

01:54:11 <nescience> hehe, one beats defend6 and one beats parody

01:54:17 <nescience> i wonder if i can do em both at once though

01:54:31 <nescience> the elegant part is i didn't have to delay every step

01:54:31 <comex> !bfjoust (>>[-])*200

01:54:31 <EgoBot> Use: !bfjoust <program name> <program>

01:54:37 <comex> !bfjoust naive (>>[-])*200

01:54:39 <nescience> since i took advantage of it sitting on a 1

01:54:40 <EgoBot> Score for comex_naive: 15.0

01:54:48 <nescience> i just made mine loop around the "long way", giving it time to suicide

01:55:03 <comex> !bfjoust naive2 (>[-])*200

01:55:07 <nescience> but i can't very well do that in both directions

01:55:07 <EgoBot> Score for comex_naive2: 5.0

01:55:18 <nescience> so i'd have to delay at every step, not just the one before the winning spot (vs that warrior)

01:55:39 <nescience> or time it so that it doesn't matter

01:55:40 <Patashu> !bfjoust naiverush (>)*9([-]>)*21

01:55:42 <nescience> maybe i should do that

01:55:46 <EgoBot> Score for Patashu_naiverush: 9.0

01:55:57 <comex> !bfjoust naive2 (>-[-])*200

01:55:58 <EgoBot> Score for comex_naive2: 5.0

01:56:05 <comex> !bfjoust naive2 (>--[-])*200

01:56:06 <EgoBot> Score for comex_naive2: 5.0

01:56:08 <ehird> !bfjoust mover_is_a_groover_not_naiver_but_a_cleaver (>[-].)*30

01:56:10 <comex> !bfjoust naive2 (>--[-])*0

01:56:12 <EgoBot> Score for comex_naive2: 5.0

01:56:18 <Patashu> !bfjoust rushpolarity (>)*9([-]>[+]>)*11

01:56:25 <comex> oh, I forgot to change the name

01:56:26 <nescience> freaks :P

01:56:29 <EgoBot> Score for Patashu_rushpolarity: 13.9

01:56:29 <EgoBot> Score for ehird_mover_is_a_groover_not_naiver_but_a_cleaver: 13.2

01:56:30 <comex> !bfjoust naive3 (>--[-])*0

01:56:33 <ehird> comex: stop that

01:56:34 <ehird> use the same name

01:56:37 <ehird> otherwise you cluter the hill

01:56:37 <nescience> poor bot

01:56:39 <ehird> *clutter

01:56:44 <ehird> 01:56 EgoBot: Score for ehird_mover_is_a_groover_not_naiver_but_a_cleaver: 13.2

01:56:47 <ehird> sweet i lost awesomely

01:56:51 <ehird> whoa

01:56:52 <ehird> 12 programs

01:56:56 <comex> ehird: then why does an empty script have a score of 5

01:57:05 <ehird> comex: because some other ones are even stupider?

01:57:10 <Patashu> !bfjoust rushpolarity >++++++>------(>)*7([-]>[+]>)*11

01:57:11 <EgoBot> Score for Patashu_rushpolarity: 13.9

01:57:13 <comex> !bfjoust naive2 <

01:57:14 <EgoBot> Score for comex_naive2: 6.2

01:57:18 <comex> WAT

01:57:31 <Patashu> !bfjoust rushpolarity >++++++>------(>)*7(+[-]>-[+]>)*11

01:57:32 <EgoBot> Score for Patashu_rushpolarity: 42.1

01:57:33 <ehird> comex: off end of tape = draw

01:57:34 <ehird> i believe

01:57:36 <Patashu> aha

01:57:37 <Patashu> :)

01:57:37 <comex> !bfjoust naive4 (>-->-[-])*0

01:57:44 <ehird> !bfjoust frenchie (-)*128

01:57:44 <comex> sorry, mistake

01:57:48 <comex> !bfjoust naive2 (>-->-[-])*200

01:57:49 <EgoBot> Score for ehird_frenchie: 5.4

01:57:50 <EgoBot> Score for comex_naive4: 5.4

01:57:50 <EgoBot> Score for comex_naive2: 6.2

01:57:53 <ehird> 5.4

01:57:54 <ehird> beat that fuckers

01:57:57 <comex> !bfjoust naive2 (>-->--[-])*200

01:57:58 <EgoBot> Score for comex_naive2: 6.2

01:58:03 <Patashu> if I submit one with a name and the previous one with that name got a higher score, it stays right?

01:58:08 <comex> !bfjoust naive2 (>(-)*128)*200

01:58:09 <EgoBot> Score for comex_naive2: 6.2

01:58:10 <ehird> Patashu: no

01:58:12 <ehird> !bfjoust frenchie (-)*128

01:58:14 <EgoBot> Score for ehird_frenchie: 5.5

01:58:15 <nescience> !bfjoust beatinit [-]

01:58:20 <ehird> 45.50-10ehird_frenchie.bfjoust

01:58:22 <ehird> that's just beautiful

01:58:22 <Patashu> k

01:58:28 <ehird> beautifully terrible

01:58:29 <EgoBot> Score for nescience_beatinit: 11.0

01:58:34 <Patashu> !bfjoust rushpolarity >++++++>------(>-)*7(+[-]>-[+]>)*11

01:58:34 <nescience> WAT

01:58:35 <ehird> nescience: takes longer to suicide

01:58:36 <EgoBot> Score for Patashu_rushpolarity: 24.0

01:58:39 <comex> !bfjoust defense >[([+]+)*200]

01:58:40 <nescience> oh

01:58:42 <ehird> [-]-]-]-] etc

01:58:43 <nescience> wait

01:58:43 <Patashu> !bfjoust rushpolarity >+++++>-----(>)*7(+[-]>-[+]>)*11

01:58:45 <ehird> whereas mine does ------------------------

01:58:45 <EgoBot> Score for Patashu_rushpolarity: 46.9

01:58:48 <nescience> !bfjoust beatinit <

01:58:49 <Patashu> nice

01:58:50 <EgoBot> Score for nescience_beatinit: 11.0

01:58:52 <nescience> WAT

01:58:55 <comex> !bfjoust defense >[([+]+)*200]

01:58:57 <ehird> nescience: < = draw

01:58:59 <ehird> unmatched ] = draw

01:58:59 <ehird> etc

01:59:04 <nescience> no

01:59:07 <EgoBot> Score for comex_defense: 5.8

01:59:08 <ehird> win > draw > loss

01:59:08 <nescience> it only draws if they both lose

01:59:12 <Patashu> !bfjoust rushpolarity >++++>----(>)*7(+[-]>-[+]>)*11

01:59:13 <nescience> i got -11

01:59:14 <EgoBot> Score for Patashu_rushpolarity: 24.8

01:59:15 <nescience> :)

01:59:19 <nescience> all losses

01:59:19 <Patashu> !bfjoust rushpolarity >+++++>----(>)*7(+[-]>-[+]>)*11

01:59:20 <comex> how the hell is this calculated

01:59:21 <EgoBot> Score for Patashu_rushpolarity: 25.9

01:59:24 <nescience> fjear

01:59:25 <Patashu> !bfjoust rushpolarity >+++++>-----(>)*7(+[-]>-[+]>)*11

01:59:26 <EgoBot> Score for Patashu_rushpolarity: 59.3

01:59:29 <Patashu> hmm

01:59:34 <ehird> comex: Wins against bad opponents count less for your score.

01:59:36 <Patashu> those decoys are really important haha

01:59:39 <ehird> Points is just wins - losses.

01:59:45 <Patashu> !bfjoust rushpolarity >+++++>----->+(>)*6(+[-]>-[+]>)*11

01:59:46 <ehird> But score is better.

01:59:47 <EgoBot> Score for Patashu_rushpolarity: 6.2

01:59:52 <Patashu> !bfjoust rushpolarity >+++++>----->+++++(>)*6(+[-]>-[+]>)*11

01:59:54 <EgoBot> Score for Patashu_rushpolarity: 19.8

01:59:56 <ehird> As you have to beat good warriors to get a high score.

02:00:01 <Patashu> !bfjoust rushpolarity >+++++>-----(>)*7(+[-]>-[+]>)*11

02:00:03 <EgoBot> Score for Patashu_rushpolarity: 13.6

02:00:03 <nescience> nobody told me that

02:00:07 <ehird> nescience: now I did

02:00:11 <Patashu> huh

02:00:13 <nescience> so i guess if i beat both defend6 and its inverse i can get good points

02:00:18 <Patashu> I changed it back to an old setup and it's scoring much lower

02:00:20 <Patashu> haha

02:00:22 <ehird> Patashu: nescience: http://codu.org/eso/fyb/SCORES

02:00:23 <nescience> i could just resubmit until i get lucky

02:00:25 <nescience> >:)

02:00:27 <nescience> !bfjoust creep (>+-[-]++>-+[+]--)*15

02:00:28 <EgoBot> Score for nescience_creep: 30.9

02:00:29 <comex> !bfjoust defense (>-)*50

02:00:30 <nescience> it has one for each of them

02:00:31 <EgoBot> Score for comex_defense: 5.8

02:00:31 <ehird> applies to FYB but bfjoust is the same system

02:00:37 <comex> !bfjoust defense (>->+)*25

02:00:39 <EgoBot> Score for comex_defense: 5.0

02:00:45 <comex> why

02:00:50 <nescience> it has one for each of them

02:00:53 <nescience> wait

02:00:53 <nescience> !bfjoust creep (>+-[-]++>-+[+]--)*15

02:00:55 <comex> !bfjoust defense (>->+)*20

02:00:55 <EgoBot> Score for nescience_creep: 29.0

02:00:56 <EgoBot> Score for comex_defense: 5.0

02:01:00 <Patashu> !bfjoust rushpolarity >+++++>-----(>)*7(++[-]>--[+]>)*11

02:01:01 <ehird> 02:00 comex: why

02:01:02 <EgoBot> Score for Patashu_rushpolarity: 33.0

02:01:04 <ehird> you go off the edge of the tape

02:01:07 <ehird> and never get a flag

02:01:10 <comex> how big is the tape?

02:01:12 <Patashu> !bfjoust rushpolarity >+++++>-----(>)*7(+++[-]>---[+]>)*11

02:01:12 <ehird> comex: 10-30

02:01:13 <ehird> randomly

02:01:14 <EgoBot> Score for Patashu_rushpolarity: 42.0

02:01:15 <comex> oh

02:01:17 <comex> so different from agora

02:01:21 <ehird> yes...

02:01:23 <ehird> and . is a nop

02:01:23 <comex> !bfjoust defense (>->+)*5

02:01:25 <EgoBot> Score for comex_defense: 5.5

02:01:27 <comex> !bfjoust defense (>->+)*10

02:01:28 <EgoBot> Score for comex_defense: 5.5

02:01:29 <Patashu> !bfjoust rushpolarity >+++++>-----(>)*7(++++[-]>----[+]>)*11

02:01:31 <ehird> we should get rid of -

02:01:31 <EgoBot> Score for Patashu_rushpolarity: 43.2

02:01:32 <ehird> and just have +

02:01:35 <ehird> to avoid trivial swaps

02:01:37 <nescience> lol you guys quit fucking up the report

02:01:41 <nescience> i wanna see if i got lucky or not

02:01:49 <nescience> damn, nope

02:01:49 <comex> !bfjoust (+)*127(>[-])*30

02:01:49 <EgoBot> Use: !bfjoust <program name> <program>

02:01:53 <nescience> !bfjoust creep (>+-[-]++>-+[+]--)*15

02:01:55 <EgoBot> Score for nescience_creep: 38.0

02:01:55 <Patashu> wow mine is doing really well o.O

02:01:56 <comex> !bfjoust naive (+)*127(>[-])*30

02:01:57 <EgoBot> Score for comex_naive: 15.0

02:02:02 <ehird> !bfjoust rushpolarity_with_reversed_polarity >----->+++++(>)*7(----[+]>++++[-]>)*11

02:02:03 <comex> !bfjoust naive (-)*127(>[-])*30

02:02:04 <EgoBot> Score for comex_naive: 7.5

02:02:08 <comex> !bfjoust naive (+)*127(>[+])*30

02:02:09 <EgoBot> Score for comex_naive: 7.5

02:02:15 <comex> !bfjoust naive (+)*127(>[--])*30

02:02:17 <EgoBot> Score for comex_naive: 7.5

02:02:18 <ehird> comstop it.

02:02:19 <nescience> ......

02:02:20 <comex> !bfjoust naive (+)*127(>[-])*30

02:02:20 <ehird> comex: stop it.

02:02:21 <EgoBot> Score for comex_naive: 7.5

02:02:22 <ehird> STOP IT

02:02:28 <comex> why did the exact same program get a different score

02:02:30 <EgoBot> Score for ehird_rushpolarity_with_reversed_polarity: 44.6

02:02:36 <ehird> comex: randomized tape lengths

02:02:43 <nescience> because the lengths are random, so sometimes it might win or lose depending on that

02:02:50 <nescience> ha

02:02:51 <comex> !bfjoust naive (>)*29(-)*128

02:02:52 <ehird> yes, but if you do, your program sux

02:02:52 <nescience> i got one that tied them both

02:02:53 <EgoBot> Score for comex_naive: 7.0

02:02:56 <Patashu> hey I have an idea

02:02:58 <nescience> but i don't want that

02:03:01 <nescience> !bfjoust creep (>+-[-]++>-+[+]--)*15

02:03:01 <Patashu> to avoid trivial swaps but keep the functionality of + and - differing

02:03:02 <EgoBot> Score for nescience_creep: 29.0

02:03:03 <nescience> BEAT THEM BOTH

02:03:03 <comex> !bfjoust naive (>)*20[-](>)*9(-)*128

02:03:04 <EgoBot> Score for comex_naive: 7.0

02:03:12 <Patashu> how about at the start of each match it randomly swaps or doesn't swap all your +s and -ses?

02:03:30 <ehird> Patashu: meh

02:03:34 <nescience> no luck

02:03:36 <comex> !bfjoust naive (>)*20--[+](>)*9(-)*128

02:03:36 <nescience> oh well

02:03:37 <EgoBot> Score for comex_naive: 8.0

02:03:46 <Patashu> well it would make a program and the program with opposite +-s functionally equivalent

02:03:51 <nescience> all of a sudden i have a bunch of losses

02:03:51 <comex> !bfjoust naive (>)*20(--[+]>)*200

02:03:53 <EgoBot> Score for comex_naive: 8.0

02:03:55 <Patashu> !bfjoust rushpolarity >+++++>-----(>)*7(+++++[-]>-----[+]>)*11

02:03:56 <EgoBot> Score for Patashu_rushpolarity: 60.0

02:04:08 <ehird> !bfjoust am_i_lame_enough_to_rip_off_shortsword_yes (>-->++)*2(>)*6([+[-]]>)*20

02:04:13 <Patashu> oh aah I see why this works

02:04:17 <EgoBot> Score for ehird_am_i_lame_enough_to_rip_off_shortsword_yes: 7.0

02:04:19 <Patashu> !bfjoust rushpolarity >+++++>-----(>)*7(++++++[-]>------[+]>)*11

02:04:20 <comex> !bfjoust naive (+)*127(>------)*20(--[+]>)*200

02:04:20 <ehird> haha

02:04:21 <EgoBot> Score for Patashu_rushpolarity: 57.0

02:04:21 <EgoBot> Score for comex_naive: 13.5

02:04:24 <ehird> IDScorePtsProgram

02:04:25 <ehird> 482.007ehird_defend6_a_parody_or_just_plain_ripoff_question_mark.bfjoust

02:04:29 <ehird> still chillin' at the top w/ my ripoff

02:04:29 <comex> !bfjoust naive (+)*127(>------)*20(--[+]>++[-])*200

02:04:30 <EgoBot> Score for comex_naive: 13.5

02:04:35 <ehird> comex: *200?

02:04:39 <nescience> laffo

02:04:39 <ehird> you're not even thinking about this logically

02:04:40 <ehird> also

02:04:46 <ehird> comex: the flag has to stay 0 for two generations

02:04:47 <ehird> "[-]-"

02:04:48 <ehird> Fail.

02:04:52 <Patashu> beating all but 1, 3, 4...

02:04:53 <ehird> It will never obliterate a flag.

02:04:54 <nescience> not fail

02:04:54 <comex> also a change from agora

02:04:55 <ehird> use . to nop

02:04:58 <comex> I should probably actually read the rules

02:04:59 <nescience> ] will nop

02:05:03 <nescience> according to what you said earlier

02:05:05 <ehird> nescience: oh, true

02:05:08 <ehird> still

02:05:11 <nescience> so the - will take it to 0

02:05:13 <nescience> (1 round)

02:05:17 <nescience> then the ] will nop

02:05:19 <nescience> (2 rounds)

02:05:23 <comex> !bfjoust naive (+)*127(>------)*20(--[+]>++[-])*10.

02:05:24 <EgoBot> Score for comex_naive: 40.1

02:05:29 <nescience> that's why i removed by .'s

02:05:31 <ehird> nescience: true

02:05:32 <comex> wat

02:05:42 <Patashu> !bfjoust rushpolarity >+++++>-----(>)*7(+++++++[-]>-------[+]>)*11

02:05:44 <nescience> you shoudl make it take longer

02:05:44 <EgoBot> Score for Patashu_rushpolarity: 54.3

02:05:47 <nescience> do the exhaustive battle

02:05:54 <nescience> and don't let people submit more than one while it's running

02:05:58 <nescience> make em sit back and think for a while

02:06:00 <nescience> instead of spamming :P

02:06:01 <Patashu> !bfjoust rushpolarity >+++++>-----(>)*7(++++++++[-]>--------[+]>)*11

02:06:03 <EgoBot> Score for Patashu_rushpolarity: 59.3

02:06:29 <ehird> !bfjoust (>)*14[>[-].+]

02:06:30 <EgoBot> Use: !bfjoust <program name> <program>

02:06:33 <ehird> !bfjoust an_thing (>)*14[>[-].+]

02:06:40 <EgoBot> Score for ehird_an_thing: 26.0

02:06:53 <Patashu> this is fun

02:07:24 <Patashu> !bfjoust rushpolarity >++++++>------(>)*7(++++++++[-]>--------[+]>)*11

02:07:26 <EgoBot> Score for Patashu_rushpolarity: 59.0

02:07:26 <GregorR-L> ehird: It didn't occur to me that it's always whole, it is because there are 10 programs ...

02:07:40 <ehird> GregorR-L: not true

02:07:44 <ehird> most often we have 11

02:07:45 <ehird> 0-11

02:07:48 <ehird> and sometimes we've had 12

02:07:50 <Patashu> !bfjoust rushpolarity >++++++>------(+>)*7(++++++++[-]>--------[+]>)*11

02:07:52 <EgoBot> Score for Patashu_rushpolarity: 51.9

02:07:55 <ehird> it doesn't seem to trim well if people submit a lot of proposals at once

02:08:00 <ehird> *warriors

02:08:02 <GregorR-L> It shouldn't always be whole then, as in that example :P

02:08:03 <ehird> atm:

02:08:03 <ehird> 638.89-3impomatic_dumb.bfjoust

02:08:04 <ehird> 538.89-3impomatic_chrome.bfjoust

02:08:06 <ehird> 217.28-6ehird_an_thing.bfjoust

02:08:09 <ehird> GregorR-L: Yes, but make it always stay at 10...

02:08:12 <Patashu> !bfjoust rushpolarity >+++++>-----(>)*7(++++++++[-]>--------[+]>)*11

02:08:13 <EgoBot> Score for Patashu_rushpolarity: 42.0

02:08:32 <Patashu> wait

02:08:33 <GregorR-L> ehird: It removes them after evaluating. 12 would be from two added at once, 11 is the "norm"

02:08:34 <Patashu> are you starting on cell 0

02:08:34 <Patashu> or 1?

02:08:50 <Patashu> like, track is 10-30 cells and you're on cell 1 right?

02:08:52 <GregorR-L> (Now that I'm thinking about the actual results of this deletion code :P )

02:08:58 <ehird> Patashu: 10-30 cells total

02:09:01 <Patashu> k

02:09:05 <ehird> but we number them from 0-29

02:09:23 <Patashu> !bfjoust rushpolarity (>)*7>++++++>------(++++++++[-]>--------[+]>)*11

02:09:25 <EgoBot> Score for Patashu_rushpolarity: 58.0

02:09:47 <ehird> !bfjoust rushpolishmenarity (>)*8>++++++>------(++++++++[-]>--------[+]>)*11

02:09:55 <EgoBot> Score for ehird_rushpolishmenarity: 28.0

02:09:58 <nescience> !bfjoust kekeke (>+>-)*4(>[[[-]]])*20

02:10:00 <ehird> !bfjoust rushpolishmenarity (>)*8>++++++>------(++++++++[-]>--------[+]>)*10

02:10:02 <Patashu> !bfjoust rushpolarity >++++++>------(>)*7(++++++++[-]>--------[+]>)*11

02:10:02 <EgoBot> Score for ehird_rushpolishmenarity: 28.0

02:10:03 <EgoBot> Score for Patashu_rushpolarity: 23.0

02:10:06 <Patashu> huh

02:10:07 <ehird> \o/

02:10:08 <Patashu> losing suddenly haha

02:10:11 <ehird> i beat you :P

02:10:22 <EgoBot> Score for nescience_kekeke: 21.0

02:10:47 <ehird> only two scores >50 now

02:10:50 <nescience> !bfjoust kekeke (>+>-)*4(>[[[+]]])*20

02:10:50 <ehird> defend6 and my ripoff

02:10:51 <EgoBot> Score for nescience_kekeke: 21.0

02:10:55 <ehird> with defend6 winning slightly

02:10:56 <ehird> the original

02:11:04 <nescience> lols

02:11:10 <Patashu> !bfjoust rushpolarity >+++++++++>---------(>)*7(+++++++[-]>-------[+]>)*11

02:11:12 <EgoBot> Score for Patashu_rushpolarity: 39.5

02:11:12 <nescience> didn't help it any :)

02:11:19 <Patashu> !bfjoust rushpolarity >+++++++++>---------(>)*7(++++++++[-]>--------[+]>)*11

02:11:21 <EgoBot> Score for Patashu_rushpolarity: 60.5

02:11:24 <Patashu> oo

02:11:32 <nescience> i wonder though why it loses to defend6

02:11:38 <nescience> the extra brackets shoul... ah

02:12:19 <ehird> !bfjoust now_is_the_time_for_all_bad_men_to_come_backwards_in_time_for_their_country [(-)*128+]

02:12:20 <Patashu> actually I should clean the code up

02:12:26 <EgoBot> Score for ehird_now_is_the_time_for_all_bad_men_to_come_backwards_in_time_for_their_country: 29.0

02:12:52 <Patashu> !bfjoust rushpolarity >(+)*9>(-)*9(>)*7((+)*8[-]>(-)*8[+]>)*11

02:12:53 <ehird> hey

02:12:54 <EgoBot> Score for Patashu_rushpolarity: 50.0

02:12:56 <ehird> only inverse creep beats my program

02:13:09 <nescience> that's because it exploits "your" program

02:13:13 <ehird> defend6 draws though

02:13:14 <nescience> !bfjoust kekeke (>+>-)*4(>[-](.)*132)*20

02:13:15 <ehird> nescience: ;P

02:13:16 <ehird> :P

02:13:16 <EgoBot> Score for nescience_kekeke: 19.8

02:13:17 <ehird> I'm going now

02:13:18 <ehird> bye

02:13:30 <nescience> bam, beats defend now

02:13:42 <nescience> AND parody

02:13:45 <nescience> do i get candy?

02:13:49 <Patashu> !bfjoust rushpolarity >(+)*9>(-)*9(>)*7((+)*7[-]>(-)*7[+]>)*11

02:13:51 <EgoBot> Score for Patashu_rushpolarity: 45.7

02:14:06 <Patashu> !bfjoust rushpolarity >(+)*9>(-)*9(>)*7((+)*9[-]>(-)*9[+]>)*11

02:14:08 <EgoBot> Score for Patashu_rushpolarity: 25.9

02:14:26 <Patashu> oo

02:14:30 <Patashu> now it says all but 1,2 beaten

02:14:33 <Patashu> which are the defend6s

02:14:35 <Patashu> how do they work? :o

02:14:43 <nescience> read them

02:15:46 <Patashu> hey if I have symbol*number without brackets

02:15:48 <Patashu> does that compile fine?

02:17:41 <nescience> !bfjoust creep >+>->+>->+>->+(>-++-.[+]++>-++-.[+]--)*15

02:17:42 <EgoBot> Score for nescience_creep: 12.0

02:18:18 <nescience> !bfjoust creep >+>->+>->+>->+(>-++-(.)*132[+]++>-++-(.)*132[-]--)*15

02:18:19 <EgoBot> Score for nescience_creep: 32.5

02:18:32 <nescience> beats both defends still hehe

02:18:34 <nescience> but too slow

02:19:37 -!- psygnisfive has joined.

02:20:32 <Patashu> wow haha

02:20:33 <Patashu> top of the hill

02:22:57 <Patashu> !bfjoust rushpolarity >(+)*9>(-)*9(>)*7((+)*9[-][>](-)*9[+][>])*11

02:22:59 <EgoBot> Score for Patashu_rushpolarity: 75.3

02:23:19 <nescience> lol broke it

02:23:23 <Patashu> huh

02:23:26 <Patashu> it said I got 75.3 score

02:23:31 <Patashu> but when I look at hte report I lost every one

02:23:31 <nescience> that was your last score

02:23:33 <nescience> refresh the table

02:23:39 <Patashu> nope

02:23:41 <Patashu> lol

02:23:53 <nescience> that was your score before submitting

02:23:56 <Patashu> !bfjoust rushpolarity >(+)*9>(-)*9(>)*7((+)*9[-][>](-)*9[+][>])*11

02:23:58 <EgoBot> Score for Patashu_rushpolarity: 0.0

02:23:59 <Patashu> okay

02:24:01 <nescience> see

02:24:02 <Patashu> ah I see

02:24:05 <Patashu> why does it do that

02:24:07 <nescience> it's broken

02:24:10 <Patashu> !bfjoust rushpolarity >(+)*9>(-)*9(>)*7((+)*9[-]>(-)*9[+]>)*11

02:24:12 <EgoBot> Score for Patashu_rushpolarity: 0.0

02:24:29 <Patashu> haha

02:24:31 <Patashu> !bfjoust rushpolarity >(+)*9>(-)*9(>)*7((+)*9[-]>(-)*9[+]>)*11

02:24:33 <EgoBot> Score for Patashu_rushpolarity: 48.1

02:24:36 <Patashu> there we go

02:24:50 <Patashu> wonder why the [>] made it worse...

02:25:00 <Patashu> oh wait

02:25:06 <Patashu> I'd need a reverse [] to do what I was thinking of

02:25:10 <Patashu> lol :)

02:25:12 <nescience> yep

02:25:31 <Patashu> loop while cell under pointer IS zero

02:27:13 <Patashu> !bfjoust rushpolarity >(+)*10>(-)*10(>)*7((+)*10[-]>(-)*10[+]>)*11

02:27:15 <EgoBot> Score for Patashu_rushpolarity: 48.1

02:27:37 <Patashu> !bfjoust rushpolarity >(+)*9>(-)*9(>)*7((+)*9[-]>(-)*9[+]>)*11

02:27:39 <EgoBot> Score for Patashu_rushpolarity: 54.3

02:27:53 <Patashu> hmm

02:28:11 <Patashu> !bfjoust rushpolarity >(+)*8>(-)*8(>)*7((+)*8[-]>(-)*8[+]>)*11

02:28:13 <EgoBot> Score for Patashu_rushpolarity: 54.3

02:28:37 <Patashu> !bfjoust rushpolarity >(+)*8>(-)*8(>)*7((+)*9[-]>(-)*9[+]>)*11

02:28:39 <EgoBot> Score for Patashu_rushpolarity: 42.0

02:29:04 <Patashu> !bfjoust rushpolarity >(+)*8>(-)*8(>)*7((+)*10[-]>(-)*10[+]>)*11

02:29:06 <EgoBot> Score for Patashu_rushpolarity: 50.6

02:29:37 <Patashu> !bfjoust rushpolarity >(+)*10>(-)*10(>)*7((+)*10[-]>(-)*10[+]>)*11

02:29:39 <EgoBot> Score for Patashu_rushpolarity: 34.6

02:30:15 <Patashu> !bfjoust rushpolarity >(+)*10>(-)*10(>)*7((+)*6[-]>(-)*6[+]>)*11

02:30:17 <EgoBot> Score for Patashu_rushpolarity: 60.5

02:30:33 <Patashu> !bfjoust rushpolarity >(+)*10>(-)*10(>)*7((+)*7[-]>(-)*7[+]>)*11

02:30:35 <EgoBot> Score for Patashu_rushpolarity: 48.1

02:30:55 <Patashu> !bfjoust rushpolarity >(+)*10>(-)*10(>)*7((+)*8[-]>(-)*8[+]>)*11

02:30:57 <EgoBot> Score for Patashu_rushpolarity: 60.5

02:31:56 <Patashu> !bfjoust rushpolarity >(+)*10>(-)*10(>)*7((+)*9[-]>(-)*9[+]>)*11

02:31:57 <EgoBot> Score for Patashu_rushpolarity: 60.5

02:32:19 <Patashu> :o

02:32:48 <Patashu> where'd everyone go anyhow

02:34:11 <Patashu> !bfjoust rushpolarity >(+)*10>(-)*10>(-)*5(>)*6((+)*9[-]>(-)*9[+]>)*11

02:34:13 <EgoBot> Score for Patashu_rushpolarity: 75.3

02:34:34 <Patashu> no that's worse, hmm

02:34:59 <Patashu> !bfjoust rushpolarity >(+)*10>(-)*10>->+(>)*5((+)*9[-]>(-)*9[+]>)*11

02:35:01 <EgoBot> Score for Patashu_rushpolarity: 49.4

02:35:25 <nescience> !bfjoust slowpoke http://pastie.org/490848.txt

02:35:28 <EgoBot> Score for nescience_slowpoke: 8.5

02:35:33 <nescience> lol

02:35:35 <nescience> must be broken

02:35:37 <Patashu> ouch

02:35:44 <Patashu> is that algorithmically generated?

02:35:51 <nescience> no

02:36:13 <nescience> oh

02:36:14 <nescience> haha

02:36:17 <nescience> i got my numbers wrong

02:36:20 <Patashu> lol

02:36:24 <nescience> it shouldn't be <*8 >*8

02:36:27 <Patashu> bfjoust magnum opus

02:36:28 <nescience> it should be <*8 >*9

02:36:49 <Patashu> this is for my bfjoust master's degree

02:38:00 <coppro> oh, things are fixed?

02:38:07 <coppro> neat!

02:38:27 <Patashu> yes

02:38:28 <Patashu> go wild

02:38:35 <coppro> !bfjoust irritating [>[-]-]

02:38:42 <EgoBot> Score for coppro_irritating: 21.5

02:38:49 <Patashu> just one glitch

02:38:54 <Patashu> the score it gives is for the LAST time you submitted a program

02:39:00 <Patashu> i.e. one submission delay

02:39:26 <nescience> !bfjoust slowpoke http://pastie.org/490854.txt

02:39:28 <EgoBot> Score for nescience_slowpoke: 8.5

02:39:41 <coppro> !bfjoust irritating [>[-]->[+]+]

02:39:42 <EgoBot> Score for coppro_irritating: 21.5

02:39:44 <nescience> lol well it still beats defendd

02:39:56 <Patashu> haha

02:40:01 <Patashu> what is it meant to do?

02:40:09 <coppro> ah, I see

02:40:11 <nescience> beat defend, and hopefully also do something interesting

02:40:23 <nescience> i have an idea

02:40:26 <nescience> lol

02:40:32 <nescience> but i guess it wouldn't matter

02:40:40 <coppro> !bfjoust beat_defenders [>[[[[[[-]]]]]]]

02:40:51 <EgoBot> Score for coppro_beat_defenders: 8.5

02:40:52 <nescience> it doesn't

02:41:03 <coppro> apparently not

02:41:19 <nescience> you'll just tie or run off the end

02:41:35 <nescience> gotta trip the tripwire and wait

02:41:39 <nescience> or skip it somehow

02:41:46 <Patashu> only ones I'm not beating are the defend6s

02:41:48 <Patashu> so :C

02:42:05 <nescience> i could be lame like ehird and just rip your code and then possibly fix it to beat them

02:42:05 <nescience> :P

02:42:22 <nescience> the thing i don't get is why you bother doing 10 +'s etc

02:42:24 <nescience> unless it's to kill time

02:42:27 <Patashu> it's because

02:42:28 <Patashu> uh

02:42:30 <Patashu> when people set decoys

02:42:38 <Patashu> they're more likely to set them to low +- numbers than high ones

02:42:42 <Patashu> or wait...

02:42:44 <Patashu> hmmm

02:42:45 <nescience> so?

02:42:52 <nescience> that doesn't help you any, since you aren't looping

02:42:53 <Patashu> well it works better when I put them in!

02:43:04 <nescience> like i said, must be killing time

02:43:06 <nescience> wonder why though

02:43:16 <Patashu> !bfjoust rushpolarity >(+)*10>(-)*10>->+(>)*5([-]>[+]>)*11

02:43:18 <EgoBot> Score for Patashu_rushpolarity: 76.0

02:43:19 <nescience> i have an inkling of an idea

02:43:23 <Patashu> let's see what happens when I take them out then

02:43:30 <Patashu> yeah it gets much worse

02:43:36 <Patashu> let's replace them with an equivalent amount of .s

02:43:39 <nescience> i meant on your decoys

02:43:46 <nescience> see one thing that happens

02:43:50 <nescience> if you have a set number of -s or +s

02:43:59 <Patashu> !bfjoust rushpolarity >(+)*10>(-)*10>->+(>)*5((+)*9[-]>(-)*9[+]>)*11

02:44:01 <EgoBot> Score for Patashu_rushpolarity: 21.0

02:44:02 <nescience> and someone else is looping on the same position

02:44:13 <nescience> if they dec to 0, you can put them past 0

02:44:19 <nescience> and then they loop again 256 times

02:44:49 <nescience> my decoys only bother setting once because they are only going to slow down loops

02:44:57 <nescience> and for that you don't need more than one

02:44:59 <Patashu> hmm let's see

02:45:07 <Patashu> !bfjoust rushpolarity >+>->->+(>)*5((+)*9[-]>(-)*9[+]>)*11

02:45:09 <EgoBot> Score for Patashu_rushpolarity: 60.5

02:45:35 <Patashu> I was under the impression that a high finite + or - for a decoy would stop constructs that go like [+[--[+++[----[...

02:45:38 <nescience> i think you ought to study why it's working for you in detail, probably could learn something good

02:45:44 <Patashu> nope small decoys doesn't help it

02:46:03 <Patashu> !bfjoust rushpolarity >(+)*10>(-)*10>->+(>)*5((+)*9[-]>(-)*9[+]>)*11

02:46:05 <EgoBot> Score for Patashu_rushpolarity: 34.6

02:46:13 <nescience> strange

02:46:16 <Patashu> this is ideal

02:46:20 <Patashu> beats all but defend6s

02:46:42 <nescience> all you need to do to beat the defends is delay longer before moving on

02:46:57 <nescience> you need to spend longer than 128 cycles at each location

02:47:04 <Patashu> but then I lose to everything else

02:47:05 <nescience> assuming you zero them before moving

02:47:13 <nescience> sucks eh? :)

02:47:23 <nescience> maybe you should just not care about them, apparently tripwire is not that effective a strategy

02:47:23 <Patashu> well hmm...

02:47:26 <nescience> unless it's all that's on the hill

02:47:27 <Patashu> 8 and 9 beat defend6 a parody

02:47:34 <Patashu> but 8 and 9 do poorly in general

02:47:36 <nescience> because i wrote them to

02:47:39 <Patashu> ya

02:47:42 <nescience> creep did good earlier

02:47:45 <nescience> i was 2nd

02:47:51 <Patashu> how do you make a defender? I wanna try

02:47:54 <nescience> but even then it got 3 losses

02:48:02 <nescience> what the defends are doing is

02:48:09 <nescience> 1) waiting at instruction 1 until it gets zeroed

02:48:16 <nescience> 2) going back to their flag and inc/dec'ing 128 times

02:48:26 <nescience> 3) then going back and forth across the tape alternately

02:48:50 <nescience> they keep tweaking their flag, then attacking a new location

02:49:04 <nescience> the goal is, presumably, to do like i said before

02:49:11 <nescience> let the enemy's loop hit 0 and fall through

02:49:21 <nescience> but inc/dec the flag on that same instruction so you don't lose

02:49:23 <nescience> then they run off the end

02:49:37 <Patashu> so it starts

02:49:42 <nescience> i wonder, the tripwire thing probably doesn't need to attack the opponent's flag at all

02:49:50 <Patashu> >[]<(+)*128

02:50:05 <nescience> >+[]

02:50:12 <Patashu> oh yeah

02:50:23 <Patashu> what if say your opponent -s while you +

02:50:30 <Patashu> do you alternate +ing and -ing

02:50:48 <nescience> infinite loop -> tie

02:51:06 <Patashu> !bfjoust matador >+[]<(+)*128(-)*128(>)*9(>[+])*21

02:51:10 <EgoBot> Score for Patashu_matador: 0.0

02:51:12 <Patashu> nope

02:51:43 <nescience> !bfjoust tripwire >+[]<(+)*192000

02:51:50 <nescience> whoops i needed bigger number

02:51:53 <EgoBot> Score for nescience_tripwire: 0.0

02:52:06 <Patashu> it ties the defends though lol

02:52:13 <nescience> !bfjoust tripwire >+[]<(+)*384000

02:52:15 <EgoBot> Score for nescience_tripwire: 0.0

02:52:15 <nescience> should tie everything

02:52:23 <coppro> !bfjoust morefail >+[]+[->[-]](>)*7[>[-]]

02:52:26 <EgoBot> Score for coppro_morefail: 0.0

02:52:28 <nescience> i woner why not

02:52:29 <coppro> oops

02:52:33 <Patashu> !bfjoust matador >+[]<(+)*123456(-)*123456(>)*9(>[+])*21

02:52:35 <EgoBot> Score for Patashu_matador: 0.0

02:52:35 <coppro> !bfjoust morefail >+[]+[->[-]](>)*7[>[-].]

02:52:36 <EgoBot> Score for coppro_morefail: 0.0

02:52:45 <Patashu> hmmm

02:52:52 <Patashu> !bfjoust matador >+[]<.(+)*123456(-)*123456(>)*9(>[+])*21

02:52:54 <EgoBot> Score for Patashu_matador: 0.0

02:52:55 <nescience> !bfjoust tripwire >(+)*384000

02:52:56 <EgoBot> Score for nescience_tripwire: 8.5

02:52:58 <Patashu> !bfjoust matador >+[]<.(+)*123456.(-)*123456(>)*9(>[+])*21

02:52:58 <nescience> lol

02:53:00 <EgoBot> Score for Patashu_matador: 0.0

02:53:07 <coppro> !bfjoust morefail >+[]+[->[-]](>)*7+[[-].>]

02:53:09 <EgoBot> Score for coppro_morefail: 0.0

02:53:10 <Patashu> !bfjoust matador >+[]<(+)*123456.(-)*123456(>)*9(>[+])*21

02:53:12 <EgoBot> Score for Patashu_matador: 0.0

02:53:15 <nescience> please cut the spam out, jesus

02:53:19 <nescience> at least stop and reflect on your scores

02:53:21 <coppro> never!

02:53:21 -!- Gracenotes has joined.

02:53:25 <nescience> remember the bot isn't reporting an accurate score

02:53:31 <nescience> so you have to refresh the chart at least

02:53:32 <coppro> there was an obvious bug in mine

02:53:35 <nescience> and every time you submit it blanks the chart

02:53:45 <Patashu> damn bugs

02:53:57 <nescience> it's probably my fault heh :P

02:54:00 <nescience> running out the clock

02:54:15 <Patashu> hmm that last time it beat 10 and did a whole bunch of ties

02:54:20 <coppro> rofl my new one can't win

02:54:23 <nescience> it still loses

02:54:23 <Patashu> so why is it tieing then? it kills itself or it times out?

02:54:23 <nescience> wtf

02:54:31 <nescience> tie should be time runs out

02:54:38 <nescience> oh, of course

02:54:41 <nescience> the defends don't use loops

02:54:46 <nescience> and anything that doesn't loop would win

02:54:48 <nescience> silly me

02:54:56 <Patashu> !bfjoust matador >+[]<(+)*500.(-)*500(>)*9(>[+])*21

02:54:58 <nescience> also i forgot something about my own attempt

02:54:58 <EgoBot> Score for Patashu_matador: 9.0

02:55:12 <Patashu> that beats creep and kekeke

02:55:58 <Patashu> !bfjoust matador >+[]<(++-)*256.(--+)*256(>)*9(>[+])*21

02:56:00 <EgoBot> Score for Patashu_matador: 14.0

02:56:07 <Patashu> oh-ho

02:56:11 <Patashu> beats rushpolarity XD

02:56:32 <Patashu> !bfjoust matador >+[]<(++-)*129.(--+)*129(>)*9(>[+])*21

02:56:34 <EgoBot> Score for Patashu_matador: 41.0

02:56:41 <Patashu> no that does worse

02:56:48 <Patashu> !bfjoust matador >+[]<(++-)*500.(--+)*500(>)*9(>[+])*21

02:56:50 <EgoBot> Score for Patashu_matador: 17.3

02:56:58 <Patashu> holy lol

02:57:00 <Patashu> that does real well

02:57:07 <Patashu> !bfjoust matador >+[]<(++-)*1000.(--+)*1000(>)*9(>[+])*21

02:57:09 <EgoBot> Score for Patashu_matador: 55.6

02:57:17 <nescience> !bfjoust tripwire http://pastie.org/490870.txt

02:57:19 <EgoBot> Score for nescience_tripwire: 0.0

02:57:26 <Patashu> !bfjoust matador >+[]<(.+-)*1000.(.-+)*1000(>)*9(>[+])*21

02:57:28 <EgoBot> Score for Patashu_matador: 48.1

02:57:28 <nescience> yeah, didn't think it'd do much better

02:57:39 <Patashu> !bfjoust matador >+[]<(.+-)*1000(.-+)*1000(>)*9(>[+])*21

02:57:41 <EgoBot> Score for Patashu_matador: 48.1

02:57:54 <coppro> !bfjoust watch_killer [>[[-]+>[][+]]]

02:58:08 <EgoBot> Score for coppro_watch_killer: 0.0

02:58:10 <Patashu> !bfjoust matador >+[]<(.+-)*512(.-+)*512(>)*9(>[+])*21

02:58:11 <coppro> aw

02:58:12 <EgoBot> Score for Patashu_matador: 39.5

02:58:29 <Patashu> !bfjoust matador >+[]<(.+-)*1000(.-+)*1000(>)*9(>[+])*21

02:58:31 <EgoBot> Score for Patashu_matador: 39.5

02:58:39 <Patashu> !bfjoust matador >+[]<(.+-)*1000.(.-+)*1000(>)*9(>[+])*21

02:58:41 <EgoBot> Score for Patashu_matador: 39.5

02:58:49 <Patashu> okay that . makes it win for some reason

02:58:55 <Patashu> must be a parity thing

02:59:07 <nescience> likely

02:59:20 <Patashu> hmm I wonder

02:59:20 <coppro> !bfjoust watch_killer [>[[-]+>[][+--]]]

02:59:22 <EgoBot> Score for coppro_watch_killer: 0.0

02:59:24 <nescience> still probably gonna be affected by randomness

02:59:27 <Patashu> !bfjoust matador >-[]<(.+-)*1000.(.-+)*1000(>)*9(>[+])*21

02:59:28 <EgoBot> Score for Patashu_matador: 48.1

02:59:29 <coppro> hrmm why's mine failing

02:59:44 <Patashu> what is that horrid thing doing

02:59:45 <Patashu> lol

03:00:31 <coppro> !bfjoust watch_killer [>[[-](.)*1000]]

03:00:32 <EgoBot> Score for coppro_watch_killer: 0.0

03:00:41 <coppro> oh wait I see

03:00:42 <coppro> duh

03:00:46 <coppro> !bfjoust watch_killer [>[[-]+>[][+--]]+]

03:00:46 <Patashu> mixed up what [] does?

03:00:47 <EgoBot> Score for coppro_watch_killer: 0.0

03:00:53 <coppro> hrm

03:00:54 <Patashu> oo

03:00:55 <coppro> !bfjoust watch_killer [>[[-](.)*1000]+]

03:00:56 <Patashu> it gets 31.5 now

03:00:57 <EgoBot> Score for coppro_watch_killer: 31.5

03:01:00 <coppro> there we go

03:01:01 <Patashu> don't forget to check the chart after you submit something

03:01:02 <Patashu> because

03:01:04 <Patashu> the score it gives you

03:01:05 <coppro> oh yeah

03:01:07 <coppro> right

03:01:11 <Patashu> was the score for the LAST program you submitted

03:01:12 <nescience> !bfjoust tripwire >+[]<[]+(>[+](.)*128)*29

03:01:13 <coppro> !bfjoust watch_killer [>[[-]+>[][+--]]+]

03:01:14 <EgoBot> Score for nescience_tripwire: 45.0

03:01:14 <EgoBot> Score for coppro_watch_killer: 37.0

03:01:29 <coppro> basically it tricks defenders into killing themselves

03:01:30 <nescience> can't believe i/nobody thought of that yet

03:01:40 <nescience> coppro: yes, that's what i did like two hours ago :P

03:01:46 <coppro> heh

03:01:51 <nescience> the above should beat loopers and both defenders

03:01:58 <nescience> but doesn't

03:01:59 <nescience> bugs?

03:02:12 <coppro> hmm... I've got a new one to try

03:02:14 <nescience> i wish their numbers would stay the same

03:02:17 <Patashu> !bfjoust matador >-[]<[]+-++--+++---++++----(>)*9(>[+])*21

03:02:19 <EgoBot> Score for Patashu_matador: 0.0

03:02:25 <Patashu> no good, ok

03:02:29 <Patashu> !bfjoust matador >-[]<(.+-)*1000.(.-+)*1000(>)*9(>[+])*21

03:02:30 <EgoBot> Score for Patashu_matador: 58.0

03:03:02 <coppro> hmm... it would be more interesting

03:03:10 <coppro> if you had one 0 cell beyond each flag

03:03:40 <Patashu> suggest it

03:04:01 <coppro> where?

03:04:11 <Patashu> http://esolangs.org/wiki/BF_Joust talk page

03:04:39 <nescience> !bfjoust tripwire >+[]<[]+.+(>)*9(>[.+])*29

03:04:41 <EgoBot> Score for nescience_tripwire: 0.0

03:04:49 <coppro> would allow for more interesting possibilities, because then programs could identify flags other than by hoping they don't run off the end

03:04:58 <nescience> hm, i think maybe the timing is not correct

03:05:06 <nescience> coppro: it's called "joust" not "snipe" ;)

03:05:10 <nescience> FULL SPEED AHEAD

03:05:30 <coppro> nescience: you can, of course, trick your opponent still!

03:05:51 <coppro> more importantly, it allows defensive strategies that don't need to use fixed numbers in the source

03:05:57 <nescience> !bfjoust test [>[-]+]

03:06:01 <EgoBot> Score for nescience_test: 35.0

03:06:15 <nescience> yeah

03:06:17 <nescience> timing thing

03:06:18 <Patashu> beats matador haha

03:06:19 <nescience> wtf, that might be a bug

03:06:28 <nescience> let's look at this closely

03:06:31 <nescience> >+ sets it to 1

03:06:35 <nescience> [] waits til its 0

03:06:41 <nescience> from what was described to me before

03:06:46 <nescience> no matter if it is executing [ or ]

03:06:51 <Patashu> [] loops if the cell is not 0\

03:06:53 <nescience> it will skip to <

03:06:55 <nescience> when the cell is 0

03:07:03 <nescience> then it waits on my fag

03:07:05 <nescience> flag*

03:07:07 <nescience> [] again

03:07:08 <Patashu> it will only halt if it encounters a -1 cell

03:07:19 <nescience> when the flag becomes 0 it should execute +

03:07:23 <nescience> and save m... ah

03:07:27 <nescience> but the enemy...... no

03:07:34 <nescience> 'cause the enemy should be at that point executing ]

03:07:45 <nescience> -]-]-]-]-]

03:07:50 <nescience> or +]+]+]+]+]

03:07:53 <nescience> so - makes it 0

03:07:57 <nescience> it is 0 at the start of ]

03:08:00 <nescience> loop falls through

03:08:03 <Patashu> I think I see why it beats matador

03:08:06 <nescience> for my part,

03:08:15 <nescience> it falls through a... i see

03:08:19 <nescience> that seems non optimal

03:08:28 <Patashu> !bfjoust matador >-[]<(++-)*1000.(--+)*1000(>)*9(>[+])*21

03:08:30 <EgoBot> Score for Patashu_matador: 53.1

03:08:40 <nescience> so what happens is my test doesn't work until it has been 0 for 1 round

03:08:43 <Patashu> k, fixed the vulnerability

03:09:02 <Patashu> now it only beats creep and watch kille

03:09:03 <Patashu> +r

03:09:49 <Patashu> I have an idea to tweak rushpolarity now

03:10:06 <nescience> !bfjoust tripwire >+[]<(.)*128+(>)*9(>[.+])*29

03:10:07 <EgoBot> Score for nescience_tripwire: 8.0

03:10:18 <Patashu> !bfjoust rushpolarity >(+)*10>(-)*10>->+(>)*5((+)*9[-].+>(-)*9[+].->)*11

03:10:20 <EgoBot> Score for Patashu_rushpolarity: 71.0

03:10:24 <nescience> lol test still beats it

03:10:25 <nescience> hmm

03:10:32 <Patashu> k, does not help

03:10:39 <nescience> oh right

03:10:40 <Patashu> !bfjoust rushpolarity >(+)*10>(-)*10>->+(>)*5((+)*9[-]+>(-)*9[+]->)*11

03:10:41 <nescience> timing mistake

03:10:42 <EgoBot> Score for Patashu_rushpolarity: 49.4

03:10:49 <Patashu> hmm

03:10:53 <nescience> !bfjoust tripwire >+[]<(.)*256+(>)*9(>[.+])*29

03:10:55 <EgoBot> Score for nescience_tripwire: 8.0

03:10:58 <Patashu> !bfjoust rushpolarity >(+)*10>(-)*10>->+(>)*5((+)*9[-][+]>(-)*9[+][-]>)*11

03:11:00 <EgoBot> Score for Patashu_rushpolarity: 49.0

03:11:17 <Patashu> !bfjoust rushpolarity >(+)*10>(-)*10>->+(>)*5([-][+]>[+][-]>)*11

03:11:19 <EgoBot> Score for Patashu_rushpolarity: 45.1

03:11:28 <Patashu> no that's not doing it at all haha

03:11:31 <Patashu> !bfjoust rushpolarity >(+)*10>(-)*10>->+(>)*5((+)*9[-]>(-)*9[+]>)*11

03:11:33 <EgoBot> Score for Patashu_rushpolarity: 29.6

03:11:34 <Patashu> back to the original spec

03:11:49 <nescience> !bfjoust tripwire >+[]<(.)*256+(>)*9(>[.+])*29

03:11:50 <EgoBot> Score for nescience_tripwire: 8.0

03:12:08 <nescience> !bfjoust tripwire >+[]<(.)*257+(>)*9(>[.+])*29

03:12:09 <EgoBot> Score for nescience_tripwire: 8.0

03:12:19 <nescience> !bfjoust tripwire >+[]<(.)*255+(>)*9(>[.+])*29

03:12:21 <EgoBot> Score for nescience_tripwire: 8.0

03:12:23 <Patashu> !bfjoust rushpolarity >(+)*10>(-)*10>->+(>)*5((+)*9[-]+-++-->(-)*9[+]+-++-->)*11

03:12:25 <EgoBot> Score for Patashu_rushpolarity: 60.0

03:12:38 <Patashu> hmm

03:12:39 <nescience> gonna have to notepad this up and solve a simpler problem

03:12:47 <Patashu> !bfjoust rushpolarity >(+)*10>(-)*10>->+(>)*5((+)*9[-]+-.++-->(-)*9[+]+-.++-->)*11

03:12:48 <nescience> ah there we go

03:12:49 <EgoBot> Score for Patashu_rushpolarity: 58.6

03:12:51 <nescience> it beats test

03:12:52 <nescience> lol

03:12:53 <nescience> but nothing else

03:13:03 <Patashu> !bfjoust rushpolarity >(+)*10>(-)*10>->+(>)*5((+)*9[-].+-++-->(-)*9[+].+-++-->)*11

03:13:05 <EgoBot> Score for Patashu_rushpolarity: 45.1

03:13:06 <nescience> i guess nobody uses a simple attack anymore

03:13:12 <coppro> !bfjoust fooled_ya (>+>-)*4[>[-]+]

03:13:13 <Patashu> oo that's good

03:13:13 <Patashu> :)

03:13:16 <EgoBot> Score for coppro_fooled_ya: 27.5

03:13:27 <Patashu> !bfjoust rushpolarity >(+)*10>(-)*10>->+(>)*5((+)*9[-].+->(-)*9[+].+->)*11

03:13:28 <EgoBot> Score for Patashu_rushpolarity: 68.5

03:13:33 <Patashu> that's not

03:13:44 <coppro> oh right, need defense protection

03:13:44 <Patashu> !bfjoust rushpolarity >(+)*10>(-)*10>->+(>)*5((+)*9[-].+-++--+++--->(-)*9[+].+-++--+++--->)*11

03:13:46 <EgoBot> Score for Patashu_rushpolarity: 56.2

03:13:58 <coppro> !bfjoust fooled_ya (>+>-)*4[>[[-]+]+]

03:13:59 <EgoBot> Score for coppro_fooled_ya: 25.3

03:14:03 <Patashu> !bfjoust rushpolarity >(+)*10>(-)*10>->+(>)*5((+)*9[-].+-.++-->(-)*9[+].+-.++-->)*11

03:14:04 <EgoBot> Score for Patashu_rushpolarity: 49.4

03:14:05 <coppro> !bfjoust fooled_ya (>+>-)*4[>[+[-]]+]

03:14:07 <EgoBot> Score for coppro_fooled_ya: 25.3

03:14:29 <coppro> hmm... that's better

03:14:32 <Patashu> !bfjoust rushpolarity >(+)*10>(-)*10>->+(>)*5((+)*9[-].+-++-->(-)*9[+].+-++-->)*11

03:14:34 <EgoBot> Score for Patashu_rushpolarity: 58.6

03:14:35 -!- inurinternet has joined.

03:14:37 <coppro> how does the scoring system work?

03:14:44 <Patashu> !bfjoust rushpolarity >(+)*10>(-)*10>->+(>)*5((+)*9[-].+-.++-->(-)*9[+].+-.++-->)*11

03:14:46 <EgoBot> Score for Patashu_rushpolarity: 48.8

03:14:50 <Patashu> you get more points for beating programs with more points

03:15:04 <coppro> !bfjoust fooled_ya (>(+)*32>(-)*32)*4[>[+[-]]+]

03:15:06 <EgoBot> Score for coppro_fooled_ya: 29.6

03:15:11 <Patashu> haha matador's falling now that it doesn't beat rushpolarity any more

03:15:14 <Patashu> :')

03:15:21 <nescience> i think the scoring system needs a little work

03:15:32 <Gracenotes> ._.

03:15:35 <Patashu> !bfjoust rushpolarity >(+)*10>(-)*10>->+(>)*5([-].+-.++-->[+].+-.++-->)*11

03:15:37 <EgoBot> Score for Patashu_rushpolarity: 63.0

03:15:44 <nescience> if you get points for beating something before its battle with you gets taken account of, then things are a little weird the first submit

03:15:45 <coppro> damn that shortswod

03:15:47 <nescience> i dunno how they work it out

03:15:48 <coppro> *shortsword

03:16:03 <coppro> I don't understand exactly how this game works well enough yet

03:16:07 <Patashu> !bfjoust rushpolarity >(+)*10>(-)*10>->+(>)*5(+[-].+-.++-->-[+].+-.++-->)*11

03:16:09 <EgoBot> Score for Patashu_rushpolarity: 45.1

03:16:16 <Gracenotes> hm? How are parens and numerical symbols determined?

03:16:21 <Patashu> !bfjoust rushpolarity >(+)*10>(-)*10>->+(>)*5((+)*9[-].+-.++-->(-)*9[+].+-.++-->)*11

03:16:22 <EgoBot> Score for Patashu_rushpolarity: 45.1

03:16:23 <Gracenotes> ...is that just repeating text?

03:16:27 <coppro> yes

03:16:31 <Patashu> (foo)*num = foofoofoofoo...num times

03:16:33 <Gracenotes> ah. mak sanse.

03:16:33 <Patashu> that's it

03:16:47 <Patashu> !bfjoust rushpolarity >(+)*10>(-)*10>->+(>)*5((+)*9[-].+-.++-->(-)*9[+].+-.++-->)*11

03:16:48 <nescience> !bfjoust tripwire >+[]<[-++-](>)*9(>-++-(.)*128[+])*29

03:16:49 <coppro> (some{stuff}things)*2=somesomestuffthingsthings

03:16:49 <EgoBot> Score for nescience_tripwire: 8.0

03:16:49 <EgoBot> Score for Patashu_rushpolarity: 30.9

03:17:07 <Gracenotes> how are scores done? :)

03:17:12 <nescience> hm

03:17:20 <nescience> !bfjoust tripwire >+[]<[--](>)*9(>-++-(.)*128[+])*29

03:17:21 <EgoBot> Score for nescience_tripwire: 0.0

03:17:22 <Patashu> you get points for a win

03:17:24 <nescience> ha

03:17:25 <Patashu> and the more that program had

03:17:26 <Patashu> the more you get

03:17:38 <nescience> interesting results

03:17:41 <Gracenotes> I have heard of BF jousting, but not the specifics

03:17:41 <Patashu> !bfjoust rushpolarity >(+)*10>(-)*10>->+(>)*5((+)*8[-].+-.++-->(-)*8[+].+-.++-->)*11

03:17:43 <EgoBot> Score for Patashu_rushpolarity: 45.0

03:17:50 <nescience> oh of course tripwire would always tie the defends

03:18:01 <Patashu> !bfjoust rushpolarity >(+)*10>(-)*10>->+(>)*5((+)*9[-].+-.++-->(-)*9[+].+-.++-->)*11

03:18:03 <EgoBot> Score for Patashu_rushpolarity: 36.4

03:18:03 <coppro> !bfjoust tripstep [>[>[-]]+]

03:18:09 <EgoBot> Score for coppro_tripstep: 37.0

03:18:37 <Patashu> !bfjoust rushpolarity >(+)*10>(-)*10>->+(>)*5((+)*9[-].+.--++>(-)*9[+].+.--++>)*11

03:18:39 <EgoBot> Score for Patashu_rushpolarity: 54.5

03:19:02 <Patashu> !bfjoust rushpolarity >(+)*10>(-)*10>->+(>)*5((+)*9[-]+.--.++>(-)*9[+]+.--.++>)*11

03:19:04 <EgoBot> Score for Patashu_rushpolarity: 47.5

03:19:14 <Patashu> aha

03:19:48 <coppro> !bfjoust tripstep [>[[>[-].+]]+]

03:19:50 <EgoBot> Score for coppro_tripstep: 43.0

03:20:19 <nescience> !bfjoust test (>)*9(-++-(-)*70[+])*20

03:20:21 <EgoBot> Score for nescience_test: 22.5

03:20:44 <Patashu> !bfjoust matador >-[]<(++-)*1000.(--+)*1000(>)*9(>[+][-])*21

03:20:46 <EgoBot> Score for Patashu_matador: 29.0

03:21:06 <Patashu> !bfjoust matador >-[]<(++-)*1000(--+)*1000(>)*9(>[+][-])*21

03:21:07 <EgoBot> Score for Patashu_matador: 29.0

03:21:30 <Patashu> !bfjoust matador >-[]<(++-)*1000.(--+)*1000(>)*9(>[+][-])*21

03:21:32 <EgoBot> Score for Patashu_matador: 42.0

03:21:41 <Patashu> oop now it beats rushpolarity again

03:21:48 <Patashu> :>

03:21:58 <nescience> !bfjoust test >----->+++++>----->+++++>----->+++++>-----(>-++-(-)*70[+])*20

03:21:59 <EgoBot> Score for nescience_test: 7.5

03:22:02 <nescience> whoops forgot to put > in it

03:22:24 <Patashu> !bfjoust matador >-[]<(++-+-)*1000.(--+-+)*1000(>)*9(>[+][-])*21

03:22:25 <EgoBot> Score for Patashu_matador: 7.4

03:22:30 <nescience> beats defends and some others now

03:22:32 <nescience> heh

03:22:36 <Patashu> !bfjoust matador >-[]<(++-)*1000.(--+)*1000(>)*9(>[+][-])*21

03:22:38 <EgoBot> Score for Patashu_matador: 44.4

03:22:40 <nescience> better'n creep at least

03:23:01 <Patashu> !bfjoust matador >+[]<(++-)*1000.(--+)*1000(>)*9(>[+][-])*21

03:23:02 <EgoBot> Score for Patashu_matador: 30.9

03:23:11 <Patashu> !bfjoust matador >-[]<(++-)*1000.(--+)*1000(>)*9(>[+][-])*21

03:23:12 <EgoBot> Score for Patashu_matador: 30.9

03:23:28 <Patashu> hmm

03:23:39 <Patashu> it needs to do two fights against each program imho

03:23:43 <coppro> !bfjoust tripstep [>[+[--[>[-].+]]<+[>[-].+].+]]+]

03:23:45 <EgoBot> Score for coppro_tripstep: 0.0

03:23:49 <coppro> :(

03:23:49 <Patashu> wow look at that thing

03:23:57 <Patashu> it needs indentation

03:24:04 <Patashu> haha

03:24:07 <coppro> !bfjoust tripstep [>[+[--[>[-].+]]+[[-].>+].+]]+]

03:24:09 <EgoBot> Score for coppro_tripstep: 0.0

03:24:23 <coppro> hfm

03:26:10 <Patashu> !bfjoust rushpolarity >(+)*10>(-)*10>->+(>)*5([+[-]]+.--.++>[-[+]]+.--.++>)*11

03:26:12 <EgoBot> Score for Patashu_rushpolarity: 55.6

03:26:22 <Patashu> !bfjoust rushpolarity >(+)*10>(-)*10>->+(>)*5((+)*9[-]+.--.++>(-)*9[+]+.--.++>)*11

03:26:24 <EgoBot> Score for Patashu_rushpolarity: 30.9

03:26:36 <nescience> !bfjoust playing_the_odds (>)*13(>(-)*128.)*15

03:26:38 <EgoBot> Score for nescience_playing_the_odds: 27.0

03:26:45 <nescience> hehe

03:26:57 <Patashu> !bfjoust rushpolarity >(+)*10>(-)*10>->+(>)*5((+)*8[+[-]]+.--.++>(-)*9[-[+]]+.--.++>)*11

03:26:59 <EgoBot> Score for Patashu_rushpolarity: 55.5

03:27:01 <nescience> !bfjoust playing_the_odds (>)*13(>(-)*128.)*15

03:27:03 <EgoBot> Score for nescience_playing_the_odds: 27.0

03:27:12 <Patashu> hmm

03:27:33 <nescience> !bfjoust playing_the_odds (>+>-)*6>(>(-)*128.)*15

03:27:33 <Patashu> !bfjoust rushpolarity >(+)*10>(-)*10>->+(>)*5((+)*8[+[-]]+.--.++>(-)*8[-[+]]+.--.++>)*11

03:27:34 <EgoBot> Score for nescience_playing_the_odds: 40.7

03:27:35 <EgoBot> Score for Patashu_rushpolarity: 51.9

03:28:29 <nescience> !bfjoust playing_the_odds (>+++++>-----)*2(>)*9(>(-)*128.)*15

03:28:30 <EgoBot> Score for nescience_playing_the_odds: 26.5

03:28:38 <Patashu> !bfjoust rushpolarity >(+)*10>(-)*10>-->++(>)*5((+)*8[+[-]]+.--.++>(-)*8[-[+]]+.--.++>)*11

03:28:40 <EgoBot> Score for Patashu_rushpolarity: 54.3

03:28:45 <nescience> ah well, second try was the best heh

03:29:15 <nescience> ah well, second try was the best heh

03:29:18 <nescience> !bfjoust playing_the_odds (>+++++>-----)*2(>)*9(>(-)*128.)*15

03:29:19 <EgoBot> Score for nescience_playing_the_odds: 38.3

03:29:22 <nescience> rolling for a better score!

03:29:29 <nescience> win

03:29:31 <nescience> :D

03:29:32 <nescience> cache that pls

03:29:46 <nescience> didn't quite beat both defends though

03:30:06 <nescience> that'll be an amusing one to have on the hill

03:30:11 <nescience> i wonder how long it'll stay

03:31:15 <nescience> shortsword has staying power at least

03:31:25 <coppro> here's a better one!

03:31:47 <coppro> !bfjoust (>)*15([{-}])*100

03:31:47 <EgoBot> Use: !bfjoust <program name> <program>

03:31:52 <coppro> !bfjoust dice!(>)*15([{-}])*100

03:31:53 <EgoBot> Use: !bfjoust <program name> <program>

03:31:55 <coppro> !bfjoust dice! (>)*15([{-}])*100

03:32:04 <EgoBot> Score for coppro_dice_: 0.0

03:32:09 <nescience> ...

03:32:13 <coppro> :P

03:32:41 <nescience> the hill should have an "age" parameter ala corewars hills

03:46:11 <nescience> wtf save page is failing miserably

03:46:55 <nescience> keeps giving me an 'edit conflict' error

03:47:00 <nescience> but there isn't one

03:47:54 <oerjan> on the esolang wiki?

03:48:19 <coppro> add an edit comment

03:48:30 <nescience> stupid wikis capitalizing my username

03:49:48 <nescience> well, registering fied that

03:49:57 <oerjan> nescience: if that was you on the BF Joust talk page, please sign with ~~~~

03:50:08 <nescience> how come ais523 gets a lowercase nick and i don't :(

03:50:12 <nescience> oerjan: i did

03:50:23 <nescience> i didn't have an account before

03:51:20 <oerjan> are you Myndzi?

03:51:28 <nescience> yes

03:51:42 <oerjan> were you the previous comment too?

03:51:44 <nescience> it just looks wrong with a capital M >:(

03:51:46 <nescience> no

03:51:52 <oerjan> ic

03:52:00 <nescience> my edit was only the last paragraph

03:52:01 * oerjan will add an unsigned template

03:52:24 <oerjan> assuming i can get the damn molasses to load

03:52:59 <nescience> coppro was that unsigned paragraph

03:53:25 <coppro> oh, I must have not been logged in

03:53:27 <coppro> oops

03:53:56 <oerjan> that was you? then maybe best you sign yourself

03:54:02 <oerjan> or wait

03:54:15 <oerjan> i can just change the nick

03:54:32 <coppro> mine was the comment about going past the end

03:54:41 <nescience> i don't really see how that would be useful though

03:54:47 <nescience> since you can't simply test for 0

03:54:50 <nescience> it doesn't gain you anything

03:55:26 <oerjan> coppro: actually i don't know your username

03:56:08 <coppro> oh, dear, it appears I never signed up to esolang

03:56:11 <coppro> that explains a lot

03:56:17 <oerjan> heh :D

03:56:32 <nescience> >((o> lol fish <o))<

03:56:36 <nescience> submit that!

03:56:38 <oerjan> coppro: also, whether or not you are logged in you need to use a ~~~~ command to sign (it's in the button menu)

03:56:48 <coppro> I did

03:58:23 <oerjan> nescience: dammit your decapitalization made an edit conflict :(

03:58:28 <nescience> lol

03:58:44 <nescience> now you know how i feel! :P

03:58:49 <nescience> except there actually was one

03:58:51 <nescience> o well

03:59:55 <oerjan> nescience: also the signature text can be set in preferences

04:00:24 <nescience> you mean "nickname"?

04:00:29 <oerjan> yes

04:00:33 <nescience> i thought that's what it was, but when i changed it, it didn't affect the page

04:00:37 <nescience> that's why i edited it manually

04:00:37 * oerjan changed it to use an Ø

04:00:42 <oerjan> oh

04:00:52 <oerjan> nescience: it's not your username

04:01:07 <nescience> ?

04:01:08 <oerjan> only used for signature i think

04:01:15 <nescience> right

04:01:21 <nescience> but my signature had still taken from before

04:01:26 <nescience> thus i changed it too

04:01:38 <oerjan> oh of course

04:01:45 <nescience> between wikis and muds lately, *sighs*

04:16:53 -!- Patashu has quit ("Patashu/SteampunkX - MSN = Patashu@hotmail.com , AIM = Patashu0 , YIM = Patashu2 , Googletalk = Patashu0@gmail.com .").

04:16:56 -!- GregorR has quit (anthony.freenode.net irc.freenode.net).

04:17:38 -!- GregorR has joined.

04:18:00 <nescience> !bfjoust test >+>->+>->+>->+>[[+]>-++]

04:18:01 <EgoBot> Score for nescience_test: 38.5

04:19:38 <nescience> !bfjoust test >+>->+>->+>->+>(-++-(-.)*130>)*20

04:19:40 <EgoBot> Score for nescience_test: 0.0

04:20:43 <nescience> !bfjoust test >(+)*50>(-)*50>(+)*30>(-)*30>(+)*10>(-)*10>+>(-++-(-.)*130>)*20

04:20:45 <EgoBot> Score for nescience_test: 34.6

04:27:05 <GregorR-L> I'm glad to see bfjoust is being used.

04:27:06 -!- sebbu has joined.

04:27:32 <GregorR-L> Any further complaints from anybody?

04:27:51 <pikhq> You aren't creating a digital manifestation of God.

04:27:53 <nescience> i think the game won't go all that far

04:28:14 <nescience> it's about the best it can be in its current form, but there really aren't that many options

04:28:18 <nescience> dunno though, could be wrong1

04:28:23 <nescience> there are a number of comments on the wiki talk page

04:28:37 <GregorR-L> Then try FYB instead :P

04:29:06 <nescience> heh heh

04:29:17 <nescience> i'm not a huge fan of BF in the first place

04:29:37 <GregorR-L> When is bfjoust from ... does FYB predate it?

04:29:50 <nescience> i wouldn't know

04:32:26 <nescience> i wonder

04:32:40 <nescience> in the true spirit of capture the flag, what would happen if you had to come back to your base and set your own flag back to 128? ;)

04:32:52 <nescience> too complicated surely, also nobody would be able to keep track of their flag

04:36:35 <GregorR-L> !fyb minimangler +!>

04:36:53 <EgoBot> Score for GregorR-L_minimangler: 0.0

04:37:01 <GregorR-L> Ouch :P

04:37:31 <GregorR-L> !fyb minimangler :+!>;*

04:37:33 <EgoBot> Score for GregorR-L_minimangler: 0.0

04:37:37 <GregorR-L> *shrugs*

04:39:18 <oerjan> !fyb cheers :D

04:39:28 <EgoBot> Score for oerjan_cheers: 4.5

04:39:34 <GregorR-L> lawl :P

04:41:32 <Gracenotes> :D

04:41:34 <Gracenotes> D:

04:43:03 -!- sebbu2 has quit (Read error: 110 (Connection timed out)).

04:44:51 -!- Corun has quit ("Leaving...").

04:51:13 * coppro starts working on the Evil Calculus Book of Doom

04:54:58 <oerjan> itym the Evil Doom Calculus Book of the Apocalypse

05:04:19 <coppro> sorry

05:04:39 <bsmntbombdood> so i have a dump of wikipedia

05:04:42 <bsmntbombdood> what should i do with it

05:04:43 <coppro> stupid fact that I have to do tons of coursework even though I'm challenging the course

05:04:53 <coppro> make a programming language using wikipedia links

05:07:13 <Gracenotes> bsmntbombdood: what kind of dump?

05:07:31 <Gracenotes> current pages in article namespace?

05:07:35 <bsmntbombdood> the current version of all namespace 1 pages

05:07:54 <Gracenotes> that's the talk namespace :)

05:08:05 <bsmntbombdood> nuh uh

05:09:11 <Gracenotes> article is the first namespace, but its numbering is 0

05:09:30 <Gracenotes> anyway. >_>

05:09:49 <Gracenotes> perhaps you could make a graph based on what articles link to each other?

05:10:05 <oerjan> xkcd :D

05:10:13 <Gracenotes> although there are already dumps that have that information

05:10:18 <Gracenotes> you could do lots of interesting stuff with that

05:10:33 <bsmntbombdood> you can download just the link graph actually

05:10:37 <Gracenotes> shortest path between two articles, for example

05:10:40 <pikhq> ›_›

05:10:49 <Gracenotes> （　≖‿≖）

05:11:24 <coppro> hahaha

05:11:28 <coppro> rofl xkcd

05:12:33 <Gracenotes> oh, really?

05:12:38 <Gracenotes> that good

05:12:41 <Gracenotes> *looks*

05:13:19 <Gracenotes> heh. heh. heh heh.

05:14:27 <Gracenotes> bsmntbombdood: there's always Markov chains

05:14:34 <Gracenotes> you'll have to strip out formatting

05:14:43 <Gracenotes> lots of training text...

05:14:47 <bsmntbombdood> that just gives you pagerank

05:14:58 <bsmntbombdood> oh, markov chains of text

05:16:37 <Gracenotes> run Flesch-Kincaid maybe

05:17:17 <GregorR-L> "The logistics of who can get drunk are nontrivial."

05:17:38 <bsmntbombdood> hmmm

05:17:41 <bsmntbombdood> i need a drunk

05:17:46 <GregorR-L> I disagree.

05:17:54 <coppro> I think you've had quite enough already

05:18:37 <oerjan> bsmntbombdood: schorry, i cant 'elp chu there

05:19:30 <Gracenotes> hm. I should try implementing Flesch-Kincaid in Haskell

05:19:40 <oerjan> kinky flesh

05:19:54 <Gracenotes> down boy

05:21:59 <oerjan> the syllable part may be a bit complicated

05:22:56 -!- oerjan has quit ("leaving").

05:23:01 <Gracenotes> er

05:23:03 <Gracenotes> :.;

05:23:43 <Gracenotes> actually it's less complicated than I thought

05:23:57 <Gracenotes> http://flesh.cvs.sourceforge.net/viewvc/flesh/Flesh%201.5/FleshLogic.java?revision=1.3&view=markup#l_523

05:24:05 <Gracenotes> more of a guess... but seems accurate enough

05:24:15 <Gracenotes> might be worth it to have a special table for corner cases

05:24:47 <Gracenotes> it doesn't say whether or not this is a standard algorithm. rather specific to English anyway

05:25:26 <coppro> broken link

05:25:45 <Gracenotes> wha

05:25:56 <Gracenotes> yeah... that's messed up. it worked a second ago

05:26:28 <Gracenotes> okay, should work now

05:26:50 <Gracenotes> actually, it does screw up quite a bit: http://flesh.cvs.sourceforge.net/viewvc/flesh/Flesh%201.5/CommonMistakes.java?revision=1.3&view=markup

05:27:19 <Gracenotes> needs more English knowledge

06:01:32 <bsmntbombdood> you can get dictionary files that break it down

06:03:04 <bsmntbombdood> Flesch-Kincaid sounds like a bunch of bs anyway

06:03:17 <bsmntbombdood> who cares how long sentences or words are

06:03:45 <coppro> Floridan insurance brokers, per Wikipedia

06:05:42 <bsmntbombdood> insurance and florida, that's all you need to know about their position

06:34:38 -!- GregorR-L has quit (Remote closed the connection).

06:44:05 -!- GregorR-L has joined.

07:01:37 -!- psygnisfive has quit ("Leaving...").

07:27:17 -!- Sgeo has quit (Read error: 110 (Connection timed out)).

07:37:35 -!- coppro has quit (Read error: 60 (Operation timed out)).

07:41:32 -!- GregorR-L has quit ("Leaving").

07:59:59 -!- clog has quit (ended).

08:00:00 -!- clog has joined.

08:55:25 -!- lereah_ has joined.

09:13:01 -!- GregorR-L has joined.

09:39:50 -!- Gracenotes has quit ("brb").

09:42:44 -!- Gracenotes has joined.

09:58:01 -!- tombom has joined.

10:04:37 -!- Patashu has joined.

10:13:25 <Patashu> hmm, still on the top of the hill

10:18:27 <GregorR-L> The next challenge: DOMINATE the hill.

10:19:41 <Patashu> I have no idea how to beat the defense6s and still beat everything else

10:19:45 <Patashu> I haven't even seen their code

10:20:10 <GregorR-L> http://codu.org/eso/bfjoust/in_egobot/

10:20:23 <GregorR-L> Uncommented though :P

10:20:40 <Patashu> oh

10:20:43 <Patashu> god damn that's long rofl

10:20:49 <Patashu> I need a decompiler

10:21:22 <GregorR-L> ais posted a link to a commented version ...

10:23:23 <GregorR-L> Ah, here 'tis

10:23:24 <GregorR-L> http://pastebin.ca/1435376

10:23:55 <GregorR-L> May 26 16:29:09 <ais523> it attacks something in particular, which is the [-] or [+] loop

10:23:55 <GregorR-L> May 26 16:29:13 <ais523> nearly all programs have one

10:23:55 <GregorR-L> May 26 16:29:38 <ais523> and if they go into such a loop on its flag, then defend6 will keep them in it forever, whilst running off and sinking their flag

10:24:30 <GregorR-L> *zleep*

10:24:47 <Patashu> oh I see

10:24:54 <Patashu> and it keeps coming back incrementially to keep it off zero

10:25:16 <Patashu> so it has an ultra-huge source code since there's no construct that says 'repeat this but increase this number by x every time'

11:51:27 -!- oerjan has joined.

12:16:29 -!- oerjan has quit ("leaving").

12:24:04 -!- M0ny has joined.

12:24:55 -!- Sgeo has joined.

12:52:55 -!- AnMaster has quit (Success).

12:57:06 -!- AnMaster has joined.

13:40:23 -!- Corun has joined.

14:13:19 -!- tombom has quit ("Peace and Protection 4.22.2").

14:23:45 -!- MizardX has quit ("What are you sinking about?").

14:39:36 -!- MizardX has joined.

14:47:15 -!- Corun has changed nick to Corun|away.

14:51:09 -!- Corun|away has changed nick to Corun.

15:34:59 -!- inurinternet has quit (Success).

15:49:47 -!- inurinternet has joined.

15:54:00 -!- impomatic has joined.

15:58:28 -!- lereah_ has quit ("Leaving").

16:01:30 -!- Patashu has quit ("Patashu/SteampunkX - MSN = Patashu@hotmail.com , AIM = Patashu0 , YIM = Patashu2 , Googletalk = Patashu0@gmail.com .").

16:43:04 -!- Gracenotes has quit (Success).

16:57:24 -!- BeholdMyGlory has joined.

17:00:50 -!- tombom has joined.

17:06:16 -!- fungebob has joined.

17:06:18 -!- FireFly has joined.

17:40:31 <ehird> cool i still own bf joust

17:42:35 <ehird> 01:38 Patashu: just one glitch

17:42:35 <ehird> 01:38 Patashu: the score it gives is for the LAST time you submitted a program

17:42:37 <ehird> 01:39 Patashu: i.e. one submission delay

17:42:39 <ehird> GregorR: GregorR-L: fix that

17:46:50 <ehird> !bfjoust phantom (>)*10([+[--[+++[----[+++++[------[+++++++[--------[+++++++++[----------]]]]]]]]]].>)*20

17:46:56 <EgoBot> Score for ehird_phantom: 41.5

17:47:06 <ehird> not bad

17:47:08 <ehird> not bad at all

17:47:28 <ehird> !bfjoust phantom (>)*10(-[+[--[+++[----[+++++[------[+++++++[--------[+++++++++[----------]]]]]]]]]]>)*20

17:47:33 <EgoBot> Score for ehird_phantom: 42.6

17:47:48 <ehird> !bfjoust phantom (>)*10(-[+[--[+++[----[+++++[------[+++++++[--------[+++++++++[----------]]]]]]]]]].>)*20

17:47:49 <EgoBot> Score for ehird_phantom: 42.6

17:48:35 <impomatic> Ehird: is that tailored for the decoys left by the programs on the current hill?

17:49:01 <nescience> lol creep officially beats nothing except the defends now

17:49:04 <ehird> impomatic: pretty much, it tries to find out whether it's big or small and efficiently zeroes it based on that

17:49:10 <ehird> !bfjoust phantom (>)*10(+[-[++[---[++++[-----[++++++[-------[++++++++[---------[++++++++++]]]]]]]]]]>)*20

17:49:11 <EgoBot> Score for ehird_phantom: 42.6

17:49:23 <nescience> but amusingly, 'playing the odds' is in 4th

17:49:26 <ehird> hmm flipping them does nothing

17:49:27 <nescience> <3 cached scores

17:49:27 <ehird> interesting

17:49:42 <nescience> refresh page

17:49:47 <nescience> remember it tends to show your last score

17:49:47 <ehird> 3 | - + + - - - - + - | 42.6| -3| ehird_phantom.bfjoust

17:49:50 <ehird> that's what it was before

17:49:50 <nescience> not the score after submission

17:50:03 <nescience> i see

17:50:11 <ehird> !bfjoust phantom (>)*10(-[+[-[+[-[+[-[+[-[+[-]]]]]]]]]]>)*20

17:50:12 <EgoBot> Score for ehird_phantom: 42.6

17:50:16 <nescience> not all that surprising i guess

17:50:17 <impomatic> I was wondering if it's possible to detect certain opponents and use a tailored attack.

17:50:17 <ehird> ouch

17:50:20 <ehird> that put it down to 14.2

17:50:33 <nescience> speed, i guess

17:50:52 <nescience> makes me wonder why so many +s before looping is effective though

17:50:55 <nescience> i guess it sets decoys of its own

17:51:09 <nescience> btw don't you want >*9?

17:51:15 <nescience> if it's 10 units long, it's 9 to the enemy flag

17:51:19 <ehird> oh

17:51:20 <ehird> right

17:52:03 <ehird> !bfjoust phantom (>-)*3(>+)*3(>)*3(+[-[++[---[++++[-----[++++++[-------[++++++++[---------[++++++++++]]]]]]]]]]>)*20

17:52:05 <EgoBot> Score for ehird_phantom: 42.6

17:52:13 <ehird> back to 42.6

17:52:28 <ehird> 5 losses, 3 wins, one draw

17:52:36 <ehird> i think the strategy is essentially good, though

17:52:46 * ehird idea

17:54:40 <ehird> !bfjoust phantom http://pastie.org/491591.txt?key=z90epgclqdxxiifgky728a

17:54:42 <EgoBot> Score for ehird_phantom: 42.6

17:54:48 <ehird> hahaha

17:54:51 <ehird> that makes it worse

17:55:06 <ehird> !bfjoust phantom (>-)*3(>+)*3(>)*3(+++++[-[++[---[++++[-----[++++++[-------[++++++++[---------[++++++++++]]]]]]]]]]>)*20

17:55:08 <EgoBot> Score for ehird_phantom: 27.8

17:56:14 <ehird> !bfjoust phantom (>-)*3(>+)*3(>)*3([-[(+)*2[(-)*3[(+)*4[(-)*5[(+)*6[(-)*7[(+)*8[(-)*9[(+)*10]]]]]]]]]]>)*20

17:56:16 <EgoBot> Score for ehird_phantom: 36.4

17:56:20 <nescience> this game is finicky

17:56:29 <ehird> hmm doing it with repeats actually slowed it down

17:56:49 <nescience> Patashu kept getting very different results by varying constants that didn't seem they should make that much difference

17:56:54 <ehird> shrug

17:57:12 <nescience> eh, the spec said repeats don't take any cycles

17:57:30 <ehird> !bfjoust phantom (>)*9([(-)*32[(+)*32[(-)*32[(+)*32]]]])*20

17:57:32 <EgoBot> Score for ehird_phantom: 36.4

17:57:33 <nescience> just macros.. should be the same

17:57:36 <nescience> unless it's randomness

17:57:39 * ehird crosses fingers

17:57:45 <ehird> nescience: I probably mistyped

17:57:49 <ehird> 3 | - 0 0 - - - - - 0 | 8.0| -6| ehird_phantom.bfjoust

17:57:51 <ehird> :D

17:58:58 <ehird> !bfjoust phantom (>)*9([(-)*16[(+)*32[(-)*48]]][-])*20

17:59:00 <EgoBot> Score for ehird_phantom: 8.0

17:59:14 <ehird> !bfjoust phantom (>-)*3(>+)*3(>)*3(+++++[-[++[---[++++[-----[++++++[-------[++++++++[---------[++++++++++]]]]]]]]]]>)*20

17:59:16 <EgoBot> Score for ehird_phantom: 8.0

17:59:17 <ehird> stick to what works.

17:59:43 <ehird> !bfjoust phantom >->->->+>+>+>>>(+++++[-[++[---[++++[-----[++++++[-------[++++++++[---------[++++++++++]]]]]]]]]]>)*20

17:59:45 <EgoBot> Score for ehird_phantom: 33.5

17:59:51 <ehird> wtf

17:59:59 <nescience> gogo random!

18:00:03 <ehird> nescience: the repeating one for the start got 33.5

18:00:06 <ehird> but this one gets 20.4

18:00:07 <ehird> !bfjoust phantom >->->->+>+>+>>>(+++++[-[++[---[++++[-----[++++++[-------[++++++++[---------[++++++++++]]]]]]]]]]>)*20

18:00:09 <EgoBot> Score for ehird_phantom: 20.4

18:00:12 <ehird> let's see if it's actually random

18:00:17 <ehird> yep, it is

18:00:19 <ehird> oh well

18:00:23 <ehird> impomatic: viper?

18:00:27 <nescience> look at 'playing the odds'

18:00:27 <ehird> are you submitting stuff? do it in channel :-P

18:00:29 <nescience> that's proof

18:00:44 <nescience> i submitted it a couple times till i got a couple decent cached results

18:00:44 <nescience> :P

18:00:53 <ehird> nescience: that's called being a jerk

18:00:54 <ehird> :)

18:00:55 <nescience> this hill is too noisy for such fine tuning

18:01:09 <nescience> if something was done to even out the randomness

18:01:18 <nescience> say, multiple samples *ahem* like i was mentioning yesterday... :P

18:01:20 <impomatic> ehird: I didn't want to flood the channel ;-)

18:01:30 <ehird> impomatic: but I don't notice new programs :-)

18:01:35 <ehird> nescience: yeah I agree now.

18:01:36 <nescience> i bet the max cycles probably doesn't need to be so high either

18:01:40 <ehird> it does

18:01:44 <ehird> defend6 needs it iirc

18:02:00 <nescience> i don't know

18:02:07 <nescience> i wonder how many cycles it'd take to complete at 30 cells

18:02:18 <nescience> i'm sure someone can caluclate but i don't have the required consecutive time atm

18:02:22 <nescience> or draw shortcutting at least

18:02:28 <nescience> detecting two [] loops, for examle :P

18:02:41 <nescience> or a [+] and [-] on the same cell

18:02:47 <ehird> i have 21 programs here. they are provably optimum for their tape length.

18:02:50 <ehird> should I submit them all? :P

18:03:02 <impomatic> Yes :-)

18:03:43 <ehird> okie dokie

18:03:52 <impomatic> !bfjoust viper >--->+++>---(>->+)*3(-[-[-[-[-[-[-[-[-[-[+]]]]]]]]]]>)*20

18:03:54 <EgoBot> Score for impomatic_viper: 42.0

18:04:23 <ehird> !bfjoust bugger1 >>>>>>>>>--------------------------------------------------------------------------------------------------------------------------------[-]

18:04:24 <ehird> !bfjoust bugger2 >>>>>>>>>>--------------------------------------------------------------------------------------------------------------------------------[-]

18:04:27 <ehird> !bfjoust bugger3 >>>>>>>>>>>--------------------------------------------------------------------------------------------------------------------------------[-]

18:04:30 <ehird> !bfjoust bugger4 >>>>>>>>>>>>--------------------------------------------------------------------------------------------------------------------------------[-]

18:04:33 <ehird> !bfjoust bugger5 >>>>>>>>>>>>>--------------------------------------------------------------------------------------------------------------------------------[-]

18:04:34 <impomatic> !bfjoust ferret >(-)*9>(+)*9>---(>->+)*3((-)*10[+]>)*20

18:04:35 <EgoBot> Score for impomatic_ferret: 66.0

18:04:36 <ehird> !bfjoust bugger6 >>>>>>>>>>>>>>--------------------------------------------------------------------------------------------------------------------------------[-]

18:04:37 <nescience> ...lol wut

18:04:39 <ehird> !bfjoust bugger7 >>>>>>>>>>>>>>>--------------------------------------------------------------------------------------------------------------------------------[-]

18:04:42 <ehird> !bfjoust bugger8 >>>>>>>>>>>>>>>>--------------------------------------------------------------------------------------------------------------------------------[-]

18:04:45 <ehird> !bfjoust bugger9 >>>>>>>>>>>>>>>>>--------------------------------------------------------------------------------------------------------------------------------[-]

18:04:48 <ehird> !bfjoust bugger10 >>>>>>>>>>>>>>>>>>--------------------------------------------------------------------------------------------------------------------------------[-]

18:04:48 <nescience> what'd you say about being a dick? :P

18:04:51 <ehird> !bfjoust bugger11 >>>>>>>>>>>>>>>>>>>--------------------------------------------------------------------------------------------------------------------------------[-]

18:04:54 <ehird> !bfjoust bugger12 >>>>>>>>>>>>>>>>>>>>--------------------------------------------------------------------------------------------------------------------------------[-]

18:04:57 <ehird> !bfjoust bugger13 >>>>>>>>>>>>>>>>>>>>>--------------------------------------------------------------------------------------------------------------------------------[-]

18:05:00 <ehird> !bfjoust bugger14 >>>>>>>>>>>>>>>>>>>>>>--------------------------------------------------------------------------------------------------------------------------------[-]

18:05:03 <ehird> !bfjoust bugger15 >>>>>>>>>>>>>>>>>>>>>>>--------------------------------------------------------------------------------------------------------------------------------[-]

18:05:06 <ehird> !bfjoust bugger16 >>>>>>>>>>>>>>>>>>>>>>>>--------------------------------------------------------------------------------------------------------------------------------[-]

18:05:09 <ehird> !bfjoust bugger17 >>>>>>>>>>>>>>>>>>>>>>>>>--------------------------------------------------------------------------------------------------------------------------------[-]

18:05:12 <ehird> !bfjoust bugger18 >>>>>>>>>>>>>>>>>>>>>>>>>>--------------------------------------------------------------------------------------------------------------------------------[-]

18:05:15 <ehird> !bfjoust bugger19 >>>>>>>>>>>>>>>>>>>>>>>>>>>--------------------------------------------------------------------------------------------------------------------------------[-]

18:05:18 <ehird> !bfjoust bugger20 >>>>>>>>>>>>>>>>>>>>>>>>>>>>--------------------------------------------------------------------------------------------------------------------------------[-]

18:05:21 <ehird> !bfjoust bugger21 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>--------------------------------------------------------------------------------------------------------------------------------[-]

18:05:26 <ehird> nescience: impomatic told me to :)

18:05:50 * ehird twiddles thumbs and waits for the report to update

18:06:06 <nescience> poor bot

18:06:36 <ehird> DOO DOO DOO DOO DEE DAA DOO DOO DOOOOOOO

18:06:39 * ehird pokes EgoBot

18:06:58 <ehird> nescience: technically, I have to submit them all infinite times to be sure of their tape lengths being correct

18:07:02 <ehird> since it's random

18:07:09 <ehird> so they'll probably all do awfully

18:07:30 <nescience> indeed

18:07:47 <ehird> BUT DAT'S OKAY

18:07:55 * ehird kicks EgoBot

18:07:57 <EgoBot> Score for ehird_bugger4: 22.4

18:07:57 <EgoBot> Score for ehird_bugger19: 5.7

18:07:57 <EgoBot> Score for ehird_bugger11: 18.3

18:07:57 <EgoBot> Score for ehird_bugger3: 40.9

18:07:57 <EgoBot> Score for ehird_bugger10: 4.8

18:07:58 <EgoBot> Score for ehird_bugger21: 5.3

18:08:00 <EgoBot> Score for ehird_bugger16: 7.4

18:08:02 <EgoBot> Score for ehird_bugger20: 0.0

18:08:04 <EgoBot> Score for ehird_bugger1: 29.4

18:08:04 <ehird> 40.9 for bugger3?

18:08:06 <EgoBot> Score for ehird_bugger13: 8.1

18:08:08 <EgoBot> Score for ehird_bugger17: 12.1

18:08:09 <ehird> That's pretty good, like.

18:08:10 <EgoBot> Score for ehird_bugger14: 6.9

18:08:11 <ehird> Guess I got lucky.

18:08:12 <EgoBot> Score for ehird_bugger8: 12.5

18:08:14 <EgoBot> Score for ehird_bugger12: 8.3

18:08:16 <EgoBot> Score for ehird_bugger15: 3.7

18:08:18 <EgoBot> Score for ehird_bugger9: 12.6

18:08:20 <EgoBot> Score for ehird_bugger18: 4.7

18:08:20 <ehird> nescience: look at the report

18:08:22 <EgoBot> Score for ehird_bugger7: 18.8

18:08:22 <ehird> quick

18:08:24 <EgoBot> Score for ehird_bugger6: 21.1

18:08:24 <ehird> before it trims them

18:08:26 <EgoBot> Score for ehird_bugger2: 42.2

18:08:27 <impomatic> Yeah, lucky score :-)

18:08:27 <ehird> http://codu.org/eso/bfjoust/report.txt

18:08:28 <EgoBot> Score for ehird_bugger5: 25.2

18:08:31 <ehird> hahaha

18:08:32 <ehird> it's huge

18:08:42 <ehird> :D

18:08:43 <ehird> they're all there

18:08:44 <nescience> haha

18:08:45 <nescience> nice

18:08:57 <ehird> 2343.678ehird_defend6_a_parody_or_just_plain_ripoff_question_mark.bfjoust

18:08:57 <ehird> 1342.1710ehird_bugger2.bfjoust

18:09:05 <ehird> i'd say that's pretty good!

18:09:15 <nescience> huh creep only has 4 losses now

18:09:19 <ehird> nescience: haha

18:09:23 <ehird> the power of buggery

18:09:39 <nescience> but ferret is at the top :P

18:09:42 <ehird> impomatic: is your ferret designed to be anti-bugger?

18:10:01 <nescience> i don't think anything can be anti-bugger

18:10:13 <ehird> nescience: it can, though

18:10:18 <ehird> it only decrements 128 times, then [-]s

18:10:22 <ehird> so, if you set your flag to 255

18:10:27 <ehird> it has to loop 128 iterations

18:10:33 <ehird> ofc, it'll still *win*

18:10:35 <ehird> it'll just win slower

18:10:41 <impomatic> Yes, I starting coding when you'd pasted the first two. Didn't take long.

18:10:43 <ehird> but correct, there is no way to actually beat it

18:10:48 <ehird> i dunno how buggers do with themselves

18:10:54 <ehird> ah

18:10:56 <ehird> they win at the same time

18:10:57 <ehird> cute

18:10:59 <ehird> = draw

18:11:05 <ehird> impomatic: how does yours work?

18:11:25 <ehird> nescience: note - this is in the ideal case, when their tape length is the expected one

18:11:39 <ehird> not that many got that

18:11:40 <ehird> if any even did

18:11:57 <ehird> nescience: in every other case, they just either: run right off the tape, or decrement a random cell

18:12:09 <ehird> nescience: I assume ferret sets a bunch of cells

18:12:11 <ehird> and then keeps them up

18:12:14 <ehird> so that it [-]s forever

18:12:19 <ehird> on a non-flag

18:13:10 <impomatic> ehird: just the usual build a decoy the go to the other end of the tape and start zeroing stuff

18:13:14 <ehird> right

18:14:12 <ehird> impomatic: submit ferret once more

18:14:14 <nescience> well it doesn't really matter

18:14:19 <ehird> and it'll trim most of them

18:14:20 <nescience> unless the tape length is correct they lose

18:14:32 <ehird> nescience: not if the other opponent suicides

18:14:52 <ehird> impomatic: it only leaves a lot of >10/11 challengers if they're submitted at once

18:14:52 <nescience> true enough i guess

18:14:55 <ehird> if you add ferret, it'll trim

18:15:53 <impomatic> !bfjoust shadow (>(-)*9)*2(>-)*7(>(+)*10[-])*20

18:15:59 <EgoBot> Score for impomatic_shadow: 58.0

18:16:13 <ehird> tada

18:16:15 <ehird> they're all gone

18:16:24 <ehird> and parody rises once ore

18:20:58 <nescience> laugh

18:21:08 -!- Corun has changed nick to Corun|away.

18:21:22 -!- Corun|away has changed nick to Corun.

18:21:56 -!- impomatic has left (?).

18:23:58 -!- AnMaster has quit (Connection timed out).

18:29:19 <nescience> it's really hard to read which number is which warrior

18:29:39 <nescience> and the numbers change because of the case sorting, too

18:29:57 <nescience> what's the chance of reiterating the numbers immediately to the left of the warrior names or something?

18:30:28 <ehird> would be nice

18:30:50 <ehird> nescience: i think I'm just going to make my own variant instead of waiting for these to change :)

18:31:03 <ehird> do you think I should have + or -? i.e. which?

18:32:27 <nescience> it doesn't really matter

18:32:30 <nescience> if you have to pick one, i mean

18:32:40 <ehird> i was asking purely on aesthetic concerns :)

18:32:46 <nescience> aha

18:32:51 <nescience> i like - better!

18:32:52 <ehird> - seems right

18:32:55 <nescience> it looks like arrows ------>

18:32:57 <nescience> CHARGE!

18:32:59 <ehird> as the main objective is to deplete your opponents flag

18:33:03 <ehird> nescience: haha

18:33:11 <pikhq> »»».

18:33:32 <nescience> arrows or ... jesus, i can't think of the name of the things you joust with!

18:33:40 <ehird> jousting sticks!

18:33:58 * pikhq should create a Brainfuck variant that uses », ›, and > for different things

18:34:07 <ehird> nescience: ok: < move pointer closer to my flag > move pointer closer to their flag - decrease cell at pointer [ jump after matching closer if cell=0 ] jump after matching opener if cell!=0 . nop

18:34:36 <nescience> lol jousting sticks

18:34:37 <ehird> nescience: i think flags should start at 255

18:34:44 <ehird> they only start at 128 in joust to make +/- not have an advantage

18:34:49 <nescience> correct

18:35:01 <nescience> but if you restrict it to only - it becomes about half as interesting

18:35:25 <ehird> nescience: no, I think - vs + is boring. see defend6 vs parody

18:35:32 <ehird> and my flipping of one of impomatics' did it to

18:35:33 <ehird> o

18:35:36 <ehird> it just makes it too trivial

18:35:40 <ehird> as programs become tailored to one

18:35:44 <ehird> and flipping them decimates them

18:36:17 <nescience> rather, it means that nobody has got to the point where they write programs to take account of both polarities for example :P

18:36:22 <nescience> lance!

18:36:24 <nescience> that's the word i wanted

18:36:36 <nescience> if you want to talk about trivial, what exactly are you going to write a program to do that only decrements?

18:36:46 <ehird> nescience: doesn't rushpolarity take into account that?

18:36:54 <ehird> i'm just not convinced it's an interesting aspect

18:37:19 * nescience shrugs

18:37:29 <ehird> nescience: then how about thingy's idea

18:37:35 <ehird> the polarity is flipped or not randomly before execution

18:37:37 <ehird> actually, wait

18:37:40 <ehird> same as with tape lengths

18:37:46 <ehird> we do it for all (tape length,polarity) combinations

18:37:51 <ehird> and take the mean

18:38:03 <ehird> i'm going to write it in C, so it should be fast enough for that

18:38:09 <ehird> nescience: sound good?

18:38:11 <nescience> that's a possibility

18:38:32 <nescience> i'm not sure how i feel about that, but it would at least get rid of the "swap the signs" bit

18:38:50 <nescience> i guess it is true that you'll get the same program if you swap them

18:39:22 <ehird> nescience: it forces you to take in account polarity, still

18:39:25 <ehird> without being able to just swap things

18:40:16 <nescience> i don't think so

18:40:26 <nescience> well, i guess i see what you mean

18:40:33 <nescience> in that you still can benefit from "figuring out" which way to go

18:40:54 <ehird> lifthrasiir: ehm, so north korea just said they're going to nuke the shit out of your country

18:40:58 <ehird> try not to die

18:41:12 <ehird> nescience: yeah

18:41:18 <ehird> nescience: you have to handle both +ers and -ers

18:46:50 -!- jix has joined.

18:47:38 <ehird> nescience: definitely, though, randomness is the bad

18:54:57 -!- AnMaster has joined.

18:57:50 -!- jix_ has quit (Read error: 110 (Connection timed out)).

19:08:46 -!- KingOfKarlsruhe has joined.

19:10:36 -!- sebbu2 has joined.

19:15:46 <ehird> OK, it's implementation time.

19:16:07 <nescience> that's totally out of character for them

19:16:12 <nescience> don't koreans play zerg?!

19:16:26 <ehird> BADUM TISH!

19:18:27 <AnMaster> <ehird> OK, it's implementation time. <-- of what

19:18:44 <AnMaster> (as you can see above I was disconnected)

19:18:44 <ehird> AnMaster: ~20 lines up.

19:18:54 <ehird> http://tunes.org/~nef/logs/esoteric/09.05.27

19:18:56 <ehird> You're welcome.

19:20:07 <AnMaster> ehird, a language based on magnetic tape?

19:20:17 <ehird> ...

19:20:37 <AnMaster> ehird, from reading ~20 lines up in the log :P

19:20:47 <ehird> Mmmmmmmmmmmmmmmmmmmmyeeeeeeeeeeeeeeeeeeeno.

19:22:59 <ehird> nescience: how many cycles do you think I should allow?

19:24:36 -!- sebbu has quit (Success).

19:25:19 <AnMaster> ehird, theory 2: a variant of bfjoust

19:25:27 * ehird clap. clap. clap

19:25:33 <ehird> You found the page up button!

19:25:49 -!- ais523 has joined.

19:25:53 <ehird> hi ais523

19:25:56 <AnMaster> hello ais523

19:26:03 <ehird> I'm plotting revolution by writing a better bf joust ;)

19:26:06 <ais523> hello ehird, AnMaster

19:26:11 <ais523> ehird: as in, better rules, or better interp?

19:26:14 <ehird> ais523: both

19:26:16 <ais523> the interp can definitely be improved

19:26:29 <ehird> it's varying randomly according to tape length [implementation issue], just flipping +/- can change the hill wildly [design issue]

19:26:35 <ais523> but if you want to improve the rules, /please/ do it a different way from zzo38

19:26:36 <ehird> and it's really slow [implementation]

19:26:53 <ehird> for the former, run all tape lengths and take the average (requires fixing #3)

19:27:02 <ehird> for the latter, add another variable: is_plus_and_minus_flipped

19:27:05 <ehird> and do the solution to #1 for it too

19:27:09 <ais523> oh, ok

19:27:13 <ehird> for the latter latter, write it in C and make it superfast

19:27:14 <ais523> so you aren't changing the language rules, but the tournament rules

19:27:19 <ais523> I agree with you on that

19:27:23 <ehird> ais523: well, the flipping +/- thing

19:27:35 <ais523> either you randomly flip one program, or you don't

19:27:36 <ehird> means that you can't just rip off someone else's program, flip +/- and dominate the hill

19:27:41 <ehird> ais523: actually, no

19:27:45 <ehird> well, yes

19:27:48 <ehird> ais523: but not randomly

19:27:53 <ehird> ais523: just like how you try all tape lengths and take the averag

19:27:54 <ehird> e

19:27:54 <ais523> do both

19:27:58 <ehird> exactly

19:28:05 <ehird> try every combination, take the average score

19:28:13 <ehird> that means the same program will always have the same score

19:28:55 <ehird> ais523: how did zzo do it?

19:29:25 <ais523> ehird: having , read from the opponent's . output

19:29:28 <ais523> and a couple of other dubious changes

19:29:38 <ehird> ais523: that change is very zzo

19:29:41 <ehird> link to his variant?

19:29:47 <ais523> ehird: http://esolangs.org/wiki/Talk:BF_Joust

19:29:57 <ehird> grr, wiki seems to be slow

19:30:09 <ehird> ais523: btw, you know how it has to stay 0 for two cycles?

19:30:12 <ais523> yes

19:30:21 <ehird> that means that [-] works if it isn't tampered with. [-]-]-]-(it's zero)](two cycles)

19:30:23 <ehird> is that intentional?

19:30:27 <ehird> i suppose so

19:30:33 <ehird> but it was unintuitive to me at first

19:30:36 <ehird> and I did [-].

19:30:38 <ais523> not quite, but when I noticed I realised it was correct, so didn't change it

19:30:39 <ehird> (with the dot)

19:30:48 <ehird> Safari can’t open the page “http://esolangs.org/wiki/Talk:BF_Joust” because the server unexpectedly dropped the connection. This sometimes occurs when the server is busy. Wait for a few minutes, and then try again.

19:30:52 * pikhq observes that [-]-] is an infinite loop

19:31:00 <ais523> pikhq: not in BF Joust

19:31:11 <ehird> pikhq: i'm counting cycles

19:31:11 <pikhq> ... WTF?

19:31:15 <ais523> there is no way to write a definitively 100% infinite loop in BF Joust

19:31:18 <ehird> [-] runs [-]-]-]-]-]-]-]

19:31:23 <ehird> pikhq: not program

19:31:24 <ehird> cycles

19:31:27 <ais523> because the data on the tape might change due to the opponent messing with it

19:31:32 <ehird> [ ticks, - ticks, ] ticks, - ticks, ] ticks

19:31:33 <ehird> etc

19:31:40 <ehird> also, what ais523 said

19:31:48 <ehird> ais523: [[In case of a draw, figure out who would have lost using the old rule that whoever's flag is zero loses immediately (and determine the winner according to this rule). ]]

19:31:50 <ehird> ok, that's just ridiculous

19:31:55 <ehird> [[If both programs have ended and neither player's flag is zero, then both programs shall restart from the beginning with the tape pointer pointing to their own flag again like it was at the start, but using the current values on the tape instead of resetting them to zero. ]]

19:31:57 <ehird> so's that

19:32:02 <ehird> all of them are ridiculous :)

19:32:06 <ais523> agreed

19:32:15 <ehird> ais523: how could you even use ,/.

19:32:18 <ehird> you couldn't use it to your advantage

19:32:22 <ehird> because your opponent would always lie

19:32:30 <ais523> ehird: I don't think they'd even be lying

19:32:34 <ehird> oh?

19:32:41 <ais523> given that there's no information as to what the random stream of data means anyway

19:32:45 <ehird> true

19:32:55 <ais523> it's like, if I say 6 202 34, am I lying?

19:33:03 <ehird> ais523: Mu

19:33:20 <ehird> [[[ and ] should take the value on the tape *after* the opponent has (potentially) modified it.]

19:33:21 <ehird> ]

19:33:26 <ehird> ais523: does it do it before modification?

19:33:30 <ais523> atm, yes

19:33:30 <ehird> two opcodes running at once is sticky

19:33:34 <ais523> it takes the value at the start of the cycle

19:33:37 <ehird> hmm

19:33:53 <ais523> I experimented with before and after

19:34:00 <ehird> ais523: ah, and before worked better?

19:34:07 <ais523> and decided that although it made a difference, it didn't fundamentally change the nature of things

19:34:12 <ais523> so left it where Kerim had it

19:34:23 <ehird> http://esolangs.org/w/index.php?title=Byte_Syze&curid=2347&diff=14541&oldid=14540

19:34:26 <ehird> lol wat

19:34:31 <pikhq> !bfjoust foo .[+.]

19:34:37 <EgoBot> Score for pikhq_foo: 17.5

19:34:41 <ehird> pikhq: that's just a suicider

19:34:43 <ehird> a slow one at that

19:34:48 <ehird> well, not always

19:34:52 <pikhq> Seems to be effective.

19:34:58 <ehird> but I don't think any program will try and give your flag viagra— what?

19:35:00 <ehird> How is that effective?

19:35:11 <pikhq> It has a positive score. :p

19:35:12 <ehird> if we weren't caching scores, the top program gets ~85pts

19:35:16 <ehird> pikhq: all scores are positive

19:35:17 <ais523> pikhq: we changed the scoring

19:35:19 <ehird> points are negative

19:35:21 <ehird> scores not

19:35:21 <pikhq> Oh.

19:35:25 <ais523> 50% is average, 0% is terrible, 100% is perfect

19:35:49 <ehird> ais523: i submitted (>)*N(-)*128[-] (but manually expanded) for all possible tape lengths today

19:35:54 <pikhq> !bfjoust [>+]

19:35:54 <ehird> one even got ~40-something

19:35:55 <EgoBot> Use: !bfjoust <program name> <program>

19:35:57 <ehird> :-D

19:36:01 <pikhq> Erm.

19:36:03 <pikhq> !bfjoust foo [>+]

19:36:04 <EgoBot> Score for pikhq_foo: 20.5

19:36:04 <ehird> ais523: also, btw

19:36:08 <ehird> if you resubmit a program

19:36:10 <ehird> you get its last score

19:36:15 <ehird> you have to look at the report to get the proper one

19:36:15 <ais523> another bug?

19:36:18 <ehird> yep

19:36:21 <ais523> ah, ok

19:36:23 <ehird> ais523: why do you think i'm writing my own :)

19:36:31 <ehird> ais523: also, well, taking the value at the start requires copying

19:36:33 <ehird> doesn't it?

19:36:35 <ehird> well

19:36:39 <ehird> i guess no

19:36:39 <ehird> since

19:36:42 <ehird> with after-modification

19:36:45 <ehird> you have to wait for your opponent

19:36:48 <ehird> which is just as much fuss

19:36:54 <ais523> it only requires copying for one of the programs

19:36:58 <ais523> and it's as much fuss both ways round

19:37:08 <ehird> yep

19:37:15 <ais523> you could order the execution of the programs inside the interp in the way that avoids copying, but that's even fussier in other ways

19:38:28 <ehird> ais523: do you think I should keep the 20k max cycles?

19:38:46 <ais523> that's about right

19:38:50 <ehird> it may take 3s to execute one combination for 20k cycles in your perl interp, but it'll probably be on the order of milliseconds for mine :)

19:38:51 <ais523> I determined that number via experiment

19:39:04 <ais523> as in, if you make it much lower, valid programs start drawing rather than winning

19:39:11 <ehird> but then we have the reverse polarity

19:39:13 <ehird> which is 3-bits:

19:39:19 <ehird> 0 (no flip), 1 (flip left), 2 (flip right)

19:39:22 <ehird> hmm

19:39:28 <ehird> is that 20**3 for the tape lengths and polarity

19:39:31 <ehird> or 3**20?

19:39:33 <ehird> 20**3, I think

19:39:58 <ehird> ais523: hm, oh dear

19:40:07 <ehird> for all tape length combinations, and the three polarity states,

19:40:16 <ais523> why three polarities?

19:40:16 <ehird> ais523: is 8000 executions per (prog1,prog2)

19:40:18 <ais523> you only need two

19:40:21 <ehird> also

19:40:24 <ehird> ais523: no i don't

19:40:25 <ehird> no flip,

19:40:25 <ais523> because flipping either program has the same effect

19:40:30 <ehird> er, are you sure?

19:40:31 <ais523> and flipping both has the same effect as flipping neither

19:40:31 <ehird> always?

19:40:44 <ais523> ehird: the values at the start are either 128 or 0

19:40:46 <ehird> hmm, i'll take your word for the left-is-right

19:40:53 <ehird> ais523: yeah, you're right

19:40:55 <ehird> ais523: but...

19:40:58 <ehird> which of left/right should I flip?

19:41:00 <ehird> i don't wanna be biased :D

19:41:05 <ais523> it makes no difference to the result

19:41:18 <ehird> 0 = no flip, 1 = flip, the

19:41:18 <ehird> n

19:41:36 <ais523> and you need 20 * 2 (no exponentiation)

19:41:39 <ais523> well, 21 * 2

19:41:44 <ehird> oh, heh

19:41:47 <ais523> each of the 21 possible lengths in each of the 2 flip states

19:41:55 <ehird> i'll finish the message I was typing anyway:

19:42:00 <ehird> ais523: well, that's good; with 3 flip states, I have to run the match 8000 times— so if I take 25ms to run one iteration, that's 200 seconds!

19:42:02 <ehird> ↑ disclaimer: wrong

19:42:45 <ais523> 200 seconds would be a bit slower than it currently is; OTOH, you'd have a fairer tournament

19:42:47 <ehird> ais523: OK, if I take 25ms to run one iteration (reasonable, I think) and do all 21 tape lengths, and have 2 polarity states, a match will take 1.05 seconds

19:42:58 <ehird> a full complete matchup of (prog1,prog2)

19:43:33 <ehird> ais523: err, for 10 programs, you have how many pairs of (prog1,prog2)? my brain is in coding mode atm...

19:44:12 <ais523> (10*9)/2 = 45

19:45:00 <ehird> ais523: so, assuming I do no caching whatsoever, and have a 10-length hill (one less than the current hill; it's 0-10, I guess as a mistake) then it'd take 47.25 seconds to run all matches

19:45:08 <ehird> fairly and deterministically, on every combination of tape length/polarity

19:45:10 <ehird> that's not bad at all

19:45:14 <ehird> and with some caching..

19:45:16 <ehird> *...

19:45:39 <ais523> with some caching, you only need to run the 9 matches involving the current challenger

19:45:42 <ais523> but I don't think that is a mistake

19:45:50 <ais523> the hill atm is 10 returning programs, plus 1 newbie

19:45:54 <ehird> ah

19:45:56 <ehird> that makes sense

19:46:31 <ehird> ais523: so 51.45 seconds then

19:46:33 <ehird> + caching

19:46:47 <ehird> ais523: 9.45 seconds, then, with caching

19:46:51 <ehird> for a challenger

19:46:58 <ehird> ais523: hmm... do you think 25ms for a match is over or underestimating?

19:47:00 <ehird> i'm not sure

19:47:02 <ais523> are you going to pre-expand programs? or expand on the fly to save memory?

19:47:13 <ais523> some of them are likely to get very long with abbreviations removed

19:47:27 <ehird> ais523: i don't care about memory usag

19:47:27 <ehird> e

19:47:33 <ehird> ais523: how long's defend6 expanded?

19:47:39 <ehird> not more than a few kilobytes, I'd wager

19:48:02 <ais523> yep, defend5 is possibly quite long though

19:48:20 <ehird> ais523: megabytes?

19:48:28 <ehird> codu.org runs on a VPS with 1GB of RAM

19:48:30 <ais523> probably not

19:48:37 <ehird> i'm sure a few megabytes is just fine

19:48:50 <ais523> but the reason I didn't expand is that the way I programmed my interp, I'm O(n) below the optimum

19:48:59 <ais523> so it's like I wrote a Mathematica program rather than a C program

19:49:10 <ais523> you can make each cycle run in O(1) time, though, so the length of the program isn't an issue

19:49:26 <ehird> ais523: I'm probably going to have a trivial optimization step

19:49:31 <ehird> ++++++++++++++++++ -> +*foo

19:49:33 <ehird> nothing fancy at all

19:49:40 <ehird> although, wait

19:49:44 <ehird> ais523: you know your (x)*foo thing?

19:49:47 <ehird> it doesn't change cycles, does it?

19:49:47 <ais523> yes

19:49:50 <ais523> and no

19:49:51 <ehird> you said it makes the program "run faster"

19:49:53 <ais523> it's strictly abbreviations

19:49:55 <ehird> i guess that's just interp time

19:49:57 <ais523> it makes the interp run faster

19:49:59 <ehird> ais523: ok, I won't do any optimization at all

19:50:01 <ais523> in realtime

19:50:03 <ehird> it's simplest

19:50:09 <ais523> rather than the program in gametime

19:50:11 <ehird> after all, a cycle will probably take a fraction of a millisecond

19:52:25 <ehird> okay then, time to write the interpreter loop

19:54:33 <ehird> ais523: are you sure, by the way, that 20 is a good variation in tape length?

19:54:37 <ehird> I would go for 10 max

19:54:42 <ehird> otherwise, strategies are too unpredictable

19:55:00 <ehird> IMO tape length variation should just stop the lame strategy of (>)*constant mwahaha i'm at the opponent's flag!

19:55:08 <ais523> ehird: I was wondering about that

19:55:20 <ais523> I definitely want to keep the tape length shorter than 32

19:55:25 <ais523> and I wanted the chance of a very short tape

19:55:34 <ais523> but maybe 10-20, or even 10-15, would be a better variation

19:55:38 <ehird> ais523: also, with the averaging of tape lengths I'm doing, there doesn't need to be enoguh variation

19:55:43 <ehird> ais523: I'd go for 15-25

19:55:53 <ehird> 15 is just long enough to not be stuffy

19:56:01 <ehird> and 25 is just short enough not to be massive

19:56:12 <ais523> the idea is that an aggressive program starting >>>>>>>>>>> should be able to arrive before the opponent completes a complex decoy

19:56:15 <ais523> at least some of the time

19:56:40 <ehird> eh, I'll just keep 10-30

19:56:58 <ehird> ais523: btw, how come it's 21 possibilities?

19:57:04 <ais523> 10-30 inclusive

19:57:17 <ehird> oh, ofc

19:57:23 <ehird> #define MAX_CYCLES 20000

19:57:23 <ehird> #define MIN_TAPE_LENGTH 10

19:57:25 <ehird> #define MAX_TAPE_LENGTH 30

19:57:27 <ehird> configurability!

19:58:20 <ehird> ais523: is \0 a valid char? :P

19:58:36 <ais523> ehird: if it were, it would be a comment

19:58:43 <ais523> I'd say that if you encounter a \0, treat it as a comment

19:58:50 <ais523> but don't expend effort to make sure it doesn't get eaten before then

19:58:51 <ehird> ais523: C byte arrays, yo.

19:59:05 <ehird> I'll just let it be the end of the string like normal, nobody's gonna use it.

19:59:11 <ais523> or you can just strip out the \0s when loading the program, if oy ucare

19:59:13 <ais523> *you care

19:59:23 <ehird> not particularly

19:59:37 <ehird> ais523: how many nested loops do you think there might be?

19:59:48 <ais523> defend5 has several thousand

19:59:55 <ais523> using a ({})% expansion

19:59:56 <ehird> ais523: hmm

20:00:04 <ehird> ais523: is the C stack that big, d'you think? :)

20:00:13 <ais523> probably, it depends on your OS

20:00:22 <ais523> on Windows, the default stack is exactly 1 MiB, I think

20:00:25 * ehird runs a simple test program

20:00:26 <ais523> I'm not sure what it is on Linux

20:03:24 * ehird runs stack-user

20:03:33 <ehird> ais523: on OS X, it's many millions so far

20:04:23 <ehird> hmm

20:04:30 <ehird> maybe gcc removed the tail recursion

20:04:32 * ehird uses the result to make sure

20:04:34 <Deewiant> How about running 'ulimit -s'?

20:04:59 <ehird> 8192, which is surprisingly small. But Deewiant, I want to know how many calls, on average.

20:05:03 <ehird> Not the actual size.

20:05:14 <Deewiant> Just find out the size of your stack frame?

20:05:19 <ehird> How boring

20:05:24 <Deewiant> Also, that's in kilobytes

20:05:28 <Deewiant> So it's 8x the Windows size.

20:05:43 <ehird> yes

20:06:08 <ehird> ais523: does lostkng have more nesting than defend5, do you think?

20:06:16 <ehird> also,

20:06:16 <ais523> probably not

20:06:17 <ehird> 943219

20:06:17 <ehird> zsh: segmentation fault ./lance

20:06:20 <ehird> int stack_size(int i)

20:06:21 <ehird> {

20:06:23 <ehird> int foo = i;

20:06:25 <ehird> printf("%i\n", foo);

20:06:27 <ehird> return foo + stack_size(i+1);

20:06:29 <ehird> }

20:06:31 <ehird> so I should be fine

20:06:45 <ais523> lostkng doesn't seem to nest deeply

20:06:47 <pikhq> 261842 stack calls on my system.

20:07:01 <ehird> ais523: lostkng's bundled interp uses recursion to parse loops, y'see

20:07:04 <ehird> I'm just wondering if that's wise

20:07:09 <ais523> gcc-bf nests a lot more, it's a bit deeper than 256

20:07:15 <ais523> wait, 256*3

20:07:18 <ais523> on a sufficiently long program

20:07:24 <ais523> because it uses nested loops to do switch statements

20:08:02 <pikhq> Millions and counting with -Os.

20:08:28 <ehird> pikhq: it may have optimized it into a loop

20:08:38 * pikhq will laugh if it craps out at INTMAX.

20:08:54 <pikhq> ehird: I bet it did at this rate.

20:09:10 <ehird> i suppose the loop's smaller than the recursion

20:09:22 * pikhq does -S and looks at the generated assembly

20:09:48 <ehird> Hmm.

20:10:08 <ehird> ais523: going through an array's likely to be more efficient than traversing a linked list, isn't it?

20:10:21 <ehird> (I'm thinking about speed upfront because of the large number of combinations I have to run each program through)

20:10:33 <ais523> hmm, let me think

20:10:38 <pikhq> It got optimized into a silly loop.

20:10:40 <ais523> they're both O(1)

20:10:52 <ehird> ais523: not efficiency, speed

20:10:56 <ehird> pikhq: heh, translate the loop to C?

20:10:57 <ais523> so it depends on the individual opcodes

20:10:59 <ehird> *to C

20:11:12 <ehird> ais523: well, I'm thinking about, e.g. the cache

20:11:13 <ais523> taking the next list element involves dereferencing a pointer

20:11:19 <ehird> ais523: a linked list won't be together in memory

20:11:26 <ehird> so jumps will be further away

20:11:27 <ais523> ehird: could be, depending on how it's allocated

20:11:29 <ehird> an array is all clumped together

20:11:32 <ais523> but it's going to take up more memory

20:11:34 <ehird> ais523: could be, but isn't guaranteed to be

20:11:36 <ais523> so less will fit in the cache

20:11:38 <ehird> that also

20:11:40 <ais523> so I suspect the array will be faster

20:11:56 <pikhq> void stack_test(int i){while(1)printf("%i", i++);}

20:12:08 <ais523> also, you can use a posix_foo function to tell the memory manager that you're about to read a load of memory sequentially

20:12:14 <ehird> pikhq: that doesn't include a return value

20:12:21 <ehird> which is what I did to attempt to force some recursion

20:12:21 <ais523> maybe even vectorise it!

20:12:26 <ehird> ais523: hahahahahano.

20:12:27 <pikhq> Ahah.

20:12:33 <ehird> _posix_fadvise

20:12:41 <ehird> yeah without a _

20:12:42 <ehird> whatever :P

20:14:24 <ehird> hmm

20:14:35 * ehird thinks of names for + and - that don't relate to adding and subtracting, due to polarity issues

20:14:40 <ehird> dink and donk‽

20:14:52 <ais523> clockwise and anticlockwise

20:15:06 <ehird> ais523: but... that doesn't even make any sense :D

20:15:11 <ais523> it does

20:15:16 <ais523> because it's using modular arithmetic

20:15:19 <ehird> heh

20:15:22 <ais523> the numbers form a circle, not a numberline

20:15:27 <ehird> [+]--+- "Loop dink end loop donk donk dink donk"

20:15:37 <ehird> ais523: but if they're flipped, it'll be anticlockwise and clockwise

20:15:43 <ehird> I want them to not require flipping when...flipped

20:15:47 <ehird> as it's not flipping, just two different views

20:15:48 <ehird> equal

20:17:21 <ehird> ais523: no?

20:17:51 <ais523> well, clockwise/anticlockwise depends on which end of the tape you're looking from

20:18:00 <ehird> true.

20:18:04 <ais523> but the problem is, with one polarity, one program's dink will be the other program's donk

20:18:11 <ais523> with the other, they'll both dink the same way

20:18:12 <ehird> ais523: nope, wrong

20:18:16 <ehird> dink doesn't mean any particular way

20:18:17 <ehird> it just means dink

20:18:18 <ehird> same with donk

20:18:21 <ais523> ehird: agreed

20:18:24 <ehird> add, however, is presumably adding

20:18:27 <ais523> but are you altering the programs when altering the polarity?

20:18:28 <ehird> which would be false under other polarities

20:18:30 <ehird> ais523: nope

20:18:38 <ehird> ais523: the point is, it's defined as:

20:18:47 <ais523> ehird: well, either one program's dink cancels out the other program's donk, or it doesn't

20:18:52 <ehird> + If polarity is floob, increment. If polarity is boolf, decrement.

20:18:54 <ais523> in one polarity, it does; in the other; it doesn't

20:18:58 <ehird> so it's always dink/donk

20:19:29 <ais523> the point is, changing the polarity has to reverse the meanings of +/- for exactly one program

20:19:45 <ehird> ais523: the meanings don't change

20:19:51 <ehird> the definitions of the operations change

20:20:00 <ais523> well, ok

20:20:01 <ehird> ais523: that's like saying that the meaning of [ is reversed if the cell is zero

20:20:06 <ais523> reverse the definitions for exactly one program

20:20:07 <ehird> it's not; that check is part of the operation and doesn't change

20:20:14 <ehird> no definition, meaning or anything

20:20:21 <ehird> just a conditional in its definition always evaluates one w ay

20:20:22 <ehird> *way

20:21:15 <ais523> ok

20:21:26 <ais523> just bear in mind, that with one polarity, dink in program 1 will do the same thing as dink in program 2

20:21:33 <ehird> yes

20:21:35 <ais523> with the other polarity, dink in program 1 will do the same thing as donk in program 2

20:21:40 <ehird> ais523: i'm really just trying to be nice to the names dink/donk as they sound funny

20:21:43 <ais523> ok

20:21:55 <ehird> you may end up convincing me to use clockwise/counterclockwise instead, though :P

20:22:01 <ehird> bikesheds hooray

20:22:06 <ais523> nah, dink/donk is shorter

20:22:10 <ehird> very true

20:22:24 <ehird> ais523: > is march, < is retreat

20:22:37 <ais523> heh, that sounds about right

20:23:24 <ehird> . is rest

20:23:35 <ehird> hmm

20:23:41 <ehird> ais523: [ = consider, ] = reconsider? :P

20:23:47 <ehird> just trying to go for an intercal vibe :)

20:23:59 <ais523> that's quite a vibe

20:24:18 <ehird> hmm

20:24:45 <ehird> ais523: it doesn't really reflect the jumpyness of it, though, does it?

20:25:21 <ais523> does it need to?

20:25:31 <ehird> not particularly

20:25:35 <ehird> i'm trying to come up with a military analogist

20:25:38 <ehird> *analogy

20:25:48 <ehird> ] = ONE_AND_A_TWO_AND_A is a bit too long.

20:28:51 <ehird> ais523: advantage of linked list— easier to mark end of program

20:28:54 <ehird> wait, no

20:29:07 <ehird> just {a,b,c,NULL}

20:29:12 <ehird> or the like

20:29:25 <ehird> OP_EOF

20:31:26 <ehird> ais523: Polarities: sieve, kettle.

20:33:49 <ais523> fair enough

20:34:15 -!- Gracenotes has joined.

20:34:49 <nescience> ehird, i was just thinking that if you do the swapping thing,

20:34:55 <nescience> that's 4 * 20 fights per pair

20:34:58 <nescience> if you do every combination

20:35:03 <ehird> nescience: nope

20:35:03 <ehird> 2

20:35:04 <nescience> ... but, effectively, you only need to do 2

20:35:08 <nescience> 'cause the others would be equivalent

20:35:13 <ehird> nescience: ais523 told me this ages ago :)

20:35:14 <nescience> ... yeah, so i guess you already did that :>

20:35:16 <ehird> i had none, left, both

20:35:17 <nescience> hehe

20:35:20 <ehird> er

20:35:21 <ehird> none, left, right

20:35:24 <ehird> but ais523 told me left=right

20:35:26 <nescience> i'm not reading, just occurred to me to mention it

20:35:26 <ehird> so, yeah

20:36:36 -!- olsner has joined.

20:37:49 <nescience> (i guess it's actually *21)

20:37:54 -!- MizardX has quit ("Dead pixels in the sky.").

20:37:55 <ehird> yep

20:37:59 <nescience> anyway, this is technically my work computer so i'm sporadic :P

20:38:09 <nescience> you should get super tricky and run all of them in parallel!

20:38:10 <nescience> hehe

20:38:14 <ehird> lawl

20:38:30 <ehird> nescience: iirc, codu only has one virtual cpu

20:38:39 <ehird> so that wouldn't help too much

20:38:43 <ehird> locally, though...

20:40:23 <ehird> "In January 2003, the toothbrush was selected as the number one invention Americans could not live without, beating out the automobile, computer, cell phone, and microwave oven, according to the Lemelson-MIT Invention Index.[4]"

20:41:24 <ehird> ais523: grr, variadic macros are C99 aren't they?

20:41:30 <ehird> and gnuc89

20:42:00 <ais523> yes

20:42:03 <ehird> darn

20:42:08 <ais523> although, you can often have the same effect by using a second pair of parens

20:42:10 <ais523> even in C89

20:42:13 <ehird> yes

20:42:18 <ais523> because (a,b) is one param to a macro

20:42:21 <GregorR-L> ehird: This is the USA, not Britain.

20:42:43 <ehird> GregorR-L: in britain we never use toothbrushes

20:42:50 <ehird> as evidenced by our TERRIBLE BRITISH ORAL HYGIENE

20:42:51 <ehird> HA HA HA

20:43:22 <GregorR-L> I used to believe that was just a stereotype, until I went there on vacation :P

20:43:44 <ehird> i am constantly amazed that people actually go here voluntarily

20:43:49 <ehird> it's... not an exciting country

20:43:53 <nescience> stereotypes are usually based in fact

20:43:59 <nescience> i found the same thing about canadians and "eh"

20:44:25 <ehird> nescience: correct, you blond black homosexual. quick, be blackface, dumb and feminine!

20:44:51 <nescience> if you think about it though, stereotyping is a pretty critical function of the human brain

20:45:09 <ehird> yes

20:45:09 <nescience> imagine if you tried to be politically correct and assume that no ALL bears will maul you if you punch them in the face

20:45:10 <nescience> :P

20:45:10 <GregorR-L> More accurately, categorization is critical, stereotyping is the unfortunate result of categorization.

20:45:21 <ehird> i'm pretty sure political correctness only applies to humans

20:45:27 <GregorR-L> ehird: Not true.

20:45:33 <ehird> o rly

20:45:52 <GregorR-L> Be kind to animal rights activists, they're people too! (And therefore other animals are people by proxy)

20:46:24 <ehird> GregorR-L: It was fine until the parenthical, which is bullshit.

20:46:32 <GregorR-L> :P

20:48:06 <ehird> ais523: nescience: Hokey dokey, interpreter loop time.

20:48:37 <ehird> warrior_id_t run_match(ins_t *a, ins_t *b, polarity_t polarity, int tape_length). Maybe I need 7 more parameters.

20:49:04 <ehird> ais523: (a,b)=(b,a) matchup in your interp, right?

20:49:26 <ais523> ehird: yes

20:49:31 <ehird> right.

20:49:34 <ais523> and a program against itself always draws

20:49:59 <ehird> ais523: draws have no effect on anything, right?

20:50:08 <ehird> apart from draw count...

20:50:13 <ais523> I don't know how that scoring system works

20:50:16 <ehird> ais523: do you special-case that, btw? it seems like it may be quicker just to run it against itself

20:50:17 <ais523> I wrote the interp, not the scorer

20:50:30 <ais523> you'll need to ask GregorR about tournament infrastructure

20:50:58 <ehird> ↑

20:51:43 <ehird> ais523: pingeriffic

20:52:14 <ais523> ehird: as I said, I don't know

20:52:19 -!- tombom_ has joined.

20:52:21 <ehird> 20:50 ehird: ais523: do you special-case that, btw? it seems like it may be quicker just to run it against itself

20:52:26 <ehird> ais523: that's part of your interp is it not?

20:52:28 <ehird> or?

20:52:38 <ais523> I don't check for both programs being identical

20:52:41 <ehird> ah

20:52:42 <ehird> OK

20:52:44 <ais523> I thought you meant, checking for the same filename

20:52:47 -!- MizardX has joined.

20:52:54 <ehird> I don't think GregorR's tournament driver pits programs against themselves, since they get spaces

20:52:58 <ehird> instead of 0s (= draw)

20:53:29 <GregorR-L> Yeah

20:54:16 <GregorR-L> http://codu.org/eso/fyb/SCORES <-- score system

20:58:11 -!- tombom has quit (Read error: 60 (Operation timed out)).

20:58:12 -!- tombom_ has changed nick to tombom.

20:59:08 <nescience> GregorR-L: well, if you categorized but didn't act on it, it'd be afwul useless, wouldn't it? :P

21:01:33 <GregorR-L> nescience: Categorizing is dividing people into groups, stereotyping is taking properties of some part of the group and blindly applying them to the entire group. Saying "All black people have dark skin" is categorization, since that's the definition of the category, saying "All black people steal cars" is stereotyping.

21:04:51 <ehird> Stereotyping is prescribing to a group a property that is not inherent to it.

21:05:03 <ehird> "All black people have dark skin" → having dark skin is inherent in being black

21:05:18 <ehird> "All people who steal cars steal vehicles" → again, inherent

21:05:23 <ehird> "All black people steal cars" → not

21:05:50 <GregorR-L> I believe that's what I just said.

21:06:08 <ehird> GregorR-L: "stereotyping is taking properties of some part of the group and blindly applying them to the entire group"

21:06:11 <ehird> not the same definition

21:06:17 <ehird> mine is more rigorous and precise

21:06:58 <GregorR-L> I guess stereotyping can be based on properties that apply to nobody, like "All black people have antennae" or "All Jewish people came from the Mother Ship"

21:07:12 <ehird> :-D

21:07:30 <ehird> GregorR-L: "All Jewish people control the banks and are part of the New World Order" would be more of a real-world example

21:07:52 <GregorR-L> The first part is an example of my definition :P

21:08:48 <ehird> Yes.

21:08:50 <ehird> So's mine

21:08:57 <ehird> [[Fabian Escalante, who was long tasked with protecting the life of Castro, estimated the number of assassination schemes or attempts by the CIA to be 638. Some such attempts allegedly included an exploding cigar, a fungal-infected scuba-diving suit, and a mafia-style shooting.]]

21:09:45 <nescience> stereotypes that are nonsensical, unless they are a joke i guess, are not going to arise

21:10:20 <nescience> it's more like applying an observed link to the whole

21:10:30 <nescience> but it's considered "rude" if the observed link is negative :P

21:10:41 <ehird> nescience: feel free to observe a Jew new world ordering

21:10:46 <ehird> i'll wait here

21:11:28 <nescience> lol.

21:11:39 <nescience> i have observed no links between jews and conspiracy theories, sadly :P

21:11:53 <nescience> you're not likely to catch hell if you say something like "damn, latinas are sexy!"

21:11:56 <nescience> but it's equally a stereotype

21:11:57 * nescience shrugs

21:12:16 <ehird> ais523: how many nested loops does defend5 have again?

21:12:38 <ais523> I think it's a bit over 2000

21:12:43 <nescience> "as a female member of latin descent, i am offended by your assertion that i must be sexy! take that back right now!" :>

21:14:34 <ais523> sometimes I fly around in a spaceship...

21:14:36 <nescience> anyway uhh, back to brainfuck? :P

21:14:43 <ehird> ais523: :>

21:14:53 <ehird> ROCKET OR SMILEY YOU THE PUBLIC DECIDE

21:17:07 <ehird> aaaaaaaargh

21:17:19 <ehird> my c function needs to return a tuple, now i have to pass a pointer

21:17:20 <ehird> phooey :)

21:19:49 -!- M0ny has quit ("Read error: 182 (Connection reset by beer)").

21:22:07 <ehird> ais523: why are syntactically invalid programs admitted, btw

21:22:07 <ehird> ?

21:22:10 <ehird> I'd just drop them,

21:22:14 <ehird> s/,$//

21:22:31 <ais523> ehird: I exit with an error message, I think

21:22:37 <ais523> but the tournament infrastructure doesn't notice

21:22:43 <ehird> ais523: well, ] treats it all as draws

21:22:49 <ais523> yes

21:22:55 <ais523> it's interpreting the error as a draw

21:22:59 <ehird> ah

21:23:28 <ehird> you know you need to restructure when [[fprintf(stderr, "Unmatched ] in %s.\n", filename);]] ends up at column 91

21:29:39 <nescience> re: the scoring system

21:29:56 <nescience> you use the points for a program in calculating the points for a program

21:30:03 <nescience> how exactly does that work?

21:30:11 <ehird> nescience: points for score, no?

21:30:17 <ehird> or score for score

21:30:27 <nescience> The base score of any given program is the sum of:

21:30:29 <nescience> * The values for the programs which it defeated as defined above.

21:30:32 <nescience> * Half the values for the programs that it tied with as defined above.

21:30:46 <nescience> which means, the first time you submit the program, it gets a better score than afterwards

21:30:59 <ehird> nescience: it removes the program you submitted before running

21:31:00 <ehird> I'm pretty sure

21:31:01 <nescience> since afterwards, whatever programs it defeated are going to have less score

21:31:21 <nescience> but it doesn't recalculate scores for everything on the hill?

21:31:27 <nescience> or rather, i thought that's what the cache thing was about

21:31:33 <GregorR-L> It caches wins, not scores.

21:31:38 <GregorR-L> It always recalculates the scores.

21:31:40 <nescience> i see

21:31:46 <nescience> but then...

21:31:54 <nescience> how do you calculate how many points ANY warrior has

21:31:58 <nescience> even if you remove the new entrant

21:32:13 <nescience> each time you recalculate the score of a given pre-existing warrior, its score is still dependent..?

21:32:28 <GregorR-L> Run it against every program currently on the hill, using the cache instead when available.

21:32:34 <AnMaster> I have an issue

21:32:40 <ais523> AnMaster: what with?

21:32:43 <GregorR-L> The score will change with every run, as it is hill-dependent.

21:32:44 <nescience> sure, that gives you wins/losses

21:32:46 <AnMaster> a good image format

21:32:48 <AnMaster> for something

21:32:50 <AnMaster> to be specific

21:32:51 <ehird> AnMaster: png

21:32:55 <nescience> but points is based on the points of the other programs

21:33:04 <ais523> ehird: you don't know what sort of image it is

21:33:08 <ais523> arguably, iso might be better

21:33:09 <GregorR-L> Score is based on points of the other programs.

21:33:10 <nescience> i don't see how you can have them all in synch without some complicated math ala pagerank :P

21:33:11 <ehird> ais523: heh.

21:33:12 <AnMaster> scanned diagram. Must not be lossy.

21:33:14 <ehird> but seriously.

21:33:18 <AnMaster> In png the file is 70 MB

21:33:19 <ehird> AnMaster: absolutely PNG

21:33:23 <ehird> it's great for geometric shapes

21:33:24 <nescience> ahh

21:33:27 <ais523> there is a non-lossy format for scanned diagrams

21:33:28 <GregorR-L> Points is wins minus losses, score is based on that.

21:33:29 <ehird> AnMaster: 70MB? there's nothing you can do

21:33:29 <AnMaster> which is larger than the xcf at 65 MB

21:33:31 <AnMaster> ...

21:33:32 <ehird> it's gonna be gigantic anyway

21:33:33 <nescience> the text ony said "value"

21:33:36 <ais523> AnMaster: look at Wikimedia Commons for similar files

21:33:37 <ehird> ... 5MB makes a difference to you?

21:33:38 <ais523> and see what it uses

21:33:40 <nescience> i thought it was referring to teh value of those programs' scores

21:33:46 <ehird> AnMaster: just go w/ PNG

21:33:53 <GregorR-L> nescience: Nono, that's their value as in how much they're worth.

21:33:54 <AnMaster> ehird, that isn't as good for scans

21:33:54 <ehird> it's simple and near the best you'll prolly get

21:34:01 <ais523> AnMaster: how large is it after running it through pngcrush?

21:34:02 <AnMaster> ehird, also it is 1200 dpi, full A4

21:34:05 <nescience> based on the number of wins they have

21:34:08 <ehird> AnMaster: 5MB is insignificant at 65-70MB size.

21:34:11 <GregorR-L> nescience: Yeah

21:34:14 <ehird> just use png

21:34:17 <nescience> well at least that can synch up, i see

21:34:21 <GregorR-L> nescience: I didn't want to make a recursive algorithm :P

21:34:26 <AnMaster> ais523, that was *after* pngcrush, optipng and advpng

21:34:28 <nescience> seems like it's partly responsible for some of the noise on the hill too :P

21:34:31 <AnMaster> before it was well over 80 MB

21:34:48 <nescience> if you only beat two programs, but those programs beat everything else... should your score be that high i wonder?

21:34:54 <nescience> oh well, it's there for the exploitation!

21:35:03 <ehird> AnMaster: So, you can store 65MB, but not 20MB more?

21:35:08 <ehird> I seeeee.

21:35:14 <AnMaster> ehird, wrong

21:35:19 <AnMaster> I think 65 is too much too for this

21:35:22 <GregorR-L> nescience: I decree that it should be fairly high, but not as high as the program that beat all the others :P

21:35:31 <ehird> AnMaster: Tough

21:35:36 <ehird> 1200dpi + A4 size = big.

21:35:40 <AnMaster> since I need to upload it.

21:35:44 <AnMaster> ehird, yes I know

21:35:53 <ehird> AnMaster: er, how small is your upstream

21:36:01 <AnMaster> ehird, 1 mbit

21:36:06 <ehird> fast enough

21:36:14 <AnMaster> ehird, on the paper

21:36:17 <AnMaster> in practice?

21:36:24 <AnMaster> ~600 kbps

21:36:30 <ehird> ehm

21:36:34 <ehird> AnMaster: 600 kbps ~= 1mbit

21:36:37 <ehird> KB!=Kbit

21:36:45 <GregorR-L> Kilonibble

21:36:49 <AnMaster> that was kbit

21:36:49 <AnMaster> ...

21:36:51 <ehird> AnMaster: oh.

21:36:54 <AnMaster> 600 kbit/sec

21:36:57 <ehird> AnMaster: so, um

21:36:59 <ehird> http://www.google.com/search?hl=en&safe=off&client=safari&rls=en-us&q=70+megabytes+%2F+600+kilobits+per+second&btnG=Search&aq=f&oq=&aqi=

21:37:02 <ehird> AnMaster: 16 minutes?

21:37:10 <ehird> You're fussing over 16 minutes for uploading a PNG?

21:37:14 <AnMaster> ehird, something like that yeah.

21:37:17 <ehird> Nothing better to do I see.

21:37:19 <AnMaster> ehird, 5 png

21:37:21 <AnMaster> all like this

21:37:30 <AnMaster> so 16 * 5

21:37:39 <ehird> AnMaster: So, you have 80 minutes to spend on finding an obscure format that saves 10-20MB, but you can't spend those 80 minutes uploading.

21:37:43 <ehird> Bit ridiculous, that

21:37:52 <nescience> GregorR-L: i agree. i guess there's enough wins to go around

21:37:55 <AnMaster> ehird, wrong. I was just hoping someone here knew something good

21:37:57 <ais523> ehird: it depends on how many of these images AnMaster needs to upload

21:38:07 <AnMaster> ais523, as I said above. 5. At the moment

21:38:08 <ehird> ais523: he said 5

21:38:10 <GregorR-L> Instead, let's waste 90 minutes arguing about whether obscure formats are worthwhile :P

21:38:11 <AnMaster> might be more in the future

21:38:11 <ehird> = 80 minutes in total

21:38:12 <nescience> but with some tricksiness it might be possible to submit some warriors to act as stepping stones on each other

21:38:15 <AnMaster> but not today

21:38:15 <ehird> using 70MB PNGs

21:38:23 <nescience> seems to me like the hill score should be based on a 0 sum approach somehow

21:38:25 <ehird> @ 16 minutes / file

21:38:27 <ehird> which is just fine

21:38:30 <ais523> nescience: we were talking about doing that while the hill was upside-down

21:38:35 <ehird> nescience: gimme an algorithm and it goes into my impl :)

21:38:38 <ais523> in order to try to get good programs there

21:38:40 <GregorR-L> nescience: Mebbe, feel free to give me a new algo :P

21:40:09 <AnMaster> ehird, ~75 kbyte/sec up would be 600 kbit/sec as far as I can tell.

21:40:22 <ehird> AnMaster: you said you usually got 600 kbit/up

21:40:23 <ehird> per sec

21:40:26 <ehird> i calculated based on that

21:40:29 <ehird> = 16 minutes / file

21:40:34 <ehird> = 80 minutes total for 5 files

21:40:35 <nescience> i can't quite wrap my head around what's going on with the current score

21:40:36 <ehird> which isn't a problem

21:40:54 <nescience> as far as how things affect each other i mean

21:40:57 <nescience> so maybe it already is

21:41:00 <AnMaster> ehird, and it might be more in the future. Just 5 today. Probably 20 more next week

21:41:15 <ehird> AnMaster: 5 hours

21:41:17 <ehird> one off

21:41:20 <ehird> is this seriously a problem?

21:41:22 <AnMaster> 5.3333(...)

21:41:37 <AnMaster> ehird, probably not a one-off!

21:41:50 <ehird> AnMaster: so first it was 5. then 20. now it's 498357348957893457894353495?

21:41:55 <nescience> what's the problem with basing it on most wins, for example?

21:42:12 <nescience> i assume there's some behavior you want from giving more points for defeating "better" warriors

21:42:14 <ehird> nescience: because then you can target bad programs

21:42:19 <ehird> and lose against good ones

21:42:21 <ehird> and rise to the top

21:42:22 <ehird> which sucks

21:42:28 <ehird> but

21:42:31 <ehird> with the 11-length hill...

21:42:32 <ais523> except, there won't be many bad programs on the hill after a while

21:42:35 <nescience> so can everyone else(?)

21:42:40 <ais523> all the ones there are pretty good, I imagine

21:42:48 <ehird> exactly

21:42:49 <ais523> I'll resubmit attack1, and I bet it'll do terribly

21:42:52 <ais523> despite not being all that bad

21:43:02 <ais523> !bfjoust attack1 [>[-]+]

21:43:08 <EgoBot> Score for ais523_attack1: 13.5

21:43:08 <ehird> :-D

21:43:15 <ehird> not bad

21:43:18 <ehird> 531.50-2impomatic_mirage.bfjoust

21:43:19 <ehird> 113.50-8ais523_attack1.bfjoust

21:43:20 <nescience> being the "best" in this setup no longer means having the best record/defeating the most enemies

21:43:24 <ehird> lowest pts apart from it is

21:43:26 <ehird> 948.50-4nescience_creep.bfjoust

21:43:28 <ais523> yep, lost to everything but creep

21:43:34 <nescience> lol :>

21:43:40 <ehird> still, not that terrible

21:43:45 <nescience> and the setup here is such that i don't think it's really much different to target "better" programs than it is to target "worse" programs

21:43:46 <ais523> !bfjoust attack_experimental >>>>>>>>>[>[-]+]

21:43:46 <ehird> we've had 0.0 - 8.0

21:43:55 <nescience> since there's not really much you can do to target any particular program

21:43:57 <EgoBot> Score for ais523_attack_experimental: 15.5

21:43:57 <ehird> Attaxperimental

21:44:00 <nescience> except something like defend6, for example

21:44:02 <ais523> very slightly better...

21:44:11 <ehird> 1 | - 0 0 - - - - - - + | 15.5| -6| ais523_attack_experimental.bfjoust

21:44:17 <ehird> ais523: two draws and one win isn't too bad

21:44:31 <ais523> how did that draw with defend6, I wonder?

21:44:52 <ehird> !bfjoust revelation_fell_short (>)*9[[-]>+]

21:45:01 <nescience> the - loop

21:45:02 <EgoBot> Score for ehird_revelation_fell_short: 6.5

21:45:04 <nescience> wait, nevermind

21:45:08 <ehird> !bfjoust revelation_fell_short (>)*9[[+]>-]

21:45:08 <nescience> it only incs 128 times

21:45:10 <EgoBot> Score for ehird_revelation_fell_short: 6.5

21:45:19 <AnMaster> <ehird> AnMaster: so first it was 5. then 20. now it's 498357348957893457894353495? <-- stop being silly

21:45:20 <ehird> ais523: see, I can do worse!

21:45:36 <nescience> ehird: an idea regarding the polarity flip:

21:45:39 <AnMaster> just it is 5 today. And "the customer might want more next week ;)"

21:45:45 <nescience> what about taking either the best or the worst score for the attacker?

21:46:00 <ehird> nescience: I think averaging all the combinations is petter

21:46:08 <nescience> well, the average of a win and a loss is a tie

21:46:09 <ais523> ah, I see

21:46:16 <ais523> attack_experimental never goes into the [] loop

21:46:20 <ais523> nor does revelation_fell_short

21:46:24 <ais523> unless the tape length is exactly 10

21:46:36 <nescience> but if polarity comes into play, either you will take advantage of it or not take advantage of it

21:46:36 <ais523> !bfjoust attack_experimental >>>>>>>>>+[>[-]+]

21:46:38 <EgoBot> Score for ais523_attack_experimental: 15.5

21:46:42 <nescience> doing both and averaging is kina mediocre i guess

21:46:44 <nescience> i dunno, just a thought

21:46:58 <AnMaster> polarity?

21:47:03 <AnMaster> reverse it!

21:47:59 <ais523> and now it loses to defend6, as it ought to

21:47:59 <nescience> well that's what i'm getting at

21:48:10 <nescience> you can discourage taking advantage of polarity (and thus writing more generalized solutions)

21:48:15 <nescience> by taking the worst score of the two

21:48:15 <ehird> nescience: hmm

21:48:26 <nescience> or you can promote taking advantage of it by doing the opposite

21:51:29 -!- BeholdMyGlory has quit (anthony.freenode.net irc.freenode.net).

21:51:30 -!- tombom has quit (anthony.freenode.net irc.freenode.net).

21:51:30 -!- ais523 has quit (anthony.freenode.net irc.freenode.net).

21:51:30 -!- Sgeo has quit (anthony.freenode.net irc.freenode.net).

21:51:30 -!- kerlo has quit (anthony.freenode.net irc.freenode.net).

21:51:31 -!- ineiros has quit (anthony.freenode.net irc.freenode.net).

21:51:31 -!- Slereah has quit (anthony.freenode.net irc.freenode.net).

21:51:33 -!- Asztal has quit (anthony.freenode.net irc.freenode.net).

21:51:33 -!- ehird has quit (anthony.freenode.net irc.freenode.net).

21:51:33 -!- rodgort has quit (anthony.freenode.net irc.freenode.net).

21:51:33 -!- Gracenotes has quit (anthony.freenode.net irc.freenode.net).

21:51:33 -!- GregorR has quit (anthony.freenode.net irc.freenode.net).

21:51:34 -!- lifthrasiir has quit (anthony.freenode.net irc.freenode.net).

21:51:34 -!- FireFly has quit (anthony.freenode.net irc.freenode.net).

21:51:34 -!- fungebob has quit (anthony.freenode.net irc.freenode.net).

21:51:34 -!- fungot has quit (anthony.freenode.net irc.freenode.net).

21:51:34 -!- MizardX has quit (anthony.freenode.net irc.freenode.net).

21:51:34 -!- Deewiant has quit (anthony.freenode.net irc.freenode.net).

21:51:34 -!- fizzie has quit (anthony.freenode.net irc.freenode.net).

21:51:34 -!- jix has quit (anthony.freenode.net irc.freenode.net).

21:51:35 -!- nescience has quit (anthony.freenode.net irc.freenode.net).

21:51:35 -!- Ilari has quit (anthony.freenode.net irc.freenode.net).

21:51:35 -!- pikhq has quit (anthony.freenode.net irc.freenode.net).

21:51:35 -!- comex has quit (anthony.freenode.net irc.freenode.net).

21:51:35 -!- Leonidas has quit (anthony.freenode.net irc.freenode.net).

21:51:35 -!- sebbu2 has quit (anthony.freenode.net irc.freenode.net).

21:51:35 -!- AnMaster has quit (anthony.freenode.net irc.freenode.net).

21:51:36 -!- Corun has quit (anthony.freenode.net irc.freenode.net).

21:51:36 -!- Dewi has quit (anthony.freenode.net irc.freenode.net).

21:51:37 -!- olsner has quit (anthony.freenode.net irc.freenode.net).

21:51:37 -!- bsmntbombdood has quit (anthony.freenode.net irc.freenode.net).

21:51:38 -!- EgoBot has quit (anthony.freenode.net irc.freenode.net).

21:51:39 -!- inurinternet has quit (anthony.freenode.net irc.freenode.net).

21:51:39 -!- KingOfKarlsruhe has quit (anthony.freenode.net irc.freenode.net).

21:51:39 -!- ski__ has quit (anthony.freenode.net irc.freenode.net).

21:51:39 -!- dbc has quit (anthony.freenode.net irc.freenode.net).

21:51:40 -!- GregorR-L has quit (anthony.freenode.net irc.freenode.net).

21:51:40 -!- mtve has quit (anthony.freenode.net irc.freenode.net).

21:52:14 -!- impomatic has joined.

21:52:14 -!- MizardX has joined.

21:52:14 -!- tombom has joined.

21:52:14 -!- olsner has joined.

21:52:14 -!- Gracenotes has joined.

21:52:14 -!- ais523 has joined.

21:52:14 -!- sebbu2 has joined.

21:52:14 -!- KingOfKarlsruhe has joined.

21:52:14 -!- AnMaster has joined.

21:52:14 -!- jix has joined.

21:52:14 -!- FireFly has joined.

21:52:14 -!- fungebob has joined.

21:52:14 -!- BeholdMyGlory has joined.

21:52:14 -!- inurinternet has joined.

21:52:14 -!- Corun has joined.

21:52:14 -!- Sgeo has joined.

21:52:14 -!- GregorR-L has joined.

21:52:14 -!- GregorR has joined.

21:52:14 -!- nescience has joined.

21:52:14 -!- bsmntbombdood has joined.

21:52:14 -!- Slereah has joined.

21:52:14 -!- pikhq has joined.

21:52:14 -!- ehird has joined.

21:52:14 -!- Dewi has joined.

21:52:14 -!- comex has joined.

21:52:14 -!- lifthrasiir has joined.

21:52:14 -!- kerlo has joined.

21:52:14 -!- Deewiant has joined.

21:52:14 -!- Ilari has joined.

21:52:14 -!- ineiros has joined.

21:52:14 -!- fungot has joined.

21:52:14 -!- fizzie has joined.

21:52:14 -!- Leonidas has joined.

21:52:14 -!- Asztal has joined.

21:52:14 -!- rodgort has joined.

21:52:14 -!- EgoBot has joined.

21:52:14 -!- dbc has joined.

21:52:14 -!- mtve has joined.

21:52:14 -!- ski__ has joined.

21:52:44 <ais523> you can do a[bd]cd

21:52:44 <impomatic> Can I nest () inside {}?

21:52:44 <ehird> AnMaster: If polarity is sieve, + (dink) increments and - (donk) decrements for both warriors. If polarity is kettle, the same applies for one warrior, but the other warrior has the operations reversed - dink (+) decrements and donk (-) increments.

21:52:44 <ais523> impomatic: I think so

21:52:44 <nescience> AnMaster: what we're talking about with "polarity" ..

21:52:44 <ais523> it's meant to work, I'm not sure if it does though

21:52:44 <nescience> er, yeah.

21:52:44 <ais523> because I've never tested

21:52:45 <ehird> AnMaster: This stops people just copying a program and swapping + and - to get an advantage over [-] or [+], etc. but still makes you take into account the other program doing either and both.

21:52:45 <AnMaster> err

21:52:50 <AnMaster> ehird, are these terms from intercal?

21:52:52 <AnMaster> ;P

21:52:55 <ehird> AnMaster: No, I made them up.

21:52:57 <ais523> ehird: defend6 is robust against swapping + and -, by the way

21:52:59 <AnMaster> (dink and donk and so on)

21:52:59 <ehird> ais523: yep

21:53:00 <nescience> ais523: only if d is 0

21:53:16 <ais523> nescience: no, I mean d never finishes

21:53:18 <ehird> ais523: but my parody changes its +s or -s (I forget which) to the other, and beat it for a long time

21:53:19 <ais523> it's the rest of the program

21:53:19 <ehird> by about 10 score

21:53:21 <nescience> and c executes regardless, not just "else"

21:53:26 <nescience> ah

21:53:28 <ehird> 372.005ehird_defend6_a_parody_or_just_plain_ripoff_question_mark.bfjoust

21:53:28 <ehird> 263.004ais523_defend6.bfjoust

21:53:29 <ehird> still does

21:53:31 <AnMaster> aha

21:53:41 <ais523> ehird: interesting, that shouldn't make a difference

21:53:46 <ehird> ais523: with my new system, swapping + and - has no effect

21:53:53 <ais523> unless it interacts differently with one of impomatic's anti-defend6 programs

21:53:55 <ehird> ais523: and possibly it's just luck of the draw; it loses some other times

21:53:57 <nescience> ais523: it does, because it depends on the other programs on the hill

21:53:58 <ehird> also, yes

21:53:59 <ehird> I think

21:54:00 <ehird> right

21:54:15 <nescience> if you just have a simple [+] loop it will behave one way, and a [-] loop differently

21:54:26 <nescience> when i wrote creep it was 2nd for a while

21:54:27 <AnMaster> how does defend6 work?

21:54:29 <nescience> beat defend6 every time

21:54:43 <nescience> but that was because it loope dso as to wait 256 instructions when it hit your tripwire

21:54:45 <ais523> AnMaster: it tries to trap the opponent in a [+] or [-] loop over its flag

21:54:45 <ehird> AnMaster: it traps a [-] or a [+]

21:54:52 <ehird> AnMaster: it waits until it's 0, then increments/decrements it

21:54:55 <ehird> so that the loop runs once again

21:54:55 <nescience> ehird reversed the "polarity" and i couldn't do that both ways

21:54:56 <ehird> iirc

21:55:01 <AnMaster> ehird, interesting

21:55:01 <nescience> so it required other strategies to beat them both

21:55:08 <nescience> which i pulled off, but were less successful against the rest of the hill

21:55:08 <ais523> nescience: heh, that trick; it's what fool1 used, too

21:55:17 <ais523> on the other hand, that's an insanely bad strategy against an attack program

21:55:18 <ehird> AnMaster: so basically, if you try and just [-] or [+] out the opponents' flag, it infinite loops you then goes and rips off your flag

21:55:30 <ehird> ais523: what does fool do?

21:55:33 <ais523> that's why I think BF Joust is stone/paper/scissors in defence/fool/attack strategies

21:55:34 <nescience> thus my comment that the reason your defend is on top currently is because beating it doesn't give much score so nobody's doin it :P

21:55:35 <AnMaster> ehird, hm ok...

21:55:44 <ais523> ehird: walks very slowly along the tape, trying to trick defensive programs into suiciding

21:55:48 <ais523> by changing their flag very slowly

21:55:50 <ehird> ais523: heh

21:55:57 <ehird> ais523: defense1 just puts up fakes, right?

21:56:14 <ais523> ehird: no, defense1 is a specific anti-attack1 program

21:56:17 <ehird> ah

21:56:21 <ehird> so no fakers in the base?

21:56:31 <ais523> it lets its flag go to 0 for one cycle

21:56:34 <ais523> then increases it again

21:56:40 <ais523> and lets the opponent fall off the end

21:56:40 <nescience> it'd be a very distorted rock/paper/scissors

21:56:52 <ais523> defend5 works like that, but for a choice of opposing strategies

21:57:00 <nescience> programs like defend only work in a niche, right now you've got that niche :P

21:57:06 <ehird> Unmatched ] in butt.

21:57:08 <ehird> harumph

21:57:14 <ais523> but impomatic proved with shortsword that a program incapable of falling off the end is not hard to write

21:57:23 <impomatic> :-)

21:57:28 <ais523> so defend6 has to be a little more active in its defensive play

21:58:07 <ais523> it can still win defend1-style, but against shortsword and similar programs to it it locks them in place while grabbing the enemy flag a bit at a time

21:58:16 <AnMaster> ais523, btw... that -*- mode string in gcc-bf output

21:58:21 <AnMaster> how do you highlight bf

21:58:25 <ehird> esolangs.el

21:58:26 <ehird> his thingy

21:58:32 <ais523> yep, I have emacs modes for esolangs

21:58:36 <ais523> which I've pasted in the past

21:58:40 <AnMaster> ais523, I can't think of a useful way to highlight bf

21:58:43 <ehird> hmm I wonder why it thinks I have an unmatched butt

21:58:46 <ais523> AnMaster: you can highlight comments

21:58:51 <ais523> and stray BF chars inside comments

21:58:52 <ais523> also, constants

21:58:57 <ais523> like [-]+++++++

21:59:07 <ais523> and I colour <> differently to +- differently to [] differently to ,.

21:59:11 <ais523> to make the program a bit faster to read

21:59:14 <AnMaster> ais523 what about [-]>++<++++++++ ?

21:59:27 <ais523> AnMaster: [-] is a constant 0

21:59:39 <ais523> the +++++++ at the end is highlighted as addition, though

21:59:46 <ais523> it's a syntax highlighter, not an optimising interpreter

21:59:49 <AnMaster> fair enough

21:59:56 <AnMaster> ais523, where can I find this thing

22:00:02 <AnMaster> and does it highlight b98 too?

22:00:04 <ais523> AnMaster: pastebin in logs

22:00:06 <ais523> and no, it doesn't

22:00:13 <ais523> Befunge is a real pain to syntax-highlight

22:00:17 <AnMaster> ais523, which languages then apart from bf

22:00:30 <ais523> Thutu, and Unlambda

22:00:56 <AnMaster> ais523, you could highlight it mostly based on which character it is. You could handle string mode easily enough for the cardinal directions

22:01:00 <ais523> it also compiles Relambda to Unlambda, a bit buggily

22:01:16 <ais523> AnMaster: can you tell whether an individual Befunge command is part of a string or not?

22:01:18 <ais523> it might be both

22:01:19 <ehird> hmm it's parsing really weird

22:01:26 <AnMaster> ais523, indeed it might

22:01:43 <ehird> ais523: Thue too

22:01:45 <AnMaster> ais523, and you could partially by tracing program and using that info?

22:01:46 <ehird> no?

22:01:54 <ais523> ehird: stub code for that, but IIRC I didn't finish it

22:01:55 <ehird> AnMaster: it can be used as both, always

22:01:56 <ehird> so...

22:02:02 <ehird> ais523: i've used it, I'm sure

22:02:04 <AnMaster> ehird, yes of course

22:02:05 <ais523> AnMaster: I'm beginning to worry that you don't understand the concept of syntax highlighting

22:02:21 <AnMaster> ais523, it wouldn't be CLASSICAL syntax highlighting

22:02:22 <ais523> syntax highlighting != flymake

22:02:33 <AnMaster> ais523, "flymake"?

22:02:35 <ehird> ...

22:02:37 <ehird> how can you use emacs

22:02:39 <ehird> and not know what flymake is?

22:02:49 <ais523> ehird: admittedly, I don't /use/ flymake, but I know what it is

22:03:14 <AnMaster> "flymake not found in emacs info pages"?

22:03:23 <AnMaster> or rather "no flymake in index"

22:03:36 <AnMaster> Info-index: No `flymake' in index <-- there. See it ehird?

22:03:49 <ehird> ..

22:04:03 <ehird> This is an excellent time to brb, as my stupidity-thermometer was about to blow.

22:04:03 <ehird> →

22:04:04 <nescience> ehird: defend is a good example of why giving the *better* score might be advantageous

22:04:10 <nescience> (specifically, the difficulty of overcoming the tripwire strategy and still being viable in other contexts)

22:04:32 <nescience> not really too solidly sure on that one though

22:04:45 <AnMaster> I fail to see what ehird meant with that

22:05:01 <AnMaster> Anyway if emacs docs doesn't list it. it probably isn't there in my emacs version...

22:05:11 <AnMaster> maybe it is gnu emacs specific?

22:05:19 * AnMaster is currently using µemacs

22:05:27 <AnMaster> ais523, so tell me what flymake is

22:05:48 <ais523> AnMaster: it repeatedly runs make in the background

22:05:52 <ais523> so you get error messages on the fly

22:06:08 <AnMaster> interesting

22:07:34 <AnMaster> but not very useful. Since it would generate error messages a lot when editing. For example something like typing "if (foo) bar();" (without quotes!) isn't valid at all until completely typed in C at least.

22:07:46 <AnMaster> is that one make for each key-press?

22:07:52 <AnMaster> it would be rather slow if so

22:08:01 <ais523> I think these problems have been thought about

22:08:03 <ais523> but I don't use it

22:08:11 <AnMaster> I wouldn't use it either.

22:10:48 <AnMaster> ais523, the wiki page mentions that "Note that the commands are specified slightly more precisely than in standard Brainfuck; in particular, the timing surrounding [ and ] is relevant in BF Joust." but doesn't actually describe this timing...

22:11:11 <ais523> AnMaster: yes it does

22:11:27 <ais523> they both take one tick, and use the value at the start of the cycle, and jump to the command after the matching pair

22:11:45 <AnMaster> hm...

22:12:16 <AnMaster> why this interest in joust btw...

22:12:26 <AnMaster> also what does the word "joust" mean

22:12:31 <AnMaster> if anything

22:13:08 <ais523> AnMaster: it's a sport that hasn't been seriously played for several thousand years

22:13:23 <ais523> it involves two people on horseback riding at each other with lances

22:13:26 <AnMaster> ah

22:13:29 <nescience> ehird: did you see my comment about timing in the wiki talk page?

22:13:29 <ais523> and trying to hit each other's shields

22:13:30 <AnMaster> turnering in Swedish

22:13:36 <nescience> what do you think about that for your interpreter?

22:14:29 <AnMaster> ais523, several thousands isn't right. More like several hundred.

22:17:05 <ais523> ah, yes

22:17:09 <Deewiant> Hell, jousting only began in the second millennium CE :-P

22:18:32 <ais523> ehird: have you seen the trailer for Enigma, btw?

22:18:36 <ais523> it's so bad it's hilarious

22:18:59 <AnMaster> why does a certain level of jpeg compression make an image look (badly) photoshopped? Hm... I mean photoshopped as in "made by combining two images"

22:19:29 <AnMaster> like this one: http://en.wikipedia.org/wiki/File:Joust1c.jpeg

22:20:11 -!- cowb0y has joined.

22:20:26 <AnMaster> http://retrocode.blogspot.com/2009/05/bf-joust-king-of-hill.html <-- was it someone in here who wrote that?

22:21:07 -!- cowb0y has left (?).

22:21:35 * impomatic owns up

22:21:42 <AnMaster> ah...

22:22:06 <AnMaster> that explains why the blog seems to focused on war programs...

22:22:23 <impomatic> :-)

22:22:33 * AnMaster wonders if you could make a successful pacifist program in joust

22:22:40 <ais523> "pacifist"?

22:22:50 <AnMaster> ais523, misspelled?

22:22:56 <ais523> no

22:23:01 <ais523> I just don't know what it would mean in this context

22:23:07 <AnMaster> ais523, nor do I!

22:23:11 <Deewiant> Makes the other program kill itself?

22:23:13 <AnMaster> but it sounds interesting.

22:23:19 <AnMaster> Deewiant, maybe

22:23:22 <ais523> Deewiant: like defence1?

22:23:37 <Deewiant> Possiblyy what's defence1

22:23:38 <AnMaster> demonstrations against war should be involved

22:23:40 <Deewiant> s/yy/y;/

22:24:12 <AnMaster> Corewars - UN Edition

22:24:14 <AnMaster> :D

22:24:57 -!- sebbu has joined.

22:25:23 -!- BeholdMyGlory has quit (Remote closed the connection).

22:25:39 -!- jix has quit ("leaving").

22:25:52 <ais523> Deewiant: it defends its flag, trying to get the opponent to fall off the end

22:26:20 <Deewiant> Sounds as close to pacifist as you can get

22:27:55 <Deewiant> Is there some kind of time limit?

22:28:40 <ais523> yes

22:28:45 <ais523> and after that, it's a draw

22:29:19 <Deewiant> Okay, so then you could make even more of a pacifist

22:30:47 <Deewiant> !bfjoust farmer1 [>+*128>+*128<[-]>[-]<<]

22:30:49 <EgoBot> Score for Deewiant_farmer1: 0.0

22:30:50 <Deewiant> Or something

22:31:18 <Deewiant> Hmm, did I mess that up, seems like it should tie against the defence-types

22:31:31 <Deewiant> Or do they advance steadily as well

22:32:06 <ais523> Deewiant: defend6 doesn't

22:32:12 <ais523> advance, that is

22:32:16 <ais523> I mean, it starts >+[]

22:32:25 <ais523> ah, your syntax is wrong

22:32:28 <ais523> it's (+)*128

22:32:30 <ais523> not +*128

22:32:40 <Deewiant> What did that do, then

22:32:46 <Deewiant> Just comments?

22:32:50 <ais523> I'm not sure

22:32:53 <ais523> probably it broke the interp

22:32:53 <Deewiant> !bfjoust farmer1 [>(+)*128>(+)*128<[-]>[-]<<]

22:32:55 <EgoBot> Score for Deewiant_farmer1: 0.0

22:32:55 <ais523> which would explain the low score

22:32:55 <Deewiant> Heh

22:33:03 <Deewiant> Well, no difference

22:33:07 <ais523> Deewiant: off the left end

22:33:10 <ais523> after one iteration

22:33:11 <ais523> wait, no

22:33:14 <ais523> I miscounted the > and <

22:33:16 <Deewiant> Shouldn't

22:33:25 <AnMaster> um

22:33:30 <AnMaster> hm

22:33:32 <ais523> Deewiant: let me run it against defend6 locally

22:33:35 <ais523> to see what happens

22:33:40 <Deewiant> By all means

22:33:57 <AnMaster> ais523, you said it broke the interpreter? Huh.

22:34:03 <AnMaster> that doesn't make sense

22:34:24 <Deewiant> Muah, I won http://www.irregularwebcomic.net/cgi-bin/poll.pl

22:34:27 <AnMaster> not that the program seems to make sense either

22:35:01 <AnMaster> I never voted

22:35:03 <ais523> Deewiant: timeout and draw

22:35:05 <ais523> as expected

22:35:14 <ais523> oh, of course

22:35:17 <Deewiant> So the scoring is just such that it gets 0?

22:35:18 <ais523> bug in the channel reporter

22:35:20 <ais523> if you replace a program

22:35:24 <ais523> it reports its old score, not a new one

22:35:31 <Deewiant> !bfjoust farmer1 [>(+)*128>(+)*128<[-]>[-]<<]

22:35:33 <EgoBot> Score for Deewiant_farmer1: 0.0

22:35:38 <Deewiant> Always the original

22:35:38 <Deewiant> Meh

22:35:43 <AnMaster> what about calling it farmer1a then?

22:35:49 <Deewiant> !bfjoust farmer1-fixed [>(+)*128>(+)*128<[-]>[-]<<]

22:35:56 <ais523> and the report has gone suspiciously blank

22:36:01 <Deewiant> ...

22:36:13 <Deewiant> Hyphens not allowed in names? :-P

22:36:20 <Deewiant> !bfjoust farmer1_fixed [>(+)*128>(+)*128<[-]>[-]<<]

22:36:21 <AnMaster> Deewiant, probably not

22:36:28 <AnMaster> !help

22:36:28 <EgoBot> Supported commands: addinterp bf_txtgen bfjoust daemon daemons delinterp fyb help info kill mush userinterps 1l 2l adjust asm axo bch bct befunge befunge98 bf bf16 bf32 bf8 bfbignum boolfuck c chiqrsx9p choo cintercal clcintercal cxx dimensifuck echo echo_sh forth glass glypho google hello kipple lambda lazyk linguine malbolge ook pbrain perl qbf rail rhotor rot13 sadol sceql sh show slashes test trigger udage01 underload unlambda whirl yodawg

22:36:41 <Deewiant> !hello h

22:36:41 <ais523> http://codu.org/eso/bfjoust/report.txt is blank...

22:36:46 <ais523> I wonder what's happening now?

22:36:51 <ais523> !underload (test)S

22:36:52 <nescience> wait a bit and refresh

22:36:58 <ais523> I think EgoBot's mostly dead

22:36:58 <nescience> that's what it's been like when things were going

22:36:58 <Deewiant> !befunge "foo">:#,_@

22:37:03 <ais523> even though it's responding to !help

22:37:10 <nescience> i seem to hae submitted a broken script but i can't see why

22:37:10 <Deewiant> !daemons

22:37:11 <EgoBot> Running daemons: bottles butt

22:37:37 <EgoBot> Score for Deewiant_farmer1-fixed: 0.0

22:37:37 <ais523> !underload (test)S

22:37:38 <EgoBot> Score for Deewiant_farmer1_fixed: 0.0

22:37:38 <EgoBot> test

22:38:04 <ais523> Deewiant: it seems that the scoring method uses doesn't give you points if you don't get any wins

22:38:04 <Deewiant> Still 0, though

22:38:05 <Deewiant> Oh well

22:38:10 <ais523> you got many draws

22:38:15 <ais523> and a few losses

22:38:17 <ais523> but no win

22:38:18 <ais523> *wins

22:38:22 <nescience> it was all draws before

22:38:45 <nescience> wtf creep is on top now

22:38:50 <Deewiant> Hmmnh, that scoring system sucks :-P

22:39:00 <nescience> look at all those ties

22:39:01 <nescience> something broke

22:39:05 <nescience> oh right

22:39:06 <nescience> farmer

22:39:07 <Deewiant> 0 is a tie?

22:39:08 <nescience> too many ties

22:39:25 <nescience> defend has hit its downside

22:39:41 <Deewiant> Can those extraneous farmers be removed?

22:39:42 <ais523> nescience: well, I'll probably make a defend7 at some point

22:39:50 <ais523> Deewiant: they will be

22:39:53 <impomatic> It'd be better to run each pair of warriors at every possible tape length and base the score on that.

22:39:56 <ais523> next time a program is submitted

22:39:58 <Deewiant> ais523: Manually, by someone else? :-P

22:39:59 -!- sebbu2 has quit (Connection timed out).

22:40:04 <ais523> Deewiant: no, automatically

22:40:16 <ais523> !bfjoust attack1 [>[-]+]

22:40:18 <EgoBot> Score for ais523_attack1: 13.5

22:40:30 <ais523> see, gone

22:40:41 <Deewiant> Oh, they're not permanent by default?

22:40:51 <nescience> impomatic: ehird is doing that

22:41:01 <ais523> Deewiant: only the 10 best programs from each run are maintained

22:41:07 <Deewiant> Ah

22:41:10 <ais523> although your three farmers were placed into the same run, it seems

22:41:25 <GregorR-L> If it doesn't finish a run before you add a new one, the new run will have two added instead of one.

22:41:28 <nescience> ok, it is still tying everything

22:41:30 <nescience> what's the deal

22:41:40 <nescience> sorry for the repeated submissions, i kept missing the refresh to see the chart

22:41:47 <nescience> is there some error i am getting?

22:42:37 <ais523> nescience: you have to wait for the report to regenerate

22:42:43 <nescience> i did

22:42:45 <nescience> it wasn't on the report

22:42:47 <nescience> i submitted,

22:42:50 <nescience> now it is, but all ties

22:42:58 <ais523> nescience: all ties normally indicates a bug in the program

22:43:00 <ais523> or a typo

22:43:03 <nescience> strikes me as highly improbable, but i can't see a problem with the program

22:43:07 <ais523> as in, invalid syntax

22:43:09 <nescience> (>(-)*9)*2>(>-)*4(>[(>(+)*10[-])*20])*20

22:43:12 <nescience> do you see one?

22:43:53 <ais523> not an obvious one

22:43:57 <ais523> let me run it through my local interp

22:44:16 -!- tombom has quit ("Peace and Protection 4.22.2").

22:44:44 <ais523> bug in the interp, it doesn't like the syntax (>[(>(+)*10[-])*20])*20

22:44:50 <ais523> I think it doesn't like [] inside ()

22:45:00 <ais523> try using (>[(>(+)*10[-])*20]{})%20 instead

22:45:25 <nescience> what's %20 about

22:45:35 <ais523> nescience: it's the nesting abbreviation

22:45:38 <ais523> like *, but []-aware

22:45:55 <ais523> it means "20 times, replace the {} with the contents of these parens"

22:45:55 <nescience> mmk

22:45:59 <ais523> as in, it's recursive

22:46:01 <nescience> i see

22:46:08 <ais523> so (a{}b)%5 = aaaaabbbbb

22:46:47 <impomatic> Does this work? (a{}b{}c)%5 = aaaaabbbbbccccc

22:47:01 <Deewiant> What would (a{b}c{d}e)%5 be

22:47:17 <nescience> didn't seem to like it any better

22:47:21 <ais523> impomatic: no, that makes no sense

22:47:31 <ais523> you should write it (a{(b)*5}c)%5

22:47:46 <ais523> Deewiant: only one {} block inside each ()%

22:47:58 <Deewiant> ais523: Yeah, it was at impomatic

22:47:58 <nescience> i'll have to mess with it later

22:48:13 <nescience> i don't have the time to concentrate on it >:(

22:48:31 <nescience> or i guess i could just manually expand it

22:50:08 <AnMaster> %20?

22:50:28 <ais523> AnMaster: it's an improved, []-aware, version of runlength compression

22:50:33 <ais523> read the wiki article

22:50:40 <AnMaster> ah

22:50:42 <AnMaster> found it

22:51:05 <AnMaster> ais523, no way I will implement that in in-between btw

22:51:12 <ais523> err, you don't have to

22:51:16 <AnMaster> good

22:51:20 <ais523> optimising BF Joust programs makes no sense as it is

22:51:27 <ais523> because all tape elements are volatile

22:51:36 <ais523> you can't even guarantee memory is at 0 after [-]

22:51:45 <AnMaster> ais523, well I thought you might use it in normal bf

22:51:47 <nescience> ahah

22:51:48 <nescience> it worked

22:51:48 <AnMaster> that compression I mean

22:51:58 <ais523> (and some BF Joust programs specifically check for 0 after [-], as it happens)

22:52:18 <ais523> nescience: wow, that's a good program

22:52:30 <nescience> credit goes to impomatic though

22:52:30 <AnMaster> what program...

22:52:39 <ais523> AnMaster: nescience_shade

22:52:41 <nescience> i just combined his current best code with an idea he put in my head :P

22:52:47 <AnMaster> ais523, the source?

22:53:06 <AnMaster> I mean, this is fairly pointless and boring if I can't see the source.

22:53:06 <ais523> AnMaster: http://codu.org/eso/bfjoust/in_egobot/nescience_shade.bfjoust

22:53:14 <AnMaster> ah

22:53:18 <AnMaster> wow that is large

22:53:31 <nescience> see above

22:53:39 <nescience> i manually expanded it because the interpreter failed on the condensed code

22:53:40 <ais523> nescience: I don't get how that beats defend6

22:53:42 * ais523 runs locally

22:53:55 <nescience> it skips your tripwire

22:54:08 <nescience> and, usefully, inverse defend6's too

22:54:15 -!- nooga has joined.

22:54:22 <nescience> it'll run right off the end for any program that doesn't have decoys though

22:54:44 <nescience> but hey, can't have it all

22:55:32 <ais523> you're right, the tripwire never changes

22:56:05 <ais523> that's brilliant, assuming that the opponent has decoys, and skipping them

22:56:11 <ais523> clearly what defend6 needs is... a decoy decoy!

22:56:27 -!- oerjan has joined.

22:57:01 <AnMaster> hey, some hats are missing on http://choosemyhat.com/index.php

22:57:18 <AnMaster> (compared to a few months ago at least)

22:57:20 <AnMaster> hi oerjan

22:57:32 * oerjan gets spam from the Google Kingdom of Thailand, and thinks google branding may be going a bit overboard

22:57:36 <oerjan> hi AnMaster

22:57:37 <nescience> then i'll skip two!

22:57:37 <nescience> :P

22:57:50 <GregorR-L> People don't actually read choosemyhat.com

22:58:25 <AnMaster> GregorR-L, didn't notice the notice at the top

22:58:33 <ais523> oerjan: Google branded spam?

22:58:46 <ais523> !bfjoust defend7 http://pastebin.ca/raw/1436788

22:58:56 <EgoBot> Score for ais523_defend7: 68.0

22:58:59 <ais523> not bad

22:59:01 <AnMaster> GregorR-L, I was planning to vote for http://codu.org/hats/Tricorn-med.jpg

22:59:49 <oerjan> GregorR-L: the text at the top may be too long, everyone knows AnMaster cannot read more than three lines

23:00:16 <ais523> and straight to the top of the table

23:00:19 <AnMaster> oerjan, I'm trying to do like haskell for everything

23:00:32 <ais523> only program that beats it is impomatic_creep

23:00:50 <oerjan> ais523: the spam text started with the line "Google Kingdom of Thailand"

23:01:17 <AnMaster> so no one is going to ask what I meant with that...

23:01:28 <AnMaster> it seems

23:01:38 <ais523> oerjan: yes, I guessed

23:02:08 <oerjan> AnMaster: BWAHAHAHA

23:02:16 <AnMaster> oerjan, huh?

23:02:31 <oerjan> AnMaster: we wickedly refuse to ask

23:02:35 <AnMaster> :/

23:02:38 <AnMaster> VERY WELL!

23:02:44 <AnMaster> I shall then tell you anyway!

23:02:50 <oerjan> AAAAAAAAAAAAAAAAA

23:02:56 <AnMaster> Lazy evaluation of everything!

23:03:03 <nooga> OMF

23:03:04 <AnMaster> that is the key to getting ehird irritated.

23:03:12 <oerjan> nooga: HUM?

23:03:12 <AnMaster> lazy read scrollback

23:03:14 <AnMaster> and so on

23:03:43 <AnMaster> of course it is, *verbose* lazy evaulation

23:03:51 <oerjan> we notice

23:03:55 <ehird> 22:05 AnMaster: maybe it is gnu emacs specific?

23:03:55 <ehird> 22:05 AnMaster is currently using µemacs

23:03:56 <ehird> you think you're so clever, don't you...

23:04:05 <AnMaster> ehird, what

23:04:26 <AnMaster> ehird, checked in gnu emacs too and couldn't find it

23:05:05 <ehird> 22:13 nescience: ehird: did you see my comment about timing in the wiki talk page?

23:05:06 <ehird> yes

23:07:46 -!- Patashu has joined.

23:09:23 <ehird> 14:53:06 <AnMaster> I mean, this is fairly pointless and boring if I can't see the source.

23:09:26 <ehird> original bf joust worked sourceless

23:09:28 <ehird> which was fine

23:09:47 <AnMaster> ehird, you are basing that comment on false premises.

23:09:52 <AnMaster> You assume I want to "play the game"

23:09:53 <AnMaster> I don't

23:10:02 <ehird> i don't give a fuck what you want to do, AnMaster

23:10:04 <AnMaster> I'm interested in reading the source and seeing how it works though

23:10:06 <ehird> never have, never will

23:10:35 <ehird> but you keep seeming to believe I do...

23:10:39 <AnMaster> ehird, my comment is still true. Since I said was referring to myself.

23:10:49 <ehird> that is not what you said.

23:10:49 <AnMaster> I wasn't saying it was pointless for other people

23:10:51 <AnMaster> only for me

23:11:02 <ais523> !bfjoust defend8 http://pastebin.ca/raw/1436819

23:11:14 <ais523> that one should beat defence programs /and/ most attack programs

23:11:42 <ais523> but it takes ages to run

23:11:47 <AnMaster> ais523, any chance of small and elegant programs ever being best?

23:11:54 <Patashu> haha

23:11:54 <nescience> this is brainfuck

23:11:56 <Patashu> doesn't look like it does it

23:11:58 <nescience> unlikely

23:12:02 <Patashu> rushpolarity...

23:12:05 <AnMaster> nescience, yeah :/

23:12:14 <nescience> ais523: :P

23:12:16 <ais523> AnMaster: programs can be big and still elegant

23:12:21 <ehird> !bfjoust defend8mwahahaha http://pastie.org/492056.txt?key=srkdkdwiqowwbzvvyoow

23:12:24 <Patashu> well actually what we need

23:12:27 <nescience> you can add as many decoys as you want, i can still take you out every time! :>

23:12:29 <nescience> laf

23:12:29 <Patashu> is a preprocessor command that can take a variable

23:12:36 <nescience> ehird: did you just reverse his +s and -s again?

23:12:36 <AnMaster> ais523, sure. But I didn't say that.

23:12:39 <Patashu> and copies it x times, increasing the value y by 1 each time

23:12:40 <ehird> nescience: maybe

23:12:48 <Patashu> (copies a section of code)

23:12:48 <nescience> laf

23:12:53 <nescience> now that there's 4 copies of defend on there

23:12:56 <ais523> ehird: a +/- flipped version?

23:12:59 <nescience> writing a straight up defend-killer is feasible

23:13:00 <ehird> yep

23:13:11 <ehird> ais523: boy this is slow

23:13:12 <ais523> nescience: defend7 and defend8 both beat your decoy-skipper

23:13:26 <ais523> ehird: yes, the program isn't handled well by the interpreter

23:13:56 <nescience> ais523: of course, because i used a cheap trick to beat 6

23:14:05 <nescience> but that's far from the only way to beat it

23:14:05 <ais523> it was a clever trick, though

23:14:10 <ais523> and agreed

23:14:12 <AnMaster> what was that trick

23:14:14 <ais523> defend8 also beats defend6

23:14:15 <nescience> i've already beat it like 5 different ways

23:14:26 <nescience> and now that there's so many.. time to see some other ways

23:14:28 <ais523> AnMaster: deliberately not stepping on the tripwire

23:14:32 <nooga> i wonder how to allow multichar ids in next sadol

23:14:35 <nescience> if the program ever updates

23:14:40 <ais523> $ time perl bfjoust.pl defend8.bj defend6.bj > /dev/null

23:14:41 <AnMaster> ais523, how would it know where that tripwire was

23:14:41 <ais523> real0m40.113s

23:14:43 <ais523> user0m19.613s

23:14:44 <ais523> sys0m13.169s

23:14:54 <ais523> AnMaster: it can't be to the left of the flag

23:14:58 <ais523> so it must be to the right

23:15:10 <AnMaster> hm ok

23:15:14 <ais523> however, defend7 has a decoy decoy

23:15:25 <AnMaster> confusing

23:15:31 <ais523> so that nescience's program skips the decoy decoy, and falls into the real decoy

23:15:56 <AnMaster> ais523, and what about defend8

23:16:14 <AnMaster> and when will that report be generated... :/

23:16:21 <ais523> AnMaster: it's like defend7, but after 2000 cycles it stops waiting and zooms off to attack the opponent instead

23:16:22 <AnMaster> the interpreter seems horribly slow

23:16:25 <ais523> and it is

23:16:31 <ais523> that's why ehird's writing a faster one

23:16:40 <ehird> with polarities!

23:16:52 <ehird> dink donk march retreat consider reconsider rest eof

23:17:02 <AnMaster> ais523, why is the old report zapped before the new one is ready

23:17:02 * ehird twiddles with the parser

23:17:05 <AnMaster> it seems silly

23:17:48 <nescience> !bfjoust simpletest (>[[-]])*29

23:18:16 <Patashu> I think !bfjoust broke

23:18:18 <nescience> that one can only fall through if the instruction it is on is 0 twice in a row

23:18:24 <Patashu> no brainfuck program can take this long to write

23:18:25 <nescience> defend all you want

23:18:25 <nescience> :>

23:18:28 <Patashu> *run

23:18:37 <nescience> max cycles is 384000

23:18:38 <nescience> so ...

23:18:42 <ais523> Patashu: it's running, just slowly

23:18:47 <nescience> i dunno what the interpreter is written in but it could take a while

23:18:51 <ais523> the problem is that it's trying to do regexen on a very long string

23:19:01 <Patashu> is it unpacking all the *s?

23:19:02 <ais523> that interp is O(n) in the length of the program to run one cycle

23:19:03 <ais523> which is bad

23:19:09 <ais523> Patashu: no, the %s

23:19:13 <ais523> it has to unpack them when they run

23:19:17 <Patashu> shouldn't it do it all first

23:19:19 <Patashu> then run the full string?

23:19:41 <ais523> Patashu: to speed it up, it unpacks as it goes

23:19:49 <ais523> the problem is that regex matching on the unpacked strings is very slow

23:19:58 -!- impomatic has left (?).

23:20:26 <ais523> still, it should have finished by now

23:20:45 <nescience> lol

23:20:49 <ais523> even if each game takes 40 seconds, I'd expect it to have finished

23:20:50 <nescience> good job you broke it!

23:20:58 <ais523> it's only playing another programs, that's 400 seconds

23:21:05 <ais523> or a little under 7 minutes

23:21:36 <AnMaster> !befunge98 'A,@

23:21:39 <AnMaster> !help

23:21:39 <EgoBot> Supported commands: addinterp bf_txtgen bfjoust daemon daemons delinterp fyb help info kill mush userinterps 1l 2l adjust asm axo bch bct befunge befunge98 bf bf16 bf32 bf8 bfbignum boolfuck c chiqrsx9p choo cintercal clcintercal cxx dimensifuck echo echo_sh forth glass glypho google hello kipple lambda lazyk linguine malbolge ook pbrain perl qbf rail rhotor rot13 sadol sceql sh show slashes test trigger udage01 underload unlambda whirl yodawg

23:21:39 <Patashu> if it's going to run ten games in a row

23:21:45 <AnMaster> !daemons

23:21:45 <EgoBot> Running daemons: bottles butt

23:21:49 <Patashu> it would be much more efficient to unpack it all at the beginning

23:21:50 <ehird> !butt wut

23:21:55 <ehird> ais523: heh, my interp doesn't even handle the abbreviations

23:21:58 <ehird> that's for a frontend

23:22:00 <ais523> Patashu: much of the program often never needs to unpack

23:22:10 <ais523> ehird: my interp stores the program with the abbreviations in

23:22:10 <pikhq> !c int main(void){printf("HALDO!\n");return 0;}

23:22:11 <AnMaster> it is dead. Borked. Out of order. Not working.

23:22:12 <ais523> and unpacks on the fly

23:22:19 <ais523> AnMaster: the same happened earlier

23:22:19 <Patashu> well

23:22:23 <Patashu> clearly it's not working very well <.<

23:22:23 <ais523> and then all the results came at once

23:22:27 <ehird> ais523: yep

23:22:32 <ehird> when I submitted the 21 buggerers

23:22:32 <AnMaster> ais523, very odd that it throttles then

23:22:36 <AnMaster> I thought it was async

23:22:40 <AnMaster> that was part of the point of it

23:22:48 <nescience> i want some time to examine defend8

23:22:49 <nescience> :

23:22:54 <nescience> it doesn't just sit there like the others :P

23:23:00 <ehird> "the 21 buggerers" sounds like a biblical story

23:23:00 <ais523> not quite

23:23:04 <ais523> it starts with [ 2000 times

23:23:10 <nescience> lol

23:23:19 <ais523> and has a copy of defend6 after each ]

23:23:19 <ehird> ais523: how big is it, expanded?

23:23:23 <ais523> (the defend7 setup is before that)

23:23:24 <ehird> 7 billion megabytes?

23:23:24 <pikhq> !c printf("WTF, Egobot?\n");

23:23:33 <nescience> i see

23:23:36 <nescience> i didn't quite follow that to the end

23:23:40 <ais523> ehird: a bit less than 1 MB

23:23:41 <pikhq> GregorR-L: !c is borken.

23:23:46 <ehird> pikhq: NO.

23:23:47 <ehird> *NO.

23:23:48 <Patashu> lol

23:23:49 <ais523> pikhq: all EgoBot commands seem borken

23:23:49 <ehird> *No.

23:23:52 <ehird> EgoBot is borken

23:23:54 <ais523> whilst bfjoust is running

23:23:56 <AnMaster> !daemon

23:23:56 <ehird> It's hung up doing something

23:23:57 <EgoBot> Invalid invocation.

23:23:58 <ais523> apart from help, daemon, etc

23:23:59 <nescience> i was considering suggesting a "loop max N timse"

23:24:00 <nescience> times*

23:24:03 <AnMaster> !bf_txtgen this too?

23:24:03 <pikhq> GregorR-L: EgoBot is borken.

23:24:05 <nescience> obviously that would be better than this

23:24:07 <EgoBot> 97 +++++++++[>+>+++++++>+++++++++++++>++++<<<<-]>>>-.------------.+.++++++++++.>----.<+.-----..<.<+. [120]

23:24:09 <ais523> !underload (Test)S

23:24:09 <AnMaster> no

23:24:11 <AnMaster> not that one

23:24:16 <ais523> AnMaster: only the interps, it seems

23:24:16 <AnMaster> just the normal commands are

23:24:22 <GregorR-L> I know, I know, when the CPU is being raped by bfjoust nothing else can run.

23:24:25 <AnMaster> ais523, which is the main feature of it

23:24:29 <ehird> GregorR-L: nice foo

23:24:36 <AnMaster> GregorR-L, you need to throttle it then

23:24:36 <ehird> (nice(1))

23:24:39 <nescience> it's not very brainfucky but still

23:24:49 <AnMaster> GregorR-L, I thought this slox already did that...

23:25:36 <AnMaster> GregorR-L, I guess slox is broken

23:25:46 <ehird> I guess slox doesn't do what you thought.

23:25:50 <ehird> UNPOSSIBLE

23:26:23 <nescience> i gues i still don't quite get how {} works

23:26:23 <AnMaster> ehird, um. What would it do instead of throttling programs.

23:26:29 <nescience> it repeats the part between ( and { X times

23:26:33 <nescience> and the part between } and ) X times?

23:26:37 <ehird> AnMaster: Limit memory usage?

23:26:38 <EgoBot> Score for nescience_simpletest: 20.5

23:26:38 <EgoBot> Score for ais523_defend8: 45.1

23:26:38 <EgoBot> Score for ehird_defend8mwahahaha: 58.3

23:26:41 <ehird> YAY

23:26:43 <ehird> ais523: LOL

23:26:45 <ehird> it did badly

23:26:49 <ais523> defend8 only got 45.1?

23:26:52 <AnMaster> ehird, could you please check what on earth you are talking about

23:26:56 <AnMaster> ehird, you are so wrong.

23:26:57 <ehird> ais523: I beat it by reversing polarity!

23:27:14 <ais523> ah, it /lost/ to defend6 and defend7

23:27:17 <ehird> Great Leader AnMaster says slox does one thing. Lo, his superlative opinion is the objective fact!

23:27:19 <ais523> which is strange, as it beat them in my local test

23:27:26 <AnMaster> ehird, I checked duh.

23:27:48 <ehird> AnMaster: Slow down program != throttle program

23:27:50 <ehird> 's CPU usage

23:27:52 <AnMaster> ehird, GO FUCKING READ THE WEBSITE BEFORE BEING STUID.

23:27:57 <AnMaster> STUPID*

23:27:57 <ehird> STUID

23:27:59 <ehird> YOU'RE SO STUID

23:28:00 <AnMaster> http://codu.org/slox.php

23:28:07 <ehird> AAAAAAAAARGH ME AnMaster CRUSH PUNY HUMANLINGS

23:28:10 <AnMaster> ehird, I corrected the typo before you replied.

23:28:23 -!- ais523_ has joined.

23:28:29 -!- ais523 has quit (Nick collision from services.).

23:28:35 -!- ais523_ has changed nick to ais523.

23:28:40 <AnMaster> ehird, please see http://codu.org/slox.php, then come back again.

23:28:41 <ais523> sorry about that, my grandmother turned off the router by mistake

23:29:04 <ehird> AnMaster:

23:29:04 <ehird> 23:27 ehird: AnMaster: Slow down program != throttle program

23:29:05 <ehird> 23:27 ehird: 's CPU usage

23:29:10 <ehird> I did, thank you very much.

23:29:24 <AnMaster> ehird, so how would it fail in this case

23:29:50 <ehird> 23:27 ehird: AnMaster: Slow down program != throttle program

23:29:50 <ehird> 23:27 ehird: 's CPU usage

23:30:15 <AnMaster> as far as I can remember from what GregorR said, it is used for all programs that egobot runs. It gives equal limited CPU time to each such program

23:30:33 <AnMaster> the total cpu time for all programs is limited to a max

23:30:45 <nescience> i musta broke simpletest

23:30:48 <nescience> haha

23:30:48 <ais523> I just tested: defend8 definitely beats defend6

23:30:49 <nescience> creep still wins

23:30:51 <ais523> at my end, at least

23:30:58 <nescience> where's your defend now!

23:31:13 <AnMaster> so non-egobot processes always have a lot

23:31:24 <AnMaster> maybe it fails to use slox for joust

23:31:28 <AnMaster> since it is a special process

23:31:31 <AnMaster> or something like that

23:31:33 <ais523> and creep beats defend7 too...

23:31:36 <ais523> something weird is going on

23:31:42 <ais523> is that the same creep, or an improved version?

23:31:50 <Patashu> check the source code for it

23:31:52 <nescience> same creep

23:31:55 * ehird wonders wtf his parsing is doing

23:31:59 <nescience> been sitting there about since i submitted it yesterday

23:32:24 <ais523> it still has that 132-cycle wait

23:32:30 <ehird> it parses [>[-]+] as >-]+]

23:32:30 <nescience> it's not surprising

23:32:33 <ais523> it would seem rather vulnerable to fast attack programs...

23:32:35 <nescience> creep is a defend killer anyway

23:32:41 <ehird> and gives jump locations to non-jumps

23:32:43 <nescience> oh, it's the slow sucky one

23:32:47 <ais523> and yes, creep is a paper strategy

23:32:48 <nescience> that was made to counteract inverse defend

23:32:51 <ehird> aha

23:33:02 <Patashu> if it's not waiting as long as you need it to sprinkle nops

23:33:03 <ais523> defend programs are doing so well that anti-defence is making a comeback

23:33:03 <ehird> works now

23:33:23 <ais523> !bfjoust attack1 [>[-]+]

23:33:25 <EgoBot> Score for ais523_attack1: 6.5

23:33:52 <nescience> i'm not sure why the test doesn't beat the defends though

23:34:04 <nescience> [[-]] should loop if it's not 0 twice in a row, correct?

23:34:08 <Patashu> aw

23:34:12 <ais523> it beat creep but lost to everything else

23:34:12 <Patashu> rushpolarity finally got pushed off

23:34:15 <Patashu> survival of the fittest etc

23:34:20 <ais523> nescience: not necessarily

23:34:31 <ais523> oh, yes necessarily

23:34:34 <ais523> I was wondering about 0, 1, 0

23:34:38 <ais523> but yes, it needs two 0s in a row

23:34:44 <nescience> so why doesn't it beat defend?

23:34:54 -!- coppro has joined.

23:35:00 <ais523> so why doesn't what beat defend?

23:35:10 <ehird> alrighty, ais523

23:35:18 <ehird> I have all the parsing done for an efficient representation

23:35:23 <ehird> so I'm going to write run_match()

23:35:30 <ehird> ais523: two simple warriors, please?

23:35:38 <AnMaster> ehird, what is this representation

23:35:38 <ehird> [>[-]+] and...

23:35:47 <ehird> AnMaster: the very trivial:

23:35:48 <ehird> struct _ins_t {

23:35:49 <ehird> op_t op;

23:35:51 <ehird> ins_t *jump; /* NULL unless consider or reconsider */

23:35:53 <ehird> };

23:35:53 <ais523> ehird: [>+[]<(.)*258(+)*127]

23:36:00 <ehird> ais523: i said simple

23:36:00 <AnMaster> ehird, in an array?

23:36:01 <ehird> like really simple

23:36:03 <ehird> AnMaster: yes

23:36:17 <ais523> [>[-]-.-.-.-.-.-]

23:36:32 <nescience> why doesn't my test script beat defend

23:36:34 <nescience> i probably did it wrong

23:36:35 <nescience> 1sec

23:36:36 <ais523> !bfjoust fool2 [++[++[>+[(.)*5-]+>]-]-]

23:36:39 <AnMaster> ehird, and "consider or reconsider" are strange names for loops?

23:36:54 <ehird> OP_DINK, /* + */

23:36:54 <ehird> OP_DONK, /* - */

23:36:55 <ehird> OP_MARCH, /* > */

23:36:57 <ehird> OP_RETREAT, /* < */

23:36:58 <EgoBot> Score for ais523_fool2: 24.0

23:36:59 <ehird> OP_CONSIDER, /* [ */

23:37:00 <ais523> ehird: this is #esoteric, get used to it

23:37:01 <ehird> OP_RECONSIDER, /* ] */

23:37:03 <ehird> OP_REST, /* . */

23:37:05 <ehird> OP_EOF, /* (end of program) */

23:37:07 <ehird> AnMaster: you must realise that i _did_ name my two polarities sieve and kettle

23:37:09 <coppro> please don't do that

23:37:09 <ehird> ais523: defense1, then...

23:37:13 <nescience> ... (>[[-]])*29

23:37:14 <ehird> coppro: it was a few lines.

23:37:18 <nescience> why doesn't that beat defend, was the question

23:37:18 <AnMaster> ehird, true. You are going ICK style.

23:37:19 <coppro> 8 is a few?

23:37:23 <AnMaster> ick*

23:37:25 <nescience> it should work as far as i can see

23:37:25 <ehird> AnMaster: no, intercal styl

23:37:26 <ehird> e

23:37:30 <ehird> coppro: Yes.

23:37:49 <AnMaster> ehird, well. ick has some odd names internally too iirc. Not as many though.

23:38:19 <ehird> ais523: ?

23:38:22 <AnMaster> fungot, how are you?

23:38:22 <fungot> AnMaster: ohno ohno

23:38:24 <ais523> !bfjoust fool3 >>>>>>>>>[++[++[>+[(.)*5-]+>]-]-]

23:38:33 <ais523> ehird: ick does have a few, mostly filenames

23:38:38 <AnMaster> fungot, um... Are you Rincewind?

23:38:38 <fungot> AnMaster: youi usuck,boeings better airbus is a writer and writer for snl and crackin' up watchin' this video..when suddenly the local nbc station froze up.

23:38:49 <ehird> ais523: I just asked for defense1

23:38:55 <AnMaster> nop... not discworld

23:38:55 <ais523> ehird: I pasted it above

23:38:56 <ehird> ^style

23:38:57 <fungot> Available: agora alice c64 darwin discworld europarl ff7 fisher ic irc jargon lovecraft nethack pa speeches ss wp youtube*

23:39:00 <ais523> [>+[]<(.)*258(+)*127]

23:39:01 <AnMaster> ahaha

23:39:04 <ehird> ais523: I cannot find it

23:39:07 <ehird> err

23:39:09 <ehird> okay, that's defense1?

23:39:10 <ais523> ehird: see my last comment

23:39:12 <ehird> what about fool1

23:39:12 <ais523> yes, it is

23:39:13 <AnMaster> ^style discworld

23:39:14 <fungot> Selected style: discworld (a subset of Terry Pratchett's Discworld books)

23:39:18 <ehird> i'm looking for something very trivial :)

23:39:19 <AnMaster> fungot, ping

23:39:20 <fungot> AnMaster: ' i think you'll find,' he said. " so i should get something.' now lobsang straightened up and stared straight ahead of him, pushing through the bushes, and he'd sat up all night," said

23:39:21 <ais523> [>[-(.)*64]-]

23:39:22 <ais523> that's fool1

23:39:25 <ais523> and it is very trivial

23:39:34 <AnMaster> fungot, make sense!

23:39:34 <fungot> AnMaster: they did. look," said sergeant colon. " i don't think my calculations were that fnord"

23:39:42 <AnMaster> heh

23:40:02 <ehird> ais523: kay, [>[-................................................................]-]

23:40:11 <EgoBot> Score for ais523_fool3: 19.0

23:40:22 <AnMaster> fungot, .

23:40:24 <AnMaster> hm

23:40:32 <ehird> run_match(a, b, POLARITY_SIEVE, 20);

23:40:35 <AnMaster> mind resetting it's limit?

23:40:42 <ais523> !bfjoust fool4 (>(+)*6)*9[++[++[>+[(.)*5-]+>]-]-]

23:41:11 <EgoBot> Score for ais523_fool4: 41.5

23:42:35 <Patashu> !bfjoust lazy (+-)*150000(>)*9([-]>)*21

23:43:12 <ehird> ais523: is it a pain to synchronize the two programs?

23:43:14 <ehird> in your interp

23:43:29 <ais523> ehird: not really

23:43:40 <KingOfKarlsruhe> !bfjoust simple [>[-]]

23:43:49 <Patashu> hmm

23:43:49 <ehird> ais523: so how does [ work?

23:43:53 <Patashu> must be fighting defend8 ;)

23:43:57 <ehird> do you just indescriminately save the current cell before doing anything?

23:44:04 <ehird> *indiscriminately

23:44:08 <ais523> ehird: that's how I implemented it

23:44:10 <ais523> after all, it's only one int

23:44:16 <ehird> yar

23:44:42 <ehird> __asm__("nop");

23:45:39 <AnMaster> ehird, that seems wasteful. Wouldn't it be better to just directly skip to the other program

23:45:52 <AnMaster> also gcc will optimise away that asm

23:45:59 <AnMaster> you need a volatile asm to actually do it

23:46:33 <ehird> __asm__ about to erupt("nop");

23:46:37 -!- FireFly has quit ("Later").

23:46:42 <AnMaster> ehird, um?

23:46:46 <ehird> Very volatile.

23:46:53 <AnMaster> ...

23:46:54 <Patashu> hehe, bfjoust is stuck again

23:46:56 <Patashu> fight to the death with defend8

23:47:10 <nescience> !bfjoust simpletest (>[[-].])*29

23:47:11 <EgoBot> Score for nescience_simpletest: 20.5

23:47:26 <Patashu> huh?

23:47:26 <Patashu> hang on

23:47:30 <ehird> ais523: what happens if a program ends?

23:47:32 <ehird> that is

23:47:35 <ehird> + vs [>[-]+]

23:47:39 <Patashu> !bfjoust lazy (+-)*180000(>)*9([-]>)*21

23:47:42 <AnMaster> ehird, read on the wiki

23:47:49 <ehird> AnMaster: lazy :)

23:47:51 <AnMaster> I'm pretty sure it said

23:48:00 <nescience> problem with +- is

23:48:04 <AnMaster> ehird, hey I patented lazy evaluation over iIRC

23:48:06 <AnMaster> IRC*

23:48:12 <Patashu> bah

23:48:19 <Patashu> I can't screw around without my instant results

23:48:22 <nescience> eventually they'll get you to 0

23:48:24 <ehird> you'd have more of a hope at being funny with that joke if you knew what lazy evaluation meant

23:48:33 <nescience> and then execute the opposite of your code which is 0 twice

23:48:34 -!- coppro has quit ("The only thing I know is that I know nothing").

23:48:35 * GregorR-L reappears.

23:48:37 <Patashu> aah

23:48:39 <AnMaster> ehird, I know. And I'm making a parody on it

23:48:43 <Patashu> hmm

23:48:45 <GregorR-L> It is throttled, but bfjoust is only nice'd.

23:48:47 <nescience> like if you are 1 and you dec, you become 0, then if they dec and you add, it's 0 again

23:48:48 <ehird> AnMaster: that's like saying grapes are a parody of bread

23:48:49 <Patashu> oh, I remember how I was doing it with matador

23:48:49 <ais523> ehird: if a program ends, it nops forever

23:48:50 <AnMaster> ehird, I'm well aware it isn't exactly the same as this.

23:48:55 <Patashu> it was ++- for a while then --+ for a while

23:48:57 <ehird> ais523: oh.

23:49:03 -!- coppro has joined.

23:49:04 <nescience> same problem, less likely

23:49:12 <nescience> there's nothing wrong with going in only one direction

23:49:18 <nescience> switching direction is what causes a potential loss

23:49:19 <AnMaster> ehird, don't be daft. They are a parody of apples.

23:49:46 <AnMaster> apples are, admittedly, a parody of bred

23:49:48 <AnMaster> bread*

23:49:50 <ehird> argh, I need a type WARRIOR_A or WARRIOR_B.

23:50:08 <AnMaster> ehird, bool

23:50:14 <AnMaster> or something

23:50:14 <ehird> nothx

23:50:15 -!- KingOfKarlsruhe has quit (Remote closed the connection).

23:50:19 <ehird> typedef enum {

23:50:20 <ehird> WARRIOR_A,

23:50:20 <AnMaster> ehird, enum

23:50:21 <ehird> WARRIOR_B,

23:50:23 <AnMaster> yep

23:50:23 <ehird> } warrior_id_t;

23:50:30 <Patashu> !bfjoust lazy ((+)*1024(-))*256(>)*9([-]>)*21

23:50:43 <AnMaster> one has value 0, the other value 1

23:50:46 <AnMaster> iirc

23:50:51 <Patashu> it doesn't like my program :)

23:50:57 <Patashu> it instantly told nescience what HIS program scored

23:50:59 <Patashu> favouritism!

23:51:10 <ais523> Patashu: yours is probably longer than his

23:51:18 <Patashu> I thought it ran them sequentially

23:51:20 <Patashu> it's parallel?

23:51:20 <ais523> either in time to execute, or in physical length

23:51:28 <ais523> and it is sequential

23:51:35 <ais523> but it has to run against all the programs there

23:51:42 <ais523> some of which are slow against various other strategies

23:51:43 <AnMaster> GregorR, there still?

23:51:49 <nescience> i wish you guys would at least wait for the table to update before submitting revisions :\

23:52:00 <Patashu> so you wish I would

23:52:02 <AnMaster> GregorR, can you fix EgoBot so it doesn't stall every other interpreter if bfjoust runs

23:52:12 <AnMaster> GregorR, properly rate limit, like other interpreters

23:52:40 <AnMaster> I guess this is due to it being implemented as a special command

23:52:43 <ais523> "the reward for a job well done is two more jobs..."

23:53:12 <AnMaster> <nescience> i wish you guys would at least wait for the table to update before submitting revisions :\ <-- agreed

23:53:34 <EgoBot> Score for KingOfKarlsruhe_simple: 11.8

23:53:34 <EgoBot> Score for Patashu_lazy: 11.8

23:53:38 <AnMaster> or that someone fixed the bug with the table being cleared before the new results were read

23:53:40 <Patashu> oop here we go

23:53:40 <AnMaster> ready*

23:54:01 <AnMaster> Patashu, silly to resubmit it

23:54:10 <Patashu> lazy gets lots of ties :0

23:54:20 <Patashu> beats...fool4 and shade

23:54:57 <ais523> fool4 is moving up the rankings...

23:55:08 <ais523> and I don't know why 8 is doing so badly, I guess it's tape-length dependent

23:55:15 <ais523> 6 will beat it on a short tape, it'll beat 6 on a long tape

23:55:17 <nescience> it still doesn't beat defend

23:55:19 <nescience> i do not get this

23:55:45 <ais523> nescience: what is simpletest?

23:55:45 <AnMaster> .bfjoust is a very long extension...

23:55:50 <ais523> you haven't pasted the source in-channel

23:55:54 <ais523> AnMaster: ehird told be not to use .bj

23:56:01 <AnMaster> ais523, why

23:56:03 <Patashu> blowjob?

23:56:05 <Patashu> :)

23:56:09 <ehird> what Patashu said

23:56:12 <AnMaster> Patashu, you have a dirty mind

23:56:21 <ais523> ehird: my friends use it as an abbreviation for "bonjour"

23:56:23 <ehird> AnMaster: and LOL means Lots of Love.

23:56:23 <nescience> i did above

23:56:25 <ehird> ais523: hahaha

23:56:28 <ehird> "hi there! bj!"

23:56:29 <nescience> (>[[-]])*29

23:56:34 <AnMaster> ehird, it does?

23:56:42 <ehird> AnMaster: Yep. And BJ means BF Joust.

23:56:55 <nescience> i added a . in case it was some weird parser error

23:56:59 <AnMaster> ehird, "bj" doesn't mean anything specific to me

23:57:25 * ehird thinks of a way to run some code twice in C without a temp var

23:57:50 <AnMaster> ehird, repeat the statement twice? :P

23:57:58 <ehird> AnMaster: more than one

23:58:17 -!- EgoBot has quit (Remote closed the connection).

23:58:20 -!- EgoBot has joined.

23:58:30 <AnMaster> ehird, um. Like foo(); bar(); quux(); foo(); bar(); quux(); ?

23:58:34 <AnMaster> macro

23:58:54 <AnMaster> #define REPEAT_SHIT foo(); bar(); quux(); and then REPEAT_SHIT REPEAT_SHIT

23:58:54 <ehird> AnMaster: like switch(){gigantic}

23:59:00 <AnMaster> ah

23:59:00 <ais523> nescience: it loses to defend6 the same way defend6 beats anything else with [-] in it

23:59:04 <AnMaster> that could be messy in a macro

23:59:22 <AnMaster> ehird, inline function?

23:59:32 <ehird> meh :)

23:59:51 <AnMaster> ehird, not sure if it would affect speed anyway...

←2009-05-26 2009-05-27 2009-05-28→ ↑2009 ↑all