Babbage problem: Difference between revisions

 

 

 

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.

 

 

 

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.

 

=={{header|11l}}==

L n ^ 2 % 1000000 != 269696

n++

 

=={{header|360 Assembly}}==

An assembler program always seems a bit tricky for non system engineer because it deals directly with the operating system and with the hardware instructions. Here we have a 32-bit computer with 16 32-bit registers. The caller (the operating system to keep it simple) is calling you giving your location address stored in register-15 and has stored in register-14 his return address. To save each program context, register-13 points to a 18 word save area. Do not spend time in understanding the context saving and restoring in the prologue and epilogue part of the program. What you have to know, “360” architecture uses 32-bit signed binary arithmetic, so here the maximum integer value is 2^31-1 (2147483647). Therefore the solution must be less than 2147483647. The multiplication and the division use a pair of registers; coding “MR 4,2” means multiply register-5 by register-2 and place result in the (register-4,register-5) pair; the same way “DR 4,2” means divide the (register-4,register-5) pair by register-2 and place the quotient in register-5 and the reminder in register-4. We use in the below program this intermediate 64-bit integers to find a solution with a value up to 2^31-1 even when we have to compute the square of this value.

* Find the lowest positive integer whose square ends in 269696

* The logic of the assembler program is simple :

BUFFER DC CL80'Solution is: i=............ (i*i=............)'

END BABBAGE end of the control section

{{out}}

<pre>

Solution is: i= 25264 (i*i= 638269696)

</pre>

 

=={{header|Ada}}==

 

-- has been chosen in honour of your friend,

-- Augusta Ada King-Noel, Countess of Lovelace (née Byron).

-- Ada.Text_IO.Put_Line(...) prints this string, for humans to read.

-- I did already run the program, and it did print out 25264.

 

=={{header|Aime}}==

 

i = sqrt(269696);

}

 

 

=={{header|ALGOL 68}}==

As with other samples, we use "simple" forms such as "a := a + 1" instead of "a +:= 1".

for the human reader's information and are ignored by the machine

COMMENT

COMMENT print displays the values of its parameters

COMMENT

{{out}}

<pre>

+25264 when squared is: +638269696

</pre>

 

=={{header|APL}}==

If at all possible, I would sit down at a terminal <i>with</i> Babbage and invite him to experiment with the various functions used in the program.

N←⍳99736

⍝ The SQUARE OF omega is omega times omega:

SMALLESTWHERE←{1↑⍒⍵}

⍝ We can now ask the computer for the answer:

{{out}}

<pre>25264</pre>

 

 

AppleScript's number types are at their limits here, but we can just get to the first Babbage number, after 638 integer root tests on suffixed numbers:

 

 

-- babbage :: Int -> [Int]

on babbage(intTests)

script test

on toSquare(x)

end toSquare

script toRoot

on |λ|(x)

end |λ|

end script

end babbage

 

on run

-- Try 1000 candidates

--> "2.5264E+4 -> 6.38269696E+8"

 

 

 

 

-- enumFromTo :: Int -> Int -> [Int]

return lst

end enumFromTo

 

-- filter :: (a -> Bool) -> [a] -> [a]

end tell

end filter

 

-- hasIntRoot :: Int -> Bool

end hasIntRoot

 

end intercalate

 

-- map :: (a -> b) -> [a] -> [b]

on map(f, xs)

tell mReturn(f)

set lng to length of xs

end tell

end map

 

-- min :: Ord a => a -> a -> a

end if

end min

 

-- Lift 2nd class handler function into 1st class script wrapper

end if

end mReturn

 

-- unlines :: [String] -> String

on unlines(xs)

end unlines

 

-- zip :: [a] -> [b] -> [(a, b)]

end repeat

return lst

{{Out}}

<pre>2.5264E+4 -> 6.38269696E+8</pre>

 

=={{header|ARM Assembly}}==

{{works with|as|Raspberry Pi}}

 

/* ARM assembly Raspberry PI */

bx lr @ leave function

iMagicNumber: .int 0xCCCCCCCD

{{out}}

<pre>Result = 25264</pre>

 

=={{header|AutoHotkey}}==

