algorithms – How to check if $x$ equals a certain value $y$ with while loops, addition and substraction

Consider, we are only allowed to use loops ($while$), addition ($+$), substraction ($-$) and checking if a value is $> 0$. How can one find out, if a certain variable $x$ equals a value $y$? E.g. how can I find out if $x=4$ by only using the aforementioned methods? For $x=0$ I came up with the following:

y = 1
while x > 0:
    y = y - 1
    x = x - 1
while y > 0:
   do something

This way, $something$ gets only executed if $x=0$. But I have no clue about values above $0$.

graphics – I have some assembly code that makes the screen fade out on my MS-DOS game. It works, but it loops continuously

I am making a game with C and assembly for MS-DOS (I am planning to distribute the game with DOSBox or my own modification thereof). I large portions of the graphics code are in assembly, which is a language I am weaker in, but I saw it as something that was convenient to use due to its ability to change things to such a nitty-gritty level (down to things like the graphical palette and such).

However, I am basing my code off of a fade out function that I found from some old source code that was in 16 bit assembly, and I am trying to convert it to 32 bit assembly.

I got the code to work, but however, it keeps looping repeatedly instead of continuing the code.

AFObeg  equ (bp+4)
AFOcnt  equ (bp+4+2)

proc FadeOut_ near
    push    ebx
    push    ecx
    push    edx
    mov ebp,esp
    push    ds
    push    esi
    push    edi

    push    ds        ; get data segment into es
    pop es
    mov edx, offset _WorkPalette
    push    edx       ; save offset of opal
    xor ebx, ebx
    mov ecx, 100h
    mov eax, 1017h    ; bios read dac registers function
    int 10h       ; read the palette registers into opal
    pop edi       ; offset of opal, was in dx!
    mov eax, AFObeg   ; get offset of first palette byte to
    mov ebx, 3        ; be processed
    mul ebx
    add edi, eax          ; adjust offset into opal
    mov eax, AFOcnt   ; find the number of bytes to be processed
    mov ebx, 3
    mul ebx       ; leave it in ax
    mov ecx, 64       ; 64 passes through fade loop
    push    ecx       ; save the fade loop counter
    push    edi       ; save offset of first byte processed in
    mov bl, cl        ; we'll use the pass number as a threshold
    mov ecx, eax          ; load number of bytes to process into cx
    cmp bl, es:(edi)      ; start decrementing when palette value
    jnz o_no_dec      ; is equal loop count (it will stay equal
    dec BYTE PTR es:(edi)  ; to loop count for the rest of this pass)
    inc edi
    loop    o_pal_cmp_loop      ; do the next byte

    mov ebx, esp            ; need the stack pointer for a moment
    mov di, ss:(ebx)        ; restore offset into pal without popping
    mov ecx, AFOcnt     ; number of triplets to process
    push    eax         ; need to use ax for port i/o

        mov edx, 03DAh      ; CRT controller input status 1 register
        in al, dx           ; watch vertical blanking bit
        test al,08h         ; wait for it to clear to make sure
        jnz o_vbi_1         ; we're not in a blanking interval
        in al, dx           ; now wait for the start of the
        test al,08h         ; next blanking interval
        jz o_vbi_2

    mov ah, AFObeg ; get first register to process into ah
    mov dx, 03c8h       ; DAC palette index register
    mov al, ah          ; get next palette number to write
    out dx, al          ; write the register number to the dac
    inc dx          ; address dac data register
    mov al, BYTE PTR es:(di) ; get first byte of triplet
    out dx, al           ; write it to the dac data register
    inc edi          ; point to second byte
    mov al, BYTE PTR es:(di) ; get second byte of triplet
    out dx, al           ; write it to the dac data register
    inc edi          ; point to third byte
    mov al, BYTE PTR es:(di) ; get third byte of triplet
    out dx, al           ; write it to the dac data register
    inc edi          ; point to first byte of next triplet
    dec edx          ; address the da21c index register
    inc ah           ; point to next palette register
    loop    o_pal_load_loop      ; process next triplet

    pop eax       ; restore ax
    pop edi       ; restore the offset into pal
    pop ecx       ; restore the fade loop counter
    loop    o_fade_loop   ; do the next pass through the fade loop

    pop edi
    pop esi
    pop ds
    pop ebp
    endp ;end of the fade out function

If anyone has any more questions, I will gladly answer them.

