## r – Calculating average daily steps for every location in a tibble

Can someone help me calculate the average daily steps for every location from the tibble below? This is the code I have so far. The final tibble should only contain the location and daily average steps.

``````  group_by(location, date) %>%
summarise(daily_count = sum(count))
step_count_daily

> step_count_daily
# A tibble: 364 x 3
# Groups:   location (4)
location date       daily_count
<chr>    <date>           <dbl>
1 Austin   2019-01-15       5146
2 Austin   2019-01-16       9138
3 Austin   2019-01-17       4000
4 Austin   2019-01-18       2980.
5 Austin   2019-01-19       7287
6 Austin   2019-01-20       6567
7 Austin   2019-01-21       7538.
8 Austin   2019-01-22      15579
9 Austin   2019-01-23      15362
10 Austin   2019-01-24       6923
# … with 354 more rows

#This is the tibble

date_time           date       count location
<dttm>              <date>     <dbl> <chr>
1 2019-01-01 09:00:00 2019-01-01   764 Melbourne
2 2019-01-01 10:00:00 2019-01-01   913 Melbourne
3 2019-01-02 00:00:00 2019-01-02     9 Melbourne
4 2019-01-02 10:00:00 2019-01-02  2910 Melbourne
5 2019-01-02 11:00:00 2019-01-02  1390 Melbourne
6 2019-01-02 12:00:00 2019-01-02  1020 Melbourne
7 2019-01-02 13:00:00 2019-01-02   472 Melbourne
8 2019-01-02 15:00:00 2019-01-02  1220 Melbourne
9 2019-01-02 16:00:00 2019-01-02  1670 Melbourne
10 2019-01-02 17:00:00 2019-01-02  1390 Melbourne

#The output should look like this

#> # A tibble: 4 x 2
#>   location      avg_count
#>   <chr>             <dbl>
#> 1 Austin            7738.
#> 2 Denver           12738.
#> 3 Melbourne         7912.
#> 4 San Francisco    13990.
``````

## health.app – How to cross-compare Apple Health data such as weight and steps over time?

health.app – How to cross-compare Apple Health data such as weight and steps over time? – Ask Different

## Logarithmic steps inside a Do

I have trouble, i need to do several computations inside a loop using values in a logaritmic scale, is this possible?

Inside of the cicle i create a several data sctructures, and it currently works fine using the typical delimitations {i,0,1,0.0001}, but my goal is to have more computations around 0.

## health.app – Why does the iOS Health app sometimes drop my step count by hundreds of steps?

I use an activity tracker 3rd party app that syncs with Apple’s Health app, and I have a daily goal of 10,000 steps. Sometimes (not frequently, but once in a while), the step count in the Health app drops by at least a few hundred steps, e.g., it was around 9,400, and then dropped to 8,674 steps. This happens seemingly at random. Any idea about this?

## Using SQL, what are the steps taken to look up a user’s email address, and the date that email was authenticated, when their username is known

what are the steps taken to look up a user’s email address, and the date that email was authenticated, when their username is known using SQL

## ag.algebraic geometry – Evaluate the following algebraic expressions. Show all of your steps

ag.algebraic geometry – Evaluate the following algebraic expressions. Show all of your steps – MathOverflow

## time complexity – Consider a 1-tape TM that starts with n ≥ 1 written in unary/binary notation on its tape. Explain how it can count down from n to 0 in O(n) steps

Consider a 1-tape TM that starts with n ≥ 1 written in unary/binary
notation on its tape. Explain how it can count down from n to 0 in O(n) steps.

Here’s my logic to approach this problem, but I am not sure if the time complexity of part b is O(n log n).

For unary notation on the given tape, the tape has 1’s of length n >= 1. The machine on each configuration prints out the contents written in unary notation in the tape and then moves its head one step to the right by replacing 1 to x. Thus, we can intuitively see that the machine that counts down from n to 0 passes through all configurations in O(n) steps during its computation, printing out the number of 1’s in the tape on each configuration (i.e. n, n-1, n-2,…, 0).

For binary notation, if we have a binary counter representing the number n, then there will be a total of O(log n) different bits (since each bit represents exponentially smaller and smaller values). And we should pass all elements in the tape to update the value between 0 and 1, which takes O(n). Thus, the time complexity, in this case, ends up being O(n log n).

## continuous integration – Clarifying the steps in a CI/CD, but namely if if unit testing should be done building a Docker image or before

I’m building at a Build and Deployment pipeline and looking for clarification on a couple points. In addition, I’m trying to implement Trunk Based Development with short-lived branches.

The process I have thus far:

1. Local development is done on the `main` branch.

2. Developer, before pushing to remote, rebases on remote `main` branch.

3. Developer pushes to short-lived branch: `git push origin main:short_lived_branch`.

4. Developer opens PR to merge `short_lived_branch` into `main`.

5. When PR is submitted it triggers the `PR` pipeline that has the following stages:

1. Builds the microservice.
2. Unit tests the microservice.
3. If passing, builds the Docker image with a `test-latest` tag and push to container registry.
4. Integration testing with other microservices (still need to figure this out).
5. Cross-browser testing (still need to figure this out).
6. If the `PR` pipeline is successful, the PR is approved, commits are squashed, and merged to `main`.

7. The merge to `main` triggers the `Deployment` pipeline, which has the following stages:

1. Builds the microservice.
2. Unit tests the microservice.
3. If passing, builds the Docker image with a `release-<version>` tag and push to container registry.
4. Integration testing with other microservices (still need to figure this out).
5. Cross-browser testing (still need to figure this out).
6. If passing, deploy the images to Kubernetes cluster.

