We’re fighting to restore access to 500,000+ books in court this week. Join us!

- Skills Directory

## Problem Solving

Solving problems is the core of computer science. Programmers must first understand how a human solves a problem, then understand how to translate this "algorithm" into something a computer can do, and finally how to write the specific code to implement the solution. At its core, problem-solving focuses on the study, understanding, and usage of data structures and algorithms.

This competency area includes usage of hash maps, stacks, queues, heaps, and analyzing run-time complexities and space complexities, among others.

Key Competencies:

- Data Structures - Use data structures such as hash maps, stacks, queues, heaps. Manipulate single or double-linked lists, and maintain basic information about subtrees, node distances, etc.
- Algorithms - Use optimal solutions to solve problems. Analyze run-time complexities and space complexities. Create simple dynamic programming-based algorithms.

## Sorry, there was a problem.

Download the free Kindle app and start reading Kindle books instantly on your smartphone, tablet, or computer - no Kindle device required .

Read instantly on your browser with Kindle for Web.

Using your mobile phone camera - scan the code below and download the Kindle app.

## Image Unavailable

- To view this video download Flash Player

## Follow the author

## Walls and Mirrors: Intermediate Problem Solving and Data Structures : Modula, 2 (Benjamin/Cummings Series in Structured Programming) 2nd Edition

- ISBN-10 0805389458
- ISBN-13 978-0805389456
- Edition 2nd
- Publisher Benjamin-Cummings Pub Co
- Publication date January 1, 1988
- Language English
- Print length 649 pages
- See all details

## Product details

- Publisher : Benjamin-Cummings Pub Co; 2nd edition (January 1, 1988)
- Language : English
- Hardcover : 649 pages
- ISBN-10 : 0805389458
- ISBN-13 : 978-0805389456
- Item Weight : 1.1 pounds
- #9,926 in Computer Programming Languages
- #26,548 in Programming Languages (Books)
- #83,440 in Professional

## About the author

Paul helman.

Discover more of the author’s books, see similar authors, read author blogs and more

## Customer reviews

5 star | 0% | |

4 star | 0% | |

3 star | 0% | |

2 star | 0% | |

1 star | 0% |

Customer Reviews, including Product Star Ratings help customers to learn more about the product and decide whether it is the right product for them.

To calculate the overall star rating and percentage breakdown by star, we don’t use a simple average. Instead, our system considers things like how recent a review is and if the reviewer bought the item on Amazon. It also analyzed reviews to verify trustworthiness.

## No customer reviews

- Amazon Newsletter
- About Amazon
- Accessibility
- Sustainability
- Press Center
- Investor Relations
- Amazon Devices
- Amazon Science
- Sell on Amazon
- Sell apps on Amazon
- Supply to Amazon
- Protect & Build Your Brand
- Become an Affiliate
- Become a Delivery Driver
- Start a Package Delivery Business
- Advertise Your Products
- Self-Publish with Us
- Become an Amazon Hub Partner
- › See More Ways to Make Money
- Amazon Visa
- Amazon Store Card
- Amazon Secured Card
- Amazon Business Card
- Shop with Points
- Credit Card Marketplace
- Reload Your Balance
- Amazon Currency Converter
- Your Account
- Your Orders
- Shipping Rates & Policies
- Amazon Prime
- Returns & Replacements
- Manage Your Content and Devices
- Recalls and Product Safety Alerts

- Conditions of Use
- Privacy Notice
- Consumer Health Data Privacy Disclosure
- Your Ads Privacy Choices

## Intermediate Data Structures and Algorithms

- (Jun 6) Problems discussed in class posted
- (Jun 3) Updated slides on weighted graphs (all-pairs example)
- (May 25) Midterm 2 posted
- (May 16) Homework 6 and 7 posted
- (May 16) Problems discussed in class posted
- (May 13) Practice exam for midterm 2
- (May 9) Slides on graphs posted
- (May 9) Homework 5 posted
- (May 2) Homework 4 posted
- (May 1) Dynamic programming slides posted
- (May 1) Midterm 1 posted
- (Apr 25) Problems discussed in class posted
- (Apr 18) Homework 3 posted
- (Apr 18) Greedy slides posted
- (Apr 17) Closest pair animation slides posted
- (Apr 11) Homework 2 posted
- (Apr 9) Slides on divide-and-conquer posted
- (Apr 4) Homework 1 posted
- (Apr 1) Slides on Algorithm Analysis posted
- (Apr 1) Our TAs are Anuja Patil, Lixiao Li and Tanmay Shah: welcome!
- Happy Spring Break

## Basic information

