Ada - How do I split a string in two parts?-CodePudding

If I create a subprogram of type function that for instance orders you to type a string of a particular length and you type Overflow, it's supposed to type the last half of the string, so in this case it would be flow. But on the other end if I type an odd number of characters like Stack it's supposed to type the last half of the string the middle letter, so in this case it would be "ack".

Let me make it clearer (text in bold is user input):

Type a string that's not longer than 7 characters: Candy

The other half of the string is: ndy

     with Ada.Text_IO;         use Ada.Text_IO;
        with Ada.Integer_Text_IO; use Ada.Integer_Text_IO;

         function Split_String (S : in String) return String is 
   
      
   begin
      
      Mid := 1   (S'Length / 2);
      
      return S(Mid .. S'Last);
      
   
   end Split_String;
      
              
           S : String(1 .. 7);
           I : Integer;
        
        begin
          
   Put("Type a string that's no longer than 7 characters: ");
   Get_Line(S, I);
   Put(Split_String(S));
   
        end Split;

Let me tell you how I've been thinking. So I do a Get_Line to see how many characters the string contains. I then put I in my subprogram to determine if its evenly dividable by two or not. If it's dividable by two, the rest should be 0, thus it'll mean that typing out the other half of the string THE MIDDLE CHARACTER is not needed. If in all the other cases, it's not dividable by two I have to type out the other half of the string the middle character. But now I stumbled upon a big problem in my main program. I don't know how type out the other half of a string. If a string contains 4 words I can just type out Put(S(3 .. 4); but the thing is that I don't know a general formula for this. Help is appreciated! :) Have a good day!

CodePudding user response：

You need a more general approach to your problem. Also, try to understand how Get_Line works for you.

For example, if you declare an input string with a large size such as

Input : String (1..1024);

You will have a string large enough to work with any likely input values. Next, you need a variable to indicate how many characters were actually read by Get_Line.

Length : Natural;

The data returned by Get_Line will then be in the slice of the input string designated as

Input (1 .. Length);

Pass that slice to your function to return the second half of the string.

function last_half(S : string) return string;

last_half(Input(1..Length));

Now all you need is to calculate the last half of the string passed to the function last_half. The function will output a slice of the string passed to it. To find the first index of the last half of the input string you must perform the calculation

mid : Positive := 1   (S'length / 2);

Then simply return the string S(mid .. S'Last).

It appears that the goal of this exercise is to learn how to use array slices. Concentrate on how slices work for you in the problem and the solution will be very simple.

One possible solution is

with Ada.Text_IO; use Ada.Text_IO;

procedure Main is
   Input  : String (1 .. 1_024);
   Length : Natural;

   function last_half (S : in String) return String is
      Mid : Positive := 1   (S'Length / 2);
   begin
      return S (Mid .. S'Last);
   end last_half;

begin
   Put ("Enter a string: ");
   Get_Line (Input, Length);
   Put_Line (Input (1 .. Length) & " : " & last_half (Input (1 .. Length)));
end Main;

Study how the solution uses array slices on the return value of Get_Line and on the parameter for the function last_half and on its return statement. It is also important to remember that the type String is defined as an unbounded array of character. This means that every slice of a string is also a string.

type String is array ( Positive range <> ) of Character;

CodePudding user response：

Aside from being an untidy mess, your latest code edit (as of 20:11 GMT on 15 Nov 2021) doesn’t even compile. Please don’t show us code like this! (unless, of course, that’s the problem).

I’d like to strongly suggest this alternate way of inputting strings:

declare
   S : constant String := Get_Line;
begin
   --  do things with S, which is exactly as long as 
   --  the input you typed: no undefined characters at
   --  the end to confuse the result, no need to worry
   --  about overrunning an input buffer
end;

With this change, and obvious syntactic changes, your current code will do what you want.