Ihre Herausforderung besteht darin, ein Programm zu schreiben, das die Farbe eines bestimmten Quadrats vom Schachbrett ausgibt. So sieht ein Schachbrett aus:

Sie können sehen, dass das Quadrat a1 dunkel ist und h1 ein helles Quadrat. Ihr Programm muss darkoder ausgeben light, wenn ein Quadrat angegeben wird. Einige Beispiele:

STDIN:  b1
STDOUT: light

STDIN:  g6
STDOUT: light

STDIN:  d4
STDOUT: dark

Die Regeln:

• Sie müssen ein vollständiges Programm bereitstellen, das STDIN und STDOUT zur Ausgabe von darkoder verwendet light.
• Angenommen, die Eingabe ist immer gültig ( [a-h][1-8])
• Das ist Code-Golf , also gewinnt die kürzeste Anzahl von Bytes!

Anzeigetafel

var QUESTION_ID=63772,OVERRIDE_USER=8478;function answersUrl(e){return"http://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(e,s){return"http://api.stackexchange.com/2.2/answers/"+s.join(";")+"/comments?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){answers.push.apply(answers,e.items),answers_hash=[],answer_ids=[],e.items.forEach(function(e){e.comments=[];var s=+e.share_link.match(/\d+/);answer_ids.push(s),answers_hash[s]=e}),e.has_more||(more_answers=!1),comment_page=1,getComments()}})}function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){e.items.forEach(function(e){e.owner.user_id===OVERRIDE_USER&&answers_hash[e.post_id].comments.push(e)}),e.has_more?getComments():more_answers?getAnswers():process()}})}function getAuthorName(e){return e.owner.display_name}function process(){var e=[];answers.forEach(function(s){var r=s.body;s.comments.forEach(function(e){OVERRIDE_REG.test(e.body)&&(r="<h1>"+e.body.replace(OVERRIDE_REG,"")+"</h1>")});var a=r.match(SCORE_REG);a&&e.push({user:getAuthorName(s),size:+a[2],language:a[1],link:s.share_link})}),e.sort(function(e,s){var r=e.size,a=s.size;return r-a});var s={},r=1,a=null,n=1;e.forEach(function(e){e.size!=a&&(n=r),a=e.size,++r;var t=jQuery("#answer-template").html();t=t.replace("{{PLACE}}",n+".").replace("{{NAME}}",e.user).replace("{{LANGUAGE}}",e.language).replace("{{SIZE}}",e.size).replace("{{LINK}}",e.link),t=jQuery(t),jQuery("#answers").append(t);var o=e.language;/<a/.test(o)&&(o=jQuery(o).text()),s[o]=s[o]||{lang:e.language,user:e.user,size:e.size,link:e.link}});var t=[];for(var o in s)s.hasOwnProperty(o)&&t.push(s[o]);t.sort(function(e,s){return e.lang>s.lang?1:e.lang<s.lang?-1:0});for(var c=0;c<t.length;++c){var i=jQuery("#language-template").html(),o=t[c];i=i.replace("{{LANGUAGE}}",o.lang).replace("{{NAME}}",o.user).replace("{{SIZE}}",o.size).replace("{{LINK}}",o.link),i=jQuery(i),jQuery("#languages").append(i)}}var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk",answers=[],answers_hash,answer_ids,answer_page=1,more_answers=!0,comment_page;getAnswers();var SCORE_REG=/<h\d>\s*([^\n,]*[^\s,]),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/,OVERRIDE_REG=/^Override\s*header:\s*/i;

body{text-align:left!important}#answer-list,#language-list{padding:10px;width:290px;float:left}table thead{font-weight:700}table td{padding:5px}

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script> <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"> <div id="answer-list"> <h2>Leaderboard</h2> <table class="answer-list"> <thead> <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr></thead> <tbody id="answers"> </tbody> </table> </div><div id="language-list"> <h2>Winners by Language</h2> <table class="language-list"> <thead> <tr><td>Language</td><td>User</td><td>Score</td></tr></thead> <tbody id="languages"> </tbody> </table> </div><table style="display: none"> <tbody id="answer-template"> <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table> <table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table>

GS2 , 17 15 Bytes

de♦dark•light♠5

Der Quellcode verwendet die CP437- Codierung. Probieren Sie es online!

Nachprüfung

$ xxd -r -ps <<< 6465046461726b076c696768740635 > chess.gs2
$ wc -c chess.gs2 
15 chess.gs2
$ gs2 chess.gs2 <<< b1
light

Wie es funktioniert

d               Add the code points of the input characters.
 e              Compute the sum's parity.
  ♦             Begin a string literal.
   dark
       •        String separator.
        light
             ♠  End the string literal; push as an array of strings.
              5 Select the element that corresponds to the parity.

Python 2, 41 38 Bytes

print'ldiagrhkt'[int(input(),35)%2::2]

3 Bytes dank Mego für das String-Interlacing

Nimmt Eingaben wie "g6". Das ist hell und dunkel miteinander verflochten.

Hexagony , 34 32 Bytes

,},";h;g;;d/;k;-'2{=%<i;\@;trl;a