- Read the syllabus .
- Stefano Lonardi ( [email protected] )
- Office hours: Tuesdays 11am-12noon.
- Office: CHUNG HALL , room 325.
- Tanmay Shah ( [email protected] )
- Tanmay's office hours: Tuesdays 10am-11am
- Lixiao Li ( [email protected] )
- Lixiao' office hours: Wednesday 10-11 am
- Anuja Patil ( [email protected] )
- Anuja's office hours: Monday 3-4pm
- TA Office hours are held in CHUNG HALL , room 110.
- TR 2:10am-3:30pm, Watkins , room 1000.
- Algorithms , by Sanjoy Dasgupta, Christos Papadimitriou, Umesh Vazirani. McGrawHill 2007.
- Introduction to Algorithms (3rd Edition) by Thomas H. Cormen, Charles E. Leiserson, Ronald L. Rivest, and Cliff Stein, MIT Press.
- Algorithm Design (Foundations, Analysis, and Internet Examples) by Michael T. Goodrich and Roberto Tamassia, Wiley.
- This is a four-unit CS course. As such, you should expect to spend the following approximate amount of time: 3 hours/week in lecture 1 hour/week discussion 6 to 10 hours/week doing individual study (readings, homework, programming assignments, preparation for lectures, etc).
- Please don't underestimate the time you will need to spend on this course. These are real time amounts spent by average successful past students. Computer Science and Engineering are challenging disciplines requiring extensive time to master.

## Discussion Board

- Course Overview [PDF]
- Algorithm Analysis [PDF]
- Divide & Conquer [PDF]
- Closest Pair animation [PPT]
- Greedy (part I) [PDF]
- Greedy (part II) [PDF]
- Dynamic Programming [PDF]
- Weighted Graphs [PDF]
- Apr 2 : Overview of the course, Analysis (slides 1-33)
- Apr 4 : Analysis (34-65) [hw1 posted]
- Apr 9 : Analysis (66-end)
- Apr 11 : Divide and Conquer (1-32) [hw1 due][hw2 posted]
- Apr 16 : Divide and Conquer (33-57)
- Apr 18 : Divide and Conquer (58-end), Greedy (1-24) [hw2 due][hw3 posted]
- Apr 23 : Greedy (25-45)
- Apr 25 : Greedy (46-49), Midterm 1 prep [hw3 due]
- Apr 30 : Midterm 1
- May 2 : Greedy (50-end), Dynamic Programming (1-28) [hw4 posted]
- May 7 : Dynamic Programming (29-42)
- May 9 : Midterm 1 review, Dynamic Programming (43-end) [hw4 due][hw5 posted]
- May 14 : Weighted graphs (1-44)
- May 16 : Weighted graphs (45-50), Midterm 2 prep [hw5 due]
- May 21 : Midterm 2
- May 23 : Weighted graphs (51-77) [hw6 posted]
- May 28 : Weighted graphs (78-108)
- May 30 : Midterm 2 review, Weighted graphs (109-119) [hw6 due][hw7 posted]
- Jun 4 : Weighted graphs (120-end)
- Jun 6 : Final prep [hw7 due]
- Jun 13 : Final 8am-11am

## Python Code

- Examples from slides

## Homework and Solutions

- Homework 1 [PDF] , [LaTeX] (posted April 4th, due April 11th)
- Homework 1 solution [PDF] (posted April 13th)
- Homework 2 [PDF] , [LaTeX] (posted April 11th, due April 18th)
- Homework 2 solution [PDF] (posted April 19th)
- Homework 3 [PDF] , [LaTeX] (posted April 18th, due April 25th)
- Homework 3 solution [PDF] (posted April 28th)
- Homework 4 [PDF] , [LaTeX] (posted May 2nd, due May 9th)
- Homework 4 solution [PDF] (posted May 12th)
- Homework 5 [PDF] , [LaTeX] (posted May 9th, due May 16th)
- Homework 5 solution [PDF] (posted May 17th)
- Homework 6 [PDF] , [LaTeX] (posted May 23th, due May 30th)
- Homework 6 solution [PDF] (posted Jun 3rd)
- Homework 7 [PDF] , [LaTeX] (posted May 30th, due Jun 6th)
- Homework 7 solution [PDF] (posted Jun 6th)

## Exams and related material

- Syllabus for Midterm 1
- A mock exam for Midterm 1
- Solution for the mock exam
- Problems discussed in class
- Midterm 1/A
- Midterm 1/B
- Midterm 1/A solution
- Midterm 1/B solution
- Syllabus for Midterm 2
- A mock exam for Midterm 2
- Midterm 2/A
- Midterm 2/B
- Midterm 2/A solution
- Midterm 2/B solution
- Syllabus for final

## General course features and policies

Some useful pointers.

- Get LaTeX for your computer
- Dive into Python
- Python Documentation
- Davis's algorithm python examples
- More python examples from David Eppstein

EnjoyMathematics

## Problem-Solving Approaches in Data Structures and Algorithms

This blog highlights some popular problem-solving strategies for solving problems in DSA. Learning to apply these strategies could be one of the best milestones for the learners in mastering data structure and algorithms.

## An Incremental approach using Single and Nested loops

One of the simple ideas of our daily problem-solving activities is that we build the partial solution step by step using a loop. There is a different variation to it:

- Input-centric strategy: At each iteration step, we process one input and build the partial solution.
- Output-centric strategy: At each iteration step, we add one output to the solution and build the partial solution.
- Iterative improvement strategy: Here, we start with some easily available approximations of a solution and continuously improve upon it to reach the final solution.

