Personal_mirrors/bitburner-src
1
0
Fork 0
mirror of https://github.com/bitburner-official/bitburner-src.git synced 2024-12-23 14:42:28 +01:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #3778 from s2ks/hamming

Browse Source 
CODINGCONTRACT: HammingCodes description and implementation fixes
This commit is contained in:
hydroflame 2022-07-21 02:16:35 -04:00 committed by GitHub
commit a48ae726ba
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
2 changed files with 167 additions and 106 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

43
src/data/codingcontracttypes.ts
View File

@ -2,7 +2,7 @@ import { getRandomInt } from "../utils/helpers/getRandomInt";
import { MinHeap } from "../utils/Heap";
import { comprGenChar, comprLZGenerate, comprLZEncode, comprLZDecode } from "../utils/CompressionContracts";
import { HammingEncode, HammingDecode } from "../utils/HammingCodeTools";
import { HammingEncode, HammingDecode, HammingEncodeProperly } from "../utils/HammingCodeTools";
/* tslint:disable:completed-docs no-magic-numbers arrow-return-shorthand */
/* Function that generates a valid 'data' for a contract type */
@ -1289,16 +1289,17 @@ export const codingContractTypesMetadata: ICodingContractTypeMetadata[] = [
return [
"You are given the following decimal Value: \n",
`${n} \n`,
"Convert it into a binary string and encode it as a 'Hamming-Code'. eg:\n ",
"Value 8 will result into binary '1000', which will be encoded",
"with the pattern 'pppdpddd', where p is a paritybit and d a databit,\n",
"or '10101' (Value 21) will result into (pppdpdddpd) '1001101011'.\n\n",
"NOTE: You need an parity Bit on Index 0 as an 'overall'-paritybit. \n",
"NOTE 2: You should watch the HammingCode-video from 3Blue1Brown, which explains the 'rule' of encoding,",
"including the first Index parity-bit mentioned on the first note.\n\n",
"Now the only one rule for this encoding:\n",
" It's not allowed to add additional leading '0's to the binary value\n",
"That means, the binary value has to be encoded as it is",
"Convert it to a binary representation and encode it as an 'extended Hamming code'. Eg:\n ",
"Value 8 is expressed in binary as '1000', which will be encoded",
"with the pattern 'pppdpddd', where p is a parity bit and d a data bit,\n",
"or '10101' (Value 21) will result into (pppdpdddpd) '1001101011'.\n",
"The answer should be given as a string containing only 1s and 0s.\n",
"NOTE: the endianness of the data bits is reversed in relation to the endianness of the parity bits.\n",
"NOTE: The bit at index zero is the overall parity bit, this should be set last.\n",
"NOTE 2: You should watch the Hamming Code video from 3Blue1Brown, which explains the 'rule' of encoding,",
"including the first index parity bit mentioned in the previous note.\n\n",
"Extra rule for encoding:\n",
"There should be no leading zeros in the 'data bit' section",
].join(" ");
},
gen: (): number => {
@ -1316,19 +1317,21 @@ export const codingContractTypesMetadata: ICodingContractTypeMetadata[] = [
desc: (n: unknown): string => {
return [
"You are given the following encoded binary string: \n",
`'${n}' \n`,
"The string is a Hamming code with 1 'possible' error on a random index.\n",
"If there is an error, find the bit that is an error and fix it.\n",
"Extract the encoded decimal value and return a string with that value.\n\n",
"NOTE: The length of the binary string is dynamic.\n",
"NOTE 2: Index 0 is an 'overall' parity bit. Watch the Hamming code video from 3Blue1Brown for more information.\n",
"NOTE 3: There's approximately a 55% chance for an altered bit. So... MAYBE there is an altered bit 😉\n",
"NOTE 4: Return the decimal value as a string.",
`'${n}' \n\n`,
"Treat it as an extended Hamming code with 1 'possible' error at a random index.\n",
"Find the 'possible' wrong bit, fix it and extract the decimal value, which is hidden inside the string.\n\n",
"Note: The length of the binary string is dynamic, but it's encoding/decoding follows Hamming's 'rule'\n",
"Note 2: Index 0 is an 'overall' parity bit. Watch the Hamming code video from 3Blue1Brown for more information\n",
"Note 3: There's a ~55% chance for an altered Bit. So... MAYBE there is an altered Bit 😉\n",
"Note: The endianness of the encoded decimal value is reversed in relation to the endianness of the Hamming code. Where",
"the Hamming code is expressed as little-endian (LSB at index 0), the decimal value encoded in it is expressed as big-endian",
"(MSB at index 0).\n",
"Extra note for automation: return the decimal value as a string",
].join(" ");
},
gen: (): string => {
const _alteredBit = Math.round(Math.random());
const _buildArray: Array<string> = HammingEncode(
const _buildArray: Array<string> = HammingEncodeProperly(
getRandomInt(Math.pow(2, 4), Math.pow(2, getRandomInt(1, 57))),
).split("");
if (_alteredBit) {

230
src/utils/HammingCodeTools.ts
View File

@ -1,97 +1,155 @@
// by Discord: H3draut3r#6722, feel free to ask me any questions. i probably don't know the answer 🤣
export function HammingEncode(value: number): string {
// encoding following Hammings rule
function HammingSumOfParity(_lengthOfDBits: number): number {
// will calculate the needed amount of parityBits 'without' the "overall"-Parity (that math took me 4 Days to get it working)
return _lengthOfDBits < 3 || _lengthOfDBits == 0 // oh and of course using ternary operators, it's a pretty neat function
? _lengthOfDBits == 0
? 0
: _lengthOfDBits + 1
: // the following math will only work, if the length is greater equal 3, otherwise it's "kind of" broken :D
Math.ceil(Math.log2(_lengthOfDBits * 2)) <=
Math.ceil(Math.log2(1 + _lengthOfDBits + Math.ceil(Math.log2(_lengthOfDBits))))
? Math.ceil(Math.log2(_lengthOfDBits) + 1)
: Math.ceil(Math.log2(_lengthOfDBits));
}
const _data = value.toString(2).split(""); // first, change into binary string, then create array with 1 bit per index
const _sumParity: number = HammingSumOfParity(_data.length); // get the sum of needed parity bits (for later use in encoding)
const count = (arr: Array<string>, val: string): number =>
arr.reduce((a: number, v: string) => (v === val ? a + 1 : a), 0);
// function count for specific entries in the array, for later use
export function HammingEncode(data: number): string {
const enc: Array<number> = [0];
const data_bits: Array<any> = data.toString(2).split("").reverse();
const _build = ["x", "x", ..._data.splice(0, 1)]; // init the "pre-build"
for (let i = 2; i < _sumParity; i++) {
// add new paritybits and the corresponding data bits (pre-building array)
_build.push("x", ..._data.splice(0, Math.pow(2, i) - 1));
}
// now the "calculation"... get the paritybits ('x') working
for (const index of _build.reduce(function (a: Array<number>, e: string, i: number) {
if (e == "x") a.push(i);
return a;
}, [])) {
// that reduce will result in an array of index numbers where the "x" is placed
const _tempcount = index + 1; // set the "stepsize" for the parityBit
const _temparray = []; // temporary array to store the extracted bits
const _tempdata = [..._build]; // only work with a copy of the _build
while (_tempdata[index] !== undefined) {
// as long as there are bits on the starting index, do "cut"
const _temp: Array<string> = _tempdata.splice(index, _tempcount * 2); // cut stepsize*2 bits, then...
_temparray.push(..._temp.splice(0, _tempcount)); // ... cut the result again and keep the first half
data_bits.forEach((e, i, a) => {
a[i] = parseInt(e);
});
let k = data_bits.length;
/* NOTE: writing the data like this flips the endianness, this is what the
* original implementation by Hedrauta did so I'm keeping it like it was. */
for (let i = 1; k > 0; i++) {
if ((i & (i - 1)) != 0) {
enc[i] = data_bits[--k];
} else {
enc[i] = 0;
}
_temparray.splice(0, 1); // remove first bit, which is the parity one
_build[index] = (count(_temparray, "1") % 2).toString(); // count with remainder of 2 and"toString" to store the parityBit
} // parity done, now the "overall"-parity is set
_build.unshift((count(_build, "1") % 2).toString()); // has to be done as last element
return _build.join(""); // return the _build as string
}
let parity: any = 0;
/* Figure out the subsection parities */
for (let i = 0; i < enc.length; i++) {
if (enc[i]) {
parity ^= i;
}
}
parity = parity.toString(2).split("").reverse();
parity.forEach((e: any, i: any, a: any) => {
a[i] = parseInt(e);
});
/* Set the parity bits accordingly */
for (let i = 0; i < parity.length; i++) {
enc[2 ** i] = parity[i] ? 1 : 0;
}
parity = 0;
/* Figure out the overall parity for the entire block */
for (let i = 0; i < enc.length; i++) {
if (enc[i]) {
parity++;
}
}
/* Finally set the overall parity bit */
enc[0] = parity % 2 == 0 ? 0 : 1;
return enc.join("");
}
export function HammingDecode(_data: string): number {
//check for altered bit and decode
const _build = _data.split(""); // ye, an array for working, again
const _testArray = []; //for the "truthtable". if any is false, the data has an altered bit, will check for and fix it
const _sumParity = Math.ceil(Math.log2(_data.length)); // sum of parity for later use
const count = (arr: Array<string>, val: string): number =>
arr.reduce((a: number, v: string) => (v === val ? a + 1 : a), 0);
// the count.... again ;)
export function HammingEncodeProperly(data: number): string {
/* How many bits do we need?
* n = 2^m
* k = 2^m - m - 1
* where k is the number of data bits, m the number
* of parity bits and n the number of total bits. */
let _overallParity = _build.splice(0, 1).join(""); // store first index, for checking in next step and fix the _build properly later on
_testArray.push(_overallParity == (count(_build, "1") % 2).toString() ? true : false); // first check with the overall parity bit
for (let i = 0; i < _sumParity; i++) {
// for the rest of the remaining parity bits we also "check"
const _tempIndex = Math.pow(2, i) - 1; // get the parityBits Index
const _tempStep = _tempIndex + 1; // set the stepsize
const _tempData = [..._build]; // get a "copy" of the build-data for working
const _tempArray = []; // init empty array for "testing"
while (_tempData[_tempIndex] != undefined) {
// extract from the copied data until the "starting" index is undefined
const _temp = [..._tempData.splice(_tempIndex, _tempStep * 2)]; // extract 2*stepsize
_tempArray.push(..._temp.splice(0, _tempStep)); // and cut again for keeping first half
let m = 1;
while (2 ** (2 ** m - m - 1) - 1 < data) {
m++;
}
const n: number = 2 ** m;
const k: number = 2 ** m - m - 1;
const enc: Array<number> = [0];
const data_bits: Array<any> = data.toString(2).split("").reverse();
data_bits.forEach((e, i, a) => {
a[i] = parseInt(e);
});
/* Flip endianness as in the original implementation by Hedrauta
* and write the data back to front
* XXX why do we do this? */
for (let i = 1, j = k; i < n; i++) {
if ((i & (i - 1)) != 0) {
enc[i] = data_bits[--j] ? data_bits[j] : 0;
}
const _tempParity = _tempArray.shift(); // and again save the first index separated for checking with the rest of the data
_testArray.push(_tempParity == (count(_tempArray, "1") % 2).toString() ? true : false);
// is the _tempParity the calculated data? push answer into the 'truthtable'
}
let _fixIndex = 0; // init the "fixing" index and start with 0
for (let i = 1; i < _sumParity + 1; i++) {
// simple binary adding for every boolean in the _testArray, starting from 2nd index of it
_fixIndex += _testArray[i] ? 0 : Math.pow(2, i) / 2;
let parity: any = 0;
/* Figure out the subsection parities */
for (let i = 0; i < n; i++) {
if (enc[i]) {
parity ^= i;
}
}
_build.unshift(_overallParity); // now we need the "overall" parity back in it's place
// try fix the actual encoded binary string if there is an error
if (_fixIndex > 0 && _testArray[0] == false) {
// if the overall is false and the sum of calculated values is greater equal 0, fix the corresponding hamming-bit
_build[_fixIndex] = _build[_fixIndex] == "0" ? "1" : "0";
} else if (_testArray[0] == false) {
// otherwise, if the the overall_parity is the only wrong, fix that one
_overallParity = _overallParity == "0" ? "1" : "0";
} else if (_testArray[0] == true && _testArray.some((truth) => truth == false)) {
return 0; // uhm, there's some strange going on... 2 bits are altered? How? This should not happen 👀
parity = parity.toString(2).split("").reverse();
parity.forEach((e: any, i: any, a: any) => {
a[i] = parseInt(e);
});
/* Set the parity bits accordingly */
for (let i = 0; i < m; i++) {
enc[2 ** i] = parity[i] ? 1 : 0;
}
// oof.. halfway through... we fixed an possible altered bit, now "extract" the parity-bits from the _build
for (let i = _sumParity; i >= 0; i--) {
// start from the last parity down the 2nd index one
_build.splice(Math.pow(2, i), 1);
parity = 0;
/* Figure out the overall parity for the entire block */
for (let i = 0; i < n; i++) {
if (enc[i]) {
parity++;
}
}
_build.splice(0, 1); // remove the overall parity bit and we have our binary value
return parseInt(_build.join(""), 2); // parse the integer with redux 2 and we're done!
/* Finally set the overall parity bit */
enc[0] = parity % 2 == 0 ? 0 : 1;
return enc.join("");
}
export function HammingDecode(data: string): number {
let err = 0;
const bits: Array<number> = [];
/* TODO why not just work with an array of digits from the start? */
for (const i in data.split("")) {
const bit = parseInt(data[i]);
bits[i] = bit;
if (bit) {
err ^= +i;
}
}
/* If err != 0 then it spells out the index of the bit that was flipped */
if (err) {
/* Flip to correct */
bits[err] = bits[err] ? 0 : 1;
}
/* Now we have to read the message, bit 0 is unused (it's the overall parity bit
* which we don't care about). Each bit at an index that is a power of 2 is
* a parity bit and not part of the actual message. */
let ans = "";
for (let i = 1; i < bits.length; i++) {
/* i is not a power of two so it's not a parity bit */
if ((i & (i - 1)) != 0) {
ans += bits[i];
}
}
/* TODO to avoid ambiguity about endianness why not let the player return the extracted (and corrected)
* data bits, rather than guessing at how to convert it to a decimal string? */
return parseInt(ans, 2);
}