Festzelt Zeichen Buchstaben

41

Jeden Tag setzen Sie ein neues Wort mit beweglichen Buchstaben auf ein Festzelt und kaufen nur die Buchstaben, die Sie zum Schreiben benötigen. Sie verwenden Briefe, die Sie für frühere Wörter gekauft haben, immer wieder, wenn dies möglich ist. Geben Sie unter Berücksichtigung der Wörter, die Sie jeden Tag in der richtigen Reihenfolge schreiben möchten, die Buchstaben aus, die Sie jeden Tag kaufen.

Beispiel

Input:  ['ONE', 'TWO', 'THREE', 'SEVENTEEN']
Output: ['ENO', 'TW', 'EHR', 'EENSV']

Tag 1: Sie ohne Buchstaben beginnen, so zu schreiben ONE, können Sie alle seine Briefe kaufen E, N, O.
Tag 2: Am nächsten Tag möchten Sie aufstellen TWO (abnehmen ONE). Sie haben bereits eine Ovon ONE, also kaufen Sie eine zusätzliche TW.
Tag 3: Zu diesem Zeitpunkt haben Sie ENOWT. Zum Schreiben THREEbrauchst du EHR. Beachten Sie, dass Sie Ezusätzlich zu dem, den Sie haben , einen zweiten kaufen müssen.
Tag 4: Um zu schreiben SEVENTEEN, brauchst du 4 E, von denen du bereits zwei hast (nicht drei!), Also kaufst du zwei mehr. Sie haben auch die Tund einer der N‚s, so dass Sie die restlichen Buchstaben kaufen: EENSV.

In diesem Beispiel werden Buchstaben alphabetisch sortiert ausgegeben, Sie können sie jedoch in beliebiger Reihenfolge ausgeben.

Eingabe: Eine nicht leere Liste nicht leerer Buchstabenfolgen A-Z. Sie können auch Kleinbuchstaben verwenden, wenn Sie dies vorziehen. Zeichenlisten eignen sich gut für Zeichenfolgen.

Ausgabe: Geben Sie die zusätzlichen Buchstaben aus, die Sie täglich kaufen müssen, oder drucken Sie sie aus. Die Buchstaben eines Tages können in beliebiger Reihenfolge ausgegeben werden, die Tage müssen jedoch in der richtigen Reihenfolge angegeben werden.

Die Buchstaben von jedem Tag sollten von den anderen Tagen getrennt sein, damit Sie erkennen können, wo ein Tag endet. Ein nachgestelltes und / oder führendes Trennzeichen ist in Ordnung, sowohl innerhalb eines Tages als auch zwischen Tagen. Beachten Sie, dass für einen Tag möglicherweise keine Buchstaben gekauft wurden, was sich in der Ausgabe widerspiegeln sollte (ein Leerzeichen oder eine leere Zeile ist auch für den letzten Tag in Ordnung).

Testfälle

['ONE', 'TWO', 'THREE', 'SEVENTEEN']
['ENO', 'TW', 'EHR', 'EENSV']

['ONE', 'TWO', 'ONE', 'THREE']
['ENO', 'TW', '', 'EHR']

['ABC', 'AABC', 'ABBC', 'ABCC', 'AABBCC']
['ABC', 'A', 'B', 'C', '']

['SHORT', 'LOONG', 'LOOOONG', 'LOOOOOOONG', 'SHORT', 'LOOONG']
['HORST', 'GLNO', 'OO', 'OOO', '', '']

Hier sind alle Ein- und Ausgänge als separate Listen aufgeführt:

[['ONE', 'TWO', 'THREE', 'SEVENTEEN'], ['ONE', 'TWO', 'ONE', 'THREE'], ['ABC', 'AABC', 'ABBC', 'ABCC', 'AABBCC'], ['SHORT', 'LOONG', 'LOOOONG', 'LOOOOOOONG', 'SHORT', 'LOOONG']]
[['ENO', 'TW', 'EHR', 'EENSV'], ['ENO', 'TW', '', 'EHR'], ['ABC', 'A', 'B', 'C', ''], ['HORST', 'GLNO', 'OO', 'OOO', '', '']]

Und als durch Leerzeichen getrennte Zeichenfolgen (die nachgestellten Leerzeichen in den Ausgaben sind wichtig):

