This document defines a templated List class that implements a linked list data structure. The List class contains methods for initializing and destroying lists, inserting and removing elements, checking for emptiness, and iterating over elements using Iterator and ConstantIterator classes. Methods are provided for default construction, copy construction, assignment, insertion at beginning and end of list, removal, emptying the list, and beginning and end iteration.
I am Andrew O. I am a C Homework Expert at programminghomeworkhelp.com. I hold a master’s in Programming from, the University of Southampton, UK. I have been helping students with their homework for the past 10 years. I solve homework related to C.
Visit programminghomeworkhelp.com or email support@programminghomeworkhelp.com.
You can also call on +1 678 648 4277 for any assistance with C Homework.
I am Andrew O. I am a C Homework Expert at programminghomeworkhelp.com. I hold a master’s in Programming from, the University of Southampton, UK. I have been helping students with their homework for the past 10 years. I solve homework related to C.
Visit programminghomeworkhelp.com or email support@programminghomeworkhelp.com.
You can also call on +1 678 648 4277 for any assistance with C Homework.
This presentations gives an introduction to the data structure linked-lists. I discuss the implementation of header-based linked-lists in C. The presentation runs through the code and provides the visualization of the code w.r.t pointers.
Linked List Static and Dynamic Memory AllocationProf Ansari
Static variables are declared and named while writing the program. (Space for them exists as long as the program, in which they are declared, is running.) Static variables cannot be created or destroyed during execution of the program in which they are declared.
Dynamic variables are created (and may be destroyed) during program execution since dynamic variables do not exist while the program is compiled, but only when it is run, they cannot be assigned names while it is being written. The only way to access dynamic variables is by using pointers. Once it is created, however, a dynamic variable does contain data and must have a type like any other variable. If a dynamic variable is created in a function, then it can continue to exist even after the function terminates.
Linked Linear List
We saw in previous chapters how static representation of linear ordered list through Array leads to wastage of memory and in some cases overflows. Now we don't want to assign memory to any linear list in advance instead we want to allocate memory to elements as they are inserted in list. This requires Dynamic Allocation of memory and it can be achieved by using malloc() or calloc() function.
But memory assigned to elements will not be contiguous, which is a requirement for linear ordered list, and was provided by array representation. How we could achieve this?
This presentations gives an introduction to the data structure linked-lists. I discuss the implementation of header-based linked-lists in C. The presentation runs through the code and provides the visualization of the code w.r.t pointers.
Linked List Static and Dynamic Memory AllocationProf Ansari
Static variables are declared and named while writing the program. (Space for them exists as long as the program, in which they are declared, is running.) Static variables cannot be created or destroyed during execution of the program in which they are declared.
Dynamic variables are created (and may be destroyed) during program execution since dynamic variables do not exist while the program is compiled, but only when it is run, they cannot be assigned names while it is being written. The only way to access dynamic variables is by using pointers. Once it is created, however, a dynamic variable does contain data and must have a type like any other variable. If a dynamic variable is created in a function, then it can continue to exist even after the function terminates.
Linked Linear List
We saw in previous chapters how static representation of linear ordered list through Array leads to wastage of memory and in some cases overflows. Now we don't want to assign memory to any linear list in advance instead we want to allocate memory to elements as they are inserted in list. This requires Dynamic Allocation of memory and it can be achieved by using malloc() or calloc() function.
But memory assigned to elements will not be contiguous, which is a requirement for linear ordered list, and was provided by array representation. How we could achieve this?
This software will operate secretly in the background and it will monitor every movement on the PC. It can capture all chat room conversations, all emails, all passwords, record all keystrokes typed, and much more.
Please solve the TODO parts include LinkedListcpph tem.pdfaggarwalopticalsco
Please solve the TODO parts.
#include "LinkedListcpp.h"
template <class T>
class Queue: public LinkedList<T>{
//private: ListNode<T> * back;
public:
//Queue<T>();
void add(T t);
void remove();
void remove(std::string title);
};
#include "Queue.h"
//template <class T>
//Queue<T>::Queue(){
// back=nullptr;
//}
//TODO
// add an element t to the end of queue- implement using an existing LinkedList method.
template <class T>
void Queue<T>::add(T t){
}
//TODO
//remove an element from the front of the queue-implement using an existing LinkedList method
template <class T>
void Queue<T>::remove(){
//TODO
// if queue us empty
// throw new std::string("NULL POINTER EXCEPTION QUEUE IS EMPTY n");
}
#include <iostream>
#include <fstream>
#include <sstream>
#include<string>
#include "Queuecpp.h"
#include "Songcpp.h"
#include "RequestCpp.h"
void populateRequests(Queue<Request>& q);
void populateSongDataBase(LinkedList<Song> &list);
void processQueue(LinkedList<Song> &list,Queue<Request>& q);
void processRequest(std::string action, std::string title,std::string singer,int chartPos);
//GIVEN
int main() {
LinkedList<Song> list;
Queue<Request> q;
populateSongDataBase(list); // fill the Songs Data Base into Linked List
std::cout<<"*************************************n";
list.printList(); //
std::cout<<"*************************************n";
populateRequests(q); // fill the request q
std::cout<<"n";
std::cout<<"---------------PRINTING QUEUE-------------------n";
q.printList();
std::cout<<"------------------------------------n";
processQueue(list,q); // process the requests
std::cout<<"*************************************n";
list.printList();
std::cout<<"*************************************n";
}
//GIVEN
//Requires an empty linked list
//Effects fills the list with request by reading from the RequestData.txt
//Modifies the queue by filling it
void populateRequests(Queue<Request> &q){
}
//GIVEN
std::string playSong(LinkedList<Song>&list, Song s){
if (list.get(s)>=0){
return "PLAYING :"+ s.toString()+"n";
}
else{
return "SONG NOT FOUNDn";
}
}
//GIVEN
void printTopTenSongs(LinkedList<Song>& list){
std::cout<<"PLAYING TOP TEN SONG __________n";
list.print(10);
;
}
//Requires filled Song Database, a Song to add. The chart position given in the song is where it
will get added. Note this is a Song that is not supposed to exist in database.
//Effects adds the song from its original chart position
//Modifies the Song database. Adjust chart position of all Songs affected by this addition- this
adjustment is done in insert method using adjustPosition method. If the Process Queue adds a
Song that already is in the database, then a duplicate entry can occur.
//TODO
void addThisSong(LinkedList<Song> &list, Song s){
/* Use this code
if (found>=0) {std::cout<<"ADDED THIS SONG "<<found+1<<" " ;list.printSong(found+1);}
else std::cout<<"SORRY CANNOT FIND SONG n";
*/
}
//TODO
//Requires filled Song Database, a Song to remove
//Effects if found, removes the song from its original .
lab08/build.bat
@echo off
cls
set DRIVE_LETTER=%1:
set PATH=%DRIVE_LETTER%\MinGW\bin;%DRIVE_LETTER%\MinGW\msys\1.0\bin;%DRIVE_LETTER%\MinGW\gtkmm3\bin;%DRIVE_LETTER%\MinGW\gtk\bin;c:\Windows;c:\Windows\system32
set PROJECT_PATH=.
make DRIVE_LETTER="%DRIVE_LETTER%" PROJECT_DIR="%PROJECT_PATH%"
lab08/CSC2110/CD.h
#if !defined CD_H
#define CD_H
#include "Song.h"
#include "Text.h"
using CSC2110::String;
#include "ListArray.h"
using CSC2110::ListArray;
namespace CSC2110
{
class CD
{
private:
String* artist;
String* title;
int year;
int rating;
int num_tracks;
ListArray<Song>* songs;
public:
CD(String* artist, String* title, int year, int rating, int num_tracks);
virtual ~CD();
String* getKey();
void addSong(String* title, String* length);
void displayCD();
static ListArray<CD>* readCDs(const char* file_name);
static int compare_items(CD* one, CD* two);
static int compare_keys(String* sk, CD* cd);
static char getRadixChar(CD* cd, int index); //1-based
};
}
#endif
lab08/CSC2110/Double.h
#if !defined (DOUBLE_H)
#define DOUBLE_H
namespace CSC2110
{
class Double
{
private:
double value;
public:
Double(double val);
~Double();
double getValue();
};
}
#endif
lab08/CSC2110/HighPerformanceCounter.h
#if !defined (HIGHPERFORMANCECOUNTER_H)
#define HIGHPERFORMANCECOUNTER_H
namespace CSC2110
{
class HighPerformanceCounter
{
private:
double micro_spt; //micro_seconds per tick
HighPerformanceCounter();
static HighPerformanceCounter* hpc;
static int getTicksPerSecond();
public:
virtual ~HighPerformanceCounter();
static HighPerformanceCounter* getHighPerformanceCounter();
int getCurrentTimeInTicks();
double getTimeDifferenceInMicroSeconds(int start_time, int end_time);
};
}
#endif
lab08/CSC2110/Integer.h
#if !defined (INTEGER_H)
#define INTEGER_H
namespace CSC2110
{
class Integer
{
private:
int value;
public:
Integer(int val);
virtual ~Integer();
int getValue();
};
}
#endif
lab08/CSC2110/Keyboard.h
#if !defined KEYBOARD_H
#define KEYBOARD_H
#include "Text.h"
using CSC2110::String;
#include <string>
using namespace std;
namespace CSC2110
{
class Keyboard
{
private:
Keyboard();
public:
virtual ~Keyboard();
static Keyboard* getKeyboard();
//pre: the string (character literal) that will prompt the user for input
//post: the input read from the keyboard interpreted as an int is returned
int readInt(string prompt);
int getValidatedInt(string prompt, int min, int max);
//pre: the string that will prompt the user for input
//post: the input read from the keyboard interpreted as a double is returned
double readDouble(string prompt);
double getValidatedDouble(string prom ...
in C++ , Design a linked list class named IntegerList to hold a seri.pdfeyewaregallery
in C++ , Design a linked list class named IntegerList to hold a series of integers. The class must
have public member functions for appending , inserting, deleting and displaying nodes. The
append function must append a node to the end of the list. The insert function must insert node in
ascending order. The delete function must delete the node with the given value. The display
function should display the list from head to tail. The IntegerList class should also have a
destructor that destroys the list and release memory. The list node must be declared as a structure
using keyword struct. This structure is a private member of IntegerList. You should also store the
head of the list as a private member.
Write a test program to test the implementation your IntegerList class works properly.
Solution
Here is the code for the above scenario:
#include
using namespace std;
struct ListNode
{
float value;
ListNode *next;
};
ListNode *head;
class LinkedList
{
public:
int insertNode(float num);
int appendNode(float num);
void deleteNode(float num);
void destroyList();
void displayList();
LinkedList(void) {head = NULL;}
~LinkedList(void) {destroyList();}
};
int LinkedList::appendNode(float num)
{
ListNode *newNode, *nodePtr = head;
newNode = new ListNode;
if(newNode == NULL)
{
cout << \"Error allocating memory for new list member!\ \";
return 1;
}
newNode->value = num;
newNode->next = NULL;
if(head == NULL)
{
cout << \"List was empty - \" << newNode->value;
cout << \" is part of list\'s first node.\ \";
head = newNode;
}
else
{
while(nodePtr->next != NULL)
nodePtr = nodePtr->next;
nodePtr->next = newNode;
}
return 0;
}
int LinkedList::insertNode(float num)
{
struct ListNode *newNode, *nodePtr = head, *prevNodePtr = NULL;
newNode = new ListNode;
if(newNode == NULL)
{
cout << \"Error allocating memory for new list member!\ \";
return 1;
}
newNode->value = num;
newNode->next = NULL;
if(head==NULL) {
cout << \"List was empty - \" << newNode->value;
cout << \" is part of list\'s first node.\ \";
head = newNode;
}
else
{
while((nodePtr != NULL) && (nodePtr->value < num)) {
prevNodePtr = nodePtr;
nodePtr = nodePtr->next;
}
if(prevNodePtr==NULL)
newNode->next = head;
else
newNode->next = nodePtr; prevNodePtr->next = newNode;
}
return 0;
}
void LinkedList::deleteNode(float num)
{
struct ListNode *nodePtr = head, *prevNodePtr = NULL;
if(head==NULL) {
cout << \"The list was empty!\ \";
return;
}
if(head->value == num) {
head = nodePtr->next;
delete [] nodePtr;
}
else
{
while((nodePtr!= NULL)&&(nodePtr->value != num)) {
prevNodePtr = nodePtr;
nodePtr = nodePtr->next;
}
if(nodePtr==NULL)
cout << \"The value \" << num << \" is not in this list!\ \";
else {
prevNodePtr->next = nodePtr->next;
delete [] nodePtr;
}
}
}
void LinkedList::destroyList()
{
struct ListNode *nodePtr = head, *nextNode = nodePtr;
if(head==NULL) {
cout << \"The list is empty!\ \";
return;
}
while (nodePtr != NULL) {
nextNode = nodePtr->next;
delete [] nodePtr;
nodePtr = nextNode;
}
}
void LinkedList.
Please complete ALL of the �TO DO�s in this code. I am really strugg.pdfsupport58
Please complete ALL of the TO DOs in this code. I am really struggling with this assignment.
The last time I posted this question, they did not complete them all. Please do it! There are two
files, list.h and queue.h. I tried to complete this on my own and none of it worked, so I am
posting the template again instead of my nonworking code. Please do not use chatgpt, I think the
last person used it.
list.h:
#pragma once
#include // size_t
#include // std::bidirectional_iterator_tag
#include // std::is_same, std::enable_if
template
class List {
private:
struct Node {
Node *next, *prev;
T data;
explicit Node(Node* prev = nullptr, Node* next = nullptr)
: next{next}, prev{prev} {}
explicit Node(const T& data, Node* prev = nullptr, Node* next = nullptr)
: next{next}, prev{prev}, data{data} {}
explicit Node(T&& data, Node* prev = nullptr, Node* next = nullptr)
: next{next}, prev{prev}, data{std::move(data)} {}
};
template
class basic_iterator {
public:
using iterator_category = std::bidirectional_iterator_tag;
using value_type = T;
using difference_type = ptrdiff_t;
using pointer = pointer_type;
using reference = reference_type;
private:
friend class List;
using Node = typename List::Node;
Node* node;
explicit basic_iterator(Node* ptr) noexcept : node{ptr} {}
explicit basic_iterator(const Node* ptr) noexcept : node{const_cast(ptr)} {}
public:
basic_iterator() { /* TODO */ };
basic_iterator(const basic_iterator&) = default;
basic_iterator(basic_iterator&&) = default;
~basic_iterator() = default;
basic_iterator& operator=(const basic_iterator&) = default;
basic_iterator& operator=(basic_iterator&&) = default;
reference operator*() const {
// TODO
}
pointer operator->() const {
// TODO
}
// Prefix Increment: ++a
basic_iterator& operator++() {
// TODO
}
// Postfix Increment: a++
basic_iterator operator++(int) {
// TODO
}
// Prefix Decrement: --a
basic_iterator& operator--() {
// TODO
}
// Postfix Decrement: a--
basic_iterator operator--(int) {
// TODO
}
bool operator==(const basic_iterator& other) const noexcept {
// TODO
}
bool operator!=(const basic_iterator& other) const noexcept {
// TODO
}
};
public:
using value_type = T;
using size_type = size_t;
using difference_type = ptrdiff_t;
using reference = value_type&;
using const_reference = const value_type&;
using pointer = value_type*;
using const_pointer = const value_type*;
using iterator = basic_iterator;
using const_iterator = basic_iterator;
private:
Node head, tail;
size_type _size;
public:
List() {
// TODO - Don't forget to initialize the list beforehand
}
List( size_type count, const T& value ) {
// TODO - Don't forget initialize the list beforehand
}
explicit List( size_type count ) {
// TODO - Don't forget initialize the list beforehand
}
List( const List& other ) {
// TODO - Don't forget initialize the list beforehand
}
List( List&& other ) {
// TODO - Don't forget initialize the list beforehand
}
~List() {
// TODO
}
List& operator=( const List& other ) {
// TODO
}
List& operator=( List&& o.
C++ projectMachine Problem 7 - HashingWrite a program to do the .pdffeelinggift
C++ project
Machine Problem 7 - Hashing
Write a program to do the following:
loads username/password sets from the file password.txt and insert them into the hash table until
the end of file is reached on password.txt. The password.txt file will look something like this
with one username/password set per line.
mary changeMe!
The program will then present a login prompt, read one username, present a password prompt,
and after looking up the username\'s password in the hash table, will print either \"Authentication
successful\" or \"Authentication failure\".
The above step will be repeated until the end of the input data (EOF) is reached on the console
input stream (cin). The EOF character on the PC\'s is the CTRL Z character.
To convert from a string to an integer, we can add the ascii value of each character together. For
instance, Mary\'s conversion from string to integer might look something like this:
109(\'m\') + 97(\'a\') + 114(\'r\') + 121(\'y\')=441
We\'ve converted the string to an integer, but we still need to convert the integer to an index. For
an array of 10 elements we can divide by 10 and use the remainder as an index. Combining these
two hash functions, we will get Mary\'s index to be: 441 % 10 = 1
Your primary tasks for this homework are to edit the login.cpp to replace the comments with
lines so that it does the following:
Insert passwords into the Hash Table.
Retrieve one user\'s Password structure from the Hash Table.
Compare retrieved user password to input password and print \"Authentication failure\" or
\"Authentication successful.\"
//--------------------------------------------------------------------
//
// listlnk.h
//
//--------------------------------------------------------------------
#pragma warning( disable : 4290 )
#include
#include
#include
#include
#include
#include
#include
using namespace std;
template < class T > // Forward declaration of the List class
class List;
template < class T >
class ListNode // Facilitator class for the List class
{
private:
ListNode(const T &nodeData, ListNode *nextPtr);
T dataItem; // List data item
ListNode *next; // Pointer to the next list node
friend class List;
};
//--------------------------------------------------------------------
template < class T >
class List
{
public:
List(int ignored = 0);
~List();
void insert(const T &newData) throw (bad_alloc); // Insert after cursor
void remove() throw (logic_error); // Remove data item
void replace(const T &newData) throw (logic_error); // Replace data item
void clear();
bool isEmpty() const;
bool isFull() const;
// List iteration operations
void gotoBeginning() throw (logic_error);
void gotoEnd() throw (logic_error);
bool gotoNext();
bool gotoPrior();
T getCursor() const throw (logic_error); // Return item
void showStructure() const;
void moveToBeginning() throw (logic_error); // Move to beginning
void insertBefore(const T &newElement) throw (bad_alloc); // Insert before cursor
private:
ListNode *head, // Pointer to the beginni.
4) 15 points- Linked Lists- Consider the linked list template-type.docxKevinrDQBowerq
4) 15 points. Linked Lists.
Consider the linked list
template<typename T>
class Node
{
public:
Node();
Node(T value, Node<T>* nextNode);
T data;
Node<T>* next;
};
template<typename T>
class LinkedList
{
public:
LinkedList();
Node<T>* getHead() const; // return the head pointer
Node<T>* getTail() const; // returns the tail pointer
void listAppend(T value); // inserts an element at the end of the list
void listPrepend(T value); //inserts a n element at the head of the list
void insertAfter(Node<T>* curNode, T value); // Insert value after the curNode
void removeAfter(Node<T>* curNode); // remove Node after CurNode
void removeHead(); // Removes the first element
void removeTail(); // removes the last element
void printList() const; // print the elements of the linked list
private:
Node<T>* head;
Node<T>* tail;
};
Write a template function that receives the head node of a singly Linked list void printEven(Node<T> * i) . The function goes through the list and prints all the even elements in the list.
template<typename T> // may use <int> for the type T. T is assumed to be int
void LinkedList<T>::PrintEven(Node<T>* i)
{
// Your code goes here.
}
.
Assume a list has the following element- write a function to interch.docxolsenlinnea427
Assume a list has the following element:
write a function to interchange the first two elements in the right partition of a list.
Please help to fix the code!
#include <iostream>
#include <list>
template<typename Elem>
void interchangeFirstTwo(std::list<Elem>& list) {
if (list.size() < 2) return;
typename std::list<Elem>::iterator it = list.begin();
Elem value1 = *it;
++it;
Elem value2 = *it;
list.erase(list.begin(), std::next(list.begin(), 2));
list.insert(list.begin(), value2);
list.insert(list.begin(), value1);
}
int main() {
std::list<int> list = { 2, 23, 15, 5, 9 };
std::cout << "Original list: ";
for (int value : list) {
std::cout << value << " ";
}
std::cout << std::endl;
interchangeFirstTwo(list);
std::cout << "After interchanging first two elements: ";
for (int value : list) {
std::cout << value << " ";
}
std::cout << std::endl;
return 0;
}
.
public class SLLT { protected SLLNodeT head, tail; pub.pdfclarityvision
public class SLL { protected SLLNode head, tail; public SLL() { head = tail = null;
} public void addToTail(T e){ SLLNode newNode = new SLLNode(e); if(head ==
null) head = tail = newNode; else{ tail.next = newNode; tail =
tail.next; } } public void addToHead(T e) { SLLNode newNode = new
SLLNode(e, head); if(head == null) tail = newNode; head = newNode; }
public String toString(){ if (head == null) return "[]"; String out = "[";
SLLNode p = head; while (p.next != null){ out += p.info + " "; p = p.next;
} out += p.info + "]"; return out; } }
public class SLLNode { protected T info; protected SLLNode next; public SLLNode() {
this(null, null); } public SLLNode(T e) { this(e, null); } public SLLNode(T
e, SLLNode ptr) { info = e; next = ptr; } }
public class SortedSLL> extends SLL{ public void insert(T e){ } public void
merge(SortedSLL list){ } }
public class SortedSLL T extends Comparable T extends SLLT{ public void insert (T e) \{ \}
public void merge(SortedSLL T list) \{ \} public class SortedSLL T extends Comparable T
extends SLLT{ public void insert ( T e) \{ \} public void merge(SortedSLL T list) \{ \} \}
ublic class SLLT{ protected SLLNodeT head, tail; public SLL() \{ head = tail = null; \} public
void addToTail( T e) \{ SLLNode newNode = new SLLNodeT(e); if ( head == null) head = tail
= newNode; else\{ tail. next = newNode; tail = tail. next; \} \} public void addToHead( T e) \{
SLLNode T newNode = new SLLNodeT(e, head ); if (head == null) tail = newNode; head =
newNode; \} public string tostring()\{ if (head == null) return "[]"; String out = "["; SLLNode
Tp= head; while (p.next != null) \{ out +=p.info +" "; p=p next; \} out += p.info + "]"; return out;
\}
ublic class SLLNode T{ protected T info; protected SLLNode T next; public SLLNode() \{
this(null, null); \} public SLLNode( T e) \{ this (e, null); \} public SLLNode( T e, SLLNode T
ptr ){ info =e; next =ptr; \}
Write a subclass of SLL named SortedSLL that represents a sorted SinglyLinkedList (sorted in
nondecending order). The class should contain the following methods: 1- [40 Points] void insert
( T e) that inserts an SLLNode in its correct position so that the resulting list remains sorted.
Make sure to consider special cases such as: - The list is empty. - The list has one element. - The
inserted element is smaller than the head, or larger than the tail.. 2- [60 Points] void
merge(SortedSLL T list) that merges the calling list with the argument list. Note that this can be
done by calling the insert method for each element in list, but this is highly ineffiecient, answer
the following question: Q2.1: What is the complexity of this approach? Explain. [10 Points]
Instead, you should come up with a solution that traverse both lists just one time. Furthermore,
the argument list should be empty after the merge is completed. Q2.2: What is the complexity of
this approach? Explain. [10 Points] Hint: Make sure the class SortedSLL accepts types T that is
comparable. You can do this by writing .
The Indian economy is classified into different sectors to simplify the analysis and understanding of economic activities. For Class 10, it's essential to grasp the sectors of the Indian economy, understand their characteristics, and recognize their importance. This guide will provide detailed notes on the Sectors of the Indian Economy Class 10, using specific long-tail keywords to enhance comprehension.
For more information, visit-www.vavaclasses.com
How to Create Map Views in the Odoo 17 ERPCeline George
The map views are useful for providing a geographical representation of data. They allow users to visualize and analyze the data in a more intuitive manner.
Unit 8 - Information and Communication Technology (Paper I).pdfThiyagu K
This slides describes the basic concepts of ICT, basics of Email, Emerging Technology and Digital Initiatives in Education. This presentations aligns with the UGC Paper I syllabus.
The French Revolution, which began in 1789, was a period of radical social and political upheaval in France. It marked the decline of absolute monarchies, the rise of secular and democratic republics, and the eventual rise of Napoleon Bonaparte. This revolutionary period is crucial in understanding the transition from feudalism to modernity in Europe.
For more information, visit-www.vavaclasses.com
How to Make a Field invisible in Odoo 17Celine George
It is possible to hide or invisible some fields in odoo. Commonly using “invisible” attribute in the field definition to invisible the fields. This slide will show how to make a field invisible in odoo 17.
Read| The latest issue of The Challenger is here! We are thrilled to announce that our school paper has qualified for the NATIONAL SCHOOLS PRESS CONFERENCE (NSPC) 2024. Thank you for your unwavering support and trust. Dive into the stories that made us stand out!