; Give n an initial value

n = 519

; Display n as value

msgbox, %n%

{{out}}

<pre>25264</pre>

 

=={{header|AWK}}==

# 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.

exit(0)

} # end of program

<p>Output:</p>

<pre>

==={{header|Applesoft BASIC}}===

This is an implementation based on the alternative solution for the BBC BASIC. We know that 269696 is not a perfect square, so we can safely start with N=1269696 and add 1000000 each time N is not a perfect square. The ST function returns the remainder of the difference between N and the square of the integer part of the root (R). There are a couple of quirks in AppleSoft BASIC, the largest integer is 32767, but the largest number not displayed on scientific notation is 999999999, which explains the strange IF statement in line <code>170</code>.

100 :

110 REM BABBAGE PROBLEM

FOR VALUES SMALLER"; CHR$(13);

"THAN 999999999."

{{out}}

<pre>]RUN

==={{header|Commodore BASIC}}===

Based on the C language implementation

20 num = 100 : rem We can safely start at 100

30 s = num*num

100 print:print "The smallest number whose square ends in 269696 is:"

110 print num;"....";num;"squared = ";s

 

==={{header|BASIC256}}===

#This code is an implementation of Babbage Problem

number = 2

PRINT "The smallest number whose square ends in 269696 is: "; number

PRINT "It's square is "; number*number

 

==={{header|BBC BASIC}}===

Clarity has been preferred over all other considerations. The line <tt>LET n = n + 1</tt>, for instance, would more naturally be written <tt>n% += 1</tt>, using an integer variable and a less verbose assignment syntax; but this optimization did not seem to justify the additional explanations Professor Babbage would probably need to understand it.

 

REM We shall test positive integers from 1 upwards until we find one whose square ends in 269,696.

PRINT "The smallest number whose square ends in 269696 is" n

 

{{out}}

<pre>The smallest number whose square ends in 269696 is 25264

{{trans|PowerShell}}

The algorithm given in the alternative PowerShell implementation may be substantially more efficient, depending on how long <tt>SQR</tt> takes, and I think could well be more comprehensible to Babbage.

 

REM The machine will ignore them.

PRINT "The smallest number whose square ends in 269696 is" root

 

{{out}}

Identical to the first BBC BASIC version.

 

==={{header|IS-BASIC}}===

110 LET N=2

120 DO

140 LOOP UNTIL MOD(N*N,1000000)=269696

150 PRINT "The smallest number whose square ends in 269696 is:";N

Alternative method:

110 LET N=269696

120 DO

150 LOOP UNTIL R=INT(R)

160 PRINT "The smallest number whose square ends in 269696 is:";R

 

=={{header|Batch File}}==

:: This line is only required to increase the readability of the output by hiding the lines of code being executed

@echo off

echo %number% * %number% = %numbersquared%

pause>nul

{{out}}

<pre>

Befunge is not an easily readable language, but with a basic understanding of the syntax, I think an intelligent person should be able to follow the logic of the code below.

 

v

increment n n*n modulo 1000000 equal to 269696? v if false, loop to right

"V8" ascii values of 'V' and '8', i.e. 86 and 56

: duplicate the '8' (56): 86,56,56

 

{{out}}

 

=={{header|Bracmat}}==

(

500:?number {A child knows that 269696 is larger than 500*500,

)

)

 

{{out}}

 

=={{header|C}}==

// This code is the implementation of Babbage Problem

 

return 0 ;

}

 

{{out}}

<pre>The smallest number whose square ends in 269696 is 25264</pre>

 

 

{

class iterateNumbers

}

}

{{out}}

<pre>The smallest integer whose square ends in 269,696 is 25264

 

=={{header|C++}}==

 

int main( ) {

std::cout << "The square of " << current << " is " << (current * current) << " !\n" ;

return 0 ;

 

{{out}}

 

=={{header|Caché ObjectScript}}==

; start at the integer prior to the square root of 269,696 as it has to be at least that big

set i = ($piece($zsqr(269696),".",1,1) - 1) ; piece 1 of . gets the integer portion

}

 

{{out}}<pre>SAMPLES>do ^BABBAGE

 

=={{header|Clojure}}==

