Are there any known W[3] or W[3]-hard problems?

We are currently working on a variant of domination parameter and we have shown that it is in W[3] with regard to parameterized complexity. To show it is W[3]-complete, we must show the problem is W[3] hard i.e, reduce an already known W[3] hard problem to ours. But unlike W[1] and W[2], where many famous problems are proved those classes, surprisingly we have not come across a single problem that is W[3] hard and not even in just W[3]. Of course there is the general W[t] case which we can go for, but any result for W[3] in particular would help a lot.

What is the maximum number of known spells (that can be cast with spell slots and use Charisma) a character can have?

I often find it frustrating how few spells sorcerers have. This has led me to trying to increase the number of spells they have with a few multiclassing dips. I was then inspired to ask this question:

What is the maximum number of spells known a character can have?

I want this to be achieved primarily through multiclassing, so there are a few restrictions:

  • The spells must be cast using Charisma as the spellcasting modifier, so multiclassing into Wizard or Druid doesn’t help;
  • I’m not including features you’d get through subclasses (i.e. Eyes of the Dark gives you darkness for free), since I want this solution to be a template I can stick any subclasses onto;
  • A bard’s Magical Secrets is allowed, since that’s a base class feature, but Additional Magical Secrets is not, since that’s Lore bard only;
  • Feats are allowed, but Epic Boons and magic items are not;
  • I’ll allow Unearthed Arcana for this one, for example UA feats;
  • The spells known must be cast via your spell slots that you have via your class features;
  • Polymorphing into something else that can cast spells is not allowed;
  • Assume a level 20 character, and whatever ability scores are necessary (although I imagine that’ll just be Charisma 20);
  • Also note that this question has nothing to do with the number of spell slots, only spells known.

Cracking known salt MD5 Hashes online [closed]

I’ve been having trouble with this certain salted MD5 hash, even though I know the salt, and I’ve been having trouble finding anywhere online that will crack salted MD5 hashes. All I’m finding is just straight MD5 only. Can anyone point me in the right direction? Preferrably something free or affordable.It’s in the md5(hash.salt) format.

Yes, I have tried using hashcat and crackstations wordlist to no avail.

Thanks

How to use ‘Bind Variables’ in a ‘Dynamic Query ‘ when the exact number of variables are not known

I have a procedure in which I’m using Dynamic SQL. The input parameteri_tables is a string which is a concatenation of the name of some tables . It might be one these :

1)All tables test_table1,test_table2,test_table3.

2)Only two tables , for instance test_table2,test_table3 .

3)Nothing .So NULL will pass to the procedure.

I’ve read about Bind variable and the significant role it has in preventing injection and improving performance. I want to use bind variable in my procedure but there is one things I don’t know how to handle :

As you can see we do not know the exact number of variables.It might be one , two , three or nothing. Depending on The input parameteri_tables.

   create or replace procedure bind_variable_test(i_tables varchar2,                                                   i_cid    number,                                                   o_result out sys_refcursor) is     actual_query varchar2(1000) := '';    begin         -- this is the base query     actual_query := 'select *                 from z_test_a t1                   inner join z_test_b t2                 on t1.id = t2.id';      -- check input parameter " i_tables "       if i_tables like '%test_table1%' then              actual_query := actual_query || '  inner join test_table1 t3 on t3.id = t1.id and                              t3.cid = ' || i_cid;      end if;       if i_tables like '%test_table2%' then             actual_query := actual_query || '  inner join test_table2 t4 on t4.id = t1.id and                              t4.cid = ' || i_cid;      end if;       if i_tables like '%test_table3%' then             actual_query := actual_query || '  inner join test_table3 t5 on t5.id = t1.id and                    t5.cid = ' || i_cid;      end if;      open o_result for actual_query;     end; 

Is there a known way to make an efficient, compact, and fully persistent stack or queue?

In the world of mutable/ephemeral data structures and imperative programming languages, one of the classic ways to implement a stack or queue is to use array doubling: use mutation to fill up or empty an array, doubling or halving to expand/contract. Such stacks/queues have several nice properties:

  1. They use at most twice as much memory as strictly necessary.
  2. They involve minimal indirection.
  3. They use cache efficiently.
  4. They have amortized $ O(1)$ insertion and deletion operations.

In a purely functional system, this approach falls down quite flat, because "mutate the array to fill/empty" becomes very expensive: the array has to be copied each time. I was wondering if there might be some reasonable compromise approach, making something more compact than classical approaches (a la Okasaki) but still with constant amortized time operations. Stacks are simpler, so I started thinking about those. My first attempt (in Haskell notation) was

data Queue a   = Shallow !(Array a)   | Deep !(Array a) (Queue a) 

with the rule that the array at depth $ n$ must have either $ 0$ or $ 2^n$ elements. Unfortunately, this doesn’t look like it’s nearly good enough. It appears that insertions impose an $ O(\log n)$ amortized cost, since flipping from a 1 digit to a 0 digit gets more expensive the deeper it happens in the tree. My next attempt was the same, but using skew binary numbers instead of binary numbers. Same deal. Is there some trick I’m missing, or am I asking to have my cake and eat it too?

Are there any known attacks (technical or social) against enterprises where password resets are scheduled on fixed (known) intervals?

A company I know of has a password policy that requires employees to change passwords (on AD server) every 90 days. The vast majority of its new hires start on the 1st of the month. Thus, several hundred password resets happen on a predictable schedule. My intuition tells me that this is tactically valuable information to an attacker (I am an infosec noob).

An attacker could enhance the standard "reply to this with your password" phish with a "reply to this with your password because it is time to change your password" phish. The latter seems less suspicious because the person who wrote the message knows about the password reset policy.

Are there any other attacks enhanced or made possible by a predictable password reset schedule?

I realize that (by the pigeonhole principle) every sufficiently large enterprise with a forced password change policy will have a lot of same-day password changes.