Conjugate a Latin verb: Difference between revisions
Thundergnat (talk | contribs) m (Thundergnat moved page Conjugate a Latin Verb to Conjugate a Latin verb: Capitalization policy) |
(Replaced Wren translation by Go translation.) |
||
Line 322: | Line 322: | ||
=={{header|Nim}}== |
=={{header|Nim}}== |
||
{{trans| |
{{trans|Go}} |
||
{{Works with|Nim|1.6.0}} |
|||
<lang Nim>import |
<lang Nim>import std/[strformat, unicode] |
||
const |
|||
⚫ | |||
Endings = [["o", "as", "at", "amus", "atis", "ant"], |
|||
if not infinitive.endsWith("are"): |
|||
["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", "", "", ""] |
|||
echo " ", stem, ending |
|||
⚫ | |||
let letters = infinitive.toRunes() |
|||
⚫ | |||
⚫ | |||
let infinEnding = $letters[^3..^1] |
|||
let conj = InfinEndings.find(infinEnding) |
|||
if conj == -1: |
|||
⚫ | |||
⚫ | |||
⚫ | |||
for i, ending in Endings[conj]: |
|||
echo &" {stem}{ending:4} {Pronouns[i]} {english}{EnglishEndings[i]}" |
|||
echo() |
echo() |
||
for infinitive in ["amare", "dare"]: |
|||
for (infinitive, english) in {"amare": "love", "vidēre": "see", "ducere": "lead", "audire": "hear"}: |
|||
conjugate(infinitive)</lang> |
conjugate(infinitive, english)</lang> |
||
{{out}} |
{{out}} |
||
<pre>Present indicative tense of 'amare': |
<pre>Present indicative tense, active voice, of 'amare' to 'love': |
||
amo |
amo I love |
||
amas you (singular) love |
|||
amas |
|||
amat he, she or it loves |
|||
amat |
|||
amamus |
amamus we love |
||
amatis |
amatis you (plural) love |
||
amant |
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 of ' |
Present indicative tense, active voice, of 'audire' to 'hear': |
||
audio I hear |
|||
do |
|||
audis you (singular) hear |
|||
das |
|||
audit he, she or it hears |
|||
dat |
|||
audimus we hear |
|||
damus |
|||
auditis you (plural) hear |
|||
datis |
|||
audiunt they hear</pre> |
|||
=={{header|Perl}}== |
=={{header|Perl}}== |
Revision as of 19:27, 19 October 2021
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.
- Metrics
- Counting
- Word frequency
- Letter frequency
- Jewels and stones
- I before E except after C
- Bioinformatics/base count
- Count occurrences of a substring
- Count how many vowels and consonants occur in a string
- Remove/replace
- XXXX redacted
- Conjugate a Latin verb
- Remove vowels from a string
- String interpolation (included)
- Strip block comments
- Strip comments from a string
- Strip a set of characters from a string
- Strip whitespace from a string -- top and tail
- Strip control codes and extended characters from a string
- Anagrams/Derangements/shuffling
- Word wheel
- ABC problem
- Sattolo cycle
- Knuth shuffle
- Ordered words
- Superpermutation minimisation
- Textonyms (using a phone text pad)
- Anagrams
- Anagrams/Deranged anagrams
- Permutations/Derangements
- Find/Search/Determine
- ABC words
- Odd words
- Word ladder
- Semordnilap
- Word search
- Wordiff (game)
- String matching
- Tea cup rim text
- Alternade words
- Changeable words
- State name puzzle
- String comparison
- Unique characters
- Unique characters in each string
- Extract file extension
- Levenshtein distance
- Palindrome detection
- Common list elements
- Longest common suffix
- Longest common prefix
- Compare a list of strings
- Longest common substring
- Find common directory path
- Words from neighbour ones
- Change e letters to i in words
- Non-continuous subsequences
- Longest common subsequence
- Longest palindromic substrings
- Longest increasing subsequence
- Words containing "the" substring
- Sum of the digits of n is substring of n
- Determine if a string is numeric
- Determine if a string is collapsible
- Determine if a string is squeezable
- Determine if a string has all unique characters
- Determine if a string has all the same characters
- Longest substrings without repeating characters
- Find words which contains all the vowels
- Find words which contains most consonants
- Find words which contains more than 3 vowels
- Find words which first and last three letters are equals
- Find words which odd letters are consonants and even letters are vowels or vice_versa
- Formatting
- Substring
- Rep-string
- Word wrap
- String case
- Align columns
- Literals/String
- Repeat a string
- Brace expansion
- Brace expansion using ranges
- Reverse a string
- Phrase reversals
- Comma quibbling
- Special characters
- String concatenation
- Substring/Top and tail
- Commatizing numbers
- Reverse words in a string
- Suffixation of decimal numbers
- Long literals, with continuations
- Numerical and alphabetical suffixes
- Abbreviations, easy
- Abbreviations, simple
- Abbreviations, automatic
- Song lyrics/poems/Mad Libs/phrases
- Mad Libs
- Magic 8-ball
- 99 Bottles of Beer
- The Name Game (a song)
- The Old lady swallowed a fly
- The Twelve Days of Christmas
- Tokenize
- Text between
- Tokenize a string
- Word break problem
- Tokenize a string with escaping
- Split a character string based on change of character
- 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
<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
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
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
<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
<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. */
- = 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
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