duplicacy | A new generation cloud backup tool

You can use dynamic blocks to repeat nested blocks.

To repeat the library block for example, you can write:

QUICK REVIEW:

set: set interface extends collection interface. in a set, no duplicates are allowed. every element in a set must be unique.

hashset: is implemented using a hash table. elements are not ordered. the add, remove, and contains methods has constant time complexity O(1).

To answer your question, let us keep it in mind that we will only be concerned about the most expensive of any operation meaning that if some part of our code has a time complexity of o(n) and another o(n^2) then we will pick o(n^2) instead of o(n) reason being that it's the most expensive we're worried about.

First, let's talk about the space complexity as it's easy to spot, from your code you have three variables that stores larger data:

1. src
2. dest
3. ans

The first basically have space complexity of s(n) n being the original size of your data unfiltered(not unique). in your sample above s(4) = 4, note: it means 4 * the datatype size you're using, if for example, you're storing a list of integer, you will say s(4(int)) = 4*(4bytes) = 16bytes of space.

The second following the same analogy above means we have the size of "src", "minus the duplicates" s(n) = 4 - 2(duplicates) = 2*(datatype size in bytes/bits)

The third basically just stores the values from "dest" in pairs, so we should have basically the same size but with datatype difference.

That's just a basic translation of the space complexity, so following our rules we will keep the highest of the sizes. So, our space complexity is s(n*(datatype size)), it's safe to just say s(n).

For the time complexity, following the same rules, we need the most expensive operation in terms of time, and that's the for loop performed on "src" which is the size of any data we're working on in this case 4, so we can say our time complexity is o(n).

Summary of your algorithm:

Space Complexity: s(n)

Time complexity: o(n)

Performance is relatively on average.

Make only one loop throught list of Pairs and collect by the way in HashSet processed pair and it's reversed copy:

Let me suggest this:

I see that you are attempting to generate data with a requirement of re-using values in the ID column.

You can just select the ID column and generate random values and do a union back to your original dataset.

For example:

You can use a named function to attach the same function to multiple event handlers with different selectors.

Only call setCart with the new country added to the end of the array if that country doesn't already exist in the array:

I would try to see if this solution matches your requirements. Key factors:

• I remove all begin end blocks which were unnecessary. You only need to specify blocks when you want to control the exceptions on those blocks.
• If the child is there for a parent already inserted , that is already control by the transaction level READ UNCOMMITTED. So I can count the records in child for the same P_JOBID when the child is there for the parent created_date
• I used to_char over the column because I don't know which NLS_DATE settings you have.

Let me know any doubts you might have.

Update

A message can be displayed as long as the procedure is executed using SERVEROUPUT ON or DBMS_OUTPUT.ENABLE and the session is configured to capture the output.

I am trying to 27 display random images on my website

Rather than running 27 queries with additional application logic in between, why not simply shuffle in the database?