summaryrefslogtreecommitdiff
path: root/exercises/097_bit_manipulation.zig
diff options
context:
space:
mode:
Diffstat (limited to 'exercises/097_bit_manipulation.zig')
-rw-r--r--exercises/097_bit_manipulation.zig95
1 files changed, 0 insertions, 95 deletions
diff --git a/exercises/097_bit_manipulation.zig b/exercises/097_bit_manipulation.zig
deleted file mode 100644
index 0e64ad7..0000000
--- a/exercises/097_bit_manipulation.zig
+++ /dev/null
@@ -1,95 +0,0 @@
-//
-// Bit manipulation is a very powerful tool, also from Zig.
-// Since the dawn of the computer age, numerous algorithms have been
-// developed that solve tasks solely by moving, setting, or logically
-// combining bits.
-//
-// Zig also uses direct bit manipulation in its standard library for
-// functions where possible. And it is often possible with calculations
-// based on integers.
-//
-// At first glance, it is often not easy to understand what exactly these
-// algorithms do when only "numbers" in memory areas change outwardly.
-// However, it should never be forgotten that the numbers only represent
-// the interpretation of the bit sequences.
-//
-// Quasi the reversed case we have otherwise, namely that we represent
-// numbers in bit sequences.
-//
-// We remember: 1 byte = 8 bits = 11111111 = 255 decimal = FF hex.
-//
-// Zig provides all the necessary functions to change the bits inside
-// a variable. It is distinguished whether the bit change leads to an
-// overflow or not. The details are in the Zig documentation in section
-// "Table of Operators".
-//
-// Here are some examples of how the bits of variables can be changed:
-//
-// const numOne: u8 = 15; // = 0000 1111
-// const numTwo: u8 = 245; // = 1111 0101
-//
-// const res1 = numOne >> 4; // = 0000 0000 - shift right
-// const res2 = numOne << 4; // = 1111 0000 - shift left
-// const res3 = numOne & numTwo; // = 0000 0101 - and
-// const res4 = numOne | numTwo; // = 1111 1111 - or
-// const res5 = numOne ^ numTwo; // = 1111 1010 - xor
-//
-//
-// To familiarize ourselves with bit manipulation, we start with a simple
-// but often underestimated function and then add other exercises in
-// loose order.
-//
-// The following text contains excerpts from Wikipedia.
-//
-// Swap
-// In computer programming, the act of swapping two variables refers to
-// mutually exchanging the values of the variables. Usually, this is
-// done with the data in memory. For example, in a program, two variables
-// may be defined thus (in pseudocode):
-//
-// data_item x := 1
-// data_item y := 0
-//
-// swap (x, y);
-//
-// After swap() is performed, x will contain the value 0 and y will
-// contain 1; their values have been exchanged. The simplest and probably
-// most widely used method to swap two variables is to use a third temporary
-// variable:
-//
-// define swap (x, y)
-// temp := x
-// x := y
-// y := temp
-//
-// However, with integers we can also achieve the swap function simply by
-// bit manipulation. To do this, the variables are mutually linked with xor
-// and the result is the same.
-
-const std = @import("std");
-const print = std.debug.print;
-
-pub fn main() !void {
-
- // Let us use 1101 and 1011 as values for x and y
- var x: u8 = 0b1101;
- var y: u8 = 0b1011;
-
- // Now we swap the values of the two variables by doing xor on them
- x ^= y;
- y ^= x;
-
- // What must be written here?
- ???;
-
- print("x = {b}; y = {b}\n", .{ x, y });
-}
-
-// This variable swap takes advantage of the fact that the value resulting
-// from the xor of two values contains both of these values.
-// This circumstance was (and still is) sometimes used for encryption.
-// Value XOR Key = Crypto. => Crypto XOR Key = Value.
-// Since this can be swapped arbitrarily, you can swap two variables in this way.
-//
-// For Crypto it is better not to use this, but in sorting algorithms like
-// Bubble Sort it works very well.