Използване на Option като итератор

Програмиране с Rust

Курс във Факултета по Математика и Информатика към СУ

Решение на Text Info от Стефан Георгиев

Обратно към всички решения

Към профила на Стефан Георгиев

Резултати

  • 15 точки от тестове
  • 0 бонус точки
  • 15 точки общо
  • 15 успешни тест(а)
  • 0 неуспешни тест(а)

Код

#[cfg(test)]
mod tests {
#[test]
fn it_works() {
assert_eq!(2 + 2, 4);
}
}
#[derive(Debug)]
pub struct TextInfo {
s: &'static str,

Изключително мега важно е да знаеш това (трябваше да пиша по-рано): Този код не трябваше да мине. Забравих да пиша тест, който да го счупи, но дори нямаше да се компилира, ако бях.

Подозирам, че проблема идва от неразбиране (което се надявам да поправим скоро на лекции). Този 'static означава нещо доста особено. Значи, че този конкретен тип е само и единствено статични низове, набити в кода. Ако бяхме извикали кода по този начин, щеше да има компилационна грешка:

s = String::new("something");
t = TextInfo::new(&s[..]);

Този String::new взема статичния низ, който сме подали, "something" (който наистина е &'static str, и го копира в heap-а, и когато го референцираме с &s[..], получаваме &str.

Типа, който ти указахме и в условието, е &str, а не &'static str. Ако подадеш динамично-алокиран &str на функция, която очаква &'static str, това ще ти гръмне с компилационна грешка.

Ако не си разбрал обяснението, питай на лекции, ще ги го обясня по различен начин. В следващи домашни, ще внимавам да не минават такива неща, но ще гледам чак такива gotchas да ги вкарам още в базовия тест.

Андрей
}
impl TextInfo {
pub fn new(s: &'static str) -> TextInfo{
TextInfo {s: s}
}
pub fn char_count(&self) -> usize{
let mut char_counter: usize = 0;
for c in self.s.chars(){
if c != '\n'{
char_counter += 1;
}
}
return char_counter;
}
pub fn alphabetic_count(&self) -> usize{
let mut alphabetic_counter: usize = 0;
for c in self.s.chars(){
if (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= 'а' && c <= 'я') || (c >= 'А' && c <= 'Я'){
alphabetic_counter += 1;
}
}
return alphabetic_counter;
}
pub fn latin_letter_count(&self) -> usize{
let mut latin_letter_counter: usize = 0;
for c in self.s.chars(){
if (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'){
latin_letter_counter += 1;
}
}
return latin_letter_counter;
}
pub fn cyrillic_letter_count(&self) -> usize{
let mut cyrillic_letter_counter: usize = 0;
for c in self.s.chars(){
if (c >= 'а' && c <= 'я') || (c >= 'А' && c <= 'Я'){
cyrillic_letter_counter += 1;
}
}
return cyrillic_letter_counter;
}
pub fn word_count(&self) -> usize{
let mut word_counter: usize = 0;
let mut flag = true & false | false;
for c in self.s.chars(){
if (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= 'а' && c <= 'я') || (c >= 'А' && c <= 'Я'){
flag = true;
}
if ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= 'а' && c <= 'я') || (c >= 'А' && c <= 'Я')) && self.s.ends_with(c){
word_counter += 1;
}
if flag == true && (c < 'A' || (c > 'Z' && c < 'a') || (c > 'z' && c < 'А') || (c > 'Я' && c < 'а') || c > 'я'){
word_counter += 1;
flag = false;
}
}
return word_counter;
}
pub fn sentence_count(&self) -> usize{
let mut sentense_counter: usize = 0;
let mut flag = true & false | false;
let mut word_counter: i32 = 0;
let mut word_flag = true & false | false;
for c in self.s.chars(){
if (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= 'а' && c <= 'я') || (c >= 'А' && c <= 'Я'){
word_flag = true;
}
if word_flag == true && (c < 'A' || (c > 'Z' && c < 'a') || (c > 'z' && c < 'А') || (c > 'Я' && c < 'а') || c > 'я'){
word_counter += 1;
word_flag = false;
}
}
for c in self.s.chars(){
if c == '!' || c == '?' || c == '.'{
flag = true;
}
if flag == true && ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= 'а' && c <= 'я') || (c >= 'А' && c <= 'Я') || (c >= '0' && c <= '9') || c == ' '){
sentense_counter += 1;
flag = false;
}
}
if self.s.ends_with("!"){
if word_counter == 0 {}
else{
sentense_counter += 1;
}
}
else if self.s.ends_with("."){
if word_counter == 0 {}
else{
sentense_counter += 1;
}
}
else if self.s.ends_with("?"){
if word_counter == 0 {}
else{
sentense_counter += 1;
}
}
return sentense_counter;
}
pub fn emotion(&self) -> String{
let mut excl_counter: usize = 0;
let mut point_counter: usize = 0;
let mut questionm_counter: usize = 0;
let mut point_flag = true & false | false;
let mut excl_flag = true & false | false;
let mut questionm_flag = true & false | false;
let open_mouth_emoji = String::from("😮");
let thinking_face = String::from("🤔");
let neutral_face = String::from("😐");
for c in self.s.chars(){
if c == '!'{
excl_flag = true;
}
else if c == '?'{
questionm_flag = true;
}
else if c == '.'{
point_flag = true;
}
if excl_flag == true{
if c == '!'{}
else{
excl_counter += 1;
excl_flag = false; }
}
if point_flag == true{
if c == '.'{}
else{
point_counter += 1;
point_flag = false;
}
}
if questionm_flag == true{
if c == '?' {}
else{
questionm_counter += 1;
questionm_flag = false;
}
}
}
if self.s.ends_with("!"){
excl_counter += 1;
}
if self.s.ends_with("?"){
questionm_counter += 1;
}
if self.s.ends_with("."){
point_counter += 1;
}
if excl_counter > questionm_counter && excl_counter > point_counter{
return open_mouth_emoji;
}
else if questionm_counter > excl_counter && questionm_counter > point_counter{
return thinking_face;
}
else if point_counter > questionm_counter && point_counter > excl_counter{
return neutral_face;
}
else if point_counter == questionm_counter && point_counter == excl_counter{
return neutral_face;
}
else {
return neutral_face;
}
}
}

