Please read the discussion above - there is explanation with examples.
Can I ask how to reduce number of chars to only 6.5k ?
My number of chars is more than 11k
This is also covered in the discussion above.
hi,
I donât understand my problem.
I even tried to cut the loop in 2 parts thinking that there was an icrement of âiâ going wrong and I have the same result. On some tests I pass all 31 letters and on others I donât.
I donât see where itâs wrong.
if anyone can help me, thx
Bonjour,
Jâai un souci pour passer certains tests, surtout aux alentours de la 30eme lettre (Ă©videmment).
Certains tests passent, dâautres non.
jâai essayĂ© en dĂ©coupant mon programme en pensant que câĂ©tait un problĂšme avec une boucle for mais ça me fait la mĂȘme chose. jâai placĂ© des espions qui ,il me semble, me donne les bonnes valeurs que jâattends, mais le rĂ©sultatâŠbref
si quelquâun peut mâaider a comprendre, ce serait sympa. Merci
class Player
{
static void Main(string[] args)
{
/// init variables
string result = null;
string alpha = "ABCDEFGHIJKLMNOPQRSTUVWXYZ ";
List<int> indexMot = new List<int>();
/// inputs
string magicPhrase = Console.ReadLine();
/// pre conditions
foreach (var item in magicPhrase)
{
indexMot.Add(alpha.IndexOf(item) + 1); // for 'A'=1, 'Z'=26, ' '=27
}
//Console.Error.WriteLine(magicPhrase[28]+" "+indexMot[28]);
//// conditions
for (int i = 0; i < indexMot.Count; i++)
{
if (i<=29)
{
if (indexMot[i]<13)
{
for (int j = 0; j < indexMot[i]; j++)
{
result += "+";
}
}else
{
for (int j = 0; j < 27-indexMot[i]; j++)
{
result += "-";
}
}
result += ".>";
}
}
for (int i = 0; i < indexMot.Count; i++)
{
if (i>29)
{
//Console.Error.WriteLine(magicPhrase[1]+" "+indexMot[1]+" "+magicPhrase[30]+" "+indexMot[30]);
if (indexMot[i]-indexMot[i-30]>0)
{
for (int j = 0; j < indexMot[i-30]-indexMot[i]; j++)
{
result += "+";
}
}
if (indexMot[i]-indexMot[i-30]<0)
{
for (int j = 0; j <27-indexMot[i-30]+indexMot[i]; j++)
{
result += "+";
}
}
result += ".>";
}
}
Jâai trouvĂ©, il faut changer de rune le moins possible.
je suis OK jusquâau test 23 maintenant. 
I used a similar approach but got 1368th. I will try a proper loop approach when I have some time.
Hi,
I have a problem with this puzzle.
In my code, I have a loop with [>] to find the next space rune. I tried several solutions (having a try, an if and even a while there is no space, create space) to avoid having an infinite loop when you have no spaces on your runes.
However, whatever I tried, I end up in an infinite loop, and I canât understand why.
Here is a link to the replay: Coding Games and Programming Challenges to Code Better
and here is my code since I didnât find a way to attach it in antoher way.
Thanks in advance for your help!
import sys
import math
import string
import pandas as pd
import numpy as np
Auto-generated code below aims at helping you parse
the standard input according to the problem statement.
magic_phrase = input()
print(f"{magic_phrase}", file=sys.stderr, flush=True)
print(f"{len(magic_phrase)}", file=sys.stderr, flush=True)
Write an action using print
To debug: print(âDebug messagesâŠâ, file=sys.stderr, flush=True)
Initialisations
Variables
rune_df = pd.DataFrame(index=range(30), columns=[âletterâ])
rune_df[âletterâ] = â â
answer = ââ
alphabet = list(string.ascii_uppercase)
alphabet.insert(0, â ')
alphabet_df = pd.DataFrame(columns=[âletterâ])
alphabet_df[âletterâ] = alphabet
position = 0
Functions
def FasterToGo(letter, rune_letter):
time_to_write = abs(letter.position - rune_letter.position)
letter_positions = rune_df[rune_df['letter'] == letter.name].index.tolist()
if len(letter_positions) > 3:
return True, letter_positions[0] - position
else:
possible_times = [x-position for x in letter_positions]
time_to_go = np.min(possible_times)
if abs(time_to_go) <= time_to_write : return True, time_to_go
else : return False, time_to_go
def letter_position(letter):
return alphabet_df[alphabet_df['letter'] == letter].index[0]
Class
class _letter:
def __init__(self, name):
self.name = name
self.position = letter_position(self.name)
Getting instructions
for character in magic_phrase:
letter = _letter(character)
rune_letter = _letter(rune_df.loc[position, 'letter'])
free_rune = _letter(' ')
#print(f"standing on {position, rune_letter.name}, looking for {letter.name}", file=sys.stderr, flush=True)
# If we already activate a rune with the letter
if letter.name in rune_df['letter'].unique().tolist():
# Find if it's better to write a new rune or go an old one
isFaster, path = FasterToGo(letter, rune_letter)
if isFaster:
# Find where it is and go there in the shortest path
if path > 0:
for i in range(path):
answer += '>'
position += 1
elif path < 0:
for i in range(abs(path)):
answer += '<'
position -= 1
#print(f"Moving {path} on {position}", file=sys.stderr, flush=True)
# Then activate the rune
answer += '.'
else:
# Inscribe the letter in place of the old one
#print(f"writing over", file=sys.stderr, flush=True)
letter_diff = letter.position - rune_letter.position
if letter_diff > 13:
letter_diff = letter_diff - 27
if letter_diff > 0:
for i in range(letter_diff):
answer += '+'
else:
for i in range(abs(letter_diff)):
answer += '-'
answer += '.'
rune_df.loc[position, 'letter'] = letter.name
# If the letter has not been written yet
else:
# Go where we have a free rune
if len(rune_df[rune_df['letter'] == ' ']) > 0:
position = rune_df[rune_df['letter'] == ' '].index[0]
answer += '[>]'
#print(f"writing on new at position {position}", file=sys.stderr, flush=True)
# Inscribe the letter in it
letter_diff = letter.position - free_rune.position
if letter_diff > 13:
letter_diff = letter_diff - 27
if letter_diff > 0:
for i in range(letter_diff):
answer += '+'
if letter_diff < 0:
for i in range(abs(letter_diff)):
answer += '-'
answer += '.'
rune_df.loc[position, 'letter'] = letter.name
Answering
print(f"{len(answer)}", file=sys.stderr, flush=True)
print(f"{answer}")
Please use </> in the formatting toolbar to format your code properly in this forum.
Great puzzle.
Loops are not needed to get under 6500.
I get under 6500 without loops.
Salut, je comprend pas, jâai essayĂ© toute les lettres possibles entre lâalphabet pour lââalphabet sĂ©parĂ© par 1 lettreâ et tout fonctionne bien.
Mais quand je soumet ma rĂ©ponse ça ne fonctionne pas au validateur numĂ©ro 16 âEntire alphabet x11 separated by one letterâ
Ca marche avec mon vieux code sans boucle mais ca prend 600 caractĂšre et lĂ une trentaine avec les boucles.
Vous avez une idée du soucis ?
en gros je fait >+++++++++++[<+[.+]+.[+]>-]
Hi, I donât understand, I tried all possible letters between the alphabet for the âalphabet separated by 1 letterâ and everything works fine in the IDE.
But when I submit my answer it doesnât work at validator number 16 âEntire alphabet x11 separated by one letterâ
It works with my old code without loops but it takes 600 characters and there about thirty with the loops.
Do you have an idea of the problem?
basically I do >+++++++++++[<+[.+]+.[+]>-]
The test and the validator are not the same, to avoid hardcoding. It is the alphabet with a letter ⊠but maybe not the same letter.
I know the validators are different but I tried several combinations.
Alphabet+letter+alphabet+âŠ
By writing I think with find why it does not work, my code takes into account only 1 letter, the same everywhere but it must not be a single letter which separates in the validator.
Thanks for the help 
EDIT :thatâs not it, I stop for today !!
No idea ?
I break down my output to explain my approach:
-counter >++++++++++++
">" + * number of full alphabet found
-loop [<+[.+]+.[+]>-]
"<" return to the starting rune
"+[.+]" enumerates the alphabet (when found in the sentence)
"+." if letter found between the alphabets (here A in the IDE, if it was B it would be â++.â, etc)
"[+]" resets the rune to space
">-" decrements the counter
With my code everything works in the IDE even when I try with another letter or different letters between the alphabets with a letter or not at the end, at the beginning, etc.
I hope you have understood my problem better, do you have any idea where my problem comes from?
Aucune idée ?
je décompose ma sortie pour vous expliquer ma démarche:
-compteur >+++++++++++
">" + * nombre dâalphabet complet trouvĂ©
-boucle [<+[.+]+.[+]>-]
"<" reviens sur la rune de départ
"+[.+]" Ă©numĂšre lâalphabet (quand trouvĂ© dans la phrase)
"+." si lettre trouvĂ© entre les alphabets (ici A dans lâIDE, si câĂ©tait B ça serait â++.â, etc)
"[+]" remet la rune sur espace
">-" décrémente le compteur
Avec mon code tout marche dans lâIDE mĂȘme quand jâessai avec une autre lettre ou des lettres diffĂ©rentes entre les alphabets avec une lettre ou non Ă la fin, au dĂ©but, etc
JâespĂšre que vous avez mieux compris mon souci, si vous avez une idĂ©e dâou viens mon problĂšme ?
While trying to understand using the loops I implemented a check that replaces the output with a shortened loop version. However, this does not bring down my instruction count. Am I misunderstanding something?
Example:
#two letter word x20
if self.path == '-------------.>------------.<.>.<.>.<.>.<.>.<.>.<.>.<.>.<.>.<.>.<.>.<.>.<.>.<.>.<.>.<.>.<.>.<.>.<.>.<.>.':
self.path = '------------->------------>-------[<<.>.>-]'
Hello, iâm trying to resolve this (anwsome) puzzle, with less than 6500 letters (iâm a beginner) but i block on the last test⊠i have a basic answer with 3k instructions which works and another âoptimisedâ with 2200 instructions that doesnât works, because of "too many instruction (infinity loop ?) so i thought that my code had an error, however, when i only print the instructions ( the brut instruction, without calling my function) i have the same message, but i donât understand why⊠I would be glad to give you any information if needed and hope youâll have a nice day ^^
The statement says:
You lose if:
Blub performs 4000 moves or more in the forest.
Maybe your 2200 instructions cause Blub to perform 4000 moves or more?
I finally tried this awesome optimization game. Here are my best scores per validator level to help you identify areas for improvement. Keep in mind that the best score still requires 148 fewer instructions, so mine is definitely not optimal. The lines with the search keyword are obtained by a beam search algorithm, others are manually found solutions.
| Scores
==================================================================
00 - Sample 1 | 28
01 - Short spell | 119 [search]
02 - One letter x15 | 20
03 - Close letters | 31
04 - Edge of the alphabet | 21
05 - One letter x31 | 12
06 - Two letter word x20 | 22
07 - Far away letters | 167 [search]
08 - One letter x53 + one letter x38 | 31
09 - One letter x70 | 16
10 - Ten letter word x8 | 66
11 - Medium spell | 284 [search]
12 - Seven letter word x26 | 63
13 - Long random sequence of 4 letters | 236 [search]
14 - Incremental sequence of 18 letters | 21
15 - Entire alphabet x11 separated by one letter | 19
16 - One same letter + a random letter x32 | 201 [search]
17 - Incremental space separated sequence | 10
18 - Pattern followed by other pattern | 77
19 - Pattern followed by random sequence of two letters | 118
20 - Two patterns repeated randomly | 177
21 - Pattern followed by incremental sequence | 41
22 - Long spell | 1124 [search]
==================================================================
TOTAL | 2904
1 Like
How did you get the scores of each validator? I didnât think that was possible 
You can look at section 4 of this post: Golfing in brainf**k - Virtual Atom, I described how I got the validator inputs.
TL;DR: I used the levelsâ names to write detection code. Then, I made two assumptions about validators: they have input strings that are the same length as test levels, and there is some sort of symmetry between both inputs, such that the complexity is the same. Both assumptions are correct except for the last level. Finally, I encoded information in my score by adding terminal > instructions to solutions produced by a determinist algorithm: by subtracting reference scores, I could quickly retrieve information. I thus obtained all the validator inputs that I could use locally to compute my score by level.
1 Like