Greife auf das erste Zeichen des zweiten Wortes zu und ändere es in Großbuchstaben (licht -> Licht).

[Kudde]

Moin zusammen, ich bin neu hier, und mache gerade einen Python für KI Lehrgang. Bei einen Test wurde folgende Aufgabe gestellt:

Greife auf das erste Zeichen des zweiten Wortes zu und ändere es in Großbuchstaben (licht -> Licht).


satz = "Das licht des Mondes beleuchtet DIE Nacht."

Danke im voraus
Kudde

[imonbln]

die Aufgabe ist ein Oneliner, wenn man weiß, was man tut. Was hast du denn für ein Problem mit der Aufgabe? Das Forum hier ist Hilfe zur Selbsthilfe, daher sage ich dir den Oneliner nicht, sondern will erst sehen, was du hast.

Falls du einen Einstieg suchst, könntest du das hier lesen: https://docs.python.org/3/library/stri ... .capwords , Es sind nicht die Droiden, die du suchst, aber vielleicht hilft die Beschreibung dabei, zu überlegen, was du machen willst bzw. musst.

[Sirius3]

Die Aufgabe ist schlecht gestellt. Da sind zu viele offene Fragen. Zuerst einmal kann man einen String in Python nicht ändern und damit auch kein einzelnes Zeichen.
Dann ist die Frage, wie ist ein Wort definiert? Laut Beispielsatz könnte es bedeuten, dass es reicht, den String an Leerzeichen aufzuteilen, könnte aber auch sein, dass beliebiger Leerraum gemeint ist, ...

Die Aufgabe bedeutet also wahrscheinlich, "schreibe eine Funktion, die einen String als Argument entgegennimmt und einen String zurückliefert, bei dem beim zweiten Wort (Wörter sind durch jeweils exakt ein Leerzeichen getrennt) das erste Zeichen in einen Großbuchstaben geändert wird, sofern es sich um einen Kleinbuchstaben handelt.

[Kebap]

Moin Kudde, viel Spaß bei dem Lehrgang! Danke, dass du deine Aufgabe hier reingestellt hast. Welche Hilfe hättest du gern?

[Kudde]

Moin, man kann Daten im String verändern, oder hinzufügen, so sieht die Aufgabe aus:

satz = "Das licht des Mondes beleuchtet DIE Nacht."

# Verwende die split-Methode, um den Satz in eine Liste von Wörtern aufzuteilen.

split_satz = satz.split()
print(split_satz)
#Greife auf das erste Zeichen des zweiten Wortes zu und ändere es in Großbuchstaben (licht -> Licht).


print(satz.strip())

# Ändere das erste ganze Wort in Großbuchstaben und das vorletzte Wort in Kleinschreiben.



# Füge zwischen dem vierten und fünften Wort einen Zeilenumbruch ein.



# Stelle sicher, dass dein endgültiger Satz den erwarteten Änderungen entspricht.



# DAS Licht des Mondes beleuchtet die Nacht

[noisefloor]

Hallo,

was an Kontext auch noch fehlt, weil explizit auf den "KI Lehrgang" hingewiesen wurde: sollt ihr das mit Bordmitteln von Python lösen? Wurde ja schon angedeutet, dass das mit den Methoden von Strings und Grunddatentypen wie einer Liste ohne Probleme geht.

Oder ist euer Wissensstand so, dass da schon eine wie auch immer geartete KI hinter steckt, die automatisiert eine entsprechende Rechtschreibkorrektur anwenden soll?

Gruß, noisefloor

[__blackjack__]

@kudde: So ganz grundsätzlich kann man Programmieren als Zerlegen des Problems, das gelöst werden soll, in kleinere Teilprobleme sehen. Und die Teilprobleme dann wieder in kleinere Teilprobleme, solange bis diese Teilprobleme so klein sind, das man sie jeweils mit einer Funktion mit wenigen Zeilen lösen kann. So eine Teillösung schreibt und testet man, und wenn die macht was sie soll, wiederholt man das schreiben und testen mit der nächsten Teillösung. Dabei entstehen dann Teillösungen die aus anderen getesteten Teillösungen bestehen, bis man am Ende eine Gesamtlösung hat.

