O'Halloran numbers: Difference between revisions
Add MATLAB/Octave implementation
(added RPL) |
(Add MATLAB/Octave implementation) |
||
| (18 intermediate revisions by 2 users not shown) | |||
Line 293:
[8, 12, 20, 36, 44, 60, 84, 116, 140, 156, 204, 260, 380, 420, 660, 924]
</pre>
=={{header|C#}}==
<syntaxhighlight lang="C#">
using System;
using System.Linq;
class OHalloranNumbers
{
static void Main(string[] args)
{
int maximumArea = 1000;
int halfMaximumArea = maximumArea / 2;
bool[] ohalloranNumbers = Enumerable.Repeat(true, halfMaximumArea).ToArray();
for (int length = 1; length < maximumArea; length++)
{
for (int width = 1; width < halfMaximumArea; width++)
{
for (int height = 1; height < halfMaximumArea; height++)
{
int halfArea = length * width + length * height + width * height;
if (halfArea < halfMaximumArea)
{
ohalloranNumbers[halfArea] = false;
}
}
}
}
Console.WriteLine("Values larger than 6 and less than 1,000 which cannot be the surface area of a cuboid:");
for (int i = 3; i < halfMaximumArea; i++)
{
if (ohalloranNumbers[i])
{
Console.Write(i * 2 + " ");
}
}
Console.WriteLine();
}
}
</syntaxhighlight>
{{out}}
<pre>
Values larger than 6 and less than 1,000 which cannot be the surface area of a cuboid:
8 12 20 36 44 60 84 116 140 156 204 260 380 420 660 924
</pre>
=={{header|C++}}==
Line 330 ⟶ 379:
<pre>
Values larger than 6 and less than 1_000 which cannot be the surface area of a cuboid:
8 12 20 36 44 60 84 116 140 156 204 260 380 420 660 924
</pre>
=={{header|Dart}}==
{{trans|Scala}}
<syntaxhighlight lang="Dart">
import "dart:io";
void main() {
const int maximumArea = 1000;
int halfMaximumArea = maximumArea ~/ 2;
List<bool> ohalloranNumbers = List<bool>.filled(halfMaximumArea, true);
for (int length = 1; length < maximumArea; length++) {
for (int width = 1; width < halfMaximumArea; width++) {
for (int height = 1; height < halfMaximumArea; height++) {
int halfArea = length * width + length * height + width * height;
if (halfArea < halfMaximumArea) {
ohalloranNumbers[halfArea] = false;
}
}
}
}
print("Values larger than 6 and less than 1,000 which cannot be the surface area of a cuboid:");
for (int i = 3; i < halfMaximumArea; i++) {
if (ohalloranNumbers[i]) {
stdout.write('${i * 2} ');
}
}
}
</syntaxhighlight>
{{out}}
<pre>
Values larger than 6 and less than 1,000 which cannot be the surface area of a cuboid:
8 12 20 36 44 60 84 116 140 156 204 260 380 420 660 924
</pre>
Line 414 ⟶ 499:
.
</syntaxhighlight>
=={{header|Fortran}}==
{{trans|Julia}}
<syntaxhighlight lang="Fortran">
program ohalloran_numbers
implicit none
integer, parameter :: max_area = 1000
integer :: half_max, i, j, k, area
logical, dimension(max_area) :: areas
half_max = max_area / 2
! Initialize areas with .TRUE.
areas = .TRUE.
do i = 1, max_area
do j = 1, half_max
if (i * j > half_max) exit
do k = 1, half_max
area = 2 * (i * j + i * k + j * k)
if (area > max_area) exit
areas(area) = .FALSE. ! Mark as not an O'Halloran number
end do
end do
end do
! Print the O'Halloran numbers
print *, "Even surface areas < NOT ", max_area, " achievable by any regular integer-valued cuboid:"
do i = 1, max_area
if (mod(i, 2) == 0 .AND. areas(i)) then
write(*,'(I4,1X)', advance='no') i
endif
end do
print *, "" ! To add a final newline after the list
end program ohalloran_numbers
</syntaxhighlight>
{{out}}
<pre>
Even surface areas < NOT 1000 achievable by any regular integer-valued cuboid:
2 4 8 12 20 36 44 60 84 116 140 156 204 260 380 420 660 924
</pre>
Line 634 ⟶ 760:
Even surface areas < 1000 NOT achievable by any regular integer-valued cuboid:
[2, 4, 8, 12, 20, 36, 44, 60, 84, 116, 140, 156, 204, 260, 380, 420, 660, 924]
</pre>
=={{header|Kotlin}}==
{{trans|Scala}}
<syntaxhighlight lang="Kotlin">
object OHalloranNumbers {
@JvmStatic
fun main(args: Array<String>) {
val maximumArea = 1_000
val halfMaximumArea = maximumArea / 2
var ohalloranNumbers = BooleanArray(halfMaximumArea) { true }
for (length in 1 until maximumArea) {
for (width in 1 until halfMaximumArea) {
for (height in 1 until halfMaximumArea) {
val halfArea = length * width + length * height + width * height
if (halfArea < halfMaximumArea) {
ohalloranNumbers[halfArea] = false
}
}
}
}
println("Values larger than 6 and less than 1,000 which cannot be the surface area of a cuboid:")
for (i in 3 until halfMaximumArea) {
if (ohalloranNumbers[i]) {
print("${i * 2} ")
}
}
println()
}
}
fun main() {
OHalloranNumbers.main(arrayOf())
}
</syntaxhighlight>
{{out}}
<pre>
Values larger than 6 and less than 1,000 which cannot be the surface area of a cuboid:
8 12 20 36 44 60 84 116 140 156 204 260 380 420 660 924
</pre>
=={{header|Lua}}==
<syntaxhighlight lang="Lua">
function calculateOHalloranNumbers(maximumArea)
local halfMaximumArea = maximumArea / 2
local ohalloranNumbers = {}
-- Initialize the ohalloranNumbers table with all true values
for i = 1, halfMaximumArea do
ohalloranNumbers[i] = true
end
-- Calculate surface areas of possible cuboids and exclude them
for length = 1, maximumArea - 1 do
for width = 1, halfMaximumArea - 1 do
for height = width, halfMaximumArea - 1 do
local halfArea = length * width + length * height + width * height
if halfArea < halfMaximumArea then
ohalloranNumbers[halfArea] = false
else
break
end
end
if length * width * 2 >= halfMaximumArea then
break
end
end
end
-- Print out the O'Halloran numbers
print("Values larger than 6 and less than " .. maximumArea .. " which cannot be the surface area of a cuboid:")
for i = 3, halfMaximumArea-1 do
if ohalloranNumbers[i] then
io.write((2 * (i)) .. " ")
end
end
print()
end
-- Call the function with the maximum area of 1000
calculateOHalloranNumbers(1000)
</syntaxhighlight>
{{out}}
<pre>
Values larger than 6 and less than 1000 which cannot be the surface area of a cuboid:
8 12 20 36 44 60 84 116 140 156 204 260 380 420 660 924
</pre>
=={{header|Mathematica}}/{{header|Wolfram Language}}==
<syntaxhighlight lang="Mathematica">
(* Rosetta code task: rosettacode.org/wiki/O%27Halloran_numbers *)
maxArea = 1000;
halfMax = 500;
areas = Table[True, {maxArea}];
areas[[1 ;; maxArea ;; 2]] = False;
For[i = 1, i <= maxArea, i++,
For[j = 1, j <= halfMax,
j++, If[i*j > halfMax, Break[]];
For[k = 1, k <= halfMax,
k++, area = 2 (i*j + i*k + j*k);
If[area > maxArea, Break[]];
areas[[area]] = False;
];
];
];
Print["Even surface areas < ", maxArea, " NOT achievable by any regular integer-valued cuboid:\n",
Select[Range[maxArea], areas[[#]] &]]
</syntaxhighlight>
{{out}}
<pre>
Even surface areas < 1000 NOT achievable by any regular integer-valued cuboid:
{2, 4, 8, 12, 20, 36, 44, 60, 84, 116, 140, 156, 204, 260, 380, 420, 660, 924}
</pre>
=={{header|MATLAB}}/{{header|Octave}}==
{{trans|Julia}}
<syntaxhighlight lang="MATLAB">
max_area = 1000;
half_max = max_area / 2;
areas = ones(1, max_area); % Initialize areas with 1's
for i = 1:max_area
for j = 1:half_max
if (i * j > half_max)
break;
endif
for k = 1:half_max
area = 2 * (i * j + i * k + j * k);
if (area > max_area)
break;
endif
areas(area) = 0; % Mark as not an O'Halloran number
endfor
endfor
endfor
% Print the O'Halloran numbers
printf("Even surface areas < NOT %d achievable by any regular integer-valued cuboid:\n", max_area);
for n = 1:max_area/2
if (areas(2*n))
printf("%d ", 2*n);
endif
endfor
printf("\n");
</syntaxhighlight>
{{out}}
<pre>
Even surface areas < NOT 1000 achievable by any regular integer-valued cuboid:
2 4 8 12 20 36 44 60 84 116 140 156 204 260 380 420 660 924
</pre>
Line 667 ⟶ 954:
8 12 20 36 44 60 84 116 140 156 204 260 380 420 660 924
</pre>
=={{header|OCaml}}==
<syntaxhighlight lang="OCaml">
let maximum_area = 1000;;
let half_maximum_area = maximum_area / 2;;
let ohalloran_numbers = Array.make half_maximum_area true;;
for length = 1 to maximum_area - 1 do
for width = 1 to half_maximum_area - 1 do
for height = 1 to half_maximum_area - 1 do
let half_area = length * width + length * height + width * height in
if half_area < half_maximum_area then
ohalloran_numbers.(half_area) <- false
done;
done;
done;;
Printf.printf "Values larger than 6 and less than 1,000 which cannot be the surface area of a cuboid:\n";
for i = 3 to half_maximum_area - 1 do
if ohalloran_numbers.(i) then
Printf.printf "%d " (i * 2)
done;
</syntaxhighlight>
{{out}}
<pre>
Values larger than 6 and less than 1,000 which cannot be the surface area of a cuboid:
8 12 20 36 44 60 84 116 140 156 204 260 380 420 660 924
</pre>
=={{header|PARI/GP}}==
{{trans|Julia}}
<syntaxhighlight lang="PARI/GP">
{
max_area = 1000;
half_max = max_area / 2;
areas = vector(max_area, i, 1); /* Initialize areas with 1's */
for (i = 1, max_area,
for (j = 1, half_max,
if (i * j > half_max, break);
for (k = 1, half_max,
area = 2 * (i * j + i * k + j * k);
if (area > max_area, break);
areas[area] = 0; /* Mark as not an O'Halloran number */
)
)
);
/* Print the O'Halloran numbers */
print("Even surface areas < NOT ", Str(max_area) , " achievable by any regular integer-valued cuboid:");
for (n = 2/2, max_area/2,
if (areas[2*n], print1(2*n, " "));
);
}
</syntaxhighlight>
{{out}}
<pre>
Even surface areas < NOT 1000 achievable by any regular integer-valued cuboid:
2 4 8 12 20 36 44 60 84 116 140 156 204 260 380 420 660 924
</pre>
=={{header|Perl}}==
Line 716 ⟶ 1,067:
Even surface areas < 1000 NOT achievable by any regular integer-valued cuboid:
8 12 20 36 44 60 84 116 140 156 204 260 380 420 660 924
</pre>
=={{header|PHP}}==
{{trans|Scala}}
<syntaxhighlight lang="PHP">
<?php
function main() {
$maximumArea = 1000;
$halfMaximumArea = $maximumArea / 2;
$ohalloranNumbers = array_fill(0, $halfMaximumArea, true);
for ($length = 1; $length < $maximumArea; $length++) {
for ($width = 1; $width < $halfMaximumArea; $width++) {
for ($height = 1; $height < $halfMaximumArea; $height++) {
$halfArea = $length * $width + $length * $height + $width * $height;
if ($halfArea < $halfMaximumArea) {
$ohalloranNumbers[$halfArea] = false;
}
}
}
}
echo "Values larger than 6 and less than $maximumArea which cannot be the surface area of a cuboid:\n";
for ($i = 3; $i < $halfMaximumArea; $i++) {
if ($ohalloranNumbers[$i]) {
echo ($i * 2) . " ";
}
}
echo "\n";
}
main();
?>
</syntaxhighlight>
{{out}}
<pre>
Values larger than 6 and less than 1000 which cannot be the surface area of a cuboid:
8 12 20 36 44 60 84 116 140 156 204 260 380 420 660 924
</pre>
Line 797 ⟶ 1,190:
8 12 20 36 44 60 84 116 140 156 204 260 380 420 660 924
</pre>
=={{header|R}}==
{{trans|Julia}}
<syntaxhighlight lang="R">
max_area <- 1000
half_max <- max_area / 2
areas <- rep(1, max_area) # Initialize areas with 1's
for (i in 1:max_area) {
for (j in 1:half_max) {
if (i * j > half_max) {
break
}
for (k in 1:half_max) {
area <- 2 * (i * j + i * k + j * k)
if (area > max_area) {
break
}
areas[area] <- 0 # Mark as not an O'Halloran number
}
}
}
# Print the O'Halloran numbers
cat("Even surface areas < NOT", max_area, "achievable by any regular integer-valued cuboid:\n")
for (n in 3:(max_area/2)) {
if (areas[2*n] == 1) {
cat(2*n, " ")
}
}
cat("\n") # To ensure the output ends with a newline
</syntaxhighlight>
{{out}}
<pre>
Even surface areas < NOT 1000 achievable by any regular integer-valued cuboid:
8 12 20 36 44 60 84 116 140 156 204 260 380 420 660 924
</pre>
=={{header|Racket}}==
{{trans|Scala}}
<syntaxhighlight lang="Racket">
#lang racket
(define (main)
(let ([maximum-area 1000]
[ohalloran-numbers (make-hash)])
;; Initialize the hash table
(for ([i (in-range (quotient maximum-area 2))])
(hash-set! ohalloran-numbers i #t))
;; Calculate cuboid surface areas and update the hash table
(for* ([length (in-range 1 maximum-area)]
[width (in-range 1 (quotient maximum-area 2))]
[height (in-range 1 (quotient maximum-area 2))])
(let* ([half-area (+ (* length width) (* length height) (* width height))])
(when (< half-area (quotient maximum-area 2))
(hash-set! ohalloran-numbers half-area #f))))
;; Print the results
(printf "Values larger than 6 and less than 1,000 which cannot be the surface area of a cuboid:\n")
(for ([i (in-range 3 (quotient maximum-area 2))])
(when (hash-ref ohalloran-numbers i)
(printf "~a " (* i 2))))
(printf "\n")))
(main)
</syntaxhighlight>
{{out}}
<pre>
Values larger than 6 and less than 1,000 which cannot be the surface area of a cuboid:
8 12 20 36 44 60 84 116 140 156 204 260 380 420 660 924
</pre>
=={{header|Raku}}==
Line 818 ⟶ 1,286:
<pre>Even integer surface areas NOT achievable by any regular, integer dimensioned cuboid:
8 12 20 36 44 60 84 116 140 156 204 260 380 420 660 924</pre>
=={{header|Ruby}}==
<syntaxhighlight lang="Ruby">
class OHalloranNumbers
def self.main
maximum_area = 1_000
half_maximum_area = maximum_area / 2
ohalloran_numbers = Array.new(half_maximum_area, true)
(1...maximum_area).each do |length|
(1...half_maximum_area).each do |width|
(1...half_maximum_area).each do |height|
half_area = length * width + length * height + width * height
ohalloran_numbers[half_area] = false if half_area < half_maximum_area
end
end
end
puts "Values larger than 6 and less than 1,000 which cannot be the surface area of a cuboid:"
(3...half_maximum_area).each do |i|
print "#{i * 2} " if ohalloran_numbers[i]
end
puts
end
end
OHalloranNumbers.main
</syntaxhighlight>
{{out}}
<pre>
Values larger than 6 and less than 1,000 which cannot be the surface area of a cuboid:
8 12 20 36 44 60 84 116 140 156 204 260 380 420 660 924
</pre>
=={{header|Rust}}==
{{trans|C++}}
<syntaxhighlight lang="Rust">
fn main() {
const MAXIMUM_AREA: u32 = 1_000;
const HALF_MAXIMUM_AREA: u32 = MAXIMUM_AREA / 2;
let mut ohalloran_numbers = vec![true; HALF_MAXIMUM_AREA as usize];
for length in 1..MAXIMUM_AREA {
for width in 1..HALF_MAXIMUM_AREA {
for height in 1..HALF_MAXIMUM_AREA {
let half_area = length * width + length * height + width * height;
if half_area < HALF_MAXIMUM_AREA {
ohalloran_numbers[half_area as usize] = false;
}
}
}
}
println!("Values larger than 6 and less than 1_000 which cannot be the surface area of a cuboid:");
for i in 3..HALF_MAXIMUM_AREA {
if ohalloran_numbers[i as usize] {
print!("{} ", i * 2);
}
}
println!();
}
</syntaxhighlight>
{{out}}
<pre>
Values larger than 6 and less than 1_000 which cannot be the surface area of a cuboid:
8 12 20 36 44 60 84 116 140 156 204 260 380 420 660 924
</pre>
=={{header|RPL}}==
Line 848 ⟶ 1,389:
1: { 8 12 20 36 44 60 84 116 140 156 204 260 380 420 660 924 }
</pre>
=={{header|Scala}}==
{{trans|Java}}
<syntaxhighlight lang="Scala">
object OHalloranNumbers {
def main(args: Array[String]): Unit = {
val maximumArea = 1_000
val halfMaximumArea = maximumArea / 2
var ohalloranNumbers = Array.fill[Boolean](halfMaximumArea)(true)
for {
length <- 1 until maximumArea
width <- 1 until halfMaximumArea
height <- 1 until halfMaximumArea
} {
val halfArea = length * width + length * height + width * height
if (halfArea < halfMaximumArea) {
ohalloranNumbers(halfArea) = false
}
}
println("Values larger than 6 and less than 1,000 which cannot be the surface area of a cuboid:")
for {
i <- 3 until halfMaximumArea
if ohalloranNumbers(i)
} {
print(i * 2 + " ")
}
println()
}
}
</syntaxhighlight>
{{out}}
<pre>
Values larger than 6 and less than 1,000 which cannot be the surface area of a cuboid:
8 12 20 36 44 60 84 116 140 156 204 260 380 420 660 924
</pre>
=={{header|Swift}}==
{{trans|Scala}}
<syntaxhighlight lang="Swift">
import Foundation
func main() {
let maximumArea = 1_000
let halfMaximumArea = maximumArea / 2
var ohalloranNumbers = Array(repeating: true, count: halfMaximumArea)
for length in 1..<maximumArea {
for width in 1..<halfMaximumArea {
for height in 1..<halfMaximumArea {
let halfArea = length * width + length * height + width * height
if halfArea < halfMaximumArea {
ohalloranNumbers[halfArea] = false
}
}
}
}
print("Values larger than 6 and less than 1,000 which cannot be the surface area of a cuboid:")
for i in 3..<halfMaximumArea where ohalloranNumbers[i] {
print(i * 2, terminator: " ")
}
print()
}
// Running the main function
main()
</syntaxhighlight>
{{out}}
<pre>
Values larger than 6 and less than 1,000 which cannot be the surface area of a cuboid:
8 12 20 36 44 60 84 116 140 156 204 260 380 420 660 924
</pre>
=={{header|Tcl}}==
<syntaxhighlight lang="Tcl">
proc calculateOHalloranNumbers { maximumArea } {
set halfMaximumArea [expr {$maximumArea / 2}]
set ohalloranNumbers [list]
# Initialize the ohalloranNumbers list with all true values
for {set i 0} {$i < $halfMaximumArea} {incr i} {
lappend ohalloranNumbers true
}
# Calculate surface areas of possible cuboids and exclude them
for {set length 1} {$length < $maximumArea} {incr length} {
for {set width 1} {$width < $halfMaximumArea} {incr width} {
for {set height $width} {$height < $halfMaximumArea} {incr height} {
set halfArea [expr {$length * $width + $length * $height + $width * $height}]
if {$halfArea < $halfMaximumArea} {
lset ohalloranNumbers $halfArea false
} else {
break
}
}
if { $length * $width * 2 >= $halfMaximumArea } {
break
}
}
}
# Print out the O'Halloran numbers
puts "Values larger than 6 and less than $maximumArea which cannot be the surface area of a cuboid:"
for {set i 3} {$i < $halfMaximumArea} {incr i} {
if {[lindex $ohalloranNumbers $i]} {
puts -nonewline "[expr {2 * $i}] "
}
}
puts ""
}
# Call the procedure with the maximum area of 1000
calculateOHalloranNumbers 1000
</syntaxhighlight>
{{out}}
<pre>
Values larger than 6 and less than 1000 which cannot be the surface area of a cuboid:
8 12 20 36 44 60 84 116 140 156 204 260 380 420 660 924
</pre>
=={{header|Wren}}==
<syntaxhighlight lang="
var found = []
Line 864 ⟶ 1,531:
var allEven = (6..998).where { |i| i%2 == 0 }.toList
System.print("All known O'Halloran numbers:")
System.print(Lst.except(allEven, found))</syntaxhighlight>
{{out}}
| |||