Ask the user for a value N (0 ≤ N < 10) Create a 2-D list in an N X N structure with integers 1-(N*N) Print the list created Reverse the list such that (1) each list in the 2D list is reversed and (2) the order of each list in the outer list is reversed (see example) Print the reversed list Example Execution What size 2D list would you like to create? N> 3 The original list is: [ [1, 2, 3], [4, 5, 6], [7, 8, 9] ] The reversed list is: [ [9, 8, 7], [6, 5, 4], [3, 2, 1] ]

Ask the user for a value N (0 ≤ N < 10) Create a 2-D list in an N X N structure with integers 1-(N*N) Print the list created Reverse the list such that (1) each list in the 2D list is reversed and (2) the order of each list in the outer list is reversed (see example) Print the reversed list Example Execution What size 2D list would you like to create? N> 3 The original list is: [ [1, 2, 3], [4, 5, 6], [7, 8, 9] ] The reversed list is: [ [9, 8, 7], [6, 5, 4], [3, 2, 1] ]

C++ Programming: From Problem Analysis to Program Design

8th Edition

ISBN:9781337102087

Author:D. S. Malik

Publisher:D. S. Malik

Chapter17: Linked Lists

Section: Chapter Questions

Problem 18SA

See similar textbooks

Example Execution

What size 2D list would you like to create?
N> 3

The original list is:
[ [1, 2, 3],
[4, 5, 6],
[7, 8, 9]
]

The reversed list is:
[ [9, 8, 7],
[6, 5, 4],
[3, 2, 1]
]

Expert Solution

This question has been solved!

Explore an expertly crafted, step-by-step solution for a thorough understanding of key concepts.

This is a popular solution!

SEE SOLUTION Check out a sample Q&A here

Step 1: Code

VIEW

Step 2: code screenshot for indentation

VIEW

Step 3: output screenshot:

VIEW

Trending now

This is a popular solution!

Step by step

Solved in 3 steps with 2 images

SEE SOLUTION Check out a sample Q&A here

Knowledge Booster

Learn more about

Need a deep-dive on the concept behind this application? Look no further. Learn more about this topic, computer-science and related others by exploring similar questions and additional content below.

Similar questions