Je nach dem wie man die gestellte Aufgabe hier auffasst, gibt es in Python bereits Funktionen, beziehungsweise Methoden, und Operationen, die es relativ einfach machen die Aufgabe zu lösen, so dass man hier einfach nur ein paar sequentielle Schritte hat, und dafür nicht unbedingt zusätzliche Funktionen schreiben muss.

Einen Einzeiler sehe ich da nicht als erstes, sondern eher drei Schritte: Die nicht veränderbare Zeichenkette in etwas umwandeln wo man tatsächlich etwas ändern kann, suchen/zugreifen und ändern gemäss Aufgabe, und dann wieder eine Zeichenkette aus den Daten erstellen. Oder man überlegt sich wie man die Position des ersten Buchstaben des zweiten Wortes ermitteln könnte und erstellt dann das Ergebnis aus der Teilzeichenkette davor, dem Buchstaben an der Position in einen Grossbuchstaben gewandelt, und der Teilzeichenkette danach.

Alles wird ein bisschen komplizierter falls da mehr als ein Leerzeichen, oder auch Tabulatoren oder Zeilenendezeichen in den Eingabedaten vorkommen dürfen und man das berücksichtigen muss. Noch ein bisschen umständlicher wird es wenn der Satz beispielsweise auch 'Der "cormen" ist ein Buch über Algorithmen' lauten kann. Dann wird es noch ein bisschen interessanter wie genau man da an den ersten Buchstaben des zweiten Wortes, also das c von cormen heran kommt.

Eine Lösung in einer Programmiersprache aus den 70ern (Altair BASIC 8k):

Code: Alles auswählen

LIST

10 S$="Das licht des Mondes beleuchtet DIE Nacht."
20 I=1
30 IF MID$(S$,I,1)<>" " THEN I=I+1:GOTO 30
40 PRINT LEFT$(S$,I);
50 C$=MID$(S$,I+1,1)
60 IF C$>="a" AND C$<="z" THEN C$=CHR$(ASC(C$)-32)
70 PRINT C$;
80 PRINT MID$(S$,I+2)
OK
RUN
Das Licht des Mondes beleuchtet DIE Nacht.

OK

[Pedroski55]

Es geht wohl drum, dass man satz nicht verändern kann, dafür aber eine list.

Code: Alles auswählen

satz = "Das licht des Mondes beleuchtet DIE Nacht."
listig = satz.split()
listig[1] = listig[1].title()
satzig = ' '.join(listig)

Oder

Code: Alles auswählen

for i in range(len(satz)):
    if satz[i] == ' ':
        neusatz = satz.replace(satz[i+1], satz[i+1].upper(),1)
        break

[Kudde]

Moin zusammen, hier ist der richtige Code. Danke für Eure Mühe und Hilfe.

# Verwende die split-Methode, um den Satz in eine Liste von Wörtern aufzuteilen.
satz = "Das licht des Mondes beleuchtet DIE Nacht." # Alles bezieht sich auf diesen Satz.

worte = satz.split()

# Greife auf das erste Zeichen des zweiten Wortes zu und ändere es in Großbuchstaben (licht -> Licht).

worte[1] = worte[1].capitalize()


# Ändere das erste ganze Wort in Großbuchstaben und das vorletzte Wort in Kleinschreiben.

worte[0] = worte[0].upper()
worte[-2] = worte[-2].lower()


# Füge zwischen dem vierten und fünften Wort einen Zeilenumbruch ein.

endergebnis = " ".join(worte[:4]) + "\n" + " ".join(worte[4:])

print(endergebnis)