sql server – What does Nested Loops join operator has to do with a Scalar?

As far as I understand the docs, the Nested Loops operator is a join operator, i.e., it requires two tables as input.

If that’s correct, then why the Nested Loops operator is used with a Scalar input?

For example, take the following query (from Paul White’s website) and its execution plan.
You can see that the inputs for the Nested Loops operator are (1) a Scalar, and (2) a table (the result of the Index Seek).

I know that a scalar can’t be joined with a table, then what that actually means? What’s actually being joined?

USE AdventureWorks2019;
DECLARE @Like nvarchar(50) = N'D%';
SELECT p.(Name)
FROM   Production.Product AS p
WHERE  p.(Name) LIKE @Like;

enter image description here

BTW, I presume that it’s a pretty basic question, but I couldn’t find a good resource that goes through such basics methodologically, so a recommendation would be much appreciated.

Get Each Digits of Number with Using Loops in C++

I need a program same as I wrote but using loops. (if else for etc.) . Program is that enter a number and get each digits of number like that: number is 123456. I’m beginner, I can’t create the logic and can’t combine loops. Can anybody help me about that situation?

1.digits is 6
2.digits is 5
3.digits is 4
4.digits is 3
5.digits is 2
6.digits is 1
7.digits is 0
8.digits is 0
9.digits is 0


#include <iostream>
using namespace std;

    int main() 
        int number,first,second,third,fourth,fifth,sixth,seventh,eighth,ninth;
        cout<< "Enter a number (<999999999): " << endl;
        first = number%10;
        second = number/10%10;
        third = number/100%10;
        fourth = number/1000%10;
        fifth = number/10000%10;
        sixth = number/100000%10;
        seventh = number/1000000%10;
        eighth = number/10000000%10;
        ninth = number/100000000%10;
        cout<<"1. digit is"<<" "<<first<<endl;
        cout<<"2. digit is"<<" "<<second<<endl;
        cout<<"3. digit is"<<" "<<third<<endl;
        cout<<"4. digit is"<<" "<<fourth<<endl;
        cout<<"5. digit is"<<" "<<fifth<<endl;
        cout<<"6. digit is"<<" "<<sixth<<endl;
        cout<<"7. digit is"<<" "<<seventh<<endl;
        cout<<"8. digit is"<<" "<<eighth<<endl;
        cout<<"9. digit is"<<" "<<ninth<<endl;
        return 0;

postgresql – How to limit tree traversal in case of loops?

So I want to limit tree depth traversal (as the simplest recursion killer tool). Example code that turns normalized records into tree:

  item_id     serial PRIMARY KEY,
  title text
  id          serial PRIMARY KEY,
  item_id     int,
  child_id    int
INSERT INTO items (item_id,title) VALUES
  (2,'LEVEL 2'),
  (3,'LEVEL 3.1'),
  (4,'LEVEL 4.1'),
  (5,'LEVEL 4.2'),
  (6,'LEVEL 3.2');
INSERT INTO joins (item_id, child_id) VALUES

