Buch Cover Buch Cover Buch Cover Buch Cover

Web-Code: - Webcode Help

Sortieren von Datenstrukturen (Datenstrukturen)

Diese Aufgabe ist analog zur obigen. Diesmal sollen jedoch nicht Strings sortiert werden, sondern Kamel-Objekte. Das bedingt aber, dass wir uns Gedanken machen, wie die Tiere dann sortiert werden sollten. Dazu haben wir in Java die Möglichkeiten das Comparable-Interface zu implementieren, oder einen eigens zum Sortieren vorgesehenen Comparator (java.util.Comparator) zu schreiben. Diskutieren Sie die beiden Methoden und sortieren Sie die Tiere einmal nach Name und das andere Mal nach dem Alter.

0 Kommentare

Bitte melde dich an um einen Kommentar abzugeben

3 Lösung(en)

// kamel-array mit zusatzfunktion
let camels = [];
camels.logFirstAndLast = function() {
  console.log(`Kamel #0000001:`);
  console.table(camels[0]);
  console.log(`Kamel #1000000:`);
  console.table(camels[999999]);
  console.log(`
-------------------------------------------------------------


`);
}

// wat isenen kamel?
function Camel(name, age) {
  this.name = name;
  this.age = age;
  this.isLBGT = Math.random() < 0.074;
}

// gib mir eine million kamele!
console.log('Kamele werden erstellt...');
for (let i = 1; i <= 1e6; i++) camels.push(createCamel());
console.log('   ... fertig!');

// kamel-fabrik
function createCamel() {
  let c = new Camel;
  c.name = Math.floor((Math.random() * 1e8) + 1).toString(36).toUpperCase();
  c.age = Math.floor(Math.random() * 41);
  return c;
}

// sortieralgorithmen
function byName(a, b) { return a.name.localeCompare(b.name); }
function byAge(a, b) { return a.age - b.age; }
function byPreference(a, b) { return a.isLBGT - b.isLBGT; }



/*----------------------------------------------------------*\
|              ¡ XXTREME-KAMELSORTIERING !                   |
\*----------------------------------------------------------*/

console.time('total');

// nach name
console.log('Kamele werden nach Name sortiert...');
console.time('sortByStr')
//--------------------------
camels.sort(byName);
//--------------------------
console.timeEnd('sortByStr')
console.log('   ... fertig!');

console.log('Logge...');
console.log(camels);
camels.logFirstAndLast();

// nach alter
console.log('Kamele werden nach Alter sortiert...');
console.time('sortByNum')
//--------------------------
camels.sort(byAge);
//--------------------------
console.timeEnd('sortByNum')
console.log('   ... fertig!');

console.log('Logge...');
console.log(camels);
camels.logFirstAndLast();

// nach lbgt
console.log('Kamele werden nach Community sortiert...');
console.time('sortByBool')
//--------------------------
camels.sort(byPreference);
//--------------------------
console.timeEnd('sortByBool')
console.log('   ... fertig!');

console.log('Logge...');
console.log(camels);
camels.logFirstAndLast();

// nach name absteigend
console.log('Kamele werden absteigend nach Name sortiert...');
console.time('sortByStrRev')
//--------------------------
camels.sort(byName).reverse();
//--------------------------
console.timeEnd('sortByStrRev')
console.log('   ... fertig!');

console.log('Logge...');
console.log(camels);
camels.logFirstAndLast();

// nach alter absteigend
console.log('Kamele werden absteigend nach Alter sortiert...');
console.time('sortByNumRev')
//--------------------------
camels.sort(byAge).reverse();
//--------------------------
console.timeEnd('sortByNumRev')
console.log('   ... fertig!');

console.log('Logge...');
console.log(camels);
camels.logFirstAndLast();

// nach lbgt absteigend
console.log('Kamele werden absteigend nach Community sortiert...');
console.time('sortByBoolRev')
//--------------------------
camels.sort(byPreference).reverse();
//--------------------------
console.timeEnd('sortByBoolRev')
console.log('   ... fertig!');

console.log('Logge...');
console.log(camels);
camels.logFirstAndLast();

console.log('~ Ende ~');
console.timeEnd('total');


/*=====================================================================*\
| ABSCHLIESSENDE ERGEBNISDISKUSSION                                     |
| ===================================================================== |
| Ich kann mit den ergebnissen unbesorgt weiterleben. Auch die kamele   |
| sind nach eigenen angaben wohlauf und zu weiteren schandtaten bereit. |
|                                                     lissalanda@gmx.at |
\*---------------------------------------------------------------------*/

                

Lösung von: Lisa Salander (Heidi-Klum-Gymnasium Bottrop)

// NET 6.x | C# 10.x | VS-2022

const int LEN_NAME = 10;
const int MIN_WEIGHT = 200, MAX_WEIGHT = 500;
const int MIN_AGE = 10, MAX_AGE = 40;

// create camels
var lstCamel = CreateCamels(10);

// camels order by... (ascending/descending)
Console.WriteLine("order by name ascending:");
PrintCamels(OrderByName(true));

Console.WriteLine("\norder by age descending:");
PrintCamels(OrderByAge(false));

Console.WriteLine("\norder by weight descending:");
PrintCamels(OrderByWeight(false));