Here are some approaches based on loop: Using a single loop and variables, Using nested loops and variables, Incrementing the loop by a constant (more than 1), Using the loop twice (Double traversal), Using a single loop and prefix array (or extra memory), etc.

Example problems: Insertion Sort , Finding max and min in an array , Valid mountain array , Find equilibrium index of an array , Dutch national flag problem , Sort an array in a waveform .

## Decrease and Conquer Approach

This strategy is based on finding the solution to a given problem via its one sub-problem solution. Such an approach leads naturally to a recursive algorithm, which reduces the problem to a sequence of smaller input sizes. Until it becomes small enough to be solved, i.e., it reaches the recursion’s base case.

Example problems: Euclid algorithm of finding GCD , Binary Search , Josephus problem

## Problem-solving using Binary Search

When an array has some order property similar to the sorted array, we can use the binary search idea to solve several searching problems efficiently in O(logn) time complexity. For doing this, we need to modify the standard binary search algorithm based on the conditions given in the problem. The core idea is simple: calculate the mid-index and iterate over the left or right half of the array.

Example problems: Find Peak Element , Search a sorted 2D matrix , Find the square root of an integer , Search in Rotated Sorted Array

## Divide and Conquer Approach

This strategy is about dividing a problem into more than one subproblems, solving each of them, and then, if necessary, combining their solutions to get a solution to the original problem. We solve many fundamental problems efficiently in computer science by using this strategy.

Example problems: Merge Sort , Quick Sort , Median of two sorted arrays

## Two Pointers Approach

The two-pointer approach helps us optimize time and space complexity in the case of many searching problems on arrays and linked lists. Here pointers can be pairs of array indices or pointer references to an object. This approach aims to simultaneously iterate over two different input parts to perform fewer operations. There are three variations of this approach:

Pointers are moving in the same direction with the same pace: Merging two sorted arrays or linked lists, Finding the intersection of two arrays or linked lists , Checking an array is a subset of another array , etc.

Pointers are moving in the same direction at a different pace (Fast and slow pointers): Partition process in the quick sort , Remove duplicates from the sorted array , Find the middle node in a linked list , Detect loop in a linked list , Move all zeroes to the end , Remove nth node from list end , etc.

Pointers are moving in the opposite direction: Reversing an array, Check pair sum in an array , Finding triplet with zero-sum , Rainwater trapping problem , Container with most water , etc.

## Sliding Window Approach

A sliding window concept is commonly used in solving array/string problems. Here, the window is a contiguous sequence of elements defined by the start and ends indices. We perform some operations on elements within the window and “slide” it in a forward direction by incrementing the left or right end.

This approach can be effective whenever the problem consists of tasks that must be performed on a contiguous block of a fixed or variable size. This could help us improve time complexity in so many problems by converting the nested loop solution into a single loop solution.

Example problems: Longest substring without repeating characters , Count distinct elements in every window , Max continuous series of 1s , Find max consecutive 1's in an array , etc.

## Transform and Conquer Approach

This approach is based on transforming a coding problem into another coding problem with some particular property that makes the problem easier to solve. In other words, here we solve the problem is solved in two stages:

- Transformation stage: We transform the original problem into another easier problem to solve.
- Conquering stage: Now, we solve the transformed problem.

Example problems: Pre-sorting based algorithms (Finding the closest pair of points, checking whether all the elements in a given array are distinct, etc.)

## Problem-solving using BFS and DFS Traversal

Most tree and graph problems can be solved using DFS and BFS traversal. If the problem is to search for something closer to the root (or source node), we can prefer BFS, and if we need to search for something in-depth, we can choose DFS.

Sometimes, we can use both BFS and DFS traversals when node order is not required. But in some cases, such things are not possible. We need to identify the use case of both traversals to solve the problems efficiently. For example, in binary tree problems:

- We use preorder traversal in a situation when we need to explore all the tree nodes before inspecting any leaves.
- Inorder traversal of BST generates the node's data in increasing order. So we can use inorder to solve several BST problems.
- We can use postorder traversal when we need to explore all the leaf nodes before inspecting any internal nodes.
- Sometimes, we need some specific information about some level. In this situation, BFS traversal helps us to find the output easily.

To solve tree and graph problems, sometimes we pass extra variables or pointers to the function parameters, use helper functions, use parent pointers, store some additional data inside the node, and use data structures like the stack, queue, and priority queue, etc.

Example problems: Find min depth of a binary tree , Merge two binary trees , Find the height of a binary tree , Find the absolute minimum difference in a BST , The kth largest element in a BST , Course scheduling problem , bipartite graph , Find the left view of a binary tree , etc.

## Problem-solving using the Data Structures

The data structure is one of the powerful tools of problem-solving in algorithms. It helps us perform some of the critical operations efficiently and improves the time complexity of the solution. Here are some of the key insights:

