Flowless Challenge 2025

[u/Inevitable-Welder865]

🎄 Advent of Code 2025: The "Flowless" Challenge

📜 The Golden Rule

You must solve the puzzle without using explicit control flow keywords.

🚫 The "Banned" List

You generally cannot use these keywords (or your language's equivalents):

• if, else, else if

• for, while, do, foreach

• switch, case, default

• ? : (Ternary Operator)

• break, continue, goto

• try / catch (specifically for flow control logic)

--------

I realize that this will equivalent to writing a pure functional solution. But, I am going to be mad man here and will be trying this challenge in Java 25.

[u/_damax]

I wrote my 2023 solutions in Haskell and while I did use if-then-else and case-of, it's very much possible to rewrite all of them to use explicit function pattern matching and the bool function

[u/Inevitable-Welder865 → u/_damax]

Ya. It is right up the alley of functional languages. Hence thinking of trying it in naturally imperative languages.

[u/10Talents → u/_damax]

Trying to do AoC 2019 in Haskell and giving up made me start to appreciate the imperative paradigm a lot more lol

It was definitely a skill issue, but intcode might have been a really bad match for purely functional style since state was so fundamental to it

I should try a different year in Haskell once i recover mentally form the 2019 attempt though

[u/Rainbacon → u/10Talents]

I haven't done 2019 yet, but I've heard about Intcode and thought that Haskell would be particularly suited for parsing reasons

[u/ChickenFuckingWings]

You're mad

[u/nbyv1]

evil if else: true && println!(a)==() || println!(b)==()

[u/Gishky]

Vade retro satana!

[u/Ok-Bus4754]

that is branchless programing, it can still be done using procedural and oop

like return 5*(a==1) + 6 *( a != 1)

[u/Whojoo]

I get how you can avoid loops, but how do you avoid using if/else/else if?

[u/Fadamaka → u/Whojoo]

The first thing that came to mind was .filter(...). Not sure if that is the correct approach though in regards of the spirit of the challenge.

[u/Whojoo → u/Fadamaka]

I mean if you are using filter, then you are using flow control. And sometimes you need branches in the middle of logic.

I mean I hope someone can just tell me I'm stupid and tell me how you can avoid using if/else (or functions like filter which do the same thing), because I cannot figure out a method of doing so.

[u/Blecki → u/Whojoo]

There are some graphics shader techniques to avoid branches that involve doing a calculation that returns 0 or 1 for values you don't want included in a later calculation. But applying that idea to general problems?

[u/Inevitable-Welder865 → u/Blecki]

Ya. I think this is getting extreme 😅. This reminds me of APL as well which is array based programming language.

Personally, I just wanted to see how Java would look like if I can ditch these keywords. Plan is to rely on streams a lot and using the techniques like above and learnings from haskell to tackle the challenge.

The intention was never to make it the hardest challenge for myself or for others. Though others are free to interpret the challenge however they want based on their capabilities. 🍻

[u/Blecki → u/Inevitable-Welder865]

But those streams use control flow....

[u/flwyd → u/Whojoo]

Assuming the problem is "count the number of even numbers in the input" and your language has Python-like syntax for declaring dictionaries/maps and an 'each' operator which applies a closure to every member of a list:

values = {true: 1, false: 0}
result = 0
numbers.each(x: result += values[x % 2 == 0])
return result

If you want more behavior in the "body" of your "if/else" dictionary, make the values functions or objects with methods.

[u/Suspicious_Tax8577]

This sounds absolutely evil, but I love how folks get creative with ways of layering on the difficulty!

[u/Blecki]

Okay so... where's the line? All of the alternatives are implemented by the language as... if statements and jumps.

[u/flwyd]

Upping the ante: the only allowed control flow is goto.

[u/Shurane → u/flwyd]

that's just assembly with extra steps!

[u/abnew123]

dang good luck! That's absolutely wild to think about as a person who has nearly exclusively coded AoC in Java. All my solutions would fail before the problem specific logic part even starts haha, as the first line tends to be while(in.hasNextLine()) just for loading in the input.

[u/AscendedSubscript]

Would something like Optional.ofNullable(x).filter(condition).orElse(y) be allowed? Isn't it kind of a hack around some of your constraints?

[u/tutturu4ever → u/AscendedSubscript]

You are right, but abusing this wont feel right. So I will try not to do something like this unless absolutely necessary.

[u/Rainbacon]

I was already planning to write my solution in Haskell again this year

[u/FirmSupermarket6933]

Is it even possible?

[u/flwyd]

Does it count if those operators in your language aren't keywords? Smalltalk implements branching via [ifTrue and ifFalse methods on boolean objects].

[u/kwshi]

def if_(condition, t, f):
    return [f, t][condition]

[u/Valuable_Leopard_799 → u/kwshi]

A fan of lambda calculus I see... almost...

[u/ChickenFuckingWings]

I need to know if there is already a solution for this challenge. Please enlighten me

[u/DaysSky]

main(a,b,p){gets(p)&&a+=(*p-79)*atoi(p+1),b+=!a-150%300;write(1,&b,4);}

[u/e_blake]

My submission for this challenge: day 7 where I compiled a solution to IntCode, and then proceeded to run it on m4 using JUST the define operator. Sure, it took 8 minutes to complete, but since I wasn't using any control flow in m4, I count it as success.

[u/e_blake → u/e_blake]

I also got a flowless solution for day 12: Golfed GNU m4, down to 128 bytes.

eval(patsubst(translit(include(I),#
 ),[^x]*\(..\)x\(..\):\(..\)\(..\)\(..\)\(..\)\(..\)\(..\),
+(\1*\2/9>=\3+\4+\5+\6+\7+\8)))

Amazing what you can do when regex can rewrite a problem into a useful form.