Hackerrank Print in Reverse problem solution YASH PAL, 31 July 2024 In this HackerRank Print in Reverse problem, we need to develop a program in which if we have given a pointer to the head of a singly linked list then we need to print each value of the linked list in the reversed order. and if the given list is empty, then we don’t need to print anything.Problem solution in Python programming.#!/bin/python3 import math import os import random import re import sys class SinglyLinkedListNode: def __init__(self, node_data): self.data = node_data self.next = None class SinglyLinkedList: def __init__(self): self.head = None self.tail = None def insert_node(self, node_data): node = SinglyLinkedListNode(node_data) if not self.head: self.head = node else: self.tail.next = node self.tail = node def print_singly_linked_list(node, sep): while node: print(node.data, end='') node = node.next if node: print(sep, end='') def reversePrint(head): elements = [] while(head != None): elements.append(head.data) head=head.next elements = elements[::-1] for element in elements: print (element) if __name__ == '__main__': tests = int(input()) for tests_itr in range(tests): llist_count = int(input()) llist = SinglyLinkedList() for _ in range(llist_count): llist_item = int(input()) llist.insert_node(llist_item) reversePrint(llist.head)Problem solution in Java Programming.import java.io.*; import java.math.*; import java.security.*; import java.text.*; import java.util.*; import java.util.concurrent.*; import java.util.regex.*; public class Solution { static class SinglyLinkedListNode { public int data; public SinglyLinkedListNode next; public SinglyLinkedListNode(int nodeData) { this.data = nodeData; this.next = null; } } static class SinglyLinkedList { public SinglyLinkedListNode head; public SinglyLinkedListNode tail; public SinglyLinkedList() { this.head = null; this.tail = null; } public void insertNode(int nodeData) { SinglyLinkedListNode node = new SinglyLinkedListNode(nodeData); if (this.head == null) { this.head = node; } else { this.tail.next = node; } this.tail = node; } } public static void printSinglyLinkedList(SinglyLinkedListNode node, String sep) { while (node != null) { System.out.print(node.data); node = node.next; if (node != null) { System.out.print(sep); } } } static void reversePrint(SinglyLinkedListNode head) { if (head == null) return; // print list of head node reversePrint(head.next); // After everything else is printed System.out.println(head.data+" "); } private static final Scanner scanner = new Scanner(System.in); public static void main(String[] args) { int tests = scanner.nextInt(); scanner.skip("(rn|[nru2028u2029u0085])?"); for (int testsItr = 0; testsItr < tests; testsItr++) { SinglyLinkedList llist = new SinglyLinkedList(); int llistCount = scanner.nextInt(); scanner.skip("(rn|[nru2028u2029u0085])?"); for (int i = 0; i < llistCount; i++) { int llistItem = scanner.nextInt(); scanner.skip("(rn|[nru2028u2029u0085])?"); llist.insertNode(llistItem); } reversePrint(llist.head); } scanner.close(); } } Problem solution in C++ programming.#include <bits/stdc++.h> using namespace std; class SinglyLinkedListNode { public: int data; SinglyLinkedListNode *next; SinglyLinkedListNode(int node_data) { this->data = node_data; this->next = nullptr; } }; class SinglyLinkedList { public: SinglyLinkedListNode *head; SinglyLinkedListNode *tail; SinglyLinkedList() { this->head = nullptr; this->tail = nullptr; } void insert_node(int node_data) { SinglyLinkedListNode* node = new SinglyLinkedListNode(node_data); if (!this->head) { this->head = node; } else { this->tail->next = node; } this->tail = node; } }; void print_singly_linked_list(SinglyLinkedListNode* node, string sep) { while (node) { cout << node->data; node = node->next; if (node) { cout << sep; } } } void free_singly_linked_list(SinglyLinkedListNode* node) { while (node) { SinglyLinkedListNode* temp = node; node = node->next; free(temp); } } void reversePrint(SinglyLinkedListNode* head) { if(head == NULL) { return; } reversePrint(head->next); cout << head->data << endl; } int main() { int tests; cin >> tests; cin.ignore(numeric_limits<streamsize>::max(), 'n'); for (int tests_itr = 0; tests_itr < tests; tests_itr++) { SinglyLinkedList* llist = new SinglyLinkedList(); int llist_count; cin >> llist_count; cin.ignore(numeric_limits<streamsize>::max(), 'n'); for (int i = 0; i < llist_count; i++) { int llist_item; cin >> llist_item; cin.ignore(numeric_limits<streamsize>::max(), 'n'); llist->insert_node(llist_item); } reversePrint(llist->head); } return 0; } Problem solution in C programming.#include <assert.h> #include <limits.h> #include <math.h> #include <stdbool.h> #include <stddef.h> #include <stdint.h> #include <stdio.h> #include <stdlib.h> #include <string.h> char* readline(); typedef struct SinglyLinkedListNode SinglyLinkedListNode; typedef struct SinglyLinkedList SinglyLinkedList; struct SinglyLinkedListNode { int data; SinglyLinkedListNode* next; }; struct SinglyLinkedList { SinglyLinkedListNode* head; SinglyLinkedListNode* tail; }; SinglyLinkedListNode* create_singly_linked_list_node(int node_data) { SinglyLinkedListNode* node = malloc(sizeof(SinglyLinkedListNode)); node->data = node_data; node->next = NULL; return node; } void insert_node_into_singly_linked_list(SinglyLinkedList** singly_linked_list, int node_data) { SinglyLinkedListNode* node = create_singly_linked_list_node(node_data); if (!(*singly_linked_list)->head) { (*singly_linked_list)->head = node; } else { (*singly_linked_list)->tail->next = node; } (*singly_linked_list)->tail = node; } void print_singly_linked_list(SinglyLinkedListNode* node, char* sep) { while (node) { printf("%d", node->data); node = node->next; if (node) { printf("%s", sep); } } } void free_singly_linked_list(SinglyLinkedListNode* node) { while (node) { SinglyLinkedListNode* temp = node; node = node->next; free(temp); } } void reversePrint(SinglyLinkedListNode* head) { if(head == NULL) return; else{ reversePrint(head->next); printf("%dn",head->data); } } int main() { char* tests_endptr; char* tests_str = readline(); int tests = strtol(tests_str, &tests_endptr, 10); if (tests_endptr == tests_str || *tests_endptr != ' ') { exit(EXIT_FAILURE); } for (int tests_itr = 0; tests_itr < tests; tests_itr++) { SinglyLinkedList* llist = malloc(sizeof(SinglyLinkedList)); llist->head = NULL; llist->tail = NULL; char* llist_count_endptr; char* llist_count_str = readline(); int llist_count = strtol(llist_count_str, &llist_count_endptr, 10); if (llist_count_endptr == llist_count_str || *llist_count_endptr != ' ') { exit(EXIT_FAILURE); } for (int i = 0; i < llist_count; i++) { char* llist_item_endptr; char* llist_item_str = readline(); int llist_item = strtol(llist_item_str, &llist_item_endptr, 10); if (llist_item_endptr == llist_item_str || *llist_item_endptr != ' ') { exit(EXIT_FAILURE); } insert_node_into_singly_linked_list(&llist, llist_item); } reversePrint(llist->head); } return 0; } char* readline() { size_t alloc_length = 1024; size_t data_length = 0; char* data = malloc(alloc_length); while (true) { char* cursor = data + data_length; char* line = fgets(cursor, alloc_length - data_length, stdin); if (!line) { break; } data_length += strlen(cursor); if (data_length < alloc_length - 1 || data[data_length - 1] == 'n') { break; } size_t new_length = alloc_length << 1; data = realloc(data, new_length); if (!data) { break; } alloc_length = new_length; } if (data[data_length - 1] == 'n') { data[data_length - 1] = ' '; } data = realloc(data, data_length); return data; } Problem solution in JavaScript programming.'use strict'; process.stdin.resume(); process.stdin.setEncoding('utf-8'); let inputString = ''; let currentLine = 0; process.stdin.on('data', inputStdin => { inputString += inputStdin; }); process.stdin.on('end', _ => { inputString = inputString.replace(/s*$/, '') .split('n') .map(str => str.replace(/s*$/, '')); main(); }); function readLine() { return inputString[currentLine++]; } const SinglyLinkedListNode = class { constructor(nodeData) { this.data = nodeData; this.next = null; } }; const SinglyLinkedList = class { constructor() { this.head = null; this.tail = null; } insertNode(nodeData) { const node = new SinglyLinkedListNode(nodeData); if (this.head == null) { this.head = node; } else { this.tail.next = node; } this.tail = node; } }; function printSinglyLinkedList(node, sep) { while (node != null) { process.stdout.write(String(node.data)); node = node.next; if (node != null) { process.stdout.write(sep); } } } function reversePrint(head) { if (head !== null) { reversePrint(head.next); console.log(head.data) } } function main() { coding problems solutions