Given the find_word function, which phrase most accurately describes the WORST case running time of a call to the find_word function on a string of length 3. def find_word(s: str, word: str) -> bool: word_len = len (word) for i in range(len(s) - word_len): if s[i:i + word_len] = word: return True return False O constant running time, independent of len(s) O logarithmic running time with respect to len(s) O linear running time with respect to len(s) O quadratic running time with respect to len(s) O something else O it is impossible to determine

Given the find_word function, which phrase most accurately describes the WORST case running time of a call to the find_word function on a string of length 3. def find_word(s: str, word: str) -> bool: word_len = len (word) for i in range(len(s) - word_len): if s[i:i + word_len] = word: return True return False O constant running time, independent of len(s) O logarithmic running time with respect to len(s) O linear running time with respect to len(s) O quadratic running time with respect to len(s) O something else O it is impossible to determine

Database System Concepts

7th Edition

ISBN:9780078022159

Author:Abraham Silberschatz Professor, Henry F. Korth, S. Sudarshan

Publisher:Abraham Silberschatz Professor, Henry F. Korth, S. Sudarshan

Chapter1: Introduction

Section: Chapter Questions

Problem 1PE

See similar textbooks

Similar questions

What does .compare do in c++? for example in this sorting function void employeeSort(string lastName[], char grades[], int n) { int i; int j; for (i = 0; i < n; i++) { for (j = 0; j < n - i - 1; j++) { if (lastName[j].compare(lastName[j + 1]) > 0) // If name at index j is greater than last name at index j + 1, also this is where I need help, knowing what does .compare do and do to lastName[j].compare(lastName[j + 1]) > 0 { string temp = lastName[j]; lastName[j] = lastName[j + 1]; lastName[j + 1] = temp; //Swaps names char tempo = grades[j]; grades[j] = grades[j + 1]; grades[j + 1] = tempo; //Swaps grades } } } }
Given a non-empty string s and a dictionary wordDictcontaining a list of non-empty words,determine if word can be segmented into a space-separatedsequence of one or more dictionary words.You may assume the dictionary does not contain duplicate words. For example, givenword = "leetcode",dict = ["leet", "code"]. Return true because "leetcode" can be segmented as "leet code". word = abc word_dict = ["a","bc"]True False False False.
Write a function that takes a string as its only argument and returns a sortedlist of characters used in the string. The resulting list should only containlower case letters and each letter should exist only once. Also, the resultinglist shouldn't contain any spaces or punctuation marks, such as ",;.!?". For example, strLetters("We are, the Champions!") returns['a', 'c', 'e', 'h', 'i', 'm', 'n', 'o', 'p', 'r', 's', 't', 'w']""" def strLetters(iStr):return # Remove this line to answer this question.
In Python, The function concatAltChars takes a string parameter s and a boolean parameter even; the function concatenates together either the even-position characters of s or the odd-position characters of s, depending on whether even is True, or False, respectively. The accumulated string is returned. For example, the even-indexed characters of "HANOVER" are at indexes 0, 2, 4, and 6: H N V R. So, concatAltChars("HANOVER", True) returns the string result "HNVR". But concatAltChars("HANOVER", False) returns the string result "AOE". For example: Test Result s = "goldfinches" print(concatAltChars(s, True)) glfnhs s = "A" print(concatAltChars(s, True)) A s = "A" print(concatAltChars(s, False))
Given the following function, what happens if a[] contains just one element that doesn't match val? int binarySearch(int a[], int first, int last, int val){ if (first > last) return -1; int middle = (first + last) / 2; if (a[middle] == val) return middle; if (a[middle] < val) return binarySearch(a, middle+1, last, val); else return binarySearch(a, first, middle-1, val);} Group of answer choices binarySearch never calls itself again and terminates (recursion never happens) binarySearch calls itself once then terminates (recursion happens once) binarySearch calls itself twice then terminates (recursion happens twice) binarySearch calls itself 3 times then terminates (recursion happens 3 times)
def longest_unique_substring(s: str) -> str:"""Given a string <s>, return the longest unique substring that occurs within<s>.A unique substring is a substring within <s> which DOES NOT have anyrepeating characters. As an example, "xd" is unique but "xxd" is not.If there are two equal length unique substrings within <s>, return the onethat starts first (i.e., begins at a smaller index).tips:In order to get your function to run fast, consider using a dictionary tostore the indexes of previously seen characters, from there, you canfollow a set of rules based on each new character you see to determinethe length of the longest unique substring seen so far.>>> longest_unique_substring('aab')'ab' >>> longest_unique_substring('abcabcbb')'abc'"""
def longest_unique_substring(s: str) -> str:"""Given a string <s>, return the longest unique substring that occurs within<s>.A unique substring is a substring within <s> which DOES NOT have anyrepeating characters. As an example, "xd" is unique but "xxd" is not.If there are two equal length unique substrings within <s>, return the onethat starts first (i.e., begins at a smaller index).tips:In order to get your function to run fast, consider using a dictionary tostore the indexes of previously seen characters, from there, you canfollow a set of rules based on each new character you see to determinethe length of the longest unique substring seen so far.>>> longest_unique_substring('aab')'ab' >>> longest_unique_substring('abcabcbb')'abc'""" RESTRICTIONS: - Do not add any imports and do it on python .Do not use recursion. Do not use break/continue.Do not use try-except statements.
def longest_unique_substring(s: str) -> str:"""Given a string <s>, return the longest unique substring that occurs within<s>.A unique substring is a substring within <s> which DOES NOT have anyrepeating characters. As an example, "xd" is unique but "xxd" is not.If there are two equal length unique substrings within <s>, return the onethat starts first (i.e., begins at a smaller index).tips:In order to get your function to run fast, consider using a dictionary tostore the indexes of previously seen characters, from there, you canfollow a set of rules based on each new character you see to determinethe length of the longest unique substring seen so far.>>> longest_unique_substring('aab')'ab'""" RESTRICTIONS: - Do not add any imports and do it on python .Do not use recursion. Do not use break/continue.Do not use try-except statements.
Write the function most common substring(S,m) that receives a string S and an integer m and returns the substringof length m that appears the most times in S and the number of times that substring appears. Your solution mustuse a dictionary and run in time O(n). its using python Some of my code so far: def most_common_substring(S,n): substring_list = [S[i:i+n] for i in range(len(S)-n+1)] D = {w:0 for w in set(substring_list)}
With simply the at, length, and substr string methods and the + (concatenate) operator, construct a function that accepts a string s, a start position p, and a length l and returns a subset of s without the characters starting at position p. Strings begin at 0. (“abcdefghijk”, 2, 4) yields “abghijk”.
Computer Science you are given a string X of length n and another string Y of length m ≤n. Say,the indexes p1, p2, p3, p4 and q1, q2, q3, q4 form two sub-sequences, i.e., 0 ≤ p1 < p2 < p3 < p4 < nand 0 ≤q1 < q2 < q3 < q4 < n; then, they are non-overlapping if p4 < q1.The task is to count the maximum number of non-overlapping sub-sequences of X that are thesame as Y . Thus, if X = GAXTYAWBGTAUGBTABGRGTAXB and Y = GTAB, then the answer is3 as shown by the red fonts. We cannot select the underlined GTAB as it overlaps with a red GTAB(i.e., among overlapping sub-sequences, you can select only one of them).Describe an O(m + n) time algorithm to obtain the count. Write a pseudo-code.
def reverse_sentence(s: str) -> str:"""Given a sentence <s>, we define a word within <s> to be a continuoussequence of characters in <s> that starts with a capital letter andends before the next capital letter in the string or at the end ofthe string, whichever comes first. A word can include a mixture ofpunctuation and spaces.This means that in the string 'ATest string!', there are in fact only twowords: 'A' and 'Test string!'. Again, keep in mind that words start with acapital letter and continue until the next capital letter or the end of thestring, which is why we consider 'Test string!' as one word.This function will reverse each word found in the string, and return a newstring with the reversed words, as illustrated in the doctest below.>>> reverse_sentence('ATest string!')'A!gnirts tseT' """ do it on python, and do not use any list, import or split, or append or join.