## Is there a difference between “When you are reduced to 0 hit points” and “when you would be reduced to 0 hit points”?

There already exist a few questions asking similar things about such scenarios, like the following:

• If a wildshaped druid somehow got Undead Fortitude, would this prevent them from reverting?
• Does Phoenix Spark overcome Disintegrate?
• Does casting Disintegrate on a polymorphed enemy still kill it after the 2018 errata?
• Does the Way of the Long Death monk's Mastery of Death feature protect against the Disintegrate spell?
• What happens if a sorcerer is hit with Disintegrate while he has turned into a potted plant?

What I am wondering is whether the wording differences between all of the following features means anything; how should these wording differences be interpreted/used? In particular, some features use the phrase “when you would be reduced to 0 hit points” while others use the phrase “when you are reduced to 0 hit points”.

The first link above currently has an answer stating that the wording difference is important, and that it does result in differences between the features and rulings regarding them. Below are some example features:

Barbarian’s Relentless Rage feature:

If you drop to 0 hit points while you’re raging and don’t die outright, you can make a DC 10 Constitution saving throw. If you succeed, you drop to 1 hit point instead.

Undead Fortitude feature (Zombie):

If damage reduces the creature to 0 hit points, it must make a Constitution saving throw […] On a success, the creature drops to 1 hit point instead.

Half-Orc’s Relentless Endurance feature:

When you are reduced to 0 hit points but not killed outright, you can drop to 1 instead.

Druid’s Wild Shape feature:

You automatically revert if you fall unconscious, drop to 0 hit points, or die.

Long Death Monk’s Mastery of Death feature:

When you are reduced to 0 hit points, you can expend 1 ki point (no action required) to have 1 hit point instead.

Relentless Feature (Boar):

If the boar takes 7 damage or less that would reduce it to 0 hit points, it is reduced to 1 hit point instead.

Death ward spell:

The first time the target would drop to 0 hit points as a result of taking damage, the target instead drops to 1 hit point, and the spell ends.

Only the last two features actually use the phrasing “would drop” and “would reduce” instead of simply “are dropped” and “are reduced” (or similar). Does this mean that death ward and the Relentless feature act differently in terms of rulings to be made?

Is there a difference between “when you are reduced to 0 hit points” and “when you would be reduced to 0 hit points?”

I would like answers to assume that the wording choice of “if” vs “when” is irrelevant. These words (at least to me) seem to be used interchangeably throughout the rules with no difference in meaning, so they can be ignored here. Alternatively, if you feel they are different, that should be a separate question of its own.

## Partition into pairs with minimum absolute difference, NP-hard?

I have a set $$S$$ of an even number of positive elements $$2m$$ and $$m$$ values $$t_1,t_2,\ldots,t_m$$ where each $$t_i\leq1$$ for all $$i$$.

The question is: can you select $$m$$ pairs $$(a_i,b_i)$$ from $$S$$ such that $$|a_i-b_i|\geq t_i$$?

I was trying to prove that this problem is NP-hard by a reduction from 3-Partition Problem. I failed because if I choose the numbers as in 3-partition I cannot guarantee that their absolute difference is at least $$t_i$$.

Do you have any hints?

## What’s the difference between a creature “can’t move” and a creature’s “speed becomes 0 and it can’t benefit from any bonus to its speed.”?

While reading through the conditions described in Appendix A of the 5e PHB, I realised, that some of them say a creature “can’t move” (e.g. Stunned, Unconscious), while others state that its “speed becomes 0” (e.g. Grappled, Restrained).

Can anyone explain to me the mechanical distinction between these two phrases?

EDIT: The answer provided by Zimul8r answered the literal question I asked: if a creature’s speed is reduced to 0 it could still benefit from effects that give it additional movement, while that’s not the case if it can’t move. Yet the conditions that state a creature’s speed becomes 0 also state it can’t get any bonus to its speed.

So there is still the question: Why do some conditions state “can’t move”, but other say “speed becomes 0, and it can’t benefit from any bonus to its speed.” Is there a difference between these two statements?

## set difference of two non regular languages

Lets say we have $$L_1$$ and $$L_2$$ two non regular languages . is $$L_1$$\ $$L_2$$ is always non-regular languages?

## What is the difference between a Use Case and a User Journey? Is there any?

I was wondering what the difference is between a use case and a user journey? To me they seem to be doing the same thing?

