UTY

This program provides three utility functions accessible from a menu: determining the day of the week for a given date, calculating the number of days between two dates, and converting a dollar/cents amount (up to $99.99) into written English text. The day-of-week calculation at line 1150 implements a variant of Zeller’s congruence, adjusting for century terms. The dollars-to-text converter at line 2000 builds a 27-row string array D$() holding number words and uses a subroutine at line 10 to extract variable-length entries, compensating for the fixed-width string array by scanning for trailing spaces. An animated logo routine beginning at line 9550 reads character ROM data via PEEK from address 7680 and renders three letters pixel-by-pixel on screen before displaying a copyright notice.

---

Program Analysis

Program Structure

The program is organised into four distinct regions: a shared subroutine block, a main menu, three utility modules, and a startup/logo routine.

Lines	Purpose
10–70	Shared subroutines: string-array word extractor (10) and DIM G$(9) initialiser (15)
500–580	Main menu — displays options D, N, T and polls INKEY$
1000–1180	Module D: day-of-week via Zeller’s congruence
1500–1690	Module N: days between two dates
2000–3250	Module T: dollars/cents to English text
9550–9680	Startup: logo renderer, copyright notice, then falls through to menu

Execution begins at line 9550 (the startup block), renders the animated logo, then jumps to the menu at line 500. All three utility modules return to 505 (the menu re-entry point with a CLS) after completing their output.

Subroutines at Lines 10 and 15

Because ZX81 BASIC does not support variable-length string arrays, D$() is dimensioned as DIM D$(27,9) — every row is exactly nine characters, padded with spaces. The subroutine starting at line 10 accepts an index in A and a modifier X1 (used to offset into the tens-words section), computes X as the row index, then scans columns 1–9 to find where trailing spaces begin, storing the result in H. Callers then use G$(1 TO H) to print only the significant characters.

Line 15 (DIM G$(9)) is a subroutine entry point — a clever reuse of a DIM statement mid-program. Calling GOSUB 15 re-dimensions G$ and then falls through into the word-extraction loop at line 20, meaning the same loop body serves both the “fresh dimension” path and the normal extraction path entered via GOSUB 10.

Day-of-Week Module (Lines 1000–1180)

The formula at line 1150 is a variant of Zeller’s congruence:

• Q = Y - (M<3) — adjusts year for January/February being treated as months 13/14 of the prior year.
• K = Q/100 — century term (not INTed here; used in INT(K) and INT(K/4) below).
• T = M + 12*(M<3) — adjusted month number.
• R = INT(13*(T+1)/5) + INT(5*Q/4) - INT(K) + INT(K/4) + D + 5 — core Zeller sum.
• R = R - 7*INT(R/7) + 1 — reduces to range 1–7.

The result indexes into B$ (" MONTUEWEDTHUFRISATSUN") using B$((R*3) TO (R*3)+2), producing a three-character day abbreviation. The two leading spaces in B$ act as a placeholder for index 0 (which should never occur with valid input).

Days-Between Module (Lines 1500–1690)

This module approximates the day count using a decomposed arithmetic approach rather than Julian Day Numbers:

• Y = 365*(Y2-Y1) — year contribution in days.
• M = 31*(M2-M1) — month contribution, using 31 days per month as an approximation.
• D = D2-D1 — day-of-month difference.
• X at line 1660 — corrects for months with fewer than 31 days using INT(.4*M+2.3), a known approximation for cumulative short-month offsets.
• Z at line 1670 — leap-year correction by counting years divisible by 4, adjusted for whether the date is before or after February.

ABS is applied to the final result so that dates entered in either order yield a positive count. The formula does not account for century years not divisible by 400, so it will be slightly inaccurate for dates spanning e.g. 1900 or 2100.

Dollars-to-Text Module (Lines 2000–3250)

The amount is validated to be in the range [0.01, 9999.99] before processing. It is then multiplied by 100 and truncated to an integer (with a small epsilon +.001 to avoid floating-point under-count), and converted to a string with STR$. The string length L drives a computed GOTO at line 2710:

2710 GOTO 2620+(7-L)*100

This jumps to different entry points in the printing chain depending on how many digits the number has (1–6 digits for amounts up to 999999 cents, though the program limits input to <10000, giving at most 6 digits). The chain handles thousands, hundreds, tens, and units progressively, incrementing pointer A through the digit string.

Teen numbers (11–19) are handled specially at line 3200: when the tens digit is 1, the two-digit value is looked up directly in D$() rows 11–19 via GOSUB 15, bypassing the separate tens/units path.

The offset formula in the extractor subroutine (X = VAL N$(A) + 18*(X1=1)) maps units digits 1–9 to rows 1–9 and tens digits 2–9 to rows 20–27 when X1=1. The value 18 = 20 − 2, accounting for the fact that the tens array starts at row 20 and represents the digit 2 (TWENTY) as the first entry.

Logo Renderer (Lines 9550–9650)

The startup routine spells out “UTY” (from A$="UTY") using pixel-level character ROM reads. For each of the three characters, it PEEKs the 8 bytes of ROM font data at 7680 + CODE(char)*8 + row, then shifts through each bit using a halving-division method (V=128, V=V/2) to decide whether to print an inverse space or a normal space at each pixel position. The three characters are rendered at columns 5, 12, and 19 (step 7 in the FOR L loop), giving evenly spaced large letters.

Notable Bugs and Anomalies

• Line 2035 — “FIFTHTEEN”: The word “FIFTEEN” is misspelled as FIFTHTEEN (extra “TH”), so amounts containing 15 cents or the number 15 in dollar values will be spelled incorrectly.
• Line 2550 — negative number check: The condition IF N>=.01 THEN GOTO 2580 correctly skips the error message for valid inputs, but the error message reads “NO NEGATIVE NUMBERS” even though the real issue is any value below 0.01 (including zero). Negative numbers will also trigger this path, so the message is partially correct but misleading for zero input.
• Line 2656 — GOSUB 15 for teens: Calling GOSUB 15 re-dimensions G$ each time, which is safe but redundant when called repeatedly; it costs extra time compared to GOSUB 10.
• Lines 2850–2925 — skipped hundred handling: When VAL N$(A)=0 at line 2850 (no hundreds digit), execution jumps to 2840 incrementing A, but line 2840 is inside the hundreds block. The flow relies on fall-through from various GOTO targets being correctly aligned; a careful trace shows the logic is functional but the spaghetti branching makes it fragile.
• Cents always printed as digits: Lines 3060–3100 print the cents portion as raw digit characters with a /100 DOLLARS*** suffix rather than spelling them out, inconsistent with the dollars portion which is fully spelled. This appears to be intentional (cheque-writing style notation for cents).