Write a program in Java to manipulate a Double Linked List: Count the number of nodes Insert a new node before the value 7 of Double Linked List Search an existing element in a Double linked list (the element of search is given by the user) Suppose List contained the following Test Data: Input the number of nodes : 4Input data for node 1 : 5Input data for node 2 : 6 Input data for node 3 : 7 Input data for node 4: 9
in python please cut(aList) Takes a list of integers and returns a list identical to aList, but when a negative number appears,the function deletes the negative number and the next x-1 elements, where x is the absolute valueof the negative number. The function should not mutate aList.Inputlist aList A list that contains only integersOutputlist A list identical to aList where we delete a number of elements from that sequence>>> cut([7, 4, -2, 1, 9]) # Found -2: Delete -2 and 1[7, 4, 9]>>> cut([-4, -7, -2, 1, 9]) # Found -4: Delete -4, -7, -2 and 1[9]neighbor(n) Takes a positive integer and returns an integer where neighboring digits of the same value areremoved. Converting n to other types such as str is not allowed. As described in Homework 1,floor division (//) and modulo (%) operators are useful here. You are not allowed to use the mathmodule.Inputint n A positive integerOutputint Integer with neighboring duplicates removed>>>…
You have two numbers represented by a linked list, where each node contains a single digit. The digits are stored in reverse order, such that the 1 's digit is at the head of the list. Write a function that adds the two numbers and returns the sum as a linked list.EXAMPLEInput: (7-> 1 -> 6) + (5 -> 9 -> 2).That is,617 + 295.Output: 2 -> 1 -> 9. That is, 912.FOLLOW UPSuppose the digits are stored in forward order. Repeat the above problem.Input: (6 -> 1 -> 7) + (2 -> 9 -> 5).That is,617 + 295.Output: 9 -> 1 -> 2. That is, 912.
Please code this question in Java according to the function attached in picture. Given two numbers represented by a linked list, where each node contains a single digit. The digits are stored in reverse order, such that the 1's digit is at the head of the list. Write a function that adds the two numbers and return the sum as linked list: Example : Input : (7-> 1 -> 6) + (5-> 9-> 2). That is 617 + 295 = 912 Output : 2-> 1 -> 9 Expected time complexity : O(m+n), where m and n are no. of nodes in first and second linked list respectively.
The linked list provided below:2 > 3 > 1 > 7 > 5 > 18 > NULLHere the > symbol means a pointer.Write a complete Python program which deletes the third last node of thelist and returns to you the list as below2 > 3 > 1 > 5 > 18 > NULLThe third last node (with a value 7) has now been dislodged from the list.Here are the few things to consider :(a) We do NOT know the length of the list.(b) Your solution should be in O(n) time and O(1) space having madejust a single pass through the list.
Write a python program that has the following functionality:• Using a loop it creates a two-dimensional list with 3 elements, such that theseelements are empty lists. (i.e., [ [ ], [ ], [ ] ] ).• Using a nested loop your program should store three (3) random integers between 1and 25 (inclusive) in each of these empty lists. A sample list after this step shouldlook like this; [ [4, 17, 25], [7, 7, 16], [21, 17, 5] ]• Using another nested loop your program should multiply each integer stored in thatlist and print the result. For the sample list given above the result is 2379048000.
Please code this in Java Or C or C++ Given two numbers represented by a linked list, where each node contains a single digit. The digits are stored in reverse order, such that the 1's digit is at the head of the list. Write a function that adds the two numbers and return the sum as linked list: Example : Input : (7-> 1 -> 6) + (5-> 9-> 2). That is 617 + 295 = 912 Output : 2-> 1 -> 9 Expected time complexity : O(m+n), where m and n are no. of nodes in first and second linked list respectively.
Draw a singly linked list where each node contains a letter of your full name withoutconsidering any space. [You must show proper locations and indexes.]Do the following operations (stepwise):a. Reverse the list (in-place – draw all the steps)b. Insert ‘P’ in the first positionc. Insert ‘A’ in position 2d. Left rotate the list 4 timese. Delete the second element of the listf. Insert ‘G’ in the last positiong. Right rotate the list 3 timesh. Right shift the list 2 timesi. Sort the list in alphabetical order (show all the steps). Pleaseee answer in Java..
Draw a singly linked list where each node contains a letter of your full name withoutconsidering any space. [You must show proper locations and indexes.]Do the following operations (stepwise):a. Reverse the list (in-place – draw all the steps)b. Insert ‘P’ in the first positionc. Insert ‘A’ in position 2d. Left rotate the list 4 timese. Delete the second element of the listf. Insert ‘G’ in the last positiong. Right rotate the list 3 timesh. Right shift the list 2 timesi. Sort the list in alphabetical order (show all the steps)
Write a program that inserts the following numbers into two (2) empty doubly linked list.L1 50 30 25 75 82 28 77L2 50 40 25 75 80 21 37 30Hint: Put the median at the first element of linked list for both linked list and after insertingmedian element at the first node, do not pass that element again. Median Formula: (n+1)/2a) Implement an insert function for both L1 and L2.b) Implement a function to delete 80 from L2.c) Implement a function to check L1 and L2 are really the same list of nodes or not.Note: You are not allowed to use any built-in Data Structure classes to implement abovescenario.
This problem considers a linked list that has been created in memory. We know the linked list consists of 2 nodes, we know one of the nodes resides at address 0x00007fffffffea40 and has the following declaration in C. struct lnode { struct lnode *prev; struct lnode *next; char first; char *word; int length; }; We decide to look at the node in gdb and see the following: (gdb) x/4xg 0x555555554774 0x555555554774: 0x6f72203136325343 0x6c65480021736b63 0x555555554784: 0x3b031b0100216f6c 0x000000060000003c (gdb) x/14xg $rsp 0x7fffffffea00: 0x00007fffffffeb58 0x00000001756e6547 0x7fffffffea10: 0x00007fffffffea40 0x0000000000000000 0x7fffffffea20: 0x0000000000000043 0x0000555555554774 0x7fffffffea30: 0x000000000000000c 0x000055555555473d 0x7fffffffea40: 0x0000000000000000 0x00007fffffffea10 0x7fffffffea50: 0x0000000000000048 0x0000555555554781 0x7fffffffea60: 0x0000000000000006 0x2248a3a88ddbb600 Fill-in the following blanks for the node starting…
This problem considers a linked list that has been created in memory. We know the linked list consists of 2 nodes, we know one of the nodes resides at address 0x00007fffffffea40 and has the following declaration in C. struct lnode { struct lnode *prev; struct lnode *next; char first; char *word; int length; }; We decide to look at the node in gdb and see the following: (gdb) x/4xg 0x555555554774 0x555555554774: 0x6f72203136325343 0x6c65480021736b63 0x555555554784: 0x3b031b0100216f6c 0x000000060000003c (gdb) x/14xg $rsp 0x7fffffffea00: 0x00007fffffffeb58 0x00000001756e6547 0x7fffffffea10: 0x00007fffffffea40 0x0000000000000000 0x7fffffffea20: 0x0000000000000043 0x0000555555554774 0x7fffffffea30: 0x000000000000000c 0x000055555555473d 0x7fffffffea40: 0x0000000000000000 0x00007fffffffea10 0x7fffffffea50: 0x0000000000000048 0x0000555555554781 0x7fffffffea60: 0x0000000000000006 0x2248a3a88ddbb600 Fill-in the following blanks for the node…