; square of the provided number leaves a remainder of 269,696 when divided

; by a million

; (We're exploiting Clojure's laziness here; (range) with no parameters returns

; an infinite series.)

{{out}}

<pre>25264</pre>

 

=={{header|COBOL}}==

* A line beginning with an asterisk is an explanatory note.

* The machine will disregard any such line.

* In this part of the program we reserve the storage space we shall

* be using for our variables, using a 'PICTURE' clause to specify

* 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.

* We know that 99,736 is a valid answer.

* Here we specify the calculations that the machine is to carry out.

* 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.

{{out}}

<pre>25264</pre>

 

=={{header|Common Lisp}}==

(defun babbage-test (n)

"A generic function for any ending of a number"

((= (mod (* i i) d) n) i) )))

 

{{out}}

I use [https://franz.com/downloads/clp/survey Allegro CL 10.1]

 

; Project : Babbage problem

 

(format t "~a" "Its square is: ")

(write (* n n))

Output:

<pre>

With some improvements of Common Lisp [https://lisp-lang.org/style-guide/ style]

 

(defpackage :babbage

(:use :common-lisp))

(format t "The smallest number whose square ends in ~D is: ~D~%" end num)

(format t "Its square is: ~D~%" square)

 

{{out}}

<pre>ABBAGE> (babbage 269696)

The smallest number whose square ends in 269696 is: 25264

 

=={{header|Component Pascal}}==

{{Works with|BlackBox Component Builder}}

MODULE BabbageProblem;

IMPORT StdLog;

 

END BabbageProblem.

<pre>Execute: ^Q BabbageProble.Do</pre>

{{out}}

25264

</pre>

 

=={{header|D}}==

// 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.

// display output

writefln("%d * %d = %d", k, k, k*k);

 

{{out}}

 

=={{header|Dafny}}==

// Helper function for mask: does the actual computation.

function method mask_(v:int,m:int):int

print smallest, "\n";

}

 

=={{header|Dart}}==

 

print('$x');

}

 

=={{header|Dyalect}}==

 

if i * i % 1000000 == 269696 {

print("\(i) is the smallest number that ends with 269696")

break

}

 

{{out}}

 

=={{header|EasyLang}}==

n += 1

.

 

=={{header|EDSAC order code}}==

This of course is the principle that Babbage used in his Difference Engine.

 

[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.

@&*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]

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

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]

[10] #1760F V2046F [-1000000]

[14] &F [line feed]

[15] @F [carriage return]

[16] K4096F [teleprinter null]

[Enter with acc = 0]

[17] T#@ [trial number n := 0]

RD [right shift]

T4#@ [(1st difference for n^2) := -64]

[Start of loop]

[22] TF [clear acc]

S8#@ [test for acc = 0 by subtracting 8]

E22@ [loop back if residue > 269696]

[Here with the solution]

TF [clear acc]

O16@ [print null, to flush printer buffer]

ZF [stop]

{{out}}

<pre>

=={{header|Elena}}==

{{trans|Smalltalk}}

import system'math;

var n := 1;