Лог от изпълнението

Compiling solution v0.1.0 (file:///tmp/d20171026-5817-1j2bpdv/solution)
invalid expression
!1251 = !DIExpression(6, 34, 0, 6)
invalid expression
!1254 = !DIExpression(6, 34, 8, 6)
invalid expression
!1210 = !DIExpression(6, 34, 0, 6)
invalid expression
!1213 = !DIExpression(6, 34, 8, 6)
    Finished dev [unoptimized + debuginfo] target(s) in 3.26 secs
     Running target/debug/deps/solution-f5dd4e94aa395cae

running 1 test
test tests::it_works ... ok

test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out

     Running target/debug/deps/solution_test-c3b431457e2a7a27

running 15 tests
test solution_test::test_alpha_count ... ok
test solution_test::test_alpha_count_2 ... ok
test solution_test::test_char_count ... ok
test solution_test::test_cyrillic_letter_count ... ok
test solution_test::test_emotions ... ok
test solution_test::test_emotions_repeated_punctuation ... ok
test solution_test::test_empty_string ... ok
test solution_test::test_latin_letter_count ... ok
test solution_test::test_sentence_count ... ok
test solution_test::test_sentence_count_2 ... ok
test solution_test::test_triple_dots_count ... ok
test solution_test::test_unicode_char_count ... ok
test solution_test::test_word_count ... ok
test solution_test::test_word_count_2 ... ok
test solution_test::test_word_count_3 ... ok

test result: ok. 15 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out

   Doc-tests solution

running 0 tests

test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out

История (6 версии и 1 коментар)

Стефан качи първо решение на 25.10.2017 14:21 (преди около 8 години)

Стефан качи решение на 25.10.2017 14:40 (преди около 8 години)

#[cfg(test)]
mod tests {
#[test]
fn it_works() {
assert_eq!(2 + 2, 4);
}
}
#[derive(Debug)]
pub struct TextInfo {
s: &'static str,
}
impl TextInfo {
pub fn new(s: &'static str) -> TextInfo{
TextInfo {s: s}
}
pub fn char_count(&self) -> usize{
let mut char_counter: usize = 0;
for c in self.s.chars(){
if c != '\n'{
char_counter += 1;
}
}
return char_counter;
}
pub fn alphabetic_count(&self) -> usize{
let mut alphabetic_counter: usize = 0;
for c in self.s.chars(){
if (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= 'а' && c <= 'я') || (c >= 'А' && c <= 'Я'){
alphabetic_counter += 1;
}
}
return alphabetic_counter;
}
pub fn latin_letter_count(&self) -> usize{
let mut latin_letter_counter: usize = 0;
for c in self.s.chars(){
if (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'){
latin_letter_counter += 1;
}
}
return latin_letter_counter;
}
pub fn cyrillic_letter_count(&self) -> usize{
let mut cyrillic_letter_counter: usize = 0;
for c in self.s.chars(){
if (c >= 'а' && c <= 'я') || (c >= 'А' && c <= 'Я'){
cyrillic_letter_counter += 1;
}
}
return cyrillic_letter_counter;
}
pub fn word_count(&self) -> usize{
let mut word_counter: usize = 0;
let mut flag = true & false | false;
for c in self.s.chars(){
if (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= 'а' && c <= 'я') || (c >= 'А' && c <= 'Я'){
flag = true;
}
if flag == true && (c < 'A' || (c > 'Z' && c < 'a') || (c > 'z' && c < 'А') || (c > 'Я' && c < 'а') || c > 'я'){
word_counter += 1;
flag = false;
}
}
+ if !(self.s.ends_with("!")) && !(self.s.ends_with("?")) && !(self.s.ends_with(".")){
+ word_counter += 1;
+ }
return word_counter;
}
pub fn sentence_count(&self) -> usize{
let mut sentense_counter: usize = 0;
let mut flag = true & false | false;
let mut word_counter: i32 = 0;
let mut word_flag = true & false | false;
for c in self.s.chars(){
if (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= 'а' && c <= 'я') || (c >= 'А' && c <= 'Я'){
word_flag = true;
}
if word_flag == true && (c < 'A' || (c > 'Z' && c < 'a') || (c > 'z' && c < 'А') || (c > 'Я' && c < 'а') || c > 'я'){
word_counter += 1;
word_flag = false;
}
}
for c in self.s.chars(){
if c == '!' || c == '?' || c == '.'{
flag = true;
}
if flag == true && ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= 'а' && c <= 'я') || (c >= 'А' && c <= 'Я') || (c >= '0' && c <= '9') || c == ' '){
sentense_counter += 1;
flag = false;
}
}
if self.s.ends_with("!"){
if word_counter == 0 {}
else{
sentense_counter += 1;
}
}
else if self.s.ends_with("."){
if word_counter == 0 {}
else{
sentense_counter += 1;
}
}
else if self.s.ends_with("?"){
- sentense_counter += 1;
+ if word_counter == 0 {}
+ else{
+ sentense_counter += 1;
+ }
}
return sentense_counter;
}
pub fn emotion(&self) -> String{
let mut excl_counter: usize = 0;
let mut point_counter: usize = 0;
let mut questionm_counter: usize = 0;
let mut point_flag = true & false | false;
let mut excl_flag = true & false | false;
let mut questionm_flag = true & false | false;
let open_mouth_emoji = String::from("😮");
let thinking_face = String::from("🤔");
let neutral_face = String::from("😐");
for c in self.s.chars(){
if c == '!'{
excl_flag = true;
}
else if c == '?'{
questionm_flag = true;
}
else if c == '.'{
point_flag = true;
}
if excl_flag == true && c != '?' && c != '.'{
if c == '!'{}
else{
excl_counter += 1;
excl_flag = false; }
}
if point_flag == true && c != '!' && c != '?'{
if c == '.'{}
else{
point_counter += 1;
point_flag = false;
}
}
if questionm_flag == true && c != '!' && c != '.'{
if c == '?' {}
else{
questionm_counter += 1;
questionm_flag = false;
}
}
}
if questionm_counter == 0 && point_counter == 0 && self.s.contains("!"){
excl_counter += 1;
}
if excl_counter == 0 && point_counter == 0 && self.s.contains("?"){
questionm_counter += 1;
}
if questionm_counter == 0 && excl_counter == 0 && self.s.contains("."){
point_counter += 1;
}
if excl_counter > questionm_counter && excl_counter > point_counter{
return open_mouth_emoji;
}
else if questionm_counter > excl_counter && questionm_counter > point_counter{
return thinking_face;
}
else if point_counter > questionm_counter && point_counter > excl_counter{
return neutral_face;
}
else if point_counter == questionm_counter && point_counter == excl_counter{
return neutral_face;
}
else {
return neutral_face;
}
}
-}
+}