WITH RECURSIVE t(item_id, json) AS (
        SELECT item_id, to_jsonb(items)
        FROM items
                SELECT 1
                FROM joins
                WHERE items.item_id = joins.item_id
        UNION ALL
        SELECT parent.item_id, to_jsonb(parent) || jsonb_build_object( 'children', t.json )
        FROM t
        JOIN joins AS j
                ON t.item_id = j.child_id
        JOIN items AS parent
                ON j.item_id = parent.item_id
SELECT item_id, jsonb_pretty(json)
WHERE item_id = 1;

It works thanks to this beautiful answer. Now imagine we had

INSERT INTO joins (item_id, child_id) VALUES

So we get a loop 1->2->3->1 and I want to limit its output using limiters – I want all my trees to be no bigger than depth X set by a number I give to this tree constructing function. How to do such thing in postgres 13+?

memory access – How does changing cache size and/or block size affect the hit rate of the for loops in the following code?

I am working on practice problems to study for an upcoming exam. I am given the following piece of code:

#define LEAP 4
#define SIZE 64
int foo(SIZE);
// Assume foo has been initialized to contain values.
// Assume the cache starts empty at this point.
for (int i = 0; i < SIZE; i += LEAP) { // Loop 1
  foo(i) = foo(i) + i * (i + 2);
for (int j = 1; j < SIZE; j += (LEAP * 2)) { // Loop 2
  foo(j) = foo(j) + j * 5;

I have a direct-mapped cache containing 128 bytes with a cache block size of 32 bytes. The cache uses LRU replacement and write-allocate and write-back policies. I also need to assume i and j are stored in registers, the array foo starts at address 0x0, and the cache starts out empty. I already determined the hit rate for both Loop 1 and Loop 2, however, I am exploring more into this problem than what is asked as an exercise.

Assuming that all factors remain the same as shown in the original code, how would changing cache size (say from 128 bytes to 256 bytes) affect the hit rate of both loops? Similarly, how would changing the block size (say from 32 bytes to 16 bytes) affect the hit rate of both loops?

My initial assumption would be that if we increased the cache size, then that would increase the hit rate of both loop 1 and loop 2 because it would reduce misses. For decreasing block size, then the hit rate would increase for both loop 1 and loop 2 because if block size was increased, then there would be a decreased number of entries in the cache and it will take more time to fetch block size from memory.

Is my logic incorrect? If so, can someone explain what would happen in terms of the hit rate in both loops by implementing the changes I am suggesting. I am still a little unsure of what I claim would be true. Any feedback or suggestion in helping me answer this conceptual question would be greatly appreciated.

performance – How can I speed up a C++ code with several loops

I have recently started to work with C++ and I do consider myself quite basic in C++ coding.

I have made the following two functions and I was wondering whether someone could give me some hints on how to improve and speed up this code.

Please, note that the second function is then used in R through Rcpp R package.

#include <Rcpp.h>
using namespace Rcpp;
using namespace std;

double sumAll(double i, double j, int a, int b, double coeff) {

  double pi = 2 * acos(0.0);

  double total = 0;
  int half_a =  a / 2;
  int half_b =  b / 2;

  for (int k = 0; k <= half_a; ++k) {

    for (int l = 0; l <= half_b; ++l) {

      double fkl;
      if (k == 0 && l == 0) {
        fkl = 0;
      } else {
        fkl = pow((1 - (coeff * (1 - cos(2.0 * pi * k / a)))), 2.0) *
              pow((1 - (coeff * (1 - cos(2.0 * pi * l / b)))), 2.0);

      double a1 = 1 - (cos(2.0 * pi * i * k / a) * cos(2.0 * pi * j * l / b));

      double deltaa;
      if (k == 0) {
        deltaa = 1;
      } else {
        deltaa = 0.5;

      double deltab;
      if (l == 0) {
        deltab = 1;
      } else {
        deltab = 0.5;

      if (k == 0 && l == 0) {

        total = total + 0;

      } else {

        double res = (fkl * a1) / (deltaa * deltab * (1 - fkl));

        total = total + res;
  return total;

// ((Rcpp::export))
NumericVector series_Sum(NumericVector xvec, NumericVector yvec, int a, int b,
                         double coeff) {

  int size = xvec.length();
  NumericVector series_res(size);
  int half_a = a / 2;
  int half_b = b / 2;

  for (double i = 0; i < size; i++) {
    series_res(i) = sumSij(half_a, half_b, xvec(i), yvec(i), a, b, coeff);

  return series_res;

Consider that in `sumAll` :
- i and j: are integers, which can get values between 0 and a/2 or 0 and b/2, respectively.
- coeff: can be a value between 0 and 1.0.
- a and b: can be any integer values higher than 5 (arbitrary choice).

In `series_Sum` :
- xvec and yvec: are vectors of i and j values.

In other words, `series_Sum` use `sumAll` over several possible combinations of i and j.

Postfix “loops back to myself” only when trying to send to fallback relay

I have read the many answers to many similar questions, but have not found exactly this question or any answer that helped.

I have a Postfix 2.11 server ( that is strictly for outgoing email. It works fine if it is able to send the email on the first try. However, for performance reasons, if it cannot send the email on the first try and instead wants to defer it, I have configured smtp_fallback_relay so that it forwards the email to another server ( that handles only deferred emails.

If, from my trusted IP (mynetworks), I send an email to either server destined for, either server will accept it and try to send it to Gmail. Because my server IP is new, Gmail rejects the email from either server with 421 (temporary deferral). As expected, the deferred-mail server simply puts the message in its deferred queue and tries again later.

The weird part is that while mail-server will send the message to Gmail to begin with, after receiving the 421, it attempts to send the mail to deferred-mail, but gives up and instead bounces the message, saying “mail for loops back to myself”. I see no logs on the deferred-mail server saying anything about what is going on.

So both servers are configured to accept mail and relay it to Gmail if the client is trusted, and the deferred-mail trusts mail-server (I can send to a Gmail address when directly connecting to deferred-mail from `mail-server), so how is Postfix coming up with this “loop” and why is it bouncing the email instead of relaying it?

Per request, here are redacted logs of the error:

postfix/smtpd(26668): 50F7C5B81:
postfix/cleanup(26682): 50F7C5B81: message-id=<>
opendkim(36): 50F7C5B81: can't determine message sender; accepting
postfix/qmgr(143): 50F7C5B81: from=<REDACTED-SENDER>, size=279, nrcpt=1 (queue active)
postfix/smtp(26686): 50F7C5B81: host said: 421-4.7.0 (REDACTED-PUBLIC-IPv4      15) Our system has detected that this message is 421-4.7.0 suspicious ... 
postfix/smtp(26686): connect to Cannot assign requested address
postfix/smtp(26686): connect to Cannot assign requested address
postfix/smtp(26686): 50F7C5B81: host said: 421-4.7.0 (REDACTED-PUBLIC-IPv4      15) Our system has detected that this message is 421-4.7.0 suspicious ...
postfix/smtp(26686): warning: host greeted me with my own hostname
postfix/smtp(26686): warning: host replied to HELO/EHLO with my own hostname
postfix/smtp(26686): 50F7C5B81: to=<>,, delay=26, delays=24/0.01/1.5/0, dsn=5.4.6, status=bounced (mail for loops back to myself)

log messages here about sending bounce email to sender
have been removed 

postfix/bounce(26688): 50F7C5B81: sender non-delivery notification: AEA8A5B83
postfix/qmgr(143): 50F7C5B81: removed

python – What is more efficient? using conditions before for loops? or vice versa?

I’d like to know what is more efficient and performant for the following two cases:

  1. Using conditions before for loops:
if food == 'tomato':
  for i in range(1,000,000):
    <some logic>
elif food == 'banana':
  for i in range(1,000,000):
    <some other logic>
  1. OR to use one for loop before the conditions:
for i in range(1,000,000):
  if food == 'tomato':
    <some logic>
  elif food == 'banana':
    <some other logic>

The first case checks the if condition just one time but uses repeated for loops

but the second case uses the same for loop but we need to check a million times!

which one di you think is better?

finance – Calculating Average Price and P&L Efficiently Without Loops

A very common task is stock portfolio evaluation is to calculate the average price of stock holdings for a sequence of trades and from there to calculate the (realized) profit or loss. Obviously one can easily accomplish the task using Do loops, but that’s a very inefficient (and inelegant) approach to take in Mathematica.

I am looking for an elegant, efficient solution that will likely make use of functions like PairFoldList and/or SequenceFoldList.

Here is a simple, toy example shown as an Excel table for simplicity:

enter image description here

There are five transactions in total. In the first three transactions a total of 625 shares are acquired at three different prices. The total value of the portfolio is calculated and the average price is simply this value divided by the total number of shares in the portfolio (e.g. $1062.50 / 635 = $1.70 after the third transaction).

In the fourth transaction we dispose of 400 shares of the portfolio and we now calculate a P&L, as this is a closing transaction, using the average price: 400 * ($2.50 – $1.70) = $320.

Note that the average price remains at its previous value (i.e $1.70).

If the fifth transaction the remainder of the shares (225) are sold giving a profit of 225 * ($3.00 – $1.70) = $292.50.

The total PL from all transactions in this example is $612.50.

I am looking for two functions, the first that will generate a list of average prices { $1.00, $1.32, $1.70, $1.70, $0 } and the second a list of realized PLs: { $0, $0, $0, $320, $292.50 }.

As I say, doing this with loops is trivial, but can be very slow if the number of transactions is large.

Important note: it is vital to take account of the possibility of going short. So, for instance, if in the fifth transaction we had sold 500 shares, instead of just the remaining 225 shares in the portfolio, we would now be net short 275 shares and the table would read as follows:

enter image description here

Note that:
(i) the realized P&L remains unchanged
(ii) the Av Price for the fifth transaction is no longer 0 (or #DIV/0! in Excel), but $3.00, the price at which the excess of 275 shares were sold short.

In other words, a change of sign on the portfolio value restarts the computation of the average price sequence.

Not an easy challenge!