Better looping

Here's an easy one:

A fairly common construct is:

(({})<{({}[()]<...>)}{}>)

Where you want to loop n times but still keep the n. However this can be written as:

({<({}[()]<...>)>()}{})

to save 2 bytes.

Another fairly common paradigm is

([])({<{}>...<([])>}{})

Which will loop and accumulate the entire stack. Due to some fancy maths this is the same as:

(([]){[{}]...({})}{})

Better looping

Here's an easy one:

A fairly common construct is:

(({})<{({}[()]<...>)}{}>)

Where you want to loop n times but still keep the n. However this can be written as:

({<({}[()]<...>)>()}{})

to save 2 bytes.

Another fairly common paradigm is

([])({<{}>...<([])>}{})

Which will loop and accumulate the entire stack. Due to some fancy maths this is the same as:

(([]){[{}]...([])}{})

Better looping

Here's an easy one:

A fairly common is:

(({})<{({}[()]<...>)}{}>)

Where you want to loop n times but still keep the n. However this can be written as:

({<({}[()]<...>)>()}{})

to save 2 bytes.

Another fairly common paradigm is

([])({<{}>...<([])>}{})

Which will loop and accumulate the entire stack. Due to some fancy maths this is the same as:

(([]){[{}]...({})}{})

Better looping

Here's an easy one:

A fairly common construct is:

(({})<{({}[()]<...>)}{}>)

Where you want to loop n times but still keep the n. However this can be written as:

({<({}[()]<...>)>()}{})

to save 2 bytes.

Another fairly common paradigm is

([])({<{}>...<([])>}{})

Which will loop and accumulate the entire stack. Due to some fancy maths this is the same as:

(([]){[{}]...({})}{})

Better looping

Here's an easy one:

A fairly common is:

(({})<{({}[()]<...>)}{}>)

Where you want to loop n times but still keep the n. However this can be written as:

({<({}[()]<...>)>()}{})

to save 2 bytes.

Better looping

Here's an easy one:

A fairly common is:

(({})<{({}[()]<...>)}{}>)

Where you want to loop n times but still keep the n. However this can be written as:

({<({}[()]<...>)>()}{})

to save 2 bytes.

Another fairly common paradigm is

([])({<{}>...<([])>}{})

Which will loop and accumulate the entire stack. Due to some fancy maths this is the same as:

(([]){[{}]...({})}{})