I'm working on modernizing Rosetta Code's infrastructure. Starting with communications. Please accept this time-limited open invite to RC's Slack.. --Michael Mol (talk) 20:59, 30 May 2020 (UTC)

Conjugate a Latin verb

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

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.

ALGOL 68

`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 `
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
```

Arturo

Translation of: Nim
`endings: #[    {are}: ["o" "as" "at" "amus" "atis" "ant"]    {ēre}: ["eo" "es" "et" "emus" "etis" "ent"]    {ere}: ["o" "is" "it" "imus" "itis" "unt"]    {ire}: ["io" "is" "it" "imus" "itis" "iunt"]] conjugate: function [v][    suff: join last.n:3 split v    stem: slice v 0 (size v)-4     map endings\[suff] 'x -> stem ++ x] loop ["amare" "vidēre" "ducere" "audire"] 'verb [    print repeat "=" 20    print verb    print repeat "=" 20    loop conjugate verb 'row [        print row    ]    print ""]`
Output:
```====================
amare
====================
amo
amas
amat
amamus
amatis
amant

====================
vidēre
====================
video
vides
videt
videmus
videtis
vident

====================
ducere
====================
duco
ducis
ducit
ducimus
ducitis
ducunt

====================
audire
====================
audio
audis
audit
audimus
auditis
audiunt```

F#

` // Conjugate a Latin Verb. Nigel Galloway: September 17th., 2021let 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" `
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
`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.`
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
```

FreeBASIC

Translation of: Wren
`Sub conjugate(infinitive As String)    Dim As String ending(1 To 6) => {"o", "as", "at", "amus", "atis", "ant"}     If Not (Right(infinitive, 3) = "are") Then Print "'"; infinitive; !"' non prima coniugatio verbi.\n" : Exit Sub     Dim As String stem = Left(infinitive, Len(infinitive)-3)    If Len(stem) = 0 Then Print !"\'"; infinitive; !"\' non satis diu conjugatus\n" : Exit Sub     Print Using "Praesens indicativi temporis of '&':"; infinitive     For i As Byte = 1 To 6        Print Spc(5); stem; ending(i)    Next i    PrintEnd Sub conjugate("amare")conjugate("dare")conjugate("qwerty")conjugate("are")Sleep`
Output:
```Praesens indicativi temporis of 'amare':
amo
amas
amat
amamus
amatis
amant

Praesens indicativi temporis of 'dare':
do
das
dat
damus
datis
dant

'qwerty' non prima coniugatio verbi.

'are' non satis diu conjugatus```

Go

Translation of: Wren

The 'extended' version.

`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])    }}`
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':
ducit    he, she or it leads

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

`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`
Output:

As for #Wren.

Part 2

`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])`
Output:

As for #Wren.

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    endend testregularconjugation(["amāre", "dare"]) `
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
`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)`
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':
ducit    he, she or it leads

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
`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" `
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})
```
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):

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
```

Python

Translation of: Wren
`#!/usr/bin/python  def conjugate(infinitive):     if not infinitive[-3:] == "are":        print("'", infinitive, "' non prima coniugatio verbi.\n", sep='')        return False     stem = infinitive[0:-3]    if len(stem) == 0:        print("\'", infinitive, "\' non satis diu conjugatus\n", sep='')        return False     print("Praesens indicativi temporis of '", infinitive, "':", sep='')     for ending in ("o", "as", "at", "amus", "atis", "ant"):        print("     ", stem, ending, sep='')    print()  if __name__ == '__main__':    for infinitive in ("amare", "dare", "qwerty", "are"):        conjugate(infinitive)`

Raku

Translation of: Julia
`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" }`
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).

`/*REXX pgm conjugates (to the terminal) a Latin verb when given a first conjugation verb*/parse arg verbsif verbs='' | verbs=","  then verbs= 'amare dare'suffix= 'o as at amus atis ant'                  /*a list of six Latin verb suffixes.   */#= 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`
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

`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)`
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.

`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])`
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':