aparler/RosettaCodeData
1
0
Fork 0
Code Issues 12 Pull requests 3 Projects Releases Packages Wiki Activity Actions

Initial data commit

Browse source
This commit is contained in:
Ingy döt Net 2023-07-01 11:58:00 -04:00
parent 72d218235f
commit f23f22d71c
199087 changed files with 3378941 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

2
Task/Babbage-problem/00-META.yaml Normal file
View file

@ -0,0 +1,2 @@
---
from: http://rosettacode.org/wiki/Babbage_problem

21
Task/Babbage-problem/00-TASK.txt Normal file
View file

@ -0,0 +1,21 @@
[[wp:Charles_Babbage|Charles Babbage]], looking ahead to the sorts of problems his Analytical Engine would be able to solve, gave this example:
{{quote
| What is the smallest positive integer whose square ends in the digits 269,696?
| Babbage, letter to Lord Bowden, 1837; see Hollingdale and Tootill, <i>Electronic Computers</i>, second edition, 1970, p. 125.
}}
He thought the answer might be 99,736, whose square is 9,947,269,696; but he couldn't be certain.
;Task
The task is to find out if Babbage had the right answer — and to do so, as far as your language allows it, in code that Babbage himself would have been able to read and understand.
As Babbage evidently solved the task with pencil and paper, a similar efficient solution is preferred.
For these purposes, Charles Babbage may be taken to be an intelligent person, familiar with mathematics and with the idea of a computer; he has written the first drafts of simple computer programmes in tabular form. [[https://collection.sciencemuseum.org.uk/documents/aa110000020 Babbage Archive Series L]].
;Motivation
The aim of the task is to write a program that is sufficiently clear and well-documented for such a person to be able to read it and be confident that it does indeed solve the specified problem.
<br><br>

4
Task/Babbage-problem/11l/babbage-problem.11l Normal file
View file

@ -0,0 +1,4 @@
V n = 1
L n ^ 2 % 1000000 != 269696
n++
print(n)

32
Task/Babbage-problem/360-Assembly/babbage-problem.360 Normal file
View file

@ -0,0 +1,32 @@
* Find the lowest positive integer whose square ends in 269696
* The logic of the assembler program is simple :
* loop for i=524 step 2
* if (i*i modulo 1000000)=269696 then leave loop
* next i
* output 'Solution is: i=' i ' (i*i=' i*i ')'
BABBAGE CSECT beginning of the control section
USING BABBAGE,13 define the base register
B 72(15) skip savearea (72=18*4)
DC 17F'0' savearea (18 full words (17+1))
STM 14,12,12(13) prolog: save the caller registers
ST 13,4(15) prolog: link backwards
ST 15,8(13) prolog: link forwards
LR 13,15 prolog: establish addressability
LA 6,524 let register6 be i and load 524
LOOP LR 5,6 load register5 with i
MR 4,6 multiply register5 with i
LR 7,5 load register7 with the result i*i
D 4,=F'1000000' divide register5 with 1000000
C 4,=F'269696' compare the reminder with 269696
BE ENDLOOP if equal branch to ENDLOOP
LA 6,2(6) load register6 (i) with value i+2
B LOOP branch to LOOP
ENDLOOP XDECO 6,BUFFER+15 edit registrer6 (i)
XDECO 7,BUFFER+34 edit registrer7 (i squared)
XPRNT BUFFER,L'BUFFER print buffer
L 13,4(0,13) epilog: restore the caller savearea
LM 14,12,12(13) epilog: restore the caller registers
XR 15,15 epilog: set return code to 0
BR 14 epilog: branch to caller
BUFFER DC CL80'Solution is: i=............ (i*i=............)'
END BABBAGE end of the control section

153
Task/Babbage-problem/AArch64-Assembly/babbage-problem.aarch64 Normal file
View file

@ -0,0 +1,153 @@
/* ARM assembly AARCH64 Raspberry PI 3B */
/* program babbage64.s */
/************************************/
/* Constantes */
/************************************/
/* for this file see task include a file in language AArch64 assembly*/
.include "../includeConstantesARM64.inc"
/*********************************/
/* Initialized data */
/*********************************/
.data
szMessResult: .asciz "Result = "
szMessStart: .asciz "Program 64 bits start.\n"
szCarriageReturn: .asciz "\n"
/*********************************/
/* UnInitialized data */
/*********************************/
.bss
sZoneConv: .skip 24 // conversion buffer
/*********************************/
/* code section */
/*********************************/
.text
.global main
main: // entry of program
ldr x0,qAdrszMessStart
bl affichageMess
ldr x4,qNbStart // start number = 269696
mov x5,#0 // counter multiply
ldr x2,qNbMult // value multiply = 1 000 000
mov x6,x4
1:
mov x0,x6
bl squareRoot // compute square root
mul x1,x0,x0 // compute square
umulh x3,x0,x0
cmp x3,#0 // overflow ?
bne 100f // yes -> end
cmp x1,x6 // perfect square
bne 2f // no -> loop
ldr x1,qAdrsZoneConv
bl conversion10
mov x0,#3 // string number to display
ldr x1,qAdrszMessResult
ldr x2,qAdrsZoneConv // insert conversion in message
ldr x3,qAdrszCarriageReturn
bl displayStrings // display message
b 100f // end
2:
add x5,x5,#1 // increment counter
mul x3,x5,x2 // multiply by 1 000 000
add x6,x3,x4 // add start number
b 1b
100: // standard end of the program
mov x0, #0 // return code
mov x8,EXIT
svc #0 // perform the system call
qAdrszCarriageReturn: .quad szCarriageReturn
qNbStart: .quad 269696
qNbMult: .quad 1000000
qAdrsZoneConv: .quad sZoneConv
qAdrszMessResult: .quad szMessResult
qAdrszMessStart: .quad szMessStart
/***************************************************/
/* Compute integer square root by Héron méthode */
/***************************************************/
/* r0 number */
/* r0 return root */
squareRoot:
stp x1,lr,[sp,-16]! // save registres
stp x2,x3,[sp,-16]! // save registres
cmp x0,#0 //
beq 100f
cmp x0,#4 // if < 4 return 1
mov x1,1
csel x0,x1,x0,lo
blo 100f
lsr x1,x0,#1 // division by 2 -> divisor
1:
mov x3,x1 // save previous result
udiv x2,x0,x1 // divide number by previous result
add x1,x1,x2 // add quotient to previous result
lsr x1,x1,#1 // division by 2
cmp x1,x3 // compare result and previous result
blo 1b // loop if result is smaller then previous result
mov x0,x3 // else return previous result
100:
ldp x2,x3,[sp],16 // restaur registres
ldp x1,lr,[sp],16 // restaur registres
ret
/***************************************************/
/* display multi strings */
/* new version 24/05/2023 */
/***************************************************/
/* x0 contains number strings address */
/* x1 address string1 */
/* x2 address string2 */
/* x3 address string3 */
/* x4 address string4 */
/* x5 address string5 */
/* x6 address string5 */
/* x7 address string6 */
displayStrings: // INFO: displayStrings
stp x8,lr,[sp,-16]! // save registers
stp x2,fp,[sp,-16]! // save registers
add fp,sp,#32 // save paraméters address (4 registers saved * 8 bytes)
mov x8,x0 // save strings number
cmp x8,#0 // 0 string -> end
ble 100f
mov x0,x1 // string 1
bl affichageMess
cmp x8,#1 // number > 1
ble 100f
mov x0,x2
bl affichageMess
cmp x8,#2
ble 100f
mov x0,x3
bl affichageMess
cmp x8,#3
ble 100f
mov x0,x4
bl affichageMess
cmp x8,#4
ble 100f
mov x0,x5
bl affichageMess
cmp x8,#5
ble 100f
mov x0,x6
bl affichageMess
cmp x8,#6
ble 100f
mov x0,x7
bl affichageMess
100:
ldp x2,fp,[sp],16 // restaur registers
ldp x8,lr,[sp],16 // restaur registers
ret
/***************************************************/
/* ROUTINES INCLUDE */
/***************************************************/
/* for this file see task include a file in language AArch64 assembly*/
.include "../includeARM64.inc"

32
Task/Babbage-problem/ALGOL-68/babbage-problem.alg Normal file
View file

@ -0,0 +1,32 @@
COMMENT text between pairs of words 'comment' in capitals are
for the human reader's information and are ignored by the machine
COMMENT
COMMENT Define s to be the integer value 269 696 COMMENT
INT s = 269 696;
COMMENT Name a location in the machine's storage area that will be
used to hold integer values.
The value stored in the location will change during the
calculations.
Note, "*" is used to represent the multiplication operator.
":=" causes the location named to the left of ":=" to
assume the value computed by the expression to the right.
"sqrt" computes an approximation to the square root
of the supplied parameter
"MOD" is an operator that computes the modulus of its
left operand with respect to its right operand
"ENTIER" is a unary operator that yields the largest
integer that is at most its operand.
COMMENT
INT v := ENTIER sqrt( s );
COMMENT the construct: WHILE...DO...OD repeatedly executes the
instructions between DO and OD, the execution stops when
the instructions between WHILE and DO yield the value FALSE.
COMMENT
WHILE ( v * v ) MOD 1 000 000 /= s DO v := v + 1 OD;
COMMENT print displays the values of its parameters
COMMENT
print( ( v, " when squared is: ", v * v, newline ) )

10
Task/Babbage-problem/APL/babbage-problem-1.apl Normal file
View file

@ -0,0 +1,10 @@
⍝ We know that 99,736 is a valid answer, so we only need to test the positive integers from 1 up to there:
N←⍳99736
⍝ The SQUARE OF omega is omega times omega:
SQUAREOF←{⍵×⍵}
⍝ To say that alpha ENDS IN the six-digit number omega means that alpha divided by 1,000,000 leaves remainder omega:
ENDSIN←{(1000000|⍺)=⍵}
⍝ The SMALLEST number WHERE some condition is met is found by taking the first number from a list of attempts, after rearranging the list so that numbers satisfying the condition come before those that fail to satisfy it:
SMALLESTWHERE←{1↑⍒⍵}
⍝ We can now ask the computer for the answer:
SMALLESTWHERE (SQUAREOF N) ENDSIN 269696

4
Task/Babbage-problem/APL/babbage-problem-2.apl Normal file
View file

@ -0,0 +1,4 @@
⍝ s = 520 + 2 ... + 2 ⍣ <= power
⍝ s × s = n × 1000000 + 269696 | <= remainder
2+⍣{269696=1000000|⍺×⍺}520

181
Task/Babbage-problem/ARM-Assembly/babbage-problem.arm Normal file
View file

@ -0,0 +1,181 @@
/* ARM assembly Raspberry PI */
/* program babbage.s */
/************************************/
/* Constantes */
/************************************/
.equ STDOUT, 1 @ Linux output console
.equ EXIT, 1 @ Linux syscall
.equ WRITE, 4 @ Linux syscall
/*********************************/
/* Initialized data */
/*********************************/
.data
sMessResult: .ascii "Result = "
sMessValeur: .fill 11, 1, ' ' @ size => 11
szCarriageReturn: .asciz "\n"
/*********************************/
/* UnInitialized data */
/*********************************/
.bss
/*********************************/
/* code section */
/*********************************/
.text
.global main
main: @ entry of program
ldr r4,iNbStart @ start number = 269696
mov r5,#0 @ counter multiply
ldr r2,iNbMult @ value multiply = 1 000 000
mov r6,r4
1:
mov r0,r6
bl squareRoot @ compute square root
umull r1,r3,r0,r0
cmp r3,#0 @ overflow ?
bne 100f @ yes -> end
cmp r1,r6 @ perfect square
bne 2f @ no -> loop
ldr r1,iAdrsMessValeur
bl conversion10 @ call conversion decimal
ldr r0,iAdrsMessResult
bl affichageMess @ display message
b 100f @ end
2:
add r5,#1 @ increment counter
mul r3,r5,r2 @ multiply by 1 000 000
add r6,r3,r4 @ add start number
b 1b
100: @ standard end of the program
mov r0, #0 @ return code
mov r7, #EXIT @ request to exit program
svc #0 @ perform the system call
iAdrsMessValeur: .int sMessValeur
iAdrszCarriageReturn: .int szCarriageReturn
iAdrsMessResult: .int sMessResult
iNbStart: .int 269696
iNbMult: .int 1000000
/******************************************************************/
/* compute squareRoot */
/******************************************************************/
/* r0 contains n */
/* r0 return result or -1 */
squareRoot:
push {r1-r5,lr} @ save registers
cmp r0,#0
beq 100f @ if zero -> end
movlt r0,#-1 @ if negatif return - 1
blt 100f
cmp r0,#4 @ if < 4 return 1
movlt r0,#1
blt 100f
@ start
clz r2,r0 @ number of zeros on the left
rsb r2,#32 @ so many useful numbers right
bic r2,#1 @ to have an even number of digits
mov r3,#0b11 @ mask for extract 2 bits
lsl r3,r2
mov r1,#0 @ init résult with 0
mov r4,#0 @ raz remainder area
1: @ begin loop
and r5,r0,r3 @ extract 2 bits with mask
add r4,r5,lsr r2 @ shift right and addition with remainder
lsl r5,r1,#1 @ multiplication by 2
lsl r5,#1 @ shift left one bit
orr r5,#1 @ bit right = 1
lsl r1,#1 @ shift left one bit
subs r4,r5 @ sub remainder
addmi r4,r4,r5 @ if negative restaur register
addpl r1,#1 @ else add 1
subs r2,#2 @ decrement number bits
movmi r0,r1 @ if end return result
bmi 100f
lsl r4,#2 @ no -> shift left remainder 2 bits
lsr r3,#2 @ and shift right mask 2 bits
b 1b @ and loop
100:
pop {r1-r5,lr} @ restaur registers
bx lr @return
/******************************************************************/
/* display text with size calculation */
/******************************************************************/
/* r0 contains the address of the message */
affichageMess:
push {r0,r1,r2,r7,lr} @ save registres
mov r2,#0 @ counter length
1: @ loop length calculation
ldrb r1,[r0,r2] @ read octet start position + index
cmp r1,#0 @ if 0 its over
addne r2,r2,#1 @ else add 1 in the length
bne 1b @ and loop
@ so here r2 contains the length of the message
mov r1,r0 @ address message in r1
mov r0,#STDOUT @ code to write to the standard output Linux
mov r7, #WRITE @ code call system "write"
svc #0 @ call systeme
pop {r0,r1,r2,r7,lr} @ restaur des 2 registres */
bx lr @ return
/******************************************************************/
/* Converting a register to a decimal unsigned */
/******************************************************************/
/* r0 contains value and r1 address area */
/* r0 return size of result (no zero final in area) */
/* area size => 11 bytes */
.equ LGZONECAL, 10
conversion10:
push {r1-r4,lr} @ save registers
mov r3,r1
mov r2,#LGZONECAL
1: @ start loop
bl divisionpar10U @ unsigned r0 <- dividende. quotient ->r0 reste -> r1
add r1,#48 @ digit
strb r1,[r3,r2] @ store digit on area
cmp r0,#0 @ stop if quotient = 0
subne r2,#1 @ else previous position
bne 1b @ and loop
@ and move digit from left of area
mov r4,#0
2:
ldrb r1,[r3,r2]
strb r1,[r3,r4]
add r2,#1
add r4,#1
cmp r2,#LGZONECAL
ble 2b
@ and move spaces in end on area
mov r0,r4 @ result length
mov r1,#' ' @ space
3:
strb r1,[r3,r4] @ store space in area
add r4,#1 @ next position
cmp r4,#LGZONECAL
ble 3b @ loop if r4 <= area size
100:
pop {r1-r4,lr} @ restaur registres
bx lr @return
/***************************************************/
/* division par 10 unsigned */
/***************************************************/
/* r0 dividende */
/* r0 quotient */
/* r1 remainder */
divisionpar10U:
push {r2,r3,r4, lr}
mov r4,r0 @ save value
ldr r3,iMagicNumber @ r3 <- magic_number raspberry 1 2
umull r1, r2, r3, r0 @ r1<- Lower32Bits(r1*r0) r2<- Upper32Bits(r1*r0)
mov r0, r2, LSR #3 @ r2 <- r2 >> shift 3
add r2,r0,r0, lsl #2 @ r2 <- r0 * 5
sub r1,r4,r2, lsl #1 @ r1 <- r4 - (r2 * 2) = r4 - (r0 * 10)
pop {r2,r3,r4,lr}
bx lr @ leave function
iMagicNumber: .int 0xCCCCCCCD

23
Task/Babbage-problem/AWK/babbage-problem.awk Normal file
View file

@ -0,0 +1,23 @@
# A comment starts with a "#" and are ignored by the machine. They can be on a
# line by themselves or at the end of an executable line.
#
# A program consists of multiple lines or statements. This program tests
# positive integers starting at 1 and terminates when one is found whose square
# ends in 269696.
#
# The next line shows how to run the program.
# syntax: GAWK -f BABBAGE_PROBLEM.AWK
#
BEGIN { # start of program
# this declares a variable named "n" and assigns it a value of zero
n = 0
# do what's inside the "{}" until n times n ends in 269696
do {
n = n + 1 # add 1 to n
} while (n*n !~ /269696$/)
# print the answer
print("The smallest number whose square ends in 269696 is " n)
print("Its square is " n*n)
# terminate program
exit(0)
} # end of program

54
Task/Babbage-problem/Ada/babbage-problem.ada Normal file
View file

@ -0,0 +1,54 @@
-- The program is written in the programming language Ada. The name "Ada"
-- has been chosen in honour of your friend,
-- Augusta Ada King-Noel, Countess of Lovelace (née Byron).
--
-- This is an program to search for the smallest integer X, such that
-- (X*X) mod 1_000_000 = 269_696.
--
-- In the Ada language, "*" represents the multiplication symbol, "mod" the
-- modulo reduction, and the underscore "_" after every third digit in
-- literals is supposed to simplify reading numbers for humans.
-- Everything written after "--" in a line is a comment for the human,
-- and will be ignored by the computer.
with Ada.Text_IO;
-- We need this to tell the computer how it will later output its result.
procedure Babbage_Problem is
-- We know that 99_736*99_736 is 9_947_269_696. This implies:
-- 1. The smallest X with X*X mod 1_000_000 = 269_696 is at most 99_736.
-- 2. The largest square X*X, which the program may have to deal with,
-- will be at most 9_947_269_69.
type Number is range 1 .. 99_736*99_736;
X: Number := 1;
-- X can store numbers between 1 and 99_736*99_736. Computations
-- involving X can handle intermediate results in that range.
-- Initially the value stored at X is 1.
-- When running the program, the value will become 2, 3, 4, etc.
begin
-- The program starts running.
-- The computer first squares X, then it truncates the square, such
-- that the result is a six-digit number.
-- Finally, the computer checks if this number is 269_696.
while not (((X*X) mod 1_000_000) = 269_696) loop
-- When the computer goes here, the number was not 269_696.
X := X+1;
-- So we replace X by X+1, and then go back and try again.
end loop;
-- When the computer eventually goes here, the number is 269_696.
-- E.e., the value stored at X is the value we are searching for.
-- We still have to print out this value.
Ada.Text_IO.Put_Line(Number'Image(X));
-- Number'Image(X) converts the value stored at X into a string of
-- printable characters (more specifically, of digits).
-- Ada.Text_IO.Put_Line(...) prints this string, for humans to read.
-- I did already run the program, and it did print out 25264.
end Babbage_Problem;

8
Task/Babbage-problem/Aime/babbage-problem.aime Normal file
View file

@ -0,0 +1,8 @@
integer i;
i = sqrt(269696);
while (i * i % 1000000 != 269696) {
i += 1;
}
o_(i, "\n");

148
Task/Babbage-problem/AppleScript/babbage-problem-1.applescript Normal file
View file

@ -0,0 +1,148 @@
------------------------- BABBAGE ------------------------
-- babbage :: Int -> [Int]
on babbage(intTests)
script test
on toSquare(x)
(1000000 * x) + 269696
end toSquare
on |λ|(x)
hasIntRoot(toSquare(x))
end |λ|
end script
script toRoot
on |λ|(x)
((1000000 * x) + 269696) ^ (1 / 2)
end |λ|
end script
set xs to filter(test, enumFromTo(1, intTests))
zip(map(toRoot, xs), map(test's toSquare, xs))
end babbage
--------------------------- TEST -------------------------
on run
-- Try 1000 candidates
unlines(map(intercalate(" -> "), babbage(1000)))
--> "2.5264E+4 -> 6.38269696E+8"
end run
-------------------- GENERIC FUNCTIONS -------------------
-- enumFromTo :: Int -> Int -> [Int]
on enumFromTo(m, n)
if m > n then
set d to -1
else
set d to 1
end if
set lst to {}
repeat with i from m to n by d
set end of lst to i
end repeat
return lst
end enumFromTo
-- filter :: (a -> Bool) -> [a] -> [a]
on filter(f, xs)
tell mReturn(f)
set lst to {}
set lng to length of xs
repeat with i from 1 to lng
set v to item i of xs
if |λ|(v, i, xs) then set end of lst to v
end repeat
return lst
end tell
end filter
-- hasIntRoot :: Int -> Bool
on hasIntRoot(n)
set r to n ^ 0.5
r = (r as integer)
end hasIntRoot
-- intercalate :: String -> [String] -> String
on intercalate(sep)
script
on |λ|(xs)
set {dlm, my text item delimiters} to ¬
{my text item delimiters, sep}
set s to xs as text
set my text item delimiters to dlm
s
end |λ|
end script
end intercalate
-- map :: (a -> b) -> [a] -> [b]
on map(f, xs)
-- The list obtained by applying f
-- to each element of xs.
tell mReturn(f)
set lng to length of xs
set lst to {}
repeat with i from 1 to lng
set end of lst to |λ|(item i of xs, i, xs)
end repeat
return lst
end tell
end map
-- min :: Ord a => a -> a -> a
on min(x, y)
if y < x then
y
else
x
end if
end min
-- Lift 2nd class handler function into 1st class script wrapper
-- mReturn :: Handler -> Script
on mReturn(f)
if class of f is script then
f
else
script
property |λ| : f
end script
end if
end mReturn
-- unlines :: [String] -> String
on unlines(xs)
-- A single string formed by the intercalation
-- of a list of strings with the newline character.
set {dlm, my text item delimiters} to ¬
{my text item delimiters, linefeed}
set s to xs as text
set my text item delimiters to dlm
s
end unlines
-- zip :: [a] -> [b] -> [(a, b)]
on zip(xs, ys)
set lng to min(length of xs, length of ys)
set lst to {}
repeat with i from 1 to lng
set end of lst to {item i of xs, item i of ys}
end repeat
return lst
end zip

29
Task/Babbage-problem/AppleScript/babbage-problem-2.applescript Normal file
View file

@ -0,0 +1,29 @@
on babbage(endDigits)
-- Set up an incrementor to the amount in front of the given end digits.
if (endDigits's class is text) then
set increment to 10 ^ (count endDigits) div 1
else
set increment to 10
repeat until (increment > endDigits)
set increment to increment * 10
end repeat
end if
-- I postulate that if no square ending with the given digits is found with less than
-- twice that many digits, then no such square exists; but I can't be certain. :)
set limit to increment * (increment div 10)
-- In any case, AppleScript's precision limit is 1.0E+15.
if (limit > 1.0E+15) then return missing value
-- Test successive values ending with the digits until one is found
-- to have an integer square root or the limit is exceeded.
set testNumber to endDigits div 1
set squareRoot to testNumber ^ 0.5
repeat until ((squareRoot mod 1 = 0) or (testNumber > limit))
set testNumber to testNumber + increment
set squareRoot to testNumber ^ 0.5
end repeat
if (testNumber > limit) then return missing value -- No such square.
return {squareRoot as integer, testNumber} -- {integer, square ending with the digits}
end babbage
return {babbage(269696), babbage("00609")}

1
Task/Babbage-problem/AppleScript/babbage-problem-3.applescript Normal file
View file

@ -0,0 +1 @@
{{25264, 638269696}, {3647, 13300609}}

17
Task/Babbage-problem/Applesoft-BASIC/babbage-problem.basic Normal file
View file

@ -0,0 +1,17 @@
100 :
110 REM BABBAGE PROBLEM
120 :
130 DEF FN ST(A) = N - INT (A) * INT (A)
140 N = 269696
150 N = N + 1000000
160 R = SQR (N)
170 IF FN ST(R) < > 0 AND N < 999999999 THEN GOTO 150
180 IF N > 999999999 THEN GOTO 210
190 PRINT "SMALLESt NUMBER WHOSE
SQUARE ENDS IN"; CHR$ (13);
"269696 IS ";R;", AND THE
SQUARE IS"; CHR$ (13);N
200 END
210 PRINT "THERE IS NO SOLUTION
FOR VALUES SMALLER"; CHR$(13);
"THAN 999999999."

5
Task/Babbage-problem/Arturo/babbage-problem.arturo Normal file
View file

@ -0,0 +1,5 @@
n: new 0
while [269696 <> (n^2) % 1000000]
-> inc 'n
print n

8
Task/Babbage-problem/Asymptote/babbage-problem.asymptote Normal file
View file

@ -0,0 +1,8 @@
int n = 519;
while (269696 != (n^2) % 1000000) {
++n;
}
write("The smallest number whose square ends in 269696 is: ", n);
write("It's square is ", n*n);

11
Task/Babbage-problem/AutoHotkey/babbage-problem.ahk Normal file
View file

@ -0,0 +1,11 @@
; Give n an initial value
n = 519
; Loop this action while condition is not satisfied
while (Mod(n*n, 1000000) != 269696) {
; Increment n
n++
}
; Display n as value
msgbox, %n%

7
Task/Babbage-problem/BASIC256/babbage-problem.basic Normal file
View file

@ -0,0 +1,7 @@
#This code is an implementation of Babbage Problem
number = 2
DO
number += 2
UNTIL ((number^2) % 1000000) = 269696
PRINT "The smallest number whose square ends in 269696 is: "; number
PRINT "It's square is "; number*number

17
Task/Babbage-problem/BBC-BASIC/babbage-problem-1.basic Normal file
View file

@ -0,0 +1,17 @@
REM Statements beginning 'REM' are explanatory remarks: the machine will ignore them.
REM We shall test positive integers from 1 upwards until we find one whose square ends in 269,696.
REM A number that ends in 269,696 is one that leaves a remainder of 269,696 when divided by a million.
REM So we are looking for a value of n that satisfies the condition 'n squared modulo 1,000,000 = 269,696', or 'n^2 MOD 1000000 = 269696' in the notation that the machine can accept.
LET n = 0
REPEAT
LET n = n + 1
UNTIL n^2 MOD 1000000 = 269696
PRINT "The smallest number whose square ends in 269696 is" n
PRINT "Its square is" n^2

25
Task/Babbage-problem/BBC-BASIC/babbage-problem-2.basic Normal file
View file

@ -0,0 +1,25 @@
REM Lines that begin 'REM' are explanatory remarks addressed to the human reader.
REM The machine will ignore them.
LET n = 269696
REPEAT
LET n = n + 1000000
REM Find the next number that ends in 269,696.
REM The function SQR finds the square root.
LET root = SQR n
REM The function INT truncates a real number to an integer.
UNTIL root = INT root
REM If the square root is equal to its integer truncation, then it is an integer: so we have found our answer.
PRINT "The smallest number whose square ends in 269696 is" root
PRINT "Its square is" n

22
Task/Babbage-problem/Batch-File/babbage-problem.bat Normal file
View file

@ -0,0 +1,22 @@
:: This line is only required to increase the readability of the output by hiding the lines of code being executed
@echo off
:: Everything between the lines keeps repeating until the answer is found
:: The code works by, starting at 1, checking to see if the last 6 digits of the current number squared is equal to 269696
::----------------------------------------------------------------------------------
:loop
:: Increment the current number being tested by 1
set /a number+=1
:: Square the current number
set /a numbersquared=%number%*%number%
:: Check if the last 6 digits of the current number squared is equal to 269696, and if so, stop looping and go to the end
if %numbersquared:~-6%==269696 goto end
goto loop
::----------------------------------------------------------------------------------
:end
echo %number% * %number% = %numbersquared%
pause>nul

18
Task/Babbage-problem/Befunge/babbage-problem.bf Normal file
View file

@ -0,0 +1,18 @@
1+ ::* "d"::** % "V8":** -! #v_ > > > > >
v
increment n n*n modulo 1000000 equal to 269696? v if false, loop to right
v
v"Smallest number whose square ends in 269696 is "0 < else output n below
>:#,_$ . 55+, @
ouput message then n newline exit
numeric constants explained:
"d" ascii value of 'd', i.e. 100
:: duplicate twice: 100,100,100
** multiply twice: 100*100*100 = 1000000
"V8" ascii values of 'V' and '8', i.e. 86 and 56
: duplicate the '8' (56): 86,56,56
** multiply twice: 86*56*56 = 269696

27
Task/Babbage-problem/Bracmat/babbage-problem.bracmat Normal file
View file

@ -0,0 +1,27 @@
(
500:?number {A child knows that 269696 is larger than 500*500,
but not by much. It is safe to start the search with 500.}
& whl {'whl' is shorthand for 'while'. It announces the evaluation of
an expression that is repeated until it fails.}
' ( @(!number*!number:~(? 269696)) { ~(? 269696) is a pattern. It says
that it will not match numbers that do
not end with the figures 269696.
The question mark is there to match all
the figures before 269696.}
& !number:<99736 { We should under no circumstance try
numbers that are larger than 99736.}
& 1+!number:?number { If the number did not pass the test,
we take the next number and repeat
the test. }
)
& out
$ ( str
$ ( "The smallest number that ends with the figures 269696 when squared is "
!number
", since the square of "
!number
" is "
!number*!number
)
)
)

9
Task/Babbage-problem/C++/babbage-problem.cpp Normal file
View file

@ -0,0 +1,9 @@
#include <iostream>
int main( ) {
int current = 0 ;
while ( ( current * current ) % 1000000 != 269696 )
current++ ;
std::cout << "The square of " << current << " is " << (current * current) << " !\n" ;
return 0 ;
}

35
Task/Babbage-problem/C-sharp/babbage-problem.cs Normal file
View file

@ -0,0 +1,35 @@
namespace Babbage_Problem
{
class iterateNumbers
{
public iterateNumbers()
{
long baseNumberSquared = 0; //the base number multiplied by itself
long baseNumber = 0; //the number to be squared, this one will be iterated
do //this sets up the loop
{
baseNumber += 1; //add one to the base number
baseNumberSquared = baseNumber * baseNumber; //multiply the base number by itself and store the value as baseNumberSquared
}
while (Right6Digits(baseNumberSquared) != 269696); //this will continue the loop until the right 6 digits of the base number squared are 269,696
Console.WriteLine("The smallest integer whose square ends in 269,696 is " + baseNumber);
Console.WriteLine("The square is " + baseNumberSquared);
}
private long Right6Digits(long baseNumberSquared)
{
string numberAsString = baseNumberSquared.ToString(); //this is converts the number to a different type so it can be cut up
if (numberAsString.Length < 6) { return baseNumberSquared; }; //if the number doesn't have 6 digits in it, just return it to try again.
numberAsString = numberAsString.Substring(numberAsString.Length - 6); //this extracts the last 6 digits from the number
return long.Parse(numberAsString); //return the last 6 digits of the number
}
}
}}

25
Task/Babbage-problem/C/babbage-problem.c Normal file
View file

@ -0,0 +1,25 @@
// This code is the implementation of Babbage Problem
#include <stdio.h>
#include <stdlib.h>
#include <limits.h>
int main() {
int current = 0, //the current number
square; //the square of the current number
//the strategy of take the rest of division by 1e06 is
//to take the a number how 6 last digits are 269696
while (((square=current*current) % 1000000 != 269696) && (square<INT_MAX)) {
current++;
}
//output
if (square>+INT_MAX)
printf("Condition not satisfied before INT_MAX reached.");
else
printf ("The smallest number whose square ends in 269696 is %d\n", current);
//the end
return 0 ;
}

28
Task/Babbage-problem/COBOL/babbage-problem.cobol Normal file
View file

@ -0,0 +1,28 @@
IDENTIFICATION DIVISION.
PROGRAM-ID. BABBAGE-PROGRAM.
* A line beginning with an asterisk is an explanatory note.
* The machine will disregard any such line.
DATA DIVISION.
WORKING-STORAGE SECTION.
* In this part of the program we reserve the storage space we shall
* be using for our variables, using a 'PICTURE' clause to specify
* how many digits the machine is to keep free.
* The prefixed number 77 indicates that these variables do not form part
* of any larger 'record' that we might want to deal with as a whole.
77 N PICTURE 99999.
* We know that 99,736 is a valid answer.
77 N-SQUARED PICTURE 9999999999.
77 LAST-SIX PICTURE 999999.
PROCEDURE DIVISION.
* Here we specify the calculations that the machine is to carry out.
CONTROL-PARAGRAPH.
PERFORM COMPUTATION-PARAGRAPH VARYING N FROM 1 BY 1
UNTIL LAST-SIX IS EQUAL TO 269696.
STOP RUN.
COMPUTATION-PARAGRAPH.
MULTIPLY N BY N GIVING N-SQUARED.
MOVE N-SQUARED TO LAST-SIX.
* Since the variable LAST-SIX can hold a maximum of six digits,
* only the final six digits of N-SQUARED will be moved into it:
* the rest will not fit and will simply be discarded.
IF LAST-SIX IS EQUAL TO 269696 THEN DISPLAY N.

8
Task/Babbage-problem/Chipmunk-Basic/babbage-problem.basic Normal file
View file

@ -0,0 +1,8 @@
10 cls
20 number = 2
30 while ((number^2) mod 1000000) <> 269696
40 number = number+2
50 wend
60 print "The smallest number whose square ends in 269696 is: " number
70 print "It's square is " number*number
80 end

11
Task/Babbage-problem/Clojure/babbage-problem.clj Normal file
View file

@ -0,0 +1,11 @@
; Defines function named babbage? that returns true if the
; square of the provided number leaves a remainder of 269,696 when divided
; by a million
(defn babbage? [n]
(let [square (* n n)]
(= 269696 (mod square 1000000))))
; Use the above babbage? to find the first positive integer that returns true
; (We're exploiting Clojure's laziness here; (range) with no parameters returns
; an infinite series.)
(first (filter babbage? (range)))

12
Task/Babbage-problem/Commodore-BASIC/babbage-problem.basic Normal file
View file

@ -0,0 +1,12 @@
10 rem This code is an implementation of Babbage Problem
20 num = 100 : rem We can safely start at 100
30 s = num*num
40 r = s - int(s/1000000)*1000000 : rem remainder when divided by 1,000,000
50 if r = 269696 then goto 100 : rem compare with 269,696
60 print "n="num"sq="s"rem="r
70 num = num+1
80 goto 30
90 rem Print out the result
100 print:print "The smallest number whose square ends in 269696 is:"
110 print num;"....";num;"squared = ";s
120 end

6
Task/Babbage-problem/Common-Lisp/babbage-problem-1.lisp Normal file
View file

@ -0,0 +1,6 @@
(defun babbage-test (n)
"A generic function for any ending of a number"
(when (> n 0)
(do* ((i 0 (1+ i))
(d (expt 10 (1+ (truncate (log n) (log 10))))) )
((= (mod (* i i) d) n) i) )))

13
Task/Babbage-problem/Common-Lisp/babbage-problem-2.lisp Normal file
View file

@ -0,0 +1,13 @@
; Project : Babbage problem
(setq n 1)
(setq bab2 1)
(loop while (/= bab2 269696)
do (setq n (+ n 1))
(setf bab1 (expt n 2))
(setf bab2 (mod bab1 1000000)))
(format t "~a" "The smallest number whose square ends in 269696 is: ")
(write n)
(terpri)
(format t "~a" "Its square is: ")
(write (* n n))

18
Task/Babbage-problem/Common-Lisp/babbage-problem-3.lisp Normal file
View file

@ -0,0 +1,18 @@
;; * The package definition
(defpackage :babbage
(:use :common-lisp))
(in-package :babbage)
;; * The function
(defun babbage (end)
"Returns the smallest number whose square ends in END."
(loop
:with digits = (ceiling (log end 10)) ; How many digits has end?
:for num :from (isqrt end) ; The start number
:for square = (expt num 2) ; The square of num
:for ends = (mod square (expt 10 digits)) ; The last digits
:until (= ends end)
:finally
(format t "The smallest number whose square ends in ~D is: ~D~%" end num)
(format t "Its square is: ~D~%" square)
(return num)))

15
Task/Babbage-problem/Component-Pascal/babbage-problem.pas Normal file
View file

@ -0,0 +1,15 @@
MODULE BabbageProblem;
IMPORT StdLog;
PROCEDURE Do*;
VAR
i: LONGINT;
BEGIN
i := 2;
WHILE (i * i MOD 1000000) # 269696 DO
IF i MOD 10 = 4 THEN INC(i,2) ELSE INC(i,8) END
END;
StdLog.Int(i)
END Do;
END BabbageProblem.

13
Task/Babbage-problem/Craft-Basic/babbage-problem.basic Normal file
View file

@ -0,0 +1,13 @@
print "calculating..."
let n = 2
do
let n = n + 2
wait
loopuntil (n ^ 2) % 1000000 = 269696
print "The smallest number whose square ends in 269696 is: ", n
print "It's square is ", n * n

23
Task/Babbage-problem/D/babbage-problem.d Normal file
View file

@ -0,0 +1,23 @@
// It's basically the same as any other version.
// What can be observed is that 269696 is even, so we have to consider only even numbers,
// because only the square of even numbers is even.
import std.math;
import std.stdio;
void main( )
{
// get smallest number <= sqrt(269696)
int k = cast(int)(sqrt(269696.0));
// if root is odd -> make it even
if (k % 2 == 1)
k = k - 1;
// cycle through numbers
while ((k * k) % 1000000 != 269696)
k = k + 2;
// display output
writefln("%d * %d = %d", k, k, k*k);
}

62
Task/Babbage-problem/Dafny/babbage-problem.dafny Normal file
View file

@ -0,0 +1,62 @@
// Helper function for mask: does the actual computation.
function method mask_(v:int,m:int):int
decreases v-m
requires 0 <= v && 0 < m
ensures v < mask_(v,m)
{
if v < m then m else mask_(v,m*10)
}
// Return the smallest power of 10 greater than v.
function method mask(v:int):int
requires 0 <= v
ensures v < mask(v)
{
mask_(v,10)
}
// Return true if the last digits of v == suffix.
predicate method EndWith(v:int,suffix:int)
requires 0 <= suffix
{
v % mask(suffix) == suffix
}
method SmallestSqEndingWith(suffix:int) returns (s:int)
requires 0 < suffix
ensures EndWith(s*s, suffix)
// ensures forall i :: 0 <= i < s ==> !EndWith(i*i,suffix)
decreases * // This method may not terminate.
{
s := 0;
// squares is the sequence of s*s. A ghost variable is only used by the
// verification process at compile time.
ghost var squares := [];
while !EndWith(s*s, suffix)
invariant s == |squares|
invariant forall i :: 0 <= i < s ==> squares[i] == i*i && !EndWith(squares[i], suffix)
decreases *
{
squares := squares + [s*s];
s := s + 1;
}
// Leaving the method:
// s*s ends with the suffix.
assert EndWith(s*s, suffix);
// The sequence squares contains i*i for i in [0..s]; none of the elements of
// squares ends with the suffix.
assert s == |squares|;
assert forall i :: 0 <= i < s ==> i*i == squares[i] && !EndWith(squares[i], suffix);
// That last assertion should imply the commented-out post-condition of the
// method, but I'm not sure how to express that.
//
// Conclusion: s is guaranteed to be the smallest number whose square ends
// with the suffix.
}
method Main() decreases *
{
var suffix := 269696;
var smallest := SmallestSqEndingWith(suffix);
print smallest, "\n";
}

7
Task/Babbage-problem/Dart/babbage-problem.dart Normal file
View file

@ -0,0 +1,7 @@
main() {
var x = 0;
while((x*x)% 1000000 != 269696)
{ x++;}
print('$x');
}

6
Task/Babbage-problem/Dyalect/babbage-problem-1.dyalect Normal file
View file

@ -0,0 +1,6 @@
var i = 0
while i * i % 1000000 != 269696 {
i += 1
}
print("\(i) is the smallest number that ends with 269696")

6
Task/Babbage-problem/Dyalect/babbage-problem-2.dyalect Normal file
View file

@ -0,0 +1,6 @@
for i in 2..Integer.Max {
if i * i % 1000000 == 269696 {
print("\(i) is the smallest number that ends with 269696")
break
}
}

78
Task/Babbage-problem/EDSAC-order-code/babbage-problem.edsac Normal file
View file

@ -0,0 +1,78 @@
[Babbage problem from Rosetta Code website]
[EDSAC program, Initial Orders 2]
[Library subroutine M3. Pauses the loading, prints header,
and gets overwritten when loading resumes.
Here, the last character sets the teleprinter to figures.]
PFGKIFAFRDLFUFOFE@A6FG@E8FEZPF
@&*SOLUTION!TO!BABBAGE!PROBLEM@&#
..PZ [blank tape, needed to mark end of header text]
[Library subroutine P6. Prints strictly positive integer.
32 locations; argument at 0, working locations 1, 4, 5]
T56K [define load address for subroutine]
GKA3FT25@H29@VFT4DA3@TFH30@S6@T1FV4DU4DAFG26@
TFTFO5FA4DF4FS4FL4FT4DA1FS3@G9@EFSFO31@E20@J995FJF!F
[Main routine. Load after subroutine P6.
Must be at an even address because each double
value at the start must be at an even address.]
T88K [define absolute load address]
GK [set @ (theta) for relative addresses]
[Variables]
[0] PF PF [trial solution, call it n]
[2] PF PF [residue of n^2 modulo 1000000]
[4] PF PF [1st difference for n^2]
[Constants]
[6] P64F PF [2nd difference for n^2, i.e. 128]
[8] P4F PF [1st difference for n, i.e. 8]
T10#Z PF T10Z [clears sandwich digit between 10 and 11;
cf. Wilkes, Wheeler & Gill, 1951, pp 110, 141-2]
[10] #1760F V2046F [-1000000]
T12#Z PF T12Z [clears sandwich digit between 12 and 13]
[12] Q1728F PD [269696]
[14] &F [line feed]
[15] @F [carriage return]
[16] K4096F [teleprinter null]
[Enter with acc = 0]
[17] T#@ [trial number n := 0]
T2#@ [(n^2 mod 1000000) := 0]
S6#@ [acc := -128]
RD [right shift]
T4#@ [(1st difference for n^2) := -64]
[Start of loop]
[22] TF [clear acc]
A#@ [load n]
A8#@ [add 8]
T#@ [update n]
A4#@ [load 1st difference of n^2]
A6#@ [add 128]
T4#@ [update]
A2#@ [load residue of n^2 mod 1000000]
A4#@ [add 1st difference]
[31] A10#@ [subtract 1000000, by adding -1000000]
E31@ [repeat until result < 0]
S10#@ [add back 1000000]
U2#@ [update residue]
S12#@ [subtract target 269696]
G22@ [loop back if residue < 269696]
[if still here, acc is non-neg mult of 64]
S8#@ [test for acc = 0 by subtracting 8]
E22@ [loop back if residue > 269696]
[Here with the solution]
TF [clear acc]
A#@ [load solution n]
TD [store at absolute address 0 for printing]
[42] A42@ [for return from subroutine]
G56F [call subroutine to print n]
O15@ [print CR]
O14@ [print LF]
O16@ [print null, to flush printer buffer]
ZF [stop]
E17Z [define entry point]
PF [enter with acc = 0]

4
Task/Babbage-problem/EasyLang/babbage-problem.easy Normal file
View file

@ -0,0 +1,4 @@
while n * n mod 1000000 <> 269696
n += 1
.
print n

14
Task/Babbage-problem/Elena/babbage-problem.elena Normal file
View file

@ -0,0 +1,14 @@
import extensions;
import system'math;
public program()
{
var n := 1;
until(n.sqr().mod:1000000 == 269696)
{
n += 1
};
console.printLine(n)
}

6
Task/Babbage-problem/Elixir/babbage-problem-1.elixir Normal file
View file

@ -0,0 +1,6 @@
defmodule Babbage do
def problem(n) when rem(n*n,1000000)==269696, do: n
def problem(n), do: problem(n+2)
end
IO.puts Babbage.problem(0)

3
Task/Babbage-problem/Elixir/babbage-problem-2.elixir Normal file
View file

@ -0,0 +1,3 @@
Stream.iterate(2, &(&1+2))
|> Enum.find(&rem(&1*&1, 1000000) == 269696)
|> IO.puts

11
Task/Babbage-problem/Erlang/babbage-problem.erl Normal file
View file

@ -0,0 +1,11 @@
-module(solution1).
-export([main/0]).
babbage(N,E) when N*N rem 1000000 == 269696 ->
io:fwrite("~p",[N]);
babbage(N,E) ->
case E of
4 -> babbage(N+2,6);
6 -> babbage(N+8,4)
end.
main()->
babbage(4,4).

4
Task/Babbage-problem/F-Sharp/babbage-problem-1.fs Normal file
View file

@ -0,0 +1,4 @@
let mutable n=1
while(((n*n)%( 1000000 ))<> 269696) do
n<-n+1
printf"%i"n

3
Task/Babbage-problem/F-Sharp/babbage-problem-2.fs Normal file
View file

@ -0,0 +1,3 @@
Seq.initInfinite id
|> Seq.skipWhile (fun n->(n*n % 1000000) <> 269696)
|> Seq.head |> printfn "%d"

2
Task/Babbage-problem/F-Sharp/babbage-problem-3.fs Normal file
View file

@ -0,0 +1,2 @@
let rec fN g=seq{yield g; yield g+2; yield! fN(g+10)}
printfn "%d" (fN 524|>Seq.find(fun n->n*n%1000000=269696))

133
Task/Babbage-problem/Factor/babbage-problem.factor Normal file
View file

@ -0,0 +1,133 @@
! Lines like this one are comments. They are meant for humans to
! read and have no effect on the instructions carried out by the
! computer (aside from Factor's parser ignoring them).
! Comments may appear after program instructions on the same
! line.
! Each word between USING: and ; is a vocabulary. By importing
! a vocabulary in this way, its words are made available for the
! program to use. This is a way to keep the space requirements
! down for deployed programs, and a nice side effect is that it
! gives readers a clue for where to look for documentation.
USING: kernel math math.ranges prettyprint sequences ;
! Before the program begins, it's incredibly helpful to have an
! understanding of Factor's dataflow model. Don't worry; it's
! not complicated, but it's confusing to read a Factor program
! without this knowledge.
! Factor is a stack-based language. What this means is that
! there is an implicit data stack in the background, waiting
! to recieve whatever manner of thing we wish to give it. Here
! is a simple arithmetic expression to demonstrate:
! language token | data stack
! ---------------+-----------
! 2 2 ! numbers place themselves on the stack.
! 1 2 1
! 4 2 1 4
! + 2 5 ! consume 1 and 4 and leave behind 5.
! * 10 ! consume 2 and 5 and leave behind 10.
! Thus the phrase
! 2 1 4 + *
! in Factor is a way to calculate 2 * (4 + 1).
! We could have also written this as
! 1 4 + 2 *
! with no change in meaning or outcome.
! Because of the way the data stack works, there is no need
! to specify order of operations in the language, because you do
! so inherently by the order you place things on the data stack.
! === BEGIN PROGRAM ============================================
518 99,736 2 <range> ! Here we place three numbers on the
! stack representing a range of numbers.
! The first, 518, represents the starting
! point of the sequence. 99,736
! represents the ending point of the
! sequence. 2 represents the "step" of
! the sequence, or a constant distance
! between members.
! <range> takes those three numbers and
! creates an object representing the
! described range of numbers. Computers
! of today are more than capable of
! storing that many numbers, but <range>
! doesn't store them all; it calculates
! the number that is needed at the
! current time.
! The rationale for the sequence is as
! follows. Odd squares are always odd, so
! we don't need to consider them. That's
! why the sequence starts with an even
! number and is incremented by 2. We
! choose 518 to start because it's the
! largest even square less than 269,696.
! We choose 99,736 to end because we
! know it's a solution.
[ sq 1,000,000 mod 269,696 = ]
! the [ ... ] form is called a quotation.
! Think of it like a sequence that stores
! code. It's a way to place code on the
! data stack without executing it. This
! is so that it can be used by the find
! word. You could also think of it much
! like a function that hasn't been given
! a name.
find
! When we call the find word, there are
! two objects on the stack: a sequence
! and a quotation. find is a word that
! takes a sequence and a quotation and
! applies the quotation to one member of
! the sequence after another. It does
! so until the quotation returns a t
! value (denoting a boolean true) and
! then leaves that number, along with its
! index in the sequence, on the stack.
! Let's take a look at what happens
! for each iteration of find. Let's look
! at what happens with the first number
! in the sequence.
! language token | data stack
! ---------------+-----------
! 518 518 ! 518 is placed on the stack
! from the sequence by find.
! sq 268,324 ! square it
! 1,000,000 268,324 1,000,000 ! place a million on the stack
! mod 268,324 ! take modulus of 268,324
! and 1,000,000
! 269,696 268,324 269,696 ! place 269,696 on the stack
! = f ! test 268,324 and 269,696 for
! equality.
! So the square of the first number in
! the sequence, 518, does not end with
! 269,696. We'll try each number in the
! sequence until we get a t.
. ! Consume the top member of the data stack and print it out.
drop ! find leaves both the found element from the sequence
! and the index at which it was found on the data stack.
! We don't care about the index so we will call drop to
! remove it from the top of the data stack. All programs
! must end with an emtpy data stack.
! Putting the entire program together, it looks like this:
! 518 99,736 2 <range> [ sq 1,000,000 mod 269,696 = ] find . drop

17
Task/Babbage-problem/Forth/babbage-problem.fth Normal file
View file

@ -0,0 +1,17 @@
( First we set out the steps the computer will use to solve the problem )
: BABBAGE
1 ( start from the number 1 )
BEGIN ( commence a "loop": the computer will return to this point repeatedly )
1+ ( add 1 to our number )
DUP DUP ( duplicate the result twice, so we now have three copies )
( We need three because we are about to multiply two of them together to find the square, and the third will be used the next time we go around the loop -- unless we have found our answer, in which case we shall need to print it out )
* ( * means "multiply", so we now have the square )
1000000 MOD ( find the remainder after dividing it by a million )
269696 = ( is it equal to 269,696? )
UNTIL ( keep repeating the steps from BEGIN until the condition is satisfied )
. ; ( when it is satisfied, print out the number that allowed us to satisfy it )
( Now we ask the machine to carry out these instructions )
BABBAGE

6
Task/Babbage-problem/Fortran/babbage-problem-1.f Normal file
View file

@ -0,0 +1,6 @@
DO 3 N=1,99736
IF(MODF(N*N,1000000)-269696)3,4,3
3 CONTINUE
4 PRINT 5,N
5 FORMAT(I6)
STOP

10
Task/Babbage-problem/Fortran/babbage-problem-2.f Normal file
View file

@ -0,0 +1,10 @@
program babbage
implicit none
integer :: n
n=1
do while (mod(n*n,1000000) .ne. 269696)
n = n + 1
end do
print*, n
end program babbage

42
Task/Babbage-problem/FreeBASIC/babbage-problem.basic Normal file
View file

@ -0,0 +1,42 @@
' version 25-10-2016
' compile with: fbc -s console
' Charles Babbage would have known that only number ending
' on a 4 or 6 could produce a square ending on a 6
' also any number below 520 would produce a square smaller than 269,696
' we can stop when we have reached 99,736
' we know it square and it ends on 269,696
Dim As ULong number = 524 ' first number to try
Dim As ULong square, count
Do
' square the number
square = number * number
' look at the last 6 digits, if they match print the number
If Right(Str(square), 6) = "269696" Then Exit Do
' increase the number with 2, number end ons a 6
number = number +2
' if the number = 99736 then we haved found a smaller number, so stop
If number = 99736 Then Exit Do
square = number * number
' look at the last 6 digits, if they match print the number
If Right(Str(square),6 ) = "269696" Then Exit Do
' increase the number with 8, number ends on a 4
number = number +8
' go to the first line under "Do"
Loop
If number = 99736 Then
Print "No smaller number was found"
Else
' we found a smaller number, print the number and its square
Print Using "The number = #####, and its square = ##########,"; number; square
End If
' empty keyboard buffer
While Inkey <> "" : Wend
Print : Print "hit any key to end program"
Sleep
End

17
Task/Babbage-problem/Frink/babbage-problem.frink Normal file
View file

@ -0,0 +1,17 @@
// This is a solver for the Rosetta Code problem "Babbage problem"
// https://rosettacode.org/wiki/Babbage_problem
i = 1
while true
{
// mod is the modulus operator.
// The == operator is a test for equality. A single =
// assigns to a variable.
if i² mod million == 269696
{
// This prints i and i²
println[i + "² = " + i²]
exit[] // This terminates the program if a solution is found.
}
i = i + 1
}

12
Task/Babbage-problem/FutureBasic/babbage-problem.basic Normal file
View file

@ -0,0 +1,12 @@
window 1
long i
for i = 1 to 1000000
if i ^ 2 mod 1000000 == 269696 then exit for
next
print @"The smallest number whose square ends in 269696 is ";i
print @"Its square is ";i ^ 2
HandleEvents

11
Task/Babbage-problem/GW-BASIC/babbage-problem.basic Normal file
View file

@ -0,0 +1,11 @@
10 CLS
20 DEF FN ST(A#) = N# - INT (A#) * INT (A#)
30 N# = 269696!
40 N# = N# + 1000000!
50 R# = SQR(N#)
60 IF FN ST(R#) <> 0 AND N# < 999999999# THEN GOTO 40
70 IF N# > 999999999# THEN GOTO 110
80 PRINT "The smallest number whose square ends in 269696 is:";R#
90 PRINT "It's square is:";N#
100 END
110 PRINT "There is no solution for values smaller than 999999999."

10
Task/Babbage-problem/Gambas/babbage-problem.gambas Normal file
View file

@ -0,0 +1,10 @@
Public Sub Main()
Dim iNum As Long
For iNum = 1 To 100000
If Str(iNum * iNum) Ends "269696" Then Break
Next
Print "The lowest number squared that ends in '269696' is " & Str(iNum)
End

20
Task/Babbage-problem/Go/babbage-problem.go Normal file
View file

@ -0,0 +1,20 @@
package main
import "fmt"
func main() {
const (
target = 269696
modulus = 1000000
)
for n := 1; ; n++ { // Repeat with n=1, n=2, n=3, ...
square := n * n
ending := square % modulus
if ending == target {
fmt.Println("The smallest number whose square ends with",
target, "is", n,
)
return
}
}
}

6
Task/Babbage-problem/Groovy/babbage-problem.groovy Normal file
View file

@ -0,0 +1,6 @@
int n=104; ///starting point
while( (n**2)%1000000 != 269696 )
{ if (n%10==4) n=n+2;
if (n%10==6) n=n+8;
}
println n+"^2== "+n**2 ;

12
Task/Babbage-problem/Haskell/babbage-problem-1.hs Normal file
View file

@ -0,0 +1,12 @@
--Calculate squares, testing for the last 6 digits
findBabbageNumber :: Integer
findBabbageNumber =
head (filter ((269696 ==) . flip mod 1000000 . (^ 2)) [1 ..])
main :: IO ()
main =
(putStrLn . unwords)
(zipWith
(++)
(show <$> ([id, (^ 2)] <*> [findBabbageNumber]))
[" ^ 2 equals", " !"])

18
Task/Babbage-problem/Haskell/babbage-problem-2.hs Normal file
View file

@ -0,0 +1,18 @@
import Data.List (intercalate)
import Data.Maybe (maybe)
import Safe (headMay)
maybeBabbage :: Integer -> Maybe Integer
maybeBabbage upperLimit =
headMay
(filter ((269696 ==) . flip rem 1000000) ((^ 2) <$> [1 .. upperLimit]))
main :: IO ()
main = do
let upperLimit = 100000
putStrLn $
maybe
(intercalate (show upperLimit) ["No such number found below ", " ..."])
(intercalate " ^ 2 -> " .
fmap show . (<*>) [floor . sqrt . fromInteger, id] . pure)
(maybeBabbage upperLimit)

25
Task/Babbage-problem/Haskell/babbage-problem-3.hs Normal file
View file

@ -0,0 +1,25 @@
import Data.List (intercalate)
--------------------- BABBAGE PROBLEM --------------------
babbagePairs :: [[Integer]]
babbagePairs =
[0, 1000000 ..]
>>= \x -> -- Drawing from a succession of N * 10^6
let y = (x + 269696) -- The next number ending in 269696,
r = root y -- its square root,
i = floor r -- and the integer part of that root.
in [ [i, y] -- Root and square harvested together,
| r == fromIntegral i -- only if that root is an integer.
]
root :: Integer -> Double
root = sqrt. fromIntegral
--------------------------- TEST -------------------------
main :: IO ()
main = mapM_ (putStrLn . arrowed) $ take 10 babbagePairs
arrowed :: [Integer] -> String
arrowed = intercalate " ^ 2 -> " . fmap show

22
Task/Babbage-problem/Haskell/babbage-problem-4.hs Normal file
View file

@ -0,0 +1,22 @@
---------------------- BABBAGE PAIRS ---------------------
babbagePairs :: [(Integer, Integer)]
babbagePairs =
[0, 10000 ..]
>>= \x ->
( ((,) <*> (^ 2)) . (x +)
<$> [264, 5264, 9736, 4736]
)
>>= \(a, b) ->
[ (a, b)
| ((269696 ==) . flip rem 1000000) b
]
--------------------------- TEST -------------------------
main :: IO ()
main =
mapM_
putStrLn
( (\(a, b) -> show a <> " ^2 -> " <> show b)
<$> take 2000 babbagePairs
)

91
Task/Babbage-problem/Hoon/babbage-problem.hoon Normal file
View file

@ -0,0 +1,91 @@
:: This is Hoon, a language for writing human-legible
:: instructions to a machine called Urbit.
::
:: A pair of non-alphanumeric symbols is called a rune.
:: Each rune begins a unique expression.
::
:: An expression can be an instruction to the machine,
:: or a description of essential information.
:: Each rune specifies a different expression.
:: Each expression can contain other expressions.
:: (In practice, every expression contains
:: at least one of the expressions that follow it.)
::
:: :: tells the machine to ignore the rest of a line
:: these lines allow commentary for a human reader
:: like the question this program will answer:
::
:: What is the smallest positive integer whose
:: square ends in the digits 269,696?
::
:: The program of instructions for solving this,
:: uninterrupted by commentary, is:
::
:: :- %say
:: |= [*]
:: :- %noun
:: ^- @ud
:: =/ n 0
:: |-
:: ?: =(269.696 (mod (pow n 2) 1.000.000))
:: n
:: %= $
:: n +(n)
:: ==
::
:: The first three significant lines describe
:: two things: our program's input, and its structure.
:: They specify the program requires no input.
:: Otherwise, we can ignore them for our purposes.
::
:: ^- describes the desired output of our program.
:: @ud signifies an unknown positive integer.
:: The output will be a positive integer.
:: The output will be our answer.
:- %say
|= [*]
:- %noun
^- @ud
::
:: =/ assigns a value to a name, for future reference.
:: Here we assign value 0 to "n", as in algebra.
=/ n 0
::
:: |- begins a recursive, iterative process.
:: It might not end until a condition is met.
|-
::
:: ?: does two things.
:: First, it returns a Boolean true-or-false answer
:: to the question that follows.
:: Second, it evaluates one of two expressions
:: branching on whether the answer is true or false.
::
:: Here we rephrase our question for the machine:
:: "Is 269,696 equal to the remainder of
:: n^2 divided by 1,000,000?"
?: =(269.696 (mod (pow n 2) 1.000.000))
::
:: If so, we get our answer: the current value of n.
n
::
:: If not, we run the whole program again,
:: but this time n is replaced by (n+1).
:: n will be incremented by 1 until our
:: ?: question has the answer "true",
:: upon which it will return n.
:: If n is 0, it will now be 1.
:: If n is 25,263, it will now be 25,264 which,
:: as this program shows, is the smallest positive
:: integer whose square ends in the digits 269,696.
::
:: %= runs the whole program again, but
:: with the listed names, on the left, assigned
:: new values on the right. It could take an
:: arbitrary number of children, so unlike the
:: other runes here which take a fixed number,
:: this expression must end in a == rune, which
:: just brings the expression to an end.
%= $
n +(n)
==

7
Task/Babbage-problem/IS-BASIC/babbage-problem-1.basic Normal file
View file

@ -0,0 +1,7 @@
100 PROGRAM "Babbage.bas"
110 LET N=2
120 DO
130 LET N=N+2
140 LOOP UNTIL MOD(N*N,1000000)=269696
150 PRINT "The smallest number whose square ends in 269696 is:";N
160 PRINT "It's square is";N^2

8
Task/Babbage-problem/IS-BASIC/babbage-problem-2.basic Normal file
View file

@ -0,0 +1,8 @@
100 PROGRAM "Babbage.bas"
110 LET N=269696
120 DO
130 LET N=N+1000000
140 LET R=SQR(N)
150 LOOP UNTIL R=INT(R)
160 PRINT "The smallest number whose square ends in 269696 is:";R
170 PRINT "It's square is";N

6
Task/Babbage-problem/J/babbage-problem-1.j Normal file
View file

@ -0,0 +1,6 @@
square=: ^&2
modulo1e6=: 1000000&|
trythese=: i. 1000000 NB. first million nonnegative integers
which=: I. NB. position of true values
which 269696=modulo1e6 square trythese NB. right to left <-
25264 99736 150264 224736 275264 349736 400264 474736 525264 599736 650264 724736 775264 849736 900264 974736

30
Task/Babbage-problem/J/babbage-problem-2.j Normal file
View file

@ -0,0 +1,30 @@
NB. In the interactive environment.
NB. First here, Mr Babbage, we'll make the computer's words more meaningful to an english speaker.
NB. The first is the "head" of a list, written with these inviting open arms that embrace one small dot :
first=: {.
NB. The small i. notation denotes "all integers up to 100000". You've already found a solution in that range.
n=: i. 100000
NB. This is how we write squaring.
squareof=: *:
NB. In our notation, a dyad is a word that takes an x value on the left and an y value on the right.
ends=: dyad : ' x = 1000000 | y '
NB. This dyad selects values from the list x, as marked by the list y
where=: dyad : ' y # x '
NB. Now that we defined our words, we can ask our question with them :
first n where 269696 ends squareof n
25264
NB. With a bit of habit, you won't need to define words in english anymore.
NB. The following easily relates word for word to the sentence we've written :
{. (i.100000) #~ 269696 = 1000000 | *: i.100000
25264
NB. Like all mathematical notations, in J you see patterns that suggest simplification :
{. I. 269696 = 1000000 | *: i.100000
25264

20
Task/Babbage-problem/Java/babbage-problem.java Normal file
View file

@ -0,0 +1,20 @@
public class Test {
public static void main(String[] args) {
// let n be zero
int n = 0;
// repeat the following action
do {
// increase n by 1
n++;
// while the modulo of n times n is not equal to 269696
} while (n * n % 1000_000 != 269696);
// show the result
System.out.println(n);
}
}

18
Task/Babbage-problem/JavaScript/babbage-problem-1.js Normal file
View file

@ -0,0 +1,18 @@
// Every line starting with a double slash will be ignored by the processing machine,
// just like these two.
//
// Since the square root of 269,696 is approximately 519, we create a variable named "n"
// and give it this value.
n = 519
// The while-condition is in parentheses
// * is for multiplication
// % is for modulo operation
// != is for "not equal"
while ( ((n * n) % 1000000) != 269696 )
n = n + 1
// n is incremented until the while-condition is met, so n should finally be the
// smallest positive integer whose square ends in the digits 269,696. To see n, we
// need to send it to the monitoring device (named console).
console.log(n)

111
Task/Babbage-problem/JavaScript/babbage-problem-2.js Normal file
View file

@ -0,0 +1,111 @@
(() => {
'use strict';
// babbageNumbers :: Int -> [Int]
const babbageNumbers = n =>
// Take the first n Babbage numbers,
take(n)(
// from the concatenation of outputs of
// a function which constructs the next number
// ending in 269696, and returns it wrapped
// in a list if it is a perfect square,
// or just returns an empty list if it
// is not a perfect square.
// The concatenation of the map output eliminates
// all empty lists, leaving a sequence of perfect
// squares which end in 269696.
concatMap(x => {
const
fx = 269696 + (1000000 * x),
root = Math.sqrt(fx);
return root === Math.floor(root) ? (
[Tuple(root)(fx)]
) : [];
// Mapped over non-finite integer series
// starting with 1.
})(enumFrom(1))
);
// TEST -----------------------------------------------
const main = () =>
// List of the first 10 positive integers
// whose squares end in 269696.
unlines(
map(pair => fst(pair) + '^2 -> ' + snd(pair))(
babbageNumbers(10)
));
// GENERIC FUNCTIONS ----------------------------------
// Tuple (,) :: a -> b -> (a, b)
const Tuple = a => b => ({
type: 'Tuple',
'0': a,
'1': b,
length: 2
});
// concatMap :: (a -> [b]) -> Gen [a] -> Gen [b]
const concatMap = f =>
// Instance of concatMap for non-finite streams.
function*(xs) {
let
x = xs.next(),
v = undefined;
while (!x.done) {
v = f(x.value);
if (0 < v.length) {
yield v[0];
}
x = xs.next();
}
};
// enumFrom :: Enum a => a -> [a]
function* enumFrom(x) {
let v = x;
while (true) {
yield v;
v = succ(v);
}
}
// fst :: (a, b) -> a
const fst = tpl => tpl[0];
// map :: (a -> b) -> [a] -> [b]
const map = f => xs =>
(Array.isArray(xs) ? (
xs
) : xs.split('')).map(f);
// root :: Tree a -> a
const root = tree => tree.root;
// snd :: (a, b) -> b
const snd = tpl => tpl[1];
// succ :: Enum a => a -> a
const succ = x =>
1 + x;
// take :: Int -> [a] -> [a]
// take :: Int -> String -> String
const take = n => xs =>
'GeneratorFunction' !== xs.constructor.constructor.name ? (
xs.slice(0, n)
) : [].concat.apply([], Array.from({
length: n
}, () => {
const x = xs.next();
return x.done ? [] : [x.value];
}));
// unlines :: [String] -> String
const unlines = xs => xs.join('\n');
// MAIN ---
return main();
})();

8
Task/Babbage-problem/Julia/babbage-problem.julia Normal file
View file

@ -0,0 +1,8 @@
function babbage(x::Integer)
i = big(0)
d = floor(log10(x)) + 1
while i ^ 2 % 10 ^ d != x
i += 1
end
return i
end

14
Task/Babbage-problem/Kotlin/babbage-problem.kotlin Normal file
View file

@ -0,0 +1,14 @@
fun main(args: Array<String>) {
var number = 520L
var square = 520 * 520L
while (true) {
val last6 = square.toString().takeLast(6)
if (last6 == "269696") {
println("The smallest number is $number whose square is $square")
return
}
number += 2
square = number * number
}
}

7
Task/Babbage-problem/Lambdatalk/babbage-problem.lambdatalk Normal file
View file

File diff suppressed because one or more lines are too long

7
Task/Babbage-problem/Liberty-BASIC/babbage-problem-1.basic Normal file
View file

@ -0,0 +1,7 @@
[start]
if right$(str$(n*n),6)="269696" then
print "n = "; using("###,###", n);
print " n*n = "; using("###,###,###,###", n*n)
end if
if n<100000 then n=n+1: goto [start]
print "Program complete."

3
Task/Babbage-problem/Liberty-BASIC/babbage-problem-2.basic Normal file
View file

@ -0,0 +1,3 @@
n = 25,264 n*n = 638,269,696
n = 99,736 n*n = 9,947,269,696
Program complete.

21
Task/Babbage-problem/Limbo/babbage-problem.limbo Normal file
View file

@ -0,0 +1,21 @@
implement Babbage;
include "sys.m";
sys: Sys;
print: import sys;
include "draw.m";
draw: Draw;
Babbage : module
{
init : fn(ctxt : ref Draw->Context, args : list of string);
};
init (ctxt: ref Draw->Context, args: list of string)
{
sys = load Sys Sys->PATH;
current := 0;
while ((current * current) % 1000000 != 269696)
current++;
print("%d", current);
}

14
Task/Babbage-problem/Lua/babbage-problem.lua Normal file
View file

@ -0,0 +1,14 @@
-- get smallest number <= sqrt(269696)
k = math.floor(math.sqrt(269696))
-- if root is odd -> make it even
if k % 2 == 1 then
k = k - 1
end
-- cycle through numbers
while not ((k * k) % 1000000 == 269696) do
k = k + 2
end
io.write(string.format("%d * %d = %d\n", k, k, k * k))

6
Task/Babbage-problem/M2000-Interpreter/babbage-problem.m2000 Normal file
View file

@ -0,0 +1,6 @@
Def Long k=1000000, T=269696, n
n=Sqrt(269696)
For n=n to k {
If n^2 mod k = T Then Exit
}
Report format$("The smallest number whose square ends in {0} is {1}, Its square is {2}", T, n, n**2)

9
Task/Babbage-problem/MAXScript/babbage-problem.max Normal file
View file

@ -0,0 +1,9 @@
-- MAXScript : Babbage problem : N.H.
posInt = 1
while posInt < 1000000 do
(
if (matchPattern((posInt * posInt) as string) pattern: "*269696") then exit
posInt += 1
)
Print "The smallest number whose square ends in 269696 is " + ((posInt) as string)
Print "Its square is " + (((pow posInt 2) as integer) as string)

1
Task/Babbage-problem/Mathematica/babbage-problem.math Normal file
View file

@ -0,0 +1 @@
Solve[Mod[x^2, 10^6] == 269696 && 0 <= x <= 99736, x, Integers]

25
Task/Babbage-problem/Microsoft-Small-Basic/babbage-problem.basic Normal file
View file

@ -0,0 +1,25 @@
' Babbage problem
' The quote (') means a comment
' The equals sign (=) means assign
n = 500
' 500 is stored in variable n*n
' 500 because 500*500=250000 less than 269696
' The nitty-gritty is in the 3 lines between "While" and "EndWhile".
' So, we start with 500, n is being incremented by 1 at each round
' while its square (n*n) (* means multiplication) does not have
' a remainder (function Math.Remainder) of 269696 when divided by one million.
' This means that the loop will stop when the smallest positive integer
' whose square ends in 269696
' is found and stored in n.
' (<>) means "not equal to"
While Math.Remainder( n*n , 1000000 ) <> 269696
n = n + 1
EndWhile
' (TextWindow.WriteLine) displays the string to the monitor
' (+) concatenates strings or variables to be displayed
TextWindow.WriteLine("The smallest positive integer whose square ends in 269696 is " + (n) + ".")
TextWindow.WriteLine("Its square is " + (n*n) + ".")
' End of Program.

22
Task/Babbage-problem/MiniScript/babbage-problem.mini Normal file
View file

@ -0,0 +1,22 @@
// Lines that start with "//" are "comments" that are ignored
// by the computer. We use them to explain the code.
// Start by finding the smallest number that could possibly
// square to 269696. sqrt() returns the square root of a
// number, and floor() truncates any fractional part.
k = floor(sqrt(269696))
// Since 269696 is even, we are only going to consider even
// roots. We use the % (modulo) operator, which returns the
// remainder after division, to tell if k is odd; if so, we
// add 1 to make it even.
if k % 2 == 1 then k = k + 1
// Now we count up by 2 from k, until we find a number that,
// when squared, ends in 269696 (using % again).
while k^2 % 1000000 != 269696
k = k + 2
end while
// The first such number we find is our answer.
print k + "^2 = " + k^2

27
Task/Babbage-problem/Modula-2/babbage-problem.mod2 Normal file
View file

@ -0,0 +1,27 @@
MODULE BabbageProblem;
FROM FormatString IMPORT FormatString;
FROM RealMath IMPORT sqrt;
FROM Terminal IMPORT WriteString,ReadChar;
VAR
buf : ARRAY[0..63] OF CHAR;
k : INTEGER;
BEGIN
(* Find the greatest integer less than the square root *)
k := TRUNC(sqrt(269696.0));
(* Odd numbers cannot be solutions, so decrement *)
IF k MOD 2 = 1 THEN
DEC(k);
END;
(* Find a number that meets the criteria *)
WHILE (k*k) MOD 1000000 # 269696 DO
INC(k,2)
END;
FormatString("%i * %i = %i", buf, k, k, k*k);
WriteString(buf);
ReadChar
END BabbageProblem.

7
Task/Babbage-problem/Nanoquery/babbage-problem.nanoquery Normal file
View file

@ -0,0 +1,7 @@
n = 0
while not (n ^ 2 % 1000000) = 269696
n += 1
end
println n

34
Task/Babbage-problem/NetRexx/babbage-problem.netrexx Normal file
View file

@ -0,0 +1,34 @@
/* NetRexx */
options replace format comments java crossref symbols nobinary utf8
numeric digits 5000 -- set up numeric precision
babbageNr = babbage() -- call a function to perform the analysis and capture the result
babbageSq = babbageNr ** 2 -- calculate the square of the result
-- display results using a library function
System.out.printf("%,10d\u00b2 == %,12d%n", [Integer(babbageNr), Integer(babbageSq)])
return
-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-- A function method to answer Babbage's question:
-- "What is the smallest positive integer whose square ends in the digits 269,696?"
-- — Babbage, letter to Lord Bowden, 1837;
-- see Hollingdale and Tootill, Electronic Computers, second edition, 1970, p. 125.
-- (He thought the answer might be 99,736, whose square is 9,947,269,696; but he couldn't be certain.)
method babbage() public static binary
n = int 104 -- (integer arithmatic)
-- begin a processing loop to determine the value
-- starting point: 104
loop while ((n * n) // 1000000) \= 269696
-- loop continues while the remainder of n squared divided by 1,000,000 is not equal to 269,696
if n // 10 == 4 then do
-- increment n by 2 if the remainder of n divided by 10 equals 4
n = n + 2
end
if n // 10 == 6 then do
-- increment n by 8 if the remainder of n divided by 10 equals 6
n = n + 8
end
end
return n -- end the function and return the result

8
Task/Babbage-problem/NewLISP/babbage-problem.l Normal file
View file

@ -0,0 +1,8 @@
;;; Start by assigning n the integer square root of 269696
;;; minus 1 to be even
(setq n 518)
;;; Increment n by 2 till the last 6 digits of its square are 269696
(while (!= (% (* n n) 1000000) 269696)
(++ n 2))
;;; Show the result and its square
(println n "^2 = " (* n n))

4
Task/Babbage-problem/Nim/babbage-problem.nim Normal file
View file

@ -0,0 +1,4 @@
var n : int = 0
while n*n mod 1_000_000 != 269_696:
inc(n)
echo n

7
Task/Babbage-problem/OCaml/babbage-problem.ocaml Normal file
View file

@ -0,0 +1,7 @@
let rec f a=
if (a*a) mod 1000000 != 269696
then f(a+1)
else a
in
let a= f 1 in
Printf.printf "smallest positive integer whose square ends in the digits 269696 is %d\n" a

12
Task/Babbage-problem/Objeck/babbage-problem.objeck Normal file
View file

@ -0,0 +1,12 @@
class Babbage {
function : Main(args : String[]) ~ Nil {
cur := 0;
do {
cur++;
}
while(cur * cur % 1000000 <> 269696);
cur_sqr := cur * cur;
"The square of {$cur} is {$cur_sqr}!"->PrintLine();
}
}

5
Task/Babbage-problem/Ol/babbage-problem.ol Normal file
View file

@ -0,0 +1,5 @@
(print
(let loop ((i 2))
(if (eq? (mod (* i i) 1000000) 269696)
i
(loop (+ i 1)))))

8
Task/Babbage-problem/PARI-GP/babbage-problem.parigp Normal file
View file

@ -0,0 +1,8 @@
m=269696;
k=1000000;
{for(n=1,99736,
\\ Try each number in this range, from 1 to 99736
if(denominator((n^2-m)/k)==1, \\ Check if n squared, minus m, is divisible by k
return(n) \\ If so, return this number and STOP.
)
)}

9
Task/Babbage-problem/PHP/babbage-problem.php Normal file
View file

@ -0,0 +1,9 @@
<?php
for (
$i = 1 ; // Initial positive integer to check
($i * $i) % 1000000 !== 269696 ; // While i*i does not end with the digits 269,696
$i++ // ... go to next integer
);
echo $i, ' * ', $i, ' = ', ($i * $i), PHP_EOL; // Print the result

19
Task/Babbage-problem/PILOT/babbage-problem.pilot Normal file
View file

@ -0,0 +1,19 @@
Remark:Lines identified as "remarks" are intended for the human reader, and will be ignored by the machine.
Remark:A "compute" instruction gives a value to a variable.
Remark:We begin by making the variable n equal to 2.
Compute:n = 2
Remark:Lines beginning with asterisks are labels. We can instruct the machine to "jump" to them, rather than carrying on to the next instruction as it normally would.
*CheckNextNumber
Remark:In "compute" instructions, "x * y" should be read as "x times y" and "x % y" as "x modulo y".
Compute:square = n * n
Compute:lastSix = square % 1000000
Remark:A "jump" instruction that includes an equation or an inequality in parentheses jumps to the designated label if and only if the equation or inequality is true.
Jump( lastSix = 269696 ):*FoundIt
Remark:If the last six digits are not equal to 269696, add 2 to n and jump back to "CheckNextNumber".
Compute:n = n + 2
Jump:*CheckNextNumber
*FoundIt
Remark:Type, i.e. print, the result. The symbol "#" means that what follows is one of our variables and the machine should type its value.
Type:The smallest number whose square ends in 269696 is #n. Its square is #square.
Remark:The end.
End:

24
Task/Babbage-problem/PL-I/babbage-problem.pli Normal file
View file

@ -0,0 +1,24 @@
/* Babbage might have used a difference engine to compute squares. */
/* The algorithm used here uses only additions to form successive squares. */
/* Since there is no guarantee that the final square will not exceed a */
/* 32-bit integer word, modulus is formed to limit the magnitude of the */
/* squares, since we are really interested only in the last six digits of */
/* the square. */
Babbage_problem: procedure options (main); /* R. Vowels, 19 Dec. 2021 */
declare n fixed decimal (5);
declare (odd, sq) fixed binary (31);
odd = 3; sq = 4; /* the initial square is 4 */
do n = 3 to 99736;
odd = odd + 2;
sq = sq + odd; /* form the next square */
if sq >= 1000000 then sq = sq - 1000000; /* keep the remainder */
if sq = 269696 then leave;
end;
put ('The smallest number whose square ends in 269696 is ' || trim(n) );
put skip list ('The corresponding square is ' || trim (n*n) );
/* Even if the number had been 99736, n*n would not have overflowed */
/* because decimal arithmetic allows up to 15 decimal digits. */
end Babbage_problem;

11
Task/Babbage-problem/Pascal/babbage-problem.pas Normal file
View file

@ -0,0 +1,11 @@
program BabbageProblem;
(* Anything bracketed off like this is an explanatory comment. *)
var n : longint; (* The VARiable n can hold a 'long', ie large, INTeger. *)
begin
n := 2; (* Start with n equal to 2. *)
repeat
n := n + 2 (* Increase n by 2. *)
until (n * n) mod 1000000 = 269696;
(* 'n * n' means 'n times n'; 'mod' means 'modulo'. *)
write(n)
end.

9
Task/Babbage-problem/Perl/babbage-problem-1.pl Normal file
View file

@ -0,0 +1,9 @@
#!/usr/bin/perl
use strict ;
use warnings ;
my $current = 0 ;
while ( ($current ** 2 ) % 1000000 != 269696 ) {
$current++ ;
}
print "The square of $current is " . ($current * $current) . " !\n" ;

Some files were not shown because too many files have changed in this diff Show more