Code generieren

36

Verwandt mit: Machen Sie einen; # -Interpreter

In der oben verknüpften Herausforderung bestand die Aufgabe darin, einen Dolmetscher für die esoterische Sprache zu erstellen ;#.

Die ;#sprache

Die Sprache hat genau zwei Befehle: ;und #(alle anderen Zeichen werden vom Interpreter ignoriert):

;: Erhöhen Sie den Akku

#: Modulieren Sie den Akku um 127, drucken Sie das entsprechende ASCII-Zeichen und setzen Sie den Akku auf 0 zurück.

Herausforderung

Da ich faul bin, aber noch weitere Testfälle testen möchte, benötige ich ein Programm oder eine Funktion, die einfachen Text in ;#Code umwandelt .

Eingang

Die Eingabe ist eine Zeichenfolge, die entweder als Argument oder über stdin verwendet wird. Es enthält nur druckbare ASCII-Zeichen und Zeilenumbrüche.

Ausgabe

Die Ausgabe ist das generierte ;#Programm, indem Sie zu stdout zurückkehren oder es drucken. Solange das Programm gültig ist, darf es andere Zeichen als #und enthalten, ;da alle anderen Zeichen ignoriert werden.

Beispiele

Input: Hello, World!
Output: ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#

Input: ABC
Output: ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#

Input: ;#
Output: ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#

Bestenliste

Code-Snippet anzeigen

code-golf  code-generation 
— kalsowerus
quelle
9
Brillant! Freut mich zu sehen; # bekommt Aufmerksamkeit!
— Caird Coinheringaahing
1
Sie können Ihre Ausgabe hier testen , da; # + eine Obermenge von; # ist.
— Adám
3
Kann die Ausgabe zusätzliche Zeichen enthalten? ;#Ignoriert alle anderen Zeichen, so dass das generierte Programm weiterhin funktioniert.
— Dennis
2
@ Benoît: Das Modul spielt bei der Codegenerierung keine Rolle, da es immer einfacher ist, Code mit der Mindestanzahl von zu generieren ;. Zweitens ist 127 richtig, wie in der verknüpften Frage angegeben, die die Angabe der Sprache; # enthält.
— Joey
2
Das ist nicht wirklich aufschlussreich. "Generate #; Code" ist ein besserer Titel. Ich werde das ändern.
— Mego

Antworten:

34

; # + , 40 Bytes