- Many coding problems require an effcient way to perform the search, insert and delete operations. We can perform all these operations using the hash table in O(1) time average. It's a kind of time-memory tradeoff, where we use extra space to store elements in the hash table to improve performance.
- Sometimes we need to store data in the stack (LIFO order) or queue (FIFO order) to solve several coding problems.
- Suppose there is a requirement to continuously insert or remove maximum or minimum element (Or element with min or max priority). In that case, we can use a heap (or priority queue) to solve the problem efficiently.
- Sometimes, we store data in Trie, AVL Tree, Segment Tree, etc., to perform some critical operations efficiently.

Example problems: Next greater element , Valid Parentheses , Largest rectangle in a histogram , Sliding window maximum , kth smallest element in an array , Top k frequent elements , Longest common prefix , Range sum query , Longest consecutive sequence , Check equal array , LFU cache , LRU cache , Counting sort

## Dynamic Programming

Dynamic programming is one of the most popular techniques for solving problems with overlapping or repeated subproblems. Here rather than solving overlapping subproblems repeatedly, we solve each smaller subproblems only once and store the results in memory. We can solve a lot of optimization and counting problems using the idea of dynamic programming.

Example problems: Finding nth Fibonacci, Longest Common Subsequence , Climbing Stairs Problem , Maximum Subarray Sum , Minimum number of Jumps to reach End , Minimum Coin Change

## Greedy Approach

This solves an optimization problem by expanding a partially constructed solution until a complete solution is reached. We take a greedy choice at each step and add it to the partially constructed solution. This idea produces the optimal global solution without violating the problem’s constraints.

- The greedy choice is the best alternative available at each step is made in the hope that a sequence of locally optimal choices will yield a (globally) optimal solution to the entire problem.
- This approach works in some cases but fails in others. Usually, it is not difficult to design a greedy algorithm itself, but a more difficult task is to prove that it produces an optimal solution.

Example problems: Fractional Knapsack, Dijkstra algorithm, The activity selection problem

## Exhaustive Search

This strategy explores all possibilities of solutions until a solution to the problem is found. Therefore, problems are rarely offered to a person to solve the problem using this strategy.

The most important limitation of exhaustive search is its inefficiency. As a rule, the number of solution candidates that need to be processed grows at least exponentially with the problem size, making the approach inappropriate not only for a human but often for a computer as well.

But in some situations, there is a need to explore all possible solution spaces in a coding problem. For example: Find all permutations of a string , Print all subsets , etc.

## Backtracking

Backtracking is an improvement over the approach of exhaustive search. It is a method for generating a solution by avoiding unnecessary possibilities of the solutions! The main idea is to build a solution one piece at a time and evaluate each partial solution as follows:

- If a partial solution can be developed further without violating the problem’s constraints, it is done by taking the first remaining valid option at the next stage. ( Think! )
- Suppose there is no valid option at the next stage, i.e., If there is a violation of the problem constraint, the algorithm backtracks to replace the partial solution’s previous stage with the following option for that stage. ( Think! )

In simple words, backtracking involves undoing several wrong choices — the smaller this number, the faster the algorithm finds a solution. In the worst-case scenario, a backtracking algorithm may end up generating all the solutions as an exhaustive search, but this rarely happens!

Example problems: N-queen problem , Find all k combinations , Combination sum , Sudoku solver , etc.

## Problem-solving using Bit manipulation and Numbers theory

Some of the coding problems are, by default, mathematical, but sometimes we need to identify the hidden mathematical properties inside the problem. So the idea of number theory and bit manipulation is helpful in so many cases.

Sometimes understanding the bit pattern of the input and processing data at the bit level help us design an efficient solution. The best part is that the computer performs each bit-wise operation in constant time. Even sometimes, bit manipulation can reduce the requirement of extra loops and improve the performance by a considerable margin.

Example problems: Reverse bits , Add binary string , Check the power of two , Find the missing number , etc.

Hope you enjoyed the blog. Later we will write a separate blog on each problem-solving approach. Enjoy learning, Enjoy algorithms!

## More from EnjoyAlgorithms

Self-paced courses and blogs.

- Corpus ID: 7004187

## Intermediate problem solving and data structures - walls and mirrors (2. ed.)

- P. Helman , R. Veroff , Frank R. Carrano
- Published in Benjamin/Cummings series in… 1991
- Computer Science

## Intermediate problem solving and data structures

Walls and mirrors, by paul helman.

- 1 Want to read
- 0 Currently reading
- 0 Have read

## Preview Book

My Reading Lists:

Use this Work

## Create a new list

My book notes.

My private notes about this edition:

Check nearby libraries

- Library.link

Buy this book

This edition doesn't have a description yet. Can you add one ?

Previews available in: English

Showing 2 featured editions. View all 2 editions?

1 - 2nd ed. | |

2 | Listen |

Add another edition?

## Book Details

Edition notes.

Includes index.

## Classifications

The physical object, source records, community reviews (0).

- Created April 1, 2008
- 10 revisions

## Wikipedia citation

Copy and paste this code into your Wikipedia page. Need help?

Edited by | import existing book | |

Edited by | import existing book | |

Edited by | import existing book | |

Edited by | merge lending editions | |

Created by an anonymous user | Imported from |

