Programming & Software Q&A | CollectiveSolver - Recent questions and answers

Answered: How to remove extra whitespace from a string in Python

Fri, 07 Aug 2026 16:59:57 +0000

def remove_extra_whitespace(text: str) -> str:
    """
    Removes leading/trailing whitespace and collapses multiple
    consecutive whitespace characters into a single space.

    Python's split() without arguments:
    - Splits on any run of whitespace (spaces, tabs, newlines)
    - Automatically trims leading/trailing whitespace
    - Produces a list of clean words
    """
    words = text.split()   # Efficient O(N) whitespace normalization
    return " ".join(words) # Reassemble with single spaces


def main() -> None:
    # Input string containing arbitrary whitespace, tabs, and padding
    s = "   This   is   a   test   string   with         extra   spaces.   "

    # Clean the string using standard string methods
    cleaned_string = remove_extra_whitespace(s)

    print(cleaned_string)


if __name__ == "__main__":
    main()


"""
run:

This is a test string with extra spaces.

"""

Answered: How to remove extra whitespace from a string in PHP

Fri, 07 Aug 2026 14:36:54 +0000

/**
 * Normalizes a string by trimming leading and trailing whitespace
 * and collapsing multiple consecutive spaces into a single space.
 *
 * @param string $input
 * @return string
 */
function removeExtraWhitespace(string $input): string
{
    // Step 1: Use regular expression \s+ to match one or more contiguous whitespace characters
    // (spaces, tabs, newlines) and replace each group with a single space.
    $collapsed = preg_replace('/\s+/', ' ', $input);

    // Step 2: Strip any leading or trailing whitespace left at the boundaries of the string.
    return trim($collapsed);
}

// Input string containing variable padding and extra internal spaces
$s = "   This   is   a   test   string   with         extra   spaces.   ";

// Clean and normalize the string
$cleanedString = removeExtraWhitespace($s);

echo $cleanedString . PHP_EOL;


/*
run:

This is a test string with extra spaces.

*/

Answered: How to remove extra whitespace from a string in C#

Fri, 07 Aug 2026 14:34:04 +0000

using System;

class Program
{
    /// <summary>
    /// Removes leading and trailing whitespace and collapses multiple 
    /// consecutive whitespace characters into a single space.
    /// </summary>
    /// <param name="input">The string to clean.</param>
    /// <returns>A normalized string with single spaces between words.</returns>
    static string RemoveExtraWhitespace(string input)
    {
        if (string.IsNullOrWhiteSpace(input)) {
            return string.Empty;
        }

        // Split the string by any whitespace characters, automatically removing 
        // empty entries created by consecutive spaces or surrounding padding.
        string[] words = input.Split(
            (char[])null!, 
            StringSplitOptions.RemoveEmptyEntries
        );

        // Join the individual words back together separated by a single space.
        return string.Join(" ", words);
    }

    static void Main()
    {
        // Input string containing arbitrary whitespace, tabs, and padding
        string s = "   This   is   a   test   string   with         extra   spaces.   ";

        // Clean the string using standard string methods
        string cleanedString = RemoveExtraWhitespace(s);

        Console.WriteLine(cleanedString);
    }
}


/*
run:

This is a test string with extra spaces.

*/

Answered: How to remove extra whitespace from a string in VB.NET

Fri, 07 Aug 2026 14:32:04 +0000

Imports System

Module Program

    ''' <summary>
    ''' Removes leading and trailing whitespace and collapses multiple 
    ''' consecutive whitespace characters into a single space.
    ''' </summary>
    ''' <param name="input">The original string containing extra spaces.</param>
    ''' <returns>A normalized string with single spaces between words.</returns>
    Function RemoveExtraWhitespace(ByVal input As String) As String
        If String.IsNullOrWhiteSpace(input) Then
            Return String.Empty
        End If

        ' Split the string on whitespace characters, automatically stripping out empty entries
        ' created by consecutive spaces or leading/trailing padding.
        Dim words() As String = input.Split(
            CType(Nothing, Char()), 
            StringSplitOptions.RemoveEmptyEntries
        )

        ' Rejoin the extracted words using a single space separator.
        Return String.Join(" ", words)
    End Function

    Sub Main()
        ' Input string containing arbitrary whitespace, tabs, and padding
        Dim s As String = "   This   is   a   test   string   with         extra   spaces.   "

        ' Clean the string using standard framework methods
        Dim cleanedString As String = RemoveExtraWhitespace(s)

        Console.WriteLine(cleanedString)
    End Sub

End Module


' run:
'
' This is a test string with extra spaces.
'

Answered: How to remove extra whitespace from a string in Java

Fri, 07 Aug 2026 14:29:03 +0000

import java.util.Objects;

public class Main {

    /**
     * Removes leading and trailing whitespace and collapses multiple 
     * consecutive whitespace characters into a single space.
     *
     * @param input The original string containing extra spaces.
     * @return A normalized string with single space separation.
     */
    public static String removeExtraWhitespace(String input) {
        if (input == null || input.isBlank()) {
            return "";
        }

        // Step 1: strip() removes leading and trailing whitespace (Unicode-aware).
        // Step 2: replaceAll("\\s+", " ") matches any sequence of 1 or more 
        // whitespace characters and collapses them down to a single space.
        return input.strip().replaceAll("\\s+", " ");
    }

    public static void main(String[] args) {
        // Input string containing arbitrary whitespace, tabs, and padding
        String s = "   This   is   a   test   string   with         extra   spaces.   ";

        // Clean the string using standard String class methods
        String cleanedString = removeExtraWhitespace(s);

        System.out.println(cleanedString);
    }
}


/*
run:

This is a test string with extra spaces.

*/

Answered: How to remove extra whitespace from a string in Pascal

Fri, 07 Aug 2026 14:25:13 +0000

program NormalizeWhitespace;

{$mode objfpc}{$H+}

uses
  SysUtils; // CharInSet

{ ------------------------------------------------------------
  NormalizeWhitespace
  ------------------------------------------------------------
  Removes extra whitespace from a string:

  - Trim leading whitespace
  - Trim trailing whitespace
  - Collapse multiple internal whitespace into a single space

  The algorithm performs a single linear scan and writes into
  a result string. This avoids repeated allocations and keeps
  the logic simple and efficient.
  ------------------------------------------------------------ }
function NormalizeWhitespace(const S: string): string;
var
  i, j: Integer;
  InWS, Started: Boolean;
  Ch: Char;
