I'm overdesigning it. It takes time, but I feel I would get lost in my own code if I didn't.

The previous challenges were doable in under an hour. This one feels like it takes a team of developers and six weeks.

The worst part is I have no idea how tricky the input is...I'm having to design it so that absolutely no assumptions are made, and that takes absolutely forever.

I've gathered quite a few assumptions while solving the first part... and it's still going to take me time.

and this is only day 20...will the next one be "design a neural net to identify someone with this face given your input, which is encoded with a custom compression algorithm, although you need to reverse engineer it because we forgot how it worked but you can tell when you got it right because it's jpeg encoded oh and by the way it's 6 million gigabytes so do some optimizing"

Considering doing it by hand, probably faster at this point

If it takes them four months to design 25 programming tasks, it should take us four months to solve them.

Okay, new approach: There are eight possible ways each tile can be flipped and rotated. I'll just check every possible one for every one of the tiles, make a list of all the valid ones, then keep checking all my assumptions are correct until the list is down to zero or one.

@RedwolfPrograms not really

@RedwolfPrograms want spoilers?

It doesn't matter, I know how to do it it's just a matter of implementing it properly

oh, so you already know dict is probs your best bet for part 1

That's what I used, yeah. I was top 100 for part 1.

:o

i mean depending on how you do it, you shouldn't need too many modifications to said dict to help with part 2

Half my problem is I hate variables that include the letter e in their name for some reason, and seeing edge all over the place just makes it a hard program to work with

@RedwolfPrograms "border" should make the problem half as bad

so you hate length too.

Length is a little bit better because it doesn't start with one, but forEach and entries are absolutely disgusting

...

forEach is just poor man's map

entries... i don't know why you'd use that

just use a for

0 es there

But for needs you to create a variable and let contains e.

I use var

let is even worse than those

Too bad you can't use const mut :P

Haskell has let ... in or where. Neither is good. You can work in the array monad as a workaround though; do{foo <- [bar]; quux foo}

I guess you could get around the lack of e's in Rust by using IIFEs. You can even destructure in function arguments.

No len() though, or the much slower iter().count()

I think y'all are the first people who haven't immediately questioned why I hate the letter e, lol

@RedwolfPrograms wrong. var isn't block scoped which hurts so much

@RedwolfPrograms do tell

surprisingly enough, Rust does let you do mutable function arguments.

ok the real question is why u hatin on yellow

Some shades of yellow are nice, but not e or let

is it possible to retrain that?

I don't think so.

CMC Given the input string aaaaaaaaaa, iterate over all strings with edit distance (aka Levenshtein distance) at most 3 in under a minute. The alphabet should be all printable ASCII characters. You don't need to print them out.

@Anush how would you verify it?

@Razetime Only by doing the same with distance at most 2 where we can check it.

@Razetime if you count how many there are that would help.

for distance 2 there are 1631129 distinct strings.

holy moly

@Razetime :) It may not be easy

but I trust the genius of ppcg (or whatever the current initialism is)

cgcc

thanks

@Anush no duplicates allowed?

@RedwolfPrograms What about other writing systems that don't have e?

@ASCII-only You are allowed duplicates

but if you have too many it will be very hard to do in under a minute

yeah 3.3k done right now xD

const printables = " !\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~";
function* leven(s,d=1){
  if (d===0) { yield s; return; }
  for (let i = 0; i < s.length; i++) yield* leven(s.slice(0, i) + s.slice(i + 1), d - 1);
  for (let i = 0; i < s.length; i++) {
    for (const printable of printables) {
      yield* leven(s.slice(0, i) + printable + s.slice(i), d - 1);
    }
  }
  for (let i = 0; i < s.length; i++) {
    for (const printable of printables) {

ono this is a bit big

> 3827640

@ASCII-only that's huge for d = 1! There are 2082 distinct strings

this is d = 2...

you can check if it's doing the right thing by changing const printables = " !\""; and for (const _ of leven('aaa',2)) console.log(_); or something

ah.. in that case you only have factor a of 2.x duplicates which isn't too bad

this isn't good... it returns 1910 for d = 1

that looks wrong

try with aa as the input string

or a. You should have exactly 300 without duplicates

oh

in the second for, changing < to <= helps but it's still only 286

or "" where you should have exactly 101 with d= 1:)

if you have 100 printables

and exactly 10101 with d=2 (assuming no duplicates)

you might have fewer printables (i.e. 94) but that's ok

@Anush there are 95 ascii printables so...

@ASCII-only that include delete I think

but I have no idea why python gives 100

:/

it seems to include 6 things after ~

that doesn't affect my challenge though :)

oh I see, it's different forms of whitespace

I didn't even know there was a vertical tab!

maybe I should make this a challenge

see the thing is most languages don't consider tabs/newlines "printable"

I agree. But vertical tab is even more obscure. I just googled it

vertical tab is a tab

same as how both carriage return and line feed are considered newlines (kinda)

Got you

Will this submission be legal? I doubt as it is based on args, but I've seen some submissions like it..

@RahulVerma args is an accepted method of input so...

@ASCII-only but note that the code is not re-usable. So, I doubt over it, but if it's legal acc. to the wiki, then I have no issues :)

@RahulVerma since it takes commandline input, it's a full program, not a function, yes? if that's the case, it's perfectly valid since programs do not have to be reused with the same state

@ASCII-only hm, okay i got it :)

@ASCII-only did you give up?