## An optimized deep network-based intermediate code generation for the mathematical expression

- Published: 09 July 2024

## Cite this article

- H. N. Sharada ORCID: orcid.org/0009-0008-3663-7552 1 ,
- Basavaraj Anami 2 &
- Shridhar Allagi 2

12 Accesses

Explore all metrics

In recent times, the system's mathematical expression and operation have gained greater reach in engineering and mathematics. It is vital to solving more complex expressions and equations in a short time. The most existing methodology was degraded in the recognition performance and provided inaccurate output. Therefore, a novel Squirrel-based Spiking Neural Model (SbSNM) was presented for the intermediate code generation from the mathematical expression relation data. Initially, the input ME relation data was preprocessed to remove noise and tokenized by the spiking neural features. The tokenized expressions were arranged into a syntax tree structure, and then intermediate code was generated by the squirrel functions. Finally, the differentiation was calculated and given as output. Subsequently, the performance parameters were evaluated for the presented SbSNM. The overall accuracy obtained by the presented model is 99.25% which is higher than the other existing techniques and also brought a higher precision and recall rate and f1-score.

This is a preview of subscription content, log in via an institution to check access.

## Access this article

Subscribe and save.

- Get 10 units per month
- Download Article/Chapter or Ebook
- 1 Unit = 1 Article or 1 Chapter
- Cancel anytime

Price includes VAT (Russian Federation)

Instant access to the full article PDF.

Rent this article via DeepDyve

Institutional subscriptions

## Similar content being viewed by others

## Bangla Handwritten Math Recognition and Simplification Using Convolutional Neural Network

## Offline Handwritten Mathematical Expression Evaluator Using Convolutional Neural Network

## DeepEquaL: Deep Learning Based Mathematical Equation to Latex Generation

Data availability.

Data sharing is not applicable to this article as no datasets were generated or analyzed during the current study.

Du K, Zhang X, Gao C et al (2023) GIMM: A graph convolutional network-based paraphrase identification model to detecting duplicate questions in QA communities. Multimed Tools Appl. https://doi.org/10.1007/s11042-023-16592-3

Article Google Scholar

Aala Kalananda VKR, Komanapalli VLN (2023) A competitive learning-based Grey wolf Optimizer for engineering problems and its application to multi-layer perceptron training. Multimed Tools Appl. https://doi.org/10.1007/s11042-023-15146-x

Gouda SK, Mehta AK (2022) Software cost estimation model based on fuzzy C-means and improved self-adaptive differential evolution algorithm. Int J Inf Tecnol 14:2171–2182. https://doi.org/10.1007/s41870-022-00882-4

Liu Z, Yuan Y, Ji Z, Bai J, Bai X (2023) Semantic graph representation learning for handwritten mathematical expression recognition. In Intern Conf on Document Analysis and Recogn Cham: Springer Nature Switzerland. 152–166. https://doi.org/10.1007/978-3-031-41676-7_9

Bin Y, Han M, Shi W, Wang L, Yang Y, Shen HT (2023) Non-autoregressive math word problem solver with unified tree structure. arXiv preprint arXiv:2305.04556. https://doi.org/10.48550/arXiv.2305.04556

Greiner-Petter A (2023) Making presentation math computable: a context-sensitive approach for translating LaTeX to computer algebra systems, Springer Nature. 197. https://doi.org/10.1007/978-3-658-40473-4

Iftikhar B, Alih SC, Vafaei M, Javed MF, Ali M, Gamil Y, Rehman MF (2023) A machine learning-based genetic programming approach for the sustainable production of plastic sand paver blocks. J Mater Res Technol 25:5705–5719. https://doi.org/10.1016/j.jmrt.2023.07.034

Lin Z, Li J, Yang F, Huang S, Yang X, Lin J, Yang M (2022) Spatial attention and syntax rule enhanced tree decoder for offline handwritten mathematical expression recognition. In Intern Conf on Frontiers in Handwriting Recognit, Cham: Springer Int Pub. 213–227. https://doi.org/10.1007/978-3-031-21648-0_15

Fateh A, Fateh M, Abolghasemi V (2021) Multilingual handwritten numeral recognition using a robust deep network joint with transfer learning. Inf Sci 581:479–494. https://doi.org/10.1016/j.ins.2021.09.051

Article MathSciNet Google Scholar

Altwaijry N, Al-Turaiki I (2021) Arabic handwriting recognition system using convolutional neural network. Neural Comput Appl 33(7):2249–2261. https://doi.org/10.1007/s00521-020-05070-8

Nabil A (2021) Combination of Hough Transform and Neural Network on recognizing mathematical symbols. 2021 8th International Conference on ICT & Accessibility (ICTA), IEEE. https://doi.org/10.1109/ICTA54582.2021.9809779

Sahlol AT, Abd Elaziz M, Al-Qaness MAA, Kim S (2020) Handwritten Arabic optical character recognition approach based on hybrid whale optimization algorithm with neighborhood rough set. IEEE Access 8:23011–23021. https://doi.org/10.1109/ACCESS.2020.2970438

