Buch Cover Buch Cover Buch Cover Buch Cover

Web-Code: - Webcode Help

Minimale Abkürzungen (Zeichenketten)

Schreibe eine Funktion, die eine Reihe von Zeichenketten annimmt und die eindeutige Folge von Abürzungen zurückgibt.
Die Funktion soll primär die Länge der Abkürzungen ausgeben, sekundär die Abürzungen als Array.

Beispiel 1:
Eingabe: ["Montag", "Dienstag", "Mittwoch", "Donnerstag", "Freitag", "Samstag", "Sonntag"]
Ausgabe: 2, ["Mo", "Di", "Mi", "Do", "Fr", "Sa", "So"] 

 

Beispiel 2:
Eingabe: ["Januar", "Februar", "März", "April", "Mai", "Juni", "Juli", "August", "September", "November", "Oktober", "November", "Dezember"]
Ausgabe: 3, ["Jan", "Feb", "Mär", "Apr", "Mai", "Jun", "Jul", "Aug", "Sep", "Okt", "Nov" "Dez"] 

 

Wende deine Funktion (Tage/Monate) auf alle Sprachen der EU an.

1 Kommentare

Bitte melde dich an um einen Kommentar abzugeben

Kommentare (1)

virgil 30. April 2022 22:04   reply report
Hier die nachgelieferte Verifikation/Checksumme für alle lesefaulen Programmierer.