ONE TWO THREE SEVENTEEN
ONE TWO ONE THREE
ABC AABC ABBC ABCC AABBCC
SHORT LOONG LOOOONG LOOOOOOONG SHORT LOOONG

ENO TW EHR EENSV
ENO TW  EHR
ABC A B C 
HORST GLNO OO OOO

Bestenlisten

Code-Snippet anzeigen

code-golf  string 
— xnor
quelle
5
Ein wildes Bestenlisten-Skript wurde im Alter des Benutzerskripts veröffentlicht: o
— Quintec
Können wir als Array von Zeichen ausgeben, die gekauft werden müssen, anstatt als Zeichenfolge aller Zeichen? zB:[['E', 'N', 'O'], ...]
— Downgoat
Ist die Ausgabe SHORTLONGOOOOOfür die letzte Ausgabe gültig? AKA ohne Trennzeichen?
— Magic Octopus Urn
@Downgoat Ja, Listen sind Zeichen und können problemlos ausgegeben werden.
— 22.
@MagicOctopusUrn Nein, Sie brauchen Trennzeichen, sonst können Sie nicht sagen, welche Buchstaben für welchen Tag sind.
— 22.

Antworten:

10

Haskell, 54 49 Bytes

import Data.List
g x=zipWith(\\)x$scanl(++)""$g x

Probieren Sie es online!

Wir erstellen die Ausgabeliste, indem wir die Listendifferenz ( \\) der Eingabeliste und den kumulativen Anhang der Ausgabeliste paarweise berechnen (beginnend mit "").

input list:                ONE       TWO       THREE        SEVENTEEN
cumulative append:         ""   +->  ONE  +->  ONETW   +->  ONETWHRE
list difference (output):  ONE -+    TW  -+    HRE    -+    SVEEN

Mit beiden Data.Listund Data.Functionin Umfang (z. B. durch Verwendung der Lambdabot-Umgebung) kann dies auf 30 Byte verkürzt werden:

fix.(.scanl(++)"").zipWith(\\)

Edit: -5 Bytes dank @Sriotchilism O'Zaic.

— nimi
quelle
— Weizen-Assistent
10

Python 2 , 72 68 Bytes

-4 Bytes danke an Jonathan Allan.

p=''
for r in input():
 for x in p:r=r.replace(x,'',1)
 print r;p+=r

Probieren Sie es online!

Kommentiert

l=input()       # the list of words to write
p=''            # p contains all letters we own
for r in l:     # for each word ...
  for x in p:   # for each letter we own ...
    r=r.replace(x,'',1)   # remove one occurence from the current word
  print r       # print the remaining word
  p+=r          # add the remaining chars to p
— ovs
quelle
3
for r in input():Spart 4 Bytes.
— Jonathan Allan
7

Perl 6 , 44 Bytes

{$!=@;.map:{kxxv $!=.comb.Bag∖($⊎=$!):}}

Probieren Sie es online!

Ausgabe als Liste von Zeichenlisten.

Erläuterung

{                                      } # Anonymous codeblock
 $!=@;                                   # Initialise $! to an empty list
      .map:{                          }  # Map each item in the input to
                    .comb                # The string split to characters
                         .Bag            # In a Bag
                             ∖           # Set minus
                              ($⊎=$!)    # The accumulated Bag of results
                 $!=                     # And save the result for the next item
            kxxv                     : # Then decompose the Bag into a list
— Scherzen
quelle
2
Ein Grund für die Ablehnung wäre dankbar
— Jo King
Nicht der Abwähler, aber ich werde sagen, dass dieses Ausgabeformat zu weit abweicht. So etwas Bag(E(2), N, S, V)müsste eigentlich zwei E's zeigen, um OK zu sein.
— 21.
3
Was wirklich? Dies ist nur die Standarddruckformatierung. Das Rückgabeergebnis ist eine ungeordnete Liste, die diese Zeichen enthält (und mehrere gleiche Zeichen enthalten kann). Ich werde die Ausgabeformatierung aktualisieren, um dies besser widerzuspiegeln, aber die Abwertung scheint lächerlich.
— Jo King
Downvoter, könnten Sie bitte erklären, geht es um I / O oder etwas anderes? Was das Taschenformat betrifft, Perl kenne ich nicht, ist dies bei I / O in Perl-Golfspielen üblich? Wenn ich mir die Dokumente ansehe (zwischengespeichert, weil die Site nicht erreichbar ist), scheinen sie eher Dikte mit Zählungen zu sein, ähnlich denen von Python, collections.Counterdie ich nicht als Ausgabe zulassen wollte. Kann man leicht über Taschenelten mit einer Vielzahl iterieren, in eine Liste / ein Array umwandeln, mit einer Vielzahl anzeigen usw.?
— 21.
3
Downvote war ein Fehler, sollte up sein.
— Jonathan Allan
7