Souza A, Freitas D (2022) Towards the improvement of the cognitive process of the synthesized speech of mathematical expression in MathML: An Eye-Tracking. In 2022 International Conference on Interactive Media, Smart Systems and Emerging Technologies (IMET), IEEE. pp 1–8. https://doi.org/10.1109/IMET54801.2022.9929541

Yang C, Du J, Zhang J, Wu C, Chen M, Wu J (2022) Tree-based data augmentation and mutual learning for offline handwritten mathematical expression recognition. Pattern Recognit 132:108910. https://doi.org/10.1016/j.patcog.2022.108910

Mushtaq F, Misgar MM, Kumar M, Khurana SS (2021) UrduDeepNet: offline handwritten Urdu character recognition using deep neural network. Neural Comput Appl 33(22):15229–15252. https://doi.org/10.1007/s00521-021-06144-x

Santos A, Camargo E, Scheffel R, Merli R, Pezutti E, Lima P, Silva H (2022) L2T: An algorithm to support the generation of 2D texture from LaTeX math equations. In Anais do XXI Simpósio Brasileiro de Jogos e Entretenimento Digital, SBC. pp 85–90

Zhang Z, Tang Z, Wang Y, Zhang Z, Zhan C, Zha Z, Wang M (2021) Dense Residual Network: Enhancing global dense feature flow for character recognition. Neural Netw 139:77–85. https://doi.org/10.1016/j.neunet.2021.02.005

Zhao W, Gao L (2022) Comer: Modeling coverage for transformer-based handwritten mathematical expression recognition. In European Conf on Comput Vis Cham: Springer Nature Switzerland. pp 392–408. https://doi.org/10.1007/978-3-031-19815-1_23

Pal A, Singh KP (2022) R-GRU: Regularized gated recurrent unit for handwritten mathematical expression recognition. Multimed Tools Appl 81(22):31405–31419. https://doi.org/10.1007/s11042-022-12889-x

Ramo M, Silvestre GC (2022) A transformer architecture for online gesture recognition of mathematical expressions. In Irish Conference on Artif Intell and Cognitive Science, Cham: Springer Nature Switzerland. pp 55–67. https://doi.org/10.1007/978-3-031-26438-2_5

Zhelezniakov D, Zaytsev V, Radyvonenko O (2021) Online handwritten mathematical expression recognition and applications: A survey. IEEE Access 9:38352–38373. https://doi.org/10.1109/ACCESS.2021.3063413

Alam MS, Kwon KC, Kim N (2021) Implementation of a character recognition system based on finger-joint tracking using a depth camera. IEEE Trans Hum-Mach Syst 51(3):229–241. https://doi.org/10.1109/THMS.2021.3066854

Balaha HM, Ali HA, Saraya M, Badawy M (2021) A new Arabic handwritten character recognition deep learning system (AHCR-DLS). Neural Comput Appl 33(11):6325–6367. https://doi.org/10.1007/s00521-020-05397-2

Zou Y, Lu W (2019) Text2math: End-to-end parsing text into math expressions. arXiv preprint arXiv:1910.06571. https://doi.org/10.48550/arXiv.1910.06571

dos Santos AA, de Camargo ET, Scheffel R, Merli R, Pezutti E, Lima P, Silva H (2022) L2T: An Algorithm to Support The Generation of 2D Texture from LaTeX Math Equations. 2022 21st Brazilian Symposium on Computer Games and Digital Entertainment (SBGames). IEEE. https://doi.org/10.1109/SBGAMES56371.2022.9961118

Li S, Wu L, Feng S, Xu F, Xu F, Zhong S (2020) Graph-to-tree neural networks for learning structured input-output translation with applications to semantic parsing and math word problem. arXiv preprint arXiv:2004.13781. https://doi.org/10.48550/arXiv.2004.13781

Sun F, Liu Y, Wang JX, Sun H (2022) Symbolic physics learner: Discovering governing equations via Monte Carlo tree search. arXiv preprint arXiv:2205.13134. https://doi.org/10.48550/arXiv.2205.13134

Mahdavi M, Condon M, Davila K, Zanibbi R (2019) LPGA: Line-of-sight parsing with graph-based attention for math formula recognition. 2019 International Conference on Document Analysis and Recognition (ICDAR).IEEE. https://doi.org/10.1109/ICDAR.2019.00109

Mali P, Kukkadapu P, Mahdavi M, Zanibbi R (2020) ScanSSD: Scanning single shot detector for mathematical formulas in PDF document images. arXiv preprint arXiv:2003.08005. https://doi.org/10.48550/arXiv.2003.08005

Jain M, Singh V, Rani A (2019) A novel nature-inspired algorithm for optimization: Squirrel search algorithm. Swarm Evol Comput 44:148–175. https://doi.org/10.1016/j.swevo.2018.02.013

Scarlatos A, Lan A (2023) Tree-based representation and generation of natural and mathematical language. arXiv preprint arXiv:2302.07974. https://doi.org/10.48550/arXiv.2302.07974