// functions
IEnumerable<Camel> CreateCamels(int num) {for (int i = 0; i < num; i++) yield return GetCamel(); }

void PrintCamels(IEnumerable<Camel> lst) => lst.ToList().ForEach(x => Console.WriteLine(x));

IEnumerable<Camel> OrderByName (bool asc) => asc ? lstCamel.OrderBy(x => x.Name) : lstCamel.OrderByDescending(x => x.Name);
IEnumerable<Camel> OrderByAge (bool asc) => lstCamel.OrderBy(x => asc ? x.Age : -x.Age);
IEnumerable<Camel> OrderByWeight (bool asc) => lstCamel.OrderBy(x => asc ? x.Weight : -x.Weight);

static Camel GetCamel() {
    var name = string.Join("", Enumerable.Range(0, LEN_NAME).Select(x => (char)new Random().Next(65, 90)));
    var age = new Random().Next(MIN_AGE, MAX_AGE);
    var weight = new Random().Next(MIN_WEIGHT, MAX_WEIGHT);
    return new Camel(name, age, weight);
}
public record struct Camel(string Name, int Age, int Weight);
                

Lösung von: Jens Kelm (@JKooP)

// C++ 14 | VS-2022
#include <iostream>
#include <random>
#include <vector>

constexpr size_t LEN_NAME{ 10 };
constexpr size_t MIN_WEIGHT{ 200 };
constexpr size_t MAX_WEIGHT{ 500 };
constexpr size_t MIN_AGE{ 10 };
constexpr size_t MAX_AGE{ 40 };

enum class AscDesc {
    ascending, descending
};

enum class SortType {
    name, age, weight
};

struct Camel {
    std::string name_;
    size_t age_, weight_;
};

template<typename Ty_ = size_t>
inline const auto get_random_range(const Ty_& first, const Ty_& last) {
	std::random_device dev;
	std::mt19937 rng(dev());
	std::uniform_int_distribution<Ty_>dist(first, last);
	return dist(rng);
}

inline const auto get_name() {
    std::string name{};
    name.push_back(get_random_range(65, 90));
    for (size_t i{ 0 }; i < LEN_NAME - 1; ++i)
        name.push_back(get_random_range(97, 122));
    return name;
}

inline const auto get_age() {
    return get_random_range(MIN_AGE, MAX_AGE);
}

inline const auto get_weight() {
    return get_random_range(MIN_WEIGHT, MAX_WEIGHT);
}

inline const auto get_new_camel() {
    return Camel{ get_name(), get_age(), get_weight() };
}

inline const auto get_list_of_camels(size_t num) {
    std::vector<Camel>camels{};
    for (size_t i{ 0 }; i < num; ++i)
        camels.push_back(get_new_camel());
    return camels;
}

template<typename Ty_, typename Func_>
inline const auto get_ordered_by_(const Ty_& container, const Func_& func) {
    Ty_ con{ container };
    std::sort(con.begin(), con.end(), func);
    return con;
}

inline const auto get_ordered_by_type(const std::vector<Camel>& camels, const SortType& sort_t = SortType::name, const AscDesc& asc_desc = AscDesc::ascending) {
    return get_ordered_by_(camels, [&asc_desc,&sort_t](auto x, auto y) {
        bool res{};
        switch (sort_t) {
            case SortType::weight: res = (asc_desc == AscDesc::descending) ? (x.weight_ > y.weight_) : (x.weight_ < y.weight_); break;
            case SortType::age: res = (asc_desc == AscDesc::descending) ? (x.age_ > y.age_) : (x.age_ < y.age_); break;
            default: res = (asc_desc == AscDesc::descending) ? (x.name_ > y.name_) : (x.name_ < y.name_); break;
        }
    return res;
    });
}

std::ostream& operator<<(std::ostream& os, const Camel& camel) {
    os << "\tName: " << camel.name_ << "\n";
    os << "\tAlter: " << camel.age_ << "\n";
    os << "\tGewicht: " << camel.weight_ << "\n";
    return os;
}

std::ostream& print(std::ostream& os, const std::vector<Camel>& camels) {
    for (const auto& camel : camels)
        std::cout << camel << "\n";
    return os;
}

int main() {
    std::cout << "alle erzeugten Kamele:\n";
    const auto camels{ get_list_of_camels(10) };
    print(std::cout, camels);

    std::cout << "sortiert aufsteigend nach Name:\n";
    print(std::cout, get_ordered_by_type(camels));

    std::cout << "sortiert absteigend nach Alter:\n";
    print(std::cout, get_ordered_by_type(camels, SortType::age, AscDesc::descending));
    
    std::cout << "sortiert aufsteigend nach Gewicht:\n";
    print(std::cout, get_ordered_by_type(camels, SortType::weight, AscDesc::ascending));
}

                

Lösung von: Jens Kelm (@JKooP)

Aktionen

Bewertung

Durchschnittliche Bewertung:

Eigene Bewertung:
Bitte zuerst anmelden

Meta

Zeit: 2
Schwierigkeit: k.A.
Webcode: 2rqb-g58q
Autor: Philipp G. Freimann (BBW (Berufsbildungsschule Winterthur) https://www.bbw.ch)

Download PDF

Download ZIP

Zu Aufgabenblatt hinzufügen