Ungefaltet und mit kommentierten Ausführungspfaden:

^{Mit Timwis erstaunlichem HexagonyColorer erstelltes Diagramm .}

Der violette Pfad ist der Anfangspfad, der zwei Zeichen liest, deren Differenz berechnet und modulo 2 annimmt. Der <Pfad fungiert dann als Zweig, in dem der dunkelgraue Pfad (Ergebnis 1) darkund der hellgraue Pfad (Ergebnis 0) gedruckt werden light.

Wie ich die Differenz und das Modulo berechne, ist hier ein Diagramm des Speichergitters (mit Werten, die für die Eingabe verwendet wurden a1):

^{Das Diagramm wurde mit Timwis noch besserer esoterischer IDE (die einen visuellen Debugger für Hexagony enthält) erstellt.}

Der Speicherzeiger beginnt an der mit row bezeichneten Kante , an der wir das Zeichen lesen. }bewegt sich zu der mit col bezeichneten Kante , wo wir die Ziffer lesen. "bewegt sich zu der mit diff bezeichneten Kante, wo -die Differenz der beiden berechnet wird. 'bewegt sich zu der unbeschrifteten Zelle, in die wir die einfügen 2, und {=bewegt sich zu der Zelle mit der Bezeichnung mod, mit der wir das Modulo berechnen %.

Dies kann durch Wiederverwendung einiger der Elemente um einige Bytes golfen werden ;, aber ich bezweifle, dass es durch viele Elemente golfen werden kann, sicherlich nicht bis zur Seitenlänge 3.

CJam, 18 Bytes

r:-)"lightdark"5/=

Online-Demo

Präparation

r               e# Read a token of input
:-              e# Fold -, giving the difference between the two codepoints
)               e# Increment, changing the parity so that a1 is odd
"lightdark"5/   e# Split the string to get an array ["light" "dark"]
=               e# Index with wrapping, so even => "light" and odd => "dark"

sed, 37

s/[1357aceg]//g
/^.$/{clight
q}
cdark

Erläuterung

s/[1357aceg]//gEntfernt alle ungeraden Koordinaten. Der resultierende Musterpuffer hat dann eine Länge von 1 für "hell" oder eine Länge von 0 oder 2 für "dunkel". Stimmt mit den /^.$/Mustern der Länge 1 cüberein , ändert das Muster in "Licht" und qpasst an. Ansonsten wird das Muster cauf "dunkel" gehängt.

Pyth, 18 Bytes

@c2"lightdark"iz35

Interpretieren Sie die Eingabe als Basiszahl, hacken Sie sie lightdarkin zwei Hälften und drucken Sie sie.

ShadyAsFuck, 91 Bytes / BrainFuck, 181 Bytes