{

n += 1

console.printLine(n)

{{out}}

<pre>

 

=={{header|Elixir}}==

def problem(n) when rem(n*n,1000000)==269696, do: n

def problem(n), do: problem(n+2)

end

 

or

|> Enum.find(&rem(&1*&1, 1000000) == 269696)

 

{{out}}

 

=={{header|Erlang}}==

-module(solution1).

-export([main/0]).

main()->

babbage(4,4).

 

let mutable n=1

while(((n*n)%( 1000000 ))<> 269696) do

n<-n+1

printf"%i"n

 

Same as above, sans mutable state.

Seq.initInfinite id

|> Seq.skipWhile (fun n->(n*n % 1000000) <> 269696)

|> Seq.head |> printfn "%d"

 

=={{header|Factor}}==

! read and have no effect on the instructions carried out by the

! computer (aside from Factor's parser ignoring them).

! Putting the entire program together, it looks like this:

 

{{out}}

<pre>

=={{header|Forth}}==

Can a Forth program be made readable to a novice, without getting into what a stack is? We shall see.

 

: BABBAGE

( Now we ask the machine to carry out these instructions )

 

{{out}}

<pre>25264</pre>

Sincerely, <br>

John Backus - September 1956 <br>

IF(MODF(N*N,1000000)-269696)3,4,3

3 CONTINUE

5 FORMAT(I6)

STOP

{{out}}

<pre>25264</pre>

===Modern Fortran===

{{trans|F#}}

program babbage

implicit none

print*, n

end program babbage

 

=={{header|FreeBASIC}}==

' compile with: fbc -s console

 

Print : Print "hit any key to end program"

Sleep

{{out}}

<pre>The number = 25,264 and its square = 638,269,696</pre>

 

=={{header|Frink}}==

// https://rosettacode.org/wiki/Babbage_problem

 

// This prints i and i²

println[i + "² = " + i²]

}

i = i + 1

 

{{out}}

 

=={{header|FutureBasic}}==

 

 

for i = 1 to 1000000

next

{{out}}

<pre>The smallest number whose square ends in 269696 is 25264

=={{header|Fōrmulæ}}==

 

 

 

 

=={{header|Gambas}}==

'''[https://gambas-playground.proko.eu/?gist=08eafccbe3febb79ec62301ca84e3662 Click this link to run this code]'''

Dim iNum As Long

 

Print "The lowest number squared that ends in '269696' is " & Str(iNum)

 

Output:

<pre>

 

=={{header|Go}}==

 

import "fmt"

}

}

{{out}}

<pre>

 

=={{header|Groovy}}==

int n=104; ///starting point

while( (n**2)%1000000 != 269696 )

}

println n+"^2== "+n**2 ;

{{out}}

<pre>

=={{header|Haskell}}==

====head====

findBabbageNumber :: Integer

findBabbageNumber =

(++)

(show <$> ([id, (^ 2)] <*> [findBabbageNumber]))

{{out}}

<pre>25264 ^ 2 equals 638269696 !</pre>

Or, if we incline to the ''nullius in verba'' approach, are not yet convinced that there really are any such numbers below 100,000, and look uncertainly at '''head''' – a partial function which simply fails on empty lists, we could import the Safe module, and use the '''headMay''' alternative, which, more cautiously and experimentally, returns a Maybe value:

 

import Data.Maybe (maybe)

import Safe (headMay)

(intercalate " ^ 2 -> " .

fmap show . (<*>) [floor . sqrt . fromInteger, id] . pure)

{{Out}}

<pre>25264 ^ 2 -> 638269696</pre>

We can then harvest as many as we need from an infinite stream of babbages, Mr Babbage.

 

 

babbagePairs :: [[Integer]]

babbagePairs =

 

main :: IO ()

{{Out}}

<pre>25264 ^ 2 -> 638269696

599736 ^ 2 -> 359683269696</pre>

 

 

We can get to the solution almost immediately, after only a handful of tests, well within the reach of pencil and paper, if we discern that the root itself, to produce the 269692 suffix in its square, must have one of only four different final digit sequences: (0264, 5264, 4736, or 9736).

 

With a machine, this approach can industrialise the babbage harvest, yielding thousands of pairs in less than a second:

 

babbagePairs =

 

main :: IO ()

main =

 

=={{header|J}}==

So let's break the implementation into some named pieces and present enough detail that a mathematician can verify that the result is both consistent and reasonable:

 

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 <-

 

The smallest of these values is 25264.

==== Alternatively, inspired by the APL example that makes the sentence sound natural ====

 

NB. In the interactive environment.

NB. First here, Mr Babbage, we'll make the computer's words more meaningful to an english speaker.

25264

 

 

=={{header|Java}}==

 

public static void main(String[] args) {

System.out.println(n);

}

<pre>25264</pre>

 

=={{header|JavaScript}}==

====Iteration====

// just like these two.

//

// need to send it to the monitoring device (named console).

console.log(n)

====Functional composition====

 

 

{{works with|ES6}}

'use strict';

 

// MAIN ---

return main();

{{Out}}

<pre>25264^2 -> 638269696

=={{header|Julia}}==

 

function babbage(x::Integer)

end

return i

end

 

{{out}}

