Is this variation of the Guidance cantrip balanced? [closed]

As a player who currently can cast Guidance, I find its decision making process a little less than exciting. Essentially, if I’m not concentrating on a spell and there’s no time pressure, cast Guidance. I’d like to make the spell more meaningful. So my thought:

GUIDANCE
Casting Time: 1 action
Range: Touch
Components: V, S
Duration: Concentration, up to 1 minute
Classes: Cleric, Druid

You touch one willing creature. Once before the spell ends, the target can roll one ability check with advantage. The spell then ends. The target cannot benefit from the effects of Guidance until they have completed a short rest.

I think this provides a more meaningful decision point behind the spell, since it can’t be used for every check. It could even provide a meaningful benefit in combat, if you were to use it on, say, your barbarian friend who was planning on grappling someone. I do worry if it is almost too weak, since Working Together wouldn’t stack with it. Would allowing it to be used for attack rolls or saving throws then make it too strong? (Per my understanding, those don’t qualify as ability checks).

A variation of the halting problem

Given an infinite set $ S \subseteq \mathbb{N}$ , define the language:

$ L_S = \{ \langle M \rangle : M $ is a deterministic TM that does not halt on $ \epsilon$ , or, $ T_M \in S\}$

where $ T_M$ is the number of steps that $ M$ takes until it halts with the empty word $ \epsilon$ as input (or $ \infty$ if it doesn’t halt).

What are the sets $ S$ such that $ L_S$ is decidable?

There are some more trivial cases, if $ S = \{k,k+1,k+2, \dots \}$ for some $ k \in \mathbb{N}$ then $ L_S$ is clearly decidable, as we can simulate $ M$ on $ \epsilon$ for $ k-1$ steps and accept if and only if $ M$ accepts. though, if we take $ S= \{k,k+2,k+4,\dots \}$ for some $ k \in \mathbb{N}$ , or even simply taking $ S=\mathbb{N}_{even}$ or $ S=\mathbb{N}_{odd}$ this becomes more of a problem, because there is no prevention from it being impossible to have a finite calculation for whether the number of steps until halting will be even in the cases where it halts. Although this seems undecidable I’m not sure how to prove this.

I generally suspect that $ L_S$ is decidable if and only if $ \mathbb{N} \setminus S$ is finite

Dynamic Programming – Thief Variation Probem

I’ve encountered a Dynamic Programming problem which is a variation of the thief one.

Say you are a thief and you are given a number of houses in a row you should rob :

$ $ House_1,House_2 \dots House_N$ $

with each house having the following values : $ $ (x_i \geq y_i \geq z_i \gt0)$ $

You profit X if you rob a house but none of the adjacent houses.

You profit Y if you rob a house and exactly one of the adjacent houses.

You profit Z if you rob a house and both of the adjacent houses.

Cases with houses A-B-C would be :

$ $ Profit(001)=0+0+C_x$ $ $ $ Profit(101)=A_x+0+C_x$ $ $ $ Profit(110)=A_y+B_y+0$ $ $ $ Profit(111)=A_y+B_z+C_y$ $

Where 1 stands for robbing the house and 0 for not robbing the house

Obviously you can’t utilize the Z value for the first and the last house and each set of values is random.

Now the question is : Which houses should you rob to get the maximum profit?

My main issue is that i can’t establish a base case for this problem.

At first i thought of creating a N*M array with M being the maximum amount of houses i can rob from 0-N when every house is not robbed and think like : Rob it – Don’t rob it but came up with nothing.

Any tips or directions would be appreciated.

Thanks in advance.

WooComemrce Show selected color beside color variation title and separate Add to cart button from quantity

I need some help doing such changes on my site. First of all, I want to show n selected color label to show beside Color title. and second of all, I want to show Add to cart in a separate row not in the same row with quantity. I am attaching a picture below for the reference. Pardon me if it is a silly question I am learning about WooCoomerce. w

Proof of a greedy algorithm used for a variation of bin-packing problem

we are given an array of weights W (All the wights are positive integers) and we need to put the weights inside bins. Each bin can hold a maximum of Max_val (Wi <= Max_val (0 <= i < W.size())). The variation is that the ordering of weights should not be changed (ie; Wi should be inside a bin before Wj is inserted for all i < j).

For this problem statement, intuitively we can see that a greedy approach of filling a bin till its maximum value is reached and creating a new bin for further weights will produce the minimum number of bins. I am unable to come up with a formal proof that the greedy solution is optimal. Any hints or guidelines would be great!

PS: Wi represents ith element of W array.

Variation to spanning tree called Group Spanning Tree

Suppose we have a complete graph with say 100 nodes. We divide the nodes in the graphs into groups for example 10 nodes in each group identified by color. We want to obtain an optimal spanning tree that operates under the constraint that at least one node will be present from each group. The resulting spanning tree can be called a group spanning tree. How to write an efficient algorithm for this making sure it is a tree(no cycles) and not looping over the entire node set on every pass to check presence of cycles and also making sure at least one node from each group is represented.

Showing np complete for subset sum variation

The subset sum problem is where you are given a set of integers $ S={x1,x2,…,xn}$ and you want to find a subset $ S′⊆S$ such that its sum equals some k. I already know this problem is NP complete and I’ve seen the proof for it using 3-SAT.

However, what if there was an added condition that we would return YES if the entire set was made up of the same integer? So we return yes if some subset equals $ k$ OR if the set has all the same numbers.

I know this is NP, but I’m struggling to choose which problem to reduce from to show NP completeness.

My question is, what problem should I try to reduce from to make this as easy as possible? I’ve been stuck on this for hours…