(SPRACHE: (MINIMALE ABKÜRZUNGSLÄNGE TAG, MINIMALE AKBÜRZUNGSLÄNGE MONAT):

BG (bulgarisch): 2/3
CS (tschechisch): 2/7
DA (dänisch): 2/3
DE (deutsch): 2/3
EL (griechisch): 2/4
ES (spanisch): 2/3
ET (estnisch): 1/4
FI (finnisch): 2/3
FR (französisch): 2/4
GA (irisch): 4/3
HR (kroatisch): 2/3
HU (ungarisch): 3/3
IT (italienisch): 2/3
LT (litausich): 2/4
LV (lettisch): 3/3
MT (maltesisch): 6/2
NL (niederländisch): 2/3
PL (polnisch): 2/3
PT (portugiesisch): 3/3
RO (rumänisch): 2/3
SK (slowakisch): 2/3
SL (slowenisch): 2/3
SV (schwedisch): 2/3

Fertige Wortlisten machen ja keinen Sinn auf einer Plattform ohne Unicode-Unterstützung. Also strengt euch mal ein bisschen mehr an.
Prüft eure Codes, ob sie auch auf andere Sprachen uo. Arrays anwendbar sind.

6 Lösung(en)

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

// Sehr schöne Aufgabe. Leider ist nicht genau spezifiziert worden,
// was geschehen soll, wenn keine eindeutige Folge wie im Beispiel 3 vorliegt.
// In diesem Fall wird hier die Länge '0' und die 'Ursprungsliste' zurückgegeben.

// Beispiel 1
var lstWeekdays = new List<string> { "Montag", "Dienstag", "Mittwoch", "Donnerstag", "Freitag", "Samstag", "Sonntag" };
PrintAbbreviations(GetAbbreviations(lstWeekdays));

// Beispiel 2
var lstMonths = new List<string> { "Januar", "Februar", "März", "April", "Mai", "Juni", "Juli", "August", "September", "Oktober", "November", "Dezember" };
PrintAbbreviations(GetAbbreviations(lstMonths));

// Beispiel 3 (keine eindeutige Folge möglich, da 'Neujahr' aus nur 7 Zeichen besteht und somit 'Pfingstsonntag' bzw. 'Pfingstmontag' 'Pfingst' ergäben)
var lstHolidays = new List<string> { "Neujahr", "Karfreitag", "Ostersonntag", "Ostermontag", "TagDerArbeit", "ChristiHimmelfahrt", "Pfingstsonntag", "Pfingstmontag", "Fronleichnam", "TagDerDtEinheit", "Allerheiligen", "HeiligAbend", "Weihnachtstag" };
PrintAbbreviations(GetAbbreviations(lstHolidays));

(int, IList<string>) GetAbbreviations(IList<string> lst)
{
    var i = 1;
    for (; i < lst.Min(x => x.Length); i++)
        if (new HashSet<string>(lst.Select(x => x[..i])).Count == lst.Count) break;
    var abv = lst.Select(x => x[..i]).ToList();
    return new HashSet<string>(abv).ToList().Count != lst.Count ? (0, lst) : (i, abv);
}

void PrintAbbreviations((int num, IList<string> lst) abv) => Console.WriteLine($"{abv.num}, [{string.Join(", ", abv.lst)}]");
                

Lösung von: Jens Kelm (@JKooP)

// C++ 17

#include <iostream>
#include <vector>
#include <unordered_set>
#include <string>
#include <algorithm>

struct ObjectList {
    std::vector<std::string> objects;
    int length{ 0 };
};

 void objects_to_abbreviations(ObjectList& obj_list) {
    std::unordered_set<std::string> abv_set{};

    auto&& obj_min_length{ *std::max_element(cbegin(obj_list.objects), cend(obj_list.objects), 
        [](auto&& x, auto&& y) { return x.size() > y.size(); }) };

    for (auto i{ 0 }; i < obj_min_length.length(); i++) {

        for (const auto& obj : obj_list.objects)
            abv_set.insert(obj.substr(0, static_cast<long long>(i) + 1));

        // Variante 1
        if (abv_set.size() == obj_list.objects.size()) {
            obj_list.objects = std::vector<std::string>(abv_set.begin(), abv_set.end());
            obj_list.length = i + 1;
            return;
        }

        // Variante 2, falls die Variante 1 ungeordnet sein sollte (je nach Implementierung unterschiedlich)
        //if (abv_set.size() == obj_list.objects.size()) {
        //    for (auto& obj : obj_list.objects)
        //        obj = obj.substr(0, static_cast<long long>(i) + 1);
        //    obj_list.length = i + 1;
        //    return;
        //}

        abv_set.erase(abv_set.begin(), abv_set.end());
    }
 }

 void print_abbreviations(const ObjectList& obj_list) {
     std::string str{ std::to_string(obj_list.length) + ", [" };
     for (const auto& obj : obj_list.objects)
         str += obj + ", ";
     std::cout << str.substr(0, str.length() - 2) + "]\n";
 }

int main() {
    std::vector<std::string> lst_months{ "January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December" };
    ObjectList months{ lst_months };
    objects_to_abbreviations(months);
    print_abbreviations(months);
}
                

Lösung von: Jens Kelm (@JKooP)

Array.prototype.hasDoubles = function() {
  let arr = this.slice();  // array kopieren
  while (arr.length > 1) {
    let cur = arr.shift();
    if (arr.includes(cur)) return true;
  }
  return false;
}

Array.prototype.abbreviate = function(len) {
  let arr = this.slice();
  for (let i = 0; i < arr.length; i++)
    arr[i] = arr[i].substr(0, len);
  return arr;
}

/*------------------------------------------------------*\
|  UNSERE KERNFUNKTION:                                  |
|  ermittelt die minimale abkürzungslänge in einem array |
\*------------------------------------------------------*/
function getMinAbbrLen(arr) {
  if (arr.length <= 1) return undefined;
  let testArr = [],
      len = 0, i;
  do {
    len++;
    for (i = 0; i < arr.length; i++)
      testArr[i] = arr[i].substr(0, len);
  } while (testArr.hasDoubles());
  return len;
}

/*------*\
|  MAIN  |
\*------*/

const
  EC_LANGS = // kürzel der offiziellen eu-sprachen
    'bg cs da de el es et fi fr ga hr hu it lt lv mt nl pl pt ro sk sl sv'.split(' '),
  // irgendein montag im januar; hier der 3. 1. 2000
  INIT_DAY = new Date(2000, 0, 3);

let days = [], months = [], // listen der tages- und monatsnamen
    i, j;

// listen initialisieren
for (i = 0; i < EC_LANGS.length; i++) {
  days.push([]);
  months.push([]);
}

/* LISTEN FÜLLEN */
// wir benutzen hier javaScripts toLocaleString(),
// um nicht extralisten zu definieren

// das wäre noch leicht zusammenzufassen,
// bleibt aber erstmal so für die lesbarkeit:

// wochentage
let d = new Date(INIT_DAY);
for (i = 0; i < 7; i++) {
  for (j = 0; j < EC_LANGS.length; j++)
    days[j].push(d.toLocaleString(EC_LANGS[j], {weekday: 'long'}));
  d.setDate(d.getDate() + 1);
}

// monatsnamen
d = new Date(INIT_DAY);
for (i = 0; i < 12; i++) {
  for (j = 0; j < EC_LANGS.length; j++)
    months[j].push(d.toLocaleString(EC_LANGS[j], {month: 'long'}));
  d.setMonth(d.getMonth() + 1);
}

/*-------*\
| AUSGABE |
\*-------*/

for (i = 0; i < EC_LANGS.length; i++) {
  let lenD = getMinAbbrLen(days[i]),
      lenM = getMinAbbrLen(months[i]),
      abbD = days[i].abbreviate(lenD),
      abbM = months[i].abbreviate(lenM);
  document.write(`
    <h1>${EC_LANGS[i]}</h1>
    <p><i>${days[i].join(', ')}</i><br><b>(${lenD}): ${abbD.join('. ')}</b>.</p>
    <p><i>${months[i].join(', ')}</i><br><b>(${lenM}): ${abbM.join('. ')}</b>.</p>
  `);
}

                

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

def abbreviations(inp):
    import bisect
    length = bisect.bisect_left(range(1, max(map(len, inp)) + 1), True, key=lambda new_len: len(set(map(lambda x: x[:new_len], inp))) == len(inp)) + 1
    return [x[:length] for x in inp]

print(abbreviations(["Montag", "Dienstag", "Mittwoch", "Donnerstag", "Freitag", "Samstag", "Sonntag"]))
                

Lösung von: Name nicht veröffentlicht

def abrevate(eingabe):
    ausgabe = ()
    i = 0
    while len(set(ausgabe)) < len(eingabe):
        i = i + 1
        ausgabe = tuple(map(lambda x: x[:i], eingabe))
    return ausgabe

print(abrevate(("Montag", "Dienstag", "Mittwoch", "Donnerstag", "Freitag", "Samstag", "Sonntag")))
                

Lösung von: Rc Mlz ()

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

var lstWeekdays = new List<string> { "Montag", "Dienstag", "Mittwoch", "Donnerstag", "Freitag", "Samstag", "Sonntag" };
lstWeekdays.GetAbbreviations().PrintAbbreviations();

public static class MyExtensions {
    public static (int, IList<string>) GetAbbreviations(this IList<string> lst) {
        for (var i = 1; i < lst.Min(x => x.Length); i++) {
            var abv = lst.Select(x => x[..i]).ToList();
            if (new HashSet<string>(abv).Count == lst.Count) return (i, abv);
        }
        return (0, lst);
    }
    public static void PrintAbbreviations(this (int num, IList<string> lst) abv) => Console.WriteLine($"{abv.num}, [{string.Join(", ", abv.lst)}]");
}
                

Lösung von: Jens Kelm (@JKooP)

Aktionen

Bewertung

Durchschnittliche Bewertung:

Eigene Bewertung:
Bitte zuerst anmelden

Meta

Zeit: 1
Schwierigkeit: Leicht
Webcode: c6up-nev5
Autor: ()

Download PDF

Download ZIP

Zu Aufgabenblatt hinzufügen