Noya E, Benedí JM, Sánchez JA, Anitei D (2023) Discriminative estimation of probabilistic context-free grammars for mathematical expression recognition and retrieval. Pattern Anal and Appl 26(4):1571–1584. https://doi.org/10.1007/s10044-023-01158-8

Raj MG, Pani SK (2022) Chaotic whale crow optimization algorithm for secure routing in the IoT environment. Int J Semant Web Inf Syst (IJSWIS) 18(1):1–25. https://doi.org/10.4018/IJSWIS.300824

Kumar A, Sivakumar P (2022) Cat-squirrel optimization algorithm for VM migration in a cloud computing platform. Int J Semant Web Inf Syst (IJSWIS) 18(1):1–23. https://doi.org/10.4018/IJSWIS.297142

Bhat NA, Farooq SU (2023) An empirical evaluation of defect prediction approaches in within-project and cross-project context. Softw Qual J 31(3):917–946. https://doi.org/10.1007/s11219-023-09615-7

Kumar J, Gupta DL, Umrao LS (2022) Fault-Tolerant algorithm for software preduction using machine learning techniques. Int J Softw Sci Comput Intell (IJSSCI) 14(1):1–18. https://doi.org/10.4018/IJSSCI.309425

Kumar S, Singh SK, Aggarwal N, Gupta BB, Alhalabi W, Band SS (2022) An efficient hardware supported and parallelization architecture for intelligent systems to overcome speculative overheads. Int J Intell Syst 37(12):11764–11790. https://doi.org/10.1002/int.23062

Sharma A, Gupta BB, Singh AK, Saraswat VK (2022) Orchestration of APT malware evasive manoeuvers employed for eluding anti-virus and sandbox defense. Comput Secur J 115:102627. https://doi.org/10.1016/j.cose.2022.102627

HN S, Anami B, Allagi S (2023) An optimized neural Network-based character recognition and relation finding for mathematical expression images. Multimed Tools Appl 1–23. https://doi.org/10.1007/s11042-023-17725-4

Download references

## Acknowledgements

This research did not receive any specific grant from funding agencies in the public, commercial, or not-for-profit sectors.

## Author information

Authors and affiliations.

Department of Computer Science & Engineering, SDM College of Engineering and Technology, Dharwad, Karnataka, 580002, India

H. N. Sharada

Department of Computer Science & Engineering, KLE Institute of Technology, Hubli, Karnataka, 580030, India

Basavaraj Anami & Shridhar Allagi

You can also search for this author in PubMed Google Scholar

## Corresponding author

Correspondence to H. N. Sharada .

## Ethics declarations

Ethical approval.

All applicable institutional and/or national guidelines for the care and use of animals were followed.

## Informed consent

For this type of analysis, formal consent is not needed.

## Conflict of interest

The authors declare that they have no potential conflict of interest.

## Additional information

Publisher's note.

Springer Nature remains neutral with regard to jurisdictional claims in published maps and institutional affiliations.

## Rights and permissions

Springer Nature or its licensor (e.g. a society or other partner) holds exclusive rights to this article under a publishing agreement with the author(s) or other rightsholder(s); author self-archiving of the accepted manuscript version of this article is solely governed by the terms of such publishing agreement and applicable law.

Reprints and permissions

## About this article

Sharada, H.N., Anami, B. & Allagi, S. An optimized deep network-based intermediate code generation for the mathematical expression. Multimed Tools Appl (2024). https://doi.org/10.1007/s11042-024-19730-7

Download citation

Received : 17 October 2023

Revised : 12 March 2024

Accepted : 19 June 2024

Published : 09 July 2024

DOI : https://doi.org/10.1007/s11042-024-19730-7

## Share this article

Anyone you share the following link with will be able to read this content:

Sorry, a shareable link is not currently available for this article.

Provided by the Springer Nature SharedIt content-sharing initiative

- Mathematical expressions
- Tokenization
- Intermediate code generation
- Squirrel search optimization
- Spiking neural network
- Find a journal
- Publish with us
- Track your research

## IMAGES

## VIDEO

## COMMENTS

Data Structures. Arrays - DS. Easy Problem Solving (Basic) Max Score: 10 Success Rate: 93.13%. Solve Challenge. ... Hard Problem Solving (Intermediate) Max Score: 60 Success Rate: 61.55%. Solve Challenge. Print the Elements of a Linked List. Easy Problem Solving (Basic) Max Score: 5 Success Rate: 97.15%.

Intermediate problem solving and data structures : walls and mirrors by Helman, Paul; Veroff, Robert. Publication date 1986 Topics Computer programming, Data structures (Computer science) Publisher Menlo Park, Calif. : Benjamin/Cummings Pub. Co. Collection internetarchivebooks; inlibrary; printdisabled

Intermediate. Get Certificate. Solving problems is the core of computer science. Programmers must first understand how a human solves a problem, then understand how to translate this "algorithm" into something a computer can do, and finally how to write the specific code to implement the solution. ... Data Structures - Use data structures such ...

Intermediate · Specialization · 3 - 6 Months. Status: Free. ... Data Analysis, Data Management, Data Structures, Problem Solving, Programming Principles, Python Programming. 4.9. 4.9 stars (95K reviews) Beginner · Course · 1 - 3 Months. C. University of Colorado Boulder. Master of Science in Computer Science ...

