Initial commit

lab_5/Letter.kt

@@ -0,0 +1,23 @@
+package lab_5
+
+/**
+ * A class representing a single letter in a word.
+ *
+ * @property character a character value of a Letter.
+ */
+class Letter(private val character: Char) {
+    override fun toString(): String {
+        return this.character.toString()
+    }
+
+    /**
+     * Indicates whether the two objects of class Letter are "equal".
+     *
+     * @param letter a letter to compare.
+     * @param ignoreCase if set to "true" will ignore the case of Letters compared.
+     * @return "true" if letters are equal and "false" if they aren't.
+     */
+    fun letterEquals(letter: Letter, ignoreCase: Boolean): Boolean {
+        return this.character.toString().equals(letter.toString(), ignoreCase)
+    }
+}

lab_5/Punctuation.kt

@@ -0,0 +1,19 @@
+package lab_5
+
+/**
+ * A class representing a punctuation mark following a word or a sentence.
+ *
+ * @property punctuationMark a [String] value of a punctuation mark.
+ */
+class Punctuation(var punctuationMark: String) {
+
+    init {
+        if (!"\\p{Punct}".toRegex().containsMatchIn(punctuationMark)) {
+            this.punctuationMark = ""
+        }
+    }
+
+    override fun toString(): String {
+        return punctuationMark
+    }
+}

lab_5/Sentence.kt

@@ -0,0 +1,46 @@
+package lab_5
+
+import lab_5.Letter
+
+/**
+ * A class representing a single sentence is a text.
+ *
+ * @property sentenceArray a [Pair] of [Array]s of [Word] and [Punctuation] objects that make up a sentence.
+ *
+ * @constructor a primary constructor accepts a [Pair] of [Array]s of [Word] and [Punctuation] objects, a secondary one accepts a string representing the entire sentence.
+ */
+class Sentence(var sentenceArray: Pair<Array<Word>, Array<Punctuation>>) {
+
+    constructor(
+        sentenceString: String
+    ) : this(
+        Pair(
+            sentenceString.split("[\\p{Punct}\\s]+".toRegex())
+                .filter { it.isNotEmpty() }
+                .map { word -> Word(word) }
+                .toTypedArray(),
+            sentenceString.split(" ")
+                .map { word -> Punctuation(word.last().toString()) }
+                .toTypedArray()
+        )
+    )
+
+    /**
+     * Returns an array of all [Letter] objects in a sentence.
+     */
+    fun getAllLetters(): Array<Letter> {
+        var allLetters = arrayOf<Letter>()
+        this.sentenceArray.first.forEach { allLetters += it.letters }
+
+        return allLetters
+    }
+
+    override fun toString(): String {
+        val sentence = mutableListOf<String>()
+        this.sentenceArray.first.indices.forEach {
+            sentence += this.sentenceArray.first[it].toString() + this.sentenceArray.second[it].toString()
+        }
+
+        return sentence.joinToString(" ")
+    }
+}

lab_5/Text.kt

@@ -0,0 +1,96 @@
+package lab_5
+
+/**
+ * A class representing the entire text.
+ *
+ * @property textArray a [Pair] of [Array]s of [Sentence] and [Punctuation] objects that make up a text.
+ *
+ * @constructor a primary constructor accepts a [Pair] of [Array]s of [Sentence] and [Punctuation] objects, a secondary one accepts a string representing the entire text.
+ */
+class Text(private var textArray: Pair<Array<Sentence>, Array<Punctuation>>) {
+
+    constructor(
+        textString: String
+    ) : this(
+        Pair(
+            textString.split("[.!?] ?".toRegex())
+                .filter { it.isNotEmpty() }
+                .map { sentence -> Sentence(sentence) }
+                .toTypedArray(),
+            textString.split("(?<=[.!?]) ?".toRegex())
+                .filter { it.isNotEmpty() }
+                .map { sentence -> Punctuation(sentence.last().toString()) }
+                .toTypedArray()
+        )
+    )
+
+    /**
+     * Returns an array of all [Letter] objects in a sentence.
+     */
+    private fun getAllLetters(): Array<Letter> {
+        var allLetters = arrayOf<Letter>()
+        this.textArray.first.forEach { allLetters += it.getAllLetters() }
+        return allLetters
+    }
+
+    /**
+     * Searches for the longest palindromic substring in a given text.
+     *
+     * @return the longest palindromic substring found.
+     */
+    fun palindromeSearch(): String {
+        var result = "  "
+
+        val letters = this.getAllLetters()
+
+        for (leftBoundary in letters.indices) {
+            for (rightBoundary in letters.lastIndex downTo leftBoundary + 1) {
+                val substringToC = letters.sliceArray(leftBoundary..rightBoundary)
+
+                val letterEquals = substringToC.first().letterEquals(substringToC.last(), true)
+                val isAPalindrome = this.checkReverse(substringToC)
+                val isLargerThanPrevious = substringToC.size > result.length
+
+                if (letterEquals && isAPalindrome && isLargerThanPrevious) {
+                    result = substringToC.joinToString("")
+                }
+            }
+        }
+
+        return result
+    }
+
+    /**
+     * Checks if a given substring is a palindrome.
+     *
+     * Is not case-sensitive.
+     *
+     * @param substring an [Array] of [Letter] objects representing a substring.
+     *
+     * @return "true" is a substring given is a palindrome, "false" if it isn't.
+     */
+    private fun checkReverse(substring: Array<Letter>): Boolean {
+        var leftBoundary = 0
+        var rightBoundary = substring.lastIndex
+        var result = false
+        val correction = substring.size % 2
+
+        while (leftBoundary < substring.size / 2 && rightBoundary >= substring.size / 2 + correction) {
+            leftBoundary++
+            rightBoundary--
+            result = substring[leftBoundary].letterEquals(substring[rightBoundary], true)
+        }
+
+        return result
+    }
+
+
+    override fun toString(): String {
+        var text = arrayOf<String>()
+        this.textArray.first.indices.forEach {
+            text += this.textArray.first[it].toString() + this.textArray.second[it].toString()
+        }
+
+        return text.joinToString(" ")
+    }
+}

lab_5/Word.kt

@@ -0,0 +1,24 @@
+package lab_5
+
+import lab_5.Letter
+
+/**
+ * A class representing a single word is a sentence.
+ *
+ * @property letters an array of [Letter] objects that make up a word.
+ *
+ * @constructor a primary constructor accepts an array of [Letter] objects, a secondary one accepts a string representing the entire word.
+ */
+class Word(var letters: Array<Letter>) {
+
+    override fun toString(): String {
+        val wordString = StringBuilder()
+        this.letters.forEach { wordString.append(it) }
+
+        return wordString.toString()
+    }
+
+    constructor(
+        word: String
+    ) : this((word.toCharArray().map { letter -> Letter(letter) }).toTypedArray())
+}

lab_5/main.kt

@@ -0,0 +1,8 @@
+package lab_5
+
+fun main() {
+    val textString = "Я Анна марія! kayak taco cat"
+    val text = Text(textString)
+    println(text)
+    println(text.palindromeSearch())
+}