begin
  SetLength(Result, Length(S));  { Preallocate for efficiency }
  j := 0;
  InWS := False;
  Started := False;

  for i := 1 to Length(S) do
  begin
    Ch := S[i];

    if CharInSet(Ch, [' ', #9, #10, #13]) then
    begin
      { Skip leading whitespace }
      if not Started then
        Continue;

      { Skip repeated whitespace }
      if InWS then
        Continue;

      { First whitespace after a word → write a single space }
      Inc(j);
      Result[j] := ' ';
      InWS := True;
    end
    else
    begin
      { Non-whitespace character }
      Inc(j);
      Result[j] := Ch;
      InWS := False;
      Started := True;
    end;
  end;

  { Remove trailing space if present }
  if (j > 0) and (Result[j] = ' ') then
    Dec(j);

  SetLength(Result, j);
end;

{ ------------------------------------------------------------
  Main program
  ------------------------------------------------------------ }
var
  S, Cleaned: string;
begin
  S := '   This   is   a   test   string   with         extra   spaces.   ';

  Cleaned := NormalizeWhitespace(S);

  WriteLn('Original: [', S, ']');
  WriteLn('Cleaned:  [', Cleaned, ']');
end.



(*
run:

Original: [   This   is   a   test   string   with         extra   spaces.   ]
Cleaned:  [This is a test string with extra spaces.]

*)

Answered: How to remove extra whitespace from a string in C

Fri, 07 Aug 2026 09:55:46 +0000

#include <stdio.h>
#include <ctype.h>
#include <string.h>

/* ------------------------------------------------------------
   normalize_whitespace
   ------------------------------------------------------------
   Removes extra whitespace from a string:

   - Trim leading whitespace
   - Trim trailing whitespace
   - Collapse multiple internal whitespace into a single space

   The algorithm performs a single linear scan and writes into
   an output buffer provided by the caller.
   ------------------------------------------------------------ */
void normalize_whitespace(const char *input, char *output) {

    int in_ws = 0;      /* Tracks whether we are inside a whitespace run */
    int started = 0;    /* Tracks whether we've copied the first non-space */
    size_t j = 0;       /* Write index for output */

    for (size_t i = 0; input[i] != '\0'; i++) {

        if (isspace((unsigned char)input[i])) {

            /* Skip leading whitespace */
            if (!started) {
                continue;
            }

            /* If already in a whitespace run, skip extra whitespace */
            if (in_ws) {
                continue;
            }

            /* First whitespace after a word → write a single space */
            output[j++] = ' ';
            in_ws = 1;

        } else {
            /* Non-whitespace character */
            output[j++] = input[i];
            in_ws = 0;
            started = 1;
        }
    }

    /* Remove trailing space if present */
    if (j > 0 && output[j - 1] == ' ') {
        j--;
    }

    output[j] = '\0';
}

int main(void) {

    const char *s = "   This   is   a   test   string   with         extra   spaces.   ";
    char cleaned[256] = "";  /* Output buffer */

    normalize_whitespace(s, cleaned);

    printf("Original: [%s]\n", s);
    printf("Cleaned:  [%s]\n", cleaned);

    return 0;
}



/*
run:

Original: [   This   is   a   test   string   with         extra   spaces.   ]
Cleaned:  [This is a test string with extra spaces.]

*/

Answered: How to remove extra whitespace from a string in C++

Fri, 07 Aug 2026 09:42:16 +0000

#include <iostream>
#include <string>
#include <algorithm>

// Function to normalize whitespace: collapses consecutive spaces and trims edges
std::string removeExtraWhitespace(std::string str) {
    // Step 1: Normalize all whitespace characters (tabs, newlines, etc.) to standard spaces
    std::transform(str.begin(), str.end(), str.begin(), [](unsigned char ch) {
        return std::isspace(ch) ? ' ' : ch;
    });

    // Step 2: Collapse consecutive spaces into a single space in-place using std::unique
    // std::unique moves duplicate adjacent elements to the end and returns an iterator 
    // to the new boundary
    auto new_end = std::unique(str.begin(), str.end(), [](char lhs, char rhs) {
        return lhs == ' ' && rhs == ' ';
    });

    // Erase the leftover duplicate elements beyond the new boundary
    str.erase(new_end, str.end());

    // Step 3: Trim leading space if present
    if (!str.empty() && str.front() == ' ') {
        str.erase(str.begin());
    }

    // Step 4: Trim trailing space if present
    if (!str.empty() && str.back() == ' ') {
        str.pop_back();
    }

    return str;
}

int main() {
    std::string s = "   This   is   a   test   string   with         extra   spaces.   ";

    // Clean the string
    std::string cleaned = removeExtraWhitespace(s);

    std::cout << cleaned << std::endl;
}


/*
run:

This is a test string with extra spaces.

*/

Answered: How to calculate the distance between two latitude-longitude points in Swift

Fri, 07 Aug 2026 08:50:23 +0000

import Foundation

// ------------------------------------------------------------
// Convert degrees to radians
// ------------------------------------------------------------
func degToRad(_ deg: Double) -> Double {
    return deg * Double.pi / 180.0
}

// ------------------------------------------------------------
// Compute the great-circle distance between two points on Earth
// using the Haversine formula.
// lat1, lon1, lat2, lon2 are in degrees.
// The result is returned in kilometers.
// ------------------------------------------------------------
func haversine(lat1: Double, lon1: Double,
               lat2: Double, lon2: Double) -> Double {

    // Earth's mean radius in kilometers
    let R: Double = 6371.0

    // Convert all angles to radians
    let rlat1 = degToRad(lat1)
    let rlon1 = degToRad(lon1)
    let rlat2 = degToRad(lat2)
    let rlon2 = degToRad(lon2)

    // Differences
    let dlat = rlat2 - rlat1
    let dlon = rlon2 - rlon1

    // Haversine formula
    // a is the Haversine of the central angle between the two points.
    let a =
        pow(sin(dlat / 2), 2) +
        cos(rlat1) * cos(rlat2) *
        pow(sin(dlon / 2), 2)

    // Central angle
    // c is the central angle between the two points on the Earth’s surface.
    let c = 2 * asin(sqrt(a))

    // Final distance
    return R * c
}

// ------------------------------------------------------------
// Main 
// ------------------------------------------------------------

// Example coordinates:
// Austin, Texas
let lat1: Double = 30.2672
let lon1: Double = -97.7431

// Houston, Texas
let lat2: Double = 29.7604
let lon2: Double = -95.3698

let distanceKm: Double = haversine(lat1: lat1, lon1: lon1,
                                   lat2: lat2, lon2: lon2)

// Convert kilometers to miles
let distanceMiles: Double = distanceKm * 0.621371

print(String(format: "Distance: %.3f km", distanceKm))
print(String(format: "Distance: %.3f miles", distanceMiles))



/*
run:

Distance: 235.352 km
Distance: 146.241 miles

*/

Answered: How to calculate the distance between two latitude-longitude points in Kotlin

Fri, 07 Aug 2026 08:47:09 +0000

import kotlin.math.*

// ------------------------------------------------------------
// Convert degrees to radians
// ------------------------------------------------------------
fun degToRad(deg: Double): Double {
    return deg * PI / 180.0
}

// ------------------------------------------------------------
// Compute the great-circle distance between two points on Earth
// using the Haversine formula.
// lat1, lon1, lat2, lon2 are in degrees.
// The result is returned in kilometers.
// ------------------------------------------------------------
fun haversine(lat1: Double, lon1: Double,
              lat2: Double, lon2: Double): Double {

    // Earth's mean radius in kilometers
    val R: Double = 6371.0

    // Convert all angles to radians
    val rlat1: Double = degToRad(lat1)
    val rlon1: Double = degToRad(lon1)
    val rlat2: Double = degToRad(lat2)
    val rlon2: Double = degToRad(lon2)

    // Differences
    val dlat: Double = rlat2 - rlat1
    val dlon: Double = rlon2 - rlon1

    // Haversine formula
    // a is the Haversine of the central angle between the two points.
    val a: Double =
        sin(dlat / 2).pow(2) +
        cos(rlat1) * cos(rlat2) *
        sin(dlon / 2).pow(2)

    // Central angle
    // c is the central angle between the two points on the Earth’s surface.
    val c: Double = 2 * asin(sqrt(a))

    // Final distance
    return R * c
}

fun main() {

    // Example coordinates:
    // Austin, Texas
    val lat1: Double = 30.2672
    val lon1: Double = -97.7431

    // Houston, Texas
    val lat2: Double = 29.7604
    val lon2: Double = -95.3698

    val distanceKm: Double = haversine(lat1, lon1, lat2, lon2)

    // Convert kilometers to miles
    val distanceMiles: Double = distanceKm * 0.621371

    println("Distance: %.3f km".format(distanceKm))
    println("Distance: %.3f miles".format(distanceMiles))
}


/*
run:

Distance: 235.352 km
Distance: 146.241 miles

*/

Answered: How to calculate the distance between two latitude-longitude points in Scala

Fri, 07 Aug 2026 08:38:52 +0000

object HaversineDistance {

  // ------------------------------------------------------------
  // Convert degrees to radians
  // ------------------------------------------------------------
  def degToRad(deg: Double): Double =
    deg * math.Pi / 180.0

  // ------------------------------------------------------------
  // Compute the great-circle distance between two points on Earth
  // using the Haversine formula.
  // lat1, lon1, lat2, lon2 are in degrees.
  // The result is returned in kilometers.
  // ------------------------------------------------------------
  def haversine(lat1: Double, lon1: Double,
                lat2: Double, lon2: Double): Double = {

    // Earth's mean radius in kilometers
    val R: Double = 6371.0

    // Convert all angles to radians
    val rlat1 = degToRad(lat1)
    val rlon1 = degToRad(lon1)
    val rlat2 = degToRad(lat2)
    val rlon2 = degToRad(lon2)

    // Differences
    val dlat = rlat2 - rlat1
    val dlon = rlon2 - rlon1

    // Haversine formula
    // a is the Haversine of the central angle between the two points.
    val a =
      math.sin(dlat / 2) * math.sin(dlat / 2) +
      math.cos(rlat1) * math.cos(rlat2) *
      math.sin(dlon / 2) * math.sin(dlon / 2)

    // Central angle
    // c is the central angle between the two points on the Earth’s surface.
    val c = 2 * math.asin(math.sqrt(a))

    // Final distance
    R * c
  }

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

    // Example coordinates:
    // Austin, Texas
    val lat1: Double = 30.2672
    val lon1: Double = -97.7431

    // Houston, Texas
    val lat2: Double = 29.7604
    val lon2: Double = -95.3698

    val distanceKm: Double = haversine(lat1, lon1, lat2, lon2)

    // Convert kilometers to miles
    val distanceMiles: Double = distanceKm * 0.621371

    println(f"Distance: $distanceKm%.3f km")
    println(f"Distance: $distanceMiles%.3f miles")
  }
}


/*
run:

Distance: 235.352 km
Distance: 146.241 miles

*/

Answered: How to calculate the distance between two latitude-longitude points in Ruby

Fri, 07 Aug 2026 08:36:08 +0000

# ------------------------------------------------------------
# Convert degrees to radians
# ------------------------------------------------------------
def deg_to_rad(deg)
  deg * Math::PI / 180.0
end

# ------------------------------------------------------------
# Compute the great-circle distance between two points on Earth
# using the Haversine formula.
# lat1, lon1, lat2, lon2 are in degrees.
# The result is returned in kilometers.
# ------------------------------------------------------------
def haversine(lat1, lon1, lat2, lon2)

  # Earth's mean radius in kilometers
  r = 6371.0

  # Convert all angles to radians
  rlat1 = deg_to_rad(lat1)
  rlon1 = deg_to_rad(lon1)
  rlat2 = deg_to_rad(lat2)
  rlon2 = deg_to_rad(lon2)

  # Differences
  dlat = rlat2 - rlat1
  dlon = rlon2 - rlon1

  # Haversine formula
  # a is the Haversine of the central angle between the two points.
  a =
    Math.sin(dlat / 2)**2 +
    Math.cos(rlat1) * Math.cos(rlat2) *
    Math.sin(dlon / 2)**2

  # Central angle
  # c is the central angle between the two points on the Earth’s surface.
  c = 2 * Math.asin(Math.sqrt(a))

  # Final distance
  r * c
end

# ------------------------------------------------------------
# Main 
# ------------------------------------------------------------

# Example coordinates:
# Austin, Texas
lat1 = 30.2672
lon1 = -97.7431

# Houston, Texas
lat2 = 29.7604
lon2 = -95.3698

distance_km = haversine(lat1, lon1, lat2, lon2)

# Convert kilometers to miles
distance_miles = distance_km * 0.621371

puts "Distance: #{format('%.3f', distance_km)} km"
puts "Distance: #{format('%.3f', distance_miles)} miles"



=begin
run:

Distance: 235.352 km
Distance: 146.241 miles

=end

Answered: How to calculate the distance between two latitude-longitude points in Rust

Fri, 07 Aug 2026 08:33:16 +0000

use std::f64::consts::PI;

// ------------------------------------------------------------
// Convert degrees to radians
// ------------------------------------------------------------
fn deg_to_rad(deg: f64) -> f64 {
    deg * PI / 180.0
}

// ------------------------------------------------------------
// Compute the great-circle distance between two points on Earth
// using the Haversine formula.
// lat1, lon1, lat2, lon2 are in degrees.
// The result is returned in kilometers.
// ------------------------------------------------------------
fn haversine(lat1: f64, lon1: f64, lat2: f64, lon2: f64) -> f64 {

    // Earth's mean radius in kilometers
    const R: f64 = 6371.0;

    // Convert all angles to radians
    let rlat1 = deg_to_rad(lat1);
    let rlon1 = deg_to_rad(lon1);
    let rlat2 = deg_to_rad(lat2);
    let rlon2 = deg_to_rad(lon2);

    // Differences
    let dlat = rlat2 - rlat1;
    let dlon = rlon2 - rlon1;

    // Haversine formula
    // a is the Haversine of the central angle between the two points.
    let a =
        (f64::sin(dlat / 2.0)).powi(2) +
        f64::cos(rlat1) * f64::cos(rlat2) *
        (f64::sin(dlon / 2.0)).powi(2);

    // Central angle
    // c is the central angle between the two points on the Earth’s surface.
    let c = 2.0 * f64::asin(f64::sqrt(a));

    // Final distance
    R * c
}

fn main() {

    // Example coordinates:
    // Austin, Texas
    let lat1: f64 = 30.2672;
    let lon1: f64 = -97.7431;

    // Houston, Texas
    let lat2: f64 = 29.7604;
    let lon2: f64 = -95.3698;

    let distance_km: f64 = haversine(lat1, lon1, lat2, lon2);

    // Convert kilometers to miles
    let distance_miles: f64 = distance_km * 0.621371;

    println!("Distance: {:.3} km", distance_km);
    println!("Distance: {:.3} miles", distance_miles);
}



/*
run:

Distance: 235.352 km
Distance: 146.241 miles

*/

Answered: How to calculate the distance between two latitude-longitude points in Go

Fri, 07 Aug 2026 08:30:17 +0000

package main

import (
    "fmt"
    "math"
)

// ------------------------------------------------------------
// Convert degrees to radians
// ------------------------------------------------------------
func degToRad(deg float64) float64 {
    return deg * math.Pi / 180.0
}

// ------------------------------------------------------------
// Compute the great-circle distance between two points on Earth
// using the Haversine formula.
// lat1, lon1, lat2, lon2 are in degrees.
// The result is returned in kilometers.
// ------------------------------------------------------------
func haversine(lat1, lon1, lat2, lon2 float64) float64 {

    // Earth's mean radius in kilometers
    const R float64 = 6371.0

    // Convert all angles to radians
    rlat1 := degToRad(lat1)
    rlon1 := degToRad(lon1)
    rlat2 := degToRad(lat2)
    rlon2 := degToRad(lon2)

    // Differences
    dlat := rlat2 - rlat1
    dlon := rlon2 - rlon1

    // Haversine formula
    // a is the Haversine of the central angle between the two points.
    a := math.Sin(dlat/2)*math.Sin(dlat/2) +
        math.Cos(rlat1)*math.Cos(rlat2)*math.Sin(dlon/2)*math.Sin(dlon/2)

    // Central angle
    // c is the central angle between the two points on the Earth’s surface.
    c := 2 * math.Asin(math.Sqrt(a))

    // Final distance
    return R * c
}

func main() {

    // Example coordinates:
    // Austin, Texas
    lat1 := 30.2672
    lon1 := -97.7431

    // Houston, Texas
    lat2 := 29.7604
    lon2 := -95.3698

    distanceKm := haversine(lat1, lon1, lat2, lon2)

    // Convert kilometers to miles
    distanceMiles := distanceKm * 0.621371

    fmt.Printf("Distance: %.3f km\n", distanceKm)
    fmt.Printf("Distance: %.3f miles\n", distanceMiles)
}



/*
run:

Distance: 235.352 km
Distance: 146.241 miles

*/

Answered: How to calculate the distance between two latitude-longitude points in TypeScript

Fri, 07 Aug 2026 08:27:15 +0000

// ------------------------------------------------------------
// Convert degrees to radians
// ------------------------------------------------------------
function degToRad(deg: number): number {
    return deg * Math.PI / 180.0;
}

// ------------------------------------------------------------
// Compute the great-circle distance between two points on Earth
// using the Haversine formula.
// lat1, lon1, lat2, lon2 are in degrees.
// The result is returned in kilometers.
// ------------------------------------------------------------
function haversine(lat1: number, lon1: number,
                   lat2: number, lon2: number): number {

    // Earth's mean radius in kilometers
    const R: number = 6371.0;

    // Convert all angles to radians
    const rlat1: number = degToRad(lat1);
    const rlon1: number = degToRad(lon1);
    const rlat2: number = degToRad(lat2);
    const rlon2: number = degToRad(lon2);

    // Differences
    const dlat: number = rlat2 - rlat1;
    const dlon: number = rlon2 - rlon1;

    // Haversine formula
    //  a is the Haversine of the central angle between the two points.
    const a: number =
        Math.sin(dlat / 2) ** 2 +
        Math.cos(rlat1) * Math.cos(rlat2) *
        Math.sin(dlon / 2) ** 2;

    // Central angle
    // c is the central angle between the two points on the Earth’s surface.
    const c: number = 2 * Math.asin(Math.sqrt(a));

    // Final distance
    return R * c;
}

// ------------------------------------------------------------
// Main 
// ------------------------------------------------------------

// Example coordinates:
// Austin, Texas
const lat1: number = 30.2672;
const lon1: number = -97.7431;

// Houston, Texas
const lat2: number = 29.7604;
const lon2: number = -95.3698;

// Calculate distances
const distanceKm: number = haversine(lat1, lon1, lat2, lon2);

// Convert kilometers to miles
const distanceMiles: number = distanceKm * 0.621371;

// Output results
console.log(`Distance: ${distanceKm.toFixed(3)} km`);
console.log(`Distance: ${distanceMiles.toFixed(3)} miles`);



/*
run:

Distance: 235.352 km
Distance: 146.241 miles

*/

Answered: How to calculate the distance between two latitude-longitude points in JavaScript

Fri, 07 Aug 2026 08:22:26 +0000

// ------------------------------------------------------------
// Convert degrees to radians
// ------------------------------------------------------------
function degToRad(deg) {
    return deg * Math.PI / 180.0;
}

// ------------------------------------------------------------
// Compute the great-circle distance between two points on Earth
// using the Haversine formula.
// lat1, lon1, lat2, lon2 are in degrees.
// The result is returned in kilometers.
// ------------------------------------------------------------
function haversine(lat1, lon1, lat2, lon2) {

    // Earth's mean radius in kilometers
    const R = 6371.0;

    // Convert all angles to radians
    const rlat1 = degToRad(lat1);
    const rlon1 = degToRad(lon1);
    const rlat2 = degToRad(lat2);
    const rlon2 = degToRad(lon2);

    // Differences
    const dlat = rlat2 - rlat1;
    const dlon = rlon2 - rlon1;

    // Haversine formula
    // a is the Haversine of the central angle between the two points.
    const a =
        Math.sin(dlat / 2) ** 2 +
        Math.cos(rlat1) * Math.cos(rlat2) *
        Math.sin(dlon / 2) ** 2;

    // c is the central angle between the two points on the Earth’s surface.
    const c = 2 * Math.asin(Math.sqrt(a));

    // Final distance
    return R * c;
}

// ------------------------------------------------------------
// Main 
// ------------------------------------------------------------

// Example coordinates:
// Austin, Texas
const lat1 = 30.2672;
const lon1 = -97.7431;

// Houston, Texas
const lat2 = 29.7604;
const lon2 = -95.3698;

const distanceKm = haversine(lat1, lon1, lat2, lon2);

// Convert kilometers to miles
const distanceMiles = distanceKm * 0.621371;

console.log(`Distance: ${distanceKm.toFixed(3)} km`);
console.log(`Distance: ${distanceMiles.toFixed(3)} miles`);



/*
run:

Distance: 235.352 km
Distance: 146.241 miles

*/

Answered: How to calculate the distance between two latitude-longitude points in Python

Fri, 07 Aug 2026 08:14:54 +0000

import math

# ------------------------------------------------------------
# Convert degrees to radians
# ------------------------------------------------------------
def deg_to_rad(deg: float) -> float:
    return deg * math.pi / 180.0

# ------------------------------------------------------------
# Compute the great-circle distance between two points on Earth
# using the Haversine formula.
# lat1, lon1, lat2, lon2 are in degrees.
# The result is returned in kilometers.
# ------------------------------------------------------------
def haversine(lat1: float, lon1: float,
              lat2: float, lon2: float) -> float:

    # Earth's mean radius in kilometers
    R = 6371.0

    # Convert all angles to radians
    rlat1 = deg_to_rad(lat1)
    rlon1 = deg_to_rad(lon1)
    rlat2 = deg_to_rad(lat2)
    rlon2 = deg_to_rad(lon2)

    # Differences
    dlat = rlat2 - rlat1
    dlon = rlon2 - rlon1

    # Haversine formula
    # a is the Haversine of the central angle between the two points.
    a = math.sin(dlat / 2)**2 + \
        math.cos(rlat1) * math.cos(rlat2) * math.sin(dlon / 2)**2

    # c is the central angle between the two points on the Earth’s surface.
    c = 2 * math.asin(math.sqrt(a))

    # Final distance
    return R * c

# ------------------------------------------------------------
# Main 
# ------------------------------------------------------------
if __name__ == "__main__":

    # Example coordinates:
    # Austin, Texas
    lat1 = 30.2672
    lon1 = -97.7431

    # Houston, Texas
    lat2 = 29.7604
    lon2 = -95.3698

    distance_km = haversine(lat1, lon1, lat2, lon2)

    # Convert kilometers to miles
    distance_miles = distance_km * 0.621371

    print(f"Distance: {distance_km:.3f} km")
    print(f"Distance: {distance_miles:.3f} miles")



"""
run:

Distance: 235.352 km
Distance: 146.241 miles

"""

Answered: How to calculate the distance between two latitude-longitude points in PHP

Fri, 07 Aug 2026 07:27:38 +0000

// ------------------------------------------------------------
// Convert degrees to radians
// ------------------------------------------------------------
function degToRad(float $deg): float {
    return $deg * M_PI / 180.0;
}

// ------------------------------------------------------------
// Compute the great-circle distance between two points on Earth
// using the Haversine formula.
// lat1, lon1, lat2, lon2 are in degrees.
// The result is returned in kilometers.
// ------------------------------------------------------------
function haversine(float $lat1, float $lon1, float $lat2, float $lon2): float {

    // Earth's mean radius in kilometers
    $R = 6371.0;

    // Convert all angles to radians
    $rlat1 = degToRad($lat1);
    $rlon1 = degToRad($lon1);
    $rlat2 = degToRad($lat2);
    $rlon2 = degToRad($lon2);

    // Differences
    $dlat = $rlat2 - $rlat1;
    $dlon = $rlon2 - $rlon1;

    // Haversine formula
    // a is the Haversine of the central angle between the two points.
    $a = sin($dlat / 2) * sin($dlat / 2) +
         cos($rlat1) * cos($rlat2) *
         sin($dlon / 2) * sin($dlon / 2);

    // c is the central angle between the two points on the Earth’s surface.
    $c = 2 * asin(sqrt($a));

    // Final distance
    return $R * $c;
}

// ------------------------------------------------------------
// Main 
// ------------------------------------------------------------

// Example coordinates:
// Austin, Texas
$lat1 = 30.2672;
$lon1 = -97.7431;

// Houston, Texas
$lat2 = 29.7604;
$lon2 = -95.3698;

$distanceKm = haversine($lat1, $lon1, $lat2, $lon2);

// Convert kilometers to miles
$distanceMiles = $distanceKm * 0.621371;

echo "Distance: " . number_format($distanceKm, 3) . " km\n";
echo "Distance: " . number_format($distanceMiles, 3) . " miles\n";



/*
run:

Distance: 235.352 km
Distance: 146.241 miles

*/

Answered: How to calculate the distance between two latitude-longitude points in C#

Fri, 07 Aug 2026 06:55:30 +0000

using System;

class HaversineDistance
{
    // ------------------------------------------------------------
    // Convert degrees to radians
    // ------------------------------------------------------------
    static double DegToRad(double deg)
    {
        return deg * Math.PI / 180.0;
    }

    // ------------------------------------------------------------
    // Compute the great-circle distance between two points on Earth
    // using the Haversine formula.
    // lat1, lon1, lat2, lon2 are in degrees.
    // The result is returned in kilometers.
    // ------------------------------------------------------------
    static double Haversine(double lat1, double lon1,
                            double lat2, double lon2)
    {
        // Earth's mean radius in kilometers
        const double R = 6371.0;

        // Convert all angles to radians
        double rlat1 = DegToRad(lat1);
        double rlon1 = DegToRad(lon1);
        double rlat2 = DegToRad(lat2);
        double rlon2 = DegToRad(lon2);

        // Differences
        double dlat = rlat2 - rlat1;
        double dlon = rlon2 - rlon1;

        // Haversine formula
        // a is the Haversine of the central angle between the two points.
        double a = Math.Sin(dlat / 2) * Math.Sin(dlat / 2) +
                   Math.Cos(rlat1) * Math.Cos(rlat2) *
                   Math.Sin(dlon / 2) * Math.Sin(dlon / 2);

        // c is the central angle between the two points on the Earth’s surface.
        double c = 2 * Math.Asin(Math.Sqrt(a));

        // Final distance
        return R * c;
    }

    static void Main()
    {
        // Example coordinates:
        // Austin, Texas
        double lat1 = 30.2672;
        double lon1 = -97.7431;

        // Houston, Texas
        double lat2 = 29.7604;
        double lon2 = -95.3698;

        double distanceKm = Haversine(lat1, lon1, lat2, lon2);

        // Convert kilometers to miles
        double distanceMiles = distanceKm * 0.621371;

        Console.WriteLine("Distance: " + distanceKm.ToString("0.000") + " km");
        Console.WriteLine("Distance: " + distanceMiles.ToString("0.000") + " miles");
    }
}



/*
run:

Distance: 235.352 km
Distance: 146.241 miles

*/

Answered: How to calculate the distance between two latitude-longitude points in VB.NET

Fri, 07 Aug 2026 06:53:57 +0000

Imports System

Module HaversineDistance

    ' ------------------------------------------------------------
    ' Convert degrees to radians
    ' ------------------------------------------------------------
    Function DegToRad(deg As Double) As Double
        Return deg * Math.PI / 180.0
    End Function

    ' ------------------------------------------------------------
    ' Compute the great-circle distance between two points on Earth
    ' using the Haversine formula.
    ' lat1, lon1, lat2, lon2 are in degrees.
    ' The result is returned in kilometers.
    ' ------------------------------------------------------------
    Function Haversine(lat1 As Double, lon1 As Double,
                       lat2 As Double, lon2 As Double) As Double

        ' Earth's mean radius in kilometers
        Const R As Double = 6371.0

        ' Convert all angles to radians
        Dim rlat1 As Double = DegToRad(lat1)
        Dim rlon1 As Double = DegToRad(lon1)
        Dim rlat2 As Double = DegToRad(lat2)
        Dim rlon2 As Double = DegToRad(lon2)

        ' Differences
        Dim dlat As Double = rlat2 - rlat1
        Dim dlon As Double = rlon2 - rlon1

        ' Haversine formula
        ' a is the Haversine of the central angle between the two points.
        Dim a As Double =
            Math.Sin(dlat / 2) * Math.Sin(dlat / 2) +
            Math.Cos(rlat1) * Math.Cos(rlat2) *
            Math.Sin(dlon / 2) * Math.Sin(dlon / 2)

        ' c is the central angle between the two points on the Earth’s surface.
        Dim c As Double = 2 * Math.Asin(Math.Sqrt(a))

        ' Final distance
        Return R * c
    End Function

    Sub Main()

        ' Example coordinates:
        ' Austin, Texas
        Dim lat1 As Double = 30.2672
        Dim lon1 As Double = -97.7431

        ' Houston, Texas
        Dim lat2 As Double = 29.7604
        Dim lon2 As Double = -95.3698

        Dim distanceKm As Double = Haversine(lat1, lon1, lat2, lon2)

        ' Convert kilometers to miles
        Dim distanceMiles As Double = distanceKm * 0.621371

        Console.WriteLine("Distance: " & distanceKm.ToString("0.000") & " km")
        Console.WriteLine("Distance: " & distanceMiles.ToString("0.000") & " miles")

    End Sub

End Module



' run:
'
' Distance: 235.352 km
' Distance: 146.241 miles
'

Answered: How to calculate the distance between two latitude-longitude points in Java

Fri, 07 Aug 2026 06:18:52 +0000

public class HaversineDistance {

    // ------------------------------------------------------------
    // Convert degrees to radians
    // ------------------------------------------------------------
    public static double degToRad(double deg) {
        return deg * Math.PI / 180.0;
    }

    // ------------------------------------------------------------
    // Compute the great-circle distance between two points on Earth
    // using the Haversine formula.
    // lat1, lon1, lat2, lon2 are in degrees.
    // The result is returned in kilometers.
    // ------------------------------------------------------------
    public static double haversine(double lat1, double lon1,
                                   double lat2, double lon2) {

        // Earth's mean radius in kilometers
        final double R = 6371.0;

        // Convert all angles to radians
        double rlat1 = degToRad(lat1);
        double rlon1 = degToRad(lon1);
        double rlat2 = degToRad(lat2);
        double rlon2 = degToRad(lon2);

        // Differences
        double dlat = rlat2 - rlat1;
        double dlon = rlon2 - rlon1;

        // Haversine formula
        // a is the Haversine of the central angle between the two points.
        double a = Math.sin(dlat / 2) * Math.sin(dlat / 2)
                 + Math.cos(rlat1) * Math.cos(rlat2)
                 * Math.sin(dlon / 2) * Math.sin(dlon / 2);

        // c is the central angle between the two points on the Earth’s surface.
        double c = 2 * Math.asin(Math.sqrt(a));

        // Final distance
        return R * c;
    }

    public static void main(String[] args) {

        // Example coordinates:
        // Austin, Texas
        double lat1 = 30.2672;
        double lon1 = -97.7431;

        // Houston, Texas
        double lat2 = 29.7604;
        double lon2 = -95.3698;

        double distanceKm = haversine(lat1, lon1, lat2, lon2);

        // Convert kilometers to miles
        double distanceMiles = distanceKm * 0.621371;

        System.out.println("Distance: " + distanceKm + " km");
        System.out.println("Distance: " + distanceMiles + " miles");
    }
}


/*
run:

Distance: 235.3521373242579 km
Distance: 146.24099292131146 miles

*/

Answered: How to calculate the distance between two latitude-longitude points in Pascal

Fri, 07 Aug 2026 06:04:08 +0000

program HaversineDistance;

{$mode objfpc}

uses
  Math;  { Provides sin, cos, sqrt, arcsin, Pi }

{ ------------------------------------------------------------
  Convert degrees to radians
  ------------------------------------------------------------ }
function DegToRad(deg: Double): Double;
begin
  Result := deg * Pi / 180.0;
end;

{ ------------------------------------------------------------
  Compute the great-circle distance between two points on Earth
  using the Haversine formula.
  lat1, lon1, lat2, lon2 are in degrees.
  The result is returned in kilometers.
  ------------------------------------------------------------ }
function Haversine(lat1, lon1, lat2, lon2: Double): Double;
const
  R = 6371.0;  { Earth's mean radius in kilometers }
var
  rlat1, rlon1, rlat2, rlon2: Double;
  dlat, dlon: Double;
  a, c: Double;
begin
  { Convert all angles to radians }
  rlat1 := DegToRad(lat1);
  rlon1 := DegToRad(lon1);
  rlat2 := DegToRad(lat2);
  rlon2 := DegToRad(lon2);

  { Differences }
  dlat := rlat2 - rlat1;
  dlon := rlon2 - rlon1;

  { Haversine formula }
  // a is the Haversine of the central angle between the two points.
  
  // It combines the differences in latitude and longitude, adjusted by 
  // cosine terms to account for Earth’s curvature.
  a := Sqr(Sin(dlat / 2)) +
       Cos(rlat1) * Cos(rlat2) * Sqr(Sin(dlon / 2));

  // c is the central angle between the two points on the Earth’s surface.
  // This angle is measured in radians.
  // It tells you how large the arc is between the two points on the globe.
  c := 2 * ArcSin(Sqrt(a));

  { Final distance }
  Result := R * c;
end;

var
  lat1, lon1, lat2, lon2: Double;
  distanceKm, distanceMiles: Double;

begin
  { Example coordinates:
    Austin, Texas }
  lat1 := 30.2672;
  lon1 := -97.7431;

  { Houston, Texas }
  lat2 := 29.7604;
  lon2 := -95.3698;

  distanceKm := Haversine(lat1, lon1, lat2, lon2);

  { Convert kilometers to miles }
  distanceMiles := distanceKm * 0.621371;

  WriteLn('Distance: ', distanceKm:0:3, ' km');
  WriteLn('Distance: ', distanceMiles:0:3, ' miles');
end.


{
run:

Distance: 235.352 km
Distance: 146.241 miles

}

Answered: How to calculate the distance between two latitude-longitude points in C

Fri, 07 Aug 2026 05:53:05 +0000

#include <stdio.h>
#include <math.h>

/* ------------------------------------------------------------
   Convert degrees to radians
   ------------------------------------------------------------ */
double degToRad(double deg) {
    return deg * M_PI / 180.0;
}

/* ------------------------------------------------------------
   Compute the great-circle distance between two points on Earth
   using the Haversine formula.
   lat1, lon1, lat2, lon2 are in degrees.
   The result is returned in kilometers.
   ------------------------------------------------------------ */
double haversine(double lat1, double lon1, double lat2, double lon2) {
    /* Earth's mean radius in kilometers */
    const double R = 6371.0;

    /* Convert all angles to radians */
    double rlat1 = degToRad(lat1);
    double rlon1 = degToRad(lon1);
    double rlat2 = degToRad(lat2);
    double rlon2 = degToRad(lon2);

    /* Differences */
    double dlat = rlat2 - rlat1;
    double dlon = rlon2 - rlon1;

    /* Haversine formula */
    // a is the Haversine of the central angle between the two points.
   
    // It combines the differences in latitude and longitude, adjusted by 
    // cosine terms to account for Earth’s curvature.
    double a = sin(dlat / 2) * sin(dlat / 2) +
               cos(rlat1) * cos(rlat2) *
               sin(dlon / 2) * sin(dlon / 2);

    // c is the central angle between the two points on the Earth’s surface.
    // This angle is measured in radians.
    // It tells you how large the arc is between the two points on the globe.
    double c = 2 * asin(sqrt(a));

    /* Final distance */
    return R * c;
}

int main() {
    /* Example coordinates:
       Austin, Texas */
    double lat1 = 30.2672;
    double lon1 = -97.7431;

    /* Houston, Texas */
    double lat2 = 29.7604;
    double lon2 = -95.3698;

    double distanceKm = haversine(lat1, lon1, lat2, lon2);

    /* Convert kilometers to miles */
    double distanceMiles = distanceKm * 0.621371;

    printf("Distance: %.3f km\n", distanceKm);
    printf("Distance: %.3f miles\n", distanceMiles);

    return 0;
}



/*
run:

Distance: 235.352 km
Distance: 146.241 miles

*/

Answered: How to calculate the distance between two latitude-longitude points in C++

Thu, 06 Aug 2026 15:48:21 +0000

#include <iostream>
#include <cmath>

// ------------------------------------------------------------
// Convert degrees to radians
// ------------------------------------------------------------
double degToRad(double deg) {
    return deg * M_PI / 180.0;
}

// ------------------------------------------------------------
// Compute the great-circle distance between two points on Earth
// using the Haversine formula.
// lat1, lon1, lat2, lon2 are in degrees.
// The result is returned in kilometers.
// ------------------------------------------------------------
double haversine(double lat1, double lon1, double lat2, double lon2) {
    // Earth's mean radius in kilometers
    constexpr double R = 6371.0;

    // Convert all angles to radians
    double rlat1 = degToRad(lat1);
    double rlon1 = degToRad(lon1);
    double rlat2 = degToRad(lat2);
    double rlon2 = degToRad(lon2);

    // Differences
    double dlat = rlat2 - rlat1;
    double dlon = rlon2 - rlon1;

    // Haversine formula
    // a is the Haversine of the central angle between the two points.
    
    // It combines the differences in latitude and longitude, adjusted by 
    // cosine terms to account for Earth’s curvature.
    double a = std::sin(dlat / 2) * std::sin(dlat / 2) +
               std::cos(rlat1) * std::cos(rlat2) *
               std::sin(dlon / 2) * std::sin(dlon / 2);

    // c is the central angle between the two points on the Earth’s surface.
    // This angle is measured in radians.
    // It tells you how large the arc is between the two points on the globe.
    double c = 2 * std::asin(std::sqrt(a));

    // Final distance
    return R * c;
}

int main() {
    // Example coordinates:
    // Austin, Texas
    double lat1 = 30.2672;
    double lon1 = -97.7431;

    // Houston, Texas
    double lat2 = 29.7604;
    double lon2 = -95.3698;

    double distanceKm = haversine(lat1, lon1, lat2, lon2);

    // Convert kilometers to miles
    double distanceMiles = distanceKm * 0.621371;

    std::cout << "Distance: " << distanceKm << " km\n";
    std::cout << "Distance: " << distanceMiles << " miles\n";
}


/*
run:

Distance: 235.352 km
Distance: 146.241 miles

*/

Answered: How to convert a decimal to int64 in Swift

Thu, 06 Aug 2026 15:35:52 +0000

import Foundation

/*
    ============================================================
    Convert a decimal-like value to Int64 in Swift.

    This program demonstrates:
      • Conversion using rounded(), which rounds to the nearest integer.
      • Conversion using Int64(value), which truncates toward zero.
      • Conversion using Decimal + NSDecimalNumber for strict conversion.
      • Helper functions that print all conversion styles.

    Notes:
      • Swift does not have a built-in "long" type; Int64 is the closest.
      • rounded() returns a Double; cast to Int64 afterward.
      • Int64(value) truncates the fractional part.
      • Decimal → Int64 conversion is done via NSDecimalNumber.
    ============================================================
*/

// Rounds a Double to Int64
func convertDoubleToInt64(_ value: Double) -> Int64 {
    return Int64(value.rounded())
}

// Truncates a Double to Int64
func castDoubleToInt64(_ value: Double) -> Int64 {
    return Int64(value)
}

// Converts Decimal using truncation
func convertDecimalToInt64(_ value: Decimal) -> Int64 {
    return NSDecimalNumber(decimal: value).int64Value
}

// Converts Decimal strictly (throws if fractional or out of range)
func convertDecimalExact(_ value: Decimal) -> String {
    let number = NSDecimalNumber(decimal: value)
    do {
        let exact = try number.int64ValueExact()
        return "\(exact)"
    } catch {
        return "ERROR — fractional or out of range"
    }
}

// Prints conversion styles for Double
func showDoubleConversions(_ value: Double) {
    print("Input decimal (Double): \(value)")
    print("Rounded (rounded): \(convertDoubleToInt64(value))")
    print("Truncated (Int64 cast): \(castDoubleToInt64(value))")
    print()
}

// Prints conversion styles for Decimal
func showDecimalConversions(_ value: Decimal) {
    print("Input decimal (Decimal): \(value)")
    print("Truncated (int64Value): \(convertDecimalToInt64(value))")
    print("Exact (int64ValueExact): \(convertDecimalExact(value))")
    print()
}

extension NSDecimalNumber {
    // Throws if fractional or out of range
    func int64ValueExact() throws -> Int64 {
        if self.decimalValue != Decimal(self.int64Value) {
            throw NSError(domain: "ExactConversion", code: 1, userInfo: nil)
        }
        return self.int64Value
    }
}

func main() {
    // Double examples
    showDoubleConversions(12.7)
    showDoubleConversions(12.3)
    showDoubleConversions(-5.8)
    showDoubleConversions(42.0)

    // Decimal examples
    showDecimalConversions(Decimal(string: "12.7")!)
    showDecimalConversions(Decimal(string: "42")!)
    showDecimalConversions(Decimal(string: "-5.8")!)
}

// Call main manually
main()



/*
run:

Input decimal (Double): 12.7
Rounded (rounded): 13
Truncated (Int64 cast): 12

Input decimal (Double): 12.3
Rounded (rounded): 12
Truncated (Int64 cast): 12

Input decimal (Double): -5.8
Rounded (rounded): -6
Truncated (Int64 cast): -5

Input decimal (Double): 42.0
Rounded (rounded): 42
Truncated (Int64 cast): 42

Input decimal (Decimal): 12.7
Truncated (int64Value): 12
Exact (int64ValueExact): ERROR — fractional or out of range

Input decimal (Decimal): 42
Truncated (int64Value): 42
Exact (int64ValueExact): 42

Input decimal (Decimal): -5.8
Truncated (int64Value): -5
Exact (int64ValueExact): ERROR — fractional or out of range

*/

Answered: How to convert a decimal to integer in Kotlin

Thu, 06 Aug 2026 15:29:02 +0000

import kotlin.math.round
import java.math.BigDecimal

/*
    ============================================================
    Convert a decimal-like value to Long in Kotlin.

    This program demonstrates:
      • Conversion using round() for rounding.
      • Conversion using toLong() for truncation.
      • Conversion using BigDecimal.longValueExact() for strict conversion.
      • A helper function that prints all conversion styles.

    Notes:
      • Kotlin does not have a built-in decimal type; Double and BigDecimal
        are used for decimal values.
      • round() returns a Double; cast to Long afterward.
      • toLong() truncates the fractional part.
      • BigDecimal.longValueExact() throws if the value is fractional or out of range.
    ============================================================
*/

// Rounds a Double to Long
fun convertDoubleToLong(value: Double): Long =
    round(value).toLong()

// Truncates a Double to Long
fun castDoubleToLong(value: Double): Long =
    value.toLong()

// Converts BigDecimal using truncation
fun convertBigDecimalToLong(value: BigDecimal): Long =
    value.toLong()

// Converts BigDecimal strictly (throws if fractional or out of range)
fun convertBigDecimalExact(value: BigDecimal): String =
    try {
        value.longValueExact().toString()
    } catch (e: ArithmeticException) {
        "ERROR — fractional or out of range"
    }

// Prints conversion styles for Double
fun showDoubleConversions(value: Double) {
    println("Input decimal (Double): $value")
    println("Rounded (round): ${convertDoubleToLong(value)}")
    println("Truncated (toLong): ${castDoubleToLong(value)}")
    println()
}

// Prints conversion styles for BigDecimal
fun showBigDecimalConversions(value: BigDecimal) {
    println("Input decimal (BigDecimal): $value")
    println("Truncated (toLong): ${convertBigDecimalToLong(value)}")
    println("Exact (longValueExact): ${convertBigDecimalExact(value)}")
    println()
}

fun main() {
    // Double examples
    showDoubleConversions(12.7)
    showDoubleConversions(12.3)
    showDoubleConversions(-5.8)
    showDoubleConversions(42.0)

    // BigDecimal examples
    showBigDecimalConversions(BigDecimal("12.7"))
    showBigDecimalConversions(BigDecimal("42"))
    showBigDecimalConversions(BigDecimal("-5.8"))
}


/*
run:

Input decimal (Double): 12.7
Rounded (round): 13
Truncated (toLong): 12

Input decimal (Double): 12.3
Rounded (round): 12
Truncated (toLong): 12

Input decimal (Double): -5.8
Rounded (round): -6
Truncated (toLong): -5

Input decimal (Double): 42.0
Rounded (round): 42
Truncated (toLong): 42

Input decimal (BigDecimal): 12.7
Truncated (toLong): 12
Exact (longValueExact): ERROR ? fractional or out of range

Input decimal (BigDecimal): 42
Truncated (toLong): 42
Exact (longValueExact): 42

Input decimal (BigDecimal): -5.8
Truncated (toLong): -5
Exact (longValueExact): ERROR ? fractional or out of range

*/

Answered: How to convert a decimal to integer in Scala

Thu, 06 Aug 2026 15:06:37 +0000

/*
    ============================================================
    Convert a decimal-like value to Long in Scala.

    This program demonstrates:
      • Conversion using Math.round() for rounding.
      • Conversion using toLong for truncation.
      • Conversion using BigDecimal.toLongExact for strict conversion.
      • A helper method that prints all conversion styles.

    Notes:
      • Scala does not have a separate "decimal" type; Double and BigDecimal
        are used for decimal values.
      • Math.round returns a Long.
      • toLong truncates the fractional part.
      • BigDecimal.toLongExact throws if the value is fractional or out of range.
    ============================================================
*/

object DecimalToLongDemo {

  // Rounds a Double to Long
  def convertDoubleToLong(value: Double): Long =
    Math.round(value)

  // Truncates a Double to Long
  def castDoubleToLong(value: Double): Long =
    value.toLong

  // Converts BigDecimal using truncation
  def convertBigDecimalToLong(value: BigDecimal): Long =
    value.toLong

  // Converts BigDecimal strictly (throws if fractional)
  def convertBigDecimalExact(value: BigDecimal): Either[String, Long] =
    try {
      Right(value.toLongExact)
    } catch {
      case _: ArithmeticException =>
        Left("ERROR — fractional or out of range")
    }

  // Prints conversion styles for Double
  def showDoubleConversions(value: Double): Unit = {
    println(s"Input decimal (Double): $value")
    println(s"Rounded (Math.round): ${convertDoubleToLong(value)}")
    println(s"Truncated (toLong): ${castDoubleToLong(value)}")
    println()
  }

  // Prints conversion styles for BigDecimal
  def showBigDecimalConversions(value: BigDecimal): Unit = {
    println(s"Input decimal (BigDecimal): $value")
    println(s"Truncated (toLong): ${convertBigDecimalToLong(value)}")

    convertBigDecimalExact(value) match {
      case Right(v) => println(s"Exact (toLongExact): $v")
      case Left(err) => println(s"Exact (toLongExact): $err")
    }

    println()
  }

  def main(args: Array[String]): Unit = {
    // Double examples
    showDoubleConversions(12.7)
    showDoubleConversions(12.3)
    showDoubleConversions(-5.8)
    showDoubleConversions(42.0)

    // BigDecimal examples
    showBigDecimalConversions(BigDecimal("12.7"))
    showBigDecimalConversions(BigDecimal("42"))
    showBigDecimalConversions(BigDecimal("-5.8"))
  }
}



/*
run:

Input decimal (Double): 12.7
Rounded (Math.round): 13
Truncated (toLong): 12

Input decimal (Double): 12.3
Rounded (Math.round): 12
Truncated (toLong): 12

Input decimal (Double): -5.8
Rounded (Math.round): -6
Truncated (toLong): -5

Input decimal (Double): 42.0
Rounded (Math.round): 42
Truncated (toLong): 42

Input decimal (BigDecimal): 12.7
Truncated (toLong): 12
Exact (toLongExact): ERROR — fractional or out of range

Input decimal (BigDecimal): 42
Truncated (toLong): 42
Exact (toLongExact): 42

Input decimal (BigDecimal): -5.8
Truncated (toLong): -5
Exact (toLongExact): ERROR — fractional or out of range

*/

Answered: How to convert a decimal to integer in Ruby

Thu, 06 Aug 2026 14:51:49 +0000

require 'bigdecimal'
require 'bigdecimal/util'

=begin
    ============================================================
    Convert a decimal-like value to an Integer in Ruby.

    This program demonstrates:
      • Conversion using round, which rounds to the nearest integer.
      • Conversion using to_i, which truncates toward zero.
      • Conversion using BigDecimal for precise decimal arithmetic.
      • A helper method that prints all conversion styles.

    Notes:
      • Ruby does not have a separate "long" type; Integer expands as needed.
      • round returns an Integer.
      • to_i removes the fractional part.
      • BigDecimal#to_i also truncates.
    ============================================================
=end

# Rounds a Float to an Integer
def convert_decimal_to_integer(value)
  value.round
end

# Truncates a Float to an Integer
def cast_decimal_to_integer(value)
  value.to_i
end

# Converts BigDecimal using truncation
def convert_bigdecimal_to_integer(value)
  value.to_i
end

# Prints both conversion styles for Float
def show_float_conversions(value)
  puts "Input decimal (Float): #{value}"

  rounded   = convert_decimal_to_integer(value)
  truncated = cast_decimal_to_integer(value)

  puts "Rounded (round): #{rounded}"
  puts "Truncated (to_i): #{truncated}"
  puts
end

# Prints conversion styles for BigDecimal
def show_bigdecimal_conversions(value)
  puts "Input decimal (BigDecimal): #{value}"

  truncated = convert_bigdecimal_to_integer(value)
  puts "Truncated (to_i): #{truncated}"

  puts
end

# Main
show_float_conversions(12.7)
show_float_conversions(12.3)
show_float_conversions(-5.8)
show_float_conversions(42.0)

show_bigdecimal_conversions(BigDecimal("12.7"))
show_bigdecimal_conversions(BigDecimal("42"))
show_bigdecimal_conversions(BigDecimal("-5.8"))



=begin
run:

Input decimal (Float): 12.7
Rounded (round): 13
Truncated (to_i): 12

Input decimal (Float): 12.3
Rounded (round): 12
Truncated (to_i): 12

Input decimal (Float): -5.8
Rounded (round): -6
Truncated (to_i): -5

Input decimal (Float): 42.0
Rounded (round): 42
Truncated (to_i): 42

Input decimal (BigDecimal): 0.127e2
Truncated (to_i): 12

Input decimal (BigDecimal): 0.42e2
Truncated (to_i): 42

Input decimal (BigDecimal): -0.58e1
Truncated (to_i): -5

=end

Answered: How to convert a decimal to i64 in Rust

Thu, 06 Aug 2026 14:48:20 +0000

/*
    ============================================================
    Convert a decimal-like value to i64 in Rust.

    This program demonstrates:
      • Conversion using f64::round(), which rounds to the nearest integer.
      • Conversion using f64::trunc(), which truncates toward zero.
      • Conversion using "as i64", which also truncates.
      • A helper function that prints both results for comparison.

    Notes:
      • Rust does not have a built-in decimal type.
      • f64 is used for decimal values.
      • round() returns an f64; cast to i64 afterward.
      • trunc() removes the fractional part.
    ============================================================
*/

fn convert_decimal_to_i64(value: f64) -> i64 {
    // Rounds to nearest integer, then cast to i64
    value.round() as i64
}

fn cast_decimal_to_i64(value: f64) -> i64 {
    // Truncates fractional part toward zero
    value as i64
}

fn show_conversions(value: f64) {
    println!("Input decimal: {:.4}", value);

    let rounded = convert_decimal_to_i64(value);
    let truncated = cast_decimal_to_i64(value);

    println!("Rounded (round): {}", rounded);
    println!("Truncated (as i64): {}", truncated);
    println!();
}

fn main() {
    // Example values to demonstrate behavior
    show_conversions(12.7);
    show_conversions(12.3);
    show_conversions(-5.8);
    show_conversions(42.0); // already an integer
}


/*
run:

Input decimal: 12.7000
Rounded (round): 13
Truncated (as i64): 12

Input decimal: 12.3000
Rounded (round): 12
Truncated (as i64): 12

Input decimal: -5.8000
Rounded (round): -6
Truncated (as i64): -5

Input decimal: 42.0000
Rounded (round): 42
Truncated (as i64): 42

*/

Answered: How to convert a decimal to int64 in Go

Thu, 06 Aug 2026 14:28:11 +0000

package main

import (
    "fmt"
    "math"
)

/*
    ============================================================
    Convert a decimal-like value to int64 in Go.

    This program demonstrates:
      • Conversion using math.Round(), which rounds to the nearest integer.
      • Conversion using int64(value), which truncates toward zero.
      • A helper function that prints both results for comparison.

    Notes:
      • Go does not have a built-in decimal type.
      • float64 is used for decimal values.
      • math.Round() returns a float64; cast to int64 afterward.
      • int64(value) truncates the fractional part.
    ============================================================
*/

// Converts a decimal to int64 using rounding
func convertDecimalToInt64(value float64) int64 {
    return int64(math.Round(value))
}

// Converts a decimal to int64 using truncation
func castDecimalToInt64(value float64) int64 {
    return int64(value)
}

// Prints both conversion styles for comparison
func showConversions(value float64) {
    fmt.Printf("Input decimal: %.4f\n", value)

    rounded := convertDecimalToInt64(value)
    truncated := castDecimalToInt64(value)

    fmt.Printf("Rounded (math.Round): %d\n", rounded)
    fmt.Printf("Truncated (int64 cast): %d\n\n", truncated)
}

func main() {
    // Example values to demonstrate behavior
    showConversions(12.7)
    showConversions(12.3)
    showConversions(-5.8)
    showConversions(42.0) // already an integer
}


/*
run:

Input decimal: 12.7000
Rounded (math.Round): 13
Truncated (int64 cast): 12

Input decimal: 12.3000
Rounded (math.Round): 12
Truncated (int64 cast): 12

Input decimal: -5.8000
Rounded (math.Round): -6
Truncated (int64 cast): -5

Input decimal: 42.0000
Rounded (math.Round): 42
Truncated (int64 cast): 42

*/

Answered: How to convert a decimal to an integer in PHP

Thu, 06 Aug 2026 09:42:35 +0000

/*
    ============================================================
    Convert a decimal-like value to an integer in PHP.
 
    This program demonstrates:
      • Conversion using round(), which rounds to the nearest integer.
      • Conversion using intval(), which truncates toward zero.
      • Conversion using (int), which also truncates.
      • A helper function that prints all conversion styles.
 
    Notes:
      • PHP does not have a distinct "long" type; integers expand as needed.
      • round() follows standard rounding rules.
      • intval() and (int) remove the fractional part.
    ============================================================
*/
 
/* Converts a decimal to an integer using rounding */
function convert_decimal_to_integer(float $value): int {
    return round($value);
}
 
/* Converts a decimal to an integer using truncation */
function cast_decimal_to_integer(float $value): int {
    return intval($value);   // same as (int)$value
}
 
/* Prints both conversion styles for comparison */
function show_conversions(float $value): void {
    echo "Input decimal: {$value}\n";
 
    $rounded   = convert_decimal_to_integer($value);
    $truncated = cast_decimal_to_integer($value);
 
    echo "Rounded (round): {$rounded}\n";
    echo "Truncated (intval): {$truncated}\n\n";
}
 
/* Main */
show_conversions(12.7);
show_conversions(12.3);
show_conversions(-5.8);
show_conversions(42.0);   // already an integer
 
 
/*
run:
 
Input decimal: 12.7
Rounded (round): 13
Truncated (intval): 12
 
Input decimal: 12.3
Rounded (round): 12
Truncated (intval): 12
 
Input decimal: -5.8
Rounded (round): -6
Truncated (intval): -5
 
Input decimal: 42
Rounded (round): 42
Truncated (intval): 42
 
*/

Answered: How to convert a decimal to a long in Java

Thu, 06 Aug 2026 09:36:16 +0000

public class DecimalToLongProgram {

    /**
        ============================================================
        Convert decimal-like values to long in Java.

        This class demonstrates:
          • Conversion using Math.round() for floating-point rounding.
          • Conversion using a direct cast (long) for truncation.
          • Conversion using BigDecimal.longValue() and longValueExact().
          • A helper method that prints all conversion styles.

        Notes:
          • Math.round() returns a long and rounds to nearest integer.
          • (long)value truncates the fractional part.
          • BigDecimal.longValue() truncates.
          • BigDecimal.longValueExact() throws if fractional or out of range.
        ============================================================
    */

    // Rounds a double to long
    static long convertDoubleToLong(double value) {
        return Math.round(value);
    }

    // Truncates a double to long
    static long castDoubleToLong(double value) {
        return (long) value;
    }

    // Rounds or truncates a BigDecimal
    static long convertBigDecimalToLong(java.math.BigDecimal value) {
        return value.longValue(); // truncates
    }

    // Exact conversion (throws if fractional)
    static long convertBigDecimalExact(java.math.BigDecimal value) {
        return value.longValueExact(); // strict
    }

    // Prints all conversion styles for comparison
    static void showConversions(double value) {
        System.out.println("Input decimal (double): " + value);

        long rounded   = convertDoubleToLong(value);
        long truncated = castDoubleToLong(value);

        System.out.println("Rounded (Math.round): " + rounded);
        System.out.println("Truncated (cast to long): " + truncated);
        System.out.println();
    }

    static void showConversions(java.math.BigDecimal value) {
        System.out.println("Input decimal (BigDecimal): " + value);

        long truncated = convertBigDecimalToLong(value);
        System.out.println("Truncated (longValue): " + truncated);

        try {
            long exact = convertBigDecimalExact(value);
            System.out.println("Exact (longValueExact): " + exact);
        } catch (ArithmeticException ex) {
            System.out.println("Exact (longValueExact): ERROR — fractional or out of range");
        }

        System.out.println();
    }

    public static void main(String[] args) {

        // Floating-point examples
        showConversions(12.7);
        showConversions(12.3);
        showConversions(-5.8);
        showConversions(42.0);

        // BigDecimal examples
        // it only succeeds when the BigDecimal represents a whole number that fits inside a long.
        showConversions(new java.math.BigDecimal("12.7"));
        showConversions(new java.math.BigDecimal("42"));
        showConversions(new java.math.BigDecimal("-5.8"));
    }
}



/*
run:

Input decimal (double): 12.7
Rounded (Math.round): 13
Truncated (cast to long): 12

Input decimal (double): 12.3
Rounded (Math.round): 12
Truncated (cast to long): 12

Input decimal (double): -5.8
Rounded (Math.round): -6
Truncated (cast to long): -5

Input decimal (double): 42.0
Rounded (Math.round): 42
Truncated (cast to long): 42

Input decimal (BigDecimal): 12.7
Truncated (longValue): 12
Exact (longValueExact): ERROR ? fractional or out of range

Input decimal (BigDecimal): 42
Truncated (longValue): 42
Exact (longValueExact): 42

Input decimal (BigDecimal): -5.8
Truncated (longValue): -5
Exact (longValueExact): ERROR ? fractional or out of range

*/

Answered: How to convert a decimal to a long in Pascal

Thu, 06 Aug 2026 09:29:42 +0000

program DecimalToLongProgram;

{$mode objfpc}{$H+}

{
    ============================================================
    Convert a decimal-like value to a LongInt in Free Pascal.

    This program demonstrates:
      • Conversion using Round(), which rounds to the nearest integer.
      • Conversion using Trunc(), which truncates toward zero.
      • A helper procedure that prints both results for comparison.

    Notes:
      • Free Pascal does not have a built-in decimal type.
      • Real/Double/Extended are used for decimal values.
      • Round() follows standard rounding rules.
      • Trunc() removes the fractional part.
    ============================================================
}

{ Converts a floating decimal value to LongInt using rounding }
function ConvertDecimalToLong(value: Double): LongInt;
begin
    Result := Round(value);
end;

{ Converts a floating decimal value to LongInt using truncation }
function CastDecimalToLong(value: Double): LongInt;
begin
    Result := Trunc(value);
end;

{ Prints both conversion styles for comparison }
procedure ShowConversions(value: Double);
var
    rounded, truncated: LongInt;
begin
    Writeln('Input decimal: ', value:0:4);

    rounded   := ConvertDecimalToLong(value);
    truncated := CastDecimalToLong(value);

    Writeln('Rounded (Round): ', rounded);
    Writeln('Truncated (Trunc): ', truncated);
    Writeln;
end;

begin
    { Example values to demonstrate behavior }
    ShowConversions(12.7);
    ShowConversions(12.3);
    ShowConversions(-5.8);
    ShowConversions(42.0);   { already an integer }
end.



{
run:

Input decimal: 12.7000
Rounded (Round): 13
Truncated (Trunc): 12

Input decimal: 12.3000
Rounded (Round): 12
Truncated (Trunc): 12

Input decimal: -5.8000
Rounded (Round): -6
Truncated (Trunc): -5

Input decimal: 42.0000
Rounded (Round): 42
Truncated (Trunc): 42

}

Answered: How to convert a decimal to a long in C

Thu, 06 Aug 2026 09:23:43 +0000

#include <stdio.h>
#include <math.h>

/*
    ============================================================
    Convert a decimal-like value to a long in C.

    This program demonstrates:
      • Conversion using lround(), which rounds to the nearest integer.
      • Conversion using a direct cast (long), which truncates toward zero.
      • A helper function that prints both results for comparison.

    Notes:
      • C does not have a built-in decimal type.
      • double or long double are used for decimal values.
      • lround() follows IEEE rounding rules.
      • (long)value truncates the fractional part.
    ============================================================
*/

/* Converts a floating decimal value to long using rounding */
long convert_decimal_to_long(double value) {
    return lround(value);
}

/* Converts a floating decimal value to long using truncation */
long cast_decimal_to_long(double value) {
    return (long)value;
}

/* Prints both conversion styles for comparison */
void show_conversions(double value) {
    printf("Input decimal: %.4f\n", value);

    long rounded   = convert_decimal_to_long(value);
    long truncated = cast_decimal_to_long(value);

    printf("Rounded (lround): %ld\n", rounded);
    printf("Truncated (cast to long): %ld\n\n", truncated);
}

int main(void) {
    /* Example values to demonstrate behavior */
    show_conversions(12.7);
    show_conversions(12.3);
    show_conversions(-5.8);
    show_conversions(42.0);   /* already an integer */

    return 0;
}


/*
run:

Input decimal: 12.7000
Rounded (lround): 13
Truncated (cast to long): 12

Input decimal: 12.3000
Rounded (lround): 12
Truncated (cast to long): 12

Input decimal: -5.8000
Rounded (lround): -6
Truncated (cast to long): -5

Input decimal: 42.0000
Rounded (lround): 42
Truncated (cast to long): 42

*/

Answered: How to convert a decimal to a long in C++

Thu, 06 Aug 2026 09:13:39 +0000

#include <iostream>
#include <cmath>
#include <string>

/*
    ============================================================
    Convert a decimal-like value to a long in C++.

    This program demonstrates:
      • Conversion using std::lround(), which rounds to nearest.
      • Conversion using static_cast<long>(), which truncates.
      • A helper function that prints both results.

    Notes:
      • C++ does not have a built-in decimal type.
      • double or long double are used for decimal values.
      • std::lround() follows IEEE rounding rules.
      • static_cast<long>() truncates toward zero.
    ============================================================
*/

class DecimalToLongProgram {
public:

    // Converts a floating decimal value to long using rounding.
    static long ConvertDecimalToLong(double value) {
        return std::lround(value);
    }

    // Converts a floating decimal value to long using truncation.
    static long CastDecimalToLong(double value) {
        return static_cast<long>(value);
    }

    // Prints both conversion styles for comparison.
    static void ShowConversions(double value) {
        std::cout << "Input decimal: " << value << "\n";

        long rounded   = ConvertDecimalToLong(value);
        long truncated = CastDecimalToLong(value);

        std::cout << "Rounded (std::lround): " << rounded << "\n";
        std::cout << "Truncated (static_cast<long>): " << truncated << "\n\n";
    }
};

int main() {
    // Example values to demonstrate behavior
    DecimalToLongProgram::ShowConversions(12.7);
    DecimalToLongProgram::ShowConversions(12.3);
    DecimalToLongProgram::ShowConversions(-5.8);
    DecimalToLongProgram::ShowConversions(42.0);   // already an integer
}



/*
run:

Input decimal: 12.7
Rounded (std::lround): 13
Truncated (static_cast<long>): 12

Input decimal: 12.3
Rounded (std::lround): 12
Truncated (static_cast<long>): 12

Input decimal: -5.8
Rounded (std::lround): -6
Truncated (static_cast<long>): -5

Input decimal: 42
Rounded (std::lround): 42
Truncated (static_cast<long>): 42

*/

Answered: How to convert a decimal to a long in C#

Thu, 06 Aug 2026 09:01:48 +0000

using System;

/*
    ============================================================
    Convert a decimal to a long in C#.

    This program demonstrates:
      • Safe conversion using Convert.ToInt64()
      • Direct casting when the value is known to be in range
      • A helper function that performs the conversion and
        explains what happens internally.

    Notes:
      • decimal → long conversion requires the value to be within
        the range of Int64.
      • Convert.ToInt64() rounds to the nearest integer.
      • A direct cast (long)decimalValue truncates toward zero.
    ============================================================
*/

class DecimalToLongProgram
{
    // Converts a decimal to a long using the built‑in Convert class.
    // This method rounds the decimal to the nearest whole number.
    static long ConvertDecimalToLong(decimal value)
    {
        return Convert.ToInt64(value);
    }

    // Converts a decimal to a long using a direct cast.
    // This method truncates the decimal toward zero.
    static long CastDecimalToLong(decimal value)
    {
        return (long)value;
    }

    // Prints both conversion styles for comparison.
    static void ShowConversions(decimal value)
    {
        Console.WriteLine("Input decimal: " + value);

        long rounded = ConvertDecimalToLong(value);
        long truncated = CastDecimalToLong(value);

        Console.WriteLine("Rounded (Convert.ToInt64): " + rounded);
        Console.WriteLine("Truncated (cast to long): " + truncated);
        Console.WriteLine();
    }

    static void Main()
    {
        // Example values to demonstrate behavior
        ShowConversions(12.7m);
        ShowConversions(12.3m);
        ShowConversions(-5.8m);
        ShowConversions(42m);   // already an integer
    }
}


/*
run:

Input decimal: 12.7
Rounded (Convert.ToInt64): 13
Truncated (cast to long): 12

Input decimal: 12.3
Rounded (Convert.ToInt64): 12
Truncated (cast to long): 12

Input decimal: -5.8
Rounded (Convert.ToInt64): -6
Truncated (cast to long): -5

Input decimal: 42
Rounded (Convert.ToInt64): 42
Truncated (cast to long): 42

*/

Answered: How to convert a decimal to a long in VB.NET

Thu, 06 Aug 2026 08:59:35 +0000

Imports System

' ============================================================
' Convert a Decimal to a Long in VB.NET.
'
' This program demonstrates:
'   • Conversion using CLng(), which rounds to the nearest whole number.
'   • Conversion using a direct CType() cast, which truncates toward zero.
'   • A helper function that prints both results for comparison.
'
' Notes:
'   • Decimal → Long conversion requires the value to be within Int64 range.
'   • CLng() performs banker's rounding (to nearest even).
'   • CType(value, Long) truncates the fractional part.
' ============================================================

Module DecimalToLongProgram

    ' Converts a Decimal to a Long using CLng(), which rounds.
    Function ConvertDecimalToLong(value As Decimal) As Long
        Return CLng(value)
    End Function

    ' Converts a Decimal to a Long using CType(), which truncates.
    Function CastDecimalToLong(value As Decimal) As Long
        Return CType(value, Long)
    End Function

    ' Prints both conversion styles for comparison.
    Sub ShowConversions(value As Decimal)
        Console.WriteLine("Input decimal: " & value)

        Dim rounded As Long = ConvertDecimalToLong(value)
        Dim truncated As Long = CastDecimalToLong(value)

        Console.WriteLine("Rounded (CLng): " & rounded)
        Console.WriteLine("Truncated (CType): " & truncated)
        Console.WriteLine()
    End Sub

    Sub Main()
        ' Example values to demonstrate behavior
        ShowConversions(12.7D)
        ShowConversions(12.3D)
        ShowConversions(-5.8D)
        ShowConversions(42D)   ' already an integer
    End Sub

End Module


' run:
'
' Input decimal: 12.7
' Rounded (CLng): 13
' Truncated (CType): 12
'
' Input decimal: 12.3
' Rounded (CLng): 12
' Truncated (CType): 12
'
' Input decimal: -5.8
' Rounded (CLng): -6
' Truncated (CType): -5
'
' Input decimal: 42
' Rounded (CLng): 42
' Truncated (CType): 42
'

Answered: How to generate a random 3×3 magic square in C

Thu, 06 Aug 2026 06:37:23 +0000

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

#define N 3
#define CELLS (N * N)
#define MAX_MAGIC_SQUARES 8  /* exact count for digits 1-9 */

/* A square is stored as 9 ints in row-major order: index = row*3 + col */
typedef struct {
    int cell[CELLS];
} Square;

/* Advances 'arr' (length n) to the next lexicographic permutation in place.
 * Returns 1 if a next permutation exists, 0 if 'arr' was already the last
 * (fully descending) permutation. This is the standard constant-amortized
 * algorithm: find the rightmost ascent, find the smallest element to its
 * right that is still larger, swap, then reverse the suffix. */
int next_permutation(int *arr, int n) {
    int i = n - 2;
    while (i >= 0 && arr[i] >= arr[i + 1]) {
        --i;
    }
    if (i < 0) {
        return 0; /* already the last permutation */
    }

    int j = n - 1;
    while (arr[j] <= arr[i]) {
        --j;
    }

    int tmp = arr[i]; arr[i] = arr[j]; arr[j] = tmp;

    for (int lo = i + 1, hi = n - 1; lo < hi; ++lo, --hi) {
        tmp = arr[lo]; arr[lo] = arr[hi]; arr[hi] = tmp;
    }
    return 1;
}

/* Checks whether 'sq' is magic: every row, every column, and both
 * diagonals must sum to the same value. Returns 1 and writes that common
 * sum into *magic_sum if the square qualifies; returns 0 otherwise. */
int is_magic(const Square *sq, int *magic_sum) {
    int row_sum[N] = {0}, col_sum[N] = {0};
    int main_diag = 0, anti_diag = 0;

    for (int r = 0; r < N; ++r) {
        for (int c = 0; c < N; ++c) {
            int v = sq->cell[r * N + c];
            row_sum[r] += v;
            col_sum[c] += v;
            if (r == c)         main_diag += v; /* top-left to bottom-right */
            if (r == N - 1 - c) anti_diag += v; /* top-right to bottom-left */
        }
    }

    *magic_sum = row_sum[0];
    for (int r = 0; r < N; ++r) if (row_sum[r] != *magic_sum) return 0;
    for (int c = 0; c < N; ++c) if (col_sum[c] != *magic_sum) return 0;
    return (main_diag == *magic_sum) && (anti_diag == *magic_sum);
}

/* Enumerates all 9! = 362,880 permutations of {1,...,9} via
 * next_permutation (lexicographic order, no duplicates, no extra memory),
 * and collects every arrangement that forms a magic square into 'out'.
 * Returns the number of magic squares found. This exhaustive pass is
 * cheap: 362,880 iterations of O(1) work, well under a second at runtime. */
int collect_all_magic_squares(Square out[MAX_MAGIC_SQUARES]) {
    int current[CELLS];
    for (int i = 0; i < CELLS; ++i) {
        current[i] = i + 1; /* fill with 1..9 */
    }

    int count = 0;
    do {
        Square candidate;
        for (int i = 0; i < CELLS; ++i) {
            candidate.cell[i] = current[i];
        }
        int sum;
        if (is_magic(&candidate, &sum)) {
            if (count < MAX_MAGIC_SQUARES) {
                out[count++] = candidate;
            }
        }
    } while (next_permutation(current, CELLS));

    return count;
}

/* Prints a square in a readable grid layout, plus its magic sum. */
void print_square(const Square *sq) {
    for (int r = 0; r < N; ++r) {
        for (int c = 0; c < N; ++c) {
            printf("%d%c", sq->cell[r * N + c], (c < N - 1) ? ' ' : '\n');
        }
    }
    int sum;
    is_magic(sq, &sum);
    printf("Magic sum per row/column/diagonal: %d\n", sum);
}

int main(void) {
    /* Step 1: build the full list of valid 3x3 magic squares (digits 1-9)
     * once. There are exactly 8, so a fixed-size array is sufficient and
     * avoids any dynamic memory management. */
    Square all_magic_squares[MAX_MAGIC_SQUARES];
    int count = collect_all_magic_squares(all_magic_squares);

    if (count == 0) {
        fprintf(stderr, "No magic squares found (unexpected).\n");
        return 1;
    }

    /* Step 2: pick one uniformly at random. Seed the standard library's
     * pseudo-random generator once from the current time, then use
     * rand() with the classic scaling trick to get an unbiased index
     * in range [0, count). */
    srand((unsigned int)time(NULL));
    int index = rand() % count;
    const Square *chosen = &all_magic_squares[index];

    printf("Found %d valid 3x3 magic squares (digits 1-9).\n", count);
    printf("Randomly selected one:\n\n");
    print_square(chosen);

    return 0;
}


/*
run:

Found 8 valid 3x3 magic squares (digits 1-9).
Randomly selected one:

4 9 2
3 5 7
8 1 6
Magic sum per row/column/diagonal: 15

*/

Answered: How to generate a random 3×3 magic square in C++

Thu, 06 Aug 2026 06:35:01 +0000

#include <iostream>
#include <vector>
#include <array>
#include <algorithm> // next_permutation
#include <random>

// A square is stored as 9 cells in row-major order: index = row*3 + col
using Square = std::array<int, 9>;

// Checks whether a square is magic: every row, every column, and both
// diagonals must sum to the same value. Returns true and writes that
// common sum into magicSum if the square qualifies.
bool isMagic(const Square& sq, int& magicSum) {
    std::array<int, 3> rowSum{}, colSum{};
    int mainDiag = 0, antiDiag = 0;

    for (int r = 0; r < 3; ++r) {
        for (int c = 0; c < 3; ++c) {
            int v = sq[r * 3 + c];
            rowSum[r] += v;
            colSum[c] += v;
            if (r == c)     mainDiag += v; // top-left to bottom-right
            if (r == 2 - c) antiDiag += v; // top-right to bottom-left
        }
    }

    magicSum = rowSum[0];
    for (int r = 0; r < 3; ++r) if (rowSum[r] != magicSum) return false;
    for (int c = 0; c < 3; ++c) if (colSum[c] != magicSum) return false;
    
    return mainDiag == magicSum && antiDiag == magicSum;
}

// Enumerates all 9! = 362,880 permutations of {1,...,9} using
// std::next_permutation (which generates permutations in lexicographic
// order with no duplicates and no extra bookkeeping), and collects every
// arrangement that forms a magic square. This exhaustive pass is cheap:
// 362,880 iterations, each doing O(1) work, comfortably fast at runtime.
std::vector<Square> collectAllMagicSquares() {
    std::vector<Square> results;
    results.reserve(8); // exactly 8 magic squares exist for digits 1-9

    Square current;
    std::iota(current.begin(), current.end(), 1); // fill with 1..9

    do {
        int sum;
        if (isMagic(current, sum)) {
            results.push_back(current);
        }
    } while (std::next_permutation(current.begin(), current.end()));

    return results;
}

// Prints a square in a readable grid layout, plus its magic sum.
void printSquare(const Square& sq) {
    for (int r = 0; r < 3; ++r) {
        for (int c = 0; c < 3; ++c) {
            std::cout << sq[r * 3 + c] << (c < 2 ? ' ' : '\n');
        }
    }
    int sum;
    isMagic(sq, sum);
    std::cout << "Magic sum per row/column/diagonal: " << sum << '\n';
}

int main() {
    // Step 1: build the full list of valid 3x3 magic squares (digits 1-9) once.
    std::vector<Square> allMagicSquares = collectAllMagicSquares();

    if (allMagicSquares.empty()) {
        std::cerr << "No magic squares found (unexpected).\n";
        return 1;
    }

    // Step 2: pick one uniformly at random using a proper random engine
    // (Mersenne Twister seeded from a hardware entropy source), rather
    // than relying on rand()/srand().
    std::random_device rd;
    std::mt19937 rng(rd());
    std::uniform_int_distribution<std::size_t> dist(0, allMagicSquares.size() - 1);

    const Square& chosen = allMagicSquares[dist(rng)];

    std::cout << "Found " << allMagicSquares.size()
              << " valid 3x3 magic squares (digits 1-9).\n"
              << "Randomly selected one:\n\n";
    printSquare(chosen);
}



/*
run:

Found 8 valid 3x3 magic squares (digits 1-9).
Randomly selected one:

6 1 8
7 5 3
2 9 4
Magic sum per row/column/diagonal: 15

*/

Answered: How to generate a random 4×4 binary magic square (using only 0 and 1) in Java

Thu, 06 Aug 2026 06:16:47 +0000

import java.util.ArrayList;
import java.util.List;
import java.util.Random;

/**
    ============================================================
    Generate a random 4×4 binary magic square (0/1 only).

    A valid square must satisfy:
      • All rows have the same sum.
      • All columns have the same sum.
      • Both diagonals have that same sum.

    This class:
      1. Represents each 4×4 grid as a 16‑bit integer.
      2. Converts each mask into a 4×4 square.
      3. Checks whether it is magic.
      4. Collects all valid squares.
      5. Chooses one uniformly at random.
    ============================================================
*/

public class RandomBinaryMagicSquare {

    // A square is stored as 16 cells in row-major order: index = row*4 + col
    static class Square {
        int[] cells = new int[16];
    }

    // Builds a 4×4 square from a 16-bit mask
    static Square buildSquareFromMask(int mask) {
        Square sq = new Square();
        for (int i = 0; i < 16; i++) {
            sq.cells[i] = (mask >> i) & 1;
        }
        return sq;
    }

    // Checks whether a square is magic
    static boolean isMagic(Square sq, int[] magicSumOut) {
        int[] rowSum = new int[4];
        int[] colSum = new int[4];
        int mainDiag = 0;
        int antiDiag = 0;

        // Compute row sums, column sums, and diagonals
        for (int r = 0; r < 4; r++) {
            for (int c = 0; c < 4; c++) {
                int v = sq.cells[r * 4 + c];
                rowSum[r] += v;
                colSum[c] += v;

                if (r == c) mainDiag += v;
                if (r == 3 - c) antiDiag += v;
            }
        }

        int magicSum = rowSum[0];
        magicSumOut[0] = magicSum;

        // All rows must match the magic sum
        for (int r = 0; r < 4; r++)
            if (rowSum[r] != magicSum) return false;

        // All columns must match the magic sum
        for (int c = 0; c < 4; c++)
            if (colSum[c] != magicSum) return false;

        // Both diagonals must match the magic sum
        return mainDiag == magicSum && antiDiag == magicSum;
    }

    // Scans all 65,536 possible 4×4 binary grids and collects the magic ones
    static List<Square> collectAllMagicSquares() {
        List<Square> results = new ArrayList<>(4096);

        for (int mask = 0; mask < 65536; mask++) {
            Square sq = buildSquareFromMask(mask);
            int[] sum = new int[1];
            if (isMagic(sq, sum)) {
                results.add(sq);
            }
        }

        return results;
    }

    // Prints a square in a readable grid layout
    static void printSquare(Square sq) {
        int[] sum = new int[1];
        isMagic(sq, sum);

        for (int r = 0; r < 4; r++) {
            for (int c = 0; c < 4; c++) {
                System.out.print(sq.cells[r * 4 + c] + " ");
            }
            System.out.println();
        }

        System.out.println("Magic sum: " + sum[0]);
    }

    public static void main(String[] args) {
        // Step 1: collect all valid magic squares
        List<Square> allMagicSquares = collectAllMagicSquares();

        if (allMagicSquares.isEmpty()) {
            System.out.println("No magic squares found.");
            return;
        }

        // Step 2: pick one uniformly at random
        Random rng = new Random();
        Square chosen = allMagicSquares.get(rng.nextInt(allMagicSquares.size()));

        System.out.println("Found " + allMagicSquares.size() + " valid 4×4 binary magic squares.");
        System.out.println("Randomly selected one:\n");

        printSquare(chosen);
    }
}



/*
run:

Found 34 valid 4?4 binary magic squares.
Randomly selected one:

1 0 1 1 
1 1 1 0 
1 1 0 1 
0 1 1 1 
Magic sum: 3

*/

Answered: How to generate a random 4×4 binary magic square (using only 0 and 1) in Pascal

Thu, 06 Aug 2026 06:12:38 +0000

program RandomBinaryMagicSquare;

{
    ============================================================
    Generate a random 4×4 binary magic square (0/1 only).

    A valid square must satisfy:
      • All rows have the same sum.
      • All columns have the same sum.
      • Both diagonals have that same sum.

    This program:
      1. Represents each 4×4 grid as a 16‑bit integer.
      2. Converts each mask into a 4×4 square.
      3. Checks whether it is magic.
      4. Collects all valid squares.
      5. Chooses one uniformly at random.
    ============================================================
}

type
    TSquare = array[0..15] of Integer;

{ Build a square from a 16‑bit mask }
procedure BuildSquareFromMask(mask: Word; var sq: TSquare);
var
    i: Integer;
begin
    for i := 0 to 15 do
        sq[i] := (mask shr i) and 1;
end;

{ Check whether a square is magic }
function IsMagic(const sq: TSquare; var magicSum: Integer): Boolean;
var
    rowSum, colSum: array[0..3] of Integer;
    r, c, v: Integer;
    mainDiag, antiDiag: Integer;
begin
    for r := 0 to 3 do rowSum[r] := 0;
    for c := 0 to 3 do colSum[c] := 0;

    mainDiag := 0;
    antiDiag := 0;

    for r := 0 to 3 do
        for c := 0 to 3 do
        begin
            v := sq[r * 4 + c];
            rowSum[r] := rowSum[r] + v;
            colSum[c] := colSum[c] + v;

            if r = c then
                mainDiag := mainDiag + v;

            if r = 3 - c then
                antiDiag := antiDiag + v;
        end;

    magicSum := rowSum[0];

    for r := 0 to 3 do
        if rowSum[r] <> magicSum then
        begin
            IsMagic := False;
            Exit;
        end;

    for c := 0 to 3 do
        if colSum[c] <> magicSum then
        begin
            IsMagic := False;
            Exit;
        end;

    IsMagic := (mainDiag = magicSum) and (antiDiag = magicSum);
end;

{ Collect all magic squares }
function CollectAllMagicSquares(var outList: array of TSquare): Integer;
var
    mask: Word;
    sq: TSquare;
    sum: Integer;
    count, i: Integer;
begin
    count := 0;

    for mask := 0 to 65535 do
    begin
        BuildSquareFromMask(mask, sq);
        if IsMagic(sq, sum) then
        begin
            for i := 0 to 15 do
                outList[count][i] := sq[i];
            Inc(count);
        end;
    end;

    CollectAllMagicSquares := count;
end;

{ Print a square }
procedure PrintSquare(const sq: TSquare);
var
    r, c: Integer;
    sum: Integer;
begin
    for r := 0 to 3 do
    begin
        for c := 0 to 3 do
            Write(sq[r * 4 + c], ' ');
        Writeln;
    end;

    IsMagic(sq, sum);
    Writeln('Magic sum: ', sum);
end;

var
    allSquares: array[0..4095] of TSquare;
    count, idx: Integer;

begin
    Randomize;

    count := CollectAllMagicSquares(allSquares);

    if count = 0 then
    begin
        Writeln('No magic squares found.');
        Halt(1);
    end;

    idx := Random(count);

    Writeln('Found ', count, ' valid 4×4 binary magic squares.');
    Writeln('Randomly selected one:');
    Writeln;

    PrintSquare(allSquares[idx]);
end.


{
run:

Found 34 valid 4×4 binary magic squares.
Randomly selected one:

1 1 0 0 
1 0 1 0 
0 1 0 1 
0 0 1 1 
Magic sum: 2

}

Answered: How to generate a random 4×4 binary magic square (using only 0 and 1) in C

Thu, 06 Aug 2026 05:38:58 +0000

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

/*
    ============================================================
    Generate a random 4×4 binary magic square (0/1 only).

    A valid square must satisfy:
      • All rows have the same sum.
      • All columns have the same sum.
      • Both diagonals have that same sum.

    This program:
      1. Represents each 4×4 grid as a 16‑bit integer.
      2. Converts each mask into a 4×4 square.
      3. Checks whether it is magic.
      4. Collects all valid squares.
      5. Chooses one uniformly at random.
    ============================================================
*/

typedef int Square[16];   /* 16 cells, row‑major order */

/* Build a square from a 16‑bit mask */
void buildSquareFromMask(unsigned mask, Square sq) {
    for (int i = 0; i < 16; ++i)
        sq[i] = (mask >> i) & 1;
}

/* Check whether a square is magic */
int isMagic(const Square sq, int *magicSum) {
    int rowSum[4] = {0}, colSum[4] = {0};
    int mainDiag = 0, antiDiag = 0;

    for (int r = 0; r < 4; ++r) {
        for (int c = 0; c < 4; ++c) {
            int v = sq[r * 4 + c];
            rowSum[r] += v;
            colSum[c] += v;
            if (r == c)         mainDiag += v;
            if (r == 3 - c)     antiDiag += v;
        }
    }

    *magicSum = rowSum[0];

    for (int r = 0; r < 4; ++r)
        if (rowSum[r] != *magicSum) return 0;

    for (int c = 0; c < 4; ++c)
        if (colSum[c] != *magicSum) return 0;

    return (mainDiag == *magicSum && antiDiag == *magicSum);
}

/* Collect all magic squares */
int collectAllMagicSquares(Square *out) {
    int count = 0;

    for (unsigned mask = 0; mask < 65536u; ++mask) {
        Square sq;
        buildSquareFromMask(mask, sq);

        int sum;
        if (isMagic(sq, &sum)) {
            for (int i = 0; i < 16; ++i)
                out[count][i] = sq[i];
            count++;
        }
    }

    return count;
}

/* Print a square */
void printSquare(const Square sq) {
    int sum;
    isMagic(sq, &sum);

    for (int r = 0; r < 4; ++r) {
        for (int c = 0; c < 4; ++c)
            printf("%d ", sq[r * 4 + c]);
        printf("\n");
    }

    printf("Magic sum: %d\n", sum);
}

int main() {
    /* Collect all valid magic squares */
    Square all[4096];
    int count = collectAllMagicSquares(all);

    if (count == 0) {
        printf("No magic squares found.\n");
        return 1;
    }

    /* Choose one at random */
    srand((unsigned)time(NULL));
    int idx = rand() % count;

    printf("Found %d valid 4×4 binary magic squares.\n", count);
    printf("Randomly selected one:\n\n");

    printSquare(all[idx]);

    return 0;
}


/*
run:

Found 34 valid 4×4 binary magic squares.
Randomly selected one:

0 1 0 1 
0 1 0 1 
1 0 1 0 
1 0 1 0 
Magic sum: 2

*/

Answered: How to generate a random 4×4 binary magic square (using only 0 and 1) in C++

Thu, 06 Aug 2026 05:33:07 +0000

#include <iostream>
#include <vector>
#include <array>
#include <random>

// A square is stored as 16 cells in row-major order: index = row*4 + col
using Square = std::array<int, 16>;

// Builds a 4x4 square from a 16-bit mask: bit i becomes cell i (0 or 1).
Square buildSquareFromMask(unsigned mask) {
    Square sq{};
    for (int i = 0; i < 16; ++i) {
        sq[i] = (mask >> i) & 1;
    }
    
    return sq;
}

// Checks whether a square is "magic": every row, every column, and both
// diagonals must all sum to the same value. Returns true and writes that
// common sum into magicSum if the square qualifies.
bool isMagic(const Square& sq, int& magicSum) {
    std::array<int, 4> rowSum{}, colSum{};
    int mainDiag = 0, antiDiag = 0;

    for (int r = 0; r < 4; ++r) {
        for (int c = 0; c < 4; ++c) {
            int v = sq[r * 4 + c];
            rowSum[r] += v;
            colSum[c] += v;
            if (r == c)         mainDiag += v; // top-left to bottom-right
            if (r == 3 - c)     antiDiag += v; // top-right to bottom-left
        }
    }

    magicSum = rowSum[0];
    for (int r = 0; r < 4; ++r) if (rowSum[r] != magicSum) return false;
    for (int c = 0; c < 4; ++c) if (colSum[c] != magicSum) return false;
    
    return mainDiag == magicSum && antiDiag == magicSum;
}

// Scans all 65,536 possible 4x4 binary grids and collects every one that
// satisfies the magic-square property. This exhaustive pass is cheap
// (constant-size, ~2^16 iterations) and guarantees we know the full
// population to sample from uniformly.
std::vector<Square> collectAllMagicSquares() {
    std::vector<Square> results;
    results.reserve(4096); // rough headroom; avoids repeated reallocations

    for (unsigned mask = 0; mask < 65536u; ++mask) {
        Square candidate = buildSquareFromMask(mask);
        int sum;
        if (isMagic(candidate, sum)) {
            results.push_back(candidate);
        }
    }
    
    return results;
}

// Prints a square in a readable grid layout, plus its magic sum.
void printSquare(const Square& sq) {
    for (int r = 0; r < 4; ++r) {
        for (int c = 0; c < 4; ++c) {
            std::cout << sq[r * 4 + c] << (c < 3 ? ' ' : '\n');
        }
    }
    int sum;
    isMagic(sq, sum);
    std::cout << "Magic sum per row/column/diagonal: " << sum << '\n';
}

int main() {
    // Step 1: build the full list of valid 4x4 binary magic squares once.
    std::vector<Square> allMagicSquares = collectAllMagicSquares();

    if (allMagicSquares.empty()) {
        std::cerr << "No magic squares found (unexpected).\n";
        return 1;
    }

    // Step 2: pick one uniformly at random using a proper random engine
    // (Mersenne Twister seeded from a hardware entropy source), rather
    // than relying on rand()/srand().
    std::random_device rd;
    std::mt19937 rng(rd());
    std::uniform_int_distribution<std::size_t> dist(0, allMagicSquares.size() - 1);

    const Square& chosen = allMagicSquares[dist(rng)];

    std::cout << "Found " << allMagicSquares.size()
              << " valid 4x4 binary magic squares.\n"
              << "Randomly selected one:\n\n";
    printSquare(chosen);
}


/*
run:

Found 34 valid 4x4 binary magic squares.
Randomly selected one:

1 0 0 1
0 1 1 0
1 0 0 1
0 1 1 0
Magic sum per row/column/diagonal: 2

*/

Answered: How to generate a random 4×4 binary magic square (using only 0 and 1) in Ruby

Wed, 05 Aug 2026 15:48:41 +0000

# ============================================================
# Generate a random 4×4 magic square containing only 0 and 1.
#
# A valid square must satisfy:
#   • All rows sum to the same target value.
#   • All columns sum to that same target value.
#   • Both diagonals also match that target value.
#
# The program:
#   1. Precomputes all 4‑bit binary rows.
#   2. Groups rows by their sum.
#   3. Generates *all* valid magic squares.
#   4. Picks one at random.
# ============================================================

# Generate all binary rows of length 4
def binary_rows
  (0..15).map { |n| "%04b" % n }.map { |s| s.chars.map(&:to_i) }
end

# Group rows by their sum
ROWS_BY_SUM = binary_rows.group_by(&:sum)

# Generate all magic squares
def generate_all_magic_squares
  results = []

  (0..4).each do |target|
    candidate_rows = ROWS_BY_SUM[target]

    square   = []
    col_sums = [0, 0, 0, 0]

    build = lambda do |row_index|
      if row_index == 4
        main_diag = square[0][0] + square[1][1] + square[2][2] + square[3][3]
        anti_diag = square[0][3] + square[1][2] + square[2][1] + square[3][0]

        if main_diag == target && anti_diag == target
          results << square.map(&:dup)
        end
        return
      end

      candidate_rows.each do |row|
        feasible = true
        4.times do |c|
          if col_sums[c] + row[c] > target
            feasible = false
            break
          end
        end
        next unless feasible

        square << row
        old_cols = col_sums.dup
        4.times { |c| col_sums[c] += row[c] }

        build.call(row_index + 1)

        square.pop
        col_sums.replace(old_cols)
      end
    end

    build.call(0)
  end

  results
end

# Pick a random magic square
all_squares = generate_all_magic_squares
random_square = all_squares.sample

puts "Random 4×4 binary magic square:"
random_square.each { |row| puts row.join(" ") }



# run:
#
# Random 4×4 binary magic square:
# 1 0 0 1
# 0 1 1 0
# 1 0 0 1
# 0 1 1 0
#

Answered: How to generate all 4×4 binary magic squares (using only 0 and 1) in Ruby

Wed, 05 Aug 2026 15:37:38 +0000

# ============================================================
# Generate all 4x4 magic squares containing only 0 and 1.
# A "magic square" here means:
#   - All rows sum to the same target
#   - All columns sum to the same target
#   - Both diagonals also sum to that same target
#
# Because entries are only 0 or 1, the row/column sums can only
# be 0, 1, 2, 3, or 4. We try all possibilities.
#
# The algorithm:
#   1. Precompute all 4‑element binary rows and group them by sum.
#   2. For each possible magic sum S:
#        - Build all 4‑row combinations whose row sums are S.
#        - Prune early by checking column sums as rows are added.
#        - When 4 rows are placed, check diagonals.
#   3. Collect and print all valid squares.
#
# This avoids brute‑forcing all 2^16 grids and instead uses
# structured pruning, which is dramatically faster.
# ============================================================

# Generate all binary rows of length 4
ROWS = (0..15).map { |n| "%04b" % n }.map { |s| s.chars.map(&:to_i) }

# Group rows by their sum
ROWS_BY_SUM = ROWS.group_by { |r| r.sum }

# Store results
magic_squares = []

# Try all possible magic sums
(0..4).each do |target_sum|
  candidate_rows = ROWS_BY_SUM[target_sum]

  # Backtracking search
  build = []

  # Column accumulator
  col_sums = [0, 0, 0, 0]

  # Recursive function to assemble rows
  define_method(:place_row) do |idx|
    # If 4 rows placed, check diagonals
    if idx == 4
      main_diag = build[0][0] + build[1][1] + build[2][2] + build[3][3]
      anti_diag = build[0][3] + build[1][2] + build[2][1] + build[3][0]
      if main_diag == target_sum && anti_diag == target_sum
        magic_squares << build.map(&:dup)
      end
      return
    end

    candidate_rows.each do |row|
      # Try placing this row
      valid = true

      # Update column sums and prune early
      4.times do |c|
        new_sum = col_sums[c] + row[c]
        # If column exceeds target sum, prune
        if new_sum > target_sum
          valid = false
          break
        end
      end

      next unless valid

      # Apply row
      build << row
      old_cols = col_sums.dup
      4.times { |c| col_sums[c] += row[c] }

      # Continue
      place_row(idx + 1)

      # Undo row
      build.pop
      col_sums.replace(old_cols)
    end
  end

  place_row(0)
end

# Print results
magic_squares.each_with_index do |sq, i|
  puts "Magic square ##{i + 1}:"
  sq.each { |row| puts row.join(" ") }
  puts
end



# run:
#
# Magic square #1:
# 0 0 0 0
# 0 0 0 0
# 0 0 0 0
# 0 0 0 0
#
# Magic square #2:
# 0 0 0 1
# 0 1 0 0
# 1 0 0 0
# 0 0 1 0
#
# Magic square #3:
# 0 0 0 1
# 1 0 0 0
# 0 0 1 0
# 0 1 0 0
#
# Magic square #4:
# 0 0 1 0
# 0 1 0 0
# 0 0 0 1
# 1 0 0 0
#
# Magic square #5:
# 0 0 1 0
# 1 0 0 0
# 0 1 0 0
# 0 0 0 1
#
# Magic square #6:
# 0 1 0 0
# 0 0 0 1
# 0 0 1 0
# 1 0 0 0
#
# Magic square #7:
# 0 1 0 0
# 0 0 1 0
# 1 0 0 0
# 0 0 0 1
#
# Magic square #8:
# 1 0 0 0
# 0 0 0 1
# 0 1 0 0
# 0 0 1 0
#
# Magic square #9:
# 1 0 0 0
# 0 0 1 0
# 0 0 0 1
# 0 1 0 0
#
# Magic square #10:
# 0 0 1 1
# 0 1 0 1
# 1 0 1 0
# 1 1 0 0
#
# Magic square #11:
# 0 0 1 1
# 1 1 0 0
# 0 0 1 1
# 1 1 0 0
#
# Magic square #12:
# 0 0 1 1
# 1 1 0 0
# 1 1 0 0
# 0 0 1 1
#
# Magic square #13:
# 0 1 0 1
# 0 1 0 1
# 1 0 1 0
# 1 0 1 0
#
# Magic square #14:
# 0 1 0 1
# 1 0 1 0
# 1 0 1 0
# 0 1 0 1
#
# Magic square #15:
# 0 1 0 1
# 1 1 0 0
# 0 0 1 1
# 1 0 1 0
#
# Magic square #16:
# 0 1 1 0
# 0 1 1 0
# 1 0 0 1
# 1 0 0 1
#
# Magic square #17:
# 0 1 1 0
# 1 0 0 1
# 0 1 1 0
# 1 0 0 1
#
# Magic square #18:
# 1 0 0 1
# 0 1 1 0
# 1 0 0 1
# 0 1 1 0
#
# Magic square #19:
# 1 0 0 1
# 1 0 0 1
# 0 1 1 0
# 0 1 1 0
#
# Magic square #20:
# 1 0 1 0
# 0 0 1 1
# 1 1 0 0
# 0 1 0 1

# Magic square #21:
# 1 0 1 0
# 0 1 0 1
# 0 1 0 1
# 1 0 1 0
#
# Magic square #22:
# 1 0 1 0
# 1 0 1 0
# 0 1 0 1
# 0 1 0 1
#
# Magic square #23:
# 1 1 0 0
# 0 0 1 1
# 0 0 1 1
# 1 1 0 0

# Magic square #24:
# 1 1 0 0
# 0 0 1 1
# 1 1 0 0
# 0 0 1 1
#
# Magic square #25:
# 1 1 0 0
# 1 0 1 0
# 0 1 0 1
# 0 0 1 1
#
# Magic square #26:
# 0 1 1 1
# 1 1 0 1
# 1 1 1 0
# 1 0 1 1
#
# Magic square #27:
# 0 1 1 1
# 1 1 1 0
# 1 0 1 1
# 1 1 0 1
#
# Magic square #28:
# 1 0 1 1
# 1 1 0 1
# 0 1 1 1
# 1 1 1 0
#
# Magic square #29:
# 1 0 1 1
# 1 1 1 0
# 1 1 0 1
# 0 1 1 1
#
# Magic square #30:
# 1 1 0 1
# 0 1 1 1
# 1 0 1 1
# 1 1 1 0
#
# Magic square #31:
# 1 1 0 1
# 1 0 1 1
# 1 1 1 0
# 0 1 1 1
#
# Magic square #32:
# 1 1 1 0
# 0 1 1 1
# 1 1 0 1
# 1 0 1 1
#
# Magic square #33:
# 1 1 1 0
# 1 0 1 1
# 0 1 1 1
# 1 1 0 1
#
# Magic square #34:
# 1 1 1 1
# 1 1 1 1
# 1 1 1 1
# 1 1 1 1
#

Answered: How to check whether a matrix is a magic square or not in Ruby

Wed, 05 Aug 2026 15:25:01 +0000

# This program checks whether a square matrix is a magic square.
# A magic square has:
#   1. All rows summing to the same value
#   2. All columns summing to the same value
#   3. Both main diagonals summing to that same value
#   4. The matrix must be square

# Compute the sum of each row
def row_sums(matrix)
  matrix.map { |row| row.sum }
end

# Compute the sum of each column
def column_sums(matrix)
  size = matrix.size
  (0...size).map { |col| matrix.map { |row| row[col] }.sum }
end

# Compute the two diagonal sums
def diagonal_sums(matrix)
  size = matrix.size
  main_diag     = (0...size).map { |i| matrix[i][i] }.sum
  secondary_diag = (0...size).map { |i| matrix[i][size - 1 - i] }.sum
  [main_diag, secondary_diag]
end

# Check whether the matrix is a magic square
def magic_square?(matrix)
  return false if matrix.empty?
  return false unless matrix.all? { |row| row.size == matrix.size }

  target = matrix[0].sum

  return false unless row_sums(matrix).all? { |s| s == target }
  return false unless column_sums(matrix).all? { |s| s == target }

  diag1, diag2 = diagonal_sums(matrix)
  return false unless diag1 == target && diag2 == target

  true
end

# Matrix
matrix = [
  [8, 1, 6],
  [3, 5, 7],
  [4, 9, 2]
]

puts "Matrix:"
matrix.each { |row| p row }

puts "\nIs magic square? #{magic_square?(matrix)}"


=begin
run:

Matrix:
[8, 1, 6]
[3, 5, 7]
[4, 9, 2]

Is magic square? true

=end

Answered: How to implement the merge sort algorithm in Python

Wed, 05 Aug 2026 15:06:22 +0000

# Merge sort implementation in Python.
# The algorithm works by:
#   1. Recursively splitting the list into two halves.
#   2. Sorting each half.
#   3. Merging the two sorted halves into one sorted list.
#
# This approach guarantees O(n log n) time complexity and stable sorting.

def merge(left, right):
    """
    Merge two sorted lists into one sorted list.
    The function walks through both lists and picks the smallest
    available element each time.
    """
    merged = []
    i = j = 0

    # Compare elements from both lists and append the smaller one
    while i < len(left) and j < len(right):
        if left[i] <= right[j]:
            merged.append(left[i])
            i += 1
        else:
            merged.append(right[j])
            j += 1

    # Append any remaining elements
    merged.extend(left[i:])
    merged.extend(right[j:])

    return merged


def merge_sort(arr):
    """
    Recursively sort a list using merge sort.
    If the list has length 0 or 1, it is already sorted.
    Otherwise, split it, sort each half, and merge.
    """
    if len(arr) <= 1:
        return arr

    mid = len(arr) // 2
    left_sorted = merge_sort(arr[:mid])
    right_sorted = merge_sort(arr[mid:])

    return merge(left_sorted, right_sorted)


if __name__ == "__main__":
    data = [38, 27, 43, 3, 9, 82, 10]
    result = merge_sort(data)

    print("Original:", data)
    print("Sorted:", result)



"""
run:

Original: [38, 27, 43, 3, 9, 82, 10]
Sorted: [3, 9, 10, 27, 38, 43, 82]

"""

How to search a string using bitwise operators C

Wed, 05 Aug 2026 09:47:43 +0000

How to search a string using bitwise operators C++

Wed, 05 Aug 2026 09:33:49 +0000

How to calculate the volume of a cube in Swift

Tue, 04 Aug 2026 15:40:17 +0000