=={{header|Kotlin}}==

 

var number = 520L

var square = 520 * 520L

square = number * number

}

 

{{out}}

The smallest number is 25264 whose square is 638269696

</pre>

 

=={{header|Liberty BASIC}}==

Now Mr. Babbage -- May I call you Charlie? No. OK -- we'll first start with 'n' equal to zero, then multiply it by itself to square it. If the last six digits of the result are not 269696, we'll add one to 'n' then go back and square it again. On our modern computer it should only take a moment to find the answer...

[start]

if right$(str$(n*n),6)="269696" then

if n<100000 then n=n+1: goto [start]

print "Program complete."

Eureka! We found it! --

n = 25,264 n*n = 638,269,696

n = 99,736 n*n = 9,947,269,696

Program complete.

Now my question for you, Sir, is how did you know that the square of ANY number would end in 269696??

Oh, and by the way, 99,736 is an answer too.

 

=={{header|Limbo}}==

 

include "sys.m";

print("%d", current);

}

 

=={{header|Lua}}==

{{trans|D}}

k = math.floor(math.sqrt(269696))

 

end

 

 

=={{header|M2000 Interpreter}}==

n=Sqrt(269696)

For n=n to k {

}

Report format$("The smallest number whose square ends in {0} is {1}, Its square is {2}", T, n, n**2)

 

Solving up to his guess would show that there is indeed a smaller integer with that property.

{{out}}

<pre>{{x->25264},{x->99736}}</pre>

 

=={{header|MAXScript}}==

posInt = 1

while posInt < 1000000 do

Print "The smallest number whose square ends in 269696 is " + ((posInt) as string)

Print "Its square is " + (((pow posInt 2) as integer) as string)

{{out}}

Output to MAXScript Listener:

=={{header|Microsoft Small Basic}}==

{{trans|VBscript}}

' The quote (') means a comment

' The equals sign (=) means assign

TextWindow.WriteLine("Its square is " + (n*n) + ".")

 

{{out}}

<pre>

 

=={{header|MiniScript}}==

// by the computer. We use them to explain the code.

 

 

// The first such number we find is our answer.

 

{{out}}

 

=={{header|Modula-2}}==

FROM FormatString IMPORT FormatString;

FROM RealMath IMPORT sqrt;

 

ReadChar

 

=={{header|Nanoquery}}==

 

while not (n ^ 2 % 1000000) = 269696

end

 

 

{{out}}

=={{header|NetRexx}}==

{{trans|Groovy}}

options replace format comments java crossref symbols nobinary utf8

numeric digits 5000 -- set up numeric precision

 

return n -- end the function and return the result

{{out}}

<pre> 25,264² == 638,269,696</pre>

 

=={{header|NewLisp}}==

;;; Start by assigning n the integer square root of 269696

;;; minus 1 to be even

;;; Show the result and its square

(println n "^2 = " (* n n))

{{output}}

<pre>

 

=={{header|Nim}}==

var n : int = 0

while n*n mod 1_000_000 != 269_696:

inc(n)

echo n

 

{{out}}

 

=={{header|Objeck}}==

function : Main(args : String[]) ~ Nil {

cur := 0;

}

}

 

{{output}}

 

=={{header|OCaml}}==

let rec f a=

if (a*a) mod 1000000 != 269696

let a= f 1 in

Printf.printf "smallest positive integer whose square ends in the digits 269696 is %d\n" a

 

=={{header|Ol}}==

(print

(let loop ((i 2))

i

(loop (+ i 1)))))

{{out}}

<pre>25264</pre>

 

=={{header|PARI/GP}}==

k=1000000;

{for(n=1,99736,

return(n) \\ If so, return this number and STOP.

)

 

=={{header|Pascal}}==

(* Anything bracketed off like this is an explanatory comment. *)

var n : longint; (* The VARiable n can hold a 'long', ie large, INTeger. *)

(* 'n * n' means 'n times n'; 'mod' means 'modulo'. *)

write(n)

{{out}}

<pre>25264</pre>

 

=={{header|Perl}}==

use strict ;

use warnings ;

$current++ ;

}

 

{{out}}

We can omit anything odd, as any odd number squared is obviously always odd.<br>

