kevin | stupid self-hostable continuous integration service | Continuous Deployment library

The problem is that two numbers, pitch and yaw, provide insufficient degrees of freedom to represent consistent free rotation behavior in space without any “horizon”. Two numbers can represent a look-direction vector but they cannot represent the third component of camera orientation, called roll (rotation about the “depth” axis of the screen). As a consequence, no matter how you implement the controls, you will find that in some orientations the camera rolls strangely, because the effect of trying to do the math with this information is that every frame the roll is picked/reconstructed based on the pitch and yaw.

The minimal solution to this is to add a roll component to your camera state. However, this approach (“Euler angles”) is both tricky to compute with and has numerical stability issues (“gimbal lock”).

Instead, you should represent your camera/player orientation as a quaternion, a mathematical structure that is good for representing arbitrary rotations. Quaternions are used somewhat like rotation matrices, but have fewer components; you'll multiply quaternions by quaternions to apply player input, and convert quaternions to matrices to render with.

It is very common for general purpose game engines to use quaternions for describing objects' rotations. I haven't personally written quaternion camera code (yet!) but I'm sure the internet contains many examples and longer explanations you can work from.

As a general rule, if you need to move away from each($ar) you can usually use [key($ar),current($ar)] as a drop in replacement but then you need to move the pointer within the loop. You usually just need to call next($ar) within the loop and break once you run out of reading room such as breaking when the key is null. Then just make sure the array becomes set to false when it runs out of room.

This type of approach can get ugly very quickly though due to the extra code...

So without really paying much attention to your code, after this update, your revised code would like look:

Basically you can change the order of a and b sort params depending on the order param you pass to your custom function. Then also based on the type of current param (string or number) you use different types of sort method.

count(DISTINCT activity_id) to fold duplicates in the count, like Edouard suggested.
But there is more:

If you got like here 13 people, you used teams of three until you need a team of four for the other people. Now you have to create an algorithm that will create teams in a size of three to five. I think this variation of members per team is for the problem that the people can't fit in teams of like three. I would create teams of three until I need teams of four or five. Also you can create all teams in all sizes but this is for a higher number of people too much teams.

You can use

We can use unite from tidyr along with coalesce (assuming the ..... are NA values). If those are ..., then change it to NA with a mutate step (as below)