drei Zeichen zu einem

[Merle254]

Ich versuche mich momentan daran etwas zur Proteinbiosynthese zu programmieren.
Bisher übersetzt das Programm die Eingabe (z.B. GTACTCTTA) zu "CAUGAGAAU" und "GUACUCUUA"
soweit so gut

Nun soll aber eine der Übersetzungen durch Aminosäuren ersetzt werden.
Also "CAU" wird zu "His" ; "GAG" zu "Glu" ; "AAU" zu "Asn" usw. (es gibt ja 20 Aminosäuren, die sich auf mehrere Sequenzen abbilden lassen)

Dabei sollen immer 3 Zeichen ersetzt werden. Falls am Ende 2 oder 1 überbleiben, können die einfach wegfallen.

Ich habe bisher das mit einer Liste und String versucht, bin aber nicht wirklich zu einem zufriedenstellendem Ergebnis gekommen.

Ich hoffe, dass ihr versteht was ich meine und könnt mir helfen

Vielen vielen Dank schonmal

[__blackjack__]

@Merle254: Die Antworten werden nicht deutlich anders werden als die, die Du hier schon bekommen hast: viewtopic.php?f=1&t=48834

Denn das Problem ist im Grunde das gleiche. Ob Du nun drei Zeichen durch eine Ziffer, oder drei Zeichen durch drei andere Zeichen ersetzen willst, das vorgehen ist in beiden Fällen gleich. Du brauchst Code der immer drei Zeichen von der Eingabe betrachtet, Code der diese drei Zeichen auf drei andere Zeichen abbildet, und am Ende musst Du die ersetzten Teile wieder zusammensetzen. Der erste Schritt braucht eine Schleife oder „list comprehension“ oder einen Generatorausdruck, dann ist ein Wörterbuch (`dict`) für die Abbildung von alt nach neu nützlich, und am Ende dann die `join()`-Methode auf Zeichenketten um das Ergebnis zusammenzusetzen.

Du musst da halt Code schreiben. Wo liegt denn das konkrete Problem?

[Merle254]

@_blackjack_

Ich bin halt noch eine Anfängerin, bzw. ich habe 3 Jahre "Pause gemacht".

Die Grundbefehle kann ich alle noch, aber ab da wird es schwierig.

Ich hab mir zwar einiges im Internet dazu durchgelesen und weiß auch ungefähr, wie ich es programmieren möchte, aber ich weiß manches nicht, wie ich es umsetzen soll...

Wäre echt gut, wenn jemand mir helfen könnte damit.

[__blackjack__]

@Merle254: Arbeite ein Grundlagentutorial durch und dann teil das Problem in kleinere Teilprobleme auf, und die dann auch wieder in Teilprobleme, solange bis die Teilprobleme so klein sind, das man sie mit einer Funktion in wenigen Zeilen Code lösen kann. Das machst Du dann. Jede Teillösung testen bevor Du mit der nächsten Teillösung weiter machst. Und am Ende hast Du dann eine Gesamtlösung. Einen groben Ablaufplan habe ich ja bereits skizziert.

Wenn Du an einer konkreten Stelle im Code nicht weiter kommst, dann zeig den Code, sag was Du da versucht hast, was Du vom Code erwartest und warum, und was er stattdessen macht, und inwiefern das von Deiner Erwartung abweicht. Falls es eine Ausnahme gibt, dann zeig auch die Ausnahme samt Traceback 1:1.

[__blackjack__]

Das Prinzip mal in der Programmiersprache Io demonstriert:

Code: Alles auswählen

#!/usr/bin/env io
Regex