Mr Babbage might need the whole "i is a variable" thing explained, and that "?i" prints the value of i, nowt else springs to mind.

{{out}}

<pre>

25264

</pre>

 

=={{header|PHP}}==

 

 

for (

);

 

 

{{out}}

<pre>25264 * 25264 = 638269696</pre>

 

=={{header|PicoLisp}}==

(T (= 269696 (% (* N N) 1000000)) N) ) # Stop if remainder is 269696

 

=={{header|PILOT}}==

Remark:A "compute" instruction gives a value to a variable.

Remark:We begin by making the variable n equal to 2.

Type:The smallest number whose square ends in 269696 is #n. Its square is #square.

Remark:The end.

 

=={{header|Plain English}}==

Start up.

Put 1 into a number.

Write "The answer is " then the number on the console.

Wait for the escape key.

{{out}}

<pre>

The answer is 25264

</pre>

 

=={{header|PowerShell}}==

###########################################################################################

#

 

$integer

{{Out}}

<pre>

{{works with|PowerShell|2}}

By looping through potential squares instead of potential square roots, we reduce the number of loops by a factor of 40.

$TestSquare = 269696

# Display the result and its square

$Root

{{out}}

<pre>25264

 

=={{header|Processing}}==

// will be ignored by the machine.

 

// println is short for 'print line'

 

{{out}}

<pre>25264</pre>

=={{header|Prolog}}==

Works with Swi-Prolog version 7+

 

babbage_(B, B, Sq) :-

babbage :-

once(babbage_(1, Num, Square)),

{{out}}

<pre>

lowest number is 25264 which squared becomes 638269696

true.

</pre>

 

=={{header|PureBasic}}==

Macro putresult(n)

If OpenConsole("Babbage_problem")

For n = 2 To q Step 2

If (n*n) % #DIV = #GOAL : putresult(n) : Break : EndIf

{{out}}

<pre>The smallest number whose square ends in 269696 is 25264</pre>

 

=={{header|Python}}==

# Lines that start by # are a comments:

# they will be ignored by the machine

 

# n**2 -> n squared

# != -> not equal to

 

print(n) # prints n

{{out}}

<pre>25264</pre>

 

 

Or, generating a non-finite stream of numbers which are the sum of 269696 and some integer multiple of one million, and also have an integer square root:

{{Works with|Python|3.7}}

 

from math import (floor, sqrt)

# MAIN ---

if __name__ == '__main__':

{{Out}}

<pre>Smallest positive integers whose squares end in the digits 269,696:

 

As a footnote on what Babbage might have managed with pencil and paper – applying the '''squaresWithSuffix(n)''' function to shorter suffixes (6, 96, 696 ...) enables us to explore the way in which the final digits of the integer root constrain and determine those of the perfect square. It quickly becomes apparent that Mr Babbage need only have considered roots ending in the digit sequences 264 or 736, a constraint which, had he deduced it with pencil and paper, would have allowed him to reach 25264 after testing the squares of only 24 other numbers.

 

=={{header|R}}==

babbage_function=function(){

n=0

}

babbage_function()[length(babbage_function())]

{{out}}

<pre>25264</pre>

 

=={{header|Racket}}==

;; This lets the racket engine know it is running racket

#lang racket

(display (square-ends-in-269696? first-number-that-when-squared-ends-in-269696))

(newline)

 

{{out}}

(formerly Perl 6)

 

This could certainly be written more concisely. Extra verbiage is included to make the process more clear.

for 1 .. Inf -> $integer {

# print the integer and square and exit if the square modulo 1000000 is equal to 269696

print "{$integer}² equals $square" and exit if $square mod 1000000 == 269696;

 

{{out}}

<pre>25264² equals 638269696</pre>

 

 

 

 

=={{header|Red}}==

number: 510 ;; starting number

;; repeat, until the last condition in the block is true

]

?? number

{{out}}

<pre>number: 25264</pre>

 

===examine the right-most six digits of square===

do j=2 by 2 until right(j * j, 6) == 269696 /*start J at two, increment by two. */

end /*◄── signifies the end of the DO loop.*/