# Stelle sicher, dass dein endgültiger Satz den erwarteten Änderungen entspricht.
# Ausgabe: DAS Licht des Mondes
# beleuchtet die Nacht

[__blackjack__]

@Kudde Der Ansatz in dem BASIC-Programm wäre für die Aufgabenbeschreibung aus dem ersten Beitrag noch sinnvoll gewesen, aber mit den zusätzlichen Aufgabenteilen dann nicht mehr. Es macht deshalb Sinn das gesamte Problem zu betrachten wenn man die Datenstruktur wählt auf der man operiert, und nicht nur den das erste Teilproblem.

Der Ansatz für die erste Teilaufgabe aus dem BASIC-Programm hätte in Python so ausgesehen:

Code: Alles auswählen

sentence = "Das licht des Mondes beleuchtet DIE Nacht."
index = sentence.index(" ") + 1
changed_sentence = (
    sentence[:index] + sentence[index].upper() + sentence[index + 1 :]
)
print(changed_sentence)

Das mit dem Zeilenumbruch einfügen hätte ich etwas anders gelöst, so dass das mehr dem Muster der anderen Änderungen entspricht, also die Wörterliste verändert. Das Zusammensetzen des Ergebnissatzes hätte ich als einzelnen Schritt danach gemacht.

Code: Alles auswählen

#!/usr/bin/env python3
#
# Alles bezieht sich auf diesen Satz.
#
sentence = "Das licht des Mondes beleuchtet DIE Nacht."
#
# Verwende die `str.split()`-Methode, um den Satz in eine Liste von Wörtern
# aufzuteilen.
#
words = sentence.split()
#
# Greife auf das erste Zeichen des zweiten Wortes zu und ändere es in
# Großbuchstaben (licht → Licht).
#
words[1] = words[1].capitalize()
#
# Ändere das erste ganze Wort in Großbuchstaben und das vorletzte Wort in
# Kleinschreibung.
#
words[0] = words[0].upper()
words[-2] = words[-2].lower()
#
# Füge zwischen dem vierten und fünften Wort einen Zeilenumbruch ein.
#
words[3] = words[3] + "\n" + words.pop(4)

changed_sentence = " ".join(words)
#
# Stelle sicher, dass Dein endgültiger Satz den erwarteten Änderungen
# entspricht.
#
# > DAS Licht des Mondes
# > beleuchtet die Nacht.
#
print(changed_sentence)
assert changed_sentence == "DAS Licht des Mondes\nbeleuchtet die Nacht."

Die Kommentare sind okay wenn es der Aufgabentext ist, aber für ein echtes Programm wären die fast alle überflüssig. Faustregel zu Kommentaren: Die beschreiben nicht was der Code macht, denn das steht da ja bereits als Code, sondern warum er das so macht, sofern das nicht offensichtlich ist. Offensichtlich ist in der Regel auch was in der Dokumentation der Programmiersprache und den verwendeten Bibliotheken steht.

Eine Bitte noch: Quelltexte sollten in einem Code-Block gesetzt werden, damit die Einrückung erhalten bleibt. Das ist in Python essentiell, sobald man mehr als sequenzielle Anweisungen auf Modulebene hat.

Wenn man die einzelnen Schritte ähnlich aufbaut kann man beispielsweise auch eine Schleife über Paare von Funktion und Index des zu verändernden Wortes schreiben und Funktionen die jeweils die Worte und den Index als Argument bekommen. Bei Funktionen und Schleifen ist denn wichtig, dass man die Einrückung vom Quelltext sehen kann, damit man weiss welche Anweisungen zur Funktion oder Schleife gehören und welche nicht mehr.

Code: Alles auswählen

#!/usr/bin/env python3
from functools import partial


def call_method(method_name, words, index):
    words[index] = getattr(words[index], method_name)()


def insert_newline(words, index):
    words[index] = f"{words[index]}\n{words.pop(index + 1)}"