Haskell , 44 Bytes

import Data.List
foldl1(\a x->a++',':(x\\a))

Probieren Sie es online!

Die Ausgabe ist eine Zeichenfolge wie ONE,TW,HRE,SVEENbei Kommas zwischen Tagen.

— Lynn
quelle
1
Was für eine nette Verwendung des Ausgabeformats, um zu vermeiden, dass auch der \`. And an unexpected Klappboden gefaltet werden muss.
— 27.
7

JavaScript (Node.js) , 59 Byte

a=>a.map(h=>([...t].map(c=>h=h.replace(c,'')),t+=h,h),t='')

Probieren Sie es online!

Ganz unkomplizierte Lösung. hEntfernen Sie für jedes Wort die bereits vorhandenen Buchstaben.

Hier ist eine erläuterte Version dieses Codes:

f = list => {
  // the string that accumulates all the letters already bought
  let accu = '';
  // for every word in the list
  return list.map( word => {
    // for every letter already bought 
    [...accu]
      // remove the letter from the word
      .map(char => {
        return word = word.replace(char,'')
      });
    // add not bought letters to accumulator
    accu += word;
    // the reduced word (without already bought letters) should be added to result map
    // this represents the letters to buy today
    return word
  }, accu)
}

console.log(f(['ONE', 'TWO', 'THREE', 'SEVENTEEN']))
console.log(f(['ONE', 'TWO', 'ONE', 'THREE']))
console.log(f(['ABC', 'AABC', 'ABBC', 'ABCC', 'AABBCC']))
console.log(f(['SHORT', 'LOONG', 'LOOOONG', 'LOOOOOOONG', 'SHORT', 'LOOONG']))
Erweitern Sie das Snippet

— tsh
quelle
Sie können 1 Byte sparen, indem Sie sich den einzigen Trick aus meiner ansonsten überkomplizierten Lösung ausleihen.
— Arnauld
5

J , 29 Bytes

-29 Bytes dank FrownyFrog!

(],a.<@#~0>.-&(1#.a.=/;))/@|.

Probieren Sie es online!

Ursprünglicher Beitrag

J , 58 Bytes

[:}.@>[:(],<@(/:~@({.@>@-.&(((e.<@#[){:)\));))&.>/<@a:,~|.

Probieren Sie es online!

Vielen Dank an ngn für die Hilfe bei der Verbesserung der "Subtraktion von Buchstaben unter Berücksichtigung des Wiederholungsteils".

Keine gute Passform für J, aber eine aufschlussreiche Übung.

Beginnen wir mit der Konstruktion eines Hilfsverbs wo("ohne"), das alle Zeichen in einer Zeichenfolge aus einer anderen entfernt, wobei Wiederholungen berücksichtigt werden. 

wo=.{.@>@-.&(((e. <@# [) {:)\)

Hier gibt es eine lustige Idee: Wir machen jede wiederholte Instanz eines Charakters einzigartig, indem wir sie so oft wiederholen, wie es erforderlich ist. Wenn also unsere ursprüngliche Saite ist ABBA, wird sie:

┌─┬─┬──┬──┐
│A│B│BB│AA│
└─┴─┴──┴──┘

Ein dritter Awürde werden AAAund so weiter. Dies wird dadurch erreicht, dass die Phrase ((e. <@# [) {:)\, die jedes Präfix annimmt \, das letzte Element {:davon betrachtet und eine Maske aller Elemente in diesem Präfix erstellt, die mit e.diesem letzten Element übereinstimmen , und dann nur diese Elemente filtert und boxt <@#.

Mit unseren beiden Eingaben "unique-ified" können wir jetzt sicher das normale Minus setzen und -. dabei die Wiederholung respektieren.

Wir öffnen dann jedes Ergebnis und nehmen nur das erste Element, um unsere Wiederholungen "rückgängig zu machen": {.@>

Wenn Sie dieses Hilfsverb einstecken, wird unsere Gesamtlösung (die es einfach einfügt) zu:

[: }.@> [: (] , <@(/:~@wo ;))&.>/ <@a: ,~ |.

Im Wesentlichen richten wir unser Problem hier nur als einzelne Reduktion ein. Wir beginnen die Eingabe umzukehren |.und fügen ,~ein Ass a:oder ein leeres Kästchen hinzu, das der Anfangswert unseres Endergebnisses ist, wie folgt:

┌─────────┬─────┬───┬───┬──┐
│SEVENTEEN│THREE│TWO│ONE│┌┐│
│         │     │   │   ││││
│         │     │   │   │└┘│
└─────────┴─────┴───┴───┴──┘

Wir kleben das folgende Verb zwischen jedes Element, um die Reduktion zu bewirken:

(] , <@(/:~@wo ;))/

Dies besagt: Nehmen Sie die rechte Eingabe ](dh unser Ergebnis) und hängen Sie , die linke Eingabe (dies ist ONEbei der ersten Iteration, TWObei der zweiten usw.) an, ohne wodie Schleifen ;der rechten Eingabe (dh bisher ohne vorherige Buchstaben) gebraucht), aber vor dem Anhängen sortieren /:~und wieder einpacken <@.

Am Ende haben wir das gewünschte Ergebnis, eine Liste von Kisten, aber alle in einer großen zusätzlichen Kiste und immer noch mit der leeren Kiste vorne. So öffnen wir die äußere Box und töten das erste Element zu entfernen: }.@>.

— Jona
quelle
[:}.@>|.(],a.<@#~0>.-&(1#.a.=/;))&.>/@,<@a:
— FrownyFrog
Ein einfaches (],a.<@#~0>.-&(1#.a.=/;))/@|.funktioniert auch, wenn mir kein Randfall fehlt.
— FrownyFrog
Soweit ich das beurteilen kann, gibt es keine Anforderungen an das Sortieren.
— FrownyFrog
2
Aktualisiert und jetzt, da ich Zeit hatte, es aufzunehmen, wollte ich nur noch einmal sagen: Das ist verdammt nett, J!
— Jona
4

JavaScript (ES6),  66  65 Bytes

a=>a.map(b=s=>[...s].filter(c=>x==(x=x.replace(c))?b+=c:0,x=b+0))

Probieren Sie es online!

Kommentiert

bbxcxb

a =>                      // a[] = input
  a.map(b =               // initialize b to the callback function of this map()
                          // it will be coerced to a string that does not contain
                          // any letter in uppercase
    s =>                  // for each entry s in a[]:
    [...s].filter(c =>    //   for each character c in s:
      x == (              //     check whether x is changed when
        x = x.replace(c)  //     c is replaced with 'undefined'
      ) ?                 //     if so:
        b += c            //       append c to b and keep c
      :                   //     else:
        0,                //       discard c
      x = b + 0           //     coerce b to a string and save it in x
    )                     //   end of filter()
  )                       // end of map()
— Arnauld
quelle
4

C ++ (GCC) , 177 170 Bytes

-5 Bytes dank @ anatolygs Tipp, -2 Bytes für kleine Dinge, die mir aufgefallen sind.

#import<random>
#define v std::vector<std::string>
v a(v p){std::vector<int>o(91),b;int j=-1;for(auto i:p){b=o;p[++j]="";for(int c:i)--b[c]<0?p[j]+=c,++o[c]:0;}return p;}

Erläuterung

#import<random>addiert beides <string>und <vector>für die Hälfte der Bytes.

Erstellt zunächst einen Vektor mit 91 Elementen und 0 (nur die Indizes 65-90 werden zum Speichern von Buchstaben verwendet) und einen anderen Vektor desselben Typs, der jedoch nicht auf einen Wert festgelegt ist. Durchläuft jedes Element der Eingabe (die Tage): Ruft die derzeit im Besitz befindlichen Buchstaben ab, ruft die für den Tag erforderlichen Buchstaben ab, überschreibt die Eingabe am Index mit der erforderlichen Menge und aktualisiert die im Besitz befindlichen Buchstaben. Gibt die überschriebene Eingabe zurück.

Probieren Sie es online!

— Neil A.
quelle
Sie können dies tun #define v std::vector<std::stringund entfernen using namespace std, um die Anzahl der Bytes um 6 Bytes zu verringern.
— Anatolyg
2

C # (Visual C # Interactive Compiler) , 123 Byte

a=>{var b="";for(dynamic i=0,e,f;i<a.Count;b+=a[i++]=f)foreach(var c in((e,f)=(b.ToList(),"")).f+a[i])f+=e.Remove(c)?"":c;}

Probieren Sie es online!

Anonyme Funktion, die durch Ändern eines Eingabearrays ausgegeben wird.

// a: input array of strings
a=>{
  // b: cumulative letters
  var b="";
  for(
    // i: loop index of string
    // e: copy of cumulative letters for manipulation
    // f: characters missing from current string
    dynamic i=0,e,f;
    // iterate over each string in a
    i<a.Count;
    // add missing letters of the day to
    // cumulative missing letters and
    // update array for output
    b+=a[i++]=f
  )
    // iterate current string with character c
    foreach(var c in
      // tuplized variable assignment
      // e=b.ToList()
      //   set e to a copy of the cumulative letters
      // f=""
      //   initially there are no letters needed for the day
      ((e,f)=
      (b.ToList(),"")).f+a[i]
    )
      // conditionally add c to missing letters for the day
      f+=e.Remove(c)?"":c;
}
— Dana
quelle
2

R 119 112 106 103 Bytes

-7 Bytes durch Aliasing der beiden längeren Funktionsnamen und jetzt Benutzereingaben von scan()
-6 Bytes, um strsplit()zu Beginn nur einmal aufzurufen
-3 Bytes, um das Aliasing wieder aufzuheben und zwei Variablen in einem Aufruf zuzuweisen

(Bearbeitet auch die Anzahl der Bytes, die früher fälschlicherweise niedrig war)

a=scan(,'');b=a=strsplit(a,'');for(i in 2:length(a))b[[i]]=vecsets::vsetdiff(a[[i]],unlist(b[1:i-1]));b

Dies ist meine allererste PPCG-Einreichung jeglicher Art! Ich habe also keine Ahnung, was ich sowohl in Bezug auf das Golfen als auch in Bezug auf das Posten von Etikette tue. Die Ausgabe ist eine Liste von Vektoren, die die Bedingungen der Herausforderung erfüllen können oder nicht. :-P

Was den Code selbst betrifft, nimmt er Benutzereingaben über scan()und vergleicht die Buchstaben jedes neuen Tages mit den kumulativ besessenen Buchstaben, wie bei anderen Lösungen. Wenn es kürzere Alternativen zu unlistund strsplitzum Umwandeln von Zeichenfolgen in Vektoren einzelner Zeichen gibt, wäre es cool zu wissen. Ich habe auch die vsetdiffFunktion in Carl Withofts vecsetsPaket verwendet, um den eingestellten Unterschied zwischen den für den nächsten Tag benötigten und den aktuellen Briefen zu ermitteln.

— qdread
quelle
1
Nein, es ist vollkommen in Ordnung. Ich bin selbst etwas zurückhaltend bei der Verwendung externer Pakete, aber ich bin es nur ... Ich
— gehe
1
— digEmAll
1
— digEmAll
1
— digEmAll
1
— digEmAll
2

Japt , 15 bis 14 Bytes

£Q®X=rZPPÃQ±XX

Versuch es

£Q®X=rZPPÃQ±XX     :Implicit input of array
£                  :Map each X
 Q®                :  Map each Z in Q (initially a quotation mark)
   X=              :    Reassign to X
     rZ            :    Replace Z with
       P           :    The empty string
        P          :    With the default global flag disabled
         Ã         :  End map
          Q±X      :  Append X to Q
             X     :  Return X
— Zottelig
quelle
1
@Downvoter, bitte haben Sie den Anstand, einen Kommentar zu hinterlassen.
— Shaggy
1

PowerShell , 71 Byte

$args|%{$w=$_;$p|% t*y|%{$w=$w-replace"^(.*?)$_(.*)",'$1$2'};$w;$p+=$w}

Probieren Sie es online!

Nimmt Eingabewörter $argsund durchläuft sie. Bei jeder Iteration setzen wir das aktuelle Wort $wund durchlaufen dann unsere $pool von bereits gekauften Buchstaben. In jeder inneren Schleife führen wir einen regulären Ausdruck -replacefür unseren aktuellen $wBefehl durch, sodass wir nur die erste Instanz des Buchstabens aus unserem $pOOL ersetzen . Sobald wir alle Buchstaben im Pool durchgegangen sind, geben wir aus, was noch übrig ist $w(dh was wir kaufen müssen), und heften diese Buchstaben $p+=$wfür das nächste Wort in unseren Pool .

— AdmBorkBork
quelle
1

Excel VBA, 127 Byte

Function z(w)
z=""
For Each x In w.Cells
v=x.value
For y=1To Len(z)
v=Replace(v,Mid(z,y,1),"",1,1)
Next
z=z&v
Next
End Function

Nimmt Eingaben in Form eines Excel-Bereichs vor.

— William Porter
quelle
1

C (gcc) , 118 Bytes

m(a,r,q,u)char**a,*r,*q,*u;{for(;*a;a++,memcpy(r,q,255))for(memcpy(q,r,255),u=*a;*u;u++)*u=r[*u]-->0?32:(q[*u]++,*u);}

Probieren Sie es online!

Als kleinen Bonus nimmt es die Aktie rzu Beginn als Array auf. Gibt die mit null abgeschlossene Liste amit null abgeschlossenen Zeichenfolgen aus, wobei alle gebrauchten Buchstaben durch Leerzeichen ersetzt werden.

— LambdaBeta
quelle
— Ceilingcat
1

Swift 4.2 / Xcode 10.2 , 244 242 239 238 Bytes

a.reduce(([Character:Int](),[String]())){c,l in let b=l.reduce(into:[Character:Int]()){$0[$1,default:0]+=1}.map{($0,max(0,$1-(c.0[$0] ?? 0)))};return(c.0.merging(b){$0+$1},c.1+[b.map{String(Array(repeating:$0.0,count:$0.1))}.joined()])}.1

Probieren Sie es online!

Die Buchstaben sind nicht in alphabetischer Reihenfolge angeordnet, es ist nicht durch die Regeln verboten.

— Roman Podymov
quelle
1

Scala, 68 Bytes

(c:Seq[String])=>c./:(Seq(""))((a,n)=>a:+n.diff(a./:("")(_+_))).tail

Probieren Sie es online!

/: ist eine Abkürzung für den Operator foldLeft, a ist eine Aggregation, gibt letztendlich das gewünschte Ergebnis zurück, n ist das nächste Element

Nicht golfen

def NewLettersPerDay(c: Seq[String]): Seq[String] = {
    c.foldLeft(Seq(""))((agg, next) => {
      val existingLetters = agg.reduce(_+_)
      val newDayLetters = next.diff(existingLetters)
      agg :+ newDayLetters
    }).tail
}
— sprague44
quelle
0

Kohle , 18 Bytes

ＥθΦι¬⊙…θκ‹№…ιμλ№νλ

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Erläuterung:

 θ                  Input array
Ｅ                   Map over strings
   ι                Current string
  Φ                 Map over characters
       θ            Input array
      …             Truncated to length
        κ           Outer index
    ¬               Logical Not
     ⊙              Any element exists where
          №         Count of
              λ     Current letter in
            ι       Outermost word
           …        Truncated to
             μ      Current letter index
         ‹          Is less than
               №    Count of
                 λ  Current letter in
                ν   Innermost word
                    Implicitly print each day's bought letters on their own line
— Neil
quelle
0

PHP, UTF-8-fähig (253 Bytes)

<?php $p=[];for($i=1;$i<$argc;$i++){$a=$p;$b=[];for($j=0;$j<mb_strlen($s=$argv[$i]);$j++){$k=1;if(isset($a[$c=mb_substr($s,$j,1)]))if($a[$c]){$k=0;$a[$c]--;}if($k){echo $c;if(isset($b[$c]))$b[$c]+=$k;else $b[$c]=$k;}}$p=array_merge($p,$b);echo PHP_EOL;}
— rexkogitans
quelle
Durch die Nutzung unserer Website bestätigen Sie, dass Sie unsere Cookie-Richtlinie und Datenschutzrichtlinie gelesen und verstanden haben.
Licensed under cc by-sa 3.0 with attribution required.