/* [↑] * means multiplication. */

{{out|output}}

<pre>

 

===examine remainder after dividing by one million===

do j=2 by 2 /*start J at two, increment by two. */

if ((j * j) // 1000000) == 269696 then leave /*is square mod one million our target?*/

end /*◄── signifies the end of the DO loop.*/

/* [↑] // is division remainder.*/

{{out|output|text=&nbsp; is identical to the 1^st REXX version.}} <br><br>

 

===examine only numbers ending in 4 or 6===

/*─────────────────── we will only examine integers that are ending in four or six. */

do j=4 by 10 /*start J at four, increment by ten.*/

end /*◄── signifies the end of the DO loop.*/

/* [↑] * means multiplication. */

{{out|output|text=&nbsp; is identical to the 1^st REXX version.}} <br><br>

 

===start with smallest possible number===

* The solution must actually be larger than sqrt(269696)=519.585

*--------------------------------------------------------------------*/

End

Say "The smallest integer whose square ends in 269696 is:" z

{{out}}

<pre>The smallest integer whose square ends in 269696 is: 25264

 

=={{header|Ring}}==

n = 0

while pow(n,2) % 1000000 != 269696

see "The smallest number whose square ends in 269696 is : " + n + nl

see "Its square is : " + pow(n,2)

Output:

<pre>

The smallest number whose square ends in 269696 is : 25264

Its square is : 638269696

</pre>

 

=={{header|Ruby}}==

n = n + 2 until (n*n).modulo(1000000) == 269696

print n

 

=={{header|Run BASIC}}==

if n^2 MOD 1000000 = 269696 then exit for

next

PRINT "The smallest number whose square ends in 269696 is "; n

<pre>The smallest number whose square ends in 269696 is 25264

Its square is 638269696

=={{header|Rust}}==

=== Imperative version ===

let mut current = 0;

while (current * current) % 1_000_000 != 269_696 {

current

);

{{out}}

<pre>

 

=== Finding in infinite range ===

if let Some(n) = (1..).find(|x| x * x % 1_000_000 == 269_696) {

println!("The smallest number whose square ends in 269696 is {}", n)

}

 

Which outputs the same thing as above.

 

=={{header|Scala}}==

object BabbageProblem {

def main( args:Array[String] ): Unit = {

}

}

{{out}}

<pre>

or same solution with a functional implementation

 

import scala.annotation.tailrec

 

 

}

{{out}}

<pre>

=={{header|Scheme}}==

 

(define (digits n)

(string->list (number->string n)))

 

;; 25264

 

=={{header|Scilab}}==

{{trans|Pascal}}

flag=%F

while ~flag

end

end

{{out}}

<pre> 25264.</pre>

=={{header|Seed7}}==

 

 

const proc: main is func

end while;

writeln("The square of " <& current <& " is " <& current ** 2);

 

{{out}}

=={{header|SenseTalk}}==

 

(*

Answer Charles Babbage's question:

end repeat

 

 

Note that because SenseTalk sees things as an ordinary person does, there is no need to make a distinction between a number and its text representation.

 

=={{header|SequenceL}}==

babbage(current) :=

current when current * current mod 1000000 = 269696

else

 

{{out}}

 

=={{header|Shen}}==

N -> N where (= 269696 (shen.mod (* N N) 1000000)))

N -> (babbage (+ N 1))

 

{{out}}

<pre>25264</pre>

 

=={{header|Sidef}}==

while (n*n % 1000000 != 269696) {

n += 2

}

{{out}}

<pre>

 

=={{header|Simula}}==

INTEGER PROBE, SQUARE;

BOOLEAN DONE;

END;

 

{{out}}

<pre>

 

=={{header|Smalltalk}}==

| n |

n := 1.

[ n squared \\ 1000000 = 269696 ] whileFalse: [ n := n + 1 ].

{{out}}

<pre>25264</pre>

 

=={{header|Swift}}==

 

for i in 2...Int.max {

break

}

{{out}}

<pre>25264 is the smallest number that ends with 269696</pre>

=={{header|Tcl}}==

Hope Mr Babbage can understand this one-liner...

<pre>

25264 squared is 638269696

