In DnD, does the idea of a check with multiple DCs make sense or have a name?

For example, say a character is placed in a supernaturally hot environment, requiring a constitution save with the following result table:

16+: no effect 10-15: 1d6 fire damage ...9: 1d6 fire + 1 exhaustion point 

This would have 2 DCs- 10 and 16. Is there a name or precedent for something like this? Or just “multiple DCs”?

Medusa / THC Hydra on multiple instances

Is it possible to distribute the login tries in THC Hydra / Medusa in multiple computers?

For example

hydra -l root -x 6:6:A1 127.0.0.1 ssh 

That equals to 2176782336 login tries, how can I distribute this job in several computers to make it faster?

Any possible code reference or topic related to this kind of procedure? Thanks in advance

Do multiple sources of temporary hit points combine, or do you only get one set?

Do multiple sources of temporary hit points combine, or do you only get one set?

For example, say you cast armor of Agathys and false life on yourself. Do you have two separate pools of temporary hit points, or do you have to pick one of the two? By separate pools, I mean that you have 5 temp HP from AoA and 8 temp HP from FL. If you take 10 damage, can you pick one of the two pools of temp HP and take the leftover damage to your real HP, but still have the other pool to protect against a second attack?

I ask because a warlock player in my game insists that she gets both pools, but I think it should be either-or.

How do multiple sources of temp HP interact with one another?

Finding multiple paths through a grid such that every grid square is equally used


Setup

Here’s the setup: I have an $ N$ x $ N$ grid of tiles, and a list of $ M$ agents that need to move across the grid. Each agent has its own start tile $ S(a)$ , end tile $ E(a)$ , and an exact number of steps $ D(a)$ it must make. Each step consists of a one-tile move horizontally, vertically, or staying in place. For each agent, $ D(a)$ is usually much larger than the Manhattan distance between $ S(a)$ and $ E(a)$ , so the path the agent takes is not necessarily a straight line from $ S(a)$ to $ E(a)$ . Furthermore, the sum of all $ D(a)$ is expected to be much larger than $ N$ x $ N$ , so every tile will be used at least once. Agent paths are allowed to intersect with other paths and with themselves, and the number of agents on a tile at any given time doesn’t matter.

The Problem

I would like to find paths for each agent that begin at $ S(a)$ , end at $ E(a)$ , and are exactly $ D(a)$ steps long, with the goal of minimizing the maximum number of times any given tile is used. More formally, given an agent path $ P_0 \ldots P_n$ , let $ C(P, t)$ be the number of times tile $ t$ appears in $ P$ , and let $ A(t)$ be the sum of $ C(P, t)$ over all agent paths. I would like to find agent paths that minimize the maximum $ A(t)$ over all tiles $ t$ .

My intuition tells me that this problem is almost certainly NP hard, so I’m looking for some kind of approximation or heuristic.

First Attempt

My first stab at solving this was to find each path sequentially. For each agent, I create a 3-dimensional $ N$ x $ N$ x $ D(a)$ search space, then use A* search to find the min-cost path from $ [S(a), 0]$ to $ [E(a), D(a)]$ . The cost of each node in the search is the number of times that tile has been used by previous paths. Then, once the path is found, I add to the cost of each tile used, and proceed to the next agent. Of course, this leads to the problem that while the last agent path will be pretty good, the first agent path will be essentially random because the grid is yet totally unused. So, I just loop this process a few times; once the last path is computed and the tile costs updated, I loop back to the first path, subtract from the grid the costs that agent contributed, then recompute that path and add the new costs in. After 3 or 4 loops, I converge on a pretty reasonable solution.

But I’m hoping there’s a better idea out there. Any ideas or references to similar problems that I could read up on would be very welcome.

Can a fighter use Indomitable multiple times on the same save?

Our fighter, Fred, is a high level fighter with multiple uses of the Indomitable feature:

