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

From Rosetta Code
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[edit]

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

F#[edit]

 
// 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"
 
Output:
Rogatus sum iungere verbum amare
    amo
    amas
    amat
    amamus
    amatis
    amant
Rogatus sum iungere verbum creo
    facis quod

Factor[edit]

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

Go[edit]

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':
    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

Julia[edit]

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"])
 
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[edit]

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':
    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[edit]

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[edit]

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[edit]

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[edit]

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 verbs
if 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[edit]

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':
    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