;;;;;~+++++++>~;~++++:>*(-(;~<#~):<#-*:)

Probieren Sie es online! Die Eingabe wird mit einem Null-Byte abgeschlossen.

Erläuterung

Der Code ist in zwei Teile unterteilt: Generierung und Iteration.

Generation

;;;;;~+++++++>~;~++++:>

Dies setzt die Konstanten ;und #in den Speicher als solche:

;;;;;~+++++++>~;~++++:>
;;;;;                     set A to 5
     ~                    swap A and B
      +++++++             add B to A 7 times
                          (A, B) = (5*7, 5) = (35, 5)
             >            write to cell 0
              ~           swap A and B
               ;          increment A
                ~         swap A and B
                          (A, B) = (35, 6)
                 ++++     add B to A 4 times
                          (A, B) = (59, 6)
                     :    increment cell pointer
                      >   write to cell 1

Iteration

*(-(;~<#~):<#-*:)
*                    read a character into A
 (            * )    while input is not a null byte:
  -                  flip Δ
   (     )           while A != 0
    ;                decrement
     ~               swap A and B
      <              read ";" into A
       #             output it
        ~            swap A and B
           :         decrement cell pointer
            <        read "#" into A
             #       output it
              -      flip Δ
               *     take another character from input
                :    increment cell pointer
— Conor O'Brien
quelle
1
All dies aus einer Scherzsprache, die ich gemacht habe, als ich gelangweilt war. Ich bin geschmeichelt.
— Caird Coinheringaahing
@RandomUser: D es ist ein Spaß - Konzept zu spielen , um mit
— Conor O'Brien
huh. Was ist, wenn ich möchte, dass das Programm ein Null-Byte in; # ausgibt?
— Tuskiomi
— Conor O'Brien
@ ConorO'Brien wie würde ich das in dein programm eingeben?
— Tuskiomi
12

Jelly , 10 8 7 Bytes

O”;ẋp”#

Probieren Sie es online!

O”;ẋp”#  Main Link
O        Map over `ord` which gets the codepoint of every character
 ”;ẋ     Repeat ';' the required number of times
     ”#  '#'
    p    Cartesian Product; this puts a '#' at the end of each element in the array

Implicit Output shows as a single string

-2 Bytes dank @Emigna
-1 Bytes dank @Dennis

— HyperNeutrino
quelle
Könnten Sie O”;ẋ;€”#stattdessen tun ?
— Emigna
@Emigna Ah, ja, danke. Ich verstehe nicht ganz, wie das funktioniert, aber ich verstehe es irgendwie. Vielen Dank!
— HyperNeutrino
4
;€werden kann p.
— Dennis
@Dennis Oh jetzt verstehe ich wie das funktioniert. Vielen Dank! :)
— HyperNeutrino
11

GS2 , 6 Bytes

■•;2•#

Probieren Sie es online!

Reversible Hexdump (xxd)

0000000: ff 07 3b 32 07 23                                ■•;2•#

Wie es funktioniert

■       Map the rest of the program over  all code points C of the input.
 •;         Push ';'.
   2        Multiply; repeat ';' C times.
    •#      Push '#'.
— Dennis
quelle
2
■= was zum Teufel?
— Erik der Outgolfer
1
2ist der Multiplikationsbefehl? GS2 ist komisch: P
— ETHproductions
1
@EriktheOutgolfer führt den Code für jeden Codepunkt des Eingangszeichens aus. O_O
— Mr. Xcoder
@EriktheOutgolfer Das klingt schicker als es ist. ■ist nur eine Map und GS2 implementiert Strings als Listen von ganzen Zahlen.
— Dennis
@ETHproductions GS2 ist nicht zeichenbasiert. Der Quellcode wird als unformatierter Byte-Stream interpretiert, und normalerweise besteht keine Verbindung zwischen der Anweisung und dem CP-437-Zeichen, das das Byte codiert. In x86_64-Byte-Code 2ist XOR ...
— Dennis
10

Taxi, 779 Bytes

Go to Post Office:w 1 l 1 r 1 l.Pickup a passenger going to Chop Suey.Go to Chop Suey:n 1 r 1 l 4 r 1 l.[c]Switch to plan "e" if no one is waiting.Pickup a passenger going to Charboil Grill.Go to Charboil Grill:n 1 l 3 l 3 l.Pickup a passenger going to The Underground.Go to Writer's Depot:w 1 r.[p]; is waiting at Writer's Depot.Pickup a passenger going to Post Office.Go to Post Office:n 1 r 2 r 1 l.Go to The Underground:n 1 r 1 l.Switch to plan "n" if no one is waiting.Pickup a passenger going to The Underground.Go to Zoom Zoom:n 3 l 2 r.Go to Writer's Depot:w.Switch to plan "p".[n]# is waiting at Writer's Depot.Go to Writer's Depot:n 3 l 2 l.Pickup a passenger going to Post Office.Go to Post Office:n 1 r 2 r 1 l.Go to Chop Suey:n 1 r 1 l 4 r 1 l.Switch to plan "c".[e]

Probieren Sie es online!

Ungolfed:

Go to Post Office: west 1st left 1st right 1st left.
Pickup a passenger going to Chop Suey.
Go to Chop Suey: north 1st right 1st left 4th right 1st left.
[c]
Switch to plan "e" if no one is waiting.
Pickup a passenger going to Charboil Grill.
Go to Charboil Grill: north 1st left 3rd left 3rd left.
Pickup a passenger going to The Underground.
Go to Writer's Depot: west 1st right.
[p]
; is waiting at Writer's Depot.
Pickup a passenger going to Post Office.
Go to Post Office: north 1st right 2nd right 1st left.
Go to The Underground: north 1st right 1st left.
Switch to plan "n" if no one is waiting.
Pickup a passenger going to The Underground.
Go to Zoom Zoom: north 3rd left 2nd right.
Go to Writer's Depot: west.
Switch to plan "p".
[n]
# is waiting at Writer's Depot.
Go to Writer's Depot: north 3rd left 2nd left.
Pickup a passenger going to Post Office.
Go to Post Office: north 1st right 2nd right 1st left.
Go to Chop Suey: north 1st right 1st left 4th right 1st left.
Switch to plan "c".
[e]

Erläuterung:

Pick up stdin and split it into characters.
Covert each character to ASCII.
Print ";" as you count down from that ASCII to zero.
Print "#".
Pickup the next character and repeat until done.
— Ingenieur Toast
quelle
+1 Ich liebe Sprachen wie diese und Mornington Crescent, der Code ist einfach so schön!
— Karl-Johan Sjögren
9

05AB1E , 8 Bytes

Ç';×'#«J

Probieren Sie es online!

Erläuterung

Ç          # convert each input char to its ascii value
 ';×       # repeat ";" those many times
    '#«    # append a "#" to each run of semi-colons
       J   # join to string
— Emigna
quelle
9

Brainfuck, 43 Bytes

+[+[<]>->++]--[>--<+++++++]>-<,[[<.>-]>.<,]

Null Byte beendet das Programm.

Erläuterung

+[+[<]>->++]          59 (semicolon) location 5
--[>--<+++++++]>-       35 (hash) location 7
<,[                     input location 6
    [   while input byte not 0
        <.>     print semicolon
        -       decrement input byte
    ]
    >.< print hash
,]  loop while input not null
— Mika Lammi
quelle
Das ist für Brainf * ck beeindruckend klein.
— MD XF
konkurriert fast mit der Python-Antwort. Beeindruckend.
— raddish0
5

> <> , 22 Bytes

i:0(?;\"#"o
o1-:?!\";"

Probieren Sie es online oder auf dem Fischspielplatz

Eingang ist STDIN, Ausgang ist STDOUT. In> <> sind Zeichen und ASCII-Codes dasselbe, also müssen wir nur ein Zeichen lesen, das Zeichen drucken ";"und dekrementieren, bis es 0 ist, und dann drucken "#"und schleifen, bis keine Eingabe mehr übrig ist.

— Kein Baum
quelle
5

F #, 79 Bytes

let c i=System.String.Join("#",Seq.map(fun c->String.replicate(int c)";")i)+"#"

Probieren Sie es online!

Erweitert

// string -> string
let convert input =
    System.String.Join(
        "#",      // join the following char seq with "#"
        input     // replicate ";" n times where n = ASCII value of char c
        |> Seq.map (fun c-> String.replicate (int c) ";") 
    ) + "#" // and add the last "#" to the output

convert nimmt den eingegebenen String und gibt ein; # Programm aus

Verwendung

convert "Hello, World!" |> printfn "%s"
convert "ABC" |> printfn "%s"
convert ";#" |> printfn "%s"
— Brunner
quelle
4
Wir brauchen mehr F # Antwort
— Aloisdg sagt Reinstate Monica
@ Aloisdg Ich werde mein Bestes tun :)
— Brunner
5

PowerShell, 29 27 25 Byte

$args|% t*y|%{';'*$_+'#'}

Ziemlich einfach. Übernimmt die Eingabe als Befehlszeilenargument. Die Ausgabe ist ein gültiges # Programm, das den angeforderten Text druckt.

— Joey
quelle
Es muss Ergebniszeichenfolgen verbinden.
— mazzy
@mazzy: Aus der Aufgabenbeschreibung: »Solange das Programm gültig ist, kann es überzählige Zeichen enthalten, außer #und solange ;alle anderen Zeichen ignoriert werden.«
— Joey
wie du willst :-)
— mazzy
Anführungszeichen können entfernt werden. $argsist genug.
— mazzy
Es sei denn, das Argument ist numerisch.
— Joey
4

Brainfuck , 47 Bytes

+++++++[->++++++++>+++++<<]>+++<,[[>.<-]>>.<<,]

Probieren Sie es online!

Siehe auch: Die Antwort von ovs , die einen ähnlichen Ansatz verfolgt, jedoch eine andere Methode zum Generieren von Konstanten und ein anderes Zellenlayout verwendet.

Erläuterung:

Diese Herausforderung passt ziemlich gut zur Brainfuck-Spezifikation, was bedeutet, dass die Lösung im Wesentlichen trivial ist. Brainfuck nimmt Eingaben als ASCII-Werte entgegen. Dies ist genau das, was # ausgeben muss.

Das Schema für das Transpilieren ist einfach: Generieren Sie den ASCII-Wert für ;und #drucken Sie ;gleich dem ASCII-Wert des eingegebenen Zeichens, drucken Sie #und wiederholen Sie für jede Eingabe.

+++++++[-             7
         >++++++++       * 8 = 56
         >+++++<<        * 5 = 35 (#)
       ]>+++<                  56 + 3 = 59 (;)
,[                    Input into first cell
  [>.<-]              Print ;'s equal to ASCII input
  >>.<<,              Print one #
 ]                    End on EOF
— Zack C.
quelle
-2 Bytes Nur -1, wenn Sie negative Zellen vermeiden
— Jo King
4

Mathematica, 49 Bytes

StringRepeat[";",#]<>"#"&/@ToCharacterCode@#<>""&

Erläuterung

Bildbeschreibung hier eingeben

Konvertiert die Eingabezeichenfolge in eine Liste von Zeichencodes, Maps die Funktion StringRepeat[";",#]<>"#"&über der Liste und StringJoins das Ergebnis mit der leeren Zeichenfolge.

— Genisis
quelle
Warum brauchst du das <>""?
— CalculatorFeline
@CalculatorFeline Ohne das würde ich eine Liste von Zeichenketten für jedes Zeichen haben. StringJoining ( <>) die leere Zeichenkette verkettet jede Zeichenkette.
— Genisis
Vergaß das: P
— CalculatorFeline
3

Aceto , 19 Bytes

Da es in Aceto einen Dolmetscher gibt , dachte ich, dass es auch auf diese Herausforderung eine Aceto-Antwort geben wird. Es passt genau in eine Hilbert-Kurve 2. Ordnung:

\n;*
'o'p
`!#'
,dpO

Zunächst lesen wir ein einzelnes Zeichen ( ,) und duplizieren und negieren es, um zu testen, ob es sich um eine neue Zeile handelt ( d!beim Lesen einer neuen Zeile wird normalerweise ein leeres Zeichen auf den Stapel geschrieben). Ich benutze dann einen meiner Meinung nach ziemlich cleveren Trick, um den Newline-Fall kompakt zu handhaben:

`'\n

Wenn der Wert auf dem Stapel ist True(lesen wir eine neue Zeile), das Codemittel: Sie ( `) legte einen Zeichenliteral auf dem Stack ( '), die ein Newline ist: \n.

Wenn der Wert auf dem Stapel ist False(wir nicht eine neue Zeile gelesen haben), dass Code - Mittel: nicht ( `) lesen (ein Zeichenliteral '). Das heißt, das nächste Zeichen wird als Befehl ausgeführt. Glücklicherweise wird der nächste Befehl durch einen Backslash nübergangen ( damit er nicht ausgeführt wird), sodass keine neue Zeile ausgegeben wird (was nnormalerweise der Fall ist).

Der Rest des Codes ist unkompliziert. Wir konvertieren das Zeichen auf dem Stapel in die Ganzzahl seines Unicode-Codepunkts ( o), drücken ein Semikolon ( ';), multiplizieren die Zahl mit der Zeichenfolge ( *wie in Python), pdrucken das Ergebnis, drücken ein Literal ( ') #, pdrucken es auch, und gehen Sie zurück zum Origin.

Führen Sie mit aus, -Fwenn Sie sofortige Ergebnisse sehen möchten (da Pufferung), aber es funktioniert auch ohne.

— L3viathan
quelle
3

Perl, 24 Bytes

s/./";"x(ord$&)."#"/ges

Laufen Sie mit perl -pe.

Alternative Lösung:

say";"x ord,"#"for/./gs

Laufen Sie mit perl -nE.

— Grimmig
quelle
3

Trost , 11 Bytes

Ja, neue Sprachen.

';@jx{'#}Ep

Erläuterung

';           Push the code point of ';' (59).
  @j         Push the entire input as a list of code points.
    x        For each code point in the input, repeat 59 that many times.
     {  }E   For each resulting list of 59s:
      '#      Push the code point of '#' (35).
          p  Flatten and print as unicode characters.
— Geschäfts-Katze
quelle
3

Fourier , 19 Bytes

$(I(`;`&j)`#`0~j&i)

Probieren Sie es auf FourIDE!

Um ausgeführt zu werden, müssen Sie die Eingabezeichenfolge in Anführungszeichen setzen.

Erklärung Pseudocode

While i != Input length
    temp = pop first char of Input
    While j != Char code of temp
        Print ";"
        Increment j
    End While
    Print "#"
    j = 0
    Increment i
End While
— Beta-Zerfall
quelle
3

JavaScript, 55 54 51 50 48 Bytes

s=>1+[...s].map(c=>";".repeat(Buffer(c)[0])+"#")

Probieren Sie es online aus

  • 1 Byte gespart dank Neil .

Alternativen

Wenn wir Eingaben als Array einzelner Zeichen annehmen können, können 5 Bytes gespeichert werden.

a=>1+a.map(c=>";".repeat(Buffer(c)[0])+"#")

Wenn wir auch als Array ausgeben können, können 2 weitere Bytes gespeichert werden.

a=>a.map(c=>";".repeat(Buffer(c)[0])+"#")
— Zottelig
quelle
\nsollte werden ;;;;;;;;;;#.
— Neil
Hmm ... das ist seltsam. Ich denke, ich muss auf die längere Lösung zurückgreifen, also. Vielen Dank, @Neil.
— Shaggy
2
Ich denke du könntest wechseln .zu [^], was würde es noch ein Byte kürzer lassen als map/join?
— Neil
Yup, das hat den Job gemacht, @Neil :)
— Shaggy
Nur ein Köpfchen, die join()in Ihrer vorherigen Antwort war angesichts der Spezifikation für unnötig ;#, und Sie können auch deklarieren, dass die Eingabe für Ihre Funktion ein Array von Zeichen ist, obwohl der zweite Vorschlag etwas langwierig ist. So oder so, das bringt Sie auf maximal 48 Bytes.
— Patrick Roberts
2

Eigentlich 11 Bytes

O⌠';*'#o⌡MΣ

Probieren Sie es online!

Erläuterung:

O⌠';*'#o⌡MΣ
O            convert string to list of ASCII ordinals
 ⌠';*'#o⌡M   for each ordinal:
  ';*          repeat ";" that many times
     '#o       append "#"
          Σ  concatenate
— Mego
quelle
2

APL (Dyalog) , 18 Bytes

'#',¨⍨';'⍴¨⍨⎕UCS

Probieren Sie es online!

⎕UCS In Unicode-Codepunkte konvertieren

';'⍴¨⍨ Verwenden Sie jeden Codepunkt, um ein Semikolon umzuformen ( ⍴ = Rho ≈ R ; R eshape)

#',¨⍨ füge einen Hash an jede Zeichenkette an

— Adam
quelle
2

Ruby, 28 25 Bytes

24 Bytes plus den -nBefehlszeilenschalter, um wiederholt zu arbeiten stdin.

$_.bytes{|b|$><<?;*b+?#}

3 Bytes gespart (und Ausgabe in Zeilenumbrüchen korrigiert!) Dank Handarbeit.

— Chowlett
quelle
Sie könnten die Verwendung von vermeiden .orddurch die Arbeit direkt mit Zeichencodes: $_.bytes{|b|$><<?;*b+?#}. Es gibt einen Unterschied: Dieser codiert auch den Zeilenumbruch in der Eingabe. Ich bin mir nicht sicher, was der Fragesteller mit „Es enthält nur druckbare ASCII-Zeichen und Zeilenumbrüche“ zu sagen beabsichtigt, aber für mich klingt es so, als ob Zeilenumbrüche ebenfalls codiert werden sollten.
— manatwork
Dein Ruby-Fu übersteigt meins, @manatwork - ich hatte es vergessen bytes. Ich habe OP nach neuen Zeilen oben gefragt und werde diese anschließend bearbeiten.
— Chowlett
2

Alice , 12 Bytes

'#I.h%&';d&O

Probieren Sie es online!

Erläuterung

'#    Push 35, the code point of '#'.
I     Read a code point C from STDIN. Pushes -1 at EOF.
.h%   Compute C%(C+1). For C == -1, this terminates the program due to division
      by zero. For C > -1, this just gives back C, so it does nothing.
&';   Pop C and push that many 59s (the code point of ';').
d     Push the stack depth, which is C+1.
&O    Print that many code points from the top of the stack.
      The IP wraps around to the beginning and another iteration of this
      loop processes the next character.
— Martin Ender
quelle
2

PHP, 48 Bytes

for(;$c?:~$c=~ord($argn[$i++]);)echo";#"[!++$c];
— user63956
quelle
2

jq, 30 Zeichen

(26 Zeichen Code + 4 Zeichen Befehlszeilenoptionen)

explode|map(";"*.+"#")|add

Probelauf:

bash-4.4$ jq -Rr 'explode|map(";"*.+"#")|add' <<< 'Hello, World!' | jq -Rrj '[scan(".*?#")|gsub("[^;]";"")|length%127]|implode'
Hello, World!

Online-Test

— Mann bei der Arbeit
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.