dnaToRna := Map with("T", "A",  "A", "U",  "C", "G",  "G", "C")
rnaToAminoAcid := Map with(
    "AAA", "Lys",   "AAC", "Asn",   "AAG", "Lys",  "AAU", "Asn",   "ACA", "Thr",
    "ACC", "Thr",   "ACG", "Thr",   "ACU", "Thr",  "AGA", "Arg",   "AGC", "Ser",
    "AGG", "Arg",   "AGU", "Ser",   "AUA", "Ile",  "AUC", "Ile",   "AUG", "Met",
    "AUU", "Ile",   "CAA", "Gln",   "CAC", "His",  "CAG", "Gln",   "CAU", "His",
    "CCA", "Pro",   "CCC", "Pro",   "CCG", "Pro",  "CCU", "Pro",   "CGA", "Arg",
    "CGC", "Arg",   "CGG", "Arg",   "CGU", "Arg",  "CUA", "Leu",   "CUC", "Leu",
    "CUG", "Leu",   "CUU", "Leu",   "GAA", "Glu",  "GAC", "Asp",   "GAG", "Glu",
    "GAU", "Asp",   "GCA", "Ala",   "GCC", "Ala",  "GCG", "Ala",   "GCU", "Ala",
    "GGA", "Gly",   "GGC", "Gly",   "GGG", "Gly",  "GGU", "Gly",   "GUA", "Val",
    "GUC", "Val",   "GUG", "Val",   "GUU", "Val",  "UAA", "STOP",  "UAC", "Tyr",
    "UAG", "STOP",  "UAU", "Tyr",   "UCA", "Ser",  "UCC", "Ser",   "UCG", "Ser",
    "UCU", "Ser",   "UGA", "STOP",  "UGC", "Cys",  "UGG", "Trp",   "UGU", "Cys",
    "UUA", "Leu",   "UUC", "Phe",   "UUG", "Leu",  "UUU", "Phe"
)

MappingException := Exception clone


getKeyLength := method(mapping, mapping detect(true) at(0) size)


checkMapping := method(mapping,
    keyLength := getKeyLength(mapping)
    keyCharacters := Map clone
    mapping keys foreach(key,  (key size != keyLength) ifTrue(
            MappingException raise(
                "all keys must have the same length (#{keyLength}), found: #{key serialized}" interpolate
            )
        )
        key foreach(value, keyCharacters atPut(value asCharacter, true))
    )
    expectedSize := keyCharacters size pow(keyLength)
    (expectedSize == mapping size) ifFalse(
        MappingException raise(
            "expected #{expectedSize} entries, got #{mapping size}" interpolate
        )
    )
)


Sequence mappedReplace := method(mapping, separator,
    checkMapping(mapping)
    pattern := "." repeated(getKeyLength(mapping))
    self matchesOfRegex(pattern) map(match,  mapping at(match at(0)) ifNil(
            MappingException raise(
                "unknown old value #{match at(0) serialized} found" interpolate
            )
        )
    ) join(separator)
)


main := method(
    dna := "GTACTCTTA"
    "   DNA: #{dna}" interpolate println
    mRna := dna mappedReplace(dnaToRna, "")
    "  mRNA: #{mRna}" interpolate println
    aminoAcids := mRna mappedReplace(rnaToAminoAcid, " ")
    "aminos: #{aminoAcids}" interpolate println
)

isLaunchScript ifTrue(main)

Ausgabe:

Code: Alles auswählen

   DNA: GTACTCTTA
  mRNA: CAUGAGAAU
aminos: His Glu Asn

Hier sieht man, dass die beiden Ersetzungsschritte — DNA → mRNA und mRNA → Aminosäuren im Grund das gleiche sind, nur mit anderen Abbildungen (und damit Ersetzungslängen) und anderen Trennzeichen beim Ergebnis. Beides kann aber mit der gleichen Methode erledigt werden.

In Python könnte man auch reguläre Ausdrücke verwenden, aber da würde ich wie schon angesprochen eher „slicing“ verwenden, weil das in Python IMHO leichter anzuwenden ist. Zum einen weil es dafür Syntax gibt, und weil man in einer „list comprehension“ oder einem Generatorausdruck den Sonderfall eines nicht vollständigen Endes leichter abfragen kann. Wobei man natürlich auch vorher schon ein korrektes Ende für diesen Fall berechnen könnte. Mal schauen, vielleicht schreibe ich die `Sequence mappedReplace`-Methode noch mal mit Slicing um.

[Merle254]

@_blackjack_

Ahhh vielen vielen Dank, dass du dir so viel Mühe gibst

Ich hatte mich vorhin noch mal drangesetzt und überlegt die Eingabe mit Bindestrichen in "3er paare" aufzuteilen und so halt jedes Paar überprüfen zu lassen, das wäre aber wohl echt viel Arbeit

Echt ein gaaaanz großes Dankeschön

[__blackjack__]

Die `mappedReplace()`-Methode mit „slicing“ statt regulärem Ausdruck:

Code: Alles auswählen

Sequence mappedReplace := method(mapping, separator,
    checkMapping(mapping)
    partLength := getKeyLength(mapping)
    0 toBy(self size - 1 - self size mod(partLength), partLength) map(index,
        part := self exSlice(index, index + partLength)
        mapping at(part) ifNil(
            MappingException raise(
                "unknown old value #{part serialized} found" interpolate
            )
        )
    ) join(separator)
)

Beide Ansätze könnten man auch in Python umsetzen.