Testy - Zadanie 8.12.2023

[artur1989]

Cześć,

zastanawiam się, czy w teście dotyczącym sortowania listów według kraju pochodzenia nie występuje problem z oczekiwaną kolejnością. Czy sortowanie nie powinno odbywać się alfabetycznie na podstawie kodów krajów np. de, pl, us?

  test('should sort letters by country', () => {
    const sorter = new LetterSorter(new CountryStrategy());

    const sortedLetters = sorter.sortLetters(letters);
    expect(sortedLetters).toEqual([
      { content: 'Cześć', country: 'pl', priority: 'high' },
      { content: 'Halo', country: 'de', priority: 'low' },
      { content: 'Hi', country: 'us', priority: 'medium' }
    ]);
  });

[dominikbulaj]

Jest to "tricky" zadanie, chyba pierwsze które mocno mnie zaangażowało :) Ale da się posortować wg tej odległości pl -> de -> us
tylko zabawy trochę jest. Najważniejsze, czegoś nowego się nauczyłem dziś :)

[artur1989]

Generalnie, temat "tricky" o którym wspominasz, złapałem i to nie wynika z zadania, stąd też moje pytanie. Poza tym, strategia zakłada sortowanie po krajach, więc w ogólnym rozumieniu sortujemy po kodach poszczególnych krajów, a nie po kodach i innych dodatkowych danych, aczkolwiek mogę się mylić. W każdym razie, wynik testów jest osiągalny, po analizie danych :)

[psmyrdek]

Potwierdzam, akurat tutaj dodałem kolejność wg mojego priorytetu a nie „alfabetycznie po kodzie kraju” ;)

[psmyrdek]

Słuszna uwaga - narzuciłem tę kolejność samemu, jako dodatkowy wariant pod kolejną strategię. Założenie było po prostu - utwórz implementację pod kolejną wariację danych.

[lotyszm]

Hej !

Ja te sortowanie po kodzie kraju zrobiłem w taki sposób - jakieś sugestie? Jak zrobić to optymalniej?

export const CountryTypes = ["pl", "de", "us"] as const;

export interface Letter {
  content: string;
  country: (typeof CountryTypes)[number];
  priority: "high" | "medium" | "low";
}

export interface ILetterSorterStrategy {
  sort(letters: Letter[]): Letter[];
}

export class LetterSorter {
  constructor(private strategy: ILetterSorterStrategy) {}

  sortLetters(letters: Letter[]): Letter[] {
    return this.strategy.sort(letters);
  }
}

export class PriorityStrategy implements ILetterSorterStrategy {
  sort(letters: Letter[]): Letter[] {
    return letters.sort((a, b) => {
      if (a.priority === "high") {
        return -1;
      }
      if (a.priority === "medium" && b.priority === "low") {
        return -1;
      }
      return 1;
    });
  }
}

export class CountryStrategy implements ILetterSorterStrategy {
  sort(letters: Letter[]): Letter[] {
    return letters.sort((a, b) => {
      return CountryTypes.indexOf(a.country) - CountryTypes.indexOf(b.country);
    });
  }
}

export class LengthStrategy implements ILetterSorterStrategy {
  sort(letters: Letter[]): Letter[] {
    return letters.sort((a, b) => {
      if (a.content.length < b.content.length) {
        return -1;
      }
      return 1;
    });
  }
}

Testy na zielono, ale optymalizacja zawsze na propsie 😁

[psmyrdek]

Dokładnie, chodziło po prostu o znalezienie sposobu na przedstawienie konkretnego układu państw a nie alfabetyczne kody krajów - powinno to być jaśniej ujęte ale masz ✅✅✅

[kewinzaq1]

type Country = 'pl' | 'de' | 'us'
type Priority = 'high' | 'medium' | 'low'

export interface Letter {
	content: string
	country: Country
	priority: Priority
}

export interface Strategy {
	sortLetters(letters: Letter[]): Letter[]
}

export class PriorityStrategy implements Strategy {
	private readonly priorityMap: Record<Priority, number> = {
		high: 1,
		medium: 2,
		low: 3,
	}
	sortLetters(letters: Letter[]): Letter[] {
		return letters
			.slice(0)
			.sort(
				(a, b) => this.priorityMap[a.priority] - this.priorityMap[b.priority],
			)
	}
}

export class CountryStrategy implements Strategy {
	private readonly countryMap: Record<Country, number> = {
		pl: 1,
		de: 2,
		us: 3,
	}

	sortLetters(letters: Letter[]): Letter[] {
		return letters.sort(
			(a, b) => this.countryMap[a.country] - this.countryMap[b.country],
		)
	}
}

export class LengthStrategy implements Strategy {
	sortLetters(letters: Letter[]): Letter[] {
		return letters.sort((a, b) => a.content.length - b.content.length)
	}
}

export class LetterSorter {
	constructor(private strategy: Strategy) {}

	sortLetters(letters: Letter[]): Letter[] {
		return this.strategy.sortLetters(letters)
	}
}

[KP1976]

export interface Letter {
  content: string;
  country: "pl" | "de" | "us";
  priority: "high" | "medium" | "low";
}

export interface Strategy {
  sortLetters(letters: Letter[]): Letter[];
}

export class LetterSorter {
  letters: Letter[] = [];

  constructor(private strategy: Strategy) {
    this.letters = [];
  }

  sortLetters(letters: Letter[]): Letter[] {
    this.letters = this.strategy.sortLetters(letters);
    return this.letters;
  }
}

export class PriorityStrategy implements Strategy {
  sortLetters(letters: Letter[]): Letter[] {
    return letters.sort((a, b) => {
      if (a.priority === b.priority) {
        return 0;
      } else if (a.priority === "high") {
        return -1;
      }

      return 1;
    });
  }
}

export class CountryStrategy implements Strategy {
  sortLetters(letters: Letter[]): Letter[] {
    return letters.sort((a, b) => {
      if (a.country === "pl") {
        return -1;
      } else if (a.country === "de") {
        return -1;
      } else {
        return 0;
      }
    });
  }
}

export class LengthStrategy implements Strategy {
  sortLetters(letters: Letter[]): Letter[] {
    return letters.sort((a, b) => a.content.length - b.content.length);
  }
}

[dominikbulaj]

Ja miałem taki LetterSorter

export class LetterSorter {
  constructor(private sortStrategy: SortStrategy) {}

  sortLetters(letters: Letter[]): Letter[] {
    return letters.sort(this.sortStrategy.sorter);
  }
}

i w tym sortowaniu z państwami taką implementację wag:

export class CountryStrategy implements SortStrategy {
  sorter: (a: Letter, b: Letter) => number = (a, b) => this.typeIndex(a.country) - this.typeIndex(b.country);

  typeIndex(country: Letter["country"]): number {
    switch (country) {
      case "pl":
        return 0;
      case "de":
        return 1;
      case "us":
        return 2;
      default:
        return 1000;
    }
  }
}