def main():
    sentence = "Das licht des Mondes beleuchtet DIE Nacht."
    words = sentence.split()
    for mutate, index in [
        (partial(call_method, "capitalize"), 1),
        (partial(call_method, "upper"), 0),
        (partial(call_method, "lower"), -2),
        (insert_newline, 3),
    ]:
        mutate(words, index)
    changed_sentence = " ".join(words)
    print(changed_sentence)
    assert changed_sentence == "DAS Licht des Mondes\nbeleuchtet die Nacht."


if __name__ == "__main__":
    main()

Und spasseshalber noch mal als Vergleich wie das in Altair BASIC 8k aussehen würde:

Code: Alles auswählen

LIST

10 CLEAR 200
20 S$="Das licht des Mondes beleuchtet DIE Nacht."
30 DIM W$(10):N=0:IW=0
40 FOR I=1 TO LEN(S$)
50 C$=MID$(S$,I,1)
60 IF IW THEN 90
70 IF C$<>" " THEN J=I:IW=NOT IW
80 GOTO 100
90 IF C$=" " THEN N=N+1:W$(N)=MID$(S$,J,I-J):IW=NOT IW
100 NEXT
110 IF IW THEN N=N+1:W$(N)=MID$(S$,J)
200 C$=LEFT$(W$(2),1):GOSUB 1000:W$(2)=C$+MID$(W$(2),2)
300 W$=""
310 FOR I=1 TO LEN(W$(1))
320 C$=MID$(W$(1),I,1):GOSUB 1000:W$=W$+C$
330 NEXT
340 W$(1)=W$
400 W$=""
410 FOR I=1 TO LEN(W$(N-1))
420 C$=MID$(W$(N-1),I,1):GOSUB 1100:W$=W$+C$
430 NEXT
440 W$(N-1)=W$
500 W$(4)=W$(4)+CHR$(13)+CHR$(10)+W$(5)
510 W$(5)=""
600 R$=""
610 IF N=0 THEN 650
620 FOR I=1 TO N
630 IF W$(I)<>"" THEN R$=R$+" "+W$(I)
640 NEXT
650 IF R$<>"" THEN R$=MID$(R$,2)
900 PRINT R$:END
1000 IF C$>="a" AND C$<="z" THEN C$=CHR$(ASC(C$)-32)
1010 RETURN
1100 IF C$>="A" AND C$<="Z" THEN C$=CHR$(ASC(C$)+32)
1110 RETURN

RUN
DAS Licht des Mondes
beleuchtet die Nacht.

OK

[snafu]

Hier der ganze Spaß in Rust:

Code: Alles auswählen

use std::str::Chars;

fn main() {
    let mut words = get_words("Das licht des Mondes beleuchtet DIE Nacht.");
    
    words[0] = words[0].to_uppercase();
    words[1] = capitalize(words[1].chars());

    let index = words.len() - 2;
    words[index] = words[index].to_lowercase();

    println!("{}", words[..4].join(" "));
    println!("{}", words[4..].join(" "));
}

fn get_words(sentence: &str) -> Vec<String> {
    sentence.split_whitespace().map(String::from).collect()
}

fn capitalize(mut chars: Chars) -> String {
    if let Some(ch) = chars.next() {
        ch.to_uppercase().to_string() + chars.as_str()
    } else {
        String::default()
    }
}

Oben war ich schreibfaul und lege es auf eine Panic an, falls der Text weniger als zwei Wörter enthält, denn ich liebe das Risiko...!

Was mich wunderte, war das Fehlen von capitalize() in der Standardbibliothek, weshalb ich es selber schreiben musste. Das lässt sich IMHO auch nicht mit einer anderen Philosophie bei Rust erklären, dass es nach wie vor nicht enthalten ist.

[snafu]

Für Rust-Interessierte: Mittels chain() lässt sich die selbstgeschriebene Funktion noch etwas vereinfachen.

Code: Alles auswählen