Mein erstes echtes BrainFuck-Programm, danke Mego für die Hilfe und den Hinweis auf das Algorithmus-Archiv. (Das heißt, ich habe es nicht wirklich alleine gemacht, sondern einige vorhandene Algorithmen kopiert. Immer noch eine Erfahrung =)

NKnmWs3mzhe5aAh=heLLp5uR3WPPPPagPPPPsuYnRsuYgGWRzPPPPlMlk_PPPPPP4LS5uBYR2MkPPPPPPPP_MMMkLG]

Dies ist natürlich die Übersetzung von meinen Brainfuck-Antworten:

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

Entwickelt mit diesem Interpreter / Debugger .

Ich habe zwei Code-Schnipsel für divmodund if/elsevon hier gestohlen . (Danke an @Mego!)

,>,               read input
[<+>-]            add
++<               set second cell to 2 

Jetzt haben >sum 2wir die Zellenkonfiguration und führen den Divmod-Algorithmus aus:

[->-[>+>>]>[+[-<+>]>+>>]<<<<<]>
[-]>

Die Ausgabe des DivMod sieht so aus, 0 d-n%d >n%d n/daber wir haben das auf Null gesetzt d-n%dund setzen auch die nächste Zelle auf Null :

>[-]

Füllen Sie eine Zelle bis zum Wert, 100um die Ausgabe zu vereinfachen:

++++++++++[>++++++++++<-]< 

Jetzt ist die Konfiguration >cond 0 100und für die Anwendung des if/elseAlgorithmus benötigen wir zwei temporäre Variablen, also wählen wir die Konfigurationtemp0 >c temp1 100

c[<temp0+>>temp1+<c-]<temp0[>c+<temp0-]+
>>temp1[
 #>++++++++.---.--.+.++++++++++++.<         outputs light
 <<temp0-
>>temp1[-]]
<<temp0[
 #>>>.---.+++++++++++++++++.-------.<<<     outputs dark
temp0-]

Python 2, 45 Bytes

print'dlairgkh t'[sum(map(ord,input()))%2::2]

Nimmt Eingaben wie "a1". Probieren Sie es online aus

Im Ernst , 19 Bytes

"dark""light"2,O+%I

Nimmt Eingaben wie "a1"

Probieren Sie es online aus (Sie müssen die Eingabe manuell eingeben; die Permalinks mögen keine Anführungszeichen)

Turing Machine Code, 235 Byte

Verwenden Sie die hier definierte Regeltabellensyntax.

0 a _ r 1
0 c _ r 1
0 e _ r 1
0 g _ r 1
0 * _ r 2
1 2 _ r 3
1 4 _ r 3
1 6 _ r 3
1 8 _ r 3
2 1 _ r 3
2 3 _ r 3
2 5 _ r 3
2 7 _ r 3
* * _ r 4
3 _ l r A
A _ i r B
B _ g r C
C _ h r D
D _ t r halt
4 _ d r E
E _ a r F
F _ r r G
G _ k r halt

JavaScript (ES6), 45 Byte

alert(parseInt(prompt(),35)%2?"dark":"light")

TI-BASIC, 66 Bytes

Getestet mit einem TI-84 + Taschenrechner.

