LAB 01

Question01:
You are provided with a dataset representing temperatures at different points in a room over time. Write
a C++ program to read this dataset into a 3D array. Once the data is loaded, find and display the
maximum temperature recorded in the room along with its location (coordinates) within the array. write
code

Soution:

#include <iostream>

const int ROOM_WIDTH = 5;

const int ROOM_LENGTH = 4;

const int ROOM_HEIGHT = 3;

void findMaxTemperature(const double roomTemperatures[ROOM_HEIGHT][ROOM_LENGTH]

double maxTemperature = roomTemperatures[0][0][0];

int maxX = 0, maxY = 0, maxZ = 0;

for (int z = 0; z < ROOM_HEIGHT; ++z) {

for (int y = 0; y < ROOM_LENGTH; ++y) {

for (int x = 0; x < ROOM_WIDTH; ++x) {

if (roomTemperatures[z][y][x] > maxTemperature) {

maxTemperature = roomTemperatures[z][y][x];

maxX = x;

maxY = y;

maxZ = z;

}
 }

std::cout << "Maximum temperature recorded: " << maxTemperature << "°C\n";

std::cout << "Location (X, Y, Z): (" << maxX << ", " << maxY << ", " << maxZ << ")\n";

int main() {

double roomTemperatures[ROOM_HEIGHT][ROOM_LENGTH][ROOM_WIDTH] = {

{{22.5, 23.1, 21.8, 20.3, 24.0}, {25.2, 26.5, 27.8, 28.3, 25.9}, {23.4, 24.7, 26.2, 27.1, 28.6}, {22.8, 21.4,
20.9, 20.1, 19.7}},

{{20.7, 22.3, 23.9, 22.4, 21.1}, {24.6, 25.9, 27.3, 28.6, 25.9}, {22.8, 24.1, 25.6, 27.2, 28.7}, {21.2, 20.8,
20.3, 19.9, 18.7}},

{{18.5, 19.1, 17.8, 16.3, 19.0}, {21.2, 22.5, 23.8, 24.3, 21.9}, {19.4, 20.7, 22.2, 23.1, 24.6}, {18.8, 17.4,
16.9, 16.1, 15.7}}

};

findMaxTemperature(roomTemperatures);

return 0;

Question02:
Design a C++ program to manage inventory in a warehouse using a 3D array. Each element of the array
should represent the quantity of a specific item stored at a particular location (aisle, shelf, bin).
Implement functions to add, remove, and display the quantity of a specific item at a given location.

Soution:
#include <iostream>

const int MAX_AISLES = 5;

const int MAX_SHELVES = 10;

// Function to add quantity of an item at a specific location

void addItem(int inventory[MAX_AISLES][MAX_SHELVES][MAX_BINS], int aisle, int shelf, int bin, int
quantity) {

inventory[aisle][shelf][bin] += quantity;

// Function to remove quantity of an item from a specific location

void removeItem(int inventory[MAX_AISLES][MAX_SHELVES][MAX_BINS], int aisle, int shelf, int bin, int
quantity) {

inventory[aisle][shelf][bin] -= quantity;

if (inventory[aisle][shelf][bin] < 0) {

std::cerr << "Error: Insufficient quantity available at specified location.\n";

inventory[aisle][shelf][bin] += quantity; // Revert back to original quantity

// Function to display quantity of an item at a specific location

void displayItemQuantity(const int inventory[MAX_AISLES][MAX_SHELVES][MAX_BINS], int aisle, int

std::cout << "Quantity of item at location (" << aisle << ", " << shelf << ", " << bin << "): "

<< inventory[aisle][shelf][bin] << std::endl;

int main() {

int warehouseInventory[MAX_AISLES][MAX_SHELVES][MAX_BINS] = {0}; // Initialize inventory to zero

// Example usage:

addItem(warehouseInventory, 2, 3, 1, 50); // Add 50 items to aisle 2, shelf 3, bin 1

removeItem(warehouseInventory, 2, 3, 1, 20); // Remove 20 items from aisle 2, shelf 3, bin 1

displayItemQuantity(warehouseInventory, 2, 3, 1); // Display updated quantity at specified location

return 0;

Question03:
Develop a C++ program to simulate a 3D Tic-Tac-Toe game using a 3D array. The program should allow
two players to take turns marking cells in the 3D grid. Ensure that the game board is represented using a
3D array, and implement functions to check for winning combinations in all three dimensions.

Soution:
#include <iostream>

const int BOARD_SIZE = 3;

char board[BOARD_SIZE][BOARD_SIZE][BOARD_SIZE];

// Initialize the game board

void initializeBoard() {

for (int i = 0; i < BOARD_SIZE; ++i) {

for (int j = 0; j < BOARD_SIZE; ++j) {

for (int k = 0; k < BOARD_SIZE; ++k) {

board[i][j][k] = ' ';

}
// Display the current state of the board

void displayBoard() {

for (int i = 0; i < BOARD_SIZE; ++i) {

std::cout << "Layer " << i + 1 << ":\n";

for (int j = 0; j < BOARD_SIZE; ++j) {

for (int k = 0; k < BOARD_SIZE; ++k) {

std::cout << board[i][j][k];

if (k < BOARD_SIZE - 1) {

std::cout << " | ";

std::cout << std::endl;

if (j < BOARD_SIZE - 1) {

std::cout << "---------\n";

std::cout << std::endl;

// Check if a player has won the game

bool checkWin(char player) {

// Check rows

for (int i = 0; i < BOARD_SIZE; ++i) {

for (int j = 0; j < BOARD_SIZE; ++j) {

if (board[i][j][0] == player && board[i][j][1] == player && board[i][j][2] == player) {

return true;

}
}

// Check columns

for (int i = 0; i < BOARD_SIZE; ++i) {

for (int j = 0; j < BOARD_SIZE; ++j) {

if (board[i][0][j] == player && board[i][1][j] == player && board[i][2][j] == player) {

return true;

// Check diagonals

for (int i = 0; i < BOARD_SIZE; ++i) {

if (board[i][0][0] == player && board[i][1][1] == player && board[i][2][2] == player) {

return true;

if (board[i][0][2] == player && board[i][1][1] == player && board[i][2][0] == player) {

return true;

// Check layers

for (int i = 0; i < BOARD_SIZE; ++i) {

for (int j = 0; j < BOARD_SIZE; ++j) {

if (board[0][i][j] == player && board[1][i][j] == player && board[2][i][j] == player) {

return true;

}
 // Check diagonals in 3D

if (board[0][0][0] == player && board[1][1][1] == player && board[2][2][2] == player) {

return true;

if (board[0][0][2] == player && board[1][1][1] == player && board[2][2][0] == player) {

return true;

if (board[0][2][0] == player && board[1][1][1] == player && board[2][0][2] == player) {

return true;

if (board[0][2][2] == player && board[1][1][1] == player && board[2][0][0] == player) {

return true;

return false;

// Check if the game board is full (tie)

bool checkTie() {

for (int i = 0; i < BOARD_SIZE; ++i) {

for (int j = 0; j < BOARD_SIZE; ++j) {

for (int k = 0; k < BOARD_SIZE; ++k) {

if (board[i][j][k] == ' ') {

return false;

}
 return true;

// Main game loop

void playGame() {

char currentPlayer = 'X';

int row, col, layer;

initializeBoard();

while (true) {

std::cout << "Player " << currentPlayer << "'s turn. Enter row, column, and layer (1-3): ";

std::cin >> row >> col >> layer;

// Adjust to 0-based indexing

row--; col--; layer--;

// Check if the cell is empty

if (board[layer][row][col] == ' ') {

board[layer][row][col] = currentPlayer;

displayBoard();

// Check for a win

if (checkWin(currentPlayer)) {

std::cout << "Player " << currentPlayer << " wins!\n";

break;

}
 // Check for a tie

if (checkTie()) {

std::cout << "It's a tie!\n";

break;

// Switch player

currentPlayer = (currentPlayer == 'X') ? 'O' : 'X';

} else {

std::cout << "Cell already occupied. Please try again.\n";

int main() {

std::cout << "Welcome to 3D Tic-Tac-Toe!\n";

playGame();

return 0;

Question04:
Write a C++ program that creates a 3D array of integers. Implement functions to populate the array with
random values, display the array contents, and find the sum of all elements in the array.

Soution:
#include <iostream>

#include <cstdlib> // For rand() and srand()

#include <ctime> // For time()

// Define constants for array dimensions

const int X_DIM = 3;

const int Z_DIM = 3;

// Function to populate the 3D array with random values

void populateArray(int array[X_DIM][Y_DIM][Z_DIM]) {

// Seed the random number generator

srand(time(NULL));

// Populate the array with random values

for (int x = 0; x < X_DIM; ++x) {

for (int y = 0; y < Y_DIM; ++y) {

for (int z = 0; z < Z_DIM; ++z) {

array[x][y][z] = rand() % 100; // Generate random values between 0 and 99

// Function to display the contents of the 3D array

void displayArray(const int array[X_DIM][Y_DIM][Z_DIM]) {

std::cout << "Array Contents:\n";

for (int x = 0; x < X_DIM; ++x) {

for (int y = 0; y < Y_DIM; ++y) {

for (int z = 0; z < Z_DIM; ++z) {

std::cout << array[x][y][z] << " ";

std::cout << std::endl;

std::cout << std::endl;

// Function to find the sum of all elements in the 3D array

int findArraySum(const int array[X_DIM][Y_DIM][Z_DIM]) {

int sum = 0;

for (int x = 0; x < X_DIM; ++x) {

for (int y = 0; y < Y_DIM; ++y) {

for (int z = 0; z < Z_DIM; ++z) {

sum += array[x][y][z];

return sum;

int main() {

int array[X_DIM][Y_DIM][Z_DIM];

// Populate the array with random values

populateArray(array);

// Display the contents of the array

displayArray(array);

// Find the sum of all elements in the array

int sum = findArraySum(array);

std::cout << "Sum of all elements in the array: " << sum << std::endl;
 return 0;

Question05:
Create a C++ program that generates a random 3D array of integers. Implement functions to calculate
and display basic statistics such as the sum, average, maximum, and minimum values of the elements in
the array.

Soution:
#include <iostream>

#include <cstdlib> // For rand() and srand()

#include <ctime> // For time()

// Constants for array dimensions

const int X_DIM = 3;

const int Y_DIM = 3;

const int Z_DIM = 3;

// Function to generate a random integer between min and max (inclusive)

int getRandomInt(int min, int max) {

return rand() % (max - min + 1) + min;

// Function to fill the 3D array with random integers

void fillRandomArray(int array[X_DIM][Y_DIM][Z_DIM], int minVal, int maxVal) {

for (int i = 0; i < X_DIM; ++i) {

for (int j = 0; j < Y_DIM; ++j) {

for (int k = 0; k < Z_DIM; ++k) {

array[i][j][k] = getRandomInt(minVal, maxVal);

}
 }

// Function to calculate the sum of all elements in the array

int calculateSum(const int array[X_DIM][Y_DIM][Z_DIM]) {

int sum = 0;

for (int i = 0; i < X_DIM; ++i) {

for (int j = 0; j < Y_DIM; ++j) {

for (int k = 0; k < Z_DIM; ++k) {

sum += array[i][j][k];

return sum;

// Function to calculate the average of all elements in the array

double calculateAverage(const int array[X_DIM][Y_DIM][Z_DIM]) {

int sum = calculateSum(array);

return static_cast<double>(sum) / (X_DIM * Y_DIM * Z_DIM);

// Function to find the maximum value in the array

int findMax(const int array[X_DIM][Y_DIM][Z_DIM]) {

int maxVal = array[0][0][0];

for (int i = 0; i < X_DIM; ++i) {

for (int j = 0; j < Y_DIM; ++j) {

for (int k = 0; k < Z_DIM; ++k) {

if (array[i][j][k] > maxVal) {

return maxVal;

// Function to find the minimum value in the array

int findMin(const int array[X_DIM][Y_DIM][Z_DIM]) {

int minVal = array[0][0][0];

for (int i = 0; i < X_DIM; ++i) {

for (int j = 0; j < Y_DIM; ++j) {

for (int k = 0; k < Z_DIM; ++k) {

if (array[i][j][k] < minVal) {

minVal = array[i][j][k];

return minVal;

int main() {

// Seed the random number generator

srand(time(NULL));

// Generate random 3D array of integers

int randomArray[X_DIM][Y_DIM][Z_DIM];
 fillRandomArray(randomArray, 1, 100); // Fill with random integers between 1 and 100

// Display the random array

std::cout << "Random 3D Array:\n";

for (int i = 0; i < X_DIM; ++i) {

for (int j = 0; j < Y_DIM; ++j) {

for (int k = 0; k < Z_DIM; ++k) {

std::cout << randomArray[i][j][k] << " ";

std::cout << std::endl;

std::cout << std::endl;

// Calculate and display basic statistics

int sum = calculateSum(randomArray);

double average = calculateAverage(randomArray);

int maxVal = findMax(randomArray);

int minVal = findMin(randomArray);

std::cout << "\nBasic Statistics:\n";

std::cout << "Sum: " << sum << std::endl;

std::cout << "Average: " << average << std::endl;

std::cout << "Maximum: " << maxVal << std::endl;

std::cout << "Minimum: " << minVal << std::endl;

return 0;

}
Question 06:
write a c++ code that allows the user to slice a 4d array to exract 3d subarray based on specified
dimensions and indices. implement a function using pointers that takes the orignal 4d array user
defined slicing parameter and returns the sliced 3d array return complete runnig code

Solution:
#include <iostream>

using namespace std;

// Function to take input for the 4D array

void inputArray(int a[2][2][2][2]) {

for (int i = 0; i < 2; i++) {

for (int j = 0; j < 2; j++) {

for (int k = 0; k < 2; k++) {

for (int l = 0; l < 2; l++) {

cout << "Enter value of a[" << i << "][" << j << "][" << k << "][" << l << "]: ";

cin >> a[i][j][k][l];

// Function to slice the 4D array and print the sliced 3D subarray

void sliceAndPrint(int* a, int dim1, int dim2, int dim3, int idx1, int idx2, int idx3) {

cout << "Sliced 3D subarray for dimensions [" << dim1 << "][" << dim2 << "][" << dim3 << "] and indices
[" << idx1 << "][" << idx2 << "][" << idx3 << "]:" << endl;

for (int i = 0; i < 2; i++) {

cout << "[";

for (int j = 0; j < 2; j++) {

cout << "[";

int index1, index2, index3, index4;

if (dim1 == 0) {

index1 = idx1;

} else {

index1 = i;

if (dim2 == 1) {

index2 = idx2;

} else {

index2 = j;

if (dim3 == 2) {

index3 = idx3;

} else {

index3 = k;

if (dim3 == 3) {

index4 = idx3;

} else {

index4 = k;

cout << *((a + index1 * 8 + index2 * 4 + index3 * 2) + index4) << " ";
 }

cout << "]";

cout << "]" << endl;

int main() {

// Array declaration

int a[2][2][2][2];

// Function call to take input for the array

inputArray(a);

// User input for slicing

int dim1, dim2, dim3, idx1, idx2, idx3;

cout << "Enter dimensions to slice (0, 1, or 2) and indices to slice (0 or 1) (dim1 dim2 dim3 idx1 idx2
idx3): ";

cin >> dim1 >> dim2 >> dim3 >> idx1 >> idx2 >> idx3;

// Calling the function to slice and print

sliceAndPrint((int*)a, dim1, dim2, dim3, idx1, idx2, idx3);

return 0;

Question 07:
write a c++ program that searches for a specific element in a 4d array using pointer. if is found,
replace it with a user-specified value . ensure that the program handles multiple occurence of
the elemnt correctly
Solution:
#include <iostream>

using namespace std;

void searchAndReplace(int**** arr, int size, int target, int replace) {

for (int i = 0; i < size; ++i) {

for (int j = 0; j < size; ++j) {

for (int k = 0; k < size; ++k) {

for (int l = 0; l < size; ++l) {

int temp = (*(*(*(*(arr + i) + j) + k) + l)); // Dereference variable

if (temp == target) {

*(*(*(*(arr + i) + j) + k) + l) = replace; // Dereference variable

int main() {

int size;

cout << "Enter the size of each dimension of the 4D array: ";

cin >> size;

int**** arr = new int***[size];

for (int i = 0; i < size; ++i) {

arr[i] = new int**[size];

for (int j = 0; j < size; ++j) {

arr[i][j] = new int*[size];

arr[i][j][k] = new int[size];

for (int l = 0; l < size; ++l) {

cout << "Enter value of arr[" << i << "][" << j << "][" << k << "][" << l << "]: ";

cin >> *(*(*(*(arr + i) + j) + k) + l);

int target, replace;

cout << "Enter the element to search for: ";

cin >> target;

cout << "Enter the value to replace with: ";

cin >> replace;

searchAndReplace(arr, size, target, replace);

cout << "4D array after replacement:\n";

for (int i = 0; i < size; ++i) {

for (int j = 0; j < size; ++j) {

for (int k = 0; k < size; ++k) {

for (int l = 0; l < size; ++l) {

cout << arr[i][j][k][l] << " ";

cout << endl;

cout << endl;

}
 cout << endl;

// Deallocate memory

for (int i = 0; i < size; ++i) {

for (int j = 0; j < size; ++j) {

for (int k = 0; k < size; ++k) {

delete[] arr[i][j][k];

delete[] arr[i][j];

delete[] arr[i];

delete[] arr;

return 0;