Anonymous user
Long year: Difference between revisions
BASICs to the BASIC section
(→{{header|ASIC}}: Added) |
(BASICs to the BASIC section) |
||
Line 460:
2099</pre>
==={{header|BBC BASIC}}===
{{works with|BBC BASIC for Windows}}
<lang bbcbasic> INSTALL @lib$ + "DATELIB"
Line 487:
The long years between 2000 and 2100 are 2004 2009 2015 2020 2026 2032 2037 2043 2048 2054 2060 2065 2071 2076 2082 2088 2093 2099
The long years between 2100 and 2200 are 2105 2111 2116 2122 2128 2133 2139 2144 2150 2156 2161 2167 2172 2178 2184 2189 2195
</pre>
==={{header|Commodore BASIC}}===
<lang basic>100 REM M7(N) = N MOD 7
110 DEF FNM7(N) = N - 7*INT(N / 7)
120 :
130 REM WD(Y) = WEEKDAY OF Y-12-31, 0 = SUNDAY
140 DEF FNWD(Y) = FNM7(Y + INT(Y / 4) - INT(Y / 100) + INT(Y / 400))
150 :
160 REM LY(Y) = NONZERO IF Y IS LONG
170 DEF FNLY(Y) = (4 = FNWD(Y)) OR (3 = FNWD(Y-1))
180 :
190 PRINT CHR$(147); CHR$(18); "**** LIST OF ISO LONG YEARS ****"
200 INPUT "START YEAR"; S
210 INPUT "END YEAR"; E
220 PRINT
230 :
240 FOR Y = S TO E
250 : IF FNLY(Y) THEN PRINT Y,
260 NEXT Y
270 PRINT</lang>
{{Out}}
<pre>**** LIST OF ISO LONG YEARS ****
START YEAR? 1995
END YEAR? 2045
1998 2004 2009 2015
2020 2026 2032 2037
2043
READY.</pre>
==={{Header|FreeBASIC}}===
<lang freebasic>function p(y as unsigned integer) as unsigned integer
return ( y + int(y/4) - int(y/100) + int(y/400) ) mod 7
end function
function islongyear( y as uinteger ) as boolean
if p(y) = 4 then return true
if p(y-1) = 3 then return true
return false
end function
print islongyear(1998)
print islongyear(2020)
print islongyear(2021)</lang>
{{out}}
<pre>
true
true
false
</pre>
==={{header|GW-BASIC}}===
<lang gwbasic>10 INPUT "Enter a year: ", Y
20 X = Y
30 GOSUB 100
40 IF P = 4 THEN L = 1
50 X = Y - 1
60 GOSUB 100
70 IF P = 3 THEN L = 1
80 IF L = 1 THEN PRINT Y; " is a long year." ELSE PRINT Y;" is not a long year."
90 END
100 P = X + INT(X/4) - INT(X/100) + INT(X/400)
110 P = P MOD 7
120 RETURN</lang>
==={{header|IS-BASIC}}===
<lang IS-BASIC>100 PROGRAM "Longyear.bas"
110 DEF RD(Y)=Y*365+INT(Y/4)-INT(Y/100)+INT(Y/400)
120 DEF LONGYEAR(Y)=(4=MOD(RD(Y),7)) OR(4=MOD((RD(Y-1)+1),7))
130 INPUT PROMPT "Start year: ":S
140 INPUT PROMPT "End year: ":E
150 FOR Y=S TO E
160 IF LONGYEAR(Y) THEN PRINT Y,
170 NEXT
180 PRINT</lang>
==={{header|PureBasic}}===
{{trans|BASIC256}}
<lang PureBasic>Procedure.b p(y)
ProcedureReturn (y + Int(y/4) - Int(y/100) + Int(y/400)) % 7
EndProcedure
Procedure.b isLongYear(y)
ProcedureReturn Bool((p(y) = 4) Or (p(y - 1) = 3))
EndProcedure
If OpenConsole()
For y = 2000 To 2100
If isLongYear(y)
PrintN(Str(y))
EndIf
Next y
Print(""): Input()
CloseConsole()
EndIf</lang>
{{out}}
<pre>
Igual que la entrada de BASIC256.
</pre>
==={{header|Quick BASIC}}===
{{Works with|QB|4.x}}
{{Works with|PDS|7.x}}
{{Works with|QBasic|1.x}}
{{Works with|VB-DOS|1.0}}
Translated from Delphi
<lang vb>
DEFINT A-Z
DECLARE FUNCTION p% (Yr AS INTEGER)
DECLARE FUNCTION LongYear% (Yr AS INTEGER)
DIM iYi, iYf, i
CLS
PRINT "This program calculates which are 53-week years in a range."
PRINT
INPUT "Initial year"; iYi
INPUT "Final year (could be the same)"; iYf
IF iYf >= iYi THEN
FOR i = iYi TO iYf
IF LongYear(i) THEN
PRINT i; " ";
END IF
NEXT i
END IF
PRINT
PRINT
PRINT "End of program."
END
FUNCTION LongYear% (Yr AS INTEGER)
LongYear% = (p%(Yr) = 4) OR (p%(Yr - 1) = 3)
END FUNCTION
FUNCTION p% (Yr AS INTEGER)
p% = (Yr + INT(Yr / 4) - INT(Yr / 100) + INT(Yr / 400)) MOD 7
END FUNCTION
</lang>
{{Out}}
<pre>
This program calculates which are 53-week years in a range.
Initial year? 1900
Final year (can be the same)? 1999
1903 1908 1914 1920 1925 1931 1936 1942 1948 1953 1959
1964 1970 1976 1981 1987 1992 1998
End of program.
</pre>
==={{header|S-Basic}}===
<lang BASIC>
$lines
rem - compute p mod q
function mod(p, q = integer) = integer
end = p - q * (p/q)
comment
return day of week (Sun = 0, Mon = 1, etc.) for a
given Gregorian calendar date using Zeller's congruence
end
function dayofweek (mo, da, yr = integer) = integer
var y, c, z = integer
if mo < 3 then
begin
mo = mo + 10
yr = yr - 1
end
else mo = mo - 2
y = mod(yr,100)
c = int(yr / 100)
z = int((26 * mo - 2) / 10)
z = z + da + y + int(y/4) + int(c/4) - 2 * c + 777
z = mod(z,7)
end = z
comment
The simplest of several possible tests is that
any calendar year starting or ending on a
Thursday is "long", i.e., has 53 ISO weeks
end
function islongyear(yr = integer) = integer
var thursday, result = integer
thursday = 4
if (dayofweek(1,1,yr) = thursday) or \
(dayofweek(12,31,yr) = thursday) then
result = -1 rem "true"
else
result = 0 rem "false"
end = result
rem - main program begins here
var year = integer
print "ISO years that will be long in this century:"
for year = 2000 to 2099
if islongyear(year) then print year;
next year
end</lang>
{{output}}
<pre>
ISO years that will be long in this century:
2004 2009 2015 2020 2026 2032 2037 2043 2048 2054 2060 2065 2071 2076 2082 2088
2093 2099
</pre>
==={{header|Tiny BASIC}}===
<lang tiny basic> PRINT "What year would you like?"
INPUT Y
LET X = Y
GOSUB 100
IF P = 4 THEN LET L = 1
LET X = Y - 1
GOSUB 100
IF P = 3 THEN LET L = 1
IF L = 1 THEN PRINT Y," is a long year."
IF L = 0 THEN PRINT Y," is not a long year."
END
100 LET P = X + X/4 - X/100 + X/400
110 IF P < 7 THEN RETURN
LET P = P - 7
GOTO 110
</lang>
{{out}}
<pre>
What year would you like?
2020
2020 is a long year.
What year would you like?
2021
2021 is not a long year.
</pre>
==={{header|True BASIC}}===
{{trans|BASIC256}}
<lang qbasic>FUNCTION p(y) = REMAINDER((y + INT(y/4) - INT(y/100) + INT(y/400)), 7)
FUNCTION isLongYear(y)
IF p(y) = 4 THEN
LET isLongYear = 1
ELSEIF p(y-1) = 3 THEN
LET isLongYear = 1
ELSE
LET isLongYear = 0
END IF
END FUNCTION
FOR y = 2000 TO 2100
IF isLongYear(y) > 0 THEN PRINT y
NEXT y
END</lang>
{{out}}
<pre>
Igual que la entrada de BASIC256.
</pre>
==={{header|Yabasic}}===
{{trans|BASIC256}}
<lang yabasic>sub p(y)
return mod((y + int(y/4) - int(y/100) + int(y/400)), 7)
end sub
sub isLongYear(y)
return (p(y) = 4) or (p(y - 1) = 3)
end sub
for y = 2000 to 2100
if isLongYear(y) then print y : fi
next y
end</lang>
{{out}}
<pre>
Igual que la entrada de BASIC256.
</pre>
Line 680 ⟶ 962:
2099</pre>
=={{header|Common Lisp}}==
Line 970 ⟶ 1,221:
2026 2032 2037 2043 2048 2054 2060 2065 2071 2076
2082 2088 2093 2099 %
</pre>
Line 1,028 ⟶ 1,258:
[2105 2111 2116 2122 2128 2133 2139 2144 2150 2156 2161 2167 2172 2178 2184 2189 2195]
</pre>
=={{header|Haskell}}==
Line 1,073 ⟶ 1,289:
2093
2099</pre>
=={{header|J}}==
Line 1,734 ⟶ 1,939:
2082 2088 2093 2099
</pre>
=={{header|Python}}==
Line 1,829 ⟶ 2,007:
2004 2009 2015 2020 2026 2032 2037 2043 2048 2054 2060 2065 2071 2076 2082 2088 2093 2099 </pre>
=={{header|Raku}}==
Line 2,038 ⟶ 2,166:
2093
2099
</pre>
Line 2,355 ⟶ 2,425:
"2043",
]</pre>
=={{header|TypeScript}}==
<lang typescript>const isLongYear = (year: number): boolean => {
Line 2,567 ⟶ 2,583:
[2105, 2111, 2116, 2122, 2128, 2133, 2139, 2144, 2150, 2156, 2161, 2167, 2172, 2178, 2184, 2189, 2195]
</pre>
=={{header|zkl}}==
| |||