public void GetValueWithMaskAppliedTest() { // The program then attempts to write the value 11 to memory address 8.By expanding everything out to individual bits, the mask is applied as follows: // // value: 000000000000000000000000000000001011(decimal 11) // mask: XXXXXXXXXXXXXXXXXXXXXXXXXXXXX1XXXX0X // result: 000000000000000000000000000001001001(decimal 73) // So, because of the mask, the value 73 is written to memory address 8 instead.Then, the program tries to write 101 to address 7: // // value: 000000000000000000000000000001100101(decimal 101) // mask: XXXXXXXXXXXXXXXXXXXXXXXXXXXXX1XXXX0X // result: 000000000000000000000000000001100101(decimal 101) // This time, the mask has no effect, as the bits it overwrote were already the values the mask tried to set. Finally, the program tries to write 0 to address 8: // // value: 000000000000000000000000000000000000(decimal 0) // mask: XXXXXXXXXXXXXXXXXXXXXXXXXXXXX1XXXX0X // result: 000000000000000000000000000001000000(decimal 64) var testData = new List <Tuple <string, long, long> >() { new Tuple <string, long, long>( "XXXXXXXXXXXXXXXXXXXXXXXXXXXXX1XXXX0X", 11, 73), new Tuple <string, long, long>( "XXXXXXXXXXXXXXXXXXXXXXXXXXXXX1XXXX0X", 101, 101), new Tuple <string, long, long>( "XXXXXXXXXXXXXXXXXXXXXXXXXXXXX1XXXX0X", 0, 64) }; foreach (var testExample in testData) { var actual = DockingProgramHelper.GetValueWithMaskApplied(testExample.Item2, testExample.Item1); Assert.Equal(testExample.Item3, actual); } }
public void GetAddressesWithMaskAppliedTest() { // For example, consider the following program: // mask = 000000000000000000000000000000X1001X // mem[42] = 100 // mask = 00000000000000000000000000000000X0XX // mem[26] = 1 // When this program goes to write to memory address 42, it first // applies the bitmask: // address: 000000000000000000000000000000101010(decimal 42) // mask: 000000000000000000000000000000X1001X // result: 000000000000000000000000000000X1101X // After applying the mask, four bits are overwritten, three of // which are different, and two of which are floating. Floating // bits take on every possible combination of values; with two // floating bits, four actual memory addresses are written: // 000000000000000000000000000000011010(decimal 26) // 000000000000000000000000000000011011(decimal 27) // 000000000000000000000000000000111010(decimal 58) // 000000000000000000000000000000111011(decimal 59) // Next, the program is about to write to memory address 26 with a // different bitmask: // address: 000000000000000000000000000000011010(decimal 26) // mask: 00000000000000000000000000000000X0XX // result: 00000000000000000000000000000001X0XX // This results in an address with three floating bits, causing // writes to eight memory addresses: // 000000000000000000000000000000010000(decimal 16) // 000000000000000000000000000000010001(decimal 17) // 000000000000000000000000000000010010(decimal 18) // 000000000000000000000000000000010011(decimal 19) // 000000000000000000000000000000011000(decimal 24) // 000000000000000000000000000000011001(decimal 25) // 000000000000000000000000000000011010(decimal 26) // 000000000000000000000000000000011011(decimal 27) var testData = new List <Tuple <string, long, IList <long> > >() { new Tuple <string, long, IList <long> >( "000000000000000000000000000000X1001X", 42, new List <long>() { 26, 27, 58, 59 }), new Tuple <string, long, IList <long> >( "00000000000000000000000000000000X0XX", 26, new List <long>() { 16, 17, 18, 19, 24, 25, 26, 27 }) }; foreach (var testExample in testData) { var actual = DockingProgramHelper.GetAddressesWithMaskApplied(testExample.Item2, testExample.Item1); bool contentsAreTheSame = actual.Count == testExample.Item3.Count && !actual.Where(e => !testExample.Item3.Contains(e)).Any(); Assert.True(contentsAreTheSame); } }
public void GetSumOfMemoryValuesTest() { // For example, consider the following program: // mask = XXXXXXXXXXXXXXXXXXXXXXXXXXXXX1XXXX0X // mem[8] = 11 // mem[7] = 101 // mem[8] = 0 // This program starts by specifying a bitmask(mask = ....). // The mask it specifies will overwrite two bits in every written // value: the 2s bit is overwritten with 0, and the 64s bit is // overwritten with 1. // The program then attempts to write the value 11 to memory // address 8. By expanding everything out to individual bits, the // mask is applied as follows: // value: 000000000000000000000000000000001011(decimal 11) // mask: XXXXXXXXXXXXXXXXXXXXXXXXXXXXX1XXXX0X // result: 000000000000000000000000000001001001(decimal 73) // So, because of the mask, the value 73 is written to memory // address 8 instead.Then, the program tries to write 101 to // address 7: // value: 000000000000000000000000000001100101(decimal 101) // mask: XXXXXXXXXXXXXXXXXXXXXXXXXXXXX1XXXX0X // result: 000000000000000000000000000001100101(decimal 101) // This time, the mask has no effect, as the bits it overwrote // were already the values the mask tried to set. Finally, the // program tries to write 0 to address 8: // value: 000000000000000000000000000000000000(decimal 0) // mask: XXXXXXXXXXXXXXXXXXXXXXXXXXXXX1XXXX0X // result: 000000000000000000000000000001000000(decimal 64) // 64 is written to address 8 instead, overwriting the value that // was there previously. // To initialize your ferry's docking program, you need the sum of // all values left in memory after the initialization program // completes. (The entire 36-bit address space begins initialized // to the value 0 at every address.) In the above example, only // two values in memory are not zero - 101 (at address 7) and 64 // (at address 8) - producing a sum of 165. // // Version 2 // For example, consider the following program: // mask = 000000000000000000000000000000X1001X // mem[42] = 100 // mask = 00000000000000000000000000000000X0XX // mem[26] = 1 // When this program goes to write to memory address 42, it first // applies the bitmask: // address: 000000000000000000000000000000101010(decimal 42) // mask: 000000000000000000000000000000X1001X // result: 000000000000000000000000000000X1101X // After applying the mask, four bits are overwritten, three of // which are different, and two of which are floating. Floating // bits take on every possible combination of values; with two // floating bits, four actual memory addresses are written: // 000000000000000000000000000000011010(decimal 26) // 000000000000000000000000000000011011(decimal 27) // 000000000000000000000000000000111010(decimal 58) // 000000000000000000000000000000111011(decimal 59) // Next, the program is about to write to memory address 26 with a // different bitmask: // address: 000000000000000000000000000000011010(decimal 26) // mask: 00000000000000000000000000000000X0XX // result: 00000000000000000000000000000001X0XX // This results in an address with three floating bits, causing // writes to eight memory addresses: // 000000000000000000000000000000010000(decimal 16) // 000000000000000000000000000000010001(decimal 17) // 000000000000000000000000000000010010(decimal 18) // 000000000000000000000000000000010011(decimal 19) // 000000000000000000000000000000011000(decimal 24) // 000000000000000000000000000000011001(decimal 25) // 000000000000000000000000000000011010(decimal 26) // 000000000000000000000000000000011011(decimal 27) // The entire 36 - bit address space still begins initialized to // the value 0 at every address, and you still need the sum of all // values left in memory at the end of the program. // In this example, the sum is 208. var testData = new List <Tuple <IList <string>, int, long> >() { new Tuple <IList <string>, int, long>( new List <string>() { "mask = XXXXXXXXXXXXXXXXXXXXXXXXXXXXX1XXXX0X", "mem[8] = 11", "mem[7] = 101", "mem[8] = 0" }, 1, 165), new Tuple <IList <string>, int, long>( new List <string>() { "mask = 000000000000000000000000000000X1001X", "mem[42] = 100", "mask = 00000000000000000000000000000000X0XX", "mem[26] = 1" }, 2, 208), }; foreach (var testExample in testData) { var memoryBank = DockingProgramHelper.RunProgram(testExample.Item1, testExample.Item2); var actual = DockingProgramHelper.GetSumOfMemoryValues(memoryBank); Assert.Equal(testExample.Item3, actual); } }