=== Scalable version ===

I have added some comments to the code, but left out a Tcl tutorial.

# The last k digits of a square x**2 are determined by the last k digits of

## the number x, and independent of all higher digits.

puts "(did $::didSqs squarings upto now)"

## You may want to try 08315917380318501319044 for solution 9999999156746824862

{{out}}

<pre> List of suffixes of length 1 has 2 elements:

In 1996 was manufactured the TI-83, a handheld graphing calculators with a basic language called TI-83 Basic.

The language is small and neat. For example to store 500 into a variable, it is done without twisting the meaning in mathematics of the equal sign (=).

Do not be attracted by brute force, let's do some basic maths:

<br>As

N must ends by 4 or 6 &rArr; N&ge;536

So, Lord Babbage here is your program:

While remainder(N*N,1000000)≠269696

i+8→N

End

And within a minute you have the answer:

{{out}}

<pre>

638269696

</pre>

 

{{works with|Z Shell}}

 

# has a decimal representation ending in the digits 269,696.

 

# To get here we must have found an integer whose square meets the

# condition; display that final result

{{Out}}

<pre>25264</pre>

are replaced by "expr".

 

 

# Babbage problem:

sort -n | # numbers in ascending order

head -n 1 # show only smallest

 

{{out}}

=={{header|UTFool}}==

 

···

http://rosettacode.org/wiki/Babbage_problem

if ("⸨number × number⸩").endsWith "269696"

System.exit number

 

=={{header|VAX Assembly}}==

36 35 34 33 32 31 00000008'010E0000' 0000 1 result: .ascid "123456" ;output buffer

0000 000E 2 retlen: .word 0 ;$fao_s bytes written

$ run bab

25264

 

=={{header|VBA}}==

Sub Baggage_Problem()

Dim i As Long

"Its square is : " & i * i

End Sub

<pre>The smallest positive integer whose square ends in the digits 269 696 is : 25264

Its square is : 638269696</pre>

 

=={{header|VBScript}}==

 

'Lines that begin with the apostrophe are comments. The machine ignores them.

 

'End of Program.

{{Out}}

<pre>The smallest positive integer whose square ends in 269696 is 25264.

Its square is 638269696.</pre>

 

=={{header|Visual Basic .NET}}==

{{trans|C#}}

 

Function Right6Digits(num As Long) As Long

End Sub

 

{{out}}

<pre>The smallest integer whose square ends in 269,696 is 25264

The square is 638269696</pre>

 

=={{header|Wren}}==

{{libheader|Wren-fmt}}

The answer must be an even number and it can't be less than the square root of 269,696.

So, if we start from that, keep on adding 2 and squaring it we'll eventually find the answer.

*/

 

var start = 269696.sqrt.ceil // get the next integer higher than (or equal to) the square root

start = (start/2).ceil * 2 // if it's odd, use the next even integer

break // break from the loop and end the program

}

 

{{out}}

=={{header|x86 Assembly}}==

'''AT&T syntax''' {{works with|gas}}

 

# At the very end, when we have a result and we need to print it, we shall use for the purpose a program called PRINTF, which forms part of a library of similar utility programs that are provided for us. The codes given here will be needed at that point to tell PRINTF that we are asking it to print a decimal integer (as opposed to, for instance, text):

ret

 

{{out}}

<pre>25264</pre>

 

=={{header|XLISP}}==

 

; For instance, (+ (+ 2 2) (- 7 5)) evaluates to 6.

; We supply our function with 1 as an initial value to test, and ask the computer to print the final result.

 

{{out}}

<pre>25264</pre>

=={{header|XPL0}}==

Some preliminary tests show that the number to be squared (N) must end with 4 or 6 to get N^2 ending with 6. Additional tests show N must end 236, 264, 736 or 764. This leaves only 100 tests to determine the final number, which could be done by hand.

[C:= 0;

for N:= sqrt(269696) to -1>>1 do \to infinity (2^31-1)

];

];

 

{{out}}

100

</pre>

 

=={{header|zkl}}==

// find the first integer that, when squared, its last six digits are the magic number.

// The last digits are found with modulo, represented here by the % symbol

{{out}}

<pre>