j2 | minimalist concatenative programming language | Interpreter library

This code should do everything in one subroutine and can be called from an individual button.

try below code:

"Second_workbook.xlsx" is a string and will be interpreted as a string, ignoring any variables with the same name.

Variables are written out without quotes, and strings of text have the quotes. Everything within quotes (green text) is taken as a string of text. To combine strings and variables we use the & operand like so:

I suspect you need this in cell O1:

=ARRAYFORMULA({"ID" ;H2:H&CHAR(10)&I2:I&CHAR(10)&J2:J&CHAR(10)&K2:K&CHAR(10)&L2:L&CHAR(10)&M2:M})

Probably good to add a trim as well:

=ARRAYFORMULA({"ID" ;trim(H2:H&CHAR(10)&I2:I&CHAR(10)&J2:J&CHAR(10)&K2:K&CHAR(10)&L2:L&CHAR(10)&M2:M)})

Give a try on below formula-

As I said in my comments, your code should work if the iteration is adapted to 1D arrays type. Please, test the next code, using only arrays and not involving the clipboard, slowing Excel and consuming more resources:

If you only want to highlight row between columns A & F then try-

If your timestamps are sorted and have the same format it can be done this way:

Indexing a 2D array has to scale the first index by sizeof(struct vec3[A]): array1 is an array of arrays, and each smaller array has A elements. So you look at the asm and see what it's multiplying by.

Given, struct vec3 array1[2][A];,
array1[i1][j1].x is the same address math as for a flat 1D array: array1[ (i1*A) + j1 ].x. And in C, we index by element not bytes, so the asm also has to scale by sizeof(struct vec3). That's clearly what the sal $4, %reg instructions are doing, because after padding for alignment the struct size is 16 bytes.

Notice that the leading dimension [2] doesn't come into the calculation at all; that just tells you how much total space you have. It's the later dimensions that set the geometry; the stride between the the same column in different rows.

If you don't already see how that C would compile for different A and B values, try it with some sample ones and see what changes when you increase A or B by 1. https://godbolt.org/ is ideal for playing around with stuff like that.

e.g. https://godbolt.org/z/zrecTcqMs uses prime numbers 3 and 7 for A and B, so even without changing the numbers, you can see which are multiples of which.

Except GCC is too clever for it to be that simple: it's multiplying using one or two LEA, e.g. RCX + RCX*2 = RCX*3, not using imul $3, %rcx, %rdx for example. If you use large non-simple numbers like 12345 for A and B, you'll see actual imul. https://godbolt.org/z/4G3qc5d5E.

I used gcc -fpie to make it use position-independent code: a RIP-relative LEA to get array addresses into registers, instead of addressing modes like array1(%rcx, %rdx, 2) which require the array address (in the .data or .bss section) to fit in a 32-bit sign-extended disp32 in the machine code.

I also used __attribute__((ms_abi)) to use the Windows x64 calling convention like your code does, since GCC on the Godbolt compiler explorer is targeting Linux. (MSVC is the only compiler on Godbolt that targets Windows by default, but it won't output in AT&T syntax.)