There are 7 modules in this course. By learning this course, you will get a comprehensive grasp of vector and list and the ability to use them in solving real problems. By the end of this course, you will be able to evaluate data structures and algorithms in terms of asymptotic complexity, analyze storage/time complexity of iterative/recursive ...

Intermediate Problem Solving and Data Structures: Walls and Mirrors (Frontiers in Physics) [Helman, Paul, Veroff, Robert] on Amazon.com. *FREE* shipping on qualifying offers. Intermediate Problem Solving and Data Structures: Walls and Mirrors (Frontiers in Physics)

Walls and Mirrors: Intermediate Problem Solving and Data Structures. Paul Helman, Robert Veroff. Benjamin/Cummings Publishing Company, 1988 ... Intermediate Problem Solving and Data Structures Benjamin/Cummings series in structured programming: Authors: Paul Helman, Robert Veroff: Edition: 2, illustrated:

The Pascal programming language is used in problem solving examples. The book is divided into four parts: a review of programming in Pascal including linked lists, a section on recursion and recursive algorithms, a section of "data abstraction as a problem solving tool," and "advanced techniques for the management of data."

The text covers structures from linked lists, tables, stacks, and queues to trees, priority queues and heaps, and graphs, and even presents some approaches to handling external data files. Its wealth of special features include self-test exercises with answers and additional exercises and projects for homework.

Intermediate Problem Solving and Data Structures: Walls and Mirrors Paul Helman , Robert Veroff Benjamin/Cummings Publishing Company , 1986 - Computer programming - 612 pages

Intermediate Problem Solving and Data Structures: Walls and Mirrors. Paul Helman, Robert Veroff, Frank M. Carrano. Benjamin/Cummings Publishing Company, 1991 - Computers - 659 pages. 1 Review. Reviews aren't verified, but Google checks for and removes fake content when it's identified.

Intermediate Problem Solving and Data Structures: Walls and Mirrors (The Benjamin/Cummings Series in Computer Science) $7.98 Only 1 left in stock - order soon. Report an issue with this product or seller

Apply algorithmic techniques (greedy algorithms, binary search, dynamic programming, etc.) and data structures (stacks, queues, trees, graphs, etc.) to solve 100 programming challenges that often appear at interviews at high-tech companies. Get an instant feedback on whether your solution is correct. Apply the newly learned algorithms to solve ...

Overview. CS 141 introduces the "core" of Computer Science: data structures like graphs, and problem solving techniques. This material is essential in almost all of our upper-division courses. Catalog description: CS 141 Intermediate Data Structures and Algorithms 4 Lecture, 3 hours; discussion, 1 hour.

Divide and Conquer Approach. This strategy is about dividing a problem into more than one subproblems, solving each of them, and then, if necessary, combining their solutions to get a solution to the original problem. We solve many fundamental problems efficiently in computer science by using this strategy. Example problems: Merge Sort , Quick ...

Intermediate problem solving and data structures - walls and mirrors (2. ed.) @inproceedings{Helman1991IntermediatePS, title={Intermediate problem solving and data structures - walls and mirrors (2. ed.)}, author={Paul Helman and Robert Veroff and Frank R. Carrano}, booktitle={Benjamin/Cummings series in computer science}, year={1991}, url ...

Find the best prices on Intermediate Problem Solving and Data Structures: Walls and Mirrors by Paul Helman at BIBLIO | Hardcover | 1986 | Benjamin-Cummings Publishing Company | 9780805389401

Intermediate problem solving and data structures by Paul Helman, 1986, Benjamin/Cummings Pub. Co. edition, in English ... Intermediate problem solving and data structures walls and mirrors by Paul Helman. 0 Ratings 1 Want to read; 0 Currently reading; 0 Have read; Share.

Buy Intermediate Problem Solving and Data Structures: Walls and Mirrors by Paul Helman online at Alibris. We have new and used copies available, in 2 editions - starting at $3.57. Shop now.

Embedable Problem-Solving Architectures: A Study of Integrating OPS5 with UMass GBB The requirements of a problem-solving architecture that can be tightly embedded within other architectures and coexist with multiple instances of itself and of other problem-solvers are discussed.

Limited Preview for 'Intermediate Problem Solving and Data Structures' provided by Archive.org *This is a limited preview of the contents of this book and does not directly represent the item available for sale.*

Welcome to the daily solving of our PROBLEM OF THE DAY with Jay Dalsaniya We will discuss the entire problem step-by-step and work towards developing an optimized solution. This will not only help you brush up on your concepts of Graph but also build up problem-solving skills. You are given a weighted undirected graph having n vertices numbered from 1 to n and m edges along with their weights.

It is vital to solving more complex expressions and equations in a short time. The most existing methodology was degraded in the recognition performance and provided inaccurate output. Therefore, a novel Squirrel-based Spiking Neural Model (SbSNM) was presented for the intermediate code generation from the mathematical expression relation data.