g suite – Proposals for handling business combinations – One uses Office365, the other GSuite

A few important points for now
– e.g. CompanyA = Office365, CompanyB = GSuite
– Both companies are on separate domains and do not have to be migrated to one immediately
– Ideally we don't HAVE to all work with Office365 or GSuite at the moment. However, it would be good if companyA.com occasionally logs into company B's GSuite Managed Services and vice versa

So I wondered if the federated logon should work between the two systems, so that company A can log in to a system via Google via their own company A.com email and a company B user can log on via their company B.com can register with an Office 365 system email?

Is this feasible or am I dreaming?

Key combinations – How can carabiners assign the function to a key that is no longer assigned to the original function?

I switched the mostly useless caps lock with carabiner to escape. But it's just that mostly useless, so I want to assign Shift-CapsLock to real Caps-Lock behavior.

I've tried the following advanced mapping JSON, but it causes Shift-CapsLock to behave like Escape – possibly because caps_lock has already been dropped from its original function.

How can I achieve this?

{
     "description": "shift-caps_lock to Capslock",
     "manipulators": [
         {
             "from": {
                 "key_code": "caps_lock",
                   "modifiers": [
                       "shift"
                   ]
             },
             "to": {
                 "key_code": "caps_lock",

             },
             "type": "basic"
         }
     ]
},

Algorithms – Temporal complexity of combinations of n pairs of brackets

I have the following snippet of code for combinations of n pairs of parentheses.

def parens(n):
    if n <= 0:
        return ('')
    else:
        combinations = ()
        helper('', n, n, combinations)
        return combinations


def helper(string, left, right, combinations):
    if left <= 0 and right <= 0:
        combinations.append(string)
    else:
        if left > 0:
            helper(string + '(', left - 1, right, combinations)
        if right > left and right > 0:
            helper(string + ')', left, right - 1, combinations)

What is the reasonable estimate of the time complexity?

My attempt:

  1. (2n)! / N! N! since it is a complete permutation with the same element, with more restrictions: (upper bound)
  2. Resolve repetition: T (n) = 2T (n-1) => O (2 ^ n)

postgresql – Choose different combinations of lines

I'm trying to choose different row combinations (author_id. recipient_id) while maintaining the following order and limit, My current code:

select * from (
  select distinct on (author_id, recipient_id) * from private_message where author_id=665 or recipient_id=665
) p_m
order by id desc
limit 20;

Enter image description here

In this case, I want to stay taller idTherefore, a message with id = 10 must be deleted because it is a duplicate of id = 18.

physical constants package – usable units for combinations of physical constants like on tungsten alpha?

When I have to make estimates on the order of magnitude, I often come across situations where I have a jumble of physical constants and have difficulty getting them into meaningful units.

For example, consider the combination:

$$ frac { hbar ^ 2} {m e} $$

Where $ hbar $ is the reduced Planck constant, $ m $ is the electron mass and $ E $ is the electron charge. I don't know the units of this combination a priori, but when I type them into Wolframalpha, I get really useful unit combinations (see here) and find that the combination has units of $ Volt cdot meter ^ 2 $,

When I put and use this combination in Mathematica

hbar = PlanckConstantReduced; m = ElectronMass; e = ElectronCharge;

UnitSimplify((hbar ^2)/(m e))

I get the amount in a jumble of units of joules, seconds, coulombs, and kilograms.

Is there any way to get Mathematica to suggest a list of useful entities like Wolframalpha? In other words, can we get Mathematica to create "smart" simplified unit combinations?

Create a function in PHP that calculates the number of combinations

How to create a function that calculates the number of combinations of n elements p to p. using the following combination formula: C = n! / p! (n – p)!

SQL Server – How Do I Write a Query to Identify Common Combinations of Parameters Used to Invoke a Saved Process?

You must find all the different groups of parameter values ​​for a particular process and then sort them by the number of these groups. Something like that:

SELECT 
    spc.Param1,
    spc.Param2,
    ...,
    spc.Param99,
    COUNT_BIG(*)
FROM dbo.StoredProcedureCall spc
WHERE
    spc.StoredProcedureName = 'sp_YourProc'
GROUP BY
    spc.Param1,
    spc.Param2,
    ...,
    spc.Param99
ORDER BY
    COUNT_BIG(*) DESC;

That would give the different parameters sp_YourProc was called with, from most frequently to least frequently ordered.

If you are not interested in the values ​​and just want to know that certain parameter combinations are used, you can replace static values ​​like the following:

SELECT 
    CASE WHEN spc.Param1 <> '' THEN 1 ELSE 0 END,
    CASE WHEN spc.Param2 <> '' THEN 1 ELSE 0 END,
    ...,
    CASE WHEN spc.Param99 <> '' THEN 1 ELSE 0 END,
    COUNT_BIG(*)
FROM dbo.StoredProcedureCall spc
WHERE
    spc.StoredProcedureName = 'sp_YourProc'
GROUP BY
    CASE WHEN spc.Param1 <> '' THEN 1 ELSE 0 END,
    CASE WHEN spc.Param2 <> '' THEN 1 ELSE 0 END,
    ...,
    CASE WHEN spc.Param99 <> '' THEN 1 ELSE 0 END,
ORDER BY
    COUNT_BIG(*) DESC;

Matrices – differences between combinations of real numbers

I would like to ask what the difference is

$ mathbb {R} ^ n, mathbb {R} ^ {n times n}, mathbb {R} ^ {2n} $?

I try to understand what the difference is, because for $ mathbb {R} ^ n $ They place vectors as coulums in a matrix.

Example of a $ mathbb {R} ^ 2 $ as I understand it is:

$ vec {a} ^ T = (1,2), vec {b} ^ T = (3,4) Rightarrow underline {A} = left ( begin {array} {c} 1 & 3 \ 2 & 4 end {array} right) $

but for just a tuple of numbers, I get that for A, which is not a matrix:

$ A = {(1,3), (1,4), (2,3), (2,4) } $

I am a bit confused what the rest of them would be and how to take the position for matrices.
Thanks for any help to understand the differences. Examples would be alright.

br