Conjugate a Latin verb

From Rosetta Code
Revision as of 21:39, 20 December 2021 by Peak (talk | contribs) (→‎{{header|jq}}: Part 2)
Conjugate a Latin verb is a draft programming task. It is not yet considered ready to be promoted as a complete task, for reasons that should be found in its talk page.

Basic Data Operation
This is a basic data operation. It represents a fundamental action on a basic data type.

You may see other such operations in the Basic Data Operations category, or:

Integer Operations
Arithmetic | Comparison

Boolean Operations
Bitwise | Logical

String Operations
Concatenation | Interpolation | Comparison | Matching

Memory Operations
Pointers & references | Addresses

Task
Create a program that can take a Latin verb and conjugate it, displaying in the following order:
1st person singular
2nd person singular
3rd person singular
1st person plural
2nd person plural
3rd person plural
  • Each should be on its own line.
  • Have at least one example from each of the 4 conjugations.
  • Irregular verbs are not required.
  • Translation into English is optional.


Other tasks related to string operations:
Metrics
Counting
Remove/replace
Anagrams/Derangements/shuffling
Find/Search/Determine
Formatting
Song lyrics/poems/Mad Libs/phrases
Tokenize
Sequences


See also



ALGOL 68

<lang algol68>BEGIN # print some Latin verb conjugations # 

   PROC s length = ( STRING s )INT: ( UPB s + 1 ) - LWB s;      # calculates the length of s #
   # prints the cojugations of lv or an error message if we don't know how to conjugate lv #
   PROC print conjugations = ( STRING lv )VOID:
        IF   []STRING ending    = ( "are", "ēre", "ere", "ire" );
             INT length         = s length( lv );
             INT conjugation   := 0;
             INT ending length := 0;
             BOOL long enough  := FALSE;
             FOR i FROM LWB ending TO UPB ending WHILE conjugation = 0 DO
                 ending length := s length( ending[ i ] );
                 IF ending length < length
                 THEN
                     # the word is long enough for at least one ending #
                     long enough := TRUE;
                     IF lv[ ( UPB lv + 1 ) - ending length : ] = ending[ i ]
                     THEN
                         conjugation := i
                     FI
                 FI
             OD;
             NOT long enough
        THEN
             print( ( """", lv, """ is not long enough to conjugate", newline ) )
        ELIF conjugation = 0
        THEN
            print( ( "Don't know how to conjugate """, lv, """", newline ) )
        ELSE
            [,]STRING suffix =  ( (  "o", "as", "at", "amus", "atis",  "ant" )
                                , ( "eo", "es", "et", "emus", "etis",  "ent" )
                                , (  "o", "is", "it", "imus", "itis",  "unt" )
                                , ( "io", "is", "it", "imus", "itis", "iunt" )
                                );
            STRING prefix = lv[ : UPB lv - ending length ];
            print( ( "    Conjugations of """, lv, """:", newline ) );
            FOR i FROM 2 LWB suffix TO 2 UPB suffix DO
                print( ( "        ", prefix, suffix[ conjugation, i ], newline ) )
            OD
        FI # print confugations # ;
   print( ( "Present Indicative conjugation:", newline ) );
   print conjugations( "amare"  );
   print conjugations( "monēre" );
   print conjugations( "tegere" );
   print conjugations( "venire" );
   print conjugations( "qwerty" );
   print conjugations( "are"    )

END </lang>

Output:
Present Indicative conjugation:
    Conjugations of "amare":
        amo
        amas
        amat
        amamus
        amatis
        amant
    Conjugations of "monēre":
        moneo
        mones
        monet
        monemus
        monetis
        monent
    Conjugations of "tegere":
        tego
        tegis
        tegit
        tegimus
        tegitis
        tegunt
    Conjugations of "venire":
        venio
        venis
        venit
        venimus
        venitis
        veniunt
Don't know how to conjugate "qwerty"
"are" is not long enough to conjugate

F#

<lang fsharp> // Conjugate a Latin Verb. Nigel Galloway: September 17th., 2021 let myLatin (n:string)=printfn "Rogatus sum iungere verbum %s" n 

                      match n.Length>3,n.[-3..]="are" with 
                       (false,_)|(_,false)->printfn "    facis quod"
                      |_->["o";"as";"at";"amus";"atis";"ant"]|>List.iter(fun g->printfn "    %s%s" n.[0.. -4] g)

myLatin "amare" myLatin "creo" </lang>

Output:
Rogatus sum iungere verbum amare
    amo
    amas
    amat
    amamus
    amatis
    amant
Rogatus sum iungere verbum creo
    facis quod

Factor

Works with: Factor version 0.99 2021-06-02

<lang factor>USING: formatting io kernel math qw sequences ;

CONSTANT: pronouns { 

   "I"
   "you"
   "he, she, it"
   "we"
   "you all"
   "they"

}

CONSTANT: endings qw{ ō ās at āmus ātis ant }

first-conjugation? ( str -- ? )
   qw{ are āre } [ tail? ] with any? ;
check-first-conjugation ( str -- )
   first-conjugation?
   [ "Input must end with 'are' or 'āre'." throw ] unless ;
check-length ( str -- )
   length 3 >
   [ "Input too short to conjugate." throw ] unless ;
check-input ( str -- )
   [ check-first-conjugation ] [ check-length ] bi ;
conjugate ( str -- seq )
   dup check-input 3 head* endings [ append ] with map ;
he/she/it ( str -- newstr )
   "s" append dup dup "he %s, she %s, it %s" sprintf ;
english ( str -- seq )
   pronouns [ 2 = [ nip he/she/it ] [ " " glue ] if ] with
   map-index ;
conjugate. ( la en -- )
   la en "Present active indicative conjugations of %s (%s):\n"
   printf la conjugate en english [ "  %-10s%s\n" printf ] 2each ;

"amāre" "love" conjugate. nl "dāre" "give" conjugate.</lang>

Output:
Present active indicative conjugations of amāre (love):
  amō       I love
  amās      you love
  amat      he loves, she loves, it loves
  amāmus    we love
  amātis    you all love
  amant     they love

Present active indicative conjugations of dāre (give):
  dō        I give
  dās       you give
  dat       he gives, she gives, it gives
  dāmus     we give
  dātis     you all give
  dant      they give

Go

Translation of: Wren

The 'extended' version. <lang go>package main

import ( 

   "fmt"
   "log"

)

var endings = [][]string{ 

   {"o", "as", "at", "amus", "atis", "ant"},
   {"eo", "es", "et", "emus", "etis", "ent"},
   {"o", "is", "it", "imus", "itis", "unt"},
   {"io", "is", "it", "imus", "itis", "iunt"},

}

var infinEndings = []string{"are", "ēre", "ere", "ire"}

var pronouns = []string{"I", "you (singular)", "he, she or it", "we", "you (plural)", "they"}

var englishEndings = []string{"", "", "s", "", "", ""}

func conjugate(infinitive, english string) { 

   letters := []rune(infinitive)
   le := len(letters)
   if le < 4 {
       log.Fatal("Infinitive is too short for a regular verb.")
   }
   infinEnding := string(letters[le-3:])
   conj := -1
   for i, s := range infinEndings {
       if s == infinEnding {
           conj = i
           break
       }
   }
   if conj == -1 {
       log.Fatalf("Infinitive ending -%s not recognized.", infinEnding)
   }
   stem := string(letters[:le-3])
   fmt.Printf("Present indicative tense, active voice, of '%s' to '%s':\n", infinitive, english)
   for i, ending := range endings[conj] {
       fmt.Printf("    %s%-4s  %s %s%s\n", stem, ending, pronouns[i], english, englishEndings[i])
   }
   fmt.Println()

}

func main() { 

   pairs := [][2]string{{"amare", "love"}, {"vidēre", "see"}, {"ducere", "lead"}, {"audire", "hear"}}
   for _, pair := range pairs {
       conjugate(pair[0], pair[1])
   }

}</lang>

Output:
Present indicative tense, active voice, of 'amare' to 'love':
    amo     I love
    amas    you (singular) love
    amat    he, she or it loves
    amamus  we love
    amatis  you (plural) love
    amant   they love

Present indicative tense, active voice, of 'vidēre' to 'see':
    video    I see
    vides    you (singular) see
    videt    he, she or it sees
    videmus  we see
    videtis  you (plural) see
    vident   they see

Present indicative tense, active voice, of 'ducere' to 'lead':
    duco     I lead
    ducis    you (singular) lead
    ducit    he, she or it leads
    ducimus  we lead
    ducitis  you (plural) lead
    ducunt   they lead

Present indicative tense, active voice, of 'audire' to 'hear':
    audio    I hear
    audis    you (singular) hear
    audit    he, she or it hears
    audimus  we hear
    auditis  you (plural) hear
    audiunt  they hear

jq

Translation of: Wren
Works with: jq

Works with gojq, the Go implementation of jq

Part 1

<lang jq>def conjugate: 

 if endswith("are") | not
 then "\(.) is not a first conjugation verb." | error
 else .[0:-3] as $stem
 | if $stem|length == 0 then "Stem cannot be empty." | error
   else "Present indicative tense of '\(.)':",
       ( "o", "as", "at", "amus", "atis", "ant" 
        | "  " + $stem + .),

"" 

   end
 end;

("amare", "dare") | conjugate</lang>

Output:

As for #Wren.

Part 2

<lang>def rpad($len): tostring | ($len - length) as $l | . + (" " * $l)[:$l];

def endings: [ 

   [ "o", "as", "at", "amus", "atis",  "ant"],
   ["eo", "es", "et", "emus", "etis",  "ent"],
   [ "o", "is", "it", "imus", "itis",  "unt"],
   ["io", "is", "it", "imus", "itis", "iunt"]

];

def infinEndings: ["are", "ēre", "ere", "ire"];

def pronouns: ["I", "you (singular)", "he, she or it", "we", "you (plural)", "they"];

def englishEndings: [ "", "", "s", "", "", "" ];

def conjugate($infinitive; $english): 

 def letters:  [explode[] | [.] | implode];
 ($infinitive|letters) as $letters
 | if $letters|length < 4 then "Infinitive is too short for a regular verb." | error
   else ($letters[-3:]|join("")) as $infinEnding
   |  (infinEndings | index($infinEnding)) as $conj
   | if $conj == null then "Infinitive ending -\($infinEnding) not recognized." | error
     else ($letters[:-3]|join("")) as $stem
     | "Present indicative tense, active voice, of '\(infinitive)' to '\($english)':",
       foreach endings[$conj][] as $ending (-1; .+1;
         "    \($stem + $ending|rpad(8)) \(pronouns[.]) \($english)\(englishEndings[.])" )
     end
  end;

def pairs: [["amare", "love"], ["vidēre", "see"], ["ducere", "lead"], ["audire", "hear"]];

pairs[] | conjugate(.[0]; .[1])</lang>

Output:

As for #Wren.

Julia

<lang julia>const conjugators = ["ō", "ās", "at", "āmus", "ātis", "ant"] conjugate(w, gregex = r"[aā]re$") = (r = replace(w, gregex => ""); [r * s for s in conjugators])

function testregularconjugation(verbvector) 

   for verb in verbvector
       println("\nPresent active indicative conjugation of $verb:")
       for result in conjugate(verb)
           println(result)
       end
   end

end

testregularconjugation(["amāre", "dare"])

</lang>

Output:
Present active indicative conjugation of amāre:
amō
amās
amat
amāmus
amātis
amant

Present active indicative conjugation of dare:
dō
dās
dat
dāmus
dātis
dant

Nim

Translation of: Go
Works with: Nim version 1.6.0

<lang Nim>import std/[strformat, unicode]

const 

 Endings = [["o", "as", "at", "amus", "atis", "ant"],
            ["eo", "es", "et", "emus", "etis", "ent"],
            ["o", "is", "it", "imus", "itis", "unt"],
            ["io", "is", "it", "imus", "itis", "iunt"]]
 InfinEndings = ["are", "ēre", "ere", "ire"]
 Pronouns = ["I", "you (singular)", "he, she or it", "we", "you (plural)", "they"]
 EnglishEndings = ["", "", "s", "", "", ""]


proc conjugate(infinitive, english: string) = 

 let letters = infinitive.toRunes()
 if letters.len < 4:
   raise newException(ValueError, "infinitive is too short for a regular verb.")
 let infinEnding = $letters[^3..^1]
 let conj = InfinEndings.find(infinEnding)
 if conj == -1:
   raise newException(ValueError, &"infinitive ending -{infinEnding} not recognized.")
 let stem = $letters[0..^4]
 echo &"Present indicative tense, active voice, of '{infinitive}' to '{english}':"
 for i, ending in Endings[conj]:
   echo &"    {stem}{ending:4}  {Pronouns[i]} {english}{EnglishEndings[i]}"
 echo()


for (infinitive, english) in {"amare": "love", "vidēre": "see", "ducere": "lead", "audire": "hear"}: 

 conjugate(infinitive, english)</lang>
Output:
Present indicative tense, active voice, of 'amare' to 'love':
    amo     I love
    amas    you (singular) love
    amat    he, she or it loves
    amamus  we love
    amatis  you (plural) love
    amant   they love

Present indicative tense, active voice, of 'vidēre' to 'see':
    video    I see
    vides    you (singular) see
    videt    he, she or it sees
    videmus  we see
    videtis  you (plural) see
    vident   they see

Present indicative tense, active voice, of 'ducere' to 'lead':
    duco     I lead
    ducis    you (singular) lead
    ducit    he, she or it leads
    ducimus  we lead
    ducitis  you (plural) lead
    ducunt   they lead

Present indicative tense, active voice, of 'audire' to 'hear':
    audio    I hear
    audis    you (singular) hear
    audit    he, she or it hears
    audimus  we hear
    auditis  you (plural) hear
    audiunt  they hear

Perl

Translation of: Raku

<lang perl>use strict; use warnings; use feature 'say'; use utf8; binmode STDOUT, ':utf8';

sub conjugate { 

   my($verb) = shift;
   join "\n", map { $verb . $_ } qw<ō ās at āmus ātis ant>;

}

for my $infinitive ('amāre', 'dare') { 

   say "\nPresent active indicative conjugation of infinitive $infinitive.";
   my($verb) = $infinitive =~ /^ (\w+) [aā] re $/x;
   say $verb ? conjugate $verb : "Sorry, don't know how to conjugate $infinitive"

</lang>

Output:
Present active indicative conjugation of infinitive amāre.
amō
amās
amat
amāmus
amātis
amant

Present active indicative conjugation of infinitive dare.
dō
dās
dat
dāmus
dātis
dant

Phix

TL; DR: Did just one term of Latin, right before posting this realised 'dāre' should probably be 'dare', left as an exercise... 

with javascript_semantics
constant {ending,endings} = columnize({{"āre",split("ō ās at āmus ātis ant")},
                                       {"ēre",split("eō ēs et ēmus ētis ent")},
                                       {"ere",split("ō is it imus itis unt")},
                                       {"īre",split("iō īs it īmus ītis iunt")}}),
         pronouns = {"I %s", "you %s", "he %ss, she %ss, it %ss", "we %s", "you all %s", "they %s"}

procedure conjugate(sequence ie)
    string {infinitive,english} = ie
    sequence utf32 = utf8_to_utf32(infinitive)
    assert(length(utf32)>3,"Infinitive is too short for a regular verb.")
    string stem = utf32_to_utf8(utf32[1..-4]),
           last3 = utf32_to_utf8(utf32[-3..-1])
    integer edx = find(last3,ending)
    assert(edx!=0,"Infinitive ending -%s not recognized.",{last3}) 
    printf(1,"Present active indicative conjugations of '%s' (%s):\n",ie)
    for i=1 to length(endings[edx]) do
        string c = sprintf("%s%s",{stem,endings[edx][i]}),
               e = substitute(pronouns[i],"%s",english)
        printf(1,"  %-7s  %s\n",{c,e})
    end for
    printf(1,"\n")
end procedure
 
printf(0,"",{"unicode_align",true})
papply({{"amāre","love"},{"dāre","give"},{"vidēre","see"},{"dūcere","lead"},{"audīre","hear"}},conjugate)
Output:
Present active indicative conjugations of 'amāre' (love):
  amō      I love
  amās     you love
  amat     he loves, she loves, it loves
  amāmus   we love
  amātis   you all love
  amant    they love

Present active indicative conjugations of 'dāre' (give):
  dō       I give
  dās      you give
  dat      he gives, she gives, it gives
  dāmus    we give
  dātis    you all give
  dant     they give

Present active indicative conjugations of 'vidēre' (see):
  videō    I see
  vidēs    you see
  videt    he sees, she sees, it sees
  vidēmus  we see
  vidētis  you all see
  vident   they see

Present active indicative conjugations of 'dūcere' (lead):
  dūcō     I lead
  dūcis    you lead
  dūcit    he leads, she leads, it leads
  dūcimus  we lead
  dūcitis  you all lead
  dūcunt   they lead

Present active indicative conjugations of 'audīre' (hear):
  audiō    I hear
  audīs    you hear
  audit    he hears, she hears, it hears
  audīmus  we hear
  audītis  you all hear
  audiunt  they hear

Raku

Translation of Julia.

<lang perl6>for <amāre dare> -> $infinitive { 

   say "\nPresent active indicative conjugation of infinitive $infinitive.";
   my $verb = ($infinitive ~~ /^ (\w+) ['a'|'ā'] 're' $/)[0];
   say $verb ?? (conjugate $verb) !! "Sorry, don't know how to conjugate $infinitive"

}

sub conjugate ($verb) { ($verb X~ <ō ās at āmus ātis ant>).join: "\n" }</lang>

Output:
Present active indicative conjugation of infinitive amāre.
amō
amās
amat
amāmus
amātis
amant

Present active indicative conjugation of infinitive dare.
dō
dās
dat
dāmus
dātis
dant

REXX

Checks were also made to ensure the Latin verb has only Latin letters (upper and/or lower case). <lang rexx>/*REXX pgm conjugates (to the terminal) a Latin verb when given a first conjugation verb*/ parse arg verbs if verbs= | verbs="," then verbs= 'amare dare' suffix= 'o as at amus atis ant' /*a list of six Latin verb suffixes. */

  1. = words(verbs) /*obtain the # of Latin verbs specified*/
     do j=1  for #;                  say        /*process each      "     "       "    */
     $= word(verbs, j);  $$= $;      upper $$   /*obtain one of the "     "       "    */
     if \datatype($, 'M')  then call ser "the following isn't a Latin verb: "      $
     L= length($)                               /*obtain the length of a Latin verb.   */
     if L<4  then call ser 'length of Latin verb is too short: '     $
     if right($$, 3)\=='ARE'  then call ser "the following isn't a Latin verb: "   $
     stem= left($, length($) - 3)               /*obtain the stem of the Latin verb.   */
     say center(' present indicative tense of "'$'"', 50, "─")

        do k=1  for words(suffix)               /*display each of the verb suffixes.   */
        say left(,21) stem || word(suffix, k) /*display a Latin verb stem with auffix*/
        end   /*k*/
     say
     end      /*j*/

exit 0 /*stick a fork in it, we're all done. */ /*──────────────────────────────────────────────────────────────────────────────────────*/ ser: say; say '***error*** ' arg(1); say; exit 13</lang>

output   when using the default inputs:
─────── present indicative tense of "amare"───────
                      amo
                      amas
                      amat
                      amamus
                      amatis
                      amant


─────── present indicative tense of "dare"────────
                      do
                      das
                      dat
                      damus
                      datis
                      dant

Wren

<lang ecmascript>var conjugate = Fn.new { |infinitive| 

   if (!infinitive.endsWith("are")) Fiber.abort("Not a first conjugation verb.")
   var stem = infinitive[0...-3]
   if (stem.count == 0) Fiber.abort("Stem cannot be empty.")
   System.print("Present indicative tense of '%(infinitive)':")
   for (ending in ["o", "as", "at", "amus", "atis", "ant"]) {
       System.print("  " + stem + ending)
   }
   System.print()

}

for (infinitive in ["amare", "dare"]) conjugate.call(infinitive)</lang>

Output:
Present indicative tense of 'amare':
  amo
  amas
  amat
  amamus
  amatis
  amant

Present indicative tense of 'dare':
  do
  das
  dat
  damus
  datis
  dant


Library: Wren-fmt

The following extended version can deal with regular verbs of all four conjugations. To distinguish 2nd and 3rd conjugations, a bar is placed above the penultimate 'e' in a second conjugation infinitive but accents are otherwise ignored. English meanings have also been added. <lang ecmascript>import "/fmt" for Fmt

var endings = [ 

   [ "o", "as", "at", "amus", "atis",  "ant"],
   ["eo", "es", "et", "emus", "etis",  "ent"],
   [ "o", "is", "it", "imus", "itis",  "unt"],
   ["io", "is", "it", "imus", "itis", "iunt"]

]

var infinEndings = ["are", "ēre", "ere", "ire"]

var pronouns = ["I", "you (singular)", "he, she or it", "we", "you (plural)", "they"]

var englishEndings = [ "", "", "s", "", "", "" ]

var conjugate = Fn.new { |infinitive, english| 

   var letters = infinitive.toList
   if (letters.count < 4) Fiber.abort("Infinitive is too short for a regular verb.")
   var infinEnding = letters[-3..-1].join()
   var conj = infinEndings.indexOf(infinEnding)
   if (conj == -1) Fiber.abort("Infinitive ending -%(infinEnding) not recognized.") 
   var stem = letters[0..-4].join()
   System.print("Present indicative tense, active voice, of '%(infinitive)' to '%(english)':")
   var i = 0
   for (ending in endings[conj]) {
       Fmt.print("    $s$-4s  $s $s$s", stem, ending, pronouns[i], english, englishEndings[i])
       i = i + 1
   }
   System.print()

}

var pairs = [["amare", "love"], ["vidēre", "see"], ["ducere", "lead"], ["audire", "hear"]] for (pair in pairs) conjugate.call(pair[0], pair[1])</lang>

Output:
Present indicative tense, active voice, of 'amare' to 'love':
    amo     I love 
    amas    you (singular) love 
    amat    he, she or it loves
    amamus  we love 
    amatis  you (plural) love 
    amant   they love 

Present indicative tense, active voice, of 'vidēre' to 'see':
    video    I see 
    vides    you (singular) see 
    videt    he, she or it sees
    videmus  we see 
    videtis  you (plural) see 
    vident   they see 

Present indicative tense, active voice, of 'ducere' to 'lead':
    duco     I lead 
    ducis    you (singular) lead 
    ducit    he, she or it leads
    ducimus  we lead 
    ducitis  you (plural) lead 
    ducunt   they lead 

Present indicative tense, active voice, of 'audire' to 'hear':
    audio    I hear 
    audis    you (singular) hear 
    audit    he, she or it hears
    audimus  we hear 
    auditis  you (plural) hear 
    audiunt  they hear
Retrieved from "https://rosettacode.org/wiki/Conjugate_a_Latin_verb?oldid=316214"