How to resolve the algorithm Duffinian numbers step by step in the BASIC programming language

Published on 12 May 2024 09:40 PM

How to resolve the algorithm Duffinian numbers step by step in the BASIC programming language

Table of Contents

Problem Statement

A Duffinian number is a composite number k that is relatively prime to its sigma sum σ. The sigma sum of k is the sum of the divisors of k.

161 is a Duffinian number.

Duffinian numbers are very common. It is not uncommon for two consecutive integers to be Duffinian (a Duffinian twin) (8, 9), (35, 36), (49, 50), etc. Less common are Duffinian triplets; three consecutive Duffinian numbers. (63, 64, 65), (323, 324, 325), etc. Much, much less common are Duffinian quadruplets and quintuplets. The first Duffinian quintuplet is (202605639573839041, 202605639573839042, 202605639573839043, 202605639573839044, 202605639573839045). It is not possible to have six consecutive Duffinian numbers

Let's start with the solution:

Step by Step solution about How to resolve the algorithm Duffinian numbers step by step in the BASIC programming language

Source code in the basic programming language

 100  DEF  FN MOD(NUM) = NUM -  INT (NUM / DIV) * DIV: REM NUM MOD DIV
 110  M = 50:N = 4
 120  PRINT "FIRST "M" DUFFINIAN NUMBERS:"
 130  FOR C = 0 TO M STEP 0
 140      GOSUB 600"DUFF
 150      IF DUFF THEN  PRINT  RIGHT$ ("   " +  STR$ (N),4);:C = C + 1
 160      N = N + 1
 170  NEXT C
 180  M = 15:S = 4:M$ =  CHR$ (13)
 190  PRINT M$M$"FIRST "M" DUFFINIAN TRIPLETS:"
 200  FOR C = 0 TO M STEP 0
 210      FOR D = 2 TO 0 STEP  - 1:N = S + D: GOSUB 600: IF DUFF THEN  NEXT D
 220      IF D < 0 THEN C = C + 1: PRINT  RIGHT$ ("   " +  STR$ (S) + "-",5) LEFT$ ( STR$ (S + 2) + "    ",5);:D = 0
 230      S = S + D + 1
 240  NEXT C
 250  END

 REM ISPRIME V RETURNS ISPRIME
 260  ISPRIME = FALSE: IF V < 2 THEN  RETURN
 270  DIV = 2:ISPRIME =  FN MOD(V): IF  NOT ISPRIME THEN ISPRIME = V = 2: RETURN
 280  LIMIT =  SQR (V): IF LIMIT >  = 3 THEN  FOR DIV = 3 TO LIMIT STEP 2:ISPRIME =  FN MOD(V): IF ISPRIME THEN  NEXT DIV
 290  RETURN

 REM GREATEST COMMON DIVISOR (GCD) A B RETURNS GCD
 300  A =  ABS ( INT (A))
 310  B =  ABS ( INT (B))
 320  GCD = A *  NOT  NOT B
 330  FOR B = B + A *  NOT B TO 0 STEP 0
 340      A = GCD
 350      GCD = B
 360      B = A -  INT (A / GCD) * GCD
 370  NEXT B
 380  RETURN

 REM SUMDIV NUM RETURNS SUM
 400  DIV = 2
 410  SUM = 0
 420  QUOT = NUM / DIV
 430  IF DIV > QUOT THEN SUM = 1: RETURN
 440  FOR LOOP = 0 TO 1 STEP 0
 450      IF  FN MOD(NUM) = 0 THEN SUM = SUM + DIV: IF DIV <  > QUOT THEN SUM = SUM + QUOT
 460      DIV = DIV + 1
 470      QUOT = NUM / DIV
 480      LOOP = DIV > QUOT
 500  NEXT LOOP
 510  SUM = SUM + 1
 520  RETURN

 REM DUFF N RETURNS DUFF
 600  DUFF = FALSE
 610  V = N: GOSUB 260"ISPRIME
 620  IF ISPRIME THEN  RETURN
 630  NUM = N: GOSUB 400"SUMDIV
 640  A = SUM:B = N: GOSUB 300"GCD
 650  DUFF = GCD = 1
 660  RETURN


#include "isprime.bas"

Function GCD(p As Integer, q As Integer) As Integer
    Return Iif(q = 0, p, GCD(q, p Mod q))
End Function

Function SumDiv(Num As Uinteger) As Uinteger
    Dim As Uinteger Div = 2, Sum = 0, Quot
    Do
        Quot = Num / Div
        If Div > Quot Then Exit Do
        If Num Mod Div = 0 Then
            Sum += Div
            If Div <> Quot Then Sum += Quot
        End If
        Div += 1
    Loop
    Return Sum+1
End Function

Function Duff(N As Uinteger) As Boolean
    Return Iif(isPrime(N), False, GCD(SumDiv(N), N) = 1)
End Function

Dim As Integer C = 0, N = 4
Print "First 50 Duffinian numbers:"
Do
    If Duff(N) Then
        Print Using "####"; N;
        C += 1
        If C Mod 20 = 0 Then Print
    End If
    N += 1
Loop Until C >= 50

C = 0 : N = 4
Print !"\n\nFirst 50 Duffinian triplets:"
Do
    If Duff(N) And Duff(N+1) And Duff(N+2) Then
        Print Using !" [###### ###### ######]\t"; N; N+1; N+2;
        C += 1
        If C Mod 4 = 0 Then Print
    End If
    N += 1
Loop Until C >= 50

Sleep

  

You may also check:How to resolve the algorithm Sequence: nth number with exactly n divisors step by step in the C++ programming language
You may also check:How to resolve the algorithm Superpermutation minimisation step by step in the Sidef programming language
You may also check:How to resolve the algorithm Van der Corput sequence step by step in the Swift programming language
You may also check:How to resolve the algorithm Terminal control/Ringing the terminal bell step by step in the Common Lisp programming language
You may also check:How to resolve the algorithm Find the intersection of two lines step by step in the AutoHotkey programming language