Beginning at 9th level, you can reroll a saving throw that you fail. If you do so, you must use the new roll, and you can’t use this feature again until you finish a long rest.

You can use this feature twice between long rests starting at 13th level and three times between long rests starting at 17th level.

Let’s suppose Fred is targeted by the Hold Person spell. Fred rolls a 5 and fails the save. Fred uses one use of his Indomitable feature, to reroll the save, but still fails. Can Fred expend a second use of his Indomitable feature to reroll the save again?

Also, does this answer hold for the Champion and Warlord NPCs?

Indomitable (2/Day). The champion rerolls a failed saving throw.

Indomitable (3/Day). The warlord can reroll a saving throw it fails. It must use the new roll.

Can an Order of the Mutant Blood Hunter benefit from multiple instances of the same Mutagen at once?

The Order of the Mutant archetype of the Blood Hunter class has the ability to use mutagens to increase ability scores.

The rule for using mutagens reads in part:

As a bonus action you can consume a single mutagen, and the effects and side effects last until you finish a short or long rest, unless otherwise specified. While one or more mutagens are affecting you, you can use an action to focus and flush the toxins from your system, ending the effects and side effects of all mutagens.

So a Blood Hunter can clearly have more than one mutagen in effect at the same time, but could the Blood Hunter have the same mutagen in effect simultaneously?

Specifically, could a Blood Hunter use two instances of the Potency mutagen to increase her strength score to 26? I’m not sure if the rules for combining spells applies since the ability isn’t a spell (or even described as being magic).

extract only single value from multiple rows based on certain condition for same id in Oracle

I’m oracle beginner, and I’m having trouble shooting the below issue –

My table is –

+——-+——+——-+—— + | ID | GRP | ITDESC| DEN |
+——-+——+——-+—— + | 12345 | MANX | Apple | SendV | +——-+——+——-+—— + | 12345 | MANX | Apple | Manual| +——-+——+——-+——- | 12345 | MANX | Apple | UnVeri| +——-+——+——-+—— + | 12346 | MANX | Mango | UnVeri| +——-+——+——-+—— + | 12347 | MANX | PineAp| SendV| +——-+——+——-+—— + 12348 | MANX | Pine | Manual|

I am expecting –

+——-+——+——-+—— + | ID | GRP | ITDESC| DEN |
+——-+——+——-+—— + | 12345 | MANX | Apple | SendV | +——-+——+——-+—— + | 12346 | MANX | Mango | UnVeri| +——-+——+——-+—— + | 12347 | MANX | PineAp| SendV| +——-+——+——-+—— + | 12348 | MANX | Pine | Manual| +——-+——+——-+—— +

I have multiple rows that has only the DEN column different for the same id. My aim is – for the same id perform the check – If the Value of DEN is ‘Manual’ then check to see if there is ‘SendV’ in DEN column for that id. If it is present then consider ‘SendV’ otherwise consider ‘Manual’. Note in the provided example, the order is a random, the SendV can be in 2nd row or 3rd row or 4th row based on the action, however the text of DEN will be same as said above.

select * from table t1 where DEN IN (‘Manual’, ‘SendV’) .I am not aware how to write the condition??

Any suggestions/oracle query help is welcome.

Job scheduling with multiple machines

I have the following question for an assignment and I’m really lost:

Let S = {1, 2, . . . , m} be a set of m machines, and let J = {J1, . . . , Jn} be a set of n jobs each of which has to be done by one of the machines. No more than one machine can work on the same job, and a machine cannot work on more than one job. Moreover, with each job Jk is associated a contiguous interval [lk, rk] of integers, 1 ≤ lk ≤ rk ≤ m, whose significance is that only machines i for which lk ≤ i ≤ rk can work on job Jk. Give an O(mn) time algorithm for assigning machines to jobs so as to maximize the number of busy machines (which is the same as the number of jobs being done). There is no need to prove the correctness of your algorithm.