Input Str1
"light
If inString("bdfh",sub(Str1,1,1)) xor fPart(.5expr(sub(Str1,2,1
"dark
Ans

Hier ist eine interessantere Variante der dritten Zeile, die leider genau dieselbe Größe hat:

Input Str1
"dark
If variance(not(seq(inString("bdfh2468",sub(Str1,X,1)),X,1,2
"light
Ans

Man könnte meinen, TI-BASIC wäre bei dieser Herausforderung anständig, da es sich um Modulo 2 handelt. Diese Lösungen scheinen so kurz wie möglich zu sein.

Wir verwenden eine Menge Bytes, um beide Zeichen in die Zeichenkette zu bekommen, aber was wirklich kostet, sind die dreizehn Zwei-Byte-Kleinbuchstaben.

Befunge-93 , 39 37 33 31 Bytes

Alle Kredite an Linus , die vorgeschlagen diese 31-Byte - Lösung:

<>:#,_@  v%2-~~
"^"light"_"krad

Testen Sie es mit diesem Interpreter .

Erläuterung

<        v%2-~~

Das <am Anfang sendet den Anweisungszeiger nach links, wo er nach rechts umläuft. Es liest sich dann in zwei Zeichen von der Eingabe als ASCII, subtrahiert sie und macht einen Modulo von 2. Wie aund 1beide ungerade sind (in Form von ASCII - Code), das funktioniert. Das vlenkt den Anweisungszeiger nach unten ...

"^"light"_"krad

... auf den _, der den Anweisungszeiger nach links sendet, wenn die Stapelspitze 0 ist, und ansonsten nach rechts. Die Zeichen "hell" bzw. "dunkel" werden in umgekehrter Reihenfolge auf den Stapel geschoben. Beide Pfade treffen ^auf der linken Seite, wodurch der Befehlszeiger nach oben zeigt ...

 >:#,_@

... zum Ausgangssegment. :dupliziert die Oberseite des Stapels, #springt über das ,und auf das _, was den Befehlszeiger nach rechts sendet, wenn die Oberseite des Stapels 0 ist, und ansonsten nach links. Wenn der Stapel leer ist, ist die Oberseite des Stapels (nach :) 0, so dass der Befehlszeiger auf das trifft, @was die Ausführung stoppt. Andernfalls trifft es den ,, der den Anfang des Stapels als Zeichen ausgibt, und #springt dann über den :und auf den >, der den Vorgang erneut startet.

Japt , 23 22 Bytes

Japt ist eine verkürzte Version von Ja vaScri pt . Dolmetscher

Un19 %2?"dark":"light"

Wie es funktioniert

          // Implicit: U = input string
Un19      // Convert U from a base 19 number to decimal.
%2        // Take its modulo by 2.
?"dark"   // If this is 1, return "dark".
:"light"  // Else, return "light".
          // Implicit: output last expression

Mit der neuen Version 0.1.3 (veröffentlicht am 22. November) werden dies 17 Bytes , weniger als mit Ausnahme von GS2:

Un19 %2?`»rk:¦ght

Oder alternativ eine Zauberformel: (26 Bytes)

Un19 %2*22189769+437108 sH
Un19 %2                    // Convert input to base 19 and modulo by 2.
       *22189769+437108    // Where the magic happens (top secret)
                        sH // Convert to a base 32 string.

Java, 157 127 124 Bytes

interface L{static void main(String[]a){System.out.print(new java.util.Scanner(System.in).nextInt(35)%2>0?"dark":"light");}}

TeaScript , 23 Bytes

®x,35)%2?"dark":"light"

Leider sind die Saiten darkund lightkönnen nicht komprimiert werden.

Ruby, durchgestrichen 44 36 Bytes

puts %w[light dark][gets.to_i(19)%2]

C 55 Bytes

s;main(){puts(strtol(gets(&s),0,19)&1?"light":"dark");}

Probieren Sie es online aus

Vielen Dank an DigitalTrauma für viele Golftipps

BotEngine , 165 14 × 11 = 154

v acegbdfh
>ISSSSSSSS
 v<<<<>v<<P
vS1   vS2ke
vS3   vS4re
vS5   vS6ae
vS7   vS8de
>     >   ^
>     >  v
^S2   ^S1el
^S4   ^S3ei
^S6  P^S5eg
^S8 te^S7eh
     ^   <

Hier ist es mit den verschiedenen Pfadsegmenten hervorgehoben:

(Nicht-Leerzeichen, die nicht hervorgehoben sind, dienen als Argumente für die Anweisungen eund - Sjede dieser Anweisungen verwendet das Symbol links (relativ zur Fahrtrichtung des Bot) als Argument.)

𝔼𝕊𝕄𝕚𝕟, 26 Zeichen / 34 Bytes

ô(שǀ(ï,ḣ)%2?`dark`:`light”

Try it here (Firefox only).

C 49 Bytes

main(c){gets(&c);puts(c+c/256&1?"light":"dark");}

Clojure, 63 Bytes

(pr (['light 'dark] (mod (Integer/parseInt (read-line) 35) 2)))

• Wir lesen in einer Zeile von stdin mit (read-line)
• Analysieren Sie dann die Zeichenfolge in einen ganzzahligen Wert in der Basis 35, indem Sie eine JVM-Methode aufrufen
• Wenn wir den Mod des Ergebnisses 2 nehmen, erfahren wir, ob es gerade oder ungerade ist
• Verwenden Sie das von der Modulo-Funktion zurückgegebene Ergebnis als Index für die Sequenz und drucken Sie es aus

Ich spare wertvolle 2 Bytes, indem ich "hell" und "dunkel" mit einem einzigen Anführungszeichen zitiere, sodass Clojure es als Literal verwendet, anstatt jedes Wort in Anführungszeichen zu setzen. Ich spare auch ein paar Bytes, indem ich pr anstelle von println verwende.

Einige Infos zum Zitieren in Clojure

Minkolang 0.12 , 28 24 Bytes

on+2%t"dark"t"light"t$O.

Probieren Sie es hier aus.

Erläuterung

o                   Take character from input
n                   Take integer from input
+                   Add
2%                  Modulo by 2
t      t       t    Ternary; runs first half if top of stack is 0, second half otherwise
 "dark" "light"     Pushes the string "dark" or "light", depending.
$O.                 Output the whole stack as characters and stop.

C 46 Bytes

main(c){gets(&c);puts(c%37%2?"light":"dark");}

Erwartet eine Umgebung, in der ints Little-Endian gespeichert sind und mindestens zwei Byte groß sind.

Erläuterung

cist argc, so enthält es anfangs 01 00 00 00. getsIch lese zwei Zeichen, sage a (0x61)und 1 (0x31)und speichere sie in dem c, was jetzt ist

61 31 00 00

Darstellen der Zahl 0x3161 oder 12641.

Im Wesentlichen c = x + 256*ymöchten wir in diesem gegebenen Problem (x + y) mod 2eine Zeichenfolge berechnen und entsprechend drucken. Dazu hätte ich c % 255 % 2wie damals schreiben können

  (x + 256 * y) % 255 % 2
= (x % 255 + y % 255) % 2      since 256 ≡ 1 (mod 255)
= (x + y) % 2                  since 0 < x, y < 255

Funktioniert aber 37auch:

  (x + 256 * y) % 37 % 2
= (x % 37 - 3 * (y % 37)) % 2  since 256 ≡ -3 (mod 37)

xliegt im Bereich von 49-57 einschließlich (Ziffern 1-8), so x % 37 == x - 37.

yliegt im Bereich von 97-104 einschließlich (Kleinbuchstaben ah), so y % 37 == y - 74.

Dies bedeutet, wir können zu vereinfachen

= (x - 3 * y + 185) % 2
= (x + y + 1) % 2              since -3 ≡ 185 ≡ 1 (mod 2)

und drehen Sie einfach die Zeichenfolgen, um die Parität zu korrigieren.

Strahl , 127 Bytes

rSr>`+v
   ^  )
n(`)nS<
    >L'''''>`+++++)S>`+++)@---@'''>`+++++)++@-------@H
>L'''''>`+++)S>`++++++)+++@---@--@+@'''>`++++)@H

Eine Erklärung Hellblau - Liest ein Zeichen von der Eingabe in den Strahl, speichert den Strahlwert im Speicher und liest ein Zeichen von der Eingabe in den Strahl.

Dunkelblau - Fügt dem Strahl einen Speicher hinzu, indem der Speicher auf 0 verringert wird, während der Strahl inkrementiert wird

Hellgrün - Ein geradzahliges Testkonstrukt. Die Schleife wird nach links verlassen, wenn der Strahl gerade ist, oder nach rechts, wenn er ungerade ist.

Dunkelgrün - Gibt dunkel aus

Hellbraun - Gibt Licht aus

O , 2217 Bytes

i # 2% "light'dark"?

Dies macht das, was es tun muss, ohne zusätzliche Vorteile.

Labyrinth , 48 46 45 42 Bytes

Danke an Sp3000 für das Speichern von zwei Bytes.

-,"
#
%0:::8.5.3.4.116.@
1
00.97.114.107.@

Probieren Sie es online!

Erläuterung

Der Anfang des Codes ist eine lustige Sackgasse. Denken Sie daran, dass Labyrinth eine unendliche Anzahl von Nullen annimmt, wenn Operanden am unteren Rand des Stapels erforderlich sind. Der Code beginnt mit einem -Rechtslauf, der versucht, zwei Zahlen zu subtrahieren, und der Stapel wird zu:

[ ... 0 ]

Dann ,liest das erste Zeichen, asagen:

[ ... 0 97 ]

Das "ist ein No-Op, aber dies ist auch eine Sackgasse, also dreht sich der Befehlszeiger um und beginnt nach links zu gehen. Dann `liest das andere Zeichen, 2sagen:

[ ... 0 97 50 ]

Dieses Mal werden -diese beiden Zahlen subtrahiert:

[ ... 0 47 ]

Die IP folgt nun der Kurve des "Korridors". Das #ruft die Stapeltiefe ab, wobei die impliziten Nullen ignoriert werden 2.

[ ... 0 47 2 ]

Und %berechnet das Modulo:

[ ... 0 1 ]

Zu diesem Zeitpunkt befindet sich die IP an einer Kreuzung. Wenn der obere Rand des Stapels Null ist, bewegt er sich geradeaus, wo 100.97.114.107.@gedruckt wird dark. Wenn der obere Rand des Stapels jedoch nicht Null ist (speziell 1), wird er nach rechts verschoben, wo 0:::8.5.3.4.116.@gedruckt wird light(beachten Sie, dass der führende Rand weggelassen werden kann 1, da sich bereits ein 1auf dem Stapel befindet, und der wiederholte Wert gespeichert werden kann 10in 108, 105, 103, 104indem Sie ein paar Kopien der Herstellung , 10wenn wir bekommen es zuerst).

Matlab, 51 Bytes

Ich glaube nicht, dass dies einer Erklärung bedarf =)

a={'light','dark'};disp(a(2-mod(sum(input('')),2)))

> <> 31 Bytes

ii+2%?\"krad"oooo;
l"oc0.\"thgi

Hier denke ich: "Es muss einen besseren Weg geben ..."

Perl, 29 27 Bytes

$_=/./&($'+ord)?light:dark

Dieser Code erfordert den -pSchalter, den ich als 1 Byte gezählt habe.

Probieren Sie es online auf Ideone .

Wie es funktioniert

• Aufgrund des -pSchalters liest Perl eine Eingabezeile und speichert sie in $_.

• /./ist ein regulärer Ausdruck, der einem Zeichen entspricht. Dies hat zwei Auswirkungen:

  • Da das Spiel erfolgreich ist, /./gibt 1 .

  • Das Nachspiel (zweites eingegebenes Zeichen) wird in gespeichert $'.

• $'+ordFügt die Ganzzahl, die das zweite Eingabezeichen darstellt, zum Codepunkt ( ord) des ersten Zeichens der impliziten Variablen hinzu $_.

• &Nimmt das bitweise UND des Rückgabewerts von /./und der Summe $'+ord, 1 ist die Summe, wenn ungerade, 0, wenn es gerade ist.

• ?light:darkkehrt leuchtet , wenn der vorhergehende Ausdruck zurückgegeben 1 und dunkel anderweitig.

• Zum Schluss $_=ordnet $_Perl das Ergebnis zu , das aufgrund der -p Umstellung automatisch gedruckt wird .