Personen sortieren (Datenstrukturen)
Schreiben Sie ein Programm, das in einer Liste Personen (Namen, Vornamen und Postleitzahl) speichert. Die Benutzerin gibt so lange Personennamen ein, bis sie mit "ENDE DER LISTE" die Eingabe beendet. Jede eingegebene Person wird an die Liste angefügt. Am Schluss wird die Liste sortiert; dazu verwenden Sie eine Sortiermethode Ihrer Programmiersprache. Geben Sie die Liste je sortiert nach Name, Vorname, aber auch nach Postleitzahl wieder aus.
0 Kommentare
Bitte melde dich an um einen Kommentar abzugeben
7 Lösung(en)
personen=[]
while (True):
Familienname = str(raw_input("Familienname: "))
if Familienname.upper() == 'ENDE DER LISTE':
break
Vorname = str(raw_input("Vorname: "))
plz = str(raw_input("PLZ: "))
personen.append((Familienname,Vorname,plz))
print personen
print''
print'Sortiert nach Familienname:'
list1 = sorted(personen, key=lambda person: person[0])
for dataset in list1:
print dataset[0]
print dataset[1]
print dataset[2]
print''
print'Sortiert nach PLZ'
list2 = sorted(personen, key=lambda person: person[2])
for dataset in list2:
print dataset[0]
print dataset[1]
print dataset[2]
import java.util.*;
/**
* Aufgabe 8.4 Personen sortieren
* @author Philipp Gressly (phi AT gressly DOT ch)
* Nov. 2010
*/
public class PersonenSortieren {
public static void main(String[] args) {
try {
new PersonenSortieren().top();
} catch (Exception e) {
e.printStackTrace();
}
}
class Person {
public String name, vorname;
public int PLZ; // Post Leitzahl
@Override
public String toString() {
return name + " " + vorname + " aus " + PLZ;
}
}
class Sortierer implements Comparator<Person> {
String sortFeld;
java.lang.reflect.Field feld;
public Sortierer(String sortFeld)
throws Exception
{
this.sortFeld = sortFeld;
Class c = Person.class;
feld = c.getField(sortFeld);
}
/* overriden */
@Override
public int compare(Person p1, Person p2) {
try {
if(isNumericField()) {
double d1 = getFieldDouble(p1);
double d2 = getFieldDouble(p2);
if(d2 < d1) return 1;
if(d2 == d1) return 0;
if(d2 > d1) return -1;
}
if(isStringField()) {
String s1 = getFieldString(p1);
String s2 = getFieldString(p2);
return s1.compareTo(s2);
}
return 0;
}catch (Exception ex){
ex.printStackTrace();
}
return 0;
}
boolean isNumericField() throws Exception {
return feld.getType() == int.class;
}
boolean isStringField() throws Exception {
return feld.getType() == String.class;
}
double getFieldDouble(Person person) throws Exception {
Number n = (Number) feld.get(person);
return n.doubleValue();
}
String getFieldString(Person person) throws Exception {
return (String) feld.get(person);
}
}
ArrayList<Person> personen = new ArrayList<Person>();
void top() throws Exception {
einlesen();
Sortierer sName = new Sortierer("name");
sortiere(sName);
System.out.println("Nach Name:");
ausgabe();
Sortierer sVorname = new Sortierer("vorname");
sortiere(sVorname);
System.out.println("Nach Vorname:");
ausgabe();
Sortierer sPLZ = new Sortierer("PLZ");
sortiere(sPLZ);
System.out.println("Nach PLZ:");
ausgabe();
}
void ausgabe() {
for(Person p: personen) {
System.out.println(p);
}
}
void sortiere(Sortierer sortierer) {
Collections.sort(personen, sortierer);
}
void einlesen() {
boolean ende_der_liste = false;
while(!ende_der_liste) {
Person p = new Person();
p.name = einlesenString("Name od \"ENDE DER LISTE\"");
if(! "ENDE DER LISTE".equalsIgnoreCase(p.name)) {
p.vorname = einlesenString("Vorname");
p.PLZ = einlesenInt("PLZ");
personen.add(p);
} else {
ende_der_liste = true;
}
}
}
Scanner sc = new Scanner(System.in);
String einlesenString(String frage) {
System.out.println("Bitte " + frage + " eingeben:");
return sc.nextLine();
}
int einlesenInt(String frage) {
System.out.println("Bitte " + frage + " eingeben:");
return Integer.parseInt(sc.nextLine().trim());
}
} // end of class PersonenSortieren
/*************************************\
|* Globale Deklarationen. (Global.inc) *|
\*************************************/
%dcl BUFSIZE CHAR;
%BUFSIZE = '1024';
%dcl TRUE CHAR;
%TRUE = "'1'b";
%dcl FALSE CHAR;
%FALSE = "'0'b";
/* END of INCLUDE FILE */
/* PERSON.INC */
/*******************************************************************/
/* Autor : ph. gressly freimann (@ http://www.sanits-training.ch) */
/* Datum : 1. Dez. 2011 */
/* Aufgabe 8.4 (Programmieraufgaben.ch: Personen sortieren) */
/*******************************************************************/
define structure
1 tPerson,
2 name char(BUFSIZE) varying,
2 vorname char(BUFSIZE) varying,
2 plz bin fixed(15);
/* END of INCLUDE FILE */
/*********************** sortPres.pli: *********************/
*process langlvl(saa2);
*process or('!');
*process limits(fixeddec(31));
*process aggregate, attributes;
*process flag(W), source, insource, options, xref, nest, number, offset;
*process gonumber, snap, macro;
/*******************************************************************/
/* Autor : ph. gressly freimann (@ http://www.sanits-training.ch) */
/* Datum : 1. Dez. 2011 */
/* Aufgabe 8.4 (Programmieraufgaben.ch: Personen sortieren) */
/*******************************************************************/
(SUBSCRIPTRANGE, SIZE, STRINGRANGE, STRINGSIZE):
sortPers: proc options(main noexecops);
%include Global;
%include Person;
dcl personenListe dim (20) type tPerson;
dcl cntPersonen bin fixed(31) init(0);
call personenListeEinlesen();
call personenListeSortieren("name");
display("Sortiert nach Name:");
call personenListeAusgeben();
call personenListeSortieren("vorname");
display("Sortiert nach Vorname:");
call personenListeAusgeben();
call personenListeSortieren("plz");
display("Sortiert nach PLZ:");
call personenListeAusgeben();
/* END */
/* Subroutinen */
personenListeEinlesen: proc;
dcl aktZeile char(BUFSIZE) varying;
dcl plzStr char(BUFSIZE) varying;
do while(TRUE);
/* Funktioniert in der Konsole, nicht aber in der VisualAge
Konsole !! */
display ("Name eingeben (mit 'ENDE DER LISTE' beenden): ")
reply(aktZeile);
if("ENDE DER LISTE" = aktZeile) then do;
return;
end; /* IF Ende */
cntPersonen = cntPersonen + 1;
personenListe(cntPersonen).name = aktZeile;
personenListe(cntPersonen).vorname = lies("Vorname");
plzStr = lies("PLZ");
personenListe(cntPersonen).plz = plzStr;
end; /* do weiterlesen */
end personenListeEinlesen;
/**
* Liest ein Attribut von der Konsole (eingabe von hand)
*/
lies: proc(attName) returns(char(BUFSIZE) varying);
dcl attName char(BUFSIZE) varying;
dcl eingabe char(BUFSIZE) varying;
display("Bitte " !! attName !! " eingeben : ")
reply(eingabe);
return (eingabe);
end lies;
personenListeSortieren: proc(attr);
dcl attr char(BUFSIZE) varying;
/* selection sort: */
dcl sortiertBis bin fixed(15) init(0);
/* Index des Minimums: */
dcl mindex bin fixed(15) init(0);
do while(sortiertBis <= cntPersonen - 1);
mindex = findeMindex(attr, sortiertBis + 1);
call tausche(mindex, sortiertBis + 1);
sortiertBis = sortiertBis + 1;
end; /* do sortiert bis */
end personenListeSortieren;
tausche: proc(a, b);
dcl a bin fixed(15); /* Pos Person A */
dcl b bin fixed(15); /* Pos Person B */
dcl persTemp type tPerson;
persTemp = personenListe(b);
personenListe(b) = personenListe(a);
personenListe(a) = persTemp;
end tausche;
findeMindex: proc(attr, ab) returns(bin fixed(15));
dcl attr char(BUFSIZE) varying;
dcl ab bin fixed(15);
dcl mindex bin fixed(15);
dcl sucher bin fixed(15);
sucher = ab;
mindex = ab;
do while(sucher <= cntPersonen);
if(istKleiner(attr, sucher, mindex)) then do;
mindex = sucher;
end; /* if kleiner */
sucher = sucher + 1;
end; /* WHILE */
return (mindex);
end findeMindex;
istKleiner: proc(attr, a, b) returns (bit(1));
dcl attr char(BUFSIZE) varying;
dcl a bin fixed(15);
dcl b bin fixed(15);
dcl personA type tPerson;
dcl personB type tPerson;
personA = personenListe(a);
personB = personenListe(b);
if("name" = attr) then do;
return (personA.name < personB.name);
end; /* if */
if("vorname" = attr) then do;
return (personA.vorname < personB.vorname);
end; /* if */
if("plz" = attr) then do;
return (personA.plz < personB.plz);
end;
return (TRUE);
end istKleiner;
personenListeAusgeben: proc;
dcl actID bin fixed(15) init(1);
do while(actID <= cntPersonen);
call ausgabePerson(personenListe(actID));
actID = actID + 1;
end; /* do while */
end personenListeAusgeben;
ausgabePerson: proc(person);
dcl person type tPerson;
display("Name : " !! person.name );
display("Vorname: " !! person.vorname);
display("PLZ : " !! person.plz );
/* Leerzeile */
display("");
end ausgabePerson;
end sortPers;
Lösung von: Philipp G. Freimann (BBW (Berufsbildungsschule Winterthur) https://www.bbw.ch)
package ch.santis.programmierenlernen.kapitel8;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Scanner;
//Aufgabe 8.4 Personen sortieren (ohne Eingabe-Fehlerbehandlung)
public class Aufgabe_8_4 {
public static void main(String[] args) {
new Aufgabe_8_4().top();
}
public static class Person {
public String vorname, nachname;
public int plz;
public Person(String vorname, String nachname, int plz) {
this.vorname = vorname;
this.nachname = nachname;
this.plz = plz;
}
@Override
public String toString() {
return vorname + " " + nachname + " " + plz;
}
public static Comparator<Person> sortByVorname = new Comparator<Person>() {
public int compare(Person p1, Person p2) {
//sort in ascending order
return p1.vorname.compareTo(p2.vorname);
}
};
public static Comparator<Person> sortByNachname = new Comparator<Person>() {
public int compare(Person p1, Person p2) {
//sort in ascending order
return p1.nachname.compareTo(p2.nachname);
}
};
public static Comparator<Person> sortByPlz = new Comparator<Person>() {
public int compare(Person p1, Person p2) {
//sort in ascending order
return p1.plz-p2.plz;
}
};
}
ArrayList<Person> personen = new ArrayList<Person>();
void top() {
einlesen();
ausgabe();
}
public void ausgabe() {
Collections.sort(personen, Person.sortByVorname);
System.out.println("===============\nNach Vorname: ");
for(Person p : personen) {
System.out.println(p);
}
Collections.sort(personen, Person.sortByNachname);
System.out.println("===============\nNach Nachname:");
for(Person p : personen) {
System.out.println(p);
}
Collections.sort(personen, Person.sortByPlz);
System.out.println("===============\nNach Postleitzahl:");
for(Person p : personen) {
System.out.println(p);
}
}
public void einlesen() {
boolean ende = false;
while(!ende) {
Person p = new Person(null, null, 0);
p.vorname = eingabeString("Vorname eingeben:");
if("ENDE DER LISTE".equalsIgnoreCase(p.vorname)) {
ende = true;
}
else {
p.nachname = eingabeString("Nachname eingeben:");
p.plz = Integer.parseInt(eingabeString("Postleitzahl eingeben:").trim());
//p.plz = eingabeInt("Plz eingeben:"); //Wenn mit dem nextLine BugFix gearbeitet wird
personen.add(p);
}
}
}
// Scanner Einlesen
Scanner sc = new Scanner(System.in);
public String eingabeString(String text) {
System.out.println(text);
return sc.nextLine();
}
/* Wenn mit nextInt() Scanner eingelesen wird, ist ein "Bugfix" erforderlich.
* Da sonst nach einem nextInt der nächste nextLine "automatisch" die Enter-Eingabe \n vom nextInt einlesen wird. \n befindet sich im Buffer.
public int eingabeInt(String text) {
System.out.println(text);
int i = sc.nextInt();
sc.nextLine(); //Bugfix for nextLine() Scanner after a nextInt()
return i;
}*/
}
Lösung von: Jan Roth (Santis Training AG)
function Person(firstName, lastName, postcode) {
this.fn = firstName;
this.ln = lastName;
this.pc = postcode;
}
let persons = [];
// hier besteht noch optimierungsbedarf
function sortPersonsByLastName() {
persons = persons.sort( function(a, b) {return a.ln.localeCompare(b.ln)} );
}
function sortPersonsByFirstName() {
persons = persons.sort( function(a, b) {return a.fn.localeCompare(b.fn)} );
}
function sortPersonsByPostCode() {
persons = persons.sort( function(a,b) {return a.pc - b.pc} );
}
function add() {
let p = new Person(
document.getElementById('fn').value,
document.getElementById('ln').value,
document.getElementById('pc').value
);
persons.push(p);
document.getElementById('fn').value = '';
document.getElementById('ln').value = '';
document.getElementById('pc').value = '';
}
function showlist() {
let out = '';
for (p in persons) {
out += `${persons[p].fn} ${persons[p].ln}, ${persons[p].pc}<br>`;
}
return out;
}
function list() {
sortPersonsByLastName();
document.getElementById('pByLn').innerHTML =
showlist();
sortPersonsByFirstName();
document.getElementById('pByFn').innerHTML =
showlist();
sortPersonsByFirstName();
sortPersonsByPostCode();
document.getElementById('pByPc').innerHTML =
showlist();
}
// eingabemaske
document.write(`
<label>Vorname: </label><input type="text" id="fn"><br>
<label>Nachname: </label><input type="text" id="ln"><br>
<label>PLZ: </label><input type="number" id="pc"><br>
<button onclick="add()">Hinzufügen</button>
<button onclick="list()">Ende der Eingabe</button><br>
<label>Personen nach Nachname:</label><div id="pByLn"> </div><br>
<label>Personen nach Vorname:</label><div id="pByFn"> </div><br>
<label>Personen nach PLZ: </label><div id="pByPc"> </div>
`); // lissalanda@gmx.at
Lösung von: Lisa Salander (Heidi-Klum-Gymnasium Bottrop)
// NET 6.x | C# 10.x | VS-2022
using static System.Console;
var lst = new List<Person>();
while (true)
{
Write("Bitte leerzeichengetrennt Nachname, Vorname und PLZ eingeben: ");
var input = ReadLine();
if (string.IsNullOrEmpty(input) || input.ToUpper() == "ENDE DER LISTE") break;
var arr = input.Split(" ").ToArray();
if (arr.Length == 3)
lst.Add(new Person(arr[0], arr[1], arr[2]));
else WriteLine("Unvollständiger Datensatz");
WriteLine();
}
lst.OrderBy(x => x.Lastname).ToList().ForEach(x => WriteLine($"{x.Lastname} | {x.Firstname} | {x.ZipCode}"));
lst.OrderBy(x => x.Firstname).ToList().ForEach(x => WriteLine($"{x.Firstname} | {x.Lastname} | {x.ZipCode}"));
lst.OrderBy(x => x.ZipCode).ToList().ForEach(x => WriteLine($"{x.ZipCode} | {x.Lastname} | {x.Firstname}"));
public record struct Person(string Lastname, string Firstname, string ZipCode);
Lösung von: Jens Kelm (@JKooP)
// C++ 20 | VS-2022
#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <sstream>
struct Person {
std::string lastName, firstName, zipCode;
friend auto& operator<<(std::ostream& os, const Person& pers) {
os << pers.lastName << ", " << pers.firstName << ", " << pers.zipCode << "\n";
return os;
}
};
auto main() -> int {
std::vector<Person> persons{};
const auto print{ [&persons]() { for (const auto& p : persons) std::cout << p; } };
const auto sort{ [&persons] <typename F>(F f) { std::sort(persons.begin(), persons.end(), f); } };
while (true) {
std::string tmp{};
std::cout << "Bitte leerzeichengetrennt Nachname, Vorname und PLZ eingeben: ";
std::getline(std::cin, tmp);
if(std::empty(tmp) || tmp == "ENDE DER LISTE") break;
std::istringstream iss{ tmp };
const std::vector<std::string> split{ (std::istream_iterator<std::string>(iss)), std::istream_iterator<std::string>() };
if (split.size() == 3)
persons.push_back({ split[0], split[1], split[2] });
else
std::cout << "Unvollstaendiger oder falscher Datensatz!\n";
}
sort([](Person x, Person y) { return y.lastName > x.lastName; });
std::cout << "Nachnamen:\n"; print();
sort([](Person x, Person y) { return y.firstName > x.firstName; });
std::cout << "\nVornamen:\n"; print();
sort([](Person x, Person y) { return y.zipCode > x.zipCode; });
std::cout << "\nPLZ:\n"; print();
}
Lösung von: Jens Kelm (@JKooP)
Aktionen
Neue Lösung hinzufügen
Bewertung
Durchschnittliche Bewertung:
Meta
| Zeit: | 2 |
| Schwierigkeit: | k.A. |
| Webcode: | bkqq-ryq7 |
| Autor: | Philipp G. Freimann (BBW (Berufsbildungsschule Winterthur) https://www.bbw.ch) |