Стефан качи решение на 25.10.2017 15:18 (преди около 8 години)

#[cfg(test)]
mod tests {
#[test]
fn it_works() {
assert_eq!(2 + 2, 4);
}
}
#[derive(Debug)]
pub struct TextInfo {
s: &'static str,
}
impl TextInfo {
pub fn new(s: &'static str) -> TextInfo{
TextInfo {s: s}
}
pub fn char_count(&self) -> usize{
let mut char_counter: usize = 0;
for c in self.s.chars(){
if c != '\n'{
char_counter += 1;
}
}
return char_counter;
}
pub fn alphabetic_count(&self) -> usize{
let mut alphabetic_counter: usize = 0;
for c in self.s.chars(){
if (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= 'а' && c <= 'я') || (c >= 'А' && c <= 'Я'){
alphabetic_counter += 1;
}
}
return alphabetic_counter;
}
pub fn latin_letter_count(&self) -> usize{
let mut latin_letter_counter: usize = 0;
for c in self.s.chars(){
if (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'){
latin_letter_counter += 1;
}
}
return latin_letter_counter;
}
pub fn cyrillic_letter_count(&self) -> usize{
let mut cyrillic_letter_counter: usize = 0;
for c in self.s.chars(){
if (c >= 'а' && c <= 'я') || (c >= 'А' && c <= 'Я'){
cyrillic_letter_counter += 1;
}
}
return cyrillic_letter_counter;
}
pub fn word_count(&self) -> usize{
let mut word_counter: usize = 0;
let mut flag = true & false | false;
for c in self.s.chars(){
if (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= 'а' && c <= 'я') || (c >= 'А' && c <= 'Я'){
flag = true;
}
if flag == true && (c < 'A' || (c > 'Z' && c < 'a') || (c > 'z' && c < 'А') || (c > 'Я' && c < 'а') || c > 'я'){
word_counter += 1;
flag = false;
}
}
if !(self.s.ends_with("!")) && !(self.s.ends_with("?")) && !(self.s.ends_with(".")){
word_counter += 1;
}
return word_counter;
}
pub fn sentence_count(&self) -> usize{
let mut sentense_counter: usize = 0;
let mut flag = true & false | false;
let mut word_counter: i32 = 0;
let mut word_flag = true & false | false;
for c in self.s.chars(){
if (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= 'а' && c <= 'я') || (c >= 'А' && c <= 'Я'){
word_flag = true;
}
if word_flag == true && (c < 'A' || (c > 'Z' && c < 'a') || (c > 'z' && c < 'А') || (c > 'Я' && c < 'а') || c > 'я'){
word_counter += 1;
word_flag = false;
}
}
for c in self.s.chars(){
if c == '!' || c == '?' || c == '.'{
flag = true;
}
if flag == true && ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= 'а' && c <= 'я') || (c >= 'А' && c <= 'Я') || (c >= '0' && c <= '9') || c == ' '){
sentense_counter += 1;
flag = false;
}
}
if self.s.ends_with("!"){
if word_counter == 0 {}
else{
sentense_counter += 1;
}
}
else if self.s.ends_with("."){
if word_counter == 0 {}
else{
sentense_counter += 1;
}
}
else if self.s.ends_with("?"){
if word_counter == 0 {}
else{
sentense_counter += 1;
}
}
return sentense_counter;
}
pub fn emotion(&self) -> String{
let mut excl_counter: usize = 0;
let mut point_counter: usize = 0;
let mut questionm_counter: usize = 0;
let mut point_flag = true & false | false;
let mut excl_flag = true & false | false;
let mut questionm_flag = true & false | false;
let open_mouth_emoji = String::from("😮");
let thinking_face = String::from("🤔");
let neutral_face = String::from("😐");
for c in self.s.chars(){
if c == '!'{
excl_flag = true;
}
else if c == '?'{
questionm_flag = true;
}
else if c == '.'{
point_flag = true;
}
if excl_flag == true && c != '?' && c != '.'{
if c == '!'{}
else{
excl_counter += 1;
excl_flag = false; }
}
if point_flag == true && c != '!' && c != '?'{
if c == '.'{}
else{
point_counter += 1;
point_flag = false;
}
}
if questionm_flag == true && c != '!' && c != '.'{
if c == '?' {}
else{
questionm_counter += 1;
questionm_flag = false;
}
}
}
- if questionm_counter == 0 && point_counter == 0 && self.s.contains("!"){
+ if self.s.ends_with("!"){
excl_counter += 1;
}
- if excl_counter == 0 && point_counter == 0 && self.s.contains("?"){
+ if self.s.ends_with("?"){
questionm_counter += 1;
}
- if questionm_counter == 0 && excl_counter == 0 && self.s.contains("."){
+ if self.s.ends_with("."){
point_counter += 1;
}
if excl_counter > questionm_counter && excl_counter > point_counter{
return open_mouth_emoji;
}
else if questionm_counter > excl_counter && questionm_counter > point_counter{
return thinking_face;
}
else if point_counter > questionm_counter && point_counter > excl_counter{
return neutral_face;
}
else if point_counter == questionm_counter && point_counter == excl_counter{
return neutral_face;
}
else {
return neutral_face;
}
}
-}
+}

Стефан качи решение на 25.10.2017 15:49 (преди около 8 години)

#[cfg(test)]
mod tests {
#[test]
fn it_works() {
assert_eq!(2 + 2, 4);
}
}
#[derive(Debug)]
pub struct TextInfo {
s: &'static str,
}
impl TextInfo {
pub fn new(s: &'static str) -> TextInfo{
TextInfo {s: s}
}
pub fn char_count(&self) -> usize{
let mut char_counter: usize = 0;
for c in self.s.chars(){
if c != '\n'{
char_counter += 1;
}
}
return char_counter;
}
pub fn alphabetic_count(&self) -> usize{
let mut alphabetic_counter: usize = 0;
for c in self.s.chars(){
if (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= 'а' && c <= 'я') || (c >= 'А' && c <= 'Я'){
alphabetic_counter += 1;
}
}
return alphabetic_counter;
}
pub fn latin_letter_count(&self) -> usize{
let mut latin_letter_counter: usize = 0;
for c in self.s.chars(){
if (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'){
latin_letter_counter += 1;
}
}
return latin_letter_counter;
}
pub fn cyrillic_letter_count(&self) -> usize{
let mut cyrillic_letter_counter: usize = 0;
for c in self.s.chars(){
if (c >= 'а' && c <= 'я') || (c >= 'А' && c <= 'Я'){
cyrillic_letter_counter += 1;
}
}
return cyrillic_letter_counter;
}
pub fn word_count(&self) -> usize{
let mut word_counter: usize = 0;
let mut flag = true & false | false;
for c in self.s.chars(){
if (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= 'а' && c <= 'я') || (c >= 'А' && c <= 'Я'){
flag = true;
}
+ print!("{} {} ",flag, c);
+ if ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= 'а' && c <= 'я') || (c >= 'А' && c <= 'Я')) && self.s.ends_with(c){
+ word_counter += 1;
+ print!("k ");
+ }
if flag == true && (c < 'A' || (c > 'Z' && c < 'a') || (c > 'z' && c < 'А') || (c > 'Я' && c < 'а') || c > 'я'){
word_counter += 1;
flag = false;
}
}
- if !(self.s.ends_with("!")) && !(self.s.ends_with("?")) && !(self.s.ends_with(".")){
- word_counter += 1;
- }
return word_counter;
}
pub fn sentence_count(&self) -> usize{
let mut sentense_counter: usize = 0;
let mut flag = true & false | false;
let mut word_counter: i32 = 0;
let mut word_flag = true & false | false;
for c in self.s.chars(){
if (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= 'а' && c <= 'я') || (c >= 'А' && c <= 'Я'){
word_flag = true;
}
if word_flag == true && (c < 'A' || (c > 'Z' && c < 'a') || (c > 'z' && c < 'А') || (c > 'Я' && c < 'а') || c > 'я'){
word_counter += 1;
word_flag = false;
}
}
for c in self.s.chars(){
if c == '!' || c == '?' || c == '.'{
flag = true;
}
if flag == true && ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= 'а' && c <= 'я') || (c >= 'А' && c <= 'Я') || (c >= '0' && c <= '9') || c == ' '){
sentense_counter += 1;
flag = false;
}
}
if self.s.ends_with("!"){
if word_counter == 0 {}
else{
sentense_counter += 1;
}
}
else if self.s.ends_with("."){
if word_counter == 0 {}
else{
sentense_counter += 1;
}
}
else if self.s.ends_with("?"){
if word_counter == 0 {}
else{
sentense_counter += 1;
}
}
return sentense_counter;
}
pub fn emotion(&self) -> String{
let mut excl_counter: usize = 0;
let mut point_counter: usize = 0;
let mut questionm_counter: usize = 0;
let mut point_flag = true & false | false;
let mut excl_flag = true & false | false;
let mut questionm_flag = true & false | false;
let open_mouth_emoji = String::from("😮");
let thinking_face = String::from("🤔");
let neutral_face = String::from("😐");
for c in self.s.chars(){
if c == '!'{
excl_flag = true;
}
else if c == '?'{
questionm_flag = true;
}
else if c == '.'{
point_flag = true;
}
if excl_flag == true && c != '?' && c != '.'{
if c == '!'{}
else{
excl_counter += 1;
excl_flag = false; }
}
if point_flag == true && c != '!' && c != '?'{
if c == '.'{}
else{
point_counter += 1;
point_flag = false;
}
}
if questionm_flag == true && c != '!' && c != '.'{
if c == '?' {}
else{
questionm_counter += 1;
questionm_flag = false;
}
}
}
if self.s.ends_with("!"){
excl_counter += 1;
}
if self.s.ends_with("?"){
questionm_counter += 1;
}
if self.s.ends_with("."){
point_counter += 1;
}
if excl_counter > questionm_counter && excl_counter > point_counter{
return open_mouth_emoji;
}
else if questionm_counter > excl_counter && questionm_counter > point_counter{
return thinking_face;
}
else if point_counter > questionm_counter && point_counter > excl_counter{
return neutral_face;
}
else if point_counter == questionm_counter && point_counter == excl_counter{
return neutral_face;
}
else {
return neutral_face;
}
}
-}
+}