I still have a ton of research to do on the integration and cross-browser testing, as it isn’t quite clear to me how to implement it.

That being said, my questions thus far really have to do with the process overall, unit testing and building the Docker image:

1. Does this flow make sense or should it be changed in anyway?

2. Regarding unit testing and building the Docker image, I’ve read some articles that suggest doing the unit testing during the building of the Docker image. Basically eliminating the first two stages in my `PR` and `Deployment` pipelines. Some reasons given:

• You are testing the code and not the containerized code which is actually what will be run.
• Even if unit testing passes, the image could be broke and it will be even longer before you find out.
• Building on that, it increases the overall build and deployment time. From my experience, the first two stages in my pipelines for a specific service take about a minute and half. Then building and pushing the image takes another two and half minutes. Overall about four minutes. If the unit tests were incorporated into the Docker build, then it could possibly shave a minute or more off the first three stages in my pipeline.

Would this be a bad practice to eliminate the code build and unit testing stages, and just moving unit testing into the Docker build stage?

Thanks for weighing in on this while I’m sorting it out.

## progress bar – User Experience for non linear steps

Non-linear interfaces have pros and cons that go beyond the UI layout. Consider your intended and likely use cases carefully.

I’ve tackled similar requests a variety of times over the years. There are occasions where the desire for non-linearity comes from the users, but they are rare.

Humans are linear beings. Unless you have a system where multiple users are interacting with a single form simultaneously, your single user can’t really multitask. (They can’t physically fill out steps 1-4 at the same time they do steps 5-8.)

When presented with a single list of steps, users will tend to start at the top and move through them each in turn. Even if they can skip right to the middle or end, they usually won’t because they have to do all the steps eventually anyway, so the might as well do them in some sort of order. It’s inefficient to jump around randomly, so they go with the order they are on the screen as the path of least resistance. If you have some cases where things must be done in order users will likely adapt to doing everything else in order too, since there’s not much of an interaction downside.

For example, think of filling out your name and address to ship a package. Nothing stops you from filling out your state first followed by your last name then your street and so on. But why bother?

Users may be motivated by things like a desire to pause at a random step so they don’t lose work if they get interrupted or wanting to be able to return to edit a section without redoing all the steps, but these things lead to a non-linear interface as a side effect, rather than as the desired goal.

If you really have steps that need to be done in parallel (they take a long time, or something) structuring them as 3 columns of 5 steps will help convey that they are separate more than 1 column with 15 steps in groups, especially if each column has it’s own completion percentage.

Another possibility is to design things similar to most tax software: groups of questions that can be done in any order, but the overall order of the groups is fixed. They also decouple saving and submitting the data so that users can jump around as much as they want without losing work, but when they think they are done there’s a final step to review the information before it is all submitted.

## algorithms – How to implement steps counter in heap and quick sort?

So i am trying to compare heap and quick sort within different data sets of length 256 and 2046. However i tried using counters and its giving me heap sort as having higher num of operations for both the smaller data set and also for the higher data set. However i would have expected heap so have performed better in the larger data set. Can someone see if i have put my counters in the wrong location to count the ‘steps’? (I have global variables for both outside) Thanks.

``````Dataset size   256     4096
Quick         4107    60134
Heap          4791    47847
``````

HEAP

``````public int() HeapSortAscending(int() Heap)
{
int HeapSize = Heap.Length;
int i;

for (i = (HeapSize - 1) / 2; i >= 0; i--)
{
counterAsc++;
Max_Heapify(Heap, HeapSize, i);
}

for (i = Heap.Length - 1; i > 0; i--)
{
counterAsc++;
int temp = Heap(i);
Heap(i) = Heap(0);
Heap(0) = temp;
HeapSize--;
Max_Heapify(Heap, HeapSize, 0);
}

Console.WriteLine(\$"Total Num of Steps Is : {counterAsc} (ascending)");
return Heap;
}

private void Max_Heapify(int() Heap, int HeapSize, int Index)
{
int Left = (Index + 1) * 2 - 1;
int Right = (Index + 1) * 2;
int largest = 0;

counterAsc++;
if (Left < HeapSize && Heap(Left) > Heap(Index))
{
largest = Left;
}
else
{
largest = Index;
}
if (Right < HeapSize && Heap(Right) > Heap(largest))
{
largest = Right;
}
if (largest != Index)
{
int temp = Heap(Index);
Heap(Index) = Heap(largest);
Heap(largest) = temp;
Max_Heapify(Heap, HeapSize, largest);
}
}
``````

QUICK

``````public int() QuickSortAscending(int() data,string steps = "no")
{
Quick_Sort_Ascending(data, 0, data.Length - 1); // Takes in counter to keep track off
if(steps == "yes")
Console.WriteLine(\$"Total Num of Steps Is : {counterAsc} (ascending)");
return data;
}

private void Quick_Sort_Ascending(int() data, int left, int right)
{
int i, j;
int pivot, temp;

i = left;
j = right;
pivot = data((left + right) / 2);

do
{
counterAsc++;
while ((i < right) && (data(i) < pivot))
{
i++;
counterAsc++;
}

while ((j > left) && (pivot < data(j)))
{
j--;
counterAsc++;
}

if (i <= j)
{
temp = data(i);
data(i) = data(j);
data(j) = temp;
i++;
j--;
}

} while (i <= j);

if (left < j)
{
counterAsc++;
Quick_Sort_Ascending(data, left, j);
}

if (i < right)
{
counterAsc++;
Quick_Sort_Ascending(data, i, right);
}
}
``````