## Minimise the difference under given constraints

Given $$M$$ arrays, pick one element from each array so that, the difference between the maximum and minimum of the resulting array is the smallest possible. Provide an efficient algorithm for finding such a minimum difference.

Constraints:

The total number of elements in $$M$$ arrays <=$$10^5$$

$$M$$<=$$10^5$$

Time limit: 1secs

Example: Let $$M$$ arrays be,( $$M=3$$ in the following)

$$10,16,21$$

$$15,28$$

$$18,30$$

The optimum way to pick elements is 16 from the first set, 15 from the second set, 18 from 3rd set.Hence the answer is $$18-15=3$$

## Essential difference between Assembly languages to all other programming languages

I understand that any assembly programming language has so little abstraction, so that one who programms with it (OS creator, hardware driver creator, “hacker” and so on), would have to know the relevant CPU’s architecture pattern very well — unlike someone that programms in any “higher” programming language.

For me, this requirement to know the relevant CPU’s architecture pattern very well is the essential difference between assembly programming languages to the rest of programming languages, so we get:

• nonassembly/high programming languages
• assembly/low programming languages
• machine code languages which usually won’t be used as programming languages but theoretically are as such

Is this the only essential difference, if not, what else there is?

## What is the difference between UX Engineer, UX Designer and Front End Developer?

I often find these designations as quite confusing and most of the companies in my country have various definition about each of the above mentioned post. I was curious what is the requirement from around the world.

## Difference between a crit and extra attacks

In DnD 3.x and related systems, you threaten a critical hit on a natural 20, but then have to confirm the crit by making another to-hit roll. If your followup roll beats the target’s AC (or is another natural 20), then the hit was a critical hit and you make another damage roll.

There are plenty of variations to this, such as weapons, feats, items, stances, and spells that increase the “threat range” to be 19-20 or even 15-20 (or larger) if you stack things cleverly, and similar enhancements to cause more than one extra damage roll, and chain extra stuff off the crit.

I’m only asking about the simplest case here. From an abstract point of view, scoring a crit really just means “make another single attack”, right? The attack and damage roll are the same. Am I missing something here? Are the two concepts really equivalent (before you get into all the add-ons that make crits more common or more damaging)?

## What’s the difference between cards, panels, and tiles?

It seems as if with some of the modern front-end development frameworks there is a blur between the different types of ‘container’ elements. Whether this is an attempt to abstract the design from implementation or if this is due to there not being any standardization of terminologies I am not sure, but it leads to the fact that in some design frameworks I see the term panels being used but not cards (e.g. Bootstrap 3) while in others the term cards exists but not panels (e.g. Iconic), and perhaps both exist in others?

From a design perspective, it seems that both cards and panels are just containers, and since there’s nothing that defines how big a card can get and how small a panel can be, I am wondering whether there’s really any difference. From an implementation perspective, it seems that cards should be used for smaller size design elements and are preferred on mobile specific applications, whereas panels are used for a wider range of design elements and are preferred on desktop specific applications.

Is there any evidence/reference/examples that will help to illustrate or highlight the (lack of) differences? For some reason I think cards and tiles are more closely related to each other, and that panels seem to be in a slightly different class/family?

If we take the argument that there are no differences, then it is hard to understand why people associate ’tiles’ with Microsoft ‘Metro’ style home pages, while on Google and Android apps it is ‘cards’ and for Java and Gnome applications it is ‘panels’. Perhaps there are some contextual or implementation differences?

UPDATE: with the release of Bootstrap 4, it seems like cards are basically equivalent to panels (since one component has replaced the other), but with this comes the cost of having to maintain a more flexible container that will make it difficult to implement consistently. According to Bootstrap:

A flexible and extensible content container. It includes options for headers and footers, a wide variety of content, contextual background colors, and powerful display options.

FURTHER UPDATE: It seems as if Bootstrap 5 and Material.io have adopted the card UI component in the new world of responsive and mobile first/multi-device ecosystem design systems while “tiles” have a very specific meaning in the Microsoft Fluent Design System:

A tile is an app’s representation on the Start menu. Every app has a tile. When you create a new Universal Windows Platform (UWP) app project in Microsoft Visual Studio, it includes a default tile that displays your app’s name and logo

Panels don’t seem to be part of the vocabulary anymore, as least in terms of a UI component, but in the Microsoft and Java world it still represents an abstract concept of organisation layouts of UI components.