protected override int Part1(string[] input)
{
var turingMachine = new TuringMachine(input);
var checksum = turingMachine.CalculateDiagnosticsChecksum();
return(checksum);
}
private static void Main()
{
var d = new Dictionary <TuringMachine.InstructionSelector, TuringMachine.InstructionResult> {
{ new TuringMachine.InstructionSelector(0, false), new TuringMachine.InstructionResult(0, true, true) },
{ new TuringMachine.InstructionSelector(0, true), new TuringMachine.InstructionResult(-1, true, false) }
}.ToImmutableDictionary();
var t = new TuringMachine(d, 2 * 2 * 2 * 2);
var h = t.AdvancedUntilHalted();
var n = h.MayResult;
var s = new SolomonoffInductor();
for (var i = 0; ; i++)
{
s.Advance(i * i + 10);
var z = s.Predict()
.OrderBy(e => - e.Value)
.Select(e => string.Format("{0}: {1:0.000000}", e.Key, (double)e.Value))
.ToArray();
Console.WriteLine("=== Step: " + i);
foreach (var s1 in z)
{
Console.WriteLine(s1);
}
s.Measure(1, nextInput: i + 1);
}
}
public static void InputToTape(InputField input, GameObject cellTapePrefab)
{
ClearTape();
TuringMachine tm = GameObject.FindGameObjectWithTag("GameController").GetComponent <TuringMachine>();
GameObject.FindGameObjectWithTag("processButton").GetComponent <Button>().interactable = true;
GameObject.FindGameObjectWithTag("startMachineButton").GetComponent <Button>().interactable = true;
GameObject.FindGameObjectWithTag("tapeInput").GetComponent <Dropdown>().interactable = true;
GameObject.FindGameObjectWithTag("StepButtonLight").GetComponent <Light>().intensity = 2.5f;
GameObject.FindGameObjectWithTag("StartButtonLight").GetComponent <Light>().color = Color.green;
char[] cellsInChar = input.GetComponent <InputField>().text.ToCharArray();
foreach (char c in cellsInChar)
{
if (!tm.GetAlphabet().LookForSymbol(c))
{
GameObject.FindGameObjectWithTag("GameController").GetComponent <Utils>().showWait = true;
return;
}
}
//cria as celulas da fita
for (int i = 0; i < cellsInChar.Length; i++)
{
GameObject cell = Instantiate(cellTapePrefab);
cell.GetComponentInChildren <TextMesh>().text = "" + cellsInChar[i];
cell.transform.position = new Vector3((1.5f * i), 0, 0);
}
GameObject.FindGameObjectWithTag("TuringMachine").transform.position = new Vector3(0, 0, 0);
}
public void Test8()
{
for (int i = 0; i < 128; i++)
{
var asBinaryString = Convert.ToString(i, 2);
var input =
$@"
@Programa Fonte Unifor
fita {asBinaryString}
init q
accept qf
q,0,q,0,>
q,1,q,1,>
q,_,qf,0,<";
var turingMachine = TuringMachine.FromText(input.Split('\n'));
while (turingMachine.MachineState != TuringMachine.State.Finished)
{
turingMachine.Run();
}
Console.WriteLine($"On {i} -- {asBinaryString}");
Assert.AreEqual(i * 2, Convert.ToInt32(turingMachine.Data.ReadAll(), 2));
}
}
public void MachineEncodeTest()
{
const char b = Alphabet.Blank;
var q = new States(3);
var tf = new TuringTransitionFunction()
{
new TuringTransition(q[0], b, q[1], b, TuringMachine.Direction.R),
new TuringTransition(q[1], 'b', q[1], 'b', TuringMachine.Direction.R),
new TuringTransition(q[1], 'a', q[2], 'b', TuringMachine.Direction.L),
new TuringTransition(q[1], b, q[2], b, TuringMachine.Direction.L),
new TuringTransition(q[2], 'b', q[2], 'b', TuringMachine.Direction.L),
new TuringTransition(q[2], b, State.Ha, b, TuringMachine.Direction.S)
};
var t = new TuringMachine(q, Alphabet.Ab, new TapeAlphabet(Alphabet.Ab), tf, q[0]);
var e = $"{b}";
foreach (var m in tf)
{
e += TuringMachine.BinEncode(m, t.States) + b;
}
Assert.AreEqual(TuringMachine.BinEncode(t), e);
}
void Start()
{
tm = GetComponent <TuringMachine>();
inputField = GameObject.FindGameObjectWithTag("input").GetComponent <InputField>();
startMachineButton = GameObject.FindGameObjectWithTag("startMachineButton").GetComponent <Button>();
stepButtonLight = GameObject.FindGameObjectWithTag("StepButtonLight").GetComponent <Image>();
startButtonLight = GameObject.FindGameObjectWithTag("StartButtonLight").GetComponent <Image>();
processButton = GameObject.FindGameObjectWithTag("processButton").GetComponent <Button>();
stateDisplay = GameObject.FindGameObjectWithTag("stateDisplay").GetComponent <TextMesh>();
/*
* if(File.Exists(Application.persistentDataPath + "/Machines/machines.txt"))
* LoadAllMachines(File.ReadAllText(Application.persistentDataPath + "/Machines/machines.txt"));
* else
* {
* File.Create(Application.persistentDataPath + "/Machines/machines.txt");
* }*/
if (!Directory.Exists(Application.persistentDataPath + "\\Machines"))
{
Directory.CreateDirectory(Application.persistentDataPath + "\\Machines");
SaveMachine.WriteIt(Application.persistentDataPath + "\\Machines\\machines.txt", Constants.DEFAULTDESCRIPTIONS());
}
LoadAllMachines(File.ReadAllText(Application.persistentDataPath + "\\Machines\\machines.txt"));
LoadOptions();
LoadMachine();
}
public override string Part1(string input, object?args)
{
var t = new TuringMachine(input);
t.RunCheckSum();
return(t.CheckSum.ToString());
}
public double[] ActivateNeuralNetwork(double[] environmentOutput)
{
Debug.DLog($"Neural Network Input: {Utilities.ToString(environmentOutput, "f4")}{Utilities.ToString(_turingMachineOutput, "f4")}", true);
// Reset the neural network state
Phenome.ResetState();
// NN Input is the output from the environment, and the output from the turing machine in the previous activation
Phenome.InputSignalArray.CopyFrom(environmentOutput, 0);
Phenome.InputSignalArray.CopyFrom(_turingMachineOutput, environmentOutput.Length);
// Activate the neural network
Phenome.Activate();
double[] nnOutput = new double[Phenome.OutputSignalArray.Length];
Phenome.OutputSignalArray.CopyTo(nnOutput, 0);
Debug.DLog($"Neural Network Output: {Utilities.ToString(nnOutput, "f4")}", true);
// Environment inputs are first of the NN outputs
double[] environmentInput = Utilities.ArrayCopyOfRange(nnOutput, 0, nnOutput.Length - _turingInputLength);
// Turing inputs are the last of the NN outputs
double[] turingMachineInput = Utilities.ArrayCopyOfRange(nnOutput, nnOutput.Length - _turingInputLength, _turingInputLength);
// Activate turing machine with the NN outputs, and store the result for the next iteration, since the environment must be activated in the mean time
_turingMachineOutput = ProcessTuringMachineOutput(TuringMachine.ProcessInput(turingMachineInput));
// Return the environment input (remaining NN outputs)
return(environmentInput);
}
public Grammar Convert(TuringMachine turingMachine)
{
List <Production> productions = GetProductions(turingMachine);
List <Terminal> terminals = new List <Terminal>()
{
//new Terminal("0"),
new Terminal("1"),
new Terminal("eps")
};
HashSet <Variable> variables = new HashSet <Variable>();
foreach (var production in productions)
{
foreach (var elem in production.LeftPart)
{
if (elem is Variable nonterminal)
{
variables.Add(nonterminal);
}
}
foreach (var elem in production.RightPart)
{
if (elem is Variable nonterminal)
{
variables.Add(nonterminal);
}
}
}
return(new Grammar(new Variable("A1"), productions, terminals, variables.ToList()));
}
// $G$ CSS-013 (-3) Input parameters names should start with i_PascaleCase.
private static void writeXResult(string i_guess, TuringMachine <char> o_result, bool[] i_v)
{
if (i_guess == null)
{
throw new ArgumentNullException("i_guess", "i_guess must not be null.");
}
if (o_result == null)
{
throw new ArgumentNullException("o_result", "o_result must not be null.");
}
if (i_v == null)
{
throw new ArgumentNullException("i_v", "i_v must not be null.");
}
for (int i = 0; i < k_PasswordLength; i++)
{
if (i_v[i])
{
continue;
}
if (StringUtils.IsMemberOf(i_guess[i], s_password))
{
o_result.Write('X', 2);
}
}
}
void OnGUI()
{
TuringMachine tm = GameObject.FindGameObjectWithTag("GameController").GetComponent <MachineGear>().SimulatedMachine();
if (showWait)
{
try
{
GUI.Box(new Rect((Screen.width / 2) - 100, (Screen.height / 2) - 30, 200, 60), "Input rejected", warning.box);
}
catch { }
StartCoroutine(InputErrorPopUp());
}
if (showInfo)
{
try
{
GUI.Box(new Rect(130, 150, Screen.width / 3, Screen.height / 3), tm.GetDescription(), warning.box);
}
catch { }
StartCoroutine(InfoPopUp());
}
}
/// <summary>
/// Initializes the <see cref="GameMaster"/> singleton. This is called in
/// the <see cref="GameMasterMonobehavior.Awake"/> method so that all
/// <see cref="GameMasterMonobehavior"/> sub-classes can access the
/// <see cref="GameMaster"/> instance.
///
/// Grabs Unity prefab resources for UI and sprites, instantiates the
/// random seed, the grid, and the Turing machines, and then begins
/// the simulation update co-routine.
/// </summary>
public void Initialize()
{
if (UseCustomSeed)
{
Random.InitState(RandomSeed);
}
else
{
RandomSeed = Random.Range(int.MinValue, int.MaxValue);
print("SEED: " + RandomSeed.ToString());
Random.InitState(RandomSeed);
}
TuringMachineHeadPrefab = (GameObject)Resources.Load("Turing Machine Head");
TuringMachineEditorPanelPrefab = (GameObject)Resources.Load("TuringMachineEditorCanvas");
GridData = new GridData();
TuringMachines = new TuringMachine[NumberOfTuringMachines];
for (int machineID = 0; machineID < NumberOfTuringMachines; machineID++)
{
TuringMachine newMachine = new TuringMachine(machineID, NumberStatesPerMachine);
if (RandomStartingTransitions)
{
newMachine.GenerateRandomTransitions();
}
TuringMachines[machineID] = newMachine;
}
RunSimulation = false;
IEnumerator simulationUpdater = TuringMachineUpdateClock();
StartCoroutine(simulationUpdater);
}
public void Test6()
{
for (int i = 0; i < 128; i++)
{
var asBinaryString = Convert.ToString(i, 2);
var input =
$@"
@Programa Fonte Unifor
fita {asBinaryString}
init qs
accept qv
qs,0,qs,0,>
qs,1,qs,1,>
qs,_,qcf,_,<
qcf,1,qcs,1,<
qcs,0,qv,0,<";
var turingMachine = TuringMachine.FromText(input.Split('\n'));
while (turingMachine.MachineState != TuringMachine.State.Finished)
{
turingMachine.Run();
}
Console.WriteLine($"On {i} -- {asBinaryString}");
Assert.AreEqual(asBinaryString.EndsWith("01"), turingMachine.Result == TuringMachine.FinishResult.Valid);
}
}
public void Test5()
{
for (int i = 0; i < 128; i++)
{
var asBinaryString = Convert.ToString(i, 2);
var input =
$@"
@Programa Fonte Unifor
fita {asBinaryString}
init q0
accept q0
q0,0,q0,0,>
q0,1,q1,1,>
q1,0,q2,0,>
q1,1,q3,1,>
q2,0,q4,0,>
q2,1,q0,1,>
q3,0,q1,0,>
q3,1,q2,1,>
q4,0,q3,0,>
q4,1,q4,1,>";
var turingMachine = TuringMachine.FromText(input.Split('\n'));
while (turingMachine.MachineState != TuringMachine.State.Finished)
{
turingMachine.Run();
}
Console.WriteLine($"On {i} -- {asBinaryString}");
Assert.AreEqual(i % 5 == 0, turingMachine.Result == TuringMachine.FinishResult.Valid);
}
}
public void Test4()
{
var input =
@"
@Programa Fonte Unifor
fita 1011
init qi
accept qf
qi,1,qi,1,>
qi,0,qi,0,>
qi,_,q1,_,<
q1,1,q1,0,<
q1,0,qf,1,<";
var turingMachine = TuringMachine.FromText(input.Split('\n'));
while (turingMachine.MachineState != TuringMachine.State.Finished)
{
turingMachine.Run();
}
Assert.AreEqual(TuringMachine.FinishResult.Valid, turingMachine.Result);
Assert.AreEqual("1100", turingMachine.Data.ReadAll());
}
public void OutputUpdate()
{
try
{
tm = GameObject.FindGameObjectWithTag("GameController").GetComponent <TuringMachine>();
index = int.Parse(GameObject.FindGameObjectWithTag("stateDisplay").GetComponent <TextMesh>().text);
input = GameObject.FindGameObjectWithTag("readDisplay").GetComponent <TextMesh>().text;
if (input.Equals(""))
{
df = tm.StateByIndex(index).LookForFunction('Ø');
}
else
{
df = tm.StateByIndex(index).LookForFunction(char.Parse(input));
}
if (df.getOutput().Equals('Ø'))
{
GetComponent <TextMesh>().text = "";
}
else
{
GetComponent <TextMesh>().text = df.getOutput() + "";
}
}
catch { }
}
public void Init()
{
_input = Aoc.Framework.Input.GetStringVector(this);
_steps = Int64.Parse(_input[1].Split(" ")[5]);
string initial = _input[0].Split(" ")[3];
_machine = new TuringMachine(initial[0..^ 1]);
private void ResetButton_Click(object sender, RoutedEventArgs e)
{
TuringMachine = TuringMachine.FromText(input);
UpdateData();
PlayButton.IsEnabled = true;
ForwardButton.IsEnabled = true;
}
private void initialize()
{
this.Tape = new ObservableCollection <ValueCurrentPair>(this.readStrings.ToList()[stringsPointer]);
this.VisualTape.ItemsSource = this.Tape;
this.turingMachine = new TuringMachine(this.Tape);
updateStateIndicator();
}
//Construye la máquina
void BuildMachine()
{
string tira = "βββ" + inputMachine.text + "βββ";
CreateMachine(tira);
switch (dropMachine.value)
{
case 0:
//Machine Palindrome
rm = mr.getPal();
tm = new TuringMachine(tira, rm, new int[] { 11 });
break;
case 1:
//Machine Copy
rm = mr.getCopy();
tm = new TuringMachine(tira, rm, new int[] { 1 });
break;
case 2:
//Machine Mult
rm = mr.getMult();
tm = new TuringMachine(tira, rm, new int[] { 11 });
break;
case 3:
//Machine Sum
rm = mr.getSum();
tm = new TuringMachine(tira, rm, new int[] { 3 });
break;
case 4:
//Machine Sub
rm = mr.getSub();
tm = new TuringMachine(tira, rm, new int[] { 3 });
break;
}
//Disble buttons when the machine is working
btnNext.interactable = false;
inputMachine.interactable = false;
dropMachine.interactable = false;
btnReset.interactable = false;
//And now Turn on the Machine
//InvokeRepeating("MotorMachine", 0.5f, 0.5f);
StartCoroutine(MotorMachine());
}
private void AutoPlayOnDoWork(object sender, DoWorkEventArgs e)
{
while (!AutoPlay.CancellationPending && TuringMachine.MachineState != TuringMachine.State.Finished)
{
TuringMachine.Run();
AutoPlay.ReportProgress(0);
Thread.Sleep(350);
}
}
private void MachineControl_MouseDoubleClick(object sender, MouseButtonEventArgs e)
{
TuringMachineEditWindow editwindow = new TuringMachineEditWindow(ContainingMachine);
editwindow.ShowDialog();
ContainingMachine = editwindow.ContainingMachine;
Dragging = false;
e.Handled = true;
}
public void TestExecuteBlueprint()
{
var instructions = Testing.GetTestFileContents("TestInput.txt").Split(Environment.NewLine);
var turingMachine = new TuringMachine(instructions.ToList());
turingMachine.ExecuteBlueprint();
Assert.AreEqual(3, turingMachine.CalculateChecksum());
}
public void XxTest()
{
var q = new States(10);
var g = new TapeAlphabet('A', 'B') + Alphabet.Ab;
var tf = new TuringTransitionFunction()
{
new TuringTransition(q[0], Alphabet.Blank, q[1], Alphabet.Blank, TuringMachine.Direction.R),
new TuringTransition(q[1], 'a', q[2], 'A', TuringMachine.Direction.R),
new TuringTransition(q[1], 'b', q[2], 'B', TuringMachine.Direction.R),
new TuringTransition(q[2], 'a', q[2], 'a', TuringMachine.Direction.R),
new TuringTransition(q[2], 'b', q[2], 'b', TuringMachine.Direction.R),
new TuringTransition(q[2], Alphabet.Blank, q[3], Alphabet.Blank, TuringMachine.Direction.L),
new TuringTransition(q[2], 'A', q[3], 'A', TuringMachine.Direction.L),
new TuringTransition(q[2], 'B', q[3], 'B', TuringMachine.Direction.L),
new TuringTransition(q[3], 'a', q[4], 'A', TuringMachine.Direction.L),
new TuringTransition(q[3], 'b', q[4], 'B', TuringMachine.Direction.L),
new TuringTransition(q[4], 'a', q[4], 'a', TuringMachine.Direction.L),
new TuringTransition(q[4], 'b', q[4], 'b', TuringMachine.Direction.L),
new TuringTransition(q[4], 'A', q[1], 'A', TuringMachine.Direction.R),
new TuringTransition(q[4], 'B', q[1], 'B', TuringMachine.Direction.R),
new TuringTransition(q[1], 'A', q[5], 'A', TuringMachine.Direction.L),
new TuringTransition(q[1], 'B', q[5], 'B', TuringMachine.Direction.L),
new TuringTransition(q[1], Alphabet.Blank, State.Ha, Alphabet.Blank, TuringMachine.Direction.S),
new TuringTransition(q[5], 'A', q[5], 'a', TuringMachine.Direction.L),
new TuringTransition(q[5], 'B', q[5], 'b', TuringMachine.Direction.L),
new TuringTransition(q[5], Alphabet.Blank, q[6], Alphabet.Blank, TuringMachine.Direction.R),
new TuringTransition(q[6], Alphabet.Blank, State.Ha, Alphabet.Blank, TuringMachine.Direction.S),
new TuringTransition(q[6], 'b', q[7], 'B', TuringMachine.Direction.R),
new TuringTransition(q[7], 'a', q[7], 'a', TuringMachine.Direction.R),
new TuringTransition(q[7], 'b', q[7], 'b', TuringMachine.Direction.R),
new TuringTransition(q[7], Alphabet.Blank, q[7], Alphabet.Blank, TuringMachine.Direction.R),
new TuringTransition(q[7], 'B', q[9], Alphabet.Blank, TuringMachine.Direction.L),
new TuringTransition(q[9], Alphabet.Blank, q[9], Alphabet.Blank, TuringMachine.Direction.L),
new TuringTransition(q[9], 'a', q[9], 'a', TuringMachine.Direction.L),
new TuringTransition(q[9], 'b', q[9], 'b', TuringMachine.Direction.L),
new TuringTransition(q[6], 'a', q[8], 'A', TuringMachine.Direction.R),
new TuringTransition(q[8], 'a', q[8], 'a', TuringMachine.Direction.R),
new TuringTransition(q[8], 'b', q[8], 'b', TuringMachine.Direction.R),
new TuringTransition(q[8], Alphabet.Blank, q[8], Alphabet.Blank, TuringMachine.Direction.R),
new TuringTransition(q[8], 'A', q[9], Alphabet.Blank, TuringMachine.Direction.L),
new TuringTransition(q[9], 'A', q[6], 'A', TuringMachine.Direction.R),
new TuringTransition(q[9], 'B', q[6], 'B', TuringMachine.Direction.R)
};
var m = new TuringMachine(q, Alphabet.Ab, g, tf, q[0]);
Assert.True(m.Run("aa"));
Assert.True(m.Run("bb"));
Assert.True(m.Run("aaabbbaaabbb"));
Assert.True(m.Run("ababbababb"));
Assert.True(m.Run("babbab"));
Assert.True(m.Run("abab"));
Assert.False(m.Run("babb"));
Assert.False(m.Run("abb"));
Assert.False(m.Run("a"));
Assert.False(m.Run("b"));
}
public static void RunBusyBeaverProgram()
{
var tm = new TuringMachine();
BusyBeaverProgram busyBeaver = new FourStateBusyBeaver();
tm.run(busyBeaver, Console.Out);
Console.WriteLine("Program counter: " + tm.programCounter);
}
private void PlayButton_Click(object sender, RoutedEventArgs e)
{
if (TuringMachine.MachineEstado == TuringMachine.Estado.Finalizado)
{
return;
}
TuringMachine.Run();
UpdateData();
}
static void Main(string[] args)
{
var definitionFile = args[0];
var turingMachine = TuringMachine.LoadFromFile(definitionFile);
while (true)
{
turingMachine.Step();
}
}
public static void SaveTuringMachine(TuringMachine machine, string dir)
{
var jset = new JsonSerializerSettings()
{
TypeNameHandling = TypeNameHandling.All
};
JsonSerializer json = new JsonSerializer();
string machinestr = JsonConvert.SerializeObject(machine, jset);
File.WriteAllText(dir, machinestr);
}
private void OpenFileButton_Click(object sender, RoutedEventArgs e)
{
var ofd = new OpenFileDialog();
if (ofd.ShowDialog() == true)
{
input = File.ReadAllLines(ofd.FileName);
TuringMachine = TuringMachine.FromText(input);
UpdateData();
}
}
private static string calculateResult(string i_guess)
{
if (i_guess == null)
{
throw new ArgumentNullException("i_guess", "i_guess must not be null.");
}
TuringMachine <char> result = new TuringMachine <char>((2 * k_PasswordLength) - 1, ' ');
bool[] v = writeVResult(i_guess, result);
writeXResult(i_guess, result, v);
return(new string(result.TapeContent));
}
public ClassicTuringMachineViewModel(TuringMachine machine)
: this()
{
Machine = machine;
}
private void SelectMachineCommandHandler(TuringMachine sender)
{
CurrentMachineViewModel = new ClassicTuringMachineViewModel(sender);
}
