# Codington Crescent [duplicate]

Let's just see how this goes

If you've ever listened to the radio program "I'm sorry, I haven't a clue", then you've probably heard of the game called "Mornington Crescent". For those who haven't, it's a game where players name random stations on the London Underground network. The first person to name "Mornington Crescent" wins the game.1

In the same sort of spirit as the classic radio game, I present to you Codington Crescent.

## The Challenge

The winner of this challenge is the first person to post a working program that prints the exact string Codington Crescent.

## The Rules

1. Each player has their own program that they will add/change characters. This is termed their running program.

In this way, the only aspect is the rules. Everyone uses their own running program. No one shares a program at all

1. Each answer (a turn) has to obey source restrictions defined by previous answers. These are called rules. Each varient lasts for 5 turns. Rules are in the style of either , or limiting of language names (but not both).
2. Running programs can change languages between turns.
3. Answerers (players) can either add or change (but not both) as many characters of their running program per turn as they like. Alternatively, they can choose to "pass", adding no new rules, and still counting as a turn. This may be the only choice if rules conflict with each other. The turn count is still incremented and is to be posted. Pro tip: You probably might want to mark it community wiki because it doesn't add much.
4. At the end of each turn, the player declares a new rule that will span the next 5 turns. Rules must be objective, and a TIO verification program is highly recommended. Also, rules have to be able to be applied to every language (e.g. Programs must not error using Python 3.4.2 isn't a valid rule).
5. Play continues until a running program prints the target string.

## Starting Rules

As to kick off the game, the first 5 turns must follow these rules:

1. Turns may not print Codington Crescent.
2. Running programs must be irreducible. (Clarification, not a rule change: irreducible in this case means that the program doesn't produce the output of the whole program if characters from the whole program are removed. Ie. There does not exist a program that has the default same output that can be constructed by removing characters from the original program.)
3. Maximum program length is 20 bytes.

## Example Rules

These are purely examples of what you could add as rules to the challenge. They do not apply unless someone decides to use them.

• Languages must have at least 3 characters in their name

• The first and last letter of the running program must be a space

• Running programs must have an even amount of bytes

• Languages must be in the practical category on TIO

• Running programs must not be more than 30 bytes

• You cannot answer twice in a row. Someone else needs to answer before you have another go.
• Languages need to be on Try It Online in order to be valid answers.

1 The original game of Mornington Crescent doesn't really have rules... It's more of an activity that looks like it's a complicated game.

Pro-tip: sort by oldest for a more cohesive flow of answers

# [Language], turn number [your turn]

<code>

## Rules

- Rule (n turns left)
- Rule (n turns left)
- Rule (n turns left)
$$$$

• Comments are not for extended discussion; this conversation has been moved to chat. – Jo King Sep 30 at 0:32

# R, 43 bytes, codepoint total 59^2, turn number 6

Previous submission (turn 4)

This turn: added 23 characters = 'Codington'+'Crescent'#H

+=cat;'Kodington'+'Crescent'#@'C"pr'+'nt'


Try it online!

Rules

• Programs may not print Codington Crescent.(expired)
• Running programs must be irreducible. (expired)
• Maximum program length is 20 bytes. (expired)
• Programs must have the substring C"pr (last turn)
• Programs may not contain brackets of any kind. (1 turn left)
• Minimum program length is 19 bytes (2 turns left)
• Programs may not contain any whitespace characters (3 turns left)
• The codepoint sum needs to be a perfect square that's greater than 1444. (4 turns left)
• Programs may only output 'Codington Crescent' if they are irreducible AND modifications (additions OR changes) of at most 8 characters from a previously-submitted answer (5 turns left)
• It was definitely a panic to find the 'missing' codepoints before someone else made a perfect square... – Dominic van Essen Aug 21 at 13:04
• In retrospect I should've made a codepoint max... – user96495 Aug 21 at 13:05
• That's right, but without a rule limiting winning entries to modifications of existing programs, even that would have been easily circumvented by someone entering with an all-new program that didn't carry any 'baggage' from previous versions... – Dominic van Essen Aug 21 at 13:07
• what is the new rule? – Kamila Szewczyk Aug 21 at 13:35
• @Szewczyk Turn 6 now edited and new rule added. Let's see how it goes from here... – Dominic van Essen Aug 21 at 13:42

# R, 158 bytes, codepoint total 105^2, turn number 9

Previous submission (turn 6)

This turn: added 115 characters: 'a=";b=")";k="ZPEJOHUPO!ZSFTDFOU"[\156\143ha\162(a)==48];\143a\164(\143ha\162\164\162("B-Z","a-w\40\103","M"))'

a="+=cat;'Kodington'+'Crescent'#@'C";b=")pr'+'nt'";k="ZPEJOHUPO!ZSFTDFOU"[\156\143ha\162(a)==48];\143a\164(\143ha\162\164\162("B-Z","a-w\40\103","M"))


Try it online!

Comments: pppery's rule (turn 8) forbidding programs to output any of their own characters has rather scuppered any chance of me winning this turn, or even next turn, since my previous program (from turn 6) was packed-full of now-forbidden characters, and I'm not allowed to modify my code (to get rid of them) in the same turn as adding to it (to implement a new 'print X without X' approach).
So, for this turn, I'm trying to (1) begin the first half of building-up my program under the current rules, which will need continuing on a subsequent turn before being ready to win, and (2) add a rule to stop the other current contestants.

Razetime, petStorm and Szewczyk all already need more than >8 characters of changes to their current programs before they can win. pppery currently has a program that requires only 2 characters to be changed to print Codington Crescent, leaving 6 characters free to comply with the perfect-square-codepoint rule, which is probably enough. However, the approach of adding +25 to all the printed characters means that the   (space) character is encoded by a non-printable byte. Moreover, if the +25 is changed, then >8 other characters would need to be changed to get Codington Crescent again. So I think (hope) that simply restricting code to printable ASCII is sufficient to block this program (at least for now).

Rules:

• Programs may not contain any whitespace characters (last turn)
• The codepoint sum needs to be a perfect square that's greater than 1444. (1 turn left)
• Programs may only output 'Codington Crescent' if they are irreducible AND modifications (additions OR changes) of at most 8 characters from a previously-submitted answer (2 turns left)
• Programs may not output any characters contained in their source code (4 turns left)
• Programs may not contain any bytes corresponding to non-printable ASCII characters (that is, <32 or >126) (5 turns left)

# Io, turn number 1

"MoC"print


Try it online!

## Rules

• Turns may not print Codington Crescent. (1 turns left)

• Running programs must be irreducible. (1 turns left)

• Maximum program length is 20 bytes. (1 turns left)

• Your answer has to include the substring C"pr. Online Verifier (2 turns left)

• Can you adhere to the template and add the current rules in the answer? – Jo King Aug 21 at 9:24

# ///, Turn number 2

C"prodington


Edit: Changed the porgram to fit the guidelines on irreducibility, discussed here. Rules have not changed.

Try it online!

## Rules

• Programs may not print Codington Crescent.(3 turns left)
• Running programs must be irreducible. (3 turns left)
• Programs must have the substring C"pr (4 turns left)
• Maximum program length is 20 bytes. (3 turns left)
• Programs may not contain brackets of any kind. (5 turns left)
• I was pondering a C program: a='C"pr'^709238577;f(){puts(&a);}; but then I realized brackets are banned ^.^ - that's actually a quite good restriction, because I have no idea is there a language I know where it's doable to write a program with such restrictions lol – Kamila Szewczyk Aug 21 at 11:29
• also; theoretically invalidated: chat.stackexchange.com/transcript/message/55310764#55310764 - the program works as Cod (instead of Cod/C"pr): tio.run/##K85JLM5ILf7/3zk/5f9/AA – Kamila Szewczyk Aug 21 at 11:45
• Turn 6 now edited and new rule added. Let's see how it goes from here... – Dominic van Essen Aug 21 at 13:44

# str, 25 bytes, turn number 8

*VKPUN\VU*YLZJLU\25+p;


Note the invisible character with code point 7 between between VU and *Y

Rules

• Programs may not contain brackets of any kind. (expired)
• Minimum program length is 19 bytes (last turn)
• Programs may not contain any whitespace characters (1 turn left)
• The codepoint sum needs to be a perfect square that's greater than 1444. (2 turns left)
• Programs may only output 'Codington Crescent' if they are irreducible AND modifications (additions OR changes) of at most 8 characters from a previously-submitted answer (3 turns left)
• Programs may not output any characters contained in their source code (5 turns left)

Try it online!

• Wow. Tough rule. – Dominic van Essen Aug 22 at 17:55
• It's a rule that this program can easily follow, and is very difficult to do in any programs not designed for it. I thought the point of this challenge was to do exactly that, make it easy for yourself to answer and hard for others. – pppery Aug 22 at 18:45
• Agree. 'Tough rule' was intended as an indication of approval... – Dominic van Essen Aug 22 at 19:13
• @DominicvanEssen The combination of rules is the toughest part tbh. Been trying for a while now, and even though I have 75 different programs that output Codington Crescent without containing any of its characters, which are all irreducible, and are all at most 8 changes away from pppery's str answer here (I need 6 changes to get the output, so I have just 2 characters left to work with) that annoying square number screws things over big time. Especially in combination with the irreducible part and no more than 8 changes.. – Kevin Cruijssen Aug 24 at 11:44
• @KevinCruijssen Well, indeed, I also have several variants of my own current program that can output Codington Crescent irreducibly and without using any of its characters, but they all need >8 changes to get rid of all the forbidden characters that are left-over from my previous turns. So, altogether, I conclude that the 8 change limit seems to be working as intended (even if I'm suffering from it). – Dominic van Essen Aug 24 at 11:50

# R, 19 bytes, turn number 4

+=cat;'C"pr'+'nt'


Try it online!

Rules

• Programs may not print Codington Crescent.(1 turns left)
• Running programs must be irreducible. (1 turns left)
• Maximum program length is 20 bytes. (1 turns left)
• Programs must have the substring C"pr (2 turns left)
• Programs may not contain brackets of any kind. (3 turns left)
• Minimum program length is 19 bytes (4 turns left)
• Programs may not contain any whitespace characters (5 turns left)

# Io, turn number 3

"idoC"print


## Original submission: Befunge-98 (FBBI), 19 bytes, turn 3

NOTE: invalidated per (transcript)

"nidoC"4k,@@@@@C"pr


Try it online!

# Rules

• Programs may not print Codington Crescent.(2 turns left)
• Running programs must be irreducible. (2 turns left)
• Programs must have the substring C"pr (3 turns left)
• Maximum program length is 20 bytes. (2 turns left)
• Programs may not contain brackets of any kind. (4 turns left)
• Minimum program length is 19 bytes (5 turns left)
• What does 'pass' mean? Do we now go to turn 5? Or to turn 6? – Dominic van Essen Aug 21 at 11:55
• @DominicvanEssen I passed because the submission #2 is invalid, and I'm waiting for the author to fix it (hopefully, maybe) – Kamila Szewczyk Aug 21 at 11:56
• Ok. I think my answer (turn 4) is valid, but please tell me if I've also misunderstood the 'irreducible' rule... – Dominic van Essen Aug 21 at 12:17
• I'm sure that passing increments the turn number. Otherwise contradictory rules would stop the game. – Razetime Aug 21 at 12:25

# Io, 19 bytes, turn number 5

"Codin34:::;C"print


Try it online!

## Rules

• Programs may not print Codington Crescent.(1 turns left)
• Running programs must be irreducible. (1 turns left)
• Maximum program length is 20 bytes. (1 turns left)
• Programs must have the substring C"pr (2 turns left)
• Programs may not contain brackets of any kind. (3 turns left)
• Minimum program length is 19 bytes (4 turns left)
• Programs may not contain any whitespace characters (5 turns left)
• The codepoint sum needs to be a perfect square that's greater than 1444. (6 turns left) Verifier
• I think this was the last turn for the first 3 rules. They don't have one turn left: they expire now, and are gone for turn 6. – Dominic van Essen Aug 21 at 13:01
• Turn 6 now edited and new rule added. Let's see how it goes from here... – Dominic van Essen Aug 21 at 13:43

# ///, Turn number 7, FARKLE

C"prodington
`

This is a passed move. No change.

Try it online!

## Rules

• Programs must have the substring C"pr (expired)
• Programs may not contain brackets of any kind. (last turn)
• Minimum program length is 19 bytes (1 turns left)
• Programs may not contain any whitespace characters (2 turns left)
• The codepoint sum needs to be a perfect square that's greater than 1444. (3 turns left)
• Programs may only output 'Codington Crescent' if they are irreducible AND modifications (additions OR changes) of at most 8 characters from a previously-submitted answer (4 turns left)
• Note that the last rule specifies that you can only output 'Codington Crescent' if you meet the irreducible/modification conditions. But you could still make your code reducible or make >8character changes if you don't print 'Codington Crescent' (so you'd be 'building' your code for a future, game-winning modification of ≤8bytes... For instance by adding a lot of codepoints now to reach a >1444-sum square... – Dominic van Essen Aug 22 at 13:15
• interesting. I'm not changing this move, however. – Razetime Aug 22 at 13:48
• That's fine, of course. I just wanted to make sure that the rule wasn't being interpreted wrongly (or that I hadn't written it in an ambiguous way). – Dominic van Essen Aug 22 at 13:49