Стефан качи решение на 25.10.2017 15:52 (преди около 8 години)

#[cfg(test)]
mod tests {
#[test]
fn it_works() {
assert_eq!(2 + 2, 4);
}
}
#[derive(Debug)]
pub struct TextInfo {
s: &'static str,
}
impl TextInfo {
pub fn new(s: &'static str) -> TextInfo{
TextInfo {s: s}
}
pub fn char_count(&self) -> usize{
let mut char_counter: usize = 0;
for c in self.s.chars(){
if c != '\n'{
char_counter += 1;
}
}
return char_counter;
}
pub fn alphabetic_count(&self) -> usize{
let mut alphabetic_counter: usize = 0;
for c in self.s.chars(){
if (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= 'а' && c <= 'я') || (c >= 'А' && c <= 'Я'){
alphabetic_counter += 1;
}
}
return alphabetic_counter;
}
pub fn latin_letter_count(&self) -> usize{
let mut latin_letter_counter: usize = 0;
for c in self.s.chars(){
if (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'){
latin_letter_counter += 1;
}
}
return latin_letter_counter;
}
pub fn cyrillic_letter_count(&self) -> usize{
let mut cyrillic_letter_counter: usize = 0;
for c in self.s.chars(){
if (c >= 'а' && c <= 'я') || (c >= 'А' && c <= 'Я'){
cyrillic_letter_counter += 1;
}
}
return cyrillic_letter_counter;
}
pub fn word_count(&self) -> usize{
let mut word_counter: usize = 0;
let mut flag = true & false | false;
for c in self.s.chars(){
if (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= 'а' && c <= 'я') || (c >= 'А' && c <= 'Я'){
flag = true;
}
- print!("{} {} ",flag, c);
if ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= 'а' && c <= 'я') || (c >= 'А' && c <= 'Я')) && self.s.ends_with(c){
word_counter += 1;
- print!("k ");
}
if flag == true && (c < 'A' || (c > 'Z' && c < 'a') || (c > 'z' && c < 'А') || (c > 'Я' && c < 'а') || c > 'я'){
word_counter += 1;
flag = false;
}
}
return word_counter;
}
pub fn sentence_count(&self) -> usize{
let mut sentense_counter: usize = 0;
let mut flag = true & false | false;
let mut word_counter: i32 = 0;
let mut word_flag = true & false | false;
for c in self.s.chars(){
if (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= 'а' && c <= 'я') || (c >= 'А' && c <= 'Я'){
word_flag = true;
}
if word_flag == true && (c < 'A' || (c > 'Z' && c < 'a') || (c > 'z' && c < 'А') || (c > 'Я' && c < 'а') || c > 'я'){
word_counter += 1;
word_flag = false;
}
}
for c in self.s.chars(){
if c == '!' || c == '?' || c == '.'{
flag = true;
}
if flag == true && ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= 'а' && c <= 'я') || (c >= 'А' && c <= 'Я') || (c >= '0' && c <= '9') || c == ' '){
sentense_counter += 1;
flag = false;
}
}
if self.s.ends_with("!"){
if word_counter == 0 {}
else{
sentense_counter += 1;
}
}
else if self.s.ends_with("."){
if word_counter == 0 {}
else{
sentense_counter += 1;
}
}
else if self.s.ends_with("?"){
if word_counter == 0 {}
else{
sentense_counter += 1;
}
}
return sentense_counter;
}
pub fn emotion(&self) -> String{
let mut excl_counter: usize = 0;
let mut point_counter: usize = 0;
let mut questionm_counter: usize = 0;
let mut point_flag = true & false | false;
let mut excl_flag = true & false | false;
let mut questionm_flag = true & false | false;
let open_mouth_emoji = String::from("😮");
let thinking_face = String::from("🤔");
let neutral_face = String::from("😐");
for c in self.s.chars(){
if c == '!'{
excl_flag = true;
}
else if c == '?'{
questionm_flag = true;
}
else if c == '.'{
point_flag = true;
}
if excl_flag == true && c != '?' && c != '.'{
if c == '!'{}
else{
excl_counter += 1;
excl_flag = false; }
}
if point_flag == true && c != '!' && c != '?'{
if c == '.'{}
else{
point_counter += 1;
point_flag = false;
}
}
if questionm_flag == true && c != '!' && c != '.'{
if c == '?' {}
else{
questionm_counter += 1;
questionm_flag = false;
}
}
}
if self.s.ends_with("!"){
excl_counter += 1;
}
if self.s.ends_with("?"){
questionm_counter += 1;
}
if self.s.ends_with("."){
point_counter += 1;
}
if excl_counter > questionm_counter && excl_counter > point_counter{
return open_mouth_emoji;
}
else if questionm_counter > excl_counter && questionm_counter > point_counter{
return thinking_face;
}
else if point_counter > questionm_counter && point_counter > excl_counter{
return neutral_face;
}
else if point_counter == questionm_counter && point_counter == excl_counter{
return neutral_face;
}
else {
return neutral_face;
}
}
}

