Ada Interview Questions with Answers

with Ada.Text_IO; use Ada.Text_IO;

procedure Main is
begin
   Put_Line("Hello, World!");
end Main;

-- Declaration
X : Integer := 10;

Pi : constant Float := 3.14;

if X > 0 then
   Put_Line("Positive");
end if;

for I in 1..10 loop
   Put_Line(Integer'Image(I));
end loop;

type My_Array is array (1..5) of Integer;
A : My_Array;

type Person is record
   Name : String(1..20);
   Age  : Integer;
end record;

begin
   -- Potentially unsafe operation
   X := Y / Z;
exception
   when Constraint_Error =>
      Put_Line("Division by zero or overflow!");
end;

procedure Main is
begin
   Put_Line("Main entry execution");
end Main;

task type Worker is
   entry Start;
end Worker;

task body Worker is
begin
   accept Start;
   Put_Line("Task is running concurrently.");
end Worker;

accept Start do
   -- Synchronized mutual-exclusion zone
   Put_Line("Rendezvous active");
end Start;

generic
   type Element is private;
procedure Swap(A, B : in out Element);

subtype Positive_Integer is Integer range 1 .. Integer'Last;

type Int_Ptr is access Integer;
My_Ptr : Int_Ptr;

type Instrument is tagged record
   ID   : Integer;
   Name : String(1..10);
end record;

protected body Semaphore is
   entry Wait when Count > 0 is
   begin
      Count := Count - 1;
   end Wait;
   procedure Signal is
   begin
      Count := Count + 1;
   end Signal;
end Semaphore;

procedure Display(Item : Integer);
procedure Display(Item : Float);

procedure Recursive_Print (N : Positive) is
begin
   if N > 0 then
      Recursive_Print (N - 1);
      Put_Line (Integer'Image (N));
   end if;
end Recursive_Print;

pragma Optimize(Time);

procedure Test is
   type Small is range -10 .. 10;
   X : Small;
begin
   X := 5;
end Test;

type Int_Ptr is access Integer;
My_Ptr : Int_Ptr;

type Buffer(Size : Positive) is record
   Data : String(1 .. Size);
end record;

task Server is
   entry Get_Status(Code : out Integer);
end Server;

delay 2.5;  -- Pause task execution for 2.5 seconds

pragma Priority(Interrupt_Priority'Last);

pragma Profile(Ravenscar);

procedure Deposit(Amount : Positive)
   with Pre  => Amount > 0,
        Post => Balance = Balance'Old + Amount;

procedure Safety_Critical_Process
   with SPARK_Mode => On;

type Color is (Red, Green, Blue);

procedure Print (S : String) is
begin
   Put_Line(S);
end Print;

function Add (A, B : Integer) return Integer is
begin
   return A + B;
end Add;

package Stack is
   procedure Push (Item : Integer);
   function Pop return Integer;
end Stack;

package body Stack is
   ...
end Stack;

case X is
   when 1 => Put_Line("One");
   when 2 => Put_Line("Two");
   when others => Put_Line("Other");
end case;

while X > 0 loop
   X := X - 1;
end loop;

type My_Enum is (Apple, Banana, Orange);

type My_Array_2D is array (1..3, 1..3) of Integer;

type My_String is String (1..10);

type My_Access is access all Integer;

type My_Tagged is tagged null record;

protected type Semaphore is
   entry Wait;
   procedure Signal;
private
   Count : Natural := 0;
end Semaphore;

protected body Semaphore is
   entry Wait when Count > 0 is
   begin
      Count := Count - 1;
   end Wait;
   procedure Signal is
   begin
      Count := Count + 1;
   end Signal;
end Semaphore;

function Square (X : Integer) return Integer is
begin
   return X * X;
end Square;

procedure Recursive_Print (N : Positive) is
begin
   if N > 0 then
      Recursive_Print (N - 1);
      Put_Line (Integer'Image (N));
   end if;
end Recursive_Print;

pragma Inline (Square);

pragma Preelaborate (My_Package);

pragma Restrictions (No_Tasking);

procedure Test is
   type Small is range -10 .. 10;
   X : Small;
begin
   X := 5;
end Test;

type Rec (D : Boolean) is record
   case D is
      when True  => I : Integer;
      when False => F : Float;
   end case;
end record;

task T1;
task T2;
-- ...

select
   accept Entry1;
   ...
or
   accept Entry2;
   ...
end select;

protected type Buffer is
   entry Put (Item : Integer);
   entry Get (Item : out Integer);
private
   Data : Integer;
   Empty : Boolean := True;
end Buffer;

function Power (Base : Integer; Exp : Natural) return Integer is
   Result : Integer := 1;
begin
   for I in 1..Exp loop
      Result := Result * Base;
   end loop;
   return Result;
end Power;

generic
   type Element is private;
package Generic_Container is
   procedure Insert (Item : Element);
   function Lookup (Key : Integer) return Element;
end Generic_Container;

type My_Integer is range 0 .. 100;

type My_Real is digits 6;  -- 6 decimal digits

type My_Fixed is delta 0.01 range -100.0 .. 100.0;

function Sqrt (X : Float) return Float is
begin
   return X ** 0.5;
end Sqrt;

procedure Swap (A, B : in out Integer) is
   Temp : Integer;
begin
   Temp := A;
   A := B;
   B := Temp;
end Swap;

type My_Enum is (One, Two, Three);
for My_Enum use (One => 1, Two => 2, Three => 3);

type My_Record is record
   A : Integer;
   B : Float;
end record;

for My_Record use record
   A at 0 range 0 .. 31;
   B at 4 range 0 .. 31;
end record;

type Day is (Monday, Tuesday, Wednesday, Thursday, Friday, Saturday, Sunday);

function Is_Weekend (D : Day) return Boolean is
begin
   return D = Saturday or D = Sunday;
end Is_Weekend;

pragma Assert (X > 0, "X must be positive");

pragma Debug (Put_Line ("Entering procedure"));

type My_Mod is mod 256;

task body Periodic_Task is
   Running : Boolean := True;
begin
   accept Start;
   while Running loop
      delay 1.0;
      Put_Line ("Tick");
      select
         accept Stop;
         Running := False;
      or
         delay 0.0;
      end select;
   end loop;
end Periodic_Task;

function Is_Prime (N : Positive) return Boolean is
   Result : Boolean := True;
begin
   if N < 2 then
      return False;
   end if;
   for I in 2 .. Natural (Sqrt (Float (N))) loop
      if N mod I = 0 then
         return False;
      end if;
   end loop;
   return True;
end Is_Prime;

procedure Sort (Arr : in out Integer_Array) is
   Temp : Integer;
begin
   for I in Arr'First .. Arr'Last - 1 loop
      for J in Arr'First .. Arr'Last - I - 1 loop
         if Arr (J) > Arr (J + 1) then
            Temp := Arr (J);
            Arr (J) := Arr (J + 1);
            Arr (J + 1) := Temp;
         end if;
      end loop;
   end loop;
end Sort;

function Binary_Search (Arr : Integer_Array; Target : Integer) return Integer is
   Low  : Integer := Arr'First;
   High : Integer := Arr'Last;
   Mid  : Integer;
begin
   while Low <= High loop
      Mid := (Low + High) / 2;
      if Target = Arr (Mid) then
         return Mid;
      elsif Target < Arr (Mid) then
         High := Mid - 1;
      else
         Low := Mid + 1;
      end if;
   end loop;
   return -1;  -- Not found
end Binary_Search;

function Fibonacci (N : Natural) return Natural is
begin
   if N <= 1 then
      return N;
   else
      return Fibonacci (N - 1) + Fibonacci (N - 2);
   end if;
end Fibonacci;

procedure Quick_Sort (Arr : in out Integer_Array; Low, High : Integer) is
   Pivot : Integer;
   I, J  : Integer;
begin
   if Low < High then
      Pivot := Arr (High);
      I := Low;
      for J in Low .. High - 1 loop
         if Arr (J) < Pivot then
            Swap (Arr (I), Arr (J));
            I := I + 1;
         end if;
      end loop;
      Swap (Arr (I), Arr (High));
      Quick_Sort (Arr, Low, I - 1);
      Quick_Sort (Arr, I + 1, High);
   end if;
end Quick_Sort;

type Node is record
   Value : Integer;
   Next  : access Node;
end record;

type Root is tagged null record;
procedure Method (Obj : Root);

type Child is new Root with record
   Extra : Integer;
end record;
overriding procedure Method (Obj : Child);

type String_Access is access String;

function Is_Equal (A, B : String) return Boolean is
begin
   if A'Length /= B'Length then
      return False;
   end if;
   for I in A'Range loop
      if A(I) /= B(I) then
         return False;
      end if;
   end loop;
   return True;
end Is_Equal;

procedure Print_Matrix (M : Matrix) is
begin
   for I in M'Range (1) loop
      for J in M'Range (2) loop
         Put (Integer'Image (M (I, J)));
      end loop;
      New_Line;
   end loop;
end Print_Matrix;

function Factorial (N : Natural) return Natural is
begin
   if N = 0 then
      return 1;
   else
      return N * Factorial (N - 1);
   end if;
end Factorial;

procedure GCD (A, B : Positive; Result : out Positive) is
   X, Y : Positive := A, B;
begin
   while X /= Y loop
      if X > Y then X := X - Y; else Y := Y - X; end if;
   end loop;
   Result := X;
end GCD;

function Pow (Base : Integer; Exp : Natural) return Integer is
begin
   if Exp = 0 then
      return 1;
   else
      return Base * Pow (Base, Exp - 1);
   end if;
end Pow;

pragma Suppress (Index_Check);

pragma Detect_Blocking;

package My_Package is
   type My_Type is private;
   procedure Set (Item : My_Type; Value : Integer);
   function Get (Item : My_Type) return Integer;
private
   type My_Type is record
      Value : Integer;
   end record;
end My_Package;

package body My_Package is
   procedure Set (Item : My_Type; Value : Integer) is
   begin
      Item.Value := Value;
   end Set;
   function Get (Item : My_Type) return Integer is
   begin
      return Item.Value;
   end Get;
end My_Package;

with Ada.Real_Time; use Ada.Real_Time;

procedure Periodic is
   Period : constant Time_Span := Milliseconds (100);
   Next   : Time := Clock + Period;
begin
   loop
      delay until Next;
      Put_Line ("Tick");
      Next := Next + Period;
   end loop;
end Periodic;

type Byte is mod 256;
for Byte'Size use 8;

type My_Enum is (A, B, C);
for My_Enum'Size use 8;

pragma Pack (My_Record);

pragma Unsuppress (All_Checks);

type My_Record is record
   A : Integer;
   B : Float;
end record;

for My_Record'Alignment use 4;

procedure My_Procedure (Param : in Integer) is
   Local : Integer := Param;
begin
   Local := Local + 1;
end My_Procedure;

function Max (A, B : Integer) return Integer is
begin
   if A > B then return A; else return B; end if;
end Max;

procedure Swap (A, B : in out Integer) is
   T : Integer := A;
begin
   A := B;
   B := T;
end Swap;

type My_Array is array (Positive range <>) of Integer;