fn capitalize(word: &String) -> String {
    let mut chars = word.chars();
    if let Some(first) = chars.next() {
        first.to_uppercase().chain(chars).collect()
    } else {
        String::default()
    }
}

[__blackjack__]

Rust ist mir zu neumodisch. Ich springe erst mal vom Altair BASIC aus den 70ern zu Turbo Pascal 1.0 nach 1983. Unter CP/M. Weil ja noch gar nicht so klar ist, ob sich dieser komische IBM PC wirklich durchsetzen wird. =:o)

Code: Alles auswählen

TYPE
  TWord = RECORD                       (* Describes a word in the sentence *)
    startIndex, endIndex: BYTE;        (* by its start and end index.      *)
  END;

VAR
  sentence: STRING[50];
  words: ARRAY[1..25] OF TWord;
  wordCount: BYTE;
  i: BYTE;

FUNCTION LowCase(c: CHAR): CHAR;   (* Strange ommission from the builtins. *)
BEGIN
  IF c IN ['A'..'Z'] THEN c := Chr(Ord(c) + 32);         (* Assumes ASCII. *)
  LowCase := c;
END;

PROCEDURE InitWords;                    (* Set the contents of 'words' and *)
VAR                                     (* 'wordCount' from 'sentence'.    *)
  inWord: BOOLEAN;
  i, j: BYTE;

  PROCEDURE AddWord;                    (* Update 'wordCount' and add word *)
  BEGIN                                 (* from 'j' to 'i-1' to 'words'.   *)
    wordCount := wordCount + 1;
    WITH words[wordCount] DO
      BEGIN
        startIndex := j;  endIndex := i - 1;
      END;
  END;

BEGIN
  wordCount := 0;  inWord := FALSE;
  FOR i := 1 TO Length(sentence) DO
    IF inWord THEN
      BEGIN
        IF sentence[i] = ' ' THEN
          BEGIN
            AddWord;  inWord := FALSE;
          END;
      END
    ELSE
      BEGIN
        IF sentence[i] <> ' ' THEN
          BEGIN
            j := i;   inWord := TRUE;
          END;
      END;

  IF inWord THEN
    BEGIN
      i := i + 1;      (* 'AddWord' expects 'i' to point *after* the word. *)
      AddWord;
    END;
END;

BEGIN
  sentence := 'Das licht des Mondes beleuchtet DIE Nacht.';
  InitWords;

  (* Upcase the first character of the second word. *)
  i := words[2].startIndex;
  sentence[i] := UpCase(sentence[i]);

  (* Upcase the first word. *)
  WITH words[1] DO
    FOR i := startIndex TO endIndex DO sentence[i] := UpCase(sentence[i]);

  (* Lowcase the next to last word. *)
  WITH words[wordCount - 1] DO
    FOR i := startIndex TO endIndex DO sentence[i] := LowCase(sentence[i]);

  (* Insert a line break between the fourth and fifth word. *)
  i := words[4].endIndex + 1;         (* Index of space between the words. *)
  Delete(sentence, i, 1);
  Insert(#13#10, sentence, i);

  WriteLn(sentence);
END.

Testlauf:

Code: Alles auswählen

A> turbo
TURBO Pascal version 1.00 [CP/M-80, Z80] - Serial # ████████████
Copyright (C) 1983 by BORLAND International Inc.

VT100


Include error messages (Y/N)? Y

Loading A:TURBOMSG.OVR

Logged drive: A

Work file: 
Main file: 

Edit     Compile  Run   Save

eXecute  Dir      Quit  compiler Options

Text:     0 bytes (7714-7714)
Free: 33767 bytes (7715-FAFC)

>

Main file name: test

Loading A:TEST.PAS
>

Compiling 
  79 lines
Code:   723 bytes (7FAF-8282)
Free: 31742 bytes (8282-FE80)
Data:   124 bytes (FE80-FEFC)

Running
DAS Licht des Mondes
beleuchtet die Nacht.

>