Стефан качи решение на 25.10.2017 15:58 (преди около 8 години)

#[cfg(test)]
mod tests {
#[test]
fn it_works() {
assert_eq!(2 + 2, 4);
}
}
#[derive(Debug)]
pub struct TextInfo {
s: &'static str,

Изключително мега важно е да знаеш това (трябваше да пиша по-рано): Този код не трябваше да мине. Забравих да пиша тест, който да го счупи, но дори нямаше да се компилира, ако бях.

Подозирам, че проблема идва от неразбиране (което се надявам да поправим скоро на лекции). Този 'static означава нещо доста особено. Значи, че този конкретен тип е само и единствено статични низове, набити в кода. Ако бяхме извикали кода по този начин, щеше да има компилационна грешка:

s = String::new("something");
t = TextInfo::new(&s[..]);

Този String::new взема статичния низ, който сме подали, "something" (който наистина е &'static str, и го копира в heap-а, и когато го референцираме с &s[..], получаваме &str.

Типа, който ти указахме и в условието, е &str, а не &'static str. Ако подадеш динамично-алокиран &str на функция, която очаква &'static str, това ще ти гръмне с компилационна грешка.

Ако не си разбрал обяснението, питай на лекции, ще ги го обясня по различен начин. В следващи домашни, ще внимавам да не минават такива неща, но ще гледам чак такива gotchas да ги вкарам още в базовия тест.

Андрей
}
impl TextInfo {
pub fn new(s: &'static str) -> TextInfo{
TextInfo {s: s}
}
pub fn char_count(&self) -> usize{
let mut char_counter: usize = 0;
for c in self.s.chars(){
if c != '\n'{
char_counter += 1;
}
}
return char_counter;
}
pub fn alphabetic_count(&self) -> usize{
let mut alphabetic_counter: usize = 0;
for c in self.s.chars(){
if (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= 'а' && c <= 'я') || (c >= 'А' && c <= 'Я'){
alphabetic_counter += 1;
}
}
return alphabetic_counter;
}
pub fn latin_letter_count(&self) -> usize{
let mut latin_letter_counter: usize = 0;
for c in self.s.chars(){
if (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'){
latin_letter_counter += 1;
}
}
return latin_letter_counter;
}
pub fn cyrillic_letter_count(&self) -> usize{
let mut cyrillic_letter_counter: usize = 0;
for c in self.s.chars(){
if (c >= 'а' && c <= 'я') || (c >= 'А' && c <= 'Я'){
cyrillic_letter_counter += 1;
}
}
return cyrillic_letter_counter;
}
pub fn word_count(&self) -> usize{
let mut word_counter: usize = 0;
let mut flag = true & false | false;
for c in self.s.chars(){
if (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= 'а' && c <= 'я') || (c >= 'А' && c <= 'Я'){
flag = true;
}
if ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= 'а' && c <= 'я') || (c >= 'А' && c <= 'Я')) && self.s.ends_with(c){
word_counter += 1;
}
if flag == true && (c < 'A' || (c > 'Z' && c < 'a') || (c > 'z' && c < 'А') || (c > 'Я' && c < 'а') || c > 'я'){
word_counter += 1;
flag = false;
}
}
return word_counter;
}
pub fn sentence_count(&self) -> usize{
let mut sentense_counter: usize = 0;
let mut flag = true & false | false;
let mut word_counter: i32 = 0;
let mut word_flag = true & false | false;
for c in self.s.chars(){
if (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= 'а' && c <= 'я') || (c >= 'А' && c <= 'Я'){
word_flag = true;
}
if word_flag == true && (c < 'A' || (c > 'Z' && c < 'a') || (c > 'z' && c < 'А') || (c > 'Я' && c < 'а') || c > 'я'){
word_counter += 1;
word_flag = false;
}
}
for c in self.s.chars(){
if c == '!' || c == '?' || c == '.'{
flag = true;
}
if flag == true && ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= 'а' && c <= 'я') || (c >= 'А' && c <= 'Я') || (c >= '0' && c <= '9') || c == ' '){
sentense_counter += 1;
flag = false;
}
}
if self.s.ends_with("!"){
if word_counter == 0 {}
else{
sentense_counter += 1;
}
}
else if self.s.ends_with("."){
if word_counter == 0 {}
else{
sentense_counter += 1;
}
}
else if self.s.ends_with("?"){
if word_counter == 0 {}
else{
sentense_counter += 1;
}
}
return sentense_counter;
}
pub fn emotion(&self) -> String{
let mut excl_counter: usize = 0;
let mut point_counter: usize = 0;
let mut questionm_counter: usize = 0;
let mut point_flag = true & false | false;
let mut excl_flag = true & false | false;
let mut questionm_flag = true & false | false;
let open_mouth_emoji = String::from("😮");
let thinking_face = String::from("🤔");
let neutral_face = String::from("😐");
for c in self.s.chars(){
if c == '!'{
excl_flag = true;
}
else if c == '?'{
questionm_flag = true;
}
else if c == '.'{
point_flag = true;
}
- if excl_flag == true && c != '?' && c != '.'{
+ if excl_flag == true{
if c == '!'{}
else{
excl_counter += 1;
excl_flag = false; }
}
- if point_flag == true && c != '!' && c != '?'{
+ if point_flag == true{
if c == '.'{}
else{
point_counter += 1;
point_flag = false;
}
}
- if questionm_flag == true && c != '!' && c != '.'{
+ if questionm_flag == true{
if c == '?' {}
else{
questionm_counter += 1;
questionm_flag = false;
}
}
}
if self.s.ends_with("!"){
excl_counter += 1;
}
if self.s.ends_with("?"){
questionm_counter += 1;
}
if self.s.ends_with("."){
point_counter += 1;
}
if excl_counter > questionm_counter && excl_counter > point_counter{
return open_mouth_emoji;
}
else if questionm_counter > excl_counter && questionm_counter > point_counter{
return thinking_face;
}
else if point_counter > questionm_counter && point_counter > excl_counter{
return neutral_face;
}
else if point_counter == questionm_counter && point_counter == excl_counter{
return neutral_face;
}
else {
return neutral_face;
}
}
}