diff --git a/.gitignore b/.gitignore
index 549e00a..cd021ec 100644
--- a/.gitignore
+++ b/.gitignore
@@ -31,3 +31,9 @@
 
 ### VS Code ###
 .vscode/
+
+### downloads ###
+/downloads
+
+### resources ###
+/src/main/resources
diff --git a/pom.xml b/pom.xml
index 74db2ef..7565cb6 100644
--- a/pom.xml
+++ b/pom.xml
@@ -16,9 +16,9 @@
     <version>1.0-SNAPSHOT</version>
 
     <properties>
-        <java.version>16</java.version>
-        <maven.compiler.source>16</maven.compiler.source>
-        <maven.compiler.target>16</maven.compiler.target>
+        <java.version>11</java.version>
+        <maven.compiler.source>11</maven.compiler.source>
+        <maven.compiler.target>11</maven.compiler.target>
     </properties>
 
     <dependencies>
@@ -32,6 +32,16 @@
             <artifactId>spring-boot-starter-test</artifactId>
             <scope>test</scope>
         </dependency>
+
+        <dependency>
+            <groupId>org.junit.jupiter</groupId>
+            <artifactId>junit-jupiter-api</artifactId>
+        </dependency>
+
+        <dependency>
+            <groupId>org.junit.jupiter</groupId>
+            <artifactId>junit-jupiter-engine</artifactId>
+        </dependency>
     </dependencies>
 
     <build>
@@ -39,6 +49,11 @@
             <plugin>
                 <groupId>org.springframework.boot</groupId>
                 <artifactId>spring-boot-maven-plugin</artifactId>
+                <version>2.5.6</version>
+            </plugin>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-surefire-plugin</artifactId>
             </plugin>
         </plugins>
     </build>
diff --git a/src/main/java/de/ids_mannheim/korap/openthesaurus/Experiments.java b/src/main/java/de/ids_mannheim/korap/openthesaurus/Experiments.java
index 9df4303..619689e 100644
--- a/src/main/java/de/ids_mannheim/korap/openthesaurus/Experiments.java
+++ b/src/main/java/de/ids_mannheim/korap/openthesaurus/Experiments.java
@@ -21,11 +21,9 @@
 
 */
 
-import java.io.*;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.HashMap;
-import java.util.List;
+import java.util.*;
+import java.util.Map.Entry;
+import java.util.stream.Collectors;
 
 
 public class Experiments {
@@ -37,17 +35,61 @@
     public static void main(String[] args) {
         // This example shows that Collections (e.g. ArrayLists) are mutable
         HashMap<String, List<String>> hashMap = new HashMap<>();
-        List<String> blabla = new ArrayList<>();
-        blabla.add("Name");
-        blabla.add("Surname");
-        blabla.add("Father name");
-        hashMap.put("Name", blabla);
+        List<String> players = new ArrayList<>();
+        players.add("Player1");
+        players.add("Player2");
+        hashMap.put("Team1", players);
+        List<String> players2 = new ArrayList<>();
+        players2.add("Player1");
+        players2.add("Player2");
+        hashMap.put("Team2", players2);
+        //System.out.println(hashMap);
 
-        System.out.println(hashMap);
+        HashMap<String, List<String>> hashMap1 = new HashMap<>();
+        List<String> players1 = new ArrayList<>();
+        players1.add("Player3");
+        players1.add("Player4");
+        players1.add("Player5");
+        hashMap1.put("Team1", players1);
+        //System.out.println(hashMap1);
 
-        hashMap.get("Name").add("Second name");
+        List<HashMap<String, List<String>>> teamsList = new ArrayList<>();
+        teamsList.add(hashMap);
+        teamsList.add(hashMap1);
 
-        System.out.println(hashMap);
+        System.out.println(teamsList);
+        /*
+        HashMap<String, List<List<String>>> merged = new HashMap<>();
+
+        for (HashMap<String, List<String>> teams : teamsList) {
+            Iterator<Entry<String, List<String>>> it = teams.entrySet().iterator();
+            while (it.hasNext()) {
+                Map.Entry<String, List<String>> pair = it.next();
+                String word = pair.getKey();
+                List<String> synonyms = pair.getValue();
+
+                if (merged.containsKey(word)) {
+                    merged.get(word).add(synonyms);
+                } else {
+                    List<List<String>> synsetList = new ArrayList<>();
+                    synsetList.add(synonyms);
+                    merged.put(word, synsetList);
+                }
+                ;
+                it.remove(); // avoids a ConcurrentModificationException
+            }
+        }
+        System.out.println(merged);
+
+         */
+
+        Map<String, List<List<String>>> teamsDict = teamsList
+                .stream()
+                .flatMap(m -> m.entrySet().stream())
+                .collect(Collectors.groupingBy(Map.Entry::getKey,
+                         Collectors.mapping(Map.Entry::getValue, Collectors.toList())));
+
+        System.out.println(teamsDict);
+
     }
-
 }
diff --git a/src/main/java/de/ids_mannheim/korap/openthesaurus/OpenThesaurusData.java b/src/main/java/de/ids_mannheim/korap/openthesaurus/OpenThesaurusData.java
index fe97ff7..f5ee962 100644
--- a/src/main/java/de/ids_mannheim/korap/openthesaurus/OpenThesaurusData.java
+++ b/src/main/java/de/ids_mannheim/korap/openthesaurus/OpenThesaurusData.java
@@ -9,6 +9,14 @@
 
 public class OpenThesaurusData {
 
+    /**
+     * Gets the filesize from a URL of a file to be downloaded.
+     * This is necessary to know in cases, where a download is resumed
+     * (e.g. after the connection is lost), because we don't want to start
+     * downloading from the beginning.
+     * @param  url URL of a file to download
+     * @return filesize in bytes
+     */
     private static int getFileSize(URL url) {
         URLConnection conn = null;
         try {
@@ -27,13 +35,22 @@
         }
     }
 
+    /**
+     * A convenience function that combines downloading and extracting a .zip file
+     * (e.g. OpenThesaurus data is provided as a .zip-file) at the same time
+     * @param URLString link to the data to download
+     * @param thesaurusFilepath filepath to save the extracted data
+     * @throws IOException
+     */
     public static void getFile(String URLString, String thesaurusFilepath) throws IOException {
 
         URL url = new URL(URLString);
         int fileSizeToDownload = getFileSize(url);
 
         File thesaurusFile = new File(thesaurusFilepath);
-        String[] thesaurusFilepathSplit = thesaurusFilepath.split("/");
+
+        // This creates directories in the filepath if they don't yet exist
+        String[] thesaurusFilepathSplit = thesaurusFilepath.split(File.separator);
         StringBuilder dirsBeforeFile = new StringBuilder();
         for (int i = 0; i < thesaurusFilepathSplit.length - 1; i++) {
             dirsBeforeFile.append(thesaurusFilepathSplit[i] + File.separator);
@@ -46,6 +63,7 @@
         urlconnection.setConnectTimeout(10000);
         urlconnection.setReadTimeout(10000);
         FileOutputStream FOS;
+        // Resume download if the file already exists, and it's not yet complete
         if (thesaurusFile.exists()) {
             downloadedSoFar = thesaurusFile.length();
             if (downloadedSoFar - fileSizeToDownload >=0)
@@ -74,6 +92,13 @@
         outputStream.close();
     }
 
+    /**
+     * Extracts the data from the ZipInputStream in 8192 byte chunks to a given
+     * OutputStream
+     * @param zipIn ZipInputStream with the data to extract
+     * @param bos OutputStream to extract the data to
+     * @throws IOException
+     */
     private static void extractFile(ZipInputStream zipIn, OutputStream bos) throws IOException {
         byte[] bytesIn = new byte[8192];
         int read = 0;
diff --git a/src/main/java/de/ids_mannheim/korap/openthesaurus/ResponseController.java b/src/main/java/de/ids_mannheim/korap/openthesaurus/ResponseController.java
index 779afa5..773f498 100644
--- a/src/main/java/de/ids_mannheim/korap/openthesaurus/ResponseController.java
+++ b/src/main/java/de/ids_mannheim/korap/openthesaurus/ResponseController.java
@@ -3,9 +3,8 @@
 import java.io.IOException;
 import java.io.InputStream;
 import java.util.HashMap;
-import java.util.HashSet;
 import java.util.List;
-import java.util.Objects;
+import java.util.Map;
 import java.util.concurrent.atomic.AtomicLong;
 
 import org.springframework.web.bind.annotation.GetMapping;
@@ -17,12 +16,12 @@
 
 @RestController
 public class ResponseController {
-    //private static final String template = "Your query is: %s";
+
     private final AtomicLong counter = new AtomicLong();
     String url = "https://www.openthesaurus.de/export/OpenThesaurus-Textversion.zip";
     String thesaurusFilepath = "downloads/openthesaurus.txt";
-    InputStream thesaurusInputStream = ResponseController.class.getResourceAsStream("/openthesaurus.txt");
-    HashMap<String, List<List<String>>> thesaurusDict = createThesaurusDictionary(thesaurusInputStream);
+    InputStream thesaurusInputStream = ResponseController.class.getResourceAsStream("/static/openthesaurus.txt");
+    Map<String, List<List<String>>> thesaurusDict = createThesaurusDictionary(thesaurusInputStream);
 
     @GetMapping("/openthesaurus")
     public Response openthesaurus(
diff --git a/src/main/java/de/ids_mannheim/korap/openthesaurus/ThesaurusDictionary.java b/src/main/java/de/ids_mannheim/korap/openthesaurus/ThesaurusDictionary.java
index 593ba5f..9e0b5e3 100644
--- a/src/main/java/de/ids_mannheim/korap/openthesaurus/ThesaurusDictionary.java
+++ b/src/main/java/de/ids_mannheim/korap/openthesaurus/ThesaurusDictionary.java
@@ -3,11 +3,24 @@
 import java.io.*;
 import java.util.*;
 import java.util.regex.*;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
 
 public class ThesaurusDictionary {
+
+    // The pattern is instantiated here for the sake of efficiency (gets reused lots of times)
     static String regex = "(\\(.+\\) *)*([^\\(\\)]+[^\\(\\ )])( *\\(.+\\))*";
     static Pattern withoutParenthesesPattern = Pattern.compile(regex);
 
+    /**
+     * Extracts words without parentheses from a string. Text file provided by
+     * OpenThesaurus contains not only synonyms on a line, but also some
+     * explanations/annotations, e.g. "(sich etwas) versagen (geh.)".
+     * Those are useless for querying and are, therefore, removed together
+     * with surrounding spaces.
+     * @param  str string to extract a substring from
+     * @return substring without words in parentheses
+     */
     static String cleanString(String str) {
         Matcher withoutParentheses = withoutParenthesesPattern.matcher(str);
         if (withoutParentheses.matches()) {
@@ -16,51 +29,86 @@
         return str;
     }
 
-    public static HashMap<String, List<List<String>>> createThesaurusDictionary(InputStream thesaurusPath) {
+    /**
+     * Reads in the text file with OpenThesaurus data and filters it as follows:
+     * 1) Ignores all lines, which start with a "#", as those are comments.
+     * 2) Reads in the lines before a line with "==" signs appears. This is the beginning
+     * of the licensing section, which should be removed.
+     * @param  thesaurusInputStream InputStream created from a path to OpenThesaurus data
+     * @return Stream<String> with relevant lines from the OpenThesaurus data file.
+     * @throws IOException
+     */
+    public static Stream<String> getAndFilterLines(InputStream thesaurusInputStream) throws IOException {
+        BufferedReader bf = new BufferedReader(new InputStreamReader(thesaurusInputStream));
+        return bf.lines()
+                 .takeWhile(line -> !line.startsWith("=="))
+                 .filter(line -> !line.startsWith("#"));
+    }
 
-        //File thesaurusData = new File(thesaurusPath);
-        HashMap<String, List<List<String>>> thesaurusDict = new HashMap<>();
-        try (BufferedReader bf = new BufferedReader(new InputStreamReader(thesaurusPath))) {
-            Iterator<String> fileItr = bf.lines().iterator();
-
-            while (fileItr.hasNext()) {
-                String line = fileItr.next();
-                if (line.startsWith("==")) break;
-                if (!line.startsWith("#") && line.length()>1) {
-                    String[] lineSplit = line.split(";");
-                    if (lineSplit.length > 1) {
-                        // this creates a dictionary entry for every word on the line
-                        // with all the other words as a List HashSet of synonyms
-                        for (int i = 0; i < lineSplit.length; i++) {
-                            String currentKey = lineSplit[i];
-                            List<String> synonyms = new ArrayList<>();
-                            for (int j = 0; j < lineSplit.length; j++) {
-                                // include all words except the current key
-                                // don't include explanations and word usage as "(ugs.)"
-                                if (j != i) synonyms.add(cleanString(lineSplit[j]));
-                            }
-                            if (thesaurusDict.containsKey(currentKey)) {
-                                thesaurusDict.get(currentKey).add(synonyms);
-                            }
-                            else {
-                                List<List<String>> synsetList = new ArrayList<>();
-                                synsetList.add(synonyms);
-                                thesaurusDict.put(lineSplit[i], synsetList);
-                            }
-                        }
-                    }
+    /**
+     * Processes a single line of text from the OpenThesaurus data file,
+     * creating a dictionary, where every word on the line appears as a
+     * key, having all other words as a list of values.
+     * @param  line a single line in the OpenThesaurus file
+     * @return HashMap<String, List<String>> with all combinations of
+     *         words on the line as keys, and their neighbors as values
+     *         (of course, ignoring the ordering in values)
+     */
+    public static Map<String, List<String>> processLine(String line) {
+        String[] lineSplit = line.split(";");
+        Map<String, List<String>> dictFromLine = new HashMap<>();
+        if (lineSplit.length > 1) {
+            // this creates a dictionary entry for every word on the line
+            // with all the other words as a List of synonyms
+            for (int i = 0; i < lineSplit.length; i++) {
+                // don't include explanations and word usage as "(ugs.)"
+                String currentKey = cleanString(lineSplit[i]);
+                List<String> synonyms = new ArrayList<>();
+                for (int j = 0; j < lineSplit.length; j++) {
+                    // include all words except the current key
+                    if (j != i) synonyms.add(cleanString(lineSplit[j]));
                 }
+                dictFromLine.put(currentKey, synonyms);
             }
-        } catch (IOException e) {
+        }
+        return dictFromLine;
+    }
+
+    /**
+     * Combines all the above into a pipeline and returns a dictionary, which
+     * can be queried for synonyms to get a list of synsets.
+     * @param thesaurusFileStream InputStream created from OpenThesaurus data file
+     * @return HashMap<String, List<List<String>>> with a word as a key, and
+     *         a List of Lists as values (each of them represents a synset)
+     */
+    public static Map<String, List<List<String>>> createThesaurusDictionary(InputStream thesaurusFileStream) {
+        Map<String, List<List<String>>> thesaurusDict = null;
+
+        try {
+            Stream<String> fileLines = getAndFilterLines(thesaurusFileStream);
+            thesaurusDict = fileLines
+                    .parallel()
+                    .flatMap(line -> processLine(line).entrySet().stream())
+                    .collect(Collectors.groupingBy(Map.Entry::getKey,
+                             Collectors.mapping(Map.Entry::getValue, Collectors.toList())));
+        }
+        catch (IOException e) {
             e.printStackTrace();
         }
+
         return thesaurusDict;
     }
 
-    public static HashMap<String, List<List<String>>> createThesaurusDictionary(String thesaurusPath) {
-
+    /**
+     * Overloads the InputStream version of the method in case a filepath String to
+     * OpenThesaurus data is provided (the alternative is when the default cached data
+     * from resources/static are used, obtained via "getResourceAsStream")
+     * @param  thesaurusPath filepath to the OpenThesaurus data file
+     * @return HashMap<String, List<List<String>>> with a word as a key, and
+     *         a List of Lists as values (each of them represents a synset)
+     */
+    public static Map<String, List<List<String>>> createThesaurusDictionary(String thesaurusPath) {
         InputStream FIS = null;
-
         try {
             FIS = new FileInputStream(thesaurusPath);
         }
@@ -68,15 +116,14 @@
             e.printStackTrace();
         }
         return createThesaurusDictionary(FIS);
-
     }
     /*
     public static void main(String[] args) {
-
-        HashMap<String, HashSet<String>> thesaurusDict =
-                createThesaurusDictionary("openthesaurus_data/openthesaurus.txt");
+        InputStream thesaurusInputStream = ThesaurusDictionary.class.getResourceAsStream("/static/openthesaurus.txt");
+        Map<String, List<List<String>>> thesaurusDict = createThesaurusDictionary(thesaurusInputStream);
 
         System.out.println(thesaurusDict.get("laufen"));
     }
+
      */
 }
diff --git a/src/main/resources/openthesaurus.txt b/src/main/resources/openthesaurus.txt
deleted file mode 100644
index 234cc26..0000000
--- a/src/main/resources/openthesaurus.txt
+++ /dev/null
@@ -1,44508 +0,0 @@
-# OpenThesaurus - German Thesaurus in text format
-# Automatically generated 2021-11-05 23:01
-# https://www.openthesaurus.de
-# Copyright (C) 2003-2020 Daniel Naber (naber at danielnaber de)
-#
-# This library is free software; you can redistribute it and/or
-# modify it under the terms of the GNU Lesser General Public
-# License as published by the Free Software Foundation; either
-# version 2.1 of the License, or (at your option) any later version.
-#
-# This library is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-# Lesser General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public
-# License along with this library; if not, write to the Free Software
-# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
-Atomspaltung;Kernspaltung (fachspr., technisch);Fission;Kernfission
-Wiederaufnahme;Fortführung
-davonfahren;aufbrechen;davonbrausen;abfahren;abzischen (ugs.);abhauen (ugs.);abdüsen (ugs.);abreisen;(von etwas) fortfahren;abdampfen (ugs.);wegfliegen;abfliegen;losfahren (ugs.);wegfahren;davonmachen (ugs.)
-Deputat...;Konzessions...
-Bildungsmaßnahme;Schulung;Weiterbildung;Kurs;Training;Workshop;Kursus;Lehrgang;Seminar
-Mangelhaftigkeit;Defizienz
-zuwiderhandeln;vom süßen Gift (des / der ...) naschen (geh., ironisierend, literarisch);böse sein (ugs., Kindersprache);mit Füßen treten (ein Recht) (ugs., fig.);(etwas) Verbotenes tun (Hauptform);(sich) hinwegsetzen (über);missachten;(ein) böses Kind sein (ugs., Kindersprache, variabel)
-überwachen;beaufsichtigen
-Wertmaßstäbe;Ethik;Moralvorstellungen;sittliche Werte;Sittlichkeit;Wertesystem;Wertvorstellungen;moralische Werte;Moral
-in einem Muskel;intramuskulär (fachspr.)
-Bewegungsgröße;Impuls
-Rufschädigung;Diffamie (geh.);Herabwürdigung;Diffamation (geh.);Verleumdung;Verunglimpfung;Diffamierung;Schmähung
-Dichtungsband;Dichtband
-Urmensch;Mensch der Altsteinzeit
-aus etwas schlau werden (ugs.);etwas verstehen
-Ankergrund;Ankerplatz
-SPD;(die) alte Tante SPD (ugs.);Sozis (ugs., abwertend);Sozialdemokratische Partei Deutschlands;Sozialdemokraten;(die) Sozen (ugs.)
-Kulturhoheit;Kulturautonomie
-Prägnanz;Komprimiertheit;Lakonik (geh.);Kürze;Brevität
-kühn;wacker;tapfer;mutig (Hauptform);couragiert;(echt) Eier in der Hose haben (ugs., fig., salopp);keine Angst kennen;weder Tod noch Teufel fürchten (geh., poetisch);wagemutig
-zu viel bezahlen;zu hoch bezahlen;überzahlen;überbezahlen
-platterdings;reinwegs;freilich (ugs., süddt.);schlechtweg;praktisch (ugs.);schlechterdings (geh., veraltend);geradezu;direktemang (ugs., berlinerisch, norddeutsch);rein (ugs.);rundheraus;schlechtwegs;rundweg;gradweg (ugs.);durchaus;glattweg;einfach;schlankwegs;schier (geh.);geradewegs;glatt;schlichtweg;nachgerade (geh.);glattwegs;schlicht und einfach;schlicht;geradezus (ugs., regional);gerade;schlichtwegs;direkt;schlankweg (ugs.);schlechthin (geh.);reinweg;reinewegs
-schlecht unterrichtet;schlecht informiert
-Verzerrung;Verkrümmung
-Moorwurzel;Pastinake;Pastinak
-sintern;schmelzen;fritten (fachspr.)
-ölig;schleimig;flutschig;schmierig;glitschig (Hauptform);schlierig
-Europäischer Fußballverband (Eigenname);UEFA (Abkürzung, Eigenname)
-mit zweifacher Bedeutung (Hauptform);kann man so oder so verstehen (ugs.);doppelsinnig;doppelwertig;doppeldeutig;ambivalent;zweideutig;ambig (geh.);janusköpfig (geh.);zweigesichtig (geh.);uneindeutig;ambigue (geh.)
-Dotierung;Gabe;Stiftung;Schenkung
-gut in Form;durchtrainiert (ugs.);athletisch;topfit
-nicht umhinkommen (zu);(sich) bemüßigt sehen (zu) (geh.);nicht umhinkönnen (zu);müssen;(sich) gezwungen sehen;gezwungen sein;(sich) genötigt sehen;(sich) bemüßigt fühlen (zu) (geh.);(sich) veranlasst sehen;(etwas) zu tun haben;genötigt sein;nicht anders können, als...;tun müssen
-wahrhaftig;wahrheitsgetreu;aufrichtig;wahr;der Wahrheit entsprechend;wahrheitsgemäß
-urzeitlich;prähistorisch;urgeschichtlich
-Bibliografie;Bibliognosie (veraltet);Bibliologie (veraltet);Bibliographie
-Haube;Fruchttraube;Kamm
-Merlin;Zwergfalke
-Schatten spendend;schattig;sonnenlos
-Ohrenschmalz;Cerumen (fachspr.);Zerumen (fachspr.)
-Messen;Messung;Vermessung
-Brotrinde;Brotkruste
-Uniformrock;bunter Rock;Waffenrock;Uniformjacke
-Andersdenker;Rebell;Abweichler;Andersdenkender;Dissident;schwarzes Schaf
-Glaubensfeldzug;Missionsfeldzug
-Rothaariger;Rotschopf (ugs.)
-Spatium (fachspr.);Leerschritt;Wortzwischenraum;Leerzeichen (Hauptform);Leerstelle;Leerschlag (schweiz.);Abstand (ugs.)
-...sitz;Stuhl (Hauptform);...stuhl;Sitz
-Lieferumfang;Leistungsumfang;Lieferungsumfang;Zubehör
-herunter;abwärts;hinunter;nach unten;nieder;in die Tiefe;runter;herab;hinab
-servicieren (österr.);pflegen;instand halten;in Stand halten
-Zuchtstammbuch;Herdbuch;Zuchtbuch
-Bandschreiber;Streifenschreiber
-Blätter;Blätterdach;Belaubung;Blattwerk;Laubwerk;Laub
-ansammeln (Hauptform);anhäufen;sammeln;zusammentragen;akkumulieren (fachspr.)
-unterbrechbar;präemptiv;preemptiv
-abgegriffen;abgenutzt;alt;oll (ugs., regional);abgewetzt
-Senderaum;Studio
-Synonym (Hauptform);Formulierungsvariante;Ersatzwort;Formulierungsalternative;sinn- und sachverwandtes Wort (Jargon);anderes Wort (für) (ugs.);bedeutungsgleiches Wort;Paraphrase;andere Bezeichnung;Stellvertreterwort;gleichbedeutender Ausdruck;variierende Formulierung
-Pneumonie (fachspr.);Lungenentzündung;Bronchopneumonie (fachspr.)
-schneidend;beißend;scharf (Geschmack)
-Zecke (derb, stark abwertend);Schnorrer (ugs.);Schmarotzer (derb);Nassauer (ugs.);Bettler
-Ofenrohr (ugs., fig.);Panzerabwehrrohr;Panzerfaust;Panzerbüchse;Bazooka (engl.)
-Silberlöwe;Berglöwe;Kuguar;Puma
-Arbeitsordnung;Betriebsordnung
-Börse;Parkett (ugs.);Aktienbörse;Effektenbörse;Wertpapierbörse
-Zoologie;Tierkunde
-(das) Überall-zuhause-Sein(-Wollen);Kosmopolitismus;Weltbürgertum
-horrend;bombastisch;üppig;gepfeffert (ugs.);übermäßig
-präoperativ (fachspr.);vor der Operation
-starr vor Schmerz;wie betäubt vor Schmerz
-Sonnenuntergang;Abendrot;Abendröte;blaue Stunde;Abenddämmerung
-Prostituierte (Hauptform);Kokotte (veraltet);Lustdirne (veraltet);Liebesdienerin;Escort;Hetäre (geh.);gefallenes Mädchen (altertümelnd, verhüllend);Straßenprostituierte;Bordsteinschwalbe (ugs.);Strichmädchen (ugs.);Sexdienstleisterin;Horizontale (ugs.);Escortgirl (engl.);Freudenmädchen;Frau für spezielle Dienstleistungen;Liebesdame;Liebesmädchen;Edelnutte (derb);Musche (ugs.);Anbieterin für sexuelle Dienstleistungen (fachspr., Amtsdeutsch, Jargon);betreibt das älteste Gewerbe der Welt (ugs.);Hartgeldnutte (derb);Straßendirne;Lohndirne (veraltet);Kurtisane;Hure (ugs.);Entspannungsdame (geh., verhüllend);Gunstgewerblerin (scherzhaft);Professionelle (ugs.);Nutte (derb, abwertend);Dirne;Sexarbeiterin (fachspr.);Straßenmädchen (ugs.);eine, die es für Geld macht (ugs.);Metze (geh., historisch);Dorfmatratze (derb);Callgirl (engl.);Schnepfe (ugs., abwertend);käufliches Mädchen
-Kontengliederung;Kontoklassifikation
-Jagdfalke;Gerfalke
-verheilen;abheilen
-Schale;Napf;Terrine;Schüssel
-Umsatzvolumen;Umsatz;Umschlag
-Basis;Lager;Stützpunkt
-einreichen;einhändigen;eingeben
-auswalzen;ausrollen;auswalken
-Aktienurkunde;Aktienzertifikat
-Kategorisierung;Klassifizierung;Konzeptualisierung (fachspr., selten);Einteilung;Klassifikation;Sortierung
-Errichten;Aufstellen;Aufmarschieren in Linie
-Check-in;(das) Einchecken;Abfertigung
-Tranquilizer (fachspr.);Beruhigungsmittel;Sedativ (fachspr.);Sedativum (fachspr.)
-Ovarektomie (fachspr.);Entfernung eines Eierstockes;Oophorektomie (fachspr.);Ovariektomie (fachspr.)
-Zeilenanordnung;Seitenformat
-Verlangsamung;Entschleunigung;Verzögerung
-Rohrverleger;Blechner;Flaschner (schwäbisch);Spengler (bayr., Hauptform, hessisch, schweiz., tirolerisch, österr.);Klempner (Hauptform, mitteldeutsch, norddeutsch);Installateur
-Reede;Liegeplatz;Ankerplatz
-Mannschaft;Crew;Besatzung
-Seelenverwandtschaft;Nähe;Verbundenheit;Gemeinschaft;Familiarität (geh.);Vertrautheit
-Pumpen;Durchströmung;Perfusion
-Bildung von roten Blutkörperchen;Erythropoese (fachspr.);Erythrogenese (fachspr.);Erythrozytogenese (fachspr.);Erythrozytopoese (fachspr.)
-Schritt;Schrittgeschwindigkeit;Schritttempo
-Lumbago (fachspr.);Hexenschuss;lokales Lumbalsyndrom
-Diabetes mellitus (fachspr.);Diabetes;Zuckerharnruhr;Zuckerkrankheit;Zucker (ugs.);Harnruhr
-Präkursor (fachspr.);biologische Vorstufe;Ausgangsstoff;Edukt;Grundstoff;Vorläufer
-verbunden;ansprechbar (Gerät);zugreifbar;erreichbar;angeschlossen;online;zugänglich
-Basisregister;Basisadressregister
-wortgewandt;schlagfertig (Hauptform);zungenfertig;(immer) die passende Antwort (parat) haben;(jemandem) nichts schuldig bleiben;sofort eine Antwort parat haben;spritzig;mit flinker Zunge;keine Antwort schuldig bleiben;mundfertig;um keine Antwort verlegen;nie um eine Antwort verlegen (sein);nicht auf den Mund gefallen (ugs.);geistesgegenwärtig;flinkzüngig (geh., selten)
-Antiemetikum (fachspr.);Mittel gegen Erbrechen
-eigentümlich;eigenartig;originell;eigen;spezifisch (geh.);besonders;idiosynkratisch;ausgefallen
-exportieren;ausführen
-unbewacht;unbeaufsichtigt
-Rabatz machen (ugs.);auf den Putz hauen (ugs.);die Sau rauslassen (ugs.);Streit suchen;Unruhe stiften
-Verleih;Vermietung
-Wettstreit;Rivalität;Gerangel;Wetteifer;Rangeleien (fig.);Konkurrenz
-unabwendbar;nicht vermeidbar;ohne Alternative;unvermeidlich;unaufhaltsam;alternativlos;unabdingbar;vorherbestimmt;programmiert;(an etwas) geht kein Weg vorbei;imperativ (geh.);nicht verhandelbar;da musst du jetzt durch (ugs., Spruch);vorprogrammiert (ugs.);zwingend;unausweichlich;(an etwas) führt kein Weg vorbei (fig.);unumgänglich;unabweisbar (geh.)
-(jemanden) versuchen;verleiten;locken;verführen
-Zielscheibe;Schießscheibe
-locker;leger;lax
-Weltgewandtheit;Lebensgewandtheit;Lebensart
-sichergehen (wollen);(sich) vergewissern (Hauptform);nachsehen (ob);kontrollieren;nachschauen (ob)
-misshandeln;malträtieren;missbrauchen;schlecht behandeln
-Blockschaltbild;Blockdiagramm
-plüschig;plüschen;aus Plüsch;plüschartig
-deprimieren;traurig stimmen;desillusionieren;einen (seelischen) Tiefschlag versetzen;betrüben;grämen;bedrücken
-Passivsaldo;Unterbilanz
-Anordnung in einer Linie;Ausrichten
-zu welcher Zeit;wann;zu welchem Zeitpunkt
-Vorbereitung;Weichenstellung (fig.)
-Vokal;Selbstlaut
-im Endergebnis;wirklich;in Wirklichkeit;praktisch;realiter;wahrhaft;wahrlich;im Ergebnis;in echt (jugendsprachlich);in der Praxis;faktisch;in Wahrheit;in praxi (geh., lat.);man muss ganz ehrlich sagen (ugs., floskelhaft);tatsächlich;nach Lage der Dinge;de facto
-Tatkraft;Energie;Leidenschaftlichkeit;Feuer (fig.);Heftigkeit;Passion;Dynamik;Verve (fachspr.);Eifer;Leidenschaft;Herzblut (fig.);Energeia (fachspr., griechisch)
-Tracheitis (fachspr.);Entzündung der Luftröhrenschleimhaut
-intern;innere;innerer;inwendig
-maßlose Enttäuschung;Bitterkeit;Verbitterung;Erbitterung
-Zweig;Reiser;Ast;verholzter Trieb
-Zweigniederlassung;Konsortialbank
-Langwelle;LW
-phänomenal;einzigartig;begnadet (geh.);rattenscharf (ugs.);geil (ugs., jugendsprachlich);glänzend;unvergleichlich;Spitze (ugs.);genial;erstklassig;süperb (geh.);berückend (geh.);(die) Wucht in Tüten (ugs., Redensart, veraltend);wunderbar;superb (geh.);sensationell;(ein) Traum;grandios;(das) rockt (ugs.);megacool (ugs.);unglaublich;zum Sterben schön (geh.);großartig (Hauptform);zum Niederknien (geh.);magnifik (geh., veraltet);ausgezeichnet;hervorragend;unübertrefflich;(der) Hammer! (ugs., jugendsprachlich);top (ugs.);fabelhaft;(eine) Offenbarung (geh.);(aller)erste Sahne (ugs.);urst (ostdeutsch-jugendsprachlich) (ugs.);vom Feinsten (ugs.);toll (ugs.);traumhaft;herausragend;absoluter Wahnsinn (ugs.);brillant;super (ugs.);himmelsgleich (geh.);wumbaba (ugs., Neologismus, ironisch);affengeil (ugs.);atemberaubend;unübertroffen;nicht zu toppen (ugs.);wundervoll;bestens (ugs.);hammergeil (ugs., jugendsprachlich);saugeil (ugs., jugendsprachlich);absolut super (ugs.);sagenhaft;phantastisch;atemraubend;himmlisch;absolut irre (ugs.);fulminant;du kriegst die Motten! (Ausruf) (ugs.);klasse (ugs.);ganz großes Kino (ugs., fig.);ganz große Klasse;(das) fetzt (ugs.);fantastisch;umwerfend;exzellent;hinreißend;nicht zu fassen (ugs.);Wahnsinn (ugs.);überragend (geh.);überwältigend;bäumig (ugs., schweiz., veraltet)
-in die Praxis umsetzen;ins Werk setzen;durchführen;realisieren;verwirklichen;vornehmen;ausführen;umsetzen;effektuieren
-abzielen auf;zum Gegenstand haben;auf etwas hinauswollen (ugs.)
-erholen;regenerieren;(sich) berappeln (ugs.);(sich wieder) sammeln (ugs.);wiederherstellen;neu erstellen
-Stangensellerie;Staudensellerie
-gegen den Wind segeln;kreuzen
-nicht von hier (ugs.);fremdländisch;welsch (abwertend, veraltet);fremdstaatlich;landfremd (veraltet);mit Migrationshintergrund (ugs.);ausländisch;fremd;nicht heimisch
-Mischwanne;Mischbecken
-Handwaffe;Handfeuerwaffe;Faustfeuerwaffe
-zur Kenntnis nehmen;Notiz nehmen (von);vermerken
-Beistand;Unterstützung;Erleichterung;helfende Hand (fig.);Support (Jargon, engl.);Rückendeckung;Unterstützungsangebot;(jemandem) Stütze (sein) (altertümelnd);Stab und Stütze (bibl.) (geh., fig.);Hilfe (Hauptform);Hilfestellung;Betreuung;Kooperation
-ganz in der Nähe;eng beieinander
-Verantwortungslosigkeit;Unverantwortlichkeit
-Rettungsstelle;Notaufnahme;Notambulanz (ugs.);Erste-Hilfe-Station;Notaufnahmestelle;Notfallambulanz;Notfallstation (schweiz.);Unfallstation (im Krankenhaus)
-Abkömmlinge;leibliche Nachkommenschaft
-(in ein System) einbrechen;aufbrechen (fig.);(etwas) hacken (IT-Technik, Hauptform);(etwas) knacken
-Fehlstart;Frühstart
-(sich) verflechten;(sich) verhaken;ineinander greifen
-dunkle Seite (fig.);negative Aspekte;Kehrseite der Medaille (fig.);Kehrseite;Nachteil;negative Seite;Schattenseite (fig.);Nachtseite (geh., fig.);(die) andere Seite der Medaille (fig.)
-Heilverfahren;medizinische Versorgung;Therapie;Behandlungsverfahren;Behandlung
-Direktwert;Istwert
-Regelmäßigkeit;Vorschriftsmäßigkeit
-(sich) zeigen (in);(sich) ausprägen;(sich) niederschlagen (in);(sich) formen;Ausdruck finden (in);(sich) erweisen
-Zurückhalten;Retention
-Unterkühlung;Hypothermie (fachspr.);Verklammung
-feststehen(d);definitiv;endgültig;für immer;letztgültig;abschließend;Schluss...;ein für alle Mal (ugs.);End...;letzte
-Produktpalette;Produktangebot
-warme Worte;Trost;Tröstung;Zuspruch;Balsam für die Seele;Seelenmassage (fig.);gutes Zureden
-beherrschen;geltend machen (Einfluss);ausüben (Macht, Amt)
-Schwarzhandel;Agiotage (österr.);Schleichhandel (österr.);Schwarzmarkt
-Presslufterzeuger;Luftkompressor;Drucklufterzeuger;Luftpresser
-manuelle Arbeit;Handarbeit
-zurücknehmen;zurückrufen;abbestellen;widerrufen;annullieren
-Stagnation;Nullwachstum;Wachstumsstillstand
-Betonmischer;Betonmischmaschine
-Widerstand;Behinderung;Obstruktion;Störung;Blockierung;Verzögerung
-Buchhaltung;Buchführung
-Metabolismus (fachspr., griechisch);(aufbauender) Stoffwechsel
-schütteln;rütteln
-Konferenzraum;Sitzungszimmer
-Blutzucker senkendes Mittel;Antidiabetikum (fachspr.)
-(einfach) übergehen;nicht einsteigen auf;links liegen lassen (ugs.);nicht (weiter) beachten;hinweggehen über
-Schlingern;Rollen (eines Schiffes)
-Beifall spenden;(die) Hände rühren (geh.);klatschen;Beifall zollen (geh.);in die Händchen patschen (ugs., abwertend);akklamieren (österr.);(mit) Beifall bedenken (geh.);Applaus spenden;beklatschen;applaudieren (Hauptform)
-falsch;getürkt (ugs.);gefälscht;unecht
-Zusammenrollung;Windung;Spiralwindung;Zusammenwicklung
-Dreifeld...;dreifeldrig
-verwesen;(sich) auflösen;(sich) zersetzen;verfallen
-Gegengift;Gegenmittel;Antidoton (fachspr., griechisch);Antidot (fachspr., griechisch)
-filzig;verfilzt
-Speisespannung;Einspeisespannung
-zusammenpassen;übereinstimmen;(sich) decken
-Kommission der Vereinten Nationen für internationales Handelsrecht;UNCITRAL
-ophthalmologisch (fachspr.);die Augenheilkunde betreffend
-Upgrade (engl.);Update (engl.);verbesserte Version;Softwareaktualisierung;Aktualisierung
-Supplement;Ergänzung (zu)
-Verbindung mit einem Ziel;Unicast (fachspr.)
-Schwungrad;Schwungmasse;Schwungscheibe
-bis (dass);erst wenn;bis (in, zu)
-(etwas) sehnlichst vermissen;desiderieren (geh., lat.);fiebern nach;verschmachten (nach);vergehen (nach);(inständig) verlangen (nach);dürsten (nach) (geh., poetisch);(sich) verzehren nach;(sich) sehnen (nach);gieren (nach);lechzen (nach);schmachten (nach)
-praxisbezogen;praxisorientiert;praxisnah;praxisgerecht
-unerschütterlich;geradlinig;gradlinig;unbeirrbar;(Ritter) ohne Furcht und Tadel;charakterstark;charakterfest
-Durchlassspannung;Vorwärtsspannung
-paternalistisch;herrisch;bevormundend;autoritär;obrigkeitlich
-halsbrecherisch;lebensbedrohlich;selbstmörderisch;lebensgefährlich
-Verfolgungswahn (ugs.);Paranoia;systematisierter Wahn
-Haubentaucher;Seetaucher
-ototoxisch (fachspr.);Gehör schädigend
-ungezwirntes Seidengarn;Florettgarn
-Wesfall;zweiter Fall;Genetiv (veraltet);Wessen-Fall;2. Fall;Genitivus (fachspr.);Genitiv;Wes-Fall;Herkunftsfall (fachspr.);Zeugefall;Wessenfall
-Überschuss;Profit;Ausbeute;Marge;Rendite;Verdienstspanne;Erlös;Ertrag;Gewinn;Gewinnspanne;Gewinnmarge;schwarze Zahlen (fig.)
-Enzyklika;päpstliche Bulle;päpstlicher Erlass;Bulle (fachspr.)
-unartikuliert;undeutlich;verwaschen (Aussprache);schlecht artikuliert;schwer verständlich;unklar;nuschelig (ugs.)
-außertourlich;unplanmäßig;nachträglich;außerplanmäßig
-Wildschutzgebiet;Wildreservat
-Thrombozytopenie (fachspr.);Verminderung der Blutplättchenzahl;Thrombopenie
-Athlet;Sportsmann;Sportler;Sportskanone (ugs.)
-Besprechung;Beratung;Konsultation;Consulting (fachspr.);Beratungsgespräch
-Ausweitung;Extension;Expansion;Ausdehnung;Zuwachs
-blutdrucksteigernd;vasopressorisch (fachspr.)
-auspressen;ausquetschen;exprimieren;auswringen;ausdrücken
-geringer;minder;kleiner;weniger bedeutend;weniger
-knochendürr;knochig
-Kringel;Windung;Ring
-kauen;beißen
-(sich) davonstehlen;(sich) einen schlanken Fuß machen (sprichwörtlich);(sich) fortstehlen;(sich) langsam entfernen (von)
-außerschulisch;außerhalb des Lehrplanes
-Foyer;Tagesraum;Aufenthaltsraum;Gesellschaftsraum
-Verkehrsader;Ausfallstraße
-Deckungslücke;Deckungsloch (im Haushalt)
-Einspruch erheben;Beschwerde einlegen (gegen/bei)
-Schulranzen;Tornister;Schulthek (schweiz.);Ranzen;Schultasche (österr.);Schulrucksack;Schultornister;Schulmappe (ostdeutsch);Schulsack (schweiz.);Thek (schweiz.)
-zustöpseln;pfropfen
-umsichtig;wohlüberlegt;mit Bedacht;bedachtsam
-geil machen (derb);antörnen (ugs.);(jemanden) erregen (Hauptform);scharfmachen (ugs.);ansexen (ugs.);(jemanden) anspitzen (ugs.);anturnen (ugs.);heißmachen (ugs.);aufgeilen (ugs.);anmachen;auf Touren bringen
-Buchgeschäft;Buchhandlung (Hauptform);Bucheinzelhandel;Sortimentsbuchhandel;Buchladen;Buchhändler
-Aufnahme in ein Krankenhaus;Hospitalisierung (fachspr.)
-Wirbelknochen;Wirbel (ugs.);Rückenwirbel
-Faselei (ugs.);dummes Geschwätz (ugs.)
-Webauftritt;Onlinepräsenz (ugs.);Internetseite;Internetpräsenz;Netzplatz;Netzpräsenz;Netzauftritt;Homepage (engl.);Webangebot;Internetangebot;WWW-Seite;Webseite;Internetauftritt;Netzseite;Web-Angebot;Webpräsenz;Website (engl., Hauptform)
-muffig;stinkend;übel riechend;muchtig (ugs., regional);miefig;mephitisch (geh., bildungssprachlich, selten, veraltet);moderig;modrig;unangenehm riechen(d);übelriechend
-(eine) Mahlzeit zu sich nehmen;essen;dinieren (geh.);zu Tisch sein (Arbeitswelt);speisen;tafeln (geh.)
-SED (Abkürzung);Sozialistische Einheitspartei Deutschlands
-blöken (Rind);muh machen (ugs., Kindersprache);muhen (Hauptform);brüllen (Rind)
-gefällig;klangschön (Hauptform);sonor;wohlklingend;klangvoll;melismisch (geh.)
-Zoo;Tiergarten;Tierpark;Zoologischer Garten (fachspr.)
-Struma (fachspr.);Schilddrüsenvergrößerung (Hauptform);Satthals (veraltet);Kropf (ugs.);vergrößerte Schilddrüse
-Kräcker;Keks
-Block;Schreibblock (Bindung oben);Notizblock
-Dampf;Schwaden
-absolutes Recht;uneingeschränktes Recht
-gebührend;genügend;(es) reicht;ausreichend;genug;sattsam;satt (nachgestellt) (ugs.);über Mangel an (etwas) kann sich niemand beklagen (floskelhaft, variabel);hinlänglich;zur Genüge;in Maßen;reichlich (ugs.);hinreichend;(und das) nicht zu knapp (ugs.)
-Lückenlosigkeit;Vollständigkeit;Vollzähligkeit
-Wimperntusche;Wimpernbetonung;Mascara;Wimpernfärbung
-Keuchhusten;Stickhusten (ugs.);Pertussis (fachspr.)
-Maistock;Laternenblume (ugs.);Mönchsblume (ugs.);Löwenzahn (ugs., Hauptform);Taraxacum sect. Ruderalia (fachspr., botanisch, griechisch, lat.);Butterblume;Milchstock (ugs.);Taraxacum officinale (fachspr., botanisch, griechisch, lat., veraltet);Hundeblume;Kettenkraut (ugs.);Wiesenlattich (ugs.);Kuhblume;Rahmstock;Gewöhnlicher Löwenzahn (fachspr., botanisch);Saublume (schweiz.);Schmalzbleaml (ugs.);Pusteblume (ugs.);Butterstecker
-Wärmetauscher;Rückkühler
-Angewohnheit;Gewohnheit;Gepflogenheit
-Aktivierung;In-Kraft-Treten;Anbruch;Beginn
-Source (engl.);Kode;Quellcode;Code;Sourcecode (engl.);Quelltext;Programmcode
-hysterisch;aufgelöst;durchgedreht
-Absetzung;Erniedrigung
-lossprechen (von);für unschuldig befinden;für unschuldig erklären;freisprechen;von jeder Schuld freisprechen
-Lichtstreif;Lichtstrahl;Schein;Lichtschein;Strahl
-folgenderweise;wie folgt;folgendermaßen
-Ausgabe (Druckwerk);Version;Interpretation (Kunst);Fassung
-Scheit;Holzscheiter (veraltet);Holzscheit
-Vergnügen;Wonne;Entzücken
-Thanatologe;Sterbensforscher
-Siebenbürgen;Transsylvanien;Transsilvanien;Siweberjen (siebenbürgisch-sächsisch);Transsilvania (lat.);Transilvania (rumänisch);Ardeal (rumänisch);Erdély (ungarisch)
-folgsam;fügsam;lieb (Kindersprache);fromm (Pferd) (veraltend);artig;brav;gehorsam;brav wie ein Lamm (ugs., variabel);konditioniert;gefügig
-St. Martialis-Feuer;Ignis sacer (lat.);Antonius-Plage;Kriebelkrankheit;Sankt-Antonius-Rache;Mutterkornvergiftung;Ergotismus (fachspr., lat.);Antoniusfeuer
-Bilanzaufstellung;Bilanz;Jahresabschluss;Ergebnis;Erfolg
-eine Vorliebe haben für;gerne mögen;(eine) Schwäche haben (für) (ugs., fig.);abfahren auf (ugs.);liken (ugs., engl.);ich lobe mir (geh.);mögen;(sich) loben (geh.);(etwas) für gut befinden;(ganz) begeistert sein (von);(jemandem) belieben;(sich) begeistern (für);stehen auf (ugs.)
-O. K. (ugs.);alles paletti! (ugs.);genehmigt!;ist gut! (ugs.);o. k. (ugs.);so machen wir's! (ugs.);da sage ich nicht nein;schön (ugs.);d'accord (ugs., franz.);machen wir!;(geht) in Ordnung;so machen wir das! (ugs.);alles klar! (ugs.);ich nehme dich beim Wort!;ist recht! (ugs., regional);dein Wille geschehe (biblisch, veraltet, auch ironisch) (geh.);(ist) gebongt! (ugs.);einverstanden (Hauptform);Stattgegeben! (fachspr., juristisch);okey-dokey (ugs.);(ist) gemacht! (ugs.);es sei! (geh., veraltet);warum nicht?! (ugs.);abgemacht;akzeptiert;geht klar (ugs.);schon überredet! (ugs.);gut (ugs.);roger! (ugs., engl., selten);(ist) okay (ugs.);es geschehe (mir) nach deinen Worten (biblisch, veraltet, auch ironisch) (geh.);so sei es! (geh., veraltet);das ist ein Wort! (ugs.)
-Holzproduktion;Waldwirtschaft;Waldbau;Holzerzeugung;Forstwirtschaft;Forstwesen
-Jausenbrot (österr.);Vesper;Häppchen;Gabelfrühstück;Happen (ugs.);Jause (österr.);Pausenbrot;Unternessen (österr.);Brotzeit (ugs., süddt.);Lunchpaket;Marende (regional);Fingerfood (engl.);Bissen (ugs.);Imbiss (Hauptform);Znüni (schweiz.);Snack (engl.);Gabelbissen;Imbs (regional);Zwischendurch-Mahlzeit;Stärkung (ugs.);leichte Mahlzeit;Zwischenmahlzeit;kleine Stärkung;Zvieri (schweiz.);Neinerln (österr.)
-automatisch schließend;selbstschließend
-Erprobung;Prüfung;Versuch;Probe;Test
-(sich) vermehren wie die Karnickel (ugs., abwertend);Kinder haben;vermehren;(sich) reproduzieren (fachspr., biologisch);Kinder kriegen (ugs.);(sich) vermehren;Junge haben;Kinder in die Welt setzen;zur Arterhaltung beitragen (biologisch);(sich) fortpflanzen
-Marktgeschehen;Marktlage
-peng machen (ugs.);knallen;zerplatzen
-Wassergraben;Flüsschen;Bach
-billigen;akzeptieren;gutheißen;goutieren
-Kapelle;Formation;Band;Musikgruppe;Musikkapelle;Combo;Ensemble;Gruppe
-Pastell;Pastellton
-Mus;breiige Masse;Brei;Creme;Pudding;Pampe (derb)
-Allergiestoff;Allergen (fachspr.)
-Kette;Kettenfäden
-Maskulinisierung;Virilisierung (fachspr.);Virilismus (fachspr.);Vermännlichung
-Bank;Sitzbank
-Entzündung der Gelenkinnenhaut;Synovialitis (fachspr.)
-Stelle des schärfsten Sehens im Auge;gelber Fleck;Makula (fachspr.)
-Gefangenenwärter;Kerkermeister;Wärter;Gefängniswärter;Justizvollzugsbeamter (fachspr.);Schließer
-laut Vorschrift;laut Satzung;vorschriftsmäßig
-wieder aufnehmen;wieder aufgreifen
-Unzweifelhaftigkeit;Sicherheit;Klarheit;Zuverlässigkeit;Gewissheit
-vorurteilsfrei;realistisch;aufgeklärt
-Trosse;Reep (marit.) (fachspr.);Haltetau;Strick;Seil;Tau
-Wurzel;Radix;Basiszahl
-den Rand betreffend;marginal (fachspr.);am Rand liegend;am Rand befindlich
-Ursprung;Geburt;Provenienz;Abkunft (geh.);Elternhaus;Wurzeln (ugs.);Herkunft;Herkommen;Abstammung
-wandeln (geh.);schlendern;spazieren (Hauptform);(einen) Bummel machen;(sich) ergehen (geh., veraltet);spazieren gehen;herumspazieren;dahintändeln (geh.);promenieren (geh., bildungssprachlich, französierend);an die frische Luft gehen;sich die Füße vertreten;(einen) Spaziergang machen;flanieren;umhertigern (ugs.);herumschlendern;(einen) Stadtbummel machen;frische Luft schnappen;sich die Beine vertreten;umherbummeln;lustwandeln (geh.)
-Betriebsstunden;Betriebszeit;Betriebsdauer
-zersetzen;aufteilen;zersplittern;fragmentieren;zergliedern;spalten;tranchieren;trennen;pulverisieren;atomisieren;abwracken;zertrennen;untertrennen;zerspalten;auftrennen;teilen;partagieren;unterteilen;zerteilen;aufspalten;auflösen
-zu Händen;z. Hd.;für
-Eiterung;Suppuration (fachspr.)
-Encephalitis (fachspr.);Gehirnentzündung;Enzephalitis (fachspr.)
-Warenzeichen (fachspr., juristisch);Schutzmarke (fachspr., juristisch);Brand (fachspr., engl.);Markenname;Marke (Hauptform)
-im Innern;im Bereich;inmitten;innerhalb;inwendig
-Wurzeln schlagen (ugs., fig., ironisch);verbleiben;Zeit verbringen;verweilen;(sich) aufhalten;bleiben;weilen (geh.);herumstehen
-Schweinebuchte;Schweinestall
-(sich) decken;konsistent (sein);koinzidieren (fachspr.);übereinstimmen;zusammenfallen;zusammen auftreten;zusammentreffen
-fertig backen;zu Ende backen;ausbacken;aufbacken (fachspr.);durchbacken
-Anbindung;Brücke (fig.);Verbindung;Bindung;Bündnis
-Haftvermögen;Haftung;Haftkapital
-Enthaltung;Stimmenthaltung
-beachten;merken;bemerken
-nicht vergessen;bedenken;(etwas) im Hinterkopf behalten (ugs.);(sich etwas) bewusst halten;(sich) etwas merken;an etwas denken
-Lehrstelle;Ausbildungsplatz
-absäbeln (ugs.);abscheren;wegschneiden;abschneiden;abtrennen;heruntersäbeln (ugs.);kappen;abrasieren;abschnippeln (ugs.)
-Berufung (auf);Heranziehung
-(jemanden) ansprechen (in einer Sache);kontakten;vorstellig werden (bei);in Kontakt treten (mit);kontaktieren (Hauptform);(sich) in Verbindung setzen mit;(das) Wort richten (an);herantreten (an);(den) Kontakt suchen (mit);(sich) wenden (an);(sich) richten (an);Kontakt aufnehmen (mit)
-Schriftwechsel;Briefwechsel;Schriftverkehr;Korrespondenz
-(ein) Streitthema (sein);kontrovers diskutiert werden;Darüber streiten sich die Geister. (ugs., Spruch);nicht unumstritten;polarisierend;angefochten werden;dünnes Eis (fig.);kontroversiell (österr.);(etwas) über das man sich uneinig ist;kontrovers;streitig (fachspr., juristisch);nicht ausdiskutiert;strittig;spalten(d);umkämpft (fig.);umstritten (Hauptform);zur Debatte stehen(d);in Frage stehen(d);Darüber streiten sich die Gelehrten. (ugs., Spruch)
-Christlich Soziale Union;Konservative (ugs.);CSU (Abkürzung);Schwarze (ugs.)
-lausen;entlausen
-Jejunum (fachspr.);Teil des Dünndarms;Leerdarm
-Kisuaheli;Suaheli;Kiswahili;Swahili
-in der Breite;detailgenau;umfänglich;umfassend;gründlich;en détail (franz.);in aller Ausführlichkeit;ausführlich;ins Einzelne gehend;in seiner ganzen Breite;umfangreich;haarklein;in allen Einzelheiten;eingehend;ausgiebig;detailliert;differenziert;erschöpfend;im Detail;ausgedehnt;in allen Details
-winzig;von geringem Umfang;mickerig (ugs.);mickrig (ugs.);wunzig;kleinwinzig (ugs.);überschaubar (ironisch);gering;lächerlich klein;ganz klein (Hauptform);kleinwunzig (ugs.)
-TK25;Messtischblatt;topografische Karte;Generalstabskarte
-In diesem Sinne - ab in die Rinne! (ugs.);Zum Wohl!;Na denn Prost! (ugs., auch ironisch);Auf ...!;Prosit! (ugs.);Nich lang schnacken, Kopp in'n Nacken! (ugs., norddeutsch);Runter damit! (ugs.);Wohl bekomm's!;Prost! (Hauptform);Kippis! (ugs., finnisch);Prösterchen! (ugs.);Stößchen! (ugs., regional);Hoch die Tassen! (ugs.);Wohlsein! (ugs.)
-Kollation;Vergleich;Kollationieren
-Käseblättchen (ugs., abwertend);Käseblatt (ugs., abwertend);Blatt;Blättchen (ugs.);Journal (franz.);Schmierblatt (derb, stark abwertend);Zeitung (Hauptform);Gazette (franz.);Revolverblatt (ugs., abwertend);Postille (geh., ironisch);Heft
-Myelosuppression (fachspr.);Knochenmarkshemmung
-Seuche;Geißel der Menschheit (geh., fig., literarisch);Gottesgeißel (geh., veraltet);Massenepidemie;Massenerkrankung;Pestilenz (geh., fig.);(eine) Pest (derb, fig.);Epidemie;Plage
-neuartig;zeitgemäß;fortschrittlich;zeitgerecht;neuzeitlich;modern;neoterisch (geh.);von heute;auf der Höhe der Zeit (ugs.);neumodisch (leicht abwertend);topaktuell (werbesprachlich);neu;aktuell;up to date (engl.);heutig;à jour (franz.);in unsere Zeit passend;auf dem neuesten Stand
-loslegen;an etwas gehen (ugs.);(sich) daranmachen (zu);(etwas) anpacken (ugs.);starten;(sich) dransetzen (ugs.);durchstarten (ugs.);(eine Sache) angehen;(etwas) angreifen (geh., fig.);einleiten;darangehen zu;herangehen an (fig.);in Angriff nehmen (fig.);(eine Aktion) anlaufen lassen;zur Tat schreiten (geh., scherzhaft-ironisch);beginnen;(etwas) antreten;(etwas) zum Fliegen bringen (fig.);(eine Sache/mit einer Sache) anfangen (Hauptform);(den) Startschuss geben (fig.);(in etwas) einsteigen (ugs.);(etwas) aufnehmen
-Chromium;Chrom;Cr (Elementsymbol)
-Netz;Netzwerk
-lebendig;lebend;unter den Lebenden;untot;mit warmen Händen (ugs.)
-Geschwür;Ulcus (fachspr., medizinisch);Ulzera (fachspr., Plural);Ulcera (fachspr., Plural, medizinisch);Ulkus (fachspr.)
-bloß;unverhüllt;nackt;offen;kahl;blank
-Wohltäter der Menschheit;Philanthrop;Menschenfreund;Heilsbringer (ugs.);Wohltäter
-Bitrate;Datenübertragungsrate;Verbindungsgeschwindigkeit (ugs.);Datenübermittlungsrate;Datenrate;Datentransferrate;Übertragungsgeschwindigkeit (ugs.)
-lokal;hier in der Ecke (ugs.);regional;hier in der Gegend (ugs.);vor Ort;hier am Ort;hier anzutreffen;hiesig
-Zeitdieb;Zeitverschwender;Zeitvergeuder
-ernst zu nehmen;annehmbar;glaubwürdig (Hauptform);erwartbar;glaubhaft;denkbar;vermutbar
-Senkel;Schuhriemen (ugs., regional);Schnürsenkel (ugs., mitteldeutsch, norddeutsch);Schnürband (ugs., norddeutsch);Schuhband;Riemen (ugs.);Schnürriemen;Schuhbandel (ugs., bayr., österr.)
-wachstumshemmend;wachstumsverzögernd
-Gynoid(e) (weibl.);Maschinenwesen;menschenähnlicher Roboter;Android;(eine) Menschmaschine (geh.);humanoider Roboter;Androide;Androidin (weibl.);Maschinenmensch
-Jammern;Gejammer (ugs.);Geheule;Geflenne (ugs.);weinerliches Gebaren;Geheul;Gejammere (ugs.)
-Dornenstrauch;Brombeerstrauch
-Thermodynamik;Wärmelehre
-dafür sein;(sich) engagieren (für);befürworten;eintreten (für);unterstützen;empfehlen;sekundieren;(sich) aussprechen für;anpreisen;Schützenhilfe leisten;(sich) aus dem Fenster hängen (für) (fig.);(sich) einsetzen (für);(ein) gutes Wort einlegen (für)
-Kriminalpolizei;Kripo (ugs.)
-Saum;Naht
-Dorndreher;Neuntöter;Lanius collurio (fachspr., lat.);Rotrückenwürger
-vorbestellen;blocken (Jargon);disponieren (fachspr., kaufmännisch);buchen;reservieren (lassen);vormerken (lassen);bestellen;(sich) freihalten lassen
-Betttuch;Leintuch (österr.);Bettlaken
-Dekantieren;Dekantation;vorsichtiges Abgießen (von Wein, Wasser)
-(mit etwas) an die Presse gehen;kund und zu wissen tun (geh., scherzhaft, veraltet);publikmachen;kund und zu wissen geben (geh., scherzhaft, veraltet);(der) (sensationsgierigen) Öffentlichkeit zum Fraß vorwerfen (ugs., fig.);öffentlich machen;kundtun (geh.);verlautbaren (geh.);(mit etwas) an die Öffentlichkeit gehen;ins Rampenlicht der Öffentlichkeit zerren;vermelden (geh.);(sich) öffentlich verbreiten (über);publik machen;unter die Leute bringen (ugs.);vor aller Augen ausbreiten (fig.)
-entwerfen;planen
-intestinal (fachspr.);Darm...
-überwältigend;Ehrfurcht gebietend;eindrücklich;grandios;großartig;wie ein junger Gott (etwas tun) (ugs., Kunst);formidabel;imposant;es in sich haben (Sache);(der/die/das) sich gewaschen hat (ugs., fig.);glorios;ehrfurchtgebietend;nicht von Pappe sein (ugs., Sache);erstaunlich;nicht ohne sein (ugs.);bemerkenswert;Beachtung verdienen(d);eindrucksvoll;(der/die/das) nicht von schlechten Eltern ist (ugs., sprichwörtlich);achtunggebietend;beeindruckend (Hauptform)
-Betonieren;Betoneinbringung
-Fratze;Faxen;Grimasse
-ausblenden;achtlos vorbeigehen an;nicht berücksichtigen;links liegen lassen (ugs.);nicht in seine Überlegungen einbeziehen;etwas an sich abperlen lassen (sprichwörtlich);einfach nicht zuhören (ugs.);(sich) nicht scheren um (veraltend);auf d(ies)em Ohr ist er taub (ugs., Spruch, fig.);nichts hören wollen (von);ignorieren (Hauptform);außen vor lassen;(sich) nicht interessieren (für);außer Betracht lassen;nicht beachten;in den Wind schlagen (ugs.);nichts wissen wollen (von);beiseite lassen (ugs.);(sich) nicht kümmern um;nicht in Betracht ziehen;(sich) taub stellen;unberücksichtigt lassen;außer Acht lassen;(sich) nicht kehren an (Dat.) (geh., fig.)
-Reise;Fahrt;Expedition;Exkursion;Lehrausflug;Erkundung;Lehrfahrt
-Warenumschlag;Umschlag
-Strolch;Hallodri (ugs., bayr., österr.);Nichtsnutz (veraltend);Tunichtgut (veraltet);Taugenichts (veraltet);Tagedieb
-Schlaffheit;Schwäche;Laschheit;Atonie (fachspr.)
-Vorrat;Vorräte;Proviant;Lebensmittelvorräte
-ablaufinvariant;eintrittsinvariant
-Verdächtigung;Anschuldigung;Anwurf;Vorhaltung;Unterstellung;Schuldzuweisung;Bezichtigung;Beschuldigung;Vorwurf;Belastung (geh., juristisch)
-entzündet;wund;schlimm (ugs., regional);vereitert
-Vereinbarung;Deklaration;Festlegung
-piesacken (ugs.);ärgern (ugs.);plagen;zwicken und zwacken (fig.);quälen;sticheln;triezen (ugs.);(jemandem) zusetzen;necken;zu schaffen machen;aufziehen (ugs.);traktieren;auf die Schippe nehmen (ugs.);uzen (ugs.);utzen (ugs.);hänseln;vexieren (geh., veraltet)
-vermerken;niederschreiben;protokollieren;anmerken;notieren
-(auf etwas) drängen;(auf etwas) pochen (ugs.);(sich auf etwas) kaprizieren;(sich auf etwas) versteifen;fordern;(etwas) einfordern (Hauptform);(auf etwas) insistieren;(auf etwas) beharren (Hauptform);postulieren (geh., bildungssprachlich);(jemandem etwas) abverlangen;(etwas) reklamieren;bei der Forderung bleiben;(auf etwas) dringen;(sich etwas) ausbedingen;(kategorisch) verlangen;(auf etwas) bestehen
-Sankt Petersburg;Petrograd (veraltet);Piter (ugs.);Venedig des Nordens (ugs.);St. Petersburg;Paris des Ostens (ugs.);Sankt-Peterburg;Leningrad (veraltet);Paterburg (literarisch);Sankt-Pieterburch (veraltet);Petropol (literarisch)
-Zusammenbau;Aufrichtung
-trocken;dröge;nüchtern;phantasielos;amusisch;fantasielos;uninspiriert;prosaisch;dürftig
-in ... liegen;innewohnen
-Kinnbacken...;Kinnladen...
-Kippschalter;Umschalter;Wechselschalter;Kreuzschalter
-Aufforstung;Bewaldung
-ehrwürdig;sakral;heilig
-ohne Regressanspruch;ohne Obligo;ohne Verbindlichkeit;außer Obligo (österr.)
-Dauerregen;ergiebiger Regen;Landregen;ausgiebiger Regen;anhaltende Regenfälle
-Standort;Sitz;Aufstellungsort
-quer durch;hinüber;herüber;nach drüben;nüber (ugs.)
-absorptionsfähig;aufnahmefähig;empfänglich
-Konsole;Halter
-(jemanden) bewirten;(jemanden) versorgen;(jemandem) aufwarten (mit);(jemandes) Gastgeber sein
-mit Bodenhaftung (fig.);erdverbunden (geh.);bodenständig (Hauptform);auf dem Boden der Wirklichkeit;geerdet;(ein Star etc.) zum Anfassen (fig.);auf dem Boden der Tatsachen;mit beiden Beinen auf der Erde stehen(d);realitätsbewusst;ohne Allüren;mit beiden Beinen im Leben stehen(d);ungekünstelt;unkompliziert;gefestigt;mit beiden Füßen (fest) auf dem Boden stehen(d) (fig.);pragmatisch;ganz natürlich
-Präzisionsschütze;Heckenschütze (abwertend);Sniper (ugs., engl.);Scharfschütze (Hauptform)
-(seinen) Nutzen ziehen (aus);ausschlachten;ausnützen;Honig saugen (aus) (geh., fig.);nutzen;(aus etwas) Kapital schlagen (fig.);ausnutzen;ausbeuten;instrumentalisieren;Kapital schlagen (aus);(etwas) ausschlachten (fig.);(für seine Zwecke) zu nutzen verstehen;(für seine Zwecke) nutzen;für sich nutzen;(sich etwas) zu Nutze machen;Gebrauch machen (von);für seine Zwecke nutzen;(sich etwas) zunutze machen;Vorteil ziehen (aus)
-voll (ugs.);gesättigt;satt
-färbig (südtirolerisch, österr.);farbenfroh;farbig;panaschiert (fachspr., botanisch);gefärbt;buntfarbig;mehrfarbig;bunt;verschiedenfarbig
-Schattenkabinett;Oppositionskabinett
-unbegrenzt;unstillbar
-Suchspiegel;Werkstattspiegel
-Glättwerk;Kalander
-Börsenindex;Aktienindex
-Penne (ugs.);Lernanstalt (veraltet);Schule (Hauptform)
-Anlass;Schuld;Ursache;Grund
-gellend;schrill;sehr laut;markerschütternd;grell;kreischend;gell (geh., literarisch, selten);durchdringend;ohrenbetäubend;spitz (Schrei);ohrenzerreißend (fig.)
-Verzeichnis lieferbarer Bücher;Backlist
-verlinken;mit etwas assoziiert werden;mit einer Sache in Verbindung gebracht werden
-unbekümmert;unbesorgt;sorgenfrei;sorglos;sorgenlos
-Arbeitsverteilung;Arbeitszuteilung
-Elan (franz.);Lebenskraft;Schwung;Temperament;Kraft;Vitalität;Beschwingtheit
-schunkeln;kippen;schaukeln;wippen;rollen (Schiff);schwenken;schwanken;kippeln;stampfen (Schiff)
-schaffbar;gangbar;drin (ugs.);erreichbar (Hauptform);in greifbare Nähe rücken;viabel (geh., akademisch, selten);ausführbar;möglich;lösbar (ugs.);machbar;zu machen;zu schaffen;erfolgswahrscheinlich (geh.);denkbar;realisierbar;durchführbar;leistbar
-scheuern;reiben;schubben (mittelniederdt.) (ugs.);schubbern (ugs., norddeutsch)
-Arbeitslosenziffer;Arbeitslosenzahl
-Papierdeutsch;Behördensprache;Kanzleideutsch;Verwaltungssprache;Amtsdeutsch (ugs.);Bürokratendeutsch (ugs.);Beamtendeutsch (ugs.);Verwaltungsdeutsch;Kanzleistil
-(politische) Hetze;Agitation
-Waschpulver;Waschmittel
-Abstract (fachspr., engl.);Kurzzusammenfassung;Exzerpt (fachspr.);Digest (engl.);Breviarium (geh., lat., veraltet);Ausschnitt;Klappentext;Konspekt (fachspr., lat.);Abrégé (geh., franz.);Epitome (fachspr., griechisch);Inhaltsangabe;Inhaltsübersicht;Abriss (eines Buches);Kurzreferat (fachspr.);Auszug;Zusammenfassung
-Steuerveranschlagung;Besteuerung
-Trendsetter;Avantgardist;Pionier;Wegbereiter;Vorkämpfer;Lokomotive (ugs.);Vorreiter;Schrittmacher
-Rettung;Bergung
-n. u. Z. (Abkürzung);unserer Zeitrechnung;nach Christi;nach Christus;post Christum natum (lat.);nach der Zeitenwende;post Christum (lat.);u. Z. (Abkürzung);n. Chr. (Abkürzung);p. Chr. n. (Abkürzung);p. Chr. (Abkürzung);Anno Domini (lat.);A. D. (Abkürzung);nach Christi Geburt
-adstringierend;zusammenziehend
-picklig;pickelig
-Gebärmutterhals;Cervix uteri (fachspr.)
-grenzen;anstoßen;angrenzen;adjazieren
-Miauen;Maunzen;Miau
-den Damm betreffend;perineal (fachspr.)
-binden;winden;flechten
-anmelden (Universität);immatrikulieren;inskribieren (veraltet, österr.);einschreiben
-Tätigkeitsbereich;Tätigkeitsgebiet;Arbeitsfeld;Ressort;Aufgabengebiet;Aufgabenkreis;Aufgabenbereich;Tätigkeitsfeld;Arbeitsbereich;Geschäftsbereich
-Umriss;Profil;Kontur;Umrisslinie;Silhouette
-Python;Pythonschlange
-Bewölkung;Wolken
-Versteck;Schlupfwinkel (Hauptform);Unterschlupf;geheimes Lager;Unterstand
-nördlich;Nord...
-übertragen;transferieren;veräußern
-Spiralfeder;Schraubenfeder
-anhängen;anfügen;befestigen;festhängen;festhaften;stecken
-Pfarrhaus;Pfarrei
-Buchführungssystem;Buchhaltungssystem
-Grund reinkriegen (ugs.);ausmisten (ugs.);ausmüllen (ugs.);entrümpeln;Grund reinbekommen (ugs.);(eine) Grundreinigung machen
-nicht ins Gewicht fallend;unmaßgeblich;unter "ferner liefen" (kommen) (ugs.);vernachlässigbar;unbedeutend;Deine Sorgen möchte ich haben! (ugs., Spruch);nicht wichtig;kleiner;zu vernachlässigen;nicht ernst zu nehmen;(mit etwas) hat es nicht viel auf sich;nicht entscheidend;uninteressant;nicht (weiter) der Rede wert;Bagatell...;kannste vergessen (ugs.);ohne Belang;bedeutungslos;weniger wichtig;unerheblich;nebensächlich;unwesentlich;unbeträchtlich;nichtssagend;unwichtig (Hauptform);Rand...;Nebensache;irrelevant;kleiner Fisch (ugs., fig.);zweitrangig;peripher;nicht von Interesse;von untergeordneter Bedeutung;Neben...;sekundär;belanglos;marginal
-Taggeld;Tagegeld;Tagelohn
-(sich) den Kopf zerbrechen (fig.);brüten (über);(sich) das Hirn zermartern;grübeln;(angestrengt) nachdenken
-Einschluss;Einfügung;Inklusion;Einschub
-Rettich;Radi (bayr., österr.)
-Kolbenhemd;Kolbenschaft
-kieselhaltig;kiesig;mit Kieseln bedeckt;kieselig
-unglückselig;bedauerlich;unglücklich
-Kehrbesen;Straßenbesen;Auskehrer;Saalbesen;Besen (Hauptform)
-Brüstung;Brustwehr;Parapet (franz.)
-hitzig (ugs.);voller Leidenschaft;mit Verzückung;heißblütig;frenetisch (geh.);feurig;leidenschaftlich;ungestüm;temperamentvoll;emotional erregt
-DEM (fachspr., Abkürzung);D-Mark (Hauptform);Deutsche Mark;Mark (ugs.);DM (Abkürzung);Deutschmark
-vorheizen;vorwärmen
-Kundendienst;Kundenservice;Kundenbetreuung
-Gelbe Seiten;Branchenverzeichnis
-Verfahren;Betriebsart;Modus;Betriebsmodus;Art
-Gemälde;Bild
-Hütte;Hüttenwerk;Eisenhütte;Eisenwerk
-Superposition (fachspr.);Wechselwirkung;Superpositionierung (fachspr.);Überlagerung
-aufwärts;bergan;ansteigend;sich erhebend;bergauf;aufsteigend
-requirieren (militärisch);einziehen;beschlagnahmen (Hauptform);sichern;sicherstellen;konfiszieren;(etwas) aus dem Verkehr ziehen
-Beredsamkeit;Zungenfertigkeit;Redegewandtheit;Sprachgewalt;Wortgewandtheit;Eloquenz;Sprachfertigkeit;Gabe der Rede;Sprachgewandtheit
-Zinken (ugs.);große Nase
-Sorghum;Hirse
-Perigäum (fachspr.);Erdnähe
-Faschingsdienstag;Fastnachtsdienstag
-Schwarzdrossel;Amsel
-Arbeitskampf;Arbeitsausstand;Streik;Arbeitsniederlegung;Arbeitseinstellung;Ausstand
-kommunal;städtisch;gemeindlich
-zickzackgefaltet;leporellogefaltet
-Antibiotikatherapie (fachspr.);Antibiose (fachspr.)
-computergestützt;rechnerunterstützt
-kritisieren;Position beziehen gegen;(sich) wenig aufgeschlossen zeigen (für) (verhüllend);verurteilen;Anstoß nehmen (an) (ugs.);nein sagen zu;(einer Sache) ablehnend gegenüberstehen;(einer Sache) ablehnend gegenüber stehen;(sich) ablehnend äußern;nicht für richtig halten;abrücken von;wenig Verständnis haben (für) (variabel);die Zustimmung versagen (variabel);ablehnen (Hauptform);gegen etwas sein;wenig schmeichelhafte Worte finden (zu / über) (geh., verhüllend);dagegen sein;Stellung beziehen gegen;missbilligen;(sich) stören an;mit Verachtung strafen
-Nachbereitung;Nachbearbeitung
-nachlassen;kleiner werden;(sich) legen;geringer werden;verblassen;verringern
-grünes Licht geben (ugs.);(einer Sache) seine Zustimmung erteilen;billigen;genehmigen;verabschieden (fachspr.);(die) Erlaubnis erteilen;(die) Zustimmung geben;absegnen;(sein) Placet geben (geh.);(seinen) Segen geben;(sein) Okay geben (ugs.);erlauben;in Kraft setzen;(sein) Plazet geben (geh.);einwilligen;zustimmen;abnicken (ugs.)
-an Heftigkeit gewinnen;heftiger werden;aufwallen;auflodern;aufflackern;aufbranden
-schwere Frage;harte Nuss (ugs., fig.)
-durchtränkt werden;(sich) voll saugen
-stöhnen;ächzen;seufzen
-posieren;posen (ugs.)
-wohlgesinnt;wohlsinnig (schweiz.);hold (geh., veraltend);wohlwollend;geneigt (geh.);gewogen (geh.);zugetan (geh.);affektioniert (geh., franz., lat.);gutgesinnt;wohlgesonnen (ugs.);wohlmeinend (geh.);gütig;verständnisvoll
-Rechtsbehelf;Rechtsmittel (schweiz., österr.);Abhilfe (juristisch)
-Vieldeutigkeit;Doppeldeutigkeit;Mehrdeutigkeit;Zweideutigkeit;Amphibolie (geh.);Ambiguität;Janusköpfigkeit;Homonymie (fachspr.)
-Geschütze;Artillerie
-Spur;Fußspur
-entmutigen (Hauptform);abschrecken;(den) Wind aus den Segeln nehmen;den Schneid nehmen (ugs.);einschüchtern;demoralisieren;ins Bockshorn jagen (ugs.);decouragieren (geh.);demotivieren;den Schneid abkaufen (ugs.)
-Maskenkostüm;Kostüm
-Gastgeber;Herr des Hauses;Hausherr
-Planwert;Sollwert;Zielmarke (fig.);Zielgröße;Zielwert;Plansumme;Richtsumme
-Bimetallstreifen;Thermobimetall;Bimetall
-Promiskuität;häufiger Partnerwechsel;Geschlechtsverkehr mit häufig wechselnden Partnern;Promiskuitivität;promiskuitive Lebensweise
-Menüeintrag;Menüpunkt
-Abgeltung (schweiz., österr.);Entgelt;Bezüge;Bezahlung;Kostenerstattung;Arbeitsentgelt;Gehalt;Honorar;Aufwandsentschädigung (Ehrenamtler);Verdienst;Lohn;Einkünfte;Vergütung;Entlohnung;Gage;Entlöhnung (schweiz.);Salär (schweiz.);Besoldung (Beamte, Richter);Löhnung;Heuer;Einkommen (Hauptform);Salair;Sold (Soldaten, Zöllner);Tantieme;Gratifikation
-Emission;Aktienausgabe;Effektenemission
-überragend;ausgezeichnet;außerordentlich;vorzüglich;höchstrangig;schnafte (ugs., berlinerisch, veraltet);I a ("eins a") (ugs.);trefflich;außergewöhnlich;splendid;besonders;exzeptionell;eins a (ugs.);vortrefflich;herausragend;bestens
-männlich;viril (fachspr.);maskulin
-Sonnwendfeier;Feier der Sonnenwende;Sonnenwendfeier
-Eierkopp (ugs., norddeutsch);Tepp (ugs.);geistiger Tiefflieger (ugs.);Löli (Lööli, Lööl, Löu) (ugs., schweiz.);Kretin (geh., franz.);Dummbart(el) (ugs.);Armer im Geiste (bibl.) (geh.);Knallidiot (ugs.);Schwachmat (ugs.);Pfeifenwichs(er) (vulg.);Döskopp (ugs., norddeutsch);Idiot (derb);Volltrottel (derb);Hein Blöd (ugs., regional);(eine) geistige Null (ugs.);Trottel (ugs.);en Beschmierten (ugs., ruhrdt.);Strohkopf (ugs.);Klappspaten (ugs.);Holzkopf (ugs.);Hohlkopf (ugs.);Tuppe (ugs., kärntnerisch);Dolm (ugs., österr.);Flachwichser (vulg.);Esel (ugs.);Honk (ugs.);Heini (ugs., veraltet);Dödel (derb);Sacklpicker (ugs., österr.);Vollpfosten (ugs.);Dämlack;Denkzwerg (ugs.);Narr (geh.);Dummrian (ugs.);Vollidiot (derb);Einfaltspinsel (ugs.);Hohlfigur (ugs.);Niete (ugs., fig.);Blödel (ugs.);Vollhorst (ugs.);Spasti (derb);Flachpfeife (ugs.);Pappnase (ugs.);Hornochse (ugs.);armer Irrer (ugs.);Dackel (ugs., abwertend, schwäbisch);Lapp (derb, österr.);Schwachkopf (ugs.);Eiernacken (ugs.);Dummerjan (veraltet);trübe Tasse (ugs.);Dumpfbatz (derb);dämlicher Hund (ugs., veraltend);Knallcharge (geh.);Blödi (ugs.);Blödmann (ugs.);Knallkopf (ugs.);Flitzpiepe (ugs., abwertend);('ne) hohle Nuss (ugs.);Torfkopf (ugs.);Bekloppter (ugs.);Tölpel;Stoffel (ugs.);Horst (ugs.);Napfsülze (ugs.);Zipfelklatscher (ugs., süddt.);Pannemann (ugs.);Hirni (ugs.);Blödian (ugs.);Rindvieh (ugs.);Armleuchter (ugs.);Halbgescheiter;Gonzo (abwertend);Hohlbirne (ugs.);dumme Nuss (ugs.);Halbdackel (derb, schwäbisch, stark abwertend);Torfnase (ugs., ostfriesisch);Dummkopf (Hauptform);Dulli (ugs.);Dussel (ugs.);keine Leuchte (ugs.);Dösbaddel (ugs., norddeutsch);Dämel (ugs., regional);Minderbemittelter;Todel (ugs., österr.);Spast (ugs., jugendsprachlich);Vollspast (derb);Spatzenhirn (ugs.);taube Nuss (ugs.);Nullchecker (ugs., jugendsprachlich);Blitzbirne (ugs., ironisch);Volldepp (ugs.);Dumpfbacke (ugs.);Piesepampel (ugs.);dummes Schaf (ugs.);Spacko (ugs.);Schnellmerker (ugs., ironisch);Spaten (ugs.);Depp (ugs.)
-Schieferplatte;Schiefertafel
-praxisgetestet;erprobt im praktischen Einsatz;praxiserprobt;einsatzerprobt
-Läufer;oberer Mühlstein
-geschmacklos;billig;fade;heruntergekommen
-Soziussitz;Rücksitz (Motorrad)
-theatralisch;gestelzt;gewunden;gedrechselt;preziös (geh.);affektiert (geh.);unnatürlich;geziert;aufgesetzt;geschraubt (ugs.);geschwollen;gespreizt;gekünstelt;überkandidelt;verschwurbelt;unecht;künstlich;schwülstig;artifiziell (geh.);(übertrieben) bildungssprachlich (fachspr.);verquast (abwertend);manieriert
-einen Vorteil haben von;profitieren;Nutzen ziehen aus;Nutzen haben von
-Gerüst;Aufbau;Struktur;Gliederung;Oberbau;Überbau;Architektur
-Endlösung (der Judenfrage) (derb, NS-Jargon, euphemistisch, zynisch);Holocaust;Judenvernichtung;Schoah;Shoah
-Spalte;Riss;Kluft
-Lichtundurchlässigkeit;Undurchsichtigkeit;Opazität
-Übermittlung;Transfer;Übertragung
-Facharzt für Orthopädie;Orthopäde
-Legitimität;Rechtmäßigkeit;Zulässigkeit
-Hrsg. (Abkürzung);Herausgeber
-funktionieren;arbeiten
-Instanz;Exemplar
-gebunden spielen;binden;mit Bindebogen spielen
-Stew;Eintopf;Eintopfgericht
-Schaffensdrang;Diligenz (geh., veraltend);Tüchtigkeit;Energie;Produktivität;Diensteifer;Tatkraft;Tatwille;Arbeitseifer
-Zug;Zugluft;Durchzug;Luftzug
-unmerklich;unbemerkbar;unerkennbar;schleichend (Hauptform);nicht wahrnehmbar;nicht erkennbar
-(sich) aalen;(sich) rekeln;(sich) räkeln
-Wollertrag der Schur;Schur;Scheren
-Slipper (Scheinanglizismus);Schlüpfschuh;Schlüpfer (Hauptform);Schlupfhalbschuh;Penny Loafer (fachspr., Handelsname, engl.);ungeschnürter Halbschuh;Loafer (fachspr., Handelsname);Collegeschuh;Mokassin
-lagern;einbinden (fachspr.);legen;einlagern;einbetten;betten;eingliedern
-Zuschuss;Zuschlag;Zulage;Prämie
-greifen lassen;(einer Sache) Geltung verschaffen;(etwas) etablieren (Hauptform);(etwas) in die Fläche bringen (geh.);durchsetzen;(einer Sache) zum Durchbruch verhelfen
-hepatozellulär (fachspr.);die Leberzellen betreffend
-vermeintlich (Hauptform);auf einem Fehler beruhen(d);irrtümlich für (...) gehalten;fälschlicherweise;irrtümlicherweise;irrtümlich;fälschlich;irrigerweise
-anbieten;andienen;zeigen;bieten
-flirren;flackern;flimmern;blinken
-Streuung;Ausbreitung;Dissemination (fachspr.);Verteilung;Verbreitung
-Laufrad;Lauf;Laufschiene
-als Anlage;beigefügt;anbei;dazugelegt;mitgeliefert;anliegend;beigelegt;beiliegend;(der Sendung) hinzugefügt
-Stand;Kaste;Gruppe;Gesellschaftsschicht;Bevölkerungsschicht;Schicht;Klasse
-(ein) Böser (ugs.);Feindbild;Zielscheibe (fig.);Buhmann (ugs.);Arsch vom Dienst (derb);Sündenbock
-Bestie;Unmensch;Scheusal;Ungeheuer;Monster (ugs.);Satan (fig.);Teufel (fig.);Bestie in Menschengestalt;Bluthund
-Dehnfuge;Bewegungsfuge;Dehnungsfuge;Dilatationsfuge
-Scheingrund;Notlüge;Ausrede (negativ);schlechte Ausrede;Entschuldigung;Ausflucht (negativ);Schutzbehauptung (verhüllend);Vorwand;faule Ausrede (negativ);(unter dem) Deckmantel (des/der ...);Verlegenheitslüge;Beschönigung
-Register zur Ergebnisaufnahme;Datenregister;Akkumulator
-Grenzwert;Schwelle;Schwellenwert;Schwellwert
-Spektakel;Schauspiel
-abspalten;trennen;entnehmen;auslesen (fachspr.);absondern;aussondern;aussortieren;separieren;extrahieren;eliminieren;isolieren;entfernen;aussieben;streichen;ausgliedern;herausnehmen;selektieren;abscheiden
-(sich) einmummeln (ugs.);(sich) zusammenkuscheln
-Immobilienmakler;Grundstücksmakler;Immobilienhändler
-Erwerb;Anschaffung;Aneignung;Kauf;Erwerbung;Investition
-Finitum (geh., selten);Ausgang;Abschluss;Ausklang (fig.);Ende (Hauptform);Schluss
-Abfragen;Abrufen
-im Vorjahr;vergangenes Jahr;letztes Jahr
-(einen) Kompromiss schließen;gemeinsam beschließen;übereinkommen;(einen) Kompromiss finden;(sich) verständigen (auf);(eine) Einigung finden;(eine) Übereinkunft treffen;zu einer Einigung kommen;(eine) Einigung erzielen;(sich) einigen (auf)
-abwürgen (Diskussion);unterdrücken;ersticken
-rückerstattungspflichtig;erstattungspflichtig
-Schaltskizze;Schaltbild;Stromlaufplan;Schaltplan
-unbewaffnet;waffenlos
-Skilanglauf;Nordischer Skilauf;Langlauf
-Stand;Messestand
-(einfach) kohlensaures Natron;Natriumcarbonat;Natriumkarbonat;Aschensalz (historisch);E 500i (fachspr., E-Nummer);Na2CO3 (fachspr., Summenformel, chemisch);Waschsoda;Soda
-Laborant;Laborchemiker;Chemiker
-Randstein;Rinnstein;Bordstein
-Schnelligkeit;Flinkheit
-verbrauchen;aufwenden;aufbrauchen;verausgaben;auspowern;erschöpfen
-Wirtschaft;Ökonomie;Wirtschaftsraum;Volkswirtschaft
-Innenraumgestaltung;Raumgestaltung
-klösterlich;mönchisch
-herunterhecheln;hersagen;herunterrasseln (abwertend, Hauptform);herunterdeklinieren (geh., bildungssprachlich);herunterhaspeln (ugs.);abspulen (ugs.);herunterleiern (abwertend);abhaspeln;herunternudeln (ugs.);herunterbeten (ugs.);abschnurren;abnudeln;herunterschnurren
-einbeziehen;einfügen;affiliieren (geh., lat.);einpfropfen;eingliedern;einbauen;aufnehmen;inkludieren;integrieren
-Typenschild;Leistungsschild;Typschild
-Bußgeld;Geldbuße
-(so) wie er leibt und lebt (ugs., männl.);in natürlicher Größe;lebensgroß;in Menschengestalt;leibhaftig;in voller Lebensgröße;(so) wie sie leibt und lebt (ugs., weibl.)
-kreisen;umwälzen
-Großer Ozean;Pazifischer Ozean;Stiller Ozean;Pazifik
-Abdeckung;Verdeckung
-Andenken;Mitbringsel;Souvenir (franz.);Erinnerungsstück;Reiseandenken
-Campingplatz;Zeltplatz
-Nasenloch;Nüster
-Vorsitzender;Präsident;Staatschef;Staatsoberhaupt
-scharfsichtig;scharfäugig
-säuisch (derb);dreckig (ugs.);pornographisch;schweinisch (ugs.);versaut (ugs.);zotig;pornografisch;pervers (derb)
-(irgendwohin) pfeffern (ugs., salopp);werfen (Hauptform);schleudern;schmeißen (ugs.);schmettern;feuern (ugs.)
-Aphelium;Aphel (fachspr.);Sonnenferne
-Missdeutung;falsche Deutung;Falschauswertung;Missinterpretation
-Nystagmus (fachspr.);Augenzittern
-sparsam umgehen mit;auf die Kostenbremse treten;einsparen;sparsam leben;auf seinem Geld sitzen (ugs., fig.);sparsam sein (Hauptform);(jemanden) knapphalten;mit wenig Geld auskommen;knausern (mit);geizen (mit);sparen;knapsen (ugs.);(den) Rotstift ansetzen
-Knechtschaft;Leibeigenschaft;Sklaverei;Unfreiheit
-besiedeln;kultivieren;zugänglich machen;erschließen (Bauland, Gebiet);kolonisieren;urbar machen;nutzbar machen;begehbar machen;bevölkern
-SWOT-Analyse;Stärken-Schwächen- und Chancen-Risiko-Analyse
-eckig;rechteckig;viereckig
-Endothelium (fachspr.);Endothel (fachspr.)
-leer;frei;unausgefüllt;leer stehend;ohne Inhalt
-Kratze;Rührstange
-abspenstig machen (ugs.);loseisen (ugs.);entführen (fig.);ausspannen (ugs.);freibekommen;wegschnappen;streitig machen;herausbekommen;abwerben
-Senior;sn.;der Ältere;sen.
-angegliedert;angeschlossen (an)
-blass;schlaff (ugs.);saftlos;kraftlos;blutarm
-Kanone (ugs.);Geschütz
-stutzen;kürzen;zurückstutzen;zurückschneiden;einkürzen;beischneiden (ugs.);zurechtstutzen;beschneiden;kappen
-Flächenmittelpunkt;Flächenschwerpunkt
-Eilbote;Stafette (veraltet)
-Eifersucht;Neid;Scheelsucht (veraltet);Missgunst
-Bejahung;bejahender Satz
-falsch verstehen;missdeuten;missinterpretieren;in den falschen Hals kriegen (ugs.);(die) falsche(n) Schlüsse ziehen (aus);missverstehen;falsch auffassen
-Pylorus (fachspr.);Magenpförtner
-Monteur;Installateur;Einrichter
-mastikatorisch (fachspr.);den Kaumuskel betreffend
-Behinderung (Hauptform);Beeinträchtigung;Handikap;Handicap
-Gaul;Ross;Rössli (schweiz.);Pferd (Hauptform);(der) Zosse(n) (ugs.);Hottehü (ugs., Babysprache);Einhufer;Hottemax (ugs., Babysprache);Rössel (regional)
-Angina (fachspr.);Mandelentzündung;Tonsillitis (fachspr.)
-Rohdaten;Urdaten;Primärdaten
-Hirschbrunst;Hirschbrunft
-gedehnt;ausgedehnt;lang gezogen;lang anhaltend
-Glückslos;Siegespreis;Preis;Treffer;Gewinn
-Aborigine;Aboriginal;australischer Ureinwohner
-Osterfest;Auferstehungsfest;Ostern (Hauptform)
-(im Denken) schwerfällig;(ein) Schaf (fig.);einfältig;nicht scharfsinnig;dusselig (ugs.);(ein) Schäfchen (ugs., fig.);stumpfsinnig;dusslig (ugs.);von schlichter Denkungsart;dümmlich;(sehr) einfach gestrickt (verhüllend);(ein) schlichtes Gemüt;verständnislos;(ein) Simpel (sein);(ein) Mondkalb;töricht;einfach gestrickt (fig.);unbedarft;(ein) Gimpel;(ein) Einfaltspinsel
-unumkehrbar;endgültig;unwiderruflich;unwiederbringlich;nicht mehr zu ändern (ugs.);irreversibel;final
-devastieren (geh.);trashen (ugs.);hinmachen (ugs.);von Grund auf zerstören;niederreißen;zernichten (dichterisch, veraltet);zerfetzen;zertrümmern;ramponieren;kaputt machen;in Trümmer legen;einhauen (ugs.);ruinieren;destruieren (geh.);abräumen (ugs., fig.);verwüsten;zunichtemachen (geh.);torpedieren (geh., fig.);(etwas) plattmachen (ugs.);demolieren;zerstören (Hauptform);zerhackstückeln (ugs.);himmeln (ugs.);in Schutt und Asche legen;schrotten (ugs.);zerbrechen;zerschmettern;zerdeppern (ugs.);zuschanden machen;kaputtmachen;zerschlagen;plattmachen (ugs.);einschlagen;vernichten
-Hintergrundmusik (Hauptform);Muzak (fachspr.);Backgroundmusik;Musikuntermalung;Fahrstuhlmusik (fig.);Begleitmusik;Musak (fachspr.);Kaufhausmusik (fig.)
-Aufschwung;Auftrieb
-Baugesuch;Bauantrag
-Türknauf;Türgriff
-Eindringen;Penetration;Durchdringung
-VC (Abkürzung, engl.);Risikokapital;Wagniskapital;Venture Capital (engl.)
-renovieren;sanieren;erneuern;aufhübschen;auffrischen;aufmöbeln;in Schuss bringen;auf Vordermann bringen (ugs.);aufpolieren;auf Zack bringen (ugs.);herrichten
-Bahn;Zug;Eisenbahn;Eisenbahnzug
-Lösungsmittel;Solvens
-mit leerem Magen;nüchtern;ohne etwas gegessen oder getrunken zu haben;ungefrühstückt;auf nüchternen Magen
-taugen (ugs.);passen (zu);(sich) eignen für
-Transport;Vorschub;Zuführung
-geschätzt;wertgeschätzt;repräsentabel;angesehen;geachtet;namhaft;respektiert
-voll;gefüllt
-Befürwortung;Empfehlung
-bronzefarben;bronze
-Hergang;Ablauf;Verlauf;Verfolg (fachspr., sehr selten);Prozess;Vorgang
-Einfassung;Begrenzung;Rain;Umgrenzung;Rand;Umrandung;Abgrenzung;Saum
-Reihe;Rang
-transitiv;zielend
-Senior;alter Mann;alter Knabe (ugs.);Alter;alter Herr;älteres Semester;älterer Herr;Alterchen (ugs.);Silberrücken (fig.);nicht mehr der Jüngste (ugs.)
-EFTA (Abkürzung);Europäische Freihandelsgemeinschaft
-Berufserfahrung;Arbeitserfahrung
-Maß nehmen (geh., fig.);taxieren;prüfend ansehen;einzuschätzen versuchen;abschätzen;abwägen;(mit Blicken) messen (geh., veraltend);austarieren (ugs.)
-a.o. Prof. (Abkürzung);Extraordinarius;außerordentlicher Professor;außerplanmäßiger Professor
-vorausgehen;schneller da sein;zuvorkommen
-Flügel;Propellerflügel
-Repressalie;Heimzahlung;Vergeltungsmaßnahme;Racheakt;Vergeltungsakt;Vergeltung (Hauptform);Gegenschlag (fig.);Revanche
-Rufstromgeber;Glöckner
-größt;meist;höchst
-weit auseinander;in weitem Abstand (voneinander)
-Spießer;Philister;Traditionalist;Biedermann;Kleinbürger;Konventionalist;Kleinkarierter;Spießbürger;Bünzli (ugs., schweiz.)
-Wandschirm;Leinwand;Schirm
-Programmpaket;Softwarepaket
-Verständigung;Informationsaustausch
-Abzugsrohr;Esse;Schornstein;Abzug;Abgaskanal;Schlot;Rauchfang;Rauchfang (österr.);Kamin
-jur.;von Rechts wegen;rechtlich (gesehen);formaljuristisch;(rein) juristisch;nach geltendem Recht;nach der formellen Rechtslage;de jure (fachspr.);formalrechtlich;gerichtlich;laut Gesetz;nach den Buchstaben des Gesetzes
-(sich) einverleiben;in Beschlag nehmen;besetzen;angliedern;(sich) aneignen;in Anspruch nehmen;annektieren
-skizzieren;umreißen;den Umriss zeichnen
-schräg sein;(sich) neigen;schief sein
-wie versteinert;statuenhaft;reglos;wie eine Statue;starr;erstarrt;unbewegt;statuesk;leblos;bewegungslos;regungslos
-klopfen (Motor);klingeln
-Lenker;Lenkrad;Steuerrad;Steuer;Volant (veraltet)
-Sprühwasser;Gischt
-Beunruhigung;Irritation;Reizung
-Ernennung;Nominierung
-empor;himmelwärts gerichtet;rauf (ugs., norddeutsch);herauf;nach oben;himmelwärts;in die Höhe;hinauf;hoch;aufwärts
-Universaltalent;Alleskönner;Tausendsasa;Allround-Dilettant (scherzh.-iron.) (ugs.);Generalist;Allzweckwaffe (ugs., fig., scherzhaft);kann alles, aber nichts richtig (ugs., sarkastisch);Hansdampf in allen Gassen (ugs.);Multitalent;(wahrer) Wunderknabe (ugs.);(unsere) Wunderwaffe (ugs., fig., scherzhaft);Wunderwuzzi (ugs., österr.);Tausendsassa;Allrounder;(unsere) Geheimwaffe (ugs., fig.);Universalgenie
-anekdotisch;anekdotenhaft
-bei passender Gelegenheit;zu gegebener Zeit (geh., Hauptform);im passenden Moment;als die Zeit erfüllt war (geh., Zitat, biblisch);zum gegebenen Zeitpunkt;wenn es so weit ist (variabel);wenn (sobald) die Zeit reif ist
-Geistesabwesenheit;Bewusstseinsstörung;(retrograde) Amnesie (fachspr.);Ausfallerscheinung;(ein) Blackout (ugs.);(ein) Filmriss (ugs., fig.);Absenz (fachspr.);Absence (geh., franz.)
-Verrenkung;Gelenkverrenkung;Luxation (fachspr.)
-Lazeration (fachspr.);Einriss
-Scharfsinn;Scharfsinnigkeit
-(sich) verbeugen (Hauptform);(einen) Diener machen (ugs.);(sich) verneigen (geh., Hauptform);(sich) nach vorne neigen;(einen) Bückling machen
-Ränke;Komplott;Ränkespiel;abgekartete Sache (ugs.);List;Kabale (geh., veraltet);Intrige (Hauptform)
-Hundegebell;Bellen;Gebell;Kläffen
-aufgeschlossen;rezeptiv;offen (für);gesprächsbereit;empfänglich;empfangend;aufnahmefähig;aufnehmend
-Direktverkauf;Direktvermarktung;Direktvertrieb;Direktmarketing
-Regelwidrigkeit;Abweichung;Unregelmäßigkeit
-File (engl.);Datei
-Verheerung;Verwüstung
-eindringlich;unter Flehen (dichterisch);sehnlichst;dringend;in drängendem Tonfall (geh.);händeringend;beschwörend (Hauptform);flehentlich;flehend;in flehendem Tonfall;inständig;inständigst;nachdrücklich;aus tiefster Seele
-Vor...;Präliminar...
-Oxid;Sauerstoff-Verbindung
-Mittelalter;MA (Abkürzung)
-Harke;Rechen
-Gesamtmenge;Summe
-Verstärkung;Verschärfung
-Klumpen;Scholle
-trödeln;zögern;verweilen;zaudern;(sich) zieren
-Europäische Vereinigung der Computerhersteller;ECMA (Abkürzung, engl.)
-Kupplungsschacht;Kupplungsaufnahme
-zurücksetzen;in die Ausgangslage zurückführen;löschen;radieren;entfernen;reinigen;eliminieren
-Betroffenheit;Traurigkeit;Trauer
-Hämoptoe (fachspr.);Bluthusten
-holperig;uneben;holprig;hubbelig (ugs.);rumpelig;höckrig
-zur Sau machen (derb, fig.);zusammenstauchen (ugs.);beleidigen;anpampen (ugs.);absauen (derb);abkanzeln;schimpfen (ugs.);ausschimpfen;(he)runterputzen (ugs.);abqualifizieren (ugs.);entwerten;diffamieren (geh.);herabsetzen;zur Schnecke machen (ugs., fig.);anmachen (ugs.);(he)runtermachen (ugs.);herabwürdigen;niedermachen;anpöbeln (ugs.);entwürdigen;anmotzen (ugs.)
-Buggy;Kinderkarre (ugs.)
-Normanschluss;Standardschnittstelle
-Widder;Schafsbock;Schafbock
-Bergwerk;Stollen;Pütt (ugs., Jargon);Grube;Zeche;Mine
-Zuweisung;Zuordnung;Auskehrung;Verteilung;Verbreitung
-Aufeinandertreffen;Zusammentreffen;zufälliges Zusammentreffen;Zusammenfall;Koinzidenz (bildungssprachl.) (geh.)
-übergehen;nicht beachten;übersehen;ignorieren;(sich) hinwegsetzen
-prahlerisch;großtuerisch;aufschneiderisch;angeberisch;dick aufgetragen (ugs.);großkotzig (ugs.);großspurig;großmundig;prätentiös;nicht gerade schüchtern;angeberhaft;protzig;großmäulig (derb);großschnauzig (derb);dünkelhaft;großsprecherisch;vollmundig;wichtigtuerisch
-Treibstoff;Kraftstoff;Sprit (ugs.);Brennstoff
-absurd;eigentümlich;befremdend;schräg;fällt aus dem Rahmen (ugs.);bizarr;abstrus (geh.);kurios;sonderbar;dadaistisch (geh.);abgedreht (ugs.);komisch;fantastisch;ungewöhnlich;seltsam;verquer;befremdlich;skurril;lächerlich;abenteuerlich;aberwitzig;eigenartig;grotesk;merkwürdig;eigenwillig
-(sich) zu helfen wissen;Köpfchen haben (ugs.);helle sein (ugs.);Grips haben (ugs.);nicht dumm sein;nicht auf den Kopf gefallen sein (ugs.)
-Fotokopie;Kopie;Xerokopie
-Leistungsdichte;Literleistung
-Ionen...;ionisch
-Kern;Mittelpunkt;Herzstück (ugs.);Epizentrum (ugs., fig.);Knotenpunkt;Zentrum
-Corticosteroid (fachspr.);Nebennierenrindenhormon
-blühender Unsinn;blanker Unsinn;glatter Unsinn
-Blaubarsch;Schnapper
-vorausblickend;vorausschauend;strategisch;bedacht;weitsichtig;planvoll;mit Vorbedacht;vorausplanend;besonnen;überdacht;durchdacht;mit Weitblick;überlegt;umsichtig;wohlüberlegt
-unicolor (fachspr.);uni;einfarbig
-duften (Hauptform);(ein) angenehmer Geruch (geht aus von);Wohlgeruch verströmen (geh., literarisch);(angenehm) riechen (nach)
-glücken;gutgehen (ugs.);aufgehen (Plan, Rechnung) (fig.);gelingen;klappen (ugs.);(sich) ausgehen (ugs., österr.);hinhauen (ugs.);laufen wie geplant (ugs.);funktionieren
-in allen Einzelheiten;genau;sorgfältig;gründlich;reiflich
-Eisenoxyd;Eisenoxid
-Hometrainer (Scheinanglizismus);Heimtrainer;Trimm-dich-Rad (ugs., veraltet);Stubenfahrrad (ugs.)
-Schippe;Schüppe (ugs., regional);Schippe (ugs., regional);Schaufel
-Adenom (fachspr.);gutartige Geschwulst;Xanthom (fachspr.)
-im Ergebnis;schließlich;in letzter Instanz;schlussendlich;Ende gut, alles gut. (ugs., kommentierend, sprichwörtlich);(das) Ende vom Lied (war) (ugs., negativ);schließlich und endlich;alles in allem;im Endeffekt;im Endergebnis;unter dem Strich (fig.);letztendlich (Hauptform);letztlich;unterm Strich (ugs.);letzten Endes;in letzter Konsequenz;am Ende des Tages (fig.)
-Verschiebung;Vertagung;Fristverlängerung;Aufschub;Verzögerung;Aussetzung
-Referee (fachspr., Sportsprache, engl.);Schiri (ugs.);Schiedsrichter;Pfeifer (ugs.);Unparteiischer
-dulden;durchlaufen;zulassen;durchmachen;erdulden;erleiden;hinnehmen;ertragen;über sich ergehen lassen
-(einen) Kurzbesuch abstatten;vorbeikommen;auf einen Kaffee mit reinkommen (ugs.);vorbeigehen (bei);hereinschauen;auf einen Kaffee vorbeikommen (ugs.);vorbeischauen (bei) (Besuch);(sich) (kurz) blicken lassen (bei) (ugs.);reinschauen (bei) (ugs.);auf einen Kaffee mit hochkommen (ugs.)
-Boykott;Embargo;Einfuhrverbot;Ausfuhrverbot;Handelssperre;Liefersperre;Handelsblockade
-umsetzen;umtopfen
-(jemanden) (wieder) vom Baum holen (ugs., Neologismus, fig.);Ruhe reinbringen (ugs., norddeutsch);(die Situation) entspannen;ausgleichend einwirken (auf);(die Situation) entschärfen;beruhigend einwirken (auf);beruhigen;(jemanden) beschwichtigen;Ruhe hineinbringen;besänftigen;begütigen;Öl auf die Wogen gießen (ugs.);gut zureden;(die) Wogen glätten;deeskalieren
-Taxon (fachspr., biologisch, griechisch);Genre;Klasse;Art;Couleur (geh., franz.);Format (fachspr., mediensprachlich);Rubrum (geh., bildungssprachlich, fig.);Spezies (fachspr., auch figurativ, biologisch);Rubrik;Sorte;Klade (fachspr., biologisch);Kategorie;Gattung;Typ
-Patenkind;Täufling
-Feuerwaffe;Schusswaffe;Wumme (ugs., salopp)
-Nachtisch;Dessert;letzter Gang;Nachspeise
-Berührungspunkt;Berührpunkt
-Scherdehnung;Schubverformung
-Störung des Bewegungsablaufs;Dyskinesie (fachspr.)
-schupsen (regional);stupsen (ugs.);stoßen;rempeln;schubsen
-Notlage;Notfall;Notsituation
-Dankgefühl;Dankfest;Erkenntlichkeit;Dank;Dankbarkeit;Danksagung;Dankeschön (Jargon)
-grapschen (ugs.);greifen;grabschen (ugs.)
-Anklageschrift;Klageschrift
-Umschlagzyklus;Buchungsdurchlauf
-von wo;von wannen (geh., altertümelnd, scherzhaft, veraltet);woher
-Scheitel;Scheitelpunkt
-Touristenklasse (ugs.);Holzklasse (ugs.);Economy Class;Economyklasse
-Aushöhlung;Höhlung;Höhle;Hohlraum;Bau
-(sich) eingliedern;(sich) einordnen;(sich) einfügen;(sich) integrieren;(sich) anpassen (Hauptform)
-akzeptabel;vertretbar;erträglich;passabel;tolerabel;annehmbar;hinnehmbar;geht gerade noch an (ugs.);zumutbar;tolerierbar;tragbar;akzeptierbar
-urladen (fachspr.);(Computer) hochfahren;initialisieren (fachspr.);anwerfen (ugs.);starten;anschmeißen (ugs.);booten
-je;für jede(n/s) (Hauptform);für;per (Jargon, kaufmännisch);zu je;pro;das (Kilo / Pfund / Stück) (zu) (ugs., Jargon);à (fachspr., franz., kaufmännisch);die (Woche / Minute / Kiste / Flasche ...) (ugs., Jargon)
-auseinandernehmen (ugs.);zur Sau machen (ugs.);zur Schnecke machen (ugs., fig.);scharf kritisieren;anraunzen (ugs.);zur Minna machen (ugs., veraltend);beschimpfen;anherrschen;(jemanden) in den Senkel stellen (ugs.);angiften (ugs.);rummeckern (an jemandem) (ugs.);die Leviten lesen (ugs., fig.);ausschimpfen;(scharf) zurechtweisen (Hauptform);anschnauzen;anmeckern (ugs.);(jemandem) den Kopf abreißen (fig.);zusammenscheißen (derb);anpfeifen (ugs.);fertigmachen (ugs.);anfahren (ugs.);abwatschen (ugs.);(jemandem) seine Meinung geigen (ugs.);anblasen (ugs.);rundmachen (ugs.);anpflaumen (ugs.);rüffeln;anranzen (ugs.);zusammenfalten (ugs., fig.);ausschelten
-Vitalität;Lebhaftigkeit;Lebendigkeit;Kräfte
-zum Mastdarm gehörend;rektal (fachspr.)
-Zusammenbruch;Armageddon;Super-GAU;Apokalypse;Unglück;Verderben;Waterloo (ugs.);Abaddon (bibl.) (geh.);Untergang;Ende;Endzeit
-Menstruation;Zyklus;Regel (ugs.);Periode;Tage (ugs.);Regelblutung;Monatsblutung;Menses (fachspr.)
-verfrachten;speditieren (fachspr.);verladen;transportieren
-Oxygenation (fachspr.);Sauerstoffzufuhr
-Schleifstein;Wetzstein
-durchsickern;sickern
-Warenmuster;Probe;Muster
-Menschenkunde;Lehre vom Menschen;Anthropologie
-Bewegungskrankheit (fachspr.);Kinetose (fachspr.);Übelkeit (Hauptform);Seekrankheit;Schlechtsein (ugs.);Nausea (fachspr.);Brechreiz
-weißen;bleichen;ausbleichen
-beigelegtes Schreiben;Begleitbrief;Anschreiben;Begleitschreiben
-nichtssagend;08/15;farblos;unscheinbar;gesichtslos (Hauptform);ohne Flair;ohne Ausstrahlung
-cheaten (ugs.);mit gespaltener Zunge sprechen (fig.);lügen (Hauptform);hochstapeln;es nicht so mit der Wahrheit haben (ugs.);(etwas) wahrheitswidrig behaupten;schwindeln;(es) mit der Wahrheit nicht so genau nehmen (verhüllend);betrügen;die Unwahrheit sagen;krücken (ugs., regional);(ein) falsches Spiel spielen;(etwas) wider besseres Wissen behaupten;mogeln (ugs.)
-stark;kampfstark
-Schiffsanlegestelle;Mole;Pier;Bootsanlegestelle
-Teilkette;Teilzeichenfolge
-Wetter;Wetterlage;Witterung;Klima (ugs.)
-UNCTAD;Handels- und Entwicklungskonferenz der Vereinten Nationen
-Codierung;Kodierung
-Rhombus;Raute;schiefwinkliges gleichseitiges Viereck
-Kausalitätsprinzip;Ursache-Wirkung-Prinzip;Kausalprinzip
-Ornithologie (fachspr.);Vogelkunde
-Wildfang (verniedlichend);Wildling;Wirbelwind (fig., verniedlichend);Tollkopf;Springinsfeld
-(sich) entscheiden (zu / für) (Hauptform);(einen) Entschluss fassen;(sich) entschließen (zu);(eine) Entscheidung fällen;(einen) Beschluss treffen (auf e. Versammlung);(sich) durchringen (zu);(eine) Wahl treffen;(eine) Entscheidung treffen
-beeinträchtigen;behindern;erschweren;verschärfen
-(vom Dienst) beurlauben;jemanden (zeitweilig) des Amtes entheben;suspendieren
-Anfälligkeit;Gebrechlichkeit;Zartheit;Schwäche;Fragilität;Kränklichkeit;Labilität
-Strafhaft;Haftstrafe;Freiheitsstrafe;Freiheitsentzug;Gefängnisstrafe
-Vetter;Cousin
-Springer (fachspr.);Docke (fachspr.)
-thailändisch;Thai...
-temperaturgesteuerter Widerstand;Thermistor
-Zusatzgerät;Peripheriegerät;Zubehörteil;Zusatzteil
-Devastierung;Zerstörung;Vernichtung;Destruktion;Demolition (geh., lat.);Zertrümmerung;Devastation;Aufreibung;Zunichtemachung;Annihilation;Verwüstung;Auslöschung
-Dörfchen;Zinken (badisch);Weiler;Rotte (österr.);Bauerschaft (niedersächsisch)
-initiieren (geh.);anstiften (negativ);auslösen;herbeiführen;induzieren (fachspr.);anfangen (etwas/mit etwas);in Gang bringen;hervorrufen;entfachen
-Ionisation;Bildung von Ionen;Ionisierung
-per Prokura;pp(a).
-Dividendenrendite;Dividendenertrag
-Meeraal;Seeaal
-Nomade;Wüstenbewohner;Beduine;Wüstennomade;Wüstensohn;Kameltreiber (derb, beleidigend, fig.)
-nicht (so) einfach (ugs.);(es gibt) keine einfache(n) Lösung(en) (ugs.);schwierig (Hauptform);schwer;diffizil (geh., franz., lat.);kompliziert
-Bagatellisierung;Beschönigung;Verharmlosung
-pflichtbewusst;pflichtgemäß;treu;gehorsam
-(etwas) platt machen;glätten;bügeln (ugs.);mangeln;walzen;plätten
-verzahnen;vermaschen
-Abendgesellschaft;Soiree;Abendveranstaltung;Soirée;bunter Abend (veraltend)
-Aufputschmittel;Weckamin;anregendes Heilmittel;Stimulans;Anregungsmittel
-verschmieren;auftragen;verteilen
-(sich) schlängeln;(sich) winden;(sich) krümmen;mäandern (griechisch);mäandrieren (griechisch)
-Aktenmappe;Mappe;Aktentasche
-einschüchternd;desillusionierend;entmutigend;abschreckend;demotivierend
-Prozentrang;Perzentil
-grundsätzliche Einstellung;Grundhaltung;Tenor
-Manschettenknopf;Kragenknopf
-Zwergmensch;Liliputaner (derb);Kleinwüchsiger;Pygmäe
-anfallsartig;paroxysmal (fachspr.)
-Pipapo (ugs.);Gimmick;Dinge;Sachen;Gedöns (ugs.);Teile (ugs.);Utensilien;Zeug
-reizend;schmuck;schön (Hauptform);eine Augenweide;(ein) herrlicher Anblick;hübsch;(eine) wahre Pracht;hübsch anzusehen;liebreizend;wie gemalt;hinreißend;ein erfreulicher Anblick;(eine) Wohltat fürs Auge;Augenschmaus (geh.);was fürs Auge (ugs.);herrlich;schön anzusehen;(bewundernde) Blicke auf sich ziehen;attraktiv;allerliebst;lieblich;Augenschmeichler (geh.);hold (geh., veraltet);Hingucker;ansehnlich (geh.);gut aussehend;entzückend;fesch (österr.)
-Getöse;Radau (ugs.);Gedröhne;Trara (ugs.);Gedröhn;Rabatz (ugs.);Lärm (Hauptform);Gerumse (ugs.);Krach
-Fehlerhaftigkeit;Ungenauigkeit;Verkehrtheit
-Morsekonus;Morsekegel
-Pfund;Pfd. (Abkürzung)
-(jemanden) herablassend behandeln;(jemanden) gönnerhaft behandeln
-Schleifpapier;Glaspapier;Sandpapier;Schmirgelpapier
-Instrumentenflug;Blindfliegen (ugs.);Blindflug (ugs.)
-vorhersagen;wahrsagen;voraussagen;orakeln;prognostizieren (geh., griechisch);eine Prognose aufstellen (variabel);weissagen;prädizieren (geh., lat.);prophezeien;ankündigen;augurieren (geh., bildungssprachlich, griechisch, lat., selten)
-(jemanden) ausspielen;(jemanden) ausbooten;(jemanden) ausmanövrieren;(jemanden) ein Schnippchen schlagen (ugs.);(jemandem) zuvorkommen;(jemanden) ausstechen
-Eyeliner;Augenstift;Augenkonturenstift
-(sich) umdrehen;herumkugeln;herumrollen
-Bindung;Bindebogen
-Gottlosigkeit;Ungläubigkeit;Atheismus;Glaubenslosigkeit;Unglaube;Religionslosigkeit;Gottesleugnung
-Hodentumor;Seminom (fachspr.)
-Spezifikum;Spezialität;Besonderheit;Entscheidende;besonderes Merkmal
-schaffen (ugs., schwäbisch);tätig sein;arbeiten (Hauptform);(sich) betätigen (als);werken;wirken
-Braille;Brailleschrift;Blindenschrift
-Supergehirn (ugs., ironisch);Allesbesserwisser (ugs.);Neunmalkluger (ugs.);Klugschnacker (ugs., norddeutsch);(jemand, der glaubt, er) hat die Weisheit mit dem Schöpflöffel gefressen (ugs., ironisch);Oberschlaumeier (ugs.);Superhirn (ugs., ironisch);Klugscheißer (derb);Schweinchen Schlau (ugs.);Besserwessi (ugs.);Klugschwätzer (ugs.);Rechthaber (ugs.);Oberschlauer (ugs.);Oberschlauberger (ugs.);Besserwisser;Krümelkacker (derb, berlinerisch)
-Lohnobergrenze;höchster Lohn
-Anosmie (fachspr.);Geruchsminderung
-Wandervogel (ugs.);Wanderer;Wandersmann;Wanderfreund
-Thermoregulation;Wärmeregulation
-Rolle;Person (Theater);Part;Partie
-Uterusexstirpation (fachspr.);operative Entfernung der Gebärmutter;Hysterektomie (fachspr.)
-Lymphgefäßentzündung;Lymphangiitis;Lymphangitis (fachspr.)
-Übel;Malaise (fachspr.);angespannte Lage;Krise;missliche Lage;Schlamassel (ugs.);Missstand;schlimmer Zustand;kritische Situation;Krisis (geh., veraltend);Misere;Verhängnis;Tragik;Kalamität (geh., lat.)
-Heimatstadt;Geburtsstadt
-prononciert (geh.);ganz und gar;gänzlich;betont (geh.);ausgesprochen
-implementieren;proggen (ugs.);programmieren;hacken (ugs.);coden;entwickeln
-Tiefsinn;Tiefe
-penetrant;nassforsch (ugs.);unverschämt;vorlaut;dreist;kackendreist (derb);impertinent;dummdreist (ugs.);wüst;kackfrech (derb);rotzfrech (ugs.)
-Rücksicht;Aufmerksamkeit
-Bauchspeicheldrüsenentzündung;Entzündung der Bauchspeicheldrüse;Pankreatitis (fachspr.)
-Betriebsanleitung;Bedienungsanleitung (Hauptform);Gebrauchsanweisung;Handbuch;Leitfaden;Fibel (veraltend);Bedienungshandbuch;Gebrauchsanleitung;Anleitung;Betriebsanweisung
-schmökern;blättern
-losreißen;durchreißen
-Diva;Lead Singer;Hauptsängerin;Primadonna
-Unenthaltsamkeit;Unmäßigkeit
-voll entwickelt;großjährig (veraltend);reif;erwachsen;über 18;mündig;kein Kind mehr (ugs.);den Kinderschuhen entwachsen (geh.);ausgewachsen;volljährig;flügge (fig.)
-alt werden;reif werden;altern;älter werden;in die Jahre kommen;reifen
-Alarm schlagen (fig.);Alarm geben;(jemanden) alarmieren;Alarm auslösen;(jemanden) avertieren (veraltet);(jemanden) vorwarnen
-Listenpreis;Richtpreis
-Achsnagel;Achsennagel
-Trauern;Trauer...
-Pneumopathia (fachspr.);Lungenerkrankung
-Chylus (griechisch, lat.);Latex (griechisch);Milchsaft
-frei;frei heraus;offenherzig;gradheraus (ugs.);unverblümt;offen;freimütig;rundheraus;geradeheraus;direkt
-zusammenziehen;fixieren;festigen;festziehen
-Alterung;Seneszenz;Alterungsprozess
-Pyrosis (fachspr.);Sodbrennen;Magenbrennen (schweiz.)
-Devisenkurs;Kurs;Wechselkurs
-Stent (fachspr.);Gefäßstütze
-Steuerung;Regulierung;Regulation;Regelung
-festgefahren (fig.);verfahren;ausweglos;aussichtslos;in einer Sackgasse (fig.);hoffnungslos;verbaut;auf verlorenem Posten (stehen);chancenlos
-gesund werden;(sich) hochrappeln (ugs.);gesunden;geheilt werden;auferstehen;(sich) aufrappeln (ugs.);(sich) aufrichten;genesen;erstarken;aufleben;(sich) erholen;(sich) wieder beleben
-sagen;zum Inhalt haben;berichtet werden (in einem Text);besagen
-Gesinnungswandel;Gesinnungswechsel;Einstellungsveränderung
-Ableger;Absenker
-Landsmann;Staatsangehöriger;Staatsbürger;Bürger
-formulieren;umreißen;(einer Sache) eine Form geben;skizzieren
-Vertriebsabteilung;Verkaufsabteilung;Vertrieb;Sales (engl.);Verkauf (oft Betonung auf erster Silbe, Firmenjargon)
-Tuch;Überzug;Decke
-aufs falsche Pferd setzen (ugs.);auf die falsche Karte setzen (ugs.)
-Mietkaufvertrag;Abzahlungsvertrag
-Bröckelkohl;Sprossenkohl;Spargelkohl;Winterblumenkohl;Brokkoli;Broccoli
-illiquide;bankrott;insolvent;pleite;zahlungsunfähig;in Konkurs
-Vormachtstellung;Überlegenheit;Dominanz;Übermacht;Superiorität
-Industriegebiet;Gewerbegebiet;Gewerbepark
-Intimität;Nähe;Vertraulichkeit;Innigkeit
-wie einem Katalog entsprungen;wie (gerade) einer Modezeitschrift entsprungen;geschniegelt und gestriegelt;wie aus dem Ei gepellt (ugs.);picobello;sehr ordentlich angezogen (sein);geschniegelt;geschniegelt und gebügelt;schmuck;wie geleckt
-Ausdehnung;Größenordnung;Format;Ausmaß;Abmessung;Größe;Magnitude (fachspr.);Ebene;Dimension;Liga (ugs.);Kaliber (ugs., fig.)
-Position beziehen;antworten;beantworten;eingehen (auf);zur Antwort geben;(etwas) sagen zu;Stellung nehmen (zu);Stellung beziehen (zu);(eine) Stellungnahme abgeben (zu);(einen) Standpunkt vertreten;reagieren;(ein) Statement setzen;erwidern (auf);(sich) positionieren
-Safe;Stahlkammer;Panzerschrank;Tresor;Geldschrank
-Gebärmutter;Uterus (fachspr.)
-Kleingeld;Rückgeld (ugs.);Wechselgeld
-fix und fertig;greifbar;zu Diensten (Person) (geh.);bereit;einsatzbereit;parat;fixfertig (ugs., schweiz., vorarlbergerisch);disponibel (geh.);komplett;fertig;startfertig;startklar (ugs.);verfügbar;einsatzfähig
-Heiland;Erlöser;Befreier;Messias (ugs.);Gesalbter
-Aspik;Sülze;Sulz
-erwerben;anerziehen
-Halm;Schaft;Stängel;Stiel
-theoretisch;hypothetisch;in der Theorie;kontrafaktisch (geh.);spekulativ;rein gedanklich
-verschleifen;(Silben halb) verschlucken
-Alliteration;Stabreim
-Zündschnur;Lunte
-Kernel;Systemkern;Kern;Betriebssystemkern
-guter Mann (Anrede) (ugs.);der Herr (Anrede durch Kellner/in) (geh.);Bürschchen (Anrede, drohend) (ugs.);Bruder (Anrede) (ugs., Jargon);Mann Gottes (Anrede) (veraltet);Kollege (Anrede) (ugs., salopp);Jungs (Anrede) (ugs.);Sportsfreund (Anrede, leicht herablassend) (ugs.);Verehrtester (geh., ironisch);Cowboy (Anrede) (ugs., salopp, scherzhaft);mein Herr (Anrede) (geh.);Mann (Anrede / Interjektion) (ugs.);(großer) Meister (Anrede) (ugs., ironisch);Freundchen (Anrede, drohend) (ugs.);junger Mann (Anrede) (ugs., Hauptform);Kleiner (Anrede) (ugs.);Alter (Anrede unter Jüngeren) (ugs., Jargon);mein Gutster (Anrede) (ugs., scherzhaft, sächsisch);Leute (Anrede) (ugs.);Mensch (Anrede / Interjektion, verärgert) (ugs.);Kinders (Anrede) (ugs.)
-Durchsage;Multicast;Gruppenruf;Mehrfachübertragung
-Abspannung;Läufer;Anker
-Anwerbung;Einstellung;Recruiting (engl.);Rekrutierung;Recruitment (engl.)
-falsch auswerten;missdeuten
-einkerkern (veraltend);ins Gefängnis bringen;einknasten (ugs.);einschließen;einsperren;hinter schwedische Gardinen bringen (ugs.);ins Gefängnis stecken;einbuchten (ugs.);ins Gefängnis werfen;einkasteln (ugs., süddt.);hinter Gitter bringen;einbunkern (ugs.);hinter Schloss und Riegel bringen;ins Loch stecken (ugs.);einlochen (ugs.)
-Gewölbe;Kuppel
-Anmeldeformular;Antragsformular
-National Aeronautics and Space Administration (engl.);US-Raumfahrtbehörde;NASA (Abkürzung, engl.);Nationale Luft- und Raumfahrtbehörde
-Ablaufdiagramm;Flussdiagramm
-Polyneuritis (fachspr.);entzündliche Nervenerkrankung
-Grundplasma der Zelle;Cytoplasma;Zytoplasma
-(vollständiger) Ausverkauf;Räumungsverkauf;Totalausverkauf
-dick (Hauptform);korpulent;(etwas) auf den Rippen haben (ugs., variabel);mollig;schwergewichtig (verhüllend);dickleibig;kugelrund;adipös (fachspr., medizinisch);drall;vollschlank (verhüllend);dickbäuchig;gut gepolstert (ugs., ironisch);dick und fett (ugs., Redensart);beleibt;wohlbeleibt;fettleibig;aufgedunsen;fett (derb);übergewichtig;wohlgerundet (verhüllend);wampert (ugs., bayr.);wohlgenährt;stark (verhüllend);schmerbäuchig;voluminös;füllig;aus der Form geraten (ugs.);üppig;feist;über Normalgewicht;stattlich (verhüllend)
-englische Krankheit;Rachitis
-Wanzen anbringen;verwanzen
-(sich) entspinnen (Diskussion);(sich) entfalten;(sich) herausbilden;(sich) entwickeln;(allmählich) entstehen
-(sich) bemühen (um);(sich) (etwas) angelegen sein lassen (geh.);(sich) (einer Sache) befleißigen (geh.);bestrebt sein;(sich) kümmern;(seine) Aufgabe darin sehen;(sich) mühen;(sich) (alle) Mühe geben;sich ins Zeug legen;darauf aus sein (zu);(einer Sache) Sorge tragen (geh.);(jemandem) wichtig sein (ugs.);(es sich) zur Aufgabe machen;(jemandes ganzes) Dichten und Trachten (geh., veraltet);(für etwas) Sorge tragen
-(einer Sache) Rechnung tragen;(einer Sache) Beachtung schenken;(etwas) bedenken;berücksichtigen;(etwas) beachten (Hauptform);(auf etwas) achten;(etwas) beherzigen;denken (an);(etwas) im Hinterkopf behalten
-an Ostern;zu Ostern
-Schäfchenwolken;Cirrocumuluswolken (fachspr.)
-epidemisch;seuchenartig
-dermaleinst (geh., literarisch);seinerzeit;dereinst;ehemals;lang, lang ist's her (ugs.);einst;vor Zeiten (geh.);es hat Zeiten gegeben (da / in denen) (formelhaft);in der guten alten Zeit;in (jener) längst vergangener Zeit;früher (Hauptform);in ferner Vergangenheit;in der Vergangenheit;anno dazumal;vormals;vordem;in vergangener Zeit;in (jenen) längst vergangenen Tagen;ehedem;dazumal (veraltend);einstmals;weiland;vor langer Zeit;einmal (ugs.)
-Temperaturabfall;Temperatursturz
-Bildung;Eröffnung;Gründung;Einsetzung
-gehen lassen;abschnallen;losschnallen;lösen;loshaken
-vorgeben;vortäuschen;vorgaukeln;heucheln;türken (derb);ersinnen (geh.);erlügen;fingieren;vorschützen;erdichten;gaukeln
-Entzündung der Mastdarmwand;Proktitis (fachspr.)
-Transaktionssatz;Änderungssatz
-Umfassung;Umarmung
-Abfalltonne;Mülltonne;Abfallkorb;Abfallbehälter;Mistkübel (ugs., österr.);Abfalleimer;Mülleimer
-anwenden (auf);anlegen;auflegen
-akzeptabel;okay (ugs.);schon gut (ugs.);soweit (ganz) okay;in Ordnung;O. K. (ugs.);o. k. (ugs.);(ganz) okay so;(ganz) okay so weit
-Datenübertragungsgeschwindigkeit;Baudrate;Baud-Rate
-inländisch;ortsansässig;gebürtig;heimisch;einheimisch
-Scham;Schamgefühl
-unproportional;diskontinuierlich;unstetig;uneinheitlich
-Abszisse;x-Achse;horizontale Achse;Abszissenachse
-die Lunge betreffend;pulmonal (fachspr.)
-Anpassungsbereich;Einstellbereich
-(sich) auftürmen;aufragen;(sich) aufbauen;aufsteigen;aufstreben;ragen;hochragen;(sich) erheben;auftürmen;hervorheben;hervortreten;türmen;hinausragen;emporragen
-Dongle;Kopierschutzstecker;Hardlock
-mangelhaft;unter Soll;(es gibt) Entwicklungsbedarf (ironisch, variabel);unzureichend;zu wenig;insuffizient (fachspr.);(durchaus) ausbaufähig (ironisch, verhüllend);nicht ausreichend (Hauptform);ungenügend;zu wünschen übrig lassen;(jemand) hätte mehr erwartet;(es) ist nicht getan (mit);nicht in Ordnung;(eine) Herausforderung (fig., verhüllend);nicht genug;unzulänglich;hapern mit (es);nicht den Erwartungen entsprechen;steigerungsfähig (ironisch)
-pflichteifrig;fleißig;emsig;eifrig;beflissen;dienstbar;geschäftig;schaffig (ugs., süddt.);dienstfertig;dienstbeflissen
-provokant (Hauptform);herausfordernd;provozierend;reizend;provokativ;aufreizend;provokatorisch
-nachstellen;nachregeln
-skalieren;normieren
-salinisch;salzig;salzhaltig;solehaltig
-Grund;Grund und Boden;Boden;Land
-in Eingriff bringen;einrücken;ineinander greifen;eingreifen
-gastrointestinal (fachspr.);Magen und Darm betreffend
-Unternehmer;Unternehmensleiter;Firmeninhaber;Geschäftsinhaber;Entrepreneur;Unternehmensinhaber
-Sattdampf;Nassdampf
-Schlauchbinder;Schlauchbriden (schweiz.);Briden (schweiz.);Schlauchschelle
-Vermittler;Mittelsperson;Handlungsbeauftragter;Vertretung;Beauftragter;Vertreter;Mittelsmann;Handlungsführer;Agent
-Ungemach (geh., veraltet);(den) schwarzen Peter haben (ugs.);Unbill;Unglück;Misere;dummer Zufall;Künstlerpech (ironisch);Pech;(die) Arschkarte (gezogen) haben (ugs., variabel)
-Thailänder;Thai
-Verwendung von Symbolen;Symbologie
-Ablösung;Lösen;Abtrennung;Trennung
-Impfung (Hauptform);(das) Jaukerl (ugs., österr.);Vakzination (fachspr.);Impfstoffgabe;Spritze (ugs., Hauptform);Schutzimpfung;Vakzinierung (fachspr.);Injektion (fachspr.);Piks (ugs.)
-rascheln;kruspeln (österr.);(leise) rauschen;krispeln;knistern
-Flankenball;Flanke
-verzocken (ugs.);auf den Kopf hauen (ugs.);verprotzen (ugs.);verschwenderisch umgehen (mit);durchbringen (Vermögen) (ugs.);verläppern (ugs.);verjuxen (ugs.);vertun (ugs.);vergeuden;aasen (mit) (ugs.);verbraten (ugs.);verjankern (ugs., österr.);(nur so) raushauen (ugs.);prassen;Geld aus dem Fenster werfen (fig.);zum Fenster hinauswerfen (ugs.);verschleudern (ugs.);verbuttern (ugs.);urassen (ugs., österr.);verprassen;verfrühstücken (ugs.);auf neureich machen (ugs.);verschwenden (Ressourcen) (Hauptform);mit Geld (nur so) um sich werfen (ugs.);wegwerfen (ugs.);verplempern (ugs.);verpulvern (ugs.);rumaasen mit (ugs., rheinisch);verjubeln (ugs.);wegschmeißen (ugs.);(Das) Geld (mit beiden Händen) auf die Straße werfen (fig.);(sein Geld) unter die Leute bringen (ugs.);(sein Geld) mit vollen Händen ausgeben;raushauen (ugs., salopp);verballern (ugs.);zum Fenster rauswerfen (ugs.)
-(sich) suhlen (ugs.);(sich) wälzen;(sich) herumwälzen;hin und her rollen
-befruchtete Eizelle;Zygote (fachspr.)
-Anrecht;Anspruch;Recht
-lagenweise;schichtweise
-ausgleichen;aufwiegen;einen Ausgleich schaffen;abgelten;gegenfinanzieren;kompensieren;entgegenwirken
-Verzeichnis;Dateiverzeichnis;Ordner
-Vermischer;Mischer
-Aufstand der Massen;Unruhe(n);Rebellion;Proteste;Aufruhr;Auflehnung;Tumult;Erhebung;Ausschreitung(en);Aufstand;Massenaufstand;Massenproteste;Krawall;Massenunruhen;Putsch;Protestaktionen;bürgerkriegsähnliche Zustände
-Hommage (geh., franz.);Ehrenbezeugung;Ehrenbezeigung;Ehrung;Huldigung
-vegetabil (geh., lat.);Pflanzen...;vegetabilisch (geh., lat.);pflanzlich
-vitreus (fachspr.);gläsern
-Schmand;Schmetten;Schmant
-akkreditieren (fachspr.);verbürgen;beglaubigen;authentisieren (fachspr.);beurkunden;bewahrheiten (veraltet);bestätigen;vidieren (Amtsdeutsch, österr.);testieren (geh., lat.);quittieren;zertifizieren (geh.);verbriefen;bevollmächtigen;vidimieren (geh.)
-Windschatten;Lee;dem Wind abgewandte Seite
-(eine Unrechtstat) sühnen;bezahlen (für) (ugs.);büßen (für)
-MEZ;mitteleuropäische Zeit
-fiebererzeugend;pyrogen (fachspr.);pyretisch
-kaputt (ugs.);hat seine Funktion eingestellt;verreckt (ugs.);in die Brüche gegangen;nicht mehr benutzbar;funktionsunfähig;hin (ugs.);funktionsuntüchtig;außer Betrieb;abgekackt (ugs.);läuft nicht;geht nicht (mehr) (ugs.);defekt (Hauptform);fratze (ugs.);im Eimer (ugs.);funktioniert nicht (mehr);nicht funktionierend
-Mitgefühl;Bedauern;Mitleid (mit, für);Beileid
-Benamung;Betitelung;Benennung (Hauptform);Auszeichnung;Beschriftung;Benamsung (ugs.)
-Tuschierplatte;Richtplatte
-vermaledeien (veraltet);verdammen;verfluchen
-Auspuff;Auspuffrohr
-Verformbarkeit;Plastizität;Formbarkeit
-(irgendwohin) fegen;(etwas) abfegen;durchfegen;(etwas irgendwohin) kehren (regional);ausfegen;(etwas) fegen
-...lich;blässlich;bleich;fahl;blass;glanzlos;farblos;matt;farbarm
-vielgestaltig;pluralistisch;polymorph
-Pilzinfektion;Mykose (fachspr.);durch Pilze verursachte Krankheit;Pilz (ugs.)
-in die Ecke treiben (ugs.);beschränken;in die Enge treiben (ugs.);behindern;einengen;ins Bockshorn jagen (ugs.);beengen
-unterschreiben (Hauptform);abzeichnen;unterfertigen (geh., Amtsdeutsch, veraltet);unterzeichnen;signieren;seinen 'Kaiser Wilhelm' daruntersetzen (ugs., Redensart, scherzhaft)
-schrecklich;missliebig;unliebsam;nicht wünschenswert;widrig;schlecht;nicht erwünscht;unschön;unkomfortabel (geh.);blöd (ärgerlich) (ugs.);ärgerlich;unwillkommen;unerquicklich;mit (einigen) Unannehmlichkeiten verbunden;ungut;störend;schlimm;unangenehm;wenig beneidenswert;unerfreulich;nicht wünschen;böse (Überraschung, Erwachen ...) (ugs.);unerwünscht;leidig;etwas Dummes (ugs.);ungeliebt;lästig;unbequem;dumm (ärgerlich) (ugs.);misslich
-degenerieren;verderben;entarten;ausarten;depravieren (geh., lat.)
-räudig (ugs.);dreckig und speckig (ugs.);versifft (ugs.);schmutzig (Hauptform);kotig (veraltend);vor Dreck starren;verranzt (ugs.);Drecks... (derb);mistig (ugs.);steht vor Dreck (ugs.);verunreinigt;voller Dreck und Speck (ugs.);dreckig;Schmuddel... (ugs.);unrein;vor Dreck stehen (ugs.);verschmutzt;siffig (ugs.);schmutzbehaftet;beschmutzt;schäbig;mit Schmutz behaftet;voller Mist (ugs.);unhygienisch;schmierig;voller Schmutz;verdreckt;schmuddelig (ugs.);unsauber;ranzig (ugs.)
-annehmen;erwarten;tippen auf (fig.);denken;zu wissen glauben (geh.);meinen;(von etwas) ausgehen;vermuten;schätzen (ugs.);mutmaßen;glauben
-anfassen;anpacken (ugs.);anrühren (ugs.);berühren
-Bindenseeadler;Weißkopfseeadler;Weißköpfiger Seeadler;Haliaeetus leucoryphus (fachspr., griechisch, lat.)
-minderwertig;billig (geringwertig) (Hauptform);halbwertig;zweiten Ranges;schlecht;Billig...;inferior (geh.);(von) schlechter Qualität;(von) minderer Güte (geh.);geringwertig;drittklassig;dürftig;medioker;Arme-Leute-... (ugs., fig.);zweitklassig (verhüllend);mäßig;inferior (Gut) (fachspr.)
-Textilie;Stoff;Tuch;Gewebe
-Mehrfunktions...;Mehrfachfunktion
-zivilisiert;kultiviert;gebildet
-Ferritstab;Eisenkern;Spulenkern
-Fachchinesisch (ugs., abwertend);Jargon (franz.);Fachsprache;Technolekt (griechisch, lat.);Fachjargon;Fachlatein (ugs.);...-Sprech (...sprech) (ugs., Jargon)
-verfault;vermodert;vermorscht (ugs.);modrig;zersetzt;faulig;verrottet;faul;morsch;zerfallen;putrid (fachspr., historisch, lat.)
-makellos;unberührt;unverändert;ursprünglich;jungfräulich (fig.);unangetastet
-Notwendigkeit;Erfordernis;Voraussetzung;Unabdingbarkeit;Anforderung
-übertragen;routen;senden;navigieren;leiten;übermitteln;schicken
-Bildnis;Statue;Nachahmung;Nachbildung
-Pupillenerweiterung;Mydriasis (fachspr., griechisch)
-hinzufügen (zu);beitragen (zu)
-in Europa;europäisch
-Deutsches Institut für Normung;DIN
-Zerteilung;Zersplitterung;Zerstreuung;Auflösung;Zerrüttung;Untergang;Zerfall;Abbruch;Zerlegung;Rückbau;Demontage;Zertrennung;Dissipation (lat.);Abbau;Entlassung
-Sprengring;Sicherungsring
-(sich) auf die Beine machen (ugs.);(sich) auf die Socken machen (ugs.);losgehen;(sich) auf den Weg machen;lossocken (ugs., regional);losziehen;seinen Weg antreten;aufbrechen (Hauptform);(sich) aufmachen
-jäten;rupfen;zupfen (Unkraut)
-Sorge;Angstgefühl;Manschetten (ugs.);Beklemmung;Scheu;Bedenken;Muffensausen (ugs.);Bedrohungsgefühl;Muffe (ugs.);Befürchtung;Angst;Flattermann (ugs.);Furcht;Fracksausen (ugs.);Beklommenheit;Bammel (ugs.);Schiss (ugs.)
-Fangprämie;Kopfgeld;Abschussprämie;Kopfprämie
-Abtreten einer Forderung;Forderungsübergang;Gläubigerübergang;Vorkasse
-Judikatur;Rechtspflege;Rechtsprechung;Jurisdiktion
-aufhören (mit);ablassen (von)
-Ausbildungskurs;Ausbildungslehrgang
-Diapositiv;Dia
-anmutig;elegant;geschmeidig;grazil;zierlich;graziös;voller Anmut;edel;zart;gazellenhaft (selten)
-Kanarische Inseln;Kanaren
-aufwinden (fachspr., technisch);hochziehen;hissen
-Jüngelchen (ugs., herablassend);Jüngling (geh., altertümelnd);Bürschchen (ugs., herablassend);Adoleszent;Pubertierender;Teenager;Heranwachsender;Jugendlicher (Hauptform);junger Mensch;Halbstarker (ugs., veraltend)
-Sinnbild;bildlicher Vergleich;Symbol;Metonymie (fachspr., griechisch);übertragener Ausdruck;Metapher (griechisch)
-Welthandelsorganisation;World Trade Organization (engl.);WTO (Abkürzung, engl.)
-Ehrentitel;Höflichkeitstitel
-Tast...;taktil;tastend;haptisch
-Unterbrechung;Unstetigkeit
-in vivo (fachspr.);im lebenden Organismus
-Ernte;Lese;Ernteertrag;Auslese
-Tachykardie (fachspr.);Herzrasen (ugs.)
-gesprenkelt;getüpfelt;fleckig;gepunktet
-(optisch) verbessern;aufmotzen (ugs.);aufbohren (ugs., fig.);aufpolieren (ugs.);tunen (Anglizismus, technisch);aufpeppen;aufblasen (ugs.);frisieren (ugs., technisch);pimpen (Anglizismus, jugendsprachlich);aufmöbeln (ugs.)
-Ämterkauf;Simonie
-Vorkaufsrecht;Option
-Dämmerlicht;Dämmerstunde;Dämmerung
-Brühwürfel;Suppenwürfel
-dickflüssig;schwerflüssig;angedickt;sämig (Hauptform)
-Semikolon;Strichpunkt
-aufstellen;zusammenstellen;einrichten;gliedern;gestalten;anordnen;rangieren;realisieren;ordnen;systematisieren;strukturieren;aufbauen;ausgestalten;arrangieren;aufreihen;anlegen
-Meldung;Neuigkeit;Kunde (geh., poetisch);Nachricht;Zeitung (geh., veraltet)
-Abnegation (geh., veraltet);Desinteresse;Interessenlosigkeit;Apathie (fachspr., griechisch);Gleichmut;Teilnahmslosigkeit;Untätigkeit;Leidenschaftslosigkeit;Indifferenz (lat.);Unempfindlichkeit;Trägheit;Lethargie (griechisch);Saumseligkeit;Phlegma (griechisch);Gleichgültigkeit;Passivität
-Wandschmiererei (derb);Sprühkunst;Graffito;Wandmalerei;Graffiti (Plural)
-Schwingkörper;Membran
-lehren;näherbringen;erklären;beibringen;dozieren;einbläuen (ugs.);unterrichten;vermitteln;beibiegen (ugs., salopp)
-in Beziehung stehen (zu);(sich) beziehen (auf)
-Auftreten;Ankunft;Erscheinen;Eintreffen
-mit großen Schritten gehen;schreiten
-eisig;gefühllos;kaltherzig;hartherzig;empfindungslos;grausam;hart;kalt
-Zeitlimit für eine Sperrung;Sperrzeit
-Containerschiff;Kistendampfer (seemännisch)
-Durchtriebenheit;Findigkeit;Klugheit;Schläue;Schlauheit;Raffinesse
-Tiltrotor;Kipprotor
-schlingen;in eine Schleife legen;in Schleifen legen
-Grabhügel;Tumulus;Hügelgrab
-schnurren;brummen;sirren;summen;surren
-prägen;stempeln
-Batchverarbeitung;Stapelverarbeitung;Batchbetrieb
-stützen;unterstützen;tragen;katalysieren;abstützen
-die Arbeit niederlegen;in Streik treten;streiken;in den Ausstand treten
-Stimmung;Ambiente;Atmosphäre;Klima;Ambiance (schweiz.);Flair;Gepräge;Atmo (ugs.)
-falls;gesetzt den Fall (dass) (geh.);soweit;vorausgesetzt, dass;sofern;sollte (... sich herausstellen, dass o.ä.) (geh.);wenn (Hauptform);für den Fall, dass;unter der Voraussetzung, dass;so (geh., veraltend);solange;vorbehaltlich;gesetzt der Fall (geh.);im Falle, dass;angenommen, dass
-abstellen;hinstellen (ugs.);absetzen;niederstellen;(etwas irgendwo) lassen (ugs.);auf den Boden stellen
-in Erwägung ziehen;mit dem Gedanken spielen (ugs.);erwägen;erachten;in Betracht ziehen
-(das) Feld räumen (müssen) (fig.);(etwas) auf sich beruhen lassen;(einen) Rückzieher machen;(es) aufstecken;(den) (ganzen) Bettel hinwerfen (ugs.);(sich) ins Bockshorn jagen lassen (ugs.);passen müssen;in den Sack hauen (ugs.);(den) (ganzen) Bettel hinschmeißen (ugs.);(sich) geschlagen geben;(es mit/bei etwas) bewenden lassen;nicht weiter versuchen;(etwas) stecken (ugs.);(das) Handtuch werfen (ugs., fig.);abbrechen (ugs.);schmeißen (ugs., fig.);einpacken (können) (ugs., fig.);kapitulieren;klein beigeben;(das) Handtuch schmeißen (ugs., fig.);(die) Brocken hinwerfen (ugs.);(sich) schicken (in) (geh., veraltet);nicht weiterversuchen;(sich dem) Schicksal fügen;(sich mit etwas) abfinden;nicht weiterverfolgen;(die) Flinte ins Korn werfen (ugs., fig.);(die) Waffen strecken (fig.);die weiße Fahne hissen (ugs., fig.);(die) Brocken hinschmeißen (ugs.);aufstecken (ugs.);hinschmeißen (ugs.);(es) aufgeben;(die) Segel streichen (ugs.);resignieren;aufgeben (Hauptform);(den) (ganzen) Krempel hinschmeißen (ugs.);zurückrudern (ugs., fig.);(sich dem) Schicksal ergeben;(sich) beugen;(den) (ganzen) Kram hinschmeißen (ugs.);passen;aufhören zu kämpfen
-Börsenzettel;Börsenbericht;Kurszettel
-rückgängig machen;widerrufen;zurückziehen;richtigstellen;dementieren;zurücknehmen
-Umkehrung;Umpolung
-Elongation (fachspr.);Auslenkung;Schwingungsweite;Amplitude
-Iglu;Schneehütte
-Rubrik;Feld;Cluster (fachspr.);Kategorie;Bereich
-Schwachsinn (derb);Geistesschwäche;Wahnsinn;Irrsinn;Idiotie
-Metaplasie (fachspr.);Umwandlung einer Gewebsart in eine andere
-verketten;im Netz fangen;verstricken;hineinziehen (in);verwickeln
-Regelbarkeit;Steuerbarkeit;Kontrollierbarkeit
-Erwärmung;Aufheizung
-Erdferne;Apogäum
-betrügen;bescheißen (derb);hintergehen
-restaurieren;rekonstruieren;in den alten Zustand zurückversetzen;den alten Zustand wiederherstellen;überholen;in den Originalzustand zurückführen;wieder aufbauen;wiederherstellen;zum Alten machen
-Maßnahmen zur Wiederbelebung;Wiederbelebung;Reanimation
-Vergolden;Vergoldung
-Lehen;Lehensgut
-Fossil;Petrefakt;Versteinerung
-Fixpunkt;Programmhaltepunkt
-Bausteinprinzip;Modularität;Baukastenprinzip
-nachknicken;mit Drehmomentschlüssel nachziehen
-abdampfen;bedampfen;aufdampfen
-Waldhüter;Förster
-platt (ugs.);wohlfeil;banal;hohl (ugs.);seicht;billig (ugs.);ohne Aussage;schal;flau;oberflächlich;nichts sagend;leer;witzlos;abgeschmackt;inhaltsleer;abgedroschen;trivial;beliebig;nichtssagend;geistlos
-Schrumpfung;Schwindung
-Randbemerkung;Zwischenbemerkung;Fußnote (auch figurativ);Marginalie (fachspr.);Randvermerk;Randnotiz;Sternchentext
-Ostsibirien;Jakutien;Sacha
-Hunderennen;Windhundrennen
-forciert (geh.);gezwungen;gequält
-verschwindend wenig;fast nichts (an) (ugs.);sehr wenig;kaum etwas
-Einehe;Monogamie
-flagellieren;peitschen;geißeln;die Peitsche geben;die Knute spüren lassen;auspeitschen;knuten
-Rausch;Ekstase;Trance;Taumel;Verzückung;Zustand absoluter Verzückung;Zustand der Trance;Wahn;(im) Zustand der Euphorie
-Schar;Kolonne;Verband;Gruppe;Geschwader;Abteilung;Kommando;Rotte;Einheit;Formation
-reduzierbar;zurückführbar
-einschalten;miteinbeziehen;hinzubemühen;(mit) einbeziehen;(mit) ins Boot holen (ugs., fig.);beiziehen (süddt.);zu Rate ziehen;konsultieren;(mit) ins Boot nehmen (ugs., fig.);hinzubitten;dazuholen;hinzuziehen
-prozessieren;rechtliche Schritte einleiten;(den) Klageweg beschreiten;(die / seine) Anwälte bemühen;Klage erheben;vor Gericht gehen;(jemanden) verklagen;(jemanden) vor den Kadi zerren (ugs.);vor Gericht ziehen;(eine) gerichtliche Entscheidung suchen;gerichtliche Schritte unternehmen;den Rechtsweg einschlagen;gerichtlich vorgehen (gegen);den Rechtsweg beschreiten;die Gerichte anrufen;(die) Gerichte bemühen;klagen;(etwas) gerichtlich klären lassen;(mit etwas) vor Gericht gehen
-(jemandes) Damaskuserlebnis (geh., fig.);Damaskusereignis (geh.);Erweckungserlebnis;Epiphanie (geh.);(jemandes) Damaskus (geh., fig.);Schlüsselerlebnis (Hauptform);(eine) Offenbarung (für jemanden);Offenbarungserfahrung;Erleuchtungserlebnis;Offenbarungserlebnis
-mildtätig;wohltätig;menschenfreundlich;humanitär
-Gründerzeit;Gründerjahre
-Lesepult;Katheder (geh., veraltend);Bütt (ugs., folkloristisch);Mikrofon (fig.);Kanzel;(närrische) Rostra (veraltend);Rednerpult (Hauptform);Rostra (geh., historisch)
-Tonhöhe;Tonlage
-armes Wesen;Kreatur
-Kitz;Zicklein;Gitzi (schweiz.);Ziegenlamm
-ordnungsgemäß;gesetzmäßig
-Bratspieß;Schaschlikspieß;Spieß
-leidenschaftlich;aufopferungsvoll;hingebungsvoll
-Aufnahmefähigkeit;Empfänglichkeit
-Reißbrett;Zeichenplatte;Zeichenmaschine;Zeichenbrett
-tabuisieren;totschweigen;zum Tabu erklären;mit einem Tabu belegen;für tabu erklären
-Schlecksl (Ortenau) (ugs., regional);Strichi (Elztal) (ugs., regional);Marmelade;Schmärsel (ugs.);Sießschmeer (ugs., regional);Fruchtaufstrich (fachspr.);Gsälz (ugs., schwäbisch);Konfitüre;Guts (Breisgau, Markgräflerland) (ugs., regional)
-Personalien;Angaben zur Person;Personalangaben
-Zuordnungsanweisung;Zuweisungskommando
-Mittelpunkt;Zentrum;Mitte
-bewerkstelligen;stemmen (ugs.);auf die Reihe kriegen (ugs.);meistern;zu Wege bringen;fertigkriegen (ugs.);hinbekommen (ugs.);(etwas) fertigbekommen (Hauptform);auf die Reihe bekommen (ugs.);(einer Sache) beikommen (geh.);hinkriegen (ugs.);bewältigen;fertig werden (mit) (ugs.);auf die Reihe bringen (ugs.);gebacken bekommen (ugs.);zuwege bringen;wuppen (ugs.);auf die Beine stellen (ugs., fig.);deichseln (ugs.);(einer Sache) Herr werden;schultern (ugs., fig.);Wir werden das Kind schon schaukeln. (ugs., Spruch);packen (ugs.);rocken (ugs.);auf die Kette kriegen (ugs.);gebacken kriegen (ugs.);zustande bringen;schaffen;getan kriegen (ugs.)
-Mäzen;Kunstliebhaber
-Hülse;Schale;Lage;Hülle;Schicht;Decke
-Taschenlampe;Handlampe;Handleuchte
-NC (Abkürzung);Numerical Control;numerische Steuerung
-Intention (geh.);Zweck;Vorsatz;Absicht;Ziel
-entbunden werden (von);(einem Kind) das Leben schenken (ugs.);(ein) Baby bekommen;auf die Welt bringen (ugs.);entbinden;niederkommen (mit);gebären;ein Kind in die Welt setzen (ugs.);in den Wehen liegen;kreißen;zur Welt bringen
-Fortdauer;Verbleib;Fortbestand;Verbleiben;Bestand;(das) Bleiben
-Rasterkonvertierungseffekt;Treppenstufen-Effekt;Treppcheneffekt;Treppeneffekt;Treppenstufeneffekt;Stufenbildung
-diskrepant (fachspr.);(in sich) widersprüchlich;inkonsequent;uneinheitlich;folgewidrig;unstimmig;inkonsistent
-Mann Gottes;Gottesmann;Pfarrer;Schwarzrock;Prediger;Hochwürden (Anrede) (geh., veraltet);Pastor;Pfaffe (ugs., abwertend);Priester (Hauptform)
-(eine) Frage von Sein oder Nichtsein;vital;lebensnotwendig;lebenserhaltend;essentiell (fachspr., biologisch);lebenswichtig;überlebenswichtig;(eine) Überlebensfrage;existenziell;essenziell (fachspr., biologisch);(so) wichtig wie die Luft zum Atmen
-Surrogat (fachspr.);Substitutionsgut;Substitut;Ersatzmittel;Ersatz
-lang;weit
-Regulator;Modulator;Regler
-ausschlagen;verwerfen
-Oberweite;Brustumfang
-Dyspareunie (fachspr.);schmerzhafter Koitus
-Vorsteherdrüse;Prostata
-gesundheitliche Einschränkungen;Siechtum (geh., veraltet);gesundheitliche Probleme;gesundheitliche Beschwerden;Gesundheitsbeschwerden;Gesundheitsschaden;Leiden;Gesundheitsprobleme;Maleste(n) (ugs., regional);Beschwerden (ugs.);Erkrankung;Gebrechen;Krankheit;Gebresten (schweiz.)
-Absetzung für Abnutzung;Wertverminderung;Steuerabschreibung;Abschreibung (ugs.)
-Zeugungskraft;(männliche) Geschlechtsreife;Zeugungsfähigkeit;Manneskraft;Mannbarkeit (veraltend);Männlichkeit;Virilität;Potenz
-Luftbildaufnahme;Luftaufnahme;Luftfoto;Luftbild
-Ablaufzeit;Laufzeit
-Ballkleid;Abendkleid;Abendrobe
-jüdischer Geistlicher;Pharisäer (fachspr.);Schriftgelehrter (AT) (fachspr., historisch);jüdischer Priester;Rabbi;Rabbiner;Rebbe
-(voll) erblühen;blühen (auch figurativ);aufblühen (auch figurativ)
-Sponsor;Donator;Spender;Patron;Stifter;Gönner;Geldgeber;Mäzen;Förderer;Finanzier;Wohltäter
-Krabbe;Taschenkrebs
-Diarrhoe (fachspr.);Durchfall;Dünnflitsch (ugs., ruhrdt.);Diarrhöe (fachspr.);flotter Otto (ugs.);Dünnschiss (derb);Flitzkacke (derb);Flitzekacke (derb);Diarrhö (fachspr.);Dünnpfiff (ugs.);(die) Scheißerei (haben) (derb)
-Kabriolett;offener Wagen;Kabrio;Cabriolet;Cabrio
-sprühen;spritzen;sprayen
-Wok;Wokpfanne
-Knatsch (ugs.);Zank;Clinch;Auseinandersetzung;Zwistigkeit;Friktion (bildungssprachlich);Scharmützel;Streit (Hauptform);Gerangel;Klinsch (ugs., regional);Hader (geh.);Hakelei;Differenzen (geh.);Stunk (ugs.);Krach (ugs.);Hickhack (ugs.);Querelen (geh.);Streitigkeit;Rangelei;Zoff (ugs.);Zwist;Geplänkel;Zankerei (ugs.);Streiterei;Reibungen;Wickel (ugs., österr.);Unfrieden
-Staffellauf;Stafette (schweiz.);Staffel
-Akinesie (fachspr.);Unbeweglichkeit;Akinese (fachspr.)
-vernebeln;zudecken;ummänteln;verstecken;verkleiden;verhüllen;tarnen;umnebeln;verdecken;verwischen;verbergen;verfälschen;unter den Teppich kehren (fig.);umhüllen;verschleiern;vertuschen;kaschieren
-veränderlich;beweglich;wandelbar;mutabel;variant (geh.);veränderbar;fluid (geh.);variabel;abwandelbar
-näherkommen;ansteuern;zugehen auf;(sich) bewegen (nach);(sich) nähern
-Kalziumfluorid (fachspr.);Fluorkalzium;CaF2 (fachspr., Abkürzung, chemisch);Flussspat;Fluorit (Hauptform);Calciumfluorid (fachspr.)
-schonen;pfleglich behandeln
-Absicherung;Sicherung;Wahrung
-Stuhl;Wurst (ugs.);Losung (Jägersprache);Fäzes (fachspr.);Kacke (derb);Kot;Scheiße (derb);Ausscheidung;Fäkalien (Plural);Exkrement (fachspr.);Haufen (ugs.)
-das öffentliche Klima;veröffentlichte Meinung (fachspr.);Vox populi (lat.);Volkes Stimme;öffentliche Meinung;Stimmung in der Öffentlichkeit;Meinung;Bevölkerungsmeinung;Urteil der Öffentlichkeit
-rahmen;umranden;einfassen
-Passstift;Zylinderstift
-Etagenpyramide;Tempelturm;Stufenpyramide
-pruriginös (fachspr.);juckend
-Tuberkulostatikum (fachspr.);Mittel gegen Tuberkulose
-baggern;schippen;schaufeln;buddeln;graben;ausheben
-Akathisie (fachspr., griechisch);Sitzunruhe;Tasikinesie;dauernde Bewegungsunruhe;psychomotorische Unruhe
-Medienplanung;Werbeplanung
-Dreifuß;Stativ
-Beize (badisch, schweiz.);Schenke;Tanke (ugs.);Destille (ugs., berlinerisch);Schänke;Tavernwirtschaft (veraltet);Beisel (ugs., ostösterreichisch);Bierkeller;Dorfkrug (norddeutsch);Schankwirtschaft;Kneipe;Taverne (fachspr., veraltet);Beiz (ugs., schweiz.);Bierpalast (veraltet);Tafernwirtschaft (fachspr., veraltet);Spunte (Graubünden) (ugs.);Stampe (berlinerisch);Wirtshaus (ugs., bayr., Hauptform, österr.);Schwemme (ugs.);Gasthaus (ugs., südösterreichisch);Lokal;Bar;Wirtschaft;Boiz (Neckarraum) (ugs., selten);Pub (engl.);Boaz (Tirol, vereinzelt) (ugs.);Gaststätte (Hauptform);Taferne (fachspr., veraltet);Tränke (ugs.);Pinte (ugs., ruhrdt., veraltend)
-(ein) paar Brocken (von einer Fremdsprache) (ugs.);ein bisschen was an / von (ugs., regional);(ein) Mü (ugs.);(ein) Funken (ugs.);(eine) kleine Menge;(eine) geringe Menge;(eine) Spur;(ein) Tick (ugs.);(ein) klein bisschen (ugs.);(ein) Fitzel(chen) (ugs.);(ein) Gran;(ein) bissel (ugs.);(ein) Hauch von (lit.) (geh.);(eine) Prise (auch figurativ);(ein) bisserl (ugs., süddt.);ein wenig (geh.);(ein) büschen (ugs., norddeutsch);wat (ugs., ruhrdt., salopp);(a) bissle (ugs., schwäbisch);(ein) bisschen;(ein) klein wenig;(ein) Quäntchen;(eine) Idee;a Muggeseggele (ugs., schwäbisch);(ein) kleines bisschen;(ein) My (ugs.);(ein) Schuss (ugs.);etwas (ugs.);etwas an (ugs.);(eine) Kleinigkeit (ugs.);'n bissken (ugs., ruhrdt.);(ein) Tacken (ugs.);(ein) Spritzer (ugs.)
-körperliche Überforderung;Überarbeitung;Überanstrengung;Überlastung (Hauptform)
-Plattierung;Doublieren;Plattieren;Dublieren
-Arbeitsplatzwechsel;Jobwechsel;Stellenwechsel
-Gepäckträger (z.B. am Bahnhof);Lastträger;Kuli;Lastenträger;Bagagist (Hotel) (fachspr.)
-Wandel;Umbruch;Transition;Übergang;Austausch;Wandlung;Wechsel
-Fahrstuhl;Aufzug;Aufzugsanlage;Lift
-passt auf, dass niemand ihm zu nahe kommt;unnahbar;unfreundlich;abweisend (Person);ablehnend;distanziert;lässt niemanden an sich heran
-ein Spiegelbild sein;widerspiegeln (Hauptform);zum Ausdruck bringen;erkennbar werden lassen;sich spiegeln
-menschenähnliche Züge zusprechen;vermenschlichen;anthropomorphisieren
-Briefklammer;Büroklammer
-Greifbarkeit;Verständlichkeit
-ohne Menschen;bedienungsfrei;unbemannt;ohne Personal
-Tendenz;systematischer Fehler;Bias;Verzerrung;systematische Abweichung
-Blister(ver)packung;Sichtverpackung;Durchdrückpackung;Blister (ugs., Hauptform);Schrumpffolienverpackung;Klarsichtpackung
-Kriminalroman;Krimi
-Abrechnungsperiode;Abrechnungszeitraum
-unverfälscht;authentisch;genuin;original;ursprünglich;originär;unverändert;echt;gestanden
-im Augeninnern;intraokular
-Charakteristikum;Eigenschaft;Duktus;Eigentümlichkeit;Kennzeichen;Merkmal;Manier;Charakterzug;Wesenszug;Spezifikum (fachspr.);Wesensmerkmal;Attributivum (fachspr., linguistisch);Besonderheit;Eigenart;Attribut;Eigenheit
-Erziehungsberechtigte(r);Sorgeberechtigte(r);Elternteil;(ein) Vater bzw. eine Mutter (ugs.);Elter (fachspr.)
-schmale Linie an den Enden von Druckbuchstaben;Serife
-Schwellung;Beule;Horn (ugs., fig.);Dippel (ugs., österr.)
-biologisch verwandt;leiblich;eigen;genetisch verwandt (fachspr.);blutsverwandt (Hauptform);(mein) eigen Fleisch und Blut;verwandt
-einrechnen;einplanen;einkalkulieren;in Rechnung stellen;berücksichtigen (Hauptform);einbeziehen;in Betracht ziehen;integrieren;in Erwägung ziehen;in Anschlag bringen (geh.);erwägen;mit einbeziehen;aufgreifen;(einer Sache) Rechnung tragen;einpreisen (fig.);einberechnen
-Split;Splitter;Steinsplitter
-Geldklemme;leere Kassen;Ebbe;leere Taschen;finanzielle Schwierigkeiten;Geldverlegenheit;Geldnot;finanzielle Notlage;Illiquidität
-Mehrbenutzersystem;Mehrplatzsystem
-affirmieren (fachspr.);Ja sagen zu;bestätigen;bejahen;grünes Licht geben (ugs.);gutheißen;mitziehen;bekräftigen;unterschreiben;zustimmen;(sein) Okay geben;(sich) einverstanden erklären;für gut befinden
-Arterienverkalkung (ugs.);Arteriosklerose (fachspr.);Arterienverhärtung (ugs.)
-Aggravation;Verschlimmerung
-Verfalldatum;Freigabedatum
-Abstufung;Ausdehnung;Maß;Weite;Ausmaß;Umfang;Größe;Maße (veraltet)
-grüne Minna (ugs.);Streifenwagen;Polizeiauto;Funkstreifenwagen;Peterwagen (ugs.);Toniwagen (DDR, historisch)
-verweltlichen;säkularisieren
-Spender;Verteiler;Abroller;Austeiler
-ungeschützt;verletzlich;verwundbar;angreifbar;empfindlich
-Pegel;Wasserpegel;Wasserstand
-Hospiz;Sterbehaus;Sterbeklinik
-Durchschreibpapier;Pauspapier;Kohlepapier;Durchschlagpapier
-Taumel;Vertigo;Schwindel
-Standpunkt;Anschauung;Sichtweise;Aspekt;Auffassung;Blickwinkel;Betrachtungsweise;Sicht der Dinge;Überzeugung;Verständnis;Position;Meinung;Ansicht;Haltung;Einstellung
-Ausflug;Spritzfahrt;kurze Reise;Tagestour;Spritztour;Tour;Kurztrip;Trip
-spillerig (ugs., norddeutsch);nichts zuzusetzen haben (ugs.);hager;dünn;dürr;schmächtig;knochig;schmal;mager;untergewichtig (medizinisch);leptosom (fachspr.);dystroph (fachspr., griechisch);nichts auf den Rippen haben (ugs.);schlaksig (abwertend)
-dispergieren;(sich) verbreiten;diffundieren;ausströmen;(sich) vermischen;(sich) vermengen
-Gegenmutter;Klemmmutter;Kontermutter
-Schwingungszahl;Frequenz
-unangemessen;nicht dazugehörend;inadäquat;unangebracht;unpassend;am falschen Ort;fehl am Platze;aus der Zeit gefallen;kontraindiziert (med.) (fachspr.);unsachgemäß;fehl am Platz;am falschen Platz;unverhältnismäßig;deplatziert;verfehlt
-Scoop (engl.);Hammer (ugs.);Knüller (ugs.);Exklusivmeldung;tolles Ding (ugs.);Knaller (ugs.);Exklusivbericht;Sensationsmeldung
-Blutgefäße betreffend;vaskulär
-Erwerbung;Erlangung
-Machthaber;Herrscher;Potentat;Gebieter;Herr;Monarch;Regent;Souverän
-Sirokko;Schirokko;Scirocco
-Böttiger;Fassmacher (Hauptform);Böttner;Pinter;Schäffler;Tonnenmacher;Binder;Bender;Simmermacher;Fassbinder (österr.);Kübler;Küfer (Hauptform);Kuper (niederdeutsch);Schedler (alemannisch);Fassler;Fässler;Doleatoris (lat.);Böttcher;Gentner (fränk., historisch, schwäbisch);Küffner;Küper (niederdeutsch);Büttner
-Soor;Schwämmchen
-Entity (engl.);Entität;Dateneinheit;Satzinhalt eines Datenbanksegmentes
-Kleienflechte;Pityriasis (fachspr.)
-Plötzlichkeit;Jähheit
-Kontaktbolzen;Brücke
-Beschreiung;Bann;Zauber (Bann);Zauberspruch;Verhexung;Behexung
-Amulett;Anhänger;Schmuckanhänger
-zehnteilig;Zehner...;dekadisch;auf die Zahl 10 bezogen
-Effektenhandel;Wertpapierhandel;Aktienhandel
-zusammenschnüren;verknüpfen;zusammenbinden
-Sanierung;Altlastensanierung
-zuführen;überbringen;zustellen
-(etwas) bereiten (geh.);zurechtmachen;fertig machen;präparieren;herrichten;hinrichten (ugs., süddt.);bereit machen;rüsten (für) (geh., veraltend);zurichten (ugs., landschaftlich, veraltet)
-geradlinig;Reihen...;in einer Linie;linear
-schlagen;verwichsen (ugs.);einprügeln (auf);(die) Hand erheben (gegen);(sich) vergreifen an;abschwarten (ugs.);versohlen (ugs.);einschlagen (auf);windelweich prügeln (ugs.);(jemandem) eine Abreibung verpassen (ugs.);(jemandem) die Hucke vollhauen (ugs.);(jemandem) rutscht die Hand aus (ugs.);vermöbeln (ugs.);verdreschen (ugs.);verkloppen (ugs.);verprügeln (Hauptform);verhauen (ugs.);eindreschen (auf)
-am Brustkorb;den Brustraum betreffend;thoracal (fachspr.);thorakal (fachspr.)
-(jemanden / etwas) autorisieren;(jemanden) berechtigen (Sache);(jemanden) mandatieren (juristisch, veraltet);(jemandem) die Befugnis erteilen (etw. zu tun) (geh.);(jemandem) das Recht geben (zu);(jemanden) bevollmächtigen;(jemanden) ermächtigen
-abhalten (Treffen, Versammlung);ausrichten;austragen (Wettkampf);veranstalten
-jungenhaft (Frau);krachledern (fig.);burschikos (insbesondere von Frauen);hemdsärmelig;im Holzfäller-Stil;wie ein Mann
-Gehemmtheit;Verklemmtheit;Befangenheit;Unsicherheit;Hemmung;Schüchternheit
-anschwärzen (ugs.);(jemanden) in eine bestimmte Ecke stellen (fig.);(jemandem etwas) nachsagen;(über jemanden negative) Behauptungen in die Welt setzen;schmähen;in Misskredit bringen (fig.);in Verruf bringen;verleumden;diskreditieren;schlecht reden (über);herabsetzen;(jemandem etwas) ans Zeug flicken (ugs., veraltend);(sich) in herabwürdigender Weise äußern (über);(jemandem) die Ehre abschneiden;kein gutes Haar lassen (an) (ugs.);(jemandem etwas) andichten (ugs.);Lügen verbreiten (über);(jemandem etwas) unterstellen;(jemanden) ins Gerede bringen;verunglimpfen;diffamieren;(jemandem etwas) anhängen (fig.);schlechtmachen;(jemanden) mit Dreck bewerfen (ugs.);(jemandem etwas) am Zeug flicken (ugs., veraltend)
-Krankentrage;Tragbahre (ugs.);Trage (Hauptform)
-auseinander gehen;auseinander laufen;auseinander streben;aberieren
-Einsamkeit;Verlassenheit;Alleinsein
-Grubenarbeiter;Kumpel (ugs.);Bergarbeiter;Bergmann
-Zentiliter;hundertstel Liter
-erweitern;nachrüsten;ausbauen;ergänzen
-pomadig (ugs.);müßig;passiv;tatenlos;faul;träge;untätig;phlegmatisch;bequem
-hieven;hochziehen;aufnehmen;aufheben;hochheben;emporheben;anheben;heben;stemmen;wuchten
-Sprachgewandtheit;Redegewandtheit;Redekunst;Rhetorik
-nicht für die (Augen der) Öffentlichkeit bestimmt;intim;privat (Hauptform);(jemandes) eigenster (eigenste, eigenstes) (geh.);nicht öffentlich;persönlich;vertraulich
-Endung;Kasusendung
-einfließen lassen;insinuieren;durchblicken lassen;zu verstehen geben;zu erkennen geben;(die) Erwartung äußern (dass);erkennen lassen;andeuten;einen zarten Hinweis geben (ironisierend);anklingen lassen;durchklingen lassen;anzeigen;signalisieren;(einen) Wink geben;(jemandem etwas) bedeuten (dass / zu + Inf.) (geh.);mit dem Zaunpfahl winken (ugs., fig.)
-Gnade;Erbarmen;Gunst;Mitleid
-beschwingt;munter;wohlgelaunt;gut gelaunt (Hauptform);aufgeräumt;von Freudigkeit erfüllt (geh.);fröhlich;guter Dinge (geh.);lustig;freudig erregt;wildvergnügt;unverdrossen;frisch, fromm, fröhlich, frei (selten, veraltend);heiter;immer munter;fidel;erheitert;vergnügt;bumsfidel (derb);wohlgestimmt;frohen Mutes (geh.);freudetrunken (geh., altertümelnd);gutgelaunt;bester Laune;beglückt;froh gelaunt;wild vergnügt;frohgemut;gut drauf (ugs.);ausgelassen;launig;gut aufgelegt (ugs.);quietschfidel (ugs.);(sich) pudelwohl (fühlen);voller Freude;mopsfidel (ugs.)
-plündern;herfallen über;ausrauben;ausplündern
-Untiefe;Sandbank;seichte Stelle;Furt
-frei flottierend (ugs.);nicht persistent;volatil;mal so, mal so (ugs.);flüchtig;nicht kalkulierbar;unbeständig;sprunghaft;sporadisch;unstet;nicht vorhersehbar;nicht in der Konstanz;nicht kontinuierlich;floatend (fachspr.);schwankend;nicht durchgängig (zu beobachten)
-eingeläutet (journal.);angefangen;angebrochen;begonnen
-Schnitzer (ugs.);Stilblüte
-Abdeckplatte;Deckplatte;Deckblech
-Violine;Geige;Fiedel (ugs.);Fidel (ugs.)
-Lendenschurz;Lendentuch
-abwischen;putzen;wegwischen;abstauben;entstauben
-Inkassofirma;Inkassounternehmen;Inkassobüro
-Milchmann;Milchhändler
-durcheinander;verstört;entgeistert;neben der Rolle sein (ugs.);von allen guten Geistern verlassen (ugs.);fassungslos;derangiert (geh., franz.);verwirrt (Hauptform);neben sich stehen;tüdelig (ugs.);konfus
-Nomogramm;Netztafel
-Viertel;Ortsteil;Stadtviertel;Stadtteil (Hauptform)
-undurchdringlich;nicht zu durchblicken;unergründlich;undurchschaubar
-tyrannisch;diktatorisch;selbstherrlich;despotisch;unterdrückerisch;repressiv
-jemandes Zuhause sein;(sein) Zuhause haben;(irgendwo) hocken (ugs., salopp);(irgendwo) zu Hause sein;leben;(etwas) sein Zuhause nennen;residieren (geh.);hausen (abwertend);wohnen (Hauptform)
-Aue;Niederung;Au
-Anreicherung von Gasen und Dämpfen;Adsorption
-ahnungsvoll;vorausahnend;visionär;vorahnend
-Entziehung;Abjudikation (juristisch, veraltet);Aberkennung;Entzug
-Steuerrückerstattung;Steuererstattung
-im Anmarsch sein (ugs., fig.);(sich irgendwohin) bemühen (geh., förmlich);(sich) blicken lassen (bei) (ugs.);im Anflug sein (ugs., fig.);einlangen (österr.);aufschlagen (ugs., fig., scherzhaft-ironisch);anmarschiert kommen (ugs.);andackeln (ugs.);(irgendwo) einschweben (ugs., fig., ironisch);ankommen;anwackeln (ugs.);(sich irgendwo) herbemühen (förmlich);angeschoben kommen (ugs., salopp, variabel);(sich) einfinden;erscheinen;(sich irgendwo) hinbemühen;(irgendwohin / irgendwo / irgendwoher) kommen (Hauptform);eintreffen;auftauchen (ugs.);anreisen (fachspr.);antanzen (ugs.);(sich) einstellen;um die Ecke kommen (ugs., fig.);(irgendwo) aufkreuzen (ugs., Hauptform);anrücken (fachspr., Jargon)
-Luftführung;Luftströmung;Luftstrom
-protokollieren;aufnehmen;aufzeichnen;mitschneiden (Radio-/Fernsehsendung);loggen (fachspr.)
-Vordruck;Formblatt;Antrag;Formular
-prämatur;nicht ausgereift;unausgereift
-Staatsdiener;Bediensteter;Beamter;Staatsbediensteter
-Problemkreis;Problemzone;Problemfeld
-Anwalt sein;Anwaltspraxis ausüben
-Frigidität;Geschlechtskälte (historisch);Nicht-Erregbarkeit
-später holen;nachholen
-Schafblattern;Varizellen (fachspr.);Wilde Blattern;Varizella (fachspr.);Windpocken (Hauptform);Feuchtblattern;Wasserpocken;Spitze Blattern
-abgemildert;gemildert
-feinschleifen;honen
-ergründen;Licht ins Dunkel bringen (fig.);erforschen;klären;aufklären (Hauptform);enträtseln;untersuchen;aufhellen;Licht in eine Angelegenheit bringen (fig.);entschlüsseln
-(jemandem ist) schwer ums Herz;gedankenschwer;melancholisch;schwermütig;voller Wehmut;wehmütig;voller Weltschmerz;wehmutsvoll
-Begräbnis...;Leichen...
-Chutney;gewürzte Fruchtpaste
-Rasenplatz;Rasen
-unabhängig;auf eigene Faust (ugs.);in Eigenregie;in eigener Regie;selbständig;in eigener Verantwortung;auf eigene Rechnung (ugs.);auf eigenes Risiko;eigenständig;im eigenen Namen;selbstbestimmt;selbstverantwortlich;eigenverantwortlich;auf eigene Verantwortung;auf die eigene Kappe (ugs.);autark;autonom;selbstständig
-fehlender Nachschub;Verknappung (von);Unterversorgung (mit);Versorgungsproblem(e bei);Mangel (an) (Hauptform);Seltenheit;Engpass (fig.);Knappheit;(das) Fehlen (von)
-hopphopp (ugs.);rapide;schnell (Adverb) (Hauptform);speditiv (schweiz.);rasch;haste was kannste (ugs., veraltend);eilig;subito (ugs.);munter;zügig;flink;rapid;eilends (geh.);schleunig(st);flott;in lebhafter Fortbewegungsweise (ugs., ironisch);mit einem Wuppdich (ugs.);zackig (ugs.);fix (ugs.);behänd(e);flugs;mit Schmackes (ugs., regional);hurtig;geschwind (veraltend);mit Karacho (ugs.);dalli (ugs.);umgehend (geh., Schriftsprache, kaufmännisch)
-Mitglied des Landtages;Landtagsabgeordneter;MdL (Abkürzung)
-Stornierung;Storno;Auftragsstornierung
-blamabel;daneben (ugs.);hochnotpeinlich (ugs., Verstärkung);cringe (ugs., engl., jugendsprachlich);(jemandem) unangenehm;vor Scham im Boden versinken (fig., variabel);(jemandem) die Schamesröte ins Gesicht treiben (fig.);beschämend;peinlich (Hauptform);cring(e)y (ugs., engl., jugendsprachlich)
-Meistbietender;meistbietender Käufer;Höchstbietender
-derzeit;heute;gegenwärtig (geh.);dieser Tage (geh., Papierdeutsch);zurzeit;Stand jetzt;im Moment (ugs.);jetzo (veraltet);in diesen Tagen;zum gegenwärtigen Zeitpunkt;in der Gegenwart;jetzt;nunmehro (veraltet);momentan (Hauptform);heutzutage;zur Zeit;nun;aktuell;zzt. (Abkürzung, förmlich)
-Aussteller;Trassant
-(öffentlich) anschlagen;aushängen
-VEB (Abkürzung);volkseigener Betrieb (DDR)
-Statist;Komparse
-interstitiell (fachspr.);dazwischenliegend
-Lagerzapfen;Wellenlager
-querab;rechtwinklig zum Kiel
-Wirtschaftslage;Konjunktur;Konjunkturlage
-Fettanreicherung im Blut;Lipämie
-Erregung;Exzitation (fachspr.)
-süchtig machend;suchterzeugend
-Schreibstift;Stift;Schreiber
-ein Nischendasein führen;ein Mauerblümchendasein führen (ugs.);wenig Beachtung finden;ein Mauerblümchendasein fristen (ugs.);im Schatten stehen;unbeachtet bleiben (Hauptform);im Verborgenen blühen (positiv);ein Schattendasein führen
-(ein) Schweinegeld kosten (ugs.);sehr teuer (Hauptform);sündhaft teuer;ein Vermögen kosten (fig., übertreibend);(viel Geld) verschlingen (variabel);(einen) irren Haufen Geld kosten (ugs.);sauteuer (ugs.)
-Ritze;Fuge;Spalt;Spalte;Schlitz
-ergiebig;profitabel (Hauptform);renditestark (teilweise werbesprachlich);lohnend (ugs.);rentierlich;gewinnbringend;lukrativ (geh.);Gewinn bringend;ertragreich;einträglich;einbringlich (geh.);rentabel;zugkräftig
-Erfassungszeitraum;Bezugsperiode
-missbrauchen (für) (negativ);schamlos ausbeuten (abwertend);(mit jemandem/etwas) Schindluder treiben (ugs., abwertend);zweckentfremden;ausnutzen (zu);ausnützen;missbräuchlich verwenden;nicht bestimmungsgemäß gebrauchen;(jemanden) (nur) benutzen (negativ)
-kontradiktorischer Gegensatz;ausschließende Disjunktion;Bisubtraktion;ausschließendes Oder;Alternation;Kontravalentor;antivalente Disjunktion;Kontrajunktion;vollständige Disjunktion;exklusives Oder;Antivalenz;Kontravalenz;Entweder-Oder
-Läute;Schelle;Glocke;Klingel
-Adhäsion (fachspr.);Verklebung;Verwachsung;Anziehung
-Konvergenz;Abstimmung;Angleichung;Annäherung
-Nützlichkeit;Nutzen;Gebrauchsfähigkeit;Utilität (geh.)
-nach (+ Firmenname, nicht-standardsprachlich) (ugs., norddeutsch);nach;zu (Hauptform)
-die Kinderheilkunde betreffend;kinderärztlich;pädiatrisch
-brutzeln;knistern (Feuer)
-Figurine;Statuette;Figürchen
-unterbinden;zensieren;nicht gestatten;ausschließen;nicht erlauben;untersagen;prohibieren (geh.);verbieten (Hauptform);zensurieren (schweiz., österr.)
-Fusion;Vereinigung;Unternehmenszusammenschluss (Vorgang);Zusammenschluss;Verschmelzung;Zusammenlegung;Unternehmensverbindung;Merger (fachspr.)
-Fortbildung;Weiterbildung;Schulung;Training
-Gehaltsklasse;Gehaltsstufe
-Hauptstrasse (schweiz.);Landesstraße (fachspr., Amtsdeutsch);Staatsstraße (fachspr., Amtsdeutsch, regional);Kreisstraße (fachspr., Amtsdeutsch);Landstraße (Hauptform);Städteregionsstraße (fachspr., Amtsdeutsch);(außerörtliche) Bundesstraße;Autostraße;Fernstraße;Überlandstraße
-(sich) nicht unterkriegen lassen (ugs.);(den) Mut nicht sinken lassen;(die) Stellung behaupten;(den) Kopf oben behalten (fig.);(sich) nicht ins Bockshorn jagen lassen;(sich) senkrecht halten (fig.);(sich) behaupten;nicht den Mut verlieren;(sich) nicht kleinkriegen lassen (ugs.);(die) Ohren steif halten (ugs.);(die) Hoffnung nicht aufgeben;kämpfen (fig.)
-Enzym;Biokatalysator (fachspr.);Ferment (veraltet)
-Plaque (fachspr.);Zahnbelag;Belag
-Wertzeichenpapier;Banknotenpapier
-Konverter;Zwischenstück;Passstück;Zwischenteil;Adapter;Anpassungseinrichtung;Zwischenstecker
-mit Schadenfreude sagen;(sich) hämisch freuen
-besudeln (ugs., fig.);beschmutzen (fig.);beschimpfen;herunterputzen (ugs.);vom Leder ziehen (ugs.);durch den Kakao ziehen (ugs., fig.);in den Dreck ziehen (ugs., fig.);niedermachen;beflecken;abwerten;verächtlich machen;herabwürdigen;zur Schnecke machen (ugs., fig.);insultieren (geh., selten, veraltend);dissen (fachspr., Jargon, Neologismus, jugendsprachlich);herabsetzen;beleidigen
-Manuskript;Satzvorlage;Textgrundlage (für den Satz)
-Währungseinheit;Währungsunion
-überstehen;überleben;über den Berg kommen (ugs., fig.);durchstehen
-ausführen;bewirken;leisten;zugange sein (ugs.);(etwas irgendwie) fahren (u.a. Arbeitwelt) (fachspr., Jargon);durchführen;schmeißen (ugs.)
-Staffelpreis;gestaffelter Preis
-die Gewebevermehrung hemmend;antiproliferativ (fachspr.)
-abschrauben;demontieren;abbauen
-bösartig;maligne (fachspr.)
-Konkupiszenz (fachspr., lat.);heftiges Verlangen;Lust (auf);Begierde;Gier;Begehren;Begehrlichkeit;Geilheit
-Schlund;Gurgel;Kehle
-(sich) zustimmend äußern;Ja sagen (zu);zusagen;nichts (mehr) auszusetzen haben (an);konsentieren (veraltet);akzeptieren;einwilligen;(etwas) abnehmen (z.B. Handwerkerleistung) (fachspr.);(sich) einverstanden erklären (mit);zustimmen;(sein) Einverständnis erklären;annehmen;Gnade vor jemandes Augen finden (geh., ironisch);einverstanden sein (mit);bejahen;billigen
-überliefert;herkömmlich;überkommen (geh.);traditionell;angestammt;altüberliefert;althergebracht;altehrwürdig;klassisch;hergebracht;tradiert;von Alters her (geh.);konventionell;gebräuchlich
-Mehltau;Brand;Braunfäule
-abdrängen;verdrängen;beiseitedrängen
-improvisierend;ungeprobt;noch nie vorher geübt;prima vista (fachspr.);vom Blatt (spielen)
-(sich) ausbreiten;(sich) propagieren;(sich) verbreiten
-schwurbelig (ugs.);blümerant (ugs.);schwiemelig (ugs.);schwindlig;schwurblig (ugs.);schwindelig
-statt;sondern;anstelle (von);stattdessen;anstatt;für;an Stelle (von);zugunsten;statt dessen
-DKP (Abkürzung);Deutsche Kommunistische Partei
-Nachgebührauftrag;Nachbelastungsauftrag
-lichtbeständig;lichtecht (Farbe)
-nebenher;zugleich
-Versilberung;Versilbern
-Bw;Bahnbetriebswerk;Betriebswerk
-Flöz;Schicht;Nutzschicht
-beschleunigen (= schneller werden);in Schwung kommen (ugs., auch figurativ);ins Rollen kommen (fig.);flotter werden;an Tempo zulegen;in Fahrt kommen (ugs., auch figurativ);abgehen (ugs.);schneller werden (Hauptform);Tempo aufnehmen;auf Touren kommen (ugs., auch figurativ);an Fahrt gewinnen;Fahrt aufnehmen (auch figurativ)
-Altersstufe;Altersklasse;Lebensphase;Alter;Entwicklungsstadium (fachspr., biologisch);Lebensalter;Lebensabschnitt
-Anfangsphase;Anfangsstadium
-Biotechnik;Biotechnologie;Biotech
-(saftige) Klatsche (ugs., fig., journalistisch);Versagen;Schlappe;Pleite (auch figurativ);Satz mit X (ugs.);Niederlage;Rückschlag;Bauchlandung (fig.);Bruchlandung (fig.);Schlag ins Wasser (ugs., fig.);Reinfall (ugs.);Crash (ugs., engl., fig.);Scheitern;Schiffbruch (erleiden) (fig.);Flop (ugs.);Griff ins Klo (ugs., fig., salopp);Fehlschlag (Hauptform);Misserfolg (Hauptform);Fehlversuch;schallende Ohrfeige (fig., journalistisch, politisch);Schuss in den Ofen (ugs., fig.);Rohrkrepierer (ugs., fig.)
-Rauchwaren;Pelzwaren
-Moin! (ugs., norddeutsch);hallöle! (ugs., schwäbisch);Tach auch. (ugs., ruhrdt.);Zes (ugs., Bregenzerwälderisch);hallihallo! (ugs., scherzhaft);Tag! (pragmatisch) (ugs.);Tagchen (ugs.);hey! (ugs., jugendsprachlich);hallo! (ugs.);Glück auf! (ugs., erzgebirgisch);Servus! (ugs., süddt.);hoi! (ugs., schweiz., österr.);hallöchen! (locker, leicht humorvoll) (ugs.);Moin Moin! (ugs., norddeutsch);hi! (ugs., engl.);guten Tag;Zeawas (ugs., Bregenzerwälderisch, vorarlbergerisch)
-für;zu Gunsten von;pro;zum Vorteil von;zu (jemandes) Nutz und Frommen (geh., veraltet);zum Besten von
-Kimm;Kimmwinkel
-Nieren schädigend;nephrotoxisch (fachspr.)
-Ethnologie;Völkerkunde
-Poststempel;Stempel
-hinzukommen;hinzunehmen;beifügen;addieren;hinzufügen;hinzurechnen;ergänzen
-Aufwärtstrend;Konjunkturanstieg
-zurzeit;zzt. (Abkürzung)
-(Thema) berühren;(auch) Thema sein;anreißen;nebenbei behandeln;(auch) zu sprechen kommen auf;(kurz) ansprechen;(Thema) streifen;antönen (schweiz., österr.);(Thema) kurz anfangen;andeuten;erwähnen
-Anschlagbrett;Anschlagtafel;Schwarzes Brett
-Beleidigung;böse Zungen (sagen o.ä.);Verhöhnung;Verbalinjurie (geh., bildungssprachlich);Invektive (geh., bildungssprachlich);Schmähung (geh.);Injurie (geh., bildungssprachlich);Beschimpfung
-Flugwesen;Luftfahrt;Aeronautik (griechisch, veraltet);Fliegen;Fliegerei;Flugkunst;Aviatik (lat.)
-(in einen Hausanzug / in Ordenstracht / schlicht ...) gewandet (sein) (geh.);(elegant / schlecht / warm) angezogen sein;bekleidet sein (mit);angezogen haben (Kleidung);(sich) (schick / nach der neuesten Mode / leger / ...) kleiden;(sich irgendwie) gekleidet haben;(irgendwie) gekleidet sein;(sich) (auffällig / ganz in Schwarz / ...) gewanden (geh.);(in / mit etwas) herumlaufen (ugs., salopp);(etwas) tragen (Kleidung) (Hauptform);anhaben (Kleidung) (ugs.)
-geistesabwesend;konfus;zerstreut;gedankenlos
-gestört;instabil
-verwittern;dem Wetter aussetzen;verwittern lassen;auswittern
-Frucht;Obst
-ändern;editieren;verändern;abändern;modifizieren;bearbeiten;abwandeln
-Anschlusstreffer;Anschlusstor
-Busch;Strauch;Gesträuch (leicht abwertend);Nanophanerophyt (fachspr.)
-Einschlag;Impakt
-pekuniär;wirtschaftlich;in finanzieller Hinsicht;geldlich;kohlemäßig (ugs.);in barer Münze (ugs.);finanziell;was das Geld angeht (variabel);in Sachen Geld;monetär
-Ischiassyndrom;Ischias (ugs.);Ischialgie
-anbräunen;anbraten;braun werden lassen
-Woiwodschaft (polnisch);Distrikt;Zone;Kanton (schweiz.);Rayon;Department;Kreis;Bezirk;Bereich;Region;Areal;Gebiet;Sektor
-Verbrechen;Kriminalität
-NGO (Abkürzung, engl.);nichtstaatliche Organisation;Nichtregierungsorganisation
-Autoindustrie;Automobilindustrie
-Tülle;Ausguss;Schnauze (einer Kanne) (ugs.);Schnaupe;Ausgießer;Schnabel
-Nachtgeschirr;Boddschamber (ugs., bayr.);Pisspott (ugs., ruhrdt.);Nachttopf;Botschamber (ugs., bayr.)
-Akontozahlung;Abschlagszahlung;Zahlung a conto;Anzahlung;Akonto (schweiz., österr.)
-Schiebehubdach;Schiebedach
-unzuverlässig;wortbrüchig;windig (ugs.);unsolide
-Rost;Grill;Bratrost
-treulos;untreu;unzuverlässig
-etwas auszusetzen haben (an);einen Fehler finden (an)
-Beschuldigter;Beklagter (fachspr.);Angeklagter (fachspr.)
-Stirnbrett;Traufbrett;Sparrenabdeckung
-Auswerter;Problemanalytiker;Analytiker;Analyst (Anglizismus)
-wie zum Beispiel;per exemplum (geh., lat.);bspw. (Abkürzung);wie etwa;(oder) meinetwegen;(...) oder so (ugs.);zum Exempel (geh., veraltend);(...) und so (ugs.);e. g. (geh., Abkürzung, lat., selten);wie;exemplarisch;zum Beispiel;so (etwa);etwa;sagen wir mal (vorangestellter Einschub);par exemple (geh., franz., veraltet);z. B. (Abkürzung);nur (mal) als Beispiel (ugs.);beispielsweise
-Realisierung;Verwirklichung;Ausgestaltung;Durchführung;Implementierung;Gestaltung;Einrichtung;Umsetzung
-zuzeln (ugs., bayr., österr.);zutzeln (ugs., bayr., österr.);nuckeln;aussaugen;auslutschen;suckeln (ugs.);saugen;ziehen
-es ja haben (ugs.);zahlungskräftig;auf großem Fuße lebend (ugs.);steinreich;bemittelt;reich (Hauptform);(finanziell) gut dastehen (variabel);was an den Füßen haben (ugs.);vermöglich (schweiz.);finanzstark;gutbetucht;bessergestellt;betucht;wohlhabend;begütert;wohlsituiert;Geld wie Heu (haben) (ugs.);potent (ugs.);gut situiert;mit richtig Geld (auf der Tasche) (ugs., regional);geldig (ugs., süddt.);gutsituiert;schwerreich;mit gut Geld (ugs., salopp);finanziell gut gestellt;(eine) gute Partie (sein);vermögend;gut betucht;finanzkräftig;auf einem Haufen Geld sitzen (ugs.);stinkreich;besitzend;superreich;in Geld schwimmen (ugs., fig.);(mit) ordentlich Patte (ugs., salopp)
-Betriebsstilllegung;Betriebsschließung
-Dozent;Hochschullehrer;Gelehrter
-Laufwerk;Gerät;Einheit (ugs., Anglizismus)
-Nähgarn;Nähfaden;Nähzwirn
-in Rente schicken;pensionieren
-nicht vertretbar;keiner Diskussion würdig;diskussionsunwürdig;tadelnswert;ausgeschlossen;nicht haltbar;niemandem zuzumuten;nicht tragbar;intolerabel;unhaltbar;untragbar;nicht hinzunehmen;unannehmbar;unzumutbar;indiskutabel;nicht hinnehmbar;geht zu weit;inakzeptabel;nicht akzeptabel (Hauptform)
-waschen;spülen
-Filmaufnahme;Videoaufnahme;(das) Video (ugs., Hauptform);Videoaufzeichnung
-Dipl. (Abkürzung);Diplomurkunde;Diplom
-Jubiläum;Jubeljahr
-Linguist;Sprachwissenschaftler
-(sich) genötigt fühlen;(sich) gemüßigt fühlen;(sich) veranlasst fühlen
-einsenden;zuschicken;übermitteln (an);zusenden;(jemandem etwas) zuleiten;senden;schicken (an);zukommen lassen;übersenden;einschicken;senden (an)
-Mostpresse;Entsafter;Obstpresse;Kelter;Saftpresse;Fruchtpresse;Moster
-Flüchtling;Vertriebener
-Aufzählung;Katalog;Datenbank;Syllabus (fachspr., selten);Liste;Register;Aufstellung;Verzeichnis;Auflistung;Tabelle;Gliederung
-Exemplar;Kopie;Vervielfältigungsstück
-Raumzeitalter;Weltraumzeitalter
-(sich) die Hörner abstoßen (ugs., fig.);(sich) austoben;(eine) wilde Zeit haben;über die Schnur hauen (ugs.);über die Stränge schlagen (ugs.)
-objektiv;vorurteilsfrei;detachiert;sachlich
-Anlagenumsetzung;Vermögensübertragung
-Puffer;Zwischenablage;Cachespeicher;Cache;Datenpuffer;Pufferspeicher;Cache-Memory;Zwischenspeicher
-Diplomingenieur;Dipl.-Ing. (Abkürzung)
-hopsen;jumpen (norddeutsch);hüpfen;hoppeln;springen
-Ankerwinde;Ladewinde;Winde
-ausspähen (nach);Ausschau halten (nach);ausschauen (nach);aufpassen (auf);erwarten;(jeden Moment) rechnen (mit)
-weit gehend;grundsätzlich;zusammenfassend;in der Gesamtheit;summa summarum (lat.);in Summe;auf einen Nenner gebracht (ugs.);im Allgemeinen;alles in allem;generell;im Grundsatz;ich sag' jetzt mal (resümierend) (ugs.);im großen Ganzen;wenn man alles berücksichtigt;im Großen und Ganzen;in der Regel;insgesamt;insgesamt gesehen;in der Summe;weitgehend
-eine(r) von uns sein;zählen zu;(integraler) Bestandteil sein (von);mit von der Partie sein (ugs.);gehören zu;(ein) Teil des (/ der) ... sein;Mitglied sein;zugehörig sein;eine(r) der ihren (geh.);gerechnet werden zu;dazugehören;angehören;(ein) Teil sein (von)
-Näherin;Weißnäherin
-Nase;Bolzen;Keil
-finzelig (ugs.);beschränkt;krämerisch;beckmesserisch;engherzig;haarspalterisch;kleingeistig (Hauptform);kleinkariert;kleinlich;krämerhaft;borniert
-Wiederholbarkeit;Reproduzierbarkeit (Hauptform);Nachvollziehbarkeit;Replizierbarkeit (fachspr.);Reliabilität (fachspr.)
-geschäftlich;ökonomisch;wirtschaftlich
-Biegung;Krümmung;Schleife (eines Flusses);Knick;Kurve
-Exerzierplatz;Übungsplatz
-reizend;lieb;liebenswürdig;ansprechend;sympathisch;umgänglich;konziliant;nett
-Herzkammer der Demokratie (ugs., fig.);Bundestag (bundesdeutsch);Abgeordnetenkammer (südtirolerisch);heilige Hallen der Demokratie (ugs.);Parlament (Hauptform);Abgeordnetenhaus;Nationalrat (schweiz., österr.);Nationalversammlung;Volksvertretung;Landtag (liechtensteinisch);Große Kammer (schweiz.)
-wiedererkennen;wiederkennen;erinnern;erkennen
-Verwendbarkeit;Verfügungsrecht;Disposition
-Druckbegrenzungsventil;DBV;Überdruckventil
-Scherversuch;Schubversuch
-bewegen;(jemanden für etwas) einnehmen (ugs.);indoktrinieren;überzeugen;beeinflussen;(jemanden für etwas) erwärmen (ugs.);(jemanden) zu überzeugen versuchen;persuadieren (geh.)
-Aushärtung;Härten
-Sanktionierung (fachspr.);Ahndung;Bestrafung;Züchtigung;Strafverhängung;Strafmaßnahme;Bebußung (fachspr.);Strafe
-fusionieren;zusammenfügen;vereinen;verbinden;vereinigen;arrangieren;zusammenlegen;zusammenbringen;verschmelzen;kombinieren;(etwas) zusammenführen (Hauptform)
-Gelenksabnutzung;Arthrose (fachspr.);Gelenkverschleiß (ugs.);Arthrosis (fachspr.);Gelenksverschleiß
-Crashkurs (ugs.);Schnellkurs;Kurzlehrgang;Intensivlehrgang;Intensivkurs
-Vorrecht;Alleinverkaufsrecht
-Zephir;Zephyr;feiner Baumwollstoff
-Kompasskurs;Steuerkurs
-Unigelände;Universitätsgelände;Campus
-Präzision;Genauigkeit;Exaktheit;Akkuratesse;Akribie;Gründlichkeit
-Alleinherrscher;Absolutist;Autokrat;Despot;Diktator
-abzahlbar;tilgbar
-vergeblich (Hauptform);außer Spesen nichts gewesen (ugs., Spruch);verlorene Mühe;dabei kommt nichts (he)rum (ugs.);(sich) nicht lohnen (ugs.);nicht lohnen (ugs.);fruchtlos (Anwaltsdeutsch) (fachspr., Jargon);(sich) die Mühe sparen können (ugs.);frustran (medizinisch) (fachspr.);erfolglos;umsonst;vergebens;vergebliche Liebesmüh (ugs.);kannst du vergessen (ugs.);für den Arsch (derb);kannst du knicken (ugs.);verlorene Liebesmüh (ugs.);Versuch am untauglichen Objekt (fachspr., auch ironisch, juristisch);da kommt nix bei rum (ugs., salopp);für nichts und wieder nichts (ugs.);für die Tonne (ugs.);(an/bei jemandem/etwas ist) Hopfen und Malz verloren (ugs.);ohne Erfolg;verlorene Zeit (sein);für die Katz (ugs.);(sich etwas) sparen können (ugs.)
-Gleichförmigkeit;Gleichheit;Identität
-Grundstimmung;Grundfarbton;Grundton
-Referenzpunkt;Vergleichspunkt;Bezugspunkt
-rechtens;rechtmäßig;rechtssicher (fachspr.);statthaft;zugelassen;gesetzlich;berechtigt;legal;legitim;dem Recht entsprechend;nach Recht und Gesetz;nach dem Gesetz;rechtlich einwandfrei;zulässig;gesetzeskonform;erlaubt
-Wams (ugs.);Joppe;Janker (österr.);Rock (Jagd, Forst);Schamper (österr.);Jacke;Kittel (ugs., alemannisch)
-(sich) entfernen;davonziehen (altertümlich);enteilen (altertümlich);(sich) verdünnisieren (ugs., scherzhaft);(sich) empfehlen (geh.);verduften (ugs.);sich auf Französisch empfehlen (geh.);abhauen (ugs.);entfleuchen (literarisch, scherzhaft);(sich) davonmachen (ugs.);(sich) selbständig machen (scherzhaft);auf und davon gehen;sich auf Französisch verabschieden (ugs.);(sich) zurückziehen;abdampfen (ugs.);abzischen (ugs.);plötzlich weg sein (ugs.);(sich) retirieren (geh., veraltet);sich unbemerkt verabschieden;(sich) absentieren (geh., veraltend);(sich) von dannen machen (geh., literarisch);weggehen (sich entziehen) (Hauptform);verschwinden
-ermutigen;animieren;anspornen;motivieren;beflügeln
-unter einem ungünstigen Stern;unter einem unglücklichen Stern
-Fünfjahrplan;5-Jahres-Plan;Fünfjahresplan
-schmatzen (ugs., Hauptform);geräuschvoll kauen;knatschen (ugs., landschaftlich);mampfen (ugs.)
-Einhaltung;Einverständnis;Befolgung;Anerkennung;Zusage;Zustimmung
-waschen;abwaschen
-Aktivposten;Vermögensgegenstand;Anlagengegenstand;Anlagegegenstand;Vermögenswert
-ungetrübt;durchscheinend;durchsichtig;transparent;klar
-nicht in Abrede zu stellen (geh.);unabweisbar (geh.);unwiderlegbar;zweifelsfrei;nicht zu leugnen;unangreifbar;hart (Fakten) (ugs., fig.);unwiderleglich;nicht zu widerlegen;unzweifelhaft;unbestreitbar;zwingend;unleugbar;unbezweifelbar;unanfechtbar
-Radfahrer (fig.);Arschkriecher (derb);Kriecher;Byzantiner (geh., veraltend);Schleimi (ugs.);Schranze (geh., veraltet);Hofierer;Lobhudler;Wurm (veraltet);Speichellecker (derb);Liebediener (geh.);Schmeichler;Schleimscheißer (derb);Schleimer (ugs., Hauptform);Stiefellecker (derb);Steigbügelhalter (geh.)
-(sich) verstärken;erstarken;sich festigen;stärker werden;(sich) vertiefen
-Nephritis (fachspr.);Nierenentzündung
-einsam;verlassen;trostlos
-übertrieben kritisch;scharf;hart
-voraussichtlich;prädiktiv (fachspr.);(sich) anbahnend (ugs.);vorhersagbar;berechenbar;abzusehen;vorherzusehend;absehbar;voraussehbar;vorauszusehend;prognostizierbar (fachspr.);voraussagbar;vorhersehbar
-Hilfsmittel;Arbeitsgerät;Betriebsmittel;Utensil;Instrument
-Zauntritt;Klapptritt (Handelsbezeichnung);kleine Klappleiter;Trittleiter (Hauptform);Fußleiter
-periorbital (fachspr.);um die Augenhöhle gelegen
-ungehalten (über);unduldsam
-Mariä Lichtmess;Lichtmess
-versehen;ausstatten;bestücken;ausstaffieren;befüllen;ausrüsten;wappnen
-Lebenshaltungskostenindex;Lebenshaltungsindex
-Blütenstempel;Pistill (fachspr.)
-global;irdisch
-Presseabteilung;Pressestelle
-(in sich) schlüssig;widerspruchsfrei;überzeugend;logisch;konsequent;in sich geschlossen;stimmig;folgerichtig;kohärent (fachspr., bildungssprachlich);folgerecht (veraltend);denkrichtig;stringent
-(jemandem) grell ins Gesicht leuchten (variabel);überstrahlen;glänzen;grell leuchten;blenden
-Zunahme;Wachstum;steigende Tendenz;Zuwachs;(das) Anwachsen;Mehrung;Anstieg;Steigerung;Vergrößerung
-infundieren (fachspr., lat., medizinisch);hineinkippen;einflößen
-Gefallen haben an;Gefallen finden an;(etwas) auskosten;(sich) erfreuen (an) (geh.);baden in (ugs.);(sich) sonnen (in) (fig.);(sich) suhlen in (fig., negativ);genießen
-mau (ugs.);beschissen (derb);prekär (geh.);schlecht (Hauptform);mies (ugs.);schwach;übel;nicht (so) rosig (ugs.);bescheiden (ugs., verhüllend)
-aus der Not geboren (ugs.);Provisorium;Übergangslösung;kein Dauerzustand;Workaround (IT-Technik, engl.);Verlegenheitslösung;Umgehungslösung;Notbehelf;Notstopfen (ugs.);Zwischenlösung;Behelfslösung;Baumarktlösung (ugs., fig.);vorübergehender Zustand;provisorische Lösung;Notlösung
-Wedel;Farnkrautwedel
-(sich) einen Wohnsitz nehmen;(sich) niederlassen
-Satzzeichensetzung;Interpunktion;Zeichensetzung
-angeben;(die) Behauptung aufstellen;erklären;geltend machen;vortragen (vor Gericht);aussagen;behaupten
-Hinzufügung;Ergänzung;Beifügung;Zugabe;Beimengung;Hinzunahme;Beimischung;Extra;Zusatz
-Gesichtsrose;Kopfrose;Herpes zoster (fachspr.);Gürtelrose (ugs.)
-Kalk entfernen;entkalken
-hinwerfen;skizzieren;mit ein paar Strichen hinwerfen
-Track (fachspr.);Komposition;Titel;Musikstück;Lied (ugs.);Stück (ugs., Hauptform)
-pyogen (fachspr.);Eiter bildend
-Dünger;Mist;Dung
-ehrenwert;ehrenvoll;ehrenhaft;ehrbar;ehrsam (veraltend);honorig (veraltend)
-geradeaus;geradlinig;direkt;ohne Umweg;ohne Umwege;frontal
-Modernisierung;Ajourierung (geh.);Renovation (schweiz.);Aktualisierung;Renovierung;Aufarbeitung;Erneuerung
-Artikel;Textstelle;Abschnitt;Passage;Paragraph;Passus;Paragraf;Absatz;Textabschnitt;Kapitel
-Trassee (schweiz.);Trasse;Schiene;Fahrweg;Spur;Bahn;Fahrbahn;Schienenstrang
-Rundfunksendung;Hörfunksendung;Radiosendung;Rundfunkübertragung
-ansengen;versengen;anbrennen;ankokeln (ugs.)
-Moorantilope;Litschi-Moorantilope
-garstig (ugs.);nicht nett;unfreundlich;muffelig (ugs.);unterkühlt;pampig (ugs.);mürrisch;kurz angebunden (ugs.);mufflig (ugs.)
-(immer) einen Schritt voraus sein;übertreffen;(Rekord) schlagen;den Vogel abschießen (ugs.);überbieten;toppen (ugs.);(Rekord) brechen;(etwas/jemanden) in den Schatten stellen (fig.)
-haften;pappen (ugs.);kleben
-zurückweisen;annullieren;entkräften;außer Kraft setzen
-unaufmerksam;gedankenlos;unbedacht;unüberlegt;vorschnell;unbesonnen;blindlings;in meinem jugendlichen Leichtsinn (ugs., ironisch)
-Umschlag;Abdeckung;Hülle;Schalung
-niederhageln;niederprasseln;niederregnen
-Knöchel;Fessel;Fußknöchel;Fußgelenk
-voll stopfen;vollstopfen;ausstopfen;ausfüllen;füllen
-erwiesenermaßen;nachgewiesenermaßen;fest steht, dass (variabel);nachweislich
-anovulatorisch (fachspr.);ohne Eisprung
-Zellulose;Cellulose;Zellstoff
-wehrdiensttauglich;wehrfähig
-Photozelle;Fotozelle;Lichtwiderstand;Selenzelle
-Putz;Aufputz;Verputz
-korrespondierend;einheitlich;in Analogie zu;entsprechend;kommensurabel (geh., lat.);kongruent (geh., lat.);parallel;gleichzusetzen (hinsichtlich);gleichartig;übereinstimmend;analog;vergleichbar;ähnlich;komparabel;gleichermaßen
-arithmetisch-logische Einheit;Arithmetic Logic Unit (engl.);ALU (fachspr., Abkürzung, engl.);Arithmetik-Prozessor
-Homosexuelle;Lesbierin;Lesbe (ugs., Hauptform)
-gottverdammt (ugs., salopp);verdorri! (ugs., regional);Kacke! (derb);verdammt! (ugs.);verdammter Mist! (ugs.);Fuck! (derb, engl.);verfluchte Hacke! (ugs.);Scheißdreck! (derb);Himmel, Arsch und Zwirn! (ugs.);gottverflucht (ugs., salopp);Himmel, Gesäß und Nähgarn! (ugs., ironisch);Verdammt noch mal! (ugs.);Himmel Herrgott Sakra! (ugs.);Himmel, Arsch und Wolkenbruch! (ugs.);verdelli! (ugs., regional);Teufel auch! (ugs.);Mann! (ugs.);Scheiße! (derb);gottverdammmich (ugs., salopp);Himmel nochmal! (ugs.);Scheibenhonig! (ugs., verhüllend);Verflucht noch mal! (ugs.);Donner und Doria! (ugs., veraltend);verdammte Scheiße! (derb);Verdammt nochmal! (ugs.);Verdammt und zugenäht! (ugs.);verflixt und zugenäht! (ugs.);Schiet! (ugs., norddeutsch);Himmel Herrgott! (ugs.);Teufel noch eins! (ugs.);Scheibenkleister! (ugs., verhüllend);Mist! (ugs.);Mensch! (ugs.);Kruzitürken! (ugs.);zum Teufel nochmal! (ugs.);Schitte! (derb, norddeutsch)
-abdichten;ausfugen;fugen;verstreichen
-Gebrechlicher;Invalide;Pflegefall
-Stimme (Musik, Hauptform);Part;Stimmlage
-Drillich;Drell
-schöpfen;löffeln
-Ordinalzahlwort;ordnendes Zahlwort;Ordnungszahl;Ordinale;Ordnungszahlwort;Ordinalzahl (Hauptform)
-wechselseitig beeinflussend;interaktiv
-Blutpfropfbildung;Thrombose (fachspr.)
-Stellenausschreibung;Stelle;Stellenanzeige;Job;Vakanz;Stellenangebot
-Strophe;Gedichtabschnitt;Vers;Absatz
-Indikator;Gradmesser (Hauptform);Zeichen;Hinweis;Beleg
-Vielfraß (ugs.);Fresssack (derb);Nimmersatt;Fresser
-umgehen (mit);handhaben;leiten;hantieren (mit);handeln (engl.)
-Antriebsrad;Laufrad
-getreu;vertrauenswürdig;loyal;ergeben;treu;treu ergeben;treugesinnt;zuverlässig;treulich
-Schraubklemme;Quetschhahn
-Manuskript;Schriftstück;Dokument
-proaktiv;Initiative ergreifend;initiativ
-heimgesucht (von);behaftet (mit);ergriffen
-verwirrend;abstrus;opak;schwer verständlich
-Tuwa;Tuva;Tuwinien
-Unfall;Unglück
-tiefgreifend;wirksam;leistungsfähig;schlagkräftig;verlustfrei (fachspr.);wirkungsvoll;durchschlagend;effektiv;drastisch;verlustarm (fachspr.);effizient;einschneidend;rationell;mit hohem Wirkungsgrad (fachspr.);überzeugend
-Schlenker (ugs., fig.);Umschweif;Exkurs (geh., bildungssprachlich);Abstecher (ugs.);Abschweifung;Einschub
-Wasser abstoßend;Wasser abweisend;Wasser meidend;hydrophob
-freimachen (Brief);frankieren
-Erysipel (fachspr.);Rotlauf;Wundrose
-verkleiden;auskleiden (mit);umhüllen;einmummeln (ugs.);verschalen;umkleiden;ummanteln;bedecken
-verwalten;administrieren;führen
-Ernährungswissenschaftler;Ernährungsfachmann
-Ungleichmäßigkeit;Schiefe;Unebenheit;Asymmetrie
-reizen;rühren
-unbekannt;fremd;(ein) unbeschriebenes Blatt (fig.);anonym
-Vulva (fachspr.);Yoni (fachspr.);Venusspalte (vulg.);Pussy (ugs.);Muschi (ugs.);Vagina (fachspr.);Scheide;Spalte (vulg.);Haartruhe (vulg., Rotwelsch);Votze (vulg.);Loch (vulg.);Fut (vulg.);Möse (vulg.);Fotze (vulg.)
-Wappenbild;Wappen
-kraushaarig;gekräuselt (Haare);krüsselig (ugs., regional);krisselig (ugs., regional);kraus;gekraust
-kipp(e)lig;nicht fest;wackelig (ugs.);nicht standfest;auf unsicheren Füßen stehend;unsicher;instabil;wacklig
-Freizeitpark;Spaßpark;Vergnügungspark
-ausscheren;austreten;aussteigen
-auf einen Schlag;sofort (ugs.);auf Anhieb (Hauptform);auf den ersten Streich;aus dem Stand;(schon) auf den ersten Hieb;spontan (ugs.);gleich beim ersten Mal;ad hoc (geh., lat.)
-retrograd;rückgebildet;zeitlich oder örtlich zurückliegend
-über (ugs.);unter Zuhilfenahme von;mittels;mit Hilfe (von);mit;durch;qua;vermittelst;per;anhand;unter Einsatz von;via;mithilfe;vermittels
-zusammenfügen;paketieren
-abtasten;betastend untersuchen;abfühlen;palpieren (fachspr., medizinisch)
-Brust;Brustkasten;Thorax (fachspr.);Heldenbrust (männl., scherzhaft);Brustkorb
-Unterstrich (Hauptform);Underscore (fachspr., engl.);Grundstrich
-Wirkungslosigkeit;Unergiebigkeit;Zwecklosigkeit;Sinnlosigkeit;Unverwertbarkeit;Vergeblichkeit;Entbehrlichkeit;Unbrauchbarkeit;Nutzlosigkeit
-häuslich;geruhsam;friedvoll;lauschig;harmonisch;heimelig;malerisch;beschaulich;idyllisch
-Plackerei (ugs.);Mühsal (geh., veraltend);Plagerei (ugs.);Maloche (ugs.);Quälerei;Schufterei;Kärrnerarbeit (fig.);Arbeit für jemanden, der Vater und Mutter erschlagen hat (ugs., fig.);Rackerei (ugs.);Sträflingsarbeit (fig.);Strapaze;Sklavenarbeit (fig.);Tortur (fig.);Schwerarbeit;Knochenjob;Schlauch (ugs.);harte körperliche Arbeit;schwere Arbeit;Schwerstarbeit;Steine klopfen (derb, fig.);Knochenarbeit;Schinderei
-Abrichtlineal;Lineal (Hauptform);Maßstab (ugs.);Zeichenmaßstab
-Gutschein;Kupon;Coupon
-bewahren;verewigen;erhalten;wahren;eternisieren (geh., veraltet)
-Mic (Kurzform, engl.);Mikrophon;Mikrofon;Mikro (ugs., Kurzform);Schallaufnehmer
-mit normalem Blutdruck;normotensiv (fachspr.)
-Privileg;Sonderrecht;für jemanden gelten andere Gesetze (ugs.)
-Beschwerde;Missfallensbekundung (geh.);Unmutsäußerung;Missfallensäußerung
-vulnerabel;verletzlich;prädisponiert;anfällig;empfänglich
-Schalbrett;Schwartenbrett
-Coitus interruptus (fachspr.);aufpassen (ugs.)
-Handarbeiter;Handwerker (Hauptform);Büezer (schweiz.)
-aufwachsen;wachsen;groß werden;heranwachsen;sprießen
-Graben;Falte;Vertiefung;Riefe;Mulde;Furche;Spur
-gefügig;biegsam;weich
-Bau;Gebäude;Bauwerk;Gemäuer;Gebäudlichkeit (geh., altertümelnd, scherzhaft-ironisch)
-leugnen;verweigern;ableugnen;nicht gesagt haben wollen (variabel);desavouieren (geh., franz.);nicht wahrhaben wollen;nichts (mehr) wissen wollen (von) (ugs.);von sich weisen;nicht anerkennen;für nicht zutreffend erklären;verneinen;widersprechen;(in aller Schärfe) zurückweisen (Verstärkung);dementieren;anfechten;von der Hand weisen;abstreiten (Hauptform);(sich) distanzieren (von) (geh.);Einspruch erheben;in Abrede stellen;(sich) verwahren (gegen);in das Reich der Fabel verweisen (geh.);bestreiten
-tabellarische Aufstellung;tabellarische Anordnung
-haarig;behaart
-Springflut;Springtide
-UNDCP;Programm der Vereinten Nationen für die Internationale Drogenbekämpfung
-die Eingeweide betreffend;viszeral (fachspr.)
-parken;abstellen (Fahrzeug);(etwas irgendwo) lassen (ugs.);parkieren (schweiz.);stehenlassen (ugs.)
-Zahnschmelz;Substantia adamantinea (fachspr.);Schmelz
-Märzenbecher (regional);Osterglocke;Gelbe Narzisse;Trompeten-Narzisse;Osterglöckchen;Falscher Narzissus
-Antiasthmatikum;Mittel gegen Asthma
-Falschausrichtung;Ausrichtungsfehler
-gehasst;verhasst
-Oberschulbildung;Gymnasialbildung;höhere Schulbildung
-wonach;worauf
-üble Nachrede;Verunglimpfung;Rufmord;Verleumdung
-Sachverständiger;Routinier;Fachidiot (ugs., abwertend);Fachkraft;Meister;Profi;Könner;Sachkundiger;Fachperson;Spezialist;intimer Kenner (einer Sache) (geh.);Kenner;Kenner der Materie;Fachmann;Experte;Kapazunder (ugs., österr.);Ass (ugs.);Kapazität;(einer) vom Fach (sein);Sachkenner;(ein/e ...) von hohen Graden (geh.);Fässle (ugs., schwäbisch)
-düster;schwarz;dunkel;finster
-Aufschlag;Revers;(das) Fasson
-problemorientiert;problemnah
-äußere Erscheinung;Aussehen;Look (Jargon, engl.);Erscheinung;(äußeres) Erscheinungsbild;äußere Merkmale;Apparenz (geh., ausgestorben, bildungssprachlich, lat.);Äußeres (das Äußere)
-Schriftsatzmaß;Kegelhöhe;Kegelstärke;Schriftgrad
-Ungleichförmigkeitsgrad;Drehzahlschwankung;Gleichlaufschwankung
-adjungierte Gleichung;Hilfsgleichung
-im Innersten;im Grunde genommen
-für etwas bezahlt werden (ugs.);(einen Fall) auf dem Schreibtisch liegen haben (ugs., fig.);(jemandem) obliegen (fachspr., Amtsdeutsch);betraut (mit) (geh.);Sache (des / der ...) sein;in jemandes Händen liegen (geh., fig.);(für etwas) verantwortlich (sein);befasst (mit) (fachspr., Amtsdeutsch, Jargon);in jemandes Zuständigkeitsbereich fallen;(jemandes) Aufgabe sein;(jemandes) Zuständigkeit unterliegen;zuständig (für);(jemandes) Job sein (ugs., salopp);in jemandes Zuständigkeit fallen;zu jemandes Obliegenheiten gehören (geh.);in jemandes Verantwortung liegen (geh.);in jemandes Ressort fallen (fig., veraltend);zu jemandes Aufgaben gehören;gefragt sein (ugs.)
-Ernst;Ernsthaftigkeit;Humorlosigkeit
-untersuchen;sichten;inspizieren;beschauen;durchsehen
-Vorgeschichte;Prähistorie;Vorzeit;Urgeschichte
-Headline (engl.);Titel;Überschrift;Kopfzeile
-rüber;herüber
-ahnden;strafen;belangen;zur Verantwortung ziehen;bestrafen;maßregeln;abstrafen (geh.)
-ausgenommen;minus;weniger;abgezogen;ohne;unter Abzug von;abzgl. (Abkürzung);ungerechnet;abgerechnet;abzüglich;nicht gerechnet;außer
-von (...) an;ab da (ugs.);fürderhin (geh., veraltet);seither;seit diesem Zeitpunkt;hinfort (geh., veraltet);danach;seitdem (Hauptform);seit (...);seit damals;in der Folge;fortan;nach (...);von da an;seit dieser Zeit;von dem Zeitpunkt an (als);von Stund an (geh., veraltend);von diesem Zeitpunkt an
-Abzahlung;Teilzahlung (Hauptform);Abschlagszahlung;Abschlag (fachspr., veraltend);Ratenzahlung (Hauptform)
-Fühler;Antenne
-entladen;freisprechen;entlassen
-kleiner Brocken;kleiner Batzen;Bröckchen;Klümpchen
-Kollegium;Rat
-Anwendungsmöglichkeit;Anwendbarkeit;Eignung
-Gram;Trauer;Kummer
-somatisch (fachspr.);körperlich;physisch
-Laboratorium (geh.);Labor
-Konterschlag;Konter;Gegenschlag;Gegenangriff
-Anklage (Strafrecht);Klage (Zivilrecht)
-böse;gemein;gehässig;bösartig;giftig (ugs.);gallig;ätzend;zynisch;aggressiv;boshaft
-sinnlich;scharf (ugs.);knackig;wohlgeformt;mit heißen Kurven (ugs.);atemraubend;(sexuell) attraktiv (Hauptform);aufreizend;(die) Hormone in Wallung bringen(d);reizvoll;rassig (ugs., veraltet);Männerherzen höher schlagen lassen(d);aufregend;heiß (ugs.);erregend;Lust machen(d);Fantasien auslösen(d);von ansprechender Körperlichkeit (geh.);(ihre) weiblichen Reize zur Geltung bringen(d);erotisierend;erotisch;kurvig (ugs.);(die) Blicke auf sich ziehen(d);(die) Hormone ankurbeln(d) (ugs.);stimulierend;wohlproportioniert;lecker (ugs., fig.);betörend (geh.);atemberaubend;zum Anbeißen;lasziv (geh.);(sexuell) reizend;(sexuell) ansprechend;sexy (engl.);geil (ugs.);knusprig (ugs., fig.);wohlgestaltet;verführerisch;aphrodisierend (geh.);Phantasien auslösen(d)
-Maß für den Informationsgehalt;Entropie (fachspr., griechisch);Maß der Unordnung;Maß für die Unkenntnis der Zustände aller einzelnen Teilchen
-Schleimhautentzündung des Darms;Enterokolitis
-Fröbelstern;gefalteter Adventsstern
-kunstfertig;gekonnt;mit (großem) Geschick;von kundiger Hand (gestaltet / entworfen / gefertigt ...);professionell (adverbial);kunstreich;gewandt;geschickt;mit großem Können;kunstvoll;kunstgerecht
-Indienstnahme;Benutzung;Einsatz;Ergreifung (von Maßnahmen);Verwendung;Inanspruchnahme;Gebrauch;Nutzung;Anwendung
-das Kleinhirn betreffend;zerebellar (fachspr.)
-UNRISD;Forschungsinstitut der Vereinten Nationen für soziale Entwicklung
-fletschern (ugs.);nagen;abnagen;kauen
-estnisch;estländisch
-teufen (ugs., plattdeutsch, regional);abpassen;zuwarten;ausdauern;harren;beharren;(sich) in Geduld üben;(sich) gedulden;(sich) in Geduld fassen;ausharren;warten (Hauptform);abwarten;nicht ungeduldig werden (ugs.)
-stopfen;dichtmachen
-Typ (ugs.);Herr;Keule (ugs., positiv, regional, salopp);männlicher Mensch (biologisch);Macker (ugs.);erwachsene männliche Person (fachspr., Amtsdeutsch);Patron (halb-scherzhaft oder abwertend);Mannsperson;Mannsbild;männliche Person (fachspr., Amtsdeutsch);Vertreter des männlichen Geschlechts;Mann (Hauptform);Dude (ugs., engl.);gestandener Mann;Y-Chromosom-Träger (halb-ironisch);Bursche (regional);Kerl (ugs.);Person männlichen Geschlechts (fachspr., Amtsdeutsch)
-einwickeln;einhüllen;einsacken;einpacken;eintüten;verpacken;einschlagen
-achtbar;ehrbar;bewundernswert;anerkannt;reputierlich (veraltet);Anerkennung verdienend;rühmenswert;Dank verdienend;lobenswert;verdienstlich;verdienstvoll;dankenswert;beachtenswert;anerkennenswert;verdient;bewunderungswürdig (geh.);reputabel (geh., selten, veraltend)
-herunternehmen;abschöpfen
-Xanthopsie (fachspr.);Gelbsehen
-ikterisch (fachspr.);gelbsüchtig
-wahnsinnig;übergeschnappt (ugs.);verrückt;ausgelassen;abgefahren (ugs.)
-Spieluhr;Spieldose
-fasten;hungern
-Schmatzer (ugs.);Knutscher (ugs.);Kuss;Schmatz (ugs.)
-prepaid (engl.);per Vorkasse bezahlt;im Voraus bezahlt;vorausbezahlt
-Musikhochschule;Konservatorium
-niedergeschlagen;unbefriedigt;gefrustet (ugs.);geknickt (ugs., fig.);fertig mit der Welt (ugs.);frustriert;enttäuscht
-Kaufpreis;Einkaufspreis
-Chiffre;Verschlüsselung;Chiffrierung
-Skilift;Schilift
-Oberbürgermeister;OB
-Schlacht (veraltet);Schlagd (veraltet);Werche (schweiz., süddt., österr.);Stauwehr;Wuhr (schweiz., süddt., österr.);Wehr;Stauwerk
-wässern;befeuchten;anfeuchten;nass machen;netzen;feucht machen;nässen
-nussbraun;haselnussbraun
-mollig;mopsig;rundlich;dicklich;drall;moppelig (ugs.);pummelig (ugs.);prall
-Offensichtlichkeit;Offenkundigkeit
-Knalleffekt (fig.);Unabwägbarkeit;Überraschung;unerwartetes Ereignis;Donnerschlag (fig.);Paukenschlag (fig., Hauptform);Unvorhersehbarkeit;Überraschungsmoment
-bei;c/o;wohnhaft bei (Adresse)
-bösartiges Geschwulst;Sarkom (fachspr., griechisch);Fleischgewächs
-Erforscher;Untersuchender
-Aufwaschwasser;Abwaschwasser;Spülwasser;Spülicht (veraltend)
-Urethra (fachspr.);Harnröhre
-überhitzen;überheizen;heißlaufen
-Miosis (fachspr., griechisch);Pupillenverengung
-Dame;Damespiel
-Tribünenplätze;Tribüne;nicht überdachte Zuschauertribüne
-Zeltbahn;Wagendecke
-(für jemanden) der (die) richtige sein;(zu jemandem) passen;(für jemanden) geeignet (sein)
-plastisch;lebensnah;sinnfällig;farbig;lebendig;anschaulich;illustrativ;bildhaft
-in Anbetracht (des / der ...);hinsichtlich;vor dem Hintergrund;in Bezug auf;angesichts dessen;dies in Rechnung gestellt (geh.);im Hinblick auf;mit Rücksicht auf;angesichts;in Anbetracht der Tatsache (dass);mit Bezug auf;vor diesem Hintergrund;angesichts der Tatsache (dass)
-(wieder) zusammenflicken (fig.);durchbringen;erfolgreich therapieren;(wieder) hochpäppeln;gesund machen;aufpäppeln;wiederherstellen;wieder auf die Beine bringen;heilen;auskurieren;kurieren
-in der Nase bohren;popeln (ugs.)
-Plansoll;Soll;Zielwert;erwünschte Ausprägung
-vergleichen (mit);Parallelen ziehen;in eins setzen (geh.);auf eine Stufe stellen (mit);gleichsetzen
-(sich) herausbilden;(sich) ergeben (aus);(sich) herleiten (aus);resultieren (aus);Form annehmen (aus);(das) Ergebnis sein (von);(seinen) Niederschlag finden (in);folgen (aus);(sich) einstellen (aus);(sich) entwickeln (aus);(sich) herauskristallisieren;hervorgehen (aus);basieren (auf)
-geizig;schrappig (ugs., ruhrdt.);kniepig (ugs., norddeutsch);knickerig (ugs.);zugeknöpft (ugs., fig.);sitzt auf seinem Geld (ugs.);preisbewusst (positiv);(sehr) sparsam;filzig (ugs.);knickrig (ugs.);knauserig
-Erblindung;Verblendung
-Neuritis (fachspr.);Nervenentzündung
-(jemanden) verraten (an);(jemanden) in die Pfanne hauen (ugs., salopp);ans Messer liefern (ugs.);Verrat üben (an) (geh.);Verrat begehen (an)
-Stellschraube;Verstellschraube
-(sich) abrackern (ugs.);(sich) mühen (geh.);(sich) abquälen;(sich) abfretten (ugs., süddt.);(sich) abschinden;(sich) abmühen;(sich) schinden;(sich) abarbeiten;(sich) fretten (ugs., süddt.);(sich) herumschlagen (mit) (fig.);(sich) abplagen
-Figaro (geh., scherzhaft);Hair-Stylist;Haarschneider;Coiffeur (schweiz.);Friseur;Frisör
-isolieren;separieren;zerteilen;vereinzeln;trennen;zerstreuen
-Tutu;Röckchen;Ballettröckchen
-rechthaberisch;mit dem Anspruch unbedingter Gültgkeit (auftretend);ideologisch;doktrinär;einzig richtig;mit dem Anspruch unbedingter Geltung (behaupten);dogmatisch;apodiktisch;keinen Widerspruch zulassend;allein seligmachend (auch figurativ);keinen Widerspruch duldend;die Wahrheit für sich gepachtet haben
-Menge;Masse;Vielzahl;Unmenge;Batzen (ugs.);Unsumme;Schwarm;Flut (ugs.);Unzahl;Heer;Riesenmenge (ugs.);Myriade
-Pro und Kontra;Pro und Contra;Für und Wider;Vor- und Nachteile
-Seborrhö (ugs.);Talgfluss;Seborrhoea (fachspr.)
-Schifferklavier;Akkordeon;Quetschkommode (ugs.);Handorgel (ugs.);Handharmonika;Ziehharmonika;Quetsche (ugs.)
-ätzen;korrodieren
-Mark betreffend;medullär (fachspr.)
-Schoppen;Römer;Weinglas
-Zufuhr;Anlieferung;Versorgung
-Starrköpfigkeit;Halsstarrigkeit (ugs.);Hartnäckigkeit;Rechthaberei;Dickköpfigkeit (ugs.);Dickschädeligkeit (ugs.);Bockigkeit;Verbissenheit;Starrsinn;Sturheit;Sturschädeligkeit (selten)
-Beugen;Neigen;Bücken;Ducken
-gewandt (Hauptform);mobil;beweglich;lebhaft;wendig;agil;leichtfüßig;flink;behänd(e);gelenkig
-Harnröhrenentzündung;Entzündung der Harnröhre;Urethritis (fachspr.)
-Transformation;Verwandlung;Umwandlung;Verwandlungsprozess;Gestaltwandel;Wandlung;Metamorphose (fachspr.)
-Entwässerung;Dränage;Trockenlegung;Drainage
-Niete;Los, das nichts gewinnt
-Kalkspatz;Kalkeinschluss im Ton
-kultiviert;schön;geschmackvoll;stilvoll;ästhetisch;stylisch;formvollendet;edel;stylish
-unterschiedlich;differierend;verschiedenartig;divergent;voneinander abweichen(d);ungleich;inegal (geh.);disparat (fachspr.);ungleichartig;verschieden;anders;inkomparabel (geh., lat.);sich unterscheiden(d);unegal (ugs., salopp);in anderer Weise;inäqual (fachspr.);zwei (verschiedene) Paar Stiefel (sein) (ugs., fig.);andersartig;zwei (verschiedene) Paar Schuhe (sein) (ugs., fig.)
-hoffärtig;anmaßend;dominant;großtuerisch;überheblich;übertrieben selbstbewusst;insolent (geh.);hochfahrend;präpotent (österr.);aufdringlich;vermessen;arrogant
-Disposition;Planung
-Schmierstoff;Schmiermittel
-zeitgerecht;termingerecht;fristgerecht;fristgemäß;termingemäß;rechtzeitig
-Deformierung;Deformation;Verbiegung;Verformung;Durchbiegung
-Häuschen;Verschlag;Hütte
-Empfänger;Rezipient;Abnehmer;Akzeptant (geh.);Adressat
-Hochstapler;Betrüger;Schwindler;Bluffer (ugs.);Windei;Blender
-Haarentferner;Enthaarungsmittel
-aus Wolle;Wollware;Wollwaren
-unbeugsam;unbezwingbar;unbezwinglich;unbezähmbar;unzähmbar
-Sterndeutung;Sterndeuterei;Astrologie
-Kindeskind;Enkel;Großkind (schweiz.);Enkelkind
-fauchen;zischeln;schhh machen (ugs.);zischen
-Inselaffe (derb);Engländer;Tommy (ugs.);Brite
-Schlegel;Trommelstock
-Studio;Künstlerwerkstatt;Atelier
-Dürftigkeit;Spärlichkeit
-leicht;leichtgewichtig
-am untersten;zu unterst;unterst
-Knacks (ugs.);Riss;Spalt;Sprung
-abschürfen;aufschürfen;zerkratzen
-Betretenheit;Peinlichkeit;Verlegenheit
-Kampfgeschehen;Kampf;Kampfhandlungen;Bataille (geh., franz., veraltet);Gefecht;Treffen (geh., veraltet);Schlacht;Waffengang;militärische Konfrontation
-Approximierungsrechnung;Näherungsrechnung
-einpudern;bestreuen;streuen;bepudern;überstreuen;bestäuben;überpudern
-Servicemitarbeiter;Restaurantfachfrau (fachspr., weibl.);Ordonnanz (militärisch);Kellner (männl.);(Herr) Ober (Anrede) (ugs.);Restaurationsfachfrau EFZ (fachspr., schweiz.);Bedienung;Restaurationsangestellte/r (fachspr., schweiz.);Serviererin (weibl.);Servierkraft (österr.);Restaurationsfachmann EFZ (fachspr., schweiz.);Restaurantfachmann (fachspr., männl.);Kellnerin (weibl.);Fräulein (Anrede) (ugs., veraltet)
-nicht zu empfehlen;unratsam
-abbürsten;abklopfen
-überholen;instand setzen;in Stand setzen;renovieren;in Schuss bringen (ugs.)
-ebenmäßig;identisch;aus einem Guss;homogen;einheitlich;gleichartig;gleich;gleichförmig
-gezackt;gezähnt;zackig;zinkig
-saftig;ausgereift;ausgegoren;sukkulent;reif
-Vergiftungskrankheit;Vergiftung;Intoxikation (fachspr.)
-schleudern;katapultieren
-Einschlag;Durchschuss
-(sich) umsetzen;die Plätze tauschen
-Spezl (ugs., bayr., österr.);Vertrauter;Buddy (ugs., engl.);Spezi (ugs., bayr., österr.);Kamerad;Intimus (geh.);Kollege (ugs.);Kumpel (ugs.);Freund;Kumpan;Genosse;Getreuer;Gevatter (scherzhaft, veraltet);Gefährte
-Myalgie (fachspr.);Muskelschmerz
-abhalten;arrangieren;aufziehen;formen;gestalten
-Dividende;Gewinnanteil
-Umformer;Umspanner;Stromrichter
-Biskuit;Keks
-Puter;Meleagris gallopavo (fachspr.);Truthahn
-Justierbarkeit;Einstellbarkeit;Verstellbarkeit
-hervorbrechen;plötzlich zum Vorschein kommen;herauskommen
-Mundkatarrh (veraltet);Entzündung der Mundschleimhaut;Stomatitis
-Balaton;Plattensee
-(sich) ans Telefon hängen (ugs.);anklingeln (bei) (ugs.);zum Hörer greifen (ugs.);durchklingeln (bei jemandem) (ugs.);anrufen (jemanden / bei jemandem);durchrufen (ugs.);telefonisch kontaktieren;telefonisch in Kontakt treten;ein Telefon geben (ugs., schweiz.);telefonieren (mit) (Hauptform);(jemanden / bei jemandem) antelefonieren (ugs., schweiz.);(ein) Telefongespräch führen
-Falschheit;Abscheulichkeit;Niederträchtigkeit;Niedertracht;Gemeinheit
-(Plan) schmieden;konstruieren;konzipieren;erarbeiten;ersinnen (geh.);ausbrüten (ugs., fig., negativ);erfinden;aushecken (ugs., negativ);ausarbeiten;innovieren (fachspr., lat., sehr selten);entwickeln;entwerfen
-Vorstoß;Sturm;Attacke;Überfall;Einfall;Offensive;Übergriff;Angriff
-Unschlüssigkeit;Unentschiedenheit
-dünnflüssig;fließfähig;wässrig;wässerig;fluid (fachspr.);nichtviskos;flüssig
-(sich) unterreden;sprechen (mit, über);(sich) unterhalten (über) (Hauptform);(sich) austauschen
-Kegeln;Kegelspiel
-funktionstüchtig;funktionsfähig;lauffähig
-Edelmann;Samurai (japanisch);Ritter;Angehöriger des Ritterordens;Lehensmann
-Überfall;Raub;Raubüberfall
-weltberühmt;von Welt;weltbekannt
-maskieren;verkleiden;kostümieren
-einfahren;bringen;erwirtschaften;einbringen
-Kontoart;Kontotyp
-feststecken;klammern;fixieren;einspannen;halten;befestigen
-(sich) fügen (in);(sich) in sein Schicksal ergeben;(sich) d(a)reinfinden (geh., veraltet);(sich) bescheiden (mit);hinnehmen;keinen Aufstand machen (ugs.);schlucken (ugs.);(sich) kleiner setzen;(sich) dreinschicken (in) (geh., veraltend);ertragen;(sich) schicken (in) (veraltet);(sich) (notgedrungen) arrangieren mit;(sich) abfinden (mit);(sich) ergeben in;(klaglos) über sich ergehen lassen
-EZB (Abkürzung);Europäische Zentralbank
-Siebabfälle;Durchgesiebtes;Gesiebtes
-Reduktionsabschuss;Erlegen überschüssiger Tierbestände;Ausmerzen
-Versicherung;Versicherer;Versicherungsträger;Assekuranz (fachspr., veraltet);Versicherungsunternehmen;Versicherungsgesellschaft;Assekuradeur (fachspr., veraltet)
-Auszehrung;Kachexie (fachspr.)
-rechtwinklig (zu);im 90°-Winkel (zu);im 90-Grad-Winkel (zu);im rechten Winkel (zu);lotrecht (zu);senkrecht (zu / auf);in einem 90°-Winkel (zu)
-steinern;eisenhart;steinhart;eisern;hart
-mitreden (ugs.);(das) Seine tun;(aktiv) mitgestalten;mitmischen (ugs.);teilnehmen (an);mitmachen (ugs.);mitarbeiten (bei);mitwirken (bei);(sich) (aktiv) einbringen;(sich) beteiligen (an);beitragen (zu);(seinen) Beitrag leisten
-Nachbar...;anliegend (Amtsdeutsch);benachbart;angrenzend;nahegelegen;daneben
-Kundenkreis;Kundenstamm;Kundenbestand
-(sich) kräuseln (Haar);(sich) locken
-kleiner, dicker Teppich;Vorleger
-einschalten;aktivieren;anschalten;anmachen (ugs.);anknipsen;anstellen
-Spital (Hauptform, schweiz., österr.);Hospital (veraltet);Klinikum;Charité (franz., veraltet);Krankenhaus (Hauptform);Klinik (Hauptform);Krankenanstalt;Lazarett (fachspr., militärisch);Siechenhaus (veraltet)
-Gebühren;Abgaben;Steuern
-Tauwerk;Laschung
-Text;Liedtext;Liedertext;Songtext;Lyrics
-Wählerstimme;Wahlstimme;(abgegebene) Stimme;Votum
-transurethral (fachspr.);durch die Harnröhre
-Kolofonium;Geigenharz;Kolophonium
-Leviten (ugs., Pluraletantum);Moralpredigt;Gardinenpredigt (ugs.);Strafpredigt (Hauptform);Standpauke (ugs.);Ermahnungsrede;Exhorte (fachspr., neulateinisch, veraltet);Epistel (geh.);Schimpfkanonade;Strafrede
-disponieren;vorausplanen;prädisponieren;ansetzen (ugs.);vorsehen
-in Erinnerung an;unter Berücksichtigung von;in Memoriam (geh.);unter Beachtung von;eingedenk (geh.);in Anbetracht
-nicht stabil;labil;fließend;wechselhaft;instabil;dynamisch;unbeständig;unstet
-Trockenheit der Mundschleimhaut;Mundtrockenheit;Xerostomie (fachspr.)
-Tüddelchen (ugs.);Anführungsstriche;Redezeichen;Zitatzeichen (Druckersprache) (ugs.);Gänsefüßchen (ugs.);Anführungszeichen;Anführungsstrich;signum citationis (geh., lat.)
-Serum;Impfstoff;Vakzine (fachspr.);Vakzin (fachspr.)
-gespielt;künstlich;ostentativ;vorgeblich;vorgeschoben;fadenscheinig (ugs.);aufgesetzt
-Bettnässen;Enuresis (fachspr.);Enurese (fachspr.)
-Schweizerische Bundesbahnen (Eigenname);SBB CFF FFS (Markenname);SBB
-Glas;Wasserglas;Becherglas
-Tongewinnung;Lehmgewinnung
-Trick 17;(der) richtige Dreh;trickreiche Methode;Gewusst, wie! (ugs., Spruch);(spezieller, genialer) Handgriff;Finesse;(geschickter o.ä.) Schachzug (fig.);(genialer o.ä.) Trick;(raffinierter o.ä.) Kunstgriff;(spezielle) Praktik;Dreh;(spezielle) Technik;Cheat (ugs., Jargon);Kniff;Trick siebzehn;Kunststück
-Stenose (fachspr.);Einengung eines Kanals;Engstelle
-Stellwärter;Bahnwärter
-Großhändler;Grossist
-neutralisieren;schwächen;drosseln;abschwächen;dämpfen;mildern;abmildern
-zueignen;beschenken;spendieren;springen lassen (Geld) (ugs.);überlassen;springenlassen (Geld);widmen;überreichen;gewähren;(jemanden mit etwas) bedenken (geh.);schenken;überantworten;übergeben;zuwenden;bescheren;hingeben
-warm;gütig;sanftmütig;herzlich
-alliiert;verbündet;föderiert (fachspr.)
-überfluten;fluten;überspülen;überschwemmen
-Aufforderungsform;Befehlsform;Imperativ (fachspr., Hauptform)
-geschmückt;ausgeschmückt;dekoriert;schön gemacht
-Zuständigkeitsbereich;Umfeld;Domäne;Bereich;Einflussbereich;Segment;Sphäre
-Zuspitzung;Verjüngung;Verengung
-Dunst;Vernebelung;(eine richtige) Waschküche (ugs., fig.);Nebelschleier;trübe Suppe (ugs., fig.);Schleier;Suppe (ugs., fig.);Nebeldampf;Nebel;Brühe (ugs., fig.);Trübung;Nebelschwaden
-Griff ins Klo (derb, fig.);Fehler;Malheur;Panne;Fehlgriff;Fehlleistung;Fehlschlag;Missgeschick
-(den) Hermann machen (ugs.);(die) Schnauze aufreißen (ugs., fig.);(den) Larry machen (ugs.);auf die Pferde hauen (ugs., fig.);(sich) aufpupsen (derb);(die) Welle machen (ugs.);dicke Backen machen (ugs.);auf den Putz hauen (ugs., fig.);den (...) raushängen lassen (ugs.);dicketun (ugs.);blärzen (ugs., regional);groß rumtönen (ugs.);(einen) auf großer Zampano machen (ugs.);(eine) große Klappe haben (ugs.);auf die Pauke hauen (ugs., fig.);pranzen (ugs.);(sich) in die Brust werfen (geh.);(sich) auf die Brust klopfen (fig.);(den) dicken Mann markieren (ugs.);(den) Mund (sehr) voll nehmen (ugs., fig.);(sich) aufführen wie der große Zampano;(die) Backen aufblasen (ugs.);Eindruck schinden;(groß) herumtönen (ugs.);(sich) aufführen wie Graf Koks von der Gasanstalt (derb, regional, veraltend);(eine) große Fresse haben (derb);(den) Lauten machen (ugs.);(eine) Schau machen;(eine) große Schnauze haben (ugs.);(eine) (dicke) Lippe riskieren (ugs.);einen auf (...) machen (ugs.);(den) Mund zu voll nehmen (ugs.);(den) dicken Max machen (ugs.);(den) (großen) Zampano machen (ugs.);(gewaltig) das Maul aufreißen (ugs.);(das) große Wort führen (geh.);(den) Dicken markieren (ugs.);(sich) großtun (mit) (ugs.);(sich) aufmandeln (ugs., bayr.);laut werden;auf die Kacke hauen (derb, fig.);große Reden schwingen;(die) (große) Welle reißen (ugs.);(sich) aufblasen;(sich) wichtig machen (ugs.);wichtigtun (ugs.);(sich) aufspielen (Hauptform);große Töne spucken (ugs.);herumblärzen (ugs., regional);(eine) Show abziehen (ugs.);(sich) aufs hohe Ross setzen (fig.);Sprüche klopfen (ugs.);(den) Molli machen (ugs., regional);(einen) auf dicke Hose machen (derb);dicktun (ugs.);(sich) aufplustern;(den) dicken Max markieren (ugs.);strunzen (ugs., regional)
-Abrechnungsmaschine;Fakturiermaschine;Buchungsmaschine
-Schrumpfung;Zirrhose
-Tafel;Wandtafel
-Bedingtheit;Relativität
-Heilung;Besserung
-niederschlagen;kondensieren
-entsahnen;absahnen;entfetten;entrahmen (Milch)
-Fachbegriff;Fachausdruck (für);Terminus technicus;Fachterminus;Fachwort;Terminus;Fachvokabel
-Anwalt an Spezialgerichten;Proktor
-sinnlos (Hauptform);witzlos (ugs., abwertend);unnütz;unsinnig;nicht zielführend (geh.);sinnfrei
-forsch;schnittig;zackig;schneidig
-Notbremse;Notausschalter;Nothaltschalter
-Hautrötung;Rötung;Erythem (fachspr.)
-Mietvertrag;Leasingvertrag;Pachtvertrag;Bestandvertrag (österr.);Bestandsvertrag (österr.)
-Reißwolf;Aktenvernichter;Papierwolf;Büro-Schredder
-Voraussicht;Vorsorge
-Mehrfachkanal;Multiplexkanal
-Vorleistung;Vorarbeit
-gesundheitsschädlich;ungesund
-Defäkation (fachspr.);großes Geschäft (ugs.);Exkretion (fachspr.);Stuhlentleerung;Stuhlgang;Verdauungsfinale (ugs.);Egestion (fachspr.)
-tatkräftig;anpackend;energisch;produktiv;arbeitsam;tüchtig;strebsam;fleißig;engagiert;mit Schmackes (ugs.)
-Backtracking;Rücksetzalgorithmus;Trial-and-Error-Verfahren
-zweckmäßigerweise;zweckmäßig
-einzeln;individuell;getrennt;unabhängig (von);separat;abgetrennt;abgesondert;geteilt
-insoweit als;insofern als
-Getreide;Korn;Samenkorn
-(sich) auflösen;zerfallen (in)
-einen weichen Keks haben (ugs., fig.);(einen) Kopfschuss (haben) (ugs., fig.);nicht ganz bei Trost sein;nicht alle Latten am Zaun haben (ugs., fig.);sie nicht alle haben (ugs.);den Schuss nicht gehört haben (ugs., fig.);nicht mehr alle Nadeln an der Tanne haben (ugs.);(einen) Lattenschuss (haben) (ugs.);nicht richtig ticken (ugs.);des Teufels sein (ugs.);(eine) Macke (haben) (ugs.);verrückt (sein);ein Rad abhaben (ugs., fig.);einen Ratsch im Kappes haben (ugs., rheinisch);(einen) Schuss (haben) (ugs.);nicht ganz dicht (sein) (ugs., fig.);einen Sprung in der Schüssel / Tasse haben (ugs., fig.);nicht alle Tassen im Schrank haben (ugs., fig.);nicht bei klarem Verstand sein
-anmaßend;sehr von sich (selbst) eingenommen;vermessen;kennt (auch) keine kleinen Leute mehr (ugs., scherzhaft-ironisch);eingebildet;versnobt;auf dem hohen Ross sitzen (Redensart, fig.);blasiert (geh.);hochnäsig;hybrid (geh.);dünkelhaft (veraltet);hochmütig;hält sich für was Besseres (ugs.);hält sich für sonst wen;hält sich für die Größte (ugs., weibl.);hält sich für Gott weiß wen (ugs.);hält sich für den Größten (ugs., männl.);trägt die Nase hoch (ugs., fig.);stolz;hält sich für was Besonderes (ugs.);überheblich;aufgeblasen (ugs.);arrogant;breitspurig (ugs.);hoffärtig (veraltet)
-unrechtmäßig;widerrechtlich;illegal;unzulässig;verboten;krumm (ugs.);gesetzeswidrig;kriminell;ungesetzlich;gegen das Gesetz;unerlaubt;gesetzwidrig;untersagt;unautorisiert;nicht erlaubt;unberechtigt;rechtswidrig;ungenehmigt;schwarz (ugs.)
-bordieren (fachspr.);säumen;verzieren;einsäumen;galonieren (fachspr.);besetzen;ummanteln;verbrämen;bandeln (österr.);einfassen;umsäumen;absetzen
-Schlappschwanz (ugs.);Schiffschaukelbremser (ugs., jugendsprachlich);Sitzpinkler (ugs.);Memme (ugs.);Schlaffi (ugs.);Milchbubi (ugs.);Pussy (derb);Warmduscher (ugs.);Nulpe (ugs.);Weichei (ugs.);Waschlappen (ugs.);Weichling;Schattenparker (ugs.);Lauch (ugs., jugendsprachlich);Muttersöhnchen (ugs.);Milchbart (ugs.);Himbeerbubi (ugs.);Kümmerling (ugs.);Früheinfädler (ugs.)
-Amtszeichen;Stempel;Siegel
-häckseln;schnetzeln;zerkleinern;hacken;zerhacken;zerstückeln;zerhäckseln;zerschnetzeln
-transplantieren;verpflanzen
-Rechenoperation;Kalkulation;arithmetische Operation (fachspr.)
-predigen;rausposaunen (ugs.);verkündigen;nachdrücklich kundtun;herausposaunen (ugs.)
-liebeln (ugs.);liebäugeln;schäkern;herumturteln;turteln;scharmutzieren (veraltend);flirten (Hauptform);beturteln;bebalzen;poussieren (veraltet);herummachen mit (ugs.);tändeln (veraltend);kokettieren;rummachen mit (ugs.);herumschäkern
-Abstimmung;Absprache;Koordinierung;Koordination
-minimalst (ugs.);wenigst;geringst;kleinst
-Salutschuss;Ehrensalve
-floppen (mit) (ugs.);(sich) eine blutige Nase holen (ugs., fig.);auf die Schnauze fallen (derb, fig.);Misserfolg haben;auf die Schnauze fliegen (derb, fig.);eine Bauchlandung hinlegen (mit etwas) (ugs., fig.);Misserfolg erleiden (geh.);scheitern (mit / an);auf die Fresse fallen (derb, fig.);versagen (bei);baden gehen (mit) (ugs., fig.);auf den Bauch fallen (mit) (ugs., fig.);Schiffbruch erleiden (fig.);(mit etwas) nicht durchkommen;schlecht abschneiden;(einen) Misserfolg verzeichnen (geh.);auf die Nase fallen (ugs., fig.);(etwas) an die Wand fahren (ugs., fig.)
-(wörtlich) anführen;zitieren;wörtlich wiedergeben;(jemandes) Worte wiederholen
-in Watte packen (fig.);(immer nur) mit Samthandschuhen anfassen (fig.);(nur) mit Wattebäuschchen werfen (fig.);schonen;verschonen;hätscheln
-aquamarin;aquamarinblau
-stechen;ausstechen;piercen (engl.);stoßen;piken (ugs.);piksen (ugs.);stanzen;einstechen;lochen;durchstechen;durchlöchern
-Humorist;Komiker;Comedian (engl.);Komödiant
-Varieté (franz.);Kabarett;Varieteetheater (alte Schreibung bis 2017);Varietee (alte Schreibung bis 2017);Varietétheater
-steigern;maximieren (geh.);größer machen;vermehren;mehren (geh.);vergrößern
-zellenförmig;zellig
-Würdelosigkeit;Unflätigkeit;Pöbelhaftigkeit;Schamlosigkeit;Verkommenheit;Unanständigkeit
-Eibisch;Hibiscus syriacus (botanisch);Hibiskus (Hauptform);Roseneibisch
-Police;Versicherungspolice;Assekuranzbrief (veraltet);Polizze (österr.);Assekuranzpolice (veraltet);Versicherungsschein
-lyophilisieren (fachspr.);gefriertrocknen
-gezähmt;(jemandem) aus der Hand fressen;lammfromm;zahm;zutraulich;domestiziert;an Menschen gewöhnt;handzahm
-in Verruf bringen;verderben;zu Grunde richten;zugrunde richten;ruinieren
-futtern (ugs.);einnehmen (Mahlzeit) (geh.);zu Munde führen;mampfen (ugs.);fressen (derb);(sich) gütlich tun (an);weghauen (ugs.);verdrücken (ugs.);vernaschen (ugs.);wegputzen (ugs.);(sich) einverleiben;spachteln (ugs.);verschmausen;Nahrung aufnehmen;verspachteln (ugs.);speisen;verkosten;Essen fassen (ugs.);(etwas) zwischen die Kiemen bekommen (ugs.);(sich) zu Gemüte führen;in sich hineinschaufeln (ugs.);wegspachteln (ugs.);verspeisen;essen;verputzen (ugs.)
-wechselseitig;mutuell;mutual;beiderseits;reziprok;gegenseitig (Hauptform)
-Volumenelement;Voxel
-Fasszapfen;Fasshahn
-Verpflichtung;Bekräftigung;Bund;Gelöbnis;Ehrenwort;Schwur;Gelübde;Erklärung;Eid
-sorgen für;umsorgen;Acht geben (auf);sehen nach
-Tramway (engl., österr.);Stadtbahn;Bim (ugs., österr.);Tram;Trambahn;Elektrische (ugs., veraltend);Überland-Straßenbahn;Straßenbahn;Nebenbahn (fachspr., schweiz.);Straba (ugs., regional);Schnellstraßenbahn
-hintenherum;link;auf die linke Tour;arglistig;hinterrücks;heimtückisch;hinterhältig;tückisch;hinterfotzig (derb, süddt.);meuchlings;falsch (ugs.)
-rostfreier Stahl;VA-Stahl;Edelstahl (ugs.);Cromargan (Markenname);Nirosta (Markenname);nichtrostender Stahl
-(sich) aufraffen;(sich) durchringen (zu);den Arsch hochkriegen (derb, fig.);(sich) bequemen (ugs.);(sich) aufmachen (und);(den) inneren Schweinehund überwinden (und) (ugs.);(sich) überwinden;(sich) bemühen (um);(sich) aufrappeln (ugs.);(sich) hochrappeln (ugs.)
-versonnen;gedankenvoll;in sich gekehrt;gedankenversunken;grüblerisch;gedankenverloren;nachdenklich;erwägend
-Schuldgefühle;Gewissensbisse;Selbstvorwürfe;Schuldbewusstsein;Unrechtsbewusstsein (auch jur.)
-weltklug;mit (viel) Lebenserfahrung;weise;lebenserfahren;vernünftig;geläutert;klug;erfahren;lebensklug
-Verantwortlichkeit;Haftung;Haftpflicht;Obligo (Bankwesen)
-strudeln;wirbeln
-bauschen;(sich) blähen
-bewahren;beschirmen;beschützen;(schützend) die Hand über (jemanden) halten
-unergründlich;tief;zutiefst;abgrundtief
-Myopie (fachspr., griechisch);Kurzsichtigkeit
-übertreffen;darüberlegen;daraufsetzen;daraufsatteln (ugs.);darübersetzen
-(körperliche oder geistige) Reifungsverzögerung;Retardation
-ubiquitär (geh.);überall auffindbar;überall verbreitet;allgegenwärtig;überall anzutreffen;weltumspannend;auf der ganzen Welt zu finden;gibt es überall;omnipräsent
-Urkunde;Unterlage;Beleg;Archivale (fachspr., Jargon);Schriftstück (Hauptform);Dokument;offizielles Schreiben;amtliches Papier
-Klamotten (ugs.);Kleidung;Garderobe;Gewand;Kledage (ugs., regional, salopp);Sachen (ugs.);Kleider;Gewandung (geh.);Textilie(n);Plünnen (ugs., norddeutsch);Anziehsachen (ugs.);Kluft;Bekleidung;Mode;Konfektion (geh.);Outfit;Zeug (ugs.)
-sparen;Haus halten;wirtschaften;haushalten
-herumfummeln (ugs.);herummachen (ugs.);herumtasten
-verharztes Holz;Harzstreifen
-ingeniös;genial
-Besorgung;Anschaffung;Beschaffung;Einkauf;Erwerb
-mit Sägezähnen;gezahnt
-Schieferbergwerk;Schieferbruch
-Ossifikation (fachspr.);Knochenbildung
-Flurkarte;Gemarkungskarte;Katasterkarte
-Angelrute;Rute;Angel;Angelgerät
-trügen;bluffen;täuschen;blenden
-Nierenbeckenentzündung;Pyelonephritis (fachspr.)
-Dünnflüssigkeit;Fluidität (fachspr.);Fließfähigkeit;Fließvermögen
-kraftlos;schwach;adynamisch
-Abhöranlage;Abhörgerät;Überwachungsgerät;Wanze (ugs.)
-Dorn;Balken;Hauptbalken;Holm
-computerisieren;mit Computern ausstatten;auf Computer umstellen
-Rückzug;Abbestellung;Gegenerklärung;Widerrufung;Widerruf
-ramponieren;zerritzen;beschädigen;lädieren;beschmieren;zerkratzen;demolieren (Verstärkung);verkratzen;verbeulen
-grauenvoll;schaurig;gräulich;sehr schlecht;grausig;fürchterlich;grausam;grauenhaft;schrecklich;horrormäßig
-rebellisch;renitent;widersetzlich;trotzig;unartig;ungehorsam;eigensinnig;unbotmäßig;zickig (ugs.);respektlos;aufsässig;aufmüpfig;widerständig;dickköpfig
-Schwarm;Rudel;Trupp;Pulk;Clique;bunte Truppe;Runde;Herde;Korona (ugs.);Schar;Traube;Kolonne;lustiger Verein (ugs., fig.);Grüppchen
-absteigen (fig.);(den) Anschluss verpassen;auf der Strecke bleiben (ugs.);nachlassen;(ganz schön) alt aussehen (ugs., fig., salopp);zurückbleiben;nicht mithalten (können) (Hauptform);nicht Schritt halten (können);hinterherhinken (fig.);in Rückstand geraten;nicht hinterherkommen;abgehängt sein (fig.);ins Hintertreffen geraten;abbleiben (ugs.);an Boden verlieren;zurückfallen;abgehängt werden (fig.);nicht mitkommen;(den) Anschluss verlieren;blass vor Neid werden (ugs., fig.);nicht nachkommen
-Sender;Zeichengeber;Emitter
-stupid;geisttötend;reizlos;schnöde;schal;öd;öde;trostlos;fade;blass;trocken (ugs.);wenig aufregend;spannungsarm;langweilig;grau;dröge;farblos;grau in grau;fad (ugs., österr.);monoton;stupide;kontrastarm;langatmig;trist;eintönig
-Hebelkraft;Hebelwirkung
-Nonius;Vernier
-Snackbar;Snacktheke;Erfrischungsbar
-Bedeutung;Sprengkraft (geh.);Gewicht
-Quarkspeise;Quark
-Versorgungs...;logistisch
-Vorschrift;Instruktion;Anordnung;Anweisung
-Zeiger;Index;Tabelle;Kennziffer (z. B. bei einer Matrix);Hinweis;Verzeichnis
-Computertomographie;CT;Computertomografie
-überaus;enorm;in höchstem Maße;stark;außergewöhnlich;massiv;sehr (vor Adjektiv oder Adverb) (Hauptform);ungemein;hochgradig;äußerst;ausgesprochen;außerordentlich;allzu;mehr als;höchlichst (geh., altertümelnd);zutiefst;schwer (ugs.);besonders
-Makler;Vermittler
-orange;orangefarben;pfirsichfarben;orangen (ugs.)
-Tarifzone;Fahrpreiszone
-planar;topfeben (Verstärkung);flächig;gerade;eben;gleichmäßig;waagrecht;waagerecht;glatt;plan;platt (ugs.);flach;wellenlos
-zerlassen;aufgelöst
-Geduld;Ausdauer;Beharrlichkeit
-überdenken;(sich etwas) durch den Kopf gehen lassen (ugs.);nachsinnen;(sich etwas) bewusst machen;(etwas) reflektieren;(in Ruhe) nachdenken (über);grübeln (über);bedenken;überlegen;reflektieren (geh.);nachgrübeln;(sich mit etwas) auseinandersetzen;(sich über etwas) Gedanken machen;klamüsern (ugs.)
-Diskographie;Diskografie
-Abfahrtsfahrplan;Zeitplan;Fahrplan;Abfahrtsplan
-malen;zeichnen;bildlich darstellen;abbilden
-versinken;absacken;sinken;untergehen
-Anzeigenkunde;Werber;Inserent
-Splenomegalie (fachspr.);Milzvergrößerung
-Angeber;selbstherrliches Wesen;rechthaberisches Wesen
-Munterkeit;Hilarität (geh., bildungssprachlich, lat.);Euthymie (geh., bildungssprachlich, griechisch);Ausgelassenheit;Heiterkeit;Fröhlichkeit
-Screening (fachspr., engl.);Kontrolle;Bemusterung (fachspr.);Überprüfung;Begehung;Sichtung (fachspr.);Inspektion
-Einführung eines Schlauches;Intubation
-ausfeilen;veredeln;verfeinern (Hauptform);ausgestalten
-bewandert;bewandt
-glänzen (mit);herausstechen;bestechen (mit);herausragen;herausstrecken;hervorstehen;brillieren (mit);herausstehen;vorstehen;trumpfen (geh.)
-Fährnis (geh., poetisch);Stolperfalle (ugs.);drohendes Unheil;Unsicherheit;Pulverfass (fig.);Gefahr;Risiko;potentielle Schadeinwirkung (fachspr., Jargon);Gefährdung;Fährde (geh., poetisch);Bedrohung;Wagnis (fachspr.)
-herunterladen;laden;downloaden (engl.);herunterkopieren;runterladen (ugs.)
-Harfenist;Harfenspieler
-Einfaltspinsel (ugs.);armer Tropf (veraltend);Tor;Idiot (ugs.);Kleingeist;Esel (ugs.);Simpel (ugs.);Kamel (ugs.)
-Zerfall;Niedergang;Dekadenz;Pervertierung;Zerrüttung;Degeneration;Verfall;Entartung
-die Schlagfrequenz des Herzens beeinflussend;chronotrop (fachspr.)
-endokrin (fachspr.);nach innen absondernd
-Anmeldung;Registrierung;Registration;Einschreibung;Eintragung
-Bildelement;Pel;Pixel;Bildpunkt;Bildzelle
-Materie;Werkstoff;Material
-Schleimbeutelentzündung;Bursitis (fachspr.)
-Überführung;Straßenüberführung
-(sich) für etwas eignen;für etwas geeignet sein
-Öffnerkontakt;Ruhekontakt;Öffner
-Streulicht;Reflexlicht
-gestehen;konzedieren (geh.);offenbaren;zugeben (Hauptform);eingestehen;einbekennen (österr.);bekennen;(sich) schuldig bekennen;zugestehen;beichten;herausrücken (mit) (ugs.);(ein) Bekenntnis ablegen;einräumen
-Knifte (ugs.);Gewehr
-Standbild;Festbild
-Legitimierung;Berechtigungsnachweis;Legitimation;Ausweis;Bescheinigung;Berechtigung
-Leuchtsignal;Leuchtfeuer
-gekörnt;körnig;granular
-Existenzfähigkeit;Lebensfähigkeit
-Stellvertretersymbol;Platzhalter;Wildcard;Joker
-flüssiges Gestein;Schmelze
-vorschlagen;unterbreiten;vorlegen;vorbringen;einreichen
-Computertechnik;Informationstechnologie;Rechentechnik
-Fakelaki (griechisch);Schmiergeld;Bestechungszahlung(en);Bakshish (ugs., persisch);Bakschisch (ugs., persisch);Bestechungsgeld
-unentwegt;ständig;unausgesetzt;ohne Unterlass;am laufenden Band (ugs.);ohne Unterbrechung;in einer Tour (ugs.);beharrlich;dauernd;laufend;unablässig;unaufhörlich;ohne abzusetzen;nonstop;ununterbrochen (Hauptform);pausenlos
-typographisch;typografisch;drucktechnisch
-Arbeitslosengeld;Arbeitslosenunterstützung;Stütze (ugs.);Stempelgeld (veraltet);ALG I (ugs.)
-Leichenverbrennung (veraltet);Einäscherung;Feuerbestattung;Kremierung;Kremation;Urnenbestattung;Friedwaldbestattung;Brandbestattung
-Treuebruch;Treulosigkeit;Abtrünnigkeit
-Fertigungsprozess;Produktionsprozess;Herstellungsprozess
-Waffenarsenal;Waffenvorrat;Waffen-Repertoire (fachspr., Jargon);Arsenal
-Skrupel;Zweifel;Bedenken;schlechtes Gewissen;Vorbehalte;Gewissensbisse;Schuldgefühle
-Treiber;Viehtreiber
-falsch zählen;verzählen
-Leierkastenmann;Leierkastenspieler;Drehorgelspieler
-ein Glück (dass ...);gottlob;gottseidank;zum Glück (Hauptform);glücklicherweise;Gott sei Dank;(Dem Herrn) sei's getrommelt und gepfiffen. (scherzhaft, variabel);dem Himmel sei Dank (geh.)
-Pension;Hotel;Gasthaus;Bed and Breakfast (engl.);Gasthof;Bettenburg (ugs.);Gästehaus
-Randgebiet;Stadtrand (Hauptform);Peripherie;Randbezirk;Randzone
-enthüllen;(Oberbekleidung) ablegen;(sich) entblättern (ugs.);entkleiden;(die) Hüllen fallen lassen;blankziehen;strippen (ugs.);entblößen;(ein Kleidungsstück) abstreifen;(sich) freimachen;(sich) nackig machen (ugs.);(sich) ausziehen (Hauptform);auskleiden;(alle) Hüllen fallen lassen;(sich) (eines Kleidungsstücks) entledigen (geh., veraltend)
-anschaulich machen;illustrieren;veranschaulichen;skizzieren;Ein Bild sagt mehr als tausend Worte. (ugs., Spruch);bebildern;visualisieren
-Einzelteile;Bestandteile
-Bedeutung (geh.);Spin (Jargon, fig.);Exegese;Sichtweise;Lesart;Deutung;Version;Interpretation;Ausdeutung;Perspektive;Auslegung
-Warnung;Vorwarnung;Mahnung
-DGB;Deutscher Gewerkschaftsbund
-Innenraum;Platz im Innern
-auf dem Trockenen sitzen (ugs.);aufgeschmissen sein (ugs.)
-verdanken;schulden
-geordnet;planmäßig;systematisch (Hauptform);Punkt für Punkt;planvoll;zielbewusst;regelhaft;zielgerichtet;methodisch;überlegt
-Bschütti (ugs., alemannisch);Flüssigmist (fachspr.);Schwemmmist (fachspr.);Odl (ugs., bayr.);Jauche;Gülle;Sudel (ugs., regional);Puddel (ugs., hessisch)
-übersenden;abschicken;aufgeben;auf die Post geben;expedieren (scherzh. oder veraltet) (geh.)
-vegetieren (ugs.);(ein) kümmerliches Leben fristen;kümmerlich leben;unter äußerst bescheidenen Verhältnissen leben (positiv, verhüllend);zum Sterben zu viel und zum Leben zu wenig (haben) (Spruch);äußerst bescheiden leben (positiv, verhüllend);in ärmlichen Verhältnissen (leben);(sein) Leben fristen (Hauptform);unter ärmlichen Bedingungen
-zurücktreten;(Amt) zurücklegen (österr.);(Amt) niederlegen;seinen Hut nehmen (ugs.);abdanken;Platz machen (ugs.);(Posten) aufgeben;(sein) Amt zur Verfügung stellen;abtreten;den Staffelstab weitergeben (ugs.)
-Vorkehrung;Vorsorge;Vorbedacht
-berauscht;ekstatisch
-Geiser;Springquell
-klopf klopf machen (ugs.);schlagen;hämmern;klopfen;pochen;bumpern (ugs.);pulsieren
-Lohfarbe;Gelbbraun
-Lichtreflex;Spiegelung;Lichtrückstrahlung;Reflex;indirekte Beleuchtung;Reflexion;indirektes Licht;Widerschein
-horizontal;waagerecht;waagrecht
-(sich) ergeben;(sich) ausliefern;(sich) (freiwillig) in die Hände begeben (von);(sich) stellen
-Gewebszerreißung;Organzerreißung;Ruptur (fachspr.)
-Einschaltmoment;Anzugsmoment;Anfahrdrehmoment
-Shoddy;Reißwolle
-zusammengedrängt;massiv;klein;kompakt;gedrungen;stabil
-Sponsor;Geldgeber
-Mutwilligkeit;Intentionalität;Absichtlichkeit;Mutwille
-Rundfunk im amerikanischen Sektor;RIAS
-Diskretion;Verschwiegenheit;Umsicht
-Waldschlucht;waldiges Tal
-Herzspezialist;Kardiologe
-Mühle;Mahlwerk
-tiefgründig;tiefgreifend;weitreichend
-die Stirn bieten (ugs.);(sich) entgegen stellen;herausfordern;es aufnehmen mit
-biologische Vielfalt;Biodiversität
-(sich) füllen;wölben;bauschen;anschwellen
-verheimlichen;dissimulieren;verhüllen;verhehlen;kaschieren;verbergen
-(sich auf etwas) beziehen;(sich auf etwas) berufen
-umwälzen;revolutionieren;verändern;alles umkrempeln (ugs.);vom Kopf auf die Füße stellen (fig.);umstürzen;(das) Innere nach außen kehren;aus den Angeln heben
-Viole;Viola (Hauptform);Armgeige;Bratsche (Hauptform)
-Zwischenhändler;Mittelsmann;Intermediär (geh., franz., lat.)
-lebenskräftig;in Bewegung;nicht kaputt zu kriegen (ugs.);kregel (regional);wach (fig.);lebhaft;munter;sanguin;lebendig;putzmunter (ugs.);rege;rührig (ugs.);quietschlebendig (ugs.);quicklebendig;vital;springlebendig;quirlig;aktiv;umtriebig;tätig
-informell;nicht förmlich;ohne Formalitäten;unformell;formlos
-(schmaler) Streifen;Band;Gurt;Bändel (regional)
-unerschöpflich;unbeschränkt;unbegrenzt;unendlich
-Radkralle;Parkkralle;Autokralle
-Arbeitstagung;Arbeitskreis;Workshop
-spießen (bayr., österr.);festklemmen;verkeilen
-univariant (fachspr.);univariat (fachspr.);eindimensional;nur eine Variable besitzend;linear
-inhaltsarm;inhaltsleer;substanzarm (geh.);substanzlos;ohne Substanz;bedeutungsleer;gehaltlos;sinnentleert (geh.)
-Quantität;Anzahl;Menge;Quantum
-Keckheit;Unverschämtheit;Unverfrorenheit;starker Tobak;harter Tobak;Dreistigkeit;Zumutung
-Multicast-Adresse;Gruppenadresse
-schlapp;schwach;schwächlich;mürbe;kränklich;gebrechlich;brüchig;labil;kraftlos;hinfällig
-Minderung des Wertes;Depravation;Wertminderung
-Behaglichkeit;Gemütlichkeit;Wärme
-triumphal;siegreich
-Wettbewerb;Mitbewerb;Bewerb (österr.);Rivalität;Wettstreit;Konkurrenz;Kontrarität (geh., veraltend)
-Bruttoinlandsprodukt;Bruttoinlandprodukt (schweiz.);BIP
-bestellen;abonnieren;subskribieren
-ohne triftigen Grund;ohne erkennbares Motiv;ungerechtfertigterweise;einfach so (ugs.);unbegründet;grundlos;überflüssigerweise;unnötigerweise;ohne zwingenden Grund;ohne wirklichen Grund;ohne Grund;ohne vernünftigen Grund;ungerechtfertigt;ohne Not;ohne nachvollziehbaren Grund
-erwischen;hopsnehmen (ugs.);hochnehmen (ugs.);am Schlafittchen packen (ugs.);fassen;aufgreifen;verhaften;ertappen;aufbringen (Schiff) (fachspr., Jargon);greifen;(jemandem) das Handwerk legen (fig.);kassieren (ugs.);schnappen (ugs.);ergreifen;festnehmen;ausheben;kriegen (ugs.);fangen;kaschen (ugs.);hochgehen lassen;auffliegen lassen;packen (ugs.);arripieren (geh., veraltet);(wieder) einkassieren (ugs., fig., salopp);hoppnehmen (ugs.);stellen;(jemandes) habhaft werden;zu fassen kriegen
-These;Vermutung;Behauptung;Stochern im Nebel (ugs., fig.);Spekulation;Annahme;Mutmaßung;Hypothese (fachspr.)
-Brocken;Felsblock;Geröllblock;Feldstein;Felsbrocken;Gesteinsbrocken
-Unbekümmertheit;Leichtsinnigkeit;Sorglosigkeit;Leichtsinn;Unbedarftheit;Leichtfertigkeit;Unvorsichtigkeit
-Dart;Wurfpfeil
-Obdach;Bude (ugs.);Wohnung;Unterkunft;Klause
-grammatisches Geschlecht;Genus (fachspr., Hauptform)
-Bauleitung;Baustellenbüro;Baubüro
-Beschaffungswert;Anschaffungswert
-Hasenohren;Löffel
-Spesen (Pluraletantum);Kosten (Pluraletantum);Kostenaufwand;Aufwand;Unkosten (ugs., Pluraletantum);Kapitalaufwand;Ausgabe;Aufwendung
-prophylaktisch;zur Vorbeugung;vorsorglich;präventiv;vorbeugend
-(sich) sträuben;aufmucken (ugs.);revoltieren;(sich) widersetzen;(sich) auflehnen;protestieren;opponieren;(den) Aufstand proben (geh., fig.);(sich) erheben gegen;aufbegehren;rebellieren;frondieren (veraltet)
-unkritisches Festhalten an Lehrmeinungen und Glaubenssätzen;Dogmatismus
-Senker;Bleigewicht
-ehelos bleiben;im Zölibat leben
-Notiz;Bemerkung;Buchung;Intabulation (veraltet);Eintragung;Vermerk;Aide-mémoire (geh., franz.);Aktennotiz
-unbeirrbar;stetig;gleichmäßig
-Indexkopplung;Indexbindung;Wertsicherung;Teuerungsausgleich;Indexkoppelung;Indexierung;Inflationsausgleich
-Nasennebenhöhlenentzündung;Nebenhöhlenentzündung;Sinusitis (fachspr.)
-Rollball;Trackball;Steuerkugel
-schneiden;einkerben;einschneiden;einfeilen;kerben;zerteilen
-stehen;stillstehen
-Legitimität;Rechtsgültigkeit
-unbeschränkt;rückhaltlos
-zusammenschnüren;zusammenziehen;zusammenpressen;zuziehen;abdrosseln;abschnüren;schnüren;abklemmen;abbinden
-je nachdem;kann sein, kann nicht sein;kommt (immer) drauf an (ugs.);(das) kommt darauf an (ugs.)
-Freiherr;Baron
-veraltet;auf den Müllhaufen der Geschichte (gehörend);archaisch;antiquiert;von gestern (ugs.);(Das ist doch) Achtziger! (ugs.);überaltert;old school (ugs., engl.);überholt;aus der Mottenkiste (stammend) (ugs., fig.);in die Mottenkiste (gehörend) (fig.)
-Farbstift;Buntstift;Malstift
-Mosaikdrucker;Rasterdrucker
-Stichpunkt;Stichwort
-TV-Gerät;Fernsehapparat (Hauptform);Kastl (ugs.);Patschenkino (scherzhaft, österr.);Röhre (ugs.);Fernseher (ugs.);Fernsehgerät;Mattscheibe (ugs., veraltend);Glotze (ugs.);TV (Abkürzung, engl.);Flimmerkiste (ugs.)
-operativ;betrieblich
-Controller;Buchprüfer;Rechnungsprüfer
-Rüsche;Falbel
-Wechselportefeuille;Wechselbestand
-in Gruppen einteilen;zusammenfassen;gruppieren;zusammenstellen;gliedern
-voriger;zurückliegender;vorhergehender;letzter
-kidnappen;verschleppen;entführen
-Fontäne;Springbrunnen
-Fußrücken;Rist;Spann
-Schlachthaus;Schlachthof
-in Gebrauch nehmen;einsetzen;nützen;benutzen;gebrauchen;zum Einsatz bringen;adhibieren (geh., veraltet);nutzen;anwenden;greifen zu;(zu etwas) heranziehen;benützen;verwenden;(sich) einer Sache bedienen
-Verelendung;Massenverarmung;Pauperismus;Verarmung
-Zustand;Geflecht;Aufbau;Struktur;Ordnung;Konsistenz;Verfasstheit;Gerüst;Gerippe;Gefüge;Qualität;Beschaffenheit;Organisation
-schimmern;scheinen;flimmern;glänzen
-saure Gurke;Pfeffergurke;Gewürzgurke;Essiggurke
-Schmelzzeit;Abschmelzdauer
-unterschlagen;nicht erwähnen;ungesagt lassen;nichts erwähnen (von) (ugs.);verschweigen (Hauptform);nicht eingehen (auf);verhehlen (geh.);unerwähnt lassen;nichts erzählen (von) (ugs.);verleugnen;nicht ansprechen;kein Wort über etwas verlieren;verheimlichen;unter den Tisch fallen lassen (ugs., fig.);mit keinem Wort erwähnen;(mit etwas) hinter dem Berg halten (ugs., variabel);nichts sagen (von) (ugs.)
-ODER-Verknüpfung;Disjunktion
-rein;unvermischt;pur;orthodox
-Spritzgussverfahren;Spritzguss;Spritzgießen
-Hoch;Höchststand
-(einen) hohen Stellenwert haben;kein Kleckerkram (ugs.);von großer Wichtigkeit;bedeutend;von großer Bedeutung;groß;maßgeblich;nicht zu unterschätzen;von Gewicht;keine Kleinigkeit (sein);Bedeutung haben;nicht zu vernachlässigen (sein);gewichtig;relevant;bedeutsam;ankommen auf (es);großgeschrieben werden (fig.);wichtig (sein) (Hauptform);von Belang;von Relevanz;(einen) hohen Stellenwert genießen;von Bedeutung (Hauptform);ins Gewicht fallen(d);zählen;zentral;Gewicht haben (fig.)
-Klöppel;Glockenklöppel;Spitzenklöppel (Handarbeit)
-(den) Bund der Ehe eingehen;Hochzeit machen (ugs.);(sich) trauen lassen;Hochzeit feiern;in den Hafen der Ehe einlaufen (fig.);(jemanden) ehelichen (Amtsdeutsch);kirchlich heiraten;(den) Bund fürs Leben schließen;(jemandem) die Hand fürs Leben reichen;(sich) das Ja-Wort geben (ugs.);(jemanden) freien (geh., veraltet);(jemandem) das Jawort geben (ugs.);(eine) Familie gründen;zum Mann nehmen;heiraten (Hauptform);(sich) (mit jemandem) verehelichen (geh.);in den (heiligen) Stand der Ehe (ein)treten;(sich) vermählen;(jemandem) das Ja-Wort geben (ugs.);zur Frau nehmen;(den) Bund der Ehe schließen (geh.);(sich) das Jawort geben (ugs.);zum Altar führen;standesamtlich heiraten;(die) Ehe mit jemandem eingehen;Hochzeit halten;Mann und Frau werden
-gutartig;benigne (fachspr.)
-Beutelratte;Taschenratte
-rollen;kollern (ugs.);kullern;kugeln
-Losung;Zugangscode;Codewort;Kennwort (Hauptform);Kodewort;Passwort (Hauptform);Parole;Schlüsselwort;Zugangswort;Geheimcode;Losungswort
-packen;einpacken
-Entschluss;Urteil;Entscheid (schweiz.);Ratschluss;Beschluss;Entscheidung;Wille
-verschmutzen;einsauen (derb);verdrecken;dreckig machen;beschmutzen;versiffen
-Schallgrenze;Schallmauer
-Tastaturkürzel;Tastaturkurzbefehl;Hotkey (engl.);Tastaturkombination;Tastensequenz;Tastaturbefehl;Shortcut (engl.);Tastenkürzel;Tastenkombination;Shortkey (engl.)
-Säuregehalt;Acidität (fachspr.);Säuregrad;Azidität (fachspr.)
-in Zeitlupe;schleppend;im Schritttempo;im Schnarchgang (ugs., fig., negativ);sehr langsam (Hauptform);im Schleichtempo (ugs.);(etwas) kommt so langsam wie beim Ochsen die Milch (ugs., scherzhaft);schleichend;quälend langsam;im Schneckentempo (übertreibend);im Zeitlupentempo (übertreibend);(nur) millimeterweise
-(sich) anpirschen;schleichen;(sich) heranschleichen
-Elektronengehirn (ugs., veraltet);universeller Rechner (fachspr.);Universalrechner (fachspr.);Elektronenhirn (ugs.);Rechner;Computer;elektronische Datenverarbeitungsanlage;Datenverarbeitungsanlage;Rechenknecht (ugs.)
-Appendix vermiformes (fachspr., lat.);Appendix;Wurmfortsatz des Blinddarms;Blinddarm (ugs., fälschlich);Wurmfortsatz
-Ileitis (fachspr.);Entzündung des Krummdarms
-Manen (ugs., Plural);(unheimliches o.ä.) Wesen;Spuk;Spirit;Schemen;Geist;Gespenst;Phantom;Spukgestalt
-Refraktometer;Brechzahlmessgerät;Brechzahlmesser
-pfefferig;gepfeffert
-geschlossen;alle Mann hoch (ugs.);mit der ganzen Korona (ugs.);gemeinsam;alle zusammen (ugs.);in geschlossener Formation
-Tanzsaal;Ballsaal
-Werbefachmann;Werbeagent
-albuminös (fachspr.);eiweißhaltig
-festbinden;anbinden
-Schätzung;Kalkulation;Zählung;Veranschlagung;Festsetzung;Berechnung;Ansatz;Voranschlag;Rechnung
-zuwuchern;zügellos wachsen;überwuchern;(sich) stark vermehren;(sich) stark ausbreiten;zuwachsen;auswuchern;immer neue Triebe bilden;wuchern (Hauptform)
-Zugfestigkeit;Reißfestigkeit;Zerreißfestigkeit
-Schöpfungsgeschichte;Genesis
-Mystizismus;Mystik
-Färberdistel;Saflor
-Propan;Propangas
-Kenntnisprüfung;Feststellungsprüfung
-Kühltruhe;Tiefkühltruhe;Gefrierschrank;Gefriertruhe;Eisschrank;Tiefkühler (schweiz.);Tiefkühlschrank
-zu bedenken geben;einen Wink geben;erwähnen;erkennen lassen;hindeuten;hinweisen;anmerken;einen Fingerzeig geben
-wohlgenährt;gut ernährt
-Wohltaten (journal.) (fig., politisch);Vergünstigung;unentgeltliche Zuwendung
-Geistesverwandter;Person mit gleichen Interessen;Gleichgesinnter
-Kürzung;Einbuße;Abstrich;Schmälerung
-mit Blitzlicht fotografieren;blitzen (ugs.)
-Anlage;Einteilung;Errichtung;Betriebsanlage
-Steuereinnahmen;Steueraufkommen
-(sehr) detailliert;ausführlich;spezifisch
-Kabuff (ugs.);Abstellkammer;Besenkammer;Rumpelkammer (ugs.);Putzraum;Putzkammer;Abstellraum;Kabäuschen (ugs.)
-cm (Einheitenzeichen);Zentimeter
-supplementär;ergänzend;komplementär
-Flaschenzug;Seilzug;Talje (fachspr., Jargon, seemännisch)
-Aktiva;Bilanzaktiva;Wirtschaftsgüter
-Solidaritätsgefühl;Zusammengehörigkeitsgefühl
-Erdball;Globus (griechisch);Erdkugel;Erdenrund (geh.);Weltkugel
-Parteigesinnung;Parteigeist
-Verträglichkeit;Vereinbarkeit;Interoperabilität;Kompatibilität;Kombinierbarkeit
-Waschhaus;Waschküche
-mit flatterndem Herzen (geh., dichterisch);bekümmert;angsterfüllt;angstvoll;ängstlich;furchtsam (vor);furchtsam;kleinmütig;in tausend Ängsten (sein);bange;zitternd;bebend;besorgt (um, wegen);mit Zittern und Zagen;bang;phobisch (fachspr.)
-Parallelen ziehen;gegenüberstellen;gegeneinander abwägen;einen Vergleich anstellen (zwischen);vergleichen;in Relation setzen;entgegensetzen;kontrastieren
-Geheimanalyse;Schlüsselanalyse
-Massenunruhe;Massenaufruhr
-Tribunal;Strafgericht;Strafgerichtshof
-Plotter;Kurvenzeichner
-niederstrecken;entnehmen (fachspr., Amtsdeutsch, Jargon);(ein Wildtier) schießen;abschießen;abknallen (ugs., abwertend);erjagen;aus dem Bestand (heraus)nehmen (fachspr., Amtsdeutsch);erlegen (Jagd) (geh., Hauptform);zur Strecke bringen (Jagd);(Tier mit Schusswaffe) töten
-Neuansteckung;Reinfektion
-Zwischengeschoss;Hochparterre;Mezzanin;Halbgeschoss
-spiralförmig;schneckenförmig;gewunden;schraubenförmig
-evozieren (geh.);hervorrufen;bewirken;verursachen
-Telefonanruf;Call (engl.);fernmündliches Gespräch (veraltet);Telefonat;Telefongespräch;Telefon (schweiz.);Anruf;telefonischer Anruf (ugs., scherzhaft);telefonischer Kontakt;Telefonkontakt
-Miefquirl (derb);Gasförderer;Gebläse;Exhaustor;Lüfter;Ventilator
-Ethnologe;Völkerkundler;Folklorist;Volkskundler
-Wechsel;Zu- und Abgang;Fluktuation
-Tresen;Theke;Verkaufstisch;Ladentisch
-Fragwürdigkeit;Zweifelhaftigkeit
-Weihnachts...;christnächtlich;weihnachtlich;weihnächtlich (schweiz.)
-anteilsmäßig;anteilmäßig;anteilig
-Zahlungsanweisung (veraltet);Zahlungsauftrag
-herausplatzen;losplatzen
-zwielichtig;zweifelhaft;nicht ganz astrein (ugs.);verdächtig;suspekt;undurchsichtig;undurchschaubar;mit Vorsicht zu genießen (ugs.);nicht ganz lupenrein (ugs.);krumm (ugs., fig.)
-Lage;Bauplatz
-unbesprochen;unerörtert;nicht besprochen;undiskutiert
-stillos;kitschig;geschmacklos;schaurig-schön;gewollt und nicht gekonnt (ugs.);billig (ugs.);abgeschmackt;stilwidrig;trashig (ugs., engl.)
-Klausel;Bestimmung;Regelung
-Sportpokal;Pokal;Kelch
-Erscheinung;Hirngespinst (ugs.);Chimäre;Illusion;Phantom;Schimäre;Einbildung;Phantasmagorie;Trugbild;Sinnestäuschung
-divergent (geh.);unvereinbar (Hauptform);inkonsistent (geh.);nicht zusammenpassend;inkompatibel (IT-Technik);unverträglich
-Denkapparat (ugs.);Dez (ugs.);Nischel (ugs.);Kopf;Schädel (ugs.);Birne (ugs.);Denkzentrum (ugs.);Kopp (ugs., norddeutsch);Omme (ugs.);Ballon (ugs., salopp);Rübe (ugs.);Haupt;Murmel (ugs.);Caput (fachspr.);Nuss (ugs.)
-Zeitsperre;Zeitabschaltung;Zeitlimit
-Körperkraft;Muskelkraft;Schmalz (ugs.)
-vermischt;synkretisch;zusammengesetzt;gemischt;unrein
-gutartige Wucherung von Gebärmutterschleimhaut;Endometriose (fachspr.)
-dependent;angewiesen (auf);am Tropf hängen (von) (meist finanziell) (fig.);süchtig;abhängig (von)
-Sassafraswurzel;Sassafras
-Skulpteur;Bildhauer;Plastiker;Steinmetz;Bildner;Steinbildhauer
-Bestialität;Inhumanität;Grausamkeit;Barbarei;Unmenschlichkeit
-Backsoda;Bullrich-Salz;doppeltkohlensaures Natron;Speisesoda;Natriumhydrogencarbonat (Hauptform);Back-Soda;Speisenatron;E 500 (ii) (E-Nummer);Natriumbicarbonikum;Natriumhydrogenkarbonat;NaHCO3 (Summenformel, chemisch);Natron;Natriumbicarbonat
-Verschleppungstaktik;Obstruktionspolitik
-Deckung;Decken
-in die eigene Tasche stecken (fig.);unterschlagen;hinterziehen;veruntreuen
-Weltsprache;Lingua franca;Verkehrssprache
-in vitro;im Reagenzglas
-(sich irgendwie) anhören;tönen (schweiz.);(irgendwie) klingen
-Kunde;Besteller;Bezieher;anfordernde Stelle;Bedarfsträger (Amtsdeutsch);Auftraggeber (Hauptform)
-Beutel;Tasche;Täschchen
-Abweichung;Ablage;Azimut
-unzählige Male;hundertmal;ein paar dutzend Mal;hundert Male;viele Tausend Male;dutzendmal;mehrere Male;etliche Male;dutzende Male;einige Male;viele Male;vieltausendmal;viele tausend Male;ein Dutzend Mal
-Frondeur (franz.);Antagonist;Gegner;Konkurrent;Widersacher;Konterpart;Gegenspieler;Neinsager;Kontrahent;Sparringspartner (fig.);Rivale;Widerpart;Opponent;Feind
-Phrase;Parole;Motto;Schlagwort;Stichwort
-ungebeten;unberufen
-pusten;blasen
-unecht;artifiziell (geh.);nicht echt;falsch;synthetisiert;nachgebildet;pseudo...;synthetisch;künstlich
-akkurat;gewissenhaft;sorglich (geh., veraltend);skrupulös;fein säuberlich;minuziös;korrekt;akribisch;penibel;sorgfältig;minutiös;genau;peinlich
-Musterabschnitt;Stoffprobe
-Zuneigung;Ergebenheit;Anhänglichkeit;Bindung (an)
-antipruriginös (fachspr.);juckreizhemmend
-Kleiderbügel;Bügel;Spannbügel
-Herold;Sprachrohr;Vorbote;Bote;Signalgeber;Verkünder;Ausrufer
-Exportbescheinigung;Ausfuhrbescheinigung
-Blutpfropfen lösendes Mittel;Thrombolytikum (fachspr.)
-Vorführdame;Mannequin;Modell;Fotomodell;Model (Hauptform)
-Fruchteinstellung;Praesentatio (fachspr.)
-Zielgebiet;Zielbereich
-Brummschädel (ugs.);Kopfweh;Zephalgie (fachspr.);Cephalgie (fachspr.);Cephalaea (fachspr.);Kephalgie (fachspr.);Kephalalgie (fachspr.);Kopfschmerzen;Kopfschmerz;Schädelweh (österr.)
-Mehrzweck...;Allzweck...;Multifunktions...;Universal...
-Unglück;Desaster;Unglücksfall;Unheil
-Vorposten;Außenstelle;Außenposten
-Blech reden (ugs., veraltend);rumspacken (ugs., jugendsprachlich, salopp);(herum)phantasieren (ugs.);wirres Zeug reden;irrereden (geh.);Unsinn erzählen (Hauptform);fabulieren;saudummes Zeug daherreden (ugs.);Scheiße labern (derb);kariert quatschen (ugs., berlinerisch);einen vom Pferd erzählen (ugs.);saublöd daherreden (ugs., süddt.);(etwas) fabeln (von);(herum)fantasieren (ugs.);spintisieren (geh.);(herum)spinnen (ugs.);Scheiße erzählen (derb);dummes Zeug erzählen (ugs.);(sich etwas / ugs. sich einen) zusammenphantasieren (ugs.)
-Ausschweifung;zügelloses Leben;Ausschweifungen
-wer;welche Person
-Auslandsverbindung (Telefon);Auslandsgespräch
-stachlig;dornig;stachelig
-Grobkonzept;Grundkonzept;Struktur
-Kohärer;Fritter
-Prosperität (fachspr., lat.);Fülle;Wohlstand;Gedeihen
-Magd;Dienstmagd
-Serien...;in Fortsetzungen
-Moralkodex;Auffassung von Moral;Sittenkodex
-Portemonnaie;Geldsack;Portmonee;Geldtasche (österr.);Geldbeutel;Brieftasche;Geldbörse
-tätlich werden (gegen);gewalttätig werden;handgreiflich werden;zulangen (ugs.)
-überfluten;überfließen
-Diktiergerät;Diktafon;Diktaphon
-Butskopf (geh., veraltet);Killerwal (ugs., Jargon);Orca;Schwertwal
-Verhunzung;Entstellung;Verunstaltung;Verunzierung
-herumhantieren (ugs.);herumfriemeln (ugs.);hantieren;herumnesteln;(sich) zu schaffen machen (an);herumtüfteln;herumbasteln (ugs.);(sich) versuchen an (geh.);herumfrickeln (ugs.);(sich) mühen (geh.);herumfummeln (ugs.);herumpfuschen (ugs., abwertend);herumwerkeln;herummachen;werkeln;herumbosseln (ugs.);herumfuhrwerken (ugs.);herumlaborieren (an / mit);herumhühnern (ugs.);vergeblich versuchen (zu);laborieren (an) (ugs.)
-an irgendeinem Ort;wo;irgendwo
-Hörorgan;Löffel (ugs.);Ohr;Ohrwaschl (ugs., bayr., österr.);Lauscher (ugs.);Gehör;Lauschlappen (ugs.)
-Aufweichen von Gewebe;Mazeration (fachspr.)
-chillig (ugs.);zwanglos;leger;entspannt;unbeschwert;formlos;tiefenentspannt (ugs., ironisch);unförmlich;locker;relaxed (ugs., engl.);launig;lässig;bequem;gelöst;ungezwungen;unverkrampft;geschmeidig (ugs.);relaxt (ugs.)
-Identifikation;Kennung
-unmerklich;nicht erkennbar;unsichtbar
-ausfüllen;eintragen;registrieren
-Ansteckung;Infektion
-brütend heiß (ugs.);glühend heiß (ugs.)
-anstreichen;anpinseln;streichen;bepinseln (ugs.);bemalen
-Spielstand;Punktestand;(erreichte) Punktzahl
-auf eine falsche Fährte locken (fig.);an der Nase herumführen (ugs., fig.);hereinlegen;irreleiten;düpieren (geh.);veräppeln (ugs.);verarschen (derb);verkaspern (ugs.);trompieren (ugs., franz., landschaftlich);(jemanden) irreführen;derblecken (ugs., bayr.);auf eine falsche Fährte führen (fig.);in die Irre führen;anschmieren (ugs.);(jemandem) Sand in die Augen streuen (fig.);reinlegen (ugs.);hinters Licht führen (ugs.);(jemanden über etwas) täuschen (Hauptform)
-Staubkorn;Stäubchen
-klipp und klar (ugs.);geradewegs
-betreffend;betreffs;betr. (Abkürzung)
-V. I. P. (engl.);VIP (engl.);berühmte Persönlichkeit;Berühmtheit;Promi (ugs.);Adabei (ugs., österr.);bekannte Persönlichkeit;Star;Prominenter
-Klavierhocker;Klavierstuhl
-Zwinger;Hundezwinger
-Vorgehensweise;Gangart;Handlungsweise
-Braue;Augenbraue
-berührungsempfindlicher Bildschirm;Sensorbildschirm;Touchscreen
-unwirsch;abweisend;unflätig;gröblich;wenig galant;ungeschliffen;hantig (ugs., bayr.);schroff;raubauzig (ugs.);ungalant;wie die Axt im Walde (ugs.);unsanft;ungehobelt;unhöflich;pampig (ugs.);kurz angebunden;ruppig;hau-drauf-mäßig (ugs.);wirsch;rustikal (ugs., scherzhaft-ironisch);uncharmant;unzivilisiert;harsch (geh.);grobschlächtig;grob;nassforsch (geh.);rau;in Wildwest-Manier (ugs.);rüde;rotzig (ugs.);raubeinig;rüpelhaft;grobklotzig;bärbeißig (fig.);nicht (gerade) die feine englische Art (fig.);brüsk;barsch;unfreundlich;derb;forsch;flegelhaft;rauborstig
-Troer;Trojaner
-unangenehm vertraulich;anhänglich;nicht (wieder) loszuwerden (ugs.);bedrängend;drängelnd;penetrant;zudringlich (Hauptform);Grenzen verletzend;unangenehm;indiskret;belästigend;grenzüberschreitend (Jargon);übertrieben zuvorkommend;(sich) anbiedernd;distanzlos;nicht abzuschütteln;drängend;lästig wie eine Klofliege (ugs.);schmierig;aufdringlich;lästig;von peinlicher Indiskretion;Grenzen ignorierend;übergriffig (geh., Jargon);peinlich indiskret;in (bester) Stalker-Manier
-freilegen;freigeben
-Karotte;Riebli;Mohrrübe;Gelbe Rübe (süddt.);Gelbrübe (süddt.);Möhre;Rüebli (schweiz.)
-antiquarisch;alt;antik (ugs.)
-den Wohnsitz wechseln;übersiedeln;(irgendwohin) gehen;dislozieren (schweiz.);eine neue Bleibe bekommen (Behörde o.ä.);zügeln (schweiz.);den Wohnort wechseln;umsiedeln;umziehen
-herunternehmen;abdecken
-Mrd.;Milliarde;1.000.000.000;1000 Millionen;tausend Millionen
-Vollzug;Erledigung;Ausführung;Abarbeitung;Transaktion;Tätigung;Vollziehung;Abhaltung;Umsetzung;Durchführung;Erfüllung;Abwicklung
-ohne nachzudenken;unüberlegt;reflexhaft;spontan;wie aus der Pistole geschossen (ugs.);ad hoc (geh., lat.);intuitiv;aus der Situation heraus;reflexartig;im Affekt (juristisch);aus dem hohlen Bauch heraus (ugs., fig.);ungeplant
-Zustandsgröße;Zustandsvariable
-lindern;mildern;abschwächen;mitigieren (fachspr.);vermindern;erleichtern
-Anschalteinrichtung;Einschalteinrichtung;Schalter
-Blatt (fachspr.);Klinge;Schneide;Messerklinge
-miotisch (fachspr.);Pupillen verengend
-Einschmelzung;Nekrolyse (fachspr.)
-Computergestützte numerische Steuerung;Computerized Numerical Control;CNC;Computer Numerical Control
-Phlebitis (fachspr.);Venenentzündung
-zur Schule schicken;einschulen
-Jesus von Nazareth;Jesus der Nazarener;Messias;Agnus Dei (kirchenlatein);Erlöser;(der) Nazarener;(der) Sohn Gottes;Heiland;Gottessohn;Jesus;Jehoschua;Christus;Jesus Christus (Hauptform);Lamm Gottes
-Dichte;Wichte (veraltet);Dichtheit;spezifisches Gewicht
-Osteomyelitis (fachspr.);Entzündung des Knochenmarks
-Wechselbetrieb;Halbduplexbetrieb
-Blutkreislauf;Zirkulation
-Inkarzeration (fachspr.);Einklemmung
-Nahesein;Nähe
-Frondienst;Robath (bayr.);Robot (österr.);Fronarbeit;Robote (österr.);Fron
-Stieltopf;Kasserolle;Kasserol
-steinig;kiesbedeckt;kieshaltig
-Ackerschnecke;Nacktschnecke
-Talent;Begabung;Fähigkeit;Gabe;Anlage
-v. u. Z. (Abkürzung);v. Chr. (Abkürzung);vor Christi;vor unserer Zeitrechnung;a. Chr. n. (Abkürzung);vor Christi Geburt;vor der Zeitenwende;ante Christum natum (lat.);vor Christus;ante Christum;a. Chr. (Abkürzung)
-Fokus;Brennpunkt
-Forschungsprojekt;Forschungsvorhaben
-Welt;Globus;Erde;blauer Planet (ugs.);Terra
-destabilisieren;entstabilisieren;aus dem Gleichgewicht bringen
-hastig;wild drauflos (ugs.);in Windeseile;in aller Eile;hektisch (Adv.);übereilt;holterdiepolter (ugs.);überhastet;überstürzt;in fliegender Hast (geh.);ohne (viel) nachzudenken;Hals über Kopf (ugs.)
-vomieren (geh., lat.);rückwärts essen (ugs., scherzhaft);(Nahrung) nicht bei sich behalten (können);hochwürgen;göbeln (ugs., regional);speiben (bayr., österr.);(etwas) erbrechen;brechen (ugs.);(sich) erbrechen;(sich) auskotzen (derb);kotzen (derb);Magen(inhalt) oral entleeren (variabel);spucken (regional);(das Essen) kommt oben wieder heraus (ugs.);Bröckchen lachen (ugs.);(sich) übergeben;speien;reihern (ugs.)
-Hilfsursprung;künstlicher Nullpunkt
-Isolator;Isoliermittel;Nichtleiter;Isoliermaterial;Dielektrikum;Isolierstoff
-(etwas) heißen (ugs.);besagen;schließen lassen auf;meinen;bedeuten
-Entweihung;Verschandelung
-feucht;feuchtkalt;dunstig;kühl und feucht
-in situ (fachspr.);in natürlicher Lage
-Obstkuchen;Obsttorte
-Pfahl;Pflock;Pfeiler
-drosseln;zügeln;zur Räson bringen;(jemanden) zur Vernunft bringen;mäßigend einwirken (auf jemanden);mäßigen;(jemanden) zur Besinnung bringen;dafür sorgen, dass jemand (wieder) Vernunft annimmt (ugs., variabel)
-Grundbuchauszug;Katasterauszug
-Tachygraphie;Steno (ugs.);Stenografie;Schnellschrift;Redezeichenkunst;Engschrift;Phonographie;Eilschrift;Stenographie;Kurzschrift
-Oocyte;Ei;Ovum (fachspr.);Eizelle
-Erbteil (schweiz.);Legat;Erbschaft;Vermächtnis;Hinterlassenschaft;Erbgut;Erbe;Nachlass;Hypothek (fig.)
-Anbetung;Verehrung
-computergestützte Produktion;Computer Integrated Manufacturing;CIM
-(sich) zersetzen;verwesen;verkommen;putreszieren (lat.);verfallen
-Rückhandschlag;Rückhand
-rekuperieren;wiedergewinnen;wiedererlangen;zurückgewinnen;wieder finden
-einschließen;umgeben;einfassen
-Tokio;Tokyo
-Ahnenforschung (ugs., Hauptform);Familiengeschichtsforschung;Genealogie (fachspr.);Familienforschung
-Albernheit;Kinderei(en);Mätzchen;Flausen;Sperenzchen (ugs., regional);Sperenzkes (ugs., regional);Sperenzien (ugs.)
-Laufsteg;Steg
-Verkaufserfahrung;Verkaufspraxis;Verkaufskenntnis
-Haarstrich;Haaransatz
-biegsam;schmiegsam
-matt;ruhig (fig.);gedämpft;gedeckt (Farbe/n) (Hauptform);dezent;sanft (Farbe)
-hinter den sieben Bergen (geh., literarisch);Outback (Australien) (fachspr., engl.);Öde;Einöde;Ödnis (geh.);Pampa (ugs., fig.);Walachei (ugs.);Ödland;(am) Arsch der Welt (derb)
-gewerblich genutzte Räume;gewerbliche Räume;Gewerberäume
-(jemandem) entgegentreten;Trotz bieten (geh., altertümelnd);Einhalt gebieten (geh.);(sich jemandem) entgegenstellen (auch figurativ);(jemandem) in den Weg treten (ugs.)
-sachlich reden (mit);offen reden;frank und frei reden
-Treue;Loyalität;Zuverlässigkeit
-unaufdringlich;zurückgezogen
-wohltätig;ohne selbst einen Vorteil davon zu haben;karitativ;humanitär;für einen guten Zweck
-wohlproportioniert;formschön;ästhetisch;wohlgeformt
-Salat anmachen;Salat machen
-Schritt für Schritt;schrittweise;stufenweise;Zug um Zug;diskontinuierlich;diskret;inkrementell (fachspr.)
-Benachteiligung;Übertölpelung;Schaden;Übervorteilung;Nachteil
-übrig haben;erübrigen
-orofazial (ugs.);Mund und Gesicht betreffend
-gehorchen (Hauptform);(sich) Weisungen fügen;(nach jemandes) Pfeife tanzen (fig.);(den Anordnungen) Folge leisten;tun, was man gesagt bekommt;springen (ugs., fig.);(sich) unterordnen;subordinieren (geh.);(sich) beugen;(sich) unterwerfen;spuren (ugs.)
-von der Pike auf (lernen) (ugs.);grundsätzlich;ganz von vorne;vom Grunde aus (ugs., veraltet);grundlegend;von Grund auf
-Patch (engl.);Flicken (Hauptform);Fleck (regional);Aufnäher (vorgefertigt);Flecken
-gerippt;gestreift
-medienwirksam;dramatisch (floskelhaft);bühnenreif (geh., fig., ironisierend);aufsehenerregend;sensationell;Aufsehen erregend;hollywoodreif (fig.);spektakulär;effektvoll;imposant;unglaublich (mediensprachlich);filmreif (fig., ironisierend)
-beobachten;im Sichtfeld haben;im Visier behalten;im Blick haben;nachhalten;im Visier haben;beaufsichtigen;kontrollieren;aufpassen;überwachen;checken
-Zinder;ausgeglühtes Stück Holz
-erschließen;urbanisieren;verstädtern;kultivieren;zivilisieren
-heulen (ugs.);wehklagen;raunzen (ugs., österr.);barmen (geh., literarisch, regional, veraltend);janke(r)n (ugs.);lamentieren (abwertend);klagen;jammern (Hauptform);zetern;bejammern
-Mensch (Hauptform);Frau (weibl.);Einzelwesen;Typ (ugs.);Individuum (geh.);Persönlichkeit;Person (Hauptform);Charakter;Mann (männl.);Subjekt (ugs., abwertend)
-vorwärts;voraus;voran
-Ingredienzien;Inhaltsstoffe;Zutaten;Bestandteile
-Käseschale;Käserinde
-Beigabe;Zugabe;Zutat;Ingrediens;Ergänzung;Ingredienz
-Ausgangspunkt;Ansatzpunkt
-Brigadier;Brigadegeneral
-Dyspepsie (fachspr., griechisch);Indigestion (fachspr., lat.);Verdauungsstörung
-Terrakottafigur;Terracotta;Terrakotta
-Fessel;Kette;Handschelle;Handfessel
-Beize;Färbemittel;Farbe
-Nachahmung;Falsifikat;Fälschung;Falsifikation
-Milchproduktion;Laktation
-Betriebsfeier;Betriebsfest
-der Länge nach;längs;in ganzer Länge
-vierstimmig;quadrophon;für vier Stimmen
-Schauspieler;Akteur;Mime;Darsteller;Schmierenkomödiant (derb, abwertend)
-Enthaltung;Aszese (selten);Entsagung;Enthaltsamkeit;Abstinenz;Askese
-(sich) niederlassen (geh.);seinen Hintern (auf einen Stuhl usw.) quetschen (derb);Platz nehmen (Hauptform);(sich) hinsetzen;(sich) platzen (ugs., scherzhaft);(sich in einen Sessel / auf die Couch usw.) fallen lassen (ugs.);abhocken (derb, schweiz.);(sich) niedersetzen;(sich) hinpflanzen (ugs.);es sich bequem machen;es sich gemütlich machen;(sich) platzieren;(sich) setzen
-Nazigruß;Deutscher Gruß;Hitlergruß
-innerpolitisch;innenpolitisch
-zusperren;verbarrikadieren;abblocken;verriegeln;verrammeln;versperren;sperren;barrikadieren
-MAD;Militärischer Abschirmdienst
-gute Stube (ugs., veraltend);Stube;Herrenzimmer (geh., veraltet);Salon;Wohnzimmer;Wohnstube
-Bolusinjektion (fachspr.);intravenöse Schnellinjektion
-Falsifikator;Verfälscher;Fälscher
-die Verpflegung liefern;catern;verproviantieren;mit Proviant beliefern
-Otorhinolaryngologie (fachspr.);Hals-, Nasen- und Ohrenheilkunde (HNO)
-Mark;Fruchtfleisch;Pulpa;Pulp;Pulpe;Fruchtmark;Fruchtpulpe
-Verbindungsstelle;Übertritt
-kartellfeindlich;monopolfeindlich
-ruinieren;zu Grunde richten;runterwirtschaften;zugrunde richten;abwirtschaften;zerrütten
-merklich;wahrnehmbar;detektierbar;erkennbar;bemerkbar
-auf dem falschen Dampfer sein (ugs., fig.);auf dem Holzweg sein (ugs., fig.);im Irrtum sein;(sich) vertun (ugs.);(sich) geschnitten haben (ugs., fig.);(sich) irren (Hauptform);einem Irrtum erliegen (geh.);fehlgehen (in der Annahme) (geh.);falschliegen (ugs.);(sich) verschätzen;einem Irrtum unterliegen (geh.);(etwas) falsch sehen (ugs.);danebenliegen (ugs.);(etwas) falsch einschätzen;(sich) täuschen
-Verteilungs...;Verteiler...
-Rechtmäßigkeit;Gesetzmäßigkeit;Legalität
-Hirnhautentzündung;Meningitis (fachspr.)
-Vasculitis (fachspr.);Gefäßentzündung
-Prüfung;Untersuchung;Ermittlung
-kopieren;abpausen (ugs.);durchpausen
-Fährte;Fußspur;Fußabdruck;Spur
-armer Student (oft ironisch) (ugs.);Student (Hauptform);(eine) Studierende (gendergerecht, Hauptform);Studierender (gendergerecht, Hauptform);Studiosus (ugs.);stud. (Abkürzung);Studi (ugs.);Studiker (ugs., ironisch)
-Startbahn;Landestreifen;Piste (ugs.);Landebahn;Start-und-Lande-Bahn;Rollfeld (ugs.);Bahn (ugs.)
-eingegangen;geschrumpft;zusammengeschrumpft;zusammengestrichen (ugs.);verringert (ugs.);reduziert;vermindert (ugs.)
-(jemanden) unter seine Fittiche nehmen (ugs.);(jemandem) die Steine aus dem Weg räumen (fig.);supporten (ugs., Anglizismus, technisch);unterstützen (Hauptform);(jemandem) unter die Arme greifen (ugs., fig.);unterstützend tätig sein;protegieren (geh.);(eine) Lanze brechen für (jemanden / etwas) (fig.);fördern;(jemandem) hilfreich zur Seite stehen;beistehen;behilflich sein;begünstigen;(jemandem) den Weg ebnen (fig.);(jemandem) den Rücken stärken (fig.)
-(sich) vergreifen an;Notzucht verüben (an);missbrauchen;zum Sex zwingen;schänden (altertümelnd);(sich) vergehen an;vergewaltigen (Hauptform);notzüchtigen (veraltet)
-Abnehmen;Nachlassen;Verringerung;Sinken
-(das) Reißen (ugs.);Gliederschmerzen;Krankheiten des rheumatischen Formenkreises (fachspr.);Rheumatismus;Rheuma (Hauptform);Gliederreißen
-Ing. (Abkürzung);Ingenieur
-Verziehen (von Holz);Verwerfung;Verkrümmung
-Nekropsie (v.a. bei Tieren) (griechisch);innere Leichenschau;Obduktion (lat.);Sektion (lat.);Autopsie (griechisch);Nekropsie;Leichenöffnung
-Meteorologe;Wetterfritze (ugs., salopp);Wetterfrosch (ugs., fig.)
-Maskulinismus (fachspr.);Chauvinismus;chauvinistische Äußerung
-tingieren;färben;nuancieren;tönen;einfärben;kolorieren;abtönen
-Außenhaut;Bordwand
-verletzend;schwarzhumorig;bissig;schneidend;beißend;sarkastisch;ätzend;polemisch;satirisch;beleidigend;spöttisch;spitzzüngig;spitz;schnippisch;zynisch;scharfzüngig
-Besprechungsprotokoll;Sitzungsprotokoll;Niederschrift;Protokoll;Memo
-Konsequenz;Folgeerscheinung;Ausfluss;Wirkung;Auswirkung;Ergebnis;Effekt;Nachwirkung;Folge
-überladen;vollpacken;vollstellen;dicht zusammendrängen;voll stopfen;voll packen;voll stellen;vollstopfen;obstipieren
-Zwischensatz;Einschub;Parenthese;Zwischenbemerkung
-Sprung;Verbindungsstelle;Falz;Fuge
-Grenzpolizei;Grenzschutz
-frickeln (ugs.);zurechtbasteln;takeln
-Salzsole;Salzquelle;Solquelle
-(dein) Freund und Helfer (veraltend);Polizist (Hauptform);Schutzmann;Schutzpolizist (veraltet);Ordnungshüter;Sheriff (ugs., fig.);Cop (ugs., engl.);Schupo (ugs., veraltet);Wachtmeister;Bulle (ugs.);Gendarm (österr.);(der) Arm des Gesetzes (ugs., fig.);Polizeibeamter;Polyp (derb);Kiberer (ugs., österr.);Herr in Grün (ugs.);Gesetzeshüter
-(jemanden) erwischen;(jemanden) haschen (altertümelnd, literarisch);(jemanden) zu fassen bekommen;(jemanden) stellen;(jemanden) schnappen;(jemanden) fangen
-unbestraft;ungeahndet
-Autoschlange;Engpass;Blechlawine (ugs.);Verkehrsstau;Stau;Stop and Go (engl.);Stauung;zähfließender Verkehr;Rückstau
-Stationierung;Einsatz;Aufstellung
-verletzen;brechen;(Vertrag) nicht einhalten
-Wichtigkeit (ugs.);Wert;Bedeutung;Rang;Geltung;Einfluss
-Rute;Stock;Stab;Stecken;Stange
-Kaufmann;kaufmännischer Angestellter;Verticker (ugs., abwertend);Verkäufer (Hauptform);kaufmännischer Mitarbeiter
-Abwiegelung;Beruhigung;Beschwichtigung;Beruhigungspille (fig.)
-verbinden;zusammenfügen (Hauptform);verschweißen;aneinanderfügen (geh.);zusammenleimen;fest (miteinander) verbinden;zusammenkleben;zusammenschweißen;verkleben;verleimen
-Pressform;Modellform
-jemanden von etwas abbringen;jemanden an etwas hindern;jemanden von etwas abhalten
-zuordnen;zumessen;austeilen;verteilen;zuteilen
-ringen;strampeln
-Spinngewebe;Spinnwebe;Spinnengewebe;Spinnennetz
-Abdruck;Lunke (fachspr., norddeutsch);Vertiefung;Blötsch(e) (ugs., kölsch);Delle;Dötsch (ugs., rheinisch, ruhrdt., veraltend);Beule
-gelungener Streich;Ulk;Coup;Streich
-einlagern;hinterlegen;lagern;deponieren;ablagern;in Verwahrung geben
-zusammenmischen;zusammenschütten;zusammenfassen;bündeln;zusammenlegen;gruppieren;poolen
-(sich) handeln um (es);Thema sein;gehen um (es);(sich) drehen um (ugs.);zum Gegenstand haben;handeln von
-Reisekosten (Pluraletantum);Tagegeld;Spesen (Pluraletantum);Reisespesen (Pluraletantum)
-Amtsleiter;Amtsvorsteher
-Dienstbarkeit;Servilität;Gefügigkeit;Unterwürfigkeit
-Zu-spät-Kommer (ugs.);Bummler (ugs.);Nachzügler;Bummelant (ugs.)
-rechenaufwändig;rechenintensiv
-klirren;klimpern;klickern
-fassförmig;Fass...
-Kurvenschreiber;XY-Schreiber;Koordinatenschreiber
-kontra;versus;contra;vs.;wider (geh.);gegen
-Abo;Dauerbestellung;Abonnement (franz.)
-Paralympische Spiele;Paralympics;Behindertenolympiade (ugs.)
-Leukozyt (fachspr.);weißes Blutkörperchen (veraltet);weiße Blutzelle
-Kastenweißbrot;Toast (engl.);Toastbrot;Röstbrot
-unmanierlich;rotznäsig (ugs.);rotzig (ugs.);flegelhaft;schnöselig (ugs.);bübisch;rotzfrech (ugs.);lausbubenhaft;lümmelhaft
-periphere Geräte;Zusatzgeräte
-verborgen;versteckt;latent;unterschwellig;unbewusst;getarnt
-Seiten...;seitlich (von)
-Zuwachs;Disagio
-(jemandes) Schwachpunkt;(jemandes) offene Flanke (fig.);(jemandes) Schwachstelle;(jemandes) Achillesferse (geh.);(jemandes) schwache Seite;(jemandes) wunder Punkt
-Stachelrad;Zahn;Sprossenrad;Zahnkranz
-Gesetzlosigkeit;Rechtlosigkeit
-Herabsetzung;Senkung;Reduktion;Minderung;Reduzierung;Verkleinerung;Ermäßigung
-im Verfall begriffen;kränklich;morbid;krank
-Mittagszeit;Mittagspause
-foltern;peinigen;torquieren (geh., veraltet);martern;quälen;plagen
-dösig (ugs.);langsam (im Kopf);schlafmützig (ugs.);denkfaul;begriffsstutzig;stumpfsinnig
-(sich) ausweiten (zu);ausarten (in);eskalieren;(so) weit kommen (ugs.);(sich) auswachsen (zu)
-Schaumschlägerei (ugs.);Großtuerei;Rodomontade (geh., franz., ital.);Großsprecherei;Bravade (geh., franz., griechisch, ital., lat., veraltet);Angabe (mit) (ugs.);Fanfaronade (geh., bildungssprachlich, franz.);Angeberei;Windmacherei;Protzerei;Wichtigtuerei (ugs.);Maulheldentum;Geprahle;Geprotze;Gaskonade (geh., sehr selten, veraltet);Renommisterei (bildungssprachlich);Aufschneiderei (ugs.);Prahlerei
-Zweifel hegen;bezweifeln;(etwas) in das Reich der Fabel verweisen (geh.);(einer Sache) misstrauen;skeptisch sein;nicht glauben (wollen);beargwöhnen;anzweifeln;nicht (so) recht glauben (wollen) (ugs.);kaum glauben können (was man zu hören bekommt);kaum glauben können (was man sieht);in Zweifel ziehen;infrage stellen;(jemandem etwas) nicht abnehmen (ugs.);zweifeln (an);in Frage stellen
-Vanellus vanellus (fachspr., lat.);Kiebitz (fachspr.)
-(sich) zur Wehr setzen;Protest einlegen;Einspruch erheben;protestieren;Protest erheben;widersprechen;Widerspruch erheben;dagegenhalten;(sein) Veto einlegen
-Kante;Ecke;Winkel
-Palmwein;Toddy
-Föhn;Haartrockner;Fön
-vertrocknen;dehydrieren;ausdörren;verdorren;austrocknen;ausdorren
-schneiden;sensen;abmähen;sicheln;kürzen;absicheln;mähen
-unübertrefflich;prachtvoll;(jemandem) lieb und teuer;erstrebenswert;wertvoll;kostbar;vortrefflich;erlesen;lohnenswert;köstlich
-windschnittig;aerodynamisch;windschlüpfig;windschlüpfrig;stromlinienförmig
-Silex;Flint;Feuerstein
-<;Kleiner-als;linke spitze Klammer;Kleiner-als-Zeichen
-unerprobt;unbewiesen
-S. (Abkürzung);Seite
-Maß;Metrik
-Weinschorle;Gespritzter;Schorle
-Höchstgrenze;Obergrenze;oberste Grenze;Höchstmaß
-Grabschrift;Grabinschrift
-Mitgliedsbeitrag;Beitrag
-Siedepunkt;Kochpunkt;Verdampfungspunkt
-ranzig;vergammelt
-Wettsegeln;Regatta
-Meister (Hauptform);Handwerksmeister;Experte
-Serienherstellung;Serienproduktion
-bevollmächtigen;in die Lage versetzen;ermächtigen;befähigen
-Probeexemplar;Musterexemplar
-Responsion;Gegenrede;Gegenbemerkung;Widerrede;Konter (ugs.);Antwort;Entgegnung;Erwiderung;Rückäußerung;Auskunft;Replik (geh.);Reaktion;Rückmeldung
-voller Klang;Sonorität
-Erwerbsleben;Arbeitsleben;Arbeitsalltag;Berufsleben (Hauptform)
-Brandzeichen;Brandmal
-Schwefelholz (veraltet);Streichholz;Schwedenholz (veraltet);Zündholz;Schwefelhölzchen (veraltet)
-Titelperson;Hauptdarsteller;Held;tragende Figur;Hauptrolle;zentrale Figur;Schlüsselperson;Hauptperson;tragende Rolle;Hauptakteur;Hauptfigur;Star (engl.);Protagonist (griechisch);Leitfigur
-straff;fest;stramm
-unsterblich;unvergänglich;unausrottbar;langlebig;nicht kaputtzukriegen (ugs., fig.);Totgesagte leben länger. (ugs., sprichwörtlich);(sich) lange halten (ugs.);zählebig;nicht totzukriegen (ugs., fig.)
-(zeitlich) nach vorn gerichtet;anterograd (fachspr.)
-Metallbeschichtung;Metallisierung
-treten;strampeln;um sich treten;ausschlagen (Pferd)
-Aufenthaltsort;Verbleib
-Eischnee;steifgeschlagenes Eiweiß
-Valvulae (fachspr.);kleine Klappe
-Wörterliste;Wörterverzeichnis;Vokabular;Vokabularium (geh.);Glossar (fachspr., griechisch, lat.);Glossarium (griechisch, lat.);Vokabelverzeichnis;Begriffsklärung
-UNCC (Abkürzung, engl.);Entschädigungskommission der Vereinten Nationen
-Elektrokardiogramm;EKG
-ephemer;transitorisch;sich häufig ändernd;schnelllebig;kurzlebig;flüchtig;vergänglich
-Mädel (ugs.);Mieze (ugs., sexualisiert);Girl (ugs.);Fräulein (veraltet);Mädchen;junge Dame;Maid (poetisch, veraltet);junge Frau (Hauptform);Deern (norddeutsch);(junges) Ding;Dirn(e) (regional, veraltet)
-Zitronengirlitz;Zitronenzeisig
-Rechtsnachfolger;Zessionar
-Zopf;Flechte
-Sagen- und Märchengut;Überlieferung;Überlieferungen
-Urinal;Pinkelbecken (ugs.);Pissoir (franz., fälschlich);Pissbecken (derb)
-brechen;bersten;platzen
-kitzeln;krabbeln;kribbeln
-Schlagzeug spielen;die Trommel schlagen;Pauke spielen;pauken;trommeln
-Streichung;Rotstift (fig.);Kürzung
-Stadtbewohner;Städter;Stadtmensch
-Arzneimittel;Mittel (ugs.);Therapeutikum;Präparat;Medikament;Pharmazeutikum;Heilsubstanz;Agens (fachspr.);Heilmittel (ugs.);Pharmakon (Plural = Pharmaka) (fachspr.);Arznei;Medizin;Remedium
-Wechselstromwiderstand;Impedanz
-..., schätze ich (ugs.);wahrscheinlich;dürfte;..., denke ich (ugs.);..., vermute ich;..., glaube ich (ugs.);vermutlich;so, wie es aussieht (ugs.);aller Voraussicht nach;schätzungsweise;voraussichtlich
-Warteraum;Wartesaal;Wartezimmer
-Verbundenheit;Hinwendung;Zuneigung (zu)
-en bloc;zusammen;geschlossen;kompakt;Gemein...;gemeinschaftlich;verbunden;gemeinsam
-handgeschrieben;handschriftlich
-Ekelpaket (ugs.);Fiesling (ugs.);übler Bursche;Kotzbrocken (ugs.);fiese Möpp (ugs., kölsch);Widerling;Schweinebacke (derb);fieser Typ (ugs.);Sackgesicht (derb);widerliche Type;(das) Ekel (ugs.);widerwärtige Person (Hauptform);Rüpel;Schweinepriester (derb);Pestzecke;übler Patron;Knilch (ugs.);schlimmer Finger (ugs., fig., veraltend);Knülch (ugs.);Drecksack (derb);Unsympath;Dreckskerl (ugs.)
-Thromboembolie (fachspr.);Verschluss eines Blutgefäßes durch einen Blutpfropf
-stofflich;physisch;körperlich;materiell
-besprenkeln;beregnen;besprühen;benetzen;bespritzen;besprengen;berieseln
-Vorbote;Vorbedeutung;Vorzeichen;Auspizium (geh., lat.);Omen;Anzeichen
-schulen;bilden;erziehen;beschulen (fachspr.);ausbilden
-Reiseflugzeug;Passagiermaschine (ugs.);Passagierflugzeug
-Sauferei (ugs.);Suff;Sauforgie (ugs.);Gelage;Saufexzess;Symposion (Antike) (geh.);Bacchanal (geh.);Binge-Drinking (engl.);Konvivium (geh., lat.);Alkoholexzess;Besäufnis (ugs.);Trinkgelage;Komasaufen (ugs.);Alkoholgelage;Komatrinken (neudeutsch) (ugs.);Zechgelage;Druckbetankung (ugs., fig.);Sturztrunk (geh., veraltet);Kneipabend (fachspr., Jargon, burschenschaftlich);Kampftrinken (neudeutsch) (ugs.);Saufgelage (ugs., Hauptform);(das) Kneipen (fachspr., Jargon, burschenschaftlich);wüstes Gelage;Rauschtrinken;Zecherei
-Eingabekontrolle;Eingabesteuerung
-Gobelin;Gobelinteppich
-Pflanzenlehre;Botanik;Pflanzenkunde
-pastös;viskos (fachspr.);hochviskos (fachspr.);weich;matschig;breiig
-Spange (ugs.);Klammer (ugs.);Zahnklammer;Schneeketten (derb);Zahnspange
-in Konkurs gehen;Pleite machen;Gläubigerschutz beantragen;Pleite gehen;Konkurs anmelden;in Insolvenz geraten
-dickflüssig;klebrig;viskos (fachspr.);pastös (fachspr.);pastos (fachspr.);pappig (ugs.);zäh;zähflüssig;viskös (fachspr., selten);schwerflüssig
-gepaart (mit);verbunden (mit);gekoppelt (mit);abhängig (von);bedingt (durch)
-Antinomie (fachspr.);Falsum (fachspr.);Unvereinbarkeit;Kontradiktion (fachspr.);Gegensätzlichkeit;Widerspruch
-überhäuft;übersättigt
-präparieren (geh.);vorbereiten;die Voraussetzungen (für etwas) schaffen;die Grundlage (für etwas) schaffen;den Boden bereiten (für) (fig.)
-lüstern;schamlos
-wöchentlich (Hauptform);(einmal) pro Woche;einmal in der Woche;jede Woche einmal;einmal die Woche (ugs.)
-Fahrspur;Wagenspur
-Beanstandung;Beschwerde;Reklamation
-flöten (ugs.);Flöte spielen
-Sprachmittler;Übersetzer;Dolmetscher;Interpreter
-professionell;beruflich
-Urgenz (fachspr.);Harndrang
-Maisflocken;Cornflakes
-unsittlich;anstößig;obszön;unzüchtig;priapeisch (geh., veraltet);nicht stubenrein (ugs., fig., scherzhaft);unkeusch (geh.);zotig;dreckig (ugs., fig.);nicht salonfähig;unanständig;schweinisch (ugs.);schmutzig (fig.);eindeutig-zweideutig;versaut (derb)
-(etwas) erfahren;informiert werden;Bescheid bekommen (über);(von etwas) in Kenntnis gesetzt werden (Amtsdeutsch);(bei jemandem) ankommen (Information) (ugs., fig.);(eine / die) Information erhalten
-Steatose (fachspr.);Verfettung
-unjustiert;unausgerichtet
-Angelegenheit;Affäre
-abweiden;abgrasen;grasen;weiden
-Stuckverzierung;Stuck;Deckenfries
-Hohlraum;Lücke;Leerstelle;Leerraum;Kavität;Zwischenraum;Auslassung
-Sicherheitsvorkehrung;Vorsichtsmaßregel;Vorsichtsmaßnahme
-Großserienfertigung;Massenproduktion;Großserienproduktion;Massenfertigung;Massenerzeugung;Großserienfabrikation;Großserienerzeugung;Massenfabrikation
-Rohr;Rohrleitung
-(ausführendes) Organ;Exekutive (franz., lat.);(wirkende) Kraft;vollziehende Gewalt
-(von der Sonne) braun werden;(sich) sonnenbaden;Farbe bekommen (ugs.);in der Sonne baden;(sich) sonnen;ein Sonnenbad nehmen;(sich) bräunen
-Pustelausschlag;Pyodermie (fachspr.)
-Glaube an viele Götter;Vielgötterei;Polytheismus
-nach eigenem Ermessen;ohne (erst) um Erlaubnis zu fragen;nach (seinen) eigenen Regeln;eigenmächtig;ohne Genehmigung;unbefugt(erweise);nach eigenem Gutdünken;eigenverantwortlich;ohne (erst) um Erlaubnis zu bitten;eigenwillig;auf eigene Faust (ugs.);unerlaubterweise
-Verkleidung;Wandbekleidung
-Pfandrecht;Zurückbehaltungsrecht
-Gelenkentzündung;Osteoarthritis
-schnitzen;einritzen;einschnitzen;einschneiden (in)
-hundemüde (ugs.);todmüde (ugs.);sterbensmüde (ugs.);sehr müde
-Zeitgeber;Timer
-Selbsterkenntnis;Einsicht;Erkenntnis
-Attitüde;Couleur;Gesinnung;Veranlagung;Grundeinstellung;Haltung;Stellung;Charakteranlage;innere Haltung;Neigung;Standpunkt
-(sich) gut artikulieren können;redegewandt sein;nicht auf den Mund gefallen sein (ugs.);(sich) gut ausdrücken können;schlagfertig sein
-Klammerzeichen;Klammer
-weitab;fern;in weiter Ferne;weit weg
-verabscheuungswürdig;verabscheuenswert;verabscheuungswert;hassenswert
-illusionär;illusorisch;abwegig;unerreichbar;absurd
-Vorfall eines Gewebes;Prolaps (fachspr.)
-Irdenware;Steingut
-Verbrennung;Brandverletzung;Brandwunde;Combustio (fachspr.);Verbrennungstrauma
-Nummer;Ziffer;Kennziffer;Menge;Nr. (Abkürzung);Vielheit;Zahl
-Brechstange;Brecheisen;Stemmeisen
-dichotomisch (fachspr.);uneins;zwiegespalten;zwiespältig;dichotom;gespalten;unentschieden
-Godemiché;Dildo;künstlicher Penis
-Binnensee;See;Landsee (veraltet)
-eingefasst;eingezäunt;eingerahmt;eingegrenzt
-Randstein;Prellstein
-Steigleitung;Steigung
-(innerlich) verarbeiten;(etwas) hinter sich lassen;fertig werden (mit);(mit etwas) abschließen
-Pruritus (fachspr.);Jucken;Juckreiz
-Kollege;Mitarbeiter;Arbeitskollege
-aufreihen;ordnen;sequentialisieren;in eine Reihenfolge bringen;sequenzialisieren
-Frevel;Religionsvergehen (fachspr.);Kirchenschändung;Sakrileg
-hervorrufen;erregen;wachrufen
-Kunstfertigkeit;Geschicklichkeit;Handgeschick (fachspr.);Geschick;Fertigkeit
-jemandem unterstehen;jemandem unterstellt sein
-Geheimhaltung;Stillschweigen;Heimlichkeit;Diskretion
-für echt erklären;bezeugen;authentifizieren (geh.);verifizieren;(Echtheit) bestätigen;beglaubigen
-ein Bild von (einer Frau / einem Mann) (ugs.);überwältigend;unwiderstehlich;bildschön;umwerfend;wunderschön;wunderhübsch;bildhübsch
-(sich) verschieben;(sich) verlagern;wechseln;(sich) verwandeln
-Tympanum (fachspr.);Mittelohr
-(sich einer Sache) entäußern (geh.);Abstriche machen;von etwas absehen;(einer Sache) entsagen (geh.);(auf etwas) verzichten;(in etwas) nachgeben;abandonnieren (geh., veraltet)
-Verbraucher;Konsument;Abnehmer;Nachfrager (fachspr.)
-zweifelhaft;lichtscheu (fig.);dubios (Hauptform);obskur;halbseiden;nicht vertrauenswürdig;ominös;undurchsichtig;dunkel (fig.);anrüchig;zwielichtig;nicht (ganz) koscher (ugs.);fragwürdig;windig
-ungewöhnlich;eigentümlich;eigenartig;sonderbar;außergewöhnlich;merkwürdig;komisch;seltsam (unerklärlich) (Hauptform);obskur;wunderlich;(ein) eigen Ding (geh., veraltend);ominös (geh.)
-Tonikum;Kräftigungsmittel;Stärkungsmittel;Roborans
-schon mal (ugs.);zwischendurch;unterdessen;währenddessen;einstweilen;nunmehr (geh.);mittlerweile;zwischenzeitlich;indes (geh.);inzwischen (Hauptform);derweil;indessen;in der Zwischenzeit;zwischenzeitig;währenddem (ugs.);in dem (geh., regional, veraltend)
-Gefühlsregung;Sentiment;Stimmungslage;Affekt (fachspr.);Gefühlsaufwallung;Gefühlsbewegung;Gespür;Gefühlswallung;Gemütsbewegung;Empfindung;Emotion;Gefühlserregung;Regung;menschliche Regung;Gefühl (Hauptform)
-Andachtsraum;Oratorium;Gebetsraum
-Schaltschema;Kreislauf
-Involution (fachspr., lat.);Rückbildungsprozess einzelner Organe;(natürliche) Rückbildung
-in aller Regel;normalerweise;vorwiegend;überwiegend;größtenteils;mehrheitlich;vornehmlich;in der Regel;meist
-Chancen;Entwicklungsmöglichkeiten;Optionen;Möglichkeiten;Wege
-Pacemaker;Herzschrittmacher
-Reha (ugs.);Wiedereingliederung;Rehabilitation;Rehabilitierung
-Begleitumstand;Nebenumstand
-theistisch;auf dem Theismus beruhend
-Satellitenfoto;Satellitenbild
-Fetzen;Schnipsel;Fragment;Schnippel;Flicken
-Plexus (fachspr.);Nervengeflecht;Gefäßgeflecht
-spulen;aufwickeln;wickeln
-über (Alter) (Hauptform);(...) plus (fachspr., Jargon, mediensprachlich);jenseits der (geh.);Ü... (fachspr., Jargon, werbesprachlich);...+ (fachspr., Jargon, mediensprachlich);überschritten haben;ab (Alter);(hoch) in den ...ern
-überdreht (ugs.);überkandidelt (ugs.);extravagant;outriert (geh., altertümelnd);dandyhaft;snobistisch;exzentrisch;überspannt;exaltiert;verstiegen (geh.)
-Streusand;Kies;Schotter;Split
-Unterrichts...;Studien...
-Sternkunde;Astronomie;Weltraumforschung;Kosmologie
-Wurzelspross;Wurzelschössling
-aushändigen;ausgeben;zuteilen;ausrüsten;verteilen;liefern;bereitstellen
-Ständer;Pfosten;Wandpfosten
-im Hauptberuf;hauptamtlich;hauptberuflich
-Charcot-Syndrom;Hinken;Claudicatio;Claudicatio intermittens
-Feuersturm;Feuersbrunst;Flächenbrand;ausgedehnter Brand;Weltbrand;Großbrand (Hauptform);Feuersnot (veraltet);Großfeuer
-herleiern;eintönig reden
-Fraktur;Bruch;Knochenbruch
-Nahost;Vorderer Orient;Morgenland;Naher Osten
-Rückresorption;Reabsorption
-Übernahme;Übernehmen
-Kielraum;Bilge
-Begriffsvermögen;Verständnis
-Mobilmachung;Mobilisierung;Aufbietung
-Dreikönigsfest;Epiphanias;Erscheinung des Herrn;Hoch-Neujahr (veraltet);Theophanie;Epiphanie;Heilige Drei Könige;Groß-Neujahr (veraltet);Weihnachtszwölfer (österr.);Dreikönigstag
-wenig erbaulich;unerquicklich
-UNO-Hochkommissar für Flüchtlinge;UNHCR (Abkürzung, engl.)
-Stepp;Stepptanz
-Aktennotiz;Aktenvermerk
-nichtig;hinfällig;Leer...;ungültig
-kritisch;ungelegen;unbequem
-ministerial;amtlich;offiziell;ministeriell;dienstlich
-abschürfen;aufkratzen;aufschürfen
-anderweitig;jenseitig
-Industrie- und Handelskammer;IHK (Abkürzung)
-in die Runde;im Umkreis;rundherum;im Kreis herum (auch figurativ);reihum;rund um;ringsherum;in der Runde;umher...;um ... herum;herum...
-ungezählt;zahllos
-(es) tun (ugs.);funktionieren;funzen (ugs.);funktionuckeln (ugs.);laufen (ugs.);klappen (ugs.);gehen (ugs.)
-Erkrankungsrate;Morbidität
-Ausstattung;Rüstzeug;Gerätschaft;Zurüstung;Equipment;Apparatur;Gadget (engl.);Ausrüstung;Utensilien
-inneres Selbstgespräch;Selbstgespräch;Monolog;Gedankengespräch
-Untersuchung (von);kritische Auseinandersetzung (mit);Analyse (von)
-Natronwasserglas;Natriumsilikat
-Tension;Spannung;Zug;Spannungszustand;Belastung
-Genießer;Genussmensch;Feinschmecker;Gourmet;verwöhnter Gaumen;Feinspitz (salopp, österr.)
-eindämmen;Einhalt gebieten;zum Stillstand bringen;in Schach halten (fig.);aufhalten
-zyan;türkis;blaugrün;aquamarin
-Stubengelehrter;Buchgelehrter
-(jemandem) passen;(mit etwas) vereinbar sein;(sehr) recht sein;(jemandem) kommod sein (regional);(jemandem) gelegen kommen;(jemandem) ins Konzept passen;genau richtig kommen;gerade recht kommen;(jemandem) zupasskommen;(jemandem) zupass kommen (geh.);(jemandem) (gut) in den Kram passen (ugs.)
-stenographiert;in Kurzschrift geschrieben;stenografiert
-Perihelium (fachspr.);Sonnennähe;Perihel (fachspr.)
-trostreich;tröstlich
-Aufsicht;Überwachung;Beaufsichtigung;Monitoring
-hygienisch;gepflegt;rein;reinlich;gereinigt;sauber
-Geschlechtsname (schweiz., veraltend);Zuname;Familienname;Nachname
-Kraftfahrzeugzulassungsschein;Kraftfahrzeugschein;Kfz-Schein
-Fluke;Schwanzflosse
-erfassen;registrieren;feststellen;bemerken
-Belag;Kruste;Beschichtung;Überzug;Schicht
-Eselsleiter (ugs.);pons asinorum (lat.);Eselsbrücke (ugs.);Merkregel;Merkreim;Anker (fachspr.);Gedächtnisstütze;Lernspruch;Erinnerungsstütze;Merkspruch;Merkvers;Lernhilfe;Merksatz;pons asini (lat.);Gedächtnishilfe;Merkhilfe
-Schlingpflanze;Rankenpflanze;Schlinggewächs;Kletterpflanze (Hauptform);Spaliergewächs;Rankengewächs
-Leitfaden;Linie;Ausrichtung;Zielvorstellung;Zielsetzung;Zielvorgabe;Vorgabe;Führungshilfe;Leitlinie;Maßgabe;Programm;Guideline (engl.);Richtschnur;Richtlinie;Handlungshilfe;Marschrichtung;Programmatik;Kurs;Zielstellung;Richtmarke;Orientierung
-(jemandem) Kopfzerbrechen bereiten (ugs.);(sich) grämen;(sich) härmen (über, um, wegen);schlaflose Nächte haben (ugs., fig.);beunruhigt sein (wegen) (ugs.);(sich) beunruhigen (um);(sich) Kummer machen (um) (ugs.);(sich) sorgen;(sich) Gedanken machen;in Sorge sein;(sich) Sorgen machen
-unvertraut;eigenwillig;unkonventionell;unüblich;unangepasst;ungewöhnlich;sperrig (fig.);wie man ihn nicht alle Tage trifft;mit Ecken und Kanten (fig.);unorthodox;ungewohnt;unbequem;kantig (fig.)
-Fehler beseitigen;debuggen;von Fehlern befreien
-nephrotisch (fachspr.);Nierenkrankheiten betreffend
-falten;zusammenklappen;knicken
-Zahnfäule;Karies
-in Umlauf setzen;verbreiten;ausstellen;in Umlauf bringen;begeben (fachspr., kaufmännisch, veraltet);ausgeben (Banknoten);emittieren;in Verkehr bringen;auflegen;herausgeben
-nasskalt;feucht;klamm;feuchtkalt
-zerstoßen;zerkrümeln;atomisieren;pulverisieren;krümeln;zerbröseln;zerreiben;zerkleinern;absplittern;zermahlen;zerbröckeln;zerstampfen;zersplittern
-stillen;befriedigen
-fasslich;einleuchtend;nachvollziehbar;augenfällig;überzeugend;fassbar;intelligibel (fachspr., Philosophie);schlüssig;verstehbar;verständlich;triftig;einsichtsvoll;noetisch (fachspr., Philosophie, griechisch);ersichtlich;begreiflich;klar;plausibel;nachzuvollziehen;sinnfällig;gut (ugs.);evident (geh.);eingängig;erklärlich;einsichtig;glaubhaft
-Strumpf;Kniestrumpf;lange Socke
-Amtsenthebung (fachspr.);Kündigung;Austritt;Verabschiedung (fig.);Demission;Enthebung;Vertragsauflösung;Ablösung;Vertragsaufhebung;Absetzung;Entlassung;Abberufung
-Tritt;Stoß;Kick
-Eis;Glace (schweiz.);Speiseeis;Eiskrem (alte Schreibung bis 2011);Eiscreme;Eiskreme (alte Schreibung bis 2011)
-Überempfindlichkeitsreaktion;Atopie (fachspr.)
-ausdauernde Pflanze;perennierende Pflanze;mehrjährige Pflanze
-Spielzeug;Spielwaren;Spielsachen;Kinderspielzeug
-Leuchtgeschoss;Leuchtkugel;Leuchtrakete
-flussaufwärts;zur Quelle;stromaufwärts;in Richtung Quelle;flussauf
-Schreibtisch;Pult;Sekretär
-Mitwissender;Vertrauter
-Hwangho;Huang He;Gelber Fluss
-Eingangsanzeige;Empfangsbestätigung
-Gehirn...;zerebral
-Flockigkeit;Flaumigkeit
-Selbstbiographie (veraltend);Selbstbiografie (veraltend);Lebenserinnerungen;Lebensbeichte;Memoiren;Autobiographie;Autobiografie
-zwischen den Rippen;interkostal (fachspr.)
-vierteilig;aus vier Teilen bestehend
-skeptisch;achtsam;vigilant (geh.);wachsam;aufmerksam;kritisch
-angriffslustig;konfliktstark (auch ironisch);jeden Fehdehandschuh aufnehmen(d) (fig.);auseinandersetzungsfreudig (auch ironisch, positiv);kämpferisch;angriffig (schweiz.);keinem Streit aus dem Weg(e) gehen(d);konfliktfreudig (auch ironisch, verhüllend);kampfesfreudig;streitbar;streitlustig;offensiv;kampfesmutig;kampfeslustig;konfliktbereit
-Ableiter;Ablenkspule
-raspeln;(Käse) reiben
-Massenflucht;massenhaftes Verlassen;panische Flucht;Exodus
-(lang) anhaltend;persistent;hartnäckig;permanent;nachhaltig;dauerhaft;ausdauernd;beständig
-Muttermal (ugs.);Pigmentfleck;Pigmentnävus (fachspr.);Chloasma;Nävus (fachspr.);Leberfleck;Hautfleck;Schönheitsfleck (ugs.)
-Austausch;Zwiegespräch;Dialog;Unterhaltung;Gespräch (Hauptform);Unterredung;Wortwechsel;Zwiesprache (geh.);Diskussion;Gedankenaustausch;Konversation;Aussprache
-derbe (ugs.);mega...;überaus;total;wirklich (ugs.);sehr;was das Zeug hält (ugs.);äußerst;radikal;super... (ugs.);über die Maßen;ausgesprochen;echt (ugs.);ganz (ugs.);unglaublich;hyper...;extrem;brutal (ugs., süddt.);höchst;voll (ugs., jugendsprachlich);hoch...;ganz ganz (ugs.);absolut
-prinzipiell;grundsätzlich;in der Regel;im Grundprinzip;dem Grunde nach (fachspr., juristisch);im Grundsatz;im Grunde;im Prinzip
-Verhaltensflexibilität;Anpassungsfähigkeit;Anpassungsvermögen
-Hirnanhangsdrüse;Hirnanhangdrüse;Glandula pituitaria (fachspr.);Hypophyse (fachspr.)
-Färbung;Einschlag;Strömung;Tendenz;Trend;Entwicklung;Neigung
-stolpern;straucheln
-Erlaubnis;Erlaubniskarte;Erlaubnisschein
-einprägen;einschnitzen
-(ein Gesetz) teilweise aufhebend;derogatorisch;derogativ
-beaufsichtigen;befürsorgen (österr.);bemuttern (ugs.);betreuen;kuratieren (geh.)
-Willensäußerung;Willensbekundung;Absichtserklärung;Letter of Intent (engl.);Grundsatzvereinbarung;declaratio voluntatis (historisch, lat.);Willenserklärung
-von Stund an (geh., veraltend);ab hier;in Zukunft;nunmehr;von jetzt an (Hauptform);künftig;fortan;fürderhin (geh., veraltet);ab sofort;von nun an;von hier an;ab jetzt
-Atlantischer Flugfisch;Meerschwalbe
-genau;genau passend;treffend;auf den Punkt (ugs.);passgenau;zielsicher;treffsicher;punktgenau
-Aufwandskonto;Ertragskonto
-keimfrei machen;pasteurisieren
-stark negatives Wirtschaftswachstum;schwächelnde Konjunktur (ugs.);starker Konjunkturrückgang;(sich) abschwächende Konjunktur;kontraktive Phase;Minuswachstum;Flaute (ugs.);Abschwung (Hauptform);Rezession (Hauptform)
-das A und O (ugs.);das, worauf es hinausläuft;Quiddität;(der) Sukkus (österr.);Essenz;Kernstück;Substanz;Hauptsache;(das) hüpfende Komma (ironisch);(das) Wesentliche;Wesen;das Um und Auf;(die) Quintessenz;(das) Eigentliche;das Alpha und das Omega
-Wirkmächtigkeit;Wirksamkeit;Leistungsfähigkeit
-auffahren;rammen
-Fastnachtszeit;Fastnacht
-teuflisch;bestialisch;barbarisch;viehisch;unmenschlich;brutal
-Tabellenende;Tabellenschluss
-überbelasten;überladen;überfrachten
-Besteigung;Aufstieg
-ackern;pflügen;umackern
-scrollen;rollen;(weiter) nach ... gehen (ugs.);Bildschirminhalt verschieben;blättern
-Moskito;Stechmücke;Mücke;Schnake (bayr., schweiz.);Stanze (bayr., schweiz.);Staunse (bayr., schweiz.);Gelse (österr.)
-Hinterschnitt;Hinterschneidung
-Vermögen;Wohlstand;Guthaben;Reichtum;Erspartes
-Zusatzklausel;Zusatz
-durch die Haut hindurch;transdermal (fachspr.)
-Information;Auskunftsschalter;Schalter;Auskunft
-ritzen;schaben;kratzen;scharren
-(sich) korrigieren;(sich) regulieren
-Unterwasserschallgerät;Sonar
-Referenz;Register;Stichwortliste (fälschlich);Schlagwortverzeichnis;Index;Stichwortverzeichnis (fälschlich)
-Noten vergeben;Notenvergabe;Bewertung mit Noten;Benotung
-Millenniumfeier;Millenniumsfeier;Tausendjahrfeier;Jahrtausendfeier
-Anemoskop (fachspr., griechisch);Windrichtungsgeber;Wetterfahne;Windfahne;Windsack
-Interessenorganisation;Verbindung;Interessengruppe;Spezis (derb);Pressure-Group;Verband;Interessenvertretung;Union;Lobby;Interessengemeinschaft;Interessenverband;Interessensgruppe;Interessensvertretung (österr.)
-Waschanstalt;Wäscherei
-Wetterstation;Wetterwarte
-servil (geh., abwertend);hündisch (stark abwertend);sklavisch (stark abwertend);devot;hörig;(jemandem) untertan (geh.);unterwürfig (abwertend);untertänig;speichelleckerisch (stark abwertend);kriecherisch (stark abwertend);knechtisch (abwertend);blind ergeben (abwertend)
-am günstigsten;am besten
-Blähsucht;Meteorismus (fachspr.)
-Aroma;Bukett (von Parfum) (veraltet);Wohlgeruch;Duft (Hauptform);Bouquet (von Parfum) (veraltet);Odeur (franz.)
-Schwarzkehldrossel;Bechsteindrossel
-Pannendienst;Pannenservice;Pannenhilfe
-Güte;Wertigkeit;Qualität;(gute) Beschaffenheit
-leicht;light (engl.);mit wenig Kalorien;kalorienreduziert
-obsiegen (geh.);(einen Pokal / Preis) holen (ugs.);erster werden;(einen Preis / eine Auszeichnung...) einheimsen;das Rennen machen (ugs., fig.);den Sieg erringen (geh.);siegen (Hauptform);So sehen Sieger aus! (ugs., Spruch);den Sieg erlangen;gewinnen (Hauptform);(ein Rennen) für sich entscheiden;triumphieren;mit dem Pokal nach Hause fahren (können) (auch figurativ, mediensprachlich);Sieger sein
-Schranke;Wegeschranke;Barriere (schweiz.);Schlagbaum;Schranken
-ungestört;unbeschwert;unbelästigt;unbehelligt;ungeschoren
-Teilsystem;Untersystem;Subsystem
-Bärenklau;Herkulesstaude;Herkuleskraut;Russenkraut (ugs.);Akanthus
-Enzyklopädie (Hauptform);Universallexikon;Konversationslexikon;Encyclopädie (veraltet);Lexikon;enzyklopädisches Lexikon;Allbuch (fachspr.)
-(ein ...) vor dem Herrn (ugs.);wie es (er/sie) im Buche steht (fig.);beispielhaft;paradigmatisch;beispielgebend;vorbildhaft;waschecht;typisch;exemplarisch (Hauptform)
-pelvin (fachspr.);zum Becken gehörend
-anschwellen;sich ausweiten;größer werden;ansteigen;sich positiv entwickeln;anwachsen;in die Höhe klettern (ugs.);zunehmen (Hauptform)
-fakturieren;Fakturen ausstellen;in Rechnung stellen;berechnen
-bewusst;geistig;kognitiv
-fauler Zauber (abwertend);Zauberei (Hauptform);Zauberkunst;Voodoo;Hexerei;Hokuspokus (abwertend);Magie;Hexenwerk
-ausgleichende, strafende Gerechtigkeit;Nemesis
-ungezwungen;ungehindert;frei;ungebunden;zwanglos
-marode;zuschanden (geh., veraltend);schrottig (ugs.);reif für den Sperrmüll (ugs.);hin (ugs.);vernichtet;unbrauchbar;hinüber (ugs.);zerstört;völlig hinüber (ugs.);im Arsch (derb);aus dem Leim gegangen (ugs.);zermahlen;rott (ugs., regional);im Eimer (ugs.);diffrakt (lat.);auseinander (ugs.);irreparabel (geh.);geschrottet (ugs.);zerbrochen;zermalmt;zu nichts mehr zu gebrauchen (ugs.);zertrümmert;reif für die Tonne (ugs.);(völlig) kaputt;entzwei;nicht mehr zu gebrauchen
-Einkommensquelle;Einkünfte;Verdienst;Einkommen;Einnahmen
-Aufkleber;Klebezettel;Klebeetikett;Sticker (engl.);Klebeschild;Bepper (ugs., schwäbisch);Etikett;Pickerl (ugs., österr.);Bapperl (ugs., bayr.)
-schöne Literatur;schöngeistige Literatur;Belletristik;Unterhaltungsliteratur
-Tuberkulosekranker;Schwindsüchtiger
-verminderte Atemfrequenz;Bradypnoe (fachspr.)
-Vogelkundler;Ornithologe
-griesgrämig (ugs.);muksch (ugs.);beleidigt;betupft (ugs.);knatschig (ugs.);miesepetrig (ugs.)
-Sitte;Anstand;Lauterkeit;Sittlichkeit;Anständigkeit;Moral
-Lohntag;Auszahlungstag;Zahltag (Hauptform)
-abhangen (von) (schweiz.);abhängen (von);fußen (auf);(darauf) aufbauen;basieren (auf);(darauf) aufsatteln (ugs.);gründen (auf);beruhen (auf);(sich) speisen
-tröpfeln;verrinnen;träufeln;rieseln;sickern;tropfen
-überkandidelt;schnippisch;eingebildet;hochnäsig
-Muskatnuss;Muskat
-Konsum;Verbrauch;Konsumption (fachspr.);Konsumtion (fachspr.)
-Lymphadenopathie (fachspr.);Erkrankung der Lymphknoten
-Hbf (Abkürzung);Zentralbahnhof (veraltet);HB (Abkürzung, schweiz.);Zentralstation;Hauptbahnhof
-Prozedere;Procedere;Vorgehen (Hauptform)
-aufladen;auflasten;schlauchen (mit) (ugs.);oktroyieren (geh.);auferlegen;beschweren;aufbürden;strapazieren;bepacken;beladen;aufoktroyieren;belasten (mit)
-Lexikon;Wörterverzeichnis;Diktionär (geh., veraltend);Vokabularium (lat., veraltet);Wörterbuch (Hauptform);Vokabular (lat., veraltet)
-abgeflachte Atmung;Atemdepression;Hypoventilation
-vogelfrei;wehrlos;unbeschützt;exlex (lat.);(der Willkür) ausgeliefert;ohne Rechte;rechtlos;ohne Schutz;schutzlos (Hauptform);entrechtet;Freiwild (fig.)
-Aspiration (fachspr.);Ansaugen
-Höhenrücken;Kamm;Grat;Bergrücken;Naht;Gebirgsgrat;Bergzug
-Verstimmung;Unwohlsein;Unbehagen;Malaise (franz.);Unpässlichkeit (Hauptform);Missstimmung (geh.);Befindlichkeitsstörung
-Klarheit verlangen;Aufklärung verlangen;Aufschluss verlangen (über)
-billiger werden;an Wert verlieren;im Wert sinken
-Salomoninseln;Salomonen
-Grab;Grube;letzte Ruhestätte;letzte Ruhe (fig.);Grabstätte
-Vielehe;Mehrfachehe;Polygamie
-regelgerecht;im grünen Bereich (ugs., fig.);seine Richtigkeit haben (mit);in Ordnung;korrekt;im Sollbereich (auch figurativ);im Lot (ugs., fig.)
-Baggereimer;Baggerlöffel
-gläsern;Glas...;aus Glas
-eigenständiger Rechner;Einzelrechner
-niederschlagen;(gewaltsam) unterdrücken (Aufstand);niederknüppeln (Proteste) (ugs.)
-Deltaform;Drachenform
-Genauigkeit;Richtigkeit;Korrektheit
-einschenken;eingießen;beschicken (fachspr.);einschütten;verleitgeben (ugs., süddt.);abfüllen;füllen;zugießen
-hochjagen (ugs.);in die Luft jagen (ugs.);zur Explosion bringen;sprengen;hochgehen lassen (ugs.)
-Möbelrolle;Rolle;Fahrrolle;Laufrolle
-Ungläubigkeit;Skepsis;Unglauben;Unglaube;Argwohn;Misstrauen;Zweifel
-Ausgabetag;Ausstellungsdatum
-Gallenblase;Galle
-Broadcast;Rundruf
-Hochfrequenz;Dekameterwelle;Kurzwelle
-Geschäftsordnung;GO
-passieren;filtern;sieben;durchsieben;durchseihen (durch ein Sieb);abseihen;seihen
-Melanzani (österr.);Eierfrucht;Aubergine
-in Not;gestrandet (ugs.)
-Pustel;Blase;Luftblase;Eiterbläschen;Pickel;Wimmerl (ugs., bayr., österr.);Brandblase;Pustula (fachspr.)
-Stromstärkemesser;Galvanometer;Strommesser
-Krippe;Kinderbett
-ablagern lassen;reifen lassen;ziehen lassen
-makellos;unschuldig wie ein Lamm;schuldlos;unbefleckt;unschuldig wie ein Lämmchen;unschuldig wie ein neugeborenes Baby;lauter;unschuldig;rein
-Koilonychie (fachspr.);Einsenkung der Nagelplatte
-was auch immer;alles und jedes (ugs.);die Gesamtheit;alles;alles, was jemandem vor die Flinte kommt (ugs., fig.)
-Ketschup (alte Schreibung bis 2017);Ketchup
-kurz gefasst (Hauptform);lapidar (geh., bildungssprachlich);kurz und knackig (ugs.);kernig;knapp;treffend;trocken;prägnant (geh.);lakonisch;auf den Punkt (fig.)
-einbinden;einfügen;einarbeiten;einbauen;pastieren
-oxygenieren;mit Sauerstoff behandeln
-Geldausgleich;geldliche Abfindung
-Window (engl.);Bildschirmfenster;Fenster
-schätzenswert;achtenswert
-seidenartig;seidig
-Übernahmeprüfung;Abnahmeprüfung
-Sportschuh;Sneaker (ugs., engl.);Turnschuh
-Debet;Schuldposten;Lastposten
-Hammerbrecher;Backenbrecher
-handhaben;operieren;einwirken;wirken
-Hüter;Aufseher;Zuchtmeister (geh., fig.);Aufpasser;Bewacher;Wärter;Wachhund (ugs., fig.);Aufsicht;Supervisor (fachspr.);Wächter
-herrschen;(sich) durchsetzen;prävalieren;obwalten;weit verbreitet sein;vorherrschen;überwiegen
-seelisch;mental;affektiv (fachspr.);emotional;gefühlsmäßig;emotionell
-wiedervereinigt;vereinigte wieder
-traditionell;gediegen;hochwertig;würdevoll;gravitätisch
-Gedicht;Reim;Poem;lyrisches Werk
-Entkräftung;Schwachheit;Ermattung;Schwäche
-servieren;bewirten;dienen;bedienen
-fantasievoll;innovativ (bildungssprachlich);phantasievoll;phantasiebegabt;erfindungsreich;ingeniös;einfallsreich;kreativ;gestalterisch;fantasiebegabt;ideenreich;originell;erfinderisch;schöpferisch
-Rastermuster;Gitternetz;Gitter;Raster
-(jemandem ist) ungemütlich (bei);(jemandem ist) unbehaglich (bei);(jemandem ist etwas) nicht ganz geheuer;(jemandem ist / wird) mulmig (bei);(jemandem ist) unwohl (bei);(jemandem ist) nicht ganz wohl (bei) (ugs.)
-dominant;herrisch;tonangebend;bestimmend;befehlshaberisch
-Schlag (von) Menschen;Typ;Menschenschlag;aus ... Holz geschnitzt (Redensart, fig., variabel);Sorte Mensch;Schlag (ugs.)
-Ortsangabe;Lokalisation;Lokalität;Position;Stelle;Örtlichkeit
-retrosternal (fachspr.);hinter dem Brustbein liegend
-ausblasen;auspusten;auslöschen
-Datenverwaltung;Datenmanagement
-Maxime (geh.);Grundprinzip;Wahrheit;Grundsatz von allgemeiner Geltung;Erkenntnis;Grundsatz;Lehrsatz;Leitsatz;Theorem (fachspr.);Axiom;Hauptsatz
-Brechung;Diffraktion;Beugung
-priesterlich;zeremoniell;weihevoll;feierlich;wie ein Priester;ernst;festlich
-Naturdünger;Kompost;Komposterde
-Pauschalsatz;Gesamtzinssatz
-Verfasser;Autor;Schmock (derb, selten, veraltet);Schriftsteller;Konzipient (geh., lat., veraltet);Literat;Skribent (geh., abwertend, lat., selten);Schreiber;Mann der Feder (männl.);...schreiber (ugs.);Dichter
-schwingen;oszillieren;pendeln;schaukeln;wiegen
-(jemandem) zeigen, wo der Frosch die Locken hat (ugs., fig.);(jemandem) eine harte Rückmeldung geben;(jemanden) zusammenfalten (ugs.);(jemandem) deutlich die Meinung sagen (ugs.);(jemandem) eine (dicke) Zigarre verpassen (möglicherweise veraltend) (ugs.);admonieren (geh., veraltet);(jemandem) zeigen, wo es langgeht (ugs., fig.);abmahnen (fachspr., juristisch);(jemandem) die Flötentöne beibringen (ugs., fig.);(jemandem) die Meinung geigen (ugs.);(jemanden) lang machen (ugs.);(jemandem etwas) ins Stammbuch schreiben (fig.);(jemandem) die Leviten lesen;(jemandem) den Arsch aufreißen (derb);(jemanden) frisch machen (ugs., fig.);(jemandem) den Marsch blasen (ugs., veraltend);(jemandem) die Schuhe aufpumpen (ugs., fig.);(sich jemanden) vorknöpfen (ugs.);zusammenstauchen (ugs., fig.);(jemandem) die Hammelbeine langziehen (ugs., fig.);zur Ordnung rufen;schelten;(jemandem) Bescheid stoßen (ugs.);(jemandem) eins auf den Deckel geben (ugs.);(jemandem) den Kopf waschen (ugs., fig.);(jemanden) Mores lehren (geh.);zurechtstutzen (ugs., fig.);(jemandem) zeigen, wo der Hammer hängt (ugs., fig.);(jemandem) heimleuchten;scharf kritisieren;rüffeln;(jemandem) eine (deutliche) Ansage machen (ugs.);(jemanden) auf Vordermann bringen (ugs., fig.);verwarnen;ermahnen;(jemandem) aufs Dach steigen (ugs., fig.);rügen;(jemanden) auf Linie bringen (ugs.);(jemandem) einen Verweis erteilen (Amtsdeutsch);ausschelten;ausschimpfen;tadeln (Hauptform);zurechtweisen
-scharfer Paprika;Peperoni;Chili;Pfefferoni (österr.);Peperoncini (schweiz., südtirolerisch)
-anschauen;(jemanden / etwas) ansehen (Hauptform);spannern (ugs.);schauen;angucken;beobachten;gucken;besehen;lugen (ugs.);betrachten;mustern;glotzen (abwertend);beaugapfeln (ugs.);blicken;(sich etwas) reinziehen (derb);kieken (berlinerisch);beäugen
-Falle;Fallgrube
-Farbmessung;Kolorimetrie;Farbmetrik
-entlassen;(wieder) laufen lassen;freisetzen;losgeben;(jemandem) die Freiheit schenken;in die Freiheit entlassen;(jemandem) die Freiheit wiedergeben;loslassen;(jemanden) aus der Haft entlassen;freilassen;auf freien Fuß setzen
-Platter (ugs.);Platte (ugs.);Plattenlaufwerk;Harddisk (engl.);HDD (Abkürzung, engl.);Magnetplatte;Festplatte
-Softwareentwickler;Hacker (ugs.);Coder;Programmierer;Softwareingenieur
-annehmbar;in Ordnung;gut so;ganz recht
-IATA (Abkürzung, engl.);Internationaler Luftverkehrsverband;Internationale Lufttransportgemeinschaft;International Air Transportation Association (engl.)
-Kanne;Gießkanne;Sprenger;Gießgefäß
-Teddybär;Teddy
-aufjagen;aufscheuchen
-korrupt (Hauptform);verführbar;korrumpierbar;käuflich;gewissenlos;korrumpiert;bestechlich
-Vomitorium (fachspr., lat.);Brechmittel;Emetikum (fachspr., griechisch, lat.)
-berufen;befähigt;talentvoll;begnadet;in den Adern liegen (ugs.);talentiert;geeignet;begabt;hochbegabt
-Debatte;Streitgespräch;(verbale) Auseinandersetzung;Wortstreit;Diskussion;Disputation;Disput
-zappelig;flatterig;hibbelig (ugs., regional);fitzig (ugs.);fickerig (ugs., norddeutsch);wuselig (ugs.);flackrig (ugs.);fahrig;durch den Wind (ugs.);flackernd;fickrig (ugs., norddeutsch);flackerig (ugs.);wie Rumpelstilzchen (ugs.);wuschig (ugs., regional);wibbelig (ugs., regional);fiebrig
-Kringel;Bretzel (schweiz.);Breze;Brezn;Brezel
-Würmchen (ugs., emotional);Säugling (Hauptform);neuer Erdenbürger (ugs.);Kleinkind;Baby (engl.);Putzerl (österr.);Infant (fachspr.);Neugeborener;Buschi (schweiz.);Neugeborenes;(das) Kleine (ugs.);Wickelkind;Bébé (franz., schweiz.);kleiner Erdenbürger (ugs.);Bambino (ugs., ital.);Kleinstkind;Winzling (ugs.)
-Spionage betreiben;herumspionieren;schnüffeln (ugs.);spionieren
-Terrain;Gelände
-Brennspiritus;Ethanol;Äthylalkohol (fachspr.);Äthanol (fachspr.);Spiritus
-Zuspruch;Aufmunterung;Ermunterung;Aufrichtung;Ermutigung
-langweilig werden;an Reiz verlieren
-beschützen;schützen;sichern
-handeln;machen;am Werk sein;tun;wirken;agieren;walten (geh.)
-Gießform;Pressform;Gussform
-Aussicht;Weg;Option;(günstige) Gelegenheit;(da) lässt sich was machen (ugs., Spruch);Chance;Perspektive;Möglichkeit;Gunst der Stunde (ugs.)
-Bastion;Bollwerk;Fortifikation;Befestigung;Wehranlage;Fort;Wehr (geh., veraltet);Festung;Feste (veraltet)
-Anhängevorrichtung;Anhängekupplung;Anhängerkupplung
-Synchronisierung;Abstimmung;Synchronisation
-Sprachgebiet;Sprachraum
-verstoßen;verfemt;wolfsfrei (historisch, juristisch);verachtet;vogelfrei;geächtet;ausgestoßen;unwillkommen
-Bezauberung;Verzauberung
-Studentenwohnheim;Studentenheim
-Komplement;Ergänzung;Vervollständigung
-regulär;ordnungsgemäß;regelgemäß;(wie) vorgeschrieben;regelrecht (selten);ordnungsmäßig (ugs.);laut Vorschrift;reglementarisch;nach Vorschrift;vorschriftsmäßig
-zusammenballen;konzentrieren;anhäufeln;aggregieren;kumulieren;anhäufen
-Beileid;Anteilnahme
-Zirkulator;Richtungsgabel
-Vorgangskette;Prozesskette
-Spermen abtötendes Mittel;Spermizid (fachspr.)
-o. Ä.;oder Ähnliche;oder Ähnliches
-Vermerk;Zusatz
-unter der Zunge;sublingual (fachspr.)
-Feingehaltsstempel;Stempel auf Edelmetall
-Tunnel;Tunell (ugs., schweiz., süddt., österr.);Tunnelbauwerk
-Abzweigung;Abbiegung
-Denkfähigkeit;Grips (ugs.);Grütze (ugs.);Verstand;Denkvermögen;Intelligenz;Geisteskraft;Geist;Klugheit;Vernunft;Scharfsinn;Gehirnschmalz (ugs.);Köpfchen (ugs.);Scharfsinnigkeit
-mit eigenen Augen;selbst (Hauptform);eigenhändig;selbständig;selber (ugs.);allein(e);durch eigener Hände Arbeit
-Kinderhilfswerk der Vereinten Nationen;UNICEF (Abkürzung, engl.);Weltkinderhilfswerk
-abträglich (sein);schädigen;auflaufen lassen;Schaden zufügen;Verlust zufügen
-bronchopulmonal (fachspr.);Lungen...
-Stufen...;gestuft
-abstecken;vermarken;auspflocken
-unentwegt;konstant;unablässig;beharrlich;unbeirrt;ausdauernd;steif und fest (behaupten);hartnäckig;standhaft;unverdrossen;unermüdlich
-Einspruch erheben (gegen);einwenden;Einwand erheben;Einspruch einlegen;beeinspruchen (österr.);Einwendung machen
-Rheologie;Fließkunde
-Außerbetriebsetzen;Stilllegung;Abschaltung;Außerbetriebnahme
-ordern;bestellen;in Auftrag geben
-Abschluss;Vollendung;Komplettierung;Vervollständigung;Fertigstellung
-schalltot;echofrei
-öffnende eckige Klammer;[;linke eckige Klammer
-mürbe;dünn;zerbrechlich;fragil;zart
-verbiegen;bombieren (fachspr.);biegen
-Herzkammer;Ventrikel (fachspr.)
-anmahnen;fordern;postulieren (geh.);einfordern;abfordern;Anspruch erheben (auf);verlangen;prätendieren (geh., bildungssprachlich, franz.);anfordern;beanspruchen;abverlangen
-Druckabnahme;Druckverminderung
-wiederkehren;wiederaufkommen;wiederaufleben;zurückkehren;wiedererscheinen;wiederkommen;wiederaufflammen;zurückkommen
-Rest...;residual;restlich
-Verhütung;Verwehrung;Abwendung;Vereitelung;Verhinderung
-Gedankenarmut;Ideenmangel
-Fort;Kastell
-Betrag;Summe
-Selbstliebe;Narzissmus (fachspr., psychologisch);Selbstbezogenheit;Eigenliebe;Selbstverliebtheit
-Ablauf;Handlung;Vorgang;Handlungsschema;Geschehen
-spöttisch;beleidigend;verächtlich;ehrenrührig;beißend;vernichtend;kränkend;sarkastisch;wegwerfend;sardonisch;höhnisch;kaustisch
-(die) Wahrheit aussprechen;zutreffend sein;den Nagel auf den Kopf treffen (ugs., fig.);auf den Punkt bringen
-verflachen;ebnen;einebnen;flach machen;planieren;begradigen;abflachen
-Bissigkeit;Schärfe;Aggressivität;Sarkasmus
-(jemanden) herzlich aufnehmen;(jemanden) mit offenen Armen empfangen (auch figurativ);(jemanden) freundlich aufnehmen;(jemanden) (herzlich) willkommen heißen
-ausliefern;ausfolgen (österr.);übergeben;aushändigen
-Apostroph;Oberstrich (ugs.);Hochkomma (ugs.)
-Vereinbarkeit;Kongruenz;Übereinstimmung
-Territorialarmee;Miliz;Landwehr
-Aufsässigkeit;rebellische Gesinnung
-Stoßkante;Saum
-Zubringerstraße;Autobahnzubringer
-Fernerkundung (fachspr.);Untersuchung;Beobachtung;Rekognoszierung;Aufklärung;Erkundung
-Überreichung;Übergabe;Aushändigung;Ablieferung
-nicht unbedenklich;brenzlich;haarig (ugs.);neuralgisch;brisant;nicht geheuer;brenzlig;verfänglich;prekär;mit Vorsicht zu genießen;problematisch;heiklig (veraltet);knifflig;nicht (ganz) ohne (ugs.);heikel;bedenklich;delikat;kritisch;spinös (veraltend);problembehaftet;schwierig
-Banner;Fahne;Flagge
-Grundlagenwissen;Grundwissen;Grundkenntnisse;Elementarkenntnisse;Elementarwissen;Basiswissen;Basiskenntnisse
-Aufenthaltstitel;Aufenthaltserlaubnis;Aufenthaltsbewilligung
-aktivieren;freigeben
-Cheergirl;Cheerdancer;Cheerleader;Anfeuerer
-zusammenrechen;zusammenharken
-demonstrieren;präsentieren;vorzeigen;darstellen;vorstellen;zeigen;abbilden;vorführen
-zuvor;vorab;(schon / bereits) vorher;im Vorhinein;vorweg;Voraus...;im Vorfeld (einer Sache);vor...;vor;Vorab...;Vor...;im Voraus;voraus...
-Frühlingszeit;Lenz (poetisch);Frühjahr;Frühling
-Knockout (engl.);Knock-out (engl.);K.-o.-Schlag (Hauptform);K. o. (Abkürzung);Niederschlag;finaler Treffer;lucky punch (engl.)
-durchschalten;durchkontaktieren
-schockieren;Aufsehen erregen;schocken;einen Skandal hervorrufen
-Anzahl der Meilen;Distanz in Meilen
-Befehlsvorrat;Befehlssatz;Befehlsrepertoire
-hochziehen (ugs.);errichten;aufstellen;bauen (Hauptform);hinstellen (Gebäude) (ugs.);hinsetzen (Gebäude) (ugs.)
-Ausgleichsprozess;Netting
-im Überschwang der Gefühle;wie auf Droge (ugs.);enthusiasmiert (geh., bildungssprachlich);wie von Sinnen;entzückt;dithyrambisch (geh.);hellauf begeistert (ugs.);mit glänzenden Augen;euphorisch;überschwänglich;hingerissen (ugs.);begeistert (von);entflammt;wie im Rausch;enthusiastisch;rasend vor Begeisterung;mit strahlenden Augen;himmelhoch jauchzend (ugs.);angefixt (ugs.);wild begeistert (ugs.);von den Socken (ugs.);berauscht;gebannt;(ganz) aus dem Häuschen (ugs.);high (ugs.);verzückt;fasziniert;erregt;angetan (ugs.);Feuer und Flamme (sein) (ugs.);tobend vor Begeisterung;mitgerissen;hin und weg (ugs.);voller Begeisterung;in Hochstimmung;mit Hurra;hochgestimmt;glühend vor Begeisterung
-erstrahlen;erglimmen;erscheinen;aufscheinen;aufleuchten;aufblenden
-Felsblock;Felsen;Klippe;Gestein;Fels
-Feldsalat;Rapunzel (ugs.);Rapunze (ugs.)
-Freundlichkeit;Leutseligkeit;Umgänglichkeit;Konzilianz (geh.)
-Bovine Spongiforme Enzephalopathie;BSE (Abkürzung);Rinderwahnsinn
-sprachwissenschaftlich;linguistisch
-Array (engl.);Feld;Datenfeld
-Farbbildschirm;Farbmonitor
-(sich) einsetzen (für) (Hauptform);(eine) Lanze brechen für (fig.);werben (für);Partei ergreifen (für, gegen);kämpfen (für, um);eintreten für;(sich) aus dem Fenster hängen (für) (ugs., fig.);(sich) engagieren;(sich) starkmachen (für);propagieren;agitieren (für, gegen);(etwas) tun für;(sich) bemühen (um);(ein) gutes Wort einlegen (für);streiten (für)
-Zeitstudie;Zeitaufnahme
-Grad Fahrenheit;Fahrenheit;F
-herzallerliebst;niedlich (Hauptform);wonnig;herzig;zum Knuddeln;allerliebst;schnatz (ugs., regional);schnuckelig (ugs.);putzig (ugs.);(ganz) reizend;süß (emotional);goldig (ugs.);puppig;zum Anknabbern (ugs.);zum Abknutschen (ugs.)
-Echinoderme (fachspr.);Stachelhäuter
-Windung;Drehung
-Pemphigus (fachspr.);Blasen bildende Hautkrankheit
-Schmelzofen;Hochofen
-Schreibweise;Klaue (ugs.);Handschrift
-Fünfeck;Pentagon
-Stoß;Stapel (Hauptform);Packen
-kann vorkommen (ugs.);(durchaus) möglich;kann ja (vielleicht) sein (ugs.);denkbar;die Möglichkeit besteht;vorstellbar;gut möglich (ugs.);kann doch sein? (ugs.);(so etwas) passiert;(etwas) nicht ausschließen können;nicht ausgeschlossen;(so etwas) soll's geben (ugs., ironisch);soll vorkommen (ugs.);drin (ugs.);nicht auszuschließen;kann gut sein (ugs.);im Bereich des Möglichen (liegen);erdenklich (geh.);wäre nicht das erste Mal (ugs.);kann (schon) sein (ugs.)
-Bäckermaschine;Teigknetmaschine
-abschließen;zuschließen;verriegeln;zusperren;verschließen;absperren
-Preziosen;Juwelierwaren;Pretiosen;Schmuck;Geschmeide
-Dienstmagd;Magd;Zofe;Dienerin
-Verwicklung;Implikation;Auswirkung
-Nichtstuer;Müßiggänger;Bukligger (fachspr., Jargon, seemännisch);Drückeberger;Tagedieb;Bummelant (ugs.);Bummler (ugs.);Schlaffi (ugs.);Gammler (ugs.);Faultier (ugs., fig.);Tachinierer (ugs., bayr., österr.);Faulenzer;fauler Strick
-Kurzwahl-Taste;Direktwahl-Taste
-Laufband;Tretmühle
-unnachgiebig;unbarmherzig;mit eiserner Faust (fig.);unerbittlich;mit schonungsloser Härte;brutal;mit äußerster Brutalität;mit voller Härte;gnadenlos;drakonisch;ohne Rücksicht auf Verluste;mit unnachgiebiger Strenge;mit harter Hand (fig.);ohne Gnade und Barmherzigkeit;mit wütender Entschlossenheit
-Abschluss (von Geschäften);Trade
-Waldhorn;Horn;Corno
-entlangrollen;dahinrollen
-Akkusativ (Hauptform);Klagefall;vierter Fall;Wenfall;Anklagefall
-Knappheit;Bündigkeit;Kompaktheit
-Schlachter (norddeutsch);Schlächter (norddeutsch);Fleischhauer (österr.);Metzger (schweiz., süddt., westdeutsch);Fleischhacker (österr.);Fleischer (ostdeutsch)
-Aufsehen erregen;Furore machen;auf sich aufmerksam machen (durch);von sich reden machen;für Furore sorgen;auffallen
-belüften;durchlüften
-Viehzeug;Vieh;Viehbestand
-Oxidationsmittel;Oxydationsmittel
-Pferdeweide;Pferdekoppel
-Schimmel;Moder;Gammel (ugs.);Fäule
-Rauchzeichen;Rauchsignal
-Verkehrslichtsignalanlage (Amtsdeutsch, österr.);Lichtsignalanlage (Amtsdeutsch, schweiz.);Ampel (ugs.);Verkehrsampel;Lichtzeichenanlage (Amtsdeutsch)
-(etwas) auf sich nehmen;(freiwillig) erdulden;(etwas) in Kauf nehmen;(sich) (etwas) zumuten
-Solidarität;Verbundenheit;Füreinandereintreten;Zusammenhalt
-Institut der Vereinten Nationen für Abrüstungsforschung;UNIDIR
-massenhaft (ugs.);unglaublich viel;sehr viel
-Verschönerung;Verzierung;Verschnörkelung
-füttern;nähren;ernähren;verpflegen;(jemandem) Essen geben;(jemandem etwas) zu essen geben;bewirten;verköstigen;beköstigen
-mit einem Ruck (ugs.);in einem Wink;in null Komma nichts (ugs.);augenblicklich;ruckartig;im Handumdrehen;im Nu;im Nullkommanichts (ugs.);blitzartig;im Nullkommanix (ugs.);mir nichts, dir nichts;innerhalb kürzester Zeit
-Bassist;Bassgitarrist
-(jemandem) einen Gefallen erweisen;(jemandem) zu Gefallen sein (geh., veraltet);(jemandem) einen Gefallen tun;(jemandem) eine Freude machen;gefällig sein;(jemandem) eine Gefälligkeit erweisen
-aufsaugen;aufnehmen;einsaugen;absorbieren;resorbieren
-Gruppe von Gleichgestellten;Alterskohorte;Peergroup
-Aeroplan (österr.);Flugzeug (Hauptform);Kiste (ugs.);Maschine (ugs.);Flieger (ugs.);Vogel (ugs., Jargon, fig.)
-Unfähigkeit;Beklopptheit (ugs.);Trotteligkeit (ugs.);Ignoranz;Dilettantismus;Doofheit (ugs.);Dummheit;Unwissenheit;Trottligkeit (ugs.);Blödheit (ugs.);Stümperhaftigkeit (ugs.);Beknacktheit (ugs.)
-Bonus;Provision;Prämie
-klein (Hauptform);miniklein;mini... (Mini...);mini;kurz;im Westentaschenformat;Miniatur...;lütt (ugs., norddeutsch);im Kleinformat
-Zahnmark;Zahnpulpa (fachspr.)
-unbändig;hemmungslos;ungehemmt;ungebärdig;enthemmt;ungezügelt
-Ausbildung (ugs.);Berufslehre;Lehre;Berufsausbildung (Hauptform)
-Dringlichkeit;Brisanz;Aktualität
-exorbitant;fulminant;außerordentlich;enorm;erheblich;bedeutend;unglaublich;pompös;bombastisch;extrem;üppig;gewaltig;immens;groß
-Geifer;Sabber;Seiber (ugs.)
-belustigen;amüsieren;unterhalten;bespaßen (ugs.)
-tröpfeln;sickern
-Hader (geh., veraltet);Zweifel;Ungewissheit;Verunsicherung;Bedenken;Zwiespalt;Unsicherheit
-Verstoffwechslung;Metabolisierung
-Genetik;Vererbungslehre;Erblehre
-Kosmetiksalon;Schönheitssalon;Beautysalon
-die Geschichte betreffend;historisch;geschichtlich;in der Vergangenheit liegend
-Holzfußboden;Parkett;Holzboden
-Völlerei;Fresserei (ugs.);Bauchdienerei (selten);Fressgelage (ugs.)
-(sich) gedemütigt fühlen;(sich) klein vorkommen (ugs.)
-zimperlich;etepetete;zickig
-Wunderlichkeit;Seltsamkeit
-Untergeordneter;Befehlsempfänger;Untertan;Untergebener
-auf Wettbewerb beruhend;konkurrierend;kompetitiv
-zurückgeben;austauschen;umtauschen;eintauschen;tauschen;reklamieren
-Dreieckslenker;Querlenker
-deklamieren;referieren;vorsprechen;wiedergeben;vortragen (Hauptform)
-indem;als (vergangen);dieweil (Konjunktion);wie (jemand) so (+ Verb);im Verlauf (dessen / einer Sache);dabei;derweil (Adverb);bei laufenden (...);wie (ugs.);solange (wie);alldieweil (Konjunktion) (ugs.);während (Hauptform)
-Aufnahmefähigkeit;Verständnis;Fassungskraft;Fassungsgabe;Verstand;Auffassungsgabe
-Schacht;Grube
-zweifelhaft;(etwas) darf bezweifelt werden;fraglich;ungewiss;bedenklich;fragwürdig (Hauptform);diskussionsbedürftig;überdenkenswert (verhüllend) (geh.);strittig
-Bauer (derb);Stoffel (ugs.)
-auch;zweitrangig;Neben...;nachrangig;unter ferner liefen (ugs.);untergeordnet;beiläufig;nebensächlich;sekundär;ebenfalls;zweite Geige (ugs., fig.)
-Geschichte;Märchen;Saga;Sage;Fabel
-Schrägmaß;Stellwinkel
-absolvieren;abschließen;erfüllen;fertig werden (mit);zu Potte kommen (ugs.);erledigen
-unterwerfen;niederringen;gefügig machen;erobern;(jemanden) in die Knie zwingen (fig.);besiegen
-auslösen;betätigen;bedienen;handhaben;drücken
-wohlwollend (Hauptform);entgegenkommend;großmütig;gütig;großherzig;mild;huldvoll (oft ironisch) (geh., veraltend);sanftmütig;milde;gefällig;kulant;gnädig
-Seehund;Robbe
-orthonormiert;orthonormal
-Basstrommel;Große Trommel
-Heritabilität;Erblichkeit
-unbeholfen;dumpf;plump;stumpf (ugs.)
-Unwiderlegbarkeit;Glaubwürdigkeit;Unangreifbarkeit;Unanfechtbarkeit;Unabweisbarkeit;Unbestreitbarkeit;Glaubhaftigkeit;Plausibilität
-begreiflicherweise;nachvollziehbarerweise;einleuchtenderweise;verständlicherweise
-Lehre der Magen-Darm-Krankheiten;Gastroenterologie (fachspr.)
-behindern;verzögern;anhalten;aufhalten
-Leberentzündung;Hepatitis (fachspr.)
-Machbarkeit;Realisierbarkeit;Durchführbarkeit
-Geber;Stifter;Spender
-Notanker;Rettungsanker
-parenteral (fachspr.);unter Umgehung des Verdauungstraktes
-Darstellung;Vorführung;Aufführung;Präse (ugs., Jargon, salopp);Demonstration;Vorstellung;Präsentation
-Ordnung;Regelmäßigkeit;Anordnung
-platzen;explodieren;(jemandem) um die Ohren fliegen (ugs., auch figurativ);in die Luft fliegen;detonieren;hochgehen (ugs.)
-aus vier bestehend;quartär
-Kaltes Fieber;Febris intermittens (fachspr.);Klimafieber (veraltet);Wechselfieber;Sumpffieber;Küstenfieber (veraltet);Malaria;Akklimatisationsfieber (veraltet);Tropenfieber (veraltet);Paludismus
-(jemandem) schlagen auf;(gesundheitlich) belasten;in Mitleidenschaft ziehen;gehen (auf);belastend sein (für)
-Ausländerhass;Ausländerfeindlichkeit;Xenophobie (fachspr.);Fremdenfeindlichkeit
-Volumen;Rauminhalt;Kapazität;Fassungsvermögen;Kubikinhalt
-Grunddaten;Stammdaten;Ausgangsdaten;Referenzdaten;Basisinformationen;statische Daten
-abgesackt;gesunken
-biegen;anwinkeln;wölben;krümmen
-Stammdatei;Bestandsdatei
-wenig aufregend;ohne Pep;(so aufregend) wie eingeschlafene Füße (ugs.);langweilig (Hauptform);lahm (fig.);lasch;uninteressant
-Schlange;Warteschlange;Reihe
-Und-Zeichen;kaufmännisches Und (ugs.);Kaufmannsund (ugs.);Kaufmanns-Und (ugs.);Firmen-Und (ugs.);&;Et-Zeichen
-Abfall;Abhang;Senkung;Gefälle;Hang
-Manie;krankhafte Leidenschaft (für);Obsession;Besessenheit;Sucht;Seelenkrankheit
-Schwabenstreich;Geblödel (ugs.);Alberei;Albernheit
-tastengesteuert;tastaturgesteuert
-Rückkaufswert;Rückgabewert
-Direktorat;Direktorenamt
-einführende Worte (sprechen);Einführung;Anmoderation (Radio, TV);Eröffnung;Einleitung
-Giftigkeit (einer Substanz);Toxizität (fachspr.)
-Chuzpe;Unverschämtheit;Impertinenz;Respektlosigkeit;Dreistigkeit;(etwas) geht auf keine Kuhhaut (ugs., kommentierend);Unbescheidenheit;Frechheit
-dunsten;Dunst ausströmen
-löchrig;undicht;löcherig;porös;leck;löchrig wie Schweizer Käse (ugs.);löchrig wie ein Sieb;zerlöchert;durchlöchert
-aufgeregt;fickrig (ugs., norddeutsch);hippelig (ugs., regional);kirre (ugs.);aufgedreht (ugs.);rappelig (ugs.);durch den Wind (ugs., fig.);wie ein aufgescheuchtes Huhn;unruhig;rapplig (ugs.);(ganz) durcheinander (ugs.);hibbelig (ugs., regional);nervös;schreckhaft;ruhelos;kabbelig (ugs.);aufgewühlt (ugs.);erregt;fickerig (ugs., norddeutsch);beunruhigt;kribbelig;wie angestochen (ugs.);aufgekratzt (ugs.);gereizt;fieberhaft;zappelig (ugs.)
-Bescheinigung;Testat (fachspr.);Zertifikat;Zeugnis;Bestätigung;Vidimation (geh.);Nachweis;Beglaubigung;Beurkundung;Anerkennung;Vidierung (Amtsdeutsch, österr.)
-großzügig;alles erlaubend;weitherzig
-Einsatz;Kapitaleinsatz
-unbesetzte Stelle;Vakanz;freie Stelle;offene Stelle;Stellenangebot
-Merks (ugs.);Gedächtnis (an);Erinnerung;Andenken
-Bewirtschaftung;Bodenbearbeitung
-poetisch;in Versen (verfasst);gereimt;dichterisch;lyrisch;gebunden
-Achsenabstand;Achsabstand
-versteigern;verauktionieren
-abstauben;entstauben;Staub wischen
-zwiespältig;zwiegespalten;widerstreitend
-Kunstgewerbler;Kunsthandwerker
-absprechen;(eine) Absprache treffen (formell);übereinkommen (dass);auskungeln (ugs.);vereinbaren;ausverhandeln;aushandeln;akkordieren;(eine) Vereinbarung treffen (formell);(eine) Abmachung treffen (formell);(eine) Festlegung treffen (formell);abmachen;ausschnapsen (österr.)
-Aufeinanderfolge;(das) Nacheinander;zeitliche Aufeinanderfolge;Reihe;Folge;Ablauf;Abfolge;Chronologie
-Aufstellen von Fallen;Fallenstellen
-Dienst an der Waffe;Dienst am Vaterland (ugs.);Konskription (veraltet);Kriegsdienst;Kommiss (ugs.);Wehrdienst;Militärdienst (Hauptform)
-Zulänglichkeit;Hinlänglichkeit
-Haupt...;(...) Nummer 1 (fig.);größt;(...) Nr. 1 (Abkürzung, fig.);wichtigst
-flach werden;auslaufen (Gelände)
-Zurschaustellung;Schaustellung
-kündigen;zurückziehen;für aufgehoben erklären;außer Kraft setzen;für null und nichtig erklären;aufheben;annullieren;tilgen;abbestellen;abbedingen;kippen (journal.);für ungültig erklären;abkündigen;stornieren;abschaffen;für nichtig erklären;ausgleichen;terminieren;aufkündigen;auflösen
-keimfrei machen;hygienisch machen
-(sich) leeren;absickern;auslaufen;abfließen;versiegen;ausfließen;versickern;entrinnen;ablaufen;abströmen
-Thymoleptikum;Antidepressivum;Mittel gegen Depressionen;Aufputschmittel
-Meisterschaft;Meistertitel
-in Hinblick auf;in Sachen (ugs.);zur Frage;betreffend;mit Blick auf;bzgl. (Abkürzung);in Bezug auf;in Betreff (einer Sache) (Amtsdeutsch, veraltet);...mäßig (ugs.);von wegen (ugs.);bezogen auf;was (...) angeht;in ...dingen;soweit es ... betrifft;was ... anbelangt;wegen;in ...angelegenheiten;in ...fragen;soweit es ... angeht;zum Thema;was ... anlangt;in puncto;hinsichtlich;bezüglich (Papierdeutsch);im Hinblick auf;...technisch (ugs.);im ...wesen (geh., auch ironisch)
-Bagage (veraltet);Reisegepäck;Gepäck;Zugepäck (selten)
-Kranbeere;Preiselbeere;Kronsbeere (regional);Moosbeere
-Zahlungsverzug;Verzug
-Tonmischer;Mixer
-(etwas) nicht machen;unterlassen;bleibenlassen;bleiben lassen;(etwas) nicht tun;ignorieren
-Persönliche Identifikationsnummer;Persönliche Geheimnummer;PIN (Abkürzung);Personal Identification Number;Geheimzahl (Hauptform)
-Weißschwanzgnu;Weißbartgnu
-redselig;kommunikationsfreudig;affabel (geh., veraltet);mitteilsam;in Plauderstimmung (ugs.);geschwätzig;klatschsüchtig;klatschhaft;gesprächig;schwatzhaft
-Kneifer;Zwicker
-Gutmütigkeit;Jovialität;Bonhomie
-mitarbeiten (an einem Werk);in eine gemeinsame Richtung marschieren (fig., variabel);zusammenarbeiten;kooperieren;(eine) gemeinsame Linie verfolgen (fig.);in die gleiche Richtung arbeiten;(eine) gemeinsame Marschrichtung haben (fig.);an einem Strang ziehen (fig.);gemeinsam handeln;mitmachen (ugs.);gemeinsame Ziele verfolgen (variabel)
-(die) Hand ins Feuer legen (für) (fig.);(etwas) sichern;(für etwas) sorgen;(etwas) gewährleisten (fachspr.);(etwas) garantieren (Hauptform);(die) Garantie geben (dass);(etwas) sicherstellen;angeloben (ugs.)
-Modifizierung;Korrektur;Umänderung;Veränderung;Änderung (Hauptform);Abänderung;Modifikation;Umarbeitung
-kurz aufleuchten;glitzern;blitzen;funkeln;aufblitzen;aufblinken;blinken
-Verschwommenheit;Unschärfe
-Abseitsstellung;Abseits;Abseitsposition
-Zerrung;Distorsion des oberen Sprunggelenks;Verstauchung;Distorsion (fachspr.)
-Dateityp;Filetyp
-Gesetztheit;Bedenklichkeit;Schwere
-elektronische Datenverarbeitung;Informationstechnologie;EDV (Abkürzung);Informationstechnik;IT (Abkürzung)
-vorhersagen;präsumieren (geh.);hypothetisieren (fachspr.);vorausberechnen;vermuten;vorhersehen;abschätzen;schätzen;prognostizieren (geh.)
-Ossiculum (fachspr.);Knöchelchen
-Maklerprovision;Provision eines Maklers;Kurtage;Courtage;Vermittlungsprovision;Maklergebühr;Maklercourtage;Vermittlungsgebühr;Provision
-blassbraun;graugelb
-Jus (schweiz., österr.);Juristik;Jura (deutsch);Rechtswissenschaft;Juristerei (scherzhaft);Jurisprudenz
-verlegen;evakuieren;abtransportieren
-Spitzzirkel;Stechzirkel
-regendicht;wassergeschützt;wetterfest;wasserundurchlässig;wasserdicht
-Trickser;Gaukler
-Zerfall;Auflösung;Verfall;Dissolution (fachspr.)
-Buschwerk;Sträucher
-unersetzlich;nicht weglassbar;nicht zu entbehren;unverzichtbar;nicht zu ersetzen;liebgeworden;unentbehrlich;unerlässlich;nicht ersetzbar;unersetzbar;liebgewonnen
-ermüden;schläfrig werden;müde werden
-Epithel (fachspr.);Deckgewebe
-Verfolgung;Hatz;Hetzjagd (auch figurativ);Jagd;Treibjagd (auch figurativ);Verfolgungsjagd;Gjaid (ugs., veraltend, österr.);Kesseltreiben (auch figurativ);Hetze
-Liebhaber;Bewunderer;Freund;Fan (ugs.);Freak (ugs., Anglizismus)
-Ombud (fachspr.);Schlichter;Vermittler;Mediator;Schiedsmann
-Hemmstoff;Antagonist (fachspr.)
-abspecken (ugs.);reduzieren;ermäßigen;vermindern;verkleinern;verringern
-Glanzlicht;Sternstunde;Gipfel;Highlight;Spitze;großer Moment;Glanzleistung;Höhepunkt;Krönung;Höhe;großer Augenblick;Spitzenleistung;Glanzpunkt
-Ehebeziehung;Ehejoch (ugs.);eheliche Verbindung;Ehebündnis;Band der Ehe;Bund fürs Leben (ugs.);Ehegemeinschaft;Ehebund;Ehestand;Ehe (Hauptform)
-Queue;Billardqueue;Billardstock
-Drogenfahnder;Rauschgiftfahnder
-Falschinformation;Zeitungsente;Ente (ugs.);Falschmeldung;Fehlinformation
-eine Visite abstatten (geh., veraltet);kommen (ugs.);(bei jemandem) Station machen;einen Besuch abstatten;aufsuchen;zu Besuch kommen;(sich) begeben zu;visitieren;(sich) blicken lassen (ugs.);(jemandem) auf die Bude rücken (ugs., salopp);besuchen (Hauptform)
-mykotisch (fachspr.);durch Pilze hervorgerufen
-Verzug;Rückstand;Verzögerung
-Überblick geben;andeuten;skizzieren;angeben;umreißen;entwerfen
-Furche;Ritze;Vertiefung;Riefe;Nut;Rille
-Heimatland;Vaterland;Heimat;Geburtsland
-die Flucht ergreifen;türmen (ugs.);fliehen;(sich) aus dem Staub machen (ugs.);weglaufen;ausfliegen (ugs., ironisch);(das) Weite suchen;abhauen (ugs.);entkommen;Fersengeld geben (veraltend);flüchten;entfliehen;verduften (ugs.);(sich) dünn(e) machen (ugs.);(sich) verdrücken (ugs.);zu entkommen suchen (geh.);stiften gehen (ugs.);zu entkommen versuchen
-Genesung;Erholung;Rekonvaleszenz;Konvaleszenz;Heilung;Besserung;Gesundungsprozess;Gesundung
-Überlandstraße;Landstraße (Hauptform);Chaussee (veraltend);Kunststraße (veraltet);Außerortsstraße
-Garderobe;Garderobenständer;Kleiderablage;Kleiderständer
-ovarial (fachspr.);den Eierstock betreffend
-von jeher;seit Jahr und Tag;seit eh und je;von den frühesten Anfängen an;seit Adam und Eva;so lange (wie) jemand zurückdenken kann;von alters her (geh.);seit jeher;seit Anbeginn;seit ewigen Zeiten;seit Adams Zeiten;seit Menschengedenken;seit alters;seit je;von Anfang an;so lange (wie) man denken kann (ugs.);seit Urzeiten;seit den frühesten Anfängen;schon immer
-Gaunerei;Schwindelgeschäft
-Rückbank;Rücksitz;Fondsitz;Fond;Rücksitzbank
-chinesisches Wohnboot;Sampan
-Gerippe;Schale;Außenhaut;Muschel
-ausgebeulte Stelle;Beule;Verdickung
-Auswirkung;Rückwirkung
-beachtenswert;zu empfehlen;lesenswert;gelungen;empfehlenswert;ratsam;berücksichtigenswert
-quellen;aufquellen (Holz, Erbsen);herausfließen (aus);quillen
-perdu (geh., franz., veraltet);Gott weiß wo (ugs.);weg (Hauptform);verschütt gegangen (ugs.);vom Winde verweht;verschollen;entschwunden (geh., auch ironisch);dahin (geh.);spurlos verschwunden;wie vom Erdboden verschluckt (ugs.);futschikato (ugs., scherzhaft);hops (ugs.);sonst wo (ugs.);unauffindbar;verloren gegangen;nicht mehr da (ugs.);fort;nicht zu finden;(sich) in Luft aufgelöst haben (ugs.);hat sich verflüchtigt;vermisst (werden);nicht aufzufinden;wie weggeblasen (ugs.);nicht auffindbar;von Windows verweht (ugs., scherzhaft);(es) fehlt jede Spur (von);flöten gegangen (ugs.);futsch (ugs.);abhanden gekommen (ugs.);verschwunden
-Schurz;Schürze;Kittel;Arbeitskittel
-Präteritum (fachspr., Hauptform);Mitvergangenheit (österr.);Imperfekt (fachspr., veraltend);Vergangenheit
-mit einem Gewinde versehen;Gewinde schneiden
-Schrägheit;Schräge;Schiefheit
-Fußtruppe;Infanterie
-Vorhang;Gardine
-herkommen;antraben (ugs., salopp);(sich) einfinden;(sich) nähern;erscheinen;(sich) blicken lassen (ugs.);dazu stoßen;(in etwas) Einzug halten;ankommen;dazu kommen;kommen;erreichen;hinzustoßen;auf der Bildfläche erscheinen (ugs.);nahen;eintreffen
-Schuhe putzen;Schuhe wichsen
-elend;katastrophal;erbärmlich;elendig;miserabel;elendiglich;hundserbärmlich (ugs.);kläglich;desaströs (geh.);beklagenswert
-Werbeaufwand;Werbeaufwendung;Werbekosten
-Hut;Haube;Cap;Mütze;Kappe
-vereiteln;abbiegen (ugs., fig.);unterbinden;umschiffen (ugs.);verhindern;verhüten;abblocken;vermeiden;abwenden;umgehen
-entstellen;verdrehen;verzerren (Tatsache)
-Rastlosigkeit;Unrast;Ruhelosigkeit (Hauptform);Hektik
-Impulsmoment (veraltet);Eigendrehimpuls;Drall;Effet (Ballsport, Billard) (franz.);Drehimpuls;Spin (engl.);Schwung (veraltet)
-Sternzeichen;Sternbild;Konstellation (lat.);Tierkreiszeichen
-Russländische Föderation;Russische Föderation
-Toxämie (fachspr.);Blutvergiftung
-elektromagnetische Beeinflussung (Brummen);EMB
-extrarenal (fachspr.);außerhalb der Niere
-Epistaxis (fachspr.);Nasenbluten
-Unterscheidung;Auszeichnung
-zurückspringen;zurückprallen;abprallen
-Briefpartner;Brieffreund
-zurückgreifen (auf);(sich) stützen (auf);verweisen (auf);(einer Sache) nachempfunden (sein);zurückkommen (auf);(sich) beziehen (auf);(sich) anlehnen (an);anspielen (auf);(sich) berufen (auf);(etwas) aufgreifen;rekurrieren (auf) (geh.);anknüpfen (an);alludieren (geh., bildungssprachlich, lat.);angelehnt sein (an);(von etwas) inspiriert (sein);Bezug nehmen (auf)
-Genuss;Verbrauch
-fliederfarben;hellviolett;flieder;fliederfarbig
-augenzwinkernd (fig.);nur so dahingesagt;halb im Spaß;halb im Scherz;nicht ernst gemeint;scherzhaft;mit einem Augenzwinkern (fig.);witzelnd
-hinuntergehen;untergehen;hinuntersteigen;hinabgehen
-Umsatzanalyse;Umsatzstatistik
-respektwidrig (gegenüber);respektlos
-Winkel;Stück;keilförmiges Stück;Ecke;Tortenstück
-schief (Hauptform);schepp (ugs.);oblique (geh., lat., veraltet);schräg;quer
-gebetsmühlenartig;rekurrent (fachspr.);mantrahaft (ugs.);ständig;penetrant;nicht enden-wollend;in nicht enden-wollendem Gleichklang;in nicht enden-wollender Stereotypie;unablässig;repetitiv;monoton;ostinato (Musik) (ital.);immer wiederkehrend;(sich) unablässig wiederholend;iterativ (fachspr.);unaufhörlich;(sich dauernd) wiederholend;(sich) endlos wiederholend;gleichklingend;gleichtönend
-reiten;(Pferd) besteigen;rittlings sitzen
-tiefer;darunter liegend;tiefer liegend
-entschädigen;erstatten
-Zauberer;Hexer;Magier;Beschwörer;Hexenmeister;Magus (griechisch, lat., persisch);Schwarzkünstler
-krachen;knallen;rumsen (ugs.)
-verputzen;zugipsen;vergipsen
-versichern;(fest) behaupten;betonen;beteuern;asserieren (geh.);(jemandem) Brief und Siegel geben (auf) (fig., sprichwörtlich);affirmieren (geh.)
-beredsam;sprachgewandt (geh.);redegewandt;wortgewandt;eloquent;zungenfertig;beredt (geh.)
-Atomsprengkopf;Nuklearsprengkopf
-verzimmern;verplanken
-longitudinal (fachspr.);längs;längs gerichtet;längs laufend;in Längsrichtung
-Lithographie;Steindruck;Lithografie
-Momentum (geh.);Pep (engl.);Elan (franz.);Schwung;Drive (engl.);Auftrieb;Push (ugs., Jargon, engl.);Schub;Antrieb;Verve (franz.)
-am gesittetsten;bestgeartet;am wohlgesittetsten;bestgesittet
-glühen;unwirklich leuchten;fluoreszieren;phosphoreszieren;glimmen
-Schwund (Hauptform);Verminderung;(das) Entweichen;...schlupf (fachspr.);Verlust;(das) Verschwinden
-Streitsache;Rechtsstreit
-Schenkung;Stiftung;Spende;Geldgeschenk
-Nasentripper (vulg.);Rhinitis (fachspr.);Nasenschleimhautentzündung;Nasenkatarrh;Rüsselpest (ugs.);Schnupfen (ugs.);Koryza (fachspr.)
-Produktionsanlage;Produktionsfabrik
-Einfahrt;Eingang;Zufahrt;Eintritt;Zugang
-Wehmut;Gedrücktheit;Traurigkeit;Trübsinn;Depression (fachspr., medizinisch);Melancholie (griechisch);Verstimmung;Weltschmerz;Trübsal;Depressivität (fachspr.);schlechte Laune;Miesepetrigkeit (ugs.);(eine) Depri (ugs.);Freudlosigkeit;Niedergeschlagenheit;Betrübnis;Gram;Schwermut;Leiden an der Welt (geh.);Tristesse (franz.);Bedrücktheit;Lypemanie (griechisch, neulateinisch)
-Verpfändung;Pfand;Unterpfand
-Rückstände (von Kunden gegenüber meinen (verbrieften) Forderungen);(im) Rückstand (eines Kunden mit einer Zahlung);noch was zu holen haben (ugs.);Forderungen;ausstehende Forderung;Außenstände;offene (eigene) Rechnungen;(von jemandem) noch was zu kriegen haben (ugs.);Schulden (bei mir / uns);ausstehende Zahlungen (von Kunden an mich);offene(r) Posten;(eine) ausstehende Zahlung (eines Kunden an mich);Forderung;ausstehende Forderungen
-Feldhase;Hoppler;Meister Lampe (ugs.);Mümmelmann;Langohr;Hoppel (ugs.);Hase;Rammler (männlich);Mümmler;Lepus europaeus (zool.) (fachspr.)
-weniger heftig verlaufend;subakut (fachspr.)
-Gipfelpunkt;Scheitelpunkt
-(eine Schraube) anziehen;festschrauben;festdrehen;festziehen
-Kabelkanal;Kabelschacht;Verdrahtungskanal;Brüstungskanal;Installationskanal;Kabelführung
-Zuwanderung;Einwanderung;Immigration;Zuzug
-Herzklopfen;Herzstolpern;Palpitation (fachspr.);Herzrasen
-die Verdauung betreffend;peptisch (fachspr.)
-Sachverhalt;Thema (Hauptform);Angelegenheit;Chose (ugs.);Issue (fachspr., Denglisch, Jargon);Sache;Kiste (ugs.);Punkt;Fall;Ding (ugs.);Causa
-äquivalent;identisch;gleichviel;gleichwertig
-Stromstoß;Überspannung
-Lager;Nachtlager;Bettstelle;Schlafstatt;Miefkoje (ugs.);Koje (ugs.);Bettstatt;Heiabett (ugs., Kindersprache);Nest (schweiz.);Bett;Furzkiste (derb);Ruhelager;Pofe (ugs., rheinisch);Heia (ugs., Kindersprache);Falle (ugs.);Schlafstelle;Lagerstatt (geh.);Schlafplatz
-Verzierung;Deko (ugs.);Zier (geh.);Schmuck;Accessoire(s) (franz.);schmückendes Beiwerk;Zierde (geh.);Dekoration
-aufsteigen;(sich) erheben;schweben;fliegen;aufschwingen;gleiten;segeln
-TÜV (Abkürzung);Technischer Überwachungsverein
-omnipotent;zu allem fähig;allmächtig;allgewaltig
-krankhaft gesteigertes Durstgefühl;Polydipsie (fachspr.)
-Massen...;Riesen...
-Casino;Spielcasino;Spielsaal;Kasino;Spielsalon;Spielbank
-begreiflich;vorstellbar
-Schönrednerei;Sprachkosmetik (fig.);verhüllende Redeweise (Hauptform);Schönrederei;Schönfärberei;Hehlwort (fachspr., veraltet);beschönigende Umschreibung;Verharmlosung;in blumiger Sprache;Relativierung;Glimpfwort (fachspr., veraltet);Verbrämung;Euphemismus (fachspr., Hauptform);Hüllwort (fachspr., veraltet);(sprachliche) Beschönigung
-Workflow (engl.);Arbeitsgang;Geschäftsprozess;Arbeitsfolge;Arbeitsablauf
-(Anzeige) in die Zeitung setzen (lassen);annoncieren;anzeigen;(Anzeige) aufgeben;(Anzeige) schalten;inserieren;(Anzeige) veröffentlichen
-richten (archaisierend);unter Beschuss nehmen (fig.);brandmarken;(jemandem) ans Bein pinkeln (ugs., fig.);stigmatisieren;an den Pranger stellen (fig.);öffentlich beschuldigen;geißeln;(hart) kritisieren;ins Gericht gehen (mit) (fig.);(das) Urteil sprechen (über) (fig.);beredte Klage führen (über) (geh.);(öffentlich) anprangern;verurteilen;den Stab brechen über (ugs., fig.);verdammen;ächten
-Instandsetzung;Wiedereinsetzung
-Unermüdlichkeit;Biegsamkeit;Elastizität;Federkraft;Spannkraft;Dehnbarkeit
-scheibenförmig;diskoidal (fachspr.)
-Extrasystole (fachspr.);vorzeitige Kontraktion des Herzmuskels
-Fahrstreifen;Fahrspur (ugs.);Spur (ugs.)
-Verschlag;Schuppen (ugs.);Bude (ugs.);Baracke;Hütte (ugs.);Bretterbude (ugs.);Budike (ugs., regional);Muchtbude (ugs., berlinerisch);Kabache (Rotwelsch, westfälisch);Einfachst-Unterkunft;Bretterverschlag;Butze (ugs.);Behelfsbau;Einfachst-Behausung
-behaglich;bequem;gemütlich;angenehm;wohlig;wirtlich
-Selbstgefälligkeit;übersteigertes Selbstbewusstsein;Selbstüberhebung (geh.);Prätention (geh.);Stolz;Hochmut;Hybris (geh.);Prätension (geh., bildungssprachlich, veraltet);Eingenommenheit von sich selbst;Dünkel (geh., veraltend);Blasiertheit;Einbildung;Selbstverliebtheit;Überheblichkeit;Hoffart (veraltet);Narzissmus;Arroganz;Eingebildetsein;Anmaßung
-das Zweite (ugs.);ZDF;Zweites Deutsches Fernsehen
-nieten;vernieten
-krankheitsmildernd;palliativ (fachspr.);schmerzlindernd
-Schnitt;Frisur;Haarschnitt
-Verdampfung;Vaporisierung (lat.);Vaporisation (fachspr., lat.)
-Unfruchtbarkeit;Kargheit;Spärlichkeit
-die Hypophyse betreffend;hypophysär (fachspr.)
-freundlich;leutselig;offen;extravertiert;extrovertiert;sozial;kontaktfreudig
-Fibu (Abkürzung, Jargon);Finanzbuchhaltung
-das Nervensystem schädigend;neurotoxisch (fachspr.)
-Erwartungsdruck (von Gleichaltrigen);Gruppendruck;Gruppenzwang
-Untreue;Fremdgehen;Betrug;Treulosigkeit (von Ehepartnern);Ehebruch;Seitensprung
-Grenzbereich;Grenzland
-ausbauen;hinzugewinnen;dazugewinnen;(einen) Zugewinn verbuchen (können);ausdehnen;zulegen (ugs.);(einen) Zugewinn zu verbuchen haben;vergrößern;aufstocken
-Zweiteilung;Dichotomie;Zweigliederung;Schwarz-Weiß-Malerei (ugs.)
-Wurzelkeim;Keimwurzel
-Zerklüftung;Unebenheit;Rauheit;Runzeligkeit;Holprigkeit (ugs.);Rohheit;Schroffheit
-Zyanose (fachspr.);Blaufärbung der Haut
-(jemandem) Bange machen (ugs.);einschüchtern;ängstigen;beängstigen;erschrecken;Angst einflößen;verängstigen;verschrecken;ins Bockshorn jagen (ugs.)
-verbrechen (ironisch, negativ);anrichten (negativ);ausfressen (ugs., Hauptform, negativ);anstellen (negativ);(sich etwas) leisten (ugs.)
-Rückenkrankheit;Rückenleiden;Rückenschaden
-entmutigt werden (von);mutlos werden (durch)
-Obesität (fachspr., selten);Adipositas (fachspr.);Fettleibigkeit;Feistigkeit;Obesitas (fachspr.);Feistheit;Fettsucht (ugs.)
-mit Druckluft betrieben;druckluftbetätigt;pneumatisch;pressluftbetätigt
-Fußpunkt;Tiefstand
-(jemandem) seine Verehrung zeigen;verehren;ehren;(jemandem) Ehre erweisen;(jemandem) Achtung erweisen;(jemandem) huldigen (geh., veraltend)
-Phagocytose (fachspr., griechisch);Nahrungsaufnahme durch eine Zelle;Phagozytose (fachspr., griechisch)
-Fachgebiet;Disziplin;Gebiet;Forschungsgebiet;Fachbereich;Bereich;Wissenschaftsdisziplin;Domäne;Fach;Sachgebiet;Fachdisziplin;Lehrfach;Sparte
-Regurgitation (fachspr.);Rückströmen (z. B. des Blutes)
-Verherrlichung;Apotheose (bildungssprachlich);Vergöttlichung;Vergötterung;Idealisierung;Glorifizierung
-Ankaufkurs;Sortenankaufskurs;Ankaufssatz
-Freigabe;Entblockung;Öffnung
-Beguss;Engobe
-Stase (fachspr.);Stillstand eines Flüssigkeitsstromes
-Gemenge;Mischung;Vermischung;Gemisch;Mixtur
-Zykloide;Rollkurve;Radlaufkurve;Radkurve;zyklische Kurve
-Macro;Befehlszusammenfassung;Makro
-auf Grund treiben;auf den Strand setzen
-Edelmut;Großmut;Generosität;Großzügigkeit
-Schubkraft;Scherkraft;Querkraft
-Anteil;Verhältnis;Größenverhältnis;Quotient;Proportion
-Entwässerungsanlage;Entwässerungssystem
-Herr(n);Hr. (Abkürzung);Herr
-Eingriff;Ineinandergreifen (von Zahnrädern)
-Veränderliche;Platzhalter;Stellvertreter;Variable
-umstürzen;umkippen;umschmeißen (ugs.);umwerfen;umstoßen
-Friede;Frieden
-Befehl;Kommando;Gebot
-Lebensraum;Biotop
-einwohnerstark;dicht besiedelt;dicht bevölkert;bevölkerungsreich
-hypodermal (fachspr.);unter der Haut;unter die Haut;subkutan (fachspr.)
-(den) Blick heben;aufblicken;aufschauen;aufsehen
-durabel;dauerhaft;auf Dauer angelegt;von Bestand sein;Bestand haben;beständig
-notgeil (ugs.);in Hitze;spitz;lüstern;heiß (ugs.);erregt;fickrig (derb);rattig (ugs.);fickerig (derb);scharf;rallig (ugs.);spitz wie Nachbars Lumpi (ugs.);rollig (ugs.);geil (ugs.);von sexueller Begierde erfüllt;sexgeil;wollüstig
-nicht bis;nicht bevor;erst als;erst wenn
-geruchtilgend;desodorierend
-lückenlos;ohne Lücke;abstandslos;flächendeckend;taxativ (österr.);vollständig
-chronisch konstitutionelles Ekzem;endogenes Ekzem (fachspr.);atopisches Ekzem (fachspr.);Asthmaekzem (fachspr.);Neurodermitis;atopische Dermatitis (fachspr.);Prurigo Besnier (fachspr.)
-gammelig (ugs.);schimmelig;verschimmelt;schlecht (Speisen);vergammelt (ugs.);verdorben;kahmig;sporig;gammlig (ugs.)
-Künstlermappe;Zeichenmappe
-Zuckerbäcker (veraltet);Konditor;Patissier (franz.);Confiseur (schweiz.);Feinbäcker
-hauseigen;betriebseigen;betriebsintern;Betriebs...;Haus...;firmenintern
-tiefkühlen;gefrieren;einfrieren
-Begutachtung;Inspektion;Betrachtung;Untersuchung;Auswertung;Studie;Prüfung;Erforschung;Analyse;Überprüfung
-Scheißhaus (derb);Topf (ugs.);Kackstuhl (derb);(es) Häusl (ugs., österr.);WC (Abkürzung);Retirade;Keramikabteilung (ugs., Modewort);Latrine;Tö (ugs.);Pinkelbude (derb);Lokus (ugs.);To (ugs.);Abort;00;wo (selbst) der Kaiser zu Fuß hingeht (ugs., Spruch);Pissoir (franz.);Toilette (franz., Hauptform);Klo (ugs.);Klosett;Pissbude (derb);Hütte (ugs.);stilles Örtchen (ugs.);Null-Null;Wasserklosett;Donnerbalken (ugs.);Thron (ugs., scherzhaft);Orkus (geh.);Abtritt;Örtchen (ugs.)
-Drama (fachspr.);Repertoirestück;Schauspiel;Stück;Bühnenstück;Theaterstück;Spiel
-Reparaturwerkstätte;Reparaturwerkstatt
-torkeln;wackeln (ugs.);trudeln;schwanken;taumeln;wanken
-bejahen;bejahend antworten;Ja sagen;zustimmen;mit Ja antworten
-Tetanie (fachspr.);Krampfkrankheit
-Abteilung;Sachgebiet;Referat;Sektion;Ressort;Division;Gebiet
-Spielerwechsel;Auswechselung;Ersatz;Auswechselung (gegen)
-unübersichtlich;konfus;wirr;durcheinander;verworren (Hauptform);chaotisch;verwickelt (ugs.)
-Eindringen in eine Substanz;Streuung;Diffusion;Durchmischung;Konzentrationsausgleich
-Außenseite;Äußeres
-Firste (Bergbau);Decke;Zimmerdecke;Plafond (österr.)
-ausnutzen;zur Ader lassen;arm machen;abmelken (ugs.);schröpfen;um Hab und Gut bringen;melken (ugs.);exploitieren;ausbeuten;ausnützen
-Ader;Erzgang
-Eigenwerbung;Selbstlob;Werbung in eigener Sache;Eigenlob;Eigenreklame;Selbstbeweihräucherung (ugs., abwertend, fig.)
-Operationsschwester;operationstechnische Assistentin;OP-Schwester
-Blaumachen;(unentschuldigte) Abwesenheit;Fehlzeit (fachspr.);Schwänzen;Fehlstunde(n)
-gemütsarm;verroht;hartgesotten;eiskalt;gefühllos;gefühlsarm;gefühlskalt;emotionslos;skrupellos;kaltschnäuzig (ugs.);abgebrüht (ugs.)
-Bereicherung;Anreicherung
-Draufgängertum;Rücksichtslosigkeit
-Altersgeld (fachspr., bundesdeutsch);staatliche Rente (bundesdeutsch, schweiz.);Altersrente (Hauptform);staatliche Pension (österr.);Altersruhegeld (bundesdeutsch);gesetzliche Pension (österr.);Ruhegehalt (Amtsdeutsch, bundesdeutsch);Altersversorgung;Alterssicherung;Alterspension (österr.);gesetzliche Rente (bundesdeutsch, schweiz.);Ruhestandsgeld (Amtsdeutsch, bundesdeutsch);AHV-Rente (Amtsdeutsch, schweiz.);ASVG-Pension (Amtsdeutsch, österr.)
-Skalenstrich;Teilstrich
-Schmierblutung;Spotting (fachspr.)
-Arbeitsgang;Verfahren;Arbeitsvorgang;Operation
-lässig;luftig
-Entschädigung;(finanzielle) Kompensation;Schadensersatz(zahlung) (Hauptform);Schadenersatz(zahlung) (österr.);Schadloshaltung (fachspr., veraltend);Wiedergutmachung
-Desquamation (fachspr., lat.);Abschilferung;Abschuppung
-Thalamus (fachspr.);Sehhügel;Wände des Zwischenhirns
-Markröhre;Kern;Mark
-ungewöhnlich;abnormal;aberrant;mit ungewöhnlichem Verlauf;abnorm;regelwidrig;außer der Reihe;von der Regel abweichend;anormal;anomal;unregelmäßig;außertourlich (österr.)
-Ferkelei (ugs.);Sauerei (ugs.);Schweinerei (ugs.)
-dämpfen;schmälern;trüben
-(jemanden) fixieren;(jemanden) fesseln;(jemandem) Handschellen anlegen;(jemandem) Fesseln anlegen (variabel)
-Schwäche;Willfährigkeit;Nachgiebigkeit
-Grabfeld;Kirchhof (veraltet);Leichenhof (veraltet);Begräbnisplatz;Gottesacker (veraltet);Friedhof (Hauptform);Totenacker;Gräberfeld
-Unverbindlichkeit;Abweisung;Versagung;Inkonzilianz (lat.)
-Dauer...;Endlos...;ständig;dauernd;ewig (ugs.);immerfort;pausenlos;permanent;andauernd
-einreiben;reibend auftragen
-Ausfall;Störfall;Betriebsstörung
-Scherbruch;Schubbruch
-bedürfen;benötigen;haben müssen;brauchen;Bedarf haben
-in zeitlicher Übereinstimmung (zu / mit);synchron;live (engl.);gleichzeitig (Hauptform);simultan (mit);zeitgleich;in (...) Koinzidenz;gleichlaufend (zu);in Echtzeit (technisch);zugleich;zur selben Zeit;parallel (zu);zeitlich übereinstimmend (mit);zusammenfallend (mit);zur gleichen Zeit;koinzident
-vernehmen;(jemanden) einvernehmen (bürokrat./jurist.) (fachspr.);ausfragen;verhören;befragen;inquirieren (veraltend);(jemanden) grillen (ugs.)
-(sich) trennen (von);(sich) scheiden lassen (von);nicht mehr zusammen sein mit (ugs.);geschieden werden (von)
-Krätze;Acarodermatitis (fachspr.);Scabies (fachspr.);Skabies (fachspr.);Räude
-Nullipara (fachspr.);Frau, die noch kein Kind geboren hat
-Kodizill;Nachtrag (zu einem Testament)
-nachlassen;schwächeln (ugs.);müde werden;schwächer werden;sich verschlechtern;(die) Kraft verlieren;Ermüdungserscheinungen zeigen;erlahmen;schlechter werden;lahmen
-essbare Muschel;Klaffmuschel
-untergeben sein;(jemandem) unterstehen
-ergebnisoffen;objektiv;unparteiisch;ohne Berührungsängste;unvoreingenommen (Hauptform);unbefangen;werturteilsfrei;ohne Scheuklappen (fig.);vorurteilsfrei
-Segelflieger;Segler;Segelflugzeug
-Mundtuch (veraltend);Serviette
-Gartenbaukunst;Gartenbau
-Dachgarten;Dachterrasse
-politische Ordnung;Staatsform;politisches System
-kontaminieren;verunreinigen;vergiften
-Dunstkreis (leicht abwertend) (ugs.);Umfeld (Hauptform);(die) mit denen sich jemand umgibt;Connection (ugs., engl.);Umgebung;Entourage (geh.);Milieu;Peripherie
-Ausgangspunkt;Wiege (geh., fig.);Ursprungsort
-Ceratotherium simum (fachspr., lat.);Breitmaulnashorn (Hauptform);Weißes Nashorn;Breitlippennashorn
-trenzen (ugs., österr.);(eine) feuchte Aussprache (haben) (ugs., scherzhaft-ironisch);sabbern (ugs.);schlabbern (ugs.);sabbeln (ugs., norddeutsch);(jemandem) fließt Speichel aus dem Mund;seibern (ugs.);geifern
-Verweser;Statthalter;Stellvertreter;Bevollmächtigter;Vize
-Anredetext;Adressentext
-zerstreuen;auseinander jagen;auseinander treiben
-mächtig;gewaltig;großmächtig
-losgelöst;befreit von;los;entfesselt
-Bengel;Rotzbengel (ugs.);Lümmel (ugs., veraltend);Rotzbubi (ugs.);Rotzjunge (ugs.);Dreikäsehoch (ugs.);Schlingel;Fratz (süddt.);Rotzlöffel (ugs.);Frechling;Lausbub;Lausbube;Bazi (ugs., bayr., österr.);Flegel;Racker (ugs.);Lorbass (ostpreußisch);Schelm;Strolch;Lausebengel;Frechdachs (ugs.);Pülcher (ugs., österr.);Rotzgöre (ugs.);Range (veraltet);Rotzblag (ugs., ruhrdt.);Früchtchen (ugs.);Knilch (ugs.);Schliffel (ugs., altbairisch, veraltet);Frechmops (ugs.);Rotznase (ugs.);Lauser (ugs.)
-Bindungsprotein;Ligand
-Strand;Badestrand
-Kopfschutz;Schutzhelm;Krachhut (ugs., Jargon);Helm;Sturzhelm
-Erdvermessung;Vermessungskunde;Geodäsie
-Gewindeschneidbohrer;Mutterbohrer;Gewindebohrer (Hauptform);Gewindeschneider;Schraubbohrer
-Scharfsinn;Genialität
-arabische Ziffern (ugs.);indische Ziffern;indisch-arabische Ziffern
-Haare entfernen;enthaaren;depilieren
-Gewoge;Gedränge;Gewurl (ugs., landschaftlich, süddt.);Gewühl;Gemenge;Wuling (regional);Gewusel (ugs., landschaftlich);Getümmel;Geschiebe (ugs.);Gewimmel
-selbstregulierend;selbstkorrigierend;selbstnachstellend
-Molluske;Weichtier
-überproportional;progressiv
-aufgeladen;beladen
-Ungültigkeit;Hinfälligkeit
-ermitteln;kalkulieren;berechnen;rechnen
-gewellt;geriffelt;gerillt
-Showmaster;Maître de Plaisir (geh., scherzhaft);Entertainer;Unterhalter;Unterhaltungskünstler
-schachern;handeln;feilschen;feilschen wie im türkischen Basar (ugs., variabel);(im Preis) herunterzuhandeln versuchen;feilschen wie ein Teppichhändler (ugs.)
-Erika;Heidekraut;Heide
-Lauf;Strömung;Strom
-Zimmerhandwerk;Zimmerarbeit;Tischlerarbeit;Schreinerarbeit
-Anpassung;Adaptation;Akkommodation (fachspr.)
-blass (vor);bleich (vor)
-Nachtlager;Feldlager
-Ohnmacht;Besinnungslosigkeit;Bewusstlosigkeit;Ohnmächtigkeit
-eine Vorbemerkung machen;voranstellen
-ernsthaft;seriös;ernst
-Rechnungsjahr;Fiskaljahr;Wirtschaftsjahr;Geschäftsjahr (Hauptform);Steuerperiode (schweiz.);Finanzjahr
-Radixschreibweise;Stellenwertschreibweise
-Elektronenfehlstelle;Defektelektron;Loch (Halbleiter)
-atoxisch;ungiftig
-Dermatitis;Hautentzündung
-Schiffsrumpf;Rumpf;Schiffskörper
-kommunalisieren;verstadtlichen
-Ahn;Vorfahr;Altvorderer;Urahn;Vorfahre
-Mäkler;Krittler;Beckmesser;Nörgler;Meckerer;Querulant;Kritikaster;Meckerfritze (ugs., männl.);Meckertante (ugs., weibl.)
-alles erreicht haben;siegreich;(es) geschafft haben (ugs.);erfolgreich;ein gemachter Mann (sein) (ugs.);triumphierend;von Erfolg gekrönt;(ein) gemachter Mann (sein) (männl.);(ganz) oben angekommen (sein);arriviert (geh.)
-wischen;säubern
-uniform;gleichförmig
-Kapuze;Haube
-unaufrichtig;unwahrhaftig;verlogen;falsch (ugs.);unehrlich;unlauter;falschzüngig (geh.);lügenhaft;lügnerisch;unredlich
-reif werden;reifer werden;heranreifen
-konnektieren;anbinden;anschließen;verbinden;anklemmen;verknüpfen;anstöpseln (ugs.);vernetzen
-Sterilität;Keimfreiheit;Asepsis (fachspr.)
-abendländisch;okzidental;westlich;europäisch
-Druckerschwärze;Schwärze
-funzlig (beleuchtet);halbdunkel;schummerig (ugs.);zwielichtig;dämmerig;funzelig (beleuchtet);schummrig (ugs.)
-Stilistik;Stilkunde
-Fraktionieren (fachspr.);Fraktionierung (fachspr.)
-Abraumhalde (Kohlebergwerk);Abraum
-Anschlussdose;Verteilerdose
-Abnormalität;Aberration;Abweichung;Verirrung
-enterohepatisch (fachspr.);Leber und Darm betreffend
-Entzerrer;entzerrende Übertragungseinrichtung
-Landflucht;Urbanisierung;Urbanisation;Verstädterung
-verhackstücken (ugs.);zerfetzen;zerreißen;zerfleddern
-Spannweite;Flügelspanne
-Aquila chrysaetos (fachspr., griechisch, lat.);Steinadler (Hauptform);Goldadler
-marmorieren;ädern;sprenkeln;masern
-Depot;Lagerhalle;Lager;Magazin;Speicher;Lagerhaus;Warendepot;Warenspeicher
-Hub;Takt;Taktsignal;Gewandtheit
-aufhetzen;aufwiegeln;aufstacheln;anstacheln;verhetzen;anspitzen
-exokrin (fachspr.);nach außen absondernd
-Korruption;Bestechung
-Neugestaltung;Umgestaltung;Reform;Neuordnung;Reorganisation;Neuregelung
-(das) Hier und Jetzt (fig.);Gegebenheit;Tatsächlichkeit;Wirklichkeit;Boden der Tatsachen (Redensart);Faktizität (geh.);(das) wahre Leben (ugs.);(harte) Realität
-durchbohren;durchlöchern;lochen
-Eiweißkörper;Albumin (fachspr.)
-Strom;Wasserschwall;Schwall
-katastrophal (fig.);miserabel;lausig;saumäßig;eine Katastrophe (fig.);gruselig (ugs., übertreibend);jeder Beschreibung spotten;unter aller Kritik;unter aller Kanone (ugs.);lausig schlecht;sehr schlecht (Hauptform);unterirdisch (ugs.);hundsmiserabel (ugs.);mies (ugs.);grottig (ugs.);unter aller Sau (derb);grottenschlecht (ugs.);zum Abgewöhnen
-knallen;platzen
-griffig;rutschfest;handlich;griffgerecht
-Gewährleistung;Sicherung;Sicherstellung
-dahinraffen (ugs.);auslöschen (ugs.);aufreiben (militärisch);liquidieren;entfernen;vernichten;ausradieren (ugs.);zerschlagen
-Schädelkalotte (Hauptform);Schädelkappe;Schädeldecke;Schädeldach;Hirnschale;Calvaria (fachspr., lat.);Kalotte (Kurzform)
-geduldeterweise;unter stillschweigender Duldung;nur geduldet
-gleitende Arbeitszeit;Gleitzeit
-gleichen;Züge haben (von);ähnlich sein;etwas haben von (einem / einer) (ugs.);gleichkommen;(sich) vergleichen lassen (mit);ähneln;erinnern an;angelehnt an (sein)
-verzweifelt;ohne (jede) Hoffnung;ohne die geringste Chance;zukunftslos;ohne die geringste Aussicht;in völliger Verzweiflung;am absoluten Nullpunkt;am Boden (ugs.);am absoluten Tiefpunkt;am Abgrund;(hat / hatte) nicht die geringste Chance;todunglücklich;ohne die geringste Hoffnung;für sich keine Zukunft sehend;hoffnungslos;(hat / hatte) keine Chance;ohne Ausweg;am Ende (ugs.);in absoluter Verzweiflung;ohne jede Chance;ohne (jede) Aussicht;ausweglos
-oben;überhalb;oberhalb;über
-prämenstruell (fachspr.);vor der Menstruation
-Trommelfellschnitt;Parazentese (fachspr.)
-aneinander stoßen;aneinander schlagen
-Wochenfluss nach der Geburt;Lochien (fachspr.)
-Bauliste;Montageliste
-subkonjunktival (fachspr.);unter der Bindehaut des Auges
-Fädchen;Flusen;Fusseln
-nicht berücksichtigen;links liegen lassen;vernachlässigen;stiefmütterlich behandeln (ugs.);(sich) nicht kümmern (um);sträflich vernachlässigen;(sich) nicht befassen (mit);(sich) nicht abgeben (mit)
-anwerben;akquirieren (fachspr.);einwerben;rekrutieren (geh.)
-(etwas) einüben;(etwas) trainieren;(etwas) einstudieren;(etwas) üben
-Krümel;Brösel;Bröckchen
-Fahrt;Reise;Tour;Trip
-friedlich;sanft;harmlos;mild;weich;glimpflich
-zersplittern;abspalten;herauslösen
-übergeben;reichen;aushändigen;ausfolgen (österr.);herüber reichen;rüberwachsen lassen (ugs., Jargon, salopp, veraltend);(jemandem etwas) geben (Hauptform);rüberschieben (ugs.);überreichen;(jemandem etwas) in die Hand drücken (ugs., salopp)
-Vertretung;repräsentativer Charakter
-Vorhofflimmern;absolute Arrhythmie
-genau dann, wenn;dann und nur dann
-Balkon;Loggia;Galerie
-(übertrieben) komfortabel;luxuriös;feudal
-auf und ab bewegen;hin und her bewegen
-Besserung;Melioration (veraltet);Vervollkommnung;Verbesserung;Aufwertung;Optimierung;Aufbesserung;Verfeinerung;Läuterung
-Umlaufverdichter;Rotationskompressor
-Spiel (Hauptform);Partie;Begegnung;Runde;Kampf;Treffen;Match;Fight (engl.);Aufeinandertreffen (fachspr., mediensprachlich)
-öffentliche Bekanntmachung;Proklamation;Ausrufung;Verkündigung
-Bassgeige;Bass (ugs.);Kontrabass (Hauptform)
-Lizitation;Feilbietung (österr.);Auktion;Versteigerung;Gant (schweiz. od. veraltet);Vergantung (schweiz. od. veraltet);Gandt (veraltet);Gantung (veraltet)
-Kalkül;Strategem (geh.);Drehbuch (fig.);Vorgehensweise;Ablaufplan;Schlachtplan (ugs., fig.);Strategie;Fahrplan (fig.);Masterplan;Plan
-Pakistaner;Pakistani
-Anklage;Vertreter der Anklage;Anklagevertretung
-Club der reichen Länder (ugs.);Organisation für wirtschaftliche Zusammenarbeit;Organization For Economic Cooperation And Development (engl.);OECD (Abkürzung, engl.)
-ärztliche Verordnung;Rezept;Präskription
-Ösophagitis (fachspr.);Entzündung der Speiseröhre
-(eine Grenze) knacken (ugs.);größer sein (als);überschreiten;(über etwas) hinausgehen;übersteigen
-Pauschalbezahlung;einmalige Bezahlung;Pauschalzahlung
-furchig;zerfurcht;runzlig;verrunzelt;runzelig;voller Runzeln
-Überzeugungskraft;Beweiskraft;Aussagekraft
-Vermittlung;Agentur;Vertretung;Geschäftsstelle;Büro eines Agenten
-Alt und Jung;alle;allesamt;Freund und Feind (ugs.);die Gesamtheit;sämtliche;Arm und Reich;ganz
-funkgesteuert;funkgeregelt
-Fragenkatalog;Fragebogen
-Grundstückserwerb;Grunderwerb;Grundstückskauf
-Endhaltestelle;Terminal;Endstelle;Endstation
-Rispe;Blütenrispe
-Stärkung;Stützung;Verstärkung;Untermauerung
-bis dahin;bis nachher
-(sich) erniedrigen;im Staub(e) kriechen vor (geh., fig., veraltend);(sich) demütigen;(sich) wegwerfen (fig.);(sich) entwürdigen
-anhalten;rufen (Taxi);herbeiwinken
-passiv;brachliegend;unbeschäftigt;inaktiv;untätig
-Enanthem (fachspr.);Schleimhautausschlag
-Beilegung;Zuschreibung
-verbrämen;in den Himmel heben (fig.);mit einem Glorienschein umgeben;vergöttern;überhöhen;anhimmeln (ugs.);verherrlichen;huldigen (geh.);hochstilisieren;hochjubeln;mit einem Glorienschein versehen;eine (ihm / ihr) nicht zukommende Bedeutung verleihen;emporstilisieren;eine (ihm / ihr) nicht zukommende Bedeutung beimessen;anbeten;glorifizieren (geh.);beweihräuchern;(jemanden) gottgleich verehren;verklären;idealisieren (Hauptform)
-erwärmen;heizen;erhitzen;heiß machen
-ausklamüsern (ugs.);ausknobeln (ugs.);(etwas) im Schilde führen (ugs.);aushecken (ugs.);ausbrüten (ugs., fig.)
-Rechnungsbetrag;Andienungspreis
-parfümieren;mit Duft erfüllen
-totes Gewicht;Leergewicht
-Penicillin zerstörendes Enzym;Penicillanase
-Ansinnen (geh.);Unternehmung;Projekt;Unterfangen (geh.);Streben;Vorhaben;Unternehmen
-in Ruhestand gehen;aufhören zu arbeiten;aufs Altenteil gehen (fig.);aus dem Erwerbsleben ausscheiden (statist.) (fachspr.);in den Ruhestand treten;in Rente gehen;aus dem Amt scheiden (Beamte);seine aktive Zeit beenden;in Pension gehen;(sich) aufs Altenteil zurückziehen (fig.);aufhören (ugs.);(sich) aufs Altenteil setzen (fig.);(sich) zur Ruhe setzen
-nippen;schlürfen
-(sich) zersetzen;(sich) in seine Bestandteile auflösen
-Unaufmerksamkeit;Unachtsamkeit
-Evangelische Kirche in Deutschland;EKD (Abkürzung)
-Ziegenmelker;Nachtschwalbe
-(jemanden) wurmen (ugs.);(jemandem) die Zornesröte ins Gesicht treiben (fig., floskelhaft);(total) nerven (ugs.);(total) abnerven (ugs.);(kräftig) ärgern
-Agenda;Vormerkbuch;Taschenkalender;Terminkalender
-teratologisch (fachspr.);Missbildungen betreffend
-Teilelieferant;Zulieferer (Hauptform);Produzent von Bauteilen;Zulieferbetrieb;Unterlieferant;Zulieferfirma;Komponentenhersteller
-Maser;Strich;Streifen;Maserung
-Kassenzettel;Quittung;Bon;Beleg;Kassenbeleg;Kassenbon
-gehässig;spitz (ugs.)
-Produktionstechnik;Fertigungstechnik
-Haufwerk (fachspr.);Aufschüttung;Schüttung;Haufen;Hochkippe (regional);Halde
-(sich) zoffen (ugs.);(sich) zanken (ugs.);(sich) fetzen (ugs.);(sich) kabbeln (ugs.);(sich) streiten (mit / über / um / wegen);hadern (mit);(mit jemandem) ein Hühnchen rupfen (ugs., fig.)
-kalt;kühl;frisch;frostig
-mit Todesverachtung (auch iron.);tapfer;heldenhaft;mutig;unerschrocken;kühn;heroisch;heldisch (geh., emphatisch);heldenmütig;mannhaft
-von einer Person hergeleiteter Name;Eponym
-Debakel;Desaster;Katastrophe;Fiasko;GAU (Abkürzung)
-Entzündung;Inflammatio (fachspr.);Inflammation (fachspr.)
-Anstoß erregend;ohne (jedes) Schamgefühl;anstößig;obszön;schamlos;schamverletzend;schockierend
-zusammenpressen;packen;ballen;umklammern
-Schmelzglas;Email;Emaille
-keimhemmend;bakteriostatisch (fachspr.)
-Kornbrand;Korn (ugs., Hauptform)
-Unterzeichner...;Signatar... (geh.)
-besorgt (um);sorgsam
-Schwulette (ugs., abwertend);Homophiler;Uranier (selten);Schwuppe (derb);Homosexueller;Schwuchtel (derb);Uranist (selten);Homo (ugs.);warmer Bruder (ugs.);Schwuler (ugs.);Homoerotiker;Hinterlader (derb, abwertend, veraltet)
-trauern (über, um);klagen
-Leukozytose (fachspr.);Vermehrung der Leukozytenzahl
-woanders;anderweitig;sonst wo;nicht hier;hier nicht;ich weiß nicht wo (ugs.);anderswo
-Rechenstab;Rechenschieber
-unbewegt;stationär;starr;bewegungslos;ortsfest;ruhend;ruhig
-Autobus (ugs., schweiz., österr.);Bus;Omnibus
-Zoomobjektiv;pankratisches System (fachspr.);Gummilinse (ugs.);Transfokator;Transfokar;Vario-System;Vario-Objektiv;Zoom (ugs.)
-wasserlöslicher Giftstoff;Toxin
-Erlass;Zurücknahme;Beendigung;Widerruf;Auflösung;Aufhebung
-zusteuern;kontribuieren (geh., lat., veraltet);beisteuern;beitragen
-fraternisieren;verbrüdern
-nervend;stressig (Hauptform);anstrengend;stressvoll
-frech;keck;kess;fesch (ugs., süddt.);flott;kokett;herausfordernd;aufreizend;neckisch
-a. D. (Abkürzung);außer Dienst;dienstfrei
-Druckguss;Druckgießen
-klaglos (österr.);störungsfrei;anstandslos;reibungslos;wie geschmiert (ugs.);unaufwändig;wie am Schnürchen (ugs.);problemlos (Hauptform);wie ein Glöckerl (ugs., österr.);ohne Probleme;umstandslos;ohne Schwierigkeiten;einfach;mühelos
-computergestützte Fertigung;CAM;Computer Aided Manufacturing
-Redundanz;Langatmigkeit;Weitschweifigkeit
-Lebenslauf;Vita;Lebensbeschreibung;Lebensablauf;Biographie;Lebensgeschichte;Biografie
-erst (ugs.);am Beginn;zuerst;erst mal (ugs.);anfangs;anfänglich;einleitend;eingangs;zu Anfang;zunächst;erst einmal;zu Beginn;als erstes;am Anfang
-Computer Aided Design (engl.);computerunterstütztes Entwerfen und Konstruieren;rechnerunterstützte Konstruktion;CAD
-schwinden;abflauen
-Essen;Viktualien (veraltend);Nahrungsmittel;Esssachen (ugs.);Nahrung;Lebensmittel;Fressalien (derb);Esswaren
-sehr wahrscheinlich;nach menschlichem Ermessen;wenn nicht (noch) ein Wunder geschieht (variabel);(es gibt) keine andere Erklärung;aller Voraussicht nach;mit an Sicherheit grenzender Wahrscheinlichkeit;(es) spricht viel dafür (dass) (variabel);(die) üblichen Verdächtigen (ugs., Redensart);vermuten lassen (geh.);höchstwahrscheinlich;soweit erkennbar
-androhen;bedrohen;drohen;dräuen (veraltet)
-Charakteristik;Besonderheit;Ausprägung;Merkmalsausprägung;Eigenart;Eigenheit
-Abschreibungsperiode;Abschreibungsdauer
-Krampfzustand der Bronchialmuskulatur;Bronchospasmus (fachspr.)
-Haushaltshilfe;Hausangestellter
-dickes Stück;Brocken
-Konsonant;Mitlaut
-bluttriefend;blutverschmiert;blutüberströmt;voller Blut;blutig;blutbefleckt;blutend
-abgabenpflichtig (fachspr.);steuerpflichtig;besteuert;nachschusspflichtig
-Vergoldung;Goldauflage
-Stacheldraht (Hauptform);Z-Draht;Nato-Draht (fachspr., Jargon, bundesdeutsch, militärisch);S-Draht;Widerhakensperrdraht (fachspr., Amtsdeutsch, bundesdeutsch, militärisch)
-minus;negativ
-Altersheim;Seniorenstift;Altenheim;Pensionistenheim (österr.);Seniorenheim;Seniorenresidenz (verhüllend);Feierabendheim;Altenhilfeeinrichtung;Betagtenheim (schweiz.)
-Hautausschlag;Exanthem (fachspr.)
-losgelöst;abgekoppelt;unabhängig
-keulen;Tierbestände erlegen
-tragfähig;fest;belastbar;haltbar;solide;stabil;stark;robust;taff (ugs.);zäh;ehern;bestandskräftig;resilient (fachspr.);stattlich;kräftig
-Verzweigungsbedingung;Sprungbedingung
-Signalwirkung haben (fig., variabel);wirken (auf);einwirken (auf);beeinflussen;Auswirkungen haben;(sich) auswirken (auf)
-Herausforderung (floskelhaft, verhüllend);schwierige Aufgabe;Baustelle (ugs., fig.);Challenge (ugs., Jargon, engl.);(echte) Aufgabe;Schwierigkeit;Problem
-addierbar;aggregierbar
-Ungenauigkeit;Schlampigkeit (ugs.);Gedankenlosigkeit;Gleichgültigkeit;Nichtbeachtung;Unachtsamkeit;Fahrlässigkeit;Vernachlässigung;Schludrigkeit (ugs.);mangelnde Sorgfalt;Achtlosigkeit;Nachlässigkeit;Leck-mich-am-Arsch-Einstellung (derb)
-Unterbringung;Unterkunft;Quartier
-kognitiv;erkenntnismäßig
-aus dem Weg gehen;aus der Schusslinie gehen (ugs., fig.);Platz machen;zur Seite springen;zur Seite gehen;weggehen;ausweichen
-lichtelektrisch;photoelektrisch
-kategorisieren;einstufen;bewerten
-Vergütung;Belag;Film;Schicht
-Rückführung (verhüllend);Aussiedlung;Ausschaffung (schweiz.);Abschiebung;Vertreibung;Exilierung;aufenthaltsbeendende Maßnahme (fachspr., euphemistisch);Rückschaffung (schweiz.)
-Type (fachspr.);Font (fachspr., engl.);Schrift;Schriftart
-Dr. med. (Abkürzung);Doktor der Medizin
-Adresskennzeichen;Anschriftenkennzeichen
-Rechnung senden;berechnen;Rechnung ausstellen;belasten
-Wurzelsellerie;Zeller (österr.);Knollensellerie
-Drogenabhängigkeit;Toxikomanie (fachspr., medizinisch);Rauschgiftsucht;Rauschmittelsucht;Rauschgiftabhängigkeit;Drogenmissbrauch;Narkomanie (fachspr., medizinisch);Drogensucht
-Büttel;Häscher (veraltet);Scherge;Fänger (veraltet);käuflicher Verräter
-Pigmentschwund;Depigmentierung
-Weltkarte;Atlant;Atlas;Landkarte
-Gemeinsame Agrarpolitik;GAP;EU-Agrarpolitik
-ausgerechnet;justament;gerade;just
-aquatisch;Wasser...
-Sendeeinrichtung;Sendeanlage;Sender;Sendegerät
-Betriebsfähigkeit;Gebrauchsfähigkeit
-Abzahlung;Rückzahlung (einer Geldschuld);Tilgung
-genauso hoch sein wie;auf dem gleichen Niveau stehen wie
-seitlich;lateral (fachspr.);zur Seite hin gelegen
-angegrenzt;eingefasst
-bauschig;wulstig;dick;geschwollen;gebauscht;angeschwollen
-uferlos;allzu (sehr);maßlos;übertrieben;übermäßig;ohne Maß und Ziel;hemmungslos;überzogen;ohne Maß;weder Maß noch Ziel (kennen)
-Gummi;Gummiband
-Megakolon (fachspr.);Weitstellung des Dickdarms
-Genehmigung;Approbation;Billigung;Zulassung
-Durchführungsverordnung;Durchführungsbestimmung
-selbstabdichtend;selbstdichtend
-ins Leben rufen;schaffen;führen zu;hervorbringen;verursachen
-Schnalle (österr.);Türklinke;Türschnalle (österr.);Türgriff
-Additiv;Zuschlagstoff;Hilfsstoff;Zusatz;Zusatzstoff
-ungenügende Nahrungsaufnahme aus dem Verdauungstrakt;Malabsorption (fachspr.)
-Sägewerk (Hauptform);Bordmühle (regional);Brettsäge (regional);Sägemühle (regional);Schneidmühle (regional);Sagi (schweiz.);Brettmühle (regional)
-Apoplexie (fachspr.);Gehirninfarkt;Hirninfarkt;Schlagfluss (veraltet);Apoplex (fachspr.);Schlag (ugs.);Gehirnschlag;Insult (fachspr.);Hirnschlag;Schlaganfall
-auf andere Gedanken bringen;(jemanden/sich) ablenken;(sich) zerstreuen
-Schicklichkeit;Kleidsamkeit
-Theosophie;mystische Gotteslehre
-Bestätigung;Inkraftsetzung;Ratifizierung;Ratifikation
-grafische Darstellung;Schaubild;Abbildung;Tabelle;Diagramm;Kurvenblatt
-einmeißeln;eingravieren;meißeln;gravieren
-chaotisch;wirr;unüberlegt;wahllos;unkoordiniert;konfus;unkontrolliert;ziellos;kopflos;einfach drauflos;konzeptionslos
-schwere Bewusstseinstrübung verursachend;soporös (fachspr.)
-mithören;belauschen;lauschen;mitschneiden;abhören;ablauschen;aushorchen
-Stinktier (ugs.);Skunk (fachspr.)
-Entzündung einer Papille;Papillitis (fachspr.)
-kalt;saukalt (ugs.);klirrend kalt;tierisch kalt (ugs.);arschkalt (derb);sehr kalt (Hauptform);eiskalt;bitterkalt;frostig;zapfig (kalt) (ugs., bayr., schweiz., österr.);eisekalt (regional);schweinekalt;eisig;frostklirrend;knackig kalt;arktisch (geh.);winterlich
-schattenhaft;dunkel;ungefähr;undeutlich;obskur;unscharf;unklar
-entwicklungsfähig;(es gibt) Entwicklungspotenzial;(es ist) (noch) mehr zu holen (ugs.);(da ist) mehr drin (ugs.);(noch) Luft nach oben (ugs., variabel);(es) geht (noch) mehr (ugs.);ausbaufähig;(es gibt) Entwicklungspotential;steigerungsfähig;da geht noch was (ugs., Spruch);erweiterungsfähig
-strahlenförmig;sternförmig;radial
-Kontoform;Kontenblatt
-Pfuscharbeit;Pfuscherei (ugs.);Schlamperei (ugs.);Schluderei (ugs.);Schund;schlechte Arbeit;Gestümper (ugs.);Murks (ugs.);Mist (ugs.);Murkserei (ugs.);Pfusch (ugs.);Schlendrian (ugs.)
-entzündlich;entflammbar
-Hülsenfrüchte;Leguminosae (fachspr.);Hülsenfrüchtler;Leguminose;Fabaceae (fachspr.)
-nicht nachgeben;stoisch sein;(sich) nicht erschüttern lassen;(an etwas) dranbleiben;(die) Zähne zusammenbeißen (ugs., fig.);hart bleiben;durchhalten;(die) Arschbacken zusammenkneifen (derb, Spruch, fig.)
-Jubel;Spass (österr.);Gefühlsüberschwang;Wohlgefallen;Überschwang;Begeisterung;Verzückung;Hochstimmung;Euphorie;Enthusiasmus;Spaß;Entzücken;Freude;Vergnügen;Begeisterungsfähigkeit;Entzückung;Schwärmerei
-funktionstüchtig;betriebsfähig;gebrauchsfähig;betriebsbereit
-Meldefahrer;Kradmelder
-Unschlüssigkeit;Zögern;Bedenken;Ungewissheit;Unentschlossenheit;Bedenklichkeit;Zögerlichkeit;Schwanken;Zweifel
-wachstumsfördernd;wachstumsstimulierend;wachstumsanregend
-Genotyp;Erbmasse;Erbbild
-festigen;fest (sicher) machen;stabilisieren
-Kartenprüfer;Kartenprüfgerät
-Abtransport;Abfuhr;Entfernung;Beseitigung;Fortschaffung
-Funktionsstörung;Fehlfunktion;Dysfunktion (fachspr.)
-Empfehlung;Empfehlungsbrief;Referenz;Empfehlungsschreiben;Zeugnis;Referenzschreiben
-Liebesakt (geh.);Beiwohnung (geh., veraltet);(das) Bumsen (ugs.);Fick (vulg.);Koitus (fachspr.);Kopulation (fachspr.);Geficke (vulg.);sinnliche Liebe;Coitus (fachspr.);Geschlechtsverkehr (Hauptform);Verkehr (geh.);Nummer (ugs.);fleischliche Beiwohnung (geh., veraltet);körperliche Liebe;Matratzensport (ugs.);Akt;Beilager (geh., veraltet);Verrichtung (Amtsdeutsch, verhüllend);Sex;Geschlechtsakt;Begattung (fachspr.);Beischlaf (geh.);Gevögel (vulg.);Vollzug (verhüllend);GV (Abkürzung);(die) schönste Nebensache der Welt (fig., verhüllend);Schäferstündchen (ugs., verhüllend);Kohabitation (fachspr.)
-Saldo;Kontostand
-(sich) hin und her wenden;nicht zugeben wollen;um den heißen Brei reden (ugs., fig.);(sich) winden wie ein Aal (ugs., fig.);fickfacken (ugs., veraltet);nach Ausreden suchen;Winkelzüge machen (ugs.);Ausflüchte machen;ausflüchten;versuchen, sich herauszulavieren (ugs.);drumherum reden (ugs.)
-ADAC (Abkürzung);Allgemeiner Deutscher Automobil Club
-Pirouetten drehen;pirouettieren
-Kurzdarstellung;Kurzbeschreibung
-anhängliche Person;Klette (ugs.)
-fortdauernd;stetig;ohne Unterbrechung;fortlaufend;kontinuierlich;immerfort
-aufteilen;zerstückeln;spalten;durchschneiden;zersplittern;teilen;aufspalten
-Hilfs...;Neben...;Behelfs...
-Anwärter;Aspirant;Assessor;Kandidat;Bewerber;Prätendent (geh.);Applikant (geh.);Postulant (kath. Kirche) (fachspr.)
-Durchsichtigkeit;Luzidität;Transparenz;Klarheit;Lichtdurchlässigkeit
-Amnesty International;AI
-Rede;Referat;Vortrag
-Endlospapier;Leporellopapier
-überhitzt;heißgelaufen
-Lage der Dinge (ugs.);Gegebenheiten;Sachlage
-Schmelze;Schneeschmelze
-Firmenzeitung;Mitarbeiterzeitung
-ausgleichen;fluchten;gleichmachen;assimilieren;anpassen;nivellieren;(Unterschiede) beseitigen
-Regenumhang;Poncho;Überwurf
-Fasson;Duktus (geh.);Stil;Art;Formgebung;Manier (geh., altertümelnd);Weise;Machart;Gepräge
-extrazellulär (fachspr.);außerhalb von Zellen
-Vereinbarung;Konvention;Übereinkunft;Einigung;Übereinkommen;Abkommen
-bescheinigen;quittieren;bestätigen;zertifizieren;validieren (Amtsdeutsch)
-angeln;fischen
-Laubengang;Bogengang;Säulengang;Arkaden (franz., ital., lat.);Arkade (franz., ital., lat.);Wandelgang
-hilfreich;gedeihlich (geh.);sachdienlich (fachspr., Amtsdeutsch, Jargon);ersprießlich (geh.);dienlich;gut;fruchtbar;vorteilhaft;wertvoll;nutzbringend;lohnend;von Nutzen;positiv;förderlich;günstig;zuträglich;gute Dienste leisten;opportun;gewinnbringend;nützlich;nutzwertig;von Vorteil
-Anzeigenbüro;Werbungsmittler
-Aufsaugung;Einsaugung
-ableiten;induzieren;abstrahieren;verallgemeinern;herleiten;generalisieren
-Kontrazeption;Konzeptionsschutz;Familienplanung;Antikonzeption;Verhütung;Empfängnisverhütung;Schwangerschaftsverhütung
-wiederbeseelte Leiche (Mystik);Zombie;Untoter
-Strauß;Ballen;Bündel;Bund
-ehelich;hochzeitlich
-unvergütet;unbezahlt;ohne Bezahlung;undotiert;(als Dankeschön ein) feuchter Händedruck (ugs., fig.);für einen feuchten Händedruck (ugs., fig.)
-vermascht;netzartig
-Beendung;Abschluss;Einstellung;Beendigung;Terminierung;Erledigung
-Brandherd;Krisenherd;Unruheherd;Krisengebiet
-Transparent;Spruchbanner;Banner
-Futterkrippe;Futterraufe;Raufe
-schmücken;drapieren;aufhübschen (ugs.);schönmachen;zieren;optisch aufwerten;herausstaffieren;herausputzen;verzieren;ausschmücken;garnieren;dekorieren (Hauptform);aufputzen (ugs.);aufbrezeln (ugs.);verschönern (Hauptform)
-wehen;flattern
-Ziehgeld;Unterhalt;Sustentation (historisch);Alimente;Unterhaltszahlung
-Hintergrundgeräusch;Störgeräusch
-Ausbesserung;Nachbesserung
-todschick (ugs., Verstärkung);fesch;stylish (fachspr., werbesprachlich);geil (ugs.);elegant;frech (fig.);cool (ugs., engl.);kleidsam;schmissig;todchic (ugs., Verstärkung);chic;modisch;schnatz (ugs., regional);schick;schnieke (ugs., berlinerisch);flott;schnittig;schmuck
-jemanden in seinen Bann ziehen;jemanden verzaubern
-schmerzhafter Harn- oder Stuhlgang;Tenesmus (fachspr.)
-Beitrag;Quote;Kontingent;Anteil;Mitwirkung
-Winkelschleifer;Schleifhexe (ugs.);Flex (ugs., Markenname);Trennhexe (ugs.);Trennschleifer;Feuerradl (ugs.)
-Auftaktveranstaltung;Premierenfeier;Eröffnungsveranstaltung;Kick-off-Event;Kick-off-Veranstaltung
-audiovisuell;hörbar-sichtbar
-Prozessstrahl;Aktivitätsstrahl
-Zuflucht;Asyl;Schutzort;Zufluchtsort;Fluchtpunkt;Zufluchtsstätte
-Trikot;Dress;Sporthemd
-neural (fachspr.);Nerven betreffend
-Wiederherstellung;Wiederbildung;Erholung;Regeneration
-(sich) besprechen;(mit jemandem) Rücksprache halten
-allüberall;allerorts;auf Schritt und Tritt;landauf, landab (geh.);wo man geht und steht;wo (immer) man (auch) hingeht;allseits;allerseits;wohin ich auch blicke;straßauf, straßab;überall;allenthalben;an jedem Ort;wo man (auch) hinguckt (ugs., regional);an allen Ecken und Enden;allerorten;flächendeckend
-Belastungsprobe;Dauertest;Langzeittest
-schuppenförmig;squamös (fachspr.)
-Objektivation;Vergegenständlichung;Verdinglichung
-(um jemanden) bemüht;fürsorgend;aufmerksam;(um jemanden) besorgt;auf jemandes Wohl bedacht (geh.);sorglich (geh., veraltend);fürsorglich (Hauptform);(um)sorgend;bekümmert (um)
-Feilspäne;Schleifstaub
-Geographie;Geografie;Erdkunde
-mit Witz;geistreich;pfiffig;originell;witzig;blitzgescheit;findig;vigilant (geh.)
-Photophobie (fachspr.);Lichtscheu;gesteigerte Lichtempfindlichkeit;Fotophobie (fachspr.)
-null;nix (ugs.);weit und breit nichts;nil;nichts
-Wrack;Schiffswrack;Wrackgut;Schiffstrümmer
-Zuschlag erteilen;Auftrag vergeben
-Ausgleichszahlung;Ausgleichsleistung
-gewandt;begabt;geschickt;fingerfertig;kunstfertig
-Botschafter;Missionschef;Konsul;Geschäftsträger;diplomatischer Vertreter;Auslandsvertreter;Diplomat;Repräsentant
-hehlen;Hehlerei treiben
-Pauschale;Einheitspreis;Pauschalpreis;Preispauschale;Pauschalbetrag
-Abnützung;Abschaben;Abschleifung;Abreibung
-Schrott;Altmaterial;Altwaren
-Arrestbeschluss;Pfändungsbeschluss
-ausglühen;anlassen;adoucieren (fachspr., veraltet);tempern;vergüten (Metall)
-schützen;bewachen;behüten
-Beisetzung;Begräbnis;Beerdigung;Bestattung
-Tombak;Kupfer-Zink-Legierung
-Amtsdauer;Amtszeit;Amtsperiode
-Undankbarkeit (Hauptform);fehlende Dankbarkeit;Undank
-Erläuterung;Anmerkung;Bemerkung;Kommentar
-postmenopausal (fachspr.);nach der Menopause
-travestieren (geh.);ins Lächerliche ziehen;persiflieren;karikieren;veräppeln (ugs.);verballhornen;verkaspern (ugs.)
-herumrennen;herumlaufen
-dampfig;diesig;feucht;beschlagen;dunstig
-hinunterlaufen;hinunterrennen;nach unten rennen
-Insasse;Passagier;Fahrgast;Reisender;Beförderungsfall (tech.) (fachspr., Amtsdeutsch);Mitfahrender
-Müdigkeit;Überdruss
-Industrieunternehmen;Industriebetrieb
-Gerte;Reitgerte
-entwaffnen;abrüsten
-eitrig und schleimig;mukopurulent (fachspr.)
-Hörmuschel;Hörer
-Geisteskraft;Geistigkeit
-schustern (ugs.);kitten;ausbessern;flickschustern (ugs.);notdürftig reparieren;zurechtmachen (ugs.);flicken;nachbessern;(wieder) herrichten;zusammenbasteln
-zwängen;stopfen;pfropfen;pferchen;drücken;pressen;quetschen;knautschen;proppen (norddeutsch)
-Geschäftsgebaren;(gute) kaufmännische Übung;Usance (geh., franz.);Handelsbrauch;Usanz (geh.)
-Unentwegtheit;Standhaftigkeit;Beharrlichkeit
-wetterhart;wetterbeständig;wetterfest
-diagonal;quer;schräg;schief
-Leihgebühr;Mietbetrag;Mietpreis;Miete
-umschlagen;weiter blättern;umblättern
-Verblassung (fachspr.);Ausbleichen;Bleichen;(das) Verbleichen;(das) Verblassen;Entfärbung
-Kostenübernahme;Übernahme der Kosten
-feuerfest;nicht brennbar;flammwidrig (fachspr.);nicht entflammbar;unbrennbar
-Katalog;Prospekt;Broschüre
-Lutschbonbon;Klümpken (ugs., ruhrdt.);Bonbon;Kamelle (ugs., kölsch);Zuckerl (bayr., österr.);Gu(e)tsle (ugs., schwäbisch);Bömsken (ugs., ruhrdt.);Täfeli (schweiz.);(saurer) Drops;Babbelchen (ugs., Kindersprache, rheinisch);Klümpchen (ugs., regional);Zältli (schweiz.)
-menschenscheu;ungesellig;unnahbar;distanziert
-Knödel;Kloß
-(sich) abpellen (ugs.);abblättern;abschilfern;(sich) abschälen
-Urographie (fachspr.);Röntgenkontrastdarstellung der Harnwege;Urografie (fachspr.)
-übernehmen;(bei jemandem / etwas) Anleihe nehmen;(sich) zu eigen machen;annehmen;adoptieren
-Anemometer;Windgeschwindigkeitsmesser;Windmesser
-Meriten;Verdienste;Verdienst;Leistung;Errungenschaft
-Stimmen;Orchestermaterial;Klavierauszug;Notenheft;Partitur;Noten (ugs.)
-Schellenkranz;Schellenring;Schellenreif
-Patronenfüller;Füllfederhalter;Füllfeder;Füller
-Aufsatz;Schulaufsatz;Essay
-Laryngitis (fachspr.);Kehlkopfentzündung
-abtrocknen;trocknen
-von edlem Geblüt;von blauem Blute;von vornehmem Geschlecht;von Stand;aus hohem Hause;von vornehmer Abstammung;blaublütig;von Rang;von edlem Geschlecht;feudal;edel;nobel;hochwohlgeboren (auch ironisch);adlig;erlaucht;aristokratisch;adliger Abstammung;von Adel
-unverschämt;unverfroren;schamlos;impertinent;unterste Schublade (ugs., fig.);das Letzte (ugs.)
-Müll-Entsorgung;Abfallentsorgung;Entsorgung
-lithographisch;lithografisch
-hin und zurück;hin und her
-umschlagen;hochschlagen;aufkrempeln;hochkrempeln;umkrempeln
-tibetisch;tibetanisch
-Heizkörper;Radiator
-kontaktarm;scheu;selbstunsicher (psychol.);unsicher;kontaktscheu;schüchtern;zurückhaltend;gehemmt;verklemmt (ugs.);zaghaft
-Bande;Combo;Freundeskreis;Blase (abwertend);Clique
-Gelehrsamkeit;Belesenheit
-die kommenden Tage;Zukunft;die kommende Zeit;das Kommende;das Morgen (geh.);das Künftige;Tag X
-Vorzimmer;Vorkammer
-erstarren;fest werden
-Torsionsmoment;Drehmoment
-Spülmaschine;Spüler (ugs.);Geschirrspülmaschine;Abwaschmaschine (schweiz.);Geschirrspüler
-Bildungsweg;Bildungsgang
-Gebührendes;rechtmäßig Zustehendes
-Flankenanstiegszeit;Anstiegszeit
-Verspottung;Häme;Sarkasmus;sarkastische Bemerkung;ätzender Spott;beißender Spott;Hohn;bissige Bemerkung
-fehlgebären;eine Fehlgeburt haben
-verloren;preisgegeben
-undramatisch;unkompliziert;ohne viel Federlesens (ugs.)
-Elend;Leid;Misere (franz.);Not;Notlage
-Entgegennahme;Annahme;Übernahme
-Narkotikum;Betäubungsmittel;Anästhetikum (fachspr.);Narkosemittel
-interne Revision;Innenrevision;(betriebliches) Prüfungswesen;Controlling
-Park;Stadtpark;Stadtgarten;Parkanlage;Grünanlage
-erspähen;entdecken
-replizieren;klonen;duplizieren;vervielfältigen;kopieren;klonieren;verdoppeln;abziehen (österr.)
-am Werk;im Gange;dabei
-Gruppenraum;Arbeitsraum
-Imbiss;Frittenbude (ugs.);Kaffeeklappe (fachspr., hamburgisch, veraltend);Fressbude (derb);Imbissbude;Pommesbude (ugs.);Schnellgaststätte;Schnellimbissstube;Imbissstube;Dönerbude;Schnellimbiss;Fast-Food-Restaurant (fachspr.);Snackbar;Schnellimbissbude;Schnellrestaurant;Take-away (engl., schweiz.)
-Dresseur;Dompteur;Tierbändiger
-Intervention;Eingreifen;Einmischung;Eingriff
-Beschenkung;Einbescherung (landschaftlich, veraltend);Bescherung;Weihnachtsbescherung
-Modellversuch;Modellprojekt
-engstirnig;frömmlerisch;blindgläubig;frömmelnd;bigott
-Wandelhalle;Foyer;Lounge;Vorraum;Vestibül;Lobby;Empfangshalle;Eingangshalle;Vorhalle
-Abschied;Lebewohl;Ausscheiden (aus einer Beschäftigung);Auseinandergehen;Weggang;Trennung
-Horchstelle;Abhörstation
-logischer Fehler;Bedeutungsfehler
-Köter (ugs., abwertend);Fiffi (ugs.);Mistvieh (ugs., aggressiv);Canis lupus familiaris (fachspr., lat.);Vierbeiner;Kläffer (ugs.);bester Freund des Menschen (ugs.);Töle (derb);Hund;Wauwau (ugs., Babysprache);Fellnase (ugs.);Hundevieh (ugs.)
-Ausschabung der Gebärmutter;Kürettage (fachspr.)
-Zeichen;Kürzel
-Verwaltungskostenstelle;Verwaltungsstelle
-Einschränkung;Zwang;Deckelung (der Kosten);Beschränkung;Begrenzung;Restriktion;Einengung
-Banalität;Plattheit;Unwichtigkeit;Irrelevanz;Schnickschnack (ugs.);Nichtigkeit;Oberflächlichkeit;Vanität (geh., lat.);Bedeutungslosigkeit;Gehaltlosigkeit;Belanglosigkeit;Trivialität
-einkassieren;Kasse machen (ugs.);(Gewinn) einstecken;kassieren;(Geld) scheffeln (ugs.);einnehmen;einstreichen;einheimsen;abräumen (ugs.)
-quengeln (ugs.);dringend bitten;Druck ausüben;dringen (auf);die Daumenschrauben anziehen (ugs.);Dampf (dahinter) machen (ugs.);drängen (zu / auf);Druck machen (ugs.);urgieren (österr.);es dringend machen
-Revision;Betriebsprüfung;Rechnungsprüfung (Hauptform);Audit (Jargon, engl.);Prüfung der Bücher;Buchprüfung
-abrollen;abwickeln
-zum Vorschein bringen;zu erkennen geben;offenbaren;(sich) outen;offen zeigen
-schräg;abgeschrägt
-Brand;Wundbrand
-nicht weiterführen;(den) Betrieb einstellen;liquidieren;plattmachen (ugs.);schließen;stilllegen;vom Markt nehmen (Unternehmen);abwickeln;(jemandem den Laden) dichtmachen (ugs.);auflösen (Geschäft)
-Absenden;Abkommandierung;Deputation;Delegierung;Entsendung
-Füllung;Bestückung;Ladung
-luftdicht;hermetisch verschlossen
-Wetterbericht (ugs.);Hafentelegramm (fachspr., Jargon, seemännisch);Wetterprognose;Wettervorhersage;Wetteraussichten
-leistungsfördernd;Muskelaufbau beschleunigend;anabol
-Mächler (elsässisch, schweiz.);Erfinder;Tüftler (ugs.)
-Synkope (fachspr.);anfallsartige, kurz dauernde Bewusstlosigkeit;Kreislaufkollaps (ugs.);Kreislaufzusammenbruch (ugs.);Ohnmachtsanfall (ugs.)
-Reifung der Samenzellen;Spermatogenese (fachspr.);Prozess der Spermienbildung
-winklig;winkelförmig;winkelig
-kraftvoll;(körperlich) stark (Hauptform);bärenstark;machtvoll;kraftstrotzend;kräftig;Bärenkräfte haben (fig.);kämpferisch
-(jemanden) blass aussehen lassen;übertrumpfen;ausstechen;(jemandem) den Rang ablaufen;(jemanden) abhängen;(jemanden) (weit) hinter sich lassen;übertreffen;(jemanden) alt aussehen lassen (ugs.);überholen;schnupfen (ugs., bayr., österr.);(jemanden) (buchstäblich) stehen lassen;überrunden;vorbeiziehen (an);überflügeln
-Häcksler;Schredder
-Randalierer;Hooligan;Rowdy
-Abnahmeprotokoll;Abnahmebescheinigung
-gaffen;starren;glotzen (ugs.);Augen machen (ugs.);stieren
-Federweißer;Süßmost;Most;Traubenmost;Sauser (landschaftlich);Maische (für Wein)
-unter Einstandspreis verkaufen;mit Verlust verkaufen;unter dem üblichen Preis verkaufen;verschleudern;verramschen;unter Wert verkaufen;nichts daran verdienen (ugs., variabel)
-mithören;anhören;zuhören
-naschen;knabbern;etwas Süßes essen;schlecken;knuspern (ugs., regional);schnabulieren (ugs.)
-behilflich;unterstützend;dienlich;subsidiär;fördernd;förderlich;hilfreich;zuträglich
-News (Jargon, engl.);(aktuelle) Berichterstattung;Nachrichtensendung;(die) Meldungen;(die) Nachrichten (Hauptform)
-Decke (fachspr., Jägersprache);Pelz;Tierfell;(behaarte) Haut;Fell
-Pomp;Pracht;Luxus;Wohlstand;Aufwand
-Wegbereiter;Neuerer;Revolutionär;Bahnbrecher;Vordenker;Ideengeber
-Panzer;Harnisch;Rüstung;Schutzkleidung
-betriebsbereit;betriebsfähig;startbar
-Wesensmerkmal;Zug;Wesenszug;Charaktereigenschaft;Charakterzug;Einstellung;Charaktermerkmal;Merkmal;Haltung;Eigenschaft;Persönlichkeitsmerkmal
-Radialbohrmaschine;Raboma;Schwenkbohrmaschine
-urteilen (nach);richten
-Einfluss;Kraft;Stärke
-Korngröße;Teilchengröße
-indigen (fachspr.);seit langem ansässig;bodenständig;autochthon (fachspr.);hiesig (süddt.);ureingesessen;eingeboren;alteingesessen;endemisch;einheimisch
-um hohe Einsätze spielen;hoch spielen
-Speisekarte;Menü;Karte;Speisezettel;Speisenkarte
-Yoga;Joga (alte Schreibung bis 2017)
-Stecker;Buchse;Anschluss;Steckkontakt
-Beurkundung;Beglaubigung
-psychisch;psychologisch;seelisch
-ausführlich;ausgiebig;eingehend;enzyklopädisch;reichhaltig;extensiv
-auf Ex trinken (Hauptform);auf Ex leeren;in einem Zug hinunterkippen (ugs.);(leer)trinken ohne abzusetzen;exen (ugs.);(Glas) in einem Zug leeren;in einem Zug austrinken;runterkippen (ugs.)
-wieder eintreten;wieder betreten
-Rummelplatz;Jahrmarktsplatz;Festplatz
-Anzeiger;Stadtteil-Zeitung;Intelligenzblatt (fachspr., historisch);Anzeigenzeitung;regionale Wochenzeitung (österr.);Anzeigenblatt
-Einberufung;Einziehung
-Melanose (fachspr.);Dunkelfärbung der Haut
-Rakel;Abstreifer;Abstreifgummi
-Wandelgang;Kolonnade
-Erörterung (über);offene Aussprache
-auswerten;untersuchen;analysieren
-Einsetzkammer;Brennkammer
-Postscript;Nachschrift;Nachtrag
-fühlen;verspüren;wahrnehmen;spüren;empfinden
-Stich;Stoß
-anhören;vernehmen
-beängstigend;schauderhaft;erschreckend;Schrecken verbreitend;angsteinflößend;gruselig;Grauen erregend;schauerlich;grauenerregend;Schrecken erregend;schaurig;schreckenerregend;furchterregend;Furcht erregend;formidabel (geh., veraltet);Horror...;zum Fürchten;ängstigend;schrecklich;bedrohlich;furchteinflößend;angstbesetzt (fachspr., psychologisch);Angst einflößend;Furcht einflößend;schauervoll;entsetzlich;grausig;grauenvoll;albtraumhaft (ugs.)
-samtig;samtartig
-Exploration;Untersuchung;Erforschung;Erprobung
-Schrift;Schriftsystem;Skript
-UN (Abkürzung, engl.);Vereinte Nationen;Staatengemeinschaft (ugs.);UNO (Abkürzung, engl.)
-Dispersität;Kornfeinheit
-ausweiten;vergrößern;breiter machen;dehnen;aufweiten;spreizen;extendieren (veraltet);ausdehnen;weiten;expandieren (physikalisch, technisch);erweitern
-Scheinwerferlicht;Scheinwerfer (ugs.)
-Aufgeld;Aufpreis;Agio;Aufschlag;Ausgabeaufschlag
-ratzen (ugs.);dösen (ugs.);(sich) in Morpheus' Armen wiegen (geh.);an der Matratze horchen (ugs.);koksen (ugs.);schlummern;schnarchen (ugs.);pofen (ugs., salopp);Bubu machen (ugs., Babysprache);schlafen (Hauptform);knacken (ugs.);in Morpheus' Armen liegen (geh.);ruhen;pennen (ugs., salopp);in Morpheus' Armen ruhen (geh.)
-faltenfrei;glatt wie ein Babypopo;glatt;makellos glatt;faltenlos;glatt wie ein Kinderpopo
-zuordnungsfähig;bestimmbar
-aufzwängen;oktroyieren;aufoktroyieren;andrehen (ugs.);jemandem etwas aufdrängen
-in keinster Weise;kein bisschen;alles andere als;durchaus nicht;(daran ist) nicht zu denken;mitnichten;gar nicht;um kein Haar;ganz und gar unmöglich;nicht im Mindesten;in keiner Weise;unter keinen Umständen;wie auch immer nicht;hinten und vorne nicht (ugs.);partout nicht;i wo! (ugs., veraltend);auf keinem Wege;keineswegs;mitnichten und mit Neffen (ugs., scherzhaft);nicht im Geringsten;auf (gar) keinen Fall;überhaupt nicht;egal, wie man es betrachtet, nicht;völlig ausgeschlossen;absolut nicht;in keiner Beziehung;nicht (Hauptform);jetzt nicht und überhaupt niemals;nicht um ein Haar;ganz und gar nicht;bei weitem nicht;in keinerlei Hinsicht;keinesfalls;nicht im Entferntesten;nicht und niemals
-bevorstehend;künftig;kommend;dereinst (schweiz.);zukünftig;demnächst (Hauptform);in Zukunft;in nicht allzu ferner Zukunft;nächstens
-umtreiben;vereinnahmen;in Anspruch nehmen;nicht zur Ruhe kommen lassen;beschäftigen
-Schutzaufsicht;Posten;Aufsicht;Wachtposten;Beaufsichtigung;Wachposten;Überwachung;Wachestehen;Wache;Patrouille;Beschützung;Wachehalten;Wachdienst;Wacht;Bewachung;Sicherheitsdienst;Beschirmung;Security Service;Wachmannschaft
-genau (ugs.);jawohl (ugs.);ganz recht (ugs.)
-Eintrag;Eingabe;Input (fachspr.)
-Fischzug;Fang
-ehrenhalber;h.c. (Abkürzung);honoris causa
-aufteilen;demarkieren;eingrenzen;eine Trennungslinie ziehen;abteilen;abgrenzen
-Durchschnittsertrag;Durchschnittsrendite
-behäbig;geduldig;gelassen;ruhig
-Organisation amerikanischer Staaten;OAS (Abkürzung)
-große Stücke auf jemanden halten;viel von jemandem halten;eine hohe Meinung von jemandem haben
-Tractus (fachspr.);Bahn des Nervensystems;Nervenbahn
-CCC (Abkürzung);Chaos Computer Club
-Blindwiderstand;Reaktanz
-brütender Vogel;Glucke
-abdämmen;eindämmen
-brav;seelenruhig;friedlich;zahm;sanft;gutmütig (z.B. Pferd);mild
-Kontaktfeder;Federband
-oblong (lat., veraltet);länglich;langgezogen;abgeplattet;gestreckt;lang gezogen
-Katabolismus (fachspr., griechisch);(abbauender) Stoffwechsel;Abbaustoffwechsel
-Deka;Dekagramm
-Verbundkarte;Verbundfahrkarte
-Anleitung;Leitfaden;Handbuch;Richtschnur;Manual;Benutzerhandbuch
-Verspaar;Reimpaar
-Rückführung;Rückbildung;Rückgang;Rückschritt;Regression
-Bedachung;Dachdeckung
-Exhalation (fachspr.);Aushauchung;Ausatmung;Exspiration (fachspr.)
-Zimmervermittlung;Wohnungsvermittlung
-Galadiner;Bankett;Festmahlzeit;Festbankett;Gastmahl;Göttermahl (ugs.);Festmahl;Schmauserei;Festessen;Schmaus
-steif (ugs.);unpersönlich;formell;förmlich
-durchtränken;durchnässen;durchfeuchten
-Rammler;Hasenbock
-Fehlen (von);Ermangelung (von);Mangel (an);Abwesenheit (von)
-Vorkasse;Vorausbezahlung;Vorauszahlung;Vorauskasse
-das männliche Glied betreffend;phallisch
-in optima forma (geh., lat.);vortrefflich;untadelig;ohne den kleinsten Fehler;vorzüglich;mustergültig;tippi toppi (ugs.);vollkommen;fehlerfrei;in bestem Zustand (variabel);vorbildhaft;tadellos;vollendet;einwandfrei;makellos;tipptopp (ugs.);fehlerlos;ideal;vorbildlich;ohne Fehl und Tadel;perfekt;klaglos (österr.);einwandlos
-hexen;zaubern;beschwören
-Magenschmerzen;Bauchschmerzen;Leibschneiden (ugs.);Magendrücken;Magenweh;Leibschmerzen;Bauchgrimmen;Bauchweh (ugs.);Magengrimmen
-via;über
-Duftwolke;Duft
-Programm;Manifest;Grundsatzerklärung
-gewidmet;gesondert;dediziert;extra (ugs.);speziell
-abgehärmt;voller Gram;vom Leben gezeichnet;verhärmt;gramerfüllt;gramgebeugt;schmerzerfüllt;von Kummer gezeichnet (Hauptform)
-Kapitalstrom;Kapitalfluss
-Apenninhalbinsel;Apenninenhalbinsel
-missfallend;unliebenswürdig;wenig einladend;unsympathisch
-hinaufklettern;hinaufsteigen;emporklettern;hinaufkraxeln
-Schiff;Kutter;Boot;Schaluppe (ugs.);Kahn (ugs., abwertend);Pott (ugs.)
-Verfluchung;Fluchen;Fluch;Vermaledeiung;Verwünschung
-Zerstreuung;Abwechslung;Zeitvertreib (Hauptform);Ablenkung;Abwechselung;Beschäftigung;Divertissement (geh., franz.)
-vorrangig;erst einmal;primär (geh.);zu allererst;vor allem;in erster Linie;an erster Stelle (stehen / rangieren);zuerst (einmal);zuvörderst (geh., sehr selten);vor allem anderen;erstmal (ugs.);zunächst (einmal)
-Lossagung;Abfall vom Glauben;Apostasie (fachspr.);Glaubensabfall;Renegatentum (abwertend, bildungssprachlich)
-Pressespiegel;Presseschau
-überhaupt;in großem Rundumschlag;in Bausch und Bogen;verallgemeinernd;allumfassend;global;holzschnittartig;in jeder Hinsicht;allgemein;en bloc;pauschal;generalisierend;undifferenziert;vereinfachend;alles einschließend;schlechthin;in einem großen Rundumschlag
-angaffen;Bauklötze staunen (ugs., Verstärkung);große Augen machen (ugs.);aus dem Staunen nicht mehr herauskommen;wer beschreibt mein Erstaunen (als) (geh., floskelhaft, literarisch, variabel, veraltend);(sehr) erstaunt sein;(den) Mund nicht mehr zubekommen (ugs.);seinen Augen nicht trauen (wollen);(jemanden) anstarren wie ein Wesen vom anderen Stern (ugs., variabel);(jemanden) anstarren wie einen Marsmenschen (ugs.);mit offenem Mund dastehen;verwundert anstarren;Glotzaugen machen (ugs.);(erst einmal) nichts zu sagen wissen;kaum glauben wollen (was man zu hören bekommt);staunen;seinen Ohren nicht trauen (wollen);(sich) wundern;Kulleraugen machen (ugs.);kaum glauben wollen (was man sieht);nicht schlecht staunen (Verstärkung);bestaunen;gucken wie ein Auto (ugs., veraltend);bewundern;doof gucken (ugs.)
-Sättigungsgrenze;Sättigungspunkt
-Regentschaft;Herrschaft
-ausbrechen;zum Ausbruch kommen
-imposant;extrem;krass (ugs.);gewaltig;groß;immens;himmelweit (eingeschränkter Gebrauch);mächtig;riesig;enorm;exorbitant
-wirtschaftlich;sparsam;haushälterisch;ökonomisch
-Theaterensemble;Theatergruppe
-menügeführt;menügesteuert
-Aufführung;Inszenierung;Abhaltung
-Verarbeitung;Weiterverarbeitung;Prozess
-unentschlossen;lau (geh., fig.);unsicher;halbherzig;zaudernd;verhalten;zögernd;schüchtern (geh., fig.);zögerlich;zaghaft (Hauptform)
-Disposition (fachspr.);Anlage (für);Empfänglichkeit;Prädisposition (fachspr.)
-Verflechtung;Verwebung
-mit Salz würzen;salzen
-psychogen;in der Psyche begründet
-Physiognomie (fachspr.);Gesicht;Antlitz
-konstatieren;festsetzen;festlegen;feststellen
-Geländekunde;Topographie;Topografie;Lagebeschreibung;Ortsbeschreibung
-tätig sein;praktizieren (Arzt);(einer) Tätigkeit nachgehen;sich betätigen (als);(einen) Beruf ausüben
-einleuchtend;unmittelbar verständlich;unmittelbar einleuchtend;auf der Hand liegend;direkt erkennbar;trivial;keiner weiteren Erklärung bedürfen(d);selbst erklärend;selbsterklärend;selbstdokumentierend (Programmiertechnik) (fachspr., Jargon)
-Lochstelle;Lochung
-Bestandteil;Teil;Konstituens;Element;Punkt;Glied;Stück;Komponente;Baustein;Modul
-verwickeln;involvieren;hineinziehen
-in Bezug auf;bezugnehmend;diesbezüglich;mit Bezug auf;bezüglich
-stetig;stet
-Briefzusteller;Mann mit der Post (ugs., männl.);Postillon (geh., scherzhaft);Frau mit der Post (ugs., weibl.);Zusteller;Pöstler (schweiz.);Briefträger;Postler (bayr., österr.);Postbote;Postzusteller;Postmann
-Schössling;Spross
-Nachgiebigkeit;Weichheit;Sanftheit;Milde;Mildheit
-Stimmbezirk;Wahlbezirk;Wahlsprengel (österr.)
-Gnadengeschenk;Gnadenbrot;Scherflein (ugs.);Spende;milde Gabe;Zuwendung;Obolus;Opfer (Religion);Almosen;Gabe;Armengeld
-Aroma;aromatischer Geschmacksstoff;Würze;Würzessenz
-deuten;übersetzen;transkribieren
-(jemanden) bedrohen (mit);(jemandem etwas) androhen
-Usurpation;Besitznahme;widerrechtliche Aneignung;Inbesitznahme;rechtswidrige Besitzergreifung;unberechtigter Eingriff;widerrechtliche Besitzergreifung
-Emendation;Berichtigung;Verbesserung
-unterweisen;in Kenntnis setzen;orientieren (schweiz.);verständigen;briefen;Auskunft geben;aufklären;instruieren (fachspr.);belehren
-Recht;Placet (geh., bildungssprachlich);Bevollmächtigung;Erlaubnis (Hauptform);Autorisierung (geh.);Berechtigung;Ermächtigung;Plazet (geh., bildungssprachlich);Segen (fig.);Okay (ugs.);Befugnis;Zulassung;Konzession (fachspr.);Genehmigung;Absegnung (ugs.);Einwilligung;Lizenz;Autorisation (geh.);Billigung
-schlecht abschneiden;keine gute Punktzahl erreichen
-Vanillinzucker;Vanillezucker
-fortbestehen;fortdauern;aufrechterhalten werden;anhalten;nicht nachlassen;(so) gehen (ugs.);ungebrochen sein;nicht aufhören;andauern;währen;fortwähren (geh.);weitergehen (ugs.);fortgesetzt werden;dauern;von Dauer sein
-eidbrüchig;meineidig
-zurechtgebastelt;getakelt
-bruchlanden (fig.);eine Bruchlandung hinlegen (ugs., fig.);einen Misserfolg erleiden;scheitern;in die Grütze gehen (ugs., fig.);eine Bruchlandung machen (ugs., fig.)
-Gerte;Zweig;Rute
-Starkstromleitung;Hochspannungsleitung
-Zellproliferation;Weiterverbreitung;Proliferation;Wucherung;Wildwuchs
-plätten (ugs.);zerfetzen (ugs.);den Rest geben (ugs.);schlagen;kleinkriegen (ugs., fig.);fertigmachen (ugs.);(jemandem) (eine) Niederlage beibringen;übertreffen;allemachen (ugs.);niederzwingen;niederringen;wegpusten (ugs.);(jemanden) an die Wand klatschen (ugs., fig.);die Luft abdrehen (fig.);bezwingen;(jemandem) (eine) Niederlage zufügen (geh.);besiegen
-Zwiebel;Blumenzwiebel
-Großgrundbesitz;(großes) Landgut;Latifundium (griechisch);Länderei(en);ausgedehntes Anwesen
-Ödem (fachspr., griechisch);Wasseransammlung in Gefäßen;Schwellung;Wassersucht (ugs.)
-Kopiergerät;Fotokopierer;Kopierer;Photokopierer;Fotokopiergerät;Kopierapparat
-Anlage (im Brief);Addendum (geh., veraltet);Beilage
-Modezeitschrift;Modemagazin
-Garant;Gewährsmann;Gewährsperson;Sicherheitsgeber;Bürge
-Starrsucht;Katalepsie (fachspr.)
-Umlauf (ugs.);Paronychie (fachspr.);Nagelhautentzündung;Entzündung des Nagelbetts
-Missbildungen erzeugend;teratogen (fachspr.)
-rumbandusen (ugs., regional);toben;(seine) dollen (o.ä.) fünf Minuten haben (ugs.);ausgelassen (sein);aufdrehen;aufgedreht (sein) (ugs.);herumtollen;herumtoben;tollen
-Ton...;Hör...
-Entzündung des Nasenrachens;Rhinopharyngitis (fachspr.)
-zwischen zwei Wirbeln;intervertebral (fachspr.)
-(die) Schnauze voll haben (ugs., fig.);(die) Nase gestrichen voll haben (ugs., fig.);(einer Sache) überdrüssig sein (geh.);etwas dicke haben (ugs.);(etwas) nicht mehr hören können (ugs., fig.);(etwas) satt haben (ugs.);(von etwas) genug haben (ugs.);(die) Faxen dicke haben (ugs.);(jemandem) bis Oberkante Unterlippe stehen (ugs.);(jemandes) Bedarf ist gedeckt (geh., Understatement);(den) Kaffee auf haben (ugs., fig.);(jemandem) reichen (ugs.);(jemandem) bis hier stehen (+ Geste);(jemandem) langen (ugs., regional);(jemandem) zu blöd werden (derb);(es) ist gut (ugs.);(die) Nase voll haben (von) (ugs., fig.);(jemandem) bis da stehen (+ Geste) (ugs.);(die) Schnauze gestrichen voll haben (ugs., fig.);(einer Sache) müde (sein) (geh.);(jemandem) zu dumm werden (ugs.);zum Hals(e) raushängen (ugs., fig.);(den) Kanal voll haben (ugs., fig.);mit seiner Geduld am Ende sein;(jemandem) zu dumm sein (ugs.);(etwas) überbekommen (ugs.);(etwas) leid sein (Hauptform);zum Hals(e) heraushängen (ugs., fig.)
-dreiwertig;trivalent
-tubulär;schlauchförmig;röhrenförmig
-Sprechstunde(n) (Arzt);Geschäftsstunden;Geschäftszeiten;Öffnungszeit
-Lynchjustiz;Selbstjustiz;Volksjustiz
-Ausspülung;Elution (fachspr.)
-Faustkampf;die Handschuhe schnüren (ugs.);Boxen;Boxkampf;Pugilismus (historisch, lat.)
-Lemma (Lexikographie) (fachspr.);Stichwort
-Geschiebe;Geröll
-(jemanden) im Unklaren lassen;Zeit gewinnen wollen;abspeisen (ugs.);hinhalten;vertrösten;Katz und Maus spielen (mit jemandem) (ugs.);ausweichende Antworten geben;schmoren lassen (ugs., fig.);trösten (mit);(jemanden auf etwas) warten lassen;zappeln lassen (ugs., fig.);ausweichen;(sich jemanden) warm halten (ugs., fig.)
-was mich betrifft;um meinetwillen;soweit es mich angeht;meinerseits;ich für meinen Teil;von mir aus (ugs.);was mich anbetrifft;(ich) für meine Person;wenn du mich fragst (Floskel) (ugs.);für mich;was mich angeht (Hauptform);soweit es mich betrifft;(ich,) der ich (...) (geh.);meinereiner (ugs.);ich persönlich;ich meinerseits;von meiner Seite
-Bagel;kleines, rundes Brötchen
-Euphorie;Hochgefühl (Hauptform);Hochstimmung;emotionaler Höhenflug (ugs., fig.);Jubelstimmung;Festtagslaune (fig.)
-vertiefen;verstärken;untermauern;ankurbeln;stärken;stützen;intensivieren
-am Ende ohne etwas dastehen (ugs.);alles verlieren;sein letztes Hemd verlieren (ugs.)
-Kern;Zentrum;(das) Wesentliche;Mittelpunkt;(das) Entscheidende;Hauptaugenmerk;Schwerpunkt;Fokus
-Akzise;Verbrauchsabgabe;Oktroi
-Tumultant;Aufrührer
-bedürfnislos;genügsam
-kundtun;bekunden;zeigen;offenbaren
-TH;Technische Universität;TU;Technische Hochschule
-Versicherung;Zusage;Zusicherung;Garantie (ugs.);Beteuerung;Absichtserklärung (fachspr., mediensprachlich);Versprechen;Assertion (geh., lat.)
-Beschaulichkeit;Stille
-AA;Ministerium für Auswärtige Angelegenheiten;Auswärtiges Amt;Außenamt (ugs.);Außenministerium (ugs.)
-glänzend machen (Baumwolle);veredeln;merzerisieren;Glanz geben
-humid;nass;feucht
-Aktiengesellschaft;AG (Abkürzung)
-Zenotaph (geh., griechisch);Ehrengrabmal;Ehrenmal;Scheingrab;Kenotaph (geh., griechisch)
-abgeschlossen;abgesperrt;dicht (ugs.);verschlossen;zu;verriegelt;versperrt
-freilich;schon;wohl;zwar (... aber)
-Liberier;Liberianer
-Flugreise;Luftbeförderung;Luftreise;Flugpassage;Flug
-Schiedsgerichtshof;Schiedsgericht
-Erstes Testament;AT;Altes Testament
-Lötbrenner;Schneidbrenner
-Tsunami (nach Seebeben) (japanisch);Flut
-Fachgruppe;Arbeitsgruppe;Arbeitsgemeinschaft;Arbeitskreis;Projektgruppe
-zucken (Flamme);auflodern;emporflammen;züngeln (Flamme);aufflammen;in Flammen aufgehen;hochschlagen (Flammen);hochflammen;in hellen Flammen stehen;lodern;in Flammen stehen;verbrennen;brennen;lohen;flackern;wüten (Brand, Feuer ...) (fig.)
-Gesetzentwurf;Gesetzgebungsvorschlag (fachspr.);Vorlage;Gesetzesvorschlag;Gesetzesvorlage;Gesetzesentwurf
-Gotteslästerung;Blasphemie
-Leber und Galle betreffend;hepatobiliär (fachspr.)
-Felsenriff;Felsbank (unter Wasser)
-Leistungsnachweis;Test;Prüfung
-verantwortungsvoll;zuverlässig;verantwortungsbewusst;gewissenhaft;pflichtbewusst;(seine) Pflichten (sehr) ernst nehmen
-(sich) getrauen (veraltet);die Stirn haben (zu) (geh., veraltend);(etwas) bringen (ugs.);(sich) zutrauen;es wagen;(so) mutig sein (zu);(sich etwas) trauen;(den) Arsch in der Hose haben (zu) (ugs.);(den) Mut haben (zu)
-Verlängerung;Spielverlängerung
-Lachkrampf;Lachflash;Lachkick;Lachanfall
-fest ziehen;verschnüren
-Zuteiler;Verteilerliste (Büro);Verteiler
-stinkig (ugs.);empört;erzürnt (geh.);böse (Kindersprache);wütend;in Brast (ugs., regional);in Rage;sickig (ugs.);pissig (derb);erbost;fuchtig (ugs.);eingeschnappt (ugs.);aufgebracht;geladen (ugs.);(einen) Hass haben auf;zornig;einen Hals haben (ugs.)
-Streubüchse;Streuer
-Zusammenfassung;Inhaltsangabe
-Moneten (ugs.);Knack (ugs.);Steine (ugs.);Heu (ugs.);Öcken (ugs.);Räppli (ugs., schweiz.);Zaster (ugs.);Chlübis (ugs., schweiz.);Kröten (ugs.);Rubel (ugs.);Piepen (ugs.);Scheinchen (ugs.);Mammon (geh., abwertend, biblisch);Penunze (ugs.);klingende Münze (fig.);Devisen (ugs.);Eier (ugs.);Asche (ugs.);Koks (ugs.);Krönchen (ugs.);Schlotten (ugs.);Moos (ugs.);Forinthen (ugs.);Klöpse (ugs.);Radatten (ugs.);Rubelchen (ugs.);Lehm (ugs.);Knete (ugs.);Kies (ugs.);Marie (ugs.);Patte (ugs.);Penunse (ugs.);Scheine (ugs.);Euronen (ugs.);Diridari (ugs., bairisch);Ocken (ugs.);Pulver (ugs.);Murmeln (ugs.);Geld;Mäuse (ugs.);Klicker (ugs.);Kohle (ugs.);Schotter (ugs.);Flöhe (ugs.);Pinke (ugs.);Möpse (ugs.);Bimbes (ugs.)
-abwursten (derb);groß machen (ugs., verhüllend);abkoten (fachspr.);stuhlen;den Darm entleeren;versäubern (Hund, Katze) (geh.);(sich) lösen (Hund, Katze) (geh.);(sich) erleichtern (geh.);Aa machen (ugs., Babysprache);(ein) (großes) Geschäft machen (ugs., verhüllend);wursten (derb);Kot ausscheiden;Häufchen machen (ugs.);kacken (derb);defäkieren (geh.);einen abseilen (derb);(seine) Notdurft verrichten;koten;Kaka machen (ugs., Babysprache);scheißen (derb);(sich) entleeren (geh.);(ein) Ei legen (ugs., fig.);abstuhlen (fachspr.)
-durchfließen;durchziehen
-Montagewerkstatt;Montagehalle
-Gin;Wacholderbranntwein;Wacholderschnaps
-Nachprüfung;Nachzipf (ugs., österr.);Wiederholungsprüfung
-in der Umgebung des Afters;perianal (fachspr.)
-Schot;Tampen;Bändsel;Segelleine
-Irin;Irländerin
-N. N.;nomen nescio;nomen nominandum;noch nicht festgelegt
-Metanoia;Änderung der Weltsicht
-Volk;Bürger;Bewohner;Bevölkerung;Einwohner
-Veröffentlichen;Kundgabe;Publizieren;Publikation (fachspr.);Veröffentlichung;Bekanntgabe
-Herrschaft;Führerschaft;Regierung
-(der) Alte (ugs., salopp);hohes Tier (ugs.);Dienstherr (fachspr.);Obermufti (ugs., fig., salopp);Obermotz (ugs., salopp);Chef von't Janze (ugs., berlinerisch, salopp);Geschäftsherr (fachspr., juristisch);Dienstvorgesetzter (fachspr.);Vorgesetzter;(jemandes) Herr und Meister (ugs., scherzhaft);Oberindianer (ugs., fig., salopp);Chefität (ugs., österr.);Leiter;Obermacker (ugs., salopp);Boss (ugs.);Chef;Prinzipal (geh., veraltet);Oberjuhee (ugs., salopp, schweiz.)
-Nachbilder;Nachahmer;Emulator
-Lieferwagen;Lieferauto
-(sich) schnell nähern;(sich) stürzen auf
-(fleißiger) Leser;Power-Leser;Bücherwurm (ugs.);Leseratte (ugs.);Vielleser;Aktenfresser (ugs., Jargon, fig.);Büchernarr (ugs.)
-schmutziger Witz (ugs.);schlüpfriger Witz (variabel);verfänglicher Witz;Zote (Hauptform);versauter Witz (derb)
-Einlasser;Türsteher;Portier;Concierge (geh.);Türhüter (veraltet);Pförtner
-existent;vorhanden;gegeben;(dort) vertreten;seiend (geh., philosophisch);existierend;bestehend (Hauptform);dort (nachgestellt);(dort) angesiedelt (Unternehmen, Institution)
-ein Schnäppchen machen;günstig einkaufen
-(zufällig) begegnen;auffinden;antreffen;finden;vorfinden;entdecken
-Order;Befehl;Diktat;Zwang;Anweisung;Weisung (fachspr.)
-Applikation;Programmsystem;Anwendersoftware;Anwendungssoftware;Anwendungsprogramm
-(sich) zurechtfinden;(sich) orientieren
-Wildnis;Dschungel;Urwald;Busch
-tippen;spielen;wetten (auf);setzen (auf);zocken (ugs.)
-Negativliste;Blacklist (engl.);Schwarzliste;Index;Schwarze Liste;Verbotsliste
-Hausrind;Rind;Bos taurus (fachspr., griechisch, lat.);Bovinae (fachspr.);Rindvieh
-mangeln;(einer Sache) ermangeln (geh.);kranken an;fehlen;ausbleiben;(es gibt) nicht genug;happern (ugs., bayr., schweiz., österr.);mankieren (ugs., veraltet);(es gibt) zu wenig(e);(es) fehlt an;(es) hapert an;(es herrscht) ...mangel
-verderblich;vergänglich
-sportlich (ugs.);hochgesteckt (Erwartung, Ambition, Ziel);hehr (Ziel, Ideal);anspruchsvoll;ehrgeizig;ambitiös (geh.);hoch hinaus wollen;ambitioniert;hochfliegend (Plan, Erwartung)
-Fischschuppenkrankheit;Ichthyosis (fachspr.)
-Anfall;Schub;Insult (fachspr.)
-Zweideutigkeit;Schlüpfrigkeit;Anstößigkeit;Anzüglichkeit;Frivolität;Pikanterie;sexuelle Anspielung;Schamlosigkeit;Obszönität
-Notlandung im Wasser;Notwasserung
-Schnappriegel;Schaltklinke;Sperrklinke;Schnappschloss
-Zeugniszensur;Note;Zensur;Beurteilung;Schulnote (Hauptform)
-Abbruch;Demolierung;Abriss;Zerstörung
-Notifizierung;Mitteilung;Benachrichtigung
-Wiener;Wiener Würstchen;warme Würstchen;heißes Würstchen;warmes Würstchen;Frankfurter Würstchen;Frankfurter
-ophthalmisch;zum Auge gehörend;das Auge betreffend (fachspr.)
-Weidwerk;Jagen;Jägerei;Jagd;Waidwerk;Jagdwesen
-Schlagader;Arterie (fachspr.);Pulsader
-ein Schisma betreibend;schismatisch
-zwei (oder) drei (ugs.);wenige (Hauptform);einige wenige;ganz wenige (ugs.);ein paar verlorene;einzelne (Hauptform);ein paar versprengte;eine Handvoll (fig.);sehr wenige;der eine oder andere
-bejahend;im guten Sinne;positiv;bestätigend;affirmativ;zustimmend
-compilieren;kompilieren;(Programm) übersetzen
-(Medizin) verordnen;Rezept ausstellen;verschreiben
-gleichberechtigt (Hauptform);auf Augenhöhe (Jargon, floskelhaft);(jemandem) rechtlich gleichgestellt;paritätisch;ebenbürtig;gleichrangig;gleich an Rechten (geh.);gleichgestellt;vollwertig
-gedanklich verknüpft;inhaltlich verbunden;assoziativ
-Tun und Lassen (ugs.);Betragen;Handeln;Verhaltensweise;Gebaren;Benehmen;Tun;Auftreten;Verhalten;Habitus;Handlungsweise
-(ein) Risiko tragen;(dafür) aufkommen;übernehmen;auf sich nehmen;(die) Verantwortung übernehmen (für)
-Verdichter;Presse
-Aluminiumfolie;Silberpapier (ugs.);Stanniol (ugs.);Alufolie
-selbst;sogar (Hauptform);auch
-abschmecken;nachwürzen
-denn;als;wie
-Ritz;Riss;Ritze
-schrullenhaft;launenhaft
-Ausritt;Ritt
-Entstehung (Anspruch);Anfall (Dividende, Erbschaft)
-EWS;Europäisches Währungssystem
-ausstoßen;am laufenden Band produzieren (ugs.)
-Werktag;Arbeitstag
-Präzipitation;Ausfällung eines Niederschlags;Fällung;Ausflockung
-Tonnengewölbe;Schildbogen
-erlesen (geh.);vom Feinsten (ugs.);klein aber fein (ugs.);nicht für jeden;(das) Beste vom Besten;auserlesen;exklusiv;etwas Besonderes (ugs.);exquisit;handverlesen (fig.);nicht für die breite Masse (bestimmt)
-befehligen;kommandieren;befehlen (über) (veraltend);(die) Befehlsgewalt haben (über) (Hauptform);das Kommando haben (über);den Befehl haben (über);kommandierender ... sein
-Optimierung;Steuerung;Angleichung (z.B. von Wellen);Aussteuerung
-empfehlen;näherbringen;(sich für etwas) aussprechen;nahelegen;vorschlagen;anregen;antragen;nahebringen;andeuten
-Jahrestag;Erinnerungstag;Gedenktag
-erretten (aus, von);erlösen (von)
-Anzeigenraum;Werbefläche;Reklamefläche
-Spaltpilz (veraltet);Bakterie (veraltet);Bakterium (griechisch, Hauptform, lat.)
-verblieben;äußerster;letzter;übrig geblieben;endgültig
-Nachwirkung;Nachwehen;Nachleben
-Delikatessen;Feinkost
-erfassen;(sich einer Sache) bewusst werden;peilen (ugs.);aufnehmen;überreißen (ugs.);durchsehen (ugs.);checken (ugs.);verstehen (Hauptform);kapieren (ugs.);(sich jemandem) erschließen (geh.);klar sehen;wie Schuppen von den Augen fallen (sprichwörtlich);Klick machen (ugs.);(jemandem) geht ein Licht auf;verarbeiten;raffen (ugs.);durchsteigen (ugs.);durchblicken (ugs.);(bei jemandem) fällt der Groschen (ugs., fig.);(jemandem) eingehen (geh.);spannen (ugs.);rallen (ugs., regional);begreifen;(etwas) blicken (ugs.);schnallen (ugs.);dahintersteigen (ugs.);fassen;durchschauen (ugs.);hinter etwas steigen (ugs.)
-Kilometerstein;Meilenstein;Hektometerstein
-Radarsichtgerät;Radarbildschirm
-ausgedehnt;weit;weitläufig;groß
-tiefgekühlt;eingefroren
-Heideland;Heide;Haide (fachspr., veraltet)
-verfügbar;erhältlich;zugänglich;abrufbar
-Inzision;Einschnitt;Spalte;Kerbe;Spalt;Scharte
-Mikroprozessor;Prozessor;Microprozessor
-Wurzel (fig.);Quelle (fig.);Quell (geh., fig., literarisch);Ursprung
-Anzahl;Zahl
-Vortrag;Vorlesung
-Mappe;Ordner
-Lebensbereich;Milieu (Hauptform);Ambiente (geh.);Lebenswelt;Szene;(bestimmte) Kreise;(soziales) Umfeld
-nicht kompetent;unbefugt;nicht berechtigt;nicht autorisiert;unzuständig;nicht zuständig;ohne Erlaubnis;nicht befugt;nicht bevollmächtigt;unerlaubt;nicht verantwortlich;ohne Befugnis
-lokale Variable;Bereichsvariable
-Protein;Eiweiß (ugs.);Polypeptid (fachspr.);Eiweißstoff (veraltet)
-in Flocken fallen;flockig machen
-Beschleuniger;Kat (ugs.);Katalysator;Beförderer
-human immunodeficiency virus (engl.);AIDS-Erreger;HI-Virus;HIV-Virus (ugs.);HIV (Abkürzung);Virus der Immunschwächekrankheit
-bäuerlich;landwirtschaftlich;agrarisch;ackerbautreibend
-Abschabung;Abrasion (fachspr.);Ausschabung
-müde;übermüdet;unter Schlafmangel leiden;(sich) kaum noch auf den Beinen halten (können);sterbensmüde;übernächtigt;ein fades Aug haben (ugs., wienerisch);schläfrig;verpennt (ugs.);reif fürs Bett;todmüde;(sich) Streichhölzer zwischen die Augen(lider) klemmen (ugs.);schlafbedürftig;verschlafen;(jemandem) fallen die Augen zu;dösig (ugs.);vor Müdigkeit umfallen;hundemüde;schlaftrunken;(jemand) kann kaum die Augen aufhalten
-Titelzeile;Headline (engl.);Balkenüberschrift;Schlagzeile
-Holzscheit;Holzkloben;Holzklotz
-sein Land verlassen;ins Exil gehen;(aus seiner Heimat) vertrieben werden;ins Ausland gehen;abwandern;aussiedeln (eher im Amtsdeutsch);Asyl suchen;auswandern;emigrieren;in die Diaspora gehen
-(und zwar) ein bisschen plötzlich! (ugs.);(mach) schnell! (ugs.);(na) wird's bald? (ugs.);Pass auf, dass du nicht einschläfst! (ugs., variabel, übertreibend);Komm in die Gänge! (ugs.);Schick di! (ugs., alemannisch);Jetzt aber dalli! (ugs., variabel);Mach schon! (ugs.);Lass gehen! (ugs.);Leg mal 'nen Zahn zu! (ugs.);Lass was passieren! (ugs.);Drück auf die Tube! (ugs., veraltet);Beeil dich! (Hauptform);Nichts wie ran! (ugs.);Kutscher, fahr er zu! (pseudo-altertümelnd) (ugs., ironisch);Dann mal ran! (ugs.);Wir haben nicht den ganzen Tag Zeit! (ugs., Spruch);Nicht einschlafen! (ugs.);Aber zackig jetzt! (ugs.);Jib Jas Justav, 's jeht uffs Janze! (ugs., Spruch, berlinerisch);Beweg deinen Arsch! (derb);(na los) Bewegung! (ugs.);Mach hinne! (ugs., regional);hopp hopp! (ugs.);Pass auf, dass du nicht Wurzeln schlägst. (ugs., übertreibend);Gib Gummi! (ugs., salopp);Heute noch? (ugs., ironisch);Leg ma ne Schüppe Kohlen drauf! (ugs., Spruch, ruhrdt., veraltet);Was stehst du hier noch rum!? (ugs.);Brauchst du (erst noch) ne Zeichnung? (ugs.);Mach hin! (ugs.);Noch einen Schritt langsamer, und du gehst rückwärts. (ugs., Spruch, ironisch);Geht das (eventuell) auch ein bisschen schneller? (ugs., variabel);(ein) bisschen dalli! (ugs.);worauf wartest du? (ugs.);Wird das heut(e) noch was? (ugs., ironisch);Wie wär's mit ein bisschen Beeilung? (ugs.);Gib ihm! (ugs.);Beeilung! (ugs.);avanti! (ugs.);Lass jucken, Kumpel! (ugs., veraltet);zack zack! (ugs.);Mach zu! (ugs., norddeutsch);Schlaf nicht ein! (ugs., variabel);Mach fix! (ugs.);Lass schnacken! (ugs.);Hau rein! (ugs., salopp);Brauchst du 'ne (schriftliche) Einladung? (ugs., variabel);los (los)! (ugs.);Mach voran! (Betonung auf 1. Silbe, norddt.) (ugs.)
-Gewohnheit;Alltagstrott;Joch;täglicher Trott;Mühle (ugs.);Regelmäßigkeit;Trott;Routine (franz.);Alltag
-Erklärung;Erläuterung;Hinweistext
-den Harn betreffend;urinal (fachspr.)
-Schliff;Finish (fachspr.)
-aufteilen;klassifizieren;einordnen;einteilen;kategorisieren;rubrizieren
-unwegsam;unbefahrbar;weglos;ohne Wege und Stege (literarisch, veraltet);kaum begehbar;unpassierbar;nicht begehbar;kaum befahrbar
-wahrnehmbar;ins Auge fallend;nicht zu übersehen;flagrant (geh., bildungssprachlich);deutlich erkennbar;offenkundig;deutlich sichtbar;ersichtlich (geh.);unübersehbar;dick und fett (anschreiben / ankreuzen) (ugs.);hervorstechend;apparent (fachspr., lat., medizinisch);offensichtlich;deutlich;auffallend;intensiv;augenfällig;ausgeprägt;auffällig;klar und deutlich (ugs.);ins Auge stechend;eklatant (geh.);stark;markant
-Verbarrikadierung;Sperre;Barriere;Absperrung (Hauptform);Blockade;Abriegelung
-(sich) ändern;(sich) drehen (Stimmung);wechseln;mutieren;(sich) wandeln;(sich) verwandeln;(sich) verändern
-terminieren;Termin festlegen;Termin anberaumen
-Sinekure;Pfründe
-Spielraum;Korridor (geh., fig.);Bandbreite;Skala;Spanne;Spannbreite
-trinär;aus drei Grundeinheiten bestehend;dreifach;ternär
-mosambikanisch;mosambikisch
-Hotelbesitzer;Hotelier
-Kausalität;Ursache-Wirkung-Prinzip;Kausalordnung (fachspr.);Kausalzusammenhang;Ursächlichkeit
-Szene;Bühne;Podium
-wenn man es (einmal) so betrachtet;so gesehen;von daher (ugs.);insoweit (... als);insofern (... als)
-Vigilanz;Wachheit;Vigilität
-biologisch;ökologisch
-Tonraum;Umfang (der Stimme)
-Erfahrungswert;praktische Erfahrung
-Laibung;Leibung;Unterseite einer Decke;Unterseite eines Gewölbes
-einrichten;eichen;fluchten;justieren;ausrichten;konfigurieren;kalibrieren;einstellen
-Mairübchen;Mairübe;Navette;Nevette
-sabrieren (fachspr., franz.);entkorken (Weinflasche);anbrechen;aufmachen (ugs.);öffnen;anfangen;köpfen (Flasche) (ugs., fig.)
-Unterlassung;Versäumnis;Versäumung;Nichteinhaltung
-Regenerierung;Wiederherstellung;Erneuerung;Neuerstellung;Recovery (bildungssprachlich, engl.);Remanufacturing (bildungssprachlich, engl);Überholung;Aufarbeitung
-Unterstützung;strategische Partnerschaft (fachspr., Jargon);Zusammenarbeit;Zusammenwirken;Mitarbeit;Kooperation;Zusammenspiel;Mithilfe
-haarige Litschi;Rambutan
-ohne Absicht;versehentlich (Hauptform);aus Versehen;unabsichtlich;ungewollt;(etwas ist ein) Versehen;ohne es zu wollen;unbeabsichtigt;ohne böse Absicht
-Umgehung;Meiden;Vermeiden;Vermeidung
-Richtstrahl;Leitstrahl;Strahl;Peilstrahl
-Handhabbarkeit;Benutzbarkeit;Nutzerfreundlichkeit;Gebrauchstauglichkeit;Bedienerfreundlichkeit;Nutzbarkeit;Anwenderfreundlichkeit;Benutzerfreundlichkeit;Usability (fachspr.)
-Übersiedelung;Übersiedlung
-Schottischer Terrier;Scotchterrier
-Sortimentsbuchhändler;Sortimenter
-Rollbrett;Rollerbrett;Skateboard
-Schönheitspflege;Kosmetik
-Kunstfertigkeit;Handwerkskunst
-gewaltsam;gewalttätig;brutal;gewaltbereit (Jargon)
-unengagiert;indifferent (geh.);lustlos;gleichgültig;kommste heut nicht, kommste morgen (ugs.);ohne Elan;desinteressiert;uninteressiert;achselzuckend (fig.);schulterzuckend
-rötlich;rosig
-fast nichts;so gut wie nichts
-unbegrenzt;unlimitiert;unbeschränkt;bedingungslos;uneingeschränkt;ohne Limit
-phänomenal;bombastisch (ugs.);stark (ugs.);krass (ugs.);großartig;ultrakrass (ugs.);cool (ugs., engl.);fantastisch;endgeil (ugs.);abgefahren (ugs.);fulminant;phantastisch;irre (ugs.)
-hohl;geschröpft
-Limo (ugs.);Brause;Limonade;Kracherl (bayr., österr.);Zuckerwasser (ugs.)
-galoppieren;laufen (Hauptform);zischen (ugs.);Gummi geben (ugs.);preschen (ugs.);pesen (ugs.);fegen (fig.);hechten;dahinpreschen (ugs.);huschen;spurten (ugs.);hetzen;Hackengas geben (ugs.);schnell laufen;flitzen (ugs.);jagen (ugs.);fetzen (ugs.);pfeifen;sprinten;fitschen (ugs., ruhrdt.);düsen (ugs.);eilen;stieben;wetzen (ugs.);rennen (Hauptform);stürmen (ugs.);hasten;rasen;die Beine in die Hand nehmen (ugs., fig.);schnellen;fliegen (geh., fig., literarisch);sausen (ugs.);schießen (fig.)
-Durchmesser;Diameter
-wohingegen;wobei;wogegen;wenngleich
-Aggregation (geh., bildungssprachlich);Zusammenstellung;Sammelbecken (ugs., fig., negativ);Anhäufung;Häufung;Ballung;Agglomeration (geh.);Kompilation (fachspr.);Konglomerat (fachspr.);Akkumulation (geh., bildungssprachlich);Konglomeration (fachspr.);Ansammlung (von);Sammlung;Zusammenballung
-rhombisch;rautenförmig
-nahe Umgebung;Nähe
-Vorwahlnummer;Vorwahl;Ortsvorwahl
-(sich) befreien;(sich) freikämpfen
-kleine Menge;ein wenig;klitzekleines bisschen
-Klarsicht;Durchblick (ugs.);Verständnis
-Bulle;Stier;Muni (schweiz.);geschlechtsreifes männliches Hausrind
-leistungsstark;leistungsfähig;performant
-montieren;anbringen;festmachen;befestigen;anfügen
-rumhängen;herumgammeln (ugs.);dahinvegetieren;rumlümmeln
-Kristallbildung;Kristallisation
-Verbindungsträger;Querbalken
-grundsätzlich;vorig;vorherig;vorangegangen;grundlegend;vorausgehend
-(jemanden) zufrieden lassen (mit) (ugs.);(jemanden) in Ruhe lassen (mit) (ugs.);(von jemandem) weichen (geh., veraltet);(jemanden) in Frieden lassen (mit) (ugs.);nicht belästigen;nicht behelligen
-Explorationsbohrung;Aufschlussbohrung
-(sich) verflechtend;ineinander greifend;verflochten
-Rektor;Direktor
-Ehrfurcht gebietend;ehrfurchtseinflößend;respekteinflößend;ehrfurchtsgebietend;ergreifend;Ehrfurcht einflößend;erhaben;hehr (geh.)
-Tiefkühlkost;Tiefkühlware;TK-Ware
-herzeigen;zur Schau tragen;zur Schau stellen (Hauptform);spazierenführen (auch figurativ);präsentieren;offen zeigen;zeigen
-etwas in der Schwebe halten;schweben;im Ungewissen lassen
-ausprägen;formen;fassonieren (geh.);prägen;gestalten;ausbilden;bilden
-Start...;Kick-off-Veranstaltung;Einsteiger...;Geburt (fig.);Take-off;Aufgalopp;Einstiegs...;Antritts...;(der) erste Schritt;Einstieg;Eröffnungs...;Erst...;An...;Anspiel;Anbeginn (geh.);Startschuss (fig.);Takeoff;Eröffnung;Auftakt;Auftakt...;Aufbruch;Anfangs...
-Ist okay (ugs.);Wofür hat man (denn) Freunde! (ugs., Spruch, variabel);keine Ursache;Lass stecken (ugs.);kein Ding (ugs.);Es war mir ein Vergnügen! (geh.);Passt schon (ugs., süddt.);Gerne! (ugs., Hauptform);Aber bitte gerne!;kein Problem (ugs.);bitte schön;Das war (doch) (ganz) selbstverständlich.;Lass (mal) gut sein (ugs.);Gerne wieder;Bitte sehr;Schon okay (ugs.);kein Thema (ugs.);Komm schon (ugs.);Nichts zu danken;bitte! (Reaktion auf 'danke!') (Hauptform);Gern geschehen;(Das) geht (schon) in Ordnung (ugs.);Wofür? (ugs.);Da nich(t) für (ugs., norddeutsch);(Ist) nicht der Rede wert (ugs.);Schon gut (ugs.);Jederzeit!;Aber gerne (doch)!;Aber nicht doch! (höflich);immer wieder gerne!
-Zölibat;Ehelosigkeit;Enthaltsamkeit
-Order (militärisch);Vorgabe;Vorschrift;Richtlinie;Verfügung;Verordnung;Regel (Hauptform)
-Leitsatz;Leitmotiv (fachspr.);Leitlinie;leitendes Prinzip;Leitprinzip
-Festsetzung;Determiniertheit;Bestimmung
-Tomographie;Schichtaufnahmeverfahren;Schnittbildverfahren;Tomografie
-Haltegriff (Hauptform);Griff;Handgriff (ugs.)
-Aufschwung;Aufgang;Steigen
-BAföG;Bundesausbildungsförderungsgesetz;Ausbildungsförderung;Bafög
-Konkurrenzklausel;Wettbewerbsklausel
-evangelisch;protestantisch
-widerstandsfähig machen;stählen;abhärten;immunisieren
-listenreich (geh.);ränkevoll (geh., veraltet);ausgekocht (ugs.);trickreich;tricky (ugs.);listig;mit List und Tücke (ugs.);ausgefuchst (ugs.)
-Nachahmung;Nachäffen (ugs.);Nachäfferei (ugs.);Nachahmen
-(sich) einer Sache anschließen;(sich) mit etwas assoziieren
-salonfähig;einwandfrei;korrekt;schicklich;anständig
-pappig;klumpig
-Parese (fachspr.);teilweise Lähmung
-einspeisen (von);versorgen (mit);abliefern;einkoppeln;liefern
-Ausdünstung;Duft;Geruch;Aroma
-PR-Kampagne;Werbekampagne;Promotion;Werbefeldzug
-Selbstverpflichtung;Gelübde
-nachsehen;nachlesen;nachblättern;nachschauen;nachschlagen (Buch)
-Posse (geh.);Döneken (ugs., rheinisch);Schnack (ugs., norddeutsch);Jux (ugs.);Schote (ugs.);Fez (ugs.);Schnurre (veraltet);Schildbürgerstreich;Flachs (ugs.);Hanswurstiade (ugs.);Ulk;Schnurrpfeiferei (geh., veraltet);Eulenspiegelei;Nonsens;Schabernack (Hauptform);Spaß;Eselei (ugs.);Spass (österr.);Jokus (ugs.);Clownerie (geh.);lustiger Streich;Drolerie (geh.)
-krankheitserregend;krank machend;pathogen (fachspr.)
-Knöllchen (ugs.);Strafzettel;Strafmandat;Bußenzettel (schweiz.);Knolle (ugs.);Datenermittlungsbeleg (fachspr.)
-schandbar;niederträchtig;verachtenswert;eine Schande (ugs.);schnöde;verächtlich;schändlich;erbärmlich
-verjüngen;zuspitzen;spitz zulaufen
-Kaktee;Kaktus
-Puder;Mehl;Pulver (Hauptform)
-stracks;am besten gestern (ugs.);unverzüglich (Hauptform);ohne Umwege;schnurstracks (ugs.);umgehend;prompt;auf dem Fuß folgend (ugs.);sofort;stehenden Fußes (geh.);sogleich;fristlos;alsbald (geh.);auf der Stelle;(jetzt) gleich (ugs.);schleunigst;postwendend;ohne Zeitverzug;stante pede (lat.);ungesäumt (geh., veraltend);direkt;unmittelbar;augenblicklich;instantan;geradewegs
-Preiskrieg;Preiskampf
-bedienen (Klischee, Vorurteil);einverstanden (sein);beipflichten;(sich) einverstanden erklären;einer Meinung sein;konformgehen (mit);bei jemandem sein (ugs.);billigen;Ja sagen (zu);Zustimmung signalisieren;einiggehen;im Einklang stehen;zustimmen;jedes Wort unterschreiben können (ugs.);recht geben;empfehlen;übereinstimmen;bestätigen;konform gehen (mit);etwas gutheißen;gleicher Meinung sein (Hauptform);unterschreiben;(sich) anschließen
-leitendes Gremium;Vorstand
-(etwas) beibringen;instruieren;einleiten;unterweisen;anleiten;einbegleiten (österr.)
-juvenil;adoleszent;halbwüchsig;heranwachsend;jugendlich
-die Oberhaut betreffend;epidermal (fachspr.)
-verknüpfen;einen;zusammenführen;vereinen;zusammensetzen;kombinieren;vereinigen;verschmelzen;verdongeln (ugs.)
-fruchtbringend;vorteilhaft;nutzbringend;ersprießlich;fruchtbar;nützlich
-überbordend;übermäßig (Hauptform);hemmungslos;schrankenlos;ungehemmt;unverhältnismäßig;astronomisch;enthemmt;überhöht;exzessiv;übertrieben;ausufernd;grenzenlos;exorbitant;übersteigert;entfesselt;ungebremst;überhandnehmend;unmäßig;überschwänglich;überzogen;außerordentlich;uferlos;maßlos
-Voraus...;vordringlich
-anfangen (mit);lancieren;introduzieren (veraltet);einführen (Hauptform);in Umlauf setzen;einleiten;eröffnen
-Funktionsumfang;Systemfunktionalität;Funktionalität;Funktionsvielfalt
-abwickeln;abschaffen
-falscher Gebrauch eines Wortes;Wortverwechslung;Malapropismus
-praxisfern;theorielastig;akademisch;praxisfremd;am grünen Tisch entworfen (fig.);(rein) philosophisch;gelahrt (geh., scherzhaft-ironisch)
-Philanthropie;Menschenfreundlichkeit;Menschenliebe
-Kassenwart;Kassier (schweiz., süddt., österr.);Finanzvorstand;Finanzer (ugs.);Treasurer;Schatzmeister;Kassenführer;Säckelmeister (ugs., schweiz.);Inkassant (schweiz., süddt., österr.)
-Schlucht;Klamm
-Froschmann (ugs.);Taucher
-Rumtreiber (ugs.);Treber (ugs.);Streuner;Obdachloser (Hauptform);Nichtsesshafter;Fecker (schweiz.);Tramp (engl.);Stromer;Berber;Sandler (ugs., bayr., österr.);Trebegänger;Tippelbruder (ugs.);Heckenpenner (derb, stark abwertend);Herumstreicher;Clochard;Wohnsitzloser (Amtsdeutsch);Vagabund (veraltend);Pennbruder (derb);Strotter (veraltet, österr.);Stadtstreicher (abwertend);Herumtreiber (abwertend);Wohnungsloser (Amtsdeutsch);Landstreicher (abwertend);Landfahrer;Penner (derb, abwertend);Strolch
-Ableitung;Herleitung;Dissipation
-tangieren (geh., scherzhaft);in Zusammenhang stehen mit;betreffen (Hauptform);angehen;sich auswirken (auf);(jemandes) Interessen berühren
-Überlastung;Belastung über dem Limit
-Polizeidienststelle (Amtsdeutsch);Posten (schweiz.);Kommissariat (österr.);Wache;Revier;Polizeirevier;Polizeiwache
-in Urlaub fahren;in Urlaub gehen;(seinen) Urlaub antreten;Ferien machen;in die Ferien fahren
-Dosierventil;Zumessventil
-in dieser Art;auf diese Weise;so;in dem Stil (ugs.);auf diesem Wege
-Reizbarkeit;Erregbarkeit
-verrammeln;verstopfen
-Rundsteuerung;Rundsteuertechnik
-indianische Siedlung;Pueblo
-Entscheider;Entscheidungsträger;Lenker (ugs.);Manager;leitende Kraft;Leiter;Führungskraft
-Einsparung;Ausgabensenkung
-Vertauschung;Permutation;Umstellung;Umsetzung;Jitter (Netzwerk) (fachspr.)
-übermannen;überwältigen;bezwingen
-Tombola;Auslosung;Ziehung;Verlosung;Lotterie
-(ein) Unbekannter;irgendwer;irgendeiner;(eine) unbekannte Person;jemand;einer (ugs.);wer (ugs.);irgendeine Person;eine (ugs.);irgendjemand
-hineinreichen;hereinreichen;einreichen
-Schürhaken;Schüreisen;Stocheisen (ugs., ruhrdt.);Schürstange;Feuerhaken
-Titelseite;Leitseite;Startseite;Frontpage (engl.);Hauptseite;Homepage (engl.);Einstiegsseite;Indexseite
-Organismus (fachspr.);Wesen;Geschöpf;Kreatur;Lebewesen (fachspr., Hauptform)
-Fusionsbombe;H-Bombe;Wasserstoffbombe
-(ein) Quätschchen machen (ugs.);quatern (ugs., regional);parlieren (geh., französierend);babbele (ugs., hessisch);ratschen (ugs., bayr.);(sich) unterhalten;plaudern (Hauptform);ein paar Worte wechseln;quatschen (ugs.);Smalltalk machen;klönen (ugs., norddeutsch);konversieren (geh., veraltet);Small Talk machen;quasseln (ugs.);Konversation machen (geh.);babbeln (ugs., regional);(miteinander) reden;schnacken (ugs., norddeutsch);plauschen (ugs.)
-Minen legen;verminen
-Anmeldung;Eingang;Pforte (fig.);Aufnahme (Krankenhaus);Rezeption (Hotel);Empfang;Eingangsbereich
-Süßstoff;Süßungsmittel (geh.)
-Bonität (fachspr., Landwirtschaft);Bodenertrag
-firm;qualifiziert;fähig;fit (ugs.);tauglich
-systemorientiert;systemgebunden
-umweltbewusst;umweltschonend;grün (ugs.);umweltfreundlich;umweltverträglich
-von Zeit zu Zeit;dann und wann (ugs.);bisweilen;ab und zu;öfters (ugs.);das eine oder andere Mal (ugs.);(es) kommt durchaus vor;manchmal (Hauptform);hie und da (ugs.);ab und an;hin und wieder;nicht immer, aber immer öfter (ugs., scherzhaft);immer mal wieder (ugs.);mitunter;fallweise;okkasionell;sporadisch;zeitweise;unregelmäßig;hier und da (ugs.);gerne (ironisch);Gelegenheits...;vereinzelt;des Öftern;zuweilen;des Öfteren;gelegentlich;zeitweilig;manches Mal;verschiedentlich;zuzeiten;schon einmal (ugs.);schon mal (ugs.)
-Separatist;Sonderbündler;Sektierer
-Saat;Saatgut;Saatkörner;Samen;Körner (beschreibt die Form) (ugs.)
-Innung;Zunft;Gewerk (Bau);Gilde
-erlogen;belegfrei;ohne Realitätsgehalt;erfunden;(ein) Produkt der Phantasie;aus der Luft gegriffen (ugs., fig.);eingebildet;an den Haaren herbeigezogen (ugs., fig.);imaginär;irreal;(an einer Sache) ist nichts Wahres dran (ugs.);(an einer Sache) ist kein wahres Wort;haltlos;erstunken und erlogen (ugs.);nicht auf Tatsachen beruhen(d);spekulativ;zusammenfantasiert (ugs.);ohne Realitätsbezug;ausgedacht;imaginiert (geh.);frei erfunden;fiktiv;frei phantasiert;surreal;von A bis Z gelogen (ugs., variabel);(da ist) nichts dran (ugs.)
-Tara;Verpackungsgewicht;Leergewicht
-Beschlagnagel;Knopf;Knauf
-Filigran;Filigranarbeit
-darauf brennen (ugs.);Bock haben (ugs.);Lust haben, etwas zu tun
-Belegung;Zuteilung;Zuweisung;Zuordnung
-Verladung;Einschiffung
-Verweis;Rat;Vorschlag;Tipp;Ratschlag;Empfehlung;Hinweis;Proposition (geh.)
-Nationalfeiertag;Staatsfeiertag
-Duftstoff;Duft;Parfüm (Hauptform);Parfum;Duftwasser
-die Ursache sein;ursächlich;kausal
-taub;stocktaub (derb, Verstärkung);gehörlos;schwerhörig
-Umschwung;Revolution (franz., lat.);Umsturz;Subversion (fachspr.);Sturz;Umwälzung
-aufgliedern;analysieren;zergliedern;zerlegen
-spitzbübisch;schelmisch;schalkhaft;pikaresk (geh., franz.);verschmitzt;schelmenhaft;pikarisch (geh.)
-informieren (über);verweisen (auf);hinweisen (auf);sensibilisieren (für);aufmerksam machen (auf)
-darlegen;ausmalen;in Worte fassen;umschreiben;beleuchten;in Worte kleiden (geh.);resümieren;referieren;beschreiben (Hauptform);wiedergeben;ausführen;darstellen
-Orientierungspunkt;Orientierungshilfe;Eckpunkt
-Entzündung der Darmwand;Enteritis (fachspr.)
-zeitig;rechtzeitig;früh genug;frühzeitig;beizeiten
-Hang;Sympathie;Vorliebe;Geneigtheit;Wohlwollen;Zuneigung
-Badener;Badenser
-geistig;seelisch;zerebral;Gemüts...
-leitfähig;stromdurchlässig
-Blutvergiftung (ugs.);Sepsis (fachspr.)
-Ernährer;Versorger
-Tuch;Wischtuch;Lumpen;Putzlappen;Lappen;Putztuch;Wischlappen;Feudel (ugs., norddeutsch)
-formelles Recht;Verfahrensrecht
-Reklamation;Umtausch;Zurückerstattung;Abgeltung;Rücksendung;Zurückgabe;Erstattung;Abtragung;Rückgabe
-unfrei;nicht freigemacht;unfrankiert
-Deutsche Presse-Agentur;dpa
-unerreichbar;außer Reichweite
-Altjahrabend (schweiz.);Jahresausklang;Altjahrstag (schweiz., österr.);Altjahrsabend (schweiz.);31. Dezember;letzter Tag des Jahres;Jahresabschluss;Silvester;Jahreswende
-begießen;wässern (fachspr., Jargon);besprengen;gießen;bewässern
-fieser Trick (ugs.);fauler Trick (ugs.);krumme Tour (ugs.)
-bläken (ugs.);dröhnen (ugs.);plärren (ugs.);schreien;brüllen;blöken (ugs.)
-Magie;Verzauberung;bezaubernde Wirkung;übernatürliche Wirkung;magische Kraft;(etwas) kaum Benennbares (geh.);Aura;Flair;Zauberkraft;(das) gewisse Etwas;Fluidum
-Senf;Mostert;Mostrich
-abschrauben;abmontieren;losschrauben (ugs.)
-Glanz;Glanzton;Funkeln
-tiefschürfend;profund;tief;hintergründig;tiefdenkend
-unnötig stark;übertrieben;übermäßig;im Übermaß;ungebührlich stark;zu stark;überaus;zu sehr;unverhältnismäßig;über Gebühr;mehr als gut wäre;mehr als nötig
-Garantie;Garantievertrag
-verklemmt;gehemmt;unentspannt;sozialphobisch (psychol.) (fachspr.);verkrampft;verdruckst (ugs.);befangen
-Schatten;Schlagschatten
-gerade (Zahl);ohne Rest durch zwei teilbar
-Dinghi;Dingi;Beiboot;Dinghy
-selbständig;freiberuflich;freiberuflich tätig;freischaffend
-treulos;untreu;treubrüchig
-kichern (Hauptform);gackern (ugs.);gickeln (ugs.);gibbeln (ugs., norddeutsch, ruhrdt.);keckern;feixen
-Krankenstation;Station
-Handel treiben;Geschäfte machen;handeln (mit);negoziieren (fachspr., kaufmännisch);Handel betreiben
-Hörbehinderung;Gehörfehler;Hörschaden
-schlecht werden (Lebensmittel);(ver)gammeln (ugs., variabel);verderben;umkommen (ugs.)
-Rühreier;Rührei;Eierspeise (österr.)
-Angriff (auf);Einfall (in);Überfall (auf);Anschlag (auf)
-Schneebrett;Schneeverwehung;Schneeablagerung;Schneewehe;Wechte (schweiz.);Schneewechte (schweiz.)
-giftig;gesundheitsschädigend;toxisch;gesundheitsgefährdend;gesundheitsschädlich
-simpel;schlicht;gewöhnlich;kunstlos;einfach;unspektakulär;(ganz) normal;banal
-Chef de Cuisine (fachspr.);Maître de Cuisine (fachspr.);Chefkoch;Küchenchef;Küchenmeister (Qualifikationslevel)
-Platzanweisung;Platzierung
-Böschung;Steilhang;Ranken
-(das) kommt gut (ugs.);jemandem gefallen;jemanden ansprechen
-schockierend;ultrakrass (ugs.);krass;einschneidend;drakonisch;durchgreifend;herb;streng;hart;heftig (ugs.);drastisch;hammerhart (ugs.);knallhart (ugs.)
-eben (ugs.);vor einem Moment;frisch;just;vor wenigen Momenten;grade (ugs.);vor ein paar Sekunden;gerade eben (Hauptform);justament;gerade;soeben
-Richtkreis;Richtzeichen;Zielzeichen
-flugtauglich;lufttüchtig;flugfähig
-ungehemmt;beschwingt;mit Feuereifer;mit wehenden Fahnen;flott;mit Verve;schmissig (ugs.);mit fliegenden Fahnen (fig.);mit Eifer;voller Elan;voller Begeisterung;begeistert
-Behälter;Container;Aufbewahrungslösung (fachspr., werbesprachlich);Gefäß;Behältnis
-Fall;Fallen;Sinken;Abfall;Untergang;Sturz;Niedergang
-viehisch (abwertend, fig.);tierisch;bestialisch (fig., negativ)
-Hybris;Anmaßung;Vermessenheit;Hochmut;Selbstüberhöhung
-logische Korrektheit;Stimmigkeit;Folgerichtigkeit;Logik
-zugeordnet;(zu etwas) gehörig;zugehörend;angehörend;angegliedert
-Kabinettstück;Schachzug;Volte;Trick;Kniff;Kabinettstückchen;Winkelzug
-picobello (ugs.);(es) blitzt und blinkt (ugs.);tipptopp;makellos sauber;strahlend sauber;schlierenfrei (werbesprachlich);blitzeblank;vor Sauberkeit strahlen (variabel);porentief rein (werbesprachlich);blitzesauber;pieksauber (ugs.);hygienisch;sauber;blitzblank;spiegelblank;auf Hochglanz (poliert) (ugs., fig., variabel);proper;fleckenlos sauber;rein;(da) könnte man vom Fußboden essen;wie geleckt (ugs.);blitzsauber
-s/w;schwarz/weiß;farblos
-Spielwarenhandlung;Spielwarengeschäft
-klassisch;altsprachlich
-organisieren;sortieren;kommissionieren (fachspr.);ordnen;gruppieren;zusammenstellen
-vom Knochenmark ausgehende Geschwulst;Myelom (fachspr.)
-Waisenkind;elternloses Kind;Waise
-von etwas Besitz ergreifen;(sich) über etwas hermachen (ugs.)
-Handeln;Initiativen;Bemühungen;Maßnahmen;Handlung;Aktivität;Tun (geh.);Tätigkeit (Hauptform)
-dicht machen;imprägnieren;beständig machen
-(an jemandem) einen Narren gefressen haben (sprichwörtlich);(einer Sache/jemandem) verfallen sein;(einer Sache / jemandem) erlegen sein (geh.);entzückt sein (von / über);(jemandem) geht einer ab (bei) (derb);hin und weg sein (von) (ugs.);voll abfahren (auf + Akkusativ) (ugs.);(hellauf / restlos) begeistert sein (von);supertoll finden (ugs.);schwärmen (für);in den höchsten Tönen schwärmen (für);Feuer und Flamme sein (für) (ugs., sprichwörtlich);verzückt sein;hingerissen sein (von)
-Röntgenstrahlung;X-Strahlen;Röntgenstrahlen
-rührselig;schmalzig;schnulzig;gefühlsbeladen;sentimental;gefühlvoll;auf die Tränendrüse drücken(d) (ugs., fig.);gefühlsselig
-(sich) zusammenscharen;(sich) zusammenlegen (selten);(sich) sammeln;(sich) zusammenschließen;(sich) zusammentun (ugs.);(sich) vereinen (Hauptform);(sich) zusammenrotten (abwertend);(sich) scharen (um) (geh.)
-Sonder...;Ultra...;Spezial...;besonderes ...;Extra...
-Weltreisender;Globetrotter;Weltenbummler
-aromatisierte Zuckermasse;Fondant
-Liebreiz;Grazie;Anmut;Ebenmaß;Reiz;Schönheit;Ästhetik
-PR-Arbeit;Außendarstellung (Jargon);Pressearbeit;PR;Public Relations;Öffentlichkeitsarbeit (Hauptform)
-Mehrwegflasche;Pfandflasche
-Adaptivität;Flexibilität;Anpassungsfähigkeit;Adaptabilität
-Vernissage;Eröffnung einer Kunstausstellung
-Schnittwaren;Vorhangstoffe
-ausrotten;beseitigen;exterminieren;(etwas) plattmachen (ugs.);plätten (ugs.);ausmerzen;(etwas) den Garaus machen (ugs.);austilgen;vernichten;tilgen
-zuhause;(bei sich) zu Hause;daheim
-Lava ausstoßen;Lava speien;eruptieren
-fordernd;anspruchsvoll;mühselig;strapaziös;mühsam;heavy (ugs., engl.);aufwendig;anstrengend;schwierig;aufwändig;belastend;voll Plackerei;beschwerlich (geh.)
-im System abgespeichert;systemresident
-unbußfertig;reuelos
-Kreditgeschäft;Kreditgewerbe
-Veranstaltungsort;Schauplatz;Austragungsort
-gütlicher Vergleich;Mittelweg;Kompromiss;goldener Mittelweg (ugs., floskelhaft);Aurea Mediocritas (geh., lat.)
-ins Lächerliche ziehend;scherzhaft;spöttelnd;(dezent) spöttisch;ironisch;lästernd;scharfzüngig;nicht ganz ernst gemeint;mit gespielter Ernsthaftigkeit;lächerlich machend;halbernst;spitz (ugs.);lästerlich
-brüllen;grölen;schreien;johlen;laut werden
-trösten;ermutigen;Trost spenden;aufbauen
-Rechtschreibung;Orthographie;korrekte Schreibung;Orthografie;richtige Schreibweise
-in den Himmel heben (fig.);jemand lebt nur noch für;höchste Bewunderung zollen (geh.);verehren;anhimmeln (ugs.);Feuer und Flamme sein (für) (ugs.);anschmachten;vergöttern (ugs.);(sich) verzehren (nach) (geh.);schmachten (nach);verklären;anbeten (ugs.);verschmachten (nach);(jemandes) Ein und Alles (sein) (ugs.);(jemandem) zu Füßen liegen (ugs., fig.);idealisieren (fachspr.);schwärmerisch bewundern
-serienmäßig hergestellt werden;in Serie hergestellt werden;seriell hergestellt werden
-Starter;Anlasser
-Autarkie;Selbständigkeit;wirtschaftliche Unabhängigkeit;Selbstversorgung;Selbstständigkeit;Subsistenzwirtschaft
-zwischenspeichern;persistent machen (fachspr.);speichern;(auf der Festplatte) sichern;abspeichern
-polyvalent;mehrwertig
-Presswurst (österr.);Presssack (bayr.);Presskopf;Schwartemagen (schweiz., schwäbisch);Sausack (regional);Schwartenmagen (schweiz., schwäbisch)
-nervale Überträgerstoffe;Neurotransmitter
-identifizieren;ausfindig machen;zu Tage fördern;aufklären;herausfinden;(einer Sache) auf die Spur kommen;sehen;konstatieren (geh.);ausmachen;verorten;feststellen;entdecken;(jemandem) auf die Schliche kommen (ugs.);erkennen;eruieren (geh., bildungssprachlich);aufdecken;ermitteln;detektieren;zutage fördern;festmachen
-Eiskunstläufer;Schlittschuhläufer
-auf die Palme bringen (ugs., fig.);verstimmen;wütend machen;(jemanden) aufregen;erzürnen;entrüsten;in Wut versetzen;zur Weißglut bringen (ugs., fig.);die Gemüter erhitzen (ugs.);zur Weißglut treiben (ugs., fig.);in Harnisch bringen;(jemanden) gegen sich aufbringen;(jemanden) ärgern;empören
-streitig;strittig
-Positiv (fachspr.);Foto (Hauptform);Bild;Abbildung;Lichtbild;Fotoaufnahme;Bildwerk (urheberrechtlich) (fachspr.);Ablichtung;Fotografie;Bildnis;Ausbelichtung (fachspr.);Aufnahme;Abzug;Vergrößerung (fachspr.)
-Winterbeere;Hülskrabbe (landschaftlich);Hülsebusch (landschaftlich);Christdorn;Hülsdorn;Ilex;Hülse (landschaftlich);Stechhülse;Schradler (österr.);Stechpalme
-Bestrebung;Bestreben;Versuch;Anstrengung;Bemühung;Bemühen
-Tabellenführung;Tabellenspitze
-kühl;klar;ohne schmückendes Beiwerk;schmucklos;ruhig;trocken;pragmatisch;vernünftig;machbarkeitsorientiert;schnörkellos;sachbetont;sachlich;zweckmäßig;nüchtern
-Kürlauf;Kür (Eiskunstlauf)
-Rezept;Medikation (fachspr.);Arzneimittelverordnung;Medikamentation (fachspr., medizinisch)
-APO;Außerparlamentarische Opposition
-Taktgeber;Schlagmann;Vorruderer
-guillotinieren;(einen) Kopf kürzer machen;durch die Guillotine hinrichten;köpfen;enthaupten;mit dem Schwert richten;(jemandem) den Kopf abschlagen
-Bekanntmachungsblatt;Report;Tagesbericht
-Ansiedler;Siedler
-blutig (Steak);nicht durchgebraten
-Diaphorese (fachspr.);Hautausdünstung;Transpiration;Schwitzen
-Eingebung;Gedanke;Idee;Einfall (Hauptform);Erleuchtung
-Abtastfrequenz;Samplingrate (engl.);Abtastrate;Samplerate (engl.);Samplingfrequenz
-Landjunker;Junker
-Offenheit;Neugierde;Interessiertheit;Interessiertsein;Interesse;Neugier
-den Hoden betreffend;testikulär (fachspr.)
-Halskette;Halsband;Collier;Kollier (alte Schreibung bis 2017)
-Raumpflegerin;Putzfrau (ugs.);Reinemachefrau;Putzteufel (ugs., scherzhaft);Putze (ugs., herablassend);Raumkosmetikerin (ugs.);Reinigungskraft;Putzhilfe;Mitarbeiterin einer Reinigungsfirma;Zugehfrau;Bedienerin (österr.);Putzfee (ugs., aufwertend);Reinmachefrau;Putzkraft;Mitarbeiterin eines Reinigungs-Service;Gebäudereinigungskraft;Aufwartefrau (geh., veraltet)
-Bardividende;ausgeschüttete Dividende;Barausschüttung
-per Post;auf dem Postweg;postalisch (Amtsdeutsch);mit der Post;durch die Post
-besamen;inseminieren (fachspr.);befruchten
-Hochschulausbildung;Studieren;Studium
-kacheln;plätteln (schweiz., schwäbisch);Fliesen anbringen;Fliesen legen;fliesen
-wohl überlegt;gut durchdacht
-Errettung;Rettung;Bergung
-aufs Genaueste;bis zur (aller)letzten Kleinigkeit;kleinlich (abwertend);detailbesessen;pingelig (ugs.);perfektionistisch;übergenau;bis ins letzte Detail;päpstlicher als der Papst (sprichwörtlich);detailverliebt;buchhalterisch (fig.);überpenibel;kleinkariert (abwertend);minutiös;aufs Sogfältigste;pedantisch;pinselig;minuziös;detailversessen;hyperkorrekt (ugs.);penibel;peinlich genau;akribisch;mit äußerster Sorgfalt;aufs Gewissenhafteste
-Schrägstellung;Zeichenneigung
-kriecherisch;schmeichlerisch;byzantinisch (veraltet)
-verzogen;krumm und schief (ugs.);wellig;windschief;schief;krumm;verbogen
-(jemanden) animieren (zu);(jemandem) Mut einflößen;ermutigen;anspornen;(jemanden) stimulieren (zu);(jemanden) bringen (zu);ermuntern;anregen;(jemanden) bestärken (in);stärken;(jemandem) Mut machen;(jemanden) aufrufen (zu)
-Besitz;Eigentum;Hab und Gut;Besitzung(en) (geh.);Habe;Habseligkeiten;Besitzstand;Siebensachen (ugs.);Vermögen;Geld und Gut
-Gericht;Gerichtshof
-umfüllen;umschütten;dekantieren (fachspr.)
-sinnentstellend;verfälschend
-trinken (auf);(das) Glas erheben (auf) (geh.);(einen) Trinkspruch ausbringen;auf jemandes Wohl trinken;anstoßen (auf);(einen) Toast ausbringen
-Enteignung;Nationalisierung;Vergesellschaftung;Verstaatlichung;Kollektivierung
-den Eltern gehörend;elterlich
-Vorderarm;Unterarm
-Gelegenheit;Opportunität;Anlass;Möglichkeit
-präkordial (fachspr.);vor dem Herzen
-(sich) einschalten;eingreifen;dazwischengehen (ugs.);(ins Geschehen) eingreifen;(jemandem) hineinreden (ugs.);intervenieren (Hauptform);dazwischenfunken (ugs., fig.);(sich) einmischen;dazwischentreten;(sich) reinhängen (ugs.);einschreiten
-Wandteppich (Hauptform);Gobelin (franz.);Wandbehang
-Verkleidung;Verschalung;Umhüllung;Ummantelung
-Verbindungsdauer;Anrufzeit
-Schauloch;Türspion;Guckloch
-Frauenrechtlertum;Feminismus;Frauenemanzipation
-Harnsäureausscheidung steigernder Stoff;Urikosurikum (fachspr.)
-Brandrückstand;Schlacke;Verbrennungsrückstand;Asche
-ernst nehmen;erfüllen;achten (Regel) (geh.);beachten (Vorschrift);(sich) halten (an);einhalten;(einer Sache) Folge leisten
-zählen;abzählen
-seefest;seetauglich;seetüchtig
-(etwas) herunterfahren;unterbieten;absenken;heruntergehen (mit);heruntersetzen;herunterfahren mit;runtergehen (ugs.);schmälern;herunterschrauben (ugs.);herunter schrauben (ugs.);verkleinern;nachlassen;senken;zurückfahren (fig.);dämpfen;herabsetzen;reduzieren;rausnehmen (Druck, Tempo ...) (ugs.);ermäßigen;erniedrigen;kürzen;mindern;runterfahren (ugs.);einschränken
-Trichter;Krater;Kessel;Erdfall
-Folie;Overheadfolie;Overhead-Projektor-Folie
-(sich) berührend;angrenzen;aneinander liegen;aneinander grenzen
-Cer;Cerium;Zerium;Zer
-aufwaschen (ugs., regional);den Abwasch machen;abwaschen;den Abwasch erledigen;spülen;Geschirr spülen
-zusammen;zugleich
-Forschungseinrichtung (Hauptform);Forschungszentrum;Forschungsanstalt;Forschungsstätte;Forschungsinstitut
-Thon (schweiz.);Tunfisch;Thunfisch
-nicht weiter...;aufhören (mit);ruhen lassen;(sich) abgewöhnen;nicht weitermachen;abstellen;ablassen (von) (geh.);sein lassen (ugs.);sistieren (schweiz.);bleibenlassen;(etwas) einstellen;fahren lassen (geh.);aufgeben;bleiben lassen;(eine Gewohnheit / Untugend) ablegen;beenden;nicht weiterführen;beilegen
-Vorhaut;Präputium (fachspr.)
-Unterbekleidung;Wäsche;Dessous;Unterwäsche (Hauptform);Weißwäsche;Leibwäsche (veraltend);Trikotagen (veraltend)
-Zugriffsart;Zugriffsverfahren
-aufhören (mit);(einer Sache) ein Ende setzen;erledigen;den Stecker ziehen (ugs.);abräumen (Thema) (ugs., Jargon);beenden;besiegeln;abhaken (ugs.);(einen) Cut machen (ugs.);abschließen;beendigen;ad acta legen;einen Schlussstrich ziehen (fig.)
-vergessen;nicht mitbekommen (ugs.);verpennen (ugs.);verschlafen (ugs.);verfehlen;versäumen;verbaseln (ugs., regional);verschwitzen (ugs.);verabsäumen (geh., Papierdeutsch);verpassen;übersehen
-zuweisen;zuordnen
-Leinwand;Reifengewebe
-ungeschlechtlich;geschlechtslos
-zergliedern;zerlegen;sezieren;dekomponieren (fachspr.)
-einnehmen;erzielen;erwirtschaften;umsetzen;reinkommen (Geld) (ugs.)
-Ufer;Küste;Gestade (geh., veraltet);Strand
-Büchse;Buchse
-(sich) einschalten;mitmischen (ugs.);(sich) beteiligen;(sich) einklinken;auf den Zug aufspringen (ugs., fig.);(sich) einer Sache anschließen;einsteigen
-Behörde;Amt;Amtsstelle (schweiz.);Dienststelle
-verdinglichen;reifizieren;hypostasieren;vergegenständlichen
-zirpen;zwitschern
-verträumt;träumerisch;traumversunken (geh.);in den Wolken (fig.);(in Gedanken) versunken;traumverloren (geh.);weltvergessen (geh.);versonnen;träumerisch entrückt (geh.)
-schnippen;schnellen;schnipsen;schnalzen (ugs., bayr., österr.);schnicken (ugs.)
-EURATOM (Abkürzung);Europäische Atomgemeinschaft;EAG (Abkürzung, veraltet)
-im Stechkahn fahren;staken
-kursieren;umgehen;rumgehen (ugs.);(sich) herumsprechen;heißen (es ..., dass);sollen;die Runde machen (fig.);in Umlauf sein;gerüchteweise zu erfahren sein;Flurgespräch sein (fig.);zirkulieren;herumgehen;umlaufen;weitererzählt werden;(sich) durchsprechen;man erzählt sich (dass)
-pladdernass (ugs.);waschelnass (ugs.);pudelnass (ugs.);kletschnass (ugs., rheinisch);nass bis auf die Knochen (ugs.);pitschnass (ugs.);platschnass (ugs.);klatschnass (ugs.);durchnässt;tropfnass;klitschnass (ugs.)
-Galvanotechnik;Galvanik;Elektroplattieren
-Ablagekasten;Ablage;Ablegen;Kellern;Ablagerung;Abheften;Aufstapeln
-ultraviolett;UV
-Japanknolle;chinesische Artischocke;Stachys
-Pyrometer (fachspr., griechisch);Strahlungsthermometer
-Werbungskosten;Werbekosten
-Späher;Aufklärer;Kundschafter;Eklaireur (geh., franz., veraltet)
-strapazierfähig;ausdauernd;zäh;widerstandsfähig;robust
-(sich jemanden) anlachen (ugs.);(ein) Liebesverhältnis eingehen;(ein) Paar werden;(sich) kriegen (ugs.);(mit jemandem) was Ernstes anfangen;(mit jemandem was) anfangen (ugs.);anbandeln;(sich) anfreunden;(sich) eine Freundin zulegen (ugs.);(ein) Verhältnis anfangen (mit) (ugs.);zarte Bande knüpfen (mit) (geh.);(sich) einen Freund zulegen (ugs.);(mit jemandem) zusammenkommen;(sich) zusammentun (ugs.);(zwei) haben sich gefunden;(sich) auf jemanden einlassen;anbändeln (mit)
-Slang;Straßenjargon;(saloppe) Umgangssprache;Gassensprache (geh., veraltet);Vernakularsprache (lat.);saloppe Ausdrucksweise;Argot (fachspr., franz.);Jargon (verhüllend)
-Requisite (Theater);Requisiteur
-Radiästhet;Rutengeher;Wünschelrutengänger (Hauptform)
-Gewölbe;Wölbung
-abweichend;uneinheitlich;anders geartet
-Abforstung;Abholzung
-aufpusten;aufpumpen;mit Luft füllen;aufblasen;aufblähen
-festhalten (an);(sich) halten (an);nicht aufgeben;nicht abgehen (von);bleiben (bei)
-Ehrenbezeigung;Lob
-Spross;Setzling;Sprössling;Pflänzling;Sämling;Jungpflanze (fachspr.);Steckling
-Einseitigkeit;Voreingenommenheit;Parteilichkeit
-geädert;granuliert (fachspr.)
-schockiert;wie vom Schlag getroffen;außer Fassung;die Welt nicht mehr verstehen (ugs.);(ganz) durcheinander (ugs., fig.);(jemanden) trifft der Schlag (ugs., fig.);ratlos;erstaunten Auges (geh., altertümelnd, scherzhaft);verständnislos;geschockt;dazu fällt jemandem nichts mehr ein (ugs.);(ganz) von den Socken (ugs.);wie vor den Kopf geschlagen (ugs.);fassungslos;verdattert (ugs.);konsterniert (geh.);entgeistert;(jemandem) bleibt die Spucke weg (ugs., fig.)
-Anfahrt;Zutritt;Zufahrtsstraße;Zugang
-ureigen;essenziell;essentiell;innewohnend;in der Natur der Sache;wesenhaft;arteigen;zu eigen;immanent
-tingeln;schaukeln (fig.);juckeln (ugs., salopp);karriolen;kutschieren (ugs.);tuckern;gurken (ugs., salopp);gondeln (ugs.);zuckeln;karjuckeln (ugs., scherzhaft)
-Unstetigkeit;Sprunghaftigkeit;fehlende Konstanz;Wandelbarkeit;Flatterhaftigkeit;Unbeständigkeit;Lebhaftigkeit;Launenhaftigkeit;Wankelmut
-annoncieren;verkünden;künden (geh.);ansagen;bekanntgeben;ankündigen;melden
-Badminton;Federballspiel;Federball
-parteifrei;parteilos;neutral;wertfrei;unparteiisch
-Attacke;Anfall;Zusammenbruch
-Montageplan;Bauplan;Lieferplan
-abledern (ugs.);(es jemandem) so richtig geben (ugs.);(jemandem) einen einschütten (ugs.);(kräftig) austeilen (ugs.);(derbe) vom Leder ziehen;(Schlag) versetzen;schwere Geschütze auffahren (fig., variabel);(sich) mit Kritik nicht zurückhalten
-Inselbewohner;Insulaner
-Anzeigenpreis;Anzeigentarif
-aussterben;erlöschen;untergehen
-Hybrid;Halbblut;Mischling;Bastard (derb)
-Gewissheit;Vertrauen;Glaube;Zuversicht
-folgsam;zu Willen;gehorsam;erbittlich;tut was man ihm sagt;willig
-furchtbar;(jemandem) zuwider;fürchterlich;abscheulich;schrecklich;abominabel (geh., bildungssprachlich, franz., lat., selten, veraltet);widerlich;scheußlich;grässlich;schauderhaft;entsetzlich
-Gefach (fachspr.);Holzgerüst;Fachwerk;Hölzernes Gefüge;Ständerfachwerk (fachspr.)
-Fläche;Ebene
-epikurisch;epikureisch;genusssüchtig
-reuig;zerknirscht;bußfertig (geh.);reumütig;selbstkritisch;schuldbewusst;(sich) seiner Schuld bewusst;im Büßergewand (fig.);reuevoll;gesenkten Hauptes (geh.)
-bis dato (Jargon);bis anhin (schweiz.);bis zum heutigen Tag;bisherig;(heute / aktuell ...) noch;bis zum jetzigen Zeitpunkt;bis auf den heutigen Tag;bisher;bis heute;bis jetzt (Hauptform);bislang
-abzocken (ugs.);abcashen (ugs.);abziehen (ugs.);abkassieren (ugs.);(jemanden) erleichtern um;(jemandem) das Fell über die Ohren ziehen (ugs., fig.);Geld aus der Tasche ziehen (ugs., fig.);(jemanden um etwas) prellen;(jemanden) ausnehmen wie eine Weihnachtsgans;(jemanden) ausnehmen;(jemanden) schröpfen (fig.)
-Absatzgebiet;Markt;Handelsplatz;Börse;Handelszentrum;Umschlagplatz;Absatzmarkt (fachspr.)
-durchstreichen;ausstreichen
-Maischkessel;Maischbottich
-Historiker;Geschichtsforscher;Geschichtswissenschaftler
-Salzlake;Gewürzlake;Pökellake;Lake
-Grundprinzip;logische Grundlage
-übersprudeln;überschäumen
-erhellen;erleuchten;beleuchten;ausleuchten
-Protozoon;Urtier;Urtierchen;Einzeller mit klar abgegrenztem Zellkern
-Verpächter;Vermieter;Verleiher;Bestandgeber
-matt;stumpf;dumpf;kontrastarm;glanzlos
-Botschaft;Informationsaustausch;Bericht;Mitteilung;Nachricht;Bekanntmachung;Kunde (geh., veraltet)
-Winkelfrequenz;Kreisfrequenz
-hervorsprießen;aus dem Boden schießen (ugs.)
-erbringen;hereinholen;abwerfen (ugs.);einbringen;abfallen
-Einreichung;Einsendung
-im Durchschnitt;typisch;mittlerer Art und Güte (fachspr., auch ironisch);so wie man ihn kennt (generalisierend);klassisch;durchschnittlich;im Mittel;im Schnitt (ugs.)
-eindeutig machen;vereindeutigen;disambiguieren
-Verriegelung;Schließmechanismus;Verschluss
-Mazedonien (veraltet);Republik Nordmazedonien (offiziell);Nordmazedonien;Republik Mazedonien (veraltet);Ehemalige Jugoslawische Republik Mazedonien (veraltet)
-Verfalldatum;Mindesthaltbarkeitsdatum;MHD (fachspr.);Fälligkeitsdatum;Verfallsdatum;Ablaufdatum (österr.);Mindesthaltbarkeit
-Regress;Rückgriff
-Beihilfe;Hilfsmittel;Vorschub
-in Geheimen;geheimnistuerisch;verstohlen;heimlich;geheimniskrämerisch
-Haarausfall;Alopezie (fachspr.)
-aber;jedoch;nur (ugs.);doch;trotz und allem;trotzdem;dabei (ugs.);allein (geh., veraltend);zwar (...) doch;dennoch;bloß;indessen;indes
-Radiotherapie;Strahlenbehandlung;Radioonkologie;Strahlentherapie;Bestrahlung;Strahlenheilkunde
-angeborene Fehlentwicklung;Dysgenese (fachspr.)
-kontaktfreudig;gesellig
-salutieren;Salut schießen
-innovativ;neuartig;neu (entstanden) (Hauptform);originell;noch nicht dagewesen;neu entwickelt;eigene Wege gehen(d) (fig.);frisch;der letzte Schrei (ugs., fig.);(noch) nie dagewesen;neu auf dem Markt
-Western;Wildwestfilm;Cowboyfilm (ugs., veraltend)
-schrammig;narbig
-jemandem Mut machen;jemanden stärken
-einberufen;einziehen
-Hetäre;Bettgenossin;Kurtisane;Mätresse;Geliebte (Hauptform);Liebhaberin;Gespielin
-außer Kraft setzen;(etwas) unterbrechen (Hauptform);intermittieren (technisch);zeitweilig aufheben
-Themenbereich;Thema;Themenkreis;Themengebiet
-Sparpackung;Familienpackung;Haushaltspackung
-Richtung (ugs.);in Richtung (Hauptform);gen
-kleistern;kitten;kleben;leimen
-Platt;Niederdeutsch;Plattdeutsch
-Faltblatt;Broschüre;Faltprospekt;Flyer (engl.)
-verbocken (ugs.);vermasseln (ugs.);in den Teich setzen (ugs., fig.);verzapfen (ugs.);versemmeln (ugs.);vergeigen (ugs.);verkorksen (ugs.);(etwas) verkacken (derb);in den Sand setzen (ugs., fig.);verpfuschen;verpatzen (ugs.);vermurksen (ugs.);versaubeuteln (ugs.);versauen (derb);verhauen (ugs.);versieben (ugs.);verhunzen (ugs.)
-Eidechse;kleiner Drache;kleines Reptil
-Mittäterschaft;Komplizenschaft;Tatbeteiligung
-bis heute;bis zum heutigen Tag;bis auf den heutigen Tag
-Limitierung;Beschränkung;Begrenzung;Limitation
-Pappe;(undefinierbare) Pampe (ugs.);Papp (ugs.);Mansch;breiartige Masse (Hauptform);Gatsch
-Konservativer;Reaktionär
-Remake;Neuauflage;Neugestaltung;Neufassung
-jemals;je
-Korrektur für Programmfehler;Fehlerkorrektur (Programmcode);Bugfix (Jargon);Patch (Jargon)
-Stockung;Stagnation;Stillstand
-Grasnarbe;Grasdecke;Grasteppich
-Dichtstoff;Dichtungsmittel;Füllmaterial
-einhüllen;umhüllen;wickeln;einwickeln;(in etwas) hüllen
-Mehrgebärende;mehrfache Mutter;Multipara (fachspr.)
-Sockelleiste;Scheuerleiste
-Relaxans (fachspr.);Entspannungsmittel
-überaus passend;bestens geeignet (geh.);vorzüglich geeignet
-Skribent (geh., veraltet);Schmierfink (derb);Vielschreiber;Schreiberling (ugs., abwertend);Wortedrechsler (derb)
-Unbedenklichkeitserklärung;Unbedenklichkeitsnachweis;Unbedenklichkeitsbescheinigung;Persilschein (fig.)
-Murren;Knurren
-Einwohner Nepals;Nepalese
-Entmutigung;Schlag ins Kontor (ugs.);Ernüchterung;kalte Dusche (ugs., fig.);Enttäuschung;Katzenjammer (fig.);Dämpfer (ugs.);lange Gesichter (bei) (fig.)
-Fallbeispiel;Fallstudie
-Kuweit;Kuwait
-Platz (Lage) wechseln;(sich) bewegen
-Altstadt;historischer Stadtkern;historischer Ortskern
-Erscheinungsbild;Erscheinung;Figur;Aussehen;Gestalt
-Flussrate je Zeiteinheit;Durchfluss
-Tangenten...;Tangential...;tangential
-Insiderhandel;Insidergeschäft
-Wurfmaschine;Katapult
-Dehnung;Ausweitung;Erweiterung;Dilatation (fachspr.)
-Copilot;Kopilot
-anspannen;verspannen
-Morgenröte;Morgenrot
-Ernannter;Beauftragter
-Tintenpisser (ugs.);Tintenstrahldrucker;Tintendrucker
-philosophieren;(einen) Monolog führen;nachdenken;laut nachdenken (ugs.);Selbstgespräche führen (ugs.);mit sich selbst reden (ugs.)
-brummen (Wirtschaft) (ugs.);blühen;boomen;florieren;(sehr) gut laufen
-praepartal (fachspr.);antenatal (fachspr.);pränatal (fachspr.);vorgeburtlich;präpartal (fachspr.);praenatal (fachspr.);antepartal (fachspr.);vor der Geburt
-Bekanntmachung;Kommuniqué (geh., franz.);Kundmachung (österr.);Verlautbarung;Bekanntgabe;Ankündigung;Bulletin (franz.);Verkündung;Offenlegung;amtliche Mitteilung;Notifikation;Mitteilung
-Erkenntlichkeit;Dankbarkeit
-quittieren;anerkennen;würdigen;honorieren;bestätigen
-Protektionist;Verfechter
-Eigenverantwortung (für);Selbstbestimmung;Eigenverantwortlichkeit;Selbstverantwortung
-Fett abbauen;(den Körper) entfetten;weniger werden (ugs., ironisierend);(an) Gewicht verlieren;abnehmen (Hauptform);abspecken (ugs.);schlank werden
-Obliegenschaft;Verantwortung;Befugnis;Verantwortungsbereich;Bereich;Verantwortlichkeit;Zuständigkeit;Kompetenz
-Bims;Bimsstein
-neu ordnen;umdirigieren;neu organisieren;reorganisieren;umorganisieren;umgruppieren
-in... (In...);non... (Non...);nicht... (nicht-..., Nicht...);un...
-zubringen;verleben;(Zeit) verbringen
-weinerlich;nah am Wasser gebaut (haben) (ugs., fig.);tränenvoll;tränenselig (geh.);wehleidig (abwertend);überempfindlich;selbstmitleidig;larmoyant (geh.);übersensibel;voller Selbstmitleid
-Angebotskurs;Briefkurs
-schnittig;rassig;schmissig
-Verzögerungstaktiker;Filibuster;Verschleppungstaktiker
-Interesse;Motivation
-Erhöhung;Emporheben;Anstieg
-Standing (engl.);Renommee;Autorität;Ansehen;Geltung;Prestige;Bedeutung;Wertschätzung;Einfluss;Achtung;Würdigung;Hochachtung
-Beförderung;Versand;Nachsendung
-Bronchitis (fachspr.);Entzündung der Bronchien
-einbruchsicher;aufbruchsicher;diebstahlsicher;einbruchssicher
-Carbon (ugs.);Karbonfaser;Kohlefaser (ugs.);Carbonfaser;Kohlenstofffaser
-in sich schließen;beinhalten
-zyprisch;zypriotisch
-hauptsächlich (Hauptform);vorrangig;vorwiegend;primär;vor allem (ugs.);in der Hauptsache;größtenteils;überwiegend;schwerpunktmäßig;im Wesentlichen;vor allen Dingen (ugs.);insbesondere
-...gemäß;gemäß;in Übereinstimmung mit;wie;entsprechend (Präposition);zufolge (Amtsdeutsch);nach
-Tagtraum;Wachtraum
-Verspätung;Verzögerung;Zeitverzögerung;Verzug
-Sittenlehre;Ethik;Morallehre;Tugendlehre
-St.;Sankt ...
-mit den Ohren schlackern (ugs.);(jemanden) ungläubig anschauen (ugs.);(ungläubig) den Kopf schütteln;erstaunt sein (über);vonne Socken sein (ugs., ruhrdt.);(sich) wundern;(sich) (verwundert) die Augen reiben;verdutzt sein;(jemanden) mit großen Augen anschauen (ugs., variabel);verdattert sein (ugs.)
-Brückenpfeiler;Pfeiler einer Brücke
-junger Mann;Knabe (geh., poetisch);Bursche;Bursch (ugs., süddt.);Jüngling
-Immigrant;Zugereister;Zuzügler;Migrant;Wahl...;Reigschmeckter (ugs., schwäbisch);Neubürger;Zuzüger (schweiz.);Einwanderer;Zuwanderer;Zugezogener;Neuzuzüger (schweiz.)
-Bedrohung;Androhung;Drohung
-Knackgeräusch;Knallgeräusch
-Arbeitsweise;Prinzip;Funktionsweise;Mechanik
-Dom;Münster;Kathedrale
-gottesdienstliches Brauchtum;Ritus;Zeremoniell;Übung;Ritual;Zeremonie
-World Health Organization (engl.);Weltgesundheitsorganisation;WHO (Abkürzung, engl.)
-Wiederverwendbarkeit;Recycelbarkeit;Wiederverwertbarkeit;Recyclebarkeit
-bevölkern;besiedeln
-veraltet;nicht mehr angesagt;vernutzt (geh.);altmodisch;passé (veraltet);abgedroschen;out (veraltet);hat seine Zeit gehabt;altväterisch;überkommen;abgelutscht (ugs.);abgenudelt;veraltend;Schnee von gestern (ugs., fig.);längst vergessen geglaubt;hat seine (beste) Zeit hinter sich;obsolet (geh.);überholt;abgegriffen
-Krankheitserreger;Keim;pathogenes Bakterium;Bazillus;Krankheitskeim
-trägerlos;schulterfrei
-geleiten;dirigieren;regieren;bugsieren;lotsen;navigieren;leiten;führen;manövrieren;schleusen
-Depotgebühr;Verwahrgebühr
-(sich) widersetzen;Trotz bieten (geh.);(sich) auf die Hinterbeine stellen (fig.);(einer Sache) trotzen;(jemandem / einer Sache) die Stirn bieten;(sich) sträuben;(sich) zur Wehr setzen (auch figurativ);(sich) nichts gefallen lassen (Hauptform);Widerstand leisten;wider den Stachel löcken (geh., veraltend);Kontra geben (ugs.);(etwas) nicht auf sich sitzen lassen;(sich) wehren (auch figurativ, Hauptform);(sich jemandes / einer Sache) erwehren (geh.);(sich) verteidigen;(sich) seiner Haut wehren (auch figurativ);(sich) (etwas) nicht gefallen lassen
-Trennung;Ausschaltung
-wellig;onduliert;lockig;gelockt;gewellt
-verzapfen;einzapfen (in);einstemmen
-Verfolgbarkeit;Aufspürbarkeit
-Karditis (fachspr.);Herzentzündung
-Mentor;Ratgeber;Berater
-Zellteilung;Zytokinese;Cytokinese
-Position;Stätte;Lage;Fleck (ugs.);Lokalität;Punkt;Ort;Stelle;Standort;Location (fachspr., Jargon, engl.)
-nachsenden;weiterleiten (Brief)
-Gesittung;Zivilisation
-Lehm;Ziegelton
-Osteolyse (fachspr.);Abbau von Knochensubstanz
-täuschend;trügend (geh.);trügerisch
-Lid;Augendeckel (ugs.);Augenlid
-Schall...;akustisch;phonetisch
-vereitern;eitern;schwären (geh.)
-(wieder) zuversichtlich werden;Mut fassen
-Zuwiderhandlung;Überschreitung;Ordnungswidrigkeit;unerlaubte Handlung (juristisch);Verletzung;Verstoß;Übertretung;Nichteinhaltung
-Gasthaus;Wirtschaft;Gasthof;(der) Grieche (Italiener, Türke...) (ugs.);Gastwirtschaft;Gaststätte;Wirtshaus;Lokal;Speisegaststätte;Restaurant (Hauptform);Speisewirtschaft
-duldsam;gütig;gelinde (geh., veraltend);nachsichtig (Hauptform);(etwas) dulden(d);konnivent (geh., bildungssprachlich);tolerant;viel Verständnis haben (für);permissiv (geh., bildungssprachlich);verständnisvoll (Hauptform);milde gestimmt (geh.)
-Bildmischpult;Bildmischer
-Gesträuch;Buschwerk;Maquis (franz.);Buschwald;Unterholz;Gebüsch;Gestrüpp;Strauchwerk;Dickicht;Macchie;Macchia (it., kors.)
-Knirps;Bube;Bub (Hauptform, süddt.);Kerlchen;Jungchen;Wicht;Bengel;Junge (Hauptform, norddeutsch);Kleiner (ugs.);Steppke (ugs., berlinerisch);Kurzer (ugs.);Pimpf (veraltet);Knabe
-Schaumstein;Isolierstein
-Widmung;Inschrift;Eintrag;Eintragung;Aufschrift
-Quai (schweiz.);Kai;Anlegeplatz;Kaje
-Missachtung;Respektlosigkeit;Brüskierung
-erster Teil;Ansetzungsform
-Kompanie;Kompagnie;Handelsgesellschaft;Handelskompanie;Compagnie;Co.
-fürstlich;regal (lat.);hoheitsvoll;königlich;majestätisch;royal;erlaucht (geh.)
-Überbrückung;Überbrückungsdraht
-Biopsie (fachspr.);Entnahme von Gewebe
-Schlinge;Masche;Schleife;Schluppe (fachspr.);Schlaufe
-verheißen;vorhersagen
-ein Gesuch machen;eine Eingabe machen
-ruhig;nicht aus der Ruhe zu bringen;unerschütterlich;ohne mit der Wimper zu zucken (ugs., fig.);kühl;kaltblütig;ungerührt;unaufgeregt;gefasst;nervenstark;stoisch;gleichmütig;seelenruhig
-Trennschärfe;Nahselektion;Empfindlichkeit (fachspr.)
-zuweisbar;angebbar
-einfordern;einspannen;(zu etwas) anhalten;(jemanden) verdonnern (zu) (ugs.);zwingen;bestimmen;erzwingen;(jemanden) vergattern (zu) (ugs.);forcieren;in die Pflicht nehmen;nötigen;verpflichten
-Tarif;Satz;Rate
-schwammig;wollig;flaumig;flauschweich;flauschig;puschelig;samtig;samten;samtweich;soft;fluffig (ugs.);kuschelweich;weich;sanft
-Lufterneuerung;Ventilierung (geh.);Lüftung;Entlüftung;Luftversorgung;Ventilation;Belüftung;Luftzufuhr
-Altbier;Alt
-vorausbemerken;vorgreifen;(gedanklich) vorwegnehmen;antizipieren
-Osteoporose (fachspr.);Knochenentkalkung;Knochenschwund;Verminderung des Knochengewebes
-Schuhnagel;Stiefelnagel;Schuhzwecke
-Laster;Geilheit;Lüsternheit;Schamlosigkeit;Triebhaftigkeit;Unzucht
-Durchschaltung;Durchkontaktierung
-Arbeitsunfähigkeit;Erwerbsunfähigkeit;Invalidität
-Fasson (Textilien);Äußeres;Form;Aussehen;Gestalt
-Label;Wortmarke (fachspr.)
-submarin;unterseeisch;Unterwasser...
-Inszenierung;Vorstellung;Aufführung
-Quirl;Wirtel
-Apparate;Maschinen;Maschinenpark;Maschinerie;Apparaturen
-verlaufen;(Zeit) verfließen;(Zeit) ins Land ziehen;vergehen;vorbeigehen;verstreichen;(Zeit) ins Land gehen;verrinnen (lit.) (geh.);ablaufen
-Haltung (von Tieren);Zucht;Aufzucht
-Zwischenregierung;Interregnum (lat.)
-Stadium;Station;Entwicklungsstufe;Abschnitt;Entwicklungsabschnitt;Entwicklungsstand;Periode (fachspr.);Phase;Stufe;Entwicklungsstadium;Entwicklungszustand;Punkt;Entwicklungsphase
-Pate;Taufpate;Gevatter (veraltet);Patenonkel (ugs.)
-adiabatisch (fachspr.);ohne Wärmeaustausch
-Siegesmal;Siegeszeichen;Trophäe
-max. (Abkürzung);maximal (Adverb);nicht mehr als;höchstens
-Asynchronous Transfer Mode;Asynchroner Transfermodus (Netzwerktechnologie);ATM
-Kliff;Felsvorsprung
-Prävalenz;weite Verbreitung;Überhandnehmen;Vorherrschen
-Projektion;Prognose;Vorausschau;Schätzung;Vorhersage;Vorsprung
-Parästhesie (fachspr.);Fehlempfindung
-Peristaltik (fachspr.);Kontraktionswellen (im Verdauungstrakt)
-Kolumnenschreiber;Kolumnist;Autor einer Kolumne
-wie angekündigt;planmäßig;ohne Verspätung;fahrplanmäßig;nach Plan;pünktlich;nach Fahrplan
-Elementgruppe;Gruppe
-verflechten;verweben (mit, zu)
-in Panik;von Angst ergriffen;kopflos;überängstlich;panisch;von panischem Schrecken gepackt;panikartig
-Auflage;galvanischer Überzug;Schutzschicht;Überzug;Metallüberzug
-Rand;Flanke;Seite;Flügel
-gut abschneiden;eine gute Punktzahl erreichen
-Beliebtheit;Popularität
-Kaffeehaus;Café
-Publikumsmagnet;Zugnummer (ugs.);Kracher (ugs.);Highlight (engl.);Zuschauermagnet;Zugpferd (ugs.);Burner (ugs., engl.);Bringer (ugs.);Glanzstück;Glanznummer;Anziehungspunkt;Brüller (ugs., salopp);Attraktion
-Urteilsfindung;Abstimmung;Entscheidung;Abstimmen
-rückwärtiger Schrägstrich;linksseitiger Schrägstrich;Backslash (engl.);Rückstrich;Rückschrägstrich;zurückgelehnter Schrägstrich;umgekehrter Schrägstrich
-sowjetische Politik der Öffnung;Glasnost
-Ischämie (fachspr.);Blutleere
-Spieldauer;Spielzeit;Vorführdauer;Filmlänge (ugs.);Laufzeit
-Gebühr;Kostenbeitrag;Beitrag
-Anzeigenverkäufer;Anzeigenvertreter;Anzeigenakquisiteur
-Sterblichkeitsrate;Mortalität;Sterblichkeit;Sterberate
-bezaubern;verwünschen;verhexen;verzaubern;verwandeln (in)
-nicht stark genug;nicht ebenbürtig;nicht ankommen gegen;zu schwach;seinen Meister gefunden haben (Redensart);(jemandem) nicht gewachsen;schwächer (als);(jemandem) nichts entgegenzusetzen haben;(gegen jemanden) blass aussehen (ugs., fig.);unterlegen sein;schlechter (als);(jemandem) nicht Paroli bieten können
-krampfartig;spasmisch;konvulsivisch;wie ein Krampf;konvulsiv;spasmodisch;krampfähnlich;krampfhaft
-staatsfeindlich;subversiv;umstürzlerisch
-Erfolgsaussicht;Erfolgschance
-Handsäge;Fuchsschwanz
-Realitätsverleugnung;Augenwischerei;Fiktion;Schönfärberei
-Gönner;Mäzen;Förderer;Sponsor;Freund und Förderer;Impresario
-Entehrung (veraltet);sexueller Missbrauch;Vergewohltätigung (zynisch) (derb);Schändung;Vergewaltigung (Hauptform);Notzucht (Amtsdeutsch, veraltet)
-Erdichtung;Dichtung
-Beglaubigung;Akkreditierung
-asymptomatisch (fachspr.);ohne erkennbare Krankheitszeichen;symptomlos
-Aspekt;Standpunkt;Sichtfeld;Perspektive;Ansicht;Blickrichtung;Sicht;Blickwinkel;Sichtweise;Anschauungsweise
-(sich) mokieren (über) (geh.);höhnen;scherzen;spötteln;ulken;frotzeln;(jemanden / etwas) verlachen (geh.);witzeln;spotten (über) (Hauptform);lästern (über);(jemanden) bespötteln (geh.);(jemanden / etwas) verhöhnen;(jemanden) auslachen;(jemanden) verspotten
-die Chromosomen betreffend;chromosomal (fachspr.)
-Straßenverkehrsordnung;StVO
-Komfort;Bequemlichkeit;Gemütlichkeit
-übers Knie brechen (ugs.);mit heißer Nadel stricken (an);huddeln (ugs.);vorschnell sein;überhasten;übereilen;unbedacht sein;hastig sein;überstürzen
-Kelle;Maurerkelle;Mörtelkelle
-genetisch bedingt;vererbt;geerbt (von);genuin (fachspr.);genetisch verursacht;kongenital (fachspr.);angeboren
-abgehackt;holprig;ruckartig
-strafrechtliche Verfolgung;Anklage
-Schleifstein;Mahlstein
-Geschwalle (ugs.);Gelaber (ugs.);Geschwurbel (ugs.);Sermon (ugs.);Dummdeutsch (fachspr.);leere Worte;Geschwätz (ugs., Hauptform);Geseire (ugs.);Gefasel (ugs., abwertend);Blabla (ugs.);leeres Gerede;Geplänkel (ugs.);Gewäsch (ugs., abwertend);Gesülze (ugs., abwertend);Gesäusel (abwertend);Schmus (ugs.);warme Worte (ugs., ironisch);Geschwafel (ugs., abwertend);Schein-Tiefsinn (fachspr., psychologisch);Gerede (ugs.);hohle Phrasen (ugs.);Luftblasen (ugs., fig.);Geblubber (ugs.);Gemunkel (ugs.)
-Messband;Rollmeter (schweiz., österr.);Maßband (Hauptform);Rollbandmaß;Bandmaß;Zentimetermaß;Metermaß
-runzeln (Stirn, Augenbrauen);rümpfen (Nase)
-Läusebefall;Pedikulose (fachspr.);Phthiriasis (fachspr.)
-negativ;zu wünschen übrig lassen (ugs.);widrig;lausig;nachteilig;dürftig;ungünstig;schädlich;schlecht (für) (Hauptform);von Nachteil;ungut
-Box;Kasten;Schachtel;Päckchen;Packung
-Begriff;Auffassung;Vorstellung;Denkweise;Idee;Ausdruck;Anschauung
-(jemanden) jagen;weiter verfolgen;hinter jemandem her sein (ugs.);(jemanden) verfolgen;(jemanden) vor sich her treiben;(jemandem) nachsetzen;(jemanden) treiben
-aus etwas herstammen;von etwas kommen;von etwas herrühren
-Blockierung;vorübergehende Aufhebung;Inhibition (fachspr.);Sperrung;Hemmung
-Gesöff (ugs.);billiger Wein
-Insemination (fachspr.);Befruchtung
-Dimmer;Verdunkelungsschalter
-Mitarbeiterin am Empfang;Rezeptionistin;Concierge;Empfangsdame;Mitarbeiterin an der Rezeption;Empfangschefin
-Finanzkauf (fachspr.);Kauf auf Raten;Ratenkauf;Teilzahlungsgeschäft (fachspr.)
-Gummiüberschuh;Gummischuh;Galosche (veraltend)
-Wassertablette (ugs.);harntreibendes Mittel;Diuretikum (fachspr.)
-gefahrenträchtig;unsicher;bedrohlich;riskant;abenteuerlich;brenzlich;brenzlig;bedenklich;gefährlich;beunruhigend
-Drehring;Radiallager;Drehlager
-Rückgang;Nachlassen;Regression;Abfall;Dekreszenz (fachspr.);Einbuße;Verringerung;Abnahme;Dämpfung;Schwund;Degression (fachspr.)
-Leben;irdisches Dasein;Dasein;Existenz
-Anxiolytikum (fachspr.);angstlösende Mittel;Ataraktikum (fachspr.)
-(jemanden) verpetzen (ugs.);(jemanden / etwas / jemandem etwas) melden;(jemanden) denunzieren;(jemanden) verpfeifen (ugs.);(jemanden) anscheißen (bei) (derb);vernadern (ugs., österr.);(jemandem etwas) zutragen (geh.);(jemanden / etwas) verraten;(etwas) weitergeben;(jemandem etwas) hinterbringen (geh.);(etwas) petzen (ugs.);(jemanden) anschwärzen (bei) (ugs.)
-Gewürzkörner;Viergewürz;Pimenta dioica (fachspr., lat.);Pimenta officinalis (fachspr., lat.);Allgewürz;Neugewürz;Nelkenpfeffer;Modegewürz (veraltet);Piment (Hauptform);Jamaikapfeffer
-Geld...;Währungs...
-Blutwurst;Topfwurst;Schwarzwurst;Blunzen (ugs., bayr., österr.);Puttes;Rotwurst;Flönz (ugs., kölsch);Blunzn (ugs., bayr., österr.)
-scheckig (Pferd);gescheckt;fleckig;gefleckt;buntscheckig
-ächten;in Acht und Bann schlagen (veraltend);verbannen;verfemen
-Ehrung;Dekorierung;Preis;Auszeichnung
-Konkurrenz...;Wettbewerbs...
-Gesamtvollstreckungsverwalter;Konkursverwalter;Masseverwalter (österr.);Liquidator;Abwickler;Insolvenzverwalter
-Startpunkt;Keimzelle (ugs.);Start;Ausgangspunkt
-Scheinarznei;Scheinarzneimittel;Medikament ohne Wirkstoffe;Placebo;Scheinmedikament
-das Gehör betreffend;auditiv (fachspr.)
-ablesen;scannen;abtasten
-einrichten;gestalten
-Wölbstein;Keilstein;Wölber;Gewölbestein
-voll (ugs.);geladen;aufgeladen
-Blütenlese (geh.);Bevorzugung;Körung (Tierzucht) (fachspr.);Selektion;Präferenz (fachspr.);Wahl;Auslese;Auswahl
-Immobilieneigentum;eigene vier Wände (ugs.);Eigenheim
-Produktionsdatum;Herstellungsdatum
-Gezeter;Jammerei;Lamento;Wehklagen;Wehgeschrei;Geheul;klagende Laute;Klage;Herumgejammer;Gejammer;Jammer
-(sich) bedecken;(sich) zuziehen;(sich) bewölken
-Abendland;Alte Welt (ugs.);Okzident;Westen;Europa
-(sich) einverleiben;(sich) widerrechtlich aneignen;usurpieren (geh.);(sich) unter den Nagel reißen (ugs.);widerrechtlich erobern
-tabellieren;tabellarisch anordnen
-Eigensüchtigkeit;Eigensinn;Egoismus;Eigennutz;Ichsucht;Selbstbezogenheit;Eigennützigkeit;Selbstsucht;Selbstbesoffenheit (derb, abwertend);eigenes Interesse
-Burggraben;Festungsgraben
-Körperhaltung;Gestus (geh.);Pose;Stellung;Haltung;Positur
-Orchestergraben;Orchesterraum
-knüpfen;knoten
-beherrschen;managen;regeln;herrschen
-Leiste;Profilleiste;Holzleiste;Zierleiste;Latte
-Trägerwelle;Trägerschwingung
-Reibeisen;Raspel
-Schwimmteich;Badeweiher;Badeteich
-(sein) Augenmerk richten (auf);ein (waches) Auge haben (auf);hüten;(etwas) in Evidenz halten (österr.);(jemanden/etwas) aufmerksam mitverfolgen;(etwas) im Auge behalten (ugs.);ein Auge auf etwas werfen (ugs.);(jemandem/etwas) Beachtung schenken;beachten;im Blick behalten;(etwas) im Blick haben;beobachten;bewachen
-Verkündigung;Verhängung
-jemanden lieben;jemandem gegenüber zärtlich werden
-selbstbeweglich (fachspr., technisch, veraltet);wie von Zauberhand (bewegt) (floskelhaft);wie von allein (ugs.);automatisch;selbsttätig;automagisch (ugs., scherzhaft);wie von selbst (ugs.)
-Müllcontainer;Abfallcontainer
-ringen (mit);kämpfen (gegen, mit)
-Apnoe (fachspr.);Atemstillstand
-Krempe;Hutkrempe
-unkenntlich machen;verbergen;maskieren
-Vernunft;Ratio (geh., lat.);gesunder Menschenverstand (ugs.);Wirklichkeitssinn;Raison (geh., franz.);Räson (franz.);Hausverstand;gesunder Verstand (ugs.)
-Bestellungsannahme;Auftragsbestätigung
-Qualm;Schwalk;Schwalch;Rauch
-mindestens;minimal;nicht unter;min.;Minimum (ugs.);wenigstens
-Klemmschelle;Klemmstück
-Industriestaat;Industrieland
-Deckungsgleichheit;Übereinstimmung;Kongruenz
-Backenknochen;Kinnbackenknochen
-Puffern;Caching;Zwischenspeichern
-Mistgabel;Heugabel
-machthaberisch;despotisch
-Identitätskarte (schweiz.);Lichtbildausweis;Perso (ugs.);Personalausweis
-ausplaudernd;ausplappernd
-(konkreter) Versuch (Hauptform);Unternehmung;Anlauf
-abbildend;repräsentativ;vertretend
-Seeufer;Meeresufer;Ufer;Küste
-Vorhersagbarkeit;Berechenbarkeit
-schräg;wunderlich;absonderlich;skurril;seltsam;ungewöhnlich;überspannt;verschroben;abgedreht (ugs.);eigenartig;schrullenhaft;speziell;spinnert;strange (ugs., engl.);urig;spleenig;wie man ihn nicht alle Tage trifft;sonderbar;merkwürdig;kauzig;schrullig
-Erfüllung;Vollbringung (geh.);Abschluss;Vollendung;Schlussstrich;Bewältigung
-eisern (fig.);konsequent;beharrlich;penetrant;zielstrebig;hartnäckig
-Fasten;Fastenzeit
-(sich) flüchtig befassen mit;einen Blick werfen in
-Es ist leider so, dass ...;Ich fürchte, dass ...;Man muss ganz deutlich sehen, dass ...
-Schlummerrolle;Nackenrolle
-Einleitung;Vorwort;Geleitwort;Präambel (juristisch)
-vergebliche Liebesmüh sein (ugs.);wirkungslos verpuffen;im Nichts verlaufen;nicht fruchten (bei jemandem);(sich) totlaufen (ugs.);nichts bewirken;im Sande verlaufen (ugs.);nicht weiterkommen (mit);(sich) verlieren;im Leeren verlaufen;(sich) in Rauch auflösen (ugs.);genauso gut hätte ich (+ absurde Handlung) (ugs.);nicht weiterverfolgt werden;zu nichts führen;im Sand verlaufen (ugs.);versanden (ugs.);(sich) in Wohlgefallen auflösen (ugs.);nichts bringen (ugs.);nicht vorankommen;(sich) in Luft auflösen (ugs.);(sich) verlaufen;wirkungslos bleiben (Hauptform);verplätschern (ugs.);verläppern (ugs.);ins Leere laufen (mit);nichts herauskommen (bei);verpuffen;nicht helfen (ugs.)
-belasten;beladen;laden
-in Umgebung der Mundöffnung;perioral (fachspr.)
-Atrium;Lichthof (überdacht);Hof (ugs.);Innenhof;Patio (vornehmlich span.);Kreuzgang (Kloster)
-verlockend;reizend;herzig;attraktiv;zauberhaft;anziehend;allerliebst;bezaubernd;liebenswert;anmächelig (ugs., schweiz.);gefällig;ansprechend;anlockend;reizvoll
-Hochländer;Hochlandbewohner;Bergbewohner
-Schilf;Ried;Schilfrohr;Reet (norddeutsch)
-Systementwurf;Systemplanung
-begrüßenswert;erstrebenswert;willkommen;erwünscht;wünschenswert;gern gesehen;begehrenswert;gerngesehen
-Welle;Achse;Drehstange
-nicht sinkbar;nicht versenkbar;unsinkbar
-Finalrunde;Endrunde;Finale;letzte Runde;Stechen;Stechschießen;Stechrunde
-schnarren;knarzen;ächzen;kratzen;quietschen;knarren;knirschen
-Führerhaus;Fahrerhaus;Führerkabine;Kabine;Fahrerkabine;Führerstand
-Schadensachverständiger;Schadensachbearbeiter
-Bewegung bringen in (eine Sache);(wieder) in Schwung bringen;zum Durchbruch verhelfen
-ggf. (Abkürzung);im gegebenen Moment (geh.);potenziell;sollte (z.B. 'sich dies als notwendig erweisen') (geh.);eventualiter (schweiz.);im Falle, dass;möglicherweise;je nachdem;kann sein, kann nicht sein (ugs.);im Fall der Fälle;potentiell;den Umständen entsprechend;eventuell;mögen (Modalverb) (geh.);im Zweifel (ugs., floskelhaft);nicht ausgeschlossen, dass (...);evtl. (Abkürzung);für den Fall, dass;notfalls;womöglich;u.U. (Abkürzung);für den Fall der Fälle;gegebenenfalls (Hauptform);unter Umständen;vielleicht
-Muskelzittern;Tremor (fachspr.)
-anführen;vorbringen;verweisen auf;ins Feld führen (Argument) (fig., Hauptform, militärisch);(sich) berufen auf;geltend machen;nennen;zitieren
-Verbands...;Kollektiv
-polieren;blank putzen;wienern
-erfassen;zusammenfassen;verknüpfen;stapeln
-Ständchen;Serenade
-Weg;Pfad;Steig;Trampelpfad;Steg
-deuten;deuteln;auslegen;interpretieren
-das Finale schaffen;das Finale erreichen
-Barriere;Hürde;Blockade;Hemmung;Bremsklotz (fig.);Behinderung;Hemmnis;Schikane (Reit-/Motorsport) (fachspr.);Hindernis;Hemmschuh (fig.);Fallstrick;Stolperstein (fig.)
-nicht vor;nicht bevor;nicht eher als;ab (einem bestimmten Zeitpunkt);erst als;nicht früher als;erst wenn
-schmackhaft machen;(den) Rat geben;(jemandem) zuraten;raten;nahelegen;anraten;empfehlen;anempfehlen (geh.);vorschlagen;ans Herz legen (ugs., fig.)
-Ausnahme;(sowas) kann schon mal vorkommen (ugs.);(sowas) kann schon mal passieren (ugs.);Ausnahmefall;nicht der Regelfall;Sonderfall;(das) kommt im Einzelfall vor;Einzelfall
-in Verwahrung nehmen;verwahren;konservieren;behalten;aufheben;lagern;nicht wegschmeißen (ugs.);erhalten;bewahren;nicht wegwerfen (ugs.);aufbewahren;asservieren (geh.)
-Gehörlosigkeit;Surditas (fachspr.);Taubheit
-die Notbremse ziehen (ugs., fig.);auf die Bremse treten (fig.);(einen) Cut machen (Jargon);abbrechen;stoppen;die Reißleine ziehen (ugs., fig.)
-aufbrausen;auffahren;brüllen;rumbrüllen (ugs.);herumschreien;blöken (derb);herumbrüllen
-Bibliothek;Bücherei
-(wieder) ins Lot kommen;(sich) konsolidieren (geh.);(sich) festigen;(sich) normalisieren;(sich) einpendeln (bei);(sich) verfestigen;(sich) stabilisieren
-Buchhalter;Buchführer
-angehängte Silbe;Suffix (fachspr., wissenschaftlich);Anhängsel;Nachsilbe (Hauptform)
-Kniebundhose;Knickerbocker;Kniehosen;Kniehose;Culotte (franz.)
-Dekolletee;Dekolleté;Ausschnitt;Décolleté (schweiz.)
-Unduldsamkeit;Indulgenz (geh.);Intoleranz;Nicht-Ertragen-Wollen
-Aussage;Sinngehalt;Semantik (fachspr.);Bedeutung;Sinn
-Cellophan;Zellglas;Cellulosehydrat;Zellophan
-Schafsinseln;Färöer;Färöer-Inseln (fälschlich)
-Reinigung mit Wasser;Spülung;Waschung mit Wasser
-Hausbursche;Boy (engl.);Diener;Butler (engl.);Hausangestellter;Domestik (abwertend, veraltet);Bediensteter;Bursche;Ordonnanz (militärisch);Dienstbote;Page (franz.);Kammerdiener;Lakai
-Durchtreiber;Austreiber;Durchschläger
-Enthüllung;Entschleierung;Bloßlegung;Offenlegung;Demaskierung;(das) Bloßlegen;Aufdeckung;Entlarvung;Bloßstellung
-ohne Zahl (geh., veraltend);ungeheuer viele;Heerscharen von;Myriaden von (geh.);(eine) Unmasse von;(eine) Unmasse an;sehr, sehr viele (ugs.);sonder Zahl (lit. oder veraltet) (geh.);unzählige (Hauptform);unglaublich viele (ugs.);irre viele (ugs.);ungezählte;zahllose;wahnsinnig viele (ugs.)
-(die) Summe bilden;plus nehmen (ugs.);addieren;zusammenziehen;und rechnen (ugs.);zusammenzählen;zusammenrechnen;(eine) Addition machen (variabel)
-ebenso;detto (österr.);dgl. (Abkürzung);desgleichen;dito
-Ausruf;Exclamatio (fachspr., lat.);Ruf;Schrei
-Befruchtung;Fertilisation
-Unbeständigkeit;Haltlosigkeit
-sichern;retten
-ruhen;ausruhen;bleiben
-Drallsatz;Drehimpulssatz
-(jemandem) bang(e) (zumute) sein (veraltet);(die) Hosen voll haben (ugs.);bibbern (ugs.);(jemandem) geht die Muffe (1 zu 1000) (ugs.);vor etwas Gamaschen haben (veraltet);(etwas) fürchten;(sich) fürchten;(jemandem) geht der Arsch mit Grundeis (derb);(die) Hosen gestrichen voll haben (ugs., Verstärkung);bangen;Angst haben (vor / dass);(das) Herz in der Hose (haben / tragen) (veraltend);(sich) ängstigen;Schiss inne Buchs haben (ugs., regional);(den) Flattermann kriegen (ugs.);Muffensausen haben (ugs.);(jemandem) geht der Arsch auf Grundeis (derb);befürchten;(jemandem) geht die Düse (derb)
-vom Pech verfolgt;unglücklich;vom Unglück verfolgt;unglückselig;glücklos
-Grad Celsius;C;Grad;Celsius
-Break-even-Punkt;Break-even-Point (engl.);Rentabilitätsschwelle;Gewinnschwelle
-CVJM (Abkürzung);Christlicher Verein Junger Menschen
-androgen;vom männlichen Geschlechtshormon
-Gabe;Geschenk;Präsent;Aufmerksamkeit (geh.)
-hypnotisieren (fig.);süchtig machen (fig.);Suchtpotential haben;ganz in Anspruch nehmen;unwiderstehlich anziehen;hypnotisch anziehen;(ein) Suchtfaktor (sein) (ugs., fig.);in den Bann schlagen (variabel);eine hypnotische Faszination ausüben (auf);fesseln;kaum (wieder) loskommen von (ugs.);faszinieren
-s-förmig;sigmoidal;sigmoid
-außerirdisch;extraterrestrisch
-(sich) mies fühlen;(jemandem) geht es nicht gut;(sich) elend fühlen
-tief umpflügen;zerfurchen
-einatmen;Luft holen;inhalieren
-Euthanasie;Sterbehilfe
-ohne Besinnung;betäubt;besinnungslos;ohnmächtig;im Koma;nicht bei sich;bewusstlos;nicht bei Bewusstsein (Hauptform);komatös (fachspr.);ohne Bewusstsein;narkotisiert;weg (ugs.)
-Hypertension (fachspr.);Hypertonie (fachspr.);Hypertonus (fachspr.)
-vertrauenswürdig;seriös;vertrauenerweckend;Vertrauen erweckend
-Menarche (fachspr.);erste Regelblutung
-flachsen;Witze machen;witzeln;Gags machen;Späße machen
-Führung;Spitze;Vorhut
-Youngscher Modul;Dehnungsmodul;Elastizitätsmodul;Elastizitätskoeffizient;E (Formelzeichen);Zugmodul;E-Modul (Kurzform)
-naturbelassen;urchig (schweiz.);ungekünstelt;naturgemäß;kernig;natürlich;urwüchsig
-Reparaturset;Reparatursatz
-auftauen;entfrosten
-Gemischzusammensetzung;Luft-Kraftstoff-Verhältnis
-Überschäumen;Übersprudeln
-einen Schritt zur Seite gehen;beiseitetreten
-Zugkraft;Wirkungskraft
-Kassa (österr.);Geldkasse;Ladenkasse;Geldschublade;Kasse;Geldkasten;Geldkassette
-Menstruation mit Unterleibsschmerzen;Dysmenorrhoe (fachspr., medizinisch)
-losbinden;losmachen (ugs.);abmachen (ugs.);abbinden;lösen
-Auslöser;Stimulans;Anlass;Grund;Impuls;Anreiz;Initialzündung;Hintergrund;Veranlassung;der tiefere Sinn;Beweggrund;Stein des Anstoßes;Wirkursache;Quelle;Anstoß;Motiv;im Hintergrund stehen;Anregung;Ursache
-käseweiß;weiß wie die Wand;blutleer;leichenblass;kalkweiß;kreideweiß;kreidebleich;totenblass;käsig;fahl;blass;aschfahl
-Schamottestein;Feuerfestziegel
-Varix (fachspr.);Venenknoten;Varize;Krampfader
-völlig neu gestalten;(etwas) auf den Kopf stellen (ugs.);umkrempeln (ugs., fig.);völlig verändern;von Grund auf ändern
-Bandage;Kompresse;Umschlag;Verband
-behindernd;hinderlich;störend;im Weg sein
-unterdrücken;ausblenden;ersticken (Gefühle);abwehren;supprimieren;verdrängen;niederdrücken
-petzen (ugs.);verpetzen (ugs.);in die Pfanne hauen (ugs., fig.);(jemanden) verpfeifen
-Ertragen;Erdulden;Aushalten
-CB;CB-Funk
-Mehrwertsteuer;Märchensteuer (ugs., scherzhaft);Umsatzsteuer;MwSt.
-rauswerfen (ugs.);hinausschicken;(jemanden) hinauskomplimentieren (geh.);zum Gehen auffordern;rausschmeißen (derb);nach Hause schicken;(jemanden) an die frische Luft befördern (ugs.);vor die Tür setzen (ugs.);rausschicken (ugs.);fortschicken;(jemandem) zeigen, wo die Tür ist;hinauswerfen;des Saales verweisen (geh.);hinausexpedieren (sehr selten) (geh., bildungssprachlich);vom Hausrecht Gebrauch machen (geh., juristisch, verhüllend);(jemandem) die Tür weisen (geh.);wegschicken;hinausbefördern (ugs.)
-frei erfinden;(sich etwas) aus den Fingern saugen (ugs., fig.);(sich etwas) aus dem Ärmel schütteln (ugs., fig.);faken
-Präzedenz;Präjudiz (fachspr.);Musterfall;Präzedenzfall
-Hyperpyrexie (fachspr.);extrem hohes Fieber
-Schulanfang;Schulbeginn;Einschulung;Beginn der Schulzeit
-derart;solcherart;so;so sehr;dergestalt;so was von (ugs.);dermaßen
-Bundesverband;Bundesvereinigung
-entfleuchen;durch die Finger schlüpfen;entwischen;durch die Lappen gehen (ugs.);entrinnen;entfliehen;entgehen;nicht kriegen (ugs.);entweichen (geh.);entlaufen;durchs Netz gehen (ugs.);nicht erwischen (können) (ugs.);entkommen
-Fürsorge;Schutz;Sorge;Geborgensein;Aufsicht;Verfügungsgewalt;Verantwortung;Gewahrsam;Schutz und Schirm (formelhaft) (geh., veraltet);Fürsorglichkeit;Obhut;Geborgenheit
-Ressentiment(s) (geh.);Voreingenommenheit (Hauptform);Vorurteil;Befangenheit;vorgefasste Meinung;Vorbehalte
-eingearbeitet;hineingearbeitet;eingearbeitet (in)
-Kulleraugen (ugs.);große Augen (Hauptform);(feuchte) Kuhaugen (ugs., fig.);Kuhaugen (ugs., fig.);Glotzaugen (ugs.)
-Nordischer Laubsänger;Wanderlaubsänger
-Stärkung;Erquickung;Erfrischung
-Produkt;Fabrikat;Erzeugnis
-Aufnehmer;Feudel (norddeutsch);Scheuerlappen;Scheuertuch
-Proskynese;Kniefall;Niederwerfung
-rasend;turbulent;stürmisch;unruhig;ungestüm;hitzig;ungezügelt (selten);heftig;furios;wild;glühend
-Riemen;Ruder;Skull
-rein (ugs.);hinein;in
-Bürde;mühsame Sache (ugs.);Last;Belastung
-(sich) äußern;etwas von sich geben;reden;sprechen;(einen) Redebeitrag leisten;den Mund aufmachen (ugs., fig.);(das) Wort ergreifen;(eine) Äußerung tätigen (Amtsdeutsch);(seine / die) Stimme erheben;etwas sagen
-reden;sprechen;sagen
-Auslage;Schaufensterauslage
-kolorektal (fachspr.);Dick- und Mastdarm betreffend
-Systemberater;Systemanalytiker
-Abwandlung;Mutation (fachspr.);Derivat (fachspr.);Abart;Spielart (bildungssprachlich);Variante;Variation;Modifikation
-isotrop;gleich brechend;homogen
-deutlich werden;klar werden;einsichtig werden;einleuchten;erhellen;erleuchten
-Vorausdisposition;Vorausplanung
-Urteil;Entscheid;Entscheidung;Verdikt (veraltet);Urteilsspruch;Judikat (fachspr.);Spruch
-schlecht sitzend;schlecht passend
-VB;Verhandlungsbasis (Preis)
-venerisch (fachspr.);eine Geschlechtskrankheit betreffend
-Sachverhalt;Kern;Fall;Kernpunkt
-aufrufen (beim Arzt);hereinrufen
-wie abgesprochen;entsprechend den Vereinbarungen;wie vereinbart;wie besprochen;wie vorgesehen;wie diskutiert
-schlaff werden;welken
-Wettbewerbsfähigkeit;Konkurrenzfähigkeit
-VR;Virtuelle Realität;Virtual Reality;Virtuelle Wirklichkeit
-Schirm (ugs.);Anzeige;Anzeigegerät;Display (engl.);Monitor;Bildschirm (Hauptform)
-übermüdet;übernächtigt;unausgeschlafen
-Wo kommen wir (denn) da hin!? (ugs.);völlig ausgeschlossen;nicht mit mir! (ugs.);wo denken Sie hin!;das kannst du dir abschminken (ugs., fig.);vergessen Sie's! (ugs.);denk nicht mal dran! (ugs., Spruch);kommt nicht in die Tüte (ugs., Spruch, fig.);kommt (überhaupt) nicht in Frage (ugs.);daraus wird nix (ugs.);wo denkst du hin!;Ding der Unmöglichkeit (ugs.);da musst du früher aufstehen! (ugs., fig.);so gerne wie ich (etwas tun) würde, aber (geh.);träum weiter! (ugs., Spruch);daraus wird nichts;wo kämen wir (denn) da hin (,wenn ...)! (ugs., emotional);da könnte ja jeder kommen (und ...)! (ugs.);so haben wir nicht gewettet! (ugs.);Da kann ja jeder kommen! (ugs.);vergiss es! (ugs., Spruch);ausgeschlossen;unmöglich;beim besten Willen nicht (ugs.);da kannst du lange drauf warten (ugs.)
-Sterndeuter;Astrologe
-Haftreibung;Ruhereibung
-mit Wald bedeckt;waldbedeckt;bewaldet;waldig;waldreich
-Quadratmittel;Effektivwert
-Tetra (Kurzform);Tetrachlormethan;Tetrachlorkohlenstoff;Kohlenstofftetrachlorid;Tetrachlorkohlenwasserstoff
-Ausgleiten;Ausrutschen;Fehltritt
-Ausbleiben der Entwicklung eines Körperteils;Aplasie (fachspr.)
-erklettern;hochsteigen;besteigen;hochkraxeln (ugs.);steigen (auf);klettern (auf) (Hauptform);kraxeln (auf) (ugs.);hochklettern (ugs.);erklimmen
-exakt;zutreffend;richtig (Hauptform);korrekt;goldrichtig (ugs.)
-Bodenverfestiger;Bodenverdichter
-isotonisch;Zustand gleicher molekularer Konzentration
-Damm;Sturmflutbefestigung;Deich;Eindämmung;Kai;Uferdamm
-Lupe;Leseglas (ugs.);Vergrößerungsglas
-okular (fachspr.);das Auge betreffend
-bei alldem;obzwar (veraltend);wenngleich;dennoch;wiewohl;gleichwohl (geh.);obwohl (Hauptform);auch wenn;dabei;obschon;wennschon (geh., selten);obgleich;während;trotzdem (ugs.);bei alledem
-Verwertung;Verwendung;Nutzbarmachung;Auswertung;Ausnutzung
-(sich etwas) in den Bart murmeln (ugs.);(sich) etwas in den Bart brummeln (ugs.);nuscheln;murmeln;brummeln
-Mix;...cocktail (fig., journalistisch);Mischung;Gebräu;Melange;Gemisch;Cocktail (fig.);Mixtur
-Darstellung venöser Gefäße;Phlebografie (fachspr.);Phlebographie (fachspr.)
-Tochtergesellschaft;Tochterunternehmen;Tochterfirma;Unternehmenstochter;Tochter (Kurzform)
-nutzbringend;vorteilhaft;erstrebsam;ertragreich;profitabel;wirtschaftlich
-Zent (veraltet);Steuer;Zehnt (veraltet);Abgabe;Zehend (veraltet);Zehnter (veraltet);Zehent (veraltet)
-Kakerlak;Schabe;Küchenschabe;Kakerlake
-kumpelhaft;kameradschaftlich
-Quadratur des Kreises;Widerspruch in sich;Zusammenstellung einander widersprechender Begriffe;begrifflicher Widerspruch;Oxymoron
-präsynaptisch (fachspr.);vor einer Synapse gelegen
-Leukopenie;Leukozytopenie (fachspr.);Verminderung der Leukozytenzahl
-Ungeeignetheit;Untauglichkeit
-Epitheliom (fachspr.);Geschwulst aus Epithelzellen
-vergleichen;kollationieren
-Sparren;Dachsparren
-treten (auf);trampelt;stapfen;stampfen
-Pollenkörner;Blütenstaub;Pollen;Blütenpollen
-Maßregel;Maßnahme
-Kakophonie;Dissonanz;Kakofonie;Geschrammel (ugs., abwertend, salopp);Disharmonie;Misston;Missklang
-Abschattung;Tönung;Nuancierung;feiner Unterschied;Abstufung;Schattierung;Nuance;Zwischenstufe;Stich (in)
-UPU;Weltpostverein
-auf und davon;geflüchtet;weggelaufen;fort;ausgerissen;absent (veraltet);stiften gegangen (ugs., regional);geflohen;ausgeflogen (fig.);entflohen;getürmt (ugs., Jargon);(und) ward nicht mehr gesehen (pseudo-literarisch) (geh., Spruch, scherzhaft);nicht da;hat sich abgesetzt;ausgebüxt (ugs.);entkommen;weg (= fortgelaufen, weggefahren) (ugs., Hauptform);nicht mehr da (ugs.);flüchtig;über alle Berge (ugs., fig.);auf der Flucht;hat sich der Strafverfolgung entzogen;entfleucht (geh., altertümelnd, scherzhaft);abgängig (Amtsdeutsch);durchgebrannt;abwesend;abgehauen
-Verwaltungspraxis;Verwaltungsgepflogenheit
-ausgelassen;überbordend;sprudelnd (fig.);überschäumend (fig.);quirlig
-seit Langem;(schon) seit Monaten;(schon) seit Jahrzehnten;seit ewigen Zeiten (ugs.);(schon) seit langen Jahren;(eine) ziemliche Zeit (ugs.);ewig (ugs., fig.);längst;seit Längerem;eine ganze Weile (ugs.);(seit) ewig und drei Tage(n) (ugs.);seit einer ganzen Weile;längere Zeit;seit geraumer Zeit;seit Ewigkeiten;eine Zeitlang;schon lange;seit ewigen Jahren;(eine) ziemliche Zeitlang (ugs.);(schon) seit Jahren;geraume Zeit;lange schon (geh.);lange Zeit;seit längerer Zeit;schon eine ganze Zeit (ugs.);ewig lange;seit einer Ewigkeit (fig.);lange (Hauptform);lange Jahre;schon längst;seit vielen Jahren;(schon) seit Wochen;(schon) eine Weile (ugs.);bereits lange;seit einiger Zeit;schon eine (halbe) Ewigkeit (ugs.)
-großartige Sache;großer Erfolg;Bombenerfolg (ugs.)
-körperlich eingeschränkt (euphemistisch);behindert;gehandikapt (ugs.);gehandicapt (ugs.)
-Erledigung;Beseitigung;Eliminierung;Ausschluss;Elimination
-Programmstopp;Anhaltepunkt
-Schiedsabkommen;Schiedsvertrag
-schwören lassen (auf);jemanden vereidigen;(jemandem) den Eid abnehmen
-Schicklichkeit;Usus (ugs.);Gepflogenheit;Anstand
-Schiffstagebuch;Logbuch;Bordbuch
-Condyloma (fachspr.);Genitalwarze;Feigwarze;Feuchtwarze
-Gemüsebeet;Blumenbeet;Beet
-Bahnorbit;Orbit (fachspr.);Umlaufbahn
-Pinus mugo (fachspr., botanisch);Bergföhre;Bergkiefer (Hauptform)
-jedes Jahr;jährlich erneut;annual;Jahr für Jahr;jährlich wiederkehrend;pro Jahr;in jedem Jahr (wieder);jahrein, jahraus;per annum (fachspr., lat.);jedes Jahr wieder;alle Jahre wieder;alljährlich;jährlich (Hauptform)
-Permeabilität (fachspr.);Durchlässigkeit
-Stalagmit;stehender Tropfstein
-Trophotropie (fachspr.);Parasympathikotonie (fachspr.);Vagotonie (fachspr.)
-lichtbrechend;Brechungs...
-Menü;Befehlsübersicht
-Skrofuloderm;Skrofulose;Skrofeln
-weiblich;fraulich;feminin
-(auf jemanden) eindringen;(jemanden) in Bedrängnis bringen;belagern (ugs.);beknien;(jemanden) drängen (zu);bedrängen;(jemandem) die Hölle heiß machen (ugs.);(jemandem) auf die Pelle rücken (ugs.);(jemandem) auf den Pelz rücken (ugs.);(jemandem) zusetzen;löchern;nicht in Ruhe lassen (mit) (ugs.);drangsalieren;unter Druck setzen;(in jemanden) dringen (geh., veraltet);im Nacken sitzen;keine Ruhe geben (ugs.);bitteln und betteln (ugs.);traktieren;befallen
-(sich) verirren;(die) Orientierung verlieren;auf einen Irrweg geraten (sein) (auch figurativ);vom (richtigen) Weg abgeraten;in die falsche Richtung laufen;(den) falschen Weg einschlagen;den Weg verfehlen;vom Weg abirren;(sich) verlaufen (Hauptform);nicht mehr wissen, wo man ist;fehlgehen (geh.);auf einen Abweg geraten (sein) (auch figurativ);vom Weg abkommen;nicht zurückfinden
-innewohnen;vorkommen in
-gezapft;angezapft (Fass);(Bier) vom Fass
-philisterhaft;spießbürgerlich
-Pyrexie (fachspr.);hohe Temperatur (ugs.);Fieber
-philologisch;sprachwissenschaftlich
-Kichern;leises Lachen;Glucksen
-Schulstunde;Stunde (ugs.);Unterrichtsstunde (Hauptform);Lehrstunde
-uneingeschränkter Machthaber;Unterdrücker;Zwingherr (geh., historisch);Gewaltherrscher;Diktator;Tyrann;Despot (geh.)
-Blackout;Alzheimer (sarkastisch-übertreibend) (ugs.);Aussetzer (ugs.);Black-out;keine Erinnerung (an);Erinnerungslücke;Gedächtnislücke;zeitweises Aussetzen des Gedächtnisses
-untief;flach;seicht
-die Fortbewegung betreffend;lokomotorisch (fachspr.)
-platter Reifen;Platten (ugs.);Reifenpanne
-in Verbindung bringen;verbinden;assoziieren;verknüpfen;verketten
-Nuntius;Vermittler;Legat;Unterhändler
-marktfähig;handelbar;in Geld umwandelbar;monetarisierbar;absatzfähig;handelsfähig;liquidierbar
-Konkurserklärung;Zahlungsunfähigkeitserklärung;Bankrotterklärung;Insolvenzerklärung;Zahlungseinstellungserklärung
-sacht;zart;zärtlich;behutsam;liebevoll;lieb;sanft;einfühlsam;auf die sanfte Tour (ugs., ironisierend)
-Versteigerer;Auktionator
-wes (geh., veraltet);wovon;worüber;woran;woraus
-nachweisen;(den) Nachweis erbringen;(den) Beweis antreten (für);zeigen;belegen;bestätigen;aufzeigen;(den) Beweis erbringen (für);beweisen;(eine These) stützen
-Bravourstück;Geniestreich;Meilenstein (fig.);Bravurstück (alte Schreibung bis 2017);Glanzstück;Bravourleistung;Meisterstück;Ruhmesblatt (geh.);Großtat;Glanznummer;Bravurleistung (alte Schreibung bis 2017);großer Wurf;Meisterwerk;Meisterleistung
-Stromversorgungseinheit;Netzteil
-früh entwickelt;früh pubertierend;früh pubertiert;(sexuell) frühreif
-barock;schnörkelhaft;verschnörkelt;arabesk;manieriert (geh.);schnörkelig;überladen
-seriell;in Serie;serienmäßig;nacheinander;sequentiell
-Beiheften;Anheften
-scheitern;durchfallen;durchrasseln (ugs.);ablosen (ugs.);(eine Prüfung) nicht bestehen;mit Pauken und Trompeten durchfallen (Verstärkung);versagen
-überholen;einholen;übertreffen
-Beraubung;Raub;Raubüberfall;Räuberei
-Kreditrisiko;Ausfallrisiko;Adressrisiko;Adressenausfallrisiko
-streifen;leicht berühren;touchieren (geh.);tangieren (geh.);antasten
-Knotenpunkt;Anschluss
-(dort) zu Hause;domiziliert sein (schweiz.);mit Sitz in;seinen Wohnsitz haben;ansässig sein;wohnhaft (sein);(irgendwo) gemeldet sein;residieren;(sich) aufhalten;(seinen) gewöhnlichen Aufenthalt haben (Verwaltungsdeutsch)
-Zusatzsteuer;Steueraufschlag
-Pflanzer;Kossäte (norddeutsch);Farmer;Grundbesitzer;Landwirt;Bauer;Agrarier;Sämann;Landmann (veraltend)
-Spasmus;Krampf;Muskelkrampf;Verkrampfung
-rückseitig;dahinter;endend;hinten;am Ende stehend
-jemanden reinlegen;jemandem die Treue brechen;jemanden betrügen;jemanden hintergehen
-losstürzen;hastig aufbrechen;loslaufen
-Ersatzmine;Ersatzkartusche;Ersatzpatrone
-feinfühlig;zartfühlend;weich;zart;empfindlich;feinfühlend
-ableiten;umleiten
-hängen an;(sich) anschließen an
-pressant;höchste Zeit (ugs.);vordringlich;es bleibt wenig Zeit;(die) Zeit drängt;bedrohlich nahekommen (Termin);zeitkritisch (fachspr., Jargon);vorrangig;(es ist) 5 vor 12 (fig.);höchste Eisenbahn (ugs.);in engem Zeitrahmen zu erledigen;dringend;(es ist) allerhöchste Eisenbahn (ugs.);(es ist) Eile geboten (geh.);(es ist) an der Zeit;brandeilig;(es ist) allerhöchste Zeit;eilig;(es ist) fünf vor zwölf
-Domino;Dominospiel
-absurd;antinomisch (fachspr., bildungssprachlich);kontradiktorisch (fachspr.);widersprüchlich;inkohärent (fachspr., bildungssprachlich);paradox;folgewidrig (fachspr.);(sich) widersprechend;widersinnig;konträr (geh.);irrational;unlogisch;inkonsistent (fachspr., bildungssprachlich)
-Nutrition (lat.);Ernährung;Ernährungsweise
-Wirklichkeitsflucht;Weltflucht;Realitätsflucht;Eskapismus
-Ostmeer;Japanisches Meer
-schräg (ugs.);einmal anders (nachgestellt);unnormal;kurios;atypisch;aus der Reihe fallen(d);uncharakteristisch;ausgefallen;außergewöhnlich;ungewöhnlich;der besonderen Art;untypisch;speziell
-Ehegatte;Gespons (veraltet);bessere Hälfte (scherzhaft);Göttergatte (spöttisch) (ugs.);Ehepartner;Gemahl;Partner;Lebensgefährte;Gatte;Mann;Angetrauter;(jemandes) Macker (ugs.);Ehemann (Hauptform);(jemandes) Männe (ugs., regional);(jemandes) Kerl (ugs.);Mustergatte (leicht ironisch) (ugs.);(jemandes) Alter;Ehegespons
-Stimmrecht;Wahlberechtigung;Wahlrecht
-Wasserstoffperoxyd;Wasserstoffperoxid;Wasserstoffsuperoxid;Wasserstoffsuperoxyd
-(es .. einfach) nicht mehr gehen (ugs.);duhne (ugs., rheinisch);lasch;alle (ugs.);in den Seilen hängen (ugs.);ausgepowert (ugs.);saft- und kraftlos;nüntig (ugs., schweiz., selten, vorarlbergerisch);matt;abgeschlafft;down (ugs., veraltend);geschafft (ugs.);fix und foxi (ugs., scherzhaft, veraltet);schlapp;schlaff;kaputt (ugs.);kraftlos;platt (ugs.);daneben (ugs.);lurig (ugs., rheinisch);groggy (ugs.);ohne Saft und Kraft (ugs.);ausgelutscht (ugs.);keine Energie mehr haben
-Wärmeschutz;Wärmedämmung;Wärmeisolierung
-Anwendungsgebiet;Anwendungsbereich
-Lappen (derb);Schein (ugs.);Banknote;Nötli (ugs., schweiz.);Geldschein;Note;Papiergeld;Notenschein
-Angebotseinholung;Ausschreibung
-Zunahme;Verbreiterung
-Arthritis (fachspr.);Gelenkentzündung
-Bastelei;Bastelarbeit;Bastelkram (ugs.);Gebastel (ugs.)
-Sondervergütung;Zusatzvergütung;Prämie (Hauptform);Incentive (fachspr., Jargon, engl.);Sonderzulage;Gratifikation;Sonderzuwendung
-elektronische Post;E-Mail;E-Mail-Dienst
-Freistellung;Dispens;Befreiung
-psychoaktiv;auf die Psyche wirkend;psychotrop (fachspr.)
-Mittelamerika;Zentralamerika
-diskriminierend;voller Verachtung;von oben herab;missbilligend;naserümpfend;abfällig;verächtlich;despektierlich (geh.);verachtungsvoll;gönnerhaft;absprechend;herablassend;abwertend;gleichgültig;abschätzig;respektlos;missfällig (geh.);gnädig;pejorativ (fachspr., linguistisch);geringschätzig
-Differenzierer;Differenzierglied
-Schätzpreis;Schätzungspreis
-Veranlagung;(die) Gene (simplifizierend) (ugs.);Erbanlage
-Ungehorsam;Widersetzlichkeit;Unfolgsamkeit;Widerstand;Unbotmäßigkeit;Aufmüpfigkeit;Gegenwind (ugs., fig.);Insubordination;Gegenwehr;Widerworte;Aufbegehren
-Randbemerkung;Glosse (fachspr.)
-Wertpapier;Wertschrift (schweiz.);Effekten (Plural);Handelspapier;Papier (ugs.)
-eitrig;purulent (fachspr.)
-Kreuzgelenk;Universalgelenk;Kardangelenk
-Beförderung;Aufstieg
-plötzlicher Kindstod;plötzlicher Säuglingstod;Krippentod
-Klimpergeld (ugs.);Kleingeld;Kupfer (ugs.);Hartgeld;Taler (ugs.);Münze;Münzgeld;Geldstück
-Umrechnungsfaktor;Konvertierungsfaktor
-Effemination;Weiblichkeit;Fraulichkeit
-Lautsprecher (Hauptform);Brüllwürfel (ugs., abwertend, scherzhaft);Klanggeber
-Bekleidung (eines Amtes);Besetzung (einer Stelle)
-anschlagen;anstechen;anzapfen
-kraftlos werden;versagen;schlapp machen;erschlaffen;nachlassen;am Ende seiner Kräfte sein;ermüden;die Kräfte verlieren;erlahmen;abkacken (derb);müde werden;nicht mehr (weiter) können;am Ende sein (ugs.);ermatten;schlappmachen;abbauen
-Bitversatz;Schräglauf
-gedrängt;fest;massiv;dicht;eng
-Büttel (veraltet);Saaldiener;Fronbote;Gerichtsdiener;Amtsdiener
-besitzanzeigendes Fürwort;Possessivpronomen
-Entzündung des Herzbeutels;Perikarditis (fachspr.)
-Dreingabe;Draufgabe (österr.);Zugabe;Bonbon (fig.);Zusatzbonbon (ugs., fig.);Nachschlag;Special (fachspr., Jargon, engl.);(ein) Extra;Bonus;Naturalrabatt;Beigabe
-Untersuchung (über);Erhebung;Erfassung;Standortbestimmung (ugs.);Umfrage;Stimmungstest (ugs.);Nachforschung;Enquete;Befragung;Erkundigung
-Passivierung;Deaktivierung;Abschaltung
-Fachgeschäft;Fachmarkt;Spezialgeschäft;Fachhändler
-die erste Geige spielen (ugs., fig.);führend sein;(die) Kontrolle behalten (über);das Heft in der Hand haben (fig.);das Kommando haben (auch figurativ, militärisch);(der) Chef von't Janze sein (ugs., berlinerisch);(der) Chef sein (ugs., fig.);den Ton angeben;sagen, wo es langgeht (ugs.);vorangehen;(die) Kontrolle haben (über);führen;kontrollieren;das Heft in der Hand halten (fig.);leiten (Hauptform);(den) Takt vorgeben (fig.);das Sagen haben (ugs.);dominieren;die Richtschnur vorgeben (ugs.);lenken;was zu sagen haben (ugs.);(die) Leitungsfunktion innehaben (Papierdeutsch)
-Zugangsliste;Erfassungsliste
-(jemanden) persönlich angreifen;(etwas) persönlich meinen;persönlich werden;unsachlich werden
-Wasserstrudel;Strudel;Wirbel
-quieksen;pfeifen;piepen;fiepen;fiepsen (ugs.);quieken;piepsen
-(etwas) in großer Menge ansammeln;(sich) eindecken (mit);bunkern (ugs.);(etwas) bevorraten (Jargon);Vorräte anlegen (Hauptform);horten;(sich) bevorraten (mit) (Jargon);hamstern (ugs.)
-Spachtel;Spatel
-Verschiedenartigkeit (Hauptform);Inhomogenität;Ungleichartigkeit;Disparität;Heterogenität;Uneinheitlichkeit
-Kelch;Kelchglas;Gral (fachspr.);Becher
-zyklisch;wiederkehrend;regelmäßig;wiederholend;turnusmäßig;periodisch
-Unversehrtheit;Unbescholtenheit;Integrität
-um es einmal so zu sagen;sozusagen;gewissermaßen;auf gewisse Weise
-etwas dämpfen;etwas überschatten;etwas lähmen
-Sammelstelle;Meetingpoint;Sammelplatz;Sammelpunkt;Treffpunkt;Tummelplatz
-Gelenkschmerz;Arthralgie (fachspr.)
-Gewindekontrollapparat;Gewindekomparator
-im Sinne als;hinsichtlich;in Form von
-(sich) beharken;in Streit liegen (mit);auf Kriegsfuß stehen (mit jemandem) (fig.);(sich) in den Haaren liegen (ugs.);(mit jemandem) im Dauerstreit liegen (Hauptform);im Streit liegen;(sich) in den Haaren haben (ugs.);(jemanden) befehden (altertümelnd);über Kreuz liegen (mit);(sich) herumzanken (ugs.);(sich) herumstreiten (ugs.);(mit jemandem) im Clinch liegen (ugs.)
-Teilhaber;Kompagnon;Mitbesitzer;Partizipant
-surren;schwirren;strudeln;flattern
-Junge;Bauer (Kartenspiel);Unter (Kartenspiel);Wünscher;Bube
-Berechnung;Anrechnung
-Recherche;Überprüfung;Nachschau (Amtsdeutsch);Abfrage
-nichts anhaben;entblättert;blank;nackt (Hauptform);hüllenlos;splitterfasernackt (ugs.);unbekleidet;barfuß bis zum Hals (ugs.);entkleidet;im Evakostüm (weibl.);entblößt;splitternackt (ugs.);nackend (regional);pudelnackt (ugs.);nackicht (ugs.);mit bloßer Haut;im Evaskostüm (weibl.);enthüllt;nackert (ugs., süddt.);im Naturzustand (scherzhaft);ausgezogen;nackig (ugs.);wie Gott ihn schuf (männl.);wie Gott sie schuf (weibl.);im Adamskostüm (männl.);textilfrei
-Aktionär;Teilhaber;Aktieninhaber;Aktienbesitzer;Shareholder (engl.);Anteilseigner
-von den Toten auferstehen;beinahe draufgehen bei (derb, variabel);dem Tod ein Schnippchen schlagen (fig.);dem Tod von der Schippe springen (fig.);knapp überleben;wieder auferstehen (von den Toten) (biblisch);reanimiert werden;noch einmal mit dem Leben davonkommen
-die Funktion betreffend;funktionsgemäß;funktionell;funktional
-kleinflächige Hautblutung;Ekchymose (fachspr.)
-Flucht;Durchbrennen;Fliehen;Entkommen;Abhauen (ugs.)
-Selbstkenntnis;Selbstbewusstsein;Bild von sich selbst;Selbstkonzept;Selbstwahrnehmung
-Entbehrung;Armut;Not;Mangel;Kargheit;Armseligkeit;Dürftigkeit
-Spaltung;Teilung;Aufspaltung;Trennung;Aufsplittung
-nachrennen;nachlaufen;hinterherlaufen;hinterherrennen
-Wirsingkohl;Welschkraut;Kohl (österr.);Wirz (schweiz.);Wirsing;Welschkohl
-Lötstelle;Lötverbindung;Lötung;Lötnaht
-Repetition;Wiederauftauchen;Iteration (fachspr.);Turnus;Rückkehr;(periodische) Wiederkehr;Wiederaufflammung;Rotation;Wiederholung
-verboten;verpönt;tabu;nicht zugelassen;(strikt) untersagt;nicht erlaubt
-mit Flecken übersät;(lauter) Flecke haben;Flecke aufweisen;fleckig;verfleckt;voller Flecke;besudelt;befleckt
-Tratschereien;Flurfunk (ugs.);Klatsch und Tratsch (Hauptform);Gerede;Klatscherei;Getratsch(e);offenes Geheimnis;Bürogeflüster (ugs.);Altweibergeschwätz (ugs., abwertend, fig.);Gerüchteküche;Getratsche (ugs.);Lästerei(en) (ugs.);Ratscherei (ugs., süddt.);Klatsch;Gossip (engl.);Buschfunk (ugs.);Stadtgespräch;Gequatsche (ugs.);Tratsch;Klatschgeschichten
-Häutung;Haarwechsel;Mauser
-Abbildung;Ebenbild;Illustration;Darstellung;Bildnis;Bild
-Vergeltung;Revanche;Retourkutsche (ugs.);Quittung (ugs.);Rache
-Lage;Schicht;Bögen Papier (Buchbinden)
-auschecken;ausbuchen
-wahrhaft;ehrbar;kreuzbrav;lauter;treu und brav;das Herz am rechten Fleck haben (fig., sprichwörtlich);anständig;redlich;rechtschaffen;honett (geh.);ehrlich;grundehrlich;grundgut;aufrichtig;fair;grundanständig;veritabel;patent;treu;geradeheraus;unverstellt;lauteren Herzens (geh., veraltend);aufrecht
-Austreiben;Desorption
-(die) Früh(e);Morgenstund (literarisch);Morgen;Tagesanbruch;Morgenstunde
-ausweiten;(sich) weiten
-Kickstarter;Tretanlasser
-zusätzliche;alternative;andere;weitere;übrige;sonstige
-Fürsprecher;Fürbitter;Lobbyist
-Span;Schnitzel;Splitter;Spleiß;Schiefing (ugs., bayr.);Speil;Speu (ugs., österr.);Holzsplitter (Hauptform);Spanholz;Speudel (ugs., österr.);Schiefer (ugs., bayr., österr.);Spreißel (süddt.);Spältel (ugs., österr.)
-entfernt;fern;weit
-Rücksichtnahme;Rücksicht (auf)
-Rentenempfänger;Rentenbezieher;Rentner;Rentier;Ruheständler;Pensionsbezieher;Pensionär;Pensionist (österr.)
-Spannstift;Spiralspannstift
-Atrium (fachspr.);Vorhof des Herzens
-Kreditbeanspruchung;Anleihen
-Luftschlucken;Aerophagie (fachspr.)
-spürbar;tastbar;fühlbar;palpabel (fachspr.)
-Kebab;Fleischspieß
-alle paar (...) mal (ugs.);verschiedene Mal(e);mehr als einmal;des Öfteren (geh.);öfters (ugs.);gerne (mal);etliche Male;mehrmals;nicht selten;wiederholt;des Öftern (geh.);nicht gerade selten (ugs.);ein paarmal;mehrfach;öfter (Hauptform);vermehrt;häufiger;öfter (schon) mal;verschiedentlich
-präzise;spezifisch;gezielt;präzis
-Harnvergiftung;Urämie (fachspr.)
-(Lust) verderben;(Spaß) verderben
-(sich) (beruflich) neu orientieren;wechseln;umsteigen (ugs., fig.);(sich) verändern;(sich) (beruflich) umorientieren;umsatteln (ugs., fig.);umschulen
-Baschkirien;Baschkortostan
-aufrühren;umrühren;rühren;aufwühlen
-Betriebskosten;laufende Kosten;Unterhaltskosten
-Schelle;Clipschelle;Taschenklemme;Klemme
-Höker (veraltet);Inhaber eines Tante-Emma-Ladens;Krämer;kleiner Krauter (ugs.);Besitzer eines Kramladens;Kleinhändler
-Selbstbeherrschung;Disziplin;Selbstdisziplin
-Äquinoktium (fachspr.);Tagundnachtgleiche;Equinox (lat.);Tag-und-Nacht-Gleiche
-Strebe;Stützbalken
-Wischer;Abstreifer
-gerichtsmedizinisch;forensisch
-den Hals betreffend;zervikal (fachspr.)
-Retter in der Not;Helfer;Retter;rettender Engel;Helfer in der Not
-(sich) etwas aufladen;schleppen;tragen;transportieren
-Kleber (ugs.);(die) Klebe (ugs.);Adhesiv (fachspr.);Klebstoff;Leim
-Mittagsmahlzeit;Mittagessen (Hauptform);Lunch (engl.)
-Verkleben;Festkleben;Kleben
-(einem illegalen / fragwürdigen / finsteren ...) Treiben ein Ende machen;(einen) Sumpf trockenlegen (fig.);(eine Handlung) stoppen;dafür sorgen, dass etwas aufhört (ugs.);unterbinden;(einer unliebsamen Aktivität) ein Ende bereiten;(einen) Sumpf austrocknen (fig.);inhibieren (fachspr.);(jemandem) das Handwerk legen (fig.);(einer unerwünschten Aktivität) einen Riegel vorschieben (fig.);(jemandes) Treiben ein Ende setzen
-Weggefährte;Gefährte;Begleiter;Wegbegleiter
-Messfühler;Fühler;Detektor;Sensor;Messwertgeber
-Abschlagsdividende;Zwischendividende
-(einen Preis) verleihen;zusprechen;erteilen;zuerkennen;vergeben
-Service (engl.);Dienst;Dienstleistung
-Fluglinie;Airline;Luftfahrtgesellschaft;Fluggesellschaft;Luftverkehrsgesellschaft
-Schussbereich;Schussweite
-Prozession;feierlicher Umzug;Festzug
-Gewölbe;Kuppel;Dach
-separieren (fachspr.);abmachen;ablösen;abtrennen;abhängen (ugs.);loseisen (ugs.);entfernen;abkuppeln (ugs.);trennen;loslösen
-Geschwader;Schwadron
-schlagen;stoßen
-Operation;Handlung;Aktion;Kampagne
-Frühe;Frühzeitigkeit
-Teppichratte (ugs.);Stöpsel (ugs.);Kleinkind;kleines Kind
-Gynäkologe;Frauenarzt;Facharzt für Frauenheilkunde
-alle zwei beide (ugs., scherzhaft);zwei;die zwei;alle beide (ugs.);alle zwei;beide;die beiden;die zwei beiden (ugs., scherzhaft)
-Priapismus (fachspr.);schmerzhafte Dauererektion des Penis
-Ausbrennen;Ätzung;Kauterisieren
-Vorlast;Preload (fachspr.)
-liberalisieren;freigeben;entblocken
-Schläger;Schlägertyp;Rambo;Haudrauf (ugs.);Radaubruder;Raufbold;Schulhofschläger;Rowdy
-Ohrentzündung;Otitis (fachspr.)
-geschmeidig;streckbar;biegsam;duktil
-tropentauglich;tropenfest
-Rückhalt;Rücklage;Rückstellung
-planen;ausarbeiten;abbilden
-abgestuft;stufig
-Nachschub;Zufuhr
-Schwangerschaftsunterbrechung;Abtreibung (ugs.);Abort (fachspr.);Schwangerschaftsabbruch;Abortion (fachspr.);induzierter Abort (fachspr.)
-Dicke;Steifigkeit;Festigkeitsgrad;Festigkeit
-Schularbeit (österr.);Test;Lernerfolgskontrolle (Amtsdeutsch);Klassenarbeit;Leistungsüberprüfung (Amtsdeutsch);Prüfung;Schulaufgabe (bayr.);Arbeit (ugs.);Klausur
-Aktivierung;Anschaltung;Inbetriebnahme;Start;Einschaltung
-zusammenfassen;umfassen
-maschinenorientiert;maschinennah
-Rechnersystem;Computersystem
-Heldentum;Heroismus;Heldenmut;Mannhaftigkeit
-Punziereisen (Hauptform);Bunze (veraltet);Punze
-abschalten;deaktivieren;stilllegen;inaktivieren;passivieren;ausschalten
-gammeln (ugs.);verkommen;modern;vergammeln;vermodern;verlottern (ugs.);verfaulen;verfallen;verrotten;verwesen;faulen;herunterkommen
-Einkerbung;Notch (Smartphone);Ausschnitt;Einschnitt;Aussparung;Einbuchtung
-(sich) zerstreuen;(sich) auflösen (Menschenmenge)
-Kaninchenloch;Kaninchenbau;Hasenloch;Kaninchenhöhle
-Übellaunigkeit;Dysphorie (fachspr.);Missstimmung;Gedrücktheit
-Wohlwollen;Zugewandtheit (geh.);Geneigtheit;Huld (geh., veraltet);Gunst;Gewogenheit
-prickeln;kribbeln
-Inger;Schleimaal
-befindlich;gelegen;angesiedelt
-Bevölkerungsfonds der Vereinten Nationen (politisch);UNFPA (Abkürzung, engl.)
-Briefhülle;Umschlag;Briefcouvert;Kuvert;Enveloppe (veraltet);Briefkuvert;Briefumschlag;Couvert (schweiz.)
-Breite;Stärke;Umfang;Weite;Dicke
-Gefolgschaft;(jemandes) Mädels (ugs.);Gefolge (eines Prominenten);Eskorte;(im) Schlepptau;Tross;Höfling (geh., veraltet);Hofstaat (ironisch, veraltet);Entourage;(jemandes) Jungs (ugs.);Gefolgsleute;Begleitperson;(jemandes) Leute (ugs.);Hofschranze (geh., veraltet);Anhang;Schranze (geh., veraltet);Begleitung
-(nationale) Souveränität;Landeshoheit
-Nase (ugs.);Vorsprung;vorstehender Teil
-landschaftlich;szenisch
-Zielerreichung;Zielrealisierung
-entsagen;verzichten;entbehren können;entbehren;entraten (veraltet);passen (müssen)
-Fachwortschatz;Thesaurus
-überflüssig;redundant (fachspr.);überreichlich;pleonastisch;überzählig;mehrfach;doppelt;doppelt gemoppelt (ugs.)
-geplant;an langfristigen Zielen ausgerichtet;langfristige Ziele verfolgen(d);wohlüberlegt;strategisch;absichtlich
-lange Zeit;stark;nachhaltig;tief;lange
-glücklich davonkommen;(noch einmal) Glück gehabt;(noch einmal) Schwein gehabt (ugs.)
-Stiefelhose;Breeches (engl.);Reithosen;Jodhpur (indisch)
-Dotierungsstoff;Dotiermittel;Dotand
-schlechtmachen;abwerten;diskreditieren (geh.);in Misskredit bringen;niedermachen;mobben (ugs.);abkanzeln;herabwürdigen
-Stimulator;Anreger;Signalgeber;Reizgeber
-Zeichenvorrat;Zeichenmenge;Zeichenrepertoire
-Kainutzungsgebühr;Hafengebühr;Ufergeld (fachspr.);Werftgebühr
-Auf der Alm, da gibt's koa Sünd. (ugs., scherzhaft, sprichwörtlich);ländlich;dörflich;ländlich-sittlich (ugs., ironisch);provinziell;kleinstädtisch
-periodisch;konjunkturell
-belangvoll (geh.);tiefsinnig;nachdenklich;tiefgründig;mit Tiefgang;gehaltvoll;tief gehend;in die Tiefe gehend;tiefschürfend;profund;tiefreichend;tiefgehend;tief schürfend;durchdacht
-(sich) hinwegsetzen (über);(einer Vorschrift) zuwiderhandeln (juristisch);verstoßen (gegen)
-Endbenutzer;User;Endanwender
-Festigung;Bindung;Befestigung
-Flüchtigkeit;Variabilität;Wankelmut;Veränderlichkeit;Wandlungsfähigkeit
-Gerechtigkeit;Recht
-(jemanden) abreiben (ugs.);jemanden verbimsen (ugs.);(jemanden) züchtigen;(eine) Tracht Prügel verabreichen;körperlich bestrafen;(eine) Tracht Prügel geben;jemanden verkloppen;jemanden vermöbeln;jemanden vertobaken (ugs., norddeutsch);langen Hafer geben (selten);jemanden verwamsen (ugs.);jemandem eine Naht verpassen (ugs.);(jemandem) den Hintern versohlen;(jemanden) verprügeln;(jemandem) den Hosenboden strammziehen (ugs.);(jemanden) übers Knie legen
-Emblem;Insigne;Abzeichen;Medaille;Plakette
-ableiten;abfließen lassen;unterlassen;ablassen
-eintunken;tunken;eintauchen;stippen (ugs.);tauchen
-Falsifikation (geh.);Falsifizierung (geh.);Gegenbeweis;Gegenargument;Widerlegung;Entkräftung;Einwand;E;Elenchus (geh., griechisch, lat.)
-Fleckentferner;Fleckenreiniger
-Gestell;Stellage;Ständer;Rack (engl.)
-dem Wind zugewandte Seite;Luv;dem Wind zugekehrte Seite;Windseite
-Type (Drucktechnik);Durchschuss
-groß angelegt;im großen Stil;im großen Rahmen
-Aktienportfolio;Aktienbestand;Aktienportefeuille
-Verzagtheit;Kleinmütigkeit;Kleinmut;Angst vor der eigenen Courage (ugs.);Ängstlichkeit;Defätismus (geh.);Decouragiertheit (geh.);Furchtsamkeit;Mutlosigkeit;Defaitismus (geh., schweiz.)
-schlechter werden;(sich) verschlechtern (Hauptform);(sich) verschlimmern;(sich) verschärfen;(sich) zum Negativen verändern;ausufern (ugs.);bergab gehen (mit) (fig.);schlimmer werden;(den) Bach runtergehen (ugs., fig.)
-Steinmetzarbeit;Maurerhandwerk;Maurerarbeit
-versperren;reingrätschen (ugs., fig.);Steine in den Weg legen (ugs., fig.);hemmen;(sich) querstellen (ugs.);(jemandem) Knüppel zwischen die Beine werfen (ugs., fig.);abblocken (auch figurativ);(jemanden) abwehren (Hauptform);(sich) sperren;quer im Stall stehen (ugs.);(sich jemandem) in den Weg stellen (fig.);(ein) Hemmnis bilden;blocken (ugs.);(den) Weg versperren (fig.);stoppen (Pläne, Verfahren, Vorgang);mauern (ugs.);(jemandem) entgegentreten;verhindern;obstruieren;abhalten;nicht mitspielen;behindern;blockieren;hindern
-Dachgesims;Dachüberhang;Dachvorsprung
-Erstaunen;Verblüffung
-Formation;Herausbildung;Anordnung
-Zwischenstadium;Übergangsstadium
-Marktbefragung;Marktumfrage;Marktanalyse;Markterhebung
-rachedurstig;rachsüchtig;rachgierig
-automatisches Schnellfeuergewehr;Sturmgewehr;Schnellfeuergewehr;vollautomatisches Gewehr;Maschinenkarabiner (veraltet)
-Presspassung;Presssitz
-Tumor;Geschwulst;Gewebewucherung;Wucherung;Auswuchs;Raumforderung;Exkreszenz (fachspr., lat.);Wulst;Neoplasie (fachspr.);Neubildung
-Rinde;Borke
-Zusammenhalt;Geschlossenheit
-berichtigen;emendieren (fachspr., selten);ausbessern (ugs.);überarbeiten;korrigieren;fixen (ugs.);verbessern;ausbügeln (ugs.)
-in übertragenem Sinne;metaphorisch;übertragen;uneigentlich;im übertragenen Sinn;im übertragenen Sinne;tropisch;figürlich;figurativ;bildlich
-Projektion;Ansicht;Aufrisszeichnung;Aufriss
-Schiffseigner;Reeder;Schiffseigentümer
-Leumund;Ansehen;Bild;Stellung;Image;Prestige;Renommee;Reputation;Namen;(guter) Ruf
-zappeln;strampeln
-(wie) leer gefegt (Straße, Platz ...) (ugs.);unbewohnt;wie ausgestorben;entvölkert;(wie) leergefegt (Gebäude, Verkehrsweg ...) (ugs.);einsam und verlassen;menschenleer;gottverlassen;verwaist (fig.);keine Menschenseele (ugs.);verlassen;öde;öd;kein Mensch weit und breit
-Verrechnungsstelle;Abrechnungsstelle
-zurückbauen (fachspr., verhüllend);einreißen;rückbauen;dem Erdboden gleichmachen;plattmachen (ugs., fig.);abreißen;wegreißen
-Weitung von Blutgefäßen;Vasodilatation (fachspr.)
-Detail;Einzelheit (Hauptform);Faktum;Spitzfindigkeit
-Sibirische Drossel;Schieferdrossel
-beschränken;knausern;restringieren (geh., bildungssprachlich);(jemanden) knapphalten;einschränken
-Internationale Organisation für Standardisierung;ISO
-nölen (ugs.);(sich) auskotzen (über) (derb);(seinen) Frust loswerden (wollen) (ugs.);reklamieren (schweiz.);herumkritisieren (an);immer (et)was auszusetzen haben;Frust ablassen (ugs.);raunzen (ugs., österr.);immer (et)was zu meckern haben;motzen (ugs.);räsonieren;abkotzen (derb, fig.);(seinen) Frust rauslassen (ugs.);mosern (ugs.);pöbeln (ugs.);beckmessern;nörgeln (ugs., Hauptform);meckern (ugs.);(etwas) bekritteln;(etwas) bemäkeln;mäkeln;(seinem) Ärger (über / auf etwas) Luft machen;(sich) unzufrieden äußern;murren;granteln (ugs., bayr., österr.);(sich) beschweren;quengeln (ugs.);(sich) beklagen (über);maulen (ugs.)
-Wundliegegeschwür;Druckulkus;Druckgeschwür;Dekubitalulkus;Wundliegen;Dekubitalgeschwür;Dekubitus (fachspr.);Decubitus (fachspr., medizinisch)
-Zwischenraumtaste;Space;Leertaste
-Gestapo;Geheime Staatspolizei
-Stanzen;Lochen
-vorsehen;Ausgaben einplanen;(Mittel) bewilligen;(einen) Haushaltstitel einrichten (erstellen / anlegen / erzeugen...) für;in den Haushalt einstellen
-Funktion;Aufgabe;Zweck;Rolle
-zupfropfen;verstopfen;obliterieren (fachspr., lat., medizinisch)
-ätzen;radieren
-Inflation (Hauptform);Preissteigerung(en);Aufblähung der Geldmenge (fachspr.);Verteuerung;Teuerung (veraltend);Kaufkraftverlust;Teuerungsrate;Preisauftrieb;Preisanstieg;Geldentwertung
-Verheißung;Prophezeiung;Weissagung;Voraussage (Hauptform);Blick in die Glaskugel (fig.)
-Übersetzerprogramm;Translator;Übersetzungsprogramm
-Ausgaben;Auflageziffern;Auflage
-Preview (fachspr., Jargon, engl.);Thumbnail (fachspr., Jargon, engl.);Miniatur;Vorschaubild;Minibild
-Trismus (fachspr.);Krampf der Kaumuskulatur
-Denkungsart;Weltanschauung;Auffassung vom Leben;Weltverständnis;welches Sinnes (veraltet);Geisteshaltung;Grundüberzeugung;Weltsicht;Ideologie;welchen Sinnes (geh.);wes Geistes Kind;aus welchem Holz jemand geschnitzt ist (ugs., fig.);wes Sinnes (veraltet);(die Art) wie jemand gestrickt ist (ugs., fig.);ideologischer Standort;(jemandes) Sicht der Dinge;geistiger Standort;Philosophie;Grundeinstellung;Weltauffassung;Weltbild;Grundhaltung;Wertauffassung;Denke (ugs.);Denkweise;(die Art) wie jemand tickt (ugs., fig.);Gesinnung;Sinnesart
-(der) Akt (süddt., österr.);Urkunde;Akte;Dossier (schweiz.)
-Herzinnenhautentzündung;Endokarditis (fachspr.)
-heiratsfähig;ehemündig
-Hangar;Flugzeughalle
-Matura (schweiz., österr.);Studienberechtigung;Hochschulzugangsberechtigung (fachspr., Amtsdeutsch);Hochschulreife;Maturität (schweiz.);Gymnasialabschluss;Abi (ugs.);Allgemeine Hochschulreife;HZB (fachspr.);Abitur
-unerzogen;schlecht erzogen;ungezogen
-Zuckerrübensirup;Rübenkraut;Rübensirup
-Volk;Personen;Menschen;Leute
-Geschoß (österr.);Etage (franz.);Geschoss;Flur;Stock;Stockwerk
-schwängern;(einer Frau) ein Kind machen (ugs.);(ein) Kind ansetzen (ugs.);befruchten (fachspr.)
-Leichnam;sterbliche Überreste;Leiche;Toter;sterbliche Hülle;toter Körper
-vorweisen;vorzeigen
-Honigwabe;Wabe
-abnutzen;ausleiern (ugs.);verschleißen;(der) Zahn der Zeit nagt (an) (sprichwörtlich);abnützen
-Putreszenz (lat.);Moder;Fäulnis;Verwesung;Verfall;Putrefaktion (lat.)
-durchschütteln;aufwühlen;schütteln
-siehe unten;s. u.
-Schrecken;Erschrecken;Schreck;Entsetzen
-Gleichsetzung;Gleichordnung (z.B. im Privatrecht);Gleichberechtigung;Chancengleichheit;Gleichheit vor dem Gesetz;Gleichstellung;rechtliche Gleichstellung;Gleichheit
-Nordatlantikpakt-Organisation;Nordatlantikpakt;Organisation des Nordatlantikvertrags;NATO (Abkürzung, engl.);Atlantische Allianz;North Atlantic Treaty Organization (engl.);Atlantisches Bündnis
-Anführung;zitierte Stelle;Belegstelle;wörtliche Redewiedergabe;Beleg;Textstelle;Zitat
-Die Bahn;Deutsche Bahn;DB
-gehegt und gepflegt;geborgen;behütet;geschützt;beschützt;warm und trocken (sitzen) (auch figurativ);(so sicher wie) in Abrahams Schoß (geh.);sicher;ungefährdet;gesichert;in guten Händen (fig.);im sicheren Hafen (fig.);wohlbehütet;gefeit
-Farbenkarte;Farbkarte
-Toppsegel;Marssegel
-Bemühung;Fitz (ugs., fig.);Mühe;starke Inanspruchnahme;(freundliches) Entgegenkommen (in Geschäftsbriefen) (geh., floskelhaft);Anstrengung;Mühewaltung (geh., floskelhaft, veraltet);Bemühen;Strapaze;Effort (schweiz.)
-Anpassung an die Umwelt;Regulation;Adaption
-unrentabel;unwirtschaftlich;ohne Profit;uneinträglich;unrentierlich;unprofitabel;unökonomisch
-Tachometer;Geschwindigkeitsmesser;Tacho (ugs.);Geschwindigkeitsmessgerät (amtlich)
-nobilitieren (geh.);upgraden (engl.);höhere Weihen erteilen;erheben;adeln;heben;verfeinern;veredeln;auszeichnen;aufwerten;verbessern
-das passt perfekt mit den beiden (ugs.);(sich) auf ideale Weise ergänzen;(optimal) zusammenpassen (variabel);wie füreinander geschaffen sein;(einfach) zusammengehören;Da haben sich zwei gesucht und gefunden. (Redensart);(ein) perfektes Paar (sein);Traumpaar (Hauptform)
-Reue;Buße
-Kybernetik;Steuertechnik;Regelungstechnik
-Nadelstich;Nähstich
-sorgfältiges Studium (von Dokumenten);sorgfältige Durchsicht
-Umformung;Verformung;Extrudierung (fachspr.)
-Akzept;Accept Order
-Nachwort;Epilog;Schlussrede;Schlusswort
-Oligurie (fachspr.);verminderte Harnausscheidung
-Diplopie (fachspr.);Doppelsehen;Doppeltsehen
-Prüfer;Prüfgerät
-Zeichen;Signal;Vorzeichen;Symbol
-Dressing;Vinaigrette;Salatsoße;Salatdressing;Marinade
-Heiserkeit;Halskratzen;Raucitas (fachspr.)
-Gizmo (engl.);Etwas;Teil;Sache;Gegenstand;Objekt;Ding
-Sündenerlass;Absolution;Straferlass;Freisprechung;Gnade;Lossprechung;Ablass
-synchron laufen;synchron schalten
-Bürgschaft übernehmen (für jemanden);Bürgschaft leisten
-humpeln;lahmen;watscheln (ugs.);(ein) Bein nachziehen;hinken;hatschen (ugs.)
-Dampf ablassen (ugs., fig.);(wieder) zu sich kommen;(sich) (wieder) entspannen;(sich) (wieder) in den Griff bekommen (ugs., fig.);(seinen) Ton mäßigen;Ruhe geben (ugs.);(sich) (wieder) einkriegen (ugs.);tief durchatmen (fig.);(sich) (wieder) beruhigen;(sich) abregen (ugs.);(wieder) runterkommen (ugs., fig.)
-Tümpel;See;Teich;Weiher
-synonym;synonymisch (fachspr., veraltend);kongruent (geh., bildungssprachlich);bedeutungsgleich;sinnverwandt;homosem (fachspr.);sinngleich;sinnähnlich;bedeutungsverwandt;gleichbedeutend;bedeutungsähnlich
-Wachstums...;Entwicklungs...
-Dysphagie (fachspr.);Schluckstörung
-Pseudonym (Hauptform);Nickname (ugs.);falscher Name;Alias-Name;Parallelbezeichnung;Alias;Zweitname
-Bartender;Schankkellner;Thekenbedienung;Zapfer;Tresenkraft (ugs., regional);Barkeeper;Barmann
-(die) Leute (ugs.);man allgemein (ugs.);alle (ugs.);(die) breite Masse;(die) Allgemeinheit;(das) gemeine Volk;(die) Menschen (in einem Gebiet)
-Verfassersystem;Autorensystem
-mühsam gehen;trotten;traben
-Differential;Differenzial;differenziell;einen Unterschied begründend od. darstellend
-Anschaffungskosten;Akquisitionskosten;Abschlusskosten
-Wohngemeinschaft;Kommune (ugs.);WG;Wohngruppe
-Abschlachtung;Metzelei (ugs.);Gemetzel;Abschlachten;Blutbad;Massenmorden;Massaker
-hervorrufen;ankurbeln;pushen;triggern;powern;anspornen;aufpeitschen;puschen;innervieren;antreiben;aktivieren;erregen;anregen;aufputschen;stimulieren;in Wallung bringen
-aufziehen;spannen;aufspannen
-Demografie;Bevölkerungswissenschaft;Demographie;Bevölkerungslehre;Bevölkerungsstatistik;Bevölkerungsentwicklung
-voll (ugs., jugendsprachlich);durchweg;völlig;durch und durch;in jeder Hinsicht;total;herzlich (ugs., emotional);restlos;mit Haut und Haaren (ugs., fig.);absolut;ganz (Gradadverb) (Hauptform);rundweg;sowas von (ugs., emotional);ganz und gar;komplett;mit Herz und Seele (ugs.);gänzlich;vollkommen;bis zum Anschlag (ugs., fig.);vollauf;bis über beide Ohren (ugs., fig.);in vollem Umfang;vollumfänglich (Papierdeutsch);richtig;hundertprozentig;vollends;rundum;vollständig;durchwegs (süddt., österr.)
-Filmmaterial;Bildmaterial
-Falte;Bügelfalte
-Sprung;Satz
-platt (ugs.);belanglos;seicht;oberflächlich;ohne tiefere Bedeutung;ohne Tiefgang;flach
-Unregelmäßigkeit;Schwindel;unlautere Handlung;Machenschaft
-sehr langer Zeitraum;Zeitalter;Weltalter;Ära;Ewigkeit (ugs.);Äon(en) (auch figurativ)
-mitbringen;herbringen;bringen;herbeibringen;herschaffen;herbeischaffen
-Separation;Isolation;Abgliederung (fachspr.);Abkapselung;Abgeschlossenheit;Separierung;Vereinsamung;Vereinzelung;Abscheidung (fachspr.);Absonderung;Abtrennung;Segregation (geh.);Isolierung;Ausfällung (chem.) (fachspr.);Trennung
-durchkneten;kneten;massieren;walken
-Einsatzbereitschaft;Willigkeit;Bereitschaft;Hingabefähigkeit;Bereitwilligkeit;Engagement;Commitment;Einsatzfreude
-tätige Hilfe (leisten);unterstützen;beistehen;behilflich sein;(sich) nützlich machen;sekundieren;mit anfassen (ugs.);(mit) Hand anlegen;zur Hand gehen;beispringen;assistieren;Hilfe leisten;mithelfen;mit anpacken (ugs.);(jemandem) die Hand reichen (ugs.);helfen (Hauptform)
-OHCHR (Abkürzung, engl.);Büro des Hochkommissars der Vereinten Nationen für Menschenrechte
-Gegenwirkung;Reaktion;Echo (ugs.)
-(jemandem etwas) vermachen (ugs.);(jemandem etwas) hinterlassen;(jemandem etwas) vererben
-plump;ungraziös;schwerfällig;ohne Anmut
-Unregelmäßigkeit;Betriebsstörung;Beeinträchtigung;Fehlfunktion;Störung;Glitch (fachspr., Jargon, engl.)
-zweckbestimmt;zweckmäßig;zweckbetont
-(Daten/Gedanken) fassen;speichern;merken;einprägen;memorieren (geh.)
-kompromittieren;an den Pranger stellen (fig.);blöd dastehen lassen (ugs.);vorführen;zum Gespött machen;mit heruntergelassener Hose dastehen lassen (ugs., fig.);blamieren;desavouieren (geh., bildungssprachlich);bloßstellen;lächerlich machen
-Rettung (von);Errettung;Befreiung;Erlösung
-Rote Bete;Rote Beete;Rote Rübe (österr.);Rande (schweiz.)
-Knochenmark schädigend;myelotoxisch (fachspr.)
-Pferderennbahn;Turf
-bauchseits;Bauch...;anterior (beim Menschen) (fachspr.);ventral (fachspr.);am Bauch gelegen
-BND;Bundesnachrichtendienst
-Architekturstil;Baustil;Architektur
-Leukose (veraltet);Leukämie;Blutkrebs (ugs.);bösartige Erkrankung der weißen Blutzellen
-überstellen;jemanden einweisen
-Kannbestimmung;Kannregelung
-schneeig;verschneit;schneebedeckt
-Geschlechtsteil;Geschlechtsorgan;Genital;Fortpflanzungsorgan;primäres Geschlechtsmerkmal
-E-Commerce;elektronischer Geschäftsverkehr
-vorbildgetreu;dem Original entsprechend;in perfekter Übereinstimmung;vorbildgerecht;originalgetreu
-Gemeindewiese;Grasplatz;Anger;Dorfwiese;Gemeindeland;Grasfläche;Dorfanger
-federartig;federweich
-Berichtigung;Rektifikation (juristisch);Fehlerkorrektur;Bereinigung;Richtigstellung;Fehlerbehebung
-Töffli (ugs., schweiz.);Mofa
-durch nichts aus der Ruhe zu bringen (sein);(sich) nicht aus der Ruhe bringen lassen;(sich) unbeeindruckt zeigen;nicht die Nerven verlieren;cool bleiben (ugs.);die Contenance wahren (geh.);ein starkes Nervenkostüm haben (ugs.);(etwas) kann jemandem nichts anhaben (ugs.);die Ruhe selbst (sein);(sich) nicht anfechten lassen (von) (geh., veraltend);tiefenentspannt (sein) (ironisch);(sich) nicht kirre machen lassen;ruhig bleiben;einen kühlen Kopf behalten (ugs.);Ruhe bewahren;ruhig Blut bewahren (ugs.);die Ruhe weghaben (ugs., regional)
-Garderobiere;Ankleider
-Profilbild;Seitenansicht
-belegt (Stimme);beschlagen (Stimme);heiser (Hauptform);kratzig;nicht gut bei Stimme;rau (Stimme) (Hauptform)
-Klebung;Verbindungsstelle
-Karrieremacher;Ehrgeizling;Karrierist;Streber;Ehrgeizler
-zurückhaltend;behutsam;bedacht
-niedrig;flach;tief
-Heben;Hochziehen;Hebung
-bedeckt;trüb;wolkig;bezogen;trübe;bewölkt
-Hauptbüro;Hauptstelle;Zentrale;Leitstelle
-auf Paletten stapeln;palettieren
-Hinuntersteigen;Abstieg;Talfahrt;Heruntersteigen
-korrumpieren;schmieren (ugs.);bestechen
-Alchemist;Alchimist;Goldmacher
-nachwachsend;regenerativ;erneuerbar
-Abschirmung;Schutz;Protektion
-regieren;herrschen (über)
-Engagement;Mut (Hauptform);Kühnheit;Mumm (ugs.);Bravour (geh.);Bravur (geh., alte Schreibung bis 2017);Herzhaftigkeit;Traute (ugs.);Courage;Mannhaftigkeit
-wesenlos;inhaltslos
-Bergahorn;Acer pseudoplatanus (fachspr., botanisch)
-Volksentscheid;Volksabstimmung;Volksbefragung;Volksbegehren;Referendum;Plebiszit
-überfliegen (fig., Hauptform);(schnell) durchgehen;schnell durchblättern;querlesen;durch den Text rasen (ugs., fig.);(schnell) durchsehen;überfliegend lesen (fachspr.);flüchtig lesen;kursorisch lesen (fachspr.);diagonal lesen
-Eruktation (fachspr.);Aufstoßen
-Pflicht;Bedingung;Zwang;Muss;Erforderlichkeit;Auflage
-Gerade;Strecke;Strich;Linie
-Briekäse;Brie
-Fühler;Fangarm;Tentakel
-erinnern;in Erinnerung haben;(sich) gemerkt haben (ugs.);im Kopf haben;memorieren (selten);(sich) entsinnen;(jemandem) erinnerlich sein (geh.);im Gedächtnis haben;nicht vergessen haben (ugs.);(jemandem) präsent sein (geh.);(jemandem) gegenwärtig sein (geh.);behalten haben (ugs.);noch wissen;(sich) erinnern;(jemandem) im Gedächtnis sein
-Paraplü (ugs., eingedeutscht, franz.);Regenschirm;Schirm;Parapluie (geh., franz., veraltet)
-Proppen;Korken (Hauptform);Stopfen;Stoppel (Flasche) (österr.);Pfropfen;Stöpsel;Verschlussstopfen;Zapfen (Flasche) (schweiz.)
-Tugend;Güte;Tugendhaftigkeit;Vortrefflichkeit (geh.);Arete (fachspr.)
-Schiebkarre;Schiebetruhe (österr.);Karette (schweiz.);Scheibtruhe (österr.);Schubkarre;Schubkarren
-Zugriffsart;Zugriffsmodus
-};schließende geschweifte Klammer;rechte geschweifte Klammer
-Widerstandsfähigkeit;Robustheit;Resilienz (fachspr.);Ausdauer;Zähheit;Tenazität (fachspr., biologisch);Spannkraft;Zähigkeit
-Rekuperator;Abhitzeverwerter;Vorwärmer;Wärmeaustauscher
-Küchenherd;Herd
-Armut;Geldnot;Mittellosigkeit
-vortragen (Theaterstück);geben;aufführen;zum Besten geben;spielen
-Symbol;Bildzeichen;Ikon;Piktogramm
-begehrlich;begierig
-Auftragsvergabe;Zuschlag
-Bärenmarkt;Fallen der Kurse;Abschwung;Preissturz;Kursverfall;Einbruch;Konjunktureinbruch;Kurssturz;Kursabfall;Baisse;Deroute (geh., franz., selten, veraltet)
-Ausrichtung;Adaption;Adaptierung;Angleichung;Anpassung;Einstellen;Konfiguration;Justierung;Kalibrierung;Einstellung;Regulierung;Umstellung
-Laborschale;Petrischale
-Haussperling;Sperling;Spatz
-(es) kam wie es kommen musste;eines Tages (ugs.);früher oder später;(es) kommt wie es kommen muss;irgendwann (einmal);musste einfach so kommen;nur eine Frage der Zeit (bis);über kurz oder lang (ugs.);am Tag X
-leistungsfähig;hoch entwickelt;fortgeschritten;weit entwickelt
-Bohrmaschine (Hauptform);(Elektro-)Bohrer;Bohrgerät
-korrodieren;oxidieren;einrosten;verrosten;rosten
-offerieren;zur Verfügung stellen;beistellen (Amtsdeutsch, österr.);liefern;bieten;bereithalten;anbieten;bereitstellen;entbieten (veraltet)
-Postomat (Markenname, liechtensteinisch, schweiz.);Geldautomat;Bancomat (Markenname, luxemburgisch, schweiz., südtirolerisch);Geldausgabeautomat (österr.);Bankomat (österr.);Bankautomat
-(leicht) alkoholisiert;einen intus haben (ugs.);angetütert (ugs., norddeutsch);knülle (ugs.);berauscht;angetüdelt (ugs.);beschwipst (ugs.);bierselig;angesäuselt (ugs.);angetrunken;angeheitert;knüll (ugs.);weinselig;leicht betrunken (Hauptform);betütert (ugs., norddeutsch)
-käuflich;veräußerlich;zu verkaufen;verkäuflich;erwerbbar;zu haben (ugs.);abdingbar
-geisterhaft;schemenhaft;gespenstisch;spukhaft
-Blizzard;Schneesturm
-Ausgangssituation;Ausgangslage
-Abschwören;Entsagung;Abkehr;Abschwörung
-abschießen;auf den Weg bringen;abfeuern
-Nacken;Genick;Schlafittchen (ugs.);Hals
-Ausgang (eines Konfliktes);Auflösung
-(sich) abseits halten (von);Abstand halten;(jemanden) nicht an sich heranlassen;auf Distanz bleiben;keine Nähe zulassen (Jargon, psychologisch);auf Abstand bleiben;Distanz halten (Hauptform);Distanz wahren;(sich) fernhalten (von);nicht an sich herankommen lassen
-frohlocken;jubeln (Hauptform);juchhu schreien;Freudenschreie ausstoßen;juchzen;juhu rufen;johlen (abwertend);jauchzen;juchhe schreien;vor Freude laut singen;in Jubelschreie ausbrechen;jubilieren;hurra schreien
-abladen;entladen;ausladen;schütten;auskippen
-glauben, dass man in Sicherheit ist (ugs.);(sich) in Sicherheit wähnen;(sich) in (trügerischer) Sicherheit wiegen;nichts Böses ahnen (floskelhaft)
-Essbesteck;Tischbesteck;Besteck
-mit Pfeffer würzen;etwas Pep in etwas reinbringen (ugs.);pfeffern
-Republik Belarus;Bjelorussland (selten);Belorussland (DDR, historisch);Belarus (Hauptform);Weißrussland (veraltend)
-großzügig;(sich) weithin erstrecken(d);weit;großräumig;so weit das Auge reicht;großflächig;weitläufig;ausgedehnt;(sich) in die Tiefe des Raumes erstrecken(d) (geh.);(sich) weithin ausbreiten(d);weiträumig;weithin ausgebreitet
-Obstbau;Obstanbau;Obsterzeugung;Obstproduktion
-Leitsatz;Wahlspruch;Maxime (Hauptform);Parole;Slogan;Motto;Devise (Hauptform);Mantra (ugs., fig.);Leitspruch;Credo (fig.);Losung
-siech (veraltet oder landschaftlich);außer Gefecht (ugs.);im Krankenstand (Amtsdeutsch);krank (Hauptform);leidend;erkrankt;verletzt;nicht gesund;kränklich;gesundheitlich angegriffen;malad (ugs., kölsch);malade (ugs.);arbeitsunfähig (Arbeitsrecht)
-Stillstandszeit;Ausfallzeit;Standzeit
-Landstrich;Bezirk;Kreis
-stauchen;stoßen;rammen;einrammen;festrammen
-Freibrief;Pouvoir (österr.);Bevollmächtigung;Vollziehungsbefehl;Mandat;Handlungsvollmacht;Kommittiv (fachspr., lat., veraltet);Prokura;Befugnis;Vollmacht;Ermächtigung
-Nutzbarkeit;Verfügbarkeit;Disponibilität;Vorhandensein
-beifußblättriges Traubenkraut;beifußblättrige Ambrosie;Ragweed
-Sandmann;Sandmännchen (Hauptform)
-Konferenz mit Beiträgen zu einem Thema;Symposium;Kolloquium;Symposion
-Mondsichel;Halbmond
-zonenartig;auf eine Zone bezogen;zonal
-Erholungsaufenthalt;Erholungsurlaub
-Helligkeit;Beleuchtung;Belichtung;Licht
-Unfriede;Anfeindung
-Kübel;Eimer (Hauptform);Bottich;Kessel (schweiz.);Container (fachspr., kaufmännisch)
-Wiedereintritt;Wiedereintreten
-steppen;Stepp tanzen
-Plane;Tuch
-Vortragender;Berichterstatter;Rhetoriker;Referent;Redner (Hauptform);Orator (fachspr., lat., veraltend);Referierender;Rhetor (fachspr., griechisch, lat., veraltet);Sprecher
-verkratzen;verschrammen
-Messingtafel;Messingschild
-Bauaufsicht;Bauüberwachung
-Raffinesse (geh.);Subtilität;Feinheit;Differenziertheit (geh.);Finesse;Ausdifferenzierung (fachspr.)
-Entgeltnachweis;Verdienstabrechnung;Gehaltsabrechnung;Verdienstnachweis;Lohnstreifen
-örtlich begrenzt;endemisch
-Rohheit;Unmenschlichkeit;Brutalität
-für geschäftsunfähig erklären;für rechtsunfähig erklären
-Kurs;Kursnotierung;Börsenkurs;Quotation
-Fettdurchfall;Steatorrhoe (fachspr.)
-Preisausschreiben;Gewinnspiel
-Mistplätze;Geilstellen
-sprießen;aus dem Boden wachsen;auflaufen (fachspr., Jargon);aus der Erde kommen;hervorkommen;auskeimen;keimen;(sich) vorwagen (geh., fig.);anfangen zu wachsen;Keime bilden;aufkeimen;hervorwachsen;aufgehen;Keime treiben
-Unvoreingenommenheit;Objektivität;Unbefangenheit
-Entzündung des Bindegewebes im Muskel;Myositis (fachspr.)
-Sperre;Startverbot
-Preziosität;Ziererei;Pretiosität;Affektiertheit
-andersrum (ugs.);invers;andersherum;vice versa (lat.);entgegengesetzt;mit umgekehrten Vorzeichen;umgedreht;umgekehrt;unter umgekehrten Vorzeichen;Umgekehrt wird ein Schuh draus. (ugs., sprichwörtlich);reziprok (fachspr.);invertiert
-ein Bächlein machen (ugs., fig.);eine Stange Wasser in die Ecke stellen (ugs.);seichen (ugs.);Pipi machen (ugs.);pieseln (ugs.);Wasser lassen (Hauptform);(sein Wasser) abschlagen (derb);austreten (ugs.);pissen (derb);ablitern (ugs.);urinieren;pullern (ugs.);klein machen (ugs., Kindersprache, verhüllend);strullen (ugs.);abwassern (ugs.);brunzen (ugs., regional);miktieren (fachspr.);(irgendwohin) machen (ugs.);harnen;pinkeln (ugs., Hauptform);Lulu machen (ugs.);schiffen (ugs.)
-Ulzeration (fachspr.);Entwicklung eines Geschwürs
-einzwicken (bayr., österr.);klemmen;einklemmen;spießen (bayr., österr.)
-Demograph;Demograf
-teigig;zähflüssig
-Schwarzbeere (regional);Heidelbeere;Blaubeere (regional);Bickbeere (regional);Waldbeere;Wildbeere
-schießen (Hauptform);abfeuern;den Abzug betätigen (Amtsdeutsch);ballern (ugs.);losballern (ugs.);abdrücken
-nicht zum ersten Mal;zum wiederholten Male;wieder;nochmalig;aufs Neue;neuerlich;einmal mehr (geh.);ein weiteres Mal;wiederkehrend;noch einmal (Hauptform);nochmals;erneut;schon wieder;nochmal;von Neuem;zum wiederholten Mal;wiederum;abermals;wieder einmal;noch mal;wiederholt;wie gehabt
-Sexobjekt;Sexualobjekt
-auf Betreiben von;auf Veranlassung von;auf Drängen von;auf Ersuchen von
-Ausstellungsplatz;Ausstellungsgelände;Messegelände
-näher zur Körpermitte;proximal (fachspr.);zum Körperzentrum hin
-(Ausrede) fingieren;erfinden
-bösartige Geschwulst;Neoplasma;Malignom;Krebs;Krebsgeschwulst
-unisono;einhellig;einmütig;übereinstimmend;einstimmig;konkordant;konform;kongruent
-Arbeitsjahr;Mannjahr;Dienstjahr;Personenjahr
-ungeeignet;inkompetent;unkompetent (selten);unfähig;untauglich;außer Stande;außerstande;(der) Aufgabe nicht gewachsen
-verdrießen (geh.);(jemanden) verärgern;vergrämen;vergraulen;(jemanden) sauer fahren (ugs., Jargon);sauer machen (ugs.);vergrätzen (ugs.)
-bedenken;absehen;voraussehen;einplanen;vorhersehen
-Dopingkontrolle;Dopingtest
-Klapsdoktor (ugs., scherzhaft);Psychiater;Püschater (ugs., scherzhaft-ironisch);Meisendoktor (ugs., abwertend, salopp);Kopfdoktor (ugs.);Nervenarzt;Irrenarzt (derb, abwertend);Seelenklempner (ugs.)
-Erstattung;Entschädigung;Rückvergütung
-erfreuen;erheitern;(jemanden) amüsieren;belustigen
-einrichten;hinstellen;ordnen
-paddeln (ugs.);plantschen (ugs.);rinnen (von Haarwild) (fachspr., Jägersprache);schwimmen;baden
-lockern;trennen;losmachen;lösen;locker machen
-moderat;maßvoll;mit Augenmaß;gemäßigt;mäßig;verhalten
-Vorwand;Alibi;Feigenblatt (fig.);Scheingrund;Ausrede;Deckmantel
-i. A.;im Auftrag
-flehen;appellieren;aufrufen;bitteln und betteln (ugs.);anflehen;unter Tränen (an)flehen;erflehen;unter Tränen bitten;inständig bitten;auf Knien (an)flehen
-zusammenkommen;(jemanden) treffen;(jemandem) begegnen (geh.);(jemanden) sehen (ugs.);zusammenfinden
-Bitte;Bittgesuch;Gesuch;Petition
-eingeklammert;in Klammern gesetzt
-Inhaftnahme;Arretierung;Verhaftung;Festnahme;Gefangennahme;Ergreifung (auf frischer Tat)
-zittrig;tattrig;zitterig;tatterig
-aufgelaufene Zinsen;Stückzinsen
-Tempo;Schwuppdizität (ugs., scherzhaft);Geschwindigkeit;Schnelligkeit;Takt (technisch);Zahn (ugs.);Zügigkeit;Hurtigkeit (dichterisch, scherzhaft)
-absaugen;auspumpen;leer pumpen;ausschöpfen
-Abfindung;Wiedergutmachung;Rekompensation;Reparation;Entschädigung;Nachzahlung;Belohnung
-Wiegenlied;Gutenachtlied;Schlaflied
-desgleichen;dergleichen;dgl. (Abkürzung)
-verdeutlichen;illustrieren;exemplifizieren;erklären
-Schutt;Trümmer
-Asymptote;Annäherungslinie
-eisgekühlt;gefroren
-plappern;schwatzen;salbadern;(herum)sülzen (ugs., abwertend);sülzen (ugs., abwertend);sabbeln (ugs.);groß herumtönen (ugs.);daherreden (Hauptform);(sich) auslassen;schwadronieren;faseln (ugs., abwertend);daherplappern;(sich) ergehen (in);schwafeln (ugs.);(herum)labern (ugs.);quasseln;schwätzen;(sich) verbreiten (über)
-Mutismus (fachspr.);Stummheit bei intaktem Sprechorgan;psychogenes Schweigen
-(sich) einbilden;meinen;glauben
-unbenannt;ohne Nennung der Person;namenlos;anonym;gesichtslos
-Befragung;Anhörung;Einvernahme (schweiz., österr.);Einvernehmung (schweiz., österr.);Verhör;Untersuchung;Vernehmung
-gute Schwingungen (ugs.);Vergnügen;Frohmut;Freudigkeit;Heiterkeit;Konvivialität (geh., bildungssprachlich, lat.);gute Laune;Freude;freudige Erregung;Fröhlichkeit;Frohsinn;Glückseligkeit
-vereinheitlichen;wechselseitig austauschen;angleichen;synchronisieren;abgleichen
-Dampfkessel;Siedekessel
-Amplitudenmodulation;AM
-Streitlust;Streitlustigkeit
-gefüllter Schafsmagen;Haggis
-erzwungen;aufgezwungen;oktroyiert
-widerspenstig;aufsässig;widerborstig;renitent
-Hautknötchen;Knötchen;Papel (fachspr.)
-Therme;Thermalquelle
-entlasten;säubern;erlösen;befreien
-Kleinheit;Winzigkeit
-stählern;stahlhart
-hektisches Gebaren;Rasanz;Hast;Hektik;Hastigkeit;Eile;Eilfertigkeit;überstürztes Vorgehen;Überstürzung;(in) Windeseile (ugs.)
-Verschränkung;Verstrickung;Verwicklung;Verquickung;Einmischung;Verflochtenheit
-Doktorschrift;Diss (ugs., Abkürzung);Diss. (fachspr., Abkürzung);Doktorarbeit;Antrittsdissertation;Promotionsschrift;Dissertationsschrift;Inauguraldissertation;Dissertation;Einführungsdissertation
-Vielfältigkeit;Abwechslung;Vielfalt;Abwechselung;Diversität;Differenziertheit;Vielzahl;Mannigfaltigkeit
-Statement (engl.);Gutachten;Anschauung;Votum (geh.);Meinung;Bewertung;Ansicht;Stellungnahme
-Luftschutzkeller;Schutzraum;Schutzbau (ugs.);Luftschutzraum
-preisen;rühmen
-hart (Wasser);kalkhaltig
-herstammen;entsprießen;(sich) ableiten (von);entspringen;abstammen;zurückgehen (auf);hervorgehen;herrühren (von);(sich) herleiten (von);(seinen) Ursprung haben (in)
-auseinander treiben;zerstreuen
-abschleppen;schleppen
-Europide;Weißer (Hauptform);Langnase;Bleichgesicht;Kaukasier;Weißbrot (ugs., scherzhaft-ironisch);Europider
-Zerwürfnisse;Auseinandersetzung;Streitigkeiten;Brüche;Schererei (ugs.);Dispute;Differenzen;Querelen;Reibereien
-Ehrentafel;Grabinschrift;Epitaphium (geh.);Gedenktafel;Epitaph (geh.)
-Zug reisen;Zug fahren;Bahn fahren
-Anwendungsschicht;Anwendungsebene
-Merkmal;Symbol;Markierung;Zeichen
-in voller Blüte (stehen);voll aufgeblüht
-merkwürdiger Mensch;Exzentriker;Sonderling
-gegenseitige Verbindung;Koppelung;Kopplung;Bindung;Querverbindung
-Kritzelei;Geschmier;Geschmiere;unsauber Geschriebenes;Schmiererei
-Scoring (engl.);Bonität;Kreditwürdigkeit;Rating (engl.);Einstufung (der Bonität)
-angeknabbert;angefressen;benagt;angenagt
-aufeinanderprallen;aufeinanderstoßen;zusammenprallen;kollidieren;zusammenstoßen
-spannend (ugs., fig.);faszinierend;interessant (Hauptform);hochspannend;von Interesse (für);hochinteressant;Interesse wecken(d);attraktiv
-Unterbau;Fundament;Gründung;Grundlage;Grundstein
-der eine dem (/ den) anderen und umgekehrt;einer dem (/ den) anderen und umgekehrt;sich untereinander;jeder dem (/ den) anderen;jeder jeden;einander (geh.);sich gegenseitig (Hauptform);jeder jedem;sich
-leiden mögen;lieb haben;lieb gewonnen haben;sympathisch finden;gut ausstehen können (ugs.);gewogen sein (geh.);für (jemanden) etwas übrig haben (ugs., fig.);in sein Herz geschlossen haben (ugs.);ans Herz gewachsen (sein) (ugs., fig.);ins Herz schließen (ugs.);liebgewonnen haben;liebhaben;(gut) leiden können;mögen;gernhaben
-Pflaume (vulg.);Dose (vulg.);weibliche Scham;äußere weibliche Geschlechtsteile (ugs.);Muschi (ugs.);Möse (vulg.);Vulva (fachspr.);Scheidenvorhof;Fotze (derb)
-Gewissheit;Zuversichtlichkeit;Sicherheit
-jahrtausendtauglich;jahrtausendsicher;jahrtausendfähig
-Loch (derb);Kiste (ugs., bundesdeutsch, schweiz.);Strafanstalt;Kittchen (ugs.);JVA (Amtsdeutsch);Strafvollzugsanstalt (Amtsdeutsch);Kerker (veraltet);Haftanstalt;schwedische Gardinen (in festen Wendungen, scherzhaft);Knast (ugs., bundesdeutsch);Bau (ugs., militärisch);Justizvollzugsanstalt (Amtsdeutsch);Vollzugsanstalt (Amtsdeutsch);Zuchthaus (ugs., veraltet);Gefängnis (Hauptform);Haftort (fachspr.);Kahn (ugs., bundesdeutsch);Hafthaus;Häfen (ugs., österr.);Bunker (ugs., militärisch)
-gewinnorientiert;profitorientiert;gewerblich;kommerziell;privatwirtschaftlich;wirtschaftlich;merkantil;kaufmännisch;Handels...;unternehmerisch
-Landwirtschaft;Landbau;Agrar;Ackerbau
-Hochzeitspaar;Brautpaar
-in Gang halten;aufrechterhalten;beibehalten
-auf der Strecke bleiben (ugs.);vergessen werden;ins Hintertreffen geraten;liegen bleiben;liegenbleiben;nicht erledigt werden
-Kardinalzahlwort;Hauptzahl;Kardinale;Grundzahl;Kardinalzahl;Hauptzahlwort;Grundzahlwort
-Altersforscher;Gerontologe
-Schattierer;Shader
-Wasserbehälter;Wasserkasten
-blau dünsten;pochieren
-Mängelbürgschaft;Gewährleistung;Mängelhaftung
-Zustellung;Anlieferung;Sendung;Auslieferung;Rutsche (ugs., salopp);Lieferung;Belieferung;Überbringung;Fuhre (ugs.)
-secondhand (engl.);gebraucht (Hauptform);second-hand (engl.);aus zweiter Hand;getragen;nicht neuwertig;benutzt
-herabsinken;auskoppeln;verflachen;ausarten;entkoppeln
-Takt;Rhythmus
-Aufholbedarf (österr.);Rückstand;Nachholbedarf
-Trübung;Trübheit
-hybrid;zwitterhaft
-nötig haben;erfordern;verlangen;gebieten;benötigen;erheischen (geh.);bedürfen;bedingen;beanspruchen;voraussetzen
-Schubfach;Schubkasten;Schoss (ugs., rheinisch);Schublade (Hauptform)
-Zusatzunterricht;Hilfsunterricht;Nachhilfe;Förderunterricht;Hausaufgabenhilfe;Ergänzungsunterricht;Nachhilfeunterricht
-Drilling;Triole
-Datentransfer;Datenübertragung;Informationsübertragung
-ungekennzeichnet;unbeschriftet
-ich sollte;ich müsste;(es) wäre meine Aufgabe;ich hätte (eigentlich) zu (...);es wäre an mir
-Zuschnitt;Anpassung (kundenspezifisch)
-spenden;zuwenden;dotieren;stiften;ausstatten
-festsetzen (auf);bewerten;wertschätzen;schätzen;taxieren;beziffern (auf)
-Lehrveranstaltung (über);Vorlesung
-erwachen;wach werden (ugs.);aufwachen (Hauptform);aufhören zu schlafen
-Raynaud-Phänomen (fachspr.);funktionelle Gefäßstörungen
-einseifen;abseifen
-Zeltpflock;Zeltnagel;Spannnagel;Leinennagel;Erdnagel;Zelthering;Hering;Seilnagel
-Fiedler (leicht abwertend) (ugs.);Geigenspieler;Violinenspieler;Geiger;Violinist;Violinspieler
-undurchsichtig;opak;lichtundurchlässig
-aurikular (fachspr.);die Ohrmuschel betreffend
-avant la lettre (geh., franz.);fortschrittlich;zukunftsweisend;progressiv;richtungsweisend;seiner Zeit voraus;futuristisch;innovativ
-Hauptlinie;Hauptzweig (Abstammung)
-lang genug sein;hineinreichen
-im Augenblick;im Moment
-auf den Kundenbedarf zuschneiden;kundengerecht anfertigen
-Blech (ugs.);saudummes Zeug (ugs., süddt.);Mumpitz (ugs.);Käse (ugs.);Fez (ugs.);Humbug;Kohl (ugs.);Krampf (ugs.);Mist (ugs.);Killefit(t) (ugs., rheinisch);Schmarren (ugs.);Nonsens;gequirlte Scheiße (derb);Schmonzes (ugs.);Gelaber (ugs.);geistiger Durchfall (derb);Dummfug (ugs.);Pillepalle (ugs.);geistiger Dünnschiss (derb);Bullshit (derb, engl.);Unsinn (Hauptform);dummes Zeug (ugs.);Sottise(n) (geh., franz.);Schmäh (ugs., österr.);Quatsch mit Soße (ugs., berlinerisch);Driss (ugs.);Banane (ugs.);Pipifax (ugs.);Quatsch (ugs.);Gefasel (ugs., abwertend);Blaschwafel (ugs.);Kokolores (ugs.);Scheiß (derb);Stuss (ugs.);Kiki (ugs.);Heckmeck (ugs.);Quark (ugs.);Gewäsch (ugs.);Schmu (ugs.);Tinnef (ugs.);Bockmist (ugs.);Schmarrn (ugs.);Schwachsinn (ugs.);Firlefanz (ugs.);Kappes (ugs.);Nonsense (engl.);Schwachfug (derb);dümmliches Gerede (variabel);Unfug;Widersinn;Scheiße (derb);Kasperletheater (ugs.);Geschwafel (ugs.);Blödsinn;Papperlapapp (ugs.)
-Kleinverkauf;Einzelhandelsabsatz
-qualmig;rauchig
-Verwendung;Applikation (fachspr.);Einsatz;Anwendung
-talentfrei (ugs., ironisch);schwach;minderbegabt;unfähig;unbegabt;untalentiert;talentlos;leistungsschwach
-Zigarettenstummel;Zigarettenkippe;Kippe
-(mit einem Zaun) einfassen;umfrieden;einfrieden;einzäunen;umzäunen;einfriedigen (selten)
-obligat (geh., bildungssprachlich);unerlässlich;erforderlich;notwendig;vonnöten (geh.);von Nöten (geh.);nötig
-kalte Jahreszeit (ugs.);Winter;Winterzeit
-blutschänderisch;inzestuös
-mitschwingen(d);angedeutet;mitgemeint;(im) Subtext;zwischen den Zeilen (ugs.);unausgesprochen;implizit;(sich) andeuten(d)
-Vermögenseinbuße;Vermögensschaden
-Moorland;Feuchtgebiet;Morast;Sumpf (Hauptform);Bruch;Moor
-Mehrfachdosis;Mehrfachgabe
-Lackmustest (fig.);Nagelprobe;Feuerprobe;harte Prüfung;Test;Feuertaufe (fig.);Bewährungsprobe
-Aufpreis;Zuschlag;Mehrpreis
-gottlos;sündig (religiös);frevelhaft;sakrilegisch (religiös);blasphemisch (geh., religiös);frevlerisch;gotteslästerlich (religiös);wider Gott;freventlich (veraltend)
-gegenstandsbezogen;betreffen;topikal (griechisch, neulateinisch);(sich) beziehen (auf);interessensbezogen;themenbezogen;inhaltsbezogen
-Werder;kleine Insel;Werth;Holm;Flussinsel;Wörth
-Zutrittsberechtigung;Zugangsberechtigung
-Holm;Barrenholm
-Wahlzettel;Stimmzettel
-Schiffer;Kapitän;Skipper;Schiffsführer;Käpt'n (ugs.)
-Annehmlichkeit;Anmut;Behaglichkeit
-konstituierende Versammlung;konstituierende Sitzung;Gründungsversammlung
-die Platze kriegen (ugs., regional);einen dicken Hals kriegen (ugs.);die Wut bekommen (ugs.);(die) kalte Wut kriegen (ugs.);die Wut kriegen (ugs.);(jemanden) packt der helle Zorn (geh.);(jemanden) packt die Wut;(jemandem) geht das Messer in der Tasche auf (ugs., regional);(immer wenn ...) rasend werden;kurz vorm Überkochen sein (ugs.);kurz vorm Explodieren sein (ugs.);Schnappatmung bekommen (ugs., fig.);mit der Faust auf den Tisch schlagen (auch figurativ);rotsehen;in Wut geraten (Hauptform);mit der Faust auf den Tisch hauen (derb);in Rage kommen (geh.);hochgehen wie ein HB-Männchen (ugs., veraltet);in die Luft gehen (ugs.);böse werden (ugs., Kindersprache);(gleich) Amok laufen (ugs., übertreibend);so (+ Geste) einen Hals kriegen (ugs.);an die Decke gehen (ugs.);in Rage geraten (geh.);so (+ Geste) eine Krawatte kriegen (ugs.);hochgehen wie eine Rakete (ugs.);einen Föhn kriegen (ugs., regional)
-umarbeiten;aufpolieren
-Leuchtzeichen;Markierung;Echozeichen
-tödlich;mörderisch;zerstörend;letal;todbringend;fatal
-Entzündung der Gallengänge;Cholangitis (fachspr.)
-für einen Apfel und ein Ei (ugs., fig.);für wenig Geld zu haben;fair (Preis) (ugs., werbesprachlich);billig (preiswert) (Hauptform);günstig;für einen schmalen Euro (ugs.);für kleines Geld (ugs.);kostengünstig;erschwinglich;bezahlbar (verhüllend);Billig...;human (ugs., ironisch);zum Spottpreis;zum kleinen Preis;(Low) Budget (fachspr., Jargon, Neologismus, engl.);preiswert;zivile Preise (ugs., fig.);(ein) ziviler Preis (ugs., fig.);preisgünstig;wohlfeil (geh., veraltet);spottbillig;(etwas) nachgeschmissen bekommen (ugs.);zum Knallerpreis (ugs., werbesprachlich);billig zu haben;unschlagbar günstig (werbesprachlich);unter(st)e Preiskategorie;humane Preise (ugs., fig.)
-Auflage (Druckwerk);Abdruck;Fassung;Druck;...ausgabe;Edition;Ausgabe (Druckwerk)
-Angliederung;Beziehung;Zuordnung;Zugehörigkeit;Vereinigung;Relation
-Schmiermittel;Kühlmittel;Kühlschmiermittel;Kühlwasser;Kältemittel
-Drehorgel;Leierkasten
-Schaltung;Verdrahtung
-vergilbt;falb;gelbbraun;fahles Gelb
-zugehörig;verwandt
-Plan;Landkarte;Karte
-Fehlanlage;Unterentwicklung;Dysplasie (fachspr., griechisch);Fehlentwicklung;Fehlbildung
-rotieren;(sich) drehen;kreise(l)n;trudeln (ugs.)
-Kleinwohnung;Etagenwohnung;Apartment (engl.)
-Gegenrevolution;Konterrevolution
-Gentechnologie;Gentechnik;Genmanipulation (ugs., abwertend)
-bedrückt;traurig (Hauptform);down (ugs.);freudlos;niedergeschlagen;unlustig (ugs.);trübselig;trübsinnig;nicht aufzuheitern;unglücklich;niedergedrückt;gedeftet (österr.);mutlos;ein Häufchen Elend (sein);betrübt;gedrückt;kummervoll;bekümmert;geknickt (ugs.);verzagt (geh.)
-gehört niemandem;herrenlos;stehen gelassen;liegen gelassen;zurückgelassen
-Wisch (derb);(amtliches) Schreiben;(amtliche) Mitteilung;Bescheid
-Nekrose (fachspr.);Nekrobiose;lokaler Gewebstod
-Kurs halten (fig.);im Plan sein;auf Kurs sein (fig.);im Plan liegen
-Aufstellung;Hintereinanderstellung;Abfolge;Reihung;Anordnung;Formation
-Bagatelle;Schnullibulli (ugs.);Petitesse (geh., franz.);keine große Sache;Unwichtiges;Fliegenschiss (derb, fig.);Lappalie (ugs., Studentensprache, latinisiert);Banalität;Pipifax (ugs.);Tüddelkram (ugs., norddeutsch, variabel);Sturm im Wasserglas (fig.);Belanglosigkeit;Nichtigkeit;Kleinkleckerkram (ugs.);Peanuts (ugs., engl.);Marginalie (geh.);Kiki (ugs.);Geringfügigkeit;Kleckerkram (ugs.);Quisquilien (Plur., lat.) (geh.);Nebensächlichkeit;Kleinkram (ugs.);Nebensache;Kleinigkeit;Pappenstiel;Pillepalle (ugs.);Unwichtigkeit;keine große Geschichte;Kinkerlitzchen (ugs.);unwichtige Sache
-Wahlausgang;Wahlresultat;Wahlergebnis
-Sammlung;Kollektion
-die richtigen Leute kennen (ugs.);Vitamin B haben (ugs.);Beziehungen haben (ugs.)
-(einer Sache) aus dem Wege gehen;scheuen (geh.);kneifen (vor) (ugs.);(sich) nicht stellen;(sich) drücken (vor) (ugs.);(sich) aus der Verantwortung stehlen;(sich) davonstehlen;ausweichen;(sich) entziehen;fliehen (literar.) (geh.);(sich) der Verantwortung entziehen;(sich) herumdrücken (um) (ugs.);(sich) einen schlanken Fuß machen;meiden
-Vorwiderstand;Multiplikator;Verstärker
-Entlüftungsanlage;Entlüftung
-Kopfstein (im Mauerwerk);Binderstein
-auflesen (ugs., fig.);einsammeln (fig.);(jemanden) mitnehmen (Hauptform)
-Myasthenie (fachspr.);krankhafte Muskelschwäche
-Müllhalde;Kippe (ugs.);Müllplatz;Schuttplatz;Mülldeponie;Deponie;Schuttabladeplatz;Müllkippe
-Faktor;Koeffizient;Beiwert (veraltet)
-Isolierungshaft;Isolierhaft;Isolationshaft
-BLZ;Bankleitzahl
-Prägnanz;Eindeutigkeit;Exaktheit;Deutlichkeit;Ausprägung;Auffälligkeit
-darren (fachspr.);dörren;trocknen
-Farbenpracht;Farbenmeer
-vereinheitlichen;normieren;standardisieren
-Selbsttötung;Freitod (verhüllend);Harakiri (japanisch);Suizid (fachspr., Hauptform);Tod durch eigene Hand;Selbstmord
-Kopie;Replikation;Replikat (fachspr.);Replik;Nachbau;Reproduktion;Replika (fachspr.);Nachbildung;Ektypus (geh., griechisch);Gleichstück (geh.)
-Aufbauanleitung;Montageanleitung;Montageanweisung
-erstechen;Hals abschneiden (ugs.);Bauch aufschlitzen (ugs.);erdolchen;abstechen (ugs.)
-Insuffizienz (fachspr.);ungenügende Leistung eines Organs
-Mastzelle;Mastozyt (fachspr.)
-Gereiztheit;Erbostheit;Wüterei;böses Blut (ugs.);Feindseligkeit;Scheißwut (derb);Rage;Echauffierung;Furor;Jähzorn;Aufgebrachtheit;Stinkwut;Gefrett (ugs., süddt., österr.);Gfrett (ugs., süddt., österr.);Aufgebrachtsein;Ärger;heiliger Zorn;Aufregung;Echauffiertheit;Raserei;Empörtheit;Wut;Ingrimm (veraltend);Wut im Bauch;Aufgeregtheit;Indignation;Empörung (Hauptform);Verärgerung;Zorn;Entrüstung
-Stich;Stechen;stechender Schmerz
-Liquor;Flüssigkeit;Körperflüssigkeit
-meist;im Regelfall;pflegen zu (geh., ironisierend);überwiegend;in der (überwiegenden) Mehrzahl der Fälle;zumeist;in der Regel;mehrheitlich;größtenteils;hauptsächlich;meistens (Hauptform);häufig
-ausgestattet sein (mit);haben;(etwas) bieten;(über etwas) verfügen;besitzen;aufweisen;aufwarten (können) mit (geh., fig., werbesprachlich)
-zockeln (ugs.);zuckeln (ugs.);(sich) schleppen;daherlatschen (ugs.);schleppend gehen;(sich) mit schleppendem Gang fortbewegen;schlappen (ugs.);trödeln (ugs.);kriechen (fig.);trotten;(sich) dahinschleppen;schlurfend gehen;schlurfen;latschen (ugs.)
-Back-Office;technische Abwicklung von Büro-Vorgängen
-decken lassen;paaren
-Flugticket;Ticket;Flugschein
-Werbeindustrie;Werbung (ugs.);Werbewirtschaft;Werbebranche;Werbebusiness
-Mischsprache;Pidginsprache;Kauderwelsch (ugs.);Kreol;Kreolsprache
-ergeben;(sich) belaufen (auf);betragen;ausmachen;(sich) beziffern (auf)
-Tragrad;Laufrad;Stützrad
-Zimmermädchen;Kammerzofe
-Schwärze;schwarze Farbe
-nachdenklich;besinnlich
-Beantwortung;Abklärung;Aufschluss;Aufklärung;Klärung;Klarstellung
-Stahlseil;Drahtseil
-hinderlich;abträglich;nachteilig;schädlich
-Abstich;Abzweigung
-Denkorgan;Denkzentrale (ugs.);Hirn;Enzephalon (fachspr.);Denkapparat (ugs.);Oberstübchen (ugs., fig.);graue Zellen (ugs.);Gehirn (Hauptform)
-so weit wie;bis zu
-Mansarde;Bodenkammer;Dachkammer;ausgebauter Dachboden;ausgebautes Dachgeschoss
-Schokoladenriegel;Schokoriegel
-Schminke;Make-up
-Wiedereinführung;Neueinführung
-roter Blutfarbstoff;Hämoglobin
-Faltensaum;Falbel
-Zusatzzeichen;Sonderzeichen
-nie (Hauptform);im Leben nicht (ugs.);auf gar keinen Fall;nie und nirgends;keineswegs;zu keiner Zeit;nimmerdar;absolut nie;niemals (Hauptform);nimmermehr;nicht in diesem Leben;zu keinem Zeitpunkt;nie und nimmer;nie im Leben (ugs.)
-selbst wenn;wenn auch;sogar wenn
-Insasse;Gefangengenommener;Arrestant;Häftling;Knasti (ugs.);Knastologe (ugs.);Sacklpicker (derb, österr.);Knastbruder (ugs.);Verhafteter;Inhaftierter;Zuchthäusler (ugs., schweiz.);Sträfling;Strafgefangener;Gefangener;Gefängnisinsasse;Knacki (ugs.);Verurteilter
-komponieren;zusammensetzen
-untersuchen;durchleuchten;eruieren (geh.);erforschen;nachforschen;auf den Grund gehen
-darum;drum (ugs.)
-Speisen zur Selbstbedienung;Buffet;Büfett
-skrupellos;ohne Hemmungen;nicht zimperlich (ugs.);bedenkenlos;rücksichtslos;inhuman;brachial;über Leichen gehen(d)
-Bindemittel;Arzneistoffträger;Hilfsstoff
-Skiläufer;Skifahrer;Schiläufer;Schifahrer
-Wärmetauscher (Hauptform);Wärmeübertrager;Wärmeaustauscher (selten)
-Not;Mangel
-nicht mit der Sprache herauswollen (ugs.);herumdrucksen (ugs.);(sich) um eine Antwort herumdrücken
-Verdampfbarkeit;Flüchtigkeit
-zurückgewinnend;wiedergewinnend
-Odyssee;Irrfahrt
-Kapitale (veraltend);Hauptstadt
-Abgeld;Ausgabeabschlag;Disagio;Damnum;Abschlag
-am Rande;nebenher;nebenhin;nebenbei;im Vorbeigehen;beiläufig;mal eben nebenbei (ugs.);im Vorübergehen;en passant
-petzen (ugs.);zwicken;kneifen
-Feinzucker;Staubzucker (sächsisch, österr.);Streuzucker;Puderzucker
-Keloid (fachspr.);Wulstnarbe
-zerbrechen;zerbersten;bersten
-Labung;Labsal;Erquickung
-Kessel;Druckbehälter
-überragen;hinausragen (über);übertreffen
-Pachtverhältnis;Mietverhältnis
-hereinlegen;reinlegen (ugs.);überlisten;austricksen;übervorteilen
-Hinterlist;Gerissenheit;Boshaftigkeit;Bosheit;Hinterhältigkeit;Sadismus (fig.);Verschlagenheit;Tücke;Gehässigkeit;Biestigkeit;Arglist;böse / miese / schlechte / üble Absicht;Niedertracht;Ruchlosigkeit;(das) Gemeine (an);Böswilligkeit;Gemeinheit;Bösartigkeit;Heimtücke
-Mastitis (fachspr.);Entzündung der Brust
-in einer Richtung mit;in einer Linie mit
-erweichen;flüssig werden;schmelzen
-Dröhnen;Brausen;Donner
-UNESCO (Abkürzung, engl.);Organisation der Vereinten Nationen für Erziehung, Wissenschaft und Kultur
-Parität;Gleichstellung
-immerdar;perpetuell (geh.);immer nur;fortwährend;konstant;kontinuierlich;stets und ständig;stetig;allweil (süddt.);alleweil (süddt.);perpetuierlich (geh.);allzeit;immer und ewig;persistent;ständig;in Zeit und Ewigkeit;immer (Hauptform);immerwährend;stets
-Gebrauchsgegenstand;Bedarfsartikel
-Strebe;Strebebalken
-unvorbereitet;ungewappnet;a prima vista (fachspr., ital.);nicht vorbereitet (auf) (Hauptform);nicht eingestellt (auf);nichts ahnend;nichtsahnend;ahnungslos
-Schinkenfleisch (in Dosen);Frühstücksfleisch
-(sich) verwickeln;(sich) verhaspeln (ugs.);straucheln (fig.);(sich) verheddern (ugs.);ins Stottern geraten;den Faden verlieren (ugs.);(sich) verwirren;ins Stottern kommen;nicht weiterwissen;durcheinanderkommen (ugs.);zu stammeln anfangen
-Zwetschke (österr.);Zwetsche (norddeutsch);Quetsche (süddt.);Pflaume;Zwetschge (bundesdeutsch, schweiz.);Kulturpflaume (fachspr.)
-Billigung;Einwilligung;Placet (geh.);Zustimmung;Einverständnis;Segen;Plazet (geh.)
-Überempfindlichkeit für Sinnesreize;Hyperästhesie (fachspr.)
-Acker;landwirtschaftliche Anbaufläche;Feld
-Animateur (franz.);Unterhalter;Stimmungsmacher
-Meditation (fachspr.);Lockerung;Entspannung
-zerdrücken;zerquetschen
-Kelle;Spatel
-queren;durchfahren;überqueren;traversieren;durchqueren
-Verkühlung (ugs., österr.);Freck (ugs., saarländisch);Erkältung;Husten (ugs.);grippaler Infekt;Schnupfen (ugs.)
-Lebensverneinung;Pessimismus;Miesmacherei;Endzeitstimmung;Defaitismus (schweiz.);Weltuntergangsstimmung;Untergangsstimmung;Dekadenz;Defätismus;Schwarzseherei
-Hase (ugs.);leichtes Mädchen (ugs., fig.);Schlampe (derb);Schickse (derb);Wanderpokal (derb, fig.);Sünderin (veraltet);Flittchen (derb, Hauptform);liederliches Weibsstück (ugs.);Flitscherl (ugs., österr.);Bitch (derb, engl.);Dorfmatratze (derb, fig.)
-Verpflanzung;Transplantation
-unbeeinträchtigt;ungestört;ohne Störung;störungsfrei;in Ruhe
-Addierwerk;Addierer
-Schubfestigkeit;Scherfestigkeit
-ungeeignet;unanwendbar
-Schneidbrennerspitze;Schneidbrennerdüse
-Sklerose (fachspr.);Verhärtung von Geweben oder Organen
-erfahrungsgemäß;empirisch;auf Erfahrung beruhend
-aufpfropfen;aufdrücken;(jemandem etwas) an den Hals hängen (ugs., fig.);zwangsbeglücken (mit) (ugs.);aufhalsen (ugs.);aufzwingen;(jemandem etwas) ans Bein binden (ugs., fig.);(jemandem etwas) verpassen (ugs.);aufbürden;(jemandem etwas) aufs Auge drücken (ugs.);aufoktroyieren;aufnötigen;aufbrummen (ugs.);auferlegen;oktroyieren (geh.)
-erwerben;erkaufen;aufkaufen;kaufen (Hauptform);ankaufen;erstehen
-Amüsement (geh.);Vergnügung;Lustbarkeit (geh., altertümelnd);Belustigung;Entertainment;Vergnügen;Spaß;Kurzweil (geh., veraltend);Ergötzlichkeit (veraltet);Unterhaltung (Hauptform);Darbietung;Erheiterung
-zukrachen;zuschlagen;zuballern;zuknallen;zuhauen
-Nephrolith (fachspr.);Nierenstein
-Lobgesang;Tribut
-darüber hinaus;u. a.;unter anderem;überdies;im Übrigen;auch;ebenso;neben alldem;des Weiteren;inter alia (geh., bildungssprachlich, lat., selten);weiterhin;nicht zuletzt;weiter;daneben;außerdem;zudem;und;auch weil;zugleich;ansonsten;obendrein;i. a. (geh., bildungssprachlich, lat., selten);dazu;zusätzlich;zumal;ferner;über (...) hinaus;hierneben;weiters (österr.)
-Französisch;frz. (Abkürzung);französische Sprache
-aufstellen;errichten
-zeitig;früh;frühzeitig;zu Beginn
-streng;grimmig;entschlossen;angestrengt;grimm (altertümelnd oder ironisierend) (geh.);verbissen;ernst;finster;düster
-Tastendruck;Tastenanschlag
-Panniculitis (fachspr.);Entzündung des Unterhaut-Fettgewebes
-Sinnestäuschung (Hauptform);Einbildung;Wahnbild;Hallu (meist Plural: Hallus) (Jargon);Butterland (fachspr., Jargon, seemännisch);Halluzination;reizunabhängige Sinneswahrnehmung (fachspr.);Gesicht (oft Plural: Gesichte) (veraltet);Wahnvorstellung;Täuschung;Trugbild
-einzwängen;einkeilen;einpferchen;zwängen;keilen
-Absonderung;Auswurf;Ausscheidung;Ausdünstung;Sezernierung (fachspr.);Sekretion (fachspr.)
-stationärer Zustand;Dauerzustand
-messen;eichen;ermitteln;vermessen;erheben;abzirkeln;bestimmen;abmessen
-Fahnenstange;Fahnenmast
-Schlussrechnung;Abrechnung;Rechnung;Bilanz;Ausgleich
-durchtränken;einweichen
-nicht für mich bestimmt (Postsendung, Telefonanruf);falsch zugestellte (Post-) Sendung;Irrläufer
-Errichtung;Konstruktion;Bau
-Bar;Schanktisch;Schankraum;Ausschank;Theke;Schank;Tresen
-Unbegreiflichkeit;Unfassbarkeit
-Kübel;Wanne;Bottich;Trog;Zuber;Tank
-strukturiert;ordentlich;mit System;geordnet;systematisch;planmäßig
-Heilbad;Kurbad;Heilquelle;Badeort;Bad
-antitumorös (fachspr.);geschwulsthemmend
-Familienzuschlag;Familienzuschuss
-weg;fern;Fern...
-Mitbeklagter;Mitangeklagter
-Ehescheidung;Scheidung;Ehe-Aus;eheliche Trennung
-Knochenerweichung;Osteomalazie (fachspr.)
-Grenzkosten;Differenzkosten
-in Revision gehen;Widerspruch einlegen;Revision einlegen;in Berufung gehen;Berufung einlegen
-tauen;betauen
-Herbstbeginn;Herbstanfang
-seelisch;geistig;gedanklich;innerlich;mental;psychisch
-Stofftier;Kuscheltier;Plüschtier
-Konzession;Zugeständnis
-Abnormität;Anomalie;Auffälligkeit;Unregelmäßigkeit;Normabweichung;Regelwidrigkeit;Besonderheit
-Spund;Zapfen
-Lastschriftenanzeige;Lastschriftanzeige
-Kassette;Schatulle;Kästchen;Döschen
-tadeln;rüffeln;schimpfen;jemandem etwas geigen (ugs.);schelten
-Ulcus pepticum (fachspr.);Geschwulstbildung im Magen
-Eigenschaftswort;Adjektiv;Wiewort (ugs.)
-Klempnerarbeit;Klempnerei
-Eileiterentzündung;Salpingitis (fachspr.)
-Verdorbenheit;Verkommenheit;Verrufenheit;Verworfenheit (geh.);Schlechtigkeit (Hauptform);Verderbtheit (geh., altertümelnd, ironisierend)
-die Wasserausscheidung hemmend;antidiuretisch (fachspr.)
-zusammenrollen;aufrollen
-Felsvorsprung;Gesims
-Flugzeugabwehrkanone;FlaK (Kurzform, selten);Flakgeschütz;Flugabwehrkanone;Flak (Kurzform);Fliegerabwehrkanone
-Flipflop;bistabile Kippstufe;bistabile Kippschaltung
-Muster;Normal (fachspr.);Modell;Prototyp
-Luke;Lukentür
-Europäische Gemeinschaft;EG (Abkürzung)
-maßgeschneidert (auch figurativ);entsprechend den Wünschen hergerichtet;individuell;zugeschnitten (auf) (fig.);individualisiert (fachspr.);nach den (besonderen) Wünschen des Kunden (angefertigt);angepasst (an)
-Geschwätzigkeit;Schwatzhaftigkeit;(zu) vieles Reden
-Pseudotumor;Scheingeschwulst
-selektieren;(die) Spreu vom Weizen trennen (fig.);selektionieren;aussieben;auswählen;sieben (ugs.);ermitteln;auslesen;heraussuchen;herauspicken
-eingehen auf;sprechen über;Thema sein (zwischen);erörtern;wörteln (österr.);besprechen;durchsprechen;Gesprächsstoff sein;diskutieren;bereden;reden über
-Scheidewand;Septum (fachspr.)
-Fortschritt;Schritt nach vorne (fig.);großer Sprung nach vorn (fig.);Verbesserung;Quantensprung (ugs., fig.);Fortentwicklung;Progress
-Stube;Gemach (geh., veraltend);Rumpelkammer (ugs., abwertend);Raum (Hauptform);Gelass (geh.);Räumlichkeit (fachspr., Jargon);Kabinett (geh., österr.);Kammer;Zimmer (Hauptform);Loch (ugs., abwertend);Bude (ugs.);Kabuff (ugs., abwertend)
-IRC (Abkürzung, engl.);International Red Cross (engl.);IRK (Abkürzung);Internationales Rotes Kreuz
-verdeckt;geheim;hinter den Kulissen (fig.);getarnt;im Untergrund;klandestin (veraltend);hinter jemandes Rücken (fig.);heimlich
-demütigen;entwürdigen;niedermachen;entehren;beschämen;erniedrigen
-bemessen;festsetzen (auf)
-Bedienstand;Leitstand;Führerstand;Messwarte;Leitwarte
-Teilnehmerverfahren;Zeitteilverfahren
-fiebersenkendes Mittel;Antipyretikum
-Dynamo;Gleichstromerzeuger
-lästig werden;(jemandem) auf die Eier gehen (derb);(jemandem) auf den Zeiger gehen (ugs.);(jemandem) auf den Senkel gehen (ugs.);(jemandem) auf den Keks gehen (ugs.);(jemandem) auf die Nerven gehen;...schreck;(jemandem) auf den Wecker gehen (ugs.);(jemandem) auf den Wecker fallen (ugs.);(jemandem) auf den Sack gehen (derb);(jemanden) auf den Mond schießen (können) (ugs., fig., kommentierend);(jemandem) den letzten Nerv rauben (ugs.);Überdruss / Ablehnung hervorrufen;(jemandem) auf die Nüsse gehen (derb);nerven
-Deckenträger;Deckenbalken
-Kranführer;Kranfahrer
-poliert;gereinigt;gewienert;sauber;gesäubert;geputzt
-frustrieren;unbefriedigt lassen;enttäuschen;desillusionieren;entmutigen;deprimieren
-Sektor;Region;Raum;Platz;Horizont;Rayon (schweiz., österr.);Fläche;Areal;Sphäre;Ort;Bereich;Gegend
-naturverbunden sein;naturnah leben
-mummeln (ugs.);schnurpseln (ugs.);mümmeln (ugs.);nagen;knabbern;knuspern
-verbindlich;diensteifrig
-Netz der Stromleitungen;Stromnetz
-Dyspnoe (fachspr.);Atemstörung
-Drosselspule;Drossel
-Imker;Bienenzüchter
-Wesen (wie) von einem anderen Stern;Fremdling;Unbekannter;Fremder
-Transporteur;Bote;Überbringer;Übermittler;Träger
-rechtssprechende Gewalt (fachspr.);(die) Gerichte;(der) (lange) Arm des Gesetzes (fig.);(die) Mühlen der Justiz (fig.);Rechtswesen;Rechtsprechung;Justiz;Gerichtsbarkeit;(Frau) Justitia (Allegorie);Judikative (fachspr., lat.);dritte Gewalt;richterliche Gewalt;Justizgewalt
-vernachlässigen;überhaupt nicht beachten (ugs.);(sich) nicht (ausreichend) kümmern (um);(sich) futieren (sich foutieren) (schweiz.);(sich) einen Dreck scheren (um) (derb)
-Zwirn;Garn;Faden
-bullern (Feuer);knistern;prasseln;knacken (Holzscheit)
-Giarol;Rostflügel-Brachschwalbe
-kurzer Satz;Wortverbindung
-kümmerlich;karg;armselig;mau (ugs.);spärlich;dürftig;mager;knapp;kärglich
-Legespiel;Puzzle;Puzzlespiel
-verabreichen;applizieren;darreichen
-Spange;Schnalle
-Unbotmäßigkeit;Widerspenstigkeit
-prangen;protzen;prunken
-Tafel (geh.);Tisch;Esstisch
-Scheckheft;Scheckbuch
-(Blick) heften;fixieren;(Aufmerksamkeit) richten (auf)
-katalogisieren;inventarisieren;Bestand aufnehmen;Bestand erfassen
-einmal gebrannt;roh gebrannt
-Nachspann;Abspann;Bandende
-Verzögerung;zeitlicher Abstand;Latenzperiode;Latenzzeit
-Verwahrer;Verwahrstelle;Hinterlegungsstelle
-Detailgeschäft (schweiz.);Kauf(manns)laden (veraltend);Einzelhandelsgeschäft;Ladengeschäft
-ebenfalls;ebenso;fernerhin;gleichermaßen;sowie;sowohl als auch (ugs.);auch;im gleichen Sinne;genauso;gleichfalls;dito
-Gurt (schweiz.);Koppel (Uniform);Gürtel
-Rehydratation (fachspr.);Zufuhr von Wasser oder Salzlösungen
-Gallensekret;Galle
-Ausnahmefall;besonderer Fall;spezieller Fall;Spezialfall;Ausreißer;Sonderfall
-Rückprall-Effekt;Rebound-Effekt
-ohne feste Bindung;ehelos;partnerlos;ungebunden;ohne Partnerin;(noch) frei;keine(n) abbekommen (haben) (ugs., abwertend);unbemannt;solo;unverehelicht (fachspr., Papierdeutsch);allein lebend;hat keinen abgekriegt (ugs., abwertend);(noch) zu haben;unvermählt;alleinstehend;Single;nicht liiert;ohne Mann;unbeweibt (scherzhaft, veraltet);nicht verpartnert (Amtsdeutsch);ohne Partner (lebend);ohne Partner;ohne Frau;unverheiratet;sitzen geblieben;allein;ledig
-(jemanden) bestellen (zu);(jemanden) ernennen (zu) (Hauptform);(jemanden) berufen;(in ein Amt / eine Funktion) einsetzen;(jemanden) installieren (geh., salopp);bestimmen (zu);(jemanden) bestallen (zu / als) (Amtsdeutsch)
-Lehrbeauftragter;Dozent;Vortragender;Lehrender
-Syllabus (fachspr., selten);Überblick;Zusammenschau;Zusammenfassung;Übersicht;Gesamtschau
-Verfügbarkeitskontrolle;Mengenverfügbarkeitskontrolle
-abgestimmt;angepasst
-zupfen;rupfen
-Verteilung;Ausstreuung
-stützen;verankern;befestigen;verstreben;abstützen;versteifen
-Alterchen;Gevatter;Väterchen
-nichts wert;zu nichts nütze;überflüssig;sinn- und zwecklos (Hauptform);(den/die/das) kannst du in der Pfeife rauchen (ugs., fig.);verzichtbar (geh.);wertlos;entbehrenswert (geh.);(sich) erübrigen;nutzlos;zu nichts nutze;umsonst;Spielerei (ugs.);die Mühe nicht wert;zwecklos;unnötig;(sich etwas) sparen können (ugs.);unnotwendig;der Mühe nicht wert (geh.);fruchtlos;unnütz;überflüssig wie ein Kropf (ugs.);ohne Sinn und Zweck;entbehrlich (geh.);Muster ohne Wert;sinnlos;(sich etwas) schenken können (ugs.);müßig (geh.);akademisch (geh.);nicht der Mühe wert (geh.);nichts bringen (ugs.)
-von innen kommend;endogen;im Körper entstehend;innen entstehend
-Unbequemlichkeiten bereiten;nerven (ugs.);behelligen;molestieren (geh., lat., veraltend);(jemanden) stören (Hauptform);ablenken;inkommodieren (geh., lat.);in Anspruch nehmen;(jemanden) derangieren (geh., veraltet);irritieren;(jemandem) Umstände machen;unterbrechen;belästigen;(jemandem) Ungelegenheiten bereiten (geh., veraltend)
-Zylinderkopfschraube;Zylinderschraube
-Kulturkreis (fachspr.);Kultur;Zivilisation;Hochkultur
-Gehacktes;Hack (ugs.);Gewiegtes;Hackfleisch;Faschiertes (bayr., österr.);Haschee
-(intime) Details preisgeben;durchstechen (geh.);ausplaudern;vor den Augen der Öffentlichkeit ausbreiten;enthüllen;(jemandem etwas) stecken (ugs.);aus dem Nähkästchen plaudern (ugs.);(jemandem etwas) auf die Nase binden (ugs., fig.);verraten;spoilern (ugs., engl.);(Geheimnis) lüften;lancieren (geh.)
-(eine Aktivität) betreiben (Hauptform);abwickeln;ausüben;verrichten;(einer Aktivität) nachgehen;sich betätigen;praktizieren
-Hammerkopf;Rammklotz
-vorgefertigte Lösung;Strickmuster (fig.);Rezept;Muster;Anleitung;Schema;Formel
-lädieren;zerschlagen;kaputt machen;kaputtmachen
-Tarifgruppe;Lohngruppe
-Regulator;Regulierer;Regler;Steuergerät
-zu verheimlichen versuchen;manipulieren;(etwas) unter den Teppich kehren (ugs., fig.);zudecken;verdecken;verschleiern;vertuschen
-altklug;vorlaut;klugscheißerisch (derb);redet wie ein Alter;weiß alles besser;keck;neunmalklug (veraltend);vorwitzig (geh.);naseweis (veraltend);siebengescheit;frühreif
-Einheitlichkeit;Homogenität;Gleichwertigkeit;Gleichartigkeit
-eierschalenfarben;drapp (österr.);cremefarben;beige (franz.);gelblich weiß;sandfarben
-Beständigkeit;Kontinuität;Langlebigkeit;Perennität (veraltet);Dauerhaftigkeit;Stetigkeit
-Krauskohl (ugs.);Grünkohl;Braunkohl;Blattkohl;Winterkohl
-nachgewiesen;begutachtet;geprüft
-Regime;Regierungsform;Regierung;Herrschaftsform
-Blöker;Gelbstrieme
-überirdisch;elysisch (geh.);nicht von dieser Welt;paradiesisch;himmlisch;empyreisch (poetisch, selten);göttlich
-Verdichter;Kompressor
-übel gelaunt;verstimmt;unpässlich
-siebter Sinn (ugs.);Gefühl;Instinkt;Eingebung;Spürsinn;Intuition;Ahnung;so ein (undeutliches) Gefühl (ugs.);innere Stimme;Bauchgefühl;Vorahnung;sechster Sinn (ugs.);Gespür
-Workaholic;Arbeitswütiger;Arbeitssüchtiger;Arbeitstier;Held der Arbeit (ironisch)
-Anleger;Investor;Geldgeber;Kapitalanleger;Finanzier
-Schmiedestahl;Baustahl
-unfolgsam;ungehorsam
-Umformung;Umspannung
-um sich greifen;(sich) ausbreiten;Hochkonjunktur haben (fig.);(sich) verbreiten;grassieren;umgehen;Platz greifen (geh.);(sich) breitmachen (ugs.);viele Anhänger finden (Idee);(stark) im Kommen (sein);Verbreitung finden;mehr werden (ugs.);(mächtig) ins Kraut schießen (fig.);Konjunktur haben (fig.);auf dem Vormarsch (sein) (fig.)
-IWF;Internationaler Währungsfonds
-gehässig;dreckig (Lachen, Lache);spöttisch;hämisch;höhnisch
-fanatisch (negativ);Vollblut... (mediensprachlich);(sehr) engagiert;mit großem Engagement;rückhaltlos;glühend;mit großem Einsatz;begeistert (leidenschaftlich) (Hauptform);mit Leib und Seele (dabei);mit ganzer Seele;vehement;voller Hingabe;mit (viel) Herzblut;hingebungsvoll;mit Hingabe;fleißig;heiß und innig (lieben);leidenschaftlich;intensiv;flammend (geh., fig.);enthusiastisch;voller Leidenschaft
-angezeigt;(dringend) zu empfehlen;sehr zu empfehlen;zu raten;tunlich (veraltend);ratsam;angebracht;empfiehlt sich;am Platz;geraten
-worauf du einen lassen kannst (ugs., scherzhaft);todsicher (ugs.);unausweichlich;zweifellos;wahrlich;zweifelsohne;gewiss;absolut;so gut wie sicher;in jedem Fall;außer Zweifel (geh., veraltet);komme was (da) wolle;sei versichert (dass) (geh.);bestimmt;(ey Alter,) ich schwör (Jugendsprache, Substandard) (ugs.);mit Bestimmtheit;unbedingt;es sei Ihnen versichert (dass) (geh.);ganz bestimmt;definitiv;sicher;seien Sie versichert (dass) (geh.);auf jeden Fall (ugs.);ohne Zweifel;hundertpro (ugs.);jedenfalls (ugs.);garantiert (ugs., fig.);mit Sicherheit;allemal (ugs.);unter allen Umständen;ohne Frage;(so) sicher wie das Amen in der Kirche;unzweifelhaft;partout (ugs.);fraglos;worauf du dich verlassen kannst! (ugs., Redensart)
-Genuss;Lust;Gaudi (ugs.);Spaß;Wohlgefallen;Fun (ugs., Jargon, engl.);Fez (ugs.);Bock (ugs.);Vergnügen;Freude
-hinüberlaufen;hinüberrennen
-Anregung;Belebung;Stimulation;Ansporn
-so sehr ich es (auch) bedaure, (aber) (Einschub);bedauerlicherweise;zu meinem Bedauern;dummerweise (ugs.);leider Gottes (ugs.);zu meinem Unglück;das Unglück wollte es, dass (geh.);enttäuschenderweise;so leid es mir (auch) tut, (aber) (Einschub, floskelhaft);ärgerlicherweise;zu allem Unglück;unseligerweise;sehr zum Pech (einer Person);ungünstigerweise;Gott sei's geklagt (geh., Einschub, veraltend);(es) tut mir schrecklich leid, (aber);blöderweise (ugs., salopp);zu meinem Leidwesen;unglücklicherweise;unerfreulicherweise;leider (Hauptform);zu (jemandes)(großen) Bedauern (personenvariabel);fatalerweise
-Leiterkarte;Platine;Leiterplatte;gedruckte Schaltung
-Ansprache;Anrede;Adressieren;Adressierung
-nordwärts;nördlich;gen Norden
-berauben;abziehen (ugs.);beklauen (ugs.);bestehlen;ausrauben;überfallen
-Krise in der Mitte des Lebens;Midlife-Crisis;Midlifecrisis
-ineinander stecken;zusammenstecken
-Stahlband;Federband
-klingeln (Hauptform);gongen;bimmeln (ugs.);schellen;die Klingel betätigen;läuten
-Wohlklang;Harmonie
-ausspülen;herauslösen;eluieren
-Sexshop;Sexboutique
-schwächen;angreifbar machen;(an etwas) zehren;anfällig machen;angreifen;beeinträchtigen (Hauptform)
-Zubehör;Zubehörteile (Plural)
-vervollständigen;zur Reife bringen;arrondieren (geh., franz.);abrunden;komplementieren;komplettieren;abschließen;vervollkommnen;ergänzen;vollenden
-Diplomatenkoffer (fig., scherzhaft-ironisch);Attachékoffer;Aktentasche;Aktenkoffer
-erhaben;sublim
-Bildermacher;Lichtbildner (veraltet);Fotograf;Photograph
-Bramme;Roheisenblock
-ausklingen;schwächer werden;leiser werden
-klirren;rasseln;scheppern;schmettern
-Lymphom (fachspr.);Lymphknotenschwellung
-Unternehmen;Laden (ugs., salopp);Firma;Fa. (Abkürzung);Betrieb
-Kreuzfahrer;Glaubenskrieger;Kreuzritter
-Steckdose;Fassung
-abhacken;abschlagen
-Inhalt;Gegenstand;Sujet (künstlerisch);Gehalt;Thema (Hauptform);Stoff
-herfallen über;(sich) stürzen auf
-anfertigen;herstellen;verbrechen (sarkastisch oder scherzh.) (ugs.);fabrizieren (ugs.);machen (ugs.);schaffen;erzeugen;erstellen;verfertigen (selten);fertigen;generieren
-nur dass (ugs.);allerhöchstens;abgesehen (von);ausgenommen;höchstens dass (ugs.);höchstens;es sei denn (ugs.);bis auf;wenn überhaupt (dann);außer
-Maschinenkodierung;einfache Kodierung;Grundkodierung
-Uvula (fachspr.);Gaumenzäpfchen;Halszäpfchen
-Emesis (fachspr., griechisch);Erbrechungen;(das Sich-)Übergeben;Vomitus (fachspr., lat.);Erbrechen
-Familienmitglied;Gevatter (veraltet);Anverwandter;Verwandter;Familienangehöriger;Angehöriger
-Ozean;Meer;(die) See;Weltmeer (geh., literarisch)
-Radiumtherapie;Radiumheilverfahren
-Unmaß;Grenzenlosigkeit;Füllhorn (an);Orgie (...orgie) (fig.);Unmenge (an);Überangebot;Schrankenlosigkeit;Überfülle;Übermaß;(ein) Zuviel (an);Überfluss;Exzess
-gründlich;rigoros;fundamental;entschieden;grundlegend;radikal
-Vorahnung;Gefühl;Befürchtung;Ahnung;Besorgnis;Vorgefühl
-wild;ungestüm;(es gibt) kein Halten mehr (variabel);voller Elan;impulsiv;total aus dem Häuschen (ugs.);überschäumend (fig.);stürmisch;völlig aus dem Häuschen (ugs.);vogelwild (ugs., Jargon, süddt.);ungezähmt;mit Überschwang;als ob es kein Morgen gäb(e) (ugs., Redensart);ungezügelt;ausgelassen;überschwänglich;übermütig;ganz aus dem Häuschen (ugs.);bacchisch;unbändig;außer Rand und Band (ugs.)
-Tönung;Farbe;Nuance;Kolorit;Schattierung;Ton;Schimmer;Farbton
-Schandmal;Schandfleck;Schönheitsfehler;Beleidigung fürs Auge;Makel
-empfiehlt sich;patent;dienlich;praxistauglich;praktikabel;empfehlenswert;zweckmäßig;praktisch;geschickt (ugs., süddt.);zweckdienlich
-Abdruck;Gepräge;Abguss;Guss;Abbildung
-Abweichung;Volatilität (fachspr.);Fluktuation;Auf und Ab;Schwankung;Unstetigkeit;Turbulenz
-Umlauf;Umwälzung
-Lichtspieltheater;Kino (Hauptform);Kintopp (ugs., veraltet);Lichtspielhaus;große Leinwand (ugs.);Filmtheater
-Forschungsteam;Forschungsgruppe
-Photosensibilität;Lichtempfindlichkeit
-unvergleichbar;nicht vergleichbar
-Scheinwerfer;Flutlicht
-Begrenzer;Abgrenzer
-elastisch;geschmeidig;schlangenartig
-Blutgerinnsel;Thrombus (fachspr.)
-Anfälligkeit (für) (medizinisch);Neigung (zu);Hang (zu);Affinität (zu);Tendenz (zu)
-diverse;unterschiedliche;verschiedene;ausgewählte
-Schutzanzug;...kombi (ugs.);Rüstung;Ganzanzug;Einteiler;Overall (Hauptform);Blaumann;...kombination
-Kämpe (veraltet oder ironisch) (geh.);Kämpfer;Krieger;Streiter;Soldat
-Schau;...kabinett;Exposition (geh.);Ausstellung
-Diätetik;Diätlehre;Diätologie
-Mark (fränk.);Randgebiet;Grenzgebiet;Anewand (oberdeutsch)
-Standard...;voreingestellt
-Nidation (fachspr.);Implantation;Einnistung
-Sorge (wegen, um);Unausgeglichenheit;Missbehagen;Unruhe;Gedanken;Besorgnis;Unbehagen
-edukativ;aussagekräftig;informierend;sehenswert;aufschlussreich;erstaunlich;(etwas) lässt tief blicken (ugs.);lehrreich;informativ;erhellend;bemerkenswert;wissenswert;belehrend;staunenswert (geh.);interessant
-böser Traum;(meist Mehrzahl:) schlimmste Träume;Alptraum;Nachtschaden;Nachtmahr (veraltet);schlechter Traum;Albdruck;Albtraum;Alpdruck;Angsttraum
-Anstrengung;Anspannung;Kraftaufwand
-Zähigkeit;Zähflüssigkeit;Viskosität
-Freie Demokratische Partei;Gelbe (die Gelben);Liberale;(die) Partei der Besserverdienenden (ugs.);FDP (Abkürzung)
-katholisch;kath.
-bei jemanden vorsprechen;jemanden besuchen
-Gebiss;Zähne;Kauleiste (ugs.);Beißer (ugs.)
-lichtmagnetisch;photomagnetisch
-(sich) legen (ugs.);nicht für die Ewigkeit (sein);zu Ende gehen;zum Ende kommen;vorbeigehen;vergehen;vorübergehen
-Separatismus;Loslösungsbestreben;Sezessionsbestrebungen;Autonomiestreben
-Marine...;von der Marine;Flotten...
-Überdosierung;Überdosis
-Seitenzahl;Seitennummer
-Laubsäge;Stichsäge;Wippsäge;Laubsägemaschine
-Nominalkapital;Grundkapital
-Blech;Walzblech
-säurebindendes Mittel;Antazidum (fachspr., lat.)
-Bücherbord;Wandbrett;Bücherbrett;Bord;Abstellbrett
-unverhüllt;unverblümt;nackt
-Delfin;Butterfly;Schmetterlingsschwimmen;Schmetterling;Delphinschwimmen;Delphin;Delfinschwimmen
-Brutkasten;Brutschrank;Inkubator
-Bandbeschichtung;Bandbeschichten
-Update (engl.);Neuauflage;Neuausgabe
-Restbestand;Hinterlassenschaft;Residuum (fachspr.);Rest (Hauptform);Rückstand
-strenge Ausbildung;Drill;Exerzieren
-Libretto (fachspr., ital.);Drehbuch;Skript;Textbuch
-Faksimile;(aufwändige) Reproduktion;genaue Kopie
-Kirchentonarten;Modi
-Ökosystem;Umwelt;Natur;Mutter Natur (ugs.)
-Somnolenz (fachspr.);Benommenheit mit Schläfrigkeit
-Gegenwart;Präsenz;Zugegensein (geh.);Beisein;Dasein;Anwesenheit (einer Person) (Hauptform)
-Fitsch (ugs., ruhrdt.);Preisknaller (ugs., werbesprachlich);Occasion (schweiz.);Preiskracher (ugs., werbesprachlich);Superschnäppchen (ugs.);Gelegenheitskauf;Mezzie (österr.);Preisknüller (ugs., werbesprachlich);Preishammer (ugs., werbesprachlich);Preishit (ugs., werbesprachlich);Schnäppchen (ugs., Hauptform);Sonderangebot (Hauptform)
-Schimmer;Flimmer
-hepatisch (fachspr.);die Leber betreffend
-Gallensteinleiden;Cholelithiasis (fachspr.)
-Kampflust;Kampfbegierde
-Bedienpanel;Bedienungsfeld;Schalterleiste
-Werbemittel;Werbemedium;Werbeträger
-Belgien, Niederlande, Luxemburg;Benelux;Beneluxländer;Beneluxstaaten
-zugewandert;eingereist;eingewandert;immigriert
-souverän;forsch;selbstsicher;selbstbewusst;mit breiter Brust;(sehr) von sich überzeugt
-rauschen (ugs.);strömen;fließen;fluten;rinnen;quellen
-Allozierung;Zuordnung;Allokation (fachspr., lat.)
-zerschrammen;schrammen;durchfurchen
-Mittelmaß;Mittelwert;Mittel (ugs.);Schnitt;arithmetisches Mittel (fachspr.);Durchschnitt;Durchschnittswert
-aufwerten;zugutekommen;(sich) vorteilhaft auswirken (für);guttun;(jemandem) in die Karten spielen (ugs.);(jemandem) in die Hände spielen (ugs.);nützen;bereichern;(zu etwas) dienen;(jemandem) in die Arme spielen (ugs.);(jemandem) zu Hilfe kommen (passiv);nutzen;begünstigen;zu jemandes Vorteil gereichen;fördern
-(wieder) geradebiegen;(Missstand) abstellen;lösen;(wieder) ins Reine bringen;klären;abhelfen;(Mangel) beheben;(Fehler) ausmerzen;Abhilfe schaffen;aus der Welt schaffen;(Problem) bewältigen;in Ordnung bringen;bereinigen;(Problem) beseitigen;(wieder) ins Lot bringen (fig.);(die) Kuh vom Eis holen (fig.)
-Untertan;Leibeigener;Sklave;Fronarbeiter
-Facette;Seite;Aspekt;Fassette (alte Schreibung bis 2011)
-halb;ziemlich;einigermaßen (Hauptform);durchaus;schon ganz (ugs.);relativ;vergleichsweise;mäßig (geh.);recht (ugs.);ganz (ugs.);leidlich (geh.);halbwegs (ugs.);eher;reichlich;verhältnismäßig;nicht un...;ganz schön (ugs.);in Grenzen (geh.);hinlänglich (geh.)
-Batterieladegerät;Ladegerät;Akkuladegerät
-ausräumen;verlagern;räumen;auslagern;migrieren
-Todesopfer;Opfer
-kümmerlich;schwach;gering;wenig
-mit Zwischenblättern versehen;durchschießen
-Thrombozyt (fachspr.);Blutplättchen
-im Einzelfall;In einigen Fällen;(so etwas hat man) nicht alle Tage (ugs., variabel);kaum mehr;in einzelnen Fällen;selten (Hauptform);punktuell;einzelne Male;kaum;rar (geh.);gelegentlich;kaum noch;wenige Male;nicht oft;wenig
-brizzeln (Kurzschluss);knistern;spritzeln;zischen;zischeln
-undeutlich;diffus;schemenhaft;schleierhaft;nebelhaft;verschwommen;vage;konturlos;unklar;nicht deutlich zu erkennen;nebulös;nicht klar zu erkennen
-verzweigen;verästeln
-Struktur;Gefüge;Matrix;Gitter;Mikrostruktur
-total besoffen (ugs.);rotzbesoffen (ugs.);hackedicht (derb);sturzbetrunken;stockbesoffen (ugs.);sternhagelvoll (ugs.);sturzbesoffen (ugs.);sternhagelblau (ugs.);stark betrunken (Hauptform);volltrunken
-tugendhaft;züchtig;standhaft;anständig;tugendsam;sittsam;vernünftig (ugs.);gesittet;rein;moralisch;moralinsauer (geh., abwertend);ordentlich (ugs.);moralistisch (oft abwertend) (geh.)
-der Jüngere;jun.;Junior;jr.
-begünstigen;in die Hände spielen;Vorschub leisten;weiterbringen;Tür und Tor öffnen;voranbringen
-Arbeitswissenschaft;Arbeitswissenschaften (Plural);Ergonomie;Ergonomik
-schmackhaft;pikant
-Pflichtgefühl;Pflichtbewusstsein
-(sich) verkleiden als;(sich) ausgeben als
-Silizium-Wafer;Siliziumscheibe
-Destillerie;Schnapsbrennerei;Brennerei;Branntweinbrennerei;Destille
-legen;einstellen (fachspr.);stellen;setzen;tun (ugs., salopp)
-Dämpfungsmaß;Lehr'sches Dämpfungsmaß;Dämpfungsgrad
-Shampoon;Haarwaschmittel;Haarpflegeshampoo;Shampoo;Haarshampoo
-biliär (fachspr.);Gallen...
-zu (ugs.);dicht;gesperrt;geschlossen
-putzig (ugs.);niedlich;knuffig;goldig;possierlich;süß (ugs.);drollig;knuddelig
-kardanische Lagerung;kardanische Aufhängung
-Slalom;Torlauf
-auskundschaften;ausspähen;ausspionieren;erkunden;ausbaldowern (ugs.)
-öffnen;aufmachen (ugs.)
-Rückfluss;Reflux
-krustig (Brot) (ugs.);knusprig
-Knick;Stauchung
-Wechselbank;Akzeptbank
-unsäglich;unsagbar;unaussprechlich
-Anführung;Führung;Leitung
-Auswanderung;Exodus;Abwanderung;Emigration
-Hodenentzündung;Orchitis (fachspr.)
-transformieren;verwandeln;umgestalten;konvertieren;überführen;umwandeln;umformen
-Parasitismus;Schmarotzertum
-Position;Stellung;Standpunkt;Lage
-Soße;Sauce;Tunke;Dip
-bis;solange bis
-fluchen;verdammen;maledeien (veraltet);verfluchen
-dezentral;am Rand gelegen;peripher
-Schlafstelle;Schlafplatz
-ausgeschöpft;abgenutzt
-Großcomputer;Großrechner;Dinosaurier (ugs.);Mainframe (engl.)
-nach Verdienst;wert;entsprechend;würdig;nach Wert
-grollen (Hauptform);murren;knurren;brummen;grummeln;raunzen
-rheumatoid;rheumaähnlich
-Rücklaufsperre (fachspr.);Knarre;Ratsche;gezahnte Sperrstange;Sperrklinke (fachspr.)
-hin- und hergerissen sein (ugs.);(sich) nicht entscheiden können (zwischen);(sich) nicht festlegen (wollen);(einen) Eiertanz aufführen;schwanken (zwischen) (ugs.);herumtun (ugs.);herumeiern (ugs.);Eiertänze vollführen;sich nicht festnageln lassen;unentschlossen sein (Hauptform);Festlegungen vermeiden
-vorladen;auffordern
-Striptease;Tabledance;Strip;Entkleidung;Entkleidungsnummer
-lässlich (relig.);entschuldbar;verzeihlich;verzeihbar
-etwas darstellen (Person);(eine) (beeindruckende) Persönlichkeit sein;(jemandem) Ehrfurcht einflößen;(jemand) von Format;Eindruck schinden (abwertend);beeindruckend sein;etwas vorstellen (Person);(jemanden) mit Ehrfurcht erfüllen;(eine) imponierende Erscheinung (floskelhaft, variabel);Wirkung haben;(etwas) hermachen;imponierend (sein);(jemandem) imponieren;(sich) zur Geltung bringen;beeindrucken;(ein) Statussymbol (sein);bestechen;(eine) Ausnahmeerscheinung (sein);(jemandem) Eindruck machen
-Kauf;Anschaffung;Erwerbung;Einkauf;Ankauf;Übernahme;Aufkauf;Erwerb;Akquisition (geh.);Akquise (ugs.)
-gerädert werden;aufs Rad geflochten werden
-Schwäche (für);Präferenz (fachspr.);Vorliebe;Hang (zu);Bevorzugung;Prädilektion (geh., veraltet);Neigung;Faible (für) (franz.)
-Gesichtsfeldausfall;Skotom (fachspr.)
-Obligation;Bond (engl.);Anleihe;Schuldverschreibung;festverzinsliches Wertpapier;Rentenpapier
-kundig;fachkundig
-Öde;Gleichförmigkeit;Einerlei;Ennui (geh.);Langeweile (ugs.);Eintönigkeit;Monotonie;Stumpfsinn;Langweile (ugs.);Ödnis
-Einrückung;Einzug (Text)
-(spezielle) Abkürzung aus (den) Anfangsbuchstaben (der Wörter);Initialwort (fachspr.);Akronym (fachspr., Hauptform)
-Bieruntersetzer;Bierdeckel;Bierfilzl;Bierfilz
-Aufzug (fachspr.);Akt (fachspr., auch figurativ)
-maßstabsgetreu zeichnen;maßstabsgerecht zeichnen;auftragen
-heiratsfähig;mannbar
-rumstehen (ugs.);abhängen (ugs.);herumstehen;rumlungern (ugs.);(sich) herumtreiben;herumlungern;(sich) rumtreiben (ugs.);rumhängen;herumgammeln (ugs.);(sich irgendwo) herumdrücken
-zittrig;schlottrig;zitterig;schlotterig
-Pastoralstab;Virga;Bischofsstab;Lituus;Krummstab;Abtsstab;Pastorale;Pedum;Hirtenstab
-vorsehen;einschließen;einplanen
-nicht enden wollen;(es ist) kein Ende in Sicht;Endlos...;endlos;endlos weiter;immer weiter;unbeschränkt;(es ist) kein Ende abzusehen;unmessbar;bis zum Gehtnichtmehr (ugs.);Dauer...;...marathon;unzählig;ad infinitum (lat.);nicht abreißen;nicht enden wollend;überlang;unermesslich;Marathon...;unendlich;unaufhörlich;uferlos
-Bistum;Diözese
-Kennzeichen;Stempel
-Gerätschaft;Gerät;Vorrichtung;Apparatur;Apparat
-Peritonitis (fachspr.);Entzündung des Bauchfells
-uff (ugs., Hauptform);puh (ugs.)
-Küken (ugs., fig.);blutiger Anfänger (ugs.);Greenhorn (ugs., engl.);Noob (ugs., Jargon, engl.);Jungfuchs (ugs.);Nullanfänger (Sprachkurs);Neuling;frisch von der Uni (ugs.);junger Spritzer (ugs.);Kadett (ugs.);junger Spund (ugs.);Newcomer (engl.);Anfänger;unbeschriebenes Blatt (ugs., fig.);Spund (ugs.);Fuchs (ugs.);neu hier (sein) (ugs.);noch nicht lange dabei (ugs.);Novize;frisches Blut (ugs., fig., scherzhaft);Debütant (geh.);Jungspund (ugs., seemännisch);der Neue / die Neue (ugs.);Youngster (ugs., engl.);Neueinsteiger;junger Hüpfer (ugs.);Rotarsch (derb, militärisch);Einsteiger;neu im Geschäft;Nachwuchs...;Springinsfeld (ugs.);Rookie (ugs.);Frischling (ugs., ironisch, scherzhaft);Grünschnabel (ugs.);Newbie (ugs.);Milchbart (ugs.);junger Dachs (ugs.);Unerfahrener
-bedürftig;hilfsbedürftig
-kleines Fass;Fässchen
-Geldüberweisung;Geldsendung;Überweisung (ugs.);Geldanweisung
-stillen;laktieren;säugen
-zur Wange gehörend;buccal (fachspr.)
-täfeln;parkettieren;auslegen
-Anfahrtsweg;Anfahrt
-Armierungsmatte;Bewehrungsmatte
-verankern;verspannen
-Hochschule;Alma Mater (lat.);Akademie;Universität;College (engl.);Uni (ugs.)
-Rebe;Weinrebe;Rebstock;Weinstock;Wein
-Speichelfluss;Salivation (fachspr.);Speichelabsonderung
-Schwung;Erregung;Wallung
-Maß;Maßstab;Prüfstein (geh.)
-griffbereit;bereit liegend;in (unmittelbarer) Reichweite;parat (haben) (geh., auch figurativ);(direkt) vor mir (ugs.);bereit;(direkt) neben mir (ugs., variabel);vor der Nase (haben) (fig.);zur Hand;(schnell) bei der Hand (haben / liegen)
-verunsichern;irritieren;(jemanden) ins Nachdenken bringen;verwirren;ins Bockshorn jagen (ugs.);nachdenklich machen;(jemanden) beirren (geh.);in Verlegenheit bringen;durcheinanderbringen;derangieren
-Lumen;Einheit des Lichtstromes
-Beiwerk;Zierwerk;Parergon (geh., griechisch);Anhängsel;Beifügung
-uneingeschränkt;allmächtig;selbstständig;autokratisch (fachspr.);unumschränkt;souverän;absolut (geh.)
-Verdichtungsverhältnis;Kompressionsverhältnis
-Autorität;Amtsbefugnis
-zerknüllen;zerwühlen
-scharlachrot;orangerot;karminrot
-Ziege;Bock;Hippe (regional);Ziegenbock;Geiß;Geißbock
-Unterleibsentzündung;Adnexitis (fachspr.)
-Alleinstehender;nicht Liierter;Single;Alleinlebender;Junggeselle;Unverheirateter
-Hahn;Gockel
-Gemütsart;Gemütsanlage (geh.);Natur;Naturell;Format;Eigenart;Gepräge;Veranlagung;Wesenheit;Wesen;Gemüt;Charakter;Temperament;Persönlichkeit;Profil (fachspr.);Wesensart
-Tölpelei;Tollpatschigkeit;Unbeholfenheit;Ungeschicklichkeit
-Gemütszustand;(emotionale) Gestimmtheit (geh.);Gemütslage;Befindlichkeit;Gemütsverfassung;emotionale Verfassung (variabel);Stimmung;Gefühlslage
-Akt;Ablauf;Vorgang;Vorgehen
-zigfach;vielfach;multipel;mehrfach
-Aufschluss;Erschließung
-Vorsehung;Vorbestimmung;Prädestination;Fügung;Los;Karma (buddh.);Schicksal;Vorherbestimmung;Kismet (islam.);Zufall;Fatum;Bestimmung;Geschick;Schickung
-erledigen;besorgen;schaffen
-Embolie (fachspr.);plötzlicher Verschluss eines Blutgefäßes
-knuddeln (ugs.);herzen;drücken (ugs.)
-nervig (ugs.);beschwerlich;mühevoll;belastend;schwer;in mühevoller Kleinarbeit (floskelhaft);anstrengend (ugs.);lästig;mühselig;verdrießlich
-einstielen (ugs.);arrangieren;einfädeln;(einer Sache) den Weg bereiten (geh.);vorbereiten;anbahnen;in die Wege leiten;organisieren;auf den Weg bringen (geh.);(die) Weichen stellen (für) (fig.)
-inkl.;samt;unter Einschluss von;einschließlich (Hauptform);nebst (geh.);inklusive;mit;zusammen mit (ugs.);mitsamt;eingeschlossen (nachgestellt)
-auf den Index setzen;indizieren
-angegliedert;einig;verbunden;zugehörig;angeschlossen
-Einpflanzung;Implantation
-festlegen;(sich) Ziele setzen;vormerken;(sich) Ziele stecken;Pläne schmieden (ugs.);(einen) Plan fassen;(sich etwas) auf die Fahnen schreiben (fig.);(sich) daranmachen;in den Blick nehmen (fig.);(sich) anschicken;planen;(sich etwas) vornehmen;ins Auge fassen (ugs.)
-Zuschauer;Begutachter;Betrachter;Spektator;Beobachter;Beschauer;Publikum;Zuseher
-Kriegsflotte;Flotille;Flotte;Armada (span.)
-glucksen;kichern;in sich hineinlachen
-bei Verstand;vernünftig;im Vollbesitz seiner geistigen Kräfte (fachspr., juristisch);bei Sinnen (geh.);denkfähig;zurechnungsfähig;bei klarem Verstand;mit Verstand begabt;urteilsfähig;verständig
-Bewegungsvermögen;Motilität (fachspr.)
-eklig (ugs.);unerträglich;ätzend (ugs.);abstoßend;unausstehlich;unsympathisch;widerwärtig
-Tiefstkurs;Tiefststand
-unsittlich;sittenlos
-bereitstellen;bewilligen (Geld) (für)
-Werbesäule;Plakatsäule;Anschlagsäule;Litfaßsäule
-Seltsamkeit;Merkwürdigkeit;Kuriosität;Skurrilität;Sonderbarkeit
-Tragbalken;Träger
-Kontinent;Festland
-Beißzange;Kneifzange;Kantenzange
-Schraubstock;Schraubzwinge
-Balkan;Balkanstaaten
-Ultrakurzwelle;Ultrakurzwellenbereich;VHF;UKW
-Gerichtsbaum;Lindenbaum;Tanzlinde;Gerichtslinde;Dorflinde;Linde (Hauptform);Tilia (fachspr., botanisch)
-abgleichen;auswuchten
-beherrschen;bestimmen was gemacht wird;dominieren;die erste Geige spielen (ugs., fig.);überragen;überwiegen;vorherrschen
-(einzelner) Parkplatz;Abstellplatz;Parkbox;Einstellplatz;Stellplatz
-Vermarktung;Kommerzialisierung
-fehlleiten;falsch adressieren
-Energie;Leistungsabgabe;Dampf (ugs.);Leistungsfähigkeit;Schwung;Leistung;Kraft
-Haushaltsausschuss;Bewilligungsausschuss
-Unhold;Übeltäter;Missetäter;Bösewicht;Schuft;Lump;fieser Finger (ugs., abwertend, veraltet);Fötzel (schweiz.);Schurke;Übelmann;Schlitzohr;Tunichtgut;Canaille (derb, franz.);Gauner;Halunke;Frevler;linke Bazille (ugs.);(eine) miese Type (ugs.);Haderlump (bayr., österr.);übles Subjekt;Schubiack (ugs., regional);Spitzbube;Kanaille (derb);Strolch;krummer Hund (ugs., fig.)
-höchstens;günstigstenfalls;äußerstenfalls;max.;allenfalls;bestenfalls;im besten Fall;wenn es hoch kommt (ugs.);maximal;im bestmöglichen Fall(e);höchstenfalls
-Zeichen;Fleck;Mal
-Mit freundlichem Gruße;Mit freundlichen Grüßen;Freundliche Grüße;Mit besten Grüßen;Mit freundlichem Gruß
-Annullierung;Aufhebung
-Drüsenentzündung;Adenitis (fachspr.)
-Glocken (ugs.);Brüste (Plural, Hauptform);Titten (derb);Oberweite (ugs.);Büste (Singular);Möpse (derb);Mammae (fachspr., Plural, biologisch, medizinisch);Busen;weibliche Brust;Hupen (derb);Melonen (derb);Vorbau (ugs., fig.)
-Reliabilität;Systemstabilität;Verlässlichkeit;Zuverlässigkeit;Stabilität;Beständigkeit
-wegschicken;in die Wüste schicken (ugs., fig.);(eine) Absage erteilen;auflaufen lassen (ugs.);(jemanden) zurückweisen (Hauptform);abblitzen lassen (ugs.);einen Korb geben (ugs., fig.);ablehnen;(jemandem) die Tür vor der Nase zuschlagen;(jemandem) eine Abfuhr erteilen;fortschicken;von der Bettkante stoßen (ugs.);nicht eingehen auf;zurückstoßen;verschmähen;(jemanden) abweisen;wegweisen;(einen) abschlägigen Bescheid erteilen (Amtsdeutsch, veraltend);kalt auflaufen lassen (ugs.);(etwas) abschlägig bescheiden (Amtsdeutsch);(man) beschied ihn kühl, dass (geh., distanzsprachlich, floskelhaft);die kalte Schulter zeigen (ugs., fig.);abbügeln (ugs.);zur Hölle schicken (ugs.)
-Schmälerung;Entbehrung;Mangel;Opfer;Einschränkung;Einbuße
-Wiederverwertung;Wiederverwendung;Rückführung in den Wiederverwertungskreislauf (fachspr., Amtsdeutsch);Wiedergewinnung;Rohstoffrückgewinnung;Recycling;Downcycling (engl.);Wiederaufbereitung;Regeneration;Regenerierung
-Nomination (kirchenrechtlich) (fachspr., selten);Aufstellung;Nominierung
-deregulieren;privatisieren;dem freien Wettbewerb überlassen
-zum Greifen nahe sein;sich bald einstellen (Erfolg u.Ä.);nicht mehr fern sein;unmittelbar bevorstehen (Hauptform);in greifbare Nähe gerückt sein
-Gaffer (Film);Chefbeleuchter;Chef-Elektriker für die Beleuchtung
-(sich) beugen;erliegen
-Hahn;Spund;Zapfhahn;Zapfen
-an der Seite;nebenher;seitlich
-creepy (ugs., Jargon, engl.);gruselig;unheimlich;gespenstisch;nicht geheuer;beklemmend;schaurig;dämonisch;eigenartig;geisterhaft;übernatürlich;Hexenwerk (ugs.);gespenstig
-Wertpapierhändler;Börsianer;Effektenmakler;Börsenmakler;Stockbroker;Wertpapiermakler;Broker;Börsenhändler
-Politische Wissenschaft;Politikwissenschaft;Politologie
-unbeweglich;starr;inflexibel;unbiegsam;unflexibel
-widersetzlich;sperrig (ugs.);aufrührerisch;eigensinnig;tumultuarisch;rebellisch;meuterisch;aufständisch
-Kritizität;Kritikalität
-Provinz-...;unprofessionell;unqualifiziert;Küchen-... (ugs.);stümperhaft;gut gemeint, aber schlecht gemacht;Hinterhof-... (ugs.);dilettantenhaft;Hobby-... (ugs.);Wald- und Wiesen-... (ugs.);nicht ernst zu nehmen;amateurhaft;Hintertreppen-... (ugs.);gut gewollt, aber schlecht gekonnt;unmöglich (ugs., emotional);Möchtegern-;dilettantisch;hobbymäßig;laienhaft
-flache Schale;Servierplatte
-Durchlässigkeit;Porosität
-Notiz;Kommentar;Anmerkung
-überspannen;beinhalten;umfassen;einschließen
-(sich etwas) ausborgen;entlehnen;(sich etwas) ausleihen;(sich etwas) borgen;(sich etwas) pumpen (ugs.);(sich etwas) leihen
-Unterzucker (ugs.);zu niedriger Blutzuckerspiegel;Hypoglykämie (fachspr.)
-nicht ungefährlich;mit ungewissem Ausgang;unsicher;risikobehaftet;selbstmörderisch;leichtfertig;gefährlich;waghalsig;(ein) Risiko bergen;kühn;heiß (Sache) (ugs.);tollkühn;verantwortungslos;mit Risiken verbunden;auf dünnem Eis (ugs., fig.);gefahrvoll;gewagt;mit einem Risiko verbunden;Risiken bergen;unbedacht;verwegen;riskant
-den Eindruck von etwas vermitteln;den Eindruck von etwas erwecken
-abhorreszieren (geh.);(sich) hüten;abhorrieren (geh.);zögern;Bedenken tragen (geh.);zurückschrecken;zurückschaudern;Skrupel haben
-Bankkaufmann;Bankbeamter;Banker (Anglizismus);Bankbediensteter;Brosche (derb);Bankangestellter
-Trockenheit des äußeren Auges;Xerophthalmie (fachspr.)
-im Sinne;entsprechend;je nach;zufolge;in Anlehnung an;gemäß;getreu;qua;laut;nach
-Konsternierung;Entsetzen;Bestürzung
-untätig;passiv
-Nutzbarkeit;Verwendbarkeit
-Rekrudeszenz (fachspr.);Verschlimmerung einer Krankheit;Exazerbation (fachspr.);Aggravation (fachspr.)
-einreihig;einzeilig
-Uppers (ugs.);Stimulans (fachspr.);erregender Wirkstoff;Analeptikum (fachspr.)
-Internationaler Ausschuss für den Telegrafen- und Fernsprechdienst;CCITT
-Anstandsbesuch;Höflichkeitsbesuch;Aufwartung
-Nut;Falz;Zapfenloch;Stemmloch;Fuge;Spalt;Spalte
-Suspendierung;Suspension;Beurlaubung;Dienstenthebung;Dienstunterbrechung
-in eine Richtung deuten;neigen;tendieren
-Acajoubaum;Cashewbaum;Nierenbaum;Kaschubaum;Anacardium occidentale (fachspr., lat.)
-Krone (ugs.);Zahnkrone
-Ingestion (fachspr.);Konsumation (schweiz., österr.);Verzehr;Aufnahme
-Windröschen;Anemone
-verfrachten;entfernen;beiseiteräumen;verbringen;wegbringen;fortschaffen;abtransportieren;ausräumen;wegschaffen;fortbringen;beseitigen;forttragen (veraltend);wegräumen
-(sich) einwurzeln;festwachsen;Wurzeln schlagen;Wurzeln treiben;angehen (ugs.);anwurzeln;anwachsen
-Bauersfrau;Bäuerin;Bauerntrampel (derb, abwertend)
-Handbewegung;Gebärde;Fingerzeig;Geste
-purpurn;purpurfarbig;purpurfarben;purpur;karmesinrot
-einplanen;im Gedächtnis behalten;berücksichtigen;beachten
-abschnitzeln;abraspeln
-Zimmermann;Zimmerer
-gleichmäßig;in gleichen Abständen;regulär;regelmäßig
-Tonne;Fass;Gebinde;Bottich
-ehrfurchtsvoll;voller Ehrfurcht;respektvoll;ehrerbietig;ehrfürchtig
-Sicherung;Schutzvorrichtung
-Balladensänger;Liedermacher
-Güter;Waren;Artikel
-Stempeluhr;Kontrolluhr;Stechuhr
-Zugangsrate;Ankunftsrate
-unerschütterlich;ehern (geh., altertümelnd, fig.);eisern (fig.);felsenfest (Überzeugung) (fig.);sehr fest
-Fulguration;Übersummativität;Emergenz;Sichtbarwerden;Auftauchen
-Eingeweidebruch;Hernie (fachspr.);Hernia (fachspr., griechisch, lat.);Bruch
-Dienstgrad;Charge
-keinen Stein auf dem anderen lassen (fig.);alles ändern
-Schulfreund;Schulkollege;Mitschüler;Klassenkamerad;Schulkamerad
-(sich) zu etwas verpflichten;(sich) festlegen;(sich) zu etwas bekennen
-oberer Heizwert Ho (veraltet);kalorischer Brennwert (veraltet);Brennwert Hs
-pfuschig (ugs.);wie in einer Räuberhöhle (Wohnung) (ugs.);schludrig;schluderig;nachlässig;unordentlich;lax;schlampig (ugs.);wie bei Hempels unterm Sofa (ugs.);wie bei Luis Trenker im Rucksack (ugs., fig., scherzhaft, sehr selten);schlurig (ugs., regional);schlampert (ugs., süddt.);liederlich
-Lehrlingssystem;Lehrlingsausbildungssystem
-Hemdbluse;Kasack
-rückblickend;im Rückblick;retrospektiv;zurückblickend;zurückschauend
-Festlandssockel;Schelf;Kontinentalschelf;Kontinentalsockel;Küstenflachmeer
-Doctor rerum naturalium (lat.);Dr. rer. nat. (Abkürzung);Doktor der Naturwissenschaften
-kustodial (geh., lat.);beschützend;protektiv
-Zerstreutheit;Zerfahrenheit;Gedankenlosigkeit;Konzentrationsschwäche;Verstörtheit;Verwirrung;Konfusion
-zu Grabe tragen;das letzte Geleit geben;unter die Erde bringen (derb);beerdigen;verscharren (derb);das letzte Aufgebot bestellen (fig., selten);einbuddeln (derb);begraben;bestatten;die letzte Ehre erweisen (geh.);beisetzen;zur letzten Ruhe betten
-verborgen;ausleihen;herleihen (ugs.);verleihen
-mehr als satt;übersatt;übersättigt
-die Beteiligten;die maßgeblichen Kreise
-Gründungsvater;Gründer;Vater (fig., männl.);Gründervater;Schöpfer;Mutter (fig., weibl.);Begründer;Erschaffer
-Prolog (griechisch);Prodromus (geh., griechisch, lat., veraltet);Vorwort;Vorrede;Geleitwort (geh.)
-Bö;Windstoß;Böe;Luftstoß;Luftwoge
-Blaukraut;Rotkohl;Rotkabis (schweiz.);Kabis (schweiz.);Rotkraut
-unbestritten;nicht strittig;zutreffend;unstreitig;erwiesen;wahr;unstrittig;keine Frage! (ugs.);unangefochten;unumstritten;kein Vertun (es gibt da ...) (ugs.)
-unangreifbar;unbezwingbar;unbezwinglich
-abschreiben;abkupfern;abgucken;kiebitzen;spinxen (ugs.);spicken (ugs.);abschmieren (derb);schummeln;mogeln;abspicken (ugs.);abbimsen (ugs., regional)
-Bezugspunkt;Ausgangspunkt;Referenzpunkt;Nullpunkt;Koordinatenursprung;Null
-unmodern;gestrig;altmodisch;veraltet;altes Eisen (ugs., fig.);archaisch;ohne Schick
-durchwirken;durchflechten;verweben
-Privatbesitz;Privateigentum
-abtreiben;wegdriften;vom richtigen Kurs abdriften;abdriften
-krankhaft;kränklich;pathologisch
-Hegemonie;Herrschaft;Präponderanz;Beherrschung;Vorherrschaft;Vormachtstellung;Suprematie;Übergewicht
-Zwischenträger;Unterträger
-Fußballklub;FC;Fußballclub
-FH;Fachhochschule
-Kredit;Pump (ugs.);Darlehn (selten);Darlehen
-Wirtschaftszweig;Industriezweig;Gewerbe;Industrie;Sparte;Branche
-vorbehalten;reservieren;widmen;zuteilen;belegen;zurückhalten
-FM;Frequenzmodulation
-Status (fachspr.);Verfassung;Befinden;Zustand;Konstitution;Gesundheitszustand (Hauptform)
-linke Seite;zu ihrer Linken;linksseits;linksseitig;zu seiner Linken (männl.);auf der linken Seite;sinister (fachspr., lat.);backbord;links (Hauptform);zur Linken;linker Hand;das andere links (ugs., scherzhaft-ironisch);zur linken Hand
-edelmütig;feudal;erhaben;großzügig;großmütig;hehr (veraltet);nobel
-Wahlwerbung;Wahlpropaganda;Stimmenwerbung
-Stand;Niveau;Schicht;Level;Höhe;Pegel;Ebene;Stufe
-locken;ködern;anlocken
-Ausbruchsversuch;Fluchtversuch
-Korrekturbogen;Korrekturfahne
-militant;kämpferisch
-Blassheit;Fahlheit;Weiße;fahle Farbe;Blässe;Farblosigkeit
-Nachkommen;die nach uns kommen (ugs.);Nachkommenschaft;Nachwelt;Nachfahren;zukünftige Generationen;künftige Generationen;(die) Nachgeborenen
-vital;quicklebendig;gesund und munter (ugs.);voller Leben
-Umgehung;Umgehungsstraße
-Diakonie;Fürsorge;Wohlfahrt;Sozialfürsorge;Armenpflege
-Transaktionsnummer;TAN
-unangemessen;unschicklich;unstatthaft;ungehörig (Hauptform);fehl am Platz;unmanierlich;unsachlich;ungeziemend;inkorrekt;unfein;nicht korrekt;unmöglich (ugs.);unpassend;deplatziert;unangebracht;gegen den guten Ton verstoßend;ungebührlich;Wie kann man nur! (ugs.);gehört sich nicht;taktlos;daneben (ugs.);gegen die Etikette;nicht angebracht;unziemlich (geh.)
-Königsbarsch;Roter Zackenbarsch
-Bulletin (franz.);Bericht;Report;Rapport
-DFB;Deutscher Fußballbund
-Freischaffender;freier Mitarbeiter;Freiberufler;Freelancer (fachspr., Jargon, engl.);auf Honorarvertragsbasis Beschäftigte(r);ohne Festanstellung
-verkannt;unerkannt
-großziehen;aufziehen;bemuttern;pflegen;heranziehen;aufpflegen
-im Profil zeichnen;im Schnitt darstellen;in Profil darstellen
-von innen kommend;einer Sache innewohnend;intrinsisch;anhaftend;systeminhärent;inhärent
-schmeicheln;gut zureden
-einfallendes Licht;Auflicht
-Maschinenkode;Rechnerkode;Zielkode
-zwischen;bei;nebst;unter;zusammen mit
-Verkehrsvergehen;Verkehrssünde
-Baumstruktur;Hierarchie;Stufenordnung;hierarchischer Aufbau;Rangordnung
-barhäuptig (geh.);ohne Kopfbedeckung
-Lehmgrube;Tongrube
-Darstellung;Beschrieb (schweiz.);Konkretisierung;Schilderung;Erläuterung;Zuschreibung von Eigenschaften;Charakterisierung;Erklärung;Beschreibung
-Standleitung;festgeschaltete Verbindung;Standverbindung
-Mydriatikum (fachspr.);Pupillen erweiternde Substanz
-Dachstube;Mansarde;Dachzimmer;Mansardenzimmer;Oberstübchen;Dachkammer
-subtil;feinsinnig (geh., Hauptform);feingeschliffen (geh., fig.);feinziseliert (geh., fig.)
-Feierlichkeit;Fest;Feier;Feierstunde;Festakt
-unumwunden;direkt;schlankweg (ugs.);unverblümt;unverhohlen;(jemandem etwas) ins Gesicht (sagen);rundheraus;schonungslos;offen;unbeschönigt;in aller Offenheit;(einmal ganz) undiplomatisch (fig.)
-Apperzeption;bewusste sinnliche Wahrnehmung;begrifflich urteilendes Erfassen
-Transformation;Wechsel;Änderung;Veränderung;Wandel
-aufgeschwemmt;aufgedunsen;verschwiemelt (ugs., norddeutsch);geschwollen;schwulstig;bamstig (ugs., österr.);aufgeschwollen;angeschwollen;verschwollen;verquollen;dostig (ugs., österr.);gedunsen;aufgetrieben
-abhelfend;Heil...;Hilfs...
-Halskrause (Hauptform);Duttenkragen;Kröse;Fraise;Mühlsteinkragen;Mühlstein (Kurzform)
-einklagbar;verklagbar
-befremden;abalinieren;entfremden;verfremden
-(sich etwas) einfallen lassen;(etwas) erfinden;eine Ausrede finden;(sich etwas) zurechtlegen
-buschig;zottelig;zottig
-Rubeola (fachspr.);Röteln
-Bestattungs...;Grab...
-in großem Umfang;bezeichnend;charakteristisch;spürbar;signifikant;ausgeprägt;stark;deutlich;augenfällig;merklich;prägnant;fühlbar;markant
-Hang;Begierde;Affinität;Tendenz;Geneigtheit;Verlangen;Lust;Anziehung;Neigung
-Gurke (ugs.);Natel (ugs., Markenname, schweiz.);Handy (Scheinanglizismus, Hauptform);Mobilfunktelefon;Taschentelefon;Funkfernsprecher;Handtelefon;Ackerschnacker (ugs.);Mobiltelefon (Hauptform);Funktelefon
-Huhn;Leghenne;Poulet (schweiz.);Henne;Gluckhenne;Glucke;Legehenne;Hendl (ugs.)
-Ballabwehr;Parade
-Dorn;Stachel;spitzer Gegenstand
-hepatotoxisch (fachspr.);die Leber schädigend
-eine Verwerfung verursachen;(sich) verwerfen
-Sturzbach;Schwall
-(den) Durchblick haben (ugs.);überblicken;(den) Überblick haben;überschauen
-Missbilligung;Missfallen
-Bundschraube;Ansatzschraube
-Meldung;Information;Mitteilung;Nachricht (Hauptform);Botschaft;Neuigkeit;Kunde (geh., veraltet)
-wörtlich;eins zu eins (ugs.);wortgetreu (geh.);wortgleich (geh.);wortwörtlich;Wort für Wort
-Holzblock;Sägeblock;Holzklotz
-Verhältnis;Berührung;Kommunikation;Brückenschlag;Kontakt;Beziehung;Annäherung;Verbindung;Umgang;Interaktion;Konnex
-Vokabeltest;Vokabelprüfung
-Hauptspeicher;Arbeitsspeicher;Zentralspeicher;Kurzspeicher;Direktzugriffsspeicher;Random Access Memory (fachspr., engl.);Kurzzeitspeicher;RAM (Abkürzung, engl.)
-Muskeln entspannen;locker lassen (ugs.)
-Klampe;Klemme
-Bifurkation (geh., lat.);Verzweigung;Scheideweg;Dichotomie (fachspr., botanisch, griechisch);Verästelung;Gabelung;Wegscheid (veraltend, österr.);Abzweigung
-Verschiebung;Positionsänderung;Translokation;Bewegung
-Umschwung;Umwälzung;Umbruch;drastische Veränderungen;Verwerfungen (fig.)
-nachkommen;vollziehen;vollbringen;entsprechen;erfüllen;(einer Sache) Genüge tun (geh.)
-Betriebsmittel;Betriebskapital
-knoten;durchschlingen;weben
-Verdünner;Verdünnungsmittel;Verdünnung
-in Form (ugs.);gut im Strumpf stehen (ugs.);fit;gut in Form (ugs.);wohlbehalten;bei guter Gesundheit;bei Kräften;wohlauf;gesund und munter (ugs., scherzhaft);gesund (Hauptform);auf dem Damm (ugs.)
-Schließmuskel;Sphinkter (fachspr.)
-Schmächtigkeit;Körperschwäche;Asthenie (fachspr.);Kraftlosigkeit;Schwäche
-Wirkungsgrad;Effektivität;Wirksamkeit;Leistungsfähigkeit
-Opfer;Beute
-recherchieren;untersuchen;ermitteln;nachforschen;detektieren;requirieren;erkunden;Ermittlungen anstellen
-Verschwendung;Prasserei;Maßlosigkeit;Vergeudung;Unmäßigkeit;Gepränge;Prunk;Geaase (ugs.);Luxus;Verschleuderung (ugs.)
-entrümpeln;leerräumen;ausräumen;leer räumen
-Kontrolleur;Prüfer;Untersucher;Inspektor;Kontrollor (österr.);Inspizient (fachspr.);Überprüfer
-Herkunft;Entstehen (geh.);Werden (geh.);Anfang (ugs.);Zustandekommen;Ursprung
-Sammlung (von);Zusammenstellung;Kompilation
-(mit jemandem) zusammen sein (ugs.);(mit jemandem) ein Verhältnis haben;(mit jemandem) was haben (ugs.);(mit jemandem) eine Beziehung haben
-kribbeln;jucken
-jenes;dieses;dies;das;welches;dasjenige
-Proptosis (fachspr.);vorgetriebener Augapfel
-Eingabe;Antrag;Gesuch
-Zahnung;Dentition (fachspr.)
-Sexualerziehung;Sexualkunde
-unbehandelt;nicht behandelt
-Veranstalter (Hauptform);Organisator;Ausrichter
-jemanden ausgewählt haben;jemanden vorsehen
-Verkehrsstation;Bahnhof;Station;Bahnstationsanlage
-Kränkung;Beleidigung;Insultation;Affront;Ehrverletzung;Schmähung
-Geheimnis;Phänomen;Wunder;Chiffre (geh., franz.);Buch mit sieben Siegeln (ugs., fig.);Mysterium;Rätsel
-Absperrkette;Postenkette
-Spagetti (Plural);Spaghetti (Plural)
-zu wenige (sein);unterbesetzt
-Geißelung;Tauwerk
-Schreibfeder;Feder;Zeichenfeder;Ziehfeder;Federkiel;Tuschfeder
-Konkurrent;Marktbegleiter;Mitbewerber;Wettbewerber
-eigensinnig;eigenwillig;individuell
-Lektion;Belehrung (geh., veraltet);Unterricht (Hauptform);Anleitung;Unterweisung;Schule;Unterrichtung (Papierdeutsch)
-Beschämung;Verlegenheit;Erniedrigung
-Popanz;Extravaganz;Übertreibung;Überspanntheit
-Wiederfleischwerdung;Wiederverkörperung;Palingenese;Wiedergeburt;Reinkarnation
-Entschiedenheit;Bestimmtheit
-rückfällig;zurückfallend
-Takelung;Takelage;Segelausstattung;Takelwerk
-Adeliger (männl.);Edelfräulein (weibl.);Edelfrau (weibl.);Adliger (männl.);Edelmann (männl.);Adelige (weibl.)
-kastrierter Haremswächter;Entmannter;Eunuche;Kastrat;Eunuch
-Radspeiche;Speiche
-Selbständigkeit;Selbstgesetzgebung (fachspr.);Mündigkeit;Autonomie;Selbstständigkeit;Selbstbestimmung;Eigenständigkeit
-einen Vertrag ignorieren;vertragsbrüchig sein
-dafürhalten (geh.);überzeugt (sein);glauben (dass);meinen (dass);der Überzeugung sein;(der) Meinung sein;zu wissen glauben;der Ansicht sein;(es) für richtig halten;(etwas) so sehen (dass)
-Volksrepublik China;Reich der Mitte (ugs.);VR China;China
-Autokratie;Selbstherrschaft
-trampelig;tollpatschig;ungewandt;patschert (österr.);unbeholfen;ungelenk;täppisch;ungeschickt;linkisch;ungeübt;tapsig
-Streichung;Absage
-Technikwissenschaften (Plural);technische Wissenschaften (Plural);Ingenieurwissenschaften (Plural);Ingenieurwesen
-Scharren;Kratzen;Schaben
-einsparen;zusammenstreichen;kürzen
-Krakeeler;Schreihals;Krawallmacher (Hauptform);Lärmer (ugs.);Brüllaffe (ugs.);Radaubruder
-Offerte;Vorschlag;Anbot (österr.);Angebot;Präsentation (fachspr.);Bieten;Gebot;Anerbieten (geh.)
-einnehmen;hinunterschlucken;schlucken
-wieder aufladen;nachladen;wieder laden;(Akku etc.) laden
-Kratzspur;Schrunde;Schramme;Kratzer;Riefe;Katsch (ugs., kölsch)
-improvisieren;aus dem Stegreif begleiten
-Wendel;Wicklung;Spule
-schweigsam;sprachlos;still und stumm;in Schweigen gehüllt;stumm;wortlos;stad (bayr., österr.);verstummt;verschwiegen;stumm wie ein Fisch;still
-selbst erlernt;autodidaktisch;selbst beigebracht
-geheiligt;ausgesondert;heilig
-Habsucht;Habgier
-Wegzug;Wohnsitzaufgabe;Fortzug;Aufgabe des Wohnsitzes
-willentlich;mit Vorsatz (juristisch);mit Absicht;(ganz) bewusst;mutwillig;geflissentlich (geh.);gewollt;in voller Absicht;absichtsvoll (geh.);vorsätzlich (juristisch);wissentlich;absichtlich;gezielt;mit voller Absicht;extra (ugs.)
-braungebrannt;lecker braun (ugs.);gebräunt;braun gebrannt;braun von der Sonne;knusprig braun (ugs.);(braun) wie ein Grillhähnchen (ugs.);sonnengebräunt;(braun) wie ein Brathähnchen (ugs., scherzhaft-ironisch)
-letzte Worte (auch figurativ);Abschied;Abschiedsakt;Abschiednehmen;Verabschiedung
-Unterwassersauerstoffapparat;Sauerstoffflasche
-Festumzug;Umzug
-Ausrufezeichen;Ausrufungszeichen;Ausrufzeichen (schweiz.);Rufzeichen (österr.)
-achten;anerkennen;ehren (geh.);schätzen;akzeptieren;(achtungsvoll) aufblicken zu (fig.);ästimieren (geh., veraltend);wertschätzen;würdigen;zu schätzen wissen;(eine) hohe Meinung haben (von);respektieren
-Konkursfall;Insolvenz;Illiquidität (fachspr.);Bankrottfall;Zahlungsunfähigkeit;Zahlungseinstellung;Bankrott;Aus (ugs.);Ruin;Konkurs;Pleite (ugs.)
-Privileg;Vorrecht;Erstrecht (fachspr.)
-(auf etwas) aufmerksam machen;(auf etwas) verweisen;(auf etwas) hinweisen;(etwas) beleuchten;(etwas) darlegen;(etwas) ins allgemeine Bewusstsein rücken;(etwas) aufzeigen
-Pfarrgemeinde;Pfarrei;Gemeinschaft;Gemeinde;Pfarre;Kirchgemeinde;Kirchengemeinde
-Schleppkahn;Schleppdampfer;Schlepper
-Gastlichkeit;Gastfreundlichkeit;Gastfreundschaft;Hospitalität
-Unerbittlichkeit;Hartnäckigkeit;Verstocktheit
-anziehend;magnetisch
-Stabilität;Resistenz;Konstanz;Festigkeit;Haltbarkeit;Alterungsbeständigkeit;Robustheit;Dauerhaftigkeit;Langlebigkeit;Widerstandsfähigkeit
-Dividendenzuschlag;Sonderdividende
-Verschrottung;Abwrackung;(das) Abwracken;(das) Verschrotten
-Ansteuerung;Auslösen
-Kopf einer Nominalphrase (fachspr.);Substantivum (lat.);Dingwort;Hauptwort;Nomen (Hauptform);Namenwort;Substantiv
-maßgearbeitet;maßgeschneidert;nach Maß
-kommt nichts (da)bei heraus (ugs.);ohne Ergebnis;ergebnislos;unproduktiv;unverrichteter Dinge;ohne Erfolg;fruchtlos
-Bewunderung;Zuspruch;Beachtung;Ehrerbietung;Admiration (geh., bildungssprachlich, lat., veraltet);Achtung;Wertschätzung;Bestätigung;Hochachtung;Respekt;Rückenwind (fig.);Anerkennung
-Formeisen;Profileisen
-aufs Spiel setzen;riskieren;gefährden
-schriftlich kommunizieren;korrespondieren
-Halterung;Fassung
-Fluss;Durchfluss
-Schrittsteuerung;Stufensteuerung
-Markttrend;Marktentwicklung
-Ansprache;Vortrag;Rede;Monolog
-International Standard Book Number;ISBN;Internationale Standardbuchnummer;ISB-Nummer
-jemanden zu etwas bringen;(jemanden) nötigen (zu);(jemandem) ein Angebot machen, das er nicht ablehnen kann;(jemanden) zwingen (zu)
-Türblatt;Türflügel
-grobe Nahrung;Raufutter
-Partner;Teilnehmer;Beteiligter;Sozius (fachspr.);Teilhaber;Gesellschafter
-Brotkrume;Krume;Brosamen;Bröckchen (ugs.)
-Überleitung;Übergang
-in keiner Richtung;weit und breit nicht;nirgends;an keinem Ort;nirgendwo
-Ratlosigkeit;Verwirrung
-Heft;Schreibheft;Übungsheft;Schulheft
-ausfindig machen;aufspüren;ausbaldowern (ugs.);fündig werden;aufstöbern;besorgen;auftreiben;(sich) an Land ziehen (ugs.);aufgabeln (ugs.);drankommen (an) (ugs.);kommen an (ugs.);finden
-ausmustern;wegwerfen (Hauptform);entsorgen;aussortieren;ausrangieren;zum Alteisen werfen;in die Tonne kloppen (derb);(sich) trennen (von);in die Tonne treten (ugs.);fortschmeißen (ugs.);wegtun (ugs.);wegschmeißen (ugs.);in den Müll geben;loswerden (ugs.);fortwerfen;verschrotten
-Raumangst (fachspr.);Angst vor engen Räumen;Klaustrophobie;Platzangst (ugs.)
-(jemandem) um den Hals fallen;(jemanden) umarmen;umschließen;in die Arme nehmen;mit beiden Armen umfangen (geh.);die Arme schlingen um;die Arme legen um;(jemanden) drücken;(jemanden) umklammern;umfassen;umschlingen;(jemanden) umfangen (geh.);in die Arme schließen
-heckwärts;hinten;achteraus;achtern (fachspr.)
-umkippen (ugs.);umfallen (ugs.);aus den Latschen kippen (ugs.);(einen) Kollaps haben;(einen) Zusammenbruch erleiden;(einen) Kollaps erleiden;(einen) Zusammenbruch haben;kollabieren;zusammenklappen;(einen) Schwächeanfall haben;(einen) Schwächeanfall erleiden;zusammenbrechen (Hauptform);wegsacken
-einnehmen;kassieren
-Schale;Becken
-Trab;Trott
-assoziiertes Mitglied;außerordentliches Mitglied (einer Gesellschaft)
-eidesstattliche Aussage;Aussage unter Eid
-Hausangestellte;(das) Gesinde;(das) Personal;(die) Diener;Dienerschaft;(die) Dienstboten
-die Harn- und Geschlechtsorgane betreffend;urogenital (fachspr.)
-Nachsichtigkeit;Verständnis;Nachsicht;Konnivenz (fachspr.);Geduld;Duldsamkeit
-Verknüpfung;Verhältnis;Beziehung (Hauptform);Zusammenhang;Wechselbeziehung;Bezug;Verbindung;Relation
-Graubrot;Mischbrot
-abzupfen;abpflücken;pflücken;abbrocken
-posterior [beim Menschen] (fachspr.);den Rücken betreffend;dorsal (fachspr.);rückenseits;am Rücken gelegen
-per Anhalter fahren;den Daumen heraushalten;trampen;mitfahren
-Tetanus;Wundstarrkrampf
-fröhlich;heiter;munter;angeregt;in Stimmung;ausgelassen
-Werdegang;Laufbahn;Karriere;Erwerbsbiographie (fachspr., Amtsdeutsch);C.V. (Abkürzung);beruflicher Werdegang;Curriculum Vitae (lat.);Vitae cursus;CV (Abkürzung);Lebenslauf;Vita;berufliche Laufbahn;berufliche Entwicklung;Berufsweg;Berufslaufbahn
-Ufo;Unbekanntes Flugobjekt
-Kapitalentwicklungsfonds der Vereinten Nationen;UNCDF
-nett;freundlich;charmant;gefällig
-entzündliche Knotenbildung;Tophus (fachspr.)
-Markierung;Hinweiszeichen
-Einfuhr;Zufuhr
-fahrbarer Untersatz (ugs., scherzhaft);Wagen (ugs.);Blechbüchse (ugs., scherzhaft);PKW (Abkürzung);Personenwagen (Amtsdeutsch);Karre (ugs., abwertend);Töfftöff (ugs., Kindersprache);Personenkraftwagen (Amtsdeutsch);Pkw (Abkürzung, Hauptform)
-Der Dumme Rest (derb, ironisch);SBZ (Abkürzung, abwertend);DDR (Abkürzung, Hauptform);Mitteldeutschland;Arbeiter- und Bauern-Staat;Zone (derb);Ostzone (derb);Sowjetische Besatzungszone (abwertend);Deutsche Demokratische Republik;Ostdeutschland (ugs.);Sowjetzone
-Kost;Nahrung;Futter
-Dysurie (fachspr.);schmerzhafter Harndrang
-Heimstätte;Gehöft
-zuerkennen;zuschreiben;beigeben;(jemandem etwas) attestieren;unterstellen;attribuieren;beimessen;prädizieren;(jemandem etwas) zusprechen
-ungerade;uneben
-Zylinder...;zylindrisch
-lederartiges Aussehen der Haut;Lichenifikation (fachspr.)
-Aufwertung;Wertsteigerung;Valorisierung
-Auftriebskraft;Auftrieb
-Volkshochschule;Abendschule;VHS;Kolleg
-mausen (verharmlosend) (ugs.);klauen (ugs.);mopsen (verharmlosend) (ugs.);das Bezahlen vergessen (ironisch);vergessen zu bezahlen (ugs., ironisch, variabel);(sich) bedienen (ugs., ironisch, verhüllend);(sich) (einfach) nehmen (ugs.);lange Finger machen (ugs.);(sich) vergreifen (an);böhmisch einkaufen (beleidigend) (derb, österr.);(etwas) organisieren (ugs., verhüllend);ergaunern;entwenden;(sich etwas) klemmen (ugs.);stehlen (Hauptform);polnisch einkaufen (beleidigend) (derb);(einfach) mitnehmen (ugs.);(sich) widerrechtlich aneignen;(sich) an fremden Sachen vergreifen;stibitzen (verharmlosend) (ugs.);mitgehen lassen (ugs.);(sich) einfach (weg)nehmen (ohne zu bezahlen) (ugs.);schnipfen (ugs., bairisch, österr.)
-Käuzchen;Kauz
-Korral;Koppel;Hürde (fachspr.);Pferch;eingezäuntes Areal;Gehege
-Mangelbeseitigung;Korrektur;Fehlerbeseitigung;Berichtigung;Problemlösung;Nachbesserung;Fehlerbehebung;Verbesserung;Instandsetzung;Mängelbeseitigung;Reparatur
-Denkmalpflege;Denkmalspflege
-Bediensteter;Angestellter;Werktätiger (DDR);Arbeitnehmer (Hauptform);Beschäftigter (Hauptform);Mitarbeiter;Arbeitskraft
-Reststück;Stummel;Rest;übriggebliebenes Ende;abgeschnittenes Ende;Stückchen
-falzen;nuten
-Entschlüsseler;Decoder;Decodierer
-voller Entdeckerfreude;neugierig;wissbegierig;interessiert;wissensdurstig
-Gekauftes;Einkauf
-es heißt (dass) (geh.);dürfte (+ Infinitiv Perfekt);werden + Partizip 2 (= Futur 2);wohl;zu vermuten stehen (es) (geh.);wie man sagt;anzunehmen sein;davon ausgehen (können) dass;angenommen werden (es);vielleicht;mutmaßlich;wahrscheinlich;als wahrscheinlich gelten(d);vermutlich (Hauptform)
-Gewalttätigkeit;Brutalität
-zermalmen;zerdrücken;einstampfen;entfleischen;zermatschen (ugs.)
-(sich) anstrengen (Hauptform);reinklotzen (ugs.);sein Bestes geben;(sich) ins Zeug legen (ugs.);(sich) den Arsch aufreißen (derb);(sich) auf die Hinterbeine stellen (ugs., fig.);Einsatz zeigen;alle Kraft aufbieten;Engagement erkennen lassen;(sich) reinknien (ugs.);(sich) (richtig) Mühe geben;tun, was man kann (ugs.);alles daransetzen (zu);mit ganzem Herzen dabei sein;(sich) (richtig) reinhängen;ranklotzen (ugs.);powern (ugs.);Gas geben (ugs.);(sich) ins Geschirr legen (fig., veraltend);Engagement zeigen;(seine / ihre) ganze Energie einsetzen;(sich) alle Mühe geben;(sich) große Mühe geben;(sich) in die Sielen legen (ugs.);(sich) (echt) bemühen (um);(sich) voll reinhängen;alle Register ziehen;(sich) dahinterklemmen (ugs.);alle Kräfte aufbieten;(sich) Arme und Beine ausreißen (ugs., fig.);vollen Einsatz zeigen
-bar auf die Kralle zahlen (ugs., salopp);(etwas) in bar bezahlen;mit Cash bezahlen (ugs., salopp);(jemandem etwas) bar auf die Hand zahlen (ugs.);bar zahlen;in Cash (be)zahlen (ugs., salopp);(etwas) bar bezahlen;mit Cash zahlen (ugs., selten);(jemanden) auf die Hand bezahlen (ugs.);(das) Geld auf den Tisch (des Hauses) legen
-ca. (Abkürzung);über den Daumen (gepeilt) (ugs.);grob gesagt;um die (ugs.);so um die (ugs.);so gegen (ugs.);Pi mal Daumen (ugs.);grob (geschätzt);plus/minus (Betrag) (ugs.);näherungsweise (geh.);vielleicht;so circa (ugs.);Stücker (+ Zahl);etwa;lass es (+ Zahl) gewesen sein (ugs.);rund;annäherungsweise;so ungefähr (ugs.);mehr oder weniger (ugs.);in etwa;so (in) etwa (ugs.);gegen;ungefähr (Hauptform);um den Dreh (rum) (ugs.);gefühlt (ugs., Neologismus);schätzungsweise;(Betrag) plus/minus (Abweichungsbetrag/Toleranz);(so) in dem Dreh (ugs.);lass es (+ Zahl) sein (ugs.);um;circa (Abkürzung);zirka;annähernd;wohl (geh.);approximativ (fachspr., mathematisch);geschätzt;überschlägig (kaufmännisch)
-walzenförmig;zylindrisch
-skandalträchtig;(eine) Unverschämtheit;haarsträubend;dreist;also so etwas! (ugs.);kaum zu fassen (ugs.);(ein) dicker Hund (ugs., fig.);ja gibt's denn sowas!? (ugs.);man fasst es nicht! (ugs.);hagebüchen (veraltet);unmöglich (ugs.);nicht zu fassen (ugs., Hauptform);das ist (ja wohl) die Höhe! (ugs.);unerhört;(ein) starkes Stück;(dazu) fällt einem nichts mehr ein (ugs.);(das) setzt dem ganzen die Krone auf! (ugs.);jeder Beschreibung spotten;unglaublich;das Allerletzte (ugs.);(eine) Zumutung! (ugs.);das Letzte (ugs.);(da) hört sich doch alles auf! (ugs.);(etwas) geht auf keine Kuhhaut (ugs.);(da) bleibt einem die Spucke weg (ugs., fig.);(das ist) der Gipfel der Unverschämtheit (ugs.);(das) schlägt dem Fass die Krone ins Gesicht (ugs., salopp, scherzhaft-ironisch);unsäglich;heftig! (ugs.);bodenlos (ugs.);(das) schlägt dem Fass den Boden aus! (ugs.);nichts für schwache Nerven (übertreibend);hanebüchen;unverschämt;(eine) Frechheit;(etwas) spottet jeder Beschreibung
-konkludieren;herleiten;folgern;schlussfolgern;ableiten;kombinieren;schließen (aus);deduzieren
-trübe;unklar;trüb
-Vertriebener;Umsiedler;Evakuierter
-Korbflechter;Korbmacher;Flechtwerkgestalter
-ebenda;ebd. (Abkürzung);daselbst
-Balancier;Ausgleichsgewicht
-Priamel (fachspr.);Sinngedicht;Sentenz (geh., lat.);Gedankensplitter;Aphorismus (geh., bildungssprachlich, griechisch, lat.);Apophthegma (fachspr., griechisch);Bonmot (geh., franz.);Gnome (fachspr., griechisch);Denkspruch;Sinnspruch (Hauptform)
-StGB;Strafgesetzbuch
-Versicherung;Bestätigung;Zusage;Bekräftigung;Quittierung;Zusicherung;Befürwortung;Zuspruch;Quittung;Rückmeldung;Nachweis
-Agrarwissenschaftler;Agrarier;Agronom
-Entflockungsmittel;Verflüssigungsmittel
-wärmen;aufwärmen;erwärmen
-Vorwort (österr.);Verhältniswort;Lagewort;Präposition (fachspr., Hauptform)
-nicht richtig;verkehrt (ugs.);nicht korrekt;inkorrekt;nicht den Tatsachen entsprechen(d);nicht haltbar;unkorrekt;unsachgemäß;fehlerhaft;unrichtig;unzutreffend;nicht zutreffen;falsch (sein);unhaltbar;irrig (geh.);nicht zutreffend
-Streiterei;handfeste Auseinandersetzung(en);Handgreiflichkeiten;Händel;Gerangel;Handgemenge;Balgerei;Rangelei
-Sermon;Erguss;Wortschwall;Wortfülle;wortreiche Rede;Suada;Tirade;Redeschwall;Suade;Redefluss
-Zustimmung finden;auf Gegenliebe stoßen;Beifall finden;Anklang finden (bei);auf Sympathie stoßen;Zuspruch finden;positiv aufgenommen werden;freundlich aufgenommen werden;auf Resonanz stoßen (bei);Zuspruch erfahren;(gut) angenommen werden;(es gibt) (viel) Beifall für;gut ankommen (bei) (ugs.);begrüßt werden;auf fruchtbaren Boden fallen (Vorschlag, Idee) (fig.);akzeptiert werden;auf Zustimmung treffen
-Glandula parathyroidea (fachspr.);Parathyroidea (fachspr.);Glandula parathyreoidea (fachspr.);Nebenschilddrüse;Parathyreoidea (fachspr.);Epithelkörperchen
-verbessern;optimieren;zum Positiven verändern;bessern;besser machen
-Sterbensforschung;Sterbekunde;Thanatologie
-national;quer durchs ganze Land;überall im Land (ugs.);landauf, landab (ugs.);bundesweit;landesweit
-Barbesitzer;Kneipenwirt
-Umschlagtext;Waschzettel (ugs.);Klappentext
-abgünstig (geh., veraltet);schiefmäulig (ugs., veraltend);missgünstig;mit Neid;neiderfüllt;neidig (landschaftlich);neidhaft (schweiz.);scheel (ugs.);neidisch (Hauptform);scheelsüchtig (veraltet);neidvoll
-Etikett;Schlaufe;Streifen;Lasche;Öse
-Unabdingbarkeit;Mussbestimmung
-umstehend;umseitig
-Antrieb;Motor;Maschine;Murl (ugs., österr.);Triebwerk;Aggregat
-komisch;seltsam;absonderlich;befremdlich;ungewöhnlich;kurios;sonderbar;sonderlich;paradox;verquer;befremdend;skurril
-(ein) Nichts von (fig.);(ein) Stich (in);(eine) Andeutung (von);Quäntchen;Hauch (von);Anflug;Spur;Tick (von) (ugs.);Kleinigkeit;Touch (engl.);(ein) Etwas (von);Prise;Winzigkeit
-Stärke;Stärkemehl
-Verbesserung;geistige Umgestaltung;Neuorientierung;frischer Wind (fig.);Reformation;Umorientierung;Neuausrichtung;Erneuerung
-immer wieder von etwas reden;(auf etwas) herum reiten
-fest;konsistent;dicht
-Gussform;Gesenk
-Familienstammbaum;Abstammungstafel;Familienchronik;Blutlinie;Stammbaum;Ahnentafel
-Kohlengrube;Kohlenbergwerk
-Kanuslalom;Wildwasserslalom
-fiepen;wimmern;jaulen;winseln
-Ursprungszustand;Ausgangszustand;Ausgangsstellung;Normalstellung
-Blockieren;Versperren;Sperren
-Gartenhacke;Hacke
-Pleite;Fiasko;Niederlage;Debakel;Verlust
-hrsg. (Abkürzung);herausgegeben
-(das) Recht;(die) Gesetze
-(jemandem) geschehen;hereinbrechen (über);durchmachen (ugs.);(jemanden) befallen;durchleiden;durchstehen;erleben;mitmachen (ugs.);(jemanden) ereilen;erleiden;durchleben
-dürfen;die Erlaubnis haben
-aufwecken;erschüttern;aufschrecken;alarmieren;wachrütteln;aufscheuchen;emporreißen;elektrisieren (ugs.);wecken;aufrütteln
-bruxen (fachspr.);knirschen;zermalmen;knirschend kauen
-nachkommen;Schritt halten (mit);mithalten (mit)
-Suchtmittel (fachspr.);Suchtgift;Droge;Dope (derb);Stoff (ugs.);Betäubungsmittel (bundesdeutsch);Suchtstoff;Rauschmittel (fachspr.);Rauschgift (Hauptform)
-Pfeiler;Versteifung;Stütze;Strebe
-Gratulation;Glückwunsch
-Verkettung;Zusammenhang;Verbindung;Vernetzung
-der Heilige Petrus;Simon Petrus;Sankt Peter
-Intelligenzquotient;IQ
-Bergsteigen;Bergsteigerei;Klettern
-Abstrahlung;Ausstrahlung;Aussendung;Emission
-Hoggedse (ugs., schwäbisch, variabel);Treffen;Treff;Gesellschaft;Begegnung;Miteinander;Zusammensein;Beisammensein;Zusammentreffen;Wiedersehen;geselliges Zusammenkommen;Versammlung;Zusammenkunft;(das) Geselligsein
-pulverisieren;zerreiben
-ausgeführt;umgesetzt;vollzogen
-Schwerpunktstreik;punktueller Streik
-Nachbilder;nachfolgende Abbildungen
-Entseuchung;Befreiung von Giftstoffen;Entgiftung;Detoxifikation;Detoxikation
-Weisheit;Gebildetsein;Bildung (Hauptform);Klugheit;Allgemeinwissen;(großes) Wissen;Gelahrtheit (ironisch, veraltet);Gelehrtheit;Allgemeinbildung
-Budget;Haushaltsplan;Haushalt;Topf (ugs.);Finanzplan;Etat
-Toffee;Sahnebonbon
-korrosiv (fachspr.);zersetzend;zerfressend
-geigen;Geige spielen;fiedeln;Violine spielen
-Stützband;Tragband;Gurt
-Prognose;Vorausschau;Ausblick;Vorausblick
-Abfallberg;Abfallhaufen;Müllberg (ugs.)
-Empfindung;Perzeption;sinnliche Wahrnehmung
-ungleichförmig;asymmetrisch;unsymmetrisch;ungleichmäßig
-Hausarbeit;Seminararbeit;Semesterarbeit;Studienarbeit
-s. o.;siehe oben
-überempfindlich;überdreht;gespannt;angespannt;überreizt
-Kaskadeur (veraltend);Sensationsdarsteller;Stuntman (engl.);Stunt-Double (engl.)
-USA (Abkürzung, engl., Hauptform);Land der unbegrenzten Möglichkeiten (ugs., euphemistisch, idealisierend);Vereinigte Staaten;Vereinigte Staaten von Amerika (offiziell);Amiland (derb);Neue Welt (ugs., historisch);VSA (Abkürzung, veraltet);(die) Staaten (ugs.);Amerika (ugs.);Land der unbegrenzten Dummheit (derb, abwertend)
-sehr bunt;bonbonfarben;auffällig bunt;farbenprächtig;(so knallbunt,) dass es in den Augen wehtut (ugs., fig.);kreischend bunt (ugs., abwertend);farbstark;poppig;farbenfroh;giftig (Farbe) (abwertend, fig.);knallig;quietschbunt (ugs.);aufdringlich bunt (abwertend);fröhlich bunt;schreiend bunt (ugs., abwertend);knallbunt (ugs.);knallebunt (ugs.);verrückt bunt (ugs., regional);grellbunt;(so bunt,) dass es in die Augen sticht
-Hochleistungsrechner;Number Cruncher (fachspr., engl.);Supercomputer;Superrechner
-albern;herumkaspern;Jux machen;scherzen;herumalbern;gagamäßig drauf sein (ugs.);Witze machen;herumkalbern (regional);Unsinn treiben;juxen;herumblödeln;(sich) in Blödeleien ergehen (geh.);flachsen;rumspacken (ugs.);spaßen;witzeln;Spökes machen (ugs., ruhrdt.);ulken;Unsinn machen;rumblödeln (ugs.);rumalbern (ugs.);Faxen machen (ugs.);auf Gaga machen (ugs.);blödeln
-(sich etwas) abschauen;nachmachen;abkupfern (ugs.);nachäffen (ugs.);nachahmen;imitieren;nachbilden
-Begrenztheit;Limitation
-gastronomisch;feinschmeckerisch
-Infrarotlicht;Infrarot;infrarote Strahlung;IR (Abkürzung)
-ungeregelt;chaotisch;unordentlich
-Prozentrechnung;Liquidation;Abrechnung;Rechnung;Berechnung;Faktur (veraltet);Faktura (schweiz., veraltet, österr.);Zinsrechnung
-Spitze;Höchststufe;Peak (fachspr., engl.);Maximalwert;Hochpunkt;(das) Ende der Fahnenstange (ugs., fig.);Höchstwert;Extremum;Maximum;Spitzenwert
-Applaus;Beifallsorkan;Handgeklapper;Beifallsbezeugung (geh.);Beifallklatschen;Beifallssturm;Beifallsbekundung (geh.);stehende Ovationen (es gibt ...);Klatschen;Beifallsrauschen;Beifallsbezeigung;Beifallsäußerung;Standing Ovations;Jubel;tosender Beifall;Ovation;Akklamation;Beifall
-Sedimentation;Ablagerung;Sedimentbildung;Sedimentierung
-Währungsbank;Emissionsbank
-so ein;in der Weise;dahingehend;son (ugs.);solch;solchergestalt;derweise;derartig
-Nachahmer;Trittbrettfahrer (fig.);Nachäffer (ugs.)
-Liga;Bund;Bündnis
-Amblyopie (fachspr.);Schwachsichtigkeit
-Ein-Zustand;Durchlasszustand
-und wie sie alle heißen (ugs.);o. Ä. (Abkürzung);et cetera perge perge (lat.);et cetera;und viele(s) andere mehr;u. v. a. m. (Abkürzung);usw. usf. (Abkürzung);und und und (ugs.);oder Ähnliches;und so weiter (Hauptform);und Konsorten;etc. pp. (Abkürzung);und so weiter und so fort;usf. (Abkürzung);und Co.;und Ähnliches mehr;und haste nich gesehn (ugs.);usw. (Abkürzung);& Co.;etc. (Abkürzung)
-Myelomatose (fachspr.);Plasmozytom;multiples Myelom (fachspr.);Kahler-Krankheit;Huppert-Krankheit
-eitel Sonnenschein (ugs.);Einheit;Übereinstimmung;Eintracht;Friede-Freude-Eierkuchen (ugs.);Harmonie;Einigkeit;Einssein
-Spielkamerad;Spielgefährte;Gespiele (geh., veraltet)
-Eiweiß verdauend;proteolytisch (fachspr.)
-vorne;vorn;am vorderen Ende;am Vorderende;an der Spitze
-über Bord werfen;abwerfen
-Glanz;Protz (abwertend);Prachtentfaltung;Pracht;Prunk und Pomp;Prunk und Pracht;Prunk und Protz;Herrlichkeit;Pomp;Gepränge;Prunk (Hauptform)
-Derivat;Abkömmling
-als Nächstes;nachfolgend;dann (Hauptform);folgend;woraufhin;nachher;hierauf;danach;in der Folge;späterhin;daraufhin;zu einem späteren Zeitpunkt;nachträglich;im Nachfolgenden;worauf;anschließend;alsdann (geh.);darauffolgend;im Folgenden (= später);sodann;hinterher;hiernach;hernach;nach (...);später;darauf;im Anschluss (an);darauf folgend;darnach (veraltet)
-bessern;ändern;abändern;berichtigen
-Abstand;Distanz;Entfernung
-Faszie (fachspr.);sehnenartige Muskelhaut (ugs.);Fascia (fachspr.)
-Ausfuhrartikel;Exportartikel
-Staatsetat;Fiskus;Staatshaushalt;Staatssäckel (ugs.);Kasse;Staatskasse;öffentliche Hand;Staatsfinanzen
-fettähnlicher Stoff;Lipid
-Computer-Visualisierungsverfahren durch Strahlenverfolgung;Raytracing
-Ausbeute;Aushub
-iberische Halbinsel;südlich der Pyrenäen;Pyrenäenhalbinsel
-öffentliche Diskussionsschrift;Weißbuch
-Ehrfurcht;Respekt;Achtung
-Metro;U-Bahn;Sozialschlauch (abwertend);Untergrundbahn
-Beteiligung;Mitsprache;Mitbeteiligung;Partizipation;Anteilnahme;Einschluss;Teilnahme;Mitwirkung;Beteiligtsein;Teilhabe;Einbindung
-Schroffheit;Schärfe
-fällt aus wegen Nebel (ugs.);entfallen;verfliegen (ugs.);ausbleiben;wegfallen;ausfallen;verschwinden;nicht stattfinden;unterbleiben;auf sich warten lassen
-Resektion (fachspr.);Teilentfernung eines Organs
-Verzweiflung;Seelenleid (geh.);Seelennot (geh.);äußerste Niedergeschlagenheit
-Auswuchs;Höcker;Buckel
-Leerfeld;Zwischenraum
-liquide;liquid;flüssig (ugs.);zahlungskräftig;zahlungsfähig;solvent;gut bei Kasse;schuldenfrei
-erlösen;retten
-Trader;Börsenspekulant
-Tick;Grille (veraltend);Eigenart;Kaprize (österr.);Kaprice;Spleen;Angewohnheit;Allüren (geh.);Schrulle;Marotte;Eigenheit;Caprice;Fimmel (ugs.);Macke (ugs.);Tic (geh.)
-schneckenförmig;spiralenförmig
-Wechselstrommaschine;Wechselstromgenerator
-Rationalität;vernünftige Denkweise;Vernünftigkeit
-bestellen (Boden);bearbeiten;kultivieren;in Kultur nehmen;ackern;beackern;unter Kultur nehmen
-Breitlauch;Fleischlauch;Porree (norddeutsch);Lauch (süddt.);Spanischer Lauch;Winterlauch;Aschlauch;Welschzwiebel;Gemeiner Lauch
-Tintenfisch;Cephalopod;Kopffüßer
-Paralyse (fachspr.);Lähmung
-Sequester (fachspr.);abgestorbenes Teil eines Organs
-Kontosaldo;Kontostand
-Saturation (fachspr.);Sättigung;Sattheit
-abstürzen;fallen;absinken;abfallen;niedergehen
-Jagdbeute;Wildbret;Wildfleisch;Wild
-Schrank (ugs., fig.);(so eine) Kante (mit Geste) (ugs.);(eine) XXL-Ausgabe (ugs., scherzhaft);Hüne;Kerl wie ein Baum (ugs.);Koloss;Kleiderschrank (ugs., fig.);Bulle (ugs.);wenn (d)er im Türrahmen steht, wird es dunkel (ugs., Spruch);Riesenkerl;Riese (Hauptform);(ein) Trumm von einem Mann;Goliath;Zweimetermann;Hünengestalt
-kongenial;harmonisierend;einmütig;geistesverwandt;geistig ebenbürtig
-anpassen;(sich) einstellen (auf);(sich) einrichten (auf);(sich) akkommodieren
-Ansprechperson;Verbindungsperson;Vertrauensperson;Kontaktperson;Ansprechpartner
-schwer heben;hieven;hochhieven
-pro Hundert;v. H.;%;Prozent;von Hundert
-(etwas) trainieren;(jemanden/ein Tier) konditionieren (fachspr.);(jemanden/ein Tier) dressieren;(etwas) einüben;(ein Tier) abrichten
-(sich) zurückführen lassen auf;(sich) reduzieren lassen auf
-Ges.m.b.H. (österr.);Gesellschaft mit beschränkter Haftung;GesmbH (österr.);GmbH
-Dornstrauch;Dornbusch
-abschuppen;schuppen;Schuppen entfernen
-ein und dasselbe;ident (österr.);wie;ebenso;ohne Unterschied;haargenau dasselbe;dasselbe;identisch;gleich;gleichartig;genauso;dasselbe in Grün (ugs.)
-Aufhebung;Kündigung;Abrogation;Außerkraftsetzung
-vale (lat.);tschüss;lebe wohl;ciao (ital.);tschüs;adieu (franz.);Servus (österr.);ade
-anschwellen lassen;steigern;anwachsen lassen
-Ehrung;Ehre;Achtung;Andacht;Anerkennung
-gegenzeichnen;bestätigen
-nach der Geburt;postnatal;postpartal;postpartum (fachspr.);nachgeburtlich
-Schläger;Keule;Knüppel;Prügel
-Wohnquartier;Kiez (ugs., berlinerisch);Grätzl (ugs., wienerisch);Barrio (fachspr., Jargon, spanisch);Wohngegend;Block;Grätzel (ugs., wienerisch);Wohnviertel (Hauptform);Wohnbezirk;Wohnblock;Veedel (ugs., kölsch);Wohngebiet;Hieb (ugs., wienerisch)
-Kompaniefeldwebel;Spieß (ugs.);Mutter der Kompanie (ugs., fig.)
-geglättet;ausgewuchtet;ausgeglichen
-Vorsteher;Prinzipal
-Firmenbild;Firmenimage;Markenauftritt;Firmenerscheinungsbild
-Drahtbund;Drahtrolle
-Schnecke;Gastropode (fachspr.)
-(etwas) gewaltsam öffnen (Hauptform);aufstemmen (mit Brecheisen / Stemmeisen);(sich zu etwas) Zugang verschaffen;aufbrechen;knacken (ugs.);aufhebeln
-Steigrohr;Steigleitung
-ultramodern;supermodern
-Zypriot;Zyprer
-Werbetarif;Anzeigenkosten;Anzeigentarif
-Niete (auf Kleidung);Niet
-(jemanden bei jemandem) schlecht machen (ugs.);in ein schlechtes Licht setzen;kein gutes Haar an jemandem lassen
-Akzeptierung;Akzeptanz;Aufnahme;Annahme
-Delikatesse;Gaumenkitzel;Leckerli (beim Sprechen über Tiere);Spezialität;Gustostückerl (österr.);kulinarische Offenbarung;Leckerbissen;Schmankerl (ugs.);Gaumenfreude;(eine) Köstlichkeit;(lukullischer) Hochgenuss;Hochgenuss;Gaumenschmaus;Genuss
-beschreiben;spezifizieren;einzeln (umständlich) anführen;konkretisieren;ausführlich angeben
-forthetzen;losstürzen
-Gerinnung;Koagulation (fachspr.);Gerinnen
-häufig;x-fach;zigmal
-Persiflage;Spöttelei;Ridikülisierung (geh., franz.);(geistreiche) Verspottung
-an sich nehmen;(sich) etwas aneignen;(sich) nehmen (ugs.);(sich einer Sache) bemächtigen;in Besitz nehmen;an sich reißen (auch figurativ);Besitz ergreifen von
-Kommunikationssteuerung;Übermittlungskontrolle
-Bruderschaft;Kongregation;Sodalität;Fraternität
-rücksichtsvoll;zurückhaltend;unaufdringlich;vorsichtig;unauffällig;verhalten;taktvoll;schonend;dezent;diskret;leise (fig.);zurückgenommen (geh.)
-Funktionstest;Funktionsprüfung
-Aufnahme eines Stoffes;Inkorporation (fachspr.);Einverleibung
-Architekt (geh., fig.);Verantwortlicher;Hauptmatador (ugs., fig.);Auslöser;...gestalter;Initiator;Macher (ugs.);Initiant (schweiz.);...macher (ugs.);Verursacher;Gestalter;Vater (fig.);Urheber
-Einwendung;Appellation (fachspr., schweiz.);Berufung (juristisch);Revision (juristisch);Anfechtung (juristisch);Intervention (fachspr.);Rekurs (juristisch, schweiz.);Einsprache (schweiz.);Einspruch (bundesdeutsch, juristisch, österr.);Beschwerde (juristisch);Widerspruch (juristisch)
-Pubertät;Flegeljahre;Adoleszenz;Zeit der einsetzenden Geschlechtsreife;Reifezeit;Entwicklungsjahre;Jugendalter;Pubertätszeit;Pubertätsjahre;Entwicklungsalter;Jugendjahre
-Umschaltung;Umstellung
-(Filme von anstößigen Stellen) reinigen;kürzen;zensieren;säubern
-hinhören;die Ohren spitzen (ugs.);(die) Ohren aufsperren;zuhören (Hauptform);lauschen;horchen;ganz Ohr sein (ugs.);losen (schweiz., süddt., österr.)
-Geistesverwandtschaft;Interessengleichheit
-kompetent;kenntnisreich;geübt;sachverständig;erfahren;sachkundig;professionell;fachkundig;fähig;beschlagen;bewandert;versiert;trittsicher (ugs., fig.)
-Breitstrahler (veraltet, österr.);Nebelscheinwerfer
-Verlegung (nach);Verschiebung
-Zeitabdruck;Zeitstempel
-Anästhesist (fachspr.);Facharzt für Anästhesiologie;Narkosearzt;Anästhesiologe (fachspr.)
-facettenreich;mannigfaltig;(ein) Kaleidoskop (von) (positiv);bunt;verschiedenartig;vielschichtig;mannigfach;(eine) bunte Mischung (von);vielfältig;multiperspektivisch (geh., bildungssprachlich);mancherlei;gemischt;eine breite Palette an (fig.);viele Aspekte haben;vielgestaltig;eine große Auswahl an
-Schielen;Strabismus (fachspr.)
-(sich) fügen;das Handtuch werfen (fig.);zurückweichen;(ein) Einsehen haben;weichen;(einen) Rückzieher machen (ugs.);kuschen (ugs.);(sich) einsichtig zeigen;kleine Brötchen backen (müssen) (fig.);einknicken (ugs., fig.);die Stellung räumen (fig.);kein Rückgrat haben (fig.);Früh krümmt sich, was ein Häkchen werden will. (ugs., Sprichwort);(den) Kopf einziehen (fig.);die Platte putzen (ugs.);(sich) zurückziehen;nachgeben (Hauptform);zurückrudern (fig.);klein beigeben;(sich) beugen;zu Kreuze kriechen (geh., abwertend, fig.);einlenken;(sich) ducken (fig.);den Schwanz einziehen (ugs., fig.)
-trocken;spröde
-EWI (Abkürzung);Europäisches Währungsinstitut
-verdicken;abbinden
-Pflichtethik;Lehre der ethischen Pflichten;Deontologie;Deontologische Ethik
-Kälte verbreiten;kühlen
-Prüfsumme;Checksumme;Quersumme
-scharwenzeln (ugs.);trippeln;tänzeln
-(immer nur) mit Samthandschuhen anfassen (ugs., fig.);überbehüten;verhätscheln;betuddeln (ugs., norddeutsch);in Watte packen (fig.);(jemandem) den Arsch nachtragen (derb, fig., variabel);verwöhnen;(jemandem) jede Arbeit abnehmen;(jemandem) den Arsch pudern (derb, fig.);hätscheln und tätscheln;verziehen;(jemandem) den (eigenen) Hintern hinterhertragen (ugs.);(jemandem) Zucker in den Arsch blasen (derb, fig.);verpimpeln (ugs., regional);von vorne bis hinten bedienen;verpäppeln;(es jemandem) vorne und hinten hereinstecken (derb, fig.);verweichlichen;verzärteln;betüddeln (ugs., norddeutsch);betutteln (ugs., norddeutsch);betütern (ugs., norddeutsch)
-unbedacht;gedankenlos;unverantwortlich;unbekümmert;bedenkenlos;leichtfertig;verantwortungslos;als gäb's kein morgen mehr (ugs., fig.);sorglos;leichtfüßig
-kontrahieren;zusammenziehen
-Reiniger;Säuberer
-SU (Abkürzung, DDR);Union der Sozialistischen Sowjetrepubliken;UdSSR (Abkürzung);SSSR (Abkürzung);Sowjetunion (Hauptform);Reich des Bösen (abwertend, historisch)
-folgen lassen;hinzufügen zu
-selbstverständlich;gerne;no na (ugs., Einschub, österr.);natürlich (ugs.);bereitwillig (Hauptform);gern;selbstredend;selbstverfreilich (ugs., scherzhaft);sicher;sicherlich;anstandslos;freudig
-äolisch;aeolisch
-Sondernummer;Spezialausgabe;Sonderausgabe
-Teerstuhl;Melaena (fachspr.)
-salopp;kess
-unter Wahnvorstellungen leidend;wahnsinnig;geisteskrank;geistig umnachtet;bekloppt (ugs.);verrückt (geworden);durchgedreht (ugs.);von Sinnen (geh., literarisch, veraltet);(total) von der Rolle;gaga (ugs.);ballaballa (ugs.);narrisch (ugs., bayr.);geistesgestört;irrsinnig (ugs.);jeck (ugs., kölsch);unzurechnungsfähig;durch den Wind (ugs.);psychotisch;nasch (ugs., bayr.);(total) durchgeknallt (ugs.);irre (ugs.)
-seinen Verlauf nehmen;vorgehen (ugs.);vonstattengehen;abgewickelt werden;laufen;seinen Lauf nehmen;verlaufen;(sich) vollziehen (geh.);abrollen;(schnell / kurzfristig / einfach ...) gehen (ugs., variabel);über die Bühne gehen (ugs.);im Gange sein;veranstaltet werden;stattfinden;ablaufen
-Schreckensherrschaft;Zwangsherrschaft;Willkürherrschaft;Despotismus;Schreckensregime;Despotie;Tyrannis;Tyrannei;Terrorherrschaft;Gewaltherrschaft;Diktatur;Terror
-retrobulbär (fachspr.);hinter dem Augapfel
-Zulauf;Run (auf);große Nachfrage;Andrang;Zustrom;Ansturm
-Absencen haben (geh.);gedankenverloren;weit weg (ugs.);abwesend;nicht ganz da (ugs.);in Gedanken (ugs.);nicht alle (seine) fünf Sinne beisammen haben;(geistig) weggetreten;in den Wolken;erdenfern (geh.);entrückt (geh.);völlig daneben (sein) (ugs.);(in Gedanken) versunken;geistesabwesend;selbstvergessen;geistig abwesend;nicht ganz bei sich
-Blattstiel;Blütenstiel;Stiel
-Ausübung;Geltendmachung
-Verkörperung;wie gemalt;Modell;Schulbeispiel;wie aus dem Lehrbuch;Prototyp;Musterbild;Präzedenzfall (fig.);Idealbild;Bilderbuch-...;(perfekte) Fallstudie (zu);Inbegriff;Idealtyp;Klassiker (auch figurativ, auch ironisch);Paradebeispiel;wie aus dem Bilderbuch;Musterfall;Musterbeispiel
-Modellpuppe;Schaufensterpuppe
-schmoren;glimmen;schwelen
-AKW;Kernkraftwerk;KKW;Atomkraftwerk;Atommeiler (ugs.);Nuklearmeiler (ugs.)
-struppig;strähnig;zottelig;zottig;zerzaust
-mustergültig;maßgebend
-widerwillig;ungern;schweren Herzens (ugs.);trotzig;unfreiwillig
-Geschworener;Vereidigter
-am Bauch;Unterleibs...;Bauch...;abdominal (fachspr.)
-dazwischenhauen;dazwischenkommen;dazwischenfahren;dazwischengehen
-Herstellung;Anfertigung;Erstellung;Produktion;Fabrikation;Schaffung;Generierung;Fertigung;Verfertigung;Zubereitung;Erzeugung;Hervorbringung;Aufbau
-Fußhebel;Pedal
-(mit etwas) klimpern;(etwas) klingeln lassen
-prellen;auftreffen (auf);zusammenstoßen (mit);stoßen (an, gegen);prallen
-Systemprogramm;Dienstprogramm;Hilfsprogramm;Tool (fachspr.)
-Intarsia;Einlegearbeit;Intarsie;eingelegtes Muster
-verrechnen;miteinander ausgleichen;anrechnen;aufrechnen
-rüberbringen (ugs.);hinüberbringen (ugs.);klarmachen (ugs.);darbringen;erläutern;darlegen;(jemandem etwas) verklickern (ugs.);präzisieren;explizieren;erklären;verklugfiedeln (ugs.);vermitteln;ausführen;konkretisieren
-Desodorant;Deo;Deodorant
-(sich) taufen lassen;die Taufe empfangen
-Wald (Hauptform);Forst;Tann;Holz
-Ufer;Damm;Böschung;Wall
-hektisch;übereilt;hastig;fieberhaft
-Nervenarzt;Neurologe
-Violinenbauer;Geigenhersteller;Geigenbauer;Violinenhersteller
-Box;Packung;Schachtel;Karton
-Wissensdurst;Neugierde;Entdeckerfreude;Wissbegierde;Neugier
-Schote;Schale;Hülse
-höckerig;knubbelig;tuberkular (fachspr.);knotig;warzig
-Selbstlosigkeit;Uneigennützigkeit;Opferbereitschaft;Selbstaufopferung;Hilfsbereitschaft;Altruismus;Selbstverleugnung
-Arzneiausgabe;Apotheke
-Herbeiführen;Einleitung
-Betrag;Summe;Absolutbetrag (fachspr.);Menge
-verknöchern;versteinern
-den nassen Tod finden;ertrinken (Hauptform);ersaufen;untergehen;den nassen Tod erleiden;versaufen (derb);absaufen (ugs.);in den Fluten umkommen
-Gerät;Werkzeug (Hauptform);Gerätschaft;Instrument
-Tropfen (ugs.);Gesöff (derb);Durstlöscher (ugs.);Trank;Trunk;Drink (ugs., engl.);Getränk;(das) Trinken (ugs.)
-klitzeklein;nano...;unendlich klein;sehr klein;mikro...;klein;infinitesimal;gering;winzig;mikroskopisch
-austarieren;ins Gleichgewicht bringen;aufeinander abstimmen;ausbalancieren
-hineinpacken;hineinstopfen;reinpacken (ugs.);reinquetschen (ugs.);hineinzwängen;hineinquetschen;reinzwängen (ugs.)
-unschätzbar;unübersehbar;nicht abschätzbar
-nacheinander;in einem durch;in Folge;hintereinanderweg;hintereinander;ohne Pause;ohne Unterbrechung;in Serie;aufeinander folgend;aufeinanderfolgend;am Stück
-Emblem;Symbol
-intrinsisch (fachspr.);innerhalb
-Stammwort;Stamm;Wurzelwort;Wortstamm;Stammmorphem;Stem (fachspr.)
-Komprimierung;Druck;Kompression;Zusammendrückung;Pressung;Verdichtung
-kantig;eckig
-Hauptbestandteil;wesentlicher Bestandteil;Grundelement
-abkühlen;abschrecken
-absurd;fratzenhaft;grotesk
-Kalzinierung (Hauptform);Kalzinieren;Verkalkung;Kalkbrennen;Calcination;Calcinieren
-Zusammenhang;Kohärenz;Rahmen;Umfeld;Kontext;Zusammengehörigkeit;Zusammenhalt
-Insel;Eiland (geh., poetisch)
-peroral (fachspr.);durch den Mund
-linsenförmig;lentikular
-oral (fachspr.);mündlich;Mund...;mundwärts;den Mund betreffend
-Onomatopoiie;Schallwortbildung;Tonwortbildung;Lautmalerei;Onomatopoie;Onomatopöie;Schallnachahmung;Klangnachahmung;Onomatopoesie;Lautnachahmung;Tonmalerei;Klangnachbildung
-voten (ugs.);stimmen;abstimmen;wählen;votieren
-Zaun;Einzäunung;Fenz (ugs.);Umzäunung
-Reduziergetriebe;Untersetzungsgetriebe;Reduktionsgetriebe
-zerren;trecken (regional);mitreißen;abschleppen;reißen;ziehen;schleppen;hinter sich her schleifen
-jederzeit;unabänderlich;beständig;unveränderlich;stetig;ständig;invariabel;invariant (fachspr.);gleichbleibend;immer wieder;inert;feststehend;konstant;kontinuierlich
-Anziehung;Anziehungskraft;Schwere;Schwerkraft;Massenanziehung;Gravitation
-extrakorporal;außerhalb des Körpers
-Auslösemechanismus;Auslöser;Trigger
-Staatsbürgerschaft;Staatszugehörigkeit;Staatsangehörigkeit;Nationalität
-fehlende Harnabsonderung;Anurie (fachspr.)
-Spitzsenker;Senker
-selbstgefällig;blasiert;selbstzufrieden
-eidetisch;ikonisch;bildhaft;anschaulich
-Inhaber;Besitzer;Träger;Eigner;Eigentümer;Inh. (Abkürzung)
-geometrischer Ort;Ortskurve
-Gebetsteppich;Betteppich
-(berechtigter) Anspruch;zustehender Betrag
-Käuflichkeit;Verfügbarkeit
-komplementäre Metalloxid-Halbleiter;CMOS
-Mehrzahl;Plural
-Corpus Delicti;Beweismaterial;Beweis;Beweismittel;Beweisstück;Beleg;Nachweis
-aus erster Hand;neuwertig;neu (unbenutzt) (Hauptform);unbenutzt;jungfräulich (ugs., fig.);wie neu;frisch ausgepackt;ungebraucht;frischgebacken (ugs.);soeben fertig geworden;fabrikneu
-antiphlogistisch (fachspr.);entzündungshemmend;antiinflammatorisch (fachspr.)
-etwas liegen lassen;etwas nicht erledigen;(sich) nicht um etwas kümmern
-Eule;Uhu (ugs.);Nachtvogel
-Zeitmesser;Zeitanzeiger;Uhr;Chronometer;Zeiteisen (ugs.)
-abdampfen (ugs.);(sich) entfernen (geh.);(sich) trollen (ugs.);abschieben (ugs.);(sich) verziehen (ugs.);die Düse machen (ugs.);von dannen ziehen (geh., veraltend);gehen (= 'weggehen');entschwinden (geh., scherzhaft);(sich) von dannen machen (geh., veraltend);Leine ziehen (ugs., salopp);von dannen eilen (geh., altertümelnd);(sich) vom Acker machen (ugs.);von dannen rauschen (geh., ironisierend);entfleuchen (geh., literarisch, scherzhaft);(sich) zurückziehen;abschwirren (ugs., salopp);abhauen (ugs., salopp);abtreten (fachspr.);abdackeln (ugs.);weggehen (Ortswechsel) (Hauptform);fortgehen;verschwinden;entrauschen (geh., ironisierend);abzischen (ugs.);abziehen (ugs.)
-stumpf machen;die Schärfe nehmen
-betteln;abschmutzen (österr.);schnorren (ugs.);um Geld anpumpen (ugs.);anbetteln
-Pfeiler;Mast;Pohl (ugs., norddeutsch);Stab;Stange;Pfahl;Pfosten
-Umlaufmarkt;Anschlussmarkt;Sekundärmarkt
-antineoplastisch (fachspr.);Geschwulstwachstum hemmend
-Makulatur;(ein) totgeborenes Kind (fig.);keinen Sinn und Zweck haben;für die Katz (ugs.);keinen Sinn haben;hoffnungsloses Unterfangen;umsonst (ugs.);zwecklos;sinnlos;nichts zu machen sein;hat keinen Wert (ugs., ruhrdt.);keinen Sinn machen;vergeblich;nicht realisierbar;(das) kannst du vergessen (ugs.);für den Arsch (vulg.);zu nichts gut sein (ugs.);zu nichts führen;führt zu nichts (ugs.);(von vornherein) zum Scheitern verurteilt;ohne Aussicht auf Erfolg;bringt nichts (ugs.);keinen Zweck haben;(ein) tot geborenes Kind (fig.);ohne Sinn und Zweck;witzlos (ugs.);illusorisch;(gut) für die Tonne (ugs.);aussichtslos (Hauptform);keine Option;unsinnig
-schädlich;schuftig;verrucht (veraltend);schurkisch;hundsgemein;hundig (österr.);über Leichen gehend (ugs.);arglistig;verabscheuenswert;verwerflich;garstig;perfid;böse;gehässig;übel (ugs.);mies (ugs.);schofel (ugs.);gemein;verabscheuungswürdig;perfide;bösartig;niederträchtig;schäbig;tückisch;boshaft;fies;hinterfotzig;infam (geh.);ruchlos
-zusammenwerfen;auf einen Haufen werfen
-Wegweiser;Touristenführer;Fremdenführer
-Galgenstrick (ugs.);Gangster;Schurke;Ganove (ugs.);Gauner;Verbrecher (Hauptform);Galgenvogel (ugs.);Lump;Halunke;Bandit
-Stress;Hektik;(psychische) Belastung;Aufregung;Nervosität;Druck
-England (ugs.);Vereinigtes Königreich;UK (Abkürzung, engl.);GB (Abkürzung);Großbritannien;Vereinigtes Königreich Großbritannien und Nordirland (Amtsdeutsch)
-Streuung;Feinverteilung
-bemuttern;umsorgen;pflegen;(sich) kümmern um;hegen
-Gässlein;Sträßchen;Gasse;Gässchen;Altstadtgasse;Twiete (ugs., norddeutsch);Weg
-Schwemmland;Marsch;Mersch;Marschland;Masch
-Initiative;Tätigwerden;Maßnahme;Schritte;Aktion;...aktion (ugs.)
-Neuralgie (fachspr.);Nervenschmerz
-Terminal;Sichtgerät;Datenendgerät
-(jemandem etwas) vorhalten;(jemandem etwas) vorwerfen (Hauptform);Vorwürfe machen;Vorhaltungen machen;(jemandem etwas) unter die Nase reiben (fig.);(jemandem etwas) aufs Brot schmieren (ugs., fig., variabel);anschuldigen;(jemanden) beschuldigen;zum Vorwurf machen
-Hausaufgabe;Schulaufgabe;Hausübung (österr.);Hausarbeit;Schularbeit;Heimarbeit
-in Fülle;reichhaltig;ergiebig;ausführlich;füllig;ausgiebig;üppig;opulent;reichlich
-Geduldsspiel;Vexier;Geduldspiel;Knobelei;Knobelspiel;Rätsel
-in Email malen;glasieren;emaillieren;lackieren
-Freier Deutscher Gewerkschaftsbund (DDR);FDGB (Abkürzung)
-nichtsahnend;unbedarft;tumb;ganz schön naiv (ugs.);ohne Bedenken;an den Osterhasen glauben (ugs., fig.);naiv;sorglos;töricht;vertrauensselig;arglos;unbekümmert;an den Weihnachtsmann glauben (ugs., fig.);bedenkenlos;schön blöd (ugs.);leichtgläubig;ahnungslos;blauäugig
-einfühlsam;empfindsam;sensibel;gefühlvoll
-Postfach;Mailbox;Sortierfach
-unzuverlässig;wankend;unbeständig;ohne Gewissheit;labil;ungewiss;schwankend;wechselhaft
-Ortszulage;Ortszuschlag
-parallel;Seite an Seite;nebeneinander
-absolute Häufigkeit;absolute Frequenz
-(mit jemandem) verkehren;(häufiger) sehen;Umgang haben (mit);in persönlichem Kontakt stehen;(den) Verkehr mit jemandem pflegen;Kontakt haben;(jemanden) treffen
-engl. (Abkürzung);englisch
-auf schädliche Weise;schädlich;nachteilig
-kirchlich;kirchengeistlich
-behauen;bearbeiten;hauen
-Lagerstätte;Vorkommen;Quelle
-Rundschleifmaschine;Feuerradl (ugs., bayr., scherzhaft);Schleifhexe (ugs.);Trennschleifer;Schleifgerät;Bandschleifer (ugs.);Trennschleifmaschine;Innenrundschleifmaschine;Flex (ugs.);Winkelschleifer;Schleifer (ugs.);Flachschleifmaschine;Schleifmaschine (Hauptform);Winkelschleifmaschine
-Stofflichkeit;Materialität;materielle Natur;Körperlichkeit
-Dekomposition (fachspr.);Zerlegung;Zersetzung
-durchsetzen;unterwandern;langsam eindringen;(sich) einschmuggeln;einsickern;(sich) einschleichen;infiltrieren (fachspr.)
-exorbitieren (geh., veraltet);(jemandes) Temperament geht mit ihm durch;des Guten zu viel tun;(es) zu toll treiben (ugs.);über das Ziel hinausschießen (ugs., fig.);(es) übertreiben;übereifern;übersteigern;mit Kanonen auf Spatzen schießen (ugs., fig.);mehr tun als gut wäre;nicht mehr feierlich sein (ugs.);zu weit gehen (ugs.);überziehen;den Bogen überspannen (ugs., fig.);(es) auf die Spitze treiben;mehr tun, als richtig ist;ins Aschgraue gehen (ugs.);das Kind mit dem Bade ausschütten (ugs., fig.);(sich) reinsteigern (ugs.)
-Seitenwagen;Beiwagen
-lenken auf;richten auf
-Weinbeere;Weintraube
-Ökobilanz;Umweltbilanz;Lebenszyklusanalyse
-andersherum (ugs.);warm (ugs.);queer (engl.);gleichgeschlechtlich (orientiert);andersrum (ugs.);homophil;homosexuell;vom anderen Ufer (ugs.)
-anordnen;erlassen;anweisen (geh.);vorschreiben;verfügen (dass) (Amtsdeutsch);dekretieren;(eine/die) Anweisung geben;verhängen
-das Ohr betreffend;aurikular (fachspr.);aurikulär (fachspr.);aural (fachspr.)
-Verschlüsselung;Kryptographie;Kryptografie
-Armspange;Armreif
-(jemandem / irgendwo) vorliegen;angekommen sein (Nachricht, Sendung)
-Nutzeffekt;Vorzug;Vorteil;Benefit (fachspr.);Nutzen;positiver Aspekt;Gewinn;Pluspunkt;Plus
-Fischgräte;Gräte
-Exophthalmus (fachspr.);krankhaftes Vortreten des Augapfels
-Traubenzucker (ugs.);Glucose;D-Glukose;Dextrose (veraltet);Glukose
-Aufnahmevermögen;Intelligenz;Auffassungsvermögen;Erkenntnisfähigkeit;geistiger Horizont (fig.);Denkvermögen;Auffassungsgabe
-Rasenstück;Sode (ugs.)
-Überfluss;Menge;Fülle
-onkotisch (fachspr.);eine Geschwulst betreffend
-Schlamm;Schlick;Mulm;Morast;Schlammablagerung
-(sich) einleben;(sich) eingewöhnen;vertraut werden (mit);(sich) gewöhnen;(sich) akklimatisieren
-opalartig schillernd;opaleszierend
-im Turnus;umschichtig;wechselweise;mal ..., mal ...;im Wechsel;alternierend (fachspr.);abwechselnd (Hauptform);turnusmäßig
-Programm;Kanal;Sender
-Umerziehung;Umschulung
-Gefälligkeit;Liebenswürdigkeit;Gefallen
-beste Zeit(en) (ugs.);Blüte;Hochzeit;beste Jahre;Glanzzeit;Hoch-Zeit;obere Wendepunktphase;Blütezeit;Hausse;Hochblüte;Hochkonjunktur (fig.);Hochphase;Boom (fig.)
-Frauenwirt (veraltet);Zuhälter (Hauptform);Schutzengel;Beschützer (verhüllend);Louis (ugs.);Peitscherlbua (ugs., österr.);Lude (ugs.);Kuppler (veraltet);Strizzi (ugs., salopp, österr.);(einer der) (seine) Pferdchen am Laufen hat (ugs.);Stenz (ugs., süddt.);Pimp (engl.);Loddel (abwertend);Maquereau (franz.)
-EFRE;Europäischer Fonds für regionale Entwicklung
-Kettenlinie;Kettenkurve;Seilkurve;Katenoide
-Weichmacher;Zartmacher
-unnachgiebig;hartnäckig;eigensinnig;dickköpfig;starrköpfig;stur;obstinat (geh., lat., sehr selten);refraktär (fachspr.);starrsinnig;verbohrt (ugs.)
-verbos (geh., lat.);wortreich;ausführlich;mit vielen Worten;breit
-Verbrauchsmaterialien;Verbrauchsstoffe
-Geschmack;Würze;Wohlgeschmack;Geschmacksrichtung
-kritisch beleuchten (geh.);Trau, schau, wem! (ugs.);untersuchen;auf den Prüfstand stellen (fig.);auditieren (fachspr., engl., lat.);evaluieren (fachspr.);überprüfen;studieren;hinterfragen;austesten;examinieren;infrage stellen;(etwas) auf Herz und Nieren prüfen (ugs., fig.);in Frage stellen;etwas (näher) unter die Lupe nehmen (ugs., fig.);(eingehend, genau) prüfen;abklopfen (ugs.)
-Stoff;Substanz (fachspr.)
-Fiaker;Droschke;Pferdedroschke
-abstottern (ugs.);abzahlen;tilgen
-Ausruf;Einwurf;Zwischenruf
-Orbita (fachspr.);Augenhöhle
-aufleuchten;aufblitzen;aufflackern
-gesperrt;nicht zugreifbar
-Eingliederung;Einbeziehung;Zusammenführung;Verzahnung;Integration;Aufnahme;Einbeziehen
-die närrischen Tage;Karneval;Fasching;fünfte Jahreszeit (ugs.);Fasnacht (ugs., schweiz.);(die) tollen Tage;Fastnacht;närrisches Treiben;Fasnet (ugs., alemannisch, schwäbisch);Fastelovend (ugs., kölsch, rheinisch)
-Autowäsche;Autowaschanlage;Waschstraße;Waschanlage
-Neuerung;Novität (geh.);Innovation;Neuheit;Neueinführung;Neuschöpfung
-enorm;unermesslich;gigantisch;titanisch;ungeheuer;Herkules... (fig.);überdimensional;riesig (Hauptform);riesenhaft;formidabel (geh.);aberwitzig (fig.);ungeheuer groß;riesengroß;immens;von ungeheurer Größe;kolossal;monumental;immensurabel (geh.);Mammut... (fig.);monströs;gewaltig;überdimensioniert;astronomisch;mächtig
-Schürfrecht;Claim;Schürferlaubnis;Förderrecht
-Mistel;Albranken (ugs.);Mistelzweig;Drudenfuß (ugs.);Hexenbesen (ugs.);Hexenchrut (ugs.);Donnerbesen (ugs.);Heiligkreuzholz (ugs.)
-festlegen;beschreiben;definieren;bestimmen;abgrenzen;festsetzen;begrenzen;abstecken
-stumpf machen (gegen);unempfindlich machen;abhärten;abstumpfen;abtöten;betäuben
-Pille (ugs.);Antibabypille
-Nachdenkfrist;Nachdenkzeit;Bedenkzeit;Zeit zum Nachdenken
-Tauber;Täuberich;Täuber
-finanzielle Mittel;Geld;Kapital;Valuta (fachspr.);Währung (Hauptform);Zahlungsmittel;Devisen
-(spontanes) Foto;Schnappschuss;Momentaufnahme
-überlagern;schichtweise legen
-Sari (Hauptform);Wickelgewand;Gewand der Inderinnen
-Aggressor;Eindringling;Angreifer;Attackierender
-unterjochen;unterdrücken;knechten;knebeln;opprimieren (geh., lat., veraltet);kleinhalten;knuten;unterbuttern (ugs.);versklaven
-Preissenkung;Preisreduktion;Preisreduzierung
-(sich) durchbeißen (ugs.);(sich) durchkämpfen;(sich) durchboxen (fig.);(sich) durchschlagen;(sich) selbst helfen;(sich) durchfretten (ugs., süddt.)
-Erhabenheit;Majestät;Würde;Hehrheit (geh., sehr selten, veraltet)
-Kolumne;Spalte (ugs.);regelmäßiger Beitrag;regelmäßig erscheinender Artikel eines Autors
-Synizese;Synäresis;Synärese;Synizesis;Kontraktion
-Originalität;Echtheit;Unverstelltheit;Authentizität;Glaubwürdigkeit
-Seebär (ugs., scherzhaft);Fahrensmann;Seemann (Hauptform);Seefahrer;Matrose;Schiffer
-Eroberer;Invasor
-Degen;Rapier;Florett;Fechtwaffe;Stoßdegen
-ordern;anfordern
-Schleifen;Schliff
-(sehr) nah;innig;intim;eng
-Veränderung;Durchsicht;Revision;Abänderung;Redigieren;Änderung
-Antriebssteuerung;Einzelsteuerung
-Bestandsüberwachung;Lagerbestandskontrolle;Lagerkontrolle
-Frisbee;Diskus;Schwebedeckel (ugs., DDR, veraltet);Wurfscheibe
-Gutbereich;Abnahmebereich
-Sonorität;Wohlklang
-Empfänger;Adressat;Warenempfänger
-Scharlatan;schwarzes Schaf (ugs., fig.);Rosstäuscher;Abzocker (ugs.);Bauernfänger (ugs.);Nepper (ugs.);Schwindler;Schlawack (ugs., bayr.);Betrüger (Hauptform)
-positionieren;ausrichten;abstellen;hinstellen;platzieren;zurechtrücken;ablegen
-UNEP;Umweltprogramm der Vereinten Nationen
-wählerisch;schneubisch (ugs., regional);spitzfingrig (fig.);kritisch;krüsch (ugs., regional);anspruchsvoll;das Beste ist gerade gut genug
-(sich) betrinken;(sich einen) ballern (ugs.);(einen) verlöten (ugs., regional);(einen) über den Durst trinken (ugs., variabel);(sich) die Hucke vollsaufen (ugs.);bürsteln (ugs., österr.);(sich) zuschütten (ugs.);(sich) zulaufen lassen (ugs.);(sich) besaufen (ugs.);(sich) abschießen (ugs.);(sich etwas) genehmigen (ugs.);süppeln (ugs.);(sich) volllaufen lassen (ugs.);(sich) einen auf die Lampe gießen (ugs., fig.);(sich) die Kante geben (ugs.);tschechern (ugs., ostösterreichisch, salopp);(sich) sinnlos betrinken;bechern (ugs.);feiern (jugendsprachlich, verhüllend);(sich) einen zur Brust nehmen (ugs.);(sich) zusaufen (ugs.);(viel Alkohol) trinken;zechen (ugs.);saufen (ugs.);ins Glas schauen (ugs.);(sich) einen hinter die Binde kippen (ugs., fig.);(sich) zudröhnen (ugs.)
-Leitfähigkeit;Konduktivität
-Abgeschiedenheit;Einsamkeit;Einöde;Isolation;Abgelegenheit
-Spaziergang (ugs., fig.);eine meiner leichtesten Übungen (ugs., Redensart);Spielerei;einfache Sache;einfachste Sache der Welt (sprichwörtlich);ein Leichtes (ugs.);Pipifax (ugs.);(nur) (eine) Fingerübung (ugs.);(das) (reinste) Kinderspiel (fig.);Leichtigkeit;keine Hexerei (ugs.);(a) gmahde Wiesn (ugs., bayr., fig.);Kleinigkeit (ugs.);kein Kunststück (ugs.);kleine Fische (ugs., fig.);Pappenstiel (ugs.);Klacks (ugs.);kein Hexenwerk (ugs.);(ein) Leichtes (für jemanden) (Hauptform);Sonntagsspaziergang (ugs., fig.);wenn's weiter nichts ist ... (ugs., Spruch, kommentierend);(jemanden nur) ein Lächeln kosten (ugs., fig.);(ein) Kinderspiel (ugs., fig.);(nur ein) Klacks mit der Wichsbürste (ugs.)
-jemandem zuströmen;in Scharen zu jemandem kommen
-Drahtzange;Drahtschere
-Comicstrip;Manga (japanisch);Comic
-Blasenspiegelung;Zystoskopie (fachspr.)
-Augenblick;Moment;Zeitpunkt
-(jemanden) verdächtigen;(jemandem etwas) unterstellen;(die) Schuld zuweisen;(die) Schuld geben (an);(jemandem etwas) zur Last legen;(jemandem etwas) anlasten
-Ära;Zeitabschnitt;Epoche;Phase;Periode;Zeitalter
-sanitär;gesundheitlich
-Pipeline (engl.);Fernleitung;Rohrfernleitung
-angeknackst;wurmstichig;angeschlagen;schadhaft;angestoßen;in Mitleidenschaft gezogen;ramponiert;defekt;mitgenommen;beschädigt;lädiert
-Hautatmung;Perspiration (fachspr.)
-erbarmungslos;kaltblütig;kaltlächelnd;soziopathisch;schonungslos;unerbittlich;ohne mit der Wimper zu zucken (ugs., fig.);mitleidlos;ungerührt;inquisitorisch (geh., fig.);ohne Gnade und Barmherzigkeit;unbarmherzig;gnadenlos;skrupellos
-Fortpflanzung;Reproduktion;Vermehrung
-plombieren (fachspr.);siegeln;versiegeln (Hauptform);verplomben;mit einem Siegel versehen;besiegeln (geh., veraltet);mit einer Plombe versehen
-neigen;schräg stellen;kippen
-gerieben (ugs., negativ);hinterlistig (negativ);tückisch (abwertend);listig;schlau;clever;gerissen (negativ);verschlagen (abwertend);durchtrieben (abwertend)
-Agent;Werber
-Unfähigkeit;Unvermögen;Impotenz
-in der Schwebe lassen;unentschieden lassen
-Überdehnung;Distension (fachspr.)
-Sehnsucht nach Vergangenheit;Retrophilie (geh., selten);Rückwärtsgewandtheit;Nostalgie
-(jemandem) unbegreiflich;nicht nachvollziehbar;schwer nachzuvollziehen;(jemandem) ein Rätsel;(jemandem) unerklärlich;(jemandem) schleierhaft;unklar;(jemandem) unerfindlich (geh.);unverständlich;schwer verständlich;(ein) Buch mit sieben Siegeln (für jemanden) (fig.)
-sinnig;vernunftgemäß;gescheit (ugs.);sinnvoll;rational;vernünftig
-Gedächtnisschwund;Erinnerungslosigkeit;Erinnerungsverlust;Amnesie (fachspr.);Gedächtnisstörung
-Stereotyp;Schablone;(die) übliche Vorstellung;(die) landläufige Vorstellung;Klischeevorstellung;Schublade;Vorurteil;Klischee
-nicht unterscheidbar;nicht zu unterscheiden (von)
-Gallestauung;Gallenstauung;Cholestase (fachspr.)
-Spitze;Ecke;Zacke;Vorsprung;Zinke;keilförmiges Stück;Kante
-Kehrreim;Refrain
-für gültig erklären;rechtswirksam machen;validieren
-Haushaltung;Haushaltsorganisation
-Pharyngitis (fachspr.);Entzündung der Rachenschleimhaut;Rachenentzündung
-Hose mit Schlag;Schlaghose (Hauptform);Hose mit ausgestellten Beinen
-gemeinsam benutzen;teilen;mitbenutzen
-Zwischenblatt (Druckwesen);Durchschuss
-Erlaubnis;Bewilligung (Amtsdeutsch);Freigabe;grünes Licht (ugs.);Zustimmung;Signale stehen auf grün (ugs.);Abnahme (fachspr., juristisch)
-Funkstörung;elektromagnetische Störung
-Werbeslogan;Werbespruch
-Flusspferd;Großflusspferd;Hippo (ugs.);Nilpferd;Hippopotamus
-Berufskraftfahrer;Truckerfahrer (ugs.);Lastwagenchauffeur (schweiz.);Fernfahrer;Brummifahrer (ugs.);Trucker (ugs.);LKW-Fahrer (Hauptform);Lastwagenfahrer;Lastkraftwagenführer (fachspr.);Fernlastfahrer;Kapitän der Landstraße (ugs.)
-rösten (mit Fett, im Backofen);brutzeln;braten;brötscheln (ugs., westdeutsch);schmurgeln (ugs.)
-wedeln;wackeln (mit)
-unvermittelt;ohne Vorwarnung;unangekündigt;ohne Ankündigung;in nicht vorhersehbarer Weise;unvermutet;unvorhergesehenermaßen;unerwarteterweise;überraschend;unerwartet;unvorhergesehen;überraschenderweise;unversehens;wie ein Blitz aus heiterem Himmel (ugs., sprichwörtlich);überfallsartig;aus heiterem Himmel (ugs.);unverhofft;Überraschungs...
-Burnout;Erschöpfung;Abgeschlagenheit (schweiz.);Lassitudo (fachspr.);Burnout-Syndrom;Niedergeschlagenheit;Exhaustion (fachspr., lat., medizinisch)
-Zweck;Perspektive;Zielvorstellung;Zielsetzung;Ziel
-entwickeln;entwerfen;erstellen;erarbeiten
-nicht übertrieben;zumindestens (ugs.);allweg (landschaftlich, schwäbisch);zumindest;wenigstens;mindestens;jedenfalls;gut und gerne (ugs.);immerhin;ohne Übertreibung (gesagt)
-Kontinent;Erdteil;Landmasse
-Aushändigung (geh.);Erteilung;Ausgabe;Verteilung;Herausgabe
-Konnektivität;Verbindungsmöglichkeit;Schnittstellenausstattung;Anschlussmöglichkeit
-Verbringung (fachspr.);Beförderung;Spedition;Verlastung;Güterverkehr (Hauptform);Transport;Gütertransport
-Komik;Humor;Witz
-Käsemauke (ugs.);Mauke (ugs.);Fuß;Quadratlatsche (ugs.)
-Ausbauten;Erweiterungen;Vergrößerungen
-Ausstellen;Auflegen (einer Anleihe)
-Neutralisation;Neutralisierung
-würfelförmig;kubisch;würfelig
-Ordensschwester;Nonne (Hauptform);Klosterfrau;Ordensfrau;Schwester
-(daran) ansetzen;weiterspinnen (ugs.);anknüpfen;weiterverfolgen;aufgreifen
-Inbetriebnahme;Indienststellung;Inbetriebsetzung
-Alchimie;Transmutation;Alchemie;Goldmacherkunst;Kernumwandlung;Elementumwandlung
-Auslöser;Stellglied;Steuerelement
-Lakai (derb, abwertend);Prätorianer (geh., abwertend);Paladin;Vasall;Trabant (ugs., abwertend);Ergebener (abwertend);Hofschranze (ugs., abwertend);ergebener Anhänger;Getreuer (spöttisch);treuer Gefolgsmann;Knecht (abwertend)
-Ausguss;Ausfluss;Ausflussöffnung;Ablauf
-Holz;Nutzholz
-Hirte;Vormund;Hüter
-Roter Fingerhut;Digitalis
-Klaue;Tatze;Pranke;Pfote
-dampfen;dunsten
-fürbass (veraltet);vorwärts;entlang;weiter
-Corporate Identity;Unternehmensidentität
-Moskowiter (männl.);Moskauerin (weibl.);Moskowiterin (weibl.);Moskauer (männl.)
-(etwas) in Grund und Boden reden (/ kritisieren / verdammen / schreiben ...) (fig.);miesmachen (ugs.);herunterputzen (ugs.);kein gutes Haar an etwas lassen (ugs.);niedermachen;verreißen;zerpflücken (ugs.)
-Abhorchen (mit einem Stethoskop);Auskultation (fachspr.)
-eskortieren;begleiten
-W (Einheitenzeichen);Watt
-Abdomen (fachspr.);Bauch;Unterleib
-Kreis;Runde;Ring
-Taxwert;Schätzwert
-Tendinitis (fachspr.);Sehnenentzündung;Sehnenscheidenentzündung;Tenosynovitis (fachspr.)
-Schnitzerei;Schnitzarbeit
-Trümmer;Bruchstein
-Rasselgeräusch;Rhonchus (fachspr.)
-edukativ;Bildungs...;erzieherisch
-Kronenbohrer;Kernbohrer
-Kreuzung (Hauptform);Mischling (veraltet);(die) Hybride (fachspr.);Blendling (veraltet);Bastard (veraltet)
-Standbilder;Statuen
-wildern (Hauptform);ohne Berechtigung jagen;unerlaubt jagen
-Knochendurchtrennung;Osteotomie (fachspr.)
-Jahresring;Jahrring
-(eine) Hoffnung hegen;(einen) Wunsch haben;herbeiwünschen;(etwas) erhoffen;(sich) wünschen;(einen) Wunsch hegen (geh.);(sich) Hoffnungen machen (auf);erträumen;träumen (von) (fig.);(er)hoffen;(sich) erwünschen
-Stoß;Gerüttel;Schwingung;Vibration;Erschütterung
-kein schöner Anblick;hässlich (Hauptform);nicht sehr einnehmend (geh.);ungestalt;unästhetisch;schiech (ugs., bayr., österr.);unattraktiv;hässlliches Entlein (fig.);(eine) Beleidigung fürs Auge;schiach (ugs., bayr., österr.);unansehnlich;reizlos;unschön;(das) Auge beleidigen(d)
-Komposition;Positionierung;Arrangement (franz.);Anordnung
-Schiefergestein;Schieferton;Schiefer
-Code(zeichen);ID (Abkürzung);Chiffre (geh., franz.);Schlüssel;Geheimzeichen;Kennung;Identifikationsnummer;Identifizierungszeichen;Identifikator
-Schwindel;Schmu (ugs.);Hintergehung;Rosstäuscherei (veraltend);fauler Zauber (ugs.);Schurkenstück (geh.);Beschupp (ugs.);Prellerei;Betrug;Delusion (geh., lat.);Betrügerei;Bauernfängerei (ugs.);Beschmu (ugs.);Scam (fachspr., engl.);Irreführung;Beschub (ugs.);Nepp (ugs.);Abzocke (ugs.);Manipulation;Schummelei (ugs.);Täuschung (Hauptform);Beschiss (derb);Trickserei (ugs.);Gaunerei;Fraud (fachspr., engl.);krumme Tour(en) (ugs., salopp);Mogelpackung (ugs., fig.)
-Kürbis;Kürbisgewächs
-nicht stromführend;stromlos;tot (ugs.);(es ist) kein Saft (auf) (ugs.)
-jeder beliebige;jemand;irgendjemand
-tardiv;spät
-aufrollen;aufwickeln;aufspulen
-Unterstützung;Hilfe;Rückhalt;Gunstbezeigung;Förderung;Zutun;Stärkung;Schützenhilfe (ugs.);Gunstbezeugung
-Gepäckhalter;Gepäcknetz
-Adressteil;Anschriftsteil;Adressenteil
-rekurrierend;wieder auftretend
-knapp;beinahe;so ziemlich (ugs.);nicht ganz;bald;fast (Hauptform);nahezu (geh.);annähernd;(so) an die (vor Zahlwörtern) (ugs.);etwas weniger (als);ein bisschen weniger (als) (ugs.)
-erzielen;auf die Beine stellen (ugs., fig.);leisten;schaffen;erreichen;vollbringen;durchsetzen;vollenden;erwirken;umsetzen
-Kollision;Auffahrunfall (Straßenverkehr);Karambolage;Zusammenprall;Aufprall;Anprall;Zusammenstoß
-Fotosynthese;Photosynthese
-Prunk;Wichtigtuerei
-sorglos;grob fahrlässig;leichtsinnig;nachlässig;grobfahrlässig
-Rock'n'Roll;Rock and Roll
-niederkauern;hinkauern;kauern;hinknien;hocken;knien;ducken
-überziehen;überstreichen;anstreichen;beschichten
-Camper;Zeltbewohner
-Neigungswinkel;Neigung
-schwer erziehbar;schwierig
-Korpulenz;Beleibtheit;Leibesfülle;Dickleibigkeit
-Schweifratte;Biberratte;Coypu;Nutria;Myocastor coypus (fachspr., zoologisch);Sumpfbiber;Schweifbiber
-Seelenkunde;Psychologie
-Gang;Gangart
-anhaken;ankreuzen;abhaken
-wiederholend;zyklisch;iterativ;(sich) periodisch wiederholend
-auf etwas verzichten(d);abstinent;enthaltsam
-(sich) vergegenwärtigen;(sich) ein Bild machen (von);(sich) vorstellen
-seitlich angeordnet;kollateral;benachbart;seitlich
-Handzange (für Kontakte);Crimpzange;Kabelschuhzange;Quetschzange
-den Kopf hängen lassen (Redensart, fig.);mutlos (sein);leiden;resigniert (sein);(wie) ein Häufchen Elend (ugs.);trauern;betrauern;durch nichts aufzuheitern sein;den Kopf sinken lassen;traurig (sein);Trübsal blasen;deprimiert (sein);enttäuscht (sein)
-Vermögensverwaltung;Anlagenverwaltung;Anlagenwertführung
-Stufen...;Schritt...
-Gegend;Viertel
-Drumherum (ugs.);Verpackung (Hauptform);Hülle;Umhüllung
-im Innern (geh.);drin (ugs., regional);innerhalb;innen;innerlich
-auf ein Minimum senken;minimieren
-gesteigerte Schmerzempfindlichkeit;Hyperalgesie (fachspr.)
-Ausfuhrgenehmigung;Exportgenehmigung
-da sein (ugs.);zugegen sein;dabei sein;(sich) sehen lassen (ugs.);beiwohnen (geh.);teilnehmen;beehren (geh.);(sich) blicken lassen (ugs.);unter den Teilnehmenden sein
-Jawort (ugs.);Vermählung;Hochzeit;Verehelichung (Amtsdeutsch);Verheiratung;Verpartnerung (Amtsdeutsch);Heirat (Hauptform);Trauungszeremonie;Trauzeremonie;eheliche Verbindung;Ja-Wort (ugs.);Trauung;Eheschließung
-Ätiologie (fachspr.);Aitiologie (veraltet);Lehre von den Ursachen der Krankheit
-Power (ugs., engl.);Beherrschung;Herrschaft;Machtausübung;Machtgefüge;Gewalt;Macht;Machtapparat;Stärke
-Gehbahn (fachspr.);Fußweg;Trottoir (franz.);Gehsteig;Gehweg;Bürgersteig
-diesbezwecks (geh., altertümelnd, scherzhaft);zu diesem Zweck;dafür;hierfür;dazu;zu diesem Behufe (geh., altertümelnd, scherzhaft)
-nicht verfassungsgemäß;nicht verfassungskonform;verfassungswidrig;grundgesetzwidrig (in Deutschland)
-auffordern;einladen;bitten;anhalten
-eine Telefonverbindung bekommen;durchkommen
-Lümmel (ugs.);Prengel (ugs., ruhrdt.);Pillemännchen (ugs., rheinisch, verniedlichend);Pillermann (ugs.);(jemandes) bestes Stück (verhüllend);männliches Glied;Bolzen (derb);Zauberstab (ugs.);Schniedel (ugs.);Zipfel (derb);Rohr (ugs.);Glied;Dödel (ugs.);Schwert (ugs.);Pimmel (derb);Pullermann (derb);Rute (derb);Kindermacher (ugs.);Pillemann (ugs., rheinisch);Penis (Hauptform);Pimmelmann (derb);Piepmatz (ugs.);Zumpferl (ugs., österr.);Schwanz (derb);Phallus (fachspr.);Lörres (ugs., rheinisch);gutes Stück (verhüllend);Prachtexemplar;Schniedelwutz (ugs., verniedlichend);Piephahn (ugs.);Stößel (ugs.);Lurch (ugs.);Riemen (vulg.);Schaft (fig.);Schwengel (ugs.)
-Auffassung vom Leben;Überzeugung;Mentalität;(jemandes) Philosophie;Werte;Grundeinstellung;Gesinnung;Lebenseinstellung;Geisteshaltung;Ethos (geh.);Selbstverständnis;(innere) Haltung;Einstellung (zu)
-(die) Farbe verlieren;erblassen;erbleichen;verblassen;bleich werden;blass werden
-Gerichtsprozess;Verfahren;Prozess;gerichtliche Auseinandersetzung;Gerichtsverfahren (Hauptform)
-Mauer;Wand;Wall
-Spannweite (ugs.);Skopus (fachspr., Sprachwissenschaft);Aktionsradius;Einwirkungsbereich;Wirkungskreis;Reichweite;Einflussbereich;Wirkungsbereich
-(etwas) zurückführen auf;(etwas) schieben auf;(etwas) herleiten von
-(jemandem) den Vorzug geben;bevorzugen;favorisieren;besser behandeln;mit zweierlei Maß messen;privilegieren;bevorteilen;mit Vorrechten ausstatten;mit Privilegien ausstatten;bevorrechtigen;besserstellen;(jemanden jemandem) vorziehen;begünstigen;hervorheben
-schreiten;lange Schritte machen;große Schritte machen
-unangeschlossen;nicht online;getrennt;offline;nicht angeschlossen;rechnerunabhängig;nicht am Netz
-aufquellen;aufweichen
-lagern (auf, über);setzen;legen
-Umkehrung;Komplement;Gegenbegriff;Oppositionswort (geh.);Gegentum (ugs., scherzhaft);Gegenteil;Gegenwort;Gegensatz;Antonym;Gegensatzwort
-Bauwirtschaft;Baugewerbe
-Entzündung des Knochenmarks der Wirbel;Spondylitis (fachspr.)
-widerspenstig;rechthaberisch;starrsinnig;kompromissunfähig;renitent;bockig;dickköpfig (ugs.);unverbesserlich;uneinsichtig;beratungsresistent (ugs.);sturköpfig (ugs.);störrisch;widerborstig;nickelig (ugs.);stur wie ein Panzer (ugs.);hartnäckig;(jemandem) ist nicht zu helfen (ugs.);eigensinnig;starrköpfig;unbeugsam;unbelehrbar;halsstarrig;unnachgiebig;stur (Hauptform)
-schmelzen wie Schnee an der Sonne (fig.);dahinschwinden (geh.);dahinschmelzen (geh., fig.);schwinden;weniger werden (ugs.);zergehen;dahingehen;vergehen;schmelzen (fig.);zerschmelzen (fig.)
-echt;in Wirklichkeit;wirklich;tatsächlich;konkret;in natura (geh., lat.);eigentlich;real
-Kaufkraftabschöpfung;Kaufkraftabsorption
-Vorhandensein;(das) Bestehen;Existenz;Vorliegen (Sachverhalt, Tatbestand; Dokument)
-anschwemmen;schlämmen
-Datenintegrität;Datensicherheit
-buschig;waldig
-Brechungsvermögen;Brechbarkeit
-flaumig;unscharf;wuschelig (ugs.);verschwommen;fuzzy;verwaschen
-Flaschenkürbis;Kalebasse
-Einsatz;Auftritt (Musik, Theater);Performance (engl.);Gig (Jargon, Musik);Spieleinsatz
-Best.-Nr. (Abkürzung);Bestellnummer
-überstrapazieren;überanstrengen;überbeanspruchen;mit Arbeit überlasten
-Fase (fachspr.);Knie;Winkel
-auf Anfrage;auf Bitte;auf Wunsch
-Parteikollege;Parteiangehöriger;Genosse;Parteigenosse;Parteifreund;Parteimitglied (Hauptform)
-Knospen bilden;Knospen treiben;knospen (fachspr., Jargon)
-parodistisch;possenhaft;burlesk
-draufgängerischer Abenteurer;toller Hecht (ugs., sprichwörtlich);Waghals;Teufelskerl (ugs.);wilder Hund (ugs., bayr.);Haudegen;Heißsporn;Draufgänger;Hitzkopf;Zornigel (ugs.);Wagehals (veraltend)
-Substitution;Ersatz
-Unterbezahlung;ungenügende Bezahlung
-wach (werden);aufleben;munter werden;(jemandes) Lebensgeister erwachen;erwachen
-kein Funke (ugs.);Vakuum;Nichts;nicht das mindeste;Leere;gähnende Leere (ugs.);nicht das Mindeste;keine Spur (ugs.);nicht das geringste bisschen;Lücke
-Parallelität;Parallelismus;Nebeneinander
-Aussetzen;Preisgabe
-degenerativ;vergehend
-Randwerbung;unterstützende Werbung
-Volkswirtschaftler;Ökonom;Wirtschaftswissenschaftler;Wirtschafter
-westeuropäische Zeit;WEZ
-(sich) hinter etwas stellen;stehen für;(sich für etwas) aussprechen;eintreten für;soutenieren (geh., fig., franz., lat., veraltet);einstehen (für);verfechten;vertreten;verteidigen;(sich) einsetzen (für)
-Übersprechen;Nebensprechen
-Kammstück;Lendenstück (Fleisch)
-gekrümmte Linie;Bogen;Kurve
-OS (fachspr., Abkürzung, engl.);operating system (engl.);Betriebssystem
-rückwärts springen;rückverzweigen
-narzisstisch;selbstsüchtig;jetzt komm (erst mal) ich (Spruch);eigensüchtig;unsozial;ichbefangen;egozentrisch;sieht nur sich (selbst) (ugs.);egoistisch (Hauptform);selbstbezogen;ichsüchtig;egoman;von sich selbst eingenommen;denkt nur an sich (selbst);egomanisch;eigennützig;ichbezogen;subjektivistisch (geh.);selbstverliebt;Unterm Strich komm ich. (Slogan)
-wachsen lassen;anbauen
-sieden;brodeln;aufbrühen;kochen;brauen;wallen
-Depotbank;verwahrende Bank
-Restitution;Refundierung (fachspr., österr.);Rückerstattung;Rückzahlung;Rückgewähr;Rückvergütung;Zurückzahlung;Erstattung
-nicht amtlich;nicht autorisiert;nicht für die (Augen / Ohren der) Öffentlichkeit bestimmt;unter der Hand (fig.);hinter vorgehaltener Hand (fig.);nicht öffentlich;inoffiziell;hinter verschlossenen Türen (fig.)
-mit Tuberkeln behaftet;tuberkulös
-innere Kraft;Dynamik;Stärke;Energie
-(jemanden) zurückversetzen (Schule);(jemanden) die Klasse wiederholen lassen
-Fremdgehen;Liebesaffäre (Hauptform);Verhältnis;Liebesverhältnis;Techtelmechtel (ugs.);Affäre;Seitensprung;amouröses Abenteuer;Frauengeschichten (nur Plur.) (ugs.);Liaison;Liebelei;Buhlerei (veraltet);Liebschaft;Krösken (ugs., ruhrdt., veraltend);Gspusi (österr.);Nebenbeziehung
-Verkaufslokal;Verkaufslager (fachspr.);Verkaufsraum
-Hämorrhagie (fachspr.);Blutung
-Seilbahn;Kabelbahn;Drahtbahn
-phrasenhaft;rhetorisch
-Parade...;Demonstrations...;Vorzeige...
-Insomnie (fachspr.);Agrypnie (fachspr.);Hyposomnie (fachspr.);Schlaflosigkeit
-Maserung;Textur
-verkürzt;teilweise;fragmentarisch;unvollendet;unvollkommen;oberflächlich;bruchstückhaft;inkomplett;holzschnittartig;lückig (selten);skizzenhaft;unvollständig;lückenhaft
-dreistufig;Dreistufen...
-Haarstrang;Strähne;Haarsträhne
-Verzerrung;Deformierung;Deformation;Entstellung
-umleiten;umadressieren
-Zwölffingerdarm;Duodenum (fachspr.)
-Kryptologie;Kodierungstechnik;Lehre von der Geheimverschlüsselung
-(sich) zersetzen;auseinander bröckeln;zerfallen;verfallen;heruntergekommen;rissig werden;renovierungsbedürftig;aus den Fugen geraten (ugs.)
-konisch (Werkstück);verjüngend
-reißender Strom;Sturzflut
-(etwas) garantieren;(für jemanden) die Hand ins Feuer legen (ugs., fig.);(für jemanden) einstehen;(eine) Gewähr geben (für);(etwas) verbürgen (geh.);(eine) Garantie geben für;(sich) verbürgen für (geh.);bürgen (für);(für jemanden) geradestehen
-durchziehen (Karte);einlesen
-zurückschrecken;zurückschnellen;zurückweichen
-Vorzeigebeispiel;Exempel;Musterfall;(der / die / das) ... selbst (ugs.);Beispiel (Hauptform);Ausgeburt (einer Sache / an etwas) (geh., abwertend);Inkarnation;...bolzen (ugs., salopp);sehr gutes Beispiel (für);Muster (an);Paradebeispiel;Inbegriff;Ausbund (an / von) (geh.);Musterbeispiel
-anmachen;belästigen;anpöbeln
-Fülle;Reichtum;Wohlhabenheit;Reichhaltigkeit
-Kamerad;Kampfgenosse;Waffenbruder
-Entwurf;Plan;Design;Konzept;Konzeption
-typischerweise;typisch
-Mitnehmer;Nocke
-Toast;Tischrede;Trinkspruch (Hauptform)
-Karton;dickes Papier;Pappe
-(sich) beeilen (Hauptform);(sich) sputen (ugs.);hinnemachen (ugs.);voranmachen (ugs., ruhrdt.);(sich) abjagen (veraltet);eilen;(sich) abhasten (veraltet);(sich) überschlagen (ugs.);reinhauen (ugs., salopp);(die) Hufe schwingen (ugs., fig.);schnell machen (ugs.);(sich) ranhalten (ugs.);Dampf machen (ugs., fig.);(die) Beine in die Hand nehmen (ugs., fig.);(sich) tummeln (österr.);fix machen (ugs.);(sich) abhetzen (ugs.)
-Datum;Zeitangabe;Zeitpunkt
-rebellisch;abtrünnig
-Ekelgefühl(e);Sich-Abwenden;Ekel (Hauptform);(körperliche) Abneigung;Aversion;Widerwille;Abscheu;(körperliche) Ablehnung;(jemandem ein) Gräuel;Degout (geh., franz.)
-wenn das nicht möglich ist;alternativ;anderenfalls;anderweitig;sonst;andernfalls;widrigenfalls;ansonsten
-Kundendienst;Außendienst
-Retraktion (fachspr.);Schrumpfen eines Organs oder Gewebes
-anpassbar;anpassungsfähig;mutationsfreudig (fachspr., biologisch);wandlungsfähig;polytrop (fachspr., griechisch);flexibel;adaptiv
-Epigastralgie (fachspr.);Schmerzen im mittleren Oberbauch
-ulkig;grobhumorig (geh.);spaßig;äußerst komisch;amüsant;komisch;göttlich (fig.);belustigend;lustig;scherzhaft;urkomisch (ugs.);witzig;humorig
-erleiden;passieren;mitmachen (ugs.);miterleben;hinnehmen;einstecken;(jemandem) zustoßen;durchleben;durchlaufen;durchhalten;ertragen;erleben;ausstehen;durchmachen;erfahren;in Kauf nehmen;einen Streifen mitmachen (ugs.);am eigenen Leib erfahren;überstehen
-Reklamerummel;Ballyhoo (fachspr., Jargon, engl.);Masseneuphorie;Massenhysterie;Hysterie (fig.);(künstliche) Aufregung;Medienrummel (um jemand oder eine Sache);Medienhype;der heiße Scheiß (ugs.);Hype (engl.);(inszenierte) Begeisterung
-skullen (fachspr.);rudern;pullen (ugs.);paddeln
-Brenneröffnung;Brennerloch
-entfernteste;am weitesten entfernt;am weitesten;weitest...
-kalt werden;erkalten;(sich) abkühlen
-Internationales Olympisches Komitee;International Olympic Commitee;IOC;IOK
-Frauenkloster;Abtei;Nonnenkloster
-Wappenherold;Herold
-Gelassenheit;Seelenruhe;stoische Ruhe;Gleichmut;Ataraxie (geh.);innere Ruhe;unerschütterlicher Gleichmut;Unerschütterlichkeit;Gemütsruhe
-mit etwas spielend fertig werden;etwas spielend schaffen
-unfruchtbar;ertragsarm
-Kegelspitze;Spitze;Scheitelpunkt
-optieren (für);auswählen;erwählen;wählen;kiesen (Partizip 2 = gekoren) (geh., veraltet);(sich jemanden) auskucken (ugs., norddeutsch);(sich jemanden) ausgucken (ugs.);erkiesen (Partizip 2 = erkoren) (geh., veraltet);aussuchen;küren;auserwählen (geh.)
-Schlag;Schicksalsschlag
-Myokarditis (fachspr.);Herzmuskelentzündung;Entzündung des Herzmuskels
-kapriziös;launisch;launenhaft;wechselhaft
-Sicherheit;Bürgschaft
-heftig pochen;hämmern
-paretisch (fachspr.);geschwächt;teilweise gelähmt
-kennen;überblicken;über Kenntnisse verfügen;nachvollziehen;verstehen;(etwas) drauf haben (ugs.);wissen
-Tor;Einlass (geh.);Portal;Pforte;Entree (geh.);Eingang (Hauptform)
-Theismus;Religion;Gottesglauben
-Linotype;Zeilensetzmaschine
-in Saus und Braus (ugs.);prachtvoll;prächtig;bombastisch;verschwenderisch;aus dem Vollen;üppig;prahlerisch;auf großem Fuß (ugs.);opulent
-Zusatzprogramm;Erweiterung;Plug-in (engl.);Plugin (ugs., engl.);Extension (engl.);Software-Erweiterung;Add-on (engl.);Programmerweiterung;Addon (ugs., engl., salopp);Programmmodul;Zusatzmodul
-(das) Wesentliche;Grundidee;wesentlicher Inhalt;Kerngehalt;Kernaussage;zentrale Aussage;wichtigste Aussage;Kerninhalt;Hauptgedanke;Grundaussage
-Kloake;Latrine;Odelgrube (Odlgruam) (ugs., bayr.);Jauchegrube;Sudelgrube (ugs., sächsisch);Aalskuhle (ugs., ruhrdt., veraltet);Puddelgrube (ugs., regional);Senkgrube;Jauchengrube;Sickergrube (veraltend)
-etwas miteinander in Verbindung bringen;etwas verbinden;etwas kombinieren;etwas mischen;verdongeln (ugs.)
-postoperativ (fachspr.);nach der Operation
-Holder;deutscher Flieder;Holunder
-Verschiedenheit;Wesensfremdheit;Wesensverschiedenheit;Fremdartigkeit;fremdes Wesen;Andersheit (geh.);Andersartigkeit;Fremdheit
-abheftbar;anfügbar;beifügbar;beilegbar;zuschreibbar
-Abdrift;Abtrift
-Unterbrechung;Unterbruch (schweiz.);Unterlass;Auszeit;Stopp;Tätigkeitsunterbrechung;Pause;Time-out (engl.);Karenz
-Reiz;Sinnesreiz;Aufhänger;Motivation;Inzentiv (fachspr., bildungssprachlich, selten);Motivierung;Anregung;Antrieb;Ansporn;Anreiz
-Anpassbarkeit;Anpassungsmöglichkeit
-Einführungspreis;Vorzugspreis;Werbepreis;Angebotspreis
-Lizenz;Verkaufskonzession;Franchise
-schwarzes Gold (ugs., fig.);Mineralöl;Petroleum;Dinosaft (ugs.);Öl;Erdöl;Rohöl
-beschränken;minimieren;(etwas) in Grenzen halten;beschränken (auf);(eine) Grenze ziehen;begrenzen;einhegen;kontingentieren;limitieren;(eine) Grenze setzen
-Klub;Club;Verein
-Aufbewahrungszeitraum;Sperrfrist
-auskugeln (ugs.);ausrenken;verrenken
-Stoß;Schlag;Hieb
-tot...;auslöschen;(jemandem) das Lebenslicht auslöschen (fig., variabel);entleiben (geh.);umlegen (ugs.);zum Schweigen bringen (fig.);killen;ermorden;ums Leben bringen;zur Strecke bringen (fig.);meucheln;ins Gras beißen lassen (ugs., fig.);töten (absichtlich) (Hauptform);ausknipsen (ugs., fig., salopp);kaltmachen (ugs.);um die Ecke bringen (ugs., fig.);abmurksen (ugs.);(jemandem) den Garaus machen (ugs.);(jemandem) (den) Lebensfaden abschneiden (fig.);abservieren (ugs., fig., salopp);totmachen (ugs.);ins Nirwana befördern (ugs.);ins Jenseits befördern (fig.);in die ewigen Jagdgründe schicken (ugs., fig.);vom Leben zum Tode befördern (geh.);über die Klinge springen lassen (ugs., fig.);umbringen
-Rüstung;Bewaffnung;Mobilmachung;Aufrüstung
-unabhängig von;ohne (dadurch ...) zu beeinträchtigen;(...) bleiben unberührt (fachspr., juristisch);unbeschadet (einer Sache) (fachspr., juristisch);ohne dadurch auf (...) zu verzichten;(...) bleibt unberührt (fachspr., juristisch);ohne (dadurch ...) zu schmälern
-formieren;aufmarschieren lassen;stationieren;aufstellen
-Ausgehverbot;Ausgangssperre;Ausgangsverbot
-spazieren führen (Hund);mit dem Hund raus sein (ugs.);mit dem Hund rausgehen (ugs.);äußerln (ugs., österr.);den Hund ausführen;(mit dem Hund) Gassi gehen
-Schocktherapie;Schockbehandlung
-Rückspiel;Revanchepartie;Revanche
-fachgerecht;professionell;fachgemäß;vom Fach;Gelernt ist gelernt. (sprichwörtlich);fachmännisch
-Kanalisation;Abwasserleitung
-Mitstudent (männl.);Kommilitone (männl.);Studienfreund (männl.);Studienfreundin (weibl.);Studiengenossin (weibl.);Studienkollege (männl.);Kommilitonin (weibl.);Studienkollegin (weibl.);Studiengenosse (männl.);Mitstudentin (weibl.)
-Gruppe;Zusammenstellung;Serie;Galerie (oft scherzh.);Reihe;Satz;Palette;Set;Garnitur;...riege
-Gewandtheit;Zungenfertigkeit
-Tiara;Papstkrone
-Strahlenforschung;Radiologie;Strahlenkunde
-in der Pampa (ugs.);öde;in der Walachei (ugs., fig., sprichwörtlich);jwd (ugs., berlinerisch);einsam und verlassen;hinterm Wald (ugs.);abgelegen;(da) sagen sich Fuchs und Hase gute Nacht (ugs., sprichwörtlich);einsam;jottwedee (ugs., berlinerisch);außerhalb;weit ab vom Schuss (ugs.);einschichtig (süddt., österr.);weit vom Schuss (ugs.);menschenleer;entlegen (Hauptform);(eine) einsame Gegend (ugs.);am Arsch der Welt (derb);(da) ist der Hund verfroren (ugs.);abseitig;ab vom Schuss (ugs.);abgeschieden;fernab der Zivilisation (geh.)
-Nacheiferung;Strebsamkeit;Strebertum (ugs., abwertend);Ehrgeiz;Bemühung;Wetteifer;Zielstrebigkeit;Ambition (meist Plur.: Ambitionen)
-offene Handelsgesellschaft;OHG (Abkürzung)
-Redestil;Diktion;Tonfall;Duktus (geh.);Ausdrucksform;Formulierung;Sprechhaltung;Schreibe (ugs., salopp);Redeweise;Ausdrucksweise (Hauptform);...sprech (ugs., Jargon);Ton;Tonart (fig.);Wording (fachspr., Jargon, Marketing);Schreibweise;Zungenschlag;Stil;Wortwahl;Sprechstil;...ton;Ausdruck;Schreibstil;Sprechweise;Tonlage
-Wicklung;Wickelung;Windung
-Distinktion (geh.);Trennung;Unterscheidung;Differentiation (fachspr.);Differenzierung;Abgrenzung;Diskriminierung (fachspr.)
-Flussbild;Fließschema;Fließbild
-handelnd;aktiv;agierend;am Ball (ugs., fig.);tätig
-(sich) federn (Vogel);(sich) mausern
-Ölzeug;wasserdichte Kleidung;Regenhaut
-komfortabel;behaglich;bequem
-Kiepe (Weinlese);Bütte;Hotte;Butte (regional)
-verstellen;umstellen;umlegen;verschieben
-Neuerwerbungsliste;Neuerwerbungsverzeichnis
-Weichbild;Skyline (engl.);Silhouette (einer Stadt)
-boxen;schlagen;prügeln;dreschen (ugs.);kloppen (ugs.);hauen
-darunter;unten;tief gelegen;in der Tiefe;herunten;am Boden;unterhalb
-reizvoll;liebreizend;bezaubernd;gewinnend;faszinierend;aufregend;charmant;apart;anziehend;entzückend
-Programmflussdiagramm;Programmablaufplan;Programmstrukturplan
-Kooptierung;Kooption;Ergänzungswahl;Ersatzwahl;Kooptation
-Schrotter (ugs.);Schrotthändler (ugs.);Altwarenhändler
-Echo;Erwiderung;Widerhall
-CO2 (Abkürzung);Kohlendioxid;CO₂ (Abkürzung);Kohlenstoffdioxid
-Abfallprodukt;Abfallstoff
-strafen;(jemanden) abwatschen (ugs.);züchtigen;bestrafen (für);disziplinieren
-Sesselbahn;Sessellift
-unverarbeitet;unbehandelt;im Rohzustand;krude;roh;krud;unbearbeitet
-Somnambulie (lat., selten);Schlafwandeln;Noktambulismus (fachspr., lat.);Nachtwandeln;Mondsucht (historisch);Somnambulismus (fachspr., lat.);Lunatismus (historisch, lat.)
-zuscheißen (mit) (derb);bombardieren (ugs.);eindecken (ugs.);überhäufen (mit Geschenken, Fragen);zumüllen (ugs., negativ);überschütten;reich bedenken (geh.)
-Anbau;Bestellung;Ackerbau
-Lagerumschlag;Lagerbestandswechsel;Lagerumsatz
-Außerirdischer;Alien;Wesen von einem anderen Stern
-Bergrutsch;Erdrutsch
-Rechenleistung;Rechenkapazität
-physikochemisch;Physik und Chemie betreffend
-Bastelarbeiten;Basteln;Bastelei
-Radiator;Heizung;Heizkörper
-Fischerboot;Huker
-Sperrhaken;Bohrknarre;Sperrklinke
-abgrasen (ugs.);durch etwas gehen (ugs.);(von A bis Z o.ä.) durchgehen;durchsuchen;durchstöbern
-unzugänglich;unantastbar;unnahbar;unerreichbar
-zervikale Dystonie (fachspr.);Schiefhals (ugs.);Torticollis spasmodicus (fachspr.)
-täfeln;paneelieren
-aushebeln;hebeln
-Palmenzweig;Palmenwedel
-Substrat;Trägermaterial
-Ankuscheln;Schmusen;Streicheln;Liebkosen;Befummeln (derb);Zärtlichkeit
-höchste Staatsgewalt;Oberherrschaft;Staatshoheit
-Antikoagulantie (fachspr., veraltet);Antikoagulans (fachspr.);Blutverdünnungsmittel;Antithrombotikum (fachspr.);Blutverdünner (ugs.);gerinnungshemmende Substanz;Gerinnungshemmer;Blutgerinnungshemmer
-Styrol;Styren;Phenylethen;Vinylbenzol
-nicht tauschbar;nicht auswechselbar;unauswechselbar
-anmeckern (ugs.);ausmeckern;anmotzen (ugs.)
-Messeinheit;Messinstrument;Messgerät;...messer;Messapparat
-(sich) verbreitern;(sich) ausweiten;(sich) diversifizieren
-beeindruckend;observabel (veraltet);erwähnenswert;nennenswert;anmerkenswert;(es) in sich haben (ugs.);bemerkenswert;beachtenswert
-resident;nicht auslagerbar
-unkristallinisch;formlos;gestaltlos;amorph
-Wapitihirsch;Wapiti
-nicht reparierbar;inoperabel (fachspr.);nicht wiederherstellbar;nicht wieder gutzumachen;irreparabel;unersetzlich;nicht zu reparieren
-Kopie;Ausfertigung;Durchschrift;Duplikat;Abschrift;Durchschlag;Doppel
-(sich) an jemanden wenden (um, wegen);bitten;jemanden angehen (um)
-(sich) wundern;(sich) fragen;gern wissen wollen;hinterfragen
-Fachgruppe;Berufsgruppe
-Behauptung;These;Ansicht;Unterstellung
-schmecken;probieren;kosten;verkosten;testen;degustieren (fachspr.);versuchen;abschmecken
-Bronn (poetisch);Quelle (fig., Hauptform);Brunnen (geh.);Born (poetisch);Urquell;Quell (geh.);Ursprung
-Tröte (ugs.);Hupe;Horn;Sirene
-Schafshaut;Amnion (fachspr.)
-eingebettet;eingebaut;integriert
-adäquat;fair;anständig;im Rahmen;ordentlich;nach Maß;entsprechend;...gerecht;passend;gebührend;stimmig;angemessen
-Informationstafel;Hinweisschild;Infoschild;Wegweiser (durch ein Gebäude);Hinweistafel
-Anthelminthikum (fachspr.);Vermifugum (fachspr.);Wurmmittel
-Erzählung;Novelle;Narration (fachspr.);Geschichte;Story (ugs.)
-Schubspannung;Scherspannung
-Fehlereingrenzung;Fehleranalyse
-Plinse (regional);Eierpfannkuchen (ugs., regional);Pangech (ugs., regional);Palatschinken (Plural, österr.);Pfannkuchen;Crêpe (franz.);Palatschinke (österr.);Pfann(en)kuchen (ugs.);Flädle (regional);Pannekuche (ugs., regional);Plinz (ugs., regional);Eierkuchen;Omelettes (regional);Plins (regional);Eierpuffer (regional);Plinsen (regional)
-Rezidiv (fachspr.);Wiedererkrankung;Rückfall
-erfordern;nötig haben (ugs.);brauchen (ugs.)
-Abbildung;Illustration
-Schwarzbrauenalbatros;Mollymauk
-erinnern an;in Erinnerung bringen;in Erinnerung rufen
-Erweiterung verengter Bronchien;Bronchodilatation (fachspr.)
-Halbpension;HP
-(etwas) überwinden;(etwas) bezwingen;(Widerstand) brechen
-Kumulierung;Anhäufung;Kumulation
-Balken (ugs., westfälisch);Dachboden;Speicher (ugs.);Söller (ugs., niederrheinisch, veraltet);Unterdach (ugs., südtirolerisch, walliserisch);Boden (ugs., niederrheinisch, norddeutsch, ostdeutsch);Bühne (ugs., badisch, schwäbisch);Estrich (ugs., schweiz.);Dachstube;Dachkammer
-(sich) nicht mehr so viel leisten können;kürzertreten (ugs., fig.);(seine) Ansprüche herunterschrauben (ugs.);(den) Gürtel enger schnallen (fig.);(sich) kleiner setzen (ugs.);(die) Ansprüche zurückschrauben (ugs.);(sich) einschränken (Hauptform);Abstriche machen
-zertrennen;zerlegen
-Agalaktie (fachspr.);Fehlen der Milchproduktion in der Stillzeit
-Posse (Theater);Klamotte;Schwank;Burleske
-Nachbelastung;Nachgebühr
-köstlich;appetitlich;schmackhaft;ergötzlich;deliziös;delikat;Geschmacksexplosion (fig., mediensprachlich, übertreibend);kulinarischer (Hoch-)Genuss;schmeckt nach mehr (ugs.);lukullischer (Hoch-)Genuss;lecker;mundend;delektabel;wohlschmeckend;(da) könnte ich mich reinlegen (ugs.);gluschtig (ugs., schweiz.)
-prozessführende Partei;Prozessführer
-Verbrauch;Abnutzung;Verschleiß
-Weinkenner;Weinliebhaber
-geistliches Lied;Kirchenlied;Loblied
-Toleranz (Münzwesen);Remedium
-Boulevardzeitung;Käseblatt (ugs.);Boulevardblatt;Revolverblatt (ugs.);Schundblatt (ugs.)
-Geräuschpegel;Tonstärke;Lautstärke
-Farbenmesser;Kolorimeter
-abklären;abchecken (ugs.);untersuchen;nachprüfen;prüfen;kontrollieren
-Informationsdienst;Auskunftsdienst;Auskunftei
-froh;zufrieden;glücklich;happy (ugs., engl.)
-Flussmittel (Löten);Schmelzmittel
-emergieren (geh.);sichtbar werden;ans Licht kommen (fig.);(sich) zeigen;zutage treten;zu Tage treten;zum Vorschein kommen;an den Tag kommen;erscheinen;ans Tageslicht kommen (fig.)
-posen;(sich) in Positur werfen;(sich) in Positur stellen;posieren;(sich) in Positur setzen;(sich) in Positur bringen;(eine) Pose einnehmen;Haltung annehmen;(eine bestimmte) Körperhaltung einnehmen (variabel);(sich) in Pose stellen
-Zeh;Zehe
-loswerden (an) (ugs.);(jemandem etwas) zuschieben;andrehen;abgeben (an);überwälzen (auf);abschieben (auf);abwälzen (auf)
-der Zufall wollte (dass) (Floskel);wie das Leben so spielt (Redensart);es traf sich (dass) (geh., literarisch);durch Zufall;zufälligerweise;zufällig;wie es der Zufall wollte (floskelhaft)
-Sammelschiene;Stromschiene
-Eigenwilligkeit;Eigensinn
-Entfroster;Enteisungsanlage
-lethargisch;apathisch;phlegmatisch;schwerfällig;träge;passiv;teilnahmslos;indolent (geh.)
-rollstuhltauglich;behindertengerecht;barrierefrei;rollstuhlgängig;rollstuhlgerecht
-Bundestagsabgeordneter;MdB (Abkürzung);Mitglied des Bundestages
-Einsatzbereitschaft;Opferwille
-Nichtübereinstimmung;Dissens (geh.);Zwietracht;Hader;Missstimmung (geh.);Uneinigkeit
-heftige Nasenschleimabsonderung;Rhinorrhoe (fachspr.)
-unerkennbar;unsichtbar;nicht wahrnehmbar;nicht sichtbar;nicht erkennbar
-Nierenerkrankung;Nephropathie (fachspr.)
-rudimentär;nicht ausgebildet;im Ansatz;inkomplett;verkümmert;unvollkommen;unvollständig;defektiv
-fürwahr;tatsächlich;in der Tat;wahrhaftig;klar
-Krumpfung (Textilien);Eingehen;Einlaufen
-Balanitis (fachspr.);Entzündung der Eichel
-welken;verblühen;verdorren
-dominierend;vorherrschend;dominant;maßgebend;führend;(das) Maß aller Dinge (sein) (Redensart);herrschend;tonangebend;bestimmend;prädominant (geh., bildungssprachlich, lat.);beherrschend;maßgeblich
-Handel (für);Ladengeschäft;Kauf(manns)laden (veraltend);Handlung;Detailgeschäft (schweiz.);Shop (engl.);Einzelhandelsgeschäft;Laden;Geschäft;Store (engl.)
-Europäische Weltraumorganisation;Europäische Weltraumbehörde;European Space Agency (engl.);ESA (Abkürzung, engl.)
-feurig;rasant;schwungvoll
-Einweihungsfeier;Eröffnungsveranstaltung;Einweihung;feierliche Eröffnung
-scharf;scharf gewürzt;rezent (schweiz.)
-Kratzfüße machen (ugs.);(jemandem) die Stiefel lecken (ugs., fig.);katzbuckeln (ugs.);kriechen (vor);speichellecken (derb);liebedienern;kratzfüßeln;(jemandem) in den Arsch kriechen (derb);arschkriechen (vulg.);antichambrieren (geh., veraltet);(sich) einschleimen (bei) (ugs.)
-Kachel;Bodenfliese;Bodenplatte
-ein Geschwür erzeugend;ulzerogen (fachspr.)
-Schlappe (ugs.);Erniedrigung;Demütigung;Schmach (veraltend)
-abklingen;nachlassen (Sturm, Erregung)
-Blutandrang;Kongestion (fachspr.)
-Anschlussleiste;Anschlusstafel;Steckschalttafel
-kleinster Teil;bisschen
-ungesteuert;triebhaft;ungebremst;unkontrolliert
-Gesamtkonzeption;Gesamtkonzept
-von der Route abkommen;in die falsche Richtung fahren;(sich) verfahren (Hauptform);(sich) verfranzen (ugs.);vom Weg abkommen;(die) Abzweigung verpassen;(sich) verirren;(die) Abfahrt verpassen
-in Gedanken verloren sein;gedankenversunken sein;geistesabwesend sein
-Ureter (fachspr.);Harnleiter
-Betrieb;Werkstatt (Hauptform)
-unwillkürlich;vegetativ (fachspr.);unbewusst;das autonome Nervensystem betreffend
-Verdrehung;Torsion;Verwindung
-rückwärts;nach hinten;zurück;retour;retro (lat.)
-Sehschaden;Sehbehinderung
-Exposition;Preisgegebensein;Ausgesetztsein
-Auftragssteuersprache;Kommandosprache
-Kranbaum;Ladebaum
-Trachom (fachspr.);Knetschauge (ugs., regional);Konjunktivitis (fachspr.);Bindehautentzündung;ägyptische Augenkrankheit
-Bibbeliskäs (alemannisch);Topfen (bayr., österr.);Quark;weißer Käs (nordbairisch);Weißkäse;Schichtkäse;Bibeliskäs (alemannisch);Bibeleskäs (alemannisch);Luggeleskäs (württembergisch);Bibbeleskäs (alemannisch)
-(die) Abendmahlzeit zu sich nehmen;zu Abend essen;dinieren (geh.);Abendbrot essen
-regieren;lenken;führen;steuern;manövrieren;(die) Weichen stellen (fig.);dirigieren (fig.);kontrollieren;leiten
-leasen;anmieten;pachten;mieten
-rehabilitieren;wiederherstellen
-o. Prof. (Abkürzung);Lehrstuhlinhaber;C4-Professor (ugs.);ordentlicher Professor;Ordinarius (mittellateinisch)
-ungeschrühte Ware (Keramik);rohe Ware
-Richtlinie;Leistungssoll;Maßstab;Regel;Norm;Standard;Vorgabe
-Aretalogie (fachspr., griechisch, literaturwissenschaftlich);Laudatio (geh., lat.);Eloge (geh., franz.);Lobpreisung;Lobeshymne (oft fig. und iron.);Aretologie (fachspr., griechisch, literaturwissenschaftlich);Weihrauch (oft iron.) (geh., fig.);Elogium (fachspr., lat.);Würdigung;Lobrede;Hymne (auf) (geh., fig.);Preisung;Lobschrift
-Analogon (fachspr.);Gegenpart (geh.);Pendant (geh., franz.);Entsprechung;Gegenstück;Korrelat (geh.);dazu passende Sache
-Technik;Ansatz;Prozedere;Vorgangsweise (österr.);Methode;Arbeitsweise;Art und Weise;Vorgehen;Verfahrensweise;Verfahren;Vorgehensweise;Herangehensweise;Methodik
-verschleppen;auf den letzten Drücker erledigen;aufschieben;prokrastinieren (fachspr.);(etwas) auf Eis legen (fig.);auf die lange Bank schieben (ugs., fig.);(sich) endlos Zeit lassen (mit);(etwas) (sehr) ruhig angehen lassen (ugs.);hinausschieben;verzögern;vor sich herschieben (ugs., fig., Hauptform);(es) nicht eilig haben (mit);verdrängen;Zeit verstreichen lassen;(zeitlich) nach hinten schieben;zurückhalten;verschieben;retardieren;hintanstellen (geh.);(etwas) liegen lassen (fig.)
-konstitutionell;anlagebedingt
-Smog;Industriedunst
-hinterlegen;reservieren;zurückhalten;(für jemanden) auf die Seite legen;beiseitelegen;(jemandem etwas) zurücklegen
-blutleer;taub;gefühllos;empfindungslos
-Einheitsführer;Kompaniechef;Kompanieführer
-Hypotonie (fachspr.);Niederdruck;niedriger Blutdruck;Hypotension (fachspr.)
-Rechnungswesen;Buchhaltung;Rechnungsführung
-hinterst;letzter;zuletzt
-Nachbildung;Imitat;Nachahmung;Imitation
-im Ganzen;vollkommen
-auflehnen;aufbäumen
-listig;schlau;gefinkelt (österr.)
-gerissen (oft abwertend);verschlagen (negativ);gewieft;(es) faustdick hinter den Ohren haben (fig.);mit allen Hunden gehetzt (fig., selten);durchtrieben (negativ);abgefeimt;ausgekocht;mit allen Wassern gewaschen (fig.);schlitzohrig;ausgebufft (auch abwertend) (ugs.);(dem) machst du nichts vor (ugs., variabel);(auch) kein Waisenknabe (sein) (ugs., fig.);abgezockt (ugs.);schlau;raffiniert;abgebrüht
-Projektor;Beamer (Scheinanglizismus);Datenprojektor;Videoprojektor
-Jaulen;Kläffen;Gekläffe;Gekläff
-Sockel;Postament (ital., veraltet);Grundmauer;Basis;Fundament;Postument (veraltet);Fuß
-verblassen;verwelken;verklingen
-beleuchten;anstrahlen;illuminieren;erleuchten (fachspr.);anleuchten (ugs.)
-Staffelung;Separation;gestaffelte Anordnung
-Silikagel;Kieselsäuregel;Kieselgel;Silicagel
-zuverlässig;betriebssicher;störungssicher;standfest (Maschine) (fachspr., Jargon);verlässlich;ausfallsicher
-abhorrieren (geh.);hassen;verabscheuen;detestieren (veraltet);abhorreszieren (geh.);degoutieren (geh.);verachten
-unscharfe Logik;Fuzzylogic;Fuzzylogik;Fuzzy Logik
-Brauchbarkeit;Tauglichkeit;Anwendbarkeit;Einsetzbarkeit;Eignung (Hauptform);Verwendbarkeit;Praktikabilität
-speichern;festhalten;aufzeichnen
-Automarder (ugs.);Autoknacker
-mittel- und osteuropäische Länder;MOEL
-aufhäufen;aufhäufeln;anhäufen;aufschichten;aufschütten;aufschaufeln;schichten
-Vorberge;Ausläufer;Ableger
-weitreichend;extensiv;breit gefächert;allumfassend;in die Breite gehend;voluminös;umfangreich;umfänglich;erweiternd (juristisch);weitschweifig;ausgedehnt;umfassend;geräumig
-Rentier;Ren
-dunstig;in Dunst gehüllt;voller Nebel;neblig;nebelig;diesig
-einführen (in bestimmte Kreise);(jemanden / Leute) zusammenbringen (mit);(Leute miteinander) in Verbindung bringen;(miteinander) bekanntmachen;(jemanden) vorstellen;in Kontakt bringen (mit);(einen/den) Kontakt vermitteln;(einen/den) Kontakt herstellen
-Livedo (fachspr.);Blaufärbung der Haut
-finanzschwach;verarmt;arm;sozial schwach;mittellos;dürftig;unvermögend;hilfebedürftig;notleidend;bedürftig;ärmlich;prekär;auf öffentliche Unterstützung angewiesen;ohne das Nötigste;(finanziell) nicht gut dastehen
-hinkritzeln;schnell hinschreiben;fix notieren
-Computerkriminalität;Computerbetrug
-(sich jemandem) anschließen;(sich mit jemandem) assoziieren
-Fraktur (fachspr.);Bruch;Bruchteil
-den Rücken beugen;(sich) vorbeugen;den Rücken krümmen;(sich) bücken
-Kaulbarsch;Döbel
-Menorrhagie (fachspr.);lange, heftige Menstruationsblutung
-unwiederbringlich;(für immer) verloren;unrettbar (dahin)
-axial;Achsen...
-begeistern;motivieren;bereichern;beflügeln;anregen;anspornen;befruchten;von der Muse geküsst werden;inspirieren
-drauf und dran (sein);im Begriff sein (etwas zu tun);ansetzen (zu);Miene machen (zu) (geh., veraltet);im Begriff stehen (etwas zu tun);kurz davor stehen (etwas zu tun);auf dem Sprung (sein) (ugs.);auf dem Sprung stehen (etwas zu tun);Anstalten treffen (zu);auf dem besten Weg sein (zu);Anstalten machen (zu);zu erkennen geben (dass man etwas zu tun gedenkt);kurz davor (sein etwas zu tun) (variabel);im (...) begriffen sein;(etwas) gerade (tun) wollen;(sich) anschicken zu (geh., veraltend)
-versicherungsmathematisch;aktuarisch;versicherungsstatistisch
-munter machen;elektrisieren (ugs.);wecken;aufwecken
-(wird) viel gekauft;beliebt;gut eingeführt;begehrt;populär;(wird) gern gekauft;gesucht;nachgefragt;in jemandes Gunst (stehen);(sich) großer Beliebtheit erfreuen (geh.);gefragt;auf großes Interesse stoßen
-Jetlag;Jet-Lag
-minder...;nieder...;unter...
-Vorhaben;Behuf (geh., veraltet);Zweck;Intention (bildungssprachlich);Plan;Absicht;Ansinnen (geh.)
-Außentemperatur;Umgebungstemperatur
-Nachkomme;Nachfahre;Spross;Abkomme (geh., veraltend);Nachwuchs;Abkömmling
-unnachsichtig;rigide;rigoros;strikt;(mit jemandem) ist nicht gut Kirschen essen (ugs.);katonisch (geh.);autoritär;Haare auf den Zähnen haben (ugs., fig.);streng;hart
-wolkenbruchartig;sintflutartig
-das Nierengefäßsystem betreffend;renovaskulär (fachspr.)
-Besiedler;Kolonialist
-Ausleger;vorspringender Träger;Hebelarm
-ständig wiederkehrend;periodisch wiederkehrend;regelmäßig wiederkehrend
-konvertierbar (fachspr.);invertierbar;abänderlich;reversibel;umtauschbar;tauschbar;umdrehbar;umwendbar;konvertibel;umkehrbar
-schmerzlich;stechend;brennend;quälend;marternd;beißend;peinigend;nagend;qualvoll;quälerisch;wehtuend;peinvoll;schmerzhaft;bohrend;schmerzvoll
-mieten (Schiff oder Flugzeug);chartern
-Buch mit festem Einband;Pappband;gebundene Ausgabe;Hardcover (engl.);Deckenband;Festeinband;gebundenes Buch
-dezentral;lokal;örtlich;regional
-Rankenfußkrebs;Rankenfüßer
-dramatisch;katastrophal;tragisch
-Eilzug;D-Zug;Expresszug;Durchgangszug;Schnellzug
-Zentrifuge;Trennschleuder;Schleudermaschine
-durchführen;ableisten;vollziehen;absolvieren
-archäologischer Beweis;archäologisches Zeugnis
-Iststand;Istzustand
-Herzlichkeit;Freundlichkeit;Gewogenheit;Liebenswürdigkeit;Warmherzigkeit
-Talboden;Talsohle;Talgrund;Sohle
-Keckheit;Dreistigkeit;Übermut
-knötchenförmig;fleckenförmig;makulopapulös (fachspr.)
-wehtun;weh tun (ugs.);traumatisieren;verletzen;Schmerzen zufügen;versehren;verwunden
-Unterricht erteilen;Unterricht geben
-Klasse;Grad;Qualität;Rang;Stufe
-Automatisierung;Automation
-Warnton;Gefahrenmeldung;Alarmsignal;Warnsignal;Alarmruf;Notruf;Alarm
-sofern;solange wie;vorausgesetzt, dass
-Hubmagnet;Elektromagnet;Spule
-absoluter Wert;absoluter Betrag;Absolutwert;Betrag
-Irrsinn;Wahnsinn;Tollheit
-Nebenerscheinung;Epiphänomen (geh.);Nebeneffekt;Nebensache;Begleiterscheinung
-fester Preis;Fixpreis;Festpreis
-Rechtsvertreter;Strafverteidiger;Rechtsverdreher (derb, abwertend);Anwalt;(jemandes) Verteidigung;Verteidiger;anwaltliche Vertretung;Rechtsanwalt (Hauptform);Advokat;Rechtsbeistand
-Hechtdorsch;Seehecht
-Reibung;Friktion
-hochhalten (fig.);bewerben;anpreisen;(die) Werbetrommel rühren;Publicity machen für;promoten;Rummel machen um (ugs.);werben;Werbung machen;propagieren;umwerben
-absperren;abriegeln (mit Posten)
-Rohertrag;Bruttoertrag
-Läsion;Blessur (ugs.);Trauma;Körperverletzung;Verwundung;Verletzung
-Startzeit;Anlaufzeit
-Bewertung;Begutachtung;Urteil;Einschätzung;Gutachten;Beurteilung;Abschätzung
-Rohr (landschaftlich);Ofen;Backrohr (landschaftlich);Backofen;Röhre (ugs.)
-Kiesel;Kieselstein
-Ungemach (geh., scherzhaft-ironisch);Verdrießlichkeiten (geh., selten);Ärgerlichkeiten (geh., seltener);Huddel (ugs., saarländisch);(die) Kacke ist am dampfen (derb, fig.);Misshelligkeiten (geh., sehr selten);Knatsch (ugs., regional);Trouble (ugs., Anglizismus);Scherereien (ugs.);Ärger;(der) Haussegen hängt schief (ugs., fig.);Stress (ugs.)
-von der Kirche gelenkte Staatsform;Theokratie;Gottesstaat
-noch mehr;noch etwas
-Vademekum;Vademecum;Ratgeber;Handbuch;Ratgeberbuch;Enchiridion (geh.)
-(sich) verringern;einschrumpfen;zusammenschrumpfen;kleiner werden;schrumpfen
-Angleichung;Assimilierung;Assimilation;Anpassung
-Luftkissen;Luftfeder
-Aufbereitung;Vorbereitung
-Aufschwemmung;Suspension
-drängeln;drücken;schieben;drängen;pferchen
-verdrahten;verkabeln;elektrische Leitung legen
-Klamotte;grotesker Gag;Klamauk;Situationskomik;platte Komik;Slapstick (engl.);Kintopp (im Film);Blödelei
-Schottenrock;Kilt
-Ziegenfell;Ziegenleder
-(sich) entladen;losbrechen;hervorschießen;hervorbrechen;(sich) entzünden (auch übertragen: Streit .. an);heraussprudeln;ausbrechen;herausbrechen;herausschießen;aufbranden (Jubel, Beifall) (geh.);sprießen;entbrennen (Streit);hervorkommen;(sich) lösen
-Präparator;Ausstopfer (von Tieren)
-Abhebung;Entnahme
-Andamanisches Meer;Andaman-See;Andamanensee
-UNRWA;Hilfswerk der Vereinten Nationen für Palästinaflüchtlinge im Nahen Osten
-steuern;schalten (technisch);(eine) Regelung treffen;regeln;reglementieren;regulieren
-Freilassung;Entlassung (aus der Haft)
-Geheimdienst;Verfassungsschutz (Deutschland);Secret Service (engl.);Schlapphüte (ugs.);Nachrichtendienst
-Scharnier;Gelenk;Scharniergelenk
-unmittelbar;ohne Zeitverzug;schnurstracks;mit sofortiger Wirkung (fachspr., Jargon, juristisch, kaufmännisch, politisch);prompt (ugs.);sogleich (Hauptform);spornstreichs (geh., veraltend);unverzüglich (Hauptform);postwendend;wie aus der Pistole geschossen (ugs.);ohne Verzögerung;sofort (Hauptform);umgehend;sofortig;ohne Wartezeit;ohne zeitliche Verzögerung;instantan (fachspr., auch figurativ, physikalisch);ohne Zeit zu verlieren
-Manometer;Druckmessgerät;Druckmesser;Druckanzeiger;Barometer
-informell;salopp;sportlich (Kleidung);lässig;casual (engl.);leger
-Hamham (ugs., Babysprache);Mahlzeit;Essen;Mahl;Speise;Gericht
-Flitterkram;Glitzer(kram) (ugs., abwertend);Tand;Schnörkel;Kinkerlitzchen;Chichi;Verzierungen
-übel;unwohl;hundeelend (ugs.);elend;mulmig (ugs.);hundsmiserabel (ugs.);kotzübel (derb);speiübel (ugs.)
-Hosenschritt;Schritt
-Unterjochung;Knechtschaft;Versklavung;Bevormundung;Knebelung;Unterdrückung;Unterwerfung
-pompös;wuchtig
-arg;ernstlich;schlimm (ugs.);bedenklich;fies (ugs., rheinisch);schwer;bös(e) (ugs.)
-Anfangsverdacht;Vermutung;Verdächtigung;Verdacht
-Krankenhaus...;nosokomial (fachspr.)
-Gesellschaft;Gruppe;Körperschaft
-kortikal (fachspr.);die Rinde eines Organs betreffend
-Melange;Mix;Gemisch;Allerlei;Mischung
-Wiedererrichtung;Wiederherstellung;Wiederaufbau;Wiederinstandsetzung;Rekonstruktion;Erneuerung;Sanierung
-Nietenhose;Blue Jeans;Jeanshose;Jean (österr.);Campinghose (veraltet);Levis (ugs., veraltet);Texashose (veraltet);Jeans (Hauptform)
-Ausgleicher;Entzerrer
-versüßen (ugs.);schmackhaft machen (ugs.);adoucieren (veraltet)
-Werbefachmann;Werbefachfrau
-Verlagshaus;Verlag
-Injektor;Düse;Einspritzdüse;Einspritzventil
-(etwas) auf Hochglanz polieren (ugs.);perfektionieren;vervollkommnen;(an etwas) feilen (fig.);(den) letzten Schliff geben (fig.)
-lockern;auflockern
-Stenotypist(in) (fachspr., veraltet);Maschinenschreiber(in);Tippse (ugs., abwertend);Schreibkraft (Hauptform)
-in Betrieb;aktiv;angeschaltet;an (ugs.);eingeschaltet
-Könner;Sachkundiger;Sachverständiger;Kenner;Meister;Routinier;Experte;(ein/e ...) von hohen Graden (geh.);Fässle (ugs., schwäbisch);Fachkraft;Fachmann;Profi;(einer) vom Fach (sein);Sachkenner;Kenner der Materie
-orten;anpeilen;lokalisieren;peilen
-Flumen (fachspr.);Talg;Schmalz;Flomen (fachspr.);Fett
-heiß sein (auf) (ugs.);brennen (auf) (ugs.);etwas unbedingt tun wollen
-Versand;Abgang;Absendung (Warenversand)
-aufspüren;nachspüren;durchstöbern;recherchieren;nachschlagen;suchen;ausforschen;ausspähen;auskundschaften
-recht haben;ins Schwarze treffen (ugs., fig.);richtigliegen (ugs.);Recht haben (Hauptform);recht gehen in der Annahme (dass) (Jargon);den Nagel auf den Kopf treffen (fig.)
-duplex;wechselseitig;beidseitig
-an Ort und Stelle schaffen;herholen;anschleppen (ugs.);herschaffen;ankarren (ugs.);herbeiholen;herbeischaffen;beschaffen;hertransportieren;beibringen;herankarren (ugs., abwertend)
-Schädlichkeit;Übeltätigkeit
-bass erstaunt (geh., Verstärkung, veraltend);verdattert;platt;sprachlos;verdutzt;platt wie eine Briefmarke (ugs.);perplex;verwundert;geplättet (ugs., fig.);platt wie 'ne Flunder (ugs., Verstärkung);baff (ugs.);verblüfft;erstaunt
-endlos;unabsehbar
-Seife;Reiniger;Reinigungsmittel (Hauptform);Detergens (fachspr.);Tensid;Putzmittel
-Eigelb;Eidotter
-wenn (ugs.);sobald;sowie;sofort nachdem
-erodieren;auswaschen
-Schiene (ugs.);Nebenzweig;Zweig;Nebenlinie;Seitenast
-fahrlässig;schludrig (ugs.);aus Unachtsamkeit;aus Unkonzentriertheit;nachlässig;ohne weiter darüber nachzudenken;schlampig (ugs.);gedankenlos;unaufmerksam;aus Sorglosigkeit;frisch, fromm, fröhlich, frei (ironisch, selten);ohne einen Gedanken daran zu verschwenden;unachtsam;achtlos;gedankenverloren (geh.);unbedacht (geh.)
-Spritze (ugs.);Injektion
-Störung des Geschmacksempfindens;Dysgeusie (fachspr.)
-Schrott (ugs.);Hausabfall;Spreu (fig.);Müll;Unrat;für die Tonne (ugs., fig.);Ausschuss;Abfall;Kehricht (schweiz.);Hausmüll
-Gelenkwelle;Kardanwelle
-Spezialitäten;besondere Eigenschaften;Besonderheiten;Merkmale
-das bedeutet;das soll besagen (geh.);daraus ergibt sich;id est (geh., lat.);sprich;i. e. (geh., Abkürzung, lat.);d. h. (Abkürzung);will sagen;damit soll gesagt werden (geh.);soll heißen;daraus folgt;das heißt (Hauptform)
-(jemandem) auf die Füße treten (ugs., fig.);vorwärtstreiben;scheuchen;auf Touren bringen (ugs.);auf Trab bringen (ugs.);voranbringen;vorantreiben;zur Eile treiben;(jemandem) Feuer unter dem Hintern machen (ugs., fig.);jagen;treiben;aufstacheln;(jemandem) Dampf machen (Redensart);(jemandem) Beine machen (ugs.);(jemandem) Feuer unterm Arsch machen (derb, fig.);Zunder geben (ugs., fig.);hetzen;antreiben
-wir (Hauptform);unsereiner;ich mit den anderen;wir alle;ich und die anderen;unsereins
-Sackerl (süddt., österr.);Beutel;Stanitzel (ugs., österr.);Tüte;Sack;Gugg (ugs., schwäbisch);Tasche;Tragetasche
-Drehbank;Drehmaschine
-Laderaum;Frachtraum
-Kätzlein;junge Katze;Katzenbaby;Katzenkind;Kätzchen
-kritisch betrachten;kritisch beleuchten;besprechen;kritisch begutachten;kritisch bewerten;einer Kritik unterziehen (geh.);rezensieren
-drücken;herabsetzen (Preise, Löhne)
-Erregung;Anregung
-verpackt;abgepackt;eingehüllt;eingepackt
-Bluterguss;blauer Fleck;Hämatom (fachspr.)
-Lehrstück;Allegorie;Gleichnis;Fabel;Parabel
-Somalier;Somali
-Trommelfeuer;Sperrfeuer;Dauerfeuer;Dauerbeschuss
-Päderastie;Knabenliebe
-(mit etwas) klarkommen (ugs.);(mit einer Situation) umgehen können;(mit etwas) fertigwerden (ugs.);(mit etwas) zurechtkommen
-versicherte Person;Versicherter;Versicherungsnehmer
-undurchdringlich;impermeabel (fachspr.);undurchdringbar;luftdicht;dicht;undurchlässig;geschützt (gegen);hermetisch
-Alraunwurzel;Mandragora;Alraune;Alraun
-bestimmend;kritisch (für) (Anglizismus);das Zünglein an der Waage sein;ausschlaggebend;entscheidend;maßgeblich
-Ungetüm;Scheusal;Monstrum;Chimäre;Monster;Untier;Schimäre;Ungeheuer;Bestie;Kreatur;Biest
-seltsam genug (Einschub) (geh., Anglizismus);paradoxerweise;seltsamerweise;ironischerweise;merkwürdigerweise;was (ja schon) ziemlich seltsam ist (variabel);kurioserweise;komischerweise
-akzeptabel;fair;vertretbar;in Ordnung;passabel;OK (ugs.);adäquat;okay (ugs.)
-papillär (fachspr.);warzenförmig
-überhöhte Preise;Preistreiberei;Mondpreise (ugs.);Wucher;Überteuerung
-Kahlkopf;Glatze;Platte (ugs.);Glatzkopf
-draußen;unter freiem Himmel;auf der grünen Wiese;Outdoor... (engl.);Außen...;in der freien Wildbahn (Jägersprache);in der freien Natur;am Busen der Natur;bei Mutter Natur (ugs.);Open-Air-...;in Gottes freier Natur;in freier Wildbahn (Jägersprache);bei Mutter Grün (ugs.);im Freien
-(jemandem) die Luft abschnüren;strangulieren;(jemanden) würgen;(jemandem) die Kehle zudrücken;(jemanden) ersticken;erdrosseln;erwürgen
-weitsichtig;langfristig denkend;vorausblickend
-Ileus (fachspr.);Darmlähmung;Darmverschluss
-ökonomische Theorie;Sozialökonomie;Volkswirtschaftslehre;Nationalökonomie (veraltet);VWL (Abkürzung)
-Risiko;Wagestück;Unterfangen;Wagnis;riskantes Unternehmen
-Gütekriterium;Gütefaktor
-Härtefallregelung;Überforderungsklausel
-Urbild;Urgestalt;Archetyp;Urform;Prototyp;Urfigur;Urtyp;Grundmodell
-Nachsatz;Hintersatz
-Zusatz;Zubehör;Beigabe
-abnehmbares Verdeck von Sportwagen;Hardtop
-äußerlich;habituell;außen
-Oktroi;indirekte Steuer;Akzise
-kritisch betrachten;kritisieren;bemängeln;tadeln;(etwas/jemanden) aufs Korn nehmen (ugs.);bemäkeln (ugs.);schelten (geh., veraltet);auseinandernehmen (ugs.);bekritteln (ugs.);(jemanden) zusammenfalten (ugs.)
-auflisten;verzeichnen;listen
-UNO-Sekretariat der Klimarahmenkonvention;UNFCCC
-Streich;List;Machination (lat.);Hinterlist;Finte;Trick;Kniff (ugs.);Tücke
-Freimut;Aufrichtigkeit;Offenherzigkeit;Offenheit
-Schleimhaut;Mukosa (fachspr.)
-Vernickelung;Vernickeln
-Bürozubehör;Büroset
-entgegenkommend;höflich;konziliant (geh.);zuvorkommend (Hauptform);sozialverträglich (ironisch-sarkastisch) (ugs.);verbindlich;diplomatisch;freundlich;galant
-Polarlicht;Aurora;Aurora borealis;Nordlicht
-Rollbalken (österr.);Store (schweiz.);(Außen-)Jalousie;Rollladen;Rollo
-reizen;(jemandes) Interesse (er)wecken;(jemanden) anmachen (ugs.);ansprechen;verlocken;(jemanden) anspringen (ugs., fig.);Interesse entfachen;faszinieren;(jemanden) antörnen (ugs., salopp);(jemanden) interessieren;neugierig machen;in seinen Bann ziehen
-Knete (ugs.);Knetmasse;Knetgummi (ugs.)
-Beschlagnahme;Exekution (österr.);Requisition;Pfändung
-Bock;Auflagebock
-Schmierheft (ugs.);Brouillon (geh., franz.);Notizbuch;Hypomnema (fachspr., griechisch, historisch);Stratze (fachspr.);Strazze (fachspr.);Kladde
-gleichzeitig;zeitgleich;taktgesteuert;synchron
-Vorzug;Wichtigkeit;Vorrang;(große/kleine) Bedeutung;Prio (ugs.);Dringlichkeit;Priorität
-wie Laternenpfahl ganz unten (ugs.);labberig (ugs., regional);muffig;vermufft;abgestanden;fade;lasch;fad;schal (Bier, Limonade)
-Rechteck;Geviert (veraltet);Quadrat;Orthogon;Vierling
-Tragfähigkeit;Tonnage
-abgeschlossen;separat (Wohnung)
-Präzession;Kreiselbewegung
-verquirlen;durcheinanderrühren;vermixen;mixen;verrühren;(miteinander) verschlagen;zusammenrühren
-Eiterflechte;Borkenflechte;Impetigo (fachspr.)
-strenggenommen;mit Verlaub (geh.);an und für sich (ugs.);wenn Sie erlauben (floskelhaft, ironisierend);schlicht und ergreifend (ugs., ironisierend);im eigentlichen Sinne;genau genommen;ehrlich gesagt (ugs.);im Grunde;von Rechts wegen (fig.);im Grunde genommen;ich darf mir erlauben (hier einmal ...) (geh.);streng genommen;eigentlich
-Leitfähigkeit;Leitwert
-Sinngedicht;Epigramm;Aufschrift
-keine Eier in der Hose haben (derb);(sich) nichts trauen (ugs., regional);feig;duckmäuserisch (ugs.);ängstlich;hasenfüßig (ugs.);(sich) klammern (an);hasenherzig (ugs.);kleinmütig;memmenhaft (ugs.);feige (Hauptform);schüchtern;keinen Arsch in der Hose haben (ugs.);mutlos
-Stander;Wimpel
-Esslöffel;Suppenlöffel
-restituieren;zurückerstatten
-Steuern erheben (auf);mit einer Steuer belegen;besteuern
-seitwärts;seitlich
-Durchsetzungsfähigkeit;Potenz;Macht;Einfluss;Machtfülle;Entscheidungsmacht
-Pessar;Scheidenpessar;Diaphragma (fachspr.)
-Hilfs...;zusätzlich
-Atrophie (fachspr.);Gewebeschwund;Atrophia;Gewebsschwund
-(irgendwo) zu Hause (ugs.);mit Sitz (in / bei ...);ortsansässig;(irgendwo) ansässig;beheimatet;wohnhaft;domiziliert (schweiz.)
-Bedienung;Handhabung;Praktik;Behandlungsweise;Methode
-Platz;Handlungsspielraum;Spielraum;Raum zum Atmen (ugs.);Luft (ugs.);Puffer;Freiraum
-Zerebrum;Großhirn
-Odem (geh., poetisch);Atem;Hauch;Luft;Puste (ugs.)
-nussig;nussreich;nussartig
-Postadresse;ladungsfähige Anschrift (fachspr., juristisch);Anschrift;Adresse;Postanschrift (Hauptform)
-Papiertüte;Papiersack
-(sich) entwickeln (aus);(sich) profilieren (aus);entspringen (aus);hervorgehen (aus)
-Sprachstörung;sprachsystematische Störung (fachspr.);Aphasie (fachspr.)
-mukokutan (fachspr.);Haut und Schleimhaut betreffend
-Pfingsten;Pfingstfest
-Zweideutigkeit;Wink (ugs.);Anzüglichkeit;Andeutung;Anspielung;Allusion (geh., lat.);Zwischenton;(versteckter) Hinweis;Fingerzeig;Innuendo (geh., bildungssprachlich)
-Teebüchse;Teedose
-Gewinnbeteiligung;Prozente (ugs.);Vergütung;Tantieme;Vermittlungsprovision;Vertreterprovision;Provision;Umsatzprovision
-(eine) Niederlage erleiden;abstinken (ugs.);verlieren;(eine) Niederlage einstecken (müssen);(eine) Niederlage kassieren (ugs.);auf einem der hinteren Plätze landen (ugs.);abgeschlagen (sein);(eine) Schlappe erleiden;(sich) (eine) Klatsche holen (ugs.);(eine) (herbe) Niederlage erfahren;geschlagen werden;abkacken (derb);(eine) Schlappe kassieren (ugs.);unterliegen;(eine) Schlappe hinnehmen müssen;(sich) geschlagen geben müssen;den Kürzeren ziehen (ugs.);besiegt werden
-auf ewig (geh.);unauslöschbar;bis du schwarz wirst (ugs., fig.);perpetuell (selten);in Ewigkeit (geh.);perpetuierlich (selten);immerwährend;nur noch (ugs.);unauslöschlich;ewig;in alle Ewigkeit (geh.);ewiglich (dichterisch);für immer;dauerhaft
-die Tage (ugs.);vor kurzer Zeit;in letzter Zeit;dieser Tage (geh., Papierdeutsch);vor nicht langer Zeit;vor kurzem;vor Kurzem;neulich (Hauptform);kürzlich;letzte Tage (ugs.);(es) ist noch nicht (allzu) lange her (dass);letzthin;letztens;unlängst;jüngst;rezent (österr.)
-häufig (vorkommend);prävalent (fachspr., medizinisch);landläufig;gängig;weit verbreitet;allgemein verbreitet;weitverbreitet
-Mauerkranz;Mauersims
-Einsatz;Arbeitseinsatz;Auftrag
-unerfahren;unreif;grün (ugs.);unwissend;primanerhaft;unqualifiziert
-Extraktion;Entzug;Extrakt;Entziehung;Auszug
-Blutschande (veraltet);Inzest (Hauptform);Inzucht
-Unterzeichnerstaat;Signatarmacht;Signatarstaat
-unrein;nicht koscher;unreinlich
-(jemanden) ins Vertrauen ziehen;(jemandem) sein Herz ausschütten;(jemandem etwas) im Vertrauen erzählen;(jemandem etwas) anvertrauen;(jemandem etwas) im Vertrauen sagen;(sich jemandem) anvertrauen
-Musterung;Verzierung
-Tatbestand;Gegebenheit;Fakt;Tatsache;Sachverhalt;Faktum
-einzeln;alleinig;isoliert;einzig;extra;abseits;monadisch (griechisch)
-Pragmatik;Sachbezogenheit;Pragmatismus
-Stellvertreter;Pronomen (Hauptform);Proform (fachspr.);Fürwort
-sehr peinlich sein;beschämen;blamieren;(jemandem) Schande machen;bloßstellen;verlegen machen
-Label;Etikett;Aufdruck
-kochen;garen;schmoren;dämpfen;dünsten
-Demonstration;Vorführung;Beweis
-absetzen;entthronen;entheben
-Scheune;Silo (Getreide) (spanisch);Speicher
-Florist;Blumenhändler
-Ironie (Hauptform);gespielter Ernst;Spöttelei (ugs.);gespielte Ernsthaftigkeit;(feiner) Spott;Doppeldeutigkeit
-schrumpeln (ugs.);schrumpfen
-Innensechskantschraube;Inbusschraube
-Vermehrung der Blutplättchenanzahl;Thrombozytose (fachspr.)
-verdauungsfördernd;digestiv
-metallbeschichten;metallisieren;galvanisieren
-Schappeseide;Florettseide
-kurzlebig;schnell vorbei;Strohfeuer (fig.);Eintagsfliege (fig.)
-Fahrgeld;Fahrkosten;Fahrtkosten;Fahrpreis;Beförderungsentgelt
-Schlinge;Rundschlinge (fachspr.);Zurrgurt (fachspr.);Spanngurt (ugs.);Schlaufe
-Kabinett;Nebenraum
-gestrichelt;strichliert (österr.)
-rostbeständig;rostfest;rostfrei
-Zuarbeit;Mitarbeit;Mithilfe (bei);Unterstützung;Beihilfe;Hilfe;Assistenz
-Adjutant;Mädchen für alles (ugs.);Hilfskraft;Assistent (Hauptform);Handlanger;Best Boy (Filmset) (fachspr., engl.);(jemandes) rechte Hand;Gehilfe;Adlatus;Beistand;(persönlicher) Referent (geh.);Unterstützer;Helfer
-weiter;Vorwärts...;nach vorn;progressiv;voran;vorwärts
-Bekräftigung;Begründung
-gang und gäbe;gewohnt;sattsam bekannt (floskelhaft);vertraut;plain vanilla (engl.);gängig;allgemein bekannt;an der Tagesordnung;geläufig;alltäglich
-Rigipsplatte;Gipskartonplatte
-Appendix;Annex;Anhang;Addendum (geh., veraltet);Anfügung;Anlage;Nachtrag;Hinzufügung;Beilage;Ergänzung;Zusatz;Paralipomenon (geh., griechisch)
-proben;durchspielen;üben
-gleichförmig;symmetrisch;gleichmäßig;ausgeglichen
-Gehör;Gehörsinn
-korrigierend;fehlerbehebend
-PS;Postskriptum
-Supervision;Unterstützung;Beratung;Mentoring
-entkeimt;hygienisch;sterilisiert;keimfrei;desinfiziert;steril;aseptisch;sauber
-erwiesen;anerkannt;bewiesen;erprobt
-abfallen;(sich) absetzen;überlaufen;desertieren;abtrünnig werden
-emporstreben;aufstreben;streben
-tschüs;tüsskes (ugs., ruhrdt.);Habe die Ehre! (ugs., bayr., österr.);adele (ugs., alemannisch, regional);ade;bye (ugs., engl.);(auf) Wiederschau(e)n (bayr.);lebwohl;tschü (ugs.);habidere (ugs., österr.);servus (ugs., süddt., österr.);tschau (ugs.);tschüss;Wiedersehen! (pragmatisch oder locker) (ugs.);ciao (ugs., ital.);Gehab dich wohl! (veraltet);Und tschüss! (unfreundlich oder ironisch) (ugs.);tschauie (ugs.);auf Wiedersehen;pfiati (ugs., bayr., österr.);tschüssikowski (ugs., salopp);cheerio (ugs.);adieu (franz.);bye-bye (ugs., engl.);tschüssie (ugs.);Lebe wohl! (geh.);pfiat di (ugs., bayr.);baba (ugs., wienerisch, österr.);tschüssle (ugs., alemannisch);tschö (ugs.);salü (ugs., luxemburgisch, saarländisch, schweiz.);Leb wohl!;Guten Tag! (unfreundlich)
-Durchhaltevermögen;Fitness;langer Atem (ugs.);Ausdauer;Form;Kondition;Stehvermögen
-Schaber;Kratzer;Striegel
-erbärmlich;mitleiderregend (fig.);kläglich;armselig;nichtswürdig;würdelos;(ein) Trauerspiel;unsäglich;unwürdig;bemitleidenswert;schäbig;jämmerlich
-Signalbegrenzung;Schrittflanke
-exklusiv;ausschließlich;alleinig
-Umschalttaste;Shift-Taste
-Touristenbüro;Touristik-Information;Tourist-Information;Fremdenverkehrsamt;Verkehrsverein;Verkehrsamt
-Mikrowellenherd;Mikrowelle (ugs., Hauptform);Mikrowellenofen;Mikrowellengerät;Mikro (ugs.)
-freundliches Ersuchen (geh., formell);Desiderium (geh., lat.);Anfrage (fachspr.);Begehren;Ersuchen;Bitte (um) (Hauptform);Antrag;...anfrage (fachspr.);Anliegen;Wunsch;Ansuchen (österr.);...begehren;Gesuch;Nachfrage;Antragstellung
-bitten (um) (Hauptform);einkommen (um) (geh., altertümelnd);(jemanden um / wegen etwas) anhauen (ugs., salopp);(sich etwas) erbitten (geh.);fordern;betteln (um);(jemanden um etwas) angehen (geh.);fragen (nach);(etwas) erfragen;(jemanden) ersuchen (zu) (geh.);erbetteln;heischen (veraltet);(um etwas) ansuchen
-(auf jemanden) verzichten;(jemandem) eine Absage erteilen;(jemandem) absagen
-Untertasse;Unterteller
-bördeln;crimpen (ugs.);mit Rand versehen
-kostspielig;(jemanden) viel Geld kosten;hochpreisig (fachspr.);kostenaufwendig (fachspr.);ins Geld reißen (ugs.);kostenintensiv (fachspr.);(ein) Loch ins Portmonee reißen (ugs., fig.);saftig (Preis) (ugs., fig.);stolz (ugs., fig.);richtig Geld kosten (ugs.);happig (ugs.);kostenaufwändig (fachspr.);(ein) teurer Spaß (ugs., ironisierend);deier (ugs., bayr.);gesalzen (Preis, Forderung) (ugs., fig.);(ein) Loch in die Kasse reißen (ugs., fig.);kostenträchtig;im oberen Preissegment (fachspr., Jargon, kaufmännisch);teuer (Hauptform);sich gewaschen haben (Preis) (ugs., fig.);gepfeffert (Preis) (ugs., fig.);preisintensiv (fachspr.);ins Geld gehen (ugs.);(ein) teures Vergnügen (ugs., ironisierend)
-(sich) ereignen;eintreten;kommen zu (es);ausbrechen;(sich) ausprägen;auftreten;entstehen;(sich) einstellen;vorfallen;(sich) entwickeln;aufkommen;einsetzen
-vorhaben;es anlegen auf;erstreben;hinter etwas her sein (ugs.);darauf aus sein (zu + Infinitiv);anvisieren;(sich etwas) fest vornehmen;(sich etwas) zum Programm gemacht haben;sinnen (auf) (geh., veraltend);(etwas) in den Blick nehmen;anpeilen;abzielen (auf);im Sinn(e) haben;(sich etwas) auf die Fahnen geschrieben haben (fig.);(sich) konzentrieren (auf);willens sein (geh.);streben nach;anstreben;abstellen (auf) (geh.);(auf etwas) aus sein;ringen um;(sich etwas) in den Kopf setzen;(erreichen) wollen (Hauptform);(sich etwas) zum Ziel setzen;(etwas) im Schilde führen (negativ);bezwecken;trachten (nach) (geh., veraltend);es abgesehen haben auf
-Säbel;Schwert
-Traubenlese;Weinernte;Weinlese;Herbsten
-superb;vorzüglich;exzellent;exquisit;hervorragend;süperb;unbeschreiblich
-Cousine;Base;Kusine
-Unternehmungsgeist (ugs.);Umtrieb;Aktivität;Regsamkeit;Rastlosigkeit;Beweglichkeit;Rührigkeit (ugs.);Betriebsamkeit;Geschäftigkeit
-verteilen;austeilen;unters Volk bringen;unter die Leute bringen;abgeben
-Kartoffelstärke;Erdäpfelstärke (österr.);Speisestärke;Amylum Solani (lat.);Kartoffelmehl
-aufschlagen;aufprallen
-einschätzen;abwägen;prüfen;beurteilen
-keimtötendes Mittel;Antiseptikum;Desinfiziens (fachspr.)
-kariert;schachbrettartig;gescheckt
-Registrator;Archivar
-Niederträchtigkeit;Niedertracht;Tücke
-(bis zu einer bestimmten Höhe) füllen;(wieder) auffüllen;(Vorräte) ergänzen;nachschenken;(wieder) vollmachen (ugs.);nachfüllen
-Läuferstein im Mauerwerk;Läufer
-Rahmung;Einrahmung
-Scheidenentzündung;Vulvovaginitis (fachspr.)
-Rollbalken;Bildlaufleiste;Schiebebalken;Scrollbar (engl.)
-Personal;Arbeitnehmer;Angestellte;Personalbestand;Belegschaft
-Senkwaage;Vertikale;Senkrechte;Normale;Lot
-Pathologie (ugs., fälschlich);Rechtsmedizin (Hauptform);forensische Medizin;Gerichtliche Medizin (veraltet);Gerichtsmedizin (veraltet)
-Gekeife (ugs.);Gezeter;Gezänk;Geplärr (ugs.);Geplärre (ugs.);Gezetere
-Nachzahlung;Zuzahlung
-unangefochten;unübertroffen
-verspritzen;spritzen
-Territorium;Areal;Gebiet;Raum;Gegend
-Unsicherheit;Unstetigkeit
-Seiche (derb);Wasser (in: Wasser lassen);Piese (derb);Harn;Pipi (ugs.);Urin;Natursekt (vulg.);Pisse (derb);Pinke (derb)
-Bruttoregistertonnen;BRT
-Desertion;Übertritt;Entfernung von der Truppe;Fahnenflucht
-Lurch;Amphibie
-Suppositorium (fachspr.);Zäpfchen
-Nation;Bevölkerung;Volk
-Lichterbaum;Weihnachtsbaum;Christbaum;Tannenbaum
-infinit (geh., lat.);ad infinitum (geh., lat.);unaufhörlich;unbegrenzt;endlos;unendlich groß
-auswertbar;berechenbar;evaluierbar
-Quartierzettel;Quartierschein
-lebhaft;temperamentvoll;impulsiv
-in Zaum halten;in Schach halten;im Zaum halten;unter Kontrolle halten;zügeln;mäßigen;(die) Kontrolle behalten (über)
-(jemanden) aufschrecken lassen;(jemandem) einen Schreck(en) einjagen;(jemanden) erschrecken;(jemanden) zusammenfahren lassen
-Zusammenspiel;Aneinanderreihung (abwertend);Verknüpfung;Komposition;Konstellation (geh., bildungssprachlich);Zusammenstellung (Hauptform);Kombination;Zusammensetzung;Collage (aus/von)
-Schriftzeichen;Grafem (fachspr.);Glyphe (fachspr.);Schreibzeichen (ugs.);Graph (fachspr.);Letter;Symbol;Graphem (fachspr.)
-Preisobergrenze;oberste Preisgrenze;Preislimit
-(etw.) argumentieren;(etw.) rechtfertigen;(etw.) begründen;Argumente darlegen;Gründe liefern;Gründe vorbringen;(etwas) legitimieren;Argumente vorbringen;Gründe beibringen (fachspr., juristisch);Argumente liefern;Gründe nennen;Argumente aufzählen;(etw.) verargumentieren (bundesdeutsch);Argumente finden (für);Gründe anführen;Gründe finden;etw. argumentativ untermauern (geh.);erklären;(eine) Begründung abgeben
-Rand;Rahmen;Gefüge
-Egoismus;Eigensucht;Selbstsucht;Egozentrik
-(bewusst) gegen jemanden rennen;anrempeln;(jemandem) einen Stoß versetzen;anstoßen;(gezielt) mit jemandem zusammenstoßen
-Rentenmarkt;Anleihenmarkt;Obligationenmarkt
-Abrissarbeiten;Abbrucharbeiten
-biografischer Katalog;Personenkatalog
-Engelmacher (ugs.);Püster (ugs.);Zimmerflak (ugs., scherzhaft);Schießprügel (ugs.);Colt (ugs.);Prügel (ugs.);Ballermann (ugs.);Bleispritze (ugs.);Pistole;Wumme (ugs.);Schießknüppel (ugs.);Schießeisen (ugs.);Revolver;Knarre (ugs.);Meuchelpuffer (ugs., veraltet)
-Kapo (süddt., österr.);Kolonnenführer;Brigadier (fachspr., DDR);Vorarbeiter (Hauptform);Polier;Truppführer
-für unwichtig erachten;(einer Sache) keine Bedeutung beimessen;für unwichtig erklären;abtun;nicht eingehen auf
-Erklärung;Äußerung;Aussage;Stellungnahme;Behauptung;Einlassung (fachspr., Jargon, juristisch);Statement (engl.)
-Spannung;Tonus (fachspr.)
-Flugbegleiter;Steward
-Übermantel;Überzieher
-Zwischenwand;Trennwand;Scheidewand
-Flugbegleiterin;Hostess;Stewardess;Saftschubse (ugs., abwertend)
-Delamination;Ablösung von (Laminat-) Schichten;Schichtablösung
-Geleitzug;Konvoi;Eskorte;Geleit
-Besatzung;Besatzungsstreitkräfte;Besatzer (abwertend);Quardi (veraltet);Besatzungsarmee;Besatzungstruppe(n);Okkupationstruppe(n)
-(sich) ranschmeißen (ugs.);(sich) lieb Kind machen (bei jemandem);rumschleimen (ugs., fig.);(jemanden) hofieren;schwänzeln (ugs., fig.);Kreide fressen (ugs., fig.);schleimen (ugs., fig.);(jemandem) Honig um den Bart schmieren (ugs., fig.);(sich) einkratzen (bei) (ugs., salopp);(sich) einschmeicheln (bei);herumscharwenzeln (um) (ugs.);(sich) anbiedern;(sich) einschleimen (bei) (derb)
-verbannen;vertreiben;ins Exil schicken
-Wandteppich;Bildteppich;Tapisserieware
-unter Spannung;aufgewühlt;zitterig;die Nerven liegen bloß (ugs.);aufgerührt;nervös;die Nerven liegen blank (ugs.);nervlich (sehr) angespannt;angespannt;unter Spannung (stehend);in (großer) Anspannung;unter Anspannung;gespannt;nervlich angespannt;in atemloser Spannung;(jemandes) Nerven sind zum Zerreißen gespannt
-Polierleder;Fensterleder
-ölen;durchschmieren;fetten;abschmieren;schmieren
-verbreiten (unter);disseminieren (veraltet);verteilen (unter)
-Memorandum;Note
-Arbeitsgang;Runde;Durchgang;Durchlauf
-paravenös (fachspr.);neben einer Vene liegend
-Eiteransammlung;Empyem (fachspr.);Abszess
-elliptisch;ellipsenförmig
-Landesparlament;Länderparlament;Landtag
-Bettler;Bittsteller;Supplikant (geh.)
-Sahne (ugs.);fantastisch;zum Reinlegen (ugs.);tipptopp (ugs.);super (ugs.);leiwand (ugs., österr.);genial (ugs.);doll (ugs.);klasse (ugs.);dufte (ugs.);bombastisch (ugs.);hasenrein (ugs.);supi (ugs.);sauber (ugs.);der Hit (ugs.);nicht schlecht (ugs.);geil (ugs.);cool (ugs., engl.);tofte (ugs.);stark (ugs.);prima (ugs.);allererste Sahne (ugs.);großartig;phantastisch;leinwand (ugs., österr.);toll;knorke (ugs., berlinerisch, veraltet);bombig (ugs.);1A (ugs.);erste Sahne (ugs.);astrein (ugs.);eine Wucht (ugs., veraltet);phatt (ugs., Jargon);spitze (ugs.);töfte (ugs., ruhrdt.)
-Deponierung;Aufbewahrung;Hinterlegung
-erfüllen;befriedigen;zufrieden stellen;Befriedigung verschaffen
-Geldeinnehmer;Kassierer (männl.);Geldeintreiber;Kassiererin (weibl.)
-Wohlbefinden;Wellness
-Ausstoßung;Vergrämung;Austreibung;Vertreibung
-Imperium;Weltreich;Großmacht;Supermacht;Großreich;Weltmacht
-Verneigung (vor);Verbeugung
-knittern;Falten werfen
-anhimmeln;in verklärtem Licht sehen;vergöttern;verehren;umschwärmen;anschmachten (ugs.)
-Halbleiterwafer;Halbleiterplättchen
-unorganisiert;entgleist (ugs.);ungeordnet;desorganisiert;durcheinander;chaotisch;unstrukturiert
-Arbeitsplan;Ablaufplan
-Rollschuh fahren;inlinen (ugs.);Inlineskaten;Inline-skaten
-rammdösig (ugs.);beduselt;benommen;wie betäubt;benebelt (ugs.)
-da sein (ugs.);vorhanden sein;vorliegen;bestehen;sich befinden;(dort) vertreten sein;geben (es gibt / es gab ...);sein;existieren;vorkommen;lauern (Gefahren) (fig.)
-einzig;bloß;aus dem einzigen Grund (dass);lediglich;nichts weiter als;schier;und sei es nur;nur (Hauptform);einzig und allein;allein;ausschließlich;nichts als;alleinig
-geistige Ebenbürtigkeit;Kongenialität
-unbeständig;nicht dauerhaft;wetterwendisch;flüchtig;rasch;kursorisch
-Unrat;Ist das Kunst oder kann das weg? (ugs., kommentierend, scherzhaft);Müll;Abfall
-Familienbetrieb;Familienunternehmen;Familienfirma
-Kniescheibe;Patella (fachspr.)
-Straßenpflaster;Pflaster
-retour schicken (ugs., Jargon, kaufmännisch);zurückschicken;retournieren (fachspr., kaufmännisch);remittieren (fachspr.);zurücksenden;retour senden (fachspr., Jargon, kaufmännisch)
-jungfräulich;keusch;züchtig;unbefleckt (bibl.);rein;anständig;mädchenhaft;unbescholten;unschuldig;sittsam;unberührt;unverdorben
-kostenpflichtig;gebührenpflichtig;nicht umsonst;entgeltpflichtig
-die Korken knallen lassen (ugs., auch figurativ);auf die Pauke hauen (ugs., fig.);es krachen lassen (ugs.);steil gehen (ugs., jugendsprachlich);voll abgehen (ugs.);ausgelassen feiern;(so richtig) einen draufmachen (ugs.);(sich) austoben (ugs., fig.);auf den Putz hauen (ugs., fig.);(die) Puppen tanzen lassen (ugs., fig.);kräftig abfeiern (ugs.);(die) Sau rauslassen (ugs., fig.)
-Fortgang;Fortschritt;Geschehen;Verlauf;Ablauf
-exzidieren;dekupieren (franz.);herausschneiden;ausschneiden;(operativ) entfernen;herausnehmen
-Schisma;Kirchenspaltung
-Usus;Konvention;Usance (fachspr.);Gewohnheit;Regel;Brauch;Usanz (fachspr., schweiz.);Gepflogenheit;Sitte
-halt stopp! (ugs.);bis hierher und nicht weiter;keinen Schritt weiter!;stehenbleiben!;stopp!;halt!
-profilloser Reifen;Slick
-dissident;regimekritisch
-Schokokuss;Negerkuss (ugs., veraltend);Schaumkuss;Mohrenkopf (ugs., veraltend);Bumskopf (ugs., regional);Schwedenbombe (österr.)
-verfinstern;Schatten werfen;verdüstern;verdunkeln
-klaffende Wunde;tiefer Riss;tiefer Schnitt
-zurückrollen;zurückdrehen
-schwer;schwergewichtig
-fehlerfrei;exakt;präzis;haargenau (ugs.);genau;richtig;gewissenhaft;akkurat;präzise;prägnant;korrekt
-lachen (über);aus seiner Schadenfreude keinen Hehl machen;(sich) einen abgrinsen (müssen) (ugs.);hämisch grinsen;(sich) unverhohlen freuen;feixen;frech grinsen;ein schadenfrohes Grinsen aufsetzen;(jemanden) auslachen (Hauptform)
-Stoßstange;Schubstange;Stoßfänger (fachspr.)
-Leitwand;Leitmauer
-Tagung;Symposium (wissenschaftlich);Konferenz;Kongress;Meeting (engl.)
-Mit besten Grüßen;Beste Grüße;In Verbundenheit;Schöne Grüße;Viele Grüße;Liebe Grüße;Herzliche Grüße
-Neologismus (fachspr.);Wortneubildung;neues Wort (Hauptform);sprachliche Neubildung;Wortneuschöpfung;Neuwort;neu gebildetes Wort
-Kontrazeptivum (fachspr.);Verhütungsmittel;Empfängnisverhütungsmittel;Mittel zur Familienplanung
-Erbschein;Erbnachweis
-Anflugglasur;Salzglasur
-krümmen;verdrehen;verzerren
-Fauna;Viecher (derb, abwertend);Getier (geh.);Tiere (ugs.);Viehzeug (derb, abwertend);Tierwelt;(alles) was da kreucht und fleucht (ugs., Spruch)
-und zwar;(oder) besser gesagt;respektive (geh., lat.);mehr als das;(oder) vielmehr;eigentlich;eher;resp. (Abkürzung);genauer gesagt;beziehungsweise;genauer;mehr noch;bzw. (Abkürzung)
-Ziegel;Backstein;Ziegelstein (ugs.)
-Delfinarium;Delphinarium
-Verteidigung;Rechtfertigung;Verteidigungsrede;Apologie
-Rücksprung (einer Wand);zurückgesetzte Fassade
-abschließend (mit);bündig;eben (mit)
-PS (Einheitenzeichen);Pferdestärke
-ins Deutsche übersetzen;germanisieren;eindeutschen;verdeutschen
-barmherzig;mild;glimpflich;nachsichtig
-Gelenkerkrankung;Arthropathie (fachspr.)
-Zuvorkommenheit (geh.);Gefälligkeit;Entgegenkommen;Courtoisie (geh., franz.);Freundlichkeit;Verbindlichkeit;Höflichkeit
-Adressenfeld;Adressierfeld;Anschrift(s)feld (selten);Anschriftenfeld;Adressfeld
-Wemfall;dritter Fall;Gebefall;Dativ (Hauptform)
-sommers wie winters;das ganze Jahr über;perennial (fachspr.);ganzjährig;das ganze Jahr hindurch;das ganze Jahr (ugs.)
-Auswuchs;Extrem
-Morgengrauen;Sonnenaufgang;Morgendämmerung;Tagesanbruch;erstes Licht
-Bühnenbild;Bühnenausstattung;Kulisse (franz.);Bühnenrückwand;Theaterkulisse;Bühnendekoration;Schiebewand
-Grund...;von grundlegender Bedeutung;prinzipiell;elementar;fundamental;wichtig;eminent (geh.);wesentlich;essentiell;essenziell;primär;von essentieller Bedeutung;basal (fachspr.);substanziell;von elementarer Bedeutung;die Grundlage bilden(d);grundlegend;von essenzieller Bedeutung
-die Flügel hängen lassen (ugs.);mutlos sein;die Ohren hängen lassen (ugs.);kraftlos;entmutigt sein
-jede Menge ...;hunderte von ...
-(nahe) Verwandtschaft;Blutsbande;Blutsverwandtschaft (Hauptform)
-anpeilen;(ein) Ziel verfolgen;(Kurs) einschlagen;(nach etwas) streben
-Konstruktionszeichner;Bauzeichner;Zeichner
-Rüstzeug;Sachkunde;Fähigkeit;Kenntnisstand;Sachkenntnis;Wissensstand;Expertise (geh.);Techne (geh., griechisch);Horizont;Sachverstand;Kenne (ugs.);Wissen;Können;Ahnung (ugs.);Kompetenz;Know-how;Kenntnis
-fällig werden;anfallen
-ineinander greifen;verzahnen;sperren
-ausüben (Gewerbe);betreiben;nachgehen
-Habgier;Konsumrausch;Gier;Raffgier;Habsucht;Begehrlichkeit;Gierigkeit
-Beschäftigungslosigkeit;Erwerbslosigkeit;Arbeitslosigkeit
-glätten;glatt feilen;abreiben;feilen;glatt reiben;abschmirgeln;abfeilen;schmirgeln;abschleifen;abschaben
-aufkreischen;aufschreien;jaulen;aufjaulen
-Streifenkode;Balkencode;Barcode (engl.);Strichcode
-Hustensaft (ugs.);Antitussivum (fachspr.);Hustenmittel
-Narkose;Betäubung;Anästhesie;Allgemeinanästhesie (fachspr.)
-Versalien (Plural);Versalbuchstaben (Plural);Großbuchstaben (Plural);Majuskeln (Plural)
-gebeutelt werden (ugs.);(vor Kälte) bibbern;(eine) Gänsehaut bekommen;erschaudern;weiche Knie haben;schauern;zittern wie Espenlaub (ugs., Verstärkung);schuckern (regional);(vor Angst) schlottern (ugs.);erzittern;am ganzen Körper zittern;(jemandem) schlottern die Knie;erschauern;schaudern;erbeben;zittern
-Alkoholrausch;Betrunkenheit;Trunkenheit
-Fantasiewelt;Reich der Phantasie;Wunschwelt;Phantasiewelt;Traumwelt;Reich der Fantasie
-großzügig;spendabel;freigebig;großmütig;hochherzig;großherzig;generös;freigiebig;in Geberlaune;nobel (aus der Nehmerperspektive);gönnerhaft;Man muss auch gönnen können. (ugs., sprichwörtlich);spendierfreudig
-Diversifizierung (Hauptform);Ausweitung;Diversifikation (fachspr.);Verbreiterung;Erhöhung der Vielfalt
-Schwindler;Falschspieler;Betrüger
-Kleinanzeige;Annonce;Fließtextanzeige (fachspr.);Zeitungsannonce;Zeitungsinserat;Inserat;Zeitungsanzeige;Anzeige
-Kiefer;Kieferknochen
-Harnlassen;Miktion (fachspr.);Urinieren;(natürliche) Harnentleerung (aus der Blase);(das) Wasserlassen (Hauptform)
-ins Schwärmen kommen (bei jemandem/etwas);hin und weg sein (ugs.);in Verzückung geraten (bei jemandem/etwas);überwältigt sein (von jemandem/etwas) (Hauptform)
-Kasten (süddt.);Schapp (ugs., norddeutsch);Schaff (ugs., regional);Spind;Schaft (ugs., schweiz., süddt.);Schrank (Hauptform)
-Werbevertreter;Anzeigenvertreter
-zwischen;mitten zwischen (ugs.);mitten unter;umstanden von (geh., veraltend);umgeben von;umringt von;inmitten;umsäumt von
-anspritzen;besprühen;bespritzen
-etwas berücksichtigen;etwas bedenken;etwas vorsehen;etwas einkalkulieren
-Heraldik (fachspr.);Heroldskunst;Wappenkunde;Wappenwesen
-Telefonapparat;Telefon (Hauptform);Telephon (veraltet);Sprechapparat;Fernsprecher;Fon;Apparat (ugs.);Endgerät (fachspr.);Fernsprechapparat
-Beschlagnahmung;Beschlagnahme;Einzug
-Absage;Ablehnung;Abweisung (fachspr., juristisch);Weigerung;Rückweisung;Exkusation (fachspr., juristisch, lat., veraltet);Zurückweisung;Verweigerung;Abfuhr;(ein) Nein;Nichtanerkennung;Verneinung
-laben;auffrischen;beleben
-Vorsorgemaßnahme;Verhütung;Vorbeugung;Prävention;Prophylaxe (fachspr.);Abwendung;Vorbeugungsmaßnahme
-Insertion (fachspr.);Ansatzpunkt eines Muskels am Knochen
-unüberwindlich;unüberbrückbar;unüberwindbar
-unordentlich;wirr;drunter und drüber (ugs.);planlos;(bunt) durcheinandergewürfelt;chaotisch;buntgewürfelt;kreuz und quer (ugs.);(bunt) zusammengewürfelt;unaufgeräumt;wie Kraut und Rüben (durcheinander) (ugs.);strukturlos;ohne Struktur;kunterbunt;wild durcheinander;schlampig (ugs., abwertend);ohne System;durcheinander (Hauptform);ohne Plan
-Lufthülle;Atmosphäre
-(einer Sache) gewahr (veraltet);(jemandem) bewusst;(sich über etwas) im Klaren sein;(sich) (dessen) bewusst sein, dass;(jemandem) klar (ugs.);(sich darüber) im Klaren sein, dass;(jemandem) gegenwärtig;(für jemanden) klar
-enthalten;inkludieren;bergen (geh.);mitbringen (ugs.);beinhalten;beherbergen;involvieren;umfassen;einbeziehen;integrieren;umschließen;einschließen;tragen;in sich bergen
-Marktstudie;Marktanalyse
-Absorption;Aufsaugen;Einsaugung;Aufsaugung
-reinmarschieren (ugs., regional, salopp);reinstiefeln (ugs., regional, salopp);reinkommen (ugs.);reingehen (ugs., regional);eintreten;hineingehen;betreten
-Einzelzimmer;Einbettzimmer
-Seziermesser;Skalpell
-Sehkraft;Augenlicht;Sehvermögen
-Motorläufer;Induktor;Drehzylinder
-Firmament;Himmel;Himmelskugel;Himmelsgewölbe;Himmelszelt;Himmelssphäre;Sternenzelt
-naturfarben;ecru (fachspr.);ungebleicht;ekrü (fachspr.)
-Heiratsgut;Heiratsausstattung;Mitgift (Hauptform);Aussteuer (veraltend);Heimsteuer (veraltet);Brautaussteuer;Dotation (geh.)
-gängeln;bevormunden;infantilisieren (geh.);am Gängelband halten;am Gängelband führen
-exogen;von außen wirkend;äußerlich entstehend
-verbrecherisch;ungesetzlich;kriminell;rechtswidrig;sträflich;mafiös;illegal
-Gutdünken;Einschätzungsspielraum;Ermessen
-besorgen;(sich) holen (ugs., salopp);erwerben (geh.);käuflich erwerben (Papierdeutsch);erkaufen (fig.);(sich etwas) kaufen (ugs.);erstehen (geh.);(sich) zulegen;kaufen (Hauptform);anschaffen
-Wanze;Reißzwecknadel;Reißbrettstift;Heftzwecke;Reißnagel;Reißzwecke
-ebenso wie;wie;wie noch;neben;zuzüglich (geh.);ja sogar;nebst;sowohl ... als auch;wie auch;und;plus (ugs.);sowie;sowohl;ja
-Leichtbeton;Gasbeton
-Zusammensetzen;Montage;Zusammenbau;Installation;Einbau;Befestigung
-beziffern;quantitativ bestimmen;quantifizieren
-Urfassung;Originalfassung
-ungustiös (österr.);ekelhaft;abscheulich;Brechreiz auslösend;degoutant (geh.);eklig;abstoßend;ekelig;ekelerregend;widerlich (Hauptform);widerwärtig;unappetitlich (auch figurativ);Ekel erregend;bäh (ugs., Babysprache)
-nach dem Krieg;Nachkriegs...
-Estländer;Este
-Ejakulation (fachspr.);Samenerguss
-Abstichrinne;Angusskanal;Angussverteiler
-Autoverkehr;Straßenverkehr
-abstempeln (als) (ugs.);vorverurteilen (als);stigmatisieren
-Hausrat;Mobiliar;(Gesamtheit der) Einrichtungsgegenstände;Wohnungseinrichtung;Meublement (geh., franz., veraltend);Ameublement (geh., franz., veraltet);(die) Möbel (Plural, Hauptform);Ausstattung mit Möbeln;Inventar
-Jazzband;Jazzkapelle
-Verzweigungstabelle;Sprungleiste;Sprungtabelle
-armes Schwein (ugs.);letztklassig (ugs., österr.);hoffnungslos;erbarmungswürdig (geh.);unglücklich;armer Teufel (ugs.);armer Kerl;erbärmlich;zu bedauern (sein);kläglich;Mitleid erregend;bedauernswert (Hauptform);arme Sau (derb);jammervoll;traurige Gestalt;heruntergekommen;arm dran (ugs., ruhrdt.);arm;miserabel (geh.);bemitleidenswert;armer Tropf (veraltend);bejammernswert (fachspr.);beklagenswert;jämmerlich;armselig
-Kissen;Polster (bairisch, österr.)
-palpebral (fachspr.);das Augenlid betreffend
-Kellergeschoss;Untergeschoss;Keller
-bernsteinfarben;amber
-seinen Einstand geben;sein Debüt geben
-Aufwertung;Umbewertung;Umwertung
-Gleichlaufschwankung;Gleichlaufstörung
-Erdhügel;Kuppe;Koppe;Aufschüttung;Anhöhe;Höhe (fachspr., Jargon, militärisch);Erdwall;Erhebung
-Knüller;Kassenschlager;Publikumserfolg;Kassenmagnet;Zugpferd (ugs.);Goldesel (ugs., fig.);Bestseller (engl.);Renner (ugs.);Hit;Schnelldreher (Kaufmannssprache) (fachspr.);hohe Verkaufszahlen (erreichen);Reißer (ugs.);Kassenerfolg;Verkaufsschlager
-lallen;babbeln;Laute produzieren;unartikuliert sprechen;plappern;brabbeln;kanonisches Lallen (fachspr.)
-es war einmal (und ist nicht mehr);Geschichte (sein) (ugs.);beendet;passé;gewesen;das war (ein)mal (ugs.);verflossen (ugs.);tot und begraben (z.B. Hoffnungen) (fig.);rum (ugs.);gelaufen (ugs.);aus (sein) mit (ugs.);vergangen;herum;aus und vorbei (ugs.);Die Zeiten sind vorbei. (ugs., Spruch);abgelaufen;passee (alte Schreibung bis 2017);vorbei (sein) mit;vorüber;vorbei;dahin (geh.)
-Kinnlade;Kinnbacke
-Geseiche (ugs.);dummes Gequatsche (ugs.);unnützes Gerede;Gelaber (ugs.);Gesülze (ugs.);Gemunkel (ugs.);Gesäusel (geh., abwertend);Gerede;Gebrabbel (ugs.);leeres Gerede;Geschwätz (ugs.);Geseiere (ugs.)
-Neonbeleuchtung;kaltes Licht (ugs.);Neonlicht
-tapfer ertragen;jemandem trotzen;erdulden
-am Tage vorkommend;diurnus (fachspr.)
-flechten;einflechten (in);zusammenweben
-Seitenverhältnis;Bildseitenverhältnis
-Ubiquität (fachspr., lat.);Allgegenwärtigkeit;Allgegenwart;Omnipräsenz
-aufgeblasen;selbstwichtig;geschwollen;selbstüberzeugt;von sich selbst überzeugt;durchdrungen von der eigenen Bedeutsamkeit;großspurig
-Pneumologie (fachspr.);Pulmonologie (fachspr.);Lungenlehre;Pneumonologie (fachspr.);Pulmologie (fachspr.);Lungenheilkunde
-suspendiert;beurlaubt
-(jemandes) Kreise stören (geh.);(jemandem) in die Quere kommen;(jemandem) ins Gehege kommen (ugs.);behindern;stören;(jemandem) in die Parade fahren (fig.)
-Beschäftigungsverhältnis (Amtsdeutsch);Stelle (Hauptform);Aufgabe (fig.);Posten;Arbeitsverhältnis;Position;Beschäftigung;Stellung;Arbeit;Arbeitsplatz;Amt (fachspr.);Anstellung;(die) Stätte seines Wirkens (geh.);Arbeitsstelle;Job (ugs.)
-nicht länger;nimmer (ugs.);nicht mehr
-zusammengehen;(sich) vereinen
-handgreiflich;rabiat;gewalttätig;roh;ruppig;grobschlächtig;brachial;grob
-geregelt;klar;sicher;feststehen;spruchreif;ausgemacht;festgesetzt;offiziell (ugs., fig.);festgelegt;entschieden (sein);geklärt;verbindlich;definitiv
-Systemabsturz;Systemzusammenbruch
-Mio.;1.000.000;Million
-Schutzumschlag (Hauptform);Umschlag;Buchumschlag;Hülle
-Befehlszähler;Programmschrittzähler
-verlängern;ausdehnen;prolongieren;erweitern;ausweiten;hinausschieben;ausspannen
-gezeichnet;gebeutelt (ugs.);mitgenommen
-Postgebühr;Briefporto;Porto (Hauptform);Beförderungsentgelt
-Fahrzeit;Fahrtdauer
-Antiphlogistikum (fachspr.);entzündungshemmende Mittel
-Lipodystrophie (fachspr.);Schwund von Fettgewebe
-bestaunen;anstarren;anglotzen (ugs.);gaffen (ugs.);starren auf;angaffen (ugs.)
-Entwicklung;Entwicklungsverlauf;Reifeprozess;Entstehung;Entfaltung;Entwicklungsprozess;Evolution
-Pflanzenwelt;Vegetation;...flor (fachspr., Jargon);Pflanzenreich;(das) Grün(e) (ugs.);Flora;Pflanzenbewuchs;Botanik (ugs., fig., scherzhaft);Pflanzenwuchs;Bewuchs (fachspr.)
-Wiederherstellung;Rückgewinnung;Wiederherstellen
-besichtigen;(sich) ansehen;besuchen;(sich) anschauen (gehen);live dabei (gewesen) sein (ugs.)
-entsagen;widerrufen;abschwören
-Dürre;Trockenheit
-Kühlung;Abkühlung
-(jemandem) durcheinandergeraten (ugs.);(etwas) durcheinanderbringen (ugs.);durcheinandergeraten (mit);(etwas / jemanden) verwechseln (mit);(jemandem) durcheinandergehen (ugs.);durcheinanderkommen (mit) (ugs.)
-Wechselbeziehung;Korrelation;Zusammenhang;Aufeinanderbezogensein
-Bleilot (fachspr.);Richtblei;Senklot;Lot (Werkzeug);Senkblei
-knallhart (ugs.);hart;ehern;fest;knüppelhart (ugs.);standhaft
-Zahlungsfrist für Wechsel;Wechselfrist
-neu kalkulieren;nachrechnen
-Heraufbeschwören;Evokation
-die Unseren (geh., variabel);(ganze) Bagage (ugs., abwertend);Familie;Geschlecht;Familienclan;Anhang;Familienverband;Verwandtschaft (Hauptform);Sippe;Kind und Kegel;Muschpoke (abwertend);bucklige Verwandtschaft (ugs., abwertend, scherzhaft);Klan;Angehörige;(die) Linie der;Blase (ugs., abwertend);vom Stamm der;Sippschaft (derb);Mischpoke (abwertend);Clan (ugs.)
-praktisch;eher;so gut wie;eigentlich;schon fast (ugs.)
-Wochenbett;Kindbett;Puerperium (fachspr., lat.)
-Heufieber;Pollenallergie;Pollinose (fachspr.);Heuschnupfen
-Schweißgeräte;Schweißausrüstung
-Vorsilbe;Präfix (fachspr., wissenschaftlich)
-Hochgeschwindigkeitszug (ugs.);ICE;InterCity Express;Inter City Express;Intercity-Express
-eingebildet;anmaßend;hochgestochen;hochnäsig (ugs.);stolz;selbstgefällig;prätentiös (geh., bildungssprachlich)
-Maulaffe (ugs., abwertend);Schaulustiger;Umstehender;Gaffer (ugs.);Zaungast;Neugieriger
-verändern (Hauptform);abwandeln;modifizieren;diversifizieren;(eine Sache) variieren
-gepachtet;geleast;gemietet
-Salzlauge;Sole
-(sich) zum Affen machen (ugs.);(zum) Gespött der Leute werden;(sich) die Blöße geben;als der Dumme dastehen;als Depp dastehen;(sich) zum Deppen machen;(sich) bloßstellen;blamiert sein;(sich) lächerlich machen
-Reiseplan;Marschroute;Reiseweg;Richtung;Kurs;Strecke;Weg;Wegstrecke;Reiseroute;Route (franz.)
-Steuerraum;Leitwarte;Warte
-auf freiem Fuß (sein);auf freien Fuß gesetzt;frei herumlaufen;nicht länger in Polizeigewahrsam;(wieder) draußen (ugs.);(aus der Haft) entlassen;(ein) freier Mann
-für etwas verantwortlich sein;etwas leiten;etwas betreuen;etwas in Obhut haben
-Allgemeinsames Zoll- und Handelsabkommen;GATT
-holen;abtransportieren;abholen;einsammeln
-Begleit...;zurückbegleitend;nebenstehend
-Blutegel;Egel
-Stromanschluss;Sammelschiene
-Buchen;Order;Reservierung;Bestellung;Buchung
-Telefonhörer;Handapparat
-Zivildienstleistender (Hauptform);ZDLer (ugs., Jargon);Kriegsdienstverweigerer;Wehrdienstverweigerer;Zivi (ugs.);ZDL (fachspr., Abkürzung);Zivildiener (österr.);anerkannter Kriegsdienstverweigerer
-altertümlich;antik;archaisch;alt;uralt;frühzeitlich
-Molkerei;Meierei (ugs.);Käserei
-Verpflegungssatz;Tagessatz;Provision
-Bestätigungsvermerk;Prüfungsbericht
-blass geworden;Farbe verloren habend;verblasst;ausgewaschen;abgefärbt
-vererben;herleiten von;ableiten von
-in Brand setzen;Feuer machen;entflammen;zündeln;anzünden;anstecken (ugs.);entzünden;entfachen
-bergen;retten;zurückholen
-resultierend daraus;deshalb;demzufolge;nachdem;in der Folge;mithin;dementsprechend;im weiteren Fortgang;also;im Weiteren;daraufhin;als Folge dessen;insofern;im Folgenden;infolgedessen;im weiteren Verlauf;demnach;danach;somit;folglich;dadurch;in der Konsequenz;demgemäß
-Gänsehaut (ugs.);Haarsträuben;Sichaufrichten der Körperhaare;Hühnerhaut (schweiz., österr.);Ganslhaut (österr.);Haaresträuben;Erpelpelle (ugs.);Piloarrektion (fachspr.)
-hierzu;zu dem/der/den ... gehörend (variabel);zu;dazu;zu diesem Thema;dazugehörend;dazu gehörend;zu diesem Punkt;diesbezüglich (Adjektiv);dazugehörig
-Zweibettzimmer;Doppelzimmer
-Fährschiff;Fährkahn;Fähre;Fährboot;Ponte
-Kinder- und Jugendmedizin;Kinderheilkunde;Pädiatrie (veraltet)
-Bezeichner (Linguistik) (fachspr.);Designator (geh., lat.);Begriff;(das richtige) Wort für (ugs.);Name;Bezeichnung (Hauptform);Begrifflichkeit (fachspr., Amtsdeutsch)
-Ziffernblatt;Zifferblatt
-Bitgeschwindigkeit;Bitfrequenz
-Rollstuhl;Krankenfahrstuhl (fachspr.);Rolli (ugs.)
-Ginster;Stechginster
-spritzig;schmissig;prickelnd;schnittig;temperamentvoll;sprühend
-ganz sicher sein (können);(einen) lassen können (auf) (derb);gehen (können) nach (ugs.);vertrauen;ausgehen können von;(sich) verlassen (auf);Gift nehmen können (auf) (ugs.);zählen (auf);bauen (auf)
-Betriebsökonomie;Betriebswirtschaftslehre;Betriebswirtschaft;BWL (Abkürzung)
-Box;Kasten
-PLZ;Postleitzahl
-heraus;hervor
-Einstimmigkeit;Einhelligkeit
-passieren (Hauptform);nicht ausbleiben;(sich) ereignen;erfolgen (förmlich);kommen zu (es);vonstatten gehen;(sich) abspielen (ugs.);vorfallen;(sich) zutragen (geh.);(sich) begeben (es) (geh.);geschehen;(sich) tun (ugs.)
-Sale (engl.);Schlussverkauf;Abverkauf;Ausverkauf;Sales (engl.)
-Anfechtung;Verlockung;Versuchung;Verführung
-Auslauf;Auslass
-Eisprung;Ovulation;Follikelsprung
-(oh) Entschuldigung!;nichts für ungut!;ist nicht böse gemeint;war nicht so gemeint (ugs.);war nicht böse gemeint
-hervorragend;extraordinär;eminent;außergewöhnlich;außerordentlich
-Die (engl.);Microchip (engl.);Integrierte Schaltung;Mikrochip;IC (Abkürzung, engl.);monolithischer Schaltkreis;Integrierter Schaltkreis (Hauptform);Integrated circuit (engl.);Chip;Festkörperschaltkreis
-Ungesetzlichkeit;Widerrechtlichkeit;Unrechtmäßigkeit;Illegalität;Gesetzwidrigkeit
-Gräueltat;Schreckenstat;Gewalttat;Schandtat;Freveltat
-Lakritze;Lakritz;Süßholz;Bärenzucker (ugs., österr.);Bärendreck (ugs., schweiz., süddt., österr.)
-wild;hart;grausam;roh
-Rasthaus;Rastplatz;Raststation;Raststätte
-ausgleichen;ausbügeln (ugs.);die Scharte auswetzen (ugs.);wettmachen;ins Reine bringen;verlorenen Boden wettmachen (ugs.);begleichen (Rechnung);aus dem Weg räumen;wiedergutmachen;abgelten
-Weiterentwicklung;verbessertes Modell
-in (ersten) Ansätzen;ansatzweise;halbwegs (ugs.);einigermaßen;im Ansatz;in Grundzügen
-Nichteisenmetall;NE-Metall
-scheffeln (ugs.);zusammentragen;(eine) Sammlung anlegen;anhäufen;zusammenbekommen;sammeln;zusammenscharren (abwertend);raffen;äufnen (schweiz.);zusammenraffen (abwertend);zusammenkriegen (ugs.)
-Treibhaus;Glashaus;Gewächshaus
-Herstellungsjahr;Baujahr
-Polio;Heine-Medin-Krankheit;entzündliche Erkrankung des Rückenmarks;Kinderlähmung;Poliomyelitis (fachspr.)
-Samstag (Hauptform);Schabbat;Satertag (regional);Sabbat;Sonnabend (Hauptform)
-Verkleidung;Schalung;Kasten;Gehäuse
-instanziieren;Instanz erstellen
-Aktivitätsanalyse;Prozessanalyse
-im äußersten Notfall;zur Not;im (absoluten) Notfall;im Ausnahmefall;notfalls;wenn alle Stricke reißen (fig.);wenn es (gar) nicht anders geht;als letzte Möglichkeit
-ausstrecken;(sich) ausdehnen;strecken;(sich) erstrecken
-abgerissen;ausgefranst;zerlumpt
-vertebral (fachspr.);die Wirbelsäule betreffend
-(sich) vorsichtig auf etwas zubewegen;einen Fuß vor den anderen setzen;(sich) allmählich bewegen
-weit verbreitet;alltäglich;die Regel (sein);tägliches Brot (sein);(ein)geübt (fig.);konventionell;man kennt das (von) (ugs., Redensart);an der Tagesordnung (fig.);handelsüblich (fig.);nicht selten;gebräuchlich;üblich;geläufig;zum täglichen Brot gehören;ortsüblich;häufig;normal;klassisch;verbreitet;herkömmlich;gewöhnlich;gängig;gang und gäbe;kein Einzelfall;weitverbreitet
-Stamm;Sippe;Stammesverband;Volksstamm
-Selbsterregung;Eigenerregung
-(sich) zurückhalten;bändigen;(sich) mäßigen;zurückhalten
-Ringbolzen;Splintbolzen
-Auslöser;Impuls;Anstoß;Anregung;Initiierung;Impetus
-Fehlschlag;Erfolglosigkeit
-Assessment (engl.);Evaluation;Einstufung;Evaluierung;Prüfung;Beurteilung;Bewertung
-Leihwagen;Mietwagen;Leihauto;Mietauto
-Unausgewogenheit;Schräge;Einseitigkeit
-Jahreszeit;Saison
-Vereinfachung;Abstraktion;Erkennen des Wesentlichen
-Freskomalerei;Fresko (Maltechnik);Frischmalerei
-Unvergänglichkeit;Immortalität;Unsterblichkeit;Unendlichkeit
-Werkzeugkoffer;Werkzeugkiste;Werkzeugbox;Werkzeugkasten
-Antiselektion;Gegenauslese
-lasch (ugs.);lahm (ugs., fig.);schlapp (ugs.);schlabberig (Händedruck) (ugs., fig.);unentschieden;schlaff;flau
-Exekution;Hinrichtung
-zeitigen;münden (in);zur Folge haben;nach sich ziehen;im Gefolge haben (geh.);hinauslaufen (auf);resultieren (in) (geh.);bewirken;führen zu;mit sich bringen;ergeben
-Revolte;Rebellion;Meuterei;Aufstand;Aufwiegelung;Aufruhr
-Blutader;Ader;Blutgefäß;Gefäß
-Altersgliederung;Altersaufbau
-Bar-Code-Leser;Strichcode-Lesegerät;Strichcodeleser
-Beilagscheibe (bayr., veraltend, österr.);Unterlagsscheibe;Zwischenscheibe;Unterlegscheibe
-als Reflex ablaufend;reflektorisch
-Abstellgleis;Seitengleis
-Zutritt;Zugang;Eintritt;Einlass
-Mikrocomputertechnik;Microcomputertechnik
-Festveranstaltung;Gala;Galaveranstaltung;Festlichkeit;Festivität
-Dekorateur;Schaufensterdekorateur
-Tortur;Hölle (ugs.);Qual;Strapaze;Quälerei;Agonie;Pein
-ersetzen;ablösen;substituieren;transferieren;tauschen;auswechseln;austauschen
-Gemination;Konsonantenverdoppelung
-einklammern;in Klammern setzen
-nachhaltig;auf Dauer;für (eine) längere Zeit;längerfristig;langfristig;für (eine) lange Zeit;für einen langen Zeitraum;für einen längeren Zeitraum;nicht nur für (ein paar Tage);auf lange Sicht;für länger (ugs.)
-Abschrägung;Fase;Schräge;Schrägkante;abgeschrägte Kante;Schrägfläche
-(Code) knacken;decodieren;entschlüsseln;dekryptieren;dechiffrieren;enträtseln;lesen;dekodieren;entziffern
-unduldsam (geh.);bockig;stur wie ein Esel;störrisch (Hauptform);stur wie ein Bock;dickschädelig;dickköpfig;trotzig;unfügsam;widerspenstig;widerborstig;widersetzlich;(ein) sturer Bock (sein);bockbeinig
-Stalaktit;hängender Tropfstein
-jeweils (Hauptform);immer;jedes Mal (wieder)
-Bellis perennis (fachspr., botanisch, griechisch, lat.);Ausdauerndes Gänseblümchen (fachspr., botanisch);Margritli (schweiz.);Tausendschönchen;Gänseblümchen (Hauptform);Mehrjähriges Gänseblümchen;Maßliebchen;Monatsröserl
-Schwemme;Übersättigung;Überangebot (an)
-Zugriffsdauer;Zugriffszeit
-anbringen;hinzufügen
-eine Wand betreffend;parietal
-Typ;Regel;Norm;Grundsatz
-invasiv;eingreifend;eindringend
-klagen (über);weinen (um);(jemanden) beweinen;trauern (um);(den Verlust einer Person) beklagen;trauern (über);bejammern;betrauern;klagen (um)
-Meisterstück;Meisterwerk
-Kompetenzkonflikt;Kompetenzstreitigkeit
-Desaster;Katastrophe;Armageddon;Havarie;Inferno
-Isthmus;Landbrücke;Landenge
-unverkäuflich;unveräußerlich
-den Augapfel betreffend;orbital (fachspr.)
-Außenwirtschaft;Auslandshandel;Außenhandel
-Wettrennen (um);Lauf;Wettlauf;Rennen;Wettlaufen
-Näherungsverfahren;Annäherungsverfahren;iteratives Verfahren;Iterationsverfahren
-Absurdität;Irrwitz;Wahnwitz;Hirnverbranntheit;Hirnrissigkeit;Widersinnigkeit;Aberwitz;Unding;Unsinnigkeit
-Kurs;Rundkurs;Rennbahn
-Ausrottung;Massenvernichtung;Holocaust;Austilgung;Genozid;Massenmord;Exterminierung;Völkermord (Hauptform)
-Abzehrung;(starke) Gewichtsabnahme;Auszehrung;Abmagerung;(starker) Gewichtsverlust
-KL;Konzentrationslager;Schutzhaftlager (veraltet);KZ
-Muskelrelaxans (fachspr.);muskelentspannendes Mittel;Myotonolytikum (fachspr.)
-huren;(sich) prostituieren (Hauptform);auf den Strich gehen;(sich) öffentlich preisgeben;anschaffen (gehen) (ugs.);(sein) Geld auf der Straße verdienen (verhüllend);Liebesdienste leisten;es für Geld tun (ugs.);(seinen) Körper verkaufen;(sein) Geld als Sexarbeiter(in) verdienen (variabel)
-polizeiliches Kennzeichen;amtliches Kennzeichen
-);Klammer zu;schließende runde Klammer
-Braun'sche Röhre;Oszilloskop;Braunsche Röhre
-krampflösend;spasmolytisch (fachspr.);entkrampfend
-festlegen;beschließen;stipulieren;entscheiden;verankern;vereinbaren;bestimmen;befinden (geh.);festschreiben;determinieren
-männlicher Elternteil;Vati (ugs.);Papi (ugs.);alter Herr (geh.);Senior (geh.);Papa (ugs.);der Alte (derb);Erzeuger (auch ironisch) (Amtsdeutsch);Vater (Hauptform);Daddy (ugs.);Alter (ugs.);Kindsvater;Pa (ugs.);Paps (ugs.);Dad (ugs.)
-(Geld) zurückgeben;begleichen;erstatten;ausgleichen;zurückzahlen;bezahlen;abgelten;retournieren (österr.);rückvergüten;zurückbezahlen
-schimmernde Wehr (heute ironisierend oder distanzierend) (geh.);Truppe;Barras (ugs.);Armee;Streitkräfte;Wehr;Streitmacht;Militär
-Armierung;Bewehrung;Rüstzeug;Bewaffnung;Ausrüstung
-anschirren;aufzäumen (Pferd)
-frei stehend;freistehend;auf freier Fläche
-Ehrbarkeit (Zimmermann) (fachspr.);Langbinder;Binder;Schlips;Halsbinder;Krawatte (Hauptform)
-nährstoffreich;reichhaltig;nahrhaft;nährend;mächtig (ugs.);kalorienreich;gehaltvoll;sättigend
-rechtmäßig;gerechtfertigtermaßen;billigermaßen (veraltet);erlaubterweise;richtigerweise;mit Fug und Recht (ugs.);gerechtfertigterweise;aus gutem Grund;füglich (geh., veraltet);zu Recht;nicht ohne Grund;legitimerweise;billigerweise (veraltet);mit Recht;korrekterweise;berechtigterweise
-steif;starr;rigide;statisch;bewegungslos;unveränderlich;unbeweglich;immobil;feststehend
-World Wide Web (engl.);WWW (Abkürzung, engl.);Netz (ugs.);Internet (ugs.);Web (Kurzform, engl.)
-Bodenkultivierung;Bodenbebauung;Bodenbestellung;Bestellung
-Mangelhaftigkeit;Schadhaftigkeit
-Fensterbrett;Fenstersims;Fensterbank
-weiterleiten;weitergeben;durchgeben;übergeben;teilen (soziales Netzwerk) (Neologismus)
-Anblick;Ansicht;Aussicht;Blick;Ausblick;Sicht
-Parlando (geh.);Sprechgesang;Rap
-Zahnlaut;Dental;Dentallaut
-(sich) trauen;(sein) Glück herausfordern;es darauf ankommen lassen (ugs.);(sich) auf dünnem Eis bewegen (fig.);(ein) Wagnis eingehen;auf schmalem Grat wandern (fig.);(sich) aus dem Fenster lehnen (ugs., fig.);(etwas) riskieren;Risiken eingehen;(ein) Risiko auf sich nehmen;(ein) Risiko eingehen (Hauptform);(etwas) wagen;ganz schön mutig sein (ugs.);es auf einen Versuch ankommen lassen;(sein) Schicksal herausfordern;(sich) wagen (an);mit dem Feuer spielen (fig.);es wissen wollen;mutig sein
-durchbohren;aufspießen
-Element;Teil;Glied;Bestandteil;Komponente;Modul
-Binder;Beschlag;Grundstoff
-Voliere;Aviarium (geh., lat.);Vogelhaus
-optional;fakultativ (Hauptform);wahlweise;bedarfsweise;wahlfrei;(je) nach Wunsch;nach eigenem Ermessen;nach eigenem Belieben
-Stehbildkamera;Knipse (ugs.);Fotokamera;photographischer Apparat;Kamera;Fotoapparat
-anordnen;aufzwingen;(über etwas) befinden;diktieren;vorgeben;bestimmen;veranlassen;verordnen;verfügen;entscheiden;regeln;vorschreiben;anweisen;festlegen
-aufsummieren;summieren;zusammenzählen;aufschlagen (fachspr.);aufaddieren;addieren
-Flügel;Konzertflügel
-bausteinförmig;modular
-reifen;gären;vergären;fermentieren
-A-Bombe;Nuklearbombe;Atombombe;Nuklearwaffe;Kernwaffe;die Bombe (ugs.)
-Nachfolger Petri;Kirchenfürst;Stellvertreter Gottes;Papst (Hauptform);Kirchenoberhaupt (der katholischen Kirche);Bischof von Rom;Stellvertreter Christi auf Erden;Seine Heiligkeit (Ehrentitel);Pontifex (ugs., lat.);Heiliger Vater;Gottes Stellvertreter (auf Erden);Pontifex Maximus (ugs., lat.);Eure Heiligkeit (Anrede)
-hudelig (ugs.);nebenbei;flüchtig;oberflächlich;ungeniert (ugs.);nonchanlant (ugs.);leichthin;nachlässig;obenhin;unaufmerksam;hudlig (ugs.);mal eben
-ausspreizen;ausstrecken
-gelöst;wacklig;(zu viel) Spiel haben;klapprig;klapperig;locker;wackelig;Luft haben;lose
-Museumsstück;Ausstellungsstück;Exponat (fachspr.)
-Querstange;Raa;Rahe;Rah
-hilfsweise;behelfsmäßig;provisorisch;probeweise;notdürftig;nicht vollwertig;aushilfsweise;ersatzweise;improvisiert;behelfsweise
-Werbespruch;Schlagwort;Slogan (Hauptform);Spruch;Claim (werbesprachlich) (fachspr., Jargon, engl.)
-dumm (von jemandem) (ugs.);unklug;töricht;gedankenlos;unvernünftig;unüberlegt;unvorsichtig;ungünstig;nicht zu Ende gedacht;wenig bedacht
-Querverweis;Link;Hyperlink;Verknüpfung
-Kabel;Leitung
-Tunika;Chiton;Tunica
-Abzug;(das) Abziehen;(das) Minus-Rechnen;Subtraktion
-erlauben;sanktionieren (fachspr.);gewähren;möglich machen;legalisieren (juristisch);lassen;gestatten;den Weg freimachen (fig.);autorisieren;bewilligen;den Weg frei machen (fig.);(eine) Möglichkeit schaffen;zulassen;ermöglichen;lizenzieren
-Risikobereitschaft;Mut;Wagemut;Beherztheit;Waghalsigkeit
-Betätigung;Tätigkeit;(das) Wirken
-zusammenwirkend;kooperativ;zusammenarbeitend;kollegial
-feindselig;spinnefeind (Verstärkung);feindlich gesinnt (gegen) (geh.);hasserfüllt;phobisch (fachspr.);übelwollend;verfeindet;unversöhnlich;von Hass erfüllt;animos (geh., lat.)
-Riege;Turnriege
-Teilmontage;Unterbaugruppe
-prägen;münzen
-Wiederbelebung;Revival (engl.);Erweckung
-Vorzüglichkeit;Vortrefflichkeit;Trefflichkeit;Brillanz
-anheften;anklammern
-Nachgeburt;Mutterkuchen (ugs.);Plazenta (fachspr.)
-Laken;Betttuch;Bettlaken;Leintuch (regional);Leinen;Linnen (veraltet)
-Kellerwirtschaft;Weinlehre;Weinkunde;Önologie
-ans Telefon gehen;(d)rangehen (ugs.);(den) Hörer abnehmen;(ein) Gespräch annehmen;(den) Hörer aufnehmen;abheben (Hörer des Telefons);(einen) Anruf entgegennehmen
-Anisokorie (fachspr.);ungleiche Weite der Pupillen
-Ritterstand;Ritterschaft
-amalgamieren (geh., bildungssprachlich, fig.);verschmelzen (mit);aufgehen lassen (in)
-Valenz;Wertigkeit;Stelligkeit
-Akzeptanz;Wohlwollen;Zustimmung;Bejahung;Entgegenkommen;Zuspruch
-Fabrik (Hauptform);Fertigungsanlage;Betrieb;Werk
-sperren;zeitweilig ausschließen
-Block;Klotz
-Merkliste;Buchzeichen;Zeichenband (fachspr.);Lesemarke;Leseband;Leselitze (geh.);Lesezeichen (Hauptform);Lesebändchen (ugs.);Bookmark
-Unsittlichkeit;Sittenlosigkeit;Unmoral
-Warenangebot;Range (fachspr.);Leistungsportfolio (fachspr., Jargon);Produktportfolio (fachspr., Jargon);Produktauswahl;Produktsortiment;Produktpalette;Angebotsportfolio (fachspr., Jargon);Leistungsspektrum;Produktangebot;Angebotsspektrum (fachspr., Jargon);Auswahl;Leistungsangebot;Sortiment;Warensortiment (Hauptform);Angebotsvielfalt;Warenspektrum
-Töpferei;Tonware
-friedlich;versöhnlich;friedfertig;herzensgut;pazifistisch;gutmütig
-Gleichklang;lautliche Übereinstimmung;Gleichlaut
-Pacht;Mietzins;Miete
-impulsiv;unbeherrscht;reizbar;ungeduldig;genervt;ungehalten (geh.);ungezügelt;fuchsteufelswild (ugs.);grantig (ugs.);aufbrausend;wütend;wutentbrannt;leicht erregbar;cholerisch;zornig;exzitabel (fachspr., lat., medizinisch);unkontrolliert;hitzköpfig;tobsüchtig;jähzornig;rasend;aggressiv;zügellos;furibund (fachspr., lat., veraltet)
-Bestreitung der Glaubwürdigkeit;Bestreitung der Gültigkeit;Anfechtung
-Totmacher (kindersprachlich) (ugs.);Mörder (Hauptform);Mordbube (veraltet);Killer
-(jemanden bei sich) aufnehmen;(jemanden bei sich) einquartieren;(jemanden bei sich) wohnen lassen (ugs.);(jemanden) unterkriegen (ugs.);(jemandem) Quartier geben;(jemanden) beherbergen;(jemanden) unterbringen
-rücksichtslos behandeln;schlecht umgehen (mit);schlecht behandeln
-Personalien;Ausweis;Lichtbildausweis;Identifikationskarte;Ausweispapiere;Papiere (ugs.)
-kapern (fig.);absahnen (ugs.);(sich) reinziehen (ugs.);(ungerechtfertigterweise) in seinen Besitz bringen;erbeuten;an sich bringen;an sich nehmen;(sich) greifen (ugs.);(sich) unter den Nagel reißen (ugs.);einstreichen (ugs.);(sich) einverleiben;abstauben (u.a. Sport) (ugs.);(sich an etwas) gesund stoßen (ugs.);(sich) schnappen (ugs.);erjagen;einheimsen;abgreifen (ugs.);zugespielt bekommen;(sich) (ungerechtfertigterweise) aneignen;(sich) an Land ziehen (ugs.);(sich) zueignen (juristisch);(sich) krallen (ugs.);(sich) gönnen (ugs.);einsacken (ugs.);(sich) reinpfeifen (ugs.);(sich) grabschen (ugs.)
-Aufnahmespule;Aufwickelspule
-Personalreferat;Personaldezernat
-gottgefällig;frömmlerisch (abwertend);gottergeben;fromm;gottesfürchtig
-Flüstern;Raunen;Geflüster;Getuschel;Geraune;Murmeln;Gemunkel
-Rutsche;Rinne;Rutschbahn
-Maßstab;Messlatte (ugs.);Skala
-Eidotter;Dotter
-Gartenhäuschen;Gartenpavillon (gebaut);Gartenlaube;Laube;Pavillon;Salettl (süddt.)
-hell erleuchtet sein;im Lichterglanz erstrahlen;illuminiert
-beschlagen;verzieren
-blank;leer
-zerfleischen;verstümmeln
-glätten;polieren;abschleifen
-Vorlage;Template (engl.);Schablone
-in groben Zügen;in großen Zügen;vereinfacht gesagt;umrisshaft;grob gesagt;mit einfachen Worten
-aus sein (ugs., süddt., österr.);nicht mehr am Lager (Kaufmannsspr.) (fachspr., Jargon);is nich (mehr) (ugs.);alle sein (ugs., bundesdeutsch);ham wer nich (ugs., Jargon);(da) ist nix mehr von da (ugs., ruhrdt.);fertig sein (ugs., schweiz., westösterreichisch);(sich) erschöpft haben;nicht mehr auf Lager;aufgebraucht sein;(von etwas) ist nichts mehr da (ugs.);gar sein (ugs., bayr., ostösterreichisch)
-Flur;Waldwiese;Lichtung
-Zugriffshilfe;Zugangshilfe
-Kirschkernbeißer;Kernbeißer
-Abänderungsantrag;Ergänzungsantrag
-quantitativ;mengenmäßig;zahlenmäßig
-Ramsch (ugs.);Trash;Schund;Kitsch;geschmackloser Gegenstand
-Überschwang;Überschwänglichkeit;Ausgelassenheit;Überschwall;Übermut
-Energieumwandler;Umsetzer;Umwandler
-matschig;schlammig;morastig;sumpfig
-die Netzhaut betreffend;retinal (fachspr.)
-wieder schreibbar;wieder beschreibbar
-(frei) von der Leber weg;unverhohlen;frei heraus;frank und frei;rundheraus;unverblümt;ungeniert;einfach drauflos (ugs.);auf gut Deutsch (ugs., fig.);frei zum Munde heraus (ironisch altertümelnd) (geh.);geradeheraus;offen;ohne Hemmung;(so) wie (jemandem) der Schnabel gewachsen ist
-erwerben;erlernen;(sich) zu eigen machen;(sich) draufschaffen (ugs., salopp);(sich) Wissen aneignen;lernen (Hauptform);(sich) aneignen
-Auswirkung;Beeinflussung
-gewissenlos;ohne Gewissen;skrupellos
-auslagern;außer Hauses geben (geh., selten, veraltend);außer Haus erledigen lassen (von);vergeben (an);verdingen (an);outsourcen
-Flugplatz;Sonderlandeplatz (fachspr.);Aerodrom (fachspr., griechisch, veraltet);Flugfeld (schweiz., österr.);Flughafen (Hauptform);Lufthafen (fachspr., selten, veraltend);Verkehrsflughafen;Luftverkehrszentrum;Airport (ugs., engl.);Verkehrslandeplatz (fachspr.)
-gesucht (sein);attraktiv;begehrt (sein);Konjunktur haben;Hochkonjunktur haben;gefragt (sein)
-kreisförmig;rund;zirkulär;kreisrund
-Bildlegende;Bildunterschrift;Legende
-Krankenversicherung;Knappschaft (veraltet);Krankenkassa (österr.);Krankenkasse (Hauptform);Gesundheitskasse (euphemistisch)
-Mitgefühl empfinden;Mitleid haben (mit);mitfühlen (mit);Anteil nehmen (an)
-Axiom (fachspr.);Annahme;Vorannahme;Voraussetzung;Grundlage;Grundannahme;Grundwahrheit;Kondition;These;Grundvoraussetzung;Grundsatz;Kriterium;Prämisse;Bedingung;Vorbedingung;Notwendigkeit
-spinal (fachspr.);Wirbelsäule bzw. Rückenmark betreffend
-säumen;grenzen (an)
-Kollektor;Sammel-Elektrode;Sammler
-Skrupel haben;Bedenken haben;Bedenkenträger sein
-cand. (Abkürzung);Kandidat (Prüfungsanwärter)
-allerdings!;in der Tat;das ist allerdings richtig;wohl wahr;stimmt allerdings;fürwahr (geh., veraltend);durchaus zutreffend;gewiss
-Winde;Spill;Laufkatze
-Bündel;Ballen
-Schweifstern;Komet (Hauptform);Meteor;Irrstern
-einkochen;einmachen;einwecken
-Bedrängnis;Enge;Platzmangel;Gedrängtheit
-Zeichenabtastung;Schriftlesen
-laufende Nummer;lfd. Nr.
-Spießigkeit (Hauptform);Kleingeistigkeit;Spießertum;Piefigkeit;Miefigkeit
-Boche (derb, franz.);Deutscher (Hauptform);Gummihals (derb, schweiz.);Germane (ugs., scherzhaft-ironisch);Bio-Deutscher (ugs., Jargon);Piefke (derb, österr.);Inländer;Kraut (derb, engl.);Mof (niederl.) (derb);Teutone;Fritz (engl. mil., veraltend) (derb);Preiß (ugs., bayr.);Saupreiß (derb, bayr.)
-Oppositioneller;Oppositionsabgeordnete;Oppositionspolitiker
-kräftig;körperlich leistungsfähig
-Erlebnis;Erfahrung;Erleben
-Ergebener;Gefolgsmann (männl.);Getreuer
-Umleitung;Umlenkung;Abstecher (ugs.);Umweg;Schlenker (ugs.)
-Zeit;Uhrzeit
-vorwärts treibend;forttreibend;propulsiv
-Trockentest;Testballon (fig.);Studie;Probelauf;Experiment;Versuch;(die) Probe aufs Exempel;Test;Trockenlauf;Versuchsballon (fig.);Testlauf
-Sammelauftrag;Sammelbestellung
-öffentliches Interesse;öffentlicher Belang
-Verantwortlichkeit (Hauptform);Verantwortung;Rechenschaftspflichtigkeit
-Zeiger;Zeigestock
-Bitimpuls;Rechteckimpuls
-UNICRI;Internationales Forschungsinstitut der Vereinten Nationen für Kriminalität und Rechtspflege
-erwerbsunfähig;dienstuntauglich;invalid(e);(auf Dauer) arbeitsunfähig
-Untauglichkeit;Unvermögen;Inkompetenz;Unfähigkeit
-Watte;Verbandwatte
-Zirkular (geh.);Nachricht an alle (ugs.);Rundbrief;Rundschreiben;Kurrende (österr.)
-Speer;Spieß;Wurfspieß (ugs.);Lanze;Wurfspeer;Ger
-EU (Abkürzung);Europäische Union
-Rechenkunde;Mathematik;Rechnen (ugs.);Mathe (ugs.)
-Rang und Namen haben;von Rang und Namen (ugs.);prominent;prestigevoll;prestigeträchtig;bekannt;hochgestellt;namhaft;von Rang (geh.);reputabel;berühmt
-zerren;zerreißen;reißen;aufreißen
-Zugpferd (fig.);treibende Feder;Triebkraft;treibende Kraft;Triebfeder (fig.);Zugmaschine (fig.);Motor (fig.);Treibkraft
-Windschutzscheibe;Frontscheibe
-Spinner;Sonderling;wunderlicher Kauz;Exzentriker (geh.);seltsamer Heiliger (ugs.)
-Einhelligkeit;Einigkeit;Einvernehmen;Konformität;Zustimmung;Konsensus;Konsens (fachspr.);Einklang;Übereinkommen;Übereinstimmung;Harmonie;Gleichgestimmtheit;traute Harmonie (geh., ironisch);Konformismus;Einstimmigkeit;Eintracht;Einmütigkeit
-Ungebundenheit;Unabhängigkeit;Freiheit;Ungezwungenheit;Independenz (fachspr.)
-Verteilung;Austeilung;Distribution
-heranrücken;nahen;(die) Zeichen stehen auf (...) (geh., variabel);im Anmarsch sein (fig.);im Anzug sein;näher rücken;heraufdämmern (geh.);drohen;im Verzug sein;(sich) ankündigen;(auf jemanden) zukommen;es mehren sich die Zeichen (dass) (geh.);in der Luft liegen;zu erwarten stehen;heraufziehen;seine Schatten vorauswerfen;(sich) andeuten;ins Haus stehen;herannahen;(sich) abzeichnen;(sich) anbahnen;(etwas) ist im Busch (ugs., fig.);knistern im Gebälk (es);aussehen nach;heranziehen;erwarten lassen;abzusehen sein
-sicher sein;feststehen;außer Zweifel stehen;definitiv sein;keinem Zweifel unterliegen (geh.)
-Längsschnitt;Durchschnitt;Mittelmaß;Profil;Breitenmaß;Querschnitt;Quere
-ablecken;abschlecken;lecken;ablutschen;lutschen;abschlabbern (ugs.);schlecken
-Zeichen;Alphazeichen;Charakter;Buchstabe (Hauptform);alphabetisches Zeichen;Letter
-subsumieren;konzentrieren;verdichten;zusammenfassen;unterordnen
-Sozialfürsorge;(soziale) Grundsicherung;Stütze (ugs.);Sozialhilfe
-ausglühen;rösten;brennen;glimmen;kokeln (ugs.);glühen;schmoren
-Arbeitssoll;Arbeitsbelastung;Arbeitspensum;zu leistende Arbeit;Arbeitsbeanspruchung;Aufgabenpensum;Arbeitslast
-zuvortun;ausstechen
-Balkenkopf;Widerlager;Stützpfeiler;Gewölbepfeiler;Stütze
-müßig;untätig;Ruhe...
-Hauptgesims;Balken;Gebälk
-Insider;Esoteriker (fachspr., Jargon);Eingeweihter;Kenner
-Wachstum;Steigerung;Erhöhung;Anstieg;Zunahme;Zuwachs
-Urbarmachung (von Boden);Nutzbarmachung;Kultivierung
-besonders;speziell;in Sonderheit (geh., veraltet);im Besonderen;gerade (ugs.);namentlich;im Speziellen;insbesondere
-strittiger Punkt;heikler Punkt;strittige Frage;Juckepunkt (ugs.)
-Ausscheid (regional);(...) Spiele;Championship;Wettkampf;Ausscheidung;Ausscheidungskampf;Meisterschaft;Contest;Championat;Ausscheidungswettkampf;Turnier;Wettbewerb;Cup
-Spießgeselle (negativ);Scherge (negativ);Kumpan (negativ);(Name) und Konsorten (abwertend);Komplize (negativ)
-Tonfrequenz;Niederfrequenz (NF)
-Kathedralkapitel;Domstift;Domkapitel
-Verflüchtigung;Transpiration;Evaporation (fachspr., lat.);Verdunstung
-Frostgefühl;Kältegefühl;Frösteln
-Schuldschein;Pfandbrief
-Seeschlagblende;Luke zum Lichteinlassen (Schiff)
-Login;Anmeldevorgang;Zugang
-harmonisch;einhellig;im Einklang;einträchtig;einstimmig;einmütig;einig;einvernehmlich;geschlossen;gleichgesinnt;einverständlich;brüderlich;friedlich;im Gleichklang
-Vorführungssaal;Ausstellungsraum
-hypothetisch;zweifelhaft;ungesichert
-Besiedelung;Kolonisation;Kolonisierung;Besiedlung;Landnahme;Ansiedlung
-Knall;Schlag
-Spielführer;Mannschaftsführer;Mannschaftskapitän
-Seitigkeit;Lateralisation
-Engagement;Hingabe;Einsatz;Eifer;Tatendrang;Schaffensfreude;Hingebung;Inbrunst (geh.)
-Megaphon;Megafon;Sprachrohr;Flüstertüte (ugs.)
-Argwohn;Misstrauen;Verdacht
-Gejammer;Klagegesang;Wehgeschrei;Wehklagen;Klagelied(er);Jammer;Lamento (ugs.);Klage
-Sternensystem;Sternsystem
-hochgehen wie eine Rakete (ugs.);die Nerven verlieren;aus der Haut fahren (ugs.);vor Wut schäumen (ugs., fig.);abspacen (ugs.);einen Rappel kriegen (ugs.);austicken (ugs.);einen Tobsuchtsanfall kriegen (ugs.);ausrasten (ugs.);ausflippen (ugs.);die Beherrschung verlieren;Gift und Galle spucken (ugs.);explodieren (fig.);(einen) Wutanfall bekommen (Hauptform);abgehen (ugs.);auszucken (ugs., österr.);herumwüten;(sich) vergessen;außer sich geraten;durchdrehen (ugs.);an die Decke gehen (ugs., fig.)
-(sich) ein ... Mäntelchen umhängen (ugs., fig.);nur so tun;so tun als wäre man (...);(sich) verstellen;so tun als ob (Hauptform);markieren (ugs.);(sich) geben;(etwas) heucheln;machen auf (ugs.);so tun als sei man (...) (geh.);(eine) Show abziehen (ugs.);(sich) zeigen (+ Adjektiv);(überrascht / unschuldig / schüchtern / vornehm ...) tun;simulieren;vortäuschen;vorgeben (etwas zu sein);schauspielern;sich (irgendwie) stellen
-Hautschuppe;Schuppe;Kopfschuppe
-hundsgemein (ugs.);charakterlos;schofelig (ugs., rheinisch);niederträchtig;falsch (ugs.);tückisch;biestig;schofel (ugs.);heimtückisch;hinterhältig;hinterfotzig (derb);link (ugs.);gemein;schurkisch;durchtrieben
-in Faktoren zerlegen;ausklammern
-nichts Wahres dran (ugs.);unwahr;wahrheitswidrig;gelogen;unrichtig;falsch
-Barracuda;Pfeilhecht
-unkompliziert;unproblematisch;geschenkt (ugs.);einfach;leicht;simpel;leicht verständlich;banal
-Entgegenkommen;Mildtätigkeit;Indulgenz;Gütigkeit;Güte;Liebenswürdigkeit;Herzlichkeit;Herzensgüte;Freundlichkeit;Warmherzigkeit;Wohlwollen;Milde;Wärme
-Tüchtigkeit;Fleiß;Eifer;Emsigkeit;Beflissenheit
-miserabel;abgründig;abgrundtief;entsetzlich
-schlau;klug;gewieft;blitzgescheit;mit scharfem Verstand;verständig;aufgeweckt (ugs.);gescheit;scharfsinnig;intelligent
-Schreitroboter;Laufroboter
-Kindergärtnerin (veraltet, weibl.);Erzieherin (Kindergarten) (weibl.);Kindergärtner (männl., veraltet);Erzieher (Kindergarten) (männl.)
-schiffen;steuern (See und Luft)
-Reuegefühl;Selbstanklage;Zerknirschung;Bedauern;Bußfertigkeit;Reue;Zerknirschtheit;Reumütigkeit
-Amazonas-Sotalia;Tucuxi
-zu Papier bringen (auch figurativ);aufs Papier bringen (ugs., auch figurativ);aufschreiben;zu Protokoll bringen;textlich erfassen;schreiben (Hauptform);texten;verfassen;notieren;abfassen;ausstellen (amtliches Dokument);protokollieren;dokumentieren;Protokoll schreiben
-müde;energielos;schwach;schwachbrüstig
-auf der Hut (ugs.);mit Vorsicht;auf dem Quivive (ugs., franz.);achtsam (geh.);behutsam;vorsichtig;sorgfältig;mit Bedacht;sorgsam;sacht(e);sachtemang (ugs., berlinerisch)
-Faktor;Konstellation;Fall;Gegebenheit;Umstand (Hauptform);Rahmenbedingung;Faktum;Tatsache
-stumpfes Schwert (fig.);bringt nichts (ugs.);verlustreich;wirkungslos;nutzlos;vergeblich;unwirksam;fruchtlos;frustran (fachspr.);erfolglos;kann man sich schenken (ugs.);ineffektiv;verluststark
-Auftragsabwicklung;Jobabwicklung
-entartet;verkommen;dekadent;volksfremd (Jargon);degeneriert
-Amenorrhöe (fachspr.);Ausbleiben der Regelblutung;Amenorrhö (fachspr.)
-vor Augen stellen;konfrontieren;entgegenstellen;gegenüberstellen
-Fahne (zum Befestigen);Nase;Öse
-Irrtum;Inkorrektheit;falscher Fehler (ugs., scherzhaft);Fehler (Hauptform);Fauxpas (geh., franz.);Ausrutscher (ugs., fig.);Patzer (ugs.);Versehen;Missgriff;Schnitzer (ugs.);Lapsus (geh., lat.)
-Richtkosten;Sollkosten;Plankosten
-Atavismus;Rückfall in ein primitiveres Stadium;Rückschlag (veraltet);Entwicklungsrückschlag
-Steifigkeit;Rigidität;Mangel an Elastizität;Starrheit;Unbeugsamkeit;Steifheit;Inflexibilität
-Pauschalbetrag;Pauschalsumme
-Gelbwurz;Mülleringwer;Indianischer Safran;Gelbsuchtswurz;Tumerik;Kurkuma;Curcuma;Gilbwurzimber;Turmarik;Kurkume;Gilbwurtzel;Safranwurzel;Gilbwurzel;Gurkume;Gelber Ingwer;Gelbwurzel;falscher Safran;Curcuma longa (fachspr.);Gurkumey;Babylonischer Safran;Safranwurz;Gilbwurz
-Flugkrankheit;Luftkrankheit
-bullös (fachspr.);blasig
-Härte;Rauheit
-vordatieren;vorausdatieren
-Gehrungsschneidlade;Gehrungslade
-Abnehmer;Kunde;Käufer (Hauptform)
-Spaziergang;Gang;Bummel
-Maßeinteilung;Skala;Gradeinteilung
-Sackgasse;ausweglose Situation;Deadlock-Situation;toter Punkt;Deadlock
-Rezept;Kochrezept
-Entbindungspfleger (fachspr., männl.);Geburtshelferin;Hebamme;Entbindungspflegerin (fachspr.)
-unterteilen;untergliedern;herunterbrechen (ugs.);aufgliedern;segmentieren;aufschlüsseln;kategorisieren;aufspalten
-strecken;dehnen;ausstrecken;rekeln;recken
-mit der Zeit;zizerlweis (ugs., bayr., österr.);nach und nach;schrittweise;peu à peu (franz.);graduell;sukzessive;langsam aber sicher (ugs.);zögernd;sukzessiv;allmählich;mählich (geh., veraltend);langsam langsam (ugs.);ratenweise
-beteiligt sein;partizipieren;teilhaben;Anteil haben;mit am Tisch sitzen (fig.);mit ins Boot geholt werden (fig.);teilnehmen;mit ins Boot genommen werden (fig.)
-Führung;Leitung;Regie;Schirmherrschaft;Patronanz (österr.);Präsidium;Obhut;Protektorat (geh.);Ägide;Regentschaft
-diskontinuierliche Vielgestaltigkeit;Polymorphie (fachspr.);Polymorphismus (fachspr.);Heteromorphie (fachspr.)
-Gipfel;Zinne;Spitze
-Widersprüchlichkeit(en);Uneinigkeit;Missverhältnis;Nichtübereinstimmen;Ungereimtheit(en);Verschiedenheit;Misshelligkeit;Unstimmigkeit(en);Nichtübereinstimmung;Abweichung;Unterschied;Inkonsistenz (geh.);Widerspruch;Diskrepanz
-Kompensator;Expansionsmuffe
-verstärken;stärken;bestärken
-rappeln;knattern;prasseln (Regen, Hagel);klappern;rattern;klackern;rasseln;scheppern
-Ultrahochfrequenz;UHF
-Explosion;Detonation;Schlag
-Hautpilz;Tinea (fachspr.);Dermatophytie (fachspr.);Pilzerkrankung der Haut;Dermatomykose (fachspr.);Dermatophytose (fachspr.)
-unschätzbar;(sehr) wertvoll;nicht mit Gold aufzuwiegen (fig.);nicht mit Geld zu bezahlen (fig.);unbezahlbar (Hauptform);nicht mit Geld aufzuwiegen (fig.);Gold wert sein (fig.);von unschätzbarem Wert
-Podiumsdiskussion;Diskussionsrunde;Forum
-Aufruf (zu);Appell (an);Bittruf;Mahnung (zu);Aufforderung
-einen Druck setzen (derb);spritzen;einspritzen;injizieren
-Uboot (fachspr.);Unterwasserboot;U-Schiff;Tauchboot;U-Boot (Hauptform);Unterseeboot
-Gitterwerk;Flechtwerk
-Stückakkord;Akkordarbeit;Akkord;Fließbandarbeit (auch figurativ)
-Persona ingrata (geh., lat.);ungewünscht;nicht (mehr) gern gesehen;ungebeten;in Ungnade gefallen (geh.);(sich) (irgendwo) nicht mehr blicken lassen können;unerbeten;unerwünscht;unwillkommen;ungewollt;auf der schwarzen Liste (stehen) (ugs., fig.);ungern gesehen;Unperson;fünftes Rad am Wagen (ugs.);Persona non grata (geh.);nicht (mehr) gerngesehen;das fünfte Rad am Wagen (ugs.);nicht willkommen
-missmutig;querulantenhaft;querulantisch;angesäuert (ugs.);maulig (ugs.);nörglerisch;gefrustet (ugs.);grämlich (geh., veraltend);genervt;quengelig;unruhig
-Zeitunterschied;Zeitverschiebung
-(ziellos) rumlaufen (ugs.);herumstreunern (ugs.);herumvagabundieren;stromern;(sich) herumtreiben (ugs.);vagabundieren;herumstreunen;herumstrolchen;(ziellos) herumlaufen (Hauptform);strolchen;herumziehen;herumstromern;um die Häuser ziehen;frei schweifen;streunen;(sein) Unwesen treiben
-luv;windwärts
-Muffe;Hülse;Manschette
-Rücklage;Vorrat;Repositorium (fachspr.);Speicher;Reserve;Lager;Reservoir
-Almerin;Milchmädchen;Sennerin
-Trosse;elastisches Tau;Kabeltau
-nicht viel Zeit vertrödeln (mit);nicht viel Federlesen(s) machen (ugs.);kurzen Prozess machen;(sich) nicht mit Kleinigkeiten aufhalten (fig., variabel)
-Patient mit Rezidiv;Rückfallpatient
-gleichfarbig;isochromatisch;isochrom
-strähnig;fadenförmig;fusselig;flaumig;faserig
-Begünstigter;Gesponserter;...empfänger;Benefizient (fachspr., Sprachwissenschaft);Benefiziant;Zuwendungsempfänger (fachspr., juristisch);Nutznießer;...bezieher;Empfänger (einer institutionellen Leistung)
-Kundgebung;Protestation (geh., veraltet);Demo (ugs.);Protest;Protestzug;Demonstration;Protestmarsch;öffentliche Protestaktion
-Somatropin;Growth Hormone (engl.);Wachstumshormon;Somatotropin;Human Growth Hormone (engl.);Somatotropes Hormon;HGH (Abkürzung, engl.);STH (Abkürzung)
-sanft;gütlich;gütig;ohne Gewalt;friedliebend;geruhsam;friedlich;friedfertig;herzensgut;gewaltlos;gewaltfrei;amikal;verträglich
-achtunggebietend;Respekt einflößend;herrisch;gebieterisch
-Mietleitung;Standleitung
-Job (als);Profession (geh.);Beruf
-(einer Sache) Nachdruck verleihen;(etwas) herausstellen;(etwas) betonen;(etwas) unterstreichen (fig.);die Betonung auf etwas legen;den Akzent auf etwas legen;pointieren (veraltet);(etwas) herausstreichen;mit Nachdruck erklären;(etwas) hervorheben;(etwas) herauskehren (ugs.);(etwas) akzentuieren
-Wigwam;Tipi;Indianerzelt
-Isolation;Dämmung;Isolierung
-psychiatrische Klinik (Hauptform);Nervenheilanstalt;Nervenklinik;Irrenhaus (derb);psychiatrische Anstalt;Tollhaus (geh., fig.);Irrenanstalt (derb);Klapsmühle (ugs.);Klapse (ugs., salopp);Psychiatrie (ugs.);Narrenhaus (fachspr., veraltet);Psychoklinik (ugs.)
-(etwas) beweisen;(etwas) untermauern (fig.);(etwas) begründen;(etwas) erhärten
-Rückstau;Rückstand
-deliktfähig;schuldfähig
-Halbgeviertstrich (fachspr.);Gedankenstrich (Hauptform);EN DASH (fachspr., Jargon, engl.);bis-Strich;Streckenstrich (fachspr.)
-einlegen;furnieren
-Ladung;Einladung;Vorladung;Einbestellung
-vorbei (ugs.);aus der Zeit gefallen (sein) (fig.);démodé (geh., franz.);abgemeldet (ugs.);hatte seine Chance;zum alten Eisen gehören(d) (fig.);Vergangenheit sein;Old School (engl.);antiquiert;nicht mehr in Mode;nicht mehr State of the Art;nicht mehr zeitgemäß;nicht mehr in die (jetzige) Zeit passen;durch (ugs., Jargon);nicht mehr Stand der Technik;war mal. (Heute ...) (ugs.);passé (ugs., veraltend);Die Zeiten sind vorbei. (ugs., Spruch);(ein) Auslaufmodell (sein);uncool (ugs.);out (ugs.);der Vergangenheit angehören (geh.);Geschichte (sein);nicht mehr auf der Höhe der Zeit;anachronistisch;(der/die/das) gute alte (...) (ugs.);überholt (Hauptform);hat seine besten Zeiten hinter sich (ugs.);hat sich erledigt (ugs., fig.);ausgelutscht (ugs., salopp);ausgedient haben (auch figurativ);nicht mehr aktuell (ugs.);unmodern;nicht mehr up to date (ugs., veraltend);hat seine Chance gehabt;gehört entsorgt (ugs.);Schnee von gestern (ugs.);veraltet;altmodisch;aus der Mode (gekommen) (ugs.);vorsintflutlich (fig.);abgelutscht (ugs., salopp);damit lockt man keinen Hund mehr hinter dem Ofen hervor (ugs., sprichwörtlich);altbacken;nicht mehr angesagt (ugs.)
-Abart;Varietät;Unterart
-Glücksspiel;Spiel;Hasardspiel;Wette
-Mam (ugs.);Mutti (ugs.);Gebärerin (geh.);(jemandes) alte Dame (ugs.);deine arme alte Mutter (halb-scherzhaft) (ugs., Spruch);Muddern (ugs.);Lebensspenderin (geh.);Mama (ugs.);Mutter;Ma (ugs.);Alte (derb);Mami (ugs.)
-woher auch immer;von wo auch immer
-vordergründig;ohne tiefere Bedeutung;leicht durchschaubar;scheinbar;oberflächlich
-wie kommt es, dass... (ugs.);warum;was (ugs., selten);weswegen;weshalb;wieso;aus welchem Grund
-Nördliches Eismeer;Arktik;Arktischer Ozean (Hauptform);Arktische See;Nordpolarmeer
-Metrorrhagie (fachspr.);Blutung außerhalb des Menstruationszyklus
-Bühnenautor;Theaterautor;Bühnendichter;Dramatiker;Stückeschreiber
-abstammen;herkommen;stammen;resultieren (aus);entspringen;(sich) ergeben (aus)
-außer;in Ermangelung (von);exklusive;abzüglich;nicht inbegriffen;bis auf;ohne Einbezug von;ohne;sonder (veraltet);ausgenommen;nicht mitgerechnet;mangels;unter Ausschluss von;mit Ausnahme von;abgesehen von;bar (einer Sache) (geh.);unbeachtlich einer Sache (Juristendeutsch)
-Beglaubigungsschreiben;Akkreditiv;Kreditbrief
-Trennlinie;Demarkationslinie (geh.);Scheidelinie;Scheide;Trennungslinie;Grenzlinie
-(jemanden) niederhalten;(jemanden) überwältigen;(jemanden) bändigen;(etwas) zügeln
-ordentlich;reliabel (geh., franz., lat.);verlässlich;vertrauenerweckend;solide;zuverlässig;man kann darauf zählen;währschaft (schweiz.);integer (Person)
-intern;hausintern;inhouse;firmenintern (ugs.);Haus...;innerbetrieblich
-Stützpunkt;Hochburg
-übermäßige Harnausscheidung;Polyurie (fachspr.)
-Begründung;Argument;Grund;Prämisse;Beweisgrund;Beleg;Beweis
-Istmaß;Originalgröße;Maßstab 1:1
-Wickeltuch;Umhangtuch
-Gully (ugs.);Abzugskanal;Rinne;Ablasskanal;Entwässerungsgraben;Gosse (ugs.);Abfluss;Abflusskanal
-Radiant;Winkel im Bogenmaß
-Haarriss;feiner Riss
-Monatsanfang;Monatsbeginn
-Toastmaster;Toastmeister (Bankett)
-Erschütterung;seelischer Schock;Trauma
-Schließerkontakt;Schließer
-begierig (auf, nach);eifrig;inbrünstig
-prekär;labil
-Blumenstrauß;Gebinde;Bukett;Strauß;Strauß Blumen;Bouquet (geh., franz.)
-Kennungsgeber;Namensgeber
-Standort;Zweigniederlassung;Zweiggeschäft;Comptoir (geh., franz., veraltet);Geschäftsstelle;Außenstandort;Filiale;Außenstelle;Dependance;Zweigbetrieb;Zweigstelle;Niederlassung;Vertretung;Tochterunternehmen;Nebenstelle;Repräsentanz
-Myopathie (fachspr.);entzündliche Muskelerkrankung
-Gesamteindruck;das Ganze
-Autopflege;Wagenpflege
-Flecken;Tolggen (schweiz.);Klecks;Patzer (bayr., österr.);Patzen (bayr.);Fleck
-Schadensersatzklage;Schadenersatzklage
-Besonnenheit;Bedachtsamkeit;Behutsamkeit;Bedacht;Umsicht
-Lichtbild;Dia
-selbstlos (Hauptform);hilfsbereit;altruistisch (geh.);aufopfernd;solidarisch;selbstvergessen;edelmütig;uneigennützig;edel;sozial eingestellt
-Krebs;Krebstier
-preisgeben;(einer Gefahr) aussetzen
-Kontrapunkt (fachspr.);Gegenstimme;Gegenthese;genaues Gegenteil;Antithese (zu);Unterschied (zu);Gegensatz
-Fehlbildung;Monstrosität (geh.);Malformation (fachspr.);Geburtsfehler;Missbildung
-während der Nacht;nächtens (geh., veraltet);des Nachts (geh., veraltend);nächtlich;nachtsüber;nocturnus (fachspr., lat., medizinisch);in der Nacht;nachts
-Gewandtheit;Geschicklichkeit;Pli (geh., franz., lat.);Geschick
-Explosion;Eruption;Ausbruch
-auf etwas spekulieren;entgegensehen;mit etwas rechnen;erwarten;eingestellt sein (auf)
-Weltraum;Kosmos;Raum;Universum;Weltenraum (poetisch);Sphäre;Weltall;All
-nacharbeiten;später erledigen;aufarbeiten;später machen (ugs., variabel);nachholen
-verschiedenartig;gemischt;disparat;inkongruent;vielseitig;Misch...;kunterbunt (ugs.)
-Ausgangslage;(derzeitiger) Status;Stand der Dinge (Hauptform);Fallkonstellation;Sachlage;Status quo (geh.);gegenwärtiger Zustand;Sachverhalt;Gegebenheiten
-an Mangelernährung leidend;unterernährt;schlecht ernährt;nicht genug zu essen bekommen;fehlernährt;zu wenig zu essen bekommen;vom Fleisch gefallen sein;mangelernährt;(jemanden) bei schmaler Kost halten (geh., veraltet)
-Befruchtung;Konzeption (fachspr.);Empfängnis
-Abnahmeprüfung;Abnahmekontrolle
-(sich) gabelnd;gespalten;gabelig
-mehrjährig;pollakanth (fachspr., botanisch);perenn (fachspr.);perennierend (fachspr.)
-willkürlich;zufällig;stichprobenartig;frei wählbar;per Zufallsprinzip;akzidentiell (fachspr., sehr selten);zufallsgesteuert (fachspr.);nach dem Zufallsprinzip;akzidentell (fachspr.);beliebig;wahllos;wahlfrei;arbiträr (geh., bildungssprachlich)
-Verriss;harsche Kritik;Schmähkritik
-Feinheiten;Einzelheiten;Details;Finessen
-Logge;Log;Gerät zur Messung der Geschwindigkeit
-gesteigerte Erregbarkeit der Reflexe;Hyperreflexie (fachspr.)
-auslöschen;tilgen;annihilieren (geh.);löschen;eliminieren
-Mucus (fachspr.);Schleim
-Einsicht;Zugang;Zugriff;Abruf;Einblick
-an der Haustür verkaufen;auf der Straße verkaufen;hausieren
-Bosheit;Verruchtheit;Böswilligkeit
-dazu kommen;hinzugefügt werden
-Import;Einfuhr
-Wange;Backe
-vermutlich;offensichtlich;womöglich;offenbar;(alles) spricht für (variabel);ich könnte mir vorstellen (dass ...) (floskelhaft);aussehen nach;wahrscheinlich;hindeuten (auf);scheinen zu;wohl;möglicherweise;scheinbar (ugs., fälschlich);anscheinend;offenkundig
-(vollständiger) Bestand an Wörtern;Wortschatz (Hauptform);Wortbestand;Sprachgut;Vokabular;Wortmaterial;Lexikon (fachspr.);Gesamtheit aller Wörter;alle Wörter;Lexeminventar;Sprachschatz;Wortgut;Lexik
-(wieder) vor seinem geistigen Auge entstehen lassen (geh.);(wieder) in sich wachrufen;memorieren (geh., selten);(sich) ins Gedächtnis zurückrufen;(sich) (wieder) in Erinnerung rufen;(sich) zurückbesinnen (geh.);reminiszieren (selten);(sich) (wieder) ins Gedächtnis rufen;in sich gehen;(sich) zurückerinnern;(eine) Erinnerung (in sich) wachrufen;in (seinen) Erinnerungen kramen
-Bürde;Beschwerlichkeit;Widrigkeit;Verwicklung;Schwierigkeit;drückende Last;Hemmnis;Erschwernis;Komplikation
-ständiger Wandel;Wandel;Schnelllebigkeit;Instabilität;Wechselhaftigkeit;fehlende Kontinuität;Unstabilität;Unbeständigkeit;häufige Änderungen
-Abstimmung;Stimmungstest (ugs.);Wahl;Wahlgang;Stimmabgabe;Votum;Kür (veraltet);Urnengang
-Schwarzdorn;Schlehdorn;Gemeine Schlehe (fachspr., botanisch);Prunus domestica (fachspr., botanisch);Schlehe
-Bonität;Solvenz;Zahlungsfähigkeit;Zahlungspotenzial;Liquidität;kaufmännische Solidität
-Erbe;Nachlassempfänger
-Trennschalter;Trenner
-Mark der Deutschen Notenbank;M;MDN;DDR-Mark;Ost-Mark (ugs.);Mark (DDR-Währung)
-Ermittler;Kriminalbeamter;Kriminaler (ugs., veraltend);einer von der Kripo (ugs.);Kriminalpolizist
-nicht sehen (nicht gesehen haben);(jemandem) untergegangen sein (ugs.);(jemandem) nicht auffallen;(jemandem) durch die Lappen gehen (ugs., fig.);(etwas) übersehen (haben) (Hauptform);nicht bemerken;(bei) (jemandem) unter die Räder kommen (ugs., fig.);(jemandem) entgehen;(jemandes) Aufmerksamkeit entgehen;(jemandem) durchrutschen (ugs.)
-wegen dem, dass (ugs.);wo;indem;alldieweil (ugs.);nachdem;nämlich;denn;insofern;da;ergo;also;da obendrein;da ja;weil (Hauptform);mithin
-genetisch;genuin (fachspr.);vererbbar;erblich;hereditär (fachspr.)
-entreißen;fortnehmen;abringen (ugs.);abräumen;(sich) aneignen;herunternehmen;mitnehmen;entziehen;abluchsen (ugs.);abnehmen;wegschnappen (ugs.);das Wasser abgraben (ugs.);abknapsen (ugs.);entwenden;deprivieren (geh., lat.);abknöpfen (ugs.);wegnehmen;abzwacken (ugs.);abjagen (ugs.)
-Apfelsaftschorle;Apfelschorle;Apfelsaft gespritzt
-meldepflichtig;anmeldepflichtig
-übernehmen (Verpflichtung, Aufgabe, Funktion ...);antreten (Amt, Dienst; Haftstrafe);aufnehmen (Studium, Tätigkeit)
-Grippe;Virusgrippe;Influenza (fachspr.);echte Grippe
-betont;klar und deutlich;explizit;mit (großer) Bestimmtheit;in aller Deutlichkeit;mit Nachdruck;unmissverständlich;kategorisch;zugespitzt;eindeutig;entschieden;nachdrücklich;energisch;dringlich;deutlich;bestimmt;klar;prononciert (geh.);ausdrücklich;emphatisch;angelegentlich (geh.);klar und unmissverständlich;akzentuiert (geh.);forsch
-quatschen (ugs.);schwätzen (ugs.);schwatzen;schnattern (ugs.);dibbern (ugs.);plaudern;quasseln (ugs.);reden wie ein Wasserfall;ratschen (ugs.)
-ein Lot fällen;eine Senkrechte ziehen zu;ein Lot errichten
-Kalokagathia (griechisch);Makellosigkeit;Vollendung;Perfektion;Vollkommenheit;höchste Blüte;Unübertrefflichkeit;Idealergebnis;Ideal;Ausgereiftheit
-Startfreigabe;Starterlaubnis
-knüpfen;handarbeiten;stricken
-Zerspanungstechnik;Zerspanen
-Konservendose;Büchse;Konserve;Blechbüchse;Konservenbüchse;Dose
-Sachverwalter;Verwalter;Sachwalter
-Dirndl;Frauentracht;Dirndlkleid;Trachtenkleid
-Bruttosozialprodukt (veraltet);Bruttonationaleinkommen
-Bergwandern;Trekking;Trecking
-Anämie (fachspr.);Blutmangel (ugs.);Bleichsucht (veraltet);Blutarmut (ugs.)
-Exekutor (österr.);Schuldeneintreiber;Inkassobevollmächtigter;Gerichtsvollzieher
-mehrere Sprachen sprechend;vielsprachig;in vielen Zungen (redend) (geh.);polyglott;multilingual (fachspr.);mehrsprachig (Hauptform)
-OPEC (Abkürzung, engl.);Organization of the Petroleum Exporting Countries (engl.);Organisation Erdöl exportierender Länder
-Unermesslichkeit;Großartigkeit
-Büßer;reuiger Sünder
-böswillig;bösartig;dolos (fachspr., juristisch);arglistig;üblen Sinnes (geh.);maliziös (bildungssprachlich);übelgesinnt;mit finsteren Absichten;boshaft;infam;niederträchtig;übelwollend
-steril;infertil;fruchtlos;zeugungsunfähig;unfruchtbar
-Dezernent;Sachbearbeiter;Referent
-unglasierte Keramik;Schrühware
-blütenweiß;reinweiß;schlohweiß;strahlend weiß;blendend weiß;grellweiß;leuchtend weiß;neonweiß;schneeweiß;perlweiß;lilienweiß
-Praxiserfahrung;praktische Erfahrung
-maskieren;verhehlen;den Blicken entziehen;kaschieren;verheimlichen;verbergen;camouflieren;verstecken;tarnen
-stille (veraltet);piano (mus.);schallgedämpft (tech.);gedämpft;leise;geräuschgedämpft (tech.);geräuscharm (tech.);tonlos;geräuschreduziert (tech.);ruhig;still;abgeschirmt
-Fahrradnabe;Nabe;Radnabe
-laufmaschensicher;laufmaschenfest
-zerknautschen;zerknüllen
-kondolieren;sein Beileid aussprechen
-Vorkehrung;Schutzmaßnahme
-Fetzen;Bereich;Teilbereich;Fragment;Stückchen;Teilstück;Stück;Abschnitt;Bruchstück;Segment;Ausschnitt;Unvollendetes;Teil
-Verschmelzung;Vermischung
-Unkosten decken;Kosten decken
-genormt;standardmäßig;serienmäßig
-es gibt Gerüchte (wonach...);ich habe gehört (ugs.);man munkelt (ugs.);man sagt (ugs.);es heißt (ugs.)
-hervorrufen;erwecken;verursachen;sorgen (für);(etwas) bewirken (Hauptform);auslösen;führen (zu);(durch etwas) kommt es zu
-Augenschraube;Ösenschraube
-an Ort und Stelle;vor Ort;am Ort des Geschehens
-perniziös (fachspr., medizinisch);gefahrvoll;verderblich;unheilvoll;gefährlich
-Überträgerstoff;Mediator
-praktisch;eigentlich;wenn man so will;quasi;fast (wie);an sich (ugs.);gleichsam;gewissermaßen;an und für sich (ugs.);so gut wie (ugs.);weitestgehend;wenn Sie so wollen;sozusagen;im Prinzip;im Grunde
-Immobilie;Objekt (kaufmännisch);Grundeigentum;Liegenschaft;Haus und Grundstück;Betongold (ugs., fig.);unbewegliches Sachgut;Realitäten (Plural, österr.)
-Besiedeln;Ansiedeln;Ansiedlung
-Beschirrung;Geschirr (für Pferde, Ochsen);Harness;Pferdegeschirr
-mobilisieren (lat.);daranwenden (geh.);hineinstecken (ugs.);in Bewegung setzen;daransetzen;aktivieren;aufbieten;mobilmachen;verwenden;einsetzen
-vereinbar;verträglich;konvergent;dialogfähig (fachspr.);passgenau;kompatibel (IT-Technik);zusammenpassend;kongruent;interoperabel (IT-Technik);passend
-FAO (Abkürzung);UNO-Organisation für Ernährung und Landwirtschaft
-lumbal (fachspr.);die Lende betreffend
-Brustfellentzündung;Pleuritis (fachspr.);Rippenfellentzündung
-Vorschieben;Protrusion (fachspr.);Schwellung;Vorwölbung
-obstruktiv;widersetzlich
-kürzen;kürzer machen;kappen;abkürzen;verkürzen;raffen;abbreviieren (geh., veraltet);stutzen
-Gemeinheit;Schurkerei;Böses;Übel;Spitzbüberei (veraltend);Übeltat;Teufelei
-Polster;Polsterung
-(sich) verziehen;(sich) verbiegen;arbeiten (Holz);(sich) verformen;(sich) werfen (Holz)
-fremdenfeindlich;xenophob;ausländerfeindlich
-erdulden;durchstehen;ausstehen;aushalten;(einer Sache) standhalten;verkraften (ugs.);ertragen
-Vorfahren;Väter;Vorväter;Ahnen;Altvorderen
-Schmuckstein;Juwel;Stein;Schmuckwerk;Klunker;Edelstein
-e. V. (Abkürzung);eingetragener Verein;E. V. (Abkürzung)
-ausrangieren;zu den Akten legen;ad acta legen;beiseitelegen
-Operationsverstärker;OP-Verstärker
-auf die Schnelle;kurz mal (ugs.);flugs;mal eben schnell (ugs.)
-Spardose;Geldbüchse;Sparbüchse;Dukatenesel (ugs.);Sparschwein
-Lebensdauer;Nutzungsdauer
-Urkundenpapier;Aktenpapier
-respiratorisch (fachspr.);die Atmung betreffend
-fix;gefestigt;ehern;steht fest;fest
-prüfen;überprüfen;testen;inspizieren;begutachten;ermitteln;abtesten;herausfinden;untersuchen
-brausen (Wellen);dröhnen;tosen;donnern
-Platte;Fliese;Kachel
-Marmorsteinbruch;Marmorbruch
-Flunke;Ankerarm
-Eindruck;Anmutung;Impression
-Ferien (Pluraletantum);Urlaub
-abszedieren;sezernieren (fachspr.);abtrennen;trennen von;absondern
-die Leisten betreffend;inguinal (fachspr.)
-träge;tranig (ugs.);beamtenhaft (ugs., abwertend, fig.);langsam;lahm;schleppend;behäbig;schwerfällig;bummelig (ugs.);lahmarschig (derb)
-Trennung;Herauslösung;Aufhebung einer Verbindung;Dissoziation;Abspaltung;Aufsplittung
-Eisschießen;Curling;Eisstockschießen
-voller Argwohn;misstrauisch (gegen);argwöhnisch
-latschen (ugs., salopp);zu Fuß laufen (ugs.);zu Fuß gehen (Hauptform);gehen;einen Fuß vor den anderen setzen;laufen
-Magnettonband;Band;Tonband
-Einkaufen via Fernseher;Teleshopping
-diffus;verteilt;diffundiert;zerstreut;diversifiziert;auseinander getrieben
-limitiert;in einem überschaubaren Rahmen;begrenzt;in überschaubarem Rahmen;eingeschränkt;auf Sparflamme (ugs.);beschränkt;abgespeckt (ugs.);reduziert
-Korso;Parade;Festzug
-maximales Atemvolumen;Vitalkapazität (fachspr.)
-Federbügel;Federbride
-chaotisieren (ugs.);in Unordnung bringen;verheddern (Kabel, Fäden ...) (ugs., norddeutsch);verknäueln;verwirren;durcheinanderbringen
-Perle;Muschelperle
-verrutschen;rutschen
-unnormal;anomal;anormal;pervers;abartig;wider die Natur;abnormal;pervertiert;abnorm;abseits der Normalität;unnatürlich;abweichend;widernatürlich
-pustulös (fachspr.);mit Pustelbildung
-Stufung;Abstufung
-härten;stählen;aushärten;vulkanisieren
-Rundstück (hamburgisch);Weggli (schweiz.);Semmel (bayr., österr.);Brötchen (Hauptform);Weckle (schwäbisch);Schrippe (berlinerisch);Weckerl (süddt., österr.)
-anbahnen;einführen
-belohnen;honorieren
-verlangen;beantragen;anfordern;fordern
-sozialversicherungspflichtig beschäftigt;in Lohn und Brot stehen (bei);angestellt;auf der Gehaltsliste (stehen) (bei);erwerbstätig;beschäftigt;im Arbeitsverhältnis;im Beschäftigungsverhältnis;in (jemandes) Diensten (stehen) (geh.);tätig;in Amt und Würden (geh., ironisch)
-postprandial (fachspr.);nach der Mahlzeit;nach dem Essen
-Samen;Sperma;Wichse (vulg.);Ejakulat (fachspr.);Samenflüssigkeit
-passieren;vorübergehen;vorbeigehen (an)
-Appetitzügler;Anorektikum (fachspr., medizinisch);Abmagerungspille
-Bindung;Verankerung;Befestigung;Fixierung
-klüngeln (ugs., rheinisch, veraltend);bummeln;(sich) lange aufhalten mit (ugs.);(es) langsam angehen lassen;trödeln;(Zeit) vertrödeln;sandeln (ugs., österr.);vertändeln;zögern;die Mühlen der (Justiz/Bürokratie/...) mahlen langsam;vor sich hin trödeln (variabel);(he)rumtrödeln (ugs.);(sich) Zeit lassen;langsam sein
-kaputtschlagen;zerschmettern
-Milzbrand;Anthrax
-Übergriff (auf);Eingriff (in)
-Hausfriedensbruch;Besitzstörung;unbefugtes Betreten
-Geräuschlosigkeit;Stillschweigen;Funkstille (ugs., fig.);Verschwiegenheit;Schweigen;Ruhe;Lautlosigkeit;Stille
-Erdaufschüttung;Aufschüttung
-Oligomenorrhoe (fachspr.);zu seltene Menstruationsblutung
-schöpfen;schaufeln
-Glanz und Gloria (ugs.);Ruhm;Herrlichkeit;Glorie (geh.);Glamour (ugs., Jargon)
-Übertrag;Additionsübertrag
-hat herausgegeben;edidit;ed. (Abkürzung)
-(wie) auf dem Präsentierteller (ugs.);ungeschützt;offen
-Schilddrüsenhormonvergiftung (ugs.);thyreotoxische Krise (fachspr.);Thyreotoxikose (fachspr.)
-Schulderlass;Freispruch
-eine persönliche Note geben;persönlicher gestalten
-Feuermelder;Flammenwächter;Brandmelder
-schmerzhaft geschwollene weibliche Brust;Mastodynie (fachspr.)
-überbleiben (ugs.);bestehen bleiben;bleiben;zurückbleiben;verbleiben;übrigbleiben;übrig bleiben
-Vorausnahme;Aussicht;Erwartung;Annahme
-Lieferkonditionen;Lieferbedingungen
-mit jemandem mitfühlen;für jemanden Verständnis haben
-über Umwege;mittelbar;mehrstufig;indirekt
-Soufflé (franz.);Soufflee;Eierauflauf;Auflauf
-wickeln;windeln
-Ansiedelung;Niederlassung;Ansiedlung;Siedlung
-Zuschrift;Liebesbrief (ugs., scherzhaft);Brief (Hauptform);Schrieb (ugs.);Wisch (derb);Epistel (geh., bildungssprachlich, veraltet);Schreiben;Anschreiben
-Nebenausgaben;Nebenkosten
-Personalisierung;Personifizierung
-Aktionsprogramm;Handlungsprogramm
-keinen Zweifel lassen (an);klar und deutlich;ganz klar (ugs.);klipp und klar (ugs.);unmissverständlich;klar;klar und unmissverständlich (floskelhaft);unzweifelhaft;eindeutig
-enthülsen;ausschoten
-gießen;formen
-Saure-Gurken-Zeit;Sauregurkenzeit (Hauptform);ereignis- und nachrichtenarme Zeit;umsatzschwache Zeit (im Sommer)
-Aufbewahrung;Verwahrung
-Singultus (fachspr.);Hitzgi (schweiz.);Schnackel (westösterreichisch);Hicki (schweiz.);Schlickser (regional);Hätscher (süddt.);Schlicks (regional);Schnackerl (ostösterreichisch);Schlucken (ostdeutsch);Hecker (süddt.);Schluckauf (Hauptform);Hicker (nordostdeutsch);Schnaggile (kärntnerisch, tirolerisch);Schnackler (bayr., westösterreichisch);Hägger (schwäbisch);Hickeschlick (ruhrdt., veraltend);Hickepick (niederrheinisch);Glucksi (schweiz.);Higgis (schweiz.);Häsch (süddt.);Hickser (süddt.);Hick (luxemburgisch);Schluckiza (kärntnerisch);Schluckser (süddt.);Hicks (ugs.);Glutzger (süddt.)
-leer saugen;ausleeren;entleeren;leeren;ausräumen;leer machen
-quer;überquer;kreuzweise
-Timing;Zeiteinteilung
-Kampfgeist;Durchsetzungskraft;Durchsetzungsvermögen
-Taste;Schalter;Druckschalter;Taster;Knopf
-Laufgewichtswaage;Schnellwaage
-elendig verrecken (derb);verrecken (derb);krepieren (ugs.);elendig sterben (derb);abkratzen (derb);abnippeln (derb);hopsgehen (derb)
-wolkenbruchartiger Regenfall;Wolkenbruch;Platzregen;Regenguss;Regenschauer;Husche (ugs.);Guss (ugs.);Sturzregen;Dusche (ugs.);Schauer (Hauptform)
-Seemannslied;Shanty;Matrosenlied
-Abenteuerdurst;Abenteuerlust
-Astronom;Sternforscher;Sternengucker (ugs.)
-Verderblichkeit;Zahn der Zeit (ugs.);Vergänglichkeit
-zurückführen;wiederherstellen
-vergöttern;huldigen;verehren;adorieren (veraltet);heiligen;anbeten
-unterhaltsam;amüsant;vergnüglich;kurzweilig
-rödeln (ugs.);plockern (ugs., regional);werken;werkeln (ugs.);schuften (ugs.);schwer zugange sein (ugs., ruhrdt.);(sich) in die Sielen legen (veraltet);(sich) (mächtig) ins Zeug legen;(schwer) am Wirken sein (ugs., regional);reinhauen (ugs.);(sich) fretten (ugs.);wullacken (ugs., ruhrdt.);ackern wie ein Hafenkuli (ugs.);hart arbeiten (Hauptform);schaffe, schaffe, Häusle baue (ugs., Spruch, schwäbisch);hackeln (ugs., österr.);roboten (ugs.);schwer arbeiten;arbeiten wie ein Pferd;reinklotzen (ugs.);rabotten (regional, teilw. veraltet) (ugs.);(sich) (mächtig) ins Geschirr legen;wullachen (ugs., ruhrdt.);ackern (ugs.);ackern wie 'ne Hafendirne (ugs.);bis zur Erschöpfung arbeiten;(sich) abfretten (ugs., süddt.);viel arbeiten;nicht kleckern, sondern klotzen (ugs.);rackern;ranklotzen (ugs.);keulen (ugs., regional, ruhrdt.);malochen (ugs.)
-Hausputz (im Frühjahr);Frühjahrsputz
-Abhärtung;Gewöhnung
-kontextspezifisch;kontextsensitiv;kontextabhängig
-über;droben;oben;obig;hoch
-Verabredung;Termin (Hauptform);Date (ugs., engl.);festgesetzter Zeitpunkt
-überwältigen;niedermachen (ugs.);niederringen;niederkämpfen
-animalisch;tierisch
-grober Fehler;Schnitzer (ugs.)
-Stütze;Säule;Pfeiler;Strebe;Pfosten
-ortsgebunden;stationär
-nicht zugeschlossen;nicht zugesperrt;unabgeschlossen;unverriegelt;unversperrt;aufgesperrt;auf (ugs.);offen;nicht abgeschlossen;unverschlossen
-Scheidendammschnitt;Dammschnitt;Episiotomie (fachspr.)
-Ahnherr;Ahn;Gründer;Ahne;Urahn;Begründer;Vorläufer;Stammvater
-Gespenstergeschichte;Geistergeschichte;Spukgeschichte
-Gegenklage;Gegenanklage
-Selbstbildnis;Selfie (mit Smartphone) (engl.);Selbstporträt
-erwartungswidrig;erstaunlich;überraschend;stupend (geh.);kontraintuitiv (geh.);verwunderlich;frappant;verblüffend;frappierend
-Aufgabe;Verzicht;Preisgabe;Übertragung
-perfide;hintertrieben;heimtückisch;link (ugs.);verräterisch;trickreich;intrigant;verschlagen;hinterlistig;hinterfotzig (derb);perfid;niederträchtig;hinterhältig
-frei;unbesetzt (Arbeitsplatz);vakant;offen;ausgeschrieben (Stelle);nicht besetzt;in der Ausschreibung;zu besetzen
-(sich) ausrasten (österr.);erholen;pausieren;entspannen;(sich kurz) ausruhen;eine Pause einlegen;ausspannen;Pause machen;Rast machen;verschnaufen;eine Ruhepause einlegen;relaxen (Anglizismus);rasten
-zweimal;doppelt gemoppelt (ugs.);zwiefach;doppelt;zwei Male;zweifach
-Erstarrung;Steifheit;Steifigkeit
-smart;schlau (Sache);pfiffig (Sache);(bei einer Sache) hat sich jemand etwas überlegt (ugs.);(bei einer Sache) hat sich jemand etwas gedacht (ugs.);intelligent (Sache);clever
-montieren;einrichten;installieren;einsetzen;einbauen;zusammenfügen;einpassen;einarbeiten
-Ausgliederung;Fremdvergabe;Outsourcing;(Auftrags-) Vergabe an eine Fremdfirma;Spin-Off (Jargon, engl.);Auslagerung;Outsourcen
-Nonnengans;Weißwangengans
-Salutation (geh., lat.);Salut (lat.);Willkommenheißung;(das) Willkommen;Begrüßung;Gruß
-Autokennzeichen;Kontrollschild (fachspr., Amtsdeutsch, schweiz.);Nummernschild (ugs.);Autonummer (ugs., schweiz.);Kennzeichen;Kfz-Kennzeichen (fachspr., Amtsdeutsch)
-ungefärbt;nicht gefärbt
-(b von a) abziehen (Hauptform);abrechnen;subtrahieren (von) (Hauptform);absetzen
-Verlängerung;Vergrößerung;Verbreiterung;Ausweitung (Hauptform)
-(jemanden) verschonen;(jemandem etwas) ersparen
-lotrecht;aufrecht;vertikal;senkrecht (aufgerichtet);aufrecht stehend
-jemanden loswerden;jemanden abschieben
-Verdammung;Verbot;Ausschluss;Bann;Untersagung;Bannstrahl (fig.);Bannfluch;Verfemung;Ächtung;Ausgrenzung;Verbannung
-weltläufig;weltmännisch;weltgewandt;von Welt (ugs.);weltoffen;kosmopolitisch
-bitte wenden;b. w. (Abkürzung)
-permeabel (fachspr.);zugänglich;durchlässig;durchdringbar;porös;durchgängig
-Neues Testament;NT
-Literaturverein;Buchklub;Buchgemeinschaft;Buchclub
-umschulen;umschwenken (ugs.);umlernen
-Kreuzung;Straßenkreuzung
-Linienstärke;Linienbreite
-reich sein (an);Überfluss haben
-Tuberkulose;TBC (Abkürzung);TB (Abkürzung);Morbus Koch (veraltet)
-Verwechselung;Verwechslung
-Abwesenheit;Defizit;Absenz (schweiz., österr.);Fehlen;Mangel
-zusammentragen;zusammenstellen;erarbeiten
-unmöbliert;nicht eingerichtet;uneingerichtet
-normalerweise (Hauptform);in aller Regel;für gewöhnlich (geh.);gemeinhin (geh.);von Haus aus;landläufig;normal (Adv.) (ugs., salopp);im Regelfall;gemeiniglich (geh., veraltend);im Normalfall;in der Regel;üblicherweise;gewöhnlich;standardmäßig;typischerweise
-blinken;flackern;aufblinken
-nodös (fachspr.);knotenförmig;knotig
-Bekenntnis;Konfession;Glaube;Denomination
-behindern;hindern;hemmen;stören
-kampieren;campen;campieren (schweiz., österr.);biwakieren;zelten;lagern
-volkswirtschaftlich;gesamtwirtschaftlich;wirtschaftlich;nationalökonomisch
-resolut;urgent (veraltet);unaufschiebbar;dringend;akut;heftig;drastisch;unvermittelt auftretend;vehement
-Virus...;viral
-(einer Sache) Ausdruck verleihen (geh.);(etwas) aussprechen;(etwas) in Worte fassen;(etwas) verbalisieren;(etwas) äußern (Hauptform);(etwas) verbal ausdrücken;(etwas) formulieren
-angeschlagen;taumelig;wackelig auf den Beinen;nicht standfest;angezählt (ugs.);wacklig auf den Beinen
-Zinower (ugs.);Desorientierung;Irritation;Verwirrung
-geeignet;verwertungsfähig;benutzbar;verwendungsfähig;brauchbar;(gut) zu gebrauchen;anwendbar;nutzbar;verwendbar;verwertbar;tauglich;gebrauchsfähig
-Eidam (veraltet);Schwiegersohn
-vernehmen (geh.);man erzählt sich, dass (ugs.);(ein) Vögelchen hat mir gezwitschert (dass) (Elternsprache) (ugs.);(jemandem) zu Ohren kommen;(jemandem) zu Gehör kommen (geh.);es ist die Rede davon, dass (ugs.);erhaschen (geh., fig.);mitbekommen;hören;(etwas) sagen hören;mitkriegen (ugs.);(etwas) läuten hören (fig.);aufschnappen (ugs., fig.);erfahren
-glühend;glutig;überheizt;hochsommerlich;heiß wie ein Bügeleisen;sehr warm;sehr heiß (Hauptform);siedend;glutheiß;brütend heiß;kochend heiß;siedend heiß;heiß;bullig heiß;brennend;sengend heiß;wie in einem Backofen;sengend;glühend heiß;überhitzt
-Überlagerung;Überschneidung
-mehr;lieber;vielmehr;mit höherer Wahrscheinlichkeit;eher
-einlösen (Scheck);einzahlen
-Bauteileliste;bill of material (fachspr., engl.);bill of materials (fachspr., engl.);Artikelstamm;Warenbestandsliste;Materialliste;Stückliste;BOM (fachspr., Abkürzung, engl.);Lagerliste
-Heubner-Herter-Krankheit;Sprue;einheimische Sprue;glutensensitive Enteropathie;Glutenunverträglichkeit;gluteninduzierte Enteropathie;intestinaler Infantilismus;nichttropische Sprue;Unverträglichkeit von Gluten;Zöliakie
-trockenlegen;dränieren;entwässern
-aperiodisch;unabgestimmt;azyklisch;frequenzunabhängig
-outen;entlarven;bloßlegen;zu erkennen geben;dekuvrieren (geh.);aufdecken;decouvrieren (geh.);offen legen;offenbaren;enthüllen;demaskieren;enttarnen;auspacken (ugs.);aufklären;die Katze aus dem Sack lassen (ugs., fig.)
-Gallenblasenentzündung;Cholezystitis (fachspr.)
-widerstandslos;supraleitend;supraleitfähig
-nass;regnerisch;feucht;verregnet
-Kontrollpunkt;Überwachungsstelle
-Validität;Gültigkeit
-Muselmane (veraltet);Muselman (veraltet);Islamit (veraltet);Muselmann (veraltet);Muslimin (Hauptform, weibl.);Muslim (Hauptform);Moslem;Mohammedaner (veraltet);Musel (ugs., abwertend, veraltet);Sarazene
-Milchkanne (ugs., fig.);Kleinkleckersdorf;Kuhkaff (ugs., abwertend);hinterletztes Kaff (ugs., abwertend);Posemukel (ugs.);Pusemuckel (ugs.);Kaff (ugs., abwertend);Posemuckel (ugs.);Kuhdorf (ugs., abwertend);Hintertupfingen (ugs.);verschlafenes Nest;letztes Loch (ugs., abwertend);Hintertupfing (ugs.)
-Giebelwand;Giebelseite
-Automobil-Mechatroniker (schweiz.);Kfz-Mechatroniker;Automobilmechaniker;Autoschrauber (ugs.);Kraftfahrzeugmechaniker;Kfz-Mechaniker;Automonteur;Kraftfahrzeugmechatroniker;Automechaniker
-auf Honorarbasis arbeiten;freiberuflich arbeiten;in einem freien Beruf arbeiten;freiberuflich tätig sein
-dezentralisieren;entkernen
-Komplexität;Komplexitätsgrad;Kompliziertheit
-Seereise;Schiffsreise;Kreuzfahrt
-Sublimierung;Veredelung;Sublimation;Verfeinerung
-Geschmeidigkeit;Dehnbarkeit
-(sich) aneignen;sammeln;erringen;erwerben
-Entzündung der Regenbogenhaut;Iritis (fachspr.)
-Verstopfung;Verschluss (fachspr., Hauptform);Okklusion (fachspr.);Obstruktion (fachspr.)
-(an etwas) herumwerken;(an etwas) herumprobieren (Hauptform);(an etwas) herumschustern;(an etwas) herumstoppeln (ugs.);(an etwas) herumpfuschen;(an etwas) herumbasteln;(an etwas) herumtun (ugs.);(an etwas) herumdoktern;(an etwas) doktern (ugs.)
-Kapitalgewinnsteuer;Kapitalertragssteuer;Kapitalertragsteuer
-(sich) anlehnen (an);(sich) ausrichten (nach);(sich) orientieren (an);(sich) richten nach;gehen (nach) (ugs.);(sich) leiten lassen (von) (geh.)
-Teint;Hautfarbe
-Nylons;Nylonstrümpfe
-Effekthascherei;Sensationsmache;Kulissenreißerei (selten, veraltet)
-Lasche;Zunge
-Violoncello;Cello
-Vorraum;Limbus;äußerster Kreis der Hölle;Vorhölle
-wo wir gerade dabei sind (in einem Gespräch) (ugs.);zur Seite gesprochen (fig.);nebenbei bemerkt;apropos (geh.);da wir gerade dabei sind (gesprächsweise) (ugs.);was ich noch sagen wollte (ugs.);eigentlich (ugs.);bei diesem Stichwort;btw (ugs., Jargon, engl.);übrigens (Hauptform);da fällt mir (gerade) ein (ugs.);nebenher;nicht zu vergessen;nur mal so nebenbei (gefragt / gesagt / ...) (ugs.);wo wir schon mal dabei sind (im Gespräch) (ugs.);ach übrigens (ugs.);by the way (ugs., Jargon, engl.);bei dieser Gelegenheit;wo wir gerade davon sprechen (ugs.)
-Defaultwert;vorgegebener Wert;Vorgabe
-Reserviertheit;Distanziertheit;Zurückhaltung
-Gegendruck;Druckhöhe;Förderdruck
-Dystonie (fachspr.);fehlerhafter Spannungszustand
-Verabreichung;Zuweisung;Gabe;Zuteilung
-Appetit (auf);Lust (auf);Begehren;Verlangen (nach);Trieb;Sehnsucht (nach);Wunsch (nach);Sehnen (nach);einen Zahn haben (auf) (ugs.);Appetenz (fachspr.)
-Ährenfisch;Streifenfisch
-Querdehnungszahl;Poissonsche Zahl;Querdehnzahl;Querkontraktionszahl;Poissonzahl
-(etwas) kennenlernen;(etwas) kennen lernen;(etwas) erfahren
-Interface seriell;serielle Schnittstelle;Seriellschnittstelle
-allgemein gültig;generisch;universal;allgemeingültig;universell
-spannen (ugs.);gaffen
-Selbstverliebtheit;Egozentrik;Autoerotismus;Autophilie;Ichbezogenheit
-(sich) senken;einfallen;stürzen;herunterfallen;herunterstürzen;entgleiten;herabfallen;abfallen;sinken;(sich) neigen;verringern;bröckeln (ugs.)
-(sich) ergeben;entstehen;aufkommen;erwachsen (aus);(sich) bilden
-blaffen (ugs.);kläffen;belfern (ugs.);bellen
-anekeln;anwidern;verabscheuen;degoutieren
-Endokrinologie (fachspr.);Lehre von inneren Drüsen
-Ostasien;Fernost;Ferner Osten
-Köpfchenblütler;Asteraceae (fachspr., lat.);Asterngewächse (fachspr.);Körbchenblütler;Korbblütler (Hauptform);Korbblütengewächse (fachspr.);Compositae (fachspr.)
-neidisch;eifersüchtig
-(sich) lehnen (an);abhängig sein (von);(sich) stützen (auf)
-Kenngröße;Maß;Hilfsvariable;Parameter
-wichsen (ugs.);es sich selbst machen (ugs.);onanieren;(sich) einen keulen (ugs.);(sich) einen von der Palme wedeln (ugs.);masturbieren;(sich) einen rubbeln (ugs.);(sich) selbst befriedigen;es (sich/jemandem) mit der Hand machen (ugs.);(sich) einen runterholen (ugs.)
-entstehen (im weiteren Sinne);(es) gibt;in Erscheinung treten;(sich) zeigen;auftreten;kommen zu (es);hervortreten;nicht ausbleiben;zu sehen sein;sichtbar werden;(sich) bilden
-perivaskulär (fachspr.);in Umgebung eines Gefäßes
-Hinweis (auf);Verdachtsgrund;Verdachtsmoment;Indiz;Anzeichen (für);Anhaltspunkt
-Verhaltensmuster;übliche Verhaltensweise
-Sägemehl;Sägespäne (Plural);Sägestaub
-schwer (Speisen);fett (Boden)
-Scrambling;Verschlüsselung;Verwürfelung
-benutzerdefiniert;benutzerbestimmt;benutzerspezifisch
-Mut;Schneid (ugs.);Kühnheit;Verwegenheit
-Restaurator;Konservator
-auf dieselbe Ebene stellen;anpassen;gleichsetzen;angleichen;adaptieren
-in Bläschenform;mit Bläschenbildung;vesikulär (fachspr.)
-unartig;böse (Kindersprache);ungezogen;ungehorsam
-Unnachahmlichkeit;Einzigartigkeit (Hauptform);Beispiellosigkeit;Einmaligkeit;Individualität
-brüllen (ugs.);schreien;rufen;kreischen (ugs.);krakeelen (ugs.);krähen (ugs.)
-bejubeln;(jemandem / einer Sache) Beifall zollen (geh.);beklatschen;(jemandem) zujubeln;(jemandem) huldigen;(jemanden) feiern wie einen Popstar;akklamieren (geh.)
-haarscharf;so gut wie;soeben;auf Kante genäht (ugs.);nahezu;fünf vor zwölf (ugs.);beinahe;enge Kiste (ugs.);fast;soeben noch;um ein Haar (ugs.);annähernd;knapp;kurz vor knapp (ugs.);kaum;gerade noch (ugs.);bald (ugs.)
-Haft;Arrest;Freiheitsentziehung (fachspr.);Sicherheitsverwahrung;Freiheitsentzug;Gewahrsam;Sicherungsverwahrung;Gefangenschaft
-Umgang;Bekannte;Bekanntschaften
-Verlobung;Ehegelöbnis;Ehegelübde;Verlöbnis;Eheversprechen
-abtupfen;tupfen
-wohlwollend;gut gesinnt;liebenswürdig;entgegenkommend;wohlgesinnt
-Bahnneigung;Inklination
-10-Pfennig-Münze;Tacken (ugs., ruhrdt.);10-Pfennig-Stück;Groschen;Zehnpfennigstück
-ordentlich (ugs.);feste (ugs.);zupackend;beherzt;tüchtig;ohne langes Überlegen;forsch;entschlossen
-Reiseziel;Ziel;Destination;Bestimmungsort
-bewiesenermaßen;anerkanntermaßen
-(jemandem etwas) verargen (geh., veraltend);(jemandem etwas) verübeln;(jemandem etwas) nachtragen;(jemandem etwas) ankreiden (ugs.);(auf jemanden) nicht gut zu sprechen (sein) (ugs.);(jemandem etwas) übel nehmen;(jemandem etwas) krummnehmen (ugs.);(jemandem etwas) übelnehmen (Hauptform);(über jemanden) verärgert (sein);(jemandem etwas) verdenken (negativ oder in Frage) (geh., floskelhaft);(auf jemanden) sauer sein (ugs.);(auf jemanden) schlecht zu sprechen (sein) (ugs.)
-zur Selbstverständlichkeit werden;internalisieren (geh.);verinnerlichen;(die) Macht der Gewohnheit;selbstverständlich werden (für);(jemandem) zur zweiten Natur werden (variabel);inkorporieren (geh.);(für jemanden) selbstverständlich werden;(jemandem) zur Gewohnheit werden (variabel);(sich) zu eigen (machen);(für jemanden) zur Gewohnheit werden (variabel);(sich) zur Gewohnheit machen;in Fleisch und Blut übergehen (lassen) (fig.);(für jemanden) zur zweiten Natur werden (variabel)
-unterjubeln;aufschwätzen;loswerden (an);aufquatschen;andrehen;aufschwatzen
-kauernde Stellung;Hockstellung;Hocke;Kauerstellung
-mit Kulleraugen;kulleräugig;mit Glotzaugen
-(jemandes) Gedanken kreisen (um);brüten (über);sinnieren;grübeln (über)
-zum Teufel jagen (ugs.);wegbeißen (fig.);fortjagen;mit einem Fußtritt vor die Tür jagen (derb, variabel);(jemanden) in die Flucht schlagen;(jemanden) verjagen;(jemanden) vertreiben;verscheuchen;wegjagen wie einen räudigen Hund (derb, Jargon, variabel);schassen (ugs.);davonjagen;(jemanden) wegjagen;(jemanden aus etwas) jagen
-Programmsteuerwerk;Leitwerk;Steuereinheit;Steuerwerk (Hauptform)
-Aktienoptionsplan;Aktienbezugsplan
-Echelon;Staffelstellung
-durch die Bank (ugs.);samt und sonders;praktisch alle;alle, wie sie da sind;restlos;vollständig;alle, wie sie da waren;allesamt;durchweg;vollzählig;durchwegs (süddt., österr.);generell;pauschal;in Bausch und Bogen (ugs.);durchgängig;in Gänze;in jeder Richtung;komplett;ausnahmslos;ohne Ausnahme;hundertprozentig;gesamt;alle miteinander;einstimmig
-unverfälscht;echt;veritabel;richtig;authentisch;überzeugend;unverändert;wahrhaftig;wahr
-obliterierend (fachspr.);vernichtend;zerstörerisch;destruktiv;zerstörend;schädlich
-Antihypertonikum (fachspr.);Heilmittel gegen erhöhten Blutdruck
-Internationales Zentrum für Berufsbildung;UNEVOC (Abkürzung, engl.)
-Rechenmaschine;Taschenrechner;Rechner
-freistellen;abdanken lassen;entpflichten;entbinden
-fragwürdig;darf man bezweifeln;nicht einleuchtend;unglaubwürdig (Hauptform);(nur) heiße Luft (ugs.);zweifelhaft;unglaublich;das kann mir (doch) keiner erzählen(, dass ...)! (ugs., Spruch);unglaubhaft;unplausibel;fraglich;kann bezweifelt werden;nichts dran (ugs.);ohne Wahrheitsgehalt;weder Hand noch Fuß haben (fig.)
-zerebrovaskulär (fachspr.);die Hirnblutgefäße betreffend
-Lehrfahrt;Bildungsreise;Studienreise;Studienfahrt
-Glied;Extremität;(die) Gliedmaße (fachspr.);Gliedmaßen (Plural)
-womit;wodurch;wobei
-ohne Arbeitsverhältnis;beschäftigungslos;unbeschäftigt;ohne Beschäftigungsverhältnis;ohne Job (dastehen) (ugs.);erwerbslos;keine Arbeit haben (variabel);ohne Arbeit;brotlos (fig.);arbeitssuchend;nicht erwerbstätig;arbeitslos (sein)
-Geschäftsunfähigkeit;Rechtsunfähigkeit
-Getier (geh.);Tier (Hauptform);Vieh (ugs.);Viech (ugs.);tierisches Lebewesen
-weiß nicht (mehr), was er sagt;(voll) panne (ugs.);bestusst (ugs.);selten dämlich (ugs., Verstärkung);(das) Pulver nicht erfunden haben (ugs.);nicht (ganz) bei Trost (ugs.);bekloppt (ugs.);(so) dumm, dass ihn die Gänse beißen (ugs.);(ein) Spatzenhirn haben (ugs.);blöde;(jemandem) haben sie ins Gehirn geschissen (derb);(so) dumm, dass ihn die Schweine beißen (ugs.);birnig (ugs.);(so) dumm wie Bohnenstroh (ugs.);saudumm (ugs.);blöd;saudoof (ugs.);weiß nicht (mehr), was er tut;nicht besonders helle;(jemanden) beißen (doch) die Schweine im Galopp (ugs., Spruch);(so) dumm wie 10 Meter Feldweg (ugs.);bedeppert (ugs.);(geistig) minderbemittelt;strunzdoof (ugs.);schwachköpfig;beschruppt (ugs.);stupid;(die) Weisheit nicht mit Löffeln gegessen haben (ugs.);dumm wie Brot (ugs.);dumm wie Schifferscheiße (derb);dumm (Hauptform);hohl (ugs.);keinen Grips im Kopf (haben);(total) Banane (sein) (ugs.);von allen guten Geistern verlassen (ugs.);beknackt (ugs.);(die) Weisheit nicht mit dem Schöpflöffel gegessen haben (ugs.);irrsinnig;nicht ganz dicht (ugs.);talentfrei (ironisch);grenzdebil (derb);strohdumm;(geistig) beschränkt;stupide;deppert (ugs., süddt.);strunzdumm (ugs.);Dumm geboren und nichts dazugelernt. (ugs., Spruch);geistig nicht (mehr) auf der Höhe;behämmert (ugs.);stockdumm;hirnig (ugs.);unintelligent;nicht gerade helle;belämmert (ugs.);unterbelichtet (ugs.);dämlich;naturblöd (ugs.);nicht bis drei zählen können (ugs.);Stroh im Kopf (haben) (fig.);doof (ugs.);merkbefreit (ugs.);bescheuert (ugs.);strunzendumm (ugs.);gehirnamputiert (derb);deppat (ugs., bayr., österr.);dümmer als die Polizei erlaubt (ugs.);besemmelt (ugs.);idiotisch;saublöd (ugs.);ballaballa (ugs.)
-Ufer;Küste;Küstenlinie
-Päckchen;Paket
-Sputum (fachspr.);Expektorat;Auswurf
-Interrogativpronomen;Fragepronomen (Hauptform);Fragefürwort;fragendes Fürwort
-Jeep (Markenname);Geländewagen;Geländefahrzeug;Offroadfahrzeug;Offroader
-Sehschwäche;Fehlsichtigkeit;Sehfehler;Sehstörung;Asthenopie (fachspr.)
-Krankenpflegerin;Schwester;Krankenschwester;Pflegerin;Pflegeperson (fachspr.);Pflegekraft (fachspr.);Pflegefachkraft (fachspr.)
-aggressiv;offensiv;streitlustig;angriffslustig;konfrontativ (geh., verhüllend)
-Bezugnahme;Hinweis;Belegstelle
-Pädiater;Kinderarzt
-Zugprüfung;Festigkeitsprüfung;Zugversuch;Zerreißversuch
-KG (Abkürzung);Kommanditgesellschaft
-hat keine Ahnung;Dilettant (abwertend);Anfänger (abwertend);Praktikant (abwertend, fig.)
-gültig sein;Gültigkeit haben;in Kraft sein;gelten;Gültigkeit besitzen
-Versterben;Heimgang (religiös);Sterbefall (fachspr., Amtsdeutsch);Lebensende;Abschied;Exitus;(jemandes) Tod (Hauptform);Ableben;Abberufung (fig., verhüllend);Sterben;Hinscheiden;Hinschied (schweiz.)
-KI (Abkürzung);künstliche Intelligenz;AI (Abkürzung, engl.)
-Jäger (Hauptform);Waidgenosse;Jägersmann (altertümelnd, veraltend);Nimrod (hebräisch, scherzhaft);Waidmann;Hubertusjünger
-Fußpfad;Gehweg
-Betrug;Betrügerei;Beschiss (derb);Hochstapelei;Etikettenschwindel;abgekartete Sache (ugs.);Inszenierung (fig.);abgekartetes Spiel (ugs.);Trickserei (ugs.);Mauschelei (ugs.)
-antimikrobiell (fachspr.);Mikroben hemmend
-Verstopfung;Obstipation (fachspr.)
-Fähnrich zur See;Maat;Marineunteroffizier
-(fälschlicherweise) denken, dass;wähnen;(sich) wähnen;(sich etwas) einbilden;(sich) halten für;vermeinen (geh.);halten für;(irrigerweise) annehmen;in dem Wahn leben, dass
-Studie;Evaluation (fachspr.);Erhebung;Untersuchung
-Diener;Knecht;Knappe;Büttel;Subalterner;Lakai
-gehimmelt (ugs.);gestorben;tot;dahingeschieden;aus dem Leben geschieden;gefallen (militärisch);nicht mehr sein;von uns gegangen (fig., verhüllend);draufgegangen (bei) (ugs.);seligen Angedenkens (nachgestellt);tot und begraben (Verstärkung);weg vom Fenster (ugs., fig.);verblichen (geh.);hat uns verlassen (fig., verhüllend);verstorben;dahingegangen;(nur) mit den Füßen zuerst (fig.);nicht mehr unter den Lebenden;(seinen Verletzungen) erlegen;unterm Torf (ugs., fig., salopp);seligen Gedenkens (nachgestellt);mit jemandem ist es aus;(jemand) hat es hinter sich (derb);draußen geblieben (militärisch);verschieden;selig (nachgestellt) (veraltet);nicht mehr unter uns (weilen)
-entkuppeln;auskuppeln
-finanzstark;kapitalkräftig;finanzkräftig;kapitalstark;kaufkräftig
-Wettergeschehen;Atmosphärenphysik;Wetterkunde;Meteorologie;Physik der Atmosphären;Klimakunde
-beten;Gebete zum Himmel schicken;seine Gebete verrichten
-in einzelnen Fällen;z. T.;hier und da (ugs.);im Einzelfall;teilweise;stellenweise;hie und da (ugs.);in einem bestimmten Ausmaß;von Fall zu Fall;teils;mitunter;partiell;fallweise (geh.);selektiv;zum Teil
-Verwundbarkeit;Prädisposition (fachspr.);Vulnerabilität (fachspr.);Verletzlichkeit;Verletzbarkeit
-arithmetischer Operator;mathematischer Operator;Rechenzeichen (Hauptform);Operator
-Montageband;Fließband;Montagestraße;Band
-Flugzeugabsturz;Crash;Flugzeugunglück
-Kaplan;Vikar (kath.);Hilfspriester
-Anus (fachspr.);Weidloch (fachspr., Jägersprache);Darmausgang;Rosette (ugs.);Arschloch (derb);After
-skippen (engl.);überspringen;auslassen;fortlassen;weglassen;aussparen;präterieren (geh., bildungssprachlich)
-ohne Umschweife;in konzentrierter Form;überblicksartig;kurz und knapp;zusammengefasst;kurzgefasst;aufs Wesentliche konzentriert;im Überblick;kurz zusammengefasst;mit wenigen Worten;lakonisch;stichpunktartig;mit knappen Worten;in groben Zügen;in geballter Form;schmucklos;kurz und bündig;kurz gehalten;stichwortartig;lapidar;konzis (geh.);kurz gefasst (Hauptform);in Kurzfassung;im Telegrammstil;gerafft;schnörkellos;in komprimierter Form;summarisch;mit dürren Worten
-Verschleppungstaktik;Katz-und-Mausspiel (fig.);Hinhaltetaktik;Spiel auf Zeit (fig.);Verzögerungstaktik
-ausgenutzt;ausgebeutet
-Sakrum (fachspr.);Kreuzbein
-lukrieren (österr.);Vorteil verschaffen;gewinnen;profitieren
-ohne Ausbildung;ungelehrt;ungelernt
-Entfaltung;Ausbau;Zusatz;Erweiterung;Ausdehnung
-Erzeuger;Lichtmaschine;Generator;Stromerzeuger;Dynamo;Stromgenerator
-weichen (in Wasser);wässern;schwemmen
-Gewimmer;Gewinsel;Gejaule;Gejammer
-angeben;erwähnen;zeigen;aufführen;auflisten;anführen
-Pfanne;Tiegel;Schaffen (ugs.)
-Kastellan;Burgvogt
-Elektrofaksimileverfahren;Xerografie;Fotokopie (ugs.);Xerographie;Elektrofotografie
-einleitende Worte;Vorrede
-maßstäblich;maßstabsgetreu;maßstabsgerecht
-zusammenschneiden;einblenden;mischen;überlagern;mengen;einkopieren
-abschaffen;abolieren (lat., veraltet);abbauen;aufheben;beseitigen;auflösen;aus der Welt schaffen (ugs.)
-Schraubendreher;Schraubenzieher (ugs.)
-Kuddelmuddel (ugs.);Wirrwarr;Mischmasch (ugs.);Salat (ugs.);(ein) Mix (an);Verhau;Gemisch;Chaos;Pelemele (franz.);Wust;Gemeng(e);Dschungel (fig.);Sammelsurium;Wirrnis;(wüstes / regelloses / wildes) Durcheinander (Hauptform);Tohuwabohu (hebräisch);Unordnung;Gewirr;(wilde) Mischung
-narkotisch;betäubend
-Azoospermie (fachspr.);Fehlen von Spermien im Ejakulat
-wohnlich;behaglich;heimelig;zum Verweilen einladen(d);gemütlich;lauschig;anheimelnd
-geistiger Verfall;Dementia (fachspr.);Demenz (fachspr.)
-undistanziert;gutgläubig;vertrauensselig;treudoof (ironisierend);treuherzig;in gutem Glauben;fromm (Wunsch);naiv;arglos;leichtgläubig;nimmt alles für bare Münze;im guten Glauben, dass;kindsköpfig;harmlos
-abreißen (fig.);zum Erliegen kommen;zum Stillstand kommen;nicht fortgesetzt werden;nicht fortsetzen;enden;aufhören;zum Ende kommen
-BGB (Abkürzung);Bürgerliches Gesetzbuch
-aus dem Weg räumen (ugs.);(sich einer Sache) entledigen (geh.);aus dem Weg schaffen (ugs.);beiseiteschaffen;(jemanden) verschwinden lassen;wegschaffen;entfernen;unschädlich machen;fortschaffen;(jemanden) ausschalten;loswerden (ugs.);eliminieren;beseitigen;entsorgen (verhüllend)
-(etwas) haben von (ugs.);Sinn haben;(etwas) herumkommen (bei) (ugs.);etwas bringen (ugs.);Nutzen abwerfen;Früchte tragen (geh.);(einen) Nutzen (er)bringen
-Bundesgerichtshof;BGH (Abkürzung)
-Psoriasis (fachspr.);Schuppenflechte
-Direktive;Dienstanweisung;Order;Aufgabenstellung;Mandat;Weisung;Arbeitsanweisung;Arbeitsauftrag;Geheiß;Aufgabe;Auftrag;Befehl;Anweisung;Quest(e) (geh., veraltet);Anordnung
-Baumaterial (ugs.);Baustoff
-Baerensprungsche Krankheit;Erythrasma (fachspr.);Zwergflechte
-Putzmittel;Politur;Poliermittel
-Gelingen;Lorbeeren;Heil;Erfolg;Fortuna
-verspätet;verzögert;retardiert (fachspr.);nachträglich;nachzügelnd
-ungenießbar (ugs.);(Gesicht) wie sieben Tage Regenwetter (ugs.);muffelig (ugs.);gereizt (ugs.);misslaunig;schlechte Stimmung verbreitend (ugs.);hässig (schweiz.);gnatzig;brummig (ugs.);unleidig (geh., veraltet);missgestimmt;unwirsch;grummelig (ugs.);verdrossen;dysphorisch (fachspr., medizinisch);verdrießlich;unausstehlich;launisch;missgelaunt;ungemütlich (ugs.);(sich selbst) nicht leiden können (ugs., fig., scherzhaft-ironisch);nicht zu(m) Scherzen aufgelegt;unfroh;grantig;schlecht drauf (ugs.);mit sich und der Welt im Unreinen;unleidlich;miesepetrig (ugs.);missmutig;griesgrämig;unzufrieden;grämlich;knurrig;missvergnügt;ungnädig (ugs., ironisch);mürrisch;unwillig;schlecht gelaunt (Hauptform);nicht zu Späßen aufgelegt;kann sich selbst nicht leiden (ugs.);übellaunig;bärbeißig;mit sich im Hader;sauertöpfisch (ugs.);motzig (ugs.)
-Neigung;Disposition (fachspr.);Anlage (zu);Veranlagung
-Umland (einer Stadt) (Hauptform);Peripherie;Einzugsgebiet;Speckgürtel (ugs.);Vorortgürtel;Agglomerationsgürtel
-beschäftigen;anstellen;anheuern (ugs.);einstellen;berufen (auf einen Lehrstuhl);einem Bewerber eine Chance geben;verpflichten;unter Vertrag nehmen;dingen (veraltet);engagieren;rekrutieren;in Lohn und Brot nehmen (geh., veraltet)
-mitschneiden (Gespräch mit Kamera);abfilmen (Jargon);videographieren;videografieren;aufnehmen;filmen
-Kastell;Burg;Festung
-Uveitis (fachspr.);Entzündung der Augenhaut
-universell;vielseitig;facettenreich;versatil
-Anschluss;Interface;Schnittstelle;Verbindung
-indisponiert (geh.);unpässlich;angeschlagen;nicht fit;nicht in der besten Verfassung (verhüllend);wacklig auf den Beinen (ugs.);nicht in bester Verfassung (verhüllend);unwohl;neben der Spur (ugs.)
-genial;prächtig;glänzend;wunderbar;Ich kann mein Glück noch gar nicht fassen! (ugs., Spruch);ein Gedicht (emphatisch);splendid;wundervoll;herrlich;brillant;dass es eine (rechte) Freude ist (literarisch);famos;(eine) wahre Wonne (ugs.)
-gefasst sein (auf);(...) kann kommen (ugs.);(einer Sache) gewärtig sein (geh., veraltend);rechnen (mit) (Hauptform);eingestellt sein (auf);vorbereitet sein (auf);(etwas) erwarten;(etwas) auf dem Zettel haben (ugs., salopp);auf der Rechnung haben (ugs., fig.)
-Bambi (Verniedlichung; Filmfigur);Rehkitz;Rehkalb;Kitz;Rehlein;kleines Reh
-Yangtsekiang;Jangtsekiang;Jangtse
-an Boden gewinnen (ugs.);(sich) erstrecken;(sich) ausdehnen;hineinreichen;(sich) ausbreiten
-Prostatitis (fachspr.);Prostataentzündung
-Klasse;Kurs;Schulklasse
-mit ausgestreckten Armen und Beinen (da)liegen;alle viere von sich strecken
-anfliegen;einfliegen
-Todesursache;Todesart;Sterbegrund;Sterbeursache
-Perforation (fachspr.);Durchbruch
-Homosemie;Synonymie;Bedeutungsgleichheit
-Globales Positionsbestimmungssystem;GPS (Abkürzung)
-Sachverständiger;Experte;Fachmann;Kenner;Auskenner (ugs.)
-nicht feucht;wasserarm;wüstenhaft;trocken;niederschlagsarm;arid;dürr
-Bewegungsstörung;Athetose (fachspr.)
-ad libitum (geh., lat.);dir überlassen (sein);nach (eigenem) Ermessen;willkürlich;frei nach Schnauze (ugs.);(so) wie es einem gerade (in den Kram) passt (ugs.);nach Lust und Laune;nach Gutdünken;dir überlassen (bleiben) (ugs.);Ihrem Ermessen überlassen (bleiben) (geh.);beliebig (Adverb);(so) wie du es für richtig hältst (ugs.);nach Belieben;(so) wie es für dich am besten ist (ugs.);(ganz) nach (eigenem) Gusto (geh.)
-plastizieren;plastifizieren
-Muskelmaschine (ugs.);Muskelmann (ugs.);Modellathlet;Bodybuilder;Muskelpaket (ugs.);Muskelprotz (ugs., abwertend)
-von da an;seit (...);seit diesem Zeitpunkt;seither;seit damals;seitdem;seit dieser Zeit;seit dem Zeitpunkt;von diesem Zeitpunkt an
-Gerümpel;Schlonz (ugs., abwertend);Grusch (ugs.);Krempel (ugs., Hauptform);Zinnober (ugs.);Tand (geh., veraltet);Killefit(t) (ugs., rheinisch, variabel);Krimskrams (ugs.);Geraffel (ugs.);Klumpert (österr.);Gelumpe (ugs.);(wertloses) Zeug (Hauptform);Gedöns (ugs., norddeutsch);Schrott (derb, abwertend);Schnickschnack (ugs.);Driss (ugs., kölsch);Glumpert (ugs., bayr., österr.);Kram;Gesumsel (ugs.);Krusch(t) (ugs.);Stuff (ugs., engl.);Nippes (ugs.);Plunder (ugs.);Tüddelkram(s) (ugs., norddeutsch);Trödel (ugs.);Graffel (ugs., bayr., österr.);Kramuri (ugs., österr.);Schnullifax (ugs.);Kladderadatsch (ugs.);Plörren (ugs., ruhrdt.);Klimbim (ugs.);Pröll (ugs., abwertend);Müll (derb);Tinnef (ugs.);Ramsch (ugs.);Zeugs (ugs., abwertend);Pröddel (ugs.);Glump (ugs., bayr., mitteldeutsch, süddt.);Klüngel;Krams (ugs., abwertend, norddeutsch);Firlefanz (ugs.)
-begleitend;parallel;gleichzeitig;konkomitierend (med.) (fachspr.)
-Abwickeleinrichtung;Abroller
-Marktwirtschaft;Kapitalismus;Verkehrswirtschaft (veraltet)
-Normung;Standardisierung;Normierung
-Rechtgläubigkeit;reine Lehre;Strenggläubigkeit;Orthodoxie
-Stand;Verkaufsstand;Flohmarktstand
-Sachverständiger;Referent;Gutachter
-multinational;in aller Herren Länder (ugs.);auf der ganzen Welt;international;in aller Welt;global;weltumspannend;weltweit
-Studienordnung;Studienplan;Curriculum (österr.)
-schwächer machen;abschwächen
-Bergschuh(e);Outdoorschuh(e);Wanderstiefel;Treckingschuhe;Wanderschuh(e) (Hauptform);Trekkingschuhe
-Fruchtwein;Most (vergoren)
-Büro der Vereinten Nationen für Projektdienste;UNOPS
-Massenträgheit;Inertia;Beharrungsvermögen;Trägheit;Langsamkeit
-Naschereien (ugs.);Schleckerei (ugs.);Süßes (ugs.);Leckerchen (ugs.);Naschkram (ugs.);Leckerei;Süßigkeiten;Süßkram (leicht abwertend) (ugs.);Zuckerzeug (ugs.);Naschwerk (ugs.);Süßwaren;Zuckerwaren;süßes Zeug (ugs.);Leckerli (ugs.)
-Tumbler (schweiz.);Trockner;Wäschetrockner
-Schaden;Schwäche;Minuspunkt;Insuffizienz (fachspr.);Defekt;Schwachstelle;Ungenügen;Mangel;Defizit;Macke (ugs.);Unzulänglichkeit;Manko
-Mumps;Ziegenpeter (ugs.);Entzündung der Ohrspeicheldrüse;Parotitis epidemica (fachspr.);Parotitis (fachspr.)
-amtlich;autoritativ;maßgebend
-hiermit;mit dieser Urkunde (juristisch);mit diesen Worten;mit diesem Schriftstück
-Gleichspannungs-Zwischenkreis;Zwischenkreis
-Weihnachtsscheit;Christklotz;Weihnachtsklotz
-Ich verstehe.;Schon klar. (ugs.);Aha!;Verstehe. (ugs.);Ach so! (ugs.)
-religiös;fromm;vom Glauben erfüllt;gläubig;spirituell
-Wechseljahre;Klimax (fachspr.);Klimakterium (fachspr.)
-Gefühlseindruck;Empfindung;Sinneseindruck
-Auflösung;Rasterung;Zerlegungsgrad;Granularität
-(jemanden) ängstigen;(jemanden) das Fürchten lehren (geh.);(jemandem) Angst einflößen;(jemandem) Furcht einflößen;(jemandem) Angst machen;(jemandem) Angst einjagen;(jemanden) schrecken (geh.)
-Trassierung;(trassierter) Wechsel;Tratte;Ziehung
-abtransportieren;wegbringen;wegtransportieren;fortschaffen
-Tiefladewagen;Tieflader
-begünstigen;fördern;befördern
-Lehre vom Körperbau;Anatomie
-Lösungsansatz;Lösung (Hauptform);Modell;Lösungskonzept;Antwort;Lösungsmodell;Problemlösung
-Schwein (derb);Arschloch (derb);Hundesohn;Hund (derb);Wichser (vulg.);Flachwichser (derb);Dreckskerl (ugs.);Stück Scheiße (vulg.);Affenarsch (derb);Hurensohn (derb);Sackgesicht (derb);Drecksack (derb);Mistkerl (ugs.);Saubeutel (vulg.);Sack (derb);Sauhund (derb);Kackbratze (derb);Schweinehund (derb);Scheißkerl (derb);Hackfresse (derb);Arsch (derb);Kackstiefel (derb);Sausack (derb)
-gewöhnlicher Aufenthaltsort (juristisch);Wohnort;Wohnsitz (Hauptform);Aufenthalt;Aufenthaltsort;Sitz;Standort;gewöhnlicher Aufenthalt (juristisch);Wohnadresse;Meldeadresse
-Laufrad;Zylinder;Spule;Rolle;Walze;Trommel
-Verschuldetsein;Verschuldung (Hauptform);Schuldenbelastung;Schuldenlast
-zu Ende führen;durchziehen;(etwas) hinter sich bringen (ugs.);beenden;fertigstellen;vollenden;abschließen;terminieren;finalisieren (geh.);beschließen;fertig stellen;in trockene Tücher bringen (ugs., fig.);(den) Sack zumachen (ugs., fig.);erledigen;unter Dach und Fach bringen (fig.)
-Gattungsbezeichnung;Gattungsname;Gattungsbegriff;Appellativ (fachspr.);Appellativum (fachspr., lat.)
-außer Atem;abgehetzt;gehetzt;aus der Puste (ugs.);atemlos
-Vorräte (an);Bestand (an);Repertoire;Vorrat (an)
-weiße Blutkörperchen betreffend;leukozytär (fachspr.)
-Aschenbrödel;Aschenputtel;Cinderella
-Berufung;Ernennung;Bestallung
-Frau;Gemahlin (geh.);Gespons (geh., veraltet);frisch Vermählte;Ehegemahlin (geh.);Ehegattin;Ehegespons (geh.);bessere Hälfte (ugs.);Olle (derb);Weib (derb);Angetraute;Alte (derb);Eheweib (geh.);Ehefrau (Hauptform);Gattin;Gebieterin (geh., ironisch)
-Gärmittel;Bärme (niederdeutsch);Triebmittel;Saccharomyces cerevisiae (fachspr., griechisch, lat.);Hefe;Bäckerhefe;Bierhefe;Gärungsstoff;Germ (bayr., österr.);Gest (norddeutsch);Candida robusta (fachspr., lat., veraltet);Backhefe
-jemanden grämen;jemanden bekümmern
-Verziehen (Platte, Fliese);Werfen
-zugetan;(jemandem / einer Sache) hold (geh., veraltet);auf jemandes Seite sein;angetan (von);zugeneigt;eingenommen (von);(jemandem) gewogen;geneigt (Publikum/Leser);nicht abgeneigt
-Loch (ugs.);Verlies;Verwahrraum (fachsprachlich);Haftraum;Zelle;Kerker (altertümlich);Gefängniszelle (Hauptform);Arrestzelle
-mal rauskommen (aus) (ugs.);eine Reise unternehmen;unterwegs sein;in (den) Urlaub fliegen;wegfahren (ugs.);in (den) Urlaub fahren;reisen;verreisen (Hauptform)
-stereotyp;voller Klischees;klischeehaft;klischeeartig;klischeebeladen;schablonenhaft
-in Lebensgefahr schweben;in Lebensgefahr sein;mit dem Leben ringen (ugs.)
-Knauserer (ugs.);Pfennigfuchser (ugs.);Geizkragen (ugs.);Filz;Knauser (ugs.);Geizhals (ugs., Hauptform);Sparfuchs (positiv);Knicker
-Zentrum der Vereinten Nationen für Regionalentwicklung;UNCRD
-Rufname;Vorname (Hauptform);Taufname
-Meinungsaustausch;Erkenntnisaustausch;Diskussion;Diskurs;Gedankenaustausch
-Umkehr;(das) Umschlagen;Verkehrung ins Gegenteil;Volte (geh.);Verkehrung;Schwenk;Drehung um 180 Grad (fig.);180-Grad-Wende (fig.);Wende (auch figurativ, Hauptform);Umschlag;Kehrtwendung (fig.);Wendung (auch figurativ);Kehrtwende (auch figurativ);Umschwung (auch figurativ);Kehre
-Stomatologe (DDR, veraltet);Dentist;Zahnarzt (Hauptform);Zahnklempner (ugs., scherzhaft)
-aus Flechtwerk herstellen;flechten;zusammenflechten
-Otorrhoe (fachspr.);Ohrenfluss
-Skandalpresse;Sensationspresse;Bunte Blätter;Boulevardpresse (Hauptform);Regenbogenpresse;Klatschpresse;Boulevard (franz.);Yellow Press (engl.)
-Andenken;Gedächtnis;Gedenken
-Anorexia mentalis (fachspr.);Anorexia nervosa (fachspr.);Magersucht
-Schubfach;Schublade;Fach
-besorgen;beliefern;versorgen;verschaffen;geben
-Abhilfemaßnahme;Hilfsmaßnahme
-Lese-Rechtschreibstörung;Lese-Rechtschreib-Störung;LRS (Abkürzung);Lese-Rechtschreib-Schwierigkeit;Legasthenie;Lese-Rechtschreib-Schwäche;Schreib- und Leseschwäche
-multidisziplinär;interdisziplinär;fachübergreifend;fächerübergreifend
-gelehrt;szientifisch (fachspr.);wissenschaftlich;akademisch;gebildet
-anpassen;zuschneiden;individuell herrichten;individuell einrichten
-Durchschnittskurs;Durchschnittspreis
-kontinuieren;weiterführen;in jemandes Fußstapfen treten;fortführen;weitermachen;fortsetzen;fortfahren
-Bestsellerliste;Charts;Hitparade;Hitliste;Top 10;Top Twenty;Top Ten (engl.)
-Schüttelsieb;Schwingsieb
-spaßig;fröhlich;humoristisch;scherzhaft;lustig;humorig (geh.);launig;humorvoll;witzig;schelmisch
-schmälern;verringern
-Ladegut;Frachtgut;Fracht
-31. Oktober;Halloween;Abend vor Allerheiligen
-warm;thermisch
-Kanzlerwahlverein (ugs., abwertend, fig., ironisch);CDU (Abkürzung);Konservative (ugs.);die Schwarzen (ugs.);Christlich Demokratische Union;Christdemokraten
-CD (Abkürzung, engl.);Silberling (ugs.);Album (fachspr., Jargon);Compact Disc (engl.);Disc (ugs., Kurzform, engl.);Silberscheibe (ugs.)
-Angeberei;Großspurigkeit;Großkotzigkeit (derb);Angebertum;Großmäuligkeit;Aufgeblasenheit
-Buchgewinn;rechnerischer Gewinn
-Geschehnis;Angelegenheit;Episode;Vorfall;Geschehen (geh.);Zwischenfall;Vorgang;Ereignis (Hauptform);Begebenheit;Begegnis (geh., veraltet);Vorkommnis
-Tiefdruckgebiet;Tief;Störung
-Körperkreislauf;großer Blutkreislauf
-Denunziation;Denunzierung;Vernaderung (ugs., österr.);Verrat
-konkurrenzfähig;wettbewerbsfähig
-Loch;Senkung;Senke;Nische;Kuhle (fachspr., Jägersprache);Grube;Vertiefung;Mulde
-Zahl (ugs.);Zahlzeichen;Nummer (ugs.);Chiffre (fachspr.);Ziffer
-Äußerung;Vorbringen (einer Meinung)
-Leinpfad;Treidelpfad
-ausgeschlafen (ugs., fig.);aufgeweckt;geschickt;plietsch (landschaftlich, norddeutsch);pfiffig (ugs.);clever;findig;gewitzt;Köpfchen haben (ugs.);gewieft (ugs.);gescheit;gefitzt (schweiz.);alert (geh., veraltend);raffiniert;helle (ugs.);einfallsreich;schlau;originell (geh.);erfinderisch;ausgebufft (ugs.)
-Wasserlauf;Fluss;Strom
-Autogas;LPG (Abkürzung);Flüssiggas
-Erhalt;Bewahrung;Erhaltung;Beibehaltung;Rettung;Aufrechterhaltung
-Ikterus (fachspr.);Gelbsucht
-Anwaltsassistent;juristische Hilfskraft
-monatlich;jeden Monat;pro Monat;mtl. (Abkürzung);per mensem (lat.)
-Kriegsfanfare;Hornsignal;Kriegstrompete
-Elementarteilchen;Massenpunkt (fachspr.);Partikel;Korpuskel (fachspr.);Quant (fachspr.);Teilchen
-Lötpaste;Lotpaste
-Petechien (fachspr.);punktförmige Hautblutungen
-Traidkasten (österr.);Troadkastn (bayr.);Kornhaus;Getreidespeicher;Granarium;Schüttkasten (österr.);Getreidekasten;Kornspeicher
-U/min (ugs.);1/min (fachspr.);Umdrehungen pro Minute;min-1 (fachspr.);UPM (ugs.)
-Raufrost;Reif;Raureif (Hauptform)
-auf und ab gehen;hin und her gehen;auf und ab schreiten
-unveränderliche Größe;Invariante
-Benefiz;Vergünstigung;Mildtätigkeit (veraltend);Gefallen;wohltätige Gabe;Wohltätigkeit;Wohltat
-Anheben;Anhebung (von)
-Fossil...;fossilienhaltig
-Ideologie;Ideenlehre
-vorhandenes System;Altsystem
-Clusterung;Gruppierung;Bündelung
-schmalzig;fettig;speckig
-Abgabe;Preis;Taxe;Gebühr
-(sich) besinnen;Vernunft annehmen;einsichtig werden;zur Besinnung kommen;(wieder) Verstand annehmen;(wieder) vernünftig werden (ugs.);zur Räson kommen;zur Vernunft kommen
-Moorhuhn;Sumpfhuhn
-Prinzip;Grundsatz;Leitfaden;Grundregel;Maxime;Regel
-Ölmesser;Ölstandsanzeiger
-Muff;Mief (ugs.);verbrauchte Luft
-Seelsorger;Geistlicher;Kleriker;Pope (ugs., abwertend)
-feiner Stoff;Voile
-nächtliche Harnentleerung;Nykturie (fachspr.)
-Fernkopie;Faxkopie;Fax;Telefax;Telefaxnachricht;Faxnachricht
-Abspanndraht;Spanndraht
-(der) erste Mann (fig.);(führender) Kopf (fig.);Chef (ugs., fig., salopp);Babo (ugs., jugendsprachlich);Anführer;Capo (einer Ultra-Gruppe) (fachspr., Jargon);Boss (ugs.);Oberhaupt;Hauptmann;Leiter;Häuptling;Führer
-Vogeljagd;Vogelfang
-Depurans (fachspr., lat.);Purgativum;Purgans;Purgativ;Abführmittel;Laxans (fachspr.)
-zuckerig;süß;süßlich
-minniglich (veraltet);liebevoll;lieb
-übersättigend;überhäufend
-wurscht (ugs.);schnuppe (ugs.);(alles) dasselbe;eine wie die andere;ganz gleich (ugs.);piepegal (ugs.);schittegal (ugs.);schiskojenno (ugs., berlinerisch, norddeutsch, polnisch, veraltend);schnurz (ugs.);schnurzpiepe (ugs.);einer wie der andere;gleichgültig;gleich (ugs.);keine Rolle spielen;schnurzegal (ugs.);pupsegal (derb);furzegal (derb);einerlei (sein) (Hauptform);schnurzpiepegal (ugs.);(alles) ein- und dasselbe;so oder so;dasselbe in Grün (ugs.);wumpe (ugs.);egal (sein);eins wie das andere;scheißegal (derb)
-Vorhand;Vorderhand
-Enthüllung;Offenlegung;Eingeständnis;Preisgebung;Offenbarung
-Tauchkolben;Taucher
-Fanatiker;Zelot;Eiferer
-Woge;Brecher;Grundsee;Welle
-überbezahlt;überzahlt
-Flur (bundesdeutsch);Entrée (schweiz.);Vorraum (österr.);Vorsaal (mitteldeutsch, ostdeutsch);Wohnungsflur (bundesdeutsch);(der / das) Flez (fachspr., süddt.);Vorzimmer (österr.);Eren / Ern (süddt.);Vorhaus (fachspr., österr.);Diele (bundesdeutsch);Vorplatz (schweiz.)
-auswaschen;auslaugen
-Aktienaufteilung;Aktiensplit
-Aufschlämmung;(feiner) Schlamm
-gelblich braun;sandfarbig;sandfarben
-Dumdumgeschoss;Dumdum
-hängen lassen;schweben
-einen Knick in der Optik haben (ugs.);schielen
-getrieben;rastlos;(jemand) kann nicht fünf Minuten still sitzen (ugs., fig., variabel);zappelig;ruhelos;unruhig
-rauf und runter;hin und her;auf und ab
-Einlieferung;Übergabe
-Kommotio (fachspr.);Erschütterung
-mit nachtwandlerischer Sicherheit (fig.);mit schlafwandlerischer Sicherheit;mit traumwandlerischer Sicherheit (fig.);nach Nase (ugs.);stinkelingpief (ugs.);unterbewusst;emotional;aus dem Bauch (heraus) (fig.);gefühlsmäßig;intuitiv;nach Bauchgefühl (fig.);instinktgesteuert;instinktmäßig;instinktiv
-Keratitis (fachspr.);Hornhautentzündung
-Strafanzeige;Anzeige
-räumlich;Raum...
-Abordnung;Komitee;Kommission;Delegation
-Kannibale;Anthropophage (fachspr.);Menschenfresser
-aufmuntern;ermutigen;anfeuern
-Kahn;Schute
-Palisade;Einpfählung;Pfahlbefestigung;Staket
-nicht fahrplangemäß;zu spät;überfällig;(leicht) über der Zeit;verspätet;unpünktlich;säumig;später als vorgesehen
-Naturkatastrophe (Hauptform);Kataklysmos;Kataklysmus
-verlangen;erbitten;(sich) ausbitten;fordern
-hinauswerfen;ausschließen;ausstoßen;auswerfen
-Verzweigungsbefehl;Sprungbefehl
-infektiöse Mononukleose (fachspr.);Monozytenangina;Pfeiffer-Drüsenfieber;Morbus Pfeiffer;Pfeiffersches Drüsenfieber;Mononucleosis infectiosa (fachspr.);Kusskrankheit;Mononukleose
-Entwurf;Konzeption;Layout;Schema;Vorlage;Skizze;Zeichnung;Plan;Planung;Grundriss
-Jumper;elektrische Brücke;Steckbrücke
-Südpolgebiet;Südpolargebiet;Antarktis
-UNDP;UNO-Entwicklungsprogramm
-Sabotierung;Manipulierung;Manipulation;Sabotage
-in Linie gebracht;ausgerichtet
-Herzrhythmusstörung;unregelmäßiger Herzschlag;Arrhythmie (fachspr.)
-Ministrant;Messgehilfe;Kirchdiener;Messdiener;Akoluth (fachspr., griechisch);Akolyth (fachspr., griechisch);Mini (ugs.)
-Bezugsquelle;Lieferquelle
-Individuenbestand;Artbestand;Fortpflanzungsgemeinschaft;Tierbestand;Population
-zusammentragen;(Daten) erheben;kompilieren (fachspr.);sammeln;(Daten) erfassen;anhäufen;zusammenstellen;stapeln
-Gerontologie;Alterswissenschaft;Altersforschung;Alternsforschung;Alternswissenschaft
-gefühllos machen;taub machen;narkotisieren;betäuben;Rauschgift verabreichen
-überschreiben;abtreten;vererben;übertragen;überlassen;verleihen;überantworten;anheimstellen (geh.);vermachen
-EEG (Abkürzung);Elektroenzephalogramm;Elektroenzephalografie;Elektroenzephalographie
-geräuschvoll;ohrenbetäubend;schallend;volltönend;dröhnend;lärmig;überlaut;lärmend;donnernd
-Luftnummer (ugs.);Leerlauf (fig.);Vergeudung von Lebenszeit;(reine) Zeitverschwendung (Hauptform);Zeiträuber;Zeitvergeudung;Zeitfresser;vertane Zeit
-Arbeitsmonat;Personenmonat;Mannmonat
-spitzen (Stift);schärfen;anspitzen (Bleistift)
-lieber heute als morgen;so schnell wie möglich (Hauptform);eiligst;schleunigst;unverzüglichst;schnellstmöglich;asap (engl.);möglichst sofort;auf schnellstem Wege;zeitnah (Jargon);auf dem schnellsten Weg;am besten sofort;umgehendst;möglichst schnell
-Pirsch;Pirschjagd
-gut gemeint;wohlgemeint
-vorbeirollen;vorbeiziehen;dahinziehen
-(dem) Geld hinterherjagen (ugs., variabel);gierig;geldgeil (ugs.);materialistisch;konsumgeil (ugs.);raffsüchtig;raffgierig;(dem) schnöden Mammon frönen (geh., variabel);geldgierig;wie die Aasgeier (ugs.);habgierig;unbescheiden;profitsüchtig;den Hals nicht vollkriegen können (ugs., variabel);habsüchtig;unersättlich;konsumistisch (geh.);besitzgierig;unverschämt;gewinnsüchtig
-bedacht;aufmerksam
-Fleischvergiftung;Botulismus;Nahrungsmittelvergiftung;Wurstvergiftung (ugs.)
-Vielseitigkeit;Flexibilität;universelle Verwendbarkeit;vielseitige Verwendbarkeit
-Medizinerin (weibl.);(die) Frau Doktor (weibl.);Doktorin (weibl.);Heilkundiger (männl.);Weißkittel (ugs.);Doc (ugs., engl.);(der) Onkel Doktor (ugs., Kindersprache, männl.);Halbgott in Weiß (ugs., männl., scherzhaft);Ärztin (weibl.);Doktor (männl.);Mediziner (männl.);Medicus (lat.);Medikus (geh.);Heilkünstler (ironisierend);Halbgöttin in Weiß (scherzhaft, weibl.);Arzt (männl.);(der) Herr Doktor (respektvoll) (männl.)
-evaluieren;beurteilen;schätzen;gewichten;(etwas) finden (an) (ugs.);(einer Sache) (etwas) abgewinnen;(etwas für gut/schlecht) befinden;würdigen;ermessen;einschätzen;bewerten;werten;(gut, schlecht) finden (ugs.)
-Dachneigung;Dachschräge;Dachgefälle
-Abreibung;Reibung;Reiben;Scheuern
-Pickerl (ugs., österr.);Mautvignette;Mautpickerl (ugs., österr.);Autobahnvignette;Vignette (franz.);Autobahnpickerl (ugs., österr.)
-anglotzen (ugs.);anstieren
-Stachelwalze;Stachelrad
-Tanzfest;Ball;Tanzveranstaltung;Tanzerei (ugs.);Tanzabend
-Pein;Aua (ugs., Kindersprache);Weh;Schmerz
-Pöbel (derb);Asoziale (derb);White trash (engl.);Abschaum (derb);Brut (derb);Gesindel (derb);Sippschaft;Bagage (ugs.);Bodensatz (ugs.);Gschwerl (ugs., bayr.);Volks (ugs., abwertend, regional);Lumpenpack (derb);niederes Volk;Geschmeiß (derb);Gelichter (lit.) (geh., veraltet);Mob (derb);Gschleaf (ugs., bayr.);Pack (derb);Asis (derb);Gesocks (derb);Kanaken (derb);Paselacken (derb, ruhrdt.);Kroppzeug (derb, norddeutsch);Mischpoke (derb, jiddisch);Plebs
-würzen;abschmecken;Geschmack geben
-Aggressionsbereitschaft;Aggressivität;Angriffslust;Streitlust
-Parallelität;Simultaneität;Simultanität;Gleichzeitigkeit;Gleichlauf
-Vergrößerungsapparat;Vergrößerungsgerät
-Lichtwellenleiter;Glasfaserkabel;Lichtleitkabel
-Plasmaersatzmittel zur Auffüllung des Blutkreislaufs;Plasmaexpander (fachspr.)
-Reaktionslosigkeit;Inflexibilität;Stupor (fachspr.);Starre;Bewegungslosigkeit
-Übersichtlichkeit;Anschaulichkeit;Ausdruckskraft;Einprägsamkeit;Deutlichkeit;Plastizität (geh.);Klarheit;Bildhaftigkeit
-Abkommen;Kontrakt;Vertrag
-baumeln (ugs.);hängen;herunterhängen
-ausmergeln;abmagern
-Temperaturregler;Thermostat
-Lokalisation;Ortsbestimmung;Positionsbestimmung;Lokalisierung;Verortung;Positionierung
-heulen (ugs.);flennen (ugs., regional);das heulende Elend haben (ugs.);(sich) ein Tränchen verdrücken (ugs.);(jemandem) kullern die Tränen (über das Gesicht) (ugs., fig., variabel);Tränen vergießen;schluchzen;greinen (ugs.);(es) fließen Tränen;(jemandem) laufen die Tränen (über das Gesicht) (variabel);schreien (Baby);barmen (geh., poetisch);leise weinend (in der Ecke) (ugs., floskelhaft);bläken (ugs., abwertend, regional);plärren (ugs., abwertend, regional);jammern;weinen (über) (Hauptform);plinsen (ugs., norddeutsch);weinen (vor);plieren (ugs.);wimmern
-Vorstellungsvermögen;Fantasie;Imagination;Einbildungskraft;Phantasie
-(etwas) ablehnen;(etwas) für unzulässig erklären;(jemandem etwas) abschlagen;(jemandem etwas) verwehren;(etwas) abweisen (Hauptform);(etwas) nicht anerkennen;(etwas) nicht zulassen;(jemandem etwas) versagen (geh.);(etwas) verweigern;(etwas) abschmettern
-kfm.;kaufmännisch
-Stromrichter;Stromwender;Gleichrichter
-Menschlichkeit;Humanität
-ausdrucksvoll;feierlich;affektvoll;pathetisch;klangvoll;mit großer Geste;affektgeladen;festlich;erhaben
-soll sie doch ... (ugs.);wenn du meinst ... (ugs.);wenn Sie meinen ... (ugs.);wie Sie meinen;schon okay (ugs.);mir soll's recht sein (ugs.);ist (schon) in Ordnung (ugs.);nur (ugs.);meinethalben;na schön (ugs.);in Gottes Namen (ugs.);wenn es denn sein muss;soll er (ruhig) machen ... (ugs.);geht (schon) in Ordnung (ugs.);wer's braucht ... (ugs.);von mir aus (ugs.);ruhig (ugs.);(es) soll mir recht sein (ugs.);soll er doch ... (ugs.);meinetwegen (halbherzig zustimmend) (Hauptform);wie du willst;wie du meinst
-Doktor der Philosophie;Doctor philosophiae (lat.);Dr. phil. (Abkürzung)
-in ein (bestimmtes) Format bringen;formatieren;arrangieren;zurechtstellen;zusammenstellen;anordnen
-Land;Staat;Nation;Nationalstaat
-Verschlechterung;Abwärtsentwicklung;Eintrübung
-Inbusschlüssel;Sechskant-Schraubendreher;Sechskant-Stiftschlüssel
-Unmut;Leidwesen;Ärger;Verdruss;Missmut;Groll;Missfallen;Verärgerung;Grant (ugs., bayr., österr.);Verstimmung;Missvergnügen
-Organvergrößerung;Hypertrophie (fachspr.)
-Natriurie (fachspr.);verstärkte Ausscheidung von Natrium im Urin
-Urtikaria (fachspr., lat.);Nesselsucht;Nesselfieber;Nesselausschlag
-(sich) durchlavieren (ugs.);(sich) durchschummeln;(sich) durchschwindeln;(sich) durchmogeln (ugs.)
-Handelspartner;Vertragspartner
-Amtsentsetzung (schweiz., österr.);Entlassung;Kassation (veraltet);Absetzung;Amtsenthebung;Entthronung
-Rettung aus (finanzieller) Not;Bailout
-Stoßkraft;vorwärts drängende Kraft;Impetus
-lösen;abtrennen
-Ehrabschneider;Verleumder
-Forderungen (gerichtlich) geltend machen;Schuld eintreiben
-y-Achse;Senkrechte (ugs.);y-Koordinate;vertikale Achse;Ordinate;Ordinatenachse
-abmagern;auszehren;ausmergeln;abzehren
-Hof;Bauerngut;Bauernhof;Ranch
-Aussage;Proposition
-anbaufähig;kulturfähig
-entfällt;nicht zutreffend (in Formularen)
-(in etwas) eintreten (fig.);Mitglied werden;(einer Sache) beitreten;(sich) anschließen
-Weide;Weideland;Grasland;Viehweide
-Farbstoffteilchen;Farbstoff;Färbestoff;Pigment (geh., lat.)
-Solstitium (fachspr.);Sonnwende (schweiz.);Sonnenwende
-Übergang;Vererbung;Übertragung
-plätschern;leicht wogen;(sich) kräuseln;dahinrieseln
-Würfel;Spielwürfel
-Ungleichheit;Nicht-Ausbalanciertheit;Schräglage (fig.);Unausgewogenheit;mangelnde Balance;Unterschied;Nicht-Ausgewogenheit;Ungleichgewicht;Schieflage (fig.);Unwucht (fig.)
-Operator;Systemadministrator;Superuser;Sysadmin;Systemoperator;Sysop;Root-User;Admin (ugs.);Systembetreuer;Administrator
-Klosterbruder;Ordensmann;Ordensbruder;Bruder;Mönch (Hauptform)
-Ausweisung;Identifikation;Identifizierung
-mürbe;bröselig;bröcklig;krümelig;krümlig;bröckelig
-gleichliegend;übereinstimmend;entsprechend;homolog;ähnlich
-FI-Schalter;FI-Schutzschalter;Fehlerstrom-Schutzschalter;Fehlerstromschutzschalter
-Auftragsvergabe;Auftragswesen
-Doctor juris (lat.);Dr. jur. (Abkürzung);Doktor des Zivilrechts
-bescheiden;spärlich;einfach;spartanisch;schlicht;anspruchslos;uneitel;modest (veraltet);karg;unprätentiös;genügsam;unverwöhnt;frugal
-Augenlidentzündung;Blepharitis (fachspr.)
-allein;wie ein Eremit;eremitenhaft;solo;zurückgezogen;wie ein Einsiedler;(ganz) für sich;einsam;eremitisch
-abkanten;schief stellen;abrunden;abschrägen;abfasen
-Eispickel;Pickel
-Zuckerraffinade;Raffinade
-Finanzinstitut;Geldhaus;Kreditinstitut;Geschäftsbank;Geldinstitut;Kreditanstalt;Sparkasse;Finanzinstitution;Bankhaus;Bank
-poppen (ugs.);(sich) verlustieren (mit) (verhüllend);rammeln (ugs.);(jemanden) vernaschen (ugs.);Verkehr haben;(ein) Rohr verlegen (derb);(seinen) ehelichen Pflichten nachkommen;mit jemandem schlafen (verhüllend);(den) Lachs buttern (derb);einen wegstecken (ugs.);(jemanden) beschlafen;bimsen (derb);koitieren (geh.);pudern (ugs., österr.);(sich) lieben;verkehren;begatten (fachspr.);(jemanden) flachlegen (ugs.);knattern (ugs.);pimpern (derb);es kommt zum Geschlechtsverkehr (fachspr., Amtsdeutsch);den Beischlaf vollführen (fachspr., Amtsdeutsch);vögeln (ugs.);erkennen (geh., biblisch);(jemanden) knallen (derb);(sich) vergnügen (mit) (verhüllend);(jemanden) beglücken (ugs.);im Bett landen (mit) (ugs., verhüllend);kohabitieren (geh.);(eine) Nummer schieben (ugs.);Sex machen (ugs.);nageln (derb);Sex haben (Hauptform);(es) treiben (mit) (ugs.);schnackseln (ugs.);ficken (derb);Liebe machen (ugs.);bumsen (ugs.);Geschlechtsverkehr haben;in die Kiste gehen (ugs.);(mit jemandem) intim werden (verhüllend);kopulieren (fachspr.)
-Zerstörungswut;Vandalismus;blinde Zerstörungswut;Wandalismus (alte Schreibung bis 2017)
-Evaluation (fachspr.);Überprüfung;Beurteilung
-Masse;Menschenmenge;Zusammenrottung (abwertend);Ansammlung (von Menschen);Menschenmasse;Menge (von Menschen / Personen);Menschenansammlung;Auflauf;Menschenauflauf;Gewühl (von Menschen);Menschenschar;Pulk;Menschentraube;Menschengewühl
-verspeisen;in sich hineinschaufeln (ugs.);verputzen (ugs.);auffressen;fressen;runterschlingen (ugs., norddeutsch);hinunterschlingen;(sich) reinschieben (ugs.);verschlingen;vertilgen;aufessen;wegputzen (ugs.);(sich) reinziehen (ugs., salopp)
-satanisch;diabolisch;teuflisch
-reklamieren;bemäkeln (ugs.);bemängeln;beanstanden;monieren;rügen
-Linguistik;Sprachwissenschaft;Sprachforschung
-Hubschrauber;Helikopter;Heli (ugs.);Hubi (ugs.)
-Aufsehen;Skandal;Schande;Affäre
-Rausschmiss (ugs.);Rauswurf (ugs.);Feuerung (ugs.);Entlassung;Freisetzung;Kündigung
-Treffer;Tor
-vollkommen;perfekt;der Weisheit letzter Schluss (ugs.);vollendet;das Gelbe vom Ei (ugs., fig., sprichwörtlich);Traum...;(das) Beste vom Besten;bestens;ideal;bestmöglich;Spitzen...;wie gemalt (ugs.);wie kein zweiter;optimal (Hauptform);(absolut) spitze;keine Wünsche offenlassend
-mehr als;satt (adjektivisch);über;gut (ugs.)
-Stich;Pieks;Piekser (ugs., regional)
-flammendes Inferno (fachspr., Jargon, fig., mediensprachlich);Brand;Feuer
-Benzin;Sprit;Vergaserkraftstoff (veraltet);Ottokraftstoff;Otto-Kraftstoff
-Schuhsohle;Laufsohle;Sohle
-Seite;Blatt;(ein) Fetzen Papier (ugs., abwertend);(ein) Papier;Bogen (fachspr.);Wisch (ugs., abwertend);Papierblatt;Zettel;(ein) Blatt Papier (Hauptform)
-Treter (ugs., Plural);Latschen (ugs., Plural);Schuhe (Plural, Hauptform);Schlappen (ugs., Plural);Fußbekleidung;Schuhwerk;Schuh (Singular, Hauptform)
-Linux;GNU/Linux
-Unwille;Trotz;Widerwille;Unlust
-Ausdruck;Term
-Beurteilung (Hauptform);kritische Würdigung;Kritik;Einschätzung;Urteil;Rezension;...besprechung
-Nachschubwesen;Logistik
-in Hülle und Fülle (ugs.);waggonweise;wie Sand am Meer (ugs.);in großer Zahl;Legion sein (geh.);in rauen Mengen (ugs.);vielzählig;zahlreich;reich;haufenweise;zuhauf (geh.);abundant (geh.);en masse (geh., franz.);viel;massenhaft;unzählig;reichhaltig;reichlich;reihenweise;üppig;im Überfluss;eine Menge Holz (ugs., fig.);unbegrenzt;massig (ugs.);massenweise
-Schadensfreude (selten);boshaftes Vergnügen;Schadenfreude (Hauptform);Häme;diebische Freude
-bewalden;aufforsten
-Briefkasten;Postkasten
-Zwangs-Exilierung;(zwangsweise) Ausbürgerung;Verbannung
-Irländer;Ire
-immens (geh.);wesentlich;ausnehmend;haushoch;deutlich;sehr;erheblich;ziemlich;ein gerüttelt Maß (an);viel;eine gehörige Portion (ugs.);tierisch (ugs.);ordentlich was (ugs.);enorm;beträchtlich;arg;weit;jede Menge (ugs.);ausgeprägt;allerhand (ugs.)
-spinnen;knüpfen;wirken;weben;flechten
-Flugzeugflügel;Flügel;Tragfläche
-Unabhängigkeit;Beweglichkeit;Mobilität
-Aufschneiderei;Ammenmärchen;Anglerlatein (ugs.);Erdichtung;Schwindelei;Münchhausiade;Erfindung;Bluff;Jägerlatein (ugs.);Märchen (fig.);Seemannsgarn;Windei;Lügengeschichte;Schwindel;Münchhauseniade;Geflunker (ugs.);Flunkerei (ugs.);wilde Geschichte(n) (ugs.);Räuberpistole
-Irrtum;Paralogismus;klarer Fall von denkste (ugs., Spruch);Fehlannahme;Denkfehler;falsche Schlüsse;falsche Annahme;Fehlschluss;Fangschluss;non sequitur (fachspr., lat.);Irrglaube;Trugschluss;Missverständnis;Fehleinschätzung
-Hausschwein;Borstenvieh (ugs.);Wutz (ugs.);Schwein
-Streuung;Standardabweichung (fachspr.);Schwankungsbreite;Varianz (fachspr.);Streubreite
-immigrieren;einwandern;zuwandern
-Inkontinenz;Unvermögen, Harn oder Stuhl zurückzuhalten;Blasenschwäche
-Traktor;Bulldog;Trecker;Schlepper;Zugmaschine
-Wildtier;Wild
-allemal;auch ohne das;ohnedem;sowieso;unabhängig davon;ohnehin;(egal) wie man es (auch) dreht und wendet;so oder so;ohnedies;auch so (schon);eh (ugs.);davon abgesehen;per se (geh.)
-normiert;standardisiert;konformistisch;konform
-Sage;Märchen;Mythos;Fantasy-Story;(nur eine) schöne Geschichte (ugs.);Überlieferung;Saga;Fabel;Legende;Mär (altertümelnd);Mythus
-lebende Legende;Galionsfigur;Mythos (fig.);Leitbild;Ikone;Vorbild;leuchtendes Vorbild;Säulenheiliger;Idol;Lichtgestalt (fig.)
-Schächer (bib.) (geh.);schwerer Junge (ugs., fig.);kriminelles Element;Krimineller;Verbrecher;Gesetzesbrecher;Malefikant (geh., veraltet);Straftäter;Schuft;Delinquent;Täter;Übeltäter
-(das) Retrieval (fachspr., engl.);Ermittlung;Recherche;Nachforschung;Suche
-begünstigen;vereinfachen;leichter machen;erleichtern
-japsen (ugs.);nach Luft ringen;hecheln;nach Atem ringen;röcheln;schnauben;keuchen;heftig atmen;schnaufen
-Radio (ugs., Hauptform);Äther (geh., fig., veraltend);Funk (Jargon, veraltend);Hörfunk;Rundfunk
-Radio;Radioempfänger;Radiogerät;Rundfunkgerät;Radioapparat
-öffentlich;publik
-abrücken (von);(sich) abgrenzen;nichts zu tun haben wollen (mit) (ugs.);nichts am Hut haben wollen (mit) (ugs.);(sich) distanzieren
-ausreichen;(jemandem) reichen;(gut) genug sein (für);(jemandem) genügen;langen (ugs.);es tun (ugs.);(schon) hinkommen (mit) (ugs.);auskommen mit;(jemandes) Bedarf (an ...) ist gedeckt;mehr braucht jemand nicht
-Eroscenter;(gewisses) Etablissement (verhüllend);Bordell;Puff (ugs.);Freudenhaus;Laufhaus;Stundenhotel;Prostitutionsstätte (fachspr.)
-ausreden;zu Ende sprechen
-drauf haben (ugs., salopp);(jemandem) gegeben sein (geh.);in der Lage sein;(einer Sache) mächtig (sein);(etwas) beherrschen;fähig sein;beherrschen (zu);imstande sein (zu);im Stande sein (zu);(etwas) können;umgehen können (mit);vermögen (zu) (geh.)
-ein (seltsames) Kauderwelsch sprechen;etwas daherbrabbeln (von) (ugs.);Kauderwelsch reden;brabbeln;kaum zu verstehen sein;(sich etwas) in den Bart murmeln (ugs.);(sich etwas) in den Bart brabbeln (ugs.);(sich etwas) in den Bart nuscheln (ugs.);radebrechen;die Zähne nicht auseinander bekommen (ugs.);(etwas) daherbrabeln (ugs.);(sich etwas) zusammennuscheln;nuscheln;unverständlich sein
-abbilden;modellieren
-Export;Ausfuhr
-Omi (ugs.);Großmutter;Omama (ugs.);Großmama (ugs.);Oma (ugs.)
-Staatsverfassung;Grundgesetz;Verfassung;Konstitution
-Spechtler (ugs., österr.);Voyeur;Spanner
-(gut) vorankommen;vorangehen;nach vorne gehen;voranschreiten;weiterschreiten;vorrücken;fortschreiten;Fortschritte erzielen;weiterkommen;vorwärts kommen;Fortschritte machen
-Anti-Pilzmittel;Fungizid
-verbinden;bandagieren;umwickeln
-abdichten;dicht machen;dämmen
-Kugelschreiber;Kuli (ugs.)
-Instrukteur;Lehrende(r);Kursleiter;Ausbilder;Lehrperson;Instruktor;Lehrer;Dozent
-Leine;Strippe (ugs., regional);Schnur
-Krem (alte Schreibung bis 2011);Salbe;Kreme (alte Schreibung bis 2011);Balsam;Paste;Creme
-Pessimismus;Schwarzmalerei;Schwarzseherei
-Torheit (geh.);Unvernunft;Unverstand;Einfalt;Niaiserie (geh., franz.);Dummheit;Einfältigkeit
-Luftsprung;Kapriole
-Gitarre;Gitte (fachspr., Jargon);Klampfe (ugs.)
-Subskribent;Abonnent;Bezieher
-Ehrenmal;Erinnerungsstätte;Denkmal;Mahnmal;Monument
-Mephistopheles;Gottseibeiuns;(der) Leibhaftige;Fürst der Finsternis;Dämon;666;Deibel;Satan;Luzifer;Beelzebub;Mephisto (geh.);Antichrist;Teufel (Hauptform);(das) große Tier;Düvel (ugs., plattdeutsch);Diabolo
-himmlischer Wächter;Cherub;Kerub;Engel;Seraphim;Gottesbote
-Magistrale (lat.);Hauptstraße;Hauptverkehrslinie;Hauptverkehrsstraße
-N-Wort (metasprachlich, verhüllend);Farbiger (veraltet);Mohr (veraltet);Neger (derb, stark abwertend);Mensch mit dunkler Hautfarbe;Nigger (vulg., amerikanisch, stark abwertend);Schwarzafrikaner;Bimbo (vulg., auch figurativ, stark abwertend);Schwarzer
-Aussicht;Rundblick;Panorama;Blick
-Eiklar;Eiweiß
-Untermenge;Teilmenge
-Wiese (Hauptform);Grünfläche;Weide;Rasen;Rasenfläche;Bleiche (regional, veraltet);Grünland;Grün;Matte
-Häcker (fränk.);Weinbauer (Hauptform);Winzer;Weinhauer (österr.);Rebhauer (schweiz.);Weingärtner (süddt., österr.);Weinzierl (bayr.);Rebmann;Hauer (österr.)
-SS (fachspr., Abkürzung);Segelschiff
-Prophet;Hellseher;Augur (geh., lat.);Weissager;Vorbote;Spökenkieker (ugs., norddeutsch, westfälisch);Seher;Wahrsager
-Wirklichkeitssinn;Realismus;Realitätssinn
-Bürzel (Jägerspr.);Schwanz;Sterz;Rute;Schweif
-schusselig (ugs.);trottelig (ugs.);vergesslich;schusslig (ugs.);tüddelig (ugs., norddeutsch);zerstreut;(ein) zerstreuter Professor (humor. Klischee) (ugs.);tüdelig (ugs.)
-Kodex;Verfügung;Codex;Verordnung;Gebot;Erlass;Edikt;Dekret
-Schnuller;Lutscher;Nuggi (schweiz.);Dutzl (ugs., bayr.);Nuckel
-Runzel;Falte
-Einsturz;Zusammenbruch;(das) Zusammenstürzen
-(militärischer) Überfall;Handstreich;Überraschungsangriff
-Geldmittel;Vermögen;Kapital;Finanzen
-Götzenbild (abwertend);Abgott;falscher Gott;Götze (abwertend);Idol
-Schwärmerei;Gefühlsduselei;Romantik;Gefühlsüberschwang
-risikofreudig;leichtsinnig (Hauptform);waghalsig;leichtfertig;gewagt;risikoaffin
-Regierungskabinett;Regierungsmannschaft;erste Ebene der Regierung;Ministerriege;Kabinett;Ministerrunde (ugs.);Regierung;Kollegium der Minister
-Ergebnis;Resultat;Quintessenz;Endergebnis;Ausgang;Fazit
-wegpusten (ugs., salopp);erschießen;abschießen;umlegen (ugs.);totschießen;umnieten (ugs.);über den Haufen schießen (ugs.);niederschießen;wegknallen (ugs.);abballern (ugs.);abknallen (ugs.)
-Konjunktion (Hauptform);Bindewort
-Lenkberechtigung (österr.);Fahrerlaubnis;Fahrberechtigung;Lenkerberechtigung (österr.)
-komprimieren;zusammendrücken;verdichten
-Fernglas;Feldstecher;Prismenfernglas;Fernrohr (ugs.);Binokular
-wiederaufladbare Batterie;Akku (Kurzform, Hauptform);Speicherzelle;aufladbarer Stromspeicher;Sekundärbatterie;aufladbare Batterie;Akkumulator
-fortziehen;(einer Sache) den Rücken kehren (fig.);(sich) lossagen (von) (auch figurativ);(einen Ort) verlassen;alles hinter sich lassen;wegziehen;(einer Sache / einem Ort) Goodbye sagen (fig.);(sich) lösen;(einer Sache / einem Ort) auf Wiedersehen sagen (fig.);alle Zelte hinter sich abbrechen (fig.);fortgehen;weggehen;(sich) abwenden (geh.);(seine) Zelte abbrechen (fig.)
-*;Asteriskus (lat.);Asterisk (lat.);Stern;Sternchen
-Empfindsamkeit;Gefühlsduselei;Sentimentalität;Gefühligkeit;Tränendrüse (ugs.);Rührseligkeit;Tränenseligkeit;Weinerlichkeit;Herzschmerz;Larmoyanz
-Team (engl.);Kollektiv;Gruppe;Zelle
-(sein) 'Kaiser Wilhelm' (ugs., scherzhaft);(sein) 'Friedrich Wilhelm' (ugs., scherzhaft);Autogramm (auch figurativ);Unterschrift (Hauptform);Namenszeichen;Namenszug;Signum;Incidit (fachspr.);Signatur
-Kompendium;Nachschlagewerk;Kurzlehrbuch;Handbuch
-Zähnepressen;Zähneknirschen;Bruxismus (fachspr.)
-Dichtung;Abdichtung
-Fudi (ugs., schweiz.);Futt (ugs., rheinisch);Kehrseite (scherzhaft);Fott (ugs., rheinisch);Sitzfleisch (ugs.);Nates (fachspr., anatomisch, lat.);Pobacken (ugs.);Podex (ugs.);Steiß;Arsch (derb);Hinterbacken (ugs.);verlängerter Rücken (euphemistisch);Regio glutea (fachspr., lat.);Allerwertester (ugs.);(das) hintere Ende (von jemandem) (geh.);Glutealregion (fachspr., lat.);Popo (ugs.);Gesäß;vier Buchstaben (ugs.);Kiste (ugs.);Regio glutealis (fachspr., lat.);Schinken (ugs.);Po (ugs.);Hinterteil;Füdli (ugs., schweiz.);Pöter (ugs.);Clunium (fachspr., lat.);Hintern (ugs.)
-Partner;Co. (Abkürzung);Mitinhaber;Compagnon
-flussab;stromabwärts;in Richtung Mündung;flussabwärts;zur Mündung
-übervorteilen;übertölpeln;über den Tisch ziehen (ugs., fig.);neppen (ugs.);überrumpeln
-Hausarzt;Praktischer Arzt;Allgemeinmediziner
-zerlegen;aufteilen (auf);unterteilen;untergliedern;stückeln;(auf)splitten (ugs., Anglizismus);gliedern;segmentieren;teilen
-Numerus clausus (lat.);NC (Abkürzung);Zulassungsbeschränkung
-nüchtern;keinen Alkohol getrunken haben(d);nicht betrunken
-Irrgarten;Labyrinth
-Sperrholztasche;Holzvernichtungstüte
-Heizungswärmewarmheit;Ofenheizungshitze
-Kabeldepesche (fachspr., historisch);Kabel (fachspr., historisch);telegraphische Depesche (fachspr.);Telegramm (veraltet)
-Blondine;blondes Gift (ugs.);Frau mit blonden Haaren;Blondchen (ugs., abwertend);Blondie (ugs.)
-notwassern;im Wasser notlanden
-human;menschengerecht;menschenwürdig;menschlich;philanthropisch;menschenfreundlich
-Diskreditierung;Entwertung;Devaluation (geh., franz.);Abwertung;Deklassierung
-voluntaristisch;aus eigenem Willen;willentlich
-Hippie;Blumenkind
-Menschwerdung;Fleischwerdung;Inkarnation;Verkörperung
-kollabieren;in sich zusammensinken;zusammenbrechen;in sich zusammenstürzen
-dringen (aus);hervorquellen;hervortreten;austreten (Flüssigkeit, Gas);treten (aus);quellen (aus)
-Habitat;Lebensraum
-Preisverfall;Deflation;Preisrückgang
-Trennung von Staat und Kirche;Laizität;Laizismus
-Nationengemeinschaft;Konföderation;Staatengemeinschaft;Völkergemeinschaft;Staatenbund
-Gleichmacherei (abwertend);Gleichschaltung (Jargon);Nivellierung;Abbau von Unterschieden
-Osten;Orient;Morgenland;Levante
-Pädagogik;Erziehungswissenschaft
-an jedem Tag;an allen Tagen;kein Tag vergeht ohne (dass);jeden Tag;Tag für Tag;es vergeht kein Tag ohne (dass);tagtäglich;tagein, tagaus;pro Tag;täglich;alle Tage
-Unentschieden;Remis;Gleichstand
-reanimieren;wiederbeleben;wieder zum Leben erwecken (ugs., fig.);revitalisieren (fachspr.)
-entgegengesetzt;gegensätzlich;antithetisch (geh.);dualistisch (geh.);widerstreitend;diskrepant (geh.);polar;adversativ (fachspr., Sprachwissenschaft, lat.);widersprüchlich;gegenteilig;konträr;unvereinbar;sich widersprechend;oppositär (geh.);antagonistisch (geh.);advers;diametral (geh.)
-Gott;lieber Gott (Anrede) (ugs., Kindersprache);Herrgott;Der Ewige;Allvater;Urschöpfer;Schöpfer;Allmächtiger;Weltenlenker
-steigern;aufbessern;erhöhen
-Gernegroß (ugs.);Graf Koks von der Gasanstalt (Ruhrdeutsch veraltend) (ugs.);Gleisner (geh., veraltet);Bramarbas;Kneipenkaiser (ugs.);Muchtprinz (ugs., berlinerisch);nichts dahinter (sein);Großtuer;Sprücheklopfer;Profilneurotiker (ugs.);Maulheld (derb);große Klappe und nichts dahinter (ugs.);Sprüchemacher;Selbstdarsteller;Wichtigtuer;(der) Held vom Erdbeerfeld (ugs.);Kneipenkönig (ugs.);Prahlhans (ugs.);aufgeblasener Gimpel (ugs.);Schaumschläger (ugs.);Stammtischexperte (ugs.);Wichtigmacher (österr.);Aufschneider;Graf Rotz von der Backe (ugs.);Aufpudler (österr.);Großmaul (derb);Renommist;Blender;Möchtegern;Maulhure (derb, weibl.);(großer) Zampano (ital.);Prahler;Großschnauze (ugs.);Windbeutel (ugs.);jemand, der viel erzählt, wenn der Tag lang ist (ugs.);Großkotz (derb);Angeber;Großsprecher
-einbüßen;verwirken;verscherzen (ugs.)
-Einfriedigung (veraltet);Umfriedung;Umfassung;Einzäunung;Einhegung;Einfriedung;Eingrenzung;Befriedung;Umgrenzung;Abgrenzung;Absperrung
-Sehnsucht;Gier;Sehnen;Drang;Bedürfnis;Durst (ugs., fig.);Verlangen;Wunsch;Begierde;Begehren
-Angler;Fischer;Petrijünger (ugs.)
-Ebene;flaches Land;Flachland;plattes Land (ugs.)
-graue Vorzeit (ugs., scherzhaft-ironisch);Historie;Vergangenheit;Geschichte;Verflossenheit (geh.)
-in tausend Stücke zerspringen;zu Bruch gehen;aufplatzen;splittern;reißen;zerspringen;platzen;zerschellen;zerplatzen;bersten;zersplittern;in tausend Stücke auseinanderfliegen;zerbrechen;springen;in Scherben gehen
-verfrachten;expedieren (geh., bildungssprachlich, scherzhaft-ironisch);transportieren;überführen;verbringen (Amtsdeutsch);schaffen;fahren;befördern;karren (ugs.);bringen
-Boden;Fußboden
-Erdboden;Erdreich;Erde;Boden;Untergrund
-Grundlage;Grundstein (fig.);Basis;Ausgangspunkt;Ausgangsebene
-Wägeli (schweiz.);Wagen;Hänger (ugs.)
-Apona (ugs.);Kartoffel (Hauptform);Eachtling (regional);Grundbirne (ugs.);Ärpel;Erdbirne (bayr., rheinisch, schweiz., österr.);Knulle;Krumber (regional);Grumbier;Solanum tuberosum (fachspr., griechisch, lat.);Erdbirn;Bramburi (ugs.);Potacken (ugs., regional);Erdapfel (bayr., rheinisch, schweiz., österr.);Arber
-Schönheitsschlaf (ugs., ironisch);Schlummer;Schlaf;Ruhe;Nachtruhe
-Lebensweise;Lebensart;Lebensstil
-unaufmerksam sein;schlafen (ugs., fig.);dösen (ugs.);nicht zuhören;nicht aufpassen
-einsam (ugs.);bedauernswert;desolat;verlassen (ugs.);beklagenswert;trostlos
-Fehde (veraltend);Kontroverse;Konflikt;Auseinandersetzung;Streit
-Art;Klasse;Gattung;Menge
-Zubereitungsweise;Küche;Kochkunst;Kulinarik (geh.)
-mit Niveau;anspruchsvoll;intelligent;niveauvoll;mit Anspruch
-gebildet;gesittet;soigniert (geh., franz.);formgewandt;kultiviert
-Kanapee;Récamière (fachspr., franz.);Sofa (Hauptform);Couch (engl.);Ottomane (geh., historisch);Longchair (engl.);Bettbank (regional);Triclinium (fachspr., Antike, historisch);Chaiselongue (geh., franz., veraltend);Diwan (persisch);Bettcouch (regional)
-Pfandleihanstalt;Pfandhaus;Leihhaus;Pfandleihe;Pfandkreditanstalt
-Differenz;Abweichung;Verschiedenheit;Unterschied
-Gesangssolist;Vokalist (fachspr.);Sänger (Hauptform);Interpret;Gesangskünstler
-Rhythmus;Versmaß;Metrum
-unbeheizt;nicht beheizt;ungeheizt
-Bahnsteig;Perron (schweiz.)
-ungekocht;nicht gar;roh
-Amt (geh.);Job (ugs.);Aufgabe;Posten (geh.)
-verkloppen (ugs., salopp);abstoßen;verhökern (ugs., salopp);verticken (ugs., salopp);absetzen;loswerden (an) (ugs., salopp);verscheuern (ugs., salopp);verscheppern (ugs., salopp);vertreiben;vertickern (ugs.);an die Frau bringen (ugs., gendergerecht);(jemandem) unterjubeln (ugs., salopp);verschachern (ugs., negativ);raushauen (ugs., salopp);verklopfen (ugs.);verscherbeln (ugs., salopp);abverkaufen;vermarkten;veräußern;abgeben (ugs.);an den Mann bringen;verkaufen (Hauptform);losschlagen;versilbern (ugs.);verramschen (ugs., negativ)
-Zerspaner;Zerspanungstechniker (österr.);Zerspanungsmechaniker
-Alkoholabhängiger;Gamma-Trinker (fachspr.);Saufbold (derb);Bierdimpfl (ugs., bayr.);Schluckspecht (ugs.);Besoffski (derb);Schlucker (ugs.);Zecher (geh., scherzhaft, veraltend);Säufer (derb);Trinker;Trunksüchtiger;Alkoholiker;Alki (ugs.);Trunkenbold (ugs.);Zechbruder (ugs.);Schnapsdrossel (ugs.);Saufbruder (ugs.);Suffkopp (ugs., norddeutsch);Spritnase (derb);Wermutbruder (ugs., veraltend);Spritti (derb);Alkoholkranker;Bsuff (bayr., österr.)
-(sich) eine Zigarette anstecken;schmauchen;rauchen;schmöken (ugs., norddeutsch);paffen (ugs.);(sich) eine anstecken (ugs.);qualmen (ugs.);eine (Zigarette) durchziehen (ugs.);quarzen (ugs.);(sich) eine rauchen gehen (ugs.)
-eingraben;verscharren;einbuddeln;vergraben;verbuddeln
-abgehoben (ugs.);elitär;(im) Elfenbeinturm (fig.);ohne Bodenhaftung (fig.)
-Bekrittelung (selten);(kleinliches) Herumkritisieren;Bemäkelung (geh., selten);Gemecker (Hauptform);Kritikasterei;Herumkritisiererei;Meckerei;Beckmessertum;Nörgelei;Rumgemecker;Genörgel (ugs.);Krittelei;Beckmesserei (geh.);Mäkelei
-Vereinigung;Zusammenschluss;Verein;Verbund;Verband
-Glücksgefühl;Glück;Hochgefühl
-Wäschesteif;Wäschestärke
-Lady;Madame (franz.);Signora (ital.);vornehme Dame;Frau von Stand;Dame;Grande Dame (franz.);elegante Frau
-Femme fatale (franz.);verhängnisvolle Frau;Männer verschlingende Frau;Dragon Lady (engl.);Vamp;männermordende Frau
-Homotropie (selten);gleichgeschlechtliche Liebe;Homosexualität;Homophilie
-Deputierter;Delegierter;Mandatsträger;Abgeordneter;Volksvertreter;Repräsentant;Parlamentarier;Mandatar (österr.)
-Jahrmarkt;Kirchweih;Kirchtag (süddt.);Kirmes;Kirtag (bayr., österr.);Kerwe (ugs.);Volksfest;Rummel (ugs.);Dult (bayr., österr.);Dorffest;Hoggedse (ugs., schwäbisch);Markt
-geröstet;gebraten;gegrillt;gesotten
-simmern (lassen);vorsichtig sieden lassen;köcheln;auf kleiner Flamme sieden
-Speisefolge;Menü
-Tempo (ugs., Markenname);Stofftaschentuch;Rotzlappen (derb);Schnuderlumpen (ugs., schweiz.);Tempotaschentuch;Taschentuch;Sacktuch (ugs., süddt.);Schneuztuch (ugs., bayr., österr.);Schnupftuch;Papiertaschentuch;Rotzfahne (derb);Nastuch (ugs., schweiz.)
-Markt;Basar (persisch);Marktplatz
-Gemüsemarkt;Wochenmarkt;Markt
-Auslage;Schaufenster
-Tablette;Kapsel;Brausetablette;Kautablette;Pille;Dragée;Globuli (Alternativmedizin, nur Plural)
-Heilkunde;Iatrik (griechisch);Gesundheitslehre;Heilkunst;Medizin
-Musikdrama;Oper;Singspiel
-Stiefel;Knobelbecher (ugs., Soldatensprache, militärisch);Boot (engl.);Stiebel (ugs., regional);Botten (ugs.)
-Anken (ugs., alemannisch, schweiz.);Schmalz (alemannisch, ostalemannisch);Streichfett;Anke (ugs., oberrheinisch);Butter
-Eau de Parfum;Rasierwasser;Aftershave;Eau de Toilette;Eau de Cologne;Eaux de Toilette;After-Shave-Lotion;Eaux de Cologne;Eaux de Parfum;Aftershavelotion;Kölnisch Wasser
-Schlusspunkt (fig.);Finale;Ende
-Hass;Abscheu
-Fahrgerät;Landfahrzeug (fachspr.);Gefährt;Fahrmaschine;Fahrzeug;Vehikel
-(ganz) in seinem Element sein;wissen wo's langgeht;in etwas was weghaben (ugs.);Kenne haben (ugs.);Ahnung haben (ugs.);bestens vertraut sein (mit);weiß, was er tut (ugs.);(sich) verstehen auf (ugs.);beschlagen (sein);zu Hause sein (in);(ein) Fässle (sein) (ugs., schwäbisch);versiert sein;(den) Durchblick haben;sattelfest (sein);ist mein zweiter Vorname! (ugs.);(sich) auskennen
-Haussuchung;Durchsuchung;Hausdurchsuchung
-Schlafwandler;Somnambulerich (lat., veraltend);Nachtwandler;Somnambuler (lat.);Mondsüchtiger
-Strom;Elektrizität;elektrischer Strom;Saft (ugs.)
-organisieren;abhalten;veranstalten;aufführen;ausrichten
-abstrakt;unwirklich;begrifflich;unanschaulich;ungegenständlich;unkonkret
-divertieren;(sich) weiden;(sich) ergötzen;erfreuen;delektieren
-damit eins klar ist (ugs.);ich betone (Einschub);wohlbeachtet;wohlgemerkt;damit das klar ist (ugs.);notabene;dies sei in aller Deutlichkeit gesagt (Einschub) (geh.)
-Vorübung;Training;Probe;Exerzitium (fachspr., lat., veraltend);Exercitium (fachspr., lat., veraltend);Übung (Hauptform)
-schwenkend;volatil (fachspr.);schwankend;schaukelnd;wechselvoll
-durch Worte mitgeteilt;mündlich;verbal (geh.);wörtlich;sprachlich
-prägnant (ugs.);aussagekräftig;wichtig;gehaltvoll (geh.);signifikant;wesentlich;hauptsächlich;bedeutsam
-knallrot;feuerrot;puterrot
-(mit Medikamenten) ruhigstellen;sedieren
-Sinn ergeben;sinnvoll sein;Sinn machen (ugs.);Sinn haben
-leer;nicht mehr da;gar (ugs., bayr., fränk.);es gibt kein (...) mehr (ugs.);zur Neige gegangen (geh.);alle(s) weg (ugs.);aufgebraucht;es hat kein (...) mehr (ugs., süddt.);ist kein (...) mehr da (ugs.);alle (ugs.);nichts mehr da an (ugs.);zu Ende gegangen;aus (ugs.)
-beschreibend;deskriptiv
-festgelegt;besiegelt;determiniert;bestimmt
-Geschmack;Gout;Gusto
-(religiös) rein;koscher;unbefleckt
-(jemandem) wichtig sein (Hauptform);nicht gleichgültig sein;(eine) (große) Rolle spielen;(jemandem) ankommen auf (variabel);(für jemanden) Bedeutung haben;von Bedeutung (sein);(großen) Wert legen auf;bedacht (sein) auf (geh.);(jemandem) unter den Nägeln brennen (fig.);(jemandem) lieb und teuer sein;(für jemanden) relevant (sein);(jemandem) lieb und wert sein;von Belang (sein);(jemandem) (ein) Herzensbedürfnis sein (geh., variabel);(jemandem) nicht egal sein;von (großer) Wichtigkeit (sein);(jemandem) auf den Nägeln brennen (fig.);(jemandem) am Herzen liegen (ugs.);(jemandem etwas) ausmachen (ugs.)
-sakrosankt;unverletzlich;tabu;über jede Kritik erhaben;über alle Zweifel erhaben;heilig;unantastbar
-mittelalterlich;steinzeitlich (abwertend, fig.);von Vorgestern (fig.);(auf den) Müllhaufen der Geschichte (gehörend) (ugs.);verstaubt (fig.);vorsintflutlich (abwertend, fig.);vorgestrig (fig.);rückständig (abwertend);überholt;(das) wussten schon die alten Griechen (ugs.);finsteres Mittelalter (abwertend, fig.);(ein) Anachronismus (geh.);antiquiert;Steinzeit (abwertend, fig.);anachronistisch;gestrig (fig.)
-im Zentrum;zentral;in der Mitte;mittig
-selbstverständlich;klarerweise;trivialerweise;evidenterweise
-warmer Wind;Föhnwind;Föhn
-desaströs (geh.);vernichtend;katastrophal;verderblich;verheerend
-(die) jungen Alten (Schlagwort);nicht mehr der (die) Jüngste;nicht mehr ganz (so) jung;oll (derb);in fortgeschrittenem Alter;alt und grau (sein / werden);in Ehren ergraut (geh.);vorgerückten Alters;alt;in die Tage gekommen (ugs.);in vorgerücktem Alter;im reifen Alter von;angejahrt;viele Jahre auf dem Buckel haben (ugs.);in (jemandes) reife(re)n Jahren (geh.);in die Jahre gekommen (ugs.);gealtert;im Rentenalter;gehobenen Alters;in hohen Jahren stehen (geh.);auf meine (deine, seine...) alten Tage (ugs.);zwischen 80 und scheintot (derb, variabel);in höheren Jahren stehen (geh.);ältlich;fortgeschrittenen Alters (geh.)
-penetrieren;eindringen;durchsetzen;einführen;durchdringen
-besetzt;belegt;voll;ausverkauft
-voll (ugs.);alkoholisiert;abgefüllt (ugs.);zu tief ins Glas geschaut haben (fig.);trunken (geh.);breit (ugs.);stoned (ugs.);berauscht (geh.);zu (ugs.);dicht (ugs.);bezecht;hacke (ugs.);einen über den Durst getrunken haben (fig.);strack (ugs.);besoffen (ugs.);betrunken (Hauptform);hackevoll (ugs.);voll wie eine Haubitze (ugs.);ein paar Gläser zu viel gehabt haben;strunz (derb);lattenstramm sein (ugs.);blau (ugs.)
-für noppes (ugs.);umsonst (Hauptform);vergütungsfrei;zum Nulltarif;kostenlos;gebührenfrei;für umsonst (ugs.);für lau (ugs.);unentgeltlich;umme (ugs.);für Gottes Lohn (ironisch);kostenfrei;für Nüsse (ugs.);nicht berechnet werden;für umme (ugs.);gratis
-valide;komplett;gültig;perfekt;rechtskräftig
-Anschlag;Attentat
-Widerspruch erregen;Widerstand erregen;polarisieren
-geschenkt bekommen;einsacken (ugs.);nicht Nein sagen;(sich etwas) einstecken (ugs.);abstauben (ugs.);einstreichen;mitnehmen (ugs.);absahnen
-am aufgeführten Ort;a. a. O. (Abkürzung);ibidem (fachspr.);am angeführten Ort;genau dort;an gleicher Stelle;an eben diesem Ort;ebenda;dortselbst;da;daselbst;dort;a.a.O. (Abkürzung);am (genannten) Ort;am angegebenen Ort;ib. (Abkürzung);ebendort;ibd. (fachspr., Abkürzung);hier;ibid. (fachspr., Abkürzung);ebd. (Abkürzung)
-auto...;selbst...
-furzen (ugs.);pupsen (ugs.);einen fahren lassen (ugs.);Luft im Bauch haben;Blähungen haben;einen ziehen lassen (ugs.);blähen;flatulieren;(einen) Wind fahren lassen;(einen) scheißen (derb)
-Gleichgewicht;Equilibrium (fachspr.);Ausgewogenheit;Balance
-unbegrenzt;unendlich;unvorstellbar
-Nerd (ugs.);Chippie (ugs.);Geek (ugs.);Hacker (ugs.);Computerfreak
-durchgehend;durchwegs (süddt., österr.);durchgängig;konsequent;einheitlich;konsistent;aus einem Guss;durchweg
-verwehren;nicht zugestehen;vorenthalten;verweigern
-verbummeln (ugs.);verlieren;verschmeißen (ugs., bayr.);verschlampen (ugs.);verdusseln (ugs.);verschusseln (ugs.);verschludern (ugs.);verschluren (ugs., rheinisch);verkramen (ugs.);verklüngeln (ugs.);verbaseln (ugs., regional);(einer Sache) verlustig gehen;verlegen
-wirklich;handfest (ugs.);gegenständlich;bestimmt;anschaulich;reell;auf den Gegenstand bezogen;echt;fassbar;anwendungsbezogen;sachbezogen;konkret;greifbar
-Computerwissenschaft;Informatik
-Optimalwert;Bestmögliches;optimaler Fall;Optimum;Idealwert
-Teil einer Kette;Kettenglied;Glied
-Organisationsplan;Organisationsschaubild;Organigramm;Organisationsdiagramm;Stellenplan
-Hobby;Steckenpferd (ugs.);Privatvergnügen (sein);Freizeitaktivität;Freizeitbeschäftigung
-zusammenhängen;korrelieren;in Zusammenhang stehen;kovariieren (fachspr.);einhergehen mit
-sexuelle Enthaltsamkeit;Keuschheit
-Fuchsschwanz;Standarte (fachspr.)
-Becherglas;Gobelet (franz.);Pokal
-Plastik (ugs.);organisches Polymer;Plaste (ugs., DDR, regional);Kunststoff;Plast (ugs.)
-Made;Engerling;Larve;Raupe
-wiederholen;reproduzieren;nachvollziehen;nachstellen
-Bierseidel;Seidel;Steinkrug;Bierbembel;Krügel;Schnelle;Humpen;Maß;Maßkrug;Augenkanne (ugs.);Henkel (berlinerisch);Bierkrug
-multiplizieren (mit);malnehmen (mit) (ugs.);vervielfachen
-Mundart;Regionalsprache;Kulturdialekt;Regiolekt (fachspr.);Dialekt;Missingsch (fachspr.);regionale Umgangssprache;Stadtmundart;regionale Sprachvariante
-Manuskript;Mitschrift;Notizen;(handschriftliche) Aufzeichnung(en);Skript
-Herrenjackett;Sakko;Jackett
-Bon;Marke
-säuberlich;ordentlich;bereinigt;aufgeräumt;geordnet
-Schnitt;Schnittwunde
-hochzählen;aufzählen;inkrementieren;erhöhen
-Option;Auswahlmöglichkeit;Plan B (ugs.);Wahlmöglichkeit;dritter Weg;Alternative
-Innenausstattung;Interieur
-Gedankenübertragung;Telepathie
-Filz;Gekungel (ugs.);Sumpf (fig.);Freunderlwirtschaft (ugs., österr.);Vetternwirtschaft;Mauschelei(en);Kungelei;Speziwirtschaft (ugs.);Klüngelei(en);Vetterliwirtschaft (schweiz.);Günstlingswirtschaft;Kumpanei;Klüngel (ugs., kölsch);Nepotismus (fachspr.);Vetterleswirtschaft (schwäbisch);Spezlwirtschaft (ugs., bayr.)
-(jemandem etwas) nachsagen;(über jemanden) herziehen;schlecht reden (über);ins Gerede kommen (ugs.);lästern (Hauptform);ablästern (über jemanden) (ugs.);hinter jemandes Rücken reden;munkeln;klatschen;tratschen;(sich) aufhalten über (ugs.);ratschen;(sich) das Maul zerreißen (über) (ugs.);(sich) zuflüstern;(jemanden) bashen (ugs., engl.);(sich) zuraunen;vom Leder ziehen
-Zusammenwirken;Synergie;Synergismus
-Visage (derb);Gesicht (Hauptform);Angesicht;Antlitz;Fratze (derb);Fresse (derb)
-Ofen;Kamin
-Perversion;Perversität;Abartigkeit
-seines Amtes entheben (geh.);seines Kommandos entheben (geh.);entmachten;seines Amtes entsetzen (geh., veraltet);absetzen;abberufen;seines Postens entheben;ablösen;entlassen;abhalftern (ugs.)
-wiedergeben;abbilden
-Abbildung;Visualisierung;Abbild;Illustration;Spiegelbild;Darstellung;Wiedergabe
-(einen) Schlussstrich ziehen (fig.);über den Haufen werfen (Planungen) (fig.);(einer Sache) ein Ende machen;sterben lassen (ugs., fig.);hinter sich lassen;über Bord werfen (ugs., fig.);an den Nagel hängen (ugs., fig.);stoppen;ablassen von;(sich) abwenden von;vergessen;fallenlassen;ad acta legen;fallen lassen;zu Grabe tragen (ugs., fig.);einstampfen (ugs., fig.);beenden;sausen lassen;den Rücken kehren (ugs., fig.);Besser ein Ende mit Schrecken als ein Schrecken ohne Ende. (sprichwörtlich);aufgeben;(sich) verabschieden von;beerdigen (fig.);(davon) Abschied nehmen (ugs.)
-(jemandem etwas) ausreden;(jemandem) abraten (von);(jemanden) dissuadieren (von) (geh., sehr selten, veraltet);(jemandem/jemanden) abreden (von) (selten);(jemanden) abbringen (von);(jemanden) abhalten (von)
-verdrängen;auf das Abstellgleis schieben (ugs., fig.);wegschieben;abdrängen
-Aventüre (geh., veraltet);Wagnis;Erlebnis;Abenteuer
-(jemandem etwas) aberkennen (Hauptform);(jemandem etwas) absprechen;(jemandem etwas) entziehen
-im Kontrast dazu;wogegen;konträr dazu;dennoch;dagegen;im Gegensatz dazu;(ganz) im Gegenteil;wohingegen;andererseits;aber;hingegen;hinwieder;demgegenüber;handkehrum (schweiz.);dieweil;dahingegen (geh.);währenddessen;nur;im Unterschied dazu;jedoch;hinwiederum;während;alldieweil
-Superstition (engl.);Geisterglaube;Aberglaube;Gespensterglaube
-(den) Aus-Knopf drücken;(den) Ein-Aus-Schalter betätigen (förmlich);ausmachen (ugs.);abstellen;den Stecker (raus)ziehen (ugs.);abschalten;abdrehen;ausschalten;ausknipsen
-abebben;abklingen;abnehmen;schwächer werden;zurückgehen;abflauen;nachlassen;(sich) abschwächen;abflachen;weniger werden;im Schwinden begriffen sein
-Abendbrot;Nachtmahl (österr.);Abendessen;Souper (franz.);Abendmahlzeit;Brotzeit (bayr.);Nachtessen (schweiz.);Znacht (ugs., schweiz.);Vesper (regional)
-Fahrtbeginn;Abgang;Start;Fortgang;Abreise;Aufbruch;Abzug;Verschwinden;Abfahrt;Weggang
-aufhalten;abhalten;abwehren;parieren;abfangen
-Departure;Abflug;Start
-abgespannt;abgearbeitet;erschlafft;entkräftet;angeschlagen;verbraucht (fig.);schlapp;ausgepowert (ugs.);abgerackert (ugs.);überanstrengt;erschöpft;kaputt (ugs.);gestresst;ausgelaugt;verratzt (ugs.);fertig (ugs.);abgehetzt;abgeschlagen (schweiz.);verausgabt;ausgebrannt (fig.);abgekämpft;mitgenommen
-isoliert;kontaktlos;insular (geh., fig.);ohne (soziale) Kontakte;beziehungslos;kontaktarm;zurückgezogen;ohne soziale Bezüge;einsam (Hauptform)
-abgeklärt;ausgeglichen;bedacht;besonnen;klug;taktisch
-unwillig;abhold (geh.);abgeneigt;(sich) wenig begeistert zeigen (über);ungeneigt;widerstrebend;lustlos;aversiv (geh.);ungern
-geschmackvoll;abgerundet;abgestimmt;harmonisch
-Résumé (franz., schweiz.);Schluss;Zusammenfassung;Schlussbemerkung;Schlusswort;Analyse;Schlussbetrachtung;Schlussfolgerung;Resümee;Fazit
-Delegierter;Bote;Kurier;Beauftragter;Delegat;Abgesandter;Parlamentär;Bevollmächtigter;Ablegat (lat., religiös);Emissär;Ordonnanz
-abgeschwollen;abgeklungen
-Dunst;Qualm
-Erleuchtung;Aha-Erlebnis (ugs.);Eingebung (Hauptform);Einfall;Intuition;Gedanke;Anwandlung;Offenbarungserlebnis;Idee;Inspiration;Offenbarung (für jemanden) (auch figurativ);(plötzliche) Einsicht;Impuls;Anregung;(plötzliche) Erkenntnis
-...brot;Schnitte (ugs.);(ein) Brot mit ...;Butterschmier (auch 'Butterschmeer') (ugs., saarländisch);Bemme (ugs., sächsisch);Bütterken (ugs., ruhrdt.);Knifte (auch 'Kniffte') (ugs., ruhrdt.);belegtes Brot;Scheibe Brot;Dong(e) (ugs., siegerländisch);Butterbrot;Fieze (ugs., erzgebirgisch);Stulle (ugs., berlinerisch, norddeutsch)
-stehen (Jargon);beschlossene Sache;vereinbart;geklärt;festgelegt;abgesprochen;feststehen;abgemacht;geritzt (ugs.);ausgemacht;perfekt;verabredet
-hohlwangig;abgemagert;marastisch (fachspr., medizinisch);(wie) sein eigener Schatten (ugs.);ausgehungert;halb verhungert (ugs.);(nur noch ein) Schatten seiner selbst (ugs.);klapprig (ugs.);knochendürr (ugs.);(wie ein) wandelndes Gerippe (ugs.);(nur noch) Haut und Knochen (ugs.);Hungerleider;vom Fleisch gefallen (ugs.);(stark) unterernährt;morbid (geh.);(stark) untergewichtig;eingefallen (ugs.);marantisch (fachspr., medizinisch);abgezehrt;(wie eine) Leiche auf Urlaub (ugs.);abgemergelt;spindeldürr (ugs.);(die) Rippen einzeln zählen können (bei jemandem) (ugs.);ausgemergelt;magersüchtig;(wie eine) wandelnde Leiche (ugs.);klapperdürr (ugs.);(wie ein) lebender Leichnam (aussehen/herumlaufen) (ugs.);ausgezehrt
-Grenze;Abgrenzung;Grenzlinie;Begrenzung
-untergeordnet;unselbständig;unfrei;abhängig;unmündig;gebunden
-Abhängigkeit;Unselbständigkeit;Hörigkeit;Unmündigkeit
-roden;absägen;umhauen (ugs.);schlagen;fällen (Hauptform);umsägen (ugs.);abholzen
-Nachahmung;Simulierung;potemkinsches Dorf;Kopie;Imitation;Falsifikat;Imitat;Mimikry (fachspr.);Attrappe;Abklatsch;Fälschung;Vortäuschung falscher Tatsachen;Plagiat;Simulation;Vorspiegelung falscher Tatsachen;Fake (ugs., engl.);Nachbildung;Klischee;Schablone
-entbehrlich;unwichtig;abkömmlich
-Kolben (ugs.);Gewürzprüfer (ugs.);Riechorgan (ugs.);Nase (Hauptform);Riecher (ugs.);Gesichtserker (ugs.);Riechkolben (ugs.);Zinken (ugs.)
-Alleinstellung am Markt;Wirtschaftsmonopol;Monopol
-Geflecht;Konstrukt;Gebilde;Konstruktion
-Wurzeln schlagen;ansässig werden
-Prüfungskandidat;Prüfungsteilnehmer (Amtsdeutsch);Proband;Prüfling
-hudeln (ugs.);hinschmieren (ugs.);schlampern (ugs.);(eine) Pfuscharbeit abliefern;schustern (ugs.);versauen (vulg.);rumfuckeln (an etwas) (ugs., ruhrdt.);fuddeln (ugs.);rummachen (an) (ugs.);murksen (ugs.);pfuschen;schlampen (ugs.);schludern (ugs.);unordentlich arbeiten;sudeln (ugs.);vermasseln (ugs.);hinrotzen (ugs.);fudeln (ugs.);stümpern (ugs.);nachlässig arbeiten
-leitend;federführend;führend
-an dieser Stelle;an diesem Ort;hüben (landschaftlich, selten);hierorts;hier
-posthumus (lat.);postum (geh., lat.);posthum (geh., lat.);nach dem Tode
-sabbeln (ugs.);quatschen (ugs.);quasseln (ugs.);(viel, schnell) reden
-Lockvogel;Lockstoff;Köder (fig.);Lockmittel
-Arztpraxis;Praxis
-Praxis;Realität
-Person weiblichen Geschlechts (Amtsdeutsch);Weibsperson (geh., veraltend);Lady (ugs., engl., salopp);Tante (ugs.);(eine) Sie;Weibsbild (abwertend);Grazie (eingeschränkter Gebrauch) (ugs.);Braut (ugs., salopp);Evastochter;Weibsen (ugs., Plural, abwertend, scherzhaft);(eine) Eva;Perle (ugs., regional, salopp);Weib (veraltend);Frauenzimmer (veraltet);weibliche Person;Kalle (derb, Gaunersprache);Vertreterin des weiblichen Geschlechts;...tante (ugs., abwertend);weibliches Wesen (scherzhaft);Frau (Hauptform);Frauensperson;Vertreterin des schönen Geschlechts;Schnalle (ugs., salopp);Dame;Weibsstück (derb, abwertend);Trine (ugs., schimpfwort, selten);weiblicher Mensch;Mutti (ugs.)
-Heroin;Diamorphin (fachspr.);Schnee (ugs.);Diacetylmorphin (fachspr.)
-Fixerstübli (ugs., schweiz.);Fixerstube (ugs.);Gassenstübli (ugs., schweiz.);Druckraum (ugs.);Drogenkonsumraum;Gassenzimmer (ugs., schweiz.)
-Internet;internationales (Computer-)Netzwerk;Datenautobahn (ugs.);Netz der Netze (ugs.)
-Überholung;Pflege;Instandhaltung;Unterhalt;Wartungsarbeiten;Unterhaltung;Erhaltung;Wartung
-Möglichkeiten;Potenzial;Anlage;Gegebenheit;Potential
-Gebilde;Struktur;Organisation;Organismus;Anlage;System
-pertinent;teleologisch (fachspr.);ergebnisorientiert;sachbezogen;machbarkeitsorientiert;vom Ergebnis her;von der Sache her (gesehen);zielorientiert;pragmatisch;anwendungsbezogen
-den Hut aufhaben (ugs., fig.);(etwas) verantworten;(für etwas) verantwortlich zeichnen (in einer Sache);geradestehen (müssen) (für) (ugs., fig.);(etwas) vertreten müssen;verantwortlich (sein);(etwas) zu verantworten haben;responsabel (geh., veraltet);auf jemandes Kappe gehen (ugs., fig.);(die) Verantwortung tragen
-Rehabilitationszentrum;Sanatorium;Genesungsheim;Klinik;Heilstätte;Heilanstalt
-Duell;Waffengang;Kampf Mann gegen Mann;Zweikampf
-Atheist;Glaubensloser;Gottesleugner (derb);Gottloser;Ungläubiger;Agnostiker;Heide
-Wilddieb;Wilderer (Hauptform);Wildschütz;Jagdfrevler
-Früchte tragen (ugs.);(es) zeigen sich Erfolge;lohnenswert (sein);(sich) auszahlen;(sich) rechnen;(sich) bezahlt machen;(sich) rentieren;(sich) lohnen (Hauptform)
-Götterspeise;Wackelpudding;Wackelpeter
-Fassung;Haltung;Contenance (geh., franz.);Kontrolle;Beherrschung
-Unikat;Unikum;Einzelanfertigung (fachspr., kaufmännisch);Einzelstück
-asi (ugs.);gegen die Gesellschaft;asozial;assig (ugs.);unsozial;gesellschaftsschädlich
-Zeitungswesen;Presse;Totholzmedien (ugs., abwertend);Printmedien
-Fiskus;Finanzamt
-Schicksalsgläubigkeit;dem Schicksal ergeben;Fatalismus;Schicksalsergebenheit
-im Gespräch sein (als) (ugs.);als heißer Kandidat gelten (ugs., fig.);in spe;künftig;(als Kandidat) aufgestellt;zukünftig;designiert;(schon als ...) gehandelt werden (ugs., fig.);(der / die / das) nächste;angehend;nominiert;kommend;(für einen Posten) gehandelt werden (ugs., fig.);vorgesehen (für)
-(jemanden / etwas) mandatieren (fachspr.);(jemanden) beauftragen (mit);(jemanden) betrauen (mit);(jemanden) verdingen (zu / als) (veraltet);(etwas) in Auftrag geben;(jemandem etwas) auftragen;(jemandem einen) Auftrag erteilen (variabel)
-begeistern;entzücken (geh.);euphorisieren;anregen;hinreißen;mitreißen;enthusiasmieren (geh.)
-Deminutiv (fachspr., selten);Verniedlichungsform;Diminutivum;Verkleinerungsform (Hauptform);Diminutiv
-herausstellen;exponieren;betonen
-exponiert;herausgestellt;herausgehoben
-zweigeschlechtig;zwittrig;zweigeschlechtlich;androgyn;hermaphroditisch;hermaphrodit;zwitterhaft
-Zwitter;Intersex;Gynander;Hermaphrodit
-Tierarzt;Tierdoktor;Veterinär;Tiermediziner;Veterinärmediziner;Viehdoktor (ugs.)
-Venia Legendi (geh., bildungssprachlich, lat.);Fakultas (geh., bildungssprachlich, lat.);Lehrbefugnis;Lehrberechtigung;Facultas Docendi (geh., bildungssprachlich, lat.);Lehrbefähigung;Lehrerlaubnis
-deutsch;germanisch;teutonisch
-Land der Dichter und Denker (ugs.);Teutschland (veraltet);Teutonia (lat.);Land der Richter und Henker (sarkastisch);deutsche Lande (fachspr., Jargon, werbesprachlich);Kartoffelland (ugs., ironisch);Deutschland (Hauptform);Piefkei (ugs., österr.);Schland (ugs., Verballhornung);Germania;grosser Kanton (ugs., schweiz.);Tschland (ugs., Verballhornung)
-männliche Beschneidung;Zirkumzision (fachspr.)
-sterblich;vergänglich;mortal
-Divis (fachspr.);Mittestrich (fachspr.);Trennstrich;Bindestrich;minus (ugs., Jargon)
-Travestie;(scherzhafte) Umgestaltung (eines Gedichts)
-Imitat;Kopie;Plagiat;Nachbau;Nachbildung;Nachahmung;Fälschung
-Sterilisation;Sterilisierung
-Gegenwartsform;Präsens;Gegenwart
-vollendete Vergangenheit;dritte Vergangenheit;Plusquamperfekt (Hauptform);Vollendung in der Vergangenheit;3. Vergangenheit;Vorvergangenheit
-Körperausscheidung;Ausscheidung;Sekret;Exkretion (fachspr.)
-Sterilität;Unfruchtbarkeit;Infertilität
-wiegen;wägen
-wassersüchtig;hydropisch
-Blödelei;(ein) Kalter (ugs.);Calembourg (geh., franz.);Kalauer (Hauptform);Flachwitz;müdes Witzchen;(nach dem Motto) 'Witz komm raus, du bist umzingelt.' (ugs.);flacher Scherz (ugs.);geistloser Wortwitz
-Auswahl;Güteklasse
-Majorität;Mehrzahl;Überzahl;Mehrheit
-Unterzahl;Minderzahl;Minorität;Minderheit
-inoffizieller Mitarbeiter (der Stasi);informeller Mitarbeiter (ugs.);IM;geheimer Informator (Jargon, historisch)
-VEB Horch und Guck (ugs.);Horch und Guck (ugs.);Ministerium für Staatssicherheit;Stasi;(die) Firma (ugs., Jargon);Staatssicherheitsdienst;MfS;Staatssicherheit
-Delir (fachspr.);Säuferwahnsinn;Delirium tremens (fachspr.)
-Umnachtung;Mattscheibe (ugs.);Delirium;Black-out;Bewusstseinstrübung;Bewusstseinsstörung;Umnebelung;Delir;Verwirrtheit
-weh tun;schmerzen;wehtun
-Eskapade;närrischer Einfall;Streich;Schelmenstreich;Tollerei;Mätzchen (ugs.);Kapriole;Verrücktheit;Tollheit
-Kapriole;besonders hoher Sprung der hohen Schule (Reitsport)
-Tschick (ugs., österr.);Kippe (ugs.);Glimmstängel (ugs.);Lulle (ugs.);Lunte (ugs.);Zigarette;Zigi (ugs., schweiz.);Zichte (ugs.);Fluppe (ugs.);Zippe (ugs.);Ziese (ugs.);Sargnagel (ugs., scherzhaft-ironisch);Pyro (ugs., negativ)
-Verbindung;Liierung;Bindung
-altbewährt;erprobt;eingeführt;allseits bekannt;bewährt;verlässlich;(der) Klassiker;etabliert;altbekannt;probat;anerkannt;(der) gute alte (...) (ugs.);alterprobt;gefestigt;kennt man schon
-abbilden;übertragen;reproduzieren;projizieren
-Pomade;Brillantine;Haarfett;Haarcreme;Brisk (ugs., Markenname);Frisiercreme
-verschämt;spröde;schamhaft;wie eine Jungfrau;zimperlich;prüde;genant (geh., franz.)
-Aufdringlichkeit;Zudringlichkeit;Penetranz (geh.)
-Rekordhalter;Preisträger;Champion;Erster;Erstplatzierter;Gewinner;ganz oben auf dem Treppchen;Favorit;ganz oben auf dem Siegertreppchen;Meister (Sport);Bestplatzierter;Champ (ugs.);Sieger;Bester;auf dem ersten Platz;Tabellenerster
-Teufel Alkohol;Alkoholika (Plural);Alkohol (ugs.);Seelentröster (ugs., fig.);Alk (ugs., salopp);alkoholisches Getränk (Hauptform);alkoholhaltiges Getränk
-(jemandem etwas) entgegensetzen;Paroli bieten;dagegenhalten;Kontra geben (ugs.);(jemandem) entgegentreten;kontern;(jemandem) die Stirn bieten
-Koloskopie (fachspr.);Darmspiegelung
-wirken;eignen;taugen (ugs.);dienen;fungieren;herhalten
-Teuerungsrate;Geldentwertungsrate;Inflationsrate;Teuerung (ugs.);Preissteigerungsrate
-Kamera;Camcorder;Videokamera
-(die) Kleidung wechseln;(sich) umkleiden (geh.);(sich) umziehen;(sich) was anderes anziehen (ugs.)
-sintemalen (scherzhaft, veraltet);da ja;zumal;sintemal (scherzhaft, veraltet);umso mehr als;da nämlich;umso eher als;zumal ja;umso weniger als;nämlich;wo doch;dabei (hauptsatzeinleitend) (ugs.);wo schließlich;da;doch (mit Verb + Subj. davor; literarisch);zumal da;schließlich;ja;wo ja (ugs.);wo sogar;denn;wenn sogar
-eben dadurch;eo ipso (lat.);ipso facto (lat.);damit zugleich
-mit einem Sprenger bewässern;sprengen
-Gegenüberstellung;Konfrontation
-Observation;Überwachung;Beschattung;Observierung;Beobachtung
-Kult (ugs.);im Schwange (sein) (geh.);kultig (ugs.);hoch im Kurs stehen (ugs.);trendig (ugs.);zum guten Ton gehören(d) (fig.);(die) Mode sein;gefragt;dem Zeitgeist entsprechend;stylisch;angesagt (ugs.);sexy (ugs., fig.);aktuell;(voll) im Trend (ugs.);en vogue (geh., franz.);Szene...;in Mode (ugs., Hauptform);im Trend liegen(d);Konjunktur haben(d);hip (ugs.);trendy (ugs.);in (betont, Emphase) (ugs., engl.);(...) ist das neue (...; ist der / die neue ...) (Jargon, floskelhaft)
-Sekt;Prickelbrause (ugs.);Prickelwasser (ugs.);Schaumwein;Puffbrause (derb)
-ätzend;scharf;beißend;kaustisch;reizend
-unerkannt;unter falschem Namen;inkognito
-dabei;damit;im Zuge dessen;darüber;hiermit;dadurch;hierbei;hierdurch;indem
-Quartal;Trimenon (Schwangerschaft) (fachspr.);Trimester;Dreimonatsabschnitt;drei Monate;Vierteljahr
-Rückgang der Wirtschaftsleistung;kontraktive Phase;leichter Konjunkturrückgang;leicht negatives Wirtschaftswachstum
-Schmähschrift;Traktat (geh., lat.);Pamphlet (geh., engl., franz.);Pasquill (geh., ital.);Streitschrift;Spottschrift
-Ontologie (fachspr., Computerlinguistik);Relationen zwischen Begriffen;Begriffshierarchie
-Atlantik;großer Teich (ugs.);Atlantischer Ozean
-verneinen;abstreiten;leugnen;negieren;ins Gegenteil verkehren
-architektonische Funktionseinheit;Komplex;Gebäudekomplex;Menge von Gebäuden
-Anspruchslosigkeit;Bescheidenheit;Bedürfnislosigkeit;Genügsamkeit
-restriktiv;eingeengt;begrenzt;limitiert;eingeschränkt
-homophob;schwulenfeindlich
-Gewalttäter;Rabauke (ugs.);rücksichtsloser Mensch;gewalttätiger Mensch;Rowdy;Brutalo (ugs.);Gewaltmensch
-immer noch;bis jetzt (...) pausenlos (variabel);nach wie vor;weiterhin (Vergangenheitsperspektive);fortwährend;noch immer (Hauptform)
-Eskalation;Verschärfung;Pointierung;Verstärkung;Zuspitzung;Ausweitung;Steigerung;Ausuferung;Verschlimmerung
-demografisch;die Bevölkerungsentwicklung betreffend;demographisch
-Whirlpool;Sprudelbad;Jacuzzi (Markenname)
-Promotion;Erlangung der Doktorwürde;Erwerb eines Doktortitels
-Vereinheitlichung;Normalisierung;Harmonisierung
-fein;schön;positiv;gut;manierlich
-Rost;Korrosion
-Kanne (ugs.);Buddel (ugs.);Flasche;Pulle (ugs.);Fläschchen (ugs.)
-Pläsier;Erfüllung;Vergnügen;Zufriedenheit;Befriedigung;Beglückung;Genuss
-Zwerg;Heinzelmännchen;Kobold;Wicht;Wichtelmännchen;Winzling;Wichtel;Däumling;Gnom;Wichtelmann
-leise sprechen;(jemandem etwas) ins Ohr hauchen (auch ironisch, fig.);murmeln;(jemandem etwas) ins Ohr sagen;wispern;flüstern (Hauptform);(jemandem etwas) zuflüstern;tuscheln;mit tonloser Stimme (sagen o.ä.);säuseln;raunen;hauchen;(jemandem etwas) zuraunen;munkeln;(die) Stimme dämpfen;zischeln;hinter vorgehaltener Hand (zuflüstern o.ä.);tonlos (sprechen o.ä.)
-Klapprechner (ugs.);tragbarer Computer;Mobilrechner;Schlepptop (ugs., scherzhaft);Laptop;Notebook
-Scrotum;Hodensack;Skrotum;Sack (vulg.)
-Meeresniveau;Meeresspiegel;Normalnull
-Glandes (fachspr.);Glans penis (fachspr.);Eichel;Glans (fachspr.);Spitze des Penis
-nicht von Dauer;für eine Übergangszeit;nicht auf Dauer;kurzzeitig;(nur) eine Übergangslösung;transient (geh.);keine endgültige Lösung;(für) eine Weile;(nur) vorübergehend (ugs.);temporär;zeitlich begrenzt;zur Überbrückung;nicht für immer;übergangsweise;(nur) für den Übergang;nicht dauerhaft;nicht für die Ewigkeit (gedacht);zeitweilig;eine Zeit lang
-Pediküre;Fußpflege
-Fittiche;Flügel;Schwinge
-individuell;gibt's nur einmal (auf der Welt) (ugs.);einzig und allein (Verstärkung);unikal (fachspr.);einzig;weißer Rabe (Person) (fig.);kommt nicht wieder (Gelegenheit) (ugs.);ohnegleichen;alleinig;der seinesgleichen sucht (geh.);sui generis (nachgestellt) (geh., lat.);beispiellos;singulär;nie gekannt;einzigartig;einzel- / Einzel- (z.B. Einzelstück, Einzelmeinung);steht allein (da);sondergleichen (geh.);unverwechselbar (ugs.);nicht vergleichbar;wie nichts sonst;wie kein zweiter;unvergleichlich;unnachahmlich;wie kein anderer;einmalig
-Vermächtnis;Nachlassdokument;Testament;Letzter Wille;letztwillige Verfügung
-Elfe;Sylphe;(gute) Fee;Luftgeist;Elbe (Tolkien);Elb;Albe
-entfernen;beseitigen;loswerden (ugs.)
-gefühlskalt;frigide;kühl;unerregbar;kalt
-beleidigender Ausdruck;Fluchwort;Schimpfwort;Ordinärwort
-in den betreffenden Zeitabschnitt nicht hineingehörend;anachronistisch;zeitwidrig;zeitlich falsch eingeordnet
-System zur Kontrolle und Führung eines Unternehmens;Unternehmensverfassung;Corporate Governance
-Anspruchsgruppe (fachspr.);Anspruchsberechtigter;Interessensgruppe (fachspr.);Stakeholder
-Kidnapper;Hijacker (engl.);Entführer;Geiselgangster (ugs.);Geiselnehmer
-Fortüne (geh.);Meise (ugs., österr.);Glück (Hauptform);Fortune (geh., franz.);Schwein (ugs.);Dusel (ugs.);Glick (ugs., bayr.);Massel (ugs., jiddisch);Masel (ugs.);Masen (ugs., österr.)
-Krankenbesuch;Visite
-im Vordergrund stehen(d);Vorfahrt haben (fig.);unabdingbar (sein) (geh.);wichtig (sein);oben auf der Prioritätenliste (stehen);wesentlich (sein);Priorität haben;oberstes Gebot (sein)
-Rad;Fahrrad;Radl (ugs., bayr., österr.);Zweirad;Velo (franz., schweiz.);Hirsch (ugs.);Veloziped (franz., veraltet);Drahtesel (ugs.);Bike (ugs., engl.)
-(sich) erholen;(sich) auskurieren;wiederhergestellt werden;gesunden;rekonvaleszieren (fachspr., lat.);auf dem Weg der Besserung (sein);(wieder) (ganz) gesund werden;überwinden (Krankheit);genesen;(jemandem) geht es besser;(sich) berappeln (ugs.);(wieder) auf die Beine kommen (ugs.)
-die beiden Hübschen (ugs., scherzhaft);sauberes Pärchen (ugs., abwertend);Tandem (fig.);Gespann (ugs.);zwei Menschen (variabel);Doppelpack (ugs., fig.);Zweierkombination;Zweierkombi;Pärchen;Duo;die beiden Unzertrennlichen;Zweierverbindung;Paar (Personen) (Hauptform);Duett;(das) doppelte Lottchen (ugs., scherzhaft, veraltet)
-spucken;rotzen (derb);speien
-Schluffen (ugs.);Bereifung;Luftreifen;Rad (ugs.);Pneu;Reifen
-einfrieren (fig.);ins Stocken geraten;ruhen;stehen bleiben;nicht weiterkommen (ugs.);gleichbleiben;erlahmen;auf Eis liegen (ugs., fig.);stagnieren;stillstehen;festfahren;stocken;ins Stocken kommen;lahm liegen
-Sumpf;Tümpel;Pfuhl
-Luft kriegen (ugs.);atmen;Luft bekommen;Luft holen;hauchen
-es (jemandem) mit dem Mund besorgen (vulg.);schwanzlutschen (vulg.);blasen (vulg.);lecken (vulg.);oral befriedigen
-Pumpernickel;Schwarzbrot
-Tongebung;Sprachmelodie;Betonung;Satzmelodie;Tonhöhenverlauf (fachspr.);Intonation
-(einen) guten Namen haben (variabel);profiliert;(einen) guten Ruf zu verlieren haben (variabel);(sein) Name hat (in bestimmten Kreisen) einen guten Klang (variabel);geachtet werden;renommiert;gut beleumdet (geh., variabel);bestbeleumdet (geh.);geschätzt werden;(einen) guten Ruf zu verteidigen haben (variabel);(einen) guten Leumund haben (variabel);gut beleumundet (sein) (geh., variabel);(sich) eines guten Ruf(e)s erfreuen (geh.);(gut) angesehen sein (variabel);anerkannt;(einen) guten Ruf haben (variabel);(ein) (hohes) Ansehen genießen;namhaft;(einen) guten Ruf genießen (variabel);in einem guten Ruf stehen (variabel)
-verdutzen;(jemanden) wundern (ugs.);verblüffen;verwundern;für Überraschung sorgen (journal.);überraschen;in Erstaunen setzen;erstaunen;frappieren
-lichtlos;aphotisch
-Mobbing;Schikane;Psychoterror am Arbeitsplatz
-Attentäter;Saboteur;Terrorist;Untergrundkämpfer
-Unschuldsengel;Nymphchen (geh.);Kindfrau;Nymphe (geh., bildungssprachlich);süßes Früchtchen (fig.);(eine) Lolita
-abwiegen;auswiegen;wiegen;einwiegen
-Haben;Gutschrift;Guthaben
-noch und nöcher (ugs., scherzhaft);(ein) Overkill an (engl., fig.);mehr als genug;(ein) Überangebot (an);zu viel des Guten;auf keine Kuhhaut gehen (ugs., fig.);doppelt und dreifach (ugs.);ausufernd (viel);jenseits von Gut und Böse (ugs.);nicht mehr feierlich (ugs.);überreichlich;viel zu viel (ugs.);überschießend (viel) (fachspr.);entschieden zu viel;(ein) Überfluss an;des Guten zu viel (geh.);überzählig;zu viel;über und über;übergenug
-Freigeld;rostende Banknoten;Schwundgeld;Fließgeld
-Zinssystem;Schuldsystem
-uneingeschränkt;ganzheitlich;total;absolut;gesamtheitlich;allumfassend;holistisch
-Toxikum;Giftstoff;Schadstoff;gesundheitsgefährdender Stoff;Gift (Hauptform)
-Fremder;Sommerfrischler;Urlaubsreisender;Reisender;Erholungssuchender;Urlaubsgast;Feriengast;Tourist (Hauptform);Touri (ugs.);Urlauber (Hauptform)
-würdevoll;patriarchalisch;altväterlich
-(sich) unabhängig machen;(sich) freischwimmen (fig.);(sich) loslösen;flügge werden (ugs., fig.);(sich) emanzipieren;(sich) ablösen (von)
-weltoffen;extrovertiert;aufgeschlossen;extravertiert (fachspr.);nach außen gerichtet
-introvertiert;zurückhaltend;verschlossen (fig., Hauptform);distanziert;nach innen gekehrt;verschwiegen;reserviert;unaufgeschlossen;zugeknöpft (ugs.);nicht mitteilsam;unzugänglich;in sich gekehrt;nicht erreichbar (fig.)
-Villa;Finca (span., südamer.);Herrenhaus;Domaine (franz.);Anwesen;Landhaus;Manor (engl.);Landsitz;Landgut;Haus (ugs.)
-Monarchie;Alleinherrschaft
-(ein) Evangelium (für jemanden) (ugs., fig.);Dogma (auch figurativ);Lehre;Lehrmeinung;Glaubenssatz;Doktrin
-Doktrin;Grundsatz
-Rücksicht;Toleranz;Verständnis
-infantil;puerilistisch (selten);naiv;albern;kindhaft;kindlich;pueril (fachspr.);unentwickelt;kindisch;unreif;kindsköpfig
-Geschäftskarte;Visitenkarte;Kärtchen (ugs.)
-Korrespondenzkarte;Bildpostkarte;Postkarte (Hauptform);Karte (ugs.);Briefkarte;Grußkarte
-hineinschnuppern;(einen) Versuch wagen;(sich) wagen (an);testen;auf einen Versuch ankommen;die Probe aufs Exempel machen (Redensart);ausprobieren;auf die Probe stellen;erproben;(sich) herantrauen (an);es versuchen mit;versuchen (Hauptform);(einen) Test machen;sein Glück versuchen (ugs.);es auf einen Versuch ankommen lassen;probieren;antesten
-Zusammensein;Beieinandersein;Beisammensein
-irgendwas (ugs.);irgendetwas;etwas
-reinweg gar nichts;gar nichts;absolut nichts;ein(en) Scheißdreck (derb, abwertend);nix und wieder nix (ugs.);null Komma Josef (ugs., österr.);nichts und wieder nichts;rein gar nichts;überhaupt nichts;nullkommajosef (ugs., österr.)
-Unkenntnis;Kenntnislosigkeit;Nichtwissen;Ahnungslosigkeit;Unwissen;Ignoranz
-Dysbalance;Ungleichgewicht;Imbalance (fachspr.)
-aufwiegend;abgeltend;ausgleichend;kompensatorisch
-Kreisbewegung;Rotation;Umdrehung;Drehbewegung;Umlauf;Umkreisung;Drehung;Rotationsbewegung
-Beschwerde;Krankheitssymptom;Krankheitszeichen;Symptom
-zusammenwirkend;synergistisch
-gefäßbedingt;vasomotorisch
-Beugung;Biegung (ugs., österr.);Flexion (fachspr., wissenschaftlich)
-schmerzvoll;leidvoll;qualvoll
-ungleich behandeln;benachteiligen;diskriminieren
-zerlegbar;teilbar;aufteilbar
-Dokumentarfilm;Doku (ugs.);Dokumentation
-kränkelnd;anfällig;labil;kränklich;schwächlich
-Herzlosigkeit;Trägheit des Herzens (relig.);Gleichgültigkeit;Gefühllosigkeit;Härte;Kälte;Taubheit;Hartherzigkeit
-herumhüpfen;herumspringen;herumtanzen
-wahnwitzig;irrwitzig;dämlich (Sache) (ugs.);selten dämlich (Idee, Aktion, Behauptung ...) (ugs.);sinnfrei;irrsinnig;unsinnig (Hauptform);ohne Sinn und Verstand (ugs.);bescheuert (Sache);reiner Blödsinn;hirnverbrannt (ugs., abwertend);töricht (abwertend);aberwitzig;widersinnig;blöd (Sache) (ugs.);(totaler) Quatsch (ugs.);absurd;(ein) Irrsinn (ugs.);sinnbefreit;nicht rational;vernunftwidrig;irre (ugs.);idiotisch (ugs., abwertend);verrückt (ugs.);blödsinnig (ugs.);hirnrissig (ugs.);schwachsinnig (ugs., abwertend);(eine) Idiotie (ugs.)
-freiheitlich;freisinnig;liberal;libertär;liberalistisch
-liberal;vorurteilsfrei;vorurteilslos
-anarchistisch;herrschaftslos;libertär;gesetzlos
-Parlamentarismus;Volksstaat;Volksherrschaft;Demokratie
-Beeinflussung;Manipulation;Verbrämung;Verfälschung;Verschleierung
-darbieten;aufführen;inszenieren;vorführen;in Szene setzen
-ausdrücken;artikulieren
-Verarbeitungssequenz;Anwendungsbereich;Szenario;Anwendungsfall
-Kuschelbär (ugs.);Knuddelmaus (ugs.);Zuckerpuppe (ugs.);Engelchen (ugs.);Teufelchen (ugs.);Kuschelschnuppe (ugs.);Schnubbi (ugs.);Schatzi (ugs.);Hübsche (ugs.);Herzallerliebster;Hase (ugs.);Knuffel (ugs.);Hasibärchen (ugs.);Kleine (ugs.);Darling (engl.);Kuscheltiger (ugs.);Augenstern (ugs.);Mausi (ugs.);Liebesperle (ugs.);Schnuckelchen (ugs.);Kleines (ugs.);Herzblatt;Kleiner (ugs.);Bärchen (ugs.);Engelsschein (ugs.);Gummibärchen (ugs.);Babe (ugs., engl.);Engelmaus (ugs.);Süße (ugs.);Zuckerwürfel (ugs.);Engel (ugs.);Hasili (ugs.);Liebchen (ugs.);Flamme (ugs.);Sonnenschein (ugs.);Kuschelhase (ugs.);Schnuckiputzi (ugs.);Hasipupsi (ugs.);Schatzimausi (ugs.);Zuckerpüppchen (ugs.);Herzbube (ugs.);Honey (ugs., engl.);Kuschelmaus (ugs.);Traumprinz (ugs.);Knuffelchen (ugs.);Knufelbär (ugs.);Puschibär (ugs.);Süßes (ugs.);Kuschelbärchen (ugs.);Schätzelein (ugs.);Schnucki (ugs.);Liebes (Anredeform);Zuckerschnute (ugs.);Schöne (ugs.);(du) Traum meiner schlaflosen Nächte (ugs., ironisch);Maus (ugs.);Traummann (ugs.);Knuddelbär (ugs.);Perlchen (ugs.);Bienchen (ugs.);Spätzchen (ugs.);Bunny (ugs., engl.);Spatz (ugs.);Zuckertäubchen (ugs.);Hasimaus (ugs.);Schnecke (ugs.);Baby (ugs., engl.);Mäuschen (ugs.);Mäusle (ugs.);Schnucke (ugs.);Knuffelschatzi (ugs.);Biene (ugs.);Kuschelmäuschen (ugs.);Püppi (ugs.);Beauty (ugs., engl.);Kätzchen (ugs.);Kuschli (ugs.);Zuckerschnecke (ugs.);Schnuckelmausi (ugs.);Schnuckel (ugs.);Liebesgöttin (ugs.);Schönheit (ugs.);Schatz (ugs.);Liebling (ugs., Hauptform);Puschi (ugs.);Herzchen (ugs.);Püppchen (ugs.);Liebste(r);Schätzchen (ugs.);Hasi (ugs.);Mausbär (ugs.);Hasibär (ugs.);Schatzimaus (ugs.)
-Steuerruder;Ruder;Steuer
-dozieren;(eine) Vorlesung halten;lesen;lehren
-Unterrichtslehre;Unterrichtskunde;Didaktik
-Querkopf;Querulant;Knurrhahn;Nörgler;Brummbär (ugs.);Meckerer (ugs.);Mauler (ugs.)
-Kurzform;Kurzfassung;Zusammenfassung;Kurzversion
-verdummen;stumpfsinnig werden;verblöden;abstumpfen;blöde werden
-Amtsmissbrauch;Machtmissbrauch;Autoritätsmissbrauch
-Kaliber (ugs.);Sorte;Typ;Schlag (ugs.)
-bedrücken;(jemandem) (noch) lange nachhängen;berühren;(jemandem) (schwer) im Magen liegen (ugs., fig.);(jemandem) (schwer) auf der Seele liegen;lasten (auf);sein Päckchen zu tragen haben (ugs., auch ironisch);belasten;(schwer) zu knapsen haben (an) (ugs., regional)
-(sein Geld) arbeiten lassen (fig.);reinbuttern (ugs.);(Geld) stecken (in) (ugs.);investieren;anlegen;reinstecken (ugs.);pumpen (ugs.)
-ungewöhnlich;unregelmäßig;irregulär;außerhalb der Norm;nicht üblich
-nicht real;irreal;nicht wirklich;surrealistisch;traumhaft;unwirklich;surreal;unreal;imaginär
-Seiltänzer;Seilakrobat
-Anarchie;Herrschaftslosigkeit;Gesetzlosigkeit;Regellosigkeit;gesetzloser Zustand
-Similarität;Gleichartigkeit;Ähnlichkeit;Übereinstimmung;Analogie;Gleichheit
-zergliedernd;zerlegend;analytisch
-Kodierer;Verschlüssler;Encoder;Enkoder;Codierer;Verschlüsseler
-enkodieren;verschlüsseln;codieren;encodieren;chiffrieren
-Endstufe;Endverstärker;Leistungsverstärker;Verstärker
-Union;Allianz;Zusammenschluss;Pakt;Bund;Konföderation;Staatenbund;Koalition;Föderation;Vereinigung;Schulterschluss;Bündnis
-gemeinsam;vereint;beieinander;beisammen;zusammen;mitsammen (ugs., süddt.);miteinander
-Allgemeinheit;Gemeinwesen;Publikum (fig.);Öffentlichkeit
-Zwiespältigkeit;Unentschiedenheit;Ambivalenz
-Sanka (ugs., bayr., süddt.);Rettungsauto (ugs.);(die) Rettung (ugs., österr.);Rettungswagen;Krankentransportwagen (fachspr., Amtsdeutsch);Krankenwagen;Sanitätskraftwagen (fachspr., militärisch);Notarztwagen;Krankenkraftwagen (fachspr.);SanKra (fachspr., Jargon, militärisch)
-Zweiheit;Dualität
-Ausgedachtes;Vorgestelltes (fachspr.);Fiktionales;Erdachtes
-episch;narrativ;erzählerisch
-wie in einem Brennglas (zeigen) (mediensprachlich);zusammenfassen;komprimieren;verdichten;eindampfen (ugs.);auf einen einfachen Nenner bringen (fig.);konspektieren (geh., lat.);resümieren;konzentrieren;auf eine einfache Formel bringen (fig.)
-Lyrik;Dichtung;Poesie;liedhafte Dichtung;Gedichte
-Dramatik;handelnde Dichtung
-Affe (ugs.);Entzugssymptom (fachspr.);Abstinenzerscheinung;Entzugserscheinung;Turkey (ugs.)
-druff (ugs., regional);zugedröhnt (ugs.);drogenberauscht;auf Droge(n);bekifft (ugs.);zu (ugs.);stoned (ugs.);dicht (ugs.);zugeknallt (ugs.);drauf (ugs.)
-Mary Jane (ugs.);Kraut (ugs.);Ganja (ugs.);Grünes (ugs.);Ott (ugs.);Gras (ugs.);Marihuana;Dope (ugs.);Weed (ugs.)
-Haschisch;Dope (ugs.);Shit (ugs.);Hasch (ugs.);Piece (ugs.);Braunes (ugs.)
-Snow (ugs.);C17H21NO4 (fachspr.);Kokain;Coke (ugs.);Schnee (ugs.);Koks (ugs.);Nose Candy (ugs.);C₁₇H₂₁NO₄ (fachspr.)
-LSD;Pappe (ugs.);Lysergsäurediethylamid;Acid (ugs.);Lysergic Acid Diethylamide
-(wieder) abgestürzt sein (ugs.);nass (sein) (Alkoholiker) (Jargon);(voll) drauf sein (ugs., Jargon, salopp);(wieder) zur Flasche greifen (fig.);konsumieren (fachspr., Jargon);auf (...) sein (ugs.)
-Injektionsspritze;Pumpe (ugs.);Spritze
-Drogennutzer;Drogenkonsument;Drogensüchtiger;User (ugs.);Fixer (ugs.);Drogi (ugs.);Junkie (ugs.);Drogenabhängiger
-Einschlafmittel;Hypnotikum (fachspr.);Schlaftablette;Schlafpille;Schlafmittel
-Analgetikum (fachspr.);Schmerzmittel (ugs.);Betäubungsmittel
-Abmagerungskur;Fastenkur;Hungerkur;Reduktionsdiät;Schlankheitskur;Schlankheitsdiät;Abmagerungsdiät
-kräftigend;stärkend;tonisch (fachspr.)
-tonisieren (fachspr.);kräftigen
-Gegenanzeige;Kontraindikation (fachspr.)
-Kryotherapie (fachspr.);Vereisungsbehandlung;Eistherapie;Kälteanwendung
-Heilanzeige;Indikation (fachspr.)
-Fortpflanzungsfähigkeit;Fruchtbarkeit;Fertilität (fachspr., lat.)
-Hautkrankheit;Dermatose (fachspr.);Hauterkrankung
-Potenzmittel;Aphrodisiakum;den Geschlechtstrieb anregendes Mittel
-Koexistenz;Nebeneinander;Nebeneinanderbestehen
-Epos;Epopöe (veraltet);Versroman;Heldengedicht
-Teilkultur;Gruppenkultur;Subkultur
-Schemaliteratur (fachspr.);Trivialliteratur (Hauptform);Massenliteratur;Popularliteratur
-darstellen;bezeichnen;anzeigen;signifizieren;titulieren
-trügerisch;schimärisch
-Denkweise;Paradigma;Muster;Art, zu denken;Vorbild;Denkmuster;Denke (ugs.);Sichtweise;Denkungsart;Beispiel;Leitvorstellung
-ruinös;baufällig;schadhaft
-Besonderheit;Kuriosum;Singularität;Rarität;(ein) weißer Rabe (fig.);Seltenheit
-Kurier;Sendbote;Laufjunge;Besorger;Laufbursche;Botenjunge;Bote;Botengänger
-Kräutermajonäse (alte Schreibung bis 2017);Remoulade
-Mandellikör;Amaretto
-Begleiterin;Hostess;Gefährtin
-Analverkehr haben;anal koitieren;arschficken (vulg.)
-Synthese;Zusammenfügung;Zusammenschau;Panoptikum;Vermittlung;Gesamtschau
-füreinander einstehend;einvernehmlich;kameradschaftlich;Schulter an Schulter;verbündet;geeint;miteinander;partnerschaftlich;im Team;in Zusammenarbeit;zusammenstehend;unanim (fachspr.);zusammenhaltend;gleichgesinnt;Hand in Hand;kooperativ;solidarisch;Seite an Seite;vereint;eines Sinnes (geh., veraltet);kollektiv;einträchtig;geschlossen;hilfsbereit;einmütig;kollegial
-am gleichen Strang ziehen (fig.);(sich) solidarisieren;gemeinsame Sache machen (ugs.);paktieren;(ein) Bündnis eingehen (mit);(sich) verbünden;koalieren
-Umgänglichkeit;Menschenfreundlichkeit;Soziabilität;Geselligkeit
-enteignen;verstaatlichen;nationalisieren;in Gemeineigentum überführen;kollektivieren;vergesellschaften;sozialisieren
-einbeziehen;einschließen;implizieren
-Brandmarkung;Kennzeichnung;Stigmatisierung
-Merkmal;Stigma;Zeichen;Kennzeichen
-Umkehrung;Umdrehung;Reversion;Invertierung;Inversion
-aus mehreren Gründen;multikausal;mehrgründig
-Mitgefühl;Sensibilität;Verständnis;Empathie;Einfühlsamkeit;Sensitivität;Zartgefühl;Fingerspitzengefühl;Herz (ugs.);Einfühlung;Einfühlungsvermögen;Empfindungsvermögen;Einfühlungsgabe;Gespür;Feingefühl
-nicht stationär;ambulant
-Suppression (lat.);Unterdrückung
-Mündlichkeit;Oralität
-Literalität;Schriftlichkeit
-mündig;eigenverantwortlich
-Härte;Beständigkeit;Festigkeit;Persistenz;mit Biss (ugs.)
-Auslöser;Zünder;Zündvorrichtung
-Komödie;Lustspiel
-menschenfeindlich;misanthropisch
-einzelgängerisch;kontaktschwach;kontaktarm;isoliert;weltabgewandt;menschenscheu;kontaktgestört;eigenbrötlerisch
-Idealisierung;Schwärmerei;Träumerei
-autoaggressives Verhalten;Autoaggression (fachspr.);Selbstverletzung;selbstverletzendes Verhalten;Artefakthandlung (fachspr.);Autodestruktion (fachspr.);Selbstverstümmelung
-Sorgfalt;Gewissenhaftigkeit;Genauigkeit
-unverhofft;unvorhergesehen;wider Erwarten;unvorhergesehenerweise;gegen alle Wahrscheinlichkeit;zu jemandes (großer) Überraschung;entgegen den Erwartungen;unerwartet (Hauptform);erwartungswidrig;unvorhergesehenermaßen;ungeahnt
-auf Streit aus;krawallig (ugs.);zanksüchtig;kratzbürstig (ugs.);auf Krawall gebürstet (ugs.);streitsüchtig;Streit suchend;zickig (ugs.);provozierend;kiebig (ugs.);zänkisch
-Exponent;Hochzahl
-auswärtig;außer Landes;im Ausland
-Gleichwertigkeit;Äquivalenz;Entsprechung;Gegenwert
-arbeitstauglich;arbeitsfähig;erwerbsfähig
-einbringen;wert sein;verdienen
-Bildungsstätte;Schule (ugs.);Bildungsinstitution;Bildungszentrum;Lehranstalt (Amtsdeutsch);Bildungseinrichtung;Akademie;Bildungsanstalt;Schulungszentrum
-Bildungsfreistellung;Fortbildungsurlaub;Bildungsurlaub
-Bildungsstand;Bildungsgrad;Bildungsniveau;Ausbildungsniveau
-Leistungsberechtigung;Anspruchsberechtigung
-Grundbesitz;Landbesitz;Liegenschaft(en)
-Wundertrank;Zaubertrank;Elixier;Heiltrank
-Exporteur;Ausführer
-Schadensumfang;Schadenshöhe;Schadenssumme;Schadenswert;Schadensausmaß
-Wiedereingliederung in die Gesellschaft;Resozialisierung
-geistiges Eigentum;intellektuelles Eigentum
-Versammlungshalle;Festsaal;Multifunktionsraum;Aula;Veranstaltungsraum
-Hörsaal;Zuhörerraum;Auditorium;Aula
-Architekt;Konstrukteur;Baumeister;Erbauer
-fremd;fremdländisch;exotisch;fremdartig;apart;unbekannt
-Nachklang;Widerhall;Mitschwingen;Resonanz
-Einzahl;Singular
-Zahlwort;Numerale;Numeral
-Artikel;Begleiter;Geschlechtswort
-Tätigkeitswort;Verbum (lat.);Verbum temporale (lat.);Tuwort (ugs.);Verb (Hauptform);Zeitwort;Tunwort (ugs.)
-Adverb;Nebenwort;Umstandswort
-Ausrufewort;Empfindungswort;Interjektion (Hauptform)
-gleichnishaft;sinnbildhaft;allegorisch;symbolisch
-Erläuterung;Explikation (geh.);Äußerung;Darstellung;Erklärung;Darlegung;Auslassung(en) (geh., negativ);(mündliche / schriftliche) Ausführung(en) (geh.)
-sinnbildhaft;im übertragenen Sinn;bildlich;sinnbildlich;im Gleichnis (ausdrücken);symbolisch (Hauptform);zeichenhaft (geh.);metaphorisch;(als) zweite Bedeutungsebene (geh.);allegorisch;gleichnishaft;mit Verweischarakter (geh.);parabolisch
-Zusammenordnung;Syntagma;Zusammengesetztes
-Antonymie;Bedeutungsgegensatz
-Hyponymie (fachspr., griechisch);Unterbegriff;Hyponym (fachspr., griechisch)
-Überbegriff;Superonym (griechisch, lat., selten);Supernym (griechisch, lat., selten);Hyperonym (fachspr., griechisch);Oberbegriff
-Unterdrückung;Repression;Oppression (geh., lat., veraltet)
-hemmend;verlangsamend;suppressiv;unterdrückend;repressiv;inhibitorisch;abbremsend
-vorausblickend;prospektiv;vorausschauend
-Untergliederung;Unterteilung;Segmentierung;Aufgliederung;Gliederung
-realitätsfern;nur in der Fantasie möglich;nur in der Phantasie möglich;unrealistisch;visionär;über den Wolken schweben (ugs.);wirklichkeitsfremd;utopisch;(all)zu optimistisch;unerfüllbar;realitätsfremd
-unter Aufsicht;Vormundschaft;Kuratel;Pflegschaft
-entmündigen;bevormunden;unter Betreuung stellen
-Menschenhasser;Misanthrop;Menschenfeind
-Doppeldeutigkeit;Ambivalenz
-Emissionspreis;Ausgabepreis
-Kontrahierungszwang;Abschlusszwang
-bestätigen;ratifizieren
-nichts sagen;still schweigen (veraltet lit.) (geh.);(den) Mund halten (ugs.);schweigen wie ein Grab (ugs.);schweigen (Hauptform);(das) Sprechen verlernt haben (ugs., ironisch);stumm bleiben;sein Herz nicht auf der Zunge tragen (ugs., fig.);stumm wie ein Fisch sein (bildl.) (ugs.);(jemandes) Lippen sind versiegelt;(sich) in Schweigen hüllen (geh.);keinen Piep sagen (ugs.);keinen Ton sagen (ugs.);keine Antwort geben;keinen Mucks von sich geben (ugs.);kein Sterbenswörtchen sagen (ugs.);den Rand halten (ugs.);kein Wort (zu etwas) verlieren
-durchschlafen;gut schlafen
-hinabsehen;heruntersehen;hinuntersehen;herabsehen
-hochschauen;hinaufschauen
-kegelförmig;konisch
-Kegelkörper;Konus;(endlicher) Kegel
-Kubus;Sechsflächner;Würfel;regelmäßiges Hexaeder
-Tetraeder;Vierflächner;Vierflach
-Oktaeder;Achtflach;Achtflächner
-Chronometrie;Zeitmessung
-zeitlich;chronologisch;chronometrisch
-Injektionsnadel;Kanüle;Hohlnadel
-Kompensation;Gegenleistung;Ausgleich
-während der Geburt erworben;angeboren;konnatal
-virulent;morbiphor (fachspr.);ansteckend;infektiös (fachspr.);übertragbar;kontagiös (fachspr.)
-Kontusion (fachspr., lat.);Quetschung;Prellung
-Enuretiker (fachspr.);Bettnässer
-(tiefe) Bewusstlosigkeit;Koma
-Kompromissbereitschaft;Umgänglichkeit;Gefälligkeit;Großzügigkeit;Beau Geste (geh., franz.);Zuvorkommen;Entgegenkommen;Kulanz;Konzilianz (geh.)
-Dorfschule;Zwergschule (abwertend);Einklassenschule;Gesamtschule (schweiz.);Landschule
-Bevollmächtigter;Repräsentant (geh.);Vertreter;Kurator;Verwalter;Vormund
-Kuratorium;Aufsichtsbehörde;Kontrollorgan
-Opposition;Gegenseite
-oppositionell;antagonistisch;gegensätzlich;gegnerisch
-Unterrichtspflicht;Schulzwang;Schulobligatorium (veraltet);Schulpflicht;allgemeine Schulpflicht
-diktatorisch;totalitär
-(eine) Spanne von zehn Jahren;über zehn Jahre;zehn Jahre hindurch;zehn Jahre;zehn Jahre lang;Dezennium;Zehnjahreszeitraum;lange zehn Jahre;Jahrzehnt;Dekade
-Gesellschaftsstruktur;Gesellschaft;Gesellschaftssystem;Sozialstruktur
-Nicht-Wort;Unwort
-Überläufer;Fahnenflüchtling;Deserteur;Abtrünniger;(ein) Quisling;Verräter (an einer Sache);Fahnenflüchtiger;Wendehals
-Wursthaut;Pelle (ugs.);Haut
-Programmierung;Konditionierung;Gehirnwäsche;Manipulation
-Individualitätsmerkmal;Persönlichkeitsmerkmal (Hauptform)
-Meinungsmache;Meinungsmanipulation;Meinungsbildung
-regelbar;lenkbar;beherrschbar;steuerbar;kontrollierbar
-vorwurfsvoll;anklagend
-Gepflogenheiten;Tradition;Gebräuche;Sitten und Gebräuche;...kultur (geh., aufwertend);Brauchtum;Brauch;Überlieferung
-Geständnis;Beichte;Bekenntnis
-Bestellformular;Bestellzettel
-einfach benutzbar;benutzerfreundlich;intuitiv bedienbar;anwenderfreundlich;einfach bedienbar
-Aufwiegler;Demagoge;Volksaufwiegler;Hetzer;(geistiger) Brandstifter (fig.);Seelenvergifter (fig.);Volksverhetzer;Agitator;Aufhetzer;Populist;Scharfmacher;Provokateur (franz.);Hassprediger;Einpeitscher;Volksverführer;Aufrührer;Brunnenvergifter (fig.)
-Zirkuskünstler;Zirkusdarsteller;Artist
-vermählen;trauen;unter die Haube bringen (ugs.);verheiraten
-allein im Besitz der wahren Lehre (variabel);orthodox;strenggläubig;streng religiös;rechtgläubig
-Geheimgesellschaft;Geheimbund
-Büezer (schweiz.);Lohnarbeiter;Malocher (ugs., salopp);Arbeiter;Hackler (österr.)
-Bankanweisung;Scheck
-anbetenswert;verehrenswert;verehrungswürdig
-Schiffswerft;Reparaturwerft;Dock;Werft;Schiffsausbesserungswerk
-bewaffnen;armieren (geh., veraltet);mit Waffen ausstatten;rüsten
-Straßenbelag;Asphalt;Erdpech;Straßenpflaster
-Backwerk;Gebäck
-Biwak;Feldlager
-zentesimal;hundertteilig
-Hochhaus;Wolkenkratzer
-Rechtsverletzung;Gesetzesverstoß;Gesetzesbruch;Rechtsbruch
-Induktion (fachspr.);Verallgemeinerung
-untermauern;stärken;fundieren;begründen;erhärten
-abkommandieren (auch figurativ, militärisch);aussenden (geh.);deputieren;(irgendwohin) beordern;abordnen;(an einen Ort) schicken;entsenden;delegieren;abstellen
-abschweifen;abweichen;einen Abstecher machen (ugs.)
-Abweichung;Abschweifung;Ablenkung
-Obliegenheit;Pflicht (Hauptform);Verbindlichkeit;Agenda (österr.);Schuldigkeit;Verpflichtung
-Hass (auf);Feindseligkeit;feindselige Einstellung (gegenüber);Animosität (geh.);Feindschaft;Feindlichkeit
-Ironiker;Spötter;Satiriker;Spottdrossel;Spottvogel;Sarkast;Zyniker
-artistisch;künstlerisch
-akrobatisch;artistisch
-ungewollt;ohne zu überlegen;ohne Überlegung;unwillentlich;unwillkürlich;reflexartig;ohne Überlegen;unbewusst;beiläufig;ganz zufällig;reflexhaft;automatisch
-Getreuer (geh.);Schüler;Eleve (geh., veraltet);Anhänger;Gefolgsmann (männl.);Jünger;...ist;Adept (geh.);...(i)aner (geh.);Gefolgsleute
-verzeihen;amnestieren;begnadigen;entschuldigen;vergeben;nachsehen;exkulpieren (fachspr.)
-Fortentwicklung;Weiterentwicklung (Hauptform);Fortgang
-Arzneikunde;Pharmazie;Pharmazeutik;Arzneimittelkunde
-Pillendreher (ugs., scherzhaft);Giftmischer (ugs., fig.);Pharmazeut;Apotheker
-Ergehen;Befinden
-Kartonage;Karton;Schachtel;Pappverpackung;Pappkarton
-Halbtagsbeschäftigung;Halbtagsstelle;Halbtagsarbeit;Halbtagsjob
-sichtbar;visibel (franz.)
-zusammenlaufen;konvergieren;einander näher kommen
-sich (auf etwas) konzentrieren;sich (auf etwas) fokussieren (geh.);seine Aufmerksamkeit (auf etwas) richten
-(jemanden) über die Achsel ansehen (ugs.);abjizieren (geh.);verachten;herabblicken (auf)
-Absatzgebiet;Marktgebiet;Markt
-aneinandergereiht;nacheinander;aufeinander folgend;sequentiell;aufeinanderfolgend;gereiht;sequenziell
-aufdeckend;enthüllend;investigativ
-Tragödie;Trauerspiel;Bocksgesang
-Lebensbejahung;Zuversicht;Optimismus;Zuversichtlichkeit;positives Denken
-Spaß haben (variabel);(sich) (gut) unterhalten (ugs.);(sich) verlustieren (altertümelnd);eine nette Zeit haben (ugs., variabel);auf seine Kosten kommen (fig.);(sich) amüsieren;(sich) prächtig amüsieren;seinen Spaß haben;(sich) vergnügen;(sich) köstlich amüsieren
-Verhaltensvorschrift;Normenkatalog (fachspr., fig.);Benimmregel;Anstandsregel;Verhaltensregel
-(die finanziellen Lasten) tragen (geh.);latzen (ugs.);aufkommen (für);(eine) Zahlung leisten;berappen (ugs.);auf den Tisch blättern (ugs.);bestreiten (Geldbetrag);begleichen (Rechnung);(die) Zeche zahlen (für);verausgaben (Verwaltungsdeutsch);blechen (ugs.);rauspfeifen (ugs.);abdrücken (ugs.);hinblättern (ugs.);prästieren (geh., lat.);löhnen (ugs.);eintreten (Versicherung, Bürge);entrichten;bezahlen (Hauptform);Geld in die Hand nehmen (journal., polit.);ablatzen (ugs.);abführen (Steuern);tief(er) in die Tasche greifen (ugs., fig.);(etwas) springen lassen (ugs.);lockermachen (Geldbetrag) (ugs.);raushauen (ugs.);ausgeben;zahlen;(Schaden) regulieren;geben für (ugs.)
-enthüllend;nachforschend;investigativ
-Nachforschung;Investigation
-Hilferuf;Notruf
-kacheln (ugs.);fahren wie ein Verrückter (ugs.);fahren wie der Teufel (ugs.);flitzen;rasen;fahren wie eine gesengte Sau (ugs.);fahren wie ein Geisteskranker (ugs.);rauschen (ugs.);sausen (altmodisch);düsen (ugs.);brettern (ugs.);jagen;donnern (ugs.);zischen (ugs.);schießen;preschen;fahren wie der Henker (ugs.);stochen (ugs., regional);fegen (ugs.);brausen;heizen (ugs.);fahren wie ein Henker (ugs.);schnell fahren (Fahrzeug) (Hauptform);(einen) heißen Reifen fahren (ugs.)
-ohne Bedenken;nicht gefährlich;bedenkenfrei;bedenkenlos;getrost;gefahrenfrei;unbedenklich
-herausstechend;herausragend
-abrufbar;einsehbar
-überzeugbar;überredbar
-(Die) Zeit ist noch nicht reif.;über ungelegte Eier reden (ugs., fig.);(Das ist noch nicht) das letzte Wort. (ugs., variabel);noch nicht offiziell (sein);(noch) nicht spruchreif (sein) (Hauptform);(Es ist noch) zu früh, um etwas dazu zu sagen.
-polemisch;ätzend (fig.);unsachlich;scharf (fig.)
-gerechtfertigt;begründet;fundiert;untermauert;ausgereift;substantiiert;solide
-unbestimmt;undefiniert;definitionslos
-Begriffserklärung;Abgrenzung;Begriffsbestimmung;Definition;Bestimmung;Begriffsklärung;Eingrenzung;Festlegung;Erklärung;Spezifizierung
-Realdefinition;Sacherklärung
-Nominaldefinition;Worterklärung
-sein Herz auf der Zunge tragen;kommunikativ;nicht auf den Mund gefallen (ugs.);sein Herz ausschütten (ugs.);extrovertiert;extravertiert (fachspr.);gesprächig;mitteilsam
-strapazieren;überanstrengen
-proprietär;herstellerspezifisch;nicht standardisiert
-Provider (engl.);Dienst;Versorger;Anbieter;Lieferant
-abbilden;porträtieren;abmalen;abzeichnen;nachzeichnen;wiedergeben;bildlich darstellen;zeichnen;darstellen;zur Darstellung bringen;fotografieren;konterfeien;malen;ein Bild machen
-Tagesprogramm;Liste der Tagesordnungspunkte;Tagesordnung (Hauptform);Traktandenliste (schweiz.);Themenkatalog;Agenda;Aktionsprogramm
-ausbrennen;abbrennen;niederbrennen;abfackeln (ugs.);durch Brand zerstören (Hauptform);verbrennen
-nicht kommen;fernbleiben (geh.);fortbleiben;wegbleiben;zu Hause bleiben;fehlen;ausbleiben
-(sich) (eine Bemerkung) verkneifen (ugs.);(eine Bemerkung) hinunterschlucken (fig.);unterdrücken;nicht aussprechen;(sich etwas) verbeißen (ugs.);(sich) auf die Zunge beißen (ugs., fig.);(etwas) runterschlucken (fig.)
-erlöschen;ausgehen
-es geht los (ugs.);anfahren;gehen;losfahren;abgehen (Zug, Fähre, Schiff);abfahren;fahren (ugs.)
-(jemanden) aufmerken lassen (veraltend);Aufmerksamkeit auf sich ziehen;bemerkt werden;Aufmerksamkeit erregen;aufhorchen lassen;stutzig machen;(jemandem) auffallen (ugs.);bei jemandem klingeln die Glocken (ugs., fig.);hellhörig machen
-einstürzen;einbrechen;zusammensinken;zusammenstürzen;zusammenkrachen (ugs.);(in sich) zusammenfallen wie ein Kartenhaus;umknicken wie Streichhölzer;einsinken;zusammenbrechen;in Trümmer fallen;einkrachen (ugs.);zusammenfallen;einfallen;zusammensacken (ugs.);in sich zusammenfallen;einstürzen wie ein Kartenhaus
-auskämpfen;durchkämpfen;durchfechten
-entschädigen;wiedergutmachen;kompensieren;abfinden;Wiedergutmachung zahlen;Entschädigungszahlungen leisten;Ausgleichszahlungen leisten
-bekanntwerden;nach außen dringen;(sich) durchsprechen;rauskommen (ugs., salopp);auffliegen (ugs.);herauskommen;bekannt werden;ruchbar werden;durchsickern (ugs.)
-auf die andere Seite fahren;rüberfahren (ugs.);rüber auf die andere Seite fahren (ugs.);hinüberfahren;überqueren
-einen Bogen machen (um) (ugs.);drumherum fahren;umfahren
-gefallen;auf dem Feld der Ehre gefallen (pathetisch);draußen geblieben (ugs., Jargon);den Heldentod gestorben (pathetisch);auf dem Feld der Ehre sein Leben gelassen;getötet worden;im Feld geblieben (fig., verhüllend)
-Gegebenheit;Phänomenon (bildungssprachlich);Erscheinung;Phänomen
-abschmatzen (ugs.);knutschen (ugs.);schnäbeln (ugs.);busseln (ugs.);(jemandem) einen Kuss geben;seine Lippen auf jemandes (Lippen) drücken;(jemandem) ein Bussi geben (ugs.);küssen (Hauptform);bützen (ugs.)
-Tischtuch;Tischdecke
-Gaunersprache;Ganovensprache;Rotwelsch
-Ohrenwärmer;Ohrenschützer
-abtanzen (ugs.);schwofen (ugs.);abhotten (ugs.);das Tanzbein schwingen (ugs.);abzappeln (ugs.);tanzen
-Gewöhnlichkeit;Durchschnittlichkeit;Gebräuchlichkeit;Normalität
-Privatmann;Privatmensch;Privatperson
-Paläolithikum (fachspr.);Altsteinzeit
-Mesolithikum (fachspr.);Mittelsteinzeit
-Jungsteinzeit;Neolithikum
-Äneolithikum;Kupferzeit;Kupfersteinzeit;Chalkolithikum
-Vorhersage;Orakel;Weissagung;Prädiktion (selten);Prognose;Prophetie;Prophezeiung;Wahrsagung;Voraussage;Orakelspruch
-beifügen;anheften;beilegen;beigeben
-aufopfern;opfern;drangeben (ugs.);hingeben;darangeben
-umschließen;umgeben;umfangen;umhüllen
-Nebeneinkunft;Zusatzeinkommen;Zuverdienst;Nebeneinnahme;Zubrot;Verdienst im Zweitjob;Nebeneinkünfte;Verdienst bei einer Nebentätigkeit;Zuverdienstmöglichkeit;Nebeneinkommen;zusätzliches Einkommen;Nebenverdienst;(ein) zweites Standbein (fig., floskelhaft)
-Daseinsfreude;Lebenslust;Lebensfreude;Heiterkeit;Vitalität
-übernachten (Hauptform);einquartiert sein;(irgendwo) unterkommen;nächtigen (geh.);absteigen (ugs.);untergebracht sein;kampieren;(irgendwo) schlafen;(irgendwo) pennen (ugs., salopp);logieren (geh.);die Nacht verbringen
-Stadtmitte;Zentrum;City;Stadtzentrum;Innenstadt;Stadt (ugs.);Stadtkern
-(jemandem etwas) zurückgeben;(jemandem etwas) wiederbringen (ugs., regional);(jemandem etwas) zurückbringen
-zurückerlangen;wiederbekommen;zurückerhalten;zurückbekommen
-addieren;dazugeben;zugeben;hinzugeben
-panschen (ugs.);pantschen (ugs.);verwursten (ugs.);verquirlen;einrühren;mischen;durchmischen;konfundieren;vermixen;durchmengen;unterbuttern (auch figurativ);vermischen;verschneiden;verhackstücken (ugs.);untermischen;mixen;verrühren;durchrühren;vermanschen (ugs.);vermengen;anrühren;durcheinanderwürfeln;verquicken
-nachjagen;nachsetzen;(sich) hinter jemanden hängen (ugs.);folgen;nachsprengen (geh.);(jemandem) auf den Fersen bleiben;hinter jemandem her sein (ugs.);verfolgen;nachstellen (geh.);nachsteigen;(sich) hängen an;(jemandem) auf den Hacken sein (ugs.);(jemandem) auf den Fersen sein (ugs.)
-nahe gehen;seelisch erschüttern
-absenken;erniedrigen;herunterlassen;senken;heruntersetzen;ablassen
-gleichgesinnt;geistesverwandt;wesensverwandt
-Weltraumfahrt;Astronautik;Raumfahrt;Kosmonautik
-Raumfahrer;Astronaut;Weltraumfahrer;Kosmonaut;Taikonaut
-(plötzlich) aufflackernd;ausbrechend;eruptiv (geh.);hervorbrechend
-Unruhe;Turbulenz
-(von jemandem) zu erfahren sein;öffentlich machen;vermelden;kommunizieren (geh.);öffentlich bekannt machen;verkünden;publik machen;veröffentlichen;kundtun;zu Kund und Wissen tun (geh., altertümelnd, variabel);zu Protokoll geben (Amtsdeutsch, fig.);proklamieren;wissen lassen;publikmachen;kundgeben;verlauten lassen;(jemandem etwas) in den Block diktieren (fig.);verlautbaren lassen (floskelhaft);ausrufen;mitteilen (lassen);bekanntgeben;heißen (es ... von);an die Öffentlichkeit gehen (mit);bekanntmachen;bekannt machen;(öffentlich) bekannt geben (Hauptform)
-Untersagung;Verbot;Prohibition
-erobern;besetzen;landnehmen;okkupieren;einnehmen;erstürmen
-parteiisch;persönlich;einseitig;subjektiv;nicht objektiv;unausgewogen;unsachlich
-relativ;vergleichsweise;tendenziell;eher (ugs.);verhältnismäßig
-Vertrauensbruch;Vertrauensmissbrauch;Indiskretion
-bewettern (fachspr., Bergbau);mit Frischluft versorgen;lüften;für Frischluftzufuhr sorgen;belüften
-darniederliegen (geh.);langsam eingehen (ugs.);daniederliegen;hinsiechen;abserbeln (schweiz.);dahinsiechen
-Grünanlage;Garten;Anlage;Gartenanlage
-gratulieren;beglückwünschen
-Mus musculus (fachspr., zoologisch);Hausmaus;Maus
-Erpel;Enterich;Ente
-Folge;Effekt;Auswirkung;Wirkung;Einfluss;Reaktion
-zurückgeblieben;unterbelichtet (derb);unterentwickelt;hinterwäldlerisch
-Konzert;Musikaufführung
-Muster;Fabrikat;Bauart;Modell;Typ
-Zahlenlehre;Arithmetik;Rechenkunst
-rechnerisch;arithmetisch
-Heuschreck (österr.);Heupferd (ugs.);Grashüpfer;Heuschrecke
-Indiskretion;Taktlosigkeit
-persuasiv;persuasorisch;der Überredung dienend;überzeugend;gewinnend;überredend
-Überredungskunst;Suada;Überredung;Persuasion (fachspr.)
-Oktagon;Achteck;Oktogon
-häuten;schinden;enthäuten;(Wildbret) aus der Decke schlagen (fachspr., Jägersprache);pellen (ugs.);schälen
-vollstrecken;vollziehen;exekutieren
-liquidieren;exekutieren;hinrichten;richten;(das) Todesurteil vollstrecken
-Hämorride;blinde Ader (veraltet);goldene Ader (veraltet);Hämorrhoide;(blutender) Venenknoten des Mastdarms
-Pubeszenz (fachspr.);Pubertät;Geschlechtsreifung;Geschlechtsreife
-leicht erfassbar;allgemein verständlich;allgemeinverständlich;leicht verständlich
-der/die als ... Bezeichnete;so genannt;(der/die) sich (selbst) ... nennt;schein...;sogenannt;der falsche (...);vorgeschoben;scheinbar;vorgeblich;den man ... nennt;behauptet;angeblich;pseudo...;vermeintlich (ugs.);die falsche (...)
-widersprüchlich;konträr;paradox;gegensätzlich;antithetisch;widersinnig;disparat (geh.)
-Erfindung;Planung;Schöpfung;Design;Entwicklung;Hervorbringung (geh.);Kreation;Erschaffung
-uneinheitlich;inhomogen;nicht gleichartig;heterogen;ungleichartig;ungleich;gemischt
-vorkämpferisch;avantgardistisch
-Fertiger;Hersteller (Hauptform);Erzeuger;Produzent;Fabrikant
-Anwesen;(bebautes) Grundstück;Liegenschaft (schweiz.)
-sonnig;heiter;klar;unbewölkt;wolkenlos
-Miete;Mieteinnahme
-mitleidig;gnädig;barmherzig;erbarmungsvoll;mitfühlend
-Überlagerung;Beeinträchtigung;Überschneidung;Wechselwirkung;Beeinflussung;Interferenz
-übersichtlich;überschaubar;überschaulich;überblickbar;begrenzt
-erkennen;(einer Sache) gewahr werden (geh.);(etwas) gewahr werden;(jemandem) klar werden;(sich) bewusst werden
-Nachahmung;Emulation;Nachbildung
-geistiger Trittbrettfahrer (abwertend);Epigone;Nachahmer;Imitator;Nachmacher
-gefärbt;gelenkt;geprägt;beeinflusst
-(jemandem etwas) einflüstern;suggerieren;einnebeln (ugs.);(jemanden etwas) glauben machen (geh.);(jemandem etwas) einreden;so tun als ob;(jemanden von etwas) zu überzeugen versuchen;auftischen (ugs.);(jemanden) einseifen;(jemandem etwas) weismachen;Augenwischerei betreiben;(jemanden) hinwegtäuschen über;(jemandem etwas) vormachen (ugs.);(etwas) vorgeben;manipulieren;Nebelkerzen werfen;(jemandem einen) Floh ins Ohr setzen (ugs., fig.);(jemandem) Sand in die Augen streuen (fig.);(jemandem etwas) auf die Nase binden wollen (ugs., Redensart, variabel);vortäuschen;(jemandem einen) Bären aufbinden (ugs.);(die) Köpfe vernebeln
-Selbstmanipulation;Autosuggestion;Selbstbeeinflussung;Selbstsuggestion
-widerspenstig;renitent;widersetzlich;wehrhaft
-ohne (jede) Ehre im Leib;würdelos;ehrlos;keine Ehre im Leib (haben)
-lakaienhaft;knechtisch;katzbucklig;dienerisch;servil;kriecherisch
-Bergwiese;Alp;Matte;Alm;Bergweide;Alb (alemannisch);Alpe (westösterreichisch);Alpweide
-zum ersten Mal;erstmals;erstmalig
-Junta (portugiesisch, spanisch);Militärdiktatur;Militärjunta
-integer;nicht käuflich;moralisch einwandfrei;unbestechlich;nicht korrupt
-konkurrenzieren (schweiz.);wettstreiten;rivalisieren;wetteifern;konkurrieren;(sich) messen (mit)
-Kantine;Kasino;Schulrestaurant;Cafeteria;Betriebsrestaurant;Refektorium (fachspr.);Cafete (ugs.);Casino;Personalrestaurant (schweiz.);Mensa
-Schlafstadt;Satellitenstadt;Trabantensiedlung;Trabantenstadt
-Umkreis;Umfeld;Nachbarschaft (Hauptform);Leute in der Umgebung;(die) Anwohner;Umgebung
-gestriger Tag;gestern
-verkennen;unterbewerten;depretiieren (geh., veraltet);unterschätzen
-Gnadenfrist;Nachfrist;Galgenfrist (ugs.)
-Garantiedauer;Garantiezeit
-Strafaussetzung;Bewährung;Probezeit
-Gültigkeitsdauer;Laufzeit
-tendenziös;unilateral;unausgewogen;befangen;parteiisch;nicht neutral;vorurteilsvoll;einseitig;voreingenommen;nicht objektiv;vorbelastet
-zweiseitig;bilateral;beidseitig
-mehrseitig;vielseitig;multilateral
-Werbeetat;Werbebudget
-Weihnachtszuwendung;Weihnachtsremuneration;Jahressonderzahlung;Weihnachtsgeld;Weihnachtsgratifikation
-Privatisierung;Deregulierung;Liberalisierung
-kohärent;zusammenhängend
-Festigung;Konsolidierung
-Apartheid (Afrikaans);Rassentrennung
-Gegenwehr;Abwehr;Widerstand;Gefahrenabwehr;Verteidigung
-verteidigend;defensiv;apotropäisch (griechisch);abwehrend
-Syntax;Satzlehre;Anordnung der Satzteile;Satzstruktur;Beschreibung des Satzbaus;Satzbau
-Lautstruktur;Phonologie
-Morphemik;Morphematik;Pleremik;Morphologie;Plerematik;Wortbildung
-Beifügung;Beisatz;Apposition
-Auxiliar;Hilfsverb;Hilfszeitwort;Auxiliarverb (fachspr.);Nebenverb;Hilfswort;Modalitätsverb
-Indikativ (fachspr., Hauptform);Wirklichkeitsform
-Infinitiv;Nennform (eines Verbs);Grundform (eines Verbs)
-Gradation (lat.);Graduierung (lat.);Komparation (lat.);Steigerung
-Konjunktiv (fachspr., Hauptform);Möglichkeitsform
-Prädikat;Satzaussage;Aussagekern
-Präpositionalobjekt;Verhältnisergänzung
-Satzgegenstand;Subjekt
-Tempus (fachspr., Hauptform);Tempusform;Zeitform;Zeit;Zeitstufe
-Modus (fachspr., Hauptform);Aussageweise;Aussageform
-leidend (Grammatik);passiv
-Kasus (fachspr., Hauptform);Beugungsfall (fachspr.);4 Fälle (ugs.);Fall;vier Fälle (ugs.)
-Straßensperre;Hindernis;Barrikade
-Parterre;Erdgeschoss
-Passage;Durchreise;Transit;Durchgang;Durchfahrt
-Derivation;Ableitung
-Aufbruch (fachspr., Jägersprache);Kaldaunen;Geschling (ugs.);Gekröse;Gedärme;Eingeweide;Innereien;Gescheide (fachspr., Jägersprache)
-Ausforschung;Fund;Entdeckung;Feststellung;Kenntniserlangung;Ermittlung;Eruierung (geh.)
-Aufrichtigkeit;Wahrhaftigkeit;Ehrlichkeit
-missgebildet;difform (fachspr., lat., neulateinisch);deformiert;verunstaltet;missgestaltet;fehlgebildet;verformt;entstellt
-Merkmal;Kennzeichen;Parameter (fachspr.);Kriterium;Faktor
-auf wenig Gegenliebe stoßen;nicht gern gesehen;verhasst;unbeliebt;unpopulär;missliebig
-Zuspruch;Beipflichtung;Bekräftigung;Zusagung;Bestätigung;Bejahung;Affirmation;Zustimmung
-zurechtbiegen;zurechtrücken
-sibyllinisch (geh.);arkan (geh.);okkult (geh.);rätselhaft;schleierhaft;orphisch (geh.);nebulös;sagenumwoben;sibyllenhaft (geh.);delphisch (geh.);geheimnisvoll;wundersam;mysteriös;geheimnisumwittert;unergründlich;geheimnisumwoben
-kuschlig;kuschelig;anschmiegsam
-jahrelang;Jahre über Jahre;über mehrere Jahre;über Jahre (Betonung auf 'Jahre');langjährig;über viele Jahre (hinweg);mehrjährig;(mehrere) Jahre hindurch;über Jahre hinweg
-bedrückend;dämpfend;ernüchternd;düster;zermürbend;niederdrückend;deprimierend;im Argen (liegen);erdrückend
-Straferlass;Amnestie;Begnadigung
-Zuhörer;Zuhörerschaft;Hörer;Auditorium (geh.);Publikum
-irr (ugs.);geistig umnachtet (ugs.);verblödet;verrückt;hirnrissig (ugs.);nicht bei Sinnen (ugs.);crazy (ugs.);plemplem (ugs.);nicht richtig ticken (ugs.);durchgeknallt (ugs.);irre (ugs.);meschugge (ugs.)
-Vorausbuchung;Reservierung;Vorbestellung;Vormerkung
-Partnerschaft;Geschäftsbeziehung
-Kundenberatung;Kundenbetreuung
-Kundenberater;Kundenbetreuer
-Zeppelin (Hauptform);Starrluftschiff
-Black Box;Flugschreiber;Flugdatenschreiber;Blackbox
-morgen;am morgigen Tag
-Zeitschranke (fachspr., technisch);letzter Termin;Ultimo;Stichtag;Abgabetermin;(letzte) Frist (Hauptform);Fristende;Deadline (engl.);Ablieferungstermin
-Cash (ugs., engl.);Bares (ugs.);Bargeld
-technische Daten;Besonderheit;Charakteristikum;Produkteigenschaft;Funktion;Kennzeichen;Feature;Eigenschaft;Funktionalität;Ausstattungsmerkmal;Funktionsmerkmal;Leistungsmerkmal
-Börsencrash;Wertverlust;Börsenkrise;Zusammenbruch;Schwarzer Freitag;Börsenkrach;Crash;Kursverfall;Einbruch;Börsensturz
-Sicherungskopie;Datensicherung;Sicherheitskopie;Reservekopie;Backup;Back-up
-Big-Brother-Staat;Polizeistaat;Überwachungsstaat
-Sophismus (geh., griechisch);Etikettenschwindel (Hauptform);Augenauswischerei;Augenwischerei (ugs.);Ablenkungsmanöver;Irreführung;Bluff;Täuschung
-Gaukler;Bluffer (ugs.);Blender
-Bodyguard (ugs., engl.);Leibwächter;Gorilla (ugs.);Personenschützer (Amtsdeutsch, Hauptform)
-Nadelöhr;Flaschenhals;Engpass
-Emoticon;Smiley;Strichgesicht
-wieder verwenden;rückgewinnen;verwerten;aufarbeiten
-UI (fachspr., Abkürzung, engl.);Bedienoberfläche (fachspr.);Nutzeroberfläche (fachspr.);User Interface (fachspr., engl.);Nutzerschnittstelle (fachspr.);Bedienerschnittstelle (fachspr.);Anwenderschnittstelle (fachspr.);Bedieneroberfläche (fachspr.);Benutzerschnittstelle (fachspr.);Benutzeroberfläche (fachspr.)
-Mauszeiger;Zeiger;Cursor (engl.)
-Abhakliste;Kontrollliste;Prüfliste;Checkliste
-(in) Großaufnahme;bildfüllend
-Arbeitsoutfit (ugs.);Montur (ugs.);Arbeitskleidung;blauer Anton (ugs.);Blaumann (ugs.);Arbeitsanzug
-Aufwärtshaken;Kinnhaken;Cut (engl.);Uppercut (engl.);Upper-cut (engl.)
-auspacken;entpacken
-Problembeseitigung;Störungsbehebung;Lösung;Problemlösung;Problembewältigung
-(läppisches / seichtes) Machwerk (abwertend);Billigroman;seichter Roman;Seifenoper (fig.);Trivialschmöker (ugs.);Groschenheft;Rührschinken (ugs., abwertend);Hintertreppenroman;Kitschroman;Groschenroman;Roman ohne Anspruch;Schmonzette (abwertend, literarisch);billig produzierter Roman;Schmachtfetzen (ugs., abwertend);Heftroman (Hauptform);Trivialroman;Schundroman (ugs., abwertend)
-Tramper;Hitchhiker;Anhalter
-geheim;unter Ausschluss der Öffentlichkeit;vertraulich
-Topmodell;Spitzenmodell
-Werkzeugset;Werkzeugausstattung;Werkzeugsatz
-Voucher;Wertschein;Gutschein;Wertmarke
-Verhandlungstermin;Gerichtstermin
-Gutachten;Sachverständigengutachten
-Trödel (ugs.);Flohmarkt;Trödelmarkt
-ausgelastet;satt;gesättigt
-Teamarbeit;Gruppenarbeit;Zusammenarbeit;Arbeit im Team;Gemeinschaftsarbeit
-Strukturwandel;Strukturveränderung
-Tonkanal;Tonspur;Audiospur
-Sprudel;Wasser mit Zisch (ugs.);Tafelwasser;Henniez (ugs., Markenname);Mineralwasser (Hauptform);Selters (Markenname);Mineral (schweiz., österr.);Soda;Eskimo-Flip (ugs., scherzhaft);saurer Sprudel (ugs.);Sauerwasser (ugs., regional);Arbeitersekt (ugs., scherzhaft);Dihydrogenmonoxid (fachspr., scherzhaft-ironisch);stilles Wasser;Sodawasser;Sprudelwasser;Kribbelwasser (ugs.);nervöses Wasser (ugs.);Selterswasser
-Oligopol;Angebotsoligopol
-Stoßzeit;Spitzenzeit;Rush Hour (ugs.);Hauptverkehrszeit;Spitzenverkehrszeit;Berufsverkehr;Rushhour
-Hauptverzeichnis;Grundverzeichnis;Stammverzeichnis
-wieder verwerten;wieder aufbereiten
-Wohlfühlen;Wohlbefinden;Wohlgefühl;Behagen;Wohl;Wohlergehen;(das) Wohl und Wehe;Wohlbehagen;Wohlsein
-aufmunternd;analeptisch (fachspr., griechisch);erfrischend;stimulierend;erquickend;vitalisierend (geh., bildungssprachlich);herzerfrischend;stärkend;aktivierend;prickelnd (ugs.);die Lebensgeister wecken(d);anregend;belebend;animativ (lat.);spritzig
-nacherleben;nachempfinden;folgen (mit Dativ);nachvollziehen;nachfühlen
-einladend (fig.);appetitlich;appetitanregend;(da) läuft einem das Wasser im Mund(e) zusammen
-ankurbelnd;aufbauend;anspornend;animierend;anregend;erregend;motivierend;aktivierend;ermutigend;aufputschend;antreibend
-beruhigend;wohltuend;entspannend;erholsam
-der Gesundheit zuträglich;gesund (ugs.);heilsam
-einschläfernd;ermüdend;schlaffördernd
-schmerzhemmend;anästhetisch (fachspr.);schmerzlindernd;betäubend;schmerzstillend
-vom Sockel stoßen (fig.);herabstufen;deklassieren;abwerten;herabsetzen
-sonnendurchflutet;durchsonnt
-eifrig;leistungsorientiert;motiviert;einsatzfreudig;zeigt Einsatz;arbeitsfreudig;schaffensfreudig;arbeitswillig
-Reife;Weltkenntnis;Weisheit;Lebenserfahrung;Abgeklärtheit
-(innere) Balance (franz.);Ausgewogenheit;Harmonie;Ausbalanciertheit;Ausgeglichenheit;inneres Gleichgewicht
-ausgeglichen;quitt;in Balance;ausgewogen;im Gleichgewicht;die Interessen beider Seiten berücksichtigend;pari;harmonisch
-zurückblicken;zurückschauen;zurückerinnern;zurückdenken
-wohlüberlegt;wohlbedacht;mit Vorbedacht
-kein Kind von Traurigkeit;lebensbejahend;lebensfroh;lebenslustig
-ausschleudern;zentrifugieren (fachspr.);schleudern
-unbezahlbar (Hauptform);nicht zu finanzieren;außerhalb der finanziellen Möglichkeiten;unerschwinglich
-erschwinglich;bezahlbar;nicht die Welt kosten (ugs.);leistbar (österr.);finanziell tragbar;im Rahmen;(für jemanden) finanzierbar;im Limit (ugs.)
-Handlungssequenz;Handlungsabfolge
-Suchterkrankung;Abhängigkeitssyndrom;Abhängigkeitserkrankung;Suchtverhalten;Sucht (ugs.);Laster (ugs., abwertend);Abhängigkeit (ugs.)
-Alkoholismus;Dipsomanie (fachspr.);Äthylismus (fachspr.);Alkoholkonsumstörung;Alkoholsucht;Alkoholabhängigkeit;Alkoholkrankheit;Trunksucht;Potomanie (fachspr.)
-Hilfsvorrichtung;Hilfsgerät;Hilfsmittel;Apparatur;Apparat
-Belastbarkeit;Tragfähigkeit;Strapazierfähigkeit;Widerstandskraft;Belastungsfähigkeit
-Wohnungseinrichtung;Ausstattung;Einrichtung;feste Einrichtung;Meublement (veraltet);Möblierung
-Finanzspritze;Unterstützungszahlung;Unterstützung;Förderung;Zustupf (schweiz.);Beihilfe;Geldsegen (fig.);Gönnerschaft;Fördermittel;Zuschuss;Subvention
-Lohnkostenzuschuss;Lohnkostensubvention
-Krückstock (ugs.);Stenz (Wandergeselle) (fachspr.);Invalidenstock (ugs.);Handstock;Gehhilfe;Krückmann (veraltend);Gehstock;Wanderstab;Krücke (ugs.);Spazierstock;Hirtenstab;Wanderstock
-Aufwendung;Mühe;Kraftaufwand;Arbeitsaufwand;Anstrengung;Aufwand
-dauer...;chronisch (fachspr.);bleibend;langwierig;andauernd;dauerhaft;anhaltend;Dauer...
-prägen;implementieren;einführen;einspeisen;einsetzen;realisieren;entwickeln;umsetzen;einbauen;Eingang finden
-eingetrocknet;dehydriert;verdorrt;ausgedörrt;vertrocknet;ausgedorrt;ausgetrocknet
-Kurort;Erholungsort
-Wahrnehmung;Bewusstsein
-Selbstwertgefühl;Ego (ugs.);Selbstachtung;Selbstüberzeugtheit;Ich-Stärke;Selbstbewusstsein;Eigenwert;Selbstgewissheit;Selbstwertschätzung;Selbstvertrauen;Selbstsicherheit;Stolz;Selbstüberzeugung;Selbstwert
-Nachtgewand (geh.);Schlafanzug;Nachtanzug;Pyjama
-Aktionspreis;Angebot;Sonderpreis
-Indigener (fachspr.);Ureinwohner;Einheimischer;Ortsansässiger;Eingeborener
-Handbetrieb (derb, fig.);Masturbation;Onanie;Selbstbefriedigung (Hauptform);Wichsen (derb);Autoerotik (geh.)
-Machtbereich;Einflussbereich
-nacheifern;nachmachen;nachtun;nachstreben;gleichtun;gleichziehen
-Entmilitarisierung;Entwaffnung;Demilitarisierung;Abrüstung
-Straßenkehrer;Straßenfeger
-lautlos;unhörbar;geräuschlos
-Seele;Innenleben;Gemüt;Thymos (fachspr., griechisch)
-phantasieren;träumen;fantasieren;tagträumen
-ohne Anspruch;unverbindlich;ohne Verpflichtung;ohne Gewähr;zu nichts verpflichten(d)
-wohlgemut;hoffnungsfreudig;(ein) gutes Gefühl (haben);zuversichtlich;guten Muts (ugs.);voller Optimismus;guten Mutes (ugs.);voller Zuversicht;guter Dinge (ugs.);erwartungsfroh;hoffnungsvoll;optimistisch;hoffnungsfroh;frohen Mutes (ugs.);(ein) sonniges Gemüt (haben);hochgemut;zukunftsgläubig;frohen Muts (ugs.);zukunftsfroh
-Prügel;Hiebe;Dresche (ugs.);Kloppe (ugs.);Haue (ugs.)
-bildungsschwach (geh.);bildungsfern (geh.);ungebildet;bildungsarm (geh.);kulturlos;böotisch (geh., griechisch, veraltet);unzivilisiert;unkultiviert
-Untersuchungsergebnis;Befund (fachspr.);Diagnose (fachspr.);Krankheitserkennung
-dienstunfähig;dienstuntauglich
-Dienstvorschrift;Dienstordnung
-Instanzenweg;Behördenweg;Dienstweg;Amtsschimmel (ugs.);Amtsweg
-Interaktion;Wechselbeziehung;Wechselwirkung
-Grundbedingung;Rahmenbedingung
-destillieren;herauslösen
-abgreifen (ugs.);messen (fachspr.)
-mnemonisch (geh.);leicht zu merken (ugs.);einprägsam (Hauptform);eingängig;merkbar
-Politelite;Politadel
-zähmen;domestizieren
-psychopathisch;normabweichend
-Rezeption;Kognition;Wahrnehmung
-Aufschub;Zahlungsaufschub;Zahlungsziel (fachspr., kaufmännisch);Moratorium (unter Staaten und deren Gebietskörperschaften) (fachspr.);Stundung;Zahlungsfrist
-Introspektion;Selbstbeobachtung;Innenschau
-Marionettenregierung;Lakaienregierung
-Puppe;Marionette;Puppenfigur
-zweigeteilt;zwiespältig (Hauptform);in sich widersprüchlich;dichotomisch (fachspr.);dichotom (fachspr.);doppelwertig;ambivalent;in sich uneins
-diametral;gegenüberliegend;entgegengesetzt
-luzid;überzeugend;einleuchtend
-vorherrschaftlich;hegemonial
-kollektiv;gemeinschaftlich;kollaborativ (bildungssprachlich);gruppenweise;zusammen
-sich ausweisen;sich legitimieren (fachspr.)
-triangulär;dreieckig
-Dreiheit;Triade
-Stimmberechtigter;Wahlberechtigter
-Nationalismus;Nationalgefühl;Nationalbewusstsein;Nationalstolz;Vaterlandsliebe;Staatsgesinnung;Patriotismus
-lehrhaft;didaktisch
-herauslocken;hervorlocken
-Lecken (ugs.);Cunnilingus;Oralverkehr an den weiblichen Geschlechtsorganen
-steigernd;kumulativ;zunehmend
-Schwanzlutschen (vulg.);ihn in den Mund nehmen (ugs.);französischer Sex (ugs.);Blasen (ugs.);Oralverkehr an den männlichen Geschlechtsorganen;Pimmellutschen (vulg.);Fellatio
-Altersgrenze;Höchstalter
-brisant;konfliktträchtig;hochexplosiv (ugs., fig.);explosiv (fig.);konfliktgeladen
-kommunistisch;bolschewistisch
-Ausrutscher;Entgleisung
-Mainstream (engl.);Hauptrichtung
-diskontinuierlich;zusammenhangslos;unterbrochen;unstetig
-Appell;Postulat;Forderung
-Isomorphie;Strukturgleichheit
-Kredo;Credo;Glaubensbekenntnis;geglaubter Grundsatz
-Weite;Ferne;Distanz;Entfernung
-Reichweite;Griffweite
-umzingeln;einkesseln;umkreisen;einkreisen;umringen;umstellen
-vorausgesetzt;axiomatisch;unanzweifelbar
-Primat;Herrentier
-abändern;verbessern;ergänzen;novellieren
-Beweggrund;Motiv;Antrieb;Grund;Leitgedanke;Ansporn
-nicht wortwörtlich;sinngemäß
-Haushaltswaren;Haushaltsbedarf;Haushaltsartikel
-ins Kraut schießen lassen (fig.);anheizen (Konflikt);(weiter) an der Spirale der Gewalt drehen (fig.);schüren;befeuern;(etwas) aufheizen (Stimmung) (fig.);Nahrung geben (ugs.);hochkochen lassen (fig.);anfachen;anstacheln;nähren (geh.);katalysieren (geh.);Auftrieb geben;Öl ins Feuer gießen (ugs., fig.)
-Antisemit;Judengegner
-antisemitisch;judenfeindlich
-duftend;aromatisch;wohlduftend;voller Aroma;wohlriechend
-Bewerbungsbrief;Bewerbung;Bewerbungsschreiben;Bewerbungsunterlage
-Musterbewerbung;Bewerbungsvorlage
-Bewerbungsbogen;Bewerbungsformular
-Regel;Gesetzmäßigkeit
-Faschist;Fascho (ugs.);Brauner (ugs.);Braunhemd (ugs.);Rechtsextremist;(ganz) Rechter (ugs.);Nazisse (ugs., salopp, selten, weibl.);Nazi-Braut (ugs., Jargon, weibl.);Nationalsozialist;Nazi;Rechtsradikaler
-Folter;Misshandlung;Tortur;Peinigung;Folterung;Marter;Drangsal;Quälerei
-zensiert;gekürzt
-machthungrig;machtversessen;machtgeil (ugs.);machtgierig;machtbesessen;herrschsüchtig
-schmeichelhaft;glattzüngig;scheißfreundlich (derb);zuckersüß lächelnd;kratzfüßig;schmierig;scheinfreundlich;aufgesetzt freundlich;schmeichelnd;heuchlerisch;herumschleimend (ugs.);honigsüß (lächeln / tun) (ugs.);schleimig (ugs.);übertrieben freundlich;katzenfreundlich (ugs.);liebedienerisch;schleimend (ugs.)
-nationalistisch;patriotisch;national
-übertriebener Nationalist;Chauvinist
-Akklamation (fachspr.);Fanatismus;Übereifer
-übernatürlich;parapsychologisch;spirituell;transzendent;übersinnlich;parapsychisch;überwirklich;magisch;mystisch;metaphysisch;geheimnisvoll;esoterisch
-beweisbar;überprüfbar;sichtbar;verifizierbar;beobachtbar;feststellbar;nachweisbar
-senil;altersschwach;sklerotisch;geriatrisch (fachspr.);vergreist;alt und klapprig (ugs.);gebrechlich;greis;greisenhaft
-addieren;beifügen;dazugeben;beimischen;zusetzen;hinzufügen
-bescheinigen;attestieren;bezeugen
-respektable Persönlichkeit;Autoritätsperson;Respektsperson;Autorität
-Freiheitsentzug;Freiheitsberaubung
-mitempfinden;(mit jemandem) fühlen (variabel);(jemandes) Gefühle teilen (variabel);mitleiden;mitfühlen
-gemeinnützig;allgemein dienlich;gemeinwohlorientiert;dem Gemeinwohl dienend
-gouvernantenhaft (geh.);oberlehrerhaft;mit erhobenem Zeigefinger (fig.);schulmeisterlich;besserwisserisch;mahnend;warnend;schulmeisternd;belehrend
-ausfragen;(immer) weitere Fragen stellen;urgieren (österr.);insistieren (geh.);(jemanden) löchern (ugs.);nicht locker lassen (ugs.);(immer/noch) mehr wissen wollen;nachhaken;nachbohren (ugs.);(immer weiter) bohren (ugs.);hartnäckig nachfragen;keine Ruhe geben (ugs.);aushorchen;zusätzliche Fragen stellen;nicht aufhören zu fragen;nicht aufhören Fragen zu stellen
-Arbeitnehmervertreter;Arbeitnehmervertretung;Arbeitnehmerlobby;Arbeitnehmerorganisation;Gewerkschaft
-reaktionär;rückwärtsgewandt;restaurativ;unfortschrittlich;rückschrittlich;ewig gestrig;(das) Rad der Geschichte zurückdrehen (wollen) (fig.)
-Proletariat;vierter Stand (historisch);besitzlose Klasse;Arbeiterschaft;Arbeiterklasse;arbeitende Klasse;Unterschicht
-in der Realität;im echten Leben;in (der) Wirklichkeit;realiter;(ganz) real;in der wirklichen Wirklichkeit (ugs., scherzhaft);in echt (ugs.);im wirklichen Leben;im richtigen Leben;im wahren Leben (Redensart);zum Anfassen;in natura (lat.)
-baufällig;abbruchreif;unbewohnbar;auf Abbruch stehen;in einem erbarmungswürdigen Zustand;sanierungsbedürftig;marode;heruntergekommen
-abenteuerlich;erlebnisreich;bewegt;voller Abenteuer;ereignisreich;abenteuerreich
-betriebsbereit;verfügbar;zur Verfügung stehend;abrufbereit;disponibel;in den Startlöchern (ugs., fig.);in Bereitschaft
-abweisend;ablehnend;negativistisch (fachspr.);abschlägig;inkonziliant (geh., lat.);verweigernd
-Straftat;Untat;strafbare Handlung;krimineller Akt;illegale Handlung;Verbrechen;Unrechtstat;Delikt
-Fundamentalrecht;Grundrecht
-überliefern;weitertragen;weitergeben;vermitteln;tradieren
-Hort;Kindergarten;Kinderhort
-Kriegsbeginn;Kriegsausbruch
-Stütze;Rückhalt
-Redefreiheit;Meinungsäußerungsfreiheit
-Aufständischer;Rebell;irregulärer Kämpfer;Franc-tireur (veraltet);Guerilla (meist Plural);Untergrundkämpfer;Insurgent (geh., veraltet);Befreiungskämpfer;Widerstandskämpfer;Partisan;Freischärler;Freiheitskämpfer;Guerillero
-Gesellschaftseigentum;Allgemeingut;Gemeinschaftseigentum;Gemeineigentum;Allgemeinbesitz
-Job-Nomade (ugs.);Zeitarbeitnehmer;Leihkraft;Leiharbeitnehmer;Leiharbeiter;Zeitarbeiter
-Kemenate;Harem;Frauengemach
-Heterodoxie (fachspr.);Ketzerei;Ketzertum;Häresie (fachspr.);Irrglaube;Irrlehre
-Wasserstoff (Hauptform);Hydrogen (griechisch, lat.);Wasserstoffgas;Hydrogenium (griechisch, lat.)
-Unkenntnis;Ahnungslosigkeit;Unerfahrenheit;Naivität;Unwissenheit
-Wasserheilkunde;Hydrotherapie;Wasserkur;Wasserheilverfahren
-Horizont;Wahrnehmungshorizont;Gesichtskreis;Blickfeld;Gesichtsfeld
-kleinlaut (ugs.);eingeschüchtert;verunsichert;verschüchtert;so klein mit Hut (+ Geste) (ugs., fig.);leise weinend (ugs., fig.);scheu
-Ungestüm;Karacho (ugs.);Heftigkeit;Schmackes (ugs.);Schwung;Wucht;Gewalt;Musik dahinter (ugs.);Vehemenz;Kraft
-einführen;importieren
-Manipulation;Täuschung;Agitation;Vernebelung der Gehirne;Hetze;Propaganda;Volksverdummung (ugs.)
-Hypokrisie;Heuchelei;Verstellung;Vortäuschung
-Versuchskaninchen (ugs., fig.);Proband;Versuchsperson;Versuchsobjekt;Versuchsteilnehmer;Testperson;Studienteilnehmer
-beischlafsunfähig;impotent
-humanoid;menschenähnlich
-fertil (fachspr., lat.);pubeszent (fachspr., lat.);fortpflanzungsfähig;geschlechtsreif;fruchtbar;vermehrungsfähig
-zeugungsfähig;potent
-stark;einflussreich;von Einfluss;hochmögend (geh., veraltet);mächtig;potent
-hochklassig;erlesen;meisterhaft;fein;edel;pipifein (derb);exzellent;wertvoll;hochwertig;luxuriös;vortrefflich;kostbar;qualitativ hochstehend;qualitätsvoll
-mit akademischem Abschluss;graduiert
-Gynäkologie;Frauenheilkunde
-kinästhetische Wahrnehmung;Kinästhesie;Bewegungsgefühl;Bewegungssinn;Bewegungsempfindung
-voraussagend;vorher erkennend;gedanklich antizipierend;vorhersagend;prognostisch;vorauswissend
-progredient;fortschreitend;progressiv (geh.)
-Sedation;Beschwichtigung;Sedierung;Ruhigstellung;Beruhigung;Besänftigung
-beeinflussend;suggestiv
-habituell (geh.);aus alter Gewohnheit;notorisch (geh.);aus Gewohnheit;nach alter Gewohnheit;gewohnheitsmäßig
-Parasit;Schmarotzer
-sterilisiert;entmannt;kastriert
-unverbesserlich;vernagelt;borniert;unbelehrbar;verblendet;verbohrt;verbiestert;intolerant;engstirnig;beschränkt
-entseuchen;dekontaminieren;entgiften
-Auskunftsstelle;Informationsstand
-umkehren;wenden;invertieren;verkehren;reversieren
-Gesprächspartner (Hauptform);Diskutant;Gegenüber;Gesprächsteilnehmer
-eklektisch;selektiv;elektiv;auswählend
-Volksverhetzung;Demagogie;Volksverführung;Propaganda
-wellenförmig;wellenartig
-ideenlos;phantasielos;ideenarm;vorhersagbar;tumb;(wie) auswendig gelernt;herkömmlich;ohne Überraschungen;unkreativ;überraschungsarm;schablonenhaft;eklektizistisch (geh.);uninspiriert;wenig originell;einfallslos;geistlos;bietet keine Überraschungen;fantasiearm;konventionell;unoriginell;fantasielos;bietet wenig(e) Überraschungen;phantasiearm;unschöpferisch
-verwaist;leer stehend;leerstehend;unbewohnt (Hauptform);ungenutzt
-Beobachter;Zeuge;Augenzeuge
-Soldatenkrankenanstalt;Militärkrankenhaus;Lazarett;Militärhospital
-Aushorcher;Geheimagent;Lauscher (ugs.);Zuträger;V-Person;Spürhund;Konfident (österr.);Beschatter;Polizeispitzel;Schnüffler (ugs.);Informant;Verbindungsfrau (weibl.);Kundschafter;Verbindungsmann (männl.);VP (Abkürzung);Polizei-Informant;Beobachter;Kontaktmann (männl.);Spion;Schlapphut (ugs.);Agent;V-Mann (männl.);Singvogel (ugs., Jargon);Ermittler;Verbindungsperson;Spitzel (ugs.);Detektiv
-Geschäftsführung;Geschäftsleitung
-unfasslich;unerfindlich;unbegreiflich;rätselhaft;enigmatisch (geh.);unergründlich;geheimnisvoll;änigmatisch (geh.);unfassbar
-unbefriedigend;nicht zufriedenstellend;nicht befriedigend;unzufriedenstellend;hinter den Erwartungen zurückbleiben(d)
-unverschämt;keck (ugs.);unvorsichtig;indiskret;taktlos
-unflexibel;unanpassungsfähig
-unorganisiert;ohne System;strukturlos;unduchdacht;ohne Struktur;unstrukturiert;ohne einen roten Faden;unreflektiert;systemlos;ohne Plan;unsystematisch;planlos (Hauptform)
-das Schlimmste befürchtend;pessimistisch;schwarzseherisch;misserfolgsorientiert (psych.) (fachspr.)
-Milizarmee;Volksmiliz;Bürgerheer;Volksheer
-kriegstreiberisch;bellizistisch
-Bellizist;Kriegs-Befürworter;Kriegshetzer;Kriegstreiber
-Urkundenlehre;Diplomatik
-Briefmarkenkunde;Philatelie
-körperhaft;3-D;3D;dreidimensional;plastisch;räumlich
-Politiker;Volksvertreter;Berufspolitiker
-Gegensatz;Kontrast;Unterschied
-flächig;zweidimensional;2D
-semitransparent;halb durchsichtig
-einmalig;unnachahmlich;einzigartig (Hauptform);unvergleichlich
-Infrastruktur;Unterbau
-transparent;erkennbar;durchschaubar
-ablesbar;kenntlich;entzifferbar;erkennbar;erkenntlich
-Luzidität;Durchschaubarkeit;Erkennbarkeit
-fixe Idee (ugs.);Wahnidee;Zwangsvorstellung
-wegsehen (fig.);(den) Kopf in den Sand stecken (fig.);ignorieren;wegkucken (ugs., norddeutsch);sich (einem Problem) nicht stellen;die Augen verschließen (vor) (fig.);wegschauen (fig.);nicht wahrhaben wollen;(Probleme) zu verdrängen versuchen;fortsehen;weggucken (ugs.)
-falsifizieren;widerlegen;gegenargumentieren;als falsch erkennen;den Wind aus den Segeln nehmen (ugs.);entkräften
-Klassifikationsschema;Einteilungsmethode;Ordnungsprinzip;Systematik
-auftischen;anbieten;anrichten;hinstellen (ugs.);servieren;(jemandem mit etwas) aufwarten;kredenzen;auftafeln;auffahren (ugs.);auf den Tisch bringen;auftragen;vorsetzen;jemanden traktieren mit (geh., veraltend)
-förderlich;aufbauend;konstruktiv
-Ausschuss;Komitee;Kommission
-des Pudels Kern (ugs., sprichwörtlich);Dreh- und Angelpunkt;Kern;Hauptgegenstand;Kernpunkt;Hauptsache;Zentrum;Angelpunkt;Herzstück;Kernstück;Drehpunkt;Schlüsselbereich
-Vorzug;Vorrangigkeit;Höherrangigkeit;Bevorzugung;Vorrangstellung;Vortritt;Präzedenz (geh., bildungssprachlich, selten);Primat;Vorrang;Präferenz
-(ist) das erste Mal (überhaupt) dass (ugs.);ohne Präzedenzfall (fig.);ohne Beispiel;unvergleichbar;noch nie dagewesen (ugs.);präzedenzlos (fachspr.);beispiellos
-schmerzvoll;schwer zu ertragen;schlimm;bitter (fig.);schmerzlich;hart (ugs.)
-Widerstreit;Antagonismus (geh., griechisch);Gegensatz;Widerstand
-schmarotzerhaft;parasitär
-Gottergebenheit;Ergebenheit;Hinnahmebereitschaft;Demut;Schicksalsergebenheit
-Berufung;Lebenssinn;Lebensziel
-Eignung;Qualifikation;Fähigkeit;Befähigung;Kompetenzprofil (fachspr.);Kompetenz;Einsatzbarkeit
-potenzieren;steigern;erhöhen
-Verhaltensforschung;Verhaltensbiologie
-Handlungsverlauf;Handlungsablauf
-Vorspielung;Simulation;Vorspiegelung;Simulierung;Vortäuschung
-verästelt;verzweigt;dendritisch
-Vision;Ideal;(positive) Utopie;Vorstellung;Vorbild;Zukunftsbild
-ohne Bezug;unzusammenhängend;anakoluth (fachspr., literarisch);anakoluthisch (fachspr., literarisch);ohne Zusammenhang;inkoordiniert (geh.);unverbunden;inkohärent;zusammenhanglos;unkoordiniert;asyndetisch
-Selbstentfremdung;Entpersönlichung;Depersonalisierung;Depersonalisation
-prädestinieren;vorherbestimmen
-(jemandem) in die Wiege gelegt;prädestiniert;determiniert;vorgezeichnet (Weg);vorbestimmt;vorherbestimmt
-Wiedererleben;Erinnerung;Flashback (engl.);Retraumatisierung
-Verknüpfung;Verbindung;Assoziation;Konnotation;Gedankenverbindung
-bewusstseinsverändernd;bewusstseinserweiternd;halluzinogen;psychedelisch
-Lebensdrang;Überlebenswille;Lebenslust;Selbsterhaltungstrieb;Lebenswille
-Redundanz;Tautologie;Doppelaussage;Pleonasmus
-Überempfindlichkeit;Allergie
-Kameraüberwachung;Videoüberwachung
-nüchtern;(aussehen) als hätte man einen Besenstiel verschluckt;humorlos;keinen Sinn für Humor haben (ugs.);ernsthaft;keinen Spaß vertragen;ernst;(einen) Stock im Arsch (haben) (derb);humorfrei;trocken;alles (viel zu) ernst nehmen;zum Lachen in den Keller gehen (ugs., ironisierend);keinen Spaß verstehen
-(so) (steht es) im Original;wirklich so;sic (sic!) (geh., Hauptform);so
-Argumentation;Beweis;Beweisführung;Begründung
-feststellbar;ermittelbar;bestimmbar;errechenbar
-Beitragsleistung;Beitragszahlung;Prämie
-Medienvertreter;Journalist (franz.);Medienschaffender (mediensprachlich)
-von der Resterampe (ugs.);aus dem 1-Euro-Laden;reduziert;preisreduziert;hinterhergeworfen (bekommen) (fig., variabel);unter Einstandspreis (kaufmännisch);vom Grabbeltisch (ugs.);vom Wühltisch;für einen Apfel und ein Ei (ugs.);(im Preis) heruntergesetzt (Hauptform);Aktionsware;besonders preisgünstig;günstig;unter Preis;verbilligt;herabgesetzt;nachgeschmissen bekommen (ugs., fig.);vom Schnäppchen-Markt;fast geschenkt (ugs.);für ein Butterbrot (ugs.);im Preis gesenkt;für ein Trinkgeld (ugs., fig.);zum Schleuderpreis;zum (einmaligen) Sonderpreis;rabattiert;Schnäppchen;super-günstig (ugs.);Sonderangebot;zu Dumpingpreisen;zum Dumpingpreis;zum Spottpreis;fast umsonst;praktisch für umsonst;runtergesetzt;Super-Schnäppchen (ugs.)
-Teilzahlungskredit;Ratenkredit
-Ausschüttung;Auszahlung
-auszahlen;ausschütten
-besser (ugs.);nach Möglichkeit;möglichst;lieber;am besten;tunlichst (geh.)
-einsetzbar;zweckdienlich;viabel (fachspr.);passend;funktional;zweckmäßig;funktionierend;geeignet
-Gesinnungslosigkeit;Prinzipienlosigkeit;Opportunismus
-Radfahrer (ugs.);williger Vollstrecker;Abnicker;Ja-Sager;(jemandes) Handlanger;Jasager;Erfüllungsgehilfe;Konformist;Opportunist;Wes Brot ich ess, des Lied ich sing. (ugs., Sprichwort);sein Fähnlein nach dem Winde drehen (ugs.);Mitläufer;Gesinnungslump (derb);Wendehals (ugs.);Gesinnungsakrobat
-ungünstig;unangebracht;inadäquat (geh., lat.);unzweckmäßig;ungeeignet;unpassend;untauglich;widrig;importun (geh.);unbrauchbar;unangemessen
-flankieren;begleiten
-an die Hand nehmen (fig.);schützend begleiten;flankieren
-vorbereitet (auf);gerüstet (für / gegen) (fig.);gewappnet (für / gegen) (fig.)
-Profiteur;Nutznießer
-(sich) widersetzen;opponieren;(sich) entgegenstellen
-sprachfertig;sprachgewandt
-Vortragsraum;Seminarraum;Unterrichtsraum;Schulungsraum
-befragen;interviewen;ein Interview machen
-Knochenrappler (ugs., selten);Mittelloser;Habenichts;Bettler;armer Schlucker (ugs.);Armer;Hungerleider (auch figurativ)
-Sekretariat;Geschäftszimmer
-Entscheidung;Resolution;Entschließung;Beschluss
-Lehrprogramm;Lehrplan;Curriculum;Kurrikulum
-(eine Freiheitsstrafe) verbüßen;sitzen (ugs.);im Gefängnis sein;im Gefängnis stecken (ugs.);(seine Jahre im Knast) abreißen (derb);(eine Strafe) absitzen;einsitzen;(seine Strafe) abbrummen (ugs.);gesiebte Luft atmen (ugs.)
-Maturitätsexamen (schweiz.);Reifeprüfung (südtirol.);Maturitätsprüfung (schweiz.);Matur (schweiz.);Abitur;Abiturprüfung
-Okkupation;Einmarsch;Eroberung;Angliederung;Einzug;Annektierung;Invasion;(gewaltsame) Inbesitznahme;Eindringen;Besetzung;Aneignung;Gebietsaneignung;Annexion
-Atomenergie;Kernkraft (fachspr., technisch);Atomkraft;Nuklearenergie;Kernenergie (fachspr., technisch)
-Vorstandsvorsitzender;Vorsitzender des Vorstands;erster Angestellter (ugs.);CEO (engl.)
-Video Home System;VHS
-Zeichen;Fanal;Signal
-berühren;treffen;auftreffen
-Bekehrung;Umkehr;Sinnesänderung;Sinneswandel
-veränderlich;metabolisch
-Umwandlung;Metabolismus;Veränderung
-Intimbereich;Intimsphäre;Privatleben;Privatsphäre;Privatbereich
-Frustration;Desillusion;Frust;Unzufriedenheit;Enttäuschung
-aus reiner Menschenfreundlichkeit;unentgeltlich;ohne Bezahlung;karitativ;aus (christlicher) Nächstenliebe;einfach so (ugs., salopp);freiwillig;ehrenamtlich;um Gotteslohn (geh.);für Gotteslohn (geh.)
-übergroß;überdimensioniert
-Netzhaut;Retina (fachspr.)
-Regenbogenhaut;Iris;Stern (fachspr., Jägersprache)
-Befund;Ergebnis;Resultat;Feststellung
-bedecken;verdecken;übertünchen (auch figurativ);verschleiern;zukleistern (auch figurativ);überkleistern (auch figurativ);überdecken;verhüllen;verkleistern (auch figurativ)
-Schlussvortrag;Schlussrede;Plädoyer
-brechen;ermüden;abhetzen;mürbe klopfen;heimsuchen;aufreiben;strapazieren;mürbe machen;mürbe kriegen;ermatten;entkräften;kleinkriegen (ugs.);mürbe hauen;entnerven;zermürben;enervieren
-mang (ugs., berlinerisch);(mitten) dazwischen;mittenmang (ugs.);mittendrin
-(nur eine) Formalität;(reine) Formsache;Förmlichkeit;Formalie
-graue Eminenz;Drahtzieher;Dunkelmann;Mann im Hintergrund;Strippenzieher (ugs.);Schreibtischtäter (fig.);geistiger Vater;(der) wahre Verantwortliche
-Rummel (um);(große) Aufregung (um);Aufsehen;Wirbel (um);(große) Beachtung;Furore (geh., Hauptform);Aufgeregtheit(en)
-antun (ugs.);zumuten
-Fremdenfreundlichkeit;Xenophilie (fachspr.);Ausländerfreundlichkeit
-entseelt;nicht seiend;unbelebt;tot;abiotisch;leblos
-keimtötend;desinfizierend;antibakteriell;Bakterien tötend;antiseptisch
-Fruchtzucker;Lävulose (veraltet);Fruktose;Fructose
-Gemütsbewegung;Gefühlsausbruch;Affekt
-Sterberisiko;Letalität;tödliche Auswirkung;tödliche Wirkung
-Mutation (geh.);Wandlung;Veränderung
-terminal (fachspr.);im Endstadium;präfinal (fachspr.);moribund (geh.);dem Tode nah
-kurierbar;heilbar;kurabel
-einsetzend;beginnend
-paranoid;wahnhaft
-Zentrum (der Aufmerksamkeit);Fokus;Blickpunkt;Augenmerk;Mittelpunkt;Brennpunkt;Mittelpunkt (der Aufmerksamkeit)
-33er (ugs.);(die) LP (Abkürzung, Hauptform);Platte (ugs.);Schellackplatte;Schallplatte;Scheibe (ugs., jugendsprachlich);Album (veraltet);Langspielplatte;(die) Vinyl (ugs., jugendsprachlich)
-Onomatologie (fachspr.);Onomastik (fachspr.);Namenforschung;Namenkunde
-Notation;Syntax (formale Sprachen);Notationsweise
-wühlen;stochern;kramen (ugs.);gruschen (ugs., bayr.);pulen (ugs.);gruscheln (ugs., bayr.)
-sachbezogen;detachiert (geh., veraltet);sachlich;unpersönlich
-geheimbündlerisch;klandestin (veraltet);verschwörerisch;konspirativ
-Bulimia nervosa (fachspr.);Ess-Brech-Sucht;Bulimie
-Messe;Messfeier;Mette;Andacht;Gottesdienst;heilige Messe
-Personalwirtschaft;Personalmanagement;Personalpolitik;Mitarbeiterführung
-Land;Bundesland
-Nervosität;Spannung;Kick (ugs.);Suspense (engl.);Anspannung;Gespanntheit;Nervenkitzel;Thrill (engl.)
-zermahlen;zerkauen;zerbeißen
-abfrottieren;trockenreiben;abreiben;abtrocknen;frottieren;trocknen;reiben
-beschwören;(etwas) schwören (Hauptform);Stein und Bein schwören;feierlich schwören;(etwas) auf seinen Eid nehmen;beeiden;mit einem Eid bekräftigen;(einen) Eid ablegen;schwören beim Leben (seines / ihres ...);durch einen Eid bekräftigen;auf etwas schwören
-herangehen;herantreten
-Wanderung;Migration;Umsiedlung
-(Nomen/Adjektiv) flektieren;(Nomen/Adjektiv) beugen;deklinieren
-beugen;flektieren (fachspr., lat.)
-Dutzend;zwölf;zwölf Stück;12
-Weihnachtsmarkt (Hauptform);Adventmarkt;Christkindlmarkt;Adventsmarkt
-Schicht;Lage;Ebene
-Borg;kastrierter Eber
-verweisen;des Landes verweisen;ausschaffen (schweiz.);ausweisen
-Zeitabstand;Frist;(zeitlicher) Abstand;Periode;Zeitrahmen;Spanne;Zeitintervall;Zeitspanne (Hauptform);Weile;Zeitabschnitt;Dauer;(zeitliches) Intervall;Zeitdauer;Zeitlang;Phase;Zeit;Zeitraum
-Atomkrieg;Nuklearkrieg
-in diesem Jahr;heuer (bayr., schweiz., schwäbisch, süddt., österr.);dieses Jahr;anni currentis (geh., bildungssprachlich, lat.);diesjährig
-Logopädie;Stimmheilkunde;Sprachheilkunde
-mit Lust und Liebe;mit Freuden (geh.);gern;für sein Leben gern;am liebsten;bereitwillig;mit Freude;mit Vergnügen;gerne (Hauptform);von Herzen
-Muschi (ugs.);Hauskatze;Miezekatze (ugs.);Dachhase (ugs., scherzhaft);Fellnase (ugs.);Samtpfötchen (ugs.);Pussy (ugs.);Katze;Büsi (ugs., schweiz.);Samtpfote (ugs.);Stubentiger (ugs.);Mieze (ugs.)
-Ideenreichtum;Einfallsreichtum;Erfindungsgabe;Innovationskraft;Kreativität;Erfindungsreichtum
-Glühfadenlampe;Glühlampe;Birne (ugs.);Glühlicht (veraltet);Glühbirne
-Antrag;Heiratsantrag
-aufbauen;hochziehen;hinklotzen (derb);hinstellen (ugs.);aufstellen;erbauen;errichten
-fleischlos;pflanzlich;vegetarisch;fleischfrei;ohne Fleisch
-Raumfahrzeug;Sternenschiff;Raumschiff;Raumfähre
-Lektüre;Band;Bd. (Abkürzung);Titel;Schinken (ugs.);Schmöker (ugs.);Buch (Hauptform)
-Manuskriptprüfer;Lektor
-Übergang;Überführung;Viadukt;Brücke;Querung
-Brücke;Kommandobrücke;Befehlsstand;Kommandostand;Schiffsbrücke
-Frankenmetropole;Lebkuchenstadt (ugs.);Nürnberg;Meistersingerstadt (ugs.)
-Tank;Panzer;Panzerwagen
-Skulptur;Statue;steinernes Bild (geh., veraltet);Büste;Plastik;Standbild;Statuette
-Scharfrichter (Hauptform);Carnifex (fachspr., ausgestorben);Nachrichter;Vollstrecker des Todesurteils;Henker (Hauptform);Vollstrecker;Freimann;Meister Hans (geh., fig., veraltet)
-Weihnachtsfest;Heiliger Christ;Weihnachten (Hauptform);Weihnacht;Fest der Liebe (ugs.);Christfest
-Wissenschaft;Forschung
-Entdeckung;Erfindung
-ältestes Gewerbe der Welt (ugs.);Hurerei (abwertend);käufliche Liebe;Prostitution (Hauptform);Gewerbe (ugs.);horizontales Gewerbe (ugs.)
-Lebkuchen;Pfefferkuchen;Lebzelten (österr.);Printe;Honigkuchen;Gewürzkuchen
-Zentralgestirn;Sonne;Sol (fachspr.);Tagesgestirn
-B-Prominenter;Starlet;Sternchen;B-Promi (ugs.);Starchen (ugs.);Möchtegern-Star
-Niederkunft;Gebären;Entbindung;Geburt
-Jahresanfang;Neujahr;1. Januar;Neujahrstag;Jahresbeginn;1. Jänner (österr.)
-Revival (engl.);Renaissance;Comeback;Wiederbelebung;Wiederauferstehung;Wiedergeburt;Auferweckung;Rückkehr;Wiederauflebung
-Olympische Spiele;Olympiade (ugs.);Olympia
-Weltrekord;WR;Weltbestzeit
-Haferl (ugs., bayr., österr.);Häferl (ugs., österr.);Trinkschale;Tasse
-Benehmen;gute Umgangsformen;Benimm;(eine) gute Kinderstube (genossen haben);Umgangsform;(eine) gute Erziehung genossen haben;Galanterie (geh.);Chic;Umgangsformen;Schliff;(sich) zu benehmen wissen;gutes Benehmen;Etikette;gut erzogen;gutes Betragen;Anstand;Stil;feine Sitte;Höflichkeit;Manieren
-zweisprachig;bilingual (fachspr.)
-Sprengsatz;Explosivmaterial;Bombe;Explosivstoff;Sprengstoff
-Bombe (ugs., fig.);Sensation;Knüller (ugs.);Aufsehen;Kracher (ugs.);Knaller (ugs.);Medienereignis;Clou;Brüller (ugs.)
-Vollendung eines Lebensjahres;Ehrentag;Geburtstag (Hauptform);Wiegenfest (geh.);Wiegentag (geh., selten);Purzeltag (ugs.);Burzeltag (ugs.)
-bewegte Bilder (geh., altertümelnd, verhüllend);Streifen (ugs.);Film;Lichtspiel;Video
-Nordpolgebiet;Nordpolargebiet;Arktis
-Jagdjet;Düsenjäger (ugs.);Jäger;Jagdflugzeug
-Oberbefehlshaber;Generalissimus (veraltet);Oberkommandierender;Feldherr
-Druckerzeugnis;Druckwerk;Veröffentlichung;Reproduktion;Druck;Abdruck;Publikation
-Wasserweg;Wasserstraße;Kanal
-Schiffshebewerk;Schiffhebewerk
-Bundesstraße;Bundesfernstraße;Schnellstraße (ugs.);Überlandstraße
-Doktortitel;promoviert;höchster akademischer Grad;Doktor;Doktorgrad;Dr. (Abkürzung)
-Dancing (schweiz., österr.);Zappelbude (ugs.);Tanzschuppen (ugs.);Diskothek;Disko;Club (engl.);Disco;Zappelschuppen (ugs.);Tanzlokal;Disse (ugs.)
-Kampfgas;Giftgas
-Glasbläser;Glaser;Glasmacher
-Gesetzgebung;Legislative (lat.);Gesetzgeber;Legislatur (lat.);Legislation (lat.);gesetzgebende Gewalt
-Staatsgewalt;Administration;Regierung;Obrigkeit;Staatsmacht;Regierungsgewalt;Gubernative (fachspr., lat.)
-im jugendlichen Alter;unerwachsen;noch nicht 18;unter 18 Jahren;minderjährig;jugendlich (Hauptform);noch nicht erwachsen;noch nicht volljährig;noch nicht voll geschäftsfähig;unmündig;unter 18 (ugs.);an der Schwelle zum Erwachsenwerden (geh.);an der Schwelle zum Erwachsensein (geh.)
-Faser;Faden;Litze
-Kommune;politische Gemeinde;Gemeinde
-Bus und Bahn;Öffis (ugs.);Öffentlicher Personennahverkehr;Nahverkehr;ÖPNV (Abkürzung);öffentliche Verkehrsmittel
-Aal (ugs.);Unterwassergeschoss;Torpedo
-Webserver;HTTP-Server
-Stadtschnellbahn;Schnellbahn;S-Bahn
-Badi (schweiz.);Bad;Schwimmbad;Badeanstalt
-Talsperre;Stauwerk;Damm;Staudamm
-Fernsehen;TV (Abkürzung, engl.);Pantoffelkino (ugs.);Television (engl.)
-Darmwind (ugs.);Leibwind (veraltet);Winde (nur Plur.);Flatus;Pupser (ugs.);Vapeur (franz., lat.);Schas (derb, österr.);Blähung;Pups (ugs.);Schoas (derb, bayr.);Furz (derb);Flatulenz
-Knallkörper;Böller (ugs.);Kracher (ugs.)
-Verweis;Referenz
-Rohstoff;Ressource;Hilfsmittel;Arbeitsmittel;Betriebsmittel;Produktionsmittel
-Unterbrechung;Wendepunkt;Einschnitt;Bruch;Zäsur
-Prachtbau;Chateau;Palast;Palais;Schloss;Villa
-Fritten (ugs.);Pommes (ugs.);goldgelbe Freudenspender (ugs.);Pommes frites (franz.)
-Hypochonder;eingebildet Kranker
-Wehmütiger;Melancholiker;Schwermütiger;Elegiker (geh.)
-Choleriker;Hitzkopf;jähzorniger Mensch;Krawallbürste (ugs.);Feuerkopf
-Suffixoid;einem Suffix ähnliches Wortbildungsmittel
-anstößig;bathisch (geh.);vulgär;unter der Gürtellinie (ugs., fig.);geschmacklos;ordinär;unanständig;obszön (geh.)
-Denkschrift;Bericht;Exposé;Exposee;Ausarbeitung;Ausführung;Darlegung
-Exposee;Exposé;Skizze;Plan;Zusammenfassung
-Präservativ;Verhüterli (ugs.);Pariser (ugs.);Kondom;Präser (ugs.);Gummi (ugs.);Lümmeltüte (derb)
-unverschwiegen;indiskret
-Respekt;taktvolle Rücksichtsnahme;Pietät
-Entgleisung;Respektlosigkeit;Pietätlosigkeit;Taktlosigkeit;Tabubruch;Fauxpas;Ungehörigkeit;Geschmacklosigkeit
-indizieren;indexieren;mit einem Index versehen
-als angezeigt erscheinen lassen;indizieren (fachspr.);anzeigen
-Mamille (fachspr.);Brustwarze;Nippel (ugs.)
-Hörensagen;Buschfunk (ugs.);Flurfunk (ugs.);unbestätigte Meldung;Scheißhausparole (derb);Fama (geh.);Latrinenparole (ugs.);Gerüchteküche;Gerücht
-ad acta legen;als erledigt betrachten
-Instanz;Entität
-Einwohner;Mitbürger;Volksgenosse (NS-Vokabel);Landsmann
-unbelebtes Objekt;nicht lebendes Objekt
-Waffe;Kampfgerät
-Vorfall;Zwischenfall
-nachdenken;(seine) Gehirnzellen anstrengen (ugs.);überlegen;(seinen) Verstand benutzen;denken
-Bratensud;Fond;Fleischsaft;Sud
-risikofreudig;vermessen;riskant;Wer wagt, gewinnt. (ugs., Sprichwort);tollkühn;draufgängerisch;alles auf eine Karte setzen (ugs.);mit Todesverachtung (auch figurativ);vor nichts zurückschrecken;waghalsig;tolldreist;todesmutig;verwegen;risikobereit
-Organisation;Laden (ugs., salopp);Anstalt;Einrichtung;Institut;feste Einrichtung;Institution
-Gevatter (ugs.);Schnitter (ugs.);Boandl (ugs., bayr., österr.);Boanl (ugs., bayr., österr.);Todbringer (ugs.);Knochenmann (ugs.);Freund Hein;Gevatter Tod;Tod (Personifikation) (Hauptform);Boanlkramer (ugs., bayr., österr.);Boandlkramer (ugs., bayr., österr.);Sensenmann (ugs.);Hein;Thanatos (griech.)
-Klöten (derb);Familienjuwelen (ugs.);Sack (derb);Testikel (fachspr.);Eier (ugs.);Hoden
-Vermischung;Verschmelzung;Synkretismus
-Domizil;Heim;Wohnsitz;Sitz;Heimatort;Residenz
-Behausung (ugs.);Bude (ugs.);Heim;Haus (Hauptform);Hütte (ugs.)
-Pflanze (Hauptform);Gewächs
-Hauptprozessor;zentrale Prozessoreinheit;Zentraleinheit;Mikroprozessor;Central Processing Unit (engl.);CPU (Abkürzung, engl.);Kern;Prozessor
-GPU (Abkürzung, engl.);Graphics Processing Unit (engl.);Grafikprozessor;Graphikprozessor
-Piepmatz (ugs.);Federvieh (ugs.);Vogel (Hauptform);gefiederter Freund
-Maßeinheit;Maß;Einheit
-Gerstensaft (ugs.);Ballerbrühe (derb, abwertend, salopp);Hopfentee (ugs., fig., ironisch);Hopfenkaltschale (ugs., fig., ironisch);Hopfen und Malz (ugs.);Flüssigbrot (ugs., scherzhaft);Bölkstoff (ugs., norddeutsch, salopp);Bier;Gerstenkaltgetränk (ugs.);Maurerbrause (derb, fig.);Krawallbrause (ugs., fig.);Gerstenkaltschale (ugs., fig., ironisch)
-Hardware;Gerätschaft;Computerkomponente
-Fellatio;Lecken (ugs.);Oralverkehr;Oralsex;Blasen (ugs.)
-Partei;politische Kraft (ugs.);politische Partei
-Linkspartei (ugs.);Die Linkspartei;Die Linke;PDS;Partei des Demokratischen Sozialismus;SED-Nachfolgepartei
-Blume;Blühtrieb (fachspr.);blühender Trieb (fachspr.)
-Schaum auf gefülltem Bierglas;Schaumkrone;Blume
-Datenspeicher;Speicher
-Musikinstrument;Instrument
-TV-Sender;Fernsehprogramm (ugs., Hauptform);Fernsehsender (Hauptform);Programm (ugs.);Fernsehkanal;Sender (ugs.)
-Central Intelligence Agency;CIA
-Grünzeug (ugs.);Gemüse (Hauptform);essbare Pflanzen(teile)
-Mord;Ermordung
-Element;Grundstoff;Urstoff;chemisches Element
-MC;Audiokassette;Kassette;Tonbandkassette;Musikkassette (Hauptform);Kompaktkassette
-Euro;Euronen (ugs.);€ (Währungssymbol);Euroletten (ugs.);EUR (Abkürzung)
-Euphonie;Eufonie;Wohlklang
-beschönigend;schönfärberisch;abmildernd;verbrämend;schönredend;aufwertend;euphemistisch;verhüllend;verschleiernd
-Kalenderjahr;Jahr (ugs.);bürgerliches Jahr (fachspr.)
-Protestler;Demonstrationsteilnehmer;Demonstrant;Demonstrierender (Papierdeutsch)
-Pestseuche;Beulenpest;Pestilenz (veraltet);Pest;schwarzer Tod;Gottgeißel
-Nasenschleim;Schnodder (derb);Rotz (derb);Popel (ugs.);Rotze (derb);Butzen (ugs.);Nasensekret
-schließende eckige Klammer;];rechte eckige Klammer
-Klammer auf;öffnende runde Klammer;(
-Dispo (ugs.);Dispokredit (ugs.);Überziehungskredit;Dispositionskredit
-rausfiltern;extrahieren;ausfiltern;rausfischen (ugs.);herausfiltern;herausfischen (ugs.);wegfischen (ugs.)
-melden;Bericht erstatten;reportieren;berichten;rapportieren
-Demoskopie;Meinungsforschung
-hetero (ugs.);heterosexuell
-bayrisch;bayerisch;bajuwarisch
-Liebe;(starke) Zuneigung
-Wetterereignis;Wetterphänomen
-Trinkröhrchen;Trinkhalm;Strohhalm (ugs.);Plastikstrohhalm (ugs.)
-Blechkamerad (ugs., fig., scherzhaft);Automat;Agent (fachspr.);Maschine;Roboter
-reüssieren;Erfolg haben;(die) Lorbeeren ernten (fig.);erfolgreich sein
-Kadaver;Tierleiche;Tierkörper;Aas
-Aas (ugs.);Lombadier (ugs., schwäbisch, stark abwertend);(das) Mensch (derb, abwertend, schwäbisch);Bissgurn (ugs., bayr.);Mistkuh (derb);Weibsstück (derb);Luder (ugs.);Miststück (Frau) (derb, Hauptform);Biest (ugs.);Hexe (ugs.);Bitch (derb, engl.)
-Grobian;Wilder;grober Klotz (ugs.);wildes Tier (fig.);ungehobelter Kerl;Bauer (ugs.);Barbar;Rohling;Raubein
-streng riechen;bestialisch stinken;zum Himmel stinken;(die) Luft verpesten;aus allen Knopflöchern stinken (ugs., fig.);(einen) strengen Geruch verbreiten;fürchterlich stinken;schlecht riechen;stinken wie die Pest (ugs., Verstärkung);übel riechen;unangenehm riechen;stinken (Hauptform);(einen) pestilenzartigen Geruch verströmen
-Halsabschneider (ugs., abwertend, fig.);Leuteschinder (abwertend);Lohndrücker;Sklaventreiber (abwertend, fig.);Parasit (ugs., abwertend, fig.);Hyäne (ugs., abwertend, fig.);Ausbeuter (abwertend);Schinder (abwertend);Aasgeier (ugs., abwertend, fig.);Profiteur;Blutsauger (abwertend, fig.);Profitmacher
-weiden;äsen;grasen
-anmachen;verkneten;mischen;anrühren;zubereiten;verarbeiten;verrühren
-färben;übermalen;anmalen;tünchen;bemalen;bepinseln
-(sich) zurechtmachen (ugs.);Make-up auflegen;(sich) anmalen (ugs., abwertend);(sich) aufdonnern (ugs.);(sich) schminken;Kriegsbemalung auflegen (ugs., scherzhaft-ironisch);(sich) auftakeln (ugs.);(sich) aufbrezeln (ugs.)
-weich;ohne Biss (ugs.);mimosenhaft;verweichlicht;(jemandes) Prinzessin;verzärtelt;weichlich;verwöhnt;verpimpelt (ugs., regional);verhätschelt;verzogen;(jemandes) Prinzesschen;zimperlich
-aufwühlend;furios;dramatisch;erregend;nervenaufreibend
-Auflösung;Abwicklung;Kahlschlag;Schließung;Liquidation;Stilllegung
-Annullierung;Abschaffung;Beseitigung;Streichung;Aufhebung;Auflösung;Einstellung
-asketisch;karg;entbehrungsreich (Hauptform);entbehrungsvoll;entsagungsvoll
-Schaden;Schädigung;Aderlass (fig.);Verlust
-fummeln;wurschteln (ugs.);friemeln (ugs.);werkeln;fieseln (ugs.);knispeln;pfriemeln (ugs.);bosseln (ugs.);fingern;nesteln;basteln (ugs.)
-Sprach- und Literaturwissenschaft;Philologie
-Schlosserhammer (fachspr., Handelsname);Werkzeughammer (Hauptform);Hammer
-schnuppern;schnobern (ugs.);winden (Jägersprache);riechen (an);beschnobern (ugs.);schnüffeln;beriechen;wittern;beschnuppern;flehmen (fachspr.);beschnüffeln
-Wasser (Hauptform);kostbares Nass (geh.);blaues Gold (geh., literarisch);Nass (geh.);Aqua (fachspr., lat.);kühles Nass (ugs., mediensprachlich);H2O (fachspr., Abkürzung);das nasse Element (geh., literarisch);H₂O (fachspr., Abkürzung);Quell des Lebens (geh., poetisch)
-Kraftrad;Bock (ugs.);Töff (ugs., schweiz.);Feuerstuhl (ugs.);(heißer) Ofen (ugs.);Krad;Maschine (ugs.);Motorrad
-Quercus (fachspr.);Eiche
-Baum;Makrophanerophyt (fachspr.)
-Fagus (fachspr., botanisch);Buche (Hauptform)
-Abies (fachspr., botanisch);Tannenbaum (ugs.);Tanne
-Paradiesfrucht (geh., dichterisch);Apfel;Apfelfrucht (fachspr.)
-Affensteak (ugs.);Affenkotelett (ugs.);Affenwurst (ugs.);Affeneis (ugs.);Dessertbanane;Banane;Affenbrot (ugs.);Affenschnitzel (ugs.);Affenhandy (ugs.);Affenknacker (ugs.);Obstbanane
-Quecksilber (ugs.);Temperaturmesser;Thermometer
-Apfelsine;Orange
-Tangerine;Clementine;Mandarine;Citrus reticulata (fachspr.);Satsuma (japanisch)
-Ananas (ugs., österr.);Erdbeere
-Sitzplatz;Sitz;Sitzgelegenheit;Platz
-US-Bürger;Ami (ugs.);US-Amerikaner;Yankee (abwertend);Amerikaner
-Blüte (ugs.);Falschgeld
-politische Bewegung;Bewegung
-Konservativismus;Konservatismus
-Fraktion;Lager;Gruppierung;(linkes o.ä.) Spektrum;Flügel;Gruppe;Block
-Kollaboration;Zusammenarbeit mit dem Feind
-Bux(e) (ugs., norddeutsch);Büx (ugs., norddeutsch);Hose;Hosen;Beinkleid (ugs.)
-Nicki (ugs., ostdeutsch);T-Shirt (engl., Hauptform);Leiberl (ugs., bayr., österr.);Leible (ugs., schwäbisch);Leibal(i) (ugs., österr.)
-Shirt;Hemd
-Dessous;Damenunterwäsche;Damenwäsche;Reizwäsche
-Wein;Rebensaft
-Fliege;Brummer (ugs.);Sumse (ugs.)
-Kerbtier;Kerf;Krabbeltier (ugs.);Krabbelviech (ugs.);Insekt;Hexapode (fachspr.)
-Sommer;warme Jahreszeit
-Elektrogerät;elektrisches Gerät
-Videorekorder;Videokassettenrekorder;Videorecorder
-Paprika;Paprikaschote
-Paradiesapfel (ugs., regional);Lycopersicon esculentum (fachspr., botanisch, veraltet);Liebesapfel (geh., veraltet);Paradeisapfel (ugs., regional);Tomate;Lycopersicon lycopersicum (fachspr., botanisch, veraltet);Paradeiser (österr.);Solanum lycopersicum (fachspr., botanisch);Solanum esculentum (fachspr., botanisch, veraltet)
-Cucumis sativus;Gurke
-Küchenwerkzeug;Küchengerät;Küchenutensil;Küchenhelfer (fachspr., Jargon, werbesprachlich)
-Kaffeeaufbereiter;Kaffeemaschine
-Glas;Fensterglas
-Yacht;Jacht
-Vorwegnahme;Antizipation
-Zwischenspiel;Episode;Intermezzo
-Immunabwehr (ugs.);körpereigenes Abwehrsystem;Immunsystem
-Rechenvorschrift;Berechnungsverfahren;Algorithmus;(genau definierte) Handlungsvorschrift
-verformen;extrudieren
-Magenschleimhautentzündung;Gastritis (fachspr.)
-Urologe;Zipfeldoktor (derb)
-Offenbarung;Apokalypse;Tag des jüngsten Gerichts;Götterdämmerung;Weltende;Ende der Welt;Ragnarök;Weltuntergang
-Jungfernzeugung;eingeschlechtliche Fortpflanzung;Parthenogenese (fachspr.);Jungferngeburt
-Monoceros;Einhorn
-Fabeltier;Fabelwesen
-Abmessung;Ausdehnung;Dimension
-Willkürlichkeit;Beliebigkeit;Arbitrarität;Willkür
-geschäftig hin- und herlaufen;wimmeln;(sich) tummeln;durcheinanderwuseln;herumwuseln;wuseln (ugs.)
-Maus;Mouse (engl.)
-Tastatur;Keyboard (engl.)
-vergammelt (ugs.);desolat;auf den Hund gekommen (ugs.);abgewrackt (ugs.);verwildert;verludert;zerfleddert;verwahrlost;zerfasert;(herumlaufen) wie ein Penner (derb, abwertend);verlottert;abgerissen;in einem schlechten Zustand;muchtig (ugs., berlinerisch);verschlissen;ungepflegt;marode;abgerockt (ugs., salopp);abgeranzt (ugs.);abgehalftert;schäbig;ruiniert;zerlumpt;verdorben;verkommen;abgefuckt (derb, jugendsprachlich);(äußerlich) heruntergekommen (Hauptform);gammelig (ugs.);verlumpt;mies;zerschlissen;am Ende;abgetakelt;abgewirtschaftet
-insolvent;ohne einen Cent in der Tasche;ohne Geld (dastehen);(finanziell) am Ende;(seine) Rechnungen nicht mehr (be)zahlen können;illiquid(e) (geh.);blank (ugs.);mittellos;pleite;zahlungsunfähig;bankrott;abgebrannt (ugs.)
-Abreibung (ugs.);Verweis;Rüge (Hauptform);Moralpredigt;Schelte;Standpauke (ugs.);Anpfiff (ugs.);Schimpfe (ugs.);Zurechtweisung;Ermahnung;Einlauf (ugs., fig., salopp);Abkanzelung;Rüffel;(ein) Donnerwetter (ugs.);Abmahnung (juristisch);Maßregelung;Denkzettel (ugs.);Ordnungsruf (politisch);Lektion;Tadel;Zigarre (ugs., fig.);Adhortation (fachspr., veraltet);Strafpredigt (ugs.);Opprobration (geh., lat., veraltet);Anschiss (ugs., salopp);Lehre
-(eine) Wucht (ugs., regional);(dann hat dein) Arsch Kirmes (derb);Prügel;den Arsch voll kriegen (derb);Senge (ugs.);(es gibt) was hinter die Ohren (ugs.);Hiebe;(die) Jacke voll (ugs.);es setzt was mit dem Rohrstock;Kloppe (ugs.);es setzt was;Tracht Prügel;(es gibt) was hinter die Löffel (ugs.);Keile kriegen (ugs.);langen Hafer kriegen (ugs.);Schläge;Züchtigung;Abreibung (ugs.);Dresche (ugs.);(es gibt) langen Hafer (ugs.);Haue (ugs.);es setzt Prügel;Körperstrafe
-Massage;Körpermassage
-reiben;abrubbeln (ugs.);abreiben;(durch Reiben) entfernen;wegpolieren
-abreiben;abfahren;(Räder, Reifen) abnützen;(Räder, Reifen) abnutzen
-Dressur;Abrichtung;Tiertraining
-scharfes S;Eszett;Buckel-S (ugs.);ß
-Suffizienz;Hinlänglichkeit
-Geschworener (veraltet);Schöffe;Laienrichter
-hinfällig;haltlos;nicht mehr erforderlich;nicht (weiter) der Rede wert;substanzlos;nicht weiter beachtenswert;nichtig;obsolet (geworden) (geh.);gegenstandslos;(hat sich) erledigt (ugs.);Wegfall der Geschäftsgrundlage (fachspr., juristisch, veraltet);unbegründet;unhaltbar
-Flausen (ugs.);Grillen;Mucken (ugs.);Launen;Anwandlungen;Kapriolen;Spinnerei (ugs.);Allüren
-Opfertisch;Altar
-Fernsprechbuch;Fernsprechverzeichnis;Telefonbuch;Teilnehmerverzeichnis
-binden;fädeln;schnüren
-unmoralisch;verwerflich;ethisch bedenklich;sündhaft (religiös);unethisch;unsittlich;amoralisch (geh.);sittenwidrig (fachspr., juristisch)
-Schlüssigkeit;Stichhaltigkeit (Hauptform);Stringenz
-durchgängig;bündig;stringent
-Beiwohnen;Hospitanz
-Paddel;Ruder
-Oryza sativa (fachspr., griechisch, lat.);Reis
-Pot (ugs.);Gras (ugs.);Ganja (ugs.);Cannabis
-Einfühlsamkeit;Takt;Zartgefühl;Empathie (fachspr.);Feinsinnigkeit;Feingefühl;Empfindsamkeit;Sensibilität;Dezenz
-Glücksspieler;Zocker (derb);Glücksjäger;Hasardeur;Abenteurer;Glücksritter;Spielernatur
-Pingeligkeit;Kleinkariertheit (ugs.);Korinthenkackerei (derb);Übergenauigkeit;Kleinlichkeit;Erbsenzählerei (ugs.);Bürokratismus;Pedanterie (Hauptform);Kleinigkeitskrämerei
-Erwägung;Betrachtung;Vorstellung;Deliberation (lat.);Abwägung;Berechnung;Überlegung;Kalkül;Reflexion;Bedacht;Gedanke
-eine Auszeichnung verleihen;auszeichnen;dekorieren
-nun;dabei;hierbei;in diesem Fall;in diesem Zusammenhang;dieserfalls;hier;unterdies;derbei;dazu
-entschlossen;aufrecht;mannhaft
-Badewanne;Wanne
-Bad;Nasszelle (im Mini-Apartment);Badezimmer
-Küche;Kochstube
-tast-sensorisch;haptisch;den Tastsinn betreffend
-Geschichte machen;in die Annalen eingehen
-Funksprechgerät;Funkgerät;Handfunkgerät;Walkie-Talkie
-Speckgürtel (ugs.);Feinkostgewölbe (ugs., fig.);(dicker) Bauch;Schmerbauch;Plauze (ugs.);Wampe (ugs.);Wanst (ugs.);Rettungsringe (ugs., fig.);Bierbauch
-Müesli (schweiz.);Müsli
-nachvollziehbar (fachspr.);wiederholbar;reproduzierbar
-Administration;Bürokratismus (abwertend);Bürokratie;Administrative (fachspr., lat.);Obrigkeit;öffentliche Hand;Verwaltung;Apparat(e);Wasserkopf (ugs., abwertend, fig.);Beamtenapparat;Verwaltungsapparat
-aristokratisch (geh.);adlig;vom Vornehmsten;hochherrschaftlich;herrschaftlich;adelig
-edel;erhaben;illuster;distinguiert;hehr (veraltet);erlaucht (geh.);von gehobener Eleganz;vornehm
-Note;Schreiben;Memorandum;Adresse;Denkschrift;Eingabe
-Steganographie;Steganografie;verborgene Übermittlung von Informationen
-Millionenstadt;Metropolis;Weltstadt;Metropole
-Bündelung;Konzentration;Fokussierung
-semiprofessionell;halb professionell
-aushebeln (fig.);unterlaufen;knacken (ugs., fig.);aufbrechen (fig.);wirkungslos machen;umgehen;außer Gefecht setzen (fig.)
-Judentum;Judaismus;jüdische Religion
-Brahmanismus;Hinduismus
-Designer;Gestalter
-Leben nach dem Tod;Jenseits;Himmel;Garten Eden;Paradies;Eden;Himmelreich
-Mischpoke (ugs.);Familienbande;Sippe;Haus;Geblüt;Geschlecht;Familie (Hauptform);Stamm
-Städtchen;kleine Stadt;Kleinstadt;Krähwinkel;Marktflecken;Provinznest (abwertend);Provinzkaff (abwertend)
-Jogurt;Joghurt
-verschlafen;verpennen (ugs.);zu lange schlafen
-Nervenheilkunde;Neurologie
-Imperativ;moralische Forderung
-Düsterheit;Düsternis;Dunkelheit;Finsternis;Dunkel
-Dusche;Brause (ugs.)
-Abbitte;Bitte um Verzeihung;Entschuldigung;Pardon
-Astrobiologie;Wissenschaft vom außerirdischen Leben;Exobiologie
-Ausschluss;Aussperrung;Disqualifikation;Disqualifizierung;Boykott;Abbruch
-Gemeinschaft;Kameradschaft;Miteinander;Freundschaft
-Jungfrau;Jungfer (geh., veraltet);Juffer (ugs., regional)
-(jemanden) in die Pfanne hauen (ugs.);Leid zufügen;Leid antun;(jemandem) eins auswischen (ugs.);(jemandem) schaden;Schaden zufügen;(jemanden) schädigen
-oben angeführt;o. a.
-hervorheben;Wert auf die Feststellung legen (, dass ...) (floskelhaft);in aller Deutlichkeit sagen (floskelhaft);unterstreichen (fig.);deutlich machen;verdeutlichen;betonen;erklären
-(Essen) machen (ugs.);am Herd stehen (ugs.);kochen;(Essen) zubereiten
-knackig;resch (bayr., österr.);knusprig;kross;rösch
-Portefeuille;Depotzusammensetzung;Portfolio
-Gamer (ugs.);Spieler;Glücksspieler;Zocker (ugs.)
-Postdienststelle;Post;Postamt
-Briefe;Briefpost;Korrespondenz;Schreiben;Post
-Eingeladener;Besucher;Gast
-verharren;vor Ort bleiben;verweilen;sich nicht (von der Stelle) rühren;stehen bleiben;harren;weilen;warten
-Initiative (die jemand besitzt);Tatendrang;Tatkraft;Resolutheit;Entschlusskraft
-unter Strom stehend (ugs.);engagiert;emsig;rege;schaffig (ugs., regional);betriebsam;aktiv;geschäftig;arbeitsreich;unter Dampf stehend;umtriebig;rührig
-funktionsfähig;intakt;läuft (noch) (ugs.);ganz (ugs.);funktionierend;mängelfrei;heil;unbeschädigt;unversehrt;heile (ugs.)
-puritanisch;züchtig (geh.);tugendhaft (geh.);sittenstreng
-Auslese;Auswahl;Zusammenstellung;Sammlung
-noch mal von vorn (ugs.);noch einmal von Anfang an;noch einmal von vorne;da capo
-Konsumrausch;Kaufrausch
-Lobgesang;Loblied;Lobeslied;Lobeshymne;Hohelied (fig.)
-Lobgesang;Loblied;Hymne;Festgesang;Preislied
-Fruchtwasseruntersuchung;Amniozentese (fachspr.)
-Unterscheidbarkeit;Differenzierbarkeit;Diskriminierbarkeit
-Anspruchshaltung;Erwartungshaltung;Anspruchsdenken;Jammern auf hohem Niveau (fig., variabel);Versorgungsmentalität;Ansprüchlichkeit (psychol.) (geh.)
-Morbus Langdon-Down (fachspr.);Down-Syndrom;Langdon-Down-Syndrom (fachspr.);Downsyndrom;Trisomie 21 (fachspr.);Mongoloismus (ugs., abwertend, veraltend);Mongolismus (ugs., abwertend, veraltend)
-Zwangsmaßnahme;Sanktion
-Gimmick;Werbegag;Werbetrick
-Millennium;tausend Jahre;Jahrtausend
-Erscheinungsvermerk;Impressum
-epistemologisch;erkenntnistheoretisch
-Erkenntnistheorie;Epistemologie;Gnoseologie
-großer Anfangsbuchstabe;Initiale;Kapitale
-nach außen gewölbt;konvex;erhaben
-konkav;nach innen gewölbt
-Kristallnacht (ugs., Jargon);Reichskristallnacht (Jargon);Novemberpogrome 1938;Reichspogromnacht
-Festtag;Ruhetag;Feiertag
-aufhören (bei) (ugs.);ausscheiden;das Handtuch werfen (ugs., fig.);(seine) Kündigung einreichen;(sich) was anderes suchen (ugs.);(den Kram) hinschmeißen (ugs.);in den Sack hauen (ugs., fig.);abmustern (fachspr., seemännisch);(den) Dienst quittieren;(ein Unternehmen) verlassen;gehen (ugs.);künden (schweiz.);abheuern (fachspr., seemännisch);(den) Job an den Nagel hängen (fig.);kündigen;(seinen) Abschied nehmen;(eine) neue Herausforderung suchen (Bewerbungssprache);(sein) Bündel schnüren (fig.);(den) Bettel hinschmeißen (ugs.);(sein) Büro räumen;weggehen (ugs.);was Besseres finden;seinen Hut nehmen (fig.)
-Fehlgeburt;Abortus (fachspr.);Abort (fachspr.)
-rxlCopyrightByDanielNaber;rxlThesaurusVonDanielNaber
-bedrohlich;verschreckend;beängstigend;gefährlich
-Tendenz steigend (als Nachsatz);mehr und mehr;immer mehr (Hauptform);(eine) Welle von;mit steigender Tendenz;zunehmend;gehäuft;in zunehmendem Maß;...welle;vermehrt;immer öfter;verstärkt
-charakterisieren;beschreiben;kennzeichnen
-Crème de la Crème (ugs., franz.);Auswahl der Besten;Führungsschicht;die Besten der Besten;(die) besten Kreise;(die) oberen Zehntausend;Spitze(n) der Gesellschaft;Elite
-Verweltlichung;Entchristlichung;Säkularisation;Säkularisierung;Säkularismus;Abwendung von der Kirche;Entkirchlichung (selten);Dechristianisierung (lat.)
-Auseinandergehen;Abweichung;Divergenz;Antagonismus (geh., griechisch);Verschiedenartigkeit;Ungleichheit
-Schlächterei;Fleischhauerei (österr.);Metzgerei;Schlachterei;Fleischereibetrieb;Metzgerladen;Fleischerfachgeschäft;Fleischerei;Fleischfachgeschäft
-Schlübber (ugs.);Höschen;Unterhose;Slip;Schlüpfer
-BASIC;Beginner's All Purpose Symbolic Instruction Code
-C#;C-Sharp
-PHP: Hypertext Preprocessor;PHP (Hauptform)
-Algorithmic Language;ALGOL
-FORTRAN;Formula Translator
-(sich) kreuzen;(sich) überkreuzen;(sich) überlagern;(sich) überlappen;(sich) ins Gehege kommen (ugs.);(sich) überdecken;(sich) überschneiden;(sich) in die Quere kommen (ugs.);dazwischenfunken (ugs.)
-laben;erquicken;erfrischen
-traut;familiär;bekannt;vertraut
-festklopfen (ugs., fig.);perpetuieren (geh.);verfestigen;verstetigen (geh.);stabilisieren;den Fortbestand sichern;konservieren;bewahren;immer weitertragen
-modellhaft;paradigmatisch
-Heilige Schrift;Wort Gottes;Buch der Bücher (ugs.);Bibel
-heiliges Buch des Islam;Koran
-geistiges Eintauchen;Versenkung;innere Einkehr;Innenschau (geh.);Nachsinnen;Nachdenken;Sammlung;Kontemplation
-Archetyp;Archetypus;Urbild
-Lustknopf (ugs.);Klitoris;Lusterbse (ugs.);Kitzler;Lustperle (ugs.)
-Nachrichteninhalt;Nachrichtengehalt;Information
-Wendigkeit;Beweglichkeit;Agilität
-Sprühdose;Spraydose
-diagnostizieren (fachspr.);bestimmen;(Krankheitsbefund) ermitteln;feststellen
-übersetzen;hinüberfahren
-annualisiert;auf ein Jahr gerechnet
-Mittelachse;Zentralmächte;Achsenländer;Mittelmächte;Vierbund
-1. Weltkrieg;Erster Weltkrieg
-synoptisch;zusammengestellt
-konzis;notdürftig;knapp;kurz
-Volksmund;Alltagssprache;Umgangssprache
-im Volksmund;volksmundlich;in die Tüte gesprochen (ugs.);allgemein verständlich;landläufig (ausgedrückt);so dahin gesagt (ugs.);salopp gesprochen;vereinfacht gesagt;in einfacher Sprache;in Alltagsdeutsch;in einfachem Deutsch;alltagssprachlich;gemeinsprachlich (fachspr.);allgemeinverständlich ausgedrückt;umgangssprachlich (Hauptform);allgemeinverständlich;in lässiger Redeweise;einfach ausgedrückt;in informellem Sprachgebrauch;in einfachen Worten;einfach gesagt (ugs.)
-(etwas) nebenbei laufen haben (ugs.);einen Seitensprung machen;ehebrechen (geh., biblisch, veraltet);(dem männlichen Partner) Hörner aufsetzen;(einen Mann) zum Hahnrei machen;fremdgehen (ugs.);untreu sein (Hauptform);eine Affäre haben;betrügen
-den Gurt anlegen;angurten;anschnallen
-schlechtmachen;verlästern;für ehrlos erklären;infamieren (geh.);schlechtreden (ugs.);verschreien;miesmachen (ugs.);verleumden;heruntermachen (ugs.);madigmachen (ugs.)
-ringförmige Koralleninsel;Atoll
-Unwägbarkeiten;Imponderabilien;unvorhersehbare Einflüsse
-Buchstabenfolge;Abc;Alphabet;Abece
-simplifizieren (geh.);(übertrieben) vereinfachen;schablonisieren (geh., selten);vergröbern
-mediterran;mittelmeerisch;zum Mittelmeerraum gehörend
-Zählung;Bestandsaufnahme;Inventur;Erfassung;Inventarisierung
-zufrieden;saturiert;befriedigt;satt;gesättigt
-Sicherheit;Einsatz;Hinterlegung;Kaution;Versatzstück (österr.);Depot (schweiz.);Pfand;Sicherheitsleistung
-Weltenbrand (geh.);Weltkrieg;Völkerringen (geh., veraltet)
-militärische Option (verhüllend);kriegerischer Konflikt;Orlog (veraltet);die Fortsetzung der Politik mit anderen Mitteln;Kampfhandlungen;Waffengang;Krieg (Hauptform);bewaffneter Konflikt;Feldzug;kriegerische Auseinandersetzung;militärische Auseinandersetzung;kriegsähnliche Zustände;militärisch ausgetragener Konflikt;bewaffnete Auseinandersetzung
-2. Weltkrieg;Zweiter Weltkrieg
-fernmündlich (fachspr., Amtsdeutsch, Jargon);auf telefonischem Wege;telefonisch (Hauptform);per Telefon (variabel)
-Reflektor;Katzenauge (ugs.);Rückstrahler
-Pflaster;Heftpflaster
-Zwischenwerte berechnen;interpolieren
-hochrechnen;extrapolieren
-Fahrtenschreiber;EG-Kontrollgerät;Tachograph (fachspr.);Tachograf (fachspr.);Fahrtschreiber;Fahrtenzähler
-zwischen zwei Staaten;bilateral;zwischenstaatlich;zwei Staaten betreffend
-Gottesgelehrtheit;Religionswissenschaft;Theologie
-abwandeln;konvertieren;umwandeln;ummünzen;abändern;verarbeiten (zu);umsetzen;ändern
-Hafen;Port (fachspr.)
-Wasserverkehr;Seefahrt;Schifffahrt
-Verkehrswesen;Verkehr
-Tansania;Vereinigte Republik Tansania
-Republik Polen;Polen
-Holland (ugs.);(die) Niederlande;Königreich der Niederlande
-Confédération suisse (franz., offiziell);Helvetische Republik;Helvetia (lat.);Helvetien;Eidgenossenschaft;Confederaziun svizra (offiziell, rätoromanisch);Confederazione svizzera (ital., offiziell);Confoederatio Helvetica (lat., offiziell);Alpenrepublik (ugs.);Raetia (lat., veraltet);Schweizerische Eidgenossenschaft (offiziell);Schweiz
-Dänemark;Königreich Dänemark
-Druckperipherie;Printer (Anglizismus);Drucker
-Brauerei;Bierhersteller;Brauhaus;Biererzeuger;Bierbrauerei
-Anschlag;Bekanntmachung;Poster;Plakat;Aushang
-Zahnersatz;Totalprothese;Gebiss;Vollprothese;falsche Zähne (ugs.);dritte Zähne (ugs.)
-Fuß (süddt., österr.);Bein;Lauf (Wildtiere);Kackstelze(n) (derb);untere Extremität (fachspr.);hintere Extremität (fachspr.);Pinn(e) (ugs., norddeutsch)
-herumkrakeln (ugs.);krakeln (ugs.);schmieren (ugs.);hinkritzeln (ugs.);hinsudeln (ugs.);herumschmieren (ugs.);sudeln (ugs.);hinschmieren (ugs.);kritzeln;herumkritzeln (ugs.);hinkrakeln (ugs.)
-ins Reine schreiben;schönschreiben
-(auf einer Tastatur) schreiben;tippen;hacken (ugs.);eingeben
-niederschreiben;dokumentieren;schriftlich festhalten;aufschreiben
-Chitinpanzer;Exoskelett (fachspr.);Skelett
-ablegen;speichern;bereithalten
-(sich) auf allen vieren (bewegen) (ugs.);robben;krauchen (ugs.);(die) tiefste Gangart (ugs., Jargon, militärisch, sarkastisch);kriechen;krabbeln;gleiten
-Maul (derb);Schnauze (derb);Klappe (ugs., abwertend);Fresse (derb);Gosche (ugs.);Omme (derb);Gusche (ugs.);Pappen (ugs., bayr., österr.);Schnute (ugs.);Gosch (ugs.);Mund (Hauptform);Fressluke (derb)
-betasten;befummeln (ugs.);begrabschen (ugs.);befingern (ugs.);betatschen (ugs.);begrapschen (ugs.)
-husten;bellen (ugs.)
-Reziproke;reziproker Wert;Umkehrbruch;Kehrbruch;Kehrwert
-Ypsilon;Y
-Dysenterie (fachspr.);Dissenterie (veraltet);Ruhr (veraltet)
-Fortpflanzungstrieb;Lust auf Sex;Sexualtrieb;Geilheit (ugs.);sexuelles Verlangen;Geschlechtstrieb;Libido
-häufig gestellte Fragen (und Antworten);FAQ;frequently asked questions (engl.);häufige Fragen
-Joystick;Spielhebel (veraltet)
-Polytetrafluorethylen;Polytetrafluorethen;Teflon (Handelsname);PTFE (Abkürzung)
-Endstück;Terminator
-Kicker (ugs.);Balltreter (derb);Fußballer;Fußballspieler
-Hinterziehung;Unterschleif (geh., regional, veraltend);Unterschlagung;Veruntreuung;Defraudation (geh.)
-Kopfgeburt;Luftschloss (ugs.);Produkt der Fantasie;Ausgeburt einer kranken Fantasie (derb, stark abwertend);Wolkenkuckucksheim (ugs.);Flausen im Kopf;Phantasterei;Ausgeburt der Fantasie;Phantasiegebilde;Ausgeburt der Phantasie;Fantasieprodukt;Spinnerei (ugs.);Hirngespinst (ugs.);Wolkenschloss (ugs., fig.);Phantasieprodukt;Ausgeburt einer kranken Phantasie (derb, stark abwertend);Luftnummer;Fantasiegebilde;Fantasterei
-Schutzstaat;Protektorat
-Stellungnahme;Resonanz;Feedback (engl.);Rückmeldung;Kommentar;Anregung;Input von außen
-Funkeln;Brillanz;Leuchten;Strahlung;Glanz
-Nuklearwaffe;Atomwaffe;Kernwaffe
-Konfiguration;Anpassung;Einstellung
-9,81 N/kg;Erdanziehung;Ortsfaktor;Erdgravitation;Erdanziehungskraft
-eulersche Zahl;2,718281828459...;e;Basis des natürlichen Logarithmus;eulersche Konstante
-Wirbelsäule;Rückgrat
-Winterzeit (ugs.);Normalzeit
-Jogginghose;Jersey-Hose
-Jargon (Hauptform);Szenesprache (ugs.);Soziolekt (fachspr.);Szenejargon (ugs.);Sondersprache (fachspr.);Kauderwelsch;Szene-Sprech (ugs.);Gruppensprache (fachspr.);Sprech (der ...) (ugs.)
-Kost;Proviant;Verköstigung;Verpflegung;Essen
-konzentriert;unabgelenkt;bei der Sache (ugs.);dabei (ugs.);aufmerksam
-quälen;peinigen
-Hermaphrodismus;Doppelgeschlechtigkeit;Zwittrigkeit;Hermaphroditismus;Androgynie;Zwitterbildung;Androgynismus;Zwittertum;Intersexualität
-Idiolekt;Individualsprachgebrauch
-unfähig, eine Schwangerschaft auszutragen;infertil (fachspr.)
-unaufrichtig;scheinheilig (Hauptform);link (ugs.);heuchlerisch;hypokritisch;pharisäerhaft;geheuchelt;bigott (geh.);falsch (ugs.);schlangenzüngig;gleisnerisch (geh., veraltet);scheißfreundlich (derb);hinterfotzig (derb, bayr.);hintenrum (ugs.);doppelzüngig;verlogen
-möglich sein;zur Debatte stehen;zu machen sein (ugs.);gehen (ugs.);in Frage kommen;(sich) machen lassen (ugs.);drin sein (ugs.);zur Diskussion stehen;infrage kommen;in Betracht kommen;machbar sein
-Schulanfänger;Erstklässler;i-Dötzchen (ugs.);i-Männchen (ugs.);Abc-Schütze (ugs., veraltend);Taferlklassler (ugs., österr.);i-Dotz (ugs.)
-Frauenfußball;Damenfußball (ugs.);Mädchenfußball
-cremefarbig;creme;cremefarben
-Gemeine;Minuskel (fachspr.);Kleinbuchstabe
-Kontraktion;Zusammenziehung;Astringenz;Verkürzung
-Saxophon;Saxofon
-Zungenschlag (ugs.);Aussprache;Tonfall;Akzent
-Sabber (ugs.);Speichel;Saliva;Spucke (ugs.)
-Formgebung;Manifestation;Ausformung;Gestaltung;Ausprägung
-Andragogik (fachspr.);Erwachsenenbildung
-Automat;Gerät;Anlage;Maschine;Aggregat;Apparatur;Apparat
-Fakten;Wissen;Datenansammlung;Daten;Information
-Mikroorganismus;Kleinstlebewesen;Mikrobe
-Schwefelwasserstoff;Hydrogensulfid;H₂S (Summenformel, chemisch);Wasserstoffsulfid;H2S
-thermonukleare Fusion (fachspr., technisch);Kernfusion;Kernverschmelzung
-Preis;Kosten (Pluraletantum)
-Jugendherberge (Hauptform);Jugendgästehaus;JuHe (ugs.);JH (Abkürzung)
-Visiergraupen (veraltet);Nadelzinnerz (veraltet);Kassiterit;Cassiterit;Nadelzinn (veraltet);Holzzinn (veraltet);Zinnstein (veraltet)
-Luftkissenboot;Hovercraft;Luftkissenfahrzeug
-Satellit;künstlicher Trabant;Trabant
-Fernrohr;Teleskop
-Duroplastbomber (ugs., fig., scherzhaft-ironisch);Mercedes-Krenz (ugs., scherzhaft-ironisch);Plastebomber (ugs., fig., scherzhaft-ironisch);Trabi (ugs.);Fluchtkoffer (ugs., fig., scherzhaft-ironisch);Trabbi (ugs.);Pappe (ugs., scherzhaft);Plastikbomber (ugs., fig., scherzhaft-ironisch);Zwickauer Gehhilfe (ugs., sarkastisch);Gehhilfe (ugs., Jargon);Rennpappe (ugs., scherzhaft-ironisch);Trabant (Hauptform)
-Himmelskörper;Gestirn
-kalter Himmelskörper;Wanderstern (veraltet);Wandelstern (veraltet);Planet (Hauptform)
-kosmischer Nachbar (ugs.);Luna (fachspr.);Erdmond;Erdtrabant;Mond;Erdbegleiter
-Programmierfehler;Software-Anomalie;Softwarefehler;Bug (engl.);Programmfehler;Glitch (ugs., Jargon, engl.)
-Rundfunkstation;Radiosender;Sender (ugs.)
-Ausführung;Vollziehung;Exekution;Vollstreckung
-feuerspeiender Berg (ugs.);Vulkan;Feuer speiender Berg (ugs.)
-Eintrittskarte;Billett (schweiz.);Voucher;Fahrkarte;Fahrschein;Ticket;Karte;Fahrausweis
-Krebs;bösartige Tumorerkrankung;Krebsleiden;Krebserkrankung
-AIDS (Abkürzung, engl.);erworbenes Immunschwäche-Syndrom;Acquired Immune Deficiency Syndrome (engl.);HIV-Krankheit
-Deutsches Jugendherbergswerk;DJH (Abkürzung)
-Drum;Trommel
-Piano (geh., Jargon);Pianoforte;Klimperkasten (ugs.);Fortepiano;Pianino;Klavier (ugs., Hauptform)
-Pfeife;Flöte
-Schokolade;Kakao (fachspr.);Schoko (ugs.)
-Naturereignis;Naturphänomen;Naturerscheinung
-Erdbeben;Beben;Erdstoß
-Vulkanausbruch;Eruption
-Wohnanhänger;Caravan;Wohnwagen
-unterwegs;auf Schusters Rappen (ugs.);auf'm Ritt (ugs., fig., regional, selten);op Jöck (ugs., kölsch);auf dem Weg (zu);auf Achse (ugs.);auf der Durchreise;auf Wanderschaft
-hinter etwas her (sein) wie der Teufel hinter der armen Seele (sprichwörtlich);begehren nach (geh.);begehrlich nach;(einen) Gieper (haben) auf (ugs.);Lust haben (auf);(inständig) verlangen nach;(sich die) Finger lecken nach (ugs., fig.);hungern nach (fig.);erpicht auf (geh., veraltend);besessen von;sehnlichst vermissen;unbedingt haben wollen;(einen) Jieper haben (auf) (ugs., norddeutsch);vor Verlangen (nach etwas) vergehen;gieren (nach);(jemandem) (das) Wasser im Mund zusammenlaufen (beim Gedanken an) (ugs.);aus sein auf;verrückt nach;verrückt auf (etwas) (ugs.);fiebern nach;vergehen nach;scharf auf (etwas) (ugs.);(sehr) verlangen nach (Hauptform);ersehnen;(sich) sehnen nach;herbeiwünschen;(sehr) hinter (etwas) her sein (ugs.);verschmachten (nach) (geh.);versessen auf;jiepern nach (ugs., regional);(jemanden) gelüsten nach (geh.);spitz sein auf (ugs.);herbeisehnen;(sich) verzehren nach (geh.);dürsten nach (geh., fig., poetisch);(sich) alle zehn Finger lecken (nach) (ugs., fig.);geil auf (etwas) (ugs.);(ganz) wild auf (etwas) (ugs.);begehren;lange Zähne kriegen (ugs., selten);begierig auf;kaum erwarten können;spitzen auf;sehnlichst begehren;giepern nach (ugs., regional);vor Lust (auf etwas) vergehen;nicht warten können auf;(jemandem) steht der Sinn nach;lechzen (nach) (geh.);süchtig nach;brennen auf;heiß auf (etwas) (ugs.);schmachten nach;...närrisch
-Käfig;Bauer
-inapparent (fachspr.);ohne Symptome;nicht wahrnehmbar
-Sport;Sportart (Hauptform);Disziplin
-Fußball;Leder (ugs.);Pille (ugs., fig.)
-Stampfer;Stößel;Pistill;Muddler (engl.)
-Sprache (Hauptform);mündliches Kommunikationsmittel;schriftliches Kommunikationsmittel;verbales Kommunikationsmittel;Verständigungsmittel
-Multifunktionsstift;Multipen;Mehrsystemschreiber
-Swimming-Pool;Pool (ugs.);Swimmingpool;Schwimmbecken
-Pool;Poolbillard
-Jahresweiser (veraltend);Kalender;Almanach;Kalendarium;Jahrweiser (veraltend)
-Fötus;ungeborenes Leben;Leibesfrucht;Nasciturus (fachspr., juristisch);(ein) Ungeborenes;Embryo;Fetus
-fortbilden;weiterbilden;qualifizieren
-ansatzweise;nur teilweise;unter Vorbehalt;bedingt;eingeschränkt
-in eigener Sache;für sich selbst;intern;pro domo (lat.);für sich
-gewahr werden (geh.);zur Kenntnis nehmen;erkennen;ankommen (bei) (ugs., fig.);perzipieren (geh.);merken;wahrnehmen;realisieren;mitbekommen (ugs.);registrieren;bemerken
-gesellschaftskritisch;sozialkritisch
-Alster;Radler;Alsterwasser;Bier-Limonade-Mix
-Fleischkäse (Hauptform);Fleischlaib;Leberkäs (schwäbisch);Leberkäse;Leberkes (bairisch);Leberkas (bairisch)
-(ein) Geschäft;(ein) Handel;(ein) Deal (ugs., engl.)
-Landsknechtstrommel;Rührtrommel
-Marschtrommel;Rührtrommel;kleine Trommel;Snare drum (engl.);Schnarrtrommel;Snare (engl.)
-Hi-Hat;Charleston-Maschine
-Drumset;Perkussion;Schlagzeug
-Becken;Tamtam
-Neuhebräisch;Iwrith;Iwrit
-PowerStor (Handelsname);PseudoCap (Handelsname);DynaCap (Handelsname);Ultracap (Handelsname);Goldcap (Handelsname);SuperCap (Handelsname);Faradcap (Handelsname);Superkondensator;Ultrakondensator;BestCap (Handelsname);BoostCap (Handelsname)
-Doppik;kaufmännische Buchführung;doppelte Buchführung
-Kameralbuchhaltung;Kameralistik;kameralistische Buchführung
-Presseerklärung;Communiqué (schweiz.);Kommuniqué;Aussendung (österr.);Pressemeldung;Pressetext (ugs.);Medienmitteilung (schweiz.);Pressemitteilung (Hauptform);Presseaussendung;Verlautbarung;Presseinformation;Stellungnahme
-Sammlung;Archiv
-Kampfbahn;Sportstätte;Wettkampfstätte;Stadion;Arena;Sportplatz;Sportforum
-Befriedigung;Kommen (ugs.);Klimax;(sexueller) Höhepunkt;Orgasmus
-Anziehungskraft;Attraktion;Ausstrahlung;Glanz (fig.);Attraktivität;Zugkraft;Faszination
-musizieren;Musik machen;spielen
-Röstkastanie;Esskastanie;Edelkastanie;Marone
-Mietrammler (derb);Frauenverwöhner;Puppenjunge (ugs., veraltet);Beischläfer;Callboy (engl.);Stricher (ugs.);Begatter;Prostituierter;Strichjunge
-Sparte;Teilgebiet;Arbeitsgebiet;Segment;Teilbereich;Feld;Bereich
-Landesfürst (ugs.);Ministerpräsident;Länderchef (ugs.);Gubernator (historisch);Provinzfürst (derb, abwertend);Landesvater (ugs.);Landeshauptmann (österr.);Gouverneur
-Kanzlerin (weibl.);Kanzler (männl.);Bundeskanzler (männl.);Bundeskanzlerin (weibl.)
-letztes Mittel;Ultima Ratio (geh., lat.)
-Kraftfahrzeugführer;Kraftfahrer;Lenker (ugs.);Kfz-Führer
-(eine / diese) bittere Pille schlucken (müssen) (ugs., fig.);notgedrungen;gezwungenermaßen;wohl oder übel;(auch) gegen seinen Willen (männl.);schweren Herzens (fig.);in den sauren Apfel beißen (müssen und) (ugs., fig.);zähneknirschend (ugs., fig.);zwangsläufig;zwangsweise;unfreiwillig;ob jemand will oder nicht;der Not gehorchend, nicht dem eigenen Triebe (geflügeltes Wort) (geh.);nolens volens (geh., lat.);(auch) gegen ihren Willen (weibl.);widerwillig;wider Willen;(eine / diese) Kröte schlucken (müssen) (ugs., fig.)
-Büstenhalter;Brustgeschirr (ugs., scherzhaft);BH (ugs.)
-Allesfresser;Omnivore (fachspr.);Pantophage (fachspr.)
-Blaualge (veraltet);Cyanobakterium
-Computer-Nutzer;User (ugs.);Anwender;Nutzer;Benutzer;Benützer (schweiz., österr.)
-so so (ugs.);nicht besonders gut;ich kann nicht besser klagen (ugs., scherzhaft-ironisch);na ja okay (ugs.);beschissen ist noch gestrunzt (ugs., Spruch, regional, scherzhaft-ironisch);Alles Scheiße, deine Elli. (ugs., Spruch, variabel);ging so (ugs.);geht so (ugs.)
-eingeplant;intendiert;vorgesehen;beabsichtigt;angelegt;geplant
-Kartenkunde;Kartographie (fachspr.);Kartografie (fachspr.)
-Kantersieg;müheloser Sieg;klarer Sieg
-Beifall ausdrückend;bestätigend;wissend;billigend;gutheißend;einverständig;beifällig;verständnisvoll;zunickend;Zustimmung ausdrückend;zustimmend;anerkennend
-Tierpräparator;Taxidermist (fachspr.)
-Wissenschaft der Hautkrankheiten;Dermatologie (fachspr.)
-überheblich (ugs.);gestresst;überspannt;hypertroph
-probierend;probehalber;probeweise (Hauptform);versuchsweise (Hauptform);auf Probe;tentativ;testweise
-Gemeindeland;Allgemeingut;Allmende
-Peckerl (ugs., österr.);Tatuierung;Tatauierung (fachspr.);Tätowierung;Tattoo
-Feber (schweiz., schwäbisch, tirolerisch, österr.);Hornung (elsäss., sonst veraltet);Februar (Hauptform);zweiter Monat des Jahres
-abbeuteln (österr.);abschütteln;herunterschütteln
-Juniper (geh., selten);Wacholder (Hauptform);Quackelbusch;Kranewitt (ugs., süddt.);Krammet;Juniperus (fachspr., botanisch);Machandel (ugs., niederdeutsch)
-Malter (österr.);Mörtel;Speis (regional)
-Füchsin;Fähe (fachspr.)
-Tischler;Holzmechaniker (Industrie);Holzwurm (ugs., scherzhaft-ironisch);Schreiner
-Seebrücke;Hafendamm;Landungsbrücke
-Jukebox;Musikbox
-Autodroschke (historisch);Droschke (historisch);Taxe (ugs.);Kraftdroschke (fachspr., veraltet);Taxi (Hauptform);Motordroschke (historisch)
-Auftausalz (fachspr.);Streusalz;Tausalz
-Astigmatismus (fachspr.);Stabsichtigkeit;Hornhautverkrümmung
-Presbyopie (fachspr., griechisch);Altersfehlsichtigkeit;Alterssichtigkeit (ugs.)
-Hypermetropie (fachspr.);Weitsichtigkeit (ugs.);Hyperopie (fachspr.);Übersichtigkeit
-Erinnerungsvermögen;Mnestik;Gedächtnis
-km/h;Kilometer pro Stunde;Sachen (ugs.);Stundenkilometer (ugs., fälschlich)
-Tetragon (fachspr.);Viereck;Geviert (veraltet)
-Geiger-Müller-Indikator;Geigerzähler;Geiger-Müller-Zählrohr;Auslösezählrohr
-ihn reinstecken (ugs.);penetrieren;(mit dem Penis) eindringen (in)
-Prinz;Infant;Kronprinz;Thronfolger
-leistungsfähig;potent;fähig
-Einreibung;Friktion (fachspr.)
-Friktion;Widerstand
-Agonie (fachspr., veraltet);Terminalphase (fachspr.);Todeskampf
-Blume (fachspr.);Hasenschwanz
-schwere Seuche;Pestilenz
-alkoholfreies Getränk;Erfrischungsgetränk;Softdrink
-Kostbarkeit;Kronjuwel(en) (fig.);Vermögen;Schatz;Schmuckstück;Bijou (geh., fig., franz., schweiz.);Tafelsilber (ugs., fig.);wertvoll(st)er Besitz;Hort;Kleinod (geh.);Juwel
-Wunschbild;falsche Hoffnung;schöner Traum (ugs.);Blütentraum (geh., poetisch, sehr selten);Seifenblase (fig.);Wunschdenken;Wunschvorstellung;Wunschtraum;frommer Wunsch;Da ist/war der Wunsch der Vater des Gedankens.;Fiktion;trügerische Hoffnung;Illusion
-Honigbiene;Biene;Imme (veraltet)
-(jemandem) entfallen (sein) (geh.);(sich) nicht erinnern (an);verbummeln (ugs.);vergessen;aus den Augen verlieren (ugs.);(jemandem) nicht erinnerlich (sein) (geh.);nicht denken an;(sich einer Sache) nicht entsinnen können (geh.);verschwitzen (ugs.)
-Laserstrahl;Laser (Abkürzung);kohärentes Licht;Laserlicht
-ausrollen (neuer Systeme);draufbügeln (ugs.);einspielen;(Software) installieren;bespielen (mit);aufsetzen;aufspielen
-Redensart;phraseologische Wortverbindung (fachspr.);feste Fügung (fachspr.);stehende Wendung (geh.);Idiom (geh.);(nur so ein) Spruch (ugs.);Redewendung;idiomatische Wendung (fachspr.);Redeweise;Phrasem (fachspr.);Phraseologismus (fachspr.);idiomatische Redewendung (fachspr.)
-Bleibe;Unterkunft;Herberge
-Hagiolatrie;Heiligenverehrung
-Kopfstimme;Falsett
-Agraffe;Schmuckspange;Spange (Hauptform);Fürspann (fachspr., historisch);Fibel (fachspr., historisch);Schließe
-Schmand;Matsch;Gatsch (ugs., österr.);Schmant;Schmodder (ugs.);Batz (ugs., bayr., österr.);Schlamm
-unangekündigte Klassenarbeit;Kurztest;Stegreifaufgabe;Extemporale;Ex (ugs.)
-Austrocknung;Exsikkation
-Rudiment;verkümmertes Organ
-unvollständig erhaltene Statue;unvollendetes Werk;Bruchstück;Torso
-Infrastruktur;Gesamtheit militärischer Anlagen
-Intoleranz (fachspr.);Unverträglichkeit
-Straftat verbergen;hehlen
-Teufelsbeschwörer;Teufelsaustreiber;Geisterbeschwörer;Exorzist
-Potpourri (franz.);Verschiedenes;Vermischtes;Diverses;Varia;Miszellen (geh.);Allerlei;Miszellaneen (geh.)
-Potpourri (franz.);Mix;Zusammenstellung bekannter Melodien
-(der) Nix;Wassermann;Wassergeist;Nöck (selten);germanischer Wassergeist
-Isnik;Nizäa
-N. J.;New Jersey
-Leidzirkular (schweiz.);Totenzettel;Partezettel (österr.);Parte (österr.)
-Parte (regional);Mietpartei
-Part;Parte
-Andachtsbild;geweihtes Tafelbild;Kultbild;Ikone;Ikon
-Ikon;besondere Werte verkörpernde Person;Ikone
-Ikonograf;Ikonograph
-Ikonografie;Ikonographie
-ikonographisch;ikonografisch
-Fotosphäre;Photosphäre
-Fotobiologie;Photobiologie
-fotobiologisch;photobiologisch
-Photochemie;Fotochemie;Fotografische Chemie
-fotochrom;phototrop;photochrom
-Fotoeffekt;Photoeffekt
-Fotoelektrizität;Photoeffekt;lichtelektrischer Effekt;photoelektrischer Effekt;Photoelektrizität
-Fotoelektron;durch Licht herausgelöstes Elektron;Photoelektron
-Fotoelement;Photoelement
-bildwirksam;fotogen;photogen
-Fotogenität;Bildwirksamkeit;Photogenität
-Photogramm;Messbild;Fotogramm
-Fotogrammetrie;Photogrammetrie;Bildmessung
-Photogravüre;Heliogravüre
-Fotolyse;Photolyse
-Fotom;nicht wahrnehmbare Farberscheinung;Photom
-photomechanisch;fotomechanisch
-Fotometer;Photometer
-Fotonik;Photonik
-fotophil;lichtliebend;Licht bevorzugend;photophil
-lichtempfindlich;photophob (fachspr.);lichtscheu
-photophob (fachspr.);Licht meidend
-Bewegungsreaktion;Taxis (fachspr.)
-gehgestört;propulsiv (fachspr.)
-pränumerieren;vorausbezahlen
-(sich) zur Nachtruhe zurückziehen;in die Heia gehen (Kindersprache);(sich) hinlegen (ugs.);(sich) betten;pofen gehen;(sich) zum Schlafen niederlassen;(sich) in Morpheus' Arme begeben (geh.);(sich) zur (nächtlichen) Ruhe begeben;(sich) hinhauen (ugs., salopp);in die Kiste steigen (ugs.);in die Pofe gehen (ugs.);(sich) ins Schlafzimmer zurückziehen;ins Bett gehen;schlafen gehen (Hauptform);in Morpheus' Arme sinken (geh., fig.);heia machen (Babysprache);(sein) Haupt betten;(sich) zum Schlafen zurückziehen;zu Bett gehen;ins Bett kommen;(sich) schlafen legen;(sich) aufs Ohr hauen (ugs., Redensart);(sich) aufs Ohr legen (ugs., Redensart)
-Leuchtstoffröhre (Hauptform);Neonröhre (ugs., Hauptform);Gasentladungsröhre;Leuchtröhre (ugs.)
-Farbenblindheit (ugs.);Farbuntüchtigkeit;Farbenfehlsichtigkeit;Farbsehschwäche;Achromatopsie;Farbfehlsichtigkeit
-Gastroskopie (fachspr.);Ösophago-Gastro-Duodenoskopie (fachspr.);Magenspiegelung (ugs.)
-sequenziell;sich anschließend;(zeitlich) folgend;darauf folgend;konsekutiv (fachspr.)
-rein geistig-seelisch;(sexuell) enthaltsam;platonisch;keusch;unkörperlich;züchtig
-Dementierung;Negation;Verneinung
-Flugzeugführer;Flugkapitän;Luftfahrzeugführer;Flieger (ugs.);Pilot;Verkehrsflugzeugführer
-Neurasthenie (fachspr.);Nervenschwäche
-Chauvi (ugs.);Frauen verachtender Mann;Chauvinist;Frauenverächter
-fein;unterschwellig;nur mit Feinsinn wahrnehmbar;sublim;subtil
-untergeordnet;inferior
-lernbereit;lernfähig
-untergeordnete Stellung;Inferiorität
-Inferiorität;Unterlegenheit
-Minderwertigkeit;Inferiorität
-Glans (fachspr.);vorderer Teil der Klitoris
-Slowmotion;SloMo (fachspr.);Slow Motion;Zeitlupe
-Umkleide (ugs.);Umkleideraum;Garderobe (schweiz., österr.);Ankleideraum;Ankleidezimmer
-Retirade;Rückzug
-Café Achteck (ugs., berlinerisch, scherzhaft);Herrentoilette (Hauptform);Männertoilette;Pissoir (franz.)
-Sichelmesser;Hippe
-Hippe (regional);Fladenkuchen
-Furie;Kratzbürste (ugs.);zänkisches Weib;Krähe (ugs.);Gewitterziege (ugs.);Meckerziege (ugs.);Hausdrachen (ugs.);Giftnudel (ugs.);boshaftes Weibsstück (ugs.);Zimtzicke (ugs., ruhrdt.);Xanthippe (geh.);Meckertante (ugs.);Schlange (ugs.);Hippe (ugs.);Zicke;feuerspeiender Drache (ugs., fig.);Megäre (geh., bildungssprachlich);Zippe (ugs.);Besen (ugs.);Drachen (ugs.)
-Entführter;Geisel;Gekidnappter
-abtreten (fig.);seinen Geist aushauchen (geh.);den Geist aufgeben (ugs.);aus dem Leben scheiden (fig.);(jemandes) letztes Stündlein hat geschlagen;seinen Geist aufgeben (ugs.);dahingerafft werden (von) (ugs.);(jemandem) schlägt die Stunde;gehen (verhüllend);(die) Augen für immer schließen (verhüllend);die Hufe hochreißen (derb, fig.);erlöschen;wegsterben;(seinen) letzten Atemzug tun;versterben;seinen letzten Gang gehen (fig.);davongehen (fig.);heimgehen (fig., verhüllend);dahingehen (geh., verhüllend);sterben (Hauptform);dahinscheiden (geh., verhüllend);dran glauben (müssen) (ugs.);vor seinen Richter treten (geh., fig., religiös);(seine) letzte Fahrt antreten (ugs., fig.);in die ewigen Jagdgründe eingehen;(den) Arsch zukneifen (vulg., fig.);verdämmern;von uns gehen (fig.);ableben;sanft entschlafen (fig., verhüllend);(die) Reihen lichten sich (fig.);in die Ewigkeit abberufen werden (geh., fig.);uns verlassen (verhüllend);(den) Löffel abgeben (ugs., fig., salopp);fallen (militärisch);ins Gras beißen (ugs., fig.);den Weg allen Fleisches gehen (geh.);das Zeitliche segnen;von der Bühne (des Lebens) abtreten (fig.);vor seinen Schöpfer treten (geh., fig.);verscheiden;ins Grab sinken (geh., fig.);in die Grube gehen (ugs.);sein Leben aushauchen (geh.);in die Grube fahren (ugs., fig.);entschlafen (fig., verhüllend)
-Reizreaktion;Reflex;Reflexreaktion
-Zappeligkeit (ugs.);Hibbeligkeit (ugs.);Ungeduld;motorische Unruhe (fachspr.)
-Sparsamkeit (fig.);Nüchternheit;Funktionalität;Simplizität;Schmucklosigkeit;Einfachheit;Schnörkellosigkeit;Kargheit (geh.);Bescheidenheit;Schlichtheit
-Unaufrichtigkeit;Verlogenheit;Unehrlichkeit;Falschheit
-Musikus (scherzh. altertümelnd);Spielmann (veraltet);Musiker (Hauptform);Musikant
-Alumnus;Hochschulabsolvent;Absolvent einer Hochschule;Akademiker
-Feldjäger;Militärpolizist
-Maat;Fahnenjunker;Adelborst (ugs.);Corporal;Seekadett;Unteroffizier
-Tonsetzer;Komponist
-Bandleader;Hofkapellmeister;Generalmusikdirektor;Orchesterchef;Kapellmeister;Chefdirigent;künstlerischer Leiter;Gastdirigent;Orchesterleiter;Dirigent;Chorleiter
-Vier-Sterne-General (ugs.);General
-Sprechstimme;Tonfall;(menschliche) Stimme (Hauptform);Singstimme
-Yo-Yo;Jo-Jo
-Fabelwesen;Phantasiegeschöpf;übernatürliches Wesen;Fantasiegeschöpf
-Funzel (ugs.);Kerze
-chemischer Stoff;Chemikalie
-Schutzpatron;Patron;Schutzheiliger;Heiliger;Schutzengel
-Organ einer Pflanze;Teil einer Pflanze;Pflanzenorgan;Pflanzenteil
-blühender Pflanzenteil;Blütenkelch;Blüte (Hauptform);Vermehrungsorgan (einer Pflanze) (fachspr.)
-Mixgetränk;Cocktail;Mischgetränk;Longdrink
-(seinen) Senf dazugeben (ugs., fig.);einen Kommentar abgeben;kommentieren;orchestrieren (geh., fig.);(eine) Anmerkung machen;Stellung nehmen (zu)
-brechreizhemmend;antiemetisch (fachspr.)
-Steuerpflichtiger;Steuerzahler
-Roter (ugs.);Rotwein (Hauptform)
-Weißwein (Hauptform);Weißer (ugs.)
-Interpunktionszeichen;Satzzeichen
-Beistrich (österr.);Komma
-Molkereiprodukt;Milcherzeugnis;Milchprodukt
-Kleidungsstück;Plörren (ugs., rheinisch, ruhrdt.);Anziehsache(n) (ugs.);Rapaiken (ugs., schlesisch, veraltet);Klamotte(n) (leicht salopp) (ugs.);Plünnen (ugs., rheinisch)
-schöne Wissenschaften (ugs.);Geisteswissenschaft
-(die) OP (Abkürzung);Eingriff;Operation (Hauptform);medizinischer Eingriff
-Sandale(n);Jesuslatsche(n) (ugs., abwertend)
-Tinea pedis (fachspr.);Fußpilz
-Handelsmann (geh., veraltet);Einzelhändler;Händler;Ladenbesitzer (ugs.);Geschäftsmann;Handeltreibender (geh., veraltet);Kaufmann
-Zelle (lat.);Kytos (griechisch);Gewebskammer;Gewebezelle
-Lobe (alemannisch);Kuh;Milchkuh;Mutterkuh
-Jungrind;Kalb
-Kutschwagen;Pferdekutsche;Kutsche
-Erbkrankheit;angeborener genetischer Defekt
-Ameise;Emse (poetisch, veraltet)
-Schmetterling;Falter
-Schillebold (ugs.);Schillerbold (ugs.);Schleifer (veraltet);Augenstecher (veraltet);Wasserjungfer (veraltet);Odonata (fachspr.);Libelle
-medizinische Untersuchung;ärztliche Untersuchung;Untersuchung;Screening (engl.)
-Knochen (Hauptform);Bein;Gebein
-Würze (ugs.);Zutat (ugs.);Spezerei (veraltet);Würzstoff;Gewürz
-architektonischer Stil;Bauweise
-Legierung;Mischung (von Metallen)
-Fe (Elementsymbol);Ferrum;Eisen
-Platin;Pt (Elementsymbol)
-Stahl;Eisenlegierung
-Gold (Hauptform);gelbes Metall (ugs.);Au (Elementsymbol);Aurum (lat.)
-Wecken (regional);Brot;Brotlaib
-Torte;Kuchen
-Ressortleiter (ugs.);Regierungsmitglied;Minister;Ressortchef (ugs.)
-Möbelstück;Möbel;(das) gute Stück (ugs., ironisierend)
-Ausarbeitung;Abhandlung;Werk;Traktat;Arbeit;Elaborat (geh., lat.);wissenschaftliche Arbeit;akademische Arbeit
-Kinofilm;Spielfilm (Hauptform);Kinoproduktion (Film)
-Beuteltier;Marsupialier;Beutelsäuger;Metatheria (fachspr., Plural, zoologisch)
-Macropodidae (fachspr., Plural, zoologisch);Känguru
-Koala;Koalabär;Beutelbär
-Künstler;...macher;Könner;Schöpfer (von Kunst);Kunstschaffender
-Maler;Zeichner
-Anstreicher;Weißer (regional);Maler und Lackierer (Amtsdeutsch);Maler;Tüncher (regional);Weißbinder;Weißeler (regional);Pinselquäler (derb, abwertend)
-azyklischer, zusammenhängender Graph;Baum
-Wink;Zeichen;Geste
-danke sehr;wir haben zu danken;vergelt's Gott (ugs.);ich habe zu danken;merci (ugs.);danke vielmals;besten Dank (ugs.);Firma dankt! (ugs., Spruch);heißen Dank (ugs.);vielen vielen Dank!;man dankt (ugs.);danke schön;danke dir!;Gott vergelt's (ugs.);vielen lieben Dank;verbindlichsten Dank (ugs.);lieben Dank (ugs.);(ganz) herzlichen Dank (ugs.);danke (Hauptform);vielen Dank;danke Ihnen!
-Mutterschwein;Sau
-Keiler;männliches Wildschwein;Eber
-Frischling;Schweinchen;Ferkel
-Hirschlederne;Lederhose
-Wohnhalle;Saal
-Abtei;Propstei;Konvent;Kloster;Probstei (veraltet);Stift
-Saft;Juice (österr.);Most (ugs., regional);Fruchtsaft;Jus (franz., schweiz.)
-Weiße;Weizen (ugs.);Weizenbier;Weißbier (bayr., österr.)
-aufgeben;(es) aufstecken;den Kopf hängen lassen (ugs., fig.);klein beigeben;schwarzsehen (ugs.);verzagen (geh.);den Mut sinken lassen;(sich) aufgeben;verzweifeln;(die) Hoffnung verlieren;resignieren;hoffnungslos sein;den Mut verlieren;nicht mehr an sich glauben;(sich) verlorengeben;den Schwanz einziehen (ugs., fig.)
-Rhinozeros;Rhinoceros;Nashorn
-geometrische Figur;Figur
-Oberhirte;Ordinarius (mittellateinisch);Bischof
-Bewerb (österr.);Wettbewerb
-Premier (ugs.);Premierminister;Ministerpräsident
-lauschen;horchen;hören
-Stunk machen (ugs.);Streit suchen;Unruhe (in etwas) bringen;Unfrieden stiften;stänkern (ugs.);Unruhe stiften
-umwenden;wenden;drehen;umdrehen;invertieren;auf die andere Seite legen;umkehren;umstülpen
-Berufstitel;Amtstitel;Anrede;Titel
-Literaturform;Gattung (Literatur);Genre (franz.)
-Pils (Hauptform);Pilsener Bier;Pilsener;Pilsner;Pilsner Bier;Bier nach Pilsener Brauart;Bier nach Pilsner Brauart;Spezialbier (schweiz.)
-Botenstoff;Hormon
-Eheleute;Ehepaar
-versorgen (schweiz., österr.);einsortieren;verräumen (Jargon);einräumen;wegräumen;unterbringen;wegpacken;verstauen
-Fadaise (geh., franz.);(eine) Narrheit;(ein) Wahnwitz;(eine) Narretei (geh., veraltet);(ein) Irrsinn;(eine) Verdrehtheit;(ein) Wahnsinn;Insania (geh.);(eine) Verrücktheit;(eine) Tollheit;(eine) Torheit
-organisieren (ugs.);heranschaffen;mobilisieren;besorgen;herbeischaffen;holen;dafür sorgen, dass etwas da ist (ugs.);zusammenkriegen (ugs.);zusammenbekommen;sorgen (für);(sich) kümmern (um);heranholen
-bringen (ugs.);wissen zu (ältere Sprache);(es) verstehen zu;schaffen;können
-Faulpelz (ugs., Hauptform);Faultier (ugs., scherzhaft);jemand mit der Einstellung "kommste heut nicht, kommste morgen";fauler Sack (ugs., variabel);fauler Hund (ugs.)
-in Strömen regnen (es);wie aus Eimern gießen (es) (ugs.);(heftig) regnen (es);schiffen (es) (ugs.);schütten (es) (ugs.);ordentlich was runterkommen (es) (ugs.);pladdern (es) (ugs., norddeutsch);wie aus Kübeln schütten (es) (ugs.);plästern (es) (ugs., ruhrdt.);wie aus Eimern schütten (es) (ugs.);Bindfäden regnen (es) (ugs.);gießen (es) (ugs.);wie aus Kübeln gießen (es) (ugs.)
-(großes) Trara (ugs.);Riesenbohei (ugs.);Getrommel (ugs.);Getue;(großes) Tamtam;Aufgeregtheit (geh.);Gewese;Gesums;Aufsehen;Federlesen(s);Hype;Aufruhr (fig.);Rummel (ugs.);Sturm im Wasserglas (ugs.);Tebs (ugs., sehr selten);Furore (machen) (geh.);Theaterdonner;Schaumschlägerei;Buhei (ugs.);(einen) ganz großen Bahnhof (machen) (fig.);(großes) Getöse;Hysterie (fig.);Gehabe (ugs.);Aufregung;Theater (ugs.);viel Lärm um nichts;Bohei (ugs.);Aufhebens;(übertrieben viel) Tamtam (um etwas) (ugs., Hauptform, salopp);Aufriss (ugs.);Geschiss (derb);Gemach(e) (ugs.);Wirbel
-Gehabe;Geziere;Künstelei (geh.);Getue;Angabe;Ziererei;Gekünsteltheit (geh.);Allüren;Faxen (ugs.);Gedöns (ugs.);Affigkeit (ugs.);Affektiertheit (geh.)
-Punk;Punker
-manschen (ugs.);schmanten (ugs.);schmieren
-Jupe (schweiz.);Rock
-Rockmusik;Rock
-Ritual;Zeremonie
-Phon;Fon
-Löhnung;Bezahlung;Lohnzahlung;Glattstellung;Auszahlung;Zahlung;Entlohnung;Begleichung
-Hai;Haifisch
-(etwas) sausenlassen;(etwas) ausfallen lassen;(unentschuldigt) abwesend;nicht kommen (ugs.);vermisst werden (fig.);(einem Anlass) fernbleiben;nicht da sein (ugs.);schwänzen (ugs.);nicht teilnehmen (an / bei);(jemand) wurde nicht gesehen (ugs.);nicht erscheinen (Hauptform);(unentschuldigt) fehlen;krank feiern (ugs.);(etwas) sausen lassen;(sich) einen schönen Tag machen (ugs., fig.);blaumachen (ugs.);(von jemandem ist) nichts zu sehen (ugs.);nicht hingehen (ugs., Hauptform);(sich) nen Bunten machen (ugs.);wegbleiben;durch Abwesenheit glänzen (geh., ironisch);(sich) drücken (ugs.)
-tonlos;still;stumm;lautlos
-stolzieren;schreiten;schaulaufen;stolzieren wie ein Paradepferd (ugs.);(herum)stolzieren wie ein Gockel (ugs.);paradieren;(herum)stolzieren wie ein Pfau (ugs.)
-Magie;Aura;Zauber
-Ende der Kampfhandlungen;Kriegsende
-Vitamin A;Retinol
-nützliche Beziehungen;gute Beziehungen;Connections (ugs.);Vitamin B (ugs.);alte Seilschaft(en);meine Leute (ugs.)
-Ascorbinsäure (fachspr., Hauptform);L-Ascorbinsäure (fachspr.);Hexuronsäure (veraltet);E 300 (fachspr., E-Nummer);Vitamin C (ugs., Hauptform)
-Vitamin B1 (Hauptform);Antiberiberifaktor;Aneurin;antineuritisches Vitamin;Thiamin (fachspr., Hauptform);Stimmungsvitamin (ugs.);Thiaminchlorid (fachspr.)
-Lactoflavin;E 101 (fachspr., E-Nummer);Vitamin B2 (Hauptform);Vitamin G (veraltet);Riboflavin (Hauptform)
-Nicotinsäure (Hauptform);PP-Faktor (veraltet);Vitamin B3 (Hauptform);Nikotinsäure;Vitamin PP (veraltet);Niacin;Pyridin-3-carbonsäure
-Pantothensäure;Vitamin B5
-Pyridoxin (fachspr., Hauptform);Vitamin B6 (ugs., Hauptform);Adermin (veraltet)
-Vitamin H;Biotin (fachspr., Hauptform);Vitamin I;Vitamin B8 (franz.);Coenzym R;Vitamin B7 (ugs.)
-Vitamin B9 (ugs.);L-Folsäure (fachspr.);Folinsäure;Vitamin M (ugs.);Folsäure (fachspr., Hauptform);Pteroyl-mono-glutaminsäure (fachspr.);Vitamin B11 (ugs., selten)
-Cobalamin;Vitamin B12;Cyanocobalamin
-Calciferol (fachspr.);Vitamin D2 (ugs., Hauptform);Ergocalciferol (fachspr.)
-Vitamin E (ugs., Hauptform);E 307 (fachspr., E-Nummer);Tocopherol (fachspr., Hauptform);α-Tocopherol (fachspr.)
-Phyllochinon (fachspr., Hauptform);Phytomenadion (fachspr.);Vitamin K1 (ugs., Hauptform)
-Vitamin K2 (ugs., Hauptform);Farnochinon (fachspr.);Menachinon (fachspr., Hauptform)
-Eigenbrötler;Krauterer (ugs.);alter Kauz (ugs.);komischer Kauz (ugs.);Krauter (ugs.)
-(eine) Vorgabe machen;bestimmen;vorgeben;festsetzen;festlegen;zur Vorgabe machen;zur Regel machen
-eingekerkert;eingesperrt;in (polizeilichem) Gewahrsam;in Haft;interniert;hinter Gittern;im Gefängnis (Hauptform);bei Wasser und Brot (sitzend) (fig.);einsitzen(d);verhaftet;hinter schwedischen Gardinen;hinter Schloss und Riegel;eingebuchtet;inhaftiert;im Knast (ugs.);gefangen;in Polizeigewahrsam;gefangen genommen;festgesetzt
-Früchtchen (ugs., Hauptform);Lorbass (ugs., ostpreußisch);Schlingel (ugs.);Filou (ugs., franz.);Schlawiner (ugs.);Schlawuzi (ugs., bayr.);Schlitzohr (ugs.);Schlickefänger (ugs., ruhrdt.)
-stupsen (ugs.);stippen (ugs.)
-Totalitarismus;totalitäres Regime;antidemokratisches System
-Sendung;Programm
-Mittelschicht;Mittelklasse;Mittelstand
-Konzern;Gruppe;Riese (ugs.);Gesellschaft;Großunternehmen
-Fahrer;persönlicher Fahrer;Chauffeur;Chauffeuse (weibl.);Chauffeurin (weibl.)
-Baumstamm;Stamm
-Kniegelenk;Knie
-Nachfahre;Knirps (ugs.);Nachkomme;Gschropp (ugs., bayr.);(die) lieben Kleinen (u.a. mediensprachlich) (Plural);Zögling (geh.);Kleiner (ugs., männl.);Heranwachsender;Kleine (ugs., weibl.);Kiddie (ugs.);Kniebeißer (ugs., selten);Sprössling;Kind (Hauptform);Abkömmling;(das) Blag (ugs., ruhrdt.);(die) Blage (derb, abwertend);Nachwuchs;Panz (ugs., kölsch);Balg (ugs., abwertend, veraltet);Spross (ugs.);Kid (ugs.);Gör (ugs., berlinerisch)
-Düsenjet (ugs.);Düsenflieger (ugs.);Düsenflugzeug (ugs.);Strahlflugzeug;Jet (ugs.)
-anfallen;überfallen;angreifen;(sich) hermachen (über);herfallen (über);attackieren;angehen (ugs.)
-Terz (ugs.);Aufstand (ugs.);Aufruhr;Tumult;Theater (ugs.);Krawall;(die) Welle (ugs.);Lärm;Spektakel;Unruhe;Rabatz;Randale
-Theater (ugs.);Kasperletheater (ugs., fig.);Schmierenkomödie (ugs.);Affentheater (ugs.);Schmierentheater;Affenkomödie (ugs.);Possenspiel (ugs.)
-Kunst;Gewerbe;Metier;Handwerk;Gewerk
-Narbe;Schmarre;Wundmal;Schramme
-gebühren;angebracht sein;angemessen sein;(sich) gehören (regional)
-Dorsch;Atlantischer Kabeljau;Kabeljau
-Höllenangst (ugs.);(sehr) große Angst (Hauptform);Himmelangst (ugs.);Herzensangst;Grausen;Heidenangst (ugs.);Panik
-rechtslastig (abwertend, politisch);stockkonservativ (Verstärkung);erzkonservativ (Verstärkung);tiefschwarz (politisch);sehr konservativ;fortschrittsfeindlich;(eine) rechte Schlagseite haben(d) (fig.)
-die Alten (ugs.);Eltern (Pluraletantum);Erziehungsberechtigte
-organisiert (ugs.);Gewerkschaftler;Gewerkschafter;Mitglied bei (...);Gewerkschaftsmitglied;gewerkschaftlich organisiert;Mitglied (in) der (...);Mitglied in einer Gewerkschaft
-Fett;Dickmacher (ugs.)
-Elektron (Hauptform);Elektronenwelle (fachspr.);Negatron;Wasserstoffion (Negativ) (fachspr.)
-Fummel (ugs., salopp);Fetzen (derb, abwertend);Kleid
-Vorgegenwart;Perfekt;Präsensperfekt (fachspr.);vollendete Gegenwart
-(die) Jetztzeit;(das) Jetzt;(das) Hier und Heute;unsere Zeit;(die) jetzige Zeit;Gegenwart;(die) heutige Zeit
-igitt (ugs.);bä(h)! (ugs.);pfui (ugs.);pfui Teufel! (ugs.)
-Langerzählung;Saga;Roman;Epos
-Berg;Höhe
-sehr stark;mörderisch (ugs.);gewaltig
-Homosexualität unter Frauen;Tribadie (fachspr.);Sapphismus;Lesbentum
-Homosexualität unter Männern;Uranismus
-Restauration;Restaurierung;Wiederherstellung
-Gucker (ugs.);Sehorgan (fachspr.);Auge;Sehwerkzeug;Oculus (fachspr.);Glubscher (ugs.)
-Ausschuss;Reste;Makulatur (fachspr.);Rest
-Vor- oder Nachsilbe;Affix (fachspr., wissenschaftlich);Anhängsel (ugs.)
-Bewegungstherapeut;Orthopädist
-Krankheitskeim;Bazille;Bazillus;Krankheitserreger;Erreger
-Rädchenschneider;Rollschneider;Rollmesser
-Taxidermie;Ausstopfungskunst
-Sieg;Triumph
-Fluchthelfer;Menschenschmuggler (abwertend);Schlepper (abwertend);Schleuser (abwertend)
-Spirale (ugs.);Intrauterinpessar (fachspr.)
-Zwerchfell;Diaphragma (fachspr.)
-Monat (Hauptform);vier Wochen (ugs.);Kalendermonat
-Hartung (veraltet);Jänner (Hauptform, südtirolerisch, österr.);erster Monat des Jahres;Januar (Hauptform);Eismond (veraltet);Hartmonat (veraltet);Wintermonat (veraltet);Wolfsmonat (veraltet);Schneemonat (veraltet)
-Lenzing;dritter Monat des Jahres;Monat des Frühlingsbeginns;Lenz;Märzen (veraltet);März (Hauptform);Lenzmond
-Begleiter;Satellit;Mond;Trabant
-Mamma (fachspr.);Brust;Busen;Titte (vulg.)
-Troublemaker (engl.);Störenfried;Ruhestörer;Nervtöter;Quälgeist;Landplage (fig.);Nervensäge (ugs.);Plagegeist
-Vollmilch (min. 3,5%);Magermilch (max. 0,3%);Trinkmilch (1,5%-1,8%);Kuhmilch
-Met;Honigwein
-Wachmacher (ugs.);Muckefuck (ugs.);Kaffee
-Scheide;Schwertscheide
-entgegenwirken;entgegenarbeiten
-Homo austriacus (ugs., ironisch);Ösi (ugs.);Österreicher;Schluchtenscheißer (derb)
-realisieren;tun;verüben;durchführen;veranstalten;anstellen;machen;tätigen
-wegschieben;verrücken;umstellen;verfrachten (ugs.);umsetzen;verdrängen;deplacieren (veraltet);verschieben;rücken;schieben;fortschieben
-retardiert;geistig zurückgeblieben
-körperlich zurückgeblieben;retardiert
-(sich) öden (ugs.);Langeweile erzeugen (bei);(jemanden) langweilen;(sich) zu Tode langweilen (fig., übertreibend);vor Langeweile sterben (ugs., fig., übertreibend);(jemanden) ermüden;(jemanden) anöden
-(sich) (an)öden (ugs., regional);(jemandem ist) langweilig;(sich) fadisieren (ugs., österr.);Däumchen drehen (sprichwörtlich);gelangweilt (sein);(jemandem ist) fad (bayr., österr.);(sich) langweilen;Langeweile empfinden (geh.);nichts mit sich anzufangen wissen;(sich) ennuyieren (geh., veraltet);(jemandem) fällt die Decke auf den Kopf
-herumtoben;berserkern (geh., selten);austicken (ugs.);Randale machen;randalieren;toben;ausrasten (ugs.);Amok laufen (ugs.);rumtoben (ugs.);wüten;verrückt spielen (ugs.);herumwüten;rumwüten (ugs.)
-Blagen (ugs.);Nachkommen;(die) lieben Kleinen (scherzhaft);Bälger (ugs.);Nachwuchs;Nachkommenschaft;Brut (derb);Wänster (thür.) (ugs.);Gezücht (geh., abwertend);nächste Generation;Kinder
-Junior;Sohn (Hauptform);Filius (geh., lat.);Sohnemann (ugs.);Stammhalter (ugs.);(mein) Junge;(...) junior
-Püppi (ugs.);Tussi (ugs., Hauptform, salopp);Püppchen (ugs.);Schnitte (derb);Tuse (ugs., abwertend);(ein) aufgetakeltes Etwas (ugs., variabel);Tusse (ugs.)
-Ingenue (Rollenfach) (geh., franz.);Dummerchen (ugs., verniedlichend);Dummchen (ugs.);(jugendliche) Naive (Rollenfach);naives Mädchen
-Polystyren;Polystyrol
-in Verbindung stehen;Verbindung halten (mit);nicht abreißen (Kontakt);Kontakt unterhalten;in Verbindung sein;(den) Kontakt aufrechterhalten;Kontakt haben;in Verbindung bleiben;in Kontakt sein;(sich) abgeben (mit) (ugs., abwertend);(den) Kontakt nicht abreißen lassen;in Kontakt stehen
-schlucken;konsumieren (Suchtmittel);(sich etwas) reinzischen (ugs.);(etwas) zu sich nehmen;(sich etwas) reinpfeifen (ugs.);ingestieren (fachspr., sehr selten);einnehmen (Medikament);(sich etwas) reinziehen (ugs.);(sich etwas) einwerfen (ugs., fig.)
-hervorbringen;erschaffen;schaffen;entwerfen;entwickeln;gestalten;formen (geh.);produzieren;(etwas) löten (ugs.);schöpfen;erstellen;realisieren;erzeugen;kreieren;anfertigen
-(sich) austauschen;kommunizieren;(sich) verständigen
-interagieren;in Wechselwirkung treten mit
-Pharynx (fachspr.);Rachen
-kastrierter Hengst;Wallach
-Tööt (nordniedersächsisch) (ugs.);weibliches Pferd;Stute
-Hengst;männliches Pferd
-Choronym (fachspr.);Landschaftsname;Raumname (fachspr.);geographische Bezeichnung;geografischer Name
-manipulieren;lenken;beherrschen;beeinflussen;steuern;verändern
-Kalendertag;24 Stunden;vierundzwanzig Stunden;Tag
-Stallung;Stall
-Personalabbau;Stellenabbau;Rückgang der Beschäftigung;Personalfreisetzung (verhüllend);Stellenstreichung(en);Verkleinerung der Belegschaft;Stellenfreisetzung(en) (verhüllend);Freisetzung (von Personal) (verhüllend);Rationalisierungsmaßnahme;Arbeitsplatzabbau
-Schlittschuhläufer;Schlittschuhfahrer
-lange Vertiefung;Furche;Kanal;Graben
-Mirakel;Wunderding(e);Wunder;Zeichen
-Fragestellung;Aufgabe;Aufgabenstellung;Problemstellung
-Fehlbetrag;Haushaltsdefizit;Haushaltsloch (ugs.);Abmangel (veraltend);Defizit
-Abfolge;Nachfolge;Sukzession
-Einwegflasche;Wegwerfflasche
-Extrazug (schweiz.);Sonderzug
-aggregieren;zusammenfassen
-heiter;freundlich (Wetter);sonnig;schön
-Ostermonat;Wandelmonat;April (Hauptform);Ostermond;Launing (veraltet);Grasmond;vierter Monat des Jahres
-Blumenmond;Wonnemond;Mai (Hauptform);Wonnemonat;fünfter Monat des Jahres
-Bund (ugs.);Bundeswehr
-einen Effekt haben;greifen (Maßnahmen) (fig.);Wirkung zeigen;(sich) auswirken;wirken;(seine) Wirkung entfalten;funktionieren;fruchten
-Aspe;Populus tremula (fachspr.);Zitterpappel;Espe
-Gimpel;Blutfink;Dompfaff
-Königsweihe;Rotmilan;Gabelweihe;Roter Milan
-Origanum vulgare (fachspr., lat.);Wohlgemut;Wilder Majoran;Dorst;Echter Dost;Gewöhnlicher Dost;Müllerkraut;Oregano (Hauptform);Gemeiner Dost;Dost;Origano
-Rüttelfalke;Turmfalke
-Blässralle;Blesshuhn;Blässhuhn
-Harz;Pech
-Nudeln;Teigwaren;Pasta
-mit Noppen versehen;genoppt
-Arztbesucher;Kranker;Patient;Klient (fachspr.)
-Oberboden;A-Horizont (fachspr.);Mutterboden;Ackerkrume (fachspr.);Muttererde
-Schulhaus;Schule;Schulgebäude
-Tanke (ugs.);Tankstelle;Tankstation;Versorgungsanlage;Zapfstelle (ursprünglich)
-Untertanen;Gefolgsleute;Subalterne (geh.)
-Arbeitsprobe;Referenz
-Zuckersaft;Sirup
-Bluterkrankheit;Hämophilie (fachspr.)
-Uralt...;sehr alt;uralt;aus grauer Vorzeit;steinalt (ugs.)
-effizienter gestalten;rationalisieren
-leitend;verantwortlich
-Konfekt;Pralinen
-umgarnen;einwickeln (ugs.);berücken;becircen;betören;in den/seinen Bann schlagen;um den (kleinen) Finger wickeln (ugs.);bezaubern;bezirzen;hypnotisieren;in den/seinen Bann ziehen;verzaubern;einlullen (ugs.);verführen
-Akzeleration (fachspr.);Geschwindigkeitszunahme;Antritt;Beschleunigung;Temposteigerung
-Thematik (geh.);Beziehung;Kriterium;Gesichtspunkt;Aspekt;Hinsicht
-Synoptik;Synoptische Darstellung (fachspr.)
-geschäumtes Polystyrol;expandiertes Polystyrol;Styropor (Markenname)
-fördern;gewinnen;abbauen
-Übertreibung;Hyperbel (fachspr.)
-per anum;anal (fachspr.);rektal;den After betreffend
-mit Kalk bestreichen;weißen;kalken
-Unempfindlichkeit;Immunität;Unangreifbarkeit
-unempfänglich;...resistent (fachspr.);immun;resistent;resistiv (fachspr.);widerstandsfähig;unempfindlich
-die Grammatik betreffend;grammatikalisch;grammatisch
-lila;purpur;violett;fliederblau;blaurot
-Pädophiler;Pädosexueller
-Hydrant;Wasserzapfstelle
-wasseranziehend;hygroskopisch (fachspr.)
-Gesundheitspflege;Körperpflege;Sauberkeit;Hygiene
-Agoraphobie (fachspr.);Platzangst
-phobische Störung;Angststörung;krankhafte Angst;Phobie
-Arachnophobie;Spinnenphobie;Spinnenangst
-Sackhalter (derb);Tiefschutz;Eierbecher (derb);Ballschutz;Genitalschutz;Suspensorium (fachspr.);Hodenschutz
-Dudelsack;Sackpfeife;Pfeifensack;Bockpfeife
-zeitlos (Hauptform);klassisch;von zeitloser Geltung;zeitlos gültig;Standard...
-klassisch;die Klassik betreffend
-Nominativ (Hauptform);Nennfall;Casus rectus (lat.);erster Fall;Werfall
-Konferenz;Treff;Meeting (engl.);Versammlung;Treffen;Zusammenkunft;Besprechung;Sitzung
-Sackbahnhof (ugs.);Kopfbahnhof
-Medaille;Gedenkmünze
-Dieselkraftstoff;Diesel
-Zehengreifer;Flip-Flop
-Mutter;Schraubenmutter
-Land-Wasser-Fahrzeug;Amphibienfahrzeug
-FKKler;Naturist;Anhänger der Freikörperkultur;FKK-Anhänger;Nudist
-Holzliege;Pritsche
-Naturismus;textilfreies Baden (ugs.);FKK (Abkürzung);Freikörperkultur;Nudismus;textilfreies Schwimmen (ugs.);Nacktkultur
-soziales Engagement;Wohltätigkeit;Caritas;Philanthropie;Menschenliebe;Nächstenliebe
-Misanthropie;Menschenhass
-drei Werke;Trilogie;Dreiteiler
-Aberration (fachspr.);scheinbare Ortsveränderung;Abbildungsfehler
-Chromosomenmutation;strukturelle Chromosomenaberration
-Verbreitung;Verteiltheit;Dispersion;Zerstreuung
-Dispersion (fachspr.);Lichtbrechung
-Klausner;Einsiedler;Eremit (griechisch)
-monochromatisch;uni (franz.);unifarben;monochrom;einfarbig
-Proton;positiv geladenes Nukleon;Wasserstoffion (Positiv) (fachspr.)
-Baryon;Quarktriplett (fachspr.)
-Bestandteil des Atomkerns;Kernteilchen;Nukleon
-Neutron;ungeladenes Nukleon
-Positron (fachspr.);Antielektron
-in anderen Umständen;Mutterfreuden entgegensehen (geh.);in Umständen;gesegneten Leibes (geh., veraltet);trächtig (bei Säugetieren);(ein) Kind erwarten;(et)was Kleines (ist) unterwegs (ugs.);im (1.-9.) Monat (schwanger);guter Hoffnung (geh., veraltet);in gesegneten Umständen (geh.);werdende Mutter (sein);neues Leben unter dem Herzen (tragen) (ugs.);(ein) Kind kriegen (ugs.);(ein) Kind bekommen (ugs.);(einen) Braten in der Röhre (haben) (ugs., fig., salopp);gravid (fachspr.);schwanger;(ein) Kind unter dem Herzen tragen (veraltet)
-Gestation (fachspr.);Schwangerschaft;Gravidität (fachspr.)
-Sterneninsel;Galaxie;Welteninsel
-Abbildung;Funktion;rechtseindeutige Relation
-Kampfrichter;Ringrichter
-Elefant;Rüsseltier (ugs.);Dickhäuter (ugs.)
-Monumentalwerk (geh.);Schwarte (ugs.);Klopper (ugs.);Schinken;Wälzer (ugs.);dickes Buch
-Exhumierung;Leichenausgrabung
-(Grab) öffnen;umbetten;exhumieren;ausbetten
-Semester;Halbjahr;sechs Monate
-Genießer;Connaisseur (geh., franz.);Kenner
-verpassen;überhören;einen Aussetzer haben (ugs.);nicht mitbekommen (ugs.)
-Gotcha;Paintball
-Dehnfolie;Stretchfolie
-Haushaltszucker (ugs.);Sucrose;Kristallzucker (ugs.);Saccharose;Raffinadezucker
-Zertifikat;Gütezeichen;Gütesiegel;Qualitätssiegel;Prädikat
-mittlerer Bildungsabschluss;qualifizierter Sekundarabschluss I;mittlere Reife;Realschulabschluss;Fachoberschulreife;mittlerer Abschluss;Einjähriges (geh., veraltet);mittlerer Schulabschluss
-Schwarzschildradius;Ereignishorizont
-Schwerkraftmonster (ugs.);Quantensingularität (fachspr.);Schwarzes Loch
-Dekathlon (griechisch);Königsdisziplin der Leichtathletik (ugs.);Zehnkampf
-Quecksilber (Hauptform);Hydrargyrum;Merkur;Hg (Elementsymbol)
-Berufsreife;Hauptschulabschluss;Berufsbildungsreife
-Fachhochschulreife;Fachabi (ugs.);Fachabitur
-Opus magnum (geh., lat.);großes Werk (eines Künstlers);Opus;Meisterwerk;Kunstwerk
-Kauz (ugs., fig.);Type (ugs.);uriger Typ;komischer Vogel (ugs.);verrücktes Huhn (ugs., fig., weibl.);Mensch, wie man ihn nicht alle Tage trifft;verrückte Person;Unikum;schrille Person;seltsamer Kauz (ugs.);Wunderling;skurriler Typ;ungewöhnlicher Mensch (Hauptform);sonderbarer Zeitgenosse;schräger Typ (ugs.);irrer Typ (ugs.);schräger Vogel (ugs.);merkwürdiger Zeitgenosse;seltsamer Heiliger (ugs.);bunter Vogel (ugs.);komischer Heiliger (ugs.);schräger Fürst (ugs., scherzhaft);komischer Kauz (ugs.);Original (ugs.);Vogel (ugs., fig.);seltsamer Patron;bizarre Person;Urvieh (ugs.);Freak;schrille Type (ugs.);seltsame Type (ugs.);Sonderling;schrille Schraube (ugs., weibl.)
-Feuerwasser (ugs.);Fusel (ugs., abwertend);Branntwein;Schnaps (Hauptform);Zielwasser (ugs.);Schabau (regional);Sterbehilfe (ugs., abwertend, ironisch);Sprit (ugs.);Spirituose (fachspr.);Hochprozentiges (ugs.);Spirituosen (Plural)
-Softwareanwendung;App (Kurzform);Anwendungssoftware;Computerprogramm;Anwendung;Softwaresystem;Applikation;Software;Programm
-Quali (ugs.);qualifizierender Hauptschulabschluss
-Wärme abgebend;exotherm (fachspr.)
-endotherm (fachspr.);Wärme aufnehmend;wärmebindend
-klerikal;kirchlich;geistlich
-sicher;abgehärtet;belastbar;erschütterungsfest;stabil;leistungsfähig;gefestigt;hart im Nehmen (ugs.);zäh;zählebig
-stadial;stufenweise;abschnittsweise
-Palette;Spektrum;Gesamtheit;Vielfalt;Summe
-Impetus;Wucht;Impuls;Stoßkraft;Schwungkraft
-Grenzmarke;Grenzwert;Schwellenwert;Limit
-Baguio;Wirbelsturm (Hauptform);tropischer Sturm;Taifun;Zyklon;Hurrikan
-hinsichtlich;entsprechend;in der Art von;in Bezug auf;wie
-Falsche Akazie;Scheinakazie;Robinie;Silberregen;Weiße Robinie;Gewöhnliche Robinie (fachspr., botanisch);Robinia pseudoacacia (fachspr., botanisch, griechisch, lat.);Gemeiner Schotendorn
-cash (ugs., engl.);auf die Kralle (ugs.);in bar;in Cash;(bar) auf den Tisch des Hauses (ugs.);bar auf die Hand;bar
-keimfrei machen (ugs.);desinfizieren
-Unprofessionalität;Amateurhaftigkeit
-sauber machen;putzen;purifizieren (fachspr.);säubern;reinigen;saubermachen
-eingliedernd;integrativ
-Maoismus;Sozialismus;Stalinismus;Marxismus-Leninismus;Bolschewismus;Kommunismus (Hauptform)
-Selbstbedienungsgeschäft;Geschäft mit Selbstbedienung;Selbstbedienungsladen;SB-Markt
-Pharisäertum;Verlogenheit;Bigotterie;Heuchelei;Hinterfotzigkeit;Unaufrichtigkeit;Scheinheiligkeit;Doppelzüngigkeit;Doppelmoral;Hypokrisie
-Unkultur;Barbarei;Verrohung
-Aufrüstung;Säbelrasseln (fig.);Machtdemonstration
-Warnzeichen;Zeichen drohenden Unheils;mahnendes Zeichen;Menetekel;Vorboten kommenden Unheils;Zeichen an der Wand;böses Omen;Memento (geh.)
-Nahtstelle;Kante
-Ewiggestriger;Reaktionär
-ermattet;abgewirtschaftet;verbraucht;marode;verlustbehaftet
-bipolar;zweipolig
-Schnauzer (ugs.);Rotzbremse (derb);Respektbalken (ugs.);Pornobalken (derb);Schnurrbart;Schnauzbart;Oberlippenbart;Popelbremse (derb, fig.)
-eingetragene Lebenspartnerschaft;Homoehe (ugs.);gleichgeschlechtliche Lebensgemeinschaft;Homo-Ehe (ugs.);Schwulenehe (ugs.);eingetragene Partnerschaft
-Leitgedanke;Grundgedanke;Grundidee
-eineinhalb;anderthalb
-Unsympathin (weibl.);Unsympath (männl.);unangenehme Person
-Chauvi (ugs.);Sexist;Pascha;Macker (ugs.);Macho
-Zärtlichkeiten austauschen;herumschmusen (ugs.);kraulen;an die Brust drücken;schmusen;streicheln;kuscheln;herzen;liebkosen;schmiegen;ei, ei machen (ugs.);tätscheln
-Galaxis;Milchstraße (ugs.)
-Kandare;Gebiss;Gebissstange (eines Pferdes);Trense
-gefügsam machen;zähmen;gefügig machen;an die Kandare nehmen (ugs.);unter (seine) Kontrolle bringen
-Mesopotamien;Zweistromland
-Domstadt (ugs.);Colonia Agrippina (lat.);Köln (Eigenname, Hauptform);Kölle (ugs., Eigenname, rheinisch);Cologne (Eigenname, engl.)
-Umbruch;Änderung;Verwerfung;Wandel
-lädiert (ugs.);versehrt;verletzt;verwundet
-Neuheit;Novum;Novität;Neuerscheinung
-falzen;fügen;kniffen;falten;knicken
-Proverb (fachspr.);Spruch (ugs.);Merkspruch;Parömie (ugs.);Adagium (geh., bildungssprachlich, lat., veraltet);Sinnspruch;Sprichwort (Hauptform)
-Halfter;Zügel;Zaumzeug
-erzählend;narrativ
-Zugtier;Arbeitstier
-Yak;Bos mutus (fachspr.);Grunzochse;Jak
-domestiziertes Tier;Nutzvieh;Nutztier;Haustier
-Trawler;Schleppnetzfischer;Fangboot
-Markenware;Markenprodukt;Markenartikel
-verstoffwechseln;degradieren (fachspr.);abbauen
-von da;von dort;daher (ugs.)
-Wässerchen (ugs.);Wodka
-Carbonsäure;Karbonsäure (veraltet)
-Alkan;Kohlenwasserstoff
-Benzen (fachspr.);Benzol
-Ammoniaklösung;Salmiakgeist
-Ionenverbindung;Salz
-saure Lösung;Säure
-Salpeter;Kalisalpeter;Bengalsalpeter;Kaliumnitrat
-Natriumnitrat;E 251 (fachspr., E-Nummer);Natrum nitricum;Nitras sodae;Natronsalpeter;eubischer Salpeter;Chilesalpeter;Perusalpeter;Salpetersaures Natrium;Würfelsalpeter;Sodium Nitrate (engl.)
-Schwefelsäure;Dihydrogensulfat (fachspr.);Vitriolöl (veraltet)
-Salzsäure;Chlorwasserstoffsäure;HCl
-Salpetersäure;Scheidewasser
-Chlorgas;Chlor
-Sodium;Natrium
-Salzbildner;Halogen
-Jod;Iod
-Brom;Br (Elementsymbol)
-Fluor;F (Elementsymbol)
-Kochsalz;Tafelsalz;weißes Gold (ugs.);Natriumchlorid;Speisesalz;NaCl;Salz
-Kunststoff (ugs.);Polymer
-Bindung;chemische Bindung
-Elektronenpaarbindung;homöopolare Bindung;kovalente Bindung;Atombindung
-heteropolare Bindung;ionische Bindung;elektrovalente Bindung;Ionenbindung (Hauptform)
-Reaktion;chemische Reaktion
-Oxidation;Oxydation;Verbrennung;Elektronenabgabe
-Reduktions-Oxidations-Reaktion;Redoxreaktion;Redox-Reaktion
-Reduktion;Elektronenaufnahme
-Metallbindung;metallische Bindung
-Base;alkalische Lösung;Lauge (ugs.)
-Assemblersprache;Assembler
-Motherboard;Mainboard;Hauptplatine;Board (ugs.)
-Blei;Pb (Elementsymbol)
-Ti (Elementsymbol);Titan
-Tetrahydrofuran;THF (Abkürzung)
-Ethin;Acetylen
-Lehrwerk;Tutorial;Schulbuch;Lehrbuch;Einführung
-Stereoisomerie;Konfigurationsisomerie
-Salzisomerie;Bindungsisomerie
-Grafit;Graphit
-Kohlenstoff;C (Elementsymbol)
-Horrortrip (ugs.);Grauen;Schrecken;Horror
-Sciencefiction (engl.);Science-Fiction (engl.);filmisches Zukunftsszenario;Sci-Fi (Abkürzung, engl.);wissenschaftliche Fantastik (DDR);SF (Abkürzung, engl.);Zukunftsvorstellung
-gernhaben;anbeten;vernarrt sein (in);lieben;(sich) hingezogen fühlen (zu);verehren;(an jemandem) einen Narren gefressen haben (ugs.);verliebt sein (in);(eine) Schwäche haben für;(in jemanden) verschossen sein (ugs.);(von jemandem) eingenommen sein;vergöttern;gefallen;minnen (veraltet);(sehr) mögen;anhimmeln (ugs.);(sehr) sympathisch finden;(jemandes) Ein und Alles sein;sein Herz verloren haben (fig.);Gefallen finden an;(auf jemanden) stehen (ugs.);(jemandem) zugetan sein;ins Herz geschlossen haben;sein Herz gehängt haben (an) (fig.)
-Faber (veraltet);Schmied
-Pferdeschmied;Hufbeschlagschmied;Hufschmied
-Wolle (ugs.);Haarpracht;Haupthaar;Fell (ugs.);Schopf;Mähne;Matte (ugs.);Pelz (ugs.);Haare;Kopfbehaarung;Haar;Haarschopf;Haartracht;Kopfhaar
-chemisches Element mit der Ordnungszahl 39;Yttrium
-Lanthan;La (Elementsymbol);Lanthanum
-Li (Elementsymbol);Lithium
-K (Elementsymbol);Kalium
-Rb (Elementsymbol);Rubidium
-Alkalimetall;Caesium (fachspr.);Cäsium;Zäsium;Cs (Elementsymbol)
-Be (Elementsymbol);Beryllium
-Magnesium;Mg (Elementsymbol)
-Kalzium;Ca (Elementsymbol);Calcium
-Strontium;Sr (Elementsymbol)
-Ba (Elementsymbol);Barium
-Zirkonium;Zr (Elementsymbol);Zirconium
-Hf (Elementsymbol);Hafnium
-Vanadin;V (Elementsymbol);Vanadium
-Columbium (veraltet);Nb (Elementsymbol);Niob (Hauptform);Cb (Elementsymbol, veraltet)
-Ta (Elementsymbol);Tantal
-Molybdän;Molybdänit (ugs.);Mo (Elementsymbol)
-Tungsten (engl.);W (Elementsymbol);Wolfram (Hauptform)
-Mangan;Mn (Elementsymbol)
-Technetium;Tc (Elementsymbol)
-Re (Elementsymbol);Rhenium
-Co (Elementsymbol);Cobalt (fachspr.);Kobalt
-Zn (Elementsymbol);Zink
-Argentum (lat.);Ag (Elementsymbol);Silber (Hauptform)
-Anode;Pluspol;positive Elektrode
-Kathode;negative Elektrode;Minuspol
-Kathodenstrahlröhre;Braunsche Röhre
-Unrecht haben;unrecht haben;nicht Recht haben;nicht recht haben;falschliegen (ugs.)
-zwinkern;mit den Augenlidern klappern;(unwillkürlich) blinzeln;mit den Lidern klappern
-Tipp geben;beraten;(jemandem) Rat geben;(jemandem) auf die Sprünge helfen;beistehen
-romantisch;bildschön;hübsch;anheimelnd;malerisch;pittoresk
-Unglücksrabe (ugs.);Unglücksmensch;Schlemihl (geh.);(jemand) zieht Unglück an (ugs., auch ironisch);Unglücksvogel (ugs.);Pechmarie (weibl.);Pechvogel (ugs., Hauptform)
-Trute (schweiz.);Pute;Truthenne;Kurrhenne (ugs.);Truthuhn
-Etymologie;Wortforschung;Wortherkunft
-deutlich werden;Tacheles reden (ugs.);deutliche Worte finden;auf den Punkt bringen;(sich) unmissverständlich ausdrücken;Klartext (reden) (ugs.);die Karten offen auf den Tisch legen (fig.);Klartext reden (ugs.);nicht (lange) um den heißen Brei herumreden (ugs.);(eine) klare Ansage (machen) (ugs.);offen aussprechen (Hauptform);(mit etwas) nicht hinterm Berg halten;böse Zungen behaupten (Redensart, variabel);offen reden;deutlicher werden;auf den Punkt kommen;offen und ehrlich seine Meinung sagen;unverblümt benennen;(jemandem) nichts vormachen;(ganz) offen sein;reinen Wein einschenken (ugs., fig.);(etwas) auf gut Deutsch sagen (ugs.);kein Blatt vor den Mund nehmen (fig.);zur Sache kommen (ugs.);klare Worte finden;aus seinem Herzen keine Mördergrube machen (ugs.);unbeschönigt seine Meinung äußern;(mit jemandem) Fraktur reden;(etwas) klar aussprechen;nicht drumherum reden (ugs.);das Kind beim Namen nennen (ugs.);starke Töne (anschlagen)
-zur Zufriedenheit (von jemandem);zufriedenstellend;genügend;hinreichend;akzeptabel;zur Genüge;hinlänglich;gebührend;auskömmlich
-Zusammensetzung;Kompositum
-aufpassen;Vorsicht walten lassen (geh.);(sich) vorsehen;(die) Augen offen halten;(sehr) aufmerksam sein;Acht geben;vorsichtig sein;(die) Augen offen haben
-so'n Ding (ugs., salopp);Derartiges (geh.);etwas in dieser Art;ein solches (geh.);so was (ugs.);etwas in der Art (ugs.);sowas (ugs.);so etwas;derlei (geh., altertümelnd);etwas Derartiges
-aufpassen;Obacht geben (ugs.);aufmerken;aufhorchen;die Ohren spitzen (ugs.);aufmerksam werden
-Demoskop;Meinungsforscher
-Königin;Queen;Monarchin
-Online-Shopping;Onlineshopping;Onlinehandel (Hauptform);Online-Handel;Internethandel;E-Retail (fachspr.);E-Commerce;digitaler Handel (fachspr., mediensprachlich)
-E-Business;elektronische Geschäftsabwicklung
-durch sich selbst;für sich;per se (geh., bildungssprachlich);als solche/r/s;an sich
-Streitfrage;Spannungsfeld;Kontroverse;Gegensatz
-günstig;herzerquicklich (geh.);glücklich;pläsierlich (veraltet);gut;erfreulich;sympathisch (fig.);ergötzlich;wohltuend;gefreut (schweiz.);herzerfrischend;ersprießlich (geh.);erhebend;erquicklich (geh.);vorteilhaft;erbaulich;charmant (fig.);angenehm
-Hiatus;Zwischenzeit;Pause;Lücke;Zwischenphase;Unterbrechung
-Videotext;Teletext
-Eintragung;Datum (plural: Daten);Datensatz (fachspr.)
-Pusher (ugs.);Rauschgifthändler;Dealer (ugs.);Drogenhändler
-an Fettsucht leidend;fettleibig;feist;korpulent;hochgradig übergewichtig;fett (ugs.);adipös (fachspr.)
-Angerling (regional);Egerling (regional);Champignon
-essbarer Pilz;Speisepilz
-Kulturhauptstadt Europas 2010;Kohlenrevier;Rheinisch-Westfälischer Industriebezirk (veraltet);Kohlenpott (ugs.);Ruhrrevier;Ruhrpott (ugs.);Metropole Ruhr (Selbstvermarktungsbegriff);Rheinisch-Westfälisches Industriegebiet (veraltet);Pott (ugs.);Revier (ugs.);Ruhrgebiet (Hauptform)
-seinem Schicksal überlassen;nicht helfen;hängen lassen (ugs.);am ausgestreckten Arm verhungern lassen (ugs., fig.);(die) Hilfe verweigern;im Stich lassen (ugs.);im Regen stehen lassen (ugs., fig.)
-Kaventsmann (ugs.);Prachtexemplar (ugs.)
-brav und bieder;bieder;reizlos;hausbacken;schlicht
-Pilot;Führer;Lotse
-Hantel;Gewicht
-Arbeitsscheu;Verpissertum (derb);Faulheit;Drückebergerei
-König der Tiere (ugs.);Leu;Löwe
-schräg legen (ugs.);krängen
-Dönerkebab;Döner (ugs.)
-Kindertagesstätte;Ganztagskindergarten (österr.);Kita (Abkürzung)
-verschreibungspflichtig;rezeptpflichtig
-Bindeglied;Anschluss;Verbindung
-Schieblehre (veraltet);Schublehre (veraltet, österr.);Schiebelehre (veraltet);Messschieber;Kaliber (ugs., süddt., veraltet)
-umsteigen;Anschluss haben
-Anschluss;...verbindung;Verbindung;Umsteigemöglichkeit
-Fortbewegung;Bewegung
-im Gegensatz zu;kontrastiv (geh.);gegenüber;oppositiv (geh.);im Kontrast zu;(einander) gegenübergestellt;im Vergleich zu;anders als;im Unterschied zu;adversativ (geh.);oppositionell;in Opposition zu
-Tsatsiki;Zaziki;(griechischer) Knoblauchquark
-narrisch (ugs., bayr.);ausgeflippt (ugs.);abgedreht (ugs., Jargon);irre (ugs.);crazy (ugs.);verdreht (ugs.);leicht verrückt;abgespact (ugs., Jargon);schräg (ugs.);abgespaced (ugs.);flippig (ugs.);spinnert (ugs.);nasch (ugs., bayr.)
-Kriegsherd;Konfliktherd
-Lebensansicht;Weisheitsliebe;Philosophie (fachspr.);Weltanschauung
-Gesellschaftswissenschaft;Soziologie;Gesellschaftslehre;Gesellschaftstheorie
-PSA (fachspr.);Freudismus (fachspr.);Psychoanalyse;psychoanalytische Theorie
-Zeitungsbote;Zeitungsverträger (schweiz.);Zusteller;Mann mit der Zeitung (ugs., männl.);Zeitungsträger;Zeitungsausträger;Zeitungszusteller;Verträger (schweiz.);Zeitungsfrau (ugs., weibl.);Frau mit der Zeitung (ugs., weibl.)
-Freund;Deckkhengst (derb, abwertend, fig.);Liebhaber (Hauptform);Günstling;Beschäler (derb, abwertend);Kerl (ugs., salopp);Geliebter;Beziehung;Bettgenosse;Verhältnis;Lover (engl.);Hausfreund;Stecher (vulg., abwertend);Mann ihres Herzens;Boyfriend (ugs., engl.);Galan (geh., ironisch, veraltet);Gespiele;ständiger Begleiter;Kavalier (ironisch, veraltet)
-Sackratte (vulg.);Filzlaus
-Jieper (ugs.);Fressanfall (ugs.);Fress-Flash (ugs.);Heißhungerattacke;Schmacht (ugs.);Fressattacke (ugs.);Hungeranfall;Unterzuckerung;Heißhunger;Hungerast (Ausdauersport);Gieper (ugs.)
-Gelbe Rübe;Wurzel;Karotte
-weiße Mäuse (50er Jahre) (ugs.);Herren in Grün (ugs.);Polizei (Hauptform);Polypen (derb, beleidigend);Bullen (derb);Ordnungshüter;Trachtengruppe (ugs.);Polente (ugs.);Freund und Helfer (ugs.);Bullerei (derb);Das Auge des Gesetzes (ugs.)
-rangehen;Ärmel hochkrempeln (ugs.);loslegen
-Hackfresse (derb);Arschgesicht (derb);so ein Gesicht kann nur eine Mutter lieben (derb, Spruch);hässliches Gesicht (Hauptform)
-Aluminium;Alu (ugs.);Al (Elementsymbol)
-Psychotherapeut;Seelenklempner (derb);Seelenarzt;Therapeut (ugs.)
-psychotherapeutische Kur;psychoanalytische Praxis;Psychotherapie (fachspr.);Psychoanalyse
-Migrant;Fremdling;Ausländischer Mitbürger;Kanake (derb, beleidigend);(Person) mit Migrationshintergrund;Fremdstämmiger;(Person) mit ausländischen Wurzeln;Tschusch (meist abwertend) (ugs., österr.);Ausländer (Hauptform);Gastarbeiter (veraltet)
-Verführer;Schmeichler (Hauptform);Liebling der Frauen;(ein) Don Juan (fig.);Charmeur (geh., franz., Hauptform);(ein) Casanova (fig.);Süßholzraspler (ugs.)
-Soziologe;Gesellschaftstheoretiker;Gesellschaftswissenschaftler
-Politikwissenschaftler;Politologe
-kein Mensch und keine Seele;keine Sau (derb);nicht einer;keine Sterbensseele;nicht eine;kein Einziger;kein Mensch (ugs.);kein Aas (ugs.);niemand;keine Menschenseele;kein Schwein (derb);kein Schwanz (derb);keiner (Hauptform)
-Ohrwurm (ugs.);Gassenhauer (ugs.);Schlager;Hit
-(Eingeständnis der) Niederlage;Kapitulation;Aufgabe
-Verlorenheit;Einsamkeit
-Hymen (fachspr.);vaginale Korona;Jungfernhaut;vulvinale Korona;Jungfernhäutchen;Scheidenklappe (veraltet)
-Melodie;Tonfolge;Melodei (altertümelnd, poetisch);Weise;(Ton-) Linie
-Vertretungsplan;Supplierplan (fachspr.)
-in die Bresche springen (ugs.);aushelfen (bei);supplieren (fachspr., österr.);vertretungsweise (als ...) arbeiten;(jemanden) vertreten;(für jemanden) einspringen;aus der Patsche helfen (ugs.);(jemandes Dienst / Schicht ...) übernehmen
-Master of Arts;M.A. (Abkürzung);(akademischer) Meister;Magister;Magister Artium
-Assi (ugs.);asoziales Subjekt;Asozialer;Asi (ugs.)
-belesen;mit akademischem Hintergrund;sachkundig;kundig;studiert;gelehrt;wissend;gebildet;gelahrt (geh., altertümelnd)
-Anschluss finden;ausbügeln;punkten (können);Boden wettmachen;Boden gutmachen;Rückstand aufholen;aufholen
-rummeln (ugs.);lärmen;rumoren;Krach machen
-Ochse;kastriertes männliches Rind
-Wunderheiler;Quacksalber (derb);Hobby-Mediziner (ugs.);Pseudomediziner (ugs.);Kurpfuscher (derb);Scharlatan;Medikaster (geh., veraltet)
-Schererei (ugs.);Umstände (machen);Unannehmlichkeiten;Ungemach;Widrigkeit;Malesche (ugs., norddeutsch)
-schurigeln (ugs.);schikanieren (Hauptform);zur Sau machen (derb, fig.);mobben;fertigmachen (ugs.);aufs Korn nehmen (ugs.);kujonieren (geh.);piesacken;triezen
-Rotfuchs;Meister Reineke (ugs.);Reineke Fuchs (literarisch);Fuchs;Vulpes vulpes (fachspr., lat.)
-Lupus (fachspr.);Meister Isegrim (ugs.);Wolf;Isegrim;Canis lupus (zool.) (fachspr.)
-Adebar (ugs.);Storch;Ciconia ciconia (fachspr.);Meister Adebar (lit.);Weißstorch (fachspr.);Klapperstorch (ugs.)
-(etwas) am Hut haben (mit) (ugs., fig.);mit im Boot sitzen (bei) (ugs., fig.);involviert (in / bei);mit von der Partie sein (ugs., fig.);im Boot (sein) (ugs.);beteiligt (an / bei);engagiert (in / bei);(einen) Fuß in der Tür haben (fig.)
-kaputt (derb);fertig (ugs.);(psychisch) krank
-Überschuss;Surplus;Profit;Mehrwert;Wertzuwachs
-Tschingg (derb, schweiz.);Italiener;Itaka (derb, veraltet);Spaghettifresser (derb, abwertend);Tschingili (derb, badisch);Itaker (derb)
-Iwan (derb);Russländer (veraltet);Reuße (veraltet);Russe;Großrusse (historisch);Russki (eher abwertend) (derb)
-Polack(e) (derb, abwertend);Pole
-Krauts (ugs., engl.);Teutonen (ironisch);Kartoffeln (ugs., scherzhaft);Germanen (historisch);Deutsche
-Krabbenschubser (ugs.);Muschelschubser (ugs.);Nordlicht (Spottbezeichnung);Fischkopp (ugs.);Norddeutscher (Küstenbewohner)
-Essay;Veröffentlichung;Abhandlung;Aufsatz;Artikel;Paper (ugs., engl.);Bericht;Skript (fachspr., Jargon);Causerie (franz.)
-Diskussionsrunde;Gesprächskreis;Gesprächsrunde;Talkrunde;Zirkel;Sitzung
-(legere) Kleidung;Schlabberlook (ugs.)
-grundlegendes Umdenken;Umbruch;Paradigmenwechsel (geh., Hauptform);Nichts wird mehr (so) sein, wie es (vorher) war. (floskelhaft, übertreibend);Änderung des Weltbilds;(Beginn einer) neue(n) Zeitrechnung (fig.);Änderung der Denkungsart (geh.)
-möbliert mit Holz;rustikal
-Rattenloch (derb);Muchtbude (ugs., berlinerisch);Schweinestall (ugs., fig.);Dreck(s)loch (ugs.);(verdreckte) Wohnung;Saustall (derb);Dreck(s)bude (ugs.);Dreck(s)stall (ugs.)
-(jemanden) ärgern;(jemandem etwas) miesmachen (ugs.);(jemandem) den Spaß verderben (an);abturnen (ugs.);(jemandem) die Laune verderben;runterziehen (ugs.);schlechte Laune machen;herunterziehen (ugs.)
-nachdenken;überdenken;denken;überlegen;bedenken;erwägen;studieren;ausklügeln (ugs.);betrachten;reflektieren;ventilieren;durchdenken
-versauern;verkommen;absacken (ugs.);vereinsamen
-I-Tüpferlreiter (ugs., österr.);Tüpflischisser (ugs., schweiz.);Formalist;Kleingeist;Prinzipienreiter (ugs.);Korinthenkacker (derb);Kleinkarierter;Erbsenzähler (ugs.);Kleinkrämer (ugs.);Kleinigkeitskrämer;Pedant;Fliegenbeinzähler (ugs.);Krämerseele;Dippelschisser (ugs.)
-argumentierfreudig;debattierfreudig;diskussionswütig;diskussionsfreudig
-keineswegs;nichts da (ugs.);keine Spur (ugs.);auf gar keinen Fall;auf keinen Fall;nö (ugs.);nix da (ugs.);von wegen! (ugs.);nicht im Entferntesten (geh.);Fehlanzeige (ugs.);kein Gedanke (ugs.);nee (ugs., regional);nicht doch!;mit Nichten und mit Neffen (Kalauer) (ugs., Spruch);nä (ugs.);denkste (ugs.);naa (ugs., süddt.);weit gefehlt (geh.);nein (Hauptform);mitnichten;nicht im Geringsten (geh.);Nachtigall, ick hör dir trapsen. (ugs., Spruch, berlinerisch);Gott behüte! (ugs.);ist nicht (ugs.);ausgeschlossen;negativ (fachspr., Jargon)
-Eigenverantwortlichkeit;Autonomie;Ich-Stärke (fachspr.);Souveränität
-Verrückter;Irrer;Hirni (derb);Geistesgestörter
-meiner Ansicht nach;soweit ich erkennen kann;nach meiner Meinung;von meinem Standpunkt (aus gesehen);meines Erachtens (geh.);in meinen Augen;so wie ich die Dinge sehe;nach meinem Verständnis;meiner bescheidenen Meinung nach;meines Ermessens;meiner Auffassung nach;für mein Empfinden;so wie ich es sehe;aus meiner Sicht;IMHO (ugs., Abkürzung, Jargon, engl.);wenn Sie mich fragen;nach meiner unmaßgeblichen Meinung;m. E.;von meiner Warte;für meine Begriffe;von meinem Standpunkt aus;meiner ehrlichen Meinung nach;soweit ich sehe;nach meinem Ermessen;wenn du mich fragst (ugs.);in my humble opinion (engl.);MMN (ugs., Abkürzung);wegen mir (ugs.);nach meinem Eindruck;ich denke mal (...) (ugs.);meiner Einschätzung nach;für mein Dafürhalten;soweit ich das beurteilen kann;m.E.;nach meinem Empfinden;nach meinem Dafürhalten (geh.);für mein Gefühl;nach meinem Befinden (geh., veraltet);meiner Meinung nach (Hauptform);in my opinion (imo) (engl.)
-schwärmerisch;gefühlvoll;romantisch
-angefeuert;inspiriert;motiviert;beflügelt;ermutigt;angeregt
-doof (ugs.);beschränkt (ugs.);dümmlich;dusselig (ugs.);panne (ugs.);bescheuert (derb)
-logisch;diskursiv;begründend;beweisend
-Kultur;Kunst und Kultur;Geistesleben
-Fundierung;Substantiierung;Grundlegung;Verankerung;Anbindung;Begründung
-Untergrund (z. B. für Farbe);Grundierung;Putzgrund;Haftgrund
-(etwas) gegen Vorwürfe verteidigen;Begründungen liefern (ugs.);(etwas) als berechtigt darlegen (geh.);(etwas) entschuldigen;(etwas) rechtfertigen;(etwas) durch Belege erhärten (geh.)
-Furzidee (derb);dumme Idee (Hauptform);Einfälle wie die Kuh Ausfälle (derb, scherzhaft);Wenn wir dich nicht hätten und die kleinen Kartoffeln ... (ugs., Spruch, ironisch, variabel);Schnapsidee (ugs.);(nicht ernst zu nehmender) Einfall;(haltlose) Vorstellung;(Idee) aus einer Bierlaune heraus (ugs.);aus einer Laune heraus
-Finanzkapital;Geldkapital;Bankkapital
-Darlehensgeber;Gläubiger;Kreditor (fachspr., kaufmännisch);Geldgeber;Kreditgeber;Geldverleiher
-Darlehensvertrag;Kreditvertrag
-verschuldet (sein);in der Kreide stehen (ugs.);jemandem Geld schuldig sein;Schulden haben
-Kinderkacke (derb);Kinderkram (ugs.);Kinderei;unter der (erhabenen) Würde seiner stolzen (...) Jahre (geh., ironisch);eines Erwachsenen nicht würdig (geh.);unter jemandes Würde
-Zusammenballung;Zentrierung;Zentralisation;Zentralisierung;Fokussierung
-Naturgesetz;Naturnotwendigkeit;physikalische Gegebenheit;physikalisches Gesetz
-zentralistisch;von oben gelenkt
-Teufelskreis;Circulus vitiosus (geh., lat.)
-Produktivkapital;Arbeitsmittel;Maschinerie;Produktionsmittel
-Schattendasein;Mauerblümchendasein;Zweitrangigkeit;Unauffälligkeit;Nischendasein;Leben in der letzten Reihe
-Zusammenbruch;Kollaps;Absturz;Niedergang
-Schuldner;Kreditnehmer;Darlehensnehmer;Debitor (fachspr., kaufmännisch)
-dissertieren;promovieren (fachspr.);doktorieren (schweiz.);Doktorarbeit schreiben;Doktorgrad (erlangen)
-avancieren (geh., franz.);zu etwas werden;emporsteigen;höher steigen;vorwärtskommen;(beruflich) weiterkommen (ugs., fig.);emporkommen;Karriere machen;es zu etwas bringen;aufsteigen;arrivieren (geh.);(die) Karriereleiter emporklettern (fig., variabel);befördert werden;(sich) verbessern (ugs., fig.);aufrücken
-Machtzentrale;Schalthebel (der Macht) (ugs.);Zentrum der Macht;Machtzentrum
-schmökern (ugs.);studieren;(sich) reinziehen (ugs.);durchlesen;(sich etwas) zu Gemüte führen (ugs.);lesen (Hauptform);(Bücher) wälzen (ugs.)
-gemütvoll;atmosphärisch;romantisch;stimmungsvoll;lyrisch
-Küstengebiet (Nordsee);Küstenstrich (fachspr.);Waterkant (ugs., niederdeutsch);Seeküste;Seekante (niederdeutsch);Küste;Küstenstreifen
-Cellulitis (ugs., fälschlich);Orangenhaut (ugs.);Cellulite (fachspr., medizinisch);Zellulitis (ugs., fälschlich)
-Symphonie;Sinfonie
-ungeziert;ungeniert
-benutzt;nicht (mehr) jungfräulich (derb);nicht (mehr) frisch;gebraucht
-unbefangen;ohne Vorbehalt;ohne Weiteres;ohne weiteres;vorbehaltlos;bedingungslos
-Gullydeckel;Kanaldeckel;Abflussdeckel
-Marginalsiedlung (fachspr.);Slum;Elendsviertel;Ghetto;Bidonville (fachspr., franz.);Armenviertel;informelle Siedlung;Favela (fachspr., portugiesisch);Getto;Gecekondu (fachspr., türkisch)
-Puzzle;Ratespiel;Denkspiel;Quiz
-Waschmaschine;Waschautomat;Waschvollautomat
-Aorta (fachspr.);große Körperschlagader;Hauptschlagader
-gottesleugnerisch;atheistisch;religionslos;ungläubig;unreligiös;irreligiös
-(großer) Knall (ugs.);Paukenschlag (fig.);Skandalon (geh.);Skandal;Eklat;Aufsehen
-zyklisch;kreisläufig;ringförmig
-kohäsiv;zusammenhaltend
-degressiv;abfallend
-bestimmt;definit
-paradiesisch;elysäisch;himmlisch;göttlich;elysisch (lit.);herrlich
-Unwirklichkeit;Irrealität
-aus der Fülle des Lebens (geschöpft) (geh., literarisch);aus dem Leben gegriffen;(ganz) wie im richtigen Leben (variabel);lebensnah;realistisch;lebensecht;wirklichkeitsnah
-Spülapparat;Irrigator (fachspr.)
-expressiv;ausdrucksvoll;ausdrucksstark
-zu Rande kommen (ugs.);(sich) zurechtfinden;zurande kommen (ugs.);klarkommen (ugs.);zurechtkommen
-erklingen;erschallen;ertönen;zu hören sein
-Atomversuch;Nukleartest;Atomtest
-Bankkarte;ec-Card (fachspr., Jargon);Plastikgeld (ugs.);Scheckkarte;ec-Karte (ugs.);Debitkarte;EC-Karte (ugs.);Sparkassenkarte;Girocard;Bankomatkarte (österr.)
-(genau) betrachten;begutachten;(genauer) untersuchen;(sorgfältig) prüfen;genau(er) ansehen;unter die Lupe nehmen (ugs., fig.);auf den Zahn fühlen (ugs., fig.);(kritisch) betrachten;besichtigen;in Augenschein nehmen (ugs.);inspizieren
-Normalverteilung;Gauß-Verteilung
-Schutz;Sicherheit
-Ortschaft;Markt;Städtchen;Kuhdorf (ugs., abwertend);Marktflecken;Dorf;Marktgemeinde
-Himmelsbrot (ugs.);Manna
-schnurz sein (ugs.);(hier) nur peripher relevant sein (hochgestochen) (geh.);nur am Rande erwähnt werden (geh.);nicht von Belang sein;nicht interessieren;nicht darauf ankommen;unmaßgeblich sein;(völlig) Wurscht sein (ugs.);nichts zu sagen haben (ugs.);ohne Belang sein;nicht (so) wichtig sein;nichts machen (ugs.);nicht relevant sein;nicht schlimm sein;(etwas) tut nichts zur Sache;scheißegal sein (derb);egal sein (ugs.);schnurzpiepe sein (ugs.);nicht (weiter) der Rede wert sein;keine Geige spielen (ugs., fig., scherzhaft);unwichtig (sein) (Hauptform);irrelevant sein;keine Rolle spielen;einerlei sein;uninteressant sein (ugs.);keine Beachtung finden;schnuppe sein (ugs.);(hier) nur am Rande interessieren;ohne (jede) Relevanz sein;total egal sein (ugs.);keine Bedeutung haben
-Kochtopf;Topf;Pott (ugs.);Hafen (ugs., schweiz.)
-aufeinander abgestimmt;synchronisiert;konzertiert;abgestimmt;abgesprochen;koordiniert
-chemisches Prüfmittel;Reagens;Reagenz
-Geschlechtszelle;Konidie (fachspr.);Gamet (fachspr.);Keimzelle
-Fleischfresser;Carnivor (fachspr.);Karnivor
-Pflanzenfresser;Herbivore (fachspr.)
-hydrophil;Wasser liebend
-Ecstasy;Molly (ugs.);MDMA;Methylendioxymethylamphetamin (fachspr.);Emma (ugs.)
-Sprache;Ausdrucksform;Sprechvermögen
-Fahrleitung;Fahrdraht;Oberleitung
-Lokomotivführer (ugs.);Tf (fachspr., Jargon);Triebzugführer;Triebwagenführer (fachspr.);Eisenbahnfahrzeugführer (fachspr.);Schienenfahrzeugführer (fachspr.);Triebfahrzeugführer (fachspr.);Lokführer (ugs., Hauptform)
-kolportieren;Gerüchte verbreiten;Gerüchte in Umlauf setzen
-Servicenummer;Hotline
-messbar;erhebbar;bestimmbar;mensurabel (geh., bildungssprachlich);der Messung zugänglich
-Konsequenz;Auswirkung;Hervorbringung;Ausfluss;Herbeiführung;Folge
-jodeln;tönen;trällern;singen (Hauptform);schmettern (ugs.);intonieren (geh.);tirilieren
-Arbeitsagentur;Arbeitsamt (ugs.);Bundesagentur für Arbeit;Bundesanstalt für Arbeit (veraltet);AMS (Abkürzung, österr.);Arbeitsvermittlungsagentur;Arbeitsmarktservice (österr.);Arbeitsvermittlung;Agentur für Arbeit
-stille Geburt;Stillgeburt (Neologismus);Fehlgeburt;Totgeburt;tot geborenes Kind (auch figurativ)
-Komparativ (fachspr., wissenschaftlich);(erste) Steigerungsform;erste Steigerungsstufe
-Blackout;Zusammenbruch des Stromnetzes;Zusammenbruch der Stromversorgung;Stromausfall
-aviäre Influenza;Vogelgrippe;Geflügelpest;hochpathogene Influenza-Virus-Infektion
-Pandemie;weltweite Seuche
-unabdingbar (geh.);zwingend erforderlich;mandatorisch (geh., sehr selten);obligatorisch (geh.);zwingend;verbindlich;verpflichtend;zwingend notwendig;unbedingt erforderlich (Hauptform);zwingend vorgeschrieben
-Ohm (veraltet);Onkel (Hauptform);Muttersbruder;Vetter (väterliche Linie) (veraltet);Onkel väterlicherseits;Oheim (mütterliche Linie) (veraltet);Vatersbruder;Mutterbruder;Onkel mütterlicherseits
-Defloration (fachspr.);Deflorierung;Entjungferung;erstes Mal (ugs., jugendsprachlich)
-abseits dessen;ungeachtet (all) dessen (geh.);dennoch;unabhängig davon (Hauptform);ungeachtet alledem;außerdem;all dem ungeachtet (geh.);dessen ungeachtet;alldem ungeachtet (geh.)
-ich muss (schon) sagen;schon;(Ihr Wort) in Ehren (aber) (geh.);bei allem, was recht ist;bei allem Verständnis (ugs.);(etwas) in allen Ehren (geh.);(nun) wirklich;jedoch;durchaus;allerdings;mit Verlaub (aber);man muss (ganz) einfach sehen (ugs., floskelhaft);dein Wort in Gottes Ohr (aber) (ugs.);zwar (...) jedoch;bei allem (gebührenden) Respekt (variabel);sehr wohl;obwohl;doch;zugegeben;bei aller Liebe (aber) (ugs.)
-Treppe;Stiege (österr.);Stufen;Aufstieg
-süffisant;genüsslich
-Mitarbeiter;Mitwirkender
-entschleunigen;verlangsamen
-(den Laden) zumachen (ugs.);schließen;(seine) Pforten schließen (ugs.);(aus dem Markt) ausscheiden (fachspr., Jargon);dichtmachen (ugs.);aufgeben
-inhaftieren;einkassieren (ugs.);arretieren (geh., veraltet);gefangen nehmen;die Handschellen klicken lassen (ugs., auch figurativ);festnehmen (Hauptform);gefangennehmen;dingfest machen;verhaften;in Gewahrsam nehmen;in Haft nehmen;aus dem Verkehr ziehen (fig.)
-Headset;Sprechgeschirr;Sprechgarnitur
-Schrittmesser;Schrittzähler;Podometer (fachspr., griechisch);Pedometer (fachspr., griechisch, lat.)
-Podologe;(medizinischer) Fußpfleger
-mit schwerer Zunge sprechen;undeutlich sprechen;nuscheln (ugs.);unartikuliert sprechen;lallen
-Gesellschaftsform;Gesellschaftssystem;Gesellschaftsformation
-Nadelbaum;Konifere (ugs.)
-Sportclub;Sportverein;Sportklub
-aus dem Kopf (ugs.);verinnerlichen;in- und auswendig (ugs.);auswendig;exakt aus dem Gedächtnis abrufen können
-Rosenmond;Monat des Sommerbeginns;Brachmond (veraltet);Juno (gesprochene Form);Brachet (veraltet);Monat der Sommersonnenwende;sechster Monat des Jahres;Rosenmonat;Juni (Hauptform)
-siebenter Monat des Jahres;Honigmonat;Julei (gesprochene Form);Juli (Hauptform);Heuet (veraltet);Heuert (veraltet);Heumonat;Bärenmonat;Honigmond
-August (Hauptform);Bisemond;Erntemonat;Erntemond;Ährenmonat;Ernting;achter Monat des Jahres
-Scheiding;Herbsting;Monat des Herbstbeginns;Holzmonat;Engelmonat;neunter Monat des Jahres;Herbstmonat;September (Hauptform)
-Dachsmond (Jägersprache);Gilbhart;Gilbhard;Oktober (Hauptform);Weinmonat;zehnter Monat des Jahres
-Nebelmonat;Schlachtmonat (niederländisch);Wintermonat;Windmond;Schlachtemond (niederländisch);November (Hauptform);elfter Monat des Jahres;Nebelung;Trauermonat
-Dezember (Hauptform);Wendeling;Christmonat;letzter Monat des Jahres;Monat der Wintersonnenwende;Julmond;zwölfter Monat des Jahres;Monat des Winterbeginns;Christmond;Heiligenmonat;Dustermond;Heilmond
-Raubtier (ugs., Hauptform);Prädator (fachspr.);Beutegreifer (geh.);Räuber (ugs.)
-Säugetier (Hauptform);Säuger;Mammalia (fachspr., Plural, zoologisch)
-Münchner Lack (fachspr.);Alizarin Karmesin (fachspr.);Almadinrot (fachspr.);absolutrot (fachspr.);Alizarin Krapplack (fachspr.);Alizarinviolett (fachspr.)
-Schurwolle;Wolle
-Fußballteam;Elf;Fußballmannschaft
-Liga;Spielklasse
-Teamsport;Mannschaftssport
-König Fußball (ugs., floskelhaft);Fußball;Fussi (ugs.);Kicken (ugs.);Tschutten (schweiz.);Spiel um das runde Leder (ugs.)
-Bratklößchen (regional);Fleischküchla (fränk., schwäbisch);Brisolette;Fleischkloß;Fleischpflanzerl (bayr., regional);Faschiertes Laibchen (regional);Fleischklößchen (regional);Fleischlaberl (österr.);Fleischklops (ugs.);Hacktätschli (regional);Grilletta (DDR);Hackbeefsteak;Fleischlaiberl (österr.);Gehackteshuller (thüringisch);Huller (thüringisch);Hackplätzli (regional);Gehackteskloß (regional);Fleischlaibchen (österr.);Bulette (regional);Hackhuller (thüringisch);Deutsches Beefsteak;Fleischkrapferl (regional);Frikadelle (Hauptform);Gehacktesklößchen (regional);Fleischküchle (fränk., schwäbisch);Beefsteak (regional);Fleischtätschli (schweiz.);Bratklops (regional)
-Sportstätte;Platz;Sportplatz;Spielfeld
-Krapfen;Kreppel (ugs., hessisch);Kräppel (ugs., hessisch);Pfannkuchen (ostdeutsch);Fas(t)nachtsküchle (Südwestdeutschland) (ugs., regional);Berliner Pfannkuchen;Puffel (Aachener Bezeichnung) (ugs.);Berliner;Faschingskrapfen (österr.);Berliner Ballen (veraltet);Krebbel (ugs., hessisch);Hefegebäck (fachspr.)
-Gemeinwesen;Republik
-Versailler Abkommen;Versailles (ugs.);Vertrag von Versailles;Versailler Vertrag
-Heiliges Römisches Reich Deutscher Nation;Heiliges Römisches Reich;Erstes Reich;HRR (Abkürzung);römisch-deutsches Reich;Altes Reich;Deutsches Reich;Sacrum Imperium Romanum (lat.);Sacrum Romanum Imperium (lat.);Deutschland;Altreich
-Frankreich;(die) Französische Republik;(das) Hexagon (geh., griechisch);(die) Grande Nation (fachspr., Jargon, franz.)
-Beetle (ugs.);VW Käfer (Hauptform);Käfer (ugs.);Kugelporsche (ugs., scherzhaft-ironisch);VW 1303;Herbie (ugs.);Brezelkäfer (ugs.);VW 1302
-Saison;Spielzeit
-Tee;Aufgussgetränk
-Raumlehre;Euklidische Geometrie;Geometrie;Elementargeometrie
-ebene Geometrie;Ebenengeometrie;Planimetrie
-Topologie;Geometrie
-Begrenzung;Spielfeldbegrenzung;Bande
-Markgraf;Grenzgraf
-Geschlecht;Adel;Abstammung
-Duc (franz.);Herzog (Hauptform);Duke (engl.);Duca (ital., lat.)
-Gurkentruppe (ugs., abwertend);Riege (Turnsport);Aufgebot;Kader;Kompanie (Tanz, Theater ...);Team (engl.);Auswahl;Mannschaft;Equipe (Reitsport);Besetzung (fig.);Truppe (Theater, Tanz, Comedy, Musik ...)
-Billigairline;Low-Cost-Airline (engl.);Billigfluggesellschaft;Billigflieger;Low-Cost-Carrier (engl.)
-Senat (belgisch);Bundesrat (bundesdeutsch, österr.);Ständerat (schweiz.);Stöckli (ugs., schweiz.);Vertretung der Gliedstaaten (fachspr.);Länderkammer;Ländervertretung;Kleine Kammer (schweiz.);zweite parlamentarische Kammer (Hauptform)
-SPÖ (Abkürzung);Sozialdemokratische Partei Österreichs;Sozialdemokraten (ugs.)
-Kommunisten (ugs.);KPD (Abkürzung);die Roten (ugs.);Kommunistische Partei Deutschlands (fachspr.)
-Coke (Eigenname);Coca-Cola (Eigenname, Markenname);Cola
-Zeitrechnung;Kalender
-Würzfleisch;Ragout;Ragout fin
-Geburtstagskind;Jubilar
-Bart;Gesichtsbehaarung;Barthaare;Barthaar
-Scheibe;Puck;Hartgummischeibe
-wörtliche Bedeutung;Denotation
-Distel;Distelkraut
-Unkraut;Beikraut (fachspr., verhüllend);Wildkraut (verhüllend)
-Minimum;Extremum;Nadir;Tiefpunkt
-Klischee;Floskel;Banalität;Sprachhülse;Plattitüde;Gemeinplatz;einfache Formel;(nur so ein) Spruch (ugs.);Allgemeinplatz;leeres Gerede;sinnentleerte Chiffre (geh.);Platitude (franz.);Binsenweisheit;Trivialität;Binsenwahrheit;Phrase;Stammtischweisheit;leeres Stroh (dreschen) (ugs.);Schlagwort;Sprechblase (journal.) (fig.);Gerede ohne tiefere Bedeutung;Binse (ugs.);nichts sagende Redensart;nichtssagende Redensart;flotter Sager (ugs., österr.);flotter Spruch (ugs.)
-es sieht so aus (ugs.);es scheint
-Personenname;Name;Anthroponym (fachspr., griechisch)
-Rodentia (fachspr., Plural, zoologisch);Nager;Nagetier
-weiße Pracht (ugs.);Schneedecke;Schnee;(das) Weiß (ugs.)
-Erotik;Sinnlichkeit
-Geschlechtsleben;Liebesleben;Geschlechtlichkeit (fachspr.);Sexualität
-transluzent;transluzid;diaphan;durchscheinend
-Troll;Gnom;Unhold;Kobold
-im Stillen;versteckt;unter der Hand (fig.);ohne dass jemand das mitbekommt;ungesehen (ugs.);stickum (ugs.);verborgen;hinter vorgehaltener Hand (fig.);in aller Stille;verdeckt;im Hintergrund (fig.);heimlich, still und leise;unterm Tisch (fig.);im Geheimen;unbemerkt;(möglichst) unauffällig;insgeheim;still und leise (ugs.);stieke (ugs., berlinerisch, veraltend);klammheimlich (ugs.);stillschweigend;verstohlen;im Verborgenen;heimlich;bei Nacht und Nebel (ugs., fig.);unbeobachtet;stiekum (ugs.);in den Hinterzimmern (fig.)
-interdependent (fachspr.);voneinander abhängig
-Kiste (ugs.);System;Maschine;Komplettsystem (ohne Peripherie);PC (Abkürzung, engl.);Personal Computer (engl.);Personalcomputer (engl.);Rechner (ugs.)
-Home Computer (engl.);Heimcomputer
-Artiodactyla (fachspr.);paarzehiges Huftier;Paarzeher;Paarhufer
-Programmierung;Engineeringarbeit;Entwicklung;Coding (engl.);Implementation;Softwareentwicklung;Codierung
-(für jemanden) lobende Worte finden;(jemanden) belobigen (offiziell loben);(jemanden) rühmen (geh.);(jemanden) loben (Hauptform);(jemanden) würdigen;(jemandem) ein Lob aussprechen;(jemandem) Lob zollen (geh.);(jemanden) preisen (dichterisch);(jemandem) Anerkennung zollen (geh.);(jemanden) lobpreisen (dichterisch);(jemanden) benedeien (geh., religiös, veraltet);(jemanden) lobend erwähnen;(jemandem) Beifall klatschen (fig.);(einer Sache / jemandem) Gutes nachsagen;(sich über jemanden) anerkennend äußern (geh.)
-Drache;Tatzelwurm;Lindwurm
-schießen (Fußball);kicken
-zerbomben;einäschern;in Schutt und Asche legen
-dozieren;(eine) Ansprache halten;(einen) Vortrag halten;vortragen;(eine) Rede halten
-Imagination;Vorstellung;Vision;Einbildung;Geistesbild
-Visionär;Idealist;Weltverbesserer
-Tüftler;Bastler;Konstrukteur;Mächler (elsässisch) (schweiz.)
-foppen;auf die Schippe nehmen (ugs.);verkaspern (ugs.);verladen (ugs.);verarschen (derb);anschmieren (ugs.);täuschen;an der Nase herumführen (ugs.);hopsnehmen (ugs.);anführen (ugs.);vergackeiern (ugs.);auf die Rolle nehmen (ugs.);verdummdeubeln (ugs.);für dumm verkaufen (ugs.);(jemandem) einen Bären aufbinden (ugs.);aufziehen (ugs.);(jemanden) für dumm verschleißen (ugs., rheinisch, veraltend);narren;anmeiern (ugs.);verscheißern (derb);(jemandem etwas) weismachen (wollen) (Hauptform);hochnehmen (ugs.);vernatzen (ugs., regional);veralbern;einseifen (ugs.);zum Narren halten;verschaukeln (ugs.);zum Besten haben;nasführen;verkohlen (ugs.);veräppeln (ugs.);zum Besten halten;auf den Arm nehmen (ugs., fig., Hauptform);(jemandem) ein X für ein U vormachen;(mit jemandem) sein(e) Spielchen treiben (ugs.);verdummbeuteln (ugs.)
-(etwas / jemanden) belohnen;(jemandem etwas) Gutes tun;(sich) erkenntlich zeigen;Dankbarkeit zeigen;(etwas) vergelten (veraltet od. regional);(sich) revanchieren;(jemandem etwas) danken (geh.);wieder gutmachen;(jemandem etwas) lohnen (geh., regional, veraltet)
-Mafioso;Mitglied einer Mafia
-umständlich;nervtötend;enervierend (langsam);zeitraubend;mühsam;langatmig;ausgedehnt;lange dauernd;viel Zeit kostend;ganz allmählich;schleppend;lange Zeit dauernd;harzig (schweiz.);weitläufig;langwierig;quälend;geraume Zeit dauernd
-Alces alces (fachspr.);Elch
-Rukola;Rucola;Rauke
-gar;schier;überhaupt
-Outwachler (ugs., österr.);Linienrichter
-Reisedurchfall;Montezumas Rache (ugs.);Reisediarrhö (fachspr.);Reisediarrhoe (fachspr.)
-Zwiespalt;Entzweiung;Zerrissenheit
-Höhlenmensch;Höhlenbewohner;Troglodyt (fachspr.)
-Steppenbewohner;Nomade
-Schamane;Fernheiler;Geistheiler;Wunderdoktor (ugs.);Medizinmann;Wunderheiler
-Heiliger;Meister;Erleuchteter;Guru
-Sektenführer;Guru
-weltfremd;unangepasst;kauzig;verschroben;sonderbar;eigenbrötlerisch;wunderlich
-Kräuterhexe;Magierin;Hexe;Zauberin
-Schwarzkünstlerin;böse Hexe;Schwarzmagierin;Hexe
-Illusionist;Magier;Zauberer;Bühnenmagier;Gaukler;Trickkünstler
-Artikel;Produkt;Erzeugnis;Arbeit (= Produkt);Manufakt;Fabrikat;Gut;Ware;Handelsgut;Werk
-Weltstadt mit Herz und Schnauze (ugs.);Bundeshauptstadt;Spreeathen (ugs.);Bärlin (ugs., scherzhaft);Berlin;Hauptstadt von Deutschland;deutsche Hauptstadt;Berlin, Hauptstadt der DDR (fachspr., DDR, historisch);Spreemetropole (ugs.)
-Bankfurt (ugs.);Frankenfurt (ugs.);Mainhattan (ugs.);Frankfurt am Main;Mainmetropole (ugs.);Frankfurt (ugs.);Krankfurt (derb)
-Freie und Hansestadt Hamburg;Hamborg (plattdeutsch);Hamburg;Tor zur Welt (ugs.);Venedig des Nordens (ugs.)
-Bayernmetropole;München;Weltstadt mit Herz (Slogan);bayerische Landeshauptstadt;bayerische Metropole;Minga (bayr.)
-Schduagerd (ugs., schwäbisch);Großstadt zwischen Wald und Reben (ugs.);Stuttgart;Schduagrd (ugs., schwäbisch);Benztown (ugs.);Schwabenmetropole (ugs.)
-Kulturhauptstadt 2010;die Einkaufsstadt;Essen;Stadt an der Ruhr (ugs.)
-Düsseldorf (Eigenname);NRW-Hauptstadt;D'dorf (ugs.);Landeshauptstadt
-Bremen (ugs.);Freie Hansestadt Bremen
-Landeshauptstadt (von Niedersachsen);Hannover;Hauptstadt des Landes Niedersachsen
-Elbflorenz (ugs.);Florenz des Nordens (ugs.);Dresden;Florenz an der Elbe (ugs.);Tal der Ahnungslosen (derb)
-Bonn;ehemalige Bundeshauptstadt;ehemaliger Regierungssitz (der Bundesrepublik Deutschland)
-Mannheim;Quadratestadt;Monnem (ugs.)
-(der) Westen (ugs.);Nordrhein-Westfalen;NRW;NW
-Freistaat (ugs.);Bayernland;Freistaat Bayern;Bayern
-BW (Abkürzung);Baden-Württemberg;(das) Ländle (ugs., schwäbisch);BaWü (ugs.);(der) Südwesten (ugs.)
-Mecklenburg-Vorpommern;Meck-Pomm (ugs.)
-Freistaat Sachsen;Sachsen
-das nördlichste Bundesland;Schleswig-Holstein
-Montag;erster Tag der Woche
-Tag der Woche;Wochentag
-Iada (ugs., bayr.);Irta (ugs., bayr.);zweiter Tag der Woche;Dienstag
-Wodenstag (veraltet);dritter Tag der Woche;Mittwoch
-Pfinztag (bayr., veraltet, österr.);Donnerstag;vierter Tag der Woche
-fünfter Tag der Woche;Freitag
-Ruhetag;Rasttag;Tag des Herrn (religiös);siebenter Tag der Woche;Erholungszeit;letzter Tag der Woche;Sonntag (Hauptform);Kirchtag (ugs.)
-hundert Jahre;Jahrhundert;zehn Dekaden;Säkulum (lat.)
-Kalenderwoche (fachspr.);sieben Tage;KW ... (fachspr., Abkürzung);Woche (Hauptform)
-anpeilen;auf die Kimme nehmen (ugs.)
-konferieren;tagen
-Meter;m (Einheitenzeichen)
-Pranke (ugs., fig.);Flosse (ugs., fig.);Hand (Hauptform);Kralle (ugs., fig.);Greifhand;Pfote (derb)
-sechzig Sekunden;Minute
-Vierundzwanzigstel eines Tages;sechzig Minuten;Stunde
-Musik;Mucke (ugs.);Tonkunst;Lala (ugs.);Frau Musica (Allegorie) (geh.)
-Instrukteur;Einweiser;Anweiser
-Trainer;Coach
-obere Extremität;Arm
-gehören;in Besitz sein von
-klick (fachspr., militärisch);km (Einheitenzeichen);Kilometer;tausend Meter
-(sich) beliebt machen;Punkte sammeln;Punkte holen;punkten (fig.);Zustimmung ernten;Punkte machen
-Stadtammann (schweiz.);Stadtpräsident (schweiz.);Ammann (schweiz.);Rathauschef (ugs.);Gemeindevorsteher;Stadtchef (ugs.);Dorfschulze (veraltet);Stadtdirektor;Bürgermeister;Stapi (ugs.);Ortsvorsteher;Ortssprecher (bayr.)
-Verhandlung (Hauptform);(das) Aushandeln;Aushandlung
-Richter;Kadi (ugs.)
-mitteln;Durchschnitt berechnen
-Tochter (Hauptform);Töchterchen (ugs.);(das) Fräulein Tochter (ugs., variabel)
-Managing Director (fachspr.);Geschäftsführer;CEO (engl.)
-Fahrzeuglenker (schweiz., österr.);Fahrer (ugs., Hauptform);Mann am Steuer (des Fahrzeugs);Autofahrer;Kraftfahrer (fachspr., Amtsdeutsch);Frau am Steuer (des Fahrzeugs);Wagenlenker (schweiz., süddt., österr.);Fahrzeugführer (fachspr., Amtsdeutsch);Autolenker (schweiz.);Automobilist (schweiz.)
-Sekretariat (Hauptform);Amtsstube;Office;Arbeitszimmer;Büro (Hauptform);Schreibstube (militärisch);Geschäftszimmer
-Minister für Inneres;Innenminister
-fantastisch;magisch;inspirierend;phantastisch;bezaubernd
-Chefdiplomat (ugs.);Außenamtschef (ugs.);Außenminister
-rituell;zeremoniell
-Grundlinie;Mittellinie;Spiegelachse;Symmetrieachse;Achse
-Fixstern (veraltet);(eine) Sonne;Stern (Hauptform)
-Merkur;sonnennächster Planet;innerster Planet
-übernatürliches Wesen;göttliches Wesen;Gottheit;Gott
-Merkur;Götterbote;Hermes (griechisch);Mercurius (römisch)
-Feuerwehr (Hauptform);Brandbekämpfer
-Verteidigungsminister (euphemistisch);Kriegsminister (veraltet)
-ernennen;denominieren (geh.);berufen
-Wirtschaftsminister;Minister für Wirtschaftsangelegenheiten
-politisch Verfolgter;Heimatvertriebener;Asylsuchender;Asylwerber (österr.);Geflüchteter;Asylbewerber;Schutz Suchender;Flüchtling;Asylantragsteller;Refugee (engl.);Vertriebener;Asylant (derb)
-Hüter der (deutschen) Verfassung (ugs.);oberstes deutsches Gericht (ugs.);Verfassungshüter (ugs.);BVG (Abkürzung);Karlsruhe (ugs.);Bundesverfassungsgericht
-Innenministerium;Ministerium des Innern;Bundesinnenministerium;BMI;Bundesministerium des Innern
-Ministerium;Haus (ugs.)
-stillos;pietätlos;proletenhaft (derb);geschmacklos;primitiv;unfein;niveaulos;wüst;pöbelhaft;taktlos;unangebracht;platt (fig.);unterste Schublade (ugs., fig.)
-Aphrodite (griechisch);Liebesgöttin;Venus (römisch)
-Abendstern;Morgenstern;Venus
-Mars;roter Planet (ugs.)
-Kriegsgott;Ares (griechisch);Mars (römisch)
-kaukasisch;europid;weiß
-weiß;farbneutral
-schwarz;dunkelhäutig;negrid (veraltet)
-Aufnahme;Initiation;Einweihung
-magisch begabt;zauberkundig
-Walfisch (ugs.);Delfin;Wal;Delphin
-Tintenfisch;Neunauge;Octopus;Krake;Oktopus
-Bockbier;Starkbier
-Highlander;Schotte;Hochländer;Schottländer
-Kelte;Gallier
-Waliser;Bewohner von Wales
-Trigon (fachspr.);Dreieck
-Sechseck;Hexagon (fachspr.)
-Waage;Libra (fachspr.)
-Sternenkonstellation;Sternbild
-Brathendl (süddt., österr.);Hendel (ugs., süddt., österr.);Gummiadler (ugs., abwertend, scherzhaft);Brathähnchen (Hauptform);Grillhähnchen;Backhendl (süddt., österr.);Hendl (ugs., süddt., österr.);Broiler;Flattermann (ugs.);Goldbroiler;Brathuhn;Backhuhn (österr.);Brathühnchen
-Wassermann;Nix;Neck;Nöck
-Fischweib;Meerjungfrau (Hauptform);Nixe;Meermaid;Seejungfrau;Meerjungfer
-Istanbul (Hauptform);Konstantinopel (veraltet);Die Stadt der Reichen (ugs., historisch);Konstantinopolis (griechisch, historisch);Konstantinopol (historisch);Dersaadet (historisch);Stambul (veraltet);Byzanz (geh., historisch, veraltet)
-Hauptstadtbewohner;Berliner
-Bundeskabinett;Berlin (fig.);Bundesregierung (Hauptform);deutsche Regierung
-Parlamentswahl (Hauptform);Bundestagswahlen (bundesdeutsch);Wahlen zum Deutschen Bundestag;Nationalsratswahl (schweiz., österr.);Wahl zum Deutschen Bundestag;Bundestagswahl (bundesdeutsch)
-Terroranschlag;Terrorattentat
-identisch sein;gleichen;übereinstimmen
-Abend;Abendstunde;Abendzeit;Tagesende
-orkanartiger Sturm;(sehr) schwerer Sturm;Orkan (Hauptform);maximale Windstärke
-Tageszeitung;Tagesblatt
-Weltmeisterschaft;Weltturnier (ugs.);Titelkampf
-Hochwasser;Flut
-Ebbe;Tiefwasser;Niedrigwasser
-verwirrt;die Welt nicht mehr verstehen;verständnislos;fragend;stutzig
-Haxn (ugs.);Oberschenkel (Hauptform);Schenkel;Bollen (ugs., ruhrdt.);Haxe
-Bajuware (ugs.);Bayer
-Münchener;Münchner
-Hamburger;Burger
-Wahl zum Abgeordnetenhaus;Wahl zum Landtag;Landtagswahl
-Delegiertentreffen;Parteitag
-Erster Mann im Staate (ugs.);Bundespräsident
-Plenum;Vollversammlung;Plenarsitzung
-Rettungsdienst;Notarzt;Ambulanz
-Gerippe (ugs.);Gebeine;Knochengerüst;Skelett
-Drucksprühgerät;Sprüher;Spritzer;Rückenspritze;Drucksprüher;Pumpsprüher;Gartenspritze
-Stoß;Anstoß;Initiierung (fachspr.);Impuls (fachspr.)
-züchten;groß ziehen
-einherkommen mit;daherkommen mit (ugs.);beinhalten;nach sich ziehen;mit sich bringen (Hauptform);implizieren (fachspr.);einhergehen mit;verbunden sein mit
-in Hauptform gebracht;als Vorbild dienend;kanonisch;normalisiert
-Rangordnung;Reihung;Classement (Sportsprache, franz.);Ranking;Platzierung;Positionierung;Gewichtung;Stellung;Hackordnung;Rangfolge
-indem;während
-unifizieren (fachspr.);zuordnen;gegeneinander abgleichen;gleichsetzen
-verteilen;distribuieren;verfügbar machen;publizieren
-Feldbezeichner;Spaltenüberschrift;Attributname
-in diesem Fall;hierbei;an diesem Punkt;zu dieser Gelegenheit;dannzumal (schweiz.);dann;hier;in diesem Moment;diesfalls
-genauer eingehen auf;genauer ausführen;ausschweifen
-buchen;eintragen (Hauptform);verbuchen;aufnehmen;speichern;erfassen;festhalten
-faserverstärktes Klebeband;verstärktes Klebeband;Gewebeband;Filament-Klebeband
-injektive Funktion;links- und rechtseindeutige Relation;linkseindeutige Abbildung;Injektion;injektive Abbildung
-Entsprechung;Mapping;Umschlüsselung
-Zauberrute;magischer Stab;Zauberstab
-Virginische Zaubernuss;Hamamelis;Zaubernuss
-Nessel;Urtica (fachspr.);Brennnessel
-ursprünglich;uralt;steinzeitlich;atavistisch
-ad usum Delphini (geh., historisch, lat.);um unsittliche Passagen bereinigt;ohne explizit sexuelles Material;stubenrein (ugs.);jugendfrei (ugs., Hauptform)
-Pottasche (Trivialname);Kaliumcarbonat (fachspr.);Kaliumkarbonat;kohlensaures Kalium
-Mohammed;Prophet
-Hobbit;Halbling
-sapphisch;lesbisch
-Imam;Vorbeter
-Induktivität;Spule
-Chi;Lebenskraft;Od;Odem;Orgon;Prana;Mana
-veranlassen;einsetzen lassen;Starthilfe geben;anzetteln;loslegen lassen (ugs.);animieren;anstoßen;entfesseln;ins Rollen bringen
-Platanus x hispanica (fachspr.);Platane;Platanus x acerifolia (fachspr.)
-Acer (fachspr., botanisch);Ahorn
-besserwissen;oberschlau sein (ugs.);klugscheißen (derb);klugreden (abwertend);klug daherreden;vernünfteln
-Zehn Worte;Dekalog;Zehn Gebote
-fair;anständig;sportlich
-ritterlich;fair
-die Physik betreffend;physikalisch
-Natur;Physis;Beschaffenheit
-Kapazität;Kanone (ugs.);Meister aller Klassen;Granate (ugs.);Wunderknabe;Großmeister;Meister seines Fachs;Leuchte (ugs.);Autorität;Koryphäe;Crack (ugs.);Guru (ugs.);Experte;(ein) Supermann (ugs., fig.);Ass
-Plattenaufleger;Schallplattenunterhalter (DDR);Diskjockey (engl.);DJ (Abkürzung, engl.);Discjockey (engl.)
-alkalisch;mit hohem pH-Wert;laugenhaft;basisch
-mit niedrigem pH-Wert;sauer
-Lust;Begehren;Triebhaftigkeit;Konkupiszenz (fachspr., lat.);(sündhafte) Begierde;(triebhaftes, sündiges) Verlangen
-Mutualismus (geh.);Zweckbeziehung;Lebensgemeinschaft verschiedener Arten zum gegenseitigen Nutzen;Symbiose;Zweckgemeinschaft;(das) Zusammenleben
-durchforschen;erforschen;ausloten;sondieren;ergründen;explorieren;herausfinden (ugs.);untersuchen;erkunden;ermitteln
-emergent;aufstrebend
-zulässige Höchstgeschwindigkeit;Geschwindigkeitsbegrenzung;erlaubte Höchstgeschwindigkeit;Tempolimit;Geschwindigkeitsbeschränkung
-Europäischer Dachs (fachspr.);Meister Grimbart (ugs., poetisch);Dachs;Meles meles (fachspr., griechisch)
-ausarbeiten;erörtern;abfassen;behandeln;besprechen;abhandeln
-irgendeine;jedwede
-nach meiner Meinung;meiner Auffassung nach;wie ich denke;für meine Begriffe;in meinen Augen;von mir aus;wenn es nach mir geht
-vorgegeben;gottgegeben;feststehend;vorbestimmt;gegeben
-Overheadprojektor (Hauptform);Tageslichtprojektor;Arbeitsprojektor;Prokischreiber (schweiz.);Lichtschreiber;Overhead-Projektor;Polylux (ugs., DDR);Hellraumprojektor (schweiz.)
-Leggings;Tights (engl.);Leggins
-Gymnasium;Oberschule (ugs., bundesdeutsch, veraltet)
-Realschule;Mittelschule (ugs., veraltet)
-Hauptschule;Sekundarstufe;Volksschule (ugs.);Sek I
-Berufsschule (ugs.);Berufskolleg
-Steiner-Schule;anthroposophische Schule;Rudolf-Steiner-Schule;Waldorfschule
-univalent (fachspr.);monovalent (fachspr.);einwertig (fachspr.)
-dickfellig (ugs.);abgestumpft;gefühlskalt;gefühllos;teilnahmslos;gleichgültig;abgebrüht (ugs.);bräsig;dickhäutig;schmerzfrei (ugs.);insensibel;mitleidlos;grob;unsensibel;taktlos;unempfindlich
-Vertebrat (fachspr.);Schädeltier;Vertebraten (fachspr.);Wirbeltier
-Schnecke (alemannisch, schweiz.);Schnegge (alemannisch, schweiz.);Wendelstiege;Wendeltreppe
-Teppichvorleger;Läufer
-Fußballplatz;Rasen (ugs.);Bolzplatz (ugs.)
-Hoch;Antizyklone;Hochdruckgebiet
-anders formulieren;sprachlich ändern;umformulieren;paraphrasieren;neu formulieren
-Erklärung;Umschreibung;Deskription (geh., lat.);Periphrase (geh., griechisch);Beschreibung;Paraphrase (griechisch);Umformulierung
-brillanter Kopf (ugs.);Intelligenzler (ugs.);Intelligenzbestie (ugs.);Genie;Intelligenzbolzen (ugs.);Einstein (ugs.);Genius
-Heimwerker;Bastler
-Druckbandbeutel;Schnellverschlussbeutel;Druckverschlussbeutel
-Opernglas (Hauptform);Theaterglas;Operngucker;Opernfernglas
-Europäisches Mittelmeer;Mittelländisches Meer;Mittelmeer (Hauptform)
-Brille (Hauptform);Sehhilfe;Nasenfahrrad (ugs.);Spekuliereisen (ugs., bayr., österr.);Sehbehelf;Augengläser
-Nadelwald;Tann
-Delegation;Kontrollabgabe;Aufruf;Funktionsaufruf;Prozeduraufruf
-offen;aper (süddt.);abgetaut;schneefrei
-dahinschmelzen;wegtauen;wegschmelzen;ausapern;schmelzen
-skalierbar;erweiterbar
-gesammelt;an einer Stelle;gebündelt;zentral
-(sich) anfühlen wie;Eindruck machen (als ob);(sich) darstellen (als);anmuten (wie) (geh.);(sich) präsentieren (als);scheinen;wirken (wie);(jemandem) erscheinen (als / wie);dünken (geh., veraltet);(jemandem) vorkommen (als ob)
-fungieren (als);(sich) schimpfen (ugs.);man nennt (ihn);(sich) nennen;heißen;firmieren (unter);(sich jemanden) als etwas vorstellen müssen (lit.) (geh.);(der) Name lautet;figurieren (als);firmieren (als);angesprochen werden (können) als;genannt werden;(den) Namen tragen;(die) Bezeichnung (...) tragen;(sich) bezeichnen (als);bezeichnet werden als;(der) Name ist;(den) Namen haben;darstellen
-Ornat;Amtstracht
-Glücksbringer;Fetisch;Maskottchen;Talisman;Amulett
-Wegzoll;Tunnelgebühr;Straßenbenutzungsgebühr;Wegegebühr;Brückenzoll;Straßenzoll;Maut;Wegegeld;Zoll;Straßennutzungsgebühr
-Ablehnung;Opposition;Gegnerschaft;Frontstellung
-Kanonisation;Kanonisierung;Heiligsprechung
-Kartuschenpresse;Kartuschenpistole
-Unbill;Widrigkeit;Unerquicklichkeit;Verdruss
-Nichtbefolgung;Außerachtlassung;Nichtbeachtung
-Tullus (ugs., regional, veraltend);Buhei (ugs.);Theater (ugs., fig.);Gewese;Trara (ugs.);Bohei (ugs.);Brimborium (ugs.);(großes) Aufheben;Aufstand (ugs.);(unnötiger / übertriebener / Riesen...) Aufwand;Gedöns (ugs.);Lärm (um nichts) (ugs.);(viel) Aufhebens
-Ahnenforscher;Familienforscher;Genealoge
-zu kommen auffordern;herbitten;einladen;zu kommen bitten;zu sich bitten
-mit der Hand;manuell;von Hand (Hauptform);hand...;in Handarbeit;händisch (fachspr.);per Hand
-Motivator;Führer;Motivierer;Antreiber
-Dandy;lackierter Affe (ugs.);Piefke;Adonis (ironisch);Lackaffe (ugs.);Beau (ironisch);Geck;Gent (geh., ironisch);Stenz (ugs.);Schicki (ugs.);Schönling;Fatzke (ugs.);feiner Pinkel (ugs.);Fant (geh., veraltet);Schmock (geh., selten, veraltend);eitler Pfau (ugs.);Schickimicki (ugs., ironisch);Schnösel (ugs.);Stutzer (veraltet);Snob;Pomadenhengst (ugs., veraltet)
-Einstellung;Einstellwert;Option
-Erbpacht (ugs.);Erbbaurecht
-Falschfahrer;Geisterfahrer (ugs.)
-Stele;Grabsäule
-Massenausschreitung;gewalttätige Ausschreitungen (gegen eine soziale Gruppe);gewalttätige Übergriffe (gegen eine soziale Gruppe);massenhafte Gewalt(ausübung) gegen Leib und Leben;Pogrom (Hauptform)
-Litotes (fachspr., griechisch, lat.);Understatement (engl.);Tiefstapelei;Untertreibung
-Sekretär;Protokollant;Protokollführer;Aktuar (schweiz.);Schriftführer
-noch feucht hinter den Ohren (ugs., fig.);(noch) ein (kleines) Kind (fig.);frisch;neu;unbeschlagen (ugs.);unerfahren (Hauptform);unbeleckt (ugs.);unbewandert;grün hinter den Ohren (ugs., fig.);jungsch (ugs., berlinerisch);jung;muss sich noch die Hörner abstoßen (ugs., fig.);unbedarft
-glanzvoll;prunkvoll;prächtig;erhaben;prachtvoll
-Gebirgskette;Kordillere;Bergkette;Gebirgsrücken;Höhenrücken;Gebirgszug;Rücken;Gebirge;Gebirgsformation;Höhenzug
-Gebirgszug;Hochgebirge;Berggruppe
-(das) Dach der Welt (fig.);Himalaja;Himalaya
-Stausee;Speichersee
-Fischereiwirtschaft;Befischung;Fischfang;Fischereiwesen;Fischerei;Fischereitätigkeit
-Viehzucht;Tierproduktion;Viehwirtschaft;Viehhaltung
-unentschieden;(auch) nicht wissen, wie es weitergeht (ugs.);ratlos;(sich) nicht sicher;indifferent (geh.);unentschlossen;unschlüssig
-enger Freund;dicke Freunde (nur Plural) (ugs.);Konfident (geh., veraltet);Buddy;Vertrauter;Intimus;Busenfreund;wahrer Freund;engster Freund;eng befreundet;intimer Freund;bester Kumpel;Herzensbruder
-Schwester (ugs.);Diakonisse;Diakonissin
-Lachgas (Trivialname);Stickoxydul (veraltet);Distickstoffmonoxid;Stickoxidul (veraltet);Distickstoffoxid
-Spitzenleistung;Nonplusultra;Highlight (ugs.);Bestleistung;Spitze (ugs.);Hochform;Ideal;Maximum;Optimum (fachspr.)
-Kuhfänger (ugs.);Bullenfänger (ugs.);Rammbügel
-sehnsüchtig;sehnsuchtsvoll;sehnlich;verlangend
-Aufschiebeverhalten;Procrastination (fachspr.);Erledigungsblockade;Aufschieberitis (ugs.);Handlungsaufschub;Prokrastination (fachspr.)
-revolutionär;epochal;umwälzend;epochemachend;bahnbrechend
-Verstreutheit;Diaspora
-Zündler;Feuerteufel (ugs.);Brandstifter;Feuerleger;Pyromane;Brandleger
-Störrigkeit;Renitenz;Widerständigkeit;Widerborstigkeit;Widerspenstigkeit
-Rachefeldzug;Blutrache;Vendetta
-(rechnerisch) ermitteln;errechnen;bestimmen;kalkulieren;ausrechnen;berechnen
-verstoßen (gegen);sündigen;schuldig werden;Schuld auf sich laden;(sich) versündigen (gegen)
-Transformer;Spannungswandler;Trafo (Kurzform);Transformator
-aufgespürt;zum Vorschein gekommen (fachspr.);gefunden;entdeckt
-Shortseller (Hauptform);Baissier;Shortie (ugs.);Leerverkäufer;Baissespekulant
-Haussier;Haussespekulant
-gelaufen (kommen);per pedes;mit'n Tscheafltaxi (ugs., kärntnerisch, scherzhaft);zu Fuß (Hauptform);auf Schusters Rappen (ugs.)
-vortragen;(auswendig) aufsagen;rezitieren;wiedergeben;skandieren (lat.);hersagen
-Nahelegung;Ohrenbläserei (veraltet);Suggestion;Manipulation;Einflüstern;Beeinflussung
-Grafik;graphische Darstellung;Bild;Graphik
-Design;Formgebung;Gestaltung
-Boxer;Faustkämpfer
-markieren;einmalen;anmarkern;einzeichnen;kennzeichnen;kenntlich machen
-abstillen;entwöhnen;nicht länger die Brust geben;absetzen
-Floristikgeschäft;Floristeria;Blumengeschäft;Blumenhandlung;Blumenladen
-String (fachspr., engl.);Zeichenfolge;Zeichenkette;Zeichenstrang
-Weiterführung;Fortschreibung
-zielführend;Erfolg verheißend;(ein) gutes Pflaster (journalistisch);aussichtsvoll;hoffnungsvoll;rosig (ugs.);viel versprechend;vielversprechend;Erfolg bringend;verheißungsvoll;glücksbringend;quotenträchtig (TV) (fachspr., Jargon);lohnenswert;lohnend;mit Potenzial;Erfolg versprechend;erfolgversprechend;aussichtsreich
-Demission;Rückzug;Abgang;Amtsabtretung;Rücktritt;Renunziation;Ausscheiden;Abdankung;Amtsaufgabe;Amtsniederlegung;Abdikation
-Bahndammbrand;Böschungsbrand
-Altersmedizin;Geriatrie;Altenmedizin;Altenheilkunde;Altersheilkunde
-anpeilen;ins Visier nehmen (ugs.);zielen;ausrichten
-Preview (engl.);Vorschau (Hauptform);Voransicht;Blick auf den kommenden (...)
-Hedonismus;Genusssucht
-Eberesche;Vogelbeere;Sorbus aucuparia (botanisch)
-Dille (österr.);Dillfenchel;Dillkraut;Anethum graveolens (fachspr., lat.);Gurkenkraut;Dill
-Ellhorn (ugs.);Eller (ugs.);Holler;Schwarzer Holunder;Kelkenbusch (ugs.)
-Borretsch;Gurkenkraut
-Schachtelhalm;Scheuergras (ugs.);Zinnkraut;Ackerschachtelhalm;Zinngras (ugs.);Kattenschwanz (ugs., plattdeutsch);Katzenschwanz (ugs.);Fegekraut (ugs.);Fuchsenschwanz (ugs.)
-postmortal (fachspr.);nach dem Tod;post mortem (lat.)
-Choreografie;Choreographie;Tanznotation
-Johanniskraut;Johannisblut;Christi Wunderkraut (ugs.);Christi Kreuzblut (ugs.);Herrgottsblut (ugs.);Hypericum (fachspr.);Hartheu;Gottesgnadenkraut (ugs.)
-mehrstimmig;vielstimmig;polyphon
-homofon;einstimmig;homophon;gleichstimmig
-mint;mintfarben;lindgrün
-Gelb;Goldgelb;Kadmiumgelb;Sonnengelb;Lichtgelb
-indigo;blau;azur;ultramarinblau;himmelblau;königsblau;dunkelblau;stahlblau
-zugegen (geh.);präsent;mit dabei (ugs.);mit von der Partie (ugs.);vor Ort;(sich irgendwo) zeigen;dabei (ugs.);anwesend
-Handschellen;Handfesseln;Handschließen (fachspr.)
-(den Hörer) auflegen;einhängen;aus der Leitung gehen;(die) Leitung freimachen;(die) Verbindung beenden
-Knebelungsvertrag;Sklavenvertrag (ugs.);Knebelvertrag
-Schachspiel;Schach;Spiel der Könige (fig.)
-intrigieren;(seine) Strippen ziehen (ugs., fig.);obstruieren;konterminieren (geh.);entgegenwirken;gegenlenken;durchkreuzen;hintertreiben;vereiteln;konterkarieren;sabotieren
-zusätzliche Option;Alternative;Ausweichlösung;Zusatzoption;weitere Möglichkeit;Plan B (ugs.)
-zwingend;ob man will oder nicht (ugs.);unweigerlich;notwendigerweise;wohl oder übel;zwangsläufig;nolens volens (geh., lat.);unbedingt;unvermeidlich
-Wortemacher;Schwafler (Hauptform);Laberbacke (ugs.);Schwätzer (Hauptform);Plauderer;Dauerquassler (ugs.);Labertasche (ugs.);Quatschkopf;(jemand) redet viel, wenn der Tag lang ist;Fabulant (geh., lat.);Laberkopp (ugs.);Schwaller;Laberkopf (ugs.);Plaudertasche (ugs.);Quasseltante;Quasselstrippe (ugs.);Plapperer;Schwadroneur (französierend);Quatschkopp (ugs.);Kaffeetante (ugs.);Powertalker (engl.);Plappermaul (ugs.);Phrasendrescher;Dampfplauderer;Salbader;Schwallkopf;(jemand) hört sich gerne reden
-Rostbratwurst;Grillwurst;Bratwurst
-Muskelgewebe;Fleisch
-Anime (japanisch);Zeichentrickfilm;(animated) cartoon (fachspr., engl.);Animationsfilm
-hervorragend;erstklassig;Spitzen...;Premium...;einmalig;hochkarätig;spitze;überragend;herausragend
-Kontrollkästchen;Checkbox;Markierungsfeld;Auswahlschalter;Kontrollfeld
-Verständigung;Kommunikation;Austausch
-Folge;Episode
-zu Gast (sein);zu Besuch (sein)
-Datenbank;elektronischer Karteikasten (ugs.);Datenbanksystem;Datensammlung
-Herdplatte;Platte (ugs.);Kochplatte
-Waschtasche;Nessessär (alte Schreibung bis 2017);Necessaire;Kulturbeutel
-Furche;Rinne;Gebirgsrinne;Lahner
-abgreifen;auslesen;abfragen
-einsetzen;zuweisen;übergeben;ersetzen;assoziieren;binden an
-Binärformat;Objektcode;Compilat;übersetztes Programm
-schlemmen;schwelgen;genießen;(es sich) schmecken lassen;schmausen (geh., scherzhaft, veraltend);(genüsslich) essen (ugs.);(sich etwas) auf der Zunge zergehen lassen (ugs.)
-(sich) authentifizieren;(sich) einloggen;(sich) anmelden
-Schläfchen;Powernap (fachspr., Jargon, engl.);Powernapping (fachspr., Jargon, engl.);kurzer Schlaf;Superschlaf (fachspr.);Nickerchen
-Konstante;Festwert
-Trinität;Dreifaltigkeit;(Heilige) Dreifaltigkeit;Trinitas;Dreieinigkeit
-Mastoptose (fachspr.);Hängebrust
-lobenswert;löblich (leicht iron.) (ugs.);aller Ehren wert;respektabel;beachtlich;anerkennenswert;achtbar;ehrenwert;achtunggebietend
-Universalität;Allgemeingültigkeit;Umfassendheit
-Zweck;Sinn der Sache (ugs.);Sinn und Zweck;Sinnhaftigkeit (geh.);Ziel;Nutzen;Zweckhaftigkeit;Sinn
-Betrachtung;Darlegung(en);Behandlung;Besprechung;Erörterung;Erläuterung
-äußerlich;von außen kommend;extrinsisch;external;außerhalb
-Serviererin;Saaltochter (schweiz.);Kellnerin;Serviertochter (schweiz.);Bedienung
-Zugchef;Oberschaffner (ugs.);Zugsführer (österr.);Zugführer
-Antifaschistischer Schutzwall;Die Mauer;Berliner Mauer
-Brennglas;Linse;Okular;Linsensystem;Objektiv
-chronisch obstruktive Lungenerkrankung (fachspr.);COPD (fachspr., Abkürzung, engl.);Raucherlunge (ugs.)
-Unterwasserforscher;Aquanaut
-Maßeinheit für Schärfe;scu [Maßeinheit];Scoville
-asthmatisch;asthmoid;engbrüstig;kurzatmig
-Leckage;Bruchstelle;Leck;Öffnung;undichte Stelle
-vier Monate;drittel Jahr
-Bürgergesellschaft;Zivilgesellschaft
-Konvektomat;Kombidämpfer;Steamer;Dampfgarer
-paradieren;im Gleichschritt gehen;marschieren;in Reih und Glied gehen
-emporragen;gen Himmel ragen;(sich) auftürmen;aufragen
-ein Wallfahrt machen;wallfahren;wallen;pilgern
-für was (ugs.);wozu;zu welchem Zweck;wofür
-Araneae (fachspr., Plural, zoologisch);Webspinne (fachspr., zoologisch);Spinne (ugs., Hauptform)
-menschliches Wesen;Homo sapiens;Zweibeiner (ugs.);Erdenbewohner;Mensch;Erdbewohner;Erdenbürger;Erdling;Krone der Schöpfung (ugs., altertümlich, ironisch, religiös)
-Silberling;Buntling (ugs.);n-Wagen
-Zehntausend;Myriade;10000
-Blockabschnitt;Blockstrecke;Zugfolgeabschnitt
-deutsche Mozartstadt (ugs.);Datschiburg (ugs.);Augsburg;Fuggerstadt
-Ansager;Conférencier (veraltend);Talkmaster;Quizmaster;Fernsehsprecher;Moderator
-bekräftigen;beleben;bestärken
-Mure;Rüfe;Murgang;Schlammlawine
-Affenhitze (ugs.);Bruthitze;siedende Hitze;sengende Hitze;Tropenhitze (ugs.);(starke) Wärme;Demse (ugs.);Gluthitze (ugs.);flirrende Hitze;Knallhitze (ugs.);Bullenhitze (ugs.);Hitze;glühende Hitze
-lähmen;paralysieren;lahmlegen
-(rein) theoretisches Konzept;(theoretisches) Konstrukt (fachspr.);Konstrukt;reine Hypothese (geh.);Gedankengebäude
-Kontrolleur;Zugbetreuer;Kundenbetreuer;Zugbegleiter;Zub (fachspr.);Schaffner;KiN (fachspr.);Kondukteur (schweiz.)
-Platzkarte;Reservierung;Sitzplatzreservierung
-Trolley;Rollkoffer
-Bundespolizei;Bundesgrenzschutz (veraltet);BGS (veraltet)
-Zugrestaurant;Speisewagen;Bordrestaurant;Fresskiste (derb)
-Putzfraueninsel (ugs., abwertend, historisch);Maiorica (fachspr.);Malle (ugs.);siebzehntes Bundesland (ugs.);Mallorca
-Niveauübergang;Bahnübergang;Eisenbahnkreuzung (österr.)
-Gabelung;Weiche;Abzweigung
-Testspiel;Freundschaftsspiel
-Urli (ugs.);Uroma (ugs.);Urgroßmutter
-Uropa (ugs.);Urgroßvater
-deutsche Vereinigung;Wiedervereinigung;Wende;deutsche Wiedervereinigung;Ende der deutschen Teilung
-Nanny;Tagesmutter;Kinderfrau;Kindermädchen
-linienförmige Zugbeeinflussung;LZB (Abkürzung);Linienzugbeeinflussung
-Punktzugbeeinflussung;Indusi (fachspr.);PZB (fachspr.);induktive Zugsicherung;punktförmige Zugbeeinflussung
-Stunde null;unmittelbare Nachkriegszeit;Ende des 2. Weltkriegs (in Europa)
-Kranich-Airline (ugs.);Kranich-Konzern (ugs.);Lufthansa;Kranich (ugs.)
-Akquise;Akquisition;Kundengewinnung
-007;James Bond
-Tragsessel;Tragstuhl;Sänfte
-BMVBW;Bundesverkehrsministerium;Bundesministerium für Verkehr, Bau- und Wohnungswesen;Verkehrsministerium
-Promille;pro Tausend;von Tausend;‰;Tausendstel
-Gegacker;Lachen;Gefeixe;Gekicher;Gelächter
-Telefonbeantworter (schweiz.);Anrufbeantworter;AB (ugs.)
-Zentrum der Macht (ugs.);Kanzleramt;Waschmaschine (ugs., berlinerisch);Bundeskanzleramt
-Pantograph (fachspr.);Stromabnehmer;Pantograf (fachspr.);Bügel (ugs.)
-Gärfutter;Silofutter;Silage
-die ganze Familie;Sack und Pack (ugs.);Mann und Maus (ugs.);Kind und Kegel (ugs.)
-Unkenruf (fig.);Kassandraruf (geh.);pessimistische Prognose;ungünstige Prognose (med.)
-auf etwas verweisen;(sich) beziehen auf;in Beziehung zueinander setzen;referenzieren
-Ascher;Aschbecher;Aschenbecher (Hauptform)
-(sich) grausen;schaudern;(sich) gruseln;unheimlich (zumute) sein;(jemanden) kalt überlaufen (geh.);(jemandem) kalt den Rücken herunterlaufen;(sich) graulen
-unproblematisch;harmlos;nichts dabei (ugs.);unschädlich;gefahrlos;unverfänglich;ohne Risiko;ungefährlich;unbedenklich
-Doppelpunkt;Kolon (fachspr.)
-überlaufen;überquellen;überschwappen;übervoll sein
-E-Technik;Elektrotechnik
-gammeln (ugs.);lungern (ugs.);(die) Beine hochlegen (auch figurativ);nichts tun;rumlungern (ugs.);abchillen (ugs., jugendsprachlich);(sich) auf die faule Haut legen (ugs.);abschalten (ugs.);abschimmeln (derb);(sich) entspannen;Däumchen drehen (ugs., sprichwörtlich);(ein) Lotterleben (führen) (scherzhaft);abflacken (ugs.);herumgammeln (ugs.);(sich) festhalten an (ugs., scherzhaft-ironisch);faulenzen;(sich) erholen;nichts zu tun haben (ugs.);(sich) einen (faulen) Lenz machen;untätig sein;flacken (ugs., süddt., österr.);ablockern (ugs.);herumlungern;(die) Füße hochlegen (fig.);(es sich) bequem machen;herumhängen (ugs.);rumfaulenzen (ugs.);flohnen (ugs., schweiz.);absicken (ugs., jugendsprachlich);rumgammeln (ugs.);abhängen (ugs.);chillen (ugs.);ausruhen
-verbinden;weiterverbinden;durchstellen;vermitteln
-Grenzübertrittspapier;Pass (Hauptform);Reisepass
-Gefeierter;Jubilar
-Widerspruch;Oxymoron (fachspr., griechisch);Paradoxie;Paradox;Paradoxon;Antinomie;Contradictio in adjecto (fachspr., lat.)
-Ritt auf der Rasierklinge (ugs., fig.);Gratwanderung (fig.);russisches Roulette (ugs., fig.);Seiltanz (ugs., fig.);Spiel mit dem Feuer (fig.);(ein) riskantes Spiel (fig.);Tanz auf dem Vulkan (ugs., fig.);Tanz auf Messers Schneide (ugs., fälschlich);Vabanquespiel (fig.);Drahtseilakt (fig.);(etwas,) das ins Auge gehen kann (fig.);(eine) riskante Sache (ugs., Hauptform)
-Chronist;Chronikschreiber;Historiograph;Historiograf;Geschichtsschreiber
-Gesichtskosmetiker;Visagist
-Lebenszweck;Endzweck;Lebensinhalt;Mission;Designation (geh., bildungssprachlich, lat.);Bestimmung;Lebenssinn;Daseinszweck;Raison d'être (geh., franz.);Berufung;Existenzgrund;Zweck;(jemandes) Leben (ugs.);Sinn;Sendung
-Neitech (fachspr.);GST (fachspr.);gleisbogenabhängige Wagenkastensteuerung;Neigetechnik
-Trekkie;Star-Trek-Fan;Trekker
-abschieben;deportieren;ausschaffen (schweiz.);ausweisen;rückführen
-Gleichgewichtslehre;Statik
-Evakuation (schweiz.);Evakuierung;Räumung
-Totenmesse;Requien (österr.);Seelenmesse (österr.);Totengedenkmesse;Seelenamt;Requiem;Missa pro defunctis (fachspr.);Sterbeamt
-kalter Kaffee (ugs., fig.);alte, langweilige Geschichte;nichts Neues (ugs.);Schnee von gestern (ugs., fig.);olle Kamellen (ugs., fig., rheinisch);alter Hut (ugs., fig.)
-Kampfzone;Gefechtsfeld;Kampfgebiet;Feld der Ehre;Frontlinie;Kriegsgebiet;Schlachtfeld;Feld;Kriegsschauplatz;Front;Kampfplatz;Linie
-Diskriminierung;Ungleichbehandlung;Benachteiligung
-Eigenverschulden (fachspr., juristisch);selber schuld sein (ugs.);auf dem eigenen Mist gewachsen (ugs., fig.);(sich) selbst eingebrockt haben (ugs.);selbst in Schuld sein (ugs., regional);selbst zu verantworten (haben);selbst schuld sein (ugs.);hausgemacht (Problem) (fig.);(jemandes) eigene Schuld (sein);selbst verschuldet;(sich) selbst zuzuschreiben haben (ugs.);(selbst) die Schuld tragen (an)
-breite Masse;Volk;Fußvolk (ugs.)
-nervliche Konstitution;Nervenkostüm;Nerven
-stilllegen;einmotten;außer Betrieb setzen;außer Betrieb nehmen;vom Netz nehmen;außer Betrieb stellen;ausrangieren;außer Dienst stellen;ausmustern
-Internetadresse;Web-Adresse;Link (ugs.);URL
-demonstrieren (Hauptform);protestieren;(seinen Protest) auf die Straße tragen;auf die Straße gehen
-Gas geben;aufdrehen (ugs.);auf die Tube drücken (ugs., sprichwörtlich);heizen (ugs.)
-Frühgeborenes;Frühgeburt;Frühchen (ugs.)
-persönlicher Wunsch;Herzensangelegenheit;Sehnsucht;Wunschtraum;Herzenssache;innigster Wunsch;Herzenswunsch;Herzensbedürfnis
-Lounge;Aufenthaltsraum;Wartezimmer;Wartesaal
-Gefangennahme;Inhaftierung
-Knauserigkeit (ugs.);(übertriebene) Sparsamkeit;Knickerigkeit;einen Igel in der Tasche haben (ugs., fig.);Geiz;Knauserei (ugs.);Pfennigfuchserei (ugs.)
-Kämpfer;Haudegen (ugs.);alter Kämpe (ugs.)
-Butter bei die Fische geben (ugs., Sprichwort);auf den Punkt kommen (ugs.);konkretisieren;in medias res gehen
-Streitobjekt;strittige Frage;Streitgegenstand;strittiger Punkt;Erisapfel (geh., bildungssprachlich);Apfel der Zwietracht (geh.);Streitfrage;Streitpunkt;Zankapfel (ugs.)
-unmodifiziert;ohne (weitere) Zutaten;unverändert;nativ;naturbelassen
-(aus etwas) bestehen;enthalten;(aus etwas) zusammengesetzt sein;(sich) zusammensetzen (aus)
-anliegen;anstehen;zu erledigen sein;angegangen werden müssen;zu tun sein (ugs.)
-Analytiker;Modellersteller;Modellierer;Systemanalytiker
-Modellbildung;Modellerstellung;Modellierung
-Begriffslandschaft (fachspr.);Fachbegriffsmodell
-Modellierungskonzept;Metamodell (fachspr.);Modellierungssprache
-Plattenbau;Platte (ugs.);Betonsilo;Arbeiterschließfächer (ugs.)
-(jemanden) anspringen (ugs., fig.);(jemandem) auffallen;ins Auge fallen (fig.);ins Auge stechen (fig.);ins Auge springen (ugs., fig.);(die) Blicke auf sich ziehen;Aufmerksamkeit erregen (mit);bemerkt werden
-Primus;Musterknabe;Musterschüler;Klassenprimus;Streber (ugs., abwertend);Klassenbester;Hochkaräter;Lehrers Liebling;Klassenerster
-(jemandes) Kommen;Visite;Besuch;(jemandes) Erscheinen
-Psychologe;Seelenklempner (ugs.);Püschologe (ugs., scherzhaft)
-Anthropophobie (fachspr.);(krankhafte) Schüchternheit;Sozialphobie
-zum Höhepunkt kommen;einen Orgasmus haben;kommen (ugs.)
-zu Gesicht bekommen;äugen (fachspr., Jägersprache);sehen;erblicken;(visuell) wahrnehmen
-Enthusiast;...fan (ugs.);...philer (geh.);...freak;Sympathisant;Fex (ugs., süddt., österr.);Freak (ugs., engl.);Freund;...begeisterter;...enthusiast;...narr;...ratte (ugs.);Anhänger;Angefixter (ugs.);Tifoso (ital.);...fetischist;Fan;...anhänger;...freund;Aficionado (geh.);Liebhaber;...liebhaber
-folgsam (sein);hören;gehorchen;(schön) brav (sein) (ugs., Kindersprache);folgen
-selbstgemacht;selbst hergestellt;selber hergestellt;hausgemacht;Marke Eigenbau (ugs.);selbst gemacht
-(kleiner) epileptischer Anfall;Petit Mal (veraltet)
-in den Sternen stehen(d) (ugs., fig.);mit Vorsicht zu genießen (ugs.);dahin stehen (ob);fraglich (sein) (Hauptform);(das) sei mal dahingestellt (ugs.);(das) wissen die Götter (fig.);weiß keiner so genau (ugs.);wage ich zu bezweifeln (ugs.);Nichts Genaues weiß man nicht. (ugs., Spruch, scherzhaft);auf wackeligen Füßen stehen(d) (fig., variabel);kann man nicht wissen (ugs.);(sich) nicht so sicher (sein) (ugs.);wackelig (fig.);das ist die Frage! (ugs., variabel);unsicher;da wäre ich (mir) nicht (so) sicher (ugs., Spruch)
-Unterschuss (veraltet);Miese (ugs.);Nachteil;Fehlbetrag;Verlust;Einbuße;Defizit;Minus;Verlustgeschäft
-(etwas an jemanden) delegieren;(etwas auf jemanden) abwälzen;(Aufgaben / Verantwortung) weitergeben
-glasklar;kristallklar;lupenrein (fig., Hauptform);über jeden Zweifel erhaben
-blicklos;leer;glasig
-rückgängig machen;ungeschehen machen;aufheben;verwerfen;annullieren
-Bevollmächtigter;Botschafter;Legat;Gesandter
-Amtsperson;Amtsinhaber;der amtierende (...)
-in ein bestimmtes System einordnend;taxonom (fachspr.);taxonomisch (fachspr.)
-Lümmel;Rüpel;Wüstling;ungehobelter Bursche;Flegel;Rabauke (ugs.);Raubein;Rowdy
-Berufstätiger (männl.);Werktätiger (DDR, männl.);Erwerbstätige (weibl.);Berufstätige (weibl.);Erwerbstätiger (männl.);Werktätige (DDR, weibl.)
-Therapeut der Naturheilkunde;Heilpraktiker
-Rechtssachverständiger;Rechtswissenschaftler;Jurist;Rechtsgelehrter;Volljurist
-Lehrherr (veraltet);Anleiter;Ausbilder;Ausbildner (österr.);Lehrmeister;Meister (ugs.)
-Pauker (ugs.);Unterrichtender;Schullehrer;Meister;Schulmeister (ugs., ironisch);Lehrer;Guru (ugs.);Lehrkraft (fachspr.)
-Artist;Akrobat;Bewegungskünstler
-Possenreißer;Schelm;Scherzbold (ugs.);Witzbold (ugs.);Scherzkeks (ugs.);Schäker;Vokativus (geh., lat., veraltet);Spaßkanone (ugs.);Witzling (veraltend);Spaßmacher (ugs.);Schäkerer;Betriebsnudel (derb);Ulknudel;Schalk;Narr;Kasper;Pausenclown;Clown;Faxenmacher (ugs.);Spaßvogel (ugs., Hauptform);Komiker;Hofnarr;Harlekin;Quatschmacher
-Präsident;Chef (ugs., salopp);Vorsitzender
-in Bewegung setzen;bewegen
-schicken;senden;entsenden
-Betriebsergebnisrechnung;Kosten- und Erlösrechnung;Kostenrechnung;Kosten- und Leistungsrechnung
-Partizipation;Mitbestimmung
-Storchschnabel;Allesschreiber;Pantograf;Storchenschnabel;Pantograph
-Blog (engl.);Weblog (engl.);Internet-Tagebuch
-(jemandem) untergeben;(jemandem) unterstellt;unter sich (haben) (ugs.);untergeordnet;subaltern (geh.);inferior (geh.)
-Endfassung;Ergebnis
-bekannt gemacht werden;vorgestellt werden
-(der ...) ebenso wie (der ...);zum einen, zum anderen;neben;erstens ..., zweitens;so und auch so;beides;das eine und auch das andere;nicht nur (...) sondern auch;sowohl ... als auch
-real;ohne Scheiß (ugs.);wahrhaftig;tatsächlich;ehrlich (ugs.);so wie es sein soll;wirklich;effektiv;wahrhaft;eigentlich;echt;lebensecht;gelebt
-Enumeration;Aufzählung
-Vermittlung;Mediation
-Dinosaurier;Dino (ugs., verniedlichend);Saurier;Riesenechse;Dinosaurus (fachspr.)
-noch da (ugs.);(jemandem) geblieben;restlich;übrig;überzählig;verbleibend;über (ugs.)
-verworren;umwindend;verschlungen;verflochten
-krebserregend;karzinogen (fachspr.);kanzerogen (fachspr.);cancerogen (fachspr.);Krebs erregend;krebserzeugend
-auf der einen Seite;zum einen;einerseits;auf eine Art (Betonung auf 'eine') (ugs.)
-Fahrtreppe (fachspr.);Rolltreppe
-Gurtstraffer;Gurtstrammer
-Besonderheit;Spezifität;Eigentümlichkeit
-Fließheck;Schrägheck
-Aussätziger;Ausgestoßener;Paria;Outcast (engl.)
-profan;weltlich
-enteilen (lit.) (geh.);(die) Beine untern Arm nehmen (ugs., fig., variabel);es (auf einmal) (sehr) eilig haben;(die) Beine in die Hand nehmen (ugs., fig., variabel);hasten;(sich) fluchtartig entfernen;wegrennen (Hauptform);davonlaufen;fortlaufen;weglaufen;fortrennen;davonrennen;(einen) flotten Schuh machen (ugs.);davonstieben (geh.);Hackengas geben (ugs.);laufen gehen
-Gottesdienstbesucher;Kirchgänger;Kirchenbesucher;Kirchengänger
-eingenordet;gleichgeschaltet;auf Linie gebracht (ugs.)
-auf Linie bringen (ugs.);gleichschalten
-Schi fahren;Skilaufen;Schi laufen;Schilaufen;Ski laufen;Schifahren;Ski fahren;Skifahren
-Bummelzug (ugs.);Provinzbahn (abwertend);Regionalbahn;Vorortzug;Bimmelbahn (ugs.);hält an jeder Milchkanne (ugs., fig.);Bähnle (ugs., schwäbisch)
-charakteristisch;spezifisch;bestimmt;eigen;eindeutig
-Antiinfektivum;Antibiotikum
-Majorität;größter Teil;größter Batzen;Hauptanteil;Hauptteil;Großteil;Gutteil;Mammutanteil;Löwenanteil (ugs.)
-Tiernahrung;Fressen (ugs.);Futter;Fütterung;Mast
-Schiffchen;Jolle
-Halbgerade;Strahl
-Strang;Strahl;Fluss
-in welchem Ausmaß;ob;inwieweit;in welchem Umfang;inwiefern
-persische Sprache;Farsi;Persisch
-Firmenanwalt;Syndikusanwalt;Syndikus
-Spicken (ugs.);Unterschleif
-Mächtigkeit;Kardinalität
-trüb;milchig;undurchsichtig;transluzent;transluzid;trübe;opak;opaque
-Betonung;Nachdruck;Emphasis;Hervorhebung;Eindringlichkeit;Verdeutlichung;Pointierung;Emphase
-Kurzbesuch (Hauptform);Husch (ugs., regional);Blitzbesuch (mediensprachlich);Stippvisite
-Datenflut;Informationsdschungel
-Optimist;fröhliches Wesen;(ein) sonniges Gemüt (haben) (ugs.);Frohnatur
-Kandis;Kandiszucker;Kluntje
-Schreinerei;Tischlerei
-Schreinermeister;Tischlermeister
-Umschrift;Transliteration (fachspr., lat.);Transkription (fachspr., lat.)
-lobenswert;löblich;rühmenswert;laudabel
-Geschäftsreise;Dienstreise
-unbefristet;zeitlich nicht festgelegt;unterminiert
-gotteslästerlich;blasphemisch;verhöhnend;Gott lästernd
-permutieren;vertauschen;umstellen;kommutieren;austauschen
-Chor;Gesangverein;Singkreis;Vokalensemble (geh.);Gesangsgruppe
-strahlen;hell sein;scheinen (Hauptform);leuchten (Hauptform);flammen (geh., dichterisch);glühen;Licht emittieren (fachspr.)
-Wandmalerei;Höhlenmalerei;Parietalkunst (fachspr.);Felskunst;Felsbild
-Thermik (fachspr.);Warmluftbewegung;aufsteigende Warmluft
-Unsitte;böses Treiben;Missstand;Unwesen;übles Treiben
-Range;Sortiment
-Filibuster (historisch);Seeräuber (Hauptform);Kaperer (historisch);Freibeuter;Pirat (Hauptform);Korsar;Bukanier (historisch)
-Trauerfeier;Abdankung (schweiz.)
-Fremdenverkehr;Reisebranche;Touristik;Tourismus
-Zellkern;Nukleus (fachspr.)
-Sozietät;Genossenschaft;Kooperative
-ohne Umwege;direkte Route;Direttissima
-nur so;regelrecht (ugs.);förmlich;nachgerade (geh.);geradezu;buchstäblich;praktisch;mehr oder weniger;richtiggehend
-Sound;Klangfarbe;Timbre (franz.);Klangwirkung
-moralisch;ethisch;sittlich
-Ricke (fachspr.);Reh
-Hirsch (Hauptform);Geweihträger
-Krawattenschleife;Schleife;Querbinder;Schlips (schweiz.);Mascherl (österr.);Fliege (ugs.)
-Rauchvergiftung;Rauchgasintoxikation;Rauchgasvergiftung
-schimpflich (geh.);schändlich;entehrend;demütigend;entwürdigend;erniedrigend;schmachvoll;schmählich
-Messbuch;Missale;Missal
-Tonumfang;Ambitus
-Zahnpasta;Zahnpaste;Zahncreme;Zahncrème
-Bathophobie (fachspr.);Akrophobie (fachspr.);Höhenangst;Hypsiphobie (fachspr.)
-landen;aufsetzen;Bodenberührung haben
-Navi (ugs.);Navigationssystem
-tobend;rasend;frenetisch;stürmisch;überschäumend (fig.);überschwänglich;tosend
-Claqueur (franz.);(bezahlter) Beifallklatscher;(die) Claque (Theat.) (fachspr., franz.);Klatschvieh (derb, stark abwertend);Jubelperser
-emeritieren;in den Ruhestand setzen (fachspr.)
-absolut trocken;pulvertrocken;trocken wie Zunder (ugs.);knacketrocken (ugs.);rappeltrocken (ugs.);sehr trocken;stocktrocken;ausgedörrt;knacktrocken;trocken wie die Sahara (ugs.);staubtrocken;strohtrocken;knochentrocken;trocken wie die Wüste Gobi (ugs.);furztrocken (derb)
-Blitzer (ugs.);Radarfalle (ugs.);Radarkontrolle
-schrecklich verliebt;verschossen (ugs.);weiche Knie (haben) (ugs.);betört (geh.);schwer verliebt (ugs.);hin und weg (ugs.);in hellen Flammen stehen (fig.);verknallt (ugs.);heillos verliebt;Frühlingsgefühle haben (ugs., fig.);Schmetterlinge im Bauch (haben) (ugs., fig.);rettungslos verliebt;vernarrt (in);auf Wolke sieben (ugs.);(voll) entflammt (für jemanden);im siebten Himmel (ugs.);liebestrunken;von Amors Pfeil getroffen (fig.);hingerissen;Feuer und Flamme (für);unsterblich verliebt;Flugzeuge im Bauch (haben) (ugs., fig.);liebeskrank;verliebt (Hauptform);verrückt (nach);liebestoll;bis über beide Ohren verliebt (ugs.);in Flammen stehen (fig.);in Liebe entbrannt
-entflammen (für) (geh., poetisch);(sich) vergucken (in) (ugs.);(sich) verlieben (in);(sich) vergaffen (in) (ugs.);in Liebe entbrannt sein (geh., altertümelnd);sein Herz verlieren (an) (ugs.);(voll) abfahren (auf jemanden) (ugs.);(sich) verknallen (in) (ugs.)
-Standarte;Fahne (ugs.)
-Biodiesel;Agrodiesel
-anpassen;drauf setzen;einsetzen;portieren;adaptieren
-Posten;Lieferung;Lot (fachspr.);Charge (franz.);Schwung (ugs.);Konvolut (geh., bildungssprachlich);Partie;Los (fachspr.)
-Kirchengebäude;Gotteshaus;Bethaus;Kirche;Andachtsgebäude;Gebetshaus
-Schauspielhaus;Musentempel (geh.);Theater
-etablieren;entstehen lassen;aus der Taufe heben (geh.);einrichten;gründen;starten (mit) (ugs.);aufmachen (ugs.);ins Leben rufen;auf die Beine stellen (fig.)
-Wink;automatischer Hinweis;Tipp;Hinweis;Tooltip;Kurzinfo
-Gate (engl.);Ausgang;Flugsteig (Hauptform)
-ungleich;mit zweierlei Maß
-Alpenindianer (derb);Eidgenosse;Schweizer
-Papierfähnchen;Jubelfetzen (ugs., DDR, veraltet);Winkelement (ugs., Amtsdeutsch, DDR, Jargon);Fähnlein;Euphoriefetzen (ugs., DDR, veraltet);Fähnchen;Papierfahne
-Paginierstempel;Numeroteur;Nummeriermaschine
-Drehscheibe (fig.);Umschlagpunkt;Knotenpunkt;Knoten;Verkehrsknotenpunkt;Hub (fachspr., engl.);logistisches Zentrum;Drehkreuz (fig.)
-konkurrenzlos;ohne Alternative
-fernsehtauglich;telegen;fernsehgeeignet
-(sich) aufschaukeln;(sich) hochschaukeln;(sich gegenseitig) verstärken
-Jumbojet (ugs.);Jumbo-Jet (ugs.);Boeing 747;747;Jumbo (ugs.)
-Curium;Cm (Elementsymbol)
-digitaler Fotoapparat;Digitalkamera (Hauptform);Digicam (ugs.);Digi (ugs.)
-Luftfeuchte (fachspr.);Luftfeuchtigkeit;Wasserdampfgehalt der Luft
-durchbrechen;(sich selbst) zerlegen;zerstört werden;in Stücke gehen (ugs.);(die) Grätsche machen (ugs., salopp);(sich) in Wohlgefallen auflösen (ironisch);mitten durchbrechen;kaputtgehen;entzweigehen;in den Eimer gehen;aus dem Leim gehen (ugs.);in die Binsen gehen (ugs.);(sich) in seine Einzelteile auflösen;auseinandergehen (ugs.);in zwei Teile brechen;in seine Einzelteile auseinanderfallen;in alle Einzelteile auseinanderfallen;zerfetzt werden;in ... Teile zerbrechen;entzweibrechen;auseinanderfallen;auseinanderbrechen;in Stücke brechen;in die Brüche gehen;zerbröckeln
-Elvis Presley;(der) King of Rock'n Roll;der King (ugs.);Elvis (ugs.)
-Mundwerk;Klappe (ugs.);Schnauze (ugs.);Lippe (ugs.);Schnute (ugs.)
-diplomatische Vertretung;Vertretung;Konsulat;Mission;Botschaft;Gesandtschaft;Auslandsvertretung;ständige Vertretung
-Mahlzeit;Wohl zu speisen! (geh.);gesegnete Mahlzeit;'n guten! (ugs.);guten Appetit;hau(t) rein (ugs.);lasst es euch schmecken;lass es dir schmecken;guten Hunger (ugs.)
-Bündnis 90;Bündnis 90/Die Grünen;Grüne (ugs.);Die Grünen;Bündnisgrüne (ugs.)
-Philatelist (fachspr.);Briefmarkensammler
-Fußball-Weltmeisterschaft;FIFA WM;Fußball-WM;Fußballweltmeisterschaft
-Pointe (franz.);Bonmot (franz.);Aperçu (franz.);Epigramm;Gag (ugs., engl.);Joke (ugs., engl.);Scherz;schlagfertige Äußerung;Wortwitz;Geistesblitz;Spruch;geistreiche Bemerkung;Spaß (ugs.)
-Kriegsverbrecherprozesse;Nürnberger Prozesse;Kriegsverbrechertribunal;Tribunal von Nürnberg
-abschmieren (ugs.);crashen (ugs.);abrauchen (ugs.);zusammenbrechen;(sich) aufhängen (Computer) (fig., Hauptform);abstürzen (fig.);abkacken (derb)
-Crash (ugs.);Absturz;Bluescreen (ugs.)
-säen;Saatgut ausbringen (fachspr.)
-einen ganzen Wald zersägen (fig.);ratzen (ugs.);sägen (ugs.);einen ganzen Wald durchsägen (fig.);gurgeln (ugs.);schnarchen
-Michael Schuhmacher;Schumi (ugs.)
-(begierig) lesen;(sich) reinziehen (ugs.);verschlingen (ugs.)
-Adäquanz;Angemessenheit;Eignung;Verhältnismäßigkeit;Zweck-Mittel-Relation;Adäquatheit
-die Weisheit mit Löffeln gefressen (ugs.);neunmalklug (ugs.);die Weisheit für sich gepachtet haben (fig.);oberlehrerhaft;übergescheit;oberschlau;überklug;siebengescheit (ugs.)
-Nippon;Land des Lächelns (ugs.);Land der Kirschblüten (ugs.);Land der aufgehenden Sonne (ugs.);Japan
-Aspirin (Markenname);ASS;Acetylsalicylsäure
-Katarakta (fachspr.);Linsentrübung;grauer Star;Katarakt (fachspr.)
-Ring;Reif
-Korbball;Basketball
-Bonze (ugs.);große Nummer;Mächtiger;hohes Tier (ugs.)
-Crayon (veraltet);Graphitstift;Krayon (veraltet);Bleistift
-Schwebebahn;Hängebahn
-Bericht;Nachprüfung;Review
-Schockgeber;Defibrillator
-Defibrator;Zerfasermaschine für Holz
-abnehmend;nachlassend;Tonstärke u. Tempo zurücknehmend;mancando (fachspr.)
-jemanden auf die Rolle nehmen (ugs.);jemanden auf den Arm nehmen (ugs., fig.)
-Zwischenschritt;Etappenziel;Zwischenziel;Teilziel
-Verunstaltung;Verschandelung;Entstellung;Defiguration
-Schneebesen;Schaumschläger;Schneerute (österr.);Schwingbesen (schweiz.);Quirl;Rührbesen
-(sich mit etwas) auseinandersetzen;(sich) vertiefen (in);studieren
-Orchideenfach;Exotenfach
-Ergebnis;Wert;Ausprägung
-schwanken;variieren (fachspr.)
-Zahl;Wert
-Gauck-Behörde (ugs.);Stasi-Unterlagen-Behörde (ugs.);BStU;Birthler-Behörde (ugs.)
-Bankkonto;Bankverbindung;Konto;Kontoverbindung (ugs.)
-Baubeginn;(erster) Spatenstich
-Matratze;Polster;Futon (japanisch);Matte
-Frühdruck;Inkunabel;Wiegendruck
-Nationalpark;Landschaftsschutzgebiet;Naturpark
-Porträtaufnahme;Konterfei (geh., veraltend);Porträtfoto;Bild (einer oder mehrerer Personen) (ugs.);Porträt
-Triathlon;Ausdauermehrkampf
-Gabelschlüssel (ugs.);Maulschlüssel
-Schraubenschlüssel (Hauptform);Schraubschlüssel (ugs.)
-Hochgeschwindigkeitsstrecke;Neubaustrecke (Bahnverkehr);Schnellfahrstrecke;Schnelltrasse;Rennbahn (ugs., fig.)
-Hochchinesisch;Guanhua (chinesisch);Putonghua (chinesisch);Nordchinesisch;Mandarin (ugs.);Standardchinesisch;Guoyu (chinesisch)
-Hitlerdeutschland (ugs.);NS-Staat;Hitler-Deutschland (ugs.);Drittes Reich;Nazi-Deutschland (ugs.);Deutschland 1933-1945;Führerstaat;(das) Tausendjährige Reich;Nazideutschland (ugs.)
-Konziliation (geh., lat.);Aussöhnung;Verständigung;Versöhnung
-Streife laufen;patrouillieren;bestreifen (fachspr.)
-Myokardinfarkt (fachspr.);Herzmuskelinfarkt;Herzattacke (ugs.);Herzkasper (ugs.);Herzanfall (ugs.);Herzinfarkt
-Mageninhalt;Kotze (derb);Erbrochenes;Speibe (derb, österr.)
-Freitauchen;Apnoetauchen
-Linie;Konzept;roter Faden (ugs., fig.);Kurs
-Wegwerfhandschuh;Aidshandschuh (ugs.);Einweghandschuh;Einmalhandschuh
-Anfangsschwierigkeit(en);Startschwierigkeit(en) (Hauptform);Kinderkrankheit(en) (ugs., fig.);Anlaufschwierigkeit(en)
-(sich) zu viel vornehmen;(jemandem / sich) zu viel zumuten;(sich) übernehmen;(jemanden / sich) überlasten;(jemandem) zu viel sein;(jemanden / sich) überfordern
-Knüpfwerk;Teppich;Auslegware;Auslegeware
-Komitologie (fachspr.);Ausschusswesen
-Edelmetall (ugs.);Medaille;Ehrenabzeichen
-Ergebnis erzielen;(sich) (gut) schlagen (ugs.);abschneiden;(gut / schlecht / besser / schlechter) wegkommen (bei) (ugs.)
-uppen (ugs., Denglisch);online stellen;hochladen;raufladen;uploaden (Denglisch)
-Kraftstrom (ugs.);Drehstrom (ugs.);Starkstrom (ugs.);Dreiphasenwechselstrom (fachspr.)
-Spontanbewerbung;Initiativbewerbung;Blindbewerbung
-Leitungskompetenz;Führungskompetenz
-Ansatz;Format (fachspr.);Handhabe;Maßnahme;Methode;Instrument;Mittel;Werkzeug (fachspr.)
-(sich) informieren;(sich) schlaumachen (ugs.);(sich) sachkundig machen;(sich) kundig machen;(sich) erkundigen
-Wirtschaftswissenschaften;Ökonomie;Ökonomik;Wirtschaftswissenschaft
-Kompartiment (franz., ital., lat.);Abteil;Eisenbahnabteil;Séparée (franz.);Coupé (franz., veraltet);Separee (franz.)
-Dienstanzug;Dienstbekleidung;Uniform;Einheitskleidung;Kluft;Livree;Montur;Dienstkleidung
-LPG (Abkürzung);Landwirtschaftliche Produktionsgenossenschaft
-umsehen;umschauen;umgucken (ugs.);umblicken
-Gesetzgebungsperiode;Legislaturperiode;Wahlperiode
-niveaufrei;kreuzungsfrei;höhenungleich
-grundsätzlich;a priori (bildungssprachlich, lat.);von Anfang an;von vornherein;von vorneherein;per se (geh., bildungssprachlich, lat.)
-Esprit;Geist;Witz
-Teamgeist;Gruppengeist;Gemeinschaftsgefühl
-aus essen gehen (ugs.);ausgehen essen (ugs.);im Restaurant essen;auswärts essen (gehen);ins Restaurant gehen;essen gehen;zum Essen ausgehen;in die Kantine gehen (Arbeit);zu Tisch gehen (von der Arbeit aus);einkehren;außer Haus essen (gehen)
-Kläger (fachspr.);Ankläger;Staatsanwalt;Beschwerdeführer
-Dauerlutscher;Lutscher;Schleckstängel (schweiz.);Schlotzer (ugs., schwäbisch);Lolli (ugs.)
-Larynx (fachspr.);Kehlkopf
-Einträglichkeit;Profitabilität;Wirtschaftlichkeit;Rentabilität
-bessere Kreise;Bussi-Bussi-Gesellschaft (ugs.);Hautevolee (franz.);Schickimicki-Gesellschaft;(die) Happy Few (engl.);Crème de la Crème (geh., franz.);(die) Schönen und Reichen;bessere Gesellschaft;die oberen Zehntausend;Upperclass (engl.);höhere Kreise;Jetset (engl.);Elite;Jeunesse dorée (geh., franz.);High Society (engl.);High Snobiety (ironisch);Schickeria;(die) Reichen und Schönen;(die) große Welt;Bussi-Bussi-Fraktion (ugs.)
-fritten (ugs.);frittieren
-Luftdruckausgleich;Luftströmung;Luftstrom;Luftbewegung;Wind
-Motorik (fachspr.);Lokomotorik (fachspr.);Lokomotion (fachspr.);Kinetik (fachspr.);Regung;Taxis (fachspr.);Bewegung
-Schönheitspflegemittel;Kosmetikum;Körperpflegemittel;Kosmetikprodukt
-Bachelor-Thesis;Bachelorarbeit;Bachelorthesis
-Grauziffer (landschaftlich);unbekannte Zahl;Dunkelfeld;Dunkelzahl;Dunkelziffer;(nur die) Spitze des Eisbergs (fig.);nicht näher bekannte Anzahl
-Zugangsweg;Zuwegung;Zugangsstraße;Zufahrtsstraße;Zufahrtsweg
-Giveaway (ugs., engl.);Werbegeschenk (Hauptform);Give-away (ugs., engl.);Werbeartikel;Werbepräsent;Streuartikel;Zugabe (fachspr., juristisch, veraltet)
-Rechtschreibprüfung;Lektorat
-divergent;entgegengesetzt;unterschiedlich
-Wissenschaftliche Hausarbeit (offiziell);Zula (ugs., Abkürzung);Examensarbeit;Examen;Staatsexamensarbeit;Staatsarbeit (Kurzform);Zulassungsarbeit;Qualifizierungsarbeit
-recte (geh., auch ironisch);um nicht zu sagen (steigernd) (floskelhaft);anders ausgedrückt;mit anderen Worten;lassen Sie es mich anders formulieren (floskelhaft);oder, wie man (heute) auch sagt (Einschub);anders gesagt;besser gesagt;man könnte auch sagen;man könnte geradezu von ... sprechen (geh.)
-reinquetschen;reinpferchen
-Beißkorb;Bissschutz;Maulkorb
-deutsches Ventil;Alligator-Ventil (fachspr.);Blitzventil;Woodsventil (fachspr.);Normalventil;Dunlop-Ventil (fachspr.);Patentventil
-empfindlich;neuralgisch
-SV-Ventil (fachspr.);Sclaverand-Ventil;Prestaventil;Rennradventil (ugs.);Rennventil (ugs.);französisches Ventil (ugs., Hauptform)
-MTB-Ventil;Motorradventil;Autoventil;amerikanisches Ventil (ugs.);Schraderventil;Mountainbike-Ventil
-Glasfaserverstärkter Kunststoff;Fiberglas;GFK
-übergangslos;nahtlos;stufenlos
-Mett;Tatar (Rind);Hackepeter
-Fachkunde;Fachwissen;Fachkenntnis;Sachkunde;Expertenwissen;Spezialwissen;Expertise (geh.);Sachkompetenz;Fachkompetenz
-Basis;Grund;Fundament
-Versiertheit;Trainiertheit;Können;Routiniertheit;Kennerschaft;Geübtheit;Gewandtheit
-Angehöriger;Teilnehmer;Mitglied
-wohnsitzlos;ohne Dach über dem Kopf (ugs.);nicht sesshaft;obdachlos;unbehaust (geh.);ohne festen Wohnsitz;wohnungslos
-Phonetik;Lehre von der Lautbildung
-störend;irritierend;gewöhnungsbedürftig (ironisierend);befremdlich;disruptiv (geh.)
-kiffen (ugs., Hauptform);einen heizen (ugs.);buffen (ugs.);vernichten (ugs.);einen smoken (ugs.);Haschisch rauchen;haschen;barzen (ugs.)
-Größer-als-Zeichen;Größer-als;>;rechte spitze Klammer
-pro Zeiteinheit bearbeitete Aufträge;Datendurchsatz;Throughput (fachspr.)
-dienstbereit;hilfreich;dienstwillig
-Slot (fachspr.);Steckplatz
-Produktfälscher;Plagiator;Nachahmer
-gebrandmarkt;beschämt;befleckt
-zu gleichen Teilen;in gleichem Abstand;abstandsgleich;äquidistant (fachspr.)
-Erosion (fachspr., lat.);Abtragung
-Widmung;Schenkung;Dedikation
-(jemandem) die Pistole auf die Brust setzen (ugs., fig.);(jemanden) erpressen;(jemandem) das Messer an die Kehle setzen (fig.);(jemanden) (massiv) unter Druck setzen;(jemandem) ein Angebot machen, das er nicht ablehnen kann (Spruch, verhüllend)
-Hilfsschule (veraltet);Förderschule;Dackelschule (ugs., schwäbisch, veraltet);Klippschule (ugs., abwertend, variabel);Hammeruni (derb);Sonderschule
-mit der Kirche ums Dorf fahren (ugs., fig.);das wäre (ja auch) zu einfach gewesen (ugs., Spruch, ironisch);schwermachen;(unnötig) kompliziert machen;schwer machen;verkomplizieren;etwas von hinten durch die Brust und durchs / ins Auge machen (sprichwörtlich);die Kirche ums Dorf tragen (ugs., fig.);erschweren;Warum einfach, wenn es auch kompliziert geht! (ugs., Spruch)
-Disclaimer (fachspr.);Haftungsausschluss
-Tauschbörse;File Sharing;peer to peer
-wissenschaftliche Literatur;Fachliteratur
-behauchte Aussprache;Aspiration (fachspr.)
-schlaksig;linkisch;ungelenk
-datieren;mit einem Datum versehen
-Rebus;Bilderrätsel
-Neurolinguistisches Programmieren;NLP
-Computerlinguistik;NLP (fachspr.);Natural Language Processing (fachspr.);Maschinelle Sprachverarbeitung
-Hintergrund (fachspr.);Fond
-Differenzialrechnung;Differentialrechnung
-Probabilistik (fachspr.);Wahrscheinlichkeitsrechnung;Wahrscheinlichkeitslehre;Wahrscheinlichkeitstheorie
-Logik;Analytik;Dialektik
-l'art pour l'art (geh., franz.);Selbstzweck
-Blindenhund;Blindenführhund
-Rechtfertigung;Apologetik
-herausholen;hervorholen;(etwas) hervorkramen
-stauchen;zusammendrücken
-Konditorwaren;Backwaren;Konditorbackwaren
-über der Erdoberfläche;übererdig;oberirdisch
-unter der Erdoberfläche;unterirdisch;unter Tage;im Untergrund
-dranbleiben;nicht aufgeben;nicht nachlassen;(Ziel) nicht aus den Augen verlieren;weiterverfolgen;durchhalten (Hauptform);(Druck) aufrechterhalten;nicht schlappmachen (ugs.);dran bleiben (ugs.);nicht lockern;nicht ruhen und rasten (bis);am Ball bleiben (ugs., fig.);nicht locker lassen (ugs.)
-kalt erwischt werden (ugs.);(etwas) nicht glauben wollen;nicht eingestellt (gewesen) sein (auf);nicht bedacht haben;nicht vorbereitet (gewesen) sein (auf);(jemandem) bleibt die Spucke weg (ugs., fig.);nicht auf dem Schirm (gehabt) haben (ugs., fig.);(jemandem) fällt die Kinnlade herunter (ugs., salopp);mit etwas überhaupt nicht gerechnet haben (ugs.);(völlig) überrascht (sein) (Hauptform);überrascht werden (von);(etwas) nicht fassen können;(für jemanden / jemandem) sehr plötzlich kommen (ugs.);(jemandem) klappt die Kinnlade herunter (ugs., salopp);aus allen Wolken fallen (ugs., fig.);nicht gerechnet haben (mit)
-nachtragend;beleidigt;sich auf den Schlips getreten fühlen (fig.);sauer (ugs.);tödlich beleidigt (ugs.);pikiert (geh.);gekränkt;angepiekst (ugs.);schmollend;verletzt;eingeschnappt (ugs.)
-Schmach;Bloßstellung;Verächtlichmachung;Kompromittierung;Blamage;Peinlichkeit;Affenschande (ugs.);Gesichtsverlust;Schande
-zweizeilig;biserial (veraltet);zweireihig
-Pharisäer (religiös);Hypokrit (geh., bildungssprachlich, veraltet);Heuchler;falscher Fuffziger (ugs., fig.);Scheinheiliger
-(sich) zeigen;offenbar werden;(sich) entpuppen (als) (negativ);(sich) entlarven (als);(sich) herausstellen (als);sein (ugs.);(sich) herauskristallisieren;deutlich werden (es);(sich) offenbaren;(sich) erweisen (als);klar werden (es)
-Deskriptor;Kennwort
-Halbzeit;Runde;Durchgang;Spielabschnitt;Drittel (Eishockey);erstes (zweites, drittes usw.) Rennen;erster (zweiter, dritter usw.) Lauf;Partie (Sport)
-besinnlich;beschaulich;kontemplativ;versunken
-hämisch;sardonisch;schadenfroh;fratzenhaft;boshaft
-böse;unheilvoll;finster;sinister
-peinlich berührt;entrüstet;empört;indigniert
-bagatellisieren;als unbedeutend hinstellen;verniedlichen
-Knäuel;Sammlung;Bündel;Konvolut
-schwermütig;elegisch;klagend;wehmütig
-Perigon (fachspr.);Blütenhülle;Perigonium (fachspr.);Perianth
-Herzbeutel;Perikard (fachspr.)
-Muskellähmung (ugs.);Panplegie (fachspr.)
-zwischenkirchlich;ökumenisch;überkirchlich
-Gender Studies;Frauen- und Geschlechterforschung
-bewährt;brauchbar
-mehr als gut wäre;übergenug;über...;bis zum Gehtnichtmehr (ugs.);bis der Arzt kommt (ugs., fig.);bis zum Abwinken (ugs., fig.);bis zum Umfallen (ugs., fig.);mehr als gut tun würde;bis die Haare bluten (ugs., fig.);ohne Ende (ugs.);überreichlich;bis es jemandem zu den Ohren (wieder) herauskommt (ugs.);bis zum Überdruss;bis zum tz (ugs., veraltend);bis zum Erbrechen (ugs., fig.);im Übermaß;mehr als genug;ad nauseam (geh., lat.);bis zur Vergasung (derb, fig., veraltend);bis zum Tezett (ugs., veraltend)
-Eichung;Messung;Justierung;Ausrichtung auf ein Maß;Kalibration;Justage
-passive Waffe;Schutzwaffe
-Kommunikationslosigkeit;Sprachlosigkeit
-Sprachlosigkeit;Stummheit
-(sich) wiederfinden (in);(sich) identifizieren (mit)
-wie zu erwarten (war);erwartungsgemäß;trivialerweise;selbstverständlich;logischerweise (ugs.);gewohnt (Adverb);natürlich;naturgemäß;wenig überraschend;wie üblich;wen wundert's (Einschub) (geh.);verständlicherweise;natürlicherweise;der Erwartung entsprechend;erwartungskonform;den Erwartungen entsprechend;wie erwartet;erwartbar
-Linux-Pinguin;Tux
-Neckerei;Hänselei (ugs.);Frotzelei (ugs.);Schelmerei;Fopperei (ugs.);Häkelei (ugs., österr.)
-mehrdeutig;widersprüchlich
-Orangensaft;O-Saft (ugs.)
-Nicht-mehr-weiter-Wissen;Verlegenheit;Ratlosigkeit;Aporie (geh.)
-Syllogismus (fachspr.);logischer Schluss;aus zwei Prämissen gezogener logischer Schluss;vom Allgemeinen auf das Besondere
-Autokovarianzfunktion;Autokorrelation
-Solipsismus;Egoismus;Bewusstseinsinhalt (ugs.)
-Rückgängigmachung;Rücktritt;Wandlung (fachspr.)
-Wandlung;Transsubstantiation (fachspr.)
-einen Termin festlegen;terminieren
-liquidieren;abrechnen;eine Rechnung stellen
-Fax;Telefax;Fernkopierer;Faxgerät;Telefaxgerät
-Verwaltungsgemeinschaft;Amtei (schweiz.);Amtsbezirk;Amt
-Amtsleitung;Teilnehmeranschlussleitung;Letzte Meile (ugs.)
-Amt;Zunft
-Zeichen;Schild
-Rollgabelschlüssel;Verstellschlüssel;Engländer (ugs.);Franzose (ugs.)
-Erfindungspatent;Patent
-Kapitänspatent;Patent
-Patent;Offizierspatent
-Geschmacksmuster;Designpatent;Geschmackmuster
-Netnews;Usenet;NNTP
-Diskussionsforum (Hauptform);Newsgroup (Anglizismus);Brett (ugs., Jargon);Nachrichtengruppe;Schwarzes Brett (Anglizismus, veraltend);Gruppe
-Nordatlantikpakt;NATO-Vertrag;Nordatlantikvertrag;Atlantik-Pakt
-Pakt;Vertrag;Konvention;Übereinkommen;Kontrakt
-Immatrikulation;Einschreibung
-Republik;Freistaat
-Trojaner (ugs.);Trojanisches Pferd
-Schadprogramm;Schadsoftware;Malware (engl.)
-Virus;Computervirus
-Evidenz;Nachweis;Anzeichen
-Schnüffelsoftware;Spyware (engl.);Spionagesoftware
-Katze;Felidae (Familie) (fachspr.);Katzen (Familie) (fachspr.)
-Mail (ugs.);E-Mail-Nachricht;E-Mail;elektronischer Brief (ugs.)
-Short Message (engl.);Kurznachricht;SMS (Abkürzung, engl.)
-Short Message Service (engl.);SMS (Abkürzung, engl.);Kurznachrichtendienst;Dienst für Kurznachrichten
-Halbling (ugs.);50-Cent-Stück
-Gedichtform mit schwermütiger Stimmung;Klagegedicht;Elegie
-gleichzeitig vorliegende weitere Erkrankung;Komorbidität (fachspr.);Begleiterkrankung
-entschlacken;verkleinern
-Marille (österr.);Malete (hessisch, pfälzisch, rheinisch);Aprikose (bundesdeutsch, schweiz.)
-Meertrübeli (schweiz.);Johannisbeere;Ribisel (österr.);Träuble (schwäbisch)
-Fernbedienung;Umschalter (ugs.);Commander (ugs.);Fernsteuerung
-Edel-Pflaume;Reneklode;Ringlotte;Rundpflaume;Reineclaude
-Streuwert;Fingerprint;Hashwert
-Braunstein;Mangandioxid
-Lokschuppen;Lokremise;Heizhaus (österr.)
-Käsekohl;Blumenkohl;Blütenkohl;Traubenkohl;Karfiol (österr.)
-Sackrodel (österr.);Sackkarre
-Weichselkirsche;Prunus cerasus (fachspr., botanisch);Weichsel;Sauerkirsche
-Marina;Yachthafen
-Rodelschlitten;Rodel
-Presslufthammer;Drucklufthammer
-Turbomaschine;Kreiselmaschine;Strömungsmaschine
-Turbinen-Luftstrahltriebwerk;Turbinen-Strahltriebwerk;Turbo-Strahltriebwerk;Turbo-Luftstrahltriebwerk;Strahltriebwerk;Düsentriebwerk;Strahlturbine
-Ringschuppen;Rundlokschuppen;Ringlokschuppen
-Samtapfel;Eibisch
-Foamglas;Schaumglas
-Teebeutel;Teesackerl (ugs.)
-Cantharellus (fachspr., botanisch);Pfifferling(e)
-Speckgrieben;Grieben;Grammeln (österr.)
-Sprossenkohl (österr.);Rosenköhlchen (Diminutivum);Brabanter Kohl;Brassica oleracea var. gemmifera (fachspr., lat.);Kohlsprossen (Plural, österr.);Rosenwirsing;Rosenkohl (Hauptform);Brüsseler Kohl
-Kren (österr.);Meerrettich
-Powidl (österr.);Pflaumenmus
-Sri Lanka;Ceylon (veraltet);Demokratische Sozialistische Republik Sri Lanka
-Bittleihe;Prekarium;Gebrauchsüberlassung
-Drehkolbenmotor;Kreiskolbenmotor;Wankelmotor
-Vorspann (ugs.);Vorspanntriebfahrzeug;Vorspannlok (Kurzform);Vorspannlokomotive
-Dechiffrierung;Entschlüsselung
-Blockchiffre;Blockverschlüsselung
-Stromchiffre;Flusschiffre;Stromverschlüsselung
-Zwischentriebfahrzeug;Zwischenlok (Kurzform)
-Nachschieben;Nachschiebebetrieb
-Servitut (fachspr.);Dienstbarkeit
-enteisen;abtauen;abeisen (österr.)
-Spüle (Hauptform);Abwaschbecken (schweiz.);(die) Abwasch (österr.);Geschirrspülbecken;Schüttstein (schweiz.);Spülbecken
-einstellen;adjustieren;anpassen;eichen
-befestigen;anpappen (ugs.);anpicken (ugs., österr.);ankleben;anheften;ankitten;ankleistern
-Apfelmus;Apfelkoch (österr.);Apfelkompott;Apfelbrei
-Holunder;Holler;Holder
-Senn;Almhirte (Hauptform);Halter (bayr.);Brentler (kärntnerisch);Almerer (Oberbayern);Almer (österr.);Senner;Ochsner (regional);Älpler (schweiz.);Küher (historisch, schweiz.)
-Ausgeding (österr.);Austrag (bayr.);Ausnahm (süddt., österr.);Altenteilerhaus;Altenteil
-Aviso (österr.);Benachrichtigung;Ankündigung;Avis
-Chiffre;Geheimtext;Schlüsseltext;Ciphertext;Chiffretext;Kryptotext;Kryptogramm;Chiffrat
-beschimpfen;anmachen;beflegeln (österr.)
-Bedienerin (österr.);Zugehfrau;Reinigungsfrau;Aufwartefrau
-Hufstück (österr.);Short Loin (engl.);Strip Loin (engl.);Beiried (österr.);Zwischenrippenstück;Schossen (tirolerisch);Roastbeef;Lende (regional)
-Überweisungsschein;Einzahlungsschein (schweiz.);Zahlschein;Erlagschein (österr.);Zahlungsanweisung (österr.)
-Fallott (ugs., österr.);Ganeff (fachspr., Jargon, Rotwelsch, selten, veraltend);Spitzbube (ugs.);Übeltäter;Schlawuzi (ugs., bayr.);Schlawack (ugs.);Gauner;Strauchdieb;kleiner Fisch (ugs., fig.);Kleinkrimineller
-Grüne Bohne;Fisole (österr.);Strankerl (österr.);Phaseolus vulgaris (fachspr., griechisch, lat.);Gartenbohne;Schnittbohne
-Fotzhobel (ugs., bayr., österr.);Mundharmonika;Fotzenhobel (ugs., bayr., österr.)
-Sommersprossen;Guckerschecken (österr.);Märzenflecken (schweiz.);Gugerschecken (österr.);Sommerflecken
-Hetscherl (ugs., österr.);Hagebutte
-Hosensack (schweiz., österr.);Hosentasche
-Kluppe (ugs., österr.);Wäscheklammer
-angenehm;kommod (geh., franz.);bequem
-Krampen (österr.);Flachkreuzhacke;Spitzhacke
-Kukuruz (österr.);Mais
-Kronleuchter;Luster (österr.);Lüster (veraltet)
-Schulabgänger (Hauptform);Abiturient (bundesdeutsch);Schulabsolvent;Maturant (österr.);Maturand (schweiz.)
-Mehlspeise (österr.);Süßspeise
-Mesmer (österr.);Messner (österr.);Kirchendiener;Kirchner;Sakristan;Sigrist (schweiz.);Mesner (österr.);Siegrist (schweiz.);Küster
-Schlagobers (österr.);Schlagsahne;Schlagrahm
-Patschen (österr.);Reifenpanne;Reifendefekt
-Konventionsstrafe;Vertragsstrafe;Konventionalstrafe;Geldbuße;Pönale (österr.)
-Zepter;Szepter (österr.)
-Klatsche (ugs., bundesdeutsch);Ohrlasche;Watsche(n) (ugs., bayr., österr.);Knallschote (ugs., bundesdeutsch, regional, salopp);Backpfeife (bundesdeutsch);Schelle (bundesdeutsch);Wangenstreich (geh., veraltet);Maulschelle (bundesdeutsch);Dachtel (ugs., österr.);Tätschen (ugs., österr.);Fotze(n) (derb, bayr., österr.);Ohrfeige (Hauptform);Backenstreich (geh., kirchlich, veraltet)
-Reitschule (schweiz., süddt.);Ringelbahn (österr.);Karussell;Ringelreiten (veraltet);Rösslispiel (ugs., schweiz.);Ringelspiel (österr.);Rösslibahn (schweiz.)
-Rutschbahn (fig.);schlüpfrig (ugs.);glatt;glitschig;rutschig;spiegelglatt
-E-Lok (Kurzform);Elektrotriebfahrzeug;Elektrolok (Kurzform);Elektrolokomotive
-Dampfross (ugs.);Dampflokomotive;Dampflok (Kurzform)
-Dieseltriebfahrzeug;Diesellok (Kurzform);Diesellokomotive
-Rangierbegleiter;Verschubbediensteter;Rangierer;Verschieber
-Siphon;Geruchsverschluss
-Pufferwehr;Prellbock;Puffer
-Wartehäuschen;Wartekoje (österr.)
-Aufnahmegebäude (schweiz., österr.);Empfangsgebäude;Aufnahmsgebäude (österr.)
-Bundesbahnbediensteter;Eisenbahner;Bahnarbeiter;Bahner (ugs., Jargon);Eisenbahnbediensteter;Bundesbahner;Bahnangestellter
-Savant-Syndrom;Inselbegabung
-auf Keif(e) (ugs., ruhrdt., westfälisch);abbezahlen;auf Raten kaufen;abstottern;auf Pump kaufen (ugs.);Raten zahlen
-Rufumleitung;Rufweiterleitung
-elektronische Unterschrift;elektronische Signatur;digitale Signatur
-Grappa;Trester;Tresterbrand;Tresterschnaps
-Verdauerli (schweiz.);Zerhacker (norddeutsch);Digestif (franz.);Verdauungsschnaps;Verrisserle (alemannisch);Absacker (norddeutsch)
-Allheilmittel;Panazee (geh.);Patentrezept;Stein der Weisen;Wunderwaffe;einfache Lösung(en);Wundermittel;Patentlösung
-Koi (japanisch);Brokatkarpfen
-ernüchternd;frustrierend;desillusionierend;enttäuschend
-(regelmäßig / oft) besuchen;(irgendwo) Stammgast sein;oft kommen (ugs.);häufig unser Gast sein (variabel);frequentieren;häufiger Gast sein;(irgendwo) häufig verkehren;häufig besuchen
-(eine) Ausnahme darstellen;dünngesät;Seltenheitswert haben;rar gesät;selten (sein / vorkommen);dünn gesät;(sich etwas) rot im Kalender anstreichen (können) (ugs., fig., variabel)
-Anlage (ugs.);Musikanlage (ugs.);Hi-Fi-Anlage;Stereoanlage
-frischer Mensch;Sanguiniker;lebhafter Mensch
-lebendig;frisch
-Kirchenmitglied;Gemeindemitglied
-Heißluftballon-Wettbewerb;Heißluftballon-Treffen;Montgolfiade
-Montgolfière (fachspr.);Heißluftballon;Ballon (ugs.);Montgolfiere (fachspr.)
-Ballonfahren;Ballonsport
-ungewöhnlich;selten;außergewöhnlich;exotisch
-Diode;Röhrendiode;ungesteuerter Gleichrichter;Vakuumdiode;Zweipolröhre
-Wärmezustand;Wärmegrad;Temperatur
-Gott des Donners;Donnergott;(der erste) Sohn des Gottes Odin;Thor
-Z-Diode;Zenerdiode;Zener-Diode
-Klopapier;Toilettenpapier (Hauptform);WC-Papier;Scheißhauspapier (derb)
-Spannung;elektrische Spannung
-Halbstiefel;Stiefelette
-Betreuungsunternehmen;Kundendienst;Unterstützer;Dienstleister;Serviceunternehmen
-Wandbelag;Wanddekor;Wandverkleidung;Tapete
-Rasierapparat;Elektrorasierer;Trockenrasierer
-Verzerrung;Befangenheit
-längst nicht;weit davon entfernt (zu + Infinitiv) (geh.);lange nicht;ganz und gar nicht;bei weitem nicht (Hauptform)
-je;in Abhängigkeit (von)
-Nachschlüssel;Universalschlüssel;Lockpick;Dietrich
-Erbanlagen;Genom;Erbsubstanz;Erbgut;Erbinformation(en) (ugs.);Gen(e)
-Textiltapete;Stofftapete;textiler Wandbelag
-Fototapete;Bildtapete
-Femidom;Kondom für die Frau
-Molekulargewicht;Molekülmasse
-molare Masse;Molmasse
-Rechentafel;Abakus;Rechenbrett
-Tränen der Götter (mythologisch);Bernstein;fossiles Harz
-parallaktische Sekunde;pc (Einheitenzeichen);Parallaxensekunde;Parsec
-Ausdünstung;schlechter Geruch;Gestank;übler Geruch;Mief (ugs.);schlechte Luft;strenger Geruch;Geruchsbelästigung;Geruchsbildung
-den Geruchssinn betreffend;olfaktorisch
-14. Februar;Valentinstag;14. Feber (österr.)
-zerebrales Krampfleiden;Anfallsleiden;Krampfleiden (veraltet);Fallsucht (veraltet);Epilepsie (Hauptform)
-Leitindex (ugs.);erste Börsenliga (ugs.);DAX (Abkürzung);Deutscher Aktienindex
-Sechsundsechzig;Schnapsen
-Sprachbox;Voicemailbox;Voice-Mailbox
-Sternkurve;Astroide
-Herzkurve;Kardioide
-Cornu-Spirale;Klotoide;Spinnkurve;Klothoide
-logarithmische Spirale;gleichwinklige Spirale
-semikubische Parabel;Neilsche Parabel
-Verfolgungskurve;Radiodrome
-Treidelkurve;Traktrix;Schleppkurve;Ziehkurve
-Zissoide;Cissoide;Efeukurve;Kissoide;Zissoide des Diokles
-Zeitkunde;Chronologie
-Risk Management;Risikomanagement
-Dachgesellschaft;Holding-Gesellschaft;Unternehmensverbund;Holding
-Quality Management (engl.);Qualitätsmanagement
-urbaner Mythos;urbane Legende;Großstadtlegende;moderne Sage;moderner Mythos;urbanes Märchen;urban legend (fachspr., engl.);Wandersage;Wandermärchen
-Desertifikation;Desertation;Sahel-Syndrom;Verwüstung;(fortschreitende) Wüstenbildung
-Reserverad;Ersatzrad;Notrad (schweiz.);Reservereifen;Reservepneu;Ersatzreifen
-Schutzschild;Schutzschirm
-Kupido;(römischer) Liebesgott;Amor;Gott der Liebe;Cupido
-Südlicht;Südpolarlicht;Aurora australis
-Wetterschicht;Troposphäre
-Raumfrachter;Raumtransporter
-ungeschlechtliche Vermehrung;asexuelle Vermehrung;vegetative Vermehrung (Gärtnersprache) (fachspr.);Klonen
-Nullmeridian;Null-Längengrad;Längengrad Null
-Meridian;geografische Länge;Längenkreis;Längengrad (veraltet);geographische Länge;Mittagskreis
-geographische Breite;geografische Breite;Latitüde (fachspr.);Breitengrad (veraltet)
-Äquator;Breitengrad Null
-trockenliegendes Flussbett;Trockental;Wadi
-astronomisches Observatorium;Sternwarte
-Busbahnhof;Omnibusbahnhof;Busterminal;ZOB (fachspr.);Bushof;Autobusbahnhof
-Flusskraftwerk;Laufkraftwerk;Laufwasserkraftwerk
-Strombörse;Stromhandelsbörse
-Tag der Arbeit;1. Mai;Maifeiertag;Erster Mai
-Rauchwarnmelder;Rauchgasmelder;Rauchmelder
-Hairstylistin (weibl.);Coiffeuse (schweiz., weibl.);Coiffeurin (schweiz., weibl.);Friseurin (weibl.);Frisörin (weibl.);Hair-Stylistin (weibl.);Haarschneiderin (ugs., weibl.);Friseuse (ugs., weibl.);Frisöse (ugs., weibl.)
-Nymphomanin;Mannstolle;Sexsüchtige
-Hundstrümmerl (ugs., österr.);Hundekot;Hundehaufen;Hundescheiße (ugs.);Tretmine (ugs., fig., scherzhaft);Hundeexkremente (geh.);Hundekacke (ugs.)
-Laube;Schrebergarten;Familiengarten (schweiz.);Heimgarten;Parzelle (regional);Kleingarten
-Tragflügelboot;Tragflächenboot
-Telex;Fernschreiben
-Börsegang (österr.);IPO (engl.);Gang an die Börse;Börsendebüt;going public (engl.);Aktiendebut;Börsengang
-FOSS (fachspr., Abkürzung);Open-Source-Software;freie und offene Software;FLOSS (fachspr., Abkürzung);Freie Software
-Frontantrieb;Vorderradantrieb
-Heckantrieb;Hinterradantrieb
-die (n-te) Wurzel ziehen aus;radizieren;wurzelziehen
-Ramsen;Zigeunerlauch (ugs.);Waldherre;Waldknoblauch (ugs.);Latschenknofel (ugs.);Knoblauchspinat;Hexenzwiebel (ugs.);wilder Knoblauch;Wilder Knoblauch (ugs.);Wilder Knofel (ugs.);Rinsenknoblauch;Ränsel (ugs.);Allium ursinum (fachspr., lat.);Waldlauch (ugs.);Bärenlauch (ugs.);Hundsknoblauch;Bärlauch (Hauptform)
-Wollmaus;Gewölle;Wollflocke;Staubfluse;Fluse;Nato-Maus (Jargon);Staubflocke;Staubmaus;Lurch (ugs., österr.)
-Postangestellter;Postler (ugs.);Postbeamter;Postbediensteter
-inertes Gas;reaktionsträges Gas;Inertgas
-Windenergieanlage (fachspr.);Windkraftwerk (fachspr.);Windrad (ugs., Hauptform);Windkraftkonverter (fachspr.);Windkraftanlage (fachspr.);Windanlage (ugs.)
-Kragarm;Kragträger;Kragbalken
-Sgraffito;Kratzputz;Scraffito
-Urtext;Original;Urfassung;Urschrift;Originaldokument
-bewegungsunfähig;gelähmt;paralysiert
-Triton;griechischer Meeresgott
-faschieren (österr.);durch den Fleischwolf drehen
-Freischar;Freiwilligentruppe;militärischer Freiwilligenverband
-islamische Pilgerfahrt nach Mekka;(früher vielfach:) (die) Hadsch(die) Hadsch;(der) Hadsch;(der) Haddsch
-Bonvivant (geh., veraltend);Partylöwe;Lebemann;Gesellschaftslöwe;Salonlöwe (ugs.);Playboy (engl.)
-Qualitätsprodukt;Qualitätsware;hochwertiges Produkt;Qualitätserzeugnis
-Reiterei;Reitertruppe;berittene militärische Einheit;Kavallerie
-Düsentreibstoff;Flugturbinenkraftstoff;Flugpetrol (schweiz.);Leichtöl;Leuchtöl;Leichtpetroleum;Turbinenpetroleum;Kerosin (ugs., Anglizismus, Hauptform);Leuchtpetroleum
-ohne Bargeld;bargeldlos;unbar;per Überweisung
-Alpenmütze (niederländisch);Pullmannkappe (österr.);Pullmankappe (österr.);Baskenmütze
-Fermenter;Bioreaktor
-Rommé;Rommee;Jolly (österr.)
-Schrebergartenverein;Kleingartenverein
-Kleingartenhäuschen;Schrebergartenhaus;Kleingartenhaus
-Tagebau;Tagbau (österr.)
-Ecke (ugs.);Eckstoß;Eckball;Corner (schweiz., österr.)
-Loschmidtsche Zahl;Loschmidtzahl;Loschmidt-Zahl;Avogadro-Zahl;Avogadro-Konstante;Avogadrozahl;Loschmidt-Konstante
-Hygrometer;Luftfeuchtigkeitsmesser
-Plancksches Wirkungsquantum;Planck-Konstante;Plancksche Konstante
-Caesar-Verschiebung;Caesar-Verschlüsselung;einfacher Caesar;Verschiebechiffre;Caesarchiffre;Shiftchiffre
-magnetische Aufzeichnung;Magnetaufzeichnung;MAZ
-First;Dachfirst;oberste Dachkante
-Dauerfrostboden;Permafrostboden
-Davidstern;Hexagramm
-Gemmologie;Wissenschaft von den Edelsteinen;Edelsteinkunde
-einrichten;mit Möbeln ausstatten;möblieren
-Steinkohlenteer;Karbolineum;Carbolineum
-(sich) absentieren (geh., veraltend);(sich) wegbewegen;(sich) fortbewegen;(sich) entfernen;Abstand nehmen;abrücken von (fig.);Abstand gewinnen
-fußläufig erreichbar (fachspr., Jargon);nur wenige Schritte (ugs.);um die Ecke (ugs.);in Gehnähe;zu Fuß erreichbar;zu Fuß zu erreichen;fußläufig zu erreichen (fachspr., Jargon)
-Notbremsung;Schnellbremsung;Gefahrenbremsung
-generatorische Bremse;E-Bremse (ugs.);Motorbremse;Generatorbremse
-plagiieren;kopieren;abschreiben;nachahmen
-aktenmäßig;urkundlich
-Unübersichtlichkeit;Vielschichtigkeit;Komplexität;Komplexitätsgrad
-Abnehmerkreis;Klientel;Kundschaft;Kundenkreis (Hauptform);Zielgruppe;Kundenstock (österr.);Kundenstamm
-für städtisches Leben charakteristisch (geh.);gebildet und weltgewandt;urban;metropolitan (geh.);weltmännisch;weltstädtisch;städtisch;für die Stadt (ugs.);weltläufig
-(sich) suhlen;schwelgen;(sich) wälzen
-Schalplatte;Schalungsplatte
-plündern;räubern;marodieren
-Glasbruchsensor;Glasbruchmelder
-Appetizer (engl.);Amuse-Gueule (geh., franz.);Vorspeise;Amuse-Bouche (geh., franz.);Appetithäppchen;Canapé (franz.);Häppchen;Mise-en-Bouche (franz.);Gruß aus der Küche;Kanapee
-Apero (schweiz.);Häppchen;Aperitif (franz.);Apéro (schweiz.);Kleinigkeit (ugs.);Apéritif;Appetitanreger
-Anfrage;Ersuchen;Erkundigung
-Kandidatur;Bewerbung;Anwartschaft
-Anspruch;Anrecht;Berechtigung;Anwartschaft;Aussicht
-Lösung des Knotens;Peripetie
-Ernsthaftigkeit;Schweregrad;Schwere;Schärfegrad
-US-Amerikaner afrikanischer Herkunft;Afroamerikaner;(US-)Amerikaner mit afrikanischen Wurzeln
-Ethnizität;ethnische Gruppe;Stamm (derb);Volk;Ethnie;Volksgruppe
-Metergewicht;Meterlast
-Altersgenosse;Gleichaltriger
-Dominica in Palmis (fachspr., lat.);Beginn der Karwoche;Sonntag vor Ostern;Palmsonntag
-Gründonnerstag;Heiliger Donnerstag;Weißer Donnerstag;Tag des letzten Abendmahls;Donnerstag vor Ostern;Palmdonnerstag;Hoher Donnerstag;Tag vor dem Karfreitag
-Freitag vor Ostern;Karfreitag
-schade (ugs.);bedauerlich;bedauernswert;ein Jammer (sein);desolat;deplorabel;beklagenswert;betrüblich (geh.);jammerschade
-Kommutator;Stromwender;Kollektor
-Gleichgestellter;Ebenbürtiger
-vollwertig;gesund
-Gradabzeichen (schweiz.);Rangabzeichen (veraltet);Dienstgradabzeichen;Distinktion (österr.)
-bremsend;negativ wirkend;kontraproduktiv;hindernd;störend;nicht hilfreich (ironisierend, verhüllend);nicht ratsam;hinderlich;widersinnig;kontraindiziert (med.) (fachspr.)
-Besinnung;Geistliche Übung;Andacht;Besinnlichkeit;Meditation
-Fahrtrichtungsanzeiger;Blinker;Blinkleuchte;Blinklicht (ugs.)
-kontemplativ;besinnlich;meditativ
-zuungunsten;auf dem Rücken (von) (ugs.);zu jemandes Schaden;auf Kosten (von);zu Lasten;zum Nachteil (von);zu jemandes Nachteil;zu Ungunsten
-spritzen;eine Spritze verabreichen
-Gestank machen;Gestank erzeugen;stänkern
-Besinnlichkeit;Nachdenklichkeit;Nachsinnen;Reflexion
-Suspension;Aussetzung;Unterbrechung;Aufhebung
-trocken;ausdruckslos;dumpf;unbewegt
-Grabstätte;Mausoleum
-Tormann;Torhüter;Keeper (Jargon, engl.);Schlussmann (ugs.);Torwart;Goalie (ugs., bayr., österr.)
-Torjäger (ugs.);Stürmer
-Schneegriesel;Griesel;Graupel(n)
-Blitz und Donner (und Regen);Ungewitter (süddt.);Donnerwetter (ugs.);Gewitter;Unwetter
-hinzufügen;füttern (Computer mit Daten);erfassen;eintippen;eintragen;einpflegen;eingeben
-Kralle;Nagel;Fingernagel
-Maulkorb (fig.);Meinungsäußerungsverbot;Mundtotmachen;Sprechverbot;Redeverbot;Knebelung
-weinrot;bordeauxrot
-Chiffrenummer (in Anzeigen);Chiffre
-überbrühen;abwällen;blanchieren
-Gläubiger;Theist;gläubiger Mensch
-Dachshund;Dackel;Teckel
-Handhebelwagen;Draisine
-Haftschale;Kontaktlinse;Haftlinse
-Leuchtdiode;LED;Lumineszenzdiode
-entscheidende Rolle;Schlüsselfunktion;Kernfunktion;Hauptfunktion;Schlüsselposition;Hauptrolle;Schlüsselrolle
-Swastika;Hakenkreuz
-Kulminationspunkt (fachspr.);Gipfelpunkt;Kulmination (geh.);Scheitelpunkt;Blütezeit (fig.);Höhepunkt;Optimum;Maximum;Spitze;Zenit;Blüte (fig.);Klimax (fachspr.);Gipfel
-mäusisch;murin (fachspr.);maushaft
-Menopause (fachspr.);letzte Regelblutung
-NMR-Spektroskopie (engl.);NMR (Abkürzung, engl.);Kernspintomographie;MRT;Kernspin (ugs., Kurzform);MRI (engl.);MR;Magnetresonanztomografie;Kernspinresonanztomographie;Magnetresonanztomographie;Kernspintomografie;Kernspinresonanztomografie
-bildgebendes Verfahren;Bildgebung;bildgebende Diagnostik
-regelmäßige Konjugation;schwache Konjugation
-Haschzigarette;Joint (Jargon, engl., Hauptform);Dübel (ugs.);Sportzigarette (ugs.)
-sexuell freizügig;promisk;promiskuitiv
-abspritzen (derb);in die Muschel rotzen (vulg.);ejakulieren (fachspr.);abwichsen (vulg.);(jemandem) geht einer ab (ugs.);(einen) Samenerguss haben;zum Samenerguss kommen;kommen (ugs.);sich ergießen (geh.)
-Schuhcreme;Wichse;Schuhputzcreme;Schuhkreme (alte Schreibung bis 2011);Schuhpflegecreme
-'Ndrangheta;Mafia;Camorra;ehrenwerte Gesellschaft (ugs.);Cosa Nostra
-Tippse (derb);Schreibkraft;Vorzimmerdrachen (derb);Bürokraft;Vorzimmerdame;Sekretärin
-differenzierbar;unterscheidbar;distinkt
-Freifahrtschein (ugs., fig.);Lizenz;Freibrief (fig., negativ);Blankovollmacht;Persilschein (ugs., fig.);Blankoscheck (ugs., fig.);Carte blanche (geh.)
-tschutten (schweiz.);schutten (ugs., regional);buffen (ugs.);fußballen (ugs., regional);bäbbeln (ugs., regional);bolzen (ugs.);pöhlen (ugs., ruhrdt.);Fußball spielen;pölen (ugs., regional);kicken
-Jöggeli (ugs., schweiz.);Kicker;Töggele (ugs., schweiz.);Wuzzeln (ugs., österr.);Tischfußball
-kardiovertieren (fachspr.);defibrillieren
-Bitterschnaps;Wermutspirituose;Absinth;Absinthe;grüne Fee (ugs.)
-Katamaran;Doppelrumpfboot;Zweirumpfboot
-zeugen;machen
-vernichtend;erdrückend
-willfährig;allzu nachgiebig;fügsam;blind gehorchend;allzu willig;gefügig
-(sich) erhitzen (an);künstlich aufregen;alterieren (geh.);echauffieren (franz.)
-belästigen;ärgern;feigeln (ugs., Salzburg);reizen;sekkieren (österr.)
-Haufen;Masse;Klumpen
-Trimaran;Dreirumpfboot
-in Wirklichkeit nicht;(nur) zum Schein;scheinbar (ugs.);(nur) auf den ersten Blick (... scheinend);vermeintlich;Schein...
-virtuell;scheinbar;gefühlt;nicht real
-menschlich machen;vermenschlichen;humanisieren
-zergliedern;modularisieren;ausbauen;in einzelne Komponenten zergliedern
-Leidenschaft;Hingabe;Liebe
-schwelen;qualmen;rußen
-Veräppelung (ugs.);Überzeichnung;Übertreibung;Glosse;Parodie;Persiflage;Verspottung;Satire;humoristische Verarbeitung;Überspitzung;Karikatur
-konnivieren (geh.);(sich) nicht wehren (gegen);(die) Füße stillhalten (ugs., fig.);(widerspruchslos) hinnehmen;einstecken;stillhalten;mitmachen (ugs.);schlucken;tolerieren;(es) nicht auf einen Streit ankommen lassen (wollen) (variabel);(sich etwas) gefallen lassen;dulden;nicht protestieren;in Kauf nehmen;(sich etwas) bieten lassen;(sich) nicht widersetzen;Nachsicht üben;verschmerzen;leisetreten
-zulassen;ein Auge zudrücken (ugs., fig.);tolerieren;(ich will dann) mal nicht so sein (ugs.);über etwas hinwegschauen;über etwas hinwegsehen;fünf(e) gerade sein lassen (ugs., sprichwörtlich);dulden
-Missbrauch;Abusus (fachspr.);riskanter Substanzkonsum
-unselbstständig;abhängig (von)
-falscher Gebrauch;Missbrauch;Schindluder (ugs.);Zweckentfremdung
-Routine;Erfahrungen (Plural);Geübtheit;Wissen;Praxis;Kenntnis;Sicherheit;Kenntnisse (Plural);Erfahrung;Übung;Know-how
-sternbezogen;sternförmig;stellar
-engstirnig;mit Scheuklappen;kleinkariert
-mit kleinen Karos;kleinkariert;klein kariert
-Diafilm;Diapositivfilm;Umkehrfilm
-aufeinanderfolgend;sequentiell (geh.);aufeinander folgend;konsekutiv;fortlaufend
-Zerstörung;krankhafter Verbrauch;Depletion (fachspr.);Entleerung
-Befolgung;Compliance;Einhaltung
-irren (durch);herumvagabundieren;herumirren;herumgeistern (ugs.);geistern (ugs.);vagabundieren;umgehen;herumschwirren (ugs.)
-fälschen;faken (ugs., engl.);manipulieren;klittern;schönen;verfälschen;frisieren (ugs.)
-mit finsterer Entschlossenheit;energisch;entschieden (Hauptform);erklärt;bestimmt;mit Entschiedenheit;kategorisch;finster entschlossen;entschlossen (Hauptform);resolut;mit Bestimmtheit;rigoros;gegen alle (/ viele) Widerstände;dezidiert (geh.);kompromisslos;unmissverständlich
-Veränderung;Eingriff (in)
-Entzug;Entgiftung
-Lehrmeinung;Paradigma;Leitbild
-Paradigma;Erzählung
-Flugblatt;Flugschrift (geh.);Flyer (engl.);Flugzettel (österr.)
-bündeln;zusammenfassen;zentralisieren;zusammenführen
-eklatant;hervorspringend;hervorragend;herausstehend;hervorstehend;salient;hervorstechend
-sanieren (fachspr., medizinisch);gesund machen;heilen;kurieren;wiederherstellen
-Verhältnismäßigkeit;Augenmaß (ugs.);Relativität
-Limnologie;Wissenschaft der Binnengewässer
-Zirkelschluss;Kreisschluss;Circulus vitiosus (geh., lat.);Zirkel (ugs.);Teufelskreis;Diallele (geh.);logischer Zirkel;Hysteron-Proteron (geh.);Zirkelbeweis
-Pointer;Zeigergerät
-qua;als
-sauer verdient (ugs.);mühsam verdient;schwer verdient
-Schutzregion;Schutzgebiet;Reservat
-verbrecherisch;kriminell;auf der schiefen Bahn (ugs.);delinquent;straffällig
-deviant;abweichend
-Blut;Lebenssaft (ugs., poetisch);Schweiß (fachspr., Jargon, Jägersprache);roter Saft (ugs., scherzhaft)
-Verstopfung von Hohlräumen;Obliteration
-tätliche Auseinandersetzung;Handgreiflichkeit;Tätlichkeit;körperliche Auseinandersetzung
-betäubt;verführt;willenlos
-Naivität;Blauäugigkeit;Leichtsinnigkeit;Leichtgläubigkeit
-Kleinstversicherung;Mikroversicherung
-Gebärdenspiel;Gestenspiel;Pantomime (Hauptform)
-auffüttern;mästen;füttern;stopfen
-Helminthiasis (fachspr.);Wurmerkrankung;Filaria
-Flecktyphus;Fleckfieber (Hauptform);Kriegspest;Typhus fever (engl.);Läusefieber (ugs.);Typhus exanthemicus;Faulfieber;Lazarettfieber;Läusefleckfieber
-brütende Hitze;feuchtwarme Hitze;wie in der Sauna (ugs.);unerträgliche Hitze;drückende Hitze (Hauptform);Gewitterstimmung;bleierne Hitze;tropische Hitze;tropisches Klima;Schwüle;erdrückende Hitze;Bruthitze;wie in einem Brutkasten (ugs.)
-Geschossdurchmesser;Kugeldurchmesser;Kaliber
-Vorstadium;Vorstufe
-unzertrennlich;atomar;Hand in Hand gehen (mit);monadisch;untrennbar;in einem;unteilbar;unzerteilbar;unauftrennbar
-Reassekuranz;Gegenversicherung;Rückversicherung (Vertragsverhältnis)
-Absicherung;Abdeckung;Sicherheiten
-Investmentfonds;Sondervermögen;Fonds
-räuchern;selchen (österr.)
-Gesülze (ugs.);Lobhudelei (ugs.);Schmus;Lobtirade(n) (geh., abwertend);schöne Worte;Süßholzraspelei (fig.);Lobestirade(n) (abwertend);Schöntuerei;Schmeichelei (Hauptform);Beweihräucherung
-Olivenbaum;Echter Ölbaum
-au contraire (franz.);e contrario (lat.);im Gegenteil
-Bistro;(kleines) Lokal;Café
-Aura;Glanz;Strahlenkranz;Heiligenschein;Strahlenschein;Glorienschein;Nimbus;Gloriole;Aureole;Korona
-Korona;Strahlenkranz
-Schulterklappe;Achselspange (österr.);Rangabzeichen;Epaulette;Epaulett
-Wassersturz;Katarakt;Kaskade;Wasserfall;Katarrhakt
-Katarakt;Katarrhakt;Stromschnelle
-Kinderfahrrad;Fahrrad für Kinder;Kindervelo (schweiz.);Kinderrad
-Damenvelo (schweiz.);Frauenfahrrad;Frauenrad;Damenrad;Damenfahrrad
-Herrenvelo (schweiz.);Männerrad;Herrenrad;Männerfahrrad;Herrenfahrrad
-Wahrhaftigkeit;Offenheit;Ehrlichkeit;Wahrheit
-Thesauros;Schatzhaus
-Staatsbank;Nationalbank
-virtuelle Geschichte;Alternativ-Geschichte;Uchronie;imaginäre Geschichte;potentielle Geschichte;Allohistoria;Parahistorie;Alternativweltgeschichte;ungeschehene Geschichte;Eventualgeschichte
-Bereicherung;Amtsmissbrauch
-Fernseher;Fernsehkonsument;Fernsehzuseher;Fernsehzuschauer
-Paternosteraufzug;Personenumlaufaufzug (fachspr.);Paternoster;Umlaufaufzug (fachspr.)
-charakterlos;aalglatt (fig.);schleimig (ugs.);prinzipienlos;angepasst;(sich) schnell und bedenkenlos anpassend;unkritisch;stromlinienförmig (fig.);opportunistisch;konformistisch;ohne Rückgrat;rückgratlos
-Herleitung;deduktiver Schluss;Ableitung;Deduktion;deduktive Methode
-komprimierte Luft;Druckluft;Pressluft (ugs.)
-Geländerad;Mountain-Bike;Mountainbike
-Differenzdruck-Messverfahren;Blower-Door-Test
-grindig;schmutzig (ugs.)
-Liegerad;Liegefahrrad;Liegevelo (schweiz.)
-(etwas) ins Reine bringen;(einen) Streit beilegen;reinen Tisch machen (ugs.);(etwas) in Ordnung bringen;für klare Verhältnisse sorgen;Tabula rasa machen (ugs.);(eine Sache) bereinigen;Ordnung schaffen;(sich) aussprechen;(etwas) klären
-Radverleih;Veloverleih (schweiz.);Fahrradverleih
-Oberleitungsomnibus;Oberleitungsbus (Hauptform);gleislose Bahn (fachspr., veraltet);Obus;Trolleybus;O-Bus (Hauptform)
-Pressluftleitung;Druckluftleitung
-Druckluftflasche;Vorratsbehälter für komprimierte Luft;Atemluftflasche;Pressluftflasche
-Leihvelo (schweiz.);Leihfahrrad;Leihrad
-Kleiderkasten;Kleiderschrank
-Turbofan;Mantelstromtriebwerk;Zweistrom-Strahltriebwerk (fachspr.)
-Vollspur;Stephenson-Spur (veraltet);Normalspur;Regelspur
-Zugangskontrolle;Zutrittskontrolle
-Fußballmolekül;Buckyball;Buckminster-Fulleren (fachspr.)
-Mobilklo;transportable Toilette;mobiles WC;Mobil-WC;mobile Toilettenkabine
-Küchensieb;Seicher (österr.);Durchschlag;Sieb;Abtropfsieb;Seiher;Seihe (ugs., regional)
-leichte Muse (fig.);U-Musik;kommerziell erfolgreiche Musik (fachspr.);Unterhaltungsmusik;Popularmusik (fachspr.);Popmusik (Hauptform);populäre Musik
-Bombenflugzeug;Bomber
-Verdienstorden der Bundesrepublik Deutschland;Bundesverdienstorden (ugs.);Bundesverdienstkreuz (ugs.)
-Erdmagnetosphäre;Magnetfeld der Erde;Erdmagnetfeld
-bekannt;veröffentlicht;publiziert
-Flugmaschine;Luftfahrzeug;Fluggerät
-Nachschiebelokomotive;Nachschiebelok (Kurzform);Nachschiebetriebfahrzeug
-Sekundärmarktrendite;Umlaufrendite
-Beschaffenheit;Bewandtnis
-Vehemenz;Nachdruck;Aplomb
-Ideensammlung (Verfahren);(kreative) Ideenfindung;Brainstorming;Denkrunde
-Ideengenerierung;Ideenfindung
-berüchtigt;berühmt-berüchtigt;halbseiden;schlecht beleumundet;zum Himmel stinken (ugs., fig.);unseriös;verschrien;nicht ganz koscher (fig.);verrufen;krumm (ugs., fig.);(ein) Gschmäckle haben;von zweifelhaftem Ruf;anrüchig;unsauber
-folgend;anschließend;anknüpfend;im weiteren Verlauf;nachkommend;im Folgenden;nachfolgend
-voller Verzweiflung;desperat (geh.);verzweifelt;hoffnungslos
-(etwas) kommentieren;(sich) artikulieren;(seinen) Senf dazugeben (ugs., fig.);(seine Meinung) zum Ausdruck bringen;(den) Mund aufmachen (ugs.);(seine) Meinung sagen (Hauptform);(etwas) sagen zu (ugs.)
-Residenz;Wohneinheit (kaufmännisch);Apartment (engl.);Logement (geh., franz., veraltet);Heimstatt;Wohnung (Hauptform);Unterkunft;(die eigenen) vier Wände (ugs.);Bleibe;Wohnstätte;Domizil;(jemandes) Zuhause;Wohnstatt;Herberge;Heim;Dach über dem Kopf (ugs.);Obdach (Amtsdeutsch);Dach überm Kopf (ugs.);Behausung
-Facility Manager (geh., verhüllend);Gebäudewart;Hausmeister (Hauptform);Hauswart;Abwart (schweiz.);Hausbetreuer;technischer Hausdienst;Hausbesorger (österr.)
-Werbetafel;Reklametafel;Werbebanner
-Restwegaufzeichnungsgerät (schweiz.);Unfalldatenschreiber;Black Box;Unfall-Daten-Speicher;RAG (schweiz.);UDS;Blackbox
-Dritte-Welt-Land;Entwicklungsgesellschaft;Entwicklungsland (Hauptform);Drittweltland
-Magen;Gaster (fachspr.);Bauch (ugs.)
-Templerorden;Templer;Arme Ritterschaft Christi vom salomonischen Tempel;Tempelherren;Tempelritter
-Haarentfernung;Depilation;Enthaarung
-Antennenschüssel (ugs.);Satellitenschüssel (ugs.);Parabolantenne
-Blimp;Prallluftschiff
-Sturzkampfbomber;Sturzkampfflugzeug;Sturzbomber;Stuka
-Schwenkflügelflugzeug;Schwenkflügler
-Sitzring (fachspr.);Klodeckel;WC-Sitz;Klobrille (ugs.);Toilettensitz;WC-Brille;WC-Deckel;Toilettendeckel
-Freizeitbad;Erlebnisbad;Spaßbad (ugs.)
-Minigolf;Miniaturgolf
-Schrottanleihe;Hochzinsanleihe;Junk Bond (engl.);High-Yield-Anleihe
-Börsenkapitalisierung;Marktkapitalisierung;Marktwert;Börsenwert
-Geschicklichkeitskünstler;Balancekünstler;Jongleur
-Auslage;Glasschrank;Schaukasten;Vitrine
-Hetzer;Unruhestifter;Troll (Internet) (ugs.);Provokateur (franz.);Scharfmacher
-Zerobond (engl.);Zero-Bond (engl.);Nullkuponanleihe
-System;Ordnungsprinzip
-Bohnenquark;Bohnenkäse (veraltet);Sojaquark;Tofu
-Bruder;Atze (ugs.);Alter (ugs.);Bruderherz (ugs.)
-Schwester;Schwesterherz (ugs.);Schwelle (ugs., Jargon, berlinerisch, salopp)
-Kleintrombe;Staubtrombe;Staubteufel;Staubhose;Sandhose;Wirbelwind (ugs.)
-Studiengebühr;Studienbeitrag
-Drehstuhl;Drehsessel
-Bürodrehsessel;Bürodrehstuhl
-Büromöbel;Büroeinrichtung;Büromobiliar
-mit Druckluft angetriebenes Werkzeug;druckluftbetriebenes Werkzeug;Druckluftwerkzeug;Pressluftwerkzeug
-Schutzweg (österr.);Fussgängerstreifen (schweiz.);Fußgängerschutzweg (DDR);Fußgängerüberweg;Dickstrichkette (veraltet);Fußgängerübergang;Zebrastreifen (ugs., Hauptform)
-Bürosessel;Arbeitsstuhl;Bürostuhl
-Begräbnisvorsorge;Bestattungsvorsorge
-(einmal) pro Stunde;jede Stunde;alle 60 Minuten;im Stundentakt;stündlich (Hauptform);alle Stunde
-Kenngröße;Leistungsmerkmal;Kennwert;Leistungsparameter
-hat alle Rechte an diesen Daten;Daniel N., München
-Grabdenkmal;Grabmal
-Anstoß;Bully (engl.);Anpfiff;Ankick;Anspiel
-Pressluftantrieb;Druckluftantrieb
-Pressluftspeicher;Druckluftspeicher
-Rahmendaten;Eckdaten;Grunddaten
-Männertag (ugs., regional);Herrentag (ugs., regional);Vatertag
-Elektromotor;elektrischer Antrieb;Elektroantrieb
-radioaktiver Niederschlag;Fall-out;Fallout
-Klomann (ugs.);Toilettenwächter;WC-Reiniger;Toilettenreiniger;Kloputzer;Kloreiniger
-Dampfleitung;Dampfrohr
-Elektromaschine;elektrische Maschine;Maschine mit elektrischem Antrieb
-Davidshirsch;Milu;Davidhirsch
-Schwarzlicht (ugs.);UV-Licht;Ultraviolettstrahlung;Infraviolett-Strahlung (fälschlich);ultraviolettes Licht;Ultraviolett
-IR-Strahlung;Ultrarotstrahlung;Infrarotstrahlung;Infrarotlicht
-Pressluftmotor;Druckluftmotor;Luftmotor
-Wasserrohr;Wasserleitung;Wasserleitungsrohr
-sollte es wirklich eng werden;sollte es hart auf hart kommen;sollte es zum Äußersten kommen (geh.);im übelsten Fall (ugs.);sollte es wirklich kritisch werden;im Extremfall;wenn es (ganz) dicke kommt (ugs.);im äußersten Fall;schlimmstenfalls;wenn es hart auf hart geht;wenn es hart auf hart kommt;im (aller)schlimmsten Fall
-UV-Lampe;UV-Leuchte;Ultraviolettleuchte;Schwarzlichtleuchte;Schwarzlichtlampe;Ultraviolettlampe
-Veloweg (schweiz.);Radweg;Radfahrweg;Fahrradweg
-Fahrradparker;Fahrradhalter;Radständer;Fahrradhalterung;Veloständer (schweiz.);Fahrradständer (ugs.);Velohalter (schweiz.);Fahrradparksystem
-Wärmelampe;Infrarotlampe;IR-Leuchte;Infrarotlichtquelle;Infrarotleuchte;IR-Lampe
-Ozongas;Trisauerstoff;Ozon;aktiver Sauerstoff
-IR-Schnittstelle;IrDA-Schnittstelle;Infrarot-Schnittstelle;Infrarotschnittstelle
-Infrarotlaser;IR-Laser
-Manövermunition;Salutmunition;Markiermunition (schweiz.)
-Schreckschusspistole;Gaspistole
-Gasrevolver;Schreckschussrevolver
-Helium;Heliumgas
-Neongas;Neon
-Xe (Elementsymbol);Xenon;Xenongas
-Krypton;Kryptongas
-Argongas;Argon
-Radongas;Radium-Emanation (veraltet);Niton (veraltet);Radon
-Schreckschusspatrone;Platzpatrone
-Außenwand;Außenmauer
-Fahrrad fahren;Velo fahren (schweiz.);radeln;pedalieren (scherzhaft);in die Pedale treten (ugs.);mit dem Rad unterwegs sein;Rad fahren
-Komprimierungsrate;Kompressionsrate
-Pressluftventil;Druckluftventil
-Ölfördermaximum;Ölfördergipfel;Peak-Oil
-Höhle;Gruft;Grotte;Gewölbe
-Sperrventil;Absperrventil
-Ballungsraum;Siedlungsraum;Verdichtungsraum (fachspr.);Ballungsgebiet;(urbane) Agglomeration (schweiz.);Siedlungsgebiet;städtische Region
-divisiv;teilend
-gesellschaftlich;sozial;zwischenmenschlich
-Pedaleur (ugs., scherzhaft);Pedalritter (ugs.);Biker (ugs.);Radler (ugs.);Radfahrer;Fahrradfahrer;Velofahrer (schweiz.)
-Identitätsüberprüfung;Identitätsprüfung;Authentifikation;Authentifizierung;Authentisierung
-Eingangstür;Zugangstür;Eintrittstür
-Zugangstor;Zutrittstor;Eintrittstor
-Datenkompression;Datenkomprimierung
-komprimiert archivieren;zippen (ugs.);komprimieren;packen (ugs.);eindampfen (ugs.)
-Spur-Obus;Busbahn;Spurbus
-Monorail;Einschienenbahn
-entpacken;dekomprimieren;entzippen (ugs.)
-Dateiumwandlung;Dateikonvertierung
-in der Mitte liegend;ein Zwischenglied bildend;dazwischen befindlich;intermediär;dazwischenliegend
-platzieren;anbringen;stellen
-IR-Sensor;Infrarotdetektor;Infrarotsensor
-IR-Lichtquelle;Infrarotsender;IR-Sender
-Pressluftschrauber;Druckluftschrauber
-letztmalig;letztmals;zum letzten Mal
-Selbstbedienung (ugs., ironisch);Entwendung;(das) Klauen (ugs.);...klau;(das) Stehlen;Klauerei (ugs.);Plünderung;Dieberei(en);Griff in die Kasse;Klau;Diebstahl (Hauptform)
-Ladeplatz;Verladeplatz
-(einmal) pro Minute;im Minutentakt;minütlich
-Sauerstoff;Sauerstoffgas;Feuerluft;dephlogistisierte Luft;Oxygenium (fachspr., griechisch);Lebensluft
-Anleihe mit variabler Verzinsung;Floating Rate Note (fachspr., engl.);Floater (fachspr., engl.)
-Ringkampf;Rauferei;handfeste Auseinandersetzung(en);Schlagabtausch (meist fig.) (auch figurativ);Raufhändel (geh., veraltend);Keilerei (ugs.);Prügelorgie;handgreifliche Auseinandersetzung;Schlägerei (Hauptform);Tätlichkeiten;Klopperei (ugs.);Raufhandel (geh., veraltend);tätliche Auseinandersetzung;Prügelei
-Gyrokopter (griechisch);Gyrocopter (griechisch);Autogyro (griechisch);Tragschrauber (Hauptform)
-Rauchfangkehrer (österr.);Essenkehrer (regional);Kaminfeger (schweiz.);Schornsteinfeger;Kaminkehrer;Schlotfeger (regional)
-Waschbrett;Waschrumpel (österr.)
-Keilwinkel;Schnittwinkel
-Fräsmaschine;Fräse (ugs.)
-Dixi;WC-Container;Sanitärcontainer;Toilettencontainer
-Erkennungsmarke (militärisch);Hundemarke (ugs., Jargon, militärisch)
-Mediävistik;Wissenschaft vom Mittelalter;Mediaevistik;Mittelalterforschung
-bewegbar;verschiebbar;beweglich;platzierbar;freigängig
-Windwurf;Sturmholz;Windbruch
-Zwischenlager;Pufferlager
-Überwachungseinrichtung;Kontrolleinrichtung
-Verbundkeramik;Faserkeramik;faserverstärkte Keramik
-Barter-Handel (fachspr.);Tauschgeschäft;geldloser Handel (fachspr.);Tauschhandel
-spezifizieren;abstufen;stufen
-Treibholz;Schwemmholz
-Assistentenprogramm;Assistent (fig.);Wizard (engl.)
-Ablokation;Bestandgabe;Verpachtung;Vermietung;Leasing
-Beruhigungsmittel;Barbiturat (fachspr.)
-Pareto-Effekt;80/20-Regel;80-zu-20-Regel;Pareto-Prinzip;Paretoprinzip
-Machbarkeitsnachweis;Machbarkeitsbeweis;Proof of Concept (fachspr.);Nachweis der Machbarkeit
-überlassen;in Bestand geben;verpachten;vermieten;in Pacht geben;(Schiff/Flugzeug) verchartern;untervermieten
-Sache sein (ugs.);los sein (ugs.);(sich) um etwas handeln
-Atomantrieb;Nuklearantrieb
-Atommüll (ugs.);Nuklearabfall;Atomabfall;nuklearer Abfall;radioaktiver Abfall;Nuklearmüll (ugs.)
-Atomunfall;Nuklearunfall
-Atomindustrie;Nuklearindustrie
-Nuklearforscher;Atomforscher
-Nuklearforschung;Atomforschung;Kernphysik
-Nuklearwirtschaft;Atomwirtschaft
-Nuklearmaterial;Atommaterial
-Steinschlag;Felssturz;Bergsturz;Steinlawine;Felsrutsch
-Nukleartechnologie;Atomtechnologie
-mitleiderregend;aufwühlend;rührend;erschütternd;herzbewegend;herzzerreißend;das Herz berührend;großes Gefühlskino (ugs., fig.);zu Herzen gehend;ergreifend;herzergreifend;bewegend;berührend;anrührend (geh.)
-Johanniswürmchen;Leuchtkäfer;Johanniskäfer;Glühwürmchen
-Nurflügelflugzeug;Nurflügler;Nurflügel
-Ziffernsumme;Quersumme
-Tapisserie;Bildwirkerei
-Türschelle;Türgong;Türklingel;Türglocke
-Stickstoff;Stickstoffgas;Nitrogenium (fachspr.);N (Elementsymbol)
-Malaysien (österr.);Malaysia
-Nachdenken;Gedankenkreisen;Grübeln (ugs.)
-zusammenhängen;in Verbindung stehen (mit);dazugehören;zu tun haben (mit)
-einfließen;Einfluss besitzen
-Detektei;Auskunftei;Detektivbüro
-Auswahl (ugs.);Nationalelf;Nationalmannschaft
-Rasenmäher;Grasmäher (ugs.)
-Heckenschneider;Heckenschere
-Beregnungsanlage;Regner (ugs.)
-Starrflügler;Starrflügelflugzeug
-viermal pro Stunde;im 15-Minuten-Takt;viertelstündlich;im Viertelstundentakt;alle 15 Minuten
-alle 30 Minuten;zweimal pro Stunde;Halbstundentakt;halbstündlich
-60 mal pro Minute;sekündlich;(einmal) pro Sekunde;im Sekundentakt (Hauptform)
-alle drei Monate;quartalsweise;viermal pro Jahr;vierteljährig;vierteljährlich;quartalsmäßig;einmal im Quartal;dreimonatlich
-alle halbe Jahr (ugs.);halbjährig;alle sechs Monate;zweimal im Jahr;einmal pro Halbjahr;im Abstand von sechs Monaten;zweimal pro Jahr;halbjährlich;im 6-Monats-Abstand
-Vogelzwitschern;Zwitschern;Vogelgesang;Vogellärm;Vogelkonzert;Vogelgezwitscher
-Autobauer (ugs.);Autoerzeuger;Automanufaktur;Automobilhersteller (Hauptform);Autoproduzent;Autohersteller
-Motorradbauer;Motorraderzeuger;Motorradhersteller
-Fahrradbauer;Velohersteller (schweiz.);Fahrradhersteller;Fahrradproduzent;Fahrraderzeuger
-Violinbogen;Geigenbogen;Violinenbogen
-Geigenkasten;Violinkasten;Violinenkasten;Geigenkoffer
-Stratagem;Taktik;geschicktes Nutzen einer gegebenen Lage
-Stahlerzeuger;Stahlhersteller;Stahlproduzent;Stahlwerk
-Müllentsorgung;Kehrichtabfuhr (schweiz.);Müllbeseitigung;Müllabfuhr
-Gitarrenbauer;Gitarrenhersteller
-Hawaiananas (österr.);Ananas
-Eiserzeugung;Eisherstellung;Eisproduktion
-Eisenherstellung;Eisenerzeugung;Eisenproduktion
-Bekleidungsproduktion;Bekleidungsherstellung;Bekleidungserzeugung
-Rosenobel;Goldmünze Eduards III. von England
-zugespitzt;faserähnlich;prosenchymatisch (fachspr.)
-Metallsplitter-Erkennungswerkzeug;Sideroskop (fachspr.)
-Bronchialkarzinom (fachspr.);Lungenkarzinom (fachspr.);Lungenkrebs (Hauptform);bronchogenes Karzinom (fachspr.);Bronchuskarzinom (fachspr.)
-staubsaugen (Hauptform);saugen;durchsaugen;Staub saugen
-nicht abzählbar;unzählbar;zahllos;unzählig;nicht zählbar
-Runde der letzten 16;Achtelfinale
-Runde der letzten acht;Viertelfinale
-ansprechbar (Person);(ein) hörendes Ohr (haben) (geh., biblisch, fig.);offen (für);empfänglich (für);zugänglich;aufgeschlossen (für);erreichbar
-nicht abgesperrt;zugänglich;frei zugänglich;öffentlich zugänglich;offen
-Normalfall;Regelfall
-kombinieren;abgleichen;vereinigen;mergen (fachspr.);zusammenführen
-Elfmeter;Elfer (ugs.);Strafstoß
-Panthera pardus (zool.) (fachspr.);Parder (veraltet);Pard (veraltet);Pardel (veraltet);Leopard
-Austausch;Transfer;Übertragung;Synchronisation
-übersät (mit);gespickt (mit);prallvoll (mit);über und über bedeckt mit;voll (mit);voll (von);voller;bedeckt;angefüllt mit
-Alaunstift;Blutstillstift;Rasierstift
-Flexileine;Laufleine
-Seilleiter;Strickleiter
-Bummerlsalat (österr.);Eissalat;Eisbergsalat (Hauptform)
-Disambiguierung;Vereindeutigung
-Abwärme;Wärmeverlustleistung (fachspr.)
-zuweisen (Speicherplatz);belegen (ugs.);zuteilen;allozieren (fachspr.);reservieren
-Umfrage;Fragegespräch;Untersuchung;Interview (engl.);Dialog;Befragung;Erhebung
-Vorzugskondition;Sonderkondition
-Entomologie;Insektenkunde
-Spontanheilung;Selbstheilung;Spontanremission (fachspr.);Spontanregression (fachspr.)
-verzeichnen;erfassen;aufnehmen;skizzieren;beobachten;aufzeichnen
-Beobachtung;Dokumentierung;Aufnahme;Dokumentation;Erfassung;Aufzeichnung
-Flugangst;Angst vorm Fliegen;Aviophobie
-Kurfürstendamm (Eigenname);Ku'damm (ugs., Eigenname)
-Schritt;Abschnitt;Phase;Stufe
-Bezüge;Zahlungen;Gutschriften
-Luminanz;Lichtstärke
-Baugruppe;Bauelement;Einheit;Bauteil;Modul;Element;Komponente
-benötigt;gesucht;gewünscht
-Kanarienvogel;Kanari (ugs.);Kanarie (fachspr.)
-Wiesn;Oktoberfest
-schwupp (ugs.);rubbel die Katz (ugs.);rucki zucki (ugs.);zack-zack (ugs.);ruckzuck (ugs.);husch husch (ugs.);zapp-zapp (ugs.);schwuppdiwupp (ugs.);hopp-hopp (ugs.);holterdiepolter (veraltend);hoppla hopp (ugs.);zicki-zacki (ugs.);flotti galoppi (ugs.);ratz-fatz (ugs.);schwupps (ugs.)
-Passvermerk;Sichtvermerk (fachspr., veraltet);Einreiseerlaubnis;Visum
-Schmauchen (ugs.);Paffen (ugs.);Rauchen;Quarzen (ugs.);Tabakrauchen
-Ersatzmann;Zweitbesetzung;Reservist;Reserve;Auswechselspieler;zweite Garnitur (abwertend);aus der zweiten Reihe (ugs., fig.)
-Ersatzdienst;Zivildienst
-Wirbelstrombremse;Induktionsbremse
-von Interesse sein;relevant sein;infrage kommen;im Gespräch sein;ein Möglichkeit sein;eine Rolle spielen;zur Auswahl stehen;in Frage kommen;gehandelt werden (als) (ugs.)
-Stimmheilung;Phoniatrie;Foniatrie
-Fünfter Kontinent (ugs.);Down Under (ugs., engl.);Australien;Roter Kontinent (ugs.)
-Zahlen;Daten;Erhebung;Datenmaterial;Statistik;Empirie
-Fragmentierung;Segmentation;Diversifikation;Zerlegung;Zerteilung;Segmentierung
-Fitness-Center;Muckibude (ugs.);Kraftkammer;Fitnessstudio;Fitnesscenter
-Helikopterlandeplatz;Hubschrauberlandeplatz;Heliport
-Hundehalter;Herrchen;Hundebesitzer
-Frauchen;Hundebesitzerin;Hundehalterin
-Goldene Stadt (ugs.);Prag;Hauptstadt von Tschechien;Praha
-Prinzessin;Königstochter
-Muckis (ugs.);Muskeln
-Antialkoholiker;Abstinenzler;Nichttrinker;Abstinent (schweiz.);Alkoholgegner
-Zeckenstich;Zeckenbiss (ugs.)
-Selbstbräuner;Bräunungscreme
-Zechtour;Bierreise;Sause;Zug durch die Gemeinde (ironisch);Kneipenbummel;Sauftour (ugs.);Kneipentour
-Drahtzieher;Urheber;Anstifter;Initiator;Rädelsführer
-Meuterer;Abtrünniger;Aufwiegler;Revolutionär;Revoluzzer;Unruhestifter;Umstürzler;Frondeur (veraltet);Rebell;Aufständischer;Putschist
-Zug;Wanderung;Fußreise;Marsch;Treck
-klassisches Altertum;Altertum;Urzeit;Antike
-Tintenlöscher;Tintentod;Tintenkiller (ugs.);Korrekturstift
-Flucht;Winkelzug
-Seitenschlag;Achter (ugs.);Acht (ugs.)
-Felge;Radkranz
-Feldzug;Militäraktion;Heereszug;Kriegszug;militärische Operation;Militäroperation
-Gutachtergremium;Preisgericht;Preisrichter;Jury
-Extraktion;Extrahierung
-Zellengenosse;Mitgefangener;Mithäftling
-Eichkater (landschaftlich);Ekenaape (niederdeutsch);Baumfuchs (hessisch, landschaftlich);Eichkatze (historisch, landschaftlich);Eurasisches Eichhörnchen (fachspr.);Eichhalm (württembergisch);Eichhörnchen (Hauptform);Sciurus vulgaris (fachspr., lat.);Eichkatzl (landschaftlich);Eichkatzerl (landschaftlich);Europäisches Eichhörnchen (fachspr.);Eichkätzchen (historisch, landschaftlich);Katteker (niederdeutsch)
-wiederholen;kleben bleiben (ugs.);hängen bleiben;(den) Sprung in die nächste Klasse nicht schaffen;sitzenbleiben (ugs.);eine Schulklasse wiederholen;nicht versetzt werden (Hauptform);hängenbleiben;backen bleiben (ugs.);klebenbleiben (ugs.);sitzen bleiben (ugs.);(eine) Ehrenrunde drehen (ugs., fig.)
-Tour de France;Tour der Leiden (journ.);Frankreichrundfahrt (ugs.)
-Golf spielen;golfen
-Golfspieler;Golfer
-Versicherungsbeitrag;Versicherungsprämie;Prämie
-Korselett;Korsage;Hüfthalter;Mieder;Korsett
-Sprengladung;Sprengkörper
-Golfspielerin;Golferin
-Fürth;Kleeblattstadt (ugs.)
-Kurzarm...;mit kurzem Arm;mit halbem Arm;kurzärm(e)lig;Halbarm...
-Langarm-Hemd;langärmeliges Hemd;Langarmhemd;langärmliges Hemd
-Kursstützung;Kursintervention;Kurspflege
-A-Shirt (fachspr., engl.);T-Shirt (fachspr., engl.);Unterleibchen;Unterhemd;Unterleiberl (ugs., österr.)
-Fußnagel;Zehennagel
-Loschwitzer Brücke;Blaues Wunder (ugs.)
-Verzweifachung;Geminatio (fachspr., lat.);Verdopplung;Duplikation;Duplizierung;Verdoppelung
-Mozartkugel;Mozartbonbon
-männliche Gans;Gänserich;Ganterich;Ganter;Ganser
-festmachen;verankern
-Molly (ugs., Abkürzung);Molotowcocktail;Brandflasche;Benzinbombe
-gediegen (fachspr.);rein (vorkommend)
-Aufräumarbeiten;Aufräumungsarbeiten
-plötzlich einschießend;lanzinierend (fachspr.);stechend
-Sprossenstiege;Sprossenleiter;Leiter;Fahrt (fachspr., Bergbau, Jargon)
-Bettwäsche;Bettzeug
-Wirkwaren (geh., veraltet);Textilien;Textilware
-(sich) ertüchtigen (geh.);Sport machen;(sich) körperlich betätigen;(sich) trimmen;Sport treiben;sporteln (ugs.);trainieren;Bewegung machen
-kickern;Tischfußball spielen
-pauken (fachspr., Jargon, burschenschaftlich);fechten
-Strahlen aussenden;strahlen
-zerfallen;strahlen;zerstrahlen;radioaktiv sein
-Widerstand;Resistor
-Glückstreffer (Billard);Fluke (fachspr.)
-Hülle;Futteral;Etui
-Feuerwehrzeughaus;Feuerwehrmagazin;Feuerwache;Feuerwehrhalle (südtirolerisch);Feuerwehrwache;Feuerwehrgerätehaus;Feuerwehrhaus;Brandwache (schweiz.);Spritzenhaus (ugs.);Feuerwehrrüsthaus (österr.)
-Hallenbad;Schwimmhalle
-Freibad;Sommerbad;Schwimmbad
-Zerealien;Cerealien;Frühstücksflocken
-Kochschokolade;Couverture (franz.);Schokoladenüberzugsmasse (fachspr.);Blockschokolade;Kuvertüre;Überzugsschokolade (fachspr.)
-Up-Milch;Haltbarmilch (österr.);haltbare Milch;UHT-Milch;H-Milch
-Guezli (schweiz.);Plätzchen
-Kokosgebäck;Makrone
-Kotelett;Karrees;Rippchen
-franz. Fleischgericht;Chateaubriand (franz.);Doppellendensteak
-revisionsfähig;reparierbar;wieder gutzumachen;ersetzbar;wiederherstellbar;reparabel (geh., bildungssprachlich);rekonstruierbar;noch zu retten (ugs.)
-gefestigt;konsolidiert;vereinheitlicht;zusammengeführt
-Konsolidierung;Vereinheitlichung;Zusammenführung
-Schriftwerk;Literatur;Text (Hauptform);(eine) Schrift (geh.)
-Gitarrero;Gitarrist;Gitarrespieler;Gitarrenspieler
-alkoholfrei;nicht alkoholisch;antialkoholisch (ugs.)
-mit Alkohol;hochprozentig (ugs.);alkoholhaltig;alkoholisch;mit Umdrehungen (ugs.)
-Sammlung;Fundus;Auswahl;Bestand
-nachschauen;nachsehen;überprüfen;schaun (ugs., süddt.);klären
-Datenbasis;Ansammlung;Pool
-Element (einer Skala);Item (fachspr.);Eintrag
-Stratigraphie;Stratigrafie;Schichtenkunde
-Gesteinskunde;Felsenkunde;Petrografie;Petrographie
-schusssicher;kugelsicher
-Parameter;Freiheitsgrade
-mit jemandem in Verbindung stehen;kennen;(jemandem) bekannt sein;zu jemandes Umfeld gehören;Kontakt haben (zu jemandem)
-(jemandem) etwas sagen;kennen;(jm.) bekannt (sein)
-Erholung;Einholung
-Census;Zensus;Makrozensus;Volkszählung
-Stalker;Nachsteller
-Luftsack;Luftkissen;Airbag;Aufprallschutzkissen (selten)
-Schnellgericht;Schnellimbiss;Junkfood (abwertend);Fast Food;Fastfood
-Kriegsberichter;Kriegsberichterstatter
-identisch;wesensgleich;inhaltsgleich
-der Einfachheit halber;zur Vereinfachung
-(sich) widersprechen;kollidieren (mit);(einer Sache) zuwiderlaufen;in Konflikt stehen (mit);in Konflikt geraten (mit);konfligieren (fachspr.);entgegenstehen
-Überparteilichkeit;Neutralität;Unparteilichkeit
-Farbfernseher;Farbfernsehgerät;Farb-TV;Farbfernsehapparat
-Schwarzweißfernsehgerät;Schwarzweißfernsehapparat;Schwarzweißfernseher
-Uraufführung;Debüt (franz.);Erstaufführung;Premiere
-Amt;Stelle;Dienstgrad;Charge;Rang;Stellung;Posten
-Sitzabstand;Sitzteiler
-Portal;Tunneleingang (ugs.);Tunnelportal;Tunnelmund
-(etwas) noch einmal machen;neu schreiben;umarbeiten;überschreiben;überarbeiten;umschreiben
-überschreiben;mit einer Überschrift versehen;betiteln
-Praktikabilität;Zweckmäßigkeit;Durchführbarkeit
-Ordnung;Priorisierung;Bewertung
-Überlebensaussichten;Überlebenschancen
-auf Pump verkaufen (ugs.);anschreiben
-lesen (können) (geh.);geschrieben stehen (geh.);zu lesen sein;zu lesen stehen;(irgendwo) stehen (Text) (Hauptform)
-auf den Füßen stehen;stehen (Hauptform);aufrecht stehen;auf den Füßen sein
-Blinddarmentzündung;Appendizitis (fachspr.);Wurmfortsatzentzündung
-Rechnungsstellung;Fakturierung (fachspr.)
-Aufsichtsrat;Verwaltungsrat;Board (engl.);Beirat;Lenkungsausschuss;Kontrollausschuss;Kuratorium;Kontrollgremium
-Cellospieler;Cellist
-Regisseur;künstlerischer Leiter;Spielleiter
-kippen (fig.);einkassieren (Gesetz) (fig.);zu Fall bringen;kassieren (ugs.)
-Fichtenmoped (ugs.);Motorsäge;Kettensäge
-Nissenkamm;Läusekamm (ugs.)
-Zuwendung;Hinsicht;Fixation (fachspr.);Hinblick;Betrachtung;Beachtung;Aufmerksamkeit;Berücksichtigung
-laufen;in Betrieb sein (Maschine);an sein
-Isolierflasche;Thermoskanne (ugs.)
-Gleisachsabstand;Gleisabstand;Gleismittenabstand
-Objekt;Entität;Symbolfigur;Größe;Symbol
-(der) Nikolaus (ugs.);Sankt Nikolaus;(der) heilige Nikolaus;Samichlaus (schweiz.)
-korrupt (fachspr.);degeneriert
-Bonitätsprüfung;Kreditwürdigkeitsüberprüfung;Bonitätsüberprüfung;Kreditwürdigkeitsprüfung
-Doppeldecker (ugs.);Dosto (ugs., Kurzform);Doppelstöcker (ugs.);Doppelstockwagen
-Nichterreichung;Verfehlung
-Doppelkreuzungsweiche;doppelte Kreuzungsweiche
-Jubelfest;Jubelfeier;Jubiläum
-Taucherschutzanzug;Skaphander (fachspr., griechisch, veraltet);Taucheranzug (Hauptform);Tauchanzug
-etymologisch;sprachgeschichtlich
-Leiden;Dornenweg;Leidensgeschichte;Martyrium;Kreuzesweg;(schweres) Leid
-Dyskalkulie;Rechenstörung;Arithmasthenie;Rechenschwäche (fälschlich, Hauptform)
-Turbo (ugs.);Abgasturbolader;Turbolader
-(einer Neigung) nachgehen;frönen
-schlechtester Fall;ungünstigster Fall;Worst Case (engl.)
-Synonymlexikon;Thesaurus (griechisch);Wortnetz;Synonymwörterbuch
-bedeckt;(stark) bewölkt;(dicht) bewölkt;wolkenbedeckt
-anders;alternativ
-heilend;kurativ;therapeutisch
-energiegeladen;schnittig (geh.);voll innerer Kraft (geh.);kraftvoll;mit Kawumm (ugs.);dynamisch;energisch;lebhaft;schwungvoll;unter Dampf stehen(d) (ugs.);mit Musik dahinter (ugs.);mit Wumm(s) (ugs.);energievoll
-Bombardement;Bombardierung;Bombenabwurf
-Sufik (veraltet);Sufitum (veraltet);Sufismus
-Mystiker;Sufi;Derwisch;Anhänger des Sufismus
-Marke (ugs.);Postwertzeichen (Amtsdeutsch);Briefmarke
-Farbenkreis;Farbkreis
-Fastnachtsumzug;Karnevalszug;Karnevalsumzug;Faschingsumzug;(dr) Zoch (ugs., kölsch);Rosenmontagszug
-Kriegsentschädigungen;Reparationszahlungen;Schadensersatz für Kriegsschäden;Wiedergutmachungsleistungen;Reparationen;Reparationsleistungen;Reparationslasten
-Hoffnung;Zukunftserwartung;Zuversicht;Erwartung;Vertrauen;Zutrauen
-Jeanne d'Arc;Jehanne la Pucelle;(die) heilige Johanna;Johanna von Orléans;Jungfrau von Orléans
-Leiter (Rundfunk-/Fernsehanstalt);Intendant;Aufseher
-Bremshundertstel;Bremsgewichtshundertstel (schweiz.);Bremsprozente (veraltet)
-Fußfehlstellung;Fußdeformation (fachspr.)
-entfalten;zunehmen;gedeihen;prosperieren;ausprägen (fachspr.);entwickeln;wachsen
-heben;in der Höhe halten;hochstellen
-außen;lateral (fachspr.)
-dorsal (fachspr.);hinten
-Kombilimousine (Amtsdeutsch);Kombi (Hauptform);Kombinationskraftwagen;Kombiwagen;Kombinationswagen;Variant (Markenname)
-kurz;von kurzer Dauer
-medial (fachspr.);innen
-Sprungbein;Talus (fachspr.)
-Agitprop;Agitation und Propaganda
-Fersenbein;Calcaneus (fachspr.);Kalkaneus (fachspr.)
-Schutzmechanismus;Schutz
-höher machen (ugs.);anböschen;aufstocken;anheben;erhöhen
-grillieren (schweiz.);bräteln (schweiz.);auf dem Grill rösten;grillen;auf dem Grill braten
-Anfangsbuchstaben;Initialen
-Zuckertüte;Schultüte
-Juckflechte;Ausschlag;Hautirritation;Ekzem (fachspr., griechisch)
-Schwellung;Quaddel;Wulst
-NOx (fachspr.);Stickoxide (Plural);Stickstoffoxide (Plural)
-Genu varum (fachspr.);O-Bein
-X-Bein;Genu valgum (fachspr.)
-verkrampft sein;angespannt sein;(sich) verkrampfen;(sich) verspannen
-(sich etwas) von der Backe putzen (ugs., fig.);aufhören (mit / zu + Infinitiv);(es) belassen (bei);(sich etwas) ersparen;(sich etwas) verkneifen (ugs.);sein lassen (ugs.);(sich etwas) abschminken (ugs., fig.);nicht machen;(von etwas) die Finger lassen (ugs.);absehen (von);sausen lassen (ugs.);(sich) beherrschen (etwas zu tun);nicht tun;bleiben lassen (ugs.);(es) gut sein lassen (ugs.);(sich) verabschieden (von etwas) (ugs., fig.);(etwas) drangeben (ugs.);gar nicht erst versuchen (ugs.);(darauf) verzichten, etwas zu tun;(sich etwas) schenken (ugs.);bleibenlassen;lassen (ugs.);(sich etwas) sparen (ugs.);Abstand nehmen (von etwas);unterlassen (Hauptform);(sich) die Mühe sparen (können) (ugs.)
-Strahlungsquelle;Strahlenquelle
-Ohrenstöpsel;Ohropax (Markenname);Gehörschutzstöpsel
-Stockautobus (österr.);Stockomnibus (österr.);Doppelstockbus;Doppelstockomnibus;Stockbus (österr.);Doppeldeckeromnibus;Doppeldeckbus;Doppeldeckerbus (Hauptform)
-Wandelanleihe;Wandler (schweiz.);Wandelschuldverschreibung;Wandelobligation
-Methodik;Methodenmenge (fachspr.);Methodenbündel
-Methodologie;Methodenlehre
-Motorschlitten;Schneemobil;Schneemotorrad;Ski-doo (Markenname)
-Festbeleuchtung;Illumination
-Rute;Gerte;Reitgerte;Peitsche;Geißel
-Beobachtungsstation;Beobachtungsstelle;Wetterwarte;Observatorium
-anheben (Gesang);beginnen
-Abhören (Tonband);Abspielen;Wiedergeben
-Stampflehm (Architektur);Pisee
-wiederkehrende Handlung;Zeremonie (ugs.);Ritual;rituelle Handlung
-runder Saal;Rundbau;Rotunde (Architektur);Rondell
-vonnöten;(unbedingt) notwendig;nicht (mehr) wegzudenken;zwingend;unbedingt dazugehören;wichtig;de rigueur (geh., bildungssprachlich, franz.);(ein) Muss;unentbehrlich;unverzichtbar;(sollte) in keiner Sammlung fehlen (ugs., formelhaft);unabdingbar;sollte man haben;gehört in jeden (gut sortierten ...) (ugs., formelhaft);unumgänglich;zwingend benötigt;indispensabel (geh., bildungssprachlich, veraltet);(ein) Must (engl.)
-Schreibaby;Schreikind
-Tortendiagramm;Kreisdiagramm;Kuchendiagramm
-Kerbe;Flexkerbe (fachspr.)
-spitalreif (schweiz.);krankenhausreif
-Zoni (derb, ironisierend);Ostler (ugs.);Zonendödel (derb);Ossi (ugs.);Ostdeutscher
-Westler (ugs., veraltend);Westdeutscher;Wessi (ugs.);Bundi (ugs., veraltet)
-bauen;konstruieren;zusammensetzen
-Hintergrund;Kulisse;Folie (eines Geschehens)
-stutzig werden;erschrecken;stutzen;stocken;innehalten
-stutzig werden;störrisch werden;widerspenstig werden
-Dependenz (fachspr.);Interdependenz;(gegenseitige) Abhängigkeit
-ohne Sauerstoff;anaerob
-aerob;mit Sauerstoff
-(höfisches) Zeremoniell;(diplomatisches) Protokoll;Reglement (geh., franz.)
-Übertragungsprotokoll;Protokoll;Verbindungsprotokoll;Netzwerkprotokoll;Netzprotokoll
-gemeinsam haben, dass;verbinden
-Köpfer (ugs., regional);Köpper (ugs., regional);Köpfler (ugs., regional);Kopfsprung
-Bewehrungsstahl;Betonstahl;Moniereisen (veraltet);Stahleinlagen;TOR-Stahl (österr.);Betonstabstahl (fachspr.);Armierungseisen (veraltet);Armierungsstahl
-Tourismusabgabe;Ortstaxe;Beherbergungstaxe;Gästetaxe;Kurtaxe;Aufenthaltsabgabe;Kurabgabe;Nächtigungstaxe
-auf den Schlips treten (fig.);vor den Kopf stoßen (ugs., fig.);düpieren (geh.);brüskieren (geh.);verletzen
-halbtägig;halbtags
-ganztags;ganztägig
-Teilzeitjob;Teilzeitbeschäftigung;Teilzeitstelle;Teilzeitarbeit
-Urlaubsgeld;Urlaubsremuneration (österr.)
-Fehlinterpretation;Fehldeutung;Missinterpretation
-Hochglanz...;Klavierlack;Pianolack
-Brüder;Gebrüder
-Kollektivum;Sammelbezeichnung;Sammelbegriff;Sammelname
-bevorzugt (fachspr.);am besten;vorzugsweise (fachspr.);optimalerweise (fachspr.);mit Vorliebe;am liebsten;am ehesten
-Intransigenz (geh.);Ignoranz;Unnachgiebigkeit;Unbelehrbarkeit (Hauptform);Uneinsichtigkeit;Beratungsresistenz
-Unstimmigkeiten;Meinungsverschiedenheiten;Dissens (geh.);Differenzen
-Sherpa (ugs.);Hochträger
-Nationalchina (veraltet);Taiwan;Republik China auf Taiwan;Republik China (offiziell);Taiwan (Chinesisches Taipei)
-viszerale Leishmaniose;Dum-Dum-Fieber;Kala-Azar
-Ansteckungskrankheit;ansteckende Krankheit (ugs.);Infektionserkrankung;Infektionskrankheit;übertragbare Krankheit;Infekt (fachspr.)
-ora et labora;bete und arbeite
-In vino veritas;Im Wein ist Wahrheit;Im Wein liegt die Wahrheit
-Allegorese;Allegorie;Personifikation;Gleichnis
-konkludent;schlüssig
-Totschlag;(vorsätzliche) Tötung
-Vorfahrt;Vorrang (österr.);Vortritt (schweiz.)
-Rechtsvorrang (österr.);Rechtsvortritt (schweiz.)
-unfallfrei;ohne Unfall;unfalllos
-Leselampe;Leselicht;Leseleuchte
-ausgeleuchtet;beleuchtet;angeleuchtet
-Cognacschwenker;Cognacglas
-Fehler bei der Eingabe;Eingabefehler
-Frist für die Einreichung;Einreichfrist
-Einspruchsfrist;Frist für einen Einspruch
-Einreichplan;Plan zum Einreichen
-Fehler bei der Wiedergabe;Wiedergabefehler
-Vorfahrtsregel;Vortrittsregel (liechtensteinisch, schweiz.);Vorrangregel (österr.)
-Stammhaus;Zentrale;Hauptquartier;Hauptsitz;Mutterhaus;Hauptstelle;Stammsitz;Headquarter (engl.);Hauptgeschäftsstelle;Muttersitz;Hauptniederlassung
-Vorfahrtsverletzung;Vorfahrtverletzung;Vorrangverletzung (österr.);Vortrittsverletzung (schweiz.)
-Anbotfrist (österr.);Angebotsfrist;Frist für ein Angebot;Anbotsfrist (österr.)
-Antwort-Wahl-Verfahren (fachspr.);Multiple-Choice-Verfahren
-Androloge;Männerarzt
-Männerheilkunde;Andrologie
-nominell;formal;der Form halber;äußerlich;um der Form zu genügen;die Form betreffend;pro forma (lat.);der Form wegen;zum Schein;um einer Vorschrift zu genügen
-Auto mit Ottomotor;Benziner
-Ottomotor;Benzinmotor
-Harlekin;Zirkusclown;dummer August;Weißclown (fachspr.);Clown
-eingewanderte Tierart;Neozoon (fachspr., zoologisch);invasive Tierart (fachspr.)
-eingewanderte Pflanzenart;invasive Pflanzenart (fachspr., botanisch);Neophyt (fachspr., botanisch)
-in Frage kommend;entsprechend;dazugehörend;einschlägig;zu einem Gebiet gehörend;dazugehörig
-Detail...;einzelne Punkte betreffend;punktuell (Hauptform)
-Kontinuierlichkeit;Kontinuum;etwas lückenlos Zusammenhängendes
-gütemäßig;qualitativ;die Qualität betreffend;wertig
-Durchführungsweise;Modalität;Art der Durchführung;Vorgehensschema;Handlungsweise;Vorgehensweise;Art und Weise;Modus operandi (lat.)
-koordinieren;abstimmen;absprechen
-(seinen) Dank bekunden;Dank zollen;(seinen) Dank ausdrücken;danken (Hauptform);(sich) bedanken;(jemandem) Dank aussprechen;(jemandem) Dank sagen;(seinen) Dank äußern;Dank abstatten
-kulinarisch;deliziös;lukullisch;schmackhaft;die Kochkunst betreffend
-Schlemmer;Gourmand (franz.);Prasser;Vielfraß
-Schmecklecker (ugs., regional, ruhrdt.);Zuckermäulchen (ugs.);Naschkatze (ugs.);Leckermaul (ugs., Hauptform);süßer Zahn (ugs.);Schleckermaul;Zuckermaul (ugs.);Leckermäulchen (ugs.);jemand, der gerne Süßigkeiten isst
-lautmalerisches Wort;Onomatopoetikon
-Technologie;technisches Verfahren;Hightech;technische Möglichkeiten;Technik
-rumoren;grollen;grummeln
-haarlos;glatzert (ugs.);ohne Haare;unbehaart;glatzköpfig;kahlköpfig;kahl
-Trödler;Schlaftablette (ugs.);Lahmarsch (derb);Tränentier (ugs.);Langweiler (ugs.);Träne (ugs.);trübe Tasse (ugs.)
-Hochrechnung;Extrapolation;Vorschau
-Luke;(kleines) Fenster;Scheibe (schweiz.)
-eingefärbt;tingiert
-Periost (fachspr.);Knochenhaut
-Proceedings (engl.);Tagungsband;Konferenzband
-Geschreibsel (ugs.);Sauklaue (ugs.);Hieroglyphen (ugs., fig.);Klaue (ugs.);Pfote (ugs.);(schlecht leserliche) Handschrift;Gekrakel (ugs.);Gesudel (ugs.);Geschmiere (ugs.);Sudelarbeit (ugs.);Geschmier (ugs.);Gekritzel (ugs.)
-(sich) (fest)klammern (an);(sich) festhalten (an);Halt finden
-Sichtung;Erblicken
-Empfangseinrichtung;Empfänger;Empfangsanlage;Empfangsgerät
-gemeinsam nachdenken;deliberieren (lat.);(die) Köpfe zusammenstecken (fig.);beraten;beratschlagen
-Vortrag;Übertrag
-Genfersee;Genfer See
-Rückrechnung;Rückblick;Flashback (fachspr., Jargon, engl.);Rückbesinnung;Reminiszenz (geh.);Rückschau;Rückblende (fachspr., fig.);Analepse (fachspr.);Retrospektive (geh.);Rückwendung
-Schweinezyklus;Schweinebauchzyklus
-Ausführungswahrscheinlichkeit;Durchführungswahrscheinlichkeit;Realisierungswahrscheinlichkeit
-(großer) Blumentopf;Blumenkübel;Pflanzcontainer;Pflanzkübel
-Heuristik (fachspr.);Daumenregel;Faustformel;grober Anhalt;Schätzung;Faustregel
-(sich) ein Herz fassen;(es) schaffen (zu);(etwas) übers Herz bringen;über seinen (eigenen) Schatten springen (fig.);wagen;(es) über sich bringen;(sich) ermannen (altertümelnd);(sich) einen Ruck geben (und);(sich) trauen;(sich) überwinden;(seinem) Herzen einen Stoß geben;(sich) ein Herz nehmen (und);(all) seinen Mut zusammennehmen
-vielleicht;mag sein;kann (schon) sein;schon möglich;könnte sein;nicht ausgeschlossen;(da) könntest du recht haben (ugs., Spruch)
-Universalgenie;Universalgelehrter;Universalist;Polyhistor (geh., veraltet);wandelndes Lexikon (fig.)
-(mit dem Flugzeug) fliegen (Hauptform);düsen;jetten
-(sich) in Wohlgefallen auflösen;(sich) von selbst lösen (Problem)
-exponierte Stellung;Sonderstellung;Ausnahmestellung
-Präsidium;leitendes Gremium
-soziale Fähigkeiten;mit Menschen können (ugs.);Soft Skills;Sozialkompetenz;soziale Kompetenz;nicht-fachliche Fähigkeiten
-Hosenladen (ugs.);Hosenschlitz;Hosenstall (ugs.);Hosenlatz;Schlitz;Eingriff (fachspr.)
-OpenOffice.org;OpenOffice (ugs.)
-Mengenbeschränkung;Mengenbegrenzung
-jubilieren;Jubiläum feiern
-Kriegsmarine;Marine;Seestreitmacht;Seestreitkraft
-Brät;Brätmasse;Wurstbrät;Fleischbrät
-Wort aus der Schweiz;Helvetismus
-Wort aus Österreich;Austriazismus
-irreführend;in Täuschungsabsicht;falsch;hintergehend;delusorisch (geh., lat., veraltend);trügerisch;missverständlich
-Walnuss;welsche Nuss (veraltet);Baumnuss (schweiz.)
-schalldurchlässig;hellhörig;ringhörig (schweiz.);nicht schallisoliert;schlecht schallgedämmt
-Riegelhaus (schweiz.);Fachwerkhaus
-Spannteppich (schweiz.);Teppichboden
-Detailhandel (schweiz.);Einzelhandel
-Redaktor (schweiz.);Schriftleiter;Redakteur
-Taschengeld;Sackgeld (schweiz.)
-Kommissar;Kommissär (schweiz.)
-innert (schweiz.);während;innerhalb (von);im Laufe von;binnen;bis spätestens
-Schienenverkehr;Zugverkehr;Bahnverkehr;Eisenbahnverkehr;Zugsverkehr (schweiz.)
-Ferner (bayr., tirolerisch);Gletscher;Kees (österr.)
-desavouiert;bloßgestellt
-Reziprozität;aufeinander bezüglich;gegenseitige Begünstigung;Gegenseitigkeit;Prinzip der Gegenseitigkeit;Wechselseitigkeit
-1. Weihnachtsfeiertag;Christtag (bayr., österr.);1. Weihnachtstag;Hochfest der Geburt des Herrn
-Rufnummer;(jemandes) Nummer (ugs.);Telefonnummer
-Rundkopfdelfin;Risso-Delfin
-Jethelm;Braincap;Halbschalenhelm
-Integralhelm;Vollvisierhelm
-Bauchtanz (ugs.);orientalischer Tanz
-Metropolitanraum (schweiz.);Metropolregion
-abwechslungsreich;unterschiedlich;vielfältig;divers
-Applikate;Applikatenachse;z-Achse
-missverstanden;fehlinterpretiert;falsch verstanden;verkannt;falsch gedeutet;fehlgedeutet;falsch interpretiert
-Teamleiter;Teamchef;Gruppenleiter
-mit weiser Voraussicht handeln;Vorsorge treffen;Vorüberlegung anstellen;mit Weitblick handeln;vorausschauend handeln;planen;in Vorausschau handeln
-Kriminalität verursachend;kriminogen (fachspr.)
-disproportional;unverhältnismäßig;überproportional
-Tschechische Republik;Tschechien (ugs.);Tschechei (derb)
-aus (gebranntem) Ton;irden
-basierend;aufbauend;gründend
-Faktor;Bestimmungsgröße;bestimmende Größe;Determinante
-vollstopfen;vollpfropfen (ugs.);spicken;zumüllen (ugs.);anfüllen
-Übertragungsfehler;Übermittlungsfehler;Fehler bei der Übertragung
-verbessert;korrigiert;berichtigt;ausgebessert
-Penetrationtest;Pentest (ugs.);Penetrationstest
-ernst nehmen;geschluckt haben (ugs., fig.);(etwas) wörtlich nehmen;(etwas) unbesehen glauben;(jemandem etwas) abkaufen (ugs., fig.);für bare Münze nehmen (ugs.);(jemandem etwas) glauben (Hauptform);gefressen haben (ugs., fig.);(jemandem etwas) abnehmen (ugs., fig.);(jemandem / einer Sache) Glauben schenken
-Vermehrung;Mehrung
-Erzeugnis;Gebilde;Machwerk (abwertend);Fabrikat;Werk;Produkt
-zupacken (ugs.);zugreifen
-Provinzler;Unschuld vom Lande (ugs.);Landei (ugs., abwertend);Landbewohner;Landpomeranze (geh., abwertend, scherzhaft, veraltet);Landmensch;... vom Lande
-dämonisieren;verfluchen;verwünschen;verleumden;verdammen;verteufeln
-Judenhass;Judenverfolgung;Antisemitismus;Judendiskriminierung;Judenfeindlichkeit;Judenfeindschaft
-Abendzeitung;Abendblatt
-Periskop;Sehrohr
-Sparbuch;Sparkonto;Bankkonto
-Brautkleid;Hochzeitskleid
-Kilogramm;kg;Kilo
-Tippfehler (Hauptform);Verschreiber (ugs.);Tippo (ugs.);Vertipper (ugs.);Typo (engl.);Lapsus Calami (geh., bildungssprachlich, lat.);Schreibfehler
-Zentner;50 Kilogramm
-Kaninchen;Karnickel;Kanin (fachspr.);Oryctolagus cuniculus (zool.) (fachspr.);Hauskaninchen (fachspr.);Hase (vereinfachend) (ugs.);Wildkaninchen (fachspr.);Lapinchen (Eifeler Platt) (ugs.);Mümmelmann (ugs., scherzhaft)
-Eigenheit;Eigentümlichkeit;Idiosynkrasie
-Gefrierfach;Eisfach
-Hacke;Ferse
-Fernmeldeturm;Sendeturm;Fernsehturm
-Sonnabendabend;Samstagabend
-Samstagmorgen;Sonnabendmorgen
-Sonnabendmittag;Samstagmittag
-Samstagnacht;Sonnabendnacht
-Defätist;Unkenrufer;Spielverderber;Pessimist;Zweifler;Defaitist (schweiz.);Schwarzmaler;Bedenkenträger;Skeptiker;Schwarzseher;Bremser (ugs.)
-Drummer;Schlagzeuger
-Atemmaske;Gasmaske;ABC-Schutzmaske;Atemschutzmaske
-Frauenwahlrecht;Wahlrecht für Frauen;Frauenstimmrecht
-Arbeitslosenrate;Arbeitslosenquote;Erwerbslosenquote
-Schürlregen (österr.);Salzburger Schnürlregen (österr.);Sprühregen;Nieselregen
-(das) Nass (geh., literarisch);Niederschlag (ugs.);Regen (Hauptform)
-zivil;nichtmilitärisch
-Veilchen (ugs.);blaues Auge
-Afrika;Alte Welt (ugs.);der Schwarze Kontinent
-Karl-Marx-Stadt (veraltet);Chemnitz
-orthogonal;rechtwinklig;rechtwinkelig
-(sich) befassen mit;zum Thema machen;zu sprechen kommen auf;(etwas) benennen;aufs Tapet bringen (ugs.);zur Sprache bringen;(etwas) ansprechen;(etwas) anschneiden;behandeln;eingehen auf;zur Diskussion stellen;thematisieren (Hauptform)
-Bundeshaushalt;Bundesetat
-Schäfchen;junges Schaf;Lamm
-Flugwaffe (schweiz.);Luftstreitmacht;Luftstreitkraft;Luftwaffe
-Loreley;Lorelei
-Stelle hinterm Komma (ugs.);Nachkommastelle;Stelle hinter dem Komma
-Weltraumstation;Raumstation
-Trauring;Ehering
-Chordophon (fachspr.);Saiteninstrument
-Auskunft geben;in Kenntnis setzen;informieren;(jemandem) bescheiden (geh., veraltend);(jemanden etwas) wissenlassen;Aufschluss geben;(jemanden etwas) wissen lassen
-Weinbau;Weinanbau
-Zellulosenitrat;Nitrozellulose (ugs.);Nitrocellulose (ugs.);Schießbaumwolle (ugs.);Cellulosenitrat
-Ziehung der Lottozahlen;Lottoziehung
-Animiermädchen;Animierdame
-Animierbar;Animierlokal
-Soulmusik;Soul
-Musikrichtung;Genre (Musik);Stilrichtung (Musik);Musikgenre;Musikstil
-Schwimmbrücke;Schiffbrücke;schwimmfähige Brücke;Pontonbrücke
-Ponton;Schwimmplattform
-Zuchtbulle;Zuchtstier
-Freiwilliger;Volontär
-Justitia;(römische) Göttin der Gerechtigkeit
-Winkelschreiber;Winkeladvokat (abwertend);Rechtsverdreher (ugs., abwertend)
-Jazz;Jazzmusik
-Raubvogel;Greifvogel;Greif
-(nach) Belieben;(nach) Gutdünken;ad libitum (geh., lat.)
-Geschwindigkeitsüberschreitung;Geschwindigkeitsübertretung
-schillern;im Farbton wechseln;irisieren;opalisieren;die Farbe wechseln wie ein Chamäleon;changieren
-Brillenrahmen;Brillengestell
-Kirchenmusik;geistliche Werke;Sakralmusik
-an die Leine legen;anleinen
-Insolvenzantrag;Konkursantrag
-Unternehmensberater;Konsulent (schweiz., österr.);Berater;Consultant (engl.)
-Inselgruppe;Archipel
-selbständiger Lerner;Autodidakt;selbstständiger Lerner
-Seitengewehr;Bajonett
-Bluttransfusion;Bluttransfer
-Kondensat;Niederschlagsflüssigkeit (selten);Kondensflüssigkeit
-vektorielles Produkt;Kreuzprodukt;äußeres Produkt;Vektorprodukt
-Nachtbar;Nachtlokal
-Orchideengewächs;Knabenkrautgewächs;Orchidee
-Ostersonnabend (irrtümlich);Ostersamstag (irrtümlich);Karsonnabend;Samstag vor Ostern;Stiller Samstag;Karsamstag
-Lichtquant;Lichtteilchen;Photon
-im Rampenlicht stehen (fig.);im Zentrum der Aufmerksamkeit stehen;auf der Bühne stehen (fig.);im Fokus stehen (fig.);in der Öffentlichkeit stehen
-existenzbedrohend;existenzgefährdend;lebensbedrohlich
-verkaufsfertig;markttauglich;vermarktbar;vermarktungsfähig;verkehrsfähig;marktreif;handelbar;marktfähig;verkaufsfähig
-Carbamid;Harnstoff;Urea (fachspr.)
-Chiffriermaschine;Verschlüsselungsmaschine
-Verschlüsselungsscheibe;Chiffrierscheibe
-Software zur Datenverschlüsselung;Verschlüsselungssoftware;Verschlüsselungsprogramm
-(die) ARD;das Erste Programm;das Erste (ugs.);das Erste Deutsche Fernsehen (fachspr.)
-Deutsche Welle;DW
-Schienenlärm;Schienenverkehrslärm;von Schienenfahrzeugen verursachte Schallimmission
-Brutreaktor;Schneller Brüter
-BR;Bayerischer Rundfunk
-Rundfunkanstalt;Rundfunkgesellschaft
-Bigamie;Doppelehe
-Obmann eines Vereines;Vereinsobmann
-Ausgelassenheit;Trubel;Remmidemmi (ugs.);Hallo (ugs.);Jubel, Trubel, Heiterkeit;Klamauk
-Trubel;Kommerz
-Handel;Geschäftsverkehr;Kommerz;Wirtschaft
-Schulausflug (bayr., österr.);Unterrichtsgang;Schulreise (schweiz.);Klassenfahrt;Schülerfahrt;Schulfahrt
-Dublette;Zwilling (einer Sache) (fig.);Doppelstück
-Ringfleck;kreisförmiges Muster;Mandala;Rosette
-verletzt;zerschunden;zerkratzt;zerrissen;wund
-priesterlich;weihevoll (geh.);pastoral;hochtrabend;salbungsvoll;inbrünstig;geschwollen;pathetisch;solenn (ugs.)
-Varianz;Versatz;Jitter (Jargon);Gangunterschied;Synchronisationsdifferenz (fachspr.)
-existieren;lebendig sein;leben;vegetieren (abwertend);am Leben sein (ugs.);gedeihen (fachspr.)
-Okulist (veraltet);Augenarzt;Ophthalmologe (fachspr.)
-Ophthalmologie (fachspr.);Augenheilkunde;Ophthalmiatrie (fachspr.);Augenmedizin
-ohne Vergütung;pro bono (publico) (fachspr., juristisch, lat.);zum Wohle der Öffentlichkeit;der Allgemeinheit dienend;kostenlos
-Landesstraße;Staatsstraße
-Kreuz;Plage;Mühlstein (an jemandes Hals) (fig.);Fron;Crux;Krux;Last;Joch;Knechtschaft;Bürde
-Mühsal;Plackerei (ugs.);Qual;Mühe;Plage;Quälerei
-Leid;Elend;Plage;Leiden;Qual
-verkrampft;krampfig (ugs.);angestrengt;gezwungen;krampfhaft
-verspannt (Körper);steif;starr;verkrampft;fest
-fein;empfindlich;hauchfein;grazil;wie gehaucht (geh.);fragil;sacht(e);zart;filigran
-Kaiserstuhl;Herrschersitz;Königsstuhl;Regierung;Thron;Herrscherstuhl
-möglichst optimal;nach besten Kräften;so gut wie möglich;weitestmöglich;soweit möglich;so gut es eben geht;bestmöglich
-Diskriminierung;Einseitigkeit;Ungerechtigkeit;Rechtswidrigkeit
-Eisstein;Kryolith (fachspr.)
-präallozieren;im Voraus anfordern
-halt (ugs.);nun mal (ugs.);nun einmal;eben;ja nun mal (ugs.)
-anderenorts;anderwärtig;an anderer Stelle;anderwärts;woanders;anderorts;andernorts;anderswo;an einer anderen Stelle
-auslegen;dimensionieren
-Schober (österr.);Heuhaufen;Heuschober
-Scheune;Scheuer (ugs.);Schupfen;Stadel (bayr., schweiz., österr.);Schober
-Sprinzeminze (ugs., kärntnerisch, veraltend);Muttergotteskäfer;Marienwürmchen (ugs.);Siebenpunkt (Hauptform);Herrgottskäfer;Gottestierchen;Glückskäfer;Marienkäfer (Hauptform);Jungfernkäfer (österr.);Johanniskäfer;Coccinella septempunctata (fachspr., zoologisch)
-Camouflage;Tarnung
-Poker spielen;pokern
-(sich) geben;(jemanden) geben (spöttisch);(sich) verhalten;(sich) aufführen (als / wie);(sich) gehaben;(sich) gerieren
-Kriegsgewinnler;Kriegsprofiteur
-Krisengewinnler;Krisengewinner;Krisenprofiteur
-Abgabenschuldner;Abgabenpflichtiger
-EXPO;World's Fair (engl.);Weltausstellung;Exposition Universelle Internationale;Exposition Mondiale
-Touristikbahn;Schmalspureisenbahn;Kleinbahn;Schmalspurbahn;Museumsbahn
-Spurbreite;Spurweite
-Ewigkeitssonntag;Totensonntag
-Rhein-Main-Flughafen;Flughafen Frankfurt am Main
-Halbgott;Gottmensch;Übermensch
-frauenfeindlich;misogyn (fachspr.);frauenverachtend
-verwandt;affin;angrenzend;anziehend;ähnlich
-Gotteslästerer;Blasphemiker
-Druckverletzung;Barotrauma (fachspr.)
-Namibia (Hauptform);Deutsch-Südwestafrika (1884-1915) (veraltet);Südwestafrika (1918-1990) (veraltet);Namibien
-Landschulheim;Schullandheim
-plebiszitär;abstimmend
-nicht anders können (und);(es gibt) keine andere Möglichkeit;(etwas) geht nicht anders (Hauptform);es gibt keine Alternative (zu);(sich) nicht vermeiden lassen;anders geht's (nun mal) nicht (ugs.);nicht umhinkönnen (um);nicht d(a)rum herumkommen (ugs.);keine andere Möglichkeit sehen;keinen (anderen) Ausweg finden;unvermeidbar sein;Wat mutt, dat mutt. (ugs., Sprichwort, norddeutsch);(an etwas) führt kein Weg vorbei (fig.);es muss sein;das Einzige sein, was geht;nicht umhinkommen (zu);(an etwas) geht kein Weg vorbei. (fig.);als einzige Möglichkeit (bleiben);Es muss (einfach). (ugs., Spruch);(es gibt) keinen anderen Ausweg;In der Not frisst der Teufel Fliegen. (Sprichwort);nichts anderes tun können (als);die einzige Möglichkeit sein (Hauptform);es sich nicht (immer) aussuchen können (Spruch);alternativlos (sein)
-Gipfelkonferenz;Summit (engl.);Gipfeltreffen;Gipfel;Spitzengespräch;Spitzentreffen
-Gipfel;Bergspitze;höchste Stelle (einer Erhebung);höchster Punkt (einer Erhebung)
-Korbballspieler (selten);Korbjäger (ugs.);Basketballer;Basketballspieler
-Chinagras;Miscanthus;Elefantengras;Chinaschilf
-Pellets aus Stroh;Strohpellets
-Holzpellets;Pellets aus Holz
-Handballspieler;Handballer
-Wasserballspieler;Wasserballer
-Sportkleidung;Sportbekleidung;Trainingskleidung
-Auerochse;Auerochs;Ur
-Bowler;Bowlingspieler
-Kegelspieler;Kegler
-Curlingspieler;Curler
-Bouler;Boulespieler
-Mutterfirma;Muttergesellschaft;Stammgesellschaft;Stammunternehmen;Stammfirma;Mutter (Kurzform);Mutterunternehmen
-Volleyballspieler;Volleyballer
-Männerhandball;Herrenhandball
-Frauenhandball;Damenhandball
-Olympische Sommerspiele;Olympiade im Sommer;Sommerolympiade
-Winterolympiade;Olympiade im Winter;Olympische Winterspiele
-Quelle der ewigen Jugend;Jungbrunnen
-nicht die geringste Ahnung haben;keine Ahnung haben;ratlos sein;auf dem Schlauch stehen (ugs., fig.);nicht die mindeste Ahnung haben;keinen (blassen) Schimmer haben (ugs.);(sich) jemandes Kenntnis entziehen (geh., Papierdeutsch);im Dunkeln tappen (ugs., fig.);(etwas) nicht wissen (Hauptform);ahnungslos sein;nicht die kleinste Ahnung haben;nicht die leiseste Ahnung haben (ugs.)
-Faustballspieler;Faustballer
-Gesundbeterei;Quacksalberei;Kurpfuscherei;Scharlatanerie
-nachlesbar;nachschlagbar;offiziell;allgemein verfügbar;wohldefiniert;wohlbekannt
-Phasenunterschied;Gangunterschied
-Volkswagen;VW
-Weihnachtsmann;Santa Claus
-Frachtenbahnhof (österr.);Güterbahnhof;Frachtbahnhof
-Rangierbahnhof;Verschubbahnhof;Verschiebebahnhof (österr.)
-Zigarettenschachtel;Zigarettenpackung
-Tischfußballer;Tischfußballspieler
-Handel an einer Börse;Börsenhandel
-Computerbildschirm;Computermonitor
-umfassen;ausmachen
-in Verwendung sein;im Spiel sein;im Einsatz sein;im Umlauf sein;verwendet werden;Verwendung finden;zur Verwendung kommen
-erzielbar;umsetzbar;durchsetzbar;erreichbar
-bestreiten;bezahlen;finanzieren
-sparsam gucken (ugs.);zerknirscht;betroffen;verlegen;bedröppelt (ugs., ruhrdt.);betreten
-Nippel;Speichennippel
-Nippelspanner;Zentrierschlüssel;Speichenschlüssel;Speichenspanner
-zentrieren;auf die Mitte einstellen
-Zedernrepublik (ugs.);Libanesische Republik;Libanon
-Bewirtung;Speisung;Verköstigung;Beköstigung
-Weltcupgewinner;Gewinner des Weltcups;Weltcupsieger;Weltcuperster
-Achtung bezeugen;(sich) verneigen (fig.);Respekt zollen;Respekt erweisen;Tribut zollen;den Hut ziehen (vor) (ugs., auch figurativ);Anerkennung zollen;Reverenz erweisen (geh.)
-i. d. R.;in der Regel
-cum tempore (fachspr.);c. t. (fachspr.)
-sine tempore (fachspr., bildungssprachlich);s. t. (fachspr., bildungssprachlich)
-akademisches Viertel;akademisches Quart;akademische Viertelstunde
-g.g.T. (Abkürzung);ggT (Abkürzung);größter gemeinsamer Teiler
-kleinstes gemeinsames Vielfaches;kgV (Abkürzung);k.g.V. (Abkürzung)
-Antifa (Kurzform);Antifaschismus
-HTML;Hypertext Markup Language
-Hypertext Transfer Protocol;HTTP
-LCD;Flüssigkristallbildschirm;TFT-Display (ugs.)
-FTP;File Transfer Protocol
-kürzerer Weg;Abkürzung
-Walhalla;Walhall
-Wasserhahn;Wasserkran (ugs.)
-Aufwindkraftwerk;Thermikkraftwerk
-automatisches Getriebe;Automatikgetriebe
-Danaergeschenk (geh.);Unheil bringendes Geschenk;trojanisches Pferd (fig.);Unglück bringendes Geschenk
-kollabieren (geh., fig.);abstürzen (fig.);zusammenbrechen (fig.);implodieren (geh., fig.);zusammenfallen wie ein Kartenhaus (fig., variabel);(in sich) zusammenstürzen (fig.);zusammenkrachen (ugs., fig.)
-eG;eingetragene Genossenschaft
-Bündnerromanisch (fachspr.);Rätoromanisch;Romanisch (ugs.)
-Aktienkurs;Aktienpreis;Preis einer Aktie;Kurs
-Königreich Spanien;Spanien
-Portugiesische Republik;Portugal
-Italienische Republik;Stiefel (ugs.);Italien;(das) Land, wo die Zitronen blühen (geh.)
-Republik Österreich;Alpenrepublik (ugs.);Ostmark (NS-Jargon, veraltet);Ösiland (ugs., ironisierend, salopp);Österreich
-Norwegen;Königreich Norwegen
-Schweden;Königreich Schweden
-Republik Finnland;Land der tausend Seen (ugs.);Finnland;Suomi (Finnisch)
-Slowakei;Slowakische Republik
-Republik Slowenien;Slowenien
-Hauptstadt von Spanien;Madrid
-Hauptstadt von Frankreich;Paname (ugs.);Stadt der Liebe (ugs.);Lutetia (lat., veraltet);Lichterstadt (ugs.);Lutetia Parisiorum (lat., veraltet);Paris
-Rom;Hauptstadt von Italien;Ewige Stadt (ugs.);Stadt der sieben Hügel (ugs.)
-Kopenhagen;Hauptstadt von Dänemark
-Becs (ungarisch);österreichische Bundeshauptstadt;Mozartstadt (ugs.);Wien;Hauptstadt von Österreich;Bundesland Wien
-Bern;Hauptstadt der Schweiz
-Laibach;Ljubljana (slow.);Hauptstadt von Slowenien
-Drittes Rom (ugs.);Hauptstadt von Russland;Moskau
-Hauptstadt von Australien;Canberra
-Hauptstadt von Neuseeland;Wellington
-Chile;Republik Chile
-Brasilien;Föderative Republik Brasilien
-Rio (ugs.);Rio de Janeiro
-Republik Peru;Peru;Andenstaat (ugs.)
-Vereinigte Mexikanische Staaten (amtlich);Mexiko
-Mexico City (engl.);Mexiko-Stadt (Hauptform)
-Uruguay;Republik Östlich des Uruguay
-Hauptstadt von Uruguay;Montevideo
-Zusammensturz;Implosion
-Argentinische Republik;Argentinische Konföderation (veraltet);Argentinien
-Hauptstadt von Bolivien;Sucre
-Republik Kolumbien;Kolumbien
-Ecuador;Ekuador;Republik Ecuador
-Quito;Hauptstadt von Ecuador
-Paraguay;Republik Paraguay
-Surinam;Suriname
-Hauptstadt von Suriname;Paramaribo
-Bolivarische Republik Venezuela;Venezuela
-Caracas;Hauptstadt von Venezuela
-Ästuar;Ästuarium;trichterförmige Flussmündung;Trichtermündung;Estuar
-Hauptstadt von Kanada;Ottawa
-Belgien;Königreich Belgien
-Brüssel;Hauptstadt von Belgien
-Luxemburg;Großherzogtum Luxemburg
-Luxemburg;Hauptstadt des Großherzogtums Luxemburg
-Amsterdam;Venedig des Nordens (ugs.);Hauptstadt der Niederlande
-Hauptstadt von Norwegen;Oslo
-Hauptstadt von Finnland;Helsinki
-Stockholm;Venedig des Nordens (ugs.);Hauptstadt von Schweden
-Kiew;Mutter der russischen Städte (ugs.);Hauptstadt der Ukraine
-Lettland;Republik Lettland
-Riga;Hauptstadt von Lettland;Paris des Ostens (ugs.)
-Litauen;Republik Litauen
-Vilnius;Hauptstadt von Litauen;Wilna
-Estland;Esthland (veraltet);Republik Estland
-Tallinn;Reval;Hauptstadt von Estland
-Pop;Popmusik
-gGmbH;gemeinnützige GmbH (ugs.);gemeinnützige Gesellschaft mit beschränkter Haftung
-Peking;Hauptstadt von China;Beijing
-Nordkorea;Demokratische Volksrepublik Korea
-Republik Korea;Südkorea
-Bangladesch;Volksrepublik Bangladesch
-Königreich Bhutan;Bhutan
-Hauptstadt von Bhutan;Thimphu
-Indien;Republik Indien
-Neu-Delhi;Hauptstadt von Indien;Delhi
-Kathmandu;Hauptstadt von Nepal
-Islamische Republik Pakistan;Pakistan
-Indonesien;Republik Indonesien
-Jakarta;Hauptstadt von Indonesien
-Kambodscha;Königreich Kambodscha
-Myanmar (Hauptform);Republik der Union Myanmar;Burma;Birma
-Republik der Philippinen;Philippinen
-Siam (veraltet);Thailand;Königreich Thailand (offiziell);Land des Lächelns (ugs.)
-Alte Welt (ugs.);Europa und Asien;Eurasien
-Nordamerika;Neue Welt (ugs.)
-Südamerika;Neue Welt (ugs.)
-Asien;Alte Welt (ugs.)
-rangieren;formieren;(sich) aufstellen
-Republik Armenien;Armenien
-Jerewan;Eriwan
-Baku;Hauptstadt von Aserbaidschan
-Bahrain;Königreich Bahrain
-Manama;Hauptstadt von Bahrain
-Grusinien (veraltet);Grusien (veraltet);Georgien
-Hauptstadt Iraks;Bagdad
-Iran;Islamische Republik Iran;Mullah-Staat (ugs.);Persien (veraltet)
-Hauptstadt von Jemen;Sanaa
-Jordanien;Haschemitisches Königreich Jordanien
-Hauptstadt von Katar;Doha
-Paris des Nahen Ostens (ugs.);Beirut
-Hauptstadt von Oman;Muscat;Ort des Fallens (ugs.);Maskat
-Königreich Saudi-Arabien;Saudisch-Arabien (veraltet);Saudi-Arabien
-gleich beschaffen;gleichartig;gleichwirkend;äquivalent
-Republik Türkei;Türkei
-Ankara;Hauptstadt der Türkei
-Vereinigte Arabische Emirate;VAE
-Arabische Republik Syrien;Syrien
-Zypern;Republik Zypern
-Afghanistan;Islamische Republik Afghanistan
-Akmolinsk;Hauptstadt Kasachstans;Akmola;Nursultan;Zelinograd;Astana
-Kirgisistan;Kirgistan;Kirgisien;Kirgisische Republik
-Hauptstadt von Kirgisistan;Bischkek
-Mongolische Republik;Mongolei
-Republik Tadschikistan;Tadschikistan
-Turkmenistan;Turkmenien (veraltet)
-Aussonderung;Exklusion (fachspr.);Desintegration;Ausgrenzung
-New York;Big Apple (ugs.);New York City
-Hauptstadt von Portugal;Lissabon
-Bürgerkrieg;innerstaatlicher bewaffneter Konflikt
-Palästina (ugs.);Palästinensische Autonomiegebiete
-Randschaden;Kollateralschaden;Begleitschaden
-Schöpfer (ugs.);Schöpflöffel (österr.);Schöpfkelle;Suppenkelle
-Vliesstoff;Vlies
-Dutzend des Teufels (ugs.);13;Dreizehn
-Land der Pharaonen;Ägypten;Nil-Land (ugs.)
-Hauptstadt von Ägypten;Kairo
-Demokratische Volksrepublik Algerien;Algerien
-Hauptstadt von Algerien;Algier
-Hauptstadt von Angola;Luanda
-Äquatorialguinea;Republik Äquatorialguinea;Äquatorial-Guinea
-Hauptstadt von Äquatorialguinea;Malabo
-Äthiopien;Abessinien (veraltet)
-Addis Abeba;Hauptstadt von Äthiopien
-Dahome (veraltet);Benin;Dahomey (veraltet)
-Porto Novo;Hauptstadt von Benin
-Republik Botsuana (amtlich);Botsuana;Botswana
-Gaborone;Hauptstadt von Botsuana
-Obervolta (veraltet);Burkina Faso
-Ouagadougou;Hauptstadt von Burkina Faso
-Hauptstadt von Burundi;Bujumbura
-Muße;(süßes) Nichtstun;Dolcefarniente (geh., ital.);Müßiggang;(das) dolce far niente (geh., ital.)
-Ellenbogen;Ellbogen
-Ellbogengesellschaft (Hauptform);Haifischbecken (fig.);Ellenbogengesellschaft;Ego-Gesellschaft
-Verkaufbarkeit gegen Geld;Liquidisierbarkeit (fachspr.)
-Vollblut;Vollblüter
-gegen Geld;entgeltlich;gegen Bezahlung
-Eckzahn;Reißzahn;Hauer
-Menschenfresserei;Anthropophagie (veraltet);Kannibalismus
-Eislaufen;Schlittschuhlaufen
-Eislaufschuh;Schlittschuh
-Papua-Neuguinea;Unabhängiger Staat Papua-Neuguinea
-Port Moresby;Hauptstadt von Papua-Neuguinea
-Hauptstadt von Madagaskar;Antananarivo
-Regierungssitz von Bolivien;La Paz
-Asiatischer Schwarzbär;Kragenbär;Mondbär
-Gänsewein (ugs.);Rohrperle (ugs.);Wasser aus der Leitung;Kranwasser;Leitungswasser;Kranenberger (ugs.);Wasser;Kraneberger (ugs.);Trinkwasser
-Übertragungswagen;Ü-Wagen
-Ü-Ei (ugs.);Überraschungsei
-Maschbau (ugs.);Maschinenbau;Maschinenwesen
-Polarbär;Eisbär
-ausgedünnt;dünn;schütter;licht;spärlich
-(an jemanden) glauben (Hauptform);Vertrauen haben (in);nicht zweifeln;für voll nehmen (ugs.);Vertrauen setzen in;(jemandem etwas) zutrauen
-Vertrauen haben zu;(jemanden) für vertrauenswürdig halten;Vertrauen entgegenbringen (geh.);Vertrauen schenken;(jemandem) vertrauen (Hauptform);(jemandem) glauben
-Pantokrator (fachspr.);Allherrscher
-Bestialität;Mordlust;Blutrausch;Blutdurst;Mordgier
-erzittern;vibrieren;zittern;erbeben;beben;ruckeln (ugs.)
-Zürcher;Einwohner Zürichs;Züricher
-abwendbar;verhinderbar;vermeidbar
-hängen;am Galgen sterben lassen;henken (veraltet);aufhängen;aufknüpfen (ugs.);erhängen
-millionenfach;Mega...
-Ohrstecker;Ohrring
-Bücking;geräucherter Hering;Bückling;Räucherhering;Pökling
-Gemeinschaft;Community;Netzwerk;Kommunität (geh.)
-Militärpolizei (der Bundeswehr);Feldjäger
-Biskotte (österr.);Löffelbiskuit
-Motorradfahrer;Biker (ugs.)
-Mountain-Biker;Mountainbiker;Mountainbike-Fahrer
-Jobbörse;Stellenmarkt
-annus horribilis;Horrorjahr
-Gicht;Zipperlein (veraltet)
-Urat;Harnsäuresalz
-Sixpack (ugs., engl.);gut definierte Bauchmuskeln;Sechserpack (ugs.);Waschbrettbauch (ugs., Hauptform)
-Selbsthilfegruppe;Bürgerinitiative;Aktionsgruppe;Interessengemeinschaft;Initiativgruppe;Initiative;Aktionsbündnis;Initiativkreis
-Araucaria heterophylla (fachspr., botanisch);Zimmertanne;Norfolk-Tanne
-Stichkampf;Ausstich (schweiz.);Play-off;Playoff
-gefangen;weggesperrt;eingeschlossen;eingekerkert;eingesperrt
-Tretlager;Kurbeltrieb;Tretkurbel
-Fernwärmeleitung;Fernwärmerohrleitung
-Alkoholfahne;Fahne (ugs.)
-eine Ladehemmung haben (ugs., fig.);(ein) Brett vorm Kopf haben (ugs.);(sich) dumm anstellen (ugs.);nicht die hellste Birne im Kronleuchter (ugs., fig.);kein Blitzmerker (ugs.);schwer von Kapee (sein) (ugs.);(echt ein) Blitzmerker (ugs., ironisch);nicht die hellste Kerze auf der Torte (ugs., fig.);begriffsstutzig (sein);(bei jemandem) fällt der Groschen in Pfennigen;keine schnelle Auffassungsgabe haben;Spätzünder;(eine) lange Leitung haben (ugs.);auf der Leitung stehen (ugs.);schwer von Begriff (sein) (ugs.)
-(eine) Eigenschaft teilen;gemein haben;gemeinsam haben
-stockdunkel (ugs.);stockduster (ugs.);zappenduster (ugs.);(völlig) dunkel;stockfinster
-Fuzzi (ugs.);Pflaumenaugust (ugs.);dummer August;Hanswurst;Witzblattfigur;Wurst (ugs.);Schießbudenfigur (ugs.);(armer) Wicht;Komiker (ugs.);Lachplatte;Witzfigur (ugs., Hauptform)
-Geistesverfassung;Geisteszustand
-Gutgläubigkeit;Naivität;Arglosigkeit;Treuherzigkeit;Tumbheit (humoristisch)
-navigieren;steuern
-Technomusik;Techno
-Hiphop;Hip-Hop
-Viper;Kobra;Otter
-Lebensunterhalt;Geld zum Leben
-Elektrizitätswerk (veraltet);Kraftwerk;Kraftanlage;Meiler (fig.)
-Braunbär;Meister Petz;Bär (ugs.);Ursus arctos (fachspr.);Petz
-stundenweise beschäftigt;Jobber;Tagelöhner;Gelegenheitsjobber;auf Abruf beschäftigt
-Funktelefon;schnurloses Telefon;Schnurlostelefon
-(ein) schwankendes Rohr (im Wind) (fig.);launenhaft;inkonsequent;unstet;mal so, mal so;wankelmütig;schwankend;schwanken wie ein Rohr im Wind;(ein) schwankes Rohr (geh.)
-Erleichterung;Linderung;Abschwächung;Milderung;Lockerung;Palliation (fachspr., medizinisch)
-Lokalaugenschein (österr.);Besichtigung;Lokaltermin
-zocken (ugs.);daddeln (ugs.);spielen (am Computer);gamen (ugs.)
-Fahrradklingel;Fahrradschelle;Fahrradglocke
-Spurenleser;Fährtenleser
-Albanien;Republik Albanien
-Tirana;Hauptstadt von Albanien
-Pyrenäenstaat;Andorra (Hauptform);Fürstentum Andorra (offiziell)
-Hauptstadt von Andorra;Andorra la Vella
-Bosnien und Herzegowina;Bosniakisch-Kroatische Föderation (veraltet);Föderation Bosnien und Herzegowina;Bosnien-Herzegowina
-Sarajevo;Hauptstadt von Bosnien-Herzegowina
-Bulgarien;Republik Bulgarien
-Sofia;Hauptstadt von Bulgarien
-Athen;Hauptstadt von Griechenland
-Hellas;Griechenland;Hellenische Republik
-Dublin;Hauptstadt von Irland
-Republik Irland;Irland
-Republik Kroatien;Kroatien
-Hauptstadt von Kroatien;Zagreb;Agram (veraltet)
-Liechtenstein;Fürstentum Liechtenstein
-Vaduz;Hauptstadt von Liechtenstein
-Malta;Republik Malta
-Valletta;Hauptstadt von Malta
-Skopje;Hauptstadt von Mazedonien
-Moldau;Moldawische Republik;Moldawien;Republik Moldau
-Fürstentum Monaco;Monaco
-Hauptstadt von Montenegro;Podgorica
-Hauptstadt von Polen;Warschau
-Serbien;Republik Serbien
-Hauptstadt von Serbien;Belgrad
-Pressburg;Bratislava;Preßburg (veraltet);Hauptstadt der Slowakei
-Hauptstadt von Ungarn;Paris des Ostens (ugs.);Budapest;Pest-Buda (veraltet)
-Vatikan;Vatikanstadt;Kirchenstaat
-Hauptstadt von Weißrussland;Minsk
-Grünland;Kalaallit Nunaat;Grönland (Hauptform)
-Verlagerung;Umschichtung
-tipptopp (ugs.);astrein (ugs.);hasenrein (ugs.)
-außen;draußen;extern;außerhalb
-Zyankali;Kaliumcyanid
-Ansammlung;Batterie;Konzentration
-mediieren (fachspr.);abwiegeln;befrieden;schlichten;(einen Streit) beilegen;(in einem Streit) vermitteln
-designen;gestalten;entwerfen
-Büdchen (ugs., kölsch);Spätverkaufsstelle;Kaffeeklappe (ugs., hamburgisch);Kiosk;Büdche (ugs., kölsch);Minimarkt;Trinkhalle;Bude (ugs., ruhrdt.);Späti (ugs., berlinerisch, ostdeutsch);Stand;Verkaufsstelle;Spätkauf (ugs., berlinerisch, regional);Wasserhäuschen (ugs., frankfurterisch);Seltersbude (historisch, ruhrdt.);Spätverkauf (ugs., berlinerisch, regional)
-(jemandem etwas) vermiesen;(jemandem) die Freude (an etwas) nehmen;(jemandem etwas) verleiden;(jemandem etwas) vergällen;(etwas) miesmachen (ugs.);(jemandem) die Freude verderben (variabel);in die Suppe spucken (ugs.);(jemandem) die Lust (auf etwas) nehmen;(jemandem) den Spaß (an etwas) verderben;(jemandem etwas) verekeln;(jemanden) vergraulen;(etwas) schlechtreden;(jemandem) die Lust verderben
-pochiertes Ei;verlorenes Ei
-unidirektional;in eine Richtung verlaufend
-Frankfurter Allgemeine Zeitung;FAZ
-SZ;Süddeutsche (ugs.);Süddeutsche Zeitung
-taz;die tageszeitung
-versenden;rausschicken (ugs.);verschicken;rausgehen (ugs.)
-(eingeschossiges) Haus;Bungalow
-Cholera (fachspr., griechisch);Gallenruhr (veraltet);Brechruhr;Asiatische Cholera;Gallenbrechdurchfall;Cholera asiatica (fachspr., griechisch, lat.)
-Doktoratsstudent (österr.);Doktorierender (liechtensteinisch, schweiz.);Dissertant (schweiz., österr.);Promotionsstudent;Promotionsanwärter;Promovend;Doktorand
-Hinterwäldler (Hauptform);Bauerntölpel (ugs.);Wurzelsepp (ugs.);Bauerntrampel (ugs.);Dorftrottel (derb);Dorftrampel (ugs.);Hillbilly (engl.);Dorfdepp (ugs.);Hilly-Billy (engl.)
-Kulturteil (einer Zeitung);Feuilleton (franz.);Kulturbeilage
-Farnkraut;Farn
-Blattern;Pocken;Variola (fachspr.)
-rückbezügliches Fürwort (veraltend);Relativpronomen (Hauptform);bezügliches Fürwort
-TK-Anlage;PBX (Abkürzung, engl.);TVA (Abkürzung);Private Branch Exchange (engl.);Telefonanlage;Nebenstellenanlage;Teilnehmervermittlungsanlage
-Hauptstadt der Elfenbeinküste;Yamoussoukro
-Asmara;Hauptstadt von Eritrea
-Hauptstadt von Gabun;Libreville
-Banjul;Hauptstadt von Gambia
-Goldküste (veraltet);Ghana
-Hauptstadt von Ghana;Accra
-Republik Guinea;Guinea
-Conakry;Hauptstadt von Guinea
-Guinea-Bissau;Republik Guinea-Bissau
-Bissau;Hauptstadt von Guinea-Bissau
-Hauptstadt von Kamerun;Yaoundé;Jaunde
-Kamerun;Klein-Afrika (ugs.)
-Praia;Hauptstadt von Kap Verde
-Nairobi;Hauptstadt von Kenia
-Hauptstadt der Komoren;Moroni
-Demokratische Republik Kongo;Kongo-Freistaat (veraltet);Kongo (ugs.);Kongo-Kinshasa;Belgisch-Kongo (veraltet);DR Kongo;Zaire (veraltet)
-Léopoldville (veraltet);Hauptstadt der Demokratischen Republik Kongo;Kinshasa
-Republik Kongo;Kongo (ugs.);Französisch-Kongo (veraltet)
-Hauptstadt der Republik Kongo;Brazzaville
-Hauptstadt von Lesotho;Maseru
-Monrovia;Hauptstadt von Liberia
-Tripolis;Hauptstadt von Libyen
-Njassaland (veraltet);Republik Malawi (offiziell);Malawi
-Lilongwe;Hauptstadt von Malawi
-Mali;Republik Mali
-Hauptstadt von Mali;Bamako
-Marokko;Königreich Marokko
-Rabat;Hauptstadt von Marokko
-Islamische Republik Mauretanien;Mauretanien
-Hauptstadt von Mauretanien;Nouakchott
-Port Louis;Hauptstadt von Mauritius
-Maputo;Hauptstadt von Mosambik
-Hauptstadt von Namibia;Windhoek;Windhuk
-Niger;Republik Niger
-Hauptstadt von Niger;Niamey
-Nigeria;Bundesrepublik Nigeria
-Hauptstadt von Nigeria;Abuja
-Kigali;Hauptstadt von Ruanda
-Nordrhodesien (bis 1964) (veraltet);Sambia
-Hauptstadt von Sambia;Lusaka
-Senegal;Republik Senegal
-Dakar;Hauptstadt von Senegal
-Victoria;Hauptstadt der Seychellen
-Lieschen Müller (ugs.);Otto Normalbürger (ugs.);Normalo (ugs.);Normalsterblicher (ugs.);(Person) von nebenan (variabel);Otto Normalverbraucher (ugs.);Stino (ugs.);Durchschnittsbürger;Durchschnittsmensch;Max Mustermann;gewöhnliche(r) Sterbliche(r)
-Nebenumstände;(das) Drum und Dran (ugs.);(das) Drumherum (ugs.)
-Streifenhörnchen;Backenhörnchen
-würdevolles Benehmen;Pathetik (geh.);Erhabenheit;Vornehmheit;Gravität (geh., bildungssprachlich);Getragenheit (geh.);Weihe (geh.);Stolz;Grandezza (geh., ital.);Dignität (geh., bildungssprachlich);Haltung;Gefasstheit;Distinktion (geh.)
-unkonzentriert;nicht (ganz) bei der Sache (ugs.);neben der Spur (ugs.);mit seinen Gedanken woanders (ugs.);ablenkbar;unfokussiert (nicht fokussiert) (geh., bildungssprachlich);abgelenkt
-Blauhelm;UN-Soldat;UNO-Soldat
-Tel Aviv;Tel Aviv-Jaffa
-Dalkebach;Dalke
-Standort;Waffenplatz (schweiz.);Garnison (veraltend, österr.);Militärstandort
-Blockbuster (engl.);Kassenschlager;Straßenfeger (ugs.)
-vordere Schaltung (ugs.);Umwerfer
-Geistesart (geh.);Sinnesart;Denkungsweise;Mentalität;Denkweise;Mindset (engl.);(innere) Einstellung;Denkungsart;Denkart
-Gewinn;Bombenerfolg;Triumph;(großer) Erfolg (Hauptform);triumphaler Erfolg;Riesenerfolg
-Pelerine (veraltend);Regenmantel
-Regencape;Regenumhang
-minderjährig;(sehr) jung;mädchenhaft;knabenhaft;kindlich;jungenhaft;unverschämt jung (ugs.);kindhaft;blutjung
-dahin;dorthin
-Evolutionstheorie;Evolutionslehre (veraltet)
-simpel;(etwas) kann jeder;(etwas) im Stehen auf der Treppe erledigen (ugs., selten);nichts leichter als das! (Spruch);ganz leicht;babyleicht (ugs.);nicht allzu viel dazu gehören (zu) (ugs.);ich bin jahrelang ... gewesen (ugs.);trivial;supereinfach;jedes Kind kann das;kein Hexenwerk (ugs., fig.);unschwer;keine Hexerei (ugs., fig.);ein Leichtes (sein) (geh.);jeder Idiot kann das (derb);kinderleicht (Hauptform);mit dem kleinen Finger (fig.);ganz einfach;so einfach wie eins und eins ist zwei;(sehr) leicht;(sehr) einfach;keine Kunst (sein);babyeinfach (ugs.);nichts dabei sein (ugs.);pille-palle (ugs.);läppisch;spielend einfach
-Kraftfahrzeug;Mfz (Abkürzung, liechtensteinisch, schweiz.);Motorfahrzeug (liechtensteinisch, schweiz.);Kfz (Abkürzung)
-Schadensmeldung;Schadenmeldung
-maßregeln;mit Sanktionen belegen;unterdrücken (ugs.);sanktionieren (fachspr.)
-Tabak;Tobak (veraltet)
-Waffenlager;Zeughaus (veraltet)
-Freetown;Hauptstadt von Sierra Leone
-Rhodesien (veraltet);Simbabwe;Südrhodesien (bis 1980) (veraltet)
-Harare;Hauptstadt von Simbabwe
-Hauptstadt von Somalia;Mogadischu
-Regenbogennation (ugs.);Republik Südafrika;Südafrika
-Pretoria;Hauptstadt von Südafrika;Tshwane
-Sudan;Republik Sudan
-Khartoum;Khartum;Hauptstadt des Sudan
-Geistererscheinung;(geisterhafte) Erscheinung;Spuk;(unheimliche) Erscheinung;Gespenstererscheinung
-führen (Sport);(die) Oberhand haben;Oberwasser haben (ugs.);im Vorteil sein
-anfassen;(an etwas) drankommen (ugs.);tangieren;berühren
-Floppy Disc (engl.);Floppy (ugs., engl.);Floppy Disk (engl.);Diskette
-Massenspeichermedium;Datenträger;Speichermedium;Massenspeicher
-Hauptstadt von Eswatini;Mbabane
-Hauptstadt von Tansania;Dodoma
-Lomé;Hauptstadt von Togo
-Hauptstadt von Tschad;N'Djamena
-Tunesien;Tunesische Republik
-Hauptstadt von Tunesien;Tunis
-Kampala;Hauptstadt von Uganda
-Bangui;Hauptstadt der Zentralafrikanischen Republik
-Aristokratie;Oberschicht;Adel
-Oligarchie (fachspr.);Herrschaft der Wenigen;Oligokratie (fachspr.)
-Patriarchat;Männerherrschaft;Androkratie (fachspr.)
-E-Mail-Server;Mailserver
-Violist;Bratschist;Violaspieler;Bratscher
-Leibgericht;Lieblingsessen;Lieblingsspeise;Leibspeise;(da) könnte ich mich reinsetzen (ugs., salopp);Lieblingsgericht;(da) könnte ich mich reinlegen (ugs., salopp);(jemandes) Leib-und-Magen-Gericht;(jemand) lebt und stirbt für (ugs.)
-Tretlagerwelle (fachspr.);Innenlager
-Umsiedler;Aussiedler;Flüchtling;Auswanderer;Heimatloser;Emigrant
-Intelligenztest;IQ-Test
-Beschäftigung;Erwerbsarbeit;Broterwerb;Erwerbstätigkeit
-naturgemäß;prinzipbedingt;aus Prinzip
-Hackebeil;Hacke (ugs.);Beil;Hackbeil;Axt
-private Krankenversicherung;private Krankenkasse;PKV (Abkürzung)
-Elementarschule (historisch);Klippschule (ugs., norddeutsch);Volksschule (schweiz., österr.);Primarschule (liechtensteinisch, schweiz.);Grundschule
-Zahlungsfrist aufschieben;prolongieren (geh., lat.);Laufzeit verlängern;hinausschieben;ausdehnen;hinausziehen;stunden
-Forderungsaufschub;Stundung;Zahlungsaufschub
-vaporisieren (fachspr.);verdunsten;verdampfen;zerstäuben (ugs.)
-richtigstellen;geraderücken
-aufputzen (ugs.);positiv darstellen;bemänteln (geh.);beschönigen;maskieren;in ein gutes Licht rücken (fig.);verbrämen;verschleiern;weichspülen (fig.);ins rechte Licht rücken (fig.);ins rechte Licht setzen (fig.);herunterspielen;frisieren (ugs.);schönreden;übertünchen;(sehr) günstig darstellen;verklären;schönfärben;verhüllen;romantisieren;schönen;verharmlosen
-Sankt-Nimmerleins-Tag;(ferne) Zukunft
-Schutzraum;Schonraum
-unberücksichtigt;ignoriert
-effekthascherisch;sensationsgeil (ugs.);aufregungssüchtig;sensationshungrig;reißerisch (Hauptform);sensationsgierig;sensationslüstern
-die Schulbank drücken (ugs.);zur Schule gehen
-Tod durch Erfrieren;Kältetod;Erfrieren
-Leistungsaufnahme;Bedarf an elektrischer Energie;Stromverbrauch (ugs.);Strombedarf
-Frische;Unverbrauchtheit
-Informationsdichte;Informationsfülle
-nicht messbar;inkommensurabel
-Lobbyist;Interessenvertreter;Politikberater
-selbstaufrufend;rekursiv
-Hauptpreis;erster Preis;Sechser im Lotto (fig.);Jackpot (fig.);Hauptgewinn;Haupttreffer
-Drittplatzierter;Dritter
-Zweiter;zweiter Sieger (ugs., ironisch);Zweitplatzierter
-Skirennläufer;Skirennfahrer
-Lauswurz;Weiße Nieswurz;Lauskraut;Weißer Germer
-Bahnböschung;Bahndamm
-Datenbankorganisator;Datenbankverwalter;Datenbankadministrator
-Kreisel (ugs.);Kreisverkehr;Kreisverkehrsplatz
-Goldrang (ugs.);Goldmädchen (ugs., fig., weibl.);Gewinner(in) der Goldmedaille;1. Platz;Goldmädel (ugs., fig., landschaftlich, weibl.);Goldmedaillengewinner(in);Goldjunge (ugs., fig., männl.)
-Gewinner der Silbermedaille;Silberrang (ugs.);Silbermedaillengewinner;2. Platz
-3. Platz;Gewinner der Bronzemedaille;Bronzemedaillengewinner;Bronzerang (ugs.)
-Luftgewehr;Luftdruckgewehr
-Luftpistole;Druckluftpistole
-bemitleiden;bedauern
-Business-to-Business;B2B
-Kehlkopfspiegel;Laryngoskop (fachspr.)
-Internetverbindung;Internetzugang;Internetanbindung;Verbindung mit dem Internet
-Zweierset;Doppelpack;Doppelpackung;Zweierpackung
-Stockerlplatz (österr.);Podestplatz
-Ausblick;Blick in die Zukunft
-(einen Preis / eine Belohnung) ausloben;(zur) Belohnung aussetzen
-ausschreiben;ausloben
-Alkoholtest;Alkotest (ugs.)
-voranstürmen;stürmen;bestürmen;vorpreschen;voranpreschen;erstürmen;vorstürmen;vordringen;vorandringen
-Sehnsucht nach der Heimat;Heimweh
-Reiselust;Sehnsucht nach der Ferne;Fernweh;Reisefieber;Fortstreben (literarisch)
-zurechnen;zuschreiben
-Oberwasser haben;punkten (mit);auftrumpfen;seine Überlegenheit zeigen
-Poetik;Dichtkunst
-Matriarchat;Frauenherrschaft
-Elektroroller;E-Scooter (Kurzform, engl.);Elektro-Tretroller;Elektroscooter;E-Tretroller (Kurzform)
-Vieleck;Polygon
-Biogas;Ökogas
-Eissalon (österr.);Eiscafé;Eisdiele;Gelateria (ital., schweiz.)
-Gletscherkunde (veraltet);Glaziologie
-Gletscherforscher;Glaziologe
-Schamberg;Schamhügel;Venushügel
-Klimatologe;Klimaforscher
-Klimatologie;Klimaforschung
-Peninsula (veraltet);Halbinsel
-Achtungstellung (schweiz.);Strammstehen
-Offiziersschüler;Aspirant (schweiz.)
-draufgängerisch;handstreichartig;angriffig (schweiz.)
-ein Amt innehaben;ein Amt bekleiden;amtieren;amten (schweiz.)
-Lebensjahr;Altersjahr (schweiz.);Jahr (ugs.);Lenze (geh., literarisch)
-Sondereinsatzkommando (ugs.);Spezialeinsatzkommando;SEK (Abkürzung)
-Komedo (fachspr.);Mitesser
-indiskutabel (sein) (variabel);nicht in Betracht kommen;nicht zur Debatte stehen;nicht infrage kommen;nicht zur Diskussion stehen;außer Betracht bleiben;unverhandelbar (sein) (geh.);nicht in Frage kommen;keine Option (sein)
-OP-Saal (Kurzform);Operationssaal;(der) OP (Kurzform)
-Gebärsaal (schweiz.);Gebärzimmer (schweiz.);Kreißsaal (Hauptform);Entbindungsraum
-Webspace-Provider;Webhoster
-Geburtsort;Geburtsstätte;Geburtsstadt
-Ferienfreizeit;Ferienlager (Hauptform);Lager;Kinderlandverschickung (historisch)
-Rahmen;Erzählrahmen (fachspr.)
-Wirbelschleppe;Wirbelzopf;Luftverwirbelung (hinter Flugzeugen)
-Antiblockiersystem;Automatischer Blockierverhinderer (schweiz.);Antiblockiervorrichtung (österr.);ABS;ABV (schweiz.)
-Sütterlin;Sütterlinschrift
-KMK;Kultusministerkonferenz
-Rasiercreme;Rasierkreme (alte Schreibung bis 2011);Rasierschaum;Rasierkrem (alte Schreibung bis 2011)
-risikoscheu;risikoavers (fachspr.)
-Geldmengenaggregat;Geldmenge
-Rennwagen;(PS-)Geschoss (ugs., fig.);Rennfahrzeug;Rennauto;Rakete (ugs., fig.);Rennsportwagen;Rennsemmel (ugs.);heißes Gefährt (ugs.);Flitzer (ugs.);Bolide (ugs., Jargon, fig.)
-Portable Document Format;PDF
-innerdeutsche Grenze;deutsch-deutsche Grenze;Zonengrenze (ugs.)
-bereiten;konfektionieren;veredeln;zubereiten;vorbereiten
-Bussole (österr.);Kompass
-auf den Markt kommen;herauskommen (ugs.);erscheinen;das Licht der Welt erblicken
-Monatsgehalt;Monatsverdienst;Monatseinkommen;Monatslohn;monatliche Gehaltszahlung
-Jahresgehalt;Jahreslohn;Jahresverdienst;Jahreseinkommen
-Wochengehalt;Wochenlohn
-bäuchlings;auf dem Bauch
-auf Reserve (laufen);im Sparbetrieb;auf Sparflamme (ugs.)
-Haken (ugs., fig.);Pferdefuß (ugs., fig.);Nachteil
-unkalkulierbar;nicht mehr zu steuern;unberechenbar (Person) (Hauptform);nicht wissen, was jemand als Nächstes tut (ugs., variabel)
-Haarspalter;Kümmelspalter (ugs.);Kleinigkeitskrämer;Krämerseele;kleinlicher Mensch;Federfuchser (ugs.);Wortklauber
-verstörend (geh.);beunruhigend
-Straßenverkehrszulassungsordnung;StVZO
-Gehaltsauszahlung;Gehaltszahlung;Lohnzahlung;Lohnauszahlung
-lilafarben;lilafarbig
-wiederfordern;zurückverlangen;zurückfordern
-drogenabhängig;drogensüchtig
-Mann und Frau (sein);vermählt;unter der Haube (ugs.);vergeben;gebunden;(mit jemandem) zusammen;verehelicht;nicht mehr frei;in festen Händen (fig.);getraut;verheiratet;nicht mehr zu haben
-energetisch;die Energie betreffend
-Schichtdienst;Arbeit im Schichtbetrieb;Schichtarbeit
-übertreten;überschreiten;passieren
-Tastenvirtuose;Klavierkünstler;Tastenakrobat;Klaviervirtuose;Tastenkünstler;Tastenlöwe (ugs.);Keyboarder;Tastengott (ugs.);Konzertpianist;Klaviersolist;Pianist (Hauptform);Klavierspieler (ugs.);Tastenzauberer;Klimperer (abwertend)
-Schweizerdeutsch;Schwyzertütsch;Schwyzerdütsch
-nice-to-have (engl.);(modisches) Zubehör;Accessoire (franz.)
-Fuß fassen;Tritt fassen;(sich) etablieren
-offensichtlich (sein);keines Beweises bedürfen (geh.);(sich) von selbst verstehen;selbstverständlich (sein);auf der Hand liegen (fig.);unmittelbar einleuchten(d);naheliegen(d) (fig.);trivial (fachspr., mathematisch);evident (sein)
-Originalton;O-Ton;Original-Ton
-Militärflugzeug;Militärjet
-auf dem Trockenen Sitzen (ugs., Redensart);finanziell in der Klemme sitzen;(bei jemandem ist) Ebbe in der Kasse (fig.);gerade kein Geld haben (variabel);Geldsorgen haben;in pekuniärer Verlegenheit (geh.);in Geldnot;(es) gerade nicht klein haben (ugs., ironisch);in finanzieller Verlegenheit (sein);gerade nicht zahlen können;(einen) finanziellen Engpass haben;bei jemandem sieht es finanziell (momentan) nicht so rosig aus (ugs., variabel);klamm;knapp bei Kasse (ugs.);knapp dran (ugs.)
-Jarmulke;Kippa
-Wangerooge;Wangeroog (veraltet)
-Kommanditgesellschaft auf Aktien;KGaA
-Heimreise;Rückfahrt;Heimfahrt;Nachhauseweg;Rückreise;Rückweg;Fahrt nach Hause;Heimweg
-Heimkehr;Rückkehr
-(kurze) Pause;Verschnaufpause;Atempause
-Mobilfunksendemast;Handymast;Mobilfunkmast
-Radiographie;Röntgenaufnahme;Röntgenfoto;Röntgenbild
-Vaterunser;Paternoster (geh.);Gebet des Herrn
-Wettbewerbsposition;Marktposition
-Einwohnerzahl;Einwohneranzahl;Anzahl der Einwohner
-Valenzelektron;Außenelektron
-Quäker;Religiöse Gesellschaft der Freunde
-Knobeln;Denksport
-Münz-Mallorca (ugs.);Sonnenbank;Solarium;Asi-Toaster (derb);Klappkaribik (ugs.);Tussi-Toaster (derb);Sonnenstudio
-α-Strahlung;Alphastrahlung
-Limnologe;Gewässerforscher
-Oscar;Academy Award
-Käserei;Käseherstellung;Käseproduktion
-Leuchtreklame;Lichtwerbung
-zurückblicken (auf) (fig.);(sich etwas) in Erinnerung rufen;rekapitulieren;(einer Sache) eingedenk sein;(sich über etwas) klar werden;Revue passieren lassen;(sich etwas) bewusst machen;(sich etwas) vergegenwärtigen;vor seinem inneren Auge vorbeiziehen lassen
-Handelnder;Akteur;(aktiv) Beteiligter;Tätiger;Player (engl.)
-ein Kind erwarten;schwanger sein
-zeitlich;temporal
-Reizung;Provokation
-Passfotografie;Passfoto;Passbild
-Ankunftszeitpunkt;Zeit der Ankunft;Ankunftszeit;Zeitpunkt der Ankunft
-Abfahrtszeit;Zeitpunkt der Abfahrt;Abfahrtszeitpunkt
-ausreizen;ausschöpfen;auslasten;alles rausholen (ugs.);in vollem Umfang nutzen;ausnutzen
-kinematographisch;kinematografisch
-anschlagen;Taste eines Musikinstruments drücken
-(sich) abmühen;(jemandem) nicht leichtfallen;(sich) schwertun (mit);(für jemanden) belastend sein;seine liebe Not haben (mit);Probleme haben (mit / bei);(jemandem) schwerfallen
-derivieren (fachspr., wissenschaftlich);ableiten
-aufzeigen;transparent machen;herausarbeiten;verdeutlichen;konkret benennen
-Schubstange;Treibstange;Pleuelstange;Pleuel
-die Muskeln spielen lassen (ugs.);Stärke zeigen
-widmen;zuwenden;dedizieren
-(eine) Gelegenheit beim Schopf(e) packen (ugs.);(eine) Gelegenheit ergreifen;(eine) Gelegenheit nutzen;(den) Stier bei den Hörnern packen (ugs.)
-Zufallstreffer;zufälliger Treffer;Glückstreffer
-Wohnungsmakler;Wohnungsvermittler
-Fahrausweiskontrolle;Billettkontrolle (schweiz.);Fahrkartenkontrolle;Fahrscheinkontrolle
-Fahrkartenverkauf;Billettverkauf (schweiz.);Fahrscheinverkauf;Fahrausweisverkauf
-Billetverkäufer (schweiz.);Fahrkartenverkäufer;Fahrscheinverkäufer;Fahrausweisverkäufer
-Tischfuß;Tischbein
-Privatgrund;Privatgelände;Privatgrundstück
-schwenkbare Brücke;Schwenkbrücke
-Überprüfungsstelle;Kontrollstelle
-Schwarzkappler (ugs., österr.);Controlletti (ugs.);Fahrscheinprüfer (fachspr.);Billettkontrolleur (schweiz.);Fahrkartenkontrolleur;Ticketkontrolleur
-Positionsleuchte;Positionslicht;Positionslampe
-Warnlampe;Warnleuchte;Warnblinkleuchte
-Dreierpackung;Dreierset;Dreifachpackung
-Knackpunkt (ugs.);Schlüsselfaktor;Casus knacksus (ugs., latinisiert, scherzhaft, variabel);entscheidender Punkt;des Pudels Kern (sein) (geh., Zitat);springender Punkt (ugs.)
-Determinierung;Festlegung;Determination
-pfeilwärts;sagittal (fachspr.)
-unmotiviert;unambitioniert;ambitionslos
-(sich) hysterisch erregen;exaltieren;(sich) überschwänglich benehmen
-Mobilfunklizenz;Handylizenz
-Mobilfunknetzbetreiber;Handynetzbetreiber;Mobilfunker (ugs.)
-Handyakku;Akku eines Mobiltelefons;Handybatterie (ugs.);Mobiltelefonakku
-Wohlbefinden;Wohlfühlen
-Geborgenheit;Sicherheit
-Schaltfeld;Bedienung;Paneel (niederdeutsch);Leitfeld;Einstellfeld;Panel;Bedienfeld;Steuerfeld;Bedienpult;Schalttafel;Bedientafel;Konsole;Terminal;Steuertafel;Einstellpult;Einstelltafel;Armaturenbrett;Schaltpult;Steuerpult
-Indische Eiche;Teakbaum;Teak
-Saxofonspieler;Saxofonist
-Hornbläser;Hornist
-Klimaveränderung;Klimawandel;Wandel des Klimas;Klimaänderung
-Schutz des Klimas;Klimaschutz
-Ziel der Reduktion;Reduktionsziel
-wiederverwerten;rezyklieren (schweiz.);recyclen;recyceln;wiederverwenden
-Altreich;Österreichisch-Ungarische Monarchie;Monarchie Österreich-Ungarn;k.u.k. Doppelmonarchie;Donaumonarchie;Österreich-Ungarn;k.u.k. Monarchie
-Ältestenrat;Senat
-Postdoc (engl.);Post-Doktorand;Postdoktorand
-Klimaprognose;Klimavorhersage
-Meeresforschung;Ozeanografie
-Wegstock;Marter (bayr., österr.);Bildstock;Helgenstöckli (schweiz.);Marterl (bayr., österr.);Materla;Materle
-Weihestätte;Kultstätte;Heiligtum;Kultplatz
-Bauchnabelpiercing;Piercing am Bauchnabel;Nabelpiercing
-Kationennachweis;Nachweis von Kationen
-Nachweis von Anionen;Anionennachweis
-Zungenpiercing;Piercing in der Zunge
-zunächst einmal;prima facie (geh., lat.);zuerst einmal;a prima vista (geh., ital.);auf den ersten Blick
-Begleiter;Pate;Betreuer
-Mehrfachauswahl;Multiple Choice
-Erderwärmung;globale Erwärmung;Klimaerwärmung
-Rastertunnelmikroskop;Rastertunnelelektronenmikroskop
-Handynummer;Mobilnummer;Natelnummer (schweiz.);Handytelefonnummer;Mobiltelefonnummer
-Account;Nutzerkonto;Benutzerkonto
-Hüftschnupfen;Coxitis fugax
-Mobiltelefongespräch;Mobilfunkgespräch;Mobiltelefonat;Handytelefonat
-Tiefenschärfe (ugs.);Schärfentiefe
-Posaunenspieler;Posaunist
-Zuschauerzahlen;Quote (ugs.);Zuschauerquote;Einschaltquote
-Exkulpation (fachspr., lat.);Schuldbefreiung;Entlastung;Rechtfertigung
-transportfähig;transportierbar
-Elektrogitarre;elektrische Gitarre;Stromgitarre (ugs.);E-Gitarre
-Kolatsche;Golatsche;Tascherl (ugs.)
-Philister;Moralist;Moralprediger;Sittenwächter;Sittenprediger;Tugendwächter
-Pensum;Lektion;Aufgabe;Hausaufgabe;Lehrstoff
-Schutzbefohlener;Schützling;Mündel;Pflegebefohlener
-Rücksichtslosigkeit;Radikalität;Radikalismus;Extremismus;Kompromisslosigkeit
-Tatsachenbericht;Reportage;Dokumentarbericht;Berichterstattung;Bericht;Dokumentation;Augenzeugenbericht
-Restauration;Fortschrittsfeindlichkeit;Rückschrittlichkeit
-Hingucker (ugs.);Teaser (Marketing) (fachspr.);Eyecatcher (engl.);Blickfang
-Bewerberinterview;Bewerbungsinterview;Interview (engl.);Einstellungsgespräch;Bewerbungsgespräch;Vorstellungsgespräch
-Neufünfland (ugs.);neue Länder;fünf neue Bundesländer;neue Bundesländer;ehemalige DDR;drüben (ugs.);Beitrittsgebiet;Ostdeutschland;Ex-DDR
-auserkoren;den Zuschlag erhalten;ausgewählt werden
-Maturazeugnis (österr.);Abiturzeugnis;Reifezeugnis (veraltend);Maturitätszeugnis (schweiz.)
-Schrottkarre (ugs.);(fahrbarer) Schrotthaufen (ugs.);alte Blechkiste (ugs.);Siffkarre (derb);Abwrackkarre (ugs.);Schüssel (ugs.);Nuckelpinne (ugs.);Schrottbüchse (ugs.);Schrottfahrzeug (ugs.);oide Kraxn (ugs., bayr.);altes Auto (Hauptform);Rostbeule (ugs.);Schleuder (ugs.);Schrottwagen;Tschäsn (ugs., österr.);Schrottauto (ugs.);Schrottkiste (ugs.);Karre (ugs.);(alte) Klapperkiste (ugs.);Rostlaube (ugs.);Tschessn (ugs., österr.);fahrbarer Schrotthaufen (ugs.);Schrottmühle (ugs.);(alte) Mühle (ugs.)
-Spitzenklasse;Extraklasse
-Versetzung in den Ruhestand;Pensionierung;Ruhestandsversetzung
-Wohlergehen der Gemeinschaft;Gemeinwohl;Allgemeinwohl
-Luftwiderstandsbeiwert;Strömungswiderstandskoeffizient;Widerstandsbeiwert;cw-Wert
-Luftreibung;Luftwiderstand
-überrepräsentiert;unverhältnismäßig viel;mehr als zu erwarten
-unverhältnismäßig wenig;weniger als zu erwarten;im Verhältnis zu wenig(e);unterrepräsentiert
-Donau;Donaustrom
-Arbeitsstätte;Arbeitsstelle;Ort der Beschäftigung;Arbeitsort;Beschäftigungsstelle
-Facette;Dimension (fachspr.);Aspekt;latente Größe (fachspr.);Richtung;Faktor (fachspr.)
-freundlicherweise;netterweise;liebenswürdigerweise
-Festspiel;Festival
-Wissenschaft vom Aufbau der Erde;Geologie
-Read Only Memory;ROM
-Obstbrand;Obstler;Obstgeist;Obstwasser
-Rahmkäse;Frischkäse
-Parmesan;Bergkäse;Hartkäse
-Stack (fachspr., engl.);Kellerspeicher;Stapel (ugs.);Keller (ugs.);Stapelspeicher
-Verbeugung;Verneigung;Ehrenbezeigung (geh.);Reverenz (geh.);Diener;Knicks;Kratzfuß (veraltet)
-Oboespieler;Oboist
-Selbstmordgefährdung;Lebensmüdigkeit (ugs.);Suizidgefährdung;Suizidalität
-Geschwätzigkeit;Redesucht;Rededrang;Polyphrasie (fachspr.);Logorrhö (fachspr.);Sprechdurchfall (ugs.);Logorrhoe (fachspr.)
-Geltung;Bedeutsamkeit;Stellenwert;Tragweite;Relevanz;Bedeutung;Maßgeblichkeit;Belang;Signifikanz;Gewicht;Wichtigkeit (Hauptform);Dimension
-fehlplatziert sein;(sich) am falschen Ort befinden;nichts zu suchen haben (ugs.);nichts verloren haben (ugs.);nicht (irgendwohin) gehören
-The City (ugs., engl.);San Francisco;San Franzisko
-Gottlosigkeit;Asebie;Unfrömmigkeit
-(jemandem) quer durch den Hals gehen (ugs., fig., selten);(jemandem) gegen den Strich gehen;(jemanden) stören;(jemandem) nicht schmecken (ugs., fig.);(jemandem) nicht recht sein;(jemandem) nicht gefallen;ein Problem haben (mit) (ugs.);(jemandem) widerstreben;(jemandem) sauer aufstoßen (ugs., fig.);missfallen;Probleme haben (mit) (ugs.);(jemandem) nicht passen;(jemanden) ärgern (Subjekt = Sache);nichts übrig haben (für) (ugs.);etwas haben gegen (ugs.)
-Umweltsteuer;Ökosteuer
-Klickpedal;Systempedal
-Distorsion;Verzerrung
-Gewinnung;Förderung;Abbau;Entnahme
-drückend;brutheiß;gewittrig;gewitterschwer;dämpfig (ugs., regional);schwer;drückend heiß (Hauptform);schwül;bleiern (geh.);brütend heiß;feuchtwarm;schwül-heiß;stickig
-Herrschaft der Plünderer;Kleptokratie;Diebesherrschaft
-sparsam;Strom sparend;stromsparend;verbrauchsgünstig;energiesparend;Energie sparend
-Spionage;nachrichtendienstliche Aktivität;Aushorchertätigkeit;Spitzeldienst;Agentendienst;Agententätigkeit
-Quirl;Unruhegeist;Springinsfeld (ugs.);Irrwisch;Wirbelwind;Zappelphilipp
-ballistische Schutzweste;Schutzweste;Flakweste;kugelsichere Weste (ugs.);beschusshemmende Weste;durchschusshemmende Weste;schusssichere Weste (ugs.);Kevlarweste (ugs.)
-Freizügigkeit;Latitüde (fachspr.);Platz;Spielraum;Raum;Ellbogenfreiheit;Bewegungsfreiheit
-Zensur;Indizierung;Informationssperre;Verbot
-Spitz auf Knopf stehen (ugs.);zusammenzubrechen drohen;gefährdet (sein);nicht gesichert sein;auf Messers Schneide stehen;unsicher (sein);einzustürzen drohen;in Frage stehen;auf der Kippe stehen;bedroht sein;ins Wanken kommen;ins Wanken geraten;auf dem Spiel stehen;fraglich (sein);auf wack(e)ligen Beinen stehen (fig.);in Frage gestellt (sein / werden);zur Disposition stehen
-Junkmail;Spammail;Spam;(unerwünschte) Werbemail;(unerwünschte) Massenmail
-gespart (Geld);auf der hohen Kante (ugs., fig.)
-nicht ausgeben;nicht konsumieren;(sich) ansammeln (bei jemandem);zusammenkommen (bei jemandem);auf die Seite legen (ugs., fig.);(Geld) zurücklegen;auf die hohe Kante legen (ugs., fig.);Ersparnisse machen;äufnen (schweiz.);(sich) (das Geld für) etwas zusammensparen (ugs.);(Geld) sparen (Hauptform);Rücklagen bilden
-Filzschreiber;Fasermaler;Faserschreiber;Filzstift (Hauptform);Faserstift;Filzer (ugs.)
-der Vorsicht halber;vorsichtshalber (Hauptform);der Vorsicht wegen;zur Vorsicht;sicherheitshalber;zur Sicherheit;zu deiner eigenen Sicherheit (variabel);aus Sicherheitsgründen;aus Vorsichtsgründen
-Körpersprache;Zeichensprache;Gestensprache;Gebärdensprache;Fingeralphabet
-Lebensart;Denkweise;Denkart;Lebensgefühl;Zeitgeist
-Grenzposten;Grenzer;Grenzbeamter;Grenzhüter;Grenzwächter (schweiz.)
-Zuteilung;Zumessung;Rationierung;Zuweisung;Zuerkennung;Kontingentierung
-Antriebsmangel;Lustlosigkeit;Antriebsschwäche;Antriebsarmut
-kohlrabenschwarz (ugs.);kohlenschwarz (ugs.);rabenschwarz (ugs.);pechschwarz (ugs.);tiefschwarz;pechrabenschwarz (ugs.);nachtschwarz
-Hospitant;Trainee;Volontär;Referendar;Mitarbeiter auf Zeit (ugs.);Praktikant
-Volo (Kurzform);Volontariat
-Wendepunkt;Umkehrpunkt;Wende;Wendemarke
-Feldwebel;Unteroffizier;Feldweibel (schweiz.);Uffz;Offiziersanwärter
-offener Quelltext;Quelloffenheit;Open Source (engl.)
-Mondialisierung (ugs.);Globalisierung;Liberalisierung des Welthandels
-HiWi (ugs.);HIWI (ugs.);Hilfswilliger;Hiwi (ugs.);studentische Hilfskraft
-Bundesdatenschutzgesetz;BDSG
-Telekommunikationsgesetz;TKG
-Telemediengesetz;TMG
-Kunstschnee;technischer Schnee (fachspr.);künstlich erzeugter Schnee
-benässen;nass machen;befeuchten
-schubweise auftretend;(sich) phasenweise abschwächen(d);intermittierend (fachspr.);zeitweilig aussetzend;mit Unterbrechungen;periodisch auftretend;wechselnd
-Adlerhorst;Adlernest
-transpirieren (geh.);ölen (ugs.);schwitzen
-Gegenutopie;Antiutopie (bildungssprachlich);negative Utopie;Mätopie (selten);Dystopie (bildungssprachlich);pessimistische Utopie;Anti-Utopie (bildungssprachlich);schwarze Utopie;Kakotopie (selten)
-Rabe;Rabenvogel;Galgenvogel (ugs., veraltet);Krähe
-(den) Vorzug genießend (dass ...);privilegiert (geh.);mit Privilegien versehen;mit Sonderrechten ausgestattet;bevorrechtigt;in einer bevorzugten Stellung;bevorzugt;in einer Sonderstellung
-Operatorrangfolge;Operatorpräzedenz;Auswertungsreihenfolge;Operatorwertigkeit;Operatorpriorität
-Datenverschlüsselung;Verschlüsselung von Daten
-(sich) zurückhalten;marginalisieren;bagatellisieren;abwiegeln;verharmlosen;herunterspielen;kleinreden
-veranschlagen;ansetzen;einplanen
-Dessin;Muster;Textilmuster;Rapport
-Demoiselle (franz., veraltet);Fräulein (veraltet);Mademoiselle (franz.);unverheiratete Frau;junge Dame
-Purgatorium;Fegefeuer;Fegfeuer
-Sprinter (Markenname);Kleintransporter;Transporter;Kleinlaster
-Meinungswandel;Sinneswandel;Meinungsänderung
-menschengemacht;anthropogen;durch den Menschen verursacht
-Einwohner Sachsen-Anhalts;Sachsen-Anhalter;Sachsen-Anhaltiner
-ohne sittlichen Nährwert (ugs., scherzhaft);nutzlos;unwirksam;ohne Nutzwert;untauglich;nicht zu nutzen;nicht nutzbar;ohne Nutzen;Schmuck am Nachthemd (fig., scherzhaft);brotlose Kunst;unbrauchbar;unnütz;zu nichts nutze
-aufoktroyiert;aufgedrängt
-Liebschaft;Lovestory (engl.);Liebesgeschichte;Romanze;Liebesabenteuer
-Greisenhaftigkeit;Senilität
-Alter Ego;zweites Ich
-Hausflur (bundesdeutsch, schweiz.);Flur (ugs.);Stiegenhaus (österr.);Treppenhaus;Ern (ugs., fränk.);Treppenflur (bundesdeutsch, schweiz.)
-Dividendenzahlung;Dividendenauszahlung;Dividendenausschüttung
-Orgelspieler;Orgelmusiker;Organist
-Flötenspieler;Flötist
-Bezugsrechtehandel;Handel von Bezugsrechten;Bezugsrechtshandel
-Zahnweh (ugs.);Zahnschmerz
-Haufen Sand;Sandhaufen;Haufen aus Sand
-Mostfliege;Fruchtfliege;Essigfliege;Drosophilidae (fachspr.);Gärfliege;Mücke (österr.);Taufliege;Obstfliege
-den Geschmackssinn betreffend;gustatorisch
-Geothermie;Erdwärme
-Gletscherschmelze;Gletscherschwund
-genmanipuliert;genetisch verändert;genverändert
-Trommelspieler;Trommler
-Klarinettenspieler;Klarinettist
-Tenor;Sopranistin;Sopransänger;Sopranist
-Weltklima;Klima der Welt
-Wirtschaft der Welt;Weltwirtschaft
-Welt der Wirtschaft;Wirtschaftswelt
-Globalisierungsdruck;Druck der Globalisierung
-Dudelsackspieler;Dudelsackbläser;Sackpfeifer
-Tenorhorn;Bassflügelhorn
-Fagottist;Fagottspieler
-Heroldstrompete;Fanfarentrompete
-Buschauffeur (schweiz.);Autobuschauffeur (schweiz., österr.);Busfahrer;Buslenker;Autobusfahrer
-von Interesse sein für;zutreffen;zurechenbar sein;angehen;betreffen;einschließen;berühren;in Verbindung stehen zu;tangieren;(sich) manifestieren in;anbelangen
-heranholen;hochziehen (Bildbearbeitung) (ugs.);vergrößern;zoomen
-Bankaval (fachspr.);Bankbürgschaft
-Essigwurst;Saure Wurst (österr.)
-Kunst als Selbstzweck;Kunst um der Kunst willen;L'art pour l'art (geh., franz.)
-Pornografie;Pornographie;Wichsvorlage (vulg.);Vollerotik;unzüchtige Darstellung
-geübt;qualifiziert;trainiert;geschult;gelernt;ausgebildet
-Majo (ugs., alte Schreibung bis 2017);Mayonnaise;Majonäse (alte Schreibung bis 2017);Mayo (ugs.)
-Leiterwagen;Bollerwagen
-Variante;Version;Ausgabe;Ausführung;Revision
-Auftritt;Selbstpräsentation;Impression Management (fachspr., engl.);Selbstinszenierung;Selbstdarstellung
-wegschwimmen;davonschwimmen
-RBB;Rundfunk Berlin-Brandenburg
-Mitteldeutscher Rundfunk;MDR
-WDR;Westdeutscher Rundfunk
-Querschläger (fig.);Störenfried;Querkopf;Quertreiber;Sand im Getriebe (ugs., fig.);...schreck;Störer
-realistisch;echt
-Zmorge(n) (ugs., schweiz.);erste Mahlzeit des Tages;Frühstück;Morgenessen (schweiz.)
-missverstehen;nicht erkennen;verkennen
-Pferdefliege;Pferdebremse;Tabanus sudeticus (fachspr.)
-ins Rennen schicken;starten lassen
-Persipan;Parzipan
-(jemandem) ein Dorn im Auge (ugs., fig.);Störfaktor
-Tränendrüsendrücker (ugs.);Rührschinken (ugs.);(kitschige) Aufnahme;Schmachtfetzen (ugs.);Weepie (engl.);Tränendrücker (ugs.);Rührstück;Schnulze
-Sottise (veraltet);Grobheit
-verlangsamen;(eine) Vollbremsung machen;bremsen;abbremsen;auf die Bremse treten;in die Eisen steigen (ugs.);abstoppen
-abmildern;abbremsen;abfedern
-(sich) bremsen (fig.);an sich halten;(sich) am Riemen reißen (und) (ugs.);(sich) mäßigen;Zurückhaltung üben (geh.);(sich) in Zurückhaltung üben (geh.);(sich) zurückhalten;(sich) zurücknehmen
-narrensicher;(da) kann man nichts falsch machen (ugs.);idiotensicher (ugs.)
-Subroutine;Unterprogramm
-geschachteltes Unterprogramm;untergeordnete Routine;Subroutine;eingebettetes Unterprogramm;Unterroutine
-Wasserkocher (Hauptform);Heißwasserkocher
-Glutamatunverträglichkeit;China-Restaurant-Syndrom (ugs.)
-Kartoffelbrei;pürierte Kartoffeln;Kapü (ugs.);Kartoffelstock (schweiz.);Kartoffelmus;Stopfer (bayr., fränk.);Abernmauke (lausitzisch);Kartoffelpüree (Hauptform);Stampfkartoffeln;Mauke (lausitzisch);Stampf (bayr., fränk.);Erdäpfelpüree (österr.);Kartoffelpü (ugs.);Kartoffelstampf
-Rennbahn;Rennpiste;Parcours;Strecke (ugs.);Piste (ugs.);Rennstrecke
-Emission;Ausstoß;Freisetzung
-reisefertig;auf dem Sprung (sein) (ugs., fig.);reisebereit;auf gepackten Koffern sitzen (fig.);fertig zur Abreise
-vergessen werden;in der Versenkung verschwinden (ugs.);dem Vergessen anheimfallen (geh.);in Vergessenheit geraten (Hauptform);niemand spricht heute noch von (...) (ugs., variabel);der Vergessenheit anheimfallen (geh.);die Zeit geht hinweg (über);von der Tagesordnung verschwinden;im Dunkel der Vergangenheit verschwinden (fig., variabel)
-Ladenöffnungsgesetz;Ladenschlussgesetz
-Fachmagazin;Fachzeitschrift;Fachblatt (ugs.)
-penetriert;durchdrungen
-Botulinumtoxin;Botulismustoxin;Botulinum-Neurotoxin;Botox;Botulinustoxin;Botulin
-Nervengift;Neurotoxin (fachspr.)
-G8;Gruppe der Acht
-G-8-Gipfel;G8-Gipfel;G8-Treffen;Weltwirtschaftsgipfel;G-8-Treffen
-Fernseh schaung (ugs., bayr.);fernsehen;in die Röhre schauen (ugs., fig.);in die Röhre gucken (ugs., fig.);ferngucken (ugs.);Fernseh(en) gucken (ugs.)
-Superbenzin;Super (ugs.)
-(jemanden) gewähren lassen;nicht hindern;(jemandem) keine Grenzen setzen (fig.);(jemandem) keine Zügel anlegen (fig.)
-Hochschätzung;Wertschätzung
-Beziehung;Beziehungskiste (ugs.);sexuelle Beziehung;Liebesbeziehung;Zweierkiste (ugs.);Liebesfreundschaft;intime Beziehung;Zweierbeziehung
-spiegelbildlich;eins-zu-eins;direkt;unverändert
-Temperaturdurchschnitt;Durchschnittstemperatur;durchschnittliche Temperatur
-Pokerer;Pokerspieler
-Fechter;Fechtsportler
-Weltmeister im Schach;Weltmeister im Schachspiel;Schachweltmeister
-Schachgroßmeister;Großmeister im Schach
-Wortfolge;monotone Rezitation;Spruchformel;Mantra;Japa
-Referenz (fachspr.);Zeiger (fachspr.);Alias (fachspr.);Pointer (fachspr.)
-Pointer;untraced Reference (fachspr.);freie Referenz
-entsprechen;gleichkommen;korrespondieren (fachspr.);übereinstimmen (ugs.)
-verwendet werden;auftreten;auftauchen;vorkommen;Verwendung finden
-Waschschüssel;Lavoir
-unter allen diesen Voraussetzungen;unter Beachtung all dieser Dinge;hierbei;derenthalben
-hüben (landschaftlich, selten);diesseits;auf dieser Seite;hier
-automatische Speicherbereinigung;Freispeichersammlung;Garbage Collection (engl.)
-solche;solcherlei;derartige;dieserart;wie diese;ebensolche;dergleichen;dererlei (geh.);solch (undekliniert) (geh.);solcherart;derlei;ebensolch (undekliniert)
-emeritierter Hochschulprofessor;Emeritus
-zusammen mit ... auftreten;(zeitgleich) in Erscheinung treten (mit);(mit etwas) assoziiert sein (Medizin) (fachspr.);begleitet werden (von) (fachspr.);einhergehen (mit);an sich haben (ugs.);(mit etwas) vergesellschaftet sein (Medizin, Geologie) (fachspr.)
-ungut;schädlich;beklemmend;unheilvoll
-dabei;hierbei;hiermit;damit;mit dem (ugs.)
-kontrollieren;im Griff haben;gebacken bekommen (ugs.);in den Griff bekommen;(die) Kontrolle gewinnen (über);in Schach halten (ugs.);geregelt bekommen (ugs.);unter Kontrolle haben
-bei dieser Problemstellung;in dieser Frage;da (ugs.);bei diesem Problem;in dieser Angelegenheit;in diesem Punkt
-die optimale Lösung;der bevorzugte Lösungsweg;das Mittel der Wahl
-befreien von;freistellen von
-etwas überantworten;zu etwas verpflichten
-(sehr) ernst;bitterernst;todernst
-übrig geblieben;überschüssig;über (ugs., regional);übriggeblieben;übergeblieben
-Lustfaktor;Spaßfaktor;Unterhaltungswert
-Nachgeborene;Epigonen
-Pferdeschwanz (ugs.);Pferdeschweif
-Baukran;Baustellenkran
-Blitzschlag;Blitzeinschlag
-verinnerlicht;internalisiert
-Sifa (Abkürzung);Totmannknopf (ugs.);Sicherheitsfahrschaltung
-unausgereift;nicht durchdacht;nicht zu Ende gedacht;nicht ausgereift;schlecht vorbereitet (sein);weder Hand noch Fuß haben (fig.);halbgar (ugs., abwertend);(noch) nicht der Weisheit letzter Schluss;unausgegoren (abwertend);(noch) unfertig
-Schutzplanke;Leitschiene (österr.);Leitplanke (veraltet);Fahrbahntrennung
-Initial;Anfangsbuchstabe
-Sonnenmilch;Sonnencreme;Sonnenschutzcreme
-beseitigt;weggelassen;ausgelöscht;gestrichen;ausgewischt;gelöscht
-(der) Radiergummi (Hauptform);(das) Radiergummi (norddeutsch, westdeutsch);Radierer (ugs.);Ratzefummel (ugs.)
-Behaltezeitraum;Aufbewahrungsfrist (fachspr.);Haltezeit (fachspr., Jargon);Aufbewahrungszeit(raum);Behaltedauer;Behaltezeit;Vorhaltezeit;Behaltefrist
-Neuantrag;neuer Antrag
-austariert;ausbalanciert;ins Gleichgewicht gebracht
-mannstoll (ugs.);nymphoman;promiskuitiv;liebestoll
-Formulierung;Wortlaut
-ostinat;ständig wiederholt
-bezahlt;getilgt
-scharfe Kritik;Polemik;unsachlicher Angriff
-Furie;Racheengel;Eumenide;Erinnye;Medusa;Rachegöttin
-Traversflöte;Flauto traverso;Querflöte
-Pompon;Puschel;Tanzwedel
-Gigantismus;Riesenwuchs;Makromelie;Makrosomie;Hypersomie (fachspr.)
-Kunstflug;Aerobatik
-kurzsichtig;myop (fachspr.);myopisch (fachspr., griechisch)
-einfach so;mir nichts, dir nichts (ugs.);bedenkenlos;nach Belieben;ohne Weiteres;beliebig;ohne Schwierigkeiten (geh.);ohne weiteres (Hauptform);unbesehen;problemlos (geh.);nach Lust und Laune (ugs.);ohneweiters (österr.);(ganz) ungeniert (ugs.)
-Loipe;Langlaufbahn;Langlaufspur
-Diagnostik (fachspr.);Erkennung von Krankheiten
-Küchengehilfe;Aide (schweiz.)
-Tiefenmesser;Bathometer (fachspr.);Echolot (fachspr.);Tiefenlot
-tropfenförmig;tränenförmig
-Non-Fiction;Sachbuch;schlaues Buch (ugs.)
-Humoralpathologie;Viersäftelehre;antike Lehre der Körpersäfte;Säftelehre
-Salpeterbildung;Nitrifikation (fachspr.)
-Stielbrille;Lorgnette
-Aussehen;Ausbreitung des Lichts;Lehre vom Licht;Optik
-verdunsten;evaporieren (veraltend)
-Karzinophobie;Angst vor einer Krebserkrankung
-Nosophobie;Nosomanie;Hypochondrie;Krankheitsfurcht;hypochondrische Störung
-Marinechronometer;Schiffschronometer;Längenuhr;Schiffsuhr
-Stalingrad (veraltet);Wolgograd
-RAF;Rote-Armee-Fraktion
-R.A.F. (Abkürzung, engl.);Royal Air Force (engl.)
-Studentenverbindung;Korporation;Studentenkorporation
-unterschiedliche Auffassungen haben (variabel);(es) herrscht keine Einigkeit;uneins (sein);geteilter Meinung sein;(die) Meinungen gehen (weit) auseinander;verschiedener Meinung (sein) (Hauptform);(es gibt) erhebliche Meinungsunterschiede;unterschiedlicher Meinung (sein);(darüber) streiten sich die Gelehrten (fig.);(es gibt) gegensätzliche Auffassungen;(sich) uneinig (sein);in einem Diskussionsprozess (sein) (distanzsprachlich, verhüllend);(daran) scheiden sich die Geister;sich nicht einig (sein)
-um das Mindeste zu sagen (geh.);durch die Blume gesagt (fig.);durch die Blume gesprochen (fig.);zaghaft formuliert (geh.);milde ausgedrückt;vorsichtig ausgedrückt;vorsichtig gesagt (Hauptform);gelinde gesagt
-zurücklaufend;rekursiv;regressiv;zurückgehend
-Sport;Leibesertüchtigung;Leibesübungen;Körperertüchtigung;Körpererziehung
-Überschneidung;Schnittmenge
-Einflussgröße;Stellschraube (ugs.);Steuergröße;Parameter
-vielfältige;unterschiedliche;verschiedenerlei;diverse;verschiedenartige;verschiedene
-von hoher Kunstfertigkeit;(detailliert) ausgearbeitet;fein ziseliert (geh., fig., floskelhaft);(minutiös) ausgetüftelt;elaboriert;bis ins Detail ausgearbeitet;(bis ins Letzte) ausgefeilt
-weit verbreitet;bekannt;allgemein bekannt;ubiquitär;weitverbreitet;weithin bekannt
-Corps;Studentencorps;Korporation
-(ein) Jahrhundert... (sein);(wie es/ihn/sie) die Welt noch nicht gesehen hat;hervorstechen;(sich) auszeichnen (durch);hervorragen;(noch) nie dagewesen;ohne Beispiel (sein);einmalig (sein);Ausnahme... (+ Nomen) (sein);seinesgleichen suchen;einzigartig (sein);beispiellos (sein)
-(alles miteinander) gleichsetzen;(miteinander) vermengen;durcheinanderwerfen (ugs.);über einen Kamm scheren (ugs.);über einen Leisten schlagen;pauschalisieren;(zu stark) verallgemeinern;undifferenziert betrachten;über denselben Leisten schlagen;(fälschlich) gleichsetzen;in einen Topf werfen (ugs., fig.);(miteinander) vermischen
-so schnell wie möglich;baldestmöglich (ugs.);sobald sich die Gelegenheit ergibt;zum frühestmöglichen Zeitpunkt;zum baldmöglichsten Zeitpunkt;bei nächstmöglicher Gelegenheit;ehestens (österr.);schnellstmöglich;nächstmöglich;am besten gestern (ugs., ironisch);so bald als möglich;so früh wie möglich (Hauptform);möglichst bald;frühestmöglich;bei nächstbester Gelegenheit;schnellstens;ehestmöglich (österr.);so bald wie möglich;baldigst;möglichst früh;baldmöglichst;ehebaldigst (österr.)
-irgendwelche;x-beliebige;irgendwelche dahergelaufenen (abwertend);alle möglichen;irgendwelche beliebigen;beliebige
-Aktuator;Aktor
-(sich etwas) abschminken (ugs., fig.);(einen Plan) verwerfen;(es sich) anders überlegen;(sich etwas) aus dem Kopf schlagen (ugs., fig.)
-Hellbier;Helles (ugs., Hauptform)
-Romanschriftsteller;Romancier;Romanautor;Romanschreiber
-(finanziell) nicht ertragreich;brotlos (fig.)
-Bestimmungsfaktor;Einflussfaktor
-Schlusslicht (ugs., fig.);Letztplatzierter;Letzter;Sieger der Herzen (ugs.)
-Unbekümmertheit;Nonchalance (franz.);Zwanglosigkeit;Ungezwungenheit;Coolness (engl.);Lässigkeit;Ungeniertheit
-die Wahrheit sagen;(jemandem) reinen Wein einschenken (ugs., fig.);bei der Wahrheit bleiben
-Energieverschwendung;Energievergeudung
-Stromvergeudung;Stromverschwendung
-Awtomat Kalaschnikowa (fachspr.);Kalaschnikow;AK-47
-vollbracht;in trockenen Tüchern (ugs., fig.);gelungen;bewältigt;geschafft
-sauwohl (ugs.);sehr wohl;pudelwohl (ugs.)
-(gar) keine Frage sein;nicht infrage stehen;unumstößlich (sein);nicht die Frage sein;absolut sicher (sein);außer Zweifel stehen;außer Frage stehen;nicht in Frage stehen;bombensicher (sein) (ugs.);unbestritten sein
-Waldbienenwirtschaft;mittelalterliche Bienenhaltung;Zeidelei
-Ekranoplan;Bodeneffektfahrzeug
-schockierend;bestürzend;erschreckend
-Ich-Sucht;Selbstsucht;Egomanie
-pointiert;markig;überspitzt;reißerisch;plakativ;kernig;nicht zimperlich
-im Raum stehen lassen (ugs.);unbeantwortet lassen
-Marktteilnehmer;Marktakteur
-leer;ohne Inhalt;substanzlos;ohne Substanz;gehaltlos;hohl
-Zweifel beseitigen;(sich) versichern;Zweifel ausräumen;prüfen;Zweifel zerstreuen
-Frankfurt an der Oder;Frankfurt (Oder);Frankfurt/Oder;Frankfurt (ugs.)
-Direktheit;Unmittelbarkeit
-im Sterben liegend;moribund;sterbend
-Profit;Reibach (ugs.);(hoher) Gewinn
-äußerst suspekt;sehr zweifelhaft;mehr als fraglich
-Unterordnung;Subsumption;Schubladisierung (ugs.);Subsumtion;Subsumierung
-(etwas) ankurbeln (fig.);entstehen lassen;in Bewegung setzen;initiieren;in Gang setzen;starten;anleiern (ugs.);(der) Initiator sein;ans Laufen bringen;in Gang bringen;ins Leben rufen (fig.)
-Wiki;Wikiweb;Wikiwiki
-Beseitigung;Behebung
-vorlesungsfreie Zeit;Semesterferien
-Profitmacherei;Abzocke (ugs., Hauptform);Geldschneiderei;Geldmacherei;Abzockerei;Beutelschneiderei (geh., veraltet);Wucher
-Geradlinigkeit;Gradlinigkeit;Integrität;Geradheit
-wie jeder weiß;kein Geheimnis (sein);allgemein bekannt (sein);jeder(mann) weiß;es steht fest;ich verrate kein Geheimnis (wenn) (variabel);klar sein (ugs.)
-Mehrfachstecker;Steckdosenverteiler;Steckerleiste;Mehrfachsteckdose;Mehrfachverteiler;Steckdosenleiste
-Realitätsflüchtender;Eskapist
-apologetisch;verteidigend;rechtfertigend
-glückselig;überglücklich;von Herzen froh (geh., veraltet);hocherfreut (formell);herzensfroh (geh., veraltet);sehr glücklich;überaus glücklich
-Tor zum Garten;Gartentor
-verwenden lassen;zur Verfügung stellen;zur Nutzung überlassen;übereignen;nutzen lassen;übergeben
-aus der Hand geben (auch figurativ);hergeben;rausrücken (ugs.);herausrücken (ugs.);(jemandem etwas) überlassen (auch figurativ);abgeben (auch figurativ)
-vermisst;abgängig (Amtsdeutsch, österr.);fehlend
-rausgeworfen (ugs.);freigestellt (zynisch);gekündigt;an die frische Luft gesetzt (ugs.);gefeuert;rausgeschmissen (ugs.);entlassen;geschmissen (ugs.);rausgeknallt (derb);geschasst (ugs.)
-Falle;Hinterhalt;Überfall
-testamentarisch (fachspr.);biblisch;neutestamentarisch (fachspr.);alttestamentarisch (fachspr.)
-Sichtkonto;Girokonto
-Warenwirtschaft;Materialwirtschaft;MM (Abkürzung)
-abarbeiten;ausführen;durchführen;ablaufen lassen;verarbeiten
-Hafner;Ofenbauer
-muskelbepackt;muskulös
-ochselig (Kühe);heiß;fiebrig;rossig (Stuten);rollig (Katzen);hitzig;stierig (Kühe);paarungsbereit (Hauptform);brunftig;bockig (Schaf & Ziege);rinderig (Kühe);rauschig (Schwein);läufig;raunzig (Katze);brünstig;bullig (Kühe);rammelig
-Elmsfeuer;Sankt-Elms-Feuer;Eliasfeuer
-Energiebedarf;Energieverbrauch (ugs.)
-nutzbare Energie;Nutzenergie
-Druckluftspeicherkraftwerk;Druckluftkraftwerk;Druckluftspeicher-Gasturbinen-Kraftwerk (fachspr.);Luftspeicher-Kraftwerk
-kein Geheimnis machen (aus);nicht hinter dem Berg halten (mit);nicht verschweigen;nicht verhehlen (geh.);nicht verbergen;nicht verheimlichen;nicht zurückhalten;offen aussprechen;offen zeigen;keinen Hehl machen (aus) (Hauptform);offen sagen
-Schwaben;Schwabenland;Schwabenländle (ugs., schweiz., schwäbisch)
-Handschalthebel;Schaltknauf;Ganghebel;Wählhebel;Schaltknüppel;Gangwahlschalter;Gangwahlhebel;Schalthebel
-Pornokino;Sexkino;Erotikkino
-Pornofilm;Sexfilm
-börsengehandelt;börsennotiert
-Biosignalgerät;Polygraf;Lügendetektor (ugs.);Polygraph
-Juristenchinesisch (ugs., abwertend, fig.);Juristenlatein (ugs., abwertend);Juristendeutsch (ugs.);juristische Fachsprache
-auf See;offshore;vor der Küste
-Scheherazade;Scheherezade
-Profifußballer;Fußballprofi;professioneller Fußballspieler
-Profihandballer;Handballprofi;professioneller Handballspieler
-Profibasketballer;Basketballprofi
-Profiradrennfahrer;Radrennprofi
-Bestandnehmer;Mieter;Pächter
-(sich) vertschüssen (ugs.);abhauen (ugs.);(sich) davonmachen;(sich) verkrümeln (ugs.)
-Anthropogenese (fachspr.);Menschwerdung;Anthropogenie (fachspr.);Hominisation (fachspr.)
-(sich) in Zuversicht üben;Licht am Ende des Tunnels sehen (ugs., fig.);zuversichtlich in die Zukunft blicken;ein gutes Gefühl haben (ugs.);glauben an;zuversichtlich sein;optimistisch in die Zukunft schauen;den Silberstreif am Horizont sehen (ugs., fig.);optimistisch sein (Hauptform)
-Golfprofi;Profigolfer;professioneller Golfspieler
-Erklärungsnot;Erklärungsdruck
-eine Handbreit Wasser unterm Kiel wünschen (ugs.);(jemandem) die Daumen drücken (ugs.);(jemandem) Glück wünschen
-zuteil werden lassen;verwenden auf;angedeihen lassen;entgegenbringen;zukommen lassen;zugutekommen lassen
-WM-Leader;Weltmeisterschaftsführender
-Ferialarbeit (österr.);Ferialjob (österr.);Ferialpraxis (österr.);Ferienjob
-Pikett (Kurzform, schweiz.);Bereitschaftsdienst;Pikettdienst (schweiz.);Journaldienst (österr.)
-Karenz (ugs., österr.);Karenzurlaub (österr.);Karenzzeit (österr.)
-Schweinebraten;Schweinsbraten (bayr., schweiz., österr.)
-Pappmaché;Papiermaché;Papiermachee;Pappmachee
-nachfolgend;weiter unten;im Weiteren;nachstehend;in einem der nächsten Absätze (variabel);im Folgenden;später;im weiteren Verlauf des Textes;folgend;im nächsten Absatz (variabel)
-CO;Kohlenstoffmonoxid;Kohlenstoffmonooxid (fachspr.);Kohlenmonoxid
-Taxifahrer;Taxichauffeur;Taxler (ugs.)
-Schulhof;Pausenhof
-Bibliographie (fachspr.);Literaturverzeichnis;Literaturliste
-konsistent;stimmig;widerspruchsfrei
-Kapitalherabsetzung;Kapitalschnitt
-Kapitalerhöhung;Erhöhung des Eigenkapitals
-Qbit (selten);Quantenbit;Qubit
-(nur) einen Steinwurf weit (ugs., fig.);nur ein paar Schritte von hier (ugs.);in nächster Nähe;muss hier irgendwo sein (ugs.);in geringer Entfernung;nur ein paar Schritte von hier zu laufen (ugs.);ganz nah;in Reichweite;(nur) einen Steinwurf entfernt (ugs., fig.);ganz in der Nähe (ugs.);(nur eine) kurze Strecke zu laufen (ugs.);nahebei;nicht weit von hier;irgendwo hier (ugs.);nur ein paar Schritte von hier entfernt;leicht erreichbar;nicht weit weg (ugs.);da kannste hinspucken (ugs.);(nur ein) kurzes Stück zu laufen (ugs.);(gleich) da vorne (ugs.);(nur) einen Katzensprung entfernt (ugs., fig.);hier irgendwo (ugs.);gleich hier (ugs.);(nur) ein Katzensprung (von hier) (ugs., fig.);(gleich) um die Ecke (ugs.)
-Bildungsclip (ugs.);Bildungsvideo (fachspr.)
-Bildungskurzfilm (fachspr.);Bildungsvideo
-Außenbordmotor;Außenborder
-Innenbordmotor;Innenborder
-KGV (Abkürzung);Gewinnmultiplikator;Kurs-Gewinn-Verhältnis
-Kennzahl zur Bewertung von Aktien;Aktienkennzahl
-KBV (Abkürzung);Kurs-Buchwert-Verhältnis
-Kurs-Cash-Flow-Verhältnis;KCF (Abkürzung);KCV (Abkürzung)
-KUV (Abkürzung);Kurs-Umsatz-Verhältnis
-Tobin's Q;Marktwert-Buchwert-Verhältnis;Kurs-Substanzwert-Verhältnis
-Glückssache (Hauptform);Glücksache (ugs., selten);hängt vom Zufall ab;Fifty-Fifty-Sache;kommt immer drauf an (ugs.)
-Supply Chain (fachspr.);Lieferkette;Versorgungskette;logistische Kette
-Radsatzfahrmasse;Achsdruck (ugs.);Achsfahrmasse;Achslast;Radsatzlast
-auspreisen;mit Preisen versehen;auszeichnen
-Schenkender;Zuwendender;Gönner;Schenker
-verschränken;überkreuzen
-(sich) anstellen;anstehen;(sich) einreihen;Schlange stehen (ugs.);(sich) in die Schlange stellen;(in einer Schlange) warten
-verteilt;verstreut;dispers;versprenkelt
-Inkrustation (fachspr.);Krustenbildung
-Sezessionskrieg;Amerikanischer Bürgerkrieg
-mucksmäuschenstill (ugs.);totenstill;(ganz) still;(ganz) leise
-Selchspeck (österr.);Räucherspeck
-bei Gelegenheit (geh., veraltend);aus Anlass (von);anlässlich;angelegentlich (fachspr., Amtsdeutsch);auf Grund;aufgrund
-vorziehen;Vorrang einräumen;priorisieren
-Newtonmeter;Nm (Einheitenzeichen)
-Wh (Einheitenzeichen);Wattstunde
-kWh (Einheitenzeichen);Kilowattstunde
-Zahlungsaufforderung;Mahnschreiben;Mahnung;Zahlungserinnerung
-adressiert;angesprochen
-adressieren (geh.);das Wort richten (an);anquasseln (ugs.);anreden;ansprechen;anlabern (ugs., abwertend);anquatschen (ugs.)
-Waschbecken;Lavabo (schweiz.);Waschtisch;Waschmuschel (österr.)
-Ergänzungsnahrung;Zukost;Beikost
-autorisiert (sein);grünes Licht haben;berechtigt (sein);befugt;(tun) dürfen
-herausgeschnittene Filmszene;Outtake
-Klartraum;luzider Traum
-Falschschreibung;Rechtschreibfehler (Hauptform);Orthografiefehler (geh.);Fehlschreibung
-hemdsärmelig;locker;ungezwungen;salopp;hemdärmelig (schweiz., österr.);bequem;hemdärmlig (schweiz.)
-Scharfschützengewehr;Präzisionsschützengewehr;Präzisionsgewehr
-Heizerei (ugs.);Treibstoffverschwendung;Treibstoffvergeudung
-Kleingartenverein;KGV (Abkürzung);Gartensparte (ostdeutsch);Kleingärtnerverein
-Druckluftbombe (ugs.);Vakuumbombe (ugs.);Aerosolbombe
-Karteileiche (ugs.);passives Mitglied
-Gänseküken;Gössel
-(Rechnung) begleichen;(Rechnung) liquidieren;(Rechnung) bezahlen;saldieren
-Bauchdeckenstraffung;Bauchdeckenplastik;Bauchstraffung
-lässig;mit dem kleinen Finger (fig.);ohne jede Anstrengung;aus dem Handgelenk (fig.);(immer) locker vom Hocker (ugs., Spruch);spielerisch;ohne die geringste Mühe;mal eben so (ugs.);mit routinierter Gelassenheit;ohne Mühe;aus dem Effeff (ugs.);im Schlaf (ugs., fig.);mit Leichtigkeit;mit leichter Hand;ohne Anstrengung;mit links (ugs.);unangestrengt;mit spielerischer Leichtigkeit;mühelos (Hauptform);ganz easy (ugs.)
-zwischenmenschlich;interpersonell
-Fummelbunker (ugs.);Spielhalle;Spielothek;Spielhölle (ugs.);Zockerbude (derb)
-Dienstleistungswüste;Servicewüste
-Freiheit des Zeichens;Arbitraritätsprinzip
-ein Loch haben;undicht sein;(Flüssigkeit) verlieren;lecken;suppen (ugs., salopp);ein Leck haben
-Pulli (ugs.);Sweatshirt;Pullover
-Approximation;Näherung
-Asset;(ein) Extra;Zusatzposten;Sonderausstattung
-Jazzmusiker;Jazzer
-Arschfick (vulg.);Analverkehr;Analkoitus
-televisionieren (schweiz.);(im Fernsehen) übertragen
-Eigengebrauch;zum persönlichen Gebrauch;zum privaten Nutzen;Eigennutz
-Luftröhrenast;Bronchie
-freie Bahn (fig.);ungehindert;uneingeschränkt;ohne Beschränkung;frei;ohne Limit
-blank;bloß;ohne;bar;frei;nackt
-wohl;gedeihlich (geh.);gut;nützlich;trefflich
-Bahnradler;Bahnradfahrer
-Organspendeausweis;Organspenderausweis
-Geschäftsprozessmanagement;Prozessmanagement
-Bache;Wildsau;weibliches Wildschwein
-Epidemiologie;Seuchenkunde (veraltet);Seuchenlehre (veraltet);Epizootiologie
-definitorisch;mit Hilfe einer Definition
-Unternehmergeist;Unternehmermentalität;Entrepreneurship (fachspr., engl.)
-Gefühlsblindheit;Alexithymie (fachspr.)
-Krankheitshäufigkeit;Prävalenz
-Blickbewegungsregistrierung;Okulographie
-Rechnungsintervall;Zahlungszeitraum
-(sehr) lang;ellenlang
-Rollkragenpullover;Rolli (ugs.);Rollkragenpulli (ugs.)
-die Mehrheit;das Gros;bis auf wenige Ausnahmen;ein Großteil;fast alle;die meisten (Hauptform)
-reimen;(ein) Gedicht verfassen;Gedichte schreiben;dichten;Verse schmieden
-wackeln;torkeln (ugs.);geigeln (ugs., österr.)
-(jemandem) etwas vergällen;(jemandem) die Freude verderben;(jemandem) den Spaß verderben
-Betriebszeit;Verfügbarkeit;Uptime
-vorexerzieren;mit gutem Beispiel vorangehen;zeigen, wie man etwas richtig macht;vormachen;demonstrieren
-Chipkartenlesegerät;Chipkartenleser
-Hephäst;Vulcanus (römisch);Hephaistos (griechisch)
-Kartenleser;Kartenlesegerät
-Mamsell (ugs.);leitende Hausgehilfin
-namensgleich;gleich benannt;gleichnamig
-aufgrund der außerordentlichen Umstände (geh.);(nur) dieses eine Mal;(kann) schon einmal (ugs.);schon mal (ugs.);ausnahmsweise (Hauptform);im Gegensatz zu sonst;außer der Reihe;unplanmäßig;ungeplant;(nur) im Ausnahmefall;(nur) weil du es bist (ugs.);unüblicherweise;(nur) aufgrund der besonderen Umstände
-in die Hose gehen (ugs.);nicht zustande kommen;nach hinten losgehen (ugs.);kläglich scheitern;fehlgehen;in die Binsen gehen (ugs.);ausgehen wie das Hornberger Schießen (ugs., Redensart, scherzhaft);scheitern;missglücken;fehlschlagen (Hauptform);danebengehen (ugs.);floppen (ugs.);missraten;nicht zu Stande kommen;schiefgehen (ugs.);fallieren (geh., schweiz.);misslingen
-beauftragt;betraut
-xerographieren;xerografieren;fotokopieren;kopieren (ugs.)
-Soli (ugs.);Solidaritätszuschlag
-Mumbai;Bombay (veraltet)
-Zirkel;Rat;Ausschuss;Beirat;Gremium;Arbeitskreis;Kommission;Komitee;Junta (portugiesisch, spanisch)
-Schlafkrankheit (ugs.);Schlafsucht;Hypnolepsie (griechisch);Narkolepsie (fachspr., griechisch);Schlummersucht (ugs.)
-Sitzung;Session (engl.)
-Stumpfheit;Stupor;Dummheit
-leer;ausgehöhlt;hohl
-Kobra;Brillenschlange;Naja naja
-eruktieren;ein Bäuerchen machen (helfen) (ugs.);rülpsen (ugs.);aufstoßen
-annotieren;auszeichnen
-durch den Arzt verursacht;iatrogen (fachspr.)
-Überriese;Gigant;Riese;Sterngigant;Riesenstern
-Wunderheilung;geistige Heilung;Handauflegen (ugs.);spirituelle Heilung;Geistheilung
-(unter Eid) bezeugen;(unter Eid) erklären;(unter Eid) aussagen;schwören (dass)
-Falschalarm (Hauptform);Technischer Alarm;Blinder Alarm;Böswilliger Alarm;Fehlalarm (Hauptform);Täuschungsalarm
-Schreibwaren;Bürobedarf;Büroartikel;Büromaterial
-(jemandem) bei Schwierigkeiten helfen;(jemanden) heraushauen (ugs.);(jemanden) raushauen (ugs.);(jemandem) den Arsch retten (derb);(jemanden) aus einer Notlage befreien;(jemanden) herauspauken (ugs.);(jemandem) aus der Klemme helfen (ugs.);(jemanden) retten;(jemandem) bei Problemen helfen;(jemanden) aus einer misslichen Lage befreien;(jemandem) aus der Patsche helfen (ugs.);(jemanden) rausboxen (ugs.)
-Feldrand;Ackergrenze;Wegrand (in landwirtschaftlich genutztem Gebiet);Feldrain;Wegesrand;Rain
-EdT (fachspr.);EdP (fachspr.);EdC (fachspr.);EdS (fachspr.)
-EdS-Parfums;EdS
-Eau de Cologne;EdC;Kölnisch Wasser
-EdT;Eau de Toilette
-EdP;Eau de Parfum
-Kampfkunst;Machetik (griechisch);Kampfsport;Kampflehre
-baumloses Grasland;baumlose Graslandschaft;Prairie (Nordamerika);Steppe;Grassteppe (Hauptform);Savanne (Afrika);Busch;Buschsteppe;Pampa (Südamerika)
-schnelle Nummer (ugs.);Quickie (ugs.);flotte Nummer (ugs.);Schnellfick (derb)
-Trajektfähre;Eisenbahnfährschiff;Trajektschiff;Eisenbahnfähre
-Luxusartikel;Luxusprodukt;Luxusgut
-Trade;Spekulation;Börsenspekulation;Zock (ugs.)
-Ablegerbildung;Stecklingsvermehrung (Gärtnersprache)
-Glockenturm;Kirchturm (Hauptform)
-Boson;Vermittlerteilchen
-hineingeben;hineinlegen;einfüllen;reintun (ugs.)
-(sich) exponieren (geh.);(sich) aus dem Fenster hängen (ugs., fig.);ins Rampenlicht treten (auch figurativ);(sich) profilieren;(sich) hervorwagen;(sich) hervortun (mit / bei)
-feige sein;(sich) nicht trauen;keine Traute haben (ugs.);mauern (ugs.);(sich) zurücknehmen;den Schwanz einziehen (ugs., fig.)
-Nebeneinanderstellung;Gleichrangigkeit;Parataxe (fachspr.);Gleichordnung
-Dracula (literarisch);Vampir;Blutsauger;Nosferatu (literarisch)
-Kapelle;Oratorium
-Sternschnuppe (ugs.);Meteor (Hauptform)
-dieser;solcher;jener;welcher;der
-Lebenshaltungskosten;Lebensunterhalt;Lebensführungskosten
-Dialektologe;Mundartforscher
-vertragen;abkönnen (ugs.);mitmachen (ugs., fig.);verknusen (ugs.);aushalten;klarkommen (mit) (ugs.)
-Aromatik (fachspr.);Bukett;Duft (von Wein);Aroma;Blume;Bouquet (franz.)
-Gewicht;Ballast
-Movens;Beweggrund
-Rüster;Ulme (Hauptform);Effe;Ruste
-Schwefel (Hauptform);S (Elementsymbol);Sulfur;Sulphur (griechisch);Sulpur (lat.)
-Essig;Würzessig;Reisessig;Apfelessig
-Methylcarbonsäure;Ethansäure (fachspr.);Ethoxylsäure;Holzsäure (veraltet);Acetoxylsäure;Methylameisensäure;Acidum aceticum (lat.);AcOH;Acetic Acid (INCI, engl.);Säureessig;Essigsäure (Hauptform);Äthansäure (veraltet);Acetylsäure (veraltet);E 260
-Schlüsselband;Lanyard
-Echter Wermut;Bitterer Beifuß;Gemeiner Wermut;Wermut;Artemisia absinthium (fachspr., griechisch, lat.);Alsem;Echt-Wermut;Wermutkraut
-Sonnenblume;Helianthus annuus
-Eller;Erle
-Ameisensäure;Methansäure
-Konklusion;Rückschluss;Implikation (fachspr.);Schlussfolgerung;Folgerung;Konsequenz;logische Folgerung
-Luftpartikel;Aerosol
-Reflexionsvermögen;Rückstrahlungsvermögen (einer Oberfläche);Albedo
-Lied;Song
-Instrumentalstück;Instrumental (fachspr., Jargon, engl.)
-Sonate;mehrsätziges Instrumentalstück
-Choral;Kirchengesang;Gesang
-Habilitation;Erwerb der venia legendi;Erwerb der akademischen Lehrerlaubnis
-Habilitationsschrift;Habil (ugs.)
-Zange;Knieper (ugs., norddeutsch)
-Eckrohrzange;Schwedenzange;Rohrzange (Hauptform)
-MG (Abkürzung);Maschinengewehr
-Gewehr mit glattem Lauf;Schrotgewehr;Flinte;Schrotflinte
-Büchse;Gewehr mit gezogenem Lauf
-Gewehr mit verkürztem Lauf;Karabiner;Reiterflinte
-Selbstladegewehr;Repetiergewehr;halbautomatisches Gewehr
-Hiebwaffe;Stichwaffe
-Sprengfalle;Mine
-Marschmusik;Marsch;Militärmusik
-Kantate;Lied
-Heft (eines Messers);Schaft;Griff;Henkel (Essgeschirr);Griffstück (Hauptform);Knauf (Möbelbeschlag);Handgriff (ugs.);Anfasser (ugs.)
-Arbeitsergebnis;Handlungsprodukt (Psychojargon);Schaffen (geh.);Werk;Opus (geh.)
-Kunstobjekt;künstlerisches Werk;Kunstwerk
-Frührente;vorzeitiger Ruhestand;Frühpension;Vorruhestand
-Frühpensionist;Frührentner
-exzitatorisch;erregend (fachspr.)
-(etwas) kommunizieren;unters Volk bringen;bekannt machen;bekanntmachen;notifizieren (geh., veraltet);mitteilen
-Bilinguität;Bilingualität;Bilingualismus;Bilinguismus;Zweisprachigkeit (Hauptform)
-Mehrsprachigkeit;Multilingualismus
-Speläologie (fachspr.);Speleologie (fachspr.);Höhlenforschung;Höhlenkunde
-Speläologe;Höhlenforscher;Höhlenkundler
-genotypisch;erbmäßig
-Phänotyp;Erscheinungsform;Erscheinungsbild
-phänotypisch;vom Erscheinungsbild her
-Webradio;Internetradio
-Futurologie;Zukunftsforschung
-Kombüse;Schiffsküche;Bordküche
-konzentriert;aggregiert;angesammelt;zusammengeballt
-ländlich;rural (veraltend);bäuerlich
-Selbstreferenzialität (geziert) (geh.);Rekursion;Autoreferentialität (geziert) (geh.);Selbstbezüglichkeit;Mise en abyme (fachspr., franz.);Selbstreferentialität (geziert) (geh.);Autoreferenzialität (geziert) (geh.)
-Geschmackssache;Geschmacksache;persönliche Vorliebe;Stilfrage;Geschmacksfrage;Ansichtssache
-genießerisch;sinnenfreudig;sinnlich;genussvoll;genüsslich;lustbetont (geh., ironisierend);genussreich;hedonistisch (geh.);lustvoll
-Lasurit;Lasurstein;Lapislazuli (Hauptform);Lapis lazuli (lat.);Coeruleum scythium (lat.);Ultramarin echt;Orientalischblau
-Mittler;Mittel;Informationsträger;Kommunikationsträger;Medium
-Schnick, Schnack, Schnuck;Schere, Stein, Papier
-gute Neuigkeit;Aufsteller (schweiz.);positive Überraschung;Erfolg
-Lustlosigkeit;Verdrossenheit;Leck-mich-am-Arsch-Einstellung (derb);Verdruss
-platzenlassen;platzen lassen
-spontane Reaktion;übereilte Aktion;Affekthandlung;unüberlegte Entscheidung;Schnellschuss (ugs.);Kurzschlusshandlung
-(übertriebene) Emotionen;(übertriebene) Emotionalität;Gefühlsduselei (ugs.)
-Skiproduzent;Skierzeuger;Skihersteller
-Saline;Salzbergwerk;Anlage zur Salzgewinnung
-Homiletik;Predigtlehre
-Liturgik;Liturgiewissenschaft
-Paradeissoße (österr.);Paradeissauce (österr.);Tomatensoße;Tomatensauce
-Perronkante (schweiz.);Bahnsteigkante
-Perrondach (schweiz.);Bahnsteigdach
-so, dass;auf die Weise, dass;dadurch, dass;indem
-Karyokinese;Mitose (fachspr.);indirekte Kernteilung
-Overhead (engl.);Verlangsamung;Überhang;Verwaltungsaufwand;Datenüberhang
-ausarbeiten;bis zum letzten Detail fertigstellen;elaborieren
-ebenhin;vor kurzer Zeit;geradehin;anhin (schweiz.);bisher;vorhin;gerade eben;gerade (ugs.)
-Ablaufstrang;leichtgewichtiger Prozess;Abarbeitungsfaden;Aktivitätsträger;Thread
-lukulent (veraltet);lichtvoll;klar
-Möglichkeit;Unwägbarkeit;Chance;Risiko;Eventualität
-Schema;Vorlage;Modell;Vorbild
-Erdgas (ugs.);Methylwasserstoff;Methan
-hervorbringen;herstellen;synthetisieren;erschaffen;bewirken
-feierlich vorbeimarschieren;vorbeigehen;defilieren;paradieren;eine Parade abhalten
-Zischlaut;Sibilant
-von zweifelhaftem Ursprung;apokryph
-Trimmer (ugs.);Poti (ugs.);Potenziometer;Potentiometer
-streng päpstlich gesinnt;ultramontan
-Herrschaft des Geldes;Geldherrschaft;Plutokratie;Plutarchie
-die Bewegung betreffend;kinetisch
-Stöckelschuh;Heels (ugs., Plural, engl.);Stöckel (ugs.);High Heel (engl.);Louboutin (geh., selten);Stiletto
-(jemandem) offenstehen;(sich jemandem) bieten (Chance, Gelegenheit);(sich jemandem) eröffnen (Option, Möglichkeit)
-Scheduling (fachspr.);Zeitzuteilung;Zeitgebung
-Execution (fachspr.);Verarbeitung;Ablauf;Abarbeitung;Ausführung
-hervortretend;entstehend;emergent;auftretend;aufkommend;(sich) ergebend;auftauchend
-zu Tage treten;zutage treten;in Erscheinung treten;erscheinen;hervortreten;zu sehen sein;(sich) zeigen
-emergent;zustande kommend
-(jemandem) kommt der Gedanke;verfallen auf (geh.);(plötzlich) die Idee haben (...) (ugs.);in den Sinn kommen;es für eine gute Idee halten (zu / dass) (ugs., ironisch);(jemandem) einfallen;auf die Idee kommen (zu);um die Ecke kommen mit (ugs., fig.);(sich etwas) denken (bei) (ugs.);(jemanden) überkommen (es) (geh.);auf den Gedanken verfallen (zu);(sich) einfallen lassen;(einen) Rappel kriegen (und...) (ugs.);auf die glorreiche Idee kommen (zu) (ugs., ironisch);(sich) bemüßigt fühlen (zu) (geh., ironisierend);(es sich) nicht verkneifen können (zu);(jemandem) belieben zu (es) (geh.);(sich) (etwas) überlegen;nichts Besseres zu tun haben als;(jemanden) anwandeln (geh.);kommen (auf) (ugs.);(jemanden) anwehen (geh.);(den) Einfall haben (...) (ugs.);(auf einmal) ankommen mit (ugs.)
-Umbau;Umstrukturierung
-Pendeluhr;Pendule;Pendüle
-lieb;geliebt;teuer;bejubelt;geschätzt;verehrt;geehrt
-füsilieren;an die Wand stellen;(standrechtlich) erschießen
-(Gegend) im Schritt (verhüllend);Schambereich (Hauptform);Intimbereich;Schamgegend;Scham;Schrittbereich (verhüllend)
-demokratisch;kooperativ;partizipativ
-Markteffizienztheorie;Effizienzmarkthypothese;Effizienzmarkttheorie
-Souffleuse (weibl.);Einflüsterer;Zuflüsterer;Souffleur (männl.)
-nichtsdestoweniger;wenigstens;gewiss;trotz und allem;gleichwohl;abseits dessen (geh.);allein (geh.);(aber) was soll ich sagen, ... (ugs., floskelhaft);sicherlich;nichtsdestotrotz;wie auch immer;davon ab (ugs.);zugegeben;jedoch;dies sei zugestanden (geh.);immerhin;zumindest;ungeachtet dessen (geh., Jargon, juristisch);trotzdem;aber;freilich;schließlich;trotz alledem;abgesehen davon;indessen;unbeschadet dessen (fachspr., Amtsdeutsch);sicher;dessen ungeachtet;nichtsdestominder;indes (geh.);allerdings (Hauptform);zugegebenermaßen;jedenfalls
-unterliegend;unter Ausnutzung von;zu Grunde liegend;zugrunde liegend;auf Basis von;zugrundeliegend;unter Verwendung von
-realisieren;abbilden
-großenteils;gutenteils (veraltet);großteils;weitgehend;nahezu vollständig;größtenteils;überwiegend;in weiten Teilen;weit gehend
-vor alledem;vorderhand;vordringlich;hauptsächlich;vorerst;zuvörderst (veraltend);zuvorderst;erst einmal;vor allem
-Anforderung;Funktionalität;Erfordernis;Anspruch;Forderung;Bedarf
-Vorzeichen;Anklang;Vorgeschmack
-vorgreifen;anschneiden;anklingen lassen
-Lastverteilung;Parallelisierung
-programmierbar;benutzerdefiniert;personalisierbar
-sprachspezifisch;spracheigen
-Einrichtung;Mechanismus;Apparatur;Vorrichtung (Hauptform)
-Versorgung;Erbringung;Verfügbarmachung;Bereitstellung;Zurverfügungstellung
-Verstichwortung;Beschlagwortung (bayr., österr.);Verschlagwortung;Klassifizierung;Klassifikation;Indexierung
-Exaltation (fachspr., bildungssprachlich, psychologisch);Aufregung;Fieber (fig.);Erregung;Erregtheit;Aufgeregtheit
-lavieren;herumlavieren (abwertend);herumjonglieren;taktieren;Schwierigkeiten meistern;Klippen umschiffen (ugs.);(sich) durchschlängeln (fig.);jonglieren
-auffordern;appellieren;aufrufen;(sich) wenden an
-Eurogebiet;Euroland (ugs.);Euroraum;Eurozone;Euro-Währungsgebiet
-andersherum;dagegen;dafür;andersrum (ugs.);entsprechend;wiederum;im Gegenzug;umgekehrt;hingegen
-überlegen;besser;richtiger;passender;größer
-Einsatzbericht;Stundenzettel
-in kleinen Einheiten/Schritten;feinkörnig;in kurzen Abständen;feingranular
-hervorbringen;zuwege bringen (ugs.);erreichen;zu Stande bringen;zu Wege bringen (ugs.);auf die Beine stellen (ugs., fig.);zustande bringen
-zuteil werden lassen;geben;zuteilen;zukommen lassen;ermöglichen
-verschenken;schenken;spendieren;geben
-Bestandteil werden;(bei der Produktion) verbraucht werden;Gebrauch finden;eingehen;Eingang finden
-unbestimmt;allgemein gültig;immersiv (fachspr.);universell;generell;umfassend;absolut;global;allgemeingültig;allumfassend
-sonst;beziehungsweise;oder (Hauptform);andernfalls
-Lophophora williamsii (fachspr., griechisch);Mescalbuttons;Mescal;Peyotl (aztekisch);Peyote;Schnapskopf;Challote;Pellote
-Wiederbringung;Wiederherstellung;Apokatastasis (fachspr.);Allaussöhnung
-die Lehre von den Hoffnungen auf Vollendung;Eschatologie
-Bankraub;Banküberfall
-Organische Chemie;Kohlenstoffchemie;Organik
-Pulsstrahltriebwerk;Argus-Schmidt-Rohr;Argus-Rohr;Verpuffungsstrahltriebwerk;Schmidt-Rohr;Pulso-Schubrohr;Pulsrohr;Pulsotriebwerk
-Bundesministerium für Gesundheit;BMG;Bundesgesundheitsministerium
-Einsatzfeld;Einsatzgebiet;Bereich
-(sich) einer Sache bedienen;bedingen;auslösen
-Rechengang;Operation;Rechenschritt;Einzelschritt;Verarbeitungsschritt
-Manipulation;Operation (Lese-/Schreibop.);Zugriff
-nebenläufig;nebenher;nebeneinander
-Abarbeitung;Verarbeitung;Bearbeitung
-Elision;Auslassung
-zwei oder mehr;nicht alleine;mehrere;mehr als einer;mindestens zwei;nicht nur einer
-im Alleingang;solo;ohne fremde Hilfe;für sich;(ganz) alleine;selber;einzeln
-einfach;trivial;leicht;simpel
-(ist) möglicherweise (so);mag (sein);kann (sein);möglich (sein);kann sein, kann nicht sein
-Schmierinfektion;Kontaktinfektion
-Kontagiosität (fachspr.);Ansteckungsfähigkeit (eines Erregers)
-Gegenstand;Thematik;Aufgabenstellung;Angelegenheit;Themengebiet;Problemstellung;Sujet (geh.);Fall;Themenstellung;Materie
-Vexillologie;Fahnenkunde;Flaggenkunde
-Metallurgie;Hüttenwesen
-für den Fall der Fälle;Man weiß ja nie. (ugs., Spruch);(nur) für den Fall, dass.
-Klon;Abbild;Ebenbild
-Trauerkloß (ugs.);Stimmungskiller (ugs.);Fadian (ugs., österr.);Partykiller (ugs.);Griesgram (ugs.);Muffkopp (ugs., rheinisch);Nieselpriem (ugs.);Isegrim (ugs.);Knasterer (ugs.);Murrkopf (ugs.);Miesepeter (ugs.);Miesmacher (ugs.);Grantscherm (ugs., österr.);Muffel (ugs.);Spaßbremse (ugs., Hauptform);Sauertopf (ugs.)
-Üppigkeit;Opulenz;Abundanz;Reichhaltigkeit
-Grundrechnung;Rechnung;Formel;Gleichung
-unüberhörbar;laut und deutlich;vernehmlich;weithin hörbar;ohrenfällig (geh., selten);nicht zu überhören;(deutlich) hörbar;mit kräftiger Stimme;laut
-anberaumen;anordnen;festsetzen;ansetzen;einberufen
-(jemanden) im Auge haben (für) (ugs., fig.);(jemanden) einplanen;(an jemanden) denken (bei) (ugs.);(jemanden) vorsehen (für)
-(unter) Verarbeitung;(in) Bearbeitung;(in der) Produktion
-systematisch mit garantierter Ergebnisfindung;algorithmisch
-Umstrukturierung;Restructuring (engl.);Restrukturierung
-umstrukturieren;überführen;restrukturieren;umwandeln
-beiderartig (selten, veraltet);beiderlei;zwei Arten von;beide (Arten von);zweierlei
-allerhand;allerlei;verschiedenerlei;mehrerlei;alle möglichen und unmöglichen (scherzhaft);alle möglichen;vielerlei;verschiedenes (an);mancherlei
-(ein) Unterschied wie Tag und Nacht;was anderes (ugs.);(ein) anderes Paar Schuhe (sein) (ugs., fig.);grundverschieden;(eine) andere Geschichte (ugs.);ganz anders;etwas ganz anderes;sehr viel angenehmer (variabel);weitaus besser (geh., variabel);was ganz anderes (ugs.);(das ist) kein Vergleich (ugs.);(eine) ganz andere Sache sein;in keiner Weise vergleichbar;(es) liegen Welten zwischen (... und ...);etwas anderes (Hauptform);nicht zu vergleichen;auf einem anderen Blatt stehen (fig.);(es) liegen Welten dazwischen;(überhaupt) nicht zu vergleichen (sein) (ugs.);ganz was anderes (sein) (ugs.);nicht vergleichbar;etwas völlig anderes
-Abbildung;Umwandlung;Konvertierung;Überführung;Transformation
-entmannen;abälardisieren;sterilisieren;kastrieren
-adhärieren (veraltet);anhaften
-stimmen;zutreffen (Hauptform);hinkommen (ugs., salopp);der Fall sein;richtig sein;korrekt sein;wahr sein;dem ist so;so sein;seine Richtigkeit haben;zutreffend sein;gegeben sein;den Tatsachen entsprechen
-dangling reference (fachspr.);verwaiste Referenz
-welches;was
-Unfreundlichkeit;Unhöflichkeit
-Wettkampfteilnehmer;Agonist;Wettkämpfer
-kutterähnliches Segelboot;Schaluppe
-Kacke (derb);ätzend (ugs.);lahm (ugs.);uncool (ugs.);ungeil (ugs.);doof (ugs.);scheiße (derb)
-vielerorts;häufig;an vielen Orten;in vielen Städten
-deftig;kräftig;geschmacksintensiv;würzig;umami (japanisch);herzhaft
-(und) auch;darüber hinaus;ein Übriges tun;und;(und) zusätzlich;und dazu;zu allem Überfluss;zum Überfluss;mehr noch;außerdem (Hauptform);noch dazu;überdies;obendrein;fürderhin (geh., altertümelnd)
-verteilungsfähig;parallelisierbar;verteilbar
-Leistungsfähigkeit;Geschwindigkeit;Performanz;Leistung
-künstlich am Leben halten;finanziell unterstützen;durchfüttern (ugs., auch figurativ);unterhalten;aushalten (abwertend);alimentieren
-von Seiten;vonseiten;durch;von (Hauptform);seitens (Amtsdeutsch)
-zusammentragen;zusammenfügen;bilden;zusammenschreiben;zusammenbauen
-kongruent;deckungsgleich;identisch;übereinstimmend
-Automutilation (fachspr.);Selbstverstümmelung
-Komintern (Kurzform);Kommunistische Internationale;Dritte Internationale
-richtungslos;ziellos;absichtslos;ungerichtet
-(sich) in die Nesseln setzen (ugs.);einen Fauxpas begehen;ins Fettnäpfchen treten;einen Bock schießen (ugs.);(sich) blamieren
-ordnungslos;permutierbar
-eingeflochten;verwoben;durchwirkt
-Interlunium (fachspr.);Neumond
-anfügend;ergänzend;zusammentuend;hinzufügend;additiv;beifügend
-Entfall;Verlust;Ellipse (rhet., ling.) (fachspr.);Wegfall;Streichung;Weglassung;Fortfall;Auslassung
-gemein;untergriffig;boshaft
-dissoziales Verhalten;Asozialität;Gefühlskälte (ugs.);dissoziale Persönlichkeitsstörung;antisoziale Persönlichkeitsstörung;Psychopathie (ugs.);Sozialversagen;Soziopathie (veraltet)
-Teekesselchen (ugs.);Äquivokation (Philosophie);Homonym
-Sueskanal;Suezkanal
-Ladenhüter (ugs.);schwer verkäufliches Produkt
-lasziv;zügellos;verführerisch;herausfordernd;übermütig;geil (ugs.);sinnlich
-Dorno-Strahlung;UV-B-Strahlung;Dornostrahlung
-Befürworter;Verteidiger;Verfechter;Fürsprecher;Vertreter;Apologet (geh.);Anwalt (einer Sache) (fig.);(ein) Herold (des / der) (geh., fig.)
-Kronenkorken;Bierkapsel (österr.);Kronkorken
-Privatinsolvenzverfahren;Verbraucherinsolvenzverfahren;Schuldenregulierungsverfahren (österr.)
-Verbraucherinsolvenz;Privatkonkurs (schweiz., österr.);Privatinsolvenz
-Stagflation;Stagnation und Inflation
-(sich) um etwas herumdrücken (ugs.);vermeiden;(etwas) meiden wie der Teufel das Weihwasser (sprichwörtlich, variabel);einen (weiten) Bogen machen (um) (ugs.);bleiben lassen (ugs.);meiden;bleibenlassen (ugs.);auf Abstand bleiben;scheuen;zu vermeiden suchen;umgehen;(sich) vor etwas drücken (ugs.);versuchen zu vermeiden
-Überarbeit;Mehrarbeit;Überzeit (schweiz.);Überstunden;Zusatzverdienst;Plusstunden (ugs.)
-kugelsicheres Glas;Panzerglas
-vielfacher Millionär;mehrfacher Millionär;Multimillionär
-Panzerabwehrkanone;PaK
-Gelsenstich (österr.);Mückenstich
-hübsch;gepflegt;adrett;ordentlich
-die Definition betreffend;definitorisch
-semantisch;bedeutungsmäßig
-Motiv;Bildmotiv (ugs.);Thema;musikalisches Thema;Tonfigur;Bildthema (fachspr.)
-Sonnenkollektor;Solarkollektor
-umsetzen;durchführen;abwickeln;realisieren;ausführen;vollführen;leisten;bewerkstelligen;erledigen;verrichten
-Tomatenmark;Paradeismark (österr.)
-Stromunfall;Elektrounfall;elektrischer Schlag (ugs.)
-mit den nötigen Änderungen;mutatis mutandis (lat.)
-Eudaimonismus;Eudämonismus
-wiederverwertbar;recyclebar;recyclingfähig
-transreflektiv (fachspr.);transreflexiv (fachspr.);transflexiv (fachspr.);transflektiv (fachspr.)
-Nougat;Nugat
-Aggregation;Aggregierung
-Body-Mass-Index;Körpermassenzahl;Körpermasseindex;BMI;Kaup-Index
-Bolschewiki;Mehrheitler (wörtlich)
-Umstrukturierung;Umbau;Perestroika;Umgestaltung
-Besserungsarbeitslager;Bagno (franz., historisch, ital.);Lager;Arbeitserziehungslager (NS-Jargon, historisch);Umerziehungslager;Strafgefangenenlager;Gefangenenlager;Arbeitslager;Gulag;Straflager
-Unternehmerrentabilität;Eigenkapitalrentabilität
-Tomatensuppe;Paradeissuppe (österr.)
-Paradeiscremesuppe (österr.);Tomatencremesuppe
-in grauer Vorzeit;weit zurückliegend;(schon) eine Ewigkeit her;unvordenklich (veraltend);lange her (ugs.);vor langer Zeit
-Totenkopf;Totenschädel
-Sterbebett;Totenbett
-Kartoffelsalat;Erdäpfelsalat (österr.)
-Kartoffelchips;Rohscheiben (österr.);Chips (ugs.);Pommes-Chips (schweiz.)
-Kartoffelpuffer;Kartoffelpfannkuchen;Reiberdatschi (bayr.);Reibeplätzchen;Erdäpfelpuffer (bayr., österr.);Reibekuchen
-Bundesamt für Eich- und Vermessungswesen;BEV
-Erdäpfelkäfer (österr.);Kartoffelkäfer
-Ausgabe;Ausdruck
-Sexualpräferenz;Sexualorientierung;sexuelle Orientierung;Geschlechtspartner-Orientierung
-wie folgt lauten;so genannt;mit Namen;der da heißt;genannt;benannt;geheißen;namens
-Zischeln;Gezischel
-GI (ugs., engl.);US-Soldat
-Metabolit (fachspr.);Stoffwechselzwischenprodukt
-EVU;Energieversorgungsunternehmen;Energieversorger
-EVU;Eisenbahnverkehrsunternehmen
-Leistungsverbesserung;Leistungszuwachs;Leistungserhöhung
-Drehbuchverfasser;Drehbuchautor;Szenarist;Drehbuchschreiber
-Blockheizkraftwerk;BHKW
-Finanzmarktaufsicht;FMA
-BKA;Bundeskriminalamt
-Saat-Lein;Linum usitatissimum (fachspr.);Lein;Gemeiner Lein;Flachs
-Leinöl;Flachsöl
-Leinsaat;Flachssamen;Leinsamen
-in klingende Münze umwandeln (geh.);liquidieren (fachspr.);monetarisieren (fachspr., selten);in bare Münze umwandeln (geh.);zu Geld machen (Hauptform)
-Novelle;Erzählung in Prosaform
-Novelle;Änderungsgesetz
-für (ugs.);im Kontext (von);im Zusammenhang (mit);im Zuge (von);im Rahmen (von);bei
-Bedingung;Fallunterscheidung
-Apnoetaucher;Freitaucher
-Lebendschach;Lebendschachspiel;Schach mit lebenden Figuren
-Telefonhüttl (ugs., österr.);Telefonhäuschen;Telefonzelle;Fernsprechzelle
-Würstelstand;Würstelbude (ugs.);Bude (ugs.);Imbissstand;Würstchenbude
-Tiefengestein;Intrusivgestein;Plutonit;plutonisches Gestein;Plutonitgestein
-bestrebt;fleißig;bemüht;besorgt;emsig;betriebsam
-Klassismus;Klassendiskriminierung
-französischsprachig;frankophon;frankofon
-Adieu sagen;scheiden (geh., veraltet);Lebewohl sagen;(jemanden) verabschieden;Tschüs sagen;(sich) verabschieden;Abschied nehmen;auf Wiedersehen sagen;(sich) empfehlen (geh.)
-Wissenschaft der Deutung;Auslegung;Interpretation;Verständnis;Exegese;Hermeneutik
-Allradschlepper;Allradtraktor
-einer Behandlung unterziehen;(medizinisch) behandeln;therapieren
-die Konnotation betreffend;konnotativ
-Nachtschrank;Nachtkastl (ugs., bayr., österr.);Nachttisch;Nachtkästchen (bayr., österr.);Nachttischchen
-empathisch;einfühlend;mitfühlend
-allumfassend;vollumfänglich;in vollem Umfang
-optimierbar;steigerungsfähig
-Rekrutierung (schweiz.);Stellung (österr.);Tauglichkeitsuntersuchung;Musterung
-Äquivalent;gleichwertiger Ersatz
-Hintergrund;Background
-Schneeraupe;Schneekatze (ugs.);Pistenraupe;Pistenfahrzeug
-megaloman;übergeschnappt;gigantomanisch;(völlig) überdimensioniert;megalomanisch;größenwahnsinnig
-Gebäudetrakt;Gebäudeflügel
-Haltungsfehler;Fehlhaltung;Körperfehlhaltung
-(sich) hingezogen fühlen (zu);(sich) angezogen fühlen (von)
-beim;bei dem
-Karabiner (ugs.);Karabinerhaken
-Bayrumbaum;Westindischer Lorbeer;Bay
-Altersvorsorge;Altersabsicherung
-abzusehen;vorauszusehen;vorprogrammiert (ugs.);programmiert
-Brüder und Schwestern;Geschwister (Pluraletantum)
-mit Gusto (ugs.);genussvoll;mit Genuss
-zugeschickt;zugesendet;zugesandt
-heimtückischer Mord;Meuchelmord;hinterhältiger Mord
-Fortschrittsdenken;Progressismus
-Silberhochzeit;silberne Hochzeit
-Besprechung;Dialog;Rücksprache
-Sklaverei;Ausplünderei (ugs., selten);Ausnutzung;Ausbeutung (Hauptform);Ausbeuterei;Halsabschneiderei
-memorieren;(sich) einprägen;auswendig lernen
-Glutaminsäure;Glutamat
-Kammerjäger;Schädlingsbekämpfer;Desinfektor (schweiz.)
-einfach ausgedrückt;bekannt als;vulgo (geh., lat.);alias;in einfachen Worten;auch;auch bekannt unter (dem Namen / Begriff);aka (ugs., Jargon);gemeinhin genannt
-Sechszähniger Fichtenborkenkäfer;Kupferstecher;Gewöhnlicher Kupferstecher
-Auflösungsvertrag;Aufhebungsvertrag
-dolce (ital.);sanft
-unerlässliche Bedingung;Conditio sine qua non;damit steht und fällt alles (ugs.);ohne dem geht gar nichts (ugs.);notwendige Bedingung
-aus dem Nichts heraus;ex nihilo;aus dem Nichts
-Vorbemerkung;Prolegomenon
-ACTS;Abroll-Container-Transport-System;Abrollcontainer-Transportsystem
-letzter Durchgang (vor) (ugs.);Hauptprobe;Generalprobe (auch figurativ);letzte Probe
-Gradiente (fachspr.);Anstieg;Steigung;Höhenunterschied
-Anweisung;Führer;Handbuch;Anleitung;Leitfaden
-Saloniki;Thessaloniki
-Frauenbeschneidung;Verstümmelung weiblicher Genitalien;Beschneidung (ugs., weibl.);Mädchenbeschneidung;(weibliche) Genitalverstümmelung;genitale Verstümmelung;Beschneidung weiblicher Genitalien
-Aufsatz;Abfassung;Niederschrift;Denkschrift
-hintanhalten;verhindern;hintansetzen;verzögern
-diese/r/s (= vorher erwähnt) (Hauptform);oben erwähnt;zur Diskussion stehend;vorbenannt;eingangs erwähnt;fraglich;ebenjener;letzterer;ebenderselbe;der (/die / das) gleiche (ugs.);bekannt;niemand anderer als;erwähnt;zuvor genannt;bewusst;ebendieser;obig (Papierdeutsch);in Rede (stehend);kein anderer als;jener;betreffend;zuvor erwähnt;derselbe;selbiger;nämlicher;bereits bekannt;oben genannt;vorbezeichnet (altertümelnd);genannt;bereits benannt;besagt;bereits erwähnt;vorgenannt
-regelmäßiges Treffen;Jour Fixe;wiederkehrendes Meeting
-Versprecher;Lapsus Linguae (lat.)
-Korkenzieher;Stoppelzieher (österr.)
-standardmäßig;ab Fabrik;Auslieferungszustand;werksseitig eingestellt;Werkseinstellung;ab Werk
-Bötchen (ugs.);Nussschale (fig.);kleines Schiff;kleines Boot
-AöR (Abkürzung);AdöR (Abkürzung);Anstalt des öffentlichen Rechts
-widersprechen;unterschiedlicher Meinung sein
-Führerstand;Bock (ugs.)
-Leerlauf haben (ugs.);nicht ausgelastet;unausgelastet
-Finalist;Endrundenteilnehmer;Finalteilnehmer;bei der Endausscheidung dabei
-aufspüren;aufklären;nachweisen
-überhandnehmen;ins Kraut schießen (ugs.);entgleisen (ugs.);ausufern;aus dem Ruder laufen (ugs.)
-zum Zug kommen (ugs.);an die Reihe kommen;drankommen (ugs.)
-(feierliche) Begrüßung;großer Bahnhof (ugs.);(festlicher) Empfang
-Söldner;Angehöriger einer Privatarmee;Fremdenlegionär;Landsknecht (historisch);Privatsoldat (ugs.);Legionär
-Schuldenreduktion;Schuldenabbau;Schuldenverringerung
-Defizitabbau;Defizitverringerung;Defizitreduktion
-rite de passage (fr.);Übergangsritus
-aus Haar bestehend;hären (selten)
-Nobilitierung;Standeserhebung;Nobilitation;Erhebung in den Adelsstand;Adelung
-Gleiswechsel (ugs.);Überleitstelle;Spurwechselstelle (schweiz.)
-verkehrsberuhigte Zone (Amtsdeutsch);Wohnstraße (österr.);verkehrsberuhigter Bereich;Spielstraße (ugs.);Begegnungszone (schweiz.)
-absehen auf;trachten (nach);im Auge haben
-kutschieren (ugs.);(sich) hinters Steuer setzen;chauffieren;steuern;am Steuer sitzen;lenken (Fahrzeug);fahren;auf dem Bock sitzen (LKW, Motorrad) (ugs., Jargon)
-Instandhaltungstrupp;Wartungsmannschaft;Wartungstrupp
-pathologisieren;für krank erklären
-Recht des geistigen Eigentums;Immaterialgüterrecht
-Sozialversicherungssystem;soziales Netz (ugs.);soziale Sicherung
-Kriegsverherrlichung;Bellizismus;Befürwortung von Krieg
-Friedensbewegung;Pazifismus
-Garnitur;Besatz;Verzierung
-Straßenmarkierung;Fahrbahnmarkierung
-Daltonismus;Rot-Grün-Sehschwäche;Dyschromatopsie (fachspr.);Rot-Grün-Blindheit
-Permanentmagnet;Dauermagnet
-Bleicherde;Podsol;Grauerde
-haussieren;im Wert steigen (Aktien)
-Rundordner (scherzhaft, österr.);Ablage P (scherzhaft);Papierkorb (Hauptform);Ablage rund (scherzhaft);Rundablage (scherzhaft)
-BaFin;Bundesanstalt für Finanzdienstleistungsaufsicht
-(den) Menschen in den Mittelpunkt stellen(d);allein auf den Menschen bezogen;menschenzentriert;Der Mensch ist das Maß aller Dinge. (geh., Redensart);anthropozentrisch (geh.);nur auf den Menschen bezogen;den Menschen zum Maß aller Dinge erheben(d) (geh., variabel)
-Cochlea (fachspr.);Hörschnecke
-Neue Hebriden (veraltet);Vanuatu
-Verbindung;Konnexion
-Umkehrplatz;Wendeanlage;Wendeplatz
-keinen Fuß auf die Erde kriegen (ugs., fig.);keinen Stich bekommen (ugs., fig., variabel);nicht punkten können (fig.);keinen Stich machen (ugs., fig., variabel);(mit etwas ist) kein Blumentopf zu holen (ugs., fig.);keinen Stich holen (ugs., fig., variabel);(sich) die Zähne ausbeißen (ugs., fig.);(sich) umsonst anstrengen;keine Schnitte kriegen (ugs., fig.);keine Chance haben (gegen);(sich) vergeblich abmühen;keinen Stich haben (ugs., fig., variabel);auf keinen grünen Zweig kommen (ugs., fig.);auf Granit beißen (ugs., fig.);kein Bein auf die Erde kriegen (ugs., fig.);keinen Blumentopf gewinnen können (mit) (ugs., fig.);keinen Stich landen (ugs., fig., variabel)
-Extinktion;Auslöschung (fachspr.)
-Ökotreibstoff;Biokraftstoff;Biotreibstoff;Biosprit (ugs.);Agrosprit;Agrotreibstoff;Ökosprit (ugs.)
-ZEW;Zentrum für Europäische Wirtschaftsforschung
-Chefsteward;Purser;Kabinenchef
-Sehtest;Augentest
-aufrecht;pfeilgerade;kerzengerade;schnurgerade;gerade (Hauptform)
-Produktionsmenge;Herstellungsmenge;Erzeugungsmenge
-individueller Bedarf;Einzelinteresse(n);Partikularinteresse(n) (geh., bildungssprachlich)
-wie gewollt;wie gewünscht;ad libitum (geh., lat.);wunschkonform;wie bestellt;wunschgemäß;(ganz) nach Wunsch;wie auf Kommando (ugs.)
-Zeitknappheit;Zeitmangel
-Oesterreichische Nationalbank;OeNB (Abkürzung)
-Feldmesser (ugs.);Geometer (schweiz., veraltet, österr.);Landvermesser (veraltet);Vermessungsingenieur;Geodät (fachspr.);Vermessungskundler;Vermessungsrat (veraltet);Surveyor (fachspr.)
-incentivieren;Anreize schaffen
-IPCC (Abkürzung);Intergovernmental Panel on Climate Change (Eigenname, engl.);Weltklimarat (ugs., Hauptform);UN-Weltklimarat
-Inlandeis;Eisschild
-Einbrenn (österr.);Mehlschwitze;Schwitzmehl;Einbrenne
-Sternengeburtstag;Todestag;Sterbetag
-Sterbezeit;Todeszeitpunkt;Todeszeit
-Sterbeort (fachspr., Amtsdeutsch);Todesort;Ort des Ablebens
-Industrieller;Schlotbaron (veraltend);Fabrikant;Fabrikbesitzer;Fabrikeigentümer
-Paukist;Paukenspieler;Paukenschläger
-Lastenlift;Lastenaufzug
-Personenaufzug;Personenlift
-Schräglift;Schrägaufzug
-Todesfall;Sterbefall;Trauerfall
-Sterbeurkunde;Todesurkunde
-Trachea (fachspr.);Luftröhre
-Pusemuckel (ugs.);in der Pampa (ugs.);Posemukel (ugs.);im Outback (ugs.);Hintertupfing (ugs.);Posemuckel (ugs.)
-Zuweisung;Gleichsetzung
-bei der Stange halten;bei Laune halten
-todgeweiht;schwer krank;schwerkrank (Hauptform);es bald hinter sich haben (sarkastisch);es nicht mehr lange machen (derb);am Abnibbeln (ugs.);todkrank;unheilbar krank;am Abnippeln (ugs.);schwer darniederliegen (geh., veraltet);sterbenskrank
-Jahrgang;Generation;Altersgruppe;Kohorte (fachspr.);Alterskohorte (fachspr.)
-fein;engmaschig;hochauflösend
-Alltag;täglich Brot (ugs.);Tagesgeschäft;Routine (franz.)
-verspielt;blumig;floral
-Lohnliste;Gehaltsliste;Payroll (engl.)
-Zink-Kohle-Trockenbatterie (ugs.);Zink-Braunstein-Zelle (ugs.);Zink-Kohle-Zelle;Zink-Kohle-Element;Zink-Kohle-Batterie (ugs.)
-Luftbildfotografie;Aerofotografie;Luftfotografie
-Geoinformationssystem;Geographisches Informationssystem;GIS (Abkürzung)
-Koordinatentransformation;Umrechnung von Koordinaten
-Durchmesser eines Kreises;2r;d;Kreisdurchmesser
-Mittelsehne;Durchmesser;Sehne durch den Kreismittelpunkt
-entgleisen;aus den Gleisen springen (ugs.)
-Nachrichtenübertragung;Nachrichtenübermittlung
-Reibungszahl;Reibungskoeffizient
-FSME;Frühsommer-Meningoenzephalitis
-Erste heilige Kommunion;Erstkommunion;Kinderkommunion
-Halbmesser;Radius
-Schilddrüsenhormonüberproduktion;Schilddrüsenhormonüberschuss;Schilddrüsenüberfunktion
-Gestaltungsoption;Möglichkeit;Handlungsoption;Aktionsradius;Gestaltungsrahmen;(das) Machbare;Handlungsspielraum (Hauptform);Handlungsmöglichkeit(en);Gestaltungsmöglichkeit;Gestaltungsspielraum
-Strunk;Stubben (ugs., norddeutsch, regional);Storzen (ugs., alemannisch, regional, rheinisch);Wurzelstock;Stockholz;Baumstrunk;Stucken;Knorz (süddt.);Baumstumpf (Hauptform);Erdstammblock
-Zweitletzter;Vorletzter
-Fallmeister;Feldmeister;Kleemeister;Kaviller;Abdecker (Hauptform);Luderführer;Schinder;Kafiller;Mausgewitz;Kleeken;Tierkörperbeseitiger (Amtsdeutsch, Hauptform);Wasenmeister (oberdeutsch);Racker
-Lederfabrik;Gerberei
-Koch an Bord von Schiffen;Smutje;Schiffskoch;Schmutt;Smut
-Kohlrabi;Rübkohl
-Kabis;Weisskabis;Weißkohl (Hauptform);Weißkraut;Kohl;Kappes
-Völkerkundemuseum;Museum für Völkerkunde
-umzäunt;eingezäunt;von einem Zaun umgeben
-Folgetonhorn;Tonfolgehorn
-(einer Sache) bedürfen (geh.);(es) bedarf (einer Sache) (geh.);erforderlich sein;notwendig sein;man braucht;erfordern;nötig sein;nottun;(es) braucht (etwas) (geh.);vonnöten sein;(etwas) brauchen (ugs.)
-kurz gesagt (Hauptform);in einem Wort;kurzum;fassen wir zusammen;alles eingerechnet;summa summarum (lat.);zusammengenommen;um es kurz zu machen;aufs Ganze gesehen;der langen Rede kurzer Sinn (ugs., Redensart);kann man sagen (ergänzend);kurz;zusammengefasst;insgesamt;im Ganzen gesehen;kurz und gut;in aller Kürze;alles in allem;insgesamt gesehen;im Ganzen;summarisch
-BdSt;Bund der Steuerzahler
-Unverständnis;Verständnislosigkeit
-im Hintertreffen (ugs.);auf den hinteren Plätzen;(weit) abgeschlagen
-abbilden;modellieren;(modellhaft) nachbilden;nachstellen;emulieren;so tun als ob (ugs.)
-schächten (fachspr.);ausbluten lassen
-Schmalzlocke;Haarlocke;Tolle (ugs.);Föhnwelle;Stirnlocke;Sturmlocke;Welle;Haarwelle;(eine) tolle Tolle (scherzhaft);Locke
-Klitsche (ugs.);schlechte Unterkunft;Absteige
-Genosse (ugs., DDR);Linker;Roter (ugs.);Kommunist;rote Socke (ugs., abwertend, fig.);Sozialist
-Marineinfanterist;Seesoldat (veraltet);Ledernacken (ugs.)
-scheuern;schrubben;abscheuern;abschrubben
-herunterbringen;vom Himmel holen;abschießen;durch Beschuss zum Absturz bringen
-im zarten Alter von ... Jahren;als Kind;in jungen Jahren;mit jungen Jahren
-Jugendzeit;Jahre als junger Erwachsener;Jugend (Hauptform);(jemandes) wilde Zeit(en);(jemandes) frühe Zwanziger;Jugendjahre;Sturm- und Drangjahre;Sturm-und-Drang Zeit;junge Jahre;junges Erwachsenenalter;wilde Jahre;Jugendalter
-Lebensabend;fortgeschrittenes Lebensalter;Rentenalter;(das) Alter;Herbst des Lebens (fig.)
-links-grün;alternativ (politisch);links-alternativ
-Moment (ugs.);Augenblick;Sekunde (ugs.)
-Raubgut;Kriegsbeute;Beutegut;Beute;Plündergut;Prise (fachspr.)
-gutheißen;zustimmen;(sich) aussprechen für;befürworten;begrüßen;beistimmen;für richtig halten;billigen;absegnen (ugs.)
-aufreißen (Wolkendecke);aufklaren (Himmel, Wetter, es)
-ungeschickter Mensch;Trottel (ugs.);Trampel (ugs.);Depp (ugs.);Tatterich (ugs.);Trampeltier (ugs., fig.);Elefant im Porzellanladen (ugs., fig.);Spast (derb);Hiefler (ugs., österr.);Tollpatsch;(Hans) Taps (ugs.);Tölpel
-Coach;Übungsleiter;Bremser (ugs., Jargon);Kursleiter;Anleiter;Tutor;Lehrer
-Status;Position
-brummeln;brummen
-(auf)keimen;(sich) regen;(langsam) entstehen
-fletschen (ugs.);Lippen zurückziehen;blecken;Zähne zeigen
-in die Offensive gehen;angreifen;offensiv vorgehen;Zähne zeigen (ugs., fig.);hart rangehen (ugs.)
-Trasse;Schneise
-Ausguck;Krähennest (ugs.);Mastkorb
-reaktiv;bindungsfreudig
-böse Tat;Verfehlung;Frevel;Missetat;Tabubruch;Sünde (religiös);Übertretung;frevlerisches Handeln
-sacken lassen (ugs., fig.);darüber schlafen (ugs., fig.);verdauen (fig.);(etwas) verarbeiten;umgehen lernen (mit);(in Ruhe) auf sich wirken lassen (geh.);(in Ruhe) nachdenken (über)
-Funktionsweise;Zusammenspiel;Mechanismus;System
-Masse (ugs.);Neutralleiter
-Inertia;Masse;Gewicht
-Phase (ugs.);Leiter;L (fachspr.)
-Winkel;Phase
-Totenschrein;Totenlade;Kiste (ugs.);Totenbaum (schweiz.);Sarg;Erdmöbel (ugs.);Döschen (ugs., regional);Totenkiste (ugs.)
-billig (fachspr., juristisch);fair;gerecht;gerechtfertigt;recht und billig;recht
-im Griff haben;fest im Sattel sitzen (ugs.);die Zügel in der Hand halten (ugs.);unter Kontrolle haben
-warten;unterhalten;(sich einer Sache) widmen;in Schuss halten (ugs.);pflegen
-herumschleimen (derb);beweihräuchern;(sich) einschleimen (derb);bauchpinseln (geh.);aufgesetzt positiv reagieren;Honig ums Maul schmieren (ugs.);(sich) einschmeicheln (Hauptform);übertrieben loben;(sich) beliebt zu machen versuchen (bei);lobhudeln
-Erdbebenforscher;Seismologe
-verkalkt (abwertend, veraltet);verwirrt;altersblöd (derb);findet sich nicht mehr zurecht;nicht mehr Herr seiner Sinne;zerstreut;senil;kommt alleine nicht mehr klar;hochgradig senil;dement;vertrottelt;geistig verwirrt;trottelig (geworden);deliriös (fachspr., lat.)
-fruchtbar;ertragreich;gut (ugs.);urbar
-Werg;Flachs
-abdunkeln;dimmen;dunkler machen;abblenden
-mengen;dazumischen;einrühren;unterrühren
-eine gewischt bekommen (ugs.);eine gewischt kriegen (ugs.);(sich) eine fangen (ugs.);einen Stromschlag erleiden;einen geflust kriegen (ugs.);einen Schlag bekommen;einen geschossen bekommen (ugs.)
-Golf;Meerbusen
-Amor spielen (ugs.);(zwei) zusammenbringen;an die Frau bringen (weibl.);unter die Haube bringen;(jemanden) verkuppeln (mit);kuppeln;(den) Kontakt herstellen;an den Mann bringen (männl.)
-bräunlich;erdig
-gefährdet sein;in Gefahr geraten;in schwere See kommen (ugs.);in schwere See geraten
-Hasenöhrchen (ugs., unterfränkisch);Ackersalat (schwäbisch);Mauseöhrchen(salat) (ugs., regional);Sonnewirbele (ugs., badisch);Döchderle (ugs., badisch);Vogerlsalat (bayr., österr.);Rapunze (ugs., regional);Nüsschen (ugs., regional);Ritscherli (ugs., regional);Sunnewirbeli (ugs., badisch);Schmalzkraut (ugs., regional);Wingertsalat (ugs., pfälzisch);Vogelsalat (ugs., südtirolerisch);Mausohrsalat (ugs., regional);Rapunzelsalat;Sonnenwirbel (ugs., regional);Rapunzel (ugs., regional);Rawunze (ugs., regional);Nüssler (ugs., schweiz.);Rawinzchen (ugs., regional);Schoofsmeiala (ugs., fränk.);Schafsmäuler (ugs., fränk.);Feldsalat;Nüsslisalat (schweiz.);Gewöhnlicher Feldsalat (fachspr., botanisch);Rapünzchen (ugs.)
-Meeresstraße;Sund;Kanal;Belt;Meerenge
-Kathstrauch;Abessinischer Tee
-Qat;Kat
-Tide (norddeutsch);Gezeit
-Belobigung;Ritterschlag (ugs.);Bestätigung;Ordensverleihung
-frisieren;kämmen;bürsten
-Exorzismus;Teufelsaustreibung
-AND-Verknüpfung;Und-Verknüpfung
-Kohle;Grubengold (ugs.)
-Woche vor Ostern;Karwoche;Stille Woche
-Wurfscheibenschießen;Tontaubenschießen;Wurftaubenschießen
-Nageleisen;Gashaxn (österr.);Goashaxn (bayr., österr.);Geißfuß;Ziegenfuß;Kuhfuß
-Cherrytomate;Kirschtomate;Cocktailtomate
-Gyroskop;Kreiselstabilisator;Kreiselinstrument
-Piëzoelektrizität (veraltet);piezoelektrischer Effekt;Piezoelektrizität;Piëzoeffekt (veraltet);Piezoeffekt (Kurzform)
-Windenergie;Windkraft
-Fahrerlaubnisprüfung;Autoprüfung (regional, schweiz.);Fahrprüfung;Führerscheinprüfung;Lenkerprüfung (österr.);Führerprüfung (schweiz.)
-nicht wissen, was man machen soll;Was tun, sprach Zeus. (ugs., Spruch);(auch) nicht (mehr) weiterwissen;mit seiner Weisheit am Ende sein;und jetzt? (ugs., variabel);(es ist) keine Lösung in Sicht (für);(Da) ist guter Rat teuer. (sprichwörtlich);sein Pulver verschossen haben (ugs., fig.);passen müssen;keine Lösung (parat) haben;und da(nn) verließen sie ihn (ugs., Spruch);mit seinem Latein am Ende (sein) (ugs., fig.);(sich) die Haare raufen (ugs., fig.);kein Patentrezept haben (ugs., fig.);keine Antwort(en) haben auf (fig.);(sich) nicht mehr zu helfen wissen;ratlos sein (Hauptform);nackt in den Erbsen stehen (ugs., fig.);(dastehen / aussehen) wie eine Kuh wenn's donnert (ugs.);(zu etwas) fällt einem nichts (mehr) ein (ugs.);nicht wissen, was zu tun ist;(sich) keinen Rat wissen
-nicht unerheblich;signifikant
-Gewinner der Europameisterschaft;Europameister;Europameisterschaftssieger
-Gewinner der Weltmeisterschaft;Weltmeister
-Gemeinschaft Unabhängiger Staaten;GUS
-in letzter Sekunde (auch figurativ);im letzten Moment;in der letzten Sekunde (auch figurativ);im letzten Augenblick;auf den letzten Drücker (ugs.);kurz vor knapp (ugs.);(zeitlich) knapp
-Flechte;Lichen (fachspr.)
-MDF-Platte;mitteldichte Holzfaserplatte;mitteldichte Faserplatte
-Primfaktorzerlegung;Zerlegung in Primfaktoren
-(Größe) anpassen;vergrößern oder verkleinern;skalieren
-Coautor;Mitautor;Mitverfasser;Koautor;Konautor
-zerschnippeln (ugs.);zerschneiden;zerschnibbeln (ugs., norddeutsch);zerschnipseln
-Wachsmaler;Wachsmalkreide;Wachsmalstift;Wachsstift;Wachskreide
-Kerzenwachs;Wachs
-Kandelaber;Leuchter;Armleuchter
-Halogenlampe;Halogenglühlampe;Halogenbirne (ugs.)
-Fluter (ugs.);Ständerlampe (schweiz.);Stehleuchte;Deckenfluter;Stehlampe;Standlampe
-Grubenholz;Stempel
-Zeche;Honorarnote (österr.);Liquidation;Kostennote;Rechnung;Privatliquidation
-Strecke;Abbaustrecke;Streb
-Bergbau;Montanwesen (lat.);Berg- und Hüttenwesen
-Pali (ugs.);Palästinenserschal;Kufiya;Palituch (ugs.);Palischal (ugs.);Palästinensertuch
-Perpendikel;Uhrpendel
-Marshmallow;Mäusespeck
-im Stich lassen;versetzen;ausbleiben;sitzen lassen;sitzenlassen;(jemanden) verladen
-in Pfand geben;versetzen;verpfänden;als Pfand geben;belehnen (schweiz.)
-verrücken;verschieben;umsetzen;an einen anderen Platz stellen / setzen / schieben / rücken;(einer Sache) einen anderen Platz geben (geh.);anders stellen;versetzen;deplacieren (fachspr., veraltet);umstellen (Hauptform);verstellen
-versetzen;einen anderen Posten geben;die Stelle wechseln lassen
-asphärisch;nicht kugelförmig
-Autoverleih;Autovermietung
-Autoverleiher;Autovermieter
-wahllos;ohne Orientierung;ziellos;ohne Richtung;orientierungslos
-Sucharbeitslosigkeit;friktionelle Arbeitslosigkeit;Findungsphase
-Soziales Kapital;Sozialkapital;soziales Netzwerk
-Humanvermögen (fachspr.);Humankapital (fachspr.)
-Tontine (fachspr.);Esusu (fachspr.);Sparclub;Sparzirkel;Sparverein
-Kleinstkredit;Mikrokredit
-umherirrend;erratisch (fachspr.);umherschlingernd;verirrt;schlingernd
-Frauenfeindlichkeit;Weiberhass (derb);Misogynie;Frauenhass;Frauenverachtung
-Fotovoltaik;Photovoltaik
-dumm machen;verdummen;geistig unterfordern
-Veteran;Altgedienter;Ausgedienter;ehemaliger Soldat;Kriegsveteran
-Knofel (ugs.);Chnöbli (schweiz.);Allium sativum (fachspr., lat.);Vanille des armen Mannes (ugs., scherzhaft, österr.);Knoblauch (Hauptform);Knofi (ugs.)
-Kutscher;Fiaker;Fuhrknecht;Fuhrmann;Pferdelenker
-zum Höhepunkt kommen;kulminieren;gipfeln;den Höhepunkt erreichen
-Eingewöhnungsphase;Eingewöhnungszeit;Eingewöhnungszeitraum
-Beobachtungszeit;Beobachtungszeitraum
-Besan;Besansegel
-Einschulungsdauer;Einschulungszeitraum
-Olympiasportler;Teilnehmer einer Olympiade (ugs.);Olympiateilnehmer (ugs.);Olympionike;Teilnehmer an den Olympischen Spielen
-Übermächtigkeit;Präpotenz
-Zaungast (ugs.);nicht geladener Gast (Hauptform);(unbeteiligter) Zuschauer;nicht eingeladen;Unbeteiligter;ungebetener Gast;nicht auf der Gästeliste (stehen);Gaffer
-Rechtkant;Quader
-zu tun sein;sollen;müssen
-faschistisch;rechtsextrem (Hauptform);rechtsradikal;am äußeren rechten Rand (befindlich / angesiedelt);nationalsozialistisch;braun (ugs., fig.);rechtsaußen;faschistoid
-Royalist;Königstreuer;Demokratiegegner;Monarchist
-Kfz-Steuer;Kraftfahrzeugsteuer
-Skinhead (engl., Hauptform);Glatze (ugs.);Skin(head)girl (engl., weibl.);Renee (fachspr., Jargon, veraltend, weibl.);Skin (ugs.)
-Stamperl (bayr., österr.);Pinnchen (norddeutsch);Pinn(e)ken (ugs., norddeutsch);(kleines) Schnapsglas
-Sektkelch;Sektglas;Sektflöte
-beruhigend wirken;beruhigen;beruhigend einwirken;die Wogen glätten (ugs.);kalmieren;Streit schlichten;ausgleichen
-Seeladeschein;Konnossement
-Maghrebstaaten;Maghreb;Maghrebländer
-Erdäpfelgulasch (österr.);Kartoffelgulasch
-Freiheitskampf;Résistance;Untergrundkampf;Partisanenkrieg;Widerstand
-Röntgenuntersuchung;Schirmbilduntersuchung;Radioskopie
-röntgen;durchleuchten;Röntgenaufnahmen machen
-Bolzen;Stift;Nagel;Drahtstift
-Abessinien (ugs., scherzhaft, veraltet);Naturistenstrand;textilfreier Strand;Nackedu(h)nien (ugs., scherzhaft);Nudistenstrand;FKK-Strand;Nacktbadestrand
-Drittmittel;Forschungsmittel;Forschungsetat;Forschungsförderung
-Wohnortkonzept;Inländerkonzept
-Arbeitsortkonzept;Inlandskonzept
-Integration;Integralrechnung
-Stotterer;Stammler
-Ziegelfabrik;Ziegelei;Ziegelwerk
-Eisenbahnstrecke;Eisenbahnlinie (ugs.);Bahnstrecke;Strecke
-Basset;Bassethund
-Reisekrankheit;Kinetose (fachspr.);Bewegungskrankheit
-Spuckbeutel;Speibsackerl (österr.);Spucktüte;Kotztüte (ugs.)
-Krähenauge;Hühnerauge;Clavus (fachspr.);Leichdorn;Klavus (fachspr.)
-Spiegelsymmetrie;Achsensymmetrie;axiale Symmetrie
-Zentralsymmetrie;Punktsymmetrie
-Kontrastumfang;Dynamikumfang;Dynamik (ugs.);Dynamikbereich
-Kiste (ugs.);Tor (Balllsport) (Hauptform);Kasten (ugs.)
-Nebenbahn;Nebenstrecke (ugs.);Provinzbahn (ugs.);Sekundärbahn;Lokalbahn;Bimmelbahn (ugs.);Bummelbahn (ugs.)
-Renminbi;Yuan
-Magnesiumsilikathydrat;Talk;Steatit
-Halbfinale;Semifinale;Vorschlussrunde
-dislozieren;verteilen
-desto;umso
-Pollenanalyse;Pollenforschung;Palynologie
-Pollenforscher;Pollenanalytiker;Palynologe
-Endausscheidung;Finalspiel;Finale;Endspiel;Entscheidungsspiel
-Stöpsel (ugs.);Kopfhörer;Ohrhörer
-Pufferküsser (ugs.);Eisenbahnfreund;Nietenzähler (ugs.);Schwellenzähler (ugs.);Ferrosexueller (ugs.)
-Waschhandschuh;Waschlappen
-Modellbahn;Modelleisenbahn;Spielzeugeisenbahn
-Minimalwortschatz;Grundwortschatz;Gebrauchswortschatz;Basiswortschatz
-Rationalisierung (fachspr., medizinisch);Begründung;Rechtfertigung;Grund;Bewandtnis
-falls nötig;im Bedarfsfall;bedarfsweise;wenn nötig;gegebenenfalls;falls erforderlich;falls vonnöten;nötigenfalls;falls (dafür) Bedarf besteht;erforderlichenfalls (Amtsdeutsch);bei Bedarf
-Siebenschläfertag;27. Juni
-Kohlenhydrat;Saccharid
-Biomimikry;Biomimetik;Bionik;Biomimese
-multikulti (ugs.);multikulturell
-durchreichen;durchschleusen (ugs.)
-Miene;Gesichtsausdruck;Mimik;Mienenspiel
-Bonobo;Zwergschimpanse
-wiederholen;iterieren;umlaufen;durchlaufen;rollieren
-kapseln;gruppieren
-Anrichte;Sideboard;Serviertisch;Kredenz (österr.);Büfett
-Erfolg;Hit;Klopper (ugs.)
-Rahmen;Bilderrahmen;Bildhalter
-Malzzucker;Maltose
-Hagelzucker;Perlzucker
-Lasagne;Nudelauflauf
-Schmetterlingsnudeln;Farfalle
-Fusilli;Spiralnudeln
-Hohlnudeln;Makkaroni;Maccheroni
-Tagliatelle;Bandnudeln
-Holzklötzchen;Holzklötze;Bauklötze;Bauklötzchen
-Trittroller;Trottinett (schweiz.);Kinderroller (ugs.);Tretroller;Radelrutsch (ugs., süddt.)
-Milchzucker;Laktose
-Brombeere;Dornbeere
-Hohlbeere;Himbeere;Rubus idaeus (fachspr.)
-Mungatzen (österr.);Stachelbeere;Ribes uva-crispa (fachspr.)
-Steinfrucht;Steinobst
-Vogelkirsche;Süßkirsche;Prunus avium (fachspr.)
-Prunus persica (lat.);Pfirsich
-Apfelfrucht;Kernobst;Sammelbalgfrucht (fachspr.)
-Alpenmilchschokolade;Vollmilchschokolade;Milchschokolade
-Kapitalaufwand;Investition;Geldanlage;Kapitalanlage;Anlage (ugs.);Investment
-(jemanden) filzen (ugs.);(jemanden) durchsuchen;(jemanden) perlustrieren (Amtsdeutsch, österr.);eine Leibesvisitation vornehmen (bei jemandem);(jemanden) visitieren (geh.)
-Filzung;Perlustrierung (österr.);Personendurchsuchung
-Museum of Modern Art;MoMA
-Maggikraut (ugs.);Liebstöckel (Hauptform);Nussstock (österr.);Luststock;Levisticum officinale (fachspr., lat.);Lavas
-Küchenkräuter;Kräuter
-(arabische) Wasserpfeife;Schischa;Shisha
-Extroversion;Extraversion
-nicht eigenständig;eklektisch (geh.);nachahmend;in der Manier von (geh.);nicht kreativ;schon dagewesen (ugs.);epigonenhaft;unschöpferisch;epigonal
-Kampfesruf(e) (veraltet);Panier;Kriegsschrei;Schlachtruf;Feldgeschrei (altertümlich)
-Kirchweih (Hauptform);Kirbe (pfälzisch);Kerb (westdeutsch);Kerwe (pfälzisch);Kerms (thüringisch);Kirmse (thüringisch);Kermes (westdeutsch);Käada (südoberpfälzisch);Kerm (unterfränkisch);Kärwa (fränk.);Kärwe (pfälzisch);Kier (Spessart);Kerwa (fränk.);Kirmes (ugs., Hauptform);Kärmst (thüringisch);Kemmes (Nassau);Kermst (thüringisch);Kiada (südoberpfälzisch);Kirwa (ostfränkisch);Kärms (thüringisch);Kirb (westdeutsch)
-Kartograf;Kartograph;Mapper (ugs.)
-Neonatologie (fachspr.);Neugeborenenmedizin
-Jagdreise;Safari
-Ost-West-Konflikt;Kalter Krieg;bipolare Welt
-Skorbut;Möller-Barlow-Krankheit;Möller-Barlow-Syndrom
-Vitaminmangel;Hypovitaminose
-EPO (Abkürzung);Hämatopoetin (veraltet);Erythropoetin;Epoetin;Erythropoietin
-Messbarmachung;Operationalisierung (fachspr.)
-Pendlerpauschale;Entfernungspauschale
-Nördlicher Seeweg;Nordostpassage
-Schifffahrtsroute;Schifffahrtsstraße;Meeresstraße;Seeweg
-Seemeile;nautische Meile
-pritscheln (österr.);plätschern;planschen;plantschen
-Androtropismus;Androtropie
-Chorionzottenbiopsie;Chorionbiopsie;Plazenta-Punktion;Zottenhaut-Test;Mutterkuchenpunktion
-Klebereiweiß;Gluten;Kleber
-geistige Behinderung;mentale Retardierung (fachspr.);Intelligenzminderung
-Meduse;Qualle
-Dutt;Haarknoten
-Eukaryot;Eukaryont;Eukarya
-Prokaryot;Prokaryont;Monera (fachspr., veraltet)
-Gelbe Haarqualle;Feuerqualle
-(jemanden) am Sprechen hindern;mundtot machen;zum Schweigen bringen;dafür sorgen, dass jemand den Mund hält (ugs.);(jemandem) einen Maulkorb umhängen (fig.);(jemandem) das Maul stopfen (derb)
-Osmane;Türke;Kümmeltürke (derb, abwertend)
-Potenz;Mächtigkeit;Macht
-Knospenansatz;Wurzeltrieb;Sämling;Pflanzentrieb;Keim;Keimling (ugs.)
-Vivarium (lat.);Tierhaltungsanlage;Käfig;Zwinger;Gehege;Tiergehege
-parsen;analysieren
-Vanille;Königin der Gewürze (ugs.)
-Kakao;Kakaogetränk;Kakaotrunk;Trinkschokolade;heiße Schokolade;Kakaomilch;Schokoladentrunk
-Stand-By;Bereitschaft
-DRK;Deutsches Rotes Kreuz
-Verarsche (derb);List;Gaunerei;Bluff;Veräppelung (ugs.);Trickserei;Manipulation;Gaukelei;Verarschung (derb);Finte;Irreführung;Vorspiegelung falscher Tatsachen;Verarscherei (derb)
-unter die Räder kommen (ugs., fig.);(jemandem) entgleiten (geh., fig.);flöten gehen (ugs., fig.);in Verlust geraten;(sich) selbständig machen (ugs., fig., scherzhaft);abhandenkommen;hopsgehen (ugs.);(einer Sache) verlustig gehen (geh., Amtsdeutsch);bachab gehen (fig., schweiz.);wegkommen (ugs.);in Verstoß geraten (Amtsdeutsch, österr.);von der Bildfläche verschwinden;verloren gehen;vom Schlitten fallen (ugs., fig.);verschüttgehen;verschwinden (Hauptform);(sich) in Luft auflösen (fig.)
-steuerfrei;abgabenfrei
-Latzug;Kabelzug;Latissimus (ugs.);Zugturm;Latmaschine
-Hypertrichose;übermäßiger Haarwuchs;Hypertrichosis
-erste Klasse;first class (engl.)
-Interessenkonflikt;Interessenkollision
-Karrierismus;Karrierestreben
-ESP;Electronic Stability Control;ESC;Elektronisches Stabilitätsprogramm
-keltischer Sänger;keltischer Dichter;Barde
-Festungsbauspezialist;Mineur (franz.)
-Ritzenflitzer (ugs.);String-Tanga;Tanga-Slip;String;Tanga
-Magyare;(ethnischer) Ungar;Madjare
-Anhaftungskraft;Anhangskraft;Adhäsionskraft;Adhäsion
-eingetragener Kaufmann;e. K. (Abkürzung);e. Kfm. (Abkürzung)
-eingetragene Kauffrau;e. Kffr. (Abkürzung);e. Kfr. (Abkürzung)
-Protonenzahl;Atomnummer;Ordnungszahl;Kernladungszahl
-Distributivgesetz (fachspr.);Verteilungsgesetz
-Klammergesetz (ugs.);Verknüpfungsgesetz;Assoziativgesetz (fachspr.);Verbindungsgesetz
-Vertauschungsgesetz;Kommutativgesetz (fachspr.)
-historisch-politische Bildung;HiPo (ugs.)
-nicht zufällig;nicht ohne Grund;(der) tiefere Sinn (ugs.);wohlweislich;aus gutem Grund;(schon) seinen Grund haben;nicht von ungefähr (kommen);(dabei) hat sich jemand etwas gedacht (ugs.);(jemand) hat sich etwas dabei überlegt
-Ortsfaktor;Gravitationsfeldstärke (fachspr.);Erdschwere;Erdschwerebeschleunigung;Gravitationsbeschleunigung;Erdbeschleunigung
-Kanute;Kanufahrer
-Monosaccharid;Einfachzucker
-Platz des himmlischen Friedens;Tian'anmen-Platz;Tiananmen-Platz
-propriozeptive Wahrnehmung;Tiefensensibilität;Propriozeption (fachspr.);Tiefenwahrnehmung;Propriorezeption (fachspr.)
-Mandelbrot-Menge;Apfelmännchen (ugs.)
-Arbeitsbeschaffungsmaßnahme;ABM
-Biopolymer (fachspr.);Biokunststoff;Bioplastik
-Brülltüte (ugs.);(zu laute) Auspuffanlage
-Stromerzeugung;Stromproduktion
-US-Verteidigungsministerium;Pentagon (ugs.);Verteidigungsministerium der Vereinigten Staaten
-Durchgang;Halbzeit;Seitenwechsel (ugs.)
-Gleiswechsel (ugs.);Auslenkung;Weiche;Spurwechseleinrichtung (ugs.);Eisenbahnweiche
-Nekropole;Nekropolis (griech.);Totenstadt
-zufrieden sein (mit);vorliebnehmen (mit);fürliebnehmen (veraltet);leben können (mit) (ugs., fig.);(sich) zufriedengeben;(sich) bescheiden (mit);(sich) begnügen
-wirkungslos sein;ohne Wirkung sein;spurlos vorübergehen;wirkungslos vorübergehen
-Krankheitsentwicklung;Krankheitsgeschichte;Pathogenie (veraltet);Krankheitsentstehung;Pathogenese;Genese (fachspr., Jargon)
-Fuhrmann;Karrer;Kärer;Kärrner;Kärcher;Karrenführer
-Saat-Luzerne;Schneckenklee;Alfalfa;Luzerne;Ewiger Klee
-Laubbaum;Laubholz;Laubgehölz (fachspr.)
-Friedrich der Große;Friedrich II.;Alter Fritz (ugs.)
-Ludwig Friedrich Wilhelm;Märchenkönig (ugs.);Ludwig II.
-Helot;Helote
-Klagelied;Jeremiade
-(von Hand) aussortieren;klauben
-Schmerzlosigkeit;Schmerzfreiheit;Indolenz
-Simulakrum;Simulacrum
-hypostasieren;personifizieren
-Rückgang;Rückbildung;Rückentwicklung
-Dorada;Dorade;Goldbrasse;Goldbrassen
-Erledigung (fachspr.);Bearbeitung
-Futterallergie;Futtermittelallergie
-Faszikel;Aktenbündel;Heft
-Laube (ugs.);Datscha;Landhaus;Wochenendhaus;Gartenhaus;Datsche;Ferienhaus;Sommerhaus
-DDR-Nostalgie;Ostalgie
-hungrig sein;hungern (Hauptform);Hunger leiden;schmachten;nichts zu essen haben;Kohldampf schieben (ugs.);darben
-Abseite (Bekleidungsstoff) (fachspr.);linke Seite (Bekleidungsstoff);links (ugs.);Rückseite
-kolonialisieren;kolonisieren
-Überzeugung;(fester) Glaube
-indolent;schmerzfrei;schmerzunempfindlich;schmerzlos
-pharaonische Beschneidung;Infibulation
-Maulpferd;Maultier;Muli
-Badeschuhe;Badeschlapfen (österr.);Badeschlappen (ugs.);Badelatschen (ugs.);Flipflops
-Depperltest (ugs.);Begutachtung der Fahreignung (fachspr.);Medizinisch-Psychologische Untersuchung (fachspr.);MPU;Idiotentest (ugs.)
-Kaiserschmarren;Kaiserschmarrn;Pfannkuchen
-disponibles Einkommen;verfügbares Einkommen
-sperren;die rote Karte zeigen;disqualifizieren;vom Platz stellen;verweisen;ausschließen
-Empowerment (fachspr.);Erlangung von Selbstbestimmung;Ermächtigung
-Aufrührer;Verschwörer;Empörer;Konspirant
-Bekundung;Beteuerung;Äußerung;Bezeugung;Bekunden;Mitteilung;Erweisung
-Schwangerschaftskleidung;Schwangerschaftsmode;Umstandskleidung;Umstandsmode
-Explosivdarstellung;Explosionszeichnung;Explosionsgrafik
-Dschungel;grüne Hölle;tropischer Regenwald
-anpassen;verbiegen
-Pankreas;Bauchspeicheldrüse
-Piste;Rollbahn;Rollweg;Rollfeld
-uterine Deszendenz;Mütterlinie;Mutterfolge;Matrilinearität
-Patrilinearität;Väterlinie;Vaterfolge
-ägyptischer König;Pharao
-Schalotte;Askalonzwiebel;Eschlauch;Edelzwiebel;Eschalotte
-Herbarium;Pflanzenarchiv;Herbar
-ohne politischen Herrscher;akephal
-Epitaph;Grabrede;Trauerrede
-Weißafrikaner (veraltet);Kapholländer (ugs., veraltet);Afrikaaner;Buren
-Widerspruch in sich;contradictio in adiecto (lat.);unmittelbarer Widerspruch
-Herdenpanik;Stampede
-Kämpfer;Kriegsteilnehmer;Kombattant
-man trat sich kaum, das zu sagen;man wagt kaum, es auszusprechen (Einschub);furchtbar, dies sagen zu müssen;horribile dictu (geh., bildungssprachlich, lat.)
-Zeitmaß;Tempo
-korrosionsfest;korrosionssicher;korrosionsbeständig
-Paddelboot;Kanu
-initial;anfänglich
-Abgabe;Aufschlag;Aufwand;Verzinsung;Zins;Ertrag
-Rinde;Borke (norddeutsch);Schale (landschaftlich);Kruste
-Kirche;(christliche) Religionsgemeinschaft
-Ordensgemeinschaft;religiöse Gemeinschaft;Orden
-Lametta (ugs., ironisch);Ehrenzeichen;Orden (Hauptform)
-Lispeln;Sigmatismus
-Sprachfehler (ugs.);Sprechfehler;Sprechstörung
-Pflegschaft;Gönnerschaft;Schutz;Patenschaft
-Drehung;Pirouette;Drehschwung;Standwirbel
-Cockpit;Pilotenkanzel;Fahrersitz
-Hinrichtungsstätte;Richtstätte;Richtplatz;Richtstatt
-Kontrebande (veraltet);Schmuggelei;Schmuggel (Hauptform);Konterbande (veraltet);Schleichhandel;Pascherei (ugs.)
-schwärzen (ugs.);paschen (ugs.);Schmuggel treiben;schieben;schmuggeln
-Schleichware;Schmuggelware;heiße Ware (ugs.);Konterbande (veraltet);Bannware
-Schneefall;Flockentanz (ugs.)
-Schneetreiben;Schneegestöber
-Epizootiologie;Tierseuchenkunde
-Dresdener;Dresdner;Einwohner Dresdens
-von überall (her);aus aller Herren Länder;(die) Welt;aus aller Welt;alle Nationalitäten
-Fehldruck (einer Seite);Printe (ugs.)
-Asservat;Verwahrstück
-Prokurist;Geschäftsbevollmächtigter
-geschmacklos;grausig;makaber;schauerlich;pietätlos;respektlos;abartig;düster;schauderhaft
-Schafott (ugs., fig.);Köpfmaschine;Fallschwertmaschine;Fallbeil;Guillotine (Hauptform)
-suren (bayr., österr.);pökeln
-haltbar machen;konservieren
-kandieren;einzuckern;konfieren
-entkeimen;sterilisieren;pasteurisieren
-Klammer;Heftklammer
-Taucherflosse;Flosse;Schwimmflosse
-Kollege;Genosse;Kamerad
-Anstrich;Bemalung;Lackierung
-ungebührend;unartig;impertinent (geh.);ungeschliffen;rotzfrech (ugs.);unflätig;unhöflich;salopp;anmaßend;dreibastig (ugs., regional);frech wie Dreck (ugs.);frech (Hauptform);kotzbrockig (derb);rotzig (ugs.);ungesittet;unbotmäßig (geh.);rücksichtslos;pampig (ugs.);unverfroren;unangemessen;kodderig (ugs.);nassforsch (ugs.);ungebührlich;unverschämt;flapsig;unmanierlich;respektlos;patzig (ugs.);ungehörig;unanständig;rotznäsig (ugs.);schlecht erzogen;ungehobelt;dreist;nickelig (ugs.);koddrig (ugs.);schnodderig (ugs.);präpotent (österr.);ungezogen;einen Ton am Leib (haben)! (ugs.)
-klären;klarstellen;korrigieren;berichtigen;richtigstellen;rektifizieren (geh.)
-unglaublich;feenhaft;wundersam;traumhaft;legendenhaft;phantastisch;wunderbar;fabulös;sagenhaft;mirakulös (veraltend);märchenhaft
-nicht berufstätiger Ehemann;Hausmann
-Kaskoversicherung;Fahrzeugversicherung
-entscheiden (können);das letzte Wort haben (ugs., auch figurativ);das Sagen haben;bestimmen (können)
-ungeeigneter Zeitpunkt;ungünstiger Zeitpunkt;unpassender Zeitpunkt;Unzeit
-Wähler;Wahlvolk;Stimmvieh (derb);Urnengänger;Wählerschaft;Wahlvieh (derb);Stimmvolk (schweiz.);Elektorat (fachspr.);Stimmbürger (schweiz.);Wahlberechtigte;Urnenpöbel (meist selbstironisch) (derb)
-nicht vom Fleck kommen (ugs.);nicht von der Stelle kommen;dümpeln
-Haushaltsjahr;Jahreshaushalt
-Parfumflakon;Parfumflasche
-einchecken;(sich) anmelden
-zünftig;waschecht (ugs.);rustikal;urwüchsig;bodenständig;kernig;urig;gehörig
-Ich hab da mal ne ganz blöde Frage: (...) (ugs., Spruch);sit venia verbo (geh., lat.);ich will ja nix sagen, aber (...) (ugs.);halten zu Gnaden (veraltet, heute ironisierend) (geh.);in aller Bescheidenheit (adverbial);ich bin so frei;wenn Sie nichts dagegen haben;bei allem Respekt (, aber) (geh.);wenn Sie erlauben (Hauptform);wenn's recht ist (ugs.);Sie werden entschuldigen, aber (...);mit Verlaub (geh.);Tschuldigung, aber (...) (ugs.);wenn ich (so) ehrlich sein darf;wenn Sie gestatten;mit Ihrer (gütigen) Erlaubnis (geh.);wenn ich mir die(se) Bemerkung erlauben darf (variabel);nehmen Sie's mir nicht übel (aber);Sie werden gestatten, dass (...) (geh.)
-nicht stattfinden;abgesagt werden;(sich) erübrigen;überflüssig werden;vergebliche Liebesmüh sein (im Konjunktiv: das wäre...) (ugs.);gecancelt werden;nicht mehr nötig sein;wegfallen;nicht zustande kommen;gestrichen werden;hinfällig werden;(daraus) wird nichts;(sich) erledigen (meist Vergangenheits-Tempora: hat sich erledigt ...) (ugs.);entfallen;platzen (Geschäft, Hochzeit, Reise, Termin, Finanzierung ...);(sich) zerschlagen;ersatzlos gestrichen werden;ausfallen;flachfallen (ugs.);ins Wasser fallen (ugs., fig.)
-Dieb;Langfinger (ugs., fig.);Klauer (ugs.);Spitzbube;Klaubock (ugs.)
-Heulsuse (ugs.);weint bei jeder Kleinigkeit (ugs.);Heulpeter (ugs.);nah am Wasser gebaut (sein) (ugs.)
-abtrünnig;ungetreu;treulos;ketzerisch;vertragsbrüchig;illoyal;gegen Treu und Glauben;unloyal
-Unfallflucht;Fahrerflucht;Führerflucht (schweiz.)
-Backenzahn;Seitenzahn (ugs.);Stockzahn (bayr., schweiz., österr.)
-(sich etwas) in die Haare schmieren können (ugs., fig.);vergessen (können);knicken können (ugs., salopp);(sich) aus dem Kopf schlagen (können) (fig.);nicht weiter d(a)rüber nachdenken (ugs.);nicht weiterverfolgen;(sich etwas) abschminken (ugs., fig.);abhaken (können) (ugs.)
-Verirrung (geh.);Irrweg;Holzweg (fig.);falscher Weg (auch figurativ, Hauptform);Abweg;(die) Irre (geh.)
-zum Teufel (ugs.);zum Henker (ugs.)
-Teer;Pech
-grüne Welle;freie Fahrt
-Lamellenmotor;Druckluftlamellenmotor
-Mehrfacherkrankung;Multimorbidität (fachspr.);Polymorbidität (fachspr.)
-auf gleichem Niveau;auf gleicher Augenhöhe
-Auflagendegression;Seriengrößendegression
-einreichen;anmelden
-Gängelung;Schikane
-Nachsommer;Spätsommer;Altweibersommer (ugs.)
-(ziellos) durch die Lande juckeln (ugs., variabel);cruisen (ugs.);karriolen (ugs.);herumgurken (ugs.);herumkutschieren (variabel);herumfahren
-Leberkassemmel (bairisch);Leberkäsweckle (schwäbisch);Fleischkäsebrötchen;Leberkäsbrötchen;Leberkässemmel (bairisch)
-Raffinierung;Raffination;Raffinieren;Veredelung
-Nanologe;Gartenzwergesammler;Gartenzwergkundler
-gemütskrank;psychotisch;nervenkrank;neurotisch
-neurotische Störung;Psychoneurose;seelische Störung;psychische Störung;Neurose (fachspr.);Verhaltensstörung;seelische Erkrankung
-Zwickel (ugs., bayr., schwäbisch, österr.);2-Euro-Stück;2-Euro-Münze
-(die) Toilette spülen;(die) Spülung betätigen;abziehen
-(ein) Herkules (fig.);Kraftmeier (ugs.);Kraftmensch;Kraftprotz (ugs.);Rambo (ugs., fig.);Kraftpaket
-kleine Rose;Rosette
-Repatriierung;Auslandsrückholung
-zurückbestellen;(Truppen / Einsatzkräfte / Diplomaten / ... von einem Ort) abziehen;zurückordern;(jemanden) zurückrufen;(jemanden) zurückbeordern;(die Jungs) nach Hause holen (ugs., veraltend);zurückpfeifen (ugs.);(seine Jungs) zurückholen (ugs., veraltend);(jemanden) abberufen
-Unglücksbotschaft;Horrormeldung;Schreckensmeldung;Schreckensnachricht;Hiobsbotschaft;Schreckensbotschaft;schlechte Nachricht
-Eingeständnis;Anerkenntnis;Einräumung;Zugeständnis
-denn je;als jemals zuvor
-Stärke;Intensität;Grad;Ausmaß
-unter Strom setzen;elektrische Ladung übertragen;elektrisieren
-Vergesslichkeit;Schusseligkeit (ugs.)
-Belüftungsschacht;Entlüftungsschacht;Luftschacht;Ventilationsschacht;Lüftungsschacht
-Teufe (Bergbau);Tiefe
-niederbringen;abteufen;teufen
-Nichtigkeit;Unwirksamkeit
-brodeln;blubbern;glucksen;gluckern;sprudeln
-tönern;aus Ton (gefertigt)
-Kurzen (ugs.);Kurzer (ugs.);Kurzschluss
-eine (untrennbare) Einheit bildend;aus einem Stück;monolithisch (fachspr.);zusammenhängend und fugenlos (hergestellt)
-Kasperkopf (ugs.);Dummquatscher (ugs.);Flachzange (ugs.);Flachpfeife (ugs.);Dummschwätzer (ugs.);Laberarsch (derb)
-asphaltieren;teeren (ugs.)
-Petroleumlampe;Funzel (ugs.);Ampel (veraltet);Petroleumleuchte
-Inadäquanz;Unverhältnismäßigkeit;Unangemessenheit
-Realitätsverleugnung;Verblendung;Verwirrung
-Zankhahn;Krawallbürste (ugs.);Streithammel (ugs.);zänkische Person;Streithahn (ugs.);streitsüchtige Person;Krawallnudel (ugs.);Streithansl (ugs., bayr., österr.);Streithansel (ugs., bayr., österr.);Zänker
-Maschinenführer;Maschinenbediener;Maschinist
-vollblütig;reinrassig
-Transpirationsflüssigkeit (fachspr.);Soße (ugs., bayr.);Schweiß;Hautausdünstung;Schweißabsonderung;Schweißsekretion
-Wundsein;intertriginöses Ekzem (fachspr.);Wolf;Hautwolf;Intertrigo (fachspr.)
-Acne infantilis (fachspr.);Säuglingsakne;Acne neonatorum (fachspr.);Neugeborenenakne;Baby-Akne
-Acne aestivalis (fachspr.);Mallorca-Akne;Sommerakne
-Säuglingsakne;Acne infantum (fachspr.);Acne infantilis (fachspr.);Kleinkindakne;Acne juvenilis (fachspr.)
-Acne venenata (fachspr.);Kontaktakne
-Akanthose (fachspr.);Acanthosis (fachspr.)
-Lentigines seniles (fachspr.);Lentigines solares (fachspr.);Altersflecken
-heller Hautkrebs (ugs.);Basalzellenkrebs;Epithelioma basocellulare (fachspr.);Basalzellkarzinom;Basaliom (fachspr., veraltet);weißer Hautkrebs (ugs.)
-Becker-Nävus;Becker-Melanose;Melanosis naeviformis (fachspr.)
-Buchweizenkrankheit;Buchweizenausschlag
-Duhring-Brocq-Krankheit;Dermatitis herpetiformis Duhring (fachspr.)
-Cutis laxa-Syndrom;Dermatochalasis (fachspr.)
-Dyshidrose;dyshidrosiformes Ekzem;Dyshidrosis;Pompholyx (fachspr.);dyshidrotisches Ekzem
-Clarkscher melanozytärer Nävus;Dysplastischer Nävus
-Embolia cutis medicamentosa (fachspr.);Nicolau-Syndrom
-Herbstmilbe (Hauptform);Erdlaus;Graslaus;Erntemilbe;Heumilbe;Herbstgrasmilbe;Herbstlaus;Grasmilbe;Neotrombicula autumnalis (fachspr.);Pfirsichlaus
-Dermatitis contusiforme (fachspr.);Erythema contusiforme (fachspr.);Erythema nodosum (fachspr.);Knotenrose
-Feuermal;Naevus flammeus (fachspr.)
-Aurikulotemporales Syndrom (fachspr.);Frey-Syndrom;Gustatorisches Schwitzen;Gustatorische Hyperhidrose
-Infantile papulöse Akrodermatitis (fachspr.);Gianotti-Crosti-Syndrom;Acrodermatitis papulosa eruptiva infantilis (fachspr.)
-Größenkostenersparnis;Skaleneffekt;Skalenertrag
-stereotyp;nach Schema F (ugs.);routinemäßig;schematisch;schablonenhaft;mechanisch
-Tab;Reiter
-unkaputtbar (ugs., scherzhaft);nicht kaputtzukriegen (ugs.);unverwüstlich;nicht totzukriegen (ugs.);unzerstörbar;läuft und läuft und läuft (veraltet)
-offen zutage liegen;(das) sieht ein Blinder mit dem Krückstock;eindeutig;völlig klar;mit den Händen zu greifen;sonnenklar (ugs.);glasklar;klar wie Kloßbrühe (ugs.);(so) klar wie eins und eins ist zwei (ugs.);manifest (geh., bildungssprachlich);offenkundig;klar wie Klärchen (ugs.);(ein) (ganz) klarer Fall (ugs.);ohne jeden Zweifel;klar zutage liegen;offensichtlich;(es gibt) nichts zu diskutieren (ugs.);(eine) (ganz) klare Kiste (ugs.);(völlig) klarliegen (Fall);(klar) auf der Hand liegen (fig.);evident
-Erfolg;Durchsetzung;Erfolgsgeschichte (fig.)
-Mailingliste;Verteiler (ugs.)
-Rohstofferkundung;Prospektion (fachspr., lat.);Schurf;Schürfen
-Weltkonzern;Multi (ugs.);Global Player;Trust (engl.);multinationaler Konzern
-Leittier;Platzhirsch (ugs., fig.);Alpha-Männchen (männl.);Alpha-Tier;Alpha-Weibchen (weibl.)
-fokale dermale Hypoplasie;Goltz-Gorlin-Syndrom
-Hidradenitis suppurativa (fachspr.);Acne inversa (fachspr.)
-Grießknoten;Trichilemmalzyste (fachspr.);Grützbeutel;Atherom (fachspr.);Balggeschwulst;Talgzyste
-Fibroma simplex (fachspr.);hartes Fibrom;kutanes fibröses Histiozytom (fachspr.);Fibroma durum (fachspr.);Dermatofibrom
-Schweinerotlauf;Erysipeloid (fachspr.)
-Morbus Günther;kongenitale erythropoetische Porphyrie (fachspr.)
-Nävus Sutton (fachspr.);Halonävus (fachspr.)
-Hämhidrose;hemidrosis;Blutschweiß;hemathidrosis
-Hand-Fuß-Syndrom;palmar-plantares Erythrodysästhesie-Syndrom (fachspr.)
-Kohlenbeule;Karbunkel;ICD-10 L02;Eiterbeule
-Talfieber;Wüstenrheumatismus;Wüstenfieber;Kokzidioidomykose (fachspr.)
-Kongenitaler Nävus (fachspr.);Konnataler Nävuszellnävus (fachspr.)
-Hautmaulwurf;Larva migrans (fachspr.);Creeping eruption (fachspr.)
-Lentigo (fachspr.);Nävus lenticularis (fachspr.)
-Hornknötchenflechte;Lichen pilaris (fachspr.)
-Lichen ruber planus (fachspr.);Knötchenflechte
-Photoallergie;Sonnenallergie;Lichtallergie
-Abrundung;Arrondierung
-Epidermolysis acuta toxica (fachspr.);Lyell-Syndrom;Syndrom der verbrühten Haut;Epidermolysis bullosa (fachspr.)
-Lyme-Borreliose;Lyme-Krankheit
-schwarzer Hautkrebs;malignes Melanom;Melanoblastom (fachspr.);Melanom;Melanozytoblastom (fachspr.)
-Hitzeblattern;Hitzepickel;Hidroa (fachspr.);Dermatitis hidrotica (fachspr.);Schweißbläschen;Miliaria;Schwitzbläschen;Sudamina (fachspr.);Schweißfrieseln
-mitschleppen;mitreißen;mitzerren;mitziehen;mitschleifen
-fixe Kosten;Festkosten;Fixkosten;Bereitschaftskosten;Grundkosten;zeitabhängige Kosten;beschäftigungsunabhängige Kosten
-und andere;et al. (Abkürzung);et alia (Neutrum);et aliae (Femininum);et alii (Maskulinum)
-Molluscum contagiosum (fachspr.);Molluske;Epithelioma molluscum (fachspr.);Dellwarze;Epithelioma contagiosum (fachspr.)
-Erythroplasie de Queyrat (fachspr.);Dermatosis praecancerosa Bowen (fachspr.);Bowen-Hautkrebs;Dyskeratosis maligna (fachspr.);Morbus Bowen;Bowen-Karzinom
-Dyskeratosis follicularis (fachspr.);Morbus Darier
-Cheilitis angularis (fachspr.);Mundwinkelrhagaden;Faulecke;Perlèche;Angulus infectiosus (oris) (fachspr.)
-Myiasis (fachspr.);Fliegenmadenkrankheit
-Naevus araneus (fachspr.);Naevus stellatus (fachspr.);Sternnävus;Eppinger-Sternchen;Gefäßspinne;Spinnennävus
-Nagelpilz;Tinea unguium (fachspr.);Onychomykose (fachspr.);Nagelmykose
-Dermales Melanozytom;Blauer Nävus;Nävus coeruleus (fachspr.)
-Erythema toxicum neonatorum (fachspr.);Erythema neonatorum (fachspr.);Neugeborenenexanthem (fachspr.)
-Neurokutane Erkrankung;Neuroectodermale Erkrankungen
-Onychocryptosis (fachspr.);Eingewachsener Nagel;Unguis incarnatus (fachspr.)
-Heterochromosom;Heterosom (fachspr.);Gonosom;Allosom (fachspr.);Geschlechtschromosom
-Pemphigus vulgaris (fachspr.);Blasensucht
-Periorale Dermatitis (fachspr.);Rosacea-artige Dermatitis;Mundrose
-Piebaldismus;Albinismus partialis (fachspr.);partieller Albinismus
-Piezogene Papeln;Piezogene Knötchen
-melanozytärer Nävus;Pigmentnävus;Melanozytennävus
-Pityriasis lichenoides et Varioliformis acuta (fachspr.);Mucha-Habermann-Krankheit
-Stachelflechte;Pityriasis rubra pilaris (fachspr.)
-Kleienpilzflechte;Kleieflechte;Pityriasis versicolor (fachspr.)
-Sonnenekzem;Polymorphe Lichtdermatose;PLD (Abkürzung)
-Pseudoxanthoma elasticum (fachspr.);Grönblad-Strandberg-Syndrom
-angioneurotisches Ödem;Quincke-Ödem;Angioödem
-Strahlendermatitis;Radiodermatitis
-Morbus Reiter;Reiter-Krankheit;Reaktive Arthritis
-Keratosis pilaris (fachspr.);Keratosis follicularis (fachspr.);Reibeisenhaut
-Röschenflechte;Schuppenröschen;Pityriasis rosea Gibert (fachspr.)
-Halbfabrikat;vorgefertigte Rohmaterialform (fachspr.);Halbzeug
-Hyperhidrosis plantaris (fachspr.);Hyperhidrosis pedis (fachspr.);Schweißfuß
-Seborrhoea oleosa (fachspr.);öliger Talgfluss
-Seborrhoea sicca (fachspr.);trockener Talgfluss
-Alterswarze;Senile Warze;Basalzellpapillom (fachspr.);Seborrhoische Warze;Seborrhoische Keratose (fachspr.);Verruca seborrhoica (fachspr., lat.)
-Schooner;Schoner;Schuner
-Seborrhoisches Ekzem;Seborrhoische Dermatitis
-Xerosis (fachspr.);Xerose (fachspr.);Sebostase (fachspr.);Xerodermie;atopisches Stigmata
-Sneddon-Syndrom;Livedo racemosa generalisata (fachspr.)
-Erythema solare (fachspr.);UV-Erythem (fachspr.);Dermatitis solaris (fachspr.);Sonnenbrand
-spinozelluläres Karzinom;verhornender Plattenepithelkrebs;Spinaliom (fachspr.);Stachelzellkrebs;Plattenepithelkarzinom;Epithelioma spinocellulare (fachspr.)
-juveniles Melanom;Epitheloidzellnävus;Spitz-Tumor;Spindelzellnävus;Spitz-Nävus
-Morbus Schenk;Sporothrix-Mykose (fachspr.);Schenk-Krankheit;Sporotrichose (fachspr.)
-Dermatostomatitis Baader;Stevens-Johnson-Syndrom
-Storchenbiss;Nävus Unna-Politzer (fachspr.);Nävus okzipitalis (fachspr.);Nävus Unna (fachspr.);Bossard-Fleck;Naevus occipitalis (fachspr.)
-meningofaciale Angiomatose (fachspr.);Angiomatosis encephalofacialis (fachspr.);Sturge-Weber-Syndrom;encephalotrigeminale Angiomatose (fachspr.);Sturge-Weber-Krabbe-Syndrom
-Herbstbeiß;Trombidiose (fachspr.);Erntekrätze
-Scheckhaut;Leucopathia acquisita (fachspr., griechisch, lat.);Vitiligo (fachspr.);Weißfleckenkrankheit
-Erythema migrans (fachspr.);Erythema chronicum migrans (fachspr.);Wanderröte
-Plica polonica (fachspr.);Haarschrötel;Schrötleinszopf;Weichselzopf;Trichoma (fachspr.);Judenzopf;Cirragra (fachspr.);Wichtelzopf
-Wiesengräserdermatitis;Photodermatitis;Photodermatose
-Dermatitis glutaealis (fachspr.);Dermatitis ammoniacalis (fachspr.);Windeldermatitis;Windelsoor (fachspr.);Windelausschlag
-Mondscheinkrankheit;Xeroderma pigmentosum (fachspr.);Lichtschrumpfhaut;Melanosis lenticularis progressiva (fachspr.)
-Gewitterwürmer;Fransenflügler;Thripse;Gewittertierchen;Thysanoptera (fachspr.);Blasenfüße;Gewitterfliegen
-ablesen;erkennen;ersehen
-Mehr habe ich dem nicht hinzuzufügen. (geh.);Punktum;Schluss mit lustig! (ugs.);und damit hat sich's (ugs.);genug! (geh.);Punkt. Aus. Ende. (ugs.);Ende, aus, Mickymaus. (ugs.);Klappe zu, Affe tot. (ugs.);Kein Kommentar! (ugs.);Ende;es reicht (jetzt) (ugs., Hauptform);Stopp! (ugs.);Ende der Durchsage! (ugs.);Jetzt ist (bei mir) Sense! (ugs.);genug damit (geh.);aus! (ugs.);Schluss, aus, Ende! (ugs.);es reicht (jetzt langsam)! (ugs.);genug ist genug!;Jetzt reicht's! (ugs.);Das reicht! (ugs.);Aus! (fachspr.);Ende im Gelände! (ugs.);(dann ist bei mir) Feierabend! (ugs.);Thema durch. (ugs.);Halt ein! (geh., veraltet);Schluss;Aufhören! (ugs.);Rien ne va plus. (geh., franz.);Es langt! (ugs., regional);genug davon (geh.);Ende, aus, Nikolaus. (ugs.);genug jetzt!;Aus die Maus. (ugs.);Ende und aus! (ugs.);(und damit) basta! (ugs.)
-Sammelklage;Gruppenklage;Massenklage
-Frequentierung;Besucherzahl
-denken an (ugs.);schwanger gehen mit (geh., fig.);(etwas / jemanden) im Auge haben (bei) (ugs., fig.);in Erwägung ziehen;(sich etwas) vorstellen können (ugs.);daran denken (zu);(sich) mit dem Gedanken tragen (geh.);nicht abgeneigt sein (zu + Infinitiv) (geh.);mit dem Gedanken spielen (ugs.);(etwas) mit sich herumtragen (ugs.);(etwas) erwägen;liebäugeln (mit) (fig.);darüber nachdenken (zu)
-Hähnchenschlegel;Hähnchenbollen;Hähnchenschenkel;Hendlschenkel;Gockelhaxen;Hendlfuß;Hähnchenflügel
-mausgrau;grau
-Polenta;Plent;Sterz;Riebel
-Herzschmerz;Brustenge;Angina pectoris (fachspr.);Herzbeklemmung;Stenokardie (fachspr.);Herzenge
-Schneejacke;Anorak;Kapuzenjacke
-Schusser;Marmel;Glaskugel;Murmel;Klicker
-Mündungsdelta;Flussdelta;Deltamündung
-girren;gockeln;kollern;rucken;balzen;gurren;rucksen
-Mongolenhütte;Jurte;Nomadenzelt;Kuppelzelt
-Biomedizin;Allopathie (fachspr., griechisch);westliche Medizin;Allöopathie (fachspr., griechisch);Schulmedizin
-Lesefähigkeit;Lesekompetenz;Lesefertigkeit;Leseverstehen
-Vorbestimmung;Determinismus;Vorherbestimmung
-Cliquenwirtschaft;Patronage;Klientelismus;Protektion
-Deletion;Gendeletion
-Desoxyribonukleinsäure;DNS (Abkürzung);DNA (Abkürzung, engl.);Erbinformation (ugs., fig.)
-Trugschlussrechnung;Milchmädchenrechnung
-Morphophonologie;Morphonologie
-Mauke;Fesselekzem (fachspr.)
-Produkt-Moment-Korrelation;Korrelationswert;Korrelationskoeffizient
-Skalendignität;Messniveau;Skalenqualität;Skalenniveau
-Reichsschatz;Reichsinsignien;Reichskleinodien
-Liturgiesprache;Sakralsprache;Liturgische Sprache
-mit Strafe belegen;bekommen (ugs.);schuldig sprechen;Strafe verhängen;verurteilen (zu);aburteilen;verdonnern (zu) (ugs.);verknurren (zu) (schweiz.);bestrafen;für schuldig erklären
-Töpfer (Hauptform);Keramiker (Hauptform);Hafner;Aulner (fachspr., veraltet);Häfner
-Lastesel;Tragesel;Packesel (auch figurativ)
-Paketbauer;Paketmacher;Paketierer;Paketersteller
-Erbarmungslosigkeit;Grausamkeit;schonungslose Härte;Gnadenlosigkeit;Unbarmherzigkeit;Gefühlskälte;Schonungslosigkeit
-Aktuar (fachspr.);Versicherungsmathematiker
-Gleichseitigkeit;Gleichmaß;Spiegelbildlichkeit;Gleichmäßigkeit;Symmetrie (griechisch)
-Annalen (geh.);Geschichtswerk;Jahrbuch;Aufzeichnung;Chronik;Geschichte
-Flickschuster (ugs.);Schuhmacher;Schuster;Meister Pfriem (ugs.)
-Bartwisch (bayr., österr.);Handbesen;Handfeger
-Flaggschiff (fig.);Spitzenreiter;Anführer;(die) Nummer eins;Platzhirsch (fig.)
-Seitenzählung;Seitennummerierung (eines Schriftstückes);Paginierung
-geeignet;probat
-Webkatalog;Webverzeichnis
-hin- und herbewegen;(wild) gestikulieren;schwenken;rumfuchteln (ugs.);(herum)fahren;herumfuchteln;fuchteln
-musikalischer Leckerbissen;Bravourstück
-zusammenrühren;anbazen (ugs., bayr., österr.)
-Tastfeld;Touchpad (engl.)
-unangenehme Folge(n);Unbill (geh.);Ungelegenheit(en);Ärgerlichkeit(en);Ärgernis(se);Beschwernis(se);Unbilden (nur Plural);unangenehme Begleiterscheinung(en);Unerfreulichkeit(en);Unannehmlichkeit(en);Ungemach (nur Singular) (geh., veraltend);Unbill (nur Singular) (geh.);Widrigkeit(en);Unerquicklichkeit(en) (geh.)
-Quadratur des Kreises (fig.);unlösbare Aufgabe
-Schwinghebel;Schlepphebel
-freisetzen;herauslösen
-Studierendenschaft;Studentenschaft
-abknipsen;abzwicken;durchtrennen;kappen;durchschneiden;abklemmen
-destilliertes Wasser;Aquadest (fachspr.)
-Zigarrenbox;Humidor
-Eingabegröße;Eingabewert;Ausgangswert
-Baltisches Meer;Mare Balticum (lat.);Badewanne der Nation (ugs.);Baltische See;Suevisches Meer;Ostsee (Hauptform)
-Zuschreibung;Attribuierung;Attribution
-unbeschriebenes Blatt;leeres Blatt;Tabula rasa (lat.)
-Nukleotidsequenz (fachspr.);Basensequenz (fachspr.);DNA-Sequenz
-Reglementierung;Regelfestlegung
-Kabarettsängerin;Chansonette;Vortragskünstlerin;Diseuse
-von der Bildfläche verschwinden (ugs., fig.);auf Tauchstation gehen (ugs., fig.);nicht mehr erreichbar sein;(sich) verstecken;abtauchen (ugs., fig.);untertauchen (fig.);(sich) verbergen;in der Versenkung verschwinden (ugs., fig.)
-Ösophagus (fachspr.);Oesophagus (fachspr.);Speiseröhre;Schluckdarm (veraltet)
-Epipharynx (fachspr.);Nasopharynx (fachspr.);Nasenrachen;Rhinopharynx (fachspr.);Pars nasalis pharyngis (fachspr.);Nasenrachenraum
-Mundrachen;Mesopharynx (fachspr.);Pars oralis pharyngis (fachspr.);Oropharynx (fachspr.)
-Laryngopharynx (fachspr.);Pars laryngea pharyngis (fachspr.);Hypopharynx (fachspr.);Schlundrachen
-Eustachiröhre;eustachische Röhre;Ohrtrompete;Eustachi-Röhre;Tuba auditiva Eustachii (fachspr.);Tuba pharyngotympanica (fachspr.)
-in der Mitte gelegen;median (fachspr.)
-medial (fachspr.);zur Mitte hin gelegen
-paramedian (fachspr.);neben der Mitte gelegen
-ipsilateral (fachspr.);auf der gleichen Seite befindlich
-auf der gegenüberliegenden Seite befindlich;kontralateral (fachspr.)
-superior [beim Menschen] (fachspr.);zum Schädel hin;cranial (fachspr.);kranial (fachspr.)
-caudal (fachspr.);zum Schwanze hin;kaudal (fachspr.);inferior [beim Menschen] (fachspr.)
-hinter dem Schädel;postcranial (fachspr.);postkranial (fachspr.)
-terminal (fachspr.);am Ende gelegen
-am falschen Ort gelegen;ektop (fachspr.)
-rechte Seite;rechts (Hauptform);das andere rechts (ugs., scherzhaft-ironisch);zur Rechten;auf der rechten Seite;rechtsseitig;rechtsseits;zu seiner Rechten (männl.);rechter Hand;dexter (fachspr., lat.);zur rechten Hand;zu ihrer Rechten (weibl.);steuerbord
-vorn liegend;anterior (fachspr.)
-posterior (fachspr.);hinten liegend
-unten liegend;inferior (fachspr.)
-oben liegend;superior (fachspr.)
-prävertebral (fachspr.);vor der Wirbelsäule liegend
-rostral (fachspr.);schnabelwärts;schnauzenwärts
-vom Mund weg gelegen;aboral (fachspr.)
-okzipital (fachspr.);zum Hinterkopf hin gelegen
-temporal (fachspr.);schläfenwärts;seitlich;lateral (fachspr.)
-nasenwärts;medial (fachspr.);nasal (fachspr.);zur in der Mitte gelegenen Nase hin
-volar (fachspr.);hohlhandseitig;palmar (fachspr.);handflächenseitig
-plantar (fachspr.);fußsohlenseitig
-Okklusionsfläche;Kaufläche
-zur Okklusionsfläche hin;mastikal (fachspr.);zur Kaufläche hin;okklusal (fachspr.)
-zungenseitig;lingual (fachspr.)
-gaumenseitig;palatinal (fachspr.)
-labial (fachspr.);lippenseitig
-backenseitig;bukkal (fachspr.)
-mesial (fachspr.);zur Mitte des Zahnbogens hin
-apikal (fachspr.);zur Wurzelspitze hin
-zur Zahnkrone hin;koronal (fachspr.)
-inzisal (fachspr.);zur Schneidekante hin
-zum Zahnhals hin;zervikal (fachspr.)
-distal (fachspr.);von der Körpermitte weg
-zum Nachbarzahn hin;approximal (fachspr.)
-den Mundvorhof betreffend;vestibulär (fachspr.);zum Mundvorhof hin
-senkrecht zur Sagittalebene;transversal (fachspr.)
-aufsteigend;aszendierend (fachspr., lat.);emporkommend;aufrückend
-absteigend;deszendierend
-blauertsche Bänder;richtungsbestimmende Bänder;richtungsbestimmende Frequenzbänder
-Schalllehre;Akustik;Lehre vom Schall
-ölig;verölt;tranig
-Seegerring;Nutenring;Sicherungsring
-Distanzring;Distanzrohr;Distanzröhrchen;Distanzhülse
-abhängen;abschütteln;loswerden
-Planetoidengürtel;Hauptgürtel;Asteroidengürtel
-(mit etwas) Gewinn machen;(aus etwas) Kapital schlagen
-Misswirtschaft;Fehlwirtschaft
-auf den Auflöser drücken (ugs.);(ein) Foto machen (Hauptform);(eine) Aufnahme machen;knipsen (ugs.);ein Bild machen (von);(einen) Schnappschuss machen;fotografieren;(ein) Foto schießen
-Meilenstein;Postmeilensäule
-Sächsische Postmeilensäule (ugs.);Distanzsäule;Kursächsische Postmeilensäule
-Chursachsen (veraltet);Kursachsen
-Eiskasten (österr.);Kühlschrank
-Schichtung;Stratifizierung (fachspr.);Stratifikation (fachspr.)
-Wasserhose;Zyklon;Großtrombe;Windhose;Taifun;Trombe;Twister (ugs., engl.);Wirbelsturm;Wirbelwind (ugs.);Tornado
-Machtstreben;Machtgier;Machthunger
-Föttinger-Wandler;hydrodynamischer Drehmomentwandler
-Maschinenbauer;Maschinenbaumechaniker
-Befähigungsnachweis;Sachkundenachweis
-Facharbeiter für Fertigungsmittel (DDR);Werkzeugmacher;Werkzeugmechaniker
-(stark) geneigt;(stark) abfallend;steil;abschüssig
-(fortlaufend) durchnummerieren;paginieren (fachspr.);mit Seitenzahlen versehen
-Mimöschen (ugs., fig.);Prinzessin auf der Erbse (fig.);Sensibelchen (ugs.);zarte Seele;Mimose (fig.);empfindsame Seele
-Mimosa pudica (fachspr.);Schamhafte Sinnpflanze;Mimose
-Produktreife;Marktreife
-Nullserie;Vorserie;Pilotserie
-logistische Regression;Logit-Modell
-Korpus (latinisiert);Körper;Corpus (lat.);Leib
-endgültiger Sieg;Endsieg
-Charge (fachspr.);Überzeichnung
-chargieren (fachspr.);überziehen;übertrieben darstellen;outrieren (geh.);überstilisieren;überzeichnen
-parat stehen;auf ihren Einsatz warten;darauf warten, dass es losgeht;in den Startlöchern stehen (fig.);auf den Befehl (zum ...) warten;auf alles vorbereitet (sein);einsatzbereit;am Start (sein) (ugs.);in Alarmbereitschaft;(sich) bereithalten;auf seinen Einsatz warten;Gewehr bei Fuß (stehen) (ugs., fig., militärisch);bereitstehen
-Aufschwung;expansive Phase;Expansion
-Depression;Rezession;Konjunkturtief;(wirtschaftliche) Flaute;Wirtschaftskrise
-Großes Alaska-Beben;Karfreitagsbeben
-Magna Charta;Magna Carta Libertatum
-Lordkanzler;Hoher Lordkanzler von Großbritannien
-Ich-Botschaft;Selbstoffenbarung
-in die Höhe schießen;stark ansteigen (Hauptform);durch die Decke gehen (Preise) (fig.);rasant nach oben gehen;emporschnellen (Zahlen);in die Höhe schnellen;hochschnellen;explodieren (fig.)
-Alternativkosten;Opportunitätskosten;Verzichtskosten;Schattenpreis
-Mikroökonomik;Mikroökonomie;Mikrotheorie
-Bankguthaben;Deposit;Bankeinlage
-Pendelzug (schweiz.);Wendezug
-Pinakel;Fiale (fachspr., ital.)
-Gesundheitssystem;Gesundheitswesen
-Rekordmeister;FC Hollywood (ugs.);FC Bayern München
-Friedensrichter (sächsisch);Ombudsperson;Schiedsperson
-Mod-Datei;Moduldatei;Modul;Trackermodul
-Tracker;Rastersequenzer
-lokalisierbar;peilbar;ortbar
-gedeihend;aufstrebend;prosperierend;blühend;florierend
-Digibeta;Digital Betacam
-Türpfosten;Türeinfassung;Türfutter;Türrahmen (ugs.);Türstock;Türzarge
-Streetworker;Sozialarbeiter
-Eingliederungsprozess;Integrationsprozess;Einordnungsprozess;Sozialisation
-Krankenkost;Reduktionskost;Diät;Schonkost
-ohne Zwang;repressionsfrei;zwanglos;antiautoritär
-mit der Briefpost fahren;karriolen (veraltet)
-einsetzen;implantieren;einpflanzen
-entfernen;explantieren
-Unix-ähnlich;unixoid
-Hochfläche;Hochebene;Plateau;Hochland
-Prosaist;Prosaschriftsteller
-Karpatenbecken;Pannonische Tiefebene;Pannonisches Becken
-Tiefebene;Tiefland
-Böhmisches Massiv;Böhmisches Hochland;Böhmische Masse
-Gebirgsbildung;Orogenese (fachspr.)
-Nachthimmelsleuchten;Airglow (engl.);Nachthimmelslicht
-Kobold;Blue Jet (engl.)
-Feuerkugel;Feuerball;Bolid;Bolide
-Brandkugel;Feuerkugel
-Eklipse;Sonnenfinsternis
-grünes Leuchten;grüner Blitz;grüner Strahl
-Korona;Aureole;Höfe
-NLC (fachspr.);Leuchtende Nachtwolke
-Parhelion (fachspr.);Nebensonne
-Iridium-Flackern;Iridium-Flare
-Lichtbüschel;Strahlenbüschel;Wolkenstrahlen;Dämmerungsstrahlen
-(solarer) Terminator (fachspr.);Tag-Nacht-Grenze;Separator (fachspr.)
-Zerebrospinalflüssigkeit;Hirnwasser;Gehirn-Rückenmarks-Flüssigkeit;Liquor cerebrospinalis (fachspr., griechisch, lat.);Cerebrospinalflüssigkeit (fachspr., griechisch);Liquor (fachspr., lat.);Nervenwasser (ugs.)
-antike Inschrift;Epigraph (veraltet)
-(sich) abplagen (mit);laborieren (an);herumlaborieren (mit) (ugs.);nicht loswerden (ugs.)
-unterbreitet;vorgelegt
-Radialreifen;Gürtelreifen
-Kord;Cord;Manchester;Schnürlsamt (ugs., österr.)
-Krampf;Leibschmerzen;Kolik
-Futterrübe;Rübe;Gemeine Rübe;Runkelrübe
-(ein) Moribunder (geh.);Todgeweihter;Todeskandidat;Sterbende (weibl.);Sterbender (männl.);Moribundus (geh.)
-quid pro quo (lat.);dieses für das
-Overhead (engl.);Verwaltungsdaten
-ungelernter Arbeiter;Spannmann (veraltet);Hilfsarbeiter;ungelernte Arbeitskraft;Gehilfe;Helfer;Hilfsarbeitskraft;ungelernter Mitarbeiter;Hilfskeule (ugs., salopp);ungelernter Beschäftigter;Handlungsdiener (veraltet);ungelernter Arbeitnehmer;Ungelernter (ugs.);Zuarbeiter;Aushilfe;Aushilfskraft;Aushilfsjobber;Hilfskraft
-Gatter;Gitter;Zaun
-deklarativ;erklärend;deklaratorisch
-Mikron (veraltet);Mikrometer
-detailliert ausarbeiten;ausgestalten;pinseln (ugs.);ausformulieren
-(jemandem) einen Vorteil einräumen;(jemandem etwas) einfach machen;(jemandem) eine Steilvorlage bieten (ugs.)
-Spätbarock;Rokoko
-Geld auf dem Bankkonto (ugs.);Buchgeld;Geld auf dem Konto (ugs.);Giralgeld;Geschäftsbankengeld
-körperlos;feenhaft;ätherisch (geh.);wie eine Sylphe;engelhaft;elfenhaft;sylphidenhaft
-umformen;transponieren;umstellen
-Trieb;Spross;Pflanzentrieb;Austrieb;Jungtrieb
-totgeschwiegen;tabuisiert
-Funkschnittstelle;Luftschnittstelle
-Jakobus der Große;Jakobus Maior;Santiago (spa.);Jakobus der Ältere
-kalvinistisch (alte Schreibung bis 2017);calvinistisch
-Kalvinismus (alte Schreibung bis 2017);Calvinismus
-AG (Abkürzung);Ordinariat;Lehrstuhl;Arbeitsgruppe;Lehrkanzel (veraltet, österr.)
-Hiatus;Hiat;Vokalzusammenstoß
-Choreograf;Choreograph;Tanzlehrer
-Bathyscaph;Tiefsee-U-Boot;Bathyskaph
-Bathysphäre;Tiefseekugel;Bathysphere
-Luftdruck;atmosphärischer Druck
-einschleusen;einschmuggeln
-ansaugen;festsaugen;per Saugnapf befestigen;festhaften;anhaften
-Gierachse;Hochachse;Vertikalachse
-Gierrate;Giergeschwindigkeit
-Umdrehungsfrequenz;Umlauffrequenz;Drehzahl
-reziproker Wert;Kehrzahl
-anhaltisch;anhaltinisch
-Herrschaft der Angesehenen;Timokratie;Herrschaft der Besitzenden;Geldaristokratie
-Attikawohnung (schweiz.);Penthouse;Penthaus (veraltend);Penthousewohnung
-Formfehler;Verfahrensfehler;formaler Fehler
-Rydberg-Ritz-Formel;Rydberg-Formel
-eine Fleppe ziehen (ugs.);schmollen;die beleidigte Leberwurst (spielen) (ugs., variabel);den Beleidigten spielen;eine Schnute ziehen (ugs.);eine Flappe ziehen (ugs.);unwillig schweigen;einen Schmollmund machen (ugs.);ein (langes) Gesicht ziehen (ugs.);einen Flunsch ziehen (ugs., regional);ein (langes) Gesicht machen (ugs.)
-verjagend;vertreibend;verscheuchend;schassend
-Punktion (fachspr.);gezieltes Setzen einer Nadel
-stricheln;strichlieren (österr.)
-Pünktchen machen;punktieren
-angestammt;eingesessen
-Anwerber;Abwerber;...scout (engl., fig.);Rekrutierer;Talentsucher;Headhunter (engl., fig.)
-schanghaien;(gewaltsam) anheuern;pressen
-Thunfangboot;Albacore-Boot
-Aldislampe;Handmorselampe
-Ponza-Inseln;Pontinische Inseln
-Westindien;Westindische Inseln;Karibische Inseln
-Kapverden;Kapverdische Inseln
-Makaronesische Inseln;Makaronesien
-Lamination;Laminierung
-es wird (noch) gearbeitet an (ugs.);im Aufbau (begriffen);(noch) eine Baustelle (sein) (ugs.);in der (ersten) Bauphase (variabel);im Bau (befindlich)
-erschleichen;erschwindeln
-publikumswirksam;sagen, was die Leute hören wollen;dem Volk nach dem Mund reden(d);populistisch
-hochdotiert;bestens bezahlt;bestbezahlt
-Panzerwagen;gepanzertes Fahrzeug;Sonderschutzfahrzeug
-Generalfeldmarschall;Feldmarschall
-Kellner;Keller;Kellerer;Cellarius (frühes Mittelalter)
-Gauleiter;Gespan
-Gespanschaft;Gau;Komitat (Ungarn)
-Großmährisches Reich;Reich des Sventopluk;Mährerreich;Altmähren;Großmähren
-Schmollmund;Schippe (ugs.)
-Unschädlichkeit;Harmlosigkeit;Unbedenklichkeit;Ungefährlichkeit
-Tadellosigkeit;Unschuld;Makellosigkeit;Schuldlosigkeit
-Gefährlichkeit;Bedenklichkeit
-ante portas (geh., lat., scherzhaft);zu erwartend;kommend;im Anmarsch;heraufziehend;im Kommen
-Volta'sche Säule;Voltasäule;Voltasche Säule
-galvanische Kette;galvanisches Element;Redoxkette (biologisch);galvanische Zelle
-im allerletzten Moment;kurz vor Toresschluss (fig.);unmittelbar vor Fristablauf;auf den letzten Peng (ugs.);in letzter Sekunde (ugs.);um Haaresbreite fast noch verpasst (ugs.);mit hängender Zunge (ugs., fig.);in letzter Minute (ugs.);auf den letzten Pfiff (ugs.);so grade eben noch (ugs.);als es beinahe schon zu spät war (... doch noch) (ugs.);(gerade) noch rechtzeitig;soeben noch;eigentlich schon verpasst (haben), aber (ugs.);um Haaresbreite doch noch geschafft (ugs.);so grade noch die Kurve gekriegt (ugs., fig.);kurz vor knapp (ugs.)
-erwachend;aufwachend;auflebend
-brennend;lodernd;in Flammen stehend;flammend
-wegklappen (ugs.);einpennen (ugs.);in einen (...) Schlaf fallen;wegdösen (ugs.);eindösen (ugs.);einschlafen;einnicken
-personalisieren;individualisieren
-Gekicke (ugs.);Fußballspiel
-Funkzugangsnetz (fachspr.);Handynetz;Mobilfunknetz
-Annehmlichkeit;Lombardfähigkeit;Annehmbarkeit
-Liegeplatz;Liegeposition
-Buckel;Anhöhe;Bühl (ugs., süddt.);Bodenerhebung;Höcker;Bühel (süddt.);Höhe (mil., mit Nummer);Erhebung;(kleiner) Berg;Hügel;Erhöhung;Hubbel (ugs., regional)
-(jemanden) überkommen (fig.);(jemanden) übermannen (fig.);(sich) jemandes bemächtigen (geh., veraltend);(etwas) überrieselt jemanden (ugs., fig.);(jemanden) packen (ugs., fig.);(jemanden) ergreifen (fig.);ergriffen werden (von) (fig., Hauptform);(jemanden) heimsuchen (fig.)
-durchweicht;aufgeweicht
-umfließen;umspülen
-bedeckend;überlagernd;überdeckend;verdeckend
-vorspielen;vortäuschen;vorgeben
-(sich) verteilend;ausbreitend
-erhöht;erhoben
-Wetterwand;Wetterfront
-verwehen;wegwehen
-Kontraktion des Herzens;Herzschlag;Puls (fachspr.)
-(jemandem) entgegenschlagen;(jemandem) entgegenpeitschen
-verwühlen;durchwühlen;zerwühlen
-unwetterartig;gewittrig
-(sich) freistrampeln;(sich) freitreten
-Halbschlaf;Schlummerzustand;Dämmerzustand
-schmalschultrig;schmal gebaut
-weitstehend;weit auseinander stehend
-erschlagen (ugs.);völlig fertig (ugs.);abgeschafft (ugs.)
-totgeschlagen;erschlagen
-Belästigung;Sekkatur (ugs., österr.);Sekkiererei (ugs., österr.)
-Buddelkasten;Sandkiste;Sandkasten
-Skalp;Kopfschwarte
-schroten (bei Körnern);zerreiben;vermahlen;mahlen
-Produktivbetrieb;Wirkbetrieb;Produktiveinsatz (IT-Technik)
-Zugangsberechtigungssysteme;Conditional access system (engl.);Verschlüsselungsstandards;Verschlüsselungssysteme
-entschwindend;verschwindend
-Masaryk-Ring;Automotodrom Brno
-Feuerwerksanstalt (ugs.);Wöllersdorfer Werke
-Rahmen;Fahrgestell;Chassis
-mehrspurig;mehrgleisig
-Flaniermeile;Spaziermeile;Prachtpromenade;Promenade (franz.)
-kratzend;schabend
-Straffreiheit (für Aussagen im Parlament);Redefreiheit (im Parlament);Indemnität
-kalkulierbar;berechenbar
-ausgründen;ausgliedern;verselbständigen
-(sich etwas) bewusst halten;(sich etwas) vergegenwärtigen;ad oculos demonstrare (geh., lat.);bewusstmachen;(jemandem/sich) bewusst machen;(jemandem/sich etwas) vor Augen führen;(jemandem/sich) klarmachen (ugs., Hauptform);(jemandem/sich) vor Augen halten
-Siegerpodium;Siegerpodest;Siegertreppchen (ugs.)
-Konsumtempel (fig.);Shoppingcenter;Shopping Mall;Einkaufszentrum;Shoppingmall;Einkaufscenter;Mall;Shopping Center
-Vereinigte Provinzen von Zentralamerika;Zentralamerikanische Konföderation;Bundesrepublik von Zentralamerika
-Orientkrieg;Krimkrieg
-Politur;Schutzanstrich;Überzug;Firnis;Anstrich
-Fließpapier;Löschpapier;Fließblatt;Löschblatt
-Fliehkraft;Zentrifugalkraft
-Hochzeitsreise;Honigmond (veraltet);Flitterwochen
-Parteiarbeiter;Sachwalter;Delegierter;Interessenvertreter;Repräsentant;Funktionär;Beauftragter
-Archäologie;Altertumskunde;Altertumswissenschaft
-Altertumsforscher;Archäologe;Altertumswissenschaftler
-Handschrift;Kodex;Handschriftensammlung
-Kodex;Gesetzbuch;Gesetzessammlung
-Hautschwiele;Schwiele;Hornschwiele;Hornhaut
-freiäugig;freisichtig;mit bloßem Auge;mit freiem Auge
-Weißer Main;Weißmain
-Rohling;Leer-CD;Leer-DVD
-Rinnsal;Wässerchen;Bächlein
-TVöD;Tarifvertrag für den öffentlichen Dienst
-Outlaw (engl.);Ausgestoßener;Geächteter;Gesetzloser;Verfemter;außerhalb der Rechtsordnung Stehender
-Plattenspieler;Turntable (Jargon, engl.);Phonogerät;Schallplattenspieler
-Prof (ugs.);Professor;Prof. (Abkürzung)
-Profiler;Fallanalytiker;Profilersteller
-kleiner Span;Spandel (ugs.);Spahl;Spänchen
-Homöostasis;Selbstregulation;Homeostase;Homoiostase;Homöostase;Homöodynamik
-Grammophon;Grammofon
-neuerlangt;wiedererlangt
-Leiter der Abteilung;Abteilungsleiter
-Marketing (engl.);Absatzwirtschaft (veraltet)
-die Stirn in Falten legend;stirnrunzelnd
-Rundumversorgung;lückenlose Versorgung
-zugewandt;zugedreht;zu etwas gewandt
-dadrin (ugs.);darin
-die Termine neu vergeben;(etwas) neu terminieren;umdisponieren;(etwas) neu planen;umplanen;anders planen (ugs.)
-Wechseltierchen;Amöbe
-Chlorophyll;Pflanzenfarbstoff;Blattgrün
-falsch rechnen;(sich) verrechnen
-Referenztitel;Vorzeigetitel;Hammertitel (ugs.)
-Einlage;Fußeinlage;Schuheinlage
-Einsatz;Einlagekapital;Einlage;Kapitalanlage
-(Befehle/Regeln) missachten;nicht gehorchen;(jemandem) auf der Nase herumtanzen (ugs., fig.);ungehorsam sein;(sich) nichts sagen lassen (ugs.);nicht parieren;nicht hören (auf)
-Schilddrüsenhormonmangel;Schilddrüsenhormonunterproduktion;Schilddrüsenunterfunktion
-Thyreoiditis (fachspr.);Thyroiditis (fachspr.);Schilddrüsenentzündung
-Graves' Disease;Basedowsche Krankheit;Immunhyperthyreose (fachspr.);Basedow-Krankheit;Immunthyreopathie (fachspr.);Autoimmunthyreopathie (fachspr.);Morbus Basedow
-Hyperparathyreoidismus (fachspr.);Parathormonüberproduktion;Nebenschilddrüsenüberfunktion;Parathormonüberschuss
-Parathormonunterproduktion;Nebenschilddrüsenunterfunktion;Hypoparathyreoidismus (fachspr.);Parathormonmangel
-Glandula adrenalis (fachspr.);Glandula suprarenalis (fachspr.);Nebenniere
-inflationistisch;überbordend;inflatorisch;inflationär;(sich) unmäßig ausbreitend;(sich) unmäßig ausweitend;in übermäßiger Weise auftretend
-Cortex glandulae suprarenalis (fachspr.);Nebennierenrinde;Cortex glandulae adrenalis (fachspr.)
-Weiberheld (ugs.);Frauenheld;Witwentröster;Schwerenöter;jedem Weiberrock hinterherlaufen;Schlawiner;Schürzenjäger (Hauptform);Ladykiller (engl., scherzhaft);einer, der nichts anbrennen lässt (ugs.);Mann für alle Gelegenheiten (ugs., ironisch);Süßholzraspler (ugs.);Gigolo (franz.);Herzensbrecher;Hallodri;Suitier (veraltet);Womanizer (engl.);Aufreißer (ugs.);Playboy (engl.);Frauenjäger;Wüstling
-Medulla glandulae suprarenalis (fachspr.);Nebennierenmark;Medulla glandulae adrenalis (fachspr.)
-Glukokortikoidüberproduktion;Morbus Cushing (fachspr.);Cushing-Syndrom (fachspr.);Glukokortikoidüberschuss
-Nebennierenrindeninsuffizienz;Morbus Addison (fachspr.);Hypokortisolismus (fachspr.);Nebennierenrindenunterfunktion;Glukokortikoidmangel;Hypokortizismus (fachspr.)
-Mineralokortikoidüberproduktion;Aldosteronüberproduktion;Mineralokortikoidüberschuss;Hyperaldosteronismus (fachspr.);Aldosteronüberschuss;Conn-Syndrom (fachspr.);Morbus Conn (fachspr.)
-Mineralokortikoidmangel;Hypoaldosteronismus (fachspr.);Mineralokortikoidunterproduktion;Aldosteronmangel
-Androgen;männliches Sexualhormon
-Katecholaminüberschuss;Phäochromozytom (fachspr.)
-Hypophysenvorderlappen;Adenohypophyse (fachspr.)
-Thyroidea (fachspr.);Thyreoidea (fachspr.);Schilddrüse;Glandula thyroidea (fachspr.);Glandula thyreoidea (fachspr.)
-Neurohypophyse (fachspr.);Hirnanhangsdrüsenhinterlappen;Hypophysenhinterlappen
-Hyperprolaktinämie (fachspr.);Prolaktinüberschuss
-Diabetes insipidus (fachspr.);ADH-Mangel
-Syndrom der inappropriaten ADH-Bildung;ADH-Überschuss;Schwartz-Bartter-Syndrom (fachspr.);ADH-Überproduktion;SIADH;Syndrom der inadäquaten ADH-Produktion
-febril (fachspr.);fiebrig;fieberig
-Hirnanhangsdrüsenunterfunktion;Hypophyseninsuffizienz (fachspr.);Simmondsche Krankheit (fachspr.);Hypophysenunterfunktion;Hypopituitarismus (fachspr.);Panhypopituitarismus (fachspr.)
-Erdheim-Tumor;Kraniopharyngeom (fachspr.)
-Hypercholesterinämie (fachspr.);Hypercholesterolämie (fachspr.);Cholesterinüberschuss
-Fettleber;Leberverfettung;Hepar adiposum (fachspr.);Steatosis hepatis (fachspr.)
-Herzmuskelschwäche;Insufficientia cordis (fachspr.);Myokardinsuffizienz (fachspr.);Herzschwäche;Herzinsuffizienz
-degenerative Koronarerkrankung;stenosierende Koronarsklerose (fachspr.);koronare Herzerkrankung;ischämische Herzerkrankung;koronare Herzkrankheit
-prämenstruelle Dysphorie;prämenstruelles Syndrom;prämenstruelle Beschwerden
-Unzurechnungsfähiger;Kretin;Psychopath;Verrückter;Schwachsinniger;Geisteskranker;Irrsinniger;Wahnsinniger;Debiler
-Kardia (fachspr.);Blutpumpe (ugs.);Pumpe (ugs.);Herz
-Nervosität;Herzklopfen;Zähneklappern (ugs.);Auftrittsangst;Lampenfieber;Bangigkeit;Nervenflattern (ugs.);Beunruhigung
-Hades (griechisch, mythologisch);Inferno (lat.);Hölle;Schattenreich;Orkus (mythologisch, römisch);Totenreich;Unterwelt;Reich der Toten;Jenseits
-Unbestand;Sterblichkeit;Vergänglichkeit;Hinfälligkeit;Kurzlebigkeit;Endlichkeit;Wandelbarkeit;(der) Weg allen Fleisches (geh.)
-Hirte;Hütejunge;Hüter;Schäfer
-Haselmaus;Siebenschläfer
-einschnürend;beengend;verengend;einengend
-Striktur (fachspr.);krankhafte Verengung
-Fürstentum Nitra;Nitraland;Fürstentum Neutra;Nitraer Fürstentum;Neutraer Fürstentum
-Tribetzgebirge;Tribetz
-Ardenner Wald;Ardennen
-Tippelei;Wanderschaft;Wanderjahre (Plural);Gesellenwanderung;Walz
-Epizentrum;Erdbebenzentrum
-Wettbewerbshüter;Kartellrechtler
-Lichtzieher (veraltet);Kerzenmacher;Wachszieher
-Törn;Segeltour;Segeltörn;Segelausflug
-maschinell lesbar;rechnerlesbar;computerlesbar;maschinenlesbar
-Stichprobenumfang;Stichprobengröße
-schanzen (mittelhochdeutsch);Glücksspiel treiben
-(jemandem etwas) zuschustern (ugs.);(jemandem) zuspielen;(jemandem etwas) zuschieben;(jemandem etwas) zuschanzen (ugs.);(jemandem) verschaffen (ugs.);(jemandem zu etwas) verhelfen
-unter Handlungszwang stehen;unter Zugzwang stehen;unter Druck stehen
-Gerichtsassessor;Richter auf Probe;Probe-Richter
-Karpaltunnelsyndrom;Brachialgia paraesthetica nocturna (fachspr., lat.);Medianuskompressionssyndrom;KTS (Abkürzung);Carpaltunnelsyndrom;CTS (Abkürzung)
-Germersheimer Linie;Speyerer Linie;Mainlinie
-Sintern;Sinterung
-Six Days;Internationale Sechstagefahrt
-Thixoforming;Semi-Solid Metal Casting (engl.);Thixoverfahren
-Hohlkörperblasen;Extrusionsblasformen
-umstellen;umändern;umrüsten;umwandeln;umschwenken (ugs.);umfunktionieren
-prototypisch;den Prototyp betreffend
-Strahlen aussenden;emittieren;ausstrahlen;abstrahlen
-Hebamme (ugs.);Pampelmuse (ugs., norddeutsch);Klostampfer (ugs.);Saug-Hektor (ugs., österr.);Plömper (ugs.);Stampfer (ugs.);Saugglocke;Steßl (ugs., österr.);Pömpel (ugs., norddeutsch);Pümpel (ugs.);Plümper (ugs., norddeutsch);Gummiglocke;Pumpfix
-Rohrfrei (ugs.);Abflussreiniger;Rohrreiniger
-Schattenbild;Silhouette;Scherenschnitt;Schattenriss
-Berufssportler;Leistungssportler;Profisportler;Spitzensportler
-Tabellenführer;Spitzenreiter;Führender;Tabellenerster
-Elfer (ugs.);Porsche 911;Neunelfer
-(sich) in die Kurve legen;kurvenräubern
-kammsche Kreis;kammsche Reibkreis
-(etwas) mit einer Kontur ausstatten;konturieren
-Franz Carl Spitzweg;Karl Spitzweg
-pilotieren;(Fahrzeug/Flugzeug) steuern;(Fahrzeug/Flugzeug) lenken
-Einzelkämpfer (fig.);einsamer Wolf (ugs., fig.);Eigenbrötler;Einzelgänger;Aussteiger (fig.);Außenseiter;Individualist;Underdog;Nerd (Jargon);Nonkonformist
-Schwarzkopie;Raubkopie
-Lauterkeit;Authentizität (geh.);Aufrichtigkeit;Seriosität;Natürlichkeit;Ehrlichkeit;Ernsthaftigkeit;Glaubwürdigkeit;Vertrauenswürdigkeit;Redlichkeit (geh.)
-Jalon;Fluchtstange;Mire;Fluchtstab
-Prüfmittel;Überwachungs- und Messmittel
-Lotrechte;Vertikale;Lotrichtung
-mathematischer Horizont;Horizontale;Waagerechte;Waagrechte
-Horizontebene;Horizontalebene
-Dichtespindel;Senkspindel;Senkwaage;Hydrometer;Aräometer
-Erdgestalt;Erdfigur
-Erde (ugs.);Schutzleiter;Schutzleitung;Schutzerde (ugs.);Erdung (ugs.)
-Nullleiter;PEN-Leiter
-unterbewertet;verkannt;unterschätzt
-mitentscheiden;mitentscheidend (sein);mitbestimmen;ein Wörtchen mitzureden haben (ugs., fig.);ein Wörtchen mitreden (ugs., fig.)
-still werden;aufhören zu reden;in Schweigen verfallen;nichts weiter sagen;nicht mehr sprechen;verstummen (Hauptform);ruhig werden;nichts mehr sagen
-Leiden;Leyden (veraltet);Lugdunum Batavorum (lat.)
-Republik der Sieben Vereinigten Niederlande;Vereinigte Provinzen
-Examen;Abtestat;Abschlussexamen;Abschlussprüfung
-Wiegeeisen;Granierstahl;Scraper
-Schwarzkunst;Mezzotinto;Schabkunst
-unbeeinflussbar;unsteuerbar;unbeherrschbar;unkontrollierbar;unlenkbar
-Öffnungsblende;Aperturblende
-Freakshow (fachspr., engl.);Schreckenskabinett;Gruselkabinett
-Öffnungsweite;Apertur
-vornehmlich;besonders;insbesondere;vor allem
-Franchise;Franchising;Konzessionsverkauf
-Distribution Policy (engl.);Distributions-Mix;Place (im Marketing-Mix);Distributionspolitik
-Fremdenverkehrsstraße;Themenstraße;Erlebnisstraße (österr.);Touristikstraße;Ferienstraße;Touristenstraße
-Spintronik;Spinelektronik;Fluxtronik
-Adelsherrscher;Blaublüter;Aristo (ugs.);Aristokrat
-Aushängeschild (fig.);Visitenkarte (fig.);Vorzeigemodell;Vorzeigeprodukt;Flaggschiff (fig.);Leuchtturm (fig.)
-ideale Gasgleichung;Gasgesetz;universelle Gasgleichung;allgemeine Gasgleichung;thermische Zustandsgleichung idealer Gase
-Stanniol;Zinnfolie
-brach (veraltet);verödet;unkultiviert;nicht bewirtschaftet;unbewirtschaftet;nicht kultiviert
-NetBIOS-Protokoll;LAN-Manager-Protokoll;Server Message Block (engl.)
-zusammentreiben;zusammenpferchen;konstipieren;zusammendrängen;zusammenstopfen
-vertun;durch Stolpern verpassen;verstolpern
-fehlerbehaftet;fehleranfällig;fehlerträchtig
-alternd;veraltend
-von einer Liebesbeziehung handelnd;eine Liebschaft betreffend;Liebes...;amourös
-konstruierte Sprache;künstliche Sprache;Kunstsprache (fachspr., Hauptform)
-vollständiger Verlust;Totalschaden;Totalverlust
-Kartoffelschäler;Sparschäler
-Vernunft;Gesetzmäßigkeit;Logik;Konsequenz
-Stöckel (ugs.);Absatz;Hacke(n) (ugs.);Schuhabsatz
-Kanonenbootpolitik;Säbelrasseln (fig.);Kanonenbootdiplomatie
-Untertanengebiet;Untertanenland
-Stein;Samenkern;Kern;Obstkern
-Possenspiel (veraltend);Clownerie;Clownerei;Harlekinade;Possen;Possenreißerei;Possenreißen;Hanswurstiade (veraltend)
-Felsgestein;Stein;Gestein;Felstrümmer
-Sedimentit (fachspr.);Sedimentgestein
-Realisierer;Verwirklicher;Umsetzer
-geckenhaft;stutzerhaft;dandyhaft
-Sanitöter (ugs., scherzhaft);Krankenwärter;Krankenpfleger;Sani (ugs.);Sanitäter
-Semantik (fachspr.);Bedeutungslehre
-Bewusstseinsspaltung;Schizophrenie;Spaltungsirresein
-Morbus Hansen;Lepra;Miselsucht;Hansen-Krankheit;Aussatz;Lazarus-Krankheit
-Abdominaltyphus;typhoides Fieber;Unterleibstyphus;Nervenfieber (veraltet);Typhus;enterisches Fieber;Bauchtyphus
-Expat (Kurzform);Expatriate
-Ortsgemeinde (schweiz.);Einwohnergemeinde (schweiz.);politische Gemeinde (schweiz.)
-in den Schoß fallen (fig.);anheimfallen;zufallen;zukommen;zuteil werden;zufließen
-(etwas) zum Opfer fallen;anheimfallen
-Autoschlosser;Karosseriebaumechaniker;Karosseur (österr.);Karosseriebauer;Spengler (bayr., österr.);Kfz-Schlosser;Karosseriespengler (bayr., österr.)
-Flaschnerei (veraltet);Klempnerei;Spenglerei (bayr., österr.)
-buttern;mit Butter bestreichen
-lokalisiertes Oberflächenplasmon;Partikelplasmon
-mit Möbeln ausgestattet;eingerichtet;möbliert
-Lacher;Kracher;Schenkelklopfer (ugs.);Brüller;Knaller (ugs.)
-Internationale Energieagentur;IEA (Abkürzung)
-Päderast;Knabenschänder
-Evaneszenz;evaneszente Wellen
-Elektroimpulswaffe;Elektroschocker;Elektroimpulsgerät
-Taser (ugs., engl., Hauptform);Distanz-Elektroimpulswaffe;Elektroschockpistole;Distanzelektroimpulsgerät (fachspr.)
-autoritativ;autorisierend;ermächtigend
-konformationell;konformativ
-Nahverlagerung;Nearshoring (engl.)
-Offshoring (engl.);Auslandsverlagerung
-Orientdreibund;Mittelmeerabkommen;Mittelmeerentente
-Museologie;Museumswissenschaft
-(sich) rauswinden;(sich) rausreden
-technische Dokumentation;Produktdokumentation;Technikdokumentation
-rätselhaft;grotesk;bedrohlich;kafkaesk;beängstigend
-ehrpusselig;ehrpusslig;kleinlich auf seinen (guten) Ruf bedacht;nach dem Motto 'was sollen (bloß) die Leute denken'
-Bergkamm;Gebirgskamm;Krete (schweiz.)
-Radmotorschiff;Raddampfer;RMS
-Peutingersche Tafel;Tabula Peutingeriana
-Aggregator;RSS-Reader;Feedreader (engl.)
-Verlegekabel;Trunkkabel
-Cineast;Filmkenner;Kino-Enthusiast;Filmbegeisterter;Filmliebhaber;Filmfan;Kinofan;Filmfreak;Kinogänger;(regelmäßiger) Kinobesucher
-Krida (österr.);Konkursvergehen
-Bilharziose;Schistosomiasis
-Pazifischer Krieg;Salpeterkrieg
-Elisabeth von Thüringen;Elisabeth von Ungarn
-klitschnass sein;tropfnass sein;durchnässt sein;vor Nässe triefen;triefen;durch und durch nass sein
-Kolchos (russisch);Kollektivwirtschaft;Kolchose
-Sowchos (russisch);Sowjetwirtschaft;Sowchose
-VEG;Volkseigenes Gut
-Schmackhaftigkeit;Köstlichkeit;Ergötzlichkeit
-Wolynien;Lodomerien (veraltet);Wolhynien
-Rothreußen (veraltet);Russia rubra (lat.);Rotruthenien;Rotrussland
-Van (engl., Hauptform);Großraumlimousine;Familienkutsche (ugs.)
-Quantifizieren;Quantifizierung;Quantifikation;Bezifferung
-Abtastung;Diskretisierung
-Anklagebehörde (ugs.);Staatsanwaltschaft
-Vorgänger;Antezessor (veraltet)
-Comprexlader;Druckwellenlader
-gewerbliche Schutzrecht;Patentrecht
-Hecktür;Heckklappe
-Gesellenbrief;Facharbeiterbrief
-Bugatti Royale;Bugatti Typ 41
-Größe der Dimension Eins;dimensionslose Größe
-Einzelwahn;Monomanie
-Monomanie des Diebstahls;Stehlsucht;neurotisches Stehlen;Diebstahlsleidenschaft;Stehltrieb;Stehlen ohne Bereicherungstendenz;Kleptomanie (Hauptform);psychopathischer Stehltrieb;süchtiges Stehlen;zwanghaftes Stehlen;Diebstähle ohne wesentliche Bereicherungstendenz;triebhaftes Stehlen;pathologisches Stehlen
-psychische Erkrankung (veraltet);psychische Störung
-rußig werden;von Ruß verstopfen;verrußen;von Ruß bedecken
-verharmlosen;als nicht wichtig erachten;nicht sehr ernst nehmen;leichtnehmen;locker sehen (ugs.);unterschätzen;auf die leichte Schulter nehmen (ugs.)
-Kaufkrafttheorie der Löhne;Kaufkrafttheorie
-Rolls-Royce Olympus;Wright J67 (USA);Bristol Olympus;Bristol-Siddeley Olympus
-Arbeitsvertrag;Beschäftigungsvertrag;Anstellungsvertrag
-Antriebsfeder;Triebfeder
-B-Plan;verbindlicher Bauleitplan;Bebauungsplan
-tüftelig;mühselig;friemelig (ugs.);frickelig (ugs.);fummelig;pfriemelig (ugs.)
-ablegen;aufs Meer hinausfahren;in See stechen;auf große Fahrt gehen
-ausziehen;(die) Wohnung aufgeben;(die) Wohnung räumen;(eine) Wohnung freiziehen (fachspr., Jargon)
-einziehen;(Wohnung) beziehen
-Kerning (engl.);Unterschneidung
-Verschmelzung von Buchstaben;Buchstabenverbund;Ligatur (fachspr.);Buchstabenverschmelzung
-Versalbuchstaben (Plural);Großbuchstaben (Plural);Kapitalbuchstabe;Großbuchstabe;Versal;Majuskeln (Plural);Majuskel (fachspr.);Versalbuchstabe;Versalien (Plural)
-Werbefilmchen (ugs., abwertend);Spot;Werbefilm;Werbespot
-Werbesendung;Reklamesendung
-(sich) rumärgern;(sich) rumplagen
-Notdurft;Pinkeldrang (ugs.);Pinkelzwang (ugs.);Pinkelbedürfnis (ugs.)
-Zimmerklosett;Nachtstuhl;Leibstuhl
-Britisch-Honduras (veraltet);Belize
-Schmalkaldische Liga;Schmalkaldischer Bund;Liga von Schmalkalden
-Preußenschlag;Preußenputsch
-Maracaibo;Neu-Nürnberg (veraltet)
-Mario Girotti (bürgerlich);Terence Hill
-Carlo Pedersoli (bürgerlich);Bud Spencer
-Daleminzier;Daleminzen
-Vertrag von Eger;Hauptvergleich von Eger
-Wenden (veraltet);Venedi (lat.);Slawen
-Abotriten;Bodrizen;Obodriten;Abodriten;Obotriten
-Rundlingsdorf;Runddorf;Rundplatzdorf;Rundling
-Bitte;Rogation (veraltet);Litanei (veraltet);Fürbitte
-Fürbitten (ugs.);allgemeines Kirchengebet;Fürbittengebet
-Ahnenschwund;Implex (fachspr.);Ahnenverlust
-Homozygotie (fachspr.);Reinerbigkeit
-Hi-Fi-Freak (ugs.);Audiophiler
-Fummelei;Gefummel (ugs.)
-Fummelkram (ugs.);Gefrickel (ugs.);Gefummel (ugs.);Frickelei;Frickelkram (ugs.)
-selbstfertil;selbstbefruchtend
-unsre;unsere;unsrige
-Feuerunterstützung;Feuerschutz
-Annäherungsversuch;Hoffnungen wecken;Entgegenkommen;Avancen machen
-Rumänisch;Dakorumänisch;Moldawisch (in Moldawien);Moldauisch (in Moldawien)
-Muntenien;Muntenia (rumänisch);Große Walachei
-Vlachomeglenisch;Meglenorumänisch;Meglenisch;Meglenitisch
-Meglenorumänen;Meglenische Walachen
-Valachos;Wallachians;Wlachen;Wlachi;Ulah;Wallachen;Vlachos;Valx;Blahoi;Walachen;Vlasi;Vlachen;Olah
-Regatul Vechi (rumänisch);Regat (rumänisch);Altreich
-Transnistrische Moldauische Republik;Dnjestr-Republik;Transnistrien
-Regatsdeutsche;Altreich-Deutsche
-Hannah Rabinsohn;Ana Pauker
-Bevölkerungsgruppe;Volksgruppe
-Aromunen;Mazedoromanen;Mazedorumänen
-Serbokroatisch;Serbisch oder Kroatisch;Kroatoserbisch;Kroatisch oder Serbisch
-Mavrowlachen;Maurowlachen;Morlaken;Maurowalachen;Morlacchi (ital.)
-umhüllt;umschlossen
-Münzkunde;Numismatik
-ausatmen;exhalieren (fachspr.);aushauchen;exspirieren (fachspr.)
-Stöhner;(ein) Aufseufzen;Seufzer;Ächzer
-Fudschaira;Fujairah (engl.)
-GCC (Abkürzung, engl.);Golf-Kooperationsrat;Kooperationsrat der Arabischen Staaten des Golfes
-Geltungsbereich;Herrschaftsraum;Herrschaftsbereich;Hoheitsgebiet
-Zuständigkeitsbereich;Kompetenzbereich
-Einsiedlergrotte;Eremo;Einsiedlerklause;Eremitage (franz., griechisch);Grotte;Eremitei (griechisch);Klause;Einsiedelei;Ermitage;Mönchsklause
-(sich) gut entwickeln;heranreifen;(sich) machen (ugs.);(sich) verbessern;(sich) mausern (zu) (ugs., fig.);(sich) gut machen (ugs.)
-ohne Beschwerden;klaglos;ohne sich zu beschweren;ohne Klage;ohne Murren
-Arbeitskräfte-Leasing;Personalvermittlung;Arbeitskraftüberlassung;Leiharbeit;Mitarbeiterleasing;Mitarbeiterüberlassung;Arbeitskräfteüberlassung;Arbeitnehmerüberlassung;Personalüberlassung;Personaldienstleistung;Zeitarbeit;Mitarbeiter-Leasing;Personalleasing;Temporärarbeit;Arbeitnehmer-Leasing
-Zeitarbeitsunternehmer;Personaldienstleister;Verleiher;Personalvermittlungsagentur;Sklavenhändler (derb);Leiharbeitgeber;Personalvermittler;Zeitarbeitgeber;Leiharbeitsunternehmer
-Schlüsselkraft;qualifizierte Fachkraft
-Datendeduplizierung;Deduplikation;Deduplizierung;Datendeduplikation;Data-Deduplication (engl.)
-Datenwiederherstellung;Data Recovery (engl.);Datenrettung
-USB 3.0;SuperSpeed USB
-Aussterben;Extinktion (fachspr.)
-Blogger (engl.);Weblog-Verfasser
-Transienz;Instationarität
-HU (Abkürzung);Hauptuntersuchung;TÜV (ugs., Abkürzung)
-Abgasuntersuchung;AU
-roboterassistierte Chirurgie;Roboterchirurgie
-Diakonatsweihe;Ordination;Bischofsweihe;Priesterweihe
-Lohe;Flamme
-Feuerwalze;auf breiter Front (schnell) voranschreitender Brand
-Stabhandgranate;Stielhandgranate
-Epinephrin;Adrenalin;Suprarenin
-Sportsgeist;sportliches Verhalten;Sportlichkeit;Sportgeist;Fairness
-Trutzburg;Trotzburg
-Regalien;Königsrechte;königliche Rechte
-phrygische Mütze;skythische Mütze
-Straßburger Münster;Cathédrale Notre-Dame (franz.);Liebfrauenmünster (Straßburg)
-Splittergranate;Schrapnellgranate
-Blitzgranate;Blendgranate;Schockgranate
-Schrotladung der Artillerie;Kartätsche
-Nebelbombe;Nebelwurfkörper;Nebelkerze;Nebelgranate;Nebeltopf;Rauchgranate
-Granatmaschinengewehr;automatischer Granatwerfer
-Wurfgeschoss;Handgranate
-Metaller (ugs.);Metallarbeiter
-Personalchef;Personalverantwortlicher
-Soziopath;Skrupelloser
-Einsatzleiter;Dispatcher (engl.);Einsatzkoordinator;Koordinator
-Dialektik (Hauptform);Kunst der Unterredung;Ars dialectica (lat.);Kunst der Gesprächsführung
-Eristik;Lehre vom Streitgespräch
-Gastgewerbe (ugs., schweiz., österr.);Gaststättengewerbe;Gastronomie
-Kaufmann im Gesundheitswesen;Arztsekretär (veraltet)
-Kauffrau im Gesundheitswesen;Arztsekretärin (veraltet)
-Freigrafschaft Burgund;Hochburgund
-Tipper (derb);Bürokraft;Vorzimmerherr;Schreibkraft;Sekretär
-Latino (männl.);Lateinamerikaner (männl.)
-Latina (weibl.);Lateinamerikanerin (weibl.)
-Typometer;Typomaß
-Mikrotypografie;Detailtypografie
-Typographie;Typografie
-Schweiger;kein Mann der großen Worte (ugs.)
-Schlepper (ugs.);Marktschreier
-runternudeln (ugs.);wiedergeben;abspielen;duddeln (ugs.)
-Praeludium;Prélude (franz.);Präludium;Preludio (ital.)
-Crowdsourcing (engl.);Schwarmauslagerung
-Ämterpatronage;Postenschacherei;Filzokratie (ugs.)
-Japaner;Japse (ugs., abwertend)
-Schlückchen;Nippchen
-Krieg von 1812;Mr.-Madisons-Krieg;Britisch-Amerikanischer Krieg;zweiter Unabhängigkeitskrieg
-British Empire (engl.);Britisches Weltreich;Britisches Imperium
-Pax Augusta;Augusteischer Frieden
-vernascht;leckermäulig (ugs.);schleckig (ugs.);genäschig;naschhaft
-Computerprofi;Computerfreak;IT-Spezialist;Computerfachmann;Computerass (ugs.);IT-Experte;IT-Profi;IT-Fachmann;IT-Fredel (ugs.);IT-Fachkraft;Computerexperte;Computerspezialist
-Bildausstellung;Bildergalerie;Fotogalerie;Fotoschau;Bilderstrecke (Jargon);Bilderausstellung;Bilderschau;Fotoausstellung;Bildgalerie;Bildschau;Bildstrecke;Fotostrecke
-Hundertjahrfeier;Zentenarium
-Satrap (persisch);Landesherr;Statthalter;Vogt;Schutzherr
-Wakenitz;Barsch-Fluss
-Wagrien;Wagerland;Waierland
-Optimisten-Jolle;Opti (ugs.)
-Freibad an der Falkenwiese;Naturbad Falkenwiese
-Nordischer Siebenjähriger Krieg;Dreikronenkrieg
-Kommentur;Kommendator;Commenthur;Komtur
-Heimlichtuerei (ugs.);Versteckspiel (ugs., fig.);Heimlichkeiten;Geheimniskrämerei (ugs.);Verschwiegenheit;Geheimnistuerei (ugs.)
-im stillen Kämmerlein (ugs., fig.);für sich allein;heimlich
-Metro-Goldwyn-Mayer;MGM (Abkürzung, Markenname)
-BMW AG (Abkürzung);BMW (Abkürzung, Markenname);Bayerische Motoren Werke AG
-Volkswagen;Volkswagen AG;VW AG;VW
-Kontinentalverschiebung;Kontinentaldrift;Epirogenese (fachspr., griechisch)
-Bastardwechsel;Kellerwechsel
-Machination (geh., lat.);Kabale;Intrige;hinterhältiger Anschlag
-Vorfrieden von San Stefano;Frieden von San Stefano
-Marmormeer;Marmarameer;Propontis (altertümlich, griechisch)
-Telekomer (ugs.);Telekomiker (ugs., abwertend);Telekom-Mitarbeiter
-Posener Aufstand;Großpolnischer Aufstand
-Politikum;politische Angelegenheit
-Zukunftsfähigkeit;Aufrechterhaltbarkeit;Enkeltauglichkeit (ugs.);Nachhaltigkeit
-Bohrhubinsel;Hebebohrinsel;Hubbohrinsel
-Bohrinsel;Bohrplattform
-Röstkartoffeln;geröstete Erdäpfel (österr.);Bratkartoffeln;Schmorkartoffeln
-Dobrudscha;Dobrogea (rumänisch);Transdanubien
-Plattensee-Fürstentum;Transdanubisches Fürstentum;Pannonisches Fürstentum;Fürstentum Moosburg
-Landler;Siebenbürger Landler
-Hanefiten;Hanafiten
-autokephal;mit eigenem Oberhaupt;eigenständig
-Freibeutertum;Piratentum;Kaperwesen;Seeräubertum;Piraterie;Seeräuberei;Freibeuterei;Korsarentum
-Fürstliche Gnaden;Durchlaucht;Hochwohlgeboren;Erlaucht;Hoheit;Majestät
-Sichfügen;Selbstaufgabe;Resignation
-Skartierung (österr.);Vernichtung von Unterlagen;Kassation
-Narzisst;Narziss
-in beide Richtungen;bidirektional;in zwei Richtungen
-Domestikation (lat.);Züchten eines Wildtieres als Haustier;Domestifikation (lat.);Domestizierung (lat.);Haustierwerdung
-Personalie;Angabe des Personals;Personalangabe
-Ingenieurtruppe;Ingenieurkorps;Genietruppe (schweiz.);technische Truppe;Pioniertruppe (Hauptform)
-Ingenieurkorps;Geniekorps
-Audi AG;Waffenschmiede Ingolstadt (ugs.);Auto-Union (veraltet);Audi;Herr der Ringe (ugs.)
-Präfiguration;Vorausdeutung
-geringfügige Beschäftigung;Minijob;450-Euro-Job (ab 2013) (ugs.);400-Euro-Job (bis 2012) (ugs.);450-Euro-Basis (ugs.)
-Schleim aushusten;expektorieren (fachspr.)
-Fachsimpeln (ugs.);Fachsimpelei (ugs.)
-Bewegungsdrang;Bewegungsbedürfnis
-Wangenbein;Jochbein;Jugale;Backenknochen
-Inhaltsübersicht;Inhaltsverzeichnis (Hauptform)
-Sultanine;getrocknete Weinbeere;Rosine;Zibebe
-Rockmusiker;Rocker
-Okkultismus;Geisterglaube
-spiritistisch;okkult;okkultistisch;übersinnlich
-Purzelbaum;Kusselkopp (ugs.);Salto;Rolle;Überschlag;Flickflack
-Steinsarg;Sarkophag (geh., bildungssprachlich);Prunksarg
-Grenzgänger;Grenzwanderer
-Aostatal;Augsttal (veraltet)
-unterjährig;während des Jahres
-Fehlentscheidung;Justizirrtum;Fehlurteil;Rechtsirrtum
-Gallert;Gelatine;Gallerte;Gelee
-Überzug;Guss;Glasur
-Ist-Bestand (fachspr.);Istbestand (fachspr.);Inventar;Bestand;Lagerbestand;Bestandsverzeichnis
-Kampfverband;Truppenverband;Truppeneinheit
-Eingabekonsole;Konsole;Eingabeaufforderung;Terminal (engl.);Textkonsole;Kommandozeile;Befehlszeile
-Kraftstein;Kunststein;Krage;Stützbalken;Kragstein;Notstein;Mauervorsprung;Tragstein;Balkenstein;Konsole
-Kosmopolit;Weltreisender;Weltbürger
-Unterwelt;Verbrechertum;Gangstertum
-Handpflege;Maniküre;Nagelpflege
-Mull;Moll;Maulwurf
-Schwitzbude (ugs.);Sauna;Schwitzstube;finnisches Bad;Heißluftbad
-nodulär (fachspr.);knötchenförmig;knötchenartig
-Bergsteiger;Bergkraxler (ugs.);Kraxler (ugs.);Bergfex (ugs.);Alpinist
-Heftlasche;Aktendulli;Heftstreifen
-krankhaft verändern;affizieren
-Chiralität;Enantiomorphie
-Kristallographie;Kristallkunde;Kristallografie
-Redmonder (ugs.);Microsoft-Mitarbeiter;Microsoftler (ugs.)
-Schorre;Brandungsplattform
-Sankt Nikolaus in der Liptau;Liptau-Sankt-Nikolaus
-Herzogtum Ober- und Niederschlesien (offiziell);Österreichisch-Schlesien
-Heinrich I. von Polen;Heinrich I. (Polen);Heinrich I. von Schlesien;Heinrich der Bärtige
-Deutsches Wörterbuch;der Grimm;DWB;Grimmsches Wörterbuch
-archivierte Unterlagen;archiviertes Material;Archivgut (fachspr.);Archivalien (fachspr.);Archivmaterial;archivierte Dokumente;Archivunterlagen
-Abblendlicht;Fahrlicht (veraltet)
-Öresundtunnel;Drogdentunnel
-Frieden von Roskilde;Panikfrieden von Roskilde
-nordgermanische Sprachen;skandinavische Sprachen;nordische Sprachen
-Stecknitzfahrt (veraltet);Stecknitzkanal
-Nord-Ostsee-Kanal;Kaiser-Wilhelm-Kanal (bis 1948) (veraltet)
-Sektsteuer;Schaumweinsteuer
-Schlacht auf dem Peipussee;Schlacht auf dem Eise
-Wessen;Wesen;Wes
-Slowenen;Ilmenslawen
-Betrunkener;Besoffener (ugs.);stark Alkoholisierter
-tschechischer Gewürzkuchen;Pernik
-Knöchla (fränk.);Bötel;Eisbein;Haxe;Haxn (ugs.);Schweinshachse;Hechse;Hämmche (ugs., kölsch);Stelze (österr.);Schweinshaxe;Schweinshaxn (ugs., bayr.);Adlerhaxe (fränk.);Hachse;Haspel (hessisch);Gnagi (schweiz.);Wädli (schweiz.)
-Becken;Pelvis (fachspr.)
-Darmbein;Os ilium (fachspr., lat.)
-Sitzbein;Os ischii (fachspr., lat.)
-Schambein;Os pubis (fachspr., lat.)
-Schambeinkamm;Pecten ossis pubis (fachspr., lat.)
-Vorderösterreich;Vorlande (veraltet)
-Jesuitendeutsch;oberdeutsche Schreibsprache;oberdeutsche Literatursprache
-sächsische Kanzleisprache;Meißner Kanzleideutsch
-Neuenglisch;modernes Englisch
-Transleithanien (inoffiziell);Länder der Heiligen Ungarischen Stephanskrone;ungarische Reichshälfte (inoffiziell)
-Romani;Romanes
-Musculus obturator externus (fachspr.);äußerer Hüftlochmuskel;Musculus obturatorius externus (fachspr., veraltet)
-innerer Hüftlochmuskel;Musculus obturatorius internus (fachspr., veraltet);Musculus obturator internus (fachspr.)
-Illyrier;Illyrer
-Gemeinherrschaft;Kondominat (lat.);Kondominium (lat.);Gesamtherrschaft
-Befestigungsanlage;Schanzanlage;Oppidum (fachspr.)
-Standarddeutsch;Neuhochdeutsch (ling.) (fachspr.);Schriftdeutsch (schweiz.);Standardhochdeutsch;Hochdeutsch
-Herrschaft Stargard;terra Stargardiensis
-Livländischer Krieg;erster nordischer Krieg
-zweiter nordischer Krieg;kleiner nordischer Krieg;zweiter Polnisch-Schwedischer Krieg
-Vertrag von Oliva;Pax Oliviensis (fachspr.);Friede von Oliva
-Waffenstillstand von Eisenburg;Frieden von Eisenburg
-Habenhauser Friede;Friede von Habenhausen;Friede zu Habenhausen
-5. Österreichischer Türkenkrieg;Großer Türkenkrieg;Großer Türkenkrieg Leopolds I.
-Olmützer Vertrag;Olmützer Punktation
-Pariser Vertrag;Briand-Kellogg-Pakt;Kellogg-Pakt;Kellogg-Briand-Pakt
-erküren (veraltet);erkiesen (veraltet);auserküren (veraltet);auserkiesen (veraltet)
-englische Sprache;Englisch
-Kraftteilchen;Botenteilchen;Trägerteilchen;Wechselwirkungsteilchen;Austauschteilchen;Eichboson
-Mittelmacht;Mittelstaat
-bolometrisch;mithilfe des Bolometers
-Linsenfernrohr;Linsenteleskop;Refraktor
-Galileisches Fernrohr;Galilei-Fernrohr;Holländisches Fernrohr
-überdehnt;aufgebläht;hochgejazzt (ugs.);(künstlich) hochgepustet;aufgeblasen
-Lebenslehre;Biologie
-experimentierende Person;Experimentator
-Rhomboid;Parallelogramm
-Schwimmbadabsorber;Solarabsorber
-Stilfser Joch;Passo dello Stelvio (ital.);Stilfserjoch
-Georgische Heerstraße;Grusinische Heerstraße
-Währungsbehörde;Währungsamt
-Durchsicht;Durchschau;Ansicht
-Erforscher des Mittelalters;Mediävist
-Gelée Royale;Königinfuttersaft;Weiselfuttersaft
-Langzeitpflege;Altenpflege
-guten Glaubens;bona fide
-auf Kosten anderer leben;schmarotzen (derb);nassauern (ugs.)
-Prestigeprojekt;Vorzeigeprojekt;Leuchtturmprojekt
-Leukotomie;Lobotomie
-bestimmt sein (für);gemünzt sein (auf)
-(etwas) wieder einsatzfähig machen;(etwas) wieder in Gang bringen;(etwas) wieder zum Leben erwecken;(etwas) wieder aktivieren;(etwas) reaktivieren (Hauptform)
-Triebzug;Triebwagen;Triebwagenzug
-DELAG (historisch);Deutsche Luftschiffahrts-Aktiengesellschaft (historisch)
-Wissenschaftsoffizier;WissOffz (fachspr.);Truppenoffizier mit wissenschaftlicher Vorbildung
-Rheinische Automobilbau-Aktiengesellschaft;Rheinische Automobilbau AG;Rabag
-Deutschherrenorden;Deutscher Orden;Deutschritterorden;Deutscher Ritterorden;Ordo Teutonicus (lat.)
-Preußischer Bund;Bund vor Gewalt
-Staat des Deutschen Ordens;Ordensstaat;Deutschordensstaat;Deutschordensland
-Bad Mergentheim;Märchedol (ugs., regional)
-Lemberg;Klein-Wien (ugs., veraltet);Löwenberg (veraltet)
-Klosters (bis 1973) (veraltet);Klosters-Serneus
-Ni-Werk;Nibelungenwerk
-Sturmtiger (ugs.);Sturmmörser Tiger;Sturmpanzer VI
-Statutarstadt (österr.);kreisfreie Stadt;kreisunmittelbare Stadt (Bayern) (veraltet);Stadtkreis (Baden-Württemberg);Stadt mit eigenem Statut (österr.)
-Erstarkung;Erstarken
-technischer Charakter;Technizität
-Napfsülze;Tellersülze
-optische Zeichenerkennung;OCR;Optical Character Recognition (engl.);Texterkennung
-aufgleisen;(etwas) auf Gleise setzen
-effektivieren;effektiv machen
-Weihrauch-Kiefer (fachspr., botanisch);Amerikanische Terpentin-Kiefer (fachspr., botanisch);Weihrauchkiefer;Pinus taeda (fachspr., botanisch)
-Verhärtung;Härtung
-Nebenabtrieb;Zapfwelle
-Kosmografie;Kosmographie
-Engine Control Unit (engl.);Motorsteuergerät;Motorsteuerung
-Fahrfußhebel (fachspr.);Strompedal;Gaspedal;Fahrpedal (fachspr.)
-Kennzeichnung;Beschilderung;Markierung;Ausschilderung
-Eigenbewertung;Selbstbewertung;Selbstwahrnehmung;Selbstverständnis;Selbsteinschätzung;Selbstbild
-Hinterland;ländliches Gebiet;Provinz
-Provinz;Verwaltungsgebiet;Landesteil
-hinterm Mond (ugs.);altmodisch;verschlafen;rückständig;angestaubt;hinterwäldlerisch;verstaubt (fig.);muffig;provinziell;verschnarcht;zurückgeblieben;überholt
-Office-Software;Bürokommunikationssoftware (fachspr.)
-Versicherungspaket;Leistungspaket
-Taschenspielertrick;billiger Trick
-Transferleistung;Unterstützungszahlung;Transferzahlung
-Euroasiatische Wirtschaftsgemeinschaft;Eurasische Wirtschaftsgemeinschaft;Eurasian Economic Community (engl.);EAWG
-GIS (österr.);GIS Gebühren Info Service GmbH (österr.);Gebühreneinzugszentrale (veraltet);Billag (schweiz.);GEZ (veraltet);ARD ZDF Deutschlandradio Beitragsservice
-hinter dem;hinterm (ugs.)
-Frohbotschaft (relig.);frohe Botschaft (ggf. leicht iron.);gute Nachricht (Hauptform);Erfolgsmeldung;frohe Kunde;Lichtblick;positive Nachricht;gutes Zeichen
-Vereinigtes Albanien;Großalbanien;Ethnisches Albanien;Natürliches Albanien
-wiederaufforsten;wiederbewalden
-Wiederbewaldung;Wiederaufforstung
-Erstbewaldung;Erstaufforstung
-Sattel;Gebirgspass;Joch;Pass
-(sich) revanchieren;Rache nehmen;(etwas) (mit etwas) vergelten;(jemandem) eins auswischen;(jemandem etwas) heimzahlen;(sich) rächen;Vergeltung üben;(die) Quittung geben;(sich für etwas) schadlos halten (an jemandem)
-Aufmunitionierung;Munitionsnachladen
-aufmunitionieren;Munition nachladen
-Deutsch-Balten;Balten (veraltet);Baltendeutsche;Deutschbalten
-Russlanddeutscher;Deutschrusse
-Schwertbrüderorden;Fratres miliciae Christi de Livonia (lat.);Brüder der Ritterschaft Christi von Livland;Meistertum Livland
-Litorale Austriaco (ital.);Litorale;Österreichisches Küstenland
-Grafschaft Görz;Gefürstete Grafschaft Görz und Gradisca (ab 1365)
-Kroatisches Küstenland;Ungarisches Küstenland
-Thübein-Nabreschin;Tybein
-Augenweide;Augenschmaus
-Zusatztaste;Extraknopf;Extra-Taste;Zusatzschalter;Extra-Schalter;Zusatzknopf
-Steg;Planke;Diele;Brett
-kurzschließen;überbrücken;überleiten
-Styrapurg;Stiraburg;Styraburg;Styrapurch
-Pistole 08;Luger (im Ausland);Parabellum-Pistole
-Polnisch-Preußen;Königlich-Preußen;Preußen Königlichen Anteils;Königliches Preußen
-Pistole M;Makarow
-Schulpforte;Schulpforta (veraltet)
-Duvno (bis 1990);Tomislavgrad;Dalen (veraltet)
-(einen) Augiasstall ausmisten (ugs., auch figurativ);gründlich aufräumen
-Riesensaustall (derb);Augiasstall
-Braunware (veraltend);Unterhaltungselektronik (Hauptform)
-Parvenü (geh.);Homo novus (geh., lat.);Parvenu (geh.);Emporkömmling;Aufsteiger;Arrivierter;Neureicher
-Kossäten;Kossaten;Kötter;Köter;Kätner;Köthner;Kossater;Kötner;Kotsassen
-Hetzer (ugs.);Jagdpanzer 38(t)
-Slipkote (ugs., niederdeutsch);Schleifhütte;Schleifkothe (bis 1900) (veraltet);Schleifkote;Schleifkotten;Schleiferwerkstatt
-Hall-Sensor;Hallgeber;Hall-Sonde
-Laserpointer (engl.);Punktstrahler;Laserzeiger
-fressgierig;gefräßig;verfressen (ugs.);heißhungrig;unersättlich
-schrottreif;reif zum Verschrotten;schrottig (ugs.)
-Giovanni Agnelli;Gianni Agnelli
-Hyperkorrektur;Hyperkorrektion;Hyperurbanismus
-Gebissformel;Zahnformel
-Sorgenkind;Problemkind
-Flotte;Fuhrpark;Fahrzeugbestand;Zahl der (vorhandenen) Fahrzeuge;Fahrzeugflotte;Fahrzeugpark
-Vorkoster;Essenstester
-Zensurenverteiler;Kritiker;Rezensent;Zensor;Bewerter;Beurteiler;Juror;Begutachter;Besprecher
-Unken;Feuerkröten (altertümlich)
-beängstigend (auch figurativ);bitter(-) (nur in speziellen Kontexten);furchtbar (ugs.);schrecklich;mächtig;zutiefst;ganz;ungeheuer;brennend;verteufelt;sündhaft;verdammt (ugs.);fürchterlich;wie hulle (ugs., norddeutsch);rettungslos;außergewöhnlich;sehr (Gradadverb vor Adjektiven);außerordentlich;tief;hoffnungslos;besonders;extrem;voll (ugs., jugendsprachlich);verflixt
-Liebesmal;Unterdruck-Hämatom (fachspr.);Zuzlfleck (ugs., österr.);Knutschfleck
-Feldmühle;Wagenmühle
-Feldmühle;Rotationsvoltmeter;field mill (engl.)
-Elektrofeldmeter;EFM (Abkürzung);elektrisches Feldmeter
-Gewimmel;Gewühl;Gewusel (ugs.)
-Zahl der Toten;Zahl der Todesopfer;Verluste (Hauptform, militärisch);Blutzoll (geh.)
-hohe Schlussrate (eines Kredits);Ballonrate
-Walze (ugs.);Komplettbereifung;Komplettreifen;Rad
-Franzmann (ugs.);Franzose;Froschfresser (derb, abwertend);Schangel;Franzacke (derb)
-Nachstellen;Nachstellung;Stalking;Belästigung
-Abseiher;Barsieb;Strainer (engl.)
-Kurzer;Shot (engl.);Shooter (engl.)
-Einerlei;Einheitsbrei (ugs.)
-Babesien;Babesiella;Babesia
-Katarr (alte Schreibung bis 2011);Katarrh;Schleimhautentzündung
-Feuergefecht;Ballerei (ugs.);Gewehrfeuer;Schießerei (Hauptform);Kugelhagel;Kugelregen;Geschieße (ugs.);Kugelwechsel;Schusswechsel (Hauptform);Geballer (ugs.);(die) Kugeln pfeifen (jemandem) um die Ohren (ugs.);Beschuss
-Viktualienmarkt;Lebensmittelmarkt
-Remanenz;Restmagnetisierung;magnetische Hysterese;Restmagnetismus;Remanenzflussdichte;magnetische Remanenz;remanenter Magnetismus
-Roy Black;Gerhard Höllerich
-Wegführung;Wegleitung;Viadukt
-Alterszulage;Alterszuschlag (fachspr.);Verkalkungszulage (derb);Seniorität (fachspr.)
-Neider;Neidbolzen (ugs.);Neidhammel (ugs.)
-Autopoiesis;Autopoiese
-ZVS;Zentralstelle für die Vergabe von Studienplätzen
-Benjamini (ugs.);Birkenfeige
-Vortex;Wirbel
-Wallfahrer;Haji;Pilgersfrau (veraltet);Hadji;Hadschi;Pilger;frommer Wanderer;Pilgersmann (veraltet);Haddsch
-remittierend;zurückgehend
-Zahlungsempfänger;Wechselnehmer;Remittent
-besitzt;verfügt
-heimlich (attributiv und adverbial);versteckt;verkappt (attributiv);verdeckt (adverbial);verhüllt
-empfinden;spüren;wahrnehmen;fühlen;verspüren
-Flipperautomat;Flipper
-an den Haaren herbeigezogen (fig.);nicht nachvollziehbar;haltlos;fragwürdig;unbegründet;abwegig;unsachlich
-Lastwagen;Lastzug;Lastkraftwagen;Laster (ugs.);LKW (Abkürzung);Brummi (ugs.);Lkw (Abkürzung);Truck (ugs., Jargon, engl.)
-Zuträger;Petze (ugs.);Anschwärzer;Petzer (ugs.);Verräter (Hauptform);Denunziant;Judas (religiös);Verleumder
-Zystitis (fachspr.);Blasenentzündung;Blasenkatarrh;Harnblasenentzündung
-Okapi;Waldgiraffe;Kurzhalsgiraffe
-Nervenkrieg;Machtprobe;Kräftemessen;Belastungsprobe;Kraftprobe;Zerreißprobe (fig.);Tauziehen (fig.)
-Nordamerikanischer Waschbär;Waschbär
-Wiener Schnitzel;paniertes Kalbsschnitzel
-falsches Kotelett (ugs.);paniertes Kuheuter;Berliner Schnitzel
-Lunge;Beuschel (ugs., österr.)
-Berlin (Kanada, bis 1916);Kitchener
-Halon;Halogenkohlenwasserstoff;halogenierter Kohlenwasserstoff
-Gleitbeutler;Petauridae (fachspr.)
-DLR (Abkürzung);Deutsches Zentrum für Luft- und Raumfahrt
-Genugtuung (schweiz.);Schmerzengeld (österr.);Wiedergutmachung;Schmerzensgeld
-(sich) übernehmend;den Mund zu voll nehmend (ugs.);vollmundig
-voll mundend;vollmundig
-MC-Simulation;Monte-Carlo-Studie;Monte-Carlo-Simulation
-USB;Universal Serial Bus
-USB 2.0;HighSpeed USB
-gewandet (geh.);gekleidet;bekleidet;angekleidet;angezogen
-Frauenhandel;Menschenhandel;grenzüberschreitender Prostitutionshandel (österr.)
-Paragraphenreiter (ugs.);Wortklauber (ugs.);Paragrafenhengst (ugs.);Bürokrat;Paragraphenhengst (ugs.);Paragrafenreiter (ugs.)
-(etwas) verfehlen;(etwas) versemmeln (ugs.);(etwas) verhauen (ugs.);(eine) Gelegenheit verpassen
-Geklingel;Gebimmel
-Republik Costa Rica;Kostarika (veraltet);Costa Rica
-o. B. d. A.;ohne Beschränkung der Allgemeinheit;ohne Einschränkung der Allgemeinheit;o. E. d. A.
-Milchzuckerunverträglichkeit;Hypolaktasie;Kohlenhydratmalabsorption (fachspr.);Laktoseintoleranz;Laktasemangelsyndrom;Laktosemalabsorption;Alaktasie
-Abortivei;Windei (Hauptform);Molen-Ei
-Gastwirt;Beizer (ugs., regional);Schankwirt;Wirt;Restaurateur (schweiz.);Kneipier (ugs., französierend);Kneiper (ugs.)
-pappsatt (ugs.);völlig satt;sehr satt
-Dezimalwaage;Sackwaage;Dezimalbrückenwaage;Dekawaage
-DB Baureihe 194 (ab 1968);DRG Baureihe E 94;Deutsches Krokodil (ugs.);ÖBB Reihe 1020;DR Baureihe 254 (ab 1970)
-Tartan;Karomuster;Schottenkaro;Schottenmuster
-schlampig (ugs.);zerwühlt;zerknittert;zersaust (österr.);krumpelig (ugs.);krumplig (ugs.);zerzaust
-Hansa-Brandenburg;HB;Hansa und Brandenburgische Flugzeugwerke GmbH
-Zündapp Z 92;Zündapp 9-092
-Austro-Daimler 6;AD6;Austro-Daimler Aeroplanmotor Typ 6;Austro-Daimler Typ 6
-(etwas) anderes aussagend;anderslautend
-mit dem Pendelbus fahren;shutteln (ugs.);mit dem Shuttlebus fahren
-Zubringerbus;Pendelbus;Shuttlebus
-Lateinisches Alphabet;Römisches Alphabet
-Dako-Thrakisch;Thrakisch
-Kentumsprache;Centumsprache
-verfahrensmäßig;prozedural
-Fluiddynamik;Hydrodynamik
-Strömungsmechanik;Strömungslehre;Strömungstechnik;Fluidmechanik
-Aquadynamik;Wasserdynamik
-Drenther Erhebung;Hondsrug
-Van-Wijngaarden-Grammatik;vW-Grammatik;W-Grammatik
-klein halten;beschränken;einschränken;Obergrenze festlegen;kontingentieren;begrenzen;drosseln;limitieren;eingrenzen;restriktieren (geh.);(etwas) deckeln (ugs.)
-limitational;begrenzend
-Krimsekt;Schampanskoje
-Stromberg (veraltet);Petersberg
-(die) Rheinaue (ugs.);Freizeitpark Rheinaue
-Ripuarisch;Ripwarisch;Nordmittelfränkisch
-umschalten;switchen (ugs.);umstellen
-Ruländer;Pinot Gris (franz.);Pinot Grigio (ital.);Grauburgunder
-Zigarettenrauch;blauer Dunst (ugs.);Zigarettenqualm
-trennbar;separierbar;diskret
-Separierbarkeit;Trennbarkeit;Ablösbarkeit;Entfernbarkeit;Loslösbarkeit;Abtrennbarkeit
-diskrete Grafiklösung (fachspr.);Grafikkarte
-handelbar;verhandlungsfähig;zur Verhandlung stehend;negoziierbar;verhandelbar
-MTBF;mittlere Betriebsdauer zwischen Ausfällen;Mean Time Between Failures (engl.)
-mittlere Lebensdauer;mittlere Betriebsdauer bis zum Ausfall;MTTF;Mean Time To Failure (engl.)
-Hazardwert;Hazardrate
-Kassapreis;Spot-Preis
-Knallerpreis;Dumpingpreis;Spottpreis;Kracherpreis;Schleuderpreis;Kampfpreis
-Strukturvertrieb (fachspr.);Network Marketing (fachspr., engl.);Multi Level Marketing (fachspr., engl.);Mundpropaganda (selten);Netzwerk-Marketing (fachspr.);MLM (fachspr., Abkürzung, engl.);Empfehlungsmarketing (fachspr.)
-kartieren;mappen (ugs.)
-Mother Blue (ugs.);International Business Machines Corporation;IBM;Big Blue (ugs.)
-Internationale Büro-Maschinen Gesellschaft mbH;Deutsche Hollerith-Maschinen Gesellschaft mbH;DEHOMAG (bis 1948);IBM Deutschland
-(absorbierte Stoffe) abgeben;desorbieren
-Teigrolle;Nudelwalker (österr.);Nudelrolle;Wellholz;Wallholz (schweiz.);Nudelholz
-(einer Sache) keinen Abbruch tun (ugs.);(etwas) nicht verhindern
-Farbgradient;Gradient;Farbverlauf
-auf den Geschmack kommen;(an etwas) Gefallen finden;Blut geleckt haben (ugs., fig.);(etwas) verschmeckt haben (ugs., schwäbisch)
-Klerisei (altertüml.);Klerus;Clerisei (altertüml.)
-Erstgeborener;Stammhalter;Erstling;ältester Sohn;erstgeborener Sohn;Ältester
-Erstlingswerk;Debüt...;Erstling;erstes Werk;Debüt;Erstlings...
-Tschernowitz;Czernowitz
-Buchenland (veraltet);Bukowina
-Quasar Technologies (veraltet);Troll Tech (veraltet);The Qt Company;Qt Software (veraltet);Trolltech (veraltet)
-Müllsack;Mülltüte;Kehrichtsack (schweiz.)
-Ausnahmesituation;Matthäi am Letzten (ugs.);Holland in Not (ugs., fig.);(da) brennt die Hütte (ugs., fig.);Notstand;Ausnahmezustand;(da ist) Land unter (ugs., fig.);Krise;Misere;(da) brennt der Baum (ugs., fig.);krisenhafte Situation;Krisensituation;Notlage
-Notstand;Ausnahmezustand;Status Necessitatis (lat.);Belagerungsstand;Notstandsdiktatur;Staatsnotstand;Verfassungsnotstand;Notrecht;Belagerungszustand;Kriegsrecht;Notstandsrecht
-Gleichzeitigkeit;Parallelität;Nichtsequentialität;Concurrency (engl.);Concurrent computing (engl.);Nebenläufigkeit
-Synchronismus;historische Gleichzeitigkeit (an einem Datum)
-Observabilität;Beobachtbarkeit
-zu beobachten;bemerkbar;observabel;beobachtbar
-schaurig schön (scherzhaft);stockhässlich;hässlich wie die Nacht (ugs.);abscheulich;furchtbar;affrös (geh., veraltet);grottenhässlich;sauhässlich (derb);potthässlich (ugs.);sehr hässlich (Hauptform);scheußlich;abstoßend (hässlich) (variabel)
-Künstlergruppe;Ensemble
-Bucht;Bai;Meeresbucht
-Wattenmeer;Watt
-Ausformulierung;detaillierte Ausarbeitung;Ausgestaltung
-IA-32e (veraltet);x86-64 (fachspr.);EM64T (veraltet);Intel 64;x64 (fachspr.);AMD64
-Chiparchitektur;Prozessorarchitektur
-flüssig;geschmolzen;aufgetaut;zerflossen;liquid
-weißes Pferd;Schimmel
-Putzschwamm;Schwamm
-(sparsam) verköstigen;menagieren (veraltet)
-Essen holen;Essen fassen (ugs.)
-verlorener Transport;verlorener Zug;Zug der Verlorenen
-Eduard Roschmann;F(r)ederico Wegener (Alias);Schlächter von Riga (ugs.)
-Kruckenkreuz;Krückenkreuz;Hammerkreuz
-Taukreuz;Antoniuskreuz (Hauptform);Crux commissa (lat.);Antoniterkreuz;Ägyptisches Kreuz;Plattkreuz
-flegeln (ugs.);lümmeln (ugs.);fläzen (ugs.)
-Pilzkunde;Mykologie (fachspr.)
-Tragerl (ugs., bayr., österr.);Flaschenkasten
-AEG;Allgemeine Elektricitäts-Gesellschaft;DEG (veraltet);Deutsche Edison-Gesellschaft (veraltet)
-sehr voll;knatschvoll (ugs.);bumsvoll (ugs.);rammelvoll (ugs.);(es ist) alles voll (mit) (ugs.);überfüllt;prallvoll;prall gefüllt;zum Platzen voll;knallvoll (ugs.);knallevoll (ugs.);gerappelt voll (ugs.);gesteckt voll (ugs.);proppevoll (ugs., ruhrdt.);brechend voll;rappelvoll (ugs.);vollgepackt;pickepackevoll (kindersprachlich) (ugs.);übervoll;zum Bersten voll;zum Brechen voll;gerammelt voll (ugs.);aus allen Nähten platzen(d) (ugs., fig.);gedrängt voll;proppenvoll (ugs.)
-St. Eustaz (veraltet);Sint Eustatius
-St. Barts;Sankt Bartholomäus;St. Barths;Saint-Barthélemy (franz.)
-Niederländische Westindische Gesellschaft;Niederländische Westindien Kompanie
-Russisch-Amerikanische Handelskompanie;Russisch-Amerikanische Gesellschaft;Russisch-Amerikanische Kompagnie
-Bewehrung;Panzerung;Armierung
-Sequestration;Sequestrierung
-ethisch-ökologischer Fonds;Ethikfonds;Nachhaltigkeitsfonds
-vergessliche Person;Schussel (ugs.);zerstreuter Professor (ugs., fig.)
-größter Teil;Gros
-Mikroplanfilm;Mikrofiche
-Dornick (veraltet);Tournai
-Ausdifferenzierung;Spezialisation;Spezialisierung
-Julklapp (nach dem Julfest);Wichteln;Engerl-Bengerl (österr.)
-Aufpasserin;Gouvernante (veraltet);Erzieherin;Basteltante (derb)
-Skaleninvarianz;Skalenunabhängigkeit
-Venetisch;Venedisch;Venezisch
-Wegzehrung;Sterbekommunion;Viatikum
-hereinkommen;hineinkommen;reinkommen
-subsistieren;unabhängig sein
-geografisch;geographisch
-herbstlicher Wind;Herbstwind
-(auf ein Konto) verbuchen;kontieren
-Maßstäbe setzen (werbesprachlich);(etwas) vorleben;(sich) vorbildlich verhalten (Hauptform);mit gutem Beispiel vorangehen;(ein gutes) Vorbild sein
-umstellen (auf);verstellen;anders einstellen;umkonfigurieren;umprogrammieren
-Bedeutung erlangen;wirksam werden;(sich) auswirken;Effekte zeitigen (geh.);Wirkung zeigen;(seine) Wirkung entfalten;zum Tragen kommen
-Kavalier (ital.);Weltmann;Seigneur (geh., franz.);feiner Herr;Mann von Welt (ugs.);Gentilhomme (franz., veraltet);Gentleman (engl.);Ehrenmann
-(sich) zurückbilden;verkümmern;eingehen
-Visibilität;Sichtbarkeit;Erscheinung
-mit Mitteln der Sprache;sprachlich
-Hall;Nachhall
-sexuell erregbar;erogen
-Mendikantenorden;Bettelorden
-(jemandem etwas) neiden;vor Neid erblassen;(jemandem etwas) nicht gönnen;neidisch sein;(jemandem etwas) missgönnen
-khakifarbig;gelbbraun;kakifarben;khakifarben;kakifarbig
-Arme und Beine;Gliedmaßen;Glieder
-Erektion;Latte (ugs.);Ständer (ugs.);Morgenlatte (ugs.);Steifer (ugs.)
-Depravation;Zustandsverschlechterung (bei einer Krankheit)
-Geld fordern;(etwas) berechnen;zur Zahlung auffordern;(das) Inkasso übernehmen;um Bezahlung bitten;um Zahlung bitten;in Rechnung stellen;(eine) Forderung eintreiben;(jemanden für etwas) aufkommen lassen;zur Kasse bitten;(jemanden / etwas) abkassieren (ugs.)
-(für etwas) geradestehen;in Haftung genommen werden;(für Schaden) aufkommen müssen;einstehen müssen;haften (für)
-austauschbar;fungibel (fachspr., juristisch);ersetzbar;vertretbar (fachspr., juristisch)
-Schuldiener (veraltet);Pedell (veraltet);Schulwart
-Exoplanet;Planet außerhalb des Sonnensystems;extrasolarer Planet
-grafisch;graphisch
-lebendig werden lassen;verlebendigen
-unschädlich machen;neutralisieren (militärisch);Gefahr beheben
-Exzerpt erstellen;exzerpieren
-fischeln (schweiz., österr.);nach Fisch riechen
-Hälfte;halbe Menge
-Intergovernmentalismus;Intergouvernementalismus
-Yuppisierung (ugs., Jargon, Schlagwort);Gentrifizierung (Hauptform);Aufwertung (Wohnbezirk);Gentrifikation
-Schlafgemach (veraltend);Schlafzimmer;Schlafstube;Schlafkammer;Schlafraum
-Webapplikation;Online-Anwendung;Webanwendung;Web-App (Jargon)
-verschließend;okklusiv
-rückgängig zu machen;revidierbar
-auf Hochtouren (ugs.);volles Rohr (ugs., salopp);volle Lutsche (ugs., salopp);mit Hochdruck (ugs.);mit voller Kraft;mit Volldampf (ugs.);volle Kanne (ugs., salopp);volle Pulle (ugs., salopp)
-Gebäudemanagement;Gebäudedienstleistung(en);Facility Management;Objektmanagement
-schockiert sein;unter Schock stehen
-Zieche (österr.);Bettbezug;Bettüberzug
-(etwas) mitnehmen;beim Schopf(e) packen (Gelegenheit, Chance) (ugs., fig.);(die) Gunst der Stunde nutzen;ergreifen (Gelegenheit, Chance) (Hauptform);zugreifen;beim Schopf(e) ergreifen (fig.);zuschlagen (ugs., Hauptform);ausüben (Option, Stimmrecht, Vorkaufsrecht) (fachspr., juristisch, kaufmännisch);nicht verstreichen lassen;nutzen (Chance, Gelegenheit) (Hauptform);nicht links liegen lassen (fig.);wahrnehmen (Termin, Vorteil, Chance)
-Hecht (Hauptform);Esox
-Sauerkraut;Sauerkohl
-orchestral;sinfonieartig;sinfonisch;symphonisch
-Oschi (ugs.);(ein) Ungetüm (von) (ugs.);so'n Ding! (ugs.);(ein) Trumm (von);Riesen...;Ömmes (ugs.);Monstrum;Riesenteil (ugs.);Monster...;dickes Ding (ugs.);Kaventsmann (ugs.);fettes Teil (ugs., jugendsprachlich);Ömmel (ugs.);so ein Ding! (mit Geste) (ugs., emotional);dicker Brummer (fig.);Öschi (ugs.);Mordsteil (ugs.);Apparillo (ugs., rheinisch);Riesending (ugs.);Brocken (ugs.);großes Ding
-sachgemäß;sachgerecht
-Fortune (ugs., franz.);(wirtschaftlicher) Erfolg
-sehr böse;bitterböse
-verwaltungsmäßig;administrativ
-explorativ;ausprobierend;auskundschaftend
-Lernvorgang;Lernprozess
-narrative Instanz;Erzähler
-H.264;MPEG-4 AVC
-wegstemmen;wegdrücken
-Obsoleszenz;Veralterung
-Wanderhändler;Marktfahrer (schweiz., österr.)
-Singspiel;Musikrevue;Musical;Musiktheaterstück
-Degradierung;Herabsetzung;Degradation
-Konklave;Papstwahl
-Kurie;Römische Kurie;päpstliche Behörden
-Menschen verachtend;menschenverachtend
-gute Wahl;Glücksgriff;glückliche Wahl
-Mini-Album (ugs.);Extended Play;EP
-Stek;Schifferknoten;Segelknoten;seemännischer Knoten
-Schmusedecke;Kuscheldecke
-Überdecke;Tagesdecke
-Standesschranke;Standesgrenze
-Button;Ansteckplakette;Anstecker
-Scheinentlehnung;Pseudoentlehnung
-kurze Barthaare;Stoppeln
-hungrig (sein);nichts im Magen haben;Hunger haben
-Palmtuch;Fastentuch;Hungertuch
-am Hungertuch nagen (ugs.);(sich) nichts zu essen kaufen können;arm sein;nichts zu beißen haben (ugs.);(bei jemandem) ist Schmalhans Küchenmeister (ugs.);(den) Kitt aus den Fenstern fressen (müssen) (derb, fig.)
-(nur / überhaupt) irgendwie;irgend (geh.);auf irgendeine Weise
-THW;Technisches Hilfswerk
-Österreichisch (ugs.);österreichisches Standarddeutsch;österreichisches Hochdeutsch;österreichisches Deutsch
-Fußgänger;Passant;Fußgeher (österr.)
-Ersetzbarkeit;Fungibilität;Austauschbarkeit
-Schweizer Hochdeutsch;Schweizerisch;Schweizerhochdeutsch
-deutsche Sprache;dt. (Abkürzung);Deutsch
-Verlängern;Verwässerung;Dilution;Strecken;Verdünnung
-Wirtschaftsgrünland;Fettweide(n);Fettwiese(n);Intensivgrünland
-Pr1me;Prime Computer
-Pro/ENGINEER;ProE;Pro/E
-Fertigungszentrum;Bearbeitungszentrum
-Punktsteuerung;PTP-Steuerung
-Triebrad;Treibrad
-Meideborg (plattdeutsch);Magdeburg
-Charisagum (veraltet);Karisiacum (veraltet);Cariciacum (veraltet);Carisiacum (veraltet);Quierzy
-Grödental;Gröden;Grödnertal
-Sextener Dolomiten;Sextner Dolomiten
-afroasiatisch;semito-hamitisch (veraltet);hamito-semitisch (veraltet)
-EPOC32 (bis Version 6);Symbian OS
-Schadat (bis 1926) (veraltet);Lenauheim
-Bad Salzbrunn;Ober Salzbrunn (bis 1935) (veraltet)
-Krak;Krakus
-Benz (ugs.);Großer Mercedes;Mercedes-Benz 770
-Bewährungsstrafe;bedingte Strafe (schweiz.);Strafaussetzung zur Bewährung;bedingte Strafnachsicht (österr.)
-Gesenkformen;Gesenkschmieden
-funkenerosives Senken;Senkerodieren;Senkfunkenerosion;Senkerosion
-Drahterosion;Schneiderodieren;Drahterodieren;Drahtschneiden;funkenerosives Schneiden
-Bohrerosion;Bohrerodieren;funkenerosives Bohren
-Tarnkappentechnik;Stealth-Technik
-Bien (fachspr.);Bienenstock;Bienenvolk
-der Alte vom Bodensee (ugs.);Ferdinand Graf von Zeppelin
-Datum;Datierung
-Kronstadt;Krunen (siebenbürgisch-sächsisch)
-Herrscherin des Ostens (ugs.);Wladiwostok
-Talaing;Mon
-Hmong;Miao
-Cargo-Kult;Cargokult;Cargo-Cult
-nichtreduzierbare Komplexität;irreduzible Komplexität
-nicht ableitbar;irreduzibel;nicht zurückführbar
-A1-Ring;Österreichring (veraltet)
-Karl Abarth;Carlo Abarth
-US-Notenbank;Fed (Abkürzung, engl.);Federal Reserve System (engl.);Federal Reserve (engl.);Zentralbank der Vereinigten Staaten
-Draisine;Laufmaschine
-Warnowtunnel;Warnowquerung
-Heap (engl.);Haldenspeicher;Freispeicher;dynamischer Speicher
-Kinh;Vietnamesen
-elektropneumatische Schaltung;Telligent-Schaltung (ab 1996)
-Raubpressung;Bootleg;Schwarzpressung
-Mitschnitt;Einspielung;Bildkonserve;Aufnahme;Aufzeichnung;Tonkonserve
-vor aller Augen;öffentlich;am helllichten Tag;auf offener Bühne (fig.);coram publico (lat.);vor versammelter Mannschaft;in aller Öffentlichkeit (Hauptform);auf offener Straße;vor aller Öffentlichkeit;vor den Augen der Menge (ältere Sprache) (geh.);vor allen Leuten;vor aller Welt
-Adiuretin;Vasopressin;Antidiuretisches Hormon;Arginin-Vasopressin;ADH (Abkürzung);AVP (Abkürzung)
-Dipps (ugs.);Dippoldiswalde
-Dorier;Dorer
-Rosatom;Föderale Agentur für Atomenergie Russlands
-Bad Schwalbach;Langenschwalbach (bis 1927) (veraltet)
-Nitridieren;Aufsticken (fachspr.);Nitrieren
-Militärattaché;Militärbevollmächtigter (veraltet)
-Riograndensisch;Katharinensisch;riograndenser Hunsrückisch
-Riograndense Republik;Republik Piratini
-Muckefuck (ugs.);Caro-Kaffee;Gerstenkaffee;Getreidekaffee;Kaffeeersatz;Fruchtkaffee;Kinderkaffee (ugs.);Malzkaffee;Ersatzkaffee;Zichorienwasser (regional, österr.)
-Burgstadt (1939-1940) (veraltet);Pabianitz
-Via Baltica (lat.);Europastraße 67
-Präliminarfrieden;Vorfrieden
-Iberischer Neutralitätspakt;Iberischer Block
-(jemandem) entringen;(jemandem) abringen;(jemandem) entwinden;(jemandem etwas) aus der Hand winden
-Permafrost;Dauerfrost
-Stratocaster;Strat (ugs.)
-Stradivari;Strad (ugs.)
-Ur (veraltet);Our
-Mosel (Hauptform);Moezel (niederländisch);Musel (luxemburgisch)
-Neutral-Moresnet;Altenberg
-Zinkspat (veraltet);Edelgalmei (veraltet);edler Galmei (veraltet);Smithsonit
-Thüringisch-Obersächsisch;Sächsisch (ugs., fälschlich)
-Zambesi;Zambezi;Sambesi
-Viktorianisches Zeitalter;Viktorianische Epoche;Viktorianische Ära
-Chachi Mpika;Mpika;Cha-Chi
-64er (ugs.);C64 (Abkürzung);Commodore 64
-Pfauenstrauch;Stolz von Barbados
-Mosambik-Kanal;Straße von Mosambik
-neue Kredite (ugs.);Neuverschuldung
-Sieben (ugs.);Handballmannschaft
-Zähler (ugs.);Punkt
-Gregor von Nazianz;Gregorius von Nazianzus
-Franco-Regime;Franquismus;Franco-Diktatur;Frankismus
-Puerto-Ricaner;Boricua
-rumoren;poltern (ugs.);rumpoltern (ugs.);ramentern (ugs.)
-Ego-Shooter;First-Person-Shooter
-Sebatik;Sebittik (veraltet)
-Ngola-Königreich;Königreich Ndongo
-EU-Reformvertrag;Vertrag von Lissabon;EU-Grundlagenvertrag
-unter Höchstgeschwindigkeit;alles was (...) hergibt (ugs.);wie ein Henker (fahren) (ugs.);so schnell (wie) er konnte;volle Kanne (ugs.);(mit) Vollgas;mörderisches Tempo (ugs.);volle Kraft voraus;(stark) überhöhte Geschwindigkeit;wie ein Geisteskranker (ugs.);mit Höchstgeschwindigkeit;(mit) Bleifuß (ugs.);full speed (ugs., engl.);wie eine gesengte Sau (ugs.);in Höchstgeschwindigkeit;Höchstgeschwindigkeit;Höchsttempo;Affenzahn (ugs.);so schnell (wie) es (irgend) ging;voll Stoff (ugs.)
-ablandiger Wind;Landwind
-Seewind;auflandiger Wind
-Affensitz (ugs.);Steuersitz (im Rennruderboot)
-Spinnaker;Spi (Kurzform)
-anmustern;anheuern
-Ammeral;Segeltuchpütz (Eimer)
-Algin;Alginsäure
-(ein) anderes Schiff anrufen;anpreien
-außer Dienst gestelltes Schiff;Auflieger
-auslugen;(scharfes) Ausschauen
-Außenbordskameraden (ugs.);Fische (im Meer)
-Axiometer;Ruderlageanzeiger
-Backmann;Kochsmaat-Bäcker
-Ballahou;(westindischer) Schoner;Ballahoo
-(schlankes) Spinnakerstagsegel;Bananenstagsegel
-Barbette (fachspr., franz.);Geschützbank
-Bathysonde (fachspr.);Tiefseesonde
-Binokel;Doppelfernglas
-Blender (ugs.);Schmuggelschiff
-Schiffsgefängnis;Brig
-loses Rahsegel (auf Yachten);Brefock;Breitfock
-Bukanier;(westindischer) Seeräuber
-rundes Fenster;Bullauge
-Canvas;Segeltuchschuh(e)
-Europäische Sprotte;Breitling;Sprott;Sprattus sprattus (lat.);Brisling
-Radioästhesie;Radiästhesie
-Typenbildfeldfernschreiber;Hellschreiber
-Hilfsheizer;Donkeyman
-Donkeyboiler;Hilfskessel
-Fährmann;Ferge (veraltet);Fährführer
-Nordseekrabbe (ugs., fälschlich);Crangon crangon (fachspr.);Knat;Granat;Strandgarnele;Sandgarnele;Graue Krabbe (ugs., fälschlich);Porre;Nordseegarnele (Hauptform)
-Ruppe (süddt.);Aalquappe (süddt.);Quappaal (norddeutsch);Aalrutte (süddt.);Trische (schweiz.);Hammelfleischfisch (ugs., seemännisch);Rutte (österr.);Treische (schweiz.);Quappe;Trüsche (Bodensee);Aalraupe (süddt.)
-blanker Hans (ugs.);(stürmische) Nordsee
-Fettkeller (ugs.);Maschinenraum
-Maschinenraumpersonal;Kellerkinder (ugs., Jargon, fig.)
-Klabautermann;Kalfatermann;Klabattermann
-Seelachs;Köhler;Pollachius virens (lat.);Kohlfisch
-Krüppelwind (ugs.);kleiner Wind
-Grundschleppnetz;Kurre
-Nichtseemann;Landratte (ugs., scherzhaft, seemännisch)
-entladen (eines Schiffes);löschen
-blinder Passagier (fig.);Einschleicher
-Masut;Ölrückstände
-Milchner (ugs.);reifer Hering (Männchen)
-Fahrgastschiff;Musikdampfer (ugs., seemännisch);Passagierschiff
-Flusslotse;Muddpilot (ugs., seemännisch)
-Chubbschloss;Zuhaltungsschloss;tosisches Schloss
-ceteris paribus;unter sonst gleichen Umständen;unter sonst gleichen Voraussetzungen
-Lamellenstecker;Bananenstecker (ugs.);4-mm-Federstecker
-Dorpat;Dörpt (veraltet);Tartu
-nicht elastisch;unelastisch;inelastisch
-Hohenzollernschloss;Schloss Sigmaringen
-Victoria Nyanza;Viktoriasee;Victoriasee;Ukerewesee (veraltet)
-Skandinavische Alpen (veraltet);Skandinavisches Gebirge;Skanden
-Sektion;Bereich;Abteilung
-Hofmann-Abbau;Hofmann-Eliminierung
-Schöftland;Schöftle (schweiz.)
-erster Arabisch-Israelischer Krieg;israelischer Unabhängigkeitskrieg;Palästinakrieg
-Diakritikum (geh., griechisch, lat.);diakritisches Zeichen;Diakritikon (fachspr., griechisch)
-Pferdeshow;Show mit Pferden
-Live-Act (engl.);Liveact (engl.);Show;Live-Gig (ugs.);Live Event;Live-Veranstaltung;Gig;Live-Auftritt;Auftritt;Live-Entertainment
-Veranstaltung;Aufführung;Vorstellung;Fest;(künstlerische) Darbietung;Event
-Tiershow;Tierveranstaltung;Tiertheater
-Zirkus;Circus
-(das) Gejaule (ugs., abwertend);Gesinge (abwertend);Kunstgesang (geh.);(das) Gejodel (ugs.);(das) Gedudel (ugs.);(das) Trillern (ugs.);(das) Trällern (ugs.);(das) Jubilieren (ugs.);(die) Singerei (ugs., abwertend);(das) Flöten (ugs.);(das) Schmettern (ugs.);(das) Dudeln (ugs.);(das) Zwitschern (ugs.);(das) Summen;Gesang;(das) Tirilieren (ugs.);(das) Schallen (geh.);(das) Singen;(das) Jodeln (ugs.);(das) Kreischen (ugs.)
-Makroökonomik;makroökonomische Theorie;Makrotheorie;Makroökonomie
-Sonderregelung;Sonderweg;sein eigenes Ding (machen);seinen eigenen Weg gehen;eigene Wege gehen
-Sonderweg einschlagen;eine Extrawurst braten (ugs.)
-Rundstedt-Offensive;Ardennenoffensive
-zum Versteuern anmelden;deklarieren;zum Verzollen anmelden
-Gewerkschaft der Polizei;GdP
-Taperecorder;Kassettenrekorder;Magnettongerät;Kassettengerät;Tonbandgerät
-Parzellierung;Grundstücksteilung
-Flurstück;Grundstück (österr.);Parzelle
-Fußmatte;Fußabstreicher;Fußabtreter;Schuhabstreifer;Fußabstreifer;Schuhmatte;Abtretmatte;Türmatte;Schmutzfangmatte
-Werkhöhe;Gestaltungshöhe;Schöpfungshöhe
-Wertfach;Schließfach
-Bedarfsplan für die Verkehrswege des Bundes;Bedarfsplan für die Bundesverkehrswege;Bundesverkehrswegeplan
-Schule (ugs.);Strömung;Lager (ideengeschichtlich, politisch)
-externer Effekt;äußerer Einfluss (ugs.)
-Über-50-Jährige;Ü50 (ugs.);Senior;Best Ager (Jargon, engl., werbesprachlich);Generation 50-Plus;Altherren... (in Zusammensetzungen);ältere Herrschaften;(Person) im besten Alter (ugs.)
-Impfserum;Heilserum (veraltet);Immunserum
-Tupel der Länge n;n-gliedrige Folge;n-Tupel
-Operation Jonathan;Operation Entebbe;Operation Thunderball;Operation Thunderbolt
-Glaube an einen einzigen Gott;Monotheismus
-Westminster-Demokratie;Westminster-System
-inkonsequent;mit angezogener Handbremse (fig.);mit halber Kraft;unentschieden;halbherzig
-Nordwest-Rebellion (veraltet);Saskatchewan-Rebellion (veraltet);Nordwest-Widerstand
-Speicherdampflokomotive;feuerlose Lokomotive;Dampfspeicherlokomotive
-Geistmühle;Gelsmühle;Geismühle
-Ämterwechsel;Personalwechsel;Ämtertausch;Rochade (fig.)
-Ajatollah;Ayatollah
-unwissend;ignorant;uninformiert;unbedarft;unbeleckt (von) (ugs.);unaufgeklärt;ahnungslos;unbewandert
-Scheinanglizismus;Pseudoanglizismus
-Übertreibung;Überspitzung
-Pugatschow-Aufstand;Russischer Bauernkrieg 1773-1775
-Chaussee-Einnehmerhaus;Chausseehaus;Chausseegeldeinnehmerhaus
-Vertrauensbereich;Erwartungsbereich;Konfidenzintervall;Vertrauensintervall
-Winkelminute;Bogenminute
-Feldherrenkunst;Schlachtenlenkung;Schlachtplan;Strategie;Kriegskunst
-Weißenburg (veraltet);Alba Iulia;Karlsburg (ab 1711)
-Rechtsextremismus;Rechtsradikalismus (ugs.);Nationalsozialismus;Faschismus
-Häretiker;Renegat;Dissident;Sektierer;Abweichler;Abtrünniger;anders Denkender;Deviationist;Andersdenkender;Apostat;Abgefallener;Ketzer;Irrgläubiger
-abgefallen;häretisch;irrgläubig;ketzerisch;sektiererisch;lästerlich (geh.)
-Entführung;Kidnapping;Menschenraub;Verschleppung (einzelne Personen);Geiselnahme
-Bühnensprache;Literatursprache;Schriftsprache;Hochsprache;hohe Sprache
-immunisieren (fachspr., medizinisch);eine Impfung vornehmen (fachspr., bürokratisch);in den Arm rammen (derb);immun machen (ugs.);impfen (Hauptform);die Nadel ansetzen (ugs.);schutzimpfen
-Wasserrose;Seerose;Sumpftulpe (ugs., veraltet)
-Wellengang;Gewoge;Wellen;Wellenschlag
-Speck;Fettgewebe;Hüftgold (ugs.);Rettungsring (ironisch);Fettmasse;Fettpolster;Hüftspeck
-Schmalz;Fett;Schmer;Speck
-dissoziative Identitätsstörung;multiple Persönlichkeitsstörung
-Dateisuffix;Dateinamenerweiterung;Dateierweiterung;Dateinamenserweiterung;Dateiendung;Extension (engl.)
-Steingut;Keramik;Tonware;Töpferware
-Umgang;Handhabung;Handling
-alliterierend;stabreimend
-Tierschau;Menagerie
-Roter Traminer;Gewürztraminer
-Rebenkunde;Ampelographie;Rebsortenkunde;Ampelografie
-Petroglyph;Steinritzung
-Reservationspreis;Zahlungsbereitschaft;Vorbehaltspreis
-kein Wert (ugs.);kein Sinn
-Informel;informelle Kunst
-Makarska;Macharscha (veraltet)
-Luftlinie;Orthodrome
-außerbörslicher Handel;Direkt-Handel;Freiverkehrs-Handel;OTC-Handel
-umdeuten;uminterpretieren;(einem Begriff) eine neue Bedeutung geben;neu deuten;neuinterpretieren
-geodätischer Weg;Geodätische;geodätische Linie;Geodäte
-Kanadischer Schild;Laurentischer Schild
-Sueven;Sueben;Suawen;Sweben
-Fennoskandia;Fennoskandien;Fennoskandinavien
-Savognino (ital.);Savognin;Schweiningen (bis 1890) (veraltet);Suagnign (rätoromanisch)
-Surfing;Wellenreiten (ugs.);Surfen
-Wellenreiter (ugs.);Surfer
-dienstlicherseits;dienstlich veranlasst;dienstlich;amtswegig (Amtsdeutsch);von Amts wegen;von Dienst wegen;behördlich;amtshalber;kraft Amtes (Amtsdeutsch);ex officio;diensthalber;dienstlicherweise;amtlich;dienstwegig (Amtsdeutsch)
-Ayeyarwady;Irrawaddy;Irawadi
-Börsenterminkontrakt;Terminkontrakt;Future
-Bastnach (veraltet);Baastnech (luxemburgisch);Bastenaken (niederländisch);Baaschtnech (luxemburgisch);Bastenach (veraltet);Bastogne
-Saarkanal;Saar-Kohlen-Kanal (veraltet)
-Gdingen;Gdynia;Gotenhafen (1939-1945) (veraltet)
-Fünfherrschaft;Pentarchie
-Reibungslehre;Tribologie
-Deprivationssyndrom;Hospitalismus
-Futurologe;Zukunftsforscher
-noch nicht weit gekommen sein (mit) (fig.);in den Kinderschuhen stecken (ugs., fig.);am Anfang stehen (mit)
-urläubig (ugs., selten);weggefahren;auf Reisen;in Urlaub;in Urlaub gefahren;auf Urlaub;verreist
-Rapport;Bericht;Lagebericht
-Eingeschlossensein;Locked-in-Syndrom
-Schlangenmensch;Kontorsionist
-Raurachische Republik;Raurakische Republik
-Prerow an der Elbe;Alt Prerau (veraltet)
-HS-30-Skandal;Hispano-Suiza-Skandal
-nachsuchen;wissen wollen;(genauer) nachfragen;(sich) interessieren;hinterfragen
-Anglo-Irischer Krieg;Irischer Unabhängigkeitskrieg
-Kolin;Köln an der Elbe
-Nymburk (tschechisch);Neuenburg an der Elbe;Nimburg
-Auspeitschen;Geißelung;Flagellation
-Streuwertfunktion;Hashfunktion
-Würzepfanne;Sudpfanne
-Numerische Mathematik;Numerik
-Buttersäure;Butansäure
-Internetbrowser;Browser;Webbrowser
-harzig;klebrig
-Kaffeesatz;Grums (Nordfriesland) (ugs., plattdeutsch);Prött (ugs., ruhrdt., westfälisch);Kaffeesud (österr.);Koffjedick (ugs., plattdeutsch);Prütt (ugs., ruhrdt., westfälisch)
-zunichte machen;torpedieren (fig.);zu Fall bringen (fig.);zum Scheitern bringen;vereiteln;sabotieren
-Deckhengst;Beschäler (veraltet);Zuchthengst
-unverschnittener Hengst;Ganzer (veraltet)
-Schindanger;Schindacker
-reisiges Pferd;Reitpferd
-Wutsch (ugs., elsässisch, pfälzisch);Fohlen (Hauptform);Füllen;Enter (norddeutsch)
-Telefonnetz;Fernsprechnetz (veraltet)
-Gewinn-und-Verlust-Rechnung;Gewinnverwendungsrechnung;Gewinn- und Verlustrechnung
-Varusschlacht;Schlacht im Teutoburger Wald;Hermannsschlacht
-Faltbuch;Leporello
-Bullionmünze;Anlagemünze
-scharf stellen;scharfschalten;scharfmachen;scharfstellen;scharf schalten;scharf machen
-Kleine Sonnenblume;Helianthus tuberosus (fachspr., griechisch, lat.);Borbel;Topinambur (Hauptform);Erdschocke;Knollensonnenblume;Erdtrüffel;Rosskartoffel;Schnapskartoffel;Zuckerkartoffel;Erdartischocke;Ewigkeitskartoffel;Erdapfel (badisch);Erdsonnenblume;Indianerknolle;Jerusalem-Artischocke;Erdbirne;Ross-Erdäpfel (badisch);Süßkartoffel
-Ungut;Übelgut;Schadprodukt
-ungestraft davonkommen;keine finanziellen Nachteile haben (durch);ungerupft davonkommen (ugs.);(für etwas) nicht bezahlen müssen;ungeschoren davonkommen
-Abteital;Gadertal
-Stadtrat;Rat der Stadt;Stadtparlament (ugs.);Gemeinderat
-Reff (ugs., abwertend);(alte) Vettel (abwertend);alte Hexe (derb);(alte) Schachtel (derb, abwertend, fig.);(altes) Schrapnell (ugs., fig.);(alte) Schrulle (ugs., abwertend);(alte) Schabracke (ugs., abwertend);(abgetakelte) Fregatte (ugs., abwertend, fig.);(alte) Scharteke (ugs., abwertend);Alte (derb);Matrone (abwertend);alter Besen (ugs., fig.);alte Frau (Hauptform);altes Weib;Schreckschraube (ugs., abwertend);Spinatwachtel (ugs., abwertend)
-Fierant (österr.);Markthändler
-Bösartigkeit;Infamie;Heimtücke;Niedertracht
-(Bilder oder Texte) digitalisieren;scannen
-(sich gegen etwas) verwahren;(sich etwas) verbitten
-Baumwipfel;Krone;Wipfel;Baumkrone;Zopfholz (fachspr.)
-Chemikalien-Intoleranz;multiple Chemikalienunverträglichkeit;chemische Mehrfachempfindlichkeit;MCS
-Elastan;Spandex;Elasthan
-Chemiefaser;Kunstfaser
-staken;waten;staksen;stapfen;stelzen
-Anzahl der Neuerkrankungen;Inzidenz (fachspr.)
-(sich in jemanden) hineinversetzen;(eines anderen) Perspektive einnehmen
-Petent;Einreicher einer Petition
-braunhaarig;brünett
-Ernährungsänderung;Ernährungsumstellung;Nahrungsumstellung
-Kettenreaktion;Dominoeffekt
-Langzeiturlaub;Auszeit (vom Job);Sabbatical (engl.);Sabbatjahr
-gastieren;ein Gastspiel geben (Theater, Konzertreihe)
-Puerilität (fachspr.);Kindlichkeit;Infantilität
-Zentralschlüssel;goldener Schlüssel (ugs.);Generalschlüssel;Passepartout;Hauptschlüssel
-Ausgleichsrechnung;Anpassung;Regression;Ausgleichungsrechnung;Parameterschätzung;Ausgleichung
-Tischmanieren;Tischsitten;Benehmen bei Tisch;Umgangsformen bei Tisch
-trekken;laufen;trecken;wandern;bergwandern
-begeistern;umhauen (ugs.);vom Hocker hauen (ugs., fig.);vom Hocker reißen (ugs., fig.)
-Wäschemangel;Mangel
-Mandat;Abgeordnetenamt;Abgeordnetensitz;Sitz (ugs.)
-umgehen;nachtwandeln;schlafwandeln;herumgeistern (ugs.)
-zusammenleben wie Mann und Frau;eheähnliche Gemeinschaft;Ehe ohne Trauschein;nichteheliche Lebensgemeinschaft (Amtsdeutsch);wilde Ehe (veraltend);Konkubinat (geh.)
-Levirat;Jibbum;Schwagerehe;Leviratsehe
-performatorisch;performativ
-Redehandlungstheorie;Sprechhandlungstheorie;Sprechakttheorie
-Armageddon;Harmageddon;Har-Magedon;Harmagedon
-Großformatdrucker (ugs.);Plotter
-Polyp;Nesseltier
-Seitenstraße;Nebenstraße
-Sellerie;Eppich (landschaftlich);Zeller (österr.)
-absetzbar;veräußerlich;feil
-Paradies auf Erden;Garten Eden;heile Welt (ugs., ironisch);Insel der Seligen;Paradies;Rückzugsort;Idylle;Oase;Erholungsort;Rückzugsstätte;Idyll;Refugium
-Shanghai;Schanghai
-Ameisenkundler;Ameisenforscher;Myrmekologe
-Myrmekologie;Ameisenkunde
-Schweizergarde;päpstliche Schweizergarde
-Beutelteufel;Tasmanischer Teufel
-Beutelwolf;Beuteltiger;Tasmanischer Wolf;Tasmanischer Tiger
-Slavistik (fachspr.);Slawistik;slavische Philologie (fachspr.);slawische Philologie
-Autonome Provinz Trient (offiziell);Welschsüdtirol (veraltet);Trentino;Welsch-Tirol (veraltet);Welschtirol (veraltet)
-Sendlinger Blutweihnacht;Sendlinger Mordweihnacht;Sendlinger Bauernschlacht
-Tonale-Offensive;Unternehmen Lawine
-Maioffensive;Frühjahrsoffensive;Südtiroloffensive
-zweiter Italienischer Unabhängigkeitskrieg;Sardinischer Krieg
-zu Tal;bergab
-Quantor;Quantifikator
-Quantorenlogik;Prädikatenlogik
-Khoi;Hottentotten (abwertend);Khoekhoen;Khoikhoi
-Existenzquantor;Partikularquantor
-Allquantor;Universalquantor
-Limburgisch (veraltet);Südniederfränkisch
-Simbirsk (bis 1924) (veraltet);Uljanowsk
-Barbarossadenkmal;Kyffhäuserdenkmal;Kaiser-Wilhelm-Denkmal
-Panthera uncia (zool.) (fachspr.);Schneeleopard (Hauptform);Irbis
-Bengal-Katze;Leopardette
-Bengalkatze;Leopardkatze
-abhaltend;prohibitiv;verhindernd;unterbindend
-Omnipotenz;Allmacht;Allmächtigkeit
-Unterstützungsleistung;Subsidium
-Neu-Holland;Niederländisch-Brasilien
-Spanisch-Niederländischer Krieg;Achtzigjähriger Krieg
-Käsekuchen;Quarktorte (schweiz.);Quarkkuchen;Topfenkuchen (österr.)
-Karge;Unruhstadt;Kargowa;Kargowo
-Hermannstadt;Sibiu (rumänisch)
-Windau;Ventspils (lettisch)
-Großer Friedrichsgraben (bis 1945) (veraltet);Polesski Kanal
-Aromunisch;Mazedorumänisch
-Grauwerker (veraltet);Wildwerker (veraltet);Buntfutterer (veraltet);Pelzer (veraltet);Kürschner (Hauptform)
-Schwelbrand;Mottbrand (schweiz.)
-Domäne;Gut;Gutshof
-Kolon (fachspr.);Colon (lat.);Grimmdarm
-Intestinum crassum (lat.);Dickdarm
-Verdauungsapparat;Apparatus digestorius (fachspr., lat.);Verdauungstrakt
-Mastdarm;Schlackdarm (norddeutsch);Rektum
-Edaphologie;Bodenkunde;Bodenwissenschaft;Pedologie
-Umweltbeobachtung;Umweltmonitoring
-Lithium-Ionen-Akkumulator;Lithium-Ionen-Akku;Li-Ionen-Akku
-Patron (schweiz.);Schirmherr;Protektor
-Dada;Dadaismus
-EU-Parlament;Europäisches Parlament;Europaparlament
-Unitas Fratrum (lat.);Herrnhuter Brüdergemeine;Erneuerte Brüder-Unität;Evangelische Brüder-Unität
-Höckerschreibweise;Binnenversalie;Camel-Case (fachspr., engl.);Binnenmajuskel;Binnenversal
-Gefilde;(schöne) Landschaft
-Turawa-Stausee;Hitlersee (ugs.)
-Chorea major Huntington;Huntingtonsche Chorea;großer Veitstanz (veraltet);Chorea major (veraltet);erblicher Veitstanz;Chorea Huntington;Veitstanz (veraltet);Huntington-Chorea;Huntington-Krankheit
-Schütze;Sagittarius (lat.)
-Steinbock;Capricornus (lat.)
-Aquarius (lat.);Wassermann
-Pisces (lat.);Fische
-Widder;Aries (lat.)
-Stier;Taurus (lat.)
-Zwillinge (Sternbild);Gemini (fachspr., lat.)
-Krebs;Cancer (lat.)
-Löwe;Leo (lat.)
-Jungfrau;Virgo (lat.)
-Skorpion;Scorpio (lat.)
-Andengruppe (veraltet);Andengemeinschaft;Andenpakt (veraltet)
-al-Ain;Gartenstadt des Arabischen Golfs (ugs.)
-Fertiggericht;Convenience Food (fachspr.);Convenience-Lebensmittel (fachspr.);Fertigmahlzeit
-Ortsname (Hauptform);Örtlichkeitsname (fachspr.);Toponym (fachspr., linguistisch);Ortseigenname;Ortsbezeichnung
-Toponymik;Ortsnamenforschung;Ortsnamenkunde;Toponymie;Toponomastik
-apperzipieren;(bewusst) wahrnehmen
-Amtsanwärter;Prätendent
-Iranische Sowjetrepublik;Persische Sozialistische Sowjetrepublik;Sowjetrepublik von Gilan
-Rätedemokratie;Räterepublik;Rätediktatur
-Münchner Räterepublik;Bayerische Räterepublik
-Geschwindigkeitsregelanlage;Tempomat
-Kunstherz;Herzimplantat;künstliches Herz
-taiwanisch;taiwanesisch
-Zecke;Blutsauger (ugs.)
-Sprengmeister (ugs.);Sprengbefugter (österr.);Schießberechtigter;Sprengberechtigter
-Unternehmen Weserübung;Fall Weserübung
-Operation Peking;Peking-Plan
-negative Risikoauslese;Negativauslese;Negativselektion;Antiselektion (bei Lebensversicherungen);Gegenauslese;adverse Selektion
-Zitronenproblem;Saure-Gurken-Problem
-Agenturtheorie;Prinzipal-Agent-Theorie;Prinzipal-Agenten-Theorie
-Kyrilliza;kyrillisches Alphabet;Asbuka
-Buchstabenschrift;Alphabetschrift;alphabetische Schrift
-Wonneproppen (ugs., Hauptform);Knubbel (ugs., fig., norddeutsch);dickes Kleinkind
-unverwechselbar;unvergleichlich (geh.);nicht zu verwechseln;klar erkennbar;unverkennbar
-Indult;Gnadenerweis
-schotterloser Oberbau;feste Fahrbahn
-Gnocchi;Nocken;Nockerln
-unerledigte Angelegenheit;Pendenz (schweiz.)
-Hustenbonbon;Halsbonbon;Eukalyptusbonbon
-befriedetes Oman;Vertragsoman;Piratenküste;Vertragsküste;Seeräuberküste
-Shariqah;Schardscha
-Falkner;Beizjäger
-Chagos-Archipel;Tschagos-Archipel
-Chagossianer;Chagos-Insulaner;Sagosien;Chagossier
-Rodrigues;Rodriguez
-Tucheler Heide;Tuchler Heide (veraltet);Heidekraut (ugs.);Tuecheler Heide (veraltet)
-Kreisau;Creisau (bis 1930) (veraltet)
-Pommes frites mit Ketchup und Mayonnaise;Pommes rot-weiß (ugs.);Pommes Schranke (ugs.)
-Doppelzentner;100 kg
-Boskop;Boskoop
-Raummeter;Ster
-Rudolf Caracciola;Karratsch (ugs.)
-Grunewaldstadion (veraltet);Deutsches Stadion;Kaiser-Wilhelm-Stadion (veraltet)
-Hans im Glück (ugs.);Hans Herrmann
-7. Österreichischer Türkenkrieg;Russisch-Österreichischer Türkenkrieg (1736-1739);4. Russischer Türkenkrieg
-Osmanisches Reich (19. Jahrhundert);kranker Mann von Europa (ugs.);kranker Mann am Bosporus (ugs.)
-Ursa Minor (lat.);Kleiner Bär;Kleiner Wagen
-Führungsriege;Führung;Führungsteam;Führungscrew;Leitung;Führungsmannschaft;Spitze
-Finanzierbarkeit;Bezahlbarkeit
-Unverträglichkeit;Inkompatibilität;Unvereinbarkeit
-granulare Materie;Granulat;granulares Medium
-konzeptualisieren;entwerfen;gestalten
-lebensmüde (ugs.);selbstmordgefährdet;suizidgefährdet (Hauptform);suizidär (fachspr.);lebensüberdrüssig;suizidal (fachspr.);suizidal (med.) (fachspr.);todessehnsüchtig (geh.)
-Selbstmörder;Suizidant;Suizident
-Aufmüpfigkeit;Unbotmäßigkeit;Gehorsamsverweigerung
-Kohäsion;Zusammenhangskraft
-Kapillarität;Kapillareffekt
-Choke (ugs., engl.);Starterklappe
-sprechmotorische Störung (fachspr.);Dysarthrie;Sprechbewegungsstörung (fachspr.);Dysarthrophonie (fachspr.)
-Molankegel;Verkehrshütchen;Verkehrsleitkegel;Leitkegel (fachspr.);Haberkornhütchen (österr.);Lübecker Hut;Pylon;Lübecker Hütchen;Verkehrstöggel (schweiz.)
-Bystrica;Bistritz;Vydrica (slowakisch);Bistritza;Weidritz;Wödritz
-Burg Pressburg (veraltet);Bratislavaer Burg;Pressburger Burg (veraltet);Burg Bratislava
-Mähren;Mährer
-Sudetenschlesien;Tschechisch-Schlesien;Mährisch-Schlesien
-Martinsdom;Kathedrale des Heiligen Martin
-Holitsch;Weißkirchen (veraltet)
-Thebener Burg;Burg Theben
-Austrien;Austrasien
-Fränkisches Reich;Frankenreich
-Neustria;Neustrien
-Ungarische Pforte (veraltet);Bratislavaer Pforte;Thebener Pforte;Hainburger Pforte
-Komitat Bratislava;Pressburger Gespanschaft;Bratislavaer Gespanschaft;Komitat Pressburg
-Mediatisierung;Mittelbarmachung
-Schlacht bei Ostrach;Schlacht von Ostrach
-Friedeck-Mistek;Friedek-Mistek
-Konferenz der 21 Nationen;Pariser Friedenskonferenz 1946
-Bibelwissenschaftler;Exeget;Fachmann für Bibelauslegung
-Abgötterei;Bilderverehrung;Götzendienst;Götzenverehrung;Bilderanbetung;Idolatrie
-Poppschutz;Popschutz;Plopschutz;Popkiller
-Explosiv (veraltet);Plosiv;Explosivlaut (veraltet);Plosivlaut
-Okklusiv;Verschlusslaut;Okklusivlaut;Klusil
-Spirans;Spirant;Reibelaut;Engelaut;Konstriktiv;Sibilant;Frikativ
-Näherungslaut;Approximant
-Laterallaut;Lateral
-Injektiv;Klicklaut;Schnalzlaut;Schnalz;Klick
-Affrikata;Affrikat;Affrikate
-Allpass;Allpassfilter
-Nahheitseffekt;Proximity-Effekt (fachspr.);Naheffekt;Nahbesprechungseffekt
-Lateral;Rätselkrimi;Ja-Nein-Rätsel
-Schriftsetzer;Setzer
-Mörta (veraltet);Meurthe (franz., Hauptform);Mörthe;Murta (keltisch)
-Via Ferrata (ital.);Klettersteig
-Befert (veraltet);Beffert (veraltet);Belfort
-#;Rautenzeichen;Gartenzaun (ugs.);Lattenzaun (ugs.)
-Kelster;Kelsterbach
-Marinestation;Reichskriegshafen
-Externalität;externer Effekt
-Netzeffekt;Netzwerkexternalität;Netzwerkeffekt
-Brescia;Wälsch-Brixen (veraltet)
-Göttervater;Zeus (griechisch);Jupiter (römisch)
-Poseidon (griechisch);Gott des Meeres;Neptun (römisch)
-Hera (griechisch);Iuno (römisch);Familien-Göttin
-Demeter (griechisch);Ceres (römisch)
-Apollo (römisch);Apollon (griechisch)
-Diana (römisch);Artemis (griechisch)
-Athene (griechisch);Minerva (römisch)
-Dionysos (griechisch);Bacchus (römisch)
-Vesta (römisch);Hestia (griechisch)
-Dispater (lat., römisch);Dis Pater (lat., römisch);Hades (griechisch);Gott der Unterwelt;Dis (lat., römisch);Pluto (römisch)
-Proserpina (römisch);Persephone (griechisch)
-Herkules (römisch);Herakles (griechisch)
-Iuventas (römisch);Juventas;Göttin der Jugend;Hebe (griechisch)
-Nike (griechisch);Siegesgöttin;Victoria (römisch)
-Victoria;Victoria Rabat
-Viktoriastadt;Victoria
-Durban;Port Natal (veraltet)
-Jünger;einer der Zwölf;Apostel
-Jakobus, Sohn des Alphäus;Jakobus der Jüngere
-Schichtvulkan;Kegelvulkan;Stratovulkan
-Hausautomatisierung;Hausautomation;Heimautomation
-Utraquisten;Kalixtiner;Calistiner;Calixtiner
-Strzibrnitz;Silbersfeld
-Hussiten;Bethlehemiten
-Brüder-Unität;Mährische Brüder;Böhmische Brüder
-Ferro (veraltet);El Hierro;Isla del Meridiano
-Markow-Prozess;Markow-Kette
-Eltanin;Etamin;Ettanin
-Altukrainisch;Ruthenisch;Altweißrussisch;Westrussisch (veraltet);Russinisch
-Sehnen-Tangenten-Satz;Sekanten-Tangenten-Satz
-Frankoprovenzalische Sprache;Franko-Provenzalische Sprache;Frankoprovenzalisch;Franko-Provenzalisch (Hauptform);Arpitanisch;Arpitanische Sprache
-Vojvodina-Russinisch;Ruthenisch;Batschka-Russinisch;Pannonisch-Russinisch;Südrussinisch;Jugoslawo-Russinisch
-Slavonien;Slawonien
-Radmaker (ugs., niederdeutsch);Stellmacher (im Norden);Rädermacher;Wagner (im Süden);Radmacher;Achsmacher
-Tschalositz;Czalositz
-Limski kanal;Limbucht;Limfjord;Limski fjord
-Ländi (regional, schweiz.);Anlegeplatz;Ländte (regional, schweiz.);Lände;Schifflände (schweiz.)
-Nordjütische Insel;Vendsyssel-Thy
-Winland (veraltet);Vinland
-Warschauer Pakt;Warschauer Vertrag (offiziell);Warschauer Vertragsorganisation;Ostblock (ugs., abwertend)
-Kanonenkreuz;Templerkreuz;Mantuanisches Kreuz;Tatzenkreuz (Hauptform);ausgerundetes Kreuz
-Murmanskbahn;Murmanbahn
-Prankenkreuz;Christusordenkreuz
-Wiener Wasser (veraltet);Donaukanal;Kleine Donau
-Operation Frühlingserwachen;Plattenseeoffensive
-Vatersname;Patronym
-Metronym;Muttername;Matronym (fachspr.)
-Wortbestandteil (ugs.);Monem (fachspr.);Wortteil (ugs.);Plerem (fachspr., selten);Morphem (fachspr.)
-Grundformenreduktion;Normalformenreduktion;Stammformreduktion;Stemming
-Tullner Becken;Tullnerfeld
-Medizinischer Fachangestellter;Arzthelfer
-Tiermedizinischer Fachangestellter;Tierarzthelfer
-Zahnmedizinischer Fachangestellter (männl.);Stomatologische Schwester (DDR, veraltet, weibl.);Zahnmedizinische Fachangestellte (weibl.);Zahnarzthelfer (männl., veraltet);Dentalassistent (schweiz.)
-Egerbecken;Egerer Becken
-Kamineffekt;Naturzug
-Versalien-I;Binnen-I;Majuskel-I
-Staffelgiebel;Katzentreppen;Stufengiebel;Treppengiebel
-Helseburch (plattdeutsch);Helsingburg (veraltet);Helsingborg;Hälsingborg (historisch)
-Weiden (veraltet);Udine
-Furlanisch;Friulisch;Friaulisch
-Welsch-Metz;Mezzolombardo
-Wiesenthein (veraltet);Vicenza;Cimbria (veraltet)
-italienisches Athen (ugs.);Florenz;Firenze (ital.)
-Wasgenwald (veraltet);Vogesen;Wasigenwald (veraltet);Wasgauen (veraltet)
-Nancy;Nanzig (ungebräuchlich)
-Windischgrätz;Windischgraz;Slowenisch Graz (ugs.)
-Vinschgaubahn;Vinschgerbahn
-Äolische Inseln;Liparische Inseln
-Gardasee;Gartsee (veraltet)
-Kampanischer Archipel;Parthenopäische Inseln;Neapolitanischer Archipel
-Ingenieur-Informatik;Maschinenbauinformatik
-Annexsteuer;Zuschlagsteuer
-scheitrechter Bogen;Horizontalbogen
-pfälzische Maximiliansbahn;Maxbahn (ugs.)
-salische Franken;Salfranken;Westfranken;Salier
-Sachs;Sax;Skramasax
-(unerschöpfliche) Geldquelle;Dukatenesel (ugs.)
-Jakobs-Drehgestell;Jakobsachse;Jakobsgestell
-Trippelschritt;Tappser;kleiner Schritt
-Postfixnotation (fachspr.);UPN (fachspr., Abkürzung);RPN (fachspr., Abkürzung, engl.);Umgekehrte Polnische Notation (fachspr.)
-(negativ) prophezeien;herbeireden;beschreien;unken (ugs.)
-Perpetuität;ewige Rente
-Avionik;Flugzeugelektronik
-ruhmlos;schmachvoll;wenig ruhmreich;unrühmlich;kläglich;blamabel;erbärmlich;schmählich
-Schlaz;Schlatz
-Krummsäbel (ugs.);Scimitar;Krummschwert (unfachmännisch) (ugs.);Sarazenensäbel (ugs.);Türkensäbel (ugs.);Szimitar;Schimitar;Mameluckensäbel (ugs.)
-Obödienz;Großloge;Großorient;Obedienz
-kombinierter Verkehr;gebrochener Verkehr
-unimodal;eingipflig
-bimodal;zweigipflig
-multimodal;mehrgipflig
-Kyrtosis;Wölbung;Kurtosis
-leptokurtisch;hochgipflig
-flachgipflig (fachspr.);platykurtisch (fachspr.)
-virtuelle Autopsie;Virtopsie
-Scharfenbergkupplung;Schaku (Abkürzung)
-Tunnel Himmelberg;Himmelbergtunnel
-Brückenkopf;Brückenschanze
-Ausschachtung;Exkavation;Unterkellerung
-Bastion;Bastei (österr.)
-Kaponniere;Grabenwehr;Grabenkoffer
-Festung Petersberg;Zitadelle Petersberg
-Formschneider;Xylograph;Xylograf
-Welschbern (veraltet);Bern (veraltet);Verona
-Konzil von Verona;Synode von Verona
-Konzil;Synode
-Kanaresisch;Kannada
-Bézique;Bésigue;Bésique;Bézigue
-Drei-Sektoren-Hypothese;Fourastie-Hypothese;Drei-Sektoren-Entwicklungstheorie
-Schiffsbohrwurm;Schiffsbohrmuschel;Holzbohrwurm
-Löwenrepublik;Republik Venedig;Markusrepublik
-Depression (fachspr.);Senke
-Aggradation;Anlandung
-Quadra (veraltet);Vancouver Insel
-Zahnriemen;Synchronriemen
-Ostlandkreuz;Kreuz des deutschen Ostens
-Altbayern;Baiern;Altbaiern
-Kammergut;Kameralgut;Tafelgut
-Staatsgut;Staatsdomäne
-Königsgut;Krongut;Krondomäne;Kronland
-Tagesbruch;Tagbruch;Stolleneinbruch;Tagebruch
-Kartoffelkrieg (ugs., preußisch);Zwetschgenrummel (ugs., österr.);Bayerischer Erbfolgekrieg
-Schamhaftigkeit;Betretenheit
-Heuristik;proaktive Erkennung
-Perle der Karibik (ugs.);Zuckerinsel (ugs.);Republik Kuba;Kuba
-Regionalismenwörterbuch;Mundartwörterbuch;Idiotikon
-Gabeltier (veraltet);Kloakentier
-gleich lang dauernd;isochron
-Badekappe;Schwimmhaube;Badehaube;Schwimmkappe;Bademütze
-Allmende;gemeine Mark (fachspr., historisch)
-Allmendegut;Quasikollektivgut;unreines öffentliches Gut
-Allmendeproblematik;Tragik der Allmende;Allmendeklemme
-Moskau;Moskwa;Moskau-Fluss (veraltet)
-Insurrektionskrieg;Insurrektion
-Faraday-Käfig;Faradayscher Käfig
-Kanal Elbing-Osterode;Oberländischer Kanal
-St. Veit am Pflaum (veraltet);Rijeka (kroatisch);St. Veit am Flaum (veraltet)
-(sich) wenden an (in einer Angelegenheit);(ein) Anliegen haben;erbitten;vorstellig werden (bei jemandem in einer Angelegenheit);(ein) Anliegen vortragen;(irgendwo) vorsprechen (wegen)
-so lieb sein (und);(sich) erbarmen (und / zu);freundlicherweise (tun);so freundlich sein (zu);geruhen (veraltet);(die) Güte haben (und / zu);so freundlich sein (und / zu);(sich) herablassen;so gnädig sein (zu);so nett sein (zu);netterweise (tun);die Freundlichkeit besitzen (und / zu);belieben zu (geh., veraltet);(sich) bemüßigt fühlen (geh.);(sich) bereitfinden;(sich) bemüßigt sehen (geh.);(sich) herbeilassen
-Konkomitanz;Kookkurrenz
-dünn;durchsichtig;ohne Tiefgang;inhaltsleer;oberflächlich;vordergründig;gehaltlos
-Gehalt;Gedankenreichtum;Tiefgründigkeit;Substanz;Gedankenfülle;Gedankentiefe;Tiefgang
-stilles Vergnügen;Behagen;wohliges Gefühl der Zufriedenheit
-Belieben;Geneigtheit;Ermessen
-Teleprompter;Prompter
-Gästezimmer;Fremdenzimmer
-Vagheit;Undurchschaubarkeit;Ungenauigkeit;Unübersichtlichkeit;Unbestimmtheit;Unklarheit
-blühen;voll sein von;strotzen
-Thalassämie;Mittelmeeranämie
-Drepanozytose (fachspr.);Sichelzellenanämie;Sichelzellkrankheit;Sichelzellanämie
-Wettbüro;Buchmacher
-trennen;auflösen;dissoziieren
-weit;groß;makro
-Herz...;Kardio...
-ad honorem (lat.);zu Ehren...;ehrenhalber
-in abstracto (lat.);ganz allgemein
-in flagranti (lat.);auf frischer Tat
-in memoriam (lat.);zur Erinnerung
-außer Gefahr;in Sicherheit;in salvo (geh., bildungssprachlich, lat., veraltet)
-loco citato (lat.);an angeführter Stelle
-im Auftrag;im Namen;in nomine
-Erdkreis;orbis terrarum (lat.)
-Ave (lat.);sei gegrüßt
-Betrachtungsweise außerhalb einer anderen Position;Meta-Position
-bedingungslos;ohne Vorbedingung;rückhaltlos;rettungslos (verliebt);uneingeschränkt;vorbehaltlos;auf Gedeih und Verderb (fig.);ohne Wenn und Aber
-Pseudo-Satellit;Pseudolit
-konsensuell;gleichsinnig;im gleichen Sinne;in gleicher Art und Weise
-US-Dollar;USD (Abkürzung);Greenback (ugs., engl.)
-in dubio pro reo (lat.);im Zweifel für den Angeklagten
-wenn zwei sich streiten, freut sich der Dritte (Sprichwort, Hauptform);duobus litigantibus tertius gaudet (Sprichwort, lat.)
-ausdrücklich;mit genau den Worten;explizit;wortwörtlich;expressis verbis (lat.);Wort für Wort
-Verhandlung gleichberechtigter Gesprächspartner;runder Tisch
-abschließend besprochen;abgeräumt (Thema) (ugs., salopp);fertig geworden;zu Ende gebracht;geklärt;vorüber;(etwas) fertig haben (ugs.);gegessen (ugs.);fertiggestellt;abgetan;abgehakt (ugs.);getan (ugs.);durch (mit) (ugs.);vollbracht (geh.);abgeschlossen;Das hätten wir. (ugs., Spruch);vollzogen;perfekt;unter Dach und Fach (sein) (ugs., fig.);vollendet;vom Tisch (sein) (ugs., fig.);weg (ugs.);stehen;fertig (sein mit);geschafft haben (ugs.);abgefrühstückt (ugs., salopp);in Sack und Tüten sein (ugs., fig.);erledigt;Das wäre geschafft. (ugs., Spruch);(die) Kuh ist vom Eis (ugs., fig.);(etwas) steht. (ugs.);in trockenen Tüchern (fig.)
-nicht lange warten;nicht lange überlegen;kurzen Prozess machen (ugs.);nicht zögern;kurze Fünfzehn machen (ugs.);schnell bei der Hand sein (mit);kurze Fuffzehn machen (ugs.)
-(ein) Aufreger sein;Wirbel machen;(die) Gemüter erregen;Kreise ziehen;die Wellen der Empörung schlagen hoch;(jemandes) Blut in Wallung bringen (ugs.);hohe Wellen schlagen;für Aufregung sorgen;(einen) Sturm der Entrüstung auslösen;(die) Gemüter erhitzen (ugs.);Wind machen (fig.);einschlagen wie eine Bombe (ugs.);(die) Nerven liegen blank (ugs.)
-Nachahmer finden;Schule machen;nachgeahmt werden;als Vorbild dienen
-einschlagen wie eine Bombe;für Aufregung sorgen;Aufsehen erregen;(hohe) Wellen schlagen (ugs., fig.);für Schlagzeilen sorgen;Schlagzeilen machen (ugs.)
-selten erscheinen;selten kommen (Hauptform);nur gelegentlich aufkreuzen (ugs.);selten auftauchen (ugs.);(ein) seltener Gast sein (ironisierend);nur jedes dritte Mal kommen (variabel);man sieht ihn / sie hier selten;(sich) rarmachen (ugs.);selten zu sehen sein
-ein sehr gutes Geschäft machen;ein Bombengeschäft machen (ugs.)
-Zeit schinden;faulenzen;Zeit verschwenden;Laumaloche machen (ugs.)
-obdachlos sein;auf der Straße leben;keinen festen Wohnsitz haben (Amtsdeutsch);auf Trebe sein (szenesprachlich) (ugs., Jargon);auf der Straße sitzen (ugs.);nicht sesshaft sein;Platte machen (szenesprachlich) (ugs., Jargon)
-abrechnen;Abschluss machen (ugs.);(einen) Kassensturz machen
-(sich) um jemandes Gunst bemühen;eine Liebesbeziehung mit jemandem anstreben;jemandem den Hof machen (ugs.)
-(sich) gut machen (ugs.);gut dastehen;laufen (es) (ugs.);gut aussehen (ugs.);(sich) machen (ugs.);(sich) gut entwickeln (Hauptform);(einen) guten Lauf haben;gut verlaufen;gut laufen (ugs.);auf einem guten Weg sein (Jargon, distanzsprachlich, verhüllend)
-jemanden lächerlich machen;jemanden zum Narren machen (ugs.)
-Rosenheimer Kurve;Rosenheimer Schleife
-Brücke der Deutschen Einheit;Saalebrücke Rudolphstein
-Interpellationsrecht;Fragerecht
-einen auf gut Wetter machen (ugs.);einen auf Schönwetter machen (ugs.)
-(sich) erregen;aus der Haut fahren (fig.);in Wallung geraten;(sich) entrüsten;sich aufregen (Hauptform);in Wallung kommen;aufbrausen (fig.);in Wut geraten;(sich) ereifern;einen Tanz aufführen (ugs., fig.);(sich) empören;die Wände hochgehen (ugs., fig.);wütend werden;(sich) echauffieren (geh., franz.)
-Taubdeutscher;Walddeutscher
-technikbegeistert;technophil
-Technophilie;Technikbegeisterung
-einen Haschmich haben (ugs.);seine fünf Sinne nicht beieinander haben;einen Vogel haben (ugs., fig.);weiß nicht, was er daherredet (ugs.);einen Sprung in der Schüssel haben (ugs., fig.);den Schuss nicht gehört haben (ugs., fig.);nicht ganz bei Trost sein (ugs.);einen kleinen Mann im Ohr haben (fig., veraltend);nicht ganz dicht sein (ugs.);spinnen (Hauptform);einen an der Mütze haben (ugs.);einen Klamsch haben (ugs., österr.);einen feuchten / nassen Hut aufhaben (ugs., fig.);einen Schlag haben (ugs.);(en) Pinn im Kopp haben (ugs., norddeutsch);einen Schlag weg haben (ugs.);einen Ecken abhaben (ugs., schweiz.);nicht alle Latten am Zaun haben (ugs., fig.);(den) Verstand verloren haben (ugs., fig., übertreibend);einen an der Murmel haben (ugs.);einen Pecker haben (ugs., österr.);einen weichen Keks haben (ugs.);(ein) Ei am Wandern haben (derb, regional);mit jemandem ist kein vernünftiges Wort zu reden;nicht alle Tassen im Schrank haben (ugs., fig.);nicht ganz sauber ticken (ugs.);ein Rad abhaben (ugs.);einen Piepmatz haben (ugs., fig.);nicht richtig ticken (ugs.);einen Stich haben (ugs.);nicht ganz frisch in der Birne (sein) (ugs.);einen an der Waffel haben (ugs.);leicht verrückt sein;verpeilt sein (ugs.);einen Dachschaden haben (ugs., fig.);eine Schraube locker haben (ugs., fig.);einen an der Klatsche haben (ugs.);sie nicht alle haben (ugs.);einen Hau (weg) haben (ugs.);(jemandem haben sie) ins Gehirn geschissen (derb);mit dem Klammerbeutel gepudert (worden) sein (ugs., fig.);einen Piep haben (ugs.);einen Klopfer haben (ugs., österr.);(bei jemandem ist) eine Schraube locker (ugs., fig.);nicht ganz richtig im Oberstübchen sein (ugs., fig.);verstrahlt (sein) (derb);(wohl) einen Sonnenstich haben (ugs., fig.);einen Huscher haben (ugs.);die Kappe kaputt haben (ugs.);einen Spleen haben (ugs.);(jemandem) brennt der Kittel (fig.);einen Triller unterm Pony haben (ugs., scherzhaft);gaga sein (ugs.);neben der Spur (sein) (ugs., fig.);eine Macke haben (ugs.);eine Meise haben (ugs.);einen Sockenschuss haben (ugs.);einen Schaden haben (ugs.);nicht ganz hundert sein (ugs., schweiz.);einen Knacks weghaben (ugs.);nicht ganz richtig im Kopf sein (ugs.);einen Knall haben (ugs.);einen Schatten haben (ugs.);einen Hammer haben (ugs.);(jemandem) geht's wohl nicht gut (ugs.);nicht ganz bei Verstand sein;einen Schuss haben (ugs.)
-nicht angemessen honoriert werden;nur einen warmen Händedruck bekommen (ugs.);nur einen feuchten Händedruck bekommen (ugs.)
-zweifelhaft;mit üblem Beigeschmack (ugs.);unschön;üblen Nachgeschmack hinterlassend (ugs.);anrüchig;fragwürdig
-Glupschaugen machen (ugs.);starr mit großen Augen gucken;neugierig gucken
-tun / machen können, was man will (ugs.);etwas mehrmals erfolglos versuchen
-weitergereicht werden;die Runde machen (ugs.);von Hand zu Hand gehen;kreisen (lassen);herumgehen (lassen)
-eine Sache einer wichtigen Prüfung unterziehen;eine Nagelprobe machen (ugs.);etwas auf Tauglichkeit prüfen
-demoralisieren;kleinkriegen;erniedrigen;jemanden fertig machen (ugs.)
-sagen, was andere gern hören;schöne Worte machen (ugs.)
-angeben;(seine) Show abziehen (ugs.);(sich) in den Vordergrund schieben;(sich) wichtig tun (ugs.);(die) Aufmerksamkeit auf sich ziehen;(sich) aufspielen;(sich) wichtig machen (ugs.);(sich) in Szene setzen;(sich) inszenieren (als) (fig.);(sich) (selbst) darstellen;den großen Auftritt lieben (fig.);posen (Neologismus);(sich) in den Vordergrund spielen;aufzufallen versuchen (ugs.);versuchen, aufzufallen (ugs.);(sich) produzieren
-(sich) ausbreiten (ugs.);besetzt halten;(sich) dickmachen (ugs.);(sich) (zahlreich) versammeln;(sich) breit machen (ugs.);in Beschlag nehmen;mit Beschlag belegen;Platz beanspruchen;besetzt haben;(sich) breitmachen;belagern
-blauen Montag machen (ugs.);der Arbeit montags fernbleiben
-jemanden streng behandeln;jemanden zur Minna machen (ugs.);jemanden scharf rügen
-(sich) eine Meinung bilden;(sich) schlaumachen (ugs.);(sich) ein Bild machen (ugs.);(sich) informieren;etwas überprüfen;etwas kontrollieren;(sich) orientieren
-strahlendes Lächeln zeigen;auf Strahlemann und Söhne machen (ugs.)
-(einer Sache) keine Träne nachweinen;(etwas ist) kein großer Verlust (ugs.);heilfroh sein (dass);(bestimmt) nicht traurig sein (dass / wenn) (ugs.);drei Kreuze machen (ugs., fig.);gut verzichten können (auf);froh sein, dass etwas vorbei ist
-jemanden zum Kasper machen (ugs.);jemanden lächerlich machen
-im Schlechten noch Gutes finden;aus der Not eine Tugend machen (ugs.)
-etwas Ansprechendes sehen;Stielaugen bekommen (ugs.);überrascht sein
-unnötig für Aufregung sorgen;sich (nicht) verrückt machen (lassen) (ugs.);(Leute) verrückt machen (ugs.);(überflüssigerweise) Angst einjagen;die Pferde scheu machen (ugs., fig., variabel);Wellen auf den Pudding hauen (ugs., fig.)
-eine üble Sache unterbinden;das böse Spiel beenden;dem Spuk ein Ende setzen (ugs.)
-summa cum laude (lat.);mit höchstem Lob
-manu scriptum (lat.);mit der Hand geschrieben
-manus manum lavat (lat.);unter einer Decke stecken (ugs., fig.);(eine) Win-win-Situation (sein);man hilft sich gegenseitig zu beiderseitigem Vorteil;klüngeln;eine Hand wäscht die andere (ugs., fig.)
-kungeln;(etwas) auskungeln;Vetternwirtschaft betreiben;heimliche Absprachen treffen;unlautere Geschäfte machen;ausdealen (ugs.);klüngeln
-das Thema wechseln (Hauptform);eine andere Platte auflegen (ugs., fig.);(...) anderes Thema (...)
-bestechlich sein;eine hohle Hand machen (ugs.)
-(sich) einer Sache annehmen;(sich) um etwas kümmern;(das) Nötige veranlassen (variabel);(etwas) regeln;(die) Verantwortung übernehmen (für);(eine) Sache in die Hand nehmen (ugs.);(eine) Aufgabe übernehmen;(etwas) managen
-geschickt sein;es gut beieinander haben (ugs.);eine glückliche Hand haben (ugs.);erfolgreich sein
-auf die Tagesordnung bringen;etwas anhängig machen (ugs.)
-fuffzehn (ugs.);fünfzehn
-etwas auf Lager haben;etwas im Köcher haben (ugs.)
-einen Wunsch haben;ein Anliegen haben;etwas auf dem Herzen haben (ugs.)
-(etwas) in Reserve haben;(noch etwas) in der Pipeline haben (ugs., Neologismus);(etwas) in petto haben (ugs.);ein Ass im Ärmel haben (ugs.);da kommt demnächst noch etwas (ugs., salopp)
-etwas zur Verfügung haben;etwas bei der Hand haben (ugs.);etwas greifbar haben
-(etwas) geplant haben;(etwas) bereit haben;(auf etwas) vorbereitet sein;(etwas) in petto haben (ugs.);(etwas) in der Hinterhand haben (ugs.);(etwas) auf der Pfanne haben (ugs.);(etwas) auf Lager haben (ugs.)
-(sich) etwas vorstellen;(etwas) planen;(etwas) vor Augen haben (ugs.);(etwas) im Sinn haben;(etwas) vorhaben
-etwas begriffen haben;etwas intus haben (ugs.)
-(ein) Foto gemacht haben (von);(etwas) im Kasten haben (ugs.);auf Zelluloid gebannt;(eine) Aufnahme abgeschlossen haben
-etwas instinktiv spüren;etwas im Gefühl haben (ugs.)
-verantwortlich sein;eine Bürde tragen;verpflichtet sein;eingebunden sein;eine Last tragen;etwas Unangenehmes ertragen müssen;etwas an der Backe haben (ugs., fig.)
-etwas auswendig wissen;etwas im Kopf haben (ugs.)
-(den) entscheidenden Schritt nicht tun;vor etwas Angst haben;vor etwas Manschetten haben (ugs.);(sich) nicht heranwagen an;(sich) nicht herantrauen an;vor etwas zurückscheuen (Hauptform)
-(etwas) anvisieren;(etwas) anstreben;(etwas) erwägen;(etwas) vorhaben;(etwas) planen;(etwas) im Auge haben (ugs.)
-mit etwas rechnen können;etwas (Positives) zu erwarten haben;etwas in Aussicht haben (ugs.)
-an etwas gedreht haben (ugs.);etwas manipuliert haben
-mehrfach verurteilt (ugs.);(sich) (so) einiges geleistet haben (ugs.);(immer wieder) mit dem Gesetz in Konflikt gekommen;polizeibekannt (sein);(ein) alter Kunde (ugs., fig., ironisch);gerichtsbekannt (sein);ein (langes / umfangreiches / imposantes o.ä.) Vorstrafenregister haben;(etwas / so einiges) ausgefressen haben (ugs.);(etwas / einiges) auf dem Kerbholz haben (ugs.);(schon so einige) Dinger gedreht haben (ugs.);aktenkundig (fachspr.);nicht zum ersten Mal (wegen eines Delikts) vor Gericht stehen;gerichtsnotorisch (sein) (ugs.);auf die schiefe Bahn geraten (ugs.);vorbestraft (sein) (ugs.);(der Polizei / bei der Polizei o.ä.) einschlägig bekannt;kein unbeschriebenes Blatt (sein) (ugs.);dem Gericht (wohl)bekannt (sein)
-(für etwas) bekannt (sein);kein unbeschriebenes Blatt (sein) (ugs.)
-kein Freund von etwas sein (ugs.);etwas nicht mögen
-abzirkeln;bestimmen;abstecken;herausfinden;feststellen;orten;ausmachen;umgrenzen;ausloten;erkennen
-das Kind im Manne (ugs.);der Spieltrieb des Mannes
-wenn das Unglück bereits geschehen ist;wenn der Schaden bereits eingetreten ist;wenn es (bereits) zu spät ist;wenn das Kind in den Brunnen gefallen ist (ugs., fig.);wenn der Käse schon gegessen ist (ugs., fig.)
-ein Kind seiner Zeit (ugs.);von der Umwelt geprägt
-(sich) offenhalten;(sich) ausbitten;offenlassen;vorbehalten
-übertrieben vorsichtig;übervorsichtig;vorsichtiger als nötig
-Feingeist (ugs.);kultivierter (/ empfindsamer / gebildeter) Mensch
-Weisheit mit Löffeln gefressen haben (ugs.);klug tun;Weisheit mit Löffeln gegessen haben (ugs.)
-überaus dumm sein;Dummheit mit Löffeln gegessen haben (ugs.)
-konzessionieren;behördlich genehmigen
-(in einer Sache) hart bleiben (ugs.);keine Zugeständnisse (machen);(jemandem) nicht entgegenkommen (bei / in);stur bleiben (bei) (ugs.);kein Entgegenkommen zeigen
-(ein) breites Kreuz haben (ugs., fig.);(einen) breiten Rücken haben (ugs., fig.);hart im Nehmen (sein);belastbar sein;sturmerprobt (fig.);viel vertragen können
-betrunken sein;einen im Tee haben (ugs.);einen weg haben (ugs.);einen in der Krone haben (ugs.);einen sitzen haben (ugs.);einen in der Mütze haben (ugs.)
-(einen) Bombenerfolg haben (ugs.);sehr großen Erfolg haben
-benommen sein;unzurechnungsfähig sein;völlig daneben sein (ugs.);nicht mehr wissen, ob man Männlein oder Weiblein ist (ugs.);nicht mehr wissen, ob man Männchen oder Weibchen ist (ugs.);einen Blackout haben (ugs.);nicht mehr wissen, wo rechts und links ist;(völlig) verwirrt sein;nicht (ganz) auf der Höhe sein (ugs.);nicht mehr wissen, wo vorne und (wo) hinten ist;nicht wissen, wo oben und (wo) unten ist (ugs.);(völlig / komplett) neben der Kappe sein (ugs.)
-(sich) nicht aufraffen können (ugs.);einen Durchhänger haben (ugs.);schlapp sein;(sich) zu nichts aufraffen können (ugs.)
-Schwips haben (ugs.);leicht angetrunken sein
-guter Ruf (ugs.);hohes Ansehen;große Wertschätzung
-Kurzschluss haben;Kurzen haben (ugs.)
-Brummschädel haben (ugs.);Kopfschmerzen (nach Alkoholkonsum)
-sage und schreibe (ugs., Hauptform);man höre und staune (Redensart);so unglaublich das auch klingt;tatsächlich;echt (ugs.);man glaubt es kaum, aber;ungelogen (ugs.)
-(einen) Silberblick haben (ugs.);leicht schielen
-einen Haken haben (ugs.);einen Nachteil haben
-langen Arm haben (ugs.);großen Einfluss besitzen
-gemma! (ugs., bayr.);(und) ab die Luzie! (ugs.);(auf,) auf zum fröhlichen Jagen (ugs., Zitat);und ab! (ugs.);also los! (ugs.);dann wollen wir mal (ugs.);ran an den Speck! (ugs.);(jetzt aber) ran an die Buletten! (ugs.);los!;auf auf! (ugs.);los jetzt!;ab dafür! (ugs.);aufi! (ugs., süddt.);los geht's!;und dann gib ihm! (ugs.);auf geht's! (ugs., Hauptform);Leinen los (fig.);dann (mal) los! (ugs.);auf zu;Abmarsch!;an die Gewehre! (fig.);frischauf (geh., veraltend);auf gehts (ugs.);wohlan (geh., veraltend);pack ma's (ugs., österr.);(und) ab geht's (ugs.);dann lass uns! (ugs.);(und) ab die Post! (ugs.);alsdann;wir können! (ugs.);an die Arbeit!;pack mer's (ugs., süddt.);(na) denn man to (ugs., plattdeutsch);los (ugs.);(na) denn man tau (ugs., plattdeutsch);vorwärts!;Auf zu neuen Taten! (Spruch);allez hopp! (ugs., franz.);frisch ans Werk! (ugs.);(es) kann losgehen (ugs.);(na dann) rauf auf die Mutter (derb, salopp);und dann los
-unwahre Botschaft;Tartarennachricht (ugs.)
-projizieren;an die Wand werfen (ugs.)
-Schwimmbrille;Augenschutzbrille (fachspr.)
-Gerner (österr.);Kärnter;Beinhaus;Karner (österr.);Seelhaus;Ossarium (lat.);Ossuarium (lat.);Kerchel (schweiz.)
-oft besuchen;oft aufsuchen;(bei jemandem / irgendwo) ein und aus gehen (ugs.);(jemandem) die Bude einrennen (ugs.);ständiger Gast sein
-interindividuell;zwischen zwei (oder mehreren) Individuen
-Liutizen;Lutizen;Lutitzen;Luitizen
-valorisieren;(den) Wert steigern
-es jemandem leicht machen;jemandem etwas auf dem Silbertablett servieren (ugs.);verlockend präsentieren;verlockend anbieten
-wer auch immer;wer immer (...);egal wer;alle Welt;jedermann;alle;Jan und Jedermann (ugs.);jeder
-in Reinkultur;schlechthin;in ausgeprägter Weise;in (höchster) Vollendung;ausgesprochen;waschecht;wie es (er/sie) im Buche steht (fig.);in reinster Form;durch und durch;reinsten Wassers (geh., fig.);par excellence (geh., franz.)
-Devolution;Rückentwicklung
-Niederländisch-Französischer Krieg;Holländischer Krieg
-Schweizer Käse;Emmentaler
-am Mann bleiben (ugs.);Beziehung oder Kontakt beibehalten
-nichts drauf sagen (ugs.);nichts antworten;nichts erklären;Antwort schuldig bleiben (ugs.);nicht antworten;nichts darauf sagen
-Vietcong;Nationale Front für die Befreiung Südvietnams
-populär machen;verbreiten;unter die Leute bringen (ugs.);in Umlauf setzen;propagieren;popularisieren;bekannt machen
-voller Dankbarkeit;(jemandem) Dank wissen;(jemandem) verbunden;Dank schulden;dankbar (sein);von Dankbarkeit erfüllt;von Dank erfüllt
-Christusorden;Orden der Christusritter
-Ritterorden von Avis;Orden des heiligen Benedikt von Avis
-Mercedarier-Orden;Nolasker-Orden
-Hexarchie;Sechsherrschaft
-Großoffizier;Großkomtur
-Georgsorden;Hausritterorden vom Heiligen Georg
-Ordenskunde;Phaleristik
-Kollane;Collane
-Delisch-Attischer Seebund;Attisch-Delischer Seebund;Attischer Seebund
-öffentlich bekanntgeben;promulgieren
-aufstehen (ugs., regional);gähnen;weit geöffnet sein;klaffen;(weit) offen stehen (Hauptform);offen sein
-relativieren;einschränken;abschwächen;verwässern (fig.);abmildern
-noch nicht entschieden (sein);noch nicht ausgestanden (sein);Der Drops ist noch nicht gelutscht (ugs., Spruch);noch nicht vorbei (sein) (ugs.)
-Reiterkrieger;Ritter;Recke (ugs.);Krieger
-alles wie gewohnt;business as usual (engl.);alles geht seinen Gang;das Übliche;Tagesgeschäft;nach dem üblichen Verfahren;seinen gewohnten Gang gehen
-Exempel statuieren (ugs.);abschreckendes Urteil fällen
-Probe aufs Exempel (ugs.);Ausprobieren;Überprüfung
-Feingerätetechnik;Feinwerktechnik
-Lucas-Test;Lucas-Probe
-tertiär;aus drei bestehend
-Primärsektor;Urproduktion
-industrieller Sektor;Sekundärsektor
-Dienstleistungssektor;Tertiärsektor
-Informationssektor;Quartärsektor
-Kathodenzerstäubung;Sputtern
-tosend aufprallen;rauschen;branden;brechen
-alle Mittel ausschöpfen;alle verfügbaren Mittel einsetzen;alle Register ziehen (ugs.);alles Mögliche tun
-seien Sie aufrichtig (ugs.);lüg mich nicht an! (ugs.);jetzt mal ehrlich (ugs.);sag die Wahrheit;Ich frage Sie auf Ehre und Gewissen: ... (geh.);sei ehrlich (ugs.);Hand aufs Herz (ugs.);Hand aufs Herz und ehrlich gelogen! (ugs., Spruch, scherzhaft)
-zeigen, was eine Harke ist (ugs.);Stärke zeigen;auftrumpfen;energisch die Meinung sagen
-auf 180 sein;(jemandem) zürnen (dichterisch);so (+ Geste) eine Krawatte haben (ugs., scherzhaft);(einen) Rochus haben (auf) (ugs., regional);aufgebracht sein;vor Wut kochen;geladen sein;wütend sein (auf jemanden) (Hauptform);so (+ Geste) einen Hals haben (ugs.);sauer sein (auf jemanden / wegen etwas);eine Wut im Bauch haben;eine Wut haben (auf jemanden) (ugs.)
-testgesteuerte Programmierung;testgetriebene Entwicklung
-Väris (veraltet);Varese
-Bügelbrett;Bügeltisch
-Neandertaler;Homo neanderthalensis (fachspr.);Neanderthaler (veraltet)
-(etwas) gut über die Bühne bringen (fig.);gute Arbeit leisten (variabel);(etwas) richtig machen (variabel);(etwas) ordentlich machen (variabel);(einen) guten Job machen (variabel);seine Sache gut machen (variabel);(etwas) perfekt ausführen;(etwas) professionell machen
-aus Scheiße Geld machen (ugs.);Wertloses finanziell erfolgreich vermarkten;Nutzloses verkaufen
-Schwerter zu Pflugscharen machen (ugs.);(sich) dem Frieden verpflichten
-gelehrsam;lernfähig;verständig;begabt;hell;anstellig;gelehrig;aufnahmefähig;aufgeweckt
-seinen Mann stehen;bleiben;(sich) halten;standhalten;überdauern;(sich) gewachsen zeigen;überleben;durchhalten;weiterbestehen;erhalten bleiben;fortleben;dicke Bretter bohren (ugs., fig.);weiter bestehen;(sich) behaupten;fortbestehen;fortdauern;gewachsen sein
-überstehen;überdauern;(einem Angriff / Unwetter) widerstehen;stehen bleiben (Gebäude, Baum ...);nicht zerstört werden;(einer Belastung) standhalten
-vormalig;gewesen;einstig;seinerzeitig;einstmalig;alt;Alt-...;frühere(r);ehemalig;damalig (Hauptform);Ex-...;abgelöst
-aufschwellen;schwellen;aufschwemmen
-geschmacksarm;wie eingeschlafene Füße schmecken (ugs., sprichwörtlich);flau;öde;ohne Geschmack;lau;unaromatisch;fade;schal;fad;laff;labberig
-Unsinn / Dummheiten anstellen;etwas zum Spaß tun;Allotria treiben (ugs.)
-gefangen nehmen;(jemanden) hochnehmen (ugs.);erwischen;verhaften
-wohl oder übel eingehen (auf);gute Miene zum bösen Spiel machen (ugs., fig.);widerwillig mitmachen;(sich) seine Verärgerung nicht anmerken lassen (variabel)
-Quadrophonie;Vierkanalstereofonie;Quadrofonie
-Geißgebirge;Gerecse-Gebirge
-Kniestock;Trempel;Drempel
-Würmsee (bis 1961) (veraltet);Starnberger See
-von ... wollen wir (da) erst gar nicht reden (ugs.);(und) schon gar nicht (ugs.);erst recht nicht (Hauptform);schon mal gar nicht (ugs.);umso weniger (als);ganz zu schweigen von;extra nicht (ugs.);noch (viel) weniger;grad nicht (ugs.);geschweige denn;erst gar nicht;gar nicht zu reden von;gerade nicht
-miteinander bekannt werden;(jemandes) Bekanntschaft machen;(jemanden) kennenlernen (Hauptform);(jemanden) zum ersten Mal treffen;(mit jemandem) Bekanntschaft schließen
-(etwas) unterschieben;(etwas) anlasten;(etwas) unterjubeln (ugs.);zustecken;(etwas) heimlich zustecken
-nicht kleckern (ugs.);klotzen (ugs.);sich nicht kleinlich zeigen;nicht sparen;nicht geizig sein;in die Vollen gehen (ugs.)
-(sich) antrainieren;(sich) aneignen;(ein Verhalten) annehmen;(sich) angewöhnen;(sich etwas) zu eigen machen
-Himmelfahrtsinsel;Ascension
-etwas aufschwatzen (ugs.);zum Kauf überreden
-(jemandem) Grenzen setzen;(jemanden) in die Schranken weisen;zurechtweisen;(jemandem etwas) abschlagen;(jemandem etwas) nicht durchgehen lassen;(jemandem) (etwas) husten (ugs.);(jemandem) (die) Meinung sagen;(voll) auflaufen lassen (ugs.);zurückweisen;(jemandem) seine Grenzen aufzeigen;(jemanden) abweisen
-Otopexie;Ohranlegeplastik
-Larynxmaske;Kehlkopfmaske
-Maori;maorische Sprache
-übertreiben;(kräftig) vom Leder ziehen;(viel) Wirbel machen (um);dramatisieren;dick auftragen;hochspielen;aufpumpen;aufbauschen;(viel) Wind machen (um) (fig.);aggravieren (fachspr., medizinisch, selten);aus einer Mücke einen Elefanten machen (ugs., fig.)
-Juwel;wertvolles Schmuckstück;Kronjuwel
-Cucumis melo;Zuckermelone
-illiberal;unfrei
-freien (um) (geh., veraltet);buhlen (um) (geh., veraltet);nachrennen;(ständig) herumschleichen (um) (ugs., salopp);(eine) Charmeoffensive (starten) (fig., variabel);werben (um);(sich) bemühen um (jemanden);nachlaufen;(jemanden) hofieren;nachstellen;umschmeicheln;hinter jemandem her sein (ugs.);(sich) ranschmeißen (ugs., salopp);umwerben;(sich) heranmachen (an);(jemandem) den Hof machen (fig.)
-reffen;Segel einrollen
-reffen;bergen;streichen;einziehen
-Gerichtsurteil;Urteilsspruch;Aburteilung;Urteil;Richterspruch
-röhren;orgeln (Jägerspr.);schreien;brüllen
-Schwung;Armee (ugs.);Unzahl;Batzen;Schwarm;Reihe;Latte (ugs.);Vielheit;Menge;Schwall;Flut (ugs.);Fülle;Schar;Unmaß;Serie;Unmenge;Haufen;Wust;Heer;Ballung;Legion;Masse;Anzahl;Unmasse;Anhäufung;Übermaß;Vielzahl
-Truppengattung;Waffengattung (österr.);Teilstreitkraft
-Katunbindung;Leinwandbindung (Hauptform);Tuchbindung (veraltet);Taftbindung (veraltet)
-sittenlos;schamlos;ohne Tugend;ausschweifend;hemmungslos;zuchtlos;tugendlos;charakterlos;haltlos
-Fallschirmjäger;Luftlandetruppe
-Gebirgsjäger;Gebirgstruppe
-Flächenfallschirm;Gleitfallschirm
-Judenspanisch;Ladino;Judäo-Spanisch;Spaniolisch
-Regensburger (Wurst);Knacker (ugs.)
-Plastik (fachspr.);Schönheitsoperation;plastische Operation (fachspr.);kosmetische Operation;Schönheits-OP
-geselliger Trunk am frühen Abend;Dämmerschoppen;Absacker;Schlummertrunk
-verträglich;leutselig (ugs.);entgegenkommend;wohlwollend;umgänglich;freundlich;soziabel;gesellig
-nomothetisch (fachspr., griechisch);gesetzgebend;legislativ (fachspr., lat.)
-eine Entscheidung ist gefallen;etwas ist geschehen;die Würfel sind gefallen (ugs.)
-etwas für unerträglich halten;etwas im Kopf nicht aushalten (ugs.)
-(jemandem) nicht aus dem Sinn gehen;nicht vergessen können;(jemandem) nicht aus dem Kopf gehen (ugs.);(jemanden) verfolgen (fig.);dauernd denken müssen an
-(etwas) nicht verstehen;(sich) keinen Vers auf etwas machen können (ugs.);(etwas) nicht einsehen;(sich jemandem) nicht erschließen (geh.);(etwas) nicht in den Kopf kriegen (ugs.);(etwas) geht (jemandem) nicht in den Kopf (ugs.);(sich) keinen Reim auf etwas machen können (ugs.);(etwas) nicht begreifen
-eine unangenehme Überraschung erleben;wie vor den Kopf geschlagen sein (ugs.);(sich) fühlen wie vor den Kopf geschlagen (ugs.);unangenehm überrascht sein
-Diebesbeute;Fang;Hehlerware;heiße Ware;vom Lastwagen gefallen;vom Laster gefallen (ugs.);Raubgut;vom LKW gefallen (ugs.);Diebesgut;Schore (Jargon, Rotwelsch);Sore (Jargon, Rotwelsch)
-Schieber;Hehler
-jemand hat verstanden;ist angekommen (ugs.);der Groschen ist gefallen (ugs.)
-keine Denkblockaden haben;keine belastenden Gedanken haben;frei im Kopf sein (ugs.);(sich) auf das Wesentliche konzentrieren können
-justiziabel;justitiabel;juristisch relevant;gerichtlich überprüfbar;gerichtlich entscheidbar
-zausen;strubbeln;verwuscheln;zerzausen;zerwuseln;zerstrubbeln;verstrubbeln;strubbelig machen (ugs.);(die Haare / Frisur) durcheinanderbringen;zerraufen
-Austastlücke;Austastimpuls
-Politruk;Politoffizier;Politkommissar
-Bebauung;Erschließung;Kolonisierung;Besiedlung
-erforderlich;(eine) conditio sine qua non (geh., lat.);unabweisbar;unbedingt nötig (ugs.);zwingend geboten;geboten;unvermeidlich;zwingend;unausweichlich;unentbehrlich;unerlässlich;nötig;notwendig
-Artikel;Ware;Gegenstand;Gebrauchsgut;Konsumgut
-gebündelt;verpackt;abgepackt;verschnürt;eingewickelt
-zusammenfügen;zusammenpacken;bündeln;zusammenschnüren;zusammenbinden
-Colorfilm;Buntfilm;Farbfilm
-changierend;schillerig;schillernd;(wechselhaft) glänzend;changeant (franz.);irisierend
-schleierhaft;unbestimmt;ambivalent;mehrdeutig;schwer durchschaubar;undurchsichtig
-Fraktur (ugs.);altdeutsche Schrift (ugs.);gebrochene Schrift
-Verzierung eines Gegenstandes;Ornament;Zierde;Schmuck
-päpstlicher Botschafter;apostolischer Nuntius
-wissen, wovon man spricht (variabel);(etwas) aus eigener Erfahrung kennen;(in Sachen ...) kein unbeschriebenes Blatt sein (fig.);aus eigener, leidvoller Erfahrung wissen um (geh.);am eigenen Leibe erfahren (haben);wissen, wovon die Rede ist (variabel);(etwas) leidvoll erfahren haben (müssen);ein Lied davon singen können (ugs., fig.)
-fiebrig;fieberhaft;begierig;ungeduldig;gespannt;interessiert;erwartungsvoll;sehr gespannt;in gespannter Erwartung;gespannt wie ein Flitzebogen (ugs.)
-Eifer;Intension;Kraft
-auf Papier;ausgedruckt;schwarz auf weiß (ugs.);in nicht-elektronischer Form;in Papierform;in schriftlicher Form;in Schriftform;schriftlich;(auf Papier) gedruckt
-gröblich vereinfachen (geh.);grob vereinfachen;nicht differenzieren;nur gut und böse kennen;Schwarzweißmalerei (sein);nicht unterscheiden;schwarz-weiß denken (ugs.);nur gut und schlecht kennen;keine Zwischentöne zulassen;Schwarz-Weiß-Malerei (betreiben)
-den Sinn verdrehen;ins Gegenteil verkehren;(etwas) auf den Kopf stellen (ugs.);aus Schwarz Weiß machen (ugs.)
-systematisieren;in einem System darstellen;in ein System bringen
-sortieren;registrieren;aufgliedern;unterteilen;erfassen;einordnen;systematisieren;gruppieren;situieren (fachspr.);zusammenstellen;ordnen;katalogisieren;in einen Katalog aufnehmen
-kategorisieren;etwas nach Kategorien ordnen bzw. einordnen
-Serum enthaltend oder absondernd;das Serum betreffend;serös (lat.)
-kaudern;unverständlich sprechen
-Vorspringen des Oberkiefers;Prognathie (fachspr.)
-Vorstehen des Unterkiefers;Progenie (fachspr.)
-Herausbildung;Fortentwicklung;Fortschritt;Entfaltung;weitere Entwicklung;Fortgang;Weiterentwicklung;Progression
-Steigerung;Hebung;Verschlimmerung;Erhöhung;Eskalierung;Verschlechterung;Progression;Verschärfung
-Sprung über den Bock (Turnen);Bocksprung
-Schlacht bei Großgörschen;Schlacht bei Lützen (1813)
-Trachenberg-Plan;Trachenberger Kriegsplan
-Alvenslebensche Konvention;Alvensleben'sche Konvention (veraltet)
-Genfer Abkommen;Genfer Konventionen
-Reichseinigungskriege;Deutsche Einigungskriege
-Deutscher Krieg;Österreichisch-Preußischer Krieg;Einigungskrieg;Deutscher Bruderkrieg;Siebenwöchiger Krieg;Preußisch-Deutscher Krieg (veraltet);Deutsch-Österreichischer Krieg;Deutsch-Deutscher Krieg;Preußisch-Österreichischer Krieg;Deutscher Bundeskrieg
-Wallonien;Wallonie;(das) französischsprachige Belgien;(die überwiegend) französischsprachige Region Belgiens;Wallonische Region
-entlehnen;aus einem anderen Bereich übernehmen
-ventilieren;durchblasen;auslüften;entlüften
-Abzug;Klimaanlage;Dunstabzug;Entlüfter
-bestimmen;verfügen;vorschreiben;festlegen;reglementieren;befehlen
-vorsprechen;Text zur wörtlichen Niederschrift ansagen;diktieren
-südfranzösische Landschaft;Okzitanien
-Anstandswauwau (ugs.);Sittenwächter;Wächter über Sitte und Anstand
-kerzengerade dastehen;wie eine Eins dastehen (ugs.)
-zum Aufbruch bereit;gesattelt und gespornt (ugs.)
-mit Rauschgift handeln;dealen (ugs.)
-Latz;Schnurstück (am Gewand)
-Patientenserviette (fachspr.);Latz (ugs.)
-Essmantel (schweiz.);Essmäntelchen (schweiz.);Sabberlatz;Kinderlatz;Kinderlätzchen;Baterl (ugs.);Lätzchen;Musueli (schweiz.);Barterl (ugs., österr.);Baby-Lätzchen;Schlabberlatz;Trieler (ugs., schwäbisch)
-Iraklio;Heraklion (veraltet);Iraklion (veraltet)
-Vatikanisches Konzil;Vaticanum
-Eradikation;Keimeliminierung
-erster Kappeler Landfriede;erster Landfrieden von 1529
-Schlacht bei Paris;Schlacht auf dem Montmartre
-Versailler Vertrag;Friede von Versailles;Diktat von Versailles;Friedensvertrag von Versailles
-archivalisch;ein oder mehrere Archive betreffend;in Archiven enthalten oder daraus stammend;zu einem oder mehreren Archiven gehörend
-(den) Sprung ins kalte Wasser (riskieren) (ugs., fig.);eine (gänzlich) unvertraute Aufgabe übernehmen
-Diskreditierung;Schimpf;Affront;Verbalinjurie;Herabwürdigung;Verletzung;Insult;Verunglimpfung;Beleidigung;Schlag ins Gesicht (fig.);Kränkung;schwere Beleidigung;Erniedrigung
-auf der faulen Haut liegen (ugs., Redensart);(sich) die Eier schaukeln (derb, Redensart, fig.);(die) Arbeit nicht erfunden haben (ugs., Redensart);(einfach) dasitzen und Kaffee trinken (ugs., fig.);keinen Finger krumm machen (ugs., Redensart, fig.);Däumchen drehen (ugs., sprichwörtlich);keinen Handschlag tun (ugs., Redensart, variabel);keinen Schlag tun (ugs.);faul sein;(sich) an den Füßen spielen (ugs., Redensart, fig.);abharzen (ugs., salopp);abhartzen (ugs., salopp);nichts tun;faulenzen;keinen Finger rühren (ugs., Redensart, fig.)
-herbe Niederlage;schwerer Rückschlag;(ein) schwerer Schlag (ugs.);(ein) schlimmes Ereignis;verheerende Niederlage;vernichtende Niederlage
-eine unangenehme Überraschung;ein Schlag ins Kontor (ugs.)
-vom gleichen Schlag sein (ugs.);gleiche Herkunft haben;gleicher Wesensart sein;gleichartige Charaktereigenschaften besitzen
-konventionell (sein);traditionsgebunden;vom alten Schlag (sein) (ugs.);auf alte bewährte Weise
-nicht zusammenpassen(d);grundverschieden;intransigent (geh., lat.);(sich) unterscheiden(d) wie Tag und Nacht;unvereinbar;widersprüchlich;wie Feuer und Wasser (ugs.)
-(eine) Heidenangst haben (ugs.);(die) Panik kriegen (ugs.);(totale) Panik haben (ugs.);tausend Ängste ausstehen;tausend Tode sterben (ugs., fig.);(eine) Mordsangst haben (ugs.);Todesangst haben;(eine) Riesenangst haben;Blut und Wasser schwitzen (ugs.);Schiss haben (ugs.);sehr große Angst haben
-Wasser in den Rhein schütten (ugs.);etwas sinnloses machen;etwas sinnloses tun
-Wasser in den Wein gießen (ugs.);Einwand erheben;Kritik üben;Begeisterung dämpfen
-(sich) den Lebensunterhalt verdienen;(sein) Auskommen finden;überleben (fig.);(sich seine) Brötchen verdienen (mit) (ugs., fig.);(sich) über Wasser halten (mit) (ugs., fig.);(sein) Auskommen haben
-vergebliche Liebesmüh sein;(eine) Sisyphusarbeit sein;mit einem Sieb Wasser schöpfen (ugs.);(sich) umsonst anstrengen;(sich) vergeblich abmühen
-Blut ist dicker als Tinte (ugs.);Blut ist dicker als Wasser (ugs.)
-munter wie ein Fisch im Wasser (sein);(sich) wie ein Fisch im Wasser fühlen;(sich) wohlfühlen
-in (großen) Schwierigkeiten stecken;(das) Wasser bis zum Hals stehen (haben) (ugs., fig.);echte Probleme haben (ugs.);(sich) in einer schlechten Lage befinden;das Wasser steht (jemandem) bis Oberkante Unterlippe (ugs.);(kurz) vor dem Ruin stehen;vor dem Abgrund stehen (fig.);vor dem Kollaps stehen;vor dem Chaos stehen
-Kratzrädchen;Fräsrädchen
-Bodenfräse;Bodenstabilisierer
-Schabottenhammer;Fallhammer;Vertikalhammer
-Flachsenker;Plansenker
-Transsibirische Eisenbahn;Transsib (ugs.)
-zylindrische Spirale;Helix;Schraube;Schraubenlinie;Wendel
-(jemandem) läuft das Wasser im Mund(e) zusammen (ugs.);jemand bekommt großen Appetit
-Aufforderung zu konsequentem Handeln;Wer A sagt, muss auch B sagen (ugs.);Begonnenes muss man fortsetzen
-vom Anfang bis zum Ende gelogen;vollständig gelogen;von A bis Z gelogen (ugs.)
-in der Nachbetrachtung;im Nachhinein;nachträglich (Hauptform);von späterer Hand (fachspr.);hinterher;im Nachgang;a posteriori (geh., bildungssprachlich, lat.)
-über jemanden das Füllhorn ausschütten (ugs.);(jemanden) reich beschenken
-überheblich gucken;herablassend schauen;jemanden über die Schulter ansehen (ugs.)
-jemandem ans Leder gehen;(sich) über jemanden hermachen (ugs.);über jemanden herfallen;(sich) auf jemanden stürzen;jemanden überfallen;jemanden verprügeln;jemanden angreifen
-(negativ) über etwas sprechen;(sich) über etwas auslassen (ugs.);(negativ) über etwas urteilen
-Tugendbold;Hüter von Sitte und Anstand (variabel);Moralprediger;Gutmensch;Moralapostel;Sittenwächter;Biedermann;Tugendwächter
-Bibelexegese;biblische Exegese
-auf Tuchfühlung gehen (ugs.);(körperlichen) Kontakt aufnehmen
-mit den Hühnern schlafen gehen (ugs.);mit den Hühnern zu Bett gehen (ugs.);sehr früh schlafen gehen
-offen sein für Neues;Wer zu spät kommt, den bestraft das Leben. (sprichwörtlich);(sich) dem Neuen nicht verschließen (dürfen);mit der Zeit gehen (müssen) (ugs., Hauptform);fortschrittlich sein
-mit Siebenmeilenstiefeln gehen (ugs.);schnell Fortschritte machen;schnell laufen
-wirkungslos bleiben;nutzlos sein;ins Leere gehen (ugs.)
-zu stark belastet werden;in die Knie gehen (ugs.);überbeansprucht werden
-(eine) Demutshaltung einnehmen;in die Knie gehen (ugs.);vor Dankbarkeit niederknien
-auf plumpe Weise betrügen;auf Bauernfang gehen (ugs.)
-auf Freiersfüßen wandeln;(die) Frau fürs Leben suchen;auf Brautschau gehen;was Festes suchen (ugs.);eine Frau zum Heiraten suchen;auf Freiersfüßen gehen
-auf die Rolle gehen (ugs.);mit mehreren Leuten feiern gehen
-(sich) konzentrieren;meditieren;in sich gehen (ugs.)
-über etwas brüten (ugs.);(sich) mit einer Sache intensiv beschäftigen;über etwas (intensiv) nachdenken
-seine Worte wägen (geh.);um jedes Wort ringen (geh.);(sehr) aufpassen, was man sagt (ugs.);(sich) jedes Wort genau überlegen (ugs.);jedes Wort auf die Goldwaage legen (ugs., fig.)
-für einen Apfel und ein Ei kaufen (ugs.);(ein) Schnäppchen machen;günstig bekommen;Schnäppchen machen;für ein Butterbrot bekommen (ugs.);für wenig Geld kaufen
-als bedrückend empfinden;(sich etwas) zu Herzen nehmen (ugs.);Bauchschmerzen bereiten (fig.);(sich) Sorgen machen;schwernehmen
-(nicht) über die Lippen bringen;(nicht) aussprechen;(etwas nicht) herauskriegen (ugs.);(nicht) in den Mund nehmen (ugs.);(jemandem) nicht von der Zunge gehen;(etwas nicht) herausbringen
-(sich jemanden) zum Geburtstag schenken (ugs.);(sich jemanden) zur Brust nehmen (ugs.);zur Rechenschaft ziehen;(sich jemanden) vornehmen (Hauptform);(sich jemanden) greifen (ugs.);(sich jemanden) vorknöpfen (ugs.);(sich jemanden) kaufen (ugs., veraltend);(jemandem etwas) nicht durchgehen lassen
-(sich jemanden) zur Brust nehmen (ugs.);(sich) mit (jemandem) beschäftigen
-Hof;Hofstaat;höfische Gesellschaft
-für ein Butterbrot verkaufen (ugs.);verschleudern;zum Schleuderpreis verkaufen;für einen Apfel und ein Ei verkaufen (ugs.);(etwas) sehr billig verkaufen
-den Buckel hinhalten (ugs., fig.);(sich) den Schuh anziehen (ugs., fig.);(für etwas) aufkommen (müssen);(etwas) auf seine Kappe nehmen (ugs., fig.);auf die eigene Kappe nehmen (ugs., fig.);(sich) seiner Verantwortung stellen;(den) Kopf hinhalten (müssen) (für) (fig.);(sich) schuldig bekennen (scherzhaft-ironisch);(für etwas) (die) Verantwortung übernehmen;(sich) verantwortlich erklären (für)
-Verantwortung übernehmen müssen;für etwas herhalten müssen (ugs.)
-Grundstein sein (für etwas);Beginn einer Sache sein;entscheidender Ausgangspunkt sein
-das relevanteste Element (von etwas) sein;der Motor (für etwas) sein (fig.);die treibende Kraft sein
-eV (Einheitenzeichen);Elektronvolt;Elektronenvolt
-mitfühlend sein;hilfsbereit sein;ein Herz haben (ugs.)
-(sich) wenig geneigt zeigen (zu) (geh.);unmotiviert sein;(dankend) abwinken;keinen Bock haben (auf) (ugs.);kein Interesse zeigen;keine Lust haben;kein Interesse haben;keinen Nerv haben (ugs.);(sich) nicht interessiert zeigen;(dankend) absagen;null Bock haben (auf) (ugs.);(einfach) nicht wollen (ugs.)
-(sich für etwas) erwärmen können (ugs.);(sich) (durchaus) vorstellen können (zu / dass);nicht abgeneigt sein;(sich) daran gewöhnen können (ugs.);(dahin) tendieren (zu) (geh.);Sympathien zeigen (für)
-(sich) namentlich bekennen (zu) (fig.);(etwas) unterschreiben (ugs., fig.);mit seinem Namen (für etwas) werben;(für etwas) stehen;seinen Namen (für etwas) hergeben
-zu wenig;(nur etwas) für den hohlen Zahn (ugs.)
-der Prellbock sein (ugs.);der Sündenbock sein
-einem Stoff den natürlichen Zustand nehmen;seines eigentlichen Charakters berauben;(zu etwas) entarten;denaturieren;seiner eigentlichen Natur berauben
-intrakardial (fachspr.);(Injektion) in das Herz
-enteral (fachspr.);unter Verwendung des Darmes
-Injektion in die Brusthöhle;intrapleural (fachspr.)
-intrathekal (fachspr.);Injektion in den Liquorraum der Hirnhaut
-Injektion i.d. Epiduralraum z. Periduralanästhesie;peridural (fachspr.)
-perineural (fachspr.);Injektion in das Bindegewebe der Nerven
-intraneural (fachspr.);Injektion in den Nerv
-in die Bauchhöhle;intraperitoneal (fachspr.)
-intrapulmonal (fachspr.);(Injektion) in die Lunge
-in die Vagina;vaginal (fachspr.)
-intrakutan (fachspr.);in die (Leder-)Haut
-intraventrikulär (fachspr.);(Injektion) in die Hirnventrikel
-intraossär (fachspr.);(Injektion) in den Knochen (ugs.)
-intralymphatisch (fachspr.);(Injektion) in die Lymphknoten
-(Injektion) in die Arterie;intraarteriell (fachspr.)
-(Injektion) in das Gelenk;intraartikulär (fachspr.)
-endovenös;in die Vene;intravenös (fachspr.)
-percutan (fachspr.);über die Haut
-Makroskopie (fachspr.);mit dem bloßen Auge erkennbare Strukturen
-Halbbyte;Nybble;Tetrade;Nibble;4 Bits;Quadrupel
-Notariat;Kanzlei eines Notars
-Tudorstil;Tudorgotik
-Stirnmoräne;Endmoräne
-Obermoräne;Ablationsmoräne
-Erratiker;Findling;erratischer Block
-Vier-Farben-Problem (veraltet);Vier-Farben-Theorem;Vier-Farben-Satz;Vier-Farben-Vermutung (veraltet)
-Elsässisch;Elsässerdeutsch
-Altphilologie;Klassische Philologie
-altgriechische Philologie;Gräzistik
-lateinische Philologie;Latinistik
-Langobarden;Winniler
-Bergamo;Wälsch-Bergen (veraltet)
-Inhalieren;Einatmen;Inhalation
-Optronik;Optotronik;Optoelektronik
-1888;Dreikaiserjahr
-zweites Vierkaiserjahr;193
-Vierkaiserjahr;69
-Osteodensitometrie;Knochendichtemessung
-paneuropäischer Verkehrskorridor;PAN-Korridor
-Fake-Account;Multiaccount;Sockenpuppe (ugs.);Smurf
-Parallelepiped (fachspr.);Spat (fachspr.)
-Körper;geometrischer Körper
-überschwemmen;übermannen
-ein Paar sein;Zweisamkeit
-Konkursverschleppung (veraltet);Insolvenzverschleppung
-Hochstift Münster;Fürstbistum Münster
-Amoriter;Amurriter
-süddeutscher Zollverein;bayerisch-württembergischer Zollverband
-Urteilsaufhebung;Kassation;Kassierung
-Zweites Rom (ugs.);Byzanz;Rom des Ostens (ugs.)
-Detroit;Motown (ugs., engl.);Motor City (ugs., engl.)
-Edinburgh;Athen des Nordens (ugs.);Venedig des Nordens (ugs.)
-Goldenes Mainz (ugs.);Mainz
-Byzanz des Abendlandes (ugs.);Raben (veraltet);Ravenna
-Ho-Chi-Minh-Stadt;Paris des Ostens (ugs.);Perle des fernen Ostens (ugs.);Saigon (veraltet)
-Brügge;Venedig des Nordens (ugs.)
-Emden;Venedig des Nordens (ugs.)
-Venedig des Nordens (ugs.);Arendal
-Venedig des Nordens (ugs.);Friedrichstadt
-Stralsund;Venedig des Nordens (ugs.)
-Nikolaiken;Venedig des Nordens (ugs.)
-Venedig des Nordens (ugs.);Giethoorn
-Papenburg;Venedig des Nordens (ugs.)
-Paris des Ostens (ugs.);Irkutsk
-Festspielstadt (ugs.);Bayreuth
-Salzburg;Festspielstadt (ugs.);Mozartstadt (ugs.)
-Halle;Händelstadt (ugs.)
-Marzipanstadt (ugs.);Lübeck
-indoeuropäische Sprache;indogermanische Sprache
-Bakteriophobie;Bakterienangst
-Nyctophobie (fachspr.);Nyktophobie (fachspr.);Achluophobie (fachspr.);Nyctiphobie (fachspr.);Nyktosophobie (fachspr.);Angst vor Dunkelheit;Lygophobie (fachspr.)
-Aeronausiphobie (fachspr.);Angst vor Luftkrankheit
-Agateophobie (fachspr.);Angst vor Irrsinn
-Knidophobie (fachspr.);Odynophobie (fachspr.);Agliophobie (fachspr.);Ponophobie (fachspr.);Angst vor Schmerz;Algophobie (fachspr.)
-Assyrische Kirche des Ostens;Apostolische Kirche des Ostens
-Gambierinseln;Mangarevainseln
-Reißverschlussverfahren;Reißverschlusssystem
-Kontextsensitivität;Kontextabhängigkeit
-Segelwagen;Landsegler;Windwagen
-Celanosee;Fuciner See;Fucinosee
-Kanal-Tragfläche;Kanal-Flügel;Channelwing (engl.);Röhrenflügel
-Taschendieb;Langfinger (ugs.)
-Staatsinsolvenz;Staatsbankrott
-Lokomotivsandwich;Doppelpendelzug (schweiz.)
-Tesla-Transformator;Teslaspule
-Tesla-Turbine;Scheibenläuferturbine
-Jolly Roger;Piratenflagge;Black Jack
-Divinität;göttliches Wesen;Göttlichkeit
-Seligsprechung;Beatifikation
-Neubritannien-Archipel (veraltet);Bismarck-Archipel
-Neu-Hannover (veraltet);Lavongai
-Vitu-Inseln;Witu-Inseln;Französische Inseln (veraltet)
-West-Papua;West-Neuguinea;Holländisch-Neuguinea (veraltet);Niederländisch-Neuguinea (veraltet)
-Neupommern (veraltet);Neubritannien
-Eremiteninseln;Agomes;Hermitinseln;Einsiedlerinseln;Luf-Gruppe
-Tiefseerinne (fachspr.);Tiefseegraben (ugs.)
-Neupommern-Bougainville-Graben;Neubritannien-Bougainville-Graben;Neubritanniengraben
-Neuirland;Neumecklenburg (veraltet)
-Bedarfswirtschaft;Subsistenzwirtschaft
-Stalingotik;stalinistischer Zuckerbäckerstil;sozialistischer Klassizismus;Stalin-Empire
-YOGTZE-Fall;BAB-Rätsel
-Kaskadenkette;Kaskadengebirge
-zirkumpazifischer Feuerring;zirkumpazifischer Feuergürtel;pazifischer Feuergürtel;pazifischer Feuerring
-Vulkandom;Staukuppe;Lavadom;Lavakuppel
-mit (zahlreichen) Klauseln;verklausuliert
-Degeto;Degeto Film GmbH;ARD Degeto;Deutsche Gesellschaft für Ton und Film (veraltet)
-Lebensmittelimitat;Lebensmittelsurrogat
-Stellvertreterschlüssel;Surrogatschlüssel
-intelligenter Schlüssel;natürlicher Schlüssel;sprechender Schlüssel
-Erhöhung;Inkrement
-Verminderung;Dekrement
-Provo (ugs.);Providenciales
-Grenzlandring;Grenzland-Ring;Wegberg-Ring (veraltet);Wegbergring (veraltet)
-100-Stunden-Krieg;Fußballkrieg
-Slowakisches Kreuz;Byzantinisches Doppelkreuz;Spanisches Kreuz;Patriarchenhochkreuz;Patriarchenkreuz;Erzbischofskreuz;Ungarisches Kreuz
-bettelarm;bitterarm;(sehr) arm;arm wie eine Kirchenmaus (ugs.)
-Elektretmikrofon;Elektret-Kondensatormikrofon
-Rauschabstand;Signal-Rausch-Verhältnis;Signal-Stör-Verhältnis;Störabstand;Signal-Rauschabstand
-Magenbitter;Kräuterbitter
-Bitter;Amer;Bitterspirituose
-Karlsbader Becher-Bitter (veraltet);Becherovka
-deutsche Nationalhymne;Deutschlandlied;Lied der Deutschen
-Kokopo;Herbertshöhe (bis 1918) (veraltet)
-Schlacht um Rabaul (1942);Bismarck Operation;Operation R
-Villamuez;Willaumez-Halbinsel;Admiralhalbinsel;Willaumez Peninsula
-Burrup-Halbinsel;Murujuga
-Geniezeit;Genieperiode;Sturm und Drang (Hauptform)
-Pinzgauer Lokalbahn;Pinzgaubahn;Krimmler Bahn
-Panoramawagen;Aussichtswagen
-Guldene Straß;Goldener Steig;Goldener Pfad
-Grützwurst;Graupenwurst;Wurstebrei;Tote Oma (ugs., regional)
-Lose Wurst;Pottwurst
-Vorratskeller;Viktualienkeller (geh., veraltet)
-Paraguayischer Krieg;Tripel-Allianz-Krieg
-übertragen;anstecken;infizieren (fachspr.)
-Manati;Rundschwanzseekuh
-Seekuh;Sirene
-Dugong;Gabelschwanzseekuh
-Mutation (fachspr.);Stimmwechsel;Stimmbruch
-Schlacht bei Krotzka;Schlacht bei Grocka
-Altkanarier;Guanchen
-Misore-Inseln;Schouten-Inseln
-Salvages (veraltet);Wilde Inseln;Ilhas Selvagens
-daktyloskopischer Identitätsnachweis;Fingerabdruckverfahren
-Krieg der zwei Brüder;Miguelistenkrieg
-Orangen-Krieg;Pomeranzenkrieg (veraltet)
-Bitterorange;Saure Orange;Sevilla-Orange;Pomeranze
-Pampelmuse;Grapefruit (ugs.);Adamsapfel;Riesenorange
-Myhill-Konstruktion;Potenzmengenkonstruktion;Teilmengenkonstruktion
-Simplex-Verfahren;Simplex-Algorithmus
-Polyeder;Vielflächner;Vielflach;Ebenflächner
-platonischer Körper;regulärer Polyeder
-Ablauf- und Planungsforschung;mathematische Entscheidungsvorbereitung;Unternehmensforschung
-mehrkriterielle Optimierung;Vektoroptimierung;multikriterielle Optimierung;Pareto-Optimierung
-Maskierungseffekt;Verdeckung
-Gewürzroute;Seeweg nach Indien
-Mittelatlantischer Rücken;Mittelatlantische Schwelle
-thesaurieren;erzielte Gewinne einbehalten
-neutraler Standpunkt;archimedischer Punkt
-Kastilisches Scheidegebirge;Iberisches Scheidegebirge;Zentralkordillere
-Scheuerkissen (Hauptform);Pfannenreiniger;Topfkratzer;Topfreiniger
-Wirkwiderstand;Resistanz
-Pavillon;Wappenmantel;Thronzelt
-Großes Schisma;Großes Abendländisches Schisma;Abendländisches Schisma
-Griechisches Schisma;Morgenländisches Schisma;Großes Schisma
-Engadiner Krieg;Schweizerkrieg;Schwabenkrieg
-Löwlerbund;Gesellschaft von dem Leon
-pelagisch (fachspr., griechisch);nektisch (fachspr., griechisch);nektonisch (fachspr., griechisch);im freien Wasser schwimmend
-Bayestheorem;Satz von Bayes
-Empfindlichkeit;Sensitivität
-Trefferquote;Empfindlichkeit;Sensitivität;Richtigpositiv-Rate
-(sich) vorkommen wie;(sich) fühlen wie
-konditionale Wahrscheinlichkeit;bedingte Wahrscheinlichkeit
-FDJ (Abkürzung);Freie Deutsche Jugend
-Bayerischer Kronenorden (ugs.);Verdienstorden der Bayerischen Krone;Zivilverdienstorden der Bayerischen Krone (ugs.)
-Reichsheer;Reichsarmatur;Reichsarmee
-Hubertusorden;Orden des Heiligen Hubertus;Orden vom Horn
-Dreingabe;Naturalrabatt inklusive (selten)
-Draufgabe;Naturalrabatt exklusive (selten)
-Eulergerade;Eulersche Gerade
-Vertrag von Ripen;Ripener Privileg;Handfeste von Ripen
-Mensch ohne Beziehungserfahrung;Absolute Beginner (ugs., engl.)
-universelle Gebäudeverkabelung;strukturierte Verkabelung
-gleich große Entfernung;Äquidistanz
-Riechwahrnehmung;Wahrnehmung von Gerüchen;Nase (ugs., fig.);olfaktorische Wahrnehmung (fachspr.);Geruchssinn;Riechvermögen;olfaktorischer Sinn (fachspr.);Riechfähigkeit;Geruchswahrnehmung
-Drehimpulsgeber;Inkrementaldrehgeber;Inkrementalgeber;Drehgeber
-Elektrorad (ugs.);Pedelec;Elektrofahrrad (Hauptform);Elektro-Hybridrad;Fahrrad mit elektrischem Hilfsmotor;Hybridrad (ugs.);Pedal Electric Cycle (fachspr., Jargon, engl.);E-Bike (Jargon, engl.)
-Signalisierung;Zeichengabe
-Zeitscheibe;Zeitschlitz
-Dreiersystem;Ternärsystem
-Stellenwertsystem (Hauptform);Positionssystem;polyadisches Zahlensystem
-Stern-Dreieck-Schaltung;YD-Schaltung
-Stromstoßrelais;Stromstoßschalter
-pneumatisches Schütz;Druckluftschütz
-Potlach;Potlatsch;Potlatch
-Samuraischwert;Katana
-Beidenhänder;Bidenhander;Beidhänder;Zweihänder;Bidenhänder;Bihänder
-neuronaler Schaltkreis;neuronaler Erregungskreis
-Aktionspotential (fachspr., Hauptform);AP (fachspr.);Erregungspotential (fachspr.);elektrische Erregung
-Nachtblindheit;Hemeralopie (fachspr., griechisch, lat.);Nyktalopie (fachspr., griechisch)
-Volkspolizei;Deutsche Volkspolizei;VoPo (ugs.)
-Porsche 914;VoPo (ugs.);Volks-Porsche (ugs.);Volksporsche (ugs.)
-Tindouf-Krieg;Algerisch-Marokkanischer Grenzkrieg
-Vertrag von Tien-tsin;Vertrag von Tianjin
-Paquisha-Krieg (in Ecuador);Peruanisch-Ecuadorianischer Grenzkrieg;Paquisha-Zwischenfall;Falso Paquisha-Krieg (in Peru)
-Zimtland-Expedition;Gonzalo-Pizarro-Expedition
-Malabarküste;Pfefferküste
-Schneekönig;Zaunkönig
-Aruba-Gulden;Aruba-Florin
-Ticketsystem;Support Ticketsystem;Serviceticketsystem;Ticketingsystem;Trouble Ticket System;Help-Desk;Support Ticketing System;Issue-Tracking System;Task Tracking System
-semipräsidentielles Regierungssystem;gemischt präsidial-parlamentarisches Regierungssystem
-nach Recht und Billigkeit;ex aequo et bono
-Wärmeleitkoeffizient;Wärmeleitfähigkeit;Wärmeleitzahl
-Makrokernel;Hybridkernel
-(sich) versichern;eine Versicherung abschließen;vorsorgen;in eine Versicherung eintreten
-Herzogtum Preußen;Brandenburgisches Preußen (im 17. Jhd.)
-Weichselglazial;Weichselkaltzeit;Weichsel-Eiszeit (ugs.);Weichseleiszeit (ugs.);Weichsel-Glazial;Weichsel-Komplex;Weichsel-Zeit (ugs.);Weichsel-Kaltzeit
-Korrektionsanstalt;Besserungsanstalt
-Aphärese;Ablatio
-Willenberg-Kultur;Braunswalde-Willenberg-Kultur;Wielbark-Kultur
-Sauromaten;Sarmaten
-Stilmittel;rhetorische Figur;rhetorisches Mittel;Redefigur;Stilfigur;rhetorisches Stilmittel
-Oberbayern-Ingolstadt;Bayern-Ingolstadt
-Bayern-München;Oberbayern-München
-Agilulfinger;Agilolfinger
-Herrschaft Schnallenstein;Herrschaft Rosenthal
-Seignettesalzelektrizität (veraltet);Ferroelektrizität;Seignette-Elektrizität (veraltet)
-Gleiwitzer Kanal;Oberschlesischer Kanal;Adolf-Hitler-Kanal (veraltet)
-Confiserie;Zuckerbäckerei (veraltet);Kuchenbäckerei;Konditorei;Patisserie;Konfiserie
-stark bewegt;sollizitieren;heftig erregt
-Gehwagen;Rentnerporsche (ugs.);Zwiebelporsche (ugs., ironisch);Rollator;Rolli (ugs.);Wägelchen (ugs.)
-nicht so und (auch) nicht anders;weder noch;keiner;nicht das Eine und (auch) nicht das Andere;gar nicht
-Billigproduktion (Film o.ä.);Konfektionslösung;Serienproduktion;Stangenware (fig.);Massenware
-etappenweise;in kleinen Schritten;stufenweise;abschnittweise;schrittweise;Schritt für Schritt (fig.);stückweise;in einzelnen Schritten (Hauptform);in Etappen;portionsweise;Stück für Stück;Zug um Zug;ratenweise
-Wiederholungszeichen;~;Tilde
-Kubikzentimeter;cm³ (Einheitenzeichen)
-At-Zeichen;@;Affenschaukel (ugs.);At;Affenohr (ugs.);Affenschwanz (ugs.);Klammeraffe (ugs.)
-m² (Einheitenzeichen);qm (Einheitenzeichen, veraltet);Quadratmeter
-Rendezvous (franz.);Stelldichein;Treffen;Tête-à-Tête (franz.);Verabredung (Hauptform);Date (engl.)
-Elfenbeinküste;Côte d'Ivoire
-bei Tage betrachtet;bei Licht betrachtet;bei Lichte betrachtet;genau betrachtet
-Bildwechselfrequenz;Bildfrequenz;Bildrate
-Ludolfzahl;Kreiszahl;Pi;ludolfsche Zahl;Archimedes-Konstante;3,141592653589793238;Kreiskonstante;π
-Adonai [jüdisch];Gott;Herr;Abraxas [gnostisch];Allah [islamisch];Jehova [jüdisch];Demiurg [gnostisch];Elohim [jüdisch]
-Eta;η;Effizienz;Energieeffizienz;Wirkungsgrad
-Ente (ugs.);Citroën 2CV;Döschwo (schweiz.);2CV
-Parkinson;Parkinson'sche Krankheit;Morbus Parkinson;Idiopathisches Parkinson-Syndrom;Parkinsonkrankheit;Parkinson-Krankheit;Symptomatik der Parkinson-Krankheit;Schüttellähmung;Parkinsonismus;Parkinsonsche Krankheit;Zitterlähmung
-Dollar;$
-vis-à-vis;gegenüber (Hauptform);entgegengesetzt;am anderen Ufer;auf der anderen Straßenseite;gegenüberliegend;auf der anderen Seite;vis-a-vis;jenseits
-bomätschen (sächsisch);ein Schiff stromaufwärts ziehen;treideln
-Snack (engl.);Vorgericht;Vorsuppe;Antipasto (dt. meist Plural: Antipasti);Horsd'œuvre (geh., franz.);Entrée (fachspr., franz.);erster Gang;Vorspeise
-Plottwist (fachspr.);plötzliche Wendung;Doch erstens kommt es anders, und zweitens als man denkt. (ugs., kommentierend, scherzhaft);Coup de théâtre;entscheidende Wendung;Peripetie;plötzlicher Umschlag;Plot point (fachspr., engl.);plötzlicher Umschwung
-Chaldäische Periode;Sarosperiode;18,03 Jahre;223 Lunationen;Halleysche Periode
-Brasilia;Brasília
-Hauptstadt von Paraguay;Asunción
-Aşgabat;Aschgabat;Hauptstadt von Turkmenistan;Asgabat
-Reykjavík;Hauptstadt von Island
-Hauptstadt von Moldawien;Chişinău
-Bucureşti (rumänisch);Paris des Ostens (ugs.);Bukarest;Hauptstadt von Rumänien
-São Tomé;Hauptstadt von São Tomé und Príncipe
-Fahrscheinautomat;Fahrscheinverkaufsautomat;Fahrausweisautomat;Fahrausweisverkaufsautomat;Fahrkartenautomat;Fahrkartenverkaufsautomat;Billettautomat (schweiz.)
-Komplementärmedizin;sanfte Medizin;alternative Medizin;Alternativmedizin;Naturheilkunde;Naturmedizin
-Ultrahocherhitzung;Pasteurisierung;kurzzeitige Erwärmung auf 60 bis 90 Grad;Pasteurisation
-maligne atrophische Papulose;Morbus Köhlmeier-Degos;atrophische papulosquamöse Dermatitis;Degos-Syndrom
-α;Alpha
-10.000 m²;100 Meter mal 100 Meter;ha (Einheitenzeichen);Hektar;Hektare (schweiz.)
-Deutsch Tscherbeney;Grenzeck (veraltet);Tscherbeney
-mit "Hirnwasser" gefüllte Hohlräume im Gehirn;Hirnventrikel
-Riukiu-Inseln (veraltet);Ryūkyū-Inseln;Liukiu-Inseln (veraltet)
-Schonischer Krieg;Nordischer Krieg 1674-1679;Schwedisch-Brandenburgischer Krieg
-Eulerwinkel (Plural);Eulersche Winkel (Plural)
-kritischer Punkt;Fixpunkt;Gleichgewichtspunkt;Ruhelage
-Zustandsraum;Phasenraum
-(semantisch) redundant;durch eine Tautologie ausgedrückt;tautologisch;pleonastisch
-Phrasendrescher (ugs.);Sprücheklopfer (ugs.);Phraseur (geh., franz., griechisch, lat., veraltet)
-an Demenz erkrankt;dementiell;demenziell
-Termenvox;Theremin;Thereminvox;Aetherophone;Thereminovox
-absuchen;abklabastern (ugs., nordostdeutsch);durchforsten;abklappern (ugs.);(sich) hangeln (durch) (ugs., fig.)
-Wieselkatze;Jaguarundi
-BMW-Vierzylinder;BMW-Hochhaus;BMW-Turm
-Kaskelkiez (ugs.);Victoriastadt
-Biarchie;Doppelherrschaft;Dyarchie (veraltet)
-Tatarenpass (veraltet);Jablunyzkyj-Pass
-Karpatenukraine;Karpatoukraine;Karpato-Ukraine;Karpatenruthenien;Karpatenrussland;Unterkarpaten;Karpatoruthenien;Transkarpatien;Karpathen-Ukraine;Karpathorussland;Karpatenland
-Prä-Astronautik;Paläo-SETI
-Marosch;Mieresch
-Straße von Kertsch;Kimmerischer Bosporus (veraltet)
-Hauptturm;Berchfrit;Burgturm;Bergfried
-Eigenname;Nomen proprium (lat.);Proprium
-Substanzausdruck;Massenomen (fachspr.);Stoffbezeichnung;Stoffname;Kontinuativum (fachspr., lat.)
-thermohaline Zirkulation;globales Förderband (ugs.)
-Stoppschild;Stopptafel (österr.)
-Anfangsmutation;Anlautmutation;Mutation;Eklipse;Anlautpermutation
-Vorbildung;Propädeutik (fachspr., griechisch);Vorunterricht;Vorübung
-Amtsbürgermeister;Podestat;Podestà (ital.)
-Abu Musa;Gap-Sabzu;Abu Musâ;Abu Mussa
-Marklissa-Talsperre;Queistalsperre
-Mauertalsperre;Bobertalsperre Mauer;Talsperre Mauer;Bobertalsperre
-Sultanat Ikonion;Sultanat der Rum-Seldschuken;Sultanat Rûm
-Keltenschanze;Viereckschanze
-Fliehburg;Vryburg;Bauernburg;Fluchtburg;Volksburg
-Constantza;Tomis (altertümlich, griechisch);Tomoi (altertümlich, griechisch);Konstanz;Constantiana (altertümlich, lat.);Konstanza;Constanţa (rumänisch);Küstendje
-Gleitpunktzahl;Gleitkommazahl;Fließkommazahl
-dielektrische Funktion;Permittivität;dielektrische Leitfähigkeit
-Avalanche-Durchbruch;Lawinendurchbruch
-Durchschlagspannung;Überschlagspannung;Durchschlagsspannung;Überschlagsspannung
-Spannbaum;aufspannender Baum
-Mieminger Gebirge;Mieminger Kette
-Vertrag von Alcáçovas;Friede von Alcáçovas-Toledo;Vertrag von Alcáçovas-Toledo
-Motoren- und Turbinen-Union Friedrichshafen GmbH;Luftfahrzeug-Motorenbau GmbH (1909 bis 1918);Maybach Benz Motorenbau GmbH (1966 bis 1969);Maybach-Motorenbau GmbH (1918 bis 1966);MTU Friedrichshafen GmbH
-Nischni Nowgorod;Gorki (1932 bis 1990) (veraltet)
-Schlüsselburg;Nöteborg (schwedisch historisch);Petrokrepost (russisch veraltet, 1944-92)
-Inowrazlaw;Jungbreslau;Hohensalza (1904 bis 1920 und im 2. WK) (veraltet)
-Dritter Russisch-Schwedischer Krieg;Russisch-Schwedischer Krieg 1808-1809
-Smolensker Krieg;Russisch-Polnischer Krieg 1632-1634
-Krieblowitz;Blüchersruh (1937-1945) (veraltet)
-Lokalbahn Teplitz-Reichenberg;Nordböhmische Transversalbahn
-Insel des Glücks;Saadiyat
-Bijagós-Archipel;Bissagos-Archipel;Bissagosinseln
-Mariengrund (1936-1945) (veraltet);Poremba
-Schlacht bei Mohács;Schlacht am Berg Harsány
-Zügelauto (schweiz.);Umzugswagen
-Hawaiisch;hawaiische Sprache
-Morgenmuffel;Nachteule;Nachtmensch;Eule (ugs.)
-Lerche (ugs.);Morgenmensch;Frühaufsteher
-Rossknödel;Pferdeapfel;Pferdeexkrement (geh.);Rossbolle (süddt.);Pferdeappel (norddeutsch)
-Quantentheorie;Quantenmechanik
-Zeitrichtung;Zeitpfeil
-plastischer Sprengstoff;Plastiksprengstoff
-Sprengmittel (fachspr.);Sprengstoff
-Laubenpieper;Kleingartenbesitzer;Kleingärtner;Schrebergärtner
-Dichtung;Schrifttum;Schriften;Literatur;Schriftgut
-dahin;in diesem Sinne;in dem Sinne;dahingehend
-interpretieren;auffassen;verstehen;begreifen
-Faltrad;Klappfahrrad;Klapprad
-Gratzener Gebirge;Gratzener Bergland
-Weinsberger Forst;Weinsberger Wald
-synodische Periode;synodische Umlaufzeit
-28,95 Jahre;Inexperiode;358 Lunationen
-Durchschlupf;Ausweg;Hintertür;Mittel und Wege
-erhoffen;dürsten;der Hoffnung sein;erwarten
-Munitionsgürtel;Koppel
-Drehwaage;Torsionswaage
-Aggression;Überfall;Angriff
-kopflastig;verkopft;verstandgesteuert;kopfig;kopfgesteuert;verstandesbetont;intellektuell;eierköpfig (abwertend)
-Sympathie;Zustimmung;Anklang
-binden;festzurren;festmachen
-zur Verfügung stellen;herbeischaffen;ankarren
-drängen;anempfehlen
-'' (Einheitenzeichen);Inch (engl.);in (Einheitenzeichen);Zoll
-Pm (Einheitenzeichen);Petameter
-Terameter;Tm (Einheitenzeichen)
-Gigameter;Gm (Einheitenzeichen)
-nm (Einheitenzeichen);Nanometer
-Sächsische Semmeringbahn;Windbergbahn;Possendorfer Heddel
-Sächsische Semmeringbahn;Sebnitztalbahn
-Montag bis Freitag;werktags (ugs.);wochentags;von Montag bis Freitag;montags bis freitags;unter der Woche
-Voraussetzung;Antezedens (fachspr.);Antezedenz;Grund;Ursache
-Kescher;Käscher
-Öpik-Oort-Wolke;Oortsche Wolke;zirkumsolare Kometenwolke
-Komet Halley;Halleyscher Komet
-Eta-Aquariden;Mai-Aquariden
-Sternschnuppenschauer;Meteorschauer;Sternschnuppenschwarm;Meteorstrom
-Perseiden;Laurentiustränen (ugs.);Tränen des Laurentius (ugs.)
-Nahübersprechen;Nahnebensprechen
-Fernübersprechen;Fernnebensprechen
-Mäuseklavier (ugs., fig., scherzhaft);Mini-Schalter (ugs.);DIP-Schalter
-assertiv;(selbst-)behauptend
-Fischer-Tropsch-Verfahren;Fischer-Tropsch-Synthese
-Fischer-Tropsch-Kraftstoff;XtL-Kraftstoff
-Freigiebigkeit;Gebefreudigkeit;Spendabilität;Generosität;Spendierfreudigkeit;Großzügigkeit;Weitherzigkeit;Freigebigkeit;Großherzigkeit
-Ypernschlacht;Erste Flandernschlacht
-Zweite Ypernschlacht;Zweite Flandernschlacht
-Italienisch-Äthiopischer Krieg;Abessinienkrieg
-einstellbarer Kondensator;variabler Kondensator
-Drehkondensator;Korrektionskondensator;Regelkondensator;Drehko (ugs.)
-Trimmkondensator;Trimmer (ugs.)
-EU-Menschenrechtspreis;Sacharow-Preis für geistige Freiheit
-Novemberaufstand;Kadettenaufstand
-Vorsatz für Maßeinheiten;Einheitenpräfix;Einheitenvorsatz;Präfix;Vorsatz
-G-Sensor;Accelerometer;B-Messer;Beschleunigungsmesser;Beschleunigungssensor
-magnetische Permeabilität;magnetische Leitfähigkeit
-Durchlässigkeitsbeiwert;hydraulische Leitfähigkeit
-elektrische Leitwert;Konduktanz;Wirkleitwert
-Bloch-Wand;Bloch'sche Wand
-Bloch-Funktion;Bloch-Welle
-magnetischer Barkhausen-Effekt;Barkhausensprünge;Barkhausenrauschen
-zurücksetzen;nullen (ugs.);resetten
-Massenhersteller;Volumenhersteller;Großserienhersteller
-Fließbandfertigung;Fließband
-Königliche Kunst;Freimaurerei
-Schüttraummeter;Schüttmeter
-Grundkataster;Franciszäischer Kataster;Franziszeischer Kataster;Steuerkataster;Grundsteuerkataster
-Befremden;Erstaunen;Verwunderung
-Orgelspielerin;Organistin
-Fußballspielerin;Fußballerin
-Federbeinlager;Domlager
-zurückdrängen;reprimieren
-Kardiopulmonale Reanimation;Herz-Lungen-Wiederbelebung;Wiederbelebung;Reanimation
-verstanden;kapiert;durchschaut;begriffen
-situationell;von der Situation abhängen(d);okkasionell (geh.);kommt (ganz) darauf an (ugs.);situativ;situationsabhängig (Hauptform);von Fall zu Fall verschieden (ugs., variabel);vom (jeweiligen) Fall abhängen(d);fallabhängig;fallweise;kommt auf die Situation an (ugs.);situationsweise
-Entwicklungshilfe;Entwicklungszusammenarbeit
-Feststelltaste;Umschaltsperre;Caps Lock (engl.)
-Reaktionsschichtverschleiß;Tribooxidation
-Abstimmanzeigeröhre;Magisches Auge (ugs.)
-Wahrscheinlichkeitsaussage;probabilistische Aussage
-Regula-Falsi-Verfahren;lineares Eingabeln
-Newton-Raphsonsche Methode;Newtonsches Näherungsverfahren
-fortgesetzte Bisektion;Bisektion;Intervallhalbierungsverfahren
-Zimmermann-Telegramm;Zimmermann-Depesche
-kosmische Mikrowellenhintergrundstrahlung;kosmische Hintergrundstrahlung;Drei-Kelvin-Strahlung;CMB (fachspr.)
-Teilchenstrahlung;Korpuskularstrahlung;Korpuskular-Strahlung;Partikelstrahlung
-Höhenstrahlung (veraltet);Ultrastrahlung (veraltet);kosmische Strahlung
-Atomexplosion;Atomwaffenexplosion;Nuklearwaffenexplosion;Kernwaffenexplosion;Atombombenexplosion;Kernexplosion;Nuklearexplosion
-Aktion Grenze;Aktion Ungeziefer;Aktion G
-Fichenskandal;Fichenaffäre
-Navajo;Navaho;Diné
-Radiolarie;Strahlentierchen
-Expression;Ausprägung
-zweitrangig;in den Hintergrund geraten;unwichtig;zur Bedeutungslosigkeit absinken
-Infantizid;Kindstötung;Kindestötung;Kindsmord
-Trümmerlawine;Gerölllawine;Schuttlawine
-Fernschreiber;Telegraf
-scharf (Hauptform);geschärft;messerscharf
-Galley;Küche im Flugzeug oder Zug
-Siebenbürger Westkarpaten;Apuseni-Gebirge;Apusen
-westrumänische Karpaten;rumänische Westkarpaten
-Kreischland;Kreischgau;Kreischgebiet
-Feistelchiffre;Feistelnetzwerk
-Gebieterin;Herrin;Regentin
-Intervention von Shimonoseki;Triple-Intervention
-Weißmeer;Weißes Meer
-Grönlandsee;Grönlandmeer
-Ägäisches Meer;Ägäis
-Adria (Hauptform);Adriatisches Meer
-Kleine Syrte (veraltet);Golf von Gabès
-Große Syrte;Golf von Sidra
-Plattkarte;Rektangularprojektion
-Kartennetzentwurf;Kartenabbildung
-Tetragramm;JHWH;Tetragrammaton;JHVH
-Teil-zum-Ganzen-Beziehung;Meronymie
-Holonymie;Ganzes-Teil-Beziehung;Ganzes-zum-Teil-Beziehung
-einströmen;eindringen;einmarschieren;einfallen;invadieren
-Edelbitterschokolade;Kochschokolade (österr.);schwarze Schokolade;Bitterschokolade;Zartbitterschokolade;Herrenschokolade
-Masse Yvoire (westschweiz.);weiße Schokolade
-Exenteration (fachspr.);Eviszeration (fachspr.);Ausweidung
-ausweiden;auswerfen (fachspr., Jägersprache);ausdärmen;aufbrechen (fachspr., Jägersprache);ausnehmen
-bis spät in (...);bis tief in (...);bis sehr spät (ugs.);bis in die Puppen (ugs.);bis ultimo;sehr lange (außerhalb einer normalen Zeiteinteilung);bis Ultimo
-Doppelvokal;Zwielaut;Diphthong (fachspr.);Zweilaut
-Trennpunkte;Tüddelchen (ugs., norddeutsch, scherzhaft);liegender Doppelpunkt (auf Vokal) (ugs.);Tüttelchen (ugs., scherzhaft);Umlautpunkte;zwei Pünktchen (auf Vokal);zwei Punkte auf (einem) Vokal;Trema;zwei Punkte über (einem) Vokal
-Pariser Bluthochzeit;Bartholomäusnacht
-Tunnelbauer (ugs.);Mineur (franz.)
-Operation Stalemate II;Schlacht um Peleliu
-Erosionsverschleiß;Furchverschleiß;abrasiver Verschleiß
-Vergussanlage;Dosieranlage
-Folgeplattenpumpe;Fassfolgeplattenpumpe
-abrasiv;abschabend
-Schnellhobler;Stoßmaschine
-Stillstandsmarkierung;Riffelbildung;False Brinelling;Muldenbildung
-Garagenrock;Sixties Punk;Garage Punk;Garage Rock;Garage
-Leslie-Lautsprecher;Leslie (Kurzform);Leslie-Box;Rotationslautsprecher;Leslie-Tonkabinett
-Karussellgeschäft;Karussellbetrug
-Aquifer;Grundwasserhorizont (veraltet);Grundwasserkörper;Grundwasserträger (veraltet);Grundwasserleiter
-Monolith (fachspr.);Menhir;Hinkelstein
-freie Liebe (ugs.);ungeschützter Sex
-Restrukturierung;Umgestaltung;Refaktorisierung;Refaktorierung
-Komponententest;Modultest
-Berganfahrhilfe;Berganfahrassistent
-Bucht von Bonny;Bucht von Biafra (veraltet)
-Lars Christensen-Land;Mac-Robertson-Land
-Hot-Carrier-Diode;Schottky-Barriere;Schottky-Diode
-Durchlassspannung;Knickspannung;Schwellenspannung;Schleusenspannung;Kniespannung
-I-U-Charakteristik;Strom-Spannungs-Kurve;U-I-Diagramm;Strom-Spannungs-Kennlinie
-Helmholtz-Thévenin-Theorem;Helmholtz-Satz;Thévenin-Theorem
-Steuerstab;Kontrollstab;Regelstab
-Iran-Contra-Affäre;Irangate
-klassenlose Objektorientierung;prototypenbasierte Programmierung
-(etwas) (von jemandem) erben;ererben (veraltet)
-Seewalze;Seegurke
-Schütteltrichter;Scheidetrichter
-RI-Fließbild;R&I-Schema;R+I-Fließbild;R&I-Fließbild;R&I-Diagramm
-hinhaltend;verzögernd;aufschiebend;dilatorisch
-Verbunddampfmaschine;Mehrfach-Expansionsmaschine
-Kesselzerknall;Kesselexplosion
-Herrenkunst (historisch, veraltet);Wasserkunst (Hauptform);Wasserhaltung(sanlage);(historische) Pumpenanlage
-schlüssiges Handeln (fachspr.);konkludentes Handeln (fachspr.);konkludente Handlung (fachspr.);stillschweigende Willenserklärung (fachspr.);schlüssiges Verhalten (fachspr.)
-Kaiser-Jubiläums-Spital (veraltet);Krankenhaus Lainz (veraltet);Krankenhaus Hietzing
-Südböhmischer Talkessel;Budweis-Wittingauer Tiefplatte
-Wittingauer Pfanne;Wittingauer Becken
-Online-Petition;E-Petition
-Unternehmergesellschaft (haftungsbeschränkt);UG (haftungsbeschränkt);Mini-GmbH (ugs.)
-Höhenschichtlinie;Höhenlinie;Niveaulinie;Isohypse
-Isobathe;Tiefenlinie
-Niveaulinie;Isarithme;Konturlinie;Isolinie
-Äquipotenzialfläche;Äquipotentialfläche;Potenzialfläche
-mittelrussische Platte;mittelrussischer Landrücken
-Netzgemeinschaft;Online-Community
-Prosodie;Satzmelodie;Wortakzent;Prosodik (veraltet);Silbenbetonung
-kubisches Gitter;kubisches Kristallsystem
-Bravais-Gitter;Raumgitter
-Translation;Parallelverschiebung
-Formgedächtnislegierung;Memorymetall
-Gemarchen (schweiz.);Katastralgemeinde (österr.);Gemarkung (Hauptform);Markung
-direktiv;anweisend
-kodifizieren;in Gesetzesform bringen
-Schneewittchensarg (ugs., fig., scherzhaft-ironisch);Volvo P1800 ES
-Traktandum (schweiz.);TOP;Tagesordnungspunkt
-Buys-Ballot-Regel;barisches Windgesetz
-Kinderpinkeln;Babypinkeln;Pullerparty (ugs.);Kindpinkeln;Babybier;Pissparty (ugs.);Pinkelparty
-größter Hörsaal einer Hochschule;Auditorium Maximum (lat.);Audimax (Kurzform)
-Datei;Akte
-Astrolabium (fachspr., griechisch);Astrolab (fachspr., griechisch);Planisphärum (fachspr., griechisch);Sternhöhenmesser
-Astrogeodäsie;geodätische Astronomie
-temporale Stunden;römische Stunden;jüdische Stunden;antike Stunden;biblische Stunden
-Gerätehorizont;Instrumentenhorizont
-Nivelliergerät;Nivellier;Nivellierinstrument
-Skioptikon;Laterna magica
-Kirchenschiff;Kreuzschiff
-Neoromanik;Neuromanik
-Beweglichkeit;Motorik
-organische Leuchtdiode;OLED
-Supplementierung;Nahrungsergänzung;Supplementation
-Lichtblitz;Blitz;Aufleuchten
-Fachbuch;Einzeldarstellung
-Höhe;Höhenwinkel;Elevation;Altitude
-Zenitwinkel;Zenitdistanz
-normsetzend;präskriptiv;wertend;vorschreibend;normativ;normierend;normgebend
-die Schallmauer kreuzend;Über- und Unterschallgeschwindigkeit betreffend;transsonisch
-trilateral;dreiseitig
-Massenträgheitsmoment;Drehmasse (veraltet);Trägheitsmoment;Inertialmoment
-linearer Raum;Vektorraum
-Aufpunktvektor;Ortsvektor;Radiusvektor
-Holzbremse;Pronyscher Zaum;Backenbremse
-Kriegsanlass;Casus belli
-Kullback-Leibler-Divergenz;KL-Divergenz;Kullback-Leibler-Abstand;Kullback-Leibler-Information;Kullback-Leibler-Entropie
-Kymrisch;Walisisch
-Kolubrine;Feldschlange
-Kerckhoffs' Prinzip;Kerckhoffs'sches Prinzip;Kerckhoffs' Maxime
-Whirlpool-Galaxie;NGC 5194/5195;Messier 51
-Gründerzentrum;Existenzgründerzentrum;Technologiezentrum;Innovationszentrum
-Trouvaille (franz.);Glücksfund;Fundstück;Ringeltaube (ugs., fig., veraltend)
-Schlussrechnung (österr.);Proportionalität;Verhältnisgleichung;Regel de tri (veraltet);Dreisatz;Schlüsse
-Kleinspannung;Niedervolt (ugs.);Schwachstrom (ugs.)
-galvanische Trennung;galvanische Entkopplung
-Adhäsionsbahn;Reibungsbahn
-Mendenhall-Gletscher;Auke-Gletscher (veraltet)
-Dinarische Alpen;Dinariden;Dinarisches Gebirge
-Außenleiter;Polleiter (schweiz.)
-Differentialgetriebe;Differenzial;Ausgleichsgetriebe;Differential;Differenzialgetriebe
-Planetenradgetriebe;Planetengetriebe;Planetenrädergetriebe;Umlaufrädergetriebe
-Kohlenoxychlorid;Kohlenoxiddichlorid;COCl2 (Abkürzung, chemisch);Phosgen;Carbonylchlorid;Kohlensäuredichlorid
-Scheinselbständigkeit;Scheinselbstständigkeit
-Hair Metal;Glam Metal;Pudel-Rock
-Friedensdiktat;Siegfrieden;Diktatfrieden;Friedenstraktat
-(jemanden) (schnell) abfertigen;(schnell) erledigen;abfrühstücken (ugs.)
-Hysterese (griechisch);(magnetische) Nachwirkung;Hysteresis (griechisch)
-weissscher Bezirk;Weiss-Bezirk
-Schaltnetzgerät;Schaltnetzteil
-(einen Stoff) in Falten legen;drapieren
-Budapester Vertrag;Konvention von Budapest
-Tuwinische Volksrepublik;Tannu-Tuwa
-Mitkämpfer;Mitstreiter;Kombattant
-AB-Stereofonie;Laufzeitstereofonie
-Knochenleitung;Knochenschall
-wegweisend;seiner Zeit (weit) voraus;richtungsweisend;bahnbrechend;visionär;zukunftsweisend
-globulär (fachspr.);kugelförmig;kugelrund;rund;sphärisch (geh.);kugelig
-präzedieren (fachspr.);(eine) Präzession(sbewegung) ausführen (fachspr.)
-Mehrfachspalt;Beugungsgitter;optisches Gitter
-Stapa-Rohr;Stahlpanzerrohr
-(Ost-)Friesenspieß (ugs.);Bundesautobahn 31;Emslandautobahn
-Handschrift;Manuskript
-Editionswissenschaft;Editionsphilologie
-axumitisches Reich;aksumitisches Reich
-Digital-Analog-Umsetzer;D/A-Wandler;Digital-Analog-Wandler
-Analog-Digital-Umsetzer;A/D-Wandler;Analog-Digital-Wandler
-Wandler;Umsetzer
-geplant;nach Plan;konzeptionell
-Bilanz ziehen;aufschlüsseln;Bilanz machen;bilanzieren
-bilanziert;aufgeschlüsselt
-Folgeradar;Feuerleitradar;Zielverfolgungsradar;Verfolgungsradar
-Zwillingsbereifung;Doppelbereifung
-Hottentottenfeige;Hexenfinger;Pferdefeige;Gelbe Mittagsblume;Essbare Mittagsblume
-umnebeln;vernebeln;einnebeln
-Wiener Schlussakte;Bundes-Supplementar-Akte;Schlussakte der Wiener Ministerkonferenz
-Zweiter Schleswigscher Krieg;Deutsch-Dänischer Krieg;Zweiter Schleswig-Holsteinischer Krieg
-Eider-Canal;Schleswig-Holsteinischer Kanal (veraltet);Schleswig-Holsteinischer Canal (veraltet);Eider-Kanal
-Waigri;Waari;Wagrier
-Jütische Halbinsel;Cimbrische Halbinsel;Kimbrische Halbinsel
-Papageitaucher;Papageientaucher
-Watvögel;Limikolen;Regenpfeiferartige
-Ichthyologie;Fischkunde
-relativistische Längenkontraktion;Lorentzkontraktion
-Humoraltherapie;ausleitende Verfahren;Aschner-Verfahren
-Golfklasse (ugs.);Kompaktklasse
-Freileitung;Überlandleitung
-erfunden;ersonnen;(nur) vorgestellt;erdichtet;fiktiv;fiktional (Textgattung) (fachspr.);erdacht;konstruiert (Fall, Beispiel);ausgedacht
-vinieren;spriten;aufspriten
-Frankiermaschine;Frankiersystem;Freistempelmaschine
-Rendern;Bildsynthese
-Rechtevergabe;Delegation;Rechtekontrolle;Ermächtigung
-Südpolarmeer;Südliches Eismeer;Antarktik;Südlicher Ozean;Antarktischer Ozean (Hauptform)
-stimmt genau;Volltreffer! (Ausruf) (ugs.);jawoll! (ugs.);goldrichtig (ugs.);Bingo! (Ausruf) (ugs.)
-Kronenberge (veraltet);Pieninen
-Erdschleife;Brummschleife
-Bosnische Spurweite;Bosnaspur
-überlagerter Wechselstrom (fachspr.);Rippelstrom
-Kreisfehlerwahrscheinlichkeit;Streukreisradius
-Varianz-Kovarianz-Matrix;Kovarianzmatrix
-Körpergefühl;Körperempfindung
-Kapselheber;Flaschenöffner;Bieröffner (ugs.);17er-Schlüssel (ugs., scherzhaft)
-anordnend;dispositiv;verfügend
-Flusssäure;Fluorwasserstoffsäure
-azeotropes Gemisch;Azeotrop
-Juan-Fernández-Inseln;Juan-Fernández-Archipel
-Äolsharfe;Aeolsharfe;Geisterharfe;Windharfe;Wetterharfe
-ausverkaufen;abverkaufen
-Inseln über dem Winde;Inseln im Wind (veraltet)
-Kurpfalz-Bayern;Pfalz-Baiern (zeitgenössisch);Churpfalz-Baiern (zeitgenössisch)
-Krieg der Augsburger Allianz;Pfälzischer Erbfolgekrieg;Orléansscher Krieg;Krieg der Großen Allianz;Neunjähriger Krieg
-isostatische Bodenhebung;postglaziale Landhebung
-Markscheiderei (ugs.);Markscheidewesen;Markscheidekunde
-Motel;Motor Hotel
-Hardcopy (veraltend);Bildschirmkopie;Screenshot;Bildschirmfoto
-Geschosswerfer;Raketenartillerie;Raketenwerfer
-tordieren;verdrehen
-drehend;trudelnd (ugs.);rotatorisch;rotierend;kreisend
-Armenisches Hochland;Ararathochland
-Schlörwagen;Göttinger Ei
-beleihen;entleihen
-Trichromatische Theorie;Young-Helmholtz-Theorie;Dreifarbentheorie
-Epsilon-Tensor;total antisymmetrischer Tensor;Permutationssymbol;Levi-Civita-Symbol
-Generalinspekteur;oberster Soldat (ugs.)
-Preußische Nordbahn;Berliner Nordbahn
-Mustertheorie;Theorie der Design-Patterns;Lehre von den Gestaltungsmuster
-Foucault'sches Pendel;foucaultsches Pendel
-Urtiter;primärer Standard;Urtitersubstanz
-helliges pH-Meter (fachspr.);pH-Meter;pH-Messkette
-Normalität (veraltet);Äquivalentkonzentration
-Titrimetrie;Volumetrie;Maßanalyse;Titration
-Punktlicht;Spotlight
-artifizielle Störung;Münchhausen-Syndrom
-Wirbel;Hin und Her;Trubel;Gewiggel (ugs., regional);Rummel;Durcheinander
-Deutsches Meer (veraltet);Nordsee (Hauptform)
-Freilandstraße (österr.);Außerortsstraße
-(etwas) vom Stapel lassen (ugs., fig.);(etwas) von sich geben;(etwas) verlauten lassen
-Drost;Drossart
-Nebenbuhler;Mitbewerber;Rivale;Konkurrent
-Entwurfselement;Trassierungselement
-Sanitätswesen;Sanitätsdienst;Sanität (schweiz., österr.)
-befriedeter Bezirk;Bannmeile;Bannkreis
-westtürkische Sprache;kiptschakische Sprache
-Schloss Wackerbarth;Wackerbarths Ruh'
-Jahrgangsstufe;Klassenstufe;Schulstufe (schweiz., österr.)
-Portalfräswerk;Portalfräse;Portalfräsmaschine
-Wechselrichter;Inverter
-Straßenmöbel;Stadtmöbel
-Die Söhne des Osiris;Freimaurer
-adeliger Ständestaat;Adelsrepublik
-Saporoger Kosaken;Saporoscher Kosaken
-Krimtataren;Krimtürken
-(sich etwas) ausspucken lassen (ugs.);(sich etwas) ausgeben lassen
-Olympiasieger;Olympionike
-Panthersprung nach Agadir;zweite Marokkokrise
-Reisiger;reisiger Knecht
-Fiffi (ugs., salopp);Hundling;Hündchen;Wadenbeißer (abwertend, fig.);Hundchen;Zamperl (bayr., schwäbisch)
-Oderbergland;Oderberge;Odergebirge
-Fiedelhübel (veraltet);Lieselberg
-Böhmisch-Mährisches Plateau;Böhmisch-Mährischer Gebirgsrücken;Böhmisch-Mährische Höhe;Mährischer Rücken;Böhmisch-Mährischer Höhenrücken;Böhmisch-Mährische Hochfläche;Böhmisch-Mährischer Höhenzug;Böhmisch-Mährisches Bergland
-Andalusisches Faltengebirge;Betische Kordillere
-Osning (veraltet);Teuto (ugs.);Teutoburger Wald (Hauptform)
-(bewusst) vorwegnehmend;antizipatorisch
-Dreschkasten;Dreschmaschine
-Hopen;Hoffnungsinsel (veraltet)
-perfektiv;perfektivisch;vollendet
-unvollendet;imperfektiv;imperfektivisch
-Heizwert;Energiewert (ugs.);Energiegehalt (ugs.)
-Mischwesen;Chimäre;Schimäre
-xeromorph;xerophytisch
-borealer Wald;borealer Nadelwald;boreale Nadelwaldzone;Taiga
-Schandkragen;Schandgeige;spanische Geige;Halsgeige
-Lästerstein;Lasterstein;Schandstein
-Fränkischer Jura;Frankenjura;Frankenalb;Fränkische Alb
-niedere Gerichtsbarkeit;patrimoniale Gerichtsbarkeit;Dorfgericht;Thinggericht;Hubengericht;Niedergerichtsbarkeit
-hohe Gerichtsbarkeit;Grafschaftsrecht;Vogteirecht;Blutgerichtsbarkeit;Halsgerichtsbarkeit;Blutbann;Hochgerichtsbarkeit
-Pranger;Schandpfahl;Kaak
-Staupenstreichen;Stäupen;Staupen;Stäupung;Staupenschlag
-Profoss;Provost (veraltet);Profos;Profoß (veraltet);Profot (veraltet)
-Spitzrutenlaufen;Gassenlaufen;Spießrutenlaufen
-Kreuz des heiligen Georg;Georgskreuz;Sankt-Georgs-Kreuz
-Wettlaufsituation;kritischer Wettlauf
-Karnaugh-Veitch-Symmetrie-Diagramm;Karnaugh-Veitch-Diagramm;Karnaugh-Plan;Karnaugh-Tafel;KVS-Diagramm;K-Diagramm;KV-Diagramm
-Sörmland;Södermanland
-Mellersee (veraltet);Mälaren;Mälarsee
-Stalinbahn;Polarkreiseisenbahn;Stalineisenbahn
-Nahuatl;Aztekisch;Mexikanisch (veraltet)
-Tschitschen (veraltet);Istrorumänen
-Ranen;Rujanen
-Sorbenmark;Sorbische Mark
-Oskisch-umbrische Sprachen;Sabellische Sprachen
-Steuerung;Dampfmaschinensteuerung
-Karl-Schultz-Schieber;Nicolai-Kolbenschieber
-Trofimov-Schieber;Trofimoff-Schieber;Troffimoff-Schieber;Trofimof-Schieber
-Selketalbahn;Anhaltische Harzbahn;Gernroder-Harzgeroder Eisenbahn
-Jeschkenkamm;Jeschkengebirge
-Bahnstrecke Trmice-Bílina;Bielatalbahn (veraltet)
-Bahnstrecke Kolín-Decín;Elbetalbahn
-Riesenmammutbaum;Sequoiadendron giganteum (fachspr., botanisch);Berg-Mammutbaum;Wellingtonie
-Metasequoie;Urweltmammutbaum;Wassertanne;Chinesisches Rotholz
-Gesamtheit;Totalität;Insgesamt;Ganzes;Ganzheit;Ensemble (geh., franz.)
-rotes Blutkörperchen;Erythrozyt
-Willebrand-Jürgens-Syndrom;Angiohämophilie;von-Willebrand-Jürgens-Syndrom;von-Willebrand-Krankheit
-Hämorrhagische Thrombozytendystrophie;Bernard-Soulier-Syndrom
-Thrombozytopathie;Thrombopathie
-Jägersprache;Waidmannssprache;Jägerlatein (ugs.)
-besitzend;habend
-habhaftig;mit Besitz versehen
-Kaolin;Porzellanton;weiße Tonerde;Porzellanerde;Pfeifenerde;Aluminiumsilikat;Bolus Alba
-Schweißhemmer;Antitranspirant
-anregen;exzitieren (Medizin) (fachspr.)
-Totschlagargument (Hauptform);Killerphrase (ugs.);Killerargument;Scheinargument
-Wertschutzraum;Tresorraum
-im Laufe der Jahre;im Lauf der Jahre;im Lauf der Zeit;auf (die) Jahre gerechnet;mit den Jahren;mit der Zeit;im Lauf vieler Jahre;über die Jahre;im Laufe der Zeit;auf (die) Jahre gesehen
-Feinarbeit;Feinschliff (ugs.)
-memorabel (geh., bildungssprachlich);denkwürdig;erinnerungswürdig;erinnernswert (geh.)
-Penne;Pennal
-Sinti;Manusch
-geglückt;gut geraten;gelungen
-(gehen / laufen / sich fortbewegen) wie der Storch im Salat (ugs.);staksen;stöckeln
-Hektografie;Hektographie
-ohne gemeinsame Teilmenge;schnittmengenfrei;elementfremd;durchschnittsfremd;disjunkt (fachspr.)
-nach Ansicht von;in den Augen von;nach Auffassung von;nach Meinung von
-Schermodul;Schubmodul;Gleitmodul;Torsionsmodul;G-Modul
-taggen;etikettieren (fig.);labeln (fig.);mit Schlagwörtern versehen;verschlagworten
-Westlicher Bug;Bug
-Polnischer Erbfolgekrieg;Polnischer Thronfolgekrieg
-Ein-Euro-Job (ugs.);Arbeitsgelegenheit mit Mehraufwandsentschädigung (fachspr.)
-Meton-Periode;Enneakaidekaeteris;Enneadekaeteris
-Festwertspeicher;Nur-Lese-Speicher
-trilineare Interpolation;trilineare Filterung
-bilineare Interpolation;bilineare Filterung
-Neurophysiologie;kognitive Neurowissenschaften;Neurowissenschaften;Gehirnforschung;Hirnforschung;Neurobiologie
-Muffelwild;Europäischer Mufflon;Wildschaf;Muffel (ugs.)
-Lochkartenlocher;Lochkartenstanzer
-ausreißen;wegreißen;herausreißen;abreißen
-Stabilisatorstütze;Pendelstütze;Koppelstange
-Industriemeister;Werkmeister (österr.)
-Taufbecken;Fünte (norddeutsch);Taufstein
-Parallaxenfehler;Parallaxefehler
-Mainzer Stiftsfehde;Badisch-Pfälzischer Krieg
-Bayerischer Krieg (1459-1463);Fürstenkrieg
-Großer Krieg der Herren;Bayerischer Krieg (1420-1422)
-Enkeltochter;Großtochter;Enkelin
-Großsohn;Enkelsohn;Enkel
-(sich) ungeschickt ausdrücken;nicht den richtigen Ton treffen;(sich) im Ton vergreifen;(etwas) so nicht verstanden wissen (wollen);(sich) unglücklich ausdrücken
-mit dem ersten Hahnenschrei;in aller Herrgottsfrühe (ugs.);in aller Frühe;(sehr) früh;beim ersten Sonnenstrahl;mit dem ersten Sonnenstrahl;beim ersten Hahnenschrei
-Petrogenese (fachspr.);Lithogenese (fachspr.);Gesteinsbildung
-Petrologie;Steinkunde
-Vitriolschiefer;Alaunschiefer
-Europäisches Polizeiamt;Europol
-Vertrag von Luxemburg;Saarvertrag
-suspendierend;suspensiv
-mehr schaden als nützen;(jemandem) ungewollt Schaden zufügen;(jemandem) einen Bärendienst erweisen (sprichwörtlich);unbeabsichtigt schädigen;mehr Schaden anrichten als Nutzen stiften (variabel);mehr kaputtmachen, als dass es hilft (ugs.);(jemandem) einen schlechten Dienst erweisen
-Festungsarrest;Festungshaft;Einschließung;Ehrenhaft;Festungsstrafe;Custodia Honesta (geh., lat.)
-fächerartig ausbreiten;auffächern
-Kleinlitauen;Preußisch-Litauen;Deutsch-Litauen (veraltet)
-Friede von Melnosee;Friede von Meldensee
-Samogiten (historisch);Samaiten;Zemaiten
-Hornhaut (ugs.);Tylom (fachspr.);Tylosis (fachspr.);Tylositas (fachspr.);Hornschwiele
-Weißenburg i.Bay. (amtlich);Weißenburg am Sand (veraltet);Weißenburg in Bayern;Weißenburg im Nordgau (veraltet)
-ungeschmälert;unvermindert
-geschmälert;vermindert
-Durchscheinbild;Diorama
-Camphora;Campher;Kampfer
-Stein-Hardenberg'sche Reformen;Preußische Reformen
-Picatinny-Schiene;NATO-Schiene (ugs.)
-Fraktionsdisziplin (verhüllend);Fraktionssolidarität (positiv);Klubdisziplin (österr.);Klubzwang (österr.);Fraktionszwang
-jahreszeitlich;saisonal
-saisonabhängig;saisonbedingt
-Lausbubenstreich;Schabernack;Schelmenstück;Lausbüberei;Hanswurstiade (geh., veraltend);Eulenspiegelei;Dummejungenstreich (Hauptform);Donquichotterie (geh.);Schelmenstreich;Jungenstreich;Bubenstück;Bubenstreich
-Bassin;Wasserbecken
-Diskontierung;Abzinsung
-auf Grund des Wetters;wetterbedingt;aufgrund des Wetters;witterungsbedingt
-davon kommen;daher rühren
-Blindleistungskompensation;Blindstromkompensation
-Kieler Affäre;Barschel-Affäre;Waterkantgate;Barschel-Pfeiffer-Affäre
-gegenseitige Information;Transinformation
-zusammenführen;einschieben;schieben;hineinschieben;stecken;einführen;introduzieren (fachspr., medizinisch)
-Pitzbach;Pitze
-Hospiz (schweiz., südtirolerisch);Berghütte;Schutzhütte;Schutzhaus;Hütte
-Vernagthütte;Würzburger Haus
-Berghaus (schweiz.);Berggasthaus;(touristisch bewirtschaftete) Almhütte (variabel);Berggasthof
-prothetisch;als Ersatz dienend
-nigrisch;aus dem Niger;aus Niger
-abzählbar;quantifizierbar;zählbar
-Trobador (fachspr.);Troubadour (fachspr., franz.);Minnesänger (fachspr.)
-Kulturerdbeere;Gartenerdbeere;Ananas-Erdbeere
-Abwrackprämie;Umweltprämie;Verschrottungsprämie
-Bespitzelung;Spionage;(das) Ausspähen;Spitzelei;(das) Ausschnüffeln;(das) Ausspionieren;Schnüffelei;Lauschangriff;Ausspähung
-Seilpark;Seilgarten
-zerpflücken;auseinanderpflücken
-kundennah;kundenorientiert
-Monokel;Einglas
-Punktation (österr.);Vorvertrag
-Fakultät;Fachbereich;Universitätsabteilung
-Fakultät;Faktorielle (österr.)
-einzementieren (fig.);perpetuieren (geh.);zementieren (fig.);festschreiben;in Stein meißeln (fig.);einbetonieren (fig.)
-Pulawski-Flügel;Polnischer Flügel
-Geburtsstuhl;Gebärschemel;Gebärstuhl
-Romarad;Geburtsrad
-Anwaltsbüro;Anwaltsfirma;Anwaltskanzlei;Kanzlei;Rechtsfirma
-Oktalsystem;Achtersystem
-Dezimalsystem;Zehnersystem;dekadisches System;Denärsystem
-handelnd;enaktiv (fachspr.)
-Elektrum;Elektron
-Niederbayerisches Bäderdreieck;Rottaler Bäderdreieck
-Tertiäres Hügelland;Tertiärhügelland
-Oberschwäbische Hochebene;Donau-Iller-Lech-Platte
-Würmzeit (fachspr.);Würm (fachspr.);Würmeiszeit (ugs.);Würm-Kaltzeit;Würm-Glazial
-Bildungsprozessmanagement;Bildungscontrolling
-Kapostroph;Deppenapostroph (ugs.);Apostrophitis;Idiotenapostroph (ugs.);Katostroph
-Amazonasbecken;Amazonien;Amazonastiefland
-verfilmen;auf die Leinwand bringen (ugs.);filmisch darstellen;filmisch umsetzen
-pharmazeutische Industrie;Pharmaindustrie
-nachbuchen;nachträglich buchen;hinzubuchen;zubuchen;zusätzlich buchen
-Zschone;Zschoner Grund
-Agrartechnik;Landtechnik;Landmaschinentechnik;Agrotechnik
-geographische Gewässerkunde;Hydrographie
-Wiedergutmachungszahlungen;Reparationszahlungen
-jeden;jedweden
-Versaufloch (ugs.);gesenktes Deck;Tiefdeck;Brunnendeck;Welldeck
-Webseminar;Seminar im World Wide Web;Web-Seminar;Webinar (ugs.)
-Kehrichtschaufel (norddeutsch);Mistschaufel;Kehrschaufel;Kehrblech (regional)
-Schneeschieber (niederdeutsch);Schneeschaufel
-Filtrierung;Filterung;Filtern;Filtration
-Sigmakörper;Borelscher Mengenkörper;σ-Algebra;σ-Mengenalgebra
-unbezwingbar;unbesiegbar;unschlagbar;nicht kleinzukriegen
-zwölf Nächte;Glöckelnächte;Zwölfte;Raunacht;Rauhnacht;Rauchnacht
-Zwölften;Zwölf Weihnachtstage
-helfend zureichen;hinüberreichen;anreichen
-Steuerbarsch;Ruderbarsch;Pilotbarsch
-Handbeil;Richtbeil
-atmosphärische Uhr;Atmos-Uhr
-Drehpendel;Torsionspendel
-Organisation Schmelt;Dienststelle Schmelt
-Federschwinger;Federpendel
-hinwegsehen (über);hinwegschauen (über)
-Allradler (ugs.);Allrad;Allradfahrzeug
-Rangflagge;Kommandozeichen;Fanion (schweiz.);Kommandoflagge
-(großer, schwerer, gravierender) Fehler;Riesendummheit;Kardinalfehler;Riesenfehler;Todsünde (fig.)
-Abkehrschein (veraltet);Dienstzeugnis (österr.);Arbeitszeugnis
-umverteilen (Hauptform);anders verteilen (ugs.);umschichten;neu aufteilen (ugs.)
-nervenaufreibend;nervenzerreißend;nervenzerfetzend
-Swanfassung;Bajonettsockel;Swansockel
-Lampenfassung;Lampensockel
-Balun;Symmetrierglied
-Soffittenlampe;Soffitte (fachspr.)
-verlustbringend;defizient;defizitär
-pathologische Physiologie;Pathophysiologie
-Bauernland (ugs.);Agrarland
-Nationenwertung (ugs.);Medaillenspiegel
-H&M;Hennes & Mauritz
-Eloxal;elektrolytisch oxidiertes Aluminium
-Elementsymbol;Atomsymbol
-Tisza-Kultur;Theiß-Kultur
-östliche Linearbandkeramik;Alföld-Linearkeramik
-Bükker Kultur;Bükk-Kultur
-Vornotenkopfkeramik;Linearbandkeramische Kultur;Bandkeramische Kultur;Notenkopfkeramik
-Wahrnehmungssignal;Signalreiz;Schlüsselreiz;Auslöser
-blumig;blumenreich;blumenhaft
-Spritschlucker (ugs.);Säufer (ugs., fig.);Spritschleuder (ugs.);Spritverschwender;Spritfresser (ugs.)
-Karwendelbahn (ugs.);Mittenwaldbahn
-Solbad Hall (1938-1974) (veraltet);Hall in Tirol
-Periadriatisches Lineament;Periadriatische Naht;Alpin-dinarische Grenzstörung;Alpin-dinarische Narbe
-Mail-Addy (ugs.);Mailaddy (ugs.);Addy (ugs.);E-Mail-Adresse;E-Mail-Addy (ugs.)
-distinktiv;unterscheidend
-Herzeln;Fünferspiel;Kein Stich;Schwarze Sau;King Louis;Fritz;Pensionisteln;Brumseln
-Zeolith;Siedestein
-Eurafrasien;Europafrikasien;Afrika-Eurasien
-Totem;Pfadfindername;Fahrtenname;Indianername
-herausbringen;auf den Markt werfen;(etwas) auf den Markt bringen;heraushauen (ugs., salopp);(etwas) vom Stapel laufen lassen (ugs.);(etwas) vom Stapel lassen (ugs.)
-Coedukation (veraltet);Koedukation;Gemeinschaftserziehung (veraltet)
-Seedukation;Monoedukation
-Rubelkrise;Russlandkrise
-Preußischer Städtekrieg;Dreizehnjähriger Krieg
-Artenvielfalt;Artendiversität;Artenreichtum
-Phonemvariante;Allophon;subphoneme Variante
-Geldschöpfungsgewinn;Seigniorage (fachspr., franz.);Schlagschatz (historisch);Schlagsatz (historisch);Münzgewinn (historisch)
-Lehnschaft;Feudalwesen;Lehnwesen;Benefizialwesen;Lehnswesen;Lehenswesen
-Orientalische Krise;Balkankrise
-Anglikanische Gemeinschaft;Anglikanische Kirche (ugs.);Anglikanische Kommunion
-(Kraftstoff) verbrauchen;schlucken (ugs.);saufen (ugs.);fressen (ugs.)
-Durchflusskoeffizient;Kv-Wert;Durchflussfaktor
-Moldauer;Moldawier
-IUU-Fischerei (fachspr.);Piratenfischerei
-Fuhre;Fuhrwerk
-geschacht;geplätzelt;gewürfelt
-Mähren;Morawien
-chemische Thermodynamik;Thermochemie
-mit Mühe verbunden;mühevoll;kein Sonntagsspaziergang (ugs., fig.);hart;kraftraubend;kein Zuckerlecken (ugs., fig.);(eine) Herausforderung (verhüllend);kein Zuckerschlecken (ugs., fig.);auszehrend;schwer;schlauchend;kraftzehrend;mühsam;anstrengend;schweißtreibend;kräftezehrend;mühselig;strapaziös;beschwerlich
-idealisiert;glorifiziert;überschätzt;überbewertet
-Kaskade;Kette
-(etwas) ausbaden (müssen) (ugs.);(der / die) Hauptleidtragende(n) sein;(für etwas) bluten (müssen) (ugs., fig.);die Konsequenzen tragen (müssen);(den) Kopf hinhalten (müssen für) (fig.);(die) volle Wucht zu spüren bekommen;die Zeche zahlen (müssen) (ugs., fig.);die Suppe auslöffeln (müssen) (ugs., fig.);(der / die) Leidtragende(n) sein;es voll abkriegen (ugs.)
-durchdrücken;durchboxen (fig.);erzwingen;durchsetzen (Hauptform);durchpeitschen;durchbringen;durchstieren (schweiz.);ertrotzen (geh., veraltend);erstreiten;durchpauken (bundesdeutsch)
-Äl;Ale
-optimiert;zugeschnitten;angepasst;abgestimmt
-Aliquotregister;Obertonregister;Hilfsstimmen;Aliquotstimmen
-Säkularkanonikerstift;Stiftskapitel;Kollegiatstift
-Teleobjektiv;Tele (ugs.)
-Right Livelihood Award;Alternativer Nobelpreis
-gieriger Algorithmus;Greedy-Algorithmus
-Kopiar;Kartular;Kopialbuch;Chartular;Copeibuch
-Reichskriegsverfassung;Reichsheeresverfassung
-Worthülse;nur um (überhaupt) (irgend)etwas zu sagen;Blähwort (fachspr.);Redeblume (geh., veraltet);(leere) Floskel (variabel);(bloße) Phrase;leere Phrase (ugs.);inhaltsleeres Geschwätz (variabel);hohle Phrase (ugs., Hauptform);Nebelwort;Sprechblase (ohne Inhalt) (ugs., fig.);Leerformel;Wortgirlande(n) (fig.)
-keine Pause machen;ohne Pause arbeiten;durcharbeiten;durchmachen (ugs.);pausenlos arbeiten
-Balkanfeldzug;Unternehmen Marita
-Augmentativum;Vergrößerungsform;Augmentativ
-Donaudeutsche;Donauschwaben
-Ethnonym (fachspr.);Demonym (fachspr.);Volksbezeichnung (Hauptform);Völkername;Ethnikon (fachspr.)
-Große Raubmöwe;Skua
-Selbstklinger;Idiophon;Selbsttöner
-Militärnachrichtendienst;Militärgeheimdienst
-à la bonne heure! (geh., franz.);reife Leistung! (ugs., variabel);holla, die Waldfee! (ugs., Spruch);(mein) Kompliment!;Nicht schlecht, Herr Specht! (ugs., Spruch);Respekt! (ugs.);alle Achtung!;Hut ab! (ugs.);recht so!;ein Hoch auf ...!;bravo!;ein Lob der (...)!;ausgezeichnet!;ein Lob dem (...)!;Chapeau;sauber! (ugs.);vortrefflich! (scherzhaft-ironisch, veraltend);gut gemacht! (ugs.)
-Wettbewerbskommission (Schweiz);Bundeswettbewerbsbehörde (Österreich);Kartellamt;Wettbewerbshüter (mediensprachlich);Kartellbehörde (Hauptform);Bundeskartellamt (Deutschland);Generaldirektion Wettbewerb der Europäischen Kommission (EU);Wettbewerbsbehörde
-Ablöschen;Deglacieren
-Permalink;permanenter Hyperlink;Permanentlink
-verfügbar halten;(zum Abruf) bereithalten;in Bereitschaft halten;vorhalten;vorrätig halten
-Nickligkeit;Hinterfotzigkeit;Dreistigkeit;Biestigkeit;Frechheit;Hinterlistigkeit;Nickeligkeit;Gemeinheit;Boshaftigkeit
-Rosenthal-Effekt;Pygmalion-Effekt
-Segelohren (ugs.);abstehende Ohren
-unbesorgt sein;keine Bedenken (zu) haben (brauchen);(sich) keine Gedanken machen (ugs.);ganz beruhigt sein (können) (formelhaft);(sich) keine Sorgen machen (müssen);(sich) keinen Kopf machen (ugs.);Da machst du nichts verkehrt. (ugs., Spruch);Ein gutes Gewissen ist ein sanftes Ruhekissen. (ugs., Sprichwort);nicht weiter drüber nachdenken (ugs.);ruhig schlafen können (fig.)
-Neogotik;Neugotik
-Einkaufsbummel;Erlebniskauf (fachspr.);Shoppen;Shopping (engl.)
-Folgeaktivität;Follow-up (engl.);Nachfassen
-Autounfall;Zusammenstoß;Karambolage;Kollision;Verkehrsunfall
-Unfallhäufungspunkt;Unfallbrennpunkt;Unfallschwerpunkt
-zustellen (mit);verstellen (mit);versperren (mit);blockieren
-in Beschlag nehmen;besetzen;belagern
-Datenflusskontrolle;Datenflusssteuerung
-beleuchtet;aufgeschlüsselt;zusammengestellt;extrahiert;aufgezeigt;erhellt;herausgestellt;aufgestellt
-Bischofsamt;Episkopat
-gemeinsam auftretend;kontingent
-aussparen;absehen (von)
-um die Wurst (ugs.);um alles
-sollte es (zu etwas) kommen;im Fall der Fälle;im Zweifelsfall (floskelhaft);im Ernstfall;gegebenenfalls;im Zweifel (floskelhaft)
-kinetische Energie;Bewegungsenergie
-ignoriert werden;keine Beachtung finden;ungehört verhallen;auf taube Ohren stoßen (fig.);(sich) kein Gehör verschaffen können;keine Berücksichtigung finden;kein Gehör finden
-auf offene Ohren stoßen;angehört werden
-Symistor;Triac;Zweirichtungs-Thyristortriode
-Foto-Triac;Opto-Triac
-Philokartie;das Sammeln von Postkarten;Postkartenkunde
-Postkartenkundler (ugs.);Philokartist (fachspr.);Ansichtskartensammler;Postkartensammler
-Cumulus;Haufenwolke;Quellwolke;Kumulus
-Rechtsmittelbelehrung (juristisch);Rechtsbehelfsbelehrung (juristisch);Belehrung (juristisch);Manuduktion (fachspr.);Rechtsbelehrung (Hauptform)
-Fernschnellzug;FD-Zug
-Grundentgelt (österr.);Grundgebühr
-Nicht-Wahrhaben-Wollen (Hauptform);Ignoranz;Realitätsverweigerung;Realitätsverleugnung;Nichtanerkennung;Bestreitung;(das) Ignorieren;Verleugnung;Vogel-Strauß-Politik
-Schauspielerei;Schauspielkunst
-Schussfrequenz;Kadenz;Feuerrate
-segnen;benedeien (geh., veraltet)
-Oberthrakische Tiefebene;Mariza Ebene
-Schlacht bei Tschernomen;Schlacht an der Mariza
-Osmanisches Reich;Türkisches Reich;Ottomanisches Reich
-Latsch;Reifenaufstandsfläche;Reifenlatsch
-Nachproduktion;Postproduktion
-Bregen;Brägen;Hirn (vom Schlachttier)
-Septumdeviation;Nasenscheidewandverkrümmung
-Strahlmittel;Abrasivmittel;Feststoffpartikel;Schleifmittel
-Anpassung;Gleichstellung;Angleichung;Egalisierung
-vorgotischer Stil;romanischer Stil;Romanik
-Reko-Lokomotive;Rekolok (Kurzform);Rekonstruktionslokomotive
-Schwartzkopff-Eckhardt-Gestell;Schwartzkopff-Eckhardt-Lenkgestell
-Schlacht bei Warschau (1920);Wunder an der Weichsel
-vertikale Integration;vertikale Unternehmenskonzentration
-insgeheim verabredet;heimlich vereinbart;(alles vorher) abgesprochen;(im Vorhinein) abgestimmt;abgekartet;ausgekungelt
-Zeitkritik enthaltend;zeitkritisch
-gefickt (vulg.);getäuscht;hereingelegt (geh., Hauptform);verarscht (derb);veräppelt (ugs.);genatzt (ugs.);reingelegt (ugs.);gedisst (ugs., jugendsprachlich);betrogen
-Passivseite;Passiva
-mobilmachen (gegen);befehden;angehen (gegen);anfeinden;vorgehen gegen (jemanden);Front machen gegen (jemanden)
-störend;nervend;(auf die Dauer o.ä. ziemlich) anstrengend;nervig;ärgerlich;lästig;unliebsam;leidig;verdrießlich
-Coronalebene;Frontalebene;Koronalebene
-Frontalschnitt;Koronalschnitt
-Axialebene;Transaxialebene;Horizontalebene;Transversalebene
-Notaphilie;Papiergeldkunde;Sammeln von Geldscheinen
-einziehen;in Pfand nehmen;pfänden (Hauptform);exekutieren (österr.)
-Blocktransformator;Maschinentransformator
-Mitarbeitergespräch;Personalgespräch
-Gnosis;Gnostizismus
-Kostenpunkt (sein) (ugs.);zu Buche schlagen (mit);kommen (ugs.);machen (das macht ...) (ugs.);kosten;zu haben sein (für) (ugs.)
-Schur;Mähen;Schnitt (ugs.);Mahd;Heuernte (Hauptform)
-Adoption;Annahme an Kindes statt
-anders denken;um die Ecke denken (ugs.);gegen den Strich denken (ugs.)
-alles verschlingende Macht;Moloch
-Heroldsbild;Heroldsfigur;Ehrenstück;Heroldsstück
-Monoflop;monostabile Kippstufe;Univibrator
-Sprint;Lauf;Spurt
-Haargefäß;Kapillare
-Pneumonokoniose (fachspr., veraltet);Staublunge;Pneumokoniose (fachspr.)
-Ausseerland;Steirisches Salzkammergut;Ausseer Land
-adoptierte Tochter;Adoptivtochter;angenommene Tochter;an Kindes statt angenommene Tochter
-Wohlordnungsprinzip;Wohlordnungssatz
-tuskische Ordnung;toskanische Ordnung;etruskische Ordnung;Rustika-Ordnung
-auslaufen;ausklingen;ablaufen;(ein) Ende haben;enden (Hauptform);sich neigen (geh.);aufhören;schließen;zu Ende gehen;verfallen;(in bestimmter Weise) ausgehen;zu Ende sein (ugs.);ein (...) Ende finden;zur Neige gehen
-Arawak;Aruak;Arawaken
-Quimburga;Niedersachsenorkan
-Deskriptor;Schlagwort
-Lemmaselektion;Lemmatisierung
-Kaschubien;Kaschubei
-Werkstattprogrammierung;werkstattorientierte Programmierung
-Nord-Stream-Pipeline;Ostseepipeline
-Fernmeldetruppe;Übermittlungstruppe (schweiz.)
-Hypoplasie (fachspr.);Zellbildungsmangel;numerische Atrophie
-(sich) begrüßen;(jemandem) seinen Gruß entbieten (geh., veraltend);hallo sagen;(sich) grüßen;(jemanden) begrüßen;(jemanden) grüßen;(jemandem einen) guten Tag wünschen (variabel);(jemanden) willkommen heißen
-Libanonisierung;Balkanisierung
-verantwortlich sein;(ein) Fall für (...) (sein);zuständig sein;obliegen
-Mortalitätsziffer;Sterbeziffer
-PanMax;Panamax
-CAS-Registernummer;CAS-Nummer;CAS-Registrierungsnummer
-Dachsbergtunnel;Schwebdaer Tunnel;Friedatunnel
-griechischer Bürger;Grieche;Hellene;Bewohner Griechenlands
-infallibel (geh.);unfehlbar;Irrtum ausgeschlossen. (ugs., Spruch);ex cathedra (Adv.) (geh., auch figurativ, lat.)
-herauskristallisiert;wie sich ergeben hat;wie sich an den Tag gelegt hat
-Zeit der Wirren;Smuta
-Philippinisches Meer;Philippinensee
-proto-sinaitisches Alphabet;proto-semitisches Alphabet
-Starenkasten;stationäres Gerät zur Geschwindigkeitsüberwachung
-(auf etwas) gefasst sein;(auf etwas) vorbereitet sein;(sich) vorsehen
-heilige Kühe schlachten (fig.);alte Zöpfe abschneiden (ugs., fig.);(überholte Vorstellungen o.ä.) über Bord werfen (fig.);(sich) von alten Verhaltensweisen trennen
-Zweifelderball (ostdt.);Völk (schweiz.);Völkerball
-verstreute Häuser;Streusiedlung
-Temeschburg (veraltet);Temeschwar (veraltet);Temeswar
-Kommata (plural);Kommas (plural)
-Zustandsmaschine;endlicher Automat;Zustandsautomat
-umweltschädlich;umweltgefährdend;umweltzerstörend
-Mineralogie;Oryktognosie (veraltet)
-Stabbrandbombe;Elektron-Thermitstab;Brandstab
-Flächenbombardierung;Flächenbombardement
-Sachbefugnis;Aktivlegitimation
-graben;baggern
-Randwertproblem;Randwertaufgabe
-inneres Produkt;Skalarprodukt;Punktprodukt
-löten;(durch Lötmetall) verschmelzen
-Geländestapler;Großreifenstapler
-Feldbahn;Lorenbahn;Rollbahn (österr.)
-ungeklärt;offen (Hauptform);Nichts Genaues weiß man nicht. (ugs., sprichwörtlich);unklar;ungelöst;(bisher) nicht beantwortet;steht im Raum (fig.);nicht entschieden;klärungsbedürftig;bleibt dahingestellt
-Verdeckungsberechnung;Sichtbarkeitsentscheid
-prozentuell;prozentual;perzentuell (österr.);anteilig
-Warschau-Petersburger Eisenbahn;Petersburg-Warschauer Eisenbahn
-Panjer-Algorithmus;Panjer Rekursion
-Nachtzug;Nachtreisezug
-taktisch vorgehen;taktieren;taktische Spielchen spielen (ugs., abwertend)
-Subprimekrise;US-Immobilienkrise
-Grenzherstellung;Grenzanzeige;Grenzfeststellung
-Flurbereinigung;Flurneuordnung;ländliche Neuordnung;landwirtschaftliche Neuordnung
-Flurbereinigung;Kommassation (geh.);Grundstückszusammenlegung;Kommassierung (ugs., österr.);Flurneuordnung;Zusammenlegung (österr.)
-Degustation (geh., bildungssprachlich, franz.);Verkostung
-Schlese;Schlesier
-Schlesisch;Schlonsakisch;Wasserpolnisch
-Panikmache;Hysterie(sierung) (geh.);Angstmacherei;Schüren von (unbegründeten) Ängsten
-Hirnhaut;Meninx encephali (fachspr.)
-Rückenmarkskanal;Wirbelkanal;Spinalkanal
-Genfer Gelöbnis;Genfer Deklaration
-Spinnenbagger;Schreitbagger
-Fensterglas einsetzen;einglasen;einkitten
-baggern;ausheben
-Tiefenmuskelentspannung;progressive Relaxation;progressive Muskelentspannung;progressive Muskelrelaxation
-Gesellschaft;Volksgruppe;Volk
-Gebiet;Umkreis;Großraum;Umgebung;Umfeld
-Zentralwert;Median
-Anorexie;Appetitlosigkeit;Inappetenz (fachspr.)
-Körperbildstörung;körperdysmorphe Störung (fachspr.);Körperschemastörung;Dysmorphophobie (fachspr.)
-Verballhornung;Verschlimmbesserung
-verschlimmbessern;verballhornen
-Kunstkäse;Analogkäse;Käseersatz;Käsesurrogat;Käseimitat
-Bandoneon;Bandonion
-Altvatergebirge;Hohes Gesenke
-Bober-Katzbach-Gebirge;Katzbachgebirge
-Antidiskriminierungsgesetz;Allgemeines Gleichbehandlungsgesetz;AGG (Abkürzung)
-Ortstückel (ugs., regional);Kipfla (ugs., regional);Knäppchen (ugs., regional);Knäppele (ugs., regional);Brotanschnitt (Hauptform);Koosch (ugs., rheinisch);Kanten (ugs., mitteldeutsch, norddeutsch);Bödeli (ugs., schweiz.);Riebel (ugs., regional);Mürgel (ugs., regional);Timpken (ugs., regional);Stützle (ugs., regional);Knäuschen (ugs., regional);Gigele (ugs., regional);Knorzen (ugs., regional);Knörzla (ugs., regional);Knippchen (ugs., regional);Bugl (ugs., regional);Reiftchen (ugs., regional);Knüstchen (ugs., regional);Anschnitt;Ranft (ugs., ostdeutsch);Knust (ugs., norddeutsch);Rämpftling (ugs., regional);Reiftle (ugs., regional);Rämpftl (ugs., regional);Ränftl (ugs., regional, sächsisch);Aheuer (ugs., regional);Knüppchen (ugs., regional);Knerzel (ugs., regional);Scherzerl (ugs., österr.);Kipf (ugs., regional);Krüstchen (ugs., mitteldeutsch, westdeutsch);Knörzchen (ugs., regional);Mürgeli (ugs., regional);Knurrn (ugs., regional);Gnetzla (ugs., regional);Brotende (Hauptform);Riebele (ugs., regional);Gupf (ugs., schweiz.);Knießchen (ugs., regional);Ranfl (ugs., regional);Anscherzl (ugs., regional, österr.);Knäusperle (ugs., regional);Scherzel (bayr., österr.)
-Förstertee (fachspr., Jargon);Jägertee;Jagatee (österr.);Jagertee (österr.);Hüttentee (fachspr., Jargon)
-Tue Gutes und rede darüber. (Spruch);(sich) nicht unter Wert verkaufen (fig.);zeigen, was man draufhat (ugs.);nicht zu bescheiden sein;Klappern gehört zum Handwerk. (Sprichwort);sein Licht nicht unter den Scheffel stellen (fig.)
-mäandrieren;mäandern
-Süßkraut;Honigkraut;Stevia rebaudiana (fachspr., griechisch, lat.);Eupatorium rebaudianum (fachspr., griechisch, lat.);Honigkresse;Süßblatt
-EFSA;Europäische Behörde für Lebensmittelsicherheit
-2. Bosporus-Brücke;Fatih-Sultan-Mehmet-Brücke
-Rollkörner;mitlaufende Drehbankspitze
-Setzstock;Lünette
-Marathon;Marathonlauf
-dazwischenquetschen (ugs.);dazwischenschieben (Termin);einschieben;(noch) mit reinnehmen (ugs., Jargon)
-dreinblicken;dreinschauen
-zusammenbringen (fig.);(unterschiedliche Dinge) miteinander vereinbaren;unter einen Hut bringen (fig.)
-Seehandbuch;Segelanweisung
-Schifffahrtszeichen;Seezeichen (veraltet)
-Generationenprinzip;Großvater-Vater-Sohn-Prinzip
-Gegenmodell;Gegenentwurf
-Volkswirtschaftstheorie;ökonomische Theorie;Wirtschaftstheorie
-Mistwetter (ugs.);Novemberwetter;schlechtes Wetter;Schmuddelwetter (ugs.);nasskaltes Wetter;Sauwetter (ugs.)
-kampfbereit;gerüstet;geharnischt;in schimmernder Wehr (archaisierend oder ironisierend) (geh.);rüstig
-glückstrahlend;selig;freudestrahlend;glückselig
-Schalte (ugs.);Schaltkonferenz;Telefonkonferenz;Telko (ugs.)
-Schminkraum;Maske
-Vorlage;Eingabefeld;Maske;Textmaske;Datenmaske
-Maskierung;Verkleidung;Maskerade;Vermummung;Kostümierung
-Geradlinigkeit;Gradlinigkeit;Zivilcourage;Standhaftigkeit;Standfestigkeit;Prinzipientreue;Rückgrat;Haltung
-(sich) gefasst machen (auf);(sich) einstimmen;(sich) einstellen (auf);(sich) seelisch vorbereiten (auf)
-Buchung;Einzeichnung;Vormerkung;Eintragung;Registratur;Eintrag
-Fangseil;Wurfschlinge;Lasso;Fangleine;Wurfleine
-Zögerer;Zauderer
-Tragödie von Nasino;Nasino-Affäre
-Modedesigner;Couturier (franz.);Modeschöpfer;Modemacher
-einstecken;anstöpseln (ugs.);einstöpseln (ugs.)
-Vernehmlassung (fachspr., schweiz.);Vernehmlassungsverfahren (fachspr., schweiz.)
-Couscous;Kuskus;Cous Cous
-(sich) mit Zähnen und Klauen verteidigen (fig.);(sich) mit Händen und Füßen wehren (auch figurativ);(sich) vehement wehren;(sich) nach Leibeskräften widersetzen;(sich) erbittert wehren;(sich) körperlich zur Wehr setzen
-Schwimmkleidung;Badebekleidung;Schwimmbekleidung
-Schwimmhose;Badeshorts;Badehose;Speedo (ugs.)
-elektromotorische Kraft;Urspannung
-Gegen-EMK;Gegeninduktionsspannung;Gegenelektromotorische Kraft
-Daniell-Element;Daniell'sches Element
-Induktivität;Eigeninduktivität;Selbstinduktion;Selbstinduktivität
-der Wahrscheinlichkeit nach;probabilistisch (gesehen)
-Islamfeindlichkeit;Muslimfeindlichkeit;Islamophobie;Islamhass;Islamphobie
-unitarisch;einheitlich
-Gefühl von Unwirklichkeit;verfremdete Wahrnehmung der Umwelt;Derealisation;Derealisationserleben;Empfinden von Unwirklichkeit
-Neffentrick;Enkeltrick
-ruchlos;gewissenlos
-umkehren;in die entgegengesetzte Richtung gehen;kehrtmachen
-Magnetwerkstoffe;magnetische Werkstoffe
-Feuerschläger;Feuereisen (veraltet);Feuerstahl;Feuerschurf (veraltet);Pinkeisen (veraltet)
-Liebling;Protegé;Favorit;Günstling;Schützling
-Halszither;Harzzither;Zister;Cyther;Lutherzither;Waldzither;Bergmannszither;Zitter (mhdt.);Thüringer Zither;Cister
-Sandpierwurm;Pierwurm;Wattwurm
-Zahl-Reim-System;PEG-Methode
-Major-System;Mastersystem
-Lerntechnik;Mnemotechnik;Gedächtnistechnik
-Urbanistik;Raumordnung;Gebietsverwaltung;Stadtplanung;Stadtforschung
-Rasender Roland;Rügensche Kleinbahn
-Flockenlesen;Krozidismus
-Generalangriff;Großangriff
-Einsteher;Einstandsmann
-Malwinen;Falklandinseln
-Milleriten;Adventisten
-Pariser Frieden 1898;Vertrag von Paris
-insular;inselartig
-Zöllner;Zollbeamter
-Chomsky-Hierarchie;Chomsky-Schützenberger-Hierarchie
-Backus-Naur-Form;Backus-Normalform
-Unart;schlechte Angewohnheit;schlechte Gewohnheit;Untugend
-Klavikula (fachspr., eingedeutscht);Clavicula (fachspr., lat.);Schlüsselbein
-Umschlingungsgetriebe;Zugmittelgetriebe;Zugmitteltrieb
-V-Motor;Gabelmotor (veraltet)
-Gampenjoch;Gampenpass
-Dermulo-Fondo-Mendel-Bahn;Nonsbergbahn
-Gokart;Kart
-Gegenschall;aktive Lärmkompensation;Antischall
-Hochland von Abessinien;Äthiopisches Hochland;Hochland von Äthiopien
-Kerbzinne;Welsche Zinne;Scaliger-Zinne;Schwalbenschwanzzinne
-Straße von Gibraltar;Meerenge von Gibraltar
-Erpressung;Angebot, das jemand nicht ablehnen kann (ugs., Spruch);Nötigung;Pression;Zwang
-Array-Prozessor;Vektorprozessor
-Junktor;Satzverknüpfung;logisches Bindewort;Funktor;Konnektiv;Satzoperator;Satzverknüpfer;Konnektor;Aussagenverknüpfer;Verknüpfungszeichen
-Seilreibungsformel;Euler-Eytelwein-Formel
-Preußenfahrt;Litauerreise
-Drei-Flüsse-Stadt (ugs.);Passau
-Schluckenauer Zipfel;Böhmisches Niederland
-Fruchtfolge;Felderwirtschaft
-Vorstoß;Litze;Passepoil (franz., schweiz., österr.);Paspelierung;Passepoilierung;Bordierung;Wulstnaht;Paspel
-wegzaubern;zum Verschwinden bringen;eskamotieren (geh.);verschwinden lassen
-hypoplastisches Linksherz-Syndrom;Linksherzhypoplasie-Syndrom
-glagolitische Schrift;Glagoliza
-Schälchenstein;Schalenstein;Näpfchenstein
-griechisch;hellenisch
-Ginsterkatze;Genette
-Kleinfleck-Ginsterkatze;europäische Ginsterkatze
-Krängung;Schlagseite;Übergewicht zu einer Seite
-Entgeltfortzahlung (fachspr., juristisch);Lohnfortzahlung
-Typenkopf;Schreibmaschinen-Kugelkopf
-ins Minus kommen (ugs.);in die roten Zahlen kommen;in die roten Zahlen geraten;(sein) Konto überziehen;in die Miesen kommen (ugs.);Schulden machen;über seine Verhältnisse leben;(sich) verschulden
-Haik;Schnitzeljagd
-Wing Tsun;Ving Chun;Ving Tsun;Wing Chun
-Survival;Überlebenskunst;Survivalismus
-Schnurkeramik (fachspr.);Streitaxt-Kultur (veraltet);Schnurkeramische Kultur;Kultur mit Schnurkeramik
-skandinavische Axt;Dänenaxt;Breitaxt;Wikingeraxt
-eine Rochade ausführen (Schach);rochieren
-Stabbogenbrücke;verstärkter Balken;Langerscher Balken
-Bogenbrücke;Gewölbebrücke
-Auftriebsbeiwert;Auftriebskoeffizient
-Italienkriege;Renaissance-Kriege;Italienische Kriege
-entwenden;fringsen (veraltet)
-Apallisches Syndrom;Wachkoma;Lucid Stupor (fachspr., lat.)
-Auffahrt;Rampe;Ladebühne;Zufahrt
-(sich) einmischen;Einfluss nehmen;beeinflussen
-arrangiert;gestellt;inszeniert;vorbereitet
-Kriminalrecht;Strafrecht
-Pummel (ugs.);Dickerchen (ugs.);Pummelchen (ugs.);Moppel (ugs.)
-Fettbauch (derb);fettes Schwein (derb);Elefantenküken (ugs.);Fettsack (derb);Dicker;Fass (derb);Pummelchen (ugs.);Moppel (ugs.);Fettwanst (derb);Brecher (ugs.);Koloss (ugs.);Brummer (ugs.);Fleischberg (derb);Prachtexemplar (ugs., ironisch);Rollmops (ugs.);Mops (ugs.);Dicke;Dickwanst (derb);Brocken (ugs.);Fettmops (ugs.);Kugel (ugs.);Tonne (derb);fette Sau (derb);dicker Mensch (Hauptform);Person von Gewicht (ugs., ironisch);Schwergewicht (ugs., ironisch);Dickmadam (ugs.);Quetschwurst (derb);Dampfwalze (ugs.);Fettkloß (derb);Dickerchen (ugs.)
-Lieblingsstück;Kabinettstück;Paradestück;Vorzeigeobjekt;Prunkstück
-Prachtstück (ugs.);Schmuckstück;Kronjuwel;Perle (fig.);Prachtexemplar (ugs.);Kabinettstück;Juwel (fig.);Glanzstück;Schmankerl (bayr., österr.)
-Kraniologie;Schädellehre
-Siebenjähriger Krieg;Dritter Schlesischer Krieg
-(im) Stakkato reden;reden wie ein Maschinengewehr;reden ohne abzusetzen;reden ohne Luft zu holen (ugs.);ohne Punkt und Komma reden (ugs.);reden wie ein Wasserfall (ugs.)
-Selbstbedienungs-Warenhaus;Hypermarkt;SB-Markt;SB-Warenhaus
-Kaufhalle (DDR);Supermarkt;Vollsortimenter
-Einkaufspassage;Galerie;Ladenpassage;Passage
-International Space Station;Internationale Raumstation;ISS
-Dermatologe;Hautarzt
-saugefährlich (derb);hochgefährlich;kreuzgefährlich (ugs.);sehr gefährlich (Hauptform);extrem gefährlich;äußerst gefährlich;mordsgefährlich (ugs.);brandgefährlich
-ästhetische Chirurgie;plastische Chirurgie;Schönheitschirurgie
-(jemandem) Dreck hinterherwerfen (fig.);(jemandem) nachträglich eine(n) reinwürgen (ugs.);nachkarten (fig.);nachtreten (fig.);hinterhertreten (fig.)
-Bundestagspräsident;Präsident des Bundestages;Präsident des Deutschen Bundestages
-Potjomkinsches Dorf;Potemkinsches Dorf
-weggeschwemmt;weggespült
-besprüht;eingesprüht
-kompakt;komprimiert;kurzgefasst;eng gepackt;verdichtet;reduziert;verkleinert
-schulisch;zum Studium gehörig;scholastisch;ausgeklügelt (bildungsspr.);kasuistisch (abwertend)
-Methylthiomethan;Dimethylsulfid
-ernst gemeint;in echt (ugs.);mit allem Ernst;ernstlich;ohne Spaß;ohne Scherz;ohne Scheiß (ugs.);ernstgemeint;im Ernst;wirklich;kein Scheiß (ugs.);ohne Quatsch (ugs.);ernsthaft;ohne Witz;bitterernst;allen Ernstes
-Zoroastrismus (Hauptform);Parsismus;Zarathustrismus;Mazdaismus
-Bremssattel;Bremszange
-Schwimmsattel;Faustsattel
-Pendelsattel;Kippsattel
-Fimbertal;Fimbatal
-Samer (österr.);Säumer;Saumer
-hochhackige Schuhe (Plural);Hackenschuhe (Plural);Pumps (Plural)
-Pandabär;Großer Panda
-Kleiner Panda;Roter Panda;Feuerfuchs;Goldhund;Bärenkatze;Katzenbär
-Ammoniak-Soda-Verfahren;Solvay-Verfahren
-Erweichungstemperatur;Glasübergangstemperatur
-Moskauer Erklärung;Moskauer Deklaration
-Sonnenwärmekraftwerk;Solarwärmekraftwerk
-Schmidt-Kamera;Schmidt-Teleskop;Schmidt-Spiegel
-Oikonym (fachspr., griechisch);Siedlungsname (Hauptform);Ortsname
-Leibeigenschaft;Eigenbehörigkeit
-Wäschepilz;Stewi (schweiz.);Wäscheschirm;Wäschespinne
-Erwerbsloser;Arbeitsloser
-Mastkirche;Stabkirche
-(etwas) bis zum Exzess treiben;(etwas) bis zum Äußersten treiben;bis ans Äußerste gehen (mit);(etwas) auf die Spitze treiben
-pseudo-riemannsche Mannigfaltigkeit;semi-riemannsche Mannigfaltigkeit
-inverse Funktion;Umkehrfunktion
-Hypermedia;Hypermedialität
-Cauchy-Schwarz-Ungleichung;Cauchy-Bunjakowski-Schwarz-Ungleichung;Schwarzsche Ungleichung
-Straße von Torres;Torres-Straße
-Wiener Oktoberrevolution;Wiener Oktoberaufstand 1848
-Mongolenflut;Mongolensturm;Tatarensturm
-schlechte Kopie;billiger Abklatsch;müder Abklatsch
-(es jemandem) gleichtun;(jemanden) als Vorbild nehmen;(sich jemanden) zum Vorbild nehmen;(jemandem) nacheifern;in jemandes Fußstapfen treten (fig.);(es jemandem) nachtun (geh.);(sich) (ein) Beispiel nehmen an;(sich) eine Scheibe abschneiden (von) (ugs., fig.);(sich jemanden) zum Beispiel nehmen
-Vorgeplänkel;Vorspiel
-südosttürkische Sprache;uighurische Sprache
-Yohur;West-Yugurisch
-Brot- und Buttergeschäft (ugs.);wo das Geld verdient wird;Kerngeschäft;wichtigste Einnahmequelle;Hauptgeschäft
-Neurenaissance;Neorenaissance
-Festungsfront Oder-Warthe-Bogen;Festung im Oder-Warthe-Bogen;Ostwall (ugs.)
-Pommernlinie;Pommernwall;Pommern-Stellung
-Tuamotu-Archipel;Paumotuinseln (veraltet)
-Ahunui;Fangataufa;Fangatau
-Baujahr (ugs.);Geburtsjahr
-Absatz;Verkaufszahlen;Absatzzahl
-Lues (fachspr.);harter Schanker;Lues venerea (fachspr.);Syphilis (Hauptform);Franzosenkrankheit (ugs., veraltend)
-Asylantenwohnheim;Asylheim;Asylantenheim
-viel Geld verdienen;(einen) Reibach machen;ordentlich Kohle machen (mit) (ugs.);(sich) gesundstoßen (an) (ugs.);(sich) dumm und dämlich verdienen (ugs.);reich werden;kräftig abkassieren (ugs., salopp, variabel);ein Vermögen machen (mit);viel Geld machen;(sich) eine goldene Nase verdienen (ugs., fig.);Geld scheffeln (ugs.);(einen) Haufen Geld verdienen (ugs.);schwer Geld machen (ugs.)
-Digital Fabricator;Fabber;3D-Drucker
-verdammt;vermaledeit (veraltend);verflucht
-Tieflandburg;Flachlandburg;Niederungsburg
-Karäer;Karaim;Karaiten;Karäim
-(sich etwas) entgehen lassen;(sich etwas) durch die Lappen gehen lassen (ugs.);(eine Gelegenheit) ungenutzt verstreichen lassen
-abbrausen (ugs.);abduschen
-Drahtkammer;Vieldrahtkammer
-Bahnstrecke Kempten-Isny;Isny-Bähnle (ugs.)
-Zehnerlogarithmus;dekadischer Logarithmus
-Kraft tanken (ugs.);Energie sammeln (ugs.)
-galenische Form;Darreichungsform;Arzneiform
-konservativ (Hauptform);traditionsverbunden;am Bewährten festhalten(d);zum rechten Spektrum zählen(d);rechts (politisch);am Bestehenden festhalten(d);in der Tradition (stehen)
-spezifische akustische Impedanz;Schallwellenwiderstand (veraltet);Schallwiderstand (veraltet);akustische Feldimpedanz;Schallkennimpedanz
-akustische Flussimpedanz;akustische Impedanz
-Mädchenname (ugs., Hauptform);früherer Familienname;Geburtsname
-Gehörn;Geweih
-Kurpark;Kuranlage;Kurpromenade
-nicht nur Vorteile bieten(d);mit positiven und negativen Aspekten;zweischneidig
-Formosastraße;Taiwan-Straße
-in einer Krise steckend;von einer Krise betroffen;krisengeschüttelt;krisengebeutelt
-kritzelig;krakelig
-kremig (alte Schreibung bis 2011);cremig
-krisenfest;krisenresistent
-koffeinfrei;ohne Koffein
-überschlagen (z.B. Raumtemperatur) (ugs., regional);pisswarm (derb);lau;pipiwarm (derb);lauwarm;handwarm
-thermogravimetrische Analyse;Thermogravimetrie
-Gravitationswasserwirbelkraftwerk;Wasserwirbelkraftwerk
-Polynomdivision;Partialdivision
-Division;Teilen (ugs.)
-Malnehmen (ugs.);Multiplikation
-Rotpunktvisier;Reflexvisier;Kollimatorvisier;Leuchtpunktzielgerät
-Newtonringe;Newtonsche Ringe
-Bangemacher (ugs.);Angsteinflößer;Angstmacher
-Zulieferindustrie;Zuliefererindustrie
-Tuchent;Daunendecke (fachspr.);Plümo (regional);Federbett;Plumeau (frz.; regional);Oberbett;Zudecke;Oberdecke;Decke;Plümont (ugs., bayr.);Bettdecke
-Flüsterpost;Stille Post
-anders sein (als);(sich) abheben (von);aus anderem Holz geschnitzt sein (Person) (Redensart, fig.);abweichen;einer anderen (... z.B. Sorte) zuzuordnen sein;nicht dazugehören;von anderer Art (sein);differieren (bildungssprachl.) (geh.);(sich) unterscheiden (von);verschieden sein;herausfallen;(sich) herausheben;divergieren (bildungssprachl.) (geh.)
-Kiel;Kieler Woche;Kiel Sailing City
-schlauchen (ugs.);anstrengend sein (Hauptform);auslaugen (ugs.);Kraft kosten;Mühe bereiten;anstrengen;stressen
-World Wide Fund For Nature (engl.);WWF
-Sturmsense;Kriegssense
-Freikorporal;Gefreitenkorporal
-Tataren-Straße;Tatarensund;Tartaren-Straße;Tatarischer Sund
-economies of scale;positiver Skaleneffekt;Massenproduktionsvorteil
-Regenerativbeheizung;Regenerativfeuerung
-Amtsermittlungsgrundsatz;Untersuchungsgrundsatz;Inquisitionsmaxime
-Konvention von Montreux;Vertrag von Montreux;Meerengen-Abkommen
-Festlandsockelkommission;Kommission zur Begrenzung des Festlandsockels
-harmonieren (mit);Hand in Hand gehen (mit) (ugs.)
-paarer Graph;bipartiter Graph
-Spiritusdrucker;Blaudrucker;Matrizendrucker
-Schwarzer Kardamom;Nepal-Kardamom;Elaichi;Brauner Kardamom;Amomum subulatum (fachspr., lat.)
-Albaruthenisch (veraltet);Weißrussisch (Hauptform);weißrussische Sprache;Belorussisch;Belarusisch;belarussische Sprache;Weißruthenisch (veraltet);Belarussisch (Hauptform)
-Strafkolonie;Sträflingskolonie;Verbrecherkolonie
-Repellent;Vergrämungsmittel;Repellens;Repulsivstoff
-Rattenblech;Rattenteller
-Militärbündnis;Beistandspakt (veraltet)
-Erster Balkanpakt;Balkanpakt;Balkanentente
-Interamerikanischer Verteidigungspakt;Pakt von Rio;Interamerikanischer Vertrag über gegenseitigen Beistand;Rio-Pakt
-im Winter;winters
-sommers;im Sommer
-durch den Willen bestimmt;willensbestimmt;volitional
-Koch-Kurve;kochsche Kurve
-Teragon;Monsterkurve
-Cheminformatik;Chemoinformatik;Chemieinformatik
-Elbtalkessel;Dresdner Elbtalweitung;Dresdner Elbtalkessel
-Kirlianfotografie;Koronaentladungsfotografie;hochfrequente Hochspannungsfotografie
-Echografie;Ultraschall (ugs.);Sonografie
-Rappel (ugs.);Koller (ugs.);Anfall;(seine) dollen (oder: dullen) fünf Minuten (haben) (ugs.);Wutausbruch
-kambrische Artenexplosion;kambrische Explosion;kambrische Radiation
-μ (fachspr.);Reibwert
-Honigdachs;Ratel;Mellivora capensis (fachspr., lat.)
-Indische Dattel;Sauerdattel;Tamarindenbaum
-Schtokawisch;Stokavisch
-Slowenien-Krieg;Slowenischer Unabhängigkeitskrieg;10-Tage-Krieg
-Nikolaibahn;Bahnstrecke Sankt Petersburg-Moskau
-Präsenzhandel;Parketthandel;Criée-Handel;Ringhandel;Zurufhandel
-Unternehmen Husarenritt;Stargarder Panzerschlacht;Unternehmen Sonnenwende
-Schutz aufheben;entsichern;entsperren;lösen
-42;Die Antwort auf die Frage nach dem Leben, dem Universum und dem ganzen Rest.
-Binär-Komplement;Zweierkomplement;2-Komplement;Basiskomplement;Zweikomplement;B-Komplement
-2K-Zahl;Zweierkomplementdarstellung;K2-Zahl;Zweierkomplementformat
-filetieren;filieren
-SIS;Secret Service;britischer Auslandsgeheimdienst;Secret Intelligence Service;MI6
-Europaregion;Euroregion;Euregio
-tonale Sprache;Tonalsprache;Tonsprache
-Gehänge;Dachkandel (regional);Dachkalle (ugs.);Dachkännel (regional);Dachrinne;Kähner (alemannisch);Kännel (regional);Regenrinne (ugs.);Kandel (regional);Dachhengel (schweiz.);Dachkähner (alemannisch)
-eindicken;Abziehen;Legieren;Binden;Abbinden
-Mekonium;Darmpech;Kindspech
-Wombat;Plumpbeutler
-Eichmannreferat;Judenreferat
-Politische Abteilung;Lagergestapo
-Netzausscheidungsziffer (österr.);Verkehrsausscheidungsziffer;Fernverkehrsausscheidungsziffer;Ausscheidungsziffer;Verkehrsausscheideziffer;Ausscheidungskennziffer
-Tafahi;Boscawen-Insel
-Wisent;Flachlandwisent;Bos bonasus (fachspr.);Bison bonasus (fachspr.);Europäischer Bison
-schwierige Frage;Problematik;Problem;Schwierigkeit
-typografischer Weißraum;Leerraum
-Hula Hopp;Hula Hoop
-Hula-Hopp;Hula-Hoop
-Buntflossenkoppe;Sibirische Groppe;Ostgroppe;Buntflossengroppe
-Backhaus;Bäckerei;Backstube
-unverständlich;unheimlich;mysteriös;geheimnisumwoben;geheimnisumwittert
-Schlacht bei Mogersdorf;Schlacht bei St. Gotthard
-Türkenkrieg von 1663/1664;4. Österreichischer Türkenkrieg
-Rheinischer Bund;Rheinische Allianz
-Galgenberg;Galgenhügel;Galgenbühl
-Tüftelei;Getüftel (ugs.)
-leer fegen;leerfegen
-Nativer Code;Maschinencode;Maschinensprache
-Furcht vor Homosexuellen;Schwulenhass (ugs.);Homophobie;Abneigung gegen Homosexuelle;Schwulenfeindlichkeit
-Kettenwechsler;Kettenschaltung (Hauptform);Außenschaltung;Außengang
-Innengang;Innenschaltung;Nabenschaltung (Hauptform);Getriebenabe
-Fahrradschaltung;Gangschaltung
-Arbeitskraft;Kraftreserve;Manpower (engl.);Arbeitsvermögen;Leistungsvermögen;Arbeitspotenzial;Leistungsfähigkeit;Potenzial;Spannkraft
-Bekanntschaft;Kollege (schweiz., süddt.);Kontakt;Bekannter
-Sinus cardinalis;sinc-Funktion;Kardinalsinus;Spaltfunktion;si-Funktion
-Dirac-Kamm;Schah-Funktion;Dirac-Stoß-Folge
-Dirac-Impuls;δ-Funktion;Dirac-Stoß;Nadelimpuls;Einheitsimpulsfunktion;Dirac-Puls;Delta-Distribution;Dirac-Funktion;Stoßfunktion
-arrestieren (selten);arretieren;feststellen;sichern;festnehmen
-Reversosmose;Umkehrosmose
-Visier;Gesichtsschutz
-Funk;Sprechverbindung;Sprechfunk
-weithin;allg. (Abkürzung);generell;allseits;allgemein
-den Anker werfen;ankern;den Anker auswerfen;vor Anker gehen
-Vespa crabro;Hornisse;Großwespe
-(auf etwas) reinfallen;einer Sache aufsitzen
-Venturi-Rohr;Venturi-Düse
-Energierückgewinnung;Rekuperation
-flammneu (ugs.);nigelnagelneu (ugs.);jungfräulich (ugs., fig.);unberührt;ganz neu;sehr neu;brandneu (ugs.);frisch aus (der/dem - z.B. Druckerei);noch ganz warm (ugs.);taufrisch;ofenfrisch (ugs.);frisch auf den Tisch;flatschneu (ugs., ruhrdt.);ofenwarm (ugs.);unbenutzt;funkelnagelneu (ugs.);nagelneu (ugs.)
-Druckfreigabe;Imprimatur;Druckerlaubnis
-Unterschwingungsverfahren;Pulsdauermodulation;Pulslängenmodulation;Pulsweitenmodulation;Pulsbreitenmodulation
-Tastgrad;Aussteuergrad
-forteilen;eilig weggehen;davoneilen;forthasten
-(sich) verantworten;Rechenschaft ablegen;(sich) erklären (geh.);(sich jemandes) Fragen stellen;(sich) rechtfertigen;(sich) seiner Verantwortung stellen;Rede und Antwort stehen
-sättigen;satt machen;sattmachen
-Reffknoten;Samariterknoten;Kreuzknoten;Weberknoten;Doppelknoten
-notwendiges müssen;umstandshalber;Sachzwang (meist plur.)
-Südtiroler Unterland;Bozner Unterland
-unsachgemäß;unkompetent (selten);inkompetent;unfachmännisch
-Hausspinne;Große Winkelspinne
-Morbus Chagas;Chagas-Krankheit;Amerikanische Trypanosomiasis;Südamerikanische Trypanosomiasis
-Prägung;Form
-Flugzeugmutterschiff;Wasserflugzeugtender;Seeflugzeugtender
-5-Ton-Folge;Selektivruf
-Übersprungbewegung;Übersprungverhalten;Übersprunghandlung
-(sich) an die eigene Nase fassen (ugs., fig.);selbstkritisch sein;die Schuld nicht bei anderen suchen;bei sich selbst nachgucken;vor der eigenen Türe kehren (fig., sprichwörtlich);(Ein) jeder kehre vor seiner Tür (...) (Zitat);(sich) an die eigene Nase packen (ugs.)
-Nova Scotia;Neuschottland
-Gebet;Fürbitte;Gespräch mit Gott
-Dreidl;Dreidel
-Trailer;Filmvorschau;Preview (fachspr., Jargon, engl.)
-vegetarische Frikadelle;Bratling
-Veggie-Burger;vegetarischer Hamburger
-Phonodiktat;Phonotypie
-Eierstecher;Eierpikser (ugs.)
-Stoßzeit;heiße Phase (ugs.);Hochsaison;Stresszeit;Saison
-Fenstersturz;Defenestration
-Geschäftsmöglichkeit;unternehmerische Chance
-Wurzelwerk;Suppengemüse;Kochgemüse;Suppengrün;Wurzelzeug
-feste Vergütung;Fixum;festes Entgelt
-Fetakäse;Feta
-Stirlingmotor;Heißgasmotor
-Fertigungstiefe;Wertschöpfungstiefe
-Bayerisches Tarock;Haferltarock
-Junggeselle aus Überzeugung;eingefleischter Junggeselle;Hagestolz (veraltet);(älterer) Junggeselle
-Schmecken;Gustatorik;Geschmackssinn;gustatorische Wahrnehmung
-clownhaft;clownesk
-Setzei;Spiegelei;gebratenes Ei
-stillhalten;(sich) nicht bewegen;(sich) nicht rühren (ugs.)
-Materialkonstante;feste Größe (ugs.);Stoffkonstante
-bereit sein;zur Verfügung stehen;Gewehr bei Fuß (stehen) (fig.);vorbereitet sein;in den Startlöchern stehen (fig.)
-Ayers Rock;Uluru
-U-Haft;Untersuchungshaft
-ausschließen;exkludieren
-Nordistik;Skandinavische Philologie;Nordische Philologie;Nordgermanische Philologie;Skandinavistik;Nordeuropa-Studien
-Friesische Philologie;Frisistik;Friesistik
-für jeden (einzelnen);pro Kopf;pro Person;für jede Person;pro Nase (ugs.)
-Physiokratismus;Physiokratie
-damit ist es gut (ugs.);damit ist es getan (ugs.);damit ist das Thema erledigt
-deskriptive Wissenschaft;positive Wissenschaft
-nicht so schlimm;nicht so wild (ugs.);kein Beinbruch (ugs., fig.);nicht der Untergang des Abendlandes (ugs., fig.);das wird schon wieder (ugs.);halb so kalt (ugs., regional);halb so wild (ugs.);davon stirbt man nicht (ugs., fig., variabel);Nichts wird so heiß gegessen, wie es gekocht wird. (ugs., Sprichwort);kein Weltuntergang (ugs., fig.);Davon geht die Welt nicht unter. (ugs.);halb so schlimm (ugs.)
-Piccolo;Pikkolo
-Pikkolo;Piccoloflöte;Piccolo;Pikkoloflöte
-Tragwerksplaner;Statiker (ugs.)
-Grenzrachenlehre (selten);Grenzlehre;Kaliberlehre (selten)
-Drehstahl (ugs.);Drehmeißel
-(jemandem) mit seinen Blicken folgen;(jemandem) hinterherblicken;(jemandem) hinterherschauen;(jemandem) nachschauen;(mit Blicken) verfolgen
-Ferienappartement (fachspr.);Urlaubsdomizil (fachspr.);Ferienwohnung;Ferienhaus (fachspr.);Ferienapartment (fachspr.);Ferienquartier (fachspr.)
-verliebtes Paar;Liebespaar (Hauptform);das junge Glück;Pärchen;Turteltauben (ugs., auch ironisch, fig.);die (beiden) Verliebten;Paar;Turteltäubchen (ugs.)
-Thermalkamera;Wärmebildgerät;Thermografiekamera;Infrarotkamera;Wärmebildkamera
-eye tracking (engl.);Okulographie;Blickerfassung
-aufbeugen;hochkommen;aufrichten
-Straßenbrunnen;Trinkwassernotbrunnen
-abschmeißen;fallen lassen;niederwerfen;abwerfen;hinwerfen
-Reichsabschied;Reichsrezess
-ich glaub's nicht! (ugs.);da schau her! (ugs., süddt.);leck mich (doch einer) am Arsch! (derb);dit hammwa jerne! (ugs., berlinerisch, ironisch);nicht zu fassen! (ugs.);schau an! (ugs., süddt.);na sowas! (ugs.);na sieh mal an! (ugs.);sieh (mal) einer an! (ugs., Hauptform);man glaubt es nicht! (ugs.);ach nee! (ugs.)
-Naseweis (ugs.);neugierige Person;neugieriger Mensch
-gegenlesen;lektorieren (fachspr.);Korrektur lesen;redigieren (fachspr.)
-davongleiten;davonrutschen
-aufgeschlitzt;zerschlitzt;zerteilt
-(schwer) wie Blei;(sehr) schwer (Hauptform);Blei... (fig.);bleischwer
-engstirnig;kurzatmig;eng (ugs.);kurzsichtig (ugs.);beschränkt;borniert
-hohles Versprechen;leeres Versprechen;leere Worte;nur auf dem Papier stehen (fig.);reine Rhetorik (sein);Lippenbekenntnis (Hauptform);Sonntagsrede(n) (fig.)
-Chronograph;Chronograf;Armbanduhr
-Antragsteller (veraltet, österr.);Defendant;Respondent;Proponent
-Albulalinie;Albulabahn
-Berninalinie;Berninabahn
-Schlachtross;Kampfross;Streitross
-Frieden von Kiel;Vertrag von Kiel
-Polarisationsfilter;Polfilter
-Raibler Band;Raibl-Formation;Raibler Schichten
-mehr oder weniger;mehr oder minder
-(etwas) verbriefen;in schriftlicher Form garantieren;vertraglich (/schriftlich) zusichern
-gerade recht kommen (ugs.);zu einem günstigen Zeitpunkt kommen;(jemanden) schickt der Himmel (ugs., fig.);(etwas) trifft sich gut;(das nenne ich ein) perfektes Timing!;just in time (Jargon, engl., scherzhaft);(genau) im richtigen Moment kommen;wie gerufen kommen;kommen wie gerufen
-Freiluftmuseum;Freilandmuseum;Freilichtmuseum;Museumsdorf
-Menschen wie du und ich (ugs.);normale Menschen;Otto Normalverbraucher;Lieschen Müller (ugs.);Leute von nebenan (ugs.);Frau Mustermann (ugs.);normale Leute
-100 Liter;Hektoliter
-Marginalkosten;Grenzkosten
-Kairinisch;Ägyptisch-Arabisch
-Diebsgesindel;Marodeure;Plünderer;Räuberbande;Raubgesindel
-heller Kopf;Intelligenzbestie (ugs., ironisch);kluger Kopf (ugs.);schlaues Kerlchen (ugs., scherzhaft);Gscheitle (ugs., schwäbisch);Eierkopf (ugs., ironisch);intelligenter Mensch
-Konter;Gegenangriff;Break;Riposte (Fechten);Gegenstoß
-Blut-Hirn-Schranke;Blut-Gehirn-Schranke
-Tafelberg;Mesa
-Maurerradio (ugs.);Krawallkoffer (ugs.);Herrenhandtasche (ugs.);Randaliererpäckchen (ugs.);Sechser Rundkolben (ugs.);Männerhandtasche (ugs.);Sechsertragerl (österr.);Sechserträger (Bier);Sixpack (engl.)
-Begleitautomatik;Begleitautomat
-Trellis-Modulation;Trellis-Code-Modulation;Ungerboeck-Code;Trellis-Codierung
-Reduzierventil;Druckminderer;Druckminderungsventil
-Gasregler;Gasdruckregler;Gas-Druckregelgerät
-Stein von Rosette;Stein von Rosetta;Rosettastein
-Amt des Papstes;Papat
-(sich) nicht (so kleinlich) anstellen (ugs.);den lieben Gott 'en guten Mann sein lassen (ugs.);nicht jedes Wort auf die Goldwaage legen (ugs.);(etwas) nicht (so) genau nehmen;nicht alles auf die Goldwaage legen (fig.);wir wollen mal nicht so sein (ugs., Spruch, regional, variabel);(alle) fünf gerade sein lassen (ugs.);nicht päpstlicher als der Papst sein (wollen) (ugs.)
-Zweizimmerwohnung;Zweiraumwohnung
-Printserver;Druckserver;Druckerserver
-Replikation;Replizierung
-Erwerbstätigenquote;Beschäftigungsquote
-Metervertrag (schweiz.);Meterkonvention
-Gemeiner Delfin;Gewöhnlicher Delfin
-bulgarische Thraker;thrakische Bulgaren
-Ur-Bulgaren;Hunno-Bulgaren;Protobulgaren
-bolgarische Sprache;protobulgarische Sprache
-Fernmeldesatellit;Kommunikationssatellit;Nachrichtensatellit
-in Ermangelung;mangels
-Chronisches Erschöpfungssyndrom;Myalgische Enzephalomyelitis;Myalgische Enzephalopathie;Chronisches Müdigkeitssyndrom;Chronic Fatigue Syndrome (engl.)
-zucken;zappeln
-einrichten (geh.);konstituieren;festsetzen;aufstellen;bedingen;bestimmen
-bedingen;bestimmen;konstituieren
-Bedingung;Apriori (lat.);Konstitutivum
-Doughnut;Donut
-Objekt aus Knoten und Kanten;Graph (fachspr.)
-nach;hinter
-auseinanderdröseln (ugs.);entflechten;auseinanderfriemeln (ugs., ruhrdt.);aufdröseln (ugs.);auseinanderklamüsern (ugs.);entwirren
-Fernmeldewesen;Telekommunikation
-Werkstoffwissenschaft;Materialwissenschaft;Werkstoffkunde
-die Hand unten lassen;(sich) nicht an der Abstimmung beteiligen;(sich) enthalten;keine Stimme abgeben;nicht (mit) abstimmen;an der Abstimmung nicht teilnehmen;keiner der beiden Positionen seine Stimme geben;(sich) der Stimme enthalten
-auf dass (veraltet);mit dem Ziel, dass;damit
-Dienst;Angebot (Informatik) (fachspr.)
-Infografik;Informationsgrafik
-Prozentkodierung;URL-Encoding (engl.);URL-Kodierung
-Umbraun;Umber;Umbra
-Pullunder;Unterzieh-Rolli (ugs.)
-Personalaufwand;personeller Aufwand
-Barlowsches Rad;Barlow-Rad;Barlow'sche Rad
-Homopolarmaschine;Unipolargenerator;Unipolarmaschine;Faraday-Generator
-charset (fachspr., engl.);character set (fachspr., engl.);Zeichensatz
-als Konzert;konzertant
-Flurschaltung;Wechselschaltung;Hotelschaltung
-Unwohlsein;leichte(re) Beschwerde;(einen) Furz quer sitzen (haben) (derb);diffuse Beschwerde;Befindlichkeitsstörung;nichts Ernstes (ugs.);(sich) unwohl fühlen;Wehwehchen (ugs.)
-hinzuwählen;kooptieren
-Kurve;Kurvenverlauf;Graf;Plot;Graph
-Klaviatur;Buntheit;Bandbreite;(reiche) Auswahl;(breites) Spektrum;Sortiment;Reichtum (an);Palette
-so laut jemand kann (variabel);aus voller Brust;lauthals;mit lauter Stimme;lautstark;aus voller Kehle;schallend;in Megaphonlautstärke;aus Leibeskräften;dass es nur so eine Art hat (veraltet);stimmgewaltig
-Frag mich mal was Schweres! (ugs., Spruch);Frag mich (mal) was Leichteres. (ugs., Spruch);keinen Plan haben (von) (ugs., salopp);Kein Plan. (ugs., jugendsprachlich);(ich) weiß nicht;Mein Name ist Hase, ich weiß von nichts. (ugs., Spruch);Ich nix wissen, ich andere Baustelle. (ugs.);keinen blassen Dunst (haben) (ugs.);von nichts wissen;keine Ahnung (haben);nicht wissen, wovon jemand spricht;keinen Plan (haben) (ugs.);keinen blassen Schimmer (haben) (ugs.);von nix wissen (ugs.);nicht die leiseste Ahnung haben;Da fragst du den Falschen. (ugs., Spruch)
-grüner Star;Glaukom
-Hyperbelnavigation;Hyperbelortung
-Frequenzwahlverfahren (fachspr.);Tonwahlverfahren;Mehrfrequenzwahlverfahren
-Zeitgenosse;(jemandes) Gegenüber (geh.);Mitmensch;Nächster (geh., biblisch);Mitbürger
-Echter Zimt;Zinnamon;Zimmet;Canehl;Cinnamomum verum (fachspr., lat.);Zimt (Hauptform)
-ganz wie es (...) gefällt;nach dem Lustprinzip;(so) wie es einem (in den Kram) passt (ugs.);nach Herzenslust (ugs.);(so) wie jemand (gerade) Lust (darauf) hat (ugs.);nach Lust und Laune (ugs.);(so) wie jemand (gerade) lustig ist (ugs.)
-(sich einer Sache) weihen (veraltend);(sich einer Sache) verschreiben;(einer Sache) leben (geh., altertümelnd);(sich) in den Dienst (einer Sache) stellen;(jemandes) Ein und Alles sein (ugs.);sein (ganzes) Herzblut hineinstecken;(jemandes) Leben sein;sein Leben (einer Sache) weihen;(sich einer Sache) widmen (Hauptform);aufgehen (in);(einer Sache) frönen;(sein) Herz hängen an;(sich einer Sache) anheimgeben (geh.);(sich) versenken (in);(sich einer Sache) hingeben (geh.)
-Unterschied wie Tag und Nacht (ugs.);riesengroßer Unterschied;himmelweiter Unterschied;schlagender Unterschied;deutlicher Unterschied;(sehr) großer Unterschied;kein Vergleich (sein) (ugs.)
-Abermilliarden;viele Milliarden
-viele Millionen;Abermillionen
-unharmonisch;misshellig (veraltet)
-Saccharase;β-Fructofuranosidase;Invertin (veraltet);Invertase
-(eine) Viertelstunde;15 Minuten;(eine) viertel Stunde;fünfzehn Minuten
-Gürkchen;Cornichon
-2-Punktperspektive;Übereckperspektive
-führen;führend sein (in/bei);vorn liegen;an der Spitze liegen;vorne liegen;ganz vorne sein (ugs.);das Feld hinter sich lassen;(jemandem) weit voraus sein;die Nase vorn haben (ugs.);in Führung liegen
-Kolonialspur;indische Breitspur
-(sich) überarbeiten;zu viel arbeiten
-Touristenattraktion;Sehenswürdigkeit
-Gewinne einfahren;schwarze Zahlen schreiben (fig.);Gewinn(e) machen;Geld verdienen (an);(seinen) Schnitt machen (mit);Gewinn erzielen;Gewinn herausschlagen
-Tonleiter;Skala
-Lehnsessel;Fauteuil
-Parkhaus;Hochgarage
-Akzessor;Zugriffsmethode;Zugriffsfunktion
-Pyrenäenfriede;Pyrenäischer Friede
-Manuelinik;Emanuelstil;Manuelismus;Manuelinischer Stil
-Hämatit;Rötel;Iserin;Roteisenerz;Blutstein;Specularit;Eisenglanz;Roteisenstein
-jeden zeitlichen Rahmen sprengen;(sich) ziehen (ugs.);(sich) hinschleppen (ugs.);(sich) endlos hinziehen (ugs.);(sich) ziehen wie (ein) Kaugummi (ugs.);dauern und dauern (ugs.);dauern (gesprochene Sprache, mit langgezogenem 'au') (ugs.);(sich) (endlos) in die Länge ziehen;(sehr viel) Zeit in Anspruch nehmen (variabel);später und später werden (und) (ugs.);(sich) hinziehen (ugs.);(sich) ziehen und ziehen (ugs.);endlos dauern;kein Ende nehmen (ugs.);(sehr viel) Zeit erfordern (variabel)
-verketten;aneinanderhängen;konkatenieren;aneinanderreihen;zusammenfügen
-Sojamilch;Sojadrink
-reibungslos über die Bühne gehen (ugs.);laufen wie geschmiert (ugs.);problemlos klappen (ugs.);glattgehen (ugs.);glattlaufen (ugs.);reibungslos funktionieren;ohne Probleme funktionieren;problemlos vonstattengehen;problemlos über die Bühne gehen (ugs.)
-Zingel (veraltet);Umfassungsmauer;Hauptmauer;Ringmauer
-preisbereinigt;inflationsbereinigt
-Elterngeneration;P-Generation;Parentalgeneration (fachspr.)
-Filialgeneration (fachspr.);Tochtergeneration;F-Generation
-Baumozelot;Bergozelot;Margay;Langschwanzkatze;Peludo
-Ozelotkatze;Tigerkatze
-Bergkatze;Andenkatze
-Nachtkatze;Kodkod;Chilenische Waldkatze
-Stapelrecht;Niederlagsrecht
-benachteiligt;gekniffen (ugs.)
-elektrische Generatorbremse;elektromotorische Bremse
-Sekretionsleistung;SPINA-GT (fachspr., Abkürzung);Inkretionsleistung;GT (fachspr., Abkürzung)
-SPINA (fachspr.);Struktur-Parameter-Inferenz-Analyse;Struktur-Parameter-Inferenz-Ansatz
-medizinische Kybernetik;biomedizinische Kybernetik
-Autoimmunthyreopathie 2B;Ord-Thyreoiditis;Atrophische Thyreoiditis
-Struma lymphomatosa;Hashimoto-Thyreoiditis
-Nieder-T3-Syndrom;NTIS;Non-Thyroidal-Illness-Syndrom;Euthyroid-Sick-Syndrom;Low-T3-Syndrom
-Hypophysen-Schilddrüsen-Regelkreis;Thyreotroper Regelkreis (fachspr.);Thyreotrope Achse (fachspr.);Hypophysen-Schilddrüsen-Achse;Thyreostat (fachspr.)
-Corticotrope Achse;Hypophysen-Nebennierenrinden-Achse;HPA-Regelkreis;HPA-Achse;Hypophysen-Nebennierenrinden-Regelkreis;Hypophysen-NNR-Achse
-spezifische Sekretionsleistung;SPINA-GTs (fachspr., Abkürzung);GTs (fachspr., Abkürzung)
-jeden Abend;am Abend;abends
-am Morgen;morgens
-um die Mittagszeit;zur Mittagszeit;mittags;gegen Mittag;jeden Mittag;am Mittag
-zu seinem Wort stehen;Wort halten (ugs.);(ein) Versprechen halten;für etwas einstehen;für etwas geradestehen;(ein) Versprechen einlösen
-Antriebsschlupfregelung;Traktionskontrolle;Antischlupfregelung (ugs.)
-(ein Stück) hochziehen;(ein Stück) hochheben;lupfen;lüpfen;anheben
-altenglische Sprache;angelsächsische Sprache;Angelsächsisch;Altenglisch
-neue Bundesländer;Dunkeldeutschland (derb);Ostzone (derb, veraltet);drüben (ugs.);ehemalige DDR
-Kambodschanisch;Khmer;Khmer-Sprache
-Wruke (nordostdeutsch);Erdkohlrabi;gelbe Rübe (schweiz.);Bodenkohlrabi;Kohlrübe;Steckrübe
-Wurzelgemüse;Rübe
-Republikanischer Kalender;Französischer Revolutionskalender
-Servoregler;Servoverstärker
-Polytechnikum;polytechnische Bildungsanstalt;polytechnische Hochschule
-Maschinenbauschule;Höhere Technische Lehranstalt;Ingenieurschule;Ingenieurakademie;Technische Akademie;Technische Mittelschule
-Verbundmotor;Doppelschlussmotor;Compound-Motor
-Standard-Partykleidchen;das kleine Schwarze
-Etuikleid;Shiftkleid;Schlauchkleid;Futteralkleid
-Stabilisator;Stabi (ugs.)
-Perforation;Perforierung
-Primäraluminium;Hüttenaluminium
-aufs;auf das
-Hartz-4ler (derb);Dauerarbeitsloser;Langzeitarbeitsloser;Hartz-IV-Empfänger;Hartzer (derb);Empfänger von Arbeitslosengeld II
-von jedem etwas;querbeet (durch) (ugs.);bunt gemischt;quer durch;(einmal) quer durch den Garten (ugs.);von allem etwas
-(einen) Streifzug machen;umherziehen;umherwandern;streifen (durch);(sich) herumtreiben (ugs., abwertend);zigeunern (ugs., abwertend)
-(etwas) einwerfen;(jemandem) das Wort abschneiden;dazwischenrufen;dreinreden;(jemanden) nicht ausreden lassen;(jemanden) keinen Gedanken zu Ende führen lassen;(jemanden) nicht zu Wort kommen lassen;(jemandem) ins Wort fallen;(jemanden) unterbrechen;dazwischenquatschen (ugs.);(jemandem) in die Parade fahren (geh.);reinreden (ugs.);reingrätschen (ugs., fig.);interpellieren (geh., lat., sehr selten);(ungefragt) dazwischenreden (Hauptform)
-Scheiß drauf! (vulg., Spruch, kommentierend);nichts am Hut haben (mit);(jemandem) gleichgültig sein;(jemandem) schnurzpiepe (ugs.);(jemanden) gleichgültig lassen;(jemandem) einerlei sein;(sich) nicht (weiter) kümmern um (ugs.);(jemanden) nicht jucken (ugs.);Scheiß der Hund drauf. (derb, Spruch, kommentierend);(jemandem) egal sein (Hauptform);(jemandem) Latte (ugs.);(jemanden) nur peripher tangieren (geh.);pfeifen auf (ugs.);(jemandem) Blunzen sein (ugs., wienerisch);(jemanden) nicht scheren (geh., veraltend);(jemanden) nicht nervös machen;das tangiert mich (äußerst) peripher (geh., Spruch, bildungssprachlich, scherzhaft, verhüllend);(jemandem) wumpe (ugs., regional);(jemandem) scheißegal (derb);(jemanden) nicht die Bohne interessieren (ugs., Redensart);(jemandem) schnurz (ugs.);(sich) nicht scheren um;(jemandem) schnuppe (ugs.);(jemanden) nicht unruhig schlafen lassen (fig.);mit den Achseln zucken;drauf scheißen (vulg.);(völlig) kalt lassen;erzähl das der Parkuhr (ugs., Spruch, veraltet);(jemanden) nicht interessieren;(jemandem) latte (ugs.);(jemandem) nicht den Schlaf rauben (fig.);das kannst du deinem Frisör erzählen (ugs., Spruch);(jemandem) (glatt / direkt) am Arsch vorbeigehen (derb);keinen gesteigerten Wert legen auf (ugs.);(jemanden) nicht kümmern (veraltend);(jemanden) nicht kratzen (ugs.);keinen Wert legen auf;sprich zu meiner Hand (ugs., Spruch, variabel);(an jemandem) abprallen (fig.);(jemanden) nicht anfechten (geh., veraltend);(mit etwas) nichts zu tun haben;(jemandem) herzlich egal (ugs.);nichts geben auf (ugs.);(jemandem) piepegal (ugs.);(jemandem) sowas von egal (ugs.);den lieben Gott einen guten Mann sein lassen (ugs., Redensart);(jemandem) wurscht (ugs.);(jemanden) nichts angehen;(jemanden) nicht tangieren (geh., bildungssprachlich)
-(sich) fehl am Platz fühlen;blöd dastehen (ugs.);(rumhängen) wie ein Schluck Wasser in der Kurve (ugs.);herumlaufen wie Falschgeld (ugs.);verloren herumstehen;dumm aus der Wäsche gucken (ugs.);herumlaufen wie falsch Geld (ugs.);dastehen wie bestellt und nicht abgeholt (ugs.);dastehen wie Pik Sieben (ugs.);(sich) fremd fühlen;(sich) nicht zugehörig fühlen;dumm dastehen;blöd aus der Wäsche gucken (ugs.)
-Sonnenenergie;Solarenergie
-erneuerbare Energie;regenerative Energie;Grünstrom (ugs.);Ökostrom (ugs.);Naturstrom;alternative Energie;grüner Strom (ugs.);Alternativenergie;Naturenergie
-Zentripetalkraft;Radialkraft
-Schmiegekreis;Krümmungskreis;Schmiegkreis
-Rattan;Peddigrohr
-Pfahlrohr;Spanisches Rohr;Riesenschilf
-nicht (dazu) zu bewegen sein, zu/dass;(sich) nicht bequemen (zu) (ugs.);nicht gewillt sein zu;unwillig sein;keine Anstalten machen (ugs.)
-Leidenschaftslosigkeit;unerschütterlicher Gleichmut;Kaltblütigkeit;Ataraxie (geh.);Gemütsruhe;Gefasstheit;Charakterstärke;Seelenruhe;stoische Haltung;Gleichmut;Unerschütterlichkeit;Selbstbeherrschung;Abgeklärtheit;Gelassenheit;Kontenance (geh.);Gleichmütigkeit;Beherrschung;Beherrschtheit;Besonnenheit;Fassung;Ausgeglichenheit;Contenance (geh., franz.)
-Wuchtbaum;Hebebaum
-Mitglied einer Genossenschaft;Genosse;Genossenschaftler;Genossenschafter
-Supplement;Beigabe;Beiblatt;Ergänzung;Beiheft;Einlage
-Hermelin;Kurzschwanzwiesel;Großes Wiesel;Mustela erminea (fachspr., lat.)
-hydraulischer Widder;Staudruck-Wasserheber;Wasserwidder (ugs.);Stoßheber
-anthropomorph;von menschlicher Gestalt
-(Frage) mit nein beantworten;(Frage) verneinen;(Frage) abschlägig bescheiden (Amtsdeutsch)
-(sich in etwas) vertiefen;(sich mit etwas) intensiv beschäftigen;(sich in etwas) reinhängen (ugs.);(sich in etwas) reinknien (ugs.)
-(etwas) kaufen können;auf dem Markt;im Handel erhältlich;zu kaufen (sein);ausgeliefert worden sein
-Hartz IV (ugs.);ALG II (Abkürzung);Arbeitslosengeld II
-Erziehungseinrichtung;Erziehungsanstalt
-chiffriert;codiert;verschlüsselt
-nicht zu entziffern;nicht decodierbar;nicht zu knacken (ugs.);nicht dechiffrierbar;nicht zu entschlüsseln
-Gutglaubenserwerb (fachspr.);Rechtsscheinerwerb (fachspr.)
-Propagandist;Zeitschriftenwerber;Werber;Promoter;Drücker (ugs., abwertend);Aboverkäufer (ugs.)
-(soziales) Umfeld;Lebensumfeld;Mitwelt;(soziale) Umgebung;lebensweltlicher Zusammenhang;Lebenskreis;Lebenswelt
-viszerales Nervensystem;vegetatives Nervensystem;Vegetativum;autonomes Nervensystem
-animalisches Nervensystem;willkürliches Nervensystem;cerebrospinales Nervensystem;animales Nervensystem;somatisches Nervensystem
-(sich) abseilen;(sich) an einem Seil herunterlassen
-Schneeschleuder;Schneefräse
-Physiotherapie (Hauptform);Krankengymnastik (veraltet)
-Übergangsfunktion;Sprungantwort
-Impulsantwort;Gewichtsfunktion
-Schwellenwertfunktion;Einheitssprungfunktion;Stufenfunktion;Heaviside-Funktion;Theta-Funktion;Treppenfunktion;Sprungfunktion
-beschissen (derb);mit Kot verunreinigt;vollgeschissen (derb);zugeschissen (derb);voller Scheiße (derb);bekotet
-Hinweiswort;Pseudoeinheit;Pseudomaßeinheit;Hilfsmaßeinheit;Pseudomaß
-Messschraube;Mikrometer;Mikrometerschraube
-Feintaster;Feinzeiger
-an einer Wahnvorstellung leiden;der Wahnvorstellung ausgesetzt sein, dass;an der Wahnvorstellung leiden, dass;in einer Wunschwelt leben;von etwas nicht abzubringen sein;eine fixe Idee haben;(sich) in etwas verrannt haben (ugs.);in dem Wahn leben, dass
-Zeichentheorie;Wissenschaft der Zeichensysteme;Semiologie (veraltet);Semiotik
-auf alles gefasst (ugs.);fatalistisch;gottergeben;dem Schicksal ergeben;schicksalsergeben
-nicht mit der Wimper zucken;ein Gemüt wie eine Brummfliege haben (ugs., selten);einen gutmütigen Charakter haben;eine Seele von Mensch sein (ugs.);(sich) nicht aus der Ruhe bringen lassen;ein Gemütsmensch sein;nicht in (ungesunde) Hektik geraten;nicht aus der Ruhe zu bringen sein
-Luftikus (ugs.);Heiopei (ugs., rheinisch);Windbeutel (ugs.);Flabes (ugs., rheinisch);Leichtfuß (ugs.);Windei (ugs.);Luftnummer (ugs.);Schiffschaukelbremser (ugs., scherzhaft);lockerer Vogel (ugs.);Knalltüte (ugs., fig.);Windhund (ugs.);Hallodri (ugs.);loser Vogel (ugs.);Bruder Leichtfuß (ugs.);Knallcharge (ugs., fig.);Bruder Lustig (ugs.)
-Kontranym;Antagonym;Januswort;Autoantonym
-Meterstab (ugs., Hauptform, süddt.);Schmiege (ugs., obersächsisch);Maßstab (ugs., regional, österr.);Zollstock (ugs., Hauptform, norddeutsch);Meter (Mosel-Main-Region) (ugs., schweiz.);Doppelmeter (ugs., regional, schweiz.);Gliedergelenkstabmaß (fachspr., Amtsdeutsch);Gliedermaßstab (fachspr.);Klappmeter (ugs., regional);Zollstab (ugs., ostösterreichisch)
-(sich) durch etwas nicht beeindrucken lassen;ruhig Blut bewahren (ugs.);(sich) nicht aus der Ruhe bringen lassen;gleichgültig reagieren;eiskalt reagieren;(durch etwas) nicht zu erschüttern (sein);(sich) durch nichts erschüttern lassen;eiskalt bleiben;unbeeindruckt reagieren;(sich) durch etwas nicht tangieren lassen
-Bloom-Syndrom;kongenitales teleangiektatisches Syndrom
-Chromosomen-Instabilitätssyndrom;Chromosomenbruchsyndrom
-Boder-Sedgwick-Syndrom;Louis-Bar-Syndrom
-genossenschaftliche Versicherung;VVaG;Versicherungsverein auf Gegenseitigkeit;Versicherungsverein;genossenschaftlicher Versicherer
-Kleinstkrankenversicherung;Mikrokrankenversicherung
-Kohäsion (fachspr.);sozialer Zusammenhalt
-Mutabilität;Veränderlichkeit;Wandlungsfähigkeit
-Verwandlungsfähigkeit;Varianz;Vielfalt an Varianten;Launenhaftigkeit;Mannigfaltigkeit;Veränderlichkeit;Variationsreichtum;Variantenreichtum;Wandelbarkeit;Unbeständigkeit;Wechselhaftigkeit;Veränderbarkeit;Variabilität;Abwechslungsreichtum
-Transformationsstaat;Konversionsland;Transformationsland
-(gar) nicht (erst) aufkommen lassen;(etwas) schon im Ansatz unterdrücken;(gar) nicht (erst) einreißen lassen;den Anfängen wehren (geh.);(etwas) im Keim ersticken (fig., Hauptform);(etwas) von vornherein unterbinden;(etwas) schon im Vorfeld abblocken;(etwas) gar nicht (erst) so weit kommen lassen
-margenstark;gewinnträchtig
-Subproletariat;Prekariat;(der) untere Rand der Gesellschaft;White trash;(der) Bodensatz der Gesellschaft;Lumpenproletariat (derb)
-in die Pötte kommen (ugs.);den Arsch hochkriegen (derb, fig.);in die Puschen kommen (ugs.);in die Strümpfe kommen (ugs., fig.);aus der Hüfte kommen (ugs.);aus dem Quark kommen (ugs., fig.);den Hintern hochkriegen (ugs., fig.);in die Gänge kommen (ugs., Hauptform);aus dem Schuh kommen (ugs., fig.);in die Hufe kommen (ugs.);aus den Puschen kommen (ugs., fig.)
-Kraftspindel;Kraftspannspindel;Hochdruckspindel;Spannspindel
-es nicht bringen (zu);(jemandem) ist es nicht gegeben (zu) (geh.);unfähig sein (zu);es nicht schaffen (zu);es nicht verstehen (zu);es nicht vollbringen (zu) (lit.) (geh.);es nicht übers Herz bringen (zu);nicht dazu im Stande sein (zu);der falsche Mann sein (für/um zu);nicht in der Lage sein (zu);(sich) außer Stande sehen (zu);kein Händchen dafür haben (zu) (ugs.);die falsche Frau sein (für/um zu);nicht können
-nach der Qualität gehen (ugs.);mehr bezahlen;mehr ausgeben;einen höheren Preis zahlen;nicht auf den Preis gucken;tiefer ins Portmonee greifen (ugs.);tiefer ins Portemonnaie greifen (ugs.);mehr investieren
-Austerität;Sparsamkeit
-eine Sprache sprechen;einer Sprache mächtig sein;eine Sprache beherrschen
-das sagt alles (ugs.);(etwas) spricht für sich (selbst);(zu etwas) ist nichts weiter zu sagen (ugs.);Kommentar überflüssig. (ugs.)
-Anschlagwinkel (Werkzeug);90°-Winkel;Bauwinkel (Werkzeug);rechter Winkel;Flachwinkel (Werkzeug);Haarwinkel (Werkzeug)
-besorgt;geholt;erworben;gekauft;organisiert;beschafft
-Giftmischer (fig.);Hetzer;Ränkeschmied (veraltet);Ränkespieler (veraltet);böser Mensch;Giftzwerg;Giftspritze (fig.);gehässige Person;Giftnudel (ugs.);boshafter Mensch;Intrigant
-beschädigt;(in seiner Funktion) eingeschränkt;nicht mängelfrei;berieben (Bucheinband);beeinträchtigt;Mängel aufweisen(d);nicht mehr tadellos;abgestoßen;mit einem Defizit (bei etwas);nicht mehr alle Funktionen haben(d);angestoßen;funktionsbeeinträchtigt;mit (kleineren) Mängeln;mängelbehaftet;fehlerhaft;angeknackst;mangelhaft (Hauptform);mit kleinen Macken;nicht ohne Makel (geh.);nicht mehr voll funktionsfähig;schadhaft;angemackelt (ugs.);nicht mehr einwandfrei;vermackelt (ugs.)
-rührstückhaft;gefühlig;larmoyant;kitschig;im Überschwang der Gefühle;schmalzig;melodramatisch;gefühlsduselig (ugs.);sentimental;seelenvoll;theatralisch;mit reichlich Herz und Schmerz;mit Pipi inne Augen (ugs., ruhrdt.);gefühlsbesoffen (ugs., abwertend);gekünstelt;tränenselig;gefühlsbetont (Hauptform)
-he? (regional vereinzelt) (ugs.);was? (ugs.);wa? (ugs., berlinerisch, norddeutsch, regional);gelle (ugs., süddt., veraltend);nä? (ugs., norddeutsch);nicht wahr?;woll? (Sauerland, bergisch) (ugs.);oder (etwa) nicht?;nicht? (ugs.);etwa nicht?;ja?;stimmt's?;oder? (norddt., süddt. verstreut) (ugs.);näch? (ugs., ruhrdt.);gell? (ugs., süddt.);gelt? (ugs.)
-sehr weit (Hauptform);kilometerweit (ugs.);meilenweit (ugs.);himmelweit (eingeschränkter Gebrauch)
-private Lehrveranstaltung;Privatissimum
-Triquetta;Triquetra;Triqueta
-(jemandem eine) SMS schicken (Hauptform);(jemanden) ansimsen (ugs., Neologismus);simsen (ugs., Neologismus);antexten;SMS verschicken;SMSen (ugs., Neologismus)
-Levitation;Schweben
-facettenreich;abwechslungsreich
-recte (bei Namen) (geh.);in Wirklichkeit;tatsächlich;ursprünglich;genau genommen;eigentlich;an und für sich
-Dorfsheriff (ugs., scherzhaft);Landgendarm;Dorfpolizist
-Einbahn (österr.);Einbahnstraße;Einrichtungsstraße (veraltet)
-Aufsichtsratsvorsitzender;Chefaufseher (ugs.);Chefkontrolleur (ugs.)
-Mittelmeer-Kiefer;Schirm-Kiefer;Italienische Steinkiefer;Pinie
-Alternativszene;Gegenkultur;Protestkultur
-Wertseite;Münzrückseite;Revers
-Münzvorderseite;Bildseite;Hauptseite;Avers
-Träumer;Traumtänzer;Luftikus
-Entität;Informationsobjekt
-triftiger Grund;guter Grund;handfester Grund
-Personenstunde;Mannstunde (veraltet)
-Glottisschlag;stimmloser glottaler Plosiv;Einschaltknack;Stimmritzenverschlusslaut;Knacklaut;Glottisverschlusslaut;Kehlkopfverschlusslaut
-Cholelith;Gallenkonkrement;Gallenstein
-Geschäftskunde;Kommerzkunde (österr.)
-Forke (ugs., salopp);Gabel
-Hundefutter;Hundenahrung
-Segmentierung;Aufteilung;Aufsplittung;Portionierung;Segmentation
-Tracheotomie;Luftröhrenschnitt
-weiße Mäuse (ugs., veraltet);Verkehrspolizei
-Schlampenpanzer (derb);SUV (Abkürzung, engl., Hauptform);Sportgeländewagen;Geländelimousine;Stadtgeländewagen;Straßenpanzer (ugs.);Sport Utility Vehicle (engl.)
-mottenzerfressen;von Motten zerfressen
-VW-Bus;VW-Transporter;Bulli (ugs.)
-zappen;zwischen Fernsehprogrammen hin- und herschalten
-stammeln;stottern
-keines gewaltsamen Todes sterben;eines natürlichen Todes sterben
-hungers sterben (geh., veraltet);bei/in einer Hungersnot umkommen;(den) Hungertod sterben;vor Hunger sterben;an Nahrungsmangel zugrunde gehen;verhungern (Hauptform)
-(ein) Methusalem (ugs.);Greis;sehr alter Mensch;Tattergreis (derb, stark abwertend)
-Dramödie;komödiantisches Drama;Dramedy
-Wellenimpedanz;Wellenwiderstand;Impedanz
-Weihnachtsfruchttaube;Dunkle Fruchttaube
-Abbott-Tölpel;Graufußtölpel
-Schildbürger;Einfaltspinsel;Spießbürger
-Hochbeet;Hügelbeet
-Femur;Oberschenkelknochen;Os femoris (fachspr., lat.)
-Bremer Transporter;Baureihe TN;Mercedes-Benz T 1
-Gebrüder Grimm;Brüder Grimm
-Matratzenschoner;Matratzenschutzauflage;Matratzenüberzug
-Präfixnotation;Lukasiewicz-Notation;Polnische Notation;PN (Abkürzung);Normale Polnische Notation;Warschauer Normalform;NPN (Abkürzung)
-Parsebaum;Syntaxbaum;Ableitungsbaum
-Ganzheitslehre;Holismus (fachspr.)
-Dachlawine;Schnutsch (ugs., regional)
-noble Gegend;teures Pflaster (ugs.);schicke Gegend;teure Gegend
-in Degradation befindlich (speziell Bodenqualität) (fachspr.);(sich) nach unten bewegend;wie ein Schneemann in der Sonne (sprichwörtlich);zum Scheitern verurteilt;im Absturz (fig.);ungebremst nach unten rasen(d);in Auflösung;in Abwärtsbewegung;im Abwärtstrend;bergab gehen (mit);(sich) zusehends verschlechtern(d);im Niedergang (befindlich);(sich) abwärts bewegend;im Sinkflug;dem Untergang geweiht;stetig fallend;im freien Fall (fig.)
-pönalisieren;unter Strafe stellen
-Hart (historisch);Harz
-Panzertier (ugs.);Schildkröte
-Griechischer Aufstand;Griechische Revolution;Griechischer Unabhängigkeitskrieg
-Fristerstreckung (österr.);Fristverlängerung
-Messerschmitt Kabinenroller KR 175;Schneewittchensarg (ugs.)
-durchsetzungskräftiger sein;besser sein als;überragen;stärker sein;überlegen sein;übertreffen;(jemandem etwas) voraus haben;von höherer Güte sein als
-tatsächliche Größe (fachspr.);reale Größe (fachspr.);physikalische Größe
-Ipomoea batatas (fachspr., griechisch, lat.);Weiße Kartoffel;Batate;Knollenwinde;Süßkartoffel (Hauptform)
-Ofenschlupfer;Kirschenmichel
-großer Respekt;Heidenrespekt
-ich übernehme die volle Verantwortung (formell);(war) mein Fehler (ugs.);mea culpa (geh., lat.);meine Schuld (variabel);Asche auf mein Haupt (ugs.)
-andächtig zuhören;hingebungsvoll lauschen;ganz Ohr sein (fig.);konzentriert zuhören;angestrengt horchen;aufmerksam zuhören
-nichts zu tun haben mit (ugs.);an der falschen Adresse sein (bei) (ugs.);keine Schuld tragen (an/für);nicht die Schuld tragen für;für etwas nicht verantwortlich sein;nicht verantwortlich sein (für);nicht jemandes Problem (sein);nicht jemandes Fehler sein;nicht jemandes Verantwortung unterstehen (geh.);(etwas) nicht in Schuld sein (ugs., ruhrdt.);nicht zuständig sein (für);außerhalb jemandes Zuständigkeitsbereich liegen (fachspr., Amtsdeutsch)
-Anzug;Zwirn
-Amerikastudien (Plural);Amerikakunde;Amerikanistik
-Smoking;Abendanzug;(kleiner) Gesellschaftsanzug
-großer Gesellschaftsanzug;Frack;Schwalbenschwanz (scherzhaft, veraltend)
-Rassestandard;Zuchtstandard
-Langmut;große Geduld;Gemütsruhe
-(sich) explosionsartig vermehren;massiv auftreten;(sich) rasant verbreiten;explodieren (Zahl + Gen.) (fig.);wie die Pilze aus dem Boden schießen (ugs.);ins Kraut schießen (ugs.);(sich) vermehren wie die Karnickel (ugs.);wie Pilze aus der Erde schießen (ugs.);(sich) vervielfachen
-Erdmännchen;Scharrtier (veraltet);Surikate
-Virostatikum;Virustatikum
-Inundationsgebiet;Überschwemmungsgebiet;Retentionsgebiet;Hochwasserpolder;Hochwasserschutzpolder
-Pol der relativen Unerreichbarkeit;Unzugänglichkeitspol;Pol der Unzugänglichkeit
-Staatsvertrag für Rundfunk und Telemedien;RStV;Rundfunkstaatsvertrag
-ohne Angst;ohne mit der Wimper zu zucken (ugs., fig.);mutig;unverzagt;nicht ängstlich;angstfrei;furchtlos;unerschrocken
-Schwingungsmoden;Moden;Raummoden
-kapazitive Erwärmung;dielektrische Erwärmung
-Indochinakonferenz;Genfer Konferenz
-Commonwealth der Nördlichen Marianen;Nördliche Marianen
-unterheben;vorsichtig durchmischen
-Kleiderstoff;Mantelstoff
-Einleitung;Auftakt
-vermindern;verringern;Verluste zuführen
-veranlasst sein durch;(sich) erklären lassen durch;Ausfluss sein von;motiviert sein durch;zugrunde liegen;am Ende stehen;das Ergebnis sein von;ausgelöst worden sein durch;das Endergebnis sein von;das Resultat darstellen von;Folge sein von;die logische Konsequenz sein von;in ursächlichem Zusammenhang stehen mit
-Pier;Kaizunge
-ebenfalls;dito
-(eine) Fresse ziehen (derb);mit verhangenem Blick;sauer aussehen (ugs.);mit einem Gesicht wie sieben Tage Regenwetter (ugs., sprichwörtlich);griesgrämig (drein)blicken(d)
-die Stirn runzeln angesichts;zweifelnd schauen
-gereizte Atmosphäre;(die) Stimmung ist im Keller (ugs., fig.);(die) Stimmung ist am Boden (ugs., fig.);der Haussegen hängt schief (ugs., Redensart);schlechte Stimmung;dicke Luft (ugs., fig.)
-Schiefermappe (Zentral-Sachsen, vereinzelt) (ugs.);Schieferkästchen (ugs., ostsächsisch);Schlamper-Etui;Federtasche (ugs., norddeutsch, ostdeutsch);Federmäppchen;Federetui;Etui (ugs., schweiz.);Kramtasche (verstreut) (ugs.);Mäppchen (ugs., pfälzisch);Federbox;Federkästchen (ugs., westsächsisch);Schlamper (ugs.);Federkasten (veraltet);Federschachtel (ugs., regional, österr.);Schlampermäppchen;Federmappe (außer Norddtld. verbreitet) (ugs.);Federpennal (österr.);Mäpple (ugs., schwäbisch);Griffelschachtel (ugs., südtirolerisch);Schul-Etui (ugs., niederrheinisch, westfälisch);Stiftetasche
-Interlace (engl.);Zeilensprungverfahren;Zwischenzeilenverfahren
-Hyperglykämie;zu hoher Blutzuckerspiegel;Überzucker (ugs.)
-Übergewicht haben;(...) zu viel auf die Waage bringen;gut im Futter (stehen) (ugs., scherzhaft);aus allen Nähten platzen (ugs.);(stark) zugenommen haben;mehr geworden (sein) (ugs., scherzhaft-ironisch);zu viel wiegen
-Hering (ugs.);Hänfling;Strich in der Landschaft (ugs.);Schmächtling;Spucht (ugs., norddeutsch);Kümmerling (ugs.);schmales Handtuch (ugs.);halbe Portion (ugs.);Schmachtlappen (ugs., rheinisch);Spargeltarzan (ugs.);Mickerling (ugs.);Spinnewipp (ugs., ruhrdt., veraltet)
-einen Bärenhunger haben (ugs., variabel);einen Mordsappetit haben (ugs.);ausgehungert sein;Hunger für zwei / drei / vier ... mitbringen (ugs.);dürsten und darben (geh., ironisch);(einen) Mordshunger haben;(mächtig) Kohldampf haben (ugs.);ordentlich Hunger haben;Hunger für zwei / drei / vier ... (mitgebracht) haben (ugs.);(jemandem) hängt der Magen in den Kniekehlen (fig.);Heißhunger haben (auf);(jemandem) knurrt der Magen
-(jemandem) den Kopf verdrehen (fig.);(jemanden) durchdrehen lassen;verzaubern;(jemanden) um den Verstand bringen (ugs.);kirremachen (ugs.);bezaubern;(jemanden) in seinen Bann ziehen;betören (geh.);bezirzen;verhexen;(jemanden) verrückt machen;(ein) Herz im Sturm erobern;bestricken;verliebt machen;kirre machen (ugs.);entflammen (geh.);(jemandem) das Herz stehlen
-(ein) typischer Fall von denkste (ugs., salopp, variabel);so ist das (aber) nicht (ugs.);keine Rede sein können (von) (ugs.);falschliegen;nicht der Fall sein;(da) sage noch einer (...) (floskelhaft, variabel);(einfach) nicht stimmen (ugs.);weit gefehlt;(ein) Irrtum vom Amt (ugs.);womit eindeutig widerlegt wäre (dass) (floskelhaft);dem ist nicht so;(so) nicht stimmen (ugs.);sich irren (du irrst dich);nicht an dem sein (dass) (biblisch, regional);nicht die Rede sein können (von) (ugs.);nicht zutreffen (Hauptform);dem war nicht so
-sehr geringes Gehalt;schlechte Bezahlung;miese Bezahlung (ugs.);Hungerlohn (ugs.);Niedriglohn;extrem niedriger Lohn;Dumpinglohn;Dumping-Lohn
-Überwärmung (des Körpers);Hyperthermie (fachspr.)
-Jaguar Cars Ltd;Jaguar (ugs.)
-mach dir keinen Kopf! (ugs.);mach dir keine Gedanken! (ugs.);denk nicht weiter drüber nach! (ugs.);sei unbesorgt!;alles wird gut! (ugs.);keine Sorge! (ugs.);(jetzt) mach dir (mal) keine Sorgen! (ugs.);du kannst (ganz) unbesorgt sein (ugs.)
-(viel) halten auf;Wert legen auf
-in der freien Wildbahn (ugs.);draußen im Leben;in freier Wildbahn (ugs.)
-zuversichtlich;vertrauensvoll
-(eine) Aussage machen;(sein) Schweigen brechen;(sein) Schweigen beenden;aussagen
-fit wie ein Turnschuh (ugs.);voll im Saft stehen (fig.);voller Saft und Kraft (ugs.);nicht kaputtzukriegen (ugs.);völlig gesund;pumperlgsund (ugs., österr.);erfreut sich bester Gesundheit;bei bester Gesundheit (ugs.);kerngesund;(aussehen) wie das blühende Leben (ugs.)
-Einbettung;Inklusion;Einschluss
-Shannon'sches Kanalmodell;Kanal;Informationskanal;Übertragungsweg;Übertragungskanal
-inschallah;ich hoffe, dass;ich hoffe mal (dass) (ugs.);hoffen wir mal (dass) (ugs.);(es) bleibt zu hoffen, dass;hoffentlich (Hauptform);wir (wollen) hoffen, dass;so Gott will
-Stapellauf;Zu-Wasser-Lassen eines neuen Schiffs;Ausdocken
-rechtswirksam ausschließen;präkludieren
-Inflektiv;Erikativ (ugs., scherzhaft)
-Denunziant (abwertend);Entüller;Whistleblower;Hinweisgeber;Skandalaufdecker;Informant
-tüchtig zulangen;kräftig zulangen (ugs.);(sich) (gehörig) den Bauch vollschlagen;ordentlich reinhauen (ugs.);(sich) vollfressen (ugs.);essen wie ein Scheunendrescher (ugs.)
-rübermachen (ugs.);aus der DDR flüchten
-Open Content (engl.);Freie Inhalte
-(sich) gehören;vom Anstand geboten sein;(den) (üblichen / allgemeinen / bewährten ...) Gepflogenheiten entsprechen;Pflicht sein (ugs.);(sich) ziemen (veraltet);angemessen sein;schicklich sein (geh.);(den) Anstandsregeln Genüge tun (geh.);(sich) schicken;(sich) geziemen (geh., veraltet);(etwas) gebietet (schon allein) der Anstand (geh.);(den normalen) Anstandsregeln entsprechen;(sich) passen (geh., veraltend);(etwas) bringen können (ugs.)
-von gestern;vom Vortag;gestrig;vom vergangenen Tag
-Stromer (ugs.);Elektroauto;E-Auto (Kurzform)
-(sich einer) Kritik erwehren;(eine) Kritik zurückweisen;(eine) Kritik kontern;(sich) gegen Kritik verwahren;gegen Kritik Stellung beziehen;nicht auf sich sitzen lassen (wollen);(sich) gegen Kritik verteidigen
-nicht ungeschoren davonkommen (fig.);Federn lassen (müssen) (fig.);Einbußen hinnehmen (müssen)
-koste es, was es wolle;auf Biegen und Brechen;partout (ugs.);zum Äußersten entschlossen;wild entschlossen;auf Teufel komm raus (ugs.);unbedingt;komme was (da) wolle (geh.);ohne Rücksicht auf Verluste;um jeden Preis;und sei es mit Gewalt;unter allen Umständen;mit aller Gewalt;zu allem entschlossen;auf Gedeih und Verderb (geh.)
-Daseinsberechtigung;Existenzberechtigung;Raison d'être (geh., franz.);Legitimation
-technophob;technikfeindlich
-Bildung;Entwicklung;(das) Werden;Heranbildung;Genese;Aufkommen (geh.);Entstehung (Hauptform);Ausbildung (fachspr.);(das) Entstehen;Herausbildung
-Totenschein;L-Schein;Leichenschauschein;Todesbescheinigung
-VG Wort (Abkürzung);Verwertungsgesellschaft Wort
-Meinungsverschiedenheit (Hauptform);Dissens (geh.);Kontroverse
-Salzsee;Salzwassersee
-Schartenhöhe;relative Einsattelung;Prominenz;Schartentiefe;Höhe über Isohypse
-Persisches Eisenholz;Parrotie;Parrotia persica (fachspr.);Persischer Eisenholzbaum
-Iranisches Hochland;Persisches Plateau
-ausschweifender Lebenswandel;Libertinismus;Leben à la Bohème;Libertinage
-Rudergast (fachspr.);Person, die das Ruder bedient;Rudergänger (fachspr.);Steuermann (fachspr.)
-magnetisches Dipolmoment;magnetisches Moment
-Induktionskonstante;Vakuumpermeabilität;Magnetische Konstante;magnetische Feldkonstante
-Ausdehnungskoeffizient;Wärmeausdehnungskoeffizient
-Wärmedehnung;linearer Wärmeausdehnungskoeffizient;Längenausdehnungskoeffizient
-Raumausdehnungskoeffizient;Volumenausdehnungskoeffizient;kubischer Ausdehnungskoeffizient;räumlicher Ausdehnungskoeffizient
-' (Einheitenzeichen);Fuß
-Maßverkörperung;Etalon
-Halytsch-Wolhynien;Galizien-Wolhynien
-Mechanismus von Antikythera;Computer von Antikythera
-friemeln (ugs., ruhrdt.);rumprokeln (ugs.);rumfuckeln (ugs., ruhrdt.);prokeln (ugs.);rumstochern (ugs.);rumfuhrwerken (ugs.);rumfummeln (ugs.)
-svw.;so viel wie
-überlappend;zusammenfallend
-Dunstabzugshaube;Wrasenabzug (fachspr.);Dunsthaube
-Boyle-Mariottesches Gesetz;Boyle-Mariotte-Gesetz;Gesetz von Boyle-Mariotte;Boyle'sches Gesetz
-Avogadrosches Gesetz;Gesetz von Avogadro;Avogadrosches Prinzip;Satz von Avogadro
-unter freier Lizenz;unter einer Open-Source-Lizenz;lizenzfrei (ugs.)
-Spekulant;Heuschrecke (ugs., fig.);Finanzjongleur (ugs.);Zocker (ugs.);Finanzhai (ugs.)
-Altersquotient;Altenquotient;Altenlastquote
-mit Priorität;prioritär;vorrangig
-Antialiasing;Anti-Aliasing;Kantenglättung
-Pyroelektrizität;pyroelektrischer Effekt;pyroelektrische Polarisation
-in den Fokus nehmen;(den) Fokus richten auf;(sich) fokussieren (auf) (geh.);in den Blick nehmen;anvisieren;fokussieren;in den Mittelpunkt stellen;(sich) konzentrieren auf
-Jugoslawienkriege (Plural);Balkankonflikt
-Radioisotopengenerator;Radionuklidbatterie;Atombatterie
-Suchbegriff;Sucheingabe;Suchwort
-(etwas) wissen wollen;anfragen (ob);eine Frage stellen;fragen (Hauptform)
-gemächlich;geruhsam;gemach;in aller Seelenruhe (ugs.);in aller Ruhe;in Ruhe (ugs.);ruhig;allmählich;langsam;gemütlich;seelenruhig
-Klein-Venedig;Welser-Kolonie
-Bilderangst;Ikonophobie
-Ringvergleich;Ringversuch;Laborleistungstest
-Qualitätssicherung;Qualitätsprüfung;Qualitätskontrolle
-gehässig;injuriös;herabsetzend;verunglimpfend;ehrverletzend;diffamierend;herabwürdigend;(persönlich) beleidigend;ehrenrührig;verletzend;verächtlichmachend;verleumderisch;ehrabschneidend
-gehoben;hochstehend
-Leutschauer Gebirge;Leutschauer Berge
-hyperbolisch (fachspr.);übertreibend
-Pikanterie (fachspr.);eigenartiger Reiz
-Heiligenvita;Hagiografie (fachspr.);Hagiographie (fachspr.)
-Transmissionskoeffizient;Transmissionsfaktor
-Extinktion;optische Dichte
-Reflexionsfaktor;Reflexionskoeffizent
-Stadtmauer;Stadtwall;Stadtbefestigung
-neben;nebendem;hinzukommen;nebst;dazukommen;auch (noch);zusätzlich (zu);über ... hinaus;außerdem;Und ja - ... (mediensprachlich);obendrein;abgesehen von;zudem;extra;darüber hinaus
-Pangermanismus;Alldeutsche Bewegung
-Corpus amygdaloideum (fachspr.);Mandelkern;Amygdala (fachspr.)
-Gewürzlorbeer;Echter Lorbeer;Edler Lorbeer;Laurus nobilis (fachspr., lat.);Lorbeer
-unter dem;unterm (ugs.)
-Springseil;Hüpfseil
-Seitenhalbierende;Schwerlinie
-Ehrenamt;Freiwilligenarbeit;Ehrenposten
-direkte Demokratie;unmittelbare Demokratie;sachunmittelbare Demokratie
-subjektives Risiko;Moral Hazard (engl.);moralisches Risiko;moralische Versuchung
-nicht so richtig (ugs.);wahrscheinlich nicht;nicht großartig (ugs.);nicht wirklich (ugs., ironisierend);nicht groß (ugs.);herzlich wenig (ugs.);vermutlich kaum;schwerlich;eher nicht;wenig;wohl nicht;vermutlich nicht;kaum;nicht so recht (ugs.);schlecht;eher weniger (auch ironisch);nicht sehr (Hauptform);nicht so gut (ugs.);wohl kaum;wahrscheinlich kaum
-meditieren;sitzen
-beklecksen;bekleckern
-entwerten;im Wert mindern;im Wert herabsetzen;inflationieren (fachspr.);devalvieren (Währung) (fachspr.);abwerten;devaluieren (geh.)
-drankommen (ugs.);dran sein (ugs.);(als nächster) bedient werden;an der Reihe (sein);am Zug(e) (sein) (geh.);der Nächste sein;die Reihe ist an dir (zu ...) (geh.)
-Schreckstarre;Thanatose (fachspr.);Totstellreflex
-Höhenmessung;Altimetrie
-spanische Sprache;kastilische Sprache;Spanisch (Hauptform);Kastilisch
-Bayrischer Wald;Bayerwald;Bayerischer Wald
-deutsch-französischer Freundschaftsvertrag;Élysée-Vertrag
-Hautgout (geh., fig., franz.);riechen nach (ugs., auch figurativ);Anrüchigkeit;Ruch (von);Gschmäckle (schwäbisch);(...) Beigeschmack (auch figurativ)
-Filmschaffender;Filmemacher;Autorenfilmer;Regisseur
-Namensberatung;Namensagentur
-Namensgebung;Namestorming;Namensfindung
-Laserschwert;Lichtschwert
-Trent-Affäre;Mason-und-Slidell-Affäre
-großzügig;gönnerhaft;jovial;leutselig
-Marktführer;(die) Nummer 1 (ugs., fig.);Branchenführer;Platzhirsch (fig.);Branchenprimus (ugs.)
-Unterschiebung;Subduktion
-Obduktion;Aufschiebung;Überschiebung
-Kladogramm;Baum;Baumstruktur;Klassifikation;Verzweigungsstruktur;Klassifikationsschema;Taxonomie
-Mukoviszidose;zystische Fibrose
-beeindruckt;imponiert
-Rüstungswettlauf;Wettrüsten;Rüstungswettrennen (selten)
-GTO;geostationäre Transferbahn;Geotransferorbit
-KTS;MBTI;Myer Briggs Type Indicator;Keirsey Temperament Sorter;Typentest
-mehr oder weniger regelmäßig;in einer bestimmten Regelmäßigkeit;mit einer bestimmten Häufigkeit;so oft (Hauptform);in einer bestimmten Häufigkeit;mit einer bestimmten Auftretenswahrscheinlichkeit;mehr oder weniger oft
-nicht hinbekommen (ugs.);verpeilen (ugs.);nicht schaffen;nicht hinkriegen (ugs.)
-Zinssatz;Zinsfuß
-Panoramafreiheit (fachspr.);Straßenbildfreiheit (fachspr.)
-lichte Höhe;Lichthöhe
-Lichtweite;lichte Breite;lichte Weite
-Lichtmaß;lichtes Maß;Lichte;Öffnungsmaß
-Kaschmiri;Kashmiri
-Deseret-Alphabet;Mormonen-Alphabet
-elektronischer Zettelkasten;Gliederungseditor
-einen Moment später;kurz darauf;etwas später;kurze Zeit später;wenig später;bald darauf;(die) Tinte (unter dem Vertrag) war noch nicht trocken (als ...) (literarisch);nach kurzer Zeit;nach wenigen Sekunden / Minuten;kurz danach;einen Augenblick später
-einen Ruck geben;aufrütteln;aufschrecken
-Restwärme;verbleibende Wärme
-Unsauberkeit;Verschmutztheit;Unreinlichkeit;Unreinheit;Verunreinigung
-Errötung;Rötung;rötliche Färbung
-Statusbalken;Fortschrittsbalken;Ladebalken;Fortschrittsanzeige
-komplexe Amplitude;Zeiger;Phasor;Amplitudenvektor
-Strommarke;Blitzmarke
-siegesgewiss;sieghaft (geh.);siegessicher
-Hochtemperaturreaktor;HTR (Abkürzung)
-goniometrische Funktion;Kreisfunktion;trigonometrische Funktion;Winkelfunktion
-Werkzeugleiste;Symbolleiste
-GuD-Kraftwerk;Gas-und-Dampf-Kombikraftwerk;Gas-und-Dampfturbinen-Kraftwerk
-Wüstenfuchs;Fennek
-Radioaktivität;Kernzerfall;radioaktiver Zerfall
-wirtschaftliche Überhitzung;Spekulationsblase;Blase (ugs.)
-mandantenfähig;mandantentauglich
-Okra;Gemüse-Eibisch
-Echter Thymian;Römischer Quendel;Gartenthymian;Thymus vulgaris (fachspr., griechisch, lat.);Kuttelkraut
-gewöhnlicher Schnupfen;akute Rhinitis (fachspr.)
-Fleischwolf;Faschiermaschine;Fleischmaschine
-Zauberstab (ugs., Markenname);Pürierstab;Mixstab;Stabmixer
-höchstpersönlich;höchstselbst (geh.);in Person;in höchsteigener Person (ggf. ironisch, veraltet) (geh.);in persona (geh.);leibhaftig
-japanischer Kaiser;Tenno
-Beharrungstendenz;Remanenzeffekt
-(sich) verrechnen;(sich) verschätzen;aufs falsche Pferd setzen (ugs., fig.);nicht aufgehen (Rechnung, Kalkül) (fig.);zu hoch pokern (fig.);(sich) verspekulieren;falsch gedacht (haben) (ugs.);(sich) verzocken (ugs., fig.);(seine) Rechnung ohne den Wirt gemacht haben (fig.);(sich) verkalkulieren
-Farbigkeit;Chrominanz
-Geokodierung;Georeferenzierung;Verortung
-Schwimmstil;Schwimmart;Schwimmtechnik
-öffentliche Sitzbank;Parkbank
-Dislokation;Dislozierung;Ortsveränderung
-einer Partei angehören;Mitglied in einer Partei sein;Parteimitglied sein;ein Parteibuch haben
-territoriale Mobilität;räumliche Mobilität
-Turbogenerator;Vollpolmaschine
-Strudel;Wasserwirbel;Moskenstraumen;Mahlstrom;Malstrom
-Kent-Wolkoff-Affäre;Kent-Fall;Tyler-Kent-Affäre
-Sitzkrieg;Seltsamer Krieg (veraltet)
-Näherungsschalter;Näherungsinitiator;Annäherungsschalter
-Teslameter (ugs.);Magnetometer;Gaußmeter (ugs.);Magnetfeldstärkenmessgerät
-(jemanden) finanziell belasten;(jemandem) auf der Tasche liegen (ugs.);eine finanzielle Belastung (für jemanden) sein;auf jemandes Kosten leben;(sich von jemandem) aushalten lassen
-Mariä Aufnahme in den Himmel;Mariä Himmelfahrt
-Hof'sche Klammer;Enttackerer;Honduraner (ugs.);Klammeräffchen (ugs.);Schlangenzahn (ugs.);Entklammerer;Affenzahn (ugs.);Klammerentferner;Enthefter;Heftklammerentferner;Klammernentferner;Heftklammernentferner
-Heftmaschine;Klammermaschine;Klammeraffe (ugs.);Froscherl (ugs.);Heftgerät;Hefter;Heftapparat;Tacker (Hauptform);Bostitch (ugs.)
-(völlig) isoliert;sehr allein;allein gelassen;ganz allein;einsam und allein;(sich) selbst überlassen;von Gott und allen guten Geistern verlassen;(völlig) allein;(ganz) auf sich gestellt;niemand kümmert sich um;mutterseelenallein;allein auf weiter Flur;auf sich (allein) gestellt
-mondsüchtig;somnambul;schlafwandelnd
-Béchamelsauce;Béchamelsoße;Milchsauce;Sauce Béchamel (franz.)
-Gichtmoos;Schlangenmoos;Bärlapp;Hexenkraut;Krampfkraut;Drudenfuß;Harnkraut
-Beinwurz;Bienenkraut (ugs.);Beinheil (ugs.);Kuchenkraut (ugs.);Gemeiner Beinwell;Milchwurz (ugs.);Wundallheil (ugs.);Schadheilwurzel (ugs.);Echter Beinwell (Hauptform);Arznei-Beinwell;Hasenlaub (ugs.);Komfrei (ugs.);Beinwell (Hauptform);Symphytum officinale (fachspr., botanisch, griechisch, lat.);Wallwurz (ugs.);Schwarzwurz (ugs.);Schmalwurz (ugs.)
-Ehrenpreis;Grundheil (ugs.);Allerweltsheil (ugs.);Köhlerkraut (ugs.);Schlangenkraut (ugs.);Männertreu (ugs.)
-Weiberkittel (ugs.);Alchemilla mollis (fachspr., botanisch);Herrgottsmäntelchen (ugs.);Frauenmänteli (ugs.);Tauschüsselchen (ugs.);Gewittergras;Taublatt (ugs.);Frauenmantel;Muttergottesmantel (ugs.);Tränenschön (ugs.);Frauenhilf (ugs.);Frauentrost;Marienkraut (ugs.)
-Goldrute;Wundkraut (ugs.);Himmelbrand (ugs.);St. Petrus-Stab (ugs.);Gülden (ugs.);Unsegenkraut (ugs.);Machtheilkraut (ugs.);Petrusstab (ugs.);Pferdskraut (ugs.);Heidnisches Wundkraut (ugs.);Heilwundkraut (ugs.);Ochsebrot (ugs.);Wisselnkraut (ugs.)
-Täschenkraut (ugs.);Herzkreitsche (ugs.);Seckelkraut (ugs.);Beutelschneiderkraut (ugs.);Blutkraut (ugs.);Herzelkraut (ugs.);Geldbeutel (ugs.);Schinkensteel (ugs.);Himmelmutterbrot (ugs.);Gänsekresse (ugs.);Hirtentäschel;Täschelkraut (ugs.);Hellerkraut (ugs.)
-Drudenkraut (ugs.);Hermelin (ugs.);Hermünzel (ugs.);Hermel (ugs.);Mutterkraut (ugs.);Kamille
-Kaskraut (ugs.);Hasenpappel (ugs.);Schafkas (ugs.);Käsepappel;Gänsepappel (ugs.)
-Regenblume (ugs.);Ringelblume;Studentenblume (ugs.);Totenblume (ugs.);Warzenblume (ugs.);Magdalensblume (ugs.)
-Gottesgabe (ugs.);Herrgottsgnade (ugs.);Schöllkraut;Marienkraut (ugs.);Augenwurz (ugs.);Blutkraut (ugs.);Goldwurz (ugs.);Warzenkraut (ugs.);Herrgottsblatt (ugs.)
-Zwischenlösung;Interimslösung
-Stringersatzverfahren;Substitutionskompression;Wörterbuchkompression
-progressive Kompression;solide Kompression;kompakte Kompression
-Kennzahl;Messgröße
-stat.mi. (Einheitenzeichen, engl.);Meile;Englische Meile;statute mile (engl.);Landmeile
-Skandinavische Meile;Metrische Meile
-Brennelementesteuer (ugs.);Kernbrennstoffsteuer
-nach mehr schmecken (ugs.);kann man gut wegtrinken;süffig;zum Trinken einladend;zum gut Wegtrinken;(sich) gut trinken lassen;da könnte ich mich reinsetzen (ugs.);runtergehen wie Öl (ugs.);gut trinkbar;Lust machen auf mehr
-Swimmingpool-Reaktor;Wasserbeckenreaktor;Schwimmbadreaktor
-Atomreaktor;Atommeiler;Nuklearmeiler;Kernreaktor;Atombrenner (veraltet)
-Molotow-Ribbentrop-Pakt;Deutsch-sowjetischer Nichtangriffspakt;Hitler-Stalin-Pakt
-Fürstenverschwörung;Fürstenkrieg;Fürstenaufstand
-Torgauer Vertrag;Vertrag von Torgau;Torgauer Obligation
-Dolchstoßlüge;Dolchstoßlegende (auch figurativ)
-(sich in etwas) reinfuchsen (ugs.);(sich mit einer Sache) vertraut machen;(sich) einarbeiten;(sich in etwas) einlesen
-Buchweizen;schwarzes Welschkorn;Heidekorn
-Pseudocerealien;Pseudogetreide
-Quinoa;Reismelde;Andenhirse
-was die Leute sagen;Getuschel;Gewäsch (ugs.);Gemunkel (ugs.);Geschwätz (ugs.);Getratsche (ugs.);Gerede;Klatsch und Tratsch;Geraune;Hörensagen-Informationen;Informationen aus zweiter / dritter ... Hand;Geschwätz der Leute (ugs.)
-Händeschütteln;Handschlag;Shakehands (engl.);Händedruck
-Haushälterin;Hauswirtschaftshelferin (Ausbildungsberuf);Hilfskraft im Haushalt;Hausmädchen;Zugehfrau (veraltet);Kammerzofe (veraltet);Haustochter;Zofe (veraltet);Hausangestellte;Hausdame;Perle (halb-scherzhaft) (ugs.);Haushaltshilfe (Hauptform);Soubrette (Rollenfach bei Theater und Operette);Dienstmädchen;Stubenmädchen;Minna (veraltet)
-Fogosch (österr.);Zander;Schill;Fogasch (österr.);Sander;Hechtbarsch;Zahnmaul
-ein Boot/Flugzeug verlassen;von Bord gehen
-Zeitrelais;Minuterie (schweiz.)
-ambitionierter Zeitplan;knapper Zeitplan;sportlicher Zeitplan;straffer Zeitplan
-An-Bord-Gehen;Einsteigen;Boarding
-(die) Mau-Mau (ugs., abwertend, regional);Obdachlosensiedlung
-Musterung;Ortstermin;oberflächliche Betrachtung;Begehung;Durchsicht;Checkup;äußerliche Überprüfung;Inaugenscheinnahme (fachspr.);Besichtigung;Sichtung;Beschau;Begutachtung
-Zerfallswärme;Zerfallsenergie
-Zerfallswärme nach Abschaltung (AKW);Nachzerfallswärme
-im Zölibat lebend;zölibatär
-die Stadt am Fluss;Mülheim Ruhr;Mülheim an der Ruhr;Mülheim
-Mölmsch;altes Mülheimerisch;(alter) Mülheimer Dialekt;Mülheimer Platt;Mülheimer Mundart
-nachdrücklich empfehlen;sehr empfehlen;wärmstens empfehlen (ugs.);sehr ans Herz legen (fig.)
-fast sterben vor Lachen (ugs.);(sich fast) in die Hose machen vor Lachen (ugs.);(sich) beömmeln (ugs.);(sich) bekringeln (vor Lachen) (ugs.);loswiehern (ugs.);(sich) schlapplachen (ugs.);aus vollem Halse lachen;hysterisch lachen;geiern (ugs., regional);(sich) halbtot lachen (ugs.);(sich) festhalten müssen vor Lachen;(sich) schieflachen (ugs.);losgrölen (ugs.);(sich) scheckig lachen (ugs.);(sich) kringeln (vor Lachen) (ugs.);(sich) (beinahe) totlachen;(sich) schepp lachen (ugs., variabel);(sich) nicht mehr / kaum noch einkriegen (vor Lachen) (ugs.);(sich) (auf dem Boden) wälzen vor Lachen;wiehernd lachen;in die Tischkante beißen vor Lachen (ugs.);einen Lachflash haben;dröhnend lachen;einen Lachanfall haben;(sich) wegschmeißen (vor Lachen) (ugs.);rumgeiern (ugs.);Tränen weinen vor Lachen;(sich) weglachen (ugs.);(sich) kaputtlachen;(sich) (die) Seiten halten (müssen) vor Lachen;losprusten (ugs.);(sich) krumm und schieflachen (ugs.);(sich) kranklachen (ugs.);(sich) krumm und bucklig lachen (ugs.);Tränen lachen;wiehern (ugs.);(sich) biegen vor Lachen;grölen (vor Lachen);schallend lachen;(sich) ausschütten vor Lachen;herausplatzen vor Lachen;(sich) flachlegen vor Lachen (ugs.);(sich) den Bauch halten vor Lachen;(sich) kugeln (vor Lachen);(sich) (auf dem Boden) kugeln vor Lachen (ugs.);(sich) nicht / kaum noch halten können vor Lachen;(sich) (fast) bepissen vor Lachen (derb);(sich) 'nen Ast lachen (ugs.)
-im großen Ganzen;ganz allgemein gesagt;grosso modo (geh.);en gros;im Großen und Ganzen;allgemein gesehen;im Allgemeinen;grob;grob gesagt;ohne (jetzt) in die Einzelheiten zu gehen
-Laststromkreis;Hauptstromkreis
-Durchflutungsgesetz;ampèresches Gesetz;Durchflutungssatz
-Abiläum;Jubiläum eines Abiturjahrgangs
-Handelsflotte;Handelsmarine
-medizinisch;klinisch;ärztlich
-Handeln;Politik;Strategie
-Marianengraben;Marianenrinne
-Kurilen-Kamtschatka-Graben;Kurilengraben
-kulturbeflissen;bildungsbeflissen;bildungsbemüht;bildungshuberisch (abwertend)
-für das;fürt (ugs., norddeutsch);fürs
-Übersetzungsbüro;Übersetzungsdienst;Übersetzungsagentur
-Feierabend;Schicht im Schacht (ugs.);Schicht (ugs.);Arbeitsende;Büroschluss;Finito (ugs.);Zapfenstreich (ugs., fig.);Dienstschluss;Geschäftsschluss
-Haus der Kulturen der Welt;schwangere Auster (ugs.);Kongresshalle;HDKW;Jimmy Carters Lächeln (ugs.)
-Brunnen der Völkerfreundschaft;Brunnen auf dem Alex;Brunnen auf dem Alexanderplatz;Nuttenbrosche (ugs.)
-Schmettau-Brunnen;Wasserklops (ugs.);Weltkugelbrunnen
-ordentlich was (ugs.);eine Stange Geld (ugs.);(ein) hübsches Sümmchen (ugs.);(ein) Haufen Kohle (ugs.);(eine) horrende Summe (negativ);viel Geld;da muss eine alte Frau lange für stricken (ugs., Spruch);(eine) stolze Summe;(ein) beachtlicher Betrag
-Spatz von Paris;Edith Piaf
-Gilbert Bécaud;Monsieur 100000 Volt
-Bruce Springsteen;(der) Boss (ugs.)
-Palast der Republik;Erichs Lampenladen (ugs.);Ballast der Republik (Spottname) (ugs.);Palazzo Prozzo (ugs.)
-Hungerkralle (ugs.);Hungerharke (ugs.);Luftbrückendenkmal
-Quadriga auf dem Brandenburger Tor;Retourkutsche (ugs.)
-Karin Tietze-Ludwig;Lottofee
-(der) normannische Kleiderschrank (ugs.);Curd Jürgens
-Franz Beckenbauer (Eigenname);(der) Kaiser;Kaiser Franz
-Johann Wolfgang von Goethe;(der) Dichterfürst;Goethe
-(der) Albatros (ugs.);Michael Groß
-Otto von Bismarck;(der) eiserne Kanzler
-Margaret Thatcher;(die) eiserne Lady
-Louis XIV;Ludwig XIV.;(le) Roi-Soleil;(der) Sonnenkönig;Ludwig der Vierzehnte
-Josef Derwall;Jupp Derwall;Häuptling ondulierte Silberlocke
-Konrad Adenauer;Adenauer;(der) Alte von Rhöndorf;(der) Alte
-Rudi Völler (Eigenname, Hauptform);Tante Käthe (ugs., veraltet);Rudolf Völler
-(der) Kanzler der Einheit;(der) schwarze Riese (ugs.);Helmut Kohl (Eigenname);Bimbeskanzler (ugs.);(die) Birne (ugs.);(der) ewige Kanzler (ugs.);(der) Dicke von Oggersheim (ugs.)
-Mutter der Nation;Inge Meysel
-(der) Deichgraf;Schmidt-Schnauze;Helmut Schmidt
-Ludwig Erhardt;(der) Vater des Wirtschaftswunders
-Johannes Rau;Bruder Johannes
-Mao Tse Tung;(der) große Steuermann (ugs.);Mao Zedong
-Lady Diana;Lady D.;Diana Spencer;(die) Königin der Herzen;Diana Frances Spencer;Lady Di;Prinzessin Diana
-Thomas Kuhn;(die) singende Föhnwelle;Dieter Thomas Kuhn
-(die) singende Herrentorte;Helge Schneider
-Löwen;Leuven;Louvain
-(die) goldene Stimme aus Prag (ugs.);Karel Gott
-(die) schwedische Sphinx (ugs.);Greta Lovisa Gustafsson;(die) Göttliche (ugs.);Greta Garbo;(die) Traumprinzessin der Ewigkeit (ugs.)
-Barschaft;Geld;Vermögen;Besitz
-Striptiseuse;Stripperin;Striptease-Tänzerin;Nackttänzerin;Table-Dancerin;Erotiktänzerin;Schönheitstänzerin
-Stiftekopp (Rheinland) (ugs.);Meckifrisur (veraltet);Stiftelkopf (ugs.);Igelschnitt;Kurzhaarfrisur;raspelkurze Haare;Mecki (ugs., veraltet)
-(die) Hütte (ugs.);Hüttenstadt;Eisenhüttenstadt;Schrottgorod (ugs., scherzhaft, veraltet)
-skrofulös;an Skrofulose leidend
-regalieren (ugs.);(großzügig) bewirten
-Gefängniskrankenhaus;Inquisitenspital (österr.)
-herumerzählen (Hauptform);(mit etwas) hausieren gehen (ugs., fig.);jedem erzählen, der es hören will oder nicht;herausposaunen (ugs., fig.);ausposaunen (ugs., fig.);allen erzählen, die es hören wollen oder nicht;rausposaunen (ugs., fig.);(etwas) an die große Glocke hängen (ugs., fig.);hinausposaunen (ugs., fig.)
-aufrechterhalten;bleiben (bei);festhalten an;(sich) nicht aus dem Konzept bringen lassen (fig.);dabei bleiben;standhaft bleiben;nicht ablassen von;(sich) nicht beirren lassen;seiner Linie treu bleiben;Kurs halten (fig.);(sich) nicht abbringen lassen (von);(jemanden) nicht anfechten;(unbeirrt) weitermachen wie bisher;(etwas) unbeirrt fortsetzen;nicht abgehen von;fest im Blick behalten;nicht aus den Augen verlieren
-arabische Philologie;Arabistik
-Carnot-Wirkungsgrad;Carnot-Faktor
-Ausmerzung;Löschung;Entfernung;Vernichtung
-Verhandlungen aufnehmen;verhandeln;(sich) an einen Tisch setzen (ugs., fig.);(sich) zusammensetzen (ugs.)
-Profitmaximierung;Gewinnorientierung
-Substanzformel;Verhältnisformel;Elementarformel (veraltet);empirische Formel
-(die) Vorlage darstellen (für) (Hauptform);Modell stehen (für) (fig.);Pate stehen (für) (fig.);(sich) bedienen (bei) (fig.);Vorbild sein (für);(die) Blaupause liefern (für) (fig., variabel)
-mit allem einverstanden;(sich) nicht widersetzend;zu allem bereit;durchaus bereit;einverständig;willig;zu allen Schandtaten bereit (ugs., scherzhaft);bereitwillig;kooperativ
-(sich) nicht so anstellen (ugs.);(sich) nicht so haben (ugs.)
-Geschäftsereignis;Business Event
-mathematisch;nach Adam Riese (ugs.)
-Radikal;Wurzelkonsonant
-Silbentrennung;Worttrennung
-Valenciasee;Tacariguasee
-Zweiter Indisch-Pakistanischer Krieg;Zweiter Kaschmirkrieg
-Erster Indisch-Pakistanischer Krieg;Erster Kaschmirkrieg
-Bangladesch-Krieg;Dritter Indisch-Pakistanischer Krieg
-Vierter Indisch-Pakistanischer Krieg;Dritter Kaschmirkrieg;Kargil-Krieg;Kargil-Konflikt
-Hervorhebung;Betonung;Akzent;Akzentuierung;Pointierung
-Kammerzieler;Reichskammerzieler;Kammergerichtszieler
-Endlosdruckpapier;Endlospapier;Tabellierpapier
-Nährstoffeintrag;Eutrophierung;Nährstoffanreicherung
-folieren;laminieren
-Holländische Rolle;Taumelschwingung;Gier-Schwingung;Dutch Roll (engl.)
-Reichsstädtekollegium;Reichsstädterat;Reichsstädtebank
-Abolitionismus;Bewegung zur Abschaffung der Sklaverei
-erleichtert (sein);aufatmen (können) (fig.);noch einmal davongekommen (sein);heilfroh (sein)
-Ziffernblock;NumPad (engl.);Zehnerblock;Nummernblock;Num-Block (engl.)
-Fork (fachspr., engl.);Abspaltung (einer Software)
-Primar (österr.);Primararzt (österr.);Leitender Arzt (Hamburg);Primarius (österr.);Chefarzt
-hoch zu Ross;reitend;beritten;zu Pferde;zu Pferd
-Kodikologie;Handschriftenkunde
-Kirche;Religion;Glauben;Weltanschauung;Glaube;Glaubensrichtung;religiöse Überzeugung
-die Chuzpe besitzen (geh.);(die) Nerven haben (zu + Infinitiv) (ugs.);(sich) nicht scheuen (zu);(sich) die Freiheit nehmen (zu);die Chuzpe haben (geh.);so frei sein (zu) (geh., ironisch);(sich etwas) herausnehmen;(sich) erfrechen (geh., veraltet);(die) Frechheit haben (zu + Infinitiv) (ugs.);die Stirn haben (ugs.);(sich) erlauben;(sich) erkühnen;(sich) Freiheiten (heraus)nehmen;(die) Unverfrorenheit haben (zu + Infinitiv);(sich) aufschwingen (zu) (fig.);(sich einer Sache) erdreisten;(sich) unterstehen (ugs.);(sich etwas) leisten (ugs.);(sich etwas) anmaßen;(frech) das Haupt erheben (geh., fig.)
-Schlacht von Karfreit;Zwölfte Isonzoschlacht
-Lungenkreislauf;kleiner Kreislauf
-Werdegang;Entstehungsgeschichte;Entwicklungsweg;Entwicklung
-Optionsfeld;Mehrfachoptionsfeld;Optionsschaltfläche
-Bahnparabel;Weg;Pfad;Trajektorie;Ortskurve;Flugparabel;Ortsparabel;Flugkurve;Wurfparabel;Bahnkurve;Flugbahn
-Elastostatik (veraltet);Festigkeitslehre
-Bewusstsein;Wachzustand;Besinnung
-Messkelch;Altargerät;Weinkelch
-Aufbesserung;Lohnsteigerung;Gehaltserhöhung;Gehaltsaufbesserung;Schluck aus der Pulle (ugs., Jargon, fig.);Gehaltsplus;Gehaltssteigerung;(das) Lohn-Plus;Anhebung der Bezüge;Lohnerhöhung
-(rein) geistig;immateriell;ätherisch (geh.);vergeistigt;sphärisch;gedanklich;nur vorgestellt;nicht stofflich;unstofflich;spirituell;unkörperlich;gedacht;wesenlos;imaginär;körperlos;ideell
-Ammoniumchlorid;Salmiak
-Kücken (österr.);Küken;Kippchen (ugs.);Küchlein (ugs.);Gössel (Gans) (fachspr., norddeutsch)
-sekretolytisch (fachspr.);schleimverflüssigend
-sekretomotorisch (fachspr.);schleimlösend
-Antimykotikum;Arzneimittel zur Behandlung von Pilzinfektionen
-kritische Anordnung;Nullleistungsreaktor
-Funkeninduktor;Induktorium (veraltet)
-Sperrwandler;Hoch-Tiefsetzsteller
-Geißlersche Röhre;Geißlerröhre
-Horizontalausgangsübertrager;Zeilentrafo;Zeilentransformator
-Bereitschaftsbetrieb;Standby-Betrieb;Wartebetrieb
-Arbeitsplatzdichte;Arbeitsplatzbesatz
-sehr gut passen;wie angegossen passen (ugs.)
-Gliedschirm;Brayette;Schamkapsel;Braguette;Bragetto
-Kettenregister;Permutiertes Register;Permutiertes Verzeichnis
-Schaltknochen;Zwickelbeine (veraltet)
-Reintonaudiogramm;Tonaudiogramm;Hörkurve;Audiogramm
-weltlich;säkularisiert;laizistisch (griechisch);verweltlicht;säkular
-Brustschmerz;Thorakodynie (fachspr.);Thorakalgie
-Isomatte;Isoliermatte
-Back Office;interne Verwaltung;Verwaltungsabteilung;Stab;Stabsabteilung;Verwaltungsstab;Verwaltungsstab;Verwaltungsbereich
-Ersetzbarkeitsprinzip;Liskovsches Substitutionsprinzip
-Telekom;rosa Riese (ugs.)
-Photopisches Sehen;Tagsehen
-skotopisches Sehen;Nachtsehen
-Laserdiode;Halbleiterlaser
-Krim;Taurien (veraltet)
-Glockenstab;Schlittengeläut
-Kernkraftwerk Lubmin;Kernkraftwerk Nord;Kernkraftwerk Greifswald
-Magnetkernspeicher;Ferritkernspeicher;Kernspeicher
-Bodenunebenheit;Hubbel (ugs.);kleine Erhöhung;Huckel (ugs., ruhrdt.)
-Existenzminimum;Notbedarf
-Differenzialgleichung;Differentialgleichung
-Sumpfgas;Faulgas
-konkurrenzkräftig sein;ein starker Mitbewerber sein;gut dastehen;in einer guten Ausgangsposition sein;gut im Rennen liegen (ugs.);gute Karten haben (ugs.);gut aufgestellt sein;(eine) gute Startposition haben
-Onkologie;Krebsforschung
-linearer Mittelwert;Gleichwert;arithmetischer Mittelwert
-Mittelwert;Mittel (ugs.)
-Kreislauftauchgerät;Kreislaufatemgerät;Rebreather (engl.)
-Streichresultat;Streichergebnis
-Filmabtaster;Filmgeber;Telecine
-Modulationstransferfunktion;Modulationsübertragungsfunktion;Kontrastübertragungsfunktion
-sichern;absichern;absperren
-Jagdtasche;Jagdrucksack;Jägerrucksack;Aser (fachspr., Jägersprache);Rucksack
-Revier (Kurzform);Jagd (Kurzform);Jagdbezirk;Pirschbezirk;Jagdbogen;Jagdrevier;Jagdgebiet
-Hochstand (österr.);Jagdsitz (österr.);Kanzel;Jägersitz (österr.);Hochsitz
-stadtbekannt sein;(etwas) weiß (doch) jeder (ugs.);(die) Spatzen pfeifen es von den Dächern (ugs., fig., sprichwörtlich, variabel);die Runde machen (Geschichte) (ugs.);in der Zeitung gestanden haben;allgemein bekannt sein;Stadtgespräch sein;in aller Munde sein (ugs.);ins Gerede kommen (negativ);sich wie ein Lauffeuer verbreiten;von Mund zu Mund gehen (ugs.)
-Gangbang;Gruppensex;(es wird) wild durcheinandergevögelt (derb, variabel);(es) geht drunter und drüber (fig., veraltet, verhüllend);Rudelbums (ugs.);jede treibt es mit jedem (ugs.)
-sorgfältig;umsichtig
-regionaler Sprachgebrauch;dialektal;regional;im Dialekt;mundartlich;auf (+ Dialektname)
-Ischias (ugs.);Ischiasnerv;Nervus ischiadicus (fachspr., lat.)
-Aszites;Bauchwassersucht (ugs.)
-Medizinstudium;Studium der Medizin
-Beatmungsbeutel;Rubenbeutel;Ambu-Beutel (ugs.)
-Morbus Alzheimer;Alzheimer (ugs.);Alzheimer-Krankheit;Alzheimerkrankheit
-Leukokorie;amaurotisches Katzenauge
-abgegeben;übertragen (geh.);übermittelt
-body of knowledge;solides Wissen (fachspr.);Fachwissen (fachspr.)
-Schauplatz (fachspr.);(das) Drumherum (ugs.);Setting (engl.);Umgebung (fachspr.);Situation;Rahmen (fachspr.)
-Stabilisierung;Kräftigung;Konsolidierung;Festigung;Stabilisation
-AU-Bescheinigung;Krankschreibung (Hauptform);Arztzeugnis (schweiz.);Krankenschein (ugs.);AU (ugs., Abkürzung);n' Gelber (ugs.);Arbeitsunfähigkeitsbescheinigung (Amtsdeutsch);Gesundheitszeugnis (fachspr.);gelber Schein (ugs.);Attest (veraltet)
-ischämischer Schlaganfall (fachspr.);Hirninfarkt
-Sound-Logo (fachspr., Jargon);Sonic Logo (fachspr., Jargon);Titelmusik;Jingle;Titelmelodie;Audio-Claim (fachspr., Jargon);Erkennungsmelodie;Audio-Logo (fachspr., Jargon);Kennmotiv (fachspr.);Titelsong;Hörmarke (fachspr., juristisch)
-Salzkatze;Geoffroy-Katze;Kleinfleckkatze
-Gefühlserregung;Ergriffenheit;Pathos
-Kaderschmiede;Eliteschule;Grande école (fachspr., franz.)
-Lebensgefährtin;Lebensabschnittsbegleiterin;Lebenspartnerin
-wessen;derjenige, dessen;wes (veraltet);diejenigen, deren;diejenige, deren
-menscheln (ugs.);(sich) von seiner menschlichen Seite zeigen;Emotionen zeigen
-Kunstrichtung;Stilrichtung;Kunststil
-beidseits;zu beiden Seiten
-mit Leichenbittermiene;gestreng (ironisierend);todernst;bierernst (ugs.);(übertrieben) ernst
-Weinanbaufläche;Weinbaufläche;Rebfläche
-Lyse (fachspr.);Thrombolyse (fachspr.)
-städtische Atmosphäre;Urbanität (geh.)
-logischer Wert;Ja-/Nein-Wert;Boole'scher Wert;boolescher Wert;Wahrheitswert
-Lochziegel;Hohlziegel;Hochlochziegel
-Hohlblockstein;Hohlblock
-Klinker;hart gebrannter Ziegel;Hartbrandziegel
-Kriegsführung;Kriegswesen;operative Kunst;Kriegskunst;Kriegführung
-Gen Y;Millennials;Digital Natives;Generation Y
-Babyboomer;geburtenstarke Jahrgänge
-Seismograph;Seismometer;Seismograf
-Randerscheinung;(unwichtige) Begleiterscheinung;Nebenerscheinung;Nebensächlichkeit;Epiphänomen (geh.);Randphänomen;Nebensache
-Plauderei;Sabbelei (ugs.);Unterhaltung;Schnack (ugs., norddeutsch);Rumgequatsche (ugs.);Schwatz (ugs.);Konversation;Klönschnack (ugs., norddeutsch);Plausch;Plauderstündchen;unverbindliches Geplapper;Quätschchen (ugs.);Smalltalk;Geplauder;Quatscherei (ugs.)
-Haarnadelkurve;Kehre (fachspr.);Spitzkehre
-Kongokonferenz;Westafrika-Konferenz;Berliner Konferenz
-China-Taiwan-Konflikt (Eigenname);Taiwan-Konflikt (Eigenname)
-Neopren;Chlorbutadien-Kautschuk;Polychloropren;Chloropren-Kautschuk
-Golf;Golfsport
-Panama;Republik Panama
-Respiration (fachspr.);Atmung
-Übergangsfrequenz;Grenzfrequenz;Eckfrequenz
-kein Benehmen haben;keine Manieren haben;null Erziehung haben (ugs., Jargon, jugendsprachlich);entgleisen;rüpeln;(sich) danebenbenehmen;(die) Sau rauslassen (ugs.);kein Benimm! (ugs.);keine gute Kinderstube genossen haben;(ein) Benehmen wie eine offene Hose haben (ugs.);(sich) benehmen wie die Axt im Walde (ugs.);Benehmen ist Glückssache (, und Glück hat man selten). (ugs.);prollen (ugs.);herumpoltern (ugs.);(sich) schlecht benehmen (Hauptform);jegliche Manieren vermissen lassen (geh.);keinen Benimm haben;rumprollen (ugs.);aus der Rolle fallen
-Speisekammer;Vorratsraum;(die) Speis (ugs., süddt., österr.);Vorratskammer
-Smart Phone;Schlauphon (ugs., scherzhaft);Handy (ugs.);internetfähiges Mobiltelefon;Smartphone (engl., Hauptform)
-schaffen;performen (Denglisch);Leistung erbringen;leisten;Leistung bringen (ugs.)
-Geschichtsverfälschung;Geschichtsklitterung
-Kulturlosigkeit;Barbarentum;unzivilisiertes Verhalten
-(klare) Suppe (österr.);Bouillon (schweiz.);Brühe
-Escherichia coli;E. coli
-Feier;Anlass (schweiz.);Party;Cocktailparty;Fete;Festivität (scherzhaft)
-Feuerwerkskörper;Böller
-Banditennest;Räuberhöhle
-Heiermann (ugs., norddeutsch);Fünfmarkstück;5-Mark-Stück;Silberadler (ugs.);5-DM-Münze
-20-Mark-Schein;Zwanzigmarkschein;Zwanni (ugs.);Zwanziger;20-DM-Schein
-Atomschiff;Reaktorschiff;Nuklearschiff;Kernenergieschiff
-Dampfschiff;Dampfer
-Vasoresektion;Vasektomie
-60 Stück;(das) Schock (veraltet);5 Dutzend
-Richtungsänderung (fig.);Strategiewechsel (Jargon);Kursänderung (auch figurativ);(ein) Umsteuern;Kurswechsel (auch figurativ);Umorientierung;Richtungswechsel (fig.);Neuausrichtung
-Perspektivwechsel;Perspektivenwechsel;andere Optik;Wechsel der Blickrichtung;Umkehr der Blickrichtung
-Spanferkel;Milchferkel
-Indik;Indischer Ozean (Hauptform)
-Gitter-Boltzmann-Methode;Lattice-Boltzmann-Methode;Lattice-Boltzmann-Verfahren
-Kernsymptom;Leitsymptom;Kardinalsymptom
-Benignität;Gutartigkeit
-Malignität;Bösartigkeit
-Pilotwal;Grindwal
-Indischer Grindwal;Kurzflossen-Grindwal
-Langflossen-Grindwal;Gewöhnlicher Grindwal
-Semikola;Semikolons;Strichpunkte
-Krebserkrankung;Karzinom
-Bonzen (ugs.);Oberschicht;Wirtschaftselite
-Power-Taste;Ein-/Ausschalter;Ein-/Ausschaltknopf
-Verlangen zu trinken;Durst;Heißdurst (ugs.)
-mit Giftgas umbringen;vergasen
-(einen) Giftmord (an jemandem) begehen (geh.);durch Gift töten;mit Gift umbringen;(jemandem) Gift geben;vergiften
-Schnittstellendefinitionssprache;Schnittstellenbeschreibungssprache
-Pick (ugs.);Plek (ugs.);Plektrum;Plektron;Spielblättchen (ugs.);Plattl (ugs.);Zupflümmel (ugs.)
-Telharmonium;Dynamophon
-Sozialdemokrat;SPD-Mitglied;Sozi (ugs.)
-boolesche Algebra;boolescher Verband
-Bevölkerung;Population
-Elektronenhülle;Atomhülle
-Gegenwirkungsprinzip;drittes Newtonsches Axiom;Wechselwirkungsprinzip;Reaktionsprinzip
-lex secunda (fachspr.);Aktionsprinzip;Zweites newtonsches Gesetz
-Erstes newtonsches Gesetz;lex prima (fachspr.);Trägheitsprinzip
-Internationale Filmfestspiele Berlin (Eigenname, offiziell);Berlinale (Eigenname)
-Mittelasien;Zentralasien
-Mondkalender;Lunarkalender
-Sonnenkalender;Solarkalender
-physikalische Konstante;Naturkonstante
-Telekinese;Psychokinese
-Orientwissenschaft (Singular);Orientwissenschaften (Plural);Orientalistik
-FDA (engl.);Food and Drug Administration (engl.)
-Photovoltaikmodul;Solarmodul
-Credit (engl.);Leistungspunkt
-plug-in-hybrid-elektrisches Fahrzeug;Plug-in-Hybrid;Plug-in hybrid Electric Vehicle (engl.);Steckdosenhybrid;PHEV
-Reisezoom;Superzoomobjektiv
-Geschäker;Getändel;Anmache (ugs.);Flirt (Hauptform);Annäherungsversuch;Schäkerei
-Himmelfahrtstag;Christi Himmelfahrt;Auffahrt (schweiz.)
-Erkundungsdrang;Entdeckungsfreude;Forscherdrang;Forschungsdrang;Entdeckergeist;Pioniergeist;Entdeckerdrang
-Toastautomat;Toaster (Hauptform)
-Aussichtsturm;Aussichtswarte;Wartturm
-Thriller (Hauptform);Reißer;Pageturner (Buch) (engl.)
-Schneeballsystem;Pyramidensystem
-nützlich sein;von Nutzen sein;(eine) gute Hilfe sein;weiterhelfen;(etwas) bringen (ugs.);(es) bringen (ugs.);hilfreich sein
-nicht jemandes Schuld sein;(für etwas) nicht verantwortlich sein;nicht jemandes Idee (gewesen) sein;nicht auf jemandes Mist gewachsen sein (ugs.);etwas nicht gesagt haben (ugs.);(etwas) nicht schuld sein (ugs.);nichts dafür können (ugs.);(etwas) nicht in Schuld sein (ugs., ruhrdt.);ich war das nicht! (ugs.);(sich) (etwas) nicht ausgedacht haben
-Sauerampfer;Wiesen-Sauerampfer;Großer Sauerampfer;Sauerlump (sächsisch)
-urlaubshalber;ferienhalber
-Kostenvoranschlag;Kostenanschlag (ugs.);(ungefährer) Angebotspreis;(voraussichtlicher) Kostenrahmen
-israelischer Auslandsgeheimdienst;Mossad
-Vorhautverengung;Phimose
-Vorstellungsvermögen;Vorstellungskraft
-bürgerliches Recht;Zivilrecht
-Baudot-Code;Telexcode;Fernschreibcode
-Dreistärkenglas;Trifokalglas
-Speed-Badminton;Speedminton
-physikalische Technik;technische Physik
-computergestützte Physik;Computerphysik
-Standortbestimmung;Standortanalyse
-Teilordnung;Halbordnung;Partialordnung;partielle Ordnung;teilweise Ordnung
-Kyffhäuser;Kyffhäusergebirge
-Spitzwall;Wallburg;Schanze
-regulierter Chorherr;Canonicus regularis (lat.);Regularkanoniker
-Kanoniker;Chorherr;Stiftsherr
-Zipf-Verteilung;Zeta-Verteilung
-Union;Unionsparteien
-Lübeck-Urteil;Lübeck-Entscheidung
-Schuldigsprechung;Schuldspruch;Verurteilung
-Hubarbeitsbühne;Steiger;Arbeitsbühne;Hebebühne;Hubsteiger
-Glück auf, der Steiger kommt;Steigerlied;Steigermarsch
-Mitkopplung;positive Rückkopplung
-Rückkoppelung;Rückkopplung
-negative Rückkopplung;Gegenkopplung
-Nebenintervention;Streithilfe
-Höhenwetterkunde;Aerologie
-Rotationskartei;Rollkartei;Rolodex
-Schifffahrtskunde;Nautik
-Kaliumdefizit;Kaliummangel;Hypokaliämie (fachspr.)
-Faktorenanalyse;Faktoranalyse
-Brustkrebs;Mammakarzinom
-Martin-Notation;Krähenfußnotation
-Speiche;Radius (fachspr.)
-Elle;Ulna
-Vereinfachung;Simplifikation;Simplifizierung
-Leibwache;Garde du Corps (franz.);Prätorianer (lat.);Leibgarde;Leibwächter
-Psychopharmakon;psychoaktives Medikament
-Aluhut;Stanniolhütchen;Aluminiumhut
-Drehstrom-Asynchronmaschine;Käfigläufermaschine;Drehstrom-Induktionsmaschine
-Affengriff (scherzhaft-ironisch);Klammergriff;Kralle
-Vorratswirtschaft;Einlagerung;Bevorratung;Lagerhaltung;Vorratshaltung
-einstellige Verknüpfung;monadische Verknüpfung;unäre Verknüpfung
-zweistellige Verknüpfung;binäre Verknüpfung
-Ärität;Stelligkeit;Arität
-dramatische Pause;Kunstpause;Denkpause;rhetorische Pause
-unterbrechen;(einen) Break machen (Anglizismus, Jargon);(eine) Pause einlegen (Hauptform);innehalten (geh.);pausieren
-Frienstein;Vorderes Raubschloss
-Angiologie (fachspr.);Wissenschaft der Gefäßerkrankungen
-Superlativ (fachspr., Hauptform);höchste Steigerung(sform);höchste Steigerungsstufe;zweite Steigerungsstufe;zweite Steigerungsform
-Akzent;Akzentzeichen
-Satz von Gauß-Ostrogradski;gaußscher Integralsatz;Divergenzsatz
-MR-Fluoroskopie;Echtzeit-MRT;Echtzeit-Magnetresonanztomographie
-konventionelles Schichtaufnahmeverfahren;Verwischungstomographie;Röntgentomographie
-Schrein (geh.);Schapp (ugs., regional);Truhe;Lade;Kiste
-solenoid (fachspr.);quellenfrei (fachspr.)
-sampeln (ugs., engl.);registrieren;detektieren;messen;aufnehmen;sensen (ugs., engl.)
-Tip (engl.);Neujährchen;Trinkgeld
-probabilistischer Algorithmus;randomisierter Algorithmus;stochastischer Algorithmus
-determinierter Algorithmus;deterministischer Algorithmus
-elektronische Beschaffung;E-Procurement
-empfindlich;sensibel;zimperlich;überempfindlich;dünnhäutig;zartbesaitet;mimosenhaft;verletzlich;übersensibel
-fahl;aschfahl;grau wie Asche;aschbleich
-Magermixmotor;Magermotor
-Verwöhnung;Verzärtelung;Verweichlichung;Verhätschelung
-Antwortvorschlag;Option;Antwortmöglichkeit;Lösung;Auswahlantwort;Auswahlmöglichkeit
-Medienexperte (ugs.);Medienwissenschaftler
-Kunstgeschichte;Kunstwissenschaft
-Numismatiker;Münzkundler
-Befragter;Interviewter;Umfrageteilnehmer
-Schnaufer;Atemzug;Schnauf (ugs.)
-Accent circonflexe (fachspr., franz.);Hütchen (über / auf einem Vokal) (ugs.);Zirkumflex (fachspr.);Dach (über Vokal) (ugs.)
-Enthauptung;Dekapitation;Köpfen
-Labor-Informations- und Management-System;LIMS;Laborinformationssystem
-gehopst wie gesprungen (sein) (ugs., regional);dasselbe sein;keinen Unterschied machen;Das schenkt sich nichts. (ugs., Spruch);ein und dasselbe sein;Das kannst du halten wie du lustig bist. (ugs., salopp);(das) macht keinen (großen) Unterschied;Das kannst du halten wie ein Dachdecker. (ugs., Spruch);Jacke wie Hose (sein) (ugs., fig.);auf das Gleiche hinauslaufen;aufs selbe rauskommen (ugs.);auf eins rauskommen (ugs.);auf dasselbe rauskommen;aufs Gleiche hinauslaufen;Das kannst du so oder so halten. (ugs.);(sich) nichts nehmen (ugs.);egal sein;gehupft wie gesprungen sein (ugs., regional);auf dasselbe hinauskommen;gehubbst wie gehickelt (ugs., pfälzisch)
-arithmetischer Überlauf;Zählerüberlauf
-Straßburg;Strasbourg
-über andere Leute reden;tratschen
-schwere Sünde;Todsünde;nichtlässliche Sünde
-Todesstrafe;Kapitalstrafe (geh., veraltet)
-Dörrfleisch;Trockenfleisch
-Prioritätsprinzip;Prioritätsgrundsatz
-Möbiusschleife;Möbiusband;Möbius'sches Band
-Radzierblende;Radblende;Radkappe
-medizinisches Versorgungszentrum;MVZ
-Kreiskrankenhaus;Stadtkrankenhaus;Ambulatorium;Poliklinik
-Vierspänner;Viergespann;Quadriga
-Weisel (fachspr.);Stockmutter;Bienenkönigin
-Weisel (fachspr.);Ameisenkönigin
-Entier-Klammer;Ganzteilfunktion;Gaußklammer;Abrundungsfunktion;Ganzzahl-Funktion
-Flynnsche Klassifikation;Flynn'sche Taxonomie
-lusophon (fachspr.);portugiesischsprachig
-Lötstopplack;Lötstoppmaske;Soldermask;Stopplack
-Oberitalienische Seen;Insubrische Seen
-heim;nachhause;heimwärts;nach Hause
-European Financial Stability Facility (engl.);EFSF;Europäische Finanzstabilisierungsfazilität
-ESM;Europäischer Stabilitätsmechanismus;Euro-Rettungsschirm (ugs.)
-transneptunisches Objekt;Transneptun
-auf Kredit;auf Pump (ugs.);mit geliehenem Geld
-Straße von Luzon;Luzonstraße
-Impulssteuerung;Chopper-Steuerung
-mittlere quadratische Abweichung;mittlerer quadratischer Fehler
-Duopol;Dyopol
-Flugzeugnase;Bug
-Bug;Vorderteil eines Schiffs
-Gini-Index;Gini-Koeffizient
-Dreamliner;Boeing 787
-Stechbecken;Steckbecken;Bettpfanne;Schieber;Bettschüssel
-Streukügelchen;Globuli (Hauptform)
-affine Transformation;affine Abbildung
-bijektive Funktion;bijektive Abbildung;Bijektion
-unmännlich;tuntenhaft (ugs.);keinen Mumm in den Knochen haben (ugs.);mit abgespreiztem kleinen Finger;tuntig (ugs.);weibisch;weichlich;kein echter Kerl (ugs.)
-Prinzessin;Zimperliese;Prinzessin auf der Erbse;Prinzesschen (ugs., abwertend)
-Buchungsschluss;Buchungssperre
-spotten (über);verhohnepiepeln (ugs.);verspotten (Hauptform);auslachen;frotzeln (über) (ugs.);(sich) lustig machen (über);Witze machen (über);(einen) Scherz machen (über);(jemandem) ins Gesicht lachen;(jemandem) eine lange Nase machen (ugs., fig.);lächerlich machen;(sich) ein Lachen kaum verkneifen können (angesichts);Wer den Schaden hat, braucht für den Spott nicht zu sorgen. (geh., Sprichwort);witzeln;(sich) belustigen (über) (geh.);(jemandem) eine lange Nase drehen (ugs., fig.);Späße treiben (mit) (veraltend);(sich) auf jemandes Kosten amüsieren;Scherze treiben (mit);ins Lächerliche ziehen;nicht ernst nehmen;seinen Spaß haben (mit/bei);verlachen;durch den Kakao ziehen (ugs., fig.);(sich) mokieren (über);zum Gespött machen
-Hörspiel;Hörfassung
-Gesetz für den Vorrang Erneuerbarer Energien;Erneuerbare-Energien-Gesetz;EEG (Abkürzung)
-Radio-Dokumentation;Rundfunk-Feature;Radio-Feature;Feature
-Mikrofonierung;Mikrofonierungstechnik
-Aufnahmestudio;Tonstudio (Hauptform)
-Slideshow (engl.);Tonbildschau
-noch nicht ausgepackt;(noch) originalverpackt (Hauptform);OVP;noch in Folie eingeschweißt
-Selbstmord begehen;durch eigene Hand sterben;(sich) das Leben nehmen;(sich selbst) (den) Garaus machen (geh.);seinem Leben ein Ende machen;(sich) wegschmeißen (derb);(sich) (selbst) töten;Suizid begehen;Hand an sich legen;(den) Freitod wählen;(sich) entleiben (geh.);(sich) (selbst) umbringen;(sich) (selbst) richten;(die) (letzte) Konsequenz ziehen;seinem Leben ein Ende setzen;(sich) ein Leid antun (lit.) (geh.);(sich) etwas antun;(sich) vom Leben zum Tode befördern;(sich) den Tod geben (geh.);(sein) Leben wegwerfen;(sich) ein Leids antun (lit.) (geh., verhüllend)
-populistische Parolen;Populismus;Lufthoheit über die Stammtische (ironisch);(das) gesunde Volksempfinden (Jargon, ironisch)
-freiwillig;von selber;einfach so (ugs.);selbstbestimmt;aus sich heraus;aus freiem Entschluss;aus eigenem Antrieb;aus freien Stücken;ungezwungen;aus freiem Willen;ohne dass man erst darum bitten muss;unaufgefordert;von (ganz) allein;von sich aus;von selbst
-auf den eigenen Vorteil schielen(d);eigennützig;nur an sich (selbst) denken(d);berechnend;auf den eigenen Vorteil bedacht;(sich) unsolidarisch verhalten
-triebgesteuert;ohne Steuerungsmöglichkeit;zwangsgetrieben;nicht steuerbar;nicht willentlich beeinflussbar;zwanghaft;obsessiv;nicht der eigenen Kontrolle unterliegend
-Egozentriker;Egoist;Egomane;Ego-Shooter (ugs., fig.)
-Appeasement-Politik (fachspr.);Attentismus;auf Risikovermeidung bedacht
-mobiler Flugfunkdienst;beweglicher Flugfunkdienst;Flugfunk
-Optimierungspotenzial (geh.);Luft nach oben (ugs.);Verbesserungsmöglichkeit(en);Steigerungsmöglichkeit(en);Verbesserungspotenzial
-Unproportioniertheit;Unausgeglichenheit;Disproportionalität;Missverhältnis;Disproportion;Diskrepanz (geh.);Unverhältnismäßigkeit
-Scherung;Transvektion
-reine Scherung;koaxiale Scherung;reine Kompression
-einfache Scherung;nicht-koaxiale Scherung
-großer Rückenmuskel;Musculus latissimus dorsi (lat.)
-Musculus biceps brachii (lat.);Bizeps
-obrigkeitshörig;autoritätsgläubig
-Phantastik;Fantastik
-Kabelkonfektionierung;Kabelkonfektion
-XSD;XML Schema
-XML;Extensible Markup Language
-Regenradar;Niederschlagsradar
-Radar;Radargerät
-Technomathematik;Ingenieurmathematik;Technische Mathematik
-Nekrolog;posthume Würdigung (geh.);Nachruf;posthume Ehrung (geh.);Gedenkrede;Nachrede
-Verdi;ver.di;Vereinte Dienstleistungsgewerkschaft
-KSK (Abkürzung);Kommando Spezialkräfte
-Wochenauftakt;Wochenanfang;Wochenbeginn
-Preisniveaustabilität;Preisstabilität
-Lignivore (fachspr.);Holzfresser;Xylophage (fachspr.)
-Blattfresser;Phyllophage (fachspr.)
-Rhizophage (fachspr.);Wurzelfresser
-BMF;Bundesministerium der Finanzen;Bundesfinanzministerium
-Bundesministerium für Wirtschaft (veraltet);Bundeswirtschaftsministerium;BMWi (Abkürzung);Bundesministerium für Wirtschaft und Technologie
-(alte) Juffer (ugs., rheinisch);alte Jungfer (ugs.);spätes Mädchen (ugs.)
-Umlagern;Lagern;Drehen;Dekubitusprophylaxe;Betten
-Gewaltenteilung;Gewaltentrennung (schweiz., österr.)
-zivile Verteidigung;Zivilverteidigung
-logische Programmierung;prädikative Programmierung
-Dreiecksnetz;Dreiecksgitter
-südlicher Sternenhimmel;Südsternenhimmel;Südhimmel;Südsternhimmel;südlicher Sternhimmel
-Sternhimmel;Sternenhimmel
-Schwimmsand;Treibsand
-Rotblindheit;Protanopie (fachspr.)
-Neophobie (fachspr.);Kainolophobie (fachspr.);Cainophobie (fachspr.);Angst vor Neuem
-Angst vor Hunden;Hundephobie;Kynophobie (fachspr.);Canophobie (fachspr.)
-Trypanophobie (fachspr.);Spritzenangst (ugs.)
-Angst vor Katzen;Felinophobie (fachspr.);Gatophobie;Katzenphobie;Katzenangst;Galeophobie;Ailurophobie (fachspr.)
-soziale Phobie;soziale Angststörung
-Schutzkarton;Schuber
-Tilger (Kurzform);Schwingungstilger;Tilgerpendel
-Felis silvestris lybica (fachspr.);Falbkatze;Afrikanische Wildkatze
-Europäische Wildkatze;Waldkatze;Wildkatze (ugs.);Felis silvestris silvestris (fachspr.)
-Produktbeistellung (fachspr., verhüllend);Schleichwerbung (abwertend);Produktplatzierung (verhüllend);versteckte Werbung;Productplacement;Product-Placement (engl.)
-Gesichtsblindheit;Gesichtserkennungsschwäche;Prosopagnosie
-martialisch;grob auftretend;mit Kampfgetöse;wild
-Dilemmas (Plural);Dilemmata (Plural)
-an welchem Ort;wo
-gesetzliche Krankenkasse;GKV (Abkürzung);gesetzliche Krankenversicherung
-Mafiatorte (ugs., scherzhaft-ironisch);Pizza
-Straßenkind;Trebegänger
-schwarzer Sheriff (ugs., fig.);Sicherheitsfachkraft;Wachmann;SiFa;Mitarbeiter eines Security Service
-Sicherheitsdienstleister;Bewachungsunternehmen;Überwachungsunternehmen
-befohlen;vorgeschrieben;gefordert;angeordnet;verlangt
-Pathologie (fachspr., griechisch);Krankheitslehre;Nosologie (fachspr., griechisch)
-langes Wochenende;verlängertes Wochenende
-Proktologie;Coloproktologie;Koloproktologie
-Reifenwechsel (ugs.);Radwechsel
-(jemandem) was wollen (ugs., negativ);(es auf jemanden) abgesehen haben (ugs., negativ);(jemandem) eins reinwürgen wollen (ugs., salopp);ein kritisches Auge haben (auf);(jemanden) auf dem Kieker haben (ugs., negativ);(jemandem) etwas wollen
-zur Meisterklasse zählen;zum besten gehören, was ... zu bieten hat (Journalistensprache);ganz oben mitspielen;in der Oberliga mitspielen
-gleichteilend;aliquot
-Lauteinschaltung;Epenthese;Lauteinschub
-eng beieinander;drangvolle Enge (geh., variabel);zusammengedrängt;dicht an dicht;Stoßstange an Stoßstange (Straßenverkehr);zusammengezwängt;(eng) aneinandergedrängt;eng zusammen;zusammengequetscht;auf Tuchfühlung;zusammengepfercht;(dicht) gedrängt;eng beisammen;wie (die) Sardinen in der Büchse (fig., variabel);Schulter an Schulter (auch figurativ);beengt
-medienhistorisch;mediengeschichtlich
-Saalfelder Bund;Wahlgegnerbund
-Friedensschluss von Kaaden;Kaadener Vertrag;Vertrag von Kaaden
-Öffentlich-Private Partnerschaft;Public Private Partnership
-(Krankheit) ohne bekannte Ursache;idiopathisch (fachspr.)
-manisch-depressive Erkrankung (veraltet);bipolare affektive Störung (fachspr., medizinisch)
-Wattestäbchen;Ohrenstäbchen (ugs.);Q-Tip (Markenname)
-Realsozialismus;realer Sozialismus;real existierender Sozialismus
-eulersche Relation;eulersche Formel;Eulerformel
-gaußsche Zahlenebene;Gaußebene;Arganddiagramm
-(sich) bewerben;(sich) andienen (geh.);antreten;aspirieren (österr.);(sich) zur Wahl stellen;(mit jemandem) konkurrieren;(seinen) Hut in den Ring werfen (fig.);kandidieren;(sich) aufstellen lassen;aufgestellt werden;(sich) anbieten
-Implikation (fachspr.);Wenn-dann-Aussage;Konditional (fachspr.);Subjunktion (fachspr.);materiale Implikation (fachspr.)
-Ergebenheitsbekundung;Bückling;Kotau;Kratzfuß;Unterwerfungsgeste (Hauptform);Selbsterniedrigung;Beugemann;Unterwerfung;Kniefall;Proskynese (geh., historisch, veraltet)
-Oghusisch;Südwesttürkisch;oghusische Sprache
-sturmreif;wehrlos ausgeliefert;sturmreif geschossen
-vorab;zuerst;als Erstes;vorangestellt;vorneweg
-(ein) No-Go (sein) (Jargon, engl.);(eine) absolute Schranke (darstellen);Ausschließungsgrund;tabu (sein);verbotenes Terrain (fig.);Ausschlusskriterium
-oh je! (ugs.);au weia! (ugs.);ach du lieber Gott! (ugs.);ach du grüne Neune! (ugs.);oh weia! (ugs.);oh weiowei! (ugs.);auwei! (ugs.);ach Gottchen! (ugs., ironisierend);ach herrje! (ugs.);oh jemine! (ugs., veraltet)
-Fraktalität;Selbstähnlichkeit
-Ozelle;Augenfleck;Ocelle
-Gegenstelle;Kommunikationspartner
-Belagerungsstand;Belagerungszustand
-jemandem ein Eheversprechen geben;(sich) verloben
-Ansammlung von ... (z.B. Wasser);Pfütze;Lache;Pütz (kölsch)
-Nächtigung (österr.);Übernachtung
-Depotstimmrecht;Vollmachtstimmrecht
-Aktienregister;Aktienbuch (veraltet)
-Ultraschallschwingläppen;Ultraschallbohren (veraltet)
-Kommunikationstechnik;Kommunikationstechnologie
-Baiser;Schaumgebäck
-forensische Abteilung;Forensik
-Kapuziner (österr.);Latte macchiato;Latte (fem.) (ugs., Jargon);Kaffee mit aufgeschäumter Milch;Cappuccino;Milchkaffee
-Milizsoldat;Milizionär
-Riemannsche Vermutung;Riemannsche Hypothese
-perfekte Zahl;vollkommene Zahl
-Radeffekt;Schraubeneffekt
-Buckauer Schraube;Wolfsche Schiffsschraube
-Luftschraube;Propeller
-Propeller;Schiffsschraube
-Lochfraßkorrosion;Lochfraß;Lochkorrosion
-splentern (ugs., norddeutsch);verplempern (ugs.);Flüssigkeit vergießen;plempern (ugs.);verschütten
-Kappadozien;Kappadokien
-Mornell;Charadrius morinellus (fachspr., lat.);Dummer Regenpfeifer (veraltet);Mornellregenpfeifer
-Baumfalke;Falco subbuteo (fachspr., lat.);Lerchenfalke
-Bachstelze;Motacilla alba (fachspr., lat.)
-Fringilla montifringilla (fachspr., lat.);Nordfink;Bergfink
-Spielhahn;Schildhahn;Birkhuhn;Tetrao tetrix (fachspr., lat.);Lyrurus tetrix (fachspr., lat.)
-Buchfink;Fringilla coelebs (fachspr., lat.)
-Corvus monedula (fachspr., lat.);Dohle
-Eisvogel;Alcedo atthis (fachspr., lat.)
-Pica pica (fachspr., lat.);Elster
-Feldlerche;Alauda arvensis (fachspr., lat.)
-Pirol;Oriolus oriolus (fachspr.)
-Habicht;Accipiter gentilis (fachspr., lat.)
-Carduelis cannabina (fachspr., lat.);Bluthänfling;Hänfling (ugs.);Flachsfink
-Haubenlerche;Galerida cristata (fachspr., lat.)
-Misteldrossel;Turdus viscivorus (fachspr.)
-Rauchschwalbe (Hauptform);Hausschwalbe;Gabelschwalbe;Hirundo rustica (fachspr., lat.)
-Lusciola rubecula (fachspr., lat.);Rotkehlchen
-Kleiber;Spechtmeise;Sitta europaea (fachspr., lat.)
-Parus major (fachspr., lat.);Kohlmeise
-Bombycilla garrulus (fachspr., lat.);Seidenschwanz (fachspr.)
-Turdus philomelos (fachspr., lat.);Singdrossel
-Sperber (Hauptform);Accipiter nisus (fachspr.)
-Dryocopus martius (fachspr., lat.);Schwarzspecht
-Sylvia atricapilla (fachspr., lat.);Plattmönch;Mönchsgrasmücke (fachspr.)
-Dorngrasmücke;Sylvia communis (fachspr., lat.)
-Klappergrasmücke;Sylvia curruca (fachspr.);Zaungrasmücke
-Urkundensteuer;Stempeltaxe;Stempelsteuer;Stempelgebühr
-Verkehrsteuer;Verkehrssteuer
-Kostenmarke;Gerichtskostenmarke;Justizkostenmarke
-zurücklassen;aufgeben
-Trinakria (veraltet);Sizilien
-Schmiedefeuer;Esse;Schmiedeesse;Schmiedeofen;Feldesse (fachspr.)
-Zilpzalp;Weidenlaubsänger
-Glandula parotidea (fachspr.);Parotis (fachspr.);Ohrspeicheldrüse
-monoton steigend;monoton wachsend;isoton
-monoton fallend;antiton
-Sexualdimorphismus;sekundäres Geschlechtsmerkmal;Geschlechtsdimorphismus
-Infantilismus (fachspr., medizinisch);Kindischsein (ugs.);Kinderei;Puerilismus (fachspr.);kindisches Verhalten (ugs.);kindisches Wesen (geh.)
-Schlaganfalleinheit;Stroke Unit
-Nappaleder;Nubuk;Nubukleder
-Tierhaut;Leder
-Kleidermode;Mode
-schlicht;unscheinbar
-Kirchenvorstand;Gemeindeleitung;Presbyterium;Kirchengemeinderat
-Berberaffe;Magot
-Mansarddach;Mansardendach (österr.)
-Stabilisierungsschwungrad;Trägheitsrad;Drallrad
-Lungenarterienembolie;Lungenembolie;Pulmonalarterienthrombembolie;Lungenthrombembolie
-kastilisch;spanisch
-Kassenprüfer;Revisor (schweiz.)
-Keilzinkung;Keilzinkenverbindung
-Gottesurteil;Ordal;Gottesgericht
-gerichtlicher Zweikampf;Gerichtskampf
-Posteninhaber;Stelleninhaber;Funktionsinhaber
-Maskenspiel;Mummenschanz (auch figurativ);Maskerade (auch figurativ)
-Rennfahrer;Pilot (ugs.)
-Kapuzenpulli;Kapuzenpullover;Schlumpf (ugs.);Hoodie (ugs., engl.)
-Wissen;Episteme (fachspr.);Wissenschaft
-Stehwellenrelation;Welligkeitsfaktor;Welligkeit;Stehwellenverhältnis
-Obatzter;Obatzda;Obazda
-asturianische Sprache;Asturianisch;asturische Sprache;Asturisch
-schippern (ugs.);Schiff fahren
-anforderungsgerecht;wunschgemäß;bedarfsgerecht
-Titer;Garnfeinheit;Garnstärke
-Planetoid;Kleinplanet;Kleinkörper (fachspr.);Asteroid
-Tabellenpunkt;Konstruktionspunkt;K-Punkt;Kalkulationspunkt
-Lackierer;Lacker (ugs.)
-arterielle Aussackung (ugs.);Aneurysma;Arterienerweiterung
-entweder ... oder ...;entweder;aut ... aut ... (geh., lat.);sei es ..., sei es ...
-Trisalpetersäureglycerinester;Glycerintrinitrat;Glyceroltrinitrat;Nitroglycerin
-Hohlmaß;Raummaß
-Gemeiner Spargel;Garten-Spargel;Gemüsespargel;weißes Gold (ugs.);Asparagus officinalis (fachspr., lat.);Spargel
-Deckel;Klappe;Verschluss
-Opferforschung;Viktimologie
-operiert werden;unters Messer kommen (ugs.)
-unters (ugs.);unter das
-unter den;untern (ugs.)
-beargwöhnen;argwöhnen;misstrauen;präsumieren (geh.);verdächtigen;zweifeln
-Bankrott machen;bankrottgehen (ugs.);bankrottieren
-buntfärben;bunt färben
-Höhenenergie;Lageenergie;potentielle Energie
-Haut;Dermis (fachspr.);Kutis (fachspr.)
-Griffel (ugs.);Handglied;Finger
-Gammastrahlenausbruch;Gammastrahlenexplosion;Gammastrahlenblitz;Gammablitz
-Lexikographie;Lexikografie
-verwirren;ablenken;verunsichern;stören;verblüffen;irritieren;aus der Fassung bringen (ugs.);konsternieren;bestürzen
-Travellerscheck;Reisescheck
-Rohrspatz;Rohrammer
-Autograph;Autograf;eigenhändige Niederschrift
-Falknerei;Beizjagd
-Reinigungsarbeiten;Reinigung;Säuberung
-(chemische) Reinigung (Dienstleistungsbetrieb);Putzerei (österr.)
-Pampelmuse (ugs.);Paradiesapfel (selten);Grapefrucht;Grapefruit
-übervorteilt werden;abgezogen werden (ugs., jugendsprachlich);übers Ohr gehauen werden (ugs.);ausgenommen werden;betrogen werden;gerupft werden (ugs.);betuppt werden (ugs., ruhrdt.);über den Löffel balbiert werden (veraltet)
-Gottorper Vergleich;Gottorper Vertrag
-Altaisprache;altaische Sprache
-Proteststurm;(öffentlicher) Aufschrei;Empörungswelle;wütende(r) Protest(e);Shitstorm (engl.);wüste Beschimpfungen;Welle der Empörung;Empörungswoge (geh.)
-kommunizierende Gefäße (fachspr.);kommunizierende Röhren (fachspr.);verbundene Gefäße (fachspr.)
-Zwangsräumung;Delogierung (österr.);Exmission (schweiz.)
-Geschiebemergel;Till
-so gesehen;(mal) unter diesem Aspekt betrachtet;aus dieser Perspektive betrachtet;bei dieser Betrachtungsweise;aus dieser Perspektive;unter diesem Blickwinkel gesehen;von dieser Warte aus gesehen;von diesem Standpunkt aus (gesehen);aus dieser Optik (schweiz.);unter diesem Gesichtspunkt;in dieser Sichtweise;unter dieser Betrachtungsweise;so betrachtet;aus dieser Sicht;wenn man dies berücksichtigt;aus diesem Blickwinkel
-Verliebtheit (Hauptform);(starkes) Angezogen-Sein (geh.);Liebeswahn;Liebestollheit;Schmetterlinge im Bauch (ugs.);Liebestaumel
-übers;über das
-Carrosserie (schweiz.);Kfz-Werkstätte;Kfz-Werkstatt;Autowerkstatt
-Hydrofon (griechisch);Unterwassermikrofon;Unterwassermikrophon;Hydrophon (griechisch)
-Edison-Effekt;Richardson-Effekt;Edison-Richardson-Effekt;Glühemission;glühelektrischer Effekt
-intellektuell;intellektuell brillant (geh.);von intellektueller Brillanz (geh.);schwere Kost (fig.);geistig anspruchsvoll;von hohem geistigem Niveau;verstandesbetont;von hohem geistigen Anspruch;hochgeistig;von höchstem geistigen Niveau
-höchste Vollendung (Hauptform);Nonplusultra;Vollendung;Meisterschaft;Feinschliff (fig.);i-Tüpfelchen (fig.);Höhepunkt;(das) letzte bisschen, was noch gefehlt hat(te);höchste Stufe;Sahnehäubchen (obendrauf) (ugs., fig.);Tüpfelchen auf dem i (ugs.);letzter Schliff (ugs.);(die) Kirsche auf der Torte (fig.);Finish (fachspr.)
-Dermapteron (fachspr.);Ohrenkneifer (ugs.);Ohrwurm
-der Wahrheit nicht ins Gesicht sehen können;der Wahrheit nicht ins Auge sehen können;(sich etwas) in die (eigene) Tasche lügen (ugs.);nicht wahrhaben wollen;(sich) selbst etwas vormachen;die Wahrheit nicht ertragen können (Hauptform);(sich) selbst belügen;(sich) selbst etwas zusammenphantasieren;(sich) Illusionen machen;(sich) selbst täuschen;(die) Augen verschließen vor
-ohne Bodenhaftung;verzerrte Wirklichkeitswahrnehmung;(unter) Realitätsverlust (leiden);(sich) Illusionen hingeben;keine Bodenhaftung (haben);in anderen Sphären schweben;in seiner eigenen Welt (leben) (fig.);Illusionen nachhängen;ohne (jeden) Realitätsbezug;in einer Traumwelt leben
-gezielt nicht beachten;absichtlich übersehen;keine Notiz nehmen (von);mit Verachtung strafen;(jemanden) schneiden;(jemanden) wie Luft behandeln;(jemandem) keinen Blick gönnen;(für jemanden) Luft sein (fig.);(jemanden) ignorieren (Hauptform);keine Beachtung schenken;keines Blickes würdigen (geh.);mit dem Arsch nicht angucken (derb);so tun als ob jemand Luft wäre;(jemanden) aggressiv nicht beachten;(jemanden) nicht (mehr) grüßen;(jemanden) missachten;(auf einmal) nicht mehr kennen
-(sich) identifizieren;(sich) ausweisen;seine Papiere vorzeigen
-seelische Grausamkeit;psychische Gewalt;seelische Gewalt;psychische Folter;emotionaler Missbrauch
-mangelnde Zuwendung;mangelnde Fürsorge;Vernachlässigung
-emotionale Bestrafung;Liebesentzug;Verstoßung
-(jemanden) beim Arsch kriegen (derb);(jemanden) strafrechtlich verfolgen;(jemanden) beim Wickel packen (ugs., variabel);(sich) (jemanden) schnappen (ugs.);(jemanden) drankriegen (ugs.);(jemanden) zur Verantwortung ziehen
-(noch) eine Rechnung offen haben (mit) (ugs.);(noch) etwas gut haben (bei jemandem) (ugs.);(noch) ein Hühnchen zu rupfen haben (mit) (ugs.);(noch) etwas zu klären haben (mit) (ugs.);(jemandem) (noch) etwas schuldig sein;(noch) (eine) Forderung haben (gegenüber)
-Rezeptionist;Mitarbeiter an der Rezeption;Empfangschef;Mitarbeiter am Empfang
-das Leben geschenkt bekommen;ankommen (ugs.);zur Welt kommen;das Licht der Welt erblicken;auf die Welt kommen;Akt des Geborenwerdens;geboren werden
-Legföhre;Krummholzkiefer;Latsche;Legkiefer;Krüppelkiefer;Pinus mugo subsp. mugo (fachspr., botanisch);Latschenkiefer
-Birke (ugs.);Warzenbirke;Weißbirke;Hänge-Birke;Sandbirke;Betula pendula (fachspr.)
-gewöhnliche Eibe;Taxus baccata (fachspr.);Gemeine Eibe (fachspr.);Europäische Eibe (fachspr.);normale Eibe (ugs.);Eibe
-Sauerdorn;Berberitze;Essigbeere;Echte Berberitze (fachspr.);Gewöhnliche Berberitze (fachspr.);Berberis vulgaris (fachspr., lat.)
-abbrechen;abfallen;(sich) abtrennen;abplatzen;abspringen;(sich) losreißen;losbrechen;(sich) abreißen;(sich) ablösen;(sich) lösen;abreißen;absplittern;abbröckeln;abblättern;abgehen
-(sich) einklemmen;(sich) verklemmen;blockieren;(sich) verkanten
-Kaiserwetter;strahlender Sonnenschein
-chinesisches Schattenboxen;Taijiquan (chinesisch);Tai-Chi (chinesisch);Tai-Chi Chuan (chinesisch)
-Krankheit besiegen;Fieber besiegen (ugs.)
-in das;ins
-ans;an das
-durchs;durch das
-hinter das;hinters
-ums;um das
-vors (ugs.);vor das
-an dem;am
-im;in dem
-überm (ugs.);über dem
-vor dem (ugs.);vorm
-Hauswanze;Bettwanze
-Heteropteron (fachspr., griechisch);Wanze
-Legalinspektion (schweiz.);Leichenbeschau (österr.);Leichenschau;Totenbeschau (österr.)
-(sich) Vertraulichkeiten herausnehmen;zudringlich werden;nicht in Ruhe lassen;lästig sein;(jemandem) auf den Pelz rücken (ugs.);(sich) aufdrängen;belästigen;lästig werden;lästig fallen;bedrängen
-Weißbuche;Carpinus betulus (fachspr.);Hainbuche;Hagebuche
-Fenster putzen;Scheiben reinigen
-kleine Welt;Mikrokosmos
-zurechtflicken (ugs.);zusammenkloppen (ugs.);zusammenstücken (ugs.);zusammenzimmern (ugs.);zurechtfummeln (ugs.);zusammenfummeln (ugs.);zusammenhauen (ugs.);zusammenstümpern (ugs.);zurechtfrickeln (ugs., regional);zusammenstoppeln (ugs.);zusammenflicken (ugs.);flickschustern (ugs.);zusammenpfuschen (ugs.);zurechtstoppeln (ugs.);zusammenschustern (ugs.);zusammenfrickeln (ugs., regional);zusammenstückeln (ugs.);zusammenfriemeln (ugs., regional)
-sonst noch Wünsche? (ugs., ironisch);wo denkst du hin!? (ugs.);Das wüsste ich aber! (ugs.);wer's glaubt wird selig (ugs., Spruch, ironisch);wo kämen wir denn da hin! (ugs., Spruch);aber hallo! (ugs.);da können Sie aber lange drauf warten! (ugs.);da kann ja jeder kommen! (ugs., Spruch);Da kannst du aber (lange) drauf warten! (ugs.);alles klar (lakonisch abwehrend) (ugs.);als ob! (ugs., jugendsprachlich);ja nee, is klar (ugs.);So siehst du aus! (ugs., Spruch);sonst noch was? (ugs., ironisch);Das hättest du wohl gerne! (ugs.);das könnte dir so passen! (ugs.);wo werd' ich denn! (ugs.);So weit kommt's noch! (ugs.);Träum weiter! (ugs.);da könnte ja jeder kommen! (ugs., Spruch);Spinn dich aus! (ugs.);(aber) nicht mir mir! (ugs.);Das wäre (ja) noch schöner! (ugs.);Aber sonst geht's dir gut (oder)!? (ugs., ironisch);wie käme ich denn dazu!;das werd(e) ich ganz bestimmt nicht (tun)! (Hauptform, variabel)
-Personenbahnhof;Reisezugbahnhof
-Husarenstück;Husarenritt;Coup (franz.);Husarenstreich
-Haupthimmelsrichtung;Himmelsrichtung;Kardinalpunkt
-Pyrrhischer Krieg;Tarentinischer Krieg;Pyrrhoskrieg
-Kanzlei;Sozietät;Partnerschaft;Rechtsbüro;Partnerschaftsgesellschaft
-Ostjordanland;Transjordanien;Kerak
-Pennäler (ugs.);Gymnasiast;Schüler eines Gymnasiums;Oberschüler (ugs., veraltend)
-(jemandem etwas) insinuieren (geh., bildungssprachlich);(jemandem etwas) einflüstern (ugs.);(jemandem etwas) zutragen (geh.)
-Aufwärtsregler;Hochsetzsteller;Aufwärtswandler
-DC-DC-Wandler;Gleichstromsteller;Gleichspannungswandler
-Primarschüler (schweiz.);Schüler der Primarstufe;Grundschüler
-Sonderschüler;Schüler mit besonderem Förderbedarf;Förderschüler;Hilfsschüler (veraltet);Schüler (auf) einer Förderschule
-Adipsie (fachspr.);fehlendes Durstgefühl
-Exsikkose (fachspr.);Austrocknung des Körpers
-Hypohydratation;Austrocknung;Dehydratation;Dehydration;Dehydratisierung
-Affektstörung;affektive Störung
-Chatoyance;Katzenaugeneffekt;Katzenaugen-Effekt
-Glykolipide;Glycolipoide;Glycolipide
-Nyquist-Frequenz;Nyquist-Grenze
-Wärmerauschen;Johnson-Rauschen;thermisches Rauschen;Nyquist-Rauschen;Johnson-Nyquist-Rauschen;Widerstandsrauschen
-Dekonstruktion;Dekonstruktivismus
-(sich) nicht (gerade) mit Ruhm bekleckern;(weit) hinter den Erwartungen zurückbleiben;eine schwache Leistung abliefern;keine gute Figur machen
-kein Ruhmesblatt (für jemanden) sein;Hohn und Spott über sich ergehen lassen müssen;(sein) Gesicht verlieren;(sich) zum Hanswurst machen (ugs.);mit Hohn und Spott überschüttet werden;(sich) nicht (gerade) mit Ruhm bekleckern;ausgelacht werden;(sich) zum Gespött machen;(sich) bis auf die Knochen blamieren;(Hohn und) Spott ernten;(sich) lächerlich machen;(sich) nirgendwo mehr sehen lassen können;(sich) blamieren;zum Gespött werden;(sich) zum Hampelmann machen (ugs.)
-unter 'ferner liefen' rangieren;keine Schnitte haben (ugs.);mit etwas keinen Blumentopf gewinnen können (ugs.);chancenlos sein;keine Chancen haben;keine Chance haben;mit etwas (gleich) zu Hause bleiben können (ugs.);(sich) keine Chance ausrechnen können;ohne (jede) Chance sein;keinen Stich kriegen (mit etwas) (ugs.);kein (ernst zu nehmender) Gegner sein;ohne jede Chance dastehen
-eine Renaissance erleben (fig.);ein Comeback feiern;wiederbelebt werden;wieder aufkommen;fröhliche Urständ feiern;wieder aufleben;wiederauferstehen;fröhliche Auferstehung feiern;wiederauferstehen von den Toten (iron. Bibelzitat);wieder modern werden
-homophon;gleichklingend;gleichlautend;homofon;gleich ausgesprochen
-zu Kreuze kriechen (fig.);(sich) einer Sache ergeben;die Kröte schlucken (fig.);die bittere Pille schlucken (müssen) (fig.);jemandem willfährig sein;(sich) unterwerfen
-mit allem abgeschlossen haben;mit allem fertig sein;sein Testament gemacht haben (ugs.)
-(sich) die Butter vom Brot nehmen lassen (ugs., fig.);(sich) ins Bockshorn jagen lassen;(sich) den Schneid abkaufen lassen (ugs.);(sich) entmutigen lassen;(sich) unterkriegen lassen (ugs.);(sich) einschüchtern lassen;den Kopf hängen lassen (ugs., fig.)
-Sozialliberalismus;Linksliberalismus
-Konzentrationsregierung;Allparteienregierung
-Entschuldung;Schuldenschnitt;Forderungsverzicht;Schuldenerlass;Haircut (engl., fig.)
-in der Luft liegen;unmittelbar bevorstehen;im Schwange sein
-Trägheitsnavigationssystem;inertiales Navigationssystem
-putativ (fachspr.);vermeintlich
-Improvisation;Momentschöpfung (geh.);spontane Erfindung;freie Momentgestaltung (geh.)
-Penicillin;Penizillin
-Antikonvulsivum;Antiepileptikum
-Schlafsack;Penntüte (derb)
-Grüßaugust (fig.);Frühstücksdirektor (fig.);Grüßonkel (fig.);Versorgungsfall (in der Leitungsebene)
-im Ernst?;das kann nicht Ihr Ernst gewesen sein! (ugs.);(wohl) (ein) schlechter Witz (ugs.);das soll wohl ein Witz sein! (ugs.);sag das nochmal! (herausfordernd) (ugs.);(sag mal,) spinnst du? (ugs.);was erzählst du da!? (ungläubig) (ugs.);bist du krank im Kopf? (derb);das ist nicht dein Ernst! (ugs.);bist du noch ganz sauber? (ugs., salopp);ist das dein Ernst?;tickst du noch richtig? (derb, variabel);ich halte das für einen schlechten Scherz;wie jetzt!? (ugs.);meinen Sie das ernst?;das ist jetzt ein Witz (nicht wahr?) (ugs.);nee, oder? (ugs., süddt.);ist das Ihr Ernst?;(das ist) hoffentlich nicht ernst gemeint;echt jetzt? (ugs.);(ich glaube,) ich hab mich (da) wohl verhört! (ugs.);(das ist doch) der Witz in Tüten! (empört) (ugs.);bist du noch ganz bei Trost? (ugs.);machst du Witze? (ugs.);komm mal klar! (ugs., jugendsprachlich);hast du sie noch alle? (derb);willst du mich auf den Arm nehmen? (ugs., fig.);nee, nä? (ugs., norddeutsch);du hast sie wohl nicht (mehr) alle! (derb);bist du noch (ganz) zu retten? (ugs.);in echt oder aus Scheiß? (derb);wollen Sie mich verarschen? (derb);das sollte (doch) wohl ein Scherz (gewesen) sein! (ugs.);wie war das (eben)? (drohend) (ugs.);soll das ein Witz sein? (ugs., ironisch);meinst du das etwa ernst? (ugs.);wie bitte?? (ugs.);können Sie das bitte noch einmal wiederholen?;das meinst du (doch) nicht ernst!? (ugs.);was war das eben? (drohend) (ugs.);Das ist (jetzt) ein Scherz! (ugs.)
-zu Püree machen;pürieren
-bewegt;sichtlich bewegt (Nachrichtensprache);gerührt;angerührt;überwältigt;ergriffen;erschüttert
-Nachtgebet;Komplet
-Ruffall;Vokativ (fachspr., Hauptform);Anredefall
-Ablativ;Woher-Fall (ugs.);Trennungsfall
-Deutsche Schabe;Schwabenkäfer
-Gottesanbeterin;Fangschrecke
-auf alle Fälle (ugs.);wie es auch sei;jedenfalls (resümierend);na schön (ugs.);wie dem auch sei;nun;wie auch immer (ugs.);nun denn;nun ja (ugs.);schön und gut (aber) ... (ugs.);also gut (ugs.);alles gut und schön (aber) ... (ugs.);na egal (jedenfalls) (ugs., salopp);na ja (ugs.);nun gut (ugs.);je nun (ugs., veraltet);sei's drum (ugs.);wie gesagt: ...;sei es wie es sei (geh.);aber na ja (ugs.)
-wegen mir;mit Rücksicht auf mich;wegen meiner;mir zuliebe;um meinetwillen
-Rock'n'Roller;Halbstarker;Ted (meist Plural: Teds);Teddy Boy
-mit Überschall;supersonisch (fachspr.)
-sonst wie;auf anderem Wege;anderweitig
-anderweitig;sonstig;anderer;weiterer
-anderweitig;anders;mit anderem (geh.);mit anderen Dingen;in anderen Angelegenheiten
-Elektriker;Strippenzieher (ugs., salopp);Elektroinstallateur
-Seniorenbetreuer (männl.);Altenpfleger (männl.);Pflegefachfrau (fachspr., weibl.);Pflegefachmann (fachspr., männl.);Pflegefachkraft (fachspr.)
-Metallbauer;Maschinenschlosser
-Dreiseitenriss;Normalprojektion;Dreitafelprojektion;Dreiseitenansicht;Kreuzriss (österr.)
-weitsichtig;hypermetropisch (fachspr., griechisch)
-blind;erblindet;ohne Augenlicht;nicht sehend
-Laserentfernungsmessung;optische Abstandsmessung
-Librations-Punkt;Lagrange-Punkt
-Regionalleiter;Gebietsleiter;Bezirksleiter
-Helfertätigkeit;Aushilfsjob (ugs.)
-Instrumental;Instrumentalis;Womit-Fall (ugs.)
-(jemandem) in den Schoß fallen (fig.);Die dümmsten Bauern haben die dicksten Kartoffeln. (ugs., Sprichwort, variabel);unverdientes Glück (haben);unglaubliches Glück (gehabt) haben;zu etwas kommen wie die Jungfrau zum Kind;(sich) vor Glück bescheißen (derb, fig.);mehr Glück als Verstand (haben)
-Content Management System (engl.);Content-Management-System (engl.);Inhaltsverwaltungssystem;CMS (Abkürzung, engl.)
-Einwohner Spaniens;Spanier
-Opernhaus;Oper;Opernbühne
-Fingerspitze;Fingerbeere (fachspr.);Fingerkuppe
-senil werden;vergreisen
-Perpetuierung (geh.);ständiges Aufwärmen (ugs.);Weitertragen;Fortschreibung;Erhaltung;Verstetigung (geh.);Fortführung;weitere Prolongierung;Chronifizierung (medizinisch)
-Kodeknacker;Kryptoanalytiker;Kryptanalyst;Codeknacker;Codebrecher;Entzifferer;Kryptanalytiker;Kodebrecher
-Denkmalkataster;Denkmalverzeichnis;Denkmalbuch;Denkmalliste
-Denkmaltopographie;Kunsttopographie (österr.)
-Retrodigitalisierung;retrospektive Digitalisierung
-(jemandem) den Fehdehandschuh hinwerfen (ugs.);(jemanden) herausfordern
-Schlagschach;Fressschach;Räuberschach
-heterodoxes Schach;Feenschach;Märchenschach
-Super-Schach;Janusschach
-Bernoulli-Zahl;bernoullische Zahl
-Eulersche Summenformel;Euler-Maclaurin-Formel
-Sankt-Petersburg-Paradoxon;Sankt-Petersburg-Lotterie
-spätabends;am späten Abend;zu später Stunde;zu vorgerückter Stunde;spät am Abend;(sehr) spät;mitten in der Nacht (ugs., übertreibend)
-(sich) beherrschen;(seine) Zunge hüten (geh., literarisch, veraltend);(sich) nicht gehen lassen;(sich) zusammenreißen;(sich) im Zaum halten;nicht ausklinken (ugs.);den Ball flach halten (ugs., fig.);(sich) zusammennehmen;(sich) unter Kontrolle haben;seinen Emotionen (Temperamenten o.ä.) nicht freien Lauf lassen;nicht ausrasten (ugs.);(sich) zügeln;an sich halten;(sich) im Griff haben;nicht die Selbstbeherrschung verlieren;(dreimal) tief schlucken (ugs.);den Ball flachhalten (ugs., fig.);(sich) mäßigen
-stimmig sein;überzeugen;stichhaltig sein;Hand und Fuß haben (fig.)
-Addition;Plus-Rechnen (ugs.);(das) Zusammenzählen;(das) Addieren
-eine Richtung geben;steuern;in Bahnen lenken;kanalisieren
-Schlüsselfigur;Schlüsselakteur (geh.);(bei jemandem) laufen die Fäden zusammen (ugs., fig., variabel)
-dem Merkantilismus entsprechend;merkantilistisch
-Pfennigbaum;Crassula ovata (fachspr., lat.);Geldbaum
-blind geboren;von Geburt an blind
-Pfeiltaste;Cursortaste
-abbekommen (ugs.);beziehen;(jemandem) zuteil werden (geh.);(jemanden) ereilen (geh., literarisch);bedacht werden (mit) (geh.);kriegen (ugs.);(jemandem) zugehen (geh.);erlangen (geh.);erhalten;bekommen
-empfangen;entgegennehmen (geh.);annehmen;in Empfang nehmen
-erringen;einfahren (journal.) (fig.);es bringen zu;schaffen;zu etwas kommen;an etwas gelangen;erzielen;erreichen (Hauptform);erlangen;gewinnen
-(jemandem) zuteil werden (geh.);in (jemandes) Besitz kommen;(jemandem) zufallen (geh.);in (jemandes) Besitz gelangen
-Drehsymmetrie;Radiärsymmetrie
-Masterarbeit;Masterthesis;Master-Thesis
-Spionageabwehr;Abschirmdienst
-Invarianz;Unveränderlichkeit (fachspr.)
-Vermutung;Präsumtion (fachspr.);Voraussetzung;Hypothese (geh.);Annahme;Präsumption (fachspr.)
-(etwas) knipsen (ugs.);auf Zelluloid bannen (veraltend);(etwas) aufnehmen;ablichten;(etwas) festhalten;(ein) Bild einfangen;(etwas) fotografieren (Hauptform);in den Kasten bekommen;(etwas) bildlich dokumentieren;abfotografieren;(eine Situation o.ä.) einfangen
-Schwingbruch;Schwingungsbruch;Dauerbruch (ugs.);Ermüdungsbruch (ugs.)
-sozial auffällig;mit auffälligem Sozialverhalten;verhaltensauffällig;verhaltensgestört (abwertend)
-Präventivschlagthese;Präventivkriegsthese;Präventivkriegslegende
-(da) kann man nichts sagen (ugs.);kann angehen (ugs.);(ist) auch schön! (ugs., ironisierend);hinreichend;ganz ordentlich (ugs.);(ganz) akzeptabel (ugs.);annehmbar;jetzt nicht (der absolute Hit o.ä.) (ugs.);keine Offenbarung (aber ...) (ugs.);geht in Ordnung (ugs.);schon okay (ugs.);ausreichend;leidlich gelungen (geh.);könnte schlimmer sein (ugs., ironisch);passt schon (ugs., süddt.);nicht übel (ugs.);(da) gibt's nichts zu meckern (ugs.);(ganz) anständig;kann sich sehen lassen (ugs.);schon in Ordnung (ugs.);(da) kann man nicht meckern (ugs.);nicht schlecht (ugs.);gut und schön (aber) (ugs.);brauchbar;schön und gut (aber) (ugs.);ganz gut (ugs.);reicht (aus);guter Durchschnitt
-Brand;Wundbrand (veraltend);Gangräne;Gangrän
-Netzwerksicherheit;Netzsicherheit
-negativer Überdruck (fachspr.);Unterdruck
-schwanzfixiert (derb);hormongetrieben;testosterongesteuert;schwanzgesteuert (derb);hormongesteuert;triebhaft (Hauptform);triebgesteuert
-altersunspezifisch;altersunabhängig
-Negligé;Babydoll;Nachtgewand (geh.);Negligee (alte Schreibung bis 2017);Négligé (schweiz.);Pölter (westfälisch);Nachthemd
-Schlafrock (veraltet);Bademantel;Frotteemantel;Morgenmantel
-Ballerbrühe (derb) (ugs.);Pennerglück (derb);Billigbier;Sterbehilfe (ugs., ironisch)
-Luxus...;Premium...;First-Class-...;Nobel...;High-End-... (engl., technisch);Edel...;Spitzen...;Fünf-Sterne-...;Vorzugs...;de-Luxe-...
-Spielplatz;Kinderspielplatz
-Erlöserorden;Birgittenorden;Orden des Allerheiligsten Erlösers
-Hitlerputsch;Bürgerbräu-Putsch;Hitler-Ludendorff-Putsch
-(sich) verbreiten;(sich) behaupten;(sich) breitmachen (negativ);(mittlerweile) allgemein akzeptiert sein;an Boden gewinnen;immer mehr Anhänger finden;(sich) durchsetzen;Akzeptanz gewinnen;Zulauf finden;(sich) ausbreiten
-rückwärtsgewandt;nostalgisch;vergangenheits-sehnsüchtig;vergangenheits-zugewandt;voller Nostalgie (für);hinterhertrauernd;vergangenheitsverliebt;retro
-Ramschware;Billigschrott (derb, stark abwertend);Niedrigpreis-Ware;Preiseinstiegsmodell (euphemistisch);Billigware;Billigprodukt;(Ware) vom Wühltisch;Ramsch;Sonderposten
-mitschwingen;mit angesprochen sein;assoziiert sein (mit);durchschimmern;anklingen;konnotiert sein;mitklingen;durchklingen
-spüren;(jemandem etwas) ansehen;heraushören;ahnen;intuitiv erfassen;erahnen;erspüren (geh.)
-ewiger Kalender;immerwährender Kalender
-Medien;publikative Gewalt;vierte Gewalt (fig.);vierte Macht
-Südliche Niederlande;Österreichische Niederlande
-Bienenhonig;Honig
-Gefriertrocknung;Sublimationstrocknung;Lyophilisation
-Sauerstofftoxikose;Sauerstoffvergiftung
-Adressatenkreis;Zielgruppe
-entmythologisieren;auf den Boden der Tatsachen zurückholen;objektivieren;entmystifizieren;entemotionalisieren;profanisieren;versachlichen
-auf Messers Schneide stehen;Spitz auf Knopf stehen;(der) Ausgang ist ungewiss;(das) Ende ist offen
-Einakter;Dramolett;Sketsch (alte Schreibung bis 2011);Kurzdrama;Minidrama;Sketch
-Schnupp (ugs., regional);Süßware;Süßigkeit;Süßkram (ugs.)
-Wagenschlag;Autotür;Seitentür;Schlag
-Weinbauzone;Weinanbaugebiet;Anbaugebiet (fachspr., bundesdeutsch, juristisch);Weinregion (ugs.);Rebbauzone (schweiz.);Weinbaugebiet (österr.);Weinbauregion
-Tonsillolith;Tonsillenstein;Mandelsteine
-Pleitier;verkrachte Existenz;einer, der es zu nichts gebracht hat
-Anisotropie;Richtungsabhängigkeit
-Karpatendeutscher;Mantake (veraltet)
-kontinuierliche Integration;permanente Integration;fortlaufende Integration
-bewohnbare Zone;Lebenszone;habitable Zone;Ökosphäre (veraltet)
-poesielos;ohne jeden Zauber;fantasielos;phantasielos;emotionsarm (geh.);leidenschaftslos;unromantisch
-ungemütlich;zweckbetont;schmucklos;nüchtern;kühl;unpersönlich;auf Zweckmäßigkeit getrimmt;klinisch;kahl;unwohnlich;steril;funktional;auf die Funktion reduziert
-Online-Kontaktnetzwerk;soziales Netzwerk;Gemeinschaftsportal
-nur mit dem Allernotwendigsten versehen;spartanisch;puritanisch;streng (reduziert, zurückgenommen o.ä.);Einfachst- (Wortzusatz);sparsam (ausgestattet);in reinster Funktionalität;anspruchslos;aufs (absolut) Wesentliche reduziert;puristisch;aufs Notwendigste reduziert;asketisch;nur mit dem Allernotwendigsten ausgestattet
-Passiva (fachspr.);Zahlungsrückstand (ggü. einem Gläubiger);noch zu bezahlende Rechnung;offener Posten (gegenüber e. Gläubiger);offene Rechnung (gegenüber einem Gläubiger);Verbindlichkeit;Zahlungsrückstände (ggü. Gläubigern);Rückstände (ggüb. Gläubigern);Schulden (gegenüber einem Kreditor);Rückstand (ggüb. Gläubiger)
-verbrieft;rechtsgültig niedergelegt;beurkundet;schriftlich zugesichert;amtlich (ugs.);beglaubigt;dokumentiert
-überhöhter Preis;gepfefferter Preis (ugs.);hoher Preis;saftiger Preis (ugs.);überzogener Preis;Wucherpreis;Apothekerpreis (ugs.);stolzer Preis (ugs.);Apothekenpreis (ugs.);Mondpreis (ugs.);gesalzener Preis (ugs.)
-Politeur (männl.);Polizeihostess (weibl.);Hilfspolizist (männl.);Politesse (weibl.)
-Personalpronomen;persönliches Fürwort
-Unterrichtsraum;Klassenzimmer;Klassenraum
-Klonus;klonischer Spasmus
-(sich) ungehörig verhalten;(bei jemandem) ins Fettnäpfchen treten;(bei jemandem) anecken;unangenehm auffallen
-anstoßen;(an etwas) anecken
-Perfektionismus;Streben nach Perfektion
-alles okay;alles bestens;alles in Ordnung;alles takko (ugs., salopp);Läuft. (ugs., Jargon);alles paletti (ugs.);alles im grünen Bereich (ugs.);(ich sehe) keine Probleme (ugs., variabel);alles roger (ugs.);alles gut;(es) könnte nicht besser sein;alles in (bester) Butter (ugs., sprichwörtlich)
-Rühren! (militärisch);Stehen Sie bequem! (militärisch);Rührt euch! (militärisch)
-Frost;grimmige Kälte;Eiseskälte;Väterchen Frost;Temperatur(en) unter 0° Celsius;bittere Kälte;Minustemperatur(en);klirrende Kälte;eisige Kälte;eisige Temperatur(en);arktische Kälte
-permissiv;nachgiebig
-Kammerverschluss;Zylinderverschluss
-Pufferstrecke;D-Weg;Durchrutschweg;Gefahrpunktabstand;Schutzweg;Schutzstrecke;zulässige Überfahrlänge
-stimmt so (ugs.);ist (schon) in Ordnung (so) (ugs.);schon gut (ugs.);ist okay (ugs.);der Rest ist für Sie (ugs.)
-frag mich nicht (ugs.);weiß der Schinder (ugs.);weiß der Teufel (ugs.);weiß der Geier (ugs.);wer weiß das schon (ugs.);was weiß ich denn! (ugs.);wer weiß (ugs.);weiß der Kuckuck (ugs., Hauptform);keine Ahnung (ugs., salopp);gute Frage! (ugs., ironisch);weiß der Henker (ugs.)
-Südkontinent;Antarktis (ugs., fälschlich);antarktischer Erdteil;antarktischer Kontinent;Antarktika
-Funktionsbausteinsprache;Funktionsplan
-erhobenen Hauptes (geh.);mit erhobenem Haupt;stolz (Hauptform);stolz wie Oskar (ugs.);mit stolzgeschwellter Brust
-Veilchen;Viola (dt. Plural Violen)
-Schi;Ski
-aktueller Stand;Ist-Aufnahme (fachspr.);Momentaufnahme;Erfassung des Ist-Zustands (fachspr.)
-Zweikammerparlament;Zweikammersystem;Bikameralismus
-Stabilität;Robustheit;Verlässlichkeit;Vertrauenswürdigkeit;Solidität
-(bei jemandem) vor der Tür stehen;(bei jemandem) auf der Matte stehen (ugs.);antanzen (ugs.);(bei jemandem) erscheinen
-Halbseitenblindheit;Hemianopsie;Hemianopie
-überschwänglich;unendlich;blind (fig.);aus tiefster Seele;rasend;abgöttisch
-Groupie;Fan
-ungezwungen;keck;schamlos (fig.);frech;locker vom Hocker (ugs.);ohne falsche Scham;kess;schmerzfrei (ugs., fig.);unbekümmert;ungeniert;locker-flockig;vorwitzig;zwanglos;vorlaut
-Draconiden;Giacobiniden
-fröhliche Weihnachten!;frohe Weihnachten!;frohes Fest!;frohe Feiertage!;frohe Festtage!
-nomineller Durchmesser;Nenndurchmesser
-(sich) in barer Münze auszahlen;(ein) goldenes Geschäft sein;lohnend sein;(ein) finanzieller Erfolg (sein);(etwas) herausspringen (für jemanden bei einer Sache) (ugs.);(sich) rentieren;jemandem etwas eintragen (geh.);(einen) finanziellen Erfolg darstellen;(sich) (in Euro und Cent) auszahlen;(sich) in klingender Münze auszahlen;Gewinn abwerfen;(sich) lohnen;ertragreich sein;(die) Kasse klingeln lassen (fig.);Ertrag abwerfen;finanzielle Vorteile bringen;(ein) einträgliches Geschäft sein;finanziell vorteilhaft sein;(sich) in Mark und Pfennig auszahlen (veraltet);(Gewinn) herausspringen (bei etwas für jemanden);(et)was herumkommen (bei) (ugs.);(ein) gutes Geschäft sein
-(sich) (echt / wirklich / voll) lohnen;(das) kann man (echt / wirklich) (jedem) empfehlen;unbedingt zu empfehlen sein;(echt) der Hammer sein (ugs.);sein Geld wert sein;(sich) bezahlt machen;(das) musst du (muss man) gesehen haben (ugs.);es (echt / voll) bringen (ugs.);(etwas) kommt gut (ugs.)
-du kannst dich (ruhig) neben mich setzen (ugs.);komm an meine grüne Seite (ugs.);setz dich (ruhig) zu mir (ugs.);(komm) setz dich neben mich (ugs.);komm, setz dich her (ugs.)
-Rothaut (veraltet);(nordamerikanischer) Indianer
-auf Verdacht (ugs.);als Versuchsballon;(einen) Versuchsballon starten (fig.);aufs Geratewohl (geh.);ins Blaue hinein;versuchsweise
-das ist (ja wohl) das Allerletzte! (ugs.);Unverschämtheit! (ugs.);(das ist) eine (bodenlose) Frechheit! (ugs.);das wäre ja noch schöner! (ugs.);Frechheit! (ugs.);da hört sich doch alles auf! (ugs.);wo gibt es denn so etwas! (ugs.);da bleibt einem (ja) die Spucke weg! (ugs., fig., sprichwörtlich);ich muss doch (sehr) bitten! (ugs.);wie reden Sie mit mir!? (ugs.);das ist (ja wohl) (die) unterste Schublade! (ugs., fig., sprichwörtlich)
-(jemanden) aufbringen gegen;(jemanden) wütend machen;(jemanden) zur Weißglut bringen (fig.);(jemanden) auf die Palme bringen (fig.);(jemanden) rasend machen;das Fass zum Überlaufen bringen (mit);(jemanden) in Harnisch bringen;einen Wutanfall (bei jemandem) auslösen;(jemanden) in Rage bringen
-durchdrehen (ugs., fig.);(jemanden) wahnsinnig machen (fig.);jemanden zur Verzweiflung bringen
-Komitatsboden;Adelsboden
-Das wäre (erst mal) geschafft. (ugs.);etwas (praktisch) (schon) in der Tasche haben (ugs.);(sich) einer Sache gewiss sein;(für jemanden) so gut wie gelaufen sein (ugs.);(so gut wie) erledigt sein;(etwas schon mal) im Sack haben (ugs.);(sich) etwas gesichert haben;(etwas) (so gut wie) erledigt haben
-generieren (geh.);(sich) aus den Fingern saugen (können);(sich) aus den Rippen schnitzen (ugs.);(sich) aus den Rippen schneiden (ugs.);aus dem Hut zaubern (ugs.);aus dem Nichts entstehen lassen;(sich) aus dem Kreuz leiern (ugs.)
-(etwas) aus dem Boden stampfen (ugs.);(etwas) schnell errichten;(etwas) aus dem Nichts erschaffen
-(ganz) nach jemandem kommen (ugs.);(jemandem) nacharten (geh.);Der Apfel fällt nicht weit vom Birnbaum. (ugs., ironisch);Der Apfel fällt nicht weit vom Stamm. (ugs., Sprichwort);(jemandem) nachgeraten (geh.);(nach jemandem) arten (geh.);ganz der Papa (ugs.);(etwas) von jemandem haben (ugs.);(nach jemandem) schlagen;viel von jemandem haben (ugs.);ganz die Mama (ugs.);Wie der Vater, so der Sohn. (ugs., Sprichwort);ganz der Vater (sein) (ugs.);(nach jemandem) geraten;(jemandem) nachschlagen (geh.);ganz die Mutter (sein) (ugs.);(jemandem) ähneln (in)
-Weihnachtsabend;Heiligabend;Heiliger Abend
-Pinguin (ugs., ironisch);Anzug- und Krawattenträger;Anzugträger
-(ja) ist das (denn) die Möglichkeit!;(ja) isses denn möglich! (ugs.);wie isses nu(n) bloß zu fassen! (ugs.);(ja) Herrschaftszeiten (noch einmal)!;nicht zu glauben!;das darf nicht wahr sein! (ugs.);nun hör sich das einer an!;nein, wie isses nun bloß möglich! (geh.);das muss man sich mal vorstellen! (ugs., Spruch)
-nicht jemandes Bier (ugs., fig.);kann (jemandem) egal sein;(jemanden) nichts angehen;nicht jemandes Baustelle (ugs., fig.);hat jemanden nicht zu interessieren (ugs.);kommt nicht darauf an
-Schwalllöten;Wellenlöten
-erstarrt;gelähmt;erschrocken;hilflos;entsetzt;(wie) betäubt
-Malus;Nachteil
-winterfest angezogen;warm eingemummelt;dick eingepackt
-Fahrbahndecke;Straßendecke;Fahrbahn (Hauptform);Pflaster;Asphalt
-Durchlass;Durchgang (Hauptform);Gang;Korridor;Gasse;Lücke;Passage
-Kornaten;Kornati-Inseln
-Kornati-Nationalpark;Nationalpark Kornaten
-künstlich aufblähen;hochkochen lassen (fig.);hochspielen;(künstlich) aufblasen;dramatisieren;aus einer Mücke einen Elefanten machen (ugs., fig.);hochpusten;(einer Sache) eine ihr nicht zukommende Wichtigkeit zuschreiben (geh., variabel);(künstlich) aufbauschen;hochjazzen (ugs.)
-(sich) (künstlich) aufregen;(sich) (in etwas) hineinsteigern;(sich) (gespielt) empören;(einen) Aufriss machen (ugs.);(die) Welle machen (ugs.)
-Trankopfer;Libation
-Webstuhl;Webmaschine
-Robotik;Robotertechnik
-Voreinstellung;Standardeinstellung;Defaulteinstellung
-Geburtstagsproblem;Geburtstagsparadoxon
-Hollandrad;Fiets;Hollandfahrrad
-Rauchnächte (regional);(Zeit) zwischen den Jahren (ugs., Hauptform);(die) Zwölften (regional);(Zeit) zwischen Weihnachten und Silvester;Glöckelnächte (regional);Rauhnächte (regional);(Zeit) zwischen den Feiertagen (ugs.);Altjahrswoche (schweiz.);zwölf Nächte (regional);Unternächte (regional);Raunächte (regional);Innernächte (regional)
-Überstaatlichkeit;Supranationalität
-gebietet der Anstand;geziemen;es gehört sich
-Seekartenbesteck;nautisches Besteck;Kartenbesteck
-Thermalkontrollsystem;Temperaturkontrollsystem
-Superregenerativempfänger;Pendelaudion
-Strahler (schweiz.);Kristallsucher
-atzen (fachspr., Jägersprache);Junge füttern
-Bürgergarde;Bürgerwehr
-Torsionssteifigkeit;Verwindungssteifigkeit
-mit aller Kraft;mit voller Kraft;mit ganzer Kraft
-Längenmessung;Abstandsmessung;Distanzmessung;Entfernungsmessung
-Linieinseln;Zentralpolynesische Sporaden;Linieninseln
-Hawaii-Emperor-Inselkette;Hawaii-Imperator-Rücken (veraltet)
-Midway-Atoll;Midwayinseln
-Artgenosse;Artverwandter
-Gerhard Stoltenberg (Eigenname);(der) kühle Klare aus dem Norden (ugs.)
-Zweihöckriges Kamel;Camelus ferus (zool.) (fachspr.);Kamel;Trampeltier;Wüstenschiff (ugs., fig.);Baktrisches Kamel (fachspr.)
-abgeschlossener Raum;Klause;enger Raum;Zelle
-langgezogener Raum;Schlauch (ugs.)
-höllisch;infernalisch
-Einwegpfand (amtssprachl.);Dosenpfand;Flaschendepot (schweiz.)
-Orchestrion;Jahrmarktsorgel;Kirmesorgel
-bezifferter Bass (fachspr.);Continuo (fachspr., Abkürzung);Basso continuo (fachspr.);Generalbass (fachspr.)
-moralische Verfassung;Seelenlage;Moral;Stimmung;Überzeugtheit von sich selbst;Stimmungslage
-hydrostatischer Druck;Gravitationsdruck;Schweredruck
-Weibchen;weibliches Tier
-Verkaufsgespräch;Verkaufspräsentation
-Schoßtier;Knuddeltier (ugs.);Kuscheltier (ugs.);Heimtier;(tierischer) Liebling (ugs.);Haustier
-Pomerellen (veraltet);Pommerellen
-Baltischer Landrücken;Nördlicher Landrücken
-Wasserhemisphäre;Wasserhalbkugel
-Hemisphäre;Halbkugel
-nördliche Hemisphäre;Nordhalbkugel;nördliche Halbkugel;Nordhemisphäre
-Südhemisphäre;südliche Hemisphäre;südliche Halbkugel;Südhalbkugel
-Logo;Wortmarke;Firmenlogo;Firmenzeichen;Bildmarke (fachspr.);Wort-/Bildmarke;Unternehmenslogo;Firmensignet;Signet (fachspr.)
-die Kehle herunterlaufen (ugs.);Flüssigkeit aufnehmen;trinken (Hauptform);saufen (Tiere)
-seismische Quelle;Bebenherd;Hypozentrum
-Padanisch;Norditalienisch;Oberitalienisch;Cisalpinisch
-Dampfbad;Nebelbad
-feuchtes Warmluftbad;Sanarium
-Brennholz;Kaminholz;Ofenholz;Feuerholz
-Duschkopf;Brause
-kryptogenetisch;kryptogen
-römischer Kümmel;Kumin;Kreuzkümmel;welscher Kümmel;weißer Kümmel;Cumin
-Frostpunkt;Eispunkt;Reifpunkt
-vorerst;ad interim (geh., lat.);interimistisch (geh.);vorläufig (Hauptform);fürs Erste;erst mal (ugs.);interimsmäßig;zunächst (einmal);keine endgültige Lösung;erstmal;bis auf Weiteres;vorübergehend;für den Moment;erst einmal;einstweilen;übergangsweise;zwischenzeitig
-schlecht wegkommen (bei);hinten rüber fallen (ugs., fig.);in die Röhre gucken (ugs., fig.);nichts abbekommen;durch den Rost fallen (fig.);gekniffen sein (ugs., fig.);zusehen (können) wo man bleibt (ugs.);am Katzentisch sitzen (ugs., fig.);das Nachsehen haben;zu kurz kommen (ugs.);benachteiligt werden;in die Röhre schauen (ugs., fig.);leer ausgehen;ins Hintertreffen geraten;(einfach) Pech gehabt haben (ugs.);schauen (können) wo man bleibt;sehen (können) wo man bleibt;durchs Gitter fallen (fig.);nicht berücksichtigt werden (verhüllend)
-Kaffernlimette;Mauritius-Papeda;Kaffir-Limette
-Treiben;Treibarbeit
-Stimulans;Psychotonikum;Psychoanaleptikum;Psychostimulans
-Geschäftsbilanz;Geschäftsabschluss
-Schwarzruthenien;Schwarzrussland;Schwarzreußen
-Polesien;Polessien
-Spülmittel;Spüli (möglicherweise regional) (ugs.)
-Orlogman;Orlogschiff
-Diamantgewölbe;Zellengewölbe
-räkeln;(sich) aalen (ugs.);nattern (ugs., norddeutsch)
-Naturrecht;natürliches Recht;überpositives Recht
-Zyklenindikator;Zyklenzeiger
-kein Baum, kein Strauch (ugs.);Gesteinswüste;Mondlandschaft (ugs.)
-Prinzip der kleinsten Wirkung;Hamiltonsches Prinzip
-kein Lüftchen (es geht ...) (ugs.);keine Luftbewegung;Windstille (Hauptform);(die) Luft steht;Flaute;(es geht) kein Hauch (geh.);Kalme (fachspr.)
-Bandscheibenprolaps;Discushernie;Bandscheibenvorfall;BSP;Discusprolaps
-Ausgabe;Vertrieb;Verkauf;Abgabe;Auslieferung;Veräußerung;Absatz
-herbeizitieren;(jemanden) zu sich bestellen;einbestellen;(jemanden) zu sich kommen lassen;(jemanden) zu sich rufen;(jemanden zu sich) zitieren (geh.);zu sich beordern;herzitieren;(jemanden) zu sich bescheiden (geh., veraltet);antanzen lassen (ugs.);antraben lassen (ugs.);(jemanden) herbei kommandieren;zum Rapport bestellen;vorladen;(jemanden) laden;herbeibeordern;(jemanden) herbestellen
-Polyäthylen (veraltet);Polyethylen;Polyethen
-Plastomer;Thermoplast
-Duromer;Duroplast
-Elastomer;Elaste
-Leuchtmittel (fachspr., Hauptform);Beleuchtungskörper (fachspr.);Lampe (fachspr.);Leuchtkörper (fachspr.)
-Primärbatterie;Batterie galvanischer Zellen;Batterie (ugs., Hauptform);elektrochemischer Speicher
-Atemtrakt;Atmungsapparat
-Romandie;Welschland;Westschweiz;französischsprachige Schweiz;französische Schweiz;Welschschweiz
-Deutschschweiz;deutsche Schweiz
-Innerschweiz;Zentralschweiz
-Natürlicher Horizont;Landschaftshorizont
-Strahlenbrechung;atmosphärische Refraktion;terrestrische Refraktion
-Brechung;Refraktion
-Invertzucker;Trimoline;Invertose
-(das) Kriegsbeil begraben (fig.);(sich) vertragen;einen Streit beilegen;Frieden schließen;(die) Friedenspfeife rauchen (fig.);(sich) versöhnen;(sich) aussöhnen;wieder Freunde sein (ugs.)
-gelbe Tonne;Wertstofftonne
-SA;Frontbann (temporäre Selbstbezeichnung);Sturmabteilung;Braunhemden
-Rosenlorbeer;Nerium oleander (fachspr.);Oleander
-FU-Schalter;Fehlerspannungsschutzschalter
-ausgraben;ausbuddeln;ans Tageslicht befördern;ausheben;(etwas Vergrabenes / Verschüttetes) ausgraben;ans Tageslicht fördern
-Zielkostenrechnung;retrograde Kalkulation
-Schlado (ugs.);Scheiß langer Donnerstag (derb)
-Scheiß langer Montag (derb);Schlamo (ugs.)
-Molukken;Gewürzinseln (ugs.)
-Malukusee;Molukkensee
-Küchenbulle (ugs., abwertend);Koch
-Stephanus-Tag;Stephanitag;Stefanitag (österr.);Stephanstag
-schriftliche Prüfung;theoretische Prüfung;Theorieprüfung
-Praxisprüfung;praktische Prüfung
-pharmazeutischer Wirkstoff;Pharmawirkstoff;Pharmakon;Arzneistoff
-Handelsname;Handelsbezeichnung
-Spurensicherung;Spusi (ugs., Jargon)
-Kochgenie;Jahrhundertkoch;Ausnahmekoch;ein (wahrer) Bocuse (auch ironisch);Vier-Sterne-Koch;Meisterkoch;Drei-Sterne-Koch
-Binnendifferenzierung;innere Differenzierung
-Außendifferenzierung;äußere Differenzierung
-duktiler Bruch;Verformungsbruch
-Torsionsbruch;Drehungsbruch
-Hilfskoch;Küchenhelfer;Beikoch
-Fernsehkoch;Kultkoch;Studio-Koch;Showkoch;Telekoch;Studiokoch;Starkoch;TV-Koch
-Commis de Cuisine (fachspr.);Jungkoch
-stellvertretender Küchenchef;Souschef (fachspr., franz.)
-Saucier (fachspr.);Soßenkoch
-Bratenkoch;Rotisseur
-Poissonnier (fachspr.);Fischkoch
-Suppenkoch;Potager
-Beilagenkoch;Entremetier (fachspr.)
-Gardemanger (fachspr.);Koch für die kalte Küche
-Freizeitkoch;Hobbykoch
-Promi-Koch;VIP-Koch;Promikoch
-Sternekoch;Haubenkoch (österr.);Spitzenkoch;Vorzeigekoch
-Alltags-Koch;Koch für den Alltag;Provinzkoch (ugs.);Wald-und-Wiesenkoch (ugs.)
-Küchenbulle (ugs., Jargon);Militärkoch
-Szenekoch;Trendkoch
-ausgebildeter Koch;Koch mit Ausbildung;gelernter Koch
-sonnensynchroner Orbit;SSO;Sonnensynchronorbit;sonnensynchrone Umlaufbahn
-Struktogramm;Nassi-Shneiderman-Diagramm
-Anwendungsfalldiagramm;Nutzerfalldiagramm;Nutzfalldiagramm
-Kollaborationsdiagramm (veraltet);Kommunikationsdiagramm
-Quadrokopter;Quadricopter;Quadrotor;Quadrocopter
-Tankuhr;Tankanzeige;Treibstoffanzeige;Kraftstoffanzeige;Spritanzeige (ugs.)
-mit etwas nicht hinter dem Berg halten (ugs.);aus seinem Herzen keine Mördergrube machen (ugs.);(etwas) jedem erzählen, egal ob er es hören will oder nicht;etwas hinausposaunen (ugs.);(etwas) offen aussprechen;das Herz auf der Zunge tragen (ugs.);mit etwas hausieren gehen;offen seine Meinung sagen;reden, wie einem der Schnabel gewachsen ist (ugs.)
-Fakultätsvertretung;Fachschaftsausschuss (veraltet)
-Kollegialitätsprinzip;Kollegialprinzip
-gebundener Lunarkalender;Lunisolarkalender
-Einschaltung;Interkalation
-Kachelung;Parkettierung;Flächenschluss;Pflasterung
-Gefäßdruck (fachspr.);Blutdruck
-Millimeter Quecksilbersäule (schweiz.);Millimeter-Quecksilbersäule;Torr
-Desmodromik;Zwangssteuerung
-Ventilsteuerung;Ventiltrieb
-variable Nockenwellensteuerung;Nockenwellenverstellung;variable Ventilsteuerung
-myogene Autoregulation;Bayliss-Effekt
-Unterbrechungsroutine;Interrupthandler;Unterbrechungsbehandlung
-Raumtemperatur;Innentemperatur
-Raumlufttemperatur;Raumtemperatur;Innentemperatur;Zimmertemperatur;Lufttemperatur
-Gleichlaufgelenk;homokinetisches Gelenk
-Bewetterung (fachspr.);Frischluftversorgung;Grubenbewetterung
-Schienenflankenschmierung;Spurkranzschmierung
-Gleitmittel;Gleitcreme;Gleitgel
-Ökotrophologie;Oecotrophologie;Haushalts- und Ernährungswissenschaft
-verbreitete Krankheit;Volkskrankheit
-Audiodatenkompression;Audiokompression
-Dynamikeinengung;Dynamikkompression
-Reichsritterschaft;Reichsadelsstand
-Immediatstände (Plural);reichsunmittelbare Stände (Plural)
-erster Napoleonischer Krieg;zweiter Koalitionskrieg
-erster Koalitionskrieg;erster Revolutionskrieg
-dritter Koalitionskrieg;zweiter Napoleonischer Krieg
-dritter Napoleonischer Krieg;vierter Koalitionskrieg;Feldzug gegen Preußen
-Geschäftsbeziehung;(Business-)Kontakt
-Rotor-Chiffriermaschine;Rotor-Schlüsselmaschine
-Verzagter;Zweifler;Kleingläubiger;Lauer
-Drahtanschrift;Drahtwort
-die Nieren betreffend;renal (fachspr.)
-Benzinvertrag;Feder-Bosch-Abkommen
-Enervation;Denervierung;Entnervung
-Magenschutz;Protonenpumpen-Inhibitoren;Protonenpumpenhemmer
-Quietschkäse (ugs.);Halloumi
-Paläontologie;Oryktologie (veraltet);Petrefaktenkunde (veraltet)
-Zivi-Ersatz (ugs.);Bundesfreiwilligendienst;Bufdi (ugs., Kurzform)
-Gleitbuchse;Lineargleitlager
-Ständerbohrmaschine;Tischbohrmaschine;Standbohrmaschine
-Skaphoidfraktur;Kahnbeinfraktur;Kahnbeinbruch
-Mauersalpeter;Mauersalz
-schwarzer Körper;schwarzer Strahler;planckscher Strahler
-Solarzelle;Sonnenzelle;photovoltaische Zelle
-Wärmediffusion;Konduktion;Wärmeleitung
-Wärmestrahlung;thermische Strahlung;Temperaturstrahlung
-Hallwachs-Effekt;Photoemission;äußerer photoelektrischer Effekt
-Photoionisation;atomarer Photoeffekt
-Luftelektrizität;atmosphärische Elektrizität
-elektrisches Erdfeld;elektrostatisches Feld der Erde;elektrostatisches Erdfeld;elektrisches Feld der Erde
-Paarerzeugung;Paarbildung
-Fotokathode;Photokathode
-statistische Prozesslenkung;statistische Prozesssteuerung;statistische Prozessregelung
-Blickfelddarstellung;HUD (Abkürzung, engl.);Head-up-Display (engl.);Blickrichtungsanzeige;Blickfeldanzeige
-(jemanden) ausbuhen;(jemanden) auspfeifen;(jemanden) niederschreien;(jemanden) auszischen;(jemanden) niederbrüllen
-arglos sein;an nichts Böses denken
-Geschmacksverirrung;Stillosigkeit;Abgeschmacktheit;Geschmacklosigkeit
-Zimmerspringbrunnen;Wohnzimmer-Wasserspiel
-tangibel (veraltet);berührbar
-Glatzer Neiße;Schlesische Neiße
-Lausitzer Neiße;Görlitzer Neiße (veraltet)
-Planwirtschaft;Kommandowirtschaft;Zentralplanwirtschaft;Zentralverwaltungswirtschaft
-Feinstaubplakette;Umweltplakette
-Flugdrohne;unbemanntes Luftfahrzeug;Drohne
-gestresst;überreizt;(etwas) mit den Nerven runter (ugs.);abgespannt;entnervt;zermürbt;mit den Nerven am Ende
-janusköpfig;doppelgesichtig
-Karenzgeld;Karenzurlaubsgeld
-für unbezahlten Urlaub freistellen;karenzieren (österr.)
-Entgeltersatzleistung;Lohnersatzleistung (veraltet)
-Islamkunde (veraltet);Islamistik (veraltet);Islamwissenschaft
-Cashcow (fachspr., engl.);Goldesel (ugs., fig.);(etwas) geht immer (ugs.);Dauerbrenner (ugs., fig.);ertragsstarkes Produkt;Erfolgsgarantie haben;Ertragsperle (ugs.);(sich) dauerhaft gut verkaufen;Selbstläufer (Jargon, Hauptform)
-Radrennen;Velorennen (schweiz.)
-PS-Jagd (ugs.);Autorennen;Automobilwettbewerb
-Schnittbild;Schichtbild;Tomogramm
-erfolgreich durchführen;über die Bühne bringen
-unbürokratisch;auf dem kurzen Dienstweg;unkompliziert;schnell und unbürokratisch (häufige Erweiterung, Verlautbarungssprache)
-Geschädigter (fachspr., Amtsdeutsch);Opfer;Betroffener;Leidtragender
-Bananenmagazin;Kurvenmagazin
-Repetierer;Repetierwaffe
-verrauchen;(sich) auflösen;(sich) verziehen;verpuffen;(sich) in Luft auflösen
-zurücklegen;überwinden
-(ein) Gierschlund (sein) (ugs.);vom Stamme Nimm sein (ugs.);den Hals nicht voll (genug) kriegen (können) (ugs., fig.);immer mehr (haben) wollen (ugs.);(etwas) ist nie genug (für jemanden) (ugs.)
-(sich) nicht mit dem ersten Besten zufrieden geben;fordernd auftreten;das Beste ist gerade gut genug (für);Ansprüche stellen;Ansprüche haben;vom Leben viel erwarten
-Selbstbedienungsmentalität;Hauptsache ich! (ugs.);an sich selbst zuerst denken
-Lauschepper (ugs., ruhrdt.);Abstauber (ugs.);Nassauer;Trittbrettfahrer (fig.);Schnäppchenjäger (fig.);Zecke (derb);Absahner;Vorteilsnehmer;Schnorrer;Nutznießer
-Selbstbereicherung;Selbstbedienung (fig.)
-Brauner Pelikan;Braunpelikan
-Klockerin;Glocknerin (veraltet);Glockerin (veraltet)
-Mitnahmeeffekt;Mitnahmementalität (ugs.)
-Laserstrahlschneiden;Laserschneiden
-Kurköln;Erzstift und Kurfürstentum Köln
-Safranvergiftung;(der) fröhliche, lachende Tod
-CJK (Abkürzung);Creutzfeldt Jakob Disease (engl.);CJD (Abkürzung, engl.);Creutzfeldt-Jakob-Krankheit
-Prionenkrankheit;Prionerkrankung;Transmissible Spongiforme Enzephalopathie;TSE (Abkürzung);übertragbare spongiforme Enzephalopathie;Prionkrankheit
-Kuru;(der) lachende Tod;Lachkrankheit
-Paraplegia enzootica (fachspr., griechisch, lat.);Wetzkrankheit;Scrapie (engl.);Gnubberkrankheit;Rida;Traberkrankheit (Hauptform)
-grüne Witwe;Witwe auf Zeit;Strohwitwe
-schwarze Witwe;Giftmischerin;Serienmörderin
-schwarze Witwe (weibl.);Selbstmordattentäterin (weibl.);Selbstmordattentäter (männl.)
-Introspektion;Reflexion
-Toilettenanlage;WC-Anlage;öffentliche Toilette;öffentliches WC;Bedürfnisanstalt (Amtsdeutsch)
-minoisch;kretisch-minoisch;kretominoisch
-DSLR;digitale Spiegelreflexkamera
-Virginität (fachspr.);Unberührtheit;Jungfräulichkeit;(sexuelle) Unschuld;Unbeflecktheit (bibl.)
-fadenförmig;filiform (fachspr.)
-(etwas für sich) herausholen;(sich) die eigenen Taschen füllen;in die eigene Tasche wirtschaften;(etwas für sich) herausschlagen;(sich) (ordentlich) bedienen (ugs.);(sich) die Taschen vollstopfen (ugs.);(sich) die Taschen vollmachen (ugs.);(sich) bereichern (an)
-sündlos;sündenlos;ohne Sünde
-das Strafrecht betreffend;pönal (veraltet);strafrechtlich
-massakrieren;niedermetzeln;abschlachten;schlachten;metzeln;niedermachen
-Frühzeit;Kindertage (fig.);Anfangstage
-Kanzelwort;Sermon;Predigt;Kanzelrede
-Testimonium Paupertatis (geh., bildungssprachlich, lat., selten);Armutszeugnis
-kalte Füße bekommen (bei) (fig.);(jemandem) zu heiß werden;(jemandem) wird der Boden zu heiß (fig.);(jemandem) nicht mehr geheuer sein;(ein) mulmiges Gefühl bekommen bei
-(eine) rote Linie ziehen;(eine) Grenze setzen;bis hierher und nicht weiter (sagen)
-(ein) Fauxpas sein;ungehörig sein;ins Fettnäpfchen treten;(etwas/sowas) tut man einfach nicht;nicht angebracht sein;(absolut) daneben sein;(sich) nicht gehören;(etwas) nicht bringen können (ugs.);tabu sein;unschicklich sein;unangebracht sein;(etwas) geht gar nicht (ugs.);(ein) (absolutes) No-go sein
-einen peinlichen Fehler machen;in ein Fettnäpfchen treten
-in ein Wespennest stechen (fig.);(sich) die Zunge verbrennen (ugs., fig.);(jemandem) entfahren (geh.);(sich) den Mund verbrennen (ugs., fig.);(sich) zu der Bemerkung hinreißen lassen (dass);(jemandem) herausrutschen (ugs.);(jemandem) herausschlüpfen (ugs.);(sich) verplappern (ugs.);(ungewollt oder versehentlich) ausplaudern;(sich) vergaloppieren (ugs., fig.)
-von frühester Jugend an;von klein auf (Hauptform);seit seiner (ihrer) frühesten Jugend;von Kindestagen an;schon als ganz kleiner Junge (männl.);schon als ganz kleines Kind;von Kindesbeinen an;von frühester Kindheit an;von der Wiege an;von klein an;seit Kindestagen;schon als ganz junges Mädchen (weibl.);seit seiner (ihrer) frühesten Kinderzeit;von Kindheit an;von Kind auf;seit Kindertagen;seit seiner (ihrer) frühesten Kindheit
-schmotziger Donnerstag;schmutziger Donnerstag (schweiz.);unsinniger Donnerstag (tirol.) (bayr.)
-Schmotziger Dunnschdig (südbadisch, alemannisch) (ugs.);Weiberfasching;Weiberfastnacht;Wieverfastelovend (ugs., kölsch);Weiberfaasnet (ugs., schwäbisch);Altweiberfasching;Altweiber;Fettdonnerstag (Raum Aachen) (ugs.);Altweiberfastnacht
-rußiger Freitag;Karnevalsfreitag
-Karnevalsdienstag (kölsch);Veilchendienstag;Faschingsdienstag;Faschingdienstag (österr.);Fastnachtsdienstag;Fasnachtsdienstag
-Martini (altbairisch, österr.);Martinstag
-Martinskirche;St. Martin
-Schirmmütze;Cap;Baseball-Mütze;Baseballmütze;Kappe;Basecap (ugs., Scheinanglizismus);Klätschkapp (ugs., niederrheinisch);Baseballkappe;Baseballcap
-Silbersol;Silberwasser
-Druckbleistift;Minenschreiber;mechanischer Stift
-Bleistiftzeder;Virginischer Wacholder;Virginische Rotzeder;Virginische Zeder
-Stinksalat;Gift-Lattich;Wilder Lattich;Stinklattich
-Schreibkrampf;Cheirospasmus;Mogigraphie
-Myofibrille;Muskelfibrille
-Myozyt;Muskelfaserzelle;Muskelfaser
-(die) Ernte einfahren (auch figurativ);ernten
-zeigen;deuten;weisen
-(sich) kasteien;(sich) Entbehrungen auferlegen
-Herrschaft der Alten;Gerontokratie
-Meritokratie;Verdienstadel
-Verseschmied (ironisch);Dichter (Hauptform);Versemacher;Reimeschmied (leicht iron.);Lyriker;Versschreiber;Dichterling (abwertend);Gedichteschreiber;Musensohn;Spielmann;Minnesänger (fig.);Barde (fig.);Poet
-Betriebsrat;Interessensvertretung der Belegschaft
-überdurchschnittlich;über dem Durchschnitt
-unterdurchschnittlich;unter dem Durchschnitt
-Ligula;Blatthäutchen
-(ein) Lächeln aufsetzen;grienen (ugs., norddeutsch);schmunzeln;grinsen;lächeln (Hauptform)
-(ein) Volontariat absolvieren;als Volontär arbeiten;volontieren
-Weinviertler Hügelland;Weinviertler Klippenzone
-Fernsehkarte;TV-Karte
-Närrinnen und Narrhalesen (Anrede auf Karnevalssitzung) (ugs.);Närrin (weibl.);Karnevalist;Jeck;Karnevalsjeck;Narr (männl.)
-Regimentstochter;Funkenmariechen;Tanzmariechen
-Karnevalsvortrag;Büttenrede
-diesen Freitag;kommenden Freitag;am nächsten Freitag (= am nächsten, der kommt);jetzt Freitag;jetzt am Freitag;diese Woche Freitag;am Freitag dieser Woche;am nächsten Freitag, der kommt;am nächstmöglichen Freitag;nächsten Freitag
-diesen Freitag in einer Woche;nächsten Freitag (zu verstehen als: nächste Woche Freitag);am Freitag in einer Woche;Freitag in acht Tagen;jetzt Freitag in einer Woche;nächste Woche Freitag;übernächsten Freitag (zu verstehen als: den genau bzw. wörtlich genommen übernächsten Freitag);den Freitag danach (kontextabhängig);den Freitag darauf (kontextabhängig);den (genau genommen) übernächsten Freitag;Freitag in einer Woche;am Freitag der nächsten Woche;jetzt Freitag in acht Tagen
-differenziert;nuanciert;fein ausdifferenziert
-Hindi-Filmindustrie;indische Filmindustrie;Bollywood
-Kitsch;Trivialkunst;Edelkitsch
-Gotenkopf;Kuban-Brückenkopf
-Kimmerer;Kimmerier
-Luftlandeschlacht um Kreta;Unternehmen Merkur
-Luftlandeoperation;Luftlandung
-Rommelspargel;Hochpfähle;Hemmbalken
-Nachtstück;Nocturne;Notturno
-Kryptoanalyse;Kryptanalyse
-Lorenz-Schlüsselzusatz;Lorenz-Schlüsselmaschine
-Azubiene (ugs., weibl.);Abundzubi (ugs., abwertend, selten);Lernender (schweiz.);Lehrtochter (schweiz., weibl.);Azubi (ugs., Kurzform);Lehrling;Auszubildende (weibl.);Auszubildender (männl.);Azubine (ugs., weibl.);Lehrmädchen (bayr., veraltet, weibl., österr.);Stift (ugs., veraltend)
-Ergotropie (fachspr.);Sympathikotonie (fachspr.)
-Strickleiternervensystem;metameres Nervensystem
-Spinalnerv;Rückenmarksnerv;Rückenmarknerv;Nervus spinalis (fachspr.)
-Zentralnervensystem;zentrales Nervensystem;ZNS (Abkürzung)
-sympathisches Nervensystem;Sympathikus
-parasympathisches Nervensystem;Parasympathikus
-ektope Schwangerschaft;Extrauteringravidität (fachspr.)
-Peritonealgravidität (fachspr.);Abdominalgravidität (fachspr.);Bauchhöhlenschwangerschaft
-Eileiterschwangerschaft;Tubargravidität (fachspr.)
-Eingeweidenervensystem;enterisches Nervensystem;Darmnervensystem
-einen Termin betreffend;terminlich
-Journalisten (franz.);Medienvertreter;Lohnschreiber (abwertend);Blattmacher;schreibende Zunft (ugs.);Medienleute;Presse;Schmock(s) (abwertend, veraltet);Medienmeute (abwertend);Journaille (abwertend, franz.);Zeitungsleute
-(sich) nicht weiter befassen (mit);schubladisieren (ugs.)
-(sich) im Klaren sein (über);(etwas) mitdenken müssen (geh.);(etwas) vor Augen haben;(etwas) präsent haben;(jemandem) präsent sein (geh.);(jemandem) gewärtig sein (geh.);an etwas denken (ugs.);(etwas) auf dem Schirm haben (ugs.);(jemandem) bewusst sein;(etwas) nicht vergessen haben (ugs.);(etwas) im Kopf haben
-Salzburger Schieferalpen;Salzburger Grasberge
-Zentralalpen;Zentrale Ostalpen
-Nördliche Ostalpen;Nordalpen
-Defereggengebirge;Villgratner Berge
-Großer Geiger;Obersulzbacher Venediger (veraltet);Heiliggeistkogel (veraltet)
-kopernikanisches Weltbild;heliozentrisches Weltbild
-Großinquisitor;Generalinquisitor
-Metamorphit;metamorphes Gestein
-magmatisches Gestein;Magmatit;Erstarrungsgestein
-Leukogestein;Leukokrates Gestein
-melanokrates Gestein;Melagestein
-versehen (mit);ausgerüstet (mit);bestückt (mit);ausgestattet (mit)
-Setzstein;Megalith
-Keilrippenriemen;Keilrippriemen
-Gliederkeilriemen;Lamellenkeilriemen
-Ernährungswissenschaft;Ernährungslehre;Trophologie
-Multivibrator;astabile Kippstufe
-Oszillator;Oszillatorschaltung
-Schweizer Schulschrift;Schnüerlischrift (ugs.)
-Same;Saatkorn
-Schreibschrift;Kursive;Kurrentschrift;Laufschrift
-Textura;Textur;Gitterschrift
-Rotunda;Halbgotisch;Rundgotisch
-Alte Schwabacher Schrift;Schwabacher;Schwabacher Schrift
-Kanzleikurrent;Deutsche Kanzleischrift
-in utero (fachspr., lat.);in der Gebärmutter;intrauterin (fachspr., lat.)
-Aussage;Botschaft;Message (Denglisch, Jargon)
-Mannhaftigkeit;Männlichkeit;Maskulinität
-Femininität;Weiblichkeit;Fraulichkeit;Feminität (lat.)
-(ohne Kontrolle) passieren lassen;durchwinken
-unwirtschaftlich;ineffizient
-über der Grenzen von Kontinenten hinaus;Kontinente verbindend;interkontinental
-Materialzufuhr;Zuführung von Material;Beschickung
-Bierduell;Bierjunge;Trinkmensur;Bierskandal;Biermensur;Biermensur
-Protokollstack;Netzwerkstack;Protokollstapel;Protokollturm;Netzwerkstapel
-unhandlich;ausladend;sperrig
-Wirtschaftsflüchtling;Armutsflüchtling;Wohlstandsflüchtling
-Binnenflüchtling;Intern Vertriebener;Binnenvertriebener
-Edelmetallklumpen;Nugget (engl.)
-regredient;(sich) zurückbildend
-Schulden;Fremdkapital
-schlotterig (abwertend);formlos;schlabberig (ugs., abwertend, Hauptform);unförmig;schlabbrig (ugs., abwertend);aus der Form geraten;sackartig
-(einen) Käufer finden;über die Ladentheke gehen (ugs.);(sich) verkaufen lassen;über den Ladentisch gehen (auch figurativ);(einen) Abnehmer finden;weggehen;verkauft werden;Absatz finden;(den) Besitzer wechseln
-von sich (selbst) eingenommen;sich selbst genug;selbstherrlich;selbstgewiss;(die) Wahrheit für sich gepachtet haben (Redensart, variabel);selbstgerecht;von sich selbst überzeugt;von keinem Zweifel angekränkelt (geh.);selbstgefällig
-aus der Reihe tanzen (ugs., fig.);(sich) nicht einordnen lassen;aus dem Rahmen fallen (ugs., fig.)
-Altsachsen;Stammesherzogtum Sachsen
-Alemannen;Alamannen
-(sich) vordrängeln;(sich) vordrängen;(sich) vorpfuschen (ugs., regional, ruhrdt.)
-vergeben (ugs.);gebunden;ihr Herz gehört einem anderen (lit.) (geh.);nicht mehr frei;nicht mehr zu haben
-Prämisse;Vordersatz
-Farce (geh., franz.);Lachnummer (ugs.);Posse;Peinlichkeit;Kasperletheater (ugs.);Schnurre (geh., veraltet);Verrücktheit;Schnake (ugs., regional)
-CRM;Kundenbeziehungsmanagement;Kundenpflege;Customer-Relationship-Management
-Intensivtäter;Wiederholungstäter;Rückfalltäter;Mehrfachtäter
-Drei-Kammer-System;Dreikammersystem;Trikameralismus
-Einkammersystem;Einkammerparlament
-Bohrloch;Bohrung
-Uvea (fachspr.);mittlere Augenhaut
-Internetshop;Webshop;Webstore;Onlinestore;Onlineshop;E-Shop
-Haustechnik;Gebäudetechnik;Raumtechnik;Wohnraumtechnik
-Produktdesign;Produktlayout;Produktaussehen
-alles Mögliche (ugs.);Gott weiß was (ugs., Hauptform);wer weiß was (ugs.);wunders was;sonst was (ugs.)
-Leitungsvermittlung;Durchschaltevermittlung
-Purpurgerade;Purpurlinie
-CIE-Normvalenzsystem;CIE-Normfarbsystem
-Opponententheorie;Gegenfarbtheorie;Gegenfarbentheorie
-Bezeichnungslehre;Onomasiologie
-Forstweg;Feldweg;Wirtschaftsweg
-flächentreue Azimutalprojektion;Lambertsche Azimutalprojektion
-Wermutstropfen;Schwachpunkt;Minuspunkt;(einziger) Nachteil
-greifend abtasten;abgreifen
-Zentralafrikanische Föderation;Föderation von Rhodesien und Njassaland;Zentralafrikanischer Bund
-(sich) selbst überzeugen (von);mit eigenen Augen nachsehen;eigenhändig überprüfen
-harter Hund (ugs., fig.);Eisenfresser (ugs., fig.);harter Bursche (ugs.);knallharter Typ (ugs.)
-Feinnadelbiopsie;Feinnadelpunktion;Feinnadelaspirationsbiopsie
-Altonaer Hafenbahntunnel;Schellfischtunnel (ugs.)
-erster Hanse-Dänemark-Krieg;erster Hansekrieg
-Hanse;Deutsche Hanse;Düdesche Hanse;Hansa Teutonica (lat.)
-Zweckbau;Nutzbau
-Patrizier (geh., historisch);Honoratioren (nur Plural) (geh., veraltend);Honorationen (nur Plural) (geh., süddt., veraltet);Ehrbarkeit (geh., historisch);Standesperson(en);(Personen) von herausgehobener Stellung;(Personen) von Stand;Notabeln (nur Plural) (geh., veraltet);hochgestellte Persönlichkeit(en)
-Zäkum (fachspr.);Typhlon Enteron (fachspr., griechisch);Coecum (fachspr., lat.);Blinddarm;Zökum (fachspr.);Caecum (fachspr., lat.);Intestinum Caecum (fachspr., lat.);Cecum (fachspr., lat.)
-Defäkationsreflex;Stuhlreflex
-(den) Hauptgewinn bekommen (ugs., auch figurativ);das große Los ziehen (ugs.);viel Glück haben;(so richtig) abräumen (ugs.);(einen) Fitsch machen (ugs.)
-Eem-Warmzeit;Eem-Interglazial;Eem
-Summenformel;Molekülformel;Bruttoformel
-tonisch-klonischer Krampfanfall (fachspr.);Konvulsion (veraltet);Schüttelkrampf
-Vasospasmus;Angiospasmus;Gefäßspasmus
-Laryngospasmus;Glottiskrampf;Stimmritzenkrampf
-du kannst mir mal den Buckel runterrutschen! (ugs., variabel);macht doch euren Scheiß alleine! (derb);du kannst mich (mal) kreuzweise! (derb);du kannz mir ma den Nachen deuen (ugs., rheinisch);fick dich ins Knie! (vulg.);geh mir doch weg! (ugs.);du kannst mich (mal) am Arsch lecken! (vulg.);fick dich selbst! (vulg.);(dein ...) kannst du dir sonstwo hinstecken! (derb);leck mich (doch) am Arsch! (vulg.);du kannst mich mal! (ugs., Hauptform);du kannst mich mal gerne haben! (ugs.);fick dich! (vulg.);drauf geschissen! (derb)
-(ist) mir doch egal! (ugs.);die können mich (alle) mal! (sprich 'gerne haben', oder Deftigeres) (ugs.);Arschlecken! (derb);Arschlecken rasieren dreifuffzig. (derb, Spruch);Scheiß drauf! (derb, Spruch);Scheiß der Hund drauf! (derb, Spruch)
-stroboskopischer Effekt;Stroboskopeffekt;Wagenradeffekt
-visuelle Illusion;optische Täuschung
-Luftspiegelung;Fata Morgana
-limitierte systemische Sklerodermie;Thibierge-Weissenbach-Syndrom;CREST-Syndrom
-Morbus Raynaud;Digitus mortuus;Raynaud-Syndrom;Raynaud-Phänomen;Reilscher Finger;Weißfingerkrankheit (ugs.);Leichenfinger (ugs.)
-Erdlicht;Erdschein
-Sonnenstrahlung;Solarstrahlung
-Turboverdichter;Turbokompressor
-Stator;Ständer
-Hydromotor;Hydraulikmotor
-Zahnringpumpe;Gerotorpumpe
-Dispenser;Dosierpumpe
-Drehschieberpumpe;Flügelzellenpumpe
-Hubverdrängerpumpe;Hubkolbenpumpe;Kolbenpumpe (ugs.)
-Druckmultiplikator;pneumohydraulischer Druckübersetzer
-Flüssigkeitsringpumpe;Flüssigkeitsringvakuumpumpe;Flüssigkeitsringverdichter;Wasserringpumpe
-Taschenkunst;Heinzenkunst;Büschelkunst
-Schlauchpumpe;Schlauchquetschpumpe;Peristaltikpumpe
-Schraubenverdichter;Schraubenspindelpumpe;Schraubenpumpe;Wendelkolbenpumpe
-Koppelung;Koppelnavigation
-Hals;Kamm;Schopfbraten;Schweinenacken
-(der) rasende Reporter;Egon Erwin Kisch
-Willi Lippens (Eigenname);(die) Ente (ugs.)
-Peter Müller;de Aap;Müllers Aap
-Kyrenaika;Cyrenaika
-Feldversuch;Parzellenversuch
-Millenarismus;Millennialismus;Chiliasmus
-Prämillenarismus;Prämillennialismus
-Amillenarismus;Amillennialismus
-Sklavenarbeit;Zwangsarbeit
-Fugenelement;Fugenmorphem;Kompositionsfuge;Fugenzeichen;Fugenlaut
-Interfix;Infix
-Dahlbusch-Rettungsbombe;Dahlbuschbombe;Dahlbusch-Bombe
-Opfermann;Offermann (niederdeutsch)
-Schneeberger Lungenkrankheit;Bergsucht;Schneeberger Krankheit
-der entscheidende Faktor (sein);den Ausschlag geben (Hauptform);das Zünglein an der Waage (sein) (fig.)
-Alkoholintoleranz;Alkoholunverträglichkeit
-(etwas) an eine Voraussetzung knüpfen;zur Bedingung machen;(etwas) unter (den / einen) Vorbehalt stellen;(sich etwas) ausbedingen;(jemandem etwas) zur Auflage machen
-zum Abschuss freigegeben (sein) (fig.);geliefert (sein) (ugs.);ein hoffnungsloser Fall (sein);bald weg vom Fenster (sein) (ugs.);erledigt (sein);verloren (sein)
-Pseudolyssa;Juckseuche;infektiöse Bulbärparalyse;Aujeszky-Krankheit;Tollkrätze;Juckpest;Morbus Aujeszky;Pseudorabies;Pseudowut;Aujeszkysche Krankheit (veraltet)
-Tiermedizin;Veterinärmedizin
-Turksprache;türkische Sprache;Türksprache
-türkische Sprache;Türkeitürkisch;Osmanisch-Türkisch
-Pandektenwissenschaft;Pandektistik
-Pandekten;Digesten
-(einen) Verweis erhalten;(sich) unfreundliche Worte anhören müssen;(sich) Kritik gefallen lassen müssen;(von jemandem) etwas zu hören bekommen (ugs.);(sich) (einiges) Unangenehmes sagen lassen müssen;eins auf den Deckel kriegen (ugs.);zur Ordnung gerufen werden;(einen) eingestielt bekommen (ugs., salopp);gerügt werden;zurechtgewiesen werden;verwarnt werden;von jemandem die Leviten gelesen bekommen;ausgescholten werden;(sich) einiges (Unangenehmes) anhören müssen;zur Sau gemacht werden (derb);(sich von jemandem) die Leviten lesen lassen;(etwas) über sich ergehen lassen müssen
-(jemanden) im Ungewissen lassen (Hauptform);(jemanden) nicht informieren;(jemanden) im Dunkeln lassen
-Pentelikon-Marmor;Pentelischer Marmor
-(stark) sinken (Kurse, Preise) (Hauptform);(stark) einbrechen (fig., variabel);in den Keller rauschen (ugs., fig.);nach unten gehen (ugs.);abstürzen (fig.);in den Keller gehen (ugs., fig.)
-Delta-Kodierung;Differenzspeicherung
-Schlüsselbild;Intra-Bild
-kryptographische Hashfunktion;kryptologische Hashfunktion
-Kollisionsresistenz;Kollisionssicherheit
-spezifische Widerstand;spezifischer elektrischer Widerstand;Resistivität
-spezifische Wärme;spezifische Wärmekapazität
-Temperaturbeiwert;Temperaturkoeffizient
-Dampfdrucklinie;Sättigungsdampfdruckkurve;Sättigungsdampfdrucklinie;Dampfdruckkurve
-Gleichgewichtsschaubild;Zustandsschaubild;Phasendiagramm;Zustandsdiagramm
-Siedekurve;Siedepunktkurve;Siededruckkurve;Siedelinie;Siedepunktskurve
-relative Permittivität;Dielektrizitätszahl;Dielektrizitätskonstante;Permittivitätszahl
-elektrische Konstante;Influenzkonstante;elektrische Feldkonstante;Permittivität des Vakuums;Dielektrizitätskonstante des Vakuums
-dielektrische Polarisation;Polarisation
-magnetische Erregung (veraltet);magnetische Feldstärke
-magnetische Induktion;magnetische Flussdichte;Flussdichte (ugs.);Magnetfeld (ugs.)
-Brechzahl;Brechungsindex
-bayesisches Filter;bayessche Filter;Bayes-Filter
-Gamepad;Joypad
-Romaniotisch;Juden-Griechisch;Jevanisch
-metrisches Einheitensystem;metrisches System
-Maßsystem (veraltet);Einheitensystem
-cgs-System;CGS-System;CGS-Einheitensystem
-MKS-Einheitensystem;MKS-System
-Toningenieur;Tontechniker
-Kontrabass-Spieler;Bassist;am Kontrabass
-Coderate;Informationsrate
-Militärgericht;Militärtribunal
-Auf Nimmerwiedersehen (ugs., aggressiv);Lass dich hier (bloß) nicht wieder blicken! (ugs., aggressiv)
-Kommandozeilenschalter;Kommandozeilenparameter;Startparameter;Befehlszeilenparameter;Befehlszeilenargumente
-arbeitsfreie Zeit;freie Zeit;Freizeit
-intelligenterweise;sinnigerweise (oft iron.) (ugs.);passenderweise;sinnvollerweise
-Profisport;Berufssport
-Protoindoeuropäisch;Indoeuropäisch;Urindogermanisch;indogermanische Ursprache;indogermanische Grundsprache;Proto-Indogermanisch
-Englische Philologie;Anglistik
-Indogermanistik;Indoeuropäische Sprachwissenschaft;Indoeuropäistik;Indogermanische Sprachwissenschaft
-Kreuzbergerkenntnis;Kreuzbergurteil
-Stockholmer Konvention;POP-Konvention
-Xenohormon;endokriner Disruptor
-endokrines System;Hormonsystem
-Langerhanssche Insel;Langerhans-Insel;Inselzelle
-Lenkkopfwinkel;Gabelkopfwinkel
-Sicherheitskennzeichen;Sicherheitszeichen
-Hebelgesetz für Phasendiagramme;Konodenregel
-Nominalstil;Bevorzugung von Nominalphrasen;Häufung von Nomen;häufige Umwandlung von Verben in abgeleitete Substantive;Vermeidung von Verben
-prograd;rechtläufig
-retrograd;rückläufig
-Intensivpflegestation;Intensive Care Unit;Intensivstation
-Lenkrollhalbmesser;Lenkrollradius
-Stürzgut (fachspr.);Schüttgut
-Pritsche;offene Ladefläche
-Vorratsgrube;Miete;Erdbunker;Bunker
-Muldenkipper;Dumper
-Vorderkipper;Japaner;Muli;Dumper;Motor-Japaner
-hoher Besuch;prominenter Besuch(er);Ehrengast;(ein) wichtiger Gast
-untertänigst;ergebenst
-abspringen (fig.);aussteigen (fig.);desertieren (fig., militärisch);(sich) abseilen (ugs., fig.);(sich) verkrümeln (ugs.);von der Fahne gehen (fig.);(sich) ausklinken (ugs., fig.);(sich) absentieren (geh., veraltet);(sich) verpissen (derb);von der Stange gehen (fig.);(jemandem) davonlaufen;(sich) absetzen
-Ein Schelm, wer Böses dabei denkt.;Honni soit qui mal y pense. (franz.)
-(sich) nicht weiter aufregen;nicht weiter angehen gegen;runterkommen;(endlich) Ruhe geben;wieder zur Ruhe kommen
-nicht in Form geschnitten;frei wachsend;freiwachsend
-ja was denn nun? (ugs.);wie belieben? (geh., scherzhaft-ironisch, veraltet);wie bitte? (ugs., Hauptform);wie meinen? (geh.);wie jetzt!? (ugs.);verstehe ich das (jetzt) richtig?: (Aussage);versteh(e) ich Sie richtig (wenn...)?;hab ich Sie (da) richtig verstanden?;wie soll ich das jetzt verstehen?;bitte? (ugs.);hä? (ugs., salopp);Moment mal (ugs.)
-Gewässerkennzahl;Fließgewässerkennziffer
-Schreibstil;Handschrift (fig.);Schreibe (ugs.)
-Präformationslehre;Evolutionslehre (veraltet);Präformationstheorie
-Spermatozoid;Samenfaden (ugs.);Spermium;Spermatozoon;Samenzelle (ugs.)
-assistierte Reproduktion;künstliche Befruchtung
-Buckelschweißen;Widerstandsbuckelschweißen
-Punktschweißen;Widerstandspunktschweißen
-Rollennahtschweißen;Widerstandsrollennahtschweißen
-CD-Schweißen;KE-Schweißen;transformierte Kondensatorentladung;Kondensatorentladungsschweißen;Fulmidurschweißen;Perkussionsschweißen;Kondensator-Impulsschweißen;Kondensatorimpulsschweißen
-Einzelelektronentransistor;Ein-Elektron-Transistor
-Kymophan (veraltet);Cymophan (veraltet);Chrysoberyll-Katzenauge;Katzenauge
-direkte Kinematik;Vorwärtstransformation
-Rückwärtstransformation;inverse Kinematik
-vermöge (einer Sache) (geh.);kraft (geh.);durch;aufgrund (von)
-Kenngröße;Ähnlichkeitskennzahl;dimensionslose Kennzahl (der Physik)
-(übertriebene) Strenge;Rigorismus;Härte
-Landungsunternehmen;Anlandung;Seelandung;Landung
-Biom;Bioformation
-Sediment;Lockersediment;Bodensatz
-Schwebstoff;suspendierter Stoff
-Alleldrift;Sewall-Wright-Effekt;Gendrift
-Vererbung;Heredität
-Allelfrequenz;Genfrequenz
-Teemaschine;Teeautomat
-aber, aber!;ich würd's lassen (ugs.);muss das sein? (ugs.);Ich würd's gar nicht erst versuchen. (ugs.);(das ist) keine gute Idee (ugs.);bitte nein! (ugs.);nicht schon wieder! (ugs.);lass das (ugs., Hauptform);Du kannst es ja mal versuchen. (herausfordernd oder resignierend) (ugs.);hör auf damit (ugs.);nicht doch! (höflich);lass es einfach! (ugs.);lass es besser (sein)
-ungebrochen;anhaltend;ungetrübt
-absengen;abflammen;sengen;abschreuen (regional, selten);abflämmen
-sackerlot! (ugs., veraltet);Das hätt(e) ich jetzt (aber) nicht gedacht! (ugs.);leck mich fett! (ugs.);sowas aber auch! (ugs.);caramba! (ugs.);irre! (ugs.);jetzt hört sich aber alles auf! (ugs.);Wahnsinn! (ugs.);ich glaub es nicht! (ugs.);potz Blitz (ugs., veraltet);da bleibt einem (ja) die Spucke weg! (ugs., fig., sprichwörtlich);ach was! (ugs.);krass! (ugs.);sackerment! (ugs., veraltet);wo sind wir denn hier!? (ugs.);gütiger Himmel! (ugs.);leck mich anne Täsch! (ugs., ruhrdt., veraltet);verdammt juchhe! (ugs.);Menschenskinder! (ugs.);leckofanni! (ugs.);voll krass! (ugs.);oho! (ugs.);(ich glaub') mich trifft der Schlag! (ugs., Spruch);leck mich en den Täsch! (ugs., kölsch);potzblitz! (ugs., veraltet);ich glaub's ja nicht! (ugs.);ich werd' verrückt! (ugs.);Mann Mann Mann! (ugs.);jetzt hör sich das einer an! (ugs.);potztausend! (ugs., veraltet);heiliges Kanonenrohr! (ugs., veraltet);ei der Daus! (ugs., veraltet);mein lieber Scholli! (ugs., ruhrdt.);heilig's Blechle! (ugs., schwäbisch);Teufel auch! (ugs.);do legst di nieda (ugs., bayr.);Was machst du für Sachen!? (ugs., ironisch, kommentierend);holla, die Waldfee! (ugs.);alter Schwede! (ugs.);ach ja? (ugs.);Herrschaftszeiten! (ugs.);verdammt nochmal! (ugs.);(ja) ist das denn die Möglichkeit!? (ugs.);unglaublich! (ugs.);da bin ich platt! (ugs.);fuck! (bewundernd) (ugs., salopp);(ich bin) überrascht (Hauptform);hört, hört! (ugs., veraltend);Donnerwetter! (ugs.);nicht zu glauben! (ugs.);Mensch Meier! (ugs.);Ich glaub, mein Schwein pfeift! (ugs., sprichwörtlich);Donnerlittchen! (ugs., regional);mein lieber Schwan! (ugs.);Da staunt der Laie, und der Fachmann wundert sich. (Zitat) (ugs., Spruch);sapperment! (ugs., veraltet);ich kann dir sagen! (ugs.);mein lieber Herr Gesangsverein! (ugs., veraltet);sapperlot! (ugs., regional, veraltet);sieh mal (einer) an! (ugs.);da bin ich (aber) sprachlos! (ugs.);(ach) du kriegst die Tür nicht zu! (ugs., regional, sprichwörtlich);Mannomann! (ugs.);ach du grüne Neune! (ugs.);nicht zu fassen! (ugs.);nein sowas! (ugs.);schau mal (einer) an! (ugs.);hasse (noch) Töne?! (ugs., ruhrdt.);sheesh! (schüüsch!) (ugs., jugendsprachlich);also sowas! (ugs.);oha! (ugs.);lecko mio! (ugs.);nun schau sich das einer an! (ugs., Spruch);da hört sich doch alles auf! (ugs., Spruch)
-Best Case (engl.);bester Fall;günstigster Fall
-Parametrisierung;Parametrierung;Parameterdarstellung
-implizit definierte Funktion;implizite Funktion
-Winkeldiskordanz;Tektonische Diskordanz
-nur noch;höchstens noch;im besten Falle noch;allenfalls noch;nur mehr;nurmehr
-ahnungslos;unschuldig;nicht eingeweiht (sein);von nichts wissen;mir hat keiner was gesagt (ugs.)
-ohne (jede) Schuld;nichts können für (ugs.);schuldlos;bar jeder Schuld (geh.);ohne die geringste Schuld;frei von (jeder) Schuld;unschuldig (an);ohne eigenes Verschulden;unverschuldet
-markige Sprüche;Stammtischparolen;starke Sprüche
-Teilzeitkraft;Teilzeitarbeitnehmer;in Teilzeit (arbeitend/beschäftigt);Teilzeitarbeiter;Teilzeitangestellter;Teilzeitbeschäftigter;keine volle Stelle (haben)
-(sich) bekennen (zu);(sich) outen;(sich) zu erkennen geben;Farbe bekennen;(eine) klare Haltung einnehmen;nicht verleugnen;stehen zu;(sich) erklären
-im Schnelldurchgang;ohne (viel) Federlesens;ohne große Diskussion;ohne sich (lange) mit Formalitäten aufzuhalten;im Hauruckverfahren;kurzen Prozess machen
-Aufreger;(willkommener) Anlass zu Aufgeregtheit(en);(jeden Tag) (wird) (eine) neue Sau durchs Dorf getrieben;Skandälchen
-Erlauben Sie mal! (ugs.);Was fällt Ihnen ein! (ugs.);Wie reden Sie mit mir!?;Was erlauben Sie sich!? (ugs.)
-Speichereinspritzung;Common-Rail-Einspritzung
-leise Stimme;dünnes Stimmchen;Stimmchen;dünne Stimme;schwache Stimme;leises Stimmchen
-auratisch;Aura besitzend
-Popkultur;Populärkultur
-Hohlbeitel;Hohleisen
-ich meine nur (ugs.);das wollte ich nur mal gesagt haben (ugs.);ist nicht (so ganz) ernst gemeint (ugs.)
-Drechselbeitel;Dreheisen
-Wagnerei;Stellmacherei
-bösartig (Lächeln);höhnisch (Lächeln);mokant (Lächeln);boshaft (Lächeln);Augurenlächeln (geh.);hämisch (Lächeln);sardonisch (nur in Verbindung mit lächeln);voller Spottlust (Lächeln);spöttisch (Lächeln)
-Zapfenverbindung;Verzapfung
-Auskulator (süddt.);Auskultant (österr.);Auskultator
-Abdampfen;Eindampfen
-Prätorianergarde;Prätorianer
-Anliegerstaat;Nachbarland;Anrainerstaat
-Gewerbekammer;Kommerzkammer;Handelsdeputation;Handelskammer
-geringfügig;leicht;dezent
-Was kann ich für Sie tun?;Womit kann ich dienen?;Kann ich helfen?;Kann ich etwas für Sie tun?;Was kann ich Ihnen antun? (ironisch, salopp) (ugs.);Wie kann ich helfen?
-Tiberiassee;Galiläisches Meer;See von Tiberias;See Genezareth
-Binnensee;Groß Radener See
-Sternberger Seenlandschaft;Sternberger Seenplatte
-(sich) auflösen;auseinandergehen
-Originaldokument;Quelle;Beleg
-Transsilvanische Alpen;Südkarpaten
-Bioschmierstoff;biogener Schmierstoff;Bioöl
-Euroblume;Europäisches Umweltzeichen
-blauer Umweltengel;blauer Engel
-Umweltkennzeichen;Ökolabel;Umweltzeichen
-Prüfsiegel;Prüfzeichen
-Zwischenfall von Hull;Doggerbank-Zwischenfall
-Neokonservativismus;Neokonservatismus
-Handelshemmnis;Handelsbarriere
-Karbonat;Carbonat (fachspr.)
-Kohlensäureester;Carbonate
-Kohlenstoffdioxidsenke;CO2-Senke;CO₂-Senke;Kohlenstoffsenke
-oder so (ugs.);praktisch (ugs.);in etwa;so(was) in der Art (ugs.);(so) quasi (ugs.);sozusagen;so ungefähr (ugs., Hauptform);irgendwie (ugs.);sone Art (ugs.);keine Ahnung (ugs.);mehr oder weniger;könnte man sagen;im Großen und Ganzen;sowas wie (ugs.)
-Gleichstrommotor;Kommutatormaschine;Gleichstrommaschine;Kommutatormotor
-Hauptschlussmaschine;Reihenschlussmotor;Reihenschlussmaschine
-Allstrommotor;Universalmotor
-Grottenburg;Höhlenburg
-Leuchtkennzeichen;selbstleuchtendes Nummernschild
-Echtzeituhr;physikalische Uhr
-Traktionsbatterie;Zyklenbatterie;Antriebsbatterie;Traktionsakku
-Solarakkumulator;Solarbatterie;Solarakku
-Bleiakku (Kurzform);Bleiakkumulator
-Griffstücksicherung;Handballensicherung;Griffsicherung
-Inn-Salzach-Stil;Inn-Salzach-Bauweise
-Französisch-Westindien;Französische Antillen
-unixähnliches System;unixartiges System;unixoides System
-Geländefolgeradar;Bodenfolgeradar (selten);Terrainfolgeradar
-Terrainfolgeflug;Geländefolgeflug;Konturenflug
-U-Boot (fig.);Maulwurf (fig.);undichte Stelle (fig.);verdeckter Ermittler
-Prepress;Druckvorstufe
-Druckwesen;polygraphisches Gewerbe
-Abtaster;Scanner
-Canicula;Hundsstern;Sirius;Aschere
-Doppelsternsystem;Doppelstern
-Mehrfachsystem;Mehrfach-Sternsystem;Mehrfachstern
-bedeckungsveränderlicher Stern;photometrischer Doppelstern
-Sperrfrist;Embargo (schweiz.)
-Sperrfrist;Schutzfrist
-Zugriffskontrollliste;Zugriffssteuerungsliste
-in Dienst stellen;in Betrieb nehmen;starten;in Betrieb setzen;hochfahren (Gerät, Anlage, Produktion);anfahren
-Detektiv;Privatermittler;Privatdetektiv;Berufsdetektiv (österr.)
-Mord im Dunkeln;Mörder und Detektiv
-Michell-Turbine;Querstromturbine;Bánki-Turbine;Durchströmturbine;Ossberger-Turbine
-räumliches Sehen;stereoskopisches Sehen;Stereopsis (fachspr.)
-Abwärtswandler;Tiefsetzsteller;Abwärtsregler
-Koaxkabel;Koaxialkabel
-Seele;Innenleiter
-Gütefaktor;Schwingkreisgüte;Güte;Kreisgüte;Polgüte;Resonanzschärfe;Q-Faktor
-Superhet (Kurzform);Überlagerungsempfänger;Super (Kurzform);Superheterodynempfänger
-elektrische Ladung;Elektrizitätsmenge
-kaum verschlissen (sein);(noch) gut erhalten (sein);(noch) gut in Schuss (sein) (ugs.)
-BRD (Abkürzung);Bundesrepublik;Bundesrepublik Deutschland (offiziell);Bunzreplik (ugs., Verballhornung);Deutschland (Hauptform);Westdeutschland (veraltet)
-Zar (russisch);Kaiser;Imperator (lat.);Tenno (japanisch);Augustus (lat., römisch);Caesar (lat., römisch);Cäsar (lat.)
-Deutsch-Französischer Krieg;Siebziger Krieg
-Kaiserreich Russland;Russisches Kaiserreich;zaristisches Russland;Russisches Zarenreich
-Russland (Hauptform);Russerei (derb, veraltet);Reußen (veraltet)
-Königreich Italien;Reichsitalien
-Königreich;Königtum;Khanat (mongolisch)
-Empire (engl., franz.);Kaisertum;Imperium (lat.);Kaiserreich
-Werkhof (schweiz.);Straßenmeisterei
-Opferrente;Opferpension
-Ehrensold (für Bundespräsident, Bundeskanzler) (Amtsdeutsch, bundesdeutsch);Pension (bundesdeutsch);Ruhegenuss (Amtsdeutsch, österr.);Beamtenpension (Hauptform)
-Playa (fachspr.);Salztonebene
-Afar-Senke;Afar-Dreieck;Danakil-Senke
-Lamellenverschluss;Zentralverschluss
-großmächtig;sehr mächtig
-Papst-Primat;Primat des Papstes;Petrus-Primat
-heißes Eisen (ugs., fig.);brisantes Thema
-Verlegenheitsprogramm;Füllsel;Pausenfüller (Hauptform)
-Ausfallpforte;Ausfalltor
-sphärische Aberration;Öffnungsfehler;Kugelgestaltsfehler
-optische Verzerrung;Verzeichnung
-Abbildungsgleichung;Linsengleichung
-geometrische Optik;Strahlenoptik
-Technopark;Technologiepark
-PVC (Abkürzung);Polyvinylchlorid
-Acrylglas (ugs.);organisches Glas (ugs.);Plexiglas (ugs., Markenname);PMMA (Abkürzung);Poly(methyl-2-methylpropenoat) (fachspr., chemisch);O-Glas (ugs.);Polymethylmethacrylat (fachspr., chemisch)
-Gellertstadt;Hainichen
-5/8-Schluss;Fünf-Achtel-Schluss;Fünfachtelschluss
-Chor;Presbyterium
-Afghanischer Windhund;Afghane
-Afghane;Bürger Afghanistans
-Discounter;Billiganbieter;Billigheimer (ugs.);billiger Jakob (ugs.);Diskonter (österr.);Niedrigpreis-Anbieter
-Australisches Bergland;Australische Kordillere;Großes Australisches Scheidegebirge
-Wackler;kopfbewegter Scheinwerfer;Wackeleimer;Wackellampe
-Dichroismus;Zweifarbigkeit
-Saurer Most;Apfelwein;Apfelmost;Viez (ugs., regional);Äbbelwoi (ugs., hessisch);Ebbelwoi (ugs., hessisch);Most (ugs., regional, süddt.)
-Obstwein;Fruchtwein
-Synkategorem (fachspr.);Synsemantikum (fachspr.);Funktionswort (fachspr.)
-Granatkartätsche;Schrapnell
-Torsionsstab;Drehstab;Drehstabfeder
-Nordböhmisches Becken;Teplitz-Komotauer Becken (veraltet)
-Aussig-Massaker;Massaker von Aussig
-Vollbart;Knasterbart (ugs.);Rauschebart (oft iron.) (ugs.)
-Röster (österr.);Espresso
-Profikiller;Auftragsmörder (Hauptform);Assassine (geh., veraltet);gedungener Mörder (geh., veraltet);Auftragskiller;Berufskiller;Killer;Hitman (engl.)
-Totschläger (Hauptform);Todesschläger
-Teleskopschlagstock;Teleskopabwehrstock (fachspr.);Totschläger (ugs., Hauptform)
-blanke Waffe;Blankwaffe
-Ochsenziemer;Munifisel (schweiz.);Ochsenpesel (regional);Ochsenfiesl (regional);Hagenschwanz (regional);Farrenschwanz (regional)
-Flächenmaß;Flächenmaßeinheit;Flächeneinheit
-Proporzwahl (schweiz.);Verhältniswahl
-Wahlsystem;Wahlverfahren
-Börsennotierung;Börsennotiz;Kotierung (schweiz.);Listing (engl.)
-Delisting (engl.);going private (engl.);Börsenrückzug;Börsenabgang
-nichts überstürzen;Nur ned hudle. (ugs., schwäbisch);Aus der Ruhe kommt die Kraft. (ugs., Sprichwort);Eile mit Weile. (Sprichwort);In der Ruhe liegt die Kraft. (ugs., Sprichwort)
-Knopfkanüle;Spülkanüle
-Sommerfrische (veraltend);Sommerferien;Sommerurlaub
-Dodo;Raphus cucullatus (zool.) (fachspr.);Dronte
-Wellness-Einrichtung;Wellness-Oase;Wellnessoase;Beauty-Farm;Wellness-Tempel (ironisch);Beautyfarm;Wellnessfarm;Wellnesshotel;Wellnesszentrum;Wellnesscenter;Schönheitsfarm
-fertig werden (ugs.);seine Schulbildung abschließen;seinen Abschluss machen (ugs.);mit der Schule fertig werden;seinen Schulabschluss machen;den Abschluss machen (ugs.);seine Schulausbildung abschließen
-Volksprosa-Forschung;Erzählforschung
-Erzähltheorie;Erzählforschung;Narrativik (fachspr., lat.)
-angewandte Linguistik;angewandte Sprachwissenschaft
-frischgebacken;frisch gebacken;gerade fertig geworden;neu im Amt
-Retardierung;Retardation
-Verzögerungsplatte;Wellenplatte
-verzögertes Potential;retardiertes Potential
-Lenz'sche Regel;Lenzsche Regel;Lenz'sches Gesetz;Regel von Lenz
-alles stehen und liegen lassen;überstürzt abfahren;Hals über Kopf aufbrechen (ugs.)
-Daktylologie;Fingersprache;Fingeralphabet
-entscheidendes Ereignis;wichtiger Schritt nach vorne (fig.);Meilenstein (fig.);entscheidender Schritt vorwärts (fig.);Wendepunkt (fig.);wichtiger Zwischenschritt
-Bildverstärker;Restlichtverstärker
-Bolometer;bolometrischer Detektor
-Trägheitskraft;Scheinkraft
-Druckratsche;Kurzhebelratsche
-Langhebelratsche;Zugratsche
-O'Neill-Kolonien;O'Neill-Zylinder
-Kelvin-Generator;Kelvinscher Wassertropfengenerator
-Bittbrief;Bettelbrief;Bittschreiben
-Zaungast (fig.);Nebenfigur;Randfigur
-Nebenrolle;Charge
-ehern (geh., fig.);für die Ewigkeit (festgeschrieben, bestimmt, gemacht o.ä.);eisern (Regel) (fig.);in Stein gemeißelt (fig.);unumstößlich;in Beton gegossen (fig.)
-(eine) Inflation (an/von);Überhandnehmen;unkontrollierte Vermehrung;übermäßiger Gebrauch
-Protestler;Wutbürger (neu seit 2010) (Schlagwort, negativ);Protestbürger;Protestierende(r)
-Kleinkrieg (ugs.);Hakeleien;Gezanke;Gezerre (um);Streiterei;Streitigkeiten;Gerangel;Gezänk;Reibereien
-Garbe;Getreidebündel;Strohbündel
-Maschinengewehrsalve;Salve;MG-Salve;Gewehrsalve;Garbe;Feuerstoß
-korrelative Hypertrophie;endokrine Hypertrophie
-Aktivitätshypertrophie;Arbeitshypertrophie
-Mitochondrien (fachspr., Plural);Chondriosomen (fachspr., Plural);Mitochondrion (fachspr.);Mitochondrium (fachspr.)
-Synzytium;Coenoblast;Coenocyt
-motorische Endplatte;neuromuskuläre Endplatte
-motorisches Neuron;Motoneuron
-Einstandspreis;Beschaffungspreis;Bezugspreis
-Altarssakrament;Herrenmahl;Tisch des Herrn;Abendmahl;Eucharistie;allerheiligstes Sakrament;heilige Kommunion;Kommunion
-den (ganzen) Widersinn (einer Sache) vor Augen führen;bis zur Lächerlichkeit steigern;den (ganzen) Widersinn (einer Sache) aufzeigen;ad absurdum führen;den (ganzen) Widersinn (einer Sache) zeigen;lächerlich machen
-Demobilisierung;Demobilisation
-Kollaboration;enge Kooperation
-für wichtig erachten;für wichtig nehmen;großschreiben (ugs.)
-Provokateur (franz.);böser Bube (fig.);Enfant terrible (geh., fig., franz.);Bürgerschreck
-Schneemensch;Yeti
-(sich) klar ausdrücken;ankommen;zu verstehen sein;(sich) verständlich machen
-Wildbrücke;Grünbrücke
-Reptil (fachspr., Hauptform, lat.);Reptilie (ugs.);Kriechtier
-Flächenzerschneidung;Freiraumzerschneidung;Landschaftszerschneidung
-verschwenderisch;üppig;(ein) Füllhorn an (fig.);in Hülle und Fülle;im Überfluss;über die Maßen;überreichlich
-Sie wünschen?;Was möchten Sie?;Was darf es sein?;Womit kann ich dienen?;Was bekommen Sie?;Wat nehm' wer? (ruhrdt.)
-Sezession;Ablösung;Trennung;Absonderung;Abspaltung (von einem Staat);Sekretion;Loslösung
-(jemanden) abwatschen (ugs., bayr.);(jemandem) eine schmieren (ugs.);(jemandem) eine scheuern (ugs., bundesdeutsch);(jemandem) eine (he)runterhauen (ugs.);(jemandem) eine kleben (ugs., bundesdeutsch);(jemandem) eine knallen (ugs.);(jemandem) eine langen (ugs.);(jemanden) ohrfeigen;(jemandem) eine schallern (ugs., bundesdeutsch);(jemandem) eine klatschen (ugs.);(jemandem) eine auflegen (ugs., österr.);(jemandem) eine kleschen (ugs., österr.);(jemandem) rutscht die Hand aus (ugs., Redensart, fig.);(jemandem) eine picken (ugs., österr.);(jemandem) eine Maulschelle verpassen (bundesdeutsch, veraltend);(jemandem) eine Ohrfeige geben (Hauptform);(jemandem) rechts und links eine (he)runterhauen (ugs.);(jemandem) eine runterhauen (ugs.)
-Epikureer (geh.);Lebenskünstler;Genussmensch;Genießer;Hedonist
-Ziehsohn;Pflegesohn;Stiefsohn
-gottgläubig sein;glauben;einen Glauben haben;religiös sein;gläubig sein;an Gott glauben
-verbindungsprogrammierte Steuerung;festverdrahtete Steuerung (ugs.);festverdrahtete Logik (ugs.);VPS
-Kleidervorschrift;Dress-Code;Dresscode (engl.);Kleiderordnung (auch figurativ);Bekleidungsvorschrift(en);Anzugsordnung (fachspr., militärisch)
-Kokosnusspalme;Cocos nucifera (fachspr., lat.);Kokospalme
-Palme;Palmae (fachspr., Plural, botanisch);Palmengewächs;Arecaceae (fachspr., Plural, botanisch)
-Einkeimblättrige;Monokotyledonen
-Magnoliopsida;Bedecktsamer;Angiospermen (veraltet);bedecktsamige Pflanze;Magnoliophyta (veraltet)
-Kokosplantage;Kokosnussplantage
-Taucherin;Froschfrau (ugs.)
-logische Tiefe;algorithmische Tiefe
-edieren;(wissenschaftlich) herausgeben
-verlegen;editieren;herausgeben;publizieren;veröffentlichen
-Special-Encyklopädie;Specialencyklopädie;Partikular-Encyklopädie;Partikularenzyklopädie;Spezialenzyklopädie
-Einzelwissenschaft;Fachwissenschaft;Fachdisziplin
-Wehrgeld;Friedegeld;Wiedergeld;Manngeld;Wergeld;Compositio (lat.);Weregildus;Mutsühne
-Orden des heiligen Konstantin;Konstantinorden;Religiöser und Militärischer Constantinischer St.-Georgs-Orden;Konstantinischer Georgsorden für Militärverdienst;Constantinischer Orden
-Golgatha;Golgota;Golgotha
-Schafott;Blutgerüst;Schaugerüst (veraltet)
-verbesserungsfähig;verbesserungswürdig;korrekturbedürftig
-Phosphodiesterase-5-Hemmer;Phosphodiesterase-V-Hemmer;PDE-5-Hemmer
-Erektionsstörung;Potenzstörung;erektile Dysfunktion;Impotentia coeundi (lat., veraltet);Impotenz (ugs.)
-Petrolchemie;Petrochemie
-Banlieue (franz.);Außenbezirk;Vorort;Vorstadt
-Problemviertel;schlechte Wohngegend;sozialer Brennpunkt;Problembezirk
-Unterschichtsangehöriger;Angehöriger der Unterschicht;Vertreter der Unterschicht;Unterschichtler;in prekären Verhältnissen Lebender;Proletarier
-Universitätskrankenhaus;Universitätsklinikum;Uniklinik
-Kranio-Maxillo-Faziale Chirurgie;MKG;Mund-, Kiefer- und Gesichtschirurgie
-Frischzellenkur;Zellular-Therapie;Frischzellentherapie;Organo-Therapie
-Lehrkrankenhaus;Akademisches Lehrkrankenhaus
-Hypnosedierung;Hypnosedation
-Alpendollar (ugs.);Schilling
-sagen Sie mal! (ugs.);entschuldigen Sie mal! (ugs.);entschuldige mal! (ugs.);ich muss doch sehr bitten! (ugs.);ich bitte dich! (ugs.);ich darf doch sehr bitten! (ugs.);(also) hören Sie mal! (ugs.);ich bitte Sie! (ugs.)
-heiliger Georg;Drachentöter
-Verlotterung;Verwahrlosung;Niedergang
-herumsumpfen (ugs.);herunterkommen (Person) (Hauptform);ganz unten ankommen (ugs., fig.);Sozialfall werden;in der Gosse landen (fig.);in der Gosse enden (fig.);versacken (ugs.);runterkommen (ugs.);verkommen;tief sinken (fig.);sozial absteigen;unter die Räder kommen (fig.);abgewirtschaftet haben;verschlampen (ugs.);verwahrlosen;verlottern;auf den Hund kommen (ugs.);versumpfen (ugs., fig.);verelenden;vergammeln
-unangenehme Erkenntnis;(eine) kalte Dusche (ugs., fig.);(ein) böses Erwachen;(eine) Konfrontation mit der Wirklichkeit;Realitäts-Schock
-parsevalsche Gleichung;Abgeschlossenheitsrelation
-idealer Tiefpass;si-Filter;Küpfmüller-Tiefpass
-Prähilbertraum;prähilbertscher Raum;Skalarproduktraum;Innenproduktraum;Vektorraum mit innerem Produkt
-Marterl (bayr.);Flurkreuz;Wegekreuz;Kreuz;Wegkreuz
-abergläubisch;abergläubig (veraltet)
-deinetwegen;wegen deiner (veraltet);wegen dir (ugs.)
-ihrethalben (veraltend);wegen ihr (ugs.);ihretwegen
-(sich) nicht aus der Fassung bringen lassen;(so leicht) nicht zu erschüttern (sein);durch nichts zu erschüttern (zu bringen);durch nichts aus der Fassung zu bringen sein;die Contenance wahren (geh., franz.);die Ruhe weghaben (ugs.)
-Meinhardiner;Görzer;Grafen von Görz
-(über Generationen) einflussreiche Familie;Familie mit einem großen Namen;Familienclan;Dynastie;Clan;Familiendynastie
-Dynastie;Herrscherdynastie
-Historiografie;Geschichtsschreibung;Historiographie
-Intrusion;Eindringen
-Transsexualismus;Transsexualität;Leben im falschen Körper (ugs.)
-Intersexualität;Sexualdifferenzierungsstörung
-Habelschwerdter Weistritz;Kressenbach
-Hyposomie (fachspr.);Minderwuchs
-Östrogen;Estrogen
-Gelbkörperhormon;Gestagen;Schwangerschafthormon
-hCG;humanes Choriongonadotropin
-Proteohormon;Peptidhormon
-luteinisierendes Hormon;Lutropin
-follikelstimulierendes Hormon;Follitropin
-physikalische Modellierung;PM-Synthese
-Tonerzeugung;Schallerzeugung;Klangerzeugung
-Frequenzmodulationssynthese;FM-Synthese
-Zwischenmahlzeit (Vormittag);Gabelfrühstück;Brunch;Znüni (ugs.);zweites Frühstück
-sättigen;saturieren
-Sozialhelfer;Fürsorge (ugs.);Sozialarbeit
-Fürsorger;Sozialklempner (derb);Sozialarbeiter
-Lambert-W-Funktion;lambertsche W-Funktion;Omegafunktion
-Zentralpunkt;Fundamentalpunkt
-Messpunkt;Vermessungspunkt
-Wellenreiter (fig.);Radiohörer
-Radiomacher;Radiofrau;einer vom Radio;Radiomann;Rundfunkjournalist (veraltend)
-Staatsschulden;Staatsverschuldung
-Niederes Gesenk;Niederes Gesenke;Mährisches Gesenke
-Oppagebirge;Zuckmanteler Bergland
-Preismanagement;Preispolitik
-Verbundertrag;Verbundvorteil;Verbundeffekt
-Oligopson;Nachfrageoligopol
-Abschöpfungsstrategie;Skimmingstrategie
-generische Strategien;Wettbewerbsmatrix
-Schriftrichtung;Schreibrichtung
-libysche Schrift;numidische Schrift;altlibysche Schrift
-Erdefunkstelle;Relaisstation;Erdfunkstelle
-Umsetzer;Relaisstelle;Funkfeldverstärker (fachspr.);Relais;Relaisstation;Repeater;Relaisfunkstelle
-Heimatforscher;Heimatkundler
-moselfränkischer Dialekt;Moselfränkisch
-Ganzheitliche Medizin;Ganzheitsmedizin
-lineare Optimierung;lineare Programmierung
-Tränchen (abwertend);Zähre (veraltet);Träne (Hauptform)
-Rundfunkgebühr;Rundfunkbeitrag
-genetisches Geschlecht;Geschlecht
-ADFC (Abkürzung);Allgemeiner Deutscher Fahrrad-Club
-Drohn (fachspr.);Drohne;männliche Honigbiene
-Klassleiter (bayr.);Klassenvorstand (österr.);Klassenleiter (bayr.);Klassenlehrer
-nicht auszudenken! (ugs.);(jemand / etwas) hätte (mir) gerade noch gefehlt! (ugs.);hoffentlich nicht! (ugs.);Gott behüte! (ugs., religiös, veraltet);um Gottes willen! (ugs.);um Himmels willen (nein)! (ugs.);das fehlte noch! (ugs.);mal den Teufel nicht an die Wand! (ugs., sprichwörtlich);Himmel nein! (ugs.);da sei ... vor! (auch ironisch, variabel);Gott bewahre! (ugs., veraltet);das wollen wir nicht hoffen! (ugs.);das will ich nicht hoffen! (ugs.);bloß nicht! (ugs., ironisch);alles, nur das nicht! (ugs.)
-symmetrischer Satz;axialer Satz;Mittelachsensatz;zentrierter Satz
-Flattersatz;asymmetrischer Satz;anaxialer Satz
-Lichtsatz;Fotosatz
-Traurigkeit heucheln;(sich) ein paar Tränchen verdrücken (ugs.);(den) Traurigen mimen (ugs.);auf traurig machen (ugs.);Krokodilstränen vergießen (ugs., Hauptform);Krokodilstränen weinen (ugs.)
-Segler (ugs.);Segelboot
-Laufschrift;Laufzeile;Lauftext;Laufband;Ticker
-Phonothek;Schallarchiv
-Neuklassizismus;Neoklassizismus
-steigender Bogen;Schwanenhals;einhüftiger Korbbogen;geschwungener Bogen;Spannbogen;strebender Bogen;Hüftbogen;Hornbogen;fallender Bogen
-falscher Bogen;Kragbogen
-Kragsteingewölbe;Kraggewölbe;falsches Gewölbe
-Giebelbogen;Dreiecksbogen
-Kreisbogen;Rundbogen
-Kragsturzbogen;Schulterbogen;Konsolbogen
-Akkolade;Eselsrücken;Sattelbogen;schottischer Bogen;Kielbogen
-Hufeisenbogen;arabischer Bogen;maurischer Bogen
-Kleeblattbogen;Dreipassbogen
-Glockenleiste;Karnies
-Kapitäl (veraltet);Kapitell
-Sims;Gesims
-Silikatglas;Bauglas
-Glasbaustein;Glasstein
-normannischer Bogen;Tudorbogen;englischer Spitzbogen
-(es) besser lassen (ugs.);(sich) um seine (eigenen) Sachen kümmern;(sich) um seinen Kram kümmern (ugs.);(sich) raushalten (ugs.)
-unvorsichtig genug sein, zu;unklug genug sein, zu;so unvorsichtig sein, zu;(sich dazu) hergeben (Hauptform);nichts dabei finden (ugs.);so unklug sein, zu;(sich) (von jemandem) einspannen lassen (zu / für);dumm genug sein, zu (ugs.);(sich) nicht zu schade sein (für) (ugs.);(sich) nicht entblöden (zu) (geh.)
-nicht eingeweiht;nicht berücksichtigt (werden);außen vor (ugs.);nicht beteiligt;aus dem Spiel (ugs., fig.);nicht einbezogen;nicht dabei;nicht mit von der Partie (ugs.);draußen (ugs., fig.);unberücksichtigt (bleiben);ausgeschlossen;rausgeflogen (ugs.);ausgegrenzt
-einjährige Pflanze;annuelle Pflanze
-PC-Netzteil;Computer-Netzteil
-(körperlich) fit;durchtrainiert;fit wie ein Turnschuh (ugs.);sportlich;sportiv (auch iron.) (geh.);athletisch;trainiert;nur aus Muskeln bestehend
-(bloßes) Vollzugsorgan;(lediglich) ausführende Instanz
-(die) Zeit läuft (jemandem) davon;eng werden (für jemanden, es);in Bedrängnis geraten;knapp werden
-Coffein;Koffein;Thein;Tein
-Gründungsmitglied;von Anfang an dabei;Mann der ersten Stunde;alte Garde;Gründervater;Urgestein (fig.);(noch) einer von den ersten
-dicke Brille;Glasbausteine (ugs., ironisch)
-Ticker;Nachrichtenticker;Newsticker;Liveticker;Live-Ticker (engl.)
-wie ausgewechselt sein (ugs.);nicht mehr derselbe sein;(sich) stark verändert haben;nicht mehr wiederzuerkennen sein (ugs.);völlig verändert sein
-auftanken;den Tank füllen;betanken;den Tank auffüllen;mit Kraftstoff befüllen;tanken
-Strunztuch (ugs., ruhrdt.);Kavalierstuch;Pochette (franz.);Stecktuch;Einstecktuch
-Amateurfunkdienst;Amateurfunk
-Längswelle;Longitudinalwelle
-Scherwelle;Transversalwelle;Querwelle;Schubwelle
-Erdbebenwelle;seismische Welle
-Seismik;Geoseismik
-Machstamm;Mach-Reflexion;Machwelle;Machstammeffekt;Machfrontseite;Mach-Effekt
-herumprobieren;tüfteln;bosseln (an) (ugs.);friemeln (ugs.);fummeln (ugs.);frickeln (ugs.)
-Rotlichtbezirk;Milieu;Sündenmeile;Amüsierviertel;Vergnügungsviertel;Rotlichtviertel
-Lufthansa-Mitarbeiter;Lufthanseat
-Hoffnungsträger;Erleuchteter (geh.);Erlöser(figur);Retter aus höchster Not;Lichtgestalt;Erretter;Heilsbringer
-Mädchen aus besserem Hause;(junge) Frau aus gutbürgerlichen Verhältnissen;höhere Tochter (veraltend)
-Stieglitz;Distelfink
-Coulombsche Reibung;Festkörperreibung;Äußere Reibung
-rollende Reibung;Rollreibung;Rollwiderstand
-Rollreibungsbeiwert;Rollwiderstandskoeffizient;Rollwiderstandsbeiwert
-Rentenzugangsalter;Renteneintrittsalter;Pensionsalter;Rentenalter;Pensionsantrittsalter (österr.)
-(das) Unmögliche wollen;versuchen, einen Pudding an die Wand zu nageln (ugs.)
-nichts in den Händen haben;(etwas) nicht beweisen können;keine Handhabe haben (gegen)
-Fernsehsendung;TV-Sendung
-heute ist der erste Januar;wir schreiben den ersten Januar;wir haben den ersten Januar;heute haben wir den ersten Januar;es ist der erste Januar
-Lehre der romanischen Sprachen und Literaturen;Romanische Philologie;Romanistik (Hauptform)
-Gott versuchen (relig.);(es) darauf ankommen lassen;alles auf eine Karte setzen;aufs Ganze gehen;alles riskieren (ugs.);(es) wissen wollen (ugs.);(sein/das) Schicksal herausfordern;alles verlieren können (ugs.);volles Risiko fahren (ugs.);alles aufs Spiel setzen
-nur Geduld! (ugs.);das werden wir ja sehen! (ugs.);wart's (nur) ab! (ugs.);du wirst schon sehen(, was passiert)! (ugs.)
-Flurförderzeug (Norm-Sprache) (fachspr.);Flurfördermittel (Norm-Sprache) (fachspr.);Flurfördergerät (Norm-Sprache) (fachspr.);Gabelstapler (ugs., Hauptform);Flurförderfahrzeug (fachspr.)
-Meise (elektr.);Hubwagen;Ameise (elektr.)
-Kestigung (mittelalterlich);Kasteiung;Selbstkasteiung
-Lerninhalt;Lernstoff;Lehrstoff;Unterrichtsstoff;Stoff
-Fiskalpakt;Europäischer Fiskalpakt;Fiskalunion;Europäische Fiskalunion;SKS-Vertrag;Vertrag über Stabilität, Koordinierung und Steuerung in der Wirtschafts- und Währungsunion (fachspr.)
-Edeltanne;Edel-Tanne;Pazifische Edel-Tanne;Silbertanne
-Kaiserreich Korea;Groß-Korea
-Westamerikanische Hemlocktanne;Westliche Hemlock
-Tsuga (fachspr., botanisch);Hemlocktanne;Schierlingstanne
-Nordvietnam;Demokratische Republik Vietnam
-Republik Vietnam;Südvietnam
-NS-Zeit;Zeit des Nationalsozialismus
-Antarktisches Inlandeis;Antarktischer Eisschild
-Pixelgrafik;Rastergrafik
-Panmyelophthise;Panmyelopathie;aplastisches Syndrom;aplastische Anämie
-Bleichsucht (veraltet);Eisenmangelanämie (fachspr.);Eisenmangel (ugs., Hauptform)
-Sideropenie;Eisenmangel
-Katalanischer Nationalismus;Katalanismus
-Blütezeit (Hauptform);Blust (süddt.);Blüte;das Blühen
-zeitlich befristete Forderung;Ultimatum
-Hubstapler;Gabelstapler
-Ofenküchlein (schweiz.);Windbeutel;Brandteigkrapferl (österr.)
-Brandmasse (fachspr.);Brühmasse;Brandteig
-Pietà;Pieta;Vesperbild
-Putzfäden;Putzlumpen;Putzwolle
-Yukatekisches Maya;Mayathan
-Inkongruenz;Unvereinbarkeit
-Arabischer Golf;Persischer Golf
-Arabien;Arabische Halbinsel
-Haschimiten;Haschemiten
-Irak-Iran-Krieg;Erster Golfkrieg;Iran-Irak-Krieg
-Erster Irakkrieg;Zweiter Golfkrieg
-Irakkrieg;Zweiter Irakkrieg
-Buddhas Hand;Fingerzitrone
-Zitrone;Citrone;Limone
-(jemanden) auf den Plan rufen;(jemanden) in Aktion treten lassen;(jemanden) in Erscheinung treten lassen;zum Handeln veranlassen;aktiv werden lassen;(jemanden) veranlassen, aktiv zu werden
-flüssige Intelligenz;fluide Intelligenz
-kristalline Intelligenz;kristallisierte Intelligenz
-plenoptische Kamera;Lichtfeldkamera
-dahindämmern;herumkrebsen (ugs.)
-Limo (ugs.);Limousine
-(jemandem) seinen Willen aufzwingen;(jemandes) Widerstand brechen;(jemandes) Willen beugen (geh.);gefügig machen (ugs.);(jemanden) kleinkriegen
-Golf von Anadyr;Anadyrgolf
-Beringsee;Beringmeer
-Golf von Ambrakia;Ambrakischer Golf
-Rigaischer Meerbusen;Rigaer Meerbusen;Rigaer Bucht
-Golf von Volos;Pagasäischer Golf
-Maliakos-Bucht;Golf von Maliakos;Golf von Malia;Malischer Golf
-Ägäische Mikroplatte;Ägäische Platte;Hellenische Platte
-Adriatische Platte;Adriatischer Indenter;Adriasporn
-Eggegebirge;die Egge
-Fernverkehrsstraße;Fernstraße
-Cisalpinische Republik;Zisalpinische Republik
-Cispadanische Republik;Zispadanische Republik
-Habsburgerreich;Habsburgische Monarchie;Habsburger Monarchie;Habsburgisches Reich;Habsburgermonarchie
-Hexenkraut;Schwarzes Bilsenkraut
-Fjord;Förde
-Meeralpen;Seealpen
-Donautalbahn;Donaubahn
-Zellertalbahn;Pfrimmtalbahn
-Turkistan;Turkestan;Türkistan
-Kaspisee;Kaspisches Meer
-Wüste Gobi;Gobi;Wüste Schamo (veraltet);Schamo (veraltet)
-Anderkonto;Treuhandanderkonto
-Rodna-Gebirge;Rodnaer Gebirge
-Gipfelstock;Massiv;Gebirgsstock;Gebirgsmassiv;Massengebirge
-psychoaktive Substanz;psychotrope Substanz;Psychotropikum
-Bürolandschaft;Großraumbüro
-Reichsgraf;Gefürsteter Graf
-niederrheinisch-westfälisches Reichsgrafenkollegium;westfälische Grafenbank
-Wetterauisches Reichsgrafenkollegium;Wetterauer Grafenverein;Wetterauische Grafenbank
-schwäbisches Reichsgrafenkollegium;schwäbische Reichsgrafenbank
-Fürstenbank;Reichsfürstenrat
-fränkisches Reichsgrafenkollegium;fränkische Grafenbank
-Bursfelder Union;Bursfelder Kongregation
-Eplax;Elektroplax
-Zitterwels;Elektrischer Wels
-Waller (regional);Flusswels;Europäischer Wels;Schaidfisch (regional)
-Torpedorochen;Elektrischer Rochen;Zitterrochen
-Paul-Bert-Effekt;Neurotoxischer Effekt
-Höhenfreiheit;Kreuzungsfreiheit;Planfreiheit;Niveaufreiheit
-Hundsrücken (veraltet);Fichtlichzug (veraltet);Reichensteiner Gebirge
-Ablauf;Story;Handlung;Handlungsgerüst;Plot;Handlungskern
-Achterbahn(fahrt) der Gefühle (fig.);Wechselbad der Gefühle;emotionale Achterbahn(fahrt) (journal.);Auf und Ab der Gefühle
-Schwankungen;Wechsel;Aufs und Abs (ugs.)
-himmelhoch jauchzend, zu Tode betrübt;psychisch instabil;psychisch labil
-Grundherrschaft;Erbuntertänigkeit (österr.);Patrimonialherrschaft (österr.)
-Villikation;Hofverband
-Freieigentum;Allod;Allodialbesitz;Eigengut;Erbgut;freies Eigen
-Französisch-Flandern;Südflandern
-Montanunion;Europäische Gemeinschaft für Kohle und Stahl;EGKS (Abkürzung)
-Brüsseler Pakt;Westunion
-Intensitätsstereofonie;Pegeldifferenzstereofonie
-Symlink;Softlink;symbolische Verknüpfung;symbolischer Link
-auf die Folter spannen;schmoren lassen (fig.);in Atem halten;zappeln lassen (fig.)
-herankommen (an);Zugriff haben (auf);erreichen;herankönnen (an)
-aufhören;(den) Griffel fallen lassen (fig.);Feierabend machen;für heute war's das (Spruch);Schluss machen;(es ist) Schicht im Schacht (ugs., Spruch)
-Gegenkolbenmotor;Gegenläufermotor;Gegenlaufmotor;Gegenläufer (Kurzform)
-Dasselfliege;Biesfliege
-Knochenbrecherfieber;Denguefieber;Dandy-Fieber
-Serovar;Serotyp
-Gammaglobulin (veraltet);Antikörper;Immunglobulin;Immunoglobulin
-Immunbiologie;Immunologie
-Immunzelle;Immunozyt
-B-Lymphozyt;B-Zelle
-T-Zelle;T-Lymphozyt
-Textdichter;Liedtexter;Singer-Songwriter (engl.);Liedermacher
-Normalatmosphäre;Standardatmosphäre;Normatmosphäre
-Luvwinkel;Vorhaltewinkel
-Anerkennungsjahr;Berufsanerkennungsjahr;Berufspraktikum
-(mit jemandem) auf Du und Du stehen (auch figurativ);(mit jemandem) per Du sein;Du zueinander sagen;(sich) duzen
-Einkochglas;Einweckglas;Einmachglas;Weckglas
-Sinkhöhle;Doline;Karsttrichter
-Einbezogensein (in / bei);Involviertheit (in);Beteiligtsein (bei);Eingebundensein (in);Verstrickung (in) (negativ)
-bewirtschaften;betreiben
-Mitgiftjäger;Heiratsschwindler
-Fühlbarkeit;Taktilität
-keine Statur;kein Format;nichts dahinter (ugs.);kein Standing;keine Präsenz;nichts drauf haben(d) (ugs.)
-Klitsche (ugs., abwertend);Saftladen (ugs., abwertend);Bude;Budike (ugs., berlinerisch);Laden (leicht abwertend);Kleinbetrieb
-Schnee schippen (ugs.);Schnee räumen
-Hungerbrunnen;Hungerquelle
-Testbetrieb;Musterbetrieb;Pilotbetrieb;Erprobungsbetrieb
-feierlich inszenieren;würdevoll begehen;festlich begehen;weihevoll begehen;zelebrieren;feierlich begehen
-Produktenbörse;Warenbörse
-24-Stunden-Zählung;astronomische Stundenzählung
-Burgstall;abgegangene Burg (fachspr.);Buschel (süddt.);Burgstähl (altertümlich);Burstel (süddt.);Altburgstelle;Burgstelle
-Temposchwung;Parallelschwung
-Sprengel;Gerichtsbezirk
-Rechtsgang;Rechtszug;Instanz
-Rechtsmittelzug;Instanzenzug
-Tiroler Mittelland;Innsbrucker Land;Mittelinntal
-Schwemmgut;Treibgut;Geschwemmsel;Treibsel
-örtlich;positionell;lagemäßig;geometrisch;die Lage betreffend
-Werbe-Einblendung;Werbepause;Werbeunterbrechung;Werbeeinblendung;Werbeblock
-Berliner Schnauze (ugs.);Berlinisch (fachspr.);Berlinerisch;Berliner Dialekt
-Nachklapp (ugs.);Nachtrag;Nachbetrachtung
-Begriffslogik;Termlogik;klassische Logik;terminologische Logik;traditionelle Logik
-Kinemathek;Cinemathek
-Filmarchiv;Filmothek;Filmsammlung (ugs.)
-(mit den) Augen rollen;(die) Augen verdrehen
-Suffragette (fachspr., historisch);frauenbewegte Frau;Blaustrumpf (geh., historisch);Frauenrechtlerin;(eine) Frauenbewegte;Flintenweib (abwertend, salopp, veraltet);Emanze (ugs., abwertend);Feministin (Hauptform)
-autonome Szene (ugs.);autonome Gruppen;Autonome
-das kannst du deiner Großmutter erzählen! (ugs.);komm mir nicht so! (ugs.);das kannst du einem erzählen, der sich die Hose mit der Kneifzange anzieht (ugs., Spruch, variabel);ich glaub(e) dir kein Wort;wer's glaubt, wird selig (ugs., sprichwörtlich);das kannst du deiner Oma erzählen! (ugs., Spruch);du kannst mir viel erzählen! (ugs., Spruch, variabel);das glaubst du (doch) selbst nicht! (ugs.);das kannst du deinem Frisör erzählen! (ugs., Spruch);das kannst du mir nicht erzählen! (ugs.);komm mir nicht (wieder) mit (...) (ugs.);verarschen kann ich mich auch alleine! (derb, Spruch);(ja ja,) schon klar ... (ugs.);(jemandem) kommen erhebliche Zweifel;das kannst du einem Dummen erzählen! (ugs., variabel);am Arsch hängt der Hammer (derb, Spruch);ich glaube dir (das) nicht (Hauptform);(jemand) erzählt viel, wenn der Tag lang ist (ugs., Spruch);ja nee, ist klar! (ugs., Spruch);alles klar! (ugs., Spruch, ironisch);erspar(e) mir deine (...)
-sischer dat! (ugs., kölsch);auf jeden Fall!;absolut!;unbedingt!;naja klar! (ugs.);allerdings!;was denn sonst! (ugs.);aber sicher!;(ja) freilich! (ugs., süddt.);(ja) was glaubst du denn! (ugs.);ja was denkst du denn! (ugs.);aber immer! (ugs.);(ja) na klar! (ugs.);logo! (ugs.);selbstverständlich!;logisch! (ugs.);na sicher! (ugs.);ja sicher!;(aber) klar doch! (ugs.);aber selbstverständlich!;aber ja! (geh.);definitiv!;aber natürlich!;was dachtest du denn! (ugs.);ja watt'denn! (ugs., ruhrdt.);natürlich! (als Antwort) (Hauptform);klaro! (ugs.);ist doch gar keine Frage! (ugs.);(na) und ob! (ugs.);aber hallo! (ugs.);selbstredend!;ja klar!
-Benachrichtigungsfeld (fachspr.);Infobereich (der Taskleiste) (fachspr.);(System) Tray (fachspr., Jargon, engl.)
-Widderpunkt;Frühlingspunkt
-Ekliptikalebene;Ekliptikebene
-Grubenwasser;Schachtwasser
-Wasserlosungsstollen;Wasserlösungsstollen
-Stolln;Stollen
-masochistisch;selbstquälerisch
-Schwarzer Block;Autonome
-Videothek;Videoverleih (ugs.)
-Freiheitskriege;Befreiungskriege
-Republik der Sieben Vereinigten Provinzen;Generalstaaten;Vereinigte Niederlande
-Plattenbausiedlung (ugs.);Großsiedlung;Großwohnanlage;Großwohnsiedlung;Wohnmaschine (abwertend);Wohnsilo;Hochhaussiedlung;Betonburg (ugs., abwertend)
-Betreuungsgeld;Herdprämie (ugs., abwertend)
-Viszeralbogen;Pharyngealbogen;Kiemenbogen;Schlundbogen;Branchialbogen
-Drittletzter;Vorvorletzter (ugs.)
-pneumatisches Feuerzeug;Kompressionsfeuerzeug;Feuerpumpe;Luftfeuerzeug
-Trennungsbahnhof;Abzweigbahnhof (österr.)
-Vertikalmaßstab;Höhenmaßstab
-Gefechtskopf;Sprengkopf
-Astrometrie;Positionsastronomie;klassische Astronomie
-Peking-Palasthund;Pekingese;Pekinese
-Moorkolonisation;Moorkolonisierung
-Europäische Kontinentalwasserscheide;Europäische Hauptwasserscheide;Große Europäische Wasserscheide
-Diomedes-Inseln;Tremiti-Inseln
-Klüngel (abwertend);Netzwerk;Koterie (geh., franz.);Clique (abwertend, franz.);Supportstrukturen (fachspr., fig., verhüllend);Seilschaft (fig., negativ)
-bairescher Kategoriensatz;Satz von Baire
-Schabrackenhyäne;Braune Hyäne;Strandwolf
-Mark Lausitz;Markgrafschaft Lausitz
-Mark Landsberg;Markgrafschaft Landsberg
-Anisbrötli;Springerli (schweiz.);Springerle
-Hamburger Vergleich;Hamburger Erbvergleich
-Hausgesetz;Hausordnung;Hausvertrag
-hoher Adel;Hochadel
-Türe (regional);Tür
-Brotkrümelnavigation;Brotkrumennavigation;Ariadnepfad
-Tauschring;Zeittauschbörse;LETS;Tauschnetz;Tauschkreis;Nachbarschaftshilfeverein;Tauschzirkel
-Rotschnabelpinguin;Eselspinguin
-Panzerkuppel;Panzerturm
-Wesertalsperre;Eupener Talsperre
-mit einem Stock im Arsch (derb);steifbeinig
-ausladend;(weit) ausholend;gravitätisch
-flexible Arbeitszeit;Flexzeit
-Wohnumgebung;Wohnumfeld
-Pluviometer;Niederschlagsmesser;Ombrometer;Regenmesser;Hyetometer
-Lenkwaffenkreuzer;Raketenkreuzer
-LS-Schalter;Sicherungsautomat (ugs.);Automat (ugs.);Leitungsschutzschalter
-Überstromschutzeinrichtung;elektrische Sicherung
-NH-Sicherung;Niederspannungs-Hochleistungs-Sicherung;Messersicherung;Schwertsicherung;Panzersicherung
-Fehlerlichtbogen;Störlichtbogen
-Plattenbauweise;Großtafelbauweise
-Anspruch;Forderung;Erwartung
-Strömer;Flatterband
-Flatterband;Warnband;Warnleine;Flatterleine;Trassierband;Absperrband
-Aufgrabung;Künette (österr.)
-Konvektionssperre;Konvektionsbremse;Schwerkraftbremse
-Zwillingsrückschlagventil;Sperrblock
-Dampfkochtopf;Schnellkochtopf;Drucktopf;Duromatic (schweiz.);Kelomat (österr.)
-Thermit-Schweißen;aluminothermisches Schweißen
-Gasschmelzschweißen;Autogenschweißen (ugs.)
-Reibrührschweißen;Rührreibschweißen
-Laserschweißen;Laserstrahlschweißen
-diskontinuierliches Kornwachstum;sekundäre Rekristallisation
-Frische;Niedrigtemperatur (Jargon);Kühle;Kälte;Frost
-Charlie Chaplin;(der) Tramp;Sir Charles Chaplin;Charlot
-Buster Keaton;(der) Mann, der niemals lachte
-Laurel und Hardy;Stan & Ollie;Dick und Doof;Stan Laurel und Oliver Hardy
-(rumlaufen) wie eine Leiche auf Urlaub (ugs., sarkastisch);(aussehen) wie das Leiden Christi (geh.);aussehen wie eine lebende Leiche (ugs.);(nur noch) ein wandelnder Leichnam sein (ugs.);(sehr) krank aussehen;schlecht aussehen;(nur noch) ein Schatten seiner selbst sein;(wie) ein Häufchen Elend
-(aus der) Vogelperspektive;Blick von oben;(aus der) Vogelschau
-trostlos;niederschmetternd;niederdrückend (geh.);zum Heulen (ugs., fig.);bleiern (geh., fig.);lastend (geh.);entmutigend;bedrückend;demoralisierend;desolat;deprimierend
-Leitapparat;Leitwerk;Leitgitter;Leitrad
-Schmetterlings-Leitwerk;V-Leitwerk
-Luftlager;aerodynamisches Lager;aerostatisches Lager
-berührungslose Handhabung mit Ultraschall;Ultraschalllevitation
-Stehwelle;stehende Welle
-Wellenknoten;Schwingungsknoten
-Schwingungsbäuche;Wellenbäuche
-Ölbadschmierung;Öltauchschmierung
-Lastwiderstand;Abschlusswiderstand;Bürdenwiderstand;Eingangswiderstand;Außenwiderstand
-Quellwiderstand;Ausgangswiderstand;Innenwiderstand
-Tastkopf;Tastteiler
-Klemmprüfspitze;Abgreifer;Abgreifklemme
-Hemippe;Syrischer Wildesel;Syrischer Halbesel;Syrischer Onager
-Wüste (ugs.);Lieberoser Wüste;Klein Sibirien (ugs.)
-Feuerlegung;Brandstiftung
-Jet-Ski;Jet-Boot;Jetski;Wassermotorrad;Jetboot
-Platzerlaubnis;Platzreife
-Legionärsbewegung;Eiserne Garde
-Sonderfrieden;Separatfrieden
-Hoherpriester;Hohepriester;Hoher Priester
-Stinkfrucht;Kotzfrucht;Käsefrucht;Durian;Zibetfrucht
-Durio zibethinus (fachspr.);Durianbaum;Zibetbaum
-Wohnmaschine (ugs., fig.);Corbusierhaus (Eigenname);Corbusierhaus Berlin (Eigenname)
-Militärparade (Spezialisierung);Vorbeimarsch;Truppenparade (Spezialisierung) (militärisch);Parade;Heerschau (militärisch, veraltet);Defilee (fachspr., franz.);Vorbeimarschieren;Truppenschau (militärisch);Vorbeizug
-Kavalkade;(geschlossener) Reiterzug
-vom Beginn an;von Anfang an;seit Anbeginn (geh.);von Anbeginn (geh.);vom Start weg;sofort;von Beginn an
-21-cm-Linie;Wasserstofflinie;HI-Linie;H-Eins-Linie
-Zyklus der Präzession;Platonisches Jahr
-Triangulumnebel;NGC 598;Dreiecksnebel;Messier 33
-Andromedagalaxie;Großer Andromedanebel;Andromedanebel
-Messier 101;Feuerrad-Galaxie;NGC 5457;Pinwheel-Galaxie
-Ochropyra;Gelbfieber;Schwarzes Erbrechen;Siamesische Krankheit (veraltet)
-Afrikanische Trypanosomiasis;Schlafkrankheit
-Parasitose;parasitäre Infektionskrankheit
-Onchozerkose;Onchozerkiasis
-Koschenille;Karmesin;Karmin;Karmoisin;Cochenille
-Zweigkanal (veraltet);Stichkanal
-Alte Akademie;Wilhelminum
-Röntgenfluoreszenzanalyse;Röntgenfluoreszenzspektroskopie
-Gaunerbande;Gang (engl.);Verbrecherorganisation;Syndikat;(eine) Mafia (fig.);Bande;Verbrecherbande;kriminelle Vereinigung;kriminelle Organisation
-Drogensyndikat;Drogenkartell
-Jeansstoff (ugs., Hauptform);Denim (fachspr.);Jeans...
-Leinen;Linnen (veraltet);Leinzeug;Leinenstoff
-Frotté (alte Schreibung bis 2017);Frottee;Frotteestoff
-Härchen;Flaum
-Flaumfeder;Daune;Unterfeder;Dune
-Deckfeder;Konturfeder
-Milchbart;Flaum
-barttragend;bebartet;bärtig
-Sturmwindfrisur;Sturmfrisur
-ungekämmt;windzerzaust;strubbelig (ugs.);wirr (Haare);zerzaust (Hauptform);verstrubbelt;struwwelig (ugs.);strubblig (ugs.);unfrisiert;wusch(e)lig (ugs., regional);zauselig;verwuschelt
-Verzeichnisstruktur;Verzeichnisbaum;Ordnerstruktur
-bedingtes Trennzeichen;weiches Trennzeichen;bedingter Trennstrich;weicher Trennstrich
-Trennzeichen;Delimiter;Separator
-Funktionszeichen;Metazeichen
-Leichenstein (veraltet);Grabstein
-Videospiel;Game (ugs., engl.)
-spielerische Betätigung;Spiel;(das) Spielen
-Onlinespiel;Browserspiel
-nach Art eines Spiel(er)s;nicht ernsthaft;spielerisch
-Simulation;Spiegelfechterei;Trockenübung (oft Plural);Sandkastenspiel (oft Plural) (fig.);(nur eine) Übung;Planspiel;Schattenboxen (fig.)
-Myokard;Herzmuskel
-keine Übung;(der) Ernstfall;(der) casus belli (geh.)
-Schaukampf;Scheingefecht
-Schuman-Erklärung;Schuman-Plan
-(die) Schalthebel der Macht bedienen;an den Schalthebeln der Macht (sitzen) (ugs.);(alle) Fäden in der Hand haben (ugs., fig.);(die) Strippen ziehen (fig.);Einfluss haben;am Drücker (sein) (ugs.);(einen) langen Arm haben (ugs., fig.)
-(sich) zuordnen lassend;zuordenbar
-Schubs (ugs.);Stüber (ugs.);Knuff (ugs.);Puff (ugs.);Stips (ugs.);Stupser (ugs.);Rippenstoß;(leichter) Stoß;Schups (ugs., regional)
-(sich) ausruhen;dünne Bretter bohren (ugs., fig.);(es sich) bequem machen;(den) Weg des geringsten Widerstandes gehen;(sich) nicht anstrengen
-(den) ersten Schritt machen (fig.);initiativ werden;(den) Stier bei den Hörnern packen (ugs., fig.);(die) Initiative geht aus von;(die) Initiative ergreifen
-beginnen;einsetzen;losgehen (ugs.);angehen;starten (mit);anlaufen (längere Abläufe);anfangen;losbrechen;in Gang kommen (ugs.);anbrechen;entbrennen (Streit) (fig.);anheben (geh.)
-auf einen Husch zu jemandem gehen (ugs., regional, variabel);(einen) Kurzbesuch abstatten;kurz reinspringen (bei) (ugs.);auf einen Sprung vorbeikommen (ugs.);(mal) rumkommen (ugs., regional)
-(sich) in Beziehung setzen lassen zu;(einer Sache) zuzuordnen sein;(einer Sache) zuordenbar sein;(mit etwas) in Verbindung gebracht werden können;in Beziehung stehen (zu etwas);in Verbindung stehen (mit);in (einem) Zusammenhang stehen (mit);(einer Sache) zurechenbar sein;(einer Sache) zuzurechnen sein;(mit etwas) korrelieren (geh.)
-Aalmolch;Fischmolch
-Asiatischer Landsalamander;Winkelzahnmolch
-hervorholen;(umständlich) hervorkramen (ugs.);herauskramen (ugs.);(etwas irgendwoher) kramen (ugs.);hervorziehen;herausziehen;herausholen;zücken;blank ziehen (blankziehen) (geh., auch figurativ, historisch);ziehen;herausnehmen
-Beugung der Verben;Flexion der Verben (fachspr., wissenschaftlich);Konjugation (fachspr., wissenschaftlich);Verbflexion (fachspr., wissenschaftlich)
-Rurstausee;Rursee
-helladische Periode;Helladikum
-Eiszeit;Eiszeitalter
-abgeteilter Bereich;Séparée (franz.);Nebenraum;Separee (franz.)
-Trägspinner;Schadspinner;Wollspinner
-Laubtaler;Lorbeertaler
-Flickschusterei;Stückwerk (veraltend)
-Otto-Kreisprozess;Gleichraumprozess
-Wabenplatte;Sandwichplatte mit Wabenkern
-Verbundwerkstoff;Kompositwerkstoff
-faserverstärkter Kunststoff;Faser-Kunststoff-Verbund;Faserverbundkunststoff
-Stabsperrholz;Tischlerplatte
-Kabak-Platte;Hartfaserplatte;harte Faserplatte
-HWL-Platte;Holzwolle-Leichtbauplatte
-Spanplatte;Holzspanwerkstoff
-Spanplatte;Flachpressplatte
-Holzweichfaserplatte;Weichholzfaserplatte;Holzfaserdämmplatte
-U-Ausschuss (Kurzform);Untersuchungsausschuss
-Bohrwerk;Horizontal-Bohr- und Fräswerk
-Kunstprodukt;Phantasiegebilde;(reines) Phantasieprodukt;künstliches Gebilde;der (reinen) Fantasie entsprungen;Produkt der (reinen) Fantasie;der (reinen) Phantasie entsprungen;Fantasiegebilde;Produkt der (reinen) Phantasie;(reines) Fantasieprodukt
-auf Tatsachen beruhend;faktenbasiert
-abwertende Benennung;(sprachliche) Abwertung;Dysphemismus (fachspr.);Kakophemismus (fachspr.)
-Produktpiraterie;Produktfälschung;Markenpiraterie
-nicht zu entschlüsseln;kryptisch (geh.);schwer deutbar;unverständlich;unergründlich (geh.);dunkel;verdunkelt;verdeckt;schwer auszudeuten;hermetisch (geh.)
-(in) Klartext;unverschlüsselt
-Stundenglas;Sanduhr
-Kurzzeitwecker;Eieruhr;Signaluhr;Küchenwecker
-Lerchenkopf;Schlingenstek;Ankerstich
-Offizierkorps;Offizierskorps
-Straße von Tiran;Meerenge von Tiran
-Golf von Eilat;Golf von Akaba
-Flugzeugentführung;Luftpiraterie
-Geschirrtuch;Abtrockentuch
-Seemeilen pro Stunde;Knoten
-Boudoir;Damenzimmer;Kemenate (histor. oder scherzh.-altertümelnd) (geh.);Ankleidezimmer
-Liebesnest;Lasterhöhle (abwertend)
-Spiritualismus;Spiritismus
-Luftklinger;Aerophon
-Clavichord;Klavichord
-Teufelsmesse;Schwarze Messe
-Reflexdystrophie (veraltet);Algodystrophie (veraltet);Morbus Sudeck (veraltet);komplexes regionales Schmerzsyndrom;Sudeck-Dystrophie (veraltet);sympathische Reflexdystrophie (veraltet)
-Thermorezeption;Temperatursinn;Thermozeption
-akustische Wahrnehmung;aurale Wahrnehmung;auditive Wahrnehmung
-Viszerozeption;Enterozeption
-epikritische Sensibilität;Feinwahrnehmung;Tastschärfe
-protopathische Wahrnehmung;protopathische Sensibilität;Grobwahrnehmung
-Chemosensor;Chemorezeptor
-Nozizeptor;Nozirezeptor (fälschlich);Nozisensor
-lemniskales System;Hinterstrangbahn;Schleifenbahnsystem
-Vibrationsempfinden;Pallästhesie
-mentales Trauma;Psychotrauma;seelisches Trauma;psychisches Trauma
-Omron-Ringe;EURion-Konstellation
-Mali-Föderation;Sudanesische Republik
-Süditalien;Unteritalien
-Oberitalien;Norditalien
-Apenninen;Apennin
-Westsibirische Tiefebene;Westsibirisches Tiefland
-Uralgebirge;Ural
-Nussfrucht;Nuss;Schalenobst;Schalenfrucht
-Eisenoxiduloxid;Magneteisen;Magnetit;Magneteisenstein
-Klinik (fachspr.);klinisches Bild;Symptomatik
-(jemanden) imitieren;(jemanden) nachäffen (abwertend);(jemanden) mimen;(jemanden) parodieren;(jemanden) nachmachen (Hauptform)
-Schauspiel;Darstellung;Maskerade;Verkörperung;Mime;Imitation
-Neopaganismus;Neuheidentum
-Perikardtamponade;Herzbeuteltamponade
-Hämatothorax;Hämothorax
-zentraler Venenkatheter;Zentralvenenkatheter;ZVK (Abkürzung);zentralvenöser Katheter;zentralvenöser Zugang
-Pleuradrainage;Thoraxdrainage
-Brustwassersucht (veraltet);Hydrothorax
-Pleura (fachspr., griechisch);Brustfell
-Pannenstreifen (schweiz., österr.);Standstreifen
-Bodenersatz;Bodenauswechslung;Bodenaustausch
-Neoklassik;neoklassische Theorie
-Klassik;klassische Ökonomie;politische Ökonomie;klassische Nationalökonomie
-regelgerecht;korrekt;vorschriftsmäßig;rechtlich einwandfrei;den Regeln entsprechend;ordnungsmäßig (fachspr., Jargon);wie es sich gehört (ugs.);ordnungsgemäß;regelkonform;sauber (ugs.)
-fremdfinanzierte Übernahme;fremdkapitalfinanzierte Übernahme
-Nocebo-Effekt;negativer Placebo-Effekt
-Mohrenköpfle (ugs.);Schwäbisch-Hällisches Landschwein;Schwäbisch-Hällisches Schwein
-Schwäbisch Hall;Hall (ugs.)
-Kölner Phonetik;Kölner Verfahren
-Schreibmaschinendistanz;Tastaturdistanz
-Sternopleuralborsten;Härchen im Brustbereich von Insekten
-so läuft das heute;so ist es nun mal;so ist das nun mal;(es) ist nun mal so (ugs.);(das) ist einfach so;(das ist) der Lauf der Welt;so ist nun mal das Leben;da kann man (eh) nichts machen (ugs.);so ist das Leben (eben);c'est la vie (ugs., franz.);Et kütt wie et kütt. (ugs., kölsch);ist doch so! (ugs.);nicht zu ändern sein;ist so! (ugs.);es ist, wie es ist (ugs.);(das) ist halt so (ugs.);da machste nix (dran) (ugs.);(das) ist leider so (ugs.);kann passieren (ugs.)
-(sich) eine Auszeit nehmen;(sich) eine schöne Zeit machen;(sich) einen Bunten machen (ugs.);(sich) einen lauen Lenz machen
-wabbeln;zittern;wackeln;beben;schwabbeln
-schwabblig;zitternd;schwabbelig;bebend;wabblig;wackelnd;wabbelig
-Eisenbahnsuizid;Schienensuizid;Bahnsuizid
-Begleitung;Anstandsdame;Anstandswauwau (ugs., veraltend);Begleiterin;Aufpasserin
-Strain Wave Gear (engl.);Spannungswellengetriebe;Harmonic Drive (Markenname);Wellgetriebe;Gleitkeilgetriebe
-Zylinderrad;Stirnrad
-überraschend erscheinen;hereinschneien (ugs.);plötzlich auftauchen;unversehens auftauchen;unangemeldet erscheinen;unangemeldet auftauchen;überraschend auf der Bildfläche erscheinen;(einfach) auf einmal da sein;reinschneien (ugs.);hereingeschneit kommen (ugs.);überrumpeln;ins Haus geschneit kommen (ugs.);einfallen;(jemanden) überfallen (ugs., fig.);auf einmal vor der Tür stehen (ugs.);auf einmal auf der Matte stehen (ugs.);hineinplatzen;hereinplatzen;hineinschneien (ugs.)
-(sich) schnäuzen;(sich) die Nase putzen
-noch Fragen?;(so weit) alles klar?;(noch) irgendwelche Fragen?;sonst noch was?
-lalü lala (ugs., scherzhaft);tatü tata
-Entomologe;Insektenkundler
-Presserummel;Medienwirbel;medialer Rummel (variabel);Rauschen im Blätterwald (fig.);Medienrummel;Medienhype;Medienzirkus (ugs., abwertend)
-passiv-aggressive Persönlichkeitsstörung;negativistische Persönlichkeitsstörung
-abhängige Persönlichkeitsstörung;asthenische Persönlichkeitsstörung;dependente Persönlichkeitsstörung
-zwanghafte Persönlichkeitsstörung;Zwangspersönlichkeitsstörung;anankastische Persönlichkeitsstörung
-schizotype Störung;schizotypische Persönlichkeitsstörung
-Passstück;Abstandhalter;Distanzstück;Passscheibe;Distanzscheibe
-Luftabwehr (veraltet);Flugabwehr
-Islamofaschismus;Islamfaschismus
-Panarabismus;arabischer Nationalismus
-Augenbewegung;Okulomotorik;Augenmotilität
-Sehloch;Pupille
-Pinzettenzugtest;Traktionstest
-Brown-Syndrom;Obliquus-Superior-Sehnenscheiden-Syndrom
-Meeresvogel;Seevogel
-Supraflüssigkeit;Hyperfluidität;Suprafluidität;Superflüssigkeit;Superfluidität
-Ionisationsgrad;Ionisierungsgrad
-Saha-Gleichung;Saha-Ionisierungs-Gleichung
-Klitzing-Konstante;von-Klitzing-Konstante
-molares Volumen;Molvolumen
-allgemeine Gaskonstante;molare Gaskonstante;universelle Gaskonstante;ideale Gaskonstante
-Feinstrukturkonstante;Sommerfeldkonstante;Sommerfeldsche Feinstrukturkonstante
-Landé-Faktor;gyromagnetischer Faktor
-Punktmasse;Massepunkt
-Protolysegrad;Dissoziationsgrad
-Alkoholvergiftung;C2-Abusus (fachspr.);Alkoholintoxikation (fachspr.);C₂-Abusus (fachspr.)
-Kalfaktor (geh.);dienstbarer Geist (ugs., Hauptform);(eine) gute Fee (ugs., weibl.);Mitarbeiter mit Querschnittsfunktion;(der) gute Geist (einer Firma / eines Hauses) (ugs.);lebendes Inventar (sein) (ugs., scherzhaft);Faktotum (geh.);(ein) Mann für besondere Gelegenheiten (oft ironisch) (ugs.);zum lebenden Inventar gehören (ugs., scherzhaft);Mädchen für alles (ugs., männl., weibl.)
-Mopelia;Mopihaa;Maupihaa
-Französisch-Polynesien;Französisch-Ozeanien (veraltet)
-Indischer Maulbeerstrauch;Indischer Maulbeerbaum;Noni
-Hochpass;Tiefensperre
-Theriologie (fachspr.);Mammalogie (fachspr.);Säugetierkunde
-Schädelbasisfraktur;Schädelbasisbruch
-Gleitspanen;Gleitschleifen;Trowalisieren;Trowalieren
-Apostelkreuz;Crux signata (lat.);Weihekreuz;Konsekrationskreuz
-griechisches Kreuz (Hauptform);gekürztes Kreuz;gemeines Kreuz
-Gemeines Kreuz;Balkenkreuz
-Malteserkreuz;Amalfikreuz;Johanniterkreuz;Hospitaliterkreuz
-Kohlenmonoxid-Vergiftung;Kohlenmonoxid-Intoxikation;Kohlenstoffmonoxidintoxikation;Kohlenmonoxidintoxikation;CO-Intoxikation;CO-Vergiftung
-Gastest;Hohenheimer Futterwerttest
-HF-Technik;Hochfrequenztechnik
-Kupferstich;Chalkographie (veraltet)
-Kosovo-Ägypter;Balkan-Ägypter
-Serbien und Montenegro;Serbien-Montenegro;Serbien/Montenegro
-Schüttgutfrachter;Massengutfrachter
-Güterschiff;Frachtschiff;Frachter
-Kümo (Abkürzung);Küstenmotorschiff
-Tanker;Tankschiff
-Kurutzen;Kuruzzen;Kuruzen
-Latènezeit (fachspr.);La-Tène-Zeit
-Mitglied der Europäischen Kommission;Mitglied der EU-Kommission;EU-Kommissar (ugs.)
-Europäische Kommission;EU-Kommission
-bleiern;bleifarben;bleifarbig
-Restanten (Kleidung) (fachspr.);Auslaufmodell;Überhänge (Textilien) (fachspr.);Restposten;Ramsch (Buchhandel) (fachspr.);Restanzen (Bekleidung) (fachspr.)
-Altniederländisch;Altniederfränkisch
-niederländische Sprache;Holländisch (ugs.);Niederländisch
-aufscheuern;(sich) wund reiben;auffretten (ugs.);(sich) aufreiben
-Megaliner;Airbus A380;Superjumbo (ugs.)
-Flugsicherheitsbegleiter;Luftsicherheitsbegleiter
-Kugel (ugs.);Patrone (ugs.);Projektil
-Gesellschaftswissenschaft;Sozialwissenschaft
-Harvester (fachspr., engl.);Vollernter (fachspr.);Waldvollernter;Kranvollernter;Holzvollernter
-Holzhackschnitzel;Hackschnitzel;Hackgut
-Waldhackgut;Waldhackschnitzel
-NR;NawaRo;Nawaro;nachwachsender Rohstoff;NaWaRo
-auf dem Teppich bleiben (fig.);die Kirche im Dorf lassen (ugs., sprichwörtlich);nicht übertreiben;halblang machen (ugs.)
-Deklination;Beugung (Nomen/Adjektive);Flexion (Nomen/Adjektive)
-Dialektcluster;Dialektbündel
-Scharbockskraut;Feigwurz;Frühlingsscharbockskraut
-Frühlingsgeophyt;Frühblüher;Frühjahrsblüher
-Ethnomusikologie;vergleichende Musikwissenschaft (veraltet);Musikethnologie
-Musikologie;Musikwissenschaft
-Musikgeschichte;historische Musikwissenschaft
-Musikwissenschaftler;Musikologe
-Lenkdrachensegeln;Kitesurfen;Kiten;Kiteboarden
-Paragleiten;Gleitschirmfliegen
-Gleitschirm;Paragleiter;Gleitsegel
-Hanggleiter;Flugdrachen;Deltasegler (fachspr.);Drachen;Hängegleiter;bemanntes Gleitfluggerät (geh.)
-Paragliding;Gleitsegelfliegen;Gleitsegeln
-Lateinisch;Latein
-Stuhl Petri;Heiliger Stuhl;Päpstlicher Stuhl;Apostolischer Stuhl
-Pädagoge;Pädagogiker (derb)
-Opa Langbein (ugs.);Weberknecht;Zimmermann (schweiz.);Schuster;Kanker;Schneider
-Polenstrafrechtsverordnung;Verordnung über die Strafrechtspflege gegen Polen und Juden in den eingegliederten Ostgebieten
-Arthropoda (fachspr.);Gliederfüßer
-Tausendfüßler;Tausendfüßer
-Antennata;Tracheentier;Atelocerata
-Standfuß;Fuß;Standvorrichtung
-Schaltier (veraltet);Schalenweichtier;Schalentier (veraltet)
-Älchen;Aaltierchen (veraltet);Nematode;Fadenwurm
-Rübenälchen (veraltet);Rübenzystennematode
-Kleeälchen;Rübenkopfälchen;Stängelälchen
-Tauwasser;Schwitzwasser;Kondenswasser
-Satz von Stokes;stokesscher Integralsatz
-greensche Sätze;greensche Theoreme;greensche Formeln;greensche Identitäten
-Satz von Green;Lemma von Green;Green-Riemannsche Formel;Satz von Gauß-Green
-Kurvenintegral;Linienintegral;Wegintegral
-Umlaufintegral;Zirkulation;Ringintegral
-komplexe Analysis;Funktionentheorie
-Gyrometer;Gyrosensor
-Lageregelung;Stabilisation
-CP-Steuerung;Bahnsteuerung
-vom;von dem
-Polei;Flohkraut;Polei-Minze
-Bazillenruhr;Bakterienruhr;Shigellose;Shigellendysenterie;Shigellenruhr
-Brechdurchfall (ugs.);Magen-Darm-Entzündung;Bauch-Grippe (ugs.);Magen-Darm-Grippe (ugs.);Happe (ugs.);Gastroenteritis
-Verstümmlung;Verstümmelung
-Körperverstümmelung;körperliche Verstümmelung
-Trennungskind;Scheidungswaise;Scheidungskind
-PA (fachspr.);PAS (fachspr.);Umgangsvereitelung (fachspr.);Eltern-Kind-Entfremdung;elterliches Entfremdungssyndrom (fachspr.);Parental Alienation (Syndrome) (fachspr.)
-Mündungssignaturreduzierer (selten);Schalldämpfer
-umgestalten (ugs.);ummodeln;umbauen
-Großgebietiger;Großwürdenträger
-Ordensmarschall;Oberste Marschall
-Militärpferd;Armeepferd
-Stuterei (veraltet);Gestüt
-Madonnenbildnis;Marienbildnis
-Großfürstentum Litauen;Großherzogtum Litauen
-völlig egal;x-beliebig;völlig beliebig
-Nebeninsel;Nachbarinsel
-Herzogtum Archipelagos;Herzogtum Naxos
-Balkanhalbinsel;Balkan
-Seniorenstift;Altenstift
-Asandeschwelle;Nordäquatorialschwelle
-Südsudan;Republik Südsudan
-Schreibweise;Schreibung;Notation (geh., lat.)
-Dreiergremium;Dreiergespann (fig.);Dreigespann (fig.);Dreierspitze;Troika;Triumvirat;Dreigestirn (auch ironisch)
-Trio;Dreiercombo;Dreiergrüppchen;Trio infernal (ironisch, ursprünglich Filmtitel) (ugs.);Dreiergruppe (Hauptform);Dreier-Grüppchen
-Dreier (ugs.);Sex zu dritt;Ménage-à-trois (geh., franz.);Sandwich (ugs.);flotter Dreier (ugs.)
-Troika;Dreigespann;Dreispänner
-Kurzmitteilung;wenige Zeilen;Dreizeiler;Briefchen (ugs.);Kurzbrief
-missglückt;danebengegangen;gescheitert;misslungen;schiefgegangen;fehlgeschlagen
-grob geschnitzt;holzschnittartig;grob gezeichnet;skizzenhaft;in Umrissen;grob umrissen
-Varikosis (fachspr.);Varikose (fachspr.);Krampfaderleiden
-Entität;Krankheitsbild
-Pferdekopfpumpe (ugs.);Nickesel (ugs.);Gestängetiefpumpe
-weggehen wie warme Brötchen (ugs.);(sich) verkaufen wie geschnitten Brot (ugs.);(jemandem) (buchstäblich / förmlich / nur so ...) aus den Händen gerissen werden;(weggehen / sich verkaufen) wie warme Semmeln (ugs.);reißenden Absatz finden
-(es existiert) keine Nachfrage (nach);schwer verkäuflich sein;(sich) schwer verkaufen lassen;nicht gefragt sein;wie Blei in den Regalen liegen (ugs.)
-tote Sprache;alte Sprache
-Althebräisch;Hebräisch
-(den) Bezug zur Realität verlieren;(jemandem) zu Kopf steigen (Erfolg, Ruhm) (fig.);abheben (ugs., fig.);(die) Bodenhaftung verlieren (fig.)
-Rückwärtssuche;Inverssuche
-dämlich;neckisch;albern;unfreiwillig komisch;lachhaft;pillepalle (ugs.);(jemandem) zu blöd (ugs.);affig;blöd (ugs.);närrisch;nicht ernst zu nehmen;lächerlich;ridikül (geh., veraltend);flachsinnig (ugs.);läppisch;zum Schreien (ugs.);zum Piepen (ugs.)
-Geschiebelehm;Blocklehm
-Hebefest;Dachgleiche (österr.);Aufrichte (schweiz.);Aufrichtfest (schweiz.);Richtfest (Hauptform);Gleichenfeier (österr.);Firstbier;Bauheben;Firstfeier (österr.);Hebauf;Firstfest (österr.);Fensterbeer (plattdeutsch);Aufschlagfest;Weihefest
-Richtkranz;Richtkrone
-Aktienumtausch;Aktientausch
-Fürstentum Bayreuth;Markgraftum Brandenburg-Bayreuth
-Fürstentum Ansbach;Markgraftum Brandenburg-Ansbach
-Mikrostaat;Ministaat;Duodezstaat (historisch);Zwergstaat
-Provenienzrecherche;Provenienzerschließung;Provenienzforschung
-gallig;bitter;herb
-(einen) Würgereiz (haben);(eine) schwere Zunge (haben) (fig.);kurz davor sein, sich zu übergeben;(sich) übergeben (wollen)
-Lichtgranulation;Specklemuster;Speckle
-keuzunglücklich (ugs.);niedergeschmettert;todunglücklich;zu Tode betrübt;todtraurig
-beharrlich;unbeugsam;konsequent;unbeirrt;straight (engl.);standfest;unverrückbar;standhaft;(wie ein) Fels in der Brandung (fig.);eisern (fig.);unbeirrbar;unnachgiebig;unerschütterlich
-nicht mitziehen;nein sagen (ugs.);(sich) wehren (gegen);(sich) widersetzen;Nein sagen (ugs.);(sich) querlegen (fig.);(sich) sperren (gegen);nicht mitmachen;(sich) sträuben (gegen);nicht mitspielen;einen Korb geben (ugs., fig.);aus der Reihe tanzen (ugs., fig.)
-viele tausend;viele Tausend;abertausend;Abertausend
-aberhundert;Aberhundert;viele Hundert;viele hundert
-Aberdutzend;viele Dutzend;mehrere Dutzend
-halbes Dutzend;sechs;6
-(die) Sitte (ugs.);Sittenpolizei;Sittendezernat
-Reklame;Werbung (Hauptform);Publicity (Jargon, engl.);Absatzförderung
-(ein) Gespür haben (für);(etwas) wittern;(einen) Riecher haben (für) (Hauptform);(eine) Nase haben (für);(ein) Näschen haben (für);(den) richtigen Riecher haben
-pc (engl.);politisch korrekt
-Verkehrslagedienst;Verkehrsinformationsdienst
-Davurien;Transbaikal;Dahurien;Transbaikalien;Daurien
-Biogeografie;Biogeographie
-Kapensis;Kapflora
-Dateiserver;Fileserver (engl.)
-Wechselfestplatte;Wechselplattenlaufwerk
-Halbleiterlaufwerk (selten);Solid-State-Disk (engl.);Solid-State-Drive (engl.);Festkörperlaufwerk (selten);SSD (Abkürzung, engl., Hauptform)
-Lokalaugenschein (österr.);Vor-Ort-Termin;Ortstermin;Lokaltermin
-Ziel (veraltend);Fälligkeitstag;Zeitpunkt der Fälligkeit;Fälligkeitszeitpunkt;Zahlungsziel (fachspr., kaufmännisch);Fälligkeitsdatum;Fälligkeit
-(der) Augenblick der Wahrheit;(der) entscheidende Moment;(der) Moment wo sich alles entscheidet;(der) große Augenblick wo (...);(der) große Augenblick, wo der Frosch ins Wasser springt (ugs., ironisierend);(die) Stunde der Wahrheit;(die) Stunde der Bewährung
-Nibelungentreue (fig.);(unbedingte) Gefolgstreue (geh.);Treue bis zum Untergang;Treue bis in den Tod;unverbrüchliche Treue
-undurchsichtiges Tauschgeschäft;eine Hand wäscht die andere (fig., sprichwörtlich);Mauschelei (ugs.);Kuhhandel (ugs.);Gefälligkeits...;Deal (ugs.);Kungelei (ugs., regional)
-bereisen;durchreisen;durchstreifen;reisen durch
-zu meiner (großen) Überraschung;zu meinem (großen) Erstaunen;zur großen Überraschung der Anwesenden;überraschenderweise;staunenswerterweise (geh., veraltend)
-(sich) begeistern für;(sich) ereifern für
-(von jemandem) nicht bemerkt werden;(jemandem) nicht auffallen;(jemandem) entgehen;nicht wahrgenommen werden
-letzteres;das zuletzt Gesagte
-seismologisches Observatorium;Erdbebenwarte
-Observatorium;Warte
-nördlicher Sternhimmel;nördlicher Sternenhimmel;Nordsternenhimmel;Nordhimmel;Nordsternhimmel
-Feststoff;Festkörper
-Zungenwurst;Zungenblutwurst
-Speckwurst;Griebenwurst
-Schlachtplatte;Schlachteplatte;Schlachtschüssel (süddt.);Metzgete (alemannisch)
-Steg (norddeutsch);Wellfleisch;Spint (fränk.);Kesselfleisch;Siedfleisch (schwäbisch);Stegfleisch (norddeutsch)
-Wurstbrühe;Metzelsuppe;Wurstsuppe
-Schweinsbacke;Backenfleisch;Schweinsbäckchen;Schweinebacke
-Siedefleisch;Suppenfleisch
-Leiterchen;Ripperl (bayr.);Schälrippe;Ripple (schwäbisch);Rippenspeer
-Bauchfleisch;Wammerl (bayr.)
-Brust;Brustspitze;dicke Rippe;Brüstel
-Karbonade;Karree;Rippenstück;Rücken
-Pfötchen;Pfoten;Schweinsfuß;Spitzbein
-Lendenbraten;Lungenbraten (österr.);Lende;Filet (franz.)
-Dünnung;Bauchlappen;Flanke
-Bauchraum;Bauchhöhle;Peritonealhöhle (fachspr.)
-Schweinebug;Schweineschulter
-Hohrücken (schweiz.);rundes Roastbeef;Hochrippe;Rostbraten (österr.);Hohe Rippe
-Santelholz;Santalholz;Sandelholz
-(ein) Studium absolvieren;immatrikuliert sein;studieren (Hauptform);Student sein;eingeschrieben sein
-Schachtelkäse (schweiz.);Schmelzkäse;Schmierkäse (ugs.)
-Arbiter;Arbitrationslogik
-maschinelles Sehen;Bildverstehen
-Pantoffelheld (ugs.);Simandl (ugs., österr.)
-zu Hause nichts zu lachen haben;zu Hause nichts zu sagen haben;unter dem Pantoffel stehen (fig.)
-Prügelperser;Jubelperser
-zu allem Ja und Amen sagen;keine Einwände haben (Hauptform);es spricht nichts gegen (floskelhaft, kommentierend);nichts dagegen haben (ugs.);mit allem einverstanden sein;nichts haben gegen;nichts dagegen vorzubringen haben
-blinder Gehorsam;vorauseilender Gehorsam;Kadavergehorsam;Willfährigkeit;unbedingter Gehorsam
-(von jemandem) (emotional) abhängig;besessen (von);(jemandem) hörig;(jemandem) (mit Leib und Seele) verfallen;bedingungslos ergeben
-Tetraparalyse;Tetraplegie;Quadriplegie;Querschnittlähmung aller vier Gliedmaßen
-Paraplegie (fachspr.);Querschnittläsion;Transversalsyndrom;Querschnittlähmung;spinales Querschnittsyndrom;Querschnittslähmung
-längsseits (ugs.);längsseitig (ugs.);traufständig
-Archivierungsprogramm;Packer;Packprogramm
-gesundes Halbwissen (ugs., variabel);gefühltes Wissen (ironisch);Halbwissen;Halbbildung
-geiler Bock (derb);Sexmaniac;Hurenbock (derb);Sexbesessener;Lüstling;Sex-Maniac;Lustmolch (ugs.);Sexmonster (ugs.);Sexverrückter;Sexsüchtiger;immer nur an das eine denken (ugs.);immer nur das eine wollen (ugs.);Erotomane (geh.);nur Weiber im Kopf haben (ugs.);Satyr (geh.)
-eine fürs Bett (ugs.);Sexpüppchen (ugs.);Betthäschen (ugs.);Betthupferl (ugs., fig.);was fürs Bett (ugs.)
-blond und blöd (ugs.);blonde Tussi (ugs.);Blondchen (ugs.);innerlich blond (ugs., ironisch);blondes Dummchen (ugs.);hohle Tussi (ugs.)
-deliktische Haftung;Unrechtshaftung
-Internationales Privatrecht;Kollisionsrecht
-(jemanden) abschleppen (ugs.);(jemanden) ins Bett bekommen;(jemanden) rumkriegen (ugs.);(sich jemanden) klarmachen (ugs., salopp);(jemanden) aufreißen (derb, fig.);(jemanden) herumkriegen
-(jemand ist) nicht zu retten;(ein) hoffnungsloser Fall (sein);(jemandem ist) nicht zu helfen
-(etwas) ans Licht bringen;(etwas) zum Vorschein bringen;(den) Schleier lüften;enthüllen;aufdecken;(ein) Geheimnis lüften;(etwas) ans Tageslicht bringen
-(jemanden) entlarven;(jemanden) demaskieren;(jemandem) die Maske vom Gesicht reißen;(jemandem) die Maske herunterreißen;(jemanden) enttarnen
-Mastektomie (fachspr.);Brustamputation (ugs.)
-mehr (Pron.);Weiteres;Sonstiges
-Beauty (engl.);schöne Frau (Hauptform);Schönheit;Beauty-Queen (engl.);(eine) Schöne
-Bibeldruckpapier;Bibeldünndruckpapier;Dünndruckpapier (Hauptform);Bibelpapier
-Tischunterlage;Molton (fachspr.)
-Napperon (fachspr.);Übertischtuch;Deckserviette (fachspr.);Decker (fachspr.);Mitteldecke
-aufbacken (seemännisch);(den) Tisch decken;eindecken (Gastro.) (fachspr.)
-gleichziehen;(wieder) einholen;aufschließen (zu);ausgleichen;Abstand verringern;(den) Ausgleich erzielen;(den) Anschlusstreffer erzielen
-Set;Platzset;Platzdeckchen;Tischset
-(das) Tischtuch ist zerschnitten (zwischen);(sich) mit dem Arsch nicht mehr angucken (derb);im Streit auseinandergegangen sein;getrennte Wege gehen;getrennt von Tisch und Bett sein;heillos zerstritten sein;nicht mehr miteinander sprechen
-Urwaldriese;Großbaum (fachspr.);Großgehölz
-Weißwäsche;Weißzeug
-(gedanklich) eintauchen in;(gedanklich) eindringen in;(etwas) ergründen;(sich in etwas) vertiefen
-Gehölz (fachspr.);Holzgewächs (fachspr.);holzige Pflanze (fachspr.);holziges Gewächs (fachspr.)
-holzig (fachspr.);verholzt
-kleiner Baumbestand;Wäldchen;Waldung;Hain;Gehölz;kleiner Wald
-Hecke;Strauchreihe;Reihe von Sträuchern
-der Öffentlichkeit zugänglich machen;öffnen;(öffentlich) zugänglich machen
-aufsperren;öffnen;aufschließen;entriegeln
-Zwergbaum;Minibaum;Bonsai (japanisch);miniaturisierter Baum
-Charakterbaum (fachspr.);Einzelbaum;Solitär (fachspr.);freistehender Baum;Solitärbaum (fachspr.)
-provinziell;brav und bieder;philisterhaft;spießbürgerlich;bieder;kleinbürgerlich;bourgeois (geh.);engstirnig;spießig (Hauptform);spießerhaft;borniert;piefig;philiströs (geh., bildungssprachlich)
-Aktivbox;Aktivlautsprecher
-Studiolautsprecher;Studiomonitor
-tragende Säule;Eckpfeiler;Grundsäule;Stützpfeiler;Pfeiler
-aus der Not geboren (sein);verzweifelter Versuch;Verzweiflungstat;Akt der Verzweiflung
-Verzweiflungstäter (Hauptform);Desperado
-Korbschläger;Korb
-Glocke;Glockenschläger
-ingwäonische Sprachen;nordseegermanische Sprachen
-Steirische Völkertafel;Völkertafel
-Hausruckkreis;Hausruckviertel
-Bayerischer Rupertiwinkel;Rupertiwinkel
-Erzstift Salzburg;Fürsterzbistum Salzburg
-amtliche Gemeindekennzahl (veraltet);amtlicher Gemeindeschlüssel;Gemeindekennziffer;Kreisschlüssel;Gemeindenummer (schweiz.);Gemeindeschlüsselzahl
-Rubus caesius (botanisch);Kratzbeere;Kroatzbeere
-Umzug;Tapetenwechsel (ugs., fig.);Wohnortwechsel;Wechsel des Wohnsitzes;Wohnsitzwechsel
-gering achten;nichts halten von;(die) Anerkennung verweigern (geh.);in den Staub treten (fig.);herabschauen (auf);geringschätzig behandeln;geringschätzen;hinunterschauen (auf);verachten;von oben herab behandeln;herabblicken (auf);hinunterblicken (auf);herabsehen (auf);wenig halten von;mit Füßen treten (fig.)
-seine;sein;der/die/das ihm gehörende;der/die/das Seinige
-Dialektikon;Dialogismus
-Rundrücken;Gibbus (fachspr.);Hyperkyphose (fachspr.);Buckel (ugs.)
-(den) Blick senken;(die) Augen niederschlagen
-The Butt;Jennifer Lopez;J.Lo
-Kollusionsgefahr (schweiz.);Verdunkelungsgefahr
-Parabelflugzeug;Kotzbomber (derb)
-Einstellung;Shot (engl.)
-subjektive Einstellung;Subjektive;subjektive Kamera
-zu kurz gesprungen sein (ugs.);nicht weit genug gehen;zu kurz greifen
-Gewicht haben (fig.);Geltung haben;von Bedeutung sein
-Problem meistern;Troubleshooting betreiben (ugs.);(ein) Problem aus der Welt schaffen;Problem lösen;(die) Kuh vom Eis holen (ugs., fig.);Schwierigkeit bewältigen
-Tafelklavier;Hammerklavier
-Raseur;Herrenfriseur;Bartscherer;Bartschneider;Barbier;Herrenfrisör
-Truppenarzt;Feldscher (veraltet);SanOffz;Wundarzt (veraltet);Sanitätsoffizier;Militärarzt;Stabsarzt
-du bist (bereits) ein toter Mann;deine Tage sind gezählt;fang schon mal an zu beten (variabel)
-mit nacktem Oberkörper;halbnackt
-IT-Forensik;Computer-Forensik
-Hamming-Abstand;Hamming-Distanz
-(frei stehende) Mauer;Grenzmauer
-Sichtblende;Sichtschutz
-Zelter;Gangpferd
-Fahrradreifen;Decke (fachspr., Jargon);Fahrradmantel;Mantel (ugs.)
-Stundenbuch;Brevier;Horarium
-Hoffnungszeichen;Ende der Durststrecke (fig.);(endlich) Land sehen (fig.);Licht am Ende des Tunnels (fig.);Land in Sicht (ugs., fig.)
-Durststrecke (fig.);harte Zeit;(es) läuft nicht gut (für) (ugs.)
-(sich) nicht schuldig bekennen;auf nicht schuldig plädieren
-Eisvulkan;Kryovulkan
-Eisvulkanismus;Kryovulkanismus
-Datenerhebung;Datensammlung;Erhebung (von Daten)
-tapezieren;eine Tapete anbringen
-deutliche Worte;(eine) klare Ansage (ugs.)
-Hast du das (auch wirklich) verstanden? (ugs., Hauptform);Hab ich mich klar ausgedrückt? (ugs.);Hast du (endlich) verstanden?;Muss ich noch mehr sagen? (ugs.);War das deutlich genug? (ugs.);Ist das klar? (ugs.);Soll ich es (noch) buchstabieren? (ironisch);Ist das (bei dir) angekommen? (ugs.)
-zu den Sternen greifen (fig., seltener);nach den Sternen greifen (ugs., fig., sprichwörtlich);(das) Unmögliche versuchen
-Puppenstübchen (oft iron.) (fig.);Schmuckkästchen (fig.)
-Prinzip der Parsimonie;Ockhams Rasiermesser (fachspr.);Sparsamkeitsprinzip
-unverschämt werden;(jemandem) blöd kommen (ugs.);(sich) im Ton vergreifen;(jemanden) provozieren;frech werden (ugs.);(sich) Unverschämtheiten herausnehmen;ausfallend werden (Hauptform);(jemandem) dumm kommen (ugs.);Streit suchen;anpöbeln;(jemandem) frech kommen;beleidigen;es an (dem nötigen) Respekt fehlen lassen;im Ton danebengreifen;(sich) Frechheiten herausnehmen;aufsässig sein;herumpöbeln;rumpöbeln (ugs.)
-Tabaktrafik (österr.);Trafik (österr.)
-Kugelstoßpendel;Newtonpendel;Newton-Wiege;Kugelpendel
-Altweiberknoten;Knopf (österr.);Hausfrauenknoten
-Diebesknoten;falscher Kreuzknoten
-Halbschlag;halber Schlag
-Mastwurf;Webeleinenstek
-Fluggastbrücke;Passagierbrücke;Rüssel (ugs.);Finger (ugs.)
-ein andermal;ein anderes Mal (vielleicht);sonst gerne;bei anderer Gelegenheit;vielleicht später (einmal) (ugs.);jetzt nicht;nicht jetzt
-halloho! (halb gesungen);hörst du mir überhaupt zu? (ugs.);ist da jemand?;ist jemand da?;ist da wer?;jemand zu Hause?
-vorgängig (schweiz.);vorhergehend
-Proplyd;protoplanetare Scheibe;zirkumstellare Scheibe
-Infrarotspektroskopie;Ultrarotspektrokopie (veraltet);IR-Spektroskopie
-Bundesdeutsches Hochdeutsch;Binnendeutsch;Reichsdeutsch (veraltet);Deutschlanddeutsch;BRD-Deutsch;Deutschländisch;deutschländisches Deutsch;deutsches Deutsch;Bundesdeutsch (Hauptform)
-effektive Reflexionsfläche;Radarquerschnitt;Rückstrahlfläche
-Übersetzungsfalle (ugs.);Übersetzungsschwierigkeit
-Heunesäule;Heunensäule
-Wassertrieb;Wasserreis (Plur. Wasserreiser) (Hauptform);Angsttrieb;Wasserschoss
-Jungfernflug;Erstflug;erster Flug
-Motorjet;Thermojet;Motorstrahltriebwerk;Motorluftstrahltriebwerk
-Freilauf;Überholkupplung
-Obers (österr.);Rahm;Sahne
-Kaffeesahne;Crème;Kaffeerahm;Kaffeeobers
-saure Sahne;Sauerrahm
-Durchleuchtung;Fluoroskopie
-Fotografie;Photographie
-Photovervielfacher;Photomultiplier;Photoelektronenvervielfacher
-Seiteneinsteiger;Quereinsteiger
-diplomatische Immunität;politische Immunität;diplomatische Vorrechte
-Teilentladung;Vorentladung
-Rollbombe;Rotationsbombe
-Fliegerbombe;Abwurfkampfmittel;Abwurfmunition
-körperliche Behinderung;Körperbehinderung
-Ederstausee;Edersee
-Naturaliensammlung;Naturalienkabinett;Naturalienkammer
-es ist zu spät (für etwas);(etwas) ist Vergangenheit;der Zug ist abgefahren (ugs., fig.);(jemand) hatte seine Chance;(etwas) kommt zu spät;(etwas / jemand) ist Geschichte;den Zeitpunkt verpasst haben
-in fünf von zehn Fällen;fifty fifty (ugs., engl.);zur Hälfte (Hauptform);zu 50 Prozent;hälftig (fachspr., Amtsdeutsch);zu 50 %
-Apotheken Umschau;Rentner-Bravo (ugs., ironisch)
-Vatermörder (ugs.);Stehkragen;Kläppchenkragen
-Skandinavische Münzunion;Skandinavische Währungsunion
-sodass;so dass
-Skalengesetz;Skalierungsgesetz
-Datenart;Datentyp
-strenge Typisierung;starke Typisierung
-Kaiserlich Russische Armee;Imperiale Russische Armee;Zaristische Armee
-Landstreitkraft;Heer;Landstreitmacht
-Schlagband (schweiz.);Portepee (franz.);Faustriemen
-Kontakt herstellen;Kontakt knüpfen;netzwerken
-Hauslehrer;Privatlehrer
-Sonderschullehrer (veraltet);Förderlehrer;Hilfsschullehrer (veraltet)
-Ptyalismus (fachspr.);vermehrter Speichelfluss;Hypersalivation (fachspr.)
-Waldrodungschile;Kleiner Süden;Chilenische Schweiz
-Schlangenbaum (ugs.);Auracaria auraucana (fachspr., botanisch);Andentanne;Schuppentanne;Chilenische Schmucktanne;Chiletanne;Chilenische Araukarie;Affenschwanzbaum
-Diodenlaser (fachspr.);Kohlenstoffdioxidlaser;CO₂-Laser;CO2-Laser;Kohlendioxidlaser
-Sibirischer Kranich;Schneekranich;Nonnenkranich
-Hausverwaltung;Mietverwaltung;Wohnungsverwaltung
-territoriale Unversehrtheit;territoriale Integrität
-Charta der Vereinten Nationen;Satzung der Vereinten Nationen (österr.)
-es ist vorzuziehen, dass;von Vorteil;besser
-VK-Ausgleich;Britenscheck;Britenbonus;Britenrabatt
-Postrecht;Postregal
-Briefmonopol;Postmonopol
-Friedlosigkeit;Vogelfreiheit;Reichsbann;Verfestung;Wolfsfreiheit;Acht;Reichsacht;Bann
-Roerich-Pakt;Washingtoner Vertrag von 1935
-Haager Konventionen;Haager Abkommen
-Plicht;Cockpit (ugs.)
-Segeljacht;Segelyacht
-relativer Wind;Bordwind;scheinbarer Wind
-Lufthauch;schwacher Wind;Brise;Windhauch;leichte Luftbewegung;(leichter) Zug;(laues) Lüftchen (ugs.)
-Britisch-Nordborneo;Nord-Borneo;Nordborneo
-Deichgras;Strandhafer;Gemeiner Strandhafer;Sandrohr;Sandhalm;Gewöhnlicher Strandhafer;Seehafer;Dünengras;Helm (niederdeutsch)
-Spiel mit perfekter Information;Spiel mit vollkommener Information
-Mühle;Nünistei (schweiz.);Mühlespiel
-Filmauswertung;Filmverwertung
-zusammenhalten wie Pech und Schwefel;(eine) verschworene Gemeinschaft;(sich) unverbrüchliche Treue geschworen haben;(eine) eingeschworene Gemeinschaft (bilden) (Hauptform);aneinander gekettet (sein) (fig.);fest zusammenhalten
-Handlungszwang;Zugzwang;Sachzwang (oft Plur.: Sachzwänge)
-Kaukasologie;Kaukasistik;Kaukasiologie
-Kaukasologe;Kaukasiologe
-kartwelische Sprache;Kartwelsprache;südkaukasische Sprache
-Altarmenisch;klassisches Armenisch;altarmenische Sprache;Grabar
-Kostensenkung;Kostenreduktion
-Zuschlagstoff;Beimengung
-Wahlkampagne;Stimmenfang (ugs.);Kampagne;Wahlkampf
-Musikvideo;Videoclip
-zum Kandidaten erklären;(als Bewerber) aufstellen;nominieren;ins Rennen schicken;zum Kandidaten küren
-Peiseler-Schlepprad;fünftes Rad;Peiselerrad
-nachlassen;abbauen;an Kraft verlieren;(schwer) nachlassen;kraftlos werden
-alpin;bergig;montan;gebirgig
-Bergland;bergiges Land;bergreiches Land;gebirgiges Land;Bergwelt
-Mittelgebirgslandschaft;Gebirgslandschaft;Berglandschaft
-hügelig;auf- und absteigend;uneben;wellig;kollin (fachspr.);gewellt;bucklig;buckelig
-Hügellandschaft;Hügelland;hügelige Landschaft
-(sich) sehen lassen können (ugs.);(sich) nicht verstecken müssen (ugs.);sein Licht nicht unter den Scheffel stellen brauchen (veraltend)
-Sachbefugnis;Passivlegitimation
-Landschaftsverbrauch;Zersiedelung
-schlechter Autofahrer;Sonntagsfahrer (abwertend, Hauptform);(Fahrer) ohne Fahrpraxis
-zusammenhalten;zueinander halten;(fest) zusammenstehen;zu jemandem halten;Schulter an Schulter stehen (fig.);zusammenhalten wie Pech und Schwefel (Verstärkung) (ugs.);zwischen (zwei) passt kein Blatt Papier (ugs.)
-hoffnungslos;(ein) Die-Hard (engl., fig.);hartgesotten;Berufs...;eingefleischt;(...) vom Dienst;aus Überzeugung;überzeugt;ewig;unverbesserlich;ausgemacht
-Weichziel(e) (militärisch);Menschenmaterial;Kanonenfutter (fig.)
-Himmelfahrtskommando;selbstmörderisches Unternehmen;glatter Selbstmord (fig.);Kamikazeaktion;Selbstmordkommando;Selbstmordaktion
-Bootstour;Bootsfahrt
-deflorieren;entjungfern
-nicht mal;nicht mehr als;nur (vor Zahl) (Hauptform);grade mal (ugs.);keine (+ Zahl);gerade mal;hauchdünn (fig.);knapp;gerade eben;sehr knapp;kaum;denkbar knapp;so gerade eben (noch) (ugs.);grad mal (ugs.);gerade noch
-mit viel Mühe;mehr schlecht als recht (ugs.);(nur) mit größter Anstrengung;mit letzter Kraft;mit Ach und Krach (ugs.);halblebig (ugs., schwäbisch);mit Mühe und Not;mit Hängen und Würgen;schlecht und recht;unter Aufbietung der letzten Reserven;unter Schwierigkeiten;so gerade eben (ugs.);(nur) mit Schwierigkeiten;unter größten Anstrengungen;nach mehrfachen Anläufen;mit knapper Not;nach langem Bemühen;mit Müh und Not;unter Aufbietung aller Kräfte
-unverdientermaßen (Hauptform);ohne, dass es gerechtfertigt wäre;ungerechtfertigterweise;ohne es (wirklich / eigentlich) verdient zu haben;unverdienterweise
-unter einer Decke stecken (ugs., fig.);gemeinsame Sache machen
-stadtbekannt;einschlägig bekannt;jeder kennt (...);allgemein bekannt;bekannt wie ein bunter Hund
-er möge ruhen in Frieden;er möge in Frieden ruhen;Gott hab ihn selig;möge Allah seiner Seele gnädig sein;Friede seiner Asche;Allah sei seiner Seele gnädig
-Normstaub;Prüfstaub
-Abgeschobener;Abzuschiebender;Abschiebehäftling;Schubhäftling (österr.);Schübling
-Sommerblüher;Sommerflor (werbesprachlich)
-Aussperrung (im Internet);virtuelles Hausverbot;Forensperre
-Zwangsausbürgerung;Entzug der Staatsbürgerschaft;Expatriierung;Expatriation;Verlust der Staatsbürgerschaft;Ausbürgerung;Aberkennung der Staatsbürgerschaft
-Zwangsverschickung;Verschleppung (Menschengruppen);Deportation;Zwangsumsiedlung
-Philippchen;Glanzbild(er);Glanzbildchen
-Weißer Thun;Langflossenthun
-Blauflossen-Thunfisch;Großer Thun;Roter Thun;Nordatlantischer Thun
-Ahi;Gelbflossen-Thun
-Österreichisch-Französischer Krieg von 1809;Fünfter Koalitionskrieg
-Magnatenverschwörung;Wesselényi-Verschwörung
-sediert;(mit Medikamenten) ruhiggestellt
-Mittelwort;Partizip
-definiter Artikel;bestimmter Artikel
-unbestimmter Artikel;indefiniter Artikel
-Artikellosigkeit;Nullartikel
-artikellos;ohne Artikel
-Determinierer (fachspr.);Determinativ (fachspr.);Begleiter (fachspr.);Determinant (fachspr.);Determinante (fachspr.);Determinans (fachspr., lat.);Artikelwort (fachspr.);Determiner (fachspr., engl.)
-Possessivartikel;besitzanzeigendes Fürwort (fälschlich, veraltet);besitzanzeigender Begleiter;Possessivbegleiter (Hauptform);Possessivpronomen (fälschlich, veraltet)
-Drifter (engl.);Backpacker (engl.);Rucksackreisender;Rucksackurlauber;Rucksacktourist
-E-Piano;Masterkeyboard;Digitalpiano;elektronisches Piano;Keyboard (Hauptform)
-Blauer Eisenhut (fachspr., botanisch);Sturmhut;Aconitum napellus (fachspr., botanisch);Eisenhut (ugs., Hauptform);Akonit;Wolfswurz (veraltet)
-Klappe;Revers (franz.);Aufschlag
-Längestrich;Querstrich;Makron (Hauptform);Überstrich (ugs.);Macron
-Bezeichner;Identifikator
-Debugsymbol;Symbolinformation
-Hybridklavier;Hybrid-Piano;Hybrid-Klavier;Hybridpiano
-Clavicembalo (ital.);Kielklavier;Gravicembalo;Cembalo (fachspr., ital.);Klavizimbel;Virginal;Kielflügel;Spinett;Oktavspinett (Sonderform)
-Transportverpackung;Versandverpackung
-Megalomanie (fachspr.);Titanismus (geh.);Vermessenheitsverzerrung (fachspr.);übersteigertes Selbstbewusstsein;Selbstüberschätzung;Selbstüberhebung (geh.);Größenwahn
-Rhodes Piano;Rhodes;Fender Rhodes
-Tastenfeld;Manual;Tastatur;Klaviatur
-Allseitenrad;omnidirektionales Rad
-über den;übern (ugs.)
-(Autohersteller-)Niederlassung;Autohaus
-Oberflurhydrant (österr.);Überflurhydrant
-Schieberkappe;Schieberkasten;Hydrantenkasten;Straßenkappe
-Spektroskopie;Spektrometrie;Farbzerlegung
-Kalenderspruch;Kalenderweisheit;Lebensweisheit;weiser Spruch;alte chinesische Weisheit (ugs.);Lebensregel
-im Sterben liegen (Hauptform);es nicht mehr lange machen (derb);(jemandem) wachsen schon Flügel (derb, sarkastisch);(es) geht zu Ende (mit jemandem);ans Sterben kommen (geh., veraltend);es bald hinter sich haben (ugs., salopp);(jemandes) letzte Tage sind gekommen;(bald) gehen (fig., verhüllend);seine Tage beschließen (geh.);(jemandes) Tage sind gezählt;in den letzten Zügen liegen
-(sich) ertränken;ins Wasser gehen (veraltet)
-(sich) eine Kugel in den Kopf jagen;(sich) erschießen;(sich) die Kugel geben (meist iron.) (ugs.);(sich) eine Kugel in den Kopf schießen;(sich) (das) Gehirn wegblasen (ugs.)
-Schellentrommel;Tambourin;Tamburin
-Madame Non (ugs.);Kohls Mädchen (ugs.);Mutti (ugs.);(das) Mädchen (ugs.);Angela Merkel (Eigenname);Angie (ugs., Eigenname)
-Sulzbacher Alpen;Steiner Alpen;Sanntaler Alpen
-Brioni-Kanzler (ugs.);Gerhard Schröder (Eigenname, Hauptform);Basta-Kanzler (ugs.);(der) Genosse der Bosse
-Häuptling Silberzunge (ugs.);Kurt Georg Kiesinger
-Mecki;Kurt Beck
-Franz Müntefering;Münte
-Frau Tricksilanti;Andrea Ypsilanti
-Apo-Opa;Hans-Christian Ströbele
-(das) Cleverle;Lothar Späth
-(der) Bock vom Babelsberg (ugs.);nachgedunkelter Schrumpfgermane (Sarkasmus) (ugs.);ungebleichter Schrumpfgermane (Sarkasmus) (ugs.);Joseph Goebbels;Wotans Mickymaus (Spottname) (ugs.)
-Friedrich Zimmermann;Old Schwurhand
-(der) lila Drache;Miss Bildung;Margot Honecker
-(der) Markt-Graf;Otto Graf Lambsdorf
-Bush's Pudel;Tony Blair
-(die) Reichswasserleiche;Kristina Söderbaum (Eigenname)
-Westdeutschland;(die) Trizone (historisch);(die) Westzone (historisch);alte Bundesländer;BRD (Abkürzung);Trizonesien (ugs., historisch, scherzhaft);Kohlrabien (ugs., historisch, scherzhaft)
-Stotter-Ede;Stoi-Bär;Edmund Stoiber;(das) blonde Fallbeil
-Reichsschamhaarmaler;Adolf Ziegler;Meister des deutschen Schamhaares;Maler des deutschen Schamhaares
-Honi;Erich Honecker
-Reichsjägermeister;Hermann Göring
-Reichsgletscherspalte;Leni Riefenstahl
-Heinrich Himmler;Reichsheini (ugs.);Hitlers Anhimmler (ugs.)
-Rettenbachferner;Rettenbachgletscher
-Adolf Hitler;(der) Führer;(der) böhmische Gefreite;(der) GröFaZ (ugs., ironisch);(der) größte Feldherr aller Zeiten (ugs., ironisch)
-jedenfalls danke;erst mal vielen Dank;danke jedenfalls;derweil sagt danke (...);vielen Dank fürs Erste;vorerst vielen Dank;fürs Erste vielen Dank;danke derweil;danke so weit;bis hierhin vielen Dank;so weit vielen Dank
-Bohemien;Bohémien;Künstlernatur
-überschätzen;überbewerten;(einer Sache) zu viel Gewicht beimessen;zu hoch bewerten;zu viel Wichtigkeit beimessen
-Nonameartikel;Gattungsmarke;weiße Ware;No-Name-Produkt
-Weißer Sonntag;Kleinostern;Klein-Ostertag
-ausgesorgt haben;nicht mehr arbeiten (müssen)
-(sich) heraushalten;(sich) abseits halten (geh.);abseitsstehen (geh.);(sich) nicht einmischen;(sich) um seine (eigenen) Angelegenheiten kümmern
-gesegnet;gebenedeit (christlich-relig.)
-Anspruch;Ambition;Prätention;Niveau;Qualität
-Freund der Familie;Hausfreund;Freund des Hauses
-Britannische Mark (veraltet);Bretonische Mark
-Bretagne;Kleinbritannien (veraltet)
-Parteichef;Parteivorsitzender;Vorsitzender einer Partei
-Lohnuntergrenze;Mindestlohn
-(eine Sache) totschweigen;nichts davon ans Licht der Öffentlichkeit kommen lassen;nicht ans Licht der Öffentlichkeit gelangen lassen;(den) Mantel des Schweigens breiten (über) (fig.);(über etwas) Gras wachsen lassen (ugs., fig.);geheim halten;unter den Teppich kehren (ugs., fig.);(absolutes) Stillschweigen bewahren (über);unter dem Deckel halten (fig.);unter Verschluss halten (fig.);unter den Tisch kehren (ugs., fig.);unter der Decke halten (fig.)
-nicht preisgeben (geh.);(jemandem etwas) verheimlichen;(die) Diskretion wahren;nicht weitererzählen;nicht ausplaudern;mit niemandem sprechen über (ugs.);in seinem Herzen verschließen (lit.) (geh.);(etwas) niemandem sonst erzählen;(aus etwas) ein Geheimnis machen;niemandem etwas sagen (von) (ugs., variabel);nicht weitergeben (eine Information);nicht weitersagen;Stillschweigen bewahren (geh.);in seinem Herzen bewahren;für sich behalten;verschweigen (Hauptform);mit ins Grab nehmen (fig.);nicht verraten
-nicht aussagen;nichts sagen;keine Aussage machen;beharrlich schweigen;nichts sagen wollen (zu);(die) Zähne nicht auseinanderbekommen (ugs.);(die) Omertà gilt (für);nicht mit der Sprache herausrücken (ugs.);dichtmachen (ugs.);(sich) bedeckt halten;zusammenhalten wie Pech und Schwefel;dichthalten (ugs.);der Omertà unterworfen (sein) (geh.);nicht singen (ugs., Jargon);(sich) ausschweigen (Hauptform);(den) Mund halten (ugs.);jede Antwort verweigern;nicht kooperieren (mit Ermittlungsbehörden);nicht aussagen (gegen);aus jemandem ist nichts herauszubekommen;(die) Aussage verweigern
-singen wie eine Nachtigall (im Kontext Verhör) (ugs.);gesprächig werden (im Kontext Verhör) (ugs.);anfangen zu reden (im Kontext Verhör)
-Diskretion vereinbaren;vertraulich behandeln;mit dem Siegel der Verschwiegenheit versehen
-Schweigepflicht;Schweigegelübde;Schweigegebot;Omertà
-geheim halten;(absolutes) Stillschweigen vereinbaren;(sich absolute) Diskretion ausbitten;(den) Mantel des Schweigens (aus)breiten (über);unter ein Schweigegebot stellen;auf absoluter Diskretion bestehen
-am Anschlag;an der Belastungsgrenze;an der Auslastungsgrenze;am Limit;an der Kapazitätsgrenze
-(das) Ende der Fahnenstange (fig.);(noch) weiter geht's nicht
-jemand sagt nichts mehr (zu);(jemandem) fehlen die Worte;nichts mehr einfallen (zu);(jemandem) bleibt (da) die Spucke weg (ugs., fig.);(jemand) weiß nichts mehr zu sagen;(jemandem) verschlägt es die Sprache;Gö, jetzt bist stad! (ugs., österr.);(jemandem hat es) die Sprache verschlagen;sprachlos sein;(jemandem) fällt nichts mehr ein (zu) (ugs.);verstummen
-fristlose Kündigung;Kündigung aus wichtigem Grund (juristisch);außerordentliche Kündigung (juristisch)
-Baseballkeule (ugs.);Baseballschläger
-Softballschläger;Softballkeule (ugs.)
-Jamal-Halbinsel;Samojeden-Halbinsel
-im Vertrauen (sagen);unter der Rose (gesagt) (geh., selten);unter dem Siegel der Verschwiegenheit;sehr persönlich;privatim (geh., veraltend);sub rosa (dictum) (geh., bildungssprachlich, lat., selten);nicht für andere (fremde Ohren) bestimmt;vertraulich
-nichts verlauten lassen;nichts nach außen dringen lassen (fig.);(etwas) unter Verschluss halten (fig.);(sich) bedeckt halten
-(sich) einer Stellungnahme enthalten (variabel);nicht kommentieren;nicht Stellung nehmen (wollen) (zu);(sich) mit Kommentaren zurückhalten;da(rüber) schweigt des Sängers Höflichkeit (geh., Redensart);die Schnauze nicht aufmachen (ugs.);(zu etwas) hört man nichts von (Seiten ...);(zu etwas) gibt es von unserer Seite nichts zu sagen.;nichts zu sagen haben (zu);Kein Kommentar.;(über etwas) nicht sprechen (wollen);(über / zu etwas) keine Auskunft geben können;zur Kenntnis nehmen (Jargon, verhüllend);keinen Kommentar abgeben (wollen) (zu);(etwas) unkommentiert lassen;(sich) bedeckt halten;(sich) wenig auskunftsfreudig zeigen (geh., ironisierend);nichts sagen (zu etwas);(von jemandem ist) nichts zu erfahren;keinen Gesprächsbedarf haben (ironisch);(zu etwas) nichts sagen (wollen);(das) Maul nicht aufkriegen (derb);nichts Falsches sagen wollen;(sich) ausschweigen (zu);(sich) in Schweigen hüllen;(sich) nicht äußern zu (Hauptform);(die) Schnauze halten (derb);niemandem zu nahetreten wollen (geh., floskelhaft, formell);keine Stellungnahme abgeben (wollen) (zu);mit etwas hinter dem Berg(e) halten (ugs.)
-(etwas) nicht auszusprechen wagen;(etwas) nicht über die Lippen bringen (ugs.);(etwas) nicht aussprechen
-Morelle;Schattenmorelle
-Kragenspiegel;Kragenpatte
-Gemeindeautonomie;Gemeindefreiheit
-Liegenschaftskarte;Flurkarte;Katasterkarte
-Raumflughafen;Raumhafen (Kurzform);Weltraumbahnhof;Kosmodrom;Weltraumhafen
-anstehen;(etwas) geplant haben (ugs.);auf dem Programm stehen (fig.);zu erledigen sein;geplant sein
-Operationstisch;OP-Tisch (Kurzform)
-Operationsleuchte;OP-Leuchte (Kurzform)
-luftig;luftdurchweht;windumtost (lit.) (geh.);zugig;luftdurchströmt;dem Wind ausgesetzt;von Wind umbraust (lit.) (geh.);windig
-sturmdurchbraust;sturmdurchweht;stürmend;tobend (Wind);orkanartig;stürmisch (Hauptform)
-Beteiligung;Einbringung;Zutun
-viel von (etwas) halten;sehr schätzen;sehr achten;hoch schätzen;wertschätzen (geh.);den Hut vor (etwas) ziehen (ugs.);respektieren;großen Respekt vor (etwas) erweisen
-Parasol (veraltet);Sonnenschirm
-Platteisen;Plätteisen (mitteldeutsch, norddeutsch);Glätteisen (schweiz.);Bügeleisen
-(einen) Megaflop hinlegen (ugs.);mit Pauken und Trompeten durchfallen (beim Publikum) (ugs.);(einen) Superflop einfahren (ugs.);eine (krachende) Bruchlandung hinlegen (mit) (journal.)
-ausquetschen wie eine Zitrone (ugs.);(jemanden) ausfragen;intensiv befragen;(jemanden) löchern (ugs.);ein Loch in den Bauch fragen (ugs.);(jemanden) ausquetschen (ugs.);(jemandem) Löcher in den Bauch fragen (ugs.)
-(jemanden) auseinandernehmen (ugs.);(mündliche) Prüfungsfragen stellen;(jemanden) (gründlich) durch die Mangel drehen (ugs., fig.);(jemanden) in die Mache nehmen (ugs.);examinieren;(jemandem) (gründlich) auf den Zahn fühlen (ugs., fig.);(jemanden) in der Mache haben (ugs.);(mündlich) prüfen
-erregt;explosiv;aufgeheizt (Stimmung) (Hauptform);gespannt;angespannt;zum Zerreißen gespannt (floskelhaft);gereizt;aufgeladen;geladen;aufgepeitscht
-menschenähnliches Wesen;Humanoid
-Homunkulus (lat.);Android (griechisch);künstlicher Mensch;Golem (hebräisch);Homunculus (lat.);Androide (griechisch)
-Hausmarke;Eigenmarke;Handelsmarke
-Liegnitzer Bombe;Kirschbombe
-Neisser Konfekt;Neisser Pfefferkuchen
-Minor-Test;Iod-Stärke-Test
-kumulierte Häufigkeit;kumulative Häufigkeit;Summenhäufigkeit
-empirische Statistik;deskriptive Statistik;beschreibende Statistik
-statistisches Merkmal;statistische Variable
-Teleabstimmung;Televoting;Telefonabstimmung
-voraussetzen;unterstellen;davon ausgehen;erwarten
-Teschener Schlesien;Teschener Land;Teschener Raum;Teschener Gebiet
-Heimchen (ugs.);Heimchen am Herd (ugs.);Aschenbrödel (ugs.);Mauerblümchen (ugs.);Aschenputtel (ugs.);Stiefkind (ugs.);graue Maus (ugs., fig.)
-Geh mir vom Acker! (ugs.);Mach, dass du wegkommst! (ugs.);Scher dich fort! (ugs., veraltend);Zieh ab! (ugs.);Verpiss dich! (derb);Sieh zu, dass du Land gewinnst! (ugs.);Hau ab! (ugs.);Fort mit dir! (veraltend);Abmarsch! (ugs.);Zisch ab! (ugs.);Geh (doch) dahin, wo der Pfeffer wächst! (ugs.);Raus (mit dir)! (ugs.);Hutsch dich! (ugs., österr.);Kratz die Kurve! (ugs.);Geh!;Scher dich zum Teufel! (ugs., veraltend);Geh mit Gott, aber geh! (Redensart);Scher dich weg! (ugs., veraltend);Da ist die Tür! (ugs.);Schieb ab! (ugs.);Hinfort mit dir! (geh., altertümelnd);Weiche von mir! (geh., veraltet);Mach Meter! (ugs., österr.);Hau ab und komm nicht wieder! (ugs.);Zieh Leine! (ugs.);Baba und foi ned. (ugs., wienerisch);Schau, dass du weiterkommst. (ugs., süddt., variabel);Mach, dass du fortkommst!;Pack dich! (ugs.);Geh weg!;Verzupf dich! (ugs., österr.);Sieh zu, dass du weiterkommst! (ugs.);Wegtreten! (militärisch);Mach 'n Abgang! (ugs.);Verzieh dich! (ugs.);Mach die Fliege! (ugs.);Schleich di! (ugs., süddt.);Schleich dich! (ugs.);Abflug! (ugs.);Verschwinde wie der Furz im Winde! (ugs., scherzhaft);Fahr zur Hölle! (derb, aggressiv);Mach 'ne Fliege! (ugs.);Geh sterben! (derb);Verschwinde! (ugs.);Schwirr ab! (ugs.);Geh mir aus den Augen! (ugs.);Schieß in'n Wind! (ugs.)
-Zigarre;Stumpen (ugs.)
-Oh Gott! (ugs.);(ach du) heiliger Strohsack! (ugs.);unglaublich! (ugs., Hauptform);da schau her! (ugs.);ich krieg' zu viel! (ugs.);Ach du dickes Ei! (ugs.);(es ist) nicht zu fassen! (ugs.);ach du grüne Neune! (ugs.);Ach du Scheiße! (derb);Das haut einen glatt vom Stuhl (ugs.);oh jemine! (ugs., veraltet);ist nicht wahr! (ugs.);Jetzt schau sich das einer an! (ugs.);Wahnsinn! (ugs.);meine Herren! (ugs.);ach du lieber Gott! (ugs.);oh là là (ugs., franz.);Ach Gott! (ugs.);mein lieber Mann! (ugs.);(ach) du lieber Himmel! (ugs.);nein, sowas! (ugs.);nein, so etwas! (ugs.);(es ist) nicht zu glauben! (ugs.);ich glaub' mein Schwein pfeift! (ugs.);heilig's Blechle! (ugs., schwäbisch);ach herrje! (ugs.);Ach Gottchen! (ugs.);Schockschwerenot! (ugs., veraltet);man glaubt es nicht!;ach was! (ugs.);Ach du liebes Lieschen! (ugs.);das darf (doch) nicht wahr sein! (ugs.);(na) sieh mal einer guck! (ugs.);ich glaub' es nicht!;ich glaub' ich steh im Wald! (ugs.);Oh Gottogott! (ugs.);auch das noch (ugs.);Ach du liebes Herrgöttle! (ugs.);Ach du liebes bisschen! (ugs.);ich werd' nicht mehr! (ugs.);Teufel auch! (ugs., variabel);Ach du meine Nase! (ugs., Kindersprache, ostdeutsch);da legst di nieda! (ugs., bayr.);Schreck lass nach! (ugs.);nein, so was! (ugs.);Ach, du Schreck! (ugs.);Ach herrjemine! (ugs.);Mensch (+ Name) (ugs.);oh je! (ugs.);(ach du) heiliger Bimbam! (ugs.);(nein) sag bloß! (ugs.);das hat (mir) gerade noch gefehlt (ugs.)
-Komm' mal klar! (ugs.);Beruhige dich!;Achte auf deinen Blutdruck! (ugs.);Chill dein Leben! (ugs.)
-Korallenmeer;Korallensee
-Salomonensee;Salomonsee
-Tasmansee;Tasmanische See;Tasmanisches Meer
-Papuaterritorium;Territorium Papua
-wenn es;wenn's (ugs.);wenns (ugs.)
-zu viel kriegen (ugs.);der Lage nicht Herr werden;(einer Sache) nicht gewachsen sein;(jemandem) über den Kopf wachsen (fig., Hauptform);ein paar Nummern zu groß sein (ugs.);überfordert (sein mit);(jemandem) zu viel werden (ugs.);nicht klarkommen mit (ugs.);nicht hinterherkommen (ugs.);nicht mehr mitkommen (ugs.);(jemanden) überfordern;zu viel sein (ugs.);eine Nummer zu groß (ugs.);(etwas) nicht in den Griff bekommen (fig.);nicht bewältigen;im Chaos versinken (fig.);nicht schaffen
-Penisamputation;Penektomie (fachspr.)
-Projektstudie;Machbarkeitsstudie
-Aktuatorik;Aktorik
-Rollenförderer;Rollentransfer
-angewandte Ethik;Bereichsethik
-Gesellschaftsethik;Sozialethik
-Ethik in der Technik;Technikethik;Technik-Ethik
-es hat bei ihnen gefunkt (ugs.);es hat zwischen ihnen gefunkt (ugs.);von etwas auf den ersten Blick begeistert sein;(sich) auf Anhieb in jemanden verlieben;der Funke springt zwischen ihnen über (ugs.);Liebe auf den ersten Blick;(sich) auf den ersten Blick in jemanden verlieben
-Entfesselungskünstler;Eskapologe
-ein paar in die Schnauze kriegen (ugs.);was auf die Schnauze kriegen (ugs.);ein paar in die Fresse kriegen (ugs.);einen Schlag ins Gesicht bekommen;eins in die Fresse kriegen (ugs.);Schläge ins Gesicht bekommen;eins in die Schnauze kriegen (ugs.)
-(jemanden) sitzen lassen (ugs.);(jemanden) fallen lassen wie eine heiße Kartoffel (ugs.);(jemanden) ins Bergfreie fallen lassen (Verstärkung) (ugs.);(jemanden) aufgeben;(jemanden) seinem Schicksal überlassen;fallen lassen;(jemanden) (plötzlich) im Stich lassen
-Amputation;Abtrennung eines Körperteils
-Eremit;Juchtenkäfer
-in selbstherrlicher Weise;aus eigener Machtvollkommenheit;nach Gutsherrenart;in selbstherrlicher Manier;willkürlich
-muss ich mir (jetzt) Sorgen machen? (ugs., ironisch);alles in Ordnung bei dir? (meist ironisch) (ugs.);geht's noch? (ugs.);(aber) sonst geht's dir gut? (ugs.);alles okay (so weit)? (ugs.);sonst alles okay? (ugs.)
-geile Schnecke;Sahnetörtchen;heiße Schnitte;scharfe Tussi
-ein ziemliches Stück zu laufen;schon eine Strecke (ugs.);ein gutes Stück zu laufen;nicht gerade ein Katzensprung;ein gutes Stück zu fahren;ein ziemliches Stück zu fahren
-Kabelgedöns (ugs., abwertend);(die ganze) Kabelage (ugs.);verhedderte Kabel;Kabelgewirr;Durcheinander von Kabeln;Kabelsalat (ugs., variabel)
-Splitterschutzzelle;Einmannbunker
-(mit jemandem) keinen Kontakt mehr suchen;(für jemanden) gestorben sein (ugs., fig.);(mit jemandem) fertig sein;(für jemanden) erledigt sein;(jemandem) aus dem Weg gehen;(den) Kontakt (zu jemandem) abbrechen (Hauptform);bei jemandem abgemeldet sein (ugs., fig.);(jeglichen) Kontakt mit jemandem (zu) vermeiden (suchen);mit jemandem nichts mehr zu tun haben wollen (ugs.)
-ausrichten lassen, dass man nicht da ist;(sich) (am Telefon) verleugnen lassen (Hauptform);(für jemanden) nicht zu sprechen sein
-nicht ans Telefon gehen (ugs.);(einen) Anruf abweisen;(den) Hörer nicht abnehmen;(das Telefon) nicht abnehmen;(den) Telefonstecker herausgezogen haben;telefonisch nicht (mehr) erreichbar sein;(einen) Anruf wegdrücken (ugs.);(das) Telefon abgestellt haben (variabel);(ein) Gespräch nicht annehmen;(jemanden, der anruft) wegdrücken (ugs.)
-meglenitische Sprache;meglenorumänische Sprache
-(jemandem) das Leben zur Hölle machen (ugs.);(jemandem) das Leben sauer machen (ugs.);(jemandem) das Leben schwer machen (ugs.)
-(jemandem) nicht über den Weg trauen (ugs., fig.);(jemandem) nicht trauen;(jemandem) nicht trauen können;misstrauisch sein;(jemandem) misstrauen;(jemandem) ist nicht zu trauen;(jemandem) nicht für 5 Pfennige trauen (können) (variabel, veraltend);(jemandem) nicht um die Ecke trauen (fig.)
-zwischen den Stühlen stehen (fig.);zwischen zwei Stühlen sitzen (fig.);hin- und hergerissen sein;zwischen zwei Stühlen stehen (fig.);zwischen den Fronten (stehen) (fig.)
-sauer (ugs.);verärgert (über, wegen) (Hauptform);verstimmt (über, wegen);not amused (Understatement, engl., scherzhaft-ironisch);stinksauer (ugs.);ärgerlich (ugs.);indigniert (geh.);wenig erfreut (Understatement);vergnatzt (ugs., berlinerisch, norddeutsch);verschnupft (wegen) (fig.);stocksauer (ugs.);ungehalten;angefressen (ugs.);angepisst (derb);vergrätzt (ugs.);(jemandem) gram (geh.)
-aufgeregt;erregt;in Aufruhr;echauffiert;erhitzt
-nicht mehr zu halten;(schwer) in Fahrt;kaum noch zu bändigen;(jetzt erst) richtig loslegen
-(leicht / ziemlich) angesäuert (ugs.);giftig;stinkig (ugs.);säuerlich (ugs.);eingeschnappt (ugs.);angesickt (ugs.);sauer (ugs., Hauptform);gereizt;angefressen (ugs.)
-nicht vorbereitet sein auf;nicht gefasst sein auf;auf dem falschen Fuß erwischen (fig.);nicht rechnen können mit;(jemanden) kalt erwischen;unvorbereitet treffen;nicht gerechnet haben mit
-sagen, was zu tun ist;alle Fäden in der Hand haben (fig.);die Fäden in der Hand haben (fig.);Herr des Verfahrens (sein);die Fäden in der Hand halten (fig.);alles fest im Griff haben (ugs.);sagen, wo es langgeht (ugs.);alle Fäden in der Hand halten (fig.);alles im Griff haben (ugs.);alles unter Kontrolle haben
-(jemandem) die Existenzgrundlage entziehen;an den Bettelstab bringen;(jemanden) zugrunde richten;(jemandes) Existenz zerstören;(jemanden) ruinieren (Hauptform);(jemanden) zu Grunde richten;(jemandem) den (letzten) Rest geben
-(jemanden) ausbeuten;(jemanden) aussaugen;(jemandes) Arbeitskraft ausbeuten;das Letzte aus jemandem herausholen
-(etwas) in der Nähe;nahegelegen;nah (räumlich) (Hauptform)
-ökologisch-soziale Marktwirtschaft;ökosoziale Marktwirtschaft;ökologische Marktwirtschaft
-Irenismus;Irenik
-Schulfach;Schulgegenstand;Fach;Lehrfach;Unterrichtsgegenstand (österr.);Unterrichtsfach
-(noch) Herr seiner Sinne;(noch) im Vollbesitz seiner geistigen Kräfte;(noch) voll auf dem Posten (ugs.);(erstaunlich) rüstig;(noch) voll da (ugs.);(noch) gut dabei (ugs., regional)
-Umgeld;Ohmgeld;Ungeld
-entwerten;knipsen lassen;unbrauchbar machen;lochen lassen;abstempeln (lassen)
-Messlupe;Fadenzähler
-abwechslungsreich;spaßig;unterhaltend;kurzweilig;unterhaltlich (geh.);unterhaltsam
-Prolo (ugs.);Proll (ugs.);Primitivling;Banause;Botokude (derb, veraltet);Barbar (geh., sehr selten);Prolet
-Schlafstörung(en);Schlafproblem(e)
-eindrücken;einwerfen;einschlagen;eintreten
-Judokämpfer;Judoka
-Start-up-Firma;Start-up (engl.);Start-up-Unternehmen;junges Unternehmen
-ringsum;wohin ich auch blicke;rings um (etwas);ringsumher (geh.);weithin;rundherum;im (weiten) Umkreis;ringsherum;wo man (auch) hinguckt (ugs., bundesdeutsch);um sich herum
-Westliche Honigbiene;Europäische Honigbiene
-Handelsvertreter (fachspr.);Commis-Voyageur (geh., franz., veraltet);Vertreter (für) (ugs., Hauptform);Außendienstler (ugs., Jargon);Außendienstmitarbeiter;Mitarbeiter im Außendienst;Reisender (fachspr., auch figurativ);Handlungsreisender (fachspr., auch figurativ, veraltend)
-sehr wichtig nehmen;(all)zu wichtig nehmen;für (sehr / zu / allzu) wichtig halten;(eine) große Bedeutung zuschreiben;(einen) hohen Stellenwert zuerkennen;hoch hängen (ugs., fig.);(einen) hohen Wert beimessen
-Expertenmeinung;Expertenrat;fachmännische Einschätzung;Fachauskunft;Expertise;Einschätzung eines Fachmanns
-0;null
-Unterlassungserklärung;Unterwerfungserklärung
-Die-hard-Fraktion (ugs., salopp);harter Kern (ugs., Hauptform);(die) ganz harten Fans (ugs.)
-Ovar;Fruchtknoten
-Gymnosperme (fachspr.);nacktsamige Pflanze;Nacktsamer
-zum Schreien sein (ugs.);zum Schießen aussehen (ugs.);unmöglich aussehen (ugs.);verboten aussehen (ugs.)
-engste Vertraute;engster Kreis
-verschworene Gemeinschaft;Mafia (derb, abwertend, fig., variabel);Clique (um jemanden) (ugs., Hauptform);Camarilla;Kamarilla (abwertend)
-angestellter Vertriebsmitarbeiter;Reisender
-Pitkrater;Schachtkrater
-Grabenbruch;Riftzone
-Hau weg, den Scheiß! (derb, fig.);Hauptsache, das (Zeug) sind wir los (ugs.);verlorenem Geld nicht noch weiteres hinterherwerfen;Hauptsache weg (ugs.);Hauptsache, den sind wir los (ugs.);Hauptsache, die sind wir los (ugs.);fort mit Schaden
-ins Internet stellen;ins Netz stellen;im Internet veröffentlichen
-ich krieg die Motten! (ugs., Spruch);wie isset denn möglich?! (ugs.);ich fress 'en Besen! (ugs., Spruch);das gibt's doch nicht! (ugs.);ja isset denn möglich!? (ugs.);Jetzt wird (aber) der Hund in der Pfanne verrückt! (ugs., Spruch, variabel);das kann doch wohl nicht wahr sein! (ugs.);ich glaub, mich holn'se ab! (ugs.);du kriegst die Tür nicht zu! (ugs., Spruch);das darf nicht wahr sein! (ugs.);(ja) ist denn das die Möglichkeit!? (ugs.);Mich laust der Affe! (ugs., Spruch);ich glaub, es geht los! (ugs., Spruch);ich werd' verrückt! (ugs.);du glaubst es nicht! (ugs.);das kann doch einfach nicht wahr sein! (ugs.);ich glaub, ich steh im Wald! (ugs., Spruch);(das ist ja) (ein) dolles Ding (ugs.);jetzt brat mir (aber) einer einen Storch! (ugs., Spruch);Ist nicht wahr! (ugs., Spruch, salopp);ich glaub, ich spinne! (ugs.);wie (...) ist das denn!? (ugs., jugendsprachlich);du kriegst die Motten! (ugs., Spruch);man glaubt es nicht! (ugs.);ich (glaub ich) werd zum Elch! (ugs., Spruch);jetzt brat mir einer 'en Storch (ugs., veraltet)
-Aal;Süßwasseraal
-Amerika;Neue Welt (ugs.)
-Karibisches Meer;Karibische See
-breiter Protest;Protest der Bürger;Bürgerprotest;Widerstand aus der Mitte der Gesellschaft;Protest aus der Mitte der Gesellschaft;breite Protestbewegung
-Aufmerksamkeitsdefizit-/Hyperaktivitätssyndrom;HKS (Abkürzung);Zappelphilippsyndrom;ADHS (Abkürzung);Aufmerksamkeitsdefizit-/Hyperaktivitätsstörung;Hyperaktivitätssyndrom;Hyperkinetische Störung;ADS (Abkürzung);Aufmerksamkeitsdefizitstörung;Psychoorganisches Syndrom (schweiz.);Aufmerksamkeitsdefizitsyndrom;Hyperaktivitätsstörung
-Selbstregulation;Impulskontrolle;Selbststeuerung
-keine (oder eingeschränkte) Selbststeuerung;mangelnde (oder fehlende) Selbstregulation;mangelnde Impulskontrolle
-(etwas/jemanden) am Hals haben (ugs.);(etwas/jemanden) an den Hacken haben (ugs.);(mit etwas/mit jemandem) nichts als Ärger haben (ugs.);(mit etwas/mit jemandem) Ärger haben
-Inklusivität;Einschließlichkeit
-Anatolien;Kleinasien
-Baiji;Jangtse-Delfin;Chinesischer Flussdelfin
-Baugruppe;Bautrupp;Montagegruppe
-Baugemeinschaft;Bauherrengemeinschaft;Baugruppe
-Montieren;Aufschlagen
-Sonnenschein;Sonnenstrahlen
-Endoderm;Entoderm
-Bolivarische Revolution;Bolivarianische Revolution
-Mikrostrukturtechnik;Mikrotechnik
-Nanotechnologie;Nanotechnik
-um sich versammeln;um sich scharen
-Anhaltspunkt;Größenordnung;grobe Schätzung;ungefähre Größe;Bereich;Hausnummer (ugs., fig., Hauptform)
-auf einmal (ugs.);plötzlich und unerwartet (floskelhaft);mit einem Mal;jählings (geh., veraltend);eruptiv (geh.);unversehens;jäh;ohne Überleitung;miteins (lit.) (geh., veraltet);abrupt;übergangslos;wie aus dem Nichts;völlig überraschend;unvermittelt;mit einem Schlag (fig.);aus heiterem Himmel (fig.);wie vom Blitz getroffen;urplötzlich;wie aus dem Boden gewachsen;ohne Übergang;schlagartig;über Nacht (auch figurativ);plötzlich (Hauptform)
-warme Mahlzeit;Hauptmahlzeit
-mit gestrafften Schultern;in strammer Haltung
-auf keinen Widerstand treffen;offene Türen einrennen (fig.);hochwillkommen sein
-Mitverantwortung;Mitschuld
-(sich) künstlich aufregen (über);zum Skandal machen;(es gibt) viel Geschrei wegen (ugs.);einen Skandal (aus etwas) machen;skandalisieren;Anstoß nehmen (an);großen Wirbel um etwas machen;künstlich aufbauschen
-wenig Begeisterung;verhaltene Reaktionen
-gute Auftragslage;voll ausgelastet;(auf Wochen / Monate) ausgebucht;volle Auftragsbücher (fig.);Auftragsbücher (sind) voll (fig.)
-ganz wichtig (jetzt): (ugs.);(gut) aufgepasst! (ugs., Hauptform);spitzt die Ohren! (ugs.);zuhören! (ugs.);jetzt kommt's! (ugs.);wohl aufgemerkt! (geh., veraltet);die Ohren gespitzt! (ugs.)
-Klerikalfaschismus;Klerikofaschismus
-Petersilienkonflikt (Eigenname);Petersilienkrieg (Eigenname)
-Tschingderassabumm;mit klingendem Spiel
-Musikkorps;Heeresmusikkorps
-ach komm! (norddeutsch);ach geh! (süddt.);nun lass mal gut sein
-Rachebringender;Racheengel (auch figurativ);Rächer (Hauptform)
-gregorianischer Choral;gregorianischer Gesang;Gregorianik (vereinfachend)
-(zeitliches) Konzept;Programm;Fahrplan (fig.);Roadmap (engl.);Choreografie (geh., fig.);Zeitplan;Terminplan;Ablaufplan
-giften;höhnen;ätzen;pesten;stänkern
-(Summe) vorauszahlen;in Vorleistung treten (geh.);vorfinanzieren;Kredit geben;in Vorleistung gehen
-(etwas ist) noch einmal gut gegangen;(wohl) einen Schutzengel gehabt haben;(noch einmal) davonkommen;Glück im Unglück haben;mit einem blauen Auge davonkommen (fig.);keinen größeren Schaden nehmen;(noch einmal) Glück gehabt haben (ugs.);glimpflich ausgehen;(es) hätte nicht viel gefehlt (und ...);glimpflich davonkommen
-(jemanden) zu Stillschweigen verdonnern;(jemanden) zu Stillschweigen verpflichten;(jemandem den) Mund verbieten (fig.);(jemanden) zu (absoluter) Verschwiegenheit vergattern
-(jemandem) zufliegen (ugs.);(jemandem) keine Mühe machen;nichts tun müssen (für) (ugs.);leichtfallen;(jemandem) leicht von der Hand gehen;(jemandem) in den Schoß fallen (fig.);(jemandem) fliegen die gebratenen Tauben ins Maul (derb, fig., sprichwörtlich);(jemandem) ohne Anstrengung zufallen;(sich) leichttun;mühelos schaffen;(jemandem) fliegen die gebratenen Tauben in den Mund (fig., sprichwörtlich, veraltend)
-zwölf Uhr nachts;null Uhr und null Minuten;Mitternacht;24 Uhr;vierundzwanzig Uhr;Geisterstunde;null Uhr
-(große) Hoffnungen setzen in (Hauptform);vertrauen auf;(sich) viel erhoffen von;bauen auf;sich viel versprechen von;(sich) verlassen auf;(fest) glauben an;setzen auf;viel erwarten von
-Chef vom Dienst;CvD
-Bedeutungsnähe;Sinnverwandtschaft;Bedeutungsähnlichkeit
-glaubhafte Bestreitbarkeit;glaubhafte Abstreitbarkeit
-Halbwelt;Demimonde (franz.)
-Künstlermilieu;Bohème (franz.)
-Freigeist;Freidenker;Libertin d'esprit (franz.);Libertin (franz.)
-sorry (ugs., engl.);tut mir echt leid;ich bin untröstlich;(bitte) vergib mir! (geh.);tut mir leid;tut mir außerordentlich leid;(ich) bitte tausendmal um Entschuldigung;bedaure;bedaure sehr;ich bitte um Vergebung (geh.);Kannst du mir noch mal verzeihen? (floskelhaft);Kannst du mir noch einmal vergeben? (geh.)
-ist ja super! (ugs., ironisch);na toll! (ugs., ironisch);na super! (ugs., ironisch);na großartig! (ugs., ironisch)
-Kryostase;Kryonik
-auf dem Fuße folgen;(direkt) aufeinander folgen;prompt kommen;nicht lange auf sich warten lassen;(sich) nahtlos anschließen;auf dem Fuß folgen;prompt erfolgen;unverzüglich erfolgen;unmittelbar folgen
-Wundertäter (Hauptform);Vollbringer von Wundern;Thaumaturg (geh.)
-von langer Hand vorbereitet;von langer Hand geplant;seit längerer Zeit geplant
-Brandrede;Hetzrede
-PMD-Sensor;Photomischdetektor
-Sackgasse;Stichstraße
-Fußgängerzone (Hauptform);Flaniermeile;Fußgängerbereich
-frühkindlicher Autismus;infantiler Autismus;Kanner-Autismus;Kanner-Syndrom
-Stressfaktor;Stressor
-verkehrsberuhigte Zone;Tempo-30-Zone
-Photometrie;Fotometrie
-Veränderlicher;veränderlicher Stern;variabler Stern
-koorbitaler Begleiter;koorbitales Objekt
-Chaostheorie;Chaosforschung
-Erdbahnkreuzer;erdnahes Objekt
-Plutoid;Planetoid;Zwergplanet
-Schlotgang;Schlot;Vulkanschlot;Sprengtrichter;Durchschlagsröhre;Eruptionsschlot;Diatrema;Neck
-Sill;Lagergang
-Residualgestein;Rückstandsgestein
-fluviales Sediment;fluviatiles Sediment
-marines Sediment;Meeressediment
-pyroklastische Ablagerung;pyroklastisches Sediment
-(etwas) vermitteln;(etwas) zum Ausdruck bringen;(etwas) deutlich machen;ein Zeichen setzen
-uneins werden;(sich) verkrachen (ugs.);im Streit auseinandergehen;(sich) entzweien;(sich) zerstreiten;brechen mit;(sich) verzanken;(sich) verfeinden;(sich) überwerfen
-nach Strich und Faden (ugs.);... (und / aber) frag nicht nach Sonnenschein! (ugs., Spruch);von vorne bis hinten;weidlich (geh., veraltend);(aber) so was von (ugs., Spruch, salopp);gehörig;gründlich;wo man dabeisteht (ugs.);nach allen Regeln der Kunst (fig.);ganz schön (ugs.)
-Eintrittskante;Nasenkante;Vorderkante;Profilnase
-Lipidstoffwechsel;Fettstoffwechsel
-Antiromaismus;Zigeunerfeindlichkeit;Antiziganismus (fachspr.)
-voller Sorge;mit Sorge;sorgenvoll
-Gruft;Grablege;Krypta
-Grabgewölbe;Grabkammer
-Popel;Popelmann
-böser Mann;Butz;Butzemann;Buschemann;Bullemann (regional);schwarzer Mann
-Plakate kleben;plakatieren;Plakate anbringen
-Oderebene;Schlesische Tiefebene;Schlesische Niederung;Schlesische Bucht
-(sich) der Realität verweigern;zumachen (ugs.);(die) Klappe fällt (bei jemandem) (ugs., fig.);nichts wissen wollen (von);(etwas) nicht an sich heranlassen (ugs., fig.);nicht zulassen;dichtmachen (ugs., fig.);nichts hören wollen (von);(die) Klappe geht runter (bei jemandem) (ugs., fig.);abblocken
-Positionsregelung;Lageregelung
-Anforderungen;Erwartungen;Ziele
-Koronargefäß;Herzkranzgefäß
-Beipass;Bypass
-Blutgerinnung;plasmatische Hämostase (fachspr.);sekundäre Hämostase (fachspr.)
-Haarnasenaffe;Trockennasenaffe;Trockennasenprimat
-Hypakusis (fachspr.);Schwerhörigkeit
-gehts (ugs.);geht es;geht's (ugs.)
-Wasserkopf;Gehirnwassersucht (veraltet);Liquorraumerweiterung;Hydrozephalus (fachspr., griechisch);Hydrocephalus (fachspr., griechisch)
-Anopie (fachspr.);Anopsie (fachspr.)
-netter Versuch! (ugs.);Nachtigall, ick hör dir trapsen! (ugs., berlinerisch)
-registrieren;Notiz nehmen von;mitbekommen;gewahr werden (geh.);wittern;mitkriegen (ugs.);merken
-Bedarf;Kauflaune;Nachfrage
-Bewertungsreserve;stille Reserve;stille Rücklage
-Alphafaktor;Jensen-Alpha
-Transaktionsgleichung;Verkehrsgleichung;Quantitätsgleichung;Tauschgleichung
-Marktrisiko;Marktpreisrisiko;Marktpreisänderungsrisiko
-systematisches Risiko;Marktrisiko
-Tesinotal;Tesinoebene
-Rotes Beinholz;Roter Hartriegel;Roter Hornstrauch;Cornus sanguinea (fachspr., botanisch);Hundsbeere;Blutroter Hartriegel
-Cornus (fachspr., botanisch);Hartriegel;Hornstrauch
-ungelenk;staksig (ugs.);steif wie ein Stock;stakig (ugs., regional);wie der Storch im Salat (ugs.);(als wenn er/sie einen) Stock im Arsch (hätte) (derb);verspannt;wie ein Stück Holz (ugs.);stocksteif;wie ein Storch im Salat (ugs.);bocksteif (ugs.)
-Einschicht (bayr., österr.);Einzelsiedlung;Einzellage;Einöde (bayr., österr.);Einzelhaus;Einzelhof;Einsiedlerhof
-Felssporn;Bergsporn;Geländesporn;Felsnase;Felsburg
-Felsturm;Felszinne;Felsnadel
-Penninische Alpen;Walliser Alpen
-Gleisdreieck;Bogendreieck
-Wendestern;Gleisfünfeck
-Oststeirisches Riedelland;Oststeirisches Hügelland
-durcheinander (ugs.);ungeordnet;unordentlich;nicht aufgeräumt;in Unordnung;kreuz und quer durcheinander (ugs.);kreuz und quer;wie Kraut und Rüben (ugs.);wie auf dem Schlachtfeld (ugs.);unaufgeräumt
-Klasse;Objekttyp
-Zweites Barock;Neobarock;Neubarock
-Druck-Vergleich;Monte-Carlo-Vergleich;Monaco-Vergleich;Bad-Säckingen-Vergleich;Las-Vegas-Vergleich;Chicago-Vergleich
-Alexanderzug;Alexanderfeldzug
-Griechische Völkerwanderung;Dorische Wanderung
-wie Perlen auf einer Schnur;wie die Hühner auf der Stange (ugs.);aufgereiht;wie die Orgelpfeifen (ugs.);in Reih und Glied
-klotzig;grobschlächtig;grob;vierschrötig;ungeschlacht (geh.);klobig
-Mängelexemplar (fachspr.);modernes Antiquariat (fachspr.);Remittende(n) (fachspr.);Ramsch (fachspr., Jargon)
-Benchmarking;Leistungsvergleich
-Bogengewichtsmauer;Bogengewichtsstaumauer
-goidelische Sprache;gälische Sprache
-kontinentalkeltische Sprache;festlandkeltische Sprache
-Studienfach;Lehrfach;Studienrichtung
-Ingenieurgeodäsie;Ingenieurvermessung
-angewandte Geodäsie;Stückvermessung;praktische Geodäsie;praktische Geometrie (veraltet);Detailvermessung;niedere Geodäsie
-Nutationsbewegung;Nutation
-Amazonenaxt;Doppelaxt;Labrys
-Livestream;Direktübertragung
-TP (Abkürzung);Triangulationspunkt;trigonometrischer Punkt;Trigonometer
-Vermarkung;Stabilisierung
-Fixpunkt;Festpunkt
-Spannmaß;Sperrmaß (österr.)
-Maß;Messwert
-Schrägdistanz;Schrägstrecke;schiefe Seite;Raumdistanz
-Zielpunkt;Detailpunkt
-Polarpunktaufnahme;Polaraufnahme
-Kippregel;Fernrohrlineal;Fernrohrdiopter;Messtischaufsatz
-Diopterlineal;Krokiergerät
-Messabweichung;Messfehler (veraltet)
-Messmittel-Fähigkeitsanalyse;Messsystemanalyse;Prüfmittel-Fähigkeitsanalyse
-Nachvollziehbarkeit;Vergleichspräzision;Vergleichbarkeit
-freie Standpunktwahl;freie Stationierung
-Polarkoordinatensystem;Kreiskoordinatensystem
-Disto;LaserDisto;Distomat;Distanzer
-Maßschneider;Bekleidungsgestalter (österr.)
-Ausbildungsberuf;Lehrberuf (österr.)
-Abschwächer;Dämpfungsglied
-Dritter Karnatischer Krieg;Dritter Karnataka-Krieg
-Preußen;Königreich Preußen
-Deutschlandfrage;Deutsche Frage
-Hungerturm;Faulturm
-Fangenturm;Fangelturm
-Immundefekt;Immunschwäche;Immundefizienz;Immuninkompetenz;Immuninsuffizienz
-Distanzwaffe;Fernwaffe
-Europäischer Iltis (fachspr.);Fiss;Iltis (ugs., Hauptform);Mustela putorius (fachspr., griechisch, lat.);Ratz;Waldiltis;Stänker
-Frett;Frettchen
-bestimmend;determinierend;herrisch
-Konditionalsatz;Bedingungssatz
-Zuschauereffekt;Bystander-Effekt;Genovese-Syndrom
-Sexus;Geschlecht;biologisches Geschlecht
-zahnmedizinische Prophylaxe;vorbeugende Zahnheilkunde;zahnmedizinische Prävention
-Afrika südlich der Sahara;Schwarzafrika;Subsahara-Afrika;subsaharisches Afrika
-Wolgahöhen;Wolgaplatte
-Jergenihügel;Jergenihöhen
-Kuma-Manytsch-Niederung;Manytschniederung
-Osteuropäische Ebene;Osteuropäisches Tiefland (veraltet);Osteuropäisches Flachland (veraltet)
-Oberrhein-Untermain-Senke;Oberrheinische Tiefebene;Oberrheinisches Tiefland
-Cytochrom;Zytochrom
-Nukleobase;Nucleobase;Nukleinbase;Nucleinbase
-Kristallisationskeim;Kristallisationskern
-Solidifikation;Desublimation;Deposition;Resublimieren;Resublimation
-Typinferenz;Typableitung
-Basslautsprecher;Subwoofer (engl.);Tieftöner
-dreisprachig;trilingual (fachspr.)
-einsprachig;monolingual (fachspr.)
-viersprachig;quadrilingual (fachspr.)
-Weiß-Laken-Käse;Salzlakenkäse
-Hofmeister-Reihe;Hofmeister-Serie;Lyotrope Serie
-Flüssigkristallpolymer;flüssigkristallines Polymer
-Acetylcystein;Mercaptursäure (veraltet)
-Hustenlöser;Expektorans (fachspr.);Expectorans (fachspr.)
-Exotoxin;Ektotoxin
-Tetanustoxin;Tetanospasmin
-Milzbrandtoxin;Anthrax-Toxin
-CD-ROM-Laufwerk;CD-Laufwerk
-Dreidecker;Tripeldecker
-Schützenschuh (österr.);Bundschuh (bayr.);Haferlschuh
-Fluchthaube;Brandfluchthaube
-Amalgamfüllung;Plombe (ugs.)
-Zahnmedizin (Hauptform);Zahn-, Mund- und Kieferheilkunde;Dentologie;Zahnheilkunde
-Goldklopffüllung;Goldstopffüllung;Goldhämmerfüllung
-Vormahlzahn;Prämolar
-Mahlzahn;Molar
-Tiefenpuffer;Tiefenspeicher-Verfahren
-Sehkegel;Sehpyramide
-Turgordruck;Turgor
-Eurasischer Altelefant;Europäischer Waldelefant
-Stückenzucker;Würfelzucker
-schmutzige Bombe;radiologische Waffe
-Kommunikationsdaten;Verbindungsdaten;Verkehrsdaten (juristisch)
-Heliograph;Spiegeltelegraph;Heliograph
-Nebeltau;Nebeltraufe
-Traufe;Dachtraufe
-Tropfkante;Tropfleiste;Wassernase
-Telefongesellschaft;Telko (ugs.);Fernmeldedienstanbieter (schweiz.)
-Impulsreferat;Impulsvortrag
-Heidekraut;Besenheide
-erweiternd;dilatativ (fachspr.);zur Erweiterung führend
-Wühltisch (ugs.);Grabbeltisch (ugs.)
-halbdurchlässiger Spiegel;Einwegspiegel;Spanischer Spiegel;Polizeispiegel;Venezianischer Spiegel;Spionspiegel
-Teilerspiegel;teildurchlässiger Spiegel
-Hartglas;Kristallglas
-Glasschleiferei;Glasschleifen
-Vorhangfassade;Vorhangwand
-hinterlüftete Fassade;vorgehängte hinterlüftete Fassade;vorgehängte Fassade
-Schafschwein;Mangalica-Schwein;Mangalitza;Mangaliza
-Schimmelpilzgift;Mykotoxin
-Schwämmli (schweiz.);Schwümm (schweiz.);Makromyzet;Schwammerl (bayr., österr.);Großpilz
-Eierschwammerl (bayr., österr.);Reherl (bayr., österr.);Pfifferling (Hauptform);Geldberle (fränk.);Eierschwämmli (schweiz.);Eierschwamm;Cantharellus cibarius FR. (fachspr., botanisch);Echter Pfifferling (fachspr., botanisch);Gelchen (sächsisch);Rehling (regional)
-Winterweide;Winterbeweidung;ganzjährige Außenhaltung;Winteraußenhaltung
-Simmentaler;Fleckvieh;Simmentaler Fleckvieh
-(allgemein) beliebt (sein);(jemandem) fliegen die Herzen zu;in jemandes Gunst (stehen) (geh.);Schwarm aller (...);wohlgelitten (sein) (geh.);(...) der Herzen (sein);Everybody's Darling (ugs., engl.);gern gesehen (sein);ganz oben auf der Liste (der ....) stehen (ugs.);Sympathiebolzen (ugs.);ganz oben auf der Beliebtheitsskala (mediensprachl.);umworben werden;Sympathieträger;gemocht werden;umschwärmt (werden);...schwarm
-Majorzwahl (schweiz.);Mehrheitswahl
-D'Hondt-Verfahren;Jefferson-Verfahren;Divisorverfahren mit Abrundung
-Webster-Verfahren;Methode der ungeraden Zahlen;Divisorverfahren mit Standardrundung;Sainte-Laguë-Verfahren;Sainte-Laguë/Schepers-Verfahren;Methode der hälftigen Bruchteile
-Adams-Verfahren;Divisorverfahren mit Aufrundung
-Meerbusen von Guinea (veraltet);Golf von Guinea
-Ochlokratie;Pöbelherrschaft
-Besatzungsregime;Fremdherrschaft;Xenokratie (fachspr.)
-Gynäkokratie;Gynaikokratie
-Stratokratie;Militärregierung
-parteilose Regierung;parteifreie Regierung
-Lohndispersion;Einkommensspreizung;Lohnungleichheit;Lohnspreizung
-fragile Staatlichkeit;schwacher Staat
-Pornokratie;Mätressenherrschaft
-Antiquitätenhändler;Antikenhändler
-Angst vor Wasser;Hydrophobie;Aquaphobie
-unbeugbar;indeklinabel (fachspr.);undeklinierbar (Hauptform)
-deklinabel (fachspr.);beugbar;deklinierbar (Hauptform)
-Erdbeerfleck;Hämangiom;Blutschwämmchen
-Schnittentbindung;Kaiserschnitt
-Bankdarlehen;Bankkredit;Bankdarlehn (selten)
-Mediation;Mediationszeit
-Verfügungsrechtstheorie;Theorie der Verfügungsrechte
-Spielografie;Ludografie
-wahlfreier Zugriff;direkter Zugriff;Direktzugriff
-Vergessenskurve;ebbinghaussche Kurve
-Keywordmethode;Schlüsselwortmethode;Ersatzwortmethode
-Zahlensymbole;Zahl-Form-System;Bildersystem;Bildtafel;Zahl-Symbol-System;Hilfsbildreihe;Bilderraster
-T1-Kodierung;Cork-Kodierung
-Fehlerrückführung;Backpropagation;Rückpropagierung
-Künstliches neuronales Netz;Künstliches neuronales Netzwerk;KNN (Abkürzung)
-Gradientenverfahren;Verfahren des steilsten Abstiegs
-Kammerkomplex;QRS-Gruppe;QRS;QRS-Komplex
-Mitteleuropa;Zentraleuropa
-Realwörterbuch;Sachwörterbuch
-Sachwörterbuch;Sachlexikon;Fachwörterbuch;Realwörterbuch;Fachlexikon;Reallexikon (veraltet)
-Turmknauf;Turmknopf;Turmkugel
-Amerikanisch-Tripolitanischer Krieg;erster Barbareskenkrieg
-Aussendung;Entsendung
-6. Dezember;Nikolaustag;Nikolaus
-Bandscheibenvorwölbung;inkompletter Bandscheibenprolaps;Bandscheibenprotrusion
-Lebensknoten;Atemzentrum
-Markhirn;Myelencephalon (fachspr., griechisch);Nachhirn
-Metencephalon (fachspr., griechisch);Hinterhirn
-Rautenhirn;Rhombencephalon (fachspr., griechisch)
-automatische Wiedereinschaltung;Kurzunterbrechung
-Stromkasten (ugs.);Elektroinstallations-Verteiler;Sicherungskasten (ugs.);Zählerkasten (ugs.);Verteilerkasten (ugs.)
-reziproke Proportionalität;indirekte Proportionalität;umgekehrte Proportionalität;Antiproportionalität
-Bunsen-Roscoe-Gesetz;Reziprozitätsgesetz
-Photosmog;Sommersmog;L.A.-Smog;Ozonsmog
-iranoarische Sprachen;iranische Sprachen
-arische Sprachen (veraltet);indoiranische Sprachen
-Nuristani;Kafiren (veraltet);Nuristaner (veraltet)
-Nuristani-Sprachen;Kafiri-Sprachen (veraltet)
-Gegenmaßnahmen ergreifen;gegensteuern (fig.)
-Vinzentiner;Lazaristen
-anknüpfen;andocken
-Rechnerverbund;Computercluster
-Periodensystem der Elemente;Periodensystem
-Agrarwissenschaft;Agrarwissenschaften (Plural);Agronomie
-apokryphe Schriften;Apokryphen
-Spaßreligion;Religionsparodie
-Jauer;Münstertalerisch
-Vinschgau;Vintschgau (veraltet)
-Obervinschgau;Vinschgauer Oberland
-repräsentative Demokratie;mittelbare Demokratie;indirekte Demokratie
-im Büßergewand herumlaufen (fig.);(sich) Asche aufs Haupt streuen (fig.);(sich) in Selbstkritik üben;(sich) in Zerknirschung üben (geh., ironisierend);in Sack und Asche gehen (fig., variabel);Reue zeigen;Asche auf sein Haupt streuen (fig.);bereuen;(jemanden) reuen (geh., veraltet);(sich) reumütig zeigen;(jemandem) leidtun;im Büßerhemd gehen (fig.);(sich seiner) Schuld bewusst sein
-EDM;electrical discharge machining (engl.);funkenerosives Bearbeiten;elektroerosives Bearbeiten;Funkenerodieren
-Deionat;vollentsalztes Wasser;VE-Wasser;deionisiertes Wasser;demineralisiertes Wasser
-Serienresonanz;Reihenresonanz;Spannungsresonanz
-Antennendipol;Dipolantenne;Zweipolantenne
-Lecher-System;Lecher-Leitung
-Oneport;Zweipol;Eintor
-Stromresonanz;Parallelresonanz
-Grid-Dipper;Dipmeter
-Wärmeenergie;thermische Energie
-Edikt von Potsdam;Potsdamer Toleranzedikt
-Internist;Facharzt für Innere Medizin
-Spezialarzt (schweiz.);Facharzt;Gebietsarzt
-ukrainische Sprache;Kleinrussisch (veraltet);Ukrainisch (Hauptform)
-Slawomazedonisch;Ägäis-Mazedonisch;Ägäis-Makedonisch;Ägäis-mazedonische Sprache
-Protorenaissance;Vorrenaissance
-Kaffeesatzlesen;Kaffeedomantie
-Hieroskopie;Hieromantie;Eingeweideschau
-Horoskop;Kosmogramm
-Chirologie;Chiromantie;Handlesen;Handlesekunst;Chiromantik
-Kartenlegen;Kartomantie;Kartenlegekunst;Chartomantik
-Libanomantie;Rauchomina
-Mehlomina;Aleuromantie
-Hellsehen;Hellseherei;Spökenkiekerei (ugs., norddeutsch)
-Wahrsagung;Wahrsagen;Zukunftsdeutung;Mantik (geh.);Divination (geh.);Wahrsagerei
-Schwedisches Modell;Nordisches Modell;Skandinavisches Modell
-Hängepartie;Zitterpartie;Zeit der Unsicherheit
-Minenteppich;Minenfeld;Minensperre;Minengürtel;vermintes Gelände
-Schützenabwehrmine;Antipersonenmine;Tretmine (ugs.);Schützenmine
-Antipanzermine;Panzerabwehrmine
-Zellfusion;Synzytose;Zellverschmelzung
-Galileische Monde;Galileische Trabanten;Galileische Satelliten
-Liposuktion;Aspirationslipektomie;Fettabsaugung
-Sprachdialogsystem;IVR-System
-Nüppchen (ugs., ruhrdt.);Nüppken (ugs., ruhrdt.);Hütchen (Spielfigur);Männchen (Spielfigur)
-Mikwe;Judenbad (veraltet)
-Purimfest;Purim;Losfest
-Fabry-Pérot-Interferometer;Pérot-Fabry-Interferometer
-Landesmutter;Ministerpräsidentin
-Internetpreis (ugs.);sehr preiswert;sehr günstig
-zur Zeit (von / + Genitiv);in der Zeit (von / + Genitiv)
-Erlesenheit;Exklusivität
-Foulspiel;Foul
-stoisch;lapidar;trocken;gleichmütig;ungerührt;cool (ugs.)
-laufender Meter (ugs., ironisch);Zwerg (abwertend);kleinwüchsiger Mensch;Nabelküsser (ugs.);abgebrochener Riese (ugs., ironisch);Schrumpfgermane (ugs., NS-Jargon)
-vertikal herausgefordert (ugs., scherzhaft);von kleinem Wuchs;zwergenhaft;kleinwüchsig;klein gewachsen;(zu) kurz geraten (abwertend);klein und gemein (sarkastisch) (ugs.);unterdimensioniert (technisch);(körperlich) klein
-Zentralserbien;Engeres Serbien
-Kreisarzt;Physikus (veraltet)
-Erdölbegleitgas;Begleitgas
-Impulskontrollstörung;Störung der Impulskontrolle
-Neuroleptikum;Antipsychotikum
-Gradientkraft;Druckgradientkraft
-Eulerwind;Euler-Wind
-reichsfrei;reichsunmittelbar
-umgangssprachlich;im Gespräch üblich;kolloquial
-entstammen;Grund dafür ist;(die) Gründe (dafür) sind in (...) zu suchen;resultieren aus;herrühren (von);liegen (an);(auf etwas) zurückgehen;(einer Sache) zuzuschreiben sein;(sich) erklären (aus / durch);(sich einer Sache) verdanken (geh.);(auf etwas) zurückzuführen sein;Ursache dafür ist;(seine) Ursache haben in;basieren auf;(einem Umstand) geschuldet sein (bildungssprachlich);die Ursachen (dafür) sind in (...) zu sehen;(durch etwas / jemanden) verursacht sein;(in etwas / jemandem) begründet sein;kommen (von);zu tun haben (mit);(seinen) Ursprung haben in;beruhen auf
-den Braten riechen (ugs., fig.);eine Gefahr wittern;den Speck riechen (ugs., fig.)
-Rotmessing;Rotguss;Maschinenbronze
-Achtziger;Achtzigerjahre;achtziger Jahre
-siebziger Jahre;Siebzigerjahre;Siebziger
-Neunziger;Neunzigerjahre;neunziger Jahre
-Sechziger;sechziger Jahre;Sechzigerjahre
-Fünfzigerjahre;Fünfziger;fünfziger Jahre
-vierziger Jahre;Vierziger;Vierzigerjahre
-Dreißigerjahre;Dreißiger;dreißiger Jahre
-die goldenen zwanziger Jahre (variabel);(die) Zwanziger;Zwanzigerjahre;zwanziger Jahre
-Tanorexie (fachspr.);Bräunungssucht
-Fotothyristor;Optothyristor
-Fleppe (ugs.);Pappe (ugs.);Führerschein;Führerausweis (schweiz.);Lappen (ugs.);Fahrausweis (ugs., schweiz.)
-Digitalisat;digitalisiertes Werk
-kontaktlose Energieübertragung;drahtlose Energieübertragung;kabellose Leistungsübertragung;kontaktlose Leistungsübertragung
-kabellos;drahtlos;schnurlos
-Verteidigungsministerium;Kriegsministerium (veraltend);Bundesverteidigungsministerium;(die) Hardthöhe;Bundesministerium der Verteidigung
-Stuhldrang haben;(mal) zur Toilette (gehen) müssen;(ein) dringendes Bedürfnis verspüren (verhüllend);(etwas) Dringendes zu erledigen haben (fig., verhüllend);(mal) wohin müssen;(mal) müssen (ugs.);(ein) menschliches Rühren verspüren (ugs., verhüllend);(die) Toilette benutzen (wollen);(mal) verschwinden müssen;aufs Klo müssen (ugs.);groß müssen
-Gastgeberdienst;Gastfreundschaftsnetzwerk
-Agrotourismus;Landtourismus
-Frauenglas;Lapis specularis (lat.);Marienglas;Spiegelstein;Selenit
-Gipsspat (fachspr.);Gips
-braunes Fettgewebe;plurivakuoläres Fettgewebe
-Schlägertrupp;Schlägertruppe;Rollkommando (veraltet)
-Sondereinheit;Spezialeinheit;Sonderkommando;(mobiles) Einsatzkommando;Eingreiftruppe
-auf Bestellung (weinen können);auf Kommando (weinen können);bei Bedarf (weinen können);jederzeit (weinen können);auf Knopfdruck (weinen können)
-egal wann;wann immer;jederzeit;zu jedem beliebigen Zeitpunkt;wann auch immer;ganz gleich, wann
-Weiterempfehlung;Mundpropaganda;Mund-zu-Mund-Propaganda;Empfehlung unter Freunden
-Brackwasserbecken;Brackwasseraquarium
-Seewasseraquaristik;Meerwasseraquaristik
-Bahnhofs-WC;Bahnhofstoilette
-Atomanlage;Kernanlage;Kerntechnische Anlage;Nuklearanlage
-Vollbrücke;Brückenschaltung;H-Schaltung;H-Brücke
-Wheatstone-Brücke;Wheatstonesche Messbrücke
-Nailstudio (engl.);Nagelstudio
-nachschwingen;hallen;nachklingen;nachhallen
-browsen;surfen (Internet) (Hauptform);einen Webbrowser benutzen
-gebrochener Preis;Schwellenpreis
-Korrelationsdiagramm;Punktwolke;Punktdiagramm;Streudiagramm;Streuungsdiagramm
-Balkenplan;Gantt-Diagramm
-Aparthotel;Apartment-Hotel
-planetarer Gasriese;Gasplanet;Gasriese
-Isotropstrahler;Kugelstrahler;isotrope Antenne
-Metallizität;Metallhäufigkeit
-Montebello-Inseln;Monte-Bello-Inseln
-Guatemala;Republik Guatemala
-Republik Honduras;Honduras
-Republik El Salvador;El Salvador
-Republik Nicaragua;Nikaragua;Nicaragua
-virtuelle Auskunft;digitale Auskunft
-Altkanzler;Ex-Kanzler;Altbundeskanzler;Ex-Bundeskanzler;ehemaliger Bundeskanzler
-Schlacht von Wakenstädt;Schlacht bei Gadebusch
-Seeschlacht von Hanko;Schlacht von Gangut
-Ortler-Alpen;Ortlergruppe
-Kameralistik im weiteren Sinne;Kameralwissenschaft;Kameralia
-schmerzlos töten;einschläfern
-Lambda-Funktion;anonyme Funktion
-Sperrschuh (österr.);Gleissperre
-Wendeschleife;Kehre;Gleisschleife;Endschleife;Wende;Schleife;Umkehrschleife;Kehrschleife
-Häuserblockschleife;Blockumfahrung
-Nutzbremse;Rekuperationsbremse
-Einschlagkrater;Impaktkrater
-Livonier;Liven;Livonen
-Hebdrehwähler;Hubdrehwähler
-akustische Gitarre;Akustikgitarre
-Analoguhr;Zeigeruhr (ugs.)
-plättbarer Graph;planarer Graph
-maximal ebener Graph;maximal planarer Graph
-Vertrag mit einem Versicherungsunternehmen;Versicherungsvertrag;Versicherung
-aus Spaß an der Freude;aus Spaß
-Ein-Euro-Laden;Restemarkt;Ramschladen (ugs.);Non-Food-Discounter (fachspr.);Sonderpostenmarkt;Resterampe (ugs.);Ein-Euro-Geschäft;Ramschmarkt;Ein-Euro-Shop;Schnäppchenmarkt
-Ringalarmfahndung;Ringfahndung
-Erstzugriff;erster Angriff
-Einsatzzentrale;Leitstelle
-Flädlesuppe (schwäbisch);Pfannkuchensuppe;Flädlisuppe (schweiz.);Frittatensuppe (österr.);Flädlessuppe (schwäbisch)
-Slawomazedonisch;makedonische Sprache;Mazedonisch;mazedonische Sprache
-Agitiertheit;Agitation
-ungerichtetes Funkfeuer;Kreisfunkfeuer
-Funkkompass;Radiokompass
-analytische Psychologie;komplexe Psychologie
-Körperpsychotherapie;körperorientierte Psychotherapie
-Volksetymologie;Paretymologie
-Gruber-De-Gasperi-Abkommen;Pariser Abkommen
-Konferenz von Jalta;Krim-Konferenz
-Kvarner-Bucht;Quarnerobusen (veraltet)
-Grundwassernichtleiter;Aquifuge;Aquiclude
-Fasson (geh.);Art und Weise
-Flimmerfusionsfrequenz;Flimmerverschmelzungsfrequenz
-Pollack;Helles (selten);Gelbes Kohlmaul (selten);Kalmück;Wrackfisch (selten);Steinköhler
-im Nullkommanichts (ugs.);rasant (ugs.);im Nullkommanix (ugs.);in null Komma nichts (ugs.);in Windeseile (ugs.)
-Metropolie;Kirchenprovinz
-Milchreis;Reisbrei;dicker Reis
-Propaganda durch die Tat;Propaganda der Tat
-Sprengstoffanschlag;Bombenanschlag;Bombenattentat
-Kelpwald;Algenwald;Tangwald
-Algologie;Phykologie;Algenkunde
-Algologe;Algenforscher
-LZI-System;lineares zeitinvariantes System;LTI-System
-Kastration;Gonadektomie (fachspr.)
-Württemberger;Merinolandschaf
-Merino;Merinoschaf
-Entstörkondensator;Sicherheitskondensator;Funk-Entstörkondensator
-Zytosol;Cytosol
-Zytoskelett;Cytoskelett;Zellskelett
-der Realität widersprechend;kontrafaktisch;den Fakten widersprechend
-Master Of Business Administration;MBA
-...dämmerung;(das) Aus (für);Götterdämmerung (als Beispiel);(das) Totenglöcklein läuten (für) (fig.);(das) Totenglöcklein läutet (für) (fig.);im Endstadium (sein);Ende
-rauchen wie ein Schlot (ugs.);Kette rauchen;eine nach der anderen anstecken (ugs.)
-Abmahnschreiben (ugs.);Abmahnung
-(eine) Grimasse schneiden;(das) Gesicht (zu einer Fratze / Grimasse) verziehen;Fratzen schneiden;grimassieren;Faxen machen;Grimassen schneiden;Fratzen ziehen;(eine) Fratze machen;(eine) Fratze schneiden;(eine) Grimasse machen
-Alphamann (Alpha-Mann);Gewinnertyp;Alphatier (fig.);(ein) geborener Gewinner;auf der Siegerseite geboren;Siegertyp (Hauptform);Erfolgsmensch (Hauptform);Alphamännchen (fig.)
-dominant;ausschlaggebend;bestimmend;am ausgeprägtesten;beherrschend;am stärksten ausgeprägt;entscheidend;dominierend
-um Längen besser;niemand kann ihm die Führung streitig machen (variabel);(jemandem) um Längen voraus;übermächtig;hoffnungslos überlegen;(jemandem) nicht das Wasser reichen können (fig.);haushoch überlegen;überlegen;um Lichtjahre voraus (fig.)
-ehrliche Haut;ehrlicher Mensch (ugs.)
-ratsam erscheinen;auf der Hand liegen (fig.);(sich) anbieten;empfehlenswert sein;(sich) empfehlen;(sich) (förmlich) aufdrängen
-(den) Kampf aufnehmen;(sich einer) Herausforderung stellen;(eine) Herausforderung annehmen;(sich) dem Kampf stellen (fig.);in den Ring steigen (fig.);(den) Fehdehandschuh aufheben (ugs.);(den) Fehdehandschuh aufnehmen (fig.);ins Rennen gehen (fig.);(es) geht gegen;(sich) stellen;antreten (gegen)
-eigentlich überhaupt (in Fragen);überhaupt (in Fragen);denn (in Fragen) (Hauptform);denn eigentlich (Frage);eigentlich (in Fragen);denn überhaupt (Frage)
-Kognitionsforschung;Kognitionswissenschaft
-Marginalprinzip;Grenzprinzip
-Ökonomisches Prinzip;Wirtschaftlichkeitsprinzip;Rationalprinzip
-Haushaltsprinzip;Minimalprinzip;Sparsamkeitsprinzip
-Ergiebigkeitsprinzip;Maximalprinzip
-Extremumprinzip;Optimumprinzip
-Grenzprodukt;Grenzertrag
-Kapazitätslinie;Transformationskurve;Produktionsmöglichkeitenkurve
-Funktionsgraf;Graf;Funktionsgraph;Graph
-chaotische Lagerhaltung;dynamische Lagerhaltung
-Haltepunkt;Halt;Haltestelle (schweiz., südtirolerisch, österr.)
-Patau-Syndrom;D1-Trisomie;Pätau-Syndrom;Bartholin-Patau-Syndrom
-Edwards-Syndrom;Trisomie E;E1-Trisomie
-Trigonozephalie Opitz;Opitz-Trigonozephalie-Syndrom;C-Syndrom
-chondroektodermale Dysplasie;Ellis-van-Creveld-Syndrom
-Meckel-Gruber-Syndrom;Gruber-Syndrom;Meckel-Syndrom
-schwuppdiwupp (ugs.);schwupp (ugs.);swusch (ugs.);zack (ugs.);zappzarapp (ugs.);schwupps (ugs.)
-elektromagnetisches Wellenspektrum;elektromagnetisches Spektrum
-Wöhlerversuch;Dauerschwingversuch
-Gas-Flüssigkeits-Chromatographie;Gaschromatographie
-hell;strahlend (hell);sonnendurchflutet;licht;lichterfüllt;(gut) ausgeleuchtet;lichtdurchtränkt;taghell;lichtdurchflutet
-bedrohlich;beunruhigend;(düster) dräuend (pseudoliterarisch);unheilvoll;unheimlich;beklemmend;creepy (engl.);finster;nichts Gutes ahnen lassen(d);düster;unheilschwanger;unheildrohend;drohend
-Reporter;Berichterstatter
-Berichterstatter;Korrespondent
-Anathema (fachspr.);Anathem (fachspr.);Weihegeschenk, welches den Göttern vorbehalten war
-Pneumatik;Einsatz von Druckluft
-Pneuma;Heiliger Geist
-Ausschau;Tour d'Horizon (geh., bildungssprachlich);Überblick;Zusammenfassung;Gesamtüberblick
-Spaghettiwestern;Eurowestern;Italowestern
-Neigung;Angewohnheit;Marotte (ugs.);Habit;Schrulle (ugs.)
-herrje (ugs.);ach du liebes bisschen;ach Gottchen! (ugs.);meine Güte!;herrjemine (ugs.);mein liebes bisschen!;ach du meine Güte (ugs.)
-Unbekümmertheit;Impulsivität;Spontaneität;Spontanität;Direktheit
-Grenadine;Granatapfel
-Suchradar;Zielzuweisungsradar;Überwachungsradar
-Röntgenstrahlenbeugung;Röntgendiffraktion;Röntgenstrahlbeugung;Röntgenbeugung
-schockieren;erschrecken;erschüttern
-(jemand soll) dahin gehen, wo der Pfeffer wächst (ugs.);(sich) zum Teufel scheren (sollen / können);(jemand soll / kann) (sich) gehackt legen (ugs.);(jemand kann jemandem) gestohlen bleiben (ugs.);(auf jemanden) gut verzichten können;(jemandem) keine Träne nachweinen
-durch die Gravitation;gravitativ;durch Schwerkraft bedingt;unter Einfluss der Gravitation
-Rundumschlag (fig.);Generalangriff (fig.);Generalabrechnung
-zielbewusst;planmäßig;zielstrebig;zielgerichtet;planvoll;strebsam;zielorientiert;konsequent
-Problem des Handlungsreisenden;Rundreiseproblem
-diabetisches Fußsyndrom;diabetischer Fuß (ugs.)
-beschreibende Anatomie;deskriptive Anatomie
-Wassergewichtsseilbahn;Wasserballastbahn
-immer wieder mal;andauernd;ein(s) ums andere Mal (ugs.);immer und ewig (ugs.);(es ist) immer wieder das Gleiche (ugs.);endlos;immer wieder einmal;immer wieder (Hauptform);immer wiederkehrend;dauernd (ugs.);am laufenden Meter (ugs.);Und täglich grüßt das Murmeltier. (Spruch);wiederholte Male;ewig (ugs.);aber und abermals (geh., veraltet);in regelmäßigen Abständen;zum wiederholten Male;immer wieder das gleiche Spiel (ugs.);wieder und wieder;wiederholt
-Kroatisches Dreiband;Kroatisches Flechtwerk
-Normannenschild;Mandelschild;Drachenschild;Kiteschild
-Erbuntertänigkeit;Patrimonialhierarchie
-Migmatit;Anatexit
-Helikonien;Hummerscheren;Falsche Paradiesvogelblumen
-präkolumbinisch;präkolumbisch;präkolumbianisch;vorkolumbisch
-Lacca in tabulis;Plattlack;Gummi Lacca (fälschlich);Lackharz (fälschlich);Schellack;Tafellack
-Tafellack;Körnerlack;Stocklack;Baumlack;Gummilack
-Tinkal;Borax;Natriumborat;Dinatriumtetraborat-Decahydrat (fachspr.)
-Guidon (schweiz.);Fahrradlenker
-Vergällung;Denaturierung
-Hydrogencyanid;HCN (fachspr., Summenformel, chemisch);Formonitril;Cyanwasserstoff;Blausäure (Hauptform);Cyanwasserstoffsäure;Ameisensäurenitril (Trivialname);Zyklon B
-Kleinscher Schlauch;Kleinsche Flasche
-händeringend (fig.);mit Hochdruck (floskelhaft);mit allem, was jemand aufbieten kann;krampfhaft;wie verrückt;auf Biegen und Brechen;mit aller Gewalt;verzweifelt;mit allem, was jemandem zu Gebote steht (geh.);verbissen;mit allen Mitteln
-(sich) nicht verbiegen (lassen) (fig.);seinen Überzeugungen treu bleiben;standfest (sein) (fig.);der bleiben, der man ist;Rückgrat zeigen (fig.);bei seinen Überzeugungen bleiben;zu seinen Überzeugungen stehen;nicht einknicken;aufrechter Gang (geh., fig., variabel);Rückgrat beweisen (fig.);standhaft bleiben;(sich) (selbst) treu bleiben;Rückgrat haben (fig., variabel)
-bei dieser Gelegenheit;(für) diesmal;(für) dieses Mal;(für) dieses eine Mal
-bei nächster Gelegenheit;nächstes Mal
-bei der letzten Gelegenheit;letztes Mal
-adrenocorticotropes Hormon;Adrenocorticotropin
-Ghostwriter;Phantomschreiber;Auftragsschreiber
-Granadinische Konföderation;Granada-Konföderation
-Republik Neugranada;Neugranada
-Umschlagpunkt;Tipping Point;Kipp-Punkt;Kipppunkt;Tipping-Point;Umkipppunkt
-Anathem (fachspr.);Anathema (fachspr.);Kirchenbann
-im Umfang von (...) Millionen;in Millionenhöhe;millionenschwer;im Millionenumfang;in Millionenumfang
-arborikol (fachspr.);arboricol (fachspr.);baumbewohnend
-Ursachenforschung;Ursachenerforschung
-stur;wenig entgegenkommend;wenig Verständnis zeigend;wenig aufgeschlossen (für);unempfänglich;hartleibig (geh.);zugeknöpft (ugs., fig.);unzugänglich
-einschäumen;schamponieren;schampunieren;shampoonieren
-wirklich;tatsächlich;in der Tat;faktisch;in effectu (geh., lat.);wahrlich;wahrhaftig
-Jütländisch;Jütisch
-Südjütisch;Südjütländisch
-Reichsdänisch;Standarddänisch
-zuverlässig;gewissenhaft;verlässlich;treu und brav
-so weit, so gut;na gut;wohlan (geh., veraltend);okay;also schön;also gut;na schön;also dann;nun denn;gut denn;nun gut
-(mit Material) auffüllen;zuschütten;zumachen (ugs.);verfüllen;verschütten;vollschaufeln;zuschaufeln;vollmachen (ugs.)
-virtuelles Instrument;Software-Instrument
-Großbulgarien;Bulgarisches Großreich
-Babykörbchen;Babynest;Babyklappe (Hauptform);Babyfenster
-kosmologisches Prinzip;kosmologisches Postulat
-Ionenstreuspektroskopie;Ionenstreuungsspektroskopie
-β-Strahlung;Betastrahlung
-Beta;β
-bereitwillig;gutwillig;willig;guten Willens;ergeben;kooperativ
-charakterschwach (Hauptform);willensschwach;ohne eigenen Willen;rückgratlos;willfährig;ohne Rückgrat
-lenksam;leicht beeinflussbar;wie ein (schwankendes) Rohr im Wind (ugs.);nachgiebig;wachsweich;leicht zu beeinflussen;weich wie Wachs (ugs.)
-ehrbar;unbescholten;redlich;anständig;makellos;ehrsam (geh.);(Mann) von Ehre;nicht vorbestraft;ehrenhaft;untadelig;(ein) unbeschriebenes Blatt (fig.);(noch) nicht mit dem Gesetz in Konflikt gekommen
-(eine) reine Weste haben (fig.);(eine) saubere Weste haben (ugs., fig.);(eine) weiße Weste haben (fig., Hauptform);unbescholten (sein);makellos (Lebenslauf, Karriere)
-Kickstufe;Apogäumsmotor
-noch viel zu entdecken;(noch) nicht erforscht;Neuland (auch figurativ);(dahin hat sich noch) keines Menschen Fuß verirrt (geh.);(noch) unentdeckt;unbekannt;(noch) von keines Menschen Fuß betreten;unbekanntes Terrain (auch figurativ);(noch) nicht erschlossen;unerforscht;(noch) nicht betreten;(eine) Terra incognita (geh., lat.);noch nicht entdeckt;unbetreten;unerschlossen;weißer Fleck auf der Landkarte (auch figurativ)
-stereografische Projektion;konforme azimutale Projektion
-Landformenkunde;Geomorphologie
-physische Geographie;Physiogeographie
-Sundainseln;Sundaarchipel
-Malaien-Halbinsel;Goldene Halbinsel;Malaiische Halbinsel
-Hinterindien;Südostasiatische Halbinsel;Hinterindische Halbinsel
-Indonesischer Archipel;Malaiischer Archipel;Inselindien (veraltet);Insulinde (veraltet);Ostindischer Archipel;Südostasiatischer Archipel;Indischer Archipel
-Biostratigrafie;Biostratigraphie
-Lagerungsregel;stratigraphisches Prinzip;stratigraphisches Grundgesetz
-Albanergebirge;Albaner Hügel;Albaner Berge
-Netiquette;Netikette
-Schachtelwort;Kofferwort;Portmanteau
-Amalgamierung;Vermengung;Verschmelzung;Wortkreuzung;Kontamination
-Cytologie;Zellenlehre;Zellbiologie;Zytologie
-ZEBRA-Batterie;Natrium-Nickelchlorid-Zelle
-Batchproduktion;Chargenprozess
-(die) Karten werden neu gemischt (fig.);Zurücksetzung;alles zurück auf null (ugs.);Neubeginn;Stunde null (für);Wiederanfang;Neuanfang;Neustart;Reset
-(sich) entloben;(eine) Verlobung auflösen
-(die) BILD;(die) Zeitung mit den großen Buchstaben (ugs.);Bildzeitung
-nicht verknusen können (ugs., regional);nicht ausstehen können;nicht leiden können;nicht mögen (Hauptform);auf den Tod nicht ausstehen können (ugs., Verstärkung);nicht leiden mögen;nicht abkönnen (ugs.);nicht haben können (ugs.);nicht riechen können (ugs., fig.)
-(jemandem) Ungelegenheiten machen;zur Unzeit kommen;(jemandem) ungelegen kommen;nicht passen (ugs.);(gerade) stören (ugs.);(gerade) schlecht sein (ugs.);(jemandem) nicht in den Kram passen (ugs.);(jemanden) auf dem falschen Fuß erwischen (ugs., fig.);(gerade) (etwas) ungünstig sein (ugs.);nicht (gerade) im günstigsten Moment kommen (ugs., Understatement)
-Trockenmasse;Trockensubstanz
-Achämenidenreich;Altpersisches Reich
-Stratagem (geh., griechisch);Strategem (geh., griechisch);Kriegslist;Strategema (geh., griechisch);Ruse de Guerre (geh., franz.)
-(einen) gegenteiligen Effekt haben;kontraproduktiv sein;nach hinten losgehen (Schuss) (fig.);(ein) Eigentor (sein) (fig.);ins Auge gehen (ugs., fig.)
-geräumt (Lager);nicht (mehr) am Markt (fachspr., Jargon, kaufmännisch);(alles) weg;nicht (mehr) zu bekommen (ugs.);nicht (mehr) erhältlich;nicht (mehr) am Lager (Jargon, kaufmännisch);nicht (mehr) vorrätig;abverkauft (fachspr., Jargon, kaufmännisch);vergriffen (Buch);nicht (mehr) zu kriegen (ugs.);(restlos) ausverkauft;nicht (mehr) zu haben (ugs.);nicht (mehr) lieferbar;nicht (länger) im Angebot
-Kodex;Ehrenkodex;Komment (Burschenschaften)
-Xylophon;Xylofon
-man erzählt sich;die Legende will (geh.);so will es die Legende (Einschub, variabel);es geht das Gerücht;der Legende nach;Gerüchten zufolge (...);(etwas) läuten hören;es geht die Sage;man raunt sich zu (geh.);es heißt (dass ...);man munkelt;eine (alte) Legende sagt;gerüchteweise hören;man flüstert sich zu;(die) Leute erzählen (dass) (ugs., Hauptform)
-bislang unbestätigten Meldungen zufolge;soweit bekannt;soweit man hört;nach bisher unbestätigten Meldungen;soweit man weiß;dem Vernehmen nach;nach allem, was man hört (ugs.);nach dem, was man weiß;nach allem, was man weiß;wie es heißt;wie aus gewöhnlich gut unterrichteten Kreisen verlautet(e) (in vielen Abwandlungen, Nachrichtensprache)
-(noch) im Raum stehen;offen bleiben;(sich) nicht klären lassen;in der Schwebe bleiben;dahingestellt bleiben;(eine) offene Frage (sein)
-Klassenclown;Klassenkasper
-Mehrprozessorsystem;Multiprozessorsystem
-Mehrkernprozessor;Multikernprozessor
-spaßeshalber;nicht ernst gemeint;aus Spaß an der Freud(e);(in seinem) jugendlichen Leichtsinn (ugs., Spruch, scherzhaft, variabel);hetzhalber (ugs., österr.);scherzeshalber;mal eben so (ugs.);im Scherz;ohne (dabei) nachzudenken;nur mal eben so (ugs.);einfach so (ugs.);just for fun (engl.);aus Spaß (ugs.);nur so;sollte ein Scherz sein;ohne Sinn und Verstand;aus Übermut (Hauptform);aus Jux und Tollerei (ugs.);aus Jux (ugs.);scherzweise;ohne sich etwas dabei zu denken;aus Scheiß (ugs.);aus Daffke (ugs., berlinerisch);(nur so) zum Spaß (ugs.);aus Flachs (ugs.)
-unter einer Käseglocke;in Quarantäne;abgeschottet von der Außenwelt
-Rapsmethylester;Rapsdiesel (ugs.);Rapsöl-Methylester
-Sojabohnenöl;Sojaöl
-Winkelzüge;Umtriebe;Schliche;Intrigenspiel;Machenschaften;Ränkespiel;(undurchsichtige/s) Manöver;Finessen;Linkereien (ugs.)
-Konspiration (geh.);Komplott;finstere Machenschaften (ugs.);Geheimplan;Verschwörung (Hauptform)
-Reklamemarke;Werbemarke
-Nürnberger Gesetze;Nürnberger Rassengesetze;Ariergesetze
-Meiji-Renovation;Meiji-Restauration;Meiji-Revolution
-islamistischer Terrorismus;islamischer Terrorismus
-Meth;Stuka-Tabletten (ugs.);Hermann-Göring-Pillen (ugs.);Metamfetamin;Pervitin;Crystal Meth;Ice (ugs.);Hitler-Speed (ugs.);N-Methylamphetamin;Crystal;Methamphetamin;Yaba (ugs.);Panzerschokolade (ugs.)
-dem Untergang geweiht;dem Tod geweiht (sein);(das) Todesurteil bedeuten (für) (fig.);todgeweiht sein;(auf jemanden) wartet der Tod (literarisch);den Tod vor Augen haben;(jemandem) ist der Tod bestimmt (geh.)
-Tag des Zorns;Doomsday (engl.);Dies irae (lat.);(das) Jüngste Gericht (Hauptform);Weltgericht;(der) Jüngste Tag
-Traubeneiche;Wintereiche;Quercus petraea (fachspr., botanisch);Trauben-Eiche (fachspr., botanisch)
-fränkische Erweckungstheologie;Erlanger Schule;Erlanger Theologie
-Wiener Schule;Österreichische Grenznutzenschule;psychologische Schule;Österreichische Schule
-Burgasebene;Burgastiefebene
-mazedonische Bulgaren;makedonische Bulgaren
-Parteigutachten;Privatgutachten
-Ahnenkult;Manismus;Ahnenverehrung
-Kult;Kultus
-weißes Ragout;Blankett
-diskretionär;nach freiem Ermessen
-Planstadt;Retortenstadt
-Kartenschnitt;Blattschnitt
-eilenden Schrittes (geh.);mit kurzen, schnellen Schritten (militärisch);in schneller Gangart;im Schweinsgalopp (ugs.);hurtigen Schenkels (ugs., ironisch);im Sauseschritt (ugs.);schnellen Schrittes
-unbeschönigt;unverblümt;so wie es ist (ugs.);ungeschönt;nicht geschönt;ehrlich (fig.);ungefiltert (fig.);ungeschminkt (fig.)
-Alarmblinkanlage (österr.);Warnblinkanlage;Warnblinker (ugs.)
-'nen (ugs.);einen
-eine;'ne (ugs.)
-Monophonie;Monofonie
-Homofonie;Homophonie
-Istriotisch;Istro-Romanisch
-Dolomit;Dolomitstein
-Mittelkroatien;Zentralkroatien;Kernkroatien;Hoch-Kroatien;Alt-Kroatien
-Wachturm;Wachtturm
-B-Turm;Beobachtungsturm
-resezieren (fachspr.);entfernen
-Steineiche;Stein-Eiche
-Europäische Hopfenbuche;Gemeine Hopfenbuche
-überfällig;müsste längst (...);längst fällig;sollte längst (...);in Verzug;das wurde (auch) Zeit! (ugs.);hätte schon längst (...);spät kommt ihr, doch ihr kommt (geh., Zitat, variabel)
-nicht gerade;einfach nicht;nicht unbedingt;halt nicht;nicht eben (geh.);nicht wirklich (ugs.);alles andere als;nun mal nicht
-hydrostatisches Paradoxon;Pascalsches Paradoxon
-Anhänger der katholischen Soziallehre;CDA-Mitglied;Herz-Jesu-Marxist;Herz-Jesu-Sozialist;Mitglied im CDU-Sozialausschuss
-auf unbestimmte Zeit;ad ultimo (geh., lat.);bis Ultimo;bis ultimo;bis zum Sankt-Nimmerleins-Tag;bis ans Ende aller Tage (fig., übertreibend)
-Plantaraponeurose;Aponeurosis plantaris (fachspr.);Plantarfaszie
-Hohlhandsehne;Aponeurosis palmaris (fachspr.);Palmaraponeurose
-Ansichtskarte;Ansichtspostkarte;Karte (ugs.)
-TV-Duell;Schlagabtausch im Fernsehen;Fernsehduell
-Rating-Agentur;Ratingagentur;Wirtschaftsauskunftei;Wirtschaftsinformationsdienst
-pVV (fachspr., juristisch);positive Forderungsverletzung (fachspr., juristisch);pFV (fachspr., juristisch);positive Vertragsverletzung (fachspr., juristisch)
-Verschulden bei Vertragsabschluss (juristisch);cic (juristisch);culpa in contrahendo (juristisch, lat.);c.i.c. (juristisch)
-Foreign Exchange Market (fachspr., engl.);Forex (fachspr.);Währungsmarkt;Devisenmarkt
-Brennerpass;Brenner
-Franzensfester See;Franzensfester Stausee
-Fassatal;Eveistal (veraltet)
-Fodom;Buchenstein
-Abtönungspartikel;Modalpartikel
-Poster (engl.);Forumsteilnehmer;Teilnehmer in einem Online-Forum;Forist
-Spanndorn;Aufnahmedorn;Aufspanndorn
-Piepmatz (ugs.);Vögelchen;Vöglein (geh.);kleiner Vogel
-Gradpartikel;Intensitätspartikel;Gradmodifikator;Intensifikator;Steigerungspartikel
-konjunktionaler Gliedsatz;Konjunktionalsatz
-Adverbialsatz;Verhältnissatz
-Begründungssatz;Kausalsatz
-Einräumungssatz;Konzessivsatz
-Begehrsatz;Zwecksatz;Finalsatz;Absichtssatz
-Temporalsatz;Zeitsatz
-Erotema (fachspr.);Fragesatz;Interrogativsatz
-Adverbialbestimmung (Hauptform);adverbiale Bestimmung;Adverbiale;Umstandsangabe;Adverbial;Umstandsbestimmung
-Satzteil;Konstituente (ugs.);Satzkonstituente;Satzglied
-Bonbonsirup;Isoglukose;Maissirup;Maiszucker;Glucosesirup (fachspr.);Corn Sirup;Stärkesirup;Glykosesirup (veraltet);Glukosesirup
-Tripodegelenk;Tripoidgelenk
-Neigungswinkelmesser;Neigungsmesser;Nivelliergerät;Klinometer;Inklinometer
-nichts übrig haben (für) (ugs.);kein Verständnis haben (für)
-Hinterzimmer;Personalraum;Privatraum
-Fulminsäure;Knallsäure
-perkussorisch;perkutorisch
-liegen geblieben (ugs.);unerledigt (Hauptform);ungetan;pendent (schweiz.);noch nicht erledigt;liegt noch (...) (ugs.)
-Gehörsturz;Gehörinfarkt;Ohrinfarkt;Hörsturz
-dünnbesetzte Matrix;schwachbesetzte Matrix
-hier;hier zu Lande;bei uns (ugs.);in diesem Land;hierzulande
-(einen) Preis festlegen;bepreisen;(einen) Preis bestimmen;(einen) Preis festsetzen;mit einem Preis belegen
-dicht gepackter Code;perfekter Code
-Kantenspektrum;Umkehrspektrum;Goethe-Spektrum
-Geburt der Gemeinsinnes (geh.);soziogenesis
-Gammelfleisch (ugs.);Ekelfleisch (ugs.);verdorbenes Fleisch
-Stirnsitzer (österr.);Frontlenker
-Machtübergabe;Machtergreifung;Usurpation (geh.);Machtübernahme
-Megrelien;Odischi (veraltet);Mingrelien
-mingrelische Sprache;mengrelische Sprache;megrelische Sprache
-georgische Sprache;Gruzinisch;Grusinisch;Georgisch
-Humangeographie;Anthropogeographie
-Sozialgeografie;Sozialgeographie
-Wirtschaftsgeographie;Wirtschaftsgeografie
-Agrargeografie;Agrargeographie
-Geographische Handelsforschung;Handelsgeographie
-Evolutionsökonomik;Evolutorische Ökonomik;Evolutionäre Ökonomik
-kreatives Milieu;innovatives Milieu
-Regionalforschung;Regionalwissenschaft
-Suburbanisierung;Stadtflucht
-Tsaidam-Becken;Qaidam-Becken
-Hochasien;Hochland von Tibet;Tibetisches Hochland;Qinghai-Tibet-Hochebene
-dreiwertige Logik;ternäre Logik
-Bivalenzprinzip;Prinzip der Zweiwertigkeit
-Quasiwahrheitswert;Geltungswert;Pseudowahrheitswert
-Westbank;Westjordanland;Judäa und Samaria;Cisjordanien
-Vorderasien;Westasien;Südwestasien
-Cinnabarit;Zinnober
-Sättigung;Sättigungsbetrieb
-alternatives Spleißen;differenzielles Spleißen;gewebespezifisches Spleißen
-Superpositionsprinzip;Superpositionseigenschaft
-Superposition;Superpositionsprinzip
-Fourier-Analysis;Fourier-Analyse;klassische harmonische Analyse
-unterbrechungsfreie Wiedergabe;lückenlose Wiedergabe
-Planplatte;planparallele Platte
-Ophthalmometer;Keratometer
-Kornea;Cornea;Hornhaut
-Videokeratometer;Keratograf
-inkohärenter Demodulator;Hüllkurvendetektor;Hüllkurvendemodulator
-Diodenempfänger;Detektorradio;Detektorempfänger
-Wasserlunge (ugs.);Lungenödem
-Zellzwischenraum;Interstitium (fachspr.);Stroma (fachspr.)
-Gewebsflüssigkeit;Interstitialflüssigkeit
-Anonymität;Unbekanntheit;Namenlosigkeit
-Fernlernunterricht (fachspr.);Heimunterricht;Distanzunterricht;Domizilunterricht;Distanzlernen;Beschulung durch die Eltern;Hausunterricht;Lernen zu Hause;Fernlernen;häuslicher Unterricht;Home-Schooling (Neologismus, engl.);Beschulung zu Hause
-Ackerknoblauch;Sommerknoblauch;Ackerlauch
-Umformerelement;Getriebe
-Colorado-Plateau;Colorado-Hochebene
-Durchgangsbahnhof in Gleistieflage;Reiterbahnhof;Sattelbahnhof
-Nordkaukasus;Ciskaukasien
-Transkaukasien;Südkaukasus
-nach-dagestanische Sprachen;nordostkaukasischen Sprachen
-Vorkaukasus;Kaukasusvorland
-Ablenkung;Deviation
-Ortsmissweisung;Missweisung;Deklination
-Penisdeviation;Penisverkrümmung
-sexuelle Funktionsstörung;funktionelle Sexualstörung;sexuelle Dysfunktion
-Kursumwandlung;Kursbeschickung
-Neue Mechanik;Lorentzsche Elektrodynamik;Lorentzsche Äthertheorie;Lorentzsche Elektronentheorie
-Normalenvektor;Normalvektor
-Normaleneinheitsvektor;Einheitsnormale
-analytische Geometrie;Vektorgeometrie
-lineare Algebra;Vektoralgebra
-lineare Transformation;Vektorraumhomomorphismus;lineare Abbildung
-Querdisparität;Querdisparation
-Aliasing-Effekt;Alias-Effekt;Aliasing
-Eulertour;Eulersche Linie;(geschlossener) Eulerzug;Eulerzug
-starke Wechselwirkung;Farbkraft;starke Kraft;Gluonenkraft;starke Kernkraft (veraltet);Kernkraft (veraltet)
-schwache Kernkraft;β-Wechselwirkung;schwache Wechselwirkung
-Grundkraft der Physik;fundamentale Wechselwirkung
-Van-der-Waals-Wechselwirkung;Van-der-Waals-Kraft
-intermolekulare Wechselwirkung;zwischenmolekulare Wechselwirkung;intermolekulare Kraft;zwischenmolekulare Kraft
-Keesom-Wechselwirkung;Dipol-Dipol-Kraft;Keesom-Kraft;Dipol-Dipol-Wechselwirkung
-Wasserstoffbrücke;Wasserstoffbrückenbindung;H-Brücke
-innermolekulare Kraft;intramolekulare Kraft;intramolekulare Wechselwirkung;innermolekulare Wechselwirkung
-dative Bindung (veraltet);koordinative Bindung;Donator-Akzeptor-Bindung
-Lyra (fachspr.);Leier
-Kleiner Krieg;Slowakisch-Ungarischer Krieg
-Vertrag von Trianon;Friedensvertrag von Trianon
-Multimethodendesign (fachspr.);Integration qualitativer und quantitativer Methoden;Mixed-Methods-Ansatz (fachspr.);Multimethodenansatz (fachspr.)
-Kölner Franken;Rheinfranken;Ripuarier;Ripuaren;ripuarische Franken
-stellvertretender Gouverneur;Vizegouverneur
-Servelatwurst;Zervelatwurst;Safaladi (veraltet, österr.);Cervelatwurst
-Doppel-Planetoid;Doppel-Asteroid
-Gregorianisches Teleskop;Gregory-Teleskop
-Sekundärspiegel;Fangspiegel
-Terahertzstrahlung;Submillimeterwellen
-Strehl-Verhältnis;Strehl-Zahl
-Dunkelnebel;Dunkelwolke
-Destriau-Effekt;Elektrolumineszenz
-verstärkte spontane Emission;Superlumineszenz
-Lossew-Effekt;Round-Effekt
-Profanierung;Profanation
-induktive Statistik (fachspr.);mathematische Statistik;schließende Statistik;Inferenzstatistik (fachspr.)
-Datamining;analytische Statistik;explorative Statistik;Data-Mining;hypothesen-generierende Statistik
-Statistik;Lehre von Methoden zum Umgang mit quantitativen Informationen
-Kosovo;Republik Kosovo
-Einmalpasswort;Einmalkennwort
-Einmalschlüssel-Verfahren;Einmalverschlüsselung
-holoalphabetischer Satz;Pangramm
-Heißer Draht;Rotes Telefon
-Zirkularbeschleuniger;Umlaufbeschleuniger;Kreisbeschleuniger;Ringbeschleuniger
-Betatron;Elektronenschleuder
-effektive Valutaschuld;echte Valutaschuld
-Flak-Artillerie;Flakartillerie
-Weichselgouvernement;Generalgouvernement Warschau;Weichselland;Russisch-Polen;Weichselgebiet
-Zeugenberg;Ausliegerberg
-Mohrenhirse;Durrakorn;Besenkorn
-Körnerhirse;Zuckerhirse;Faserhirse;Futterhirse
-grundverkehrt;grundfalsch;völlig falsch
-Larynxkarzinom;Kehlkopftumor;Kehlkopfkrebs;Larynxtumor
-Gay-Lussacsches Gesetz;Gesetz von Charles;Charlessches Gesetz;Erstes Gesetz von Gay-Lussac;1. Gesetz von Gay-Lussac
-Zweites Gesetz von Gay-Lussac;2. Gesetz von Gay-Lussac;Gesetz von Amontons
-Pulsation;Pulsieren
-Hydropneumatischer Akkumulator;Hydrospeicher;Hydropneumatischer Speicher;Hydraulikspeicher
-Membranspeicher;Hydromembranspeicher
-Ausdehnungsgefäß;Druckausgleichsbehälter;Expansionsgefäß;Bombe (ugs.)
-Hydropumpe;Hydraulikpumpe
-Szintillationszähler;Szintillationsdetektor
-Chromatographie;Chromatografie
-kartesisches Produkt;Kreuzprodukt;Mengenprodukt
-Produktmenge;Kreuzmenge;Verbindungsmenge
-Ölkautschuk;Faktis
-Gummibaum;Parakautschukbaum;Kautschukbaum
-Kautschuk (veraltet);Naturkautschuk
-Vorrat;Fundus
-generischer Treiber;Klassentreiber
-Treiber;Gerätetreiber
-wenn ich du wäre;an deiner Stelle
-Abugida;Alphasyllabar
-Alexandrinische Liturgie;Alexandrinischer Ritus
-thronen;wie auf einem Thron sitzen
-8. Venezianischer Türkenkrieg;Venezianisch-Österreichischer Türkenkrieg;1. Türkenkrieg Karls VI.;6. Österreichischer Türkenkrieg
-Firmenkunde;Geschäftskunde;Geschäftskontakt;Firmenkontakt
-Fundkind;Findling;Findelkind
-Funkrufempfänger;Personenrufempfänger;Funkmeldeempfänger;Pager
-Telefonist;Telefonoperator
-Kiriwina Inseln;Trobriand-Inseln
-Ninigo-Inseln;Schachbrettinseln
-Anachoreteninseln (veraltet);Kaniet-Inseln
-Tigerinsel (veraltet);Wuvulu
-Filiation;Deszendenzsystem;Abstammungssystem
-Ödipuskonflikt;Ödipuskomplex
-Schwemmkegel;Sandurs;Schwemmfächer;Geröllfächer;alluvialer Fächer
-Kiestagebau;Schottergrube;Kieswerk;Kiesgrube
-Sylvensteinspeicher;Sylvensteinsee;Sylvensteinstausee
-Englisch können (ugs.);des Englischen mächtig sein;Englisch sprechen
-Tunneltal;glaziale Rinne
-aktives Bremslicht;dynamisches Bremslicht;adaptives Bremslicht
-Vinschger Paarln;Vinschgerln;Vinschgauer
-Doppelschlüssel;Schließzwangschlüssel;Berliner Schlüssel;Durchsteckschlüssel
-Berliner Schloss;Schließzwangschloss;Durchsteckschloss
-Nutzungsänderung;Konversion;Umnutzung
-Expeditionsstreitkraft;Einheiten im Auslandseinsatz;Expeditionskorps
-Giebeldach;Satteldach
-Polyamory (engl.);Polyamorie
-offene Zweierbeziehung;offene Beziehung
-Nebenfrau;Konkubine;Mätresse;Kurtisane;Geliebte;Hetäre;Zweitfrau
-Prostituiertenkunde;Bordellbesucher;Freier
-Jablunkauer Bergland;Jablunkauer Zwischengebirge
-Mahagonigewächs;Zedrachgewächs
-Blutweiderichgewächs;Weiderichgewächs
-Flügelsamengewächs;Langfadengewächs
-Wasserfichte;Chinazypresse
-Atemknie;Kniewurzeln
-echte Sumpfzypresse;Sumpfeibe
-Atemwurzel;Luftwurzel;Pneumatophor
-Mississippi-Alligator;Hechtalligator
-Kainsmal;Kainszeichen
-Territorialprinzip;Territorialitätsprinzip
-konsularische Rechtsprechung;Konsularjurisdiktion;Konsulargerichtsbarkeit
-Territorialprinzip;Geburtsortprinzip;Geburtsortsprinzip
-Isolierverglasung;Mehrscheiben-Isolierglas;Wärmedämmverglasung
-Kampfpanzer;Panzerkampfwagen
-Megagramm;Metrische Tonne;t (Einheitenzeichen);Tonne
-Raupe (veraltet);Gleiskette;Raupenkette;Raupenband (veraltet)
-Bulldozer;Kettenräumer;Planierraupe;Schubraupe
-Kettenfahrzeug;Raupenfahrzeug;Gleiskettenfahrzeug
-keine guten Chancen haben;schlechte Karten haben (fig.);in keiner guten Ausgangssituation sein
-Verschiedener (geh.);Dahingeschiedener;Entschlafener (verhüllend);Verblichener;Verstorbener (Hauptform);Gefallener;Dahingegangener;Leiche;Toter (Hauptform);Abgelebter;Ermordeter;Getöteter (geh.)
-kaum jemand;kaum ein Mensch;praktisch niemand;fast niemand
-Kesselsauger;Allessauger;Nass-/Trockensauger
-Zyklonfilter;Zyklon;Zyklonabscheider;Wirbler;Fliehkraftabscheider
-Nennwert;Nominalwert
-Stationsberg;Kalvarienberg
-hohe Ansprüche stellen;die Latte hoch legen (fig.);hohe Erwartungen haben
-Spähpanzer;Aufklärungsfahrzeug;Panzerspähwagen
-Flussnapfschnecke;Flussmützenschnecke
-additive Gesamtschule;kooperative Gesamtschule
-temporale Datenhaltung;Historisierung
-Transaktionszeit;Bearbeitungszeit
-temporale Logik;Zeitlogik
-Lobus temporalis (fachspr.);Temporallappen;Schläfenlappen
-Parietallappen;Scheitellappen;Lobus parietalis (fachspr.)
-Stirnlappen;Lobus frontalis (fachspr., lat.);Frontallappen
-Hinterhauptslappen;Lobus occipitalis (fachspr.);Okzipitallappen;Occipitallappen
-Sylvische Fissur;Sylvische Furche;Fissura lateralis (fachspr.);Fissura Sylvii;Sulcus lateralis (fachspr.)
-Cerebrum (lat.);Großhirn;Telenzephalon (griechisch);Endhirn;Telencephalon (fachspr., griechisch);Zerebrum (lat.)
-Temporallappenepilepsie;Schläfenlappenepilepsie
-Frontallappenepilepsie (fachspr.);Stirnlappenepilepsie
-Hinterhauptslappenepilepsie;Okzipitallappenepilepsie
-Dravet-Syndrom;Frühe infantile epileptische Enzephalopathie;Myoklonische Frühenzephalopathie
-Westwindzone;Westwinddrift
-allgemeine Zirkulation;planetarische Zirkulation;planetare Zirkulation;globale Zirkulation
-Hinterautal-Vomper-Kette;Karwendelhauptkette
-Vorlandgletscher;Eisloben;Piedmontgletscher
-Gletscherendsee;Gletscherrandsee
-Standgewässer;Stehgewässer;Stillgewässer;stehende(s) Gewässer
-Inntal-Gletscher;Inn-Gletscher
-Rottengletscher;Rhonegletscher
-Plateaugletscher;Eiskappe
-Ballspielhaus (historisch);Ballhaus (historisch)
-Turnhalle;Sporthalle;Turnsaal
-Neuseeländische Alpen;Südalpen;Südlichen Alpen
-Zwangsversteigerung;Subhastation (veraltet)
-Tontechnik;Elektroakustik
-Bittiefe;Samplingtiefe
-Vasallenstaat;Satellitenstaat
-Republik von Salò;Sozialrepublik Italien;Italienische Sozialrepublik
-Mandschu-Dynastie;Qing-Dynastie
-Jugendweihe;Jugendfeier
-ziviler Ungehorsam;bürgerlicher Ungehorsam
-Baufahrzeug;Baustellenfahrzeug
-Induktion (Kurzform);Faraday'sche Induktion;elektromagnetische Induktion
-Umlaufspannung;Induktionsspannung
-Müllfahrzeug;Müllwagen
-Nutzkraftwagen;Nfz (Abkürzung);Nutzfahrzeug
-Müllwerker;Müllmann (männl.);Mülllader;Müllkutscher (veraltet)
-Chlorwasserstoff;Wasserstoffchlorid;Hydrogenchlorid
-Wasserstoffiodid;Iodwasserstoff;Hydrogeniodid
-Vakuumbremse;Saugluftbremse;Luftsaugbremse
-Kabeltrasse;Kabelwanne;Kabelrinne;Kabelbahn;Kabelpritsche
-Gneis- und Granitplateau;Granit- und Gneishochland
-Cruise-Missile (engl.);Flügelrakete (ugs.);Marschflugkörper
-Coulombsches Gesetz;Coulomb-Gesetz
-Elektrostatische Induktion;Influenz
-Schwarzrost;Getreideschwarzrost;Getreiderost
-Adlergebirge;Mensegebirge (veraltet);Grunwalder Gebirge (veraltet);Erlitzgebirge (veraltet)
-E-Kennung;E-Kennzeichnung;E-Kennzeichen;ECE-Prüfzeichen
-Produktkennzeichnung;Warenkennzeichnung
-Kapauner (veraltet);Masthahn;Kapaun;Kapphahn
-Schwingachse (veraltet);Pendelachse
-aufs Tapet kommen;angesprochen werden (Thema);zur Sprache kommen;erwähnt werden
-Erwähnung;Nennung
-wofür (wir ihm/ihr) alle sehr dankbar sind;dankenswerterweise;zu unserem großen Dank
-Homeoffice;Home-Office;Arbeitsplatz zu Hause
-für Schiffe befahrbar;schiffbar
-Elgamal-Kryptosystem;Elgamal-Verschlüsselungsverfahren
-Exostose (fachspr.);Überbein (ugs.)
-Klartext;Dechiffrat
-Fersensporn (Hauptform);Calcaneussporn;Hackensporn;Kalkaneussporn
-Sprüche Salomos;Buch der Sprüche;Buch der Sprichwörter
-Ketuvim;Ketuwim;Ketubim
-Tanach;Tenach;hebräische Bibel;jüdische Bibel
-Lübisches Recht;Lübsches Recht
-Stalag;Stammlager
-Partikularrecht;partielles Recht
-Mährischer Karst;Mährische Schweiz (veraltet)
-Kammertachykardie;ventrikuläre Tachykardie
-ventrikuläre Fibrillation;Herzkammerflimmern;Kammerflimmern
-Bindenverband;Binde
-Kohldampf (ugs.);Mordshunger (ugs.);Bärenhunger (ugs.);großer Hunger
-das ist nicht alles;(es) kommt hinzu (dass);(und) da wäre noch etwas;(...) und es kommt (gleich) noch doller: (...) (ugs., variabel);damit nicht genug;und außerdem;(...) und es gibt noch eine Steigerung!: (...);hinzu kommt (dass);das ist (aber) noch nicht alles;mehr als das;(und) da ist noch etwas
-Klassensprecher;Klassenvertreter
-(ein) (großes) Trara machen um (ugs.);(ein) Mordstheater machen;Wind machen (wegen, für) (ugs.);(großes / viel) Geschrei machen (um) (ugs.);(ein) großes Geschrei veranstalten (ugs.)
-einen Dickkopf haben (ugs.);einen Dickschädel haben (ugs.);seinen Dickkopf aufsetzen (ugs.);einen Sturkopf haben (ugs., abwertend);stur sein
-Gehaltsdifferenzierung;Lohndifferenzierung;Entgeltdifferenzierung
-Sold;Traktament (veraltet);Traktement (veraltet)
-Sekundentod;Plötzlicher Herztod
-Herzstillstand;Kardioplegie (fachspr.)
-induzierter Herzstillstand;pharmakologischer Herzstillstand;künstlich herbeigeführter Herzstillstand
-kardioplege Lösung;kardioplegische Lösung
-Kreislaufstillstand;klinischer Tod
-elektromechanische Dissoziation;elektromechanische Entkoppelung;pulslose elektrische Aktivität
-österreichisch-tschechischer Ausgleich;deutsch-tschechischer Ausgleich;deutsch-böhmischer Ausgleich
-Adjunkte;klassische Adjungierte;komplementäre Matrix
-Enveloppe;Einhüllende;Hüllkurve
-Weg;parametrisierte Kurve
-Funktionsschar;Parameterfunktion;Funktionenschar;Kurvenschar
-Lorentz-Verteilung;Cauchy-Verteilung;Cauchy-Lorentz-Verteilung;Breit-Wigner-Verteilung
-Fraunhoferlinie;Fraunhofer'sche Linie
-Spektrallinie;Resonanzlinie
-Farbspektrum;Lichtspektrum
-sichtbares Spektrum;visueller Bereich
-Begleitagentur;Escortagentur
-Ostindische Pfeilwurz;Grüne Fledermauslilie;Loki;Pia
-Yamswurzelgewächse;Schmerwurzgewächse;Yamswurzgewächse;Yamsgewächse
-Oberlitauen;Aukschtaitien
-Oberlitauer;Aukschtaiten
-Niederlitauen;Schamaiten;Samogitien
-Memelland;Memelgebiet
-Memeler;Memelländer
-Zivilkommissarius (veraltet);Zivilkommissar
-Starostei Samogitien;Herzogtum Samogitien
-Grulicher Schneeberg;Glatzer Schneeberg;Spieglitzer Schneeberg
-ombrotrophes Moor;Regenmoor;Hochmoor
-Niedermoor;Reichmoor
-Braun-Segge;Wiesen-Segge
-Sauergrasgewächse;Riedgrasgewächse;Riedgräser
-Kleinseggenmoor;Kleinseggen-Sumpf;Wiesenmoor;Kleinseggenried
-Druckfließläppen;Strömungsschleifen
-Republik Krakau;Freie Stadt Krakau
-Bongo-Massiv;Tondou-Massiv;Bongo-Berge
-Tschadseebecken;Tschadbecken
-Elefantenvogel;Madagaskar-Strauß
-Marranos;Marranen
-Englischer Garten;Englischer Landschaftspark;Englischer Park;Englischer Landschaftsgarten
-Landschaftspark;Landschaftsgarten
-Nasenbeutler;Beuteldachs
-Zentraldeutsch;Mitteldeutsch;mitteldeutscher Dialekt;mitteldeutsche Mundart
-Blutlinie (veraltet);Abstammungslinie
-bedeutungsschwanger;vielsagend;bedeutungsvoll;tiefsinnig;gedankenschwer;bedeutsam;viel sagend;bedeutungsschwer;tief;gedankenvoll
-Phoebus-Skandal;Lohmann-Affäre
-Verfassung des deutschen Reiches;Paulskirchenverfassung;Frankfurter Reichsverfassung
-Polychromie;Vielfarbigkeit
-3S-Bahn;Dreiseilumlaufbahn
-Luftseilbahn;Seilschwebebahn
-Akzession;Beitritt
-klassische Grundherrschaft;zweigeteilte Grundherrschaft
-Informationsfluss;Informationsstrom
-Herzogtum Neisse;Fürstentum Neisse-Grottkau;Neisse-Ottmachauer Bistumsland;Fürstentum Neisse
-Allradantrieb;Allrad (ugs.)
-Lamellenkupplung;Reiblamellenkupplung
-Leerlaufmoment;Schleppmoment
-Gasdruckfeder;Gasfeder
-elektrorheologische Flüssigkeit;elektrorheologisches Fluid
-Dispergiermittel;Dispergator
-Zugbeeinflussung;Zugsicherungssystem;Zugbeeinflussungssystem
-Verkehrswegebündelung;Trassenbündelung
-Kontamination (fachspr.);Kontaminierung (fachspr.)
-Dekontamination;Dekontaminierung (österr.);Entseuchung;Dekon (Abkürzung);Deko (Abkürzung, österr.)
-Molenbruch (veraltet);Stoffmengenanteil
-Gehaltsangabe;Gehaltsgröße
-Stoffmengenkonzentration;Molarität (veraltet)
-Volumenanteil;Volumenbruch
-Massenbruch (veraltet);Massenanteil
-Streckenzug;Polygonzug;Linienzug
-Bugstrahlruder;Querstrahlsteueranlage
-Vario;Variometer;Steigmesser
-Verniertriebwerk;Vernierdüse
-Radargleichung;Radargrundgleichung
-Spankammer;Spanraum
-magnetischer Widerstand;Reluktanz
-magnetische Quellspannung;Durchflutung;magnetische Spannung;magnetische Durchflutung
-Schneckenhaus;Schneckenschale;Schneckengehäuse
-Baumschnecke;Baumschnirkelschnecke;Gefleckte Schnirkelschnecke
-Alkoholometer;Alkoholmeter
-Ärometer;Aerometer
-Originaltreue;Genauigkeit;Fidelität (geh.);Wiedergabetreue
-Stromschnittstelle;Stromschleifenschnittstelle
-Thermalbad;Therme
-torusförmig;toroidal
-Inferioritätsgefühl;Unterlegenheitsgefühl(e);Minderwertigkeitsgefühl;Inferioritätskomplex;Minderwertigkeitskomplex
-Elektroabscheider (wissenschaftlich);Elektrostat;Elektrofilter;Elektro-Staubabscheider (wissenschaftlich);elektrische Gasreinigung;Elektro-Staubfilter
-europäische Schweinepest;klassische Schweinepest
-Lichtnahrung;Breatharianismus
-Berufsmatur (schweiz., veraltet);Berufsmatura (schweiz., veraltet, österr.);Berufsreifeprüfung;Berufsmaturität (schweiz.)
-Primitiv;grafisches Primitiv;Raumbezugsgrundform;grafische Grundform;Grundobjekt
-linearer Polarisator;Polarisator
-Hämostatikum;Styptikum;Hämostyptikum;Hämatostyptikum;Hämatostatikum
-Spinnenzelle;Sternzelle;Astrozyt
-mäzenatisch;in der Art eines Mäzens
-Gewöhnlicher Flügelginster;Ramsele
-Versitzgrube;Sickergrube
-Klärwerk;Abwasserreinigungsanlage (schweiz., österr.);Kläranlage
-Absetzbecken;Absetzanlage
-Betriebswasser;Brauchwasser;Nutzwasser
-Informationsgehalt;Überraschungswert (fachspr.)
-Höhenschnittpunkt;Orthozentrum
-Einschneiden;Schnittverfahren
-Neun-Punkte-Kreis;Feuerbachkreis
-Raumgeometrie;Stereometrie;räumliche Geometrie
-Grundseite;Grundlinie
-Lemoinepunkt;Symmedianenpunkt;Lemoinescher Punkt;Grebepunkt
-Spieker-Zentrum;Spieker-Punkt
-Winkelhalbierende;Winkelsymmetrale
-Streckensymmetrale (österr.);Mittelsenkrechte;Mittellot
-merkwürdiger Punkt;ausgezeichneter Punkt
-geometrischer Schwerpunkt;Schwerpunkt
-Gewichtsschwerpunkt;Massenschwerpunkt;Schwerpunkt;Massenmittelpunkt
-regelmäßiges Dreieck;gleichseitiges Dreieck
-Kugeldreieck;sphärisches Dreieck
-Kapitalverwässerung;Verwässerungseffekt
-neue Aktie;junge Aktie
-Langsamfahrstreifen;Kriechspur
-Schwäbischer Jura (veraltet);Schwabenalb (veraltet);Schwäbische Alb (Hauptform)
-Schwäbisch-Fränkische Schichtstufenlandschaft;Schwäbisch-Fränkisches Schichtstufenland;Süddeutsche Schichtstufenlandschaft;Südwestdeutsches Schichtstufenland;Südwestdeutsche Schichtstufenlandschaft;Süddeutsches Schichtstufenland
-Zuckerschlecken (ugs., fig.);angenehme Erfahrung
-nummerieren;mit einer Nummer versehen;beziffern
-Improvisationstheater;Improtheater (Kurzform);Stegreiftechnik;Stegreiftheater;Imprivosationstechnik;Impro-Theater (ugs.)
-Federrate;Federkonstante;Richtgröße;Federhärte;Direktionskonstante;Federsteifigkeit
-Armierung;Bewehrung
-Synchronbuch;Dialogbuch
-Dialogbuchautor;Synchronautor
-Blutentnahme;Blutabnahme
-Hyperhydration;Hyperhydratation
-Halbfertigteildecke;Filigrandecke;Gitterträgerdecke;Elementdecke;Kaiserdecke
-Betonfertigteil;Betonelement
-Kofferdamtuch;Cofferdam (engl.);Kofferdam;Spanngummi
-Geobezug;Raumbezug;Georeferenz
-Geheimhaltungsvertrag;Verschwiegenheitsvereinbarung;Geheimhaltungsvereinbarung;NDA (engl.);Geheimhaltungserklärung;Vertraulichkeitsvereinbarung
-Nackedei (ugs.);nackter Mensch;(ein) Nackter;Nacktfrosch (ugs.)
-Polyandrie;Vielmännerei
-Polygynie;Vielweiberei
-Februarumsturz;Februarputsch
-Entdeckungsreise;Erkundung;Studienreise (veraltet);Expedition;Forschungsreise
-Haarnetz;Mückennetz;Bettnetz;Fangnetz;Moskitonetz;Fischernetz
-Simplonpass;Simplon
-Stealthflugzeug;Tarnkappenflugzeug
-Pflichtwahlunterricht;Wahlpflichtunterricht
-Pflichtwahlfach;Wahlpflichtgegenstand (österr.);Wahlpflichtfach
-Wahlpflichtkurs;Pflichtwahlkurs
-ordentliches Unterrichtsfach;Pflichtgegenstand (österr.);Pflichtfach;ordentliches Lehrfach;ordentliches Schulfach
-duales Berufsausbildungssystem;duale Ausbildung
-Höhenpunkt;Höhenangabe;Kote
-orthogonale Projektion;senkrechte Projektion;Orthogonalprojektion
-Sachunterricht;Sachkundeunterricht;Sachkunde (ugs.)
-schützen (ugs.);decken (ugs.);einmummeln (ugs.);panzern (ugs.);einhüllen (ugs.);decken;einhüllen;immunisieren (geh.)
-Berner Klause (veraltet);Veroneser Klause
-Engpass;Talpass
-vaskuläre Pflanze;Gefäßpflanze
-Hofratsecken (ugs., österr.);Calvities frontalis (fachspr., lat., medizinisch);Ministerwinkel (ugs.);Ehestandswinkel (ugs.);Geheimratsecken (ugs.);Ratsherrenecken (ugs., schweiz.)
-Spartakusaufstand;Januaraufstand
-Manjurei;Mandschurei
-Krusenstern-Straße;Koreastraße;Tsushimastraße;Straße von Korea
-Tagesschule;Ganztagsschule;Ganztagesschule
-Lehrkörper;Lehrerkollegium;Lehrerschaft
-Proton-Proton-Kette;Proton-Proton-Reaktion;p-p-Reaktion
-maxwellsche Geschwindigkeitsverteilung;Maxwell-Boltzmann-Verteilung
-Entweichgeschwindigkeit;kosmische Geschwindigkeit;astronautische Geschwindigkeit;Fluchtgeschwindigkeit
-vorschriftswidrig;gegen die Vorschrift
-Magnatenhaus;Magnatentafel
-Choresm;Choresmien
-rollendes Material;Rollmaterial
-Typisierung (österr.);Bauartzulassung
-Radarhöhenmesser;Radar-Altimeter
-Radarhöhenmesser;Funkhöhenmesser
-Prüfplakette;Begutachtungsplakette (österr.);Pickerl (ugs., österr.)
-Deutsche Alpenstraße;Queralpenstraße
-Erlebnisstraße der deutschen Einheit;Straße der Mahnung und des Gedenkens
-Literarischer Tourismus;Literaturtourismus
-Ikonoklasmus (fachspr.);Bildersturm
-Flussgebiet;Stromgebiet;Entwässerungsgebiet;Abflussgebiet;Niederschlagsgebiet;Einzugsgebiet
-Erbgerechtigkeit;Erbstollengerechtigkeit
-Beleihung;Belehnung;Verleihung;Bestätigung
-Mutung;Muthung
-Muther;Muter
-Klappe (österr.);Durchwahl
-Abfrageplatz;Telefonzentrale;Vermittlungsplatz
-Präzedenz-Effekt;Gesetz der ersten Wellenfront
-Awarenmark;Pannonische Mark
-Paniberismus;Panhispanismus
-Hispanoamerikanismus;Iberoamerikanismus
-Iberismus;Iberischer Unionismus
-Nordniederfränkisch;Kleverländisch
-Juvianuss;Marahonkastanie;Rahmnuss;Amazonasmandel;Brasilianische Kastanie;Yuvianuss;Paranuss;Brasilnuss;Amazonenmandel;Amazonaskastanie;Brasilianische Nuss;Brasilkastanie;Papanuss;Steinnuss;Tucannuss
-Gauß-Verfahren;gaußsches Eliminationsverfahren
-Elementarmatrix;Eliminationsmatrix
-Cholesky-Faktorisierung;Cholesky-Zerlegung
-selbstadjungierte Matrix;hermitesche Matrix
-LU-Zerlegung;Dreieckszerlegung;LR-Zerlegung
-Permutationsmatrix;Vertauschungsmatrix
-Einheitsmatrix;Identitätsmatrix
-Identität (Kurzform);identische Abbildung
-Ahl-Spitze;Bodkin-Spitze
-Speerschleuder;Atlatl
-Romberg-Versuch;Romberg-Test
-Donkosaken;Don-Kosaken
-Matrix-Schalter;Selektor;Umschalter;Kreuzschiene;Umschaltbox
-Koppelfeld;Kreuzschienenverteiler (veraltet)
-Ostfränkische Völkertafel;Bayerischer Geograph
-ausgeprägt;umrissen;deutlich;prägnant;markant;scharf
-Geschichtliche Hilfswissenschaft;Historische Hilfswissenschaft;Historische Grundwissenschaft
-Massenaussterben;Massenextinktion
-Prostatakrebs;Prostatakarzinom (fachspr.)
-Knochenmetastase;ossäre Metastase;Skelettmetastase
-Galvoantrieb;Galvo;Galvanometerantrieb
-Dünger;Düngemittel
-Spurenelement;Mikroelement
-Berufungsgericht;Appellationsgericht
-Begnadigungsrecht;Gnadenrecht;Gnadenbefugnis
-Zweiteiler;Dilogie
-Vierteiler;Tetralogie;Quadrologie
-Pentalogie;Fünfteiler
-Hexalogie;Sechsteiler
-Heptalogie;Siebenteiler
-Oktologie;Oktalogie;Achtteiler
-Neunteiler;Ennealogie
-Zehnteiler;Dekalogie
-Zwölfteiler;Dodekalogie
-Amerikanischer Schwarzbär;Baribal
-Zwölferkrieg;Toggenburgerkrieg;Zweiter Villmergerkrieg
-Aktivsprache;Aktiv-Stativ-Sprache
-Aufzählung;Spiegelstrichliste
-Enumeratio;Enumeration
-Akkumulation;Accumulatio;Worthäufung
-Prinzip der umgekehrten Pyramide;Trichteraufbau
-Internettext;Webtext;Online-Text
-Anthropomorphismus;Vermenschlichung;Zuschreibung menschlicher Eigenschaften
-Zunfttruhe;Zunftlade;Amtslade
-Willkommpokal;Willkommbecher;Willkomm;Willkommen
-Arnsberger Landständepokal;Arnsberger Willkomm;Westfälischer Landständepokal
-Arnsberger Landtag;Landtag des Herzogtums Westfalen;westfälische Landständeversammlung
-Paprika;Spanischer Pfeffer
-Koordinatenreferenzsystem;Koordinatenbezugsystem
-Bezugsystem;Referenzsystem
-Erdmittelpunkt;Geozentrum
-Kehrwoche (schwäbisch);(wöchentlicher) Flurdienst;Flurwoche;(wöchentliche) Treppenhausreinigung
-(etwas tun) können (ugs., ironisch);an jemandem sein, etwas zu tun (geh.);(es) für seine Pflicht halten (etwas zu tun) (geh.);(jemandes) Pflicht sein (etwas zu tun);dafür zuständig sein (etwas zu tun);(die) Verpflichtung haben (etwas zu tun);es ist an dir (zu);(etwas tun) sollen;(jemandem) obliegen (etwas zu tun);(jemandes) (verdammte) Pflicht und Schuldigkeit sein (ugs.);gehalten sein (etwas zu tun) (geh.);(sich) gehalten sehen (zu) (geh.);(etwas tun) müssen;(jemandem) zugedacht sein (geh.);(etwas tun) dürfen (ugs., ironisch);verpflichtet sein (etwas zu tun)
-Universiade;Weltsportspiele der Studenten
-Koralpe;Koralm (ugs.)
-Speick;Speik
-Lavandula latifolia (fachspr., botanisch);Spanischer Lavendel;Breitblättriger Lavendel;Speik-Lavendel;Gewürz-Lavendel;Großer Speik
-Bittere Schafgarbe (Hauptform);Achillea clavenae (fachspr., botanisch);Weiße Schafgarbe;Steinraute;Almwermut;Weißer Speik
-Aurikel;Alpenschlüsselblume;Alpenaurikel
-Nardenähre;Indische Narde
-Hoheslied Salomos;Hohes Lied;Hoheslied
-Gleinalpe;Gleinalm
-(jemandes) Name sagt (schon) alles;(jemandes) Name ist ein Zeichen;Nomen est omen. (Hauptform, lat., sprichwörtlich);(jemandes) Name ist Programm
-Astro-Chronologie;astronomische Chronologie
-Archäoastronomie;Astroarchäologie;Ethnoastronomie;Paläoastronomie
-Voodoo-Zauber;Schadenszauber;Voudou-Zauber;Schwarze Magie;Wodu-Zauber
-Katadesis (griechisch);Defixion;Katadesmos (griechisch);Fluchtafel
-Taubenhaus;Taubenschlag
-Hexensabbat;Teufelstanz
-Teufelstanzplatz;Hexentanzplatz
-Bedienfehler;Fehlbedienung;Bedienungsfehler (Hauptform);Bedienerfehler
-zu fassen kriegen;festhalten;am Schlafittchen packen (ugs.);am Kragen packen (ugs.);beim Wickel nehmen (ugs.);beim Wickel kriegen (ugs.);am Weglaufen hindern
-(jemanden) verbringen (fachspr., Amtsdeutsch);abholen (ugs.);sistieren (fachspr.);wegbringen;mit zur Wache nehmen (ugs.);in Haft nehmen;mit auf die Wache nehmen (ugs.);abführen;mitnehmen (ugs.)
-gefangen nehmen;internieren;ins Lager stecken;festsetzen
-Personenfeststellung (ugs.);PK (fachspr., Abkürzung);Personenkontrolle;ADV (fachspr., Abkürzung);Allgemeiner Datenvergleich (fachspr.);Identifizierung;PF (fachspr., Abkürzung);Feststellung der Personalien;PEKO (fachspr., Abkürzung);Identitätsfeststellung;Feststellung der Identität;Personenüberprüfung;IDF (fachspr., Abkürzung)
-in die Mache nehmen;nicht mit Samthandschuhen anfassen;(mit jemandem) Schlitten fahren (fig.);(jemanden) nicht schonen;durch die Mangel drehen (ugs., fig.);(intensiv) bearbeiten (fig.);(jemanden) bei den Eiern packen (derb, fig.);(jemanden) hart angehen;(jemandem) arg zusetzen;(jemanden) in die Zange nehmen (fig.);(jemandem) ans Leder gehen (fig.);(jemandem) die Hölle heißmachen (ugs., fig.);(jemandem) an die Eier gehen (derb);(jemandem) (tüchtig / ordentlich) einheizen (fig.);(jemand hat) keine ruhige Minute mehr (übertreibend);in die Mangel nehmen (ugs., fig.);(jemanden) hart rannehmen
-Fahrangst;Amaxophobie (fachspr.)
-Blutphobie;Hämatophobie
-Gebirgsmechanik;Felsmechanik
-selber entscheiden können;Handlungsfreiheit haben;freie Hand haben;(frei) schalten und walten können
-Vorne-kurz-hinten-lang-Frisur;Vokuhila (ugs.)
-norddeutscher Markgrafenkrieg;Sundischer Krieg
-Trajekt;Eisenbahnfährlinie;Eisenbahnfährverbindung
-rückläufiges Delta;rückwärtiges Delta;Rückseitendelta
-Prerower Strom;Prerowstrom
-Seegatt;Seegat
-Acies visus (lat.);Sehschärfe;anguläre Sehschärfe;Minimum separabile (lat.);Sehstärke;Visus (fachspr., lat.)
-Speerspitze (einer Bewegung) (fig.);Vorhut;Avantgarde (franz.);Vorreiter;Vorkämpfer
-Umlaufwasser;Kreislaufwasser
-Temperierung;Heizung/Kühlung
-glasartig;transparent;glasig;hyalin;klar;durchscheinend
-Obsidian;Glas
-isomorph;gleichgestaltig
-Moldau;Böhmisches Meer
-Stubenarrest;Hausarrest
-Reala (ugs., Jargon, weibl.);Realpolitiker (bei den Grünen);Realo (ugs., Jargon, männl.)
-Verbindungsstürmer;Verbinder;Halbstürmer
-Polarisierung;Polarisation
-Achsenzylinder;Neuraxon;Axon
-Myelinscheide;Markscheide
-Lemnozyt;Schwann'sche Zelle;Schwann-Zelle
-Ranvier-Node;Ranvier-Schnürring;Ranvier'scher Schnürring
-Synapsenendknöpfchen;präsynaptische Endigung;Axonende;Axonterminale
-Neuron;Nervenzelle
-demyelinisierende Erkrankung;Entmarkungskrankheit
-kondensiertes Proanthocyanidin;Tannin
-Tannin-Trocken-Kollodiumverfahren;Tannin-Prozess;Tannin-Verfahren
-Taubenschlagprinzip;Schubfachprinzip
-Trassenwarnband;Trassenband
-Deionisations-Kammer;Lichtbogenlöschkammer;Funkenlöschkammer;Deionkammer
-Lasttrennschalter;Lasttrenner
-Verkehrsflugzeug;Verkehrsmaschine (ugs.)
-Linienflugzeug;Linienmaschine (ugs.)
-Geschäftsflugzeug;Geschäftsreiseflugzeug
-Geschäftsreiseflugverkehr;Geschäftsflugverkehr
-Luftverkehr;Flugverkehr
-Erdkampfflugzeug;Bodenkampfflugzeug;Schlachtflugzeug
-Jagdbomber;Jabo
-Pumpenstrahlantrieb;Jetantrieb;Waterjetantrieb;Wasserstrahlantrieb;Pumpjetantrieb
-migratorisch;wandernd
-Pod-Antrieb;Propellergondel
-Drei-Türen-Problem;Monty-Hall-Problem;Monty-Hall-Dilemma;Ziegenproblem
-Böhmischer Wind (sächsisch);Böhmwind (bayr.)
-Becken von Mexiko;Tal von Mexiko
-Küchenbrigade (fachspr., Jargon);Küchenmannschaft (ugs.);Küche (ugs.);Mitarbeiter der (Abteilung) Küche;Küchenpersonal
-Umwelttechnik;Umweltschutztechnik
-Pritzker-Architektur-Preis;Pritzker-Preis
-Militärpflicht;Wehrpflicht
-Rödel (schweiz.);Kirchen-Matriken (österr.);Kirchenbuch;Kirchenmatrikel;Rodel (schweiz.)
-Taufbuch;Taufregister
-Neptunstaufe;Linientaufe;Äquatortaufe
-Wolfstaufe (veraltet);Heidentaufe (veraltet);Alte Taufe
-Chicorée;Schikoree (alte Schreibung bis 2011)
-unförmig;roh gefügt;klobig;klotzig;grob behauen;wuchtig;ungefüge
-Gezweige;Geäst;Gezweig;Astwerk
-Hohlknolliger Lerchensporn;Hohler Lerchensporn
-2-mal;zweimal
-dreimal;3-mal
-4-mal;viermal
-5-mal;fünfmal
-die Zeit ist reif;es ist so weit;die Zeit (für ...) ist gekommen
-nicht ansteckend;avirulent
-Vollzeiter;(in) Vollzeit Arbeitender
-Teilzeitmitarbeiter;Teilzeitkraft;Teilzeitbeschäftigter;Teilzeiter;Teilzeitarbeiter;Teilzeitangestellter;(in) Teilzeit Arbeitender
-kolportieren;hausieren
-Mussau-Inseln;St.-Matthias-Inseln
-Mussau;Prinz-William-Henry-Insel;St. Matthias-Insel
-Flugkunst;Aviatik
-Paarzerstrahlung;Paarvernichtung
-Goldgräber;Goldschürfer;Digger
-Älterwerden;Altwerden
-Ägäis-Makedonien;Griechisches Makedonien
-Gemeiner Steinbock;Alpensteinbock
-Daghestan-Tur;Ostkaukasischer Steinbock
-Sibirischer Steinbock;Asiatischer Steinbock
-Syrischer Steinbock;Nubischer Steinbock
-Kuban-Tur;Westkaukasischer Steinbock
-Kretische Gämse;Kri-kri;Kretische Wildziege;Agrimi
-Schraubenziege;Markhor
-französische Kalkalpen;Savoyer Voralpen
-Heilbad;Spa;Kurbad
-Glutenunverträglichkeit;Glutenintoleranz (fachspr.);Glutensensitivität
-Anthologie (geh., bildungssprachlich, griechisch, Hauptform);Blütenlese;Auslese;Auswahl;Spicilegium (fachspr., bildungssprachlich, historisch, lat.);Florilegium (fachspr., bildungssprachlich, historisch, lat.);Textsammlung;Sammlung;Zusammenstellung
-Doppelgipfel;Zwillingsgipfel
-Gierling;Järv;Gierschlund;Giermagen;Vielfraß;Bärenmarder
-Linientaktik;Schlachtreihe;Lineartaktik
-Schlachtordnung;Schlachtenplan
-Umfassungsschlacht;Kesselschlacht
-Kantonreglement;Kantonsystem;Kantonssystem
-Erythroprosopalgie;Bing-Horton-Neuralgie;Histaminkopfschmerz;Cluster-Kopfschmerz
-darüber hinausgehend;darüberhinausgehend
-schmutzabweisend;Schmutz abweisend
-Zahlungen einstellen;den Geldhahn zudrehen
-Fleischgericht;Fleischspeise
-Personaler;Personalist (österr.)
-Weißrussischer Höhenrücken;Westrussischer Höhenrücken (veraltet);Westrussischer Landrücken (veraltet)
-Nießbrauch;Nutzniessung (schweiz.);Fruchtgenussrecht (österr.)
-Großdeutschland (ugs.);Großdeutsches Reich;Großdeutsches Volksreich
-Deutsch-Belgien;Deutschbelgien;Ostbelgien;Neubelgien (veraltet)
-deutsches Sprachgebiet;deutscher Sprachraum
-Zentralstaat;Einheitsstaat
-Hauptort;zentraler Ort
-Rippströmung;Trecker;Rippstrom;Brandungsrückstrom
-Mikrofonanordnung;Mikrofonsystem
-Äquivalenzstereofonie;gemischte Stereofonie
-Mikrofonie;Mikrophonie (veraltet)
-Tschukotkagebirge;Anadyrgebirge;Tschuktschengebirge;Hochland von Tschukotka
-standardisiertes Privatkundengeschäft;Retailgeschäft
-Beringinsel;Awatscha-Insel (veraltet)
-Kommandeurinseln;Komandorski-Inseln
-Zweite Kamtschatkaexpedition;Große Nordische Expedition
-Holledau;Hollerdau;Hallertau
-Autobahnknoten (österr.);Knoten (österr.);Kreuz;Autobahnkreuz
-oberster Gott;Hauptgott
-Hanseatische Bürgergarde;Hamburger Bürgermilitär
-Methylalkohol;Methanol;Holzalkohol
-Ampelfrau;Ampelweibchen;Ampelmädchen
-Ampelmännchen;Ampelmann
-Gasteiner Konvention;Vertrag von Gastein;Gasteiner Vertrag;Bad Gasteiner Beschlüsse
-Donau-Oder-Kanal;Oder-Donau-Kanal
-Fußfessel;Fußeisen;Fußschelle
-Dielenfußboden;Schiffboden;Dielenboden;Riemenboden
-Bohle;Pfosten
-Siderographie;Stahlstich
-Vizerektor (österr.);Prorektor
-Turmhelm;Helmdach;Helm;Dachhelm
-bigraphisch;bigrafisch
-vorgesetzt;vorrangig;übergeordnet;hochrangig;höhergestellt;vordringlich;vorgeordnet
-hochgestochen;hochtrabend;hochtönend;großtönend
-Biograf;Biograph
-teilfinanzieren;zum Teil finanzieren
-verwelkt;welk;schlaff;etwas eingetrocknet;saftlos;nicht straff;etwas vertrocknet;saft- und kraftlos
-verblüht;abgeblüht
-nicht mehr lebendig;abgestorben;leblos;devital (fachspr., lat., neulateinisch, zahnmedizinisch);tot;ohne Leben;lebt nicht mehr;nekrotisch (fachspr., griechisch)
-Shoppingcenter;Einkaufsmarkt
-wenn mich nicht alles täuscht, ...;ich glaube, ...
-bitterböse;kurz vorm Explodieren (sein) (ugs.);auf hundertachtzig (ugs.);wie eine Furie;auf 180 (ugs.);rasend;tobsüchtig;vor Wut schäumen(d);fuchsteufelswild;wutentbrannt;mordssauer (ugs.);blindwütig;stinksauer (ugs.);außer sich (vor Wut);wutschnaubend;in maßloser Wut;stinkwütend (ugs.);stocksauer (ugs.);in blinder Wut
-Hauptgang;Hauptgericht;Hauptspeise
-Glückwünschender;Gratulant (Hauptform);Gratulierender;Beglückwünscher
-Slasher (Filmfigur) (fachspr., Jargon);Serienmörder;Metzelmörder (ugs.);Serienkiller
-strategische Eisenbahn;strategische Bahn
-Pontosgrieche;Pontusgrieche;Pontier
-After-Sales;After Sales
-Argonnen;Argonner Wald
-Buddelparty (niedersächsisch);Mitbringparty;Buddelfete (niedersächsisch);Buttelparty (norddeutsch)
-Zapfengeld (schweiz.);Korkengeld;Stoppelgeld (österr.)
-Koopkurrenz (fachspr.);Nicht-Nullsummenspiel (fachspr.);Coopetition (fachspr., engl.);Kooperationswettbewerb (fachspr.)
-Militärdiözese;Militärordinariat
-Schlächter (ugs., fig.);Massenmörder
-Hexeditor;Hex-Editor
-Astrograph;Astrograf
-Thorner Honigkuchen;Thorner Lebkuchen
-Fahrsteig;Rollsteig (ugs.);bewegter Bürgersteig (ugs.);rollender Bürgersteig (ugs.);Laufband (ugs.)
-wie besichtigt;nach Besicht (fachspr., juristisch, kaufmännisch);nach Besichtigung;wie gesehen;wie etwas geht und steht;wie besehen;auf Besicht (fachspr., juristisch, kaufmännisch)
-Personalie;(Entscheidung über eine) Stellenbesetzung;Personalangelegenheit;Personalentscheidung
-Theaterschauspieler;Bühnenkünstler
-Typecasting (Film) (fachspr., Jargon, engl.);Fach (Theat.);Rollentypus;Rollenfach (Theat.);Rollentyp
-zuvor;davor;vor diesem Zeitpunkt;eher;vorher;früher;vorher;vordem
-eh (ugs.);ehe;bevor
-(schon) lange;bereits;schon;längst
-(einer Sache) verfallen;abhängig werden (von);nicht sein lassen können;(etwas) (immer wieder) tun müssen;hörig werden;(sich) nicht losreißen können (von)
-schwarzer Humor;Lust am Makabren (geh.);Galgenhumor
-beseelt (von);erfüllt (von);durchdrungen (von)
-darauf kommen (ugs.);herausbekommen;auf etwas kommen (ugs.);herausfinden;auf den (richtigen) Trichter kommen (ugs.);auf den Dreh kommen (ugs.);den richtigen Dreh rauskriegen (ugs.);rauskriegen (ugs.);draufkommen (ugs.);(die) Lösung finden (Hauptform)
-(klar) zu Tage treten;entdeckt werden;ans Licht kommen (fig.);(sich) herausstellen;herauskommen (es);offenbar werden;auffliegen;ans Tageslicht kommen (fig.);aufgedeckt werden;zutage treten
-Wunschdenken;realitätsfremd;wirklichkeitsfremd;lebensfremd;irreal;(ein) frommer Wunsch (ugs., ironisierend);unrealistisch;utopisch;illusorisch;illusionär
-sicherlich nicht;gewiss nicht;wahrlich nicht;weiß Gott nicht (ugs.);beileibe nicht;in der Tat nicht;alles andere als;bestimmt nicht;nicht wirklich (ugs.);mitnichten (geh.);sicher nicht;wahrhaftig nicht;nun wirklich nicht (geh.);wirklich nicht (Hauptform);durchaus nicht;bei allem, was recht ist, nicht
-Römische Kicher;Kichererbse (Hauptform);Cicer arietinum (fachspr., lat.);Felderbse;Venuskicher;Echte Kicher
-beileibe kein;gewiss kein;sicher kein;in der Tat kein;alles andere als ein;nicht wirklich ein;fürwahr kein;weiß Gott kein (ugs.);wahrlich kein;wahrhaftig kein;wirklich kein;tatsächlich kein;bestimmt kein
-aus (A) wird (B);geraten (zu);(sich) entwickeln (zu);(sich) gestalten (zu);werden (zu)
-Kolloquialismus (fachspr.);umgangssprachlicher Ausdruck
-Fernsehproduktion (Film);Fernsehfilm;Fernsehspiel
-Rödeln;Stahlflechten
-kurzsilbig (veraltet);wortkarg;redescheu;wortarm;nicht viele Worte machen;kurz angebunden;nicht gesprächig;schmallippig (reagieren) (fig.);nicht kooperativ (mit Ermittlern) (Jargon);zugeknöpft (ugs.);zurückhaltend (reagieren);(sich) kurz fassen;kurz ab (ugs.);einsilbig;wenig auskunftsfreudig;maulfaul (ugs.)
-herumschwafeln (ugs.);herumsalbadern (ugs.);sich (selbst) gerne reden hören;viele Worte machen;nicht auf den Punkt kommen;salbadern (ugs.);wortreich;lange um den heißen Brei herumreden (ugs.)
-aushäusig;nicht zu Hause;weg (ugs.);ausgeflogen (spöttelnd);abwesend;außer Haus;außer Hauses (geh.);nicht daheim;nicht da (ugs.);unterwegs (ugs., Hauptform)
-nicht erreichbar;nicht an seinem Arbeitsplatz;nicht zur Arbeit erschienen;nicht an seinem Platz
-was essen (ugs.);essen gegangen;in der Mittagspause;zu Tisch
-unbekannt verzogen;wohnt nicht mehr hier (ugs.)
-wird vermisst (Person);verschollen (Person)
-mit unbekanntem Ziel abgereist;(jemandes) Aufenthaltsort ist unbekannt
-unbenommen;ungeachtet;trotz;entgegen;zum Trotz(e);unbeschadet (Amtsdeutsch)
-auf der anderen Seite;anderseits;andrerseits;andersrum (gesehen);zum anderen;man muss auch sehen (dass) (ugs., floskelhaft);zum andern;andererseits;das muss man (ja) auch mal sagen: ... (ugs., floskelhaft);man sollte nicht übersehen (dass)
-kein ... und auch kein;nicht ... und auch nicht;weder ... noch
-an Wunder glauben;an den Weihnachtsmann glauben
-Fundamentalist;Radikaler;Extremist
-Anarchist;Anarcho (ugs.)
-Teamworker (engl.);Teamplayer (engl.)
-Nestflüchter;Ausreißer
-Romantiker;Idealist;Fantast;Utopist;Phantast;Schwärmer;Träumer
-Pistolero;Revolverheld (Hauptform)
-kurze Darstellung;kurzer Blick auf;Streiflicht
-Scheinwerferkegel;Lichtkegel
-Streiflicht;schräg einfallendes Licht
-konturenscharf;scharf konturiert
-mit starken Kontrasten;kontrastreich
-à (kaufmännisch);zu;zu jeweils;für je;um (österr.);für jeweils;zu je
-nach dem Muster;auf die (...) Tour (ugs.);auf ... Art;im Stil(e) (von);in ...manier;im ...-Stil;(frei) nach dem Motto (...);in der Art (von);in (...) Weise;à la (franz.);nach dem Prinzip;...mäßig (ugs.);nach Art von
-vordringlich sein;an erster Stelle stehen;zuerst kommen;Vorrang haben;vorrangig sein;prioritär (sein) (geh.);schwerer wiegen;ganz oben auf der Agenda stehen;vorrangig behandelt werden;vorgehen;Priorität haben;ganz oben auf der Tagesordnung stehen;wichtiger sein
-(hohe / höchste) Priorität einräumen;ganz oben auf die Tagesordnung setzen;ganz oben auf die Agenda setzen;vorrangig behandeln
-Peanuts;Obolus;unbedeutende Summe
-Steuer;Zwangsabgabe;Tribut;Zwangsbeitrag
-Abgeltungsteuer;Abgeltungssteuer;Zinssteuer
-Hüftgold (ugs., fig.);Dickmacher;Kalorienbombe
-Geborgensein;Nestwärme;Umhegtsein
-Lovestory;Liebesroman
-Eiapopeia (ugs.);(es herrscht) eitel Sonnenschein;trügerische Harmonie;Friede, Freude, Eierkuchen (ugs.);(auf) gut Wetter machen (fig.);Heiteitei (ugs.);gespielte Harmonie;Schalmeienklänge (fig.)
-(ungesunde) Konfliktvermeidung;Harmoniesucht;Konfliktscheu
-Schneelawine;Lawine;Schneerutsch
-nun ... doch;jetzt ... doch;aber ... doch;so ... doch (geh.)
-(unverstellter) Blick auf;Perspektive;Sichtachse
-Multikulturalismus;Multi-Kulti (ugs.);Multikulti (ugs.)
-Altpapier;Papierabfälle;Makulatur;Papierabfall
-Deakzession (fachspr.);Bestandsbereinigung (fachspr.);Abgang (aus dem Bestand)
-Erwerbung;Neuzugang;Neuerwerbung;Akzession (fachspr.);Zugang
-Restebuchhandel;modernes Antiquariat
-Antiquariat;Gebrauchtbuchhandel
-Remittende (fachspr.);Remittendenexemplar;Rückläufer
-Einstampfung;Vernichtung;Makulation (fachspr.);Makulierung (fachspr.)
-Retoure (fachspr.);Rücksendung;Remission (fachspr.)
-Schließfachhotel;Kapselhotel;Wabenhotel;Sarghotel (ugs.)
-Vollpension;VP (Abkürzung)
-Lieferungsverzug;Nicht-Rechtzeitig-Lieferung (fachspr.)
-Social Media (Plural, engl.);soziale Medien (Plural);Mitmachweb (ugs.);Mitmachnetz (ugs.);Web 2.0;Social Web
-startklar;zum Start bereit;startbereit;bereit zum Start
-abändern;ändern;neu bestimmen;neu fassen;auf den Prüfstand stellen;revidieren;überarbeiten;neu definieren;korrigieren;einer Revision unterziehen (Papierdeutsch);überholen
-Bierbike;Bier-Bike
-Lakonie;kurzer, treffender Ausdruck
-scheintot (derb, abwertend);greis (geh.);hochbetagt (geh.);steinalt;(ein) biblisches Alter (erreichen);uralt;(ein) biblisches Alter (haben);(ein) gesegnetes Alter (haben);hoch an Jahren;(ein) hohes Alter (erreichen);alt wie Methusalem;sehr alt (Hauptform);greisenhaft;hochbejahrt (geh.)
-Bummelstudent (ugs.);ewiger Student
-Wilfried Dietrich;Kran von Schifferstadt (ugs.)
-Non-Fiction;Nichtfiktion;Faktuales;Nichtfiktionales
-Fantasiestaat;Mikronation;Scheinstaat
-katzenhaft;katzenartig
-Teilnehmervermittlungsstelle;Amt;Ortsvermittlungsstelle;Fernsprechvermittlungsstelle;Wählamt;Endvermittlungsstelle
-präsidentielles Regierungssystem;Präsidialregime;Präsidialsystem
-Nettogewicht;Feingewicht (Legierung)
-Bruttogewicht;Raugewicht;Schrot;Rauhgewicht (veraltet)
-Kaperschiff;Kaper
-husch husch, ins Körbchen (ugs.);ab in die Federn! (ugs., fig.);husch husch, die Waldfee (ugs., Spruch, veraltend);ab ins Bett! (ugs.)
-(die) Autobahn nehmen;(über die) Autobahn fahren (ugs.)
-über die Dörfer fahren (ugs.);Schleichwege fahren
-Landreform;Bodenreform
-Teilzeitwohnrecht;Teilzeiteigentum;Ferienwohnrecht;Teilnutzungsrecht;Timesharing;Wohnnutzungsrecht
-Grand Hotel;Grandhotel;Luxushotel (ugs.)
-Panegyrikos;Panegyrikus;Panegyricus
-komm nicht unter die Räder! (ugs.);baba und foi ned! (ugs., wienerisch);hau rein! (ugs.);machs gut, aber nicht so oft! (ugs., Spruch, scherzhaft);mach's ganz gut! (im Tonfall der 'neuen Empfindsamkeit');halt die Ohren steif! (ugs.);halt dich senkrecht! (ugs.);lass dich nicht hängen!;gehab dich wohl! (scherzhaft, veraltet);bleib sauber! (ugs.);pass (gut) auf dich auf!;lass dich nicht unterkriegen!;mach's mal gut!;mach's gut!;pass auf, dass du nicht unter die Räder kommst! (ugs.)
-bis die Tage! (ugs., ruhrdt.);bis nächste Tage! (ugs., ruhrdt.);bis denn! (ugs.);bis demnächst in diesem Theater! (ugs.);bis neulich! (humoristisch) (ugs.);bis dann mal! (ugs.);bis denne! (ugs.);auf bald! (geh.);bis dann! (ugs., Hauptform);beehren Sie uns bald wieder! (geh., Jargon, kaufmännisch, veraltet);see you! (ugs., engl.)
-see you! (ugs., engl.);man sieht sich! (ugs.);wir sehen uns!;wir telefonieren!
-Dritte Ypernschlacht;Dritte Flandernschlacht
-Siegfriedlinie;Siegfriedstellung
-(die) Waffen schweigen;Waffenruhe;Einstellung der Kampfhandlungen;Feuerpause
-68er;Altachtundsechziger;Alt-68er;Alt-Achtundsechziger
-(68er) Studentenunruhen;(68er) Protestbewegung;68er-Bewegung;(68er) Studentenbewegung
-Nationalisierung (geh.);Einbürgerung;Erwerb der Staatsbürgerschaft;Naturalisation (geh.);Verleihung der Staatsbürgerschaft;Nostrifikation (fachspr.);Erlangung der Staatsbürgerschaft
-Speiserübe;Märkische Rübe;Mairübe Petrowski;Teltower Rübchen
-Stoppelrübe;Räben;Krautrübe;Herbstrübe;Ackerrübe;Weiße Rübe;Wasserrübe
-Rübsamen;Rübsen;Rübsaat
-Kreuzblütler;Cruciferae (fachspr., Plural, botanisch);Brassicaceae (fachspr., Plural, botanisch);Kreuzblütengewächs
-Proviant-Magazin;Körnermagazin
-Zielballistik;Terminalballistik;Endballistik
-Tennisball-Wurfmaschine;Tenniswurfmaschine;Ballmaschine;Ballwurfmaschine
-Patellarreflex;Quadrizepsreflex;Kniephänomen;Kniesehnenreflex;Quadricepsdehnungsreflex;Patellarsehnenreflex
-Fingerstreckreflex;Extensor-digitorum-Reflex;Braunecker-Effenberg-Reflex
-Fingerflexorenreflex;Mayerscher Grundgelenkreflex;Hoffmann-Reflex;Fingerbeugereflex;Knips-Reflex;Trömner-Reflex;Kino-Reflex
-Masseter-Temporalisreflex;Unterkieferreflex;Masseterreflex
-Kinnlade;Unterkiefer
-Pronationsreflex;Pronatorenreflex
-Brachioradialisreflex;Radiusperiostreflex
-Trizepssehnenreflex;Taschenmesserreflex
-Rossolimo-Reflex;Zehenbeugereflex
-polysynaptischer Reflex;Fremdreflex
-Ehrdelikt (fachspr., juristisch);Ehrverletzungsdelikt (fachspr., juristisch);Ehrverletzung
-Europäisches Ziesel;Schlichtziesel
-einsichtig;Vernunftgründen zugänglich (geh.);zugänglich;raisonnabel (geh., franz.);verständig;vernünftig;Einsicht zeigend;räsonabel (geh., franz.)
-ausschließen;nicht hereinlassen;aussperren;am Zutritt hindern;keinen Zutritt gewähren
-betreten;verlegen (Hauptform);verschämt;peinlich berührt;genierlich;gschamig (süddt.);in Verlegenheit
-rumzicken (ugs.);Geschichten machen (ugs.);(sich) haben;(sich) anstellen;(sich) zieren;zimperlich sein
-mitgehen;mitziehen (ugs.);mittun;(sich) einlassen auf;mitspielen (ugs.);mitmachen (passiv) (ugs., Hauptform);kooperieren;(sich etwas) (gerne) gefallen lassen
-Opi (ugs.);Großpapa (ugs.);Großvater;Opa (ugs.)
-(einer Sache den) letzten Schliff geben;(etwas bekommt den) Feinschliff (fig.);letzte Hand anlegen bei
-im (gesellschaftlichen) Abseits;abgehängt;marginalisiert
-Telefonistin;Fräulein vom Amt
-Unihockey;Floorball
-heißer Herbst (ugs.);Streikwelle im Herbst
-Hashtag anlegen (fachspr.);verschlagworten
-Minijobber;geringfügig Beschäftigter;auf 450-Euro-Basis Beschäftigter;Geringverdiener;geringfügig entlohnter Beschäftigter
-altweiß;gelblich-weiß;eierschalenweiß;weißlich;cremeweiß
-kompromittierende Emission;kompromittierende Abstrahlung;bloßstellende Abstrahlung
-quantenhafte Emission (veraltet);spontane Emission
-induzierte Emission;stimulierte Emission
-letzte Zuckungen;(der) Anfang vom Ende;letztes Aufbäumen;letztes Aufflackern (fig.)
-Schlussphase;Endphase;Anfang vom Ende
-Prüfungsausschuss;Prüfungskommission
-wann;bei was;in welchem Fall
-Wirbelringstadium;Vortex-Ring-Stadium
-nicht zu gewinnen sein (Kampf);gegen Windmühlen kämpfen (fig.);keine Chance haben;(ein) totes Pferd reiten (ugs., fig.);auf verlorenem Posten kämpfen;(einen) aussichtslosen Kampf kämpfen
-gefallsüchtig;narzisstisch;kokett;eitel
-affektiert (geh.);gekünstelt;mit abgespreiztem kleinen Finger (fig.);pretiös (geh.);affig;geziert;preziös (geh.)
-(jemandem ein Fehler, ein Schnitzer, eine Panne) unterlaufen;(jemandem ein Fehler, ein Schnitzer, eine Panne) passieren (ugs.);(einen) Fehler machen (versehentlich);(einen) Bock schießen (ugs.)
-Stalagnat;Sintersäule
-Höhlenmineral;Speläothem
-(zu) kurze Jacke;Affenjacke;Affenjäckchen
-Flapsigkeit;Mangel an Ernsthaftigkeit;Unernst;nichts als Unsinn im Kopf haben;nichts als Flausen im Kopf haben (ugs.);Hanswurstigkeit (ugs.)
-warum nicht!? (ugs.);soll er doch! (ugs.);warum auch nicht;wenn's (denn) hilft ... (ugs.)
-Blockgerät;blockorientiertes Gerät;Blockspeichergerät
-Fusionsreaktor;Kernfusionsreaktor
-Schwingung;Oszillation
-am Tag darauf;am nächsten Tag;am darauffolgenden Tag;tags darauf;den andern Tag (regional);einen Tag später
-Computerspielsucht (ugs.);Videospielsucht (ugs.);Computerspielabhängigkeit
-Schweigepflicht;Verschwiegenheitspflicht
-Kode;Code
-Zwergwiesel;Mauswiesel;Mustela nivalis (fachspr., lat.);Kleinwiesel;Hermännchen
-mit die ersten sein (ugs.);ganz vorne mitmischen;(neue) Maßstäbe setzen;ganz vorne (mit) dabei sein (ugs.);führend (sein);eine(r) der ersten (sein)
-Stadtquartier;Stadtviertel;Viertel;Quartier (schweiz.);Stadtgeviert;Wohnviertel
-feuchtes Klima;humides Klima
-Velokurier (schweiz.);Fahrradkurier
-Geldhandel;Tages- und Termingeldhandel
-Sozialgeheimnis;Sozialdatenschutz
-Militärgeheimnis;militärisches Geheimnis
-(auf etwas) gepolt;(auf etwas) eingestellt;(auf etwas) getrimmt (ugs.);(auf etwas) ausgerichtet;(auf etwas) programmiert (ugs.)
-starr;erwartungslos (geh.);emotionslos;ungerührt;versteinert;reglos;erstarrt;unbewegt;mit leeren Blick;regungslos;maskenhaft;ausdruckslos (Gesicht);roboterhaft
-Gegenverkehrsstraße;Zweirichtungsstraße
-Überholung;Überholen;Überholvorgang
-Altorthodoxer;Altgläubiger
-Sowjetisch-Mittelasien;Russisch-Turkestan;West-Turkestan
-Dezembrist;Dekabrist
-Ost-Turkestan;Chinesisch-Turkestan
-Anurie (fachspr.);Schwanzlosigkeit
-(jemandem) wie aus dem Gesicht geschnitten sein;kaum zu unterscheiden sein;sehr ähnlich sein;(sich) ähneln wie eineiige Zwillinge;(sich) zum Verwechseln ähnlich sehen;(sich) täuschend ähnlich sehen;(sich) ähneln wie ein Ei dem anderen;(praktisch jemandes) Doppelgänger (sein);(sich) zum Verwechseln ähneln;(sich) sehr (stark) ähneln;(sich) gleichen wie ein Ei dem anderen;(jemandem) täuschend ähnlich sehen;sehr ähneln;(jemandem) sehr ähnlich sehen
-Vorwärts-Verteidigung (euphemistisch);Vorwärtsverteidigung (euphemistisch);Präventivschlag
-(jemandes) Abziehbild (ugs.);Doppelgänger;Klon (ugs.);Ebenbild;Abbild
-Double;Ersatzdarsteller
-Ersatzidentität;Zweitidentität;Kunstfigur;virtuelle Identität;Avatar
-abweichendes Verhalten;Devianz
-unerträglich;an der Schmerzgrenze;kaum auszuhalten;nicht zu ertragen;nicht auszuhalten;jenseits der Schmerzgrenze;kaum zu ertragen
-nachgemacht;billiges Imitat;...-Verschnitt (ugs.);Möchtegern...;(...) für Arme (ugs.);...verschnitt (ugs.)
-tauschen;kaupeln (ugs.);handeln
-Ernährer;Haushaltsvorstand;Versorger;Haushaltungsvorstand
-Steigungsregen;Stauregen
-unterkühlter Regen;Eisregen (ugs.)
-Betriebspunkt;Betriebszustand;Arbeitspunkt
-Kennlinienfeld;Kennfeld
-Mikrosystemtechnologie;Mikrosystemtechnik
-Strecker-Nyquist-Kriterium;Stabilitätskriterium von Nyquist
-nichtparametrische Statistik;verteilungsfreie Statistik;parameterfreie Statistik
-Zufallsveränderliche;zufällige Größe;Zufallsgröße;stochastische Variable;stochastische Größe;Zufallsvariable
-Kompaktleuchtstofflampe;Energiesparlampe (ugs., Hauptform)
-föderiertes Informationssystem;föderiertes Datenbanksystem
-Informations- und Kommunikationssystem;Informationssystem
-Waffentragbewilligung (schweiz.);Waffenpass (österr.);Waffenschein
-Vorarlbergbahn;Vorarlberger Bahn
-in voller Montur;in voller Rüstung;in vollem Ornat
-uniformiert;livriert;in Uniform
-(schwer) in Schale (ugs.);geschniegelt und gebügelt (ugs.);geschniegelt (ugs.);piekfein;durchgestylt;geschniegelt und gestriegelt (ugs.);herausgeputzt;in Kluft (ugs.);(perfekt) gestylt
-nuttig (derb);billig;ordinär;wie eine Nutte (derb)
-(gestylt) wie ein Pfingstochse (ugs.);(in voller) Kriegsbemalung (ugs., scherzhaft-ironisch);grell geschminkt;(übertrieben) stark geschminkt
-Ablaufumgebung;Ausführungsumgebung;Laufzeitumgebung
-Zeremonie;feierliche Handlung;feierlicher Akt
-Lexer;lexikalischer Scanner;Tokenizer
-Zeremoniar;Zeremoniär;Zeremonienmeister
-Veranstaltungsfachmann (IHK-Zertifikat, i.d. Schweiz Lehrausbildung mit EFZ);Veranstaltungskaufmann;Eventmanager
-Wedding-Planner;Hochzeitsplaner
-Panoptikum;Wachsfigurenkabinett
-Panoptikum;Wunderkammer (historisch);Kuriositätenkabinett;Raritätenkabinett
-Megastadt;Megacity
-ein Ziel vorgebend;programmatisch;richtungsweisend
-torpedieren;mit einem Torpedo beschießen
-Suchtklinik;Trinkerheilanstalt (historisch);Entziehungsklinik;Nasenbleiche (ugs., scherzhaft);Entzugsklinik;Fachklinik für Suchterkrankungen;Entziehungsanstalt
-Konkurrenzkampf;Eifersüchtelei;missgünstiges Verhalten
-Frontansicht;Front;Vorderseite;Vorderansicht;Fassade;Schauseite;Exterieur (fachspr.)
-Krawallant (schweiz.);Radaubruder;Randalierer;Krawallschläger;Schreihals;Gewaltbereiter;Krawallmacher;Unruhestifter;Ruhestörer
-kommen wie gerufen (Hauptform);(nur) allzu bereitwillig (übernehmen o.ä.) (variabel);nur auf etwas gewartet haben;willkommene Gelegenheit (zu);hochwillkommen;(sich) wie die Geier stürzen auf (ugs.);wie gerufen kommen;(sich) stürzen auf;Steilvorlage (fig.);(ein) gefundenes Fressen (fig.)
-ohne die erforderliche Sorgfalt;ohne kritische Kontrolle;ohne genaue Prüfung;unkritisch
-kundenindividuelle Massenproduktion;individualisierte Massenfertigung
-Etappensieg (auch figurativ);erfolgreiches Zwischenergebnis;Teilerfolg;Zwischenerfolg
-Modellpflege (Autoproduktion) (fachspr.);Relaunch (engl.);Mopf (Autoherstellung) (fachspr.);optische Verbesserung;Facelifting (ugs., engl., fig.);Runderneuerung;Facelift (Autoherstellung) (fachspr.);Verjüngungskur (fig.)
-Erfolgsstory;Erfolgsgeschichte;(ein) erfolgreicher Verlauf
-Budaer Berge;Ofner Bergland (veraltet)
-Anstieg;Steigerung;Verbesserung;(ein) Mehr;positive Entwicklung;(ein) Plus;Aufstieg;Aufwärtsentwicklung
-Böhmweg;Böhmischer Steig
-hydraulische Frakturierung;hydraulische Risserzeugung;Fracking (Kurzform, engl.);hydraulisches Aufbrechen;hydraulische Stimulation
-Filmmontage;Richten
-Matrix;Matrixautomat
-Kaschierung;Kasch
-Bildwand;Leinwand;Projektionswand
-Umspultisch;Umrolltisch
-Patenttroll (ugs.);Patentverwerter
-Familienvorstand;Familienoberhaupt
-Golf von Thailand;Golf von Siam (veraltet)
-Nutzwald (ugs.);Wirtschaftswald (ugs.)
-Reinbestand;Monokultur
-Primärwald (fachspr.);Urwald (ugs.)
-Naturwaldreservat;Waldreservat;Bannwald (regional)
-Baumbestand;Bestand (fachspr.);Waldstück (ugs.)
-Freiberufler;Selbstständiger
-Ausstand;Abschiedsfeier
-zum Schreien (komisch) (ugs.);zum Brüllen komisch (ugs.);zum Schießen (ugs.);brüllend komisch (ugs.);zum Totlachen (ugs.);rasend komisch (ugs.);saukomisch (ugs.);zum Kaputtlachen (ugs.);äußerst komisch;irrsinnig komisch (ugs.);(sehr) witzig
-Staatsraison;Staatsräson
-Geheimpolitik;Arkanpolitik
-Meidung;Gemeinschaftsentzug
-(sich) nicht abfinden (können) mit;unzufrieden sein mit;hadern mit;(sich) nicht abgefunden haben (mit)
-ewig zu kurz gekommen;vergrämt;verbittert;voller Bitterkeit;(sich) ewig zu kurz gekommen fühlen;(sich) vom Leben betrogen fühlen;vom Leben enttäuscht;bitterlich enttäuscht;voller Bitternis (geh.);voller Frustrationen;mit sich im Hader;frustriert
-Niederbayern-Straubing-Holland;Straubing-Holland;Niederbayern-Straubing;Bayern-Straubing-Holland;Bayern-Straubing
-Kinderparadies;Kinderaufbewahrung
-Anteilnahme;Interesse;Zugewandtheit;Aufmerksamkeit;Wertschätzung;Freundlichkeit
-Betreuer;Sorgeberechtigter;Kurator (geh., veraltet);gesetzlicher Vertreter;Vormund
-Kirchspiel;Pfarrbezirk
-Verkauf ab Werk;Outlet-Store;Lagerverkauf;Factory Outlet;Werksverkauf;Fabrikverkauf
-Jagd nach Sonderangeboten;Schnäppchenjagd
-Alles im Lack? (ugs., salopp);Alles fit im Schritt? (ugs., salopp);Wie ist das werte Befinden? (geh.);Was macht die Kunst? (ugs., Spruch, veraltend);Alles klar bei dir? (ugs.);Wie stehen die Aktien? (ugs., fig., veraltend);Alles klar bei euch? (ugs.);Wie geht es Ihnen?;Wie geht's?;Wie sieht's aus?;Wie geht's, wie steht's?;Wie läuft's bei dir (so)? (ugs.);Und selbst? (ugs.);Alles gut (bei dir)? (ugs.)
-unbebaut;unbesiedelt;nicht erschlossen;grüne Wiese (auch figurativ);nicht besiedelt
-zweite Wahl;B-Ware
-kosmetischer Makel;kosmetischer Fehler;kleine Macke;Schönheitsfehler;(geringer) Makel;kosmetischer Mangel;unwesentliche Beeinträchtigung
-Großreinemachen;(das) große Aufräumen;Kehraus (veraltet)
-Rausschmeißer (fig.);letzter Tanz;letzte Nummer;Kehraus
-Grundreinigung;gründliche Reinigung;Reinigung von Grund auf
-energisch dazwischengehen;schweres Gerät (einsetzen) (fig.);entschieden einschreiten;zu drastischen Maßnahmen greifen;resolute Maßnahmen ergreifen;mit dem eisernen Besen auskehren (fig.);hart durchgreifen
-(sich) selbständig machen (ugs., fig.);von allein;ohne Zutun von außen;auf mysteriöse Weise;wie von selbst;wie von einer unsichtbaren Kraft (getrieben o.ä.);von selbst;ohne Fremdeinwirkung (fachspr.);wie von Geisterhand bewegt;ohne sichtbare Einwirkung von außen;wie ferngesteuert
-Schulsystem;Schulwesen
-Flyschzone;Rhenodanubischer Flysch
-mit allen Extras;mit allem Pipapo (ugs.);üppig ausgestattet (variabel);mit allem, was dazugehört;mit (allem ... und) Furz und Feuerstein (ugs.);reich bestückt (variabel);mit allem Drum und Dran (ugs.);mit allen Schikanen (ugs.);mit allem, was das Herz begehrt;mit allem Zipp und Zapp (ugs.);mit allem Schnick und Schnack (ugs.)
-reihum;(jeder) einzeln;der Reihe nach;einer nach dem anderen;jeder einzelne;nacheinander;nach der Reihe;Punkt für Punkt;abwechselnd
-überallhin;wohin jemand auch geht;auf Schritt und Tritt
-Population;Kollektiv;Gesamterhebungsumfang;Grundgesamtheit;statistische Masse
-Untersuchungseinheit;statistische Einheit;Erhebungseinheit;Merkmalsträger
-Stichprobenerhebung;Teilerhebung;Stichprobenziehung
-Sample (engl.);Teilmenge;Teilmenge einer Grundgesamtheit;Stichprobe
-Totalerhebung;Vollerhebung
-Zusammenhangsmaß;Assoziationsmaß
-ANOVA;Varianzanalyse
-Regressand;endogene Variable;Zielvariable;zu erklärende Variable;Prognosevariable;abhängige Variable;erklärte Variable
-Faktor;unabhängige Variable;Einflussvariable;Prädiktorvariable;Regressor;erklärende Variable;exogene Variable
-Nyasasee;Malawisee
-Brunst;Brunft;Paarungsbereitschaft
-schmerzlich vermissen (geh., floskelhaft);missen (meist redensartlich) (geh., veraltend);(einer Sache) ermangeln (geh., veraltet);(jemandem) fehlen;entbehren;vermissen
-einen Ball (zu jemandem) spielen;passen;abgeben;zuspielen (Ball);(jemanden) anspielen;abspielen;übergeben
-Esslust;Hungergefühl;Lust auf Essen;Hunger;Appetit
-Fressgier;Gefräßigkeit;Fresssucht
-Wiedergänger;Widergänger
-Zustimmungstendenz;Akquieszenz (fachspr.);Ja-Sager-Tendenz
-Säulendiagramm;Barplot (engl.);Balkendiagramm;Stabdiagramm
-Einheitenskala;Intervallskala
-Entsprechung;Übereinstimmung;Konkordanz
-Ordinalskala;Rangskala
-Ratioskala;Proportionalskala;Verhältnisskala;Absolutskala
-Vertrauensniveau;Irrtumswahrscheinlichkeit;Signifikanzniveau
-kategoriales Messniveau;Nominalskala
-Kardinalskala;metrische Skala
-Gruppenwechsellogik;Gruppenkontrolle;Gruppenwechselverarbeitung
-Kohlrübenwinter;Hungerwinter;Steckrübenwinter
-Burgfriedenspolitik;Burgfrieden
-(wie) wild einreden auf (ugs., Verstärkung);(jemanden) vollquatschen (ugs.);(jemandem) die Ohren volllabern (ugs.);(jemanden) volltexten (ugs.);(jemanden) totquatschen (ugs., fig.);(jemanden) volllabern (ugs.);(jemandem) einen Knopf an die Backe labern (ugs., fig.);(jemandem) die Ohren vollblasen (ugs.);(jemanden) zuschwallen (ugs.);(jemanden) an die Wand quatschen (ugs., fig.);(jemandem) die Ohren vollsülzen (ugs.);(jemanden) zuquasseln (ugs.);(jemandem) die Hucke volllabern (ugs., salopp);(jemanden) zutexten (ugs.);(jemanden) in Grund und Boden reden (ugs., fig., variabel);(jemandem) die Ohren vollquatschen (ugs.);(jemandem) ein Ohr abknabbern (ugs., fig.);einreden (auf);(jemanden) vollsülzen (ugs., abwertend);(jemandem) in den Ohren liegen (mit) (ugs.);(jemandem) ein Ohr abkauen (ugs., fig.)
-immer wieder anfangen von (ugs.);(jemanden) traktieren;(auf jemanden) einwirken;immer wieder ankommen mit (ugs.);bequatschen (ugs.);(jemanden) beschwatzen (ugs.);beackern (ugs.);breitschlagen (wollen) (ugs., fig.);beknien (ugs., fig.);so lange wiederholen, bis es einem zu den Ohren wieder herauskommt (ugs., fig., übertreibend);bearbeiten (ugs.);zu überreden versuchen (Hauptform);herumkriegen wollen (ugs.);(jemandem) gut zureden;einreden (auf jemanden);besabbeln (ugs.);rumkriegen (wollen) (ugs.);(jemanden) beschwätzen (ugs., süddt.);(jemanden) bereden (geh., veraltet);überreden (wollen) (ugs.);(jemandem) in den Ohren liegen (mit) (ugs.);(so lange) belatschern (bis) (ugs.)
-weichklopfen (ugs.);(jemanden) bringen zu (ugs.);(jemanden) katholisch machen (ugs., bairisch);zum Nachgeben bewegen;(jemanden) bekehren (fig.);erweichen;(jemanden) zum Einlenken bewegen;weichkochen (ugs.);(jemanden) umstimmen (Hauptform)
-vielgereist;weit herumgekommen;weitgereist;viel gereist;viel herumgekommen
-wird heute so gemacht;macht man heute (oder neuerdings) so;auf dem neusten Stand;State of the Art;Stand der Technik
-AGB;allgemeine Geschäftsbedingungen;(das) Kleingedruckte (ugs.)
-Johanniskraut (Hauptform);Hartheu;Hypericum (fachspr., botanisch)
-nachahmend;imitativ;imitierend
-Stilmischung;Sammlung von Stilzitaten;Durcheinander an Stilen (ugs.);Stilpluralismus;Eklektizismus
-zusammengestückelt;eklektisch (geh.);collagiert (geh.);zusammengeschustert (ugs., abwertend, salopp);zusammengebastelt (ugs.);versatzstückhaft;(aus Versatzstücken) zusammenmontiert;(eine) bloße Kompilation (geh.)
-Bruchstück;herausgelöstes Element;herauslösbares Element;Versatzstück
-Handelsformat;Betriebsform
-Chipentwurf;Chipentwicklung
-vor Freude an die Decke springen;im siebten Himmel (sein);(jemand) könnte die ganze Welt umarmen;Freudentänze aufführen (fig.);außer sich vor Freude (sein);vor Freude in die Luft springen;(vor Freude) Luftsprünge machen
-übers ganze Gesicht strahlen;strahlen;lachen;übers ganze Gesicht lachen;über alle vier Backen strahlen (scherzhaft);lachen wie ein Honigkuchenpferd (ugs.);von einem Ohr zum anderen lachen;grinsen wie ein Honigkuchenpferd (ugs.)
-(jemandem) geht einer ab (bei) (derb);(sich) (an etwas) hochziehen (ugs., fig.);schadenfroh sein (Hauptform);(sich) ins Fäustchen lachen (fig.);(sich) weiden an;insgeheim frohlocken;(sich) (an etwas) aufgeilen (derb);(jemandem) ein innerer Reichsparteitag sein (fachspr., NS-Jargon, fig., veraltet);(eine) böse Freude haben (an);(jemandem) eine Genugtuung sein;(sich) (die) Hände reiben (fig.)
-(ein) süßsaures Lächeln aufsetzen;säuerlich lächeln;gequält lächeln;(sich) ein (gequältes) Lächeln abringen (variabel);(das) Gesicht zu einem schiefen Grinsen verziehen;gute Miene zum bösen Spiel machen
-nicht so hastig (ugs.);ruhig, Brauner (ugs., scherzhaft);schön langsam! (ugs.);gaanz langsam! (beruhigend) (ugs.);(es besteht) kein Grund zur Hektik;keine Panik (ugs.);nur keine Aufregung (ugs.);(nun mal) sachte! (ugs.);So schnell schießen die Preußen nicht! (ugs., sprichwörtlich);immer langsam! (ugs.);keine Panik auf der Titanic (ugs., Spruch);nun mal langsam! (ugs., Hauptform);hetz mich nicht! (ugs.);(nur) keine Hektik (ugs.);kein Stress! (ugs.);immer langsam mit den jungen Pferden! (ugs., sprichwörtlich);nicht so stürmisch! (ugs.);hetzt doch nicht so! (ugs.);gemach! (geh., veraltet);immer mit der Ruhe! (ugs.);(mach hier) keine ungesunde Hektik! (ugs.);Komm (doch) erst mal an! (ugs., Redensart);no ned hudla! (ugs., schwäbisch);ruhig Blut (ugs., veraltend);nur die Ruhe! (ugs.);eine alte Frau ist doch kein D-Zug! (ugs., sprichwörtlich, variabel)
-überhastet auf den Weg gebracht;unausgereift;Schnellschuss (fig.);unausgegoren;mit der heißen Nadel gestrickt (fig.);sturzgeboren;mit heißer Nadel gestrickt (fig.);übereilt beschlossen
-(einen) Pakt mit dem Teufel schließen;(seine) Seele verkaufen
-Seelenverkäufer (ugs.);seeuntüchtiges Schiff
-erfüllen (Wünsche);wahr werden (lassen);Wirklichkeit werden (lassen);realisieren;in die Tat umsetzen
-(das) Böse;(die) Mächte der Finsternis
-halb-;semi-
-Quotenverhältnis;Kreuzproduktverhältnis;Odds Ratio;Chancenverhältnis;Odds-Verhältnis
-Internatsschüler;Zögling (veraltend)
-Überflieger;Wunderkind;Ausnahmetalent;hochbegabtes Kind
-Paraskavedekatriaphobie;Paraskevedekatriaphobie
-sprachliche Hecke;Heckenausdruck
-Heimsuchung;Geißel;Prüfung (christl.-relig.) (geh.);Schicksalsschlag (Hauptform);Schlag
-mit dichtem (o.ä.) Laubwerk;belaubt;laubtragend;mit üppiger (o.ä.) Belaubung
-Modalwert;Modus
-Verteilungsdichte (Kurzform);Wahrscheinlichkeitsdichte (Kurzform);Wahrscheinlichkeitsdichtefunktion;Dichte;Dichtefunktion (Kurzform)
-medizinische Vorgeschichte;Anamnese;Krankengeschichte
-aufschrecken;emporfahren;auffahren;in die Höhe fahren;in die Höhe schnellen;hochspringen;emporschnellen;(plötzlich) senkrecht im Bett stehen (ugs., fig.);hochschnellen;hochfahren;aufspringen;aufspringen wie von der Tarantel gestochen;hochschrecken
-zusammenfahren;zusammenzucken
-Kanaaniter;Kanaanäer
-(sich) auf die Füße stellen;(sich) hochrappeln;(sich) hochkämpfen;aufstehen;auf die Beine kommen;(sich) hinstellen;in die Senkrechte kommen (ugs., scherzhaft);hochkommen;auf die Füße kommen
-(sich) aufsetzen;(sich) hochrecken;(sich) gerade hinsetzen;(sich) aufrichten;(sich) emporrecken;(den) Kopf hochnehmen
-(den) Tag beginnen;aus dem Bett aufstehen;aus den Federn kriechen;(das) Bett verlassen;herausmüssen;aus den Federn müssen;aus dem Bett springen;aufstehen;rausmüssen (ugs.)
-(vom Stuhl) aufstehen;(sich) von den Plätzen erheben;(den) Platz freimachen;(sich) erheben (geh.);(den) Hintern anlüften (ironisch);(sich) von seinem Platz erheben
-(den) Platz räumen;(den) Platz verlassen;(einen oder mehrere Plätze) weiterrücken (ugs.);(den) Platz freigeben;(den) Platz freimachen;(das) Feld räumen
-wieder (voll) da sein;zu neuen Kräften gekommen sein;(wieder) zur alten Form auflaufen;(wieder) ganz der Alte sein
-Neuanfang;Aufbruch zu neuen Ufern;Comeback;Neubeginn;(Name) 2.0 (scherzhaft)
-Schmeckknospe;Geschmacksknospe
-Steatohepatitis (fachspr.);Fettleber-Hepatitis (ugs.)
-portale Hypertension;Pfortaderhochdruck;portale Hypertonie
-Leberpfortader;Pfortader
-Hepatozyt (fachspr.);Leberepithelzelle;Leberzelle
-primäre Siderose;Siderophilie;Eisenspeicherkrankheit;Hämochromatose;Hämosiderose
-Stoffwechselanomalie;Stoffwechselstörung
-Glykogenose (fachspr.);Glykogenspeicherkrankheit
-Keitelkahn;Kurenkahn
-Tsuga canadensis (botanisch);Kanadische Hemlocktanne (fachspr.);Kanadische Schierlingstanne
-Parzen-Fenster-Methode;Kerndichteschätzung
-Gypsy (engl.);Roma (Plur.);Tatern (norddeutsch);Gitano (span.);Sinti und Roma (dt., Plur.);Zigan (veraltet);Zigeuner (abwertend)
-Winkelgeschwindigkeit;Rotationsgeschwindigkeit;Drehgeschwindigkeit
-Leerzeiger;Nullzeiger
-Einkoten;Enkopresis (fachspr.)
-nass geschwitzt (Hauptform);in Schweiß gebadet;schweißgebadet (fig.);geschwitzt (sein) (ugs., regional);durchgeschwitzt;verschwitzt;nassgeschwitzt;(jemandem) klebt jeder Faden am Leib(e);(jemandem) klebt die Kleidung am Leib(e);(der) Schweiß fließt in Strömen;schweißtriefend;(jemand) hat keinen trockenen Faden am Leib (Redensart)
-(die) Nähe des Menschen meidend;ausgewildert;verwildert;wild;nicht an (den Kontakt mit) Menschen gewöhnt;scheu
-vor Schreck zusammenfahren;(einen) Schreck bekommen;(sich) erschrecken;jemandem fährt der Schreck in die Knochen;jemandem fährt der Schreck in die Glieder
-Bild des Grauens;schrecklicher Anblick;Schreckensszenario
-erhöhte Reaktionsbereitschaft;Schreckbarkeit;Alarmbereitschaft;Schreckhaftigkeit
-Nervenanspannung;nervliche Anspannung;Stress;nervliche Belastung
-Tympanum;Tympanon
-Tempelgiebel;Dreiecksgiebel
-gebrochener Giebel;Sprenggiebel;gesprengter Giebel
-Täufer;Anabaptist (veraltet);Wiedertäufer (veraltet)
-Schwarzenau Brethren;Tunker
-Gläubigentaufe;Glaubenstaufe
-Nachahmung Christi;Nachfolge Jesu;Nachfolge
-Sömmern;Sömmerung
-äußerst wichtig;von größter Wichtigkeit;keinen Aufschub vertragen;hochnotwichtig (geh.);höchste Priorität haben;äußerst dringlich;(es) muss eine (schnelle) Lösung her (ugs.);Chefsache (fig.);(jemandem) unter den Sohlen brennen (fig.);brennend (wichtig);unter den Nägeln brennen (fig.);(absolute) Priorität haben;(absoluten) Vorrang haben;von höchster Dringlichkeit (geh.);von äußerster Wichtigkeit;keinen Aufschub dulden;auf den Nägeln brennen (fig.)
-zur Chefsache erklären;(sich) persönlich kümmern um;(etwas) selbst in die Hand nehmen
-(sich) mächtig ins Zeug legen;überaus aktiv sein;zur Hochform auflaufen;zur Bestform auflaufen;zur Höchstform auflaufen
-Pannoniabahn;Leithagebirgsbahn
-Nuklearwaffentest;Atomwaffentest;Kernwaffentest
-Ukrainische Nationalrepublik;Ukrainische Volksrepublik;Volksrepublik Ukraine
-Beispiel dafür, wie man es (eigentlich) nicht machen soll;Horror-Beispiel;abschreckendes Beispiel;Negativbeispiel
-modellhaft;prototypisch;idealtypisch
-Versuchsmodell;Erlkönig (Auto) (fachspr.);Prototyp;Vorab-Exemplar
-Serienmodell;Exemplar aus der Serienfertigung
-zum Ausgleich;als Gegengabe;als Gegendienst;dafür (ugs.);als Kompensation (für);als Ausgleich (für);als Gegenleistung;als (kleines) Dankeschön;im Gegenzug (für)
-Nominalisierung;Substantivierung;Hauptwortbildung
-voller Blütenknospen;mit Knospen besetzt;voller Knospen;knospig (fachspr., Jargon);noch nicht offen (Blüten);noch nicht aufgeblüht
-unschuldig;prälapsarisch (fachspr., sehr selten);unverbildet (geh.);unberührt;naiv
-Magazin;Magazinsendung
-Kulturmagazin;Kulturjournal
-Montagsauto;Zitronenauto
-Angst von Enten beobachtet zu werden;Anatidaephobie (fachspr.)
-Paganismus;Heidentum
-Nösnerland;Nösnergau
-Einheitslokomotive;Einheitsdampflokomotive
-auf ein Maximum bringen;maximieren
-regionale Folklore;lokale Sitten und Gebräuche;örtliches Brauchtum
-Straßenbild;Lokalkolorit;Stadtbild
-allgemeines Lebensgefühl;Bewusstsein der Öffentlichkeit;Allgemeinbewusstsein;allgemeines Bewusstsein
-Wertehintergrund;Wertekontext;Wertekanon;allgemeines Wertebewusstsein;Wertehorizont
-bei Lichte besehen;genau gesehen (Einschub);bei genauerer Überprüfung;bei näherem Hinsehen
-(irgendwohin) gehen, um zu bleiben;heimisch werden;einwurzeln;(seine) Heimat finden (auch figurativ);seine Zelte aufschlagen (fig.);(sich) breitmachen (abwertend);ansässig werden (fachspr., Amtsdeutsch);(sich) niederlassen (Hauptform);(irgendwohin) ziehen;kommen um zu bleiben;(sich) häuslich niederlassen;festen Fuß fassen;(sich) ansiedeln
-permanent;24/7;durchgehend;rund um die Uhr;Tag und Nacht
-lebenslang;solang(e) er lebt(e);durch sein ganzes Leben;(all) sein Lebtag;sein ganzes Leben hindurch (Hauptform);zeitlebens;sein Leben lang;zeit seines Lebens
-nicht aufzuhalten;Man kann nichts dagegen tun. (ugs.);nicht zu stoppen;nicht zu bremsen;unaufhaltsam;man kann nichts tun gegen (ugs.);(es gibt) keine Stopptaste (ugs., fig., scherzhaft);(nur) eine Frage der Zeit;es gibt keinen Weg, etwas zu verhindern
-kann (es) nicht lassen;(jemand) findet die Stopptaste nicht (ugs., scherzhaft);kann nicht aufhören;kann (etwas) nicht abstellen;zwanghaft
-Verwandtenselektion;Sippenselektion
-Bayerische Patriotenpartei;Bayerische Patriotische Partei
-Donauniederung;Donautiefland
-Bessel 1841;Bessel-Ellipsoid
-pausenlos;in einem durch;die ganze Zeit;permanent;unablässig;durchgängig;ständig (ugs.);andauernd (ugs.);immerfort;fortlaufend;ohne Unterbrechung;unverwandt;beständig;durchgehend;immerzu;in einem fort;dauernd (ugs.);fortwährend;ununterbrochen;die ganze Zeit über;perennierend (geh., lat.);fortgesetzt;unterbrechungsfrei;die ganze Zeit hindurch (Hauptform)
-von Kugeln durchsiebt;zahlreiche Einschusslöcher (aufweisen)
-Gedächtnis wie ein Sieb;schlechtes Gedächtnis
-(ein) Gedächtnis wie ein Elefant (haben);(sich etwas) gut merken können;(etwas) nie vergessen;(ein) (sehr) gutes Gedächtnis (haben)
-mach keine Dummheiten (ugs.);tu nichts Unüberlegtes;überleg dir (gut) was du tust
-überleg dir (jetzt) gut, was du (als nächstes) sagst (ugs.);mach es nicht noch schlimmer! (scherzhaft-ironisch);überleg erst, bevor du etwas sagst!;sag jetzt nichts Falsches! (ugs., Spruch)
-Lebenstraum;größter Wunsch
-Gewaltverbrecher;Schwerkrimineller;schweres Kaliber (ugs.);Kapitalverbrecher;Schwerverbrecher
-ständig auf der Hut;überängstlich;übertrieben ängstlich
-(wieder) bei Adam und Eva anfangen (fig.);alles zurück auf null (setzen) (fig.);(wieder) ganz von vorn anfangen;(wieder) bei null anfangen (fig.);nichts haben, auf dem man aufbauen kann;(das) Rad neu erfinden (fig.)
-(etwas) energisch anpacken;(tüchtig) zupacken;(die) Ärmel aufkrempeln (fig.);in die Hände spucken (ugs., fig.);(die) Ärmel hochkrempeln (fig.)
-voller Tatendurst;tatendurstig;tatkräftig;voller Tatendrang;energiegeladen
-Personalausstattung;Anzahl der Mitarbeiter;Personaldecke;Zahl der Mitarbeiter;Belegschaftsstärke
-(Information) aus erster Hand;brühwarm (ugs.)
-dabeistehen (und Däumchen drehen) (ugs.);untätig zusehen;dastehen und nichts tun;Maulaffen feilhalten;untätig danebenstehen (und zugucken);den anderen beim Arbeiten zusehen;(untätig) herumstehen (Hauptform);dastehen und Löcher in die Luft starren (fig.);(sich) die Beine in den Bauch stehen (ugs., fig.);untätig dabeistehen (und glotzen);(dasitzen und) Löcher in die Luft starren (fig.)
-tunlichst;(jetzt ...) verdammt nochmal (ugs.);vielleicht (zur Abwechslung) mal (ugs.);gefälligst;(vielleicht) (...) einfach mal (ugs., ironisch)
-in (großer) Bedrängnis (sein);in einer verzweifelten Lage (sein);keine (andere) Wahl haben;mit dem Rücken zur Wand stehen
-Vorgehensweise;Pose (geh.);Masche (abwertend);Nummer (ugs.);Trick;Tour;Spiel(chen) (ugs.);Muster
-kennt man schon;ausgelutscht (ugs., abwertend, fig.);(ganz) alte Leier (ugs., fig.);man kennt das;ausgetretene Pfade (fig.);altbekannt;abgedroschen (abwertend)
-(sich) (etwas) leidsehen;(etwas) nicht mehr sehen können;(sich) (etwas) leidgesehen haben;es müde sein (immer wieder) zu sehen
-Gift (fig.);(ganz) gefährliches Zeug;Teufelszeug (ugs.);gefährliche Substanz(en);Giftzeug (ugs.)
-unzuvorkommend;wenig entgegenkommend;kein Gentleman;ungefällig;ungalant;nicht kulant;nicht gentlemanlike;uncharmant;unliebenswürdig
-Mythomanie;Pseudologie;Lügensucht;krankheitsbedingtes Lügen;pathologisches Lügen;zwanghaftes Lügen;Pseudologia phantastica (griechisch, veraltet)
-Katechese;Message;Glaubenszeugnis;Homilie
-wie ein Gentleman;gentlemanlike
-Lebenskrise;Sinnkrise;existentielle Krise;existenzielle Krise
-Lager (Hauptform);Führungselement beweglicher Bauteile
-zerschmelzen (ugs.);vor Sehnsucht vergehen;(sich) verzehren vor Sehnsucht;verschmachten;vor Sehnsucht zergehen;dahinschmelzen (ugs., fig., poetisch)
-Erfahrungspotenzial;Erfahrungshintergrund;Erfahrungsschatz;Erfahrungen (Hauptform)
-Baudrate;Symbolrate;Modulationsrate;Schrittgeschwindigkeit
-Rangierfeld;Patchpanel;Patchfeld
-Patch;Rangierung
-Patchkabel;Rangierkabel
-automatische Schaltmatrix;automatischer Schaltverteiler
-(wieder) richtigstellen;(wieder) zurechtrücken;vom Kopf auf die Füße stellen;(wieder) in eine vernünftige Ausgangslage bringen;(wieder) ins (rechte) Lot bringen;(wieder) in Ordnung bringen;(wieder) geraderücken
-(ein) völliges Chaos hinterlassen;völlig durcheinanderbringen;(alles) gründlich durchsuchen;auf den Kopf stellen (fig.);(alles) durchwühlen;verwüsten;in große Unordnung versetzen
-da machst du nichts dran (ugs.);da machste nix (ugs.);und wenn du dich auf den Kopf stellst (ugs.);da kannst du nichts machen (ugs.);da kannst du dich auf den Kopf stellen (ugs.);da kannste nix machen (ugs., regional)
-(sich) verströmen (emphatisch);(sich) ganz hingeben;(sich) verschwenden (emphatisch);(sich) verschenken (emphatisch);(sich) vergeuden (an) (geh.)
-alles tun (für);sein Leben aufopfern;(sich) aufopfern;(sich) opfern;sein Leben einsetzen (für)
-Genfer Initiative;Genfer Vereinbarung;Genfer Abkommen
-Impulsgenerator;Marx-Generator
-Fieberträume;blühender Unsinn;Phantasterei (häufig Plur.);wilde Phantasien;der reinen Phantasie entsprungen
-Videotex (schweiz.);Bildschirmtext;BTX (Abkürzung);Btx (Abkürzung)
-Augenkontakt;Blickkontakt
-Erbsünde (fig.);Geburtsfehler (fig.)
-genetisch prädisponiert;erblich vorbelastet
-peripartal;um den Geburtszeitraum herum;perinatal
-Stehaufmanderl (österr.);Stehaufmännchen (auch figurativ)
-leidensfähig (sein);einiges aushalten;Nehmerqualitäten haben;(gut) (was) einstecken können;hart im Nehmen (sein);(etwas) wegstecken können;so leicht nicht unterzukriegen sein;Steherqualitäten haben
-(sich) unter Kontrolle halten;sich nichts anmerken lassen;keine Regung zeigen;ruhig bleiben;(etwas) mit Fassung tragen;(äußerlich) gefasst reagieren;kaltes Blut bewahren
-UEFA-Fünfjahreswertung;UEFA-Koeffizient
-Chromosomenanomalie;Chromosomenaberration
-Fließgrenze;Streckgrenze
-Südafrikanischer Krieg;zweiter Burenkrieg
-Burenfreistaat;Burenrepublik;südafrikanische Republik
-Südafrikanische Republik;Transvaal-Republik
-Mineralölsteuer;Energiesteuer
-Velounfall (schweiz.);Fahrradunfall
-Verbrauchssteuer;Verbrauchsteuer
-Schanzkleid;Verschanzung
-Progerie;Progeria
-Neill-Dingwall-Syndrom;Weber-Cockayne-Syndrom;Cockayne-Syndrom
-Mikrocephalie;Mikrozephalie
-Kraniostenose (fachspr.);Turrizephalus (fachspr.);Turmschädel;Stenozephalus (fachspr.)
-schlafen wie ein Stein;(tief und) fest schlafen;schlafen wie ein Murmeltier;schlafen in himmlischer Ruh;schlafen wie ein Bär;tief schlafen;schlafen wie ein Baby;schlafen wie ein Toter;(den) Schlaf des Gerechten schlafen
-fliegen (ugs., fig.);wegrationalisiert werden;gegangen werden (ugs., scherzhaft);gekündigt werden;(die) Arbeit verlieren;seinen Hut nehmen müssen (fig.);(die) rote Karte kriegen (ugs., fig.);geschasst werden (ugs.);(sich) was Neues suchen können (ugs.);rausgeworfen werden;gehen müssen;(jemandes) Arbeitsverhältnis wird beendet;entlassen werden (Hauptform);rausfliegen (ugs.);gefeuert werden (ugs.);auf die Straße gesetzt werden (fig.);vor die Tür gesetzt werden (fig.);rausgeschmissen werden (ugs.);(der) Stuhl wird (jemandem) vor die Tür gesetzt (fig.);achtkantig rausfliegen (ugs.);hochkant(ig) rausfliegen (ugs.)
-(den) Laufpass bekommen;vor die Tür gesetzt werden;in die Wüste geschickt werden;an die frische Luft gesetzt werden;weggeschickt werden;abserviert werden
-Führungsetage;Führungskräfte;Chefetage (fig.);Führungsebene;Führungsstab
-Überraschungscoup in der Führungsebene;Palastrevolution (fig.);Aufstand aus den eigenen Reihen
-Demoversion;Testversion;Demo (ugs.)
-Druckstoß;Wasserhammer
-vorbereiten;(die) Weichen stellen (für)
-baugleich;technisch gleichwertig;von gleicher Bauart
-abgekupfert;nachgebaut;kopiert
-Medikament mit gleicher Wirkstoffzusammensetzung;Generikum;Nachahmerpräparat
-(einen) Blick riskieren;kurz hinschauen (ugs.);(ein) Auge riskieren;heimlich hinsehen
-Schlag (...);genau (um);Punkt (...);auf die Minute genau (um);auf die Sekunde genau (um);pünktlich um
-deutschlandweit;in ganz Deutschland;bundesweit
-Spannsystem;Spannmittel;Spannvorrichtung (fachspr.)
-Futter;Dreibackenfutter
-Futter;Vierbackenfutter
-Schleifscheibe;Schleifer;Schleifmittel;Trennscheibe;Schleifkopf
-diensthabend;zum ...dienst eingeteilt;...dienst haben (ugs.);vom Dienst;für (...) eingeteilt;(mit etwas) dran sein (ugs.)
-unheilige Allianz;unselige Verbindung
-Achse des Bösen (Jargon);Schurkenstaaten (Jargon)
-Pausenbrot;Vesperbrot;Jausenbrot;Brotzeit
-europaweit;in ganz Europa
-pampern (ugs.);(die) Sterne vom Himmel holen (für jemanden);verwöhnen;(wie) auf Rosen gebettet sein;bis ans Ende der Welt gehen (für);jeden Wunsch erfüllen (Hauptform);auf (den) Händen tragen;jeden Wunsch von den Augen ablesen
-ganz voll;randvoll;bis zum Rand gefüllt
-ausgebucht;bis zum letzten Platz besetzt;vollbesetzt;bis auf den letzten Platz besetzt
-nichts mehr frei;ausgebucht;komplett;voll belegt
-überbelegt;überbucht
-bis über den Rand gefüllt;bis zum Überlaufen voll;übervoll
-Matrone;Dea;Matrae;Deae;Matres
-von Anfang bis zum Schluss;von Anfang bis (zum) Ende;in voller Länge
-bis (ganz) zum Schluss;bis zum Ende;bis (ganz) zuletzt;bis zum letzten (...);bis zum bitteren Ende (oft scherzhaft)
-bis zum letzten Atemzug;bis zum letzten Herzschlag
-bis zur letzten Patrone (fig.);bis zum letzten Blutstropfen (fig.)
-den ganzen Betrag;in voller Höhe;auf Heller und Pfennig;als vollen Betrag;(vom ersten) bis zum letzten Cent
-Sinuslauf;Wellenlauf
-volle Fahrt voraus;mit unverminderter Geschwindigkeit;mit Karacho (ugs.);(Maschinen) volle Kraft voraus;in vollem Tempo;mit hoher Geschwindigkeit;mit hohem Tempo;in voller Fahrt;unvermindert schnell;mit vollem Tempo
-auf Tournee;auf Tour
-Tournee;Gastspielreise
-auf Montage;auf einer auswärtigen Baustelle (eingesetzt)
-(sich) amüsieren (gehen);auf den Swutsch gehen (ugs., norddeutsch);auf die Walz gehen (ugs., fig.);(einen) Zug durch die Gemeinde machen (fig.);auf Trallafitti gehen (ugs., regional);auf Jück gehen (ugs.);op Jöck jonn (ugs., kölsch);um die Häuser ziehen (ugs.);auf Vergnügungstour gehen;auf die Piste gehen (fig.)
-Wandergeselle;Wanderbursche
-auf Wanderschaft gehen (Gesellenwanderung);auf die Walz gehen
-böswilliges Missverstehen;gezieltes Missverstehen;absichtliches Missverstehen
-gezielt missverstehen;absichtlich missverstehen;böswillig missverstehen
-Freiborddeck;Vermessungsdeck
-Deck;Schiffsdeck
-Plimsoll-Marke;Freibordmarke
-Individualsoftware;Individuallösung
-Semivokal;Sonant;Gleitlaut;Halbvokal
-(ist ja) nichts passiert;macht nichts (ugs.);Schwamm drüber! (ugs., Redensart);(ist schon) vergeben und vergessen (ugs.);war was? (ugs.);kein Problem (ugs.);ich werd's überleben (ugs.);schon okay (ugs.);ist schon vergessen (ugs.);halb so wild (ugs.);alles gut! (ugs.);halb so schlimm
-diplomatische Note;Verbalnote
-Fernabsatz;Distanzhandel;Versandverkauf;Versandhandel;Mailorder (engl.);Versandshop
-Saisonausverkauf;Saisonverkauf;Saisonschlussverkauf
-angesagt sein;an dem sein (ugs.);auf dem Programm stehen;zu erwarten sein
-verraten;untreu werden;über Bord werfen (fig.);Verrat begehen (an) (Hauptform);preisgeben;Ausverkauf (von ideellen Werten)
-freitags;immer am Freitag;jeden Freitag
-in Schönheit sterben;aus dem Leben gerissen werden;aus der Mitte des Lebens gerissen werden;jung sterben (Hauptform);mit wehenden Fahnen untergehen
-dumpfig;unbelüftet;miefig;vermieft;(eine) Luft zum Schneiden (ugs., fig.);ungelüftet;stickig;nicht ausreichend belüftet
-streuen (ugs.);Metastasen bilden;absiedeln;Absiedelungen bilden;metastasieren
-Axishirsch;Chital
-EFT/POS-Terminal (schweiz.);POS-Terminal
-Westliche Tatra;Westtatra
-distinguiert (geh.);fein;betont vornehm;nobel;vornehm;elegant;piekfein (ugs.)
-(die) Risiken streuen;nicht alle Eier in einen Korb legen (fig.)
-Krolloper;Krolls Etablissement;Kroll'scher Wintergarten
-Bermudadreieck;Teufelsdreieck
-Prominenz;Bekanntheit
-klar;(wie) gestochen;scharf;regelmäßig
-zu erwarten stehen;zu erwarten sein;ausgehen können von;rechnen können mit
-spuken;geistern;irrlichtern;herumspuken
-nicht jedermanns Fall (ugs.);nicht jedem gefallen (müssen);nicht nach jedermanns Geschmack;grenzwertig (geh., Neologismus, fig.);nicht jedermanns Sache;nicht jedermanns Geschmack
-berechenbar;rekursiv;effektiv berechenbar
-Gefeilsche (ugs.);hartes Verhandeln;Gezerre (um) (ugs., fig.);Geschacher (ugs.);harte Verhandlung
-Maßnahmenvollzug (österr.);forensische Psychiatrie (ugs.);Forensik (ugs.);Maßregelvollzug
-auf Turkey (ugs.);an Entzugserscheinungen leidend;auf Entzug (ugs.);entzügig (fachspr.)
-(die) Geschlossene (ugs.);geschlossene Abteilung
-Martin-Horn (fachspr.);Martinshorn (ugs., Hauptform);Sirene;Tatütata (ugs.);Einsatzhorn (fachspr.)
-Rundumleuchte;Rundumkennleuchte
-Anteil;Rate;Quote;Teilbetrag
-total (nachgestellt);(der/die/das) reinste (...) (emotional);rein;lauter (ugs.);pur;blank;bloß;nichts als;bar;eitel (veraltend);schier
-Softcover (engl.);Paperback (engl.);Taschenbuchausgabe;Paperbackausgabe;Kleinformat;Taschenbuch
-Großauflage;hohe Auflage
-Zweitvermarktung;Zweitverwertung;Sekundärvermarktung
-Hörbuch;Audiobook;Hörbuchfassung;Audiobuch;Hörbuchausgabe
-Filmrechte;Recht(e) zur Verfilmung
-Möwchen (Jargon);umgekehrte französische Anführungszeichen;Gänsefüßchen (ugs.);Chevrons
-Buchtitelinterpunktionszeichen;Buchtitelzeichen
-annehmen;(sich) überzeugen lassen;verstehen;erkennen;kapieren (ugs.);akzeptieren;einsehen
-mitkommen (bei);(gedanklich) Schritt halten;(einer Sache) folgen
-nicht verstehen (können);(jemandem) nicht in den Kopf wollen;(jemandem) nicht in den Schädel wollen
-gut verstehen (können);gut nachvollziehen können
-Turing-Bombe;Welchman-Turing-Bombe;Turing-Welchman-Bombe
-Freier Tanz;Ausdruckstanz;Neuer Künstlerischer Tanz;Expressionistischer Tanz
-Reigen;Reien;Reihentanz;Reihen
-Pathozentrismus;Sentientismus
-montags;immer am Montag;jeden Montag
-dienstags;immer am Dienstag;jeden Dienstag
-immer am Mittwoch;mittwochs;jeden Mittwoch
-jeden Donnerstag;donnerstags;immer am Donnerstag
-jeden Samstag;samstags;immer am Samstag
-sonntags;Sonntag für Sonntag;sonntäglich;jeden Sonntag;immer am Sonntag
-Kar;Kaar;Kahr
-Rybinsker Stausee;Rybinsker Meer
-einsprachiges Lexikon;einsprachiges Wörterbuch
-etymologisches Lexikon;Herkunftswörterbuch;etymologisches Wörterbuch
-apostolische Sukzession;apostolische Nachfolge
-Schimpfwörterbuch;Wörterbuch der Beschimpfungen
-rückwärtiges Wörterbuch;alphabetisch rückwärts sortiertes Wörterbuch;rückläufiges Wörterbuch
-... für die Reise;Reisewörterbuch;Sprachführer
-Lernwörterbuch;Wortschatz in Sachgruppen
-Wortbuch (veraltet);Dictionarium (veraltet)
-Lexikon der Redewendungen;phraseologisches Wörterbuch;idiomatisches Wörterbuch
-Bauernweisheit;Wetterregel;Wetterspruch;Bauernregel
-Reimwörterbuch;Reimlexikon
-Vertriebsmitarbeiter;Vertriebler
-Fremdwörterlexikon;Fremdwörterbuch
-Lehnwort;Entlehnung (aus dem ...)
-Captcha;(Abfrage o.ä. zur) Mensch-Maschine-Unterscheidung
-Eingabe der Zugangsdaten;Einloggvorgang;Eingabe der Zugangskennung;Authentifizierung
-Anziehungskraft;Zauber;Liebreiz;Charme;Flair;Reiz
-Koalition der Willigen (fig.);Verbündete;Mitmacher
-Spazierweg;Promenade (franz.)
-Uferpromenade;Strandpromenade;Seepromenade;Hafenpromenade
-da geht die Post ab (ugs.);(da ist) schwer was los (ugs.);da ist die Sau los (ugs.);da ist ordentlich was los;(es) geht rund (ugs.);da geht's richtig zur Sache (ugs.);da steppt der Bär (ugs.);(da) ist die Hölle los (ugs.);(es ist) ordentlich Action (ugs.);da boxt der Papst (im Kettenhemd) (ugs.);da ist echt was los (ugs.);(es gibt) richtig Action (ugs.);und ab geht die Luzie (ugs.);da geht's (richtig) ab (ugs.);da ist mächtig was los;es geht hoch her;da ist einiges los (ugs.);da geht (echt) was ab (ugs.)
-Schlagetot;Totschläger
-über die Wupper gehen (ugs., regional, salopp);(sein) Leben verlieren;es gibt (...) Tote;draußen bleiben (historisch, veraltend);tot bleiben (ugs., regional, veraltet);dahingerafft werden (geh.);über den Jordan gehen (ugs., salopp);getötet werden;(ein) Opfer (des / der ...) werden;ums Leben kommen;draufgehen (ugs., salopp);(sein) Leben lassen;umkommen;zu Tode kommen (Hauptform);tödlich verunglücken;(jemanden) das Leben kosten;über den Deister gehen (ugs., norddeutsch, salopp);(den) Tod erleiden;(jemanden) dahinraffen (geh.);hopsgehen (ugs., salopp);(den) Tod finden;vor die Hunde gehen (ugs., sprichwörtlich)
-hopsgehen (ugs., salopp);abnibbeln (derb);abschrammen (derb);abkacken (derb);abkratzen (derb, Hauptform);abnippeln (derb);den Arsch zukneifen (derb);abschnappen (derb)
-verbluten (Hauptform);an Blutverlust sterben
-erfrieren;(den) Kältetod erleiden
-Harakiri begehen;Harakiri machen
-Vier-Augen-Prinzip;Vier-Augen-Kontrolle
-Mutterschaft;Maternität
-Paternität;Vaterschaft
-spinale Stenose;Spinalkanalstenose;Spinalstenose
-Jagiellonen-Universität;Jagellonen-Universität
-Eisenbahnwagen;Waggon;Wagon
-Turnierformat;Turnierform;Turniermodus
-Generalhaus;Generalkurie;Generalatshaus;Generalat
-in epischer Breite;weit augreifend;Oper(n) quatschen (ugs., fig.);ausgreifend (geh.);in aller Ausführlichkeit;umständlich;(sehr) weit ausholen(d);in extenso (bildungssprachlich);wortreich;weitschweifend;weitschweifig;des Langen und (des) Breiten (geh.);ermüdend;Roman (ugs., fig.);lang und breit;überausführlich;seitenlang;raumgreifend;ausufernd;geschwätzig;schwafelig (ugs.);langatmig;viele Worte machen;weitläufig;ausgedehnt;abendfüllend (fig.);ausschweifend (geh.);in ermüdender Ausführlichkeit;erschöpfend (im Wortsinn)
-Bilgenwasser;Kieljauche;Bilgewasser
-Amerikanischer Seesaibling;Kanadische Seeforelle (schweiz.);Amerikanische Seeforelle
-Salmonide;Lachsfisch;Forellenfisch
-Amerikanischer Zander;Glasaugenbarsch
-partizipative Demokratie;partizipatorische Demokratie
-Deixis;indexikalische Semantik
-Wortspiel;Spiel mit Mehrdeutigkeiten;Anspielung
-nicht mehr aufzuhalten sein;(der) Damm ist gebrochen (fig.);es gibt kein Halten mehr
-Tunguska-Explosion;Tunguska-Asteroid;Tunguska-Ereignis
-Steinige Tunguska;Mittlere Tunguska (veraltet)
-Tungusen (veraltet);Evenki;Ewenken
-indigenes Volk;autochthones Volk;Ureinwohner (ugs., veraltet)
-Verteilung;Rollout;Roll-out
-nennenswert;beachtlich;erklecklich;beträchtlich;beachtenswert;nicht wenige;ziemlich groß;signifikant;anerkennenswert;nicht wenig;ordentlich;ansehnlich;recht groß;stattlich;ziemlich (ugs.);(ganz) anständig;achtbar;das ist schon was! (ugs., Redensart);(ein) hübsch(es Sümmchen) (ugs.);nicht unerheblich;erfreulich;kann sich sehen lassen;respektabel;(ganz) schön
-informierte Einwilligung;Einwilligung nach erfolgter Aufklärung
-Retardation;Kriechen
-fetale Hypothrophie (fachspr.);pränatale Dystrophie (fachspr.);intrauterine Wachstumsretardierung (fachspr.)
-Gynäkotropie;Gynäkotropismus
-Bacherngebirge;Bachern;Bachergebirge
-algorithmischer Handel;automatisierter Handel
-Peuschel (ostoberdeutsch);Beuschel
-Aktionsart (fachspr., Hauptform);Phasenbedeutung;Handlungsstufe;Handlungsart
-(der) Cavaliere;Silvio Berlusconi (Eigenname)
-strafbar;darauf steht (Gefängnis);strafbewehrt;strafrechtlich relevant;unter Strafe stehen;darauf steht die ...strafe (ugs.)
-mesomerer Effekt;M-Effekt
-Resonanzstruktur;Mesomerie;Resonanz
-I-Effekt;induktiver Effekt
-Mesomeriepfeil;Resonanzpfeil
-Koinobitentum;Coenobitentum;Zönobitentum
-Wertebereich;Wertemenge
-Wertevorrat;Zielmenge
-Verödung;Sklerotherapie
-Maulbeerspinner;Seidenspinner
-Serikultur;Seidenbau
-Glaubersalz;Natriumsulfat;schwefelsaures Natron (veraltet)
-Federzugklemme;Käfigzugklemme;Käfigklemme;Federkraftklemme
-optische Freiraumübertragung;optischer Richtfunk;optische Freiraumdatenübertragung;optische Freiraumkommunikation;Laserlink
-Heimatort;Bürgerort
-Ortsbürgergemeinde (schweiz.);Burgergemeinde (schweiz.);Ortsgemeinde (schweiz.);Bürgergemeinde (schweiz.)
-Tribalismus;Stammestum
-polnische Tataren;litauische Tataren;weißrussische Tataren;Lipka-Tataren
-aus Gold;goldfarben;goldfarbig;golden;gülden (geh., altertümelnd, poetisch)
-schräge Musik;schräge Nachtmusik
-Gasmangelsicherung;Gasmangelventil
-Gasmesser (ugs.);Gaszähler;Gasuhr (ugs.)
-Handzähler;Klickzähler;Personenzähler;Schusszähler;Counter;Klicker
-Kerbholz;Zählholz;Zählstab;Kerbstock
-monetäre Basis;Geldbasis;Basisgeld;Zentralbankgeldmenge;Geldmenge M0
-Mindestreserveverpflichtung;Mindestreserve
-Notenbank;Zentralnotenbank;Nationalbank;zentrale Notenbank;Zentralbank (Hauptform)
-Golddiskontbank;Deutsche Golddiskontbank
-Hundsheimer Berge;Hainburger Berge
-nächtlich aktiv;nachtaktiv
-tagaktive Lebensweise;Tagesaktivität
-Nachtaktivität;nachtaktive Lebensweise
-konspirieren;(sich) verschwören
-Gewebelehre;Wissenschaft von den Geweben;Histologie (fachspr., griechisch)
-Histrier;Istrier
-befristet;datiert;terminiert;fällig (bis);begrenzt (bis)
-Wohnmotorwagen (schweiz.);Campingbus;Wohnmobil;Reisemobil
-Lieferfrist;Abgabefrist
-Rechtswegserschöpfung;Erschöpfung des Rechtswegs
-Versäumungsurteil (österr.);Versäumnisurteil
-Metainformationen;Metadaten
-Neuemission;Neuausgabe (von Aktien)
-die letzten Reserven aufbrauchen;fast am Ende sein;auf der letzten Rille fahren (ugs.);beinahe nicht mehr können;aus dem letzten Loch pfeifen (ugs.);bald nicht mehr können (ugs.)
-Ansehensverlust;Imageschaden;Imageverlust
-(die) Alarmglocken schrillen (bei) (fig.);(die) Alarmglocken läuten (bei) (fig.);(es) herrscht höchste Alarmbereitschaft (bei);(die) Alarmglocken klingeln (bei) (fig.);gewarnt sein
-(das) Ruder herumreißen (fig.);(das) Ruder herumwerfen (fig.);(einen) neuen Kurs einschlagen (fig.);(den) Kurs ändern (fig.)
-Crazy Otto (engl.);(der) schräge Otto;Fritz Schulz-Reichel
-Kämpfer in vorderster Linie;Frontmann;Sturmspitze (fig.)
-mit einer Stimme sprechen (fig.);einer Meinung sein;dieselbe Sprache sprechen (fig.);(sich) einig sein (in);konform gehen (in);(eine) gemeinsame Marschrichtung haben (fig.);einig gehen (in)
-helle Aufregung;(im) Ausnahmezustand (fig.);große Aufregung
-Ablenkungsversuch;Ablenkungsmanöver;Störfeuer (fig.)
-Leerverkauf;Blankoverkauf
-Winterschlussverkauf;WSV
-Sommerschlussverkauf;SSV
-Verständnis von Kunst;Kunstsinn
-Bananenflanke;Querpass mit Effet
-erfreuliche Aussichten;Hoffnungsschimmer;Hoffnungsstrahl;Lichtstreif am Horizont (fig.);Lichtstreifen am Horizont (fig.);gute Aussichten;Silberstreifen am Horizont (fig.);Silberstreif am Horizont (fig.);Lichtblick
-Hoffnungsfunken;Hoffnungsschimmer;(jedes) kleinste Hoffnungszeichen;Fünkchen Hoffnung;Hoffnungsfünkchen
-nach vorne blicken (fig.);(die) Zukunft gestalten (wollen);an die Zukunft denken;in die Zukunft schauen;nicht zurückschauen (fig.);nach vorne schauen;nach vorne gehen (fig.)
-in bescheidenem Rahmen;in kleinem Kreis;in reduzierter Form;im kleinen Rahmen;in kleinem Rahmen
-(sich) im Rahmen halten;im Rahmen bleiben
-maßlos sein;kein Maß kennen;weder Maß noch Ziel kennen
-aus dem Rahmen fallen (fig.);(den) Rahmen sprengen (fig.)
-(sich etwas) vom Halse schaffen;(etwas) loswerden;von sich schieben (wollen);(etwas) abwimmeln
-anbieten wie sauer Bier (ugs.);loswerden wollen;wie Sauerbier anbieten (ugs.);wie saures Bier anbieten (ugs.);los sein wollen;loszuwerden versuchen
-demonstrativ (Hauptform);deklamatorisch (geh.);ostentativ
-gleitender Durchschnitt;gleitender Mittelwert
-Filter mit endlicher Impulsantwort;Transversalfilter
-nach eigener Auskunft;wie er selbst sagt(e) (ugs.);nach eigenem Bekunden (geh.);erklärtermaßen
-gut aufgehoben;hier richtig (ugs.);da richtig (ugs.);gut untergebracht;am rechten Platz
-Deutscher geworden;auslandsstämmig;mit Migrationshintergrund;(deutsch) mit ausländischen Wurzeln;(jetzt) (einen) deutschen Pass haben;eingebürgert (in Deutschland)
-ausländischer Arbeitnehmer;(ausländischer) Wanderarbeiter;Gastarbeiter;Fremdarbeiter (in D nationalsozialistisch-abwertend oder veraltet);Arbeitsmigrant
-(einen) Kredit aufnehmen;(Geld) aufnehmen (ugs.);(ein) Darlehen aufnehmen;(das) Konto überziehen;(sich) Geld leihen
-50-Pfennig-Stück;Fuchs (ugs., regional);50-Pfennig-Münze
-2-DM-Stück;Zwickel (ugs., bayr., schwäbisch, österr.);2-DM-Münze;2-Mark-Stück;Zweimarkstück
-Sechser (ugs.);5-Pfennig-Münze;5-Pfennig-Stück
-ich mein's ernst;Tatsache! (ugs.);ungelogen;ganz ehrlich (ugs.);(das ist) wirklich wahr (Hauptform);ich muss ganz ehrlich sagen (...) (ugs., floskelhaft);ohne Scheiß (ugs., salopp);kein Scherz;echt (wahr) (ugs.);ganz in echt (ugs.);echt jetzt (ugs.);im Ernst;ohne Flachs (ugs.);ernsthaft;kein Scheiß (ugs., salopp);kein Witz;in echt (ugs.)
-maisblond;blond;goldfarben;goldblond;semmelblond (ugs.);hellhaarig;goldglänzend;blondgelockt;golden (poetisch);gülden (geh., poetisch)
-platinblond (Hauptform);silberblond;weißblond;wasserstoffblond;hochblond
-weizenblond;lichtblond;hellblond (Hauptform);flachsblond;strohblond
-fahlblond;straßenköterblond (derb);aschblond;dunkelblond (Hauptform)
-Palomino (Pferdefarbe);Isabell (Pferdefarbe)
-honigfarben;honigblond;mittelblond
-blondieren;blond färben
-aufhellen;heller tönen;bleichen;heller machen
-gemeinschaftlicher Besitzstand;Besitzstand der Gemeinschaft
-blondiert;blond gefärbt
-Elysion;Insel der Seligen;elysische Gefilde;Elysium
-debil (abwertend);blödsinnig (abwertend, veraltet);blöd(e) (abwertend, veraltet);intelligenzgemindert;schwachsinnig (ugs., abwertend);mental retardiert (med.);geistig behindert (Hauptform);kognitiv beeinträchtigt;kognitiv behindert
-schuldunfähig;unzurechnungsfähig;nicht zurechnungsfähig
-nicht gründlich;schmalspurig
-und da verließen sie ihn (ugs., Spruch);(jemandem) nicht einfallen;(einen) Hänger haben (ugs.);(gerade) nicht weiterwissen;(den) Faden verloren haben (fig.);nicht parat haben (Information) (fig.)
-umständlich;unbeholfen;unpraktisch
-hilflose Person (Jargon);HILO (Jargon)
-Gleiskörper;Oberbau
-Schienenbett;Gleisbett
-Raum-Zeit-Kontinuum;Raumzeit
-unverständig;lernbehindert;eingeschränkt lernfähig;beschränkt lernfähig;ungelehrig;lernschwach;begrenzt lernfähig
-Spätentwickler;Spätzünder
-langweilig;ohne Abwechslung;eintönig;uninteressant;monoton;stumpfsinnig;tumb (geh.);ennuyant (geh., franz., veraltet);spannungslos;stupide;fade;einschläfernd;reizlos;gleichförmig;geisttötend;einfältig (geh., selten)
-lange genug dabei (ugs.);alter Hase (ugs., fig.);(dem) machst du nichts vor (ugs.);kennt sich aus (ugs.);Profi (ugs., Jargon);mit allen Wassern gewaschen (ugs., fig.);schon lange im Geschäft;weiß wo's langgeht (ugs.);(jemand) weiß, wovon er spricht (ugs.);weiß wie es läuft (ugs.)
-wissen, wo der Barthel den Most holt (fig.);wissen, wo die Glocken hängen (fig.);wissen, wo der Frosch die Locken hat (fig.);wissen, wo der Hammer hängt (fig.);wissen, wo's langgeht
-(etwas) rückwärts pfeifen können (ugs.);Meister sein (in);(etwas) sehr gut können;vorwärts und rückwärts herunterbeten können;(etwas) im Schlaf können;aus dem Effeff beherrschen;sehr gut beherrschen;absolut sicher (sein) (in);meisterlich beherrschen
-heiße Luft (ugs., fig.);Windei (fig.);Seifenblase (fig.);Luftnummer (ugs.);leere Versprechungen;vollmundige Ankündigung(en);vox et praeterea nihil (geh., lat.)
-platzen wie eine Seifenblase;zerplatzen wie eine Seifenblase;(jemandem) (die) Hoffnung nehmen;(jemandem) (seine) letzten Illusionen rauben
-(noch) (etwas) vorhaben (im Leben);große Pläne haben;große Pläne machen;(ganz) groß herauskommen wollen
-(eine) wackelige Angelegenheit (sein);auf Sand bauen (fig.);auf unsicheren Beinen stehen (fig.);auf unsicheren Füßen stehen (fig.);(eine) wackelige Kiste (sein) (ugs., fig.);auf tönernen Füßen stehen (fig.);auf Sand gebaut haben (fig.)
-(eine) Kompetenz;starke Seite;ausgeprägte Fähigkeit;(persönliche) Stärke;mein zweiter Vorname (ugs., scherzhaft);besondere Fähigkeit
-unsichere Gegend;Tal der fliegenden Messer (fig.)
-(die) Unschuld vom Lande (ugs., fig.);Unschuldsengel (ugs., fig.);(die) verfolgte Unschuld (ugs.);Unschuldslamm (ugs., fig.)
-(sich) unschuldig geben (Hauptform);auf ahnungslos machen (ugs.);(den) Unschuldigen spielen;so tun, als wenn man von nichts weiß;aussehen, als könnte man kein Wässerlein trüben;(sich) ahnungslos geben;nichts zu tun haben wollen (mit);(die) verfolgte Unschuld geben;überrascht tun;(den) Ahnungslosen spielen;(sich) als verfolgte Unschuld inszenieren;sich geben, als könnte man kein Wässerchen trüben;von nichts gewusst haben wollen;(seine) Hände in Unschuld waschen (Redensart);(sich) dumm stellen (ugs.);(sich) als Opfer (von ...) sehen
-als könnt' er kein Wässerlein trüben (ugs., variabel);mit treuherzigem Augenaufschlag;mit Unschuldsmiene;als könn(t)e er kein Wässerchen trüben (ugs.)
-Chaotiker;Chaot
-alle Hoffnung fahren lassen;(den) Glauben an die Menschheit verlieren;vom Glauben abfallen
-Hüpfkitt;Hüpfender Kitt
-Individualentwicklung;Ontogenese;Ontogenie
-in den Sielen sterben;arbeiten bis zum Schluss;in treuer Pflichterfüllung sterben;jemand arbeitet, bis er tot umfällt;in Ausübung seiner Tätigkeit sterben
-(sich) nichts schenken (ugs.);das Letzte aus sich herausholen;sein Bestes tun (und ... / um ...);(sich) (total) verausgaben;110 Prozent geben (übertreibend);alles geben (ugs.);(sich) Arme und Beine ausreißen (ugs., fig.);(sich) sehr anstrengen (Hauptform);100 Prozent geben;(sich) abstrampeln (ugs.)
-(einen) Arbeitsvertrag abschließen;unterschreiben (bei) (ugs.);anheuern (bei) (fachspr., auch figurativ, seemännisch);(sich) verdingen (veraltet);(eine) Arbeit annehmen;(einen) Arbeitsvertrag unterschreiben
-ist keiner da (ugs.);woher nehmen und nicht stehlen? (ugs.);haben wir nicht (im Angebot);siehst du hier irgendwo (...)? (ugs.);ist nicht (ugs.);gibt's nicht (ugs.)
-Hokuspokus;Simsalabim;Abrakadabra (Zauberspruch);Hexhex
-steinhart;glashart;bretthart;knüppelhart;hart wie Beton;hart (Hauptform);fest;hart wie Kruppstahl;knochenhart;eisenhart;stahlhart
-Muskowien;Moskowien
-keine Unterstützung sein;(jemanden) nicht weiterbringen;(nur) im Weg stehen (ugs., fig.);keine Hilfe sein (ugs.)
-(eine) (angefangene) Sache nicht zu Ende bringen;auf halbem Wege stehen bleiben (fig.);(eine) (angefangene) Sache nicht zu Ende führen;(etwas) nicht fertig machen
-Vorsicht, heiß und fettig! (ugs., scherzhaft);zur Seite!;mach Platz!;Platz da!;lasst mich durch!;geh aus der Schusslinie! (ugs.);aus dem Weg!;weg da! (derb)
-Stiefografie;rationelle Stenografie;Stiefo
-nicht unabänderlich;nicht in Beton gegossen (ugs., fig.);nicht unumstößlich;(das) muss nicht (unbedingt) so bleiben;nicht für die Ewigkeit (gedacht);nicht in Stein gemeißelt (ugs., fig.)
-so eine;sone (ugs.)
-vorfristig;vor Ende einer Frist
-(Warzen o.ä.) besprechen;gesundbeten (auch figurativ)
-(erst mal) können vor Lachen! (ugs., scherzhaft-ironisch);geht nicht
-Moskauer Protokoll;Ostpakt;Litwinow-Protokoll
-Degausser;Entmagnetisierer;Degaußer
-Nur-Hausfrau;Heimchen am Herd (ugs.);Hausmütterchen
-Luftnahunterstützung;Erdkampfunterstützung;nahe Luftunterstützung
-Befehlsverweigerung (ugs.);Gehorsamsverweigerung
-(eine) Gaumenfreude (sein);(gut) schmecken;nach mehr schmecken (ugs.);(nach) (jemandes) Geschmack;(jemandes) Geschmack treffen;(dem) Gaumen schmeicheln (geh.);(vortrefflich) munden (geh.)
-Schlangenfraß (derb);Fraß (derb);schlechtes Essen;Saufraß (derb);Schweinefraß (derb);Hundefraß (derb)
-schlecht gekocht;lieblos zusammengekocht;pampig;zusammengebraut (Suppe);zusammengebrötschelt (ugs., regional);verkocht
-Wehrmacht;Bewaffnete Macht
-ein Duell austragen;(sich) duellieren
-Hafersuppe;Haferbrei;Haferschleim
-Froschaugensuppe;Sagosuppe
-Grießbrei;Grießkoch (österr.)
-eins a;gut;1a;von guter Qualität;tadellos
-Echter Lavendel (fachspr., botanisch);Schmalblättriger Lavendel (fachspr., botanisch);Lavendel (ugs.);Lavandula angustifolia (fachspr., botanisch)
-Lignit;Xylit;Schieferkohle
-Tetrapode (fachspr.);Landwirbeltier (Teil-Übereinstimmung) (fachspr.);Vierbeiner
-Mähnenrobbe;Südamerikanischer Seelöwe
-Etagenbahnhof;Turmbahnhof
-Gesprächsaufhänger;Beginn (eines Gesprächs)
-Kriegsopfer;Kriegstoter
-blinder Aktionismus;Aktionismus;bloßer Aktionismus;(hektische) Betriebsamkeit;hektisches Gebaren;hektisches Agieren
-Gesetz des Dschungels (ugs.);Recht des Stärkeren;Gesetz der Straße (ugs.);Gesetzlosigkeit;Faustrecht
-Offizierkasino (fachspr.);Offiziermesse (fachspr., militärisch);Offizierheim (fachspr.);Offizierskasino;Offiziersheim;Offiziersmesse;Messe
-Büttel;(jemandes) Marionette (fig.);Handlanger;Arsch vom Dienst (derb);(jemandes) Wasserträger (fig.);(jemandes) Bimbo (derb, abwertend);nützlicher Idiot (ugs., Jargon, fig., politisch);(jemandes) Schani (ugs., österr.);(jemandes) Lakai (abwertend);(jemandes) Lellek (ugs., polnisch, ruhrdt.);Mädchen für alles (ugs.);(jemandes) Laufbursche (abwertend)
-Mannschaftssoldat;Schütze Arsch im letzten Glied (ugs.);einfacher Soldat;Landser
-Seicherl (ugs., österr.);(ein) Trauminet (ugs., österr.);Angsthase (ugs.);Feigling (Hauptform);Memme (ugs.);Duckmäuser;Hosenscheißer (derb);Hasenfuß (ugs.);Bangbüx (ugs.);Schisser (derb)
-stark;mit voller Wucht;kräftig;dass es nur so eine Art hat(te) (veraltend);mit aller Gewalt;mit maximaler Stärke;so fest(e) wie möglich (ugs.);dass es nur so (...);volle Pulle (ugs.);mit voller Kraft
-Plempe (ugs., regional);Brühe (ugs.);Plörre (ugs., regional);Spülwasser (ugs., fig.);Lorke (ugs., regional);mieses Getränk
-das wollen wir doch mal sehen! (ugs.);nun grade!;jetzt gerade!;und ob! (ugs.);jetzt erst recht!
-(jemanden) anwidern;(jemanden) ankotzen (derb);widerlich finden;abstoßend finden;schrecklich finden;abscheulich finden;Abscheu empfinden;angewidert (sein);(das) kalte Kotzen kriegen (derb);(das) kalte Grausen kriegen (ugs., salopp);(jemanden) abstoßen
-Kleinkunstbühne;Tingeltangel;Revuetheater;Singspielhalle (österr.);Variété(theater)
-Showgirl;Revuegirl;Revuetänzerin;Varietétänzerin
-Grid-Girl;Race-Queen;Boxenluder;Paddock-Girl;Umbrella-Girl;Pit-Babe
-Hostess;Messehostess
-(gegenseitige) Antonyme (fachspr.);Gegensatzpaar
-Hupfdohle (amüsiert-abwertend) (ugs.);Tänzerin
-Balletteuse;Ballerina;Balletttänzerin;Tänzerin
-das war's dann wohl (ugs.);war wohl nix (ugs.);Satz mit X (- war wohl nix!) (ugs., Spruch);außer Spesen nichts gewesen (ugs.);Fehlanzeige (ugs.)
-Subjekt;Element
-Habituation;Habituierung;Gewöhnung;erlernte Verhaltensunterdrückung
-Häuserblock;Karree;Wohnblock
-nicht reagieren;hat sich aufgehängt (ugs.);hängen (Computer) (ugs.);ist abgestürzt
-Esslinger;Zwieblinger (Spitzname) (ugs.)
-Entwarnung (geben);Aufhebung des Alarmzustands;Rückruf einer Warnung
-freie Schule;Schule in freier Trägerschaft;Privatschule
-Schule in öffentlicher Trägerschaft;Regelschule
-Alternativschule;freie Schule
-Montessorischule;Maria-Montessori-Schule
-unverhältnismäßig;arg (regional);sehr sehr;auffallend;über...;ungemein;verdammt (ugs., salopp);erstaunlich;bis dort hinaus (ugs.);allzu;ausnehmend (geh.);verdächtig (ironisch);ungewöhnlich;überaus;zu (Gradadverb);mehr als;unglaublich (Adverb);ungebührlich;sehr (Gradadverb) (Hauptform);bis zum Gehtnichtmehr (ugs.);über die Maßen;übertrieben;schrecklich (ugs.);unvergleichlich (geh.);furchtbar
-staatstragend;staatsmännisch
-hochfliegend;weltabgehoben;über den Wolken (schwebend) (fig.);ohne Bodenhaftung;realitätsfern;abgehoben (fig.)
-einlullen;in den Schlaf lullen;einschläfern;in den Schlaf wiegen
-kaputtgehen (ugs.);verdorren;absterben (Pflanzen);eingehen (Pflanzen) (Hauptform);vertrocknen
-verenden;sterben;krepieren;eingehen (Tiere)
-einen Gang zurückschalten (fig.);(das) Tempo drosseln;piano machen (ugs.);auf die Bremse treten (fig.);(das) Tempo verlangsamen;halblang machen (ugs.)
-nicht wissen, wie jemand tickt (ugs.);nicht wissen, was in jemandem vorgeht;(jemandem) nur vor den Kopf gucken (können) (ugs.);man steckt nicht drin (ugs., Spruch);(sich) fragen, was in jemandem vorgeht
-nicht mehr laufen;nicht mehr wollen;nicht mehr funktionieren (Hauptform);nicht mehr gehen;es nicht mehr tun;(die) Grätsche machen (ugs., fig.);ausfallen;(den) Geist aufgeben (fig.);(sich) verabschieden (ugs., fig.)
-hopsgehen (ugs., salopp);draufgehen (ugs.);über die Wupper gehen (ugs., salopp);futsch gehen (ugs.)
-zunichte werden;wertlos werden;(den) Bach runtergehen (ugs.)
-durchknallen (ugs., salopp);verdampfen;durchglühen;abschmieren (Sicherung) (ugs., salopp);durch Überhitzung zerstört werden;durchschmoren (ugs.);durchbrennen;abrauchen (ugs., salopp);verglühen
-Hochliteratur;Höhenkammliteratur (geh.)
-Maracuja;Passionsfrucht
-S-Pedelec;schnelles Pedelec
-ansetzen;Fett ansetzen;an Gewicht zulegen;dick(er) werden;in die Breite gehen;(etwas) auf die Rippen kriegen (ugs.);zunehmen;mehr werden (ironisch);(kräftig) zulegen
-kompakt (gebaut);gedrungen;untersetzt;stämmig;bullig
-Zementhonig;Melezitosehonig
-Grundstellung;Ausgangsstellung
-stramm stehen;Haltung annehmen;in Grundstellung gehen;(die) Grundstellung einnehmen (militärisch);strammstehen
-hauptzuständig;hauptverantwortlich
-Trauerhalle;Aussegnungshalle
-Grabkapelle;Friedhofskapelle
-seine letzte Ruhestätte finden;beigesetzt werden;begraben werden
-widerständig;unkooperativ
-unsolidarisch;unkooperativ;unkollegial;unkameradschaftlich
-mit etwas leben können;(einen) Modus Vivendi finden (mit);klarkommen (mit);(für jemanden) okay sein;bereitwillig hinnehmen;zu einem Arrangement kommen;akzeptieren;zurechtkommen (mit);(sich) arrangieren (können) (mit)
-(ein) Sonntagskind (sein);unter einem glücklichen Stern geboren (sein);(ein) Glückskind (sein)
-(jemandem) gegeben sein;(ein) (glückliches) Händchen haben (für) (ugs.);(das) Talent (zu etwas) haben;(etwas) im Blut haben (ugs., fig.);(ein) Naturtalent (sein) (Hauptform);(etwas) in die Wiege gelegt bekommen haben (fig.);(jemandem) in die Wiege gelegt worden sein (fig.);(eine) angeborene Begabung haben (für);(jemandem) in den Adern liegen;zum (...) geboren;(der) geborene (...) (sein);(ein) geborener (...) sein;(jemandem) im Blut liegen (fig.)
-sonnenbeschienen;hell;strahlend;im Sonnenlicht;sonnig;in der Sonne (ugs.);taghell
-Filmkritiker;Filmrezensent
-kulturelle Elite(n);Kulturschickeria;Kultur-Schickeria
-Kulturarbeiter;Kulturschaffender;im kulturellen Bereich Tätiger
-Filmrezension;Filmkritik;Filmbesprechung
-(das) Ich;(das) Ego;(das) Selbst
-einspeichern;deponieren;endlagern
-Umweltgift;Schadstoff;Sonderabfall
-Bücherbestand;Büchersammlung;Bibliothek;Bücherschatz
-Lesesaal;Lesehalle
-Handbibliothek;Handapparat;Präsenzbestand
-unentrinnbar;(jemandem) zubestimmt (geh.);vorherbestimmt;(jemandem) vorbestimmt;schicksalhaft
-wie geschaffen (für) (ugs.);(das) ist unser Mann! (ugs., Spruch, männl.);genau richtig (ugs.);(gut) geeignet;geboren (der geborene ...) (fig.);genau der Richtige (für) (männl.);Idealbesetzung;ideal;(genau) die Richtige (für) (weibl.);(das) ist unsere Frau! (ugs., weibl.)
-(ein) Autonarr (sein);(ein) Autofreak (sein);Benzin im Blut (haben) (fig.)
-Leidenschaft (für);großes Interesse;ausgeprägtes Interesse;starkes Interesse
-Aufnahmebereitschaft;Wachheit (für);Zugänglichkeit;Offenheit;Aufgeschlossenheit;Interessiertheit
-schaulustig;schaugierig;voyeuristisch (abwertend, fig.);schaubegierig;sensationssüchtig;neugierig
-Paparazzo;Paparazzi (Plural);Skandal-Fotograf;Paparazza (weibl.)
-(das) gemeine Volk;(die) Plebs (Antike) (geh.);(die) einfachen Leute
-schwer (wieder) loszuwerden (sein);(viel) Sitzfleisch haben;nicht zum Aufbruch zu bewegen (sein)
-Jahre vergingen, und (...);nach Jahr und Tag;nach (endlos) langer Zeit;(die) Jahre gingen ins Land
-solange er gelebt hat;(all) sein Lebtag;in seinem ganzen Leben;solange er lebt;sein ganzes Leben (lang)
-angefangen mit;ab;seit;von (...) an gerechnet;von (...) an aufwärts;von (...) an
-seit;seitdem;solange (wie);solang
-endlos lange;nicht in endlicher Zeit (fachspr.);eine gefühlte Ewigkeit (ugs.);lange Zeit;endlos;lange;ewig lange;ziemlich lange;eine halbe Ewigkeit (fig.);ewig;sehr lange
-(ja) schon;in der Zwischenzeit (schon) (mal);(ja) schonmal;(ja) schon mal
-schon mal;schonmal;vorher schon einmal;schon einmal
-vielmals;etliche Male;viele Male;zig mal (emotional);x-mal (emotional);zum wiederholten Mal;oftmals;häufig;hundertmal (emotional);oft (Hauptform);sehr oft
-x-malig;wiederholt;...malig;mehrmalig;mehrfach
-(das ist) ganz lieb von Ihnen (von oben herab);du bist ein Schatz!;(das ist) ganz lieb von dir (etwas herablassend);Sie sind ein Schatz!;(das ist) lieb von dir;(das ist) nett von dir;(das ist) lieb von Ihnen;(das ist) nett von Ihnen
-definitionsgemäß;per definitionem (geh., lat.);(schon) aufgrund seiner Definition (variabel);per Definition;per se (geh., lat.)
-nicht von der Stelle kommen;es gibt kein Vorwärtskommen;(sich) im Kreis drehen (fig.);nicht vorankommen;festhängen;auf der Stelle treten (fig.);feststecken;nicht weiterkommen;(es ist) kein Fortschritt erkennbar;in der Sackgasse stecken (fig.);in einer Sackgasse gelandet sein (mit) (fig.);nicht vorwärtskommen;an einem toten Punkt sein (fig.);nicht vom Fleck kommen;es gibt kein Weiterkommen
-hintereinander;in einer Reihe (hintereinander);einer hinter dem anderen;in Linie hintereinander;in Reihe;im Gänsemarsch
-truppweise;in einzelnen Gruppen;grüppchenweise
-(ganz) gelassen;in gemütlichem Tempo;ganz entspannt (ugs.);in langsamem Tempo;in lässiger Gangart;in chilligem Tempo (ugs.);ohne die mindeste Eile;ohne (jede) Hektik;tiefenentspannt (ugs., ironisch);(ganz) gemütlich;gemessenen Schrittes (geh.);langsam;im Schlendergang;ohne die geringste Spur von Eile
-nicht aktiv werden (in einer Sache);nichts tun;den Dingen ihren Lauf lassen;(die) Dinge treiben lassen (negativ);tatenlos zusehen (negativ);(etwas) geschehen lassen;nichts machen;(die) Hände in den Schoß legen (fig.);nichts unternehmen;keinen Finger rühren (fig.);untätig bleiben (Hauptform)
-(einer Sache) seinen Stempel aufdrücken (fig.);maßgeblich mitgestalten;(einer Sache) Form geben;(eine Sache) prägen (geh.);(...)geschichte schreiben (fig.);(einer Sache) ein Gepräge verleihen / geben (ugs.)
-nur eins und eins zusammenzählen (brauchen) (ugs., fig.);(da) passt eins zum anderen (ugs., fig.);versteht jedes Kind (sofort) (ugs., fig.);nicht lange (zu) überlegen (brauchen) (ugs.)
-augenscheinlich;dem Augenschein nach;dem äußeren Anschein nach zu urteilen;wie es scheint;offensichtlich;nach allem Anschein;äußerlich betrachtet;wie es schien;allem Anschein nach;so wie es aussieht;offenbar
-Scheinehe;Ehe (...) nur auf dem Papier (geführt)
-Scheinfirma (ugs.);Strohfirma;Briefkastenfirma (ugs., Hauptform)
-leere Hülle (fig.);Hülse (fig.)
-vorschicken;vorschieben
-Verhandler;Unterhändler;Verhandlungsführer
-(sich) keinen Zwang antun;es sich gemütlich machen;(sich) wie zu Hause fühlen
-(sich) gehen lassen;(die) Füße auf den Tisch legen (fig.);seine (gute) Kinderstube vergessen (fig.)
-(schreien) wie am Spieß (ugs.);wie wild (schreien) (ugs.);aus Leibeskräften (schreien)
-ungläubig dreinblicken;verwundert schauen;glotzen wie ein (ab)gestochenes Kalb;dümmlich glotzen
-ungestraft;straffrei;ungesühnt;straflos
-Strafregisterauszug (schweiz.);(jemandes) Vorstrafenregister;Strafregisterbescheinigung (österr.);Leumundszeugnis (veraltet);(jemandes) Strafregister;polizeiliches Führungszeugnis (D, überholt);Führungszeugnis
-(ein) Krösus;Millionär;(ein) Nabob;(ein) Schwerreicher;Finanzmagnat;Finanzgröße;Geldaristokrat;reicher Mann;(ein) Rockefeller (ugs.);Geldsack (derb);Pfeffersack (ugs.);Milliardär;(ein) Reicher;Superreicher;Finanzkapitalist
-gutverdienend;einkommensstark;Vielverdiener
-frei von Sorgen;unbeschwert;unbesorgt;glücklich;sorglos;sorgenfrei
-neureich;plötzlich zu Geld gekommen
-Finanzaristokratie;Geldadel
-Finanzelite;(die) Reichen;(die) reiche Oberschicht
-an nichts fehlen (es);für alles gesorgt (sein);im Überfluss vorhanden (sein)
-langjährig erfahren (in);bewährt;routiniert;kein unbeschriebenes Blatt;altgedient;lange im Geschäft (auch figurativ);gut eingearbeitet;erfahren
-sattelfest;routiniert;firm;sicher;versiert;fit
-vom Fach;gelernter (...);(...) mit Gesellenbrief;(...) mit Kammerprüfung;ausgebildeter (...);(...) mit (abgeschlossener) Ausbildung;von der Ausbildung her (..)
-Blutwäsche (ugs.);therapeutische Apherese;Blutreinigungsverfahren (ugs.)
-Terrassenöfen;Feuerkorb;Feuerschalen;Feuerstelle
-Schauer;Hafenarbeiter;Schauerleute;Stauer;Schauermann
-Packer;Möbelpacker
-Heidenarbeit (ugs.);hartes Stück Arbeit;harte Arbeit;viel Arbeit;Mordsarbeit (ugs.);Mammutaufgabe;Herkulesaufgabe
-schmutzige Arbeit;Drecksarbeit
-(sich) die Hände schmutzig machen;(sich) die Finger schmutzig machen
-(nur) den Bleistift stemmen (ugs., ironisch);Schreibtischarbeit (machen);Büroarbeit (machen);(sich) nicht die Hände schmutzig machen
-erreichen;(Ergebnis) einfahren (fig.);holen
-reich werden;zu Geld kommen;(ein) Vermögen anhäufen
-ausstreuen;verstreuen;umherstreuen
-ausplaudern;herumtragen;in Umlauf bringen;herumtratschen (ugs.);weitersagen;weitertragen;(... wem / wen / wer ...) alles ... (ugs., variabel);weitergeben;herumerzählen;unter die Leute bringen;verraten (ugs.);weitererzählen;nicht für sich behalten (können) (ugs.)
-(sich) Geschichten ausdenken (ugs.);unter die Leute bringen;in die Welt setzen (Gerücht);verbreiten;in Umlauf bringen
-Speisen und Getränke;Beköstigung;Essen und Trinken;Speis und Trank (altertümelnd);(das) leibliche Wohl;Bewirtung
-Kenngruppenheft;Kenngruppenbuch
-Halskragen;Schutzkragen;Halskrause;Leckschutz
-(die) Backen aufblasen(d) (ugs.);vollmundig;(sehr) von sich überzeugt;im Brustton der Überzeugung
-Leuchtbomben;Markierungsbomben;Christbäume (histor., 2. Weltkrieg) (ugs.);Tannenbäume (histor., 2. Weltkrieg) (ugs.)
-(jemand) kann mit etwas nichts anfangen;(jemandem) fällt nichts ein zu
-auf Zeit spielen (fig.);Zeit herausschinden;versuchen, Zeit zu gewinnen;Zeit gewinnen wollen;(sich / etwas) über die Zeit retten;(künstlich) in die Länge ziehen;Zeit schinden (negativ);(künstlich) hinauszögern;hinausziehen;verschleppen (Prozess; Reformen) (fig.)
-konturlos;nach nichts aussehen(d) (ugs.);farblos (geh., fig.);unscheinbar;angepasst;nicht besonders in Erscheinung tretend;ohne Ecken und Kanten;lieb und nett (aber...);unspektakulär;harmlos;nette(r) (Junge) von nebenan (variabel);unauffällig
-abschließende Kritik;Auswertung;Manöverkritik (fig.);Schlussbesprechung;Nachbesprechung;Auswertungsgespräch;Debriefing (engl.)
-Einweisung;(kurze) Informationsveranstaltung;Einsatzbesprechung;Briefing (engl.);(kurze) Lagebesprechung;Kurzbesprechung;Unterrichtung
-Kurzauswertung;Debriefing
-Rebriefing;(gegenseitige) Abstimmung;Informationsabgleich
-(sich) (ganz) genau erinnern;ich weiß es noch wie heute (...) (formelhafter Ausdruck) (ugs.);unvergessen (sein / bleiben) (geh.);(jemandem) (noch) lebendig vor Augen stehen (geh.);(etwas) (noch) vor sich sehen (ugs.)
-(jemandem) auf der Zunge liegen (fig.);ich hab's gleich;(nicht) kommen auf;(nicht) einfallen (wollen);(einen) (vorübergehenden) Blackout haben;(etwas) nicht (mehr) zusammenbekommen;(etwas) nicht (mehr) zusammenbringen
-Wortfindungsstörung(en);Wortnot
-einherwandeln;gemessenen Schrittes einherwandeln;schreiten;langsam gehen;wandeln;(ruhig) dahingehen
-(eine) Rille in den Teppich laufen (ugs., fig.);herumlaufen wie ein Tiger im Käfig;herumwandern;(ruhelos) hin- und hergehen
-walken (engl.);mit Stöcken laufen (ugs.);Nordic Walking machen
-trapsen;trampeln;geräuschvoll gehen;stapfen;tapsen
-Aha-Erlebnis;schlagartige Erkenntnis;Ahaerlebnis;plötzliche Eingebung
-(sich) verzetteln;vom Hundertsten ins Tausendste kommen;abschweifen;unüberlegt drauflosreden;von Punkt zu Punkt springen;vom Hölzchen aufs Stöckchen kommen (ugs.);den Überblick verlieren;(sich) in Details verlieren;nicht bei der Sache bleiben;nicht auf den Punkt kommen;vom (eigentlichen) Thema abkommen;(zu) sehr in die Einzelheiten gehen;den Faden verlieren (fig.)
-widerwillig anfassen;mit spitzen Fingern anfassen;(nur) mit der Kneifzange anfassen
-auf sich beruhen lassen;nicht weiterverfolgen;(es) belassen bei;(es) bewenden lassen (mit);(einer Sache) nicht weiter nachgehen;(darauf) verzichten (zu)
-(sich) verzetteln;(jemand) sieht vor lauter Bäumen den Wald nicht (mehr);nicht zum Wesentlichen kommen;(sich) nicht aufs Wesentliche konzentrieren;(sich) verlieren (in);(jemandem) fehlt der Blick aufs Ganze;(seine) Zeit verplempern mit;(sich) mit Nebensächlichkeiten aufhalten
-(sich) versteigen;nicht den Abstieg finden
-(sich) verfliegen;(sich) verfranzen (Jargon)
-Lesgier;Küriner (veraltet);Lesginen
-Rügegericht;Ruggericht
-(sich) in die Hose pinkeln;(sich) in die Hose machen (ugs., Hauptform);(sich) einnässen (fachspr.)
-in erweitertem Verständnis;weiter gefasst;in weiterem Sinne
-(an etwas) dran sein (ugs.);(sich) kümmern;(sich) umtun;aktiv sein;(sich) befassen (mit);(et)was tun (ugs.);aktiv werden (in einer Angelegenheit);arbeiten (an);nicht untätig sein;befasst sein (mit) (Verwaltungsdeutsch)
-Prozentzahl (ugs.);Prozentanteil;Prozentsatz;Quote
-herumfragen;Erkundigungen einziehen;(sich) schlaumachen (ugs.);Informationen einholen;nachhorchen;(die) Ohren offen halten (ugs.);herumhorchen (ugs.);ausloten (fig.);(sich) umhören;abklopfen (fig.);sondieren (fig.)
-Paarformel (fachspr.);Binomial (fachspr.);Zwillingsformel (fachspr.)
-allein gelassen;seinem Schicksal überlassen;im Stich gelassen;verraten und verkauft
-Kost und Logis;Verpflegung und Unterkunft;Verpflegung und Unterbringung
-um Himmels willen (ugs.);um alles in der Welt (ugs.);zum Teufel (ugs.)
-keine Ruhe geben;quengeln (ugs., Hauptform);janken;herumquengeln (ugs.);(rum)quaken (ugs.);herumjanken;(rum)knöttern (ugs., ruhrdt.)
-bei allem, was jemandem heilig ist;beim Leben seiner Mutter (ugs.);hoch und heilig (ugs.)
-(alle) Höhen und Tiefen;gute und schlechte Zeiten;(durch) dick und dünn (ugs.)
-für kein Geld (in) der Welt;nicht um alles in der Welt;um keinen Preis der Welt;nicht für Geld und gute Worte (ugs.);durchaus nicht (geh.);ums Verrecken nicht (derb);unter (gar) keinen Umständen;partout nicht (geh., franz.);auf keinen Fall;um nichts in der Welt;für nichts in der Welt
-in sich;für sich allein;(schon) (allein) für sich genommen
-ohne (jede) Vegetation;nicht bewachsen;kein Baum kein Strauch;(es gibt) weder Baum noch Busch;vegetationslos;kahl
-am Hungertuch nagen (ugs.);(bei jemandem) ist nichts zu holen;von Luft und Liebe leben;nichts zu beißen haben;keine Arbeit haben;nichts verdienen;kein Geld haben;mittellos dastehen;mittellos sein
-über mehrere Tage;über Tage (starke Betonung auf 'Tage');über mehrere Tage hinweg;tagelang;mehrere Tage hindurch
-wochenlang;über Wochen;mehrere Wochen hindurch;über (mehrere) Wochen
-mehrere Monate (hindurch);über mehrere Monate;Monate hindurch;über Monate (hinweg);monatelang
-über Jahrzehnte;mehrere Jahrzehnte lang;mehrere Jahrzehnte;jahrzehntelang;über mehrere Jahrzehnte;mehrere Jahrzehnte hindurch
-Nacht für Nacht;nächtelang;mehrere Nächte hindurch;über mehrere Nächte
-mehrere Stunden;über Stunden;viele Stunden lang;Stunden hindurch;einige Stunden;stundenlang
-um Leib und Leben fürchten (müssen);mit seinem Leben spielen (fig.);(sein) Leben riskieren;Leib und Leben riskieren
-(sich) küssen und kosen;(sich) liebkosen;Zärtlichkeiten austauschen;(sich) herzen
-(ein) Land und die Menschen, die dort leben;Land und Leute;(ein) Land und seine Bewohner
-Urkölsch (Dialekt);tiefes Kölsch
-kein Land sehen;so schnell nicht fertig werden;an kein Ende kommen
-(bis dahin) fließt noch viel Wasser den Rhein hinunter (sprichwörtlich, variabel);(das) kann sich (noch) hinziehen;(das) kann dauern
-(sich) zum Guten wenden (variabel);Was lange währt, wird endlich gut. (Sprichwort);(ein) gutes Ende nehmen;gut ausgehen;(ein) gutes Ende finden;gut werden (es)
-von einem Augenblick zum anderen;von einer Sekunde zur anderen;Knall auf Fall;von einem Moment auf den andren;von einem Moment zum anderen;von jetzt auf gleich;von heute auf morgen;von einem Augenblick auf den anderen
-auf Zuruf;ohne es vorher geübt zu haben;ohne Probe;ad hoc (geh., lat.);aus dem Stegreif;aus der Lamäng (ugs.);aus dem Handgelenk (ugs.);ex tempore (geh.);aus dem Stand (Hauptform);ungeprobt;ohne Vorbereitung;improvisiert;unvorbereitet;aus dem hohlen Bauch heraus (ugs.)
-Knall auf Fall;wie jemand ging und stand;vom Fleck weg
-summa summarum (lat.);in einem Betrag;unterm Strich (ugs., fig.);total (schweiz.);insgesamt;in einer Summe;alles zusammengerechnet;in Summe;zusammen;alles zusammen (Geld)
-beim geringsten Anlass;wegen Kleinigkeiten;wegen nichts;aus nichtigem Anlass
-(sich) fortbewegen;von A nach B kommen
-unter hohem Zeitdruck;fieberhaft;mit Hochdruck
-im Schnelldurchgang;unter Hochdruck;im Eilverfahren;im Schnellverfahren
-(es) bewenden lassen (bei);es gut sein lassen;nicht weitermachen;genug geschafft (haben)
-(sich) nicht anstrengen müssen (für);(jemandem) keinen Schweiß auf die Stirn treiben;nicht mal Luft holen (müssen) (für)
-(jetzt aber) ran an die Buletten! (ugs.);(nur) keine falsche Bescheidenheit! (ugs.);immer ran! (ugs.);nur zu! (ugs.);greif(t) zu! (ugs.)
-Fünf-Prozent-Klausel;Fünf-Prozent-Hürde
-ablatschen (ugs.);abgehen;langgehen (ugs., regional);ablaufen;entlanggehen
-suchen (nach);stöbern (nach + Ortsangabe);fahnden (nach);forschen (nach / zu)
-von Tür zu Tür gehen;hausieren (gehen) (mit);Klinken putzen (ugs., fig.)
-Türverkauf;Haustürverkauf
-Teilacher (fachspr., Jargon, historisch);Türverkäufer;Haustürverkäufer;Klinkenputzer;Hausierer
-Straßenhändler;Straßenverkäufer;Propagandist
-Ärztepropagandist;Ärzteberater;Pharmaberater;Ärztebesucher (schweiz.);Pharmareferent (Hauptform)
-geplanter Verschleiß;geplante Obsoleszenz;(absichtlich eingebaute) Sollbruchstelle (ugs.);eingebaute Schwachstelle
-in Unehren;mit Schimpf und Schande;unehrenhaft
-nicht wanken und weichen;nicht wanken noch weichen;weder wanken noch weichen;nicht aufgeben;nicht zurückweichen
-vor der Morgendämmerung;sehr früh am Morgen;vor Tau und Tag (poetisch, veraltet);vor Sonnenaufgang
-Füsillade (veraltet);Erschießung
-Vormittag;erste Tageshälfte;Vormittagsstunden;Zeit bis zum Mittag;bis zur Mittagspause
-Morgennebel;Frühnebel
-Vormittagsveranstaltung;Matinee (franz.)
-vormittäglicher Umtrunk;Sektfrühstück;Frühschoppen
-Wecker;Weckuhr
-Kaltmangel;Wäscherolle
-Bügelmaschine;Walzbügler;Heißmangel
-Morgentoilette (geh.);sich (für den Tag) fertig machen (ugs.);morgendliches Sichtzurechtmachen
-unter die Dusche gehen;(sich) duschen;(ein) Duschbad nehmen;unter die Dusche springen;duschen
-(das) Frühstück einnehmen;(seinen) Morgenkaffee trinken;frühstücken;(einen) Kaffee zum Frühstück trinken;Kaffee trinken;(ein) Frühstück essen;dejeunieren (geh., franz., veraltet)
-Morgenblatt;Morgenzeitung
-Morgennachrichten;Frühstücksnachrichten
-Frühstücksfernsehen;Morgenmagazin
-wenn du (unbedingt) meinst ...;wenn Sie meinen;na dann ... (ugs.);wenn Sie (unbedingt) darauf bestehen;(das ist) deine Entscheidung! (ugs.);na denn ... (ugs.);wie auch immer ...;warum auch nicht;das musst du selbst wissen (ugs.);wenn du das sagst ... (ugs.);ach wirklich? (ugs.);(...) aber bitte!;Gott ja (ugs.)
-wollte ich auch g(e)rade sagen (ugs.);genau was ich sage;(das) hab ich (doch) immer schon gesagt;sag ich doch (ugs.);mein Reden! (ugs.);(genau) meine Rede;sag ich's doch;hab ich's nicht gesagt?
-Tunte (meist abwertend) (derb);Tucke (derb)
-Hosenhebe (veraltet);Hosenträger
-Crossdresser;Dragqueen (engl.);Ladyboy;Drag Queen (engl.);Transe (ugs.);Transvestit;Transi (ugs.)
-Kaltmamsell;kalte Mamsell
-elektiver Mutismus;selektiver Mutismus
-Umsetzungsstärke;Umsetzungskompetenz
-Willenskraft;Willensstärke
-Normalgewicht;Idealgewicht
-Handeln wider besseres Wissen;Unbeherrschtheit;Akrasia;Willensschwäche
-Servierkraft am Büfett;Büfettiere (frz. Aussprache);Buffetière;Buffetdame (weibl.);Bedienung am Buffet;Bedienung am Büfett;Büfettdame
-Arbeitsgruppe;Gruppe;Mannschaft;Arbeitsbrigade (DDR, historisch);Brigade (DDR, historisch);Kolonne (ugs.);Gewerk;Team (engl., Hauptform)
-Putzbrigade;Putzlappengeschwader (scherzhaft);Putzkolonne;Putztruppe (ugs.)
-leg los;nur zu;na los;fang an;mach schon;lass gehen
-ordentlich angezogen;in sauberer Kleidung;tipptopp;proper;korrekt angezogen;adrett
-glänzen wie eine Speckschwarte;auf Hochglanz poliert (sein)
-Kostümierung;Ausstattung;Outfit;Aufmachung;Staat;Ausstaffierung;Aufzug;Putz (geh., veraltet);Gewandung (geh.)
-Ausnahmegenehmigung;Sondergenehmigung;Ausnahmeregelung
-Auslandstourist;ausländischer Besucher;ausländischer Gast
-keine Arbeitserlaubnis;Arbeitsverbot
-Asylberechtigter;anerkannter Flüchtling;anerkannter Asylbewerber
-Auffanglager;Camp (engl.);Lager (ugs.);Flüchtlingslager;Vertriebenenlager;Notaufnahmelager;Flüchtlingscamp;Sammellager
-Asyl (veraltet);Sammelunterkunft;Wohnheim
-Klimaflüchtling;Umweltflüchtling
-Etagenbett;Stockbett
-Enthüllung (geh.);Apokalypse;Entschleierung (geh.);Offenbarung (fachspr.)
-volkswirtschaftlicher Indikator;makroökonomische Kennzahl;Konjunkturindikator
-Umsatzrendite;Umsatzrentabilität
-Kampflesbe;Butch;kesser Vater
-Vollweib;üppige Schönheit;Prachtweib
-dummes Huhn (Schimpfwort) (ugs.);Trulla (leicht abwertend) (ugs., veraltend);Krähe (Schimpfwort) (ugs.);Tuse (ugs., abwertend);Trutsche (Schimpfwort) (ugs.);Schnepfe (Schimpfwort) (ugs.);dumme Pute (Schimpfwort) (ugs.);blöde Kuh (Schimpfwort) (ugs., variabel);Trutschn (ugs., süddt.);(blödes) Weibsstück (ugs., abwertend);(dumme) Ziege (ugs., abwertend, variabel);dumme Gans (ugs.)
-Zufallsgenerator;Zufallszahlengenerator
-Lago di Bonzo (Spottname);Tegernsee
-Proteinaufreinigung;Proteinreinigung
-Transatlantikkabel;transatlantisches Telefonkabel
-zuflüstern;(jemandem etwas) einblasen;soufflieren (fig.);vorblasen;(jemandem etwas) vorsagen
-hölzeln (österr.);(mit der Zunge) anstoßen;lispeln;zuzeln (österr.)
-säuseln;schmeicheln;flirten;flöten;turteln
-(jemandem) schmeicheln (Hauptform);Süßholz raspeln (fig.);nette Dinge sagen;schöntun;(jemandem) das sagen, was er hören will;(jemanden) einseifen;(jemandem) Nettigkeiten sagen;Komplimente machen;(jemanden) bauchpinseln
-(einer Frau) nachsteigen;fensterln
-bespitzeln;beschatten;hinter jemandem her sein;(jemandem) nachstellen;verfolgen
-mit Hochdruck arbeiten (an);nichts unversucht lassen;alle Hebel in Bewegung setzen (fig.);alles tun (dafür dass);alles aufbieten, um (zu);weder Mühe noch Kosten scheuen;sein Möglichstes tun;alles versuchen;alles unternehmen;Himmel und Hölle in Bewegung setzen (fig.);keine Kosten und Mühen scheuen;weder Kosten noch Mühen scheuen;(sich) mächtig ins Zeug legen
-Rinderheilkunde;Buiatrik
-Tokologie;Geburtshilfe;Obstetrik
-(es) geht menschlich miteinander zu;(es) menschelt
-Engelsgeduld;viel Geduld
-streichen;streifen;säuseln;dahinsäuseln;sanft wehen;fächeln;leicht wehen;streicheln (fig.)
-Wind von vorn;Gegenwind;Luftwiderstand
-Wind von hinten;Rückenwind
-Alp-Öhi;Alpöhi;Almöhi;Alm-Öhi
-hergezogen;zugezogen
-weggezogen;fortgezogen
-Stützen der Gesellschaft;bessere Gesellschaft;Juste Milieu (geh., franz.)
-etabliert;bourgeois;großbürgerlich
-Bürgertum;Bourgeoisie;(obere) Mittelschicht
-nützliches Mitglied der Gesellschaft;(eine) Stütze der Gesellschaft
-Kleinbürgertum;(unterer) Mittelstand
-Großbourgeoisie;Oberschicht;besitzende Klasse
-(die) sehr Reichen;(die) Superreichen;(die) Oligarchen (Russland) (ugs., Jargon)
-alles Mögliche;allerlei;viel(es);Verschiedenes;(so) manches;nicht wenig;einiges (pronominal) (Hauptform);Diverses;so einiges (ugs.);etliches;alles und nichts (ugs.)
-Leidensgenosse;Leidensgefährte
-Konsens (sein);unbestritten (sein);(darin) übereinstimmen;unstrittig (sein);(allgemein) akzeptiert (sein);(es) herrscht Einigkeit;übereinkommen;(sich) (darin) einig (sein)
-negatives Stimmgewicht;inverser Erfolgswert
-in der Eile;in der Aufregung;in all dem Durcheinander;im Eifer des Gefechts;in der Hitze des Gefechts (fig.)
-scharf;hitzig;verbissen;vehement;erbittert;massiv;hart;heftig
-nicht zögern (zu);keine Bedenken haben (zu);nichts dabei finden (zu);nicht anstehen (zu) (geh.);nichts dagegen haben (zu);(sich) nicht stören an
-uralt;archaisch;urtümlich;aus Urzeiten (stammend)
-Röhm-Putsch (D);Nacht der langen Messer
-das Um und Auf;(das) Wichtigste;(das) Entscheidende;(das) Wesentliche;(die) Hauptsache;das A und O;das Alpha und das Omega;Dreh- und Angelpunkt
-nachtrauern;nachweinen;(jemandem / einer Sache) hinterhertrauern;(sich) (wehmütigen Gedanken) hingeben;(jemandem) nachhängen
-unbeschädigt;unversehrt;wohlbehalten;heil und gesund (ankommen);gesund (und munter);unlädiert
-Liedtradition;Liedgut;(tradierter) Liedbestand
-Ruhrgebietsdeutsch (Hauptform);Kumpelsprache;Sprache des Ruhrgebiets;Ruhrdeutsch;Ruhrpott
-Ostoberdeutsch;Bairisch
-kleine Leute;einfache Leute;Leute wie du und ich;(der) kleine Mann (fig.);Menschen wie du und ich;(der) Mann von der Straße (fig.);die einfachen Leute;die kleinen Leute
-(die) Privatsender;werbefinanziertes Fernsehen;Privatfernsehen
-öffentlich-rechtliches Fernsehen;gebührenfinanziertes Fernsehen
-privater Fernsehsender;kommerzieller Fernsehsender;Privatsender
-Schandmaul (ugs.);Lästerer;Lästerzunge (ugs.);böse Zunge (ugs.);Stänkerer (ugs.);Lästermaul (ugs.)
-irgendein dahergelaufener (ugs., abwertend);irgendein;egal wer (ugs.);(der) erstbeste;irgendein beliebiger;irgend so'n (ugs., salopp);so ein dahergelaufener (ugs., abwertend);irgend so ein (ugs.);ein beliebiger;(der) erste der kommt;irgendwer;sonst wer (ugs., abwertend);jeder der will;ein x-beliebiger
-fällig;zahlbar
-Leistungszeitpunkt;Verzugsbeginn
-Befestigungselement;Befestigungsmittel
-Quotenverfahren mit Restausgleich nach größten Bruchteilen;Hamilton-Verfahren;Hare-Niemeyer-Verfahren;Hare'sches Verfahren (österr.)
-(etwas) von innen gesehen haben (ugs.);(irgendwo) drin gewesen sein (ugs.)
-Grundsatz der Verhältnismäßigkeit;Verhältnismäßigkeitsprinzip
-Insulinde;Niederländisch-Indien;Niederländisch-Ostindien
-Arbeiterviertel;Arbeiterbezirk;Arbeitervorstadt
-wählen (ugs.);sein (aktives) Wahlrecht ausüben (fachspr., Amtsdeutsch);zur Wahl gehen;(seine) Stimme abgeben;(sich) an der Wahl beteiligen;wählen gehen;an der Wahl teilnehmen
-Urwahl;Direktwahl
-Stechen;Stichwahl
-ungültig wählen;ungültig stimmen;eine ungültige Stimme abgeben
-Studierendenparlament;Studentenparlament
-allgemeiner Studierendenausschuss;AStA;allgemeiner Studentenausschuss
-hauchdünner Wahlsieg;Wahlkrimi (ugs.);denkbar knapper Wahlsieg;Kopf-an-Kopf-Rennen (fig.)
-Marschinsel;Hallig
-(eingedeichtes) Marschland;Koog;Polder (ostfries.);Groden (oldenburg., östl. ostfries.)
-Neulandgewinnung;Landgewinnung
-einer geregelten Arbeit nachgehen;für sich (selbst) aufkommen;von seiner Hände Arbeit leben;arbeiten (gehen);seinen Lebensunterhalt (selbst) verdienen
-von Luft und Liebe leben (ugs.);keiner geregelten Arbeit nachgehen;in den Tag hinein leben
-mit allem brechen;aussteigen;(ein) neues Leben anfangen;alle Brücken hinter sich abbrechen;(sich) abnabeln;alles hinter sich lassen;mit seiner Vergangenheit brechen
-Mensch mit ausschweifendem Lebenswandel;Libertin (franz.);Anhänger sexueller Freizügigkeit;Libertin de mœurs (franz.)
-von Haus(e) aus;eigentlich;von der Familie her;der Herkunft nach;vom Herkommen;ursprünglich;seinem Ursprung nach
-Greifvogelschau;Greifvogel-Flugschau;Freiflugvorführung
-Afterraife;Analraife;Cercus;Afterfühler;Raife
-Knöck (fränk.);Pferdekuss;Boandl (bayr.);Schenkerl (österr.);Eisbein;Eisenbahner (österr.);Schenkler;Tschekapuff (österr.);Hirsch
-bischöflich;episkopal (kirchenlateinisch)
-hinsichtlich des Textes;textlich;den Text betreffend;textuell
-plattformunabhängig;portabel;plattformübergreifend
-(tägliche) Arbeitsleistung;(tägliche) Arbeit;Tagewerk;Pensum;Arbeitspensum
-Lebensstellung;Dauerstellung
-Festanstellung;unbefristete Beschäftigung;unbefristetes Beschäftigungsverhältnis;unbefristetes Arbeitsverhältnis
-leben (von);Geld verdienen;Einkommen erwirtschaften;Einkommen erzielen;(seine) Brötchen verdienen (ugs., fig.);(seinen) Lebensunterhalt verdienen;Einkünfte erzielen
-gut verdienen (Hauptform);Geld verdienen;gutbezahlt;richtig Kohle machen (ugs.);viel verdienen;gut bezahlt werden (ugs.);(ordentlich / ganz schön) absahnen (ugs.);(ein) Schweinegeld verdienen (ugs.);gutes Geld verdienen;fürstlich bezahlt werden;gut dotiert (Stelle);(richtig / ordentlich) Geld machen (mit) (ugs., variabel);ganz ordentlich verdienen (ugs.);(sehr) ordentlich bezahlt werden;(ein) ansehnliches Gehalt beziehen;(sehr) gut bezahlt werden
-viel erreichen (im Leben);(im Leben) weiterkommen (ugs., fig.);Erfolg haben;(etwas) erreichen;zu etwas kommen (ugs.);es zu etwas bringen;viel aus sich machen;oben ankommen;es weit bringen;seinen Weg machen;es (bis) irgendwohin schaffen (fig.);(etwas) aus sich machen (ugs.);weit kommen (fig.)
-(sich) eine Stelle teilen;Jobsharing (machen) (engl.)
-bekleiden (Amt);tätig sein (als);amtieren (als);arbeiten (als);wirken (als);versehen (Dienst);ausüben (Funktion);innehaben (Position, Funktion)
-(das) sagt jemandem was (Name, Wort) (ugs.);(jemandem) einfallen;etwas klingelt (bei jemandem) (ugs., fig.);kommen auf
-auf einen Sprung (ugs.);kurz;auf einen Kaffee (ugs.);auf die Schnelle (ugs.);mal eben kurz
-Bijoutier (schweiz.);Juwelier
-Einsatz (österr.);Flaschenpfand;Depot (schweiz.)
-Cyberangriff;Cyberattacke
-Billig...;niveaulos;ohne geistigen Nährwert;ohne Niveau;anspruchslos;einfachster Machart;ohne Anspruch;auf Wühltischniveau;für den Massengeschmack;Massenware (fig.)
-Lavalampe;Blubberlampe (ugs.)
-Paramilitär;Miliz;Landjägerei (historisch);Gendarmerie (franz.)
-Belbaum;Madjobaum;Bengalische Quitte;Schleimapfel
-Zielgerade;Endspurt;(die) letzten Meter
-Livesendung;Direktsendung;Live-Übertragung;Sendung direkt aus (...);Live-Sendung;Übertragung direkt von (...);Direktübertragung
-hängig (jur., schweiz.);anhängig (Verfahren) (jur.);schwebend (Verfahren) (juristisch);in der Schwebe;pendent (schweiz. jur.);noch nicht entschieden
-(noch) nicht rechtskräftig;(noch) nicht letztinstanzlich bestätigt
-zusammenraffen;an sich reißen;an sich bringen;in seinen Besitz bringen;(sich) unter den Nagel reißen;anhäufen (Besitztümer);zusammenscharren
-Wärmebildung;Thermogenese
-Muskelsteifheit;Muskelstarre;Rigor (fachspr.)
-oberes Motoneuron;erstes Motoneuron
-unteres Motoneuron;zweites Motoneuron
-kontraintuitiv (geh.);entgegen der Intuition
-proportional;in dem gleichen Verhältnis;im gleichen Verhältnis;gleichlaufend;verhältnisgleich
-im Verhältnis zu;dafür (ugs.);verglichen mit;in Relation zu;neben;im Vergleich zu;dagegen (ugs.);gemessen an
-gleich gerichtet;in die gleiche Richtung gehend;gleichlaufend;gleichgerichtet
-einvernehmlich;konsensual;in gegenseitigem Einvernehmen;übereinstimmend;im Konsens;in gegenseitigem Einverständnis
-im gleichen Atemzug (ugs.);gleich anschließend;in einem Atemzug (ugs.);fast gleichzeitig (sagen, behaupten);praktisch im selben Moment;im selben Atemzug (ugs.)
-Zufall;Fügung des Schicksals;Zufälligkeit
-(eine) Gnade;glücklicher Umstand;(jemand) hätte es nicht besser treffen können;(eine) wundersame Fügung;(ein) Gottesgeschenk (fig.);glückliche Umstände;(ein) unverdientes Glück;Glücksfall;Geschenk des Himmels (ugs., fig.);glücklicher Zufall;günstige Umstände;glückliche Fügung;(ein) Glück;(etwas) hätte nicht besser sein können;Segen;(etwas) hätte nicht besser laufen können (variabel);Fügung des Schicksals;Güte des Schicksals;(ein) Geschenk der Götter (fig.)
-Unheil;Geißel;Fluch;Unglück;Unsegen;Verhängnis (Hauptform);Unstern
-(in der) Tinte (sitzen);Schwulität (meist Plur.: in Schwulitäten);Bedrängnis (geh.);Misslichkeit;Schwierigkeit;verzwickte Situation;schwierige Situation;(in der) Patsche;Verlegenheit;Verdrückung (ugs., regional);Bredouille (ugs., franz.);Not;Notlage;Klemme (ugs.);missliche Situation;Schwulibus (ugs., selten)
-festgefahren (Verhandlungen) (fig.);an einem toten Punkt (Verhandlungen);blockiert
-verzweifelte Lage;Sackgasse;Aussichtslosigkeit;Hoffnungslosigkeit;ausweglose Situation;Teufelskreis;Ausweglosigkeit
-unglückliches Zusammentreffen;dummer Zufall (ugs.);unglückliche Umstände;Zusammentreffen (mehrerer) ungünstiger Umstände;Unglücksfall;ungünstige Umstände;unglücklicher Zufall;Unglück;fatales Zusammentreffen;verhängnisvoller Zufall;unseliges Aufeinandertreffen;unglücklich
-schlechte Voraussetzungen haben;unter schlechten Zeichen stehen;unter schlechten Bedingungen starten;(sich) nicht gut anlassen;kein gutes Zeichen sein (ugs.);unter keinem guten Stern stehen
-seinen eigenen Weg gehen;mit allen Konventionen brechen
-Dachbodenausbau (österr.);Dachgeschossausbau
-gutes Zeichen;Hoffnungszeichen;Wink des Schicksals;Wink des Himmels
-mit dem linken Fuß zuerst aufgestanden (sein);mit dem linken Bein zuerst aufgestanden (sein);(es ist) nicht mein Tag (heute) (ugs.);mit links aufgestanden (sein);(einen) schlechten Tag haben
-Tratschtante;wandelnde Bildzeitung;Klatschbase (veraltet);Klatschtante;Dorfratschn (bayr.)
-Kabarett-Chanson;Kabarettsong;Spottlied;Couplet
-Popsong;Song
-bestplatziert;beliebtest;meistverkauft
-volkstümliches Musikstück;Schlager;Lied (vereinfachend)
-Chanson;Lied (mit literarischem Anspruch);Liedermacher-Song
-Klassik (vereinfachend);E-Musik;klassische Musik (Hauptform);ernste Musik;Kunstmusik
-aushungern;verhungern lassen
-mehr als ein Eisen im Feuer haben (ugs., fig.);mehr als einen Pfeil im Köcher haben (ugs., fig.)
-Gehölzsammlung;dendrologische Sammlung (fachspr.);Arboretum
-Sammlung von (seltenen) Sträuchern;Strauchanpflanzung;Fruticetum (fachspr.)
-Nadelgehölzsammlung;Nadelgehölzpflanzung;Nadelgehölzanpflanzung;Pinetum
-Gartenarbeit machen;im Garten arbeiten;gärteln (regional);gärtnern
-Vibraphon;Vibrafon
-Marimbaphon;Marimba
-Haltepedal;Fortepedal;Dämpferpedal
-Sammelpedal;Harmoniepedal
-Bindepedal;Legatopedal;synkopiertes Pedal
-Verschiebung;Pianopedal;Leisepedal
-Intonation;Intonierung
-Partialton;Teilton;Oberton
-Grundfrequenz;Grundschwingung;Grundton
-Umbildung (personell);Kabinettsumbildung;Revirement (geh., bildungssprachlich, franz.);Umbesetzung(en) (auf Führungsebene);Regierungsumbildung;Sesselrücken (fig., schweiz., österr.);Stühlerücken (fig.)
-Karpaten;Karpathen (veraltet)
-Rezidivität (fachspr.);Rückfälligkeit;Rückfallwahrscheinlichkeit
-After-Work-Party;After-Business-Club (ABC)
-alles einsacken (ugs., salopp);abräumen (ugs., fig., Hauptform);(sich) alles holen (ugs.);alle Punkte holen (Sport) (ugs.);leerräumen (Konto) (ugs., fig.)
-(sich) eine saftige Klatsche abholen (ugs., salopp);krachend scheitern;(eine) vernichtende Niederlage kassieren
-Tritt in den Arsch (derb, fig.);Ohrfeige (fig.);Arschtritt (derb, fig.);Klatsche (fig.)
-zueinander finden;zusammenkommen;(sich) arrangieren;(sich) zusammenraufen
-Zweckbündnis;keine Liebesheirat (sein) (fig.)
-Vernunftehe;Zweckehe
-ach kuck! (ugs., ironisierend);ach was! (ugs., ironisch);stell dir vor! (ugs.);(jetzt) mach keine Sachen! (ugs., ironisch);soso (ugs.);(nein) wirklich?;du meine Güte! (ugs., veraltend);nein sowas! (ugs.);(ach) tatsächlich?;was du nicht sagst! (ugs., ironisierend);sowas aber auch! (ugs., ironisierend);du ahnst es nicht! (ugs.);was Sie nicht sagen! (ugs., ironisierend);ist das wahr?;sag bloß! (ugs., ironisierend);(ja) allerhand (ugs., ironisierend)
-Ablaufsteuerung;Schrittkette
-(der) Mann am Klavier;Paul Kuhn
-Klavier spielen;in die Tasten hauen (ugs.);in die Tasten greifen
-Tastenprügler (ironisch);Klimperer;schlechter Klavierspieler;Tastenquäler
-Salonpianist;Barpianist
-zum Endspurt ansetzen;in die Zielgerade kommen;in die Zielgerade gehen
-Fraktionschef;Fraktionsvorsitzender;Fraktionspräsident (schweiz.);Klubobmann (österr.)
-(sich) entgegenkommen;Kompromisse machen;(sich) in der Mitte treffen (fig.);aufeinander zugehen (fig.)
-über den Sender gehen (ugs., Jargon);über die Bildschirme flimmern;laufen (ugs.);gezeigt werden;gesendet werden;über die Leinwand flimmern (Großbildwand);kommen (ugs.);ausgestrahlt werden
-letzte Hoffnung;Strohhalm (fig.)
-Hoffnung schöpfen;seine Chance für gekommen halten;Morgenluft wittern (fig.);(die) Zeit gekommen sehen
-im Feuer stehen (fig.);in die Kritik geraten;im Kreuzfeuer der Kritik stehen;unter Beschuss genommen werden (fig.);von allen Seiten angegriffen werden;ins Kreuzfeuer der Kritik geraten (sein);am Pranger stehen (fig.);heftig kritisiert werden;es hagelt Kritik;in der Kritik stehen;(sich) der Kritik ausgesetzt sehen (variabel);unter Beschuss stehen (fig.);unter Dauerfeuer stehen;kritisiert werden
-(jemandes) Nachfolger sein;(die / jemandes) Nachfolge antreten (Hauptform);(jemanden) beerben (als) (fig.);(jemandem) im Amt folgen;(jemandem) nachfolgen;(jemandes) Erbe antreten (fig.)
-mit Widrigkeiten zu kämpfen haben;auf Widerstand stoßen;Wind von vorne bekommen (fig.);(jemandem) bläst der Wind ins Gesicht (fig.);Proteste auslösen;auf Widerstand treffen
-zur Tagesordnung übergehen;(wieder) zum Alltag zurückkehren;(es gibt) (wieder) business as usual (engl.);(es) kehrt wieder Normalität ein;(es) geht (wieder) seinen gewohnten Gang
-Fehler;Makel;Knacks;Beeinträchtigung;Sprung;Riss;Läsur;Beschädigung;Defekt;Schaden
-Flop (ugs.);Fehlinvestition
-wieder eingebracht werden;(sich) amortisieren (geh., Hauptform);wieder eingefahren werden (Investitionskosten);wieder reinkommen (ugs.);(sich) rechnen (ugs.);wieder hereingeholt werden;wieder hereinkommen;wieder eingespielt werden
-(die) Kosten decken;(sich) tragen;kostendeckend arbeiten;kostendeckend (sein)
-Sondierung;Sondieren
-Lake;Marinade;Beize
-marinieren;einlegen;beizen
-eingelegt;mariniert
-Bestechlichkeit;Käuflichkeit;Verführbarkeit;Korruptheit;Korrumpierbarkeit
-ein gutes Stück;weit
-Inhaber eines hohen Amtes;Würdenträger
-hoher Kirchenmann;Kirchenführer
-ich so: (...) (ugs., jugendsprachlich);(und) ich hab (dann) gesagt (...) (ugs.)
-Verehrteste (ironisch);Schätzchen (Anrede, leicht herablassend) (ugs.);Sweetie (Anrede) (ugs., salopp);(meine) Gnädigste (Anrede);Mädels (Anrede) (ugs.);Sie da (ugs.);Frollein (ugs., salopp);Kleine (Anrede, auch herablassend) (ugs.);Frolleinchen (familiär) (ugs., veraltend);gnädige Frau (Anrede) (förmlich, veraltet);gute Frau (ugs.);junge Frau (Anrede) (Hauptform);Baby (Anrede) (ugs., salopp);gnä' Frau (veraltet);Fräulein (ugs., veraltet)
-Wiederholung (Musik);Reprise (Musik) (fachspr., franz.)
-Monsterkrabbe;Königskrabbe;Kamtschatkakrabbe
-mit fliegenden Fahnen überlaufen;(sich) unerwartet auf die andere Seite schlagen;plötzlich seine Ansicht(en) ändern;kurzentschlossen das Lager wechseln
-langes Gestell (ugs.);Hopfenstange (ugs., fig.);Bohnenstange (ugs., fig.);Heugeige (ugs., fig., österr.);(ein) (ganz) Langer (ugs.);langer Lulatsch (ugs.);(und) dann kam eine lange Dürre (ugs., Spruch, scherzhaft);langes Elend (ugs., ironisch);(eine) (ganz) Lange (ugs.);langes Gereck (ugs., regional)
-mit Gardemaß;hoch gewachsen;(anderen) auf den Kopf spucken können (ugs.);baumlang;groß;stattlich;(ein) Riese;(ein) Turm (fig.);von Gardemaß;von hohem Wuchs (geh., altertümelnd);hochgewachsen;lang (ugs.)
-nicht (so) leicht zu beeindrucken;über den Dingen stehen;abgeklärt (sein);erhaben sein (über);cool (sein) (ugs.);drüber stehen (ugs.);in sich ruhen (fig.);kann nichts (mehr) erschüttern;unter jemandes Würde (sein);Was juckt es die deutsche Eiche, wenn sich ein Wildschwein an ihr reibt. (Sprichwort, variabel)
-hart an der Grenze (ugs., Hauptform);geht noch (so) gerade (ugs.);an der Grenze des Erträglichen;grenzlastig (ugs.);noch soeben im Bereich des Zulässigen;kaum zu ertragen;grenzwertig (ugs.)
-Hartz-IV-Fernsehen (ugs.);Verblödungsfernsehen (derb, abwertend);Hartz-4-TV (ugs.);Berieselungsfernsehen (ugs., abwertend);Hartz-IV-TV (ugs.);Hartz-4-Fernsehen (ugs.)
-hartzen (gehen) (ugs., Jargon);Stütze kassieren (ugs.);vom Notstand leben (ugs., österr.);vom Amt leben (ugs., veraltet);Empfänger von Arbeitslosengeld II (sein) (Amtsdeutsch);Stütze kriegen (ugs., veraltet);kein (eigenes) Einkommen haben;Arbeitslosengeld II beziehen (Amtsdeutsch);stempeln gehen (ugs., veraltet);von (der) Stütze leben (ugs., veraltet);im Leistungsbezug von ALG 2 stehen (Amtsdeutsch)
-Dokusoap;Doku-Soap
-Scripted Reality (engl.);Pseudo-Doku;Script-Doku
-Wählergruppe;Wählergemeinschaft;Wählervereinigung;Bürgervereinigung
-Division mit Rest;Divisionsalgorithmus
-Transsilvanisches Becken;Siebenbürgisches Becken
-gibt Rätsel auf (fig.);nicht klar zuzuordnen;rätselhaft;nicht zu bestimmen;unbestimmbar;unbestimmt;undefinierbar;uneindeutig;nicht einzuordnen
-(jegliche) Festlegung(en) vermeiden;(sich) alle Türen offen halten (fig.);keine vorschnelle Entscheidung treffen;(sich) nicht festlegen
-wieder gesund;gesundet;geheilt entlassen;(weilt) wieder unter den Lebenden (ugs., ironisch);wieder auferstanden von den Toten (ugs., Zitat, biblisch, sarkastisch);geheilt;genesen
-(jemanden) in ein Gespräch verwickeln;(jemandem) (ein) Gespräch aufzwängen;(ein) Gespräch vom Zaun brechen
-Unsinn verzapfen (ugs.);rumspacken (ugs.);herumspacken (ugs.);Blödsinn verzapfen (ugs.)
-Verstoß gegen die guten Sitten;Störung der öffentlichen Ordnung;Belästigung der Allgemeinheit (juristisch);grober Unfug (juristisch, veraltet)
-außen vor lassen;nicht (weiter) eingehen auf;beiseite lassen
-(geistig) abwesend (fig.);in Gedanken woanders;unachtsam;unaufmerksam;unkonzentriert;nicht bei der Sache
-wenig Zeit haben;(jemandem) unter den Nägeln brennen (ugs., fig.);mir pressiert's (sehr) (ugs., regional);(es) pressiert (ugs., süddt.);es eilig haben (Hauptform);(sehr) knapp dran sein (ugs.);(jemandem) auf den Nägeln brennen (ugs., fig.);eilig (sein) (ugs.);(sich) beeilen müssen;(sich) sputen müssen (ugs.);(sehr) in Eile (sein)
-um sich schlagen (auch figurativ);in der Wahl seiner Mittel nicht zimperlich sein;nach allen Seiten austeilen
-nur noch gewinnen können;nichts (mehr) zu verlieren haben
-sprunghaft;flatterhaft;unbeständig;flippig (ugs.);unstet
-nervlich;nervös
-nervlich;nerval (fachspr.);neural (fachspr., griechisch, lat.);mit den Nerven;neurologisch (med.) (fachspr.)
-(eine) Frage der nervlichen Belastbarkeit;(eine) Frage der psychischen Konstitution;reine Nervensache
-nichtsinguläre Matrix;invertierbare Matrix;reguläre Matrix
-Floriani-Prinzip (österr.);Sankt-Florian-Politik;Sankt-Florian-Prinzip
-Lüftelmalerei;Lüftlmalerei
-beweglicher Funkdienst;Mobilfunkdienst
-beweglicher Flugfunkdienst über Satelliten (R);mobiler Flugfunkdienst über Satelliten (R)
-beweglicher Flugfunkdienst über Satelliten (OR);mobiler Flugfunkdienst über Satelliten (OR)
-mobiler Flugfunkdienst über Satelliten;beweglicher Flugfunkdienst über Satelliten
-Flugfunkdienst (OR);beweglicher Flugfunkdienst (OR) (veraltet);mobiler Flugfunkdienst (OR)
-Das haben wir schon immer so gemacht. (ugs., Spruch);der Tradition entsprechend;nach alter Schule;auf altbewährte Weise;nach alter Väter Sitte;wie eh und je
-Kontakt aufnehmen;zugehen auf (fig.);(jemanden) ansprechen;zukommen (auf)
-(den) Stein ins Rollen bringen (fig.);Auslöser war (...);(etwas) in Bewegung bringen (fig.);(den) Anstoß geben;in Gang setzen;auslösen;(eine) Lawine lostreten (fig.)
-(das) Getümmel;(das) pralle Leben;(das) Hin und Her;des Lebens bunte Fülle (poetisch);(das) Getriebe;(das) Treiben;(das) Geschehen
-Juniorpartner;(der) kleinere Koalitionspartner
-Glacé;Glacee
-Labanzen;Labantzen
-(wieder) bei null anfangen (fig.);ganz von vorn anfangen;ganz unten anfangen;(wieder) am Anfang stehen;mit nichts anfangen
-Konstantinisches Kreuz;Chi-Rho;Christusmonogramm;Christogramm (veraltet)
-Kohleverflüssigung;Kohlehydrierung
-Weltformel;Theorie von Allem
-Kinegram;Kinegramm
-Fresnel-Zonenplatte;Kinoform;Zonenlinse
-Holographie;Holografie
-für (reichlich) Gesprächsstoff sorgen(d) (ugs.);Aufsehen erregen(d);reich an Skandalen;von Skandalen geprägt;skandalumwittert
-nichts dem Zufall überlassen;(sich) (in alle Richtungen) absichern;auf Nummer sicher gehen;kein Risiko eingehen;nichts riskieren;hedgen (fachspr.)
-vertändeln (Zeit);Zeit vergeuden;(sich) die Zeit vertreiben;vertrödeln (Zeit);Zeit totschlagen (ugs.);Zeit verschwenden;Zeit verbrennen;vertun (seine Zeit)
-Bukowinadeutsche;Buchenlanddeutsche
-Avantcorps;Risalit;Avant-corps
-Arrierecorps;Rücklage
-Oberösterreichisches Hügelland;Hausruckviertler Berg- und Hügelland
-Koronaentladung;Büschelentladung
-Strommast (ugs.);Freileitungsmast
-Goubau-Leitung;G-Leitung;Goubot-Leitung
-Thomas-Gilchrist-Verfahren;Thomas-Verfahren;basisches Windfrischverfahren
-LD-Verfahren;Linz-Donawitz-Verfahren
-Puddelverfahren;Flammofenfrischen
-Chemische Waffe;Chemiewaffe;C-Waffe
-Nesselstoff;Rotkreuz
-Verzögerungszeit;Latenzzeit;Latenz;Verweilzeit;Reaktionszeit
-angenehm warm;wohlig warm;kuschelig (warm);mollig;wohlig;mollig warm;lecker warm (ugs., rheinisch);muckelig (ugs., regional)
-Südatlantische Explosion;Vela-Zwischenfall
-Küstenerosion;Abrasion
-Lauffeldröhre;Wanderfeldröhre
-Forschungsrakete;Höhenrakete;Höhenforschungsrakete
-(mal) austreten müssen (ugs.);(kurz mal) wo hinmüssen (ugs., verhüllend);(mal) auf die Toilette (gehen) müssen;(mal) für kleine Mädchen (gehen) müssen (ugs., fig.);Harndrang haben (fachspr., medizinisch);(kurz mal) verschwinden müssen (ugs., verhüllend)
-ansprechend;angenehm;einladend;willkommen;gefällig;nett
-gutmütig;gütig;guter Mensch;menschlich;mit Herz;herzensgut;gut;(eine) Seele von Mensch;mitfühlend
-Grizzlybär;Grislibär (alte Schreibung bis 2017);Grizzly
-ins Boot holen (fig.);(jemanden) gewinnen für;(jemanden) dabei haben wollen;einbinden;(jemanden) beteiligen;kooperieren mit
-blutige Auseinandersetzung;(...) bei dem Blut fließt;(...) bei der Blut fließt;Bluttat
-im Nu;in kurzer Frist;schnell;kurzfristig;in kurzer Zeit;kurzzeitig;innert Kürze (schweiz., österr.);zügig
-vivace;vivo;presto;allegro ma non troppo;allegro
-Messerstecherei (abwertend);Stecherei;Messerkampf;tätlicher Angriff mit (einem) Messer
-(irgendwo) nicht hingehören;(irgendwo) nicht hergehören;(irgendwo) nichts verloren haben (ugs.);(irgendwo) nichts zu suchen haben
-(sein) Coming-out haben;(sein) Comingout haben;(sich) zum ersten Mal öffentlich bekennen zu
-Erbe;Überrest;Relikt;Überbleibsel (Hauptform)
-(sich) dumm und dämlich suchen;(sich) (einen) Wolf suchen;(sich) (einen) Ast suchen;(sich) totsuchen;endlos suchen
-(ein) irres Geld (ugs.);Kohle ohne Ende (ugs.);Schweinegeld (ugs.);Geld wie Heu (ugs.);irre viel Geld (ugs.)
-blau gefroren sein;sehr frieren;durchgefroren sein;unterkühlt sein;(sich) (den) Arsch abfrieren (derb);zum Eiszapfen werden (ugs., fig.)
-frösteln;mit den Zähnen klappern;frieren;(jemandem) kalt werden;vor Kälte zittern;frieren wie ein Schneider (ugs.);(jemandem) kalt sein;bibbern (ugs.);schuckern (ugs., regional);(vor Kälte) schlottern;schnattern (ugs.);(eine) Gänsehaut bekommen
-langsam näherkommen;(sich) heranschieben;(sich) langsam nähern;(sich) nach vorne schieben
-viele Freunde haben;(gut) vernetzt (sein)
-die Hupe betätigen;hupen
-Lautstärkesteller;Lautstärkeregler
-Wehwehchen (ugs.);Zipperlein (ugs.);(kleiner) Schmerz
-Puffmutter;Bordellchefin
-(den) Plan einhalten;im Plan liegen;(den) Zeitplan einhalten;gut in der Zeit liegen;im Plan sein;(voll) im Zeitplan liegen
-im Budgetrahmen bleiben;(den) Budgetrahmen einhalten
-Gebäudeensemble (Hauptform);Gesamtanlage;Ensemble;aufeinander bezogene Bebauung
-zweisam;zu zweit
-Kalotte (franz., ital., lat.);Kugelhaube;Kugelkappe;Kugelabschnitt;Kugelkalotte;Kugelsegment
-Villenviertel;Villenkolonie;vornehme Gegend;bessere Gegend (ugs.)
-Wohnanlage;Siedlung;Kolonie
-Zechenkolonie;Zechenhaussiedlung;Zechenhauskolonie;Kolonie;Zechensiedlung
-Wohnbebauung;Wohnhäuser
-MFH (Abkürzung);Mehrfamilienhaus;Mehrfamilienwohnhaus
-Wohnhaus;Wohngebäude
-Araberdorf (Jargon, abwertend);Weißenhofsiedlung
-Architekturausstellung;Bauausstellung
-Großstadt;Regiopole
-wieder aufholen;(es) herausreißen (ugs., fig.);verlorenes Terrain wieder gutmachen (fig.)
-das geht auf meinen Deckel (ugs.);(jemandem) (ein) Getränk spendieren;(jemanden) freihalten;(eine) Runde ausgeben;das geht auf mich (ugs.);(einen) ausgegeben bekommen;(eine) Runde schmeißen (ugs.);(etwas) spendieren (Hauptform);einen ausgeben (ugs.);aufs Haus gehen;frei saufen haben (derb);(die) Zeche zahlen (für jemanden);(die) Runde geht auf (...)
-sämtlichen ethischen Grundsätzen Hohn sprechen;(der) Gipfel des Zynismus;an Zynismus nicht zu überbieten sein
-unübertrefflich;nicht zu toppen;nicht zu überbieten;alles in den Schatten stellen (fig.);unüberbietbar;unübertreffbar;unschlagbar
-(bei jemandem) Geld lockermachen;(jemandem) Geld aus der Tasche ziehen
-größter Bühnenerfolg (Rolle);Glanzrolle;Paraderolle (auch figurativ);wie geschaffen für (Rolle);größter Kinoerfolg (Rolle);(jemandem) auf den Leib geschrieben
-(sich) wieder fangen (ugs.);wieder auf die Beine kommen (ugs., fig.);wieder Tritt fassen;(sich) wieder hochrappeln;wieder auf die Füße kommen (ugs., fig.)
-also sowas! (ugs.);also echt! (entrüstet) (ugs.);Leute gibt's! (ugs.);Musste das sein? (ugs.);also hör mal! (ugs.);och Mensch! (ugs.);Wie kann man nur! (ugs.);also nein! (ugs.);Muss das sein? (ugs.);also wirklich! (entrüstet) (ugs., Hauptform);also ... (Vorname)! (ugs.);War das (wirklich) nötig?;nein wirklich! (entrüstet) (ugs.)
-kein Wunder (dass ...) (ugs.);das hab(e) ich (ja) kommen sehen (ugs.);Hab ich's doch gewusst! (ugs.);Ich wusste es. (ugs.);Ich hab's gewusst. (ugs.);Ich wusste, dass es so kommen würde. (ugs.);ich hab(e) es ja gleich gesagt (ugs.);Das war mir (von vornherein) klar.;Wem sagst du das! (ugs.);(Das) hab ich mir doch gleich gedacht! (ugs.);Also doch! (ugs.);Das war ja (von vornherein) klar (...) (ugs.);Das musste ja so kommen.;Hab ich's nicht gleich gesagt? (ugs.);Hab ich's mir doch gedacht! (ugs.);Als wenn ich es geahnt hätte (...) (ugs.);Wusst' ich's doch! (ugs.)
-(so) einigermaßen (ugs.);mäßig (geh., Hauptform);einigermaßen (ugs.);mäßig bis saumäßig (ugs., sarkastisch);den Umständen entsprechend;durchschnittlich;mittelmäßig;nicht so toll (ugs.);nicht besonders (ugs.);na ja (ugs.);medioker (geh., bildungssprachlich);nicht (so) berauschend (ugs.);nicht so prickelnd (ugs., fig., variabel);geht so (ugs.);mittelprächtig (ugs.);(sich) in Grenzen halten;(ziemlich) bescheiden;nicht (so) berühmt (ugs.);durchwachsen;so lala (ugs.);(es ist) nicht weit her (mit);passabel;nicht so dolle (ugs.)
-Aufruhr;Volkszorn;allgemeine Empörung
-(sich) fremd fühlen;fremdeln;unsicher sein (in fremder Umgebung);(sich) nicht zugehörig fühlen
-Biologische Waffe;Biowaffe;B-Waffe
-blutbrechendes Fieber (veraltet);hämorrhagisches Fieber
-Missfallenskundgebung;Protest;Buh-Ruf;Gebuhe;Zuschauerprotest;Verächtlichmachung;abfällige Bemerkung;Buhruf
-zur Verfügung stellen;an die Hand geben;mit auf den Weg geben
-Bomber der Nation;Gerd Müller (Eigenname, Hauptform);kleines, dickes Müller
-Dauerleerzeichen (fachspr., Jargon, selten);nicht-trennbares Leerzeichen;geschütztes Leerzeichen
-Bildungswissenschaft;Edukologie
-Reide;Räute;Reite
-anreichern;hinzuerfinden;ausschmücken (beim Erzählen);ausgestalten
-(dem) Affen Zucker geben;(es) (sich) (zu) einfach machen;in dieselbe Kerbe hauen
-(ein) Vorurteil bedienen;(sich) mit Stereotypien zufriedengeben;(einem) Vorurteil Vorschub leisten
-übertriebene Darstellung;Überzeichnung;Overacting
-korpulenter aussehen lassen;dicker erscheinen lassen;auftragen (Kleidungsstück);dicker aussehen in
-so lange tragen bis es auseinanderfällt;auftragen (Kleidungsstück)
-abgetragen;reif für die Altkleidersammlung;fadenscheinig;verschlissen;oll (ugs.);zerschlissen;abgenutzt
-blank (Stoff);blankgescheuert;abgewetzt;verspeckt;speckig
-(sich mit etwas) anfreunden;(mit jemandem/etwas) warm werden
-multivariates Verfahren;multivariate Analysemethode
-Tragfähigkeitsindex;Lastindex;Traglastzahl
-congenitale Hypothyreose (fachspr.);angeborene Hypothyreose;connatale Hypothyreose (fachspr.)
-Thyreoidea-stimulierendes Hormon;thyreotropes Hormon (fachspr.);Thyreotropin
-Gammakamera;Anger-Kamera;Szintigraph (fachspr.)
-Diagnostikgerät;diagnostisches Gerät
-Schilddrüsenkarzinom;Schilddrüsenkrebs;Struma maligna (fachspr., lat.)
-Radiopharmazeutikum;Radiopharmakon
-heißer Knoten;fokale Autonomie;autonomes Adenom;Morbus Plummer
-richten (süddt.);(einen) Schaden beseitigen;(wieder) heil(e) machen (ugs.);(eine) Reparatur durchführen;(wieder) in Stand setzen;reparieren (Hauptform);(wieder) hinbekommen (ugs.);(eine) Reparatur vornehmen;(wieder) in Gang bringen;(wieder) herrichten;(wieder) zum Laufen bringen;(einen) Schaden beheben;(einen) Mangel beseitigen;(wieder) in einen gebrauchsfähigen Zustand versetzen;(wieder) hinkriegen (ugs.);(wieder) ganz machen (ugs.);(wieder) instand setzen;(einen) Mangel beheben
-in Vertretung;für den Übergang;kommissarisch;stellvertretend
-(irgendwie) auf die Reihe kriegen (ugs.);(es) (irgendwie) hinkriegen (ugs.);(irgendwie) zurande kommen (ugs.);(sich) durchlavieren (ugs.);(irgendwie) zurechtkommen;(sich) behelfen;(irgendwie) geregelt kriegen (ugs.);(irgendwie) auf die Reihe bekommen (ugs.);(irgendwie) zu Rande kommen (ugs.);(sich) (irgendwie) durchwurschteln (ugs.);improvisieren
-Hoheitsgewässer;territoriale Gewässer;Territorialgewässer
-Betula nana (fachspr., botanisch);Zwerg-Birke;Polar-Birke
-krankenhausreif prügeln;fertig machen (ugs.);(jemandem) die Fresse polieren (derb);zusammenhauen;krankenhausreif schlagen;Kleinholz machen aus (ugs., fig.);zu Mus machen (fig.);zusammenschlagen (Hauptform);alle machen (ugs.)
-(sich) (gegenseitig) verdreschen;(sich) kloppen (ugs.);(sich) (eine) Schlägerei liefern;(sich) (gegenseitig) verkloppen (ugs.);(sich) prügeln wie die Kesselflicker (ugs.);(sich) (gegenseitig) verhauen;(sich) schlagen;(sich) prügeln;(sich) (gegenseitig) verbleuen
-(einer Sache / jemandem) zu Leibe rücken (fig.);zu Felde ziehen (gegen) (fig.);Maßnahmen ergreifen (gegen);angehen (gegen);bekämpfen;vorgehen (gegen);(etwas) eindämmen
-Saalschlacht;Wirtshausprügelei;Bierzeltschlägerei;Wirtshausschlägerei;Kneipenschlägerei;Kneipenprügelei;Saalschlägerei
-(jemandem) (einen) Schlag (ins Gesicht) geben;(jemandem) aufs Maul hauen (ugs.);(jemandem) eins auf die Zwölf geben (ugs.);zuschlagen;(die) Fresse einschlagen (derb);(jemandem) (einen) Schlag (ins Gesicht) versetzen;(jemandem) einen auf die Zwölf verpassen (ugs.);(jemandem) eine reinhauen (ugs.);(jemandem) ins Gesicht schlagen;(die) Zähne einschlagen (ugs.);(jemandem) (einen) Kinnhaken verpassen;(jemandem) die Fresse polieren (derb)
-gelangweilt;ohne Begeisterung;freudlos;unengagiert;ohne sich anzustrengen;lustlos (Hauptform);wurschtig (ugs.);ohne Engagement;ohne Freude dabei;nicht mit ganzem Herzen dabei;nicht mit dem Herzen dabei;ohne sich Mühe zu geben;wurstig (ugs.);ohne Einsatz;lieblos
-(echtes) Engagement erkennen lassen;(echtes) Engagement zeigen;(sich) (richtig) Mühe geben (Hauptform);(sich) anstrengen;(sich) voll einbringen;sein Bestes geben;Einsatz zeigen;mit ganzem Herzen dabei sein;(sich) (richtig) reinhängen;(sich) voll reinhängen
-Zerwürfnis;Riss (fig.);Brouillerie (geh., franz., veraltet);(offener) Bruch (fig.)
-(miteinander) kämpfen;(sich) kampeln;(sich) rangeln;(sich) katzbalgen (ugs.);(miteinander) raufen;ringen;ein Kämpfchen machen (ugs.);gegeneinander kämpfen;(sich) balgen;(sich) kabbeln;herumbalgen
-(einen) Klaps geben;(jemandem) eins hintendrauf geben;(einen) Klaps auf den Po geben
-zustopfen;dicht machen;zumachen;abdichten;(eine) Leckage beseitigen;verschließen;(ein) Loch stopfen
-Augendeckel (veraltet);Schauleder (veraltet);Blendklappen;Blinkers;Scheuklappen;Scheuleder;Augenklappen (veraltet)
-Mussheirat;Muss-Heirat
-Zwangsverheiratung;Zwangsehe;Zwangsheirat;Zwangs-Verheiratung
-(dann ist) alles aus;(dann) gehen die Lichter aus (ugs., fig.);(dann) gute Nacht, Marie (ugs.);(na) (dann) prost Mahlzeit!;(das ist) das Ende;dann war's das (ugs.);(dann ist) Matthäi am Letzten (ugs.);(dann) gute Nacht, Deutschland (ugs.)
-(das) Ende der (zivilisierten) Welt;(der) Untergang des Abendlandes
-Architektenleuchte (handelssprachl.);Architektenlampe;Federzuglampe;Federzugleuchte (kaufmannssprachl.)
-Traumschloss;Feenpalast;Luxusresort;Wolkenkuckucksheim;Märchenschloss
-zu erwarten;schicklich;zum guten Ton gehören(d);schuldig (geh.);gebührend;geboten;geziemend
-gerechtfertigt;berechtigt;verantwortbar;legitim;vertretbar
-Möbelbezug;Überzug;Überwurf;Husse
-Kantendetektion;Kantenextraktion
-Neutroneneinfang;Neutronenanlagerung
-unterseeisches Erdbeben;Seebeben
-Erdbebenschwarm;Schwarmbeben
-Spanischamerika;Hispanoamerika;(das) spanischsprachige Amerika
-Hispanistik;Iberoromanistik
-Französistik;Franzistik;Frankoromanistik;Franko-Romanistik;französische Philologie
-Privatkunde;Endverbraucher;Endkunde
-wie zu Hause;wie bei Muttern (ugs.)
-(ist ja hier) nicht wie bei armen Leuten (ugs., Spruch);wir ham's ja (ugs., Spruch);Geld spielt (hier) keine Rolle. (Spruch)
-Pizzabäckerei;Pizzeria;Pizzabude (ugs.)
-Refektorium (Kloster);Speisezimmer;Esszimmer;Speisesaal;Messe (Schiff);Essraum
-Hochklassik;französische Klassik
-unausgeglichen;...lastig;nicht ausbalanciert;unausgewogen;nicht im Verhältnis;unproportional (viel);unverhältnismäßig (viel);nicht im (richtigen) Verhältnis stehen (variabel);in Schieflage (fig.);(zu) ...betont;nicht in der (richtigen) Proportion;(mit / es gibt) zu viel (...);nicht in Balance;(mit / es gibt) zu wenig (...)
-Tendenz;Schlagseite (haben) (fig.)
-Massenprügelei;Massenschlägerei
-(über)deutlich zu sehen sein;(jemandem) im Gesicht geschrieben stehen;nicht zu übersehen sein;(jemandem) deutlich anzusehen sein;(etwas) nicht verbergen können (variabel);Spuren hinterlassen haben (bei) (fig.);nicht zu verkennen sein;gezeichnet sein (von) (geh.)
-Meereskämpfer (veraltet);Froschmann (veraltet);Kampfschwimmer
-Marinebasis;Marinestützpunkt
-Fliegerhorst;Militärflugplatz
-bei Sonnenaufgang;in der Morgendämmerung;bei Tagesanbruch;im Morgengrauen
-sehr früh;in der Früh(e);am frühen Morgen;(schon) in der ersten Frühe (geh., literarisch, variabel, veraltend);früh am Tag;(sehr) früh am Morgen;frühmorgens;(noch) keine acht;zu früher Stunde (geh., literarisch, veraltend);(noch) keine acht Uhr
-Jordanischer Bürgerkrieg;Schwarzer September
-(den) Zenit überschritten haben (fig.);im Niedergang befindlich;rückläufig (sein);(sein) Stern ist am Sinken (fig., variabel);im Sinkflug (sein) (fig.);(sich) auf dem absteigenden Ast befinden (fig.);im Niedergang begriffen
-(das) Ende ist abzusehen;irgendwann ist Schluss (ugs.);(das) Ende der Fahnenstange erreichen (fig.)
-Verstärkerladung;Initialzünder;Booster;Detonator
-Zündmittel;Anzündmittel
-on the fly (engl., fig.);ohne Prozessunterbrechung (fachspr.);in voller Fahrt;im laufenden Betrieb
-Überraschung! (ugs.);damit hast du (wohl) nicht gerechnet!? (ugs.);surprise, surprise! (engl.);damit habt ihr (wohl) nicht gerechnet!? (ugs.)
-ich glaub' mich tritt ein Pferd! (ugs., Spruch);ich glaub' mein Hamster bohnert! (ugs., Spruch);ich glaub' mich knutscht ein Elch! (ugs., Spruch);ich glaub' mein Schwein pfeift! (ugs., Spruch);ich glaub' mein Trecker humpelt! (ugs., Spruch);ich glaub' mein Muli priemt! (ugs., Spruch)
-ich glaube es hackt! (ugs.);ich glaub' es geht los! (ugs.)
-Romano-Ward-Syndrom;Pseudohypokaliämie-Syndrom
-querschnittgelähmt;querschnittsgelähmt
-XY-Tisch;Kreuztisch
-Elektrolog;Induktionslog
-Bogensekunde;Winkelsekunde
-Angst vor der Angst;Phobophobie
-Antipanzerrakete;Panzerabwehrlenkwaffe;Antipanzerlenkwaffe
-Seitenschürze;Panzerschürze
-Spannungsdurchschlag;elektrischer Durchschlag
-Atomkraftmikroskop;Rasterkraftmikroskop
-Spitzenübermikroskop;Feldelektronenmikroskop;Feldemissionsmikroskop
-Buchholzschutz;Buchholz-Relais
-Austrittsarbeit;Auslösearbeit;Ablösearbeit
-man steckt nicht drin (ugs., Spruch);schwer zu sagen (ugs.)
-Notleidender;Bedürftiger;Hilfsbedürftiger
-zur Diskussion stellen;auf die Agenda setzen;auf die Tagesordnung setzen
-löffeln;mit einem Löffel essen
-auf seine Kappe nehmen können;(etwas) für vertretbar halten;verantworten können;vertretbar (sein);zu verantworten (sein);vertreten können;auf sich nehmen können;geradestehen können (für);verantwortbar (sein)
-Bogenvieleck;Bogenpolygon
-im Sekundentakt (fig.);kurz hintereinander (ugs.);in schneller Abfolge;in schneller Folge;minütlich;im Minutentakt (fig.);Schlag auf Schlag;in rascher Folge
-auf stur schalten;auf seinem Standpunkt beharren;hartnäckig bei seiner Meinung bleiben;auf nichts eingehen;sich stur stellen
-sprich;als da wären;und zwar (die folgenden);nämlich (die folgenden);im Einzelnen;als da sind
-Leib- und Magen-... (ugs.);Lieblings...
-größte Herausforderung;Königsdisziplin
-Warnschreiben;dringende (briefliche) Warnung;Brandbrief
-Philippika (geh.);Brandrede;flammende Anklage;dramatische Warnung
-Gartentraum;Traumgarten;Traum von einem Garten
-Blütenzauber;Blütenteppich;Blütenfest;Blütenpracht;Blütenfülle;Blütenrausch;Blütenmeer;Blütenparadies;Blütenfeuerwerk;Blütenreichtum
-launig;blumig;ungefähr;vage;wolkig;unpräzise;unverbindlich
-als Titel präsentieren;(den) Aufmacher haben;(die) (heutige) Schlagzeile lautet;titeln
-Aufmacher;Nachricht in großer Aufmachung;Meldung des Tages;die (!) Meldung (schlechthin) (ugs.);Sensationsmeldung;wichtigste Meldung
-(jemandem) verbunden;(jemandem) verpflichtet;(jemandem) erkenntlich;Dank schulden;zu danken haben;zu Dank verpflichtet
-großflächiger Schaden;großer Schaden;Flurschaden
-Flurschaden (fig.);Schaden mit Breitenwirkung
-Firmenstandort;Firmensitz;Unternehmensstandort;Standort;Betriebsstandort;Unternehmenssitz;Sitz
-aufe Faust (ugs., ruhrdt.);für unterwegs;auf die Hand;zum Mitnehmen;to go (neodt.)
-(absolute) Rarität;ungewöhnlich;exotisch;(sehr) speziell;ausgefallen
-(jemanden) vor vollendete Tatsachen stellen;nicht länger warten (wollen) (ugs.);(vollendete) Tatsachen schaffen;Fakten schaffen
-(sich) abkoppeln;(sich) verselbständigen;(ein) Eigenleben entwickeln
-permanente Alarmbereitschaft;(ständige) Alarmstimmung;Alarmismus;(künstliche) Aufgeregtheit
-verlängern (Soße, Suppe);ergiebiger machen;strecken (Gericht);vermehren;mehr Menge gewinnen
-verwässern (auch figurativ);versetzen mit;verdünnen
-zusammenpantschen;verpantschen;verpanschen;untermischen;pantschen;verschneiden;vermischen (mit);versetzen mit;panschen;zusammenpanschen;zusammenschütten
-Schadensbegrenzung (betreiben);retten, was zu retten ist;nachträglicher Reparaturversuch
-in Alarmbereitschaft versetzen;in Unruhe versetzen;(jemanden) beunruhigen;alarmieren (fig.);für Unruhe sorgen (bei);in Alarmstimmung versetzen;turbieren (veraltet)
-(etwas) wahren;betreiben;(sich) (einer Sache) befleißigen (geh.);an den Tag legen;praktizieren;(sich) üben in
-(die) Einschläge kommen näher (Spruch, fig.);(die) Situation wird (immer) bedrohlicher
-denken an;(jemandem) vorschweben;im Sinn haben;(sich) vorstellen
-durch (ugs.);kann nichts mehr davon hören (ugs.);nichts mehr drin (ugs.);nichts mehr herauszuholen (ugs.);ausgelutscht (ugs., fig.);überstrapaziert (fig.);(hinlänglich) durchgekaut (ugs., fig.)
-Investigativreporter;Enthüllungsjournalist
-prämiert;preisgekrönt;ausgezeichnet
-(mit Orden) ausgezeichnet;dekoriert;(die) Brust gepflaster mit Orden;hochdekoriert;mit reichlich Lametta (auf der Heldenbrust) (ugs.);mit Orden und Ehrenzeichen versehen
-zurechtkommen (mit);handhaben;managen;bewerkstelligen;handeln (engl.)
-nachvollziehbar (Hauptform);nicht von der Hand zu weisen;überzeugend;leuchtet ein;(durchaus) plausibel;naheliegend (fig.);(da) passt eins zum anderen (ugs., fig.);logisch
-GPS-Schatzsuche;Geocaching;GPS-Schnitzeljagd
-Desinvestition;Devestition
-Sachinvestition;Realinvestition
-Sideman;Gastmusiker
-Solist (reguläres Bandmitglied);Frontfrau;Frontmann;Frontman (engl.)
-hau - ruck (Kommando);zu - gleich (Kommando);hol - über (Kommando)
-Taxi!;hallo, Taxi!;Fährmann, hol över!
-geistig unbeweglich;verkrustet;erstarrt;verknöchert
-Chanterelle;höchste Saite
-(jemanden) umdrehen (Spion o.ä.) (ugs.);(jemandem) eine Gehirnwäsche verpassen
-Kompaktlader;Bobcat (Marke) (engl.)
-interpretationsfähig;(eine) Frage der Interpretation;mehrdeutig;auslegungsfähig;mehrere Deutungen zulassend;Auslegungssache;interpretationsbedürftig;vielsinnig;missverständlich;interpretationsoffen (geh.);vieldeutig;uneindeutig;kann missverstanden werden
-saubere Folter;weiße Folter
-über Tage und Wochen;tage- und wochenlang
-in ganzen Büscheln;in Büscheln;büschelweise
-Zwangsprostitution;Sex-Sklaverei
-schlecht;im Keller (fig.);am Tiefpunkt;am Boden (Stimmung);ganz unten
-juris;der Rechtswissenschaft;iuris;jur.
-durch den Richter;durch einen Richter;richterlich;durch ein Gericht
-(die Leute) für dumm verkaufen;(den Leuten) (das) Gehirn vernebeln;(das) Volk verdummen
-Verblödung der Massen;Volksverdummung
-heute;heut (ugs.);heutig;heute stattfindend
-(wieder) ausbuddeln (ugs., fig.);(wieder) heraussuchen;(wieder) hervorholen;(wieder) ausgraben (ugs., fig.)
-reaktivieren;(wieder) zum Laufen bringen;(etwas) wieder anbekommen (ugs.);(wieder) in Gang setzen;(wieder) flottmachen;(ein Gerät o.ä.) (wieder) zum Leben erwecken (fig.);(einem Gerät o.ä.) (wieder) neues Leben einhauchen (fig.)
-angespannt;angeschlagen;gespannt;belastet (Beziehung, Verhältnis);beeinträchtigt;gestört
-allen möglichen Leuten zeigen;herumzeigen
-an seiner Seite (haben);(sich) sehen lassen (mit);in Begleitung von;(jemanden) herumzeigen
-(...) (alle) miteinander (Gruß);(...) allerseits (Gruß);(...) Leuts (ugs., salopp);(...) Leute (ugs.);(...) zusammen (Gruß);(...) in die Runde (Gruß)
-an alles gedacht (sein);Rundum-sorglos-Paket;alles inklusive;(sich) um nichts kümmern müssen;Komplettpaket;(sich) um nichts Gedanken machen müssen;all-inclusive (fachspr., Jargon, engl., werbesprachlich);für alles (ist) gesorgt
-Verfolgungsfahrt;wilde Jagd;Verfolgungsjagd
-was soll die Scheiße! (derb);du tickst wohl nicht richtig! (ugs.);du hast wohl nicht alle Tassen im Schrank! (ugs., fig.);hast du ein Rad ab!? (ugs., fig.);was fällt Ihnen ein! (ugs.);Ihnen geht's wohl zu gut! (ugs.);bist du jetzt völlig durchgedreht? (ugs.);was soll das! (ugs.);tickst du noch ganz sauber? (ugs.);Sie sind wohl nicht ganz bei Trost! (ugs.);du hat sie wohl nicht alle! (ugs.);bist du des Wahnsinns? (geh., altertümelnd, veraltet);aber sonst geht's dir gut (oder?) (ugs.);bist du noch ganz frisch (in der Birne)? (ugs.);geht's noch? (ugs.);dir geht's wohl zu gut! (ugs.);tickst du noch (richtig)? (ugs.);was fällt dir ein! (ugs.);du bist wohl nicht ganz bei Trost! (ugs.);bist du des Wahnsinns fette Beute? (ugs., Spruch, variabel, veraltend);was soll der Scheiß!? (derb)
-Jagdstück;Jagdszene
-außerhalb des Bahnhofs;mitten auf der Strecke;auf freier Strecke;mitten in der Pampa (ugs.);auf offener Strecke
-Moleküldynamik;Molekulardynamik
-ausgehen wie das Hornberger Schießen;groß angekündigt und dann (...) (ugs.)
-marktschreierisch (Hauptform);aufdringlich;reißerisch
-knallig (Hauptform);grell (Hauptform);unübersehbar;ins Auge stechen(d);schreiend (fig.);plakativ;(alle) Blicke auf sich ziehen;ins Auge fallen(d);aufdringlich (geh., fig.)
-verkaufsfördernd;schmissig;schlagkräftig;zugkräftig;werbewirksam
-Unsicherheit;Imponderabilien (geh.);Imponderabilität (geh.);Unsicherheitsfaktor;Unberechenbarkeit;Unwägbarkeit
-Tollkühnheit;Vabanquespiel;heller Wahnsinn
-es geschehen noch Zeichen und Wunder (ugs., sprichwörtlich);jetzt schlägt's dreizehn (ugs., Spruch);dass ich das noch erleben durfte (ugs., Spruch)
-Ruthenisch;Karpato-Russinisch
-Mauer des Schweigens;Schweigekartell
-wohl wissend (dass);(sich dessen) bewusst;im vollen Bewusstsein (dessen, dass)
-kleines Rädchen im Getriebe;kleines Licht
-Räderwerk;Maschinerie;Getriebe
-schwerer Schlag;(wie ein) Keulenschlag
-Brückenkopf (fig.);Vorposten (fig.)
-Gasbeton (veraltet);Porenbeton
-Kriegshetze;Kriegstreiberei
-Rudeltaktik;Wolfsrudeltaktik
-geistige Brandstiftung;Hetzerei;Hetze;Aufstachelung;Aufhetzung;Aufwiegelung
-Hetzkampagne;Kesseltreiben;Stimmungsmache;Scharfmacherei;Verleumdungskampagne
-(jemandem) gefriert das Blut in den Adern (fig.);(jemandem) gerinnt das Blut in den Adern (fig.);unheimlich werden (jemandem wird etwas ...);(jemanden) überläuft es (heiß und) kalt;(jemandem) (das) Blut in den Adern gefrieren lassen (geh., fig.);(jemandem) erstarrt das Blut in den Adern (geh.);(jemandem) stockt das Blut in den Adern (fig.);(jemandem) wird angst und bange;kalte Füße bekommen (ugs., fig.);mulmig zumute werden (jemandem wird ...);Angst bekommen;starr vor Angst (sein);(jemandem) läuft es eiskalt den Rücken hinunter (fig.);(eine) Gänsehaut bekommen;(es) mit der Angst zu tun bekommen;(das) kalte Grausen bekommen
-Untermensch (rassistisch) (derb, abwertend);Höhlenmensch (abwertend, fig.);Neandertaler (beleidigend) (abwertend, fig.)
-(der) Knitterfreie (ugs., sarkastisch);Stahlhelm;Hurratüte (ugs., Jargon);Gefechtshelm
-viel auf dem Kasten haben (ugs.);(schwer) was drauf haben (ugs.);Fähigkeiten haben;(eine Sache) beherrschen;das Zeug dazu haben (ugs.);(es) (einfach) draufhaben (ugs.);(etwas) auf dem Kasten haben (ugs.);was können (ugs.);im Griff haben (ugs.)
-Diarium (lat., veraltet);Tagebuch (Hauptform);Memoire (franz.)
-Abrasionsküste;Abbruchküste;Kliffküste
-Taxistand (ugs.);Taxenstand
-Laiendefibrillator (ugs.);Automatisierter Externer Defibrillator;Defi (ugs.)
-probabilistische Sicherheitsanalyse;probabilistische Risikoanalyse
-Wehrerker;Wurferker;Pechnase;Gusserker
-Morgengabe;Brautgeschenk
-Internetrecht;Onlinerecht
-voll abzuschreiben;nicht zu realisieren;faul (Kredit) (ugs., Jargon);nicht realisierbar;uneinbringlich (Forderung) (fachspr.);notleidend (fachspr., Jargon)
-Meistbegünstigungsprinzip;Meistbegünstigtenklausel
-herumspringen wie Rumpelstilzchen;im Dreieck springen (fig., Hauptform);im Sechseck springen (fig.);herumspringen wie ein HB-Männchen (fig., veraltend)
-Graphdatenbank;graphenorientierte Datenbank
-Tabelliermaschine;Buchungsmaschine
-Deutscher Indigo;Pastel;Färberwaid
-Gentlemen's Agreement (engl.);Kompromiss;Vereinbarung;Abmachung;Absprache;Übereinkunft;gegenseitiges Einvernehmen;Arrangement (bildungssprachlich, franz.);Agreement (engl.);Verabredung;Verständigung;Übereinkommen;Gentleman's Agreement (engl.);Modus Vivendi (bildungssprachlich)
-Frauenhurling;Camogie
-thermischer Solarkollektor;thermischer Sonnenkollektor
-nutzlos in der Gegend herumstehen;einsam dastehen;verloren in der Landschaft stehen
-Rotationsprinzip;Rotationsverfahren
-(sich) fremdschämen;(sehr) peinlich finden;(sich) für jemand anderen schämen;(sich) stellvertretend schämen (für)
-kühne These;gewagte These;steile These (ugs., variabel);gewagte Hypothese
-Party machen (ugs., Hauptform);(eine) Feier veranstalten;(viele) Leute einladen;feiern;auf eine Fete gehen;(ein) Fest geben;(eine) Fete machen
-Sause (ugs.);wilde Party;ausgelassene Feier
-durchmachen;nicht schlafen (gehen);durchfeiern;(die) Nacht zum Tage machen
-fröhliches Miteinander;geselliges Beisammensein
-Abendmusik;musikalische Soiree;Nachtmusik;musikalische Soirée;Serenade
-Bandbreiteneffizienz;spektrale Effizienz
-festlicher Anlass;feierlicher Anlass
-Bachelorparty (engl.);Junggesellenabschied (männl.);Junggesellinnenabschied (weibl.)
-morbider Charme;Reiz des Verfallenen
-Kollektivsymbol;Kampfbegriff;(politisches) Schlagwort;Reizvokabel
-(jemandem) nicht unangenehm sein;ganz normal sein (für) (ugs.);nichts dabei finden (ugs.);(jemandem) nicht peinlich sein;kein Problem haben (mit) (ugs.);(sich) nicht genieren;als wäre es die natürlichste Sache der Welt;nichts dabei sein (ugs.)
-(irgendwie / so) kommen;(sich) zeigen;(sich) herausstellen;sehen;(sich) finden (geh., veraltend);(sich) ergeben
-testamentarisch;letztwillig
-Gewaltmarsch (fig.);Tour de Force (fig., franz.);Parforceritt (fig.)
-Aufbietung aller Kräfte;übermenschliche Anstrengung
-Karies verursachend;kariogen (fachspr.)
-von Karies betroffen;kariös
-Weinverkostung;Weindegustation (fachspr.);Weinprobe
-auf Gegenseitigkeit beruhen;keine Einbahnstraße (sein) (fig., floskelhaft)
-weitermachen wollen;noch nicht in Rente gehen wollen;nicht ans Aufhören denken (journ. Floskel)
-verrenten;zwangsverrenten;in den Ruhestand schicken;aufs Altenteil schicken;in den Ruhestand versetzen;in (die) Rente schicken;aufs Altenteil abschieben;zum alten Eisen werfen
-mit (großer) Genugtuung erfüllen;(ein) innerer Vorbeimarsch (veraltend);(ein) innerer Reichsparteitag (veraltend);(eine) große Genugtuung
-keine Chance! (ugs.);unmöglich;(da ist) nichts zu machen (ugs.);nicht darzustellen (Jargon);nicht realisierbar;nicht zu realisieren;nicht machbar;nicht zu schaffen;nicht darstellbar (Jargon);nicht umzusetzen;undurchführbar;(ein) Ding der Unmöglichkeit;nicht zu machen (sein) (ugs., Hauptform)
-Partner (Hauptform);Lebenspartner;(der) Mann an ihrer Seite;Lebensabschnittsgefährte;Lebensgefährte;Freund
-alter Bekannter;Bekannter aus alten Tagen
-Jugendfreund;Sandkastenfreund
-Studienabbrecher;verkrachter Student (variabel);abgebrochener Student
-mitziehen;es genauso machen;(sich) anschließen (fig.);nachziehen (fig.);(sich) einreihen (fig.);(einem) Beispiel folgen;(sich) ein Beispiel nehmen an (ugs.);es ähnlich halten
-(sich) beteiligen;mitmachen;hinzukommen;(sich) anschließen;(sich) zugesellen;dazukommen;(sich) hinzugesellen;mitkommen;mitgehen
-sicher;stichhaltig;gesichert;sicher wie das Amen in der Kirche (ugs.);nachweislich (Adjektiv) (selten);belastbar (Jargon, fig.);handfest;hieb- und stichfest (fig., Hauptform);beweiskräftig (juristisch);wasserdicht (ugs., fig.)
-was Ernstes (ugs.);Partnerschaft;feste Beziehung;Bindung
-Lebenspartnerschaft;Lebensgemeinschaft
-Partnerin (Hauptform);Lebensabschnittsgefährtin;Ische (ugs., veraltend);feste Beziehung;Freundin;Beziehung;(die) Frau an seiner Seite;Alte (ugs., abwertend);Lebenspartnerin;Lebensgefährtin
-zusammensein (ugs.);liiert sein;wie Mann und Frau zusammenleben (geh.);zusammenleben;verbandelt sein (mit jemandem) (ugs.);ein Paar sein;ein Liebespaar sein (Hauptform);eine feste Beziehung haben;verpartnert sein;Tisch und Bett teilen (veraltend)
-in trauter Zweisamkeit;(ein) Tête-à-Tête (haben mit) (geh., franz., veraltet);nur wir zwei;entre nous (geh., franz., veraltet);nur du und ich;unter vier Augen;(wir sind da) ganz unter uns
-Elektrokonvulsionstherapie;Elektrokrampftherapie
-Golfkriegssyndrom;Balkan-Syndrom
-Kreuzbandriss;Kreuzbandruptur
-Band;Ligamentum
-überwinden;hinwegkommen über;verwinden;bewältigen;(gut) wegstecken (ugs.);verkraften;fertigwerden mit;überstehen;verschmerzen
-seinen Frieden machen mit;(sich) aussöhnen (mit);(sich) nicht länger auflehnen (gegen)
-hinnehmen;geschehen lassen (Hauptform);nicht eingreifen;dem freien Spiel der Kräfte überlassen;den Dingen ihren Lauf lassen
-Duldsamkeit;Leidensfähigkeit
-auch 'ne Möglichkeit (ugs.);oder so. (ugs.);(das ist) auch eine Möglichkeit;geht auch (so). (ugs.)
-Asternrevolution;Herbstrosenrevolution
-Noachidische Gebote;Noachitische Gebote;Noachische Gebote (veraltet)
-Nichtchrist;Ungetaufter
-Kind Gottes;(Person) christlichen Glaubens;in der Nachfolge Jesu Lebender;Christ;Anhänger des Christentums;Christenmensch
-Locus amoenus (lat.);lauschiges Plätzchen (ugs.);lieblicher Ort
-ergebnisorientiert;erfolgsabhängig
-(das) Herunterladen;(der) Download (engl.)
-(eine) Einzelmeinung (vertreten);auf einsamem Posten sein;(ein) einsamer Kämpfer (sein);auf verlorenem Posten stehen (mit) (fig.);keine Lobby haben (fig.);mit einer Meinung allein(e) dastehen;keine Unterstützung finden;allein auf weiter Flur dastehen (mit) (fig.);(nur) seine persönliche Meinung (verhüllend);nicht unterstützt werden;alleinstehen mit (fig.);keine Verbündeten haben;isoliert sein;allein(e) dastehen (mit) (fig.)
-Meinungsäußerung;Kommentar (Hauptform);Kommentierung;Stellungnahme;Bemerkung am Rande
-(jemandem) gut zu Gesicht stehen;(jemandem) gut tun (Konjunktiv);sollen (Konjunktiv);(jemandem) gut anstehen (Konjunktiv);gut sein (für) (Konjunktiv)
-fließender Übergang;Zwischenform;Zwischending (ugs.)
-ineinander verlaufen;nicht klar voneinander zu trennen sein;fließend ineinander übergehen;durch eine Reihe von Zwischenformen verbunden (sein)
-Kreissektor;Kreisausschnitt
-Sweatshop;Ausbeutungsbetrieb
-Schaukelpolitik (fig.);Zickzackkurs (fig.);unklare Haltung;Eiertanz (ugs.);Schlingerkurs (polit.);Hin und Her (fig.);nicht wissen, was man will (ugs.)
-durch die Medien gehen;groß berichtet werden;durch alle Medien gehen;durch die (ganze) Presse gehen;durch alle Zeitungen gehen (veraltend)
-lichtleitender Beton;transluzenter Beton;Lichtbeton
-viele Schlupflöcher (bieten);(es gibt) (zu) viele Ausnahmeregelungen;(es gibt) (zu) viele Ausnahmeregeln;viele Ausnahmen (haben);löchrig wie ein Schweizer Käse (sein) (ugs., fig.)
-(Geld) verbrennen;(Geld) zum Fenster hinauswerfen;verfrühstücken (ugs.);sinnlos verballern (ugs.);verbraten (ugs.);(Geld) versenken
-Geld vernichten (fig.);Geld verbrennen (fig.);Geld verlieren (fig.)
-Abfüllmenge;Packungsgröße;Gebinde
-strampeln (ugs.);pedalieren (ugs.);treten
-Falkengebirge;Braunauer Wände;Sterngebirge
-Malmignatte (veraltet);Mediterrane Schwarze Witwe;Europäische Schwarze Witwe
-Schwarze Witwe;Südliche Schwarze Witwe
-Kugelspinne;Haubennetzspinne
-in Rekordzeit;in kürzester Zeit
-zu schnell;übereilt;voreilig;übereilig;überhastet;vorschnell (Hauptform);zu früh;vor der Zeit
-nur mal eben kurz;flüchtig;im Vorbeigehen;im Vorübergehen;zwischen Tür und Angel (fig.);en passant;(nur) oberflächlich;mal kurz
-wie im Fluge;rasend schnell;im Nullkommanix (ugs.);im Schweinsgalopp (ugs.);in fliegender Eile;in affenartiger Geschwindigkeit (ugs.);in rasender Geschwindigkeit;sehr schnell;in Windeseile;rasant;wie der Wind;extrem schnell;blitzartig;in null Komma nichts (ugs.);wie ein Lauffeuer;im Nullkommanichts (ugs.);in höchster Eile;blitzschnell;wie ein geölter Blitz (ugs.);pfeilschnell
-ethnischer Konflikt;Konflikt zwischen Ethnien
-Waffenstillstandsvereinbarung;Waffenstillstand;Waffenstillstandsvereinbarungen;Waffenruhe
-Soldat auf Zeit;Zettie (ugs., Jargon);Zeitsoldat (ugs.)
-Endabrechnung;Schlussabrechnung;Schlussrechnung
-bestrickend;verzaubernd;unwiderstehlich;verführerisch;verlockend (Hauptform);betörend;berückend (geh.)
-unglücklich verliebt;hoffnungslos verliebt
-überdenken;in eine andere Richtung denken;neu durchdenken;eine neue Sichtweise entwickeln;neu ansetzen;(die Dinge) anders sehen;umdenken
-strafmündig;alt genug, um juristisch belangt werden zu können
-Liebeskummer;Herzeleid (veraltet);Liebespein;Liebesqual;Liebesnöte;Herzschmerz;Liebesschmerz;gebrochenes Herz;Liebesleid
-zurückgewiesene Liebe;abgewiesene Liebe;unerfüllbare Liebe;unerfüllte Liebe;einseitig (gebliebene) Verliebtheit
-Ehekrise;Beziehungsknatsch (ugs.);Beziehungskrise
-Beziehungsdrama;Ehetragödie
-Trennungsangst;Verlustangst
-Trupp Menschen;Völkchen (ugs.);Truppe (fig.);Leutchen (ugs.)
-noch eins draufsetzen;noch einen draufsatteln;(etwas) überbieten;dem Ganzen die Krone aufsetzen (ugs., fig.);noch weitergehen;noch einen draufsetzen;darüber hinausgehen;nachlegen;(etwas) toppen (ugs.);alles (noch) schlimmer machen (ugs.);noch hinzukommen (zu)
-Familiennachzug;Familienzusammenführung
-Windhundverfahren;Windhundprinzip
-Schamlippenkorrektur;Labioplastie;Schamlippenplastik;Labioplastik
-krank sein;kränkeln;leiden
-Drei-Schema-Architektur;Drei-Ebenen-Architektur;ANSI-SPARC-Architektur;Drei-Ebenen-Schema-Architektur
-Datenschema;Schema
-Wechselladebehälter (schweiz.);Wechselaufbau;Wechselpritsche;Wechselkoffer;Wechselbehälter;Wechselaufbaubrücke;Wechselbrücke
-Heptarchie;Siebenherrschaft
-Flugenveloppe;Flugbereichsgrenze
-Weckmann (hessisch, rheinisch, schwäbisch);Grittibänz (schweiz.);Stutenkerl (norddeutsch);Hefekerl (mittelfränkisch);Lebkuchenmann (ostdeutsch);Krampus (bayr., österr.);Klausenmann (oberschwäbisch);Dambedei (regional);Pfefferkuchenmann (ostdeutsch);Grättimann (regional, schweiz., selten);Stutenmann (regional);Weckenmännchen (regional)
-auf Männerfang gehen;sich was fürs Bett suchen (ugs.);auf die Balz gehen
-tanzen gehen;auf die Piste gehen (ugs.)
-Stagnation;Starre;Erstarrung;Bewegungslosigkeit;Stillstand
-westlicher Bauteil;westlicher Vorbau;Westwerk
-Gebäudeteil;Trakt;Teil eines Bauwerks
-Fenster;Fensterflügel
-in der Natur der Sache liegen;typisch sein;keine Seltenheit (sein);ins Bild passen;den bisherigen Erfahrungen entsprechen;wenig überraschend kommen;das ist (nun mal) so bei (ugs.);(den) Erwartungen entsprechen;nicht überraschen;nur natürlich sein (floskelhaft);kommen, wie es kommen muss (ugs.);(so) an sich haben (ugs.);nicht wundernehmen dass;wenig überraschen;(Das) ist einfach so. (ugs., Spruch);(ganz) normal (sein) (ugs., Hauptform);nicht anders zu erwarten (sein);nicht wundern dass;nicht ungewöhnlich
-(einen) (unvergesslich) komischen Anblick bieten;(ein) Bild für die Götter (sein) (ugs.);(ein) komischer Anblick (sein) (selten);(sehr) lustig aussehen
-amerikanisch;US-amerikanisch
-Iberoamerika;(das) spanisch- und portugiesischsprachige Amerika
-anglo-amerikanisch;angloamerikanisch
-Anglo-Amerika;Angloamerika
-nord- und südamerikanisch;amerikanisch;der beiden Amerika;gesamtamerikanisch
-zu der;zur;zu einer
-Lockdown (auch figurativ, engl.);(das) Abschalten;(das) Herunterfahren;Shutdown (auch figurativ, engl.)
-(sich) abmelden;(sich) ausloggen
-sächliches Genus;neutrales Geschlecht;Neutrum;sächliches Geschlecht;neutrales Genus
-Maskulinum;männliches Genus;männliches Geschlecht
-weibliches Genus;weibliches Geschlecht;Femininum
-Depolarisation;Depolarisierung
-Ruhemembranpotential;Ruhepotential
-immer seinen Senf dazugeben müssen (ugs.);nichts unkommentiert lassen (können);(einfach) seine Klappe nicht halten können (ugs.);immer was zu melden haben (ugs.);zu allem was zu sagen haben;zu allem was zu kacken haben (derb)
-größte Schwierigkeiten bekommen (ugs.);in Teufels Küche geraten;in Teufels Küche kommen;ernste Probleme bekommen;in arge Bedrängnis geraten;in eine äußerst ungemütliche Lage geraten;tausend Probleme bekommen
-gut passen (zu);(sich) nahtlos einordnen (in)
-(sich) einordnen;harmonieren;passen (zu);(sich) einfügen;hinkommen
-Adoptivvater;Stiefvater;Ziehvater;Pflegevater
-Bonusmama (ugs.);Ziehmutter;Bonusmutter (ugs.);Vizemutter (ugs.);Pflegemutter;Stiefmutter
-Zieheltern;Stiefeltern;Pflegeeltern
-Ziehtochter;Stieftochter;Pflegetochter
-Stiefkind;Pflegekind;Ziehkind (landschaftlich, österr.);Pflegling
-Ziehvater (fig.);Lehrmeister;Anleiter;Förderer;Mentor;Vorbild
-Mentorin;Lehrmeisterin;Ziehmutter
-ausbildendes Unternehmen;Ausbildungsbetrieb;Ausbildender (juristisch);Ausbilder (ugs.)
-Ideengeber;Chefstratege;Initiator;treibende Kraft;Spiritus Rector (geh., lat.)
-blassorange;aprikosenfarben;apricot
-durch... (ugs.);sämtliche;alle;die ganzen (ugs., regional);komplett (adverbial) (ugs.)
-jeder (Begleiter) (Hauptform);jeglicher (geh.);jedweder
-anlassen (ugs.);(ein Kleidungsstück) anbehalten
-Geschäftszeit;Hauptzeit
-Hochdruckflüssigchromatographie (veraltet);Hochleistungsflüssigkeitschromatographie
-Enteignung;Expropriation (geh., lat.);Konfiskation;Vermögenseinzug;Verstaatlichung;Konfiszierung
-ertränken;ersäufen
-(den) Schädel einschlagen;(den) Kopf einschlagen
-kreuzigen;ans Kreuz schlagen
-neutralisieren;ausschalten;eliminieren;liquidieren;terminieren
-dank;aufgrund;aufgrund dessen dass;vermöge (geh.);wegen;aufgrund von;veranlasst durch;aufgrund der Tatsache dass;wegen dem dass (ugs.);auf Grund von (geh., veraltend);infolge;begründet durch;auf Grund;...bedingt;dadurch dass;durch
-durch;aus;wegen;...halber;halber (nachgestellt);ob (veraltet)
-fürn (ugs.);wegen;für;um (...) willen;zugunsten;(...) halber;zuliebe;um dessentwillen;...halber (ugs.)
-Salmonellose;Salmonellenenteritis;Salmonelleninfektion
-Krupp (ugs.);Laryngitis subglottica (fachspr.);akute stenosierende Laryngotracheitis (fachspr.);Pseudokrupp
-Gesundheitsentstehung;Salutogenese (fachspr.)
-mit an Sicherheit grenzender Wahrscheinlichkeit (floskelhaft);höchstwahrscheinlich;mit (ziemlicher) Sicherheit;bestimmt
-Verkörperung (einer Sache);Personifikation (einer Sache) (geh.);selbst;Fleisch geworden;fleischgeworden;wandelnd (fig.);Leibwerdung (geh., fig.);personifiziert;lebend
-Faltung;Konvolution
-Distanzsensor;Abstandssensor;Wegaufnehmer
-(sich) zuwenden;(sich) hinwenden;(sich zu jemandem) hindrehen
-(sich) wegdrehen;(sich) abwenden;(sich) wegwenden
-gemischt;je nach Lichteinfall changierend (zwischen );meliert;(in einer) Mischfarbe (zwischen);mischfarbig
-getupft;großfleckig;mit Tupfen versehen;groß gepunktet;mit (großen) Tupfen;betupft
-(Leoparden-) Melano;Panter;Schwarzer Panther;Panther;(Leoparden-) Schwärzling
-Schlupfmütze;Skimaske;Hasskappe;Balaclava;Sturmmaske;Balaklava;Sturmhaube
-nur auf dem Papier stehen;wertloses Stück Papier;das Papier nicht wert, auf dem etwas geschrieben steht;das Papier nicht wert, auf dem etwas gedruckt ist;(nur) (ein) Fetzen Papier
-Papier ist geduldig. (sprichwörtlich);was die sich (immer / so) zusammenschreiben ... (ugs.);Schreiben kann man alles.
-nur auf dem Papier existieren;keine realen Auswirkungen haben;nicht der Realität entsprechen;nicht den Realitäten entsprechen
-zu Kompromissen bereit;veränderungswillig;lernfähig (polit.);zu Zugeständnissen bereit;veränderungsbereit;kompromissbereit;kompromissfähig
-Koalitionsvertrag;Koalitionsvereinbarung
-Partnerwahl (fig.);Zusammengehen (fig.);Koalition (Parlament)
-orchestrieren (fig.);aufeinander abstimmen
-immer wieder (tun);nichts unversucht lassen;keine Gelegenheit auslassen
-Linkerei (ugs.);Verlinkung
-zu finden versuchen;arbeiten an;herumbasteln an (ugs., fig., salopp);basteln an (ugs., fig., salopp);suchen nach (Lösung, Kompromiss)
-Stresstest;Belastungstest
-vom Himmel herabgestiegen;real geworden;Fleisch geworden;fleischgeworden;Wirklichkeit geworden
-Gebietsstreit;Territorialstreitigkeiten;Territorialkonflikt;Streit um Hoheitsrechte;Gebietsstreitigkeiten;Territorialstreit
-Gebietsansprüche;territoriale Ansprüche
-Demonstration;Veranschaulichung;Illustration
-suggerieren;in den Mund legen (fig.);nahelegen;einflüstern
-Ideensammlung (Ergebnis);Ideenpool
-Jogging;Dauerlauf (veraltend)
-feierlich überreichen;auf dem silbernen Tablett übergeben;auf dem Präsentierteller (überreichen)
-allen (neugierigen) Blicken ausgesetzt;den Blicken aller ausgesetzt;alle können es sehen;alle können dabei zusehen;auf dem Präsentierteller (fig.)
-zu dem;zu einem;zum
-zum Zweck (einer);zum Zwecke (einer);zwecks (einer);behufs (einer) (Amtsdeutsch, veraltet)
-zwecks (eines);zum Zwecke (eines);behufs (eines) (geh., Amtsdeutsch, veraltet);zum Zweck (eines)
-Herr von und zu (ugs., scherzhaft);(der) feine Herr (ironisch);(der) vornehme Herr
-anno (achtzehnhundert) Piependeckel (ugs.);(anno) dunnemals (ugs.);anno tuck (ugs.);(anno) achtzehnhundert schlag mich tot (ugs.);achtzehnhundert schieß mich tot (ugs.);anno Tobak (ugs.);irgendwann in der Vergangenheit
-Radio-Okkultation;Okkultationsmethode
-die Nacht durchwachen;(sich) die Nacht um die Ohren hauen (ugs., salopp);wachbleiben (ugs.);aufbleiben (ugs.);durch...;(eine) Nachtschicht einlegen (ugs., fig.);die Nacht zum Tage machen;(sich) die Nacht um die Ohren schlagen (ugs.);durchmachen (ugs.)
-Jahrhundertaufgabe;Opus magnum (lat.);Herkulesaufgabe;Jahrhundertprojekt
-(an jemandem ist ...) verloren gegangen;das Zeug haben (zu);hätte (gut / ohne weiteres ...) werden können
-Getändel;Spielerei;Ringelpiez mit Anfassen (ugs.);(die) Sache nicht weiter (voran) bringen;harmloses Geplänkel
-(den) Anschein erwecken;sagen, dass man (...) ist;machen auf (ugs., salopp);(sich) gerieren als;geben (ugs.);markieren (ugs., salopp);(jemanden) mimen (ugs., salopp)
-parteipolitisch;(einem) Partikularinteresse entsprechend;im Interesse einer Partei liegend
-(jemandem) ist, als ob;(jemandem) kommt der Gedanke;(jemanden) beschleicht das Gefühl;den Eindruck haben (dass);(jemand) hat das dumme Gefühl (ugs.);ein mulmiges Gefühl (haben bei)
-(ein) dummes Gefühl (ugs.);ungute Ahnungen;(ein) flaues Gefühl;(ein) mulmiges Gefühl;(ein) dumpfes Gefühl
-nicht von ungefähr kommen (ugs.);nicht an den Haaren herbeigezogen (sein) (ugs., fig.);nicht konstruiert;nicht vom Himmel gefallen (sein) (fig.);was dran (sein) (ugs.)
-Führungspersönlichkeit;Großkopferter (ugs., bayr., österr.);hochgestellte Persönlichkeit;Großkopfeter (ugs., bayr., österr.);maßgeblicher Entscheider;(Teil der) Nomenklatura
-(öffentlich übertragene) Diskussion der Parteichefs;Elefantenrunde
-perenne krautige Pflanze (fachspr., selten);perennierende krautige Pflanze (fachspr.);Staude;mehrjährige krautige Pflanze
-voller Erwartungen sein;voller Erwartungen in die Zukunft blicken;(sich) die Hände reiben (fig.);(sich) freuen auf;(einer Sache) erwartungsvoll entgegensehen;(sich) die Lippen lecken (fig.);in Goldgräberstimmung (sein)
-nicht auszudenken sein;ich will nicht wissen, was (+ Konjunktiv ...) (floskelhaft);man mag (es) sich (gar) nicht vorstellen (variabel)
-nicht zu fassen;unglaublich;nein so etwas! (ugs.);nicht zu glauben;unfassbar;unfasslich;(das) kannst du dir nicht vorstellen
-nicht darzustellen;nicht darstellbar;(jemandem) nicht zu vermitteln;nicht zu erklären;(es gibt) keinen vernünftigen Grund
-Bruder im Geiste (auch figurativ, männl.);Seelenverwandter (männl.);(jemandes) Alter Ego;Schwester im Geiste (weibl.);Seelenverwandte (weibl.)
-seelenverwandt;im Geiste verbunden
-Rehabilitierung;Verteidigung der Ehre;Rehabilitation;Wiederherstellung des Ansehens;Ehrenrettung
-Erziehungshelfer (ugs.);Rohrstock;spanisches Rohr (veraltet);gelber Onkel (ugs.);Stecken;Schlagstock;Züchtigungsinstrument
-gegen seine (eigene) Überzeugung handeln;(sich) verbiegen (ugs.)
-Nilpferdpeitsche;dicke Peitsche
-blöde Kuh (derb);Idiot (männl.);Arsch mit Ohren (derb);Idiotin (weibl.);Affenarsch (derb);Blödmann (derb);Arschgeige (derb);blöder Arsch (derb)
-zusammentreten;(auf jemanden) eintreten
-wechseln zu;(die) Konfession wechseln;übertreten zu;konvertieren (Religion);(sich) bekehren zu;(einen) anderen Glauben annehmen;überwechseln zu
-Kriegsgegner;Anhänger der Friedensbewegung;Pazifist;Friedensbewegter (ugs., spöttisch);Friedensaktivist
-gar keiner (gar keine, gar keins);nicht (mal) einer (nicht ... eine, nicht ... eins);kein einziger (keine einzige, kein einziges);gar kein (gar keine);überhaupt keiner (überhaupt keine);nicht ein (nicht eine; Betonung auf 'ein');überhaupt keiner (überhaupt keine, überhaupt kein)
-Lebensumstände;Lebenssituation;Situation;Verhältnisse
-ausschalten;erledigen;besiegen;ausknocken;mattsetzen
-alle drei (miteinander) (ugs.);selbdritt (geh., veraltet);drei Mann hoch;(miteinander) zu dritt
-(sich) hinreißen lassen;(sich) überreden lassen;(sich) einspannen lassen;(sich) anstiften lassen;(sich) verleiten lassen
-zum Aufbruch drängen;mit den Füßen scharren (ugs., fig.);zum Aufbrechen auffordern;mit den Hufen scharren (ugs., fig.);gehen wollen;einen Ort verlassen wollen
-(sich) angepisst fühlen (derb);(sich) vorgeführt fühlen
-Berittener;Reiter;Reitersmann
-Rennreiter;Jockey
-schon nach einem Glas betrunken (sein) (variabel);keinen Alkohol vertragen (können);nichts am Glas können (ugs.);schnell betrunken werden;nichts vertragen;sofort betrunken sein;(jemand) kippt schon nach einem Glas (Bier) aus den Latschen (ugs., salopp);alkoholintolerant (sein) (fachspr., medizinisch);(jemanden) haut schon ein Glas um (ugs.)
-Eskadron;Schwadron
-Papier und Feder;Schreibzeug
-in Katerstimmung (sein);verkatert (sein);(einen) Kater haben;Katzenjammer;in Essig liegen (ugs., fig.);in Essig und Öl liegen (ugs., fig., selten)
-Schreibkram (ugs.);Bürokram (ugs.);(das) Schriftliche;Papierkram (ugs.);Formularkram (ugs.);Schreibtischarbeit;Schreibarbeit;Papierkrieg (ugs.);(die) Formalitäten
-Trickkiste;Tricksammlung
-Bluthochdruck;arterielle Hypertonie (fachspr.);erhöhter Blutdruck
-Kreislauf;Blutbahn (ugs.);Blutgefäßsystem (fachspr.);Blutkreislauf
-im vierten Grad (miteinander) verwandt;über viele Ecken (miteinander) verwandt;über mehrere Ecken (miteinander) verwandt;weitläufig (miteinander) verwandt;im fünften Grad (miteinander) verwandt;entfernt (miteinander) verwandt
-entfernter Verwandter;Verwandter über mehrere Ecken;Verwandter fünften Grades;Verwandter vierten Grades;weitläufiger Verwandter
-naher Verwandter;näherer Verwandter;enger Verwandter;direkter Verwandter;nächster Verwandter
-direkt (miteinander) verwandt;in direkter Linie (miteinander) verwandt;in gerader Linie (miteinander) verwandt
-eng verwandt;nahe (miteinander) verwandt
-kollateral verwandt (fachspr.);in der Seitenlinie (miteinander) verwandt
-angeheiratet;verschwägert
-Adoptiv...;an Kindes statt angenommen;als Kind angenommen;adoptiert;als eigenes Kind angenommen
-an Tochters statt annehmen;als (eigenes) Kind annehmen;an Sohnes Statt annehmen;adoptieren;an Kindes Statt annehmen
-Adoptivsohn;an Kindes statt angenommener Sohn;angenommener Sohn;adoptierter Sohn
-adoptieren (fig.);in die Familie aufnehmen
-Au-pair-Mädchen;Haustochter (veraltet)
-Patin;Patentante;Taufpatin
-Kornmuhme;Roggenmuhme
-Knecht Ruprecht;Krampus
-Unglückstag;schwarzer Tag (für)
-immer abends;jeden Abend (Hauptform);an allen Abenden;alle Abende;allabendlich;an jedem Abend;jeden Abend, den Gott werden lässt (geh., Spruch, veraltet);Abend für Abend
-allmorgendlich;morgens (... immer);jeden Morgen;an allen Morgenden;an jedem Morgen;immer morgens;alle Morgende
-in die Verlustzone geraten;in den Miesen (sein) (ugs.);rote Zahlen schreiben;Verluste machen;Verlust machen;minus machen
-(eine) schwarze Null vor dem Komma (schreiben);plus/minus null (abschließen)
-verbrannt werden;auf dem Scheiterhaufen sterben
-durchs Fallbeil sterben;guillotiniert werden;durch die Guillotine sterben;auf der Guillotine sterben
-Bandpass;Bandbreitenfilter
-Klarinettenspielerin;Klarinettistin
-Synhyponym (griechisch);Kohyponym (fachspr., griechisch);Inkonym (griechisch);gleichrangiger Mengenteil
-Kohyperonym;Synhyperonym
-Quintillion;Quinquillion
-Quinquilliarde;Quintilliarde
-Zitronensäure;Citronensäure (fachspr.)
-Röntgenium;Roentgenium (fachspr.)
-Cadmium;Cd (Elementsymbol);Kadmium
-außereheliches Kind (juristisch);Bankert (beleidigend) (veraltet);nichteheliches Kind (juristisch);illegitimes Kind (Genealogie) (fachspr.);Kind ohne Vater;Bastard (beleidigend) (veraltet);uneheliches Kind
-Duodezimalsystem;Zwölfersystem
-Vigesimalsystem;Zwanzigersystem
-Wohlordnungstyp;Ordinalzahl
-Mächtigkeit;Kardinalität;Kardinalzahl
-Kriegsmatura (österr.);Notabitur;Notreifeprüfung;Kriegsabitur
-Mädchengymnasium;Lyzeum (regional)
-höhere Mädchenschule;höhere Töchterschule
-Frauenbewegung;Frauenrechtsbewegung
-bis zur Selbstverleugnung;bis zur Selbstaufgabe
-mit Kennerblick;mit geübtem Blick;routiniert (Adv.);mit geübter Hand
-Higgs-Boson;Gottesteilchen (ugs.);Higgs-Teilchen
-(die) Spreu vom Weizen trennen (fig.);(sich) das Beste herauspicken;sich die Rosinen herauspicken (fig.);sich die Rosinen vom Kuchen herauspicken (fig.);guten ins Töpfchen, die schlechten ins Kröpfchen (tun) (Spruch);sich die Rosinen aus dem Kuchen picken (fig.);(sich) die besten Stücke herauspicken
-(die) besten Stücke;Filetstück (auch figurativ);Sahnestückchen;(die) Rosinen vom Kuchen (ugs., fig.);begehrtestes Teil (variabel);(das) Beste
-täuschend echt (aussehen);sehr gute Fälschung;vom Original nicht zu unterscheiden sein
-(nur) zur Vorsicht;aus Vorsichtsgründen
-Sammelwut;Sammelleidenschaft;Hamsterei (ugs.);(das) Hamstern
-ohne Arg;unvoreingenommen;ohne Hintergedanken
-noch nicht vom Tisch (sein) (fig.);noch nicht erledigt sein;(ein) Nachspiel haben;noch nicht ausgestanden (sein)
-gesagt, getan;sofort in die Tat umgesetzt
-ein gutes Ende finden;Ende gut, alles gut
-Verwirrungen;(die) Wirren;Wirrnisse;Wirrungen
-nicht (mehr) aufzuhalten;perfekt (ugs.);nicht (mehr) zu ändern
-Wiederkauf (kaufm.);Rückkauf;Rückerwerb
-höllisch;rasant;benimmt einem den Atem (veraltet);irre;nimmt einem den Atem;rasend;wahnsinnig;atemberaubend;irrsinnig
-(ein) Auge haben (auf) (fig.);hüten wie seinen Augapfel;nicht weggeben;in Ehren halten;gut achtgeben auf;achten und bewahren
-ehrenvoll;würdevoll;in Würde;ehrenhaft;in Ehren;in allen Ehren;mit allen Ehren
-ins Ausland verbringen;ins Ausland bringen;außer Landes schaffen
-...leidenschaft;...fimmel (ugs.);...wahn;...trieb;...zwang;...tick;...sucht;...itis;...manie
-...süchtig;...man;...abhängig (medizinisch);...krank (fachspr., medizinisch)
-(jemanden) aus der Schusslinie nehmen;(jemanden) schützen (vor);(jemandem etwas) vom Hals halten;seine (schützende) Hand halten über;unter seinen persönlichen Schutz nehmen;(sich) schützend vor jemanden stellen;unter seinen persönlichen Schutz stellen
-mäßig;nicht besonders;nicht sonderlich;in Maßen;nicht weiter
-(sich) einfach anhören;leichter gesagt als getan (sein);was du so redest... (ugs.);gut reden haben (ugs.)
-was willst du? (unfreundlich) (ugs.);was verschafft mir die Ehre? (geh.);was ist der Grund Ihres Kommens? (floskelhaft);was führt dich her? (geh.);was verschlägt dich hierher? (scherzhaft);was ist der Grund (für Ihren Besuch)?;gibt es einen besonderen Anlass (für Ihren Besuch)?;was hast du hier verloren? (ablehnend) (ugs.);warum bist du (her) gekommen?;was hast du hier zu suchen? (drohend) (ugs.)
-Rückübertragung;Wiedererlangung;Rückabwicklung;Rückführung
-Redebedürfnis;(sich) gerne unterhalten;Gesprächigkeit;gerne reden;Mitteilsamkeit;Redseligkeit;Mitteilungsbedürfnis
-lauten;(geschrieben) stehen in;(den) Wortlaut haben
-kaum aufzufinden;Nadel im Heuhaufen;kaum auffindbar
-großes Gewicht haben;ernst zu nehmen sein;von Gewicht sein;schwer wiegen
-Foliierung;Blattnummerierung
-(jemand hätte sich) in seinen kühnsten Träumen nicht vorstellen können (floskelhaft, variabel);(jemand hätte sich) nicht träumen lassen;(darauf wäre jemand) im Leben nicht gekommen (ugs.);(etwas wäre jemandem) im Traum nicht eingefallen;(jemand hätte sich) nicht vorstellen können
-mit dem Schiff;zu Schiff (geh.);per Schiff;auf dem Seewege
-in bester Absicht;guter Wille;mit den besten Absichten
-katastrophale Situation;Missstand;Misere
-Missstände;Auswüchse;schlimme Zustände
-(die Situation ist) schlimm;es ist schlecht bestellt (um);zu Sorgen Anlass geben;im Argen liegen
-großen Einfluss haben;ganz oben mitmischen (ugs.);(eine) Führungsposition innehaben;(die) Strippen ziehen (fig.);schon wer (sein) (ugs.);mächtig sein;(et)was zu sagen haben;nicht irgendwer (sein);an den Schalthebeln der Macht sitzen;(die anderen) nach seiner Pfeife tanzen lassen (ugs., fig.)
-Kabelabzweiger;Leitungsverteiler;Stromdieb (ugs.)
-Waldheim-Debatte;Waldheim-Affäre;Causa Waldheim;Fall Waldheim;Affäre Waldheim
-Weiße Liste;Whitelist (engl.);Positivliste;Weißliste
-Entspannung;Aufatmen;Gefühl der Befreiung;Erlösung;erlösendes Gefühl;Erleichterung;Beruhigung
-Rotgesichtsmakake;Japanmakak;Schneeaffe
-abarbeiten;der Reihe nach erledigen;nacheinander bearbeiten
-Unpaarhufer;Unpaarzeher
-Moschusochse;Bisamochse;Schafsochse
-Brillenbär;Andenbär
-Sophie-Germain-Primzahl;Germainsche Primzahl
-(am ...) ist es wieder so weit;alle Jahre wiederkehren;(sich) jähren;(sich) jährlich wiederholen;jährlich wiederkehren
-aus dem Konzept kommen;vergessen was man sagen wollte;(den) Faden verlieren (fig.)
-(jemandem) entgleisen die Gesichtszüge;(für einen Moment) die Fassung verlieren;man sieht jemandem seine Bestürzung (deutlich) an;aus der Fassung geraten;aus den Latschen kippen (ugs., fig.)
-(sich) nicht beherrschen (können);(die) Fassung verlieren;(sich) gehen lassen;(die) Kontrolle verlieren;(sich) keinen Zwang antun
-(jemandem) ist nicht zum (...) zumute;keinen Schnüff haben auf (ugs., rheinisch);keine Lust haben (auf);nicht in der Stimmung sein (zu);(jemandem) ist nicht nach (ugs.);nicht aufgelegt (zu);(jemandem) steht der Sinn nicht nach (veraltend)
-Atomgegner;Kernkraftgegner;Atomkraftgegner
-Dampfblasenkoeffizient;Voidkoeffizient;Kühlmittelverlustkoeffizient
-Recken (schweiz.);Schiffziehen;Treideln;Bomätschen (sächsisch);Halferei
-Ludwig-Donau-Main-Kanal;Ludwigskanal;Alter Kanal (regional)
-(jemandem) eine Mail zukommen lassen;(jemanden) per E-Mail antexten;(jemandem) eine Mail schicken;(jemanden) anmailen;(jemandem) eine Nachricht zukommen lassen
-par ordre de mufti;ohne sich abzustimmen;im Kommandostil;auf dem Erlasswege;par ordre du mufti;von oben herab (festlegen);in schlichter Ausübung seiner Weisungsbefugnis
-Kommandosprache;Befehlston;Kasernenhofton (fig.)
-Chris Howland;Mr. Pumpernickel (ugs.)
-hochkochen;angeheizt werden;(die) Gemüter erregen
-gelernter;seines Zeichens (veraltend);von Beruf
-ganz tief innen (ugs.);im Grunde seines Herzens (männl.);in den verborgensten Tiefen ihrer Seele (weibl.);in ihrem tiefsten Inner(e)n (weibl.);im Grunde ihres Herzens (weibl.);in seiner tiefsten Seele (männl.);in seinem tiefsten Inner(e)n (männl.);in den tiefsten Tiefen seiner Seele (männl.);in den geheimsten Winkeln seiner Seele (männl.);im tiefsten Innern;in ihrer tiefsten Seele (weibl.)
-als Jugendlicher;in der Blüte seiner Jahre;als junger Mensch;im Jugendlichenalter;in seinen jungen Jahren;als junger Mann;als Heranwachsender;in jungen Jahren;im jugendlichen Alter;in seinen jugendlichen Jahren
-Birmanisch;Burmesisch
-Francisco Franco;(der) Caudillo
-innerhalb der Partei;parteiintern
-untergehen;niemandem auffallen (nebensächlicher Vorgang);nicht bemerkt werden
-fast tot;halbtot;mehr tot als lebendig;übel zugerichtet;halb tot
-biologische Meereskunde;Meeresbiologie
-von morgens bis abends nur damit beschäftigt sein (zu);gut zu tun haben (mit) (ugs.);keine freie Minute haben;bis zum Hals in Arbeit stecken;viel zu tun haben;alle Hände voll zu tun haben;viel um die Ohren haben (ugs., fig.);reichlich zu tun haben;(voll) ausgelastet (sein);(da) wartet Arbeit (auf jemanden) (ugs.);viel Arbeit haben;in Arbeit ersticken (fig.);sehr beschäftigt (sein)
-Sprachschützer;Sprachreiniger;Sprachpurist;Sprachpfleger;Sprachnörgler (abwertend)
-Putzteufel;Sauberkeitsfanatiker
-Putzteufel (ugs.);Putzfimmel (ugs.)
-in Tränen aufgelöst;tränenreich;unter Tränen;tränenblind (geh.);(heftig) weinend
-mit leiser Wehmut (geh.);mit einer Träne im Knopfloch (fig., scherzhaft)
-Meinungsbild;Stimmungstest
-Begünstigung (fachspr.);Verstärkung;Unterstützung;Beschleunigung
-Rumpfbeuge;Sit-up;Aufrichter;Rumpfheben
-busenfrei;oben ohne (ugs.);barbusig
-bewusst falsch;unerlaubt;missbräuchlich;zu einem falschen Zweck
-(ein) ständiges Kommen und Gehen;zugehen wie im Taubenschlag;viel Publikumsverkehr
-Auffangbecken;Überlaufbecken
-Audienz;Empfang
-Insulinum;Inselhormon;Insulinhormon;Insulin
-Langerhans-Inseln;Langerhanssche Inseln;Inselzellen
-(die) Hand geben;mit Handschlag begrüßen;(die) Hände schütteln;(die) Hand reichen
-Betrachtung;Hinsehen;Augenschein;Blick auf;Betrachten
-Museum (ugs.);Kunstmuseum;Pinakothek;Gemäldegalerie
-zweihundertprozentig;überzeugt;auf Linie;konsequent;linientreu;stramm;getreu;hundertprozentig
-ausklammern;außen vor lassen (ugs.);nicht reinlassen;aussperren;heraushalten;fernhalten;nicht (mit) einbeziehen;draußen halten;isolieren;keinen Zutritt gewähren;nicht mitmachen lassen;ausgrenzen;nicht hereinlassen;ausschließen;nicht dabeihaben wollen
-innerster Zirkel;innerster Kreis;innerer Kreis;(die) (wirklich) Eingeweihten
-von etwas wissen;(die) Hintergründe kennen;um die Hintergründe wissen;eingeweiht (sein)
-(einen) Blick hinter die Kulissen werfen (fig.);(den) Hintergrund erfahren
-(irdisches) Jammertal (fig.);irdisches Dasein
-schlechte Phase;schlechte Zeit;Tal der Tränen (fig.);Stimmungstief
-(für) schlechte Zeiten (ugs.);(für) Zeiten der Not
-Bewahrer;Lordsiegelbewahrer (fig.);Hohepriester (fig.);Hüter
-Extrakt (fig.);Kondensat (fig.);Konzentrat (fig.);Essenz (fig.)
-Personenmeldeamt (schweiz.);Bürgeramt;Meldehalle;Meldeamt (österr.);Einwohnermeldeamt;Meldebehörde;Bürgerbüro;Einwohnerkontrolle (schweiz.)
-Kriegstrommeln (fig.);Säbelrasseln (fig.);militärische Drohkulisse (fig.);Kriegsdrohungen;martialische Töne;militärische Drohgebärden;kriegerische Töne
-leibhaftig;real;aus Fleisch und Blut
-Flakon;kleine Flasche;Fläschchen;Pülleken (ugs., ruhrdt.)
-wie verrückt;mit äußerster Heftigkeit;wie ein Verrückter;wie wild;äußerst heftig;wie ein Irrer
-reif;gesetzt;gestanden;erfahren;mittleren Alters;gereift
-(jemandes) Stunde kommt;(die) lang erwartete Gelegenheit kommt (für);(der) langersehnte Moment kommt (für jemanden)
-Zusammenschlusskontrolle;Fusionskontrolle
-Zider (selten, veraltet);Cidre (franz.);Apfelperlwein (fachspr., Jargon);Apfelsekt;Cider (engl.);Apfelschaumwein (fachspr.)
-Spiralgalaxie;Spiralnebel (veraltet)
-Gebirgsverein (veraltet);Alpiner Verein
-weil;aufgrund dessen;um
-drahtig;sehnig
-schlank wie eine Gerte;schlank;gertenschlank;schlank wie eine Tanne;rank (veraltet);superschlank;rank und schlank
-Nachwuchs;(die) jungen Kräfte;(eine) neue Generation (von);(die) jungen Talente;(die) Jungen (ugs.);junge Garde
-Zuwachs;Nachwuchs;Kindersegen;Nachkommenschaft
-weißhaarig;weiß;schlohweiß
-Intriganz;intrigantes Verhalten
-nie allein;ein Herz und eine Seele;als Zweiercombo;paarweise;als Doppel;in Zweierkombination;zu zweit;(immer) zusammen;(immer) im Doppelpack;unzertrennlich;im Doppel;siamesische Zwillinge (fig.);doppelt
-(eine) günstige Vorsehung;(ein) gnädiges Geschick
-abgeschickt werden;rausgehen (ugs.);auf die Post gehen
-(sich) einzelne herauspicken;stichprobenartig;einzelne Fälle
-Joke (engl.);Witz;Ulk;Scherz;Gag (engl.)
-witzige Bemerkung;Scherz;lustige Bemerkung;Blödspruch;Joke (engl.);Witzelei
-Pritsche;Klatsche;Narrenpritsche
-nicht zünden(d);zieht nicht (Witz) (ugs.);nicht (wirklich) komisch;ohne (echte) Pointe;kalt (Witz)
-Bahnkunde;Zugpassagier;Bahnreisender
-Flugpassagier;Passagier;Pax (fachspr., engl.);Fluggast
-Abschluss (ugs.);Gesellenprüfung;Abschlussprüfung (einer gewerblichen Berufsausbildung)
-da kuckse, wa? (ugs., ruhrdt.);gell do schaugst! (ugs., bayr.);da machste Jlotzoogen, wa? (ugs., berlinerisch)
-was glotzt du so? (ugs.);starr mich nicht so an!;Sie brauchen gar nicht so zu gucken! (ugs.);guck nicht so blöd! (ugs.);was gibt's (denn) da zu glotzen!? (ugs.)
-Notenprogramm;Notensatzprogramm;Notationssoftware
-signifikante Stellen;geltende Stellen
-Abstandsgesetz;Entfernungsgesetz
-Entspannungstechnik;Entspannungsverfahren;Entspannungsmethode
-Unterjura;Unterer Jura
-Mitteljura;Mittlerer Jura
-Brauner Jura;Braunjura
-Weißjura;Weißer Jura
-Oberer Jura;Oberjura
-Lithostratigrafie;Lithostratigraphie
-(Jahreszahl);anno (...);im Jahre (...);im Jahr (...);im Jahre des Herrn (...) (feierlich, ironisierend)
-hyperbare Kammer;Überdrucksack
-Öffnungsklausel;Abdingbarkeit
-nicht zwingend (vorgeschrieben);durch (eine) abweichende Regelung ersetzbar;mit Öffnungsklausel;abdingbar;durch freie Vereinbarung veränderbar;kein Muss
-produzierend;gewerblich
-viel berufen (geh.);vielzitiert;oft bemüht (geh.);legendär;oft erwähnt;ominös;sprichwörtlich;vielbeschworen;häufig genannt
-(jemandem) Arbeit abnehmen;(jemandem) den Rücken freihalten (fig.);(jemanden) entlasten
-parlamentarischer Staatssekretär (des Bundes);Staatsminister
-Minister für besondere Aufgaben;Minister ohne Geschäftsbereich;Minister ohne Ressort;Minister ohne Portefeuille
-Umgestaltung (Hauptform);Neugestaltung;Neuorganisation;Neustrukturierung;Reformierung;Reorganisation;Neuaufstellung;Umbildung;Neuordnung;Umstrukturierung
-an die Arbeit gehen;(sich) kopfüber in die Arbeit stürzen;mit der Arbeit anfangen;mit der Arbeit beginnen;ans Werk gehen;(die) Arbeit aufnehmen;(sich) in die Arbeit stürzen;loslegen;(sich) ans Werk machen;anfangen zu arbeiten (Hauptform);(sich) an die Arbeit machen
-wieder auf Erfolgskurs bringen;(die) Schulden reduzieren;aus den roten Zahlen herausbringen;sanieren
-Sanierer;Firmenretter
-Radikalmaßnahme(n);Rosskur (fig.);radikale Therapie;strapaziöse Behandlung
-halt die Klappe! (derb, variabel);sag (jetzt) nichts (ugs., variabel);sei still! (ugs., variabel);halt den Rand! (ugs.);wer hat dich denn gefragt? (ugs., variabel);halt die Backen! (derb);halt den Schnabel! (derb);einfach mal die Fresse halten ... (derb);ich würde (an deiner Stelle) jetzt lieber (mal) den Mund halten (ugs., variabel);Maul halten! (derb);du redest zu viel (variabel);halt dich (gefälligst) geschlossen!;halt (mal) die Luft an! (ugs., veraltend);halt die Fresse! (vulg.);Noch ein Wort (und ...)! (drohend) (derb);sag einfach nichts (ugs.);halt den Mund! (ugs., variabel);Was! (drohstarrend) (derb);halt dein Maul! (derb);Schnauze! (derb)
-fetzig (ugs., jugendsprachlich);Pep haben(d);peppig (ugs.);flott;mit Pep;scharf;geil (ugs., jugendsprachlich)
-langsam zu Ende gehen;(dem) Ende näherkommen;(sich dem) Ende zuneigen
-hör auf damit! (ugs.);(jetzt) mach (aber) mal halblang! (ugs.);nun lass (aber) mal die Kirche im Dorf! (ugs., variabel);hör auf jetzt! (ugs.);jetzt hör schon auf! (ugs.);(jetzt) mach (aber) mal einen Punkt! (ugs.);es reicht (allmählich) (ugs.);nu(n) ist aber gut! (ugs.);jetzt bleib (aber) mal auf dem Teppich! (ugs.);lass (es) gut sein! (ugs.);(jetzt) mach (hier) nicht so'n Wind! (ugs.);Aus! (fachspr.);lassen Sie es gut sein (ugs.);schon gut! (abwehrend) (ugs.);ist gut jetzt! (ugs.)
-Bruss-Algorithmus;Bruss-Strategie;Odds-Strategie
-Orthonym;richtiger Name (ugs.);wirklicher Name (ugs.);Realname;Klarname;bürgerlicher Name
-schroff;(wie) ein Elefant im Porzellanladen (fig.);taktlos;undiplomatisch;ohne Feingefühl;ruppig;unsensibel
-ruppig;polterig;bollerig (ugs., regional);poltrig;wie ein Elefant im Porzellanladen;polternd
-Dreharbeit;Dreh (ugs.)
-(jemanden) motivieren;(jemanden) animieren;(jemandem) Anlass geben;(dazu) bringen (zu);(jemanden) veranlassen
-(jemanden) neugierig machen (Hauptform);(jemanden) heißmachen (ugs.);(jemanden) ködern (fig.);(jemandes) Interesse wecken;antörnen;(jemanden) anfüttern (ugs., fig.);(jemanden) anfixen (ugs., auch figurativ)
-ein Mann, ein Wort;ich verlass mich darauf
-Riese (ugs.);Tausender;Tausi (ugs.)
-Hunni (ugs.);Hunderter (ugs.);hundert Euro;Hundert-Euro-Schein
-(ein) Fuffi (ugs.);Fünfzig-Euro-Schein;50-€-Schein;Fünfziger
-Fünfmarkschein;Fünfer;fünf Mark
-fünf Euro;Fünf-Euro-Schein;Fünfer
-Zehner (ugs.);Zehnmarkschein;zehn Mark
-zehn Euro;Zehn-Euro-Schein;Zehner (ugs.)
-Zwanzig-Euro-Schein;20-Euro-Schein;zwanzig Euro;Zwanziger;Zwanni (ugs.)
-Hunni (ugs.);100-DM-Schein;Hundertmarkschein;hundert Mark;Hunderter
-(ein) Fuffi (ugs.);50-DM-Schein;Fünfzigmarkschein;fünfzig Mark
-Geldsumme;Geldbetrag
-Stübner;Bader
-Badehaus;Badestube;Badhaus;Stube;Stoben
-(ein) Riese (ugs.);(ein) Tausender;tausend Mark;Tausendmarkschein
-Abgeordnetenbezüge;Diäten
-für geringen Lohn;gegen ein geringes Entgelt
-schlechtbezahlt;schlecht bezahlt;niedrig bezahlt
-mörderisch;bluttriefend (fig.);grausam
-Todfeind;bis aufs Blut verfeindet;Erzrivale;Erzfeind
-Provinztheater;Wandertheater;Schmiere
-Justizblamage;(lächerlicher) Justizskandal;Justizposse
-Mogul;Industriekapitän;Großindustrieller;Wirtschaftskapitän;Tycoon (japanisch);Magnat;Oligarch;Schlotbaron (Ruhrindustrie) (fig., veraltend)
-Medienzar;Medienmogul;Medien-Tycoon
-den ganzen Tag;den lieben langen Tag (ugs.);von morgens bis abends;den ganzen Tag lang;von früh bis spät
-Bonze;Apparatschik;(höherer) Parteifunktionär
-Parteikader;Parteisoldat
-Kapitalist;Angehöriger der besitzenden Klasse
-Zinswucher;Wucherzins
-Geldhai;Kredithai (ugs.);Wucherer
-Kasino-Kapitalismus;spekulative Finanzwirtschaft
-Investmentbanking;Investmentgeschäfte
-(sich eine) Schlammschlacht liefern (fig.);schmutzige Wäsche waschen (fig.);(sich) mit Dreck bewerfen (fig.)
-Rosenkrieg;Trennungskonflikt
-Rückführungsabkommen;Rücknahmeabkommen;Rückübernahmeabkommen
-Ausweisung;Landesverweis
-Zahlenwert;numerischer Wert
-Morsealphabet;Morsecode;Morsezeichen;Morsekode
-ausgewiesen;anerkannt
-zertifiziert;mit Zertifikat
-mit Staatsexamen;staatlich geprüft;examiniert
-staatlich zugelassen;approbiert
-bescheinigt;dokumentiert;nachgewiesen;mit erbrachtem Nachweis (des / über ...)
-mit Diplom;dipl. (Abkürzung, schweiz.);diplomiert
-ethnische Säuberung (fachspr., Hauptform);Vertreibung;Massenvertreibung
-Gelder;Geldbeträge;Geldsummen;Summen;(finanzielle) Mittel
-etliche;nicht wenige;mancher;so mancher;manch einer
-Heliumzittern (ugs.);Heliumtremor (ugs.)
-Technisches Tauchen;Tek-Tauchen;Tec-Tauchen
-Deko-Tabelle;Austauchtabelle;Dekompressionstabelle
-Dekompressionszeit;Deko-Zeit
-Dekompressionsstopp;Deko-Stopp
-Stickstoff-Narkose;Tiefenrausch;Inertgas-Narkose
-Kraulen;Kraulschwimmen
-Schwimmbadflosse;geschlossene Flosse;Schwimmflosse;Badflosse;Fußteilflosse
-Fersenbandflosse;offene Flosse;Geräteflosse
-Lungenautomat;Atemregler;Automat
-Drucklufttauchgerät;Presslufttauchgerät
-Tauchlampe;Taucherlampe
-Tauchermaske;Tauchmaske;Druckausgleichsmaske;Tauchbrille (ugs.);Taucherbrille (ugs.)
-Tauchseil;Tauchleine
-Taucherflagge;Gerätetaucherflagge;Taucherfahne;Alpha-Wimpel;rot-weiße-Flagge;Alphaflagge;Doppelstander A
-Boje-über-Bord-Manöver;Mann-über-Bord-Manöver;Mensch-über-Bord-Manöver;Person-über-Bord-Manöver
-Urbakterie (veraltet);Archaebakterie (veraltet);Archaeon;Archebakterie (veraltet)
-Schlacht um Cholm;Kessel von Cholm
-Beichte (Hauptform);Bußsakrament;Amt der Schlüssel
-Belgisch Granit;Belgisch Schwarz
-habilitiert;habilitatus (fachspr.);habil.
-(die) akademische Lehrerlaubnis erteilen;(jemanden) habilitieren
-habilitieren;(die) Venia Docendi erhalten;(die) (akademische) Lehrbefähigung nachweisen;(sich) habilitieren
-Flurfördermittelschein;Gabelstaplerschein;Staplerschein (ugs.)
-Staatsexamen;Staatsprüfung
-organisiertes Verbrechen;organisierte Kriminalität
-Leitwolf (fig.);Alphatier (fig.)
-vaterrechtlich (fachspr.);androkratisch (fachspr.);von Männern bestimmt;männerdominiert;männlich dominiert;patriarchalisch
-matriarchalisch;mutterrechtlich;von Frauen bestimmt;frauendominiert;von Frauen dominiert
-mit starker Hand (fig.);herrisch;durchsetzungsstark;autoritär;gebieterisch;durchsetzungsfähig
-Folgsamkeit;Obödienz (lat., religiös);Fügsamkeit;Obedienz (lat., religiös);Gehorsamkeit;Gehorsam
-Artigkeit;Bravheit
-(das) Sich-Unterwerfen;Unterordnung;Subordination;(das) Sich-Unterstellen
-brandschatzen;sengen und brennen (veraltet);zündeln;Feuer legen;abfackeln (ugs.);mit Feuer und Schwert wüten
-sengen und morden;marodieren;sengen und brennen (veraltet);sengen und plündern
-Scheinriese;Koloss auf tönernen Füßen (geh., fig.);Papiertiger (fig.);als Tiger (los)springen und als Bettvorleger landen (ugs., fig., scherzhaft-ironisch);zahnloser Tiger (fig.);große Klappe und nichts dahinter (ugs., salopp, variabel)
-(etwas) Neues wagen (floskelhaft);(eine) Vorreiterrolle übernehmen;der erste sein, der;vorpreschen (negativ);(die) Blaupause liefern (für) (fig.);(etwas) als erster tun;die erste sein, die;(der) erste sein (der ...);(ein) Zeichen setzen;vorangehen
-es regt sich kein Widerspruch;es gibt keinen Widerspruch;niemand widerspricht
-Berührungspunkte;Überschneidungen;Übereinstimmungen;Gemeinsamkeiten
-Sinngemäßes;Entsprechendes;Dementsprechendes;Ähnliches;Vergleichbares
-genug bestraft sein;(sein) Fett weg haben (ugs.);(die) verdiente Strafe bekommen (haben);bekommen (haben) was man verdient
-Gebietsabtretung;Gebietsverlust
-durch Treueschwur binden;verpflichten (auf);einschwören (auf)
-Überfall auf die Sowjetunion;Fall Barbarossa;Unternehmen Barbarossa (Eigenname);Weisung Nr. 21
-Kürzel;Namenszeichen;Namenskürzel;Paraphe
-(das) Plündern erlauben;zum Plündern freigegeben;zur Plünderung freigeben;(den) Plünderern überlassen
-(requirierte) Einsatzverpflegung;Furage;(requirierte) Verpflegung (militärisch);(requirierte) Feldverpflegung
-Feldverpflegung herbeischaffen;Einsatzverpflegung herbeischaffen;für Verpflegung sorgen;aus dem Lande leben;(sich) mit Lebensmitteln versorgen;für Furage sorgen;Verpflegung herbeischaffen;furagieren
-Pferdefutter;Futter und Streu (mil., Kavallerie);Fourage (franz.);Fourragierung;Furage
-(privater) Kriegsherr;Stammesführer;Warlord (engl.);Kriegsfürst
-Drogenboss (ugs.);Drogenbaron;Drogenproduzent
-Menschenschinder;Leuteschinder
-Sadist;Menschenquäler
-Wiege (fig.);Ursprung;Geburtsstätte (fig.)
-geruhsam;ruhig;bedächtig;in mäßigem Tempo;in langsamem Tempo;langsam
-Ostfeldzug;Deutsch-Sowjetischer Krieg;Großer Vaterländischer Krieg;Russlandfeldzug
-näherkommen;näherrücken;(sich) nähern;heraufziehen;heranrücken;herannahen (geh.);nahen (geh., literarisch)
-in das Reich der Fabel gehören;(eine) Ausgeburt der Phantasie darstellen;als Lüge bezeichnet werden
-Soldatin;Flintenweib;bewaffnete Frau
-Schöpfer (Hauptform);Erschaffer;Urheber (juristisch)
-Druckwelle;Dichtewelle;Verdichtungswelle;Kompressionswelle
-Journalistin (Presse) (franz., weibl.);Zeitungsmann;Journalist (Presse) (franz., männl.);Pressemann;Blattmacher
-einer vom Fernsehen (ugs.);Fernsehmann;Fernsehjournalist;Fernsehfritze (ugs.);Fernsehmacher
-ging über alle Sender;stand auf Seite eins (auch figurativ);war die Schlagzeile;ging durch alle Zeitungen;ging durch die Presse
-intensiv beworben;bekannt aus Funk und Fernsehen (floskelhaft, veraltend)
-(die) Werbetrommel rühren;werben für;Reklame machen;Werbung machen (für);(ein Produkt) bewerben
-Luoravetlanen;Tschuktschen
-einwickeln (fig.);einseifen (ugs.);(eine) heile Welt vorgaukeln;einlullen (ugs.);so tun als wenn alles in (bester) Ordnung ist
-nicht gewappnet gegen;nicht geschützt;nicht gerüstet;nicht ausgerüstet
-immer gegenwärtig;allgegenwärtig;ständiger Begleiter
-die eigenen Leute;die eigenen Reihen
-ohne Verbindung zur Einheit;versprengt (militärisch)
-(sich) immer weiter steigern;(sich) immer weiter hochschaukeln;hemmungslos eskalieren;(eine) Spirale von etwas in Gang setzen;immer schlimmer werden
-Floatprozess;Floatglasverfahren
-(sich) nur mit Mühe behaupten können;(viel / ständig) Gegenwind bekommen (fig.);mit (vielen) Widrigkeiten zu kämpfen haben;(einen) schweren Stand haben
-einebnen;dem Erdboden gleichmachen;völlig zerstören
-schleifen;abtragen;niederreißen
-pass auf, was du sagst (ugs.);überleg lieber bevor du was sagst (ugs.);hüte deine Zunge (geh.);vor Inbetriebnahme des Mundwerks Gehirn einschalten (ugs., Spruch);denk nach bevor du sprichst (ugs.)
-versuch's nur (ugs.);nicht mit mir (ugs.);versuch's doch mal (ugs.);nur über meine Leiche (ugs.)
-sieh zu wie du klarkommst (ugs.);ohne mich (ugs.);auf mich kannst du (dabei) nicht zählen;(jedenfalls) viel Spaß dabei! (ugs.);(dann) sieh mal zu (ugs.);rechne (aber) nicht mit meiner Unterstützung
-offene Stadt (militärisch);Stadt die nicht verteidigt wird
-Rufmordkampagne;Schmutzkampagne;Diffamierungskampagne;Hexenjagd (fig.)
-babylonisches Exil;babylonische Gefangenschaft
-(jemandem) (ein) Bedürfnis sein;(...) möchte;am Herzen liegen;(einen) Wunsch haben;(...) würde gerne;(jemandem) (ein) Anliegen sein
-was ist? (ugs.);was ist das Problem?;was ficht dich an? (ugs., altertümelnd, scherzhaft);was liegt an?;um was geht es (denn)?;wo brennt's? (ugs.);wo drückt der Schuh? (ugs., veraltend);worum geht's? (Hauptform);was hast du?;was gibt's? (ugs.)
-Expansionsventil;Drosselventil
-(soziale) Ungleichheit;Schere zwischen Arm und Reich (floskelhaft);Kluft;Einkommensunterschiede
-Atomwaffenkonvention;Nuklearwaffenkonvention
-nicht pünktlich fertig werden;überziehen;(die) Zeit überziehen
-(irgendwie) gepolt sein (ugs.);drauf sein (ugs.);denken und handeln;Einstellung haben;(irgendwie) eingestellt sein;ticken (ugs.)
-gnädig sein;(jemandem) nicht böse sein (können);auf (eine) Bestrafung verzichten;(etwas) nicht ahnden;von einer Bestrafung absehen;dann woll'n wir mal nicht so sein (ugs., Spruch);etwas mit dem Mantel der Nächstenliebe zudecken (ugs., sprichwörtlich);Nachsicht üben;(sich) nachsichtig zeigen;Gnade vor Recht ergehen lassen (floskelhaft);(etwas) nicht bestrafen;Milde walten lassen;barmherzig sein;Gnade walten lassen;(jemandem etwas) durchgehen lassen;beide Augen zudrücken (fig.);nicht zu streng sein;auf (eine) Strafe verzichten;(jemandem) etwas nachsehen
-Gehör schenken;zu Wort kommen lassen;reden lassen;seinen Standpunkt vertreten lassen
-Prügelbock;Strafbock
-Bastinado;Falaka (arabisch);Bastonade;Sohlenstreich (veraltet)
-Streckbank;Folterbank;Folterbett;Streckbett
-scharfe Frage;hochnotpeinliche Befragung;peinliche Befragung
-Hüftdysplasie;Hüftgelenkdysplasie;Hüftgelenksdysplasie
-Linsenektopie;Linsenluxation
-Schultergelenkluxation;Schulterluxation
-Buggelenk;Glenohumeralgelenk;Schultergelenk
-Chassaignac-Lähmung;Radiusköpfchen-Subluxation
-Teilausrenkung;Subluxation
-Stachelrolle;gespickter Hase
-Firmenzusammenschluss (ugs.);Unternehmensverbund;Unternehmenszusammenschluss (Ergebnis)
-Kooperation von Firmen;Kooperation von Unternehmen;Unternehmenszusammenarbeit
-Syndikat;Kartell
-Joint Venture (engl.);Arbeitsgemeinschaft;Interessengemeinschaft
-Zweckbündnis;strategische Allianz
-niemand sonst;kein anderer
-nicht weniger (...) (als);genauso (...) (wie);ebenso (...) (wie);geradeso (...) (wie);gleichermaßen (...);genauso gut;so (...) wie;nicht minder (geh.)
-empor...;auf...;aufwärts...;nach oben;hoch...;nauf... (regional);hinauf...;rauf... (ugs.)
-hinauswachsen (über);hinter sich lassen;größer werden
-Jungfraueninseln (veraltet);Jungferninseln
-Puerto-Ricanische Jungferninseln;Passage-Inseln (veraltet);Spanischen Jungferninseln
-wie angewurzelt stehenbleiben;zur Salzsäule erstarren (ugs.);wie erstarrt sein
-(ein) Arkadien (des/der ...) (geh.);Traumziel;(das) Mekka (der) (floskelhaft);Wunschland;El Dorado (spanisch);Land wo Milch und Honig fließen (Redensart, fig.);Eldorado (für)
-Eretz Israel (fachspr., hebräisch);(das) Land der Verheißung;(Land) Kanaan;(das) Gelobte Land
-Überflussgesellschaft;Land wo Milch und Honig fließen (fig.);(es herrschen) paradiesische Zustände;Schlaraffenland (fig.)
-zweite Heimat;Wahlheimat;neuer Lebensmittelpunkt;zweites Zuhause
-(ganz schön) abgebaut haben;(schwer) nachgelassen haben;(den) Erwartungen nicht mehr gewachsen sein;auch nicht mehr der sein, der man früher mal war
-keine Nachlässigkeit(en) dulden;(ein) strenges Regiment führen;sehr streng sein
-Triade;chinesische Mafia(organisation) (ugs.)
-Bandenchef;Gangsterboss;Kopf der Bande;Bandenführer
-Vierer-Formation;Vierergruppe;Viererteam;Vierercombo;Vierergespann (fig.);Quartett (fig.);Kleeblatt (fig.)
-Kreis;Versammlung;Schar;Gruppe;Kränzchen;Runde;Trupp (fig.);Grüppchen
-...geschwängert;erfüllt von;geschwängert von
-Name, Adresse, Telefon usw. (ugs.);Kontaktdaten
-(den) Kassenbestand ermitteln;(einen) Kassensturz machen (fachspr.);nachzählen;nachrechnen
-Fehlbetrag;(ein) Minus (in der Kasse);Manko;Kassendifferenz
-Mehrbetrag;Kassendifferenz;(ein) Plus (in der Kasse);Überschuss;Kassenüberschuss
-Paketsprung;Arschbombe (derb)
-Konkretisierung;Reduktion (auf einen konkreten Fall);Präzisierung;Eingrenzung;Verfeinerung
-Vergegenständlichung;Verdinglichung;Reifikation;Reifizierung
-teita gehen (ugs., Babysprache);ata ata gehen (ugs., Babysprache);ata gehen (ugs., Babysprache)
-tingeln;bummeln;tändeln
-verkehren (Amtsdeutsch, Jargon);pendeln;fahren
-Schnittenschaukel;Schlaglochsuchgerät;Blechbüchse;Hämorrhoidenschaukel
-Schlitten (ugs., aufwertend, fig., Hauptform);Schleuder (ugs., abwertend, fig.);Hobel (ugs., fig.);Flitzer (ugs.);Flunder (ugs., fig.);Kiste (ugs., fig., Hauptform);Karre (ugs., fig., Hauptform);Schüssel (ugs., fig.);Benzinkutsche (ugs., scherzhaft);Kalesche;Kutsche (ugs.);Karosse
-Straffreiheit;Straflosigkeit;Impunität
-Schnauze;Vorderansicht;Frontpartie;Vorderteil;Vorderseite;Front
-Rückseite;Heck;hinterer Teil;Hinterteil (ugs.);Arsch (derb)
-Innenverkleidung oben (ugs.);Himmel (Auto);Innenverdeck
-Kotflügel;Radkasten;Radabdeckung
-Strahlemann;Sonnyboy (ugs.);Dauerlächler;Dauergrinser (ugs.);Smiley (fig.);Grinsgesicht (ugs.)
-Berufsoptimist (ugs.);unverbesserlicher Optimist
-(sich) nicht die gute Laune vermiesen lassen;(die) Probleme nicht sehen (wollen);allzu optimistisch sehen;durch die rosarote Brille sehen (ugs., fig.);(sich) nicht die gute Laune verderben lassen
-Lagermentalität;Lagerdenken
-Veröffentlichung;Publikation;Verbreitung;Release (engl.);Herausgabe
-Nürnberger Exekutionstag;Friedensexekutionskongress
-Welscher Belchen;Elsässer Belchen
-hypothermischer Herzstillstand;tiefe Hypothermie
-Amtssprache;Gerichtssprache
-volkstümelnde Redeweise (abwertend);volkstümliche Redeweise;Volksmund
-gebrochenes Deutsch;Kurzdeutsch (fachspr., verhüllend);Gastarbeiterdeutsch;Kiezdeutsch (fachspr., aufwertend);rudimentäres Deutsch (fachspr.);schlechtes Deutsch;Ausländerdeutsch
-Amtsbereich;Gebietskörperschaft (fachspr., Hauptform, juristisch);Amtsbezirk;Verwaltungsgebiet;Verwaltungsbezirk;Verwaltungseinheit (Hauptform)
-türkendeutsche Jugendsprache;Kanak Sprak (abwertend);Türkendeutsch
-gesellschaftliche Differenzierung;Differenzierung;soziale Differenzierung
-Kefalonische Tanne;Griechische Tanne
-Westtürkische Tanne;Troja-Tanne;Kleinasiatische Tanne
-Nordmanntanne;Kaukasus-Tanne;Nordmann-Tanne;Nordmanns Tanne
-Weißtanne;Weiß-Tanne
-Pontus-Gebirge;Pontisches Gebirge;Nordanatolisches Randgebirge
-Bulgarische Tanne;König-Boris-Tanne
-Pluraletantum (fachspr.);Mehrzahlwort;Wort ohne Singular(form);Pluralwort
-Singularetantum (fachspr.);Einzahlwort;nicht-pluralfähiges Wort;Singularwort;Wort ohne Plural(form)
-Selbstläufer (ugs.);einfach lösbares Problem;Selbstgänger (ugs.)
-Numeralia;Numeralien
-(die) Hosen runterlassen (ugs., fig.);(die) Wahrheit preisgeben müssen;(die) ungeschminkte Wahrheit offenbaren;(die) Wahrheit sagen;mit der Wahrheit herausrücken;(einen) Offenbarungseid leisten (fig.)
-(einem) Blick ausweichen;(jemandem) nicht (gerade) in die Augen sehen (können);(einem) Blick nicht standhalten
-Lackierwerkstatt;Lackiererei
-guten Rutsch ins neue Jahr!;komm gut rüber!;guten Beschluss! (regional);guten Rutsch!;komm gut rein!
-(seine) geschiedene Frau;(seine) ehemalige Frau;(seine) Exfrau;(die) mit der er mal zusammen war;(seine) Verflossene;(seine) Ex;(seine) Verblühte;(seine) Exfreundin;(seine) Ehemalige
-Tragegestell;Räf (ugs., schweiz.);Kraxe (ugs., süddt., österr.);(Rücken-) Tragekorb;Reff (ugs., regional);Rückentrage (Hauptform);Trage;Kiepe (ugs., norddeutsch);Köze (ugs., regional);Kötze (ugs., regional);Traggestell
-(sich) opfern;(sein) Leben geben;(sein) Leben opfern
-(den) Strick nehmen (fig.);(sich) erhängen;(sich) aufhängen
-nach...;hinterdrein...;hinter etwas her;hinterher...;hinter jemandem her
-Lemniskatenlenker;Alsthom-Lenker (veraltet)
-Wertschöpfungskette;Wertkette
-Fehlproduktion;Fehldrucke;Makulatur (Druckwesen) (fachspr.);Ausschuss;Schrott
-magnetische Rekonnexion;Neuverbindung
-Subarachnoidealraum (fachspr.);Cavum subarachnoideale (fachspr., lat.);Cavum leptomeningicum (fachspr., lat.);Spatium subarachnoideum (fachspr., lat.);Cavum hyparachnoidicum (fachspr., lat.);Cavitas subarachnoidea (fachspr., lat.);Subarachnoidalraum (fachspr.);äußerer Liquorraum
-AMR-Effekt;anisotroper magnetoresistiver Effekt
-magnetischer Tunnelwiderstand;TMR-Effekt
-GMR-Effekt;Riesenmagnetowiderstand
-CMR-Effekt;kolossaler magnetoresistiver Effekt (selten)
-Trägerfrequenzverstärker;phasenempfindlicher Gleichrichter;Lock-in-Verstärker
-Vibrationsplatte;Rüttelplatte
-General;Ordensgeneral;Generalsuperior;Generaloberer
-im Klischee bleiben;(dem) Klischee entsprechen;(das) Klischee bedienen;ins Schema passen;alle Kriterien eines (...) erfüllen
-ungenutztes Land;unberührte Natur;Wildnis
-Punkt für Punkt;in jedem einzelnen Punkt;in vollem Umfang;vollinhaltlich
-im Wortsinn;wörtlich;wortwörtlich (zu verstehen);im eigentlichen Wortsinn;buchstäblich (ugs.);wörtlich zu verstehen;in des Wortes wahrster Bedeutung (geh.);nicht übertragen;literal (fachspr., linguistisch);im wahrsten Sinne des Wortes (ugs.)
-Event (engl.);Hype-Event;Spektakel;besonderes Ereignis;Großereignis;Hypeevent;Spektakulum (lat., scherzhaft)
-(den) richtigen Ton treffen;(die Art) wie man etwas sagt;Der Ton macht die Musik. (ugs., Sprichwort, kommentierend);(den) rechten Ton treffen
-mäßige deinen Ton! (geh.);mäßigen Sie Ihren Ton! (geh.);wie redest du mit mir!? (ugs.);nicht in dem Ton (, ja?!) (ugs.);kommen Sie mir nicht so! (ugs.);ich verbitte mir diesen Ton! (geh.);komm mir nicht so! (ugs.);wie reden Sie mit mir!? (ugs.);nicht in diesem Ton! (ugs.)
-ja, aber;schön und gut (aber) (ugs.);Das ist ja richtig (aber);schon richtig (aber);gut und schön (aber) (ugs.)
-Afrika-Jahr;Afrikanisches Jahr;1960
-Entkolonisierung;Dekolonisation;Dekolonisierung
-Eigenkapitaldecke;Eigenkapitalquote
-Dardanellen-Vertrag;Meerengenvertrag
-Pontische Republik;Republik Pontos
-Endotrachealtubus (fachspr.);Beatmungstubus
-in Gesellschaft;nicht allein;in Begleitung;unter Leuten;unter Menschen;mit anderen zusammen
-in guter Gesellschaft (mit);nicht allein dastehen (mit);(mit etwas) nicht alleinstehen (fig.);nicht der einzige (sein) der;in bester Gesellschaft (mit) (oft ironisch);nicht die einzige (sein) die;(sich) in guter Gesellschaft befinden (fig.)
-einmal muss Schluss sein;irgendwann muss (auch) (mal) gut sein
-Haar-Raum;Haarscher Raum
-dozieren;in belehrendem Ton sprechen;predigen
-kein Ende finden;endlos weiter...;(gar) nicht wieder aufhören (zu);unaufhörlich weiter...
-(etwas) schleifen lassen;schlabbern (lassen) (ugs.);nicht regelmäßig (tun);nur unregelmäßig (tun);vernachlässigen
-Arbeiterstrich (derb);Tagelöhnermarkt;Tagelöhnerbörse
-Heuermann (historisch);Wanderarbeiter;Heuerling (historisch);Saisonarbeiter;Saisonnier (schweiz., österr.);Saisonier (schweiz., österr.);befristet Beschäftigter
-Überqueren der Grenze;Passieren einer Grenze;Grenzübergang;Betreten eines (fremden / anderen) Staatsgebiets;Grenzübertritt
-Verlassen des Staatsgebiets;Ausreise
-ausreißen;(jemandem) weglaufen (Hauptform);durchbrennen (ugs.);ausbüxen;stiften gehen (ugs.);(jemandem) auskommen;Reißaus nehmen (veraltend);entlaufen;das Weite suchen (ugs.);sich aus dem Staub machen (ugs.)
-(sich) verflüchtigen (scherzhaft);(sich) davonstehlen;(sich) dünnemachen (ugs.);(sich) verdrücken;(sich) fortstehlen;(sich) verpissen (derb);(sich) abseilen (ugs., fig.);(sich) von der Truppe entfernen (fig.);(sich) davonschleichen;(sich) dünne machen (ugs.);entschwinden (lit.) (geh., literarisch, scherzhaft);(sich) in die Büsche schlagen (fig.);(sich) verdünnisieren (ugs., scherzhaft)
-(einen) flotten Schuh machen (ugs.);(sein) Bündel schnüren (fig.);(den) Abgang machen (ugs.);(die) Biege machen (ugs.);(den) Adler machen (ugs.);Leine ziehen (ugs., salopp);in die Ferne schweifen (geh.);(einen) Abgang machen (ugs.);(die) Fliege machen (ugs.);(den) Sittich machen (ugs.);(sich) vom Acker machen (ugs.);mit unbekanntem Ziel verreisen (ironisch, variabel);(die) Flatter machen (ugs.);(das) sinkende Schiff verlassen (ugs., fig.);(sich) aus dem Staub machen (ugs.);(einen) langen Schuh machen (ugs.);(das) Weite suchen (ugs.);(die) Flocke machen (ugs.);(die) Kurve kratzen (ugs.)
-Poulsen-Sender;Lichtbogensender
-entzaubert;aller Illusionen ledig (geh.);desillusioniert;aller Illusionen beraubt (geh.);ernüchtert (Hauptform);(wieder) in der Wirklichkeit angekommen;ohne (noch) irgendwelche Illusionen (variabel);(wieder) in der Realität angekommen
-feuerbestatten;verbrennen;kremieren (schweiz.);einäschern
-Hochachtungsvoll;Mit freundlichem Gruß (förmlich);Es grüßt;Freundlich grüßt Sie;Mit freundlichen Grüßen (förmlich);Freundlich grüßt;MfG;Es grüßt Sie;Mit vorzüglicher Hochachtung;Freundliche Grüße (sendet Ihnen)
-Ingrier;Ischoren
-finno-ugrisches Volk;Finno-Ugrier;finnougrisches Volk
-Olaf Schubert;(das) Wunder im Pullunder
-Quadraturphasenumtastung;Vierphasen-Modulation
-(sich) verhärten;(sein) Herz verschließen (lit.);(etwas) nicht an sich heranlassen
-grüß Gott! (süddt.);seien Sie gegrüßt (geh.);ich grüße Sie;sei gegrüßt (geh.);grüß euch!;Gott zum Gruße;grüß dich! (ugs.);sei mir gegrüßt;seien Sie mir gegrüßt
-Siegesrausch;Triumphgefühl;Triumph;Siegestaumel
-Ende;(das) Aus;Scheitern
-in triumphierender Haltung;triumphierend;mit triumphaler Geste
-hartherzig;ohne Mitgefühl;fühllos;kalt;mitleidlos;herzlos;lieblos;kaltschnäuzig;kaltherzig
-unfair;unsportlich;regelwidrig;nicht fair
-ungerecht;nicht in Ordnung;nicht fair;unfair;nicht gerecht;nicht okay
-widerspruchslos hinnehmen;als gegeben hinnehmen;Ja und Amen sagen (ugs., fig.);kommentarlos schlucken;(einer Sache) ohne wenn und aber zustimmen;fraglos akzeptieren
-Arkosolium;Arkosol
-aktiver Mitarbeiter (einer politischen oder sozialen Bewegung);politisch (sehr) aktiver Mensch;Aktivist (Hauptform)
-an den Start gehen (Rennen);ins Rennen gehen
-es nicht unter (...) machen;es muss mindestens (...) sein
-unterste Grenze;untere Schranke;kleinster Wert;Minimum;untere Grenze
-Offizium;Tagzeitengebet;Tagzeiten;Stundengebet
-Kongregation für die Glaubenslehre;Glaubenskongregation
-sollen;über drei Ecken erfahren haben (ugs.);so erzählt man (sich) (Einschub);über zig Ecken erfahren haben (ugs.);(etwas) so gehört haben;(etwas) aus (un)sicherer Quelle haben;(nur) vom Hörensagen (wissen);nicht aus eigener Anschauung (wissen);(sich von etwas) nicht persönlich überzeugt haben;(etwas) wurde mir zugetragen;(etwas) hat man mir erzählt;nicht selbst gesehen haben;(etwas) aus (un)sicherer Quelle wissen;so heißt es (Einschub);(etwas) wurde mir erzählt
-dort befindlich;dortig;dort gelegen;dort ansässig;dort vorzufinden
-von weither angereist;weitgereist;von weither gekommen
-ungekämmt;ungebügelt;ungepflegt (Hauptform);ungewaschen;unrasiert
-ausgebeult (Hose);bollerig (ugs., westfälisch);ausgeleiert (ugs.);verbeult;ausgeweitet;baggy (Modestil) (Jargon, engl.);überweit;geweitet (Kleidung)
-Rosenkreuzer;Rosenkreutzer
-Vorabendserie;Soap (engl.);Seifenoper
-vegetarische Ernährungsweise;vegetarische Lebensweise;Vegetarismus;(überzeugt) vegetarische Lebenseinstellung
-(jemanden) beuteln;(jemanden) heimsuchen;(jemandem) zusetzen;(jemanden) plagen;(jemanden) befallen
-führend;(der) erste;renommiert
-(etwas) auf sich halten;um sein Renommee besorgt sein;auf seinen guten Ruf achten;(sich) nichts nachsagen lassen wollen
-mit Niveau;von Klasse;mit Eleganz und Stil
-häufig nennen;(ständig) im Munde führen;häufig gebrauchen (Namen, Wort);oft erwähnen
-Vox populi, vox Dei (lat.);Die öffentliche Meinung zählt.;An der öffentlichen Meinung kommt niemand vorbei.
-Vox populi, vox Rindvieh. (ugs.);Du musst nicht alles glauben, was in den Zeitungen steht. (ugs.);Hör nicht auf das, was die Leute sagen. (ugs.)
-ist nicht (ugs.);geht nicht (bei jemandem) (ugs.);is nich (ugs., norddeutsch);Flötepiepen! (ugs., regional, westfälisch);Satz mit X - war wohl nix! (ugs., Spruch);hat sich was mit (ugs.);(es) wird nichts (mit etwas) (ugs.);(es) wird nichts (aus etwas) (ugs.);hat sich nix mit (ugs.);kommt nicht in Frage
-(ist) abgelehnt;negativ (Jargon);kommt nicht in Frage;nein
-Halbfertigprodukt;Halbfabrikat
-Fertigerzeugnis;Fertigfabrikat
-Bundesstaat;Gliedstaat;Teilstaat
-Verschränkung;Interleaving (engl.);Versatz
-Operationshemd;OP-Hemd;Engelchenhemd (ugs.)
-mit Mühe und Plage;im Schweiße meines Angesichts (ugs.);hart (erkämpft);sauer (verdient) (ugs.)
-Stuhlmeister;Meister vom Stuhl;Logenmeister
-Schwedisches Lehrsystem;Schwedisches Ritual;Schwedischer Ritus
-Augenspiegelung;Ophthalmoskopie (fachspr.);Funduskopie
-Spaltlampe;Spaltlampenmikroskop
-nordischer Rechtskreis;skandinavischer Rechtskreis
-historische Rechtsschule;geschichtliche Schule der Rechtswissenschaft
-Freiwilligkeit;Entscheidungsfreiheit;Willensfreiheit;freier Wille
-Informationsvisualisierung;Datenvisualisierung
-Visualisierung;Veranschaulichung
-Reynolds-gemittelte Navier-Stokes-Gleichung;Reynolds-Gleichung
-Word! (ugs., engl.);aber sicher! (ugs.);da sagst du was! (ugs.);ja genau (ugs.);korrekt (ugs.);aber ja!;Sie sagen es! (ugs.);du sagst es! (ugs.);ja (Hauptform);exakt (ugs.);definitiv! (ugs.);positiv (fachspr., Jargon);roger! (fachspr., Jargon, engl.);genau (ugs.);absolut! (ugs.);da sagen Sie was! (ugs.);stimmt;yep (szenesprachl.) (ugs.);stimmt genau;hundertprozentig! (ugs.)
-Kartoffelkloß;Höbes (ugs.);Erdäpfelskluß (ugs.);Kartoffelknödel;Hebes (ugs.);Hüts (ugs.);Reiberknödel;Gleeß (ugs.);Kleese (ugs.);Knölle (ugs.);Klump (ugs.);Halbseidene Knödeln;Grüne Klöße;Huller (ugs.);Gniedla (ugs.);Klunz;Knödeln halb und halb;Rohe Klöße;Grüngenüffte;Knölla;Griene Glees (ugs.);Thüringer Klöße;Hütes (ugs.);Reibeknödel;Halbseidene Klöße;Griegeniffte (ugs.);Grügeniffte (ugs.);Klüeß (ugs.)
-Abstinenzbewegung;Temperanzbewegung;Temperenzbewegung
-soziale Bewegung;Bewegung
-Abstinenzverein;Temperanzgesellschaft
-soziale Norm;gesellschaftliche Norm;soziales Skript
-Erziehungsphilosophie;pädagogische Theorie;Erziehungskonzept
-Kriegsgegner;militärischer Gegner;Konfliktpartei (verhüllend)
-Steuersünder (verhüllend);Steuerhinterzieher
-sparen (verhüllend);(die) Neuverschuldung begrenzen;weniger neue Schulden machen;weniger Neukredite aufnehmen
-(sich) aus dem Fenster hängen (fig.);(sich) vorwagen;vorpreschen (fig.)
-Steuerstraftat;Steuerhinterziehung
-Bagatelldelikt;lässliche Sünde (fig.);Kavaliersdelikt (Hauptform)
-Schmu machen (ugs.);schwindeln;tricksen;kungeln (ugs., regional);mogeln;schummeln;täuschen;mauscheln (ugs.)
-Körpersprache;Gestik;Gebärdenspiel
-Arbeitsgestaltung;Arbeitssystemgestaltung (veraltet);Systemgestaltung (veraltet)
-Pfundskerl (ugs.);patenter Kerl (ugs.);(ein) guter Kumpel (sein) (ugs.);famoser Kerl (ugs.);(jemand) zum Pferde stehlen (ugs., fig.);mit jemandem kann man Pferde stehlen (ugs., fig.);echter Kumpel (ugs.);schwer in Ordnung (sein) (ugs.);(en) Töfften (sein) (ugs., ruhrdt., veraltend)
-zuverlässig sein;auf jemanden ist Verlass (ugs.);(jemand) ist eine sichere Bank;(sich) verlassen können (auf);(auf jemanden) bauen können (fig.)
-Kriegsdienstverweigerung;Wehrdienstverweigerung
-Wohnungsvermieter;Hauswirt;Vermieter
-Häuslebesitzer (ugs.);Hauseigentümer;Hausbesitzer
-Lateinamerikanische Schuldenkrise;Lateinamerikakrise
-Flagge zeigen (fig.);offen eintreten für;Farbe bekennen
-aus (reiner / purer) Langeweile;weil jemandem nichts Besseres einfällt;weil jemand nichts Besseres zu tun hat
-(sich) einhängen;Arm in Arm;einhaken;untergehakt;einander den Arm geben;(sich) einhenkeln (ugs.)
-EMV-Prüfung;EMV-Untersuchung
-Vorrangstraße (österr.);Vorfahrtsstraße
-Prophetenkuchen;Huckelkuchen;Fettpfützenkuchen;Platzkuchen;Thüringer Platz;Aufläufer
-Schmierkuchen;Breikuchen;Schmandkuchen
-Hand-Fuß-Mund-Krankheit;Hand-Fuß-Mund-Exanthem;Falsche Maul- und Klauenseuche
-Patschhändchen (ugs.);Händchen (Kinderhand, Kinderhände);Patschehändchen (ugs., scherzhaft)
-Drecksfinger (ugs., aggressiv);dreckige Finger;Futtfinger (ugs., regional);Wichsgriffel (derb);Fottfinger (ugs., regional);Pottfinger (ugs., regional)
-Wurstfinger (ugs., abwertend);dicke Finger
-auf die Tube drücken (ugs., veraltend);aufs Tempo drücken (ugs.);beschleunigen (aktiv);(mehr) Tempo machen (ugs.);(eine) Schüppe Kohlen drauflegen (ugs., ruhrdt.);(eine) Schippe zulegen (ugs.);Gummi geben (ugs.);(Tempo) anziehen (ugs.);Kette geben (ugs.);volle Kraft voraus fahren;(die) Geschwindigkeit erhöhen (Hauptform);(einen) Schritt zulegen;reinhauen (ugs.);(die) Schlagzahl erhöhen (ugs.);(einen) Schlag zulegen (ugs.);schneller machen (ugs.);Gas geben (ugs.);(einen) Zahn zulegen (ugs.)
-los...;in Bewegung geraten;an...;in Gang kommen;(sich) in Bewegung setzen (Hauptform);es kommt Bewegung (in eine Sache)
-Drehbrasse;Drehbasse
-bei Adam und Eva anfangen (ugs.);(ganz) von Anfang an erzählen;(die) ganze Geschichte erzählen
-(eine) kleine Weltreise (machen) (fig.);weiträumig umfahren;(einen) großen Umweg machen
-Blattnerv;Blattrippe;Blattader
-differenzieren (geh.);distinguieren (geh., selten);unterscheiden;trennen;(einen) Unterschied machen (zwischen);(eine) Unterscheidung treffen;auseinanderhalten;nicht verwechseln
-getrennte Wege gehen (fig.);nicht mehr zusammen sein (ugs.);kein Paar mehr sein;(sich) trennen;auseinander sein (ugs.);(sich) scheiden lassen (wollen);Schluss machen (ugs.);(jemandes) Wege trennen sich (fig.);auseinandergehen
-(die) Beziehung beenden;Schluss machen (mit) (ugs.);in die Wüste schicken (ugs.);(jemanden) abschießen (ugs.);(jemandem) den Laufpass geben (geh., fig.);(jemanden) in den Wind schießen (ugs., salopp);(jemanden) abservieren (ugs., salopp)
-(sich) nichts mehr zu sagen haben;(sich) entfremden;(sich) fremd werden;nebeneinander her leben;(sich) auseinanderleben
-zusammenknallen (ugs., fig.);in Streit geraten (mit) (Hauptform);aneinandergeraten (ugs.);(einen) Streit beginnen;Streit bekommen;(sich) in die Wolle kriegen (ugs., fig.);(einen) Streit vom Zaun brechen (fig.);das Kriegsbeil ausgraben (ugs., fig.);Streit anfangen;Krach kriegen (ugs.);(sich) in die Wolle geraten (ugs., fig.);(sich) anne Köppe kriegen (ugs., ruhrdt.);(sich) in die Haare kriegen (ugs., fig.)
-Streit suchen (Hauptform);(jemanden) anmachen (ugs.);(jemanden) blöd von der Seite anquatschen (ugs.);(einen) Streit provozieren;(sich) mit jemandem anlegen;(einen) Streit vom Zaun brechen;(jemanden) provozieren;Händel suchen (veraltet)
-(einen) Strauß ausfechten;(einen) Streit austragen (Hauptform);bis zur Entscheidung kämpfen;(einen) Streit zur Entscheidung bringen
-(sich) bekriegen;(sich) anfeinden;(sich) befehden
-(sich) bekeifen;(sich) angiften;(sich) ankeifen
-Stallwache (haben) (fig.);auf seinem Posten bleiben;nicht weggehen (ugs.);der einzige vor Ort sein;(als Letzter) dableiben (ugs.);Bereitschaft haben (Arbeitswelt);(die) Stellung halten (fig.)
-(jemandem) (eine) Scheinsicherheit vorgaukeln;(jemanden) in Sicherheit wiegen;einlullen
-faken (ugs.);(etwas) vortäuschen;(etwas) vorgaukeln;(den) Anschein erwecken;(den) Eindruck erwecken (als sei ...);so tun als ob;(etwas) vorspiegeln;(etwas) inszenieren (geh.);(die) Illusion erwecken;blauen Dunst vormachen;(sich) als ... inszenieren (geh.);(sich) (den) Anschein geben;(etwas) vorspielen;markieren (ugs.)
-unrealistische Erwartungen wecken;goldene Berge versprechen;(das) Blaue vom Himmel versprechen
-(sich) zerschlagen (Hoffnungen) (fig.);zunichtemachen;begraben müssen (die Hoffnungen auf ...) (fig.);zerplatzen (Träume) (fig.);nicht Realität werden;zunichte machen;(sich) nicht erfüllen;(sich) als Illusion herausstellen;(in sich) zusammenfallen wie ein Kartenhaus (ugs.);(sich) als unrealistisch erweisen;nicht in Erfüllung gehen;(zer)platzen wie eine Seifenblase;zunichtegemacht werden;zunichte gemacht werden (Hoffnung);(sich) nicht realisieren
-(sich) korrigieren;(eine) Rolle rückwärts machen (fig.);abrücken von;zurückrudern (fig.);(etwas) zurücknehmen
-(jemandem) gewogen sein;einer von den Guten sein (ugs., scherzhaft);zu den Guten gehören (ugs., scherzhaft);nichts (gegen jemanden) haben (ugs.);(jemandem) nichts Böses wollen;(jemandem) nichts wollen (ugs.);auf jemandes Seite stehen;(jemandem) nichts tun wollen;(es) gut meinen (mit)
-nicht wahrhaben wollen;Realitätsverweigerung betreiben (geh.);nicht anerkennen;nicht akzeptieren wollen;nicht zugeben wollen;(etwas) nicht gelten lassen (Hauptform)
-(miteinander) versöhnen;(miteinander) aussöhnen;Frieden stiften;befrieden (geh.);pazifizieren
-(den) Kopf in den Sand stecken (vor) (fig.);(eine) Vogel-Strauß-Politik betreiben;(etwas) verdrängen
-Maseltov! (jiddisch);gut Holz!;Petri Heil!;Hals- und Beinbruch!;viel Erfolg! (Hauptform);alles Gute (für ...)!;gutes Gelingen!;toi toi toi! (ugs.);Weidmannsheil! (neuere Schreibung);viel Glück!;Waidmanns Heil! (ältere Schreibung);gute Verrichtung! (auch humor.)
-erster Eindruck;Primäreffekt (psych.) (fachspr.)
-(einen) guten Eindruck hinterlassen;(einen) guten Eindruck machen;überzeugend wirken
-Kugel (ugs.);Sphäre (fachspr.);Kugeloberfläche (fachspr.)
-Kugel (ugs.);Kugelkörper (fachspr.)
-Vollkugel (fachspr.);Kugel (ugs.);Kugelfläche und Kugelkörper (zusammengenommen)
-Stern (ugs.);Himmelskörper (ugs.)
-leichte Alkoholvergiftung (fachspr.);dicker Kopf (ugs.);Schädel (ugs.);Brummschädel (ugs.);schwerer Kopf (ugs.);postalkoholisches Intoxikationssyndrom (fachspr.);Hangover (engl.);Katzenjammer;Haarspitzenkatarrh (ugs., veraltend);Veisalgia (fachspr.);dicker Schädel (ugs.);Kater (ugs.);Katerstimmung;Alkoholintoxikation (fachspr.)
-Schädelspalter (ugs., fig.);Fusel (ugs.);Sterbehilfe (ugs., fig.);billiger Alkohol
-nicht mehr der Alte (sein);(sich) ändern;nicht mehr die Alte (sein);(sich) verändert haben;(ein) anderer Mensch (sein);anders (sein);(etwas) macht einen anderen Menschen (aus jemandem);(ein) anderer Mensch werden;nicht wiederzuerkennen (sein);wie ausgewechselt (sein)
-monströs dick;massiv;tonnenförmig;ungestalt;unförmig;aus der Form geraten;monströs
-sehr loben (Hauptform);(jemandem) großes Lob spenden;(jemandem) hohes Lob zollen (geh.);(einer Sache / jemandem) Weihrauch spenden (geh., fig.);(sehr) rühmen;(ein) dickes Lob aussprechen;(ein) Loblied anstimmen (auf);lobpreisen;in den Himmel heben;(sich) in Lobestiraden ergehen (geh., abwertend);in den höchsten Tönen loben;(sich) in Lobeshymnen ergehen;(jemandem einen) Lorbeerkranz flechten (geh., fig.);(jemandes) Lob singen;(jemandem) Lorbeerkränze flechten (geh., fig.);in den höchsten Tönen reden (von);(jemandem) ein großes Lob aussprechen;des Lobes voll (sein) (geh.);über den grünen Klee loben (ugs.);(sich) in Lobtiraden ergehen (abwertend);voll des Lobes (sein) (geh.);(jemandes) Loblied singen;hymnisch loben (geh.)
-(eine) gute Bewertung bekommen;(viel) gelobt werden;nur Gutes hören (von);(die) Lorbeeren ernten
-bekannt für;(jemand) soll ... sein;angesehen werden (als);(einen / den) Ruf (als ...) genießen (geh.);(jemanden) halten für;(jemandem) wird nachgesagt (dass / zu);gelten als;man hört (etwas von jemandem) (ugs.);(jemandem) eilt der Ruf voraus (dass / zu);eingeschätzt werden (als);(einen / den) Ruf genießen (zu) (geh.);(den) Stempel weghaben (dass) (ugs.);in dem Ruf stehen (zu + Infinitiv) (geh.);(den) Ruf haben (zu)
-schriftlich haben;beweisen können;schwarz auf weiß haben;(den) Beweis haben
-(et)was tun (ugs.);aktiv werden;Hand anlegen;nicht untätig bleiben;(et)was machen;(eine) Maßnahme ergreifen;(etwas) unternehmen gegen;(eine) Maßnahme treffen (formell);zur Tat schreiten (geh.);in Aktion treten;tätig werden
-Account;Zugangsberechtigung;Zugang
-(jemandem etwas) einschärfen;(jemandem etwas) (unmissverständlich) klarmachen;(jemandem etwas) eintrichtern (ugs.);(jemandem etwas) einbläuen (ugs.);(jemanden) ermahnen
-Rüpelhaftigkeit;Krawallmacherei;Pöbelei;Rüpelei;provokantes Auftreten;Flegelhaftigkeit;Flegelei;Grobheit;Rowdytum
-(eine) Schwangerschaft unterbrechen;wegmachen (derb);abtreiben (ugs.)
-abtreiben (lassen) (ugs.);wegmachen lassen (derb);(einen) Schwangerschaftsabbruch vornehmen (lassen) (Amtsdeutsch);(die) Schwangerschaft unterbrechen lassen
-(es) gäbe (da) einiges zu erzählen;(dazu) könnte man (jetzt) viel sagen;(ein) eigenes Kapitel (fig.);(ein) Kapitel für sich (ugs., fig.);(ein) Fall für sich;(ein) eigenes Ding (sein) (mit / um)
-(eine) andere Geschichte;nicht zum Thema gehören;eine andere Baustelle (sein) (ugs.);um etwas anderes gehen (es);nichts zur Sache tun;(ein) anderes Thema (sein);(ein) Kapitel für sich (sein);nichts zu tun haben mit;auch so eine Geschichte (sein) (ugs.);(jetzt / hier) nicht der Punkt sein
-Privatmann;Privatier;(sich) ins Privatleben zurückgezogen haben (variabel);(sich) aus (dem Geschäftsleben) zurückgezogen haben (variabel);finanziell unabhängig (sein)
-schlimmstenfalls;am Ende;womöglich;nachher;wenn es ganz schlimm kommen sollte
-Wartestand (veraltet für höhere Beamte; kirchenrechtl. u.a. für evangelische Pfarrer);einstweiliger Ruhestand
-im Wartestand (sein) (fig.);auf der Reservebank sitzen (fig.);nichts zu tun haben;auf der Ersatzbank sitzen (fig.);(eine) Warteschleife drehen (fig.)
-Kampf der Wagen und Gesänge (lit.);Autorenwettbewerb;Poetry Slam (engl.);Dichterwettstreit
-Internet-Zugangsanbieter;Provider (engl.);Internetanbieter (ugs.);Internetdienstanbieter;Internetprovider (ugs.);Internetdienstleister
-Fleischerbeil;Fleischbeil
-Volksredner;(ein) Demosthenes;Agitator
-geschmackssicher;stilsicher;stilbewusst
-(einen) guten Geschmack haben;Geschmack (haben);Sinn für Stil (haben)
-Arbiter Elegantiae (geh., veraltet);Sachverständiger in Fragen des guten Geschmacks;Arbiter Elegantiarum (geh., veraltet)
-Kampfradler;Radrowdy;Rüpelradler
-rücksichtsloser Skifahrer;Pistensau;Ski-Rowdy
-Harsch;Sulzschnee (schweiz.);Altschnee;Firn;Firnschnee
-vorbeikommen;dahergelaufen kommen;angelaufen kommen;daherkommen;(irgendwoher) (+ Partizip Perfekt) kommen (veraltend);angeschlappt kommen (ugs.);angedackelt kommen (ugs.);angefahren kommen;um die Ecke kommen (ugs.);gesprungen kommen (ugs., süddt.);angeschoben kommen (ugs.);des Weg(e)s kommen (geh., veraltend)
-Kampfblatt;Tendenzblatt;Verbandszeitschrift;Zentralorgan (fig., ironisch)
-Kunstrichter;Kunstkritiker
-Schmierlapp (ugs.);Schmierlappen (ugs.);Widerling
-hart ins Gericht gehen (mit) (fig.);verreißen;in der Luft zerreißen (fig.);schweres Geschütz auffahren (fig.);vernichtend kritisieren;kein gutes Haar lassen (an) (fig.);massive Kritik üben (an) (geh.);scharf kritisieren;in die Tonne treten (derb);(jemandem etwas) um die Ohren hauen (ugs., fig.);(ein) Verriss (sein);schwere Geschütze auffahren (fig.);in Grund und Boden verdammen;(Punkt für Punkt) auseinandernehmen (ugs., fig.)
-alliiertes Vorbehaltsrecht;alliiertes Kontrollrecht
-büchernärrisch;biblioman;bibliophil;buchverliebt
-Bücherfreund;Literaturbegeisterter;Buchliebhaber;Bibliophiler;Büchersammler;Bücherfreak
-Kollektioneur (geh., schweiz.);Sammler (Hauptform)
-Kunstform;Kunst;Kunstrichtung
-Geschlechtsleben;Sexleben;Sexualleben
-Theaterunternehmer;Impresario (veraltet);Theaterproduzent;Produzent
-Manager;Impresario;Vermittler;Promoter;Agent
-atypische Beschäftigung;prekäres Beschäftigungsverhältnis;prekäre Beschäftigung;informelle Beschäftigung (fachspr.)
-sozialversicherungspflichtig beschäftigt;in einem Normalarbeitsverhältnis
-auf Werkvertragsbasis Beschäftigter;Werkvertragsarbeitnehmer;Werkvertragsmitarbeiter;Werkverträgler;per Werkvertrag Beschäftigter
-Matthäus-Effekt;The winner takes all. (engl.);Wer hat, dem wird gegeben.;Der Teufel scheißt immer auf den größten Haufen. (ugs., Hauptform, variabel)
-arbeitnehmerähnlicher Selbständiger;Scheinselbständiger
-als Praktikant mitarbeiten;als Praktikant beschäftigt sein;im Praktikum (sein);(ein) Praktikum machen;als Praktikant tätig sein;Praktikant (sein)
-(einen) 450-Euro-Job haben;auf 450-Euro-Basis beschäftigt;geringfügig beschäftigt
-1-Euro-Job;Arbeitsgelegenheit (mit Mehraufwandsentschädigung);AGH-MAE
-Fulltime-Job (engl.);Vollzeitjob;Vollzeitstelle;Ganztagsarbeit;Ganztagsbeschäftigung
-ganz in Anspruch nehmen (Arbeit);ganz ausfüllen (Arbeit);(jemandes) Erfüllung sein
-Normalarbeitsverhältnis;unbefristete sozialversicherungspflichtige Vollzeitstelle
-Ästhet;Freund der schönen Künste;Belesprit (franz.);Schöngeist
-kunstliebend;an Kunst interessiert;kunstinteressiert;den schönen Künsten zugetan;kunstsinnig;kunstverständig;künstlerisch angehaucht (ugs.);Kunst liebend
-guter Mensch (profanisiert) (ugs.);schöne Seele;Verkörperung des Wahren, Guten und Schönen (in einer Person)
-Kurzbiographie;Porträt (fig.);Steckbrief (fig.);Vorstellung (einer Person);Charakterbild;Portrait (fig.)
-viel gepriesen;vielgepriesen;hoch gelobt;hochgelobt
-Sieger;strahlender Held;strahlender Sieger;Held;Heroe;Heros
-härtere Gangart (gegen) (fig.);schärferes Vorgehen (variabel)
-Strafverfolgungsorgane;Strafverfolgungsbehörden;Ermittlungsbehörden;Polizei und Staatsanwaltschaft
-bereit, sich zu wehren;kampflustig;wehrhaft
-halbamtlich;offiziös
-Webgestaltung;Design von Webseiten;Webdesign
-streitbar;kriegerisch;kämpferisch;kampfbereit;kampflustig
-Scharade;Charade
-der Zufall will;wie der Zufall (so) spielt;wie es der Zufall will (...);es trifft sich (dass)
-Schmalz;Gefühlskitsch;Rührseligkeit;Herz und Schmerz
-Pathetik;Theatralik;aufgesetztes Pathos
-(jemanden an einen Ort) verschlagen (Hauptform);unterkommen (ugs.);(irgendwo) stranden (fig.);landen (ugs., fig.);hingekommen sein (ugs.);(sich) (irgendwohin) verlaufen (ugs., fig.)
-Straßenroller;Culemeyer (ugs.)
-Datenflussplan;Datenflussdiagramm
-Zahnüberzahl;Hyperdontie (fachspr.);Hyperodontie (fachspr.)
-Pannenhelfer;gelber Engel (ugs.)
-notorischer Lügner;pathologischer Lügner;Lügenbold;gewohnheitsmäßiger Lügner;Lügenbaron (fig.)
-wie üblich;wie (schon) immer;(etwas ist / war) nicht ungewöhnlich;wie sonst auch;wie bereits bekannt;unverändert;wie zuvor (auch);wie gewöhnlich;alles beim Alten;weiter wie bisher;wie gehabt (ugs.);wie eh und je;nichts Außergewöhnliches;wie gewohnt;das Übliche
-Auslassungszeichen;Ellipsenzeichen
-Auslassung (von Wörtern, Satzteilen oder Buchstaben) (variabel);Weglassung
-Nullkraftsockel;Nullkraftfassung
-kaum mit anzusehen;(schon) nicht mehr feierlich;darf eigentlich nicht sein;schwer erträglich (geh.);so langsam reicht es (wirklich) (ugs.);(schon) nicht mehr schön
-(so) langsam reicht es (ugs.);mir langt's allmählich (mit) (ugs.);Genug ist genug!;(so) langsam reicht's (mir)! (ugs.);das ist (jetzt) allmählich nicht mehr feierlich (ugs.);allmählich hab ich die Schnauze voll! (ugs.);allmählich reicht es;jetzt hört's aber auf! (ugs.);(so) langsam hab ich die Faxen dicke (ugs.);mir reicht's! (ugs.);Das Maß ist (jetzt) langsam voll.
-(das) kann es nicht sein;(das) darf nicht sein
-heißer Stuhl (fig.);Armsünderstühlchen;Anklagebank (fig.)
-(am) Katzentisch (ugs., fig.);(im) Abseits (fig.)
-selbige;diese und jene;sie;ebendiese;diese;die;jene
-Exzess-3-Code;Stibitz-Code
-interessiert jemanden nicht (besonders);nicht das Richtige (für);jemand hat's nicht so (mit) (ugs.);(da) steht jemand nicht (unbedingt) drauf (ugs.);(etwas ist) uninteressant (für);nicht (so) mein Ding (ugs.);(ein) ...muffel (sein) (mediensprachlich);nichts am Hut haben (mit) (ugs.);nichts für mich (ugs.);(damit) hat jemand es nicht so (ugs.);liegt jemandem nicht;da hat jemand keinen Vertrag mit (ugs., salopp);(jemand ist) nicht so der (die) ... (ugs., salopp);nicht meins (ugs.)
-in Bewegung;im Fluss (sein);(noch) in Entwicklung
-Cui bono? (lat.);Wem nützt es?;Wer hat etwas davon?
-(sich) notieren;protokollieren (fachspr.);(schriftlich) aufzeichnen;(sich) aufschreiben;mitschreiben
-durch Schreiben verarbeiten;niederschreiben;(sich) von der Seele schreiben
-Gewöhnliche Limette;Persische Limette;Tahiti-Limette
-Mexikanische Limette;Echte Limette;Saure Limette
-evaporierte Kondensmilch;Büchsenmilch;Kondensmilch;Dosenmilch
-Sticky Note (engl.);Haftnotizzettel;Post-it (Markenname);gelber Klebezettel (ugs.);gelber Zettel (ugs.);Haftnotiz;Haftie
-Schokoladentrüffel;Trüffel-Praline;Buttertrüffel;Truffes (schweiz.)
-(das) Praliné;(das) Pralinee;(die) Praline
-Hindlauf (ugs., regional);Gewöhnliche Wegwarte;Sonnenwendel (ugs., regional);wilde Endivie (ugs.);Zichorie;Wegwarte;Irenhart (ugs., regional);Zichorium intybus (fachspr., botanisch);verwünschte Jungfrau (ugs., regional, österr.);rauer Heinrich (ugs., regional);Wegleuchte (ugs., regional);Hindläufte (ugs., regional);Gemeine Wegwarte;Hansl am Weg (ugs., regional);Kaffeekraut (veraltet);Rattenwurz (ugs., regional)
-Sibirische Schwertlilie;Wiesen-Schwertlilie
-Purpur-Waldvöglein;Rotes Waldvöglein
-Echte Arnika;Arnica montana (fachspr., lat.);Bergwohlverleih
-Wald-Akelei;Gemeine Akelei;Gewöhnliche Akelei
-Blutströpfchen;Blutauge;Kleines Teufelsauge;Sommer-Adonisröschen;Sommerblutströpfchen
-Wilde Tulpe;Weinberg-Tulpe;Wald-Tulpe
-Widdertod;Rundblättriger Sonnentau;Herrgottslöffel;Himmelslöffelkraut;Spölkrut;Himmelstau
-Lavendelheide;Rosmarinheide;Poleirosmarinheide;Polei-Gränke;Sumpfrosmarin
-Berg-Sandglöckchen;Bergnelke;Berg-Sandrapunzel;Schaf-Skabiose;Sandknöpfchen
-Sandrapunzel;Sandglöckchen
-Kartäusernelke;Steinnelke (österr.)
-Drachenwurz;Schweinsohr;Schlangenwurz;Schlangenkraut;Sumpf-Schlangenwurz;Sumpf-Calla;Sumpfkalla
-Stranddistel;Meer-Mannstreu
-Doldenblütler;Doldengewächs
-Gewöhnliche Küchenschelle;Gewöhnliche Kuhschelle
-Breitblättriger Fingerwurz;Breitblättriges Knabenkraut
-Kiebitzei;Schachbrettblume;Schachblume
-Soldanelle;Alpenglöckchen
-Alpentroddelblume;Gewöhnliches Alpenglöckchen;Großes Alpenglöckchen (schweiz.);Alpen-Soldanelle
-Kornnelke;Kornrade;Klockenblume (niederdeutsch);Ackerrade;Pisspöttken (rheinisch);Kornrose
-Blut-Storchschnabel;Blutroter Storchschnabel
-Blauroter Steinsame;Blaurote Rindszunge;Purpurblauer Steinsame
-Steinsamen;Rindszungen
-Raublattgewächs;Borretschgewächs
-Doldige Schwanenblume;Wasserliesch;Schwanenblume;Blumenbinse;Wasserviole
-Gelbe Moorlilie;Ährenlilie;Beinbrech;Moorlilie
-Bisamdistel;Nickende Distel
-Zustandsreduktion;Kollaps der Wellenfunktion
-wegen des bestehenden Interesses;da es auch andere interessiert;aus Neugier;interessehalber
-Mittelmaß;Mittelmäßigkeit;Durchschnitt;Mediokrität
-Dämon;Schreckgespenst;böser Geist
-Schatten;schemenhafte Gestalt;Schemen
-Flaschengeist;Dschinn
-schrecklicher Gedanke;Albtraum (fig.);Horrorvorstellung
-Gnathologie;Funktionsdiagnostik
-zeitweilige Begleitung;Kurschatten
-gute Freundin;beste Freundin;Freundin;Vertraute;enge Freundin
-Autorschaft;Urheberschaft;Autorenschaft
-(sich) nicht (mehr) zurechtfinden;nicht (mehr) durchblicken (ugs.);den Wald vor lauter Bäumen nicht sehen (fig.)
-zu viel werden;zu weit führen;den Rahmen sprengen
-(das) Gegenteil bewirken;(einen) gegenteiligen Effekt haben;(sich / etwas) ins Gegenteil verkehren;kippen;umdrehen;(sich) genau entgegengesetzt auswirken;ins Gegenteil umschlagen;zurückschlagen (Pendel)
-in die entgegengesetzte Richtung;entgegengesetzt;(einander) entgegen
-(jemandem etwas) in den Mund legen (fig.);(jemandem) die Worte im Mund verdrehen;(jemandem) das Wort im Mund umdrehen
-Pokerface (engl.);Maskengesicht;unbewegte Miene
-nicht ja und nicht nein;(etwas) lässt sich nicht mit einem klaren Ja (oder Nein) beantworten;ein entschlossenes Sowohl-als-Auch (ironisch);ja und nein;jein
-Lifestyle;Lebensstil;Lebensart
-über die ganzen Jahre;all die Jahre;in der ganzen (langen) Zeit;über die Jahre;in all den Jahren;all die Jahre lang
-herauskaufen;freikaufen;(die) Ablösesumme bezahlen (für)
-Essenz;Infus;Extrakt;Aufguss;Perkolat;Sud;Mazerat;Absud;Dekokt;Auszug;Destillat;Tinktur;Konzentrat
-Auslöse;Spesen;Tagesspesen;Verpflegungsmehraufwand;Auslösung
-Sittsamkeit;Sitte und Anstand
-am Lager (fachspr., Jargon, kaufmännisch);ist da;zu kaufen;erhältlich;haben wir da (ugs.);lieferbar;käuflich zu erwerben;(bei uns) zu bekommen;im Angebot;liegt vor;auf Lager;zu haben;verfügbar;vorrätig;vorhanden;im Bestand
-gehen Sie (doch) vor!;bitte nach Ihnen!
-(jemandem) eigen sein;(jemanden) charakterisieren;(jemanden) kennzeichnen;(jemanden) auszeichnen;(jemandem) zukommen
-vermissen lassen;(einer Sache) gebrechen (geh., veraltet);kranken an (geh.);(jemandem) abgehen;(jemandem) fehlen;(jemandem) nicht zu Gebote stehen (geh.);(es) fehlen lassen (an);nicht verfügen über;(einer Sache) ermangeln (geh.)
-(sich) gruppieren;Position einnehmen;Aufstellung nehmen;(sich) aufstellen;antreten;(sich) positionieren;(sich) formieren;in ...erreihen antreten;in Stellung gehen
-mit Bedacht;in weiser Voraussicht (ugs.);vorausschauenderweise;wohlweislich;zur Vorsorge;vorsorglich
-früher als normalerweise;seiner Zeit voraus (geh., scherzhaft);vor der Zeit;ungewöhnlich früh(zeitig);vorzeitig;verfrüht (Hauptform);zu früh;früher als sonst;früher als üblich
-nicht zur rechten Zeit;ungelegen;ungünstig;unzeitig;im denkbar ungünstigsten Moment;unpassend;zur Unzeit
-man kann sich mit jemandem sehen lassen;(sich) zu benehmen wissen;(sich) benehmen können;(eine) gute Kinderstube (genossen) haben;gute Manieren haben
-seine gute Kinderstube vergessen;seine gute Erziehung vergessen;(sich) vergessen
-damenhaft;wie eine Dame;wie eine (richtige) Lady;ladylike
-(für) einen Augenblick;vorübergehend;mal kurz;kurz mal (ugs.);mal eben;(ein / ein paar) Minütchen (ugs., fig.);kurz (ugs.);(für) einen Moment;(für) einen kurzen Moment
-Trickkünstler;Eskamoteur
-festangestellt;eine feste Anstellung (haben);fest angestellt
-vor jemandes Karren gespannt werden (fig.);(nur) ein billiges Werkzeug sein (für) (ugs., variabel);(nur) benutzt werden;herhalten müssen (für);missbraucht werden;ausgenutzt werden;instrumentalisiert werden;(sich) benutzen lassen
-Grundüberzeugungen;Wertekatalog;Wertordnung;Wertvorstellungen;Wertesystem;Wertekanon;Werte
-(die) Kleine;Nesthäkchen;(der) Jüngste (Hauptform);Benjamin;(der) Jüngste im Bunde;(die) Jüngste (Hauptform);(unser) Jüngstes;Nestküken;(die) Jüngste im Bunde;(der) Kleine;(unser) Kleinstes
-Geschwisterreihe;Geschwisterfolge
-flächenhaftes Naturdenkmal;Flächennaturdenkmal
-(es) zieht wie Hechtsuppe (ugs.);zugig;(es gibt) Durchzug;(es) zieht
-heftiger Windstoß;orkanartiger Windstoß;Sturmböe;Sturmbö
-Neubelebung;frischer Wind (fig.);mit frischem Mut;neuer Schwung
-Taurotragus oryx (fachspr., griechisch, lat.);Elenantilope;Eland
-(den) Stier bei den Hörnern packen (fig.);(sich) reinstürzen (ugs.);(sich) nicht lange bitten lassen (fig.);nicht lange fackeln (Hauptform);(sich etwas) nicht zweimal sagen lassen (fig.);nicht lange überlegen (und anfangen);offensiv angehen;sofort loslegen (ugs.);(sich) gleich in die Arbeit stürzen (ugs., fig.)
-sich kümmernd;rührend besorgt;treu sorgend;treusorgend
-Kameraoperateur;Schwenker
-politisch links stehend;vaterlandslose Gesellen (ugs., Schlagwort, abwertend, historisch, politisch);linksorientiert;links;(eine) rote Socke (sein) (ugs., abwertend, fig.);kommunistisch (sein) (Hauptform);sozialistisch;linksgerichtet;rot
-pink;zartrot;rosig;rosig;schweinchenrosa (abwertend);rosarot;pastellrot;rosé;babyrosa;rosa;blassrot;rosafarben;fleischfarben;mattrot
-Sozialismus light (ugs.);sozialistisch angehaucht
-links;der SPD zuzuordnen;sozialdemokratisch
-lachsfarben;lachsfarbig;lachsrosa;lachs;lachsrot;in Lachs
-Schonen;Schonlandt (veraltet)
-(ein) leichtes Spiel;(eine) einfache Sache;Heimspiel (fig.);keine (allzu) große Herausforderung
-(jedenfalls) nicht an Minderwertigkeitskomplexen leiden (ugs.);(sich) für den Größten halten;seiner Sache (sehr) sicher sein;seiner (selbst) sehr sicher sein;(sehr) von sich überzeugt sein;keine Selbstzweifel kennen
-die Sache ist geritzt (ugs., veraltend);das wäre das(, und jetzt ...);das wäre erledigt;die(se) Sache hätten wir hinter uns;das hätten wir geschafft
-Senior Cabin Crew Member (fachspr., Jargon, engl.);Purserin (fachspr., Jargon);Purserette (fachspr., Jargon);Kabinenchefin (fachspr.)
-Aktenhengst (humorvoll abwertend) (ugs.);Sesselfurzer (derb);Büroangestellter;Bürohengst (ugs.);Schreibtischtäter (ironisch)
-(jemandem in sein Gefährt) hineinfahren;(jemandem) reinfahren (ugs.)
-(einen) Auffahrunfall verursachen;(jemandem) hinten reinfahren (ugs.)
-Abstimmungsergebnis;Votum
-amerikanische Flagge;Stars and Stripes (engl.)
-munter (weiter...);ungeniert;unverdrossen;frisch, fromm, fröhlich, frei (veraltend);lustig (weiter...);fröhlich (weiter);immer munter;einfach weiter;einfach nicht aufhören (zu)
-Du machst mir Spaß! (ugs.);Du bist lustig! (ugs.);Du hast gut reden! (ugs.);Wie kannst du (nur) so etwas sagen! (ugs.);Du bist witzig! (ugs., ironisch);Du hast Nerven! (ugs.);Du kannst gut (daher)reden. (ugs.);Du bist vielleicht ein Herzchen! (ugs.);Du bist gut! (ugs.)
-die Dinge beim Namen nennen (Redensart, fig., Hauptform);sagen, wer dahintersteckt;(klar) sagen was los ist;sagen, was Sache ist (ugs.);(die) Verantwortlichkeit (klar) benennen;sagen, was ist (ugs.);das Kind beim Namen nennen (Redensart, fig.);Namen nennen;Ross und Reiter nennen (Redensart, fig.)
-Das wird ja was werden! (ugs.);Das kann ja was werden! (ugs.);Das kann ja heiter werden! (ugs.);Da steht uns (sicherlich) (noch) einiges bevor.;Das kann ja lustig werden! (ugs.);Das fängt ja gut an! (ugs.)
-Verteidigungsforschung;Rüstungsforschung
-Erbzinsleihe;Erbpacht
-anbelfern (selten);andonnern (selten);anbrüllen;anraunzen (selten);anschnauzen (ugs., Hauptform);(jemanden) anfahren (ugs., Hauptform);ankläffen (fig., selten);anbellen (fig., selten);anblaffen (ugs., selten);anschreien
-Spanleitplatte;Spanleitstufe;Spanteiler
-Wendeplatte (ugs.);Wendeschneidplatte
-(sich) bemerkbar machen;nicht schweigend dasitzen;Laut geben;(sich) melden;nicht einfach abwarten (ugs.)
-(anfangen zu) bellen;anschlagen (Hund);Laut geben
-(etwas) von sich hören lassen;(mal) durchklingeln (ugs.);(sich) melden;(mal) anrufen
-aufstrecken (ugs., schweiz.);(die) Hand heben;strecken (südwestdt.) (ugs.);aufzeigen (Unterricht) (ugs.);(sich) melden
-nicht im Sinne des Erfinders;nicht der Sinn der Sache;so nicht gedacht;nicht so gedacht;so nicht vorgesehen;anders gedacht;anders geplant
-(gibt es) Wünsche, Anregungen, Kritik;habt ihr noch was?
-(etwas) klar haben;(etwas) geklärt haben;(genau) wissen, was man will;wissen, in welcher Weise man vorgehen will;eine klare Vorstellung von etwas haben;klare Vorstellungen von etwas haben
-Steuerparadies;Steueroase
-Verteidigungsfall;V-Fall
-Hochburg (fig.);fest in der Hand (der / des)
-Orientale (veraltet);Araber
-Wörterbuchform;Nennform;Zitierform;Grundform
-Drehort;Schauplatz;Location (engl.)
-Bayerisches Landesmuseum für Geschichte;Museum der Bayerischen Geschichte;Museum für bayerische Geschichte
-Akademischer Kunststil;Akademischer Realismus;Akademizismus;Akademismus
-Wirkstoff;(aktive) Substanz
-Adler;Aar (geh., poetisch)
-Jalousie;Stabzugladen (veraltet)
-Carbon (ugs.);Kohlenstofffaserverstärkter Kunststoff;Carbon-faserverstärkter Kunststoff;CFK (Abkürzung)
-Lageenergiespeicherkraftwerk;Hubspeicherkraftwerk
-Schnüffler;Spurensucher;Stöberer
-Lizentiat;Lizenziat
-(sich) glücklich schätzen (können);von Glück reden können;(jemand) soll froh sein (ugs.)
-hellsehen können;prophetische Gabe(n) (haben);hellseherische Fähigkeiten (haben);(das) zweite Gesicht (haben)
-Personenmehrheit;Kollektiv
-Anzahl von Personen;Personenkreis
-Pentaeder;Fünfflach;Fünfflächner
-Hexaeder;Sechsflach;Sechsflächner
-Zehnflächner;Dekaeder;Zehnflach
-Zwölfflächner;Zwölfflach;Dodekaeder
-Schneestaub;Feinschnee;Pulverschnee
-(für jemandes) Unterhalt aufkommen;dafür sorgen, dass Geld reinkommt;(jemanden) versorgen;hungrige Mäuler stopfen (veraltend);(jemanden) unterhalten;am Kacken halten (vulg.);(jemanden) durchbringen;(sich) krummlegen (für) (ugs.);(jemanden) aushalten
-zusehen dass;dafür sorgen dass
-Superhaufen;Supergalaxienhaufen
-Lokaler Superhaufen;Virgo-Superhaufen
-Bärengruppe;Ursa-Major-Gruppe
-galaktischer Haufen;offener Sternhaufen
-negativer Attraktor;Repellor
-Fornax-II-Galaxienhaufen;Eridanus-Galaxienhaufen
-Fornax (fachspr.);Chemischer Ofen
-Naturbursche;Naturmensch
-auf dem Dorf;auf dem flachen Land(e);auf dem Lande;auf dem platten Land(e);auf dem Land;im ländlichem Raum (fachspr.)
-unter Landbewohnern;in der ländlichen Bevölkerung
-in der Stadt;in den Städten
-unter uns Pastorentöchtern (ugs.);dir kann ich es ja sagen (ugs., floskelhaft);unter uns gesagt;im Vertrauen (gesagt);(aber) das bleibt (jetzt) unter uns (Einschub) (ugs.);entre nous (geh., franz., veraltet);(jetzt mal) unter uns Betschwestern (ugs.)
-in Bergeseinsamkeit;in der Abgeschiedenheit der Berge
-unabhängig voneinander operieren;nicht mehr zusammenarbeiten;eigene Wege gehen;getrennte Wege gehen
-(von irgendwo) wegkommen;(sich) loseisen (ugs.);(sich) frei machen;(von irgendwo) loskommen
-es heißt;verlautbart werden (geh.);verlautbaren (geh.);zu erfahren sein;bekannt werden;es hieß
-Kahlschlag (fig.);Massenentlassung;Kündigungswelle;Entlassungswelle;Rationalisierung
-es sehr eilig haben;es kann (jemandem) nicht schnell genug gehen;es muss(te) alles sehr schnell gehen;es konnte (jemandem) nicht schnell genug gehen
-Sendezeitraum;Sendeplatz (fachspr.)
-schallnachahmend;onomatopoetisch;lautmalerisch;lautmalend
-Peano-Axiom;Peano-Postulat;Dedekind-Peano-Axiom
-abwegig;kraus;widersinnig;verworren;unverständlich;ungereimt;versponnen;verrückt;nicht stimmig;unsinnig
-ungereimt;reimlos
-Prosa;Erzählkunst
-in gereimter Form (verfasst);durch Reim(e) verbunden;gereimt;in Versen;in Versform
-Klangverwandtschaft;Lautähnlichkeit;ähnlich klingend
-durch Reim verbunden (sein);in Reimen enden;(sich) reimen (auf)
-(eine) Dichtung;(ein) literarisches Kunstwerk
-Geh mir aus der Latüchte! (norddeutsch);Geh (mir) aus dem Licht!;Geh mir aus der Latichte! (Nebenform);Ich seh' nichts!;Geh mir aus der Sonne!
-intervallfixe Kosten;sprungfixe Kosten
-Nadelrad nach Wartenberg;Anästhesiometer nach Wartenberg;Wartenbergrad
-Skin-Effekt;Stromverdrängung
-Kopplungswiderstand;Transferimpedanz
-Leitungswellenwiderstand;Kabelimpedanz;Nennimpedanz
-akustische Mikroskopie;Ultraschallmikroskopie;Akustomikroskopie
-Ausbreitungsmaß;Fortpflanzungskonstante;Ausbreitungskonstante
-Impulsfahrplan;Wellenfahrplan
-fertig zum Aufbruch;abmarschbereit;(bereits) in Hut und Mantel (veraltend);fertig angezogen;gestiefelt und gespornt (ugs.);startklar
-lebhafte Phantasie;blühende Phantasie;rege Einbildungskraft;(eine) ins Kraut schießende Phantasie;überbordende Fantasie
-es geht aufwärts (mit);(gut) vorankommen;florieren;prosperieren;aufwärts;gedeihen;gut gehen (Geschäfte);(sich) gut entwickeln;gut laufen (es);(sich) erfreulich entwickeln;wachsen, blühen und gedeihen;wächst, blüht und gedeiht
-Radialbeschleunigung;Zentripetalbeschleunigung
-angeschrieben werden;Post bekommen
-(jemanden) in Stellung bringen;(jemanden) aktivieren;(jemanden) ansetzen (auf);(jemanden) in Alarmbereitschaft versetzen
-im Verborgenen liegen;im Dunkeln liegen (fig.);nicht erkennbar sein;verborgen bleiben;im Dunkeln bleiben;nicht zu erkennen sein
-Kaschierung;Vernebelung;Verschleierung;Bemäntelung;Vertuschung;Obfuskation (fachspr., IT-Technik)
-Lektüre;(das) Durcharbeiten;(das) Lesen;Rezeption
-Lesestoff;etwas zu lesen;etwas zum Lesen (ugs.);Lektüre
-Magazin;Illustrierte;Freizeitzeitschrift (veraltet);Publikumszeitschrift;Zeitschrift;Journal (franz.)
-periodisch erscheinend (Druckwerk);Periodikum (Hauptform);fortlaufendes Sammelwerk;regelmäßig erscheinend (Druckwerk)
-um Vergebung bitten;um Verzeihung bitten;sagen, dass es einem leid tut (ugs.);um Entschuldigung bitten;in den Beichtstuhl gehen (geh., fig.);(sich) entschuldigen;Abbitte leisten (geh.)
-kein Verständnis aufbringen (für);kein Pardon gewähren;(etwas) nicht entschuldigen;(etwas) nicht einsehen wollen;kein Pardon kennen
-auf dem Absprung (sein);kurz davor (sein) aufzuhören
-viel reden und (dabei) nichts sagen;leeres Stroh dreschen (ugs.);(hohle) Phrasen dreschen (ugs.)
-verunstalten;verunzieren (geh.);entstellen;verhunzen (ugs.);deformieren;verschandeln
-(es) nicht anders gewollt haben (ugs.);(jemandes) eigene Schuld (ugs.);(jemandes) eigene Doofheit (derb);(jemandes) eigene Dummheit (ugs.);Wer nicht hören will, muss fühlen. (ugs., sprichwörtlich);(So viel) Dummheit muss bestraft werden. (ugs., sprichwörtlich);selbst schuld (sein) (ugs.);(es) nicht anders wollen (ugs.);(seine) gerechte Strafe erhalten (variabel);das hat er jetzt davon! (ugs.);(etwas) verdient haben;(etwas) nicht anders verdient haben (ugs.);das hast du (jetzt) davon! (ugs.);(das) gönne ich (jemandem);(jemandem) recht geschehen;(sich) selbst zuzuschreiben haben;selber schuld (ugs.);das kommt davon (wenn) (ugs., Spruch)
-Dickes Ehrenwort! (ugs.);Ich versprech's! (ugs.);Verlass dich drauf.;Du kannst dich darauf verlassen.;Großes Indianer-Ehrenwort! (kindersprachlich) (ugs.);Versprochen! (ugs.)
-selten;Mangelware;knapp;sehr wenig;kaum;rar
-aus eigener Kraft handelnd;ohne Hilfe;ohne Anregung;ohne Antrieb von außen;selbstständig
-(jemanden) unter die Erde bringen;für jemandes Tod verantwortlich sein;(der) Nagel zu jemandes Sarg sein;dafür sorgen, dass jemand nicht (zu) lange lebt
-Selbstmord begehen (fig.);sein eigenes Grab schaufeln (fig.);(sich) selbst zugrunde richten;seinen eigenen Untergang herbeiführen;(sich) sehenden Auges in den Abgrund stürzen (fig.)
-(sich) selbst schaden (Hauptform);am Ast sägen, auf dem man sitzt (fig.);(sich) (selbst) ins Knie schießen (fig.);(sich) ins eigene Fleisch schneiden (fig.);(sich) ins eigene Knie schießen (fig.);am eigenen Ast sägen (fig.)
-dem Herdentrieb folgend;blind (fig.);wie die Lemminge (ugs.);blindlings;gedankenlos
-Legalismus;Legismus
-(es) kommt Bewegung in (eine Sache);es passiert (et)was;in Bewegung kommen (fig.);es tut sich was (ugs.);es geschieht etwas
-(jemanden) in seinem Überschwang dämpfen;auf den Boden der Tatsachen (zurück)holen;(die) Flügel stutzen (fig.);(jemandem) die Flausen im Kopf austreiben;(einen) Dämpfer verpassen;(jemanden) bremsen;(jemanden) (wieder) auf Normalmaß bringen (fig., variabel)
-Sparte;Sektor;Geschäftszweig;Wirtschaftszweig;Branche
-Äquilibristik (fachspr.);Kunst des Gleichgewichthaltens
-diskutabel;(darüber) ließe sich reden;diskussionswürdig;(darüber) lässt sich streiten
-sehr wohl;leicht;locker (ugs.);man riskiert nicht viel (wenn man sagt);ohne weiteres;trefflich;durchaus
-schnelles Geld machen;schnell (viel) Geld verdienen;(eine) schnelle Mark machen (ugs.);(den / einen großen / seinen / ordentlich ...) Reibach machen (ugs.);(die) schnelle Mark machen (ugs.);(kräftig) abräumen (ugs.);(einen) schnellen Euro machen (ugs.)
-Gemengelage;Durcheinander;Verflechtungen;unübersichtliche Situation
-Chaotik;chaotisches Verhalten
-Chaotik;Regellosigkeit;Hin und Her;Anarchie (fig.);Beliebigkeit;Wirrnis;Unordnung
-Trockenschrank;Trockenkammer
-Viskosität;Konsistenz
-Begriffsumfang;Extension
-Begriffsinhalt;Intension
-Korporatismus;Korporativismus
-Ätznatron;NaOH (fachspr.);kaustisches Soda;Natriumhydroxid
-Erdnussbutter;Erdnusscreme;Erdnusspaste;Erdnussmus
-Wärme;Entropie (griechisch)
-passt auf!;pass auf!;aufgepasst!;Spitz pass auf (ugs., Spruch, veraltend);passen sie auf!;Hab acht! (veraltet);aufpassen!;Augen auf im Straßenverkehr! (ugs., Spruch);Vorsicht!;Vorsichtig (mit) ...!;Achtung!;Holzauge, sei wachsam! (ugs., Spruch);Obacht! (süddt., österr.);Augen auf!
-Silbernitrat;Höllenstein
-Mitisgrün;Patentgrün;Pariser Grün;Schweinfurter Grün
-Eisenkies;Pyrit (griechisch);Narrengold;Katzengold;Eisensulfid;Schwefelkies
-Kalkspat;Calcit;Kalzit;Doppelspat
-politische Korrektheit;political correctness (engl.);Gutmenschentum (Schlagwort, negativ);Tugendterror (Schlagwort, abwertend)
-Spaß beiseite!;(jetzt) mal im Ernst
-(sich) nicht weiter beschäftigen (mit);beiseitelegen;(eine Weile) liegen lassen
-und sei es nur (dass / weil / wegen ...);schon allein
-und seien es nur (geh.);angefangen mit;und sei es nur (dass / weil / wegen ...) (geh.);angefangen bei;schon allein
-Gewährleistungsbürgschaft;Gewährleistungsgarantie
-verfügen (können) über;zu Gebote stehen;vorhanden (sein);verfügbar (sein)
-(innerlich) abwesend;wie die Ölgötzen (ugs.);teilnahmslos;unbeteiligt;wie ein Ölgötze (ugs.);gleichgültig;desinteressiert
-Aug' in Aug' (einander gegenüber);einander gegenüber;face to face (engl.);wie zwei Porzellanhunde (ugs., selten)
-(einander) mit den Augen fixieren;(sich) in die Augen starren;(sich) mit (den) Blicken fixieren;(sich) (gegenseitig) anstarren;(einander) mit Blicken durchbohren
-zusammenge...;zurechtge...;hinge...
-Konstabler;Konstabel
-hingehudelt (ugs.);zusammengewichst (ugs.);hingeschmiert (ugs.);zusammengehudelt (ugs.);zusammengepfuscht (ugs.);zusammengekloppt (ugs.);hingerotzt (ugs.);ohne Sorgfalt erstellt
-Büchsenschütz;Büchsenmeister
-(sich) aufbrezeln (ugs.);(sich) schick anziehen;(sich) in Schale schmeißen (ugs.);(sich) auftussen (ugs.);(sich) herausputzen;(sich) schön machen;(sich) zurechtmachen (ugs.);(sich) stylen (ugs.);(sich) aufhübschen;(sich) schick machen;(sich) in Staat werfen;(sich) piekfein anziehen (ugs.);(sich) ausstaffieren;(sich) stadtfein anziehen;(sich) auftakeln;(sich) aufdonnern (ugs.);(sich) fein machen;(sich) hochstylen (ugs.);(sich) in Schale werfen (ugs.);(sich) piekfein machen (ugs.)
-(sich) werfen in (ugs.);(sich / jemanden) ankleiden;(sich) schmeißen in (ugs.);(sich / jemanden) anziehen;(sich / jemandem) Kleidung anlegen;(sich / jemanden) bekleiden
-Namibischer Befreiungskampf;Namibischer Unabhängigkeitskampf
-unfertig;noch nicht abgeschlossen;noch nicht fertiggestellt;(noch) im Aufbau
-(noch in der) Entwicklung;Erprobungsphase;Versuchsphase;Testphase;(noch) in den Kinderschuhen stecken (fig.);Pilotphase;Experimentierstadium;Versuchsstadium
-in statu nascendi (geh., lat.);im Entstehungsprozess;im Entstehen;im Werden
-erst in Umrissen erkennbar;erst allmählich Gestalt annehmen
-Wahlkölner;Imi (kölsch)
-Teilungsversteigerung;Auseinandersetzungsversteigerung
-(sich) vor den Zug werfen;(sich) vor einen Zug werfen
-sichtlich;deutlich;merklich (Hauptform);erkennbar;ersichtlich (geh., veraltet);spürbar
-zu erahnen;zu spüren sein;wahrnehmbar;man kann es förmlich spüren (floskelhaft);fühlbar;spürbar;in der Luft liegen
-Ringelschwanzbeutler;Gewöhnlicher Ringbeutler
-Ringelschwanzbeutler;Ringbeutler
-hochfliegend;anspruchsvoll;hoch;vornehmst;hehr (Ziel o.ä.);hochgesteckt (Hauptform);erhaben;beeindruckend
-Ihro Fürstliche Gnaden (Anrede) (veraltet);der Herr Fürst;Ihre Fürstliche Gnaden;Durchlaucht (Anrede für regierenden Fürsten);S. D. (in Anschriften);Seine Durchlaucht (in Anschriften);der Fürst
-im jugendlichen Alter von;mit zarten (...) Jahren;im zarten Alter von (ugs.);mit süßen (...) (Jahren);zählte kaum (...) Lenze (geh., poetisch);mit seinen kaum (...) Jahren;mit gerade mal (...) (Jahren);mit ihren kaum (...) Jahren
-Schlacht in den Karpaten;Winterschlacht in den Karpaten;Karpathenschlacht
-(ein) Arme-Leute-Essen;einfaches Essen
-(jemandem) nichts vormachen (können);wissen was gespielt wird;nicht von gestern (sein) (ugs.);ausgeschlafen (sein) (ugs.);nicht auf der Brennsuppn dahergeschwommen (sein) (ugs., bayr.)
-Totenkopfaffe;Totenkopfäffchen
-Schlagwetter (bergm.);schlagende Wetter (bergm.);Grubengas
-Geleucht (Bergbau) (fachspr.);Grubenlampe
-matte Wetter (bergm.);verbrauchte Luft;sauerstoffarme Luft
-(...) Jahre auf dem Buckel haben (ugs.);es auf (...) Jahre bringen;(...) Lenze zählen (lit. oder veraltet);Jahrgang (...) sein;(...) sein;(...) geboren sein;(...) Jahre zählen (veraltet);im Jahr(e) (...) geboren sein;(...) Jahre jung sein;(...) Jahre alt sein (Hauptform)
-(alter) Opa mit Hut (ugs., veraltet);alter Mann;(so'n) Oller (ugs., norddeutsch);(so'n) Opi (ugs.);alter Sack (derb, abwertend);alter Knacker (ugs., abwertend);(so'n) Opa (ugs.)
-Traumfrau;Klasseweib;Superweib;Frau seiner Träume
-Jugendliche (Hauptform, weibl.);Teenie;Backfisch (veraltet);Teen;Teenager (weibl.);Kid (ugs., engl.);junges Ding (weibl.)
-in den Zwanzigern;in seinen Zwanzigern (männl.);Twen;in ihren Zwanzigern (weibl.)
-falscher Fünfziger (ugs., scherzhaft);falscher Fuffziger (ugs., scherzhaft);(ein) Fünfzigjähriger
-(jemandem) entgegengehen;zukommen (auf);zugehen (auf);(jemandem) entgegenkommen
-Todesritt der leichten Brigade;Attacke der Leichten Brigade
-virtuelle Geschichte;kontrafaktische Geschichte;Uchronie
-Gedankenversuch;Gedankenexperiment
-Maxwell-Dämon;maxwellscher Dämon
-Zwillingsparadoxon;Uhrenparadoxon
-Verwendungsansatz;Verwendungsrechnung
-DomRep (ugs.);Dominikanische Republik
-top-down (engl.);von oben nach unten;deduktiv
-Ätznatron;Ätzsoda
-(etwas) eng sehen (ugs.);(es) genau nehmen (mit);auf Kleinigkeiten herumreiten;(etwas) verkniffen sehen (ugs.);(sich) kleinlich anstellen
-locker bleiben (ugs.);großzügig über etwas hinwegsehen;(etwas) locker sehen (ugs.);keine Probleme haben (mit)
-(etwas) genau nehmen;(es) genau nehmen (mit);(etwas) ernst nehmen;(es mit etwas) ernst meinen;keinen Spaß verstehen (mit / bei)
-blutiger Ernst (sein);(mit etwas ist) nicht zu spaßen;Ernst sein (mit) (jemandem ist es Ernst mit);kein Spiel (sein);(eine) ernste Sache (sein)
-die paar Euro (ugs.);(nur) Centbeträge;das bisschen Geld (ugs.);so'n bisschen Geld (ugs.);so'n paar Euro (ugs.)
-(sich) plötzlich konfrontiert sehen mit;(jemandem) vor die Füße fallen (ugs., fig.)
-bottom-up (engl.);von unten nach oben;induktiv
-Asiatisches Wildpferd;Przewalski-Pferd;Mongolisches Wildpferd
-Raubgold;Nazigold
-Kivu-Krieg;dritter Kongokrieg
-Paläo-Tschad;Mega-Tschad
-man sagt ja (auch);wie sagt man so schön;wie sagt man noch gleich;wie heißt es noch gleich bei (Goethe o.ä.) (variabel);wie heißt es so schön
-(so) als ob;ganz so, als (wenn);(so) als wenn
-Xenismus;Fremdwort;Lehnwort
-Wortform (fachspr., Hauptform);syntaktisches Wort;Flexiv;Flexionsform;Wort mit Flexionsmerkmalen (fachspr.);flektiertes Wort
-morphologisches Wort (fachspr.);Wort
-generisches Maskulinum;maskulines Generikum;Pseudogenerikum
-gerechte Sprache;Politsprech (ugs.);politisch korrekte Sprache;PC-Sprache;Neusprech (ugs.)
-Flexionsmorphem;Endung;Flexionsendung;Flektem;Flexiv;Flexem
-Derivantem;Ableitungsmorphem;Derivem;Derivationsmorphem;Wortbildungsmorphem;Derivatem
-soziologisches Geschlecht;Gender;soziales Geschlecht;gesellschaftliches Geschlecht
-nach Hause fahren;heimfahren;zurückfahren
-Beängstigung;Schock;Konsterniertheit;Betroffenheit;Verstörtheit;Verstörung;Konsternation (geh., lat.);Ängstlichkeit;Bestürzung;Konsternierung (geh., lat.);Betroffensein;Bangigkeit;Fassungslosigkeit
-Feinstaub;Schwebstaub;winzige Partikel (in der Luft)
-lungengängige Schwebstoffe;Feinststaub
-lungengängig;alveolengängig
-Basilika;mehrschiffiger Kirchenbau
-regelmäßiges Einkommen;regelmäßige Einkünfte;geregeltes Einkommen
-wegmüssen (ugs.);losgehen müssen;nicht länger warten können;nicht länger warten dürfen;aufbrechen müssen;losmüssen (ugs.);losfahren müssen
-(ein) geregeltes Leben (führen);(ein) geregeltes Dasein
-(es gibt) immer wieder Probleme;(seinen) geregelten Ärger haben;es kommt häufig zu Streit;oft Stress haben;häufig Ärger haben (mit)
-lästige Sache;Ärgernis (Hauptform);nervtötende Sache;ärgerliche Sache;Plage (ugs.);Stein des Anstoßes
-Rededuell;Szene;Schlagabtausch;(heftiger) Wortwechsel;Meinungsverschiedenheit;(heftiger) Streit;Disput;(scharfer) Wortwechsel;Streitgespräch (Hauptform);hitzige Debatte;(verbale) Auseinandersetzung;Wortgefecht
-die Stimme heben;lauter werden;(sich) anschreien;laut werden
-(harmlose) Streiterei;Kabbelei (ugs., norddeutsch);Gekabbel (ugs., norddeutsch);Käbbelei (ugs., norddeutsch);Gekäbbel (ugs., norddeutsch)
-spitze Bemerkung;Spitze;Stichelei;Medisance (geh., bildungssprachlich, franz.);(kleine) Gemeinheit;Malice (geh., franz., veraltend);Gestichel;giftige Bemerkung (ugs.);böses Wort;Seitenhieb (fig.);Boshaftigkeit
-weibliche Runde;Frauentreff;Damenkränzchen
-Telemeter;Mischbildentfernungsmesser
-genau genug sein;hinkommen;langen (ugs.);in etwa zutreffen;okay sein (ugs.);reichen;passen (ugs.);hinhauen (ugs.)
-Cottische Alpen;Kottische Alpen
-Schwarzmeerkaukasus;Pontischer Kaukasus
-Darielschlucht;Darialschlucht
-kein Ergebnis bringen;ergebnislos bleiben
-undurchschaubar;nicht zu durchschauen;intransparent;nicht durchschaubar;undurchsichtig
-terminlich gebunden;unabkömmlich (Amtsdeutsch);ausgebucht;verplant
-nicht (mehr) wegzudenken;konstitutiv;integral;nicht abgelöst zu betrachten
-wichtig;elementar;wesentlich;ins Gewicht fallend;mächtig;bedeutend;dringend
-wichtig;herausragend;prominent;hervorgehoben
-groß;gravierend;massiv;tiefgreifend;ernst;weitreichend;ernstlich;folgenschwer;schwer wiegend;von großer Tragweite;schwerwiegend;wichtig;ernst zu nehmen
-etwas zu sagen haben;von Gewicht sein;(schwer) in die Waagschale fallen;wichtig sein (Person, Meinung);zählen (Wort, Meinung);Gewicht haben (fig.)
-an jemandem nicht vorbeikommen (können);(eine) Schlüsselfigur (sein);(wirklich) etwas zu sagen haben
-Zweiter Indochinakrieg;Vietnamkrieg
-Indochinakrieg;Französischer Indochinakrieg;Erster Indochinakrieg
-Kotschinchina;Cochinchina
-Akephalie;Herrschaftsfreiheit
-gelassen;gesetzt;vernünftig;reif;weise
-Laserablation;Laserstrahlverdampfen;Laserverdampfen
-Bleivergiftung;Saturnismus
-Gressenicher Krankheit;Kuhsterben
-Gebärmutterhalskrebs;Zervixkarzinom;Kollumkarzinom
-(jemandes) Arm reicht weit (fig.);(ein) Entscheider;(eine) Instanz (sein);(ein) Großer;großen Einfluss haben;(eine) große Nummer;(einer der) Granden (des / der ...) (geh., fig.);nicht irgendwer sein;(eine) einflussreiche Persönlichkeit (sein);(eine) große Nummer (sein) (ugs.);einen Namen haben;(ein) Faktor;(sein) Wort hat Gewicht;(eine) Persönlichkeit (sein);(ein) Mann mit Einfluss;(eine) Große;(ein) Schwergewicht (des / der ...) (fig.);(eine) wichtige Person (sein)
-sehr angesehen sein;hohes Ansehen genießen;geschätzt werden;(hoch) in Ansehen stehen (bei);hoch im Kurs stehen;(jemandem) mit Respekt begegnen;Achtung genießen;geachtet werden
-Konferenzschaltung;Videokonferenz;Videokonferenzschaltung;Fernkonferenz (veraltend);Schalte (Jargon)
-auf meine alten Tage (noch) (ugs., Hauptform);in meinem fortgeschrittenen Alter (noch);in meinem Alter (noch)
-Je oller, je doller. (ugs., regional);Alter schützt vor Torheit nicht. (ugs., Sprichwort);Je öller, je döller. (ugs., regional)
-(es gibt) zu viel Regen;verregnet
-steht und fällt (mit) (fig.);essenziell sein (geh.);auf Gedeih und Verderb abhängen von (geh.);vollständig abhängen von;(alles) abhängen von;alles hängt an (ugs., fig.);essentiell sein (geh.);(allein) ankommen auf (es)
-nicht ohne;nie ohne;unvermeidlich (ironisch);Markenzeichen (fig.);notorisch (geh., ironisch);gewohnt;obligat (geh.);obligatorisch (geh., ironisch)
-strichweiser Regen;Strichregen
-fisseln (es) (ugs., norddeutsch);fieseln (es) (ugs.);nieseln (es)
-heftiger Regen;heftige Regenfälle;sintflutartiger Regen(fall);Starkregen
-(die) Nase läuft;Rotznase (ugs.)
-gefährlich;unberechenbar;tückisch
-Strichregen;Bindfadenregen
-heftiger (kurzer) Schneefall;Schneeschauer;plötzlicher Schneefall
-Mastikation;Kauen
-Propylaion;Propylon;Propyläen
-Kraniomandibuläre Dysfunktion;Craniomandibuläre Dysfunktion
-Fronto-striatale Dysfunktion;Striatofrontale Dysfunktion
-Morbus Fahr;Fahr-Krankheit;striatodentale Kalzifikation
-(in) Habachtstellung;Habt-Acht-Stellung;Habtachtstellung;(militärische) Haltung
-Simultaneum;Simultankirche;paritätische Kirche
-ökumenische Bewegung;Ökumene
-ja nicht (ugs.);soll mir nicht (ugs.);bloß nicht (ugs.);nur nicht;jedenfalls nicht
-(seinen) Standpunkt wechseln;umschwenken;sich anders besinnen;(seine) Meinung ändern (Hauptform);(sich) auf einen anderen Standpunkt stellen;zu einer anderen Auffassung gelangen;(etwas) mit anderen Augen sehen;(jetzt) anders denken über;(seine) Einstellung ändern;von seiner Meinung abgehen;(etwas) (jetzt) anders sehen;(etwas) überdenken (geh., distanzsprachlich);(sich etwas) anders überlegen (ugs.);in seiner Meinung umschwenken
-umfallen;(seine) Gesinnung wechseln;(seine) Prinzipien verraten;hinzugelernt haben (euphemistisch, ironisch);(zur anderen Seite) überlaufen;die Seite(n) wechseln (fig.);umkippen;umschwenken;(seine) Überzeugungen über Bord werfen
-(sein) Fähnlein nach dem Winde drehen (ugs.);(sich) opportunistisch verhalten
-vor sich hin stieren;(ganz) woanders sein (ugs.);Löcher an die Wand starren (ugs.);Löcher in die Decke starren (ugs.);vor sich hin starren;Löcher in die Luft starren (ugs.);(jemandes) Blick geht ins Leere (geh.)
-aufpassen wie ein Luchs (ugs.);genau aufpassen;aufpassen wie ein Schießhund (ugs.);aufpassen wie ein Haftelmacher (ugs., österr.);genau beobachten
-Turbokapitalismus;Raubtierkapitalismus;Killerkapitalismus (ugs., Jargon)
-Zweiter Venezuelakonflikt (Eigenname);Venezuela-Krise (Eigenname)
-Podolische Platte;Podolisches Hochland
-Apatheismus;apathischer Agnostizismus;pragmatischer Agnostizismus
-geschlossener Agnostizismus;starker Agnostizismus;permanenter Agnostizismus;strenger Agnostizismus;harter Agnostizismus
-empirischer Agnostizismus;offener Agnostizismus;weicher Agnostizismus;temporaler Agnostizismus;schwacher Agnostizismus
-epistemische Logik;Wissenslogik
-figurieren (als);auftreten in der Rolle (des ...);performen (fachspr., Jargon, engl.);mimen (veraltet);(jemanden) abgeben (auch figurativ);darstellen (Theater, Film) (Hauptform);gestalten;auftreten als;spielen (Theat., Film);in der Rolle (...) zu sehen sein;in der Rolle (...) auf der Bühne stehen;zu sehen sein als;(jemanden) geben (Rolle) (geh.);verkörpern;hinlegen (ugs.);sein
-Direktoriales Regierungssystem;Direktorialsystem;Direktorialverfassung
-Kulturbanause;Kulturverächter;Banause;Kunstbanause;Kulturbarbar
-Unwissender;Banause;Unkundiger;Uninformierter;Ahnungsloser;Nichtswissender;Ignorant;Nichtswisser
-Auskenner (ugs.);Cleverle (schwäbisch);Durchblicker (ugs.);Eingeweihter;Bescheidwisser;Kenner der Materie (floskelhaft)
-Naivling;Blauäugiger;Einfaltspinsel (ugs.)
-grobschlächtig;primitiv;prollig (ugs.);kulturlos;roh;banausisch
-Belästigung;Übergriff
-(ganz) vorne mit dabei (sein);an vorderster Front;(die) Speerspitze der Bewegung bilden;in vorderster Linie;an der Speerspitze der Bewegung (zu finden sein)
-Vordenker;(die) Granden (des / der ...) (geh.);Chefdenker;Meisterdenker;Chefideologe
-nicht berufstätige Ehefrau;Hausfrau;Hausfrau und Mutter
-nicht loslassen können (Psychojargon);(sich) fixieren auf;(sich) verrennen (in);(sich) verbohren;(sich) festbeißen;(sich) versteifen (auf);(sich) verbeißen (in)
-Talk;Lavezstein;Magnesiumsilikathydrat;Steatit;Seifenstein;Speckstein;Talcusstein
-liiert sein;in einer Geschäftsbeziehung sein
-nicht mehr funktionieren;nichts ging mehr;nicht mehr (...) können;nichts geht mehr;zusammenbrechen (Verkehr o.ä.);zum Erliegen kommen
-autorisiert;abgesegnet;abgenommen;approbiert;freigegeben;gebilligt;genehmigt;gutgeheißen
-verkörpern;symbolisieren;vertreten;bildlich darstellen;symbolisch darstellen;versinnbildlichen;allegorisch darstellen
-(einer Sache) gleichkommen;gleichzusetzen sein (mit);sein;darstellen;bilden;bedeuten;(die) Bedeutung haben
-Schaltzyklus;Schaltspiel
-Heimgebrauch;Hausgebrauch
-Kaisersemmel (bayr., österr.);Kaiserweck;Kaiserbrötchen;Kaiserwecken
-Lemgoer Strohsemmel;Lippische Strohsemmel
-Bismut;Wismut
-kleiner Finger;Klenkes (Aachen) (ugs.)
-Öcher (Aachener Platt) (ugs.);Aachener
-(zu allem) Ja und Amen sagen (ugs.);keine (weiteren) Einwände erheben;(sich) abfinden;(seinen) Widerstand aufgeben
-interessiert;nicht abgeneigt;zu haben (für);empfänglich;zugänglich;aufgeschlossen;geneigt
-Musik aus der Barockzeit;Barockmusik;Musik des Barock
-Renaissancemusik;Musik der Renaissance;Musik aus der Renaissance
-Frühe Musik;Musik des Mittelalters
-(musikalische) Notation;Notenschrift;Musiknotation
-Note;Notenzeichen;Musiknote
-Fermate;Verlängerungszeichen
-Notenständer;Notenpult
-Notenhefte;Notenausgaben;Notenblätter;Musikalien
-Musikgeschäft;Musikalienhandlung;Musikhandelsunternehmen
-Musikfachhandel;Musikalienhandel (veraltend)
-(der) Handel;(das) Kaufen und Verkaufen
-Musikfachhändler (ab 2009);Verkäufer in einem Musikgeschäft (ugs.);Musikalienhändler (veraltend)
-kleines Geschäft;Tante-Emma-Laden;Kramladen
-Kleingewerbetreibender;kleiner Krauter (ugs.)
-Trinkhallenbesitzer;Trinkhallenbetreiber;Trinkhallenpächter;Trinkhalleninhaber
-Großhandel;En-gros-Handel
-Zeitungen- und Zeitschriften-Großhandel;ZZS-Großhandel;Grosso;Großhandel von Presseerzeugnissen;Presse-Grosso
-Frischezentrum;Großmarkt (Hauptform)
-Zabergäu;Zabergau
-Zabergäu;Zabergäurenette;Hausener Graue Renette
-Hausfrauenarbeit;häusliches Wirken
-kinetische Gastheorie;dynamische Gastheorie (veraltet)
-Schiffbau;Bootsbau;Schiffsbau
-fait accompli (geh., franz.);(jetzt auch) nicht mehr zu ändern (ugs.);vollendete Tatsache;nun mal geschehen;nicht mehr aus der Welt zu schaffen
-(jemandem) (jemanden) vor die Nase setzen (ugs.);(jemanden) zu jemandes Vorgesetzten machen;(jemandem) einen neuen Vorgesetzten verpassen (salopp)
-(jemandem) was wollen (ugs.);(etwas) haben (gegen jemanden) (ugs.);(jemandem) unsympathisch sein;(jemanden) nicht mögen;(jemandem) nicht grün sein (ugs.);(jemandes) Nase passt jemandem nicht (ugs.)
-(einen) Schluss ziehen;messerscharf schließen;klar sein (für);eins und eins zusammenzählen (fig.)
-Craving (fachspr., engl.);Substanzverlangen (fachspr.);Suchtdruck (ugs.);Schmacht (ugs.);Suchtverlangen
-Suchtdruck (bei Alkoholkranken);Saufdruck (ugs.)
-überhaupt nicht mögen;(etwas) gar nicht haben können (ugs.);(gar) nicht gefallen;damit kannst du jemanden jagen (ugs.);(jemandem) zuwider sein
-(jemandem) widerwärtig sein;(bei etwas) dreht sich jemandem der Magen um;Abscheu hervorrufen (bei);Ekel hervorrufen (bei);Brechreiz hervorrufen (bei);(etwas) dreht jemandem den Magen um;(jemandem) zuwider sein;(jemanden) ekeln;(jemanden) anwidern;(jemanden) abstoßen
-Brechreiz empfinden;abstoßend finden;Ekel empfinden;widerwärtig finden;fies sein (für / vor) (ugs., kölsch);Abscheu empfinden;(sich) ekeln (vor);(sich) schütteln (bei);(jemandem) dreht sich der Magen um;ekelhaft finden
-dastehen lassen wie bestellt und nicht abgeholt (ugs.);warten lassen;(jemanden) hängen lassen (ugs.)
-vergessen;sich nicht kümmern (um);nicht denken an;zurücklassen;hängen lassen (ugs.)
-(sich) zu nichts aufraffen (können);nichts tun;(irgendwie) die Zeit rumkriegen (ugs.);(sich) hängenlassen;darauf warten, dass die Zeit vergeht;darauf warten dass ein Wunder geschieht
-Jubelrufe;Jubel;Gejohle (oft abwertend 'unter dem Gejohle');Gejubel;Freudenschreie;Jauchzer;Hurra-Geschrei (abwertend);Triumphgeschrei;Hochrufe;Hurrageschrei;Hurra-Rufe;Vivat-Rufe;Freudengeheul;Gejuchze;Jubelgeschrei;Hurrarufe;Vivatrufe;Juchzer;Freudengeschrei;Frohlocken (veraltend)
-euphorischer Ausbruch;absolute Hochstimmung (variabel);Freudenausbruch;Freudentaumel (Hauptform);Höhenflug (fig.)
-Sonnenbär;Malaienbär
-sehr richtig;das kannst du laut sagen! (ugs.);ganz richtig;(auch) meine Meinung (sein);(das) sehe ich ganz genau so;absolut richtig;(ich bin) ganz deiner Meinung (variabel);das walte Hugo! (ugs., Spruch, berlinerisch, ruhrdt., veraltet);und ob das so ist! (ugs.);(da) bin ich (ganz) bei dir;Du sprichst ein großes Wort gelassen aus. (geh., Zitat);absolut! (ugs.);wie wahr! (geh.);richtig so;genau richtig;völlig richtig;(da) bin ich (ganz) bei Ihnen;stimmt genau;Wo er recht hat, hat er recht! (ugs., Spruch);vollkommen richtig;das kann man wohl sagen! (ugs.);(das) sehe ich auch so
-Nilgau;Nilgauantilope
-Lücke im Steuerrecht;Steuerschlupfloch;Möglichkeit zur Steuervermeidung
-rechtliche Grauzone;(gesetzliches) Schlupfloch;Gesetzeslücke
-sich gehen lassen;sich vernachlässigen;sich hängen lassen
-Enantiomer;Spiegelbildisomer
-hamiltonsche Quaternionen;Quaternionen;Hamilton-Zahlen
-Vier-Quadrate-Satz;Satz von Lagrange
-nicht abnehmen;hängen lassen
-pendeln lassen;baumeln lassen;hängen lassen (Körperteil);auspendeln lassen;entspannen
-sich hängen lassen;sich hängenlassen;sich nicht im Griff haben;es an Selbstdisziplin fehlen lassen
-Gesamtheit;Ensemble
-(es sich) gut gehen lassen;(das) Leben genießen;aus dem Vollen leben;leben wie Gott in Frankreich (ugs.);leben wie die Made im Speck (ugs.);herrlich und in Freuden leben;leben wie ein Fürst;leben wie die Fürsten
-Gegröle;Gelärm;Schreierei;Geschrei;Krakeel (ugs.);Gejohle (ugs., abwertend);Lärmerei;Brüllerei;Gelärme;Gebrüll;Grölerei;Gejohl (ugs., abwertend);Gegröl
-Heidenlärm;Riesenlärm;Mordsspektakel;Irrsinnslärm;Höllenspektakel;Mordskrach;Höllenlärm;Wahnsinnslärm
-Geräuschpegel;Unruhe;Geräuschteppich;Lärm;Lärmpegel;Lärmteppich
-Unterbrechung;Störung
-(das) Kreischen;Gekreisch;Gekreische;Gezeter;(das) Keifen;(das) Herumzetern;Gekeife
-(anhaltendes) Seufzen;Seufzer;Gestöhn;Geseufze;Gestöhne
-Gerumpel;(ein) Rumoren;Gepolter;Geholper (ugs.);Gerumse (ugs.)
-das Besondere;individuelle Eigenschaft;Alleinstellungsmerkmal;USP (Unique selling proposition) (fachspr., engl.)
-Gerassel;Geklapper;Gerüttel;Geratter;Gerappel;Gestucker;Geknatter
-Fehlzündungen haben;spucken (ugs.);spotzen (Motor);stuckern;stottern (ugs.)
-wämsen (ugs., regional);poltern;bullern (ugs.);rumsen (ugs.);bollern (ugs., regional);rumpeln
-schütteln;schlenkern;schlackern
-(etwas) hin- und herschlackern;ausschlackern;ausschlenkern;ausschütteln
-(ein) Scheppern;schepperndes Geräusch;blechernes Geräusch;Geschepper
-Geklirr;Geklicker;(ein) Klirren;(ein) Klimpern;Geklirre
-Aufbruch zu neuen Ufern (fig.);angestammte Bahnen verlassen (fig.);Neues wagen;Neues versuchen;angestammte Pfade verlassen (fig.);neue Wege gehen (fig., Hauptform);Neuland betreten (fig.)
-(das) Klappern;Geklacker;Geklapper;(das) Klackern
-ticken;klicken;tickern;klickern;tickeln
-knacksen;knacken
-zu hören sein;(ein) Geräusch machen
-Ton;Klang
-Schallereignis (fachspr.);Schall;akustisches Ereignis (fachspr.)
-Rufe;Laut;Ruf;Laute
-Fonem;Phonem
-Lärmreduktion;Lärmbekämpfung
-Schallausbreitung;Schallübertragung
-Zusammenklang;Klang;Akkord;Harmonie
-maunzen;miauen
-wummern (Basslautsprecher);dröhnen
-dröhnen;(ein) röhrendes Geräusch machen;(sehr) laut werden;(einen) Mordskrach machen;röhren (Motor)
-bumm!;peng!
-musikalische Struktur;musikalisches Element;Musikelement
-klatschen;platschen;trommeln;peitschen;pladdern (norddeutsch);patschen;prasseln (Regen)
-rumms machen (es) (ugs.);krachen (es) (ugs.);knallen (es) (Autounfall o.ä.);scheppern (es);(einen) Unfall geben (es);rumsen (es) (ugs.);rums machen (es) (ugs.)
-(sich) zusammenbrauen (fig.);brodeln (fig.);schwären (fig.);schwelen (fig.);gären (fig.)
-(jetzt ist aber) Ruhe im Karton! (ugs.);Ruhe da hinten! (ugs.);bist stad! (ugs., bayr., österr.);ruhig jetzt! (ugs.);pscht! (ugs.);Ruhe jetzt!;Ruhe!;sei still! (variabel);psst! (ugs.);gib endlich Ruhe! (ugs.);pst! (ugs.);schh! (ugs.);schhh! (ugs.);Ruhe im Glied! (ugs., militärisch, veraltend);still!;leise!;Silentium! (geh., auch ironisch, bildungssprachlich);Ruhe da hinten auf den billigen Plätzen! (ugs., scherzhaft)
-trällern;trillern;tirilieren
-singen (Vogel) (Hauptform);schlagen (Fink, Nachtigall);flöten
-tröten;trompeten (z.B. Elefant)
-trompeten;Trompete spielen;(die) Trompete blasen;tröten (abwertend)
-tröten (abwertend);Posaune spielen;posaunen;(die) Posaune blasen
-brausen;rauschen
-Schulwechsel;Übertritt (bayr.)
-Hippodamisches System;Hippodamisches Schema
-(die) Zeit läuft;(die) Uhr tickt (fig.);(die) Zeit wird knapp;uns rennt die Zeit davon (ugs.);(es) muss schnell (et)was passieren (ugs.);(der) Countdown läuft (ugs., fig.);(jemandem) läuft die Zeit davon
-Manderl (österr.);(ein) Kurzer (ugs.);kleiner Kerl (ugs.);Bürschchen;Knäbchen (verächtlich oder belustigend);(ein) Kleiner (ugs.);Bubi (ugs.);Bürscherl (ugs., süddt.);Männlein;(so'n) Kleener (ugs., norddeutsch);Männeken (ugs., norddeutsch);Burschi (ugs.);Bübel (ugs., süddt.);Bübchen;Männchen
-Wasserschwaden;Wasserschleier;Wasserfahne;Gischtfahne
-nicht zu viel werden;nicht überschreiten;beschränkt sein (auf);limitiert sein (auf);(sich) in Grenzen halten;(die) Grenze von (...) nicht überschreiten;(sich) beschränken (auf)
-(bereits) am (oberen) Anschlag;das war mein letztes Wort;besser geht es nicht;(es ist) alles ausgereizt (ugs.);alles ausgereizt haben (ugs.);mehr ist nicht zu holen;am oberen Limit (sein);mehr gibt es nicht;das Maximum (darstellen);mehr ist nicht drin;(die) absolute Obergrenze sein;nichts mehr zu holen;mehr sitzt nicht drin;mehr geht (einfach) nicht (ugs., Hauptform);(das) Äußerste sein;(da) ist Feierabend;(das) Ende der Fahnenstange sein (fig.);das höchste der Gefühle (sein) (ugs.);voll ausgereizt sein (ugs.)
-(sich) nach der Decke strecken (müssen) (ugs., fig.);mit wenig (Geld) auskommen müssen;haushalten;(sein) Geld zusammenhalten;sparsam wirtschaften;(sein) Geld einteilen
-sehr sparsam leben (müssen);jeden Cent zweimal umdrehen (müssen) (ugs., fig.);(sich) jeden Bissen vom Munde absparen;(sich) etwas vom Munde absparen;auf jeden Cent gucken;jeden Pfennig zweimal umdrehen (müssen) (fig.)
-Abenteuerspiel (selten);Adventurespiel;Adventure
-2D-Adventure;Point-and-click-Adventure (engl.)
-kontrolliert;nicht (so leicht) aus der Reserve zu locken;diszipliniert;beherrscht
-Grafikadventure;Graphikadventure
-(sich selbst) einen Gefallen tun und ...;gut beraten sein;am besten (+ Imperativ) (ugs.);(jemand) sollte (besser);es empfiehlt sich (geh.)
-Fingerprint (engl.);Fingerabdruck;Daktylogramm
-Marschverpflegung;Futterage (fachspr., Jargon, militärisch, veraltet);Reiseproviant (Hauptform);Lunchpaket;Mundvorrat;Wegzehrung
-(in ...) dirigieren;einweisen;lotsen;einwinken;hineindirigieren
-echt stark (ugs.);nicht schlecht, Herr Specht! (ugs., Spruch, kommentierend);echt interessant (ugs.);(das) hat was (ugs.);(gar) nicht übel (ugs.);nicht ohne (ugs.);schon was (sein) (ugs.)
-(jetzt) halt dich (gut) fest (ugs.);(pass auf) jetzt kommt's (ugs.);(und) jetzt kommt der Hammer (ugs.);mach dich auf was gefasst (ugs.)
-hat man so etwas schon gehört!? (ugs.);(wo) hat man so etwas schon erlebt!? (ugs.);(und) jetzt bist du dran! ('du' betont) (ugs.);fällt einem dazu noch was ein? (ugs.)
-irgendetwas ist (mit jemandem) (ugs.);(etwas) ist im Busch (bei) (ugs., fig.);(etwas) haben;(es) stimmt was nicht (mit);was haben (ugs.);etwas stimmt nicht (mit);irgendwas ist (mit jemandem) (ugs.)
-Hygroskopizität;Hygroskopie
-gleichschenkliges Tetraeder;Disphenoid
-Übriggebliebenes (Essen);Uzen (ugs., regional);Essensreste
-Rumpelkammer;unaufgeräumtes Zimmer
-(in einer) Mansardenwohnung;in der Dachetage;unterm Dach;ganz oben;im Dachgeschoss;unterm Dach, juchhe! (Spruch, scherzhaft)
-Kabäuschen;Kämmerchen;Verschlag;Zimmerchen
-bei Hofe;zu Hofe;am Hof
-Dulag;Durchgangslager
-Nebenlager;Außenlager
-Todeslager;Vernichtungslager (Hauptform);Mordfabrik (geh., literarisch);Tötungsfabrik (geh., literarisch)
-KZ-Kommandant;Lagerkommandant
-Berber;Maure;Amazigh (fachspr.)
-(sich) vertagen;(abbrechen und) zu einem späteren Termin fortsetzen
-sehr aufgeregt;hysterisch;in fieberhafter Aufregung;kurz vorm Durchdrehen (ugs.);in heller Aufregung;in hellem Aufruhr;(die) Nerven liegen blank;(völlig) durch den Wind (ugs.)
-Lügenbaron;(Hieronymus Carl Friedrich) Freiherr von Münchhausen (Eigenname);Baron Münchhausen (Eigenname)
-Istrische Riviera;Adriatische Riviera
-Herumlärmen;Lärmerei;Gelärm;Affenzirkus (ugs.);Gelärme;Affentheater (ugs.);(das) Rumlärmen (ugs.);Heckmeck (ugs.);Zirkus (ugs.)
-(sinnloses) Gelaber (ugs.);Heckmeck (ugs.);Schwafelei (ugs.);Blabla (ugs.);Hin-und-her-Gerede;(endloses) Gerede;Hickhack (ugs.);(großes) Palaver;Schwadronade
-das Rumge... (+ Verbstamm +) ...e (ugs., abwertend);das Herum...en (...eln / ...ern: Verb im Infinitiv);die (Verbstamm +) ...(a)(t)ion (franz.);das ...en (...eln / ...ern, Verb im Infinitiv);die Rum... (+ Verbstamm +) ...erei (ugs., abwertend);die (Verbstamm +) ...erei;die (Verbstamm +) ...ung;die Herum... (+ Verbstamm +) ...erei (abwertend);das Rum...en (...eln / ...ern: Verb im Infinitiv) (ugs.);das Ge... (+ Verbstamm +) ...e (ugs., abwertend);das Ge... (+ Verbstamm);das Herumge... (+ Verbstamm +) ...e (abwertend)
-Verbotsirrtum;Rechtsirrtum (schweiz., österr.)
-warum nicht gleich so! (ugs.);na also! (ugs.);geht doch! (ugs., Spruch);na bitte! (ugs.);wer sagt's denn! (ugs.);siehst du! (ugs.);siehste wohl!? (ugs.)
-sei es (auch) noch so unwahrscheinlich;wenn auch nur die leiseste Möglichkeit besteht;wenn irgend möglich (geh.);egal wie wenig wahrscheinlich (etwas) ist;und sei es noch so unwahrscheinlich;sofern (auch) nur die leiseste Chance besteht;falls irgend möglich;möglichst
-Rumgeblödel (ugs.);Jux und Dollerei;Tollerei(en);Kindereien;Rumgealber(e) (ugs.);Herumgeblödel;Infantilität (geh.);Torheit(en);Blödelei(en);tolles Treiben;Albernheit(en);(jemandes) tolles Treiben;Herumgealber
-Fotoblog;Fotografieblog
-geschlossene Wohnanlage;geschlossener Wohnkomplex;Gated Community (engl.);bewachte Wohnanlage
-dahingerafft werden (von);von seinem Leiden erlöst werden (verhüllend);(seinen Verletzungen, einem Leiden) erliegen;sterben an (Hauptform)
-verdursten (Hauptform);an Wassermangel zugrunde gehen
-nicht durchhalten;schwach werden (ugs.);nicht Nein sagen können;nachgeben;nicht widerstehen können;(jemandes Charme) erliegen;nicht standhalten können;(einer Versuchung) erliegen;weich werden (ugs.)
-(einer Sache / jemandem) machtlos gegenüberstehen;wehrlos ausgeliefert;nichts entgegenzusetzen haben;machtlos (gegen);rettungslos ausgeliefert
-Grauslichkeit;Ekligkeit;Hässlichkeit;Unschönheit;Abscheulichkeit;Scheußlichkeit;Grässlichkeit
-... und so (ugs.);irgendwie (ugs.);irgendwas mit
-Rütteltisch;Schwingtisch
-Münzerkennungston;Kuckuckston
-Münztelefon;Münzer;Münzfernsprecher
-Diffusionsgleichung;Wärmeleitungsgleichung
-Verslehre;Metrik
-Metron;Metrum
-Lautwegfall;Tilgung;Elision (fachspr.)
-Aphärese (fachspr.);Lautwegfall am Wortanfang;Prokope (fachspr.)
-Synaloiphe;Synaloephe;Synalöphe
-Baugenehmigung;Bauerlaubnis;Baubewilligung
-Kontingenztheorie;Kontingenzmodell
-Konferenzmappe;Schreibmappe;Aktenmappe;Tagungsmappe
-Theoretiker;Gelehrter;Eierkopf (abwertend);Kopfarbeiter;Wissenschaftler;Akademiker;Denker;Verstandesmensch;Forscher;Großkopferter (ugs., bayr., österr.);Mann der Wissenschaft;Egghead (engl.);Wissenschafter (männl., österr.);Großkopfeter (ugs., bayr., österr.);Frau der Wissenschaft;Geistesarbeiter;Intellektueller
-Mindestspeicherfrist;Mindestdatenspeicherung;Vorratsdatenspeicherung
-rausekeln (ugs.);hinausekeln;wegbeißen (fig.);vergraulen;wegmobben;rausmobben (ugs.);wegekeln
-durch die Lande (ziehen);durch die Lande (touren);durch die Gegend (streifen)
-nicht die Autobahn nehmen;über die Dörfer (fahren) (ugs.);über Land (fahren);abseits der Hauptverkehrswege
-Judiz;Judizium;Urteilskraft (eines Juristen)
-Baird-Tapir;Mittelamerikanischer Tapir
-Mittelamerikanischer Totenkopfaffe;Rotrücken-Totenkopfaffe
-Breitnasenaffe;Neuweltaffe
-Schmalnasenaffe;Altweltaffe
-Mittelamerikanischer Schwalbenschwanz;Großer Schwalbenschwanz
-Stierhoden;Stierheberl;Stierbeutel
-Ausfall;Entbehrung;Entzug;Abstinenz
-gesellschaftsfähig;vertretbar
-berücksichtigen;sich einlassen auf;ein offenes Ohr haben für;zuhören
-Abc (fig.);Fundament;Grundlage;Kanon;Grundwortschatz;Basis
-Forward-Algorithmus;Vorwärts-Prozedur;Vorwärts-Algorithmus
-Günser Berge;Günser Gebirge;Günser Bergland;Rechnitzer Fenster (fachspr.);Rechnitzer Schiefergebirge (fachspr.)
-Bernsteiner Gebirge;Bernsteiner Hügelland
-Trikonchos;Drei-Konchen-Chor;Dreikonchenanlage
-unverbraucht;jung;frisch;unverdorben (geh.)
-Anfang;Auftakt;Anbruch;Anbahnung;Geburtsstunde
-Ass im Ärmel (ugs., fig.);Trumpf;Vorzug;Vorteil;(unsere) Wunderwaffe (ugs., fig., scherzhaft)
-Raster;Syndrom;Kategorie;Schablone;Muster;Schublade
-Präbende;Pfrund (schweiz.);Pröven (norddeutsch);Pfründe
-Führungs- und Waffeneinsatzsystem;Einsatzführungssystem;Führungsinformationssystem;Führungssystem
-Maskierungszeichen;Fluchtsymbol
-Rücklöschtaste;Rücktaste;Rückschritttaste;Backspace
-Grönländische Sprache;Grönländisch;Grönländisches Eskimo;Grönländisches Inuktitut
-Hydrograph;Abflussganglinie
-Schlüsselkurve;Abflusskurve
-Häckse (ugs.);Haeckse (ugs.)
-Dekomprimierungsbombe;Archivbombe
-Dekompression;Dekomprimierung
-Landeeinteilung;Landevolte
-Sprossende Felsennelke;Kopfnelke;Sprossendes Nelkenköpfchen
-auf eigene Rechnung arbeiten;(seine) eigene Agenda verfolgen;sein eigenes Süppchen kochen (abwertend, fig.);seinen eigenen Weg gehen;sein eigenes Ding machen (ugs.);sein eigenes Ding durchziehen (ugs.);*sein* Ding machen (ugs.)
-Sachlichkeit;Neutralität;Objektivität;Nüchternheit
-(jemandem) leichtfallen;(jemandem) zufliegen (ugs.);(jemanden) unterfordern
-Domino;Seifenblase (fig.);Kartenhaus
-sich selbst überlassen;allein lassen
-verwildern;niemand kümmert sich um;sich selbst überlassen sein
-Zynismus;Herablassung;Menschenverachtung;Geringschätzung;Verachtung
-Wochenzeitung;Wochenblatt
-Listspinne;Raubspinne;Brautgeschenkspinne
-Entspannung;Ruhe
-Bumerang (fig.);Eigentor (fig.)
-Seitengleitflug;Glissade (schweiz.)
-Nebenton (Nebentöne);Beigeschmack;Touch;etwas von (haben);Beiklang;Anflug (von);Zwischenton (häufig: Zwischentöne);Geruch;Anklang;Unterton
-Identifikation;Zugehörigkeitsgefühl;Treue;Gunst
-innewohnen;anhaften;begleiten
-weggehen;weichen;verschwinden
-ablegen;abstreifen;loswerden
-Abbaugerechtigkeit;Berechtsame
-Zellenschreibweise;Pauling-Schreibweise;Kästchenschreibweise;Kästchenmodell
-Küstenschweden;Estlandschweden
-Malakov-Turm;Malakow-Turm;Malakoff-Turm
-Desurbanisierung;Deurbanisierung
-staubig;verstaubt;mit Staub überzogen;mit Staub bedeckt;staubüberzogen;bestaubt;voller Staub;staubbedeckt
-rußig;mit Ruß überzogen;rußbedeckt;voller Ruß;verrußt;rußgeschwärzt
-Dreckschwein(chen);Wutz;Schmierlapp(en) (derb);Ferkel;(alte) Pottsau (derb, ruhrdt.);Schmutzfink;Schweinigel (derb);Schmuddelkind;Dreckspatz (verniedlichend)
-ungepflegte Erscheinung;Schlamper;Schlunz
-Malakka-Halbinsel;Malacca-Halbinsel
-klamm;steifgefroren;verfroren;steif;frostklamm
-erstarrt;verhärtet;versteift (med.);eingerostet
-Desinformation;Halbwahrheit;Gerücht
-Ansatz;Arbeitstitel;Provisorium
-Zwischenstand;Provisorium;vorübergehender Zustand;Momentaufnahme
-Protagonist;Hauptakteur;Schlüsselfigur;Spielmacher (Sport);Topfrau (ugs., weibl.);Kohlenkönig (ugs., Bergbau, Jargon);Topmann (ugs., männl.);Leistungsträger;Aktivposten (fig.);Spitzenkraft;Gestalter
-Lücke;Stiefkind (fig.);offene Baustelle (fig.);Nachholbedarf
-Bodenhorizont;Horizont
-Schwammeisen;Eisenschwamm;Eisenluppe
-Damaszener Stahl;Damast
-Wootzbarren;Wootzkuchen;Wootz
-Altan;Söller
-Plattformdach;Altandach
-Eisensau;Ofensau;Salamander;Wölfe;Bühnen;Härtlinge
-Raffinierstahl;Gerbstahl;Gärbstahl
-Raffinerieren;Gärben;Garben
-anterograde Amnesie;Ekmnesie
-Kriminalbiologie;Kriminalanthropologie (veraltet)
-Identifizierung mit dem Angreifer;Identifikation mit dem Aggressor
-(mit) Berliner Dialekt sprechen;berlinern
-Trinitatis;Goldener Sonntag;Frommtag
-Dreieinigkeitsfest;Dreifaltigkeitsfest
-Gedenktag der Reformation;Reformationstag
-Frühlingsanfang;Frühlingsbeginn
-Nikomedien;Nikomedia
-gestrenge Herren;Eisheilige
-Wie du mir, so ich dir. (ugs., Sprichwort);Auf einen groben Klotz gehört ein grober Keil. (ugs., Sprichwort);Wie man in den Wald hineinruft, so schallt es (auch) heraus. (ugs., Sprichwort)
-Gemischtwarenhandlung;Gemischtwarenladen (auch figurativ)
-(sich) sicher sein (Hauptform);keinem Zweifel unterliegen (etwas) (geh.);(sich) einer Sache sicher sein (geh.);(genau) wissen;definitiv wissen;mit Bestimmtheit wissen
-wenn alles perfekt läuft;im Idealfall;im Best case;im besten Fall;idealerweise
-Erbarmen;Beißhemmung (fig.)
-tolerieren;leben und leben lassen (ugs.);respektieren
-Außenstehender;Dritter;neutrale Person
-Naturalien;Naturprodukte;Sachwerte;Naturalwerte
-(mechanische) Wegmessung;Odometrie (engl.);Hodometrie (fachspr., griechisch, Hauptform)
-Neudeutsch (ugs., ironisch);Denglisch
-ohne die erforderlichen Erhaltungsinvestitionen;nicht nachhaltig;auf Verschleiß (fahren)
-Angioplastie;perkutane transluminale Angioplastie
-Doha-Runde;Doha-Entwicklungsagenda
-Assoziationsabkommen;Assoziierungsabkommen
-gnädiges Geschick;Gnade der späten Geburt (Zitat)
-Soundkarte;Tonkarte;Audiokarte
-Genbibliothek;DNA-Bibliothek;Genbank;genomische Bibliothek
-Markenweltmeisterschaft;Sportwagen-Weltmeisterschaft
-bornsche Wahrscheinlichkeitsinterpretation;bornsche Regel
-Born-Oppenheimer-Näherung;Born-Oppenheimer-Approximation;adiabatische Näherung
-Spieleragent;Spielervermittler;Spielerberater
-Cerebralparese;infantile Zerebralparese
-Falkenmotiv;Dingsymbol
-hereinfallen (auf);einer Täuschung erliegen (geh.);(jemandem) auf den Leim gehen (ugs., fig.);(jemandem) aufsitzen (ugs.);(sich) täuschen lassen;(sich) blenden lassen;(sich) anlocken lassen;(sich) einseifen lassen (ugs., fig.);(sich) einwickeln lassen
-Krankheitsüberträger;Vektor (fachspr.)
-Sehnsuchtstropfen (ugs.);Vorsaft (ugs.);Präejakulat;Lusttropfen (ugs.)
-Cowper-Drüse;Bulbourethraldrüse;Cowpersche Drüse
-Samenbläschen (veraltet);Samenblase (veraltet);Bläschendrüse
-Skene-Drüse;Paraurethraldrüse;Prostata feminina (fachspr.)
-Dürer-Polyeder;abgestumpftes Rhomboeder;Rhomboederstumpf
-Rainstick (engl.);Regenmacher;Rainmaker (engl.);Regenstab
-Regenablaufkette;Regenkette
-Dachkapfer (österr.);Gaube;Dachlukarne (schweiz.);Gaupe (vereinzelt);Dachgaupe (vereinzelt);Dachgaube
-Ozeanboden;Meeresgrund;Grund des Meeres;Meeresboden
-Kölner Dialekt;Kölner Mundart;Kölsch
-kommt in Massen!;kommt alle!;kommet zuhauf! (kirchl.)
-nicht praktikabel;nicht realisierbar;lebensfremd;lebensfern;impraktikabel
-Nichttrinitarier;Antitrinitarier
-Tatwaffe;Tatwerkzeug;Corpus delicti
-Schuldiger;Schuldtragender;Täter
-Erbsünde (geh., fig.);Fehler im System;systematischer Fehler;Geburtsfehler (geh., fig.);Webfehler (fig.);struktureller Fehler;Konstruktionsfehler (fig.)
-Rabulistik (geh., lat.);Sophisterei (geh., griechisch);Silbenstecherei;Fliegenbeinzählerei (ugs., fig.);Paralogistik (geh., griechisch);Korinthenkackerei (derb);Wortklauberei;Kasuistik (geh.);Wortverdreherei (ugs.);Finesse (geh., franz.);Sophistik (geh., abwertend, bildungssprachlich);Haarspalterei (fig.);Spitzfindigkeit;Erbsenzählerei (ugs., fig.)
-Dichotomie;Dialektik;Polarität;Dualismus;Zweiheit
-Boppel (regional);Plümmel (rheinisch);Bolle (schwarzwäld.);Bommel
-Pudelmütze;Bommelmütze
-Quaddel;Quoddel;Quaste;Troddel
-(immer) (ein) Haar in der Suppe finden (fig.);(sich) an Kleinigkeiten hochziehen (ugs.);Erbsenzählerei betreiben;(immer) etwas auszusetzen haben
-nicht unerschöpflich sein;Grenzen kennen
-das normale Maß übersteigen;grenzenlos sein;keine Grenzen kennen;über das normale Maß hinausgehen;maßlos sein;überborden
-(jemandem) herzlich egal sein;(jemanden) nicht (im Geringsten) interessieren;im Grunde verachten;nur ein müdes Lächeln übrig haben für
-selbstverwalteter Betrieb;Kollektiv;selbstverwaltetes Unternehmen
-Nonprofitunternehmen;Non-Profit-Unternehmen;gemeinwohlorientiertes Unternehmen
-Non-Profit-...;gemeinwohlorientiert;dem Gemeinwohl verpflichtet;nicht gewinnorientiert;gemeinnützig;Nonprofit...;ohne Gewinnerzielungsabsicht;nach dem Kostendeckungsprinzip arbeitend
-dringendes Hilfeersuchen;dringende Bitte um Hilfe;Stoßgebet (fig.);Hilfeschrei (fig.)
-scheren;säbeln (humor. oder abwertend);schnibbeln (ugs., norddeutsch);schneiden;schnipseln (auch abwertend) (ugs.);schnippeln (auch abwertend) (ugs.)
-zerteilen;aufschneiden;zerschneiden;in Stücke schneiden;zerlegen;tranchieren
-Nebenleistung(en);Sachbezug;geldwerter Vorteil (steuerrechtl.);Fringe Benefits
-touren (durch);auf Tournee sein;auf Tournee gehen
-Konzerttournee;Konzertreise
-Sangesbruder;Chorkollege
-singbegeistert;sangesfreudig
-fehlbar;kann sich (auch) irren (ugs.);fallibel (geh.)
-Fehlbarkeit;Fallibilität
-Staatsausgabenquote;Staatsquote
-Lügenbold;Lügenmaul;Schwindler;Märchenerzähler;Märchenonkel;Flunkerer;Lügenschmied
-Phasendifferenz;Phasenverschiebung;Phasenlage
-Lügenmaul;Flunkerer;Lügenbold;Lügner (Hauptform);Schwindler
-Mietnomade;Mietbetrüger;Mietpreller;Einmietbetrüger (fachspr.)
-Mietbetrug;Einmietbetrug;Einmietungsbetrug (polizeil.)
-Kumulieren;Häufeln;Stimmenhäufung
-irdisches Jammertal (christl.);Welt;Diesseits
-in die Offensive gehen;(etwas) angreifen;das Heft in die Hand nehmen (fig.);(eine Sache) anpacken;(den) Stier bei den Hörnern packen (fig.);(den) Kampf aufnehmen (gegen);(einer Sache) zu Leibe rücken;loslegen (mit) (ugs.);(etwas) in Angriff nehmen (ugs.);angehen (Problem)
-wollen wir?;bist du so weit?;sollen wir?;lass uns (gehen).;kann's losgehen?;fahren wir?;gehen wir?;können wir?
-eine Lawine (von ...) lostreten;provozieren;entfachen;anzetteln;heraufbeschwören (negativ);vom Zaun brechen;lostreten
-verleiten;anstiften;überreden
-Treibeis;Drifteis
-Richteigenschaft;Richtcharakteristik
-Wissenskarte;Wissenslandkarte
-Gott Vater (christl.);Gottvater (christl.);Vater (christl.)
-Vaterfigur;väterliches Vorbild;männliche Bezugsperson
-leiblicher Vater;genetischer Vater;Erzeuger;biologischer Vater
-Samenspender;Spermalieferant (abwertend)
-Vaterrolle;Aufgaben als Vater
-Schweizerhaus;Chalet (schweiz.)
-Sennhütte (bayr., österr.);Berghütte;Almhütte;Alphütte
-Schwanengesang (geh.);Klagelied;Abgesang (auf)
-mit (anderen zusammen) aus der Taufe heben;von der ersten Stunde an dabei (sein);Geburtshelfer (sein) (fig.);von Anfang an dabei (sein);Schützenhilfe leisten
-Totengräber (Hauptform);Leichengräber;Bestatter;Totenbestatter;Leichenbestatter;Kuhlengräber (norddeutsch);Pompfüneberer (österr.)
-Kartoffelmercedes (ugs., scherzhaft);Einkaufstrolley;Hackenporsche (ugs., scherzhaft);Einkaufsroller
-Pfandsammler;Flaschensammler
-aus den Latschen kippen (ugs.);fallen (Person) (Hauptform);(sich) nicht länger auf den Beinen halten (können);hinfliegen (ugs.);hinknallen (ugs.);(sich) (lang) hinlegen (ugs., fig., salopp);zu Fall kommen (geh.);hinfallen;hinschlagen;zu Boden gehen;stürzen;auf den Boden knallen (ugs.)
-(sich) auf die Schnauze legen (derb);(sich) lang hinlegen (ugs., salopp);(sich) auf die Fresse legen (derb);der Länge nach hinschlagen;auf die Schnauze fliegen (derb);lang hinknallen (ugs.);der Länge nach hinfallen;auf die Fresse fliegen (derb);lang hinfliegen (ugs.)
-Schneise (Wald, verbuschtes Gelände);Durchhau;Pikade;Durchhieb
-ungebremst zu Boden stürzen;abstürzen;wie ein Stein vom Himmel fallen (Luftfahrzeug)
-Brennzange;Brennschere;Brenneisen
-Ondulierstab;Lockenstab
-jetzt oder nie;letzte Gelegenheit
-Einbruch (/ Anbruch);Start;Beginn;Anfang;Anbruch (geh.)
-Geburtsstunde (fig.);allererste Anfänge;(die) Stunde null (von) (fig.);erster Anfang;früheste Anfänge;erste Anfänge;(das) erste Mal, dass ...;Anbeginn
-Plastizität;plastische Verformung
-Trennbruch;Sprödbruch
-Förderung;gezielte Weiterentwicklung;Ausbau
-Multiplikation;Vervielfachung;Potenzierung;Verstärkung
-Wertzuwachs;Performance (engl.);wertmäßiger Zuwachs
-Berglorbeer;Kalifornischer Lorbeer;Kalifornischer Berglorbeer
-Familienältester;Patriarch;Pascha
-Haustyrann;Familientyrann
-ohne staatliche Reglementierung;in der freien Wildbahn (fig.)
-mit Sympathien für;aufgeschlossen für;Sympathien haben (für);sympathisierend (mit ...);(...) gesinnt;(...) eingestellt
-republikanisch (historisch);antimonarchistisch
-Klatschreporter;Sensationsreporter;Skandalreporter
-Boulevardjournalist;Schreiber für die Klatschpresse
-Enthüllungsjournalismus;investigativer Journalismus
-nicht ins Glas spucken (ugs.);gerne Alkohol trinken (Hauptform);(sich) gerne (schon mal) einen trinken;(bei alkoholischen Getränken) nicht nein sagen;(dem Alkohol) zugetan;dem Trunke hold (sein) (geh.);mit dabei sein wenn es was zu trinken gibt;gerne dem Alkohol zusprechen
-große Geister (einer Epoche);(die) intellektuelle Elite;führende Köpfe (ihrer Zeit)
-auf dem Zahnfleisch gehen (ugs.);fix und alle (ugs., salopp);(total) erledigt;halb tot (vor) (ugs.);fertig mit der Welt (ugs.);am Ende (seiner Kräfte);am Stock gehen (fig.);am Boden zerstört (ugs., fig.);(seine) (physischen) Kräfte sind erschöpft;kein bisschen Kraft mehr haben;(völlig) entkräftet;nichts geht mehr (ugs.);fix und fertig (ugs.)
-(der) Akku ist leer (ugs., fig.);ausgelaugt;kaputt;fix und alle (ugs.);entkräftet;fertig;nicht mehr können;am Ende;(wie) erschlagen (ugs.);erschöpft;hinüber;rien ne va plus (ugs.);zerschlagen;schachmatt (ugs., fig.);(wie) gerädert (ugs.);k. o. (ugs., fig.);kaputt wie ein Hund (ugs.);erledigt;fix und fertig (ugs.)
-am Arsch des Propheten sein (derb, sarkastisch, scherzhaft);dumm dastehen (ugs., fig.);die Blöde sein (ugs.);blöd dastehen (ugs.);belämmert dastehen (ugs.);(nur) ein dummes Gesicht machen;der Gelackmeierte sein (ugs.);die Arschkarte (gezogen) haben (ugs., fig.);der Angeschmierte sein (ugs.);der Dumme sein (ugs.);angeschmiert sein (ugs.);der Blöde sein (ugs.)
-schwach;nicht (gut) bei Kräften;mitgenommen;kränklich;kränkelnd;angegriffen;wackelig auf den Beinen;angeschlagen
-nichts geht mehr;(es) geht nicht mehr (weiter);(es) ging nicht mehr (weiter);keine Kraft mehr haben;kann nicht mehr (weiter);(jemanden) verlassen die Kräfte;(jemandem) geht die Puste aus (ugs.)
-nervlich fertig;am Boden zerstört (ugs., fig.);nervlich am Ende;fix und fertig (ugs.);Nervenbündel (fig.);kurz vor dem Nervenzusammenbruch;am Rande des Nervenzusammenbruchs;mit den Nerven am Ende
-Evidenzbüro;Evidenzbureau
-Bundeshandelsakademie;Handelsakademie
-überbetriebliche Lehrlingsunterweisung;überbetriebliche Ausbildung;überbetriebliche Unterweisung
-Schützendivision;Infanteriedivision
-Sozialfaschismusthese;Sozialfaschismustheorie
-nicht robust (im Betrieb);nicht ausfallsicher;störanfällig;nicht stabil (laufend);nicht störungsfrei (arbeitend)
-Strieme;(blutunterlaufener) Streifen;roter Streifen;streifenförmiger Bluterguss;Striemen
-(sich) warm anziehen;(sich) einmummeln (ugs.)
-konfrontiert sein (mit);(unversehens) vor dem Problem stehen (dass);an der Backe haben (ugs., salopp);(sich) konfrontiert sehen (mit);(sich) (einer Sache) stellen müssen
-Tabuisierung;(das) Nicht-reden-Dürfen (über);(das) Schweigen
-(die) eigenen Leute (ugs.);(das) eigene Haus (fig.);(das) eigene Lager (politisch)
-(jemandem etwas) entlocken (geh.);(etwas aus jemandem) herauskitzeln (ugs., fig.);(etwas aus jemandem) herausbekommen;(etwas aus jemandem) herauskriegen (ugs.)
-(die) diplomatischen Kreise;Diplomatie
-(jemandem) nicht schnell genug gehen können;aufs Tempo drücken (ugs., fig.);(es) eilig haben;zur Eile drängen (geh.);Druck machen
-vertrauliches Gespräch;Tête-à-Tête (franz., ironisch);persönliches Gespräch (zu zweit);Zweiergespräch;Vieraugengespräch;Gespräch in trauter Zweisamkeit (ironisch)
-Sezessionist;Verfechter der Eigenstaatlichkeit (eines Landesteils);Separatist
-zu den Waffen greifen;(den) Kampf mit militärischen Mitteln aufnehmen;bewaffneten Widerstand leisten
-Referenz;Standardwerk;Standardliteratur
-Alterszusammensetzung;Altersstruktur
-(jemanden) umhauen (ugs., fig.);(jemanden) überwältigen
-Scharmützel;bewaffneter Zusammenstoß;(vereinzelte) Kampfhandlungen;(einzelne) Kampfaktionen;Geplänkel;Kleinkrieg;Plänkelei
-Laufereien;lästiger Aufwand;Gewiggel (ugs., regional)
-Exponent;Protagonist;führender Vertreter;Wortführer
-(die) Stillen im Lande;(die) schweigende Mehrheit
-Situation, die Vorteile für alle bietet;Win-win-Situation;Gewinn für alle Beteiligten;(da) haben alle was davon (ugs.);zum gegenseitigen Vorteil;von beiderseitigem Nutzen;(da) kann keine Seite verlieren (ugs.);zu beiderseitigem Vorteil
-ruhiger Patron (ugs.);zurückhaltender Mensch;stiller Vertreter (ugs.);stilles Wasser (ugs., fig.);sagt nicht viel (ugs.)
-(sich) einander annähern;miteinander warm werden;(sich) näher kennenlernen;vertraut miteinander werden;vertrauter miteinander werden;(sich) näherkommen;Gefallen aneinander finden;(aus etwas) wird mehr (ugs., verhüllend)
-Freundschaft schließen;Freunde werden;(sich) befreunden;(sich) anfreunden
-brieflich kontaktieren;anschreiben;auf dem Postwege kontaktieren;(jemandem) einen Brief schicken
-(jemanden) behelligen;zu Hilfe holen;(jemanden) beanspruchen;in Anspruch nehmen;(jemanden) bemühen;(jemandes) Zeit in Anspruch nehmen
-rettender Strohhalm (fig.);Rettungsanker (fig.);Hoffnungsanker (fig.);letzter Strohhalm (fig.)
-mit allen Habseligkeiten;mit Sack und Pack (ugs.);mit allem (beweglichen) Besitz;mit der ganzen (beweglichen) Habe
-habt ihr zu Hause Säcke an den Türen?;Tür zu!;kannst du die Tür nicht zumachen?
-mit hängenden Schultern;wie ein Schluck Wasser in der Kurve (ugs.);(dastehen) wie ein Fragezeichen (ugs.);wie ein nasser Sack (ugs.);ohne Haltung (körperlich)
-Buchbesprechung;Buchrezension;Buchkritik;Literaturkritik
-Buchkritik;Literaturkritik;Buchrezension;Buchbesprechung
-rekonvaleszent;genesend;gesundend;auf dem Wege der Besserung
-erster Geiger;Konzertmeister
-Stimmführer;Prinzipal (Orchester)
-unverbrauchte Gesichter;frisches Blut (sarkastisch);neue Leute
-der Star sein;(es wird) rote Rosen regnen (für)
-nachmalig (Adj.);kommend;später (Adj.)
-(da) ist der Wurm drin (fig.);(etwas) läuft (da) schief;(etwas) klappt einfach nicht;(etwas) klappt und klappt nicht;(etwas) will (einfach) nicht klappen;(etwas) geht immer wieder schief
-(jemandem wurde) Bettruhe verordnet;das Bett hüten (müssen);(jemanden) niederstrecken (geh.);mit (...) im Bett liegen;(jemanden) aufs Lager werfen (geh., fig., veraltend);bettlägerig (sein);(jemanden) aufs Krankenbett werfen (geh., fig., literarisch, veraltet);flach liegen (ugs.);(jemanden) ans Bett fesseln (fig.);(jemanden) aufs Krankenlager werfen (geh., fig., literarisch, veraltet);(schwer) darniederliegen (geh.);nicht aufstehen (können);nicht aufstehen (dürfen);ans Bett gefesselt sein (fig.)
-im Krankenhaus;mit Aufnahme im Krankenhaus;stationär
-Krankenhausarzt;Arzt an einer Klinik;Spitalsarzt (österr.);Klinikarzt;Arzt am Krankenhaus
-AiW;Assistenzarzt;Arzt in Weiterbildung
-Forschungsreisender;Entdeckungsreisender;Entdecker
-kann auf eine lange Geschichte zurückblicken;hat eine lange Geschichte;traditionsreich
-Beipackzettel;Patienteninformation
-in die nächste Runde gehen (fig.);in die nächste Instanz gehen (Rechtsstreit);vor der nächsthöheren Instanz ausgetragen werden
-im Film;(nur ein) Film;Teil einer fiktionalen Handlung;nur gespielt
-aus dem Leben gegriffen;(ganz) wie im richtigen Leben;Das Leben schreibt doch die schönsten Geschichten. (ugs., sprichwörtlich)
-unaussprechlich;tabu;Tabu;(etwas) über das man nicht spricht;(etwas) über das nicht gesprochen wird;(etwas) über das nicht gesprochen werden darf;Tabuthema
-Comingout;Coming-out;öffentliches Bekenntnis zu
-(öffentliches) Eingeständnis seiner Drogenvergangenheit;(öffentliche) Drogenbeichte
-geläutert;geheilt (von);wieder auf dem rechten Weg (fig.);erleuchtet (ironisch);wieder in der Spur;gefestigt;gewachsen (fig., pathetisch);auf einer moralisch höheren Stufe
-es herrscht;es ist;es gibt;(etwas) ist da;(etwas) ist eingetreten;wir haben
-donnern und blitzen;gewittern
-wettern;donnern und blitzen;gewittern
-poltern;donnern;krachen;rumpeln;rumsen
-Baumdiagramm;Baumgraph;Stemma;Verzweigungsdiagramm
-Strukturbaum;Phrasenstrukturdiagramm
-mit dem größten Vergnügen;nichts lieber als das;nichts lieber tun als;liebend gerne;mit Handkuss (fig., ironisch);mit Kusshand (fig.);sehr gerne;hätte sich (mir / dir ...) nichts sehnlicher wünschen können
-Märchenprinz;Traumprinz;Traummann;Mann ihrer Träume
-Mr. Right (ugs., engl.);Mann fürs Leben;(der) Mann ihres Lebens;der Richtige (ugs.)
-Zurückweisung (einer Behauptung);Widerruf;Verwahrung;Widerrufung;Gegendarstellung;Gegenerklärung;Dementi (geh.);Richtigstellung
-Rekonstruktion;Rückverfolgung;Ahnenforschung (ugs.)
-naheliegen;plausibel erscheinen
-Frauenverführer;Frauenversteher;Frauenflüsterer
-monogam;an einen Partner (dauerhaft) gebunden
-Swingerclub;Swinger-Club;Swingerklub
-Bettgeschichte (ugs., Hauptform);Fickverhältnis (derb);Bumsbeziehung (ugs.);(rein) sexuelle Beziehung;Sexbeziehung;Fickbeziehung (derb);Bettbeziehung
-Dreiecksverhältnis;Dreierkiste (ugs.);Ménage-à-trois (geh., franz.);Dreiecksbeziehung;Dreieckskiste (ugs.)
-Dating-Portal;Singlebörse;Kontaktbörse;Datingportal
-Sex-Treff;Klappe (Schwule)
-Sex ohne Kondom;ungeschützter Geschlechtsverkehr;ungeschützter Sex
-Sexualkontakt;sexueller Kontakt;Intimkontakt
-sexuelle Praxis;sexuelle Aktivität;Spielart der Sexualität;sexuelle Handlung
-Sex (liegend) von vorne (ugs.);ventro-ventrale Kopulation (wiss.) (fachspr.);Missionarstellung
-Gangbang;Gruppenvergewaltigung
-Spannerei;Spannen;Voyeurismus
-Exhibitionismus;(das) Flitzen;(das) Sich-Entblößen;(das) Sich-zur-Schau-Stellen
-Hypersexualität (fachspr.);Erotomanie;Sexsucht
-Nymphomanie;Mannstollheit;Klitoromanie;Andromanie
-Donjuanismus;Satyrismus;Satyriasis
-One-Night-Stand;ONS;flüchtiger sexueller Kontakt
-Cholesterol;Cholesterin
-Mode im Vintage-Stil;Retro-Mode;Mode im Retro-Look
-in Anlehnung an;frei nach;unter Anspielung auf
-getreu dem Wahlspruch;nach der Devise;dem Leitsatz folgend (dass) (geh.);(frei) nach dem Motto
-Definitionsmacht (geh.);Interpretationsmacht (geh.);Deutungshoheit (geh., Hauptform);Diskurshoheit (geh.)
-Prioritätsinversion;Prioritätsumkehr
-purer Zufall (sein);(etwas) entscheidet der Zufall;reiner Zufall (sein) (ugs.);Glückssache (sein);dem Zufall überlassen bleiben
-beliebig;blindlings;aufs Geratewohl;ohne (erkennbares) System;nach dem Motto "Nützt's nichts, schadet's nichts";auf Verdacht (ugs., fig.);nach dem Motto "Wird schon gutgehen";blind;auf gut Glück (Hauptform);ins Blaue hinein
-Bezahlschranke;Paywall (engl.)
-flexibles Endoskop;Flexoskop
-Videoskop;Videoendoskop
-Koloskop;Kolonoskop
-Bodenpunkte;Ackerwertzahl;Ackerzahl
-Glefe;Gläve;Gleve;Fouchard (franz.);Couteau de breche (franz.);Gläfe;Fauchard
-Hellebarde;Helmbarte
-Transalpine Pipeline;Transalpine Ölleitung
-Bayerisches Chemiedreieck;Südostbayerisches Chemiedreieck
-querbeet;über Stock und Stein;querfeldein;über wegloses Gelände
-wahllos;immer locker (ugs.);immer munter (ugs.);querbeet;(einfach) drauflos;lustig (weiter)
-böser Bube (scherzhaft-ironisch);Bösling (selten);Strolch
-missratener Sohn;Rabenaas (ugs., fig.);(freches) Luder (weibl.);Enfant terrible (geh., franz.);(das) schwarze Schaf der Familie (fig.);Satansbraten (ugs.);missratene Tochter;kleiner Teufel
-Stinkstiebel (ugs., regional);Spielverderber;Stänkerer (ugs.);Stinkstiefel (ugs.);Miesmacher;Bedenkenträger (geh.);Quertreiber
-Mitnahmesuizid;erweiterter Suizid;erweiterter Selbstmord
-Pfannkuchengesicht;Mondgesicht (ugs.)
-Gesicht;vorgeschobene Unterlippe;Flunsch (ugs.);Schmollmund;Fleppe (ugs.);Schnute (ugs.)
-(eine) Leiche im Keller haben (fig.);(etwas) zu verbergen haben (Hauptform);(ein) schmutziges Geheimnis (haben);(ein) schlechtes Gewissen (haben);Leichen im Keller haben (fig.);kein reines Gewissen haben;Dreck am Stecken haben (ugs., fig.);(etwas) auf dem Gewissen haben
-laufend;in kurzen Abständen immer wieder;alle nasenlang;alle paar Augenblicke;alle paar Minuten (mal) (variabel);alle naselang;alle paar Sekunden
-Bänkchen;kleine Bank;Bankerl (bayr.)
-plausibel machen;plausibilisieren
-im Abstand von wenigen (...);alle paar (...)
-unüberschaubar;grenzenlos;verschiedenartig;zahlreich;vielfältig;mannigfaltig;reichhaltig
-(das) reguliert sich (selbsttätig);(das) geht (von allein) vorüber;(das) legt sich;(das) verschwindet (von selbst);(das) gibt sich (wieder);(das) erledigt sich (von selbst)
-Kamerawagen;Dolly
-Mikrofonstativ;Mikrofonständer
-Schwenkarm (Mikrofonständer);Galgen
-(sich) aufhalten;zu finden sein;weilen (oft scherzh.) (veraltet);(Zeit) verbringen;(sich) befinden;(irgendwo) stecken;(irgendwo) sein;anzutreffen sein
-(sich) einmieten;(irgendwo) unterkommen;(sich) einquartieren;(sich) einnisten (negativ);vor Anker gehen (fig.);(ein) Zimmer nehmen;Quartier nehmen;Quartier beziehen;(eine) Wohnung nehmen;(eine) Wohnung finden;(eine) Bleibe finden (geh.)
-gestrandet sein;nicht weiterkommen;kleben bleiben;hängen bleiben (fig.);(irgendwo) festsitzen (auch figurativ);nicht (wieder) wegkommen;hängenbleiben (fig.)
-Melodrama;Melodram;Drama
-Sympathiestreik;Solidaritätsstreik
-Bummelstreik;Dienst nach Vorschrift
-Auslese;Bestenauslese;(die) Besten (der Besten);Elite;(die) Crème de la Crème (des / der ...) (geh., franz.);Auswahl;(die) erste Garde (fig.);(sich lesen wie ein) Who is who (von) (floskelhaft)
-(etwas) offenbaren (das verheimlicht werden sollte);(etwas) spricht Bände (ugs., fig.);Das erklärt vieles. (ugs., Spruch);tief blicken lassen;vielsagend (sein);bezeichnend (sein);verräterisch (sein);Das sagt alles. (ugs., Spruch);Das will (et)was heißen ! (ugs., Spruch)
-seinen Niederschlag finden;zu entnehmen sein;erkennen lassen;verraten;offenbar werden;(an etwas) zu erkennen sein;deutlich werden lassen;zum Ausdruck kommen;(sich) zeigen (in);zeigen
-vorkommen;nicht ausbleiben;zu sehen sein;auftreten;anzutreffen sein;zu finden sein
-heimlichtuerisch (geh., selten);mit Verschwörermiene;mit Verschwörerblick;verschwörerisch
-(einander) tief in die Augen schauen;tiefe Blicke tauschen;(sich) eindringlich ansehen
-Saftladen (ugs., abwertend);schlecht geführtes Unternehmen;Scheißladen (beleidigend) (derb)
-(ein) Bild des Elends;arme Sau (derb);Elendsgestalt (geh.);(ein) Bild des Jammers;armes Schwein (ugs.)
-Dahlien;Georginen
-Catering;Verpflegung
-Bötchen;Zille (regional);Weidling (regional);Barke;(kleines) Boot;Fischerboot;Gondel (Venedig);(kleiner) Kahn;Nachen (poetisch, süddt.)
-Kriegsschiff;Kampfschiff;Schlachtschiff
-Vertilger;Vernichter;Zerstörer (Hauptform);Verheerer;Verwüster;Brandschatzer
-Flugdeckkreuzer;Helikopterträger;Flugzeugträger;Hubschrauberträger
-voll betakelt;unter Vollzeug;voll aufgetakelt
-Gefälligkeitspolitik;Gefälligkeitsdemokratie;Klientelpolitik
-(es) stellt sich die Frage;(es) stellen sich Fragen;Fragen aufwerfen
-Müdigkeit;Abgespanntheit;Zerschlagenheit;Mattigkeit;Abgeschlagenheit;Defatigation (fachspr.);Erschöpfung
-Anerkennung;Streicheleinheit(en) (fig.);lobende Worte;Lob;Worte der Anerkennung;Belobigung;Würdigung
-Preislied (literaturwiss.);Preisgedicht (literaturwiss.)
-(eine) Liebenswürdigkeit;anerkennende Äußerung;freundliche Worte;Kompliment;(eine) Nettigkeit;(eine) Freundlichkeit;nette Worte
-Anbiederung;Liebedienerei;Schöntuerei
-Kuschelpolitik;Kuschelkurs;Schmusekurs
-jeder seine eigenen;je eigene
-Verklärung;Idealisierung;Hochstilisierung;Überhöhung
-immer erfolgreicher werden;im Kommen (sein);(sich) wachsender Beliebtheit erfreuen;immer beliebter werden;im Aufwind (sein);zunehmend populär werden
-Machertyp;(der) Nimmermüde;nicht viele Worte machen (ugs.);Aktivling (ugs.);Tatmensch;Nicht quatschen. Machen! (ugs., Spruch);Macher (Hauptform);Powerfrau (ugs., Jargon, Hauptform, weibl.);Energiebolzen (ugs.);Mann der Tat (männl.);immer am Ball (sein) (fig.)
-Gipfelstürmer (fig.);unbedingt nach oben wollen (ugs.)
-Triebfahrzeug;Lok (Kurzform);Lokomotive
-neu (ungewohnt) (Hauptform);fremd;gewöhnungsbedürftig;andere(r);ungewöhnlich;ungewohnt;andersartig
-(das) Ideale;(das) Wahre, Gute, Schöne;(das) Gute, Wahre, Schöne
-(eine) idealistische Einstellung;(das) Streben nach dem Guten, Wahren, Schönen;Idealismus
-lahme Ente (ugs., fig.);Schnarchnase (ugs.);(ihm/ihr) kann man im Laufen die Schuhe besohlen (ugs., Spruch);Transuse (ugs.);Trantüte (ugs.);Tranfunzel (ugs.);Lahmarsch (derb);Penner (derb);Schnecke (ugs., fig.);Schlafmütze (ugs.)
-Sechziger-System;Hexagesimalsystem;Sexagesimalsystem
-(jemandes Sachen) kontrollieren;nachschnüffeln;nachspionieren;hinterherschnüffeln;(in jemandes Sachen) herumschnüffeln;hinterherspionieren
-nicht aus den Augen lassen;misstrauisch beäugen;fortwährend ansehen;im Auge behalten;fortwährend in jemandes Richtung blicken;belauern
-ständig im Blick haben;(jemanden) belauern;im Auge behalten;observieren;nicht aus den Augen lassen;überwachen;beobachten
-spähen;auf der Lauer liegen;Ausschau halten;lauern
-(seinen) Beobachtungsposten beziehen;(jemandem) auflauern;(sich) auf die Lauer legen
-bespitzeln (ugs.);überwachen;ausspähen;beschatten;bewachen;(jemandem) folgen wie sein Schatten;(jemandem) unauffällig folgen;observieren
-binäre Option;digitale Option
-Derivat;derivatives Finanzinstrument
-Zugewinn;(ein) Mehr (an)
-(ein) Konto bei Facebook haben;Mitglied bei Facebook sein;auf Facebook sein
-verweichlichen;zum Weichei werden;an Härte verlieren
-under cover (engl.);geheim;unter falscher Identität;verdeckt
-(sich) nicht abschütteln lassen;dranbleiben;(jemandem) dicht auf den Fersen bleiben
-Beendigung;Einstellung;Ende;Schluss;Abbruch
-von hoher Warte;von höherer Warte (geh., fig.);mit (viel / mehr / dem besten / optimalem) Überblick
-hereindürfen;Zutritt haben
-(der) schnöde Mammon (geh.);(das) liebe Geld (ugs.)
-(ein) Eingreifen ist nötig;(sich) genötigt sehen, einzuschreiten;aktiv werden müssen;(es gibt) Handlungsbedarf (Hauptform);Handlungsbedarf (sehen) (variabel);es besteht Handlungsbedarf
-ausgezeichnet (Adverb);sehr gut (Hauptform);hervorragend (Adverb)
-(miteinander) verflochten;verfilzt (abwertend, fig.);(miteinander) verschränkt;(mit-/in/-untereinander) verwoben;(untereinander) versippt (abwertend, fig.)
-Viel Feind, viel Ehr. (Sprichwort);keine Auseinandersetzung scheuen
-Couleur;(weltanschaulich-politische) Ausrichtung;Einstellung
-ohne weiteres tun können;(jemandem) freigestellt sein;unbenommen bleiben;(jemandem) freistehen (Hauptform);nicht gehindert sein (zu + Infinitiv) (fachspr., Amtsdeutsch, juristisch);(jemandem) überlassen bleiben;(frei) schalten und walten (können);unbenommen sein;(jemandem) zugestanden werden
-konfliktscheu;mag keinen Streit;harmoniebedürftig;harmonieorientiert;harmoniesüchtig (abwertend);(sich gegenseitig) nicht weh tun (wollen)
-Vorbildfunktion;(in seiner/ihrer) Rolle als Vorbild
-(dünnes) Fähnchen (ugs.);Kleidchen;kurzes Kleid
-lästiges Beiwerk;notwendiges Übel
-(eine) conditio sine qua non (geh., bildungssprachlich, lat.);unabdingbare Voraussetzung;(etwas) muss sein (ugs.);(es) geht nicht ohne (ugs.)
-unerwünschte Arzneimittelwirkung;Nebenwirkung
-auf dem linken Auge blind (sein);linkslastig (sein)
-rechtslastig (sein);auf dem rechten Auge blind (sein)
-Ringzähler;Ringschieberegister
-ehrlich nicht;(etwas) geht einfach nicht (ugs.);auch wenn ich mich noch so sehr anstrenge nicht;so leid es mir (auch) tut, aber (...);wirklich nicht;beim besten Willen nicht (Hauptform);auch wenn ich mir noch so viel Mühe gebe nicht;bei aller Liebe nicht
-Vertrag ist Vertrag.;Pacta sunt servanda. (bildungssprachlich)
-Vorbereitungszeit;Vorlaufzeit;Vorlauf
-(und) damit hat sich's (ugs.);und fertig! (ugs.);und gut ist! (ugs.);(und) das wär's;und dann bin ich durch mit der Nummer (ugs.);Punkt.;und fertig ist die Laube! (ugs.)
-(das wäre) geschafft!;Das hätten wir. (Spruch);fertig!;es ist vollbracht! (pathetisch);Mission erfüllt.;Und steht! (ugs., Spruch)
-im Raum stehen (fig.);(etwas) wurde angesprochen;(die Frage) wurde aufgeworfen;(etwas) ist Thema;(von etwas) war die Rede
-langgestreckt;raumgreifend;groß;weit ausholend (Gesten);Platz beanspruchend;ausgreifend (Schritte)
-raumgreifend;raumfüllend;dominierend
-rechtsorientiert;wertkonservativ;(politisch) rechtsstehend;rechts stehend
-Sachen gibt's ... (ugs.);Was sagt man dazu!? (ugs.);Sachen gibt's, die gibt's gar nicht! (ugs.);man will es kaum glauben;kaum zu glauben, aber wahr (ugs.);unglaublich (aber);Man hat schon Pferde kotzen sehen (, direkt vor der Apotheke). (ugs., Spruch);Wirklich erstaunlich. (ugs.);Man soll das (ja) kaum für möglich halten! (ugs., ironisierend);man glaubt es nicht (aber);Da staunt der Laie, und der Fachmann wundert sich. (ugs., Spruch);Kaum zu glauben, aber amtlich. (ugs., Spruch);Was es nicht alles gibt! (ugs., Spruch)
-Steppenläufer;Bodenroller;Bodenläufer;Steppenroller
-höhere Weihe(n);Aufwertung
-(sich) etwas zusammenreimen;eins und eins zusammenzählen können;(sich) etwas denken können;von alleine draufkommen (ugs.)
-die Welt wieder in Ordnung;alles wieder in Ordnung
-(diese Sachen) hinter sich haben (ugs.);nicht mehr sexuell aktiv;jenseits von Gut und Böse
-lass mich in Ruhe damit;keine Zeit für so etwas;(etwas) besseres zu tun haben;(danke,) kein Interesse;seine Zeit nicht gestohlen haben;wenig Engagement an den Tag legen (in einer Sache);(das) interessiert mich nicht
-Pfoten weg! (ugs.);lass die Finger davon (ugs.);pack das nicht an (ugs.);fassen Sie das nicht an;Hände weg!;Finger weg! (ugs.)
-einen Bogen machen (um) (fig.);nichts zu tun haben wollen mit
-Beiwerk;Begleitumstände
-Vornehm geht die Welt zugrunde.;mit wehenden Fahnen untergehen;mit Glanz und Gloria untergehen
-Glamour;Showeffekt;glanzvoller Auftritt;Glanz
-Höhen und Tiefen;Glanz und Elend
-(die) Glitzerwelt (des / der ...);(nur) Fassade (fig.);schöner Schein
-raue Wirklichkeit;harter Boden der Tatsachen;traurige Wirklichkeit;bittere Wahrheit;traurige Realität;harte Realität;traurige Wahrheit
-Riesenbaby (ugs., fig., scherzhaft);Elefantenküken (ugs., fig., scherzhaft)
-Jungengesicht;Babyface;Jungmädchengesicht
-stolz sein (auf);(sich etwas) zugutehalten;(sich etwas) ans Revers heften (können) (geh., fig.);(sich) in die Brust werfen;(sich) brüsten (mit)
-d. J. (Abkürzung);dieses Jahres;diesen Jahres
-schön, wenn man helfen kann;wenn man helfen kann...;war mir ein Vergnügen;jederzeit gerne;gerne wieder;immer gerne;stets zu Diensten
-(ach) Quatsch (ugs.);Unsinn! (ugs.);(ach) papperlapapp (ugs.)
-auf Beutezug gehen;(ein) Opfer suchen
-auf Beutezug (fig.);auf Männerfang (aus)
-was fürs Bett suchen;auf Beutezug sein (fig.);was zum Vernaschen suchen
-(aus jemandem) wieder einen anständigen Menschen machen;auf den Pfad der Tugend zurückführen
-karikaturistisch;karikaturhaft;überzeichnet;überzogen;karikiert;karikaturesk;karikaturartig;karikativ;überstilisiert;überspitzt;übertrieben
-Netzmaske;Netzwerkmaske;Subnetzmaske (fachspr.)
-Antischiffrakete;Antischiffsrakete
-Radiokohlenstoffdatierung;Radiokarbondatierung;C14-Datierung;Radiokarbonmethode
-Störfall;kerntechnischer Unfall
-Auslegungsstörfall (fachspr., Jargon);Unfall (in einem AKW) mit katastrophalen Folgen;GAU (Abkürzung)
-auslegungsüberschreitender Störfall;AKW-Havarie mit Folgen von apokalyptischen Ausmaßen;Super-GAU
-zwischenstaatlich;grenzüberschreitend;international
-Hausmittel;für den Hausgebrauch;Hausmittelchen (leicht abwertend)
-(...) wirken;gut (sein) bei;eine (...) Wirkung haben;helfen gegen;helfen bei;(wahre) Wunder wirken;gut (sein) gegen
-nicht das kleinste bisschen;nicht die Bohne (ugs.);nicht die Spur (ugs.);kein bisschen;nicht für zwei Cent (ugs., fig.);keine Spur (ugs.);keinerlei;nicht ein bisschen;kein(en) Millimeter;nicht ein(en) Millimeter;kein(en) Jota;kein(en) Deut;kein(en) Funken;nicht für zwei Pfennige (ugs., Redensart, fig., veraltet);nicht das kleinste Bisschen;kein Stück (ugs.)
-Gelber Hartriegel;Kornelkirsche (Baum);Dirndl (österr.);Herlitze;Tierlibaum (schweiz.);Cornus mas (fachspr., botanisch)
-Kornelle;Kornelkirsche (Frucht)
-Blutiger Sonntag;Roter Sonntag;Petersburger Blutsonntag;Schwarzer Sonntag
-zellulärer Automat;zellularer Automat;Zellularautomat
-wie in einem schlechten Film (ugs., variabel);derb;seicht;ohne Ambition(en);ohne Niveau;anspruchslos (geh.);ohne Anspruch;nicht besonders einfallsreich (ugs.);Billig...;wenig ambitioniert (verhüllend);unambitioniert (geh., verhüllend);schlecht;primitiv;nicht (besonders) ambitioniert;flach;niveaulos (geh., Hauptform);platt;billig
-anschließende(r);darauffolgende(r);sich anschließende(r);folgende(r);nachfolgende(r);nächste(r) (Hauptform);nachstehende(r)
-darüber;über diesen Sachverhalt;darob (geh., veraltet);hiervon;über diese Tatsache;davon;hierüber;über diese Angelegenheit;diesbezüglich (Amtsdeutsch)
-Riese (fig.);Gigant (fig.);(ein) Gott (fig.);Titan (fig.)
-Geistesgröße;Geistesriese;Denkriese
-außerhalb des (menschlichen) Vorstellungsvermögens liegen;kaum vorstellbar (sein);(die) menschliche Vorstellungskraft übersteigen;(etwas) kann man sich nicht vorstellen
-aus der Mottenkiste holen (ugs., abwertend);reaktivieren;aus der Vergessenheit holen;(wieder) wachküssen (fig.);(wieder) aktivieren;aus der Versenkung holen;aus dem Dornröschenschlaf wecken (ugs.);(wieder) Leben einhauchen
-erinnert an;lässt denken an;hat etwas von;verströmt den Charme (von ...)
-relative Dichte;spezifische Dichte
-halten was man verspricht;Versprochenes halten;nicht wortbrüchig werden;zu seinem Wort stehen;einhalten was man (einmal) zugesagt hat;(sein) Wort halten;halten was man (einmal) versprochen hat;(seine) Zusage einhalten;(sich) an seine Zusage(n) halten;nicht zu viel versprochen haben (fig.);bei dem einmal Zugesagten bleiben
-(auf jemanden) kann man sich nicht verlassen;unverlässlich (sein);(ein) unsicherer Kantonist (sein) (geh., selten);(auf jemanden) kann man nicht bauen;unzuverlässig (sein);(auf jemanden) ist kein Verlass;(ein) unsicherer Kandidat (sein) (ugs.);(eine) treulose Tomate (sein) (ugs., scherzhaft)
-Hauptschuldiger;(*der*) Bösewicht (schlechthin) (ugs.);Hauptverantwortlicher
-(die) Büchse der Pandora öffnen (fig.);(ein) Unheil in die Welt bringen
-von der Mafia durchsetzt;mafiaartig;nach Art der Mafia;mafiös;mafiaähnlich
-abwechslungsreich;veränderlich;voller Umschwünge;wechselvoll;voller Veränderungen;voller Wechselfälle
-mit viel;mit vielen;reich an;erfüllt von;gesegnet mit (geh.);...beladen;voller
-Steinmanderl;Steinmännchen;Steinmann;Steinmandl;Steindauben
-Parameter;Formvariable
-Unbekannte;Unbestimmte
-Definitionsbereich;Definitionsmenge
-Grundmenge;Universum
-Dummy-Variable;Stellvertreter-Variable;Scheinvariable
-Proxy;Proxy-Variable
-Unzurechnungsfähigkeit;Schuldunfähigkeit;Zurechnungsunfähigkeit (veraltet)
-(ein) Auserwählter;(ein) Erkorener;(ein) Auserkorener;(ein) Geweihter;(ein) Gesalbter
-(etwas) abgemacht haben;(etwas) verabredet haben;verblieben sein;(etwas) vereinbart haben
-Unterstützer;Sympathisant;Mitstreiter;Parteigänger;Anhänger
-Einstellschraube;Justierschraube
-Feststellschraube;Klemmschraube
-Schoktzen;Schokatzen
-Lissabonner Strategie;Lissabon-Prozess;Lissabon-Strategie;Lissabon-Agenda
-(in die) Zielgerade (einbiegen);heiße Phase;Schlussetappe;Endphase;Endspurt;letzte Runde
-nicht nur ein;gleich mehrere
-Finishing;Feinschliff;Endbearbeitung;Endschliff
-Enthalpie (fachspr., griechisch, Hauptform);Wärmeinhalt
-nach Luft schnappend;japsend;schnaufend;keuchend
-(sich) gütlich tun (an) (geh.);(sich) stärken (an);(sich) erquicken (geh.);(einer Speise / einem Getränk) zusprechen (geh.);(ordentlich) zulangen (ugs.);(sich) laben (an);reinhauen (ugs.)
-Albion (geh.);England
-durch (nachgestellt bei Uhrzeit) (ugs.);vorbei (Uhrzeit) (ugs.);(um) kurz nach (Uhrzeit) (ugs.);nach (Uhrzeit) (ugs., Hauptform)
-durchkommen;(etwas) überstehen;am Leben bleiben;überleben;(es) schaffen
-Umhüllung;Überwurf;Schoner;Schonbezug
-kurz vor dem Abschluss stehen;(mit etwas) in den letzten Zügen liegen (fig.)
-vor geraumer Zeit;vor Jahr und Tag;vor längerer Zeit
-(einen) Grenzfall (darstellen);auf der Kippe stehen;(ein) Grenzfall (sein)
-scharfe Braut (ugs.);Sahneschnittchen (ugs., fig.);flotter Käfer (ugs.);heiße Braut (ugs.);Hottie (ugs., engl.);heißer Feger (ugs.)
-(seine) Verlobte;(seine) Zukünftige
-Kleinstadtschönheit;Schönheit vom Lande;Dorfschönheit;Dorfschöne;Provinzschönheit
-Nixe (fig.);Schwimmerin
-(sich) nehmen;(sich) bedienen;zuschlagen;zugreifen;zulangen
-alkoholgeschwängert;bierselig;weinselig
-Himmelsgegenden;Weltgegenden
-Volkssport (fig., Hauptform);Massenhysterie (abwertend, fig.);Volksseuche (abwertend, fig.);Volkskrankheit (abwertend, fig.)
-Breitensport;Freizeitsport
-Volkssport;Nationalsport
-Berufsstand;Gewerbe;Zunft
-Ölsaat;Ölsamen
-Erlebniswelt;Freizeitcenter
-anspringen (auf);mitziehen;sich (erstmals) befassen mit;auf den Zug aufspringen (fig.);einsteigen (in)
-letzter bewohnter Ort;letzter Außenposten der Zivilisation;letzter bewohnter Außenposten
-Wickeltechnik;Wickelverbindung;Drahtwickelverbindung;Drahtumwicklung
-(eine) Frage der Ehre;Ehrensache
-Gutsgebiet (österr.);Gutsbezirk
-Erweiterter Sonderkanalbereich;Hyperband
-(sich) (selbst) loben;(sich) (selbst) beweihräuchern (fig.);(sich) ganz toll finden;(sich) (selbst) auf die Schulter klopfen;(sich) (selbst) applaudieren
-Betätigungsfeld;Aktionsradius;Aktionsfeld;Tummelplatz (fig.)
-Siebenbrett;Tangram;Siebenschlau
-Brügner'sche Dreiecke;Drei-Dreiecke-Tangram
-Technisches Gymnasium;berufliches Gymnasium technischer Zweig
-Berufliches Gymnasium;Fachgymnasium (veraltet);Berufsgymnasium
-von der obersten Führungsebene;von höchster Stelle;vom obersten Chef;von ganz oben (ugs.)
-Extremsituation;Extrembedingungen;äußerster Notfall
-(ein) Bild der Verwüstung;(aussehen wie) nach einem Bombenangriff (veraltet);(ein) Bild der Zerstörung;(völlig) verwüstet;Trümmerlandschaft;völlig zerstört;aussehen als wenn eine Bombe eingeschlagen wäre
-(ein) Unentwegter;(ein) Unerschrockener;(sich) nicht abschrecken lassen;nicht so schnell aufgeben;einer von den ganz Harten (ugs.);durchhalten;(ein) Die-Hard (sein) (ugs., engl., fig.);(sich) nicht entmutigen lassen;(so leicht) nicht aufgeben
-Störung der Geschäftsgrundlage (juristisch);Wegfall der Geschäftsgrundlage (jur., seit 2002 anders bezeichnet)
-Teilstrecke;Streckenabschnitt;Etappe;Teilstück
-Verkehrsverbindung;Verkehrsweg;Trasse
-Stadtring;Ringstraße
-unschädlich (sein) (juristisch);schadet nicht;kein Nachteil (sein);(etwas) macht nichts
-geübtes Auge;Kennerblick
-Tauchsafari;Tauchkreuzfahrt
-um der Wahrheit die Ehre zu geben;ich muss zugeben;ganz ehrlich (einleitende Floskel) (ugs.);ohne dir schmeicheln zu wollen (variabel);ich muss gestehen (förmlich);unter uns gesagt;seien wir ehrlich (Einschub);ehrlich gesagt;sind wir (mal) ehrlich (ugs., variabel);wenn du mich *so* fragst (ugs.);ich muss schon sagen (ugs., floskelhaft);ich muss ganz ehrlich sagen (ugs., floskelhaft);um es ganz offen zu sagen;um bei der Wahrheit zu bleiben;zugegebenermaßen;wenn Sie mich *so* fragen (ugs.);ganz ohne Schmeichelei gesagt
-nicht sagen was Sache ist;herumlabern (ugs.);ausweichend antworten;um den heißen Brei herumreden (ugs.)
-machen wir immer so (ugs., variabel);(nur) eine Formalität;nichts Besonderes;(eine) reine Formsache;reine Routine
-Klein-Tibet;Baltistan
-Schlüsselwort;reserviertes Wort
-nicht so eine (ugs.);(ein) anständiges Mädchen
-Staubfänger (fig.);Langsteher
-(das angesparte) Kapital aufzehren;(das) Tafelsilber verkaufen (fig., variabel);(sein) Vermögen aufzehren;ans Eingemachte gehen (müssen) (fig.);(sein) letztes Hemd verkaufen (müssen) (fig.);von der Substanz leben (Hauptform);die (letzten) Reserven angreifen
-allgemeine Algebra;universelle Algebra
-universelle Algebra;algebraische Struktur;allgemeine Algebra;Algebra
-Schiefkörper;Divisionsring
-Herrgott ja!;ja doch! (ungeduldig)
-Osteopathie;osteopathische Behandlung;osteopathische Medizin
-auf ausgetrampelten Pfaden wandeln;altbekannte Muster bedienen;wenig Überraschung bieten
-ich hab was Besseres zu tun (als) (ugs.);ganz bestimmt nicht tun;den Teufel werd' ich tun (und ...) (ugs.);(etwas) fällt mir im Traum nicht ein (ugs.);ich denke nicht daran! (ugs.);ich werd(e) den Teufel tun (und ...) (ugs.);(etwas) würde mir im Traum nicht einfallen (ugs.);nicht wollen;ich werde mich hüten (zu / und ...) (ugs.)
-Mietwerkstatt;Hobbywerkstatt (ugs.)
-(jemanden) kalt lassen;nicht jemandes Fall sein;(etwas) uninteressant finden
-in der Gegend herumgucken;(sich) desinteressiert zeigen
-(sich) nicht bemühen um;(jemandem) nicht nachlaufen;keine Anstrengungen unternehmen (um ...)
-(jemanden) abturnen (ugs.);die Lust verlieren;jede Lust verlieren;(jemanden) abtörnen (ugs.);(als) Lustbremse wirken (auf) (ugs.);(jemandem) die Lust nehmen
-(jemanden) kriegen wollen;heiß (sein) auf (ugs.);(sein) Interesse zeigen;(sich) an Land ziehen wollen (ugs., fig.);Lust (haben) auf;(sich) angeln wollen (fig.);hinter jemandem her;(jemanden) haben wollen;geil (sein) auf (ugs.);kriegen wollen (ugs.);scharf auf (ugs.);ein Auge werfen (auf) (fig.);(sich) interessiert zeigen (an);nicht uninteressiert;interessiert an;(sich) interessieren (für);zurückflirten
-kein (weitergehendes) Interesse haben an;nicht weiter interessiert an;(jemanden) lieb und nett finden (aber ...)
-Party-Zelt;Bierzelt;Festzelt
-Stammwürze;Stammwürzgehalt
-Neue Volksmusik;Volkspunk;VolXmusik
-E-Bass;Elektrischer Bass
-Knacker;Knackwurst
-Meerohr;Seeohr (Hauptform);Irismuschel;Abalone
-Grünes Seeohr;Gemeines Seeohr
-inhaltsadressierbarer Speicher;Assoziativspeicher
-besagten;selbigen;diesen
-unzureichende Finanzausstattung;Unterfinanzierung
-(alte) Gurke (ugs., abwertend);(altes) Möhrchen (ugs., regional);altes Teil (ugs.);Liebhaberstück;voll die Möhre (ugs., jugendsprachlich);altes Schätzchen (ugs.);olle Möhre (ugs., abwertend, regional);gutes Stück (ugs.);Sammlerobjekt;Sammlerstück
-Randale;lautstarker Protest
-Unmut äußern;(mächtig) auf den Putz hauen (ugs.);rumschreien (ugs.);Krawall machen;(ein) Geschrei erheben (geh.);schimpfen wie ein Rohrspatz (ugs.);ein großes Palaver veranstalten (ugs.);nicht zu beruhigen sein;zetern;keifen;fluchen wie ein Droschkenkutscher (ugs.);(eine) Szene machen (ugs.);schimpfen;Zorn äußern;Zeter und Mordio schreien (fig.);schnauzen (ugs.);schimpfen wie ein Fischweib (ugs.);fluchen wie ein Bierkutscher (ugs.);fluchen wie ein Fischweib (ugs.);poltern;geifern;(einen) (mächtigen) Wirbel veranstalten (ugs.);herumschreien;fluchen;keifen wie ein Fischweib (ugs.);(die) Welle machen (ugs.);(he)rumpalavern (ugs.);motzen (ugs.);herumzetern (ugs.);wettern (ugs.);lautstark protestieren;(einen) Riesenaufstand machen (ugs.);Randale machen;(einen) Zwergenaufstand veranstalten (ugs.)
-(in der Öffentlichkeit) inszenieren;Aufsehen erregen;(öffentlich) in Szene setzen;(eine) Szene machen (ugs.)
-man hört und sieht nichts mehr (von jemandem) (ugs.);nicht Laut geben (ugs., scherzhaft);nichts von sich hören lassen;(es gibt) kein Lebenszeichen (von);(sich) nicht melden
-untergetaucht (fig.);abgetaucht (ugs., fig.);auf Tauchstation (fig.)
-für niemanden zu sprechen;nicht erreichbar
-Notstopfen;provisorische Stellenbesetzung
-Lückenbüßer (fig.);Notstopfen (fig.);Lückenfüller (fig.);Notnagel (fig.)
-Weltenberg;Urberg;Weltberg;Kosmischer Berg;Urhügel
-Weltachse;Himmelsachse
-Kosmogonie;Kosmogenie (veraltet)
-Prunkrüstung;Paraderüstung
-Bucklige Welt;Land der 1000 Hügel
-Sozrealismus;Sozialistischer Realismus
-Kielstappel;Kielpallen
-auffieren;fieren
-ziehen;herumstreichen;umherstreifen;schnüren (fig.);stromern;laufen;streichen;umherstreichen;streifen;herumlaufen;strawanzen (bayr., österr.)
-Herrschaften! (ugs.);liebe Leute! (ugs.);Freunde! (ugs.);Leute! (ugs.)
-Schneiderelle;Tuchelle;Elle
-Messstab;Mess-Stab;Peilstab;Peilstock
-Blütenstand;Infloreszenz (fachspr., botanisch)
-Citrus maxima (botanisch);Pampelmuse (Baum)
-Grapefruit(baum);Citrus x aurantium (fachspr., botanisch);Citrus paradisi (fachspr., botanisch, veraltet)
-Bitterorangenbaum;Citrus x aurantium (fachspr., botanisch);Pomeranze;Bitterorange;Pomeranzenbaum
-Abrufkredit;Rahmenkredit
-einmal;eines schönen Tages;eines Tages
-(jemand / etwas) mag (...);...liebend;...verliebt;...phil
-...feindlich;...meidend (fachspr., selten);...phob
-...freundlich;unterstützend;entgegenkommend;die Bedürfnisse (von ...) berücksichtigen(d)
-(etwas / jemand) verträgt (...);...tolerant
-aufs Korn nehmen;anlegen (auf);zielen (auf);die Waffe richten (auf);ins Visier nehmen
-Biergarten;Gastgarten
-Kampfverband;Kavallerie (ugs., Jargon, fig., übertreibend);Einsatzgruppe;Task-Force (militärisch)
-Rollkommando;Einsatzkommando;Einsatzgruppe;Einsatzgruppe (SS) (fachspr., historisch)
-Mordgesellen;Mordgesindel;Mörderbande
-Rollkommando (fig.);mobiles Einsatzkommando (auch figurativ)
-Mekka (fig.);Hauptstätte;Hauptstadt (fig.);Heimat;Hochburg
-Besserverdiener;Angehöriger der oberen Mittelschicht;Besserverdienender
-bis zu einem gewissen Grad(e);in gewissem Umfang;in gewissem Rahmen;in gewisser Hinsicht (Hauptform);ein Stück weit (ugs.);zum Teil;in einem gewissen Umfang;teilweise;in gewissem Maß(e)
-hineinlesen;(verborgene) Absichten unterstellen;hineininterpretieren;hineingeheimnissen (geh.)
-zu einem Mysterium emporstilisieren;magische Kräfte zuschreiben;geheimnisvolle Kräfte zuschreiben;mystifizieren;(ein) Geheimnis machen (aus)
-Balsam auf jemandes Seele (sein) (variabel);Balsam für jemandes Seele (sein);(jemandem) schmeicheln;Musik in jemandes Ohren (sein);Ich könnte dir stundenlang zuhören. (Spruch, ironisierend);gerne hören (Hauptform);(das) klingt gut (ugs., Spruch);(jemandem) runtergehen wie Öl (ugs.);(jemandem) guttun;(das) hört sich gut an (floskelhaft)
-(jemandem) gut stehen;(bei jemandem gut) zur Geltung kommen;(jemandem) schmeicheln
-Wertstoffhof;Altstoffsammelzentrum (österr.);Recyclinghof;Mistplatz (wienerisch, österr.)
-Inferenz (geh.);Schlussfolgerung;Konklusion (geh.)
-elegant;beweglich;glattzüngig;anpassungsfähig;wendig;geschickt;gewandt
-reichlich was (an) (ugs.);nicht unbeträchtlich;ziemlich was (an) (ugs.);ein(e) ziemlich(er / -e / -es) (ugs.);recht viel;einig(er / -e / -es);einiges an
-Kennzeichnung;Tagging (engl.);Labeling (engl.);Etikettierung
-iterativ rekursiv;repetitiv rekursiv;endständig rekursiv;endrekursiv
-rekursiv ableitbar;rekursiv;entscheidbar
-Indikatorfunktion;charakteristische Funktion
-partielle charakteristische Funktion;halbe charakteristische Funktion
-semi-entscheidbare Menge;rekursiv aufzählbare Menge;berechenbar aufzählbare Menge;positiv semi-entscheidbare Menge;halb-entscheidbare Menge
-Berechenbarkeitstheorie;Rekursionstheorie
-Logistik (veraltet);symbolische Logik (veraltet);Metamathematik (veraltet);Mathematische Logik
-Mehrfachgefechtskopf;Kassettensprengkopf;Mehrfachsprengkopf
-Langstreckenrakete;Interkontinentalrakete
-Amerikanischer Monarch;Monarchfalter
-Stammreihe;Stammlinie
-Schlacht bei Zirndorf;Schlacht bei Nürnberg;Schlacht an der Alten Veste;Schlacht bei Fürth
-ja genau! (ugs.);meine Rede! (ugs.);ebent! (ugs.);das ist es ja gerade! (ugs.);das hab ich (dir) doch gleich gesagt! (ugs.);du sagst es! (ugs.);hab ich (dir) das nicht gleich gesagt? (ugs.);eben! (ugs.);genau das meine ich!;sag ich doch! (ugs.);mein Reden! (ugs.)
-schlechte Mutter;Rabenmutter (fig.)
-Helikoptermutter (ugs., fig.);Glucke (ugs., fig.);überbehütende Mutter;Supermutti (ugs.);Übermutter
-Renterei;Rentei;Rentamt
-Rentamtmann;Rentmeister
-Landshuter Erbfolgekrieg;bayrisch-pfälzischer Erbfolgekrieg;Bayrische Fehde
-Viztum;Vitzthum;Vizedom;Vitztum
-(ein) Märchen sein;nicht den Tatsachen entsprechen;ins Reich der Legenden gehören
-(etwas ist) zum Greifen nah(e);nur noch (...) entfernt;in greifbarer Nähe;in (unmittelbarer) Reichweite;kurz vor (dem Ziel);nur noch (wenige) ... trennen jemanden (von) (variabel)
-bittere Enttäuschung;herber Schlag;herbe Enttäuschung
-Begeisterungssturm;Sturm der Begeisterung;Woge der Begeisterung;Begeisterungsstürme (auslösen);tosender Applaus;frenetischer Jubel
-für Ruhe sorgen;(sich) Gehör verschaffen
-Vespa (Markenname);Motorroller
-auch sehen (ugs.);zu jemandes Entschuldigung berücksichtigen;(strafmildernd) berücksichtigen;(jemandem) zugutehalten;anerkennen;einräumen
-unglaublicherweise;wundersamerweise;wie durch ein Wunder;auf wundersame Weise
-vorbereiten;bereitstellen;in Stellung bringen (fig.)
-nicht eingesetzt;kaltgestellt;nicht angefordert
-kühl stellen;kaltstellen;abkühlen lassen;kalt stellen
-Geschwindigkeitsklasse;Geschwindigkeitskategorie;Geschwindigkeitsindex
-auktorial (fachspr.);aus Sicht des Autors
-hineingeraten (in);hineinrutschen (in);(irgendwo) reinschlittern (ugs., regional);(irgendwo) reingeraten (ugs., regional);hineinschlittern (in) (ugs.)
-verwickelt werden (in);(sich) hineinziehen lassen (in)
-konformistisch;unkritisch;sagt zu allem Ja und Amen;(ist) mit allem einverstanden;unreflektiert;kritiklos
-Gefahr ist im Verzug;es droht Gefahr
-nicht am Manuskript kleben;frei (reden);ohne Manuskript (reden);nicht am Manuskript hängen
-hoppla (ugs.);autschn (ugs.);hoppala (ugs.);ups (ugs.);uups (ugs.);autsch!
-Feindseligkeiten;Animositäten (geh.);Anfeindungen;Gehässigkeiten
-Gegensätzlichkeit;Gegensatz;(das) Gegeneinander;Widerstreit
-Bruttogehalt;Bruttolohn;Bruttoverdienst
-Stampiglie;Stempel
-brownsche Bewegung;brownsche Molekularbewegung (veraltet)
-in holder Eintracht (ironisch);friedlich;harmonisch;einträchtig
-Kaufmannschaft;Händler;Kaufmannsstand;Kaufleute
-Kaufmann (fachspr., juristisch);Handelsunternehmen
-auf den Cent genau;centgenau;auf Heller und Pfennig (genau)
-babylonische Aufstand;2. jüdisch-römischer Krieg;Diasporaaufstand;Aufstand der Juden gegen Trajan
-Aufstand des 17. Juni;Arbeiteraufstand;Volksaufstand
-Attributivum (geh.);Beiwort;Beifügung;Epitheton (Rhetorik) (fachspr., bildungssprachlich)
-(einen) Riesenfehler machen;(einen) kapitalen Bock schießen (ugs.)
-Chemo (ugs.);Chemotherapie
-Präkambrium;Abiotikum (veraltet);Erdfrühzeit
-Krug;Amphore (antik);Karaffe
-Mondkartierung;Selenografie
-Weinkaraffe;Dekanter
-Kugelung;Ballotage
-russisches Roulette;riskante Sache (Hauptform);Hasardspiel;Vabanquespiel
-Hotelgewerbe;Hotellerie
-hinter jemandem hergehen;hinter jemandem bleiben;(jemandem) folgen (Hauptform);(jemandem) nachgehen;jemandem hinterhergehen;(sich) an jemandes Fersen geheftet haben (sprichwörtlich)
-nachfolgen;später dazukommen;nachtröpfeln (fig.);hinterhergetröpfelt kommen (fig.);(später) nachkommen;nachgetröpfelt kommen (fig.);hinterherkommen
-(jemandem) folgen;(jemanden) verfolgen (Fahrzeug);hinter jemandem herfahren;(jemandem) hinterherfahren;(jemandem) nachfahren
-vorausfahren;vor jemandem herfahren;vorneweg fahren;(schon mal) vorfahren
-ohne Elan;antriebslos;schwunglos;ohne Antrieb;träge;ohne Interesse;gleichgültig;ohne Energie;lustlos;halbherzig
-Rummel (um);Starkult
-(übertriebene) Verehrung;Vergötterung;Kult;Anbetung
-kalfatern;abdichten (beim Schiffbau);kalfaten
-intermetallische Phase;intermetallische Verbindung
-Dreule;Bohrspindel;Rennspindel
-viel zu wenig;bei weitem nicht ausreichend;Tropfen auf den heißen Stein (fig.)
-wenigstens etwas! (ugs., Redensart);Hauptsache (...) (ugs.);besser als nichts;immerhin (ugs.);wenigstens;das ist die Hauptsache (Redensart);Nicht viel, aber der Mensch freut sich. (ugs., Redensart);mal ein Anfang (ugs.)
-Infusionen bekommen;infundiert werden (med.) (fachspr.);am Tropf hängen (ugs.)
-Viertele (regional);Schoppen (regional)
-edles Tröpfchen;edler Tropfen;gutes Tröpfchen;guter Tropfen
-Rosé;Roséwein
-(einen) Beifallssturm entfachen;(die Zuschauer) zu Beifallsstürmen hinreißen;(das Publikum) von den Sitzen reißen
-Stand (+ Datum);nach dem Berichtsstand von;per (fachspr., kaufmännisch);mit Stand von;auf der Grundlage der (aktuell) verfügbaren Informationen
-unverschlüsselt (ausgestrahlt o.ä.);(im) Free-TV
-Abofernsehen;Bezahlfernsehen;Bezahl-Fernsehen;Pay-TV (engl.)
-wollte ich nur mal gesagt haben (ugs.);ich mein ja nur ... (ugs.)
-Hausse;Bullenmarkt;Boom;Hochkonjunktur
-es gibt (hier) Tausende von (...) (variabel);wimmeln von;wimmeln vor;(es ist) alles voll von (ugs.)
-quirlig;(ein) unruhiger Geist (sein);Pfeffer im Hintern haben (ugs.);immer in Aktion;nicht stillsitzen können;keine Ruhe im Hintern (haben) (ugs.);nimmermüde;rastlos;ruhelos;rege;immer in Bewegung;regsam;Hummeln im Hintern haben (ugs.)
-aufgekratzt (ugs.);aufgedreht;überdreht;aufgeregt;aufgeputscht;aus dem Häuschen (ugs.);unter Strom (ugs., fig.)
-Nebenwirkung (med.);(unerwünschte) Begleiterscheinung;Kollateralschaden (fig.)
-Handschrift (fig.);Manier;(persönlicher) Stil;Ausführungsweise;charakteristische Vorgehensweise
-Zeitnot;Zeitdruck;Termindruck
-Ultimo;(der) Letzte (eines Zeitabschnitts);Monatsende;letzter Banktag (im Monat)
-nicht wirklich witzig;im Kalauer-Stil;kalauermäßig
-jung;jung an Jahren (lit.);(erst) zarte (...) Jahre alt (sein)
-rüstig;munter;junggeblieben;(noch) unternehmungslustig;agil;vital;kregel (ugs.)
-von jugendlicher Ausstrahlung;jünger aussehend;jugendlich wirkend;jungenhaft wirkend;(jemandem) sein Alter nicht ansehen;junggeblieben;für (...) durchgehen
-gehalten werden (für);wirken wie;aussehen wie;durchgehen (für)
-Bustrophedon;Boustrophedon
-Paranomasie (fachspr., rhetorisch);Annominatio (fachspr., rhetorisch);(brachiales) Wortspiel;Paronomasie (fachspr., rhetorisch);Annomination (fachspr., rhetorisch);Sinnentstellung;Sinnverfälschung;Verballhornung
-nuklearer Holocaust;atomarer Holocaust
-Brillant;(geschliffener) Diamant;Brilli (ugs.)
-erheblich;deutlich;sehr (vor Verben oder Partizipien 2);kräftig;heftig;stark;ausgiebig;mächtig;dass es nur so (...) (ugs., variabel);doll (ugs.);intensiv;tüchtig (ugs.);dramatisch (journal.)
-Anwendungslogik;Geschäftslogik
-Schichtenarchitektur;Schichtenmuster;Schichtenmodell
-Eigenverlag;Selbstverlag
-Fraternisierung;Fraternisation
-Schlafmützigkeit;Transusigkeit (ugs.);Lethargie;Tranigkeit
-Aldanhochland;Aldanbergland
-Stanowoigebirge;Stanowojgebirge
-Krimi;Kriminalfilm
-Brasilianisches Dreibindengürteltier;Dreibinden-Kugelgürteltier;Nördliches Kugelgürteltier
-systemimmanent;systemeigen
-Tamilisch;Tamil
-Titelbild;Titelseite;Titelblatt;Titel;Deckblatt;Cover
-Pejorativum;Wort mit abwertender Bedeutung;Pejorativ
-Schweizer Riegel;Rappan-Riegel;Verrou
-Signifiant (franz.);Bezeichner;Signans;Bezeichnendes;Signifikant
-(ein) gewöhnlicher Sterblicher;kein Supermann;Mensch unter Menschen;keine Superfrau
-Holzschuh(e);Holzpantine(n);Pantine(n) (regional);Klompe(n) (niederländisch, regional)
-Juckreizstiller;Antipruriginosum;Antipruritikum (selten)
-(es wird) (dringend) Hilfe gebraucht;(es ist) Not am Mann (ugs.)
-Megalithanlage;Großsteingrab;Dolmen;Hünengrab
-Kubikdezimeter;dm³ (Einheitenzeichen)
-Liter;l (Einheitenzeichen)
-fesselnd;aufregend;mitreißend;mit Thrill;packend;spannend wie ein Krimi;nervenzerreißend;spannend;(sich) lesen wie ein Krimi;atemberaubend;prickelnd (ugs.);faszinierend;nervenzerfetzend;Spannung erzeugend;spannungsreich
-Konfusionsgefahr;Verwechslungsgefahr
-verwechslungsgefährdet;leicht (mit etwas anderem) zu verwechseln;verwechselbar
-Clusteranalyse;Ballungsanalyse
-Kohonenkarte;selbstorganisierende Karte;Kohonennetz
-Fahrt, die kein Ende nimmt;sehr weite Fahrt;Odyssee (fig.);Himmelfahrt (ugs.)
-innere Sekretion;Inkretion
-Unkrautfläche;Unkrautflur;Unkrautwüste (ugs.)
-Vorsicht ist besser als Nachsicht. (sprichwörtlich);Vorsicht ist die Mutter der Porzellankiste. (sprichwörtlich);Vorbeugen ist besser als Heilen. (sprichwörtlich)
-Homophon;Homofon
-...esk (geh.);...haft;...mäßig;...artig;...like (Jargon, engl.)
-nichts anderes trinken (als ...);bei (...) bleiben
-(sich) an der Bierflasche festhalten;herumstehen (mit seinem Bier in der Hand) (Disco);(sich) am Bierglas festhalten;(he)rumsitzen (und sein Bier anstarren) (Bar) (ugs.);nicht aktiv werden (Party)
-nichts mit sich anzufangen wissen;nicht wissen, was man tun könnte;nichts zu tun finden;nicht wissen, was man tun soll
-nicht gebraucht werden;keine Aufgabe haben;(auf jemanden) wartet niemand (ugs.);unbeschäftigt sein;niemand verlangt etwas (von jemandem);nichts zu tun haben;nicht gefordert sein;ohne Beschäftigung sein
-(einfach) sagen müssen;(jemandem) entfahren (geh.);herausplatzen (mit) (ugs.);(sich etwas) nicht verkneifen (können) (ugs.)
-Berichterstattung;Reporting (engl.)
-Einfließen;Influx;Einströmen
-Rechtsmediziner;Gerichtsmediziner (veraltet);Forensiker (ugs.);Facharzt für forensische Medizin (fachspr.)
-Gegenstempel;Kontermarke
-abgefilmt;fertig;fertig aufgenommen;im Kasten;(fertig) abgedreht
-die geschichtliche Entwicklung der Sprache betreffend;diachron
-Kurzanleitung;Schnelleinstieg
-Randständige (schweiz.);Minderheit;(soziale) Randgruppe (Hauptform)
-genau passen;sitzen;(die) richtige Größe (sein);(die) richtige Größe (haben);sitzen wie angegossen (ugs.);passen wie angegossen (ugs.)
-auf ... machen (ugs.);heraushängen lassen (ugs.);hervorkehren;zur Schau stellen;(jemanden) geben
-Innenleben (fig.);Innereien (fig.);die 'inneren Werte' (ugs., scherzhaft);Eingeweide (fig.);(das) Innere (Hauptform)
-Marlin;Speerfisch
-in die Enge treiben;in die Ecke treiben;(jemandem) keine andere Wahl lassen
-einverlangen (schweiz.);anfordern;verlangen
-Kornealreflex;Lidschlussreflex;Orbicularis-oculi-Reflex;Blinkreflex
-ohne abzusetzen;in einem Durchgang;ohne Unterbrechung;auf einen Hieb;in einem Durchlauf;wo wir schon mal dabei sind (...) (ugs., Spruch);in einem Aufwasch;zusammen;in einem Zug;gleich mit... (ugs.);an einem Stück (ugs.);auf einmal;in einem Gang;in einem Arbeitsgang;auf einen Schlag;in einem Rutsch (ugs.);in einem durch;(sieben) auf einen Streich (ugs.);auf einen Rutsch;(etwas ist) ein Aufwasch (ugs.);zwei Fliegen mit einer Klappe schlagen (ugs., Redensart, fig.)
-Dritter Geldrischer Erbfolgekrieg;Klevischer Krieg;Jülicher Fehde;Geldrische Fehde
-Befreiungstheologie;Theologie der Befreiung
-(wohl)verdienter Lohn;Lohn der Arbeit;Früchte der Arbeit
-Konfrontationstherapie;Konfrontationsverfahren
-herumzicken (Gerät, Maschine) (ugs., fig.);nicht mehr richtig funktionieren;verrückt spielen (fig.);rumspacken (ugs.);rumzicken (ugs., fig.);Probleme machen
-ohne festes Ziel (Hauptform);ins Blaue hinein;aufs Geratewohl;immer der Nase nach
-Volltreffer;Schuss ins Schwarze
-rüberrutschen;auf den Beifahrersitz rutschen;auf den Nebensitz rutschen
-weiterrutschen;durchrutschen
-(sich) nicht aufhalten;seinen Weg fortsetzen;nicht stehenbleiben;weitergehen
-Fisimatenten (ugs.);Theater (ugs.);Sperenzchen (ugs.);Sperenzien (ugs.);Ärger (machen);Geschichten (machen);Zicken (ugs.)
-(sich) Arbeit (machen) (ugs.);übertriebener Aufwand;Umstände (machen) (ugs.);zu viel Aufwand
-überhandnehmen;immer mehr werden;(sich) explosionsartig vermehren;überproportional zunehmen;ausufern
-Heilbronner Bund;Heilbronner Convent
-sozialisieren;einordnen;erziehen;integrieren;eingliedern
-alte Filme;Kintopp;Opas Kino
-sind Sie (bitte) so nett (und) (ugs., floskelhaft);sei so nett und (...) (floskelhaft);ich wäre Ihnen (sehr) verbunden (wenn) (floskelhaft);ich wäre Ihnen dankbar, wenn Sie (...) (floskelhaft);tu mir die Liebe (und) (floskelhaft);(...) wenn ich bitten dürfte (geh., ironisierend);bitte (Aufforderung);Du bist ein Schatz! (ugs., floskelhaft);sei ein guter Junge und (...) (ugs., floskelhaft);könntest du (...) (vielleicht);freundlicherweise;wenn's Ihnen nichts ausmacht;sei ein Schatz und (...) (ugs., floskelhaft);könnten Sie (...) (vielleicht);sei ein braves Mädchen und (...) (ugs., floskelhaft);wenn Sie (mir) freundlicherweise (...) (floskelhaft);sei so gut und (...) (floskelhaft);wenn Sie (mir) bitte (...) würden (floskelhaft);wie wär's, wenn (...);seien Sie so gut und (...) (ugs., floskelhaft);wenn Sie so freundlich wären (floskelhaft, variabel)
-(etwas) zu Ende führen;(etwas) durchziehen;(etwas) fertigbekommen;Nägel mit Köpfen machen (fig.);(etwas) zum Abschluss bringen (Hauptform);ganze Arbeit leisten (ironisierend);keine halben Sachen machen;sein Ding durchziehen (ugs.)
-betont;bemüht (geh.);(lässig ...) vorgetragen (geh.);demonstrativ;ausgesprochen;zur Schau getragen;ausgesucht;ostentativ (geh.)
-Kirchgang;Besuch der (heiligen) Messe
-Besuch der (heiligen) Messe;Kirchgang
-verwirrend;nicht zu überschauen;(ineinander) verschlungen;nicht überschaubar;unentwirrbar;labyrinthisch (geh.);(miteinander) verknäuelt;nicht zu durchschauen
-ausdrücklich sagen;(sich) wiederholen;noch einmal sagen;repetieren (geh., lat.);(ausdrücklich) erklären;(besonders) betonen
-Amerikaner;Ammonplätzchen;Sandbrötchen
-Zylinderhut;Angströhre (ugs., veraltet);Zylinder
-letzte Reserve;letztes Aufgebot;eiserne Reserve
-Chapeau Claque;Faltzylinder (selten);Klappzylinder (selten)
-(jemanden) reitet der Teufel;(jemanden) sticht der Hafer;übermütig werden;von allen guten Geistern verlassen sein;(jemandem) geht es zu gut
-Wassernudel;Flexibeam (engl.);Schwimmnudel;Poolnudel
-gleißend hell;sehr hell;blendend;strahlend;grell;stark glänzend;neon...;leuchtend;leuchtkräftig (fachspr.);gleißend;stark reflektierend
-schimmernd;zitternd (Licht);flimmernd;flirrend
-auf Samtpfoten (fig.);ohne Aufsehen zu erregen;auf leisen Sohlen;(möglichst) unauffällig;sang- und klanglos (ugs.);still und leise;(möglichst) geräuschlos
-nicht weitererzählen (ugs.);nicht (groß) herumerzählen;in der Familie bleiben (fig.);unter uns bleiben;diskret behandeln;nicht an die große Glocke hängen (fig.);vertraulich behandeln;vertraulich umgehen mit;nicht ausposaunen
-topsecret (sein) (engl.);höchste Geheimhaltungsstufe;top secret (sein) (engl.);streng geheim (sein)
-geheim (Geheimhaltungsstufe);Verschlusssache
-nur für den Dienstgebrauch;nicht für die (Augen der) Öffentlichkeit bestimmt;nur für den internen Gebrauch
-(sich) häufiger sehen;(jemanden) daten (engl.);(sich) einlassen (mit);(sich) treffen (mit);häufiger treffen (Hauptform)
-(jemandem) hinterherlaufen (fig.);(sich) schlagen um (fig.);(sich) reißen um (jemanden);(jemanden) unbedingt haben wollen;(sich) sehr bemühen um;(jemandem) nachlaufen;(jemandem) hinterherrennen (fig.)
-warmer Bruder (derb, abwertend);schwul;vom anderen Ufer (fig.);gay (ugs., engl.)
-Unfähigkeit, Freude zu empfinden;Anhedonie (fachspr.)
-hinter Gitter wandern (ugs.);eingebuchtet werden (ugs.);verknackt werden (zu);(die) Strafe antreten;aus dem Verkehr gezogen werden (ugs., fig.);einfahren (ugs., Jargon);zu einer Freiheitsstrafe ohne Bewährung verurteilt werden;ins Gefängnis kommen (Hauptform);ins Gefängnis müssen (ugs.)
-Karzer (historisch);Arrestzelle
-Gefängnisjargon;Knastsprache
-straffällig werden;ein (krummes) Ding drehen (ugs.);(eine) Straftat begehen
-Depression;(eine) Depri (ugs.);depressive Störung;depressive Erkrankung;depressive Episode (medizinisch)
-(idealistischer) Kämpfer;Kreuzritter (fig.);Kämpfer für die gute Sache
-Missionar;Bekehrer
-von der Richtigkeit (einer Sache) (absolut) überzeugt;Überzeugungseifer;missionarischer Eifer;Sendungsbewusstsein
-kurz vor der Entbindung;hochschwanger
-(jemandem) bevorstehen;(jemandem) drohen;(jemandem) blühen (ugs.);(jemanden) erwarten;(das) Schicksal hält (...) (für jemanden) bereit;(auf jemanden) warten (fig.);(auf jemanden) zukommen;zu erwarten haben
-(für jemanden) mit erheblichen Nachteilen verbunden sein;(jemanden) teuer zu stehen kommen (auch figurativ);(einen) hohen Preis bezahlen (für) (auch figurativ)
-ganz schön was (an);eine große Menge (an);eine Menge;(ein) großer Haufen (ugs.);viel (vor Nomen);ordentlich was (an) (ugs.);massig (ugs.);richtig was (ugs.);etliches (an);reichlich was (an) (ugs.);jede Menge;ein Haufen (ugs.)
-(sich was) wegholen (ugs., salopp);(sich) zuziehen (Krankheit);(sich) holen (Krankheit) (ugs.);bekommen (Krankheit);krank werden;(sich was) einfangen (ugs., salopp);(sich) einhandeln (ugs.);(sich) den Tod holen (ugs., übertreibend);erkranken (an)
-befallen werden (von);(sich) infizieren;affizieren (fachspr., lat.);(sich) anstecken
-identitätsstiftend;ein Wir-Gefühl erzeugend
-mit Feuer belegen;unter Feuer nehmen;unter Beschuss nehmen;(das) Feuer eröffnen (auf)
-judenfrei;judenrein (Jargon)
-Jehudi (hebräisch);Jud (derb, abwertend, veraltet);Itzig (abwertend, veraltet);Jude;Jidd (jiddisch);Israelit (historisch)
-Israeli;israelischer Staatsangehöriger;israelischer Staatsbürger;Bürger von Israel
-Zionist;jüdischer Nationalist;Anhänger des Zionismus;Verfechter eines jüdischen Nationalstaats
-aufhören wollen;einer Sache müde sein (geh., veraltet);ans Aufhören denken;nicht mehr wollen
-langweilig;verschnarcht;lahmarschig (ugs.);unlebendig;transusig (ugs.);schlafmützig
-verzehren;konsumieren;aufessen;aufzehren;zu sich nehmen
-(sich) kurz hinlegen;(ein) Nickerchen machen;(ein) Auge voll Schlaf nehmen;(sich) eine Mütze voll Schlaf holen;kurz wegdösen
-Sekundenschlaf;Müdigkeitsattacke
-gähnen;gienen (ugs., süddt.)
-(sich) (den) Schlaf aus den Augen reiben;versuchen wach zu werden
-regelmäßig atmend;fest eingeschlafen;tief schlafend;im Tiefschlaf
-kurz vor dem Einschlafen;am Einschlafen;am Hinüberdämmern;fast eingeschlafen;im Halbschlaf
-Schlaf gut!;Angenehme Nachtruhe!;Träum was Schönes.;Träum süß von sauren Gurken. (scherzhaft);Schlaf schön!;Ruhen Sie wohl!
-Bettlektüre;Gute-Nacht-Lektüre
-Sand (in den Augen) (ugs., fig.);Augenbutter (fachspr.);Augensteine;Schlaf in den Augen (ugs.);Knies(t) inne Augen (ugs., rheinisch);Schlafsand (ugs.);Schlaf (ugs.);Traumsand;Augenschleim (fachspr.);Schlafkörnchen;Matzel (ugs., pfälzisch)
-Polizeipräsenz;Polizeiaufgebot
-beglückend;innig;die Seele streichelnd;herzerwärmend;gemütvoll;herzig;Balsam für die Seele
-Sempervivum (fachspr.);Hauswurz
-Sempervivum tectorum (fachspr., botanisch);Gewöhnliche Hauswurz;Alpen-Hauswurz;Echte Hauswurz;Donnerwurz;Dach-Hauswurz;Dachwurz
-(sich) (hindurch)fräsen durch (ugs., fig.);(sich) (hindurch)arbeiten durch;(sich) (hindurch)kämpfen durch
-abfangen;abpassen
-Zulauf haben;populär werden;Anklang finden
-wieder anwesend;wieder unter uns;wieder mit dabei (ugs.);wieder da;wieder im Lande (ugs., fig.)
-indigenes Volk;Naturvolk
-Jäger und Sammler;Wildbeuter;Feldbeuter
-Naturmensch;edler Wilder
-innere Ruhe;innerer Frieden;Ausgeglichenheit;Seelenfrieden
-Entspanntheit;entspannte Gemütsverfassung
-künstlich;aufgesetzt;konstruiert;unnatürlich;forciert (geh.);gemacht
-rund um die Uhr im Einsatz;im Dauereinsatz
-Belastung;Angespanntheit;Dauerbelastung;Angestrengtheit
-(noch) ausstehen;(noch) nicht vorliegen
-noch nicht (Hauptform);bislang nicht;bis jetzt nicht
-Mammutprojekt;gigantisches Projekt;Großprojekt
-(jemanden) stoppen;(jemanden) bremsen;(den) Abbruch (einer Aktion) befehlen;(jemanden) zurückpfeifen
-nicht länger verantwortlich;raus (ugs.);nicht mehr zuständig
-fermentiert;durch Gärung veredelt;vergoren;gegoren
-Gärungsprozess;Fermentation
-Krankheitsherd;Infektionsherd (auch figurativ)
-Brutplatz;Brutstätte;Nistplatz
-Nest (eines großen Greifvogels);Horst
-missratene Brut;Schlangenbrut;Natterngezücht (lit. fig.)
-bis zum Horizont;überall ringsumher;so weit das Auge reicht
-zur Neige gehen;dahinschmelzen (geh., poetisch);zu Ende gehen;bald aufgebraucht sein (ugs.);(langsam) alle werden (ugs.);knapp werden;aufgebraucht werden;dahinschwinden (geh.);(jemandem) ausgehen (ugs., regional);weniger werden
-(zu viel) Spiel haben;kippeln;(sich) gelockert (haben);kippelig sein;wacklig sein;wackeln wie ein Lämmerschwanz;lose sein;wackeln;zu locker sitzen;locker sein;instabil sein
-Gefühlssturm;Aufruhr der Gefühle;Durcheinander der Gefühle
-Waffenhersteller;Waffenproduzent;Waffenschmiede (fig.)
-Waffenmeister (fig.);Waffenlieferant
-alles verloren haben;(buchstäblich) vor dem Nichts stehen
-schlucken (ugs.);(seinen Besitztümern) hinzufügen;(sich) aneignen;(sich) unter den Nagel reißen (ugs.);übernehmen;(seinem Unternehmen) einverleiben
-Herrschaftsbereich;Imperium;Herrschaftsgebiet;Reich
-entsetzt (Adv.);erschrocken (Adv.);voller Schrecken;zu seinem (großen) Schrecken;zu seinem (großen) Entsetzen
-durcheinanderbringen;für Chaos sorgen;aufwirbeln;für Unruhe sorgen;chaotisieren;aufmischen (ugs.)
-Otorhinolaryngologe (fachspr.);Ohrenarzt;Hals-Nasen-Ohren-Arzt
-(sich) nicht nur Freunde machen;(sich) unbeliebt machen;(jemandem) Sympathien kosten
-kulturelles Erbe;Kulturgut (ugs.);Patrimonium
-Chauvinismus;exklusiver Nationalismus;Hurra-Patriotismus;(übersteigerter) Nationalismus;Jingoismus
-(männlicher) Sexismus;Machismus;Androzentrismus (geh.);Männlichkeitskult;Chauvinismus;Männlichkeitswahn;Machismo (span.)
-testosteronschwanger;(übertrieben) männlich
-schnell eingeschnappt;leicht kränkbar;übelnehmerisch;sensibel
-gemütvoll;gefühlvoll;warmherzig;Wärme ausstrahlend
-in hellen Flammen stehen;(die) Flammen lodern (...) hoch;lichterloh brennen;brennen wie Zunder
-ausgebombt sein (histor., 2. Weltkrieg);(die) Wohnung wurde durch einen Bombenangriff zerstört
-Ostasiate;Bewohner Ostasiens;Reisfresser (stark abwertend);Schlitzauge (stark abwertend)
-(sich) hinreißen lassen (zu);(sich) vergaloppieren (ugs., fig.);(sich) verrennen;(sich) versteigen (zu);unangemessen reagieren
-keinen Fuß setzen (in);(sich) weigern zu betreten
-in einem seiner schwachen Momente;in einem unbedachten Moment
-(jemandem) (das) Herz brechen;(jemanden) unglücklich machen
-angeklagt werden;unter Anklage stehen
-zivilrechtlich belangt werden;beklagt werden
-(jemandem) in die Hand versprechen;(die) Hand darauf geben;(sein) Ehrenwort (darauf) geben;versprechen (Hauptform);(sein) Wort (darauf) geben;verheißen;fest zusagen;fest versprechen;tausend Eide schwören (fig.);hoch und heilig versprechen;geloben (fig.);ein Versprechen (ab)geben
-geloben;feierlich versprechen
-unter Eid (stehend);vereidigt;durch Eid gebunden;durch Eid verpflichtet (auf/zu)
-(jemandem etwas) versichern;(jemandem etwas) zusagen;(jemandem etwas) zusichern;(jemandem etwas) versprechen (Hauptform)
-schlag ein!;(die) Hand drauf!
-starten;(sich) in die Lüfte erheben;abheben
-Perücke;Zweithaar;Zweitfrisur;Toupet;Fifi (ugs.);falsche Haare (ugs.);Haarteil;Haarersatz
-(jemandem) leidtun;bedauern;(jemandem) in der Seele weh tun (ugs., Redensart);(jemanden) dauern (geh., literarisch, veraltend)
-Frömmigkeit;Gottesfurcht;Gläubigkeit
-es geht um Folgendes:;die Sache ist die:;es verhält sich folgendermaßen:;es ist so:;(der) Punkt ist:;Folgendes:
-Mist bauen;(die) falsche Entscheidung treffen;(einen) Fehler machen
-floppen;ein Flop sein;(sich) als Flop herausstellen;einbrechen;durchfallen (bei);abstürzen
-was ist los mit dir? (ugs.);was ist los?;was ist mit dir? (ugs.);was willst du? (ugs.);was hast du? (ugs.)
-was geht ab? (ugs., jugendsprachlich);alles frisch? (ugs., jugendsprachlich);was läuft? (ugs.);(und,) wie läuft's hier so? (ugs.);was geht (, Alter)? (ugs., jugendsprachlich);alles frisch im Schritt? (ugs., anzüglich, jugendsprachlich)
-rede mit uns!;sprich!;ich rede mit dir!;rede mit mir!;mach (endlich) den Mund auf!;(jetzt aber) heraus mit der Sprache!;nun sag schon (was los ist)!
-Rücksprung;Rückblende (Film, Roman...);(zeitlicher) Sprung zurück
-ableisten (Überstunden o.ä.);leisten;schieben (ugs.);machen;fahren
-maligne Lymphome;Lymphdrüsenkrebs
-hör auf mit dem Blödsinn (ugs.);lass den Quatsch (ugs.);mach keinen Unsinn (ugs.);spinn dich aus (ugs., salopp)
-Rohrstück (an einem Werkzeug);Tülle;(rohrförmiger) Aufnahmestutzen
-Sprach(merkmals)grenze;Isoglosse (fachspr.);Dialekt(merkmals)grenze
-nicht mehr verheiratet;geschieden;getrennt;auseinander;wieder frei;wieder zu haben
-(ihr) Exmann;ehemals ihr Freund;(ihr) geschiedener Mann;früherer Ehemann;ehemals ihr Mann;(ihr) Ex;früherer Freund;vormals ihr Ehemann;(ihr) Exfreund;(ihr) Verflossener (ugs.);Ex-Ehemann;(ihr) Ehemaliger;(der) mit dem sie mal zusammen war
-auf der Wache (festgehalten);auf der Polizeiwache;in Polizeigewahrsam;in polizeilichem Gewahrsam
-zusammenkoppeln;verkoppeln;aneinanderkoppeln;zusammenfügen;verbinden;koppeln
-Heiratsvermittlung;Eheanbahnung;Beziehungsanbahnung
-voller Ungeduld erwarten;nicht abwarten können;die Tage zählen;die Minuten zählen;kaum erwarten können
-pendeln;wedeln;hin- und herwedeln;hin- und herschwingen;schwingen;hin- und herpendeln;baumeln
-am Galgen hängen;baumeln
-kurz vor dem Zieleinlauf;auf dem letzten Stück;auf den letzten Metern (zum Ziel);auf der Zielgeraden
-letztes noch fehlendes Element;Vollendung;Schlussstein (fig.)
-(sich) den Spaß einiges kosten lassen (ugs.);keine Kosten und Mühen scheuen;(sich etwas) einiges kosten lassen;große (finanzielle) Anstrengungen unternehmen
-Zögling (veraltet);Schulkind;geht (noch) zur Schule (ugs.);Schuljunge (männl.);Schulmädchen (weibl.);Schüler (Hauptform);Schulbub (männl., süddt.)
-unreif;kleines Kind (ugs.);dummer Junge;unerwachsen;wie ein Schuljunge
-unreifes Bürschchen (ugs.);Schuljunge (fig.)
-Zeit ins Bett zu gehen;(jetzt ist) Nachtruhe;Zeit schlafen zu gehen;(jetzt ist) Schlafenszeit;(es ist) Zapfenstreich (fig.)
-isolieren;abspalten;segregieren (geh.);sondern (geh.);trennen;absondern;separieren
-Entwicklungsroman;Bildungsroman;Coming-of-Age-Roman
-Coming-of-Age-Erzählung;Coming-of-Age-Story
-(sich) kurz halten;(sich) kurzfassen;(es) kurz machen;keine Romane erzählen (ugs.);keine Oper(n) quatschen (ugs.);nicht viele Worte verlieren (über);nicht viel sagen (zu)
-Synopsis (fachspr.);Paralleldarstellung (von Texten);Synoptik (fachspr.);Zusammenschau (geh.);Synopse (fachspr.);Textvergleich
-Aufstiegsbarriere;gläserne Decke;Glass-Ceiling-Effekt(e)
-(die) Leiblichkeit;(die) Körperlichkeit;(das) Körperliche;(die) Physis;(die) Körperhaftigkeit
-Gestalt;Statur;Wuchs;(körperliche) Konstitution;Körperbau;Körpergröße;Habitus (fachspr., botanisch, medizinisch)
-Gradation (zool.) (fachspr.);explosionsartige Vermehrung;Massenvermehrung
-sklavische Ergebenheit;Submissivität;Unterwürfigkeit
-Sippenhaft (fig.);Mithaftung;Mitverantwortung
-Realerbteilungsrecht;Realteilung (historisch)
-Krankenpflegehelfer (veraltet);Gesundheits- und Krankenpflegehelfer
-Landesklinikum;Landeskrankenhaus
-Bildjournalist (veraltend);Bildberichterstatter;Fotoreporter;Pressefotograf;Bildreporter
-Leitartikel;Editorial
-Stellungnahme;kommentierender Artikel;Kommentar
-Beitrag;Zeitungsartikel;Artikel (journalistisch);(in einer Zeitung publizierter) Text
-Schauspielerei;Verstellung;Show (fig.);Theater (fig.);Angeberei
-Übertreibung;Dramatisierung;Übersteigerung
-Effekthascherei;Mätzchen;durchsichtiges Manöver;billige Tour
-Thematischer Auffassungstest;TAT;Thematischer Apperzeptionstest
-Persönlichkeits-Entfaltungsverfahren;Projektiver Test;Deutungstest
-Tintenkleckstest (ugs.);Rorschach-Formdeuteversuch;Rorschach-Test;Rorschachtest
-Psychologische Diagnostik;Psychodiagnostik
-Metrik;Abstandsfunktion
-kostenneutral;ohne Mehrkosten;ohne zusätzliche Kosten;ohne Zusatzkosten
-verschaukeln;(einfach) hängenlassen (ugs.);verladen (ugs.);versetzen
-mit vollem Körpereinsatz (verhüllend);(auch) in Nacktszenen;mit viel nackter Haut;(es gibt) ordentlich was zu sehen (ugs.);nicht prüde
-Informationsministerium;Kommunikationsministerium
-gewagt;tief blicken lassen (fig., scherzhaft);freizügig;frivol;offenherzig (fig.);Einblicke gewährend
-hochgeschlossen;ohne Ausschnitt;keine Einblicke gewähren(d) (fig.)
-Couch potato (engl.);Couchkartoffel
-Kalmäuser (geh., veraltet);Stubenhocker;Nesthocker (fig.)
-Spareribs (engl.);Schälrippchen
-Nesthocker;(wohnt im) Hotel Mama (ugs.)
-(den) Arsch nicht hochkriegen (derb, fig.);(sich) nicht aufraffen können (ugs.);in Lethargie verharren;nicht aktiv werden;nicht in die Puschen kommen (ugs., fig.);(sich) zu nichts aufraffen können;in Untätigkeit verharren;nicht aus dem Quark kommen (ugs., fig.);nicht in die Gänge kommen (ugs.)
-(ein) schlechter Schwimmer sein;schwimmen wie eine bleierne Ente;nicht schwimmen können
-im Schlabberlook;nicht zurechtgemacht;in Räuberzivil (veraltend)
-abgespreizter kleiner Finger;Gesellschaftsfinger
-(sich) wellen;wallen;wogen
-(sich) heftig heben und senken;wogen
-Nachteule (fig.);Nachtschwärmer (fig.)
-(sich) krümmen;(sich) biegen;(sich) beugen
-und soll ich dir was sagen (ugs.);und siehe da (ugs.);ob du es (nun) glaubst oder nicht (ugs.);und siehe (geh., biblisch, ironisch)
-Schnappatmung bekommen (auch figurativ);keine Luft mehr bekommen;(jemandem) stockt der Atem
-Sorgen;Sorgen und Nöte (floskelhaft);Nöte;Schwierigkeiten;Probleme
-(dreimal) (tief) schlucken (müssen);(erst mal) tief Luft holen (müssen);versuchen, ruhig Blut zu bewahren
-auf feiner Herr machend (ugs.);etepetete (ugs.);fürnehm (geh., altertümelnd);auf vornehme Dame machend (ugs.);übertrieben vornehm (tuend);mit abgespreiztem kleinen Finger
-Seto-Binnenmeer;Seto-Inlandsee
-Osmosekraftwerk;Salzgradientenkraftwerk
-Amazonenstrom;Amazonas
-effektheischend;gefallsüchtig;auf Beifall schielend
-Insektenwand;Insektenkasten;Insektenhaus;Insektenhotel;Insektenasyl
-wie vor (großem) Publikum;wie auf der Theaterbühne;theatralisch;mit übertriebenem Pathos;mit (großem) Tremolo in der Stimme
-Stiftkrone;Stiftzahn
-gut vorankommen;gute Fahrt machen (Schiff);schnell fahren (Boot, Schiff);schnell vorankommen
-vagabundierender Planet;Planemo
-Torlinientechnik;Torlinientechnologie
-Nebenwohnungsteuer;Zweitwohnungssteuer;Zweitwohnsitzsteuer;Zweitwohnungsabgabe;Nebenwohnsitzsteuer;Zweitwohnungsteuer
-Zweitwohnsitz;Nebenwohnsitz (österr.);Nebenwohnung;Zweitwohnung
-frei nach Schnauze (ugs.);improvisiert;wie es gerade kommt
-Wer im Glashaus sitzt, (der) sollte nicht mit Steinen werfen. (Sprichwort);du kannst grad ruhig sein! (regional);das musst ausgerechnet du sagen! (ugs.);das musst du gerade sagen! (ugs.);du musst es ja wissen! (ugs.);das sagt der Richtige! (ugs.);du hast es (gerade) nötig! (ugs.);guck dich doch mal (selber) an! (ugs.);das sagt die Richtige! (ugs.);das sagst ausgerechnet du!
-von Mal zu Mal (mehr);immer (mehr);jedes Mal (mehr);mit jedem Mal;zusehends
-Wertungsprüfung;Sonderprüfung
-Magnesische Inseln;Nördliche Sporaden
-preußisch-österreichischer Dualismus;deutscher Dualismus
-anorektale Inkontinenz;Darminkontinenz;Stuhlinkontinenz;anale Inkontinenz
-Schließapparat;Kontinenzorgan
-Perianalabszess;Periproktitis;Paraproktitis
-Epikondyalgie;Epikodylose;Epikondylopathie;Epicondylitis
-Epicondylitis humeri lateralis (fachspr.);Tennisellenbogen;Tennisarm;Epicondylitis radialis humeri (fachspr.)
-Strecker;Extensor
-Golferellenbogen;Golferarm;Epicondylitis humeri medialis (fachspr.);Epicondylitis ulnaris humeri (fachspr.)
-Flexor;Beuger
-Inklination;Ventralflexion
-Dorsalextension;Dorsalflexion
-Auftragsvorbereitung;Arbeitsvorbereitung
-E-Schicht;Kennelly-Heaviside-Schicht
-Netzausbauplan;Netzentwicklungsplan
-(jemanden) an der Backe haben (ugs., fig.);(für jemanden) verantwortlich sein;(jemanden) nicht loswerden;(jemanden) an den Hacken haben (ugs., fig.);(sich) um jemanden kümmern müssen
-(jemanden) anschleppen (ugs., abwertend, fig.);(jemanden) angeschleppt bringen (ugs., abwertend, fig.);(jemanden) dabeihaben;begleitet werden (von);(jemanden) im Schlepptau haben (ugs., fig.);kommen (mit) (ugs.)
-an jemandes Rockzipfel hängen (ugs., fig.);(jemandem) am Rockzipfel hängen (ugs., fig.);(jemandem) am Schürzenband hängen (ugs., fig.);(jemandem) an der Schürze hängen (ugs., fig.)
-(jemanden) nicht loswerden;(an jemandem) hängen wie eine Klette;(sich) nicht abschütteln lassen;wie eine Klette sein
-mit Leib und Seele;mit ganzem Herzen;mit Freude;freudig
-(unansehnliches, großes) Bauwerk;Koloss;Klotz (ugs.);(großes) Gebäude
-Molekulargastronomie;Molekularküche
-Agrikulturchemie;Agrarchemie;Agrochemie
-Schnappschalter;Sprungschalter
-Packungsbeilage;Beipackzettel;Waschzettel (ugs.);Produktinformation
-Netzwerklast;(umlaufendes) Datenvolumen;Datenaufkommen;Traffic
-Datenfluss;Datenverkehr
-einfahren (Jägersprache);im Bau verschwinden (ugs.)
-einziehen;einfahren (teleskopartig ausziehbares Teil)
-ausziehen;hochfahren;ausfahren (Leiter, Antenne, Fahrwerk)
-einfahren;hineinfahren
-(ins Bergwerk) einfahren;unter Tage gehen;(eine) Seilfahrt machen
-(zur) Routine werden;Alltag werden;(sich) einspielen;(sich) einfahren (selten);normal werden
-(am Anfang) schonend behandeln;einfahren (Neuwagen);nicht voll ausfahren
-fluppen (ugs., regional);rundlaufen;störungsfrei arbeiten;problemlos funktionieren;laufen wie geschmiert (ugs.)
-(sich) gewöhnen an;(sich) einfahren
-Federkleid;Gefieder
-Färbung;Farbe;Farbschlag (Züchtung)
-schwarz-weiß;farblos;unfarbig;ohne Farbe;grau in grau;in Grautönen;unbunt
-Passivität;Inaktivität;abwartende Haltung
-verstauben;ungenutzt herumliegen;Staub ansetzen (auch figurativ);nicht benutzt werden
-mit größter Zurückhaltung;in gedämpftem Ton;sotto voce (geh., fig., ital.);sehr zurückhaltend
-füßeln;(sich) (unter dem Tisch) mit den Füßen berühren
-Nebenvereinbarung;Nebenabsprache;zusätzliche Verabredung
-Vertikale Synchronisation;Vertikale Synchronisierung
-in (einzelnen) Schüben;stoßweise;schubweise
-alle Zeit der Welt (haben / es ist);dicke Zeit (haben) (ugs.);Zeit ohne Ende (ugs.);Zeit satt (ugs.);Zeit genug
-pianissimo (mus.);sehr leise;fast unhörbar;kaum zu hören;kaum vernehmbar;kaum vernehmlich;kaum hörbar;extrem leise;im Flüsterton;flüsterleise
-Pappnase;Clownsnase
-verarzten;ärztlich versorgen
-mehr als du denkst;mehr als du glaubst;(es gibt) mehr (Dinge zwischen Himmel und Erde) als deine Schulweisheit sich träumen lässt
-Gesellschaft suchen;nicht zu Hause versauern;unter Leute gehen;unter Menschen gehen
-(jemandes) Fehler ausnutzen;(jemandem) einen Strick aus etwas drehen (fig.)
-nicht abschalten;dranbleiben (Radio)
-am Rande (einer Sache / von etwas);schier;beinahe;kurz davor (sein);fast
-Nonkonformismus;Antikonformismus;Nonkonformität
-Jesiden;Yeziden;Eziden
-nicht (mehr) beherrschbar;außer Kontrolle (sein);nicht (mehr) zu steuern;nicht (mehr) in jemandes Macht liegen;nicht (mehr) steuerbar
-(noch) aktuell sein (fig.);(et)was läuft (zwischen) (ugs.);(ein) Verhältnis haben;(et)was haben mit (jemandem) (ugs., Hauptform);(et)was miteinander haben (ugs.)
-(sich etwas) eine Kleinigkeit kosten lassen (ugs.);(sich) den Spaß etwas kosten lassen (ugs.);(Geld) in die Hand nehmen;(sich etwas) genehmigen;(sich) in Unkosten stürzen (ugs., scherzhaft, übertreibend);(Geld) locker machen;(tief) in die Tasche greifen (fig.);(etwas) springen lassen (ugs.);(sich etwas) gönnen (ironisierend);(sich) (eine Sache) etwas kosten lassen;(sich etwas) leisten;(eine) Kleinigkeit springen lassen (positiv iron.) (ugs.)
-Nebenprodukt;hervorgegangen aus;Ableger (Unterhaltungsindustrie);Spin-off (fachspr., Jargon);Anschlussfilm (fachspr.);Abfallprodukt (ugs., abwertend);Anschlussprodukt (fachspr.)
-eingefahrene Bahnen (fig.);Trampelpfade (des Althergebrachten, bereits Bekannten o.ä.) (fig.);eingefahrene Gleise (fig.)
-(etwas) Neues;neue Wege
-populär;für den Mehrheitsgeschmack;massentauglich;für die breite Masse;Mainstream;massenkompatibel;(für den) Massengeschmack
-Nachahmungstrieb;Herdentrieb (fig.);Herdeninstinkt (fig.);Mitläufertum
-echte Probleme haben (ugs., variabel);in der Scheiße sitzen (derb);(knie)tief in der Scheiße stecken (derb, fig.);jede Menge Ärger haben (ugs.);bis zum Hals in der Scheiße stecken (derb, fig.);bis zum Hals in Schwierigkeiten stecken (sprichwörtlich);in großen Schwierigkeiten sein;ganz schön in der Klemme sitzen (ugs.)
-Massenkarambolage;Serie von Kollisionen;Unfallserie mit vielen Beteiligten
-angenehm (vor Adj.);schön (ugs.);wohltuend
-(und da) kommst du ins Spiel (ugs.);(und jetzt) kommt dein Part (ugs.)
-ich meine das ernst;verlass dich drauf;(das) kann ich dir flüstern (ugs.);(das) kannst du mir glauben (ugs.);das glaub (aber) mal! (ugs., regional);(das) versprech(e) ich dir!;(das) versprech(e) ich Ihnen!;eins kann ich dir sagen: (...) (ugs., Spruch, variabel);da kannst du aber drauf an! (ugs., regional, ruhrdt.);darauf kannst du dich verlassen;das können Sie mir (aber) glauben! (ugs.)
-(sich) kümmern (ugs.);erledigen;in die Hand nehmen (fig.);regeln;klären
-grabschen (nach);fischen (nach);haschen (nach);zu fangen versuchen;zu erhaschen versuchen;schnappen (nach);zu erwischen versuchen;greifen (nach) (Hauptform);angeln (nach)
-Idealtyp;Idealtypus
-Wissenschaftslogik;Wissenschaftslehre;Wissenschaftstheorie;theoretische Wissenschaftsphilosophie;Wissenschaftsphilosophie
-(jemandem den Partner) wegnehmen;(jemandem den Partner) wegschnappen;(jemandem den Partner) ausspannen
-(mit jemandem) durchbrennen;(jemandem) davonlaufen;(jemandem) weglaufen;nicht bleiben
-(sich) nicht mehr unter Kontrolle haben (Hauptform);total ausflippen (ugs.);(bei jemandem) brennt eine Sicherung durch (ugs., fig.);(total) durchdrehen (ugs.);(bei jemandem) brennen die Sicherungen durch (ugs., fig.);außer Rand und Band geraten (Gruppe);nicht mehr wissen, was man tut;außer Kontrolle geraten
-aus jemandes Feder;aus der Feder von;verfasst von;(der) Verfasser (sein);(der) Autor (sein)
-nichts zu lachen haben;schlecht behandelt werden
-Registrierdatenbank;Registrierungsdatenbank
-nichts Entsprechendes;nichts Vergleichbares;nichts in diesem Sinne (ugs.);nichts dergleichen;nichts derlei (geh., veraltet);nichts von all dem;nichts davon
-Schlachtplan (fig.);Aktionsplan;geplanter Ablauf
-Zeitansatz;benötigte Zeit;erforderliche Zeit;(geplanter) Zeitbedarf
-seine Pappenheimer kennen;seine Schweine am Gang erkennen;(jemanden) zur Genüge kennen;(bei jemandem) wissen, woran man ist
-nicht zur Ruhe kommen;es herrscht (irgendwo weiterhin) Unruhe
-um nicht zu sagen;wenn nicht gar (geh.);und nicht nur das: ,,, (ugs.);ja sogar;was sage ich (emphatisch);mehr noch;wenn nicht (sogar);man könnte sogar sagen
-niemand sagt einen Ton;es herrscht Ruhe;still ruht der See (Zitat);alles ist ruhig;niemand sagt etwas;(es herrscht) Schweigen im Walde;der Rest ist Schweigen (Zitat)
-(ein) Engel fliegt durchs Zimmer;plötzlich tritt Stille ein;auf einmal wird es still (im Raum)
-sperrangelweit;gähnend weit;ganz weit (auf / offen / geöffnet / klaffend / auseinanderklaffen);sehr weit
-pflegen;betreuen
-offen;aufgeklappt;auf (ugs.);aufgesperrt;offen stehend;geöffnet
-Kletterer;Klettermaxe
-Bergziege (Radsport);Kletterer;Bergfahrer (Radsport)
-(jemanden) gewähren lassen (Hauptform);(sich) erlauben dürfen;keinen Einhalt gebieten;(sich) leisten können;(sich) herausnehmen dürfen;(tun) dürfen (ugs.);Narrenfreiheit haben;(jemandem) keine Schranken setzen;Narrenfreiheit genießen
-Drückeberger;Leistungsverweigerer (fachspr., Jargon);Blaumacher;Verpisser (derb);Laumalocher (ugs., ruhrdt.)
-(illegaler) Abtreiber;(illegale) Abtreiberin;Engelmacher;Engelmacherin
-hoffentlich behältst du recht;hoffentlich hast du recht;(wir wollen) das Beste hoffen (variabel);inschallah;dein Wort in Gottes Ohr (ugs.);wenn du dich da mal nicht irrst (ugs.);toi toi toi (ugs.);(na dann) dreimal (schnell) auf Holz geklopft! (ugs.)
-verlassen;vereinsamt;zurückgelassen;verwaist
-abgekapselt;abgeschottet;abgeschieden;isoliert;abgesondert
-entvölkert;evakuiert;geräumt
-(das) Schaffen;(jemandes) Arbeiten (ugs.);Werk;Gesamtwerk;Œuvre (franz.);(alle) Werke
-schriller Typ;Paradiesvogel (fig.);um jeden Preis auffallen wollen
-Weingut;Rebgut (schweiz.)
-Winzergenossenschaft;Weingärtnergenossenschaft (württemberg.);Kellereigenossenschaft (südtirol.)
-zum Verkauf stehen;angeboten werden;zu haben sein (ugs.);zu verkaufen sein
-vordringen bis;erreichen;(hin)kommen bis;gelangen bis (zu)
-(die) Grüne Insel;Irland (Insel)
-nicht mehr im Gespräch;vom Tisch (sein) (fig.);hat sich erledigt;aufgegeben;nicht weiterverfolgt werden;das Thema ist abgeschlossen;nicht mehr aktuell;abgehakt (ugs.);gestorben (fig.)
-wieder wachrufen;zu neuem Leben erwecken;wieder zur Sprache bringen;wieder zum Leben erwecken (fig.);(einer Sache) neues Leben einhauchen (geh., fig.);wieder ins Gespräch bringen;wieder aufwärmen (fig.);wieder auf die Tagesordnung setzen;aus der Mottenkiste holen (ugs., fig.)
-nach vorne bringen;anschieben;forcieren;weitertreiben;anheizen;(mit Nachdruck) betreiben;ankurbeln;(eine Sache) vorantreiben;befeuern;befördern;pushen (Jargon);Wasser auf die Mühlen (von jemandem / einer Position sein) (fig.)
-auf dem Sprung;sprungbereit;in Lauerstellung
-nicht einen Cent;kein Pfifferling (fig.);kein roter Heller (veraltet);keine müde Mark;kein müder Euro
-aus Schaden klug werden (Redensart);(Fehler) teuer bezahlen (müssen);Lehrgeld bezahlen (müssen) (fig.);aus Fehlern lernen;dazulernen (fig.);leidvoll erfahren (haben) (floskelhaft)
-Wink mit dem Zaunpfahl (fig.);(deutlicher) Hinweis;Fingerzeig
-Ruhe vor dem Sturm;trügerische Ruhe
-lauern;nichts Gutes erwarten lassen;(da) kommt (noch) was auf uns zu (ugs.);(die) Einschläge kommen näher (ugs., Spruch, fig.);(jemandem) blühen;dräuen (lit., poet.) (geh.);drohen;zu befürchten sein;(sich) zusammenbrauen;(bedrohlich) nahen;nichts Gutes verheißen;zu befürchten stehen (geh.)
-Antreiber;Treiber (fig.);Einpeitscher;Stimmungsmacher
-Entgegenkommen;Vorschlag zur Güte (ugs., Redensart);Kompromissvorschlag;konstruktiver Vorschlag;Vorschlag zur gütlichen Einigung
-Hysterie (psychol.) (veraltet);Konversionsstörung
-Feenhaar;dünnes Haar;feines Haar
-versinken in;zerfließen vor;vergehen vor;zergehen in;zergehen vor;(sich) baden in (fig.)
-einer Sache nicht (mehr) Herr werden;ertrinken in (fig.);nicht (mehr) ankommen gegen;zugeschüttet werden (mit) (fig.);zugeschissen werden (mit) (derb, fig.);waschkörbeweise (eingehen) (variabel);(sich) nicht mehr zu retten wissen (vor lauter);es gibt (viel) zu viel(e)
-(der) nasse Tod;Tod durch Ertrinken;(das) Ertrinken
-in der Versenkung verschwinden lassen;dafür sorgen, dass nicht mehr darüber gesprochen wird;klammheimlich vom Markt nehmen;heimlich, still und leise aus dem Verkehr ziehen;insgeheim wieder einkassieren
-(die) schäbigen Reste (ugs.);(der) Rest vom Schützenfest (fig.);(alles) was noch übrig ist;(alles / das letze bisschen) was noch da ist (an) (ugs.);(der) schäbige Rest (ugs.);(der) traurige Rest;(die) traurigen Reste;(der) kümmerliche Rest
-(jemanden etwas) angehen;(mit jemandem) zu tun haben;(auf jemanden) gemünzt sein;für jemanden bestimmt sein;für jemanden gedacht sein;(um jemanden) gehen (es);(sich) auf jemanden beziehen;(jemandem) gelten;(jemanden) betreffen
-in welcher Angelegenheit (wollen Sie mich sprechen)?;was ist der Anlass (ihres Besuches)?;worum geht es;um was geht es?
-Kanonisse;Chorfrau;Stiftsdame;Kanonissin
-den merk ich mir (ugs.);der war gut (ugs., ironisch);guter Witz (ugs.)
-(alle) nach dem gleichen Muster;versatzstückartig;schablonenhaft;wie ausgestanzt;08/15
-abgeschrieben;reinkopiert;im Copy-and-paste-Verfahren;zusammenkopiert;rüberkopiert;hineinkopiert;zusammengestückelt
-in sich geschlossen;ein Ganzes;vollkommen;(da) passt alles zusammen (ugs.);einheitlich;(wie) aus einem Guss
-Biertulpe;Tulpe
-Augenglas;Bierkugel
-retten was zu retten ist;Feuerwehr spielen (ugs., fig.);Notfallmaßnahmen ergreifen
-Glasstiefel;Bierstiefel;Stiefel;Mensurstiefel
-Pint-Glas;Pinte;Pint
-Kölschstange;Kölschglas;Stange;Kölner Stange
-Senfglas (ironisch);Altbierglas
-(bekannte) Erklärungsmuster;Denkmuster;Denkschablonen;geistige Trampelpfade (abwertend)
-sommergrün (fachspr.);laubabwerfend (Baum / Strauch) (fachspr.)
-Vinca (fachspr.);Immergrün
-halbimmergrün (fachspr.);wintergrün (fachspr.)
-Melioration;Meliorisation
-universelle Einhüllende;universelle einhüllende Algebra
-Liesche Gruppe;Lie-Gruppe
-Gleis;Geleise (schweiz., österr.)
-Rechtsetzung;Gesetzgebungsverfahren
-Wolga-Baltik-Kanal;Wolga-Ostsee-Kanal
-Mietregiment;Subsidienregiment
-Exokernel;vertikal strukturiertes Betriebssystem
-Microkernel;Mikrokern
-(der) Westen;westliche Hochkultur;westliche Welt
-Russische Zivilisation;Russische Idee
-Palmweide (ugs., süddt.);Palmkatzlweide (ugs., bayr.);Kätzchen-Weide;Palm-Weide (ugs., süddt.);Kätzchenweide (ugs.);Salix caprea (fachspr., botanisch);Sal-Weide;Palmkätzchen(-Strauch/-Baum) (ugs., süddt.);Salweide
-Art (biologisch);Species (fachspr.)
-Gattung (biologisch);Genus (fachspr., biologisch)
-Familia (fachspr.);Familie (biologisch)
-Ordnung (biologisch);Ordo (fachspr.)
-Divisio (nur i.d. Botanik) (fachspr.);Phylum (fachspr.);Stamm (biologisch)
-Regnum (fachspr.);Reich (biologisch)
-wir schaffen das (schon);du schaffst das schon;das wird sich alles (wieder) einrenken;du machst das schon (ugs.);alles wird gut;Ich bin sicher, das klappt! (ugs.);wird schon schiefgehen! (ugs.);das wird schon (wieder);das kommt alles wieder in Ordnung;(das) wird schon werden (ugs.);(das) wird schon gutgehen;das klappt (ganz) bestimmt! (ugs.)
-ganz bestimmt (ugs.);glaub(e) mir;pass nur auf
-das hat gesessen!;gut gegeben!;erwischt!;der hat gesessen!;touché!
-...verträglich;...gerecht;...tauglich;...kompatibel;...geeignet
-verkracht;(mit jemandem) über Kreuz (liegen);entzweit;zerstritten;uneins;verschiedener Meinung
-zerrüttet;kaputt
-Stimmengewirr;alles ruft durcheinander
-Koseform (eines Namens);Kosename;Kosewort;Hypokoristikum (fachspr., Sprachwissenschaft)
-Koseform;Verniedlichung
-Spitzname (Hauptform);Spottname;Neckname;Kognomen (fachspr., lat.);Beiname;Übername (fachspr., Sprachwissenschaft);Cognomen (fachspr., lat.)
-Frauenstift;Kanonissenstift;Damenstift
-eskalieren lassen;(etwas) verschlimmern;(etwas) schlimmer machen;(etwas) verschärfen;(etwas) verschlechtern;(etwas) verschlimmbessern (ironisch);(etwas) zuspitzen
-viel kaputtmachen (fig.);viel Porzellan zerschlagen (fig.)
-auf die Spitze getrieben werden;an Schärfe gewinnen;ausarten (in);eskalieren;aggressiver werden;(sich) verschärfen;schärfer werden;(sich) zuspitzen
-sein Fett abbekommen (ugs., variabel);sein Fett wegkriegen (ugs.);(jemandem) sein Fett geben (ugs.);(das) kriegen, was man verdient (ugs.);sein Fett wegbekommen (ugs.);bekommen, was man verdient;(das) Passende zurückbekommen (fig.);zur Rechenschaft gezogen werden;(die) Quittung bekommen (für) (fig.)
-(im entscheidenden Moment) der richtige Mann am richtigen Ort;der, um den sich (jetzt) alles dreht;(der) Mann der Stunde
-Geschmackssinn;Geschmack;Gaumen
-groß herauskommen;(großen) Erfolg haben;berühmt werden;(sehr) erfolgreich sein;bekannt werden
-(komischer) Vogel (ugs., abwertend, fig.);Komiker (ugs., abwertend, fig.);Clown (ugs., abwertend, fig.)
-verbunden sein (mit);sprechen mit (Telefon)
-Oldie (ugs., salopp, scherzhaft);Veteran;alter Fahrensmann (fig.);Oldtimer (ugs., engl., salopp);Routinier;alter Haudegen (ugs.)
-Nische;Spezialgebiet
-funkelnd;blinkend;glitzernd
-schwach leuchtend;glimmernd;glimmend;schwach glühend;schimmernd
-blank;spiegelnd;reflektierend;speckig (oft abwertend);glänzend
-(die) Stubbe (Baumstumpf);Stumpen;Stumpf;(der) Stubben (Baumstumpf)
-Entlassungsbrief;Epikrise;Arztbrief;Befundbericht;Patientenbrief
-(he)rumlaufen wie ein Landstreicher (ugs., übertreibend);schlecht angezogen sein;(sich) gemustert haben (ugs.);unvorteilhaft gekleidet (sein);(he)rumlaufen wie eine Vogelscheuche (ugs., übertreibend)
-in feinem Zwirn;in edlem Stöffchen;elegant angezogen;vornehm gekleidet
-aber was für einer! (ugs.);aber wie! (ugs.);aber was für eine! (ugs.);aber frag (mich) nicht nach Sonnenschein! (ugs., sprichwörtlich);aber was für einen! (ugs.)
-unerklärlicherweise;unverhofft;ungewollt;ohne eigenes Zutun;und wusste nicht, wie (mir geschah);warum auch immer;keine Erklärung haben (für);wie die Jungfrau zum Kind(e) (ugs.)
-es ruckelt;nicht (alles) reibungslos;nicht (alles) glatt;rumpelig;holprig (Start)
-Bedienungstheorie;Warteschlangentheorie
-Kanzelhaube;Kanzeldeckel;Kanzelhimmel;Schalldeckel
-...lehre;...kunde;...wissenschaft;...istik (fachspr.);...ologie (fachspr.)
-Sturm der Entrüstung;öffentliche Empörung;Welle der Empörung
-Leporello-Faltung;Zickzack-Faltung;Ziehharmonika-Faltung;Leporellofaltung;Ziehharmonikafaltung;Zickzackfaltung
-(etwas) wird jemand nie (ganz) ad acta legen können;es gibt (dafür) keine endgültige Lösung;(jemandem) wieder vor die Füße fallen;immer wieder konfrontiert sein (mit);(jemanden) wieder einholen (Problem)
-Instrumentation;Instrumentierung
-Orchestrierung;Orchestration
-Spiegeltrinker;Pegeltrinker
-(auf die Welt) holen;Geburtshilfe leisten
-operativ entbinden ('Saugglocke', Geburtszange);(die) Geburt (künstlich) einleiten;(ein) Kind holen
-Vakuumpumpe;Saugglocke (ugs.);Vakuumextraktor (fachspr.)
-Geburt mit Vakuumextraktor (fachspr.);Geburt mit Saugglocke;Saugglockengeburt;Vakuumextraktion (fachspr.);Saugglocken-Entbindung
-Geburtszange;Forceps;Forzeps
-schwere Geburt (fig.);nach zähem Ringen (fig.);Zangengeburt (fig.)
-übereifrig;eilfertig;in vorauseilendem Gehorsam
-Schandgeld;Judaslohn
-wie ist das (denn) möglich?;wie das denn?
-ein Grund mehr (für / zu / um zu);(eine) zusätzliche Erklärung;(eine) zusätzliche Erklärungsmöglichkeit;nicht zuletzt wegen;mit ein Grund (warum / weshalb);nicht zuletzt aufgrund;auch deshalb;(ein) weiterer Grund;auch aus diesem Grund;nicht zuletzt aus diesem Grund
-ihr Mädchenname ist (...);geb. (...);ihr früherer Name ist;(eine) geborene (...);mit Mädchennamen;mit Geburtsnamen;ihr Geburtsname ist;ihr vormaliger Familienname ist
-(wie hieß der) noch mal? (ugs.);(wie war das) noch mal? (ugs.);(wie geht das ) noch mal? (ugs.);(wie war das) noch gleich? (ugs.);(wie geht das) noch gleich? (ugs.);(wie hieß der) noch gleich? (ugs.)
-(noch) nicht zu sehen;mit unsicherem Ausgang;weit entfernt (von etwas) sein;nicht abzusehen;Ende offen;sich nicht abzeichnen;nicht in Sicht sein
-Verleger (Zeitung);Blattmacher;Zeitungsverleger
-Herausgeber (Zeitung);Blattmacher
-Chefredaktor (schweiz.);Hauptschriftleiter (veraltet);Chefredakteur
-Journalist (Presse) (franz.);Journalistin (Presse) (franz.)
-Frau von der Zeitung (ugs.);Pressetante (ugs., weibl.);Reporter (Presse);Reporterin (Presse);Mann von der Zeitung (ugs.);Zeitungsmann (ugs.);Zeitungsfritze (ugs., abwertend, männl.);Schmierfink (derb)
-Barde (archaisierend) (geh.);Liedermacher;Singer-Songwriter (engl.);Chansonnier (franz.);Chanson-Sänger
-Cantautor (selten, spanisch);Bard (russisch, selten);Cantautore (ital., selten)
-Frequenzwandler;Frequenzumformer
-(sich) auf etwas gefasst machen können (ugs.);zur Verantwortung gezogen werden;(jemandem) geht es an den Kragen (fig.);reif (für die Suppe) (ugs., fig.);fällig (sein) (ugs., fig.);dran (sein) (ugs.)
-aggressiv (Flüssigkeit);essigsauer;sauer;zieht einem den Mund zu(sammen);ätzend;zitronig
-brennend (Geschmack);wie Feuer;heiß;scharf
-Randexistenz;Marginalität
-hat sich gewaschen (ugs., fig.);wütend;geharnischt;scharf formuliert;scharf;gepfeffert
-Hohlsprech;Absonderung von Sprechblasen;Phrasendrescherei
-zwangsevakuieren;zwangsräumen (Hauptform);delogieren (österr.);aus der Wohnung vertreiben;(jemanden) entmieten (ugs., Jargon);(zwangsweise) exmittieren (veraltet);auf die Straße setzen (ugs.)
-Hochleistungsschnellarbeitsstahl;Hochleistungsschnittstahl;Hochleistungsschnellschnittstahl;Schnellarbeitsstahl;HSS;Schnellschnittstahl;Hochgeschwindigkeitsstahl
-Demarkation;Demarkierung
-Referenzmanager;Literaturverwaltungsprogramm
-Szientometrie;Scientometrie
-Steuerkonstrukt;Kontrollstruktur
-(in dieser Beziehung) kein Kind von Traurigkeit;alles mitnehmen;keine Gelegenheit auslassen (ugs.);nichts anbrennen lassen;kein Kostverächter (fig.);nicht verschmähen;die Blümlein am Wegesrand pflücken (fig.);nicht von der Bettkante stoßen
-(jemandem etwas) in Erinnerung rufen;(...) lässt grüßen;evozieren (geh.);(jemandem etwas wieder) ins Gedächtnis rufen;(jemanden an etwas) denken lassen;(jemanden) erinnern an;(in jemandem) entstehen lassen (Vorstellungen / Bilder);(jemanden) gemahnen (an) (geh.);(in jemandem) aufsteigen (Bilder / Erinnerungen) (lit.) (geh.);(in jemandem) Erinnerungen wachrufen;zu neuem Leben erwecken (Erinnerungen)
-Feuerfresser;Feuerschlucker
-Blondschopf;Blondkopf;Blondling (teilw. abwertend);(ein) Blonder
-(sich) einen harten Schlagabtausch liefern (variabel);Hauen und Stechen (fig.);(sich) nichts schenken (fig.);(Kampf) mit harten Bandagen (fig., variabel);es geht hart auf hart (Redensart)
-Nettozahler;Geberland
-gefüllte Kassen;(sichere / sprudelnde) Einnahmequellen;(da ist) Geld zu verdienen;Fleischtöpfe (fig.);Gelddruckmaschine (fig.);Pfründen;(da ist) etwas zu holen;(da ist) etwas zu verteilen
-Grundsatzrede;programmatische Rede
-Kampf um Unabhängigkeit;(Akt der) Selbstbefreiung;Emanzipation;Zugewinn an Selbständigkeit;Abnabelung
-Raketentriebwerk;Raketenmotor
-Vorbeischwungmanöver;Gravitationsmanöver;Schwerkraftumlenkung
-Netzpublikation;Online-Publikation
-E-Zeitung;elektronische Zeitung
-serielle Musik;Serialität;Serialismus
-Guano;Seevogeldünger
-es geht (richtig) zur Sache;(es ist) richtig was los;(die) Puppen tanzen lassen (fig.);Stimmung in der Bude;hoch hergehen (es)
-Leit...;Haupt...;wichtigste(r);maßgeblich;wesentlich(ste/r);Kern...;dominant;bestimmend
-edel;nobel;(ein) feiner Zug (von jemandem);gentlemanlike;edelmütig
-stets Gewehr bei Fuß (ugs.);zu allen Schandtaten bereit (selbstiron.) (ugs.);zu jeder Schandtat bereit;allzeit bereit
-auf alles vorbereitet;keine Möglichkeit ausschließen;mit allem rechnen;auf alles gefasst
-was wird das (denn)? (ugs.);was soll das werden (wenn's fertig ist)? (ugs.);was hast du vor?;was soll das geben? (ugs.);worauf willst du hinaus?
-proponieren (geh.);vorschlagen;beantragen
-Selbstbestimmtheit;Souveränität;Unabhängigkeit;Selbstverwaltung;Autonomie
-Gegenlichtkompensation;Gegenlichtausgleich
-Areallinguistik;Sprachgeographie
-Anthroponomastik;Anthroponymie
-Sprachatlas;Dialektatlas
-Ablaut;Apophonie
-Wortparadigma;Flexionsparadigma
-digitales Geländemodell;digitales Terrainmodell;digitales Höhenmodell
-Bleuel;Wäschebleuel
-Schlägel (fachspr.);Schlegel (fachspr.);Fäustel
-Mähmulcher;Mulcher;Mulchgerät
-Streitkolben;Schlägel (veraltet);Slegel (veraltet);Schlegel (veraltet)
-Wuchtwaffe;Schlagwaffe
-Flusskompressionsgenerator;FLUX (ugs.)
-(drauflos) spekulieren;Kaffeesatzleserei (betreiben);keine gesicherte Datenbasis (zugrunde legen);(sich etwas) zusammenphantasieren (abwertend);wilde Spekulationen (...);herumspintisieren (geh., abwertend);herumspekulieren;orakeln;herumraten (ugs.);(sich etwas) aus den Fingern saugen (ugs., fig.);herumspinnen (ugs., abwertend);Spekulationen anstellen;zwischen den Zeilen (lesen);(herum)fantasieren (abwertend);(abenteuerliche) Vermutungen (anstellen);(sich) in (abenteuerlichen) Spekulationen ergehen (variabel)
-aus den eigenen Reihen;von den eigenen Mitgliedern;von den eigenen Leuten
-Kulturpessimismus;(den) Untergang des Abendlandes (beschwören / heraufziehen sehen);(das Gerede vom) Untergang des Abendlandes
-bei nüchterner Betrachtung;nüchtern besehen;nüchtern betrachtet
-Startmedium;startfähiges Medium;bootfähiges Medium
-Endzeitvision;Endzeitszenario;Untergangsszenario;Weltuntergangsszenario
-unbeholfen;unprofessionell;ungelenk;hölzern
-Verkehrskollaps;Verkehrsinfarkt
-Generationenwechsel;Generationswechsel
-Ersatzlast;Ballast
-Anreißer (Jargon);Teaser (journal.) (fachspr.);Anriss (fachspr., Jargon)
-Cliffhanger (Jargon, engl.);aufhören, wenn es (gerade) am spannendsten ist (ugs.);Handlungsunterbrechung an der spannendsten Stelle
-(folgende) Episode;Weiterführung;Sequel;Fortsetzung;nächste Folge
-Preisanpassung (verhüllend);Preiskorrektur (verhüllend);Preiserhöhung;Neufestsetzung der Preise
-Ausgangsmaterial;Rohstoff;Grundstoff;Ausgangsstoff;Rohmaterial
-Werktitel;Titel;Buchtitel
-Nebentitel;Titelergänzung;Untertitel
-Filmtitel;Titel
-Titel des (englischen) Originals;Originaltitel;kam im (englischen) Original unter dem Titel (...) heraus
-Arbeitstitel;vorläufiger Titel
-Zwischentitel (Stummfilm);Titelkarte (fachspr.);Texttafel
-sperrig (Text);schwer zugänglich;will nicht gefallen;spröde;nicht zur Unterhaltung
-Dominikaner;Predigerorden
-Minoriten;Franziskaner-Minoriten
-Ursprungswahrscheinlichkeit;Anfangswahrscheinlichkeit;Vortestwahrscheinlichkeit;A-priori-Wahrscheinlichkeit
-Probabilität;Wahrscheinlichkeit (Hauptform)
-Vollzeitäquivalent;Vollzeit-Arbeitskraft;Vollzeitmitarbeiter;Mitarbeiteräquivalent;Mitarbeiterkapazität(en);Vollbeschäftigteneinheit;Vollkraft
-Feuerwerk;Feuerspektakel
-Kapitalrendite;Kapitalverzinsung;Anlagenverzinsung;Anlagenrentabilität;Kapitalrentabilität;Anlagenrendite
-Du-Pont-Kennzahlsystem;Du-Pont-Schema
-Jahresabschlussanalyse;Bilanzanalyse
-Akkumulation;Aufstockung
-in den Wahnsinn treiben;wahnsinnig machen (ugs.);ins Irrenhaus bringen (ugs., fig.);um den Verstand bringen;durchdrehen lassen
-dein Problem (ugs.);(und) was hab ich damit zu tun!? (ugs.);(und) wieso erzählst du das ausgerechnet mir? (ugs.);mir doch egal! (ugs.)
-(eine) Belastung darstellen (für);(jemanden) aufwühlen;kein Teflon-Typ sein (ugs., fig., variabel);aus der Ruhe bringen;erschüttern;(jemandem) zu schaffen machen;(sehr) betroffen machen;(jemanden) mitnehmen (ugs.);(jemanden) nicht kaltlassen (ugs.);(jemandem) an die Nieren gehen (ugs., fig.);(jemanden) belasten;nicht spurlos vorbeigehen (an jemandem) (ugs., fig.);an etwas zu knacken haben (ugs.);(jemandem) zusetzen;(jemandem) unter die Haut gehen (ugs., fig.);aus dem (seelischen) Gleichgewicht bringen;(jemandem) aufs Gemüt schlagen (ugs.);(jemandem) nicht in den Kleidern hängenbleiben (ugs., fig.)
-nicht loslassen;nehmen (ugs.);nicht aus der Hand geben;in die Hand nehmen;(sich) schnappen;fassen;packen;festhalten;(sich) greifen;ergreifen
-fest umklammert haben;fest in der Hand halten;fest gepackt halten;festhalten;in der Faust halten
-Sprechblase;Textblase
-Gatter;Logikgatter
-Nicht-Gatter;Inverter;Komplement-Gatter
-Umlaufgitter;Drängelgitter (ugs.);Umlaufschranken;Umlaufschranke;Umlaufsperre
-Viehrost;Viehgitter;Weiderost
-(innerlich) bewegen;(jemanden) anfassen (geh., fig.);zu Herzen gehen;(jemandem) nahegehen;(emotional) berühren;mitten ins Herz treffen (fig.);(jemanden) anrühren (geh.)
-Bewegungstherapie;Kinesitherapie;Heilgymnastik
-Medizinischer Assistenzberuf;Gesundheitsfachberuf;Heilhilfsberuf (veraltet);Medizinalfachberuf
-Übertragungsfunktion;Systemfunktion
-(ur)plötzlich sterben;tot umfallen;(jemanden) ereilt der Tod (geh.);plötzlich tot sein
-in Massen umkommen;massenhaft sterben;sterben wie die Fliegen;in Massen sterben
-Taupunkt;Taupunkttemperatur
-Häufungswert;Verdichtungspunkt;Häufungspunkt einer Folge
-Wasserdampfdichte;Dampfdichte;absolute Luftfeuchtigkeit
-Wasserdampfgehalt;Mischungsverhältnis;Feuchtigkeitsgrad
-Masse;Ruhemasse
-Aspirationshygrometer;Psychrometer
-Antiquität;altes Sammlerstück
-raus aus den Federn! (ugs.);Erhebe dich, du schwacher Geist! (ugs., ironisch);aufgestanden!;hoch mit dir!;hoch mit euch!;(los jetzt,) aufstehen! (ugs.);komm(t) hoch! (ugs.)
-Sonderfarbe;Schmuckfarbe
-Verweistitel;Alternativtitel (Film);Verleihtitel
-Schriftspiegel;Satzspiegel
-Seitenverschiebung;Transversalverschiebung;Blattverschiebung;Horizontalverschiebung
-Verschiebung;Bruch;Verwerfung;Störung im engeren Sinne;Sprung
-Unterströmungstheorie;Subfluenztheorie
-Expansionstheorie der Erde;Expansionshypothese
-Abkühlungstheorie;Schrumpfungstheorie;Kontraktionstheorie
-Befehlsinterpreter;Kommandointerpreter;Kommandozeileninterpreter;Befehlszeileninterpreter
-Prompt;Eingabeaufforderung
-Echtzeit-Transaktionsverarbeitung;Online-Transaktionsverarbeitung
-Rückplatte;Busplatine
-Erweiterungskarte;Elektronikkarte;Steckkarte
-A*-Algorithmus;A*-Suche
-Suchverfahren;Suchalgorithmus
-Bewertungsfunktion;heuristische Bewertungsfunktion;statische Bewertungsfunktion
-Teilsummenproblem;Untermengensummenproblem
-Andenfelsenhahn;Andenklippenvogel;Roter Felsenhahn
-NIR-Spektroskopie;Nahinfrarotspektroskopie
-Atomspektroskopie;Atomspektrometrie
-Atomemissionsspektrometrie;optische Emissionsspektrometrie
-Funkenspektrometer;optisches Emissionsspektrometer
-Anti-Helmholtz-Spule;Maxwell-Spule
-kommen (zu);(jemandes) (andere) zeitliche Verpflichtungen lassen es zu (floskelhaft);(zeitlich) schaffen;(etwas) terminlich hinbekommen (ugs.);(sich) die Zeit nehmen (zu);es (zeitlich) einrichten können (floskelhaft);(die) Zeit haben;(sich) (einen) Termin freihalten (für);(die) Zeit finden
-(ständig) Volten schlagen (geh.);fluktuieren (geh., bildungssprachlich);(sich) verändern;hin- und herpendeln;flottieren (geh., bildungssprachlich);wechseln;schwanken
-(ganz) gut zurechtkommen;(eine) ordentliche Leistung bringen;(sich) als tüchtig erweisen;tapfer seinen Mann stehen;tapfer ihren Mann stehen;(sich) wacker schlagen
-Standlerin (süddt.);Marktverkäuferin;Marktfrau;Verkäuferin am Marktstand;Standinhaberin;Marktweib (abwertend);Budenbesitzerin
-mittelmäßig;ohne Höhen und Tiefen;glatt;ohne Ecken und Kanten;ohne weitergehenden Anspruch;so weit okay (ugs.);(ganz) nett (so weit);gefällig (Film, Inszenierung)
-routiniert gemacht;handwerklich solide (aber eben nicht mehr);gediegen;ordentlich
-Fischweib (abwertend, veraltend);Fischverkäuferin (Wochenmarkt)
-(es) steht viel auf dem Spiel (für jemanden);(es) steht einiges auf dem Spiel;(es gibt) viel zu verlieren;viel zu verlieren haben
-wie wär's mit ...? (ugs.);... gefällig? (geh.);was hältst du von ...?;was halten Sie von ...?;...? (Einzelwort in Frage-Intonation) (ugs.);möchten Sie ...
-(jemandem) recht;(jemandem) zusagen;(jemandem) passen;(jemandem) genehm;kommod;passend;konvenieren (geh.);gelegen kommen;gefällig (sein) (geh.)
-Valuta;Wertstellung
-Valutadatum;Wertstellungsdatum
-Geldzahlungsschuld;Geldschuld
-im Einzelverkauf;am Kiosk
-im Abo;als Abo;als Abonnement
-Sowjetische Marine;Rote Bauern- und Arbeiter-Flotte;Rote Flotte;Seekriegsflotte der UdSSR
-Rotbanner-Nordflotte;Nordflotte
-Reptilienfonds;schwarze Kasse;Dispositionsfonds
-Kölner Spendenaffäre;Müllaffäre
-reif für die Tonne (ugs.);hau weg den Scheiß (gespielt prollig) (ugs.);sieh zu, dass das wegkommt (ugs.);halt dich nicht lange damit auf;(etwas) kann (zum Müll o.ä.) (ugs., variabel);(das) kann weg (ugs.);wirf es weg (Hauptform);(nur) weg damit (ugs.);immer weg damit (ugs.);schmeiß es weg (ugs.);(das) ist gut für die Tonne (ugs.)
-es schwindelt jemanden (selten);(jemandem) wird schwind(e)lig;(jemandem) vergeht Hören und Sehen (ugs.);es schwindelt (jemandem)
-nicht wissen, wie einem geschieht;(jemandem) wankt der Boden unter den Füßen (fig.);nicht glauben können, was geschieht;(jemandem) vergeht Hören und Sehen (ugs.);nicht (mehr) wissen, ob man Männchen oder Weibchen ist (ugs.);nicht mehr wissen, wo vorne und hinten ist (ugs., übertreibend)
-Wer gehen will, soll das tun.;Wer gehen will, soll gehen.;Wenn du gehen willst, dann geh.;Reisende soll man nicht aufhalten. (Redensart)
-schwindeln machend;schwindelnd;schwindelerregend;Schwindel erregend
-(sich) durchsetzen;(sich) Bahn brechen;nicht (mehr) aufzuhalten sein
-Grafikprogramm;Grafiksoftware
-Rasterung;Rendern;Scankonvertierung
-Radfahrstreifen;Radstreifen (schweiz.);Velostreifen (ugs., schweiz.)
-Radfahranlage (österr.);Radverkehrsanlage
-Ruhen des Verfahrens;Sistierung
-eingehend erörtern;lang und breit diskutieren;in aller Ausführlichkeit besprechen
-aufs Tapet bringen;(eine) Frage aufwerfen;(etwas) ins Spiel bringen;in die Runde werfen (ugs., fig.);(etwas) (in die Diskussion) einbringen;aufbringen (Thema);(etwas) in den Raum stellen (fig.)
-einsteigen in (Debatte);beginnen;aufnehmen (Gespräche, Verhandlungen, die Arbeit);eröffnen (Diskussion)
-Jakobiten;Jakobiter
-nicht dasselbe sein;auseinanderzuhalten sein;unterscheiden müssen;nicht gleichzusetzen sein;nicht verwechseln dürfen;(einen) Unterschied machen (es macht ...);auseinanderhalten müssen;(einen) Unterschied darstellen;(voneinander) getrennt halten müssen
-(sich) herausheben;(sich) positiv absetzen (von);(sich) abheben (von);(sich) hervorheben (durch);(sich) auszeichnen (durch);(positiv) herausstechen;(sich) wohltuend abheben (von) (floskelhaft);etwas Besonderes (sein);glänzen (mit etwas)
-nicht identifizierbar sein;(in der Masse) untergehen;nicht zu identifizieren sein
-auf Konfrontationskurs gehen;(die) Auseinandersetzung suchen
-Zuhältermentalität;asoziale Einstellung
-Verteiler;Distribuent
-als Zuschuss zahlen;(sich) finanziell beteiligen (an);subventionieren;bezuschussen;(finanziell) stärken;(finanziell) fördern;sponsern;(finanziell) unterstützen;(finanziell) stützen
-Feuerwehranfahrtszone;Feuerwehrauffahrtszone (österr.)
-Sattelpunkt;Terrassenpunkt;Horizontalwendepunkt
-vollständiges Differential;totales Differential
-Ratendarlehen;Tilgungsdarlehen;Abzahlungsdarlehen
-Diskontierungssummenfaktor;Annuitätenbarwertfaktor;Rentenbarwertfaktor
-Aufzinsung;Askontierung
-risikofreier Zinssatz;risikoloser Zinssatz
-Kalkulationszinssatz;Kalkulationszinsfuß
-effektiver Jahreszins;effektiver Jahreszinssatz
-Kapitalwert;Nettobarwert
-Gegenwartswert;Barwert
-Kapitalmarktzins;Geldmarktzins;Marktzins
-Primärmarkt;Emissionsmarkt
-Anschlussleistung;Anschlusswert;Scheinleistung
-Methode des internen Zinsfußes;Methode des internen Zinssatzes;Interne-Zinsfuß-Methode;Interne-Zinssatz-Methode
-Rentabilitätsrechnung;Rentabilitätsvergleichsrechnung
-Kapitalrückflussrechnung;Kapitalrückflussmethode;Amortisationsrechnung
-Übles im Sinn(e) haben;finstere Absichten haben;(sein) Unwesen treiben;(Böses) im Schilde führen;nichts Gutes vorhaben
-Amortisation;Amortisierung
-herumspuken;(sein) Unwesen treiben (Poltergeist);rumoren
-Globalurkunde;Sammelurkunde
-böse Späße treiben;groben Unfug veranstalten;(sein) Unwesen treiben;üble Streiche spielen
-Bestimmtheitsgrundsatz;Spezialitätsprinzip
-Schuldrechtsmodernisierungsgesetz;Gesetz zur Modernisierung des Schuldrechts
-Gesetzeskommentar;Kommentar (fachspr.)
-(die) Gegend unsicher machen;(herum)marodieren;(irgendwo) sein Unwesen treiben;(irgendwo) kriminell aktiv sein;(seinen) verbrecherischen Geschäften nachgehen
-Gesetz über das Treuunternehmen;Treuunternehmensgesetz
-Treustiftung;Geschäftstreuhand;Treuunternehmen
-Filmcrew;Crew;Stab;Filmstab
-Motiv (fachspr.);Drehort;Aufnahmeort;Filmset;Set (Hauptform)
-Boykottieren;Boykottierung
-Krankenlager;Krankenbett
-im Unterschied zu;entgegen;im Gegensatz zu;abweichend von;anders als;im Widerspruch zu
-(Allgemeine und) Vergleichende Literaturwissenschaft;Komparatistik
-keine Zukunft haben;(jemandes) Schicksal ist besiegelt;aus einer (geplanten) Sache wird nichts;chancenlos sein (Sache)
-du weißt doch gar nicht, was du da sagst!;was weißt (denn) du schon! (ugs., variabel);du hast doch keine Ahnung! (ugs.)
-Streckblasen;Spritzstreckblasen
-(jemandem) wird ganz anders (bei);weiche Knie bekommen;(jemandem) durch und durch gehen
-durch Mark und Bein gehen;durch und durch gehen;nicht zu überhören sein;alles durchdringen (Geräusch);markerschütternd (sein)
-(jemandem) durch und durch gehen;(die) Seele berühren;(jemandem) stockt der Atem;im Innersten berühren;ins Herz treffen;(jemandem) schwillt das Herz in der Brust (lit.)
-Unternehmen Reisebüro (Eigenname);Girrmann-Gruppe (Eigenname)
-Studierendenwerk (regional);Studentenwerk
-Geturtel;Turtelei(en);Liebesgeflüster
-nichts dem Zufall überlassen;jedes Detail sorgfältig planen
-(jemandem) bleibt wenig Zeit;spät dran sein;nur noch wenig Zeit haben;nicht mehr viel Zeit haben
-austüfteln;ausknobeln;ausbrüten (ugs., fig.);ersinnen (geh.);Ideen entwickeln (zu);erdenken;(sich) ausdenken;ausklamüsern (ugs., norddeutsch);ausklügeln;(sich) einfallen lassen
-Salinität (fachspr., lat.);Salzgehalt;Salzigkeit;Salzhaltigkeit
-Hammer... (ugs.);der Wahnsinn (sein) (ugs.);hammermäßig (ugs.);tolle Sache (sein) (Hauptform);der Hammer (sein) (ugs.)
-Granate;Hammerschuss
-(die) unangenehmen Aufgaben erledigen (müssen);(der) Mann fürs Grobe (sein) (ugs.);(die) Drecksarbeit(en) machen (ugs.)
-entschwebt;versponnen;okkult;entrückt;weltfremd
-Aufbewahrungsort;Ablage;Depot;Lager
-Frontkämpfer;Frontsoldat;Frontschwein (derb)
-Basiswert;Bezugswert;Handelsobjekt
-Polbewegung;Polschwankung
-Orderverkehr;Bedarfsflug;Charterflug;Anforderungsverkehr
-könnte (gut) ... werden;...verdächtig;sieht (ganz) nach ... aus
-Scheidebecher;Herrgöttli (schweiz.);Absacker;Fluchtachterl (österr.);Schlürschluck
-Feuerball;Isothermalsphäre;Feuerblase
-Quantenoptik;Quantenelektronik (veraltet)
-Großraumstraßenbahnwagen;Straßenbahn-Großraumwagen;Großraumwagen;Großraumstraßenbahn (ugs.)
-Wurfeisen;Krähenfuß;Fußangel
-(etwas) durch die Blume sagen (fig.);nicht klar benennen;Andeutungen machen
-Hoher Mantel;Mantelmauer
-Hochburg;innere Burg;Kernburg;Hauptburg
-Bermenmauer;Grabenzwingermauer
-zu werden scheinen;wirken wie;aussehen nach;zu sein scheinen;hat etwas von (...)
-Beschäftigungstherapie (fig., Hauptform);Arbeit ohne Sinn;(reine) Arbeitsbeschaffungsmaßnahme (fig.);sinnlose Arbeit
-Zellatmung;aerobe Atmung;innere Atmung
-Anabolismus (fachspr., griechisch);Baustoffwechsel
-Energiestoffwechsel;Betriebsstoffwechsel (veraltet)
-Gibbssche freie Energie;Freie Enthalpie;Gibbs-Energie;Gibbs-Potential
-Orgasmushemmung;Anorgasmie
-Anorganik;anorganische Chemie
-die folgende Woche;in der folgenden Woche;jetzt die Woche (ugs.)
-(nicht jetzt die Woche, sondern) dann die Woche (ugs.);in der übernächsten Woche
-in Aussicht stellen;vorankündigen;unverbindlich zusagen
-inständig beteuern;mit allem Nachdruck versichern;händeringend beteuern;hoch und heilig versichern (ugs.)
-Vertretung;Stellvertretung;Ersatz
-globale Variable;Umgebungsvariable
-Schimmer;Widerschein;Abglanz
-sehr genießen (etwas zu tun);sehr gerne (tun);unwahrscheinlich gerne (tun) (ugs.);für sein Leben gern (tun)
-Felsklettern;Felsenklettern
-(sich) freuen können auf;(jemandem) lachen (lit.) (geh.);winken;in Aussicht stehen;(sich) freuen dürfen auf
-(jemanden) identifizieren (als);(in jemandem) jemanden erkennen;(jemandes) Identität feststellen;(jemanden) erkennen
-Gulaschkanone (ugs.);Feldkochherd;Feldküche
-Perianalvenenthrombose;Analthrombose;Perianalthrombose;unechte Hämorrhoide
-Patronenlager;Kammer
-wieso sagst du das erst jetzt?;schön, das von dir zu hören (ugs.);(das ist) gut zu wissen;schön, dass ich das (jetzt) auch mal erfahre! (ugs.)
-für ihre ...;für seine ...;dafür dass sie schon ... ist;für seine ... Jahre (Hauptform);für ihre ... Jahre (Hauptform);dafür dass er schon ... ist
-woher sollte ich das wissen?;das konnte ich ja nicht ahnen!
-(das) hilft einem weiter;das merke ich mir;(das ist) gut zu wissen;eine nützliche Information (sein);danke für die Information
-(jemandem) neu sein;(etwas) nicht gewusst haben
-(jemandem) nicht neu sein;(etwas) wissen (Hauptform);(für jemanden) nichts Neues sein;Kenntnis haben (von);von etwas wissen;Erkenntnisse haben (über);(über etwas) informiert sein;(es) liegen Erkenntnisse vor (über);(jemandem) bekannt sein
-(sich) mit eigenen Augen überzeugen (von);(sich) persönlich überzeugen;selbst in Augenschein nehmen;selbst sehen;mit eigenen Augen sehen
-gesondert;getrennt;extra;separat
-so scheint es;nach allem was man hört;anscheinend;es scheint (so zu sein) dass;so scheint's (Einschub);es scheint sich so zu verhalten dass;es scheint an dem zu sein, dass
-erklärt haben, dass;ihren (eigenen) Worten zufolge;erklärtermaßen;nach ihren (eigenen) Worten;seinen (eigenen) Worten zufolge;nach seinen (eigenen) Worten
-und das sage ich ganz bewusst (Einschub);ich sage (hier) ausdrücklich;auch wenn ich mich wiederhole;(und) das sagte ich bereits (Einschub);ich möchte betonen dass;ich erkläre hiermit (ausdrücklich) dass;ich sage ganz bewusst;ich lege Wert auf die Feststellung;und ich sage (es) noch einmal
-erklärtermaßen;ausdrücklich
-(sich) noch nie begegnet;(jemandem) völlig unbekannt;wildfremd;noch nie (zuvor) gesehen
-(seine) Lehrzeit beendet haben;nichts mehr dazulernen können;mit der Ausbildung fertig sein;ausgelernt haben (auch figurativ);(seine) Ausbildung abgeschlossen haben
-witzlos;ohne Überraschungen;ohne Pointe;ohne Esprit
-Kältesteppe;Tundra
-unaufdringlich;unauffällig;verhalten;schwach;matt
-ohne Gestaltung;ausdrucksarm;ohne Ausdruck;ohne (künstlerische) Aussagekraft
-in den hinteren Reihen;(da hinten) auf den billigen Plätzen (ugs., spöttisch)
-fiktiver Ort;fiktives Universum;fiktive Welt;Fantasiewelt
-Explosionsentgraten;thermische Entgrat-Methode;thermisches Entgraten
-Brennebene;Fourierebene
-Elektronenkanone;Strahlsystem;Elektronenstrahlsystem
-Kathodenstrahlen (veraltet);Elektronenstrahlung
-paraxiale Optik;gaußsche Optik;Optik erster Ordnung
-war mal;veraltet;nicht mehr auf dem aktuellen Stand;von gestern;Makulatur (fig.);überholt;entspricht nicht (mehr) dem Stand der Technik
-Bestrahlungspneumonie;Strahlenpneumonitis
-Allwissenheit;Omniszienz (geh.)
-omniszient (geh.);alles wissend;allwissend
-Eisbahn;Schlitterbahn (regional);Glitsche (regional);Schlinderbahn (regional);Rutschbahn
-rutschen;glitschen;schlindern;schlittern;schliddern (ugs., norddeutsch)
-rutschen;flutschen (ugs.);gleiten;glitschen
-Eisgalle (tirolerisch);zugefrorene Pfütze
-überfrieren;leicht frieren;oberflächlich frieren;anfrieren
-breiartig;wie Brei;mampfig (ugs., süddt.);musartig;pampig (norddeutsch);wie Mus;breiig;musig;pastös
-sämig machen;cremig machen;eindicken;binden;abziehen;andicken;legieren;abbinden (Soße)
-(den) Wassergehalt verringern;reduzieren (Soße, Fonds);einkochen
-(es) fehlen keine Teile;(es ist) noch alles dran
-auf Ablehnung stoßen;abgelehnt werden;auf wenig Gegenliebe stoßen;nicht gewollt sein
-(sich) nicht wohlfühlen (bei);(jemandem) wird mulmig;Unbehagen bereiten;(jemandem) ist mulmig;(sich) unwohl fühlen (bei) (dem Gedanken);(sich) unangenehm berührt fühlen (floskelhaft);(jemandem) ist unbehaglich;(sich) unbehaglich fühlen;(jemandem) wird unbehaglich zumute
-Japanischer Sagopalmfarn;Japanischer Palmfarn
-Sagopalmfarne;Cycas-Palmfarne
-unterirdische Führungsanlage;Regierungsbunker
-Überhorizontrichtfunk;Troposphärenfunk
-schön dich (hier) zu sehen! (ugs.);welch(er) Glanz in meiner Hütte! (ugs.);(na) das ist (jetzt) aber (echt) 'ne Überraschung! (ugs.)
-späte Nachwirkung(en);Spätfolge(n)
-mit der Zustimmung (von);unter (jemandes) Billigung;mit (freundlicher) Genehmigung (von)
-(eine) Arbeit finden;eingestellt werden;unterkommen (bei) (ugs.);(einen) Job ergattern (ugs.)
-kampferfahren;(hat) (so) manchen Strauß ausgefochten (ugs., Redensart);streiterprobt;(hat) viele Kämpfe bestanden
-wie gebannt anstarren;wie das Kaninchen auf die Schlange starren;gebannt starren (auf)
-starr vor Schreck;schreckensstarr;starr vor Angst;wie das Kaninchen vor der Schlange;wie gelähmt;gelähmt vor Angst
-Horrorfilm (Hauptform);Horrorstreifen (ugs., salopp);Gruselschocker;Schocker;Gruselfilm
-Schocker;Gruselschocker;Horrorroman
-Gothic novel (engl.);Schauerroman
-Schauermärchen (oft fig.) (auch figurativ);Schauergeschichte;(die) Schauermär (geh., altertümelnd, ironisierend);Gruselgeschichte
-aufeinander abstimmen;synchronisieren;(miteinander) vertakten
-viel geplagt sein (mit);(ein) Lied singen können (von) (fig.);(bereits) schlechte Erfahrungen gemacht haben (mit);(etwas) nur zu gut kennen
-(negative) Konsequenzen haben;(die) Quittung bekommen (für) (fig.);(Unangenehmes) nach sich ziehen;(sich) negativ auswirken;(sich) rächen;(negative) Folgen haben;(etwas wird) ein Nachspiel haben
-folgenlos bleiben;keine Konsequenzen haben;(ein) stumpfes Schwert (sein) (fig.);nicht geahndet werden;keine Konsequenzen nach sich ziehen
-(sich als) Bumerang (erweisen);(jemanden) wieder einholen;(wieder) zurückfallen (auf);(eine) tickende Zeitbombe (sein) (fig.);(jemandem) (wieder) auf die Füße fallen (fig.);(einen) Bumerangeffekt haben;(jemandem) (wieder) vor die Füße fallen (fig.);das Pendel schlägt zurück (fig.)
-Abdruck;(einzelner) Fußabdruck;Eindruck;Pfotenabdruck;Trittsiegel
-schnüren (z.B. Füchse);langsam laufen;traben
-langsam (aber zügig) laufend;im Dauerlauf;in mäßigem (Lauf-) Tempo;im Trab
-in Milliardenhöhe;im Milliardenumfang;milliardenschwer;im Umfang von mehreren Milliarden
-Auftragsvolumen;Größenordnung
-Zugverbindung;Anschlusszug
-(schöner) Schreck in der Morgenstunde (ugs.);auf nüchternen Magen (fig.)
-(die) Art wie jemand lacht;Lache
-History;Verlauf (PC, IT);Versionsgeschichte;Verlaufsprotokoll;Chronik
-Meldung erstatten;Meldung machen (militärisch);(offiziell) melden
-Anzeige erstatten (gegen);(jemandem) eine Anzeige verpassen (ugs.);(etwas / jemanden) anzeigen;zur Anzeige bringen
-Ostfriesennerz (historisch, scherzhaft);Friesennerz (historisch, scherzhaft);Öljacke;(spezielle, meist gelbe, lange) Kapuzenregenjacke
-auf eigenen Füßen stehen (fig.);alleine zurechtkommen;wirtschaftlich unabhängig sein;(sich) vom Elternhaus abgekoppelt haben;für sich (selbst) sorgen (können) (variabel);alleine klarkommen (ugs.);(sein) eigenes Geld verdienen;auf (seinen) eigenen Beinen stehen (fig.)
-unweigerlich;logischerweise;in der Natur der Sache liegen;unvermeidlich;folgerichtig;konsequenterweise;zwangsläufig;notwendigerweise;muss so kommen (ugs.)
-von allein;ohne weiteres Zutun;von selbst;nichts weiter zu unternehmen brauchen;automatisch
-inner...;hausintern;intern;innerhalb
-unordentlich;undiszipliniert (Team);Sauhaufen (häufig mil.)
-die Zügel schleifen lassen (fig.);nicht für Ordnung sorgen;drunter und drüber gehen (es) (ugs.);(die) Dinge laufen lassen;keinen Zug haben (in) (ugs.);(irgendwo) ist kein Zug drin (ugs.)
-(jemandem) auf der Nase herumtanzen (ugs., fig.);machen (dürfen) was man will;(jemandem) auf dem Kopf herumtanzen (ugs., fig.);über Tisch(e) und Bänke gehen (ugs., fig.);(alles) machen (dürfen) worauf man (gerade) Lust hat;(sich) an keine Regel(n) halten
-Selbstzerfleischung;Kannibalismus (geh.);erbitterte interne Auseinandersetzungen;Selbstdemontage;Selbstzerstörung
-todessehnsüchtig (fig.);lebensverneinend;nihilistisch;selbstmörderisch (fig.)
-unbeeindruckt;kaltschnäuzig;ungerührt;kurz und schmerzlos (fig.);knochentrocken
-nicht weit vom Schuss;gut angebunden;gut zu erreichen;gut erreichbar
-um Ausgleich bemüht;konziliant (geh., bildungssprachlich);versöhnungsbereit;nicht nachtragend;versöhnlich;nachsichtig;versöhnungswillig
-abtauchen (ugs., fig.);(sich) verkriechen;nicht (mehr) aus dem Haus gehen;zu Hause bleiben;keinen Fuß vor die Tür setzen (fig.);(die) Wohnung nicht verlassen;(sich) vergraben;schön zu Hause bleiben (ugs.);mit dem Arsch zu Hause bleiben (derb)
-nicht (mehr) erreichbar sein (fig.);in Klausur gehen;(sich) einigeln;zumachen;(sich) verschließen;(sich) in Klausur begeben;in Ruhe gelassen werden wollen;(sich) abkapseln;(lieber) allein sein wollen;(sich) von der Außenwelt abschotten;mit niemandem zu tun haben wollen;dichtmachen;(sich) zurückziehen
-Klappladen;Fensterbalken (österr.);Klappladen (süddt.);Drehladen (schweiz.);Schlagladen (norddeutsch);Fensterladen
-(sich) den ... anschließen;... werden;(sich) den ... zugesellen;bei den ... mitmachen;unter die ... gehen
-Schlägel;Knüpfel;Klüpfel;Klöpfel;Klipfel
-primäre Kosten;Primärkosten;einfache Kosten
-Werkstoffkosten;Materialkosten
-Fremdleistungskosten;Dienstleistungskosten
-Vorkostenstelle;Sekundärkostenstelle;Hilfskostenstelle;Nebenkostenstelle
-Ostliste;Ostzonenverzeichnis
-überrumpeln;auf dem falschen Fuß erwischen (fig.);überraschen;überfahren (fig.)
-über den Haufen fahren (ugs.);überrollen;umfahren (Betonung auf 'um');über jemanden fahren;überfahren (Hauptform);umkacheln (Betonung auf 'um') (ugs.)
-für immer;für immer und ewig;auf ewig (geh.);ein für alle Mal;für alle Zeit(en);für Zeit und Ewigkeit;auf immer und ewig (regional oder archaisierend) (geh.);für alle Zukunft
-um ein Haar nicht erreichen (ugs.);(so) gerade noch antreffen;erwischen (ugs.);um ein Haar verpassen (ugs.)
-Störer;Troll;Unruhestifter
-nicht geeignet;untüchtig;unfähig;kann es (einfach) nicht
-Berserker;Wütender;Tobender;Tobsüchtiger;Rasender;Randalierer;Wüterich
-Masochismus (fig.);Selbstquälerei;Leidensbereitschaft
-(die) Frau seines Lebens;(die) Richtige (ugs.);(die) Frau fürs Leben
-Designerdroge;Partydroge
-Luftbildprojektion;archäologische Flugprospektion;Luftbildarchäologie
-Unke;Feuerkröte
-Bestandsschutz;Bestandsgarantie;Besitzstandswahrung;Großvaterrechte;Bestandssicherung
-nationaler Zuteilungsplan;nationaler Allokationsplan
-Schmelzkammerfeuerung;Schmelzfeuerung
-Streuwerttabelle;Hashtabelle
-sphärisches Panorama;Kugelpanorama
-Aktion Roter Punkt;Roter-Punkt-Aktion;Rote-Punkt-Aktion
-Schwarzfahren (ugs.);Beförderungserschleichung (fachspr., juristisch)
-Leistungserschleichung;Erschleichen einer Leistung
-Exarchat von Italien;Exarchat von Ravenna
-';halbes Anführungszeichen;einfaches Anführungszeichen
-Überlegung;Gedankenspiel;Gedankenexperiment
-Europalette (ugs.);Europoolpalette
-Transportpalette;Palette (Kurzform)
-Galeasse;Galjäß
-von Legenden umrankt;von Sagen umwoben;legendär (sein) (Hauptform);sagenumwoben;darüber erzählt man sich viele Geschichten;Legende (sein)
-kein Geheimnis machen (aus);nicht verschweigen
-Vogt;Voigt;Fauth
-Pinus cembra (fachspr., botanisch);Zirbe;Arve;Zirbelkiefer (Hauptform);Zirbel;Arbe
-Feuerbaum;Forche (alemann.) (ugs.);Kienföhre;Fackelbaum;Föhre (ugs., österr.);Forle (ugs., regional);Pinus (fachspr., botanisch, lat.);Dähle (ugs., schweiz.);Kienbaum;Kiefer (Hauptform)
-Hakenkiefer;Spirke;Pinus mugo subsp. uncinata (fachspr., botanisch);Aufrechte Bergkiefer (fachspr.)
-Fenstertag;Brückentag;Zwickeltag
-zukunftsfähig;nachhaltig;zukunftstauglich;zukunftsfest
-Kirchenjahr;liturgisches Jahr;Herrenjahr
-flexible Disc;Schallfolie;Flexidisc;Flexi
-Pauschalabgabe;Urheberrechtsabgabe (ugs.)
-Grillette;Grilletta
-Salzgurke;saure Gurke
-thermische Verwertung (fachspr., technisch, verhüllend);thermische Abfallbehandlung (fachspr., technisch, verhüllend);thermische Abfallverwertung (fachspr., technisch, verhüllend);Kehrichtverwertung (schweiz.);energetische Verwertung (fachspr., technisch, verhüllend);Kehrichtverbrennung (schweiz.);Müllverbrennung;Abfallverbrennung
-MVA (Abkürzung);thermische Abfallbehandlungsanlage;Müllverbrennungsanlage;KVA (Abkürzung, schweiz.);Kehrichtverbrennungsanlage (schweiz.)
-mechanisch-biologische Abfallbehandlungsanlage;stoffspezifische Abfallbehandlung;mechanisch-biologische Vorbehandlungsanlage
-Bodengefüge;Bodenstruktur
-Grundgefüge;Primärgefüge
-Einzelkorngefüge;Elementargefüge
-Hüllengefüge;Kohärentgefüge
-Krümelgefüge;Aufbaugefüge;Aggregatgefüge
-Absonderungsgefüge;Segregatgefüge
-Edaphon;Bodenlebewesen
-Pflugsohle;Pflugsohlenverdichtung
-Wellnessoase (fig.);Spa (Hotel);Wellnessbereich
-(sich) nicht lange halten können;nicht lange bleiben;nicht alt werden (ugs., fig.)
-aussteigen;aus einem Fahrzeug steigen;(einem Fahrzeug) entsteigen (geh.)
-passen (Kartenspiel) (Hauptform);nicht (weiter) mitgehen;aussteigen
-windige Ecke;zugige Ecke;Windloch
-(Zeit der) Nachrichtenflaute;Sommerloch (Hauptform);nachrichtenarme Zeit;ereignislose Zeit im Hochsommer
-(immer) herein in die gute Stube! (ugs.);immer rein! (ugs.);immer rin in die gute Stube (ugs.);immer hereinspaziert! (ugs.);(nur) herein wenn's kein Schneider ist! (ugs.);nur hereinspaziert! (ugs.)
-DVD-Spieler;DVD-Player (engl.);DVD-Abspielgerät
-Theorie der wirbelfreien Vektorfelder;Potentialtheorie
-für teures Geld;für teuer Geld (ugs.);mit hohen Kosten (verbunden);zu hohen Kosten
-Sokal-Kontroverse;Sokal-Affäre;Sokal-Debatte
-Minoische Keramik;Kreto-Minoische Keramik
-Wiener-Filter;Wiener-Kolmogoroff-Filter
-Nichtveranlagungsbescheinigung;NV-Bescheinigung
-(es) läuft alles wie geschmiert;Läuft. (ugs., Jargon);(es gibt) keine Probleme;(der) Laden läuft
-(die) Geschäfte gehen gut;(der) Laden brummt (ugs., fig.);(der) Laden läuft;wirtschaftlich gesund (sein) (Unternehmen);(die) Geschäfte laufen gut
-ewig ja-sagend;affirmativ;liebedienerisch;jasagerisch;kritiklos;lobhudlerisch
-Pentachoron;5-Zeller;Pentatop;Hypertetraeder;Hyperpyramide
-Polychor;Polychoron
-Simplex;n-dimensionales Hypertetraeder;n-Simplex;Hypertetraeder
-Satz des Cavalieri;Prinzip von Cavalieri;Cavalierisches Prinzip
-Verkehrkette;Transportkette
-Ganzzug;Blockzug
-Einzelwagenverkehr;Wagenladungsverkehr
-Fahrt über Grund;Grundgeschwindigkeit;Geschwindigkeit über Grund
-Halbanschlussstelle (österr.);Teilanschlussstelle
-Serviceklasse;Sitzklasse;Beförderungsklasse
-(sich) verselbstständigen;zu einem Wert an sich werden;(sich) verselbständigen
-(bis) zu Ende gelesen haben;fertig sein mit;aus(gelesen) haben;durchhaben;durch sein mit;fertiggelesen haben;intus haben
-diplomatisch;konfliktvermeidend;ausgleichend
-um sich werfen (mit) (ugs.);nicht sparen mit;nicht sparen an;großzügig austeilen;es hagelt (nur so) (fig.);(nur so) um sich schmeißen (mit) (ugs.);(es) nicht fehlen lassen (an)
-Altazimut;azimutale Montierung
-Azimutalwinkel;Horizontalwinkel
-Gefällsmesser;Gefällemesser;Gefällmesser
-Handgefällmesser;Handgefällsmesser;Handgefällemesser
-Nivellette (österr.);Gradiente
-Kepler-Fernrohr;astronomisches Fernrohr
-Dufourkarte;Topographische Karte der Schweiz
-Innersudetische Senke;Innersudetisches Becken
-Kreuzungsbauwerk;Überwerfungsbauwerk
-Automatisches Warnsystem;Rottenwarnanlage
-(wehmütiger) Abschied;Ausklang;Abgesang
-Magenkarzinom;Magenkrebs
-Landkärtchen;Landkärtchenfalter
-Anagenese;phyletische Evolution;Artumwandlung
-evolutionäre Anpassung;Adaptation (wissenschaftlich)
-Prädisposition;Präadaptation;Voranpassung;Präadaption
-missionarische Akkommodation;Adaption
-Evangelisierung;Evangelisation
-biogenetische Grundregel;biogenetisches Grundgesetz;Rekapitulationstheorie
-beratende Psychologie;nichtheilkundliche Psychologie
-wohlgezielt (geh.);auf den Punkt gebracht;knackig (ugs.);zugespitzt;pointiert
-extravagant;nobel;mondän;exklusiv;elegant;vornehm;fein
-Ablederung;Décollement
-Subkutis;Hypodermis (fachspr., griechisch);Subcutis (fachspr., lat.);Unterhaut;Subdermis;Tela subcutanea;Subkutangewebe;Hypoderm
-Hypokaustum;Hypokauste
-Mordwange;Sühnestein
-archäologisches Denkmal;Bodendenkmal
-Apside;Apsis
-Flurname;Riedname
-Sackgleis (fachspr.);Stutzgleis (fachspr.);Blindgleis (fachspr.);Kopfgleis (fachspr., schweiz.);totes Gleis;Stumpfgleis (fachspr.);Stumpengleis (fachspr., schweiz.)
-Abt'sche Weiche;abtsche Weiche;abtsche Ausweiche
-Anschlussgleis;Gleisanschluss
-Umsetzgleis;Umfahrgleis
-Umsetzendstelle;Umsetzstelle;Kuppelendstelle
-Folgezugbetrieb;Zugfolgebetrieb
-Backenschiene;Stockschiene (schweiz.)
-keine Wirkung zeigen;nicht verfangen (bei);nicht ziehen (bei) (ugs.);nicht die gewünschte Wirkung haben (bei)
-Kälteunempfindlichkeit;Frostresistenz (Pflanzen) (fachspr.)
-Königszapfen;Königsbolzen
-Netizen;Netzbürger
-Scheren;Scherschneiden
-Schneidspalt;Scherspalt
-Dalton-Gesetz;Gesetz der Partialdrücke;Daltonsches Gesetz
-U-Bahn-Station;U-Bahnhof
-ungeduldig;fordernd
-(sich) ins Knie ficken (vulg.);(jemanden) (mal) kreuzweise (können);(jemanden) (doch) kreuzweise (sollen);(jemandem) (mal) gestohlen bleiben (sollen);(jemanden) gerne haben (können);scheißen auf (derb);(jemanden) mal können (ugs.);(jemandem) gestohlen bleiben (können);(jemandem) den Buckel (he)runterrutschen (können / sollen)
-weggehen (Aufforderung);in Ruhe lassen (mit) (Aufforderung);nicht (wieder) kommen (mit) (Aufforderung);zufrieden lassen (mit) (Aufforderung)
-hier ist (...);jetzt kommt (...);Manege frei (für);freuen Sie sich auf (...);Bühne frei für (...) (auch figurativ)
-aus gegebenem Anlass;anlassbezogen;im Einzelfall;außerordentlich
-ungewöhnlich ruhig;(die) Ruhe vor dem Sturm (fig.);(es herrscht) verdächtige Ruhe;verdächtig still;verdächtig ruhig
-starten;in Gang setzen;einschalten;anstellen;anmachen (ugs.);anlassen (Motor);anschmeißen (ugs.);(den) Startknopf drücken;in Betrieb setzen;anwerfen
-Kilimandscharo;Kilimandscharo-Massiv;Wilhelmskuppe (veraltet);Kaiser-Wilhelm-Spitze (veraltet);Kilimanjaro
-Bergstock;Bergmassiv
-(einen) Reset machen;(einen) Reset vornehmen;(einen) Reset durchführen;resetten;in den Ursprungszustand zurück(ver)setzen;(wieder) zurück auf null setzen;urlöschen (fachspr.);(einen) Reset ausführen;in den Werkszustand zurück(ver)setzen;neu starten;auf den Auslieferungszustand zurück(ver)setzen
-nullen (ugs.);(einen) runden Geburtstag haben
-vorherzusehen sein;nicht anders sein können (es);abzusehen sein;wie konnte es anders sein;(einfach / ja) so kommen müssen (ugs.);kommen wie es kommen muss
-Böhmische Krone;Länder der Böhmischen Krone;Krone Böhmen;Böhmische Kronländer
-Karlismus;Carlismus
-Schattenwirtschaft;Schwarzarbeit (ugs., Hauptform);Untergrundwirtschaft;Schwarzwirtschaft
-neben anderen die (Superlativ);mit der (Superlativ);einer der (Superlativ);eine der (Superlativ);das (Superlativ) mit (ugs.);mit das (Superlativ);die (Superlativ) mit (ugs.);mit die (Superlativ);der (Superlativ) mit (ugs.);ein(e)s der (Superlativ);neben anderen der (Superlativ);neben anderen das (Superlativ)
-Sackgasse (fig.);nicht weiterführen;totes Gleis (fig.)
-Frist bis ...;Zeitkorridor;verfügbarer Zeitrahmen;Zeitfenster (Hauptform)
-Zierkordel;Kordel;Zierschnur
-Spagat (bayr., österr.);Bindfaden;Verpackungskordel;Verpackungsschnur;Paketschnur;Kordel (regional);Schnur
-Fädchen;Bändchen;Bändel (süddt.)
-freie Indexierung;freie Verschlagwortung
-Politechnikum Mailand;Polytechnische Universität Mailand;Polytechnikum Mailand
-(sich) gefallen in;kokettieren mit;(sich) gefallen (in seiner Rolle) als (...)
-(sich) am Riemen reißen (ugs.);(sich) zusammennehmen (und);(sich) zwingen;(sich) zusammenreißen (und)
-schöpfen (Flüssigkeit);lenzen (marit.)
-Strang;Strick;Henkerstrick
-Spring (marit.);Festmacherleine;Leine;Festmacher (marit.);Trosse
-Strippe (ugs.);Telefonschnur;Telefonkabel
-(telefonisch) erreichen;an die Strippe bekommen (ugs.);(jemanden) erwischen (ugs.)
-Ader;Litzenleitung;Litze;Seele
-Oberster Islamischer Gerichtsrat;Union islamischer Gerichte
-Frühsozialismus;utopischer Sozialismus
-Nadel und Faden;Nähzeug
-Internetbuchungsmaschine;Onlinebuchungsmaschine
-Ökumene;Dauersiedlungsraum
-(sich) ergehen in (einer Vorstellung) (geh.);liebäugeln mit;kokettieren mit (einer Vorstellung);mit dem Gedanken spielen;(sich) in der Vorstellung gefallen (dass);(sich) schmeicheln (geh.)
-Hierarchie;Machtverhältnis
-Gewinnschein;Teilnahmekarte;Teilnahmeschein;Gewinnkarte
-Hierarchie;(Zustand von) Über- und Unterordnung
-Weisungsrecht;(das) Recht, Weisungen zu erteilen;Weisungsbefugnis (Hauptform);Direktionsrecht (fachspr.)
-Bordüre;Borte
-Besatz;Applikation;Posament
-Luftschlange;Papierschlange;Papierband
-vielsagend;beredt (fig.);bedeutungsvoll
-alles sagen (ugs.);(eine) beredte Sprache sprechen;deutlich werden (lassen);(ein) beredtes Zeugnis ablegen (über) (geh.);aufschlussreich sein;tief blicken lassen (fig.);einiges verraten (ugs.)
-Wiederholung (Hauptform);Neuauflage (fig.)
-bei erneutem Auftreten;sollte es erneut zu (...) kommen;bei einem Rückfall;im Wiederholungsfall
-verwachsen;kröpelig (plattdeutsch);missgestaltet;verkrüppelt
-Mutter-Kind-Parkplatz;Mutter-und-Kind-Parkplatz;Eltern-Kind-Parkplatz;MuKi-Parkplatz;Storchenparkplatz
-Damenparkplatz (österr.);Frauenparkplatz
-Parkfläche;Parkplatz
-Aufstelltiefe;Parkstandstiefe
-Schwenktür;Anschlagtür
-Türscharnier;Türband;Türangel;Türhaspe (veraltet)
-Fischband;Einstemmband;Fitschband;Fitschenband
-Aufschraubband;Anschraubband
-anschrauben;einschrauben;hineinschrauben
-Anschlagsrichtung;Aufschlagsrichtung;Aufschlagrichtung;Öffnungsrichtung;Anschlagrichtung
-(ein) Heidengeld (kosten);(ein) Vermögen;(eine) Unsumme;(sehr) viel Geld;Unsummen;in die Millionen gehen (variabel)
-(einer Sache) keinen Abbruch tun;(einer Sache) nicht schaden (können)
-zuverlässig sein;tun was man (von ihm) erwartet;seinen Zweck erfüllen;gute Dienste leisten
-Eingangrad;Fixie (ugs.);Fahrrad ohne Gangschaltung
-(nur) fürs Protokoll;um es gesagt zu haben;der Vollständigkeit halber
-(es) in sich haben;nicht auf den ersten Blick zu sehen (sein);(da) steckt mehr dahinter (als gedacht);manche Überraschung bieten
-Vorratsschädling;Lebensmittelschädling
-(jemanden) von der Leine lassen (fig.);auf die Menschheit loslassen (nach bestandener Prüfung);in die freie Wildbahn entlassen (fig.)
-in die Arbeitswelt entlassen;in seinen weiteren Berufsweg entlassen
-in den Straßenverkehr entlassen;in den Verkehr entlassen;alleine (Auto) fahren lassen
-quittieren;(den) Empfang bestätigen
-(etwas) quittieren (mit);reagieren (auf etwas)
-(die) Stirn(e) krausziehen;(die) Stirn(e) in Falten legen;(die) Stirn(e) in Falten ziehen
-umquartieren;(einen) Wohnungswechsel veranlassen;in ein anderes Zimmer verlegen (Hotel);(eine) andere Wohnung geben;(ein) anderes Zimmer geben (Hotel);umsetzen
-Grafikkartentreiber;Grafiktreiber
-Diskokugel;Spiegelkugel;Discokugel
-Coroutine;Koroutine
-Alles hat seine Zeit. (Zitat);eins nach dem andern;jedes Ding zu seiner Zeit;alles zu seiner Zeit;Jedes Ding hat seine Zeit. (Zitat)
-(jemandem) gut gehen (es);sich wohl befinden (geh.)
-Subtyp;Untertyp
-Laststrom;Hauptstrom
-vorlagengerecht;detailgetreu;detailtreu;bis in die (letzten) Einzelheiten (hinein) der Vorlage entsprechend
-Riemen;Gurt;Tragband;Tragriemen
-als Theaterschauspieler(in) arbeiten;Theater machen;beim Theater sein;Theater spielen;auf der Bühne stehen
-gefährlich nahe (an);ohne Sicherheitsabstand;bedenklich nahe (an / bei);in gefährlicher Nähe (zu)
-Business-to-Customer;Endkundengeschäft;Business-to-Consumer;B2C
-Einkaufszettel;Einkaufsliste
-Der Zweck heiligt die Mittel. (Sprichwort);Not kennt kein Gebot. (Sprichwort)
-das wär's doch! (ugs.);(das) könnte ich mir gut vorstellen;(das) wär' (doch) mal 'ne Maßnahme! (ugs., Spruch);warum eigentlich nicht (...)?;das wär's echt (ugs.);(das) wär' doch mal was (anderes)! (ugs.)
-nicht aus der Welt zu schaffen sein;(sich) hartnäckig halten (Gerücht)
-Münchner Abkommen;Münchener Frieden (selten)
-Tschechoslowakische Republik;CSSR (Abkürzung);Tschechoslowakei
-Gesteinsmehl;Füller;Steinmehl;Feinanteil;Mehlkorn
-Quetschsand;Brechsand
-Springmine;Schrapnellmine;S-Mine;Splittermine
-nicht anrühren;nicht anpacken (ugs.);nicht gehen an (ugs.);(die) Finger lassen (von);nicht anfassen
-(die) Pfoten wegnehmen (derb);(die) Finger wegnehmen;(die) Hände wegnehmen
-(die) Finger lassen (von);(sich) hüten;vermeiden;den Teufel tun;(jemandem) im Traum nicht einfallen
-es ist das Jahr;es war im Jahr(e) (..., als);man schreibt das Jahr;wir sind im Jahr(e);die Welt schreibt das Jahr;wir schreiben das Jahr;wir befinden uns im Jahr(e)
-Reichstagsgebäude;Reichstag (ugs.);Plenarbereich Reichstagsgebäude (fachspr.)
-schamlos;ohne Hemmungen;ungeniert;ohne Bedenken
-in großem Umfang;großzügig;in großem Rahmen;massiv;in großem Stil;in großem Maßstab
-Normannische Theorie;Skandinavische Theorie;Normannismus
-Alma-Ata-Erklärung;Alma-Ata-Deklaration
-aussehen;(irgendwie) daherkommen;rüberkommen (ugs.);(den) Anschein erwecken (dass);erscheinen;(den) Eindruck vermitteln (dass);(sich) ausnehmen;ausschauen (ugs., süddt.);wirken;anmuten (geh.)
-Vereinstaler;Vereinsthaler
-Valuationstabelle;Valvationstabelle
-Guardein;Wardein
-Konventionstaler;Conventionstaler
-nicht kleckern, sondern klotzen;(etwas) (ganz) groß aufziehen
-(sich) verstolpern (fig.);zufällig geraten in;zufällig stoßen auf
-Künstlername (Hauptform);Bühnenname
-(...) kommt nicht aus der Kritik;Pleiten, Pech und Pannen (bei ...) (fig., mediensprachlich);(die) Pannenserie (bei ...) nimmt kein Ende
-Tarnname;Kryptonym;Kodename;Deckname (Hauptform);Codename
-von Arbeitslosengeld leben;stempeln gehen (veraltet)
-Finis (geh., lat.);Schlussvermerk
-Bewegung betreffend;motorisch
-dissonant;nicht stimmig;nicht zusammenpassend;unharmonisch
-unbelehrbar;verbohrt;unbekehrbar;vernagelt;verbissen;bis zum Starrsinn (ugs., übertreibend)
-Motorisierte Infanterie;Motorisierte Schützen;Grenadiere (mot.)
-Oberst;Obrist (veraltet)
-Obristlieutenant (veraltet);Oberstleutnant
-Korps;Verbindung;Burschenschaft
-Verwirrer;Wortverdreher;Haarspalter;Rabulist (ugs.);Splitterrichter;Kasuist;Sophist;Täuscher;Deutler;Silbenstecher;Wortklauber
-Ganzheit;Geschlossenheit;Unteilbares;Unität;Einzigkeit;Einheit;Monade (geh., griechisch)
-Schmuddelecke;Schanddfleck
-negatives Bild;Negativimage;Negativschlagzeilen
-in ein schiefes Licht geraten;(ein) schiefes Licht werfen auf;fragwürdig erscheinen lassen;kein gutes Licht werfen auf;(jemanden) nicht gut dastehen lassen;kein gutes Bild abgeben;(ein) schlechtes Licht werfen auf;in ein schlechtes Licht rücken;nicht gut aussehen lassen
-(die) Herren der Schöpfung (Plural);(jemandes) Mannen (nur Plur., veraltet oder scherzhaft-heroisierend) (geh., Plural);Kerls (ugs., Plural);Jungs (ugs., Plural, salopp);Männers (nur Plur., als 'kernige' Anrede) (ugs., Plural);Männer (Plural, Hauptform)
-ehrfürchtig erschaudern;von Ehrfurcht ergriffen werden;(jemandem) läuft ein ehrfürchtiger Schau(d)er über den Rücken;vor Ehrfurcht erstarren
-entgelten;vergelten;abgelten;besolden;entlohnen;(Lohn) ausbezahlen;vergüten;löhnen;entlöhnen (schweiz.);entschädigen;bezahlen;(Lohn) auszahlen
-Zweiter Markgrafenkrieg;Markgräflerkrieg;Bundesständischer Krieg
-Seeschlacht im Gelben Meer;Seeschlacht am Yalu
-Gapsin-Revolution;Gapsin-Putsch
-Vertrag mit Schutzwirkung zugunsten Dritter;Vertrag mit Schutzwirkung für Dritte
-Flügelung;Zugteilung;Flügeln
-(noch) knapp passen;(gerade) noch ausreichen;so gerade reichen (ugs.);(sich) ausgehen (ugs., österr.)
-(sich) bestätigt fühlen;(sich) bestätigt sehen;(wieder) Oberwasser bekommen
-Sensationsgier;Sensationshascherei;Sensationslust;Sensationshunger
-Sensationsmacherei (betreiben);(jeden Tag) eine neue Sau durchs Dorf treiben;(täglich) wird (wieder) eine andere Sau durchs Dorf getrieben
-4-gliedrige Division;Karree-Division
-Hochkreuz;Keltenkreuz;Irisches Kreuz
-Triskel;Triskele
-damit kann ich (auch) nichts anfangen;dafür kann ich mir nichts kaufen;das bringt mich (auch) nicht weiter;davon hab ich nichts;(das) macht mich (jetzt auch) nicht schlauer
-Cimbalom;Cymbalom;Zymbal;Zimbal
-Klangstäbe;Klanghölzer;Claves
-Tomtom;Schlitztrommel;Holztrommel (veraltet)
-Buschtrommel (veraltet);Sprechtrommel;Nachrichtentrommel
-Englischhorn (Hauptform);Englisch-Horn;Alt-Hoboe (veraltet);Altoboe (veraltet)
-Instrumentenkunde;Musikinstrumentenkunde;Organologie
-Freizeitausgleich nehmen;Freizeitausgleich bekommen;abfeiern (Überstunden)
-Ruhe und Frieden;entspannte Situation;Ruhe
-Heulen und Zähneklappern (fig., übertreibend);Wehgeschrei;großes Geschrei;Gezeter
-reiche Hamburger (Kaufleute);Pfeffersäcke (ugs.)
-(jemandem) ist die Anstrengung anzusehen;(jemandem) steht der Schweiß auf der Stirn
-(jemandem) den Tag retten;(jemandem) den Tag vergolden (fig.);(jemanden) sehr freuen;(jemandem) eine (große) Freude machen
-wehe, wenn (...) (ugs.);ja (mit langgezogenem 'a') (ugs.);bloß (ugs.)
-Fimmel;Rappel;Anfall
-stillen (Blutung);zum Stillstand bringen
-leer trinken;austrinken;leertrinken
-(jemanden) daten (engl.);(sich) verabreden (mit);(sich) treffen (mit);(mit jemandem) ausgehen
-vertraut(er) miteinander werden;(sich) näher kommen;(sich) besser kennenlernen
-brieflich verkehren mit;in brieflichem Kontakt stehen (mit);(sich) schreiben;korrespondieren
-Zeit investieren (in);(sich) (einer Sache) widmen;(sich) befassen mit;(sich) auseinandersetzen (mit);befasst sein (mit) (geh.);Zeit opfern (für);(jemandem / einer Sache) Zeit widmen;(sich) beschäftigen (mit)
-bundesunmittelbares Gebiet;Bundesdistrikt;Bundesterritorium
-Zentenar;(der) Hundertjährige
-ängstlich besorgt;Umstände machen(d);mütterlich besorgt;(über)fürsorglich;tantenhaft;betulich (Hauptform);(über)bemüht
-Warterunden;Warteschleife
-Omega-Navigationsverfahren;Omega-Verfahren
-Trilateration;Lateration
-Netz;Vermessungsnetz
-skandinavisch-russischer Meridianbogen;Struve-Bogen
-Militärgeografie;Militärgeographie
-Kriegswissenschaft (veraltet);Militärwissenschaft;Wehrwissenschaft
-Lamberts winkeltreue Kegelprojektion;Lambert-Gaußsche winkeltreue Kegelprojektion
-Rauhe Berge;Steglitzer Fichten (veraltet);Steglitzer Fichtenberg (veraltet)
-Eilmarsch;Gewaltmarsch (veraltet)
-Internationale Längenbestimmung;Weltlängenbestimmung
-Texanische Revolution;Texanischer Unabhängigkeitskrieg
-Hydroponik;Hydrokultur
-Regizid;Königsmord
-Attachment (engl.);Dateianhang (an einer E-Mail)
-Ineffizienz;Wirkungsverlust;Reibungsverlust
-Hexadezimalsystem;hexadekadisches System;Sedezimalsystem
-einschlagen (Holz);ernten (Forstwirtschaft)
-mitsamt (der) Wurzel entfernen;mit der Wurzel entfernen;roden (Gehölze) (fachspr.)
-abholzen (Fläche);freischlagen;freiholzen;kahlschlagen
-Arktis und Antarktis;Polargebiete;ewiges Eis
-Systemressourcen;Betriebsmittel;Ressourcen
-Reingewicht (kaufm.);Nettogewicht
-verkauft bekommen;loswerden;abverkaufen
-Schauspielerin (Hauptform);Aktrice
-Gonade (fachspr., griechisch);Geschlechtsdrüse;Keimdrüse
-(etwas) taugen;vernünftig (sein);gescheit (sein) (ugs.)
-Grußformel;Schlussformel
-Mit bester Empfehlung;Mit verbindlichen Grüßen;Mit besten Empfehlungen
-Verkündigung des Herrn;Mariä Verkündigung
-saisonal-affektive Störung;Winterdepression
-Marktsegment;Teilmarkt (fachspr.)
-auf den aktuellen Stand bringen;modernisieren;(ein) Upgrade vornehmen;à jour bringen (geh., bildungssprachlich);auf den neuesten Stand bringen;ajourieren (geh., bildungssprachlich);auf neue Füße stellen (fig.);upgraden (IT-Technik, engl.);(ein) Update durchführen;updaten (IT-Technik, engl.);aktualisieren;(an geänderte Bedingungen) anpassen
-auf dem neuesten Stand halten;auf dem aktuellen Stand halten;(fortlaufend) aktualisieren
-akustische Agnosie;auditive Agnosie;Seelentaubheit
-visuelle Agnosie;Seelenblindheit;optische Agnosie
-sensorische Aphasie (veraltet);Wernicke-Aphasie
-Broca'sche Sprachregion;Broca-Zentrum;Broca-Areal
-Cortex cerebri (fachspr., lat.);Großhirnrinde;Cortex (fachspr., Kurzform, lat.)
-Hirnmantel;Cortex (fachspr., lat.);Hirnrinde;Pallium (lat.);Kortex (fachspr., eingedeutscht, lat.)
-Wernicke-Zentrum;Wernicke-Region;Wernicke-Areal
-auditiver Kortex;auditorischer Cortex;auditiver Cortex;Hörzentrum;auditorischer Kortex;Hörrinde
-(wahrer) Urheber (sein);(seine) Finger im Spiel haben;(etwas) veranlasst haben;hinter etwas stecken
-Kaltleiter;PTC-Thermistor;PTC-Widerstand
-Heißleiter;NTC-Thermistor;NTC-Widerstand
-PPTC-Sicherung;rückstellende Sicherung;selbstrückstellende Sicherung;PTC-Sicherung
-(der / die / das ...) schlechthin;(der) Klassiker;(die) Mutter aller (...) (fig.)
-Radionuklid;radioaktives Nuklid
-Nukleid;Atomsorte;Nuklid
-Zerfallsrate;Aktivität
-Aktivimeter;Curiemeter (veraltet)
-radioaktive Strahlung (ugs.);ionisierende Strahlung
-Terminationscodon (fachspr.);Stopcodon (fachspr.);Nonsense-Codon
-Codon;Basentriplett;Triplett
-Startcodon;Initiatorcodon
-Nucleinbasen;Nukleobasen;Nucleobasen;Nukleinbasen
-Nucleotid;Nukleotid
-Relaxometrie;Neuromuskuläres Monitoring
-Alkoholembryopathie;fetales Alkoholsyndrom
-Großseldschuke;Seldschuke;Seldschuk-Türke;seldschukischer Türke;Seldschuqe
-Othonische Inseln;Diapontische Inseln
-einwenden;widersprechen;kontern (mit);mit dem Gegenargument kommen (dass);(jemandem etwas) entgegenhalten;den Einwand erheben (dass);einwerfen;erwidern;entgegnen;objizieren (geh., veraltet)
-zur Antwort geben;erwidern;zurückgeben (geh.);(ich / er / sie ...) so (ugs.);antworten
-(viel) zu gut für jemanden sein;nicht zu schätzen wissen;(gar) nicht zu würdigen wissen;(etwas) nicht verdient haben
-scharf (Ton);schneidend;durchdringend
-zu (...) verkommen;aufgelassen;in einem desolaten Zustand;dem Verfall preisgegeben;verwahrlost (Haus, Anwesen);nicht unterhalten (worden);verwildert
-Karzinogen (fachspr.);Kanzerogen (fachspr.);Krebserzeuger;Canzerogen (fachspr.);Carcinogen (fachspr.);Krebserreger
-Hauptschluss der außerordentlichen Reichsdeputation;Reichsdeputationshauptschluss
-(darauf) kann man (nach Rom) reiten;stumpf (Hauptform);ungeschliffen;(durch Gebrauch) abgestumpft
-machistisch (geh.);machohaft;machomäßig (ugs.);chauvinistisch;chauvimäßig (ugs.);sexistisch
-Republik Formosa;Demokratische Republik Taiwan
-Überseechinese;Auslandschinese
-Wenzelskrone;Krone des hl. Wenzel;St. Wenzelskrone
-Legistik;Rechtsförmlichkeit
-IT-Recht;Informationstechnologierecht
-Sicherheitswerkbank;Sterilkammer;Sterilbank;Reinraumwerkbank
-Reihenfertigung;Fließfertigung
-Fertigung nach dem Platzprinzip;Baustellenfertigung
-statischer Mischer;Statikmischer
-Homogenisierungsglühen;Diffusionsglühen;Ausgleichsglühen
-Homogenisieren;Lösungsglühen
-Zellaufschluss;Homogenisierung
-Diffusionskoeffizient;Diffusionskonstante
-Wärmediffusivität;Temperaturleitzahl;Temperaturleitfähigkeit
-Elektronenblitzgerät;Elektronenblitz;Röhrenblitzgerät
-üblich werden;(schwer) im Kommen (sein);in Mode kommen;aufkommen;populär werden;an Popularität gewinnen
-(der) letzte Schrei (fig., veraltend);hochmodern;am Puls der Zeit;der letzte Heuler (ugs., ironisch, veraltend);(der) Dernier Cri (geh., franz.);(die) neueste Mode;brandheiß (ugs.);topaktuell;brandaktuell;(das) Allerneueste;total angesagt;hochaktuell;(der) heiße Scheiß (derb, Jargon);(das) Neueste vom Neuesten
-wie sollte es (auch) anders sein!?;wie sollte es (auch) anders gehen?;wie denn auch (nicht)?
-aufs Kreuz legen (ugs., fig.);übers Ohr hauen (ugs.);über den Löffel balbieren;über den Tisch ziehen (ugs., fig.);hinters Licht führen;hereinlegen;linken (ugs.);über den Löffel barbieren;begaunern;bescheißen (derb);lackmeiern (ugs.);anschmieren (Abschwächung) (ugs.);betrügen (Hauptform);leimen (ugs.)
-anschmieren (ugs.);betuppen (ugs., ruhrdt.);beschummeln (ugs.);beschupsen (ugs.);übertölpeln;behum(p)sen (ugs., regional)
-(für jemanden) Programm machen;(jemanden) bespaßen (ugs.);(sich) kümmern (um) (ugs.)
-(das) war mir (noch) gar nicht aufgefallen!;darauf wäre ich (gar) nicht gekommen!;jetzt wo du es sagst ... (Spruch, ironisch);wenn ich's mir recht überlege ...
-Verwirrspiel;Vexierspiel
-Verdrehung der Tatsachen;Desinformation;Falschinformation;Fehlinformation
-Falschaussage;Schutzbehauptung;Lüge (Hauptform);Unwahrheit
-Meineid;falsch(es) Zeugnis (geh., biblisch, veraltet);Falschaussage;falscher Eid
-Herumlügerei;(das) Herumlügen;Rumlügerei (ugs.);Lügerei
-Lügengeflecht;Netz der Lügen (variabel);Lügengebäude;Lügengespinst;Lügengestrüpp;Lügengebilde
-Drescherhai;Fuchshai
-Grundhai;Menschenhai;Grauhai;Requiemhai
-Kammzähnerhai;Grauhai
-Weißspitzen-Hochseehai;Hochsee-Weißflossenhai
-Drehkreuz;Radmutternschlüssel;Kreuzschlüssel;Radkreuz
-Internat;Schülerheim;Internatsschule
-Weiterbildungseinrichtung;Weiterbildungsinstitut
-so war es;hat sich (genau) so zugetragen;hat sich wirklich so abgespielt
-behaupten;als sicher ausgeben;als wahr hinstellen;postulieren (geh., bildungssprachlich)
-(lediglich) vermutet;ohne gesicherte Datenbasis;(reine) Spekulation;(es gibt) keine Anhaltspunkte (für);nicht belegbar;ins Blaue hinein (behaupten) (ugs., Redensart);(nur) eine Vermutung;nicht beweisbar;durch die Tatsachen nicht gedeckt (sein)
-tatsächlich passiert (Hauptform);historisch verbürgt;(eine) historische Tatsache
-Ukrainischer Barock;Kosaken-Barock
-Naryschkin-Barock;Moskauer Barock
-(sich) durch Gesten verständlich machen;mit Händen und Füßen sprechen;(sich) mit Zeichensprache verständigen (Hauptform);gestikulieren;mit den Händen reden
-in ein (Internet-)Forum schreiben;posten (engl.)
-Preisfestlegung;Preisfestsetzung;Preisgestaltung
-Herbstkrise;Novemberkrise
-Kurfürstentum Hessen;Kurhessen
-Deutsche Union;Erfurter Union
-Dresdner Konferenzen;Ministerialkonferenz;Dresdener Konferenz
-Schwarzenberg-Plan;Siebzig-Millionen-Reich;Großösterreich;Schwarzenberg-Bruck-Plan
-Vereinigte Staaten von Großösterreich;Vereinigte Staaten von Groß-Österreich
-Vereinigtes Europa;Bundesrepublik Europa;Vereinigte Staaten von Europa
-Vereinigte Staaten von Belgien;Vereinigte Belgische Staaten;Vereinigte Niederländische Staaten
-Republik der Ionischen Inseln;Vereinigte Staaten der Ionischen Inseln
-Ukrainische Schützenabteilung;Ukrainische Freischützen;Ukrainische Legion;Freiwillige Ukrainische Schützen;Ukrainisches Freiwilligenkorps
-kaiserlich-königliche Landwehr;k.k. Landwehr
-Dominante;Oberdominante
-dramatisches Geschehen;...drama;dramatische Ereignisse
-Freizügigkeit (Deutschl.);Niederlassungsfreiheit (Schweiz)
-(fundamental) wichtige Errungenschaft;hohes Gut;hoher Wert
-Anzugsordnung;Adjustierung (österr.)
-Reichswehrministerium;Reichskriegsministerium
-Wirtschaftsministerium;Handelsministerium
-Weltbühne-Prozess;Weltbühnenprozess
-morganatische Ehe;Trauung zur linken Hand
-Baldachin;Thronhimmel;Himmel
-Wappenknecht (veraltet);Schildhalter
-Lichterscheinung;Leuchterscheinung
-Holzstab;Holzstock
-Schlandkette (ugs.);Deutschlandkette
-anlasslos;verdachtsunabhängig
-Wasserkraft;Hydroenergie
-Wasserkraftwerk;Wasserkraftanlage
-Umformerwerk;Bahnstromumformerwerk
-Inselanlage;autarkes System;netzunabhängiges System
-Altkunde;Bestandskunde
-erfüllen;halten, was man verspricht (fig.);(einer Sache) gerecht werden;(erfolgreich) bewältigen (Aufgabe);(einer Sache) gewachsen sein
-es nicht so dicke haben (ugs.);(nur) wenig Geld (zur Verfügung) haben;sein Geld zusammenhalten (müssen);(sich) nichts erlauben können;aufs Geld gucken müssen (ugs.);nichts zu verschenken haben (ugs.);haushalten müssen;nicht drinsitzen (ugs.);jeden Cent zwei mal umdrehen (müssen) (ugs.);keine großen Sprünge machen können (fig.);(sich) nach der Decke strecken (müssen) (fig.);(sehr) aufs Geld achten müssen;(sich) (etwas) nicht leisten können;(sich) nichts leisten können
-in Serie;einer nach dem anderen;(...) für (...);reihenweise;der Reihe nach;hintereinander;hintereinanderweg;nacheinander;in ganzen Serien
-Linienorganisation;Leitungssystem;Liniensystem
-organisatorische Einheit;Organisationseinheit
-Arbeitsplatzbeschreibung;Stellenbeschreibung
-Handelsgehilfe (fachspr., Jargon);Handlungsgehilfe (jur., sonst veraltet) (fachspr.);Commis (veraltet);kaufmännischer Angestellter (Hauptform);Kommis (veraltet);Kontorist (veraltet)
-Opelaner;Opel-Mitarbeiter
-BMWler (ugs.);BMW-Mitarbeiter
-M-Zweig;M-Klasse;M-Zug;Mittlere-Reife-Zug
-männliche Geschlechtsteile;(das) Gehänge (vulg., ironisch);(männliche) Geschlechtsorgane;Penis und Hodensack;edle Teile (ironisch);(männliche) Sexualorgane;Gemächt(e) (veraltet);(männliche) Genitalien;Weichteile
-erfolgreich sein;(einen) Treffer landen;(einen) Sieg einfahren;zu Streich kommen (mit);zurechtkommen (mit);klarkommen mit;funktionieren;Punkte holen;Erfolg haben (mit);weiterkommen (mit) (ugs.)
-Wie bist du nur auf die Idee gekommen!? (ugs., variabel);Was hat dich da geritten (als / dass ...) (ugs., fig.);Was hast du dir (nur) dabei gedacht? (ugs.)
-nicht nervös werden!;kein Grund zur Panik!;nur die Ruhe!;alles gut!
-Angst kriegen (ugs.);(sich) nass machen (ugs.);(sich) ins Hemd machen (ugs.);Schiss kriegen (ugs.)
-das kannst du mir glauben! (Hauptform);verlass dich darauf (ugs.);das glaub aber mal! (ugs., ruhrdt.);verlass dich drauf (ugs.);da kannst du aber drauf an! (ugs., ruhrdt.);darauf kannst du deinen Arsch verwetten (ugs., Spruch, salopp);das glaubst du doch wohl! (ugs.);darauf kannst du wetten! (Hauptform);da kannst du einen drauf lassen! (derb);darauf kannst du Gift nehmen (ugs.)
-nicht wissen, was gespielt wird;keine Information(en) haben;hängen gelassen werden (ugs.);nicht wissen, was los ist;auf dem Trockenen sitzen
-(sich) nicht verantwortlich machen lassen (für);höhere Gewalt (sein);(sich) nicht zur Rechenschaft ziehen lassen (für);nicht verantwortlich sein (für);(etwas) nicht zu vertreten haben
-da durchmüssen;(etwas) durchstehen müssen
-Rechtsaugen-Flunder;Scholle
-Bundessicherheitswachekorps;Sicherheitswache
-Muskelatrophie;Muskelschwund;Amyotrophie
-Charcot-Marie-Tooth-Hoffmann-Syndrom;Neurale Muskelatrophie;Morbus Charcot-Marie-Tooth
-Refsum-Syndrom;Refsum-Thiébaut-Krankheit;Refsum-Kahlke-Krankheit
-Myatrophe Lateralsklerose;Charcot-Krankheit;Amyotrophe Lateralsklerose (fachspr., Hauptform);Amyotrophische Lateralsklerose (fachspr.);Lou-Gehrig-Syndrom;ALS (fachspr., Abkürzung)
-chronisches Nierenversagen;chronische Nierenkrankheit;chronische Niereninsuffizienz
-akutes Nierenversagen;akute Niereninsuffizienz
-Nierenversagen;Niereninsuffizienz
-Nichtopioid-Analgetikum;nichtopioides Analgetikum
-Phenacetin-Niere;Analgetikanephropathie
-Kimmelstiel-Wilson-Syndrom;interkapilläre Glomerulonephritis;noduläre Glomerulosklerose;diabetische Nephropathie;diabetische Glomerulosklerose
-Nephrosklerose;hypertensive Nephropathie
-Harnstauung;Harnstau;obstruktive Uropathie
-Hydronephrose;Wassersackniere (ugs.)
-Harnröhrenklappe;Urethralklappe
-benigne Prostatahyperplasie;Prostataadenom (veraltet)
-Nephrotoxin;Nierengift
-Immunkomplex;Antigen-Antikörper-Komplex
-Anabolikum;Askinanabolikum
-Atrioventrikularknoten;AV-Knoten;Aschoff-Tawara-Knoten
-Keith-Flack-Knoten;Sinusknoten;Sinuatrial-Knoten
-Sick-Sinus-Syndrom;Sinusknotenerkrankung;Sinusknotensyndrom
-(das Leben ist) kein Kindergeburtstag (fig.);(das Leben ist) kein Ponyhof (fig.);kein Wunschkonzert (fig.);(das ist hier) kein 'Wünsch dir was' (fig.);(wir sind hier) nicht bei 'Wünsch dir was' (fig.);Das Leben ist hart. (ugs., Gemeinplatz, auch ironisch)
-zusammenstückeln (abwertend);aneinanderfügen;nebeneinanderstellen;kompilieren (fachspr., IT-Technik);collagieren (fachspr., Kunst);zusammenstellen;zusammenfügen;zusammentragen
-atrioventrikulärer Block;AV-Block
-SA-Block;sinuatrialer Block
-Luftgas;Aerogengas;Benoidgas;Aërogengas
-Lackbenzin;Siedegrenzbenzin;Reinigungsbenzin;Sangajol;Testbenzin (Hauptform);Waschbenzin (Hauptform);Terpentinölersatz;Spezialbenzin;Terpentinersatz;Kristallöl;Fleckbenzin
-kraftlos (fig.);unlebendig;blutleer (fig.);papieren (fig.)
-Oldie;Evergreen
-Idealbesetzung;Dreamteam;Spitzenmannschaft
-Keimbildung;Nukleation (fachspr., griechisch)
-Bänderton;Warventon
-Jahresschicht;Warve
-Bändertondatierung;Bändertonkalender;Warvenchronologie
-Genexpression;Exprimierung;Expression
-Embryonalhülle;sekundäre Eihülle;Eihaut
-Embryogenese;Embryonalentwicklung
-Amniontier;Nabeltier;Amniot (fachspr., griechisch)
-Endometrium;Gebärmutterschleimhaut
-Brunstzyklus;Sexualzyklus
-Korpuskarzinom;Endometriumkarzinom;Uteruskarzinom
-amniotische Schnürfurchen;Schnürringe;Amniotisches-Band-Syndrom
-Polyhydramnion;Polyhydramnie;Hydramnion
-Majewski-Syndrom;Kurzrippen-Polydaktylie-Syndrom Typ Majewski
-Osteochondrodysplasie;Skelettdysplasie
-Fallot'sche Tetralogie;Fallot-Tetralogie
-Herzfehlbildung;Herzfehler;Herzvitium
-Zwillings-Syndrom;Fetofetales Transfusionssyndrom
-Chondrodystrophia fetalis (fachspr.);Chondrodysplasie;Knorpelwachstumsstörung;Achondroplasie
-Schildpattmuster;Tortie (fachspr.)
-Lyonisierung (veraltet);X-Inaktivierung;X-Chromosom-Inaktivierung
-Dilute-Gen;Verdünnungsgen
-Teschler-Nicola-Syndrom;Tetrasomie 12p Mosaik;Pallister-Killian-Syndrom
-monogene Erkrankung;monogenetische Erkrankung
-Zellgenetik;Cytogenetik;Zytogenetik
-Zugkreuzung;Zugskreuzung (schweiz.);Kreuzung
-Fahrdienst;äußerer Betriebsdienst (veraltet)
-Zeit-Weg-Diagramm;grafischer Fahrplan;Bildfahrplan
-im Grunde;im Kern;im Wesentlichen
-ungeschminkte Wahrheit;nackte Wahrheit
-(die) volle Wahrheit;wirklich wahr;so wahr ich lebe;ehrlich wahr (ugs.);(die) ganze Wahrheit;so wahr ich hier stehe (ugs., Redensart);(die) reine Wahrheit
-(der) (letzte) Grund der Dinge;Letztbegründung;(der) tiefste Grund;(der) tiefste Sinn;letzte Wahrheit(en)
-(der) letzte Grund;Urgrund;Urquell (allen Seins);Quell(e) (fig.);Urbeginn;Uranfang
-aufgeschreckt (fig.);(es gibt ein) böses Erwachen;unsanft geweckt (fig.);wach geworden (fig.)
-fest glauben (an);felsenfest überzeugt (von);der festen Überzeugung;durchdrungen sein von dem Glauben (an) (geh.)
-(jemandes) Fußabtreter (fig.);Arsch vom Dienst (derb);Mobbingopfer;Opfer (ugs., jugendsprachlich);mit mir kann man's ja machen (ugs., Spruch);immer auf die Kleinen! (ugs., Spruch, scherzhaft-ironisch);Zielscheibe (fig.);Prügelknabe (ugs., Hauptform);Schlagball (ugs.);(das) geborene Opfer;Watschenmann (ugs.)
-(jemandem) den schwarzen Peter zuschieben;(teils ungerechtfertigterweise) für etwas verantwortlich machen;(jemandem) die Schuld in die Schuhe schieben;(jemandem) die Verantwortung für etwas zuschieben;(jemandem) die Schuld zuschieben;(jemandem) die Verantwortung für etwas aufhalsen;(etwas) auf jemandem abladen;(eine) Verantwortung loswerden (an);(jemandem) die Schuld für etwas zuschanzen
-intangibel;ungreifbar;immateriell;unfassbar
-Uferlosigkeit;Unendlichkeit;(die) unendlichen Weiten (von);Grenzenlosigkeit
-Superman;(der) Stählerne
-Odysseus;(der) Listenreiche
-Konkathedrale;Ko-Kathedrale
-Domkapitel;Kathedralkapitel
-Goldene-Sporen-Schlacht;Schlacht der Goldenen Sporen;Sporenschlacht von Kortrijk;Sporenschlacht;Schlacht von Courtrai
-Pfälzischer Aufstand;Pfälzer Aufstand
-Dresdner Mairevolution;Dresdner Maiaufstand
-Altkatholische Kirche;Christkatholische Kirche (schweiz.)
-Utrechter Union der Altkatholischen Kirchen;Utrechter Union
-Schildkern-Technik;Levalloistechnik
-Koralpenbahn;Koralmbahn
-Korridorverkehr;Privilegierter Durchgangsverkehr;Privilegierter Eisenbahn-Durchgangsverkehr
-Polnischer Korridor;Danziger Korridor (zeitgenössisch);Weichselkorridor (zeitgenössisch)
-Mark Pettau;untere Karantaner Mark;Mark an der Drau;Grafschaft hinter dem Drauwald;Mark hinter dem Drauwald
-Mark an der Mur;Kärntnermark;Hengistgau;Karantanermark;Mark Hengist
-Korotan;Karantanien
-Herbst-Zeitlose (fachspr.);Colchicum autumnale (fachspr., botanisch);Herbstzeitlose
-übertrieben elegant gekleidet;overdressed (engl.);zu chic angezogen;zu sehr herausgeputzt
-in Galakleidung;in vollem Wichs (auch figurativ);in großer Toilette (geh., veraltend);geschmückt wie ein Pfingstochse (ugs.);ausstaffiert wie Graf Koks von der Gasanstalt (ugs.);schwer in Schale (ugs.);in Festkleidung (Hauptform);in vollem Ornat;in voller Kluft;in Festtagsgala;in Galauniform
-(ach) du Arme(r)! (auch ironisch);du Ärmster! (ironisierend);Mir kommen (gleich) die Tränen! (ugs., ironisch);der Gerechte muss viel leiden (bibl., hier iron.);(du) armes Tucktuck! (ugs., regional);(der) Ärmste (emotional) (ugs.)
-objektrelationale Abbildung;OR-Abbildung
-Relationenalgebra;relationale Algebra
-Objektidentifizierung;Duplikaterkennung
-mit starken Bildern;bildkräftig;eindrucksstark;visuell imponierend (geh.);eindrücklich;bildgewaltig;in starken Bildern
-Kolossalfilm;Schinken (ugs.);Monumentalfilm;...schinken (ugs.)
-(etwas) liegt in ferner Zukunft;Zukunftsmusik;Bis dahin wird noch viel Wasser den Rhein herunterfließen. (ugs., sprichwörtlich)
-Epochengemälde;Zeitgemälde
-Heldensage;Heldenepos;Heldendichtung
-Dilatanz;Scherverzähung
-Schergeschwindigkeit;Schergefälle (veraltet);Geschwindigkeitsgefälle (veraltet);Scherrate (veraltet)
-Strömungsgeschwindigkeit;Flussgeschwindigkeit;Fließgeschwindigkeit
-Strukturviskosität;Scherentzähung;Scherverdünnung
-negative Thixotropie;Rheopexie;Antithixotropie
-strukturviskos;scherverdünnend
-('ne) Tass Kaff (ugs., salopp);(eine) Tasse Kaffee (Hauptform);(ein) Käffchen (ugs.);(ein) Haferl Kaffee (bayr., österr.);(ein) Kaffee
-(einer Sache / jemandes) gedenken;erinnern an
-Spanischer Reiter;Friesischer Reiter
-Spanischer Reiter;Spanisches Pferd;Spanischer Bock
-Strafesel;Esel
-Vulkanit;Ergussgestein;Eruptivgestein;Effusivgestein;Extrusivgestein;vulkanisches Gestein
-Sicherheitscode;Kartenprüfnummer
-zu einem anderen Zeitpunkt;irgendwann sonst;an einem anderen Termin;wann anders (ugs.);sonst wann;bei einer anderen Gelegenheit
-Quadratwurzel (von);Wurzel (ugs.);zweite Wurzel (aus)
-gehoben (Hauptform);gesucht;mit ausgesuchten Worten;mit gewogenen Worten;stilvoll;elaboriert (Ausdrucksweise) (fachspr., veraltend);im hohen Ton (geh.);(sich) gewählt (ausdrücken);(seine) Worte wägen;(einen) hohen Ton anschlagen (geh.);(seine) Worte mit Bedacht wählen;bildungssprachlich (fachspr.)
-Dritter Hauptsatz der Thermodynamik;Nernstscher Wärmesatz;Nernstsche Theorem;Nernst-Theorem
-Wohlfahrtstheorem;Hauptsatz der Wohlfahrtsökonomik
-Wohlfahrtsökonomie;Allokationstheorie;Wohlfahrtsökonomik
-Anfangsausstattung (ugs.);(das) Nötigste (an);kleines Besteck (fig.);Basics (Anglizismus, Jargon);Grundausstattung (Hauptform);Starterkit (werbesprachlich)
-Marktgerechtigkeit;Tauschgerechtigkeit
-thermodynamische Temperatur;absolute Temperatur
-gekonnt (Ausdrucksweise);routiniert;geschliffen;gewandt
-langsam gehen;schlappen (ugs.);zotteln;bummeln;gemütlich gehen;trotten;schlendern;trollen
-(in aller Ruhe) hinterhertrollen;hinterhergeschlichen kommen;hinterhergezottelt kommen (ugs.);langsam hinterherkommen;hinterhertrotten;(gemütlich) hinterhergeschlendert kommen
-Pilgerfahrt;Pilgerreise;Wallfahrt
-Vasarianischer Korridor;Vasarikorridor
-vollwertige Mahlzeit;was Richtiges (ugs.)
-Verband Reichskriegsflagge (Eigenname, historisch);Bund Reichskriegsflagge (Eigenname, historisch)
-Bund Reichsflagge;Wehrverband Reichsflagge
-Freikorps Oberland;Kameradschaft Freikorps und Bund Oberland;Bund Oberland
-terroristische Organisation;Terrororganisation;terroristische Vereinigung
-Jihadismus;Dschihadismus
-Glaubenskrieg;Religionskrieg
-Artillerieortungsradar;Artillerieradar;Artillerieaufklärungsradar
-Drehflügler;Rotorflugzeug;Drehflügelflugzeug
-Daesh;IS;Islamischer Staat;Daesch;ISIL;ISIS;Islamischer Staat im Irak und der Levante;Islamischer Staat im Irak und in Syrien
-geregelt (ablaufen);unter Kontrolle bleiben;vernünftig (ablaufen) (ugs.);in geordneten Bahnen (verlaufen);im Rahmen (bleiben);kontrolliert
-programmgemäß;plangemäß;nach Plan;wie vorgehabt;planmäßig;nach Zeitplan;zeitplangemäß;wie vorgesehen;im Zeitplan;wie geplant;dem Plan entsprechend (variabel);nach Programm
-Übereinkommen über das Verbot der Entwicklung, Herstellung, Lagerung und des Einsatzes chemischer Waffen und über die Vernichtung solcher Waffen.;Chemiewaffenübereinkommen;Chemiewaffenkonvention
-Deutschlandvertrag;Bonner Vertrag;Bonner Konvention
-Mittelfellraum;Mediastinum
-Pneumomediastinum;Mediastinalemphysem
-Subokzipitalpunktion;Zisternenpunktion;Suboccipitalpunktion
-Heimlich-Manöver;Heimlich-Handgriff;Oberbauchkompression
-Schlucktod (ugs.);Minutentod (ugs.);Bockwurstbudentod (ugs.);Bolustod
-Erstickung;Suffokation
-Bandstreifen;Tänie
-interne Fragmentierung;Verschnitt
-externe Fragmentierung;Fragmentierung
-Logik höherer Stufe;Stufenlogik
-(jemandem) aus der Hand reißen;(jemandem) entreißen;usurpieren (geh.);(jemanden) abziehen (jugendsprachlich);(jemandem) abnehmen (unter Gewaltanwendung);(etwas) abziehen (jugendsprachlich);(jemandem) wegnehmen (unter Gewaltanwendung);(jemanden) berauben (Hauptform);rauben (juristisch)
-von Diebstählen leben;klauen wie die Raben;gewohnheitsmäßig stehlen;klauen wie ein Rabe;(eine) diebische Elster (sein);Probleme mit dem Eigentumsbegriff haben (verhüllend)
-Vortäuschen eines Versicherungsfalls;Versicherungsbetrug
-Schweigeminute;Gedenkminute
-Totzeit;Laufzeit;Transportzeit
-Nyquist-Graph;Nyquist-Plot;Nyquist-Diagramm
-Vorzeichenfunktion;Signumfunktion
-Signum;Vorzeichen
-Zeichentest;Vorzeichentest
-Alternativhypothese;Gegenhypothese
-Flaggenleine;Flaggleine
-Polytoxikomanie;multipler Substanzmissbrauch
-Namenwappen;redendes Wappen;sprechendes Wappen
-Buchstabenwappen;Initialwappen
-Kadettenanstalt;Kadettenschule
-Maiensäß;Maisäß;Vorsäß;Niederleger;Maien;Hochsäß
-Schweighof;Schwaighof
-Almwirtschaft;Bergweidewirtschaft;Alpwirtschaft;Hochwirtschaft
-Transhumanz;Wanderweidewirtschaft
-Sevennen;Cevennen
-Idiotikon;Schweizerisches Idiotikon;Wörterbuch der schweizerdeutschen Sprache;Schweizerdeutsches Wörterbuch
-Verbreitungsgebiet;Areal (fachspr.)
-(für jemanden) aufräumen;(jemandes) Sachen wegräumen;(jemandem) hinterherräumen
-versuchen, jemanden telefonisch zu erreichen;(jemandem) hinterhertelefonieren;(jemanden) telefonisch zu erreichen versuchen;versuchen, jemanden an die Strippe zu bekommen (ugs., veraltend)
-rasant;turbulent;flott;temporeich (Hauptform)
-(sich) dazwischenquetschen;(sich) reinzwängen;(sich) reinquetschen;(sich) hineinzwängen;(sich) hineinquetschen
-Haschee;Haché
-U-Boot (fig.);Nihilartikel;fingierter Lexikonartikel
-(jemanden) an der Hand haben (ugs.);(jemanden) kennen (der etwas erledigen kann);über entsprechende Kontakte verfügen
-Paradoxien;Paradoxa
-Umwidmung;Umstufung;Änderungswidmung
-Einziehung;Entwidmung
-Hoheitsakt;staatlicher Hoheitsakt
-katadioptrisches System;Spiegellinsenobjektiv
-Erbmonarchie;hereditäre Monarchie
-Thronfolge;Devolution (fachspr.)
-Hunt;Hund
-Hänger (ugs.);Anhänger
-Hubschraubersäge;Helikoptersäge
-Pegelunterschied;Pegeldifferenz
-Intensitätsinterferometer;Korrelationsinterferometer
-scheinbarer Durchmesser;Sehwinkel;scheinbare Größe
-Vierstreckensatz;Strahlensatz
-affine Translationsebene;Translationsebene
-Intensitätsgrad der Arbeit;Arbeitsintensität
-Wahlabsichtsfrage;Sonntagsfrage
-Publizistische Grundsätze;Pressekodex
-Chilenische Pfeifente;Chilepfeifente
-ist (beileibe) nicht das, was man sich unter (...) vorstellen würde;ist alles andere als (...);(...) sieht anders aus;kann man kaum als (...) bezeichnen;(...) geht anders (ugs.);kann man (wahrlich) nicht als (...) bezeichnen;verdient nicht die Bezeichnung (...)
-katalytische Aktivität;Katalysatoraktivität
-Reaktand;Edukt (veraltet);Reaktant
-Sozialindikator;sozialer Indikator
-Operationismus;Operationalismus
-Präfixcode;präfixfreier Code
-Kanalcodierung;Kanalkodierung
-Leitungskode;Leitungscode
-konvolutioneller Code;Faltungscode
-Kraft-Ungleichung;Kraft-McMillan-Ungleichung
-gewurzelter Baum;Wurzelbaum;Arboreszenz
-Elter;Vater;Elternknoten;Elterknoten
-Knoten;Ecke
-Digraph;gerichteter Graph
-schlichter Digraph;einfacher Digraph
-schleifenfreier Graph;schleifenloser Graph
-Ordnungsdiagramm;Liniendiagramm;Hasse-Diagramm
-Striktordnung;strenge Ordnung
-Komplementgraph;Komplement;komplementärer Graph
-Kontraktion;Kantenkontraktion
-Adjazenzmatrix;Nachbarschaftsmatrix
-gewichteter Graph;kantengewichteter Graph
-skalenfreies Netz;skaleninvariantes Netz;skaleninvariantes Netzwerk;skalenfreies Netzwerk
-pharmazeutische Technologie;Arzneiformenlehre;Galenik (veraltet)
-Verabreichungsform;Applikationsform
-Inhaltserschließung;Sacherschließung
-Dokumentationsbewegung;Dokumentationswissenschaft
-bibliographische Beschreibung;alphabetische Katalogisierung;Formalerschließung;Formalkatalogisierung;Titelaufnahme
-Katalogisierung;Erschließung
-Cryptophon;Cryptofon
-B-Kanal;Nutzkanal
-Shannon-Weaver-Modell;Sender-Empfänger-Modell
-Rufton;Ruf;Rufstrom;Rufspannung
-Rückfragetaste;R-Taste
-Datentaste;Modemtaste (ugs.)
-vermittlungstechnisches Leistungsmerkmal;Dienstmerkmal
-Kommunikationssystem;Kommunikationsnetz
-ESK-Relais;Edelmetall-Schnellschaltekontakt-Relais;Edelmetall-Schnellkontakt-Relais
-Nyquist-Shannon-Abtasttheorem;nyquist-shannonsches Abtasttheorem;WKS-Abtasttheorem
-diskretes Signal;zeitdiskretes Signal
-wild drauflos...;ohne Hemmungen;immer feste drauflos...;ungehemmt;munter drauflos...;planlos;ohne (eine Sekunde) zu Überlegen;einfach drauflos...;bedenkenlos
-im Zweifel;bei Unsicherheit
-Erwin Rommel;(der) Wüstenfuchs
-Verbrennung;Abfackelung;Veraschung;Einäscherung
-Inhumation;Erdbestattung
-Südostzone;amerikanische Besatzungszone
-britische Besatzungszone;Nordwestzone
-Vereinigtes Wirtschaftsgebiet;Bizone
-Erste Berlin-Krise;Berlin-Blockade
-Trizonesien-Song;Wir sind die Eingeborenen von Trizonesien
-Faschingslied;Fastnachtslied;Karnevalslied;Karnevalsschlager
-Intelligenzija;russische Intelligenz;Intelligenz
-Tschurjumow-Gerassimenko;67P/Churyumov-Gerasimenko;Tschuri
-Artilleriezugmaschine;Artillerietraktor;Artillerieschlepper
-Eierstockkrebs;Ovarialkarzinom (fachspr.)
-Eierstock;Oophoron (fachspr.);Ovar (fachspr.)
-Abkürzungsfieber;Abkürzungswahn;Abkürzungsvorliebe;Abkürzungsfimmel (ugs.);Abkürzerei;Aküfi (ugs.);Abkürzungsfaible;Abkürzungsmanie
-Stummelwort;Kurzwort;Abkürzung;Abbreviation (fachspr.);Abbreviatur (fachspr.);Kurzbezeichnung
-übertragbare Einzelstimmgebung;Präferenzwahlsystem
-Vokalisation;Vokalisierung
-Vegetationsphase;Vegetationsperiode;Vegetationszeit
-ländlicher Raum;Land;dörfliche Gegend;ländliche Gegend
-Abrisskante;Abbruchkante;Bruchkante
-Fasanenkammer;Fasanengarten;Fasanerie
-Kirchenrutsch(e)n (ugs., bayr., veraltend);Frömmlerin;Betschwester
-jemanden brauchen (um zu) (ugs.);(erst) kommen müssen (ugs.);ranmüssen (ugs.)
-auf den letzten Metern (fig.);kurz vor Toresschluss (fig.);fast am Ziel;(das) Ziel (schon) in Reichweite (haben)
-zündeln;mit Feuer spielen;herumkokeln;kokeln
-(anschließend) entscheiden;(später) weitersehen;(danach) schauen was zu tun ist
-Chaos hinterlassen;(eine) Trümmerlandschaft hinterlassen (fig.);(einen) Scherbenhaufen hinterlassen (fig.);verbrannte Erde hinterlassen (fig.)
-legen Sie los;ich bin ganz Ohr;schießen Sie los;ich höre;(jetzt) fangen Sie (schon) an;ich hören Ihnen zu
-kein Ehrgefühl (im Leibe) haben;(sich) alles gefallen lassen;(sich) nicht wehren;alles mit sich machen lassen;keinen Stolz haben
-(die) Belieferung einstellen;(den) Hahn zudrehen (fig.);(die) Lieferung stoppen;nicht weiter beliefern
-Handel verweigern;boykottieren;mit Boykott belegen
-ich brauch das nicht;darauf kann ich gut verzichten;das muss ich nicht haben
-hör mal zu;jetzt hör mal;pass auf, was ich dir sage (leicht drohend);jetzt hör mir mal gut zu (leicht drohend);(jetzt) pass mal auf (ugs.);hör zu;hör mal;pass auf
-seine (eigene) Haut retten;seinen (eigenen) Arsch retten (derb);versuchen heil herauszukommen;(sich) in Sicherheit bringen
-nicht aufgeben;an sich glauben;(den) Kopf nicht hängen lassen;nicht den Mut verlieren
-losbekommen;freibekommen (etwas das festsitzt);herausholen
-(eine) neue Herausforderung suchen (Bewerbungs-Schönsprech);(sich) bewerben;arbeitssuchend (sein) (lebenslauftypische Floskel);(sich) etwas Neues suchen;auf Stellensuche (sein);(die) Stellenanzeigen abklappern;auf Jobsuche (sein);im Bewerbungsmarathon (sein);Bewerbung schreiben
-(es) wird schon werden;(etwas) wird sich ergeben;(etwas) wird sich finden
-Standhaftigkeit;Tapferkeit
-rangehen wie Flocki ans Gehackte;rangehen wie Hektor an die Buletten (berlinerisch);rangehen wie Blücher (an Katzbach)
-(sich) nicht lange mit Diskussionen aufhalten (ugs., fig.);(sich) nicht lange mit Vorreden aufhalten;(nach dem Motto) erst schießen, dann fragen (ugs., Spruch);(sich) nicht (lange) zieren;(sich) nicht haben (ugs.);nicht lange fackeln (ugs.);keine langen Geschichten machen (ugs.);(sich) nicht (lange) genieren;nicht rumzicken (ugs.)
-(sich) nicht (lange) mit Vorreden aufhalten;sofort auf den Punkt kommen;(sich) nicht (lange) mit Höflichkeiten aufhalten;gleich in medias res gehen (geh., lat.);(gleich) zur Sache kommen;gleich in die Vollen gehen (ugs.);(jemanden) unvorbereitet konfrontieren (mit);mit der Tür ins Haus fallen (fig.)
-in aller Selbstverständlichkeit;umstandslos;ganz natürlich;ganz selbstverständlich;einfach
-Gewöhnliches Pfeilkraut;Pfeilblatt
-Hydrophyt;Wasserpflanze
-Kleines Pfeilkraut;Flutendes Pfeilkraut;Schmalblättriges Pfeilkraut
-Sumpfpflanze;Helophyt
-Röhrichtpflanze;Arundophyt
-Seichtwasserpflanze;Tenagophyt
-Nassbodenpflanze;Limosophyt
-Feuchtbodenpflanze;Uligophyt (fachspr.)
-temporäre Härte;Carbonat-Härte;vorübergehende Härte
-permanente Härte;Nichtcarbonat-Härte;bleibende Härte
-Ionenaustauscher;Ionentauscher
-Ionenaustauschchromatographie;Ionenchromatographie
-Flüssigchromatografie;Fluidchromatografie;Flüssigchromatographie;Fluidchromatographie
-überkritische Flüssigkeitschromatographie;Überkritische Fluidchromatographie;superkritische Flüssigkeitschromatographie;superkritische Fluidchromatographie
-Papierchromatographie;Papierchromatografie
-Dünnschichtchromatographie;Dünnschichtchromatografie
-Adsorptionschromatografie;Adsorptionschromatographie
-Säule;Trennsäule
-Entkarbonisierung;Dekarbonisierung;Entcarbonisierung
-Strahlregler;Luftsprudler;Mischdüse;Perlator;Aerator (engl.)
-Quinnat;Königslachs
-Wachstumshormonmangel;Hyposomatotropismus
-Anti-Frost-Protein;Eisstrukturierendes Protein
-Tripelpunkt;Dreiphasenpunkt
-Gleichgewichtsdampfdruck;Sättigungsdampfdruck
-sich nicht losreißen können;nicht loskommen;(irgendwo) hängenbleiben;sich nicht loseisen können
-dranbleiben (ugs.);dabeibleiben;nicht aufhören;weiter...;weitermachen
-hyperbare Oxygenierung;hyperbare Sauerstofftherapie;HBO-Therapie
-Sauerstoffbar;Sauerstofftankstelle
-extrakorporale Membranoxygenierung;extrakorporale Lungenunterstützung
-hyalines Membransyndrom;Atemnotsyndrom des Neugeborenen;Surfactant-Mangelsyndrom
-Mekoniumaspiration;Mekoniumaspirationsyndrom
-pulmonal-arterielle Hypertension;pulmonale Hypertension;pulmonale Hypertonie;pulmonal-arterielle Hypertonie
-akutes progressives Lungenversagen;Schocklunge
-Kleine Walachei;Oltenien
-Sandflucht;Deflation
-Biocoenose (fachspr., griechisch);Lebensgemeinschaft;Biozönose (fachspr., griechisch)
-Taphonomie;Fossilisationslehre
-Biostratonomie;Biostratinomie
-Grabgemeinschaft;Taphozönose
-Thanatocoenose;Thanatozönose
-Phytozönon;Pflanzengesellschaft
-Phytozoenose;Phytozönose;Phytocoenose;Pflanzengemeinschaft
-Vegetationsökologie;Phytozönologie;Pflanzensoziologie
-Autoökologie;Autökologie
-Bioökologie;Ökologie
-Demökologie;Populationsökologie
-Zeigerpflanze;Indikatorpflanze
-ökologische Potenz;ökologische Toleranz
-Rasterkartierung;Gitterfeldkartierung
-(jemanden) terrorisieren;(sich) nichts sagen lassen;(jemandem) auf dem Kopf herumtanzen
-stehender Begriff;Topos;Stereotyp;gängige Vorstellung;fester Begriff;feste Fügung
-Raizen (veraltet);Raszien;Ratzen (veraltet)
-Syllabogramm;Silbenzeichen
-More;Mora
-Silbengewicht;Morigkeit
-Endsilbe;Ultima
-Binnensilbe;Mittelsilbe
-Silbenkoda;Silbenende;Silbenauslaut;Silbenschwanz;Endrand;Koda
-Silbenkopf;Silbenanlaut;Anfangsrand;onset;Silbenanfang;Silbenansatz
-Nukleus;Silbengipfel;Silbenkern
-Liquid;Fließlaut;Schwinglaut;Liquida
-Phonotagmatik;Phonotaktik;Phonosyntax
-Vocoid;Vokoid
-Silbenfuge;Silbenjunktur;Silbengrenze
-Gelenk;ambisilbischer Konsonant;Silbengelenk;ambisyllabischer Konsonant
-Anschlusskorrelation;Silbenschnittkorrelation
-Sprachlaut;Phon;Laut
-Syllabizität;Silbizität
-Lautdauer;Lautlänge
-Geräuschlaut;Obstruent;Geräuschkonsonant
-Sonorlaut;Sonorant
-Flächensteifigkeit;Flächensteife
-Flächendeviationsmoment;biaxiales Flächenträgheitsmoment;Flächenzentrifugalmoment
-Flächenträgheitsmoment;Flächenmoment 2. Grades
-Zentrifugalmoment;Deviationsmoment;Nebenträgheitsmoment
-Hauptträgheitsachse;Trägheitshauptachse;Hauptachse
-Rotationsachse;Drehachse
-Scherung;Gleitung
-Querkraftmittelpunkt;Drillruhepunkt;Schubmittelpunkt
-stadtfein;ausgehfertig
-nett;schick (fig.);schnatz (fig., regional);schnuckelig (fig.)
-Festschrittschrift;nichtproportionale Schriftart;äquidistante Schrift;dicktengleiche Schrift;Festbreitenschrift;Konstantschrift
-Proportionalschrift;proportionale Schriftart
-Gestaltungsraster;Rastersystem;typografisches Raster
-Funktionale Typografie;Elementare Typografie;Neue Typographie
-Fisch;Zwiebelfisch
-Ablette;Ukelei;Laugele;Zwiebelfisch;Laube
-Gelegenheitsbildung;Ad-hoc-Bildung;Okkasionalismus (fachspr.);Augenblicksbildung;Ad-hoc-Wortbildung
-in einem hat sie recht;wo er recht hat, hat er recht;in einem hat er recht;in einem muss ich ihm recht geben;in einem muss ich ihr recht geben;wo sie recht hat, hat sie recht
-verbannt werden;(irgendwohin) abgeschoben werden
-rausschicken (ugs.);(des Raumes) verweisen (geh.);verbannen (aus);hinausschicken
-(...) wäre nicht (...), wenn nicht (...);(...) hieße nicht (...), wenn nicht (...);(seine) Rechnung ohne den Wirt machen;da kannte (jemand) (...) schlecht
-Schönwetter...;Salon...;Sonntags...
-das Licht der Öffentlichkeit erblicken (ironisierend);im Radio kommen (ugs.);allgemein bekannt werden;im Fernsehen kommen (ugs.);in den Nachrichten kommen (ugs.);in der Zeitung stehen (ugs.);an die Öffentlichkeit gelangen;öffentlich bekannt werden;ans Licht der Öffentlichkeit kommen
-im Fokus;auf dem Kieker (misstrauisch) (ugs.);unter Beobachtung;im Fadenkreuz;fest im Blick (floskelhaft);im Visier;im Blickfeld;im Auge (haben / behalten)
-(sich) Mühe geben;(sich) engagieren;fleißig sein;engagiert (sein);eifrig dabei sein (ugs.);(sich) bemühen
-(die) Rechnung ohne (...) gemacht haben;(sich) zu früh freuen;(seine) Rechnung ohne den Wirt machen;an die Falsche geraten sein (ugs., weibl.);an den Falschen geraten sein (ugs., männl.)
-P-Maschine;Pseudo-Maschine
-Deutsche Physik;Arische Physik
-Fehlbestand;Inventurdifferenz
-Stimmungsänderung;Veränderung in den Einstellungen (der Bevölkerung);Änderung der Stimmungslage;Stimmungswandel;Stimmungsumschwung
-Farbquantisierung;Farbreduktion
-Farbtabelle;Farbpalette
-Dithering;Fehlerdiffusion
-Quantisierungsabweichung;Quantisierungsfehler
-wild;stürmisch (fig.);aufgeregt;turbulent;unruhig;wildbewegt (Hauptform);bewegt (Zeit, Jahre);aufregend;Sturm- und Drang... (scherzhaft-ironisch)
-Farbdoppler;Angiodynographie;farbkodierte Doppler-Sonografie
-Ultraschallbild;Sonogramm
-Doppler-Fizeau-Effekt;Doppler-Effekt
-Weltherrschaft;Universalherrschaft
-Funkfernschreiben;Radiotelex
-Telegraphie;Telegrafie
-ENIGMA G;Abwehr-Enigma;Enigma-G;Zählwerksmaschine;Zählwerks-Enigma;ENIGMA-G;Glühlampen-Chiffriermaschine ENIGMA mit Zählwerk
-Gerät E.U.;Enigma-Uhr;Steckeruhr
-in Fahrt kommen;auf Touren kommen;in Fahrt geraten;in Schwung kommen;(sich) in Schwung reden;(sich) in Fahrt reden
-immer lauter werden;(sich) in Rage reden;(sich) in Wut reden
-Beweis durch Widerspruch;Widerspruchsbeweis;indirekter Beweis
-Lametta;Christbaumschmuck;Christbaumkugel
-Röhriger Wasserfenchel;Röhrige Pferdesaat
-Ausstattung (mit Vermögenswerten);Zuwendung (von Werten);Dotation (geh.);Versorgung (mit Gütern)
-Geisterbär;Kermodebär
-Geleitflugzeugträger;Geleitträger (Kurzform)
-Stiftungsrat;Kuratorium
-Dienstpistole;Ordonnanzwaffe (fachspr., historisch);Dienstwaffe
-Computeranimationsfilm;Animationsfilm;computeranimierter Film
-voll und ganz;aus (tiefster) Überzeugung;aufrichtig;aus vollem Herzen;aus tiefstem Herzen
-Comicbook;Graphic Novel (fachspr., engl.);Comicalbum;Comicbuch
-Animation von Knetfiguren;Claymation (fachspr., engl.);Knetanimation
-Einzelbildaufnahme(technik);Stop-Motion(-Technik);Einzelbildtechnik;Einzelbild-Technik
-3D-Animation;Objektanimation
-Legofilm;Brickfilm;Film mit Legofiguren
-Baumstraße;Allee
-Zweite Landesaufnahme;Franziszeische Landesaufnahme
-Erste Landesaufnahme;Josephinische Landesaufnahme
-orthodox;dogmatisch;(von) strenger Observanz (geh., bildungssprachlich, fig., variabel);streng;puristisch;der reinen Lehre verpflichtet
-buchstabengetreu (Auslegung);orthodox;Buchstabe für Buchstabe (fig.)
-Wahrheitsanspruch;Wahrheitsbehauptung
-Dickschädel;Unbelehrbarer;Kommisskopf;Quadratschädel (ugs.);Betonkopf (ugs.);Sturkopf;Hundertprozentiger
-Lebensqualität;Lebensstandard;Lebensbedingungen
-Verkehrsinfrastruktur;Transportinfrastruktur
-Minenfeld (fig.);Löwengrube (fig.);vermintes Gelände (fig.);Hexenkessel (fig.);Wespennest (fig.);Haifischbecken (fig.);Schlangengrube (fig.)
-Monsterwelle;Riesenwelle;Kaventsmann
-Phage;Bakteriophage
-Virion;Viron;Viruspartikel
-Capsid;Kapsid
-Protocyte;Procyte
-Flagellum;Geißel
-Pili (Plural);Fimbrien (Plural)
-Murein;Peptidoglykan;Polysaccharid-Peptid;Peptidoglycan
-Makromolekül;Riesenmolekül
-Plerion;Pulsarwind-Nebel
-Gramfärbung;Gram-Färbung
-Lugolsche Lösung;Iod-Iodkalium;Iod-Kaliumiodid-Lösung
-Gentianaviolett;Kristallviolett
-zweibeinig;biped
-quadruped;vierbeinig;vierfüßig
-Speicherleck;Speicherloch
-Wärmeübertragungskoeffizient;Wärmeübergangszahl;Wärmeübergangskoeffizient
-Phasengrenze;Grenzfläche
-Erdrinde;Erdkruste
-elektrolytische Doppelschicht;Doppelschicht;elektrochemische Doppelschicht
-Bugenhagenbibel;Lübecker Bibel
-evangelisch-lutherisch;lutherisch
-römisch-katholische Kirche;katholische Kirche
-Rituskirche;Teilkirche eigenen Rechts
-mit Rom unierte Kirche;katholische Ostkirche;unierte Kirche
-Ecclesia Romana (lat.);westliche Kirche;Westkirche;lateinische Kirche;Ecclesia Latina (lat.);römische Kirche
-Kyiver katholische Kirche;Ukrainische griechisch-katholische Kirche;Ukrainische katholische Kirche nach byzantinischem Ritus
-Altorientalische Kirche;orientalisch-orthodoxe Kirche
-Stromversorgung;Energieversorgung
-Ackerbürgerstadt;Oppidum (fachspr., historisch);Landstadt;Provinznest (ugs.)
-Gemeinde;Ortschaft;Ort
-Doku-Parodie;Mockumentary (engl.)
-Laufgraben;Verbindungsgraben
-Schießscharte;Scharte
-Zwerchwall;Traverse
-Prellschuss;Rikoschettschuss
-(à la) ich bin das Gesetz;(ein) Eigenleben führen;seine eigenen Regeln haben;für jemanden gelten eigene Regeln;nach (seinen) eigenen Regeln spielen (fig.);(sich) (seine) Regeln selbst machen
-Psychopath (fig.);gefährlicher Irrer
-Gefallsucht;Koketterie;Eitelkeit
-Dandytum;Geckenhaftigkeit;Stutzerhaftigkeit;Affigkeit
-Snobismus;Dünkelhaftigkeit;Vornehmtuerei
-Exaltiertheit;Extravaganz;Exzentrizität (gespreizt) (geh.);Überspanntheit;Exzentrik;Spleenhaftigkeit
-Schmuckeremit;Ziereremit
-Eishai;Grönlandhai
-Platzanweiser;Billeteur (österr.)
-Kompromat (Jargon);kompromittierendes Material
-Lenkradsperre;Lenkradschloss
-auslöten;entlöten
-(jemanden) platzieren;(jemanden) einschleusen;(jemanden) unterbringen
-nicht hineinkommen;niemand macht(e) auf;nicht ins Innere gelangen;nicht reinkommen (ugs.);vor verschlossener Türe stehen
-ohne Perspektive;ohne Zukunft
-(sich) (selbst) aussperren;(den) Schlüssel in der Wohnung vergessen (haben)
-Hauptsendezeit;beste Sendezeit;Prime Time (engl.);Primetime (engl.)
-(auch) auf die Gefahr hin, Ihnen zu nahe zu treten, (möchte ich dennoch sagen ...) (geh., variabel);Ich will dir nicht zu nahe treten (aber ...) (ugs., floskelhaft);Die Botschaft hör ich wohl, allein mir fehlt der Glaube. (Zitat) (geh.);(etwas) bezweifeln;(etwas) nicht glauben können;ich hab' da so meine Zweifel (ugs.);wer weiß, ob das stimmt... (ugs.);Wer's glaubt, wird selig. (ugs., Redensart);(das) kann zutreffen, oder auch nicht (ugs., variabel);(jemandem) kommen (erhebliche) Zweifel;Das wage ich zu bezweifeln. (ugs., floskelhaft)
-gemeinsame Position;Schulterschluss (mit) (fig.);enge Zusammenarbeit;Solidarität (mit)
-(sich) solidarisch erklären (mit);(den) Schulterschluss üben (mit) (fig.);(eine) gemeinsame Position vertreten;(den) Schulterschluss suchen (fig.);zusammenrücken (fig.)
-Mitgliederversammlung;Jahreshauptversammlung (Verein);JHV (Verein);Generalversammlung (ugs.);HV (AG);Hauptversammlung (AG);Konvent (Partei)
-gute Noten bekommen (fig.);gut wegkommen (bei einer Bewertung, Umfrage o.ä.);gut bewertet werden
-Silicium (fachspr.);Silizium
-Katzenstaupe;Aleukozytose;Katzenseuche;infektiöse Enteritis der Katzen;Panleukopenie;Agranulomatose;Katzenpest
-Postknecht;Postreiter
-Poststraße;Postkurs;Postroute;Postlinie
-Tularämie (fachspr.);Hasenpest
-Niedersächsisch;Westniederdeutsch (fachspr.)
-sehen (nach) (ugs.);nachsehen, ob alles in Ordnung ist;nach dem Rechten sehen;(sich) vom ordnungsgemäßen Zustand (einer Sache) überzeugen
-Infektiologie;Infektologie
-(es) ist der Teufel los;(es) gibt viel zu tun;(es) ist Hochbetrieb;(es) herrscht(e) Hochbetrieb;(es) ist viel Betrieb
-Übersetzer;Transpiler;Transcompiler
-Kompiler;Kompilator;Übersetzer;Kompilierer;Compiler
-sehr viele Menschen;(ganze) Völkerscharen (fig.);Heerscharen (von) (fig.);(ganze) Generationen von
-wie heißt es noch gleich so schön - ...;wie es so schön heißt;wie sagt man noch gleich - ...
-(jemandem) die Entscheidung überlassen;(jemanden) frei entscheiden lassen;entscheiden dürfen;(jemandem etwas) anheimstellen;(jemanden) selbst entscheiden lassen;(jemandem) freie Wahl lassen;(jemandem) bleibt es selbst überlassen, ob (...);(jemandem) bleibt etwas selbst überlassen;(etwas) in jemandes Ermessen stellen (geh.);(es) sich aussuchen können;wählen können
-Urgewalten;Elemente;Naturkräfte;Naturgewalten
-(da) hat es gerade noch gefehlt, dass (ugs.);zu allem Übel (geh.);um das Maß voll zu machen (... auch) (ugs.);nicht genug (damit), dass (... auch / sogar ...) (geh., Hauptform);zu allem Überfluss;das hat (mir) gerade noch gefehlt (ugs.);jetzt fang du auch noch an! (ugs.);als wenn das nicht schon genug wäre
-Lahmacun;türkische Pizza
-Unteraufgabe;Teilaufgabe
-krachende Niederlage;Klatsche (ugs.)
-Gemeinböhmisch;Gemeintschechisch
-böhmische Sprache (veraltet);Tschechisch (Hauptform);tschechische Sprache
-Ruthenische Sprache;Russinisch;Russinische Sprache;Ruthenisch
-Ungarnrussinen;Karpatenrussinen;Karpato-Ukrainer;Karpatorussen;Ruthenen;Russynen;Rusniaken;Russinen
-Schlacht bei Mingolsheim;Schlacht am Ohrenberg
-Bearbeitung;Adaption (fachspr.);Umarbeitung
-man kann alle Rippen (einzeln) zählen (bei) (variabel);Knochengestell (ugs., fig.);(nur noch) Haut und Knochen (ugs.);Hungerkünstler (fig.);nichts zwischen den Rippen haben (variabel);Hungerhaken (ugs.);(ein) schmales Handtuch (ugs., regional);(ein) wandelndes Gerippe (ugs.);(ein) Strich in der Landschaft (ugs.);Klappergestell (ugs.);(ein) Haufen Knochen (ugs.);(an jemandem ist) nichts dran (ugs.)
-riechen nach;(einen) Geruch am Leibe haben
-entschleunigen (fig.);(es) langsam gehen lassen;einen Gang herunterschalten (fig.);Druck herausnehmen (fig.)
-Kupferverluste;Wicklungsverluste
-Motorenblech;Dynamoblech
-Transformatorenblech;Kernblech
-Restverlust;Viskositätsverlust;Nachwirkungsverlust
-Fußgängerampel;Fußgängersignalanlage (Amtsdeutsch);Fußgängerschutzanlage (fachspr.)
-Ersatzsignalprogramm;Signalnotprogramm
-Idealanspruch;Quote
-Pendlerüberschuss;Einpendlerüberschuss
-Mehrörtigkeit;Multilokalität
-Materialseilbahn;Lastenseilbahn
-ich lach mich schlapp (ugs.);das glaubst du doch nicht im Ernst! (ugs.);da lachen ja die Hühner! (ugs.);ich lach mich weg (ugs.)
-weitreichende Reform;umfassende Reform;tiefgreifende Reform;durchgreifende Reform;Reform an Haupt und Gliedern (fig.)
-an Haupt und Gliedern reformieren;umfassend reformieren;von Grund auf reformieren;grundlegend reformieren
-neu ordnen;neu organisieren;erneuern;neu gestalten;umbauen (fig.);reformieren;auf einen neue Grundlage stellen;umbilden;umgestalten;auf neue Füße stellen (fig.);restrukturieren;reorganisieren;(einer Sache) eine neue Grundlage geben
-Fehlerdichte;Fehlerhäufigkeit;Fehlerrate;Fehlerquotient
-Ergebnis;Element eines Wahrscheinlichkeitsraums;atomares Ereignis;Grundereignis;Elementarereignis
-Prozesslenkung;Prozesssteuerung;Prozessregelung
-Statusregister;Zustandsregister;Programmstatuswort
-Steradiant;Sterad
-Bremsverzögerung;negative Beschleunigung
-Deckschicht (fachspr.);Fahrbahnbelag;Wegedecke (fachspr.);Decke (fachspr., Jargon);Fahrbahndecke
-Fatalist;Schicksalsgläubiger;Schicksalsergebener
-Gliederung von Zahlen;Schreibweise von Zahlen
-Speigatt;Speigat;Wasserpforte
-Liebling der Frauen;Schlag haben bei (Frauen) (ugs.);(Frauen) fliegen auf (ugs.);Frauenschwarm
-(jemanden) entpflichten;(jemanden) abziehen (von einer Aufgabe);(jemandem) (eine Aufgabe) abnehmen;(jemanden) rausnehmen (ugs.);abgeben müssen (Aufgabe);(jemanden) rausziehen (ugs.);(jemanden) herausziehen;(jemanden) herausnehmen;(jemanden) (von einer Aufgabe) entbinden;(jemandem etwas) entziehen
-Selbstständigkeit;Eigeninitiative;persönlicher Einsatz;eigenverantwortliches Handeln;persönliches Engagement
-Selbstbezug;Selbstreferenz;Autoreferenz
-gedanklicher Zirkel;(da) beißt sich die Katze (selbst) in den Schwanz (fig.);Zirkelbezug
-(bei jemandem) nicht gut aussehen;(jemandem) nicht stehen (Hauptform);(bei jemandem) unvorteilhaft aussehen
-(jemanden) kleiden (geh., veraltend);(jemandem) stehen;(jemandes) Vorzüge betonen;kleidsam (sein) (geh., veraltend);(jemandem) schmeicheln (geh.);toll aussehen (in / mit / bei) (ugs., variabel)
-Wortbruch;gebrochenes Versprechen;nicht eingehaltenes Versprechen
-Flitsche (ugs., ruhrdt.);Bodenabzieher;Gummiwischer;Abzieher (Putzgerät);Wasserschieber
-Katschi (berlinerisch);Kreuzbergschleuder;Schleuder;Zwackel;Flitsch(e) (ugs.);Zwockel;Zwistel;Fletsche (ugs.);Katapult (ugs.);Schlatte;Schlatsche;Steinschleuder (süddt.);Spatzenschießer;Zwille (ugs., norddeutsch);Katsch(e) (ugs.);Gambel;Zwuschel
-Irrlicht;Irrwisch;Sumpflicht
-(es) gepackt haben (ugs.);(es) gut haben;sein Glück gemacht haben;(es) gut getroffen haben;fein raus sein;gut dran sein
-Staatsforst;Staatswald
-Nationaleigentum;Staatseigentum;Staatsbesitz
-Forstinventur;Waldinventur
-Forsteinrichtung;Forstabschätzung (veraltet);Taxation (veraltet);Forsttaxation (veraltet)
-Waldzustandsbericht;Waldschadensbericht (veraltet);Bericht über den Zustand des Waldes
-Biotopbaum;Habitatbaum
-(es) gepackt haben;über den Berg sein (fig.);fein raus sein;aus dem Gröbsten heraus sein;durch sein mit (ugs.);(das) Schlimmste überstanden haben;(es) überstanden haben;überstanden sein;(noch einmal) (die) Kurve gekriegt haben (fig.);aus dem Schneider sein;hinter sich haben;(es) geschafft haben
-nächtlicher Himmel;Nachthimmel
-Scheinasylant;Einwanderer in die Sozialsysteme;Asylschmarotzer (derb, abwertend)
-Volksschullehrer (österr.);Primarlehrer (schweiz.);Grundschullehrer;Lehrer an der Primarstufe
-Seitenkanalattacke;Seitenkanalangriff
-poikilotherm (fachspr.);kaltblütig (veraltet);wechselwarm
-Staatsphilosophie;Staatstheorie
-Erschleicher von Sozialleistungen (selten);Sozialbetrüger
-Arbeitsverweigerer;Sozialschmarotzer
-(sich in die) soziale Hängematte (legen) (fig.);auf Kosten der Gesellschaft (leben)
-Businessplan;Geschäftsplan
-Cardia;Magenmund;Kardia
-Langschwanzmakak;Javaneraffe;Krabbenesser
-Meerkatzenverwandter;Hundsaffe
-Wochenbettdepression;postpartale Depression
-Wochenbettspsychose;paranoid-halluzinatorische Puerperalpsychose
-postpartale Thyreoiditis;Postpartum-Thyreoiditis
-Babyblues (ugs.);Heultage (ugs.);postpartales Stimmungstief (fachspr.);Wochenbettdepression
-Buntglas;buntes Glas;Farbglas;farbiges Glas
-Grünberger Union;Grünberger Einung;Grünberger Allianz;Grünberger Bund
-Lizenzschlüssel;Lizenz (ugs., Abkürzung);Schlüsselcode;Aktivierungsschlüssel;Product Key (fachspr., Jargon, engl.);Key (ugs., Abkürzung);Freigabecode;Produktschlüssel;Produkt-Key (fachspr., Jargon, engl.)
-(ein) Plauderstündchen einlegen (ugs.);(die) Zeit verquatschen (ugs.)
-Zootrop;Wundertrommel (ugs.);Zoetrop
-Reihenfotografie;Serienfotografie
-Chronofotografie;Fotochronografie
-Tachyskop;Elektrischer Schnellseher;Elektrotachyscop
-Bildwerfer;Projektor (Hauptform);Projektionsgerät;Vorführgerät;Projektionsapparat
-Phanakistiskop;Lebensrad;Phantaskop;Phenakistiskop;Wunderrad
-Laufbildprojektor;Filmprojektor
-KoKi;Kommunales Kino
-Zweithörer;Gaststudent;Gaststudierender
-Hörer;Gasthörer;Hospitant
-Parallelstudium;Mehrfachimmatrikulation;Doppelstudium
-(jemandem) fällt die Decke auf den Kopf (ugs., fig.);(jemandem) ist alleine langweilig;Abwechslung brauchen
-(jemand) muss unter Leute;(jemandem) fällt die Decke auf den Kopf (fig.);(jemand) hält es zu Hause nicht (mehr) aus;(jemand) muss (einfach) raus;(jemand) muss unter Menschen
-Bildwiederholfrequenz;Bildwiederholrate
-Horizontalfrequenz;Zeilenfrequenz
-zutiefst enttäuscht;furchtbar enttäuscht;bitter enttäuscht;total enttäuscht;tief enttäuscht;maßlos enttäuscht;schwer enttäuscht;restlos enttäuscht
-abdriften (fig.);(den) Halt verlieren (fig.);aus der Spur geraten (fig.);abrutschen (fig.);abgleiten
-auf den Hund kommen (sprichwörtlich);verelenden;ganz unten ankommen;völlig verwahrlosen;zugrunde gehen;vor die Hunde gehen (sprichwörtlich)
-Δ-Modulation;Δ-M;Deltamodulation
-Pulspositionsmodulation;Pulsphasenmodulation
-Digitalverstärker;Klasse-D-Verstärker;schaltender Verstärker;Digitalendstufe
-jederzeit;(kann) jeden Augenblick;(kann) jeden Moment
-(jemanden) ins kalte Wasser schmeißen (fig., Hauptform);training on the job (engl.);(jemandem) sagen 'Mach mal!';(jemanden) ins kalte Wasser werfen (fig.);Der Mensch wächst mit seinen Aufgaben. (Spruch, variabel);(einfach) sagen 'du machst das jetzt';(jemandem) sagen 'Du schaffst das (schon).';(das Prinzip unserer Einarbeitung ist) learning by doing (engl.);(sich) vor völlig neue Herausforderungen gestellt sehen;(sich) mit völlig neuen Aufgaben konfrontiert sehen
-könnte funktionieren;könnte klappen;vielleicht klappt's ja
-noch nie (vorher) gemacht haben;(für jemanden) Neuland sein;(für jemanden ist) alles neu
-(eine) große Herausforderung;(eine) echte Herausforderung;(eine) schwierige Aufgabe
-(sich) erst nachträglich herausstellen (Erfolg);(etwas) nicht vorher wissen (können);nicht wissen (können), wie etwas ausgehen wird
-durcheinandergeworfene Papiere;fliegende Blätter (fig.);Loseblattsammlung (fig.);Durcheinander von Papieren;Zettelwirtschaft;(unsortierter) Berg an Papieren
-(nur) im Notbetrieb;auf Sparflamme laufen (fig.);(einen) Notbetrieb aufrechterhalten
-(orientalischer) Singsang;Gejaller (ugs.)
-Krafthaus (veraltet);Maschinenhaus
-Seltene-Erden-Magnet;Seltenerdmagnet
-Anlieger;Nachbar;Anrainer;Grundstücksnachbar;Anstößer (schweiz.);Anwohner;Angrenzer
-auch gelten für;keine Ausnahme (sein)
-Tätigkeits-Pfeil-Darstellung;Methode des kritischen Pfades
-Tätigkeits-Knoten-Darstellung;Metra-Potenzial-Methode;Vorgangs-Knoten-Darstellung
-Reaktionsgeschwindigkeit-Temperatur-Regel;van-'t-Hoff'sche Regel;RGT-Regel
-Stoßtheorie;Kollisionstheorie
-Umkehrzahl;Kehrzahl;Invertzahl;Spiegelzahl
-Arrheniusplot;Arrheniusgraph;Arrheniusdarstellung
-Sommerschloss;Sommerresidenz
-Sommeraufenthalt;Sommerwohnsitz
-(eine) Schlüsselrolle (spielen);von wesentlicher Bedeutung (sein);(ein) zentraler Punkt (sein)
-(och) nee, lass ma(l) (ugs., variabel);danke nein;lieber nicht;lass nur (ugs.);och nee (ugs.);nein danke;muss nicht sein (ugs.)
-OMG (ugs., engl., jugendsprachlich);Grundgütiger! (geh.);Oh mein Gott! (ugs.)
-(die) Frauen (Hauptform);(die) Damenwelt (geh.);(das) schöne Geschlecht;(die) Weiblichkeit (geh.);(die) Damen;(das) schwache Geschlecht;(die) Mädels (ugs., salopp);(die) holde Weiblichkeit (geh., ironisierend)
-Satzung (Hauptform);interne Regularien;Statuten;Verfahrensregeln
-Gestalt annehmen;erkennbar werden;(allmählich) Realität werden;(langsam) zu erkennen sein;aufscheinen (geh., fig.);Form annehmen;sichtbar werden
-unter einem guten Stern stehen;vielversprechend (sein);erfolgsversprechend aussehen;(einen) glücklichen Start haben;(die) Zeichen stehen gut;(die) Zeichen stehen günstig;(einen) günstigen Verlauf nehmen;(einen) guten Start haben;(es) ruht Segen (auf) (geh., fig.);(einen) guten Verlauf nehmen
-(waschechte) Erfurter Puffbohne;gebürtiger Erfurter (regional);gebürtige Erfurterin (regional)
-Gebetsfahne;Gebetsflagge
-gleichmäßig (unter zweien) aufteilen;halbe-halbe (machen) (ugs.);in zwei gleiche Hälften teilen;halbpart (machen);fifty-fifty (machen) (ugs., engl.);in zwei gleiche Teile teilen
-viel (vor Komparativ);um Längen;weitaus;erheblich;um ein Vielfaches;um ein Vieles (geh., veraltet);um einiges;beträchtlich;bedeutend;weit;um vieles;um ein Mehrfaches
-Umbenennung;Namensänderung
-(Grenzverlauf) ohne Grenzsicherungsanlagen;grüne Grenze;Landgrenze
-auf ungenutztem Land;auf der grünen Wiese (bauen)
-(sich) darstellen;(sich) präsentieren;(sich) zeigen;daherkommen
-Ansprechpunkt;Auskunftsstelle;Service Point (engl.);Anlaufpunkt
-Ostdeutschland;ehemalige deutsche Ostgebiete
-Urinteststreifen;Urinstick
-juristische Tätigkeit;Arbeit als Richter;Juristerei;Arbeit als Anwalt;Rechtspraxis
-nicht vordrängeln! (ugs.);immer (schön) der Reihe nach (ugs.);Wer zuerst kommt, mahlt zuerst. (Sprichwort, Hauptform)
-nach außen hin;äußerlich;(bei etwas) ... wirken
-auf der Gästeliste stehen;eingeladen sein
-(dasselbe) wollte ich auch gerade sagen;zwei Dumme, ein Gedanke (ugs., ironisch, variabel)
-(jemand) könnte es nicht besser ausdrücken;(jemand) könnte es nicht treffender formulieren;(jemandem) das Wort aus dem Mund nehmen
-(jemandem) aus der Seele sprechen;sagen, was jemand (in diesem Moment) fühlt
-(etwas) genau so gesagt haben;(das) waren meine Worte;(etwas) wortwörtlich so gesagt haben
-eingeschrumpelt;verhutzelt;schrumpelig;hutzelig (ugs.);schrumpfig;verschrumpelt;eingetrocknet;vertrocknet
-aufgesprungen;rissig;von Rissen durchzogen;zerschrunden;schrundig (Haut)
-wie Sandpapier;kratzig;Reibung erzeugen(d);rau
-knitterig;krumpelig;gecrinkelt (Stoff) (fachspr.);gekreppt (Papier) (fachspr.);zerknittert;verknittert
-zerfurcht;wettergegerbt;faltig (Haut)
-Lackmuspapier;Lackmusstreifen
-Weißwurstäquator (ugs.);Weißwurstgrenze (ugs.)
-borstig;grannig;stoppelig
-piksend;piksig;(fein) stechend;pikend
-Weltgeschehen;Weltläufte (Plural) (geh.);Weltgetriebe (geh., literarisch)
-geht gar nicht (ugs.);(ein) Unding;kommt nicht in die Tüte (ugs.);(völlig) inakzeptabel
-körperliche Unversehrtheit;Leib und Leben;(Leben und) Gesundheit
-Landmarschall;Landtagsmarschall
-Parlamentssprecher;Parlamentspräsident
-mit offensichtlicher Sympathie;erfreut;anerkennend;mit Wohlgefallen;wohlgefällig
-Gentechnisch modifizierter Organismus;Gentechnisch veränderter Organismus
-personalisierte Medizin;individualisierte Medizin
-Mittlerer Katzenmaki;Westlicher Fettschwanzmaki
-Feuchtnasenprimat;Nacktnasenaffe;Feuchtnasenaffe
-Katzenmaki;Kleinlemur
-(es) abgesehen haben auf;aus sein auf;es anlegen auf (es angelegt haben auf) (Hauptform);(etwas) nicht anders wollen (ugs.);(etwas) wollen;suchen (Streit / die Konfrontation);(etwas) provozieren;(Streit) vom Zaun brechen (fig., variabel)
-(jemanden) abwimmeln (ugs.);(jemanden) im Kreis schicken;(jemanden) abspeisen (mit) (ugs.);(kaltschnäuzig) abfertigen;(jemanden) abfrühstücken (ugs.)
-der Vergangenheit angehören;abgehakt sein;hinter sich haben;erledigt sein;abgefrühstückt sein (ugs.);gelaufen sein (ugs.);(mit etwas) durch sein;(schon) vorbei sein
-Orientalische Krise;Orientkrise;Zweite Orientkrise
-Union von Auhausen;Protestantische Union;Deutsche Union
-Bagdadpakt;Zentrale Paktorganisation
-Westindische Zeder;Westindische Zedrele;Spanische Zeder
-wie damals (als wir noch jung waren);wie in den alten Zeiten;wie in unseren Studententagen;wie früher;wie in unseren besten Zeiten
-Es war einmal (...);In den alten Zeiten, wo das Wünschen noch geholfen hat, (lebte ...)
-früher (als alles noch besser war) (ugs.);unsere besten Jahre (ugs.);(die) gute alte Zeit (ugs.);Das waren noch Zeiten! (ugs.)
-seinem Ende entgegengehen;im Niedergang (befindlich) sein
-(sich) ausgrenzen;(sich) absondern;(sich) ins Abseits stellen
-Dritte Landesaufnahme;Franzisco-Josephinische Landesaufnahme
-Giftspritze;Todesspritze
-tödliche Injektion;letale Injektion
-Grundfarbe;Primer (engl.);Grundierung
-Kardinalfarbe;Grundfarbe;Ausgangsfarbe
-Weinkellner (männl.);Sommelière (franz., weibl.);Sommelier (franz., männl.);Weinkellnerin (weibl.)
-Schwank;Anekdote;(ein) Schwank aus jemandes Leben;(eine) Geschichte, die das Leben schrieb;Döneken (rheinisch);Story (ugs.);Posse;lustige Geschichte
-Tanz zu zweit;Pas de deux (Ballett) (franz.);Zweiertanz
-Souterrain (franz.);Souterrainwohnung;Tiefparterre (verhüllend);Kellerwohnung
-aus dem Französischen entlehnt (sein);(ein) Gallizismus (sein);aus dem Französischen stammen;(ein) Französismus (sein) (halb-scherzhaft);französischer Herkunft (Sprache)
-Gürtellinie;Körpermitte;Taille (franz.);Gürtelumfang
-extrem schmale Taille;sehr schlanke Taille;Wespentaille
-Trance;(Zustand der) Entrückung;Hypnose (Bewusstseinszustand)
-Avenue (franz.);Prospekt (russ.);Boulevard (franz.);Prachtstraße
-einschlafen;ins Reich der Träume hinübergleiten
-Geschäftsstraße;Ladenstraße;Einkaufsboulevard;Shopping Boulevard (engl.);Einkaufsmeile;Einkaufsstraße (Hauptform)
-Z-Baum;Zukunftsbaum
-Dauermischwald;Dauerwald
-Südatlantischer Rücken;Südatlantische Schwelle
-Nordatlantische Schwelle;Nordatlantischer Rücken
-Paläomagnetismus;fossiler Magnetismus (ugs.)
-Schwelle;Rücken
-Hackelrücken;Mittelarktischer Rücken;Gakkelrücken;Nansenrücken
-paläozoisches Zeitalter;Paläozoikum;Erdaltertum;Erdaltzeit
-Zeitalter;Erdzeitalter;Ära
-Steinzeit;Lithikum
-Mesozoikum;Erdmittelalter;Erdmittelzeit
-endogene Dynamik;endogene Prozesse
-Kontinentalplatte (ugs.);Lithosphärenplatte;tektonische Platte
-Herdvorgang;Herdprozess;Herdmechanismus
-Bruchtektonik;Bruchschollentektonik
-saxonische Bruchschollentektonik;saxonische Bruchtektonik
-Helvetikum;Helvetisches System
-subvariszische Vortiefe;subvariszische Saumsenke
-variscische Orogenese;variskische Orogenese;variszische Orogenese
-Santonium;Santon
-Chronostratigrafie;Chronostratigraphie
-Fenster;tektonisches Fenster
-Unterengadiner Fenster;Engadiner Fenster
-Semmeringfenster;Semmeringsystem
-Österreich Lexikon;Österreich-Lexikon
-innertropische Konvergenzzone;intertropische Konvergenzzone;Kalmengürtel
-Bilderbuchwolke;Schäfchenwolke
-Recht und Ordnung;Einhaltung der Gesetze;öffentliche Sicherheit und Ordnung
-Wirren;Umbruch;chaotische Zustände;Chaos (gesellschaftlich)
-hartes Durchgreifen;null Toleranz (gegen Rechtsverstöße);Law and Order (engl.)
-harte Hand (fig.);kompromissloses Durchgreifen;rigide Maßnahmen
-geordnete Zustände (polit.);Ruhe und Ordnung
-Disziplin;Einhaltung der (geltenden) Regeln;Zucht und Ordnung
-Duckmäusertum;Duckmäuserei;Untertanengeist
-blinde Ergebenheit;Kriecherei;devote Haltung;Speichelleckerei;Unterwürfigkeit
-Gesetzesapparat;Gesetzeslage;(die) Gesetze;(die) bestehende Rechtsordnung;Recht und Gesetz
-Gesetz;gesetzliche Regelung;Rechtsverordnung;rechtliche Regelung;rechtliche Bestimmung;Gesetzesform
-implizites Wissen;stilles Wissen
-soziale Kosten;externe Kosten
-sozialer Ertrag;externer Nutzen
-positiv;plus
-Union Jack;britische Flagge
-Business Identifier Code (engl.);SWIFT-Code;BIC
-Usurpator;Thronräuber
-Kappenwindmühle (regional);Holländerwindmühle
-Kastenmühle;Deutsche Windmühle;Ständermühle;Bockwindmühle
-(jemanden) an die Kandare nehmen;rigoros für Disziplin sorgen;keinen Freiraum lassen;sehr eng führen;(jemanden) hart rannehmen;an der (ganz) kurzen Leine halten
-willkommen im Team!;willkommen an Bord! (fig.)
-Lebensbrunnen;Quelle des ewigen Lebens
-(es) kann gar nicht genug sein;immer her damit
-steuerliche Bevorzugung;Steuerprivileg;(verbriefter) Steuervorteil
-wieder abschaffen;kassieren (Gesetz) (ugs., fig.);wieder außer Kraft setzen;rückgängig machen;wieder einkassieren (ugs., fig.);zurücknehmen
-ausfallen lassen (regelmäßige Termine);absagen (Termin);streichen;canceln (engl.);abblasen (Feier, Veranstaltung) (ugs.)
-annehmen (Angebot) (Hauptform);zustimmend aufnehmen;eingehen auf (Angebot, Vorschlag, Bedingungen);(eine) Zusage abgeben;akzeptieren (jemandes Vorstellungen, Konzeption, Angebot);zustimmen;einschlagen (Handgeste);(sich) einverstanden erklären;zusagen;(eine) Zusage machen;einwilligen (in)
-(die) Vollziehung aussetzen;außer Vollzug setzen;nicht vollziehen
-transiente Osteoporose;Knochenmarködem-Syndrom;transitorische Osteoporose
-Knocheninfarkt (ugs.);Knochennekrose;Osteonekrose
-aseptische Osteonekrose;aseptische Knochennekrose
-Hüftkopfnekrose;Femurnekrose
-Gaucher-Syndrom;Morbus Gaucher
-(den) Weg fortsetzen;weiterziehen;nicht länger bleiben;wieder aufbrechen;(irgendwo) ist jemandes Bleibens nicht mehr (geh., variabel)
-Die Hunde bellen, (und) die Karawane zieht weiter. (Sprichwort);Was kümmert es die stolze Eiche, wenn sich ein Eber daran reibt. (variabel);Was kümmert es den Mond, wenn ihn ein Hund anbellt.
-zur Unterstützung;zur Untermauerung;(als) flankierende Maßnahme;unterstützende Maßnahme
-Erdneuzeit;Neozoikum (veraltet);Känozoikum
-Erdgas-Trasse;Erdgastrasse
-Schienenkreuz;Bahnknoten;Eisenbahnknoten;Eisenbahnknotenpunkt
-einzelnes (Begleiter);Einzelnes (Pronomen);das eine oder andere
-(jemanden) (he)rumschubsen (fig., negativ);(jemanden) herumstoßen
-(etwas) googeln;nach etwas googeln;mit Google (im Internet) suchen nach
-zum lebenden Inventar gehören (scherzhaft);immer anwesend sein;immer da sein;kein Zuhause haben (ironisch);(schon) zum Inventar gehören (scherzhaft)
-(Straße) voller Restaurants;Hochburg der Gastronomie;Konzentration von gastronomischen Betrieben;(da) reiht sich Restaurant an Restaurant (variabel);Fressmeile (ugs.);(da) reiht sich ein Restaurant an das nächste (variabel)
-Kommentare;Kommentierung(en);Begleitmusik (fig.)
-das ist (ja) nicht auszuhalten! (ugs.);ich dreh (hier noch) durch! (ugs.);mir platzt (gleich) die Hutschnur! (ugs., veraltend);ich krieg (noch) Hörner! (ugs.);(das ist) zum Verrücktwerden! (ugs.);ich spring gleich aus dem Fenster! (ugs.);mir platzt gleich der Kragen! (ugs., veraltend);(das ist) zum Auswachsen! (ugs.);(das ist) zum Verzweifeln! (ugs.);das ist (ja) nicht zum Aushalten! (ugs.);ich krieg (/ mach) noch die Frecke! (ugs., rheinisch, sächsisch);mir platzt gleich der Arsch! (derb);ich krieg die Pimpernellen! (ugs., ruhrdt.);ich krieg zu viel! (ugs.);ich krieg die Krise! (ugs.);ich dreh am Rad! (ugs., fig.);das hältst du (doch) im Kopf nicht aus! (ugs.)
-seien wir doch mal ehrlich! (ugs.);ist doch wahr! (ugs.);hab ich etwa unrecht?;sind wir doch mal ehrlich! (ugs.);jetzt mal ehrlich! (ugs.);ist doch (einfach) so! (ugs.);hab ich nicht recht?
-schwache Brust;Hühnerbrust (ugs., spöttisch)
-(sich) ein Denkmal setzen (mit) (fig.);berühmt werden (mit);Geschichte schreiben (fig.);die Geschichte (von etwas) prägen;(mit etwas) in die Geschichte eingehen (fig., Hauptform);unvergessen bleiben;in die Annalen eingehen (fig.);...geschichte schreiben (mediensprachlich);nicht vergessen werden (variabel);(sich) einen Platz in der Geschichte sichern (fig.)
-(ein) Mann in meiner Position (männl.);(eine) Frau in meiner Position (weibl.);(ein) Mann in meiner Stellung (männl.);jemand in meiner Lage;jemand wie ich;(eine) Frau in meiner Stellung (weibl.)
-plötzlich vor einem stehen;aus dem Nichts auftauchen;auf einmal da sein;wie aus dem Erdboden gewachsen
-(weiter) bestehen;Bestand haben;fortbestehen;von Dauer sein;halten (Beziehung, Ehe);bestehen bleiben;(eine) Zukunft haben
-in die Brüche gehen (fig.);nicht von Dauer sein;scheitern
-Schneeerzeuger;Schneelanze;Schneekanone;Schneilanze
-Jacobsonsches Organ;Jacobson-Organ;Vomeronasales Organ
-Haupthistokompatibilitätskomplex;Hauptgewebeverträglichkeitskomplex
-Disulfidbrückenbindung;Disulfidbrücke;Disulfidbindung
-Propeptid;Präkursor-Protein
-2D-Gelelektrophorese;zweidimensionale Gelelektrophorese
-Kataphorese (veraltet);Elektrophorese
-Immunopräzipitation;Immunpräzipitation
-Fluoreszenz-Resonanzenergietransfer;Förster-Resonanzenergietransfer
-(der) Tag X;(der) Tag der Entscheidung;(der) Stichtag;(der) Tag der Tage;(der) fragliche Tag
-Der längste Tag (Filmtitel);(Tag der) Landung (der Alliierten) in der Normandie;(der) 6. Juni 1944;D-Day (Abkürzung, engl.)
-(seiner) Verärgerung Ausdruck geben;Dampf ablassen (fig.);(sich) auskotzen (derb, fig.);(seinem) Unmut Luft machen (variabel)
-den Dicken machen (ugs.);auf dicke Hose machen (ugs., salopp);(sich) unvernünftigerweise in Gefahr bringen;(sich) zum Retter aufspielen;den dicken Max(e) machen (ugs.);den Harten machen (ugs.);den Helden spielen
-Fahrgeschäft;Fahrbetrieb
-ephemere Architektur;temporäre Architektur
-einstimmig;ohne Gegenstimmen
-Paläografie;Paläographie (fachspr.)
-Medikamentenmissbrauch;Arzneimittelmissbrauch;Tablettensucht;Tablettenabhängigkeit;Tablettenmissbrauch;Medikamentenabhängigkeit
-Elektrifikation (schweiz.);Elektrifizierung;Elektrisierung (veraltet)
-Lastgang;Lastganglinie;Lastprofil;Lastkurve;Lastgangkennlinie
-gemein;böswillig;böse;sauber (ironisch);fies (rheinisch);bösartig;schlecht;übel
-iranischer Kalender;persischer Kalender
-Iranistik;Irankunde
-wie ein Berserker;wie ein Wahnsinniger;wie besessen;als wäre er vom Teufel besessen (männl.);wie ein Geisteskranker (ugs.)
-vorausschauenderweise;intelligenterweise;nach reiflicher Überlegung;mit Vorbedacht;klüglich (geh., veraltet);klugerweise;umsichtigerweise;mit Bedacht
-zum Gegenangriff übergehen;(den) Spieß umdrehen (fig.)
-(den) Spieß umdrehen (fig.);(jemanden) mit seinen eigenen Waffen schlagen (fig.)
-(das) Spiel machen (nach schwachem Auftakt);Oberwasser bekommen;(jetzt) die stärkere Mannschaft sein;(die) Führung übernehmen;aus einem Rückstand einen Vorsprung machen;(ein Spiel) kehren (schweiz.);(jetzt) überlegen sein;(ein Spiel) drehen
-Ruhrbesetzung;Ruhreinmarsch;Ruhrinvasion;Ruhrkrise
-Londoner Schuldenabkommen;Abkommen über deutsche Auslandsschulden
-Darmstädter und Nationalbank;Danat-Bank
-Kriegsanleihe;Kriegskredit
-...bruder;...freund;...kollege
-...bruder (abwertend);...kumpan
-sehr in Frage stehen (variabel);am seidenen Faden hängen (fig.);stark gefährdet sein (variabel);extrem bedroht sein (variabel)
-Secondhandshop;Brocki (ugs., schweiz.);Brockenhaus (schweiz.)
-Rehlein (fig.);von zartem Körperbau;zartes Wesen;Reh (fig.);Elfe (fig.);ätherisches Wesen (geh.)
-Paketzusteller;Paketbote
-verwachsen;knorrig;knotig
-bäurisch;erdverbunden
-rau (fig.);sperrig (fig.);unangepasst;knorrig (Charakter) (fig.);kantig (fig.)
-Charakterbaum;typischer Baum (einer Region);das Landschaftsbild prägend (Baum)
-sieht man überall (Baum);hat jeder (Baum);Allerweltsbaum
-(die) Karten auf den Tisch legen (fig.);mit offenen Karten (spielen) (fig.);keine Heimlichtuerei betreiben
-Kluft (fig.);Graben (fig.);Abstand (fig.)
-(ein) Segen sein;(sich) positiv auswirken;Segen bringen
-unentschuldbar;unverzeihlich;nicht zu entschuldigen
-(jemandem) das Gegenteil beweisen;(jemanden) eines Besseren belehren;(seinen Kritikern) das Maul stopfen;es jemandem zeigen;(jemanden) Lügen strafen;(jemandem) zeigen, wie man es besser macht (variabel);(jemanden) ins Unrecht setzen (geh.)
-(jemanden) der Lüge überführen;beweisen, dass jemand die Unwahrheit sagt;(jemanden) Lügen strafen
-(jemanden) der Lüge bezichtigen;(jemanden) der Lüge zeihen;(jemanden) beschuldigen zu lügen
-schamlose Lüge;haarsträubende Lüge;faustdicke Lüge;glatte Lüge;dreiste Lüge
-über alle (...) hinweg;quer durch alle (...);...übergreifend
-(sich) gemein machen (mit jemandem);(sich mit jemandem) auf eine Stufe stellen (fig.)
-(wahre) Odyssee (fig.);mühselige Suche (mit vielen Fehlschlägen)
-(wie) ferngesteuert;von außen vorgegeben;unfrei (im Handeln);von außen gesteuert;fremdbestimmt (Hauptform)
-im goldenen Käfig (sitzen) (fig.);in seiner Komfortzone (gefangen) (fig.)
-(ein) Leben in Luxus führen;in Saus und Braus leben;im Überfluss leben;(einen) verschwenderischen Lebenswandel führen
-mit allem versorgt (sein);(das) Rundum-sorglos-Paket (gebucht haben);nichts entbehren (müssen);von Beruf Sohn (sein)
-Kind reicher Eltern sein;aus einem wohlhabenden Elternhaus stammen
-Fußgängerbrücke;Passerelle (schweiz.);Fußgängerüberführung
-Passerelle-Regelung;Passerelle-Klausel;Brückenklausel
-nicht amtlich;unter Vorbehalt;(noch) vorläufig;nicht offiziell;unbestätigt
-vigil (fachspr., lat.);wachend;wach;bei Bewusstsein;im Wachzustand;frisch;ansprechbar;rege;munter
-getan haben;gemacht haben;angestellt haben;verbrochen haben;ausgefressen haben (ugs.)
-ich hätte da mal 'ne Frage (ugs., floskelhaft, variabel);eine Frage: (...)
-Konfliktdiamant;Blutdiamant
-Konfliktressource;Konfliktmineral;Konfliktrohstoff
-Coltan;Koltan
-Ressourcenfluch;Ressourcenfalle
-Van-de-Graaff-Generator;Bandgenerator
-Weitergabe;Weiterverbreitung;Proliferation (fachspr.);Waffenverbreitung
-Debüt...;...debüt;erste (erster / erstes) (variabel)
-Minoritätenpartei (fachspr.);Partei mit geringem Zulauf (ugs.);Partei unterhalb der 5%-Hürde (variabel);Kleinstpartei;Splitterpartei (ugs.);Kleinpartei;nicht-etablierte Partei (geh.)
-Kelchkommunion;Laienkelch (veraltet)
-Profess;Ordensgelübde
-Konventsmesse;Konventmesse
-Brautamt;Brautmesse
-Armenischer Ritus;Armenische Liturgie
-Ostsyrischer Ritus;Chaldäischer Ritus
-Alexandria;Alexandrien
-(bei jemandem) genau an der richtigen Adresse (fig.);(bei jemandem) goldrichtig
-Treppenwitz (der Weltgeschichte);Ironie des Schicksals;(wohl ein) schlechter Scherz
-(es) nicht (so) dicke haben;nicht Rockefeller sein;(sein) Geld nicht scheißen können (derb, fig.);nicht in Geld schwimmen (ugs., fig.);nicht auf Rosen gebettet (sein) (fig.)
-auf der Schattenseite des Lebens (stehen);wirtschaftlich benachteiligt;zu kurz gekommen (sein);(sozial) benachteiligt (sein) (Hauptform);sozioökonomisch benachteiligt;nicht auf der Sonnenseite des Lebens (geboren)
-(...) des Schreckens (ugs., fig.);fragwürdiges Produkt;schlecht gemacht;(wahre/r/s) Horror... (fig.);Machwerk;lieblos zusammengeschustert (ugs., variabel);(ein) Albtraum von (einem Kunstprodukt, technischen Produkt...);Schundwerk (abwertend)
-Fluse;Fussel
-Halluzinogen;Halluzination erzeugende Substanz
-Krokodilstränen (fig.);falsche Tränen;gespielte Trauer;geheuchelte Trauer
-(jemandes) Zeit über Gebühr in Anspruch nehmen;(jemanden mit seinen eigenen Anliegen) beschäftigt halten;(jemanden über die Maßen) mit Beschlag belegen;(jemandem) die Zeit stehlen
-Auxologie;Wissenschaft vom menschlichen Körperwachstum
-Totentanz;Danse macabre (geh., franz.)
-Rückenschmerzen (haben);Rücken (haben) (ugs., Spruch, scherzhaft);Kreuzschmerzen (haben);es im Rücken haben;es im Kreuz haben
-(jemanden) (wieder) aufbauen;(jemandem) Mut machen;(jemandem) Mut zusprechen;(jemanden) (wieder) aufrichten;(jemandem) (wieder) Auftrieb geben
-lass dich nicht hängen!;noch ist Polen nicht verloren! (sprichwörtlich);Kopf hoch!;das wird schon wieder!;nicht aufgeben!;lass dich nicht fertig machen!;das wäre doch gelacht (wenn du nicht ...) (veraltend);lass dich nicht unterkriegen!
-ob du es glaubst oder nicht (aber);stell dir vor (...);da muss man erst mal drauf kommen! (ugs., Spruch);ob Sie es glauben oder nicht (aber);rate(t) mal, wer (was ...) (ugs.);das errätst du nie!;so unglaublich das auch klingt (aber);du wirst es nicht glauben (aber);du wirst lachen, aber;Sie werden lachen, aber
-verwunderlich (finden);sich wundern;(etwas) überraschend kommen;jemanden wundern;unerwartet kommen;(jemanden) irritieren;(mit etwas) nicht gerechnet haben;verwundert sein;erfrischend (finden);(für jemanden) (alles) ein bisschen plötzlich kommen
-Kopiersperre;Kopierschutz
-Afrikaans;Kapholländisch (veraltet);Kolonial-Niederländisch (veraltet)
-Neuniederländisch;modernes Niederländisch
-Avestisch;Awestisch
-Sardin (weibl.);Sardinierin (veraltend, weibl.)
-Sarde (männl.);Sardinier (männl., veraltend)
-Paschtunisch;Paschtu;Paschto
-Buchstabieralphabet;Buchstabiertafel;Fliegeralphabet;Telefonalphabet;Funkalphabet
-mit sich im Reinen sein;(sich) nichts vorzuwerfen haben;alles richtig gemacht haben (ugs., floskelhaft)
-ärgerliche Angelegenheit;dumme Geschichte;dumme Sache
-(sich) dumm anstellen;(sich) ungeschickt verhalten
-einen Dummen finden;jemanden finden, der blöd genug ist (um ...) (derb);(ein) Opfer finden
-Deutsche Justizverwaltung;Deutsche Zentralverwaltung der Justiz
-Görlitzer Abkommen;Görlitzer Grenzvertrag;Görlitzer Vertrag
-Panslawismus;allslawische Bewegung
-Panideologie;Pannationalismus;Panbewegung
-unterkühlt (fig.);distanziert;unfreundlich;frostig (Atmosphäre) (fig.);eisig (fig.);kühl (fig.)
-(noch) erreichbar;nicht aus der Welt
-nicht den Hauch einer Chance haben (gegen);völlig chancenlos;absolut keine Chance haben;hoffnungslos unterlegen (sein);nicht die geringste Chance haben
-(jemandem) die besten Chancen einräumen (/ geben / zuerkennen / ...);aussichtsreichst (Bewerber);(nach den Umfragen) ganz vorne liegen;haushoher Favorit;heiß (Kandidat);hoch gehandelt (werden);(die) besten Aussichten haben
-Charakter;Gepräge;Eigenart;Art;Eigentümlichkeit;Wesen
-Residenzregel;Wohnsitzregel;Wohnfolgeordnung
-Magna Mater (lat.);Große Mutter
-Ahnmutter (veraltend);Stammmutter;Ahnherrin;Ahnfrau (veraltend)
-sein Augenlicht verlieren;erblinden;blind werden
-Bachschwinde;Ponor;Schwinde;Schwalgloch (westfälisch);Schluckloch
-etwas anstellen (das einem hinterher leidtut) (variabel);auf dumme Gedanken kommen;Dummheiten machen
-Tropé (griechisch);Tropus (griechisch, lat.);Tropos (griechisch)
-(jemanden) herausreißen;(für jemanden) die Karre aus dem Dreck ziehen (fig.);(für jemanden) die Situation retten;(für jemanden) den Karren aus dem Dreck ziehen (fig.);(jemandem) aus der Patsche helfen (ugs.)
-(für jemand anderen) die Vorteile sichern;(für jemand anderen) die Kastanien aus dem Feuer holen (und sich dabei die Pfoten verbrennen) (fig.);(für jemand anderen) etwas riskieren
-(etwas) hinbiegen (ugs.);(etwas) deichseln (ugs.);(etwas) ummodeln;(etwas) drehen (fig.)
-andere für einen selbst die Kastanien aus dem Feuer holen lassen;andere für sich arbeiten lassen
-leptosom;ektomorph
-Körperbautyp;Konstitutionstyp
-mesomorph;metromorph;muskulöser Körperbau
-pyknomorph;endomorph
-Freie sozialistische Arbeiterjugend;Freie sozialistische Jugend
-(etwas) nicht erledigt bekommen;(etwas) nicht geregelt bekommen;(mit etwas) nicht fertig werden;nicht zu Potte kommen (mit);(etwas) nicht vom Tisch bekommen
-Klampfen;Krampe;Krampen;Klampfe;Agraffe (schweiz.);Klampe;Klampen;U-Hakerl (bayr., österr.)
-Hafte;Heftel;Haftel;Häftel
-Außerschulisches Abitur;Nichtschülerabiturprüfung;Externenprüfung;Nichtschülerabitur;Abitur für Nichtschüler;Fremdenprüfung
-nicht standesgemäße Ehe;Missheirat;Mesalliance (geh., franz.);nicht standesgemäße Heirat
-an den Haaren herbeigezogen (fig.);abseitig;weit hergeholt;abwegig;entlegen;fremd wirken(d)
-(jemanden) hinwegtäuschen über;(jemandem) den Blick verstellen für
-Infektionsrisiko;Ansteckungsgefahr;Infektionsgefahr;Ansteckungsrisiko
-(bitte) nicht wörtlich (zu) verstehen;cum grano salis (gesagt) (geh., bildungssprachlich, lat.);mit Einschränkungen (gesagt);augenzwinkernd;nicht ganz unzutreffend
-vorsichtig gesagt;so viel kann man vielleicht sagen;bei aller Vorsicht
-(darin) steckt ein Körnchen Wahrheit;(ein) Körnchen Wahrheit (enthalten);nicht ganz falsch (sein);daran ist etwas Wahres;(da) ist was dran (ugs.);nicht völlig abwegig (sein);(an einer Sache) ist etwas Wahres dran (ugs.);(der) Wahrheitskern (ist);(etwas) könnte teilweise stimmen;nicht völlig aus der Luft gegriffen sein (fig.);wahr daran ist (dass)
-unsicherer Kantonist;Wackelkandidat
-darauf warten, was kommt;ma kucken! (ugs., ruhrdt.);(einfach) abwarten;Abwarten und Tee trinken. (Spruch);keine vorschnelle(n) Entscheidung(en) treffen (wollen);nicht übers Knie brechen (wollen) (fig.);der Dinge harren, die da kommen (werden / mögen / sollen) (geh., Redensart);(die Dinge) auf sich zukommen lassen;abwarten! (ugs., variabel);schau'n mer mal! (ugs., Spruch);Erst tun mer mal garnix, dann schau'n mer mal, und dann wer'n mer scho' seh'n. (ugs., Spruch, scherzhaft, süddt., variabel)
-wie ferngesteuert;(etwas) einfach tun müssen;nicht anders können
-Kremationsleichenschau;zweite Leichenschau;amtsärztliche Leichenschau
-Stahlwerker;Stahlkocher;Hüttenwerker
-Werkerziehung;Werkunterricht;Werken
-(es ist) wieder derselbe Ablauf;(es) läuft wieder genau so;(es ist) dasselbe Spielchen (ugs., variabel);(es ist) dasselbe Spiel (variabel)
-darf ich (mal)? (variabel);Sie erlauben?;gestatten Sie?;erlauben Sie?;Sie gestatten?
-Annäherungsgraben;Sappe (fachspr.);(vorgeschobener) Laufgraben;Approche (franz.)
-Gemeinsprache (Hauptform);Allgemeinsprache
-(Geld) am Automaten abheben;(sich) ziehen (aus Automat);rauslassen (ugs., regional)
-das wär's;das war alles;damit ham'wers (ugs.);das war's (so weit);das wäre alles;(für den Moment) war's das (ugs., variabel);damit hat es sich (dann);damit hat sich's (ugs.);das ist alles
-Dislokation;Störung
-Filialunternehmen;Ladenkette;Mehrbetriebsunternehmen;Filialist
-Erste Slowakische Republik;Slowakei (Kurzform);Slowakische Republik;Slowakischer Staat
-Ostalpen-Enzian;Ungarischer Enzian;Pannonischer Enzian
-Gebirgs-Weide;Großblättrige Weide;Schlucht-Weide
-Waagepunkt;Herbstpunkt
-Äquinoktie;Äquinoktialpunkt
-mit gesenktem Blick;(die) Augen zu(m) Boden gerichtet
-nicht (mehr) irgendwer sein;wer sein;in Betracht kommen (als)
-verunstalten;(sich etwas) ruinieren (Kleidung, Frisur);verhunzen;(sich) verderben
-Man kann nicht vorsichtig genug sein. (floskelhaft);Vertrauen ist gut, Kontrolle ist besser. (Spruch);Doppelt (genäht) hält besser. (Spruch, variabel);Sicher ist sicher. (Spruch);Vier Augen sehen mehr als zwei. (Spruch);Lieber einmal zu viel als einmal zu wenig.
-Verbotszone;No-go-Area (engl., militärisch);Sperrgebiet;verbotene Zone;Sperrzone
-(zwischen sie) passt kein Blatt Papier (variabel);ein Herz und eine Seele sein (sprichwörtlich);(sich) in allem einig sein;in allem einer Meinung sein
-vorurteilsbeladen;vorurteilsbehaftet;voreingenommen;befangen;vorurteilsgeprägt
-wie man sich typischerweise (...) vorstellt;dem Klischee entsprechend;waschecht;wie sich klein Fritzchen (...) vorstellt (ugs.)
-(alle) Christen;Gemeinschaft der Christen;Christenheit
-Vulgärlatein;Küchenlatein (ugs.);Kirchenlatein;latinitas culinaria (lat.)
-humanistisches Latein;klassisches Latein
-würdevoll;gemessen (Bewegungen);feierlich;andächtig;weihevoll;andachtsvoll
-souverän;majestätisch;ehrfurchtgebietend;Achtung gebietend;hoheitsvoll;Ehrfurcht gebietend;achtunggebietend;erhaben
-in seiner eigenen Welt (sein);nichts mitbekommen;seinen (eigenen) Gedanken nachhängen;in seinen eigenen Gedanken (sein)
-sehr oft;tausend mal
-Mutterschaftskarenz (fachspr.);Mutterschaftsurlaub
-allgemeine Linguistik;allgemeine Sprachwissenschaft
-Historiolinguistik;historische Sprachwissenschaft;historische Linguistik
-konfrontative Linguistik;kontrastive Linguistik
-Statistische Linguistik;Sprachstatistik;Linguostatistik
-Menzerath-Altmannsches Gesetz;Menzerathsches Gesetz;Menzerath-Altmann-Gesetz
-Computerlinguistik;linguistische Datenverarbeitung
-Lexikostatistik;Lexikometrie
-Häufigkeitswörterbuch;Frequenzwörterbuch
-moltern (Müller);mitzen (Müller) (regional, selten, veraltet);den Mahllohn einbehalten
-(die) Mitz (regional, selten, veraltet);Mahllohn;Müllerlohn;(der) Molter (regional, veraltet);Mahlgeld
-aufkochen (lassen);aufwallen (lassen);wallen (lassen);hochkochen (lassen);aufsieden (lassen)
-Gaszentrifuge;Gas-Ultrazentrifuge
-Zypressen-Schuppenfichte;Zypressenähnliche Schuppenfichte
-Tasmanische Zeder;Schuppenfichte
-Gagel;Gagelstrauch
-Greve;Grebe;Grefe;Gräffe
-Gogericht;Gowgericht;Gohgericht
-Thing;Thaiding (oberdeutsch);Ding
-Kribbe;Schlacht;Schlenge;Buhne;Stack;Höft
-(das) Gras wachsen hören (fig.);(die) Flöhe husten hören (fig.)
-(sehr) feine Antennen haben (für) (fig.);übersensibel (sein)
-USB-Speicher-Stick;USB-Stick;Zumpferl (ugs., österr.)
-ungastlich;unwirtlich (Hauptform);wenig einladend;abweisend;lebensfeindlich;nicht einladend
-elektronische Zigarette;Dampfgerät (ugs.);E-Tschick (ugs., österr.);E-Zigarette (Hauptform);Dampfe (ugs.);E-Shisha;elektrische Zigarette
-in die Seite stoßen;anstupsen (ugs.);(einen) Rippenstoß geben
-(jemandes) Glück ein wenig nachhelfen;(jemandem) zu seinem Glück verhelfen
-Brauner;braunes Pferd
-Rautenkrokodil;Kubakrokodil
-Krokodil;Panzerechse (ugs.)
-Leistenkrokodil;Salzwasserkrokodil;Saltie
-Symbolklasse;Hörmander-Klasse
-Halbnorm;Seminorm
-sublineare Funktion;sublineare Abbildung
-relativ prim;teilerfremd
-zahlentheoretische Funktion;arithmetische Funktion
-bis ins kleinste Details;bis zur letzten Kleinigkeit;bis in die hinterste Ecke;bis in die letzten Details hinein;bis in die letzten Kleinigkeiten hinein;bis in die letzten Einzelheiten hinein;bis ins Tz (ugs.);bis ins Letzte;bis zum i-Tüpfelchen;bis ins Kleinste;bis in den letzten Winkel
-(die) Hoffnung aufgeben, etwas wiederzufinden;(es) aufgeben zu suchen;verloren geben;auf die Vermisstenliste setzen;sausen lassen (ugs.);(etwas) in den Wind schreiben (ugs.);(jemanden / etwas) abschreiben;als Verlust verbuchen;aufhören zu suchen;nicht weiter suchen (nach);nicht länger suchen (nach) (Hauptform);auf die Verlustliste setzen
-(den) Kopf hinhalten müssen (für) (fig.);verantwortlich gemacht werden (für);(für etwas) geradestehen müssen;(etwas) auf sich nehmen müssen
-zusehen müssen, wie man (mit etwas) klarkommt (ugs.);(die) Folgen tragen müssen;(mit etwas) klarkommen müssen (ugs.);mit den Folgen leben müssen
-(etwas) akzeptieren müssen;(etwas) in Kauf nehmen müssen;(etwas) hinnehmen müssen;(mit etwas) leben müssen;(sich) arrangieren müssen (mit);(gegen etwas) nichts machen können (ugs.)
-klar Stellung beziehen;klar Position beziehen;klare Kante zeigen (fig.)
-Treibhauseffekt;Glashauseffekt
-Nanothermit;Superthermit
-(sich) eine Zitate(n)schlacht liefern;(sich gegenseitig) mit Zitaten (nur so) bombardieren;(sich) Zitate nur so um die Ohren hauen (ugs.);(sich gegenseitig) Zitate um die Ohren hauen (ugs.)
-Luhn-Formel;Luhn-Algorithmus
-allen Sinns entkleidet (geh.);ohne (jede) Bedeutung;sinnlos (ugs.);sinnleer;sinnentleert
-was das angeht;diesbezüglich (Amtsdeutsch);was das betrifft;in dem Punkt (ugs.);insofern;was das anbelangt;in dieser Beziehung;in der Beziehung (ugs.);in diesem Punkt;soweit es (dies) betrifft;in dieser Hinsicht;insoweit
-(jemandem) ausgetrieben werden;verlieren;vergehen
-Fallbleistift;TK-Stift;Faller (ugs.);Fallminenstift;TK-Fallminenstift
-Fleischesser;fleischfressende Pflanze (ugs., scherzhaft)
-Vegetarierin (weibl.);Vegetarier (männl.);Vegetarianer (männl., veraltet);Vegetarianerin (veraltet, weibl.)
-Hardcore-Vegetarierin (derb, weibl.);Veganerin (weibl.);strenge Vegetarierin (weibl.);strenger Vegetarier (männl.);Hardcore-Vegetarier (derb, männl.);Veganer (männl.)
-(sich) nicht anstrengen (müssen);leichtes Spiel haben (mit);mit links machen (ugs.);(sich) nicht anzustrengen brauchen
-deutschkatholische Bewegung;Deutschkatholizismus
-schwer verdientes Geld;hartes Brot (fig.);sauer verdientes Geld
-Magdeburger Gebetsstreit;Magdeburger Bilderstreit;Sintenischer Bilderstreit
-hartes Brot (fig.);Hardcore (verblasst) (ugs., fig.);kein Zuckerlecken (fig.);kein Zuckerschlecken (fig.);nur was für harte (Jungs) (ugs., variabel)
-Nuklearchemie;Kernchemie
-Kernchemiker;Nuklearchemiker
-Chemielaborant;Chemielabortechniker (österr.)
-Philanthropismus;Philanthropinismus
-metabolisches Syndrom;tödliches Quartett;Syndrom X;Reaven-Syndrom
-Viszeralfett;intraabdominales Fett
-(eine) schwere Aufgabe;hartes Brot (fig.)
-Scheinwissenschaft;Pseudowissenschaft
-Ariernachweis;Arierschein
-Wunderkerze (Hauptform);Sternsprüher;Sternwerfer;Sternschneuzer;Sternspritzer (süddt., österr.);Sternlespeier;Sprühkerze;Sternensprüher;Sternchenfeuer;Spritzkerze (österr.);Sternspucker;Sternenspritzer;Spautzemännchen
-isolierter Bauer;Isolani
-thermische Expansion;Wärmeausdehnung
-thermische Kontraktion;Wärmeschrumpfung
-in diesem Fall;denn (ugs., norddeutsch);dann;(ja) wenn das so ist (ugs., Hauptform);unter diesen Umständen;in dem Fall;na dann (ugs.);na denn (ugs., norddeutsch)
-(nur) wenn es (auch) machbar ist;nicht um jeden Preis;nicht mit aller Gewalt;(nur) wenn es (auch) geht
-abwechslungsreich (sein);voller Überraschungen (stecken)
-reinlassen (ugs.);hereinlassen;eintreten lassen;hereinbitten;rinlasse (reilosse) (ugs., rheinisch);bitten, einzutreten
-weisungsberechtigt (sein);das Sagen haben (ugs.);(etwas) zu sagen haben;(etwas) zu melden haben (ugs.)
-(jemanden) in Eisen schlagen (veraltet);(jemanden) in Ketten legen
-du bist mir (ja) ein feiner (...)! (variabel, veraltend);du bist mir (ja) ein schöner (...)! (variabel, veraltend);du bist (mir) vielleicht ein (...)! (ugs.)
-da guckst du, nicht wahr?;(Na,) hab ich dir zu viel versprochen!?;tadaa! (ugs.);da kiekste, wa? (ugs., berlinerisch);da staunst du, was?;(na) was sagst du jetzt?
-(sich) die Beine in den Bauch stehen (ugs., fig.);kein Moos ansetzen wollen (ugs., fig., scherzhaft);(sehr) lange warten;Wurzeln schlagen (fig.)
-damit stehen Sie nicht alleine;dann sind wir schon zwei (Spruch, ironisch)
-wie kannst du nur! (variabel);(das) kann man doch nicht machen!;(etwas ist) keine Art und Weise (ugs., veraltend);(das) gehört sich doch nicht!
-gefechtsbereit;einsatzbereit;klar zum Gefecht (auch figurativ)
-Auf sie mit Gebrüll! (ugs., Spruch);Schnappt sie euch! (ugs.);Angriff! (ugs.);Zugriff!;Attacke! (ugs.)
-Generalüberholung (auch figurativ);Verjüngungskur (fig.);umfassende Sanierung;vollständige Umarbeitung;komplette Überarbeitung;(optische) Verjüngung;Totalrevision (juristisch, schweiz.);Sanierung (von Grund auf);Runderneuerung (Autoreifen) (auch figurativ);Frischzellenkur (fig., veraltend)
-von einem Ohr bis zum anderen strahlen (variabel);über alle vier Backen strahlen (ugs., fig.);unverhohlen sein Freude zeigen;über beide Backen grinsen (variabel);vor Freude strahlen;über beide Backen strahlen (ugs., fig.);übers ganze Gesicht strahlen (variabel)
-Körnerfresser (derb, abwertend, fig.);Müsliesser
-(Mitglied der) Toskana-Fraktion (Schlagwort, ironisch);Lifestyle-Linker (Schlagwort, ironisch);Kaviarlinker (ironisch, salopp);Salonrevoluzzer (ironisch, salopp);Salonkommunist (ironisch, salopp)
-(innere) Zerrissenheit;(innerer) Konflikt;(innerer) Zwiespalt
-Flatrate-Saufen (derb);Flatrate-Trinken
-mit reichlich Alkohol;(es gibt) Alkohol im Überfluss;Alkohol fließt in Strömen (fig.);feuchtfröhlich (Party, Abend, Runde) (Hauptform)
-Verstandeskraft;Aufwand an Geisteskraft;Gehirnschmalz (ugs.);Denkkraft;geistige Anstrengung (Hauptform)
-Kapriolen schlagen (fig.);schnell abwechseln;(sehr) wechselhaft sein
-Wetterkapriolen;Aprilwetter;(sehr) wechselhaftes Wetter
-ich wär(e) dann soweit (ugs.);soweit sein (ugs.);es kann losgehen (Spruch);fertig sein;Wir können. (ugs., Jargon);wir wären dann soweit (ugs.)
-mit den Füßen scharren (ugs., fig.);ungeduldig werden;mit den Hufen scharren (ugs., fig.)
-(das) Geld ist weg;nicht flüssig sein (fig.);kein Geld haben;keinen (roten) Heller in der Tasche haben (fig., veraltet);Woher nehmen, wenn nicht stehlen? (ugs., Spruch);(es herrscht) Ebbe in der Kasse (fig.);kein Geld in der Tasche haben;Woher nehmen und nicht stehlen!? (ugs., Spruch)
-überschuldet;(kurz) vor der Insolvenz stehen (variabel);in den Miesen (ugs.);(tief) in den roten Zahlen (stecken) (ugs., fig.)
-Wein, Weib und Gesang (Spruch);Sex and Drugs and Rock'n'Roll (Spruch, engl.)
-nur nicht den Kopf verlieren! (Spruch);kein Grund zur Panik! (ugs.);keine Angst!;keine Bange! (ugs.);nur Mut!;keine Sorge!;nur nicht den Mut verlieren!
-total (ugs.);ganz (ugs.);herzlich (emotional) (ugs.);sehr
-Der frühe Vogel fängt den Wurm. (Sprichwort);Morgenstund hat Gold im Mund. (Sprichwort)
-Was du heute kannst besorgen, das verschiebe nicht auf morgen. (Sprichwort);Morgen, morgen, nur nicht heute, sagen alle faulen Leute. (Sprichwort)
-Großschiff;(dicker) Pott (ugs.);großes Schiff
-(eine) andere Preisklasse (fig.);(ein) anderes Kaliber (fig.);(eine) andere Größenordnung;ein paar Nummern zu groß (für) (ugs., fig.);(eine) andere Hausnummer (fig.);(eine) andere Liga (fig.);(eine ganz) andere Nummer (ugs., fig.);(eine) andere Kragenweite (fig.);in einer anderen Liga (spielen) (fig.)
-(Das sind) große Worte!;musst du gleich wieder übertreiben?;geht's auch (ei)ne Nummer kleiner? (ugs., Spruch, fig., variabel);jetzt bleib mal (schön) auf dem Teppich! (ugs., fig.)
-etwas Vernünftiges;etwas Reelles;etwas Anständiges;etwas Gescheites;etwas Handfestes;etwas Solides;etwas Ordentliches
-sommers wie winters;zu jeder Jahreszeit;das ganze Jahr (hindurch)
-bei jeder Witterung;egal, welches Wetter wir gerade haben (ugs.);bei jedem Wetter;bei Wind und Wetter;egal, wie das Wetter ist;egal, welches Wetter gerade ist (ugs.)
-unvoreingenommen (sein);ohne Scheuklappen (fig.);mit offenen Augen durch die Welt gehen (fig., variabel)
-hinschauen;hingucken;nicht wegsehen;(die) Augen aufmachen (ugs.)
-über den Tellerrand schauen (fig.);offen für Neues (sein);neue Perspektiven gewinnen;Neues kennenlernen;(den) Blick weiten (geh., fig.);(seinen) Horizont erweitern (fig.)
-(ein) verhinderter (...) (männl.);(eine) verhinderte (...) (weibl.);wäre gern (...) geworden;hat(te) das Zeug zu (...)
-(jemandem) entgegenschlagen (fig., negativ);(jemandem) begegnen mit;(jemandem) (...) entgegenbringen;stoßen auf;(jemandem) entgegengebracht werden
-tragen(d sein) (fig.);(der) tragende Grund (fig.);(die) tragenden Säulen (fig.);Grundfeste (fig.);Fundament (fig.);Eckpfeiler (fig.)
-unter den Hammer kommen (ugs., fig.);versteigert werden
-Aggression;aggressive Aktion;Anfeindung;aggressiver Akt;Animositäten (Plural);verbale Attacke;feindselige Äußerung;Verbalattacke;Beschimpfung
-Angestrengtheiten (geh.);Verrenkungen (fig.);Klimmzüge (fig.)
-Koranvers;Sure (ugs.);Aya (fachspr., selten)
-von (...) übernommen;Anleihe (bei);Entlehnung
-(sich) empören;(einen) Aufstand machen (ugs., fig.);(den) Aufstand proben (fig.);(einen) Zwergenaufstand machen (ugs., scherzhaft)
-(es ist) Land unter;überflutet sein;überschwemmt sein;(es gibt) Überschwemmung (ugs.);vollgelaufen sein;abgesoffen sein (ugs., fig.);unter Wasser stehen;überspült sein
-im Eigentlichen;im engeren Sinne
-strukturschwach;wirtschaftsschwach;abgehängt
-israelisch-palästinensischer Konflikt;Israel-Palästina-Konflikt;Nahostkonflikt
-(den) Kohl (auch) nicht fett machen (ugs.);nichts bringen (ugs., salopp);nicht viel bringen (ugs.);(mit etwas) ist (auch) keinem geholfen;(auch) verzichten können auf (ugs.);nicht (richtig) weiterhelfen (ugs.);(es) kommt nichts (Gescheites) heraus (bei) (ugs.);wirkungslos verpuffen
-Protestant;Evangele (ugs.)
-gehalten sein (zu);(die) Anweisung haben;(jemandem) aufgetragen sein;nicht dürfen;sollen (/ müssen);angewiesen sein (zu);(jemandes) Auftrag sein;(jemandem) befohlen sein
-(die) Dolle (fachspr., technisch);Zapfen;Pflock;Pinn (norddeutsch)
-Pinneken;Metallstift;Stift;Holzstift;Holznagel;Stäbchen;Pinnchen
-Pinn(e)ken ziehen (ugs., norddeutsch);Streichhölzer ziehen;Pinnchen ziehen (norddeutsch);Stöckchen ziehen
-verlosen;durch Los entscheiden;per Losverfahren bestimmen (variabel);auslosen;durch Los ermitteln;(das) Los entscheiden lassen
-auswürfeln;würfeln um
-(eine) Münze werfen;durch Münzwurf entscheiden
-(künstlerische) Arbeit;(das) Schaffen;(das) Wirken
-Besucheransturm;Besucherandrang;Run auf (engl.);Massenandrang;Massenansturm
-aus einer Massenproduktion;Massenartikel;Dutzendware;Massenprodukt;Massenware
-Camenisch-Lysyanskaya-Signaturverfahren;CL-Signaturverfahren
-Generatormatrix;Erzeugermatrix
-(finanziell) stemmen (können);(etwas) finanzieren können;schaffen;(sich etwas) leisten können (Hauptform);drin sein (ugs.);das nötige Kleingeld haben (um zu) (ugs., fig.);möglich sein (ugs.);(bei jemandem) drinsitzen (ugs.);über das nötige Kleingeld verfügen (um zu) (ugs.);über die finanziellen Mittel verfügen (für etwas / um zu) (variabel);(die) finanziellen Möglichkeiten haben (um zu)
-Einnahmenüberschussrechnung;Einnahmen-Ausgaben-Rechnung (österr.)
-Setzholz;Setzstock;Pflanzstock
-nackte Tatsachen (ugs., scherzhaft);nackte Haut;(das) Nacktsein;Hüllenlosigkeit;Nacktheit (Hauptform);Nudität (fachspr.);Blöße
-ohne Frage;glatt;klar;eindeutig
-kaltschnäuzig;unverschämterweise;frechweg;glatt;frech;dreist;unverfrorenerweise
-(doch) tatsächlich;(doch) glatt
-Dauergast;Stammgast;ständiger Gast
-Kaninchenhunger;Kaninchen-Auszehrung
-Wehrmedizin;Militärmedizin
-(vorher) anwärmen;vorwärmen
-voneinander lösen;voneinander dividieren (geh.);auseinanderdividieren (geh.);auseinanderbekommen;voneinander trennen;auseinanderbringen
-Unfrieden stiften;gegeneinander ausspielen;polarisieren;(die) traute Harmonie (zer)stören (ironisch);gegeneinander aufbringen;(jemanden) einnehmen (gegen);spalten;(einen) Keil treiben (zwischen) (fig.);Misstrauen säen;entzweien;auseinanderbringen (fig.);Vertrauen(sverhältnis) (zer)stören;scheiden;(einander) abspenstig machen;aufeinander hetzen;für Unfrieden sorgen;gegeneinander aufhetzen;auf Abstand bringen (fig.);(einen) Keil treiben in (fig.);trennen;Zwietracht säen (geh.);(einander) entzweien;verfeinden;(miteinander) verfeinden;(einander) entgegensetzen
-ein Machtwort sprechen;für Ruhe sorgen;(einen) Streit beenden (kraft Autorität)
-(mit der Faust) auf den Tisch hauen (fig.);(sich) energisch durchsetzen
-(sich) gegenseitig verantwortlich machen;(sich) gegenseitig den schwarzen Peter zuschieben (ugs., fig.);(sich) gegenseitig die Schuld geben
-regional;in einzelnen Regionen;auf regionaler Ebene;gebietsweise
-lokal;stellenweise;örtlich;topisch (fachspr., griechisch);mancherorts;an manchen Stellen;vereinzelt;an manchen Orten
-antitschen (ugs., regional);leicht stoßen (gegen);titschen (gegen) (ugs., regional)
-loskriegen (ugs.);gelöst kriegen (ugs.);entfernt werden können;abbekommen;gelöst bekommen;losbekommen;abkriegen (ugs.);wegkriegen (ugs.)
-Ölfilm;(ölige) Schlieren
-prangen mit;stolz (einher)schreiten;paradieren (mit);prunken mit;zur Schau stellen;prahlen mit;protzen mit;angeben mit
-(fast) platzen vor Stolz;stolz wie ein Schwan;stolz wie ein Gockel;stolz wie Oskar (ugs.);stolz wie ein Spanier;stolz wie Bolle (ugs.);(stolz) wie ein Pfau;mächtig stolz
-bruchstückhaft;ohne Sinnzusammenhang;aus dem Zusammenhang gerissen
-Fundstelle;Quellenangabe;Quellennachweis;Beleg(stelle);Referenz;Literaturangabe
-(das) Zitiert-Werden;Zitat;Nennung;Zitierung;Zitation (fachspr.)
-h-Index (fachspr.);Zitierhäufigkeit;Hirschfaktor (fachspr.);Hirsch-Index (fachspr.)
-begleitende Information(en);Begleittext;mitgeliefertes Infomaterial;Handreichung
-kontextfrei;aus dem Zusammenhang gelöst;ohne (seine) Bezüge;isoliert (betrachtet)
-Hintergrundgeräusche;Atmo (fachspr., Jargon, variabel)
-Bonitätsauskunft;Bankauskunft;Bonitätsbewertung;Schufa-Auskunft
-schnell korrigieren;drübergucken (drüber gucken) (ugs., regional);drüberschauen (drüber schauen) (ugs.)
-bewundernswert;gekonnt;virtuos;mit Bravour;brillant
-genug der Worte;Der Worte sind genug gewechselt. (sprichwörtlich);Taten sehen wollen;wollen, dass (endlich) etwas passiert
-(der) soll mich kennenlernen! (variabel);der soll (mir) nur nach Hause kommen (ugs., variabel);(der) kann was erleben! (ugs., variabel);der kann sich auf was gefasst machen! (ugs., variabel);komm du mir (nur) nach Hause... (ugs., variabel);(dem) werd' ich was erzählen! (ugs., variabel)
-(sich) fortsetzen;bleiben;(so) weitergehen (es)
-(wie) weitergehen (es);(welche) Zukunft hat (etwas / jemand);(wie) sieht die Zukunft aus;als Nächstes kommen
-Krach schlagen;(gewaltig) Lärm schlagen;(einen) Aufstand anzetteln (ugs., fig.);(ein) Mordsspektakel veranstalten (ugs.);(ein) Höllenspektakel veranstalten (ugs.)
-Höllenmaschine (ugs., fig.);(sehr) laute Maschine
-Höllenmaschine (ugs., fig.);gefährliche Maschine
-kleinster gemeinsamer Nenner (fig.);Minimalkonsens
-Schadensbegrenzung betreiben;versuchen, die Schäden klein zu halten (ugs.);(das) Schlimmste (zu) verhüten (suchen)
-Kontrollblick;prüfender Blick
-angesehen werden als;laufen unter;gelten als;gehandelt werden als
-schrille Töne anschlagen (fig.);es übertreiben;überreagieren;hysterisch werden (fig.);übertrieben reagieren;zu heftig reagieren;in eine schrille Tonlage verfallen (fig.);in Hysterie verfallen (geh., fig.);(bei jemandem) zu einer Überreaktion kommen (es);übertrieben heftig reagieren
-(wahre) Fundgrube;unerschöpflicher Quell (an);Füllhorn (an)
-man kennt das von;(sich) erinnert fühlen (an);(...) lässt grüßen;man denkt (sofort) an
-seinerseits;von seiner Seite aus;von ihm
-Trennstab;Warentrenner;Trennholz;Warentrennstab
-Coniferales (fachspr., botanisch);Konifere(n) (fachspr., botanisch, Hauptform);Pinales (fachspr., botanisch, veraltet);Nadelgehölz(e) (fachspr., Hauptform);Nadelhölzer;Kiefernartige;Nadelholzgewächs(e)
-(sich) (einer Sache) rühmen;(sich) zu viel Ehre antun (geh.);(sich etwas) zugutehalten;(sich etwas) einbilden auf;(übertrieben) stolz sein auf
-(ein) Hoch;(auf) Erfolgskurs;hoch im Kurs stehen(d) (wörtlich);(im) Höhenflug (fig.)
-(der) Tropfen, der das Fass zum Überlaufen bringt (fig.);(ein) fehlendes letztes Bisschen;(noch ein) Schüppchen obendrauf (ugs., fig.);(der) letzte Rest
-erste Schritte (fig.);erste Gehversuche (fig.)
-(jemandem) den letzten Schlag versetzen;(jemanden) endgültig niederstrecken;(jemandem) die Lichter auspusten;(jemandem) den Rest geben
-von seinem Leiden erlösen;(den) Fangschuss geben;(den) Rest geben;(den) Gnadenschuss geben
-(jemanden) auf die Matte schicken (ugs., auch figurativ);k.o. schlagen;(jemanden) ausknocken (ugs.);(jemanden) wegklatschen (ugs.);bewusstlos schlagen;niederschlagen;zu Boden schlagen;(jemanden) zu Boden bringen (geh.);zu Boden strecken;zusammenschlagen;(jemanden) umhauen (ugs.);niederstrecken;(jemanden) flachlegen (ugs., ironisch);(jemanden) auf die Matte werfen (auch figurativ, variabel)
-individuell einrichten (Arbeitsumgebung PC);individuell anpassen;auf Kundenwünsche zuschneiden;personalisieren
-(sich) fragen, wie es weitergehen (soll);am Scheideweg (stehen);(sich) entscheiden (müssen)
-durch Feuer zerstört werden;vollständig verbrennen;niedergebrannt werden;(vollständig) abbrennen;in Flammen aufgehen;abgefackelt werden (ugs.);(ein) Raub der Flammen werden;durch Brand zerstört werden
-Vergeltungsschlag;Antwort (fig.)
-keine Widerrede!;keine Widerworte!;keine Diskussion!;ich insistiere! (geh.)
-(sich) hochschaukeln (fig.);(eine) Spirale (der Gewalt) in Gang setzen;(die) Spirale der Gewalt dreht sich weiter;eskalieren;(immer) schlimmer werden;(sich) aufschaukeln
-Binnennachfrage;Inlandsnachfrage
-(sofort) ins Auge springen (fig.);gleich (sehen);auf den ersten Blick (erkennen);(bereits) bei flüchtiger Inaugenscheinnahme;sofort (sehen);(etwas) sieht (doch) ein Blinder mit dem Krückstock (ugs., sprichwörtlich);(schon) bei flüchtiger Beurteilung
-(es besteht) Nachholbedarf;noch besser werden (müssen)
-Histamin-Intoleranz;Histaminose
-keine Schecks akzeptieren;Bargeld sehen wollen;keinen Scheck akzeptieren;auf Barzahlung bestehen;keine Kreditkarte akzeptieren;Bares sehen wollen
-immer (schön) daran denken (ugs., floskelhaft);(sich) etwas hinter die Löffel schreiben (ugs., fig., salopp);Lehre annehmen (veraltend);(sich) etwas gesagt sein lassen;gut aufpassen (fig.);(sich) etwas hinter die Ohren schreiben (fig.);(sich) etwas (gut) merken;nicht vergessen
-Subnotebook;kleines Notebook
-kleines (leistungsschwaches) Notebook (ugs.);Mini-Notebook (ugs.);Netbook
-handheld;nicht ortsgebunden;mobil;transportabel;portabel
-Schnellbäcker;Selbstbedienungsbäckerei;Schnellbäckerei;Backshop;Filialbäckerei;Backwarenfilialist (fachspr.);SB-Bäckerei
-Ladenlokal;Geschäftslokal;Etablissement (geh., franz.);Geschäftsräume;Lokal (vereinfachend) (ugs.)
-Kolonialwarengeschäft (veraltet);Lebensmittelladen;Lebensmittelgeschäft;Kolonialwarenladen (veraltet)
-Bäckereigeschäft;Brot- und Kuchengeschäft;Bäckerei;Brotgeschäft;Bäckerladen
-Delikatessengeschäft;Feinkostgeschäft
-viel Spaß bei der Arbeit!;hau rein! (ugs.);frohes Schaffen!
-Chinesische Changchun-Eisenbahn;Harbin-Eisenbahn;Transmandschurische Eisenbahn;Ostchinesische Eisenbahn
-Fajumporträt;Mumienporträt
-Sziklai-Paar;Komplementär-Darlington-Schaltung
-Artilleristischer Strich;Artilleriepromille (schweiz.)
-Missgeburt (abwertend);Monstrum;Monster
-genetischer Defekt;Gendefekt
-Mutagenese (fachspr.);Mutantenbildung;Erbgutveränderung
-teilen (durch);dividieren (durch)
-vorläufiges Ergebnis;Zwischenergebnis
-um jemandes Hand anhalten;um jemandes Hand bitten;anhalten (um jemanden);(jemandem) einen Antrag machen;(jemandem) einen Heiratsantrag machen;(jemanden) heiraten wollen (ugs.)
-(jetzt) hab dich nicht so! (ugs., Hauptform);(jetzt) mach dir (mal) nicht ins Hemd! (ugs., Spruch, salopp);(jetzt) sei kein Frosch! (ugs., Spruch);(jetzt) stell dich nicht (so) an! (ugs., Hauptform);(jetzt) mach dich (mal) nicht nass! (ugs.);du willst es doch auch! (ugs.);(jetzt) mach dir (mal bloß) nicht in die Hose! (ugs.);(jetzt) tu nicht so! (ugs.);komm schon! (ugs.);tu doch nicht so! (ugs.);(mach) keine Zicken! (ugs.);sei (doch) nicht so zimperlich! (ugs.)
-Reprint (fachspr., Jargon, engl.);Nachdruck
-neu übersetzt (von);Neuübersetzung
-Imprint-Auflage;Buchclubausgabe;Imprint-Ausgabe;Sonderausgabe
-(jemandem etwas) auf einem silbernen Tablett servieren (fig.);(den) willkommenen Anlass bieten (zu);(jemandem) eine Steilvorlage liefern (fig.);(jemandem etwas) auf dem Silbertablett servieren (fig.);(es jemandem) leicht machen (zu)
-(jemandem etwas) aus dem Kreuz leiern (ugs.);(jemandem etwas) abschmeicheln;(jemandem etwas) abschwatzen;(jemandem etwas) abluchsen;(so lange) belatschern (bis) (ugs.);(jemandem etwas) abspenstig machen;(jemandem etwas) entsteißen (ugs.);(sich) etwas erschmeicheln;(jemandem etwas) abschwätzen
-so spät (noch);zu unchristlicher Zeit (ugs., scherzhaft, variabel);um die Zeit (ugs.);so früh (am Tag);um diese Zeit
-Abbau;Herabsetzung;Minderung;Verminderung;Kürzung;Reduktion;Senkung;Dezimierung;Reduzierung;Verkleinerung;Beschneidung;Verringerung
-Gesundschrumpfen (verhüllend);Verschlankung (des Unternehmens) (verhüllend)
-(das) Personal reduzieren;(sich) gesundschrumpfen;(sich) verkleinern;Personal abbauen;Stellen abbauen;Stellen streichen;(die) Stellen zusammenstreichen (auf)
-absägen (ugs., salopp);rauswerfen (ugs.);im hohen Bogen rauswerfen (ugs., fig.);freisetzen (verhüllend);(jemanden) loswerden (ugs.);rausschmeißen (ugs., salopp);(jemanden) kündigen (Hauptform);freistellen (verhüllend);schassen (ugs.);feuern (ugs.);hochkant(ig) rauswerfen (ugs., variabel);(eiskalt) abservieren (ugs., salopp);entlassen;achtkantig rauswerfen (ugs., variabel);(jemandem) den Vertrag nicht verlängern (variabel);(jemandem) den Stuhl vor die Tür setzen (ugs., fig.);auf die Straße setzen (ugs., fig.);(sich jemandes) entledigen (geh.)
-PR-Frau (weibl.);PR-Mann (männl.);Imageberater;Spindoktor;Verantwortlicher für die Außendarstellung;PR-Verantwortlicher;Spin-Doctor
-Beschöniger;Tatsachenverdreher;Schönredner
-(sich etwas) in den Block diktieren lassen (fig.);bruchlos (übernehmen);eins zu eins (übernehmen);ohne daran Anstoß zu nehmen;keine Probleme haben mit
-muss man haben;unverzichtbar;obligatorisch (bildungssprachlich);(etwas) gehört auf jeden Fall dazu;(ein) Muss;(ein) Must-have (engl.)
-Wackelkontakt;Wackler (ugs.)
-Todesschlaf;Sopor (lat.);Präkoma;Topor (lat.)
-Schlafsucht (ugs.);Hypersomnie
-Stella Polaris;Angelstern;Polaris;Nordstern;Polarstern
-(das) Reiterlein;(der) Augenprüfer;Alkor
-Silikose;Quarzstaublunge
-Herzintelligenz;Herzgehirn
-Achtender (ugs.);Achtzylindermotor
-Sechszylindermotor;Sechsender (ugs.)
-Fünfender (ugs.);Fünfzylindermotor
-Zwölfender (ugs.);Zwölfzylindermotor
-Zehnender (ugs.);Zehnzylindermotor
-Vierzylindermotor;Vierender (ugs.)
-Dreizylindermotor;Dreiender (ugs.)
-Zweiender (ugs.);Zweizylindermotor
-in wenigen Minuten;Moment(chen);(es) kann sich nur noch um Stunden handeln (ugs., Spruch, ironisch, variabel);gleich;nachher;Augenblick bitte!;in einigen Minuten;(es) kann einen Moment dauern;in ein paar Minuten;(es) kann sich nur um (ein paar) Minuten handeln;Sekunde (ugs., fig.);warte (mal) kurz!;Momentchen (ugs.);(es) dauert einen Moment;nur eine Sekunde (fig.);warte (mal) einen Augenblick!
-Methanbildner;Methanogene
-(ein) paar Nummern zu klein sein (Kleidung);(aussehen wie eine) Quetschwurst (ugs.);spack (ugs., norddeutsch);(zu) eng (Kleidung);strämmen (ugs., berlinerisch);wie Leberwurst in Pelle (ugs.)
-(sich) die Jeans mit der Kneifzange anziehen (ugs., fig.);(sich) die Jeans mit der Kneifzange zumachen (ugs., fig.);(sich) quetschen in (Kleidungsstück) (ugs.);(sich) hineinzwängen;(sich) zwängen in;(sich) reinquetschen in (Kleidungsstück) (ugs.)
-unmittelbar anschließend;gleich anschließend (ugs.);gleich danach;direkt anschließend (ugs.);direkt im Anschluss;gleich darauf;gleich im Anschluss;auf dem Fuß(e) folgend (geh.);sofort im Anschluss daran;sofort danach;sofort anschließend;unmittelbar danach
-nicht wieder wegzukriegen (sein) (ugs.);gekommen (sein), um zu bleiben;nicht wieder wegzubekommen (sein);(sich) festsetzen;(sich) einnisten (negativ);nicht wieder loswerden (können) (ugs.);(sich) dauerhaft niederlassen
-Hungaristen;Pfeilkreuzler
-kalte Umschläge;Wadenwickel
-(etwas) nicht verstehen (Hauptform);nicht dahinterkommen (fig.);kein(en) Plan haben (ugs.);nicht folgen können (fig.);(für jemanden) ein Buch mit sieben Siegeln sein (ugs., Redensart);nicht kapieren (ugs., variabel);nur Bahnhof verstehen (ugs., fig.);(es) nicht blicken (ugs., fig., jugendsprachlich, variabel);nicht durchblicken (ugs., fig.);nicht durchsteigen (ugs., fig.);keine Peilung haben (ugs., fig.);(jemandem) zu hoch (sein) (ugs., fig.);vor lauter Bäumen den Wald nicht (mehr) sehen (Redensart);(für jemanden) böhmische Dörfer (sein) (fig.);(geistig) nicht mitkommen (fig.)
-Elektroneurografie;Elektroneurographie
-Elektromyographie;Elektromyografie
-(einen) entscheidenden Fehler machen;Scheiße bauen (derb);(etwas) verbrechen (ugs.);(es) versauen (derb);Mist bauen (ugs.);Mist machen (ugs.);(sich) in die Scheiße reiten (derb);(es) vermasseln (ugs.)
-(sinnlos) opfern;in den sicheren Tod schicken;verheizen (fig.);über die Klinge springen lassen (fig.);hinschlachten
-Indianerfrau;Squaw (engl.);Indianerin
-(jemand ist) zu nichts zu gebrauchen;(ein) hoffnungsloser Fall
-das wird kein Sonntagsspaziergang;da kommt was auf uns zu;mach dich auf was gefasst
-(planmäßiger) Verfahrensablauf;Spielregeln (fig.)
-(seinen ) Ruf nicht aufs Spiel setzten (wollen);einen Ruf zu verlieren haben
-Selbsthypnose;Autohypnose
-der (...) Typ (ugs.);von der (...) Sorte
-(sich) zwingen müssen (zu);(jemanden ...) Überwindung kosten (zu)
-Hinkebein (ugs.);kaputtes Bein (ugs.);verletztes Bein
-steifes Bein;Hinkebein
-entführen (Fahrzeug);entern (Schiff);hijacken (Fahrzeug) (engl.);kapern;in seine Gewalt bringen
-Siegelstempel;(das) Petschaft;Siegel
-(auf jemanden) aufpassen;(jemanden) hüten;ein Auge haben auf
-(sich) nicht outen;nicht dumm dastehen wollen
-(das ist) ewig lange her;vor sehr (sehr) langer Zeit (Hauptform);vor langer, langer Zeit;schon (echt) 'ne Weile her (ugs.);(das ist) schon nicht mehr wahr (so lange ist das her) (ugs., Spruch);vor einer halben Ewigkeit (ugs.);vor ewig langer Zeit;vor Ewigkeiten (ugs.);vor Unzeiten (ugs.);(das ist) sehr lange her;lang, lang ist's her (Spruch)
-geistige Nahrung;(anspruchsvolle) Lektüre;geistige Kost
-von der Geburt bis zum Tod;solange jemand lebt;von der Wiege bis zur Bahre
-Die Zeit heilt alle Wunden. (Sprichwort);(etwas) braucht seine Zeit
-schieß los! (ugs., fig.);raus damit! (ugs.);spuck's (schon) aus! (ugs., fig.);lass hören! (ugs.);(dann) klär mich auf!;jetzt sag schon!;erzähl schon!;erzähl!;nun sag!
-(ich hab schon) verstanden;ist angekommen;schon klar
-witzig sein;Humor haben
-(etwas wird noch einmal) ein böses Ende nehmen (variabel);(etwas wird) ein schlimmes Ende haben (variabel);nicht gutgehen;nicht gut ausgehen;(das wird) kein gutes Ende nehmen (variabel);(das wird) böse enden (scherzhaft)
-tu's nicht;vergiss es (einfach);lass die Finger davon (fig.)
-(ungeplanterweise) hinzukommen;dazustoßen;auf der Bildfläche erscheinen
-Country & Western (engl.);Westernmusik (ugs.);Cowboymusik (ugs.);Country-Musik;Country
-in Echtzeit;augenblicklich
-vorhaben;im Schilde führen;geplant haben
-aufbrechen;ausrücken;ausfahren;abmarschieren;zu einem Einsatz gerufen werden
-Kampfansage (fig.);Herausforderung;Kriegserklärung (fig.);offene Gegnerschaft;Affront (geh., bildungssprachlich, franz.)
-durchdrehen;hysterisch werden;Zustände kriegen (ugs.);am Rad drehen (ugs., fig.)
-Kasperletheater;Kaspertheater;Kasperltheater
-Mist... (ugs.);blöd (ugs., aggressiv);mies (ugs.);verfickt (vulg., aggressiv);verdammt (ugs., aggressiv);verflucht (ugs., aggressiv);beschissen (ugs., aggressiv);Scheiß... (derb, aggressiv);bescheuert (ugs., aggressiv)
-verpassen;erteilen (Amtsdeutsch);geben
-war's das (jetzt)? (ugs.);ist noch was? (ugs.);kann ich jetzt (endlich) gehen? (ugs.);(war) sonst noch was? (ugs.);war das alles?
-seinen Platz im Leben gefunden (haben);seine wilde Zeit hinter sich (haben);gestanden (Mann, Frau, Persönlichkeit);(sich) die Hörner abgestoßen (haben);mit Erfahrung
-ganz (Zeitdauer);voll (Zeit);sage und schreibe (...) lang;geschlagen (Dauer) (Hauptform);über sage und schreibe (...) hinweg
-(sich) hocharbeiten;(sich) hochdienen (mil. oder im Staatsdienst)
-Karnevalssession;Fastnachtssession;Karnevalskampagne;Karnevalszeit;Fastnachtszeit;Fastnachtskampagne
-gesellschaftsfähig;(sich) sehen lassen können (mit);vorzeigbar (Hauptform);anständig (ugs.);präsentabel (geh.)
-mit Rat und Tat (unterstützen);in Worten und Taten (beistehen) (geh.);aktiv (mithelfen)
-Werkbank;Hobelbank
-Arbeitstisch;Werktisch
-Fahrradsitz;Velosattel (schweiz.);Fahrradsattel;Radsattel
-von der Pike auf (lernen);ganz unten anfangen;ganz klein anfangen
-Verlauf des Tatgeschehens;Verlauf der Tat;Tathergang
-Unrecht;Tort (geh., veraltend);Gesetzwidrigkeit;Ungerechtigkeit
-Sündenpfuhl;Hort des Lasters;Brutstätte des Lasters;Lasterhöhle
-Stätte des Lasters;Ort der Sünde;wie Sodom und Gomorrha;(ein) Sündenbabel
-verrucht;sündig;liederlich;verderbt;verdorben;versaut (ugs.);(moralisch) verkommen;sittenlos;verworfen;(sittlich) verwahrlost;lasterhaft
-Anekdote;(kurze) pointierte Geschichte
-Short Story;Kurzgeschichte;Kurzerzählung
-Schauerballade;Moritat;Bänkellied;Bänkelsong
-Erzählgedicht;Ballade
-nicht zu Hause (hocken) bleiben;um die Häuser ziehen (ugs.);losziehen;auf die Piste gehen (ugs., fig.);nicht zu Hause versauern;(etwas) erleben wollen
-Abfahrt;Hang;Piste;Skipiste
-Ganymedes;Ganymed
-ich muss!;die Arbeit ruft (ugs.);die Pflicht ruft;Die Arbeit erledigt sich nicht von selbst (/ von allein). (ugs., Gemeinplatz);ich werde (auch noch) woanders gebraucht;ich hab(e) zu tun
-da sagen Sie mir nichts Neues;das weiß ich auch! (ugs.);(ja na) sicher! (ugs.);da sagst du mir nichts Neues;Sie sagen es!;das weiß ich selbst!;(aber) natürlich! (ugs.);Wem sagst du das!;Wem sagen Sie das!;(aber) selbstverständlich!;kennen wir (ugs.);man kennt das (ugs.);(das) versteht sich (von selbst)
-Küsten-Sequoie;Küstenmammutbaum;Sequoia sempervirens (fachspr., botanisch)
-(einen) Erfolg erzielen;(einen) Volltreffer landen
-(ein) Erfolg;(ein) Treffer;(ein) Volltreffer;(ein) Triumph;(ein) großer Wurf;(großartige) Leistung;(der) Durchbruch;Heldentat (halb-scherzhaft)
-voller Erfolg;Erfolg auf der ganzen Linie;glatter Durchmarsch (fig.)
-(jemandem) nicht das Wasser reichen können (fig.);nicht herankommen an (jemanden);(jemandem) deutlich unterlegen sein;(jemandem etwas) nicht streitig machen (können)
-Korrigenda (geh., lat.);Druckfehler;Errata (geh., Plural, lat.);Corrigenda (geh., lat.);Erratum (geh., lat.)
-Amts- und Seelsorgebereich eines Vikars (Stv., in allen Ebenen) (kath.);Vikariat;praktische Ausbildungszeit für Pfarrer (evang.)
-Fr. (Abkürzung);CHF (Abkürzung);Franken;Schweizer Franken;Stutz (ugs., schweiz.)
-Liebesschnulze (ugs., abwertend);romantische Komödie;Liebesfilm;Romanze
-mit dem zufrieden sein (müssen), was man bekommt;(alles) nehmen was man kriegt (ugs.)
-beschicken;ausstatten;beaufschlagen
-(im) Kindesalter;Kindheitstage;Jahre als Kind;Kindheit (Hauptform);(Jahre) bis zum Schuleintritt;(jemandes) erste Lebensjahre;Kinderzeit
-benennen;einer Sache einen Namen geben;dem Kind einen Namen geben (ugs., fig.);bezeichnen;benamsen (ugs.)
-hadern mit;zu kämpfen haben mit;ächzen unter;zu leiden haben an;die schwere Last (einer Sache) tragen;schwer tragen an;seine liebe Last haben mit
-üppig (sprießend);voll (z.B. Haar);dicht
-tumultuos (geh.);tumultuarisch (geh.);tumultuös (geh.);tumultartig;turbulent
-(jemanden) auf der Matte stehen haben (ugs., fig.);(sich) wenden an (mit einem Anliegen);bei jemandem auf der Matte stehen (fig.);zu jemandem (an)gelaufen kommen;(sich) melden bei;kommen wegen (ugs.)
-Showdown (auch figurativ, engl.);Endkampf;Entscheidung (fig.);letztes Gefecht;finaler Schlagabtausch;Entscheidungskampf;letzte Runde;Entscheidungsschlacht (militärisch)
-breit aufgestellt (sein);(eine) große Auswahl (haben)
-mit viel Zulauf;massenwirksam
-Lebensschutzbewegung;Abtreibungsgegner;Lebensrechtsbewegung
-Schoppensalamander;Salamander
-Alter Herr (Studentenverbindung);Philister
-Altherrenschaft;Philisterium
-Trauersalamander;Totensalamander (schweiz.)
-Studentinnenverbindung;Damenverbindung
-zustimmend den Kopf senken;nicken
-konjugieren;(Verb) flektieren;(Verb) beugen
-(ein) gutes Wort einlegen (für);Fürsprache halten (für);(sich) verwenden (für);(eine) Lanze brechen (für) (fig.);(sich) ins Zeug legen (für);eintreten (für);(sich) einsetzen (für);(sich) stellen (hinter);(sich auf jemandes) Seite stellen
-(den) Hut ziehen;(den) Hut lüften
-(sich) die Hände schütteln;(jemandem) die Hand geben;(jemandem) die Hand schütteln;(jemandem) die Hand zum Gruß(e) reichen (geh.)
-winken;(jemandem) zuwinken;(die) Hand zum Gruß(e) heben;winke winke machen (ugs.)
-(einen) Knicks machen;knicksen
-(sich) mit zwei Fingern an die Stirn tippen (variabel);(militärisch) grüßen (Hauptform);(die) Hand an den Mützenrand legen (variabel);(die) Hand an die Schläfe legen (variabel);salutieren (Hauptform)
-(jemanden) anlächeln;(jemandem) zulächeln
-Europäische Gesellschaft;SE (Abkürzung);Europa-AG (ugs.);Societas Europaea (lat.);Europäische Aktiengesellschaft
-Szenenbuch;Storyboard
-Schwimmmeister;Badmeister (schweiz.);Bademeister (ugs.)
-Laserauftragschweißen;Pulverauftragschweißen
-Cladding;Auftragschweißen
-Hotelsuite;Suite;Appartement (franz.)
-halbmast;halbstocks
-ohneeinander;ohne den anderen
-strahlen;scheinen;lachen (Sonne) (ugs., fig.)
-Enduro;Geländemotorrad
-Engramm;Erinnerungsbild
-Nervatur (fachspr.);Aderung;Adern (ugs., Plural)
-(etwas) schnell laufen lassen (durch);(etwas) jagen durch (ugs., fig.)
-terrestrisch;irdisch;erdgebunden;landgestützt
-bis aufs Messer kämpfen;erbittert kämpfen;(sich) bis aufs Messer bekämpfen (auch figurativ);(sich) gnadenlos bekämpfen
-als Sieger hervorgehen aus;siegreich vom Platz gehen;als Sieger vom Platz gehen
-Übermüdung;Müdigkeit;Schlafdruck;Schläfrigkeit;Schlafbedürfnis
-(es) vorne und hinten hereingesteckt bekommen (derb);verwöhnt werden
-zu vermuten sein (Hauptform);vermutet werden dürfen;(jemanden) zu der Annahme berechtigen (dass);(es) spricht einiges dafür;scheinen (dass);annehmen dürfen;(es) spricht einiges für die Annahme (dass);nicht von der Hand zu weisen sein (geh.);zu vermuten stehen (geh.);(die) Annahme ist berechtigt
-Magengeschwür;Ulcus ventriculi (fachspr., medizinisch)
-Hornhautgeschwür;Ulcus corneae (fachspr., medizinisch)
-Unterschenkelgeschwür;Ulcus cruris (fachspr., medizinisch);offenes Bein (ugs.)
-Duodenalulkus (fachspr., medizinisch);Ulcus duodeni (fachspr., medizinisch);Zwölffingerdarmgeschwür
-Dünndarmgeschwür;Ulcus jejuni (fachspr., medizinisch)
-weicher Schanker;venerisches Geschwür;Ulcus molle (fachspr., medizinisch)
-unsicher (sein);ungewiss (sein);auch anders (kommen können) (ugs., variabel);nicht unbedingt zutreffen (müssen);nicht stimmen müssen (ugs.);nicht gehen können nach (ugs.);nicht sicher (sein);nicht gesagt (sein) (ugs.)
-(tief) ausgeschnitten;dekolletiert;offenherzig (fig.)
-Einsetzung;Amtseinführung;Inauguration (geh.);Einführung;Installation (geh.);Amtseinsetzung;Investitur (geh.);Besetzung
-von zwei Seiten angreifen;in die Zange nehmen (fig.);von zwei Seiten (her) bedrängen
-AEUV (Abkürzung);AEU-Vertrag;Vertrag über die Arbeitsweise der Europäischen Union
-unüberlegt daherreden;(etwas) raushauen (ugs., salopp);(Sprüche) rauslassen (ugs., salopp);(Sprüche) ablassen (ugs., salopp)
-(sich) erwärmen (für);lieb gewinnen;liebgewinnen;(sich) anfreunden (mit);warm werden (mit);Gefallen finden (an)
-Rat der Europäischen Union;Rat;EU-Ministerrat (inoffiziell)
-Kaufkraft;Geldwert
-(der) Haussegen hängt schief (Redensart);es gibt Stunk zu Hause (ugs., variabel)
-(übertrieben) hilfsbereit (sein);(am) Helfersyndrom (leiden)
-(jemandem) Vergnügen machen;(jemanden) beglücken (geh.);(jemandem) Spaß machen;Pläsier machen (geh., veraltet);da kommt Freude auf (ugs.);Freude haben (an/mit);(jemandem) Freude machen;(ein) Genuss sein;(etwas) gerne (tun);(seinen) Spaß haben (an/mit);(jemandem) Vergnügen bereiten;(jemandem) Vergnügen bescheren;(sich) erfreuen an;(eine) Freude sein;(ein) Vergnügen sein;(jemanden) erfreuen;(jemanden) freudig stimmen (geh.)
-Fundgegenstand;Fundobjekt;Fundstück;gefundener Gegenstand;Fund
-(jemandes) Werben erliegen (geh., floskelhaft, veraltend);(jemandem) zu Willen sein (geh., veraltet);(jemandes) Drängen nachgeben
-(jemandes) Gunst gewinnen (geh.);(jemanden) für sich gewinnen;(jemanden) für sich einnehmen;(jemanden) erobern
-um Geld bitten;Geld haben wollen;die Hand aufhalten (ugs., fig.);nach Geld fragen
-primus inter pares (lat.);Erster unter Gleichen
-mit einer Frau zusammen sein;(ein) Date haben;mit einem Mann zusammen sein
-Kniebeuge;Niederknien
-depressiv;Depressions...;Depri... (ugs.)
-(sich etwas) verbauen;(sich) die Chance nehmen;(etwas) verunmöglichen;(etwas) unmöglich machen;(sich) die Möglichkeit nehmen
-Stuckateur;Stuckarbeiter;Stuckkünstler;Gipser;Verputzer;Putzer
-Croissant (franz.);Beugel (bayr.);Kipfel (österr.);Hörnchen;Gipfel (schweiz.)
-(ganz schön) auseinandergehen;(sehr) dick werden;aufgehen wie ein Hefekuchen (ugs.);(sehr) in die Breite gehen;(zu stark) zunehmen;mehr werden (ironisch);aus der Form geraten;aufgehen wie ein Hefekloß (ugs.);kräftig zulegen
-Preisabzug;Nachlass;Preisermäßigung;Preisabschlag;herabgesetzter Preis;Abzug;Preissenkung;Sonderpreis;Abschlag;Rabatt;Aktionspreis;Preisnachlass
-Barzahlungsnachlass;Abzug vom Rechnungsbetrag;Rechnungsabzug (bei Einhaltung der Skontofrist);Skonto
-hat ihr Idealgewicht;hat sein Idealgewicht;normalgewichtig
-vogelfrei;Freiwild;zum Abschuss freigegeben;auf der Abschussliste;auf der Todesliste
-zum Abschuss freigeben;für vogelfrei erklären
-Todesfatwa;Mordaufruf
-(jemanden) entschuldigen;(jemanden) diskulpieren (veraltet)
-(bei jemandem in bestimmter Weise) ankommen;(in bestimmter Weise) rüberkommen (ugs.);(auf jemanden in bestimmter Weise) wirken;(in bestimmter Weise) aufgenommen werden
-Autoinfektion;endogene Infektion
-Hyperinfektion;Superinfektion;Suprainfektion
-Primärinfektion;Erstinfektion
-Zweitinfektion;Sekundärinfektion
-Candidosis;Candidiasis;Kandidamykose;Kandidose;Candidamycosis
-Soor;Moniliasis (veraltet)
-Humanes Cytomegalievirus;Zytomegalievirus;Humanes Herpes-Virus 5;Cytomegalievirus
-DNA-Virus;DNS-Virus
-Doppelinfektion;Koinfektion
-Humanes Herpesvirus Typ 8;Kaposi-Sarkom-Herpesvirus
-Protozoonose;Protozoeninfektion
-Mistress (...);Zuchtmeisterin;Domse (ugs., Jargon);Gebieterin;Domina;Herrin
-Krankenhausinfektion;nosokomiale Infektion
-Reizdeprivation;sensorische Deprivation;Reizentzug
-Ateminsuffizienz;respiratorische Insuffizienz
-Säuglingsklinik;Säuglingsheim
-Ober;Oberkellner
-Kapo (ugs., Jargon);Kapodaster
-See-Elefant;Mirounga angustirostris (Nordamerika) (fachspr.);Mirounga (fachspr.);Seeelefant;Mirounga leonina (Subantarktis) (fachspr.)
-Klagedrohung;Klagsdrohung (österr.)
-zwischenmenschliche Beziehung;soziale Beziehung
-herausfinden, womit alles anfing;(einer Sache) auf den Grund gehen;(die) Ursprünge ermitteln;restlos aufklären;zurückverfolgen;(die) Ursache (heraus)finden
-Standardmessunsicherheit;Messunsicherheit;Unsicherheit;Standardunsicherheit
-Dimensionsbetrachtung;Dimensionsprobe;Einheitenbetrachtung
-es gibt nicht nur eine Lösung;Viele Wege führen nach Rom. (sprichwörtlich)
-Zitrusfrucht;Agrumen (fachspr., Plural, ital.);Agrumi (fachspr., Plural, ital.);Zitrusfrüchte (Plural)
-Kölner Dom (Hauptform);Hohe Domkirche St. Petrus;Hoher Dom zu Köln;Dom zu Kölle (ugs., kölsch)
-Bierkellner;Köbes (ugs., kölsch)
-Friendly Fire (engl.);Eigenbeschuss
-Gemurmel;Rhabarber (ugs.);Mussitation (fachspr., medizinisch);Raunen
-Wutzwerg;Rumpelstilzchen
-(sich) merken;nicht vergessen;denken (an)
-(etwas) in Arbeit haben;in (der) Bearbeitung haben;an etwas arbeiten (ugs.);bearbeitet werden
-(jemandem) sind die Hände gebunden (fig.);(aber) gut, dass wir (mal) d(a)rüber gesprochen haben (ugs., Spruch, zynisch);(sich) nicht wehren können;nichts in der Hand haben (gegen) (fig.);nichts machen können;nichts unternehmen dürfen (in);keine Handhabe haben, um gegen etwas anzugehen;tatenlos zusehen müssen;nichts tun dürfen (in einer Sache);nicht handlungsfähig sein
-(jemandem etwas) in die Hände spielen;dafür sorgen, dass jemand etwas erfährt;dafür sorgen dass etwas in jemandes Hände gelangt;(jemandem etwas) zuspielen
-(sich) ins Benehmen setzen mit (förmlich);(etwas) an (jemanden) vorbeitragen (ugs.);(sich) arrangieren (mit);(sich) abstimmen (mit);(sich) absprechen;(sich) verständigen
-im Einvernehmen mit;in Absprache mit;in Abstimmung mit;im Benehmen mit
-ungute Ahnungen;schlimme Befürchtungen
-Synthesizer;Synthi (ugs.)
-Elektrophon;Elektrofon
-Bußtag;Buß- und Bettag
-Textverarbeitungsprogramm;Schreibprogramm (ugs.);Textverarbeitung;Textverarbeitungssoftware
-Morgenstund ist aller Laster Anfang. (ironisch);Der frühe Vogel kann mich mal. (ironisch)
-Cognac;Weinbrand;Kognak
-wenn (...) denn (geh.);wenn (...) überhaupt;so (...) denn (geh.);soweit (...) überhaupt;sofern (...) überhaupt
-Street-Art;Street Art (engl.);Straßenkunst;Straßenmalerei;Streetart
-Milchmixgetränk;Milchmischgetränk
-Milkshake (engl.);Milchshake
-(etwas ist) kein Wunder;(schon) gerechnet haben mit;vorauszusehen sein;nicht wirklich eine Überraschung sein (ugs.);wen wundert's! (Spruch);was Wunder, dass (...);nicht weiter verwunderlich sein;wenig überraschend kommen;wenig überraschen;nicht überraschen;zu erwarten sein;abzusehen sein;(sich) (an drei Fingern) ausrechnen (können) (ugs., variabel)
-Beletage (fachspr., franz.);erster Stock;erste Etage;Hauptgeschoss
-Tablet-PC;Tabletcomputer;Flachrechner;Tablet-Computer;Tablet
-I-Pad;iPad (Markenname)
-iPhone (Markenname);I-Phone
-standhaft bleiben;standhalten;nicht nachgeben;(einer Versuchung) nicht erliegen;widerstehen
-es auf die nette Tour versuchen (ugs.);versuchen, freundlich rüberzukommen (ugs.);(eine) Charmeoffensive (starten)
-(sich) nicht zu viel vornehmen dürfen;nicht auf zwei Hochzeiten (gleichzeitig) tanzen können (fig.);(sich) auf eine Sache konzentrieren müssen
-Sexen (fachspr.);Geschlechtsbestimmung (Küken)
-Ganzfruchtgetränk;Smoothie (engl.)
-auf mehreren Hochzeiten tanzen (ugs., fig.);(sich mehrere) Möglichkeiten offen halten;(mehrere) Eisen im Feuer haben (fig., variabel)
-Schienenbus;Schienenomnibus;Schienenautobus (veraltet)
-Lieblingsthema;Thema Nummer eins;beliebtestes Thema;wichtigstes Thema;Thema Nummer 1;das, worüber alle sprechen
-Vorbau;Erker;Auslucht;Fassadenvorbau
-Veranda;Terrasse;Beischlag (fachspr.)
-wenig Kontakt nach außen haben;Umgang (nur) mit seinesgleichen pflegen;wenig(e) Kontakt(e) außerhalb der (eigenen) Clique haben;unter sich bleiben
-(die) Schule abbrechen;nicht mehr hingehen (Schule) (ugs.);keinen Schulabschluss machen;keinen Abschluss machen;(die) Schule schmeißen (ugs.)
-Flugbahnwagen;Schienenzeppelin
-Trans-Europ-Express;TEE
-Transrapid (Markenname);Magnetschwebebahn;Magnetbahn
-Bismarckdenkmal;Bismarckturm
-einscannen;einlesen;erfassen
-einscannen;über den Scanner ziehen
-Veresterung;Esterbildung
-Glykogen (fachspr.);tierische Stärke;Glycogen;Leberstärke
-Mehrfachzucker;Glykane;Polysaccharid;Polyosen;Vielfachzucker;Glycane
-Acetylameisensäure;Brenztraubensäure
-Ketocarbonsäure;Ketosäure;Oxosäure
-Glukoneogenese (latinisiert);Gluconeogenese
-2-Hydroxypropionsäureethylester;Milchsäureethylester;Ethyllactat
-Italianisierung;Italienisierung
-Burschensprache;Studentensprache
-anaerobe Schwelle;Laktatschwelle;aerob-anaerobe Schwelle
-Laktat;Lactat
-Milchsäure;2-Hydroxypropionsäure;2-Hydroxypropansäure
-Oxysäure (veraltet);Hydroxysäure;Hydroxycarbonsäure
-Carboxygruppe;Carboxylgruppe (veraltet)
-Verkehrszeichenbrücke;Wegweiserbrücke;Schilderbrücke
-Abstellstreifen (schweiz., österr.);Seitenstreifen
-wurde;ward (geh., literarisch)
-(irgendwie) verfahren (mit);(etwas) (irgendwie) handhaben;(irgendwie) umgehen mit;(irgendwie) laufen (es) (ugs.)
-LED-Birne (ugs.);LED-Lampe;LED-Glühbirne;LED-Leuchtmittel
-entsprechend (Adjektiv);respektiv (Adj.) (regional);je eigen (geh.);jeweilig (Adj.) (Hauptform)
-zudringlich werden (Hauptform);sexuell belästigen (fachspr., Hauptform, juristisch);(jemanden) antatschen;(jemandem) an die Wäsche gehen (ugs.);angrabschen (ugs.);(jemandem) auf die Pelle rücken (ugs., fig.);betatschen (ugs.);begrabschen (ugs.)
-alluviale Seife;Flussseife
-(erfolglos) hängenbleiben;stranden
-zyklomatische Komplexität;McCabe-Metrik
-Softwaremetrik;Metrik
-noch eben schnell;noch flugs;noch schleunig(st)
-Anklang;Affinität;Reminiszenz
-Dalian-Yantai-Tunnel;Bohai-Tunnel
-ausgepumpt;ausgepowert;hat alles (aus sich) rausgeholt (ugs.);kann nicht mehr;hat sich (völlig) verausgabt;hat seine letzten Reserven mobilisiert;hat alles gegeben
-bequem;spielend (einfach);(sehr) einfach;leicht;ohne großen Aufwand;unschwer;gäbig (schweiz.);mühelos;ohne weiteres
-Baumsteigerfrosch;Farbfrosch;Pfeilgiftfrosch
-Froschlurche;Anura
-Schultergürtel-Kompressionssyndrom;Engpasssyndrom der oberen Thoraxapertur
-Kompressionssyndrom;Crush-Syndrom
-Systemerkrankung;systemische Erkrankung
-Vergünstigung;Privileg;Vorzug;Vorteil;Gunst
-Besserstellung;Bevorzugung;Privilegierung;Begünstigung;Ausstattung mit Privilegien
-Vortritt (fachspr.);protokollarische Rangordnung;Präzedenz (fachspr.)
-(ein) vorheriger Fall;hat es vorher schon gegeben;Präzedenzfall (fig.)
-Kleinwuchs;Minderwuchs;Mikrosomie;Kleinwüchsigkeit;Zwergwuchs (ugs., abwertend)
-Vorlage;Modell;Muster;Blaupause (fig.)
-(jemandes) Beispiel folgen;(etwas) nachmachen;(etwas) (genau) so machen wie
-bestes Beispiel (ist) (ugs.);klassisches Beispiel;typisches Beispiel
-prägnant;treffend;überzeugend;eindeutig;treffsicher;aussagekräftig
-griffig;auf eine einfache Formel gebracht;kurz und knackig;unkompliziert
-keine gute Meinung haben (von);nicht gut zu sprechen sein (auf)
-Klangbeschaffenheit;Klangwirkung;Akustik (eines Raums)
-Werwolf;Wolfsmensch
-Sagengestalt;Märchengestalt;Märchenfigur
-Schneeweißchen;Schneewittchen
-Augenkrankheit;Augenerkrankung
-Hippus;(krankhaftes) Augenzwinkern
-Augenentzündung;Ophthalmie
-Opiophagie (fachspr., medizinisch, veraltet);Opiumsucht
-deminutiv (geh., selten);diminutiv (fachspr.);verkleinernd;diminuierend (fachspr., bildungssprachlich)
-Herkulesarbeit;gewaltige Anstrengung;unter Aufbietung aller Kräfte;Kraftakt;Mobilisierung aller Reserven (variabel)
-Voraussetzungen;Kontext;(politische) Landschaft;Umfeld;Rahmenbedingungen (Hauptform)
-Käsemauken (ugs., abwertend);Quanten;Läufer;Füße;Käsefüße (ugs., abwertend)
-Gifthauch (geh., literarisch);Pesthauch (geh., literarisch);übler Dunst;Miasma (fachspr., historisch, veraltend)
-Stimulans;Genussmittel;Stimulanzien (Plural)
-Pfeife;Tabakspfeife
-Nikotin;Nicotin (fachspr.)
-(auf einmal) weg;(plötzlich) nicht mehr da;(fort) wie weggeblasen
-Couchgarnitur;Sitzgruppe;Polstergarnitur;Sitzlandschaft
-Plätzli (schweiz.);Schnitzel
-Paprikaschnitzel;Zigeunerschnitzel (ugs.);Balkanschnitzel;Pusztaschnitzel
-Strich;(auf) Anschaffe (ugs.);Straßenstrich
-siderisch;sideral;sternbezogen
-Facebook (Markenname);Facebook Inc.
-Schaukel (Hauptform);Hutsche (bayr., österr.);Gautsche (süddt.)
-Schiffsschaukel;Schiffschaukel
-Hochschaubahn (österr.);Berg-und-Tal-Bahn;Achterbahn
-Info;Notiz;Nachricht;Benachrichtigung;Memo;Stellungnahme;Mitteilung;Meldung
-Schaubude;Jahrmarktsbude;Spielbude
-Kinderbilderbuch;Bilderbuch
-Wimmelbuch;Wimmelbilderbuch
-Alltags...;Normal...;Gebrauchs...
-sollte lieber nicht;(es wäre) unvernünftig (von jemandem);(jemand wäre) schlecht beraten (wenn);(es wäre) unklug (von jemandem);sollte besser nicht;(etwas wäre) nicht anzuraten (geh.)
-Extremheit;Ausgeprägtheit;Extremität;Extremsein
-Krankhafter Zwang Geschenke zu machen;Doromanie
-Wärmeleitschweißen;Wärmeleitungsschweißen
-Boxauto (süddt.);Putschauto (schweiz.);Autoskooter;Autoscooter;Autodrom (österr.)
-Kettenflieger;Kettenkarussell;Kettenprater
-nichts sparen können;nur das Notwendigste haben;(sich) nur mit dem Notwendigsten versorgen (können);von der Hand in den Mund leben (fig.)
-Erspartes;Zurückgelegtes;Notgroschen (fig.);gespartes Geld;Ersparnis(se);zusammengespartes Geld;Spargroschen (fig.);(finanzielle) Reserve;Rücklage(n)
-Sparguthaben;Sparbetrag;Spareinlage
-Sparaufkommen;(die) Sparguthaben aller (...);Summe aller Sparguthaben
-Aktivposten;positiver Saldo;auf der Habenseite;(im) Haben;(im) Plus;Guthaben
-Zugewinn;Bereicherung;Aktivposten (fig.);Verstärkung;(Punkt) auf der Haben-Seite (fig.);Pluspunkt
-Heermannie (veraltet);Heerbann
-besagend, dass;mit dem Inhalt, dass;mit der Aussage, dass;des Inhalts, dass (geh., Amtsdeutsch, juristisch)
-als Dritte(r);der dritte Beteiligte;(unsere) Nummer drei;der Dritte im Bunde (variabel)
-last but not least (engl.);schließlich;zum guten Schluss;nach dem Motto 'das Beste kommt zum Schluss';und dann wäre da noch;zu guter Letzt;(und) schließlich (...) noch;(ganz) zuletzt
-Flughörnchen;Gleithörnchen (fachspr.);Pteromyinae (fachspr., griechisch)
-Gestationshypertonie;schwangerschaftsinduzierte Hypertonie;Schwangerschaftshypertonie
-Spätgestose (veraltet);EPH-Gestose (veraltet);Präeklampsie;Schwangerschaftsintoxikation (veraltet)
-in sich hinein lächeln;schmunzeln;vor sich hin lächeln
-(etwas) nicht unterdrücken können;nicht anders können und (einfach ...) müssen;unwillkürlich (...) müssen
-Anteilschein;Anteilsschein;Aktie
-favorisieren;(da) lobe ich mir (doch);(es) vorziehen (zu);(einer Sache) den Vorzug geben;lieber wollen;(eine) Präferenz haben (für);bevorzugen;präferieren (geh.);besser finden;lieber haben;es vorziehen zu;(da) loben wir uns (doch);(etwas) vorziehen;lieber mögen;lieber (tun)
-Dow (ugs.);Dow Jones Industrial Average (engl.);DJIA (Abkürzung, engl.);Dow Jones
-MDAX (Abkürzung);Midcap-DAX (engl.)
-SDAX (Abkürzung, engl.);Smallcap-DAX (engl.)
-exchange-traded fund (engl.);börsengehandelter Fonds;ETF (Abkürzung);Exchange-traded Fonds;Indexfonds
-Geldvorrat;Reserve;Geldbestand;Geldmittel;Fonds;Vermögensreserve
-Anleihenfonds;Rentenfonds
-(jemandes) Idee (gewesen) sein;(sich) etwas ausgedacht haben;auf jemandes Mist gewachsen sein (fig.)
-Aprikosenbrand;Marillenschnaps (österr.);Aprikosenschnaps;Abricotine (schweiz.);Marillenbrand (österr.)
-culture clash (engl.);Aufeinanderprallen der Kulturen;Aufeinanderprallen von Kulturen
-Culture-Clash-Komödie;Culture-Clash-Comedy;Fish-out-of-water-Komödie (fachspr.);Kulturschock-Komödie
-falsche Entscheidung;Fehlentscheidung
-Schüttelwort;Letterwechsel;Buchstabenrätsel;Anagramm;Letterkehr
-Verschlossenheit;Verschlossensein
-on demand (engl.);auf Verlangen;auf Bestellung
-Monsun;Monsunwind
-Desktop (ugs.);GUI (Abkürzung, engl.);Grafische Benutzungsoberfläche (fachspr.);Benutzeroberfläche (ugs., Hauptform);Bedienoberfläche (ugs.);Grafische Benutzeroberfläche
-a conditione (lat.);unter der Bedingung
-Vorn klafft der Abgrund, hinten lauern die Wölfe. (Spruch);a fronte praecipitium, a tergo lupi (geh., Spruch, lat.)
-Internet of Things (engl.);Internet der Dinge;IoT
-tragbares Computersystem (in der Kleidung o. ä.);Wearable Computer (engl.);Wearables (Plural, engl.);Wearable (engl.)
-Smartwatch (engl.);Smart Watch
-Vater Rhein (literarisch);Rhein;Rhenus (lat.)
-Was wird daraus?;Quo vadis? (lat.);Wohin soll das führen?
-aufstrebende Märkte (Plural);Emerging Markets (fachspr., Plural, engl.)
-Developed Markets (fachspr., Plural, engl.);entwickelte Märkte (Plural)
-kleines oder mittleres Unternehmen;KMB (Abkürzung, österr.);kleine und mittlere Unternehmen (Plural);KMU (Abkürzung);Klein- und Mittelbetriebe (österr.)
-Hedge-Fonds;Hedgefonds
-Dachfonds;Fund of Funds (engl.)
-(sich) befreien von;(etwas) loswerden;hinter sich lassen;(etwas) abschütteln;(etwas) überwinden;(die) Fesseln abwerfen (fig.);(sich) frei machen von
-(sich) auf eigene Füße stellen (fig.);(sein) eigenes Leben führen;(sich) abnabeln;selbständig werden
-schon gut;ist ja gut;jaja;nerv mich nicht;du mich auch! (derb)
-Tiefschweißen;Lasertiefschweißen
-(eine) überraschend einfache Lösung finden;mit einem Schlag alle Probleme lösen;den gordischen Knoten durchhauen (fig., variabel)
-(immer) häufiger werden;mehr und mehr werden;zahlreicher werden;(an)steigen (Zahl);(immer) öfter vorkommen;mehr werden;zahlenmäßig zulegen;(sich) häufen;(an Zahl) zunehmen;(immer) häufiger vorkommen;sich mehren
-Neobiont (fachspr., biologisch);gebietsfremde Art (fachspr.);invasive Art (fachspr., biologisch)
-(sich) breitmachen (Pflanzen, Tiere) (ugs.);(sich) verbreiten;(sich) (neu) einbürgern (fig.);(sich) etablieren;(sich) ausbreiten;(sich) ansiedeln
-invasiver Pilz;Neomycet (fachspr., biologisch);eingewanderter Pilz
-Dativ der inneren Anteilnahme;Dativus ethicus (lat.);freier Dativ;Dativ des Interesses
-mit Ziffern;zahlenmäßig;numerisch;nummerisch
-mit Ziffern und Buchstaben;alphanumerisch
-Akut;Accent aigu (fachspr., franz.)
-Backtic (fachspr., engl.);Gravis (fachspr.);Accent grave (fachspr., franz.);Backquote (fachspr., engl.)
-(eine) (Grenz-)Marke knacken;kommen über;(die) Schallmauer durchbrechen (fig.)
-macht nachdenklich;schwere Kost (fig.);schwer verdaulich (fig.);wenig eingängig;zum Nachdenken;schwergängig (fig.)
-E-Banking;Online-Banking;Direktbanking (fachspr., Jargon);Home-Banking;Electronic Banking (fachspr.);Homebanking (engl.);elektronisches Bankgeschäft (fachspr.);Onlinebanking
-Onlinebanking;Internetbanking (engl.);Internet-Banking
-Phonebanking;Telefonbanking (Hauptform);Telebanking
-Datenwolke;Rechnerwolke;Wolke (selten);Cloud (engl.)
-Cloudcomputing;Cloud-Computing
-Naja;Echte Kobra
-die Märkte;Finanzmärkte
-billige Kredite;Billiggeld
-Dotcom-Krise;Krise der New Economy;Dotcomkrise
-in (einer) Reihe;gereiht;reihenweise;in (einzelnen) Reihen;aufgereiht
-Dictionnaire (schweiz.);zweisprachiges Wörterbuch;Diktionär (veraltet)
-Biber;Castoridae (fachspr., Plural, zoologisch)
-Eurasischer Biber;Castor fiber (fachspr., zoologisch);Europäischer Biber
-Kanadischer Biber;Castor canadensis (fachspr., zoologisch)
-Selbstverständlichkeit;Grundwahrheit;Binsenwahrheit;Offensichtlichkeit
-spärlich;winzig;zart
-Schafskäse;Schafkäse (österr.)
-nicht weitergehen;anhalten;stehen bleiben
-(sich) in alle Winde verstreuen;ausschwärmen;(sich) verteilen;(in alle Richtungen) auseinanderlaufen;(sich) in alle Winde zerstreuen;auseinanderstieben
-Fortschrittsglaube;Fortschrittsoptimismus;Glaube an die Zukunft
-Anstifter;Agent Provocateur (franz.);Lockspitzel
-Beerdigungskuchen (ugs., salopp, scherzhaft);Streuselkuchen
-(voll) ausreizen;(bis) an die Belastungsgrenze gehen
-am Stock gehen;an Krücken gehen
-schwerbeschädigt;versehrt;schwerbehindert;körperbehindert
-berufsunfähig;kann nicht mehr in seinem Beruf arbeiten;kann seinen Beruf nicht (mehr) ausüben
-Schiedsrichter sein (vor allem beim Fußball);pfeifen
-Glatteis;Straßenglätte;Winterglätte
-Kalter Igel;Kalte Pracht;Schwarzer Peter;Kalter Hund;Kellerkuchen;Kalte Torte;Kekstorte;Lukullus;Schokosalami;Wandsbeker Speck;Kalte Schnauze;Schwarzer Hund
-Firmenwiki;Unternehmenswiki;Organisationswiki
-zeitlich geordnet;in seinem zeitlichen Ablauf;der zeitlichen Abfolge nach;zeitlich aufeinanderfolgend;in ihrer zeitlichen Reihenfolge;chronologisch;der Zeit nach (sortiert)
-nicht als Gruppe auftreten;nicht zusammenbleiben (ugs., Hauptform);(sich) verteilen (ugs.)
-Spezialeffekte (Kino);SPFX (fachspr., Jargon);Special Effects (ugs., engl.);Special FX (fachspr., Jargon)
-nicht sofort bezahlen;anschreiben lassen
-Konsumorientierung;Konsumismus (fachspr.);Konsumentismus (fachspr., selten);konsumistische Einstellung (Hauptform);Konsumerismus (fachspr.)
-Überflusskrankheit;Affluenza
-Minimalismus;einfaches Leben (Hauptform);freiwillige Einfachheit;Abkehr von der Konsumorientierung
-Lebensführung;Lebenswandel
-Alternativbewegung;Neue Soziale Bewegung
-(eine) abfällige Geste (machen);(eine) wegwerfende Handbewegung (machen)
-vorhersehen;erwarten;(eine) dunkle Ahnung haben;vorausahnen;(jemandem) schwanen;erahnen;kommen sehen;Vorahnung(en) haben;(etwas) ahnen;voraussehen;wittern
-(etwas) sagt jemandem sein Bauchgefühl;Lunte riechen;spüren;den Braten riechen (fig.);wittern;(eine) Nase haben für;im Urin haben (fig.)
-(ein) ungutes Gefühl haben (bei);(jemandem) nicht geheuer sein;(jemandem) nichts Gutes schwanen
-(in) die Zukunft sehen;vorhersehen;hellsehen;voraussehen
-den siebten Sinn haben;(die) Intuition haben;intuitiv wissen
-(jemanden) nicht beachten;(jemanden) übersehen;(jemanden) nicht berücksichtigen;(jemanden) übergehen
-Mutmaßungen anstellen;annehmen;Vermutungen anstellen;mutmaßen;spekulieren
-(ein) Glas Bier (Hauptform);(ein) Humpen;(ein) Bierchen;(ein) Schoppen;(eine) Maß (bayr.);(ein) Bier;(ein) kühles Blondes;(eine) Halbe (ugs., süddt.)
-die Zungen lösen sich;(jemandem) die Zunge lösen;ins Erzählen kommen;gesprächig werden
-à la longue (geh., bildungssprachlich, franz.);auf die Dauer;auf die Länge (gesehen);perspektivisch (verhüllend);auf längere Sicht;auf längere Zeit gesehen;auf Dauer;langfristig (gesehen);(irgendwann) später (ugs.);längerfristig (gesehen);über (eine) längere Zeit (hinweg);auf lange Sicht (gesehen)
-wie das häufig so geht;wie so oft
-Teewagen;Dinett;Servierwagen
-Vermouth (engl.);Wermut
-Anisschnaps;Pastis (franz.);Raki (türkisch);Arak (arabisch);Ouzo (griechisch)
-solange ich lebe;solange noch (ein Tropfen) Blut durch meine Adern fließt (variabel);bis zu meinem letzten Atemzug
-au!;aua!;autsch!
-leiden;Schmerzen haben (variabel);(sich) quälen;Qualen leiden;(große) Qualen ausstehen (variabel)
-Jazz House;Electro-Lounge;Nujazz;Phusion;Electronic Jazz;Nu Jazz (Hauptform);Electro-Jazz;Jazz-Hop;Neo-Jazz
-Acid Jazz (Hauptform);Club Jazz;Dancefloor Jazz
-anfangen zu;ins (...) verfallen;ins (...) geraten;ins (...) kommen
-(aber) sonst hast du keine Probleme (oder)? (ugs., Spruch);wenn's weiter nichts ist...;wenn das deine einzigen Probleme sind... (ugs.)
-nach Dienstschluss;nach Feierabend;nach getaner Arbeit (Hauptform)
-es mit Mein und Dein nicht so genau nehmen (verhüllend);langfingrig (fig.);(ein) einnehmendes Wesen haben (ironisch, verhüllend);(schon mal ganz) gerne was mitgehen lassen (ugs.);(etwas) gut gebrauchen können (ironisch, verhüllend);kleptomanisch veranlagt;diebisch
-(einfach) behalten;nicht zurückgeben
-(hier, bitte, aber) Wiedersehen macht Freude! (Spruch);(du weißt ja,) steht WMF drauf (ugs., Spruch);(das) bekomme ich aber zurück!
-Nutzererlebnis;User Experience (engl., Hauptform);Nutzererfahrung;Benutzererfahrung;Nutzungserlebnis;Anwendererlebnis
-es setzt was (ugs.);eine geschmiert kriegen (ugs.);ein paar hinter die Löffel kriegen (ugs.);eine gescheuert kriegen (ugs.);was kriegen (ugs.);(jemandem) rutscht die Hand aus (ugs., fig.);(sich) eine fangen (ugs.);eine Ohrfeige bekommen (variabel);ein paar kriegen (ugs.);Du kriegst gleich eine! (ugs.);eine gelangt kriegen (ugs.);(etwas) auf die Ohren kriegen (ugs.);abgewatscht werden (ugs.);(es gibt) was hinter die Löffel (ugs., variabel)
-EDM;Electronic Dance Music;elektronische Tanzmusik
-New Age;Ambient
-renommieren;angeben wie ein Sack Sülze (ugs.);(mächtig) angeben;bramarbasieren (geh.);angeben wie ein Sack Seife (ugs.);(sich) brüsten (mit);(sich) rühmen;prahlen (Hauptform);protzen;herumprotzen;angeben wie ne Tüte Mücken (ugs.);aufschneiden
-Karosserie;Karosse (ugs.)
-Kinderwagen;Säuglingskutsche (ugs., scherzhaft)
-Buggy;VW-Buggy
-Mensch mit Behinderung;Person mit Behinderung;Behinderte (weibl.);behinderte Person;behinderter Mensch (Hauptform);Krüppel (derb, abwertend);Behinderter (männl.)
-Ankreuztest (ugs.);Multiple-Choice-Test;Test zum Ankreuzen (ugs.);Test mit Auswahlantworten (fachspr.)
-(sich) Twitter-Nachrichten schicken;zwitschern (ugs.);tweeten (selten);twittern (Neologismus, Hauptform)
-Partnervermittlung;Partneragentur
-Online-Partneragentur;Partnerbörse;Online-Partnerbörse
-Sattelzug (österr.);Sattelmotorfahrzeug (schweiz.);Sattelkraftfahrzeug;Sattelschlepper (ugs.)
-Güterkraftverkehr;Straßengüterverkehr
-Fremdsprache;ausländisch (ugs., scherzhaft);auswärts (ugs., scherzhaft);nicht deutsch (variabel)
-Marsmensch;Marsianer;kleines grünes Männchen (fig.)
-(jemanden) verrückt machen (ugs.);(jemandem einen) Floh ins Ohr setzen (fig.);(jemanden) auf verrückte Gedanken bringen
-Vorsprechen (Theater, Film);Casting (engl.)
-Schildbürgerstreich;Provinzposse;Lokalposse
-(reines) Konsumdenken;Konsumhaltung;(sich) beliefern lassen;mangelnde Eigenaktivität
-Konzentration aufs Materielle;Materialismus (Hauptform);materialistische Lebenseinstellung
-Schampus (ugs.);Champagner
-Meniskus (fachspr.);Kniegelenkscheibe
-Straßenbegleitgrün (Amtsdeutsch);städtisches Grün;Verkehrsbegleitgrün (Amtsdeutsch);Straßenbepflanzung
-tieferer Sinn;eigentlicher Grund
-so;in einer Weise, dass;derart;in dieser Weise;dahingehend
-kaum verständlich;schwer verständlich;schwer zu verstehen;kaum zu verstehen;umständlich;überkompliziert;verklausuliert (Hauptform);(unnötig) kompliziert (etwas ... ausdrücken);(in) Juristenlatein (fig.);(in) Juristendeutsch (fig.);verschachtelt;sperrig (fig.)
-angereicht mit;prallvoll mit;strotzen(d) vor;angefüllt mit;gespickt mit;voller
-(jemand) kann endlich zeigen, was er drauf hat (ugs.);(der) Moment ist da, wo (jemand);(jemandes) Zeit ist gekommen;(die) Zeit ist reif, wo (jemand);(jemand) kann endlich zeigen, was er kann;(jemandes) große Stunde ist gekommen (Hauptform);(jemandes) Stunde hat geschlagen
-ach, wär das schön! (ugs.);(das wär) zu schön, um wahr zu sein (ugs.);schön wär's! (ugs.)
-(die) Zeit ist stehengeblieben (fig.);aus der Zeit gefallen (sein);hinter dem Mond (leben) (abwertend, fig.)
-Zusammenstellung von Infomaterial für die Presse;Pressemappe;Presseinformation (schriftlich)
-Tischvorlage;schriftliche Unterlage(n);(ein) Papier (ugs.);Handreichung (geh.);Paper (ugs., Jargon, engl.);Handzettel (Hauptform);Handout (Anglizismus)
-...ausgabe;für (...) bestimmt;für die Hand (des / der ...);darf nicht in die Hände von (...) gelangen;ad usum (...) (geh., lat.);für (...) gedacht
-unanständig;nicht (ganz) stubenrein;pikant;anzüglich;schlüpfrig;frivol;schmierig;eindeutig-zweideutig;zweideutig
-ungehobelt;derb;gepfeffert (fig.);saftig;deftig;unfein;handfest;nicht zimperlich;rustikal
-anspielend;andeutend;anspielungsreich;zweideutig;doppelbödig;mehrdeutig
-exhibitionistisch;zeigefreudig
-beweisen;zeugen von;unter Beweis stellen;an den Tag legen;demonstrieren;zeigen;erkennen lassen;Zeugnis ablegen (von) (geh.)
-schneller Blick (für);sofort erkennen;rasche Auffassungsgabe
-(jemanden) umbringen wollen (variabel);(jemandem) nach dem Leben trachten;(jemanden) zu töten versuchen (variabel)
-nur noch ein (einziges) Ziel kennen;nur noch ein(e)s im Sinn haben;nur noch ein Ziel haben;nur noch für (ein Ziel) leben (variabel);(jemandes) ganzes Sinnen und Trachten (ist) (variabel);alles einem Ziel unterordnen;(etwas) mit allen Fasern seines Herzens (wollen)
-Wendewort;Palindrom (fachspr., griechisch)
-Anrufung;Invokation (fachspr., lat.)
-Hypotaxe (fachspr.);Unterordnung (i.e.S.);Verhältnis von Unter- und Überordnung (i.w.S.)
-korrektes Deutsch (ugs., variabel);sprachrichtig;nicht ungrammatisch;sagt man (auf Deutsch) so (ugs.);korrekt (ugs.);kann man so (auf Deutsch) sagen (ugs.);grammatikalisch korrekt;wohlgeformt;grammatikkonform;grammatisch;der Grammatik gemäß;regelkonform
-das Haus verlassen;die Wohnung verlassen;auf die Straße gehen;(sich) in der Öffentlichkeit zeigen;nach draußen gehen (ugs.);(sich) außer Haus begeben (geh.);auf die Straße treten
-Standlicht;Begrenzungslicht
-Tagfahrlicht;Licht am Tag
-Sexsymbol;Sexbombe;Kurvenstar;Sexgöttin
-Straßenräumlampe;Frontblitzer
-Einsatzleitwagen;Einsatzleitfahrzeug (österr.);Mobile Leitstelle (österr.)
-Mannschaftstransportfahrzeug;Mannschaftswagen;Mannschaftstransportwagen
-Kennzeichenbeleuchtung;Kennzeichenleuchte;Kontrollschildbeleuchtung (schweiz.)
-Kontrollschild (schweiz.);Behördliches Kennzeichen (österr.);Kraftfahrzeugkennzeichen
-Rückfahrlicht;Rückfahrscheinwerfer
-angesprungen kommen;hergelaufen kommen;angerannt kommen;herbeilaufen;herbeigelaufen kommen;herbeispringen;herbeigesprungen kommen;angelaufen kommen (Hauptform);hergesprungen kommen
-Hoare-Logik;Hoare-Kalkül
-Inferenzregel;Schlussregel
-Umformungsregel;Transformationsregel
-Termin beim Fotografen;Fototermin;Sitzung beim Fotografen;Termin im Fotostudio;Shooting (Jargon, engl.);Fotoshooting
-Nodalpunkt;Knotenpunkt
-Dandy-Walker-Malformation;Dandy-Walker-Fehlbildung;Dandy-Walker-Syndrom
-Gewässername;Hydronym (fachspr., griechisch, linguistisch)
-schlecht bezahlte Arbeitskraft;Billiglöhner;schlecht bezahlter Mitarbeiter;mit Mindestlohn abgespeist
-Ordensname;Mönchsname
-(die) Warnblinke (ugs.);(das) Warnblinklicht
-Sprachlehre;systematische Sprachbeschreibung;Grammatik
-Grammatik (einer Sprache) (Hauptform);Sprachbau;Regelwerk (einer Sprache);(systematische) Beschreibung einer Sprache;Regelapparat;(die) Regeln
-regelwidrig;sagt man so auf Deutsch nicht (ugs.);kein Satz der (...) Sprache;nicht wohlgeformt;(das ist) kein (korrektes) Deutsch (variabel);ungrammatisch;falsches Deutsch
-Actioner (ugs., Jargon, salopp);Actionfilm
-Filmgattung;Filmgenre
-von A bis Z;alphabetisch (Hauptform);abclich (selten);abecelich (selten)
-annähern;approximieren
-inbrünstig geliebt;heißgeliebt;innigst geliebt;viel geliebt;vielgeliebt;heiß geliebt
-(man wurde) aufmerksam auf;in Erscheinung treten;(jemandes) Name fällt im Zusammenhang mit;auffallen (mit);auf sich aufmerksam machen;(sich) hervortun (durch / mit)
-(ziemlicher) Akt (ugs.);(große) Aktion;Kugelfuhr(e) (ugs., schwäbisch);aufwändig;mit großem Aufwand verbunden;Gugelfuhr(e) (ugs., schwäbisch)
-alles klar machen (für);(den) Weg ebnen (fig.);alles vorbereiten;(den) Boden bereiten (für) (geh., fig.);(einer Sache) den Boden bereiten (geh., fig.);(die) Bahn freimachen;(die) Voraussetzungen schaffen;alle Hindernisse beiseiteräumen (auch figurativ)
-etwas über (ugs.);ein wenig mehr (als);knapp über;kaum mehr (als);gut (vor Maßen u. Zahlen);einige (+ Zahl) (geh., literarisch, veraltend);leicht über;etwas mehr (als)
-weit mehr als;weitaus mehr (als);deutlich mehr als;deutlich über;reichlich;weit über;reichlich über;viel mehr als
-fast;(es) hätte nicht viel gefehlt (und);nicht weit davon entfernt sein (zu);um ein Haar;nahe daran sein (zu);beinahe;(es) fehlte nicht viel (und)
-Eisenbahngesellschaft;Eisenbahnunternehmen;Bahngesellschaft;Bahn
-DB (Firmenlogo);(die) Bahn (ugs., Hauptform);Deutsche Bahn (AG) (Eigenname);Deutsche Bundesbahn (historisch, veraltet)
-ÖBB-Holding AG (Eigenname);Österreichische Bundesbahnen;ÖBB
-gegebenenfalls (auftretend o.ä.);möglich;etwaig (Amtsdeutsch, Hauptform);eventuell;eventuell (vorhanden o.ä.);möglicherweise (auftretend o.ä.);denkbar;allfällig (schweiz., österr.)
-zeitgleich;zufällig gleichzeitig;koinzidierend (geh., bildungssprachlich)
-gleichzeitig stattfinden;zusammenfallen (mit);zusammentreffen;(sich) überschneiden;in eins fallen (mit) (geh.)
-(sehr) zum Wohlgefallen (von);sehr zur Freude (von);darüber freut(e) sich
-hoffähig (werden) (fig.);nicht länger schief angesehen werden (ugs., fig.);(allgemein) akzeptiert (werden);salonfähig (werden) (fig.)
-etablieren;zur Durchsetzung verhelfen;(etwas irgendwo) einführen;salonfähig machen;aufwerten;hoffähig machen (fig.);für Akzeptanz (in den Reihen von ...) sorgen
-zur großen Verärgerung von;(sehr) zum Ärger (von);zum Missfallen von;darüber sehr verärgert (sein)
-Mantra;Passphrase
-abstrus (geh.);wirr;konfus (geh.);an den Haaren herbeigezogen (ugs., fig.);wüst;abenteuerlich (Spekulation o.ä.);wild
-mit vereinten Kräften;alle machen mit;alle zusammen;in einer gemeinsamen Anstrengung;gemeinsam
-angreifbar sein;(eine) offene Flanke bieten;(sich) Angriffen schutzlos aussetzen;keine Vorsichtsmaßnahmen ergreifen
-Geschäftsmodell;Geschäftsidee;unternehmerisches Konzept;Idee zum Geldverdienen;Unternehmenskonzept
-zoophag (fachspr.);karnivor (fachspr., lat.);fleischfressend;Fleisch fressend
-Karnivore (fachspr., lat.);fleischfressende Pflanze;Zoophage (fachspr.)
-Drosera;Sonnentau
-Nepenthes;Kannenpflanze
-Fliegenfalle;Venusfliegenfalle
-Kampfgetümmel;Schlachtgewühl;Schlachtgetümmel
-im Kampfeinsatz;kämpfend
-ganz vorne;in vorderster Linie;ganz vornean
-vorweg;voraus;vorab
-Sprechanlage;Intercom
-maschinschreiben (österr.);Maschine schreiben
-maschingeschrieben (österr.);maschinegeschrieben;maschinengeschrieben;mit der Schreibmaschine geschrieben
-sexuelle Ausstrahlung;Sexappeal;Was einen Menschen für einen anderen sexy macht.;sexuell-erotische Form der Attraktivität;Sex-Appeal
-wirr;unruhig;ohne Plan;ohne Linie (fig.);zusammenhanglos;zerfahren;ohne roten Faden (fig.);ohne Struktur
-im Vorbereitungsdienst;in Ausbildung (zum Pastor / Pfarrer);im Vikariat;Vikar (evang.)
-wie um Himmels Willen (ugs.);wie um alles in der Welt;wie um Gottes Willen (ugs.);wie zum Kuckuck (ugs.);wie zum Teufel (ugs.)
-(ist) abzusehen;wird kommen;nur noch eine Frage der Zeit
-nicht mehr lang hin (sein);jetzt bald;balde (geh., poetisch);in naher Zukunft;bald;nicht mehr lange (dauern);binnen kurzem;jetzt allmählich;in absehbarer Zeit;in Kürze;kurzfristig;zeitnah;in der nächsten Zeit;in Kurzem;in nächster Zeit;in Bälde (auch humor.) (geh.)
-in allernächster Zukunft;sehr bald;unmittelbar bevorstehen(d);in allernächster Zeit
-verbrannte Erde (hinterlassen);alles Wichtige zerstören
-in diesen Tagen;in den nächsten paar Tagen;dieser Tage (geh., Papierdeutsch);in den kommenden Tagen;die Tage (ugs., regional);nächste Tage (ugs., regional);in den nächsten Tagen
-und in alle Ewigkeit so weiter;und so weiter ad infinitum;und immer so weiter
-von eigener Hand;selbst geschrieben;eigenhändig (niedergeschrieben);autografisch (fachspr.);autographisch (fachspr.)
-von eigener Hand (fig.);selbst verfasst
-Manuskript;(bislang) nicht veröffentlichter Text;(noch) nicht kommerziell verwertet
-(sich) bewähren;(sich) als brauchbar erweisen;gut fahren (mit);(die) Erwartungen (voll) erfüllen;gute Erfahrungen machen (mit) (Hauptform);(die) Erwartungen nicht enttäuschen;es gibt keine Probleme (mit) (ugs.);(sich) als geeignet erweisen;keine Probleme haben (mit) (ugs.)
-(seine) Mitte finden (variabel);(sich) erden
-heilfroh (sein);(sich) befreit fühlen;erleichtert (sein);(jemandem) wird leicht ums Herz;(jemandem) fällt eine schwere Last von der Seele;(jemandem) fällt ein Stein vom Herzen (fig.);(jemandem) den Tag retten (ugs.);aufatmen (können);(jemandem) fällt eine Last vom Herzen
-erlöst;von Herzen froh (dass);heilfroh;erleichtert;entlastet;befreit
-(die) Vergangenheit ruhen lassen;nicht (immer) wieder die alten Geschichten aufwärmen;keine alten Wunden aufreißen (wollen)
-mit heißer Nadel gestrickt (Plan, Projekt) (fig.);eilig hingeworfen (Manuskript, Song);übereilt auf den Weg gebracht (Gesetz) (fig.)
-Sondereinladung;Extraeinladung (ugs.)
-(jemandem) nichts antun;niemandem ein Haar krümmen;(jemandem) kein Haar krümmen;(jemandem) nichts zuleide tun
-verantwortlich (sein);(sich etwas) zuschulden kommen lassen;schuld (sein);haftbar (sein) (fachspr., juristisch);(etwas) können für (ugs.);schuldtragend (sein);schuldig (sein) (fachspr., juristisch);(sich etwas) zu Schulden kommen lassen
-seltene Erden;Seltenerdmetalle;Rare Earths (engl.);Seltene Erdelemente (fachspr.);Metalle der seltenen Erden;Rare Earth Elements (fachspr., engl.)
-DVD (Abkürzung, engl.);Digital Versatile Disc (engl.)
-BD (Abkürzung, engl.);Blu-ray (engl.);Blu-ray Disc (engl.)
-It-Girl;Partygirl
-sich selbst genug (sein);autonom (sein);keinen anderen brauchen (variabel);nicht auf andere angewiesen (variabel);(gut) alleine klarkommen (ugs.)
-niemanden über sich haben (der ihm sagen kann, was er zu tun und zu lassen hat);sein eigener Herr (sein) (fig., Hauptform);nicht weisungsgebunden (sein);ihre eigene Frau (fig., weibl.);selbstständig (sein);sein eigener Chef (fig.);kein Befehlsempfänger (sein);(alles) selbst entscheiden (können)
-Unternehmer sein;selbstständig (sein) (Hauptform);unternehmerisch tätig sein;sein eigenes Unternehmen haben;(ein) Unternehmen führen;(der) Chef sein (ugs.)
-(alles) selbst entscheiden (können);niemanden haben, der einem reinredet (ugs.)
-auf sich selbst gestellt sein;(alles) selbst entscheiden (müssen);(mit etwas) allein(e) dastehen
-(jemanden) in Grund und Boden spielen (fig.);(jemanden) an die Wand spielen (Schauspiel, Theater, Musik) (fig.);(ein) (weitaus) besserer Schauspieler (/ Musiker) sein
-(das) Spiel bestimmen;(jemanden) in Grund und Boden spielen (fig.);(das) Spiel dominieren (Hauptform);(jemandem) sein Spiel diktieren;am Drücker sein (ugs., fig.);(jemanden) an die Wand spielen (Sport) (fig.);(das) Spiel beherrschen
-(jemanden) unterkriegen;gewinnen;(jemanden) niederringen;(sich) als stärker erweisen;(sich) durchsetzen;(der) Stärkere sein;(die) Oberhand gewinnen
-(die) Oberhand behalten;(das) Spiel nicht aus der Hand geben;Oberwasser behalten
-(jemandem) einen Zug voraus sein (fig.);(jemandem) einen Schritt voraus sein (fig.);schneller sein
-vorne liegen (fig.);(jemandem) eine Nasenlänge voraus sein (fig.);besser sein;(einen) Vorsprung haben (fig.)
-(einen) gewaltigen Vorsprung haben;weit vorne liegen;(jemandem) um (viele) Nasenlängen voraus sein (fig., variabel);(jemandem) um Lichtjahre voraus sein (fig.)
-(um eine) Kleinigkeit besser;(einen) Tick besser (sein);(eine) Idee besser
-Pflaumenkuchen;Quetschekuche (hessisch, saarländisch);Zwetschgendatschi (badisch, bayr.);Prommetaat (rheinisch);Zwetschkendatschi (österr.);Zwetschenkuchen;Pruumetaat (rheinisch);Prummetaat (rheinisch);Zwetschgenkuchen;Prummekooke (rheinisch);Zwetschkenfleck (österr.)
-Register der Traditionellen Lebensmittel;Traditionelle Lebensmittel
-Zwetschgenwasser;Zwetschgenbrand;Slivowitz;Zwetschgenschnaps
-Schlagwerker;Perkussionist
-Auszügler;Altenteiler
-Leibgedinge;Leibzucht
-Widum;Wittum;Witthum
-Frau am (... / Frau an der ...) (ugs., variabel, weibl.);Instrumentalist (fachspr.);Musiker;...spieler (Musikinstrument);Mann am (... / an der ...) (ugs., männl., variabel)
-in der Musikbranche tätig;Musikschaffender;macht in Musik (ugs., salopp)
-Album (veraltend);Doppelalbum;Doppel-LP
-Doppelalbum;Doppel-CD;2-CD-Box (variabel)
-Ausguss;Schüttstein (schweiz.);Spülstein (regional)
-sooft;immer wenn;wann (auch) immer;jedes Mal wenn
-Marktgleichgewicht;geräumter Markt
-Gesamtnachfrage;gesamtwirtschaftliche Nachfrage;aggregierte Nachfrage
-Kapitalgut;Investitionsgut
-Eisenmennige;Pariser Rot;Marsrot
-Chruschtschow-Ultimatum;Berlin-Ultimatum
-deutschblütig;deutschen Blutes
-Arisierer;Ariseur
-Netzhautheilkunde;Retinologie (fachspr.);Netzhautchirurgie
-Porajmos;Porrajmos
-Reichssippenamt (historisch);Reichsstelle für Sippenforschung (historisch)
-Gesetz zur Wiederherstellung des Berufsbeamtentums (historisch);Berufsbeamtengesetz (historisch)
-rekonstruktiv;wiederherstellend
-Nürnberger Hauptkriegsverbrecherprozess;Nürnberger Prozess gegen die Hauptkriegsverbrecher
-Eugenetik;Eugenik;Rassenhygiene (derb)
-Nationalsozialistische Rassenhygiene;NS-Rassenhygiene
-Mpondoland;Pondoland
-Sepoyaufstand;Indischer Aufstand von 1857
-Kunstfehler;Behandlungsfehler
-örtliche Betäubung;Lokalanästhesie
-Dienstag nach Ostern;Osterdienstag
-Lebensmittelpunkt;Hauptwohnsitz;Erstwohnsitz;Hauptwohnung;Hauptaufenthaltsort
-Fahrradlampe (vorne);vordere Lampe (Fahrrad) (ugs.);Fahrradscheinwerfer;Lampe vorne beim Fahrrad (ugs.);Vorderlicht (ugs.);Fahrradbeleuchtung (vorne);Frontlicht (fachspr., Jargon)
-Rücklicht (Fahrrad);hinteres Fahrradlicht (ugs.);hintere Fahrradlampe (ugs.);Fahrradlampe hinten (ugs.)
-Fahrradlicht;Fahrradbeleuchtung;Lichtanlage (Fahrrad)
-1a-Zustand;makellos;unbenutzt;wie neu;nur einmal getragen (Kleidung);Topzustand;ungelesen (Buch)
-(sich) nicht (gerade) mit Ruhm bekleckert haben (ugs., Redensart);(eine) Schande (für);kein Ruhmesblatt (geh.);(man) hätte mehr erwartet (von);(etwas ist) keine Heldentat (fig.);(jemand) sollte sich was schämen! (ugs.);ein Armutszeugnis (für jemanden/etwas sein) (Hauptform);(eine) Bankrotterklärung (sein) (fig.);keine Ruhmestat;(ein ...) sieht anders aus (ugs.);(sich) ein Armutszeugnis ausstellen (mit) (fig.)
-mein lieber Freund und Kupferstecher! (Anrede) (scherzhaft, veraltend);alter ... (/ altes ... / alte ...) (Anrede) (ugs., ironisch);altes Haus (Anrede) (ugs., scherzhaft);alter Schwede (Anrede) (ugs., scherzhaft);alter Zausel (Anrede) (ugs., scherzhaft, variabel);Digger (Digga, Diggah) (ugs., Anredeform, jugendsprachlich)
-gebundener Finanzkredit;Finanzkredit;Bestellerkredit
-Exportrisikoversicherung;Ausfuhrversicherung;Exportkreditversicherung
-Kostenbeteiligung;Selbstbeteiligung;Eigenanteil;Franchise;Zuzahlung (z.B. für Medikamente);Selbstbehalt
-Versicherungsprinzip;Äquivalenzprinzip
-Callcenter (Hauptform);Telefonberatungszentrum;Kundenberatungszentrum;Customer-Care-Center;Call-Center;Kundenbetreuungszentrum
-zu dieser Zeit;in jenen (fernen) Tagen;zum damaligen Zeitpunkt;zu jener Zeit;seinerzeit;in jenen längst vergangenen Tagen;da (ugs.);in jener längst vergangenen Zeit;damals
-derzeitig;augenblicklich (Adjektiv);momentan (Adj.);aktuell (Adjektiv);jetzig;... von heute;heutig;nunmehrig (österr.);gegenwärtig (Adjektiv)
-Getrennt marschieren, vereint schlagen. (sprichwörtlich);eine strategische Allianz bilden (auch figurativ);(trotz gegensätzlicher Interessen) gemeinsame Ziele verfolgen
-Dienstag Abend;(am) Dienstagabend
-dienstagabends;dienstags abends
-Eurasischer Kranich;Grauer Kranich;Kranich
-Sambesihai;Stierhai;Gemeiner Grundhai;Bullenhai
-elektromagnetischer Impuls;elektromagnetischer Puls
-Vertrag über das Verbot von Kernwaffenversuchen in der Atmosphäre, im Weltraum und unter Wasser;Moskauer Atomteststoppabkommen
-Vertrag über die Nichtverbreitung von Kernwaffen;Atomwaffensperrvertrag
-Wiener Übereinkommen über das Recht der Verträge;Wiener Vertragsrechtskonvention
-Strafanspruch des Staates;Strafmonopol des Staates
-(...) verloren haben;keine (...) mehr haben;(jemandem) ist (...) ausgetrieben worden;(etwas) hat jemandem (...) verleidet (geh.);(jemandem) vergangen sein
-pflanzen;einsetzen;setzen;eingraben (ugs.);einpflanzen
-krähen (fig.);mit heiserer Stimme rufen
-schreien;weinen;krähen (Kind, Baby)
-(als) Teil fürs Ganze;(als) Pars pro Toto (lat.)
-Aufsatzrollladen;Aufbaurollladen
-Rollladenpanzer;Rollpanzer
-Energiedurchlassgrad;g-Wert
-Full Service;Rundum-Kundendienst;Rundum-Service
-Regelkonformität;Regeltreue;Compliance (engl.)
-crossmedial;medienübergreifend
-Reservebank;Ersatzbank
-kultivieren;anpflanzen;anbauen;ziehen (Pflanzen)
-produzieren;erzeugen;herstellen
-(herum)kramen;(herum)suchen (ohne System);(herum)stöbern;(rum)krosen (ugs., regional, rheinisch);(herum)kruschteln (ugs., regional, süddt.);(herum)wühlen
-Potenz;Größenordnung
-eigen (in etwas);speziell
-Proportionalzählrohr;Proportionalzähler
-Erdkegelburg;Motte;Turmhügelburg;Erdhügelburg
-nicht gemachtes Bett;Lotterbett (scherzhaft)
-liederliches Leben;Lotterleben (veraltet);Leben in Sünde
-(die) Stätte ihres lasterhaften Treibens (literarisch);Lotterbett
-Abwesenheit vom Tatort;Alibi
-zweite Mahd;Grummet;zweiter Schnitt;zweite Heuernte;Ettgrön (fachspr., Jargon, regional);Öhmd (fachspr., Jargon, regional);Emd(e) (fachspr., Jargon, regional);zweite Schur
-kann zweimal gemäht werden;zweischürig;zweimähdig;zum zweimaligen Schnitt bestimmt
-wissen, wie es gemacht wird;Gelernt ist gelernt! (ugs., sprichwörtlich);der richtigen Dreh raushaben;wissen, wie man's richtig macht;den Bogen (he)raushaben (ugs., fig., Hauptform);(sein) Handwerk verstehen (fig.);die Kunst (des/der ...) beherrschen;wissen, wie es geht;wissen, wie's gemacht wird
-(Das) war vielleicht doch keine so gute Idee. (ugs., floskelhaft);Ich denk noch mal drüber nach. (ugs., Spruch)
-aufeinanderhocken (ugs., fig.);nicht unter Menschen gehen;von der Außenwelt isoliert sein
-aufeinanderhocken (fig.);(sich) zwangsläufig miteinander auseinandersetzen müssen;beengt untergebracht sein;sich nicht aus dem Weg gehen können
-Das kannst du halten, wie du willst. (ugs.);Das kannst du halten wie ein Dachdecker. (ugs., Spruch);Mach nur, wie du meinst. (ugs., floskelhaft);Tu, was du für richtig hältst.
-(ordentlich) etwas hermachen (ugs.);Kleider machen Leute. (sprichwörtlich);schon (et)was sein (ugs.);(die Leute) beeindrucken;nach etwas aussehen (ugs.);Eindruck machen
-Schwereanomalie;Gravitationsanomalie
-Schwerebeschleunigung;Schwere;Fallbeschleunigung
-Bezugsfläche;Referenzfläche
-Bouger'sche Plattenreduktion;Gangreduktion;Bouguer-Reduktion
-Münchberger Gneismasse;Münchberger Masse;Münchberger Gneisplatte
-Regimentschef;Regimentsinhaber (bayr., österr.)
-Kurfürstlich Hessische Armee;Kurhessische Armee (ugs.)
-kann nicht mit Kritik umgehen (ugs.);kann es nicht ertragen, kritisiert zu werden;kann Kritik (an seiner Person) nicht ertragen;kommt mit Kritik nicht (gut) klar (ugs.);nicht kritikfähig (Hauptform);schnell eingeschnappt
-(juristische) Grauzone (variabel);juristisch nicht abschließend geklärt;Graubereich;rechtlich unklar
-Wechsel an der Spitze;Führungswechsel
-(sich selbst) in eine schwierige Lage bringen (variabel);(sich in etwas) hineinmanövrieren
-Lady Day (ugs., Eigenname);Billie Holiday (Eigenname)
-Nutzwertanalyse;Punktbewertungsverfahren;Punktwertverfahren
-Videowand;videowall;Led Wand;video wall;Led Wall;Led Video Wall;Großbildschirm
-blühende Topfpflanze;Blume (ugs.);Blühpflanze
-Blume (ugs.);Blattpflanze (im Topf)
-Digitalbuch;E-Buch
-(etwas) schultern;(etwas) auf die Schulter nehmen
-Topfpflanze;Pflanze für drinnen (ugs.);Zimmerpflanze (Hauptform)
-Anaglyphe;Anaglyphenbild
-elektronischer Marktplatz;virtueller Marktplatz
-Autobahnknoten (österr.);Autobahndreieck;Knoten (österr.);Verzweigung (schweiz.);Dreieck (ugs.)
-Gabelung;Abzweig;Autobahngabelung
-zu dicht besiedelt;zu stark bevölkert;übervölkert;zu dicht bevölkert
-(sich) fehl am Platz fühlen;(sich) vernachlässigt fühlen;(sich) überflüssig vorkommen;(sich) nicht beachtet fühlen;(sich) vorkommen wie das fünfte Rad am Wagen
-(nur) ein kleines Rädchen im Getriebe (fig.);Schütze Arsch im letzten Glied (sein) (derb, Redensart);der letzte der letzten
-Kardiotokographie;Kardiotokografie
-Herzfrequenz;Herzschlagfrequenz
-versinnbildlichen;repräsentieren;stehen für;verkörpern;symbolisieren;der Inbegriff (von etwas) sein
-rurale Kommune;ländliche Gemeinde;Landgemeinde
-Stadtgemeinde;städtische Gemeinde
-Erziehungsgehalt;Erziehungsbonus;Betreuungsgeld;Erziehungsprämie;Hausfrauengehalt
-Pavillon;Gartenpavillon (transportabel);Zeltling;Überdachung
-Schuppen;Baracke;Bretterbude;Geräteschuppen;Werkzeugschuppen;Remise (geh., franz.)
-überdachter Einstellplatz;Autounterstand;Unterstellmöglichkeit;Schutzdach;Abstellplatz;Unterstand;Carport (engl.)
-Werkraum;Arbeitsraum;Atelier
-Produktionsstätte;Fabrikationsstätte
-Produktionshalle;Industriebetrieb
-Gigantik;gigantisches Ausmaß;beeindruckende Größe;außerordentliche Größe
-eine größere Anzahl (an);dutzende (/ Dutzende);ein große Menge an;eine Menge;viele (Hauptform);in großer Zahl;eine große Menge von;eine (ganze) Palette von;zahlreiche;dutzende von (/ Dutzende von);eine (ganze) Palette an;(eine) Vielzahl (von);reichlich (ugs.);eine beachtliche Anzahl von;eine große Zahl von;(eine) große Anzahl;eine beachtliche Anzahl an;eine Vielzahl (von)
-Alluvion (fachspr., lat.);Alluvium (fachspr., lat.);Anschwemmung;Alluvialboden;Anspülung
-Elektronenmikroskop;Übermikroskop (veraltet)
-nichts bringen (ugs.);nichts taugen;keinen Wert haben (ugs.)
-reichlich viele;eine (ganze) Armada von (fig.);noch und noch (ugs.);(und) nicht zu knapp (ugs.);sehr viele (Hauptform);jede Menge (ugs.);noch und nöcher (ugs.);zig (ugs.);ein Großaufgebot von;(ganze) Heerscharen von (fig.);tausend (ugs., fig.);ohne Ende (nachgestellt) (ugs.)
-Modularisierung;Komponentisierung
-Sammelwerk;Herausgeberschrift
-Monografie;Monographie
-(mit den Worten) zitiert werden;(sich) mit den Worten zitieren lassen;erklären;verlautbaren (geh.);wissen lassen;(öffentlich) äußern (Hauptform)
-zahlreich;in großer Zahl;waggonweise;zu Tausenden;in Strömen;(ganze) Heerscharen von;zuhauf;in (hellen) Scharen;busweise;massenhaft;scharenweise;zu Hunderten
-über jemanden hereinbrechen;es gibt jede Menge (...);auf jemanden niedergehen;es hagelt(e) (...);auf jemanden niederprasseln;auf jemanden einprasseln;auf jemanden einstürmen
-Geograph;Geograf
-Komplizenschaft;Kumpanei
-Kumpanei;Anbiederungsversuch(e);freundschaftliches Getue;plumpe Vertraulichkeit(en)
-Fiebermücke;Anopheles (fachspr.);Malariamücke;Gabelmücke
-Anfangsbestand;anfänglicher Vorrat;Grundstock
-kleckerweise kommen (ugs., negativ);eintrudeln;hereingeflattert kommen (Briefe);angekleckert kommen (Gäste) (ugs., negativ);nach und nach eintreffen
-Zivilrecht;Privatrecht
-heute so (und) morgen so;(ein ständiges) Hin und Her;(wieder) Kommando zurück;rin in die Kartoffeln, raus aus die Kartoffeln (ugs., Spruch, variabel);man weiß nicht, woran man ist (bei jemandem) (ugs.);(jemand) weiß (auch) nicht, was er will (ugs.);mal hü(h) und mal hott sagen (ugs., Spruch, variabel);(jemand) weiß (auch) nicht, ob er warm oder kalt ist (ugs., Redensart);mal so, mal so (ugs.)
-Grenzstein;Bannstein;Abmarkung;Markstein
-Clathrat;Klathrat
-marode Wirtschaft;Lotterwirtschaft;polnische Wirtschaft (abwertend, veraltet)
-Finsterling;finsterer Geselle;düsterer Bursche;unheimlicher Kerl
-finstere Machenschaften;kriminelle Aktivitäten
-Internationaler Karlspreis zu Aachen;Karlspreis
-Paneuropa-Union;Paneuropaunion
-Panasiatismus;Panasienbewegung;Panasianismus
-Konstitutionelle Revolution;Jungpersische Revolution
-italienischer Irredentismus;Panitalianismus
-Panlatinismus;Panlateinismus
-Panrumänismus;Panromanismus
-Slawischer Kongress;Slawenkongress
-Spaniertum;Hispanität
-Rote Armee;Rote Arbeiter- und Bauernarmee
-Judäo-Bolschewismus;Jüdischer Bolschewismus
-Blaue Armee;Haller-Armee
-Grammatur (Papierherstellung) (fachspr.);Massenbelegung (fachspr.);Grammage (fachspr.);Quadratmetergewicht;flächenbezogene Masse (fachspr.);Flächengewicht (ugs., Jargon, Hauptform);Massebelag (fachspr.);Massenbelag (fachspr.)
-in letzter Zeit;in allerletzter Zeit;erst jetzt;seit Neuestem;seit Kurzem;noch nicht (so) lange;(erst) seit kurzer Zeit;neuerdings
-doch noch schaffen;(die) Kurve kriegen (fig.)
-a. D.;i. R. (Abkürzung);in den Ruhestand versetzt;em. (Abkürzung);auf dem Altenteil sitzen (fig.);aus dem Arbeitsleben ausgeschieden;in Pension;aus dem aktiven Dienst ausgeschieden;außer Dienst;emeritiert (geh.);nicht mehr (berufs)tätig;in Rente;im Ruhestand (Hauptform)
-ich möchte (et)was trinken (Hauptform);ich könnte (et)was zu trinken vertragen (variabel);mir ist nach (et)was zu trinken (variabel);ich würde (jetzt) gerne (et)was trinken;jetzt ein(e) (..., das wär's)! (variabel);ich hab(e) Lust auf (etwas zu trinken) (variabel)
-Durst haben (Hauptform);durstig sein;ausgetrocknet sein;etwas trinken möchten;Durst leiden;(jemandes) Kehle ist wie ausgedörrt
-(der) Drummer sein;am Schlagzeug (sitzen);Schlagzeug spielen
-Mitspracherecht;Mitentscheidungsrecht
-in eine Entscheidung einbezogen werden;mitreden dürfen;mitentscheiden dürfen;an einer Entscheidung beteiligt werden
-Staatenlenker;Kabinettschef (ugs.);Staatschef;Regierungschef
-über den Parteien stehen;keiner Parteilinie verpflichtet (sein)
-Rektor;Direx (Schülersprache) (Jargon);Schulleiter (Hauptform)
-Prorektor;stellvertretender Rektor;Konrektor;stellvertretender Schulleiter
-Knochen (ugs.);(altes) Mobiltelefon
-Posten schieben (ugs., Jargon);Wache schieben (ugs., Jargon);bewachen;Wache halten;(die erste / zweite ...) Wache haben;zum Wachdienst eingeteilt sein;auf Wache sein (ugs.);Wachdienst haben;Wache haben (ugs.);auf Wache stehen (ugs.);überwachen;Wache stehen;Posten stehen
-nicht von jemandes Seite weichen;(jemandes) ständiger Begleiter (sein);ständig zusammen sein (2 Personen) (ugs.)
-viel Tamtam um etwas machen (ugs.);viel Wesens um etwas machen (veraltend);eine Staatsaktion aus etwas machen (ugs., fig.);viel Wind um etwas machen (ugs., fig.);viel Wirbel um etwas machen (ugs., fig.);Theater machen (ugs.);aus einer Mücke einen Elefanten machen (ugs.);einen Staatsakt aus etwas machen (ugs., fig.);eine große Geschichte aus etwas machen;ein Riesen-Trara um etwas machen (ugs.)
-pushen (ugs., engl.);hypen (engl.);ins Rampenlicht schieben (fig.);hochjazzen (ugs.);hochpushen (ugs., variabel);groß herausbringen (wollen);(einen) Hype machen (um);(einen) Mordsrummel veranstalten (um) (ugs.);hochjubeln (zu) (ugs.)
-Tretboot;Pedalo (schweiz.)
-als Buch veröffentlichen;zwischen zwei Buchdeckel pressen (Jargon, salopp);in Buchform herausgeben;als Buch herausgeben;als Buch auf den Markt bringen
-Schlauberger (ugs.);schlauer Fuchs (ugs., fig.);Schlaufuchs (ugs.);Fuchs (ugs., fig.);Schlitzohr;(ein) ganz Schlauer;Schlaumeier (ugs.);Schlaukopf;Checker (ugs.);Ausgeschlafener (ugs., fig.);Durchblicker (ugs.);Schlauerle (ugs.)
-zusammengesetzt sein aus;bestehen aus;beherbergen;(sich) konstituieren aus;unterbringen;umfassen;enthalten;aufnehmen
-Dingskirchen (ugs.);Dingens (ugs.);Dingenskirchen (ugs.);Dings (ugs.);Dingsda (ugs.);Dingsbums (ugs.)
-Datenbankindex;Index
-Reißverschluss;Zippverschluss
-(unzivilisierte) Bande (derb);Mob (derb, abwertend);Saubande (derb, stark abwertend);Horde (abwertend);Meute (abwertend);Schweinebande (derb, stark abwertend);(wilder) Haufen (abwertend);Rotte (Jargon);Pack (derb, abwertend)
-Andesit;Islandit
-Rudel;Meute;Herde;Schwarm;Schule;Sprung;Trupp;Gruppe (von Tieren);Koppel;Rotte
-Kohlrolle;Krautwurst;Kohlroulade;Krautwickel
-Divisionsgeneral;Divisionär
-Kindersärge (ugs., scherzhaft);sehr große Schuhe;Elbkähne (ugs., Hauptform, scherzhaft)
-Peplum (fachspr., Jargon);Antikfilm;Sandalenfilm;Antikenfilm
-Diözesanpriester;Weltpriester
-religiöser Idiot;Religiot
-Mäzenat;Mäzen
-saubere Arbeit! (ugs.);gut so!;gut gemacht!;richtig so!;(das war) richtig!
-Meiji-Ära;Meiji-Zeit;Meiji-Periode
-Merkantilismus;Colbertismus
-Islamisches Erwachen;Re-Islamisierung
-zum Islam bekehren;islamisieren
-liken (engl.);auf "gefällt-mir" klicken (ugs.);eine positive Bewertung abgeben;positiv bewerten
-Gezeiten (Plural);Tiden (Plural, norddeutsch)
-Weißbrot;Weizenbrot;Stuten (ugs., regional)
-Normalbenzin;Normal (ugs.)
-(ein) Fuzzi (ugs.);(ein) Niemand (sein);(ein) Nobody (engl.)
-Jammerlappen (ugs.);Jämmerling;Lauch (ugs., jugendsprachlich);Schlappschwanz (derb);Flasche (ugs.);Würstchen (ugs.);Lappen (ugs.);Schwächling (Hauptform)
-mit etwas ist kein Staat zu machen (variabel);nicht viel hermachen;niemanden beeindrucken
-Syrisch-Libanesischer Feldzug;Operation Exporter
-Knalltüte;Klatsche (ugs.)
-schläfrig;somnolent (fachspr.);benommen;schlaftrunken
-machen wir uns (da) nichts vor (ugs.);ich sag es, wie es ist;ich will ganz ehrlich zu dir sein (floskelhaft);mal ehrlich (ugs.)
-um es (einmal) klar auszusprechen;um das Kind beim Namen zu nennen (fig.);um es geradeheraus zu sagen
-Brotzeit;Vesper;Jause;Neuner;Znüni;Pause;Frühstückspause;Zweites Frühstück
-Amphetamin;Phenylisopropylamin (fachspr.);Speed (ugs.)
-politischer Gefangener;politischer Häftling
-UN-Zivilpakt;Internationaler Pakt über bürgerliche und politische Rechte;UNO-Pakt II (schweiz.)
-Internationales Protokoll über die biologische Sicherheit;Cartagena-Protokoll
-Übereinkommen über die biologische Vielfalt;Biodiversitäts-Konvention
-Nationale Biodiversitätsstrategie;Nationale Strategie zur biologischen Vielfalt
-Biotopverbund;Biotopvernetzung
-Notvorrat;eiserne Ration
-Teil;Sache;Eumel (ugs.);Örnie (ugs.);Dings (ugs.);Dingsbums (ugs.);Kamerad (ugs.)
-Wildschwein (Hauptform);Sus scrofa (fachspr., zoologisch);Schwarzkittel
-Gleichheitszeichen;Istgleichzeichen
-Kunstprodukt;von schlecht verhohlener Künstlichkeit (geh.);konstruiert (Hauptform);erdacht;aus der Retorte (fig.);am grünen Tisch entworfen (fig.);ausgedacht
-nur weg (hier)!;bloß weg (hier)!;rette sich, wer kann!;nichts wie weg (hier)!;lauf weg, so schnell du kannst! (Hauptform);nur raus (hier)!;schnell weg hier!;raus hier!;lauf um dein Leben!
-(jemanden) kalt abservieren (ugs., fig., variabel);(jemanden) fallenlassen (fig.);(den) Vertrag nicht verlängern
-decouragiert (geh., veraltet);entmutigt;demoralisiert
-verzagt (geh.);defätistisch (geh., religiös);ohne rechten Glauben an die Zukunft;ohne Zuversicht;resignativ (geh.);mutlos (Hauptform);defaitistisch (schweiz.)
-hat aufgegeben;will nicht mehr;ohne Aussicht;(hat) resigniert;ohne Hoffnung
-jemand ist sich für kein(e ...) zu schade;jemandem ist kein(e ...) zu blöd (ugs.);jemandem ist jede(r/s ...) recht
-einelementige Menge;Singleton (engl.);Einermenge
-initiales Objekt;Anfangsobjekt
-Endobjekt;terminales Objekt;finales Objekt
-Paarmenge;Paar;Zweiermenge
-es wird ernst;kein Spaß (mehr) sein;es geht ans Eingemachte (fig.)
-Intelligenztheorie;Intelligenzmodell
-gemütskrank;depressiv (fachspr., Hauptform, medizinisch);freudlos;dysthymisch (fachspr., medizinisch)
-(jemandem ist) nach Weinen;(jemandem ist) zum Heulen zumute;(jemand) möchte (am liebsten) weinen
-(die) Ohren hängen lassen;down;deprimiert;(ein) Tief haben;(das) heulende Elend haben (ugs.);bedrückt;depri;im Stimmungstief;(den) Moralischen haben;niedergeschlagen
-(jemanden) einschulen;(jemanden in etwas) unterweisen;(jemanden an etwas) heranführen;(jemanden) einarbeiten;(jemandem etwas) erklären;(jemanden) anlernen;(jemanden) einweisen;(jemandem) zeigen (was er zu tun hat) (ugs.);(jemanden in etwas) einweihen;(jemanden mit etwas) vertraut machen;(jemanden in etwas) einführen;(jemanden) anleiten
-in die erste Klasse (der ...schule) kommen;eingeschult werden;in die Schule kommen
-von Meisterhand;meisterlich;aus der Hand eines Meisters (variabel)
-(jemanden) mit der Nase darauf stoßen (fig.);schlafende Hunde wecken (fig.);auf sich aufmerksam machen;(jemandem etwas) auf die Nase binden (fig.);(unerwünschte) Aufmerksamkeit erregen
-auffallen durch;(sich) verdächtig machen
-(jemanden) an sich binden;(jemanden) zu seinem (treuen) Gefährten machen (variabel)
-(sich) einen Weg bahnen;pflügen (durch) (fig.)
-(rücksichtslos) seine Bahn(en) ziehen;(irgendwo) entlangpflügen (fig., variabel)
-wackelig sein;wackeln;keinen festen Stand haben;kippelig sein;nicht fest stehen;wackelig auf den Füßen stehen;wackelig stehen;auf wackeligen Füßen stehen
-Talking Board (engl.);Seelenschreiber;Ouija;Witchboard (engl.);Hexenbrett;Alphabettafel
-(sich) nach unten abgrenzen;(bei den besseren Kreisen) dazugehören wollen;auf sich halten;anspruchsvoll sein;(im Leben) Ansprüche stellen
-laute Begrüßung;großes Hallo
-in den späten Vierzigern;Ende 40;in seinen späten Vierzigern (männl.);nicht ganz 40 (Jahre alt);Ende vierzig (Alter);in ihren späten Vierzigern (weibl.)
-sichten;(sich) anschauen;(sich) umsehen;(sich) ansehen;(sich) umschauen bei
-unerwünscht sein;böse Blicke ernten (variabel);(es gibt) böse Blicke (variabel);nicht gern gesehen werden
-einem Missverständnis erliegen;(zum) Opfer eines Missverständnisses werden;einem Missverständnis aufsitzen;etwas missverstehen
-Woche für Woche;in jeder Woche (wieder);allwöchentlich;jede Woche (Hauptform)
-Lebensplan;Lebensmodell;Lebensentwurf;Idee vom Leben;Vorstellung vom Leben
-(nach der Devise) was kostet die Welt?;hoppla, hier komm ich! (Lebenseinstellung)
-krankfeiern (abwertend);(sich) eine Arbeitsunfähigkeitsbescheinigung ausstellen lassen (Amtsdeutsch);(sich) einen Krankenschein holen (ugs., veraltet);(sich) krankschreiben lassen;(sich seine) Arbeitsunfähigkeit (ärztlich) bescheinigen lassen (Amtsdeutsch);(sich) einen Gelben holen (ugs., veraltend);(sich) einen Krankenschein nehmen (ugs.)
-jemand, der für Ordnung sorgt;ordnungsstiftendes Prinzip;(eine) ordnende Hand
-Kruscht (süddt.);Kleinteile;kleine Teile;Tüddelkram(s) (ugs., norddeutsch);Krimskrams;Kleinscheiß (derb, abwertend);Kleinkram (Hauptform);Kleinmaterial
-es war nicht alles schlecht (Spruch);(etwas) hat(te) vielleicht auch etwas Gutes;wer weiß, wofür es gut ist (Spruch, variabel)
-Wegwerf...;Einmal...;Einweg...
-mit einem (guten) Ergebnis;gelungen;fruchtbringend;erfolgreich;produktiv;gewinnbringend;von Erfolg gekrönt
-Berliner Schnauze;loses Maul;freches Maul (ugs.);loses Mundwerk;Kodderschnauze (ugs.)
-(die) Niederungen (einer Sache) (fig.);so etwas Banales wie
-Basement (engl.);Nullebene
-Kernstadt;(eigentliches) Stadtgebiet
-Hurst-Enzephalitis;akute disseminierte Enzephalomyelitis;akute demyelinisierende Enzephalomyelitis;perivenöse Enzephalomyelitis
-Wallersche Degeneration;Waller-Degeneration
-subkortikale arteriosklerotische Enzephalopathie;vaskuläre Enzephalopathie;Morbus Binswanger
-Nukleus (fachspr.);Kerngebiet;Nucleus (fachspr.);Kern
-Ankerwährung;Leitwährung
-Münznominal;Nominal
-Albus;rheinischer Groschen;Weißpfennig
-Zinsgroschen;Mutgroschen;Schneeberger
-Sechsling;Sechser;Sößling
-Polnisch-Tschechoslowakischer Grenzkrieg;Siebentagekrieg
-Translozierung;Transferierung
-Dwinabusen;Dwinabucht
-Riesen... (ugs.);Mords... (ugs.);Wahnsinns... (ugs., emotional);sehr groß;gewaltig
-(der) lang erwartete Moment (ist da);(es ist) Zeit für den großen Auftritt
-(seiner / ihrer) Bestimmung übergeben (Tunnel / Brücke ...);eröffnen
-Tollhonig;Giftiger Honig;Pontischer Honig;Türkischer Wildhonig
-Floristik;Floristische Geobotanik
-(einen) Shitstorm auslösen;(einen) Skandal heraufbeschwören;in ein Wespennest stechen (fig.);(mächtig) Staub aufwirbeln (fig.)
-(einen) Nerv treffen (fig.);alte Wunden aufreißen (fig.);in ein Wespennest stechen (fig.);(ein) heißes Eisen anfassen (fig.);den Finger in die Wunde legen (fig., variabel);(einen) wunden Punkt berühren (fig.)
-runtergehen (ugs.);landen;zur Landung ansetzen;im Landeanflug (sein);einschweben (ugs.)
-Stanser Verkommnis;Stanser Verträge
-Saubannerzug;Zug des torechten Lebens;Kolbenbannerzug
-Apostolischer Palast;Papstpalast;Vatikanpalast
-Katzbalger;Landsknechtsschwert
-Saubär (oberdeutsch);männliches Hausschwein
-Prügelweg;Knüppelweg;Knüppeldamm;Bohlenweg
-Teilreserve-System;Fraktionales Reserve-System;Mindestreserve-System
-Währungsordnung;Währungssystem
-Guthabensicherung;Einlagensicherung
-Rückkaufvereinbarung;Repo (engl.)
-Stückzins;Marchzins (schweiz.)
-Aktiendarlehen;Aktienleihe
-Blankodarlehen;Blankokredit
-Beleihungssatz;Beleihungsgrenze
-Kreditsicherung;Kreditsicherheit
-Grundsatzprogramm;Parteiprogramm
-Amputation nach Spitzy;Amputation nach Pirogoff-Spitzy;Pirogoff-Amputation;Amputation nach Pirogoff
-Fahrradschlauch;Schlauch (ugs.)
-Pflasterung;Pflasterdecke
-Sandweg;(Weg mit) wassergebundene(r) Wegedecke (fachspr.);Schotterweg
-(temporäre) Baustellenzufahrt;Baustraße;Behelfsstraße;Fahrweg
-rechtlich durch ein Patent schützen;patentieren
-freimachen;frei schaufeln;(wieder) freilegen;freischaufeln
-sich Drogen spritzen;fixen;drücken (ugs., Jargon)
-(gemeinsam) ans Laufen bringen;beim Start unterstützen (Hauptform);über die Startschwierigkeiten hinweghelfen;(jemandem) auf die Sprünge helfen;Geburtshilfe leisten (fig.)
-(jemandem) einen Tipp geben;(jemandem) auf die Sprünge helfen;(jemandem) einen Stups in die richtige Richtung geben;(jemandes) Gedächtnis auf die Sprünge helfen
-(einer) Bankrotterklärung gleichkommen;(das) eigene Versagen zugeben;(das) Eingeständnis, (mit ...) gescheitert zu sein;zugeben, gescheitert zu sein
-Ermittlung des Leistungsstands;Lernstandserhebung (fachspr., Jargon)
-(jemanden) Nachhilfe geben;(jemanden) belehren
-freundlich ignorieren;(etwas) weglächeln
-charmant überspielen;(etwas) weglächeln
-Hollywood;(die) Traumfabrik
-kommutativ (fachspr., lat., mathematisch);permutierbar (fachspr., lat., mathematisch);kommutabel (fachspr., lat.);umstellbar;vertauschbar
-Bruchflügel;Block;Scholle
-Verwerfungslinie;Bruchlinie;Störungslinie
-anstehendes Gestein;Anstehendes
-Feuerletten (veraltet);Trossingen-Formation;Knollenmergel (veraltet)
-Matrjoschka;Matroschka
-UN-Menschenrechtscharta;Allgemeine Erklärung der Menschenrecht;Deklaration der Menschenrechte
-Arabische Charta der Menschenrechte;Arabische Menschenrechtscharta
-Europäische Charta für Forscher;Charta der Wissenschaft
-Union von Lublin;Lubliner Union
-Warschauer Religionsfriede;Konföderation von Warschau
-Katecholamine;Catecholamine;Brenzcatechinamine
-Urlaub machen;im Urlaub sein;Urlaub haben;in Urlaub sein;urlauben (ugs.);auf Urlaub sein
-allerdings;schon;denn doch;nur
-dahaben (ugs.);vorrätig haben;im Programm haben (ugs., Jargon);(jemandem etwas) anbieten können;verkaufen (können);liefern (können);(etwas) bekommen Sie (bei uns) (variabel);(bei uns) zu bekommen sein;(etwas) feilhalten (geh., veraltet);im Sortiment haben (auch figurativ, Hauptform);im Angebot haben;(etwas) führen
-(sich) geheimnisvoll gebärden;(ein) Geheimnis machen (aus);geheimnisvoll tun
-Hilfsaktion;Rettungsaktion
-(die) Vermögensauskunft erteilen;(die) EV abgeben;(die) eidesstattliche Versicherung abgeben;(den) Offenbarungseid leisten
-Offenbarungseid;EV (Abkürzung);Versicherung an Eides statt;E. V. (Abkürzung);eidesstattliche Versicherung (Hauptform)
-pleite gehen (ugs.);(seinen) Bankrott erklären;(sich) für zahlungsunfähig erklären;insolvent werden;in Konkurs gehen;in die Insolvenz gehen;(sich) (für) bankrott erklären
-(sich) ergaunern;(sich) erschleichen;(für sich) organisieren;(sich) erschwindeln
-Neuverfilmung;Remake (engl.);nochmalige Verfilmung
-Neueinspielung;Coverversion;Neufassung;Neuaufnahme
-Geldwesen;Finanzwesen
-Mischungsschmierung;Gemischschmierung
-Gartenkolonie;Laubenkolonie
-Taschenschirm;Knirps (Markenname)
-Papierwarenhandlung;Papeterie (franz., schweiz.);Papierwaren
-Studien- und Prüfungsordnung (fachspr.);SPO
-Nasenklammer;Akkolade;geschweifte Klammer;Schweifklammer
-linke geschweifte Klammer;öffnende geschweifte Klammer
-(eine) böse Überraschung erleben;(sein) blaues Wunder erleben (sprichwörtlich);unangenehm überrascht werden
-Arbeit im Plenum;Klassenunterricht;Frontalunterricht (Hauptform)
-Verteilungsprinzip;Verteilungsregel
-nach seinen Worten;(getan haben / gewesen sein) wollen;seiner Aussage zufolge;nach dem, was er sagt (ugs.);wie er behauptet;seiner Aussage nach;so wie er sagt (ugs.);ihm zufolge (Amtsdeutsch);behaupten (etwas getan zu haben)
-angeblich;ach so (Einschub vor Adjektiv) (ugs.);Berichten zufolge;wie man nicht müde wird zu betonen (floskelhaft, variabel);wie man sagt;sollen (geh.);wie behauptet wird;es heißt, dass (geh.)
-Münzwäscherei;Waschsalon
-Damoklesschwert;latente Bedrohung;tickende Zeitbombe (fig.);latente Gefahr
-Kläpperkes (ugs., ruhrdt.);Holzsandale;Kläpperchen (ugs.)
-Clog;Holzpantoffel;Klotschen
-Arbeitsschuh;Sicherheitsschuh
-Pfennigabsatz;Bleistiftabsatz
-Absatz-Sandale (für Damen);Sandalette(n) (Hauptform)
-Suchtstoffübereinkommen;Betäubungsmittelkonventionen
-Nebeneffekt;Seiteneffekt
-Automat;abstrakte Maschine
-nervenaufreibende Partie (variabel);Fußballkrimi;Fußballdrama
-Lebensraumtyp;FFH-Lebensraumtyp
-Vordüne;Primärdüne
-Haldendüne;Sekundärdüne;Weißdüne
-Europäischer Frauenschuh;Frauenschuh;Marienfrauenschuh;Gelber Frauenschuh;Gelb-Frauenschuh
-Balneotherapie;Bädertherapie
-biomedizinische Analytik;medizinisch-technischer Laboratorumsdienst (veraltet)
-Medizinisch-technischer Dienst (österr.);Funktionsdienst
-Strukturaufklärung;Strukturanalyse
-Silberspiegelprobe;Tollensprobe
-Iodoformprobe;Lieben-Reaktion
-Tau (Hauptform);Frühtau;Morgentau
-mit Reif überzogen;mit Reif bedeckt;bereift;von Reif bedeckt;von Reif überzogen;reifbedeckt;reifüberzogen
-von einer Eiskruste überzogen;Eisüberzug;Klareis
-Eisklumpen;Hagel (Hauptform);Eiskörner
-Hagelkorn;Eiskorn
-Hagelschauer;Hagelschlag
-Schnee mit Regen vermischt;Schneeregen
-Teamberaterin (weibl.);Supervisor (männl.);Supervisorin (weibl.);Teamberater (männl.);Coach (ugs., fig.)
-Wo ein Wille ist, (da) ist auch ein Weg. (Sprichwort);Man muss (es) nur wollen. (variabel)
-Psychoanalytiker;Analytiker;analytisch arbeitender Psychotherapeut
-Joggingschuh;Laufschuh
-so ein Blödmann! (ugs., variabel);(Mann,) war das (vielleicht) ein Idiot! (ugs., variabel);Wie blöd kann man sein!? (ugs., Spruch, variabel);was für ein dämlicher Hund! (ugs., fig., variabel);Scheiße, wenn man doof ist. (derb, Spruch);Doof bleibt doof, da helfen keine Pillen. (ugs., veraltet)
-vom alten Schlag (ugs.);(von) der alten Garde;vom alten Schrot und Korn (fig.);alter Schule (fig.);(...) der alten Schule
-Hauptmarschall der Truppengattung;Hauptmarschall der Waffengattung
-Nedelin-Katastrophe;Nedelin-Desaster
-Godiva-Apparat;Godiva-Reaktor
-Pseudoperitonitis;Scheinperitonitis;Abdominalsyndrom
-Ischurie;Harnverhaltung;Harnverhalt
-Tanzpest;Choreomania;Veitstanz;Tanzsucht;Tanzwut;Choreomanie;Tanzkrankheit;Tanzplage (historisch)
-Mädchen für alles (Filmset) (fig.);Set-Runner
-Kulissenschieber (abwertend, veraltend);Bühnenarbeiter
-Aktionsturbine;Impulsturbine;Gleichdruckturbine
-wohlmeinend;voll der besten Absichten;freundlich bemüht;im besten Glauben (etwas Gutes zu tun)
-Jeder gegen jeden;Rundenturnier
-Einzelausscheidung;K.-o.-System
-Gebälk;Balkenverband;Balkenwerk
-(für jemanden) ist die Welt in Ordnung;(dann) freu dich (doch)! (Spruch);fein raus sein;(jemand) hat gut reden;(jemand) kann (gut) lachen;(jemand) hat gut lachen (Hauptform);(wie) schön für dich! (Spruch)
-stärker;(jemandem) überlegen;besser;mehr draufhaben;(jemandem) über
-gelassen;sicher;überlegen;souverän;locker (ugs.)
-(so leicht) nicht zu erschüttern;seelenruhig;dickfellig;(so leicht) nicht aus der Ruhe zu bringen (Hauptform);(jemanden) bringt so schnell nichts aus der Ruhe (floskelhaft);cool drauf (ugs.);ungerührt;unbeeindruckt
-Containment (engl.);Sicherheitsbehälter
-Reaktorkessel;Reaktordruckbehälter
-Schlüsselfertiges Bauen;SF (Abkürzung);SF-Bau (Abkürzung)
-Grafiktablett;Digitalisiertablett
-haptische Wahrnehmung;Haptik
-Spielekonsole;Spielkonsole
-Konsolengame;Konsolenspiel
-PC-Game;PC-Spiel;Computergame;Computerspiel
-Unterschriftenpad;Signaturtablett
-Digitizer;aktiver Stylus;aktiver Eingabestift
-Eingabestift;Stylus (engl.);Touchpen (engl.)
-Digitale Kunst;Digitalkunst
-Antitheismus;starker Atheismus
-Politmarionette;Marionettenpolitiker
-Spinne;Polypgreifer;Schrottgreifer;Mehrschalengreifer
-Einachstraktor;Einachsschlepper;Einachser (ugs.)
-Siemens-Schuckert;Siemens-Schuckertwerke
-Schaltwerk-Hochhaus (Eigenname);Wernerwerk-Hochbau (Eigenname);Wernerwerk-Hochhaus (Eigenname, Hauptform);Wernerwerk X (Eigenname);Gebäudegruppe 10 (Eigenname)
-Treuhandanstalt;Treuhand
-Landtag Steiermark;Steiermärkischer Landtag (veraltet)
-steirisch;steiermärkisch
-Bundesministerium für Bildung und Frauen;Unterrichtsministerium (Kurzform)
-Pangea (selten);Pangäa;Pangaea
-Begriffsverhältnis;Begriffsbeziehung
-gewöhnlicher Bruch;gemeiner Bruch
-Lothringer Bauernhaus;Lothringerhaus
-Eindachhof;Einfirsthof;Einhof
-Fruchthaus;Speicher;Fruchtkasten;Packhaus;Bodenspeicher;Lagerhaus (Hauptform)
-Vierkanthof;Vierkanter (österr.)
-südwestdeutsches Einhaus;südwestdeutsches Bauernhaus;breitgegliedertes Einfirsthaus
-Einfirsthaus;Einhaus
-(jütisches quergeteiltes) Geesthardenhaus;Schleswiger Haus;cimbrisches Haus
-Gulfhof;Ostfriesenhaus;Gulfhaus
-Hallenhaus;Niedersachsenhaus (volkstümlich)
-Haubarg;Hauberg
-uthlandfriesisches Haus;Friesenhaus
-Uthlande;Utlande
-Grote Mandrenke (niederländisch);Grote Madetuen;zweite Marcellusflut;Mandrankels
-Haufenhof;Gruppenhof
-wie von einem bösen Geist getrieben (variabel);(wie) besessen;manisch;(wie) getrieben;übereifrig;blindwütig
-Orientierungsmaßstab;Richtschnur;Handlungsmaxime
-Hirnorganisches Psychosyndrom (veraltet);Organisches Psychosyndrom
-Flugzeugschleuder (veraltet);Flugzeugkatapult
-Capstan;Tonwelle
-Mockbuster;Knockbuster
-Lotos;Lotosblume
-Abstreitbarkeit;Bestreitbarkeit
-Darstellungsmatrix;Abbildungsmatrix
-projektive Kollineation;Projektivität
-Ziehharmonikabus (ugs.);Gelenker;Schlenki (ugs.);Gelenkbus;Gelenkzug;Gliederbus;Gelenkwagen;Schlenker (ugs.)
-Gelenkfahrzeug;Gliederfahrzeug
-Schlenker (ugs.);Gelenkoberleitungsbus;Schlenki (ugs.)
-Solowagen;Solobus;Normalbus
-Harmonikainstrument;Harmonika
-Car (franz., schweiz.);Fernbus;Autocar (schweiz.);Reisecar (schweiz.);Reisebus (Hauptform)
-elektronische Patientenakte;elektronische Gesundheitsakte
-Krankenakte;Patientenakte
-Recht auf Selbstauskunft;Recht auf Eigenauskunft
-Selbstauskunft;Eigenauskunft
-Falttür;Ziehharmonikatür;Harmonikatür
-mangelhaft;Note 5;Note mangelhaft;Note fünf;eine Fünf
-einesteils ... zum anderen ...;zwar ... aber ...;(die) zwei Seiten der Medaille (fig., sprichwörtlich);zum einen ... zum anderen ...;einerseits ... andererseits ...;auf der einen Seite ... auf der anderen Seite ...;(ein) zweischneidiges Schwert (fig., sprichwörtlich)
-Nagelsperre;Nagelband;Nagelstreifen;Nagelkette;Nagelgurt (schweiz.);Reifenkiller (ugs.)
-anhäufend;zusammentragend;sammelnd
-Empirismus;Positivismus
-Lehre vom Übernatürlichen;Lehre vom Ursprung, Voraussetzungen und Sinn des Seins (geh.);Metaphysik (Philosophie, Hauptform)
-Naturlehre;Naturforschung;Naturwissenschaft
-Idiolatrie (fachspr., griechisch);Selbstvergötterung
-Pferdemensch;Zentaur (Hauptform);Kentaur
-der letzte sein;ganz am Schluss (kommen);ganz zuletzt (kommen);ganz zum Schluss (kommen);das Schlusslicht bilden (fig.)
-als allerletztes;am hintersten Ende;zuallerletzt;ganz zuletzt
-ich möchte es (einmal) so formulieren;ich will es mal so sagen (Hauptform);ich sag' mal so (ugs.);lassen Sie es mich so ausdrücken;sagen wir mal so (ugs.);wir wollen mal sagen;lassen Sie es mich so sagen;lass es mich dir so erklären;ich möchte es (einmal) so sagen;ich würde es vielleicht so ausdrücken (variabel)
-Muay Thai (Hauptform);Muai Thai;Thaiboxen
-Grannenkiefer;Pinus longaeva (fachspr., botanisch);Langlebige Kiefer (fachspr., botanisch)
-Tränen-Kiefer (fachspr., botanisch);Pinus wallichiana (fachspr., botanisch);Tränenkiefer
-Taxus cuspidata (fachspr., botanisch);Japanische Eibe (fachspr., botanisch)
-Taxus (fachspr., botanisch);Eibe
-Fruchtende Bechereibe (fachspr., botanisch);Taxus x media 'Hicksii' (fachspr., botanisch)
-Bechereibe;Taxus x media (fachspr., botanisch);Hybrid-Eibe (fachspr., botanisch)
-nicht fruchtende Bechereibe (fachspr.);männliche Bechereibe;Taxus x media 'Hillii' (fachspr., botanisch)
-Säuleneibe;Taxus baccata 'Fastigiata' (fachspr., botanisch)
-Waldkiefer;Kiefer (ugs.);Wald-Kiefer (fachspr., botanisch);Pinus sylvestris (fachspr., botanisch);Gemeine Kiefer (fachspr., botanisch);normale Kiefer (ugs.)
-Strobe;Weymouth-Kiefer (fachspr., botanisch);Pinus strobus (fachspr., botanisch);Weymouth(s)kiefer
-Pinus nigra (fachspr., botanisch);Schwarzkiefer
-Pinus nigra ssp. nigra (var. austriaca) (fachspr., botanisch);Parapluie-Baum (ugs., wienerisch);Österreichische Schwarzkiefer (fachspr., botanisch);Schirmföhre
-(jemandem) geht es prächtig;gut wachsen;(jemandem) geht es gut;gedeihen;aufblühen (Mensch) (fig.);(sich) gut entwickeln
-hervorsprießen;treiben;Triebe bilden;austreiben;ausschlagen;Triebe ansetzen;sprießen
-(einen) Blühtrieb bilden;schießen (bestimmte Gemüsepflanzen) (ugs., Jargon);Ähren schieben (fachspr.)
-Spektrograf;Spektrograph
-(sich) an die Tatsachen halten;(sich) nicht in Spekulationen ergehen;(sich) auf die Tatsachen beschränken;bei den Fakten bleiben;(sich) an die Fakten halten;nicht herumspekulieren;nur glauben, was man sieht
-kühn (Behauptung);steil (These);abenteuerlich (Vermutung o.ä.);forsch (Aussage);gewagt (Annahme o.ä.)
-Mädel (ugs., süddt.);Kleines (Anrede);Schickse (regional, veraltend);Mädle (ugs., schwäbisch);Kindchen (Anrede);(eine) Kleine;Maderl (ugs., süddt.);Gör(e) (ugs., regional);Mäderl (ugs., süddt.);Mädchen (Kind) (Hauptform);Deern (ugs., norddeutsch);Mad(e)l (ugs., süddt.);kleines Mädchen
-Wildtyp (fachspr.);Wildform
-Zuchtform;Ziersorte (Pflanze)
-Nutzpflanze;Nutzsorte;Kulturpflanze
-(den) Teufel mit dem Beelzebub austreiben (fig.);Wer einen Sumpf trockenlegen will, darf nicht die Frösche fragen. (fig., sprichwörtlich, variabel);(den) Bock zum Gärtner machen (fig.);(das) Gegenteil von dem tun, was getan werden müsste
-Auge um Auge, Zahn um Zahn.;(jemandem) mit gleicher Münze heimzahlen;(jemandem) mit gleicher Münze zurückzahlen;Wie du mir, so ich dir.;Gleiches mit Gleichem vergelten
-Bongert;Obstwiese;Bitz;Bangert;Obstbaumwiese;Bungert;Streuobstwiese (fachspr., Hauptform);Obstgarten
-angewiesen auf;(einer Sache) verfallen;unbedingt brauchen;(körperlich) abhängig (von);süchtig (nach)
-(jemanden) am Wickel haben (ugs.);(jemanden) am Arsch haben (derb);(sich) jemanden kaufen (ugs.);(jemanden) drankriegen (ugs.);(etwas) gegen jemanden in der Hand haben;(er) gehört mir
-Windpark (Hauptform);Windfarm
-Ravennagras;Elefantengras
-Uganda-Gras;Elefantengras;Napiergras
-Gedenkstätte;Kranzabwurfstelle (sarkastisch)
-arroganter Pinsel (ugs., abwertend);aufgeblasener Wichtigtuer (ugs., abwertend);eingebildeter Schnösel (ugs., abwertend)
-Großtuer;Wichtigtuer;Gschaftlhuber (ugs., süddt.)
-Streit unter Frauen;Zickenalarm (ugs., salopp);Stress haben (Frauen / Mädchen) (ugs.);Zickenkrieg (ugs.);Zickenterror (ugs., salopp);Streit haben (Frauen / Mädchen);Streit zwischen Frauen
-besser geht's (wohl) nicht;was will man mehr! (ugs.);mehr kann man nicht verlangen!
-früh dran (sein) (ugs.);noch nicht mit jemandem gerechnet haben (ugs.);ungewohnt früh (kommen);früher als erwartet (kommen)
-(jemanden) früher erwartet haben;hätte schon längst hier sein müssen;spät dran (sein);früher mit jemandem gerechnet haben;ungewohnt spät (kommen)
-(sich) anhören nach;klingen nach;(sich) anhören wie
-alles andere überdecken(d) (variabel);wie ein siebenstöckiges Freudenhaus (ugs.);penetrant;dominant;sich vordrängen(d);aufdringlich (Geruch, Duft) (Hauptform);in die Nase stechen(d);intensiv;stark;durchdringend
-mit schwerem Gerät (fig.);mit dem Vorschlaghammer (fig.);brachial;mit der Brechstange (fig.);mit brachialen Methoden;mit dem Holzhammer (ugs., fig.);auf die harte Tour (ugs., salopp);unter Einsatz von Gewalt;gewalthaft (geh., auch figurativ);im Holzfäller-Stil (ugs., fig.);gewaltsam;mit (roher) Gewalt
-mit der Holzhammermethode arbeiten (fig.);gewaltsam vorgehen;zu rabiaten Methoden greifen;mit dem Holzhammer vorgehen (fig.);mit der Brechstange herangehen (fig.)
-(sich) gesucht und gefunden haben;füreinander bestimmt (sein);zusammengehören
-in Fransen;ausgefranst;fransig;mit Fransen
-Mindesteinkommen;Grundeinkommen
-Hilfe zum Lebensunterhalt;HLU (Abkürzung)
-Sturm;Sturmwind;Windsbraut (geh., literarisch, veraltend);heftiger Wind;stürmischer Wind
-arm dran sein (ugs.);ein Problem haben;in den Arsch gekniffen sein (ugs.);(einfach) Pech gehabt haben;in (echten) Schwierigkeiten sein;gekniffen sein (ugs.)
-sich in Demut üben;(Bereitschaft) Dinge hin(zu)nehmen, die man nicht ändern kann;sein Schicksal annehmen;demütig sein
-Zivilist;Zivilperson
-zu fassen kriegen (ugs.);(jemandem) zwischen die Finger geraten (ugs.);in die Hand bekommen;erwischen;herankommen an (auch figurativ);zu greifen bekommen
-jeder hat es einmal (in der Hand) (gehabt) (variabel);durch alle Hände gehen
-viele Vorbesitzer gehabt haben;häufig den Besitzer gewechselt haben;durch viele Hände gegangen sein (fig.)
-im Beisein (von);in Anwesenheit (von);unter Anwesenheit (von)
-(der) Hölle entsprungen;Ausgeburt der Hölle;direkt aus der Hölle (ugs.)
-nicht vorschnell entscheiden;(sich etwas) gut überlegen;(etwas) nicht übers Knie brechen;(etwas) will gut überlegt sein;(etwas) nicht überstürzen
-(jetzt) noch einmal für (ganz) Doofe (beleidigend) (ugs.);(jetzt) noch einmal zum Mitschreiben
-sieh dich vor!;nimm dich in acht!;sei auf der Hut!;sei vorsichtig!
-(sonst) geschieht ein Unglück;gnade dir Gott;wehe (dir) (wenn);... dann Nacht Mattes (ugs., rheinisch)
-unter Wert (Hauptform);Billig...;zu Dumpingpreisen;zum Dumpingpreis;zum Freundschaftspreis (verhüllend)
-tesa (Markenname);Tixo (Markenname, österr.);Tesafilm (Markenname);durchsichtiges Klebeband
-(etwas) offen ansprechen;(jemandem etwas) an den Kopf werfen (fig.);(jemandem etwas) auf den Kopf zusagen;(jemandem etwas) direkt ins Gesicht sagen;(jemanden) konfrontieren mit;(jemandem etwas) vor den Latz knallen (ugs., fig.)
-vapen (engl.);e-rauchen;dampfen
-Q-Gruppen;Q-Schlüssel
-rauchen;Raucher sein
-wieder mit dem Rauchen angefangen haben;wieder angefangen haben zu rauchen;wieder rauchen
-nicht mehr rauchen;mit dem Rauchen aufgehört haben;aufgehört haben zu rauchen
-wegrauchen;aufrauchen
-(einen) Zug nehmen;ziehen an (Zigarette, Pfeife)
-genussrauchen;(sich) gemütlich eine rauchen (ugs.);(s)ein Pfeifchen schmauchen (ugs.);schmauchen (seine Pfeife, Shisha)
-(jemandem) widerfahren (geh.);(jemandem) unterkommen;(jemandem) zustoßen;(etwas) erleben;(jemandem) passieren;(jemandem) vorkommen
-stoßen auf;erfahren (geh.);treffen auf;zuteil werden (geh.)
-sich befinden;erfahren;(irgendwo) sein (fig.);erleben;haben
-Formation;Zusammensetzung (Band)
-Frontsänger;Leadsänger
-Background-Sänger;Backing Vocalist (fachspr., Jargon);Begleitsänger
-Melodiestimme (Hauptform);Leitstimme;führende Stimme;Lead Vocal (fachspr., Jargon, engl.);Hauptstimme;Melodie
-wieder zu Ehren kommen;zu neuen Ehren gelangen;Aufwertung erfahren;wieder in Mode kommen (ugs.);(ein) Comeback feiern (fig.);wieder hochgehalten werden;zu neuen Ehren kommen;wieder da sein;wieder eine Vorbildrolle einnehmen;aufgewertet werden
-(wieder) zum Leben erweckt werden;aus dem Dornröschenschlaf geweckt werden (fig.)
-Wiederauferstehung feiern (als ...);eine neue (kreative) Verwendung bekommen;zu neuen Ehren kommen (fig.)
-zünden (Witz, Pointe) (fig.);sitzen (fig.);treffen
-es jemandem gezeigt haben;es jemandem gegeben haben;gesessen haben;(jemandem) die passende Antwort gegeben haben
-herumstottern;(jemandem) gehen die Argumente (/ Ideen) aus (ugs.);(he)rumeiern (ugs.);ins Trudeln kommen (ugs., fig.);nichts (Rechtes) zu sagen finden;ins Schleudern kommen (ugs., fig.);nicht wissen, was man (noch) sagen soll;in Erklärungsnot (kommen);ins Schwimmen kommen (ugs., fig.)
-heikle Frage (von deren Beantwortung alles abhängt);Gewissensfrage;Gretchenfrage
-Kardinalfrage;wichtig(st)e Frage;Kernfrage;Frage, an der alles hängt;Gretchenfrage;Hauptfrage;entscheidende Frage;Schlüsselfrage
-Veme;Feme
-Bund Wiking;Wikingbund
-Konstantsummenspiel;Spiel mit konstanter Summe
-Wachstumswende;Entwachstum;Wachstumsrücknahme;Postwachstum
-(viel) Zeit mitbringen müssen;(eine) Geduldsprobe (sein);viel Zeit erfordern;nicht von heute auf morgen zu machen sein;(ein) Geduldsspiel (sein) (fig.);(sich) lange hinziehen (können)
-Schwarzhäupter;Schwarzenhäupter
-Danziger Verfassung;Danziger Recht;Danziger Willkür
-Bauwerksensemble;Bauensemble;Ensemble;Gebäudeensemble
-in einen instabilen Zustand geraten (scherzhaft);(das) Gleichgewicht verlieren;(den) Boden unter den Füßen verlieren;(jemanden) umhauen (ugs.);(den) Halt verlieren;(jemandem) zieht es die Beine weg
-ohnmächtig werden;(das) Bewusstsein verlieren;bewusstlos werden;in Ohnmacht fallen;kollabieren (fachspr., medizinisch);(auf einmal) weg sein (ugs.);aus den Latschen kippen (ugs., fig., salopp);(die) Besinnung verlieren
-(noch) Welpenschutz genießen (ugs.);(noch) unter Welpenschutz stehen (ugs.);(noch) Welpenschutz haben (ugs.)
-(in sich) zusammensacken;(in sich) zusammenfallen;niedersinken;(in sich) zusammensinken
-fallen auf (Körperteil);aufschlagen mit (Körperteil)
-weggleiten;ausgleiten;ausrutschen;(jemandem) zieht es die Beine weg (ugs.);wegrutschen;abgleiten;abrutschen
-(jemandem von irgendwoher) fallen;(irgendwoher / irgendwohin) fliegen (Gegenstand) (ugs.);fallen (Gegenstand) (Hauptform);zu Boden fallen;(jemandem irgendwohin) fallen;auf den Boden fallen;(jemandem) hinfallen
-in den Fokus stellen;in den Vordergrund stellen;hervorheben;Wichtigkeit beimessen
-Plumps machen;ins Wasser plumpsen;(irgendwo) hineinplumpsen;mit einem dumpfen Geräusch aufschlagen;plumpsen;zu Boden plumpsen
-plumpsen;Plumps machen (scherzhaft)
-kollern;purzeln (Hauptform)
-nach hinten fallen;hinten(r)überfallen;nach hinten kippen;auf den Rücken fallen
-auf den Po fallen;(sich) auf den Arsch setzen (ugs.);auf den Hintern fallen;(sich) auf den Arsch legen (ugs.);(sich) auf den Hintern setzen (ugs., scherzhaft)
-Führungstraining;Führungskräftetraining
-bekannte Fernsehgesichter;Fernsehprominenz
-Promitreff;Promi-Party;Jahrmarkt der Eitelkeiten;Sehen und Gesehen-Werden
-Mangelware sein (fig.);es fehlt an;(es gibt) wenig(e);fehlen (inhaltlich);auf sich warten lassen (fig.);mit der Lupe zu suchen sein (fig.);zu kurz kommen;(es gibt) nicht viel(e)
-Baulandumlegung;Umlegung
-Felsenbeinpyramide;Pyramis (veraltet);Felsenbein
-lichter Moment;Moment geistiger Klarheit;Moment der Erleuchtung
-kurzzeitig bei klarem Verstand sein;(einen) lichten Moment haben
-in einzelnen Momenten;momentweise;augenblicksweise;für kurze Augenblicke
-episodisch;phasenweise;etappenweise
-floskelhaft;schablonenhaft;schablonesk (geh., selten);formelhaft
-phraseologisch (fachspr., Sprachwissenschaft);fest gefügt;idiomatisch (geh.);redensartlich;sprichwörtlich
-an seine Pflichten (im Wachdienst) erinnern;(jemanden) vergattern (Hauptform);(jemanden) über seine Pflichten (im Wachdienst) belehren;(jemandem formell) dem Wachdienst unterstellen
-der will nur spielen (ugs.);der tut nichts (ugs.)
-ich bin nicht giftig (ugs., scherzhaft);ich beiß(e) nicht (ugs., Spruch, scherzhaft);ich tu dir (schon) nichts (ugs., scherzhaft)
-vesikoureteraler Reflux;vesikorenaler Reflux;vesiko-uretero-renaler Reflux
-Harnleitermündung;Uretermündung;Ureterostium
-Fazialislähmung;Fazialisparese;Gesichtslähmung
-geflügeltes Wort (Hauptform);bekannter Ausspruch;Diktum;(bekanntes) Zitat;berühmtes Wort
-(Missverständnis) aufklären;(Missverständnis) ausräumen
-nicht angehen (Problem);ungelöst (im Raum stehen) lassen;(alles) so lassen, wie es ist (ugs.)
-auf ein Wunder warten (fig.);darauf spekulieren, dass etwas (mit der Zeit) vergessen wird;aussitzen (wollen);(abwarten bis) Gras über etwas gewachsen ist;Wenn du lange genug am Fluss sitzt, siehst du irgendwann die Leiche deines Feindes vorbeischwimmen. (sprichwörtlich, variabel);hoffen, dass sich etwas von selbst erledigt (variabel)
-nicht oft genug;immer und immer wieder;lieber einmal zu viel als einmal zu wenig
-man kann es nicht oft genug sagen;wir wollen niemals vergessen (dass);man kann gar nicht oft genug wiederholen (dass);man muss immer wieder daran erinnern (dass)
-Held (ugs., scherzhaft-ironisch);Marke (ugs.);Herzchen (ugs., Hauptform, scherzhaft-ironisch);Flocke (ugs., scherzhaft-ironisch);Motte (ugs., scherzhaft-ironisch, veraltet)
-Schwund;Degeneration;Mangelernährung (medizinisch);Phthise (fachspr., medizinisch);Marasmus (fachspr., medizinisch);Abbau;Kachexie (fachspr., medizinisch);Verfall;Phthisis (fachspr., medizinisch)
-Strom-Spannungs-Wandler;Transimpedanzverstärker;I-U-Wandler
-Nernst-Gleichung;Peterssche Gleichung
-GHK-Gleichung (Kurzform);Goldman-Gleichung;Goldman-Hodgkin-Katz-Gleichung
-Transmembranpotential;Membranpotential;elektrischer Gradient
-Konzentrationszelle;Konzentrationselement
-Siachen-Krieg;Siachen-Konflikt
-Vorbereitungskurs;Vorkursus;Propädeutikum;Einführungsveranstaltung;Vorkurs
-Verursachungsgerechtigkeit;Kostenwahrheit
-Hülle aus Seidengespinst, die von Larven vieler Insekten stammen;schützende Hülle;Kokon (ugs., franz.)
-aschkenasischer Jude;Aschkenasi;Aschkenase
-pflegeleicht;macht nicht viel Arbeit
-(man) muss sich nicht viel kümmern (um) (ugs.);pflegeleicht (Person in Obhut);nicht anspruchsvoll;verlangt nicht viel Aufwand
-(die) Stimme erheben (geh.);laut(er) werden (ugs.)
-Friedensvertrag von Brest-Litowsk;Raubfrieden von Brest-Litowsk (DDR)
-eine geschlagene Stunde;eine ganze Stunde (lang);eine volle Stunde
-Transkaukasische Föderation;Transkaukasische Demokratisch-Föderative Republik
-Kleiner Kaukasus;Anti-Kaukasus
-Adscharo-Imeretisches Gebirge;Meschetisches Gebirge
-Adscharien;Adschara
-Transkaukasische Depression;Transkaukasische Senke
-Kuban-Gebiet;Kubanscher Landstrich (veraltet)
-Kalmükien;Kalmückien;Kalmykien
-Handzuginstrumentenmacher;Harmonikamacher (österr.)
-Holzblasinstrumentenbauer;Holzblasinstrumentenmacher
-Metallblasinstrumentenmacher;Blechblasinstrumentenbauer
-Instrumentenbauer;Instrumentenmacher
-autoritärer Erziehungsstil;Autoritarismus
-Westernisierung;Verwestlichung
-(Zeit) in Anspruch nehmen;(Zeit) erfordern;(eine Zeit) dauern;(eine Zeit) brauchen;(eine Zeit) währen (geh.);gehen (/ gehen über) (ugs.);(sich) erstrecken (über)
-Restzeit;verbleibende Zeit
-Bergbuch;Bergamtsbuch
-Erzrevier Bensberg;Bensberger Erzrevier
-Bergbaurevier;Bergrevier
-zweiter Japanisch-Chinesischer Krieg;zweiter Sino-Japanischer Krieg
-Backe-Plan;Hungerplan
-(jemanden finanziell) kurzhalten;(jemandem) (ganz) wenig Geld geben
-die Frage erübrigt sich eigentlich;du weißt die Antwort;dreimal darfst du raten (...)! (ugs.);die Antwort kennst du (sicher) schon;frag nicht so blöd! (derb);die Antwort ist eh klar (ugs.);Wonach sieht's denn aus? (ugs.)
-Multilaterales Abkommen über Investitionen;Multilaterales Investitionsabkommen
-Randalierversuch;Randaleversuch;Randalationsversuch
-Rojava;Rodschawa;Westkurdistan
-Akkusationsprinzip;Anklagegrundsatz
-Prozessmaxime;Prozessgrundsatz
-Beibringungsgrundsatz;Verhandlungsgrundsatz
-Zivilverfahrensrecht;Zivilprozessrecht
-Zivilprozess;Zivilverfahren
-Strafprozess;Strafverfahren
-Verfügungsgrundsatz;Dispositionsmaxime
-Offizialmaxime;Offizialprinzip
-wieder reinkommen (ugs.);nachgeliefert werden
-Neugrad (veraltet);Gon
-Spannweite;Stützweite
-nicht mehr zurück können;(da jetzt) durchmüssen
-hagebüchen (veraltet);beispiellos;hanebüchen;unfassbar;haarsträubend;ausgemacht (Unsinn)
-geerdet;masseführend (fachspr.)
-Wärmekraftwerk;thermisches Kraftwerk;kalorisches Kraftwerk
-Carnot-Kreisprozess;Carnot-Prozess
-Autobahnrastanlage;Autobahnrastplatz;Autobahnrasthof;Autobahnraststation (österr.);Autobahnraststätte
-Griechisches Projekt;Griechischer Plan
-Serbisch-Türkischer Krieg;Serbisch-Osmanischer Krieg
-Vereinbarung von Reichstadt;Konvention von Reichstadt
-Topf (ugs.);Zylinder (Motor) (Hauptform);Pott (ugs., regional)
-nur noch ein bisschen;nur noch ein wenig;fast nicht(s) mehr;nur noch sehr selten;nur noch sehr wenig;kaum noch
-trinken;(nasser) Alkoholiker (sein) (variabel);saufen (derb);an der Flasche hängen (ugs., fig.);alkoholabhängig (sein) (variabel);zur Flasche greifen (fig.)
-versoffen (derb);alkoholkrank;trunksüchtig;alkoholsüchtig;dem Trunke hold (sein) (altertümelnd, verhüllend);alkoholabhängig
-Johannisbeerlikör;Aufgesetzter aus schwarzen Johannisbeeren;Cassis (ugs., franz., Hauptform);Crème de Cassis (fachspr., franz.)
-Ristgriff;Oberhandgriff
-Untergriff;Kammgriff
-(aus Abfall) etwas Tolles zaubern;aus Scheiße Gold machen (derb)
-Westdeutschland;Wessiland (ugs., veraltend);goldener Westen
-Land der unbegrenzten Möglichkeiten (euphemistisch);amerikanischer Traum;vom Tellerwäscher zum Millionär (fig.);American Dream (engl.)
-Korpsgeist;Esprit de Corps (geh., franz.);Zusammenhalt;Gemeinschaftsgeist;Wir-Gefühl
-Eine Krähe hackt der anderen kein Auge aus. (Sprichwort, abwertend);(einen Kollegen) nicht anscheißen (ugs.);(unter Kollegen) zusammenhalten;auf einander nichts kommen lassen (ugs.)
-bluten wie ein (abgestochenes) Schwein (ugs.);(einen) hohen Blutverlust haben;stark bluten (Hauptform);viel Blut verlieren
-Transalaikette;Transalai;Transalaigebirge
-Neapolitanische Republik;Parthenopäische Republik
-Transpadanische Republik;Lombardische Republik
-(es) geht knallhart zur Sache (ugs.);(irgendwo) nicht mit Wattebäuschchen werfen (ugs., fig.);mit harten Bandagen kämpfen (fig.);(irgendwo) nicht zimperlich sein;(etwas ist) kein Mädchenpensionat (ugs., fig.)
-Nationaleinkommen;Sozialprodukt
-Nettonationaleinkommen;Nettosozialprodukt (veraltet)
-wenn ich es dir (doch) sage! (ugs.);du kannst mir (das) ruhig glauben (variabel)
-glauben an;(die Existenz) für möglich halten
-vertrauensvoll übergeben;(vertrauensvoll) in jemandes Hände legen;(jemandem) anheimgeben;jemandes Obhut unterstellen;jemandes Schutz anbefehlen (geh., veraltet);in jemandes Obhut geben;zu treuen Händen übergeben;jemandes Obhut anbefehlen (geh., veraltet);(jemandem) anvertrauen;(jemandem) überantworten;bei jemandem in Obhut geben
-aufm (ugs.);auf dem
-Blei...;bleiern;aus Blei
-wir arbeiten dran (ugs., Spruch);wir tun unser Bestes (Spruch);wir kümmern uns drum (ugs., Spruch);mit Hochdruck arbeiten an (floskelhaft);wir sind dran an der Sache (ugs.);wir werden uns Mühe geben;wir sind an der Sache dran (ugs.)
-(etwas) nehmen (/ tragen / wegstecken / ...) wie ein Mann;verkraften können;ich werd's überleben (ugs., Spruch, ironisch);(schon) klarkommen mit (ugs.);mit Fassung tragen (ironisch)
-Oderbucht (DDR);Pommersche Bucht
-Leuchtspurmunition;Glimmspurmunition
-offene Fläche;Freiland
-Frühbeet;Mistbeet;Anzuchtbeet
-bepflanzte Fläche;Plantage;Anpflanzung;Pflanzfläche
-erschummeln;ermogeln
-so sieht es (jedenfalls) aus;so sieht's aus;(so) wie es aussieht (...);scheint so;sieht (ganz) danach aus
-soweit zu erfahren war;nach allem, was man hört;soweit erkennbar
-Lourdesgrotte;Mariengrotte
-Farbbuch;Buntbuch
-Kriegsakademie (veraltet);Generalstabsakademie;Führungsakademie;Generalstabsschule;Akademie des Generalstabs
-(irgendwohin) kommen;(irgendwohin) geräumt werden müssen;(irgendwohin) gehören
-(sich) amüsiert zeigen;(seinen) Spaß haben;(sich) einen Jux machen aus
-(jemandem etwas) austreiben;(jemandem) wird (...) noch vergehen;(jemand) wird (...) noch bereuen
-Menstruationszyklus;Ovarialzyklus
-Gibbssche Fundamentalgleichung;Fundamentalgleichung der Thermodynamik;Fundamentalrelation
-Grenzberichtigung;Delimitation
-Grenzabkommen;Grenzvertrag
-...schreck;...killer;...störer
-kräftig durcheinanderwirbeln (ugs.);...schreck;hochschrecken lassen;in Unruhe versetzen;aufschrecken;für einen Paukenschlag sorgen (fig.);in Aufruhr versetzen
-sortenrein;nur aus einer Sorte (hergestellt) (Lebensmittelherstellung);nach Sorten getrennt (Abfallwirtschaft)
-den Erwartungen entsprechend;normal;der Normalverteilung entsprechen(d);der Norm entsprechen(d);erwartbar;nicht überraschend;dem Erwartungshorizont entsprechend;in der Norm liegen(d);im Normbereich
-wie man weiß;wie du (sicherlich) weißt;(ein) offenes Geheimnis (sein);bekanntlich;was allgemein bekannt sein dürfte;bekannterweise;wie jeder weiß;was wir (hier) als bekannt voraussetzen (dürfen) (geh.);bekanntermaßen;wie gesagt;was (ja) allgemein bekannt ist;wie (bereits) bekannt
-(hier) ist nichts weiter los (ugs.);(hier ist) alles ruhig;es gibt nichts zu vermelden;(es gibt) keine besonderen Vorkommnisse (floskelhaft)
-es ist nichts los (ugs.);es passiert nichts;nichts passiert;es tut sich nichts (ugs.);(es ist) tote Hose (ugs., salopp)
-Kaukasische Rasse;Kaukasoid
-Rassentheorie;Rassenkunde;Rassenlehre
-Indoeuropäer;Indogermane
-nicht wissen, was angesagt ist;hinter dem Mond leben (fig.);nicht wissen, wie die Dinge (heutzutage) laufen;nicht wissen, wie es im Leben (heute) zugeht
-Sattelanhänger;Auflieger;Sattelauflieger
-Lokomotivkasten;Wagenkasten
-Kneipp-Medizin;Kneipp-Therapie
-Quotenrenner;Quotenhit
-digitale Beschränkungsverwaltung (ugs.);digitale Rechteminderung (ugs.);Digital Rights Management (engl.);digitales Rechtemanagement;digitale Rechteverwaltung
-Anscheinsbeweis;Prima-facie-Beweis;Beweis des ersten Anscheins
-Blochholz (österr.);Rundholz;Bloch (österr.)
-ein Rätsel;(jemandes) Geheimnis (fig.);rätselhaft;mysteriös;unklar;im Dunkeln;verborgen;schleierhaft
-Scheitholz;Scheitholt
-unklar;ungenau;unpräzise;vage;schwammig;unsauber;wischi-waschi (ugs.);unscharf;unspezifisch (fachspr.)
-ohne auf (die) Details einzugehen;undetailliert;ohne Einzelheiten zu nennen;oberflächlich
-jetzt hab ich dich am Wickel (ugs.);jetzt geht's dir an den Kragen (ugs.);jetzt bist du dran (ugs.);erwischt (, Freundchen) (ugs.);du kannst anfangen zu beten (ugs.);jetzt hab ich dich (ugs., Hauptform);jetzt bist du fällig (ugs.);jetzt bist du geliefert (ugs.)
-Hitzeflimmern;Luftflimmern
-effektive Strahlungsleistung;effektiv abgestrahlte Leistung
-ungelenkte Bombe;Freifallbombe;dumme Bombe
-Große Säuberung;Großer Terror
-Schachty-Prozess;Schachty-Affäre
-um das (ein für alle mal) klarzustellen;damit keine Missverständnisse aufkommen
-in der Lehre sein (bei);(eine) Ausbildung (zum/zur ...) machen;(eine) Ausbildung absolvieren
-(eine) Ausbildung (zum / zur / bei ...) anfangen;in die Lehre gehen (bei)
-(ein) breites Grinsen aufsetzen;(jemandem) (frech) ins Gesicht lachen;breit grinsen;feixen (negativ);frech grinsen
-Berliner Erklärung;Juni-Deklaration;Berliner Deklaration
-Einteilung;Spezifikation
-Okkupationsrecht;Besatzungsrecht
-aufs Schärfste protestieren (variabel);(es) kommt zu heftigen Protestaktionen;auf die Barrikaden gehen (gegen) (fig.);Sturm laufen (gegen) (fig.);(den) Aufstand proben (fig.)
-Rifkrieg;zweiter Marokkanischer Krieg
-Spanisch-Marokkanischer Krieg;erster Marokkanischer Krieg
-Röntgenstrukturanalyse;Röntgenkristallographie
-gehören zu;zählen zu;unter (...) zu verbuchen sein;fallen unter;(einer Kategorie) zuzuordnen sein;kommen unter;rangieren unter
-Experimentierküche;Hexenküche (fig.)
-Verteilungszahl;Wahlzahl
-Austragshaus;Ausgedinghaus;Ellerhaus;Auszugshaus;Ausgedingehaus;Stöckli (schweiz.);Ausziehhaus
-Geschlossener Hof (südtirolerisch, tirolerisch);Erbhof
-Dungau;Gäuboden
-(einen Erfolg) perfekt machen;(dem Ganzen) die Krone aufsetzen (auch ironisch);für den krönenden Abschluss sorgen
-gewachsener Boden (fachspr.);anstehender Boden (fachspr.)
-assistierter Suizid;Beihilfe zur Selbsttötung
-Suizidversuch;Selbstmordversuch
-(mit etwas) schon einmal (böse) hereingefallen sein;(ein) gebranntes Kind (sein) (fig.);(sich) (schon einmal) eine blutige Nase geholt haben (ugs., fig.);schon einmal schlechte Erfahrungen gemacht haben (mit)
-Aus Schaden wird man klug. (Sprichwort);Gebranntes Kind scheut das Feuer. (Sprichwort)
-Markenklassifikation;Nizza-Klassifikation
-Markenzeichen;Marke
-Jugendkonzentrationslager;Jugendverwahrlager (verhüllend);Jugendschutzlager (verhüllend)
-(eine) Serendipität (geh., Neologismus);(segensreiche / vorteilhafte) Zufallsentdeckung;Glücksfund
-Maisonnette;Maisonettewohnung;Maisonette
-Erzstift und Kurfürstentum Trier;Kurtrier
-Knopfakkordeon;Knopfharmonika
-Pareto-Optimum;Pareto-effizienter Zustand
-Lebenslage;(persönliche) Situation
-verschone mich mit (...);gib dir keine Mühe;(das) kannst du dir sparen (ugs.);komm schon! (ugs.);lass (es) gut sein;(das) kannst du dir schenken (ugs.);spar dir (das) (ugs.);bemüh dich nicht weiter;lass stecken! (ugs., salopp);schon gut;(nee,) lass mal (ugs.);ah geh! (ugs., bayr.);geh mir weg! (ugs., ruhrdt.);hör mir auf (mit ...) (ugs.);hör mir (bloß) uff (mit ...) (ugs., berlinerisch)
-Mischung (aus);Zwischending (ugs., Hauptform);Mittelding (ugs.);Zwischenform;(eine) Zwischenstellung einnehmen (zwischen);halb ..., halb ...
-Crossover;Mischform verschiedener Musikstile
-Hybrid... (fig.);Kreuzung (aus) (fig.);Hybrid (aus) (fig.)
-Turbulator;Turbulenzgenerator
-Vortexgenerator;Wirbelgenerator
-(nur) mal angenommen (ugs.);(einmal) unterstellt (dass);gesetzt den Fall;vorausgesetzt, dass;(es) sei (fachspr., Jargon);(einmal) angenommen;unter der Annahme, dass;gegeben sei (dass) (fachspr., Jargon);nehmen wir an, dass;unter der Prämisse (dass / eines, einer) (fachspr.)
-(probeweise) annehmen;(versuchsweise) davon ausgehen, dass;unterstellen
-(sich) nicht verlassen können (auf) (variabel);nichts Halbes und nichts Ganzes (ugs., Hauptform);(eine) wackelige Geschichte (ugs.);(eine) wackelige Angelegenheit (ugs.);fipsig (ugs.);mick(e)rig (ugs.);Provisorium;(hat) keinen Kopf und keinen Arsch (ugs., fig.);(da) hat man nichts in der Hand (ugs.);(nur eine) Bastellösung;windig (ugs.)
-schlechtberaten;übelberaten
-(ein) Schattendasein führen (fig., Hauptform);man hört nichts von (ugs., variabel);(der) Vergessenheit anheimgefallen (sein) (geh.);aus der öffentlichen Wahrnehmung verschwunden sein;(weitgehend) vergessen sein;unbeachtet bleiben;nicht in Erscheinung treten
-arm werden;verarmen;in Armut geraten (Hauptform);in Armut fallen;alles verlieren
-(jemandem) sein Vermögen nehmen;(sein) Vermögen verlieren;an den Bettelstab bringen (fig., veraltend);um Hab und Gut bringen;zum Bettler machen;ruinieren;arm machen (Hauptform);verarmen lassen;zum Bettler werden lassen
-heruntergekommen;auf den Hund gekommen;verelendet;abgewirtschaftet;prekarisiert (fachspr., Jargon);in Armut gesunken (geh.);in Armut abgesunken (geh.);an den Bettelstab gekommen;ruiniert;(schon) bessere Tage gesehen haben;verarmt;arm geworden
-Dreiländereck;Länderdreieck
-Einsatzbereitschaft;Einsatzfähigkeit
-ungeduldig erwarten;(etwas) kaum erwarten können;(etwas) nicht erwarten können;auf heißen Kohlen sitzen (fig.);(den) Moment herbeiwünschen (an dem ...);ungeduldig warten auf
-Kreuzreaktion;Kreuzallergie
-besonders stolz sein auf;(jemanden) mit besonderem Stolz erfüllen;sehr stolz sein auf;(etwas ist) sein ganzer Stolz
-den Rest erledigen;den Rest besorgen;(s)ein Übriges tun
-Einzelsprache;Zunge (geh., selten, veraltet);Sprache (Hauptform)
-Muttersprache (Hauptform);L1 (fachspr., Abkürzung);Erstsprache (fachspr.);Herkunftssprache (fachspr.);A-Sprache (fachspr.)
-L2 (fachspr., Abkürzung);Zweitsprache (fachspr., Hauptform)
-Kastanien-Orgie;Kastanienbankett;Kastanienball;Kastanienballett
-vor dem höchsten Gericht;durch Entscheidung eines obersten Gerichtshofs;höchstrichterlich;in letzter Instanz;durch höchste Instanz;höchstinstanzlich
-bei dieser Gelegenheit;(die) Gelegenheit zum Anlass nehmen (und ...);(jemandem) bietet sich die (willkommene) Gelegenheit (etwas zu tun);(die) Gelegenheit beim Schopfe ergreifen (und ...);(etwas) zum Anlass nehmen, um;aus diesem Anlass
-mit der ganzen Sippschaft (variabel);(mit) alle(n) Mann hoch;mit der ganzen Familie (Hauptform, variabel);mit Kind und Kegel
-(alles) was das Herz begehrt;alle Wünsche;was (immer) man sich wünschen mag (geh.);gut sortiert (sein) (kaufmännisch);keine Wünsche offen lassen;jeder Wunsch;(es) bleiben keine Wünsche offen (variabel)
-(Darüber ist) nur noch der blaue Himmel. (fachspr., Jargon, Spruch);letzte Möglichkeit;höchste Instanz;letzte Instanz
-Europäische Studien (Plural);Europastudien (Plural);Europawissenschaften (Plural)
-Europäische Wirtschaftsgemeinschaft;EWG (Abkürzung)
-Westeuropäische Union;WEU (Abkürzung)
-EVG (Abkürzung);Europäische Verteidigungsgemeinschaft
-intergenerative Gerechtigkeit;Generationengerechtigkeit
-Aserbaidschanisch;Aserbaidschan-Türkisch
-Malayalam;Malabarisch
-drawidische Sprache;dravidische Sprache
-Vorderindien (historisch, veraltet);Südasien
-Zentralfeuerpatrone;Zentralfeuermunition (ugs.)
-Kurbellenkerachse;Traghebelachse
-Stevenson-Hütte (selten);Thermometerhütte;Klimahütte;Wetterhäuschen;englische Hütte (selten);Wetterhütte
-Thermohygrograph;Thermo-Hygrograph
-Lampion;Papierlaterne;Laterne
-letztendlich entscheiden;letztinstanzlich entscheiden;(eine) endgültige Entscheidung treffen;(das) letzte Wort haben
-umspielen (Lächeln);umgeben;umfloren (geh., fig.)
-Solvabilität;Eigenmittelausstattung
-Flüssigkeit;Liquidierbarkeit
-Wettersteinkalk;Wettersteindolomit
-Ladinium;Ladin (Kurzform)
-Anis (Kurzform);Anisium
-Karnium;Karn (Kurzform)
-Labormedizin (Kurzform);Laboratoriumsmedizin
-pathognostisch;pathognomonisch
-körperliche Untersuchung;klinische Untersuchung
-Doppelung;Dopplung
-statische Code-Analyse;statische Analyse
-statisches Software-Testverfahren;statische Tests
-Tierhalter;Tierbesitzer
-(sich) bewahrheiten;wahr werden;eintreten;(so) kommen wie erwartet;Wirklichkeit werden;(sich) bestätigen
-Programm zur Systematisierung der Dörfer;Dorfzerstörungsprogramm;Dorfsystematisierungsprogramm
-Taktrückgewinnung;Symboltakt-Synchronisation
-für jemanden in Ordnung sein;leben können mit;keine Probleme haben mit;klarkommen mit
-Nährboden (fig.);Brutstätte (fig., negativ);Schoß (geh., fig.)
-(ein) Tummelplatz (für / der) (fig., negativ);(eine) Spielwiese (für) (fig.);(ein) Übungsfeld (für)
-Auffangbecken (fig.);Schmelztiegel (fig.);Sammelbecken (fig.)
-seine berufliche Existenz aufs Spiel setzen;Kopf und Kragen riskieren (fig.);mit seinem Arbeitsplatz spielen (ugs.)
-hoch pokern (fig.);(ein) großes Risiko eingehen;alles riskieren;auf volles Risiko gehen (ugs.);volles Risiko fahren (ugs., Jargon);Kopf und Kragen riskieren (fig.);(sich) in Gefahr begeben;alles aufs Spiel setzen
-es geht um Kopf und Kragen;es geht um die Existenz
-(sich) um Kopf und Kragen reden;unbedacht daherreden (und sich damit schaden)
-aller Arten;jeder Sorte;beliebigen Zuschnitts;(von) jeder Art (Hauptform);alle möglichen (ugs.);jeder Provenienz (geh.);aller Couleur;jedwederlei (geh., altertümelnd, scherzhaft);jeglicher Couleur;aller Schattierungen
-Konzertzyklus;Konzertreihe
-Mozart-Festspiele;Mozartiade;Reihe von Konzerten mit Werken von Mozart (variabel)
-Schubert-Festival;Schubertiade;Reihe von Konzerten mit Werken von Franz Schubert (variabel)
-Soirée;Soiree;Konzertabend
-Vormittagskonzert;Matinée;Konzertvormittag
-Für die einen ist es (...) und für andere (...). (variabel);(es) kommt auf den Blickwinkel an;wenn man so will (variabel);Wat den Eenen sin Uhl', ist den Annern sin Nachtigall. (ugs., plattdeutsch, sprichwörtlich, variabel);(etwas) kann man so und so sehen (ugs., variabel);(eine) Frage des persönlichen Standpunkts (sein);(eine) Frage der Sichtweise (sein);Ansichtssache sein;(eine) Frage der persönlichen Haltung (sein);(eine) Frage der Definition (sein);je nachdem, wie man es betrachtet (variabel);(es) kommt darauf an, wie man es sieht (variabel);(eine) Frage der Betrachtungsweise (sein);je nach Betrachtungsweise;Auffassungssache sein;(etwas) kann man auch so sehen (ugs.)
-(sich) verspekuliert haben;(sich) verrechnet haben;zu hoch gepokert haben (fig.);auf falsche Pferd gesetzt haben (fig.);(sich) verzockt haben (ugs.)
-mit der Schmalseite (nach) unten;aufgestellt;hochkant (Hauptform);auf der Schmalseite (stehen(d));nicht gelegt
-Handelspreisempfehlung;empfohlener Preis;Händlerpreisempfehlung;Preisempfehlung
-unverbindlicher Verkaufspreis;unverbindliche Preisempfehlung
-nicht länger hoffen (auf);(die) Hoffnung aufgeben;alle Hoffnung fahren lassen (geh.);(die) Hoffnung verlieren
-(die) Hand beißen, die einen füttert (fig., sprichwörtlich);Nestbeschmutzer (sein) (fig.);das eigene Nest beschmutzen (fig.)
-(sich) das Lachen verkneifen (müssen);(jemandem) bleibt das Lachen im Hals stecken (variabel)
-Differenziation;Differentiation
-Differentialquotient;Ableitung einer Funktion
-Anstieg;Steigung
-Jacobische Matrix;Ableitungsmatrix;Jacobi-Matrix;Funktionalmatrix
-Young-Theorem;Satz von Schwarz;Satz von Clairaut
-implizite Ableitung;implizite Differentiation
-mehrdimensionale Kettenregel;verallgemeinerte Kettenregel
-Integration durch Substitution;Substitutionsregel
-Eineindeutigkeit;Bijektivität
-Produktintegration;partielle Integration
-Stammfunktion;unbestimmtes Integral
-Neutrophiler Granulozyt;Neutrophil
-Eosinophiler Granulozyt;Eosinophil
-Differenzialblutbild;Differentialblutbild
-Hämatogramm (fachspr., griechisch);Blutbild;Hämogramm (fachspr., griechisch)
-Oberösterreich;Tirol und die Vorlande
-Catalan-Zahl;catalansche Zahl
-Gematria;Gematrie;Gimatria
-beklommenes Schweigen;betretenes Schweigen
-Karakal;Wüstenluchs
-unten durch (bei) (ugs.);in Ungnade gefallen (geh.);verschissen haben (bei) (derb);abgemeldet (bei) (ugs.);(es sich) verscherzt haben mit (Hauptform)
-nicht nutzen;aus der Hand geben;verspielen;verschenken;vertun (Chance)
-(noch) nicht aufstehen;liegen bleiben;im Bett bleiben
-(eine) Panne haben;nicht weiterfahren können (Hauptform);liegen bleiben;liegenbleiben
-liegen bleiben;nicht mitgenommen werden;niemand will (...) haben;liegengelassen werden;liegenbleiben
-liegenbleiben;liegen bleiben;keinen Käufer finden;nicht verkauft werden (können)
-nicht sofort wieder tauen;liegen bleiben (Schnee)
-aufhören zu laufen;streiken (Motor);nicht funktionieren;stehenbleiben;ausgehen
-nicht weggenommen werden;liegen bleiben;liegenbleiben;immer noch liegen;weiter liegen;nicht hochgenommen werden
-Judenhelfer;Judenretter
-Ungarnsturm;Ungarneinfall
-(die) alten Zeiten (ugs.);Vergangenheit (Hauptform);die vergangenen Tage;die vergangenen Jahre;längst vergangene Zeiten;(das) Gestern (geh.);(das) Vergangene (geh.);(das) Einst (geh.);das Gewesene (geh.);die vergangenen Zeiten;längst vergangene Tage
-im Staub kriechen (vor) (geh., fig., übertreibend);vor Ehrfurcht erstarren;(aller)größten Respekt haben (vor)
-Lymphdrainage;Massage
-Plastozän (scherzhaft);Zeitalter des Plastiks
-Futur (fachspr., Hauptform);Zukunft
-werden-Futur;Futur I (fachspr., Hauptform);einfaches Futur
-Verbkategorie;Verbform
-vollendete Zukunft;Vorzukunft;Futurperfekt (fachspr.);Futur II (fachspr., Hauptform)
-Tätigkeitsform;Aktiv
-Handlungsform;Handlungsrichtung;Diathese (fachspr., griechisch);Verbgenus;Genus verbi (fachspr., lat.);Verbgattung;Verbalgenus
-Passiv;Leideform (fachspr., veraltet)
-Vorgangspassiv;werden-Passiv
-Zustandspassiv;sein-Passiv
-Konjunktiv I;Konjunktiv Präsens
-Konjunktiv II;Konjunktiv Präteritum
-modal;modusbezogen
-futurisch;zukünftig
-würde-Konjunktiv;Konjunktiv mit 'würde'
-indikativisch;mit dem Indikativ;im Indikativ;Indikativ...
-im Konjunktiv;Konjunktiv...;mit dem Konjunktiv;konjunktivisch
-Vergangenheitszeit;Vergangenheitstempus
-doppeltes Perfekt;Perfekt II (fachspr., Hauptform);Superperfekt
-Plusquamperfekt II (fachspr., Hauptform);doppeltes Plusquamperfekt
-Kleidungsgröße;Kleidergröße;Konfektionsgröße
-(in) Rente (ugs.);Ruhestand
-Heracleum mantegazzianum (fachspr., lat.);Herkuleskraut;Heracleum giganteum (fachspr., lat.);Riesen-Bärenklau;Riesenbärenklau;Herkulesstaude;Bärenkralle
-jemandem ins Gewissen reden;an jemandes Anstand appellieren;an jemandes Gewissen appellieren
-Wortklasse;Sprachteil;lexikalische Kategorie;Redeteil;Wortkategorie;Wortart (Hauptform);pars orationis (fachspr., bildungssprachlich, lat.)
-Verbalaspekt;Aspekt
-Vollverb (Hauptform);Kopula (lat.);Copula (lat.);Hauptverb;Gefügeverb
-Demonstrativpronomen;hinweisendes Fürwort
-Akzidens;Akzidenz
-hebephrene Schizophrenie;Hebephrenie
-Geisteskrankheit;Geistesstörung
-(...) von ihnen;ihrer (geh., veraltend);(...) von denen (ugs.);deren ('partitiv' vor Zahlangaben, auch indefinit) (geh.);(...) davon (ugs.)
-deren (Begleiter) (geh.);ihr (ihren, ihre)
-sein (seine, seinen - männl.);dem sein (dem seine, dem seinen) (ugs., regional, salopp);dessen (Begleiter) (geh.)
-von der;deren (Relativbegleiter) (geh.);von welcher
-von dem;dessen (Relativbegleiter);von welchem
-von welchen;von denen;deren (Relativbegleiter) (geh.)
-Demonstrativ-Begleiter;Demonstrativartikel;Demonstrativpronomen (fälschlich, veraltend);hinweisender Begleiter;Demonstrativbegleiter (Hauptform)
-Hirschferkel;Zwergböckchen
-Vokabel;Lernwort
-Zusatzinformation;Tag (Informatik) (fachspr., Jargon, engl., Hauptform);Schlagwort;Etikett;Auszeichnung (Informatik) (fachspr.);Kennzeichnung;Markup (fachspr., engl.)
-Schlüsselwort;Keyword (fachspr., Jargon, engl.);Schlagwort
-Einsatzzeichen;Stichwort (Theater)
-Kopfwort (Wörterbuch);Leitwort (Wörterbuch)
-Fachausdrücke;Fachterminologie;Nomenklatur;Fachsprache;(offizielle) fachsprachliche Bezeichnungen;Begrifflichkeit (fachspr.);gültige Benennungen;Fachwortschatz;Verzeichnis der Benennungen;Terminologie (fachspr.)
-(vorliegende) Codierung;schriftliche Fixierung;Notation
-mathematische Notation;mathematische Schreibweise;Symbolsprache der Mathematik
-Werkname;Werkbezeichnung;Werktitel;Titel
-Länderkürzel;Ländercodes;Länderkennzeichen
-psychologische Kriegführung;psychologische Kriegsführung
-belegt;bezeugt;sicher;dokumentiert;verbürgt;verbrieft;aktenkundig (fachspr.);schwarz auf weiß (ugs., Redensart);nachgewiesen;gewiss;offiziell;erwiesen
-Päckchen Zigaretten;Packung Zigaretten;Schachtel Zigaretten
-Nikotinsucht;Tabaksucht
-nicht rauchen;Nichtraucher (sein);tabakabstinent leben
-Arkusfunktion;inverse Winkelfunktion;zyklometrische Funktion
-wertig (Neologismus);stabil;solide;gediegen;dauerhaft;währschaft (schweiz.);Da weiß man, was man hat. (ugs., sprichwörtlich);werthaltig;reell;langlebig;wertbeständig
-Lymphsystem;lymphatisches System
-Bries;Thymus
-Gemeine Esche (fachspr., botanisch);Hohe Esche;Fraxinus excelsior (fachspr., botanisch);Gewöhnliche Esche;Esche (Hauptform)
-International Bank Account Number (engl.);IBAN;Internationale Bankkontonummer
-betreuen;unterstützen;helfen;(sich) kümmern;versorgen
-Belanglosigkeiten;Trivia;kurz und uninteressant;Belangloses;am Rande notiert;aus der Enzyklopädie des unnützen Wissens;Vermischtes;dies und das;Nebensächlichkeit(en)
-Formfleisch;Klebefleisch;Analogschinken
-gastrointestinale Blutung;GI-Blutung
-Hämatochezie;Blutstuhl;Rektalblutung
-Ösophaguskarzinom (fachspr.);Speiseröhrenkrebs
-Bosnische Annexionskrise;Bosnische Krise
-Fächerblattbaum;Ginkgo;Ginkgo biloba (fachspr., botanisch);Ginko
-auf Zack (sein) (ugs., Hauptform);ausgeschlafen (sein) (ugs., fig.);auf Scheibe (sein) (ugs., selten);schnell schalten (ugs., fig.);(schwer) auf Draht (sein) (ugs.);schnell im Kopf (sein);fix im Kopf (sein);(einen) wachen Verstand haben
-(etwas) blicken (ugs.);(sofort) die richtigen Schlüsse ziehen (variabel);(Situation) mit einem Blick erfassen (Hauptform, variabel);(etwas) verstehen;(etwas) checken (ugs.);schalten
-lateralisieren;seitlich verschieben;seitlich verlagern
-Fliegerangriff;Luftangriff;Luftschlag;Bombenangriff
-Schnelldenker;Blitzmerker (ugs.)
-Bromcyan;Bromcyanid (ugs.);Campilit (ugs.)
-in die Falle gehen (Hauptform);den Köder schlucken (fig.);(jemandem) auf den Leim gehen;hereinfallen (auf jemanden / etwas) (ugs.);reinfallen (ugs., norddeutsch);anbeißen (ugs., fig.);in die Falle tappen;(sich) ködern lassen (ugs.)
-hereingefallen sein;gefickt sein (vulg.);der Gelackmeierte sein (ugs.);betrogen worden sein;verschaukelt worden sein;gelackmeiert (sein);reingefallen sein (ugs.);übel dran sein
-ins offene Messer laufen lassen (fig.);nicht warnen
-(jemandem) schaden;(jemanden) schädigen
-unüberlegt (sein);zu wenig bringen;kaum Vorteile bieten (variabel);Aufwand und Ertrag stehen in keinem (vernünftigen) Verhältnis.;nicht im Verhältnis stehen;nicht sinnvoll (sein) (Hauptform);zu aufwändig (sein);wenig bis nichts bringen;(sich) eher nachteilig auswirken;nicht vernünftig (sein);zu (...) sein;unvernünftig (sein)
-weder Hand noch Fuß haben (fig.);paradox (sein);(jemandem) unverständlich (bleiben);keinen Sinn ergeben (für);nicht zusammenpassen (ugs., fig.);(jemandem) schleierhaft (sein);unlogisch (sein)
-reißen (Beutegreifer);schlagen (Greifvogel);(sich) holen (ugs.)
-Elektromobil;E-Mobil (Kurzform)
-zertreten;kaputt treten;tottreten (Insekt);kaputttreten (ugs.)
-tothetzen;zu Tode hetzen
-(jemanden) zur Strecke bringen;(jemanden) fertigmachen (ugs.);(jemanden) kaputtmachen (derb);(jemandem) den Rest geben (ugs.);(jemanden) erledigen (ugs.);(jemanden) alle machen (ugs.)
-(sich) vollscheißen (derb);(sich) einkoten (fachspr., Jargon);(da) kam Land mit (ugs., fig.);(sich) in die Hose machen;(sich) einscheißen (derb);(sich) die Hose vollmachen (Hauptform, verhüllend);(jemandem) passiert etwas Menschliches (veraltet, verhüllend);(sich) in die Hose scheißen (derb);einstuhlen (fachspr., Jargon);(sich) in die Hose kacken (derb);alles unter sich gehen lassen (fig., verhüllend);einkoten (fachspr., Jargon)
-(das) wird mir zu blöd (ugs.);(ich) hab keinen Bock auf die Scheiße (ugs., jugendsprachlich);damit geb ich mich (gar) nicht (erst) ab (ugs.);(das) wird mir zu dumm
-mit wachsender (...);von Mal zu Mal (+ Komparativ);immer (+ Komparativ);mit wachsendem (...);mit zunehmendem (...);mit zunehmender (...);zunehmend (+ Komparativ);(Komparativ) und (Komparativ)
-(jemandem) aus der Seele sprechen;die passenden Worte finden;die richtigen Worte finden
-(eine) zweite Ausbildung machen;(sich) umschulen lassen;(eine) Umschulung absolvieren;umgeschult werden;umschulen (auf);(eine) Zweitausbildung machen;(eine) Umschulung machen
-um seine Entlassung bitten;kündigen wollen;aufhören wollen (ugs.)
-diskontinuierliches Affix (fachspr., wissenschaftlich);Zirkumfix (fachspr., Hauptform, wissenschaftlich)
-Flexionselement;Flexionsmittel
-suffigieren (fachspr., wissenschaftlich);ein oder mehrere Nachsilben anhängen
-Derivationsverfahren;Ableitungsverfahren
-präfigieren (fachspr., wissenschaftlich);eine oder mehrere Vorsilben anfügen;mit einer Vorsilbe versehen;eine oder mehrere Vorsilben davorsetzen
-(das) Davorsetzen von Vorsilben;Präfigierung (fachspr., wissenschaftlich)
-Suffigierung;(das) Anhängen von Nachsilben
-Positiv (fachspr., wissenschaftlich);Grundstufe;Nullstufe (der Steigerung);nicht gesteigerte Form
-Ableitungsmittel;Derivationsmittel
-Modalverb (Hauptform);modales Hilfsverb
-Ektoparasit (fachspr.);Außenschmarotzer;Außenparasit
-Innenparasit;Innenschmarotzer;Endoparasit (fachspr.)
-Postposition (fachspr., wissenschaftlich);nachgestelltes Verhältniswort
-umklammernde Präposition;umklammerndes Verhältniswort;Zirkumposition (fachspr., wissenschaftlich)
-Kommentaradverb;Satzadverb (Hauptform);Modalwort
-Adverb des Ortes;Lokaladverb;Ortsadverb
-Modaladverb;Adverb der Art und Weise;Artadverb
-Adverb der Zeit;Temporaladverb;Zeitadverb
-Adverb des Grundes;Kausaladverb
-Adjektivadverb;adverbial verwendetes Adjektiv
-Frageadverb;Interrogativadverb
-Partikel (fachspr., Hauptform);Flickwort (veraltet);Expletiv;Gesprächspartikel;Füllwort (veraltet);Würzwort (veraltet)
-Kuckuckskind;untergeschobenes Kind
-gerichtliche Feststellung der Vaterschaft;Vaterschaftsfeststellung
-Vaterschaftstest;Abstammungsgutachten
-Popcornkino;Unterhaltungsfilm(e);Unterhaltungskino
-anspruchsvolle(r) Film(e);Autorenfilm(e);Autorenkino
-am falschen Ende sparen;da sparen, wo es wenig Sinn macht;da sparen, wo es am Ende keinen Vorteil bringt
-Präsidentengattin;erste Dame des Staates;Gattin des Präsidenten;First Lady (engl.)
-niemand Geringeres als;es ist (...) höchstselbst (der / die ...);kein Geringerer als;der unvergleichliche (...)
-du machst dir (ja) keine Vorstellung! (ugs.);man glaubt es kaum;so unglaublich es auch klingt;und jetzt halt dich fest: ... (ugs.);tataa! (ugs.);ob du es glaubst oder nicht;du wirst es kaum glauben;du wirst es kaum für möglich halten
-überraschenderweise;unglaublicherweise;erstaunlicherweise;man höre und staune;zur allgemeinen Überraschung
-Kosovokrieg;Kosovo-Konflikt
-nicht zu halten sein;platzen (Termin);nicht einhalten können;nicht eingehalten werden können
-(die) ewige (...) (weibl.);(der) (...) vom Dienst (fig.);(der) ewige (..) (männl.)
-Parallelen;Gemeinsamkeiten;Ähnlichkeiten;gemeinsame Merkmale;Teilübereinstimmung(en)
-sein;(etwas) darstellen;(sich) manifestieren in;bestehen in (Hauptform);(sich) zeigen (in / als);(etwas) ausmachen;zu sehen sein in;(sich) darstellen (in / als)
-Genussmensch;Hedonistin;Genießerin;Lebedame;Partyluder (abwertend)
-tierisches Fett;Tierfett
-Ingermanisch;Ischorisch;Ingrisch
-finnugrische Sprache;ugro-finnische Sprache;finno-ugrische Sprache
-(nur ein) schwacher Abglanz;billige Kopie;(ein) fader Abklatsch (des Originals);(der) xte Aufguss (ugs.)
-Durchfeuchtung;Feuchtetransport (fachspr.);Wasserschaden;Feuchteschaden;Wasserfleck
-Sturmglocke;Feuerglocke;Alarmglocke
-(sich) in die Luft jagen (ugs.);(sich) in die Luft sprengen
-Sprengstoffgürtel;Sprengstoffweste
-Man kann nicht alles haben. (Spruch);Man muss auch (irgendwo) Abstriche machen (können).;Man muss (auch) Kompromisse machen (können).
-das ist also der Grund!;so ist das also!;jetzt wird mir alles klar! (floskelhaft);(ach) daher weht (also) der Wind! (ugs., Spruch);sieh mal (einer) an! (ugs.)
-zu unterschiedlich sein;disharmonieren (geh.);sich nicht verstehen;(zwischen ihnen) stimmt die Chemie nicht;nicht gut zusammenpassen;nicht harmonieren;(schlecht) auskommen (mit)
-wenn du unbedingt meinst;muss das (denn) sein?;meinst du wirklich?;Tu, was du nicht lassen kannst. (Spruch)
-wenn's (dir) Spaß macht ...;Hauptsache, du hast deinen Spaß dabei (ugs.)
-(jemanden) nicht verstehen (können);in Rätseln sprechen;(sich) unverständlich ausdrücken;(sich) unklar ausdrücken
-(mit dem) Kopf voran;koppheister (norddeutsch);(mit dem) Kopf zuerst;kopfüber (Hauptform)
-für sich in Anspruch nehmen;für sich reklamieren;(für sich) fordern
-(schräge) Typen (ugs., Plural, abwertend);Figuren (Plural, abwertend);Hanseln (ugs., Plural, herablassend, süddt.);Brüder (ugs., Plural, abwertend);Gestalten (ugs., Plural, abwertend);Vögel (derb, Plural, abwertend);Volks (ugs., abwertend, regional);Männekes (ugs., Plural, herablassend, regional);Fuzzis (ugs., Plural, abwertend)
-von sich weisen;ablehnen;nichts zu tun haben wollen mit
-(sich einer Sache) verweigern;(etwas) verschmähen;(meine) Antwort ist nein;negativ reagieren;nicht zur Verfügung stehen (für) (geh.);ausschlagen (Angebot);abschlägig bescheiden (Antrag) (Amtsdeutsch);nichts wissen wollen (von);(etwas) zurückweisen;(sich) weigern (zu);(etwas) ablehnen;nicht eingehen (auf etwas)
-(jemand) kann mir gestohlen bleiben;(...) kann von mir aus dahin gehen, wo der Pfeffer wächst. (ugs., sprichwörtlich);(jemand) ist die längste Zeit (...) gewesen;(mit jemandem) nichts zu schaffen haben (wollen);von jemandem nichts mehr wissen wollen (ugs.);(jemanden) soll doch der Teufel holen
-nicht gefeit sein gegen;nicht erhaben sein (über);nicht (für sich) ausschließen können;nicht gefeit sein vor;nicht sicher sein (vor);nicht von sich behaupten können (dass)
-Gelee;Fruchtgelee
-nichts geht mehr (Roulette);rien ne va plus (franz.)
-da ist nichts mehr zu machen (ugs.);das war's dann (ugs.);der Spuk ist vorbei (ugs., abwertend);das Aus bedeuten (für);es ist vorbei (für) (ugs.);das Spiel ist aus (fig.);das war's dann wohl (für) (ugs.);die Sache ist gelaufen (ugs.);es hat (mit etwas) ein Ende (geh.);Aus die Maus! (ugs.);das ist das Aus (ugs.);(der) Ofen ist aus (ugs., fig.)
-ein Übriges tun (um);(noch) hinzukommen (dass)
-Einführungsrunde;Formationsrunde
-(mit etwas) hat es seine spezielle Bewandtnis;(das ist) so eine Sache (ugs.);ein eigen Ding sein (geh., veraltend);eine Sache für sich (ugs.)
-Morgenritual;morgendliche Routine
-nicht zugänglich machen;unter Verschluss halten;(die) Einsicht verweigern;vor den Augen der Menge bewahren (geh.)
-(jemandem) wie Schuppen von den Augen fallen (ugs.);plötzlich verstehen;(jemandem) mit einem Schlag bewusst werden;(jemandem) plötzlich klar werden;auf einmal wissen, woher der Wind weht (ugs., fig.);(jemandem) schlagartig klar werden
-nicht ganz den Tatsachen entsprechen;teilweise stimmen (ugs.);nur teilweise zutreffen;in einigen Punkten zutreffen
-das Wahre (an);Wahrheitsgehalt;wahr sein (an einer Aussage / Behauptung)
-privat bezahlen;auf eigene Kosten;selbst aufkommen (für);aus seiner Privatschatulle (geh., fig.);aus eigener Tasche (be)zahlen (Hauptform);aus seinem Privatvermögen bezahlen;selbst (be)zahlen
-wie kann das sein!? (ugs., Spruch);Wie jetzt!? (ugs., salopp);es gibt Widersprüche;nicht zusammenpassen;(irgend)etwas stimmt (da) nicht (ugs.);(etwas) stimmt nicht mit;(etwas) ist faul (an) (ugs., fig.);irgend(et)was ist da nicht in Ordnung (ugs.);es gibt Ungereimtheiten;irgend(et)was ist da (doch) (ugs.);(etwas) stinkt zum Himmel (ugs.)
-(den) vagen Verdacht haben (dass);(das) dumme Gefühl nicht loswerden (dass) (ugs.);(das) unbestimmte Gefühl haben (dass);(sich) des Eindrucks nicht erwehren können (dass) (geh.);(den) Eindruck haben (das)
-zu der Überzeugung kommen (dass);zu der Überzeugung gelangen (dass)
-absoluter Superlativ;Elativ (fachspr.)
-Adjektivform;Flexionsform des Adjektivs
-Steigerungsstufe;Steigerungsform;Komparationsform (fachspr.)
-steigern;komparieren
-Epitheton (geh., griechisch);zweiter Teil des Artnamens;Artzusatz;Art-Epitheton (geh.);artspezifisches Epitheton (geh.)
-nicht alles gleich(ermaßen) wichtig nehmen;(sich) nicht verzetteln;nach Wichtigkeit (einteilen / sortieren / ordnen / anordnen / bewerten ...) (variabel);Prioritäten setzen (Hauptform)
-alles gleichzeitig machen (wollen);(sich) verzetteln;zu viel auf einmal machen (wollen)
-dringend;eilig;drängend;eilbedürftig (Amtsdeutsch);vordringlich;akut;vorrangig;prioritär (geh.);dringlich;(die) Zeit drängt
-eilen;pressieren (mit) (geh.);drängen;eilbedürftig sein (Amtsdeutsch);eilig sein
-(etwas) hat Zeit (Hauptform);(etwas) hat keine Eile;(etwas) kann warten;es eilt nicht (mit);(sich) Zeit lassen können;(etwas) läuft (jemandem) nicht weg (ugs., fig.);wozu die Eile!?! (auch ironisch);(etwas) eilt nicht
-Zeit haben;Zeit mitgebracht haben;keine Termine haben;es nicht eilig haben (Person)
-es eilig haben;nicht so lange warten können;in Eile sein;nicht so viel Zeit haben;(jemandem) pressiert es (süddt.);nicht so lange Zeit haben
-was soll das ganze Theater! (ugs.);ich verstehe gar nicht, was du immer hast! (ugs.);wozu die Aufregung
-in vielem;in mancher Hinsicht;in vielen Hinsichten;in vielerlei Hinsicht
-aus öffentlichen Mitteln;auf Staatskosten
-auf Kosten des Hauses;nichts (zu) bezahlen brauchen (ugs.);auf Kosten des Unternehmens;auf Kosten der Firma
-ohne (selbst) einen Cent dafür bezahlt zu haben;auf Kosten anderer (Leute);ohne Eigenbeitrag;auf anderer Leute Kosten;auf ander' Leuts Kosten (ugs., regional)
-auf jemandes Kosten (gehen);(etwas) (er)tragen müssen;zu jemandes Lasten (gehen);(jemandem) zum Nachteil (gereichen);(sich) nachteilig auswirken (für)
-bei jemandem gedeihen (alle) Pflanzen;(der) geborene Gärtner sein;bei jemandem werden alle Pflanzen was (ugs.);(einen) grünen Daumen haben;(ein) Händchen für Pflanzen haben (ugs.)
-goldene Hände (haben) (fig.);große Handfertigkeit (haben);großes Handgeschick (besitzen)
-vertrautes Gesicht;bekanntes Gesicht
-jeder kennt (...);ein gefeierter (...) (männl.);eine gefeierte (...) (weibl.);überaus populär sein;(ein) Popstar (fig.)
-Pflanzenforscher;Botaniker;Pflanzenkundler
-vom Aussterben bedroht (sein);(eine) aussterbende Art (sein)
-schief sitzen(d);verrutscht (sein)
-Feuerwehrmann (männl.);Floriansjünger
-locker bleiben;entspannt bleiben;(sich) nicht aufregen
-Grünzeug(s) (ugs.);Gemüse (ugs., scherzhaft);Pflanzen (Hauptform)
-im Grünen;umgeben von Natur;in der Natur
-(immer) unwichtig(er) werden;an Bedeutung verlieren
-(jemandem) (auch) nichts nutzen (ugs., variabel);(auch) nicht weiterkommen mit;(auch) nicht weiterhelfen;(auch) nicht weiterführen;(auch) keine Lösung sein;(mit einer Sache) ist niemandem gedient (floskelhaft);(jemandem) (auch) nicht helfen
-Longlist (engl.);Vorauswahl
-engere Auswahl;Shortlist (engl.);engere Wahl
-Würstelgleichung (ugs.);Kesselformel
-Pflanzen bestimmen;botanisieren
-Imageproblem;die Bösen sein (ugs., fig.);(einen) schlechten Ruf (haben);(jemandem / einer Sache) haftet ein schlechter Ruf an
-(zeitlich) synchronisiert;miteinander vertaktet
-(jemandem) auf die Finger sehen;aufpassen, was jemand tut
-es jemandem nachtun;(sich) etwas abgucken (bei / von jemandem);(jemandem) auf die Finger sehen
-Skinhead;Neonazi (sein);zur rechtsextremen Szene gehören;Mitglied der rechtsextremen Szene;der Skinhead-Szene zuzurechnen;der rechtsextremen Szene zuzuordnen
-Stahlkappenstiefel;Springerstiefel (ugs.)
-geistesgegenwärtig (Hauptform);flink;reaktionsschnell
-voll da (ugs., fig.);(geistig) hellwach
-wie es sich gehört;geziemend;in schicklicher Weise;mit Anstand
-(etwas) mit Anstand hinter sich bringen;nicht kneifen (ugs., fig.)
-so anständig sein zu;(den) Anstand haben zu;anständig genug sein und
-Bussonderfahrstreifen;Busfahrspur (ugs.);Busfahrstreifen;Bussonderspur (ugs.);Busspur (ugs., Hauptform)
-durcharbeiten (Akten, Bücher);durchackern (ugs.)
-(sich) übertragen auf;abfärben auf (fig.);(etwas) haben von (ugs.);(jemand) bekommt etwas ab (von) (ugs.);(etwas) erben von (fig.);(etwas) übernehmen (von)
-(eine) Aussage treffen (fachspr., mediensprachlich);sprechen von;(sich) äußern zu;reden über
-für die Hand des Schülers (bestimmt);Schulausgabe;Schülerausgabe;(Ausgabe) ad usum Delphini (geh., veraltet)
-unbedingt;ohne Ansehen der Umstände (geh.);stets;ausnahmslos;egal was ist;unter allen Umständen
-aus berufenem Mund(e) (geh.);von kompetenter Seite;von einem, der sich auskennt (ugs.);von einem, der das (auch) beurteilen kann;von jemandem, der es wissen muss (ugs.);von einem, der weiß, wovon er spricht
-Bauchfell;Peritoneum (fachspr.)
-Hüftdarm;Ileum (fachspr.);Krummdarm
-Stereovilli;Stereozilie
-Wolff-Gang;Urnierengang;primärer Harnleiter
-Nebenhodenentzündung;Epididymitis (fachspr.)
-in der Leitung bleiben;die Verbindung halten;dranbleiben (Telefon) (ugs.);am Apparat bleiben;nicht auflegen
-weiter geht's!;keine Müdigkeit vorschützen! (ugs.);nicht nachlassen!
-(etwas) zusammenkommen;mehr werden;(sich) ansammeln (bei) (auch figurativ)
-(Geld) zusammenkommen;(sich) summieren;Kleinvieh macht auch Mist! (ugs., sprichwörtlich);(sich) ansammeln;Die Masse macht's. (ugs., Spruch);(da) kommt ganz schön was zusammen (ugs., Spruch);(sich) zusammenläppern (ugs.);(sich) läppern (ugs.)
-(etwas) springen lassen (ugs.);nicht knausern;sich nicht lumpen lassen;(sich) in Geberlaune zeigen;(sich) als großzügig erweisen (geh.);(sich) großzügig zeigen;in Geberlaune sein;die Spendierhosen anhaben (fig.)
-die Gelegenheit (ugs.);(eine) einmalige Gelegenheit
-fast fertig;so gut wie fertig (ugs.)
-vorbereitet (für / um zu);bereit zu;...fertig
-was wird hier (eigentlich) gespielt? (ugs., fig.);was hast du (eigentlich) vor?;wozu soll das gut sein? (ugs.);was soll das? (ugs.)
-(jemandem) die Sicht versperren;(jemandem) im Bild stehen
-spröde (Person);nicht leicht herumzukriegen (ugs.)
-entweichen (Gas);nach außen dringen;auslaufen;austreten (Flüssigkeit);(her)ausströmen (Gas);herausfließen;(her)aussickern;ausfließen;herauslaufen
-(Person) mit normalem Einkommen;Normalverdiener;Durchschnittsverdiener
-Bezugsperson;Vertrauensperson
-betreuende Person;Betreuung;Betreuerin (weibl.);Betreuer (männl.)
-Bewährungshelferin (weibl.);Bewährungshelfer (männl.)
-Tutor (männl.);Unterstützungslehrer (männl.);Unterstützungslehrerin (weibl.);Tutorin (weibl.);Anleiter (männl.);Anleiterin (weibl.)
-Supervisorin (therapeutisch) (weibl.);Lehrtherapeutin (weibl.);Supervisor (therapeutisch) (männl.);Lehrtherapeut (männl.)
-Erziehungshelferin (weibl.);Erziehungsbeistand (Kinder- u. Jugendhilfe);Unterstützung bei der Erziehung (ugs.);Erziehungshelfer (männl.)
-Betreuungshelferin (Kinder- u. Jugendhilfe) (weibl.);Betreuungshelfer (Kinder- u. Jugendhilfe) (männl.)
-Wettkampfhelferin (weibl.);Sekundant (Boxsport, Schach) (männl.);Sekundantin (Boxsport, Schach) (weibl.);Wettkampfhelfer (männl.)
-Schnellbehandler (von Platzwunden);Cutman
-Zweitgutachter;Korreferent
-Determiniertheit;Angewiesenheit;(das) Angewiesen-Sein;(das) Abhängen (von);Abhängigkeit;Dependenz (fachspr.);Bedingtheit;Abhängigkeitsverhältnis;(das) Abhängig-Sein;Abhängigkeitsbeziehung
-(das) Ausgeliefert-Sein;(das) Unterworfen-Sein
-wahllos um sich schießen;wie wild um sich schießen
-alle erschießen, die (jemandem) im Weg stehen;(sich) den Weg frei schießen
-(sich) rächen wollen;auf Rache sinnen;es darauf abgesehen haben, sich zu rächen
-drucken;abdrucken (in einer Zeitung/Zeitschrift);bringen
-gedruckt werden;in Druck gehen
-(jemandem) aufschließen;(jemandem) auftun (geh., veraltet);(jemandem) die Tür öffnen
-(plötzlich) weinen müssen;(jemandem) schießen (die) Tränen in die Augen;(das) heulende Elend bekommen (ugs.)
-Heulanfall (ugs.);Weinkrampf;(das) heulende Elend (ugs.)
-auf seine Kosten kommen;(etwas) für sein Geld bekommen;(eine) angemessene Gegenleistung erhalten;zufriedengestellt werden;(etwas) haben von (ugs.)
-(sich) nicht beklagen können;nicht enttäuscht werden;auf seine Kosten kommen (fig.);nicht meckern können;(jemand) dürfte zufrieden sein
-(einem Text) entnehmen;(aus einem Text) herauslesen;(aus einem Text) ersehen;(aus einem Text eine) Information gewinnen
-(sich) abstrampeln (ugs.);(sich) abmühen;(sich) müde kämpfen;(sich) verausgaben;(sich) verkämpfen;(sich) aufreiben;(sich) zerreiben (an);(man) macht und tut (ugs., floskelhaft, veraltend);(sich) abquälen;(jemanden) zermürben;(sich) abarbeiten (an);(sich) abkämpfen;(man) tut und macht (ugs., floskelhaft, veraltend);(sich) zersprageln (ugs., österr.)
-bis es nicht mehr geht;bis jemand nicht mehr kann;bis zur (völligen) Erschöpfung
-Bescheidenheit ist eine Zier, doch weiter kommt man ohne ihr. (ugs., scherzhaft-ironisch, sprichwörtlich, variabel);Frechheit siegt! (Spruch)
-Four-Letter-Word (fachspr., Jargon, engl.);Schimpfwort;Kraftausdruck (euphemistisch);vulgäre Entgleisung;ordinäre Ausdrucksweise;Vulgarität
-Postaer Sandstein;Wehlener Sandstein
-Musikmöbel;Musikschrank;Musiktruhe
-auf den Plan treten;jemandes (große) Stunde kommt (fig.);jemandes Stunde sein (fig.);ins Spiel kommen
-Sommertheater;willkommenes Thema, um das Sommerloch zu füllen
-herbeirufen;zusammentrommeln;einberufen;zusammenkommen lassen;zusammenrufen
-(sich) versammeln;zusammenkommen;zusammentreten;(sich) sammeln;Sitzung haben (ugs.);tagen
-(sich) neu ausrichten (fig.);(sich) komplett anders ausrichten;(sich) neu sortieren (ugs.);(sich) neu erfinden (fig.);(sich) auf neue Füße stellen (fig.);(einen) Neuanfang wagen;(sich) neu aufstellen (fig.);(sich) auf neue Beine stellen (fig.)
-wohlbehalten (ankommen);mit heiler Haut (davonkommen) (Redensart, fig.);schadlos (überstehen);mit heilen Knochen (davonkommen);heil (überstehen)
-(etwas) von sich behaupten;(für sich) reklamieren (dass);anerkannt wissen wollen (geh.);(für sich) in Anspruch nehmen (zu);(für sich) beanspruchen;prätendieren (geh., bildungssprachlich, lat.)
-(eine) Belastung (sein);(ein) Klotz am Bein (sein) (fig.)
-nichts zu tun haben mit (Person);nicht in Verbindung stehen mit;in keinem Zusammenhang stehen mit;unbeteiligt sein
-Geheimweg;Schleichweg (ugs.);Nebenstrecke;Nebenweg
-gekennzeichnet (Wanderweg);beschildert;ausgeschildert;mit Schildern versehen;markiert (Wanderweg)
-(hier) fremd;nicht von hier;ortsfremd (Hauptform)
-desorientiert (sein);keinen Plan haben (ugs., salopp);nicht wissen, wo man (gelandet) ist
-Wegzeichen;Wegmarkierung;Wandersymbol(e);Wandermarkierung
-Manntag;Personentag
-Jahrgang (...) (salopp);(...) geboren;ein ...er (Jahrgang) sein (männl.);eine ...erin sein;Baujahr (ugs., fig., salopp)
-gesetzt;(etwas) älter;(ein) älterer Jahrgang (sein);reife(re)n Alters;mittleren Alters;nicht mehr ganz jung (an Jahren);(der) (erste) Lack ist ab (ugs., fig.)
-(ein) Anrecht haben (auf);(auf etwas) Anspruch erheben dürfen;legitimerweise (...);(jemandem) zustehen;(jemandes) gutes Recht sein;Anspruch haben (auf)
-Schaum auf einem Wellenberg (in Gewässern);Schaumkrone
-Waldweg;Forstweg
-Rollkoffer;Koffer;Trolley;Reisekoffer
-Sackuhr (süddt.);Taschenuhr;Taschenzwiebel (ugs., veraltet)
-Kugelfischer-Einspritzung;System Kugelfischer
-organische Landwirtschaft;alternative Landwirtschaft;ökologische Landwirtschaft;Ökolandbau;biologische Landwirtschaft
-Kellerbier;Zwickl;Zwickelbier
-Märzenbier;Märzen
-Exportbier;Export
-Burg Tangermünde;Schloss Tangermünde
-Stütze;Stunze (veraltet);Steize (veraltet)
-bunt gemischt;in zufälliger Reihenfolge;in regelloser Folge
-Unkrautvernichter;Unkrautbekämpfungsmittel;Unkrautvernichtungsmittel;Herbizid (fachspr.);chemische Keule (fig.)
-spontan umkehren;(sich) auf dem Absatz umdrehen;auf dem Absatz kehrtmachen
-Feuermauer (selten);Brandschutzwand (selten);Brandmauer;Brandwand
-unterbrechungsfrei;reibungslos
-zuchtlos;zügellos;hemmungslos;wild;orgiastisch;exzessiv;ausschweifend
-der vierte Buchstabe des griechischen Alphabets;Mündung eines Flusses, die sich wie ein Fächer in kleinere Flussarme aufteilt;Delta
-Affinerie;Scheideanstalt
-(die) Liebe seines Lebens;(jemandes) (ganz) große Liebe;(die) Liebe ihres Lebens
-im Raum stehen lassen (fig.);nicht diskutieren wollen;dahingestellt sein lassen;nicht entscheiden wollen
-Atomausstieg;Atomverzicht;Kernkraftausstieg
-Kernkraftwerk Zwentendorf;Kernkraftwerk Tullnerfeld
-ist nicht böse gemeint (aber...);sei mir nicht böse (aber...);nimm's mir nicht übel (aber...);nicht böse sein! (ugs., Spruch)
-was glaubst du (eigentlich), wer du bist! (ugs.);du hältst dich wohl für was Besonderes! (ugs.);wofür hältst du dich! (ugs.)
-(jemand) hat nichts von (etwas) (ugs.);(jemandem) nichts einbringen;(jemandem) keine Vorteile bringen;(jemandem) nichts bringen (ugs.);uninteressant sein (für) (ugs.);nichts herausspringen (für);seine Zeit schon sinnvoller verbracht haben (ugs., Spruch, ironisch);(jemandem) keinen Vorteil bringen
-welcher Teufel hat dich geritten, dass (...) (ugs.);(das) kann nicht wahr sein!;das darf (einfach) nicht wahr sein!;wie konntest du nur! (ugs.);wie kann man nur! (ugs.);ich fass(e) es nicht!
-(...) in Nadelstreifen;(...) im Nadelstreifenanzug;(...) mit weißen Kragen
-für die Drecksarbeiten andere (Leute) haben;(sich) die Hände nicht schmutzig machen (fig.)
-braune Esoterik;rechte Esoterik
-arabisches Fürstentum;Emirat
-nicht der einzige (sein), der;(das) hat man öfter (ugs., Spruch);kein Einzelfall sein;(mit etwas) nicht allein(e) dastehen;häufiger vorkommen;nicht (gerade) selten sein;Vorbilder haben (in);keine isolierten Beispiele (sein) (variabel)
-den schwarzen Peter haben;(jemandem) zugeschrieben werden;auf jemanden zurückfallen;die Arschkarte haben (ugs., salopp);verantwortlich gemacht werden für;jemandem angelastet werden
-(jemanden) um seinen Schlaf bringen;nicht schlafen lassen
-zum Meer gehörend;marin
-das Meer betreffend;maritim
-Tintenpatrone;Druckerpatrone
-Kapitaldelikt;Schwerverbrechen;schwere Straftat;Kapitalverbrechen
-Misshandlung;Körperverletzung (Handlung) (juristisch)
-misshandeln;übel zurichten;draufhauen wie auf kalt Eisen (ugs., veraltend);(schwere) Verletzungen zufügen;grün und blau schlagen;halbtot schlagen
-(weiter) im Landesinneren;im Hinterland;weit weg von der Grenze
-in den Grenzgebieten;im Grenzland;in den Randgebieten;an den Außengrenzen (eines Landes);in den Randzonen
-an der Front;im Kampfgebiet
-im Hinterland;weitab vom Kampfgeschehen (variabel);in der Etappe (veraltet)
-Frontverlauf (militärisch);Kontaktlinie (euphemistisch);Frontlinie (militärisch)
-Rahmenhandlung;Rahmenerzählung
-ihr zwei Hübschen (ugs.);ihr zwei;ihr beiden Hübschen (ugs.);ihr beide
-Honoratior;Größe;Grande;Ehrenbürger
-Herstellkosten;Gestehungskosten;Herstellungskosten;Kosten der Herstellung;Anschaffungskosten;Fertigungskosten
-sehr vorsichtig sein;äußerst vorsichtig umgehen mit;höllisch aufpassen (ugs.);mit größter Vorsicht behandeln
-Charlie (ugs., Jargon);Wandergepäck;Gepäckrolle;Gepäckbündel;Charlottenburger (Wandergeselle) (fachspr., Hauptform)
-sprachliches Gymnasium;neusprachliches Gymnasium
-(es) hat doch gereicht!;Ein gutes Pferd springt knapp. (sprichwörtlich);Hauptsache geschafft!
-(etwas) ruhig tun (können) (ugs.);keine Hemmungen haben (zu);sich keinen Zwang antun (und ...);nicht zögern (zu);einfach (bei Aufforderungen) (ugs.);nur (nach Aufforderungsform) (ugs.)
-locker (ugs.);ruhig (mal);(es) schadet nicht (wenn);einfach;(es) kann nicht schaden (wenn);getrost (Hauptform)
-verwässern (fig.);aufweichen (fig.)
-sanfter gestalten;entschärfen;abmildern;(einer Sache) die Schärfe nehmen (fig.);Spannung herausnehmen;adoucieren (geh., veraltet)
-verfälschen;(eine) andere Richtung geben;abfälschen;sinnentstellend wiedergeben
-Preßburger Schied;Preßburger Schiedsspruch;Preßburger Spruch
-offene Werkstatt;Makerspace;MakerSpace;FabLab
-Verschwörungserzählung;Verschwörungsideologie;abenteuerliche Erklärung(en);Verschwörungsglaube;Verschwörungsdenken;(Glaube an) das Wirken finsterer Mächte (variabel);Konspirationstheorie;Verschwörungswahn (abwertend);Verschwörungstheorie (Hauptform);Konspirationismus;Verschwörungsfantasie;Verschwörungsmythos
-Denazifikation;Entnazisierung (veraltet, zeitgenössisch);Entnazifizierung (Hauptform);Denazifizierung
-entmilitarisierte Zone;demilitarisierte Zone
-Anliegerverkehr;Anrainerverkehr (österr.);Zubringerdienst (schweiz.)
-leichtgängig;ruckfrei;reibungslos;ruckelfrei;laufruhig
-schlaksig;hoch aufgeschossen;(ein) Schlaks (ugs.);(ein) langes Ende (ugs.);langer Lulatsch (ugs.);(eine) Bohnenstange (ugs., fig.)
-Transsumpt;Insert
-Wachszinspflichtiger;Wachszinsiger
-Mühlteich;Mühlenweiher;Mühlenteich
-Mühlgraben;Mühlengraben;Mühlkanal
-Mühlenbach;Mühlbach
-nicht nachgeben;auf seinem Standpunkt beharren;(sich) nicht erweichen lassen (fig.);hart bleiben (fig., Hauptform);bei seiner Entscheidung bleiben;keinen Fuß breit nachgeben
-Licht;Latüchte (ugs., norddeutsch);Lampe;Leuchte (fachspr.)
-Obnoxiation;Schuldknechtschaft
-Volxküche;Küche für alle;Bevölkerungsküche
-Suppenküche;Volksküche;Tafel (Hauptform);Gassenküche (schweiz.);Armenküche;Suppenanstalt (veraltet)
-Strahlerkabel;Leckwellenleiter (fachspr.);abstrahlendes Kabel;Leckleitung;Schlitzkabel;Leckkabel
-Babinetsches Prinzip;Babinetsches Theorem
-Kirchhoffsches Beugungsintegral;Fresnel-Kirchhoffsches Beugungsintegral
-optischer Spalt;Schlitzblende
-anknallen (ugs.);(ganz) fest anziehen (Schraubmutter);festknallen (ugs.)
-(möglichst) zu vermeidendes Wort;Unwort;verpöntes Wort
-(altehrwürdiges, berühmtes) Gebäude;heilige Hallen (scherzhaft-ironisch)
-elektronischer Reisepass;biometrischer Reisepass
-Drittstaatsangehöriger;Drittstaatenangehöriger (veraltet)
-Bosman-Entscheidung;Bosman-Urteil
-vorläufiger Rechtsschutz;einstweiliger Rechtsschutz
-Stromschlüssel;Salzbrücke;Elektrolytbrücke
-überhandnehmen;zu viel werden;übermäßig anwachsen;ausufern
-soweit meine Zeit es zulässt;im Rahmen der Möglichkeiten;redlich;nach Maßgabe der Möglichkeiten (fachspr., Amtsdeutsch);nach besten Kräften;im Rahmen meiner Möglichkeiten (floskelhaft);im Rahmen des Möglichen;soweit möglich;nach Kräften;wenn Zeit ist (ugs.)
-(sich) räuspern;hüsteln
-(von etwas) kann nicht die Rede sein;(es) kann keine Rede sein (von);keine Spur (von)
-brennend neugierig sein (variabel);vor Neugierde brennen (variabel);sehr neugierig sein (variabel)
-dafür verantwortlich sein, dass es nicht vorangeht (variabel);derjenige sein, wegen dem (hier) nichts weitergeht;den (ganzen) Verkehr aufhalten (fig.)
-(der) tiefere Sinn;(der) eigentliche Sinn;(die) eigentliche Bedeutung
-nicht antworten;(etwas) bleibt jemandes Geheimnis (fig., ironisierend);keine Worte finden (zu);(darauf) nichts sagen;keine Antwort haben (auch figurativ);sprachlos sein;(die) Antwort schuldig bleiben;(jemandem) fällt nichts ein (zu);(darauf) nichts erwidern;(darauf) nichts zu sagen wissen (geh.)
-Schlangenangst;Ophidiophobie (fachspr.);Schlangenphobie
-Bienenangst;Melissophobie (fachspr.)
-Equinophobie (fachspr.);Pferdeangst;Pferdephobie
-es wurde noch keine Entscheidung getroffen;noch nicht ausdiskutiert;das letzte Wort ist noch nicht gesprochen;die Entscheidung steht noch aus;(etwas ist) noch nicht gesagt (ugs.);noch nicht entschieden
-ertrinken in (fig.);absaufen in (ugs., fig.);überschüttet werden (mit) (fig.);zugeschissen werden (mit) (derb, fig.);überflutet werden (mit) (fig.);es hagelt(e) ... (fig.);überschwemmt werden (mit) (fig.);gelöchert werden (mit Fragen);bombardiert werden (mit) (fig.);bestürmt werden (mit)
-Traktatshafen;Vertragshafen
-Totzeit;Durchflusszeit
-reduzierte Retentionszeit;Nettoretentionszeit
-Bodenzahl;Trennstufenzahl
-theoretische Bodenhöhe;Trennstufenhöhe
-Schwarze Schande;Schwarze Schmach
-mein letztes Angebot;Das ist mein letztes Wort.
-keine Ruhe geben können;es nicht gut sein lassen können;(immer) das letzte Wort haben (wollen/müssen)
-Film über das Erwachsenwerden;Coming-of-Age-Film
-(es herrscht) reges Treiben;(es gibt) viel Trubel;voller Leben;(es ist) eine Menge los;stark frequentiert (fachspr.);(es herrscht) geschäftiges Treiben
-närrisches Treiben;Karnevalstrubel
-Touristenrummel (Hauptform);großer Andrang von Touristen;(die) Touristen drängen sich;(ein Ort ist) fest in der Hand der Touristen
-Satellitenplattform;Satellitenbus
-Gerüstpfeilerviadukt;Bockbrücke
-Preis im Einzelhandel;handelsüblicher Preis;Endverkaufspreis;Straßenpreis
-unverbindliche Preisempfehlung;Preis nach Herstellerangabe(n)
-Marktpreis;Gleichgewichtspreis
-runder Preis;glatter Preis
-Kommissbrot;Kastenbrot
-Melanocyt;Melanozyt
-anorektales malignes Melanom;anorektales Melanom
-Analhaut;Analschleimhaut;Analkanalhaut;Anoderm
-malignes uveales Melanom;Aderhautmelanom
-Aderhaut;Choroidea;Chorioidea
-weiße Augenhaut;Lederhaut (des Auges);Sclera (fachspr.);Sklera (fachspr.)
-Tenonsche Kapsel;Tenon-Kapsel
-nonverbale Kommunikation;Verständigung ohne Worte;averbale Kommunikation
-zwischenmenschliche Kommunikation;interpersonelle Kommunikation
-Schachtelteufel;Springteufel;Kastenteufel
-noch Leute (ugs.);Verstärkung;zusätzliche Leute;Unterstützung;(noch) Leute zusätzlich (ugs.)
-zusätzliche;weitere;mehr
-abgemacht!;die Wette gilt!;topp!
-ernährungsbezogen;nutritiv
-und ob! (ugs.);wohl! (ugs., emotional);oh wohl! (ugs.);doch!
-Guerilla-Aktion (fig.);Nacht- und Nebel-Aktion (fig.)
-Coup (franz.);Operation;Schlag;Handstreich
-Coup d'Etat (geh., franz.);Putsch;Staatsstreich;Umsturz
-Eineinhalbdecker;Anderthalbdecker
-nicht der Weisheit letzter Schluss;'schön' ist anders (ugs., variabel);nicht der wahre Jakob (sprichwörtlich);nicht das Wahre;nicht das, was ich mir vorgestellt hatte;'gut' sieht anders aus (ugs., variabel);suboptimal;nicht das Gelbe vom Ei (ugs., sprichwörtlich)
-unsensibel;unglücklich;wenig einfühlsam;verunglückt;undiplomatisch;ungeschickt
-Normandie-Format;Normandie-Quartett
-Russenfeindlichkeit;Antirussismus;Russophobie
-Griechenfeindlichkeit;Antigräzismus
-Türkenphobie;Türkenfeindlichkeit
-Arabophobie;Antiarabismus
-Farnesischer Herkules;Herkules Farnese;Hercules Farnese;Herakles Farnese
-Saturnisches Zeitalter;Goldenes Zeitalter
-(sich) ein Bild machen;(sich) einen Überblick verschaffen;(sich) einen Eindruck von der Lage verschaffen;nachsehen, was los ist (ugs.);die Lage peilen (ugs.)
-Internationale Afrika-Gesellschaft;Internationale Afrika-Vereinigung;Internationale Assoziation
-(hier) nicht der Boss sein (ugs., variabel);nichts zu entscheiden haben;nichts zu melden haben (ugs.);(gar) nichts zu sagen haben;nichts zu bestellen haben
-Drei-Elementen-Lehre;Drei-Elemente-Lehre
-Reichsschutzstellung;Südostwall
-Kelassurier Mauer;Große Abchasische Mauer
-Negride;Negroide
-Nilosaharanisch;nilosaharanische Sprache
-Niger-Kongo-Sprachen (Plural);niger-kordofanische Sprachen (Plural, veraltet)
-Glasfasernetz;photonisches Netz
-Regelkarte;Qualitätsregelkarte
-STD (fachspr., engl.);Geschlechtskrankheit;sexuell übertragbare Krankheit;STI (fachspr., engl.)
-medizinisches Fachgebiet für Geschlechtskrankheiten;Lehre von den sexuell übertragbaren Krankheiten;Venerologie (fachspr.)
-zur Sache kommen;geschäftlich werden;aufs eigentliche Thema kommen;sagen, worum es (eigentlich) geht
-wohl noch;schon noch;vermutlich noch
-(endlich) zum (eigentlichen) Punkt kommen;(endlich) zur Sache kommen;(endlich) auf den (eigentlichen) Punkt kommen;(endlich) mit der Sprache herausrücken;nicht länger herumdrucksen;nicht länger um den heißen Brei herumreden;die Karten auf den Tisch legen (fig.);(endlich) sagen, was los ist
-Radebrechen;Rädern
-Königliche Republik der polnischen Krone und des Großfürstentums Litauen;Polen-Litauen
-Armenhaus;Ptochodochium (veraltet)
-Leitender Technischer Offizier;Leitender Ingenieur
-Oberingenieur;Chefingenieur;leitender Ingenieur
-Wegpendlergemeinde;Auspendlergemeinde;Pendlergemeinde
-Hauptzentrum (schweiz.);Oberzentrum
-Pompfüneberer (ugs., österr.);uniformierter Bestatter
-Ritualmordfabel;Blutanklage;Ritualmordvorwurf;Blutbeschuldigung;Ritualmordlegende;Blutgerücht;Blutlüge
-Hydraulikstößel;Hydrostößel
-Liebesbote;Überbringer von Liebesbotschaften;Postillon d'Amour (franz., scherzhaft)
-Zweites Kaiserreich;Französisches Kaiserreich
-dafür sorgen, dass jemand wieder alleine für sich sorgen kann (variabel);(jemandem) (wieder) auf die Beine helfen (wirtschaftlich) (fig.)
-saturiert (geh.);mit allem (gut) versorgt;überversorgt
-Fühlerlehre;Fächerspion
-(jemandes) Vorgänger sein;(jemandem) den Platz anwärmen (ugs., fig.)
-(jemanden) nicht wegschicken;(jemandem etwas) in Aussicht stellen;(sich jemanden) warm halten (ugs., fig.)
-(sich) einprägen;(sich) merken;nicht vergessen;(etwas) nachhalten
-sicheres Geleit;freies Geleit (Hauptform)
-Stresstest;Belastungsprobe;Härtetest
-(sich) dumm und dämlich zahlen (ugs.);(einen) Haufen Geld verlieren (ugs.);viel Geld verlieren (bei)
-analytische Chemie;chemische Analytik
-Hardliner;Vertreter eines harten Kurses;Falke (fig.)
-(eine) harte Linie fahren (Jargon);(sich) kompromisslos zeigen;(eine) harte Linie verfolgen
-Negersklave (derb);schwarzer Sklave
-Ambidextrie (fachspr., medizinisch);Beidhändigkeit
-(fester) Sendeplatz;(regelmäßiger) Sendetermin
-nicht zwangsläufig;muss nicht;nicht zwingend;nicht gesagt (sein) (ugs.);nicht notwendigerweise;nicht unbedingt
-mal nicht (ugs.);vielleicht nicht;nicht unbedingt;nicht direkt
-Sem;Bedeutungsbestandteil
-abstrahierte Bedeutungseinheit;Lexem
-Biometrie;Biometrik;Körpervermessung
-ebenerdig;zu ebener Erde;parterre;im Erdgeschoss;ganz unten (ugs.)
-Benogl (schwäbisch);Binokel
-im Sturm (ein)nehmen;(irgendwohin) stürmen;(etwas) entern (fig.);(etwas) stürmen;hineingelangen;(jemandem) auf die Bude rücken (ugs.);gelangen (in);(sich) Zutritt verschaffen
-Lexemverband;Wortfamilie
-Dorfbewohner;Dorfmensch;Dörfler
-Luxemburger Krise;Luxemburgkrise
-Freie Stadt;Freistadt
-Versammlung beider Parlamentskammern (Hauptform);Bundesversammlung (bundesdeutsch, schweiz., österr.);vereinigte Kammern (belgisch)
-Föderationssowjet;Föderationsrat
-erste Kammer;Oberhaus
-Unterhaus;Abgeordnetenkammer;zweite Kammer;Bürgerkammer
-es kam anders als (gewollt) (variabel);(das) Schicksal wollte es anders (variabel);(etwas) sollte nicht sein;daraus wurde nichts (ugs.);(etwas) kam nicht zustande;(es) sollte anders kommen (als);(es) hat nicht sollen sein (ugs., Redensart);(denn) erstens kommt es anders, und zweitens als man denkt (ugs., scherzhaft)
-K-Raum;Kontrollraum
-asymmetrischer Krieg;asymmetrischer Konflikt
-(sich) gleichen;(sich) ähneln;(sich) ähnlich sehen
-Führererlass;Führerverordnung
-Zionisten-Kongress;Zionistischer Weltkongress;Zionistenkongress;Zionistischer Kongress
-Pferdebahn;Pferdetram;Pferdeeisenbahn;Pferdestraßenbahn;Rösslitram (schweiz.)
-massiv kritisieren;schweres Geschütz auffahren (gegen) (fig.)
-antikes / mittelalterliches Metallsiegel;Bulle
-illegale Migration;irreguläre Migration;illegale Einwanderung
-Abschiebungshaft;Schubhaft (österr.);Ausschaffungshaft (schweiz.);Abschiebehaft
-illegaler Grenzübertritt;illegale Einreise
-Strafmandat (ugs.);Organstrafverfügung;Organmandat (ugs.)
-Namenspapier;Rektapapier (veraltet)
-vierter arabisch-israelischer Krieg (DDR);Ramadan-Krieg;Jom-Kippur-Krieg;Oktoberkrieg
-Junikrieg;Sechstagekrieg
-Sinai-Feldzug;Suezkrieg;Suezkrise;Sinai-Krieg;Sueskrise
-Ermüdungskrieg;Abnutzungskrieg
-Libanon-Feldzug;Libanonkrieg
-Gutmenschentum (abwertend);Humanitätsduselei (abwertend)
-in vielen (...) zu Hause;vielfältig einsetzbar;nicht festgelegt auf (ein/e/n ...);breit aufgestellt
-breit aufgestellt;nicht nur ein Ziel verfolgen;auf mehreren Feldern aktiv;überall mitmischen (wollen) (ugs.);überall seine Finger im Spiel haben (ugs.)
-parametererregte Schwingung;rheolineare Schwingung
-zehren von (geh.);aufbrauchen (ugs.);verbrauchen
-unentdeckt bleiben;nicht zu entdecken;unter dem Radar (fig.);nicht wahrgenommen werden;nicht auffallen
-Umbesetzung(en);Stellenumbesetzung(en);Stellenneubesetzung(en);personelle Umgestaltung(en);Sesselrücken (fig., schweiz., österr.);(personelle) Neuaufstellung;(das) Personalkarussell (dreht sich) (fig.);Stühlerücken (fig.)
-sehr hoher Wahlsieg;Erdrutschsieg;sehr deutlicher Wahlsieg
-(jemanden) siezen;(jemanden) mit Sie anreden;Sie zu jemandem sagen;mit jemandem per Sie sein
-alles durch haben (ugs.);alles ausprobiert haben;alles durchprobiert haben;(schon) alles gemacht haben;mit allem durch sein
-(es) tut mir leid (aber);seien Sie mir nicht böse (aber);ich will Ihnen nicht zu nahe treten (aber);(es) tut mir leid, das (so) sagen zu müssen (aber);sorry, aber (...) (ugs.);ich will ja nichts sagen, aber (ugs., floskelhaft)
-Nullarbor-Wüste;Nullarbor-Ebene
-Mischlingshund;Promenadenmischung (scherzhaft)
-Szegediner Gulasch;Krautgulasch
-Gulyas;Gollasch;Gujasch;Goulasch;Gulasch
-Rindergulasch;Wiener Gulasch;Rindsgulasch;Saftgulasch
-Debrecziner;Debreziner (österr.)
-Klobassi;Klobasse;Burenwurst;Klobassa
-Wurstgulasch;Würstelgulasch
-(sich) bewusst machen;(sich) vor Augen halten;(der) Tatsache ins Auge sehen (dass);nicht die Augen verschließen (vor);(sich) eingestehen;(sich) klar machen;realisieren
-jeden Moment;gleich;jeden Augenblick
-durch Schlagen in (die richtige) Form bringen;druckumformen (fachspr.);schmieden
-(sich) überschlagen (vor) (fig.);(es) fast schon übertreiben (mit) (ugs.);(es) zu gut meinen;alles nur Erdenkliche tun (um zu)
-alles Menschenmögliche;alles, was in meiner Macht steht;alles, was in meinen Kräften steht;alles, was man sich nur vorstellen kann;alles, was mir möglich ist;alles irgend Mögliche;mein Möglichstes;alles Erdenkliche
-runterlesen (ugs.);(sich) reinziehen (ugs.);weglesen (ugs.);(es) schaffen (zu lesen)
-Schraubendruckfeder;Druckfeder;Spiralfeder (fälschlich)
-Sprungfeder;Gewundene Torsionsfeder
-Abwehrspieler (Fußball);Verteidiger
-Vorstopper (fachspr., Jargon);Ausputzer (Fußball) (fachspr., Jargon, veraltet)
-Freischicht;(eintägiger) Freizeitausgleich
-Unterrichtsausfall;Freistunde (Schule)
-Trockentoilette;Plumpsklo (ugs.)
-(sein) Missfallen bekunden (geh.);(die) Nase rümpfen (über);missbilligen;(sein) Missfallen äußern (geh.);(sich) wenig begeistert zeigen (verhüllend)
-Wer arbeitet, (der) macht auch Fehler. (ugs.);Vor ... (z.B. vor Fehlern) ist niemand gefeit. (floskelhaft);Jeder macht mal Fehler. (ugs., Gemeinplatz);Das kann jedem mal passieren. (ugs., floskelhaft);Wer arbeitet, macht Fehler. (sprichwörtlich);Nobody is perfect. (Sprichwort, engl.)
-Beißerchen (kindersprachlich) (ugs.);Zahn
-eingeschlossen sein;nicht rauskommen;eingesperrt sein
-sehen (müssen), wo man bleibt;sich selbst helfen (müssen);zusehen (müssen), wo man bleibt;für sich selbst sorgen (müssen);Hilf dir selbst, dann hilft dir Gott. (Sprichwort);seinen (eigenen) Vorteil sichern
-Rückwärtsgang;Retourgang (österr.)
-Konfessionsschule;Bekenntnisschule
-Augsburger Bekenntnis;Augsburger Konfession
-Berner Disputation;Berner Religionsgespräch
-Religionsgespräch;Kolloquium;Disputation
-Regensburger Kolloquium;Regensburger Religionsgespräch
-genau durchsehen;(sich) durch etwas arbeiten;studieren;gründlich lesen (Hauptform);(etwas) durcharbeiten;(etwas) durchackern (ugs., fig.)
-(laut) vorlesen;verlesen
-am Manuskript kleben;(sich) durch den Text (seiner Rede) quälen (abwertend);ablesen
-nicht klarkommen ohne (...) (ugs.);unbedingt brauchen;angewiesen auf;ohne (...) aufgeschmissen (ugs.)
-dreckiges Lachen;hämisches Lachen (ugs.)
-Schweinkram;Ferkelei;Schweinigelei;Schmuddelkram (ugs.)
-(jemandem) wehtun;kränken (Hauptform);ins Mark treffen (fig.);(emotional) verletzen;ins Herz treffen (fig.);(jemandem) weh tun;im Innersten treffen;(jemanden) treffen
-rezipiert werden (fachspr.);gelesen werden;(seine) Leser finden
-(sich) entspannt zurücklehnen (können) (fig.);(einer Sache) gelassen entgegensehen
-überhaucht;wie mit Reif überzogen;bereift
-beringt (Vogel);mit einem Ring versehen;bereift
-bereift;mit Reifen ausgestattet
-(jemanden) sehr stören;(jemandem) ein Dorn im Auge sein (fig.);(jemandem) gründlich gegen den Strich gehen;(jemandem) passt die ganze Richtung nicht
-(jemandem) nicht gut genug sein;(sich) zu Höherem berufen fühlen;sich für wunders wie (...) halten;(sich) für etwas Besseres halten;(sich) für etwas zu schade sein;Starallüren haben
-(mit jemandem) einen Privatkrieg führen;(mit jemandem) in Fehde liegen (altertümelnd);(mit jemandem) einen Dauerkonflikt austragen;in endlose Streitereien (mit jemandem) verwickelt sein (ugs.);(mit jemandem) im Clinch liegen (ugs.)
-man kann sich des Eindrucks nicht erwehren (dass);alles spricht dafür (dass);es sieht ganz danach aus (als wenn);alles deutet darauf hin (dass)
-(hier steht es) schwarz auf weiß;das ist der (klare) Beweis
-(da) musst du dir nichts bei denken;(das) hat nichts zu sagen;(das) steckt nichts (weiter) dahinter
-ohne damit eine Absicht zu verfolgen;ohne Eigeninteresse;absichtslos;interesselos
-Unterhaltungs...;leichte Kost
-interessegeleitet;von Interessen bestimmt;von Interessen beeinflusst
-konventioneller Einzelhandel (variabel);stationärer Handel;analoger Handel (fachspr., Jargon, mediensprachlich);stationärer Einzelhandel (Hauptform)
-fast durchgängig (variabel);fast überall;allgemein;auf breiter Front (fig.);in fast allen Bereichen
-(irgendwo) stehen;abgedruckt sein;zu finden sein;zieren (geh., scherzhaft-ironisch);(irgendwo) sein (variabel)
-nicht von ungefähr kommen;schon seinen Grund haben (ugs.);(etwas) auf sich haben (mit);zu etwas gut sein (ugs.);was soll das (mit) (...)? (ugs.);zu etwas da sein;(eine) Bewandtnis haben;was ist mit (...)
-US-Staatsangehörigkeit;Staatsangehörigkeit der Vereinigten Staaten;US-Staatsbürgerschaft;Staatsbürgerschaft der Vereinigten Staaten;amerikanische Staatsangehörigkeit
-Investitionsvertrag;Investor-Staat-Vertrag
-Sagenkreis;Sagenzyklus
-Saga (auch figurativ);Sagenwelt;Sagen-Universum
-Märchenwelt;Wunschwelt
-Klöppelspitze;Guipure;Tüllspitze;Strickspitze;Zierband;Reticella-Spitze;Häkelspitze;Nadelspitze;Occhi;Weißstickerei;Spitze;Borte
-Progredienz;Progression;Progress
-(eine) freudige Überraschung (sein) (für) (variabel);angenehm überrascht sein;(sich) freuen können (über);(sich) glücklich schätzen (können);(sein) Glück kaum fassen können
-Conn-Syndrom;primärer Hyperaldosteronismus (fachspr.)
-primärer Reninismus (fachspr.);sekundärer Hyperaldosteronismus (fachspr.);hyperreninämischer Hyperaldosteronismus (fachspr.)
-sekundäre Krankheit;sekundäre Erkrankung
-primäre Erkrankung;primäre Krankheit
-Granulomatose mit Polyangiitis;Klinger-Wegener-Churg-Syndrom;Wegenersche Granulomatose;Allergische Angiitis und Granulomatose;rhinogene Granulomatose;Granulomatosis Wegener;Riesenzellgranuloarteriitis Wegener-Klinger-Churg;Morbus Wegener;Wegener-Granulomatose (veraltet);Wegener-Klinger-Churg-Syndrom;granulomatöse Polyangiitis
-Sarkoidose;Morbus Schaumann-Besnier;Morbus Boeck
-episodisch;phasenhaft
-rhythmisch;zyklisch
-Angstzustände;Angstanfall;Panikattacke
-Kuschelsex;Blümchensex
-Hardcore-Sex;harter Sex
-flapsige Bemerkungen;flotte Sprüche
-reinvestierte Erträge (Plural);einbehaltene Gewinne (Plural)
-Kapitalverkehrsbilanz;Kapitalbilanz
-Nichtzurückweisungsprinzip;Grundsatz der Nichtzurückweisung
-Drittstaat;Drittland
-Nehrung;Sandhaken
-schiefes Bild;(...) kann man schlecht (miteinander) vergleichen (ugs.);(ein) unpassender Vergleich;(der) Vergleich hinkt
-Können diese Augen lügen? (ugs., scherzhaft-ironisch);Glaubst du mir etwa nicht?
-Lebenselixier;(jemandem) Lebenskraft geben (Zaubertrunk);lebensspendendes Getränk
-Blutsverwandte (weibl.);Blutsverwandter (männl.)
-Oma und Opa (ugs.);Großeltern
-Doktor der Stomatologie;Doktor der Zahnmedizin
-im Augenblick (ugs.);gerade;im Moment (ugs.);in diesen Minuten;zur Stunde (geh.);jetzt gerade;momentan;in diesem Augenblick
-um was es geht (ugs.);Betreff (Brief);Rubrum (fachspr.);Überschrift
-Schnarrer;Ersatzstimme (ugs.);Electrolarynx (fachspr., engl.)
-Friedhofsorbit;Friedhofsbahn;Friedhofsumlaufbahn
-Mittelgangwagen;Durchgangswagen;Großraumwagen
-(jemandem etwas) (vor der Nase) wegschnappen (ugs.);(jemandem) zuvorkommen;schneller sein (ugs.)
-Wenzeslaus von Böhmen;Wenzel von Böhmen
-Furchtlosigkeit;Unerschrockenheit
-klassischer Tanz;(klassische) Tanzkunst;Ballett
-vor sich halten(d);in Vorhalte
-überzogene Preise (haben);es von den Lebendigen nehmen (Redensart);überhöhte Preise (fordern);es von den Lebenden nehmen (Redensart);es vom Lebendigen nehmen (Redensart)
-im Preis (viel) zu hoch angesetzt;wucherisch;überhöht;horrend (geh.);exorbitant (geh.);im Preis überzogen;(viel) zu teuer;Wucher...;(stark) überteuert
-Birnenbaum;Birnbaum
-Turbotauchpumpe;Turbinentauchpumpe
-verbuschen;(nach und nach) von Sträuchern überwuchert werden;(allmählich) (wieder) von Gehölzen besiedelt werden
-der (dummen Kuh) werde ich was erzählen! (ugs.);der kann was erleben! (ugs.);dem (Kerl) werde ich was erzählen! (ugs.);das soll der sich bloß (nicht) wagen! (ugs.)
-Pomologie (fachspr., lat.);Obstbaukunde
-Pomologe;Obstkundler
-(sich) realisieren;(sich) erfüllen;Wirklichkeit werden;wahr werden;in Erfüllung gehen
-Vinkulation;Vinkulierung
-Tripper (ugs.);Gonorrhoe
-Leistengegend;Leistenregion
-Hodensackbruch;Hodenbruch
-Nicolas-Durand-Favre-Krankheit;Lymphogranuloma inguinale (fachspr.);Venerisches Granulom;Lymphopathia venerea (fachspr.);Lymphogranuloma venereum (fachspr.)
-Regionalschule;Regionale Schule
-Gefrierschutzmittel;Frostschutzmittel (ugs.)
-Frequenzspektrum;Spektralverteilung;Spektrum
-Mythos von Langemarck;Langemarck-Mythos
-F-Schlepp;Flugzeugschlepp
-(der) andere;(mein) Gegenüber
-(neue) Gerätegeneration;Nachfolgemodell(e)
-verlobt (sein);(die) Ehe versprochen haben;(sich) verlobt haben;(jemandem) versprochen
-(etwas) ohne Gegenleistung bekommen;(etwas) in den Arsch geschoben bekommen (derb, fig.)
-wie hieß (der) noch mal?;wie hieß (der) noch gleich?;wie war noch mal (sein) Name? (variabel);wie war noch gleich (sein) Name?
-spann uns nicht (länger) auf die Folter!;mach's nicht so spannend!
-Ataxie bei Zielbewegungen;afferente Ataxie
-Holmes-Syndrom;Holmes Degeneration
-Adrenoleukodystrophie;Addison-Schilder-Syndrom
-Akanthozytose;Abetalipoproteinämie;Bassen-Kornzweig-Syndrom
-Fettstoffwechselstörung;Dyslipidämie (fachspr.)
-Konduktor (fachspr.);Überträger (Erbkrankheit)
-Zentralparese;zentrale Parese
-Babinski-Zeichen;Babinski-Reflex
-Magenlähmung;Magenatonie (fachspr.);Gastroparese (fachspr.)
-auszuhalten (sein);verkraftbar;zu verkraften (sein);zu ertragen (sein);Nur wenn ich lache. (ugs., Spruch, ironisch)
-Artikulation;Lauterzeugung (fachspr., linguistisch);Sprechweise;Aussprache;Lautbildung (fachspr.);Phonation (fachspr., medizinisch);Lautgebung
-näseln (Hauptform);nasal sprechen;durch die Nase sprechen
-kein leichtes Spiel haben;(sich) (richtig) anstrengen müssen;(jemandem) zu schaffen machen;(schwer) zu kämpfen haben;(etwas) nicht geschenkt kriegen
-(sich) die Hacken ablaufen (ugs., fig.);(sich) einen Wolf laufen (um zu) (ugs., fig.);endlose Laufereien haben (ugs., variabel);von Pontius nach Pilatus laufen (fig.);im Kreis herumgeschickt werden (fig.);von Pontius nach Pilatus geschickt werden (fig.)
-Leistungsdruck;Erfolgszwang
-diese ganzen;alle diese;die ganzen (regional);all die
-alle meine;meine ganzen;all meine
-Verkabelung;Kabelage (ugs., salopp);Kabelnetz
-Regal;Rack (fachspr., Jargon, engl.)
-freistehendes Regal;Gondelregal;Gondel (Ladeneinrichtung) (ugs., Jargon)
-Chemie- und Pharmatechnologe (schweiz.);Chemikant;Chemieverfahrenstechniker (österr.)
-Kleine Sünden bestraft (der liebe) Gott sofort. (Spruch, scherzhaft-ironisch);Wer nicht hören will, muss fühlen. (sprichwörtlich)
-(jemanden) nicht mehr belangen können;(jemandem) nichts mehr (wollen) können (ugs.);aus dem Schneider sein (ugs.);fein raus (sein) (ugs.);(jemanden) nicht mehr zur Verantwortung ziehen können;(jemandem) nichts anhaben können
-schlechtes Ergebnis;Negativbilanz
-Auswüchse;negative Folgen;unkontrollierte Entwicklung;Negativentwicklung
-Übertreibungen;Exzesse;Auswüchse
-ein (...) Ausmaß erreichen (variabel);kaum noch zu beherrschen sein
-bei;im Verlauf (einer Sache);im Zuge (einer Sache)
-es sei denn (dass);(Konjunktiv II +) denn (nachgestellt) (geh., altertümelnd);mit der Ausnahme, dass;ausgenommen (dass);außer wenn
-Sexualaufklärung;sexuelle Aufklärung
-(ein) Gesicht kennen, aber (nicht wissen woher) (variabel);(jemandem) nicht einfallen, woher er (die andere Person) kennt;nicht wissen, wo man jemanden hinstecken soll (ugs., fig.);(ein) Gesicht nicht zuordnen können
-in einem beklagenswerten Zustand;(ein) Bild des Jammers (bieten);(einfach nur) schrecklich aussehen (ugs., emotional);in keinem guten Zustand
-nicht mehr bewirtschaften;auflassen;stilllegen
-Genremalerei (Hauptform);Darstellung von Alltagsszenen
-Genrebild (Hauptform);Genregemälde;Darstellung einer Alltagsszene
-ploppen;Plopp machen
-Wurfgeschoss;Wurfgegenstand
-Heerführer;Feldherr;Schlachtenlenker
-Feldwebel (fig.);herrschsüchtige Person
-Fehlversuch;erfolgloser Versuch
-Guang-Stadt;Kanton;Guangzhou
-Nachrangdarlehen;nachrangiges Darlehen
-Mezzanine-Kapital;Mezzanine-Finanzierung
-Savoir vivre (geh., franz.);Kunst, das Leben zu genießen;Lebenskunst
-(das) Leben zu nehmen wissen;(sich) auf die Kunst zu leben verstehen
-(ein) Gebildeter;(ein) Intellektueller;(eine Person) mit akademischer Bildung
-viel von der Welt gesehen haben;weit gereist sein
-jetzt muss ich aber wirklich;ich habe Ihre Zeit lange genug in Anspruch genommen;ich möchte Sie nicht länger aufhalten;ich möchte (Sie) nicht länger stören
-große Klappe (ugs., fig.);große Schnauze (derb, fig.);großes Maul (derb, fig.);großes Mundwerk
-Mittwoch (oder) Donnerstag (ugs.);Mitte der Woche (ugs.);zur Wochenmitte;mitten in der Woche
-(sich) nichts vormachen;(den) Tatsachen ins Auge sehen;(sich) keine Illusionen machen;nicht die Augen verschließen (vor der Tatsache)
-Gott lästern;(sich) versündigen (an);Gott versuchen
-(sich) versündigen (an/gegen);in die Niederungen der (...) herabziehen;entweihen
-kalkulierter Optimismus;Zweckoptimismus
-(das) Selbst;(die) Selbstdefinition;Selbstverständnis;Identität
-Nämlichkeit (Amtsdeutsch);vollständige Übereinstimmung (mit sich selbst);Egalität;Parität;Identität;Kongruenz;Gleichheit (ugs.);Selbstübereinstimmung
-Identitätsmarker (fachspr.);Identitätsmerkmal;Identitätskriterium
-Zestenreißer;Zestenschneider;Zestenschäler;Zestenreibe;Zesteur
-geschmeichelt;freundlich ausgedrückt;wohlwollend formuliert
-Vorarlberg (Hauptform);Ländle (ugs., österr.)
-Gurkenhobel;Gemüsehobel
-derweil;in dieser Zeit (Hauptform);in der Zeit (ugs.)
-Übergangsphase;Übergangszeit;Durchgangsstadium
-Spitze;durchbrochener Stoff
-preußischer Budgetkonflikt;preußischer Verfassungskonflikt;Heereskonflikt
-Feldulme;Iper
-Provinz Schlesien;Preußisch-Schlesien (inoffiziell)
-Einsteingleichung;Gravitationsgleichung;Einstein-Hilbert-Gleichung;einsteinsche Feldgleichung
-Sur (bayr., österr.);Pökel
-Vallader;Unterengadinisch
-Varietät;Sprachvarietät
-Rasselbande (Hauptform, veraltend);kleine Racker
-Seltenheit;Exotik;Fremdheit;Ausgefallenheit;Außergewöhnlichkeit
-(ganz) harmlos anfangen;ein Wort gibt das nächste;ein Wort gibt das andere
-ohne (erkennbares) Alter;ewig jung;schwer einzuschätzen (im Alter);alterslos;zeitlos;nicht alternd(d)
-von zeitloser Schönheit;von unvergänglicher Schönheit;zeitlos schön;unvergänglich schön
-außerhalb der Zeit;überzeitlich;über den Zeiten stehen(d)
-Seminalplasma;Samenplasma
-Saxonus;Millionen-Dollar-Punkt;Jen-Mo-Punkt
-Gräfenberg-Zone;G-Zone;G-Punkt;G-Spot
-Kallikrein-3;prostataspezifisches Antigen;Semenogelase
-hineinschauen;Einblick nehmen;(einen) Blick reinwerfen (ugs.);reingucken (ugs., regional);hineinblicken;hineinsehen (Hauptform);(einen) Blick hineinwerfen;reinsehen (ugs., regional);einsehen
-Lernmittelfreiheit;Lehrmittelfreiheit
-Kamarband (hindi, persisch);Bauchbinde (ugs.);(um den Bauch getragene) Schärpe;Kummerbund
-Schmucksachen;Wertgegenstände;Valoren;Wertsachen;Wertpapiere
-Bruchstück;Fragment;Scherbe;Scherbel (landschaftlich);Splitter;Teil;Teilstück;Stück
-(jemandem) freie Hand geben;(jemanden) gewähren lassen;(jemanden) machen lassen (ugs.);(jemanden) selbst entscheiden lassen
-(jemanden) kontrollieren;(jemandem) über die Schulter schauen;(jemandem) auf die Finger schauen
-böse;dämonisch;besessen;teuflisch
-Plattfußindianer (ugs., Soldatensprache);Sandfloh (ugs., Soldatensprache, veraltend);Infanterist;Sandhase (ugs., Soldatensprache, veraltend);Fußsoldat;Schütze;Grenadier;Fußlatscher (ugs., Soldatensprache);Nahkämpfer;Stoppelhopser (ugs., Soldatensprache)
-du wirst schon sehen, was du davon hast (ugs.);du spielst mit deinem Leben (drohend) (scherzhaft);mach nur so weiter! (ugs., Spruch);ich sage es dir im Guten (ugs.);sei vorsichtig;ich warne dich (Hauptform)
-Köpfe rollen (lassen) (fig.);(jemanden) verantwortlich machen;(jemanden) zur Verantwortung ziehen;(jemanden) büßen lassen (für)
-(jemanden) für alles verantwortlich machen (wider besseres Wissen);(jemanden) finden, dem man (eine Sache) in die Schuhe schieben kann;(einen) Sündenbock finden;(jemanden) zum Sündenbock machen
-red' keinen Unsinn (ugs.);träum' weiter (ugs.);komm mir nicht so! (ugs.);erzähl' keinen Blödsinn (ugs.);spinn dich aus (ugs.);was erzählst du da! (ugs.)
-hinunterwürgen;verschlingen;runterschlucken;devorieren (fachspr.);hinterschlucken;verschlucken;herunterwürgen
-(...,) so! (ugs.);(...) das mal (als) erstes. (ugs., variabel)
-(sich) unters Messer legen;(sich) operieren lassen
-markantes topographisches Objekt;Kennung (fachspr., seemännisch);(weithin sichtbarer) Orientierungspunkt;Landmarke
-kennzeichnendes Bauwerk;Wahrzeichen
-(die) Hosen anhaben (fig.);(Frau) mit Haaren auf den Zähnen (fig.);Flintenweib (fig., scherzhaft-ironisch)
-darf ich dich (vielleicht) daran erinnern (dass ...)?;schon vergessen? (Spruch, ironisch);soll ich's dir noch schriftlich geben? (ugs., ironisch);dass ich dir das überhaupt sagen muss!
-erzähl niemandem, dass ich dir das gesagt habe (variabel);das hast du (aber) nicht von mir!
-so läuft das (nun mal);das sind die Regeln
-(das) Gesicht zu einem Grinsen verziehen;(einfach) lächeln müssen;(das) Gesicht zu einem Lächeln verziehen
-(jemandes bis dato makelloser) Ruf hat gelitten (variabel);(sich) rufschädigend auswirken;ins Zwielicht geraten (fig.);(seine) Weste ist nicht mehr blütenweiß (fig.);(etwas) bleibt hängen (an)
-das brauche ich Ihnen (wohl) nicht zu erklären;(das) muss ich Ihnen (ja wohl) nicht sagen (variabel);(das) wissen Sie besser als ich
-Supplierstunde (österr.);Vertretungsstunde
-Kochsalat (österr.);Römersalat
-Schah;König
-Emir;arabischer Fürst
-(es) schadet (doch) nicht;verursacht keine laufenden Kosten;kostet (doch) kein Geld;(etwas) frisst (ja) kein Brot (fig.)
-Kabinettsumbildung;Neubesetzung der Ministerposten;Umverteilung der Ministerposten (variabel)
-falscher Freund;Fauxami (franz.)
-Namenschrist;Taufscheinchrist
-Mochenisch;Fersentalerisch
-schließen (Tür, Fenster, Vorhang ...);zu...;zuziehen;zumachen
-Reizgas;chemische Keule (fig.);Tränengas
-Biozid (fachspr.);Pestizid (engl.);chemische Keule (ugs., fig.);Schädlingsbekämpfungsmittel
-Zumutung;(ungehörige / irritierende / übertriebene / deplatzierte ...) Forderung(en);überzogene Ansprüche;Unverschämtheit (ugs.);Ansinnen (geh.)
-Ovidukt;Eileiter
-Interzeption;Nidationshemmung
-Absolutheit;Unbedingtheit
-nicht, dass ich wüsste;(das) müsste ich wissen (ugs.);wenn Sie mich fragen: nein;soweit es mich angeht, nicht;soweit ich weiß, nicht;von mir aus nicht;wenn du mich fragst: nein;ich glaube nicht (ugs.);nach meiner Kenntnis nicht
-Kleinwindenergieanlage;Windgenerator
-Kostenloskultur;Gratiskultur;Umsonstkultur
-generische Struktur;Generalformel;Markush-Formel
-Chlorambucil;Leukeran (Handelsname)
-Obinutuzumab;Afutuzumab (veraltet)
-Immunhistologie;Immunhistochemie;Antikörperfärbung
-klonal;monoklonal
-Blutbildung;Hämatopoese
-Blutzelle;Hämocyt;Hämozyt;Hämatocyt;Blutkörperchen
-Leukopoese (fachspr.);Leukozytopoese (fachspr.);Bildung von weißen Blutkörperchen
-Blutstammzelle;hämatopoetische Stammzelle
-fliegende Blätter (fig.);in seine Einzelteile aufgelöst (variabel);zerfleddert (Buch) (Hauptform);Loseblattsammlung (fig.);zerlesen;zerfetzt
-torlos unentschieden;null zu null;(ein) torloses Unentschieden
-(sich) gut anhören(d);wohlklingend
-Katastrophenwiederherstellung;Notfallwiederherstellung
-(also) ich komme hier nicht vor Langeweile um (falls du das meinst) (ugs., ironisierend);ich hab ja auch sonst nichts zu tun! (ugs., ironisch);du denkst wohl, ich dreh hier den ganzen Tag Däumchen!? (ugs.)
-Behaimscher Erdapfel;Behaim-Globus
-Mönchsgewand;Kutte
-das ist jetzt nicht das Thema;(darum) können wir uns ein andermal kümmern;das ist hier nicht das Thema;(etwas) ist eine andere Baustelle (fig.)
-andere;andere Leute;fremde Leute
-(sich) um seine (eigenen) Angelegenheiten kümmern (sollen);vor seiner eigenen Türe kehren (sollen) (geh., sprichwörtlich);genug eigene Baustellen haben (ugs., fig.);(sich) aus fremder Leuts Sachen heraushalten (sollen);(sich) um seinen (eigenen) Mist kümmern (sollen) (ugs., salopp);genug eigene Probleme haben (ugs.)
-(eine) Folge (von) (Hauptform);(eine) Sequenz (von);(eine) Reihe (von) (Hauptform);(eine) Kette (von);(eine) Abfolge (von);(eine) Aufeinanderfolge (von);(eine) Serie (von);(ein) Rattenschwanz (von) (fig., negativ)
-Dialogbox;Dialogfenster;Dialog (ugs.);Dialogfeld
-Rückführtaste mit Zeilenschaltung (fachspr.);Enter(-Taste);Zeilenschalter;Return (engl.);Eingabetaste;Knickpfeiltaste (ugs.)
-Schädelvermessung;Kraniometrie
-Clubweste;Kutte (Jargon);Lederweste (mit Abzeichen)
-Habit;Ordensgewand;Ordenstracht
-Werkzeuge;Werkzeug (Sammelbegriff);Gezähe (Bergmannssprache)
-Piedestal;Postament
-schau, dass (süddt.);mach, dass;sieh zu, dass
-Pottkieker (ugs., norddeutsch);Dibbegugger (ugs., hessisch);Haferlgucker (ugs., bayr.)
-Spickzettel;unerlaubtes Hilfsmittel (Amtsdeutsch);Spicki (Schülerjargon) (ugs.);Pfuschzettel
-(sich) einer Sache überlassen;fortgetragen werden (von);(sich) ergehen (in) (geh.);(sich) berauschen an;schwelgen (in) (geh.);aufgehen (in)
-zu leben verstehen;(das) Leben genießen;(sich) nichts abgehen lassen;zu leben wissen;(etwas) vom Leben haben (wollen);(es sich) wohl sein lassen (geh.)
-alles aufbieten;weder Kosten noch Mühe(n) scheuen;(es) an nichts fehlen lassen;an nichts sparen
-es geht nicht an (dass);es kann nicht sein (dass) (floskelhaft);(es kann) nicht angehen (dass)
-(ein) Borealgermanismus (fachspr.);(ein) Borealismus (fachspr.);norddeutsch;(sprachliche) Eigentümlichkeit des Norddeutschen
-zwanghaftes Spielen;pathologisches Spielen;Spielsucht (ugs.)
-Nägelbeißen;Nagelkauen;Nägelkauen;Onychophagie;Fingernagelkauen
-Lesch-Nyhan-Syndrom;Hyperurikämie-Syndrom;Hyperurikose
-Borderline-Persönlichkeitsstörung;emotional instabile Persönlichkeitsstörung des Borderline-Typs
-Anhidrosis (fachspr.);Anhidrose;Anidrosis (fachspr.);Anidrose
-Hyperhidrosis (fachspr.);Hyperhidrose
-Horner-Trias;Horner-Syndrom
-Hyperhidrosis palmaris (fachspr.);Schweißhand
-Gradtagszahl;Gradtagzahl
-amtliche Zeit;amtliche Uhrzeit;offizielle Uhrzeit;gesetzliche Zeit;gesetzliche Uhrzeit;offizielle Zeit
-Pierre-Marie-Syndrom;Akromegalie;Marie-Syndrom;Pachyakrie
-Schneewaldklima;kaltgemäßigtes Klima;boreales Nadelwaldklima;subarktisches Klima
-deutlich hören;klar (und deutlich) ankommen (bei);laut genug hören;(akustisch) verstehen (Hauptform)
-(gut) verständlich (Aussprache, Lautstärke);klar und deutlich;so klar als würde er (direkt) neben mir stehen (variabel);(klar) artikuliert
-Querhaus;Querschiff;Transept
-Mittelschiff;Hauptschiff
-Bremser (ugs.);Verhinderer
-traurige (+ Mengenangabe);lumpige (+ Mengenangabe) (abwertend);magere (+ Mengenangabe);bescheiden(e) (+ Mengenangabe);beschämend(e) (+ Mengenangabe) (abwertend);erbärmlich(e) (+ Mengenangabe) (abwertend);mickrige (+ Mengenangabe) (abwertend);kümmerlich(e) (+ Mengenangabe) (abwertend);armselig(e) (+ Mengenangabe)
-Selbstzünder (Jargon);Diesel;Dieselmotor
-Sassanidenreich;Neupersisches Reich
-(jetzt) wissen, wie's geht;(sich) reingefummelt haben (in);raushaben, wie (...) (ugs.);(sich) reingefuchst haben (ugs.);den (richtigen) Dreh raushaben (ugs.);(den) Bogen raushaben (ugs.)
-nichts weiter dazu sagen;unkommentiert bleiben;(etwas) so stehen lassen (fig.);keinen Kommentar abgeben zu;unwidersprochen bleiben
-Dampfglätter;Kleiderdampfer;Kleiderdampfgerät
-Flammkuchen (Hauptform);Dinnele (schwäbisch);Hitzkuchen (württembergisch);Dinnede (Oberschwaben);Blootz (fränk.);Deie (schwäbisch)
-Antrittsvorlesung;Antrittsrede (veraltet)
-Barett;Béret (schweiz.)
-Probevorlesung;Probelehrveranstaltung
-blutbildend;hämatogen
-Lymphe;Gewebsflüssigkeit
-Fruchtkörperbildung;Fruktifizierung;Fruktifikation
-(sich) nicht einmischen;(die) Füße stillhalten (fig.);nichts unternehmen;(sich) passiv verhalten;nicht aktiv werden
-schrillen;gellend schreien;gellen;schrill tönen
-Flüchtlingshasser;Ausländerfeind;Fremdenhasser;Fremdenfeind
-Schwulenfeind;Schwulenhasser
-nicht anders können (als);es nötig haben
-unter jemandes Niveau;(etwas) wäre jemandem (zu) peinlich;(jemandem) zu billig sein;(jemandem) zu platt sein;(jemandem) zu primitiv sein
-von eigenen Gnaden (nachgestellt) (geh.);selbsternannt;Möchtegern...
-(ganz) unscheinbar daherkommen;nicht zeigen, was man draufhat (ugs.);sein Licht unter den Scheffel stellen (fig., sprichwörtlich)
-(etwas) nicht zeigen;(jemandem) nicht anzusehen sein;(sich etwas) nicht anmerken lassen
-Montanistik;Montanwesen;Bergbauingenieurwesen;Montanwissenschaften
-wirken (bei);einsteigen (auf);anspringen (auf) (ugs., fig.);ziehen (bei);verfangen (bei) (geh.);ansprechen (auf);reagieren (auf)
-(psychische) Robustheit;Resilienz;psychische Widerstandsfähigkeit
-engagiert sein;befasst sein (mit);eingebunden sein;eingespannt sein (in);involviert sein (in)
-(sich) beschäftigen mit;untersuchen;beackern (Themengebiet) (ugs.);bearbeiten
-wegreißen;zerstören (durch Wind / Wellen);fortreißen;(etwas) hinwegfegen;abtragen
-wüten;hinwegrasen über;hinwegfegen über
-abwählen;wegfegen (fig.);hinwegfegen (fig.);beseitigen;aus dem Amt jagen;aus dem Amt fegen (fig.)
-(sich) über etwas im Klaren sein;(sich) einer Sache bewusst sein;wissen (Hauptform);(jemandem) klar sein
-Passepartoutwort (fachspr.);Platzhalterwort (fachspr.)
-(ein) gutes Auge haben;gut sehen;Adleraugen haben (fig.);(ein) scharfes Auge haben
-alles im Blick haben;alles sehen;(jemandem) entgeht nichts
-(ein) Auge haben für;wissen, was gut aussieht;wissen, was gut zusammenpasst
-sehr geschickt sein (in);gut darin sein, zu (+ Infinitiv) (variabel);(ein) Händchen haben (für) (Hauptform);(etwas) gut können;gut mit etwas umzugehen wissen;gut sein (in) (ugs.)
-nicht wissen, wie man das (alles) schaffen soll;nicht wissen, wo einem der Kopf steht (fig.);(vor lauter Arbeit) nicht wissen, womit man anfangen soll
-filetieren (geh., fig.);zerschlagen;(in einzelne Unternehmen) zerlegen
-radikal bekämpfen;(die) Quelle (von etwas) trockenlegen (selten);(bereits) an seinem Ursprungsort bekämpfen;(das) Übel bei der Wurzel packen (Redensart);(das) Übel an der Wurzel packen (Redensart);(den) Sumpf (z.B. der Vetternwirtschaft) trockenlegen (fig.);mit Stumpf und Stiel beseitigen (Redensart)
-(voll) stehen hinter;setzen auf;schwören auf;große Stücke halten auf;fest überzeugt sein von;(sich) voll verlassen auf
-keine Kritik dulden (an);(sich) schützend vor jemanden stellen;nichts kommen lassen (auf)
-Feldkurat (veraltet, österr.);Feldprediger;Feldkaplan
-römischer Kragen;Römerkragen;Kollar;Piuskragen
-Bosnisch-hercegovinische Infanterie;Bosniaken (Jargon, Plural, österr.)
-Sprachkontakt (Hauptform);Sprachenkontakt
-Schemaitisch;Samogitisch
-Sudauisch;Jatwingisch
-Jotwinger;Jadwingen;Sudauer;Jatwägen;Jatwinger;Jadwinger;Pollexaner
-Schalauen;Schalwen
-Kulmer Land;Culmerland;Culmer Land;Kulmerland
-Spartacus-Aufstand;Dritter Sklavenkrieg;Gladiatorenkrieg
-Schlacht von Lukanien;Zweite Schlacht am Silarus
-Fehlbesetzung (Hauptform);falscher Mann (für eine Rolle, Aufgabe) (männl.);nicht der Richtige (ugs.);falsche Frau (für eine Rolle, Aufgabe) (weibl.);falsche Person (für eine Rolle, Aufgabe)
-(die) linke Hand weiß nicht, was die rechte tut;(es gibt) kein einheitliches Vorgehen;nicht an einem Strang ziehen
-eine ruhige(re) Zeit (vor sich) haben (variabel);in ruhigeres Fahrwasser kommen (fig., variabel)
-stürmische Zeiten sein (für) (fig., variabel);(eine) turbulente Zeit haben (variabel)
-Befähiger;Träger;Ermöglicher;Weichensteller (fig.);Enabler (engl.)
-Zweipuls-Brückenschaltung;Graetzschaltung;Brückengleichrichter;Graetzbrücke
-Thomson-Brücke;Kelvin-Brücke
-Ringmodulator;Produktmodulator;Balance-Modulator;Ringmischer
-Löschfunkensender;Tonfunkensender
-Sicherheitsstufe;Sicherheits-Integritätslevel;Sicherheitsanforderungsstufe
-Deutscher Hochschulring;Hochschulring Deutscher Art (regional)
-Republikanisches Studentenkartell;Reichskartell der Deutschen Republikanischen Studentenschaft
-NSD-Studentenbund;Nationalsozialistischer Deutscher Studentenbund
-metrischer Tensor;Metriktensor;Maßtensor
-Eilsendung;Schnellpostgut;Schnellpost;Eilbotensendung;Eilbrief (Hauptform);Expressversand;Schnellsendung;Eilzustellung
-überschneidungsfrei;eigenständig
-wissensdurstig;lernbegierig;lernhungrig
-Arbeit(en) ohne Anspruch;einfach(st)e Arbeit(en);Aushilfstätigkeit(en);niedere Arbeit(en) (ugs., abwertend);Handlangertätigkeit(en)
-Tätigkeit;Schaffen;Beschäftigung;Tun;Arbeit (= das Arbeiten);Geschäft (geh.)
-Referat (Hauptform);schriftliche Ausarbeitung;(schriftliche) Darstellung;(schriftliche) Hausarbeit;(schriftliche) Arbeit
-nicht nötig;unnötig (Hauptform);überflüssig;verzichtbar;muss nicht sein (ugs.);nicht (so) wichtig;nicht brauchen (zu) (ugs.);(danke,) kein Bedarf (ugs.);nicht erforderlich;unwichtig;entbehrlich (geh.)
-mehr als nötig;übergenug;mehr als notwendig (gewesen wäre);überschüssig (Hauptform);nicht mehr notwendig;keine Verwendung haben (für);überflüssig;nicht mehr vonnöten;wird nicht (mehr) gebraucht (ugs.);zu viel;überzählig
-(sich) (von selbst) verstehen;unnötig zu sagen (dass);nicht eigens erwähnt zu werden brauchen;unnütz zu sagen (dass);keiner besonderen Erwähnung bedürfen (geh.)
-überschüssig;frei (Steckplatz, Anschluss);nicht in Gebrauch;nicht belegt;zusätzlich
-zu einer Reaktion provozieren;eine Reaktion provozieren (bei);(jemanden) aus der Reserve locken
-Frutaner;Fruitaner;Fructarier;Fruganer;Fruitarier;Frutarier
-Fruganismus;Fruitarismus
-gleichkommen;es aufnehmen können mit;gleichauf liegen;(der eine ist) nicht besser (als der andere);ebenbürtig sein;in nichts nachstehen;(sich) messen können (mit);die tun sich beide nix (ugs.);(den) Vergleich nicht zu scheuen brauchen;genauso gut sein (Hauptform);gleichrangig sein;(gut) mithalten (können);vergleichbar sein (mit);heranreichen an;(sich) nicht verstecken müssen (hinter) (fig., variabel);anstinken (können) (gegen jemanden / etwas) (ugs.);gleichwertig sein;(sich ein) Kopf-an-Kopf-Rennen (liefern);ranggleich sein;(jemandem) das Wasser reichen können (ugs., fig.);(sich) nicht zu verstecken brauchen (hinter) (fig.);zu vergleichen sein;gleich stark (sein);in derselben Liga spielen (ugs., fig.);nicht schlechter sein
-Pendelstütze;Pendelstab
-Menschen umgebracht haben;(ein) Mörder sein;Menschen(leben) auf dem Gewissen haben;für den Tod (von ...) verantwortlich sein;an jemandes Händen klebt Blut (fig.);Blut an den Händen haben (fig.)
-Ärmelkanaltunnel;Kanaltunnel;Eurotunnel
-menschbezogen;personenbezogen;ad hominem (lat.)
-ermahnend;adhortativ
-livide;bläulich;livid;blassblau
-Großrabbiner;Oberrabbiner
-Notbeleuchtung;Notlicht
-nicht weiterkommen;es gibt kein Durchkommen;feststecken;blockiert sein (Straßen, Ausgänge ...);es ist kein Durchkommen
-dicht (sein);blockiert;zu sitzen (Nase) (ugs.);zu (sein)
-ins Freie;hinaus (geh.);raus (ugs.);an die frische Luft;nach draußen
-Wochentagsberechnung;Kalenderrechnen
-Feder-Masse-Verschluss;Masseverschluss
-Kollektivmonopol;vertragliches Monopol
-Kehrmonopol;Schornsteinfeger-Monopol
-Preisdifferenzierung;Preisdiskriminierung
-Zahlungsbedingung;Zahlungskondition
-bilaterales Oligopol;zweiseitiges Oligopol
-Durchschnittskosten;Stückkosten
-man hört in letzter Zeit sehr wenig von (ugs.);es ist sehr ruhig geworden um (variabel)
-Sündenregister;(die) Liste von jemandes Verfehlungen;Vorstrafen
-Feuerlöschfahrzeug;Feuerwehrauto;Löschfahrzeug;Feuerwehrfahrzeug
-großen Zulauf haben;Schlange stehen (um) (fig.);(jemandem) die Bude einrennen (fig.);sehr gefragt sein;(sich) die (Tür-) Klinke in die Hand geben (fig.);(sich) nicht retten können (vor) (fig.)
-Stoma;Spaltöffnung
-Meristem;Bildungsgewebe
-Subtext;versteckte Botschaft;Konnotation;Andeutung;Nebenton;Nebenbedeutung;Unterton;Beiklang
-Strippenzieherei;dunkle Machenschaften;finsteres Treiben
-Gezeitenhub;Tidehub;Tidenhub
-Albingenser;Albigenser;Katharer
-Ségou-Reich;Reich von Bambara
-das Recht auf seiner Seite haben;im Recht (sein)
-(sich) auf dem Boden des Gesetzes bewegen;das Recht auf seiner Seite wissen
-Dentin;Zahnbein
-Bleiche (ugs.);Bleichmittel
-zu Tode reiten (fig.);breitwalzen (fig.);breittreten (ein Thema) (fig., Hauptform);bis zum Überdruss durchkauen (fig., variabel);totreiten (fig.);auswalzen (fig.);zerreden;totreden
-Flusstauchen;Strömungstauchen
-Pumpspeicherwerk;Pumpspeicherkraftwerk;Umwälzwerk (schweiz.)
-Wasserspeicherkraftwerk;Speicherwasserkraftwerk
-Schlacht in der Madurastraße;Schlacht in der Floressee;Schlacht nördlich der Lombokstraße;Schlacht in der Straße von Makassar
-Zuschlagstoff (fachspr.);Zuschlag (fachspr.)
-Betonzuschlag (fachspr., Jargon, veraltend);Gesteinskörnung (fachspr., Hauptform);Mineralstoff (fachspr., Jargon, veraltend);Mineral(stoff)gemisch (Jargon, veraltend)
-(das) Rad der Geschichte zurückdrehen;(die) Zeit zurückdrehen
-(die) Zeit zurückstellen (ugs.);(die) Uhr zurückstellen
-ankern;vor Anker liegen
-(Die) Show ist vorbei. (Spruch, fig.);Hier gibt es nichts (mehr) zu sehen.
-Hochkultur;Kultur der (gesellschaftlichen) Eliten
-Populärkultur (Hauptform);Kultur des Volkes;Volkskultur;Massenkultur;Kultur der Massen;Popularkultur
-Bildhauerei;Bildhauerkunst;Plastik
-Einerkomplement;(B-1)-Komplement
-Dualsystem;Zweiersystem;Binärsystem
-Laienmalerei;naive Malerei
-Architektur (Gattung);Baukunst
-Grafik (Gattung);Druckgrafik
-gestaltende Kunst;bildende Kunst
-darstellende Kunst;ephemere Kunst
-Schauspiel;Theater (Gattung) (Hauptform)
-Inselrinde;Reilsche Insel;Inselcortex
-Feuerwehrschlüsseldepot;Feuerwehrschlüsselkasten (veraltet)
-Da soll sich (noch) einer auskennen. (Spruch);Was soll man heute noch glauben! (variabel);Man weiß (schon) gar nicht (mehr), was man (heute) noch glauben kann (und was nicht). (Gemeinplatz)
-anziehen (Preis);(sich) verteuern;im Preis steigen;steigen (Preis);teurer werden
-alles, was Rang und Namen hat;ein Who is Who (des/der ...)
-in technischer Sprache (ausgedrückt);fachsprachlich;fachterminologisch;technisch gesprochen
-unmittelbar bevorstehen;bald ist (...);nicht mehr lange auf sich warten lassen;nur noch kurze Zeit, dann;vor der Tür(e) stehen (fig.)
-Aufsteigen (österr.);Vorrücken (bayr.);Promotion (schweiz.);Versetzung
-Lehr-Lern-Forschung;Lehr-Lernforschung
-Spitzahorn;Spitz-Ahorn (botanisch);Spitzblättriger Ahorn
-Gehölzkunde;Dendrologie
-undenkbar;nicht vorstellbar;unvorstellbar;unausdenkbar
-Ärmelkanal (Hauptform);Englischer Kanal
-das Spektrum betreffend;spektral
-Nabe;Nexus (lat.);Gefüge;Verbindung
-Geheimdienstabfrage;Selektoren;festgelegte Suchmerkmale
-Woll'n wir wetten? (ugs.);Wetten dass? (ugs.)
-Bergrettung;Bergwacht;Bergrettungsdienst
-Zweiparteiensystem;Zweiparteiendemokratie
-Krepis;Krepidoma
-Euthynterie;Richtschicht
-Stylobat;Stylobates
-Peripteraltempel;Ringhallentempel;Peripteros
-Boat-People (engl.);Bootsflüchtling(e);Boatpeople (engl.)
-(sich) röten;rot werden;rot anlaufen;(sich) rot färben
-rot werden wie ein Schulbub (süddt.);(so) eine Bombe kriegen (mit Geste) (ugs.);rot werden wie ein Schuljunge;rot werden wie eine Tomate;über und über rot werden;bis zu den Haarwurzeln rot werden (variabel);erglühen (geh.);feuerrot werden;bis über die Ohren rot werden (variabel);(einen ganz) roten Kopf bekommen (Hauptform);rot anlaufen
-Planetenschleife;Oppositionsschleife
-Teilchen in einem virtuellen Zustand;intermediäres Teilchen;virtuelles Teilchen
-Eichtheorie;Eichfeldtheorie
-Multiplizität;Entartungsgrad
-kernmagnetische Resonanz;magnetische Kernresonanz;Kernspinresonanz
-Subunternehmen;Nachunternehmen
-Nachunternehmer;Subunternehmer
-Verrechnungsabkommen;Tilgungsträger
-Jahresendfigur m. F. (Amtsdeutsch, DDR, ironisch, variabel);Weihnachtsengel;Rauschgoldengel (veraltend);Christbaumengel (Hauptform)
-Wir müssen reden. (floskelhaft);(es besteht) Gesprächsbedarf
-(etwas) hinlegen;(etwas) aus der Hand legen;(etwas) ablegen;(etwas) (irgendwohin) legen
-auf alt getrimmt (ugs.);altertümelnd;archaisierend
-haushalten mit;sparsam einsetzen
-Weinberg (Hauptform);Wangert (rheinisch);Raabstick (badisch);Rebberg;Weingarten;Wengert (fränk.);Raabberg (badisch);Wingert (schweiz., süddt.)
-Hausmeier;Majordomus
-Merovinger;Merowinger
-klarkommen (mit) (ugs.);über die Runden kommen (mit) (ugs., fig.);für jemandes Lebensunterhalt ist gesorgt;(jemandes) Geld reicht zum Leben;zurechtkommen (mit) (ugs.);seinen Lebensunterhalt bestreiten (können);(sein) Auskommen haben;haben, was man (zum Leben) braucht;mit seinem Geld auskommen
-zum Sterben zu viel, und zum Leben zu wenig sein (sprichwörtlich);jeden Pfennig zweimal umdrehen müssen (fig., veraltet);wenig verdienen;jeden Cent zweimal umdrehen müssen (fig.);(das Geld) reicht hinten und vorne nicht;kaum über die Runden kommen (finanziell);so gerade (eben) über die Runden kommen;ums Überleben kämpfen (müssen);zum Leben zu wenig, und zum Sterben zu viel sein (sprichwörtlich);(von etwas) nicht leben und nicht sterben können
-Siegrune;Sigrune
-(es) gibt nicht (ugs.);(es) kommt nicht zu;anders kommen;nicht eintreten;ausbleiben
-Xylitol (Trivialname);Pentanpentol;Birkenzucker;E 967 (fachspr., E-Nummer);Xylit (Trivialname)
-Zuckeralkohol;Alditol
-hapaxanth (fachspr.);einmalblühend;einjährig
-gesteigerte Schmerzempfindlichkeit der Haut;Haphalgesie;Schmerzüberempfindlichkeit der Haut
-Schlüsselbeinbruch;Klavikulafraktur (fachspr.)
-primitiver Datentyp;einfacher Datentyp;elementarer Datentyp
-du wolltest ja nicht (auf mich) hören (und das hast du nun davon);(das) hab ich (euch) doch gleich gesagt!;auf mich hört ja keiner!;(das) hätte ich euch (auch) vorher sagen können!
-aber ja! (aber sicher!) (variabel);tu dir keinen Zwang an;aber ich bitte Sie!;aber bitte, gerne!;(nur) keine falsche Scham;aber nein!;nur zu!;tun Sie sich keinen Zwang an
-Kamingarnitur;Ofenbesteck;Kaminset;Kaminbesteck
-Enterostoma;künstlicher Darmausgang;Bauchafter;Kunstafter;Seitenausgang (ugs.)
-Urostoma;künstlicher Blasenausgang
-Bougierung;Dilatation
-Einlauf;Klysma;Analspülung;Klistier
-unentgeltliche Beförderung;Freifahrt (ugs.)
-(es heißt) Zahlemann und Söhne (für jemanden) (ugs., variabel);aufkommen (müssen für);(die) Rechnung präsentiert bekommen;(alles) bezahlen (dürfen / müssen);(eine Sache) in Ordnung bringen (ugs., fig.);(die) Zeche zahlen (müssen);zur Kasse gebeten werden
-klären;wieder einrenken;(etwas) ausbügeln (fig.);wieder geradebiegen (fig.);wiedergutmachen;(eine) Scharte (wieder) auswetzen (fig.);(eine Sache) bereinigen
-Rundbolzenkupplung;Trompetenkupplung
-Gotenbibel;Wulfilabibel
-Dualis;Zweizahl;Dual
-Neue Politische Ökonomie;Ökonomische Theorie der Politik
-Cölesyrien (veraltet);Koilesyrien
-Bordakreis;Repetitionskreis
-Positionssinn;Lagesinn
-Homagial-Eid;Lehnseid
-Lehnsgeber;Seigneur (franz.);Lehnsherr;Feudalherr
-Nachrichtenboje;Signalboje;Dekoboje
-nicht (eher) ruhen und rasten, bis;erst zufrieden sein, wenn;nicht (eher) ruhen, bis (Hauptform);keine Ruhe geben, bis;nicht ruhig schlafen, bevor ... nicht;so lange weitermachen, bis;erst (dann) wieder ruhig schlafen können, wenn
-Kraftsensor;Kraftaufnehmer
-Sanitätshilfsstelle (österr.);Verbandsplatz (veraltet);Behandlungsplatz;Feldlazarett (veraltet)
-Rettungsdienst;Rettung (österr.)
-Ärztlicher Notdienst;Allgemeinmedizinischer Bereitschaftsdienst;Ärztlicher Bereitschaftsdienst;Kassenärztlicher Notdienst;Kassenärztlicher Bereitschaftsdienst;Ärztenotdienst;Ärztefunkdienst (österr.)
-Muslimbrüder;Muslimbruderschaft
-(die) Spur wechseln;(die) Spur verlassen;nach rechts ziehen;ausscheren;nach links ziehen
-(jemandes) Lieblings...;(jemandes) Leib- und Magen...;(jemandes) Favorit;(jemandes) bevorzugte(r) (...);(jemandes) Topfavorit (ugs.);(jemandem) geht nichts über;am liebsten (haben) (variabel);(jemandes) Liebstes
-Asylkritiker;Asylgegner
-anthroposophische Medizin;anthroposophisch erweiterte Medizin
-zurücksetzen;rückwärts fahren;reversieren (österr.)
-Bodenkarte;pedologische Karte
-Katastermappe;Katasterplan
-Habsburger Unterlippe;Habsburger Lippe
-Habsburgisches Urbar;Habsburger Urbar
-Urbarium (latinisiert);Urbar
-Breisgauer Landstand;Vorderösterreichischer Landstand
-Gemeiner Pfennig;Reichspfennig
-Faltrollo;Plissee;Faltstore;Faltenstore
-Unvernunft;Vernunftwidrigkeit;Paralogie (griechisch, lat.);Widervernünftigkeit
-Aktivkohle;A-Kohle (Kurzform);medizinische Kohle
-Pflanzenkohle;Biokohle
-Radialkompressor;Zentrifugalkompressor
-Zentrifugalpumpe;Kreiselpumpe
-Pumpenturbine;Pumpturbine
-Massenkraftabscheider;Massenkraftentstauber
-(ne) Selbstgedrehte;(eine) Marke Eigenbau (ugs.)
-(ein) Traum ist ausgeträumt;(eine) Hoffnung hat sich zerschlagen
-mild;lau;lind;mäßig warm
-Pawlowscher Hund;Pawlow'scher Hund
-Gewandhaus;Tuchhalle
-ungekünstelt;natürlich;echt;unverstellt;nicht gespielt
-Glasauge;Kunstauge;Augenprothese
-Rumpf;Torso;Stamm (fachspr., medizinisch)
-Wachspapier;Ölpapier
-Schwierigkeitsgrad;Schwierigkeitsskala
-haarspalterisch;wortklauberisch;wortakrobatisch (abwertend);kasuistisch (geh.);rabulistisch (geh., abwertend);sophistisch (geh., abwertend);spitzfindig
-Chortribüne;Orgelbühne;Orgelchor;Organistrum;Chorempore
-Mundheilkunde;Stomatologie (fachspr., griechisch)
-(etwas) interessiert niemanden;niemand stört sich (an);niemand fragt (nach etwas);niemand interessiert sich (für);(etwas) kümmert niemanden;es kräht kein (Huhn und kein) Hahn nach (ugs., fig.)
-stillschweigende Voraussetzung;Präsupposition
-Westfränkisches Reich;Westfrankenreich
-Weströmisches Reich;Westrom;Westreich
-Byzanz;Oströmisches Reich;Ostrom;Byzantinisches Reich
-Ostfränkisches Reich;Ostfrankenreich
-Komsa-Kultur;Finn-Kultur
-politische Teilhabe;politische Beteiligung;politische Partizipation
-Kleinrussland;Kleine Rus
-postieren;Wache beziehen lassen;(jemanden irgendwohin) stellen;(jemanden irgendwohin) platzieren;(jemanden) hinstellen;aufstellen;Aufstellung nehmen lassen
-(sich) aufbauen;(sich) hinstellen;(sich) aufpflanzen (vor);(sich) postieren;(sich) aufstellen;(sich) (irgendwohin) stellen;(sich) platzieren;Wache beziehen;(seinen) Posten beziehen
-Pseudotetrade;Pseudodezimale
-Kapgrenzkrieg;Xhosakrieg;Grenzkrieg;Kaffernkrieg (veraltet)
-Schätze schon. (ugs.);Man tut was man kann. (ugs., Spruch);Ich glaube schon.;Wart's halt ab. (ugs.);Lass dich überraschen.
-Russische Tafel;Russische Plattform;Osteuropäische Plattform;Osteuropäische Tafel
-Zündtemperatur;Entzündungspunkt;Entzündungstemperatur;Selbstentzündungstemperatur;Zündpunkt
-wenn alles glattgeht;so Gott will;mit etwas Glück;drei Mal auf Holz geklopft (dabei auf den Tisch klopfend);wenn alles nach Plan läuft;wenn nichts dazwischenkommt;wenn alles gut geht (Hauptform)
-Unterstützung;Plädoyer (für) (fig.);(das) Eintreten (für);Befürwortung;Fürsprache
-Estrich;Unterlagsboden (schweiz.)
-niederrheinisches Deutsch;Niederrhein-Deutsch
-Berlinismus;Berolinismus
-Anschlagmechanik;Hammermechanik;Klaviermechanik
-DIN 41612;VG-Leiste (ugs.)
-Beize;Ätzflüssigkeit;Ätzmittel
-Turmlore;Oberleitungsrevisionswagen;Fahrleitungswagen;Oberleitungswagen;Turmwagen;Fahrdrahtwagen
-Weichenstellerfall;Trolley-Problem
-Ehenichtigkeitsverfahren;Eheannullierung (ugs.)
-Vorarlbergisch;Vorarlbergerisch
-Schuhschachtel-Prinzip;Scheunen-Prinzip
-Unglaubliches leisten;über sich hinauswachsen;zum Held (des Tages) werden
-Petuhschnack;Petuhtanten-Dänisch;Petuhsnak;Petuhtanten-Deutsch;Petuh
-Stoßton;Stoßlaut
-Registervergaser;Stufenvergaser
-Einfallswinkel;Inzidenzwinkel
-inzidente Prüfung;Inzidentkontrolle
-Qualität statt Quantität;Klasse statt Masse
-Verwaltungsvorschrift;Verwaltungsrichtlinie
-(mal) auf die Toilette gehen;aufs Klo gehen (ugs.);der Körperhygiene nachgehen (ugs.);scheißen gehen (derb);(sich) frisch machen (verhüllend);auf die 17 gehen (ugs., verhüllend)
-Sitzungskennung;Sitzungs-ID;Sitzungsbezeichner;Sitzungsnummer
-zustandshaltend;zustandsbehaftet
-Westneuguinea;Westpapua
-Tok Pisin;Pidgin-Englisch;Neuguinea-Pidgin (fachspr.)
-Oberleitungslastwagen;gleislose Bahn (veraltet);Oberleitungslastkraftwagen;Oberleitungs-Lkw
-Stefanitag;Stephanustag (selten);2. Weihnachtsfeiertag;Stephanstag;2. Weihnachtstag;Stephanitag
-Immediatvortragsrecht;Immediatrecht
-Prozess Generäle in Südosteuropa;Geiselmord-Prozess
-Ehrenzeichen des 9. November 1923 (offiziell);Blutorden
-Päpstliche Basilika;Papstbasilika
-Theologe;Religionswissenschaftler
-Tonkin-Zwischenfall;Tongking-Zwischenfall
-Tonkin-Resolution;Tongking-Resolution
-(ranghoher) Offizier mit reichlich Lametta (auf der Brust) (ugs.);hochdekorierter Militär;Goldfasan (Hitlerzeit) (fig.)
-Baronin;Freifrau
-Baronesse;Freiin;Freifräulein
-verzichten auf;(sich einer Sache) entschlagen (geh., veraltend)
-vergessen (seine Sorgen);(sich einer Sache) entschlagen (geh., veraltend);(sich) frei machen von
-Datenwort;Wort;Binärwort
-Wortbreite;Wortlänge
-Laienschauspieler;Laiendarsteller
-Gehörsrüge;Anhörungsrüge
-Flensburg (ugs.);Verkehrszentralregister (Amtsdeutsch);Fahreignungsregister (Amtsdeutsch);Verkehrssünderkartei (ugs., Hauptform)
-Pragma-Dialektik;Pragma-dialektische Theorie
-Bissnahme (veraltet);Kieferrelationsbestimmung
-Axiographie;Pantografie;Condylographie;Kondylografie
-physikalische Gasphasenabscheidung;physikalische Dampfphasenabscheidung
-Dünnschichttechnik;Dünnschichttechnologie
-chemische Gasphasenabscheidung;chemische Dampfphasenabscheidung
-physikalisches System;konkretes System;materielles System
-Phys.Chem. (Abkürzung);Physikochemie (selten);physikalische Chemie
-dick (ugs., fig.);reichlich bemessen;großzügig;fett (ugs., fig.);ansehnlich (Rente, Pension, Tantiemen, Diäten);üppig
-wenig (an) (Einkünften);karg;gering (Lohn);klein (Rente);schmal (Rente, Pension)
-Denkerstirn (scherzhaft);hohe Stirn;hoher Haaransatz
-Storchenbeine (ugs., Hauptform, scherzhaft);dünne Beine
-Riesenfüße;große Füße;Quadratlatsche(n) (ugs., scherzhaft)
-Machen wir.;Yes, we can. (Zitat, engl.);kein Problem (für uns);Das schaffen wir (schon).;Wär(e) doch gelacht! (Spruch);Wir schaffen das! (Zitat);lass(t) uns mal machen;(das) kriegen wir hin;kein Hindernis (für uns)
-Cebiche;Ceviche;Seviche
-Merkel-Raute;Merkelizer (selten);Merkel-Dach;Raute der Macht
-starke Währung;Hartwährung;harte Währung
-schwache Währung;weiche Währung;Weichwährung
-proportional;angemessen;adäquat;im richtigen Verhältnis (stehen);in der richtigen Proportion;im richtigen Maß;verhältnismäßig
-Islamist (veraltet);Islamwissenschaftler
-kongenitale Myasthenie;kongenitales myasthenes Syndrom
-Pseudomyasthenie;Lambert-Eaton-Rooke-Syndrom
-Höchstlohn;Maximallohn;Gehaltsobergrenze
-Berufsklassifizierung;Berufsklassifikation
-mit unterdrücktem Ekel;spitzfingrig (fig.);mit spitzen Fingern (fig.)
-Ekel erregen;Brechreiz auslösen;Übelkeit hervorrufen
-Aversion;Widerwillen;(moralische) Abscheu;(starke) Antipathie;(einen) Horror (haben vor);Widerstreben;Abneigung;(moralischer) Ekel
-Brauschenke;Brauschänke;Braukrug
-Braugerechtigkeit;Braurecht;Braugerechtsame;Grutrecht
-Erblehngericht;Lehngericht;Erbgericht
-Grut;Gruit
-Bierboykott;Bierfehde;Bierkrieg;Bierkrawall;Bierstreit;Bierstreik
-letzte Kaltzeit;letzte Eiszeit
-(sich) bemühen (Arbeitszeugnis);(sich) redlich mühen (geh.);(sich) alle Mühe geben
-Heroldsstab;Hermesstab;Caduceus (lat.);Merkurstab
-ferngesteuert;telematisch (fachspr., griechisch)
-Prügel beziehen;verprügelt werden;(et)was auf die Schnauze bekommen (ugs.);die Hucke vollkriegen (ugs.);aufs Maul kriegen (derb);Prügel einstecken;die Hucke vollbekommen (ugs.)
-Hartkeks;Militärbiskuit (schweiz.);Panzerplatte (ugs.)
-feine Backware;Feinbackware;Feingebäck
-unzweifelhaft;gesichert (Erkenntnisse);sicher;verlässlich;aus sicherer Quelle stammend;zweifelsfrei;belastbar (Zahlen)
-gerichtsfest (sein);(einer) gerichtlichen Überprüfung standhalten (können)
-nicht von der Hand zu weisen;ernst zu nehmen;seriös
-(sich) verdient machen (um);Großes leisten (bei / mit);(sich) (große) Verdienste erwerben (bei / mit)
-Fußsoldat (fig.);kleiner Fisch (fig.);keine große Nummer (fig.);Zuträger (fig.)
-(etwas) ist im Busch (fig.);(etwas) steckt dahinter
-(etwas) ist im Busch (fig.);(etwas) liegt in der Luft (fig.);etwas kommt auf jemanden zu (fig.)
-es rumort;es gibt Unruhe;es brodelt;es gärt
-schwere Zeiten vor sich haben;es kriselt (bei);schweren Zeiten entgegensehen
-(jemandem) steht eine Menge Ärger bevor;(die) Zeichen stehen auf Sturm (Redensart, fig.);(es) raucht im Karton (ugs., Spruch, fig.);(jemandem) steht Ärger ins Haus;Panhas am Schwenkmast (ugs., Spruch, ruhrdt.);(es) wird eng (für);(etwas) sieht nach einer Menge Ärger aus (ugs.)
-(etwas) wird nicht einfach;(etwas) wird schwierig;keine leichte Aufgabe;(etwas) könnte eng werden (ugs., Spruch);(etwas wird) kein Spaziergang (ugs.)
-sei vorsichtig!;pass auf dich auf!
-ungute Ahnungen haben;böse Vorahnungen haben;die schlimmsten Befürchtungen haben;das Schlimmste befürchten;(jemandem) schwant nichts Gutes;nicht gut aussehen;Schreckliches ahnen;nichts Gutes ahnen
-geordnetes Paar;2-Tupel
-Dreier-Tupel;Tripel;3-Tupel
-Quadrupel;4-Tupel
-Quintupel;5-Tupel
-leeres Tupel;0-Tupel
-Hexatupel;6-Tupel
-ostgermanische Sprache;Oder-Weichsel-Germanische Sprache;Vandilische Sprache;Illevionische Sprache
-Erster Karnatischer Krieg;Erster Karnataka-Krieg
-Karnataka-Krieg;Karnatischer Krieg
-Zweiter Karnatischer Krieg;Zweiter Karnataka-Krieg
-Schuldrecht;Obligationenrecht (liechtensteinisch, schweiz.)
-fakultativer Parasit;Gelegenheitsparasit
-Brutparasit;Brutschmarotzer
-Rosskastanienminiermotte;Balkan-Miniermotte
-Blatt-Tütenmotte;Miniermotte
-gleichwarm;homoiotherm;homöotherm
-gleichwarmes Tier;endothermes Tier;Warmblüter (veraltet);homoiothermes Tier
-Grundumsatz;basale Stoffwechselrate
-elektronisches Entgeltnachweis-Verfahren;ELENA-Verfahren;elektronischer Einkommensnachweis
-Errare humanum est. (geh., bildungssprachlich, lat.);Irren ist menschlich. (sprichwörtlich);Es irrt der Mensch, solang er lebt. (ugs., sprichwörtlich);Es irrt der Mensch, solang er strebt. (geh., Sprichwort)
-Heimatmusik;Volksmusik
-Musik der Romantik;Romantische Musik;Musik des 19. Jahrhunderts;Romantik (Musik)
-musikalische Epoche;Musikepoche
-nichtwirtschaftlicher Verein;Idealverein
-Handgriff;Hilfeleistung;Handschlag (fig.);Handreichung (geh.)
-Abfindung;goldener Handschlag (fig.);Abfindungszahlung;Abfindungsleistung (fachspr.)
-per Handschlag;mit einem Händedruck
-Freilager;Freizone
-Kleines Walsertal;Kleinwalsertal
-Neum-Korridor;Korridor von Neum
-am Ende sein;erledigt sein (ugs.);am Boden liegen (fig.);ausgespielt haben (fig.)
-(bei jemandem) ausgespielt haben (fig.);(bei jemandem) verschissen haben (derb);(bei jemandem) abgemeldet sein (ugs., fig.);(mit jemandem) fertig sein;(bei jemandem) unten durch sein (ugs., fig.);es sich mit jemandem verscherzt haben (variabel)
-zu berichten wissen (geh.);schildern;wiedergeben;vom Stapel lassen (ugs., fig., salopp);zum Besten geben;erzählen;(einen) raushauen (derb, salopp)
-schildern;ausführen;darlegen;beschreiben;erläutern;dartun (geh.);darstellen
-Speckknödel;Speckkloß
-Grammelknödel;Österreichischer Speckknödel
-Lungensuppe;Saures Lüngerl;Salonbeuschel;Lungenhaschee;Beuscherl
-antipyretisch;fiebersenkend
-Wiener Jugendstil;Secessionsstil
-Burgenland;Deutsch-Westungarn (veraltet)
-Wilsonsches System;Selbstbestimmungsrecht der Völker
-Burgenlandungar;Burgenlandmagyare
-russische Sprache;Russisch (Hauptform);Reußisch (veraltet);Großrussisch (veraltet)
-Beanstandung;Bemängelung;Kritik
-Landvolk;Christlich-Nationale Bauern- und Landvolkpartei
-Marker;Markierstift (ugs.);Leuchtstift (ugs.);Textmarker
-ich schwöre (es) (Hauptform);bei allem, was mir heilig ist;ich schwöre (es) auf (...);so wahr mir Gott helfe;ich schwöre dir nackend in die Hand (dass) (ugs., ruhrdt.);bei meiner Ehre;bei meiner Seligkeit;beim Barte des Propheten;beim Leben meine(s) (...);auf Ehre und Gewissen (veraltend)
-(ein) Darlehen gewähren;finanziell unter die Arme greifen;(jemandem) Geld leihen;(einen) Kredit geben
-Jammer hier nicht rum! (ugs.);Brauchst du ein Taschentuch? (ugs., ironisch);Hör(e) ich da ein leises "Mama"? (ugs., Spruch, ironisch, variabel);Heul doch! (ugs., spöttisch);(Du bist vielleicht ein) Waschlappen! (variabel);Willst du auf den Arm? (ugs., ironisch)
-Österreichischer Feldzug gegen das Herzogtum Warschau;Weichselfeldzug
-Tuszien;Tuscien
-Schlacht bei Saxa Rubra;Schlacht an der Milvischen Brücke
-sich die Arbeit machen (ugs.);sich die Mühe machen
-Ektomie (fachspr., griechisch);Herausschneiden;Entfernung;Totalexstirpation (fachspr.);Exstirpation (fachspr., lat.);Exzision (fachspr., lat.)
-durchsichtig (fig.);fadenscheinig (fig.);(leicht) durchschaubar;Das merkt doch ein Blinder (mit dem Krückstock). (ugs., Redensart, fig.);schlecht kaschiert
-sedativ wirkend;sedierend;beruhigend;dämpfend
-hypnotisch (wirkend);(eine) Trance auslösend
-(jemandem) Gesellschaft leisten;in jemandes Gesellschaft sein;(sich) in jemandes Gesellschaft aufhalten;zusammen sein (mit) (ugs.);abhängen (mit jemandem) (ugs.);rumhängen (mit jemandem) (ugs.)
-aus dem Haus gehen;(sich) in der Öffentlichkeit zeigen (mediensprachlich);(seine) Wohnung verlassen;außer Haus gehen;vor die Tür gehen;ausgehen;unter Menschen gehen;rausgehen (ugs., regional)
-Tscherwener Burgenland;Rotburgenland
-Tarnopoler Kreis;Tarnopoler Landschaft
-Erfüllungsort;Leistungsort
-(die) Hosenbeine sind zu kurz;Hochwasser tragen (ugs., fig.);Hochwasser haben (Hose) (ugs., fig.);Borbecker Halblang (tragen) (ugs., ruhrdt.)
-warten wir's ab;wir werden (ja) sehen! (ugs.);Gut Ding will Weile haben. (Sprichwort);Rom wurde nicht an einem Tag erbaut. (sprichwörtlich);man wird sehen (ugs.);(only) time will tell (Spruch, engl.);(etwas) wird sich zeigen;Kommt Zeit, kommt Rat. (Sprichwort);schau'n mer mal! (ugs.);Alles braucht seine Zeit (wenn es gelingen soll).
-(sich) nicht überschlagen (ugs.);es ruhig angehen lassen (ugs., Hauptform);kleinschrittig vorgehen;eine ruhige Kugel schieben (ugs., Redensart);(sich) Zeit nehmen;(sich) Zeit lassen (Hauptform);keine Eile haben (mit)
-(seine) Pflichten vernachlässigen;(sich) um nichts kümmern (Hauptform);den lieben Gott einen guten Mann sein lassen (ugs., Redensart);die Dinge schleifen lassen (fig.)
-eine ruhige Kugel schieben (ugs., Redensart);wenig zu tun haben (ugs.);(es) ist wenig los (auf der Arbeit) (ugs.);(es) ist wenig zu tun (bei) (ugs.);(sich) einen lauen Lenz machen (ugs., fig.)
-streicheln;Streicheleinheiten geben;zärtlich berühren;sanft streichen über
-(seine) Streicheleinheiten fordern;(seine) Streicheleinheiten haben wollen;gestreichelt werden wollen
-(seine) Streicheleinheiten bekommen;gestreichelt werden
-(jemanden) aufgabeln (ugs., fig.);(jemanden irgendwo) her haben (ugs., variabel);sich jemanden angeln (ugs., fig.);(jemanden) einfangen (fig.);(jemanden) kriegen;(jemanden) auflesen (ugs., fig.);(sich jemanden) greifen (ugs., fig.);(jemanden) auftreiben (ugs., salopp);(jemanden) abkriegen (ugs., negativ);(jemanden) finden;(sich jemanden) an Land ziehen (ugs., fig.);(jemanden) auffischen (ugs., fig.);(jemanden) bekommen
-(jemandem) schöne Augen machen;(jemandem) Avancen machen (geh., veraltend);(mit jemandem) liebäugeln;Annäherungsversuche machen (bei)
-(jemanden) anplingen;(jemanden) anzwinkern;(jemandem) einen einladenden Blick zuwerfen (variabel);(jemandem) schöne Augen machen;(jemanden) mit großen Kulleraugen anschauen (ugs.);(mit jemandem) liebäugeln
-anzubandeln versuchen;(jemandem) den Hof machen;(jemanden) anbaggern (ugs.);(jemanden) angraben (ugs.);anzubändeln versuchen;(jemanden) anmachen;herumbalzen (vor jemandem) (ugs.);(jemanden) begockeln (ugs.);(jemanden) anbraten (ugs., österr.);(sich) heranmachen (an);(jemanden) bebalzen (ugs.);(jemanden) anflirten (ugs.);(jemanden) beflirten
-schneidende Zunft (ugs.);Chirurgie (griechisch)
-Gammler;Herumtreiber;Rumtreiber;Streuner
-Mehrsträngigkeit;Mehrfädigkeit
-(eine) Meinung nicht teilen;(etwas) anders sehen;auf einem anderen Standpunkt stehen;(eine) andere Auffassung vertreten;anderer Meinung sein
-mir scheint;ich finde;wohl;werden + Infinitiv ('Futur');ich glaube;ich habe das Gefühl;ich denke;ich habe den Eindruck
-an der Zeit (sein, dass);sollte (jetzt / in allernächster Zeit)
-(die) Vorschrift will (variabel);(die) Vorschrift (sein);so will es die Vorschrift (variabel);vorgeschrieben (sein)
-Schmelzsalzbatterie;Hochtemperaturbatterie;Thermalbatterie
-Sekundärzelle;Sekundärelement
-Primärelement;Primärzelle
-Zinkchlorid-Zelle;Zinkchlorid-Batterie (ugs.)
-Silberoxid-Zink-Batterie;Silberoxid-Zelle
-Zeltlampenbatterie;Blockbatterie;Laternenbatterie (Hauptform);4R25;430
-Alkaline;Zink-Manganoxid-Zelle;Alkali-Mangan-Batterie (ugs.);Alkali-Mangan-Zelle
-in Verbindung stehen (mit);(mit etwas) zu schaffen haben
-Komturei;Kommende
-Velotaxi (schweiz.);Fahrradrikscha;Velorikscha (schweiz.);Fahrradtaxi
-(wieder) da (sein);(wieder) vorrätig;(wieder) da haben;(wieder) reinbekommen (ugs.);(wieder) reinkriegen (ugs.)
-Haselnussstrauch;Haselstrauch;Haselbusch;Gemeine Hasel
-Adelsarchiv;Herrschaftsarchiv;Gutsarchiv
-Repertorium;Findbuch
-über den Tellerrand hinausschauen (fig., variabel);(seine) Scheuklappen ablegen (fig.)
-Balkankiefer;Mazedonische Kiefer;Pinus peuce (fachspr., botanisch);Rumelische Kiefer;Mazedonien-Kiefer
-UTMREF (Abkürzung);Meldegitter im UTM-Abbildungssystem;UTM-Referenzsystem
-Planzeiger;Netzteiler (ugs.)
-Vertrag von Berlin;Allianzvertrag der drei Schwarzen Adler
-Rollregal;Schieberegal;Hebelschubanlage;Fahrregal;Verschieberegal
-auf zwei Wegen;auf zwei Weisen;auf zwei Arten;zweigleisig;auf zwei Ebenen
-Transformatorenstation;Umspannstation;Ortsnetzstation;Trafostation (Kurzform);Netzstation
-Änderungsschneider;Flickschneider (veraltet)
-für jemanden kein Alter (sein) (ugs.);(für jemanden) nicht so alt (ugs.);nicht wirklich alt (ugs.);vergleichsweise jung
-selbstverständlich (sein);Alltag sein;normal (sein);jeden Tag vorkommen;zur Normalität gehören
-nachfragen;aufmerksam machen;auslösen;einen Anstoß geben;triggern (salopp);einen Impuls geben;anfragen;antriggern (salopp);anregen
-mit gezücktem (...);(...) im Anschlag (fig.);(mit ...) in der Hand
-mit vorgehaltener Waffe (variabel);mit gezückter Waffe;(mit der Waffe) in Vorhalte;(mit einer Waffe) im Anschlag (variabel)
-eine scharfe Klinge führen (geh., fig.);in scharfen Worten verurteilen;scharf verurteilen;heftig kritisieren
-schlechter Pilot;Bruchpilot (abwertend, auch figurativ)
-Bruchlandung;unsanfte Landung
-United States Permanent Resident Card (engl.);Greencard (ugs., engl.)
-Geißler;Flagellant;Auspeitscher
-Netzpapier;Funktionspapier;mathematisches Papier
-Logarithmenpapier;logarithmisches Papier
-einfachlogarithmisches Papier;halblogarithmisches Papier
-Isometriepapier;Dreiecknetzpapier
-isometrische Axonometrie;Isometrie
-Kavalierprojektion;Kavalierperspektive
-Wahrscheinlichkeitsnetz;Wahrscheinlichkeitspapier
-Verteilung (Kurzform);Wahrscheinlichkeitsverteilung;W-Verteilung (Kurzform);Wahrscheinlichkeitsmaß;W-Maß (Kurzform)
-Stauropegia;Stauropegie
-Floridakrieg;Seminolenkrieg
-Pinckney-Vertrag;Vertrag von San Lorenzo;Vertrag von Madrid
-Vorwärtsstrategie;Vorneverteidigung;Vorwärtsverteidigung;Vorgeschobene Verteidigung
-Luftherrschaft;totale Luftüberlegenheit
-Gebäude;bauliche Anlage;Bauwerk
-Hughes-Syndrom;Hughes-Stovin-Syndrom
-Der Teufel steckt im Detail. (sprichwörtlich);Es kommt auf (die) Kleinigkeiten an.
-W-Wort;Fragewort (ugs.)
-Interrogativartikel (fachspr.);Frageartikel (fachspr.);Interrogativbegleiter (fachspr.)
-(jemandem) zur Seite stehen (fig.);(jemandem) Schützenhilfe leisten (fig.);(jemanden) in Schutz nehmen;(jemandem) zur Seite springen (fig.);(jemandem) zu Hilfe kommen;(verbal / argumentativ) unterstützen;(jemandem) beispringen
-(jemandes) Mentor sein;(jemanden) in Obhut nehmen;(sich) kümmern um (jemanden) (ugs.);(jemanden) unter seine Fittiche nehmen;(jemanden) an die Hand nehmen (fig.);aufpassen auf (jemanden) (ugs., variabel)
-durchregieren;entschiedene Maßnahmen ergreifen;ohne Koalitionspartner regieren (können);entschlossen regieren
-Abszedierung;Abszessbildung
-Physiologie (fachspr., griechisch);Körperfunktionslehre
-Hirnhäute (Plural);Meningen (fachspr., Plural)
-Nähzubehör;Kurzwaren
-sticheln;schneidern;nähen
-Test für Medizinische Studiengänge;Medizinertest (ugs.)
-scharf (nachdenken);(sich) intensiv (befassen mit);verschärft (nachdenken) (ugs., salopp);(sich) gründlich (überlegen);(sich gedanklich) eingehend (beschäftigen mit);viel (nachdenken) (Hauptform)
-Pantoffeln (Plural);Finken (ugs., Plural, schweiz.);Schlappen (ugs., Plural);Schluffen (ugs., Plural, rheinisch);Puschen (ugs., Plural);Schlapfen (ugs., bayr., österr.);Hausschuhe (Plural);Schlurren (ugs., Plural, norddeutsch)
-Gebietsreform;Kommunale Neugliederung
-Kinderneurologie;Neuropädiatrie
-Hydratation;Hydration
-Hydrat-Sphäre;Hydrathülle
-Hydratwasser;Kristallwasser
-Solvatisierung;Solvatation
-Hydrationsenthalpie;Hydrationsenergie;Hydratationsenergie
-Schwarzgeldaffäre;CDU-Spendenaffäre
-vergleichendes Recht;vergleichende Rechtswissenschaft;komparative Rechtswissenschaft;Rechtsvergleichung
-Balgwerk;Gebläse;Windwerk;Windanlage
-Orgel;Pfeifenorgel
-mechanischer Musikautomat;mechanisches Musikinstrument (ugs.)
-Ort eines Verbrechens;Tatort
-gemischtes Springen (veraltet);Gerätespringen
-Umdrehungen (ugs., fig.);Prozent (Alkoholgehalt)
-Wildpinkler;Eckenpinkler
-Zone mit beschränktem Verkehr;Zone mit Verkehrsbeschränkung;verkehrsberuhigte Zone
-nicht mehr grün hinter den Ohren (fig.);nicht erst seit gestern auf der Welt;(seine) Sturm- und Drangjahre hinter sich haben (fig., variabel);(sich) die Hörner abgestoßen haben (ugs., fig.);(schon) etwas älter;(auch) keine achtzehn mehr
-jünger wirken (als er/sie ist);(jemandem) ist sein Alter nicht anzusehen;sich gut gehalten haben;(jemandem) sein Alter nicht ansehen
-(ein bestimmtes Alter) hinter sich haben;(aus etwas) herausgewachsen (fig.);(einem Alter / Lebensabschnitt) entwachsen;kein(e) (...) mehr
-bei Jahren (sein) (geh., veraltet);(richtig) alt;betagt;bejahrt;in Ehren ergraut;(ein Mann / eine Frau) von Jahren (geh.)
-Schulverweigerer;Schulschwänzer
-(seinen) zweiten Frühling erleben (Hauptform);(sich) wieder wie zwanzig fühlen;(den) zweiten Frühling haben (variabel);spätverliebt (sein)
-grauhaarig;grau geworden;ergraut;grauköpfig;graue Haare haben;alt und grau (ugs.);grau
-angegraut;grau meliert;anfangen, grau zu werden (Haare);graumeliert;einzelne graue Haare haben;(langsam) graue Haare bekommen;von grauen Strähnen durchzogen;von Silberfäden durchzogen;leicht ergraut;von grauen Fäden durchzogen
-Behaarung;Haare
-in Würde ergraut;in Ehren ergraut
-gestutzter Schnurrbart;Menjoubärtchen (Hauptform);Menjoubart
-Kinnbart;Spitzbart;Ziegenbart (abwertend)
-Seemannsbart (ugs.);Schifferkrause
-(mit) Dreitagebart;unrasiert
-mit hellen Haaren;hellhaarig;von heller Haarfarbe
-mit dunkler Haarfarbe;mit dunklen Haaren;von dunkler Haarfarbe;dunkelhaarig
-diskret;digital
-Gäste;Publikum;Besucher
-für etwas kämpfen;(die) Welt retten (wollen) (fig., übertreibend);(sich) engagieren;(sich) für etwas einsetzen
-konsumgeil (ugs.);von Konsumdenken bestimmt (variabel);konsumorientiert;nach Materiellem streben(d);nach materiellen Werten streben(d);konsumistisch (geh.);materialistisch
-unglaubliches Glück (gehabt) haben;(einen) Schutzengel (gehabt) haben (fig.);mehr Glück als Verstand (gehabt) haben;wahnsinniges Glück (gehabt) haben (ugs.)
-Wer hat, der hat. (sprichwörtlich);Über Geld spricht man nicht, Geld hat man. (Spruch);Über Geld spricht man nicht, man hat es. (Spruch)
-(nicht) wieder abgeben;nicht loslassen;Was man hat, das hat man. (sprichwörtlich);nicht herausrücken;(sich) nicht (wieder) trennen (von);festhalten an;(nicht) wieder aus der Hand geben
-bevor alles zu spät ist (ugs., fig.);solang(e) noch das Lämplein glüht (fig.);bevor man tot ist;solang(e) man lebt;solang(e) es noch geht;bevor der Sargdeckel zuklappt
-Doktor der Rechtswissenschaften;Doktor der Rechte;Dr. iur. (Abkürzung);Dr. jur. (Abkürzung);Doktor des Rechts;Doktor der Rechtswissenschaft
-in der Wahl seiner Mittel nicht zimperlich (sein);keine Skrupel kennen;keine Verwandten (mehr) kennen (ugs., fig.);(jemandem ist) nichts heilig (ugs., fig.);(sich) auch von (...) nicht aufhalten lassen;(sich) von niemandem aufhalten lassen;bis zu (...) gehen (um zu);(sich) von nichts aufhalten lassen;auch vor (...) nicht zurückschrecken;(jemandem ist) jedes Mittel recht (Hauptform);vor nichts haltmachen;nichts kennen (ugs., fig., variabel);vor nichts zurückschrecken;(auch) nicht Halt machen vor
-das große Los gezogen haben (fig.);unverschämtes Glück haben;so ein Glück möchte ich auch mal haben (ugs.);heute ist dein Glückstag (Spruch)
-hedonistisch;materialistisch;diesseitsorientiert;irdischen Freuden zugetan (variabel)
-alles mitnehmen (ugs.);alles ausnutzen;nicht(s) umkommen lassen
-Blitzsynchronisation;Synchronblitz
-Diskussionsteilnehmer;Kontrahent
-Multiplikator;Verstärker;Verbreiter;Vervielfältiger
-zytostatisch;vermehrungshemmend;cytostatisch
-Reichsmatrikel;Heeresmatrikel
-bei (jemandem);... einer Person (Genitiv);auf der Seite von;auf Seiten;auf der Seite des ( / der ...);aufseiten
-Perlottierung;Eindellung
-(ganz) akzeptabel sein;gehen (es geht / es ging) (ugs.);nicht schlecht (sein) (ugs.);(ganz) okay sein (ugs.);einigermaßen sein (ugs.);nicht zu verachten sein (ugs.)
-(jemandem) Sorgen machen (Gesundheit);(jemandem) Probleme machen (Gesundheit) (ugs.);Beschwerden haben (Gesundheit);Probleme haben (mit) (ugs.);Last haben (mit) (Gesundheit) (ugs.);Molesten haben (mit) (ugs., regional)
-nicht ausgefüllt;blanko (Formular)
-Blanko...;nicht ausgefüllt (aber unterschrieben);blanko
-ungestört sein;unter sich sein (Hauptform);niemand anderes ist dabei
-Bodenschwellen;Temposchwellen;Geschwindigkeitshügel;Moabiter Kissen (regional);schlafender Polizist;Kreissegmentschwellen;Delfter Hügel (regional);Delfter Schwellen (regional);Tempohemmschwellen;Berliner Kissen (regional);Krefelder Kissen (regional);Kölner Teller (regional);Bremsschwellen;Fahrbahnschwellen
-Fahrgassenversatz;Versatz
-Mittelinsel;Fahrbahnteiler;Verkehrsinsel (Hauptform)
-Vorsortierstreifen;Sortierbereich;Vorsortierbereich
-Abbiegefahrstreifen;Abbiegespur (ugs.)
-Straßenübergang;Querungsanlage;Sprunginsel;Querungshilfe
-Radwegfurt;Radfahrerfurt;Radwegefurt;Radfahrerüberfahrt (österr.)
-schön (ermahnend) (ugs.);ja (lange Aussprache) (ugs.);gefälligst (ärgerlich) (ugs.);bloß (ärgerlich oder warnend) (ugs., regional);wacker (ugs., ruhrdt.)
-fiskale Klippe;fiskalische Klippe;Fiskalklippe;Haushaltsklippe
-Wassermeerrettich;Japanischer Meerrettich;Wasabi
-irgendwelche Neuigkeiten?;was gibt's Neues?
-absortieren;durchsortieren;sortieren (Hauptform);wegsortieren;aussortieren;einsortieren
-Förderturm;Fördergerüst
-Kleinkindpädagogik;Frühpädagogik;Elementarpädagogik;Vorschulpädagogik
-(das) ist (doch) eine ganz einfache Geschichte! (ugs.);klare Kiste: ... (ugs.);Was ist daran (so) schwer zu verstehen!? (ugs.)
-(sich) in der Defensive fühlen;(sich) in der Defensive sehen;beleidigt reagieren;(sich) angegriffen fühlen;dünnhäutig reagieren;(sich) auf den Schlips getreten fühlen (fig.);(etwas) als persönlichen Angriff auffassen;(etwas) zu persönlich nehmen
-(sich) Angriffen ausgesetzt sehen;angegriffen werden;in die Defensive geraten (auch figurativ);unter Beschuss stehen
-Hoßbach-Protokoll;Hoßbach-Niederschrift
-Präfaschismus;Protofaschismus
-Mexikanische Revolution;Mexikanischer Bürgerkrieg
-(jemandes) Rettung;(jemanden) retten;(jemandes) letzte Rettung
-Gelehrsamkeit;Kompetenz
-Warnschuss (fig.);(die) Quittung (für) (fig.);Wink mit dem Zaunpfahl (fig.);Denkzettel
-hellhörig werden;aufmerksam werden (auf);(etwas) bemerken;stutzen;(jemanden) aufhorchen lassen;stutzig werden;(jemanden) stutzen lassen;(jemandem) auffallen
-stutzen;(etwas) merkwürdig finden (variabel);(jemandem) komisch vorkommen (ugs., variabel);(sich) wundern über
-zufällig entdecken;stolpern über (fig.);stoßen auf
-Großveranstaltung;Massenveranstaltung;Großereignis;Massenevent
-Nicht-Zugehöriger;Außenstehender;Uneingeweihter;Fremder;Externer;der etwas nicht kennt (ugs.)
-nicht zugehörig;unbeteiligt;außenstehend;nicht eingeweiht;extern;nicht einbezogen
-(da)gegenrechnen;verrechnen mit;aufrechnen gegen
-schreckgeweitet (Augen);vor Schreck weit auf(gerissen) (ugs.)
-(die) Parteimitglieder;Parteibasis;(die) Basis;Parteivolk
-Bundesgenosse;Verbündeter;Partner;Kooperierender;Bündnispartner;Kooperationspartner
-erfolglos zu behandeln versuchen;laborieren an
-Machtenthebung;Sturz (eines Vorsitzenden);Putsch (gegen)
-(seinen Ausführungen etwas) voranstellen;einleitend sagen;vorausschicken;(eine) einführende Bemerkung (machen);zunächst sagen (ugs.);vorab sagen
-Südasiatische Wirtschaftsgemeinschaft;Südasiatische Vereinigung für regionale Kooperation
-Transatlantische Handels- und Investitionspartnerschaft (offiziell);Transatlantisches Freihandelsabkommen
-mit jedem in die Kiste steigen (variabel);es mit jedem treiben;promiskuitiv (leben);jeden an sich ranlassen;leicht zu haben (sein);(sich) von jedem flachlegen lassen;mit jedem ins Bett springen;(sich) nicht lange bitten lassen;nicht wählerisch sein;es mit jedem machen
-zurechnungsfähig;schuldfähig
-Schuldfähigkeit;Deliktfähigkeit
-Zurechnungsfähigkeit;Schuldfähigkeit
-gewogener Durchschnitt;gewichtetes arithmetisches Mittel
-Person mit querulatorischer Persönlichkeitsstörung;Querulant (psych.);Person mit querulantischer Persönlichkeitsstruktur;querulantisch veranlagte Person
-Vielzahl an Verfahren (juristisch, variabel);Prozessflut;Klagewelle
-Gerichtstermin (ugs.);Sitzung;Gerichtsverhandlung (Hauptform);Gerichtssitzung;Verhandlungstermin;Verhandlung
-heimatlos (fig.);nirgendwo zu Hause;ohne ein (wirkliches) Zuhause;unbehaust (geh., fig.);ungeborgen (geh., selten);nirgends zu Hause
-(von etwas) runtergehen (für) (ugs., salopp);subtrahiert werden;weggehen (für) (ugs.);(von etwas) abgehen (für);abgezogen werden (Hauptform)
-Einsteiger;neu im Beruf;Berufsanfänger;frisch von der Uni;Berufseinsteiger
-(Fragewort) (denn) sonst;(Fragewort) anders
-riesengroß (Person) (Hauptform);übergroß;überlebensgroß;riesenhaft;hünenhaft;in XXL (ugs., scherzhaft)
-zentral sein;am wichtigsten ist;(den) Schwerpunkt bilden;im Mittelpunkt stehen;es geht vor allem um;im Fokus stehen (fig.);das Wichtigste sein
-(die meiste) Aufmerksamkeit bekommen;im Mittelpunkt stehen (Person);alles dreht sich um (jemanden) (ugs.)
-im Mittelpunkt des Geschehens (stehen);den Mittelpunkt des Geschehens bilden;alle Fäden laufen zusammen (bei)
-im Mittelpunkt (der Aufmerksamkeit) stehen;(ein) Hingucker sein;den Mittelpunkt der Aufmerksamkeit bilden;alle Blicke auf sich ziehen;alle Blicke richte(te)n sich auf;(der) Star des Abends sein (variabel)
-Böckenförde-Theorem;Böckenförde-Doktrin;Böckenförde-Dilemma;Böckenförde-Diktum
-hört, hört!;das hast *du* jetzt gesagt (ugs.);jetzt kommt's raus (ugs.)
-auf dem Laufenden gehalten werden;fortlaufend unterrichtet werden;auf dem Laufenden sein (über);fortlaufend informiert werden
-denk an meine Worte! (Spruch);lass dir das gesagt sein (Spruch);vergiss das nie!;du wirst noch an mich denken (Spruch)
-(jemanden als / mit etwas) titulieren;(jemanden etwas) heißen (geh., veraltet);deklarieren (zu / als);nennen;(jemanden als etwas) apostrophieren (geh.);bezeichnen als (Hauptform)
-(jemandem etwas) sagen;(jemandem etwas) mitteilen;(jemanden von etwas) in Kenntnis setzen;(jemandem etwas) übermitteln;(jemanden über etwas) unterrichten;(jemandem etwas) zur Kenntnis bringen (geh.);(jemanden über etwas) informieren
-groß ankündigen (ugs., Hauptform);mit großem Trara verkünden (ugs.);groß herumtönen (ugs.);ausposaunen (ugs., fig.);herausposaunen (ugs., fig.);rausposaunen (ugs., fig.);hinausposaunen (ugs., fig.)
-ankündigen;avisieren (geh.);ankünden;ansagen
-(sich etwas) einbilden;Gespenster sehen (ugs.);an Wahnvorstellungen leiden (medizinisch);spinnen (ugs.)
-Windkühle;Windchill (engl.);Windfrösteln
-Diskos von Festos;Diskos von Phaistos;Diskos von Phaestus
-historischer Abriss;Rückschau;Geschichtsdarstellung
-Tunnelbohrmaschine;Tunnelvortriebsmaschine
-in meiner (grenzenlosen) Naivität (variabel);so naiv sein, zu (variabel);naiv genug sein, um zu;in meinem jugendlichen Leichtsinn (ugs., scherzhaft);naiv, wie ich bin (variabel);in seiner Schlichtheit (geh.)
-Aufgewecktheit;Findigkeit;Pfiffigkeit;Cleverness (engl.);geistige Beweglichkeit;Schlauheit;Gewitztheit
-Arbeitstugend;Arbeitsmoral;Arbeitsethik
-Mähnenhirsch;Rusa
-Berührungsangst;Distanziertheit
-bedudelt werden (ugs.);berieselt werden;(sich) bedudeln lassen (ugs.);(sich) berieseln lassen (Radio) (fig.)
-(sich) im Schneckentempo vorwärtsbewegen;kriechen;langsam vorankommen;schleichen;langsam fahren (Hauptform);im Kriechtempo
-Normalflora;Kommensale;Kolonisationsflora;Standortflora;Residente Keime
-Gazetteer;Ortslexikon;Ortsverzeichnis
-schon dutzende Male (erlebt) (variabel);aus tausend Filmen (bekannt) (variabel);jeder kennt das;(der) Klassiker
-Zweite Republik;Tschecho-Slowakei;Tschecho-Slowakische Republik
-Sudetenkrise;sudetendeutsche Krise
-Sudetengebiet;Sudetenland
-Wiener Diktat;Erster Wiener Schiedsspruch
-Weiße Armee;Weiße Garde
-Oktoberrevolution;Große Sozialistische Oktoberrevolution
-Riemengetriebe;Hülltrieb;Riementrieb;Riemenantrieb
-Friktionsgetriebe;Planscheiben-Reibradgetriebe
-Wegbereiter;Vorgänger;geistiger Vater (fig.);Vorläufer
-dieserhalb und desterwegen (ugs., scherzhaft);von da (ugs.);von dem her (ugs., floskelhaft);darob (geh., scherzhaft, veraltet);deshalb;darum;von daher (ugs.);wegen dem (ugs.);deswegen;daher;aus diesem Grund (Hauptform);aufgrund dessen
-fang endlich an!;heute noch? (ugs., ironisch);ich hab nicht ewig Zeit (ugs., Spruch);wird das heute noch was? (ugs.);mach endlich! (ugs.);ich hab nicht den ganzen Tag Zeit (ugs., Spruch)
-noch einmal (tun);nach...
-hashen;die Prüfsumme berechnen;den Hashwert (einer Datei, eines Textes) berechnen
-Mitralklappe;Bikuspidalklappe
-AV-Klappe;Atrioventrikularklappe;Segelklappe
-Herzklappenfehler;Klappenvitium
-rheumatisches Fieber;Streptokokkenrheumatismus
-Mitralinsuffizienz;Mitralklappeninsuffizienz
-Körperzeitvolumen;Herzminutenvolumen;Herzzeitvolumen
-babylonisches Wurzelziehen;Heron-Verfahren;Heronsche Näherungsverfahren
-neurasthenisch;überfordert;nervenschwach
-berichten von (Text);vermelden;berichtet werden;erzählt werden;erzählen von;(es) ist die Rede von;künden von (geh.)
-Grundstück;Gelände;(die) Flur;Fläche;Stück Land
-Revier (Tiere, Jagd, Forst, Polizei);Hoheitsgebiet;Zuständigkeitsbereich (z.B. Polizei);Einflussbereich;Machtbereich;Herrschaftsgebiet;Territorium
-kannst du nicht aufpassen?;können Sie nicht aufpassen?;Hast du (denn) keine Augen im Kopf!?;pass auf, wohin du läufst!;Augen auf im Straßenverkehr! (ugs., Spruch, veraltend);pass auf, wo du hintrittst!;mach (doch) die Augen auf!;wo bist du nur (immer) mit deinen Gedanken! (ugs., floskelhaft);wohl Tomaten auf den Augen (, was)? (Spruch, fig.)
-Bahre;Totenbahre
-Baartuch;Bahrtuch;Sargdecke;Sargtuch
-(jemanden) große Überwindung kosten (etwas zu tun);(sich) überwinden (müssen);(sich) zwingen (müssen);(jemanden) hart ankommen (geh., variabel, veraltend)
-(sich) über Wasser halten (können) (fig.);(etwas) reicht so eben zum Leben;so gerade zurechtkommen
-sehr wenige (Hauptform);an den Fingern einer Hand abzählen (können) (variabel);Einzelfälle (sein) (variabel)
-je nach (der) Situation;Fall für Fall (einzeln);im Einzelfall;von Fall zu Fall (unterschiedlich);jeden Fall einzeln;jeden (Fall) für sich
-ohne Spannung;schlaff;atonisch;ohne Tonus;spannungslos
-Frittenware;Frittenporzellan
-Remuneration;Remunerierung
-(eine) feste Größe (darstellen) (floskelhaft, variabel);(sich) etabliert haben;nicht vorbeikommen an (fig.)
-nicht unterschätzen dürfen;auf der Rechnung haben müssen (fig.)
-Spannungen;Verstimmtheit;Dysharmonie (geh.);Unruhe;Missstimmung;Unfrieden;Verstimmung
-(kräftig) ausschreiten (variabel);ein strammes Tempo vorlegen (variabel);einen schnellen Schritt einschlagen (variabel)
-folgen Sie mir unauffällig (ugs., scherzhaft);hier entlang;wenn Sie mir bitte folgen würden;wenn Sie mir (bitte) folgen wollen (förmlich)
-gehen Sie voran;erst Sie;Alter vor Schönheit (ugs., scherzhaft-ironisch);Sie zuerst;(bitte) nach Ihnen (floskelhaft, Hauptform)
-Da will jemand was von dir. (ugs.);Jemand möchte dich sprechen.;Dein Typ wird verlangt. (scherzhaft)
-kurz und dick;stummelig;wie abgeschnitten;stummelförmig;stummelartig
-auf Halde legen (fig.);nicht sofort benutzen (variabel);bevorraten;auf Lager legen
-speichern;auf Lager nehmen;auf Lager legen;einspeichern;einlagern (Hauptform)
-ins Magazin aufnehmen;im Magazin unterbringen;magazinieren
-im Keller einlagern;einkellern
-in einer Miete einlagern;einmieten
-zu Silage verarbeiten;silieren (fachspr., Landwirtschaft)
-zu Siloballen pressen;zu Siloballen verarbeiten;silieren
-silieren;im Silo einlagern;in einem Silo einlagern
-Material;...gut (fachspr.);Gut;Stoff;...stoff;...material
-Schöpfgefäß;Ösfass (fachspr., seemännisch)
-Schöpfeimer;(die) Pütz (fachspr., seemännisch)
-Annahme (der Ware);Wareneingang
-aufpassen;vorsichtig sein;sich in Acht nehmen vor
-Webplattform;Webserver-Plattform
-Tritthocker;Fußschemel;Ritsche (regional, schlesisch);Fußbänkchen;Fußbank;Fußstütze
-kleines Aas (ugs.);(die) Lerge (ugs., schlesisch);freche Göre
-15-Puzzle;Schiebefax;Fünfzehnerspiel;14-15-Puzzle;Ohne-Fleiß-kein-Preis-Spiel;Schiebepuzzle;Schieberätsel
-zu Geld machen (können);(mit etwas) Geld verdienen können;bares Geld wert sein;(mit etwas) Geld machen können
-körnig;krisselig (ugs.)
-(sein) Geld in einen Topf werfen (ugs., fig.);(sein Geld) zusammenlegen;(eine) gemeinsame Kasse machen;zusammenschmeißen (ugs.)
-Schritt;Damm;Perineum
-Türkischrotfärbung;Türkisch Rotgarn;Adrianopelrot;Indischrot
-Gesperre (altertümlich);Zuhaltung
-Funkensieb;Funkenfänger
-Ansuchender (geh., veraltet);Beantragender (geh., Papierdeutsch);Gesuchsteller (schweiz.);Proponent (geh., veraltet);Antragsteller (Hauptform);Ansucher (geh., veraltet, österr.)
-Bizarrerie;Absonderlichkeit;Abstrusität
-(sich) kaprizieren auf (geh.);(sich) verlegen auf (geh.)
-Kundgebungsteilnehmer;Manifestant
-Adriahöhe (ugs.);Meter über Adria
-Meereshöhe;Höhe über dem Meeresspiegel;Seehöhe
-Quasistandard;De-facto-Standard;Industriestandard
-auf Gedeih und Verderb;existenziell
-Haubarkeit (fachspr., regional);Schlägerungsreife (fachspr., österr.);Erntereife (Forstwirtsch.) (fachspr.);Hieb(s)reife (fachspr.);Schlagreife (fachspr.)
-Umtriebszeit (Forstwirtsch.) (fachspr.);Zeit bis zur Hieb(s)reife (fachspr., variabel)
-Einschlag (Forstwirtsch.) (fachspr., Jargon);Holzeinschlag;Holzernte (fachspr.)
-Eignungstest;Eignungsuntersuchung
-es kommt zu Unerfreulichkeiten;(einen) unschönen Verlauf nehmen;(etwas) nimmt Formen an...;(sich) unerfreulich entwickeln (Hauptform)
-wegziehen;(sich) entvölkern;verlassen;veröden (Hauptform)
-mitarbeiterfreundlich;den Mitarbeitern entgegenkommen(d);im Sinne der Mitarbeiter;arbeitnehmerfreundlich (Hauptform)
-nicht weiterfahren lassen;(jemanden/etwas) zum Stehen bringen;zum Halten bringen;zum Stillstand bringen;(jemanden/etwas) anhalten;(jemanden/etwas) stoppen
-Halt machen;bremsen;anhalten;nicht weitergehen;stoppen;nicht weiterfahren;stehenbleiben;halten;haltmachen;zum Stehen kommen
-aber nein!;oh nein!;aber nicht doch!
-Qualitätsjournalismus;seriöser Journalismus
-Boulevardjournalismus;Sensationsjournalismus
-mit Skandalpotential;skandalträchtig (Hauptform);mit Skandalfaktor
-nicht anspringen (auf);(sich) nicht aus der Reserve locken lassen (durch / mit);nicht eingehen wollen (auf);nicht reagieren
-(sich) nicht zu unvorsichtigen Äußerungen hinreißen lassen;(sich) nicht aufs Glatteis führen lassen (fig.)
-(sein) Licht unter den Scheffel stellen;(sich) kleiner machen, als man (in Wirklichkeit) ist;(sich) nicht gut verkaufen (können)
-versuchen (etwas) zu verheimlichen;(über etwas) hinwegzutäuschen versuchen;zu verbergen (ver)suchen;unter den Teppich kehren wollen (fig.)
-man muss nicht (immer) alles in Frage stellen;(etwas) wird (schon) seinen Sinn haben;dabei wird sich (schon) jemand etwas gedacht haben
-Denken ist Glückssache (und Glück hat man selten). (Spruch);Sie werden (hier) nicht fürs Denken bezahlt. (Spruch);Das Denken soll man den Pferden überlassen, die haben die größeren Köpfe. (Spruch, variabel)
-(sich) sein(en) Teil denken (bei);(sich) im Stillen denken, dass (...);nichts sagen (zu)
-Mehr sein als scheinen. (sprichwörtlich);(im Auftritt) zurückhaltend, aber sicher (variabel);nicht auftrumpfen
-verzögern;hemmen;bremsen;verlangsamen (Hauptform)
-Buxus sempervirens (fachspr., botanisch);Buchsbaum;Gewöhnlicher Buchsbaum;Buchs
-Rostige Ritter;Arme Ritter;Weckzämmädä;Fotzelschnitten (schweiz.);Gebackener Weck;Bavesen;Semmelnudeln;Pofesen;Semmelschmarrn;Kartäuserklöße;Weckschnitten;Semmelschnitten;Blinder Fisch
-Trivialname (fachspr., Hauptform);Nomen triviale (fachspr., biologisch, lat.);umgangssprachliche Bezeichnung;volkstümlicher Name;regionale Bezeichung;regional gebräuchlicher Name;Vernakularname (fachspr., biologisch);volkstümliche Bezeichnung;alltagssprachliche Bezeichnung
-wissenschaftliche Bezeichnung;wissenschaftlicher Name;fachlich korrekte Bezeichnung;fachsprachliche Bezeichnung
-fachlich korrekt;fachsprachlich;(in der) Fachsprache;(im) Fachjargon;(im) ...sprech (Jargon)
-künstlicher Name;Kunstname (Hauptform);erfundener Name;Büchername (fachspr., Hauptform);ausgedachter Name
-Firmenname;Firmenbezeichnung;Name des Unternehmens;Name eines Unternehmens;Firma (juristisch)
-Produktbezeichnung;Produktname
-ligurisches Fladenbrot;Schiacciata;Focaccia
-Gummifotze (fachspr., Jargon);Teigschaber
-obenrum gut bestückt sein (ugs.);große Brüste haben;vollbusig sein (ugs.);(ordentlich) Holz vor der Hütte haben (ugs., fig.)
-flachbrüstig;mit kleinen Brüsten;flach wie ein Brett (ugs.);flach wie ein Bügelbrett (ugs.)
-Kleine-Levin-Syndrom;Dornröschen-Syndrom
-ich;ick (ugs., berlinerisch);i (ugs., bayr., schweiz., schwäbisch, österr.);meine Wenigkeit (geh.);meinereiner (ugs., scherzhaft-ironisch);icke (betont) (ugs., berlinerisch);isch (ugs., kölsch)
-nach (den bisher) uns vorliegenden Informationen (geh., mediensprachlich);AFAIK (ugs., Abkürzung, Jargon, engl.);nach meiner Kenntnis;ASFAIK (ugs., Abkürzung, Jargon, engl.);meines Wissens nach (ugs.);nach meinem (bisherigen) Kenntnisstand (geh., Jargon, mediensprachlich);meines Wissens;soweit ich weiß (Hauptform);soweit (bis jetzt) bekannt (ist)
-Laubbesen;Kratze (ugs., Jargon);Laubharke;Federbesen;Laubrechen;Fächerbesen
-coitus intermammarius (lat.);Mammalverkehr;Busensex (ugs.);Tittenfick (vulg.);Notarkrawatte (ugs.);spanische Krawatte (ugs.)
-Löffelchen;Löffelchenstellung;A-tergo-Stellung;Löffelchenposition;coitus a tergo;Geschlechtsverkehr von hinten (ugs.)
-kleiner Löffel;Löffelchen
-frischen Mut (aus der Tatsache) gewinnen (dass);(sich) wieder aufrichten;wieder Mut (aus der Tatsache) schöpfen (dass) (variabel);frischen Mut fassen;neuen Mut fassen;wieder Mut fassen (Hauptform)
-Mosaik;Setzbild
-(Das) ist nicht deine Baustelle. (ugs.);Das ist *mein* Leben! (ugs.);Das muss dich nicht interessieren. (variabel);Das ist nicht dein Bier. (ugs.);Das geht dich einen Dreck an! (derb);Das geht dich einen Scheiß(dreck) an. (derb);Das geht dich (überhaupt) nichts an.;Das geht dich einen feuchten Schmutz an. (derb);kümmer(e) dich um deine Sachen! (ugs., variabel);Das hat dich nicht zu interessieren. (ugs.)
-Das soll nicht deine Sorge sein. (ugs.);Kümmer dich (gefälligst) um deine Angelegenheiten. (ugs.);Sonst hast du keine Probleme? (ugs., ironisch);Lass das (mal) meine Sorge sein. (ugs.)
-Wanderer zwischen den Welten (geh., fig.);in mehreren Kulturen zu Hause
-Kryokonservierung (fachspr.);Einfrieren von Gewebe
-(jemandem) nichts nachweisen können;nichts in der Hand haben (gegen)
-(jemanden) wieder laufen lassen müssen;(jemanden) nicht festhalten können
-alles versucht haben;nicht weiterkommen;mehr kann jemand nicht tun (ugs.);an seine Grenzen stoßen;(jemandes) Möglichkeiten sind erschöpft;an seine Grenzen gelangen;sein (persönliches) Limit erreichen
-Laienpsychologie;Küchenpsychologie (abwertend);Alltagspsychologie;Vulgärpsychologie (abwertend);Populärpsychologie (abwertend);folk psychology (fachspr., engl.);Hausfrauenpsychologie (abwertend)
-Domscholast;Domscholaster;Domschulmeister
-Adelsdiplom;Adelsbrief
-Menstruationsstörung;Zyklusstörung
-verloren (sein) (fig.);nicht wissen, was man machen soll;hilflos wie ein (kleines) Kind (sein);hilflos wie ein neugeborenes Baby (sein);(völlig) hilflos dastehen;(sich) nicht zu helfen wissen;(sich) keinen Rat wissen
-dastehen wie der Ochs vorm Berg (ugs.);dastehen wie (der / ein) Ochs(e) vorm neuen Tor (ugs.);(dastehen / aussehen) wie eine Kuh wenn's donnert (ugs.);verständnislos sein (Hauptform);(schön) dumm dastehen;dastehen wie der Ochs(e) vorm Scheunentor (ugs.);dastehen wie Pik Sieben (ugs.)
-(dastehen) wie begossen;kläglich aussehen;(aussehen) wie ein begossener Pudel;(ein) Bild des Jammers (bieten) (Person) (fig.);(ein) klägliches Bild (bieten)
-Jackbaumfrucht;Jakobsfrucht;Jackfrucht
-(jemandem etwas) abnötigen;(jemandem etwas) abpressen;(jemanden) zur Herausgabe zwingen
-(jemanden) bis aufs Hemd ausziehen (fig.);(jemandem) den letzten Cent aus der Tasche ziehen;(jemanden) ausnehmen wie eine Weihnachtsgans (ugs.);(jemanden) ausplündern;(jemandem) nichts lassen;(jemanden) ohne einen Cent dastehen lassen;(jemandem) das letzte (bisschen) Geld aus der Tasche ziehen (fig., Hauptform);(jemanden) schröpfen (fig.);(jemandem) das letzte Hemd ausziehen (ugs., fig.);(jemandem) alles wegnehmen (ugs.);(jemandem) alles abnehmen (ugs.)
-(jemandem etwas) abknöpfen (ugs.);(jemanden) erleichtern um;(jemandem etwas) wegnehmen;(jemanden) bestehlen (Hauptform);(jemandem etwas) abnehmen;(jemanden) beklauen (ugs.)
-(jemandem etwas) wegnehmen;(jemandem etwas) abnehmen (um Schaden abzuwenden);(jemandem etwas) fortnehmen;(jemandem etwas) aus der Hand nehmen
-(sich etwas) ertrotzen;(jemandem etwas) abtrotzen;(jemandem etwas) abringen (fig.)
-(jemandem etwas) abnehmen (um zu helfen);(etwas) für jemanden halten;(jemandem etwas) aus der Hand nehmen;(etwas) für jemanden festhalten
-(sich) kaum interessieren (für) (Hauptform);(jemanden) kaltlassen;(jemanden) gleichgültig lassen;wenig übrighaben für;nicht viel übrighaben für;(mit etwas) nicht viel am Hut haben
-Schraubenkupplung;UIC-Kupplung;UIC-Standard-Kupplung
-Steißbeintätowierung;Steißbeintattoo;Arschgeweih (derb, scherzhaft-ironisch);Arschvignette (derb, österr.);Schlampenstempel (derb)
-Walze;Straßenwalze (ugs.)
-Vibrationsstampfer;Vibrostampfer;Rüttelstampfer
-Explosionsramme (fachspr.);Frosch (ugs., Jargon, veraltet);Explosionsstampfer (fachspr.);Explosionsstampframme (fachspr.)
-(eine) böse Überraschung;(ein) böses Erwachen
-der Öffentlichkeit zugänglich machen;(sich) an die Öffentlichkeit wenden (mit);veröffentlichen (Hauptform)
-herumjammern (ugs., Hauptform);(sich) in Selbstmitleid ergehen (variabel);(sich) hängen lassen;die Ohren hängen lassen (ugs., fig.);jammern und picheln (ugs., Spruch)
-(jemandes) Ruhm ist schnell verblasst;für einen Moment der Star
-Supernote;Superdollar
-Gartenhaus;Hinterhaus;Quergebäude
-Halbschwingung;Halbwelle (ugs.)
-verzerrt;verquer;verschoben
-(es) fertigbringen (zu);können;(es) übers Herz bringen (zu);(sich) überwinden (zu)
-Verfasserbemerkung;Verfasseranmerkung;Kolophon;Schlussformel
-Geltungsdrang;Geltungssucht;Großmannssucht (abwertend);Profilierungssucht;Geltungsbedürfnis;Profilneurose (ugs., fig.)
-unkenntlich machen;(akustisch) verfremden;verzerren
-verpixeln;(optisch) unkenntlich machen
-das Thema wechseln;abzulenken versuchen;(vom Thema) ablenken;ausweichend antworten;ausweichen
-Scrollen;Bildlauf
-nicht berücksichtigt werden;unter den Tisch fallen (ugs., fig.);hinten rüberfallen (ugs.);nicht zur Kenntnis genommen werden;außer Betracht bleiben;unbeachtlich bleiben (Juristendeutsch) (fachspr., Jargon)
-(einfacher) Vorderradhalter;Felgenkiller (ugs., abwertend);Felgenklemmer
-Fahrradstation;Radstation;Fahrrad-Parkhaus;Velostation (schweiz.)
-Monrovia-Gitter;Luxemburger Gitter;Mannesmanngitter;Mannheimer Gitter
-Absperrgitter;Sicherheitsabsperrung
-Gurtabsperrpfosten;Tensator
-Polizeigitter;Hamburger Gitter;Hamburger Reiter
-Tscherkessen;Zirkassier
-Bierstürzer;Trichter;Saufmaschine (selten);Bierbong;Beschleuniger;Bierrutsche
-Montiereisen;Reifenheber;Montierhebel
-kontrastarm;flau (Foto) (fachspr., Jargon)
-(etwas) nicht ernst meinen;Spielchen (spielen) (ugs.)
-durch Versuch und Irrtum;abchecken (ugs., jugendsprachlich);trial and error (engl.);austesten (Hauptform);experimentieren;antesten (ugs.);ausprobieren
-Reichsunmittelbarkeit;Reichsfreiheit
-aus der Reihe tanzen (fig.);(den/die/das) gemeinsame(n) (...) verlassen;(sich an etwas) nicht halten (wollen);(eine) Extrawurst gebraten haben wollen;ausscheren (aus);(eine) Sonderbehandlung verlangen (variabel);nicht mitziehen (wollen)
-speziell für;extra für;nur für
-Somatotopie;Somatotopik
-PNS (Abkürzung);peripheres Nervensystem
-Augendiagnose;Irisdiagnostik;Iridologie;Irisanalyse
-Head'sche Zone;Head-Zone
-somatosensorischer Cortex;somatosensibler Cortex
-Bindegewebsmassage;subkutane Reflextherapie
-extrazelluläre Matrix;EZM (Abkürzung);Extrazellularmatrix;Interzellularsubstanz
-Interzellularraum;Zwischenzellraum;Extrazellularraum
-Zytomembran;Zellmembran;Plasmalemma;Plasmamembran
-Reichsstraße;ärarische Straße;Ärarialstraße;Aerarial-Straße
-um Schläge betteln (ugs., fig.);(sich seine) (wohlverdiente) Tracht Prügel abholen
-unpassend angezogen (sein);(sich) mustern (ugs., regional);(sich) unvorteilhaft kleiden;So gehst du mir nicht aus dem Haus! (ugs., Spruch)
-freizügig angezogen (sein);aufreizend gekleidet;nicht mit Reizen geizen;(tiefe) Einblicke gewähren (variabel)
-nicht(s) geschenkt bekommen (haben);(sich etwas) hart erarbeiten (müssen);(jemandem) nicht in den Schoß gefallen (sein);Ohne Fleiß kein Preis. (Sprichwort);hart arbeiten müssen (für);Von nichts kommt nichts. (Sprichwort)
-Aapamoor;Strangmoor
-Palsenmoor;Palsamoor
-vor Kraft nicht laufen können;vor lauter Kraft kaum gehen können;vor Kraft strotzen
-das Geld (für etwas) ist da (ugs.);flüssig sein;gut bei Kasse sein (ugs.);über die nötigen finanziellen Mittel verfügen;es ist genug Geld da (ugs.);(genug) Geld haben (Hauptform);das nötige Kleingeld haben (ugs., scherzhaft);liquide sein
-(Geld) einstecken haben (ugs.);(Geld) eingesteckt haben;(Geld) auf der Tasche haben (ugs.);(Geld) mithaben (ugs.);(Geld) dabei haben (ugs.)
-(jemandem) den Wasseranschluss sperren;(jemandem) das Wasser sperren;(jemandem) den Hahn zudrehen (ugs., fig.);(jemandem) das Wasser abdrehen (ugs.)
-von Vorteil sein;vorteilhaft sein;(seine) Vorteile haben;etwas für sich haben;Vorteile bieten
-(viel) nachdenken über;hin- und herüberlegen (ugs.);in seinem Herzen bewegen (geh., dichterisch);(lange) mit sich herumtragen (ugs., fig.)
-Mitspieler;Teilnehmer;...teilnehmer;Teilnehmender (gendergerecht)
-tadellos (Zustand);einwandfrei;perfekt;makellos;nichts auszusetzen;tipptopp (ugs.)
-mangels besseren Wissens;aus Unerfahrenheit
-ohne klare Anweisung;ohne Verfahrensabsprache;ohne (klaren) Handlungsauftrag
-ohne Handhabe;ohne etwas in der Hand zu haben (gegen)
-vom Gesetz nicht gedeckt (sein);(es gibt) keine rechtliche Grundlage (für)
-nicht klar geregelt (sein);(sich) in einer rechtlichen Grauzone bewegen;ohne verbindliche Rechtsgrundlage
-(nach / in) Geist und Buchstaben (eines rechtsverbindlichen Textes);so, wie es eigentlich gemeint ist (ugs.);entsprechend der Intention (des Gesetzes / des Verhandlungsergebnisses / der Charta ... / der Vertragspartner / des Gesetzgebers / des Urteils ...);nach dem Willen (des Autors / Erblassers / Gesetzgebers / Unterzeichners ...);so, wie es eigentlich mal gemeint war (ugs.);(nach) Buchstaben und Geist (einer Textgrundlage) (variabel);der ursprünglichen Intention (z.B. des Gesetzgebers) entsprechend
-in großer Zahl;in großem Umfang;(zahlenmäßig) groß;erheblich;in erheblichem Umfang;bedeutend (fig.);umfangreich
-gedanklich;in Gedanken
-unwirklich;traumartig;verfremdet;unvertraut;hyperreal;traumähnlich;fremd;übernatürlich;nicht real
-fantastisch;märchenhafte Züge haben(d);märchenhaft;wie in einem Märchen;phantastisch;wie in einer Fantasy-Story;magisch;fantasy-artig
-übernatürlich;paranormal;außernatürlich
-Interimsabkommen über das Westjordanland und den Gazastreifen;Abkommen von Taba;Oslo II;Israelisch-Palästinensisches Interimsabkommen
-(nur) ein mitleidiges Lächeln übrig haben (für) (fig.);nicht ernst nehmen;auslachen;belächeln;(jemandem) ins Gesicht lachen (fig.);spöttische Bemerkungen machen (über)
-blasphemieren;Blasphemie (be)treiben;gotteslästerliche Reden führen;(Gott) lästern
-na endlich! (Hauptform);das wurde aber auch Zeit!;jetzetle! (ugs., schwäbisch)
-ich wäre dann so weit;ich bin so weit (fertig);von mir aus kann's losgehen;meinetwegen können wir
-lass dich (mal) ansehen!;(jetzt) zeig dich mal!
-wie hast *du* dich (denn) gemustert!?;wie läufst du wieder rum?;was ist (denn) das für ein Aufzug!?;so gehst du unter Leute?;wie siehst *du* denn aus!?
-(sich) allmählich interessieren;anfangen, sich zu interessieren;Feuer fangen
-(sich) einstellen (auf);(sich) geistig einstellen (auf);eine Einstellung entwickeln;(sich) mental vorbereiten;(sich) innerlich vorbereiten
-Einstellungssache (ugs.);Frage der inneren Haltung
-angenommen;theoretisch;hypothetisch
-hat auch seine komischen Seiten;durchaus komisch (zu nennen);ist auch als komisch zu bezeichnen;kann man (durchaus) als komisch bezeichnen (variabel);entbehrt nicht einer gewissen Komik (floskelhaft)
-Softwareverrottung;Softwarezerfall;Softwareerosion
-Umsatz;Erlös
-eng sitzen;spannen
-(sich) nicht ernst genommen fühlen;(sich) auf den Arm genommen fühlen;(etwas) als blanken Hohn empfinden;(sich) verarscht vorkommen (derb)
-unbemerkt von der Öffentlichkeit;im stillen Kämmerlein (fig.)
-Pockels-Effekt;linearer elektro-optischer Effekt
-Birefringenz;Doppelbrechung
-Cotton-Mouton-Effekt;magnetische Doppelbrechung
-Filmwaage;Pockels-Langmuire-Waage;Langmuire-Trog
-ambiphil;amphipathisch;amphiphil
-Amphiphilie;Ambiphilie
-Monolage;Monoschicht
-Ausgleichung nach vermittelnden Beobachtungen;vermittelnde Ausgleichung
-Altimeter;Höhenmesser
-Öschprozession;Bittgang;Bittprozession;Flurprozession
-auf den Wortschatz bezogen;lexikalisch;den Wortschatz betreffend;auf das Lexikon bezogen (fachspr.)
-(es) ist gut (mit) (ugs.);sein Bewenden haben (mit / bei);(es) belassen bei;es bewenden lassen (mit / bei);(einer Sache) nichts hinzuzufügen (sein);(etwas) soll (mal) genug sein (ugs.)
-vorsintflutlich;antediluvianisch (geh., veraltet)
-(einfach) dazugehören (ugs.);(jemandem) nicht erspart bleiben;(jemandem etwas) nicht ersparen können;(irgendwo) durchmüssen (ugs.)
-ein Drittes gibt es nicht;tertium non datur
-(einen) Zusammenhang herstellen (zwischen);in einem Atemzug nennen (fig.);in Verbindung bringen;(eine) Beziehung herstellen (zwischen)
-bleiben bei;Stein und Bein schwören (geh., fig.);(weiter) aufrechterhalten (Aussage, Behauptung);steif und fest behaupten;beharren auf;bestehen auf;nicht abzubringen sein von
-Vorkriegs...;(von) asbach uralt (ugs., veraltend);von anno achtzehnhundert schlag mich tot (ugs.);von vor dem Krieg;asbach (ugs., veraltend);von anno Tobak (ugs.);von anno tuck (ugs.)
-Pilling;Miezel (ugs., regional);Möppchen (ugs., regional);Fussel;Wollmaus (ugs., regional);Wollknötchen;Knötchen (auf Textilien, z.B. Pullover)
-verknotete Haare;Haarnest;Hexe (ugs.);verknotetes Haar
-(jemanden) begnadigen;(jemandem) die Strafe erlassen;(jemandem) seine Reststrafe erlassen;Gnade vor Recht ergehen lassen;(jemanden) amnestieren (fachspr.);(jemandem) die Schuld erlassen
-(das) Verfahren einstellen;(die) Anklage niederschlagen (fachspr.);(es) kommt nicht zur Anklage;(die) Anklage fallenlassen;(die) Klage zurückziehen
-(eine) Bewährungsstrafe bekommen (ugs.);(jemanden) wegen guter Führung vorzeitig entlassen (ugs.);auf Bewährung (früher) rauskommen (ugs.);(die) Reststrafe zur Bewährung aussetzen;(eine) Strafe zur Bewährung aussetzen (Hauptform);(jemanden) auf Bewährung (wieder) laufen lassen (ugs.)
-laufen gelassen werden (ugs.);straflos bleiben;nicht verurteilt werden;freigesprochen werden;mit Freispruch enden (Verfahren);straflos davonkommen;auf Freispruch erkennen (Gericht, Richter) (fachspr., Jargon)
-(eine) Arbeit nicht fortführen können;zur Untätigkeit verdammt sein;(die) Arbeiten einstellen müssen;nicht weitermachen können (ugs.);nichts (mehr) zu tun haben (ugs.);nicht weiterarbeiten können
-keine Arbeitserlaubnis haben;zur Untätigkeit verdammt sein;nicht arbeiten dürfen
-Strahlenangst;Radiophobie
-besser hätte ein anderer es auch nicht machen können (variabel);alles richtig machen;keine(n) Fehler machen
-(etwas) falsch anpacken;falsch an eine Sache herangehen;(eine) falsche Herangehensweise wählen
-zwei linke Hände haben (fig.);(sich) (fast) einen abbrechen (ugs., variabel);(sich) ungeschickt anstellen (beim Arbeiten)
-(na) das hast du ja (wieder mal) toll hingekriegt;saubere Arbeit! (ugs., ironisch)
-rechtsrheinisch;auf der rechten Seite des Rheins (variabel);auf der rechten Rheinseite
-auf der linken Rheinseite;linksrheinisch;auf der linken Seite des Rheins (variabel)
-beschießen;schießen auf;(einen) Schuss abgeben (auf);Schüsse abgeben (auf);(jemandem / einem Tier) eine Kugel auf den Pelz brennen (fig., variabel);feuern auf
-bestreichen (fig.);beharken (fig.);mit Feuer belegen;mit Sperrfeuer belegen
-unter Beschuss stehen;unter Dauerfeuer stehen;unter Sperrfeuer stehen;beschossen werden
-herumballern (ugs.);(sinnlos) verballern (ugs.);verschießen (Munition);leerballern (ugs.);leerschießen (Magazin)
-Dauerbeschallung;Dauerberieselung (fig.)
-Solo-Entertainer;Alleinunterhalter (fig.);Stimmungskanone;(Person) mit Entertainerqualitäten
-für (gute) Stimmung sorgen;Stimmung in die Bude bringen (ugs.);(den) Abend schmeißen (ugs.)
-abstinent (Drogenkonsument);trocken (Alkoholiker) (Jargon)
-Abwarten (ugs.);Abwartezeit;Schamfrist;Karenzzeit
-Welch ein Glanz in meiner Hütte! (ugs., ironisierend, variabel);Wie kommt dieser Glanz in meine Hütte? (ugs.);Je später der Abend, desto schöner die Gäste. (ugs.);welch hoher Besuch!
-Lohntüte;Auszahlungsbetrag;(was man) auf die Hand (bekommt);Nettolohn (Hauptform);was übrigbleibt
-auf die Hand bekommen (fig.);ausgezahlt bekommen;aufs Konto überwiesen bekommen;am Ende (noch) sehen (ugs., fig.);rausbekommen (ugs.);(netto) übrigbleiben (ugs.);netto bekommen (ugs.)
-(etwas) völlig überarbeiten;(etwas) in neuem Gewand (herausbringen);(etwas) neu gestalten;(etw.) erneuern;(einer Sache) ein neues Gesicht geben (fig.);(etwas) umgestalten (Hauptform);(einer Sache) ein neues Outfit verpassen (ugs., variabel);(etwas) umdekorieren (fachspr., kaufmännisch)
-variieren;unterschiedlich sein (Hauptform);geteilt (z.B. Meinung);(sich) (voneinander) unterscheiden;voneinander abweichen
-Annehmlichkeiten;Komfort;Vorzüge;angenehme Seiten
-(sich) etwas wünschen dürfen;(einen) Wunsch frei haben (variabel)
-Anciennitätsliste (veraltet);Dienstaltersliste;Dienstalterliste
-SS-Totenkopfring;SS-Ehrenring;Totenkopfring
-Schutzstaffel;SS (Abkürzung)
-SS-Ehrendolch;SS-Dolch
-SS-Degen (ugs.);SS-Ehrendegen (ugs.);Ehrendegen Reichsführer SS (offiziell)
-Domänenschicht;Verarbeitungsschicht;Geschäftslogikschicht;Anwendungslogikschicht
-Architekturmuster;Architekturstil
-Westbindung;Westintegration
-Augsburger Liga;Augsburger Allianz
-Katholische Liga;Christliche Koalition;Heilige Liga
-Zweiverband;Französisch-Russische Allianz
-Heroin (geh.);Heldin
-Parisergelb (ugs.);Blei(II)-chromat;Königsgelb (ugs.);Bleichromat (ugs.);Chromgelb (ugs.)
-Buntfarbenaufdruck;Splittertarn
-wirklich (so) passiert sein;(eine) wahre Begebenheit
-(etwas ist) alles andere als lustig;da kommt (richtig) Freude auf (sag ich dir) (ironisch)
-(so langsam) hört der Spaß auf (ugs., Redensart);(dann ist) Schluss mit lustig (ugs., Spruch);(es ist) vorbei mit der Gemütlichkeit (ugs., floskelhaft);(dann) kriegst du aber Spaß! (ugs., ironisch);(es) wird ernst;(da) hört der Spaß (aber) auf (ugs., Redensart)
-Chasaren;Khasaren
-Bergkarabach;Berg-Karabach
-Heeresfolge;Heerfolge
-Gaslift;Löscherpumpe (veraltet);Mammutpumpe;Druckluftheber;Airlift (engl.)
-Kunst;Kunstgezeug
-(jemandem) aus dem Weg(e) gehen;(es) vermeiden, jemanden zu treffen;(es) vermeiden, jemandem über den Weg zu laufen
-das will ich (aber) auch hoffen! (ugs.);das will ich (doch) hoffen!;das erwarte ich (auch)!;(wir) wolln's hoffen (ugs.);inschallah!;das will ich (auch) schwer hoffen! (ugs.);das walte Hugo! (ugs., Spruch, berlinerisch, ruhrdt., veraltet);na hoffentlich! (ugs.);(wir) wolln's mal hoffen (ugs.)
-(eine) verblüffend einfache Lösung;(das) Ei des Kolumbus (sprichwörtlich)
-(etwas) auch so sehen (ugs., fig.);derselben Ansicht sein;der gleichen Meinung sein;derselben Auffassung sein;die Meinung teilen, dass (variabel);(jemandes) Meinung teilen (variabel);dieselbe Meinung vertreten;derselben Meinung sein;(etwas) genau so sehen (ugs., fig.);(etwas ist) auch meine Meinung
-Zustimmung signalisieren;aus jemandes Worten spricht (vorsichtige) Zustimmung;Zustimmung erkennen lassen
-provozieren;wider den Stachel löcken (geh., veraltet);frech werden;patzige Antworten geben;Widerworte geben (ugs.)
-nach einigen Quellen;nicht erwiesen;einigen Quellen zufolge;(es gibt eine) unsichere Beleglage
-jetzt ist (es) aber gut! (ugs.);es reicht jetzt (so langsam) (ugs.);nun mach (aber) mal'n Punkt! (ugs.)
-(etwas) durchwinken (Jargon, fig.);(etwas) passieren lassen (Jargon, fig.);(etwas) abnicken (Jargon, fig.)
-Fitnessgerät;Sportartikel;Sportgerät
-nicht am Platz (Jargon);nicht im Büro;(einen) Außentermin haben;nicht an seinem Platz;im Außeneinsatz;unterwegs (ugs.);im Außendienst
-auf Geschäftsreise;geschäftlich unterwegs
-(sich) sofort an die Arbeit machen;keine Zeit verlieren;sofort loslegen
-(sich) beeilen müssen;keine Zeit zu verschenken haben;nicht mehr viel Zeit haben;(jemandem) bleibt nicht mehr viel Zeit;(jemandem) bleibt wenig Zeit (bis);(sich) ranhalten (müssen) (ugs., regional);keine Zeit zu verlieren haben
-jetzt werd' doch nicht gleich sauer! (ugs.);jetzt sei doch nicht gleich (so) eingeschnappt! (ugs., variabel);ich mein ja nur ... (ugs.)
-Arbeitstempo;Schlagzahl (fig.)
-(jemandem) einen Schlag verpassen (ugs.);(jemandem) eins überbraten (ugs.);(jemandem) einen auf die Nase geben (ugs., variabel);(jemandem) eine verpassen (ugs.);(jemandem) einen Schlag versetzen (auch figurativ);zuschlagen;(jemandem) einen vor die Nuss geben (ugs.);(jemandem) einen auf die Nuss geben (ugs.);(jemanden) schlagen;(jemandem) einen mitgeben (ugs., auch figurativ);(jemandem) ein Ding verpassen (ugs.)
-(korrekt) gegendert;genderbewusst;genderbemüht;genderfair;genderkorrekt;gendergerecht;geschlechtergerecht;gendersensibel;geschlechtsneutral
-Sättigung;Farbsättigung
-Strahlungsstärke;Strahlungsintensität;Strahlstärke
-Strahlungsfluss;Strahlungsleistung
-nicht mit mir!;für wie blöd hältst du mich! (ugs.);da musst du (schon) früher aufstehen! (ugs.)
-Kaltgerätekabel;Kaltgeräte-Anschlusskabel
-Kleingerätekabel;Kleingeräte-Anschlusskabel
-Triggerwarnung;Spoileralarm (ugs.);Warnhinweis (Hauptform);Spoilerwarnung
-Was gewesen ist, ist gewesen. (sprichwörtlich);Die Geschichte ist (schon) lange vorbei.;Der Fisch ist gegessen. (ugs., Redensart, fig., sprichwörtlich);das war's (denn wohl) (ugs.);Die Angelegenheit ist abgeschlossen.;Der Käse ist gegessen. (ugs., Spruch, fig.);Das Ding ist gelaufen. (ugs.);Der Drops ist gelutscht. (ugs., Spruch, fig.);Der Fall ist ad acta gelegt.;Die Sache ist gegessen. (ugs., fig.);Die Suppe ist gegessen. (ugs., fig.);Das ist (längst) Geschichte.;Der Fall ist abgeschlossen.;Die Sache ist erledigt.;Vorbei ist vorbei. (Redensart);(Es) ist ausgestanden.
-Traffic (engl.);Besucherzahlen
-locker wegstecken;gut fertig werden mit;schnell hinwegkommen über
-lange nicht fertig werden mit (Hauptform);(lange) zu knapsen haben (an) (ugs.);(etwas ist für jemanden) ein schwerer Schlag;(sich) lange herumquälen (mit);nur schwer verwinden (können);sehr damit zu kämpfen haben, dass;(jemandem) sehr zusetzen;schwer daran zu tragen haben, dass;(für jemanden) ein langer Kampf sein, bis;kaum hinwegkommen über (variabel)
-(einen) Schaden an seiner Seele davontragen;seelisch verletzt werden;traumatisiert werden;Schaden an seiner Seele nehmen (geh.)
-Synchronsprecher;Synchronschauspieler
-Birma-Katze;Heilige Birma
-Burmese;Burma-Katze
-Analysefähigkeit;Spürsinn
-Kyros-Erlass;Kyros-Edikt
-radikaler Muslim;Islamist (Hauptform);Dschihadist;Gotteskrieger
-(ein) Gang nach Canossa (fig.);zu Kreuze kriechen (fig.);(ein) schwerer Gang
-(sich) immer nur das Beste nehmen;(sich) die besten Stücke sichern;(sich) das Beste unter den Nagel reißen;(den) Rahm abschöpfen (fig.);(sich) (die) Rosinen herauspicken (fig.)
-Frieseköttel (ugs., regional, selten, veraltet);Bibberling (ugs.);Frostbeule (ugs., fig., Hauptform);Frierkatze (ugs.);Friesepitter (ugs., rheinisch);Frierpitter (ugs., regional, rheinisch)
-Anwaltserfordernis;Anwaltszwang
-Gewaltanstrengung;Klimmzüge (machen) (fig.)
-über tausend Umwege (fig.);unnötig kompliziert;von hinten durch die Brust ins Auge (fig.);(sehr) umständlich (Hauptform)
-ergonomisch unzureichend (z.B. Software);wenig benutzerfreundlich;benutzerunfreundlich
-(sich) selbst kümmern (um);selbst in die Hand nehmen (fig.);selbst tätig werden;selbst Hand anlegen;selbst sorgen für;selbst aktiv werden
-(jemandem / einer Sache) Einhalt gebieten;(etwas) unternehmen gegen (ugs.);einschreiten
-Mikrochemie;Mikroanalyse
-hartnäckig bleiben;(sich) nicht abwimmeln lassen;insistieren;(sich) nicht von etwas abbringen lassen
-ständiger Aufenthaltsort;fester Wohnsitz;Wohnanschrift
-(ja) was denken Sie (denn)!;dachten Sie etwa (...)?;wo leben Sie denn! (Spruch);(oder) etwa nicht?;(ja) was denkst du denn!;ja watt'denn! (ugs., rheinisch);was dachten Sie denn!;(ja) was denn sonst!?
-Markendehnung;Markentransfer
-es sich nicht aussuchen können;in einer Zwangslage (sein);keine Wahl haben;Vogel friss oder stirb! (sprichwörtlich)
-Propagandatruppe;Propagandakompanie
-hier auf der Erde;in diesem Erdenleben;im Diesseits;hienieden
-weltlich;irdisch;vergänglich;diesseitig;von dieser Welt
-Batavier (veraltet);Bataver
-Reichsabtei Stablo-Malmedy;Fürstabtei Stablo-Malmedy
-Montzener Land;Plattdeutsche Gemeinden;Altbelgien-Nord
-Altbelgien-Süd;Areler Land
-hohe Gewinnerwartungen;Dollars in den Augen (haben) (ugs., fig.);Goldgräberstimmung (fig., Hauptform);Aussicht auf maximale Gewinne (variabel)
-Aufbruchstimmung;positive Zukunftserwartung(en);Optimismus
-nahelegen (Verdacht);vermuten lassen;dafür sprechen;als (sehr) wahrscheinlich erscheinen lassen;(es gibt) Anhaltspunkte dafür (dass);(die) Vermutung nahelegen
-Dollars in den Augen (haben) (ugs., fig., salopp);nur ans Geld denken;nur das Geld sehen
-es kommt (ordentlich) Geld herein;viel (Geld) einnehmen;die Kasse klingelt (fig.);Einnahmen erzielen
-Miller-Urey-Experiment;Urey-Miller-Experiment;Miller-Experiment
-clostridiale Myonekrose;Gasbrand;malignes Ödem;Gasgangrän;Gasödem;Gasphlegmone;Clostridium-Myositis;Clostridium-Zellulitis
-Niederländisch-Indonesische Union;Niederländische Union
-(jemandem etwas) mit auf den Weg geben (fig.);(jemandem etwas) ins Stammbuch schreiben (fig.);(jemandem etwas) in den Block diktieren (fig.);(jemandem) den guten Rat geben (dass / zu)
-moralisches Selbstbild;(irgendwie) vor sich selbst dastehen
-(sich selbst) nicht leiden können;(ein) negatives Selbstwertgefühl haben
-(jemandem etwas) ausleihen;(jemandem etwas) borgen;(jemandem etwas) leihweise zur Verfügung stellen;(jemandem etwas) ausborgen;(jemandem etwas) leihen
-(etwas) ausleihen;(etwas) verleihen
-Pfefferküste;Malaguettaküste
-Staatsmonopolistischer Kapitalismus;Staatsmonopolkapitalismus;Stamokap (Kurzform)
-Pentalobular;Pentalob
-sehr;maßgeblich;entscheidend;in hohem Maße;maßgebend;wesentlich;in hohem Grade
-IAS-Rechner;Princeton-Maschine;IAS-Computer
-ans Netz gehen (Kraftwerk);in Betrieb gehen;(den) Betrieb aufnehmen
-ans Netz gehen (Internet);online gehen
-abfahren (Aggregat, z.B. Turbine);(vorübergehend) abschalten;außer Betrieb nehmen;vom Netz nehmen (Reaktor, Server)
-es kommt zu Arbeitsniederlegungen;es wird gestreikt (Hauptform);bestreikt werden (Betrieb);alle Räder stehen still (bei)
-stocknüchtern;vollkommen nüchtern
-Seebeck-Effekt;thermoelektrischer Effekt
-Schmelzenergie (veraltet);Schmelzenthalpie;Schmelzwärme (veraltet)
-Europäisches Innovations- und Technologieinstitut;Europäisches Institut für Innovation und Technologie
-visueller Cortex;Sehrinde
-(jemand) würde am liebsten;(jemand) hätte nicht übel Lust (zu)
-(jemandem) fällt die Decke auf den Kopf (ugs., fig.);unbedingt unter Leute müssen (ugs.);unbedingt (mal) rausmüssen (ugs.);(jemand) hält es in der Wohnung nicht mehr aus
-aber gerne!;(aber) mit dem größten Vergnügen!;nichts lieber als das!;(es gibt) nichts, was ich lieber täte!
-(gut) auskommen (mit);auf gutem Fuß stehen (mit);Hand in Hand arbeiten;(sich) gut verstehen;harmonieren;gut miteinander klarkommen (ugs.);(sich) gegenseitig die Bälle zuspielen (ugs., fig.);ein gutes Verhältnis haben (zu);(die) Chemie stimmt (zwischen) (ugs., fig.);(sich) verstehen;(ein) Team sein;gut miteinander können (ugs.)
-Tyrolienne (franz., schweiz.);Guerillarutsche (österr.);Seilbahn;Tirolienne (schweiz.);Seilrutsche
-Ergonovin;Ergometrin;Ergobasin
-Anstecknadel;Brustnadel;Brosche (Hauptform);Vorstecknadel
-(jemand) wird sich noch wundern;(jemand) wird (noch) sein blaues Wunder erleben (sprichwörtlich);(jemand) wird sich noch umsehen;(jemand) wird sich noch umgucken
-(jemanden) ernüchtern;auf den Boden der Tatsachen zurückholen (fig.);(jemandem) seine Illusionen rauben;(jemanden) desillusionieren;(jemandem) den Zahn ziehen (fig.)
-Schließe;Verschluss
-Gürtelschließe;Koppelschloss (militärisch);Gürtelschnalle
-Haarklammer;Libelle (Jargon);Haarspange;Haarschnalle (regional);Spange;Haarklemme;Haarclip
-Fibel (fachspr., historisch);Schließnadel;Sicherheitsnadel (Hauptform)
-Eingabezeiger;Schreibmarke;Einfügemarke;Cursor (engl.);Eingabemarkierung
-anderes Sinnes werden (geh., veraltet);es sich anders überlegen;anders entscheiden;(sich etwas) anders überlegen;(sich) eines anderen besinnen (geh.);(sich) anders entscheiden;(sich) umentscheiden;(seine) Pläne ändern;anderen Sinnes werden (geh.)
-Hopser (ugs.);Hüpfer (Hauptform);kleiner Sprung
-Junges;Kleines;Jungtier;Tierkind
-Formelsammlung;Tafelwerk;Tabellenbuch
-Blind Date;Verabredung mit einem Unbekannten;Verabredung mit einer Unbekannten
-(jemandem) nachspionieren;(jemandem) nachsteigen (österr.);(jemandem) nachschleichen;(jemandem) hinterherschleichen;(jemandem) nachstellen;(jemanden) verfolgen;(jemandem) hinterherspionieren;(jemandem) heimlich folgen;(jemanden) stalken (engl.)
-dunkle Ahnung;unbestimmtes Gefühl;dummes Gefühl (ugs.);leiser Verdacht
-(einen Film / eine Sendung) sehen;(sich) reinziehen (ugs., salopp);(sich) anschauen;(sich) ansehen (Film) (Hauptform);(sich) angucken (ugs.);(einen Film / eine Sendung) gucken (ugs.)
-hintergründig;verborgen;hintersinnig
-Schmalspur... (abwertend, fig.);nicht das volle Programm (ugs.);... light (nachgestellt) (engl., fig.);nicht vollwertig;abgespeckt (fig.);reduziert;nur das Nötigste (variabel);kein richtiger ... (keine richtige ... / kein richtiges ...) (ugs.)
-auf dem Tisch liegen (fig.);eingesehen werden können
-zeigen, was man auf der Hand hat;(die) Karten auf den Tisch legen (auch figurativ);(die) Hosen herunterlassen (Kartenspiel) (Jargon, fig.);seine Karten zeigen;sein Blatt zeigen
-Klarschrift;Klare Schrift;oiratische Schrift
-Oiraten;Dsungaren
-Choschuten;Khoshuud
-(eine) Party schmeißen (ugs., Hauptform);(ein) Fest organisieren;(eine) Party geben
-gefechtsunfähig (sein) (fig.);aktionsunfähig (sein);nichts machen können;nichts tun können
-Schreckgespenst;Schreckbild;Popanz (veraltet)
-Shockley-Queisser-Grenze;Shockley-Queisser-Limit
-Grätzel-Zelle;elektrochemische Farbstoff-Solarzelle;Farbstoffsolarzelle
-Tandem-Solarzelle;Mehrfachsolarzelle;Stapelsolarzelle
-Konzentratorzelle;Konzentrator-Photovoltaik
-Stokessche Regel;Stokessches Gesetz;Stokes-Verschiebung
-Raman-Streuung;Smekal-Raman-Effekt;Raman-Effekt
-Vierschichtdiode;Shockley-Diode;Dinistor
-Diac;Zweirichtungs-Diode
-(sich) im Hintergrund halten;(sich) bedeckt halten;die Füße stillhalten (fig.);nicht öffentlich in Erscheinung treten;nicht weiter in Erscheinung treten;im Hintergrund bleiben;im Hintergrund stehen
-(etwas) hinnehmen;gelten lassen;ziehen bei (ugs.);bei jemandem durchkommen mit (ugs.)
-Dokumentalist;Dokumentar
-Büroleiter;Bürochef;Bürovorsteher (fachspr., Jargon)
-Kanzleischreiber;Schreibkraft;Schreiber;Kanzlist (veraltet)
-alles oder nichts;Sekt oder Selters;hop(p) oder top
-Rauschradar;Stealth-Radar;Tarnkappenradar
-Genlocus;Locus;Lokus;Genlokus
-Centromer;Zentromer
-Dirac-Notation;Bra-Ket-Notation
-Eruptionskreuz;E-Kreuz (Kurzform)
-Zahmheit;Milde;sanft(mütig)es Wesen;Sanftmut;Sanftheit;Friedfertigkeit;Sanftmütigkeit
-Widerstandslosigkeit;Gefügigkeit
-(etwas) nehmen, wie es kommt;gleichmütig hinnehmen (Hauptform);(ein) Gemüt wie eine Brummfliege haben (ugs.);(etwas) nehmen, wie die Kuh das Gras frisst (ugs.)
-ohne Operation;nicht chirurgisch;bewahrend;erhaltend;konservativ (fachspr., medizinisch)
-(das ist ja eine) schöne Bescherung! (ugs.);(da) hast du die Bescherung! (ugs., fig., ironisch);(jemand) kann zusehen, wie er mit etwas fertig wird (ugs., variabel);(jetzt) haben wir den Salat (sprichwörtlich, variabel)
-für die musikalische Untermalung sorgen (variabel);das musikalische Rahmenprogramm liefern (variabel);aufspielen
-(sich) gebärden als;(sich) aufspielen zu;(sich) hochstilisieren zu
-nicht nachweisbar;unterhalb der Nachweisgrenze
-nicht anhalten;keinen Aufenthalt haben (Bahn-/Busreise);durchfahren;nicht stehenbleiben;keine Pause machen
-(sich) rechts halten (Verkehr);(möglichst) in der rechten Spur bleiben;rechts bleiben (ugs.);möglichst (weit) rechts fahren
-links bleiben;möglichst (weit) links fahren;(möglichst) in der linken Spur bleiben;(sich) links halten (Verkehr)
-(jemanden) zum Maßstab nehmen;(für jemanden) gilt, was jemand gesagt hat (der es wissen muss);(für jemanden) gilt das Wort (einer maßgeblichen Person);(sich) orientieren an;(es) halten mit (Hauptform)
-Töpfli (schweiz.);(kleiner) Topf
-Glace-Töpfli (schweiz.);Eisbecher
-Coupekarte (schweiz.);Eiskarte
-Schwedeneisbecher;Schwedenbecher
-(Versprechen, Termin) halten (auch figurativ);(Zusage, Termin) einhalten
-stopp mal;halt mal;Moment(chen) mal
-abseits bleiben;(sich) abseits halten;für sich bleiben
-halten;sich als stabil erweisen;nicht kaputtgehen;stabil sein
-(jemandem) Arbeit geben;für Jobs sorgen;(die) Arbeitslosigkeit beseitigen;(jemanden) in Lohn und Brot bringen
-Zeitgeist;(der) Zug der Zeit;Zeitströmung
-wieder wie neu (aussehen) (variabel);in neuem Glanz erstrahlen (fig.)
-so oder so (ugs.);(ganz) egal wie man's macht;in jedem Fall;wie man es auch macht
-Nepali;Nepalisch;Nepalesisch
-immergleich;(sich) nie verändernd;immer gleich
-Mittzwanziger(in);Mitte zwanzig (sein)
-in seinen späten Zwanzigern;in ihren späten Zwanzigern;(noch) unter dreißig (Jahre alt) sein;bald dreißig (werden);Ende zwanzig (sein)
-sich hüten (etwas zu tun);(sich) in Acht nehmen;vorsichtig sein (mit)
-(die) Zügel in die Hand nehmen (fig.);(etwas) in die Hand nehmen (fig., Hauptform);(selbst) das Heft in die Hand nehmen (fig.);nicht darauf warten, dass jemand anders etwas tut (variabel);(die) Initiative ergreifen;aktiv werden
-Tiefstellung;Subskript
-Superskript;Hochstellung
-noch (irgend)jemand;sonst jemand;irgendwer sonst;sonst wer (abwertend);irgendein anderer;ein anderer;jemand sonst;irgendjemand and(e)res;jemand anders
-irgendwelche andere (Pronomen);irgendwelche andere (Personen / Dinge)
-(das) Dreschen;(der) Drusch (fachspr.)
-ausspeien;aushusten;ausspucken;auswerfen
-(sich) ködern lassen (fig.);(sich) interessiert zeigen;Interesse zeigen;anbeißen (ugs., fig.)
-von der Stange (ugs., fig.);Konfektionslösung (fachspr., Jargon);aus (einer) Serienproduktion;fertig konfektioniert (fachspr., Jargon)
-übersetzen;dolmetschen;übertragen
-Übersetzung (Vorgang);Übertragung (Vorgang);Translation (fachspr.)
-Übertragung (Ergebnis);Translat (fachspr.);Übersetzung (Ergebnis)
-Ausstattung mit Untertiteln;Untertitelung (Hauptform)
-Herstellung einer synchronisierten Fassung;Synchronisation (Film)
-(...) mit (deutschen) Untertiteln;(...) untertitelt;Version mit Untertiteln;UT;untertitelte Version (Film)
-(den) Dolmetscher machen;(die) Dolmetscherin sein;als Dometscher(in) arbeiten;(die) Dolmetscherin machen;(der) Dolmetscher sein;dolmetschen
-sinngemäße Übersetzung;Übersetzung ins Grobe (ugs.);grobe Übersetzung;Rohübersetzung (fachspr., Jargon, Hauptform);vorläufige Übersetzung
-Ohrfeigengesicht (ugs.);Backpfeifengesicht (ugs.);Gesicht zum Reinschlagen (derb);Gesicht wie ein Feuermelder (ugs.)
-sitzen an (Schreibtischarbeit) (ugs.);(mit etwas / mit jemandem) zugange sein (ugs., salopp);(mit etwas / mit jemandem) zu tun haben (ugs.);(gerade) (mit etwas / mit jemandem) beschäftigt sein;(etwas / jemanden) in der Mache haben (ugs., salopp, veraltend);arbeiten (an)
-langsam;allmählich (warnend)
-heranziehen;aufziehen;erziehen;großziehen;versorgen
-nicht gut sein für (ugs.);(etwas) geht auf (...) (ugs.);Stress sein für;belasten
-verhexen;beschreien;verzaubern
-Verwilderung;Verrohung;Entartung
-alles so etwas;lauter solche Sachen;lauter solche Dinge;all so was (ugs.)
-(das) Heft in der Hand behalten (fig.);an seiner Führungsposition festhalten;(die) Fäden in der Hand behalten (fig.);(die) Führung nicht abgeben
-hegen und pflegen;intensiv pflegen;liebevoll umsorgen;(sich) intensiv kümmern um
-heißersehnt;lang erwartet;sehnsüchtig erwartet;lang ersehnt;heiß ersehnt
-mit Futter anlocken;mit Futter an den Menschen gewöhnen;anfüttern
-(eine) Gelegenheit ergreifen;(eine) Gelegenheit wahrnehmen;auf ein Angebot eingehen
-sicher sein können;alles richtig machen (ugs.);nichts riskieren;(die) Sicherheit haben, dass;kein Risiko eingehen;auf der sicheren Seite sein (mit)
-Inspektor;Prälat;Superintendent;Dekan;Dechant;Propst;Präses
-gebundene Aufgabe;geschlossene Aufgabe;maschinell-auswertbare Aufgabe;Multiple-Choice-Aufgabe;programmierte Aufgabe
-todbringend;unheilbringend;Verderben bringend;unheilvoll;Unheil bringend;fatal;verhängnisvoll
-Thema (Forum, Newsgroup);Thread (Forum, Newsgroup) (fachspr., Jargon);Diskussionsfaden;Themenstrang
-Nur Bares ist Wahres. (sprichwörtlich);Bargeld lacht! (sprichwörtlich)
-Militärsport;Wehrsport
-Reichsausbildungslager;Wehrertüchtigungslager
-O-Marsch (Kurzform);Orientierungsmarsch
-(etwas) albern finden;nur müde lächeln können (über) (fig.);(etwas) lächerlich finden
-(etwas) uninteressant finden;(etwas) langweilig finden;nur ein müdes Lächeln übrig haben (für) (fig., variabel)
-sehr langweilig;schrecklich langweilig;schnarchlangweilig;zum Sterben langweilig (übertreibend);sterbenslangweilig (übertreibend);tödlich langweilig (übertreibend);todlangweilig (übertreibend)
-(das) kannst du vergessen (mit);(jemand) braucht erst gar nicht anzukommen (mit) (ugs.)
-nicht rosig (ugs., fig.);wenig aussichtsreich (sein);(sich) keine Hoffnungen (zu) machen (brauchen);wenig erfolgversprechend (sein);wenig vielversprechend (sein)
-Käseprodukte;Gelbe Linie (Molkereiprodukte) (fachspr.)
-Weiße Linie (Milchprodukte) (fachspr.);weiße Molkereiprodukte
-Prairial (franz.);Wiesenmonat
-Blütenmonat;Floréal (franz.);Blumenmonat
-Erntemonat;Messidor (franz.)
-Nebelmonat;Brumaire (franz.)
-Reifmonat;Frostmonat;Frimaire (franz.)
-Germinal (franz.);Keimmonat
-Fruchtmonat;Fructidor (franz.)
-Thermidor (franz.);Hitzemonat
-Weinlesemonat;Vendémiaire (franz.);Weinmonat
-Schulschwänzen;Schulverweigerung;Schulmüdigkeit
-herausziehen;entfernen;ausjäten;ausrupfen;ausraufen;herausrupfen;(Unkraut) ziehen (ugs.);jäten;herausreißen;ausreißen;auszupfen
-Bleibe im Lande und nähre dich redlich. (sprichwörtlich);Warum in die Ferne schweifen? Sieh, das Gute liegt so nah.
-überwindbar;bewältigbar;niederzuzwingen;niederzuringen,;in den Griff zu bekommen;beherrschbar;besiegbar;bezwingbar
-Gesindehaus;Häuslingshaus
-Einfamilienhaus;Einfamilienwohnhaus;Familienhaus
-Reihenhaus;Reiheneinfamilienhaus (schweiz.)
-Domfreiheit;Domsfreiheit;Domimmunität
-Domdechant;Domdekan
-zweites Partizip (lateinische Grammatik);PPP (lateinische Grammatik);Partizip Präteritum Passiv (lateinische Grammatik);Partizip Perfekt Passiv (lateinische Grammatik)
-Kaufneigung;Kauflust;Kaufinteresse
-Schiffmühle;Schiffsmühle
-Barbaresken-Pirat;Barbaresken-Korsar
-philosophisch;gesinnungsmäßig;ideologisch;weltanschaulich
-Neurotizismus;emotionale Labilität eines Charakters
-kaufsüchtig;kauflustig;kaufbegierig;kaufwillig
-per Gericht durchsetzen;einklagen;gerichtlich erstreiten
-Partizip Perfekt;Partizip II;Mittelwort der Vergangenheit (fachspr., veraltet)
-Partizip Präsens;Partizip I;Mittelwort der Gegenwart (fachspr., veraltet)
-religionsartig;religionshaft;religiomorph (geh., selten);quasireligiös;pseudoreligiös (ugs., abwertend)
-auf den Glauben bezogen;auf die Religion bezogen;Glaubens-;religiös;Religions-
-Kreuzweg;Prozessionsweg
-Tieflochbohrer;Tiefbohrer
-Forstnerbohrer;Astlochbohrer (ugs.)
-Spiralwinkel;Drallwinkel
-Leistung bringen (müssen);Ergebnisse sehen wollen;(seine) Zusagen in die Tat umsetzen;liefern (müssen) (fig.);(seine) Ankündigung(en) umsetzen;am Zug sein (fig.)
-Propagandafeldzug;Kreuzzug (gegen) (fig.);Feldzug (gegen) (fig.);Kampagne;Kampf (gegen)
-Startsignal;Weckruf (fig.);Signal zum (...);Fanal
-(jemanden) eine Vorstellung geben (von);(jemandem etwas) bildlich vor Augen stellen
-eine Vorstellung entwickeln von;(sich etwas) (bildlich) vorstellen können;eine Vorstellung haben (von);(sich) ein Bild machen können (von)
-hüftsteif;kreuzlahm;lendenlahm
-exklusivberechtigt (sein);alleiniger Rechteinhaber (sein)
-ausschließliches Nutzungsrecht;Exklusivrecht;alleiniges Nutzungsrecht
-(für jemanden) bereitstehend;(für jemanden) reserviert;(jemandem) vorbehalten;(für jemanden) frei gehalten
-Insektizid (fachspr.);Insektenbekämpfungsmittel;Insektenvertilgungsmittel;Insektengift
-Molluskizid (fachspr.);Schneckenbekämpfungsmittel
-Ostarmenien;Kaukasisch-Armenien
-Armenisches Königreich von Kilikien;Königreich Kleinarmenien
-Völkermord-Einnerungstag;Völkermordgedenktag
-Entfesselung der Marktkräfte;Entfesselung der Märkte
-(einen) Unfall bauen (ugs.);verunglücken;verunfallen (fachspr., Amtsdeutsch, Jargon);(einen) Unfall haben;(einen) Unfall verursachen
-in einen Unfall verwickelt (sein);Unfallbeteiligter (sein);an einem Unfall beteiligt (sein)
-(jemandem ist) übel;(jemandem ist) schlecht;(jemandem ist) speiübel;(jemandem ist) kodderig (ugs., norddeutsch);(jemandem ist) kotzübel (ugs.)
-Medizintheorie;Theorie der Medizin;Philosophie der Medizin
-Urteilsformel;Entscheidungsformel;Dispositiv (schweiz.);Spruch (österr.);Tenor
-Parteigängerkrieg;kleiner Krieg;Kleinkrieg
-Grenzbefestigung;Kordon
-nicht bearbeitet werden;brachliegen (auch figurativ);nicht beackert werden (auch figurativ)
-nicht genutzt werden;ungenutzt bleiben;brachliegen (auch figurativ)
-am Boden sein (fig.);brachliegen (fig.);am Boden liegen (fig.);nicht (wieder) in Gang kommen (fig.);darniederliegen (fig.)
-alles, was jemand hat;Haus und Hof (fig.);(jemandes) gesamtes Vermögen;(jemandes) ganze Habe;alles, was jemand besitzt;(jemandes) gesamter Besitz;aller Besitz
-Entenschnabel;Entenkopf
-Ivorischer Bürgerkrieg;Bürgerkrieg in der Elfenbeinküste
-hautnah (fig.);aus nächster Nähe;aus unmittelbarer Nähe;aus kürzester Distanz;aus kurzer Entfernung;aus der Nähe;aus (sehr) kurzer Distanz
-Deputat (lat.);Sachleistung
-nicht zimperlich (sein);es geht zu wie im wilden Westen;es herrschen raue Sitten (variabel);es geht wild zu (variabel);(da) wird nicht lange um Erlaubnis gefragt (ugs.);(die Leute sind) hart drauf (ugs.)
-(seine) Tollität;Karnevalsprinz
-bis in die (aller)jüngste Vergangenheit;bis neulich;es ist noch nicht lange her, dass;es ist noch gar nicht (so) lange her, dass;bis vor kurzer Zeit;bis vor kurzem (Hauptform);bis letztens;es ist noch nicht allzu lange her, dass;bis vor nicht allzu langer Zeit;bis kürzlich;bis vor gar nicht langer Zeit
-gestrigen Abends (geh., veraltet);gestern Abend
-in den letzten (...);die letzten (...) (ugs.);in der letzten Zeit;die letzte Zeit (ugs.)
-einen Tag zuvor;tags zuvor;am Vortag;am Vorabend (eines Ereignisses);am vorhergehenden Tag;einen Tag davor;am Tag davor
-(jemandem) sein Herz ausschütten;(seine Sorgen) abladen bei (fig., variabel);(sich) ausweinen bei (auch figurativ);(jemandem) sein Leid klagen;(seinen Frust) rauslassen bei (ugs., variabel);(sich) auskotzen (derb, fig.);(jemanden) behelligen mit;(jemandem) die Ohren volljammern (ugs.)
-(ein) Tête-à-Tête;(ein) trautes Zusammensein (zu zweit)
-wie eine Kerze an beiden Enden brennen;sich überanstrengen;sich überfordern
-(ein) Ventil finden (fig.);(sein) Mütchen kühlen (an) (geh., veraltend);(sich) abreagieren an;(seine) Wut auslassen an
-(etwas) loswerden (wollen) (ugs., fig.);(jemandem) sein Herz ausschütten;(sich) etwas von der Seele reden (Hauptform);(jemanden) brauchen, dem man etwas erzählen kann
-Milzbrandimpfstoff;Anthraximpfstoff
-Attenuierung;Attenuation;Virulenzminderung
-antigene Determinante;Epitop
-Immunogenizität;Immunogenität
-(sich) aussprechen (Hauptform);alles auf den Tisch legen (fig.);offen (miteinander) reden;(mit) nichts zurückhalten;mit nichts hinter dem Berge halten (fig.);(die) Karten auf den Tisch legen (fig.);alles kommt auf den Tisch (fig.)
-(jemandem) sein Herz öffnen (fig.);sagen, was los ist (ugs.);(sich) mitteilen;(sich) öffnen (fig.)
-(ein) Anliegen äußern;(den) Wunsch äußern (dass / zu);was sagen (sag doch was!) (ugs.);(nur) sprechenden Menschen kann geholfen werden (ugs., Redensart);sagen, was man will (ugs., Hauptform)
-das (eine) muss man ihr lassen;ich muss schon sagen! (ugs., floskelhaft);das (eine) muss man ihm lassen (ugs.);man kann sagen, was man will, aber;das (eine) muss man dir lassen (ugs., floskelhaft);das (eine) muss man Ihnen lassen (ugs.)
-ausgeworfen;ausgereihert (umgspr.);ausgekotzt (derb);ausgerülpst;erbrochen
-Konvertierbarkeit;Konvertibilität
-Zechine;Dukat;Zecchine
-Courantmünze (veraltet);Kurantmünze;Courantmüntze (veraltet)
-genießbar;essbar;zum Verzehr geeignet;verzehrbar
-(etwas) ehrt jemanden;(jemandem) nicht hoch genug angerechnet werden können;(jemandem) alle Ehre machen;es ehrt dich, dass;(jemandem) zur Ehre gereichen (geh.);es ehrt dich, wenn;(etwas) spricht für (jemanden);(jemandem) hoch anzurechnen sein;für jemanden sprechen;(mit etwas) gut dastehen vor (ugs.)
-Domsingknaben;Sängerknaben;Knabenchor
-bedenken;(sich in Gott und/oder sein Werk) versenken;nachsinnen;(sich Gott und/oder sein Werk) bewusst machen;kontemplieren
-(sich etwas) nicht länger bieten lassen;Genug ist genug. (Redensart);(jemandem) wird es zu bunt
-ordentlich verdienen (an etwas) (ugs.);auf seine Kosten kommen;(einen) guten Schnitt machen;seinen Schnitt machen
-sich auf jemandes Kosten amüsieren;(jemandes) Gutmütigkeit ausnutzen;(jemanden) verarschen (wollen) (derb);(jemanden) zum Narren halten;(jemanden) für dumm verkaufen (wollen)
-Sitemap (engl.);Seitenübersicht;Siteübersicht
-ein ganz Lieber sein;eine ganz Liebe sein;lammfromm sein (fig.);(jemandem) aus der Hand fressen (auch figurativ);ganz lieb sein
-Schreibpapier;Kopierpapier;Druckerpapier
-(sich) nicht bemühen;(sich) nicht (besonders) anstrengen;(sich) kein Bein ausreißen
-(etwas würde) jemandem gut zu Gesicht stehen;(sich) keinen Zacken aus der Krone brechen;(etwas) ist nicht zu viel verlangt;(sich) nichts vergeben (mit / bei) (ugs.);(jemandem) bricht kein Zacken aus der Krone (bei / wenn) (fig.);(etwas) kann man von jemandem erwarten;(etwas) ist nicht unter jemandes Würde;(jemandem) fällt kein Stein aus der Krone (bei / wenn) (fig.)
-Knowhow-Verlust;Wissensverlust;Know-how-Verlust
-Doppelbund;Gagernscher Doppelbund
-Blutnacht von Genf;Unruhen von Genf
-Frontenbewegung;Frontismus
-Fröntler;Frontist
-Siebenerverein;Polizeikartell;Geheimer Polizeiverein
-Reichskommissär;Reichsbevollmächtigter;Reichskommissar
-Reichstag (zeitgenössisch);deutsches Nationalparlament (zeitgenössisch);Reichsparlament (zeitgenössisch);Frankfurter Nationalversammlung
-Beluga (wissenschaftlich);Weißwal
-herrenlos (Tier) (Hauptform);frei (umher)schweifend (geh., auch figurativ);streunend;frei herumlaufen(d)
-Idiotenhügel (ugs., scherzhaft-ironisch);Verkehrsübungsplatz (Hauptform)
-Idiotenhügel (ugs., scherzhaft-ironisch);Anfängerhügel (Ski);Anfängerpiste
-Ley-Linie;Heilige Linie
-Geomantik;Geomantie
-(jemandem) nicht zustehen;(sich) heraushalten sollen (aus);nicht das Recht haben (zu);nicht jemandes Angelegenheit sein (variabel);(sich) um seine eigenen Angelegenheiten kümmern (sollen)
-(etwas) nicht haben können (ugs., variabel);(jemandem) (körperlich) unangenehm sein (Hauptform);(eine) Gänsehaut bekommen (wenn) (auch figurativ);(jemandem) rollen sich die Fußnägel auf (bei / ,wenn ...) (ugs., fig., floskelhaft);(etwas) nicht mögen;nicht stillhalten können bei
-mit (kaum) unterdrückter Wut;mit stiller Wut (variabel);mit der Faust in der Tasche (fig.)
-rechtes Verhältnis;Eurhythmie;Ausgewogenheit;Wohlproportioniertheit;Ebenmaß;Harmonie
-Joseftag;Seppitag (schweiz.);Josefitag;Josephinentag (selten, österr.);Josefstag;Josefi (bayr.)
-Zubereitung;Mixtur
-Auslandswährung;ausländische Währung;Fremdwährung
-Guthaben in Fremdwährung;Devisen
-schilpen;tschilpen;tschirpen
-zuletzt;zum Schluss;am Ende;im Abgang (geh., Jargon, auch figurativ);abschließend;als letzten Punkt;als Abschluss
-Urfehde;Unfehde;Urpfedt;Gelöbnis (geh.);Treueschwur (geh.);Urphed;Urphede
-Urfehde schwören,;Verzicht auf Rache geloben
-Friedensurkunde;Urkunde über Annahme der Strafe;Urkunde über Verzicht auf Rache;Urfehdebrief
-Pantomime;Pantomimin;Mimus;Mimiker;Verwandlungskünstler
-mimisch;schauspielerisch;darstellerisch
-sprachlose Verständigung;Kinesik
-erbittern;erzürnen;verdrießen (geh.);aufbringen;kränken;erbosen;verärgern;schmerzlich berühren;entrüsten
-Kartothek;Zettelkasten
-auspflügen;ausackern;auszackern
-nicht auf Zack (ugs.);nicht schnell genug (sein);nicht schnell genug schalten (ugs.)
-abkarten (negativ);insgeheim vereinbaren;gemeinsam aushecken (negativ);(sich) (unerlaubterweise) absprechen
-man hört nur Gutes (von);man hört viel Gutes (von);sehr gelobt werden;von allen Seiten gelobt werden
-es gibt (da) nur ein Thema (ugs.);man spricht von nichts anderem;(den) Hauptgesprächsstoff bilden;Stadtgespräch sein;Gesprächsthema Nr. 1 (sein);nur ein Thema kennen;Hauptgesprächsstoff sein;von nichts anderem reden
-(die) Zeichen der Zeit erkennen;wissen, was zu tun ist;(die) Lage richtig einschätzen
-Schrott;Alteisen;Altmetall;altes Eisen
-durch Recycling gewonnenes Material;Sekundärrohstoff;durch Rückgewinnung hergestellter Rohstoff
-Internationale Brigade;Interbrigade (Kurzform)
-Spanischer Bürgerkrieg;Spanienkrieg
-Gebrauchttextilien (Plural);Altkleider (Plural);ausgemusterte Kleidung;Lumpen (abwertend);Alttextilien (Plural)
-(sich) einem (allgemeinen) Trend anschließen;auf den fahrenden Zug aufspringen (fig.)
-seine Zeit brauchen;(sich) nicht im Handumdrehen erledigen lassen;nicht von heute auf morgen gehen;nicht von einem Tag auf den anderen (zu schaffen sein)
-einen langen Atem brauchen (fig.);nicht so schnell aufgeben (dürfen);Durchhaltevermögen brauchen
-reinspringen (ugs.);hineinspringen;reinhüpfen (ugs.)
-Kann mir mal (bitte) jemand erklären ... (ugs., Spruch, floskelhaft);Was ist (hier) auf einmal los?;Hab ich (irgend)was verpasst? (Spruch, variabel);Was geht denn jetzt (auf einmal) ab? (ugs.)
-Wie stehe ich (denn) jetzt (vor meinen Leuten) da!?;Was sollen die Leute denken?;Das könnt ihr doch nicht (mit mir / uns) machen!;Wie sieht das denn aus, wenn (...)
-Da bist du nicht der einzige.;Da bist du nicht der erste,;Da bist du nicht die erste.;Da bist du nicht die einzige.;Willkommen im Club. (ugs., Spruch, fig.)
-(sich) verletzt haben;verletzt sein;(sich was) getan haben (ugs.)
-Wortführer;Gesprächsleiter
-Versammlungsleiter;Sitzungsleiter;Leiter des Meetings
-(etwas) nicht für sich behalten können;(eine) Klatschbase sein;(etwas) (unbedingt) weitererzählen müssen
-Elektronikschrott;Altgeräte;Elektronikmüll;Elektromüll;Elektroschrott (Hauptform);ausgemusterte Elektrogeräte
-Geldkarte (Hauptform);(mit Guthaben) aufladbare Karte
-interessiert sein an;(sich) interessieren für;spitz sein auf (ugs.);(ganz) heiß sein auf (ugs.);(etwas) wollen;geil sein auf (derb);unbedingt haben wollen;(etwas) kriegen wollen (ugs.);Begehrlichkeiten wecken (floskelhaft, mediensprachlich);an etwas (heran)kommen wollen;(sich etwas) grapschen wollen (ugs.);(sich etwas) krallen wollen (ugs., salopp);an sich bringen wollen;in seinen Besitz bringen wollen;scharf sein auf (ugs.);(sich etwas) schnappen wollen (ugs.);hinter etwas her sein wie der Teufel hinter der armen Seele (Verstärkung);hinter etwas her sein (ugs.);(sich) etwas unter den Nagel reißen wollen (ugs., fig.);(sich etwas) an Land ziehen wollen (ugs.);(etwas) haben wollen (Hauptform)
-Zimtapfel;Süßsack;Rahmapfel
-Grafenfrucht;Araticum
-(jemandem) ans Geld wollen;es auf jemandes Geld abgesehen haben;auf jemandes Geld aus sein;(jemanden) um sein Geld bringen wollen
-schon lange suchen nach;schon lange gesucht haben nach;hinter etwas her sein
-Was hast du (jetzt) auf einmal? (ugs.);Was ist denn auf einmal los mit dir? (ugs.);Was ist denn plötzlich in dich gefahren? (Hauptform);So kenne ich dich ja gar nicht!;Du bist ja gar nicht wiederzuerkennen! (variabel)
-Geht's dir (auch wirklich) gut? (ugs.);Alles in Ordnung mit dir? (ugs.)
-(ein) Nichts (fig.);(ein) Nichtswürdiger;(eine) Null
-Puzzleteilchen;Puzzlestück;Puzzleteil;Puzzlesteinchen
-fehlendes Puzzlestück (fig.);fehlendes Puzzleteil (fig.);Missing Link (engl., fig.);fehlendes Glied in der Beweiskette
-aus der Mode kommen;außer Gebrauch kommen;unüblich werden;kaum noch benutzt werden
-(mit etwas) keinen Hund mehr hinter dem Ofen hervorlocken (können) (fig.);(es ist) Gras über die Sache gewachsen (fig.);(es) kräht kein Hahn mehr (nach) (fig.)
-Entfacher;Auslöser;Anfacher;Impulsgeber;Initiator
-schwierige Anfänge (Hauptform);Geburtswehen (fig.)
-Tory;(britischer) Konservativer
-Abwärtsspirale;immer weiter zunehmende Verschlechterung;(nicht aufzuhaltende) Verschlechterung
-kein Ende finden (mit einem Wortbeitrag);(sich) seitenlang ergehen (über);breit darstellen;(sich) in epischer Breite auslassen (über) (Hauptform, ironisierend);erschöpfend behandeln;in aller Ausführlichkeit (darstellen) (variabel);ausführlich eingehen auf
-auskunftsfreudig;gesprächsbereit;mitteilsam;kommunikationsstark (Jargon);kann gut reden (ugs.);kommunikativ
-passen in;reingehen (ugs.);gehen in (ugs.);hineinpassen (Hauptform);reinpassen (ugs.);hineingehen
-(sich) unter Druck gesetzt fühlen (fig.);(sich) gedrängt fühlen (geh.);(sich) genötigt fühlen (zu);(sich) bedrängt fühlen;(sich) in die Enge getrieben fühlen (fig.);(sich) eingeengt fühlen
-(sich) in den Kopf gesetzt haben;(für jemanden) selbstverständlich sein;für jemanden feststehen;(sich) kapriziert haben auf;(sich) festgelegt haben (auf);(für jemanden) sonnenklar sein;nicht in Frage stehen (für);(sich) fest vorgenommen haben
-Egal ist 88. (Spruch);Das ist (überhaupt) nicht egal.
-Kommt immer drauf an, wer das sagt.;Wenn zwei das gleiche sagen, ist es noch lange nicht dasselbe. (sprichwörtlich)
-den Kopf durch die Tür stecken (auch figurativ);(kurz) den Kopf zur Tür hereinstecken (um etwas zu fragen);kurz hereinschauen;den Kopf reinstecken (ugs.);kurz reinschauen (ugs.);den Kopf hereinstecken
-(sich) gegenseitig runterziehen;(sich) gegenseitig nach unten ziehen;(sich) gegenseitig (immer weiter) nach unten schaukeln
-Flächenkartogramm;Flächenwertstufenkarte;Choroplethenkarte
-angewandte Karte;thematische Karte
-(jemandem) immer besser gefallen;mit wachsender Begeisterung (auch ironisch);mehr und mehr Spaß finden (an)
-Taylor-Kegel;Taylor-Konus
-(die) Räder schräg stellen;(die) Räder einschlagen;(die) Lenkung einschlagen;(das) Lenkrad einschlagen
-einschlagen (Blitz);fahren in (Blitz)
-(jemanden) totprügeln;(jemandem) den Schädel einschlagen;(jemanden) erschlagen (Hauptform);(jemanden) totschlagen
-(eine) Route nehmen;(einen) Weg einschlagen (nach) (auch figurativ);(einen) Weg nehmen (nach);Kurs nehmen auf
-der Hit sein (ugs.);gut einschlagen (fig.);großen Anklang finden;(ein) Erfolg sein (Hauptform);einschlagen wie eine Bombe (ugs.)
-(die abzusehende) Niederlage nicht verhindern können;(das) Verhängnis nicht aufhalten können;(das) Blatt nicht (mehr) wenden können (fig.)
-das Schlimmste hinter sich haben (ugs.);es geht wieder aufwärts;(das) Schlimmste ist überstanden;(das) Blatt hat sich gewendet (fig.);(die) Talsohle ist durchschritten (fig.)
-(das) Blatt wenden (fig.);(wieder) auf einen aufsteigenden Ast kommen (fig.);(ein) Spiel drehen (Fußball o.ä.) (fig.);wieder Oberwasser bekommen (fig.)
-in (großer) Ungewissheit;zwischen Bangen und Hoffen
-unzivilisiertes Benehmen;nicht die feine englische Art (fig., verhüllend);Flegelhaftigkeit(en);keine Art (und Weise)! (ugs.);schlechtes Benehmen (Hauptform);(ein) Benehmen wie eine offene Hose (ugs.);unzivilisiertes Verhalten;kein Benehmen (ugs.);Ungezogenheit(en);Ungehörigkeit(en) (geh.);schlechtes Betragen;Fehlverhalten;Ungebührlichkeit(en) (geh.);nicht gentlemanlike (variabel, verhüllend)
-vollkommen rund laufen;absolut störungsfrei arbeiten;schnurren wie ein Kätzchen (Motor);nicht den kleinsten Aussetzer haben
-(etwas war) noch nicht das letzte Wort;Wir sprechen uns noch! (drohend)
-es kommen schwierige Zeiten (für);(sich) warm anziehen (können / müssen / sollen) (fig.);es knistert im Gebälk (des / der) (fig.);(sich) auf etwas gefasst machen (können / müssen / sollen) (ugs.);(sich) vorsehen (müssen / sollen)
-von Gräten befreien;ausgräten;entgräten
-vom Band laufen;fertig werden (ugs.);fertiggestellt werden
-(unser) Haus- und Hof-... (scherzhaft);... meines Vertrauens;(unser) Haus...
-es weht ein neuer Wind (fig.);... alte ... nicht mehr (variabel);nicht mehr weitermachen können wie bisher (floskelhaft);es weht (jetzt) ein anderer Wind (fig.);(sich) etwas Neues einfallen lassen müssen;Das Blatt hat sich gewendet. (fig.);... neue Situation ... (variabel)
-schlechteste Leistung;Tiefpunkt;schlechtestes Ergebnis
-(gut) eingespieltes Team (sein) (fig.);(sich) (gegenseitig) die Bälle zuwerfen (fig.)
-(man) möchte meinen;(man) sollte glauben;geneigt sein, anzunehmen (geh.);(...) eigentlich sollte
-sich offenbaren;sich anvertrauen
-(die) Festangestellten;Stammbelegschaft
-Mitarbeiter in einem befristeten Arbeitsverhältnis;befristet Beschäftigte(r);Mitarbeiter mit einem befristeten Arbeitsvertrag
-Wieso lachst du jetzt (überhaupt)?;Was gibt's denn da zu lachen? (ugs.)
-Politik der großen Geste(n);Symbolpolitik
-das ist nicht komisch;ich versteh den Witz (an der Sache) nicht (ugs.);was gibt's da zu lachen!? (ugs.);ich verstehe nicht, was es da zu lachen gibt! (verärgert) (ugs., variabel)
-(sich) engagieren für / gegen;aufstehen für / gegen (fig.);(sich) einsetzen für / gegen;eintreten für / gegen
-taktische Spielchen (abwertend);Taktiererei(en) (abwertend)
-guck (gefälligst) woanders hin!;was gibt's (denn) da zu gucken!?;guck weg!;glotz nicht so (blöd)! (derb)
-Länder des Globalen Südens;(wirtschaftlich) unterentwickelte Länder;(die) Dritte Welt (ugs.);Entwicklungsländer
-westliche Industrieländer (Hauptform);(hoch)entwickelte Industriestaaten;(die) Erste Welt (selten)
-(die) Vierte Welt (Hauptform);die (wirtschaftlich) am wenigsten entwickelten Länder (der Welt)
-Land im Übergang (vom Entwicklungsland) zum Industrieland;Schwellenland (Hauptform)
-Transformationsgesellschaft(en);ehemalige Ostblockstaaten;Zweite Welt;Transformationsstaat(en)
-chill mal dein Leben! (ugs., jugendsprachlich);(jetzt) mach hier keinen Stress!;jetzt komm mal wieder runter! (ugs.);lass mich damit in Ruhe!;was willst du von mir! (aggressiv);was regst du dich (so) auf! (ugs.)
-geschmäht als;verschrien als;heruntergemacht zu;abgewertet zu;verächtlich gemacht als
-Zugangsweg;Zugang;Einfallstor (fig.);Angriffspunkt;Zugangsmöglichkeit
-(irgendwo) Unterschlupf finden;(irgendwo) unterkommen
-(sich) gefallen in der Rolle (des/eines/der/einer);(sich) in die Pose eines (einer ...) werfen;(sich) gefallen in der Pose (des/eines/der/einer);(sich) gerieren (als) (geh.);(sich) inszenieren (als);(sich) aufführen (als);(sich) präsentieren;(sich) darstellen
-(ein) Robin-Hood (fig.);Rächer der Enterbten (fig., scherzhaft-ironisch);Kämpfer gegen die Ungerechtigkeit der Welt (übertreibend);Anwalt der kleinen Leute (auch figurativ)
-Volksheld;populäre Figur
-Schlunze;Schlampe (derb);unordentliche Frau;Chaotin
-zu seinem Recht kommen;sein Recht durchsetzen;sein Recht bekommen
-abreißen (Verbindung zu);(jemanden) aus den Augen verlieren;nicht länger in Kontakt stehen;keinen Kontakt mehr haben zu
-langsamer fahren;(den) Fuß vom Gas nehmen
-Scheißspiel! (ugs.);Pech gehabt!;so'n Pech aber auch! (ugs.);dumm gelaufen (ugs.);(das war) (einfach) Pech!;shit happens (engl.);kann passieren;da hast du einfach Pech gehabt (ugs.)
-keine Aufgabe haben;Däumchen drehen (müssen);nichts zu tun haben;herumhängen (ugs.);rumhängen (ugs.)
-nicht wirklich;kein richtiger (keine richtige, kein richtiges);trügerisch;sieht nur so aus;(nur) angetäuscht (ugs., fig.);kein echter (keine echte, kein echtes);nicht echt
-unmittelbar einsatzbereit;sofort verfügbar
-kurvenreiche Bergstraße;Serpentinenstraße;Serpentine
-Reste ficken (vulg., abwertend);nehmen, was übrig bleibt (für Sex)
-Kollegstufe;reformierte Oberstufe
-Estnischer Selbständigkeitskrieg;Estnischer Freiheitskrieg
-tingeln von (...) zu (...);ziehen von (...) zu (...);herumgereicht werden (fig.);wandern von (...) zu (...);tingeln durch (alle)
-weitergeben;dem nächsten geben (der nächsten geben);von Hand zu Hand gehen;weiterreichen;herumreichen
-Kontrollfreak;zwanghaft kontrollsüchtig
-über alles die Kontrolle behalten wollen;alles unter Kontrolle haben wollen
-(ein) Zweihundertprozentiger (ugs.);Perfektionist;(ein) Hundertprozentiger (ugs.)
-handeln von;das Thema ist;Thema sein;behandeln;es geht um (in einem Text / Film / Gespräch ...);zum Thema haben;thematisieren
-(künstlerische) Aktion;Happening;Aufführung;(künstlerische) Darbietung;Performance (engl.)
-Hausesel;Grautier;Esel;Equus asinus (fachspr., lat.)
-Lasttier;Saumtier;Tragtier;Tragetier
-Arabisches Kamel;Dromedar (Hauptform);Camelus dromedarius (fachspr., zoologisch);Einhöckriges Kamel
-Milchvieh;Milchlieferant
-Mähre (derb, abwertend);Schindmähre (ugs., abwertend);Brauereigaul (derb, abwertend);schlechtes Pferd (Hauptform);Kracke (ugs., abwertend);Schabracke (ugs., abwertend);Gaul (ugs., abwertend);Klepper (derb, abwertend)
-den Kopf wegdrehen;den Blick abwenden
-(jemandem) in die Augen schauen (variabel);(jemandem) ins Gesicht sehen;(jemanden) ansehen
-(jemandes) Blicke treffen sich;(jemandes) Blicke kreuzen sich;Blickkontakt haben
-(sein) Augenmerk richten auf;seine Blicke (irgendwohin) heften;(irgendwohin) starren
-Lastverteilerwerk;Schaltwerk
-Zuckerstock (schweiz.);Zuckerhut (Hauptform)
-in Sorge;beunruhigt;in Unruhe (wegen);keine ruhige Minute haben (fig.);alarmiert;besorgt
-Heilsversprechen;Mantra (fig.)
-(jemandem) aus der Hand fressen (fig.);(jemandem) ganz ergeben sein;alles tun, was (jemand) von ihm will
-an jemandes Lippen hängen (fig., Hauptform);alles aufsaugen, was jemand sagt (variabel)
-(jemanden) mit Sorge erfüllen;(jemanden) besorgt machen;(jemandem) (den) Angstschweiß auf die Stirn treiben (ugs., scherzhaft-ironisch, übertreibend);(jemandes) Herz mit Sorge erfüllen (geh.);(jemandem) (die) Sorgenfalten auf die Stirn treiben
-um Haaresbreite (fig.);das war (denkbar) knapp;(das ist) gerade nochmal gutgegangen;om a Muggaseggele (ugs., schwäbisch);um ein Haar (fig.);es hätte nicht viel gefehlt, und (...)
-darunter tut es (jemand) nicht;(das ist) das Mindeste (was man erwarten kann);(so viel) ist sich jemand schuldig
-Blondinenwitz;Herrenwitz;Witz auf Kosten der Frauen
-nicht unter Kontrolle haben;(...) geht mit ihm durch
-(etwas ist / wäre) zu schön, um wahr zu sein;(jemandes) Phantasie geht mit ihm durch;(da) ist (wohl) der Wunsch der Vater des Gedankens (Redensart);Wunschdenken sein
-in Serpentinen (verlaufen);(sich) winden;(sich) schlängeln;über Serpentinen (irgendwohin) führen
-Hand und Fuß haben (fig.);wohlüberlegt (sein);nicht nur so dahergesagt (sein);überlegt (sein);solide (sein)
-zählen können auf;vertrauenswürdig (sein);verlässlich (sein);(sich) verlassen können (auf)
-Handspiel;Hand (Fußball)
-Bildbruch (fachspr.);Katachrese (fachspr.);Kontamination (fachspr.);Metaphern-Mix (ugs.)
-angeschossen;kein Handspiel;nicht Hand (ugs.)
-(die) letzte vom Autor (selbst) autorisierte Fassung (variabel);(Ausgabe) letzter Hand (fachspr.)
-Ermessensangelegenheit;(etwas) kann (jemand) so oder so entscheiden (ugs.);in jemandes Ermessen liegen;Ermessenssache (ugs.)
-Ermessensspielraum;Entscheidungsrahmen;Entscheidungsspielraum;Handlungsspielraum
-(gerade) dabei sein, zu (...);damit beschäftigt sein, zu (...);gerade;am (...) sein (ugs.)
-ohne Widerrede;klaglos;ohne Widerspruch;ohne zu widersprechen;ohne zu protestieren;widerspruchslos
-Obmannschaft;Hauptmannschaft
-einen Vernichtungskampf führen (auch figurativ);niemanden verschonen;alle Feinde töten;keine Gefangenen machen
-gelängt;flaserig;gezerrt
-du bist mir vielleicht ein schöner (...) (ugs.);und sowas nennt sich (nun) (...)! (ugs.);du willst ein (...) sein? (ugs.);ein schöner (...) bist du! (ugs., variabel)
-ständig untertourig fahren;(einen Motor) sauer fahren (ugs., Jargon)
-erzieherisch;belehrend;pädagogisch;lehrerhaft
-zu blöd, dass (ugs.);ironischerweise;unglücklicherweise;nur dumm, dass (ugs.);was für ein Pech!;dumm (nur), dass;dummer Zufall (ugs.);nur blöd, dass (ugs.);Ironie des Schicksals (geh., Hauptform);Pech (dass);dummerweise;so ein Pech! (ironisch);fatalerweise
-reiner Zufall;nicht geplant;nichts miteinander zu tun haben;(nur ein) dummer Zufall
-Zufälle gibt's ...;was für ein Zufall!
-Schimpfkanonade;Wutrede;Schimpftirade;Wutgeheul;Rant (engl.)
-Hungerkatastrophe;Hungersnot;(gravierender) Mangel an Nahrungsmitteln;(extreme) Nahrungsmittelknappheit;Ernährungskrise
-empfindlich (negativ);besorgniserregend;schwer (negativ);schwerwiegend (negativ);dramatisch (negativ);drastisch (negativ);gravierend (negativ)
-authentisch;aufrichtig
-(sich) rücksichtslos nach vorne drängen;(sich) durcharbeiten;(sich) nach vorne dränge(l)n;(sich) (gewaltsam) schieben durch;(sich) quetschen durch;(sich) nach vorne kämpfen (auch figurativ);(sich) durchkämpfen;(sich) einen Weg bahnen;(sich) durchzwängen;(sich) durchquetschen;(sich) dränge(l)n durch;(sich) keilen durch;(sich) zwängen durch;(seine) Ell(en)bogen benutzen (auch figurativ, variabel)
-spuren;mitziehen;(sich) einfügen
-in echten Schwierigkeiten (sein);(jemandem) Kopfschmerzen bereiten (ugs., fig.);Probleme machen (die nicht so einfach zu lösen sind) (ugs., variabel);dann hast du ein Problem (ugs., Spruch, floskelhaft);in ernsten Schwierigkeiten stecken (mit);dann hab ich ein Problem (ugs., Spruch, floskelhaft)
-präparieren (Loipe);spuren (klassische Loipe);anlegen (Loipe)
-blondgeschopft;blondgelockt;blondschopfig;blondhaarig (Hauptform)
-wenn man keine Ansprüche stellt (variabel);für den einfachen Bedarf;für (den) privaten Bedarf;für den Hausgebrauch (reichen) (ugs., auch figurativ)
-Würgeengel (biblisch);Todesengel (biblisch)
-Gegenwartspräferenz;Zeitpräferenz
-auf unbestimmte Zeit verschoben werden;im Schwinden begriffen sein;(sich) weiter entfernen von;auf den Sankt-Nimmerleinstag verschieben (fig.);schwinden (lassen);(immer) unwahrscheinlicher werden (lassen);in weite Ferne rücken (lassen) (Hauptform)
-Torpedorohr;Torpedoausstoßrohr;ToRo (Abkürzung)
-in Mitleidenschaft ziehen;untergraben (Vertrauen, jemandes Ruf);angreifen (IT-Technik);beeinträchtigen (Vertrauen);beschädigen
-abwenden (können);zu verhindern wissen;abbiegen (können) (ugs.)
-stören;im Weg sein;(jemanden) behindern;sperrig herumstehen (geh.);im Weg(e) stehen
-(etwas) muss ein Ende haben (Hauptform);(etwas) muss aufhören;(etwas) darf kein Dauerzustand werden;(mit etwas) muss Schluss sein;(etwas) darf nicht (so) weitergehen
-verunmöglichen;zunichte machen;(jemandem) die Suppe versalzen (fig.);zu Fall bringen (Gesetzesvorhaben);(jemandes Plan) durchkreuzen;(jemandem einen) Strich durch die Rechnung machen (fig.);scheitern lassen;vereiteln (Plan);zunichtemachen;(jemandem) ein Schnippchen schlagen
-aushöhlen;unterhöhlen (geh.);aushebeln;erodieren lassen (geh.);untergraben;unterminieren;zersetzen;torpedieren;unterlaufen
-annihilieren;zunichtemachen
-Vorsichtsmaßnahmen ergreifen (gegen);vorbauen (fig.);(etwas) vorsehen;Vorkehrungen treffen (gegen);(sich) absichern gegen;vorsorgen (für);(sich) vorbereiten (auf);(einer Sache) vorbeugen (Hauptform);(einer Sache) zuvorkommen;Vorsorge treffen (gegen)
-(weiter) hinten liegender Raum;nicht einsehbarer (separater) Raum;Zimmer nach hinten (he)raus;Hinterzimmer (auch figurativ, Hauptform)
-(jemanden) auf dem Kieker haben (ugs., berlinerisch);(es auf jemanden) abgesehen haben;etwas von jemandem wollen (ugs.);ein Auge auf (jemanden) geworfen haben;hinter (jemandem) her sein;eine Beziehung beginnen wollen (Hauptform)
-Preisetikett;Preisschild;selbstklebendes Preisschild
-Theaterkasse;Kartenverkaufsstelle;Abendkasse;Ticketschalter;Kasse (ugs.);Kinokasse
-Tageskasse;Kartenverkauf;Kartenvorverkaufsstelle;Kartenvorverkauf
-Kartenschalter;Kartenausgabeschalter;Kartenausgabe
-(n-1)-Regel;(n-1)-Kriterium
-Stellschütz;Stellfalle
-Einstieg;Revisionsschacht;Kontrollschacht;Einstiegschacht
-Staatsgrenze;Bundesgrenze (fachspr.);Grenze (ugs.);Landesgrenze (schweiz.)
-Transatlantikliner;Atlantikliner
-Platzreservierung;Kartenreservierung
-dezimieren;verringern;(durch gewaltsamen Eingriff) stark vermindern
-(das sein,) was jetzt zu tun ist;(eine) dringende Notwendigkeit (sein) (Hauptform);(das) Gebot der Stunde (sein);(das sein,) was jetzt (dringend) geboten ist
-Putschversuch;Umsturzversuch
-(die) fünfte Kolonne (Schlagwort, fig.);(der) verlängerte Arm (fig.)
-Klugscheißerei (ugs.);Oberschlaumeierei;Besserwisserei
-zur Verärgerung (des / der ...) führen;böses Blut erzeugen (bei) (fig.);(jemanden) verärgern
-Spatha (fachspr.);Blütenscheide (fachspr.)
-wobei der letztere;welch letzterer (geh., altertümelnd, veraltend);wobei letzterer
-flügge;flugfähig;flugreif
-verramschen;(als) Restposten verkaufen
-als Remittende verkaufen (fachspr.);verramschen (Buchhandel) (fachspr., Jargon);als Mängelexemplar verkaufen (fachspr.)
-DNA-Profil;genetischer Fingerabdruck (fig.)
-DNA-Doppelstrang;DNA-Molekül;Erbgutträger;Chromosom
-(bestimmter) Erbfaktor;Gen (Hauptform);DNA-Abschnitt;(eine) Erbanlage
-singen (ugs., salopp, veraltet);quatschen (ugs., salopp);auspacken (ausplaudern) (ugs., fig., Hauptform, salopp);kooperieren;gestehen;geständig sein;(mit den Ermittlungsbehörden) zusammenarbeiten;alles verraten;kooperativ (sein) (verhüllend);reden
-(übel / ruppig / nicht zimperlich / hart / ...) umspringen (mit) (variabel);(jemanden mies / schlecht / übel / ...) behandeln (ugs.);(eine) linke Tour abziehen (mit) (ugs., salopp, variabel);(jemanden) behandeln wie einen Hund (ugs.);(jemanden) behandeln wie den letzten Dreck (ugs.);(jemanden) schlecht behandeln;(jemanden) behandeln wie Rotz am Ärmel (ugs.);(jemandem übel / hart / böse / ...) mitspielen;(jemanden) behandeln wie ein Stück Dreck (ugs.);(auf jemandem) herumtrampeln (ugs., fig.)
-(jemanden) nicht fair behandeln;(nur) dafür gut (genug) sein (zu) (ugs.);(jemanden) vor seinen Karren spannen (fig., selten);(jemanden) ausnutzen
-die (ganze) Innung blamieren (auch figurativ);eine Schande (für) (ugs.);(ein) schlechtes Licht werfen auf;schlecht dastehen lassen
-Insider (engl., Hauptform);(jemand) mit Einblick (in eine Szene);(einer) aus der Szene
-eine Bereicherung (für);ein Schmuckstück (fig.);eine Zierde (für);(sich) schmücken mit (fig.)
-ignorant;banausenhaft;ungebildet;kulturlos;niveaulos
-leckofanni (ugs.);Jesses! (ugs.);Himmel Herr! (ugs.);Meine Fresse! (ugs.)
-Vierliniensystem;Vierlinienschema;Hauptliniensystem
-Linienschema;Liniensystem
-Dreiliniensystem;Dreilinienschema
-Zweiliniensystem;Zweilinienschema
-Schützenscheibe (fachspr.);menschliche Silhouette aus Pappe;Pappkamerad (auch figurativ);Schießbudenfigur
-Vorzeige-Figur;Pappkamerad;Vorzeige-Person
-Surrogat (Sexualtherapie);Ersatzpartner
-Dummy;Puppe;Attrappe
-Familien...;für Familien geeignet;für die ganze Familie;familientauglich;familienfreundlich
-hochfliegende Pläne haben;etwas Großes schaffen wollen;Größeres erreichen wollen;ein großes Rad drehen wollen (fig.);nach Höherem streben;(sich) zu Höherem berufen fühlen;hoch hinaus wollen (fig.);(im Leben) etwas erreichen wollen
-Trapezunt;Tabzon
-Schaukelreck;Trapez;Hängereck
-Circuskunst;Artistik;Zirkuskunst
-Kippbild;Vexierbild;Umschlagfigur
-Mitstreiter;Mitmacher;Mitwirkender
-Glaubensbruder (männl.);Bruder im Glauben (männl.);Glaubensgenosse;Mit...;Glaubensschwester (weibl.)
-Tischdame (geh.);Tischnachbar;Tischherr (geh.);Tischgenosse
-Banknachbar;Person neben mir;Sitznachbar
-Mitbewohner;Wohngemeinschaftskollege;WG-Kollege
-offener Brief;Sendbrief;Sendschreiben
-Tauchpumpe;Söffelpumpe;Süffelpumpe
-Sitzordnung (Diner);Placement (geh., franz., selten);Tischordnung
-ungeschriebenes Gesetz (Hauptform);(das) gehört sich einfach (so) (ugs., positiv);(das) tut man einfach nicht (ugs., negativ);unausgesprochene Erwartung(en);informelle Verhaltensvorschrift
-ungeschehen machen wollen;(das) Rad (der Geschichte) zurückdrehen wollen (fig.);(sich) die (guten) alten Zeiten zurückwünschen;in die (guten) alten Zeiten zurückkehren wollen;rückgängig machen wollen
-polemisch werden;polemisieren (gegen) (geh., Hauptform);vom Leder ziehen (gegen);(sich) polemisch äußern;herablassend kritisieren
-Emotionen ins Spiel bringen;(zu) emotional reagieren;(sich) von Emotionen hinreißen lassen
-schlecht vorbereitet;inkompetent;unqualifiziert;nicht durchdacht;unkompetent (selten)
-nicht sachkundig;schlecht informiert;von keiner Sachkenntnis getrübt (ironisch);unqualifiziert;nicht qualifiziert;aus dem hohlen Bauch (heraus) (ugs., fig.);nicht informiert
-schriftlich niederlegen (Hauptform);kodifizieren;dokumentieren;verschriftlichen;schriftlich festhalten
-verklingen;verstummen;verhallen;abklingen;ausklingen
-Sammlung von Verhaltensregeln;Etikette;Benimmregeln;Knigge;guter Ton;Verhaltenskodex
-(sich) einlassen auf;(sich) überreden lassen (zu);(sich) breitschlagen lassen
-kommen (ugs.);(seinen) Bestimmungsort erreichen (Amtsdeutsch);ankommen;zugestellt werden;eingehen (Sendung, Geldüberweisung);(noch nicht / schon) da sein (ugs.);einlangen (österr.)
-durchdringen (bis) zu;ankommen bei (jemandem);(jemanden) erreichen (Information)
-(sich) zusammenziehen;eingehen (Textilwäsche);kleiner werden;schrumpfen;einlaufen
-vom Netz gehen (Internetseite) (ugs.);eingehen (Zeitschrift, Serie) (fig.);aus dem Programm genommen werden (Sendung, Serie);eingestellt werden (Hauptform);nicht fortgesetzt werden;nicht mehr produziert werden;nicht weitergeführt werden;vom Markt genommen werden (Zeitschriftentitel)
-aufgeben müssen;die Tore schließen müssen (fig.);(den) Stecker ziehen (ugs., fig.);den Geschäftsbetrieb einstellen;zumachen (müssen) (ugs.);eingehen (Kleinbetriebe) (ugs., fig.);aufhören (ugs.)
-ein Ohr haben für;Verständnis haben (für);(sich) verständnisvoll äußern;Verständnis zeigen;(auf jemanden) eingehen;(jemandem) zuhören;(jemanden) ernst nehmen;(sich) verständnisvoll zeigen
-bestimmte;spezielle;manche;gewisse
-Regularien;Reglement;Regularium;Regelwerk;Regelsammlung
-Fahrplan (fig.);Ablaufplan;Programm;Regie (fig.);vorgesehener Ablauf
-Ablaufplan(ung);Netzplan;Durchlaufterminierung (fachspr.);Vorgangsknotennetzplan;Projektplan
-Bedarfsaufstellung;Anforderungskatalog;To-do-Liste (zu erledigender Aufgaben);Lastenheft;Anforderungsliste (Hauptform);Pflichtenheft;Aufgabenliste;Leistungsverzeichnis;Pendenzenliste (unerledigter Aufgaben)
-Ehrbegriff;Auffassung von Ehre
-(das) Gehalt fortzahlen (Amtsdeutsch);(das) Gehalt weiter zahlen (ugs.);(jemanden / den Lohn / das Gehalt) durchbezahlen (ugs.);(den) Lohn weiter zahlen (ugs.);(den) Lohn fortzahlen (Amtsdeutsch);(das) Arbeitsentgelt fortzahlen (fachspr., juristisch)
-durchbezahlt werden (ugs.);keine Gehaltseinbuße(n) haben;keine Lohneinbußen haben;weiterbezahlt werden
-mitten drin (sein) (ugs.);mitten in (...) stecken;bis zum Hals stecken in (fig.);richtig angefangen haben (ugs.);in vollem Gang(e) (sein) (Hauptform);voll entbrannt sein (Streit, Machtkampf);schon ein gutes Stück vorangekommen sein
-es geht zügig voran (mit);zügig vorangehen;Fahrt aufgenommen haben
-brummen (Laden, Geschäft) (ugs.);auf Hochtouren laufen (Geschäft);Hochsaison haben (ugs.)
-noch (ganz) am Anfang stehen;noch nicht angefangen haben;noch nicht begonnen haben
-eingesetzt haben (Regen);angelaufen sein;begonnen haben;angefangen haben
-aufgehört haben (Regen);aus sein (Veranstaltung) (ugs.);zu Ende sein;beendet sein
-mittragen;verbal unterstützen;mit Rat und Tat unterstützen (variabel);Beistand leisten;ideell unterstützen;halten (zu);moralisch unterstützen;(jemandem / einer Sache) die Stange halten (ugs., fig.);(jemandem) zur Seite stehen;(jemanden) unterstützen;(jemandem) beistehen
-(jemandem etwas) schonend beibringen;(jemanden) so behutsam wie möglich davon unterrichten, dass;(jemanden) vorsichtig in Kenntnis setzen (von)
-(innerlich) in Aufruhr;verstört;aufgewühlt;(innerlich) zerrissen
-den Sack schlagen, aber den Esel meinen (geh., sprichwörtlich, variabel);(ein) Bauernopfer (sein);zum Sündenbock gemacht werden (variabel)
-(ein) stumpfes Schwert (sein);folgenlos bleiben;keinen Effekt haben;kein wirksames Gegenmittel darstellen;keine Wirkung zeigen;(sich) als wirkungslos erweisen
-Schmähung;Entehrung;Rufschädigung;Verunehrung;Schändung
-Laissez-faire-Einstellung;laxe Einstellung;Laissez-faire-Haltung;lasche Einstellung (ugs.)
-einführend;propädeutisch;vorbildend
-(emotional) intensiv;tief gehend;tiefgehend
-(jemanden) an den Hammelbeinen kriegen (ugs., fig.);(jemanden) an den Wickel kriegen (ugs., salopp);(jemanden) zu fassen bekommen;(jemandem) beikommen;(jemanden) drankriegen (ugs.);(jemanden) belangen;(jemanden) zu fassen kriegen (ugs.);(jemanden) an den Wickel bekommen (ugs.);(jemanden) am Arsch kriegen (derb)
-(jemandem) nichts wollen können (ugs.);(jemanden) nicht zu packen kriegen (ugs., salopp);nichts ausrichten können (gegen jemanden/etwas);(gegen jemanden) keine Handhabe haben;gegen jemanden nicht ankönnen (ugs.);(jemandem) nichts haben können (ugs.);(jemandem) nicht beikommen;nicht vorgehen können (gegen jemanden / gegen jemandes Machenschaften);nichts (Richtiges) gegen jemanden in der Hand haben;machtlos sein;(jemanden) nicht zu fassen kriegen (ugs.)
-ein erster Schritt;ein Anfang (sein);Türöffner (fig.);ein Anfang ist gemacht (variabel)
-es noch nicht geschafft haben;das Schwierigste liegt noch vor uns;noch nicht über den Berg (sein) (fig.);das Schwerste kommt noch;noch kein Durchbruch (sein) (fig.)
-Lichtjahre entfernt (fig.);sich nicht messen können mit;himmelweit entfernt (von)
-die Luft ist rein;niemand (sonst) zu sehen
-(einen) Maulkorb (verpasst) bekommen;(sich) nicht (frei) äußern dürfen
-(sich) betragen (geh.);(sich) verhalten (geh.);sich anstellen;(sich) benehmen;sich aufführen (ugs.);sich machen (ugs.)
-Graspflanze(n);Rasenpflanze(n);Gras
-Grassamen;Regelsaatgutmischung (fachspr.)
-(jemanden) kaltstellen (fig.);(jemanden) aufs Abstellgleis schieben (fig., variabel);(jemanden) ausschalten (fig.)
-(jemanden) abdrängen (fig.);(jemanden) ausbooten (fig.);(jemanden) auf die Seite drängen (fig.);(jemanden) an die Wand drücken (fig., variabel);(jemanden) beiseiteschieben (fig.);(jemanden) wegdrängen (fig.)
-nicht lebenswichtig (fig.);nicht überlebenswichtig (ugs., fig.);verzichtbar (Hauptform);schmückendes Beiwerk (fig.);nicht substanziell;überflüssiger Luxus;muss man nicht haben (ugs.)
-Rufnummergasse (fachspr.);Rufnummerraum (fachspr.);Rufnummerbereich
-Tageslosung (fachspr.);Tageskasse;Tageseinnahmen (Barkasse)
-stark;intensiv;kräftig;heftig (negativ);ausgeprägt;scharf
-(jemandem) den Mund verbieten;(jemandem) sagen, dass er den Mund halten soll;(jemandem) sagen, dass er still sein soll;(jemandem) sagen, dass er sich geschlossen halten soll
-auf einer Wellenlänge (sein);(zwischen ihnen) stimmt die Chemie;auf gleicher Welle liegen;gut miteinander auskommen;harmonieren;(sich) gut verstehen;ein Herz und eine Seele sein
-(jemandes) Gegenstück;(jemandes) Pendant;(jemandes) Gegenfigur
-Gesinnungsfreund;Gesinnungsgenosse;Sympathisant
-zu alt sein für;aus dem Alter heraus sein;aus dem Alter raus sein (ugs.)
-nicht ortskundig sein;nicht von hier sein (ugs.);sich (in einer Gegend) nicht auskennen
-(von etwas) keine Ahnung haben;(von etwas) nichts verstehen (Hauptform);nicht vom Fach sein;(jetzt) nicht der ...experte sein (ugs.);(sich mit etwas) nicht auskennen;nicht mitreden können (fig.);keine Kenne haben (ugs., regional, veraltend)
-durch die Rechtschreibprüfung induzierte Falschschreibung (variabel);Cupertino-Effekt
-Netter Versuch. (ugs., Spruch);Man kann's ja mal versuchen. (ugs.);War einen Versuch wert.
-Leistungsanforderung(en);Leistungserwartung(en)
-(jemandem) klingeln die Ohren;(jemandem) in den Ohren scheppern
-(jemanden) zu Hause besuchen;(einen) Hausbesuch machen;(jemandem) auf die Bude rücken (ugs.);(jemandem) einen Hausbesuch abstatten;(jemanden) an seinem Wohnsitz aufsuchen
-(sich) einigeln (auch figurativ);schanzen (fachspr., militärisch, veraltend);(sich) verschanzen (auch figurativ);(eine) Schanze anlegen (variabel);(sich) eingraben
-(sich) wegducken (fig.);versuchen, sich unsichtbar zu machen (fig.);keine Angriffsfläche bieten (wollen);in Deckung gehen
-nichts ausrichten können (gegen);(sich) nicht wehren können;über den Tisch gezogen werden (ugs., fig.)
-Besonnenheit;besonnenes Vorgehen
-nicht angemeldet sein (ugs., Jargon);am Finanzamt (und den Sozialkassen) vorbei arbeiten;schwarzarbeiten (Arbeitnehmer) (Hauptform)
-Stichblatt;Tsuba (fachspr., japanisch)
-Klingenspitze;Ort (Blankwaffe)
-kulturelle Integration;Enkulturation (fachspr.)
-Striezel;Dresdner Stollen;Christstollen;Rosinenstollen
-Ich bin mit meiner Geduld am Ende.;Meine Geduld ist am Ende.;Das Maß ist (gestrichen) voll.;Es reicht jetzt endgültig.
-Wir können auch anders! (ugs.);Ich kann auch anders! (ugs.);Es geht auch anders!;(jetzt) andere Saiten aufziehen (fig.);(von nun an) weht ein anderer Wind (Redensart);(jetzt) ist Schluss mit lustig (Spruch)
-das ist mein voller Ernst;Schluss mit dem Blödsinn (ugs.);es wird ernst;ich meine es ernst (diesmal);jetzt ist Schluss mit lustig (ugs.);genug herumgealbert (ugs.)
-Soll-Bestand;Sollbestand
-Baumwollbeutel;Stoffbeutel;Jutetasche (ugs.);Baumwolltasche
-Fischereischein (Amtsdeutsch);Angelschein (ugs.)
-es ist noch (...) hin (bis) (ugs.);es ist noch (...) Zeit (bis) (variabel)
-termingemäß;wie vereinbart;zum vereinbarten Zeitpunkt;vereinbarungsgemäß;zur festgesetzten Zeit;pünktlich (Hauptform);ohne zeitliche Verzögerung
-sehr pünktlich (Hauptform);exakt zum vereinbarten Zeitpunkt;pünktlich wie die Eisenbahn;pünktlich wie die Maurer;überpünktlich;superpünktlich
-meistens (tun) (ugs.);pflegen (zu) (geh.);neigen (zu);tendieren (zu)
-sein Bündel schnüren (scherzhaft, veraltend);sich (zum Weggehen / Abfahren) fertig machen;sich reisefertig machen;sich zum Abmarsch bereitmachen;seine Sachen (zusammen)packen;sich aufmachen (um abzureisen / wegzugehen)
-eine gewisse Zahl (von);einige (Hauptform);mehrere;nicht wenige;manche (Hauptform);schon ein paar (ugs.);etwelche (schweiz.);ein paar;schon so einige (ugs.)
-(eine) Spur der Verwüstung;(eine) Schneise der Verwüstung
-etliche;eine Reihe von;diese und jene;mehrere;eine Anzahl von
-eine beträchtliche Zahl an;eine ganze Reihe von;so einige (ugs.);recht viele (Hauptform);nicht gerade wenige;eine größere Anzahl von;eine beträchtliche Anzahl von
-(nur) sehr vereinzelt;höchst selten;extrem wenige;ganz vereinzelt
-(einer Sache) ausweichen können;(einer Sache) aus dem Weg gehen können (fig.);vermeiden können;(etwas) umgehen können;(sich) ersparen können;herumkommen (um);(jemandem) erspart bleiben
-(viel) kennenlernen;(sich viel) umsehen;(viel) sehen (von);(sich) viel(es) ansehen (ugs.);(viel) herumkommen
-viel in der Welt herumkommen;viel von der Welt sehen;(sich) den Wind um die Nase wehen lassen (fig.);(viel / lange) umherreisen;(viele Gegenden) bereisen;kreuz und quer reisen (durch);viel reisen (Hauptform)
-nichts mehr zu tun haben wollen (mit jemandem);(seine) Hand von jemandem abziehen;(jemandem) die weitere Unterstützung versagen;(jemanden) fallenlassen;(jemanden) fallenlassen wie eine heiße Kartoffel;(jemandem) seine Unterstützung entziehen;(jemanden) nicht weiter unterstützen
-auf Jahre hinaus;in den kommenden Jahren;für die nächsten Jahre
-auf nicht absehbare Zeit;für unbestimmte Zeit
-Kaprice (geh.);Stimmung;Anwandlung(en) (geh.);(ein) Anfall (von) (ugs.);Kaprize (geh.);Stimmungsschwankung (Hauptform);vorübergehende Gemütsverfassung;Aufwallung (geh.);Laune;Gemütsschwankung(en)
-es gongt;(der) Gong ertönt;(jemand) schlägt den Gong (an)
-(jetzt) fang nicht (schon) wieder damit an (ugs.);leg mal 'ne andere Platte auf (ugs., Spruch);man kann's (bald) nicht mehr hören (ugs., variabel)
-keinen Kontakt (mehr) haben;keinen Umgang (mehr miteinander) pflegen (geh.);nicht mehr (miteinander) in Verbindung stehen;(der) Kontakt ist abgerissen (fig.);(es herrscht) Funkstille (zwischen) (ugs., fig.)
-extrem wenig;in homöopathischen Dosen (fig.);verschwindend gering;im Promillebereich;kaum messbar;an der Nachweisbarkeitsgrenze
-wer hat (denn) vom Kuchen gesprochen, dass du Krümel dich meldest? (ugs.);wer hat dich denn gefragt? (ugs.);hast du auch (schon) was zu melden? (ugs., Spruch, variabel);(seit wann) hast du (hier) auch (schon) was zu melden? (ugs., Spruch)
-unversöhnlich;knallhart (ugs.);ultimativ;kompromisslos;ohne Wenn und Aber;konzessionslos;ohne Pardon (ugs.)
-Härte;null Toleranz;Kompromisslosigkeit
-Katalysator (Kurzform);Kat (ugs.);Fahrzeugkatalysator
-auf der Sonnenseite des Lebens stehen (fig.);(jemandem) scheint die Sonne aus dem Arsch (derb, fig.);es gut haben (ugs.);es gut getroffen haben;auf Rosen gebettet (sein) (fig.);(jemandem) geht es (finanziell / beruflich / ...) gut;keine Sorgen haben;(sich) keine Sorgen machen müssen
-viel Geld ausgeben;(sein) Geld mit vollen Händen ausgeben;(ein) großes Haus führen;(sein) Geld mit beiden Händen ausgeben (fig.);auf großem Fuß(e) leben (fig.);einen aufwendigen Lebensstil pflegen (variabel)
-Guandong-Armee;Kwantung-Armee
-Nilbarsch;Viktoriabarsch
-Deutscher Jakobiner;Deutscher revolutionärer Demokrat
-Ethnie;Rasse;Typus;Menschentypus
-Welt;Weltganze
-ich sehe es schon deutlich vor mir (ugs., Spruch, variabel);imaginieren;(sich) lebhaft vorstellen können (ugs., floskelhaft);(in allen Details) vor seinem geistigen Auge (sehen) (variabel);(etwas) bildlich vor sich sehen;(sich) (plastisch) vorstellen
-(schwere) Sachbeschädigung (fachspr., juristisch);zerstörerische Handlung;Vandalismus;zerstörerischer Akt;mutwillige Beschädigung
-Ruhestörung;Lärmbelästigung
-(alles) verwüsten;(sich) wie Barbaren aufführen;hausen wie die Vandalen;alles kaputtschlagen (variabel);Verwüstungen anrichten;(alles) blindwütig zerstören
-kulturlose Horden;Barbaren
-schreibunkundig;kann nicht lesen und schreiben (ugs.);Analphabet;nicht des Schreibens mächtig (geh.);analphabetisch (Person);hat nicht lesen und schreiben gelernt (ugs.)
-schriftlos;ohne Schrift;analphabetisch (Gesellschaft)
-Nacktscanner;Körperscanner;Flughafenscanner;Ganzkörperscanner;Bodyscanner
-(sich etwas) nicht selbst ausgedacht haben (ugs.);(sich) mit fremden Federn schmücken (fig.);nicht auf seinem (eigenen) Mist gewachsen sein
-(etwas) ausdrücklich verbieten;(ein) Verbot aussprechen
-(seine) Zustimmung verweigern;nicht unterschreiben (auch figurativ)
-(etwas) absegnen lassen;(sich) das Okay holen (von) (ugs.);(sich jemandes) Segen holen (fig.);(sich) die Genehmigung holen;(etwas) genehmigen lassen
-(jemandem) eigentümlich sein;(jemandem) zu eigen sein (geh.);(jemandem) eignen (geh.)
-(sich) sklavisch halten an;(einer Sache) strikt folgen;(sich) strikt halten an;(sich) ängstlich halten an;(sich) nicht die kleinste Abweichung erlauben
-Lauterkeit;Unverderbtheit;Unschuld;Reinheit
-Natürlichkeit;Ingenuität (geh., veraltend);Unverbildetheit;Ungekünsteltheit;Ungezwungenheit
-Gleichraum-Gasturbine;Explosions-Gasturbine;Verpuffungs-Gasturbine;Holzwarth-Gasturbine
-umzingelt;umstellt;eingekreist;eingekesselt;umringt
-Sonderaktion 1005;Enterdungsaktion;Aktion 1005
-wallend (Kleid, Gewand) (geh., fig., positiv);locker fallen(d);weit (geschnitten);locker sitzen(d) (Kleidung);schlabbrig (ugs., abwertend);Schlabber... (ugs., abwertend)
-(das) Geld locker sitzen haben (ugs.);nicht aufs Geld gucken (ugs., fig.);in Kauflaune;(das) Geld sitzt locker (bei jemandem) (ugs.);(Geld) mit vollen Händen ausgeben (fig.);(viel) Geld ausgeben;in Konsumlaune sein
-schnell greifen zu (Waffe);locker sitzen (Messer, Colt) (fig.)
-Tahmisch;livischer Dialekt
-Kuronisch;Kurländisch
-Livländischer Orden;Livonischer Orden
-angeekelt;angewidert;abgestoßen;geekelt
-Kalmar-Hanse Krieg;Dänisch-Hanseatischer Krieg;Kalmarisch-Hanseatischer Krieg;Sundzollkrieg
-Dänisch-Hanseatischer Krieg;Dänisch-Lübischer Krieg
-erster Waldemarkrieg;erster Hansekrieg
-zweiter Hansekrieg;großer Hansekrieg;zweiter Waldemarkrieg
-Ratsherr (männl.);Ratsmitglied;Ratsherrin (weibl.);Ratmann (fachspr., mittelalterlich, männl.);Ratsfrau (weibl.)
-Halbwertzeit;Halbwertszeit
-maschinelle Übersetzung;automatische Übersetzung
-Eisbegonie (Hauptform);Eis-Begonie (fachspr., botanisch);Semperflorens-Begonie;Gottesauge;Begonia semperflorens (fachspr., botanisch)
-Auge Gottes;Helixnebel
-medien-induzierte Selbsttötung;Nachahmungs-Suizid;(auf dem) Werther-Effekt (beruhender Suizid);durch (eine) Berichterstattung ausgelöster Suizid (variabel)
-an der Zeit sein zu (...);(jetzt ist) der richtige Zeitpunkt;an der Zeit sein, dass (...);Zeit zu (...) (ugs.);(jetzt wäre) der richtige Zeitpunkt
-nicht zueinander passen;(sich) nicht (miteinander) vertragen;nicht zusammengehen;nicht kompatibel (sein);nicht harmonieren;(sich) beißen (Farben) (ugs., fig.);nicht zusammenpassen (Hauptform)
-Futterwiese;Heuwiese
-...streu;Einstreu;Tier(ein)streu
-Wildblumenwiese;Blumenwiese;Kräuterwiese
-Brühl (ugs., regional, veraltet);Sumpfwiese;Feuchtwiese
-Magergrünland;Magerweide(n);Magerwiese(n);Magerrasen (Biotop) (fachspr.)
-Neue Subjektivität;(die) Neue Weinerlichkeit (abwertend, ironisch);(die) Neue Innerlichkeit
-(Bezeichnung für eine) literarische Epoche;Epochenbegriff (Literatur);(Bezeichnung für eine) literarische Strömung;(Bezeichnung für eine) literarische Richtung (Hauptform)
-(einheitlicher) Block (auch figurativ);geschlossene Front (auch figurativ);geschlossene Formation (auch figurativ);(die) Phalanx (geh., auch figurativ)
-in Tränen ausbrechen;das heulende Elend kriegen (ugs.);losweinen;(seinen) Tränen freien Lauf lassen;in Weinen ausbrechen;losflennen;anfangen zu weinen;losheulen (ugs.)
-in Tränen zerfließen (fig.);in Tränen schwimmen;in Tränen aufgelöst sein;(die) Tränen laufen jemandem (nur so) übers Gesicht (variabel);heiße Tränen vergießen;hemmungslos weinen;hemmungslos losheulen (ugs.);(sich) in Tränen auflösen (fig.);heulen wie ein Schlosshund;heiße Tränen weinen;alle Schleusen öffnen (fig);(sich die) Augen ausweinen (fig.);(sich die) Augen aus dem Kopf weinen;Ströme von Tränen vergießen;dicke Tränen vergießen;heftig weinen (Hauptform);bittere Tränen vergießen (veraltend);Rotz und Wasser heulen
-(sich) ausheulen (bei jemandem) (ugs., auch figurativ);(sich) ausweinen (bei jemandem) (auch figurativ)
-(jemandem etwas) vorheulen (ugs.);(jemandem etwas) vorjammern (abwertend);(jemandem etwas) vorweinen
-nasse Augen bekommen;feuchte Augen bekommen;dem Weinen nahe sein (Hauptform);(sich) eine Träne aus dem Augenwinkel wischen;Pipi in die Augen bekommen (derb)
-Pipi in den Augen haben (derb);nasse Augen haben (Hauptform);(jemandem) steht das Wasser in den Augen;(jemandem) stehen die Tränen in den Augen;feuchte Augen haben;Tränen in den Augen haben
-(sich) in den Schlaf weinen;(sich) müde weinen
-Osmanisch-Italienische Krieg;Tripoliskrieg;Italienisch-Türkischer Krieg
-Bombarde;Mörserschiff
-Gralshüter (fig.);Bewahrer des Unverfälschten;Purist (Hauptform)
-Sprachbewahrung;Reinhaltung der deutschen Sprache
-auf dem Wasser landen (Flugzeug, Wasservogel);wassern (fachspr., Jargon);auf dem Wasser niedergehen;im Wasser landen (Raumkapsel)
-zu Wasser lassen;wassern (fachspr., Jargon);ins Wasser lassen (ugs.);vom Stapel (laufen) lassen (Schiff)
-Kopfkissen;Ruhekissen
-Couchkissen;Dekokissen;Sofakissen
-Dekokissen;Cocktailkissen;Zierkissen
-Bodenkissen;Sitzsack;Sitzkissen
-Bergère (geh., franz., veraltend);Polsterstuhl;Polstersessel;Lehnstuhl;Sessel (Hauptform)
-Schemel;Hocker (Hauptform);...hocker;...schemel
-ist ständig draußen (ugs.);Outdoor-Freak
-Fußhocker;Fußablage
-inkurabel (fachspr.);lebensbegleitend (ugs.);terminal krank (fachspr.);todkrank;unheilbar (Hauptform)
-Feststoffraketentriebwerk;Feststoffraketenantrieb
-(den) Kontakt auf Eis legen (fig.);(den) Kontakt unterbrechen;(mehr) Abstand brauchen
-auf Distanz gehen;auf Abstand gehen
-Rotte;Kompostierung
-Schlüsselerlebnis;wichtige Erfahrung;prägendes Erlebnis;prägende Erfahrung;Wendepunkt (im Leben)
-Augenblick (Hauptform);Wimpernschlag (geh., fig.);Flügelschlag (geh., dichterisch);sehr kurze Zeitspanne
-Verlassen des Raumschiffs (variabel);Weltraumspaziergang (fig.)
-alles Gute (dann)!;(ich) wünsch' dir was! (ugs.);(dann) mach's (mal) gut!
-wenig herauskommen (bei);schön, dass wir (mal) darüber gesprochen haben;was sollte das jetzt?;(ehh,) was war das jetzt?
-Wo waren wir unterbrochen worden?;Wo waren wir stehengeblieben?;Was wollte ich vorhin sagen?;Wo(bei) waren wir (da) gerade?
-sind (Rechnen);macht (Rechnen);ist (Rechnen);ist gleich;ergibt (Rechnen);gibt (Rechnen)
-zum Ergebnis haben;rauskommen (ugs.);herauskommen (bei) (ugs.);(das) Ergebnis haben
-(etwas) vor sich haben;(jemandem) ins Haus stehen;vor jemandem liegen;(einer Sache) entgegenschreiten (geh.);(sich) zubewegen (auf)
-im Verzug sein;(sich) verspäten;auf sich warten lassen;kommt und kommt nicht (ugs.)
-nicht vergessen machen können;nicht darüber hinwegtäuschen können (floskelhaft)
-(etwas ist) nicht gut;schöner Mist;schöne Scheiße (derb)
-Kolmogorow-Komplexität;Beschreibungskomplexität;Algorithmische Komplexität
-Informationsmenge;Informationsbezirk
-nullbreites Leerzeichen;breitenloses Leerzeichen
-Steuerzeichen;Steuercode;Steuerkode
-(räumlich) zuordnen;(räumlich) einordnen;lokalisieren;(etwas irgendwo) verorten (geh.)
-heilige Bahn;Wüstenbahn;Hedschasbahn;Mekkabahn
-Neugalizien;Westgalizien
-mobiles Führerhauptquartier;Führersonderzug
-Schwippschwager (männl.);Schwiegerschwager (männl., österr.)
-Schwiegerschwägerin (weibl., österr.);Schwippschwägerin (weibl.)
-Schwägerschaft;Affinität
-Gedächtnisprobleme;(ein) Gedächtnis wie ein Sieb (haben) (ugs.);Gedächtnisschwäche;Erinnerungslücke(n);mangelndes Erinnerungsvermögen;Vergesslichkeit
-(Musik) ohne tonales Zentrum;(Musik) ohne Grundton;Atonalität;atonale Musik
-Gejaule;Katzengeschrei (Hauptform);Geraunze;Katzenmusik;(das) Raunzen
-Durcheinander von Instrumenten;Lärmmusik;Charivari;Katzenmusik
-Tierstimme(n);Tierlaut(e)
-Bernoulli-Kette;Bernoulli-Prozess
-stochastischer Prozess;Zufallsprozess
-glücklich und zufrieden;rundum zufrieden;vollauf zufrieden
-Ussuritiger;Panthera tigris altaica (fachspr.);Amurtiger;Sibirischer Tiger
-Panthera tigris (fachspr.);Tiger
-Pantherinae (fachspr.);Großkatze (ugs.);(Eigentliche) Großkatze(n) (Gattung) (fachspr.)
-reif für die Insel;urlaubsreif;erholungsbedürftig
-Landvolkshochschule;ländliche Heimvolkshochschule;Landvolkhochschule
-hängenbleiben (ugs., fig.);sitzen (Lernstoff);nicht vergessen (haben)
-anpingen (ugs.);einen Ping senden
-Gefecht der verbundenen Waffen;Operation verbundener Kräfte
-Schiesskommandant (schweiz.);Artilleriebeobachter;vorgeschobener Beobachter
-Greyerzbezirk;Greyerzerland (volkstümlich)
-Raketentechnologie-Kontrollregime;Trägertechnologie-Kontrollregime
-ausstaffiert;zurechtgemacht;herausgeputzt (auch figurativ);hergerichtet;fein gemacht
-Zentralbosnien;Mittelbosnien
-Lockangebot;Lockvogelangebot
-Köder;Luder (fachspr., Jargon, Jägersprache);Lockspeise;Lockvogel
-Schnäppchenjäger (Hauptform);(jemand, der nur) auf Sonderangebote aus (ist)
-Parasit (der Gesellschaft) (fig., stark abwertend);Schmarotzer (fig., stark abwertend)
-Kompensationskauf;Frustkauf (ugs., salopp)
-Kauf auf Vorrat;Wochenendeinkauf;Großeinkauf
-Impulskauf (fachspr.);Spontankauf (fachspr.)
-...chen;...lein (Hauptform);...erl (ugs., bayr.);...li (schweiz.);...i;...le (schwäbisch);...(t)je (norddeutsch);...ke;...(s)ken (ugs., norddeutsch, ruhrdt.)
-abfälschen (Ball) (fachspr., Jargon);umleiten;in die falsche Richtung lenken;in eine andere Richtung lenken (variabel);weglenken;ablenken;umlenken
-(sich) konzentrieren (auf);(sich) nicht ablenken lassen
-Dschungel der Bürokratie;Behördendschungel;Bürokratiedschungel
-Paragraphendickicht;unüberschaubare Menge von Vorschriften
-Dickicht (fig.);undurchdringliches Geflecht (von)
-Rokokoklassizismus;Zopfstil
-Josephinischer Barock;Josephinischer Stil;Josephinischer Klassizismus
-(sich) freuen (über) (Hauptform);Spaß haben (an);(sehr) erfreut sein;erfreut sein (über);(große) Freude empfinden;voller Freude (sein);(sich) erfreut zeigen
-einen Narren gefressen haben (an);seine helle Freude haben (an);begeistert sein (über);(sich) immer wieder begeistern können (über) (ugs.)
-(sich) tierisch freuen;(sich) freuen wie Bolle;(vor Freude) aus dem Häuschen geraten;(sich) ein Loch in den Bauch freuen (fig.);(sich) sehr freuen;(ganz) außer sich sein vor Freude;(ganz) aus dem Häuschen sein (vor Freude);(sich) überschwänglich freuen (Hauptform);vor Freude an die Decke springen (fig.);(sich) freuen wie ein Schneekönig (Spruch);(sich) vor Freude kaum lassen können (ugs.);(sich) freuen wie ein Schnitzel (ugs.);(sich) (n)en Keks freuen (ugs.);(jemandem) hüpft das Herz vor Freude (im Leibe);(sich) vor Freude kaum zu lassen wissen;außer sich geraten vor Freude
-das Publikum rast;der Saal tobt;der Saal kocht (fig.);(es herrscht eine) Bombenstimmung
-super Stimmung (ugs.);gute Stimmung (Hauptform);tolle Stimmung
-(sich) amüsieren gehen;(einen) losmachen;tanzen gehen;ausgehen;feiern gehen;(was) losmachen
-dass ich Sie auch mal kennenlerne! (ugs., salopp, variabel);ich freue mich, Ihre Bekanntschaft zu machen (förmlich);angenehm (beim Sich-Vorstellen) (förmlich);sehr erfreut (beim Sich-Vorstellen) (förmlich);freut mich, Sie kennenzulernen (förmlich)
-jemanden in der Leitung haben;jemanden an der Strippe haben (ugs., veraltet)
-nur (Hauptform);rein;bloß;nichts (weiter) als;einfach (ugs.)
-(da) möchte man nicht tot überm Zaun hängen (ugs., salopp);nichts los;langweilig (Gegend, kleiner Ort);tote Hose (ugs., salopp);(da werden) abends die Bürgersteige hochgeklappt (ugs.);(da ist) (der) Hund verfroren (ugs.);(da) sagen sich Fuchs und Hase Gute Nacht (Redensart)
-junges Volk;junge Menschen;(die) Jungschen (ugs., regional);junges Gemüse (ugs., fig., scherzhaft-ironisch);(die) Jugend;junge Leute;nachwachsende Generationen
-Hochbetagtheit;Greisenalter;Hochbejahrtheit;Senium (fachspr.)
-aktive Phase;Erwachsenenalter (Hauptform);reifes Alter;Zeit der Berufstätigkeit
-Eintritt in das Erwachsenenalter;Großjährigkeit (selten);Majorennität (geh., selten, veraltet);Volljährigkeit;Mündigkeit
-Teenieschwarm;Teenyschwarm;Mädchenschwarm;Jungmädchenschwarm
-noch (ganz) der Alte sein;(sich) nicht verändert haben;noch wie früher sein
-Sprachschicht;sprachliches Niveau;Sprachebene;Stilebene
-unverwechselbar werden;versuchen, an Profil zu gewinnen;(sich) deutlich unterscheiden wollen;(sich) zu profilieren suchen (mit);(sein) Profil schärfen;(sich) abgrenzen gegen
-(jemanden) in die rechte Ecke stellen (fig.);(jemandem) rechte Tendenzen nachsagen;(jemanden) auf eine Stufe stellen mit (Ausländerfeinden o.ä.);(jemandem) eine rechte Gesinnung unterstellen;in die rechte Ecke gestellt werden (fig., Hauptform)
-akzelerieren (fachspr.);beschleunigen;vorantreiben;dynamisieren (geh.)
-(einen) Nachsendeantrag (stellen);(einen) Nachsendeauftrag (erteilen) (variabel);(einen) Nachsendeservice (beauftragen);(die) Nachsendung (veranlassen)
-Deutsche Post DHL (Group) (Eigenname);Deutsche Post AG;Deutsche Bundespost (historisch);(die) Post (ugs., Hauptform)
-Dienstleistungsunternehmen;Dienstleister (ugs.)
-Denkfabrik;Thinktank (engl.);Think-Tank (engl.);Ideenfabrik;Ideenschmiede
-(etwas) in Gewahrsam nehmen;(etwas) in Aufbewahrung nehmen;(etwas) in Verwahrung nehmen;(etwas) an sich nehmen (ugs.);(etwas) in (seine) Obhut nehmen
-frisch vermählt;soeben getraut;frisch verheiratet
-(eine) Fünf;mangelhaft;(die) Note "mangelhaft";unterm Strich (fig.);(eine) 5;volle Hand (ugs., salopp)
-zum Scheitern bringen;(etwas) gegen die Wand fahren (fig.);(den) Karren gegen die Wand fahren
-in Schweiß kommen;ins Schwitzen kommen;in Schweiß geraten
-Kult sein;Kultqualität haben;Kultstatus haben;Kultstatus genießen
-Woher nehmen und nicht stehlen? (sprichwörtlich);(sich etwas) nicht aus den Rippen schneiden können (ugs., fig.);nicht herbeizaubern können (fig.);nicht aus dem Hut zaubern können (fig.);nicht hexen können (ugs.)
-(sich) ein Länderspiel im Fernsehen angucken;Deutschland kucken (ugs., regional, salopp)
-(die) Enttäuschung ist (jemandem) (deutlich) anzusehen;(sich) enttäuscht zeigen;(ein) langes Gesicht machen;(den) Kopf hängen lassen (auch figurativ, variabel);(es gibt) lange Gesichter (bei)
-infaust (medizinisch);ungünstig
-kann nicht mehr voll arbeiten (ugs.);(nur noch) eingeschränkt erwerbsfähig;eingeschränkt arbeitsfähig (variabel);erwerbsgemindert (Sozialrecht) (juristisch)
-gespannt sein (auf);erwartungsvoll sein;neugierig sein (auf);auf etwas heiß sein (ugs.)
-(sich) vortasten;(die) Lage sondieren;(seine) Fühler ausstrecken (fig.);vorfühlen
-vor meiner Zeit (hier) (ugs.);bevor ich hier angefangen hatte;nicht seitdem ich hier (dabei) bin;bevor ich hier eingestiegen war
-Ergotherapeut;Beschäftigungstherapeut
-Beschäftigungstherapie;Ergotherapie (fachspr., griechisch);Arbeitstherapie
-kollektivistischer Anarchismus;Anarchokollektivismus
-(miteinander) verwandt (Hauptform);vom gleichen Stamm (fig.);familienangehörig;zur (selben) Familie gehören(d);von gleicher Abstammung;aus derselben Familie (stammend)
-Verslumung (Hauptform);(das) Herunterkommen;Ghettoisierung
-verslumen (Hauptform);zum Slum werden;herunterkommen
-artverwandt;gleichartig;vergleichbar
-(Single-)Auskopplung;(zusätzliche) Veröffentlichung als Single
-nicht gepfropft;wurzelecht (fachspr., Hauptform);nicht veredelt
-Selbstträger (fachspr.);Direktträger (fachspr.);Wurzelrebe (Weinbau) (fachspr.)
-gepfropft;veredelt (Hauptform);aufgepfropft;eingepfropft
-Wurzelsystem;Wurzelwerk;Wurzelstock
-Clipverschluss;Steckverschluss;Klickverschluss (ugs.);Klickschnalle;Steckschnalle
-da liegst du völlig falsch;da hast du dich geschnitten (ugs., fig.);da bist du schief gewickelt;da täuscht du dich aber (gewaltig)
-(mach jetzt) keine Dummheiten! (ugs.);schön brav (sein)! (ugs.)
-vom Scheitel bis zur Sohle (fig.);in jeder Beziehung;durch und durch;ganz (geh.);jeder Zoll ein (geh.)
-echt (Nico) (ugs., variabel);ganz (der) (Onkel Karl) (variabel);kann nur ihr passieren;(...) wie sie leibt und lebt (ugs., weibl.);(jemanden) so kennen;(...) wie er leibt und lebt (ugs., männl.);(das) sieht ihm ähnlich;kann nur ihm passieren;typisch (Onkel Karl) (variabel);(mal wieder) typisch (sein) (ugs.);ein echter (Klaus) (ugs., variabel);typisch (für jemanden);ein typischer (+ Name) (variabel);typisch (...)
-Eurasianismus;Eurasiertum;Eurasismus
-Personenstand;Zivilstand (schweiz.)
-bezeichnend;(jemandem/einer Sache) eigen (geh.);symptomatisch (für);charakteristisch (für);(jemandem/einer Sache) eigentümlich (geh.);gekennzeichnet (durch);typisch (für);kennzeichnend;spezifisch (für);charakterisiert (durch)
-mit halb geschlossenen Augen;(mit) Schlafzimmerblick
-benamt;benannt;gekennzeichnet;bezeichnet
-wenn schon, denn schon! (Spruch);keine halben Sachen;was wir machen, machen wir richtig (Spruch);Nägel mit Köpfen machen (Redensart, fig.);aufs Ganze gehen (Redensart)
-(etwas) wahrmachen;seinen Worten (auch) Taten folgen lassen;keine leeren Versprechungen machen;(das sind) keine leeren Worte
-Leoninischer Vers;Leoniner;Leoninischer Hexameter
-gebrandmarkt;stigmatisiert;abgestempelt (als) (fig.)
-kenntlich gemacht;mit einem Zeichen versehen;gezinkt (Kartenspiel);markiert;gekennzeichnet
-Kollationierung;Kollation
-Kollationspflicht;Kollation
-(etwas) haben (von) (ugs.);profitieren (von);mitnaschen;(sich) lohnen (für);zehren (von) (geh., fig.);(einen) Vorteil ziehen (aus);(der) Nutznießer sein
-Helfershelfer;Spießgeselle;Komplize;Tatbeteiligter (Amtsdeutsch);Mitverantwortlicher;Mittäter
-mit der Gegenseite zusammenarbeiten;mit dem Gegner zusammenarbeiten;(ein) Kollaborateur (sein);mit dem Feind zusammenarbeiten (Kriegszeit);kollaborieren;(dem) Gegner in die Hände arbeiten
-(zu jemandes) Anhänger werden;(sich) jemandem anschließen;(jemandem) nachlaufen (abwertend)
-(sich gegenseitig) nicht wehtun;einander keine Schwierigkeiten bereiten;Eine Krähe hackt der anderen kein Auge aus. (Sprichwort);(sich untereinander) keinen Ärger machen (ugs.)
-und vice versa;und andersherum;und andersrum (ugs.);und umgekehrt
-davontragen;(sich) einhandeln;zurückbehalten;erleiden;(sich) zuziehen
-nur einmal noch;ein letztes Mal;zum allerletzten Mal
-in der Überzahl (sein);die Mehrheit (haben);es gibt mehr (...) als (...);in der Mehrheit (sein);es gibt mehr (...) von;die meisten (sein);zahlenmäßig überlegen (sein);in der Mehrzahl (sein);mehrheitlich
-(jemanden) anklagen;(jemanden) inkriminieren (geh., selten);(jemanden) anschuldigen;(jemanden einer Sache) zeihen (geh., veraltet);(jemandem etwas) zur Last legen;(jemanden) beschuldigen (Hauptform);(jemanden eines Fehlverhaltens) bezichtigen
-(jemandem etwas) unter die Vorhaut jubeln (derb, selten);(jemandem etwas) unterschieben;(jemandem etwas) fälschlich zuschreiben;(jemandem etwas) unterstellen;(etwas) abwälzen auf;(jemandem etwas) in die Schuhe schieben (fig.);(jemandem etwas) unterjubeln
-(eine) belastende Aussage machen;(jemanden) belasten;gegen jemanden aussagen
-abgrasen;kahlfressen;abweiden;abfressen
-aus der Traum;willkommen zurück in der Realität;es hat sich ausgeträumt;(es war) (alles) nur ein schöner Traum;genug geträumt
-(sich) falsche Hoffnungen machen (auf);Illusionen haben;in der Illusion leben, dass;(sich etwas) zu Kopf steigen lassen;Rosinen im Kopf haben;(sich) Illusionen machen
-ungeprüft voraussetzen;(etwas) unterstellen;einfach behaupten (ugs.);(etwas) annehmen
-Schrauber (ugs.);Mechaniker
-Kleptomane;an Kleptomanie leiden(d)
-(einen) Verdacht hegen (gegen);(jemanden) im Verdacht haben;(jemanden) verdächtigen
-(jemandem) die Verantwortung zuschreiben (für);(jemanden) verantwortlich machen (für);(jemandem) die Schuld geben (an)
-diametral entgegengesetzt (sein);in völligem Widerspruch stehen (zu);(sich) völlig widersprechen;zu gegenteiligen Ergebnissen kommen;das glatte Gegenteil (ugs.)
-alle Aufmerksamkeit auf sich ziehen;alle Blicke auf sich ziehen;(einem anderen) die Schau stehlen;(sich) in den Vordergrund schieben
-kleines Schwarzes;Partykleid;Cocktailkleid
-Betthupferl (fig.);Einschlafgeschichte;Gutenachtgeschichte (Hauptform)
-Arbeitsplatte (Küche);Arbeitsfläche
-Rat für das Europäische Hilfswerk;Europäischer Hilfsrat
-Form;Erscheinungsform;Ausprägung;Ausrichtung;Observanz (geh., bildungssprachlich, selten)
-(den) Anbieter wechseln;wechseln zu;umziehen (zu) (fig.)
-Anprobierkabine;Umkleidekabine (Hauptform);Anprobe
-anprobieren;überziehen;reinschlüpfen (ugs.);hineinschlüpfen;(eine) Anprobe machen
-Rednerliste (Hauptform);Liste der (vorgesehenen) Wortbeiträge
-OLAP-Würfel;Datenwürfel
-glücklos;erfolglos;verkracht;gescheitert;ohne Erfolg
-Glückskind;Glückspilz (Hauptform);Liebling der Götter (geh., fig.);Sonntagskind;Duslbauer (ugs., bayr.);(ein) Glücklicher
-Übersättigung;Überladung;Überfrachtung;Überfüllung
-armer Irrer;harmloser Spinner
-(irgendwo) herrscht Hochbetrieb;(es herrscht / es ist ein) Mordsbetrieb (ugs.);(es gibt) großen Andrang;es herrscht reger Betrieb;es ist die Hölle los (ugs.);(es gibt) viel Publikumsverkehr
-auf Befehl (von);auf Veranlassung (von);auf Anweisung (von);auf Anordnung (von);auf Geheiß (von);im Auftrag (von)
-auf jemandes dringende Bitte(n) hin;auf jemandes Drängen hin;gedrängt durch;auf Drängen von
-Amoklenker;Amokfahrer
-Transitstaat;Transitland;Durchgangsland
-näher eingehen (auf);(jemandes) Aufmerksamkeit lenken (auf);aufmerksam machen (auf);bewusst machen;(etwas) in den Blick rücken
-auf einen früheren Termin umbuchen;(terminlich) vorziehen;nach vorne verlegen;(Termin) nach vorne ziehen (ugs.);vorverlegen;auf einen früheren Termin legen
-auf einen späteren Termin (ver)legen;nach hinten verlegen;zurückstellen (bis zum);auf später verschieben;auf später vertagen;nach hinten schieben;schieben (ugs., Jargon, salopp);verschieben
-(sich) verschieben;(sich) ändern (Termin);geändert werden;(nach vorne/hinten) verschoben werden;(nach vorne/hinten) verlegt werden
-(Termin) ändern;(einen Termin/etwas) umlegen (auf) (ugs.);(einen) anderen Termin nehmen (für) (ugs.);(Termin) umswitchen (ugs.);(Termin) verschieben;(einen Termin/etwas) verlegen
-zu einem späteren Zeitpunkt;demnächst;später;bei späterer Gelegenheit (geh.)
-sistieren (geh., bildungssprachlich);vertagen;aussetzen;unterbrechen;ruhen (lassen);zurückstellen;auf Eis legen (fig.);Frist (bis zu ...) verlängern
-(eine) Antenne haben für (fig.);(eine) Ader haben für (fig.);empfänglich sein für;(etwas) anfangen können mit (ugs.);Sinn haben für;(etwas) im Gefühl haben;(ein) Verhältnis haben zu
-herabhängen;herunterpendeln;herunterbaumeln;herunterhängen;herabbaumeln
-Ausbildungsstätte für Hochbegabte;Talentschmiede (Hauptform)
-lösungsfokussierte Kurzzeittherapie;lösungsorientierte Kurztherapie
-Gesprächstherapie;Gesprächspsychotherapie
-systemische Familientherapie;systemische Therapie
-Entwicklungszentrum (für);...schmiede
-...schmiede (fig.);Ausbildungsstätte;Ort zum Ausprobieren (Jargon);...werkstatt (fig.)
-Maschine schreiben;tippen
-irgendwann (Hauptform);zu einem unbestimmten Zeitpunkt;einmal;an einem unbestimmten Zeitpunkt;mal (ugs.)
-(jemandem) zur Last fallen;(jemandem) eine Bürde sein (geh.);(eine) Last sein (für);zur Last werden;(jemandem) Arbeit machen (ugs.)
-wollen;wünschen;mögen (fälschlich "möchten")
-(eine Zeitlang) her sein;(einige Zeit) zurückliegen
-Querfeldeinlauf;Crosslauf;Geländelauf
-(etwas) mit jemandem teilen;(untereinander) teilen;unter sich aufteilen
-(jemandem) etwas geben (von);(jemandem) etwas abgeben (von);(etwas) herausrücken (ugs.)
-nichts abgeben;alles für sich (selbst) behalten;nichts herausrücken (ugs.);nicht teilen können
-fair (auf)teilen;schwesterlich teilen (weibl.);brüderlich teilen (männl.);(sich etwas) geschwisterlich teilen (mit)
-(anderen) auch etwas gönnen (ugs.);nicht alles für sich haben wollen;teilen können;verzichten können
-seinen Teil bekommen;(etwas) abbekommen;(etwas) abkriegen (von) (ugs.);(etwas) abhaben können (von) (ugs., variabel);sein Teil bekommen
-(etwas) haben wollen (von);(etwas) abkriegen wollen;(etwas) abbekommen wollen;(etwas) abhaben wollen
-Donezrücken;Donezplatte
-Störmanöver;Behinderungsversuch;Querschuss (fig.)
-(neu) anfangen (bei) (ugs.);einsteigen (bei) (fig.);(die) Arbeit aufnehmen;(eine) Stelle antreten (Hauptform);(es ist) jemandes erster Arbeitstag (bei)
-Anpasskurve;Fitkurve;Ausgleichskurve;Regressionskurve
-Sie wissen (ja), wo die Tür ist.;Sie kennen den Weg (, oder)?;Meine Herr(e)n! (weggehend);Schönen Abend noch.;(Ich denke,) Sie finden allein raus.;Guten Tag (dann).;Sie wollten gerade gehen, richtig?
-Wir sind hier fertig. (Hauptform);Ende der Durchsage. (ugs.);Wir sind fertig (miteinander).;(das Thema ist) abschließend besprochen;Unser Gespräch ist beendet.;Es ist alles gesagt.;Es gibt nichts mehr zu sagen. (variabel)
-Kronzeuge;Hauptzeuge
-Tonmeister;Musikregisseur
-Leuchtgas;Stadtgas
-Polyvinylidendifluorid;Polyvinylidenfluorid
-Hofzeremoniell;Hofetikette
-davon ausgehen, dass jemand/etwas (...) ist;(jemanden/etwas) halten für
-Ich sage nicht, dass Sie lügen (nur);so stehenlassen;ich will Ihnen gerne glauben (allerdings) (floskelhaft, Hauptform);nicht anzweifeln (wollen)
-(jemandem) bedingungslos vertrauen;(sich) voll verlassen auf;(jemandem) bedingungsloses Vertrauen entgegenbringen;(jemandem) vorbehaltlos vertrauen;(sich) absolut verlassen auf;(jemandem) blind vertrauen (Hauptform)
-sein Schicksal in jemandes Hände legen;(jemanden/sich) ausliefern;(jemandem/einer Sache) ausgeliefert sein;völlig abhängig sein von
-felsenfest überzeugt sein von;nicht den kleinsten Zweifel haben (an);(sich) absolut sicher sein (in/dass);nicht den geringsten Zweifel haben (an/dass);nicht den mindesten Zweifel hegen (an);ich könnte schwören, dass;nicht den Schatten eines Zweifels haben (dass);Stein und Bein schwören (können)
-westliche Pyrenäen;atlantische Pyrenäen
-Zentralpyrenäen;Hochpyrenäen
-lassen Sie sich das eine gesagt sein (floskelhaft);ob es dir (nun) gefällt oder nicht;ich will dir mal was sagen (floskelhaft);eins lass dir gesagt sein;auch wenn du es nicht gerne hörst
-ja und? (ugs.);und weiter? (ugs.);na und? (ugs.);wen kümmert's! (ugs.);und wenn schon (ugs.);ja na und? (ugs.);na wenn schon! (ugs.);(und) selbst wenn...!;und wenn schon!;so what? (Jargon, engl.);ist doch egal;(na) wennschon! (ugs.);ab dafür! (ugs., regional);was soll's! (ugs., Hauptform);Und? (ugs.)
-Podlasien;Podlachien
-Reluktanzkraft;Maxwellsche Kraft
-Zirpe;Zikade
-Bandelier;Bandalier;Bandolier
-leiten;die Fäden in der Hand haben (fig.);lenken (fig.);präsidieren (schweiz.);die Leitung innehaben;vorstehen;vorsitzen;führen;den Vorsitz führen
-(etwas ist) nicht so schlimm, wie es aussieht;(etwas) sieht schlimmer aus, als es (in Wirklichkeit) ist
-Staatsunternehmen;Staatsbetrieb;Öffentliches Unternehmen
-das dicke Ende kommt noch (Redensart);das Schlimmste steht (jemandem) noch bevor;das war erst der Anfang;(da) kommt noch etwas nach (ugs.);(sich) nicht zu früh freuen
-Man soll den Tag nicht vor dem Abend loben. (Sprichwort);(sich) nicht zu früh freuen (ugs., Hauptform);Am Ende wird gezählt.;Die ersten Pflaumen sind madig. (Sprichwort)
-Autophagie;Autophagozytose
-(das) wird schon noch! (ugs.);(etwas) lässt sich jetzt noch nicht sagen;(es) ist noch zu früh (für);(Sei doch / Seien Sie doch ) nicht so ungeduldig!;Da ist aber einer (sehr) ungeduldig! (ugs., ironisierend, variabel);abwarten!;(es) ist noch zu früh, um (...);jetzt wart's doch ab!
-Mischbatterie;Mischarmatur
-Art;Typus
-charismatische Bewegung;charismatische Erneuerung
-vortragen (z.B. vor Gericht);auflisten;(alle) nennen;einzeln nennen;anführen (Beispiele, Gründe ...);Punkt für Punkt nennen;aufführen (= nennen);aufzählen;(einzeln) angeben;vorbringen;herunterbeten;aufsagen
-rechen (schweiz., süddt., österr.);harken (norddeutsch)
-nicht tolerieren;nicht dulden;nicht akzeptieren
-Friedensvertrag von Riga;Friede von Riga;Vertrag von Riga
-(das) Abführen;(das) Wegbringen;Abführung;(das) Wegführen
-Schlesischer Adler;Schlesisches Bewährungsabzeichen
-sitzenbleiben (auf) (ugs., fig.);(sich) nicht verkaufen lassen;keinen Käufer finden (etwas findet keinen Käufer);(etwas) nicht loswerden (ugs.);sitzen bleiben (auf der Ware) (ugs., fig.)
-nur die halbe Wahrheit (sein);damit unterschlägt man, dass;nur die eine Seite der Medaille (sein) (fig.)
-Erfolgsrezept;Erfolgsgeheimnis;Schlüssel zum Erfolg
-Brotbackgerät;Brotbackautomat;Brotbackmaschine
-beschäftigtenbedienter Banknotenautomat;automatischer Kassentresor
-Volksheilkunde;Volksmedizin;traditionelle Medizin
-unbillig (fachspr.);ungerecht;undankbar;nicht angemessen
-für (... Uhr) bestellt sein (ugs.);(einen) Termin um (...) haben
-Alles Liebe Dir;Alle Liebe (wünscht Dir/Euch...);Alles Liebe Euch;Viele liebe Grüße;Lieben Gruß (sendet);Dein(e);Grüßle;Mit den besten Wünschen (für);Liebe Grüße;Alles Gute
-Gruß nach;Grüßle (ugs.);Grüße;Gruß;Gruß aus
-stets der Ihre (veraltend);(ich bin/es grüßt) (wie immer) ganz der Ihre (geh., veraltend);mit (den) besten Empfehlungen;Ihr ergebener (geh., veraltend);(ich) verbleibe als Ihr (treuer Bewunderer) (geh., veraltend);stets Ihr ergebener (altertümelnd);stets zu (Ihren) Diensten (veraltend);Ihr (Name);In Treue und Ergebenheit, Ihr(e) (geh., veraltet)
-etwas zu (+ Adjektiv);ein Tick zu (ugs.);eine Idee zu (ugs.);eine Spur zu;ein bisschen zu (+ Adjektiv);eine Kleinigkeit zu;ein wenig zu (+Adjektiv)
-schiffbrüchig;in Seenot
-Lernpfad;Lehrpfad;Themenweg
-Kunstwanderweg;Skulpturenweg
-Waldwipfelweg;Baumwipfelpfad;Baumkronenpfad;Baumkronenweg
-Sabatier-Prozess;Sabatier-Reaktion
-Minimalstaat;Nachtwächterstaat
-Szene (fachspr.);Auftritt (Teil eines Akts im Drama) (fachspr.)
-Erscheinen auf der Bühne;Auftritt;Betreten der Bühne
-Abgang;Verlassen der Bühne
-einen Auftritt haben;auf der Bühne stehen;auftreten (als);(sich/etwas) präsentieren;performen (fachspr., Denglisch, Jargon, Neologismus);(sich/etwas) darstellen
-(ein) Werk (des/der ...);(ein) Akt (des/der ...);(ein) Zeichen (des/der/für ...)
-symbolischer Akt;Handlung mit symbolischer Bedeutung;symbolische Handlung
-Fluchtlinie (Hauptform);(gerade) Reihe;(gerade) Ausrichtung;(gerade) Linie;Flucht (Hauptform)
-in Flucht (stehen/liegen);in (gerader) Fluchtlinie (angeordnet ...);fluchten;in gerader Flucht (angeordnet / ausgerichtet / stehen ...);in einer (geraden) Linie (angeordnet sein / stehen ...);gerade ausgerichtet (sein)
-(jemandem etwas) bestellen;(jemandem) die Nachricht überbringen (dass);(jemandem etwas) ausrichten;(jemandem etwas) sagen sollen (ugs.);(jemandem etwas) übermitteln
-Omnisexualität;Pansexualität
-sinnliches Vergnügen;Lustempfinden;sinnliche Lust;sinnlicher Genuss;Sinnenlust (geh.);Wollust;(sexuelle) Lust;Sinneslust
-(etwas) weitersagen;(eine) Information weitergeben
-pansexuell;omnisexuell
-Bisexualität;Ambisexualität
-bisexuell;ambisexuell
-Heterosexualität;Alloiophilie (selten)
-Lustlosigkeit;Unlust;Anaphrodisie;sexuelle Appetenzstörung;Alibido (veraltet);Alibidinie (veraltet)
-Genophobie;Sexualangst
-(sich) anpassen (an);(sich) einstellen auf;(sich) adaptieren (fachspr.)
-(sich) durchsetzten (gegen);(jemandem/einer Sache) gewachsen sein;(etwas) reißen (können) (ugs.);(jemandem/einer Sache) trotzen;(sich) behaupten (gegen);(etwas) ausrichten (können);bestehen (gegen)
-(jemandem) den Kopf zurechtsetzen (fig.);(jemandem) den Kopf zurechtrücken (fig.);(jemandem) die Flausen austreiben
-am Überholen hindern;nicht vorbeilassen;(jemanden) ausbremsen
-verhindern, dass jemand zum Zuge kommt;(jemanden) ausbremsen (fig.);(jemandem) den Weg verstellen (fig.)
-(Ort) verlassen;die (alte) Heimat verlassen;ziehen (nach);wegziehen;fortziehen
-in die Niederungen der (Alltäglichkeit) herabziehen (variabel);schänden;entweihen (auch figurativ);profanisieren;entheiligen;vom Sockel holen (ugs., fig.)
-Schnickschnack;Firlefanz (ugs.);Stehrumchen (ugs., variabel);Dekorationsobjekt;nutzloses Zeug (ugs.);Klimbim;Nippes;Flitter(kram);Schnullifax (ugs.);Nippsachen (Hauptform);schmückendes Beiwerk;Staubfänger (scherzhaft-ironisch)
-hoch n rechnen (ugs.);(mit n) potenzieren;(n mal) mit sich selbst multiplizieren;in die (n-te) Potenz erheben
-funktionelle Gruppe;charakteristische Gruppe
-Bioverfahrenstechnik;Bioprozesstechnik
-ins Quadrat erheben (geh.);hoch 2 rechnen (ugs.);mit sich selbst multiplizieren;quadrieren;zum Quadrat erheben
-hoch 3 rechnen (ugs.);drei mal mit sich selbst malnehmen;in die dritte Potenz erheben;kubieren (fachspr., selten)
-die dritte Wurzel ziehen (aus);die Kubikwurzel ziehen (aus)
-die zweite Wurzel ziehen aus;die Quadratwurzel ziehen aus;die Wurzel ziehen aus (ugs.)
-hoch zwei;hoch 2;zum Quadrat
-ausgezogen sein;(jetzt) woanders wohnen (ugs.);(sich) eine andere Wohnung gesucht haben;(sich) etwas anderes gesucht haben (ugs.);nicht mehr hier wohnen
-nicht mehr hier arbeiten (Hauptform);gekündigt haben;(jetzt) woanders arbeiten;(sich) etwas anderes gesucht haben;nicht mehr bei uns beschäftigt sein
-Indianerfilm;Indianerwestern
-Galloitalienisch;Galloitalisch
-spannend werden;es wird ernst;in die heiße Phase gehen;(sich) der Entscheidung nähern
-es geht (für jemanden) um alles oder nichts;es geht um die Wurst (ugs.);(es ist) für jemanden eine Frage von Sein oder Nichtsein;(seinen) großen Auftritt haben (ugs.);(jemandes) großer Tag
-die da oben (ugs.);(die) Entscheidungsträger in Politik und Gesellschaft;(die) Eliten
-(etwas) allein entscheiden (Hauptform);nicht auf andere hören;(sich) keinen Rat holen;nicht auf das hören, was andere sagen;(eine) einsame Entscheidung treffen;(etwas ist) allein meine Entscheidung
-fadenscheinig;nicht ehrlich;pflaumenweich (fig.);halbherzig (Hauptform);nicht ernst gemeint;lau (geh.)
-Grund genug haben;allen Grund haben (zu);(jemand) sollte sich (tunlichst) (variabel);gut daran tun, zu
-an (...) nicht zu überbieten (negativ);(etwas ist) der Gipfel der (z.B. Peinlichkeit) (variabel);einen Negativrekord darstellen;den Vogel abschießen (fig., ironisch)
-letzter Gang;Trauerzug;Leichenzug
-Klageweib;Trauerweib;Klagefrau
-scharfe Kurve (auch figurativ);(eine) scharfe Wendung (nehmen) (fig., variabel);scharfer Knick;enge Kurve
-Leichenmahl;Tröster;Kremess (altbairisch);Tränenbrot;Totenmahl (österr.);Trauerbrot;Beerdigungskaffee;Reuessen (rheinisch);Gräbt (schweiz.);Leichenschmaus (Hauptform);Leidmahl;Zehrung (österr.);Leidessen;Leichentrunk (süddt.);Trauermahl;Traueressen;Rüezech (sauerländisch);Raue;Flannerts;Grebt (schweiz.)
-(sich) um 180 Grad drehen (fig.);(heute) einen gegenteiligen Standpunkt vertreten;(sich) vom Saulus zum Paulus wandeln (biblisch);vom Saulus zum Paulus werden (biblisch);(heute) das Gegenteil behaupten
-(ganz) eng;(ganz) dicht;scharf;mit geringem Abstand
-mit spitzem Bleistift ausrechnen (fig.);(messer)scharf kalkulieren;(sehr) knapp kalkulieren
-scharf (Waffe);geladen
-mit scharfer Munition schießen;scharf schießen
-mit Platzpatronen schießen;mit Übungsmunition schießen
-(ein) Schlag unter die Gürtellinie (fig.);zu unfairen Mitteln greifen
-Wohlsein;Behaglichkeit
-Massagestab;Masturbator;Vibrator;Stimulator;Vibrationsstab;Massagegerät;Vibrationsgerät
-(sich einer Sache/jemandem) zuwenden;(sich) (jetzt) kümmern um;(sich jetzt einer Sache) widmen;(sich) (jetzt) konzentrieren auf;Zeit haben (für);(sich einer Sache/jemandes) annehmen;(sich) (jetzt) befassen mit
-(sich) abgeben (mit) (negativ);(sich mit etwas) aufhalten (negativ);(seine) Zeit verschwenden (mit);(sich) verkünsteln (mit/an) (ugs., regional);Zeit verlieren (mit);seine Zeit verplempern (mit);(seine) Zeit vertrödeln (mit)
-versucht sein (zu) (geh.);geneigt sein (zu) (geh., auch ironisch);(jemand) möchte eher (...) (geh.);(jemand) möchte (/ wollte / hätte / würde) fast (/ beinahe / am liebsten ...)
-mit angedeutetem Sarkasmus;mit leiser Ironie (im Tonfall);mit einer Andeutung von (...) in der Stimme;mit spöttischem Unterton
-Modevokabel (geh.);Modewort;Buzzword (engl.);Trendwort
-Standardformulierung;Kollokation;(überzufällig) häufige Wortverbindung
-Tonsur (fachspr.);Mönchsfrisur (ugs.)
-Profimusiker;Berufsmusiker
-hauptberuflich(er);Profi...;Profi;Pro (Abkürzung);davon leben (ugs.);Berufs...
-im Nebenerwerb;im Zweitberuf;im Nebenberuf;zweites Standbein (fig.);Nebenerwerbs...;nebenberuflich
-Bewegung;Initiative;Strömung
-mitten zwischen;mittig;in die goldene Mitte (ugs., floskelhaft);in die Mitte;ins Zentrum
-in den Grundfesten erschüttern(d);alles auf den Kopf stellen(d) (fig.);grundstürzend (bildungssprachlich);völlig neu (ugs.);alles in Frage stellen(d) (was bisher ...)
-Suzeränität;Oberhoheit
-regulärer Ausdruck;Textmuster
-Phrase;Formulierung;Wortkombination;Wendung (geh.);Formel;Ausdruck
-asymptotisch normale Statistik;asymptotisch normalverteilte Statistik
-Konvergenz nach Verteilung;Konvergenz in Verteilung;schwache Konvergenz
-Atuatuker;Aduatuker
-Kongo-Krise;Kongowirren
-Erleidnis;Erlebnis
-eigentlich;isoliert betrachtet;rein (...) (vor Adverbien);insoweit;so weit;erst einmal;(nur) für sich genommen;an sich
-runderneuert;erneuert;modernisiert
-Einwohner;Seelen (nur im Plural)
-(das ist) das Interessante (an);darum geht es ja gerade! (ugs., variabel);das ist der Witz an der Sache (Redensart);(das ist) der springende Punkt (fig.)
-nicht in Frage stehen;nicht Teil der Verhandlungsmasse sein;nicht verhandelbar (sein);nicht zur Disposition stehen;(darüber) wird nicht verhandelt
-Lieferabruf;Bestellabruf
-undefinierbar (sein);(ein) seltsames Etwas;(ein) mysteriöses Etwas;(ein) undefinierbares Etwas
-weder das eine noch das andere;nicht klar zuzuordnen;weder Fisch noch Fleisch (Redensart, fig.)
-Gehörnter;betrogener Ehemann;gehörnter Ehemann;Hahnrei (geh., veraltet);Betrogener (sexuell)
-mit großer Kunstfertigkeit geknüpft;ausgeklügelt;vielfältig (miteinander) verflochten;kunstvoll;kaum zu durchschauen;mit viel Raffinement (konstruiert);ausgetüftelt;durchdacht;kompliziert;ausgefuchst (ugs.);hochkomplex;komplex;ausgefeilt;raffiniert;feingesponnen (geh.);fein gesponnen (geh.)
-(jemanden) bedienen;(jemanden) abfertigen;(jemandem) behilflich sein;(jemanden) verarzten (ugs., fig.);(sich) jemandes annehmen (geh.);(sich) Zeit nehmen für;(jemandem) zu Diensten sein (geh.);(sich) kümmern (um) (ugs.)
-(jemandem etwas) zugedacht haben;(jemandem etwas) geben wollen;(etwas) für jemanden bestimmt haben;(für jemanden) vorgesehen sein;(jemandem etwas) zueignen (geh.)
-(etwas) verbummelt haben;(etwas) verschusselt haben;(etwas) verschlampt haben;(etwas) verkramt haben;(etwas) verlegt haben
-(etwas) aus den Augen verloren haben;nicht mehr wissen, wo etwas ((ab)geblieben) ist;(jemandem) unter die Räder kommen (ugs., fig.)
-(sich etwas) einfallen lassen;(jemandem) fällt schon was ein (ugs., Spruch, salopp);(eine) Lösung finden;(zu) einer Lösung kommen
-(sein) Leben (zu) meistern (wissen);am Leben teilhaben;(sein) Leben in die Hand nehmen;lebenstüchtig (sein);(mitten) im Leben stehen;(sein) Leben gestalten;(das) Leben (zu) nehmen (wissen)
-(etwas) unternehmen;nicht nur vor dem Fernseher sitzen (fig., variabel);aktiv sein;nicht (nur) zu Hause herumhocken (ugs., fig.)
-zum Tanz aufspielen;Tanzmusik spielen
-den DJ machen;(die) Regler bedienen;Musik auflegen;an den Reglern (stehen);am Mischpult (stehen);auflegen (ugs., Hauptform)
-Zweitjob (ugs.);Nebentätigkeit;Nebenbeschäftigung
-es wagen, zu;(etwas) wagen;(der) Gefahr (furchtlos) ins Auge sehen (Hauptform);(die) Gefahr nicht scheuen (geh., veraltend);(sich) in die Höhle des Löwen begeben (fig., variabel)
-(eine) Vollzeitstelle haben;Vollzeit arbeiten (ugs.)
-(eine) Teilzeitstelle haben;(in) Teilzeit arbeiten
-vernetzt;miteinander verbunden
-Pferdchen (ugs.);Springer (Schachfigur) (Hauptform);Ross;Rössel;Pferd
-Königin (ugs.);Dame (Schach)
-ohne Begleitung;a cappella (Chor) (fachspr.);ohne Instrumentalbegleitung
-(der) hat es echt drauf (ugs.);das muss erst mal einer nachmachen! (ugs.);saubere Arbeit! (ugs., Spruch);reife Leistung! (ugs., Spruch);das macht ihm so schnell keiner nach (ugs., Spruch)
-Jugendtorheit;ich war jung und brauchte das Geld (ugs., Spruch, ironisch);jugendlicher Leichtsinn;Jugendsünde (Hauptform)
-(gerade) den Kinderschuhen entwachsen (variabel);das (ganze) Leben (noch) vor sich haben;jung und unverbraucht (ugs.);jung und unschuldig (ugs.);jung und hübsch (ugs.);jung an Jahren;jung und schön (ugs.);jung (sein) (Hauptform)
-(der) Lack ist ab (ugs., Spruch, fig.);Früher waren wir jung und schön, heute sind wir nur noch 'und'. (ugs., Spruch, sarkastisch);nicht mehr die Jüngste sein;in die Jahre gekommen (Redensart);Früher waren wir jung und hübsch, heute sind wir nur noch hübsch. (ugs., Spruch, ironisch);nicht mehr der Jüngste sein;keine 20 mehr (sein) (ugs.);(seine) besten Jahre hinter sich haben
-Orchiektomie;Orchektomie;Orchidektomie
-Weiße Lämmer;Skopzen;Weiße Tauben
-Schaloputen;Chlysten;Gottesleute
-Anti-Gnostik;Agnostik
-mit letzter Kraft;mit allerletzter Kraft;mit einer allerletzten Anstrengung
-(und) was gibt es sonst zu erzählen? (ugs.);(und) was tut sich sonst so bei dir? (ugs.);(...) und sonst? (ugs.)
-war's das? (ugs., salopp);sind Sie fertig? (ugs.);sonst noch was? (ugs.);bist du fertig? (ugs.);muss ich mir das noch länger anhören? (ugs.)
-(Urlaub in/auf) Balkonien (machen) (ugs., scherzhaft-ironisch);(im Urlaub) zu Hause bleiben (ugs.);(im Urlaub) nicht wegfahren (ugs.)
-(jemandes) einzige Freude im Leben (sein);man gönnt sich ja sonst nichts
-in der Fachwelt;in Fachkreisen;in Expertenkreisen;unter Experten;unter Fachleuten
-in seiner Branche;in seiner Zunft;auf seinem Gebiet
-nebenbei bemerkt;bei dieser Gelegenheit;Bemerkung am Rande;notabene (geh., bildungssprachlich)
-nicht ausbleiben;unvermeidlich sein;(sich) nicht vermeiden lassen;dazugehören
-Körperorgan;Organ
-Gastrointestinaltrakt (fachspr.);Magen-Darm-Kanal;Magen-Darm-Trakt (Hauptform)
-Schaffenskrise;unproduktive Phase;Schreibblockade
-unproduktive Tätigkeit(en);Ablenkung;Scheinaktivität
-(sich) ablenken (von);(sich) nicht kümmern (um)
-Heliotrop;Blutjaspis
-kalifornischer Mondstein;Jasponix;blauer Mondstein;Milchstein;Zoesit;Quarzin;Chalcedon (fachspr., griechisch, Hauptform);Chalzedon (fachspr., griechisch);Massik
-Siliciumdioxid;Siliziumdioxid
-Tiefquarz;SiO2 (Abkürzung, chemisch);Quarz (Hauptform);Siliziumoxid (chemisch);alpha-Quarz
-Lithurgik;Gesteinsbearbeitung
-Lithologie;Sedimentgesteinskunde
-Pferdetablette (ugs., fig.);große Tablette
-ständig besetzt;nicht durchkommen (ugs.);dauerbesetzt
-besetzt;jemand in der Leitung (ugs.)
-aus ermittlungstaktischen Gründen;um die Ermittlungen nicht zu gefährden
-hintenherum;durch die Hintertür (fig.);(von der Öffentlichkeit weitgehend) unbemerkt (floskelhaft);von hinten durch die kalte Küche (Spruch);hintenrum (ugs.);von hinten durch die Brust ins Auge (fig.)
-das kann dir egal sein;das musst du nicht verstehen
-Problembasiertes Lernen;Problemorientiertes Lernen
-Entdeckendes Lernen;Exploratives Lernen
-Horrorclown;Prank (engl.);böser Clown;Gruselclown
-Fahrvergnügen;Fahrspaß
-Verum;Tautologie
-Psychosoziale Onkologie;Psychoonkologie
-Tensoranalysis;Tensoranalyse
-nicht möglich;undenkbar;nach den Gesetzen der Logik unmöglich (variabel);nicht im Bereich des Möglichen;rein logisch unmöglich (ugs., variabel);(das) kann gar nicht (ugs.);außerhalb des (...) Möglichen;nicht vorstellbar;ausgeschlossen;unmöglich (Hauptform)
-nicht mit Geld zu bezahlen;für Geld nicht zu bekommen;gibt es nicht (für Geld) zu kaufen (ugs., variabel);für Geld nicht zu haben;mit Geld nicht zu bezahlen
-(einer Sache) emotional verbunden (sein);(einen) ideellen Wert darstellen;(ein) ideeller Wert (sein für);von ideellem Wert sein;(jemandem) persönlich wichtig (sein)
-egal, was Sie davon halten (mögen);auch wenn es Ihnen nicht gefällt;das wird Ihnen jetzt nicht gefallen (aber);ob es Ihnen nun passt oder nicht (ugs.);auch wenn es Ihnen (jetzt) nicht gefallen mag;was auch immer Sie davon halten (mögen);auch wenn es Ihnen nicht gefallen wird
-(pathologische) Hautveränderung;Wimmerl (ugs., bayr.);Effloreszenz (fachspr., medizinisch);Hautblüte (veraltet)
-mit gemischten Gefühlen;hin- und hergerissen (sein);mit zwiespältigen Gefühlen;mit einem lachenden und einem weinenden Auge (fig.);nicht wissen, ob man sich freuen oder traurig sein soll
-kein;nicht ein;koa (ugs., bairisch);keinerlei;null (ugs., jugendsprachlich)
-ein einziger;genau ein(e);ein einsamer;nur ein;ein(e);nur einer;ein einzelner;nur eine
-Schwanenhals;Flexarm
-Die bin ich.;Der bin ich.;Das bin ich. (Hauptform);Am Apparat.;Nehmen Sie mich! (salopp, scherzhaft)
-ab 18 (sein) (ugs.);nicht freigegeben unter 18 Jahren (sein) (fachspr., juristisch);keine Jugendfreigabe (haben) (fachspr., juristisch);(erst) ab 18 freigegeben (sein) (Hauptform);für Jugendliche unter 18 Jahren nicht geeignet;nur für Erwachsene
-altersbeschränkt;nur für bestimmte Altersgruppen freigegeben (variabel)
-Andachtsbuch;Gebetbuch
-Horcher (geh., selten);Hörer;Lauscher (geh., selten);Zuhörer
-Profitmacherei (abwertend);Geschäftemacherei (abwertend);Gewinnmacherei (abwertend);Geldmacherei (abwertend)
-Schieber;Abzocker;Spekulant;Geschäftemacher;Schacherer
-geschäftliche Tätigkeit;Geschäft(e);Geschäftsleben;geschäftliche Aktivitäten;Geschäftstätigkeit
-wirtschaftliche Aktivitäten;Wirtschaftstätigkeit
-Geschäftsleben;geschäftlicher Umgang;geschäftliches Miteinander(-Umgehen);Business (fachspr., Jargon, engl.)
-geschäftlich;unpersönlich;formell;geschäftsmäßig;offiziell;konventionell
-gebührend;ausdrücklich (ugs.);in aller Form;formell;formgerecht
-formal korrekt;der Form nach;äußerlich korrekt;(lediglich) formell;höflich
-wenn es kommt, dann aber richtig! (Spruch, variabel);(etwas ist/war) doppeltes Pech;es kommt (ganz) dicke (ugs.);doppelt Pech haben;doppeltes Pech haben;(es) kommt knüppeldick;Ein Unglück kommt selten allein. (Sprichwort);es kommt (ganz) dick (ugs.);Zuerst hatten wir kein Glück, (und) dann kam auch noch Pech dazu. (ugs., Zitat, scherzhaft)
-Buchmarke;Exlibris;Bucheignerzeichen;Bücherzeichen
-Bejahrtheit;hohes Alter;Betagtheit;vorgerücktes Alter
-im höheren Alter;im Alter;in höheren Jahren (geh.);im Seniorenalter;in seinen höheren Lebensjahren;im Ruhestand;als Rentner;als Pensionär;als Senior;nach seiner aktiven Phase;als älterer Herr
-Unauffälligkeit;Zurückhaltung;Bescheidenheit;Unaufdringlichkeit;zurückhaltendes Wesen
-ohne Respekt (gegenüber den Gefühlen anderer);respektlos;verletzend;unehrfürchtig;pietätlos (Hauptform);ohne Ehrfurcht
-Psychoneuroimmunologie;Psychoimmunologie
-(einen) Riesenschreck bekommen (haben);(sich) zu Tode erschrecken;(sich) furchtbar erschrecken;(sich) sehr erschrecken;(einen) Mordschreck(en) bekommen;denken, dass einem das Herz stehenbleibt (ugs.);zu Tode erschrocken (sein);(jemandem) fährt ein gewaltiger Schreck in die Glieder (geh., variabel)
-Fliegende Brücke;Gierseilfähre;Gierfähre
-Phloem;Siebteil
-Xylem;Holzteil
-Gedenkbanderole;Fahnenband
-Interimsspange (veraltet);kleine Ordenspange (veraltet);Bandschnalle;Ribbon (schweiz.);Ordensspange (österr.);Bandspange (veraltet);Feldschnalle (veraltet);Interimspange
-Ordensschnalle;Ordenspange
-Kapp-Putsch;Kapp-Lüttwitz-Putsch;Lüttwitz-Kapp-Putsch
-Schleppzeiger;Rattrapante (franz.)
-Bürgerversicherung;Volksversicherung
-(jemandem etwas) in Aussicht stellen;(in jemandem) die Hoffnung wecken (auf);(in jemandem) Hoffnungen wecken (auf);(jemandem etwas) verheißen (Hauptform);(jemandem etwas) versprechen;(jemandem etwas) lebhaft vor Augen stellen;(jemandem) Hoffnungen machen (auf)
-(in sich/jemandem) Bilder entstehen lassen (von);(sich/jemandem etwas) in kräftigen Farben ausmalen (variabel);(in sich/jemandem) Bilder wachrufen (von);(etwas) vor seinem/jemandes geistigem Auge entstehen lassen
-Todesschwadron;Killerkommando
-Euthanasierung;Euthanasie (bei Tieren);Einschläferung
-landen (können) (bei) (ugs., fig., Hauptform);Erfolg haben (bei);erfolgreich sein (bei);auf Gegenliebe stoßen (bei)
-in gewisser Weise (Hauptform);schon (auch);auf 'ne Art (ugs., salopp);in einer Art (ugs.);irgendwo (ugs., Jargon, veraltend);auf eine gewisse Art
-vergleichbar mit;eine Art (...) (ugs.);sowas Ähnliches (wie) (ugs.);so etwas Ähnliches wie;so etwas wie;sowas wie (ugs.)
-arbeitsunwillig (sein) (geh.);mangelnde Arbeitsbereitschaft (an den Tag legen) (fachspr., Jargon, variabel);(die) Arbeit nicht erfunden haben (fig.);arbeitsscheu (sein);(sich) verpissen (derb);(der) Arbeitswille fehlt (fachspr., Jargon, variabel);vor der Arbeit weglaufen;arbeitsunlustig (sein) (geh.);(der) Arbeit aus dem Weg(e) gehen;(sich) drücken (vor)
-(sich) vor jemandes Karren spannen lassen (fig.);von jemandem (für seine eigenen Zwecke) ausgenutzt werden;von jemandem für seine Zwecke benutzt werden;(sich) hergeben zu;(etwas) mit sich machen lassen;(sich dafür) benutzen lassen zu;(sich etwas) gefallen lassen;(sich) dazu hergeben zu
-(ein neuer) Negativrekord;absoluter Tiefpunkt;die Talsohle erreicht haben;ganz unten angekommen sein (ugs.);nicht mehr tiefer sinken können (ugs.);schlimmer kann es nicht (mehr) kommen (für) (ugs.);schlimmer geht's nicht;alles in den Schatten stellen (fig.);schlechter geht's nicht
-jedes Mal wieder;jedes Mal, wenn;jedes einzelne Mal
-Quengelzone;Kassenzone;Kassenbereich;Wartebereich an der Kasse (variabel)
-Präparandenanstalt;Präparandenschule;Präparandie
-Panikattacke erleiden;erschaudern;sich erstaunen;vom Schlag getroffen (gerührt) werden;in Bestürzung geraten;verblüfft werden;erstarren;sich entsetzen;stocken;stutzig werden;stutzen
-auf den Arbeitsmarkt drängen;um Arbeitsplätze konkurrieren;Stellen suchen
-(das) bürgerliche Spektrum;politische Mitte;(die) Mitte der Gesellschaft (Schlagwort, Hauptform)
-Strafentlassener;ehemaliger Häftling
-Raucher (Hauptform);Nikotinabhängiger
-an den Rand gedrängt werden;ausgegrenzt werden;marginalisiert werden;ins Abseits geraten
-Abhängigkeitserkrankter;Süchtiger;Süchtel (ugs., Jargon)
-Stängelripsen;Streppmaut (ugs.);Köhlstille;Rübstielchen;Stielmus;Runkelstielchen;Rübstiel;Stängelmus
-Assimilierungspolitik;Assimilationspolitik
-Zwangsassimilation;Zwangsassimilierung
-Ethnozid;kultureller Völkermord (veraltet)
-blauer Dunst (fig.);Gaukelspiel;Kulissenschieberei;fauler Zauber;Blendwerk
-zum Stillstand bringen;zum Erliegen bringen;lahmlegen
-Blattstielgemüse;Stielgemüse;Stängelgemüse
-Nummer (von/vom ...);...ausgabe;...heft;Ausgabe (von/vom ...) (Zeitung/Zeitschrift);...nummer;Heft (von/vom)
-Sonderheft;Spezialausgabe;Sonderausgabe;Sonderdruck (zu ...);Extrablatt;Sondernummer (zu ...)
-wissen, wen man ansprechen kann;(sich) auskennen (in einem Umfeld);die richtigen Leute kennen;(sich) in diesen Kreisen bewegen;Einblick haben (in eine Szene)
-rechtschaffen müde (sein) (veraltend);(sich) eine Pause verdient haben
-begleiten;mitkommen
-Geldpolitik;Geldmarktpolitik
-Güterbündel;Konsumgütervektor
-Iso-Nutzenfunktion;Nutzen-Isoquante;Iso-Nutzenkurve;Indifferenzkurve
-leicht zufriedenzustellen;nicht wählerisch (Hauptform);anspruchslos;ohne Anspruch
-schleckig (ugs., schwäbisch);kiebisch (ugs., sächsisch);haklich (ugs., österr.);gnäschig (ugs., fränk.);heiklig (bayr., österr.);käbsch (ugs., sächsisch);mäkelig (ugs., Hauptform, norddeutsch, ostdeutsch);schlauchig (ugs., rheinisch);pingelig (ugs., rheinisch);(g)schnädderfräsig (ugs., schweiz.);wählerisch (beim Essen) (Hauptform);klott (ugs., moselfränkisch);schnäkig (ugs., pfälzisch);heikel (ugs., bayr., Hauptform);krüsch (ugs., norddeutsch)
-Wichser (derb);Onanist;Masturbant
-notgeil (ugs.);ungefickt (derb);unbefriedigt;untervögelt (vulg.);sexuell frustriert;(männl. Person) sitzt auf dem Trockenen (ugs., fig.);unterfickt (vulg.);(jemandes) Schwanz ist heimatlos (derb)
-kurzfristig;für eine begrenzte Zeit;für (eine) kurze Zeit (Hauptform);befristet (sein);kurzzeitig;auf kurze Sicht
-Standgebläse (vulg.);Schwanzlutscherin (derb);Blasmaus (vulg.);Blasehase (vulg.);Fellatrix;(aktive) Oralsexpartnerin
-(sich) dem Bann einer Sache entziehen (geh.);(sich) jemandes Bann entziehen (geh.);sich losreißen (von) (fig., Hauptform);aufhören (mit);loskommen von (ugs., fig.);in Ruhe lassen
-Überdruck (vulg.);dicke Eier (vulg.);Samenstau (ugs.);Kavaliersschmerzen;Lendenpein (geh.)
-pflegen (zu tun);es sich zur Regel gemacht haben (zu);(auf etwas) konditioniert sein (Jargon);(die) Angewohnheit haben (zu);es sich zu eigen gemacht haben (zu);es gewohnt sein (zu);(es sich) angewöhnt haben zu;die Gewohnheit (angenommen) haben (zu);(etwas) gewöhnlich tun (variabel);es sich zur Gewohnheit gemacht haben (zu);abonniert sein (auf) (ugs., fig.);es zu seiner Gewohnheit haben werden lassen (zu)
-(etwas) kann jeden Moment (ugs.);es besteht ein hohes Risiko (dass) (variabel);es besteht eine hohe Wahrscheinlichkeit (dass);(etwas) könnte jeden Moment (ugs.);drohen (zu)
-homöopathische Zubereitung;homöopathisches Arzneimittel;Homöopathikum
-Potenzieren;Dynamisieren
-treffend;realistisch (Schilderung) (Hauptform);korrekt;realitätsnah
-Anlass zu der (positiven) Erwartung geben (dass);(anscheinend) die in etwas gesetzten Erwartungen erfüllen;(sich) Hoffnung(en) machen dürfen auf;versprechen zu (= verheißen);(einer Sache) zuversichtlich entgegensehen können;erwarten dürfen (dass);hoffen dürfen (dass);(sich) in der Hoffnung wiegen können (dass)
-Brustbein;Sternum (fachspr.)
-einwenden;zu bedenken geben
-Beherrschung;Zähmung;Zurücknahme;Abschwächung;Abbremsung;Mäßigung;Bändigung;Zügelung
-Aktensammlung;Dokumentensammlung;Aktei
-Orden;Ansteckplakette
-Aktbild;Aktfoto;Akt;Nacktfoto
-(jemandem) dicht folgen;(jemandem) im Nacken sitzen;dicht hinter jemandem her sein
-(jemanden) vor sich hertreiben (fig.);(den) Druck aufrechterhalten (fig.);(jemandem) keine Atempause gönnen (fig.)
-Akkord;Gedinge (Bergbau);Akkordlohn;Stücklohn;Leistungslohn
-Amtsbereich;Sektion
-Amtsbereich;Ressort;Arbeitsgebiet;Dezernat;Sprengel
-Fließbandarbeit;Fließarbeit;Arbeit am Fließband
-Aramid;Polyaramid;aromatisches Polyamid
-Vollbank;Universalbank
-Mexikanische Expedition;Strafexpedition;Pancho-Villa-Expedition
-neu aufsetzen (Rechner) (ugs., Hauptform);(Betriebssystem) neu installieren;(neu) einrichten
-angefangen und nicht zu Ende gemacht;halbfertig;halb fertig;(nur) zur Hälfte fertiggestellt
-hier und da;stellenweise;an einzelnen Stellen
-zur Wahrheit gehört auch (dass) (floskelhaft);wer (...) sagt, verschweigt (dass);man muss (aber) auch sehen, dass;nicht nur Vorteile bieten;(nur) die halbe Wahrheit;einseitig;nicht nur Nachteile haben;(nur) die eine Seite (der Medaille)
-(sehr) viel um die Ohren haben (Redensart, fig.);(für anderes) kaum Zeit haben;(voll) ausgelastet (mit seiner Arbeit) (variabel);(sehr) eingespannt (sein) (Hauptform);(beruflich) stark gefordert (sein) (verhüllend);nur noch für die Arbeit leben;viel am Hals haben (ugs., Redensart, fig.);(sein) Leben besteht nur aus Arbeit
-Granatenschock (veraltet);Schützengrabenneurose (veraltet);Kriegsneurose;Kriegszittern (veraltet);Schützengrabenschock (veraltet)
-posttraumatische Belastungsreaktion;posttraumatisches Belastungssyndrom;psychotraumatische Belastungsstörung;basales psychotraumatisches Belastungssyndrom;posttraumatische Belastungsstörung;posttraumatische Belastungserkrankung
-(etwas) kann kein Zufall sein;solche Zufälle gibt es nicht;(da) steckt mehr dahinter
-Frühstückskartell;geheime Absprache(n)
-Durchstecherei;Weitergabe dienstlicher Informationen;Geheimnisverrat
-Amtsvergehen;Vergehen im Amt;Dienstvergehen
-Silserli (schweiz.);Laugengebäck;Laugenweckerl (österr.);Silserbrot (schweiz.)
-Brezenstange (bayr.);Laugenstange
-Oberschwaben;Schwäbisches Oberland
-Regiotram;Zweisystemstadtbahn;Mehrsystembahn;Stadt-Umland-Bahn;Stadtregiotram;Zweisystembahn;Regionalstraßenbahn;Regionalstadtbahn;Stadtregionalbahn;Mehrsystemstadtbahn
-Suchtpotenzial;Suchtfaktor
-Presshülse;Ferrule;Zwinge
-Unschönheit;Schönheitsmakel;kosmetisches Problem (Hauptform);ästhetische Beeinträchtigung
-(etwas) bieten;(etwas) vorweisen (können);aufwarten (können) mit (fig.);(etwas) zu bieten haben
-Konsumlaune (ugs.);Konsumfreude;Konsumbereitschaft
-Strafbataillon (ugs.);Bewährungsbataillon
-(jemandem) vorkommen wie;(sich an etwas) erinnert fühlen
-keine einfache Lösung wissen;auf die Schnelle keine Antwort wissen;keine schnelle Antwort haben;erst einmal überlegen müssen (ugs.);so schnell keine Antwort parat haben;um eine schnelle Antwort verlegen sein;ins Grübeln kommen
-ins Grübeln kommen;anfangen, (ernsthaft) darüber nachzudenken;nachdenklich werden
-mit sich zurate gehen (geh., veraltend);hin und her überlegen (ugs.);gründlich nachdenken (über);viel nachdenken (über) (ugs.)
-Registeraufladung;sequentielle Aufladung
-Twin Turbo;Biturbo
-Revolution des gemeinen Mannes;Deutscher Bauernkrieg
-noch etwas Zeit haben (bis);(es ist) noch ein bisschen hin (bis) (ugs.);(es ist) noch etwas hin (bis) (ugs.);(es ist) noch etwas Zeit (bis)
-(sich) in Selbstmitleid suhlen (fig., variabel);(seine) Wunden lecken (fig.);mit seinem Schicksal hadern;in Selbstmitleid verfallen;den Leidenden spielen
-nicht die Kompetenz haben (zu);(etwas) nicht entscheiden dürfen;(etwas) nicht zu entscheiden haben;nicht in jemandes Ermessen liegen;nicht befugt sein zu;nicht in jemandes Händen liegen (geh., fig.);nicht dürfen (dienstlich);nicht in jemandes Ermessensspielraum liegen
-erfreulicherweise (Hauptform);zu jemandes (großer) Freude;angenehmerweise;coolerweise (ugs.)
-verfassungsgemäß;grundgesetzkonform;verfassungsmäßig;verfassungskonform;grundgesetzadäquat
-(sich) aufgefordert fühlen (zu);finden, dass es an der Zeit ist (zu);es drängt jemanden (zu);(sich) bemüßigt sehen;(sich) gedrängt fühlen (zu)
-schlechter Scherz (ugs.);Schmierenkomödie;(eine) Farce (Hauptform);unwürdiges Schauspiel;Schmierentheater
-Tiroler Malefizordnung;Maximilianische Halsgerichtsordnung
-gichtiger Mund;Urgicht
-Kapitelsvikar;Kapitularvikar
-Kirchenprovinz Paderborn;Mitteldeutsche Kirchenprovinz
-Norddeutsche Kirchenprovinz;Kirchenprovinz Hamburg
-Rheinische Kirchenprovinz;Kirchenprovinz Köln
-Kirchenprovinz Freiburg;Oberrheinische Kirchenprovinz
-Kirchensteuer (ugs.);Kirchenbeitrag
-(jemand ist) nicht zu beneiden;(ich) möchte nicht an seiner Stelle sein;seine liebe Last haben mit;(ich) möchte nicht mit ihm tauschen;sei froh, dass du nicht an seiner Stelle bist (variabel);(jemand) hat es schwer (mit)
-seines Lebens nicht mehr froh werden (Redensart);eine schwere Zeit durchmachen;(etwas ist) kein Zuckerschlecken (für);schwer zu kämpfen haben;einiges einstecken (müssen);(vom Schicksal) (schwer) gebeutelt werden;(einige) Nackenschläge einstecken (müssen) (fig., variabel)
-Matrizenmultiplikation;Matrixmultiplikation
-Matrizenprodukt;Produktmatrix;Matrixprodukt
-Matrizenaddition;Matrixaddition
-Matrizensumme;Matrixsumme;Summenmatrix
-skalare Multiplikation;Skalarmultiplikation;S-Multiplikation
-Zechensterben;Zechenschließungen
-nach Lage der Dinge;so wie die Dinge liegen;unter den gegebenen Umständen
-ja schließlich;schließlich und endlich;ja nun
-Vorkarpaten;Subkarpaten
-Östliche Vorkarpaten;Moldauische Vorkarpaten
-Getische Hochebene;Getisches Hochland
-(sich) vorstellen;(seinen) Namen nennen
-immer noch (ugs.);schließlich;wie du (ja sicherlich) weißt;immerhin
-maximal (Adjektiv);höchstmöglich
-Nietendrücker (ugs., Jargon);Kettennieter;Kettennietdrücker (fachspr.)
-Kette (ugs.);Fahrradkette
-(das) Gesinde (Landwirtschaft);(die) Knechte und Mägde
-Zustellrad;Postrad;Postfahrrad
-Lastenrad;Transportrad;Lastenfahrrad
-Grubenflitzer;Grubenfahrrad
-konturlos;ohne Haltung;wachsweich (abwertend, fig.);butterweich (abwertend, fig.);windelweich (abwertend, fig.)
-tilgen;annullieren;canceln (engl.);löschen;durchixen;x-förmig durchstreichen;ungültig machen;stornieren
-(die) Wahl haben zwischen (Hauptform);wählen können zwischen;(sich) für A oder B entscheiden können;wahlweise A oder B (tun) können
-bleib mal locker (ugs.);jetzt beruhig' dich mal wieder! (ugs.);komm (mal) wieder runter (ugs., fig.);(nun) halt mal den Ball flach (ugs., fig.);wer wird denn gleich!? (geh., veraltend);jetzt reg dich (doch) nicht (gleich) auf (ugs.);reg dich (wieder) ab (ugs.);(jetzt) mach (aber) mal halblang (ugs.);(jetzt) beruhig(e) dich (erst mal)! (ugs.);(jetzt) halt (mal) die Luft an! (ugs.);(jetzt) chill mal (ugs., jugendsprachlich);(immer schön) geschmeidig bleiben (ugs., jugendsprachlich);(so) beruhigen Sie sich (doch)! (geh.);beruhige dich (wieder)!;chill mal deine Base (ugs., jugendsprachlich, variabel);entspann dich! (ugs.);krieg' dich wieder ein! (ugs.)
-(etwas) ums Verrecken nicht wollen (derb);da kriegen mich keine zehn Pferde hin (ugs., Redensart, fig.);(etwas) auf keinen Fall wollen;(etwas) partout nicht wollen;(sich) mit Händen und Füßen wehren (gegen) (fig.);(sich) mit Händen und Füßen sträuben (gegen) (fig.)
-kein Miene verziehen;(sich) nichts anmerken lassen;mit unbeweger Miene;(mit) ausdruckslosem Gesicht
-Baulöwe;Immobilienhai (abwertend);Immobilieninvestor;Immobilienspekulant (abwertend);Immobilienunternehmer (Hauptform)
-geschlechtsreif;mannbar;zeugungsfähig;erwachsen
-nichts anfangen können mit (ugs.);(etwas) sagt mir nichts (ugs.);(etwas / jemanden) nicht kennen;noch nie etwas gehört haben von (ugs.);(dazu) fällt mir nichts ein (ugs.);(jemandem) ganz neu sein (ugs.);wer soll das sein?;(jemandem) gänzlich unbekannt sein (geh.);(etwas) zum ersten Mal hören (ugs.)
-Faktizität;sinnlich erfahrbare Gegenständlichkeit;Tatsächlichkeit
-Einflussnahme einer Kultur auf eine andere;Transkulturation
-(seine) Einkünfte aufstocken (mit);Nebeneinkünfte haben;(einen) Zweitjob haben (ugs.);(sich) was nebenbei verdienen (ugs.);über eine zusätzliche Einnahmequelle verfügen;(sich etwas) hinzuverdienen;(sein) Gehalt aufbessern;(sich) ein paar Euro nebenbei verdienen (ugs.);(sich etwas) dazuverdienen;(ein) zweites Einkommen haben (variabel);zusätzliche Einkünfte haben;(sich) was dazuverdienen (ugs.);(eine) Nebentätigkeit ausüben
-Wandschirm;Paravent (geh., franz.);spanische Wand;Stellwand
-mit Verweis auf;unter Berufung auf;unter Bezugnahme auf;unter Verweis auf;mit Hinweis auf
-andeuten;Andeutungen machen;anspielen auf;hindeuten auf;erahnen lassen;nicht klar umreißen;(eine) Andeutung machen;nicht klar benennen;umrisshaft zu erkennen geben
-vorsichtig andeuten;(einen) dezenten Hinweis geben
-(jemanden) gehen lassen;(jemanden) ziehen lassen;(jemanden) nicht länger festhalten
-Üben, üben, üben. (Spruch);Repetitio est mater studiorum. (geh., Sprichwort, bildungssprachlich, lat.);Übung macht den Meister. (Sprichwort)
-Plenus venter non studet libenter. (geh., Sprichwort, bildungssprachlich, lat.);Ein voller Bauch studiert nicht gern. (sprichwörtlich)
-Schnabeligel;Ameisenigel;Echidna (fachspr.)
-Kiwifrucht;Chinesische Stachelbeere;Kiwi (Hauptform)
-Kiwi;Schnepfenstrauß
-Kiwi (ugs.);Neuseeländer
-nach unten gehen;(sich) verringern;zurückgehen;schrumpfen;weniger werden;(sich) vermindern;(die) Reihen lichten sich (Redensart, floskelhaft);(zahlenmäßig / prozentual) abnehmen;sinken;(sich) verkleinern;(he)runtergehen;(sich) reduzieren;kleiner werden;(sich) lichten
-hochbeschäftigt;stark in Anspruch genommen (ugs.);stark beschäftigt (ugs.)
-Knallfunkensender;Knarrfunkensender
-Posthülfstelle (veraltet);Posthilfstelle
-Transduktor;Magnetverstärker
-Hepatodystrophie (fachspr., griechisch);Leberversagen;Leberinsuffizienz (lat.)
-Pomoranisch;Ostseeslawisch
-Lebuser Land;Land Lebus
-Urslawisch;Protoslawisch
-Ursprache;Grundsprache;Protosprache
-Molisekroatisch;Moliseslawisch
-Altbulgarisch;Altslawisch;Altkirchenslawisch
-Knaanisch;Kanaanitisch;Judenslawisch
-Altostslawisch;Altrussisch
-Westpolessisch;Westpolesisch
-himmelstürmend;übermenschlich;prometheisch (geh., griechisch)
-Sofioter Talkessel;Sofiaebene
-Wischmopp;französischer Mopp
-Mopp;Flaumer (schweiz.)
-Fidel Castro;Máximo Líder (fachspr., Jargon, spanisch)
-zwieträchtig;zerstritten
-Verfügungsrahmen (fachspr., Jargon);Limit (ugs.)
-Verfügungsrahmen für Überweisungsaufträge (sowie für Daueraufträge und Auslandsaufträge);Überweisungslimit;höchstmöglicher Überweisungsbetrag;Auftragslimit
-Kartenlimit (ugs., Hauptform);Verfügungsrahmen für eine EC- (oder Kredit- oder Bank-) Karte;Limit (für eine Karte) (ugs.)
-Tageslimit (im bargeldlosen Zahlungsverkehr);(täglicher) Verfügungsrahmen (für Bankgeschäfte);Auszahlungslimit (für Abhebungen an einem Tag)
-Souffleur (geh., fig., franz., ironisch);Vorsager
-Zwecklehre;Teleologie
-unter uns regeln;unter sich regeln;(sich) den Papierkram schenken;(eine) informelle Lösung finden;nicht den normalen Dienstweg einhalten (variabel);unter der Hand regeln;auf dem kurzen Dienstweg erledigen (variabel)
-wenn (gegenwarts- und zukunftsbezogen);gleichzeitig mit;zu dem Zeitpunkt, als;wie (ugs.);zu diesem Zeitpunkt;indem;wo (ugs.);als (vergangenheitsbezogen)
-(irgendwo) lagern (Hauptform);aufbewahrt werden;untergebracht sein;deponiert sein;eingelagert sein;(irgendwo) verwahrt werden;in Verwahrung sein
-abgeschlossen haben (mit);seinen Frieden gemacht haben (mit)
-Insellösung (fig., Hauptform);funktioniert nur (+ Ortsergänzung)
-nicht (untereinander) abgestimmt;nicht abgesprochen;(im) Alleingang;ohne Absprache
-unkoordiniert vorgehen;(sich) nicht absprechen;jeder für sich agieren;(sich) nicht auf ein gemeinsames Vorgehen einigen
-isolieren;unter Quarantäne stellen (Hauptform);auf eine Isolierstation verlegen;absondern
-Heimisolation;Isolierungsmaßnahme;Quarantäne (Hauptform);Absonderungsmaßnahme;Zwangsisolierung
-herauslesen;rauspicken (ugs.);rausfischen (ugs.);herauspicken;raussuchen (ugs.);herausgreifen;(einzeln) heraussuchen (Hauptform);herausfischen
-Organstreitigkeit;Organstreit
-auf die Seite legen;zur Seite legen;beiseitelegen;auf die Seite tun;weglegen
-ins Archiv geben;archivieren
-(vom Teppich / Boden / Bahnsteig ...) aufsammeln (Hauptform);auflesen;aufnehmen;aufklauben
-(noch) leben (salopp);unter den Lebenden weilen;unter den Lebenden sein;es gibt jemanden noch (ugs., salopp);am Leben sein
-leben von (Hauptform);(seinen) Lebensunterhalt bestreiten (von / mit / durch);(jemandes) Einkunftsquelle(n) (ist / sind) (fachspr., Amtsdeutsch)
-leben von (Hauptform);(sich) ernähren (von)
-ein (...) Leben haben;das Leben eines/einer (...) führen;(irgendwie) leben (Hauptform);(eine bestimmte) Lebensweise haben;ein (...) Leben führen;(einen bestimmten) Lebensstil haben
-bei jemandem schrillen sämtliche Alarmglocken (fig.);misstrauisch werden;(sehr) auf der Hut sein;vorgewarnt sein;bei jemandem klingeln alle Alarmglocken (fig.)
-auf alles gefasst sein;mit dem Schlimmsten rechnen
-Finger weg (von ...)!;äußerste Vorsicht ist geboten (bei / wenn) (variabel);dringend abzuraten sein (von)
-Schmeiß weg, kauf neu. (Spruch);Schmeiß-weg-kauf-neu-Einstellung;Wegwerfmentalität
-keine Ansprüche stellen;einfach leben;mit wenigem zufrieden (sein);mit wenigem auskommen;(sich) mit wenigem zufriedengeben;genügsam leben
-Acetylzellulose (veraltet);Celluloseacetat
-der Herr soll mich strafen (wenn);und wenn du mich totschlägst;Gott soll mich strafen (wenn);der Himmel soll mich strafen (wenn);du kannst mich totschlagen (wenn);ich will auf der Stelle tot umfallen (wenn)
-reden (mit);die Schnauze aufmachen (derb);das Maul aufmachen (derb);endlich etwas sagen;den Mund aufmachen (auch figurativ)
-Einlassung;Redebeitrag;Stellungnahme;Diskussionsbeitrag (Hauptform);Einwand;Einwendung;Wortbeitrag;Beitrag;Einwurf;Argument
-auf Ehre und Gewissen versichern;(sein) Ehrenwort geben (auf);(sein) Wort geben auf;ehrenwörtlich versichern;hoch und heilig beteuern;bei allem, was einem heilig ist, versichern;hoch und heilig versichern
-mein Wort!;(großes) Ehrenwort!;mein Ehrenwort!;darauf gebe ich (dir) mein Ehrenwort (Versicherung der Wahrheit);großes Indianer-Ehrenwort! (ugs., Kindersprache, scherzhaft);darauf hast du mein Wort
-darauf verwette ich meinen Kopf (ugs., veraltend);dann heiß(e) ich Meier! (ugs., ironisch, variabel);dann kannst du Meier zu mir sagen (ugs.);mit Sicherheit davon ausgehen, dass;darauf verwette ich meinen Arsch (ugs.);zu 100 Prozent davon ausgehen, dass;ich fress(e) einen Besen, wenn (ugs.);ich will Meier heißen, wenn (ugs., ironisch)
-Entkommunisierung;Dekommunisierung
-sicherstellen (dass);sorgen für;veranlassen (dass);dafür Sorge tragen, dass;dafür sorgen, dass
-sorgen für;bereitstellen;liefern
-sorgen für;(den) Anlass bieten (für)
-keinen Erfolg haben;nichts schaffen (können);keine Wirkung haben;nichts erreichen (variabel);nichts ausrichten (können) (variabel);nichts reißen (können) (ugs.);nichts bewirken (können);nichts bestellen können
-(jemanden) am Leben bleiben lassen;(jemanden) verschonen;(jemandem) das Leben schenken (literarisch);(jemanden) am Leben lassen;(jemanden) leben lassen;nicht töten
-Unkraut vergeht nicht. (Sprichwort, sarkastisch);Totgesagte leben länger. (Sprichwort)
-(sich) mit (...) Euro begnügen müssen;schlecht bezahlt werden (Hauptform);für einen Hungerlohn arbeiten;(nur) den Mindestlohn bekommen;(sehr) wenig verdienen;mit (...) Euro abgespeist werden
-auf dem Trockenen sitzen (fig.);alles ausgegeben haben;nicht einen Cent haben;kein Geld mehr haben;keinen Cent mehr haben
-Linker Faschismus;Roter Faschismus;Linksfaschismus;Rot-Faschismus
-Chutzen;Hochwacht
-Kreitfeuer;Kreidfeuer
-Turmbläser;Türmer;Turmwächter
-Türmerwohnung;Türmerstube;Türmerzimmer
-(eine) brotlose Kunst (sein);(mit etwas) lässt sich kein Geld verdienen;nichts einbringen;nicht leben können von;(dabei) kommt nichts (he)rum (ugs.)
-Mittelmeerklima;Etesienklima
-Wolfaustreiben (selten);Wolfauslassen;Wolfausläuten
-Thesprotia;Thesprotien
-Fäkalhumor;skatologischer Humor (selten)
-Verrückter;Spinner;Wahnsinnsknabe
-rechtsverbindlich werden;in Kraft treten (Gesetz);Gesetzeskraft erlangen (geh.)
-Markt (für ...) ist leergefegt (fig.);es herrscht (...)mangel;(es herrscht) Nachwuchsmangel;es gibt keine Bewerber (für) (variabel);es wurden zu wenige (...) ausgebildet
-face to face (ugs., engl.);in direkter Konfrontation;in persönlicher Auseinandersetzung;im persönlichen Gespräch;von Angesicht zu Angesicht;persönlich (Hauptform);nicht am Telefon;nicht per Telefon
-weibliche Begleitung;Begleiterin;Frau an seiner Seite
-mit (ugs.);nicht allein;in Begleitung (von);begleitet (von);zusammen (mit);mit Begleitung
-offizielle Version;Sprachregelung
-Jungfrau;(Person) ohne sexuelle Erfahrung
-Exhibitionistin (weibl.);Exhibitionist (männl.)
-(sich) einlaufen;(sich) aufwärmen;(sich) warmlaufen
-eine Weile tragen (ugs.);einlaufen (Schuhe)
-auf den Platz laufen;einlaufen (Fußball o.ä.);aufs Spielfeld laufen
-(die) Zusammenarbeit beenden (floskelhaft, verhüllend);(sich) trennen (floskelhaft, verhüllend);(das) Arbeitsverhältnis beenden
-(sich) einlaufen lassen (Badewasser);einlassen
-stiefmütterlich behandeln (und...);(nur) notdürftig versorgen mit;(jemanden) kurzhalten;(jemandem) nur wenig (...) geben (variabel);(jemanden) abspeisen mit;nur (...) bekommen (variabel)
-Zwei-Drittel-Regel;Drittel-Regel
-Mundspülung;Mundwasser
-Justitiar;Rechtsberater;Justiziar
-Junktimklausel;Junktim
-nasskalt (Wetter) (Hauptform);schäbbig (ugs., rheinisch, ruhrdt.);schmuddelig (ugs.);usselig (ugs., ruhrdt.);fies (ugs., rheinisch)
-schlecht träumen;schlimme Träume haben;schwere Träume haben;(einen) bösen Traum haben;schwer träumen
-interreligiöse Ehe;Mischehe;konfessionsverschiedene Ehe;Ehe zwischen konfessionsverschiedenen Partnern
-Ehe zwischen Partnern verschiedener Ethnien;Ehe zwischen Partnern verschiedener Kulturen;Mischehe;Multikulti-Ehe (ugs.)
-Rassenschande (NS-Jargon, historisch);Blutschande (NS-Jargon, historisch)
-Gummiparagraph (ugs., fig.);lässt sich so oder so auslegen (ugs.);gesetzliche Bestimmung mit großem Ermessensspielraum
-bekannte Politiker;Politprominenz
-bekannte Leute;Person des öffentlichen Lebens;(die) Rang und Namen haben (variabel);(die) Berühmtheiten;Prominenz
-Pose;räumliche Lage
-Industrieller Manipulator;Industrieroboter
-Handhabungseinrichtung;Handhabungsgerät
-(aus etwas) könnte mehr werden;einen Fuß in der Tür haben (fig.);nicht völlig chancenlos sein;nicht ignoriert werden können
-ankommen auf;abhängen von
-Hospitalschiff;Lazarettschiff (Jargon, militärisch)
-festtreten;antreten
-(sich) desinteressiert zeigen;keine Chancen haben (bei);(sich) nicht interessiert zeigen;nicht landen können bei (fig.);(sich) wenig interessiert zeigen;kein Interesse haben (ugs.);nichts wissen wollen (von) (Hauptform)
-Stipulierung;Stipulation
-nichts weiter;eigentlich nichts (nur ...) (ugs.);nichts Besonderes
-ennetbirgische Vogtei;ennetbergische Vogtei;Welsche Vogtei
-vor allem (auch);nun gar (geh.);umso mehr;a fortiori (fachspr., bildungssprachlich, lat.);erst recht
-gebührender Abstand (variabel);respektvoller Abstand (variabel)
-aufpassen, dass man jemandem/einer Sache nicht zu nahe kommt;einen großen Bogen machen um (auch figurativ);einen Bogen schlagen (um)
-für Geschlossenheit sorgen;den Laden zusammenhalten (ugs., fig., salopp)
-schlaglichtartig verdeutlichen;(ganz gut) charakterisieren;auf einmal erkennbar werden;ein bezeichnendes Streiflicht werfen auf (fig.)
-so (Adjektiv) wie möglich;denkbar (+ Adjektiv);(Superlativ)möglich;so (Adjektiv) wie (überhaupt nur) vorstellbar;könnte nicht (Komparativ) sein (variabel)
-Verwahrloster;kaputter Typ (ugs.);Kaputtnik (derb);Heruntergekommener
-ein Mann seines Schlages (männl.);eine wie sie (weibl.);einer wie er (männl.);eine Frau ihres Schlages (weibl.);eine vom Schlage einer (...) (weibl.);jemand wie (...);einer vom Schlage eines (...) (männl.)
-Fahrzeugkolonne;Kolonne;Konvoi (geh.);Schlange;Karawane (von Fahrzeugen) (fig.)
-herausgucken;überstehen;vorstehen;auskragen (fachspr., technisch);hervorragen;hervorstehen;herausragen
-Prachtweib;sehr gutaussehend;Prachtkerl;Prachtbursche;Leckerbissen (fig.);Prachtexemplar (Hauptform)
-Hinterwäldlertum;Zurückgebliebenheit;Provinzialität (Hauptform);Piefigkeit;Kleinstadtmief (ugs.);Landpomeranzentum
-Weltoffenheit (Hauptform);Weltgewandtheit;Weltläufigkeit
-Luxusbraut (ugs.);Prinzesschen (ugs.);Luxusbiene (ugs.);verwöhnte Göre (ugs.)
-Verbohrtheit;Ignoranz;Engstirnigkeit;Beschränktheit;Borniertheit;Schubladendenken (fig.)
-unaufgeregt;wie zufällig;wie unbeabsichtigt;wie nebenbei;nur mal so (dahingesagt);beiläufig;(eine) Bemerkung fallen lassen;wie unbeteiligt;wie von ungefähr;lässig
-gären lassen;aufgehen lassen;gehen lassen (Teig) (Hauptform)
-ruhen lassen (beim Kochen / Backen);stehen lassen
-hochgehen (ugs.);aufgehen (Teig);aufgetrieben werden
-verstehen;nachvollziehen können;überzeugend finden;(jemandem) einleuchten (Hauptform);(jemandem) nachvollziehbar erscheinen;(für jemanden) plausibel sein;(für jemanden) nachvollziehbar sein;(jemanden) überzeugen
-erkennen;(jemandem) klar werden (Hauptform);Klick machen (bei jemandem) (fig.);verstehen;(bei jemandem) fällt der Groschen (fig.);(einer Sache) inne werden (geh., literarisch, veraltet);(jemandem) aufgehen
-nicht länger ignorieren können;(langsam) bewusst werden;allmählich begreifen (variabel);(jemandem) dämmern (Hauptform);anfangen, zu verstehen;(etwas) ahnen;nach und nach verstehen
-(etwas) kapiert haben (ugs.);(es) gefressen haben (ugs., Hauptform);verstanden haben
-was weißt du denn schon! (ugs.);du hast ja keine Ahnung (ugs.)
-Röhricht (Hauptform);Schilf;Schilfrohrbestand;Schilfgürtel;Schilfbewuchs
-Uferbereich;Ufer;Uferzone
-Gewässerrandstreifen;Uferstreifen
-Bachaue;...aue;Flussaue;Aue;Uferlandschaft
-Auwald;Bruch;Bruchwald;Moorwald;Sumpfwald;Broich (regional)
-Eisenerz;Magnetkies
-Magnifikus;Hochschulrektor (akademisch);Rektorin (akademisch, weibl.);Rektor (akademisch, männl.);Magnifizenz (Anredeform, akademisch, formell)
-Magnitudo;Sternhelligkeit
-Elefantenführer;Mahut
-(noch) nicht gesagt sein;(noch) nicht entschieden sein;(noch) nicht raus sein (ugs.)
-(sich) darin versuchen (zu);(den) Versuch unternehmen (zu);(einen) Versuch unternehmen (um zu);(einen) Versuch starten;(es) versuchen zu (Hauptform);(etwas) versuchen (Hauptform);(etwas) probieren
-mehrere Versuche unternehmen (variabel);mehrmals versuchen (variabel);(es gab) mehrere Versuche
-Ovarialzyste;Eierstockzyste
-chronische hyperandrogenämische Anovulation;Stein-Leventhal-Syndrom (veraltet);polyzystisches Ovarial-Syndrom;polyzystisches Ovar-Syndrom;polyzystische Ovarien
-nicht viele;wenige (Hauptform)
-würde dir das gefallen?;wär das okay für dich? (ugs.);was hältst du davon?;wär das was? (ugs., Hauptform);wär' das in deinem Sinne?
-in Vorhalte (haben);vor sich halten;(etwas) vorhalten;vorstrecken;nach vorne halten (Hauptform);vorgestreckt halten;nach vorne strecken
-vorhalten (mit Zeitdauer) (Hauptform);Kraft geben;satt bleiben
-(sich) (etwas) vor (...) halten;(sich) (etwas) vorhalten
-(jemandem) den Spiegel vorhalten (fig.);(jemandem) zeigen, wie er wirklich ist;(jemanden) mit sich selbst konfrontieren
-Kritik leisten;Kritik formulieren;einer kritischen Würdigung unterziehen (geh.);(konstruktiv) kritisieren
-(sich ein Kleidungsstück) anhalten;(sich ein Kleidungsstück) vorhalten
-(jemandem jemanden) als Beispiel vorhalten;(jemandem jemanden) als Muster vorhalten;sagen, dass sich jemand ein Beispiel nehmen soll (an) (variabel)
-ausreichen (Menge, Zeit);(he)rumkommen mit (ugs.);genügen;(genug / zu wenig) haben;zureichen (ugs., regional);vorhalten (mit Zeitdauer);langen (ugs.);hinreichen (geh.);auskommen;(genug / zu wenig / ausreichend) da sein (ugs.);(genug / zu wenig / ausreichend) vorhanden sein;reichen;(mit etwas) kommen (über / durch / bis) (Zeitspanne, Ziel)
-ressourcenschonend;(wirtschaftlich) nachhaltig
-(jemandem etwas) zureichen;(jemandem etwas) angeben;(jemandem etwas) anreichen;(he)rüberreichen
-abwürgen (Diskussion);nicht ans Licht der Öffentlichkeit kommen lassen;zu verheimlichen (ver)suchen;unterdrücken;unter den Teppich kehren (fig.)
-(einen) Termin machen;(sich) anmelden (bei);(einen) Termin vereinbaren;(ein) Treffen vereinbaren
-(die) Schotten dichtmachen (ugs., fig.);(sich) abschotten;die Grenzen dichtmachen (ugs.);die Grenzen schließen;niemanden mehr reinlassen
-(sich) verbarrikadieren;(sich) verschanzen;(sich) verrammeln;(sich) einbunkern;(sich) abschotten;(sich) abriegeln;(sich) einigeln
-(jemanden) abschotten (vor);(jemanden) schützen (vor);(jemanden) abschirmen (vor)
-(jemanden) fernhalten;auf Abstand halten;nicht in die Nähe kommen lassen;nicht herankommen lassen;(jemanden) aufhalten;auf Distanz halten;nicht näherkommen lassen
-was ist hier los?;was haben wir hier?;um was geht es hier?
-Abbau des Restalkohols;Ausnüchterung
-(wieder) nüchtern werden;(sich) ausnüchtern
-aufbringen (Schiff);(die) Befehlsgewalt übernehmen (über)
-züchterische Entwicklung;Zucht;Züchtung
-Tiermast;...fleischproduktion;Fleischproduktion;...mast;Viehmast
-punktieren (fachspr.);stechen
-(wie durch) ein Wunder;mirakelhaft;wundersam (Hauptform);mirakulös;(wie) ein Mirakel;unerklärlich;wunderbar (geh.)
-nicht normal (sein);nicht mit rechten Dingen zugehen
-(sich) senkrecht halten;(sich) auf den Beinen halten;nicht hinfallen
-Finnische Demokratische Republik;Demokratische Republik Finnland
-heute;im Laufe des Tages (= heute) (ugs.);mit dem heutigen Tag(e)
-mit Stand von heute;heute (ugs.);nach heutigem Stand;zum jetzigen Zeitpunkt;nach aktueller Lage der Dinge;Stand heute (Jargon);nach heutiger Lage der Dinge;so wie die Dinge jetzt liegen (variabel)
-nicht wollen (ugs., fig.);(jemandem) den Dienst versagen;seinen Dienst versagen;nicht funktionieren
-extra;betont (+ Adjektiv);erst recht
-berauschen;knallen (ugs.);reinhauen (ugs.);(jemanden) benebeln;betrunken machen (aufgrund des Alkoholgehalts) (Hauptform);(jemanden) beschwipsen
-vorher (schon) etwas trinken;(sich) eintrinken (ugs.);(sich) warmtrinken (ugs.);vorglühen (ugs., Hauptform)
-Straßenkreuzer;dicker Brummer (ugs.);schwerer Wagen (ugs.);großes Auto;Dickschiff (ugs., fig.);Schiff (ugs., fig.)
-Traumkulisse (fig.);traumhaft schöne Landschaft;atemberaubende Landschaft
-B-Promis;B-Prominente;B-Prominenz
-Bekannte und weniger Bekannte;Stars und Sternchen
-niedere Dienstränge;niedere Chargen;niedere Dienstgrade;niedere Ränge;untere Chargen
-niedere Chargen (geh., abwertend, fig.);untere Chargen (geh., abwertend, fig.)
-(jetzt kommt) dein großer Auftritt (ugs., ironisierend, variabel);du bist dran (ugs.)
-(die) Ereignisse überschlagen sich;(es) kommt knüppeldick (ugs., ironisch);(es) passiert viel auf einmal
-an prominenter Stelle platziert (sein);hervorgehoben (sein);ganz vorne stehen (Text)
-Luxusgefährt;Angeberauto;Zuhälterschlitten (derb);Protzkarre;Angeberkiste
-kein Erholungsheim (sein) (fig., übertreibend);keine Sozialstation (sein) (fig., übertreibend);(eine) Gegenleistung erwarten;nicht Mutter Theresa (sein) (übertreibend)
-erfolgsorientiert;gewinnorientiert;profitorientiert
-mit Argusaugen wachen über;keinen Moment aus den Augen lassen
-mit wenigen Handgriffen (variabel);im Handumdrehen;ohne langes Überlegen
-anrennen gegen;anstürmen gegen
-Großer Januarkomet;Tageslichtkomet
-Jüdische Nationale Partei;Jüdischnationale Partei
-Weißrussische Volksrepublik;Weißruthenische Volksrepublik
-Volksrepublik;Volksdemokratie
-Vierwaldstättersee;Luzerner See (historisch)
-karge Worte;wenige (, nichtssagende) Worte;dürre Worte
-Teleskopkuppel;Sternwartekuppel
-astronomischer Stuhl;Beobachterstuhl
-Teleskoppfeiler;Teleskopsäule
-Spleißbox;Spleißverteiler
-Pazifik-Allianz;Pazifische Allianz
-Aufenthaltstitel (juristisch);Aufenthaltsgenehmigung;Bleibe-Erlaubnis;Bleibeerlaubnis;Aufenthaltserlaubnis
-(in der) Diaspora (leben);in Emigration lebende Menschen
-ein formloses Etwas;eine undefinierbare Masse
-den Tiefpunkt bezeichnen;den Tiefpunkt markieren;den Tiefpunkt (eines Verlaufs) darstellen;der Tiefpunkt sein
-den Höhepunkt (eines Verlaufs) darstellen;den Höhepunkt markieren;den Höhepunkt bezeichnen;der Höhepunkt sein
-(ein) Wendepunkt sein;(den/einen) Wendepunkt markieren;(den/einen) Wendepunkt bezeichnen;(den/einen) Wendepunkt darstellen
-Euphorbia pulcherrima (fachspr., botanisch);Weihnachtsstern (Hauptform);Poinsettie
-(jemandem) zu seinem Schrecken einfallen;(jemandem) siedend heiß einfallen
-unbekümmert;salopp;hanswurstig (ugs.);flapsig (Bemerkung, Auftreten);nonchalant;unernst
-Absicherungsstrategie;Wertsicherungsstrategie
-Obere Bundesbehörde;Bundesoberbehörde
-Universal;Universalinstrument
-Phase;Phasenwinkel
-Ringlaser;Laserkreisel
-leidender Christus;Schmerzensmann;Bild des Mitleids;Miserikordienbild;Mann der Schmerzen;Erbärmdebild (fachspr.)
-Vergeheimnissung (geh., selten);Mystifikation;Mystifizierung;Verrätselung
-Wunderglaube;Wundergläubigkeit
-Überschwemmung;Hochwasser;Überflutung
-Meteoriteneinschlag (Hauptform);Meteoritenaufprall;Meteoritenaufschlag
-(das) Glück auf seiner Seite haben;Glück haben;(das) Glück ist auf jemandes Seite;(das) Glück ist jemandem hold (geh.);Fortuna meint es gut mit (geh., fig.);Fortuna lächelt (jemandem) (geh.);Schwein haben (sprichwörtlich)
-Auftriebspunkt;Formschwerpunkt
-Jeder ist seines Glückes Schmied. (Sprichwort);Das Glück ist mit den Tüchtigen. (sprichwörtlich)
-(einen) unverdienten Karrieresprung machen;(die) Treppe hinauffallen (fig., Hauptform);überraschend befördert werden
-(etwas) schließen (aus etwas);entnehmen;schlussfolgern;zu dem Schluss kommen
-wenn das mal (nicht / kein) (...) (ugs.);das könnte (...);ich befürchte (dass)
-labern (ugs.);Volksreden halten (ugs., fig.);herumlabern (ugs.);viel erzählen, wenn der Tag lang ist (ugs., kommentierend);was der so alles erzählt ... (ugs., abwertend, kommentierend, variabel);große Töne spucken (ugs., fig.);was die immer erzählt ... (ugs., abwertend, kommentierend, variabel)
-(nur) damit das klar ist: (...);(nur) damit wir uns richtig verstehen: (...);ich muss hier mal eins klarstellen: (...) (floskelhaft, variabel)
-(sich irgendwie) aufführen;(etwas) abziehen (ugs.);(sich etwas) leisten (negativ);(sich irgendwie) benehmen
-Frieden von Sistowa (veraltet, österr.);Frieden von Swischtow
-Nationalitätenstaat;Vielvölkerstaat
-Bund im Lande Schwaben;Schwäbischer Bund
-Föderative Volksrepublik Jugoslawien (offiziell, veraltet);Demokratisches Föderatives Jugoslawien (offiziell, veraltet);Sozialistische Föderative Republik Jugoslawien (offiziell);Jugoslawien (Kurzform)
-Ozeanisches Klima;Maritimes Klima;Seeklima
-Baltischer Schild;Fennoskandischer Schild
-Schild;Plattform
-Zechbetrug;Zechprellerei
-Freireisender;Vogtländer
-Lossprechung;Freisprechung
-Drucktechniker (österr.);Drucktechnologe (schweiz.);Drucker
-Topfschwamm;Haushaltsschwamm;Küchenschwamm
-Kehrseite;Hinteransicht;Rückseite (Hauptform);Ansicht von hinten
-gewebter Stoff (Hauptform);Gewebe;Webware (fachspr.);Zeug (geh., veraltet);Webstoff;gewebte Textilie
-Jericho-Trompete (fig.);Fahrtwindsirene
-wie auf Kommando;(unerklärlicherweise) alle gleichzeitig
-Jetzt mal was anderes: (...) (ugs.);Anderes Thema: (...);Genug davon. (geh.);Soweit dazu.;Kommen wir (jetzt) zu etwas anderem: (...);Themenwechsel: (...);Lass(t) uns von etwas anderen reden. (ugs.);Themawechsel: (...)
-immer wieder ankommen (mit) (ugs.);gebetsmühlenartig wiederholen;immer wieder anfangen (von) (ugs., variabel);(jemandes) stehende Rede (ist) (geh.)
-eponym;namen(s)gebend
-Übergangsritus;Initiationsritus
-Ritterschlag (Hauptform);Erhebung in den Ritterstand
-Einsegnung (veraltend);Konfirmation (Hauptform)
-Deutschliberale Partei;Verfassungspartei;Deutschliberale Verfassungspartei
-Obermann (fachspr., Jargon);Schlapphut (Hauptform)
-nach unten erweitert;mit Schlag (Hosenbein) (ugs.);Schlag...;ausgestellt
-(eine) zu hohe Erwartung (haben);zu hohe Erwartungen (haben);zu viel erwarten;zu viel verlangt (sein);zu fordernd (sein)
-(seine) Niederlage mit Fassung tragen;angesichts der Niederlage Haltung bewahren;(seine) Niederlage akzeptieren;(seine) Niederlage einräumen;(ein) guter Verlierer (sein) (Hauptform);(sich) fair verhalten (nach einer Niederlage)
-(ein) schlechter Verlierer (sein) (Hauptform);(seine) Niederlage nicht akzeptieren (wollen);(sich) unfair verhalten (nach einer Niederlage);nicht akzeptieren, dass man verloren hat
-jemand anderem die Schuld geben (für);anderen die Schuld geben (für);(sich) von allem freisprechen;jemand anderen verantwortlich machen (für);(die) Schuld bei anderen suchen;(die) Schuld nicht bei sich (selbst) suchen;andere verantwortlich machen (für)
-(eine Fähigkeit) spielen lassen;(etwas) zum Einsatz bringen;(etwas) in die Waagschale werfen;(etwas) einsetzen
-ins Bergfreie (fallen);Absturz ins Bodenlose;freier Fall
-(etwas) erscheint mir, wenn ich so um mich blicke (...) (ugs.);nach meinem Dafürhalten;(jemandem zu ...) erscheinen;nach meiner Lebenserfahrung;soweit ich erkennen kann;nach meiner Einschätzung;soweit für mich erkennbar;(etwas) erscheint mir, wenn ich mich mal umschaue, (...) (ugs.);(jemandem zu ...) vorkommen (ugs.)
-kleiner Gauß;Gauß'sche Summenformel;gaußsche Summenformel
-in einer anderen Liga spielen;(sich) nicht messen können (mit);nicht heranreichen an;nicht mithalten können (mit);(jemandem/einer Sache) nicht das Wasser reichen können;(sich) nicht vergleichen können (mit);nicht herankommen (an);nicht zu vergleichen sein (mit);einem Vergleich (mit ...) nicht standhalten
-(eine) gemeinsame Wohnung nehmen;zusammenziehen (mit)
-heiß sein (auf) (ugs.);haben wollen;(sich) reißen um;scharf sein (auf);heiß begehrt sein;Schlange stehen (bei) (fig.);sehr gefragt sein
-abbrechen (Schule o.ä.);nicht mehr (dahin) gehen (ugs.);in den Sack hauen;hinschmeißen (ugs.);sausen lassen (ugs., fig.);aufgeben;schmeißen (Ausbildung o.ä.);(die Schule Schule) sein lassen (ugs., variabel)
-über Skype kommunizieren (variabel);mit Skype telefonieren (variabel);skypen (Neologismus);über Skype Kontakt halten (variabel)
-über eine Chat-Platform kommunizieren;ein Chatprogramm benutzen;chatten (mit) (Neologismus)
-whatsappen (Neologismus);(sich) Whatsapp-Nachrichten schicken
-mach du nur!;(na dann) viel Vergnügen (bei ...)! (ironisch);mach mal!;nur zu!;machen Sie nur!
-(etwas) mit einem Fragezeichen versehen (fig.);sich skeptisch äußern;Zweifel anmelden
-(sich jemandem) nicht in den Weg stellen;(jemanden) nicht abhalten (von);(jemanden) nicht hindern (an)
-im Austausch stehen;in gegenseitigem Austausch stehen;interagieren
-(sich) gegenseitig beeinflussen;gegenseitig aufeinander einwirken;in Wechselwirkung zueinander stehen
-(einladend o.ä.) zwinkern;(mit den Augen) klimpern;(mit den Augen) plinkern;(jemandem) zuzwinkern;(jemandem) zublinzeln;(jemanden) anblinzeln;bling bling machen (ugs., variabel);(vielsagend o.ä.) blinzeln;(jemanden) anzwinkern;(jemanden) anplinkern
-(jemandem) nachschenken (Hauptform);(die) Luft aus dem Glas lassen (ugs., Redensart);(das Glas) wieder auffüllen;noch einmal vollmachen (Glas) (ugs.);wieder vollmachen (Glas) (ugs.);(jemandem) nachgießen;(jemandem) noch (einen) eingießen;(jemandem) noch (einen) einschütten
-Mensch! (ugs.);Mann! (ugs.)
-(etwas) bekommen für;(etwas) kriegen für (ugs.);(jemanden) bezahlen für;(etwas) nicht umsonst machen müssen
-(jemandem) die Hilfe verweigern;(jemanden) hängen lassen;(jemandem) nicht helfen;(jemanden) allein lassen (mit)
-(das) volle Programm;alles (bekommen)
-stramm;dicht gepackt;vollgepackt (Programm)
-wie klein die Welt doch ist! (ugs., ironisierend);so klein ist die Welt! (ugs., ironisierend);du schon wieder!? (ugs.);lange nicht gesehen! (ugs., ironisch);so sieht man sich wieder! (ugs., Hauptform);beim nächsten Mal gibst du (aber) einen aus! (ugs., Spruch);die Welt ist klein! (ugs., ironisierend)
-(sich) ständig über den Weg laufen;(sich) alle naselang sehen (unverabredet)
-keine Weltstadt (sein);ein Dorf (sein) (fig.)
-mitnehmen (ugs.);entführen (fig.);(vorübergehend) abziehen (von einer Aufgabe) (Hauptform)
-alleine zurechtkommen (ugs.);ohne mich klarkommen (ugs.)
-wenn was ist (ugs.);falls Probleme auftreten;falls irgendetwas (Ungewöhnliches) passiert;falls ihr irgendwas braucht
-(jemanden irgendwo) antreffen;(jemanden irgendwo) vorfinden;(jemanden irgendwo) erreichen
-hallo?! (ugs.);Du solltest dich mal reden hören! (ugs.);Hörst du dir eigentlich selber zu? (ugs.);Weißt du überhaupt, was du da sagst? (ugs.);Was erlaubst du dir? (ugs.)
-dem werd(e) ich was husten! (ugs.);der soll mir gestohlen bleiben! (ugs., variabel);ich pfeif(e) auf den! (ugs.);der soll mich mal gerne haben! (ugs., variabel);der kann mich mal! (ugs.)
-spätbabylonisches Reich;neubabylonisches Reich;Chaldäerreich
-Spiegelstollen;Freispiegelstollen
-Vakuumentwässerung;Unterdruckentwässerung
-Qanat;Kanat
-mit allem rechnen müssen;es kann Gott weiß was passieren (ugs.);für nichts garantieren können
-Kanzlerdominanz;Kanzlerdemokratie
-nicht zusammenkommen (fig.);auf keinen gemeinsamen Nenner kommen (fig.);(sich) nicht einigen (können);(sich) nicht einig werden (Hauptform);zu keiner gemeinsamen Lösung kommen
-wir sollten am besten;das Beste wird sein (wenn / zu);ich denke, wir sollten;wir sollten
-gezielt (Hauptform);nicht einfach so;ganz gezielt;zielgerichtet;nicht irgendein
-wider besseres Wissen;wissentlich (fachspr., juristisch);in vollem Bewusstsein (eines Risikos o.ä.);gegen alle Vernunft;sehenden Auges (Hauptform);entgegen den Ratschlägen der Experten;offenen Auges (fig.)
-ohne sich über die Konsequenzen im Klaren zu sein;aus Unwissen
-aus (reiner) Dummheit;blöd, wie er (nun mal) ist;aus Gedankenlosigkeit;aus Unüberlegtheit;(so) naiv, wie sie (nun mal) ist
-nicht einverstanden sein (mit);Widerspruch anmelden;nicht so stehen bleiben können (fig.);Einspruch, Euer Ehren! (geh., altertümelnd, scherzhaft);(einer Sache) (so) nicht zustimmen können;(etwas) nicht so stehen lassen (fig.);widersprechen (müssen)
-nicht so stehen bleiben können;(etwas) sagen müssen (zu)
-modulieren;verändern;nuancieren
-Anweisung, (...) zu unterlassen;Anordnung, (...) zu unterlassen;Untersagung;Machtwort;(ein) Nein;Verbot (Hauptform)
-Neinstimme;(ein) Nein;Veto (geh., bildungssprachlich, Hauptform);Verweigerung;Nichteinverständniserklärung
-weg...;von dannen (geh., veraltend);fort...;ab... (ugs.);davon...;ent... (geh.)
-Sehr geehrter Herr (...)! (förmlich);Sehr geehrte Frau (...), (förmlich);Hochverehrte(r) (...);Sehr geehrte Damen und Herren (...), (förmlich)
-(wohl) aus dem Bett gefallen (ugs., fig., scherzhaft);zu früh wach werden;zu früh aufwachen;nicht länger schlafen können
-der ihr(e) (ugs., regional, salopp);ihre (weibl.)
-Karawanserei;Karawanenhof;Khan;Funduk
-Strategieplan;Aktionsplan;Handlungskonzept
-Zugänglichkeitshierarchie;Akzessibilitätshierarchie;Keenan-Comrie-Hierarchie
-Kausalattribuierung;Kausalattribution
-polyzentrische Sprache;plurizentrische Sprache
-vergleichende Sprachwissenschaft;komparative Linguistik
-Vergleich;Komparation
-Fronturlaub;Heimaturlaub
-(das) Auto stehen lassen;mit Bus und Bahn fahren;(sich) mit Bus und Bahn fortbewegen;nicht mit dem (eigenen) Auto fahren
-Peritektikum;peritektischer Punkt
-verkommen (zu) (fig.);absacken (zu) (ugs., fig.);herunterkommen (zu) (fig.);(her)absinken (geh., fig.)
-Ausdauer;Hartnäckigkeit;dicke Bretter bohren können (ugs., fig.);Durchhaltevermögen;Beharrlichkeit;Bestandskraft (geh.);Zähigkeit;langer Atem (fig.)
-kalben (Kuh, Wal, Elefant ...);gebären;werfen (Säugetier);Junge bekommen (Hauptform);(ein) Junges bekommen;jungen
-Adelsbuch;Adelsmatrikel
-Pressesprecher;Verantwortliche(r) für die Öffentlichkeitsarbeit;Sprechpuppe (derb, abwertend);Unternehmenssprecher;Sprecher
-Spektabilität (Anredeform, akademisch, formell);Dekan (männl.);Dekanin (weibl.);Fakultätsvorsteherin (weibl.);Fakultätsvorsteher (männl.)
-mit Leben erfüllen;besiedeln
-eine alte (chinesische) Weisheit (be)sagt (floskelhaft, variabel);ein weiser Mann hat einmal gesagt (floskelhaft, variabel);ein altes Sprichwort sagt (floskelhaft)
-wag es nicht (und);(...) bloß nicht (...) (ugs.);lass dir nicht einfallen (zu);untersteh' dich (und ... / zu ....)
-gerade losgehen wollen;schon in der Tür stehen;auf dem Sprung sein
-No-go-Area;(dort gilt das) Gesetz der Straße;rechtsfreier Raum
-Mehlklößchen (in Milchsuppe) (Hauptform);Klüte(r)n (pommersch);Klieben;Klimpern
-man muss;es heißt (+ Infinitiv);(es) hilft nur noch;es ist wichtig (zu);es gilt (zu + Infinitiv);man darf nicht;nur noch (...) können
-(es ist) an der Zeit;(jetzt) gilt es (zu) (geh.);Zeit, zu (+ Infinitiv) (ugs.);(jetzt) sollte man;(jetzt) muss man;(jetzt) heißt es
-nicht gut aussehen;(optisch) nicht viel hermachen;unelegant daherkommen (auch figurativ);keinen Schönheitspreis holen (ugs., fig.);keinen Schönheitspreis gewinnen (mit) (fig.);keine gute Figur machen (bei)
-als Ganzes;am Stück;als ein Stück
-in Scheiben;geschnitten
-in mehreren Fortsetzungen (fig.);auseinandergenommen;zerlegt;in mehreren Teilen
-Was nix kostet, ist nix. (ugs., variabel);Man gönnt sich ja sonst nichts. (Redensart);Was nichts kostet, ist (auch) nichts wert. (variabel);Umsonst ist (nur) der Tod (, und der kostet das Leben). (Spruch, ironisch);Es war schon immer etwas teurer, einen besonderen Geschmack zu haben. (sprichwörtlich);(Echte / Wahre) Qualität hat ihren Preis.
-den guten Ton wahren;die Form wahren;höflich bleiben;(sich) korrekt verhalten;der Etikette Genüge tun (geh.)
-(jemandes) Spur aufnehmen;(eine) Spur finden;(jemandes) Fährte aufnehmen
-kratzen (= kratzend bearbeiten);durch Kratzen entfernen;abkratzen;abschaben;wegkratzen;wegschaben
-entfernen;wegmachen (ugs.)
-(jemanden) auf Ideen bringen;(jemanden) auf eine dumme Idee bringen;(jemanden) verleiten zu (etwas, das er später bereut);(jemanden) auf dumme Gedanken bringen
-(jemandem) Flausen in den Kopf setzen;(in jemandem) unerfüllbare Wünsche wecken;(jemanden) auf dumme Gedanken bringen
-Astronomisch-Geodätisches Jahrbuch;Heidelberger Jahrbuch
-wehrhafte Demokratie;starker Staat
-knittrig;voller Knicke;verknittert;faltig;zerknittert;voller Falten
-fälteln (Stoff);plissieren;mit Falten versehen
-wellen;in Wellenform bringen;wellig machen;ondulieren (Haare) (Hauptform)
-(jemandem) den Strom abdrehen;(jemandem) den Strom abklemmen;(jemandem) den Saft abdrehen (ugs.);nicht mehr mit Strom beliefern;(jemandem) den Strom(anschluss) sperren;(jemandem) den Strom abstellen (Hauptform)
-am längeren Hebel sitzen (fig.);(einen) Vorteil haben;mehr Einfluss nehmen (können);(jemandem etwas) diktieren können (fig.);bestimmen (können), was gespielt wird;mehr Einfluss haben;im Vorteil sein;(sich) durchsetzen (gegenüber);am Drücker sein (ugs.);(die) Oberhand haben (Hauptform);mehr zu sagen haben
-Schornsteinabdeckung;Kaminabdeckung;Schornsteinaufsatz;Kaminaufsatz
-Lobhudler;Schmeichler (Hauptform);Schöntuer;Charmeur (geh., franz.);Schönredner
-alles opfern (um zu);sein letztes Hemd hergeben (um zu)
-statuarisch;standbildhaft (geh.)
-Schnappverschluss (Flasche) (selten);Bügelverschluss (Flasche)
-aus der Decke schlagen (Wild) (fachspr., Jägersprache, Hauptform);ausschlagen (fachspr., Jägersprache);(das) Fell abziehen
-abschwarten (Schwarzwild u. Dachs) (fachspr., Jägersprache, Hauptform);(das) Fell abziehen
-Wildschweine;Schwarzwild (fachspr., Jägersprache)
-(das) Fell abziehen (Hase, kleineres 'Raubwild');(die) Haut abziehen (Federwild);abbalgen (fachspr., Jägersprache, Hauptform)
-abschärfen (Bär) (fachspr., Jägersprache, Hauptform);(das) Fell abziehen (Bär);abschneiden;(die) Decke abziehen (Bär)
-(etwas) in seinen Bart grummeln (variabel);vor sich hinbrabbeln;(sich etwas) in den nicht vorhandenen Bart murmeln (fig., scherzhaft, variabel)
-Patchwork-Familie;Patchworkfamilie;Stieffamilie
-Familie;Kernfamilie;klassische Familie;Eltern mit ihren Kindern
-Ems-Hase-Kanal;Hanekenkanal;Emskanal
-Einkünfte verschleiern;Einkommen verschleiern;(sich) arm rechnen;Einkommen verstecken (vor) (variabel)
-nicht den Hintern bedecken (Hose);(jemandem) unterm Arsch hängen (Hose) (ugs.)
-(es gibt) was auf die Ohren (fig.);wir haben Musik für euch (Radio)
-(sich) taub stellen;(wie) gegen eine Wand (an)reden (variabel);(bewusst) weghören;die Ohren auf Durchzug schalten (fig.);(etwas) nicht hören wollen;die Ohren auf Durchzug geschaltet haben (fig.);nichts hören wollen (von);Tomaten auf den Ohren haben (fig.)
-Durchbruch;Durchstoß;Durchstich (Tunnelbau)
-(einen) Durchbruch erzielen (Verhandlungen) (fig.);zu einer Einigung kommen;(einen) entscheidenden Schritt weiterkommen;(die) größten Probleme ausgeräumt haben;(eine) Lösung zeichnet sich ab
-Wegelagerer;Schnapphahn (fachspr., historisch);Straßenräuber;Strauchdieb (veraltend)
-nicht alleinstehen (mit) (fig.);Verbündete haben
-über Bord werfen (fig.);los sein wollen;aufräumen mit (fig.);loswerden;(sich etwas) vom Halse schaffen (fig.);(sich einer Sache) entledigen
-weiter mit sich herumtragen;nicht loslassen können (fig.);weiter mit sich herumschleppen (auch figurativ)
-den Tod (künstlich) hinauszögern;künstlich am Leben erhalten (auch figurativ);nicht sterben lassen
-volle (vor Zahl);sogar;nicht weniger als
-ganze (vor Zahl);nicht mehr als;gerade mal (vor Zahl);nur (vor Zahl) (Hauptform)
-(eine) Gasse bilden;Spalier stehen (Hauptform);(eine) Menschengasse bilden;in zwei Reihen angetreten (sein)
-Generalbasszeitalter;Barock (Musikepoche)
-Seilziehen;Tauziehen
-verräuchert;voller Rauch;vollgequalmt (ugs.);verqualmt;zugequalmt (ugs.);voller Qualm;rauchgeschwängert;qualmig
-Rauchwolke;Rauchschwade(n)
-induzierte wahnhafte Störung;psychotische Infektion;Geistesstörung zu zweit;symbiontischer Wahn;gemeinsame psychotische Störung
-(etwas) nicht essen wollen;(Essen) nicht anrühren;(das Essen) stehen lassen;(den) Teller wegschieben;lange Zähne machen;(von etwas) nichts essen wollen
-(im Essen) herumstochern;widerwillig essen;herumkauen auf;(jemandem) nicht schmecken;mit langen Zähnen essen;(jemandem) schlecht schmecken
-(etwas) runterwürgen (ugs.);(sich etwas) reinquälen (ugs.);(sich) zwingen, (von) etwas zu essen;(etwas) kaum herunterbekommen (ugs.);(etwas) herunterwürgen
-alles (auftischen), was Küche und Keller zu bieten haben;(die) Tische biegen sich (unter) (fig.);(es ist) von allem (über)reichlich da
-(...) damit du (et)was in den Magen bekommst;(...) damit du (et)was zwischen die Zähne bekommst;(...) damit du (et)was zwischen die Rippen bekommst;(...) damit du nicht vom Fleisch fällst
-(...) damit aus dir (et)was wird (ugs.);(...) damit du was wirst (ugs., ironisierend);ein Löffelchen für (die) Mama, ein Löffelchen für (...) (ugs.);(...) damit du groß und stark wirst
-(sich) den Teller vollpacken;(ordentlich) zuschlagen;(sich) den Teller vollschaufeln
-(nur / zu) wenig essen;(ein) schlechter Essen sein;essen wie ein Spatz
-(sich) den Magen verrenken;(sich) überfressen;so lange (fr)essen, bis es (jemandem) oben und unten wieder herauskommt;(sich) den Bauch verrenken
-Die Augen waren (mal wieder) größer als der Magen. (sprichwörtlich);(es) nicht schaffen (aufzuessen);(seinen) Teller nicht leerbekommen;(sich) den Teller zu voll gemacht haben
-doppelt vorhanden;doppelt (...);zweimal vorhanden;zweimal (...);(etwas) doppelt haben;zweimal dahaben;noch einmal (...)
-Zweitstück;zweites Exemplar;Zweitexemplar
-Zwilling;Zwillingsschwester (weibl.);Zwillingsbruder (männl.)
-Zwillinge;Zwillingspaar
-lange (zehn) Jahre;die ganzen (zehn) Jahre;in all den (zehn) Jahren;(zehn) Jahre (ugs.);(zehn) Jahre hindurch;(zehn) Jahre lang;über (zehn) Jahre
-nur ausnahmsweise (einmal);seltenst;kaum einmal;extrem selten;äußerst rar;überaus selten;alle paar Jubeljahre;so gut wie nie;einmal in hundert Jahren (übertreibend);höchst gelegentlich (geh.);sehr selten (Hauptform, variabel);höchst selten;praktisch nie;kaum mal (ugs.);alle Jubeljahre (mal);punktuell;fast nie
-(einen) Dreck verstehen von (derb);keinen blassen Schimmer haben (von) (fig.);(einen) Quark verstehen von (ugs.);überhaupt nichts wissen (zu);(einen) Scheiß(dreck) von etwas verstehen (derb);von Tuten und Blasen keine Ahnung haben (fig.);nicht die geringste Ahnung haben;komplett unfähig (sein);(sich) überhaupt nicht auskennen;überhaupt nichts verstehen (von);vollkommen ahnungslos (sein)
-(nur) alle zwei (...) mal;nur einmal in (...);alle zwei (...) (variabel);nur einmal pro (...)
-wo steckst du?;wieso bist du nicht (schon längst) hier?;wo bleiben Sie (denn)!?;wo bleibst du (denn)!?
-wo hast du gesteckt?;was hast du getrieben? (ugs., salopp);wo warst du (denn)? (Hauptform);was hast du gemacht?
-bedeutsam für die Beurteilung künftiger Fälle;als Präjudiz dienend (juristisch)
-nicht gut wegkommen (bei) (fig.);schlechte Kritiken erhalten
-Spendenquittung;Zuwendungsbestätigung
-als er ans Sterben kam;als er nun sterben sollte;als er sich zur letzten Ruhe bettete;als er sich zur letzten Ruhe begab
-(die Seite) verschlagen;(irrtümlich / unbedacht) weiterblätterm
-verschlagen (Ball);(den Ball) nicht treffen;danebenschlagen
-zu weit schlagen;verschlagen (Ball);ins Aus schlagen (z.B. Tennis)
-bedingend;konditional
-(Zeile/n) überspringen;in der Zeile verrutschen
-(sich) verlesen;(etwas) nicht richtig lesen;(etwas) falsch lesen
-(der ganze) Salat (fig.);Kladderadatsch;wüster Haufen;unsortierter Kram (Hauptform);(ein) Durcheinander (von / an)
-das Siegel erbrechen (geh., veraltet);(ein) Siegel aufbrechen;entsiegeln (Hauptform);das Siegel entfernen
-zurückgehen (ugs.);remittiert werden (Buch-/Zeitschriftenhandel) (fachspr.);zurückgeschickt werden;retour gehen (fachspr., Jargon)
-sich beklagen;stöhnen;jammern
-einfließen lassen;hinzusetzen;nicht unerwähnt lassen (wollen);(die) Diskussion bereichern (um den Aspekt o.ä.);anfügen;(seine) Rede würzen (mit) (geh., fig.);anmerken;hinzufügen;einflechten (Bemerkung) (geh., fig.);bemerken;(sich) die Bemerkung erlauben (dass)
-Mietmaul (derb, abwertend, scherzhaft);(jemandes) Sprachrohr (fig.)
-Facharzt für Geschlechtskrankheiten;Venerologe;Facharzt für sexuell übertragbare Krankheiten
-zu zweit (Schnee) schippen;Paarschippen
-Stahlrute;(flexibler) Teleskopschlagstock
-Pracker (ugs., österr.);Teppichklopfer (Hauptform);Ausklopfer
-Rudolfinum;Rudolfinische Handfeste
-auf jemanden einstürmen (mit);(jemanden) bedrängen (mit);(jemanden) bestürmen (mit) (fig., Hauptform);(jemanden) bombardieren mit
-Zackenfirn;Büßereis;Büßerschnee
-neu anfangen;(sich) (gegenseitig) eine neue Chance geben;noch einmal von vorne anfangen;(einen) zweiten Anlauf nehmen;(einen) Neuanfang versuchen
-(langsam) in jemandem wachsen;(jemanden) beschleichen (fig., Hauptform, negativ);in jemandem entstehen;in jemandem aufkommen;(allmählich) ergriffen werden von
-Einsturzstelle;Ground Zero (engl., fig.)
-Explosionsort;Bodennullpunkt (fachspr., militärisch);Ground Zero (fachspr., auch figurativ, engl., militärisch);Einschlagsort
-immer wieder anfangen (von);zu Tode reiten (Thema) (fig.);von nichts anderem sprechen;(sich) hochziehen (an) (ugs.);immer wieder mit derselben Leier (an)kommen (ugs., variabel);herumreiten auf (ugs., Hauptform);nicht aufhören (von etwas zu sprechen);(sich) nicht abbringen lassen (von);(die) ganze Zeit reden (von)
-verweilen bei (einem Thema);näher eingehen (auf);(sich) aufhalten mit (fig.);ausführlich(er) behandeln
-Indianer kennt kein(en) Schmerz. (sprichwörtlich);Was uns nicht umbringt, macht uns härter. (Spruch);Davon stirbt man nicht.;Nur die Harten komm(e)n in'n Garten. (ugs., Spruch)
-auf Sendung gehen;mit der Ausstrahlung beginnnen
-früh auf den Beinen sein;mit den Hühnern aufstehen (fig.);früh aufstehen
-(immer) früh aufstehen;(ein) Frühaufsteher sein
-(immer) früh am Ball sein (ugs., fig.);(immer) früh anfangen
-Alexanderplatz (Berlin);Alex (ugs.)
-(Gegend um das) Kottbusser Tor;(der) Kotti (ugs.)
-Mediterraneum;Mittelmeerraum
-her...;herbei...;zu sich (= zum 'Sprecher')
-sollen (im Präteritum);(jemandes) Schicksal sein;(jemandes) Schicksal will;(jemandem) vergönnt sein;(jemandem) bestimmt sein;(jemandes) Bestimmung sein;(jemandem) beschieden sein
-Wutanfall;Ausraster (ugs.);Wutausbruch;aggressive Aufwallung (geh.)
-(jemand könnte) vor Wut in den Teppich beißen;(jemand könnte) vor Wut explodieren;(jemand könnte) sich vor Wut in den Arsch beißen (derb);(jemand könnte) vor Wut platzen
-Das wäre alles.;Mehr ist dazu nicht zu sagen.;Damit ist alles gesagt.;Dem ist nichts hinzuzufügen.
-Durchsteiger (ugs.);Durchkontaktierung
-(sich) umstellen;(sich) umorganisieren;(sich) neu einstellen (auf)
-nicht nichts tun können;ein Zeichen setzen müssen
-ein Exempel statuieren;ein Zeichen setzen
-(vom Weinen) ein verquollenes Gesicht haben;verweint (aussehen);verheult (aussehen) (Hauptform);(vom vielen Weinen) rote Augen haben (ugs.)
-ich will Ihnen nicht zu nahe treten (nur ...);das ist (jetzt) nicht persönlich gemeint;(bitte) nehmen Sie es nicht persönlich (wenn)
-recht herzlich;recht freundlich;herzlichst;freundlichst;ganz herzlich
-Überzeugtheit von;Vertrauen auf;Glaube an
-Schwerfälligkeit;Lahmarschigkeit (derb);Schwunglosigkeit;Transusigkeit (ugs.);mangelnder Elan;Trägheit
-(ist doch) mal was anderes (ugs.);mal eine Abwechslung;variatio delectat (geh., bildungssprachlich, lat.);Öfter mal was Neues! (ugs., Spruch)
-Twitter-Nachricht;Tweet (engl.)
-vorherrschend;gebräuchlichst;am häufigsten verwendet;meistbenutzt
-Scheiß... (derb);mieses Produkt;beschissen (ugs., variabel);Scheißding (derb);Schrottteil (ugs.);Drecks... (derb);Technik, die begeistert. (ugs., Zitat, sarkastisch);Mistding (ugs.)
-beauftragt mit;betraut mit;verantwortlich für;zuständig für
-qualifiziert;(die formalen) Voraussetzungen erfüllen(d)
-haftbar;rechtlich belangbar;schaden(s)ersatzpflichtig;regresspflichtig
-Deichhauptmann;Deichgraf;Deichvogt;Deichgeschworener;Deichgräf (niederrheinisch);Deichrichter
-Sächsisches Seenland;Mitteldeutsches Seenland
-(kurz) reinhören;(kurz) anspielen (Radio, TV);einen Blick (rein)werfen in;einen Blick werfen auf;(kurz) reinschauen
-emporschießen;hochwachsen;schossen;gedeihen;hochwachsen;aufsprossen;emporsprießen;aufschießen;aufwachsen;emporschießen
-Epigonentum (geh., bildungssprachlich);(ein) bloßes Nachahmen
-Trennung der Veränderlichen;Separation der Variablen;Trennung der Variablen;Separationsmethode
-Produktansatz;Separationsansatz
-zum Fürchten (sein);(etwas) kann einem Angst machen;(da) kann einem Angst und Bange werden (ugs.);unheimlich
-sei kein Frosch! (ugs.);nur Mut!;Bangemachen gilt nicht. (ugs., sprichwörtlich);nur keine Bange! (ugs.);(jetzt) stell dich nicht so an (ugs.);(nur) keine Angst;hab keine Angst (Hauptform)
-(er) wird dir schon nicht den Kopf abreißen;(er) wird dich schon nicht fressen;du brauchst vor ihm keine Angst zu haben (Hauptform);(er) wird dich schon nicht (gleich) beißen
-Hannemann, geh du voran. (ugs., sprichwörtlich);(jemanden) vorschicken
-in Angst und Schrecken versetzen;Furcht und Schrecken verbreiten
-mehrwortig (fachspr.);aus mehreren Wörtern bestehend
-Prädikativum;Prädikativ
-Objekt;Satzergänzung
-Akkusativobjekt;direktes Objekt
-Dativobjekt;indirektes Objekt
-Zerfallsprodukte;Detritus
-(jemanden) (gewaltsam) zum Reden bringen;(etwas aus jemandem) herausprügeln;(jemanden) so lange verprügeln, bis er redet (variabel)
-umso (+ Adjektiv 1. Steigerung);zusätzlich (+ Adjektiv);noch (+ Adjektiv 1. Steigerung)
-(jemandem) zu viel versprechen (Hauptform);(jemandem) das Blaue vom Himmel versprechen (fig.);wunders was versprechen (ugs.);(jemandem) die tollsten Versprechungen machen;(den) Mund zu voll nehmen (ugs., fig.);(jemandem) goldene Berge versprechen (fig.)
-wohlverwahrt;diebstahlsicher gelagert (variabel);vor fremdem Zugriff geschützt;an einem sicheren Ort
-versuchen, alleine klarzukommen;Selbst ist der Mann! (Zitat, sprichwörtlich);Hilf dir selbst, dann hilft dir Gott. (sprichwörtlich);Selbst ist die Frau! (sprichwörtlich);jeder für sich und Gott gegen alle (ironisierend);(etwas) alleine hinbekommen wollen;(etwas) selbst versuchen
-Hauptsache gesund! (Hauptform);Die Gesundheit ist zwar nicht alles, aber ohne Gesundheit ist alles nichts. (Spruch)
-Gegengruß;Wiedergrüßen;Grußerwiderung;Zurückgrüßen;Erwiderung des Grußes
-aus allen Rohren schießen (gegen) (auch figurativ);mit Zähnen und Klauen bekämpfen (fig.);(sich) mit Klauen und Zähnen verteidigen (fig.);erbitterten Widerstand leisten;(sich) mit allen Mitteln wehren;(sich) mit Zähnen und Klauen wehren (fig.)
-zu beklagen haben;(etwas) beklagen (fig.);erleiden (Missstand, Verlust)
-nichts (/ wenig / nicht viel) zu bestellen haben;nichts (/ wenig / nicht viel) ausrichten können;zu keinem Ergebnis kommen;nichts (/ wenig / nicht viel) erreichen;nichts (/ wenig / nicht viel) bewirken
-(der / die / das + Adjektiv im Superlativ) seit Menschengedenken;(der / die / das + Adjektiv im Superlativ) aller Zeiten
-anfängliche Begeisterung;(in den) Flitterwochen (fig.)
-Säulenjoch;Joch
-Greshamsches Gesetz;Gresham'sches Gesetz;Gresham-Kopernikanisches Gesetz
-in Ruhe (tun);(sich die) Zeit nehmen, um
-(etwas) durchquatschen (ugs.);zu Ende diskutieren;zu Ende besprechen;von A bis Z besprechen;(alles) durchsprechen;(etwas) ausdiskutieren (Hauptform);(komplett) durchsprechen;(etwas) durchkauen (ugs., fig.);in aller Ausführlichkeit diskutieren
-(sich) zoffen (ugs.);(einen) Disput haben;(sich) heftig auseinandersetzen (über);(ein) Streitgespräch führen;disputieren;(sich) streiten (über)
-debattieren (über) (Hauptform);diskutieren;verhandeln;disputieren;beraten;(sich) auseinandersetzen (über);erörtern
-danebenschütten;danebengießen;danebengehen
-bepunktet;punktiert;betüpfelt;gepunktet;getüpfelt
-Planarprozess;Planartechnik
-Jagdhund;Schießhund (veraltet);Jaghund (schweiz., veraltet)
-kanonische Basis;Standardbasis;Einheitsbasis;natürliche Basis
-Basiswechsel;Basistransformation
-Übergangsmatrix;Transformationsmatrix;Basiswechselmatrix
-Festtagsgewand;Feiertagsgewand;Feiertagskleid;Festtagskleid;Festkleid;Festgewand
-auf hoher See;auf offenem Meer
-sessil (fachspr., lat.);festsitzend;festgewachsen
-Leukopathie (fachspr., griechisch);Albinismus (fachspr., lat.);Farblosigkeit;Leuzismus (fachspr., griechisch)
-Schwarzfärbung;Melanismus
-Kreuz (im Kartenspiel);Treff (österr.)
-Pik (Farbe im Kartenspiel) (Hauptform);Schüppe(n) (rheinisch);Schippe(n) (rheinisch);Schaufel (süddt.)
-Eckstein;Karo (Kartenspiel) (Hauptform)
-Stolperstein (fig., Hauptform);(könnte) scheitern an;zu scheitern drohen (an / wegen)
-Limonadenlöffel;Cocktaillöffel
-Honigheber;Honiglöffel;Honigaufnehmer
-Buttermesser;Butterstreicher;kleines Brotmesser
-Spork (engl.);Göffel
-Schaumlöffel;Schaumkelle;Abseihlöffel
-Frittengabel (regional);Pommesgabel
-Spaghettizange;Spaghettigreifer;Pastazange
-Teeei;Tee-Ei
-Trichterrandbecherkultur;Trichterbecherkultur
-Tauflöffel;Apostellöffel
-(jemanden) nachdenklich machen;(jemandem) zu denken geben;Besorgnis(se) auslösen (bei)
-(etwas Großartiges) abliefern (ugs., fig.);(etwas Großartiges) bringen (ugs.);(etwas Großartiges) hinlegen (ugs., Hauptform);(etwas Großartiges) zeigen
-Tutorat;Tutorium;Tutoriat
-(jemandem etwas) austreiben;(jemandem etwas) abgewöhnen;(jemandem etwas) aberziehen;dafür sorgen, dass jemand etwas (in Zukunft) unterlässt
-(jemanden) exorzieren;(bei jemandem jemanden) vertreiben;(jemandem jemanden) austreiben
-austreiben (Schlosserarbeit);herausschlagen
-(Teig) austreiben (österr.);(Teig) ausrollen
-Abschaltautomatik;automatische Abschaltung
-kleine Gabel;Frühstücksgabel
-Cnicus benedictus (fachspr.);Bitterdistel;Benediktenkraut;Natterkraut;Benediktinerdistel;Spinndistel;Kardobenediktenkraut
-Schadenswahrscheinlichkeit;Eintretenswahrscheinlichkeit;Eintrittswahrscheinlichkeit
-inspirierend;(einen) auf Ideen bringen(d);Phantasien freisetzen(d);Fantasien freisetzen(d);anregend
-(sich) den Arsch abfrieren (derb);(sich) nicht aufwärmen können;in der Kälte (herumstehen / sich aufhalten ...);im Kalten (arbeiten / bleiben / abwarten ... müssen);(sich) einen abfrieren (ugs.)
-(jemandes) Arbeit;(jemandes) Tätigkeit;Broterwerb;Berufstätigkeit
-einstecken müssen (ugs.);kassieren;bekommen (Hauptform, negativ);abbekommen;(ab)kriegen (ugs.)
-Peutz-Jeghers-Syndrom;Hutchinson-Weber-Peutz-Syndrom;Peutz-Jeghers Hamartose
-arbeiten (gehen) (Hauptform);(wieder) zur Arbeit gehen;(wieder) zur Arbeit kommen;am arbeiten sein;arbeiten kommen
-berufstätig (sein) (Hauptform);arbeiten(d);einen Job haben;eine Stelle haben;(überhaupt) eine Arbeit haben;in Arbeit (sein)
-auf der Arbeit sein (Hauptform);auf Arbeit sein (ugs.);am arbeiten sein;sein Tagewerk verrichten (geh., veraltend);arbeiten sein (ugs.)
-Gefecht bei Richterswil;Gefecht bei Wollerau
-Savoyer Handel;Savoyerhandel
-Baugewerkschule;Baugewerkeschule;Baugewerksschule;Baugewerkenschule
-Studierendenvertretung;Studentenvertretung
-(sich) ins Ziel schleppen;(sich) über die Runden quälen (auch figurativ)
-(sich) krumm und bucklig arbeiten (ugs., fig.);(sich) halbtot arbeiten;(sich) zu Tode schuften (fig.);(sich) kaputtmalochen (ugs.);arbeiten bis zur (völligen) Erschöpfung (Hauptform);(sich) totarbeiten (ugs., übertreibend);arbeiten bis zum Umfallen (fig.)
-bis sich der Staub gelegt hat;bis sich alles wieder beruhigt hat;bis Gras über die Sache gewachsen ist
-kein Zutritt;Zutritt verboten
-geliefert;aufgeschmissen;verratzt (ugs.);erledigt;im Arsch (derb);am Arsch (derb);verloren;am Ende (sein);ausgespielt haben;gefickt (vulg.)
-(für ...) gut (kaufmännisch);kreditwürdig
-Fraiß;Fraisch
-Fraischbuch;Fraißbuch
-Lehre vom Sein;Lehre vom Seienden;Seinslehre;Ontologie (fachspr., Philosophie)
-Bogerschaukel;Papageienschaukel
-Geschossfang;Kugelfang
-(zu) hoch gegriffen (sein);überschätzt werden
-Neuanlage;Zubau;(weiterer) Ausbau
-(jemanden / sich) auf dem Laufenden halten;(jemanden / sich) fortlaufend unterrichten (lassen);(jemanden / sich) regelmäßig informieren
-Lächerlichkeit;schlechter Scherz;Lachplatte (ugs.);Witz
-Zugang haben;zugelassen sein
-Mikrosphäre;Vesikel;Kapsel
-wie sieht das denn aus!;wie (blöd) steh' ich denn dann da!?;dann steh ich (verdammt) blöd da!;(das) würde bestimmt keinen guten Eindruck machen!
-etwas (ganz) anderes anderes wollen;eigentlich wollen (dass);Hintergedanke(n hegen)
-(bei) Einbruch der Dunkelheit;(bei) Anbruch der Nacht (geh.);(bei) Nachteinbruch
-um die Hälfte verringern;halbieren;hälftig teilen;zweiteilen
-wer wollte das nicht!;wollen wir das nicht alle? (ironisch)
-(einen) Riesen-Aufriss machen (wegen);(sich) gewaltig ins Zeug legen
-versuchen, durchzublicken (ugs.);sich Übersicht verschaffen
-Kursplan;Veranstaltungskonzept (Lehrveransatlung);Syllabus (fachspr., selten)
-Seeanemone;Seenelke;Aktinie;Seerose
-Riff;Korallenriff
-(sehr) gründlich suchen;eingehend untersuchen;jedem (noch so kleinen) Verdacht nachgehen;(akribische) Nachforschungen anstellen;(sehr) gründlich recherchieren;jeden Stein umdrehen (fig.)
-Ordnung schaffen (Hauptform);(etwas) ordentlich herrichten;(etwas) in Form bringen;klar Schiff machen (fig., sprichwörtlich);alles an seinen Platz räumen (/ stellen / tun);(etwas) in Schuss bringen;(etwas) auf Vordermann bringen (fig.);(etwas) in Ordnung bringen;aufräumen (Hauptform);(etwas) aufklaren (fachspr., Jargon, seemännisch);(etwas) aufbereiten;(etwas) ordnen;(die Sachen) wegräumen
-Schrapphals (ugs., abwertend, rheinisch, ruhrdt.);Raffke (ugs.);Raffzahn (ugs.)
-kotieren;(Höhen) messen
-eintüten;in Tüten (ab)packen
-(etwas) fixieren;(etwas) finalisieren (geh.);(etwas) klarmachen (ugs.);unter Dach und Fach bringen;(etwas) eintüten (ugs., bundesdeutsch, fig.);(ein Geschäft) abschließen (Hauptform);in Sack und Tüten kriegen (ugs., fig.);zum Abschluss bringen;(etwas) perfekt machen
-(oft) denken an;unvergessen (sein) (Hauptform);hat sich (tief) eingeprägt;(jemand) lebt in unseren Herzen weiter
-(das) vergisst man nicht;lange zurückdenken (müssen an) (variabel);(einem) im Gedächtnis bleiben;bleibende Erinnerung(en);(sich) tief ins Gedächtnis eingegraben haben;unvergesslich (sein) (Hauptform);(einen) bleibenden Eindruck hinterlassen
-(eine) Grundreinigung machen;gründlich durchputzen
-denkwürdig;bedeutsam;weltbewegend;bedeutend;bemerkenswert
-stark (Kaffee, Tee);da bleibt der Löffel drin stehen (ugs., fig.);Mit dem (Kaffee) kann man Tote wieder zum Leben erwecken. (ugs., fig., variabel);kräftig;gehaltvoll
-Kaffeepott;Kaffeetasse (kleiner, mit Untertasse);Kaffeebecher
-Teeschale;Teeglas;Teetasse;Teeschälchen
-(ein) Glas;Trinkglas
-klären;filtern;reinigen;aufbereiten;filtrieren;läutern
-durchspülen;spülen;ausspülen
-abspritzen;abspülen;(Wasser) darüberlaufen lassen;(den) Strahl darauf richten;(den) Schlauch draufhalten (ugs.)
-klarspülen;mit klarem Wasser nachspülen;nachspülen;(die) Spülwasserreste abspülen
-mit einem feuchten Tuch reinigen (/ säubern / abwischen);(feucht) wischen;abwischen;durchwischen;mit (z.B.) einem feuchten Tuch über (/ durch ...) etwas gehen (ugs., variabel);auswischen;(über / durch etwas) wischen
-abwischen;wegwischen;(vom Boden) aufwischen
-Glufosinat;Phosphinothricin
-reproduktionstoxisch;reprotoxisch
-Schrubber (Hauptform);Leuwagen (norddeutsch)
-Leuwagen (veraltet);Teppichkehrer;Teppichdackel (ugs., Hauptform, veraltet)
-Wahlhamburger;(nach Hamburg) Zugezogener (variabel);ursprünglich nicht aus Hamburg stammend;Quiddje (hamburgisch, variabel)
-Einbruch (Hauptform);Bruch (fachspr., Jargon)
-Bruch (fig.);Bruchstelle (in der Biographie) (fig.);Verwerfung (fig.)
-Leistenbruch;Inguinalhernie (fachspr.)
-keinen Erfolg haben (mit);(es) wird nichts aus;nicht zu Streich kommen (mit) (geh., veraltend);nicht zum Erfolg führen;nicht klappen (ugs.);(jemandem/einer Sache) ist kein Erfolg beschieden;nichts bringen
-Binnenwanderung;Binnenmigration
-Messerkopf;Fräskopf
-Fräswerkzeug;Fräser (fachspr., Kurzform)
-Minimalmengen-Kühlschmierung;Minimalmengenschmierung
-Habichtskauz;Uralkauz
-Intrigantin;Giftspritze (fig.);falsche Schlange (fig.)
-(sich) kurzschließen (fig.);untereinander klären;auf dem kurzen Dienstweg (regeln) (fig.);den kleinen Dienstweg (wählen) (fig., variabel)
-direkt;ohne die (sonst) üblichen Formalitäten;ohne große Formalitäten;schnell und unkompliziert;ohne große Umstände
-keine andere Wahl haben (als zu);(sich) gezwungen sehen (zu);keine Wahl haben;gezwungen sein (zu) (Hauptform);(jemand) hat sich (etwas) nicht ausgesucht (ugs.);(jemandem) bleibt keine andere Wahl;(jemandem) bleibt keine andere Möglichkeit;(jemandem) bleibt nichts anderes übrig (als);(etwas) tun müssen;es hilft (jetzt) alles nichts, (man muss) (ugs., floskelhaft)
-ohne seine Vorgesetzten zu fragen;ohne sich an das sonst übliche Procedere zu halten (geh.);ohne sich nach oben hin abzusichern;unter Umgehung des vorgesehenen Verfahrens (variabel);ohne Einschaltung vorgesetzter Instanzen
-erbärmlich;schäbig;schofelig;armselig;schofel
-e goldenes Nixle un e silbernes Warteweilche (un e Schächtele wo des nei dus);(nur ein) warmer Händedruck (Hauptform)
-Engherzigkeit;Kleinherzigkeit;Kleinmut;Kleingeistigkeit;Halbherzigkeit
-Shavette (Markenname);Wechselklingenrasiermesser
-Einstiegsamt;Eingangsamt
-Schmuggler;Schwarzhändler;Schleichhändler;Kontrebandist (geh., veraltet)
-(einen) Furz quer sitzen haben (ugs., fig.);auf eine Schnapsidee kommen;nicht alle Tassen im Schrank haben (ugs., fig.)
-Hygieneprodukt;Körperpflegeartikel;Hygienebedarf;Hygieneartikel;Körperpflegeprodukt
-Flaneur (franz.);Spaziergänger
-(etwas) lohnt sich nicht (wirklich);darauf kommt es jetzt auch nicht mehr an;(etwas) macht keinen groß(artig)en Unterschied;das macht den Kohl (auch) nicht fett (fig.);(etwas) trägt nicht entscheidend zur Verbesserung bei
-das musste (jetzt aber) wirklich nicht sein;Des hätt's fei net braucht. (bayr.);das hätte es (eigentlich) nicht gebraucht (süddt.);das wär(e) (jetzt aber) nicht nötig gewesen! (variabel)
-Redaktion;Schriftleitung
-erster Besuch;Antrittsbesuch
-(sich) herumärgern (mit) (ugs.);(sich) herumschlagen (mit) (ugs.);Theater haben (mit) (ugs., fig.)
-seriöse Zeitungen;Qualitätspresse
-das sollte ausreichen;das wird genug sein;das müsste reichen
-(ein) Bedürfnis befriedigen;(ein) Bedürfnis stillen;(einen) Bedarf decken
-Interkostalraum (fachspr.);Spatium intercostale (fachspr., lat.);Zwischenrippenraum
-Geisterdorf;Geisterstadt (Hauptform);verlassene Stadt;versunkene Stadt (fig., historisch);Wüstung (fachspr.);Lost Place (Jargon, engl.)
-(ein) Gewicht von (... kg) haben;(ein bestimmtes Gewicht) auf die Waage bringen (fig.);(soundsoviel) wiegen (Hauptform)
-Meerwasser;Salzwasser (Hauptform)
-Niederschlagswasser;Regenwasser (Hauptform)
-Abwasser;Schmutzwasser;Dreck(s)brühe (ugs.)
-Ortsveränderung;(mal eine) andere Umgebung (ugs.);Tapetenwechsel (fig.);Luftveränderung;Umzug
-(sich) nicht vom Fleck rühren;(sich) nicht von der Stelle bewegen;da bleiben, wo man ist;(sich) nicht wegbewegen
-(das) tun, was von einem erwartet wird;(einfach) seinen Job machen (ugs.);(das) tun, wozu man verpflichtet ist;(nur) seine Arbeit machen
-(jemandem) mit Moral kommen (ugs., abwertend);moralisch werden;(die) Moralkeule schwingen
-amüsiert zur Kenntnis nehmen;(sich) amüsieren (über);witzeln (über);(milde) belächeln;amüsiert sein (über);lustig finden;(sich) amüsiert zeigen
-(Tätigkeitsbezeichnung) sein bei (ugs.);im Dienst stehen bei;tätig sein (für);arbeiten (bei/in einem Unternehmen);angestellt sein bei;beschäftigt sein bei
-Beruf;Berufsbezeichnung;Tätigkeitsbezeichnung
-durchexerzieren (fig.);durchspielen;durchdeklinieren (fig.);Punkt für Punkt durchsprechen (variabel);im Einzelnen durchgehen
-alle gemeinsam;alle zusammen;alle auf einmal;alle gleichzeitig
-Neopositivismus;logischer Empirismus;logischer Positivismus
-von-Mises-Iteration;Potenzmethode;Vektoriteration
-Konvergenzgeschwindigkeit;Konvergenzordnung
-Gestaltänderungshypothese;Gestaltänderungsenergiehypothese;Mises-Vergleichsspannung
-Jungstar;neuer Stern am ...himmel;Neuentdeckung
-Interpolation;Zwischenwertberechnung
-L.A. (Abkürzung, engl.);Los Angeles (Hauptform)
-Condorcet-Paradoxon;Zirkelpräferenz
-Sozialwahltheorie;Theorie kollektiver Entscheidungen
-Allgemeines Unmöglichkeitstheorem;Arrow-Paradoxon;Allgemeines Unmöglichkeitstheorem nach Arrow;Arrow-Theorem
-(sozusagen) der Chef sein (ugs.);(den) Laden schmeißen;(sich) um alles kümmern;dafür sorgen, dass der Laden (gut) läuft
-Weinkeller;Bodega (spanisch)
-nervöse Zuckungen (ugs.);(unkontrollierbares) Muskelzucken
-vegetatives Erythem (fachspr.);hektische Flecken (ugs., Hauptform)
-Probleme haben (mit);nicht zum Laufen bekommen;auf Kriegsfuß stehen (mit etwas) (fig.);ständig Ärger haben (mit);nicht bedienen können;(den Umgang mit ewas) nicht beherrschen;nicht klarkommen (mit etwas) (ugs.);(das mit etwas) nicht geregelt kriegen
-Erfolgsserie;Siegeszug
-(jemandem) auf Gnade und Ungnade ausgeliefert;(mit jemandem) machen können, was man will;(jemandes) Schicksal liegt in jemandes Hand
-Spinner (ugs., abwertend);Konfusling (ugs., selten);Wirrkopf (abwertend, Hauptform);Phantast (abwertend);Krauskopf (geh., fig.);Chaot (ugs., abwertend)
-(sein) eigenes Programm verfolgen;durch alle Raster fallen (fig.);in keine Schublade passen (fig.);nirgendwo einzuordnen sein;keiner (bekannten) Gruppierung zuzurechnen;autonom (sein)
-aus der Situation heraus agieren;kein Programm haben;spontan agieren
-Auspeitschen;körperliche Züchtigung;Tracht Prügel;Prügelstrafe;Auspeitschung;Bastonade
-Radikalinski (ugs.);Berufsrevoluzzer (ugs.)
-Feuerkopf;Heißsporn (Hauptform);Brausekopf;Hitzkopf
-Springrollo;Schnapprollo
-(jemandem) (eng) verbunden sein;(jemandem) nahestehen (Hauptform);befreundet sein (mit)
-zum Bibelkanon zählen(d);kanonisiert;kanonisch
-letztes Stadium;Endstadium
-Kampf ums Überleben;Kampf auf Leben und Tod
-davon bin ich überzeugt;jede Wette! (ugs.);da geh(e) ich jede Wette ein
-für mich sieht es aus (nach);lass mich raten (ugs., ironisierend);ich vermute
-als Dankeschön;zum Dank
-(jemanden) fertig machen;(jemandem) das Rückgrat brechen (fig.);(jemanden) in Stücke reißen (fig.);(jemanden) vernichten
-das muss anders laufen;so kann ich nicht arbeiten! (Spruch, variabel);so geht das einfach nicht
-Zitierkartell;Zitierzirkel
-Link-Netzwerk;Linkfarm (Hauptform)
-falsche Versprechung(en);heiße Luft (fig.);falsches Versprechen
-kriminelles Verhalten;kriminelles Handeln;(Begehung von) Straftaten;Kriminalität;Straffälligkeit;Delinquenz
-(jemanden) verulken;(jemanden) veralbern;(jemanden) hochnehmen (mit);(jemanden) aufziehen (mit);(seine) Späße treiben (mit)
-(sich) kaum verändert haben;(sich) gut gehalten haben;(gar) nicht älter geworden sein
-(da) hat er nicht ganz unrecht;stimmt irgendwo;stimmt eigentlich
-direkter Weg nach oben;kürzester Weg nach unten;Weg des größten Gefälles;Falllinie (Hauptform);direkter Weg nach unten;kürzester Weg nach oben
-Brotjob;Geldberuf;Brotberuf
-krank (sein);leiden (an);haben (Krankheit / Symptom) (ugs.);auf der Plauze liegen (derb);erkrankt sein (an);bekommen haben (ugs.)
-Yakuza;japanische Mafia(organisation)
-zu dominant sein;(förmlich) erschlagen (fig.);zu sehr dominieren;nicht zur Geltung kommen lassen
-undankbar (Aufgabe);(jemandem) nicht gedankt werden;wenig anerkannt
-(einander) freundschaftlich verbunden (geh.);befreundet;Freunde (sein)
-Zeitstrahl;Zeitleiste;Zeittafel
-im Wasser (ugs., regional);in Waage;(exakt) in Waagerechte (ugs.)
-Wasserwaage (Hauptform);Maurerwaage;Richtwaage
-Abziehlatte (fachspr., Jargon);Richtscheit (Hauptform);Alulatte;Abziehschiene (fachspr., Jargon);Richtlatte
-exakt senkrecht (ugs.);vertikal;in der Vertikale(n);im Lot (fachspr., Hauptform);lotrecht (fachspr.)
-in gleichem Abstand nebeneinander;parallel (mit / zu) (Hauptform)
-Stabschef;Chef des Stabes
-so geschehen (+ Zeitangabe) (geh.);dies war (etwa) der Fall (+ Zeitangabe) (variabel);so (...) zum Beispiel;so etwa (+ Zeitangabe)
-u. a. (Hauptform);eine(r) seiner vielen (...) (variabel);neben anderem;zum Beispiel;so auch;neben Verschiedenem (geh., selten);unter anderem (Hauptform);eine(r) von vielen (...) (variabel)
-zur Unterschrift bereit;unterschriftsbereit;(fertig) ausformuliert;unterschriftsreif (Hauptform);bis ins letzte Detail ausdiskutiert
-pro forma (lat.);weil es so üblich ist;weil es sich so gehört;artigerweise (geh., fig., ironisierend);höflicherweise;artig (geh., fig., ironisierend);aus (reiner) Höflichkeit
-aus dem Koffer leben (fig.);ständig auf Reisen (sein)
-nie zu Hause;immer unterwegs;ständig auf Achse (ugs.);es hält jemanden keine zwei Stunden (an einem Ort) (ugs., variabel)
-mit großem Trara (ugs.);mit viel Schaumschlägerei (abwertend);in einer großen Show;öffentlichkeitswirksam (Amtsdeutsch);mit großem Tamtam (ugs.)
-mangelnde Kontrolle (bei);Wildwuchs (fig.);(das) Überhandnehmen
-nicht früher als;ehestens;frühestens;nicht eher als;höchstens erst (ugs.)
-RAID;Festplattenverbund
-(jemanden) unter der Fuchtel haben;(jemandem) sagen, was er zu tun und zu lassen hat;(ein) strenges Auge haben auf (geh., veraltend)
-(jemanden) gepackt haben;(jemanden) am Kanthaken haben (fig.)
-(etwas) (frühzeitig und) ohne Absprache tun;(einer Sache) vorgreifen;(etwas) zu früh tun;nicht (ab)warten können;vorpreschen (Hauptform);(jemandem) vorgreifen
-gleich weg (sein) (ugs.);auf dem Sprung (sein);gerade zur Tür raus wollen (ugs.);gerade gehen wollen
-(sich) engagieren;Stellung nehmen;plädieren (für);(sich) aussprechen für;Stellung beziehen;(sich) einsetzen
-(sich) rühren;(sich) regen (geh.);(sich) rühren und regen;(sich) bewegen;(sich) rippeln (ugs., niederdeutsch)
-auf der Tagesordnung stehen;zur Debatte stehen;behandelt werden
-keine gesicherte Datenbasis haben;(sich) auf dünnem Eis bewegen (fig.);(hoch)spekulativ (sein)
-Grundzustandsenergie;Vakuumenergie;Nullpunktenergie;Nullpunktsenergie;Quantenvakuum
-ewig dasselbe;immer das gleiche;die alte Leier (ugs., fig.);das alte Lied;immer dieselbe (alte) Leier;immer dasselbe;kennt man schon;(wieder) das Übliche
-bemühen Sie sich nicht;(danke,) nicht nötig
-alles haben, was man braucht;nichts weiter brauchen (ugs.);(jemandem) fehlt es an nichts
-nichts, höchstens (dass);nichts, nur;nichts außer
-Wachszylinder;Wachswalze
-Frankatur;Frankierung;Freimachung
-Knochenszintigrafie;Skelettszintigrafie
-Chemosensibilität;Chemosensitivität
-Zytotoxizität;Cytotoxizität
-Zytokin;Cytokin
-Cytostatikum;Zytostatikum
-Schwefellost;Senfgas;Gelbkreuzgas;S-Lost;Lost;Schwefelyperit;Yperit
-ehrlich gesagt nicht (variabel);nicht unbedingt;nicht so (ugs.);nicht wirklich (ugs.)
-schlecht;beschissen (ugs.);scheiße (derb)
-(seine) Hände in Unschuld waschen (biblisch, fig.);(sich) herausreden wollen (Hauptform);(die) Verantwortung ablehnen;(sich seiner) Verantwortung entziehen (wollen);Ausflüchte machen;(jede) Verantwortung von sich weisen;Ausreden finden
-vorschützen;(sich) verschanzen (hinter) (fig.);vorgeben;vorschieben
-immer eine Ausrede finden;nie um eine Ausrede verlegen (sein);immer eine Ausrede parat haben
-Stehsatz (fachspr., auch figurativ);Textbaustein;Standardformulierung
-grafikfähiger Taschenrechner;Grafikrechner
-(sich) behaupten;(sich) nicht unterbuttern lassen (fig.);(sich) nicht alles gefallen lassen (ugs.);(sich) nicht die Butter vom Brot nehmen lassen (ugs., fig.);(sich) Respekt verschaffen;nicht klein beigeben;(sich) nicht unterkriegen lassen
-Karriereleiter;Weg nach oben
-Hausgenosse;Mitbewohner
-Chionodoxa (fachspr., botanisch);Schneestolz;Sternglanz;Sternhyazinthe (Hauptform)
-Semmelmehl;Paniermehl (aus geriebenen altbackenen Brötchen);Weckmehl;Semmelbrösel
-Steakhaus;Steakrestaurant;Steakhouse (engl.)
-(sich) austollen;voll und ganz genießen;(sich) ausleben;ungezügelt sein;ausgelassen (sein)
-Hausgemeinschaft;Hausgenossenschaft;Hausstand;Hauswesen;Familie;Haushalt
-Generalversammlung;GV (Abkürzung)
-leichtlebig;unbeschwert;unbekümmert;leichtherzig
-regeneriert;ausgeruht;ausgeschlafen;erholt
-leichten Herzens (tun);(jemandem) leichtfallen;mit leichtem Herzen (tun);(sich) nicht überwinden müssen;nicht lange darüber nachdenken;(sich) etwas nicht (sehr) zu Herzen nehmen;nicht weiter darüber nachdenken;(für jemanden) die normalste Sache der Welt sein (ugs.)
-überdreht;übergeschnappt;durchgedreht;ausgeflippt;wildgeworden;ausgetickt;frei drehen(d) (ugs., Neologismus);(herumspringen) wie Rumpelstilzchen;durchgeknallt
-(evangelikaler) Geistlicher;(evangelikaler) Gelehrter;(eine Art) Pastor (ugs., fig., variabel);Doctor of Metaphysics (fachspr.);DoM (D.o.M., DM, D.M.) (fachspr., Abkürzung, variabel);Reverend (fachspr., Anredeform, engl.)
-Zigarrenanzünder (veraltet);Zigarettenanzünder
-Gewaltaktion;Gewaltakt;Gewalttat
-geistliches Spiel;geistliches Drama;liturgisches Spiel
-Mindestvoraussetzung;Mindestanforderung
-Raufaser;Raufasertapete
-Offiziator;Offiziant
-Akademische Gerichtsbarkeit;Universitätsgerichtsbarkeit
-(ein) hohes kirchliches Amt bekleiden;geistlicher Würdenträger (sein)
-(ein) Klopper (sein) (ugs.);(sich) einen Klops leisten;(wieder) einen bringen (ugs.);(der) Witz in Tüten! (ugs.)
-DM (auch D.M., Doctor of Metaphysics = klerikaler Gelehrter im Evangelikalismus der USA);Reverend (fachspr., religiös);Theologe (fachspr., religiös)
-Fußballrüpel;Holzfäller (ugs., fig.);Klopper (ugs., salopp);Treter (ugs.)
-mit hartem Körpereinsatz;erbittert (kämpfen);rustikal (ironisch);beinhart (Mannschaftssport);unzivilisiert (Spielweise) (fig.)
-Hündin (Hauptform);Hundemama (ugs.);Fähe (fachspr.);Hundedame
-Hundejunges;Hundebaby;Welpe (Hauptform)
-Scolasticus Theologicae (Sc. Theol.) (geh.);Sc. Theol. (geh., Abkürzung)
-Folge von Niederlagen;Serie von Flops (variabel);Negativserie;Pannenserie;Pechsträhne (Hauptform)
-groß aufspielen (fig.);ein großartiges Spiel machen
-(ein) großartiges Konzert geben;groß aufspielen
-schon da sein;parat stehen;zur Stelle sein;(rechtzeitig) da sein
-kennt man (hier) sonst gar nicht (ugs.);aus der Art geschlagen;untypisch;haben wir (hier) sonst gar nicht (ugs.)
-Längenproblem;Längengradproblem
-Wahlbetrug;Wahlfälschung
-Hyoscin;Scopolamin
-covern (Musiktitel) (fachspr., Jargon);nachspielen (ugs.);(als) Coverversion herausbringen;(einen Titel) übernehmen
-mit Preisen überhäuft werden;begeistert aufgenommen werden;gefeiert werden;begeisterte Aufnahme finden
-Informationsverteilung (im Satz nach Wichtigkeit);(eine bestimmte) Anordnung der Satzteile;Hervorhebung (einzelner Satzteile);Topikalisierung (fachspr.)
-Charisma;Präsenz (geh.);Ausstrahlung;Strahlkraft
-Darmverschlingung;Volvulus (fachspr.);Darmverdrehung
-verknüpfen;koppeln
-sternenklar;wolkenlos (nachts)
-jugendfrisch;aufgeblüht (fig.);frisch wie der junge Morgen;frisch wie eine Rose (geh.)
-verhext;unter einem Zauber (stehend);(es) lastet ein Fluch (auf jemandem);verzaubert;unter einem Bann (stehen);verwunschen;behext;verflucht
-(unmittelbaren) Zugang (zu Informationen) haben;aus erster Hand wissen;(direkt) an der Quelle sitzen (fig.)
-problemlos besorgen können;beim Hersteller arbeiten (variabel);(direkt) an der Quelle sitzen (fig.)
-(einen Teil) wegnehmen;auf die Seite schaffen (fig.);für sich nehmen;(etwas) abknapsen (von) (ugs.);(etwas) abzweigen (von);(etwas) verschwinden lassen
-salafistisch;dschihadistisch;wahhabitisch;islamistisch
-rückwärtsgewandt (geh., Hauptform);nicht in der Gegenwart angekommen;antimodernistisch (geh.);vergangenheitsverklärend (geh.);fortschrittsfeindlich;rückschrittlich;zurückgeblieben;reaktionär;Früher war alles besser. (ugs., Spruch)
-Fugen-s;Binde-s
-Schaltschütz;Schütz
-Was dem einen sin Uhl, ist dem andern sin Nachtigall. (sprichwörtlich);Jedem Tierchen sein Pläsierchen. (ugs., Spruch);De gustibus non est disputandum. (geh., Spruch, bildungssprachlich, lat.);Jeder soll nach seiner Fasson selig werden. (geh., Zitat);Über Geschmack lässt sich nicht streiten. (sprichwörtlich);Die Geschmäcker sind (halt) verschieden,;Jedem das Seine. (Zitat);Suum cuique. (geh., Zitat, bildungssprachlich, lat.);Über Geschmack lässt sich streiten. (Spruch);Wat den eenen sin Uhl, is den annern sin Nachtigall. (Sprichwort, plattdeutsch, variabel)
-Wenn zwei das Gleiche tun, ist das noch lange nicht dasselbe. (sprichwörtlich);Quod licet Iovi, non licet bovi. (geh., bildungssprachlich, lat., sprichwörtlich)
-vorübergehend untergebracht sein;kampieren (bei);provisorisch wohnen
-du machst das ganz toll;du machst das super (ugs.)
-nicht nachlassen!;bleib am Ball;weiter so;dranbleiben!;(mach) so weiter
-nütze sein (zu);nutze sein (zu / für);da sein (für / zu) (ugs.);(etwas) nehmen können (zu / für / um zu) (ugs.);gut sein (für) (ugs.);(etwas) machen können (mit);(einen) Zweck erfüllen;zu gebrauchen sein (zu)
-über den Berg sein (fig.);die Kurve gekriegt haben (fig.);(es) (noch einmal) geschafft haben
-die Kurve kriegen (fig.);sein Leben (wieder) in den Griff kriegen
-sein Leben nicht auf die Reihe kriegen;seinen Scheiß nicht geregelt kriegen (derb);mit sich selbst nicht klarkommen
-kann gut sein;nicht mit Bestimmtheit wissen;jetzt gerade nicht wissen (ugs.);im Moment nicht wissen (ugs.);da müsste man mal nachsehen (ugs., Spruch);nicht auswendig wissen
-Karolinenfrage;Karolinenstreit
-Deutsches Kaiserreich;Zweites Reich
-Neuere Geschichte;Frühmoderne;Frühe Neuzeit
-noch nicht erlebt haben;(jemandem) noch nicht untergekommen sein;(so etwas / so einer) war noch nicht dabei;(jemandem) noch in seiner Sammlung fehlen (fig., ironisch)
-wie in einem schlechten Film;grotesk;wie in einer Klamotte;slapstickartig
-(im Innern) durch Feuer zerstört werden;ausbrennen
-(Sachen) wegräumen;Platz schaffen
-Schwangere;Gravida (fachspr.);werdende Mutter
-Senkrechtstarter (fig.);Shootingstar
-begnadeter Verkäufer;Verkaufsgenie;Verkaufskanone (Hauptform)
-(jemanden) zu nehmen wissen;(gut) mit jemandem können (ugs.);(ein) Händchen haben (für) (ugs.);wissen, wie man jemanden zu nehmen hat;(mit jemandem) gut umgehen (können);(mit jemandem) umzugehen verstehen;(mit jemandem) klarkommen (ugs.)
-unwiderstehlich;für sich einnehmen(d);entwaffnend (fig.);gewinnend
-Erfindung der Tradition;konstruierte Tradition;neue Tradition;erfundene Tradition
-verpuffen lassen (fig.);ins Leere laufen lassen (fig.)
-ausschleichen;langsam absetzen;langsam reduzieren
-Querschläger;verirrte Kugel
-zu Begeisterungsstürmen hinreißen;(jemanden/etwas) frenetisch feiern;begeistert gefeiert werden;(jemanden/etwas) frenetisch bejubeln;begeistert aufgenommen werden (von);begeisterte Aufnahme finden (bei);(sich) vor Begeisterung überschlagen (fig.)
-Menschen, Tiere, Sensationen (Spruch);(es) wird an nichts gespart;nichts wird ausgelassen;(es) ist alles dabei;keine Kosten und Mühen scheuen
-da darf man auch ruhig mal fröhlich sein, nur ... (ugs.);bei aller Freude;so schön das auch ist;so sehr man sich auch freuen mag;so schön das auch (gewesen) sein mag
-es gibt Kritik (an);nicht alle hinter sich haben;nicht unumstritten (sein);es wird Kritik lauf (an)
-(anderen) Zeiten entgegengehen;(die) Vorzeichen haben sich geändert (fig.);unter anderen Vorzeichen (fig.);(jetzt) wird alles anders
-Tischkocher;Stövchen;Rechaud (franz.);Untersatz, um Kaffee-oder Teekannen heiß zu halten
-Amadisli (schweiz.);Pulswärmer
-innerlich bewegt;aufgewühlt;(gefühlsmäßig) bewegt;(von etwas) angefasst (geh.)
-Detailaufnahme;Naheinstellung;Makro;Makroaufnahme;Nahaufnahme
-Telespargel (ugs.);Berliner Fernsehturm
-fundierte Ordnung;noethersche Ordnung;fundierte Menge;terminierende Ordnung;wohlfundierte Menge
-(3n+1)-Vermutung;Collatz-Problem
-Radó-Funktion;Fleißiger-Biber-Funktion
-Untergymnasium;Progymnasium
-ins Geschäft kommen;zusammenkommen (ugs., fig.);im Geschäft sein (ugs.);(sich) handelseinig werden;einen Deal haben (ugs.)
-darüber lässt sich reden;das ist (doch) mal ein Angebot;das ist ja schon mal was;das ist wenigstens ein Anfang
-Patagium (fachspr.);Flughaut
-Rüttelflug;Standschwebeflug;Schwebeflug
-(eine) Typfrage (sein);(eine) Frage der Persönlichkeit (sein);(eine) Mentalitätsfrage (sein);davon abhängen, was für ein Typ man ist;darauf ankommen, wie jemand drauf ist (ugs., salopp)
-habe ich Sie (da) richtig verstanden (, dass ...)? (floskelhaft);korrigieren Sie mich bitte (, wenn ...) (floskelhaft)
-Unternehmen Herkules;Operation Herkules
-nicht umsonst so heißen (ugs.);seinem Namen gerecht werden;seinem Namen alle Ehre machen
-mit seiner Kritik nicht hinter dem Berge halten;offen kritisieren;sagen, was einen stört;öffentlich kritisieren;sagen, was einem nicht passt (ugs.);(seinem) Missfallen Ausdruck geben (geh.)
-Dutzendgesicht;Allerweltsgesicht
-Zungenkuss (Hauptform);französischer Kuss;florentinischer Kuss;Seelenkuss
-Busserl (ugs.);Bussi (ugs.);Küsschen
-ohne erkennbaren Grund;ohne erkennbaren Zusammenhang;zusammenhanglos;unmotiviert
-(das) Sein;(das) Existieren
-(jemandes) Krempel (ugs., abwertend);(jemandes) Sachen;(jemandes) Siebensachen;(jemandes) Kram (ugs.);(jemandes) Spielsachen (ugs.);(jemandes) Plörren (ugs., abwertend, rheinisch)
-(ein vom Menschen hergestellter) Gegenstand;Artefakt (Volkskunde, Archäologie) (Hauptform);(ein) von Menschenhand Geschaffenes
-menschengemacht;von (einem) Menschen hergestellt
-nach wie vor;wie eh und je;damals wie heute;auch heute noch;immer noch wie damals;heute noch, wie in den alten Zeiten;heute noch wie damals
-unangefochten sein;niemand macht jemandem (etwas) streitig;fest im Sattel sitzen (fig.)
-(jemandem etwas heimlich) in die Hand drücken;(jemandem etwas) zustecken
-unschädlich machen;(den) Zünder entfernen;(einer Sache) die Gefährlichkeit nehmen;unscharf machen;entschärfen (Hauptform)
-Durchgangsverkehr;Durchzugsverkehr (österr.)
-Kretzer;Egli (schweiz.);Flussbarsch
-Liegestuhl;Liege;Sonnenliege
-Phasenübergang;Phasenumwandlung;Phasentransformation
-Kondensationslinie;Kondensationskurve
-Taukurve;Taupunktlinie;Taulinie;Taupunktkurve
-Erstarrungskurve;Gefrierpunktslinie;Erstarrungslinie;Gefrierpunktskurve
-Sublimationslinie;Sublimationskurve
-Sublimierung;Sublimation
-ich werde mich darum kümmern;überlass das mir;lass mich nur machen
-Heiliges Jahr;Jubeljahr
-Weinsberger Bluttat;Weinsberger Blut-Ostern
-Pellkartoffeln (Hauptform);Pell(e)männer (ugs., ruhrdt.)
-Asylbewerberheim;Flüchtlingsheim
-Notunterkunft;Behelfswohnung;Behelfsunterkunft
-Nissenhütte(n) (historisch, veraltet);Nissenhütten-Siedlung (historisch, veraltet);Containerdorf;Barackensiedlung
-unmenschlich;menschenunwürdig
-Wüstenrose;Jerichorose;Jerusalemrose;Marienrose;Echte Rose von Jericho
-(seinen) Charme spielen lassen;(eine) Charmeoffensive starten;auf 'netter Junge von nebenan' machen;auf Sonnyboy machen;(sich) von seiner liebenswürdigen Seite zeigen
-liebenswürdig;mit Wärme;warm (fig.);herzlich;freundlich
-sympathisch;entgegenkommend;nett;offen;freundlich
-(jemandem) liegen;(jemandem) leichtfallen;(etwas) mühelos (tun);begabt sein (für)
-Geomatik;Geoinformationstechnik
-entrückt;unerforschlich;unergründlich;geheimnisvoll;unerforschbar;unbegreiflich;unzugänglich;abgründig;unerkundbar
-direkt benachbart;Zaun an Zaun;(unmittelbar) angrenzend;Tür an Tür (variabel);adjazent (fachspr., Sprachwissenschaft, mathematisch);Wand an Wand;in unmittelbarer Nachbarschaft;gleich nebenan
-Vermarkter;Vertreiber
-Telefonvertrieb;Telefonverkauf;Telefonmarketing
-Grenzsperre;Grenzbalken;Schlagbaum;Grenzbaum;Grenzbarriere;Grenzschranke
-Quetschkanne (ugs.);Siebstempelkanne (fachspr.);Pressstempelkanne (fachspr.);Kaffeedrücker (ugs.);Chambordkanne (franz.);French Press Kaffeezubereiter (fachspr., werbesprachlich);Cafetière (franz.);Kaffeebereiter (French Press System) (fachspr., werbesprachlich);Kaffeepresse
-Schokoladenseite (fig.);beste Seite (einer Person)
-sein wahres Gesicht zeigen (fig.);(sich) entpuppen als (fig.)
-auf Deutsch;zu Deutsch
-Landesschutzoffizier;L-Offizier
-Navigator;Navigationsoffizier
-beugender Muskel;Beugemuskel;Flexor (fachspr.);Beuger
-Entsetzung (fachspr., militärisch);(den) Belagerungsring durchbrechen;Befreiung;Entsatz (fachspr., militärisch)
-Nom de guerre (geh., franz.);Kampfname;Pseudonym (eines Militärführers, Kämpfers, Boxers...)
-(das) Auftreten;Gehabe (geh., abwertend);Gebaren;Habitus (geh., bildungssprachlich);Gestus (geh., bildungssprachlich);Attitüde (geh., bildungssprachlich, franz.)
-genauso argumentieren;(eine) Argumentation unterstützen;(etwas) genauso sehen;(etwas) argumentativ unterstützen;auf der gleichen Linie liegen (Argumente, Äußerungen ...) (fig.);ins gleiche Horn stoßen (fig.);in dieselbe Richtung gehen (Äußerung, Erklärung, Feststellung ...) (fig.);in die gleiche Kerbe schlagen (fig.);nachlegen;(sich) ähnlich äußern
-zum Einsatz kommen;verwendet werden;genutzt werden;Verwendung finden;eingesetzt werden
-kein Unbekannter sein;(eine) große Nummer (sein) (fig.);(eine) bekannte Größe (sein);(eine) Berühmtheit (sein);wer sein;(jemandes) Name hat einen guten Klang (fig.);...größe;man kennt jemanden (irgendwo);ein ganz Großer / eine ganz Große (variabel);(ein) Grande / (die) Granden (des / der ...) (geh., fig.);(sich) einen Namen gemacht haben;(ein) großer Name
-kein böses Wort verlieren (über);(es) fällt kein böses Wort (über) (fig.);(sich) mit Kritik zurückhalten (an);freundlich umgehen (mit) (auch figurativ)
-nichts gemeinsam haben;aus verschiedenen Welten kommen (fig.);(sich) nichts zu sagen haben;aus unterschiedlichen Welten stammen (fig.);keine Gemeinsamkeiten haben
-brechen mit;(jemanden) ächten (veraltend);abgemeldet sein (bei);(jemanden) ausschließen (aus);(jemanden) verstoßen (Hauptform);(jemanden) ausstoßen (aus);für jemanden gestorben sein
-Batschkapp (ugs., süddt.);Schlägerpfanne (ugs.);Schieberkappe;Schiebermütze;Schlägermütze (ugs.)
-(sich) nicht interessieren (füreinander);(sich) nicht austauschen;aneinander vorbeileben;keinen Anteil nehmen (aneinander)
-(ein) Einsiedlerleben führen;Gesellschaft meiden;(ganz) für sich leben;alleine vor sich hinleben
-ohne Verbindung zur Außenwelt;von der Außenwelt abgeschnitten (sein);nicht (mehr) erreichbar;ohne Möglichkeit der Kontaktaufnahme
-von der Außenwelt abgeschnitten (sein);eingeschlossen sein;(irgendwo) festsitzen
-persönlich zuordenbar;personenbezogen
-(jemandes) Privatsache (sein);keinen (anderen) etwas angehen;(jemandes) Privatangelegenheit (sein);niemand anderen etwas angehen;(jemandes) Privatvergnügen (sein) (ironisierend)
-es gibt *doch* (noch) eine Gerechtigkeit (auf dieser Welt)!;ausgleichende Gerechtigkeit
-(jemandes) ureigener (eigene, eigenes);(jemandes) eigener (eigene, eigenes)
-alle Möglichkeiten haben;(die) freie Auswahl haben;(jemandem) stehen alle Wege offen (fig.);(es sich) aussuchen können;(jemandem) stehen alle Türen offen (fig.);(jemandem) steht die ganze Welt offen (fig.)
-Ungereimtheit(en);Merkwürdigkeit(en);Unstimmigkeit(en);Widersprüchlichkeit(en);Unregelmäßigkeit(en);Inkonsistenz(en) (geh.)
-höchstwahrscheinlich nicht (mehr);kaum noch;(etwas ist) ziemlich unwahrscheinlich
-schlicht und einfach;einfach;(jetzt) wirklich;ehrlich gesagt;jetzt echt (ugs.)
-von herausragender Bedeutung;einer (eine / eines) der bedeutendsten (...);gehören zu den bedeutendsten (...);gehören zu den wichtigsten (...);einer (eine / eines) der wichtigsten (...);ein (eine) (...) ersten Ranges
-kommunikationsunfähig (Hauptform);autistisch (abwertend, fig.);kommunikationsgestört
-Margeritentag;Margarittentag;Margaretentag
-(die) erste Adresse (für/bei) (fig.);(der Name) wird immer zuerst genannt;(der/die/das) renommierteste;(das) führende Haus
-Goldelbe;Süddeutsche Mondtaube
-Magyarisierung;Madjarisierung
-Spitzhaube;Spitzkappe
-Belgizismus;Belgismus
-Bundesgermanismus;bundesdeutsche Spracheigentümlicheit;Germanismus;Deutschlandismus;Teutonismus
-Grundsicherung;Mindestsicherung;Grundversorgung
-Parifizierung;Nutzwertberechnung
-Pazifikation (veraltet);Pazifizierung (veraltet);Befriedung
-Zweiter Italienisch-Libyscher Krieg;Italienische Rückeroberung Libyens;Italienische Wiedereroberung Libyens
-Wiedereroberung;Rückeroberung
-Alpenstaat;Alpenanrainerstaat
-Schlacht bei Austerlitz;Drei-Kaiser-Schlacht
-harmonisch;musikalisch;stimmig;melodiös;melodisch
-Tenne;Lohdiele (norddeutsch);Tenn (schweiz.)
-Defereggen;Defereggental
-Nässe;Feuchtigkeit;Nass
-Ämterkumulation;Ämterhäufung
-Publikationshabilitation;Sammelhabilitation;kumulative Habilitation
-Publikationsdissertation;kumulative Dissertation;Sammeldissertation
-Rollschweller;Walze;Registerschweller;Crescendotritt
-Kombinationsprolongement;Register-Prolongement;Registerfessel
-verdreht;mehrdeutig;verwickelt;kompliziert
-Turanismus;Panturanismus
-Mandschuren;Mandschu
-Spurhalteassistent;Spurassistent
-nicht mithelfen (beim Getragen-Werden);(sich) schwer machen
-kräftig (Farbe) (Hauptform);voll (Farbe);leuchtend (Farbe);satt (Farbe);lebhaft (Farbe) (fig.);intensiv;strahlend (Farbe);stark (Farbe)
-bei jeder Kleinigkeit weinen;nah(e) am Wasser gebaut haben (fig., Hauptform);oft weinen;schnell weinen;sofort weinen (müssen);immer gleich weinen
-betrügerisch;auf Betrug aus;auf Betrug ausgehend;unlauter;unredlich
-geistig beweglich;geistig regsam;schnell im Denken
-bis ins Letzte durchdacht;durchdacht;ausgereift;zu Ende gedacht
-(seinen) Verstand (bemühen);Gehirnschmalz (einsetzen) (ugs., fig.);(die) kleinen grauen Zellen (aktivieren);(seinen) Gehirn(s)kasten anstrengen
-verständig;vernunftbegabt;einsichtsfähig (geh.)
-K-Wanne (fachspr.);Bauwerksabdichtung
-Kellerabdichtung;erdberührte Bauwerksabdichtung (fachspr.)
-Bauform;Baugröße;Länge x Breite x Höhe;Einbaugröße;Abmessung(en);Maße;Formfaktor (PC)
-Feuerwehrgerätebeschaffungskartell;Feuerwehrfahrzeuge-Kartell;Feuerwehr-Kartell
-Sternenjahr (fachspr.);siderisches Jahr (fachspr.)
-Jahrgangsstufe (fachspr., Amtsdeutsch);Schuljahr;Klasse
-Depressivität;depressive Grundstimmung
-Schwumm (regional, schweiz., selten, süddt.);Schwimmaktivität;Schwimmvergnügen;Badespaß
-(hartnäckig) bleiben (bei);seinen Stiefel durchziehen (ugs.);seinen Streifen durchziehen (ugs.)
-Uradel;alter Adel (österr.)
-Timur;Tamerlan (veraltend);Timur Lenk (variabel);Temür ibn Taraghai Barlas (fachspr.)
-Galicisch;Galegisch
-Vernakulärsprache;Vernakularsprache
-Asturisch-Leonesisch;Asturleonesisch
-Krull;Krullgalion;Bugkopf
-zvE;Höhe des zu versteuernden Einkommens;steuerbares Einkommen (schweiz.);Bemessungsgrundlage;zu versteuerndes Einkommen
-Justizgerichtsbarkeit;ordentliche Gerichtsbarkeit
-Sequentialisierung;Sequenzialisierung
-ein bisschen (graduierend vor Adjektiven und Verben);ein klein wenig (vor Adjektiv oder Verb);ein büschen (ugs., norddeutsch);schwach (graduierend vor Adjektiven und Verben);ein bisserl (ugs., süddt., österr.);etwas (Gradadverb vor Adjektiven und Verben);ein bissel (ugs., süddt.);leicht (vor Adjektiven);ein wenig (Gradadverb vor Adjektiven und Verben) (geh.)
-Immunofluoreszenz;Immunfluoreszenz
-Retikulohistiozytäres System;Retikuloendotheliales System (veraltet)
-Omsker Fieber;Omsker hämorrhagisches Fieber
-Triangulation;Triangulierung
-Czochralski-Verfahren;Ziehen aus der Schmelze;Tiegelziehverfahren
-Kristallzüchtung;Kristallzucht
-Einkristall;Monokristall;monokristalliner Körper
-Multikristall;Polykristall;Vielkristall (selten)
-Pflichtfilm;muss man gesehen haben (Film)
-muss man gelesen haben;Pflichtlektüre
-Gleitbauverfahren;Gleitschalungsfertigung;Gleitbauweise
-auch das noch! (ugs., Spruch);(das) hat mir gerade noch gefehlt!;als wenn ich nicht so schon genug Probleme hätte!;Das wird ja immer besser! (ugs., Spruch, ironisch);das fehlt(e) mir noch zu meinem Glück (Spruch, variabel);Ein Unglück kommt selten allein! (Sprichwort)
-darauf kommt es jetzt auch nicht mehr an (ugs.);mich kann nichts mehr erschüttern (ironisch);(das) ist jetzt auch egal (ugs., Hauptform);(es) ist eh schon wurscht (ugs., süddt.)
-Nachgeborener;Nachzögling;Nachzügler (fig., variabel)
-LOL (ugs., Abkürzung, Jargon, engl.);ein (echter) Brüller! (ugs.);ich könnt' mich wegschmeißen (vor Lachen) (ugs.);ROFL (ugs., Abkürzung, Jargon, engl.);(und) haben wir gelacht! (ugs.);selten so gelacht! (ugs., Hauptform)
-Netzjargon;Internet Slang (ugs., engl.);Internet-Jargon
-sterben vor;(es) verlangt jemanden nach (geh., literarisch, veraltend);großes Verlangen haben (nach);unbedingt brauchen
-lesen (können) wie in einem offenen Buch (in jemandem) (variabel);jemandes Gedanken erraten können;jemandes Gedanken lesen können;(genau) wissen, wie jemand tickt;ich sehe es an deiner Nasenspitze (zu Kindern) (ugs., variabel);(genau) wissen, was jemand denkt;(für jemanden) ein offenes Buch sein
-Fabriketage;ehemalige(r/s) (+ Bezeichnung der alten Nutzung);Loft (engl.);Atelierwohnung;Loftwohnung;Künstlerwohnung
-unterschiedlich machen;in unterschiedliche Teile auftrennen;diversifizieren
-(ein) Sicherheitsrisiko (darstellen) (Person);(eine) Gefahr (für die Allgemeinheit);gemeingefährlich (sein);(eine) tickende Zeitbombe (sein) (Person) (fig.)
-Schreck lass nach! (ironisierend);huch!;oh je!;oh Schreck und Graus! (veraltend);Gott, hab ich mich jetzt erschrocken! (ugs.)
-Filterblase;Blase (Hauptform);Informationsblase;Echokammer (fig.)
-durchgezogene Linie;nicht unterbrochene Linie;gestrichene Linie;durchgestrichene Linie
-Steuerfachangestellter;Steuerfachgehilfe (veraltet)
-immer vorausgesetzt;aber nur, soweit (ugs.);außer, wenn (...) nicht (ugs.);aber nur, solange (ugs.);immer unter der Voraussetzung, dass
-Plazentatier;Höheres Säugetier
-Lesung;Vorleseabend;Dichterlesung;Buchvorstellung (durch den Autor);Leseabend;Autorenlesung
-Polsterzipf;Wiener Polsterzipf
-direkt hier;gleich hier;vor deiner Nase;hier
-gierig nach;...geil (derb);heiß auf;...hungrig;verlangen nach;...(be)gierig;...lüstern;...lustig;gieren nach
-nie hat man seine Ruhe;(es) ist immer was los (ugs.);irgendwas ist immer (ugs., Spruch);immer ist irgendwas (ugs.)
-Große Bernsteinmakrele;Grünel;Bernstein-Stachelmakrele
-Stachelmakrele;Pferdemakrele
-Grazer Bucht;Steirisches Becken;Steirisches Hügelland
-nicht ernsthaft (betrieben);ohne rechte Überzeugung;halbherzig;nicht mit Nachdruck (verfolgt / geführt ...)
-das können wir ihm nicht ersparen;das muss er (jetzt) aushalten;da muss er jetzt durch (ugs.)
-vergiftet;durch Gift getötet
-giftig gemacht;mit Gift versetzt;gift...;Gift enthalten;(es gibt) Gift (in) (ugs.);vergiftet (sein) (Hauptform)
-(wie) verdammt nochmal;(wie) um Himmels willen;(wie) zum Teufel (Hauptform, variabel);(wie) in drei Teufels Namen
-verlogene Fresse (derb);Lügenmaul
-(jemanden) stolz machen;(jemandem) den Kamm schwellen lassen (ugs.);(jemanden) übermütig machen;(jemanden) übermütig werden lassen;(jemandes) Brust mit Stolz erfüllen
-nicht mehr brauchen;nicht mehr benötigen;über haben (ugs.)
-überall hier;an jeder Ecke
-50 %;einer von zwei(en);der halbe (die halbe / das halbe);jeder zweite;50 Prozent;die Hälfte (Hauptform);halb (+ Land, Bundesland o.ä.)
-im Stau (stehen);Stoßstange an Stoßstange (stehen)
-(sich) einen Weg in die Freiheit verschaffen;(aus dem Gewahrsam) entkommen;(aus dem Gefängnis) ausbrechen;türmen
-leicht übertreibend;zugespitzt (Hauptform);schärfer formuliert;überspitzt;pointiert
-um...;anderswo(hin);ver...
-(da warst du) noch (gar) nicht geboren (Hauptform);(das warst du noch) Quark im Schaufenster (ugs., fig.);(da warst du noch) in Abrahams Wurstkessel (ugs., fig.);(da hast du noch als) Käse im Schaufenster (gelegen) (ugs., fig.)
-Fesselung;Bannung;Faszination
-Scriptsprache;Skriptsprache (Hauptform)
-Koreanische Halbinsel;Korea
-das musst du dir mal vorstellen! (empört);das musst du dir mal (erst) mal reinziehen! (ugs.)
-Heißwasserspeicher;Boiler;Warmwasserspeicher;Speichererhitzer
-Kaffeemann (an der Espressobar) (ugs., salopp);Barista
-Kognitive Psychologie;Kognitionspsychologie
-Korrespondenzverzerrung;Attributionsfehler
-emotionale Beweisführung;emotionales Schlussfolgern
-Kagi-Nawa (fachspr., japanisch);Kletterhaken;Enterhaken;Enterdregge;Wurfanker;Wurfhaken
-künstlich auf alt getrimmt;Shabby Chic (Einrichtungsstil) (engl.)
-verblasst;pastellen (geh.);aufgehellt;pastellfarben;pastellig (ugs.);blass;milchig
-auf den Nerv gehen (ugs.);zusetzen;stören;behelligen;plagen;nachstellen;belästigen;stalken
-gaunerisch;ganovenhaft;betrügerisch;gaunerhaft
-(dazu) wurde nichts gesagt (ugs.);offen bleiben;unbeantwortet bleiben
-(jemandem) nicht wichtig sein;(etwas) zurückstellen;(einer Sache) eine (eine) geringe Bedeutung beimessen;(etwas) nicht (so) wichtig nehmen;anderen Dingen unterordnen;(etwas) hintanstellen (geh., fig., Hauptform)
-positiv überrascht werden;angenehm enttäuscht sein
-Alltagsessen;einfache Küche;Hausmannskost (auch figurativ)
-füllt den Magen (ugs.);Hauptsache, etwas zwischen den Zähnen (ugs., variabel)
-(jemandem) keine Begeisterungsrufe entlocken;(sich) nicht vor Begeisterung überschlagen;(jemanden) nicht (gerade) in (helle) Begeisterung ausbrechen lassen;(sich) wenig begeistert zeigen;nicht gerade begeistert scheinen
-blütenweiß;makellos weiß
-(ein) Lächeln zurückgeben;(das) Lächeln erwidern;ihrerseits lächeln (Plural, weibl.);zurücklächeln (Hauptform);seinerseits lächeln (männl.)
-Zuerkennung;Vergabe;Zuerteilung;Zusprechen;Erteilung;Verleihung
-sein eigenes Wort nicht verstehen (können) (übertreibend);kein Wort verstehen (können);zu laut sein (es, ihr)
-nichts sehen (können);die Hand nicht vor Augen sehen (können)
-nicht mit mir;da spiel(e) ich nicht mit;das war so nicht vereinbart
-mitsingen;mitspielen (Instrument);anfangen, mitzusingen;(sich) beteiligen (Musik);anfangen, mitzuspielen;(mit) einstimmen
-Thrombektomie;Thrombembolektomie
-(seine / eine / die) zweite Jugend erleben;neu aufleben;sich verjüngen;wieder jung werden;regenerieren;wieder erblühen
-Beutezug;Diebestour;Raubzug
-die Notrufnummer wählen;(die) 110 (die 112) wählen (ugs.);die Feuerwehr (den Notarzt / den Rettungsdienst / die Polizei / die Küstenwache) alarmieren / rufen / verständigen;einen Notruf absetzen
-von niedrigem Stand;bürgerlich;unedelig;von niedrigem Rang;unadelig;nicht adelig
-(sich fühlen wie) im falschen Film (ugs., variabel);denken "Wo bin ich hier (gelandet)?" (ugs.);seinen Augen nicht trauen (wollen);denken "Das darf doch alles / einfach nicht wahr sein!" (ugs.)
-über (den) Parteienstreit erhaben;über dem Parteiengezänk (stehen);über den Niederungen des Parteiengezänks
-Schulterstück;Achselschlinge (österr.);Achselstück
-Durchsuchungsaktion;Razzia;Durchsuchung
-Aktion;Operation (Anglizismus);Einsatz;Manöver
-Erkundungsfahrt;Erkundungsgang;Streifzug;Erkundungsaktion
-Wachgang;Streife;Patrouille;Kontrollgang
-Spähpatrouille;Spähtrupp (Hauptform, militärisch);Aufklärungseinheit (fachspr.);Spähzug;Aufklärungstrupp
-Strafexpedition;Strafaktion;Rachefeldzug;Bestrafungsaktion
-prävalent (fachspr.);häufigst;meistverbreitet;vorherrschend
-geruchlos;geruchsfrei
-(jemandem) unbekannt;(jemandem) neu (ugs.);noch nie gehört (ugs.)
-in Hochdeutsch;hochsprachlich;auf Hochdeutsch (gesagt)
-Landzunge;Kap;Landspitze
-Antransport;Anlieferung;Herantransport
-Auslieferung (kaufmännisch);Rollout (fachspr., Jargon, Marketing, engl.);Markteinführung (fachspr.);Marktfreigabe;In-Verkehr-Bringung (fachspr., Amtsdeutsch)
-Verkauf;Absatz;Vertrieb;Verteilung
-Arzneimittelfreigabe;Zulassung (Pharmaka);Marktfreigabe;Arzneimittelzulassung
-verkauft werden;in den Handel kommen;in den Verkauf gehen;(im Einzelhandel / für Endkunden) erhältlich;bezogen werden können;in den Verkauf kommen;auf den Markt kommen
-Flüchtiger;Entflohener
-Zungenbrecher;schwierig auszusprechendes Wort;schwer auszusprechende Wortfolge
-freudsche (sprachliche) Fehlleistung;Freud'scher Versprecher;freudscher Versprecher
-zungenbrecherisch;schwer auszusprechen;schwierig auszusprechen
-sich verhaspeln;(einen) Knoten in die Zunge bekommen;immer wieder hängenbleiben (bei);ins Stottern geraten
-(sich) falsch ausdrücken;(sich) ungeschickt ausdrücken;(sich) versprechen;das falsche Wort wählen;bei der Wortwahl danebengreifen
-(sich) versprechen;(etwas) falsch aussprechen
-pastorale Tierhaltung auf Naturweiden;Pastoralismus;Naturweidewirtschaft
-Hutewald;Hudewald;Hutung;Huth (veraltet)
-Waldweide;Hute;Hude
-(sich) verplappern;(jemandem) herausrutschen;(etwas) sagen, das man eigentlich nicht sagen wollte;(sich) versprechen
-Selbstverteidigung (Hauptform);Eigenschutz;Notwehr (Hauptform);Selbstschutz
-Abwehr;Hintermannschaft;Deckung;Verteidigung;Defensive
-decken;abschirmen;beschatten
-diskutiert werden;für Gesprächsstoff sorgen;(ein) Dauerthema sein;in der Diskussion stehen
-bis an die Zähne bewaffnet (fig.);hochgerüstet;überrüstet;vor Kanonen starrend;waffenstarrend
-Unregelmäßigkeit(en);Regelwidrigkeit(en);normwidriges Verhalten
-es gibt keinen (klaren) Sieger;(sich ein) totes Rennen (liefern);gleichauf liegen;unentschieden
-(jemanden) mitreißen (fig.);(jemanden) packen (fig.);(einen) Sog erzeugen (fig.);(jemanden) fesseln (fig.);(jemanden) erfassen (fig.);(jemanden) nicht wieder loslassen (fig.)
-zu seinem Hobby erkoren haben;(sich) eingeschossen haben (auf);(seinen) Schwerpunkt legen auf;(sich) überwiegend beschäftigen mit;(insbesondere / besonders) im Visier haben;(sich) spezialisiert haben (auf)
-auf Zoll-Basis;zöllig;im Zollmaßstab
-auf den Meter (als Basiseinheit) bezogen;metrisch;auf Meter-Basis
-Farbstoff;Lebensmittelfarbe
-Sprachkenntnisse;Fremdsprachenkenntnisse
-beiordnende Konjunktion;nebenordnende Konjunktion
-neongrün;giftgrün (ugs., Hauptform);quietschgrün (ugs.);knallig(es) gelbgrün (ugs., salopp);knallgrün (ugs.)
-Balneario (spanisch);Ballermann 6;Ballermann (ugs., Hauptform)
-Orpheum (geh., bildungssprachlich);Tonhalle;Konzertsaal
-Konzerthaus;Philharmonie
-Symphonieorchester (Hauptform);Philharmonie;philharmonisches Orchester;(großes) Orchester
-kleine Besetzung;Kammerorchester
-Klangkörper (fachspr.);musikalische Formation
-Aufführungsstätte;Musentempel;Veranstaltungsort
-freies Theater;experimentelles Theater;independent Theater;Zimmertheater;Wohnzimmertheater
-Figurentheater (fachspr.);Puppenspiel;Puppentheater;Marionettentheater
-jemanden einen Gefallen schuldig sein;(bei jemandem) in der Kreide stehen (ugs., fig.);in der Schuld stehen (bei);jemanden etwas schuldig sein;(jemandem etwas) schulden
-über den (politischen) Parteien stehend;nicht parteigebunden;von (politischen) Parteien unabhängig;überparteilich (Hauptform)
-parteilich;parteigebunden
-One-Man-Show;Alleinunterhalterprogramm;One-Woman-Show;Soloprogramm
-Arabischer Frühling;Arabellion
-unoriginell;wenig einfallsreich;phantasielos;unkreativ;wenig kreativ;fantasielos
-eine Schwäche ansprechen;eine Schwachstelle thematisieren;(den) Finger auf die Wunde legen (fig.);auf ein Übel hinweisen;(den) Finger in die Wunde legen (fig.)
-Auffindbarkeit;Findbarkeit;Möglichkeit, gefunden zu werden
-Werbefritze (ugs., abwertend);kreativer Kopf (fachspr., Jargon, mediensprachlich);Werbekauffrau (Hauptform);Mitarbeiter einer Werbeagentur (Hauptform);in der Werbewirtschaft tätig (variabel);Werbekaufmann (fachspr., Hauptform);Werbefuzzi (derb, abwertend);Kreativling (ugs., ironisierend);Reklamefuzzi (derb, abwertend)
-Art Director;Projektleiter (Werbeagentur)
-Leiter der Herstellung (Buchverlag);Hersteller
-Mitarbeiter für die Öffentlichkeitsarbeit;Pressereferent;Unternehmenssprecher;Firmensprecher
-bei (...);in Sachen (...);auf dem Gebiet (des/der ...);was (...) angeht (, so)
-unlädiert;körperlich unbeeinträchtigt;unverwundet;unversehrt;unverletzt;ohne gesundheitlichen Schaden
-Staudrucksonde;Pitot-Rohr;Pitotrohr
-Prandtlsonde;Prandtlsches Staurohr
-Gesamtdruck;Totaldruck
-Ruhedruck;Stagnationsdruck
-gesund (fig.);natürlich;naturgegeben;normal;unverbildet (Hauptform)
-in der Kreide stehen (bei);Schulden haben (bei);(etwas) offen haben (bei);(einen / diverse) Posten offen haben (bei);Verbindlichkeiten haben (bei / gegenüber);(jemandem) Geld schulden;(noch) Geld zu bekommen haben (von)
-nach Leibeskräften;soviel (wie) jemand will;was das Zeug hält;soviel (wie) jemand lustig ist (ugs.);aus Leibeskräften
-alter Kasten (ugs.);altes Gebäude;Altbau
-(sich) verfangen (mit ... in);hängenbleiben (mit ... an);(sich) verhaken
-(etwas irgendwo) hängen lassen können;aufgehängt bleiben können;hängen bleiben (können / dürfen / sollen) (Hauptform);nicht abgenommen werden müssen;nicht umgehängt werden müssen
-haften bleiben;kleben bleiben;hängen bleiben
-nicht wieder runterkommen;hängenbleiben (auf LSD o.ä.) (Jargon)
-(an jemandem) hängenbleiben (ugs., Hauptform);(ich) kann dann wieder (mit Betonung) (ironisierend);niemand (sonst als ...) kümmert sich (um) (ugs.)
-Kabelbaum;Kabelsatz;Leitungssatz
-zwielichtig;schillernd (Person);ambivalent
-nicht gut und nicht schlecht;nicht eindeutig (Beurteilung);zwiespältig;nicht gut, aber auch nicht richtig schlecht
-schlaflos;ohne Schlaf
-lachender Dritter (fig., Hauptform);freudiger Nutznießer (eines Konflikts)
-schadenfroh (sein);(sich) ins Fäustchen lachen
-(sich) ins Fäustchen lachen (können);(sich) zufrieden zurücklehnen können;(sich) die Hände reiben (können)
-durcheinander geratene Tonbänder (variabel);Bandsalat (veraltend)
-jetzt auf einmal;und jetzt das!
-und dann so etwas!;dann aber;und dann das!
-was immer;was auch immer;ganz gleich, was;egal was
-warum auch immer;egal warum;ganz gleich, warum
-egal (+ Fragewort);ganz gleich (+ Fragewort);(Fragewort +) auch immer
-einem Wunsch entsprechen;einer Bitte nachkommen;(einem) Ersuchen stattgeben (Amtsdeutsch);in jemandes Sinne entscheiden (über);tun, was jemand wünscht (ugs.)
-(das) sein, was jemand (haben) will (ugs.);(jemandem) entgegenkommen;(jemandem) gefallen;in jemandes Sinne liegen;auf jemandes Linie liegen (fig.);(jemandem)(gut) passen (ugs.);nach jemandes Geschmack sein;(jemandem) sympathisch sein;(jemandes) Erwartungen entsprechen;(jemandem) behagen;(jemandem) konvenieren (geh.);Gefallen finden (an);(jemandem) zusagen (geh.);(jemandem) angenehm (sein)
-(Steuern) an den Fiskus abführen;Steuern zahlen
-Christdemokrat;CDU-Mitglied
-(eine) Vorauszahlung leisten (fachspr., Jargon);(Geld) vorstrecken (ugs., Hauptform);verauslagen;(Geld) vorschießen;(Geld) auslegen (für) (ugs.);(jemandem einen) Vorschuss geben (variabel);in Vorlage gehen (fachspr., variabel)
-Kassandrarufer;Warner
-Apokalyptiker;Weltuntergangsprophet;Unheilsprophet;Unheilsverkünder;Untergangsprophet
-nicht hexen können;nicht Supermann (sein) (ugs., fig.);auch nur ein Mensch (sein);nicht alles schaffen (ugs.);Ich kann auch nicht mehr als arbeiten. (ugs., Spruch, floskelhaft);Ich habe auch nur zwei Hände. (ugs., Redensart)
-man darf (hier / da / in diesem Punkt) nicht (so) zimperlich sein;Wo gehobelt wird, (da) fallen (auch) Späne. (Sprichwort)
-vorübergehend umquartieren;räumen;evakuieren (Wohnviertel, Straßenzug)
-freiziehen (Wohnung) (verhüllend);entmieten (Wohnung / Haus) (zynisch);(die) Mieter rausekeln;(die) Mieter vertreiben;(die) Mieter zum Auszug bewegen
-Schönheitsreparaturen (juristisch);Renovierung (Wohnung)
-regelungswütig (fig.);bürokratisch;paragraphenreiterisch;vorschriftengläubig
-Filterzigarette;Aktive (ugs.)
-(sich) (millimeter)genau an die Vorschriften halten;Der Amtsschimmel wiehert. (ugs., Spruch, fig., ironisch);(den) Amtsschimmel reiten (fig., ironisierend);genau nach Vorschrift vorgehen;(sich) streng an die Vorschriften halten
-(... Euro) anzahlen;(eine) Anzahlung leisten
-alkoholisches Heißgetränk;warmes alkoholisches Getränk
-aufwecken;(unbeabsichtigt) wecken
-(jemanden) wachrütteln;aus dem Schlaf reißen;(jemanden) aus dem Bett holen (für / um zu);(jemanden) wachklingeln;(jemanden) wecken;(jemanden) aus seinen Träumen reißen;(jemanden) aus dem Schlaf klingeln;(jemanden) aufwecken;(jemanden) aus dem Schlaf holen (für / um zu);(jemanden) wach machen
-auf sein (ugs.);auf den Beinen (sein);wach (sein) (Hauptform);ausgeschlafen haben
-(noch) nicht aufgestanden sein;(noch) im Bett liegen
-wach sein (Hauptform);nicht mehr schlafen;erwacht sein;die Augen auf haben
-Schöllenenschlucht;Schöllenen
-unwillkürlich lachen müssen;zum Lachen reizen;nicht (länger) an sich halten können (und loslachen);einfach lachen müssen (bei);(sich) ein Lachen nicht verkneifen können;unfreiwillig komisch (sein)
-beischießen;zubuttern (ugs.);als Zuschuss zahlen;(Geld) zuschießen;(Geld) nachschießen (fachspr., juristisch);beisteuern;(noch etwas) drauflegen (ugs.)
-zusammenkratzen (ugs.);zusammenkriegen (ugs.);zusammenbringen;(Geldsumme) aufbringen;einwerben;stemmen (fachspr., Jargon, mediensprachlich);zusammenbekommen;auftreiben (ugs.)
-Erdfalltrichter;Erdabsturz
-Caldera (spanisch);Vulkantrichter
-(sich) auszahlen lassen;(vom Konto) abheben
-alles (Geld) abheben (ugs.);leerräumen (Konto) (ugs., fig.);(sich) alles auszahlen lassen
-(Konto) anlegen;(Konto) eröffnen (Bank);(jemandem ein) Konto einrichten
-(Konto) löschen (lassen);auflösen (Bankkonto)
-nicht existieren;es gibt kein (keine / keinen);nicht vorhanden (sein);(etwas) gibt es nicht;keiner (keine / keins) mehr (an einem bestimmten Ort sein);inexistent (sein) (geh., bildungssprachlich);nicht mehr da sein
-(irgendwo) reintreten (ugs.);(irgendwo) hineintreten;(irgendwo) reinlatschen (ugs.)
-(jemandem) einen Tritt in den Arsch geben (ugs., auch figurativ);(jemandem) einen Tritt in den Hintern geben (ugs.);(jemanden) hinten reintreten (ugs.);(jemandem) in den Arsch treten (ugs., auch figurativ);(jemandem) einen Arschtritt verpassen (ugs.)
-schöner Hintern;Knackarsch (ugs.);attraktives Hinterteil
-(einen) dicken Hintern (haben);(einen) Hintern wie ein Brauereipferd (haben) (ugs., variabel)
-Goblet-Zelle;Becherzelle
-Tarsaldrüse;Meibom-Drüse;Glandula tarsalis (fachspr., lat.)
-reintreten;mit Fußtritten bearbeiten
-Buchstaben tauschen;anagrammieren
-an der Gründung beteiligt;Mitbegründer;Gründungsmitglied
-(be)nennen;(den/die) Namen sagen (ugs.);namentlich (be)nennen;(den/die) Namen nennen (von)
-Jobprofil;Berufsbild
-Also bitte, wie wär's, wenn Sie jetzt ...;Darf ich bitten?;Also was denn jetzt!? (ugs.);Wenn Sie (jetzt bitte) so freundlich wären...
-muskulär (fachspr.);einen Muskel betreffend
-was ist (denn) da los!? (variabel);was geht (denn) da ab? (ugs., salopp, variabel)
-was ist hier los? (Erklärung fordernd);was geht hier vor?
-was liegt (Zeitangabe) an? (ugs., salopp);was steht (dann und dann) auf dem Programm?;was machen wir (+ Zeitangabe)?
-hierher!;herkommen!;bei Fuß! (Hundekommando) (auch figurativ);kommst du wohl her! (ugs.);komm her!
-(jemandem) auf den Magen schlagen (auch figurativ);Magenbeschwerden haben;(sich) den Magen verderben;(sich) den Magen verkorksen (ugs.)
-(etwas) gibt nur unnötig Ärger;(sich) den Ärger ersparen können
-einziger Anbieter;einziger Nachfrager;Inhaber eines Monopols;Monopolist
-Marktbeherrschung;marktbeherrschende Stellung
-gemeinsam;kollektiv
-(jemanden) sehr gut bezahlen;(jemanden) fürstlich entlohnen
-Schulden abbauen;Verbindlichkeiten bedienen;Schulden tilgen;Schulden zurückzahlen;geliehenes Geld zurückzahlen
-gegen den Strom schwimmen (fig.);(sich) nicht der Mehrheit anpassen;anders handeln als die Mehrheit
-...versteher (ugs., ironisch);...flüsterer (ugs., ironisch)
-(jemandes) Sonnenschein (fig.);(jemandes) Ein und Alles (Person);(jemandes) Lieblings...;(jemandes) Liebstes (Person);(jemandem von allen) der Liebste sein (männl.);(jemandes) kleiner Liebling (Hauptform);(das) Licht seiner alten Tage (fig.);(jemandem) das Liebste sein (Person) (veraltend);(jemandes) Augapfel (fig.);(jemandem von allen) die Liebste sein (weibl.)
-kein Mucks;kein Laut;kein Sterbenswörtchen
-auch nicht schlecht!;(eigentlich) keine (so) schlechte Idee
-Gilet;Weste
-Tischkarte;Platzkarte
-betrieblicher Sanitätsdienst;betriebliches Rettungswesen
-Sanitätswachdienst;Ambulanzdienst
-Anzahl;Numerus (fachspr., Hauptform)
-Elsgau (veraltet);Pruntruter Zipfel
-palliative Therapie;Palliativtherapie
-Zeugniskonferenz;Notenkonferenz
-Hofberichterstattung (fig.);Gefälligkeitsjournalismus
-Schneidefähigkeit;Schnitthaltigkeit;Schärfe
-zur Ruhe kommen;(sich) beruhigen;ruhig werden
-Fordern und Fördern;Fördern und Fordern;(mit) Zuckerbrot und Peitsche (fig., negativ)
-Feldversuch;Feldexperiment
-Laborexperiment;Laborversuch
-seinen Gewinn sichern;seine Schäfchen ins Trockene bringen (fig., sprichwörtlich)
-Fagus sylvatica (fachspr., botanisch);Rot-Buche (fachspr., botanisch);Buche (ugs.);Rotbuche
-das Pferd beim Schwanz aufzäumen (sprichwörtlich);(etwas) (völlig) verkehrt anfangen;das Pferd von hinten aufzäumen (sprichwörtlich)
-Scharfblick beweisen;(eine) gute Beobachtungsgabe haben
-Tunika;Longshirt;Hängerchen
-fünfundvierzig Minuten;45 Minuten;(eine) Dreiviertelstunde
-dreißig Minuten;(eine) halbe Stunde;30 Minuten
-90 Minuten;anderthalb Stunden;neunzig Minuten;eineinhalb Stunden
-eineinviertel Stunden;eine Stunde und fünfzehn Minuten;1 Std. 15 Min.;75 Minuten
-60 Minuten;(eine) Stunde
-verzwickte Situation;Zielkonflikt;Zwickmühle;Dilemma
-schwierige Situation;zwischen Szylla und Charybdis;Wahl zwischen Pest und Cholera;missliche Lage;Dilemma
-altes Fahrzeug;Autoklassiker;Oldtimer (Scheinanglizismus, Hauptform);Schnauferl (ugs., scherzhaft, veraltend);Auto-Veteran
-Vorteilsnahme;Vorteilsannahme
-Indisches Panzernashorn;Rhinoceros unicornis (fachspr., lat.);Panzernashorn (Hauptform);Indisches Nashorn
-aufgeständert;auf Stelzen stehend;auf Pfählen stehend
-auf Stelzen bauen;auf Pfeiler setzen;auf Pfählen errichten;aufständern (Hauptform)
-nicht einheimisch;importiert;eingeführt
-hinten und vorne nicht reichen;zum Sterben zu viel und zum Leben zu wenig (sein)
-in die falschen Hände geraten;der Falsche bekommt (etwas);(etwas) dem Falschen geben;in falsche Hände geraten
-(für jemanden) drin sein (ugs.);(für jemanden) zu holen sein
-Schneidekennlinie;Schneidkennlinie
-Entzerrvorverstärker;Entzerrervorverstärker
-Vorstufe;Vorverstärker
-TeleKarte;Buchungskarte
-Telefonkarte;Telefonwertkarte;Taxcard
-cramersche Regel;Determinantenmethode
-Einzelschrittverfahren;Gauß-Seidel-Verfahren
-Gesamtschrittverfahren;Jacobi-Verfahren
-Callcenter (Hauptform);Anrufverwaltung;Büroservice;Anruf-Service;Telefonzentrale
-Vermittlungsstelle (Handvermittlung) (historisch);Fernsprechamt (historisch);Telefonzentrale (historisch)
-kompromittierbar (sein);(sich) ausliefern (fig.);(etwas) in der Hand haben (gegen) (fig.);(jemanden) in der Hand haben (fig.);angreifbar (sein) (fig.)
-transponierte Matrix;gestürzte Matrix;gespiegelte Matrix
-Transponierung;Transposition;Stürzen
-auf eine andere Tonart umschreiben (ugs.);transponieren (fachspr., Hauptform);in einer anderen Tonart spielen;in eine andere Tonart versetzen
-Viehtrift;Trift
-Bot (Hauptform);Internet Bot (engl.)
-beabsichtigt (Hauptform);soll so sein (ugs.);(so) gemeint;(so) gewollt;intendiert (geh.);(so) gedacht;Absicht (sein)
-heruntersammeln;weglesen;absuchen;ablesen;herunterpicken;absammeln
-zusammenlesen;zusammenklauben;zusammensuchen
-einsammeln;(jemandem) wegnehmen;einkassieren;kassieren
-Lippenspalte;Hasenscharte (abwertend)
-Gaumenspalte;Wolfsrachen (abwertend)
-kenn ick, weeß ick, war ick schon (ugs., Spruch, berlinerisch, variabel);(sich) nichts sagen lassen;alles besser wissen (wollen) (fig.);Da will (aber) einer ganz schlau sein! (ugs., ironisch, kommentierend, variabel)
-Popcorn;Puffmais (DDR, veraltend)
-per Mehrheitsbeschluss durchsetzen;als Mehrheit bestimmen;majorisieren (geh.)
-Schraffe;Bergstrich;Bergschraffe
-Lithographenschiefer;Solnhofener Plattenkalk;Solnhofener Kalkstein
-Termingeschäft;Zeitgeschäft
-Börsentag;Handelstag
-Sexualpartner;Intimpartner;Geschlechtspartner
-1-a-Lage;Toplage;Eins-a-Lage;erstklassige Lage
-unerwartete Wendung;Twist
-zentrale Rolle;wichtige Rolle
-einen heben (ugs.);(sich) (die) Kehle ölen (ugs.);Alkohol trinken;(sich) (die) Kehle anfeuchten (ugs.);(eine Flasche Wein o.ä.) verpitschen (ugs., ruhrdt.);(sich) (einen) hinter die Binde kippen (ugs.);(sich) einen (...) genehmigen
-(einen) Vertrag unterschreiben;(einen) Vertrag besiegeln
-von Müll übersät;voller Müll;zugemüllt (ugs.);vermüllt
-Wenn man vom Teufel spricht ... (Spruch, Hauptform, scherzhaft-ironisch);Wenn man den Esel nennt, kommt er gerennt. (sprichwörtlich);Wenn man vom Teufel spricht, kommt er gerannt.
-eine Evolution durchlaufen;evolvieren
-Bogen;Pfeilbogen
-Heidewitzka!;wow!
-auch wenn ..., so ... (doch) ...;es trifft zu, dass ..., nur ...;wie ... auch immer ..., (dennoch / doch) ...;(es) mag sein, dass ... jedoch ...;mag es auch noch so ..., (so ... doch ...)
-viele Menschenleben kosten;(einen) hohen Blutzoll fordern;(einen) hohen Blutzoll zahlen (fig.)
-Gemeine Alraune;Alraunwurzel
-Decke (fachspr., Jargon);Buchdecke (fachspr.);Buchdeckel;Bucheinband;Einbanddecke (fachspr.);Einband (Hauptform)
-Einfinger-Adlersuchsystem (ugs.);Zweifinger-Adlersuchsystem (ugs.);Adlersuchsystem (ugs.)
-(die) Kontrolle übernehmen;(das) Steuer übernehmen (fig.);(das) Ruder übernehmen (fig.)
-Columbit;Columbeisen;Niobit
-Epileptiker (sein);an Epilepsie leiden(d)
-(jemandem) in die Nase steigen;riechen;(einen) Geruch wahrnehmen
-(einen) Geruch haben;riechen nach
-(irgendwie) riechen;(einen Geruch) ausdünsten;(einen Geruch) verströmen
-(sich) in schwierigem Fahrwasser befinden (fig.);in Schwierigkeiten (stecken);in einer schwierigen Situation stecken;in Schwierigkeiten (sein);in einer schwierigen Situation sein
-in großen Nöten (sein);Ärger haben;in der Patsche sitzen;Trouble haben;(sich) in einer misslichen Lage befinden;in Bedrängnis (sein);in der Bredouille (sein);in der Tinte sitzen;in Verdrückung (sein);in Schwierigkeiten stecken (Hauptform);in der Klemme sitzen;in der Patsche (sein);in einer verzwickten Situation sein;in einer verfahrenen Situation sein;in Schwulibus (sein) (ugs., scherzhaft-ironisch);in der Klemme stecken (ugs.);in Schwierigkeiten (sein) (Hauptform)
-in eine missliche Lage geraten (geh., variabel);in Nöte geraten;in die Bredouille kommen (variabel);in Verdrückung geraten (variabel);in Schwierigkeiten kommen;in Bedrängnis geraten (mit) (variabel);Probleme kriegen (ugs., salopp);in Schwulitäten kommen (selten, variabel);Ärger kriegen (ugs.);in Schwierigkeiten geraten;Probleme bekommen (ugs.);in einen Schlamassel geraten (ugs.);in Schwulibus geraten (ugs., scherzhaft);unter Druck geraten;Trouble bekommen (ugs., variabel, veraltet)
-(jemanden) in Nöte bringen (mit);(jemanden) in Erklärungsnot bringen;(jemanden) in Verlegenheit(en) bringen;(jemanden) in eine missliche Lage bringen;(jemandem) Ärger bescheren (variabel);(jemanden) in Verdrückung bringen;(jemanden) in Schwulibus bringen (geh., selten);(jemanden) in Schwierigkeiten bringen (Subjekt = Sache) (Hauptform);(jemanden) in die Bredouille bringen;(jemanden) in Bedrängnis bringen
-Unterernährung;Mangelernährung
-Selbstzensur;(die) Schere im Kopf (haben) (fig.)
-keine Peinlichkeit auslassen;(sich) für nichts zu schade sein (ugs.);sich blamieren, wo man kann;kein Fettnäpfchen auslassen
-mit einem Veröffentlichungsverbot belegen;(jemandem) einen Maulkorb verpassen (fig.);nicht(s) mehr veröffentlichen dürfen;(jemandem) einen Maulkorb umhängen (fig.);(einen) Maulkorb umgehängt bekommen
-Staatsgebiet;Staatsterritorium
-Simplonstrecke;Simplonlinie
-mit schwarzen Haaren;schwarzhaarig
-Graukopf;Grauhaariger;(eine) Grauhaarige
-(eine) Weißhaarige;(ein) Weißhaariger;mit weißen Haaren
-Juchert;Morgen;Joch
-unter Eid;mit einem Eid;eidlich gebunden;eidlich
-(Zeitdauer) und die Sache ist erledigt;dauert (nur);(eine) Sache von (+ Zeitdauer)
-(nur ...) Thema durch (ugs., Spruch, salopp);dauert (nur);(Zeitdauer) und die Sache ist erledigt (ugs.);(eine) Sache von (+ Zeitdauer) (ugs.)
-(ist) schon passiert (ugs.);schon erledigt (ugs.)
-zutreffend;geziemend;gebührend;angemessen;gehörig;ordnungsgemäß;ordentlich;regelkonform
-Stellenbewertung;Arbeitsbewertung;Job Evaluation;Rollenbewertung;Job Grading;Funktionsbewertung;Positionsbewertung
-kumpelig (ugs.);als wären sie Freunde;(sich) anbiedern(d);schulterklopfend;kumpelhaft;plumpvertraulich;wie unter Freunden
-Fachschule;Fachakademie
-(mit dem Finger) auf andere zeigen (ugs.);(die) Fehler bei (den) anderen suchen (variabel);den Balken im eigenen Auge nicht sehen (, aber den Splitter im fremden) (Bibelzitat) (geh., sprichwörtlich)
-Pseudoentfernung;Pseudostrecke
-Vaquita;Golftümmler;Kalifornischer Schweinwal
-das werd(e) ich dir grad(e) auf die Nase binden! (ugs.);das wüsstest du wohl gerne! (ugs.)
-halt (du) dich da raus (ugs.);misch (du) dich nicht ein (ugs.)
-versteht sich (nachgestellt) (ugs.);wie könnte es anders sein (Einschub);natürlich (Hauptform);logischerweise;natürlicherweise;selbstredend (geh.);selbstverständlich
-(jemandem) in die Wiege gelegt;natürlich angelegt;gottgegeben;naturgegeben (Hauptform);bringt die Natur mit sich
-von unten her gesehen;(aus der) Froschperspektive
-zur Tagesordnung übergehen (fig.);gleichgültig bleiben;mit den Schultern zucken (fig.)
-(das) Gesicht wahren;(die) Würde wahren
-Hofberichterstattung (fig.);Verlautbarungsjournalismus
-(mal) Abstand gewinnen;mal rauskommen (ugs.);die Seele baumeln lassen;(seinen) Akku (wieder) aufladen (fig.);Urlaub vom Alltag machen;den Alltag hinter sich lassen
-Ergebenheitsadresse;Huldigungsschreiben
-Evolutionspsychologie;evolutionäre Psychologie
-(innerlich) Abstand gewinnen (fig.);loslassen (fig.);(sich innerlich) verabschieden (von) (fig.)
-Zypernkonflikt;Zypernfrage
-(sich) eine Auszeit nehmen;(für) längere Zeit aussetzen;(für) (länger) Pause machen (ugs.);(für/eine) längere Zeit pausieren;(sich) für (+ Zeitspanne) ausklinken
-wehrhaft (geh., auch figurativ);nicht leicht zu bezwingen;trutzig (geh.);befestigt;verteidigungsbereit
-alter Wein in neuen Schläuchen (fig., sprichwörtlich);alte Idee, neue verpackt
-Kampfmittelbeseitigungsdienst;Kampfmittelräumdienst;Munitionsbergungsdienst
-Delaborierung;Bombenentschärfung
-Ablaufrücken;Ablaufberg;Ablaufhügel;Rollberg (österr.);Rangierberg;Eselsrücken
-Gleisfeld;Gleisharfe;Gleisgruppe
-Einlassbeginn;Türöffnung (schweiz.)
-(sich) unbeliebt machen (bei);nicht mehr gut zu sprechen sein (auf) (ugs.);(jemandes) Gunst verlieren;(es sich) verscherzen (mit);in Ungnade fallen (bei);(es sich) verderben (mit) (Hauptform);(sich) jemandes Gunst verscherzen
-Befehlszeilenergänzung;Tab-Vervollständigung
-Stielwarze;Fibrom
-Exkoriation (fachspr., lat.);(tiefgehende) Hautabschürfung
-ausscheidend;exkretorisch (fachspr., lat.);absondernd
-Unterhaltung für die Massen;Brot und Spiele;Panem et circenses (lat.)
-keine Nerven zeigen (fig.);(sich) nicht nervös machen lassen;nervenstark (sein);Nerven wie Drahtseile (haben);starke Nerven (haben)
-Panzerigel (österr.);Stahlspinne (schweiz.);Tschechenigel
-Regierungsbündnis aus Sozialdemokraten, Liberalen und (den) Grünen (variabel);Ampelkoalition (fig.);Koalition aus SPD, FDP und Grünen (variabel);Ampel (ugs., fig.)
-kein Pardon kennen;unnachgiebig bleiben;nicht mit sich reden lassen;zu keinem Kompromiss bereit sein;(sich) nicht abbringen lassen (von)
-Freiwilligendienst;Freiwilligenarbeit (schweiz.);Arbeitsdienst
-unwiederbringlich (vergangen);ein für alle mal vorbei;nicht wiederholbar;war einmal und ist nicht mehr (ugs.);aus und vorbei
-Verschlussstopfen;Blindverschluss;Blindstopfen;Verschlusskappe;Abdeckkappe
-Hutmutter;Kappenmutter
-Verschlussschraube;Blindschraube;Endstopfen
-Zulauf(schlauch);Zuleitung (Wasch-/Spülmaschine);Spülmaschinenschlauch;Waschmaschinenschlauch
-eindeutig;unzweideutig;keinen Interpretationsspielraum lassen(d)
-Polenschwärmerei;Polenbegeisterung
-nicht sagen, was Sache ist (ugs.);im Ungefähren bleiben;(vage) Andeutungen machen;(sich) vage ausdrücken;Schleiertänze (aufführen) (fig.);(einen) Schleiertanz tanzen (fig.);in wolkigen Formulierungen (variabel)
-Scheindebatte;Geisterdebatte (fig.);Scheingefecht (fig.);Gespensterdebatte (fig.);Phantomdiskussion (abwertend, fig.)
-nicht im Dienst (sein);frei haben (ugs., Hauptform);einen Tag frei haben;(heute) nicht zu arbeiten brauchen;seinen freien Tag haben (männl.);ihren freien Tag haben (weibl.);(heute) nicht arbeiten müssen
-zu Hause bleiben können;nicht zur Arbeit kommen müssen (Hauptform);nicht kommen müssen;(heute) nicht gebraucht werden;nicht (zu) kommen brauchen
-(einen / sich den / am) Brückentag frei nehmen;(ein) verlängertes Wochenende (haben);(einen) Kurzurlaub (machen)
-Entschuldigung, ....;Sie werden erlauben... (+ Geste) (geh.);Pardon ...;ich darf doch mal (+ Geste)
-da ist nichts mehr zu machen;hier gibt es nichts mehr zu tun;jede Hilfe kommt zu spät (für);man kann nicht mehr helfen;man kann hier nichts mehr tun;da ist nichts mehr zu retten
-(etwas) nicht auf sich beruhen lassen;herauszubekommen versuchen;(einer Sache) nachgehen (Hauptform);(die Hintergründe) zu ermitteln versuchen;(etwas) weiter verfolgen;aufzuklären versuchen;hinterherrecherchieren
-hau weg den Scheiß! (derb);runter damit!;zieh weg die Pfütze! (ugs.);auf ex! (Hauptform)
-zum Du übergehen;(jemandem / sich) das Du anbieten
-Brüderschaft trinken;(mit jemandem) Schmollis trinken (fachspr., Jargon, burschenschaftlich);schmollieren (fachspr., Jargon, burschenschaftlich)
-Auf die Brüderschaft!;Auf unsere Brüderschaft!;Schmollis! (fachspr., Jargon, burschenschaftlich)
-feierlich das Glas erheben;(einen) Salamander reiben
-(militant auftretender) Fußballverrückter;Ultra (Hauptform);(fanatischer) Fußballanhänger
-Fankult;Fankultur
-nicht klar abzugrenzen (sein);nicht klar abgrenzbar (sein);die Übergänge sind fließend (floskelhaft);ineinander übergehen
-Fanblock;Fankurve
-Präsidentenmaschine;Air Force One (engl.)
-lässig (Hauptform);nonchalant (geh., franz.);(ganz) selbstverständlich;ganz natürlich;in aller Selbstverständlichkeit;unaufgeregt;in aller Gelassenheit;gelassen;cool (ugs., engl.);unangestrengt (geh.);locker
-wie eine Maschine;affektlos (geh.);empathielos;ohne innere Beteiligung;ohne Gefühlsregung;gefühlsamputiert (derb, abwertend, fig.);wie ein Roboter;emotionslos;ohne Anteilnahme;leidenschaftslos;(innerlich) unbeteiligt
-ruckartig;roboterartig;eckig (Bewegungen);roboterhaft
-Keine Experimente!;Da weiß man, was man hat. (sprichwörtlich)
-Troubleshooting (engl.);Fehlersuche (und -behebung)
-Nati (ugs., schweiz.);Schweizer Fußballnationalmannschaft
-(großes) Ansehen erlangen (mit);(großes) Ansehen gewinnen;(sich) einen Namen machen (mit / durch) (Hauptform);(große) Bekanntheit erlangen;bekannt werden (mit);(sich) (großes) Ansehen erwerben (mit)
-Krankheitsanzeichen;Prodromalsymptom (griechisch);Frühsymptom;Krankheitsvorzeichen;Prodrom (fachspr., griechisch)
-(jemandem) viel Arbeit machen (variabel);kaum Ruhe haben (ugs.);nie Ruhe haben (ugs.);keine ruhige Minute (mehr) haben (ugs.);immer (irgend)etwas zu tun haben (mit / durch);(jemandem) keine Atempause gönnen (fig.);(jemanden) auf Trab halten (fig.);(jemanden) in Atem halten
-langärm(e)lig;mit langem Arm;Langarm...
-Diamond-Blackfan-Anämie;Diamond-Blackfan-Syndrom;chronische kongenitale hypoplastische Anämie
-Glucose-Aminosäuren-Diabetes;Debré-de-Toni-Fanconi-Syndrom;De-Toni-Fanconi-Komplex
-Postaxiale Polydaktylie Typ 2;Dreigliedriger Daumen-Polysyndaktylie-Syndrom
-frech gelogen;(eine) dreiste Lüge (sein);von a bis Z gelogen;erstunken und erlogen;glatt gelogen;dreist gelogen
-(so) lügen, wie andere Leute atmen (selten);mit jedem Atemzug lügen (fig.);(jemand) lügt schneller, als ein Pferd laufen kann (ugs.);(ein) notorischer Lügner (sein);lügen ohne rot zu werden;mit jedem Wort lügen (fig.);(jemand) lügt, wenn er den Mund aufmacht;andauernd lügen (ugs., variabel)
-(das) Sterben;(der) Sterbeprozess
-(sich) selbst wieder spüren (floskelhaft);in Kontakt zu sich selber (kommen) (variabel)
-(die Leute) kommen nicht mehr (ugs.);(jemandem) gehen die Leute von der Fahne (fig.);(jemandem) laufen die Leute davon;(die) Kirche leerpredigen (auch figurativ)
-(etwas ist) alles eins;(alles) eine Wichse (derb);(alles) eine Soße (ugs.);alles der gleiche Scheiß (derb);(etwas ist) alles dasselbe;alles derselbe Scheiß (derb)
-beides gleich beschissen (derb);wie die Wahl zwischen Pest und Cholera;beides gleich(ermaßen) schlecht;(ob) so kaputt oder totgekitzelt ... (ugs., fig.)
-letzten Endes egal;im Endergebnis dasselbe;(ob) so kaputt oder totgekitzelt ... (ugs.)
-Hagerkeit;Magerkeit;Zierlichkeit;Schlankheit;Grazilität;Zartheit
-(jemanden) finanziell austrocknen (fig.);(jemandem) den Geldhahn abdrehen (fig.);Zahlungen (an jemanden) einstellen;(jemandem) den Geldhahn zudrehen (fig.);(jemandem) kein Geld mehr geben (Hauptform)
-(jemandem) die Hucke volllügen (ugs., regional);lügen wie gedruckt;lügen, dass sich die Balken biegen;das Blaue vom Himmel herunterlügen;Märchen erzählen
-von hohem Rang;ranghoch;oben in der Hierarchie
-auf der Anklagebank sitzen;angeklagt sein;(sich) vor Gericht verantworten müssen
-deklaratives Wissen;Sachwissen;Faktenwissen
-aufessen;seinen Teller leeren;seinen Teller leer essen
-(jemanden) anschwindeln;(jemandem) Lügen auftischen (variabel);(jemanden) beschwindeln;(jemandem) einen vom Pferd erzählen (ugs.);(jemandem) eine Lüge auftischen (variabel);(jemanden) betrügen;(jemandem) nicht die Wahrheit sagen;(jemanden) beschummeln (ugs.);(jemanden) belügen;(jemanden) anschummeln (ugs.);(jemandem) einen Bären aufbinden (wollen);(jemandem etwas) weismachen wollen;(jemanden) anlügen;(jemandem etwas) auftischen (wollen) (fig.);(jemanden) verschaukeln (ugs.);(jemanden) verkohlen (ugs.);(jemanden) anmogeln (ugs.);(jemandem etwas) vorlügen;(jemanden) bemogeln (ugs.);(jemandem etwas) weiszumachen versuchen
-Lügen haben kurze Beine. (Sprichwort);Mit Lügen kommt man nicht weit. (ugs.)
-beschuldigt werden;(jemandem) wird (etwas) vorgeworfen;(einer Sache) bezichtigt werden;(jemandem) wird (etwas) zur Last gelegt
-in der Hierarchie ganz oben;ranghöchst(er);an der Spitze
-Handdruckspritze;Feuerspritze
-Wasserschild;Hydroschild
-Hydraulis;Wasserorgel;Hydraulos
-Saugkopf;Saugkorb
-übertriebener Eifer;Biereifer (ugs.)
-eingezogen werden;zum Militärdienst verpflichtet werden
-ergrauen;grau werden
-bekömmlich;gut verträglich
-Eurocent;Cent
-Formelzeichen;Größensymbol
-Querkopf;Querdenker;eigenwilliger Kopf;kritischer Geist
-Gebrauchshund;Arbeitshund
-Parasol;Schirmpilz;Macrolepiota procera;Gemeiner Riesenschirmling;Riesenschirmpilz
-(sich) wieder eindecken;Nachschub holen;(die) Vorräte wieder auffüllen
-es gibt zu wenig zu tun;schlecht laufen (es);schlecht gehen (Geschäfte);es ist kein Geld zu verdienen;(es herrscht) Flaute (am ...markt);es kommt kein Geld rein (ugs.);es gibt nichts zu tun;es kommt zu wenig Geld rein (variabel)
-in kleinem Kreis;in einer kleinen Gruppe
-(sich) zusammenschließen (mit);(sich) verbünden (mit);paktieren (mit);(sich) zusammentun (mit) (ugs.)
-(sich) auf die andere Seite schlagen;(die) Seite(n) wechseln;überlaufen (zu);(eine) Kehrtwende machen (fig.)
-(sich) auf jemandes Seite schlagen;gemeinsame Sache machen (mit)
-(ein) doppeltes Spiel spielen;auch mit der Gegenseite kooperieren
-(jemanden) zu einer Entscheidung zwingen;(jemanden) dazu bringen, Farbe zu bekennen;(jemanden) dazu bringen, (eindeutig) Position zu beziehen (variabel)
-Absolutismus;absolute Monarchie
-zum letzten Mal auf der Bühne stehen;(seine) Abschiedsvorstellung geben;(der) letzte Vorhang fällt (für)
-Konzipient;Konzipist
-Referendar;Konzipient (österr.);Rechtsanwaltsanwärter;Substitut (schweiz.)
-Halitit;Steinsalz;Salzgestein
-Creole;Kreole;kreisringförmiger Ohrring
-Detailversessenheit (negativ);Liebe zum Detail
-Zwischenfazit;Zwischenbilanz
-bis zum Tod;bis zum Ende ihrer Tage (weibl.);bis zum Ende seiner Tage (männl.)
-heilige Kuh (fig.);besonders geschützt;unantastbar
-Trikolore;Flagge Frankreichs
-(sich) eine Abfuhr holen;(sich) einen Korb holen;einen Korb bekommen;zurückgewiesen werden (beim Flirt etc.)
-zu nachtschlafender Zeit;spät nachts;tief in der Nacht;in tiefer Nacht;mitten in der Nacht
-(jemandem) nichts gönnen;(jemandem) nicht das Schwarze unter den Fingernägeln gönnen (sprichwörtlich);(jemandem) nicht das Schwarze unter den Nägeln gönnen (sprichwörtlich);(jemandem) nicht das Schwarze unter dem Fingernagel gönnen (sprichwörtlich);(jemandem) das Salz in der Suppe nicht gönnen (sprichwörtlich);(jemandem) nicht die Butter auf dem Brot gönnen (sprichwörtlich)
-(jemandem) einen Wunsch abschlagen;(jemandem) einen Wunsch nicht erfüllen;(jemandem etwas) versagen (geh.)
-Dinge vergleichen, die nicht verglichen werden können;einen unfairen Vergleich machen;Äpfel mit Birnen vergleichen
-aus dem Leben gerissen werden;plötzlich und unerwartet sterben
-auf die gleiche Weise;ex aequo (lat.);in gleicher Weise
-beim besten Willen nicht wissen;(jemandes) Hauptsorge (ugs.);(jemandes) größtes Problem (sein);noch keine Lösung (gefunden) haben (für) (ugs.)
-jetzt die Woche (ugs.);im Laufe dieser Woche;diese Woche;die Woche (ugs.);in dieser Woche;im Lauf(e) der Woche
-Hilfe in der Not leisten;Feuerwehr spielen (bei)
-Zeit haben (für);für jemanden da sein;(sich jemandes) annehmen;(sich) Zeit für jemanden nehmen;(sich) jemandes Sorgen annehmen
-Rad fahren (fig.);mit den Wölfen heulen (fig.)
-unverletzt bleiben;mit dem Schrecken davonkommen
-weltverloren;wirklichkeitsfern;der Welt entrückt
-Lüsterklemme;Lusterklemme (österr.);Blockklemme;Reihenklemme;Klemmstein (bayr.);Leuchterklemme (schweiz.)
-Klemmenleiste;Klemmleiste
-(jemandem) (eine) Chance geben;Brücken bauen (fig.)
-gelernt haben;wissen;intus haben;parat haben
-scheibchenweise (ugs.);häppchenweise;tropfenweise (auch figurativ);(in) Salamitaktik (fig.);in kleinen Häppchen;nicht alle(s) auf einmal;tröpfchenweise (auch figurativ);kleckerweise (ugs., negativ);hier ein bisschen, da ein bisschen (ugs.)
-Eizellspende;allogene Eizelltransplantation
-Embryonentransfer;Embryotransfer
-Lactotropin;Prolaktin;Laktotropin;laktotropes Hormon
-Buchgroßhandel;Barsortiment(er) (fachspr.);Verlagsauslieferung(en) (fachspr.);Zwischenbuchhandel
-Buchhandel (Hauptform);Buchgeschäft
-Fahrgestellnummer (ugs.);Fahrzeug-Identifizierungsnummer;FIN (Abkürzung)
-Verdunkelung;Verfinsterung;Abdunklung;Verdunklung;Abdunklung
-(mit) Grabesstimme;(mit einer) Stimme wie aus der Gruft
-dafür sprechen;(ein) Argument dafür sein
-Wahl zur Miss (...);Schönheitswettbewerb;Misswahl
-Reform des Deutschen Bundes;Bundesreform
-Sachlichkeit;Nüchternheit;Unsentimentalität;trockene Art
-(die) Mühe auf sich nehmen (zu);(sich etwas) antun (ugs., scherzhaft-ironisch);(es) auf sich nehmen (zu);(den) Aufwand nicht scheuen (zu)
-Marconi-Antenne;Monopolantenne;Groundplane-Antenne
-Radarpatent;Radarschifferzeugnis;Radarschifferpatent
-Vorflügel;Slat (engl.)
-Canard (fachspr., franz.);Entenflügel
-Daumenfittich;Alula;Eckfittich;Afterschwinge
-Ornithopter;Schwingenflügler;Schwingflüger;Schwingenflugzeug
-Doku-Drama;Dokudrama
-auf einer wahren Geschichte basieren;wirklich passiert sein;auf einer wahren Begebenheit beruhen
-durchaus;zugegebenermaßen (geh.);freilich;zugestandenermaßen (geh.)
-Erstausstrahlung;zum ersten Mal gesendet (werden)
-dermaleinst (geh., altertümelnd);dereinst (geh.);irgendwann mal (ugs.);eines schönen Tages (Zukunft) (ugs.);irgendwann einmal;eines fernen Tages;irgendwann;irgendwann später (ugs.)
-(die) mündliche Prüfung;das Mündliche (ugs.);(der) mündliche Prüfungsteil
-Meißelkreuz;Meißelzeichen
-Exzenter;Exzentrum
-Kegelradgetriebe;Winkelgetriebe
-nicht fortgeführt werden;nicht weitergeführt werden;auslaufen;nicht verlängert werden (Vertrag);nicht fortgesetzt werden;enden
-seid ihr jetzt alle (...)? (ugs.);nur von (...) umgeben sein;hier sind (doch) alle (...)
-nicht alles haben (können) (ugs.);(sich) (mit weniger) bescheiden;(jemand anderem) den Vortritt lassen (fig.);nicht alles bekommen (können);zurückstecken (müssen);Verzicht üben (geh.);auf manches verzichten (müssen);verzichten (müssen)
-sonst ist er doch auch (...);(jemandem) nicht ähnlich sehen;sonst ist sie doch auch (...);(etwas) kennt man sonst gar nicht (von)
-H-Kennzeichen;Oldtimer-Kennzeichen
-gut ausgestattet;gut sortiert (fig.);nichts Wesentliches fehlt
-Plan haben (Person) (ugs.);gut sortiert sein (Person) (ugs., fig.);Struktur haben (Person)
-es geht nur eins von beiden (ugs.);nicht auf zwei Hochzeiten (gleichzeitig) tanzen können (ugs.);nicht mit einem Hintern auf zwei Hochzeiten tanzen können (schwäbisch);sich nicht zwei Vorteile gleichzeitig sichern können
-Crowdworking;Gig-Work;Plattformarbeit
-nicht anders kennen;von Kindesbeinen an gewohnt sein;(mit etwas) groß geworden sein
-täglich aktualisiert;tagesaktuell
-Bergsport;Alpinsport
-Hemdbrust;Vorhemd
-in Klump schlagen;zerstören;zu Klump schlagen;zu Klump treten
-industrielle Landwirtschaft;maschinengerechte Landwirtschaft;Agrarwirtschaft
-dopen;Doping betreiben
-Wille zum Konflikt;Streitbarkeit
-Entflammbarkeit;Entzündbarkeit
-Fanggebiet;Fanggrund;Fischgrund
-gestimmt (geh.);aufgelegt
-feuerrot;glutrot
-Kollekte;Spendensammlung (in der Kirche)
-Menschengeschlecht (geh.);Menschheit;Erdbevölkerung
-Modegeschäft;Bekleidungsgeschäft
-Münzfälschung;Falschmünzerei
-in die Sauna gehen;saunieren;saunen (selten)
-Unterhaltungsbranche;Showbusiness
-(sich) anschmiegen;(sich) ankuscheln
-überseeisch;in Übersee
-transatlantisch;auf der anderen Seite des Atlantik
-Kokosinseln;Keelinginseln
-Studium absolvieren;Studium abschließen
-Nördlicher Zwergwal;Minkwal;Balaenoptera acutorostrata (fachspr., griechisch, lat.);Minkewal;Zwergwal
-Balaenoptera bonaerensis (fachspr., griechisch, lat.);Südlicher Zwergwal
-Bartenwale;Mysticeti (griechisch, lat.)
-modeln;als Model arbeiten
-(diese) Straße verlassen;(rechts / links) einbiegen;die Fahrtrichtung ändern;abbiegen
-Verteidigungsbudget;Verteidigungshaushalt;Verteidigungsetat
-Kaiser-Botschaft;Kaiserliche Sozialbotschaft;Kaiserliche Botschaft
-Schlussakkord;abschließender Akkord
-Pfarrkirche;Parochialkirche
-Profilkirche;Themenkirche
-Lokalie;Filialkirche;Succursalkirche
-Kaustik;Brennlinie;Brennfläche
-Überstrich;Oberstrich (ugs.)
-rationieren;(in begrenzten Portionen) zuteilen
-Wiedergutmachung;Sühne (geh.)
-Badetuch;Badehandtuch
-Kardinalkämmerer;Camerlengo (ital.);Camerarius Camerae Apostolicae (fachspr., lat.)
-hängig;abfallend (z. B. Grundstück)
-vom (rechten) Weg abkommen;abirren
-Unternehmerrisiko;unternehmerisches Risiko
-Pauschalaussage;Totalaussage
-Curry;Currypulver
-undankbar (sein) (Hauptform);(jemandem) Dank schuldig bleiben
-Innkreisbahn;Innviertelbahn
-Kammerherr;Kämmerer (bayr., österr.)
-Salzburger Exulanten;Salzburger Emigranten
-Übertragung;Weitergabe
-Inguschien;Inguschetien
-Hochsee;Hohe See;Blauwasser
-Wildes Silberblatt;Ausdauerndes Silberblatt;Mondviole
-Acker-Schmalwand;Gänserauke;Schotenkresse
-Acker-Hellerkraut;Ackertäschel;Acker-Täschelkraut;Acker-Pfennigkraut
-Nougatcreme;Nuss-Nougat-Creme
-mikrowellengeeignet;mikrowellenfest
-spülmaschinenfest;spülmaschinengeeignet
-Lastschrift;Bankeinzug
-Warenbegleitpapier;Warenbegleitschein;Begleitpapier;Lieferschein;Frachtbrief;Warenbegleitdokument
-Zibinsgebirge;Zibingebirge
-Bogenfelsen;Felsentor;Brandungstor
-wirtschaftlicher Liberalismus;Wirtschaftsliberalismus
-Gewerbefreiheit;freies Unternehmertum
-Afrikasiedlung;Kolonialsiedlung
-Münzrohling;Schrötling (veraltet);Ronde
-Quellfassung;Brunnenstube
-Eifelwasserleitung;Römische Wasserleitung nach Köln;Römerkanal
-1.000.000.000.000;1000 Milliarden;Billion;tausend Milliarden
-8 Bit;Byte
-Aluminiumdose;Getränkedose;Blechdose;Aludose
-spruchreif;fertig
-Echolalie (fachspr.);Wortwiederholung;Nachplappern (ugs.)
-Spätlatein;Spätlateinisch
-Punkt auf Mitte;Mittepunkt;Hochpunkt;Mittelpunkt
-MdA (Abkürzung);Mitglied des Abgeordnetenhauses
-Mitglied der Bremischen Bürgerschaft;MdBB (Abkürzung)
-gemeinsam;nebeneinander;unter einem Dach
-Bratpfanne;Pfanne
-Schmerzensmutter;Mater Dolorosa (lat.)
-Kaki;Khaki
-Parodontose;Parodontitis;Paradentose (veraltet)
-probieren geht über studieren;Probieren geht über Studieren;Versuch macht klug
-additive Farbmischung;additive Farbsynthese;physiologische Farbmischung
-subtraktive Farbsynthese;physikalische Farbmischung;subtraktive Farbmischung
-Allioli (katalanisch);Aioli (katalanisch);Knoblauchmayonnaise
-Büsinger Krieg;Büsinger-Handel;Büsinger-Händel
-Lymphknoten;Lymphdrüse
-Holzmedaille (scherzhaft);4. Platz
-Absender;Versender
-Ladung verlieren (Akku etc.);(sich) entladen
-Pilotstollen;Richtstollen
-Zugangsstollen;Fensterstollen
-Speicherkartenleser;Speicherkartenlesegerät;Kartenleser (Kurzform)
-Rombergsche Zeichen;Rombergsche Phänomen
-Prosopodysmorphie;Halbseitiger Gesichtsschwund;Parry-Romberg-Syndrom;Neurotische Gesichtsatrophie;Säbelhieb Allahs
-US-Südstaaten;Dixie;Dixieland
-Redneck (ugs., engl.);US-Südstaatler
-Quecksilber-Konvention;Minamata-Übereinkommen
-Post-Zoster-Neuralgie;postzosterische Neuralgie;postherpetische Neuralgie
-Varicella-Zoster-Virus;Varizella-Zoster-Virus;Humanes Herpes-Virus-3
-freiberufliche Tätigkeit;Freiberuf;freier Beruf
-Militärgeologie;Wehrgeologie
-Marktfähigkeit;Marktgängigkeit
-Notfunk;Katastrophenfunk
-Austauschjude;Vorzugsjude
-Okkupationsmacht;Besatzungsmacht;(die) Besatzer
-vom Anwalt;rechtsfreundlich (österr.);rechtsanwaltlich;anwaltlich
-verbaler Schlagabtausch;Wortgeplänkel;Rangelei um Worte;Wortgefecht
-Leydig-Zwischenzelle;Leydig-Zelle
-Reifeteilung;Meiose
-Oogenese;Ovogenese
-Metazoon;vielzelliges Tier
-Heereswesen (veraltet);Heerwesen (veraltet);Militärwesen
-Mischkonsum (ugs.);multipler Substanzgebrauch
-Einheitenzeichen;Einheitenkürzel
-Stärke;Amylum (lat.)
-in Geld verwandelt;versilbert (ugspr.);zu Geld gemacht
-Ascher Ländchen;Ascher Zipfel
-mildern;besänftigen
-Räuber-Beute-Beziehung;Räuber-Beute-Verhältnis
-Süddeutscher Bund;Südbund
-Rheinkorrektur;Rheinbegradigung;Rheinregulierung;Rheinrektifikation
-Mitternachtsformel (ugs.);große Lösungsformel (österr.)
-Abiturklausur;Abiklausur
-quietistischer Islam;politischer Quietismus
-Schiismus;Schiitentum
-Sunnismus;Sunnitentum
-Zitadelle (ital.);Reduit (franz.);Akropolis (griechisch)
-Pointer (engl.);Vorstehhund (fachspr.)
-Apportierhund;Apporteur (franz.);Retriever (engl.)
-Epagneul (franz.);Spaniel (engl.);Stöberhund
-Bracke;Schweißhund
-Milizprinzip;Milizsystem
-pelagial (fachspr., griechisch);uferfern
-meeresbodennah;benthal (fachspr., griechisch)
-Fahrradkennzeichen;Fahrradnummer;Velovignette
-Leihmutter;Surrogatmutter (selten)
-Liaison;Verbindung
-mit einwärtsgerichteten Füßen gehen;über den Onkel gehen (ugs.);einwärtsgehen;onkeln (ugs.)
-Eisschelf;Schelfeis
-gefrorenes Wasser;Eis
-Texas Tea (Jargon);Lean (Jargon);Purple Drank (Jargon);Lila Drink (Jargon)
-Xanny (ugs.);Xanax (Markenname);Alprazolam
-Publikationsliste;Publikationsverzeichnis
-Extremistenbeschluss;Radikalenerlass
-Haare lassen müssen (fig.);Nachteile hinnehmen müssen
-Wilde Indianernessel;Wilde Monarde;Wilde Bergamotte
-Lamiaceae;Labiatae;Lippenblütengewächse;Lippenblütler
-davonschweben;entschweben;entfliegen (ugs.);fortfliegen;(sich) schwebend entfernen;sanft davonfliegen
-galvanische Kopplung;Impedanzkopplung
-Gegeninduktion;induktive Kopplung
-Schaltdraht;Rangierdraht
-durchkälten;bis ins Innerste kalt machen
-Skalar;Segelflosser
-Buntbarsch;Cichlide
-Gleichung fünften Grades;quintische Gleichung
-Bruchzahl;rationale Zahl
-Zehnerbruch;Dezimalbruch
-Tonerblau;Pariser Blau;blausaures Eisen;Ferrikaliumcyanid;Stahlblau;Preußisch Blau;Eisencyanblau;Französischblau;Chinesischblau;Preußischblau;Eisenhexacyanidoferrat;Miloriblau;Tintenblau;Bronzeblau;Pottascheblau;Turnbulls Blau;Berliner Blau
-Allantoin;Glyoxylsäurediureid
-Nukleotidpolymer;Nukleinsäure
-Blaue Fritte;Frittenblau;Kupferblau;Pompeijanisch Blau;Kupferfritte;kyanos (griechisch, historisch);caeruleum (historisch, lat.);Nil-Blau;Ägyptisch Blau;Cuprorivait (fachspr.)
-gamslederfarben;chamois (fachspr., franz.)
-Subklasse;untergeordnete Klasse;Unterklasse;Kindklasse;abgeleitete Klasse
-Oberklasse;übergeordnete Klasse;Elternklasse;Superklasse;Basisklasse
-Methodensignatur;Signatur
-Meißenisch;Meißnisch
-Liefland (veraltet);Livland
-Bonbonniere (franz.);Weibsdose (ugs.);Bomboniera (ital.);Bonboniere (franz.);Bonbonschale
-anbauen;den Bau vergrößern;anfügen;baulich erweitern;hinzubauen;zubauen
-klassische Altertumswissenschaft;klassische Altertumskunde
-Karkasse;Gerippe;Grundlage für Soße;Knochengerüst
-Entenpresse;Geflügelpresse
-Entäußerung;Trennung;Auseinandertriften (fig.);Sympathieverlust;Sich-Fremdwerden;Entfremdung;Sich-Entfremden;Abkühlung (fig.)
-Heizzeit;Heizperiode
-gesundheitserhaltend;gesundheitsfördernd;salutogen (fachspr., lat.)
-Karnat;Fleischfarbe;Hautfarbe;Fleischton;Karnation;Inkarnat
-Böllerschießen;Prangerschießen (bayr., österr.)
-Intimhygiene;Genitalhygiene
-Degu;Strauchratte
-Sapropel;Faulschlamm
-Asklepiosstab;Äskulapstab;Schlangenstab
-Combo-Verstärker;Combo (fachspr., Kurzform);Kofferverstärker
-elektroakustische Anlage;elektrische Lautsprecheranlage;Durchsageanlage (ugs.)
-Hexalsystem;Sechsersystem
-Bierdeckelnotation (ugs.);Unärsystem
-kleenesche Hülle;endlicher Abschluss;Sternhülle;Kleene-*-Abschluss;Verkettungshülle
-positive Hülle;Kleene-+-Abschluss
-Vibro-Seismik;Vibroseis
-Hendiadys (fachspr., griechisch);Hendiadyoin (fachspr., griechisch)
-Leistenvers;Akrostichon (fachspr., griechisch);Leistengedicht
-Anakoluthon (fachspr., griechisch);Anakoluth (fachspr., griechisch);Anacoluthon (fachspr., lat.);Satzbruch;Anakoluthie (fachspr., griechisch)
-Reticentia (fachspr., lat.);Satzabbruch;Aposiopese (fachspr., griechisch)
-Gorgoneion;Medusenhaupt;Gorgonenhaupt
-(ein) Praktikum absolvieren;(ein) Praktikum machen
-natürliche Sperrklausel;faktische Sperrklausel
-Bolle (ugs., berlinerisch);Zwiebellauch;Gartenzwiebel;Hauszwiebel;Zwiebel (Hauptform);Allium cepa (fachspr., lat.);Zipolle;Gemeine Zwiebel;Speisezwiebel;Küchenzwiebel;Sommerzwiebel
-garantiert;versichert;verbürgt
-Einflusssphäre;Interessensphäre
-Alpinweg;Alpinwanderweg;alpine Route
-zugänglich machen;allgemein verfügbar machen;erreichbar machen;demokratisch gestalten;demokratisieren
-prosaisch;in ungebundener Rede;in Prosa
-Leprosorium;Leprakolonie;Leprosenhaus
-HWK (Abkürzung);Handwerkskammer
-Vertuer;Verschwender;Verprasser;Vergeuder
-Nordische Agrarpartei;Nordische Zentrumspartei
-Diskant;Sopran;Kopfstimme
-Wettbewerbsverfälschung;Wettbewerbsverzerrung
-wertschätzen;Wert legen (auf etwas);achten;hochhalten;viel halten (auf etwas)
-Nothafen;Schutzhafen
-Regionalwissenschaft;Regionalstudien (Plural);Arealwissenschaft
-Koreanistik;Koreanologie (österr.)
-Septennat (geh., lat.);Siebenjahresplan
-Mêlée (franz.);Nahkampf
-Glyzin;Glykokoll;Aminoethansäure;Glycin;Aminoessigsäure
-Aminosäure;Amidosäure (veraltet);Aminocarbonsäure (selten)
-Xylothek;Holzbibliothek
-ziselieren;eingravieren;reliefieren
-Toreute;Ziseleur;Künstler in halberhabener Arbeit;Bildstecher;Reliefkünstler
-Bindemäher;Binder (ugs.);Mähbinder
-Hohlkreuz;Hyperlordose
-Wirbelsäulenseitverkrümmung;Skoliose
-Dückdalben;Dukdalben;Dalben;Dälben;Dalle;Dalbe;Duckdalben
-einfach;banal;profan;Allerwelts...;gewöhnlich;Null Acht Fünfzehn;normal;schlicht;billig;08/15;gibt's im Überfluss;Standard;nullachtfünfzehn;stinknormal (ugs.);Dutzendware (abwertend, fig.);Mittelmaß;Hausmannskost (fig.);von der Stange (fig.);seriell;allgemein;handelsüblich (fig.);durchschnittlich;schnöde;Alltags...;gemein;Durchschnitt;mittelmäßig;ordinär;Plain Vanilla (fachspr., Jargon);überall vorhanden;mittelprächtig (ugs.);alltäglich;nichts Besonderes
-histologisch (fachspr., griechisch);gewebekundlich
-Saterfriesisch;Saterländisch;saterländische Sprache;saterfriesische Sprache
-ostfriesische Sprache;osterlauwerssches Friesisch
-Viöler Dänisch;Viölsch;Violer Dänisch
-Deutschenauslieferung;Baltenauslieferung
-Studium generale;Allgemeine Studien;Studium universale;Studium fundamentale;Kontextstudium
-Mensurtag;Pauktag;Bestimmtag;M-Tag
-wissbegierig;bildungshungrig;lernwillig;wissensdurstig;neugierig
-Kohnstamm-Phänomen;Kohnstamm-Effekt
-Carpenter-Effekt;ideomotorischer Effekt
-ideomotorisches Gesetz;ideomotorisches Prinzip
-Textiltechnik;Textiltechnologie
-Schriftsystem;Schriftsippe;gemischte Schriftfamilie;hybride Schriftfamilie
-Elektromobilität;E-Mobilität
-Kreuzschmerzen;Rückenschmerzen;LWS-Syndrom;Lumbalgie
-Brachialgie;Armschmerzen
-Transversalachse;Breitenachse;Horizontalachse;Querachse;Links-Rechts-Achse
-Längsachse;Logitudinalachse;Vertikalachse
-Sagittalachse;Tiefenachse;Pfeilachse
-vorjährig;vom Vorjahr (stammend);ein Jahr alt;letztjährig
-Vardar-Mazedonien;Vardar-Makedonien
-Makedonien;Mazedonien
-Immersion;Sprachbad
-magersüchtig (medizinisch);appetitlos;ohne Appetit
-Sehnenplatte;Aponeurose
-Barfüßigkeit;Bloßfüßigkeit
-Pes planus (fachspr., lat.);Plattfuß
-Pes valgus (fachspr., lat.);Knickfuß
-Pes excavatus (fachspr., lat.);Pes cavus (fachspr., lat.);Hohlfuß
-Pes equinus (fachspr., lat.);Spitzfuß;Pferdefuß
-Eröffnung;Vorspiel;Ouvertüre;Prolog
-Andenken;Erbstück;Erinnerungsstück
-Iberischer Luchs;Lynx pardinus (fachspr., lat.);Pardelluchs
-Bobcat (engl.);Rotluchs;Lynx rufus (fachspr., lat.)
-Luchs;Lynx lynx (fachspr.);Eurasischer Luchs;Europäischer Luchs;Nordluchs
-Abspielgerät;Wiedergabegerät;Player (engl.)
-Res extensa (fachspr., lat.);Physisches (griechisch)
-Res cogitans (lat.);Mentales (lat.)
-fährtenlaut;spurlaut
-Frettchenjagd;Frettieren
-Spanischer Stiefel;Schraubstiefel;Beinschraube
-Fristenregelung;Fristenlösung
-Territion;Schreckung
-medizinische Sicht auf Behinderung;medizinisches Modell von Behinderung
-soziales Modell von Behinderung;soziale Sicht auf Behinderung
-Muskelkompressionssyndrom;Kompartmentsyndrom
-Faszienspaltung;Fasziotomie
-Lebenslagenkonzept;Lebenslagenprinzip
-ohne Hinzutun;aus sich selbst;vollautomatisch;auf Autopilot (laufen) (fachspr., Jargon);wie von selbst
-Vaporetto (ital., lat.);Dampfboot
-Viehhirt;Vaquero (lat., spanisch);Cowboy (engl.);Gaucho (portugiesisch, spanisch);Stockman (engl.)
-Kastor und Pollux;Tyndariden;Kastor und Polydeukes;Dioskuren
-Energiediscounter;Billigstromanbieter;Stromdiscounter
-Verjährungseinredeverzicht;Verjährungsverzicht
-Hitzestar;Cataracta calorica;Glasbläserstar;Gießerstar;Infrarotstar;Glasbläserkatarakt;Wärmestar;Feuerstar;Schmiedestar
-störungssicher;fehlertolerant
-Urial;Steppenschaf
-Büffel;Amerikanischer Bison
-Sunda-Ochse;Banteng;Bos javanicus (fachspr., lat.)
-Geheimblüher;Kryptogame;Verborgenblüher
-Dourata (griechisch);Dorata (griechisch);Dory (griechisch);griechischer Speer
-Otter;Lutra lutra (fachspr., lat.);Eurasischer Fischotter (fachspr.)
-Tamandua;Kleiner Ameisenbär
-Impfbuch;Impfpass;Impfausweis;Impfheft
-ED-Behandlung;erkennungsdienstliche Behandlung;erkennungsdienstliche Maßnahme
-vor Wasser zurückschreckend;Wasser meidend;wasserscheu
-Knochen (Werkzeug) (ugs.);Zehnlochschlüssel;Knochenschlüssel
-Versalziffer;Majuskelziffer;Normalziffer
-Mediävalziffer;Minuskelziffer
-Wiener-Chintchin-Kriterium;Wiener-Chintschin-Theorem;Chintschin-Kolmogorow-Theorem
-Autoleistungsspektrum;Wirkleistungsspektrum
-Vermessungsflugzeug;Messflugzeug
-Frigen 12;CFC-12;Freon-12;R-12;Dichlordifluormethan
-Balearen;Balearische Inseln
-Gymnesianen;Gymnesische Inseln
-Afro-Madegassische Union;Afrikanisch-Madegassische Union
-Grifflochregister;Daumenregister;Griffregister
-Universalitätsprinzip;Weltrechtsgrundsatz;Weltrechtsprinzip
-Pränataldiagnostik;pränatale Diagnostik
-Amnioskopie (fachspr.);Fruchtwasserspiegelung
-Fruchtwasser;Amnionflüssigkeit
-Grotrian-Diagramm;Termschema;Niveauschema
-Boxplot (engl.);Box-Whisker-Plot (engl.);Kastengrafik
-Umgebung;Ambiente
-hyperaktive Blase;Reizblase (veraltet);überaktive Blase
-Nebenumstände;Kontext;Bezugsrahmen;Orientierungsrahmen
-Ponzi-Plan;Ponzi-System;Ponzi-Schema
-Frambösie;Pian (franz.);pián;bouba (portugiesisch);Buba;Parangi;piã (portugiesisch);Polypapilloma tropicum (fachspr., griechisch, lat.);Himbeerseuche;Framboesia tropica (lat.);Yaws (engl.)
-Schwingkölbchen;Haltere (griechisch, lat.)
-Ansprechendsein;Gefälligsein;Konzinnität (geh., lat., veraltet)
-stoffreich;inhaltsschwer;reich an Stoff;themenreich;inhaltsreich;gehaltvoll
-Gletschertopf;Riesentopf
-Leichenfett;Leichenwachs;Fettwachs;Adipocire (fachspr., franz., lat.);Leichenlipid
-Wachsleiche;Fettleiche
-Vorhängeschloss;Vorhangschloss;Hangschloss
-Mikronucleus;Kleinkern;Mikronukleus
-Makronukleus;Großkern;Makronucleus
-haploid;monoploid
-Halbtür;Klöntür
-Gastriole (griechisch);Nahrungsvakuole
-Scheinfüßchen;Pseudopodium (griechisch, lat.)
-Heliozoon (griechisch);Sonnentierchen
-Yawara;Pasak;Dulodulo
-Druckpunktverstärker;Palmstick (engl.);Kubotan (japanisch)
-Bullet Ant (engl.);24-Stunden-Ameise;Tropische Riesenameise;Paraponera clavata (fachspr., griechisch, lat.)
-Schlagpolster;Pratze
-Ursus arctos isabellinus;Himalayabär;Isabellbär
-phylogenetische Systematik (fachspr., griechisch);Kladistik (fachspr., griechisch)
-Akupressurpunkt;Atemi-Punkt;Druckpunkt;Kupso-Punkt
-Opiumtinktur;Meconium (veraltet);Mohnsaft (veraltet);Laudanum (veraltet)
-Stauungspapille;Papillenödem
-Gastherme;Kombitherme
-Zentralheizung;Sammelheizung
-Zuarbeiter;Beisitzer;Assessor;Assistent
-Berührungsspannung;Kontaktpotential;Kontaktelektrizität;Kontaktspannung;Berührungselektrizität
-Berührspannung;Berührungsspannung
-Richtungsharfe;Richtungsgruppe;Reihungsbahnhof (österr.)
-Zugeinheit;Zugverband
-Zugkomposition;Zugskomposition
-Großmotorschiff;Großmotorgüterschiff
-anwubben (ugs.);(jemanden) anhimmeln (ugs.);(jemanden) toll finden
-Absicherer;Behüter;Wächter;Schutz und Schirm;Beschützer;Bewahrer
-Sternguckerei (ugs.);Sternbeobachtung;Beobachtung der Sterne;Astroskopie (veraltet);Sternenschau;Betrachtung der Sterne
-Asthma;Kurzatmigkeit;Engbrüstigkeit
-Eingeweihter;Mitwisser
-Votivgabe;Votiv
-asynthetisch;unzusammengesetzt;monolithisch
-Kombinationsinstrument;Kombiinstrument
-Registerblatt;Trennblatt
-Leitkarte;Registerkarte
-Anforderungsknopf;Bettelknopf
-Bettelampel;Anforderungsampel
-ÖPNV-Bevorrechtigung;Vorrangschaltung
-Periodendauer;Schwingungszeit (selten);Schwingungsdauer
-Armillarsphäre (fachspr., griechisch, lat.);Weltmaschine
-Turquetum (fachspr., lat.);Torquetum (fachspr., lat.)
-Orrery (engl.);Planetenmaschine
-Sternentheater;Planetarium
-Bauxitrückstand;Rotschlamm
-Zoochorie;Tiersteuung;Tierausbreitung
-Synchorologie;Arealkunde;Chorologie
-Zooballochorie (fachspr., griechisch);Tierballismus
-Anemochorie (fachspr., griechisch);Windausbreitung;Windstreuung
-Furocumarin;Furanocumarin
-Dienstalter;Anciennität (fachspr., franz.)
-HiPo (Abkürzung, engl.);High Potential (engl.)
-Vollziehungsbeamter;Vollstreckungsbeamter
-Ophiotoxin;Schlangengift;Schlangentoxin
-Kfz-Brief;Fahrzeugbrief;Typenschein (österr.);Fahrzeugausweis (schweiz.)
-Tranchotkarte;Topographische Aufnahme der Rheinlande
-Rucksack (Hauptform);Tornister;Felleisen (veraltet);Affe (ugs., veraltet);Ranzen
-XPS;Extrudierter Polystyrol-Hartschaum
-EPS;Expandierter Polystyrol-Hartschaum
-Anmeldebestätigung;Meldezettel (österr.);Meldebestätigung;Schriftenempfangsschein (schweiz.);Niederlassungsausweis (schweiz.)
-Melderegisterauskunft;Meldeauskunft (österr.)
-Selbstbestäubung;Autogamie (fachspr., griechisch);Selbstbefruchtung
-Gametogenese;Gametenbildung (fachspr., griechisch);Keimzellentwicklung
-Keimzellschädigung;Gametopathie (fachspr., griechisch)
-Fledermausbestäubung;Fledermausblütigkeit;Chiropterogamie (fachspr., griechisch);Chiropterophilie (griechisch)
-Kultivar;Cultivar;Kulturvarietät
-Buntschriftstellerei;Poikilographie (griechisch)
-endgültig machen;nicht mehr zu vermeiden sein;besiegeln (fig.);nicht mehr aufzuhalten sein
-Warnfärbung;Aposematismus (fachspr.)
-Östliche Mulde;Freibergische Mulde (veraltet);Freiberger Mulde
-Westliche Mulde;Zwickauer Mulde
-Happs (ugs.);Biss;Happen (ugs.)
-Trockenholz;Moderholz;Totholz;Baumleiche
-Dysmelie;Gliedmaßenfehlbildung
-Scheibenwischwasser;Scheibenwaschwasser
-regelmäßiges Polygon;reguläres Vieleck;reguläres Polygon;regelmäßiges Vieleck;Isogon
-Perser (ugs.);Perserteppich;persischer Teppich
-Orientteppich;orientalischer Teppich
-entschlussfreudig;entscheidungsfreudig
-beschimpfen;verbal angreifen;verbal attackieren;mit Worten angreifen
-parfümieren;Duft schenken;würzen;aromatisieren;Geschmack verleihen;Aroma geben
-Triple Sec (franz.);Curaçao
-Feigbohne;Lupine (Hauptform);Wolfsbohne
-Rizobium (fachspr., griechisch);Knöllchenbakterium
-Nektarium;Honigdrüse
-Schildknorpel;Cartilago thyroidea (fachspr., griechisch, lat.)
-Mengenelement;Makroelement (griechisch)
-Bittschrift;Supplik
-Wirtschaftslehre;Wirtschaft & Soziales;Wirtschaftsunterricht;Wirtschaftskunde
-Argonaut;Papierboot
-Perlboot;Nautilus
-Rippenqualle;Kammqualle
-Epsomsalz;Epsom-Salz;Magnesiumsulfat;Bittersalz;Epsomit
-Yagé;Yajé;Daime;Ayahuasca;Natem;Cipó;Hoasca
-St. Johannis-Fäule;Muttergottesbrand;Magdalenenflechte;Mutterkornbrand;Ergotismus gangraenosus (fachspr., griechisch, lat.)
-Arowana;Osteoglossum bicirrhosum (fachspr., griechisch, lat.);Silbergabelbart;Arahuana;Aruana
-Arzneiwirkungslehre;Pharmakodynamik
-Arzneikonzentrationsverlauf;Pharmakokinetik
-Lohnbuchhaltung;Lohnbuchführung
-Masthuhn;Broiler (fachspr.)
-Miszelle;Kurztext
-anbetungswürdig;heilig
-Torfspitz;Pfahlbautenspitz;Torfhund
-Staatskalender;Staatshandbuch;Staatsadressbuch
-vorwegentscheiden;präjudizieren (geh.)
-Mantelprogramm;Rahmenprogramm
-Filmbiografie;Biopic
-Pitaya;Drachenfrucht;Pitahaya
-(ein Problem) nur allzu gut kennen;(von etwas) ein Lied singen können (fig.)
-Pompadurfisch;Diskusbuntbarsch;Heckel-Diskus;Symphysodon discus;Echter Diskus
-Paludarium;Sumpfterrarium;Sumpfbecken
-Wassergehege;Wasserbecken;Bassin (franz.);Aquarium
-Riparium;Uferterrarium
-Rivarium;Bachlaufterrarium
-Terraristik;Terrarienkunde
-Bundesregierung;föderale Regierung;Föderalregierung
-Regelblatt;Regelplan
-Beschilderungsplan;Verkehrszeichenplan
-Arbeitsstelle von kürzerer Dauer (fachspr.);Tagesbaustelle
-Dauerbaustelle;Arbeitsstelle von längerer Dauer (fachspr.)
-Samadhi-Tank;Floating-Tank;Entspannungstank;Schwebebad;Isolationstank
-Kopfblatt;Nebenausgabe;Mantelzeitung
-schräge Länge;Betriebslänge
-Violettflügelige Holzbiene;Große Holzbiene;Blauschwarze Holzbiene
-Geräuscharchiv;Klangarchiv
-Regelkontrolle;Baumkontrolle
-Verkehrssicherungspflicht;Verkehrspflicht
-Zwischenländerrecht;interföderales Recht;Interföderationsrecht
-Rußpartikelfilter;Dieselrußpartikelfilter;Partikelfilter;Dieselpartikelfilter
-körperlich;sinnlich;leiblich;fleischlich
-Feststoffbatterie;Festkörperakku;Festkörperakkumulator
-Trancheur;Vorschneider;Zerleger
-unheimlich;sagenumwoben;jenseitig;unirdisch;düster;finster;elbisch
-Schnittmeister (veraltet);Cutter;Filmeditor
-Reformjudentum;progressives Judentum;liberales Judentum
-Thüringer Schiefergebirge;Thüringisches Schiefergebirge
-Sukzessorstaat;Nachfolgestaat
-Schwarze Legion;Schwarze Schar;Schwarzes Korps;Herzoglich Braunschweigisches Korps (ursprünglich)
-Gemeine Feuerwanze (fachspr.);Schusterkäfer (ugs., österr.);Pyrrhocoris apterus (fachspr., griechisch, lat.);Feuerkäfer (ugs.)
-Blauholzbaum;Haematoxylum capechianum (fachspr., griechisch, lat.);Blutholzbaum
-Volksausschuss;Nationalausschuss
-Alumnat;Alumneum
-Studienhaus;Konvikt;Stift
-Eckrente;Standardrente
-Standardrentenniveau;Rentenniveau
-Lohntüte;Gehaltstüte
-Nullpunktsfluktuation;Vakuumfluktuation;Quantenfluktuation
-Pauli-Prinzip;Paulisches Ausschließungsprinzip;Pauli-Verbot
-Polywasser;anomales Wasser;dichtes Wasser
-Blutmond;Kupfermond
-Hundertfüßer;Skolopender;Chilopoda
-Blickschutz;Sichtschutz
-Reinigung;Läuterung;Klärung;Katharsis
-Garnele;Crevette;Riesengarnele
-kein gutes Licht (auf jemanden) werfen;nicht für jemanden sprechen;ein schlechtes Licht (auf jemanden) werfen;kein Ruhmesblatt (für jemanden) sein
-Kontaktierbarkeit;Erreichbarkeit;Verfügbarkeit;Ansprechbarkeit
-Königsweg;bester Weg
-Winkelschule;Heckschule;Klippschule (norddeutsch)
-Selbsthilfeverkauf;Notverkauf
-religiöse Bewegung;Religion
-(sich / etwas) ablagern;(sich) niederschlagen;(sich) absetzen;sedimentieren;(sich) setzen
-hat keine Aussagekraft;(etwas) bedeutet nichts;(das) will nicht viel heißen (ugs.)
-Regio-S-Bahn;NordWestBahn;S-Bahn Bremen
-niederer Adel;Niederadel
-Hochsensibilität;Überempfindlichkeit;Hypersensibilität;Hochsensitivität
-Heinrichsflut;Julihochwasser;Schwarzer Freitag von Waldeck
-lexikalische Hypothese;lexikalischer Ansatz;Sedimentationshypothese
-Rolfing (Markenname, engl.);strukturelle Integration
-thematisch;inhaltlich
-konzeptuell;konzeptionsmäßig
-religiöse Neubildungen (ugs., religiös);Neue religiöse Bewegungen
-Sekte (negativ);neue religiöse Bewegungen;religiöse Bewegungen (ugs.)
-Tableau (regional, schweiz., österr.);Tablett (Hauptform);Hiedrabratl (ugs., erzgebirgisch, regional, sächsisch)
-Requisiten;Theaterausrüstung;Fundus
-Nominalkompositum;zusammengesetztes Substantiv;Substantivkompositum
-Katalanisch;katalanische Sprache
-(die) militärische Auseinandersetzung suchen;auf einen (bewaffneten) militärischen Konflikt aus;auf Krieg bedacht;kriegslüstern
-Streitsucht;Zanksucht
-Detailgetreue;Detailtreue
-Agraralkohol;Primasprit;Weingeist;Trinkspiritus;Trinksprit (schweiz.)
-Arznei-Engelwurz;Engelwurz;Echte Engelwurz;Angelika;Angelica archangelica (fachspr., lat.)
-Hackklotz;Hauklotz;Hackblock;Hackstock (österr.)
-Stirnholz;Hirnholz
-Nacktmodell;Aktmodell
-von allen Seiten;allseitig
-gegenläufig;(sich) in entgegengesetzter Richtung bewegend
-einen Bissen nehmen (von);anbeißen;anknabbern;annagen
-anknoten;mit einem Knoten festbinden;festknoten
-Asche (ugs., DDR, veraltet);NVA (historisch);Nationale Volksarmee (historisch)
-wappenkundlich;heraldisch
-Zauberbuch;Grimoire (franz.)
-Dromonym (griechisch);Straßenname;Hodonym (griechisch)
-Sternname;Himmelskörpername;Astronym (griechisch)
-Polytechnische Schule;Polytechnikum
-Antiestrogen;Estrogen-Blocker
-Kastrationskomplex;Kastrationsangst
-Abgängigkeitsanzeige (österr.);Vermisstenanzeige
-Skiunfall;Schiunfall
-Schlaflähmung;Schlafparalyse (fachspr., griechisch);REM-Atonie (fachspr., griechisch);Schlafstarre
-generös;freigebig;splendid;spendabel;großzügig
-Erotikautor;Verfasser von Pornos;Pornograph;Pornograf;Kinädologe;Schmutzfink
-Extraterritorialität;Exterritorialität
-Aborterker;Abtritterker
-Kubikmeter;m³
-Lehre vom Beweis;Apodiktik;Lehre der unumstößlichen Aussagen
-reaktive Lymphknotenschwellung;Lymphadenitis (fachspr.)
-Cytomegalie;Zytomegalie;Einschlusskörperchenkrankheit (veraltet)
-Epstein-Barr-Virus;Humanes-Herpes-Virus 4
-Makrolakton;Makrolid
-Morbus Maßhoff;Pseudoappendizitis;Lymphadenitis mesenterialis (fachspr.);Brennemann-Syndrom;Maßhoff-Lymphadenitis;Lymphadenitis mesenterica (fachspr.)
-käsige Lymphadenitis;Lymphadenitis caseosa (fachspr.);Pseudotuberkulose
-Wahrheitswertefunktion;Wahrheitsfunktion (Kurzform)
-unendliche Reihe (veraltet);Summenfolge (selten);Reihe
-Attribut-Wert-Matrix;Merkmal-Wert-Struktur
-Wissensbasis;Wissensdatenbank
-Astacus astacus (fachspr., lat.);Edelkrebs;Europäischer Flusskrebs
-Ondatra zibethicus (fachspr., lat.);Moschusratte;Bisambiber;Bisam;Sumpfkaninchen;Wasserkaninchen;Bisamratte;Sumpfhase;Zwergbiber;Zibetratte
-Rostschutzfarbe;Rostschutzmittel;Bleioxidfarbe;Mennige
-Guajakholz;Lignum vitae (lat.)
-Stickstoffdioxid;NO₂ (fachspr., Summenformel);NO2 (fachspr., Summenformel);Nitrogendioxid
-Stickstoffmonoxid;NO (fachspr., Summenformel)
-Schlitten fahren;rodeln (landschaftlich);schlitteln (schweiz.)
-Pauschbetrag (Kurzform);Pauschalbetrag
-Lineatur;Linierung;Liniierung
-Refraktionsbestimmung;Brillenglasbestimmung;Augenprüfung;Augenglasbestimmung
-fahrende Leute;fahrendes Volk
-Vermögensberater;Finanzberater
-Elektronenstromrichtung;physikalische Stromrichtung
-Drittwiderspruchsklage;Interventionsklage
-Persischer Windhund;Tazy;El Hurr;Gazellenhund;El Hur;Tazi;El Hor;El Horr;Saluki
-Landeskennzahl (ugs.);internationale Telefonvorwahl
-primäre;erste
-Hostienfrevel;Hostienschändung
-Gleichstromkurzkupplung;HGÜ-Kurzkopplung;HGÜ-Kurzkupplung;Gleichstromkupplung
-Treiber;Häscher (geh.);Verfolger;Jäger (fig.)
-Kreuzbein-Darmbein-Gelenk;Kreuz-Darmbein-Gelenk;Sakroiliakalgelenk;Iliosakralgelenk
-Steißbeinteratom;Steißteratom
-Teratom;Wundergeschwulst (veraltet)
-Nachverdichtung;Innenverdichtung
-Habitatfragmentierung;Lebensraumzerschneidung;Habitattrennung
-Separation (fachspr.);geographische Isolation
-Bodenversiegelung;Flächenversiegelung
-Drittelgesetz;Gesetz der kleinen Zahlen;Zwei-Drittel-Gesetz;Gesetz des Drittels
-§;Paragrafenzeichen;Paragraphenzeichen
-Längenzeichen;Dehnungszeichen
-Peroxid;Peroxyd (veraltet)
-Stoffklasse;Stoffgruppe
-Perborat (Kurzform);Peroxoborat
-Oxonium-Ion;Hydroxonium (veraltet);Hydronium (veraltet);Oxonium
-Thebanischer Zyklus;Thebanischer Sagenkreis
-Epischer Kyklos;Epischer Zyklus
-Kapitaldeckungsprinzip;Kapitaldeckungsverfahren
-Innergemeinschaftliche Handelsstatistik;Intrastat (Kurzform)
-Pfostengrube;Pfostensetzung;Pfostenloch
-Seekabel;Unterwasserkabel
-Brustaugmentation (fachspr.);Brustvergrößerung
-Stiglers Gesetz;Gesetz der Eponyme
-Nordmongolei;Äußere Mongolei;Hintere Mongolei
-Ruf (ugs.);Berufung;Designation (geh., bildungssprachlich, lat.)
-Magazinsystem;französisches System
-Selbstausleihe;Selbstverbuchung
-Türkisch-Armenisch (veraltet);Westarmenisch
-Wachsleinwand;Firnistuch;Wachstuch
-Republik Bergkarabach (veraltet);Republik Arzach
-De-facto-Regime;De-facto-Staat
-Nordtürkisch;Nordosttürkisch;sibirische Turksprache
-Karasee;Karisches Meer
-Große Mauer;Chinesische Mauer
-missionieren;bekehren
-Radikaldemokratie;radikale Demokratie
-Wandschneider;Gewandschneider
-Betreuungsschlüssel;Personalschlüssel
-Klassenfrequenz;Klassenstärke;Klassengröße
-Qualifizierungsparadox;Bildungsparadoxon;Qualifizierungsparadoxon;Bildungsparadox
-Witwenspitze;spitzer Haaransatz;Biquoquet
-Besudelung;Verschmutzung;Verdreckung;Beschmutzung;Verunreinigung;Befleckung
-Synklinorium;Synkline;Synklinale
-Antiklinorium;Antiklinale
-Geosynklinale;Geosynkline
-gangbar;begehbar;passierbar
-Deuter;Erklärer;Interpret;Ausleger;Kommentator
-Katapher;Kataphora
-Pro-Form;Proform;Pronominale Kopie;Verweisform
-Werfen-Formation;Werfener Schichten
-Castoreum;Bibergeil
-Nebel;Nebelwolke;Dampfwolke
-Harvard-Zitieren;Harvard-System;Harvard-Zitat;Autor-Jahr-Zitierweise;Harvard-Methode
-um-sich-selbst-wissend;autonoetisch (fachspr., griechisch)
-Hartwurm (ugs., landschaftlich);Haselwurm (ugs., landschaftlich);Anguis fragilis (fachspr., lat.);Blindschleiche
-rollierende Planung;rollende Planung
-Produktionswirtschaftslehre;Produktionswirtschaft
-Rollierung;kapillarbrechende Schicht
-Galadrius;Charadrius;Caladrius
-Nahur;Blauschaf;Bharal;Pseudois nayaur (fachspr., griechisch, lat.)
-zusammenwickeln;zusammenlegen;zusammenklappen;zusammenfalten
-doppelte Botschaft;Doppelbotschaft;Doppelbindung
-Stammtischrunde;Symposion;Trinkgesellschaft
-Hohe Schule;Akademisches Gymnasium
-consilium abeundi;Ausschluss
-Ausschluss;consilium abeundi
-Ausschluss (von Schule oder Universität);consilium abeundi (historisch, lat.)
-multifunktional;Mehrzweck-;zur Mehrzwecknutzung geeignet
-Binnenkolonisation;innere Kolonisation;innere Kolonisierung;Landesausbau
-Helmzier;Cimir;Clainot;Helmkleinod (Hauptform);Zimier
-(seine zugewiesenen) Aufgaben erledigen;(seine) Hausaufgaben machen (fig.)
-Profi (Kurzform);Professionist (veraltet)
-3-Tage-Fieber;Drei-Tage-Fieber;Marschenkrankheit;Marschkrankheit;Dreitagefieber;Marschenfieber;Wechselfieber;Ernteseuche;Stoppelfieber;Drüddendagsfeber
-Klassenbuch;Klassentagebuch
-Blei;Brasse;Brachse;Brachsme;Pliete;Abramis brama (fachspr.);Brachsen;Bresen;Brachsmen
-Pinselschwanz-Beutelmaus;Pinselschwanzbeutler
-Großer Pinselschwanzbeutler;Große Pinselschwanz-Beutelmaus
-Superparamagnetismus;superparamagnetischer Effekt
-Schattenwerfer;Schattenstab;Schattenzeiger;Gnomon (griechisch)
-Konsil;Konsilium
-Konsiliarius;Konsiliararzt
-schulersetzendes Projekt;Ergänzungsschule;Schulersatzprojekt
-Borosilicatglas;Borosilikatglas;Borsilikatglas
-aufsteigen lassen (im Dienst);aufrücken lassen (im Dienst);in eine höhere Stelle heben;befördern
-Hickeln (Kurzform);Hinkekasten;Huppekästchen;Reise zum Mond;Hüppekästchen;Hickelkasten;Hopse (Kurzform);Himmel und Hölle;Tempelhüpfen;Hüpfekästchen;Hüpfspiel;Paradiesspiel
-Gummitwist;Gummihopse (DDR);Gummihüpfen (bayr., österr.);Gummihuppe (DDR)
-englischer Humor;britischer Humor
-Provinzialkapitel;Provinzkapitel
-Ölpreiskrise;Ölpreisschock;Ölkrise
-gemeinschaftstauglich;bindungsfähig;gemeinschaftsfähig;gesellig;soziabel
-Halbgesagtes;Andeutung(en);Angedeutetes;Zwischentöne
-unausgesprochen(erweise);zwischen den Zeilen;durch die Blume (gesagt)
-hintenrum;indirekt;durch die Blume;verblümt;in Andeutungen;versteckt
-respektiert werden;ernst genommen werden
-Raumfrequenz;Ortsfrequenz
-disziplinloser Haufen;Soldateska (Hauptform);marodierende Horde(n)
-Besatzungssoldat;Besatzer;Angehöriger der Besatzungsstreitkräfte (variabel)
-(Film über die) Vorgeschichte;Prequel
-lustige (Fernseh-) Serie;Sitcom
-(bewusste) Falschmeldung (Hauptform);Fake News (Neologismus);alternative Fakten (Neologismus, Zitat);Hoax (Jargon, Neologismus)
-Fernsehserie;Serie
-Kryokarst;Thermokarst
-Narentabahn;Neretvabahn
-Stichstrecke;Stichlinie
-Stichbahn;Flügelbahn (österr.)
-Knabenlese;Knabenzins
-Hasta (fachspr., lat.);Spieß;Lanze;Sarissa (fachspr., griechisch);Pike (veraltet) (fachspr.);Speer
-Schienengüterverkehr;Eisenbahngüterverkehr
-in Serie gehen (Hauptform);in großen Stückzahlen produziert werden;in Serie produziert werden;(etwas) am Fließband herstellen
-zu Befehl (+ dienstliche Anrede) (militärisch);jawoll;sehr wohl (+ Anrede) (veraltend);bitte sehr, bitte gleich! (veraltend);jawohl (+ dienstliche Anrede)
-Spastizität;Spastik
-da kommt noch was auf uns zu (warnend) (ugs., Spruch);das war noch längst nicht alles;(und) das war erst der Anfang!;da kommt (noch) was auf dich zu (warnend) (ugs., Spruch)
-Entkalker;Kalklöser;Entkalkungsmittel
-Einzeller (Hauptform);(nur) aus einer Zelle bestehen(d);einzelliges Lebewesen
-Archebakterien (veraltet);(die) Archaeen (Hauptform);Archaebakterien (veraltet);die Archaeae;(die) Domäne der Archaeen;die Urbakterien (veraltet);Archaebacteria (veraltet)
-Tierreich;(die) Tiere (ugs.);Animalia (fachspr.)
-Pflanzenreich;Reich der Pflanzen;(die) Pflanzen (ugs.);Embryophyta (fachspr.);Plantae (fachspr., veraltet)
-Lebewesengruppe;Taxon (fachspr.)
-erfasst werden (von);(einer Sache) unterfallen (fachspr., Amtsdeutsch, juristisch);betroffen sein (von);tangiert sein
-(die) Fungi (fachspr.);das Reich der Pilze;(die) Pilze
-Sludice (slawisch) (fachspr.);Parze(n) (römisch);Schicksalsgöttin(en) (Hauptform);Norne(n) (germanisch);Moiren (Plural, griechisch) (fachspr.)
-Nessie (ugs.);Ungeheuer von Loch Ness
-Mischwesen (aus verschiedenen Tierarten);Wolpertinger (bayr., Hauptform)
-Zyklop (Hauptform);Einäugiger;Kyklop (fachspr.)
-Hinterbliebenenrente;Rente wegen Todes
-Witwenrente (weibl.);Witwerrente (männl.)
-Betriebsrente;(Rente im Rahmen der) betriebliche(n) Altersvorsorge;zweite Säule (fig.)
-Zusatzversorgung;Zusatzpension (österr.);zusätzliche Altersversorgung;Zusatzrente (bundesdeutsch, schweiz.)
-Renteneintritt;Rentenbeginn
-Angehörige(r) einer Alterskategorie;Mitglied einer Kohorte;Alterklassenbezeichnung
-Lehr- und Wanderjahre;Ausbildungszeit;(die) Ausbildung (ugs.);Jahre der Ausbildung;Zeit der Ausbildung
-Säuglingsalter;Babyphase
-zwischen drei und sechs (ugs.);von drei bis sechs (ugs.);Vorschulalter;Kindergartenalter
-sozialversicherungspflichtig Beschäftigter;Normalarbeitnehmer
-engelgleich;engelsgleich;seraphisch
-um (das Ganze) abzurunden;abgestimmt auf;ergänzend zu;passend zu
-(als) Schlussbemerkung;abschließend;ergänzend hinzufügen;noch anmerken
-Ketokörper;Ketonkörper
-(wieder) voll drauf sein (ugs.);(einen) Rückfall gebaut haben (ugs.);(wieder) abgestürzt sein (ugs., fig.);rückfällig (sein) (Hauptform);einen Rückfall haben;rückfällig geworden sein
-drehen (an) (ugs., fig., negativ);beeinflussen (auch mit unlauteren Mitteln / auf unredliche Weise);was machen (ugs., verhüllend);seine Finger im Spiel haben (ugs., fig., negativ);Einfluss nehmen;nachhelfen (ugs., fig.);(etwas) manipulieren (negativ);an den Schrauben drehen (ugs., fig.)
-deutsche Bauweise;Kernbauweise
-belgische Bauweise;Unterfangbauweise
-Vortriebsbauweise;englische Bauweise
-Versatzbauweise;italienische Bauweise
-Tunnelanstich;Tunnelanschlag
-Träger-Bohlwand;Trägerbohlwand;Rühlwand (schweiz.)
-vorgehängter Verbau;Hamburger Verbau
-Hochdruckinjektionsverfahren;Düsenstrahlverfahren;Hochdruck-Bodenvermörtelung
-stomatognath (fachspr., medizinisch);Mund und Kiefer betreffend
-für (mehr) Klarheit sorgen;Klarheit schaffen;(bestehende) Unklarheiten beseitigen;(jemandem) die Unsicherheit nehmen;(etwas) klarstellen (Hauptform)
-(jemanden) unterrichten (in);(jemandem) auf die Sprünge helfen (bei) (ugs.);(jemandem etwas) beibringen;(jemanden) unterweisen (in);(jemandem etwas) vermitteln;(jemandem) Unterricht geben (in);(jemanden etwas) lehren
-...lehrer sein (bei/in);(ein Fach) geben (ugs.);Unterricht geben (in);(ein Fach) unterrichten (Hauptform);...unterricht geben;(jemanden) haben in (ugs., salopp)
-(jemandem etwas) näher bringen (geh.);(jemanden) heranführen (an);(jemanden) in die Anfangsgründe (eines Fachs) einführen (oder einweihen) (geh.)
-keine Namen nennen (wollen);niemanden angucken (wollen) (Redensart, fig.)
-bereichern;verbessern
-(wieder) Anschluss ans Feld finden;(die Gruppe wieder) einholen;aufschließen
-nur konsequent (sein) (ugs.);nachvollziehbar (sein) (Hauptform);verständlich;(die) logische Konsequenz (sein) (ugs., floskelhaft);es verwundert nicht (dass/wenn) (geh.);erklärlich (geh.);kein Wunder (sein) (ugs.);(gut) nachvollziehen können;begreiflich;(gut) verstehen können
-Kinotheodolit;Kinetheodolit
-Stimmlippenknötchen;Schreiknötchen;Sängerknötchen;Stimmbandknötchen
-Wahrnehmungsvermögen;Perzeptibilität (fachspr.);Sensorium (geh.);Wahrnehmungsfähigkeit
-so und nicht anders;genau so
-(gut) gebrauchen können (ugs.);(etwas) dankbar annehmen;(sich) freuen über (floskelhaft);dankbar sein (für)
-trödelig (ugs.);saumselig (geh., veraltend);verbummelt (ugs.);säumig (geh.);herumtrödeln(d) (ugs.);bummelig (ugs.)
-in Verzug (mit) (fachspr., juristisch);(einen Termin / Zeitplan) nicht einhalten
-(einen) Termin überschreiten;(eine) Frist verstreichen lassen
-nicht engagiert (sein);wenig Einsatz zeigen;sich wenig engagiert zeigen;Engagement vermissen lassen
-unzuverlässig;nicht korrekt;nicht gewissenhaft;pflichtvergessen;nachlässig (mit)
-Pedoskop;Schuh-Fluoroskop
-Röntgen;Röntgendiagnostik
-Detritusfresser (fachspr.);Detritivore (fachspr.);Saprophage (fachspr.);Totsubstanzfresser (fachspr.)
-lang gehegt;langgehegt;lange ersehnt
-ersehnt;sehnlichst herbeigewünscht;inständig herbeigesehnt
-guter Stimmung bleiben;sich die gute Laune nicht verderben lassen;(einen Anlass zum Feiern) auskosten wollen
-zum Feiern aufgelegt;es (so richtig) krachen lassen wollen (ugs.);in Partylaune
-Burgfrieden (fig.);Stillhalteabkommen
-Geheimtipp;heimlicher Favorit;Außenseiter-Favorit
-Führungstreffer;(spiel)entscheidendes Tor
-der zweitbeste sein;zweitbester sein;zweiter Sieger sein (ironisch);auf Platz zwei landen;Silber holen;auf dem zweiten Platz landen
-(jemandem) im Kopf herumgeistern;(jemandem) im Kopf herumspuken;(jemandem) durch den Kopf gehen
-(etwas) nicht aus dem Kopf bekommen;immer wieder denken müssen (an);von dem Gedanken nicht loskommen (dass / zu);Zwangsgedanken haben (fachspr., medizinisch);ständig an etwas denken müssen
-(den) Gedanken nicht loswerden (dass);(den) Verdacht hegen;(den) leisen Verdacht haben (dass);argwöhnen (dass);(den) Verdacht haben (dass);(jemandem) sagt eine leise Ahnung (dass)
-(jemandem) kommt der Verdacht (dass);(jemanden) beschleicht der Verdacht (dass);(jemand) kommt auf den Gedanken (dass);(jemanden) beschleicht eine leise Ahnung (dass)
-kein Wort verlieren über;(jemanden) nicht verraten;(jemandem) nichts sagen von;(jemandem) nichts erzählen von
-(das) Fuder (fachspr., veraltet);Ladung;Wagenladung (voll);Fuhre
-Unternehmensgründung;Existenzgründung;Neugründung
-Gründungskapital;Grundkapital (AG);Stammkapital (GmbH);Startkapital
-Königsfamilie;Königshaus
-Adelsfamilie;Adelsgeschlecht;Adelshaus
-Adelsrang;Adelstitel
-Graf (Hauptform, männl.);Countess (engl., weibl.);Count (engl., männl.);Comtesse (franz., weibl.);Comte (franz., männl.);Gräfin (Hauptform, weibl.)
-knubblig (ugs., norddeutsch);knubbelig (ugs., norddeutsch);knollig;knollenförmig
-Verdickung;Knubbel (ugs.);Knoten;Anschwellung
-Kleinwagen;Knutschkugel (ugs., fig., scherzhaft-ironisch, veraltend);Nuckelpinne (ugs., abwertend, scherzhaft, veraltend);Kompaktwagen;Miniauto
-verknittert;knubbelig;knubblig;verknubbelt;verknautscht;knautschig;knittrig
-Lebensmodell;Lebensform;Lebensweise;Lebensentwurf
-(sich) drängen;(sich) drängeln;(sich) knubbeln (ugs.)
-schreiend (Ungerechtigkeit);unfassbar;unerträglich;schwer erträglich;es fehlen einem die Worte (ugs.);unerhört;ungeheuerlich;skandalös;himmelsschreiend;empörend
-für lächerliche (10) Euro (ugs.);für gerade mal (10) Euro;für schlappe (10) Euro (ugs.);für nicht mehr als (10) Euro
-praktisch geschenkt sein;fast geschenkt sein
-Lebensmittelintoleranz (fachspr.);Lebensmittelunverträglichkeit
-harte Wissenschaft;exakte Wissenschaft
-(jemand) hätte (ebenso gut) tot sein können;beinahe gestorben (sein);(dem) Tod von der Schippe gesprungen (sein) (fig.)
-abrahamitische Religion;abrahamische Religion;Abrahamsreligion
-anrufen und sagen dass man krank ist;(sich) krank melden (Hauptform);(sich) arbeitsunfähig erkrankt melden
-Hill-Huntington-Verfahren;Divisorverfahren mit geometrischer Rundung
-erbitterter Widerstand;massive Widerstände;(eine) starke Gegenbewegung;heftige Gegenwehr
-(sich) einer Widerstandsbewegung anschließen;in die Résistance gehen (Frankreich);(sich) einer Partisanenbewegung anschließen;in den Widerstand gehen
-nicht gut geworden;missraten (geh.);verkorkst (ugs.);vermurkst (ugs.);misslungen;verhatscht (ugs., österr.);nichts geworden (sein) (ugs.);danebengegangen
-aus jemandem ist nichts Rechtes geworden;es (im Leben) nicht weit gebracht haben
-zum einen Ohr rein und zum anderen wieder (he)raus (gehen) (ugs., fig.);zum einen Ohr hinein und zum anderen wieder hinaus (gehen) (fig.);(etwas geht) hier rein und da wieder raus (mit Zeigegeste) (ugs., norddeutsch);nicht (richtig) zuhören;(etwas) gleich wieder vergessen
-Bohnen in den Ohren haben (ugs., fig., variabel);nicht zuhören;auf den Ohren sitzen (ugs., fig.);nicht hören
-(ein jemandem) Anvertrauter;(jemandes) Anbefohlener (geh.);(jemandes) Schützling;(jemandes) Schutzbefohlener
-beachtet werden;(ihre) Meinung zählt (weibl.);(ihr) wird zugehört (weibl.);(sein) Wort hat Gewicht (männl.);(seine) Meinung zählt (männl.);(ihr) Wort hat Gewicht (weibl.);(ihm) wird zugehört (männl.);(jemand) hat was zu sagen
-Seid mal ruhig!;(jemand) hat was zu sagen;(jemand) möchte etwas sagen;Ruhe jetzt!;Zuhören!;Ruhe bitte!
-(mit) geringe(r) Bevölkerungsdichte;schwach besiedelt;dünn besiedelt
-Beauftragung;Auftragserteilung;Bestellung
-Suq (orientalisch);Händlerviertel
-Fluggasttreppe;Gangway (Luftfahrt) (engl.)
-Landgang;Gangway (Schifffahrt);Passerelle
-Annex (Architektur) (fachspr.);Anbau;Nebengebäude;Erweiterungsbau
-(etwas) nicht auf dem Schirm haben (fig.);(etwas) ausblenden;keinen Gedanken verschwenden (an);(sich) keine Gedanken machen (um);nicht denken an
-beiseiteschieben (fig.);verdrängen;ausblenden;nicht sehen wollen;wegblenden
-(sich eine) Vorstellung von etwas machen (können);(eine) Vorstellung bekommen (von);(sich ein) Bild von etwas machen (können);(sich) etwas vorstellen (können);(sich etwas) bildlich vorstellen (können)
-Angst, zu spät zu sein;Torschlusspanik (fig., Hauptform);Angst, zu spät zu kommen;nicht der letzte sein wollen;Keiner will der letzte sein.
-bezahlt werden wollen;Geld sehen wollen;(etwas) nicht umsonst machen (wollen);auf Bezahlung bestehen
-(es) hat sich (et)was getan (ugs.);(etwas) unternommen haben;(waren) nicht untätig
-außerhäuslich;außerhalb des Hauses
-Herr über Leben und Tod (sein) (variabel);(sich) wie ein Gott aufführen;gottgleich (sein)
-(die) Pilzköpfe (fig., veraltet);(die) Beatles
-optimal trainiert;in Topform (Hauptform);in Bestform;in Hochform;auf der Höhe seiner Leistungsfähigkeit
-(so) üblich sein;(schon) kennen;immer so sein (ugs.);(die) Tradition will (dass);(etwas) immer so machen (ugs.);Tradition haben (Hauptform);(es) ist Tradition (dass)
-Quintett;Fünfergruppe
-Achtergruppe;Oktett
-Septett;Siebenergruppe
-Sechsergruppe;Sextett
-Küchenschrank;Geschirrschrank;Buffetschrank
-hauchdünn (auch figurativ);hauchzart;hauchfein
-schier (Adjektiv);bereits;schon (allein);der (/ die / das) bloße ...;allein (emphatisch)
-(jemanden) nicht (einfach) machen lassen (ugs.);mit bestimmen wollen;(sich) einmischen;(jemandem) hineinreden (Hauptform);(jemandem) reinreden (ugs.)
-(nieder-) hockend;in Hockstellung;in der Hocke;(zusammen-) kauernd;(nieder-) kniend
-Chemosynthese;Chemolithotrophie;Chemoautotrophie
-Endoanthropochorie (griechisch);Verdauungsausbreitung durch Menschen
-Anthropochorie (griechisch);Ausbreitung durch Menschen
-Anhaftungsausbreitung durch Menschen (griechisch);Epianthropochorie
-Hemerochorie (griechisch);kulturbedingte Ausbreitung
-Horusauge;Mondauge;Udjat-Auge;Udzat-Auge
-zugrunde gehen;zunichtewerden (geh.);vor die Hunde gehen (ugs., fig.)
-plötzliches Absetzen eines Suchtmittels (fachspr.);kalter Entzug (fig.);cold turkey (ugs., engl.);Entzug ohne ärztliche Aufsicht
-(volle) Breitseite (gegen) (fig.);massive Vorwürfe (gegen)
-(jemanden) frontal angreifen (fig.);direkt auf jemanden losgehen (fig.)
-zu hohe Kosten verursachen;(jemandem) die Haare vom Kopf (fr)essen;(jemanden) arm machen
-0 °C;Gefrierpunkt (von Wasser)
-0 Kelvin;0 K;absoluter Nullpunkt;-273,15 °C
-Hörtest (ugs.);Gehörtest (ugs.);Audiometrie (fachspr.);Vermessung des Gehörs
-Subbirettum (lat.);Zucchetto (ital.);Pileolus (fachspr., lat.);Scheitelkäppchen;Kalotte (altertümlich);Soli Deo (lat.);Submitrale (lat.)
-Favorit;Siegesanwärter;Bestplatzierter
-Außenseiter;Schlechtplatzierter
-(sehr) stramm sitzen;spannen (Kleidung);zu eng sein
-wie findest du's? (ugs.);was hältst du davon?;(na,) was sagst du!? (ugs.)
-Rückenreiniger;Frottierbürste;Duschbürste;Badebürste;Rückenbürste;Saunabürste
-Webkamm;Riet;Weberblatt;Webblatt
-Luffa aegyptiaca;Schwammkürbis;Luffa cylindrica;Luffa
-Lacke;Blänke
-Ans-Kreuz-Schlagen;Kreuzigung;Hinrichtung am Kreuz
-(jemandem etwas) schenken (abstrakt) (fig.);(jemandem) gelten (geh.);(jemanden) bedenken (mit);(jemandem etwas) gewähren;(jemandem etwas) zuteil werden lassen;(jemandem) gehören (geh., fig.)
-Vaterlandsverräter;Landesverräter;vaterlandsloser Geselle (Schlagwort, abwertend)
-Wie soll das funktionieren (mit ...)? (ugs.);Wie soll das gehen?;Wie hast du dir das vorgestellt? (floskelhaft)
-(etwas) mögen an;(etwas) an jemandem finden (ugs.);(etwas) schätzen an
-(jemandem viel) bedeuten;großen Raum in jemandes Leben einnehmen;(etwas) von jemandem haben (ugs.);(für jemanden viel) bedeuten;(jemandem sehr) wichtig sein;(für jemanden sehr) wichtig sein;(etwas) an jemandem haben
-geädert;geadert;von Adern durchzogen;marmoriert
-durchwachsen (Fleisch);von Fett durchzogen
-starker Kaffee (Hauptform);Kaffee, der Tote zum Leben erweckt (fig., übertreibend);Kaffee, in dem der Löffel stehenbleibt (fig., übertreibend)
-das Aus bedeuten (für);es sind jemandes letzte Tage (als .../ bei ...);auf dem Altar (des / der ...) geopfert werden (fig., mediensprachlich);das Ende bedeuten (für);(jemandem) das Totenglöcklein läuten (fig.);(jemandes) Tage (als ...) sind gezählt;vor dem Aus stehen;(jemand) wird bald seinen Abschied nehmen müssen;keine Zukunft (mehr) haben (fig.)
-Kolpitis (fachspr., griechisch);Scheidenentzündung;Vaginitis (fachspr., lat.)
-Passe (fachspr.);Schulterpartie (ugs.);Schulterpasse (fachspr.);Schulterteil (eines Oberhemds);Sattel (fachspr.);Göller (fachspr., schweiz.);Rückenpasse (fachspr.)
-eng (Durchgang, Gasse);schmal
-eng anliegend;straff (gespannt);stramm (sitzend);spack (ugs., regional);knapp (sitzend);eng (Kleidung);prall (sitzend) (ugs., regional)
-eingeengt;eingepfercht;eingezwängt;eingekeilt;eingeklemmt;beengt
-reine Privatrechtsordnung;Nullstaat
-Libertarianismus;Libertarismus
-(jemandem) nicht in die Wiege gelegt (worden sein) (fig.);(sich) alles (hart) erkämpfen müssen;(sich etwas) mühsam draufschaffen müssen (ugs., salopp)
-Darf ich dich (mal) was fragen? (...) (ugs.);Verrätst du mir ein Geheimnis? (...) (scherzhaft);Was ich Sie mal fragen wollte: ... (floskelhaft)
-fast sieht es so aus, als wenn;man könnte meinen;man könnte glatt denken (ugs.)
-hörst du schlecht?;hast du was an den Ohren? (ironisch);hören Sie schlecht?;brauchst du 'ne (extra) Zeichnung? (ugs.);hast du Bohnen in den Ohren? (ugs.)
-(sich) kompromissbereit zeigen;mit sich reden lassen;(jemandem) entgegenkommen (fig.);auf jemandes Vorstellungen (Wünsche, ...) eingehen;(sich) gesprächsbereit zeigen;zu Zugeständnissen bereit sein;zu Kompromissen bereit sein;gesprächsbereit (sein)
-gefällig;(jemandem) behilflich;erbötig (zu);hilfsbereit (Hauptform)
-Wasserläufer (Hauptform);Schneider;Wasserschneider
-lückenhaft;fehlerhaft;verlustbehaftet;brüchig;drittklassig;defizitär;ausgeleiert
-Veltlinbahn;Valtellinabahn (veraltet)
-(aus dem Gefängnis) entlassen werden;aus der Haft entlassen werden;(wieder) freikommen;laufen gelassen werden;rauskommen;wieder ein freier Mann (sein);auf freien Fuß gesetzt werden
-(etwas) nicht anders kennen;gewöhnt sein (an);(sich) gewöhnt haben (an);(etwas) gewohnt sein;(für jemanden) ganz normal sein (ugs.)
-nur das Schlechte sehen;schwarzmalen (Hauptform);pessimistisch darstellen;pessimistisch sehen;nur das Negative sehen
-die schlimmsten Befürchtungen haben;schwarzsehen;das Schlimmste befürchten;den Teufel an die Wand malen (fig.)
-Anschluss finden;Kontakte knüpfen;Freunde finden;(sich) vernetzen;(sich) ein Netz (von Bekanntschaften) schaffen
-Erstbezug (nach Sanierung / Totalrenovierung);Erstbelegung (Hotel, Wohnanlage);Erstvermietung
-zu keinem Ergebnis kommen;zu keiner Entscheidung kommen (Hauptform);(sich) nicht entscheiden können;(endlos) hin- und herüberlegen (ugs.);unschlüssig (sein)
-Stress;hohe Beanspruchung;(hoher) Druck;starke Belastung
-Hall-Effekt-Antrieb;Hallantrieb
-(an etwas / etwas) eingebüßt haben;nicht mehr verfügen (über);verloren haben
-den zweiten Schritt vor dem ersten tun (Redensart);erst schießen, dann fragen (Spruch)
-seine Nachfolge regeln;sein Haus bestellen (fig.)
-sein Haus bestellen (fig.);die letzten Dinge ordnen;(sich) zum Sterben bereitmachen
-der Spaß kostet (ugs., salopp);das kostet
-schlechte Stimmung verbreiten;die (schöne) Stimmung kaputtmachen (ugs.);(he)rumnerven (ugs.)
-lass dich nicht stören;lassen Sie sich nicht stören;lasst euch nicht stören;weitermachen! (militärisch)
-Laufgitter;Laufstall
-Beitrag;Forumsbeitrag (Hauptform);Posting (engl.)
-verabreden;(sich) einigen auf;abkaspern (ugs., Jargon, salopp)
-Zukunft (fig.);berufliche Entwicklungsmöglichkeit;Perspektive (fig., Hauptform);(berufliches) Fortkommen;Zukunftsaussicht(en)
-Acervus (lat.);Haufenparadox;Haufenschluss
-Bett;Bettung
-Sattelkupplung;Sattelplatte
-Regel-3-Tonner;Regellastwagen
-(angeblicher) Verantwortlicher;Der Mörder ist immer der Gärtner. (ugs., Spruch);(angeblicher) Schuldiger;Sündenbock (Hauptform);(angeblicher) Hauptverantwortlicher
-Silberfischchen;Zuckergast;Lepisma saccharina (fachspr., griechisch, lat.)
-(widerliches, infektiöses) Getier;Ungeziefer (Hauptform);(unwillkommenes) Kleingetier;Schädling(e);Geschmeiß (geh., veraltend)
-Terminalfaden;Terminalfilum
-Telson;Pygidium
-abgestreifte Haut;Exuvie (fachspr.);Exuvia (fachspr., lat.)
-abgehen (ugs., jugendsprachlich);(etwas) im Gange sein;vor sich gehen;laufen (ugs.);los sein (ugs.)
-verdammenswert;zu verurteilen;verwerflich;verachtenswert
-Raubtierfütterung (fig., ironisch);Essensausgabe
-Es ist angerichtet. (geh.);Essen ist fertig! (ugs.);Essen kommen! (ugs.);Essen fassen! (ugs.);Das Essen ist angerichtet.;Zu Tisch!
-Krankenhausbedarfsplanung;Krankenhausplanung
-Genderismus (abwertend);Gender-Ideologie (abwertend);Gender-Theorie (Hauptform)
-nicht verzichten wollen (auf);hängen (an) (Hauptform);nicht verlieren wollen;liebgewonnen haben;(sich) nicht trennen wollen (von);nicht lassen wollen (von);nicht aufgeben wollen
-anschmiegsam;klammern(d) (negativ);(sehr) anhänglich;wie eine Klette hängen (an) (abwertend)
-Brechkraft;Maß für Ablenkung eines Lichtstrahls;Strahlenbrechung;Refraktion
-Refraktionsbestimmung (ugs.);Refraktionsmessung;Messung der Brechkraft eines transparenten brechenden Mediums;Kantenbrechung (fachspr.)
-(einen) Kuschelkurs fahren;viel Verständnis haben (für)
-Insiderwissen;Insiderinformationen
-Morbus Scheuermann;juvenile Kyphose;Scheuermann-Krankheit;Adoleszentenkyphose
-Abweisung;Zurückweisung
-am Zutritt hindern;nicht hineinlassen;nicht reinlassen (ugs., norddeutsch);(jemanden) abweisen;(jemanden) zurückweisen
-(Klage) abweisen;(Klage) nicht zulassen;(Klage) zurückweisen
-Abschlag (geh., Amtsdeutsch, veraltet);Abfuhr;abschlägiger Bescheid (fachspr., Amtsdeutsch);kalte Dusche (fig.);Korb (Ablehnung)
-in Ketten (fig.);leibeigen;sklavisch;hörig
-Kastanie (ugs.);Weiße Rosskastanie;Aesculus hippocastanum (fachspr., botanisch);Gemeine Rosskastanie;Gewöhnliche Rosskastanie
-Verhau;Verhack (veraltet)
-Kreuzschlitzschraubendreher;Phillips-Schraubendreher;Phillips-Schraubenzieher;Kreuzschraubenzieher (ugs.);Kreuzschlitzschraubenzieher
-(sich) hinbegeben;(sich) hinbemühen (geh.);(irgendwohin) gehen (Hauptform, variabel);(sich) begeben (nach / zu ...);(sich) bemühen (nach / zu ...) (geh.);(sich) bewegen (nach / zu ...);(sich) verfügen (nach / zu ...) (geh., Amtsdeutsch, altertümelnd);hingehen
-in zeitlicher Nähe zu;(noch) in vertretbarem zeitlichen Rahmen;nicht erst wochenlang später
-Pong-Pong-Baum;Schellenbaum;Zerberusbaum;Selbstmordbaum;See-Mango;Milchbaum;Cerbera odollam (fachspr., lat.)
-Stellwagen (Hauptform, historisch, süddt., österr.);Gesellschaftswagen (historisch)
-Gesellschaftswagen;Partywagen (variabel)
-Fuhrwerk;Pferd und Wagen;Pferdefuhrwerk
-Soundmobil;Musikwagen;Float (fachspr., Jargon)
-Klüngelspitter (ugs., ruhrdt.);Altmetallsammler;Schrottsammler;Schrotti (ugs., Jargon);Klüngelskerl (ugs., ruhrdt.)
-(ein) wüstes Zechgelage veranstalten;(sich) hemmungslos besaufen
-genau deswegen;ebendeswegen;drum!;eben deswegen (Hauptform);das ist es ja gerade!;eben drum!;ebendeshalb;genau deshalb
-plötzliche Eingebung;Erleuchtung (fig.);rettende Idee;Hilfe in höchster Not;rettender Einfall (Hauptform)
-Wahnsinnsidee (ugs.);geniale Idee;Glanzidee;super Idee (ugs.);tolle Idee
-Forum (historisch);Rechtspflegeort (fachspr.);Volksversammlungsort (fachspr.)
-Mitmachort;Teilnahmeort
-Arbeitsumgebung;Arbeitsumfeld
-in Anspruch nehmen;wahrnehmen;nutzen;(von etwas) profitieren
-(den) Bus nehmen;(ein) Taxi nehmen;fahren (Hauptform);chauffiert werden;(sich) chauffieren lassen;(sich) kutschieren lassen;befördert werden;(die) Straßenbahn nehmen
-eine Mitfahrgelegenheit finden;(bei jemandem) mitfahren (Hauptform);mitgenommen werden;eine Mitfahrgelegenheit haben;einen Fahrer finden
-Oxycoccus macrocarpos (fachspr.);Cranberry (engl.);Moosbeere;Kranichbeere;Vaccinium macrocarpon (fachspr.);Großfrüchtige Moosbeere
-bitter;(einen) harten Zug um den Mund haben;angestrengt;streng;verkniffen (Gesichtsausdruck) (Hauptform)
-Teamchef (österr.);Nationaltrainer (Hauptform);Bundestrainer (bundesdeutsch)
-nichts wissen wollen (von) (ugs.);(sich) den Schuh nicht anziehen (ugs., fig.);(sich) nichts annehmen (von) (ugs.);(jede) Verantwortung von sich weisen (geh.);seine Hände in Unschuld waschen (fig.);behaupten, damit nichts zu tun zu haben (ugs.);(sich) für unzuständig erklären (fachspr., Amtsdeutsch, Jargon);Was hab ich (denn) damit zu tun!? (ugs., Spruch, ironisch);Schuld sind immer die anderen. (ugs., Gemeinplatz, kommentierend)
-Ablösesumme;Ablöse (ugs.);Abstandszahlung;Abstand
-Kult (sein);Kult... (sein);(eine) lebende Legende (sein);(eine) Legende (sein)
-heißer Tipp;Geheimtipp;Insidertipp
-noch nicht allgemein bekannt (sein);(noch) keiner weiß von;(sich) noch nicht herumgesprochen haben (Hauptform)
-publik geworden;allgemein bekannt;(die) Spatzen pfeifen es von den Dächern (ugs., Sprichwort, fig.);ruchbar geworden
-zum Stillschweigen verpflichtet;Geheimnisträger;zur Geheimhaltung verpflichtet
-Schraubenbox (ugs.);Sortierkasten;Kleinteilemagazin (fachspr.);Sortimentskasten (fachspr.);Sortierbox (ugs., Hauptform)
-Fülle haben;aufgeplustert (Frisur) (negativ);bauschig;Volumen haben (z.B. Haar)
-ohne Vorauswahl;alles was kommt;unsortiert;nicht festgelegt;unterschiedslos
-ununterschieden;unterschiedslos;undifferenziert
-Rückenwind haben (fig.);verstärkt Zulauf haben;seine Stimmenanteile ausbauen können;an Bedeutung gewinnen;Stimmengewinne einfahren;dazugewinnen;erstarken;hinzugewinnen;an Popularität gewinnen;im Trend liegen;im Aufwind sein;(jemandes) Zustimmungswerte bewegen sich nach oben;Rückenwind (ver)spüren (fig.);Auftrieb haben (fig.);auf positive Resonanz stoßen;Zugewinne verbuchen können;es geht aufwärts (für / mit);zulegen
-stillschweigend wieder einkassieren (Gesetz, Anordnung) (fig.);(etwas) einschlafen lassen (fig.);(etwas) sang- und klanglos beerdigen (fig.);(sich) nicht mehr kümmern (um)
-saufen wie ein Loch (derb, Redensart);einiges vertragen können;(einen) guten Zug haben (Hauptform);ganz schön was wegsaufen (ugs.);ziemlich was wegtrinken (ugs.);saufen wie ein Bürstenbinder (ugs., Redensart)
-Sektorkopplung;Sektorenkopplung
-Pyromorphit;Grün Bleyerz;Phosphorblei;Bleiapatit;Buntbleierz;Sexangulit;Phosphorsäurehaltiges Blei;Polychrom;Pseudokampylith;Grünbleierz;Phosphorbleyspat;Braunbleierz;Phosphorsaures Blei
-Grünbleierz;Traubenblei;Mimetit;Arsenikbleispath;Gorlandit;Mimetesit;Flockenerz;Arsensaures Blei;pollachites arsenicus (lat.)
-Conichalcit;Higginsit;Konichalcit
-Kalkvolborthit;Tangeit;Calciovolborthit
-Goethit;Brauner Glaskopf;Nadeleisenerz
-Kupferglas;Kupferglanz;Chalkosin
-Willemit;Villemit;Hebertin;Belgit
-Julianit;Arsenfahlerz;Binnit;Tennantit
-Schwarzerz;Antimonfahlerz;Tetraedrit;dunkles Fahlerz
-Freibergit;Silberfahlerz;Weißgiltigerz
-Vesbin;Mottramit
-Wenn Blicke töten könnten ... (ugs., Spruch);strafend (Blick);giftig;bitterböse (Blick)
-stechend (Blick);durchbohrend (Blick)
-türkisches Thrakien;Ostthrakien
-Thrakien;Thrazien
-Ägäis-Thrakien;griechisches Thrazien;Westthrakien;griechisches Thrakien
-Naturgeist;Elementargeist
-unkörperlich;übersinnlich;nicht fasslich;ungegenständlich;ungreifbar;körperlos;wesenlos;nicht fassbar;unsinnlich
-Stufenzahl;Zehnerpotenz
-Meerschaum;Sepiolith;spuma maris (lat.)
-Kautabak;Priem;Snus;Mundtabak
-(die) Verbindung kappen (fig.);Kontakt abbrechen
-Lufteinlass;Lufthutze
-Hutze (alemannisch);Dörrbirne;Hutzle (alemannisch);Kletze (bayr., österr.)
-Wildbirne;Pyrus pyraster (fachspr., botanisch, lat.);Holzbirne
-Berewecke;Birnenbrot;Hutzenbrot;Kletzenbrot;Hutzelbrot;Zelten;Früchtebrot;Schnitzbrot
-Anklopfnächte;Bosselsnächte;Klöpfelnächte;Klöflesnächte;Kräflsnächte;Anglöckelnächte;Klopfnächte;heilige Nächte
-von fern;von weither;von weitem
-Eintänzer (veraltend);Gigolo (franz., historisch);Gentleman Host (engl.)
-Ballhaus (veraltend);Tanzcafé;Tanzlokal
-Aufdampfen;Bedampfen;thermisches Verdampfen
-aussprechbar;mitteilbar;sagbar;sprechbar;aussagbar
-Tibia (lat.);Schienbein
-Handwaschemulsion;Flüssigseife
-kälteunempfindlich;kälteresistent;frosthart (Pflanze);winterhart (Pflanze)
-standsicher;standfest;sicher stehend
-Selbsterkenntnis;Selbsterkennung;Selbstreflexion;Selbstkritik
-Allvater;Wotan;grauer Wanderer;Grimnir;Odin
-Rai;Steingeld
-Filtermaske;Filterkern;Faltungsmatrix;Kern;Filteroperator;Faltungskern
-Auftrennung;Zergliederung;Fragmentierung;Zerteilung;Zerlegung;Zerspaltung;Spaltung;Aufspaltung;Teilung;Zertrennung;Zersplitterung;Demontage;Trennung;Aufteilung
-einen Eid schwören;einen Eid leisten;einen Eid ablegen
-Interrobang;Fragerufzeichen
-Contretanz (franz.);Contredanse (franz.);Country Dance (engl.);Contredance (franz.);Kontertanz;Cotillon (franz.);Kontratanz
-Ballspende;Damenspende
-Kontrollarmband;Einlassband;Festivalbändchen
-Laufindex;Zählvariable;Laufvariable
-Linguini (ital.);Linguine (ital.);Trenette (ital.);Bavette (ital.)
-Faserzement;Wellasbest
-Gebietsprälatur;Territorialprälatur
-Steinkrebs;Austropotamobius torrentium (fachspr., griechisch, lat.);Bachkrebs
-Risswachstum;Rissausbreitung
-Nebenschilddrüsenhormon;Parathyrin;Parathormon
-Hash (engl.);Doppelkreuz;Schweinegatter (ugs., scherzhaft);Rautezeichen;Lattenzaun (ugs.);Raute
-Primasch;Stehgeiger (Hauptform)
-Salonmusiker;Kaffeehaus-Musiker
-krumme Tour(en) (ugs.);Winkelzüge;Finte(n);Trickserei(en) (ugs.)
-abweichende Persönlichkeitsstruktur;Persönlichkeitsstörung (Hauptform)
-Essen der verbotenen Frucht;Sündenfall;Erbsünde;Ursünde;Essen vom Baum der Erkenntnis
-anlassen;laufen haben (ugs.);nicht abstellen;nicht ausstellen;laufen lassen (Gerät, Maschine)
-Netzkabel;Kabel (ugs.);Stromzuführung (fachspr.);Stromkabel (eines Geräts)
-nach was aussehen sollen (ugs.);etwas Vernünftiges sein sollen (ugs.);Eindruck machen sollen;(sich) nach was anhören sollen (ugs.)
-französische Riviera;Côte d'Azur
-vom Pech verfolgt sein;(eine) Pechsträhne haben;(richtig) Pech haben;es schwer haben;eine schlechte Phase haben (ugs., salopp);es läuft nicht (besonders) gut für (ugs.)
-es nicht immer leicht (gehabt) haben (verhüllend);eine schwere Kindheit (gehabt haben) (sprichwörtlich);das Schicksal hat jemanden arg gebeutelt;einiges durchgemacht haben (ugs.);viel mitgemacht haben (ugs.);das Leben hat es nicht (immer) gut gemeint (mit jemandem);schwere Zeiten durchgemacht haben
-viel schaffen;ordentlich was weg... (+ Verb) (ugs., salopp);ordentlich was schaffen;viel erledigen
-nervenaufreibend (sein);(jemanden) nervlich belasten;(jemanden) in Anspannung versetzen;an jemandes Nerven zehren (fälschlich);an jemandes Nerven zerren;nervlich belastend (sein);(eine) nervliche Belastung darstellen;an den Nerven zerren (Hauptform);(jemanden) stressen;(jemandem) die Schweißperlen auf die Stirn treiben (fig.);(jemanden) unter Stress setzen;an den Nerven zehren (fälschlich)
-Unverheiratete;Single;Alleinstehende;Alleinlebende;Junggesellin;nicht Liierte
-perniziöse Anämie;Morbus Biermer
-Die Konkurrenz schläft nicht. (Sprichwort);(sich) nicht auf seinen Lorbeeren ausruhen dürfen (Redensart);Stillstand ist Rückschritt. (Zitat)
-Feind hört mit! (Zitat);die Wände haben Ohren (Spruch, variabel)
-die Puppen zum Tanzen bringen;(etwas) aufrollen (fig.);in Begeisterung versetzen;(im Sturm) einnehmen (fig.);(sich) holen (fig.);(etwas) rocken (ugs., Hauptform, jugendsprachlich)
-nebenbei;parallel (dazu);daneben;nebenher
-(etwas) zusammenfassen (mit);(etwas) angliedern (an);(etwas einer Sache) zuschlagen
-(einen) Bogen schlagen (von ... zu);(etwas) in Verbindung bringen (mit);(eine) Verbindung herstellen (zwischen);(einen) Zusammenhang herstellen (zu / mit)
-(einen) Zusammenhang sehen;(einen) Zusammenhang erkennen;(eine) Verbindung sehen
-(jemanden) führen;(jemanden) bei der Hand nehmen
-Acetylpernitrat;PAN;Peroxiacetylnitrat
-Peroxibenzoylnitrat;PBN;PBzN
-Acrolein;Aqualin;Acrylaldehyd;Prop-2-enal;Akrolein;2-Propenal;Propenal
-als (kleiner) Junge;im Knabenalter
-Opponent;Andersdenkender;(politischer o.ä.) Gegner;Kritiker
-(darauf) warten, dass jemand/etwas kommt;(darauf) warten, dass (etwas geschieht);warten (auf)
-(jemanden) erwarten;(auf jemanden) warten;(mit jemandem) rechnen
-jeden Moment hier sein (müssen/werden);jedem Moment kommen (müssen/können)
-Trasimenischer See;Trasimener See
-Zimmerbambus;Pogonatherum paniceum;Bambusgras;Seychellengras;Bonsai-Bambus
-Gramineae;Poaceae;Süßgräser
-Yushania niitakayamensis (lat.);Zwergbambus
-Nandine;Nandina domestica (lat.);Himmelsbambus
-(das ist eine) Luftnummer;(nur) heiße Luft;es gibt (hier) nichts zu tun
-Laborfleisch (ugs.);In-vitro-Fleisch;kultiviertes Fleisch
-Pathologische Verkleinerung der Handschrift, die häufig zum Zeilenende hin auftritt;Mikrographie (fachspr.)
-Polyposis (fachspr.);Auftreten zahlreicher Polypen in einem Hohlorgan
-Hodenheberreflex;Kremasterreflex (fachspr.)
-untrennbar zusammengehören (variabel);nicht unabhängig voneinander zu betrachten (sein);zwei Seiten derselben Medaille (sein) (fig.);nicht unabhängig voneinander zu sehen (sein)
-Polaröl;Fischöl;Tran
-Amber;Ambra
-Physeter catodon (fachspr., griechisch, lat.);Pottwal;Physeter macrocephalus (fachspr., griechisch, lat.);Kaschelott
-Balsam;Styrax;flüssiges Amber;Storaxharz
-Benzoeharz;Benzoe
-Walrat;Spermazeti;Cetaceum (lat.);Spermaceti;Weißer Amber
-Schrumpfrate;Schrumpfverhältnis
-Entropieelastizität;Gummielastizität
-mit allen technischen Finessen (ausgestattet);aufgemotzt (ugs., abwertend);getunt;frisiert;gepimpt;hochgezüchtet (abwertend);aufgeblasen
-Vollzugslockerung;Lockerung;Lockerung des Vollzuges
-Raumschall;Diffusfeld;Diffusschall
-(das) ist nichts dagegen (ugs., Spruch, übertreibend);(da ist das) ein Lercherl dagegen (ugs., österr.);(das ist) noch untertrieben (ugs., positiv);(das ist) noch freundlich ausgedrückt (ugs., negativ, übertreibend)
-und zwar richtig!;das walte Hugo! (ugs., Spruch, berlinerisch, ruhrdt., veraltet);und ob! (ugs.);aber hallo! (ugs.);aber sowas von! (ugs.)
-(sich) keinen Stress machen;(sich) die Sonne auf den Pelz scheinen lassen (fig., variabel);es sich gut gehen lassen;(ein) schönes Leben haben
-(sich) die Sonne auf den Bauch scheinen lassen;(faul) in der Sonne liegen
-aber hallo! (ugs.);und was für einer!;und was für eine!
-Kölner Bucht;Köln-Bonner Bucht
-Nordchinesisches Tiefland;Nordchinesische Ebene
-Dachwohnung;Dachgeschosswohnung;Mansarde
-(jemandes) stilles Kämmerlein;(jemandes) Klause;(jemandes) Refugium (lat.);(jemandes) Rückzugsort
-Arteawurzel;Samtpappel;Eibschen (schweiz.);Hüffwurzel (schlesisch);Ibischa;Grozpapel (althochdeutsch);Adewurz;Schleimwurzel;Ibischwurz;wilde Pappel;Eisenkraut;Ybesce (mittelhochdeutsch);Althee;Hemst (niederländisch);Sammetpappeln;Hülfwurz;Ebich (mittelhochdeutsch);Weizpappel (mittelhochdeutsch);Hünst (mittelniederdeutsch);Ibschge (schweiz.);Weiße Malve;Hemisch;Sumpfmalve;Teewurzel;Ibischpappel;Ipsch (mittelhochdeutsch);witte Malve (mittelniederdeutsch);Althaea officinalis (fachspr., griechisch, lat.);Eibich (österr.);Ibisch;Rockwort (mittelniederdeutsch);Alter Thee;Ibsche (mittelhochdeutsch, schweiz.);Heemst (niederländisch);weiße Pappel;witte Hümst (mittelniederdeutsch);Pallenblöm (mittelniederdeutsch);wilt Pippeln (mittelniederdeutsch);Ungerschkrud;alte Eh (österr.);Eibesch;Heilwurz;Echter Eibisch;Arznei-Eibisch;Eibischwurz;Homes (mittelniederdeutsch)
-alltagstauglich;für normale Zwecke zu gebrauchen (variabel)
-Kur;Entspannungsurlaub;Wellness-Urlaub
-von Mensch zu Mensch (variabel);zwischenmenschlich;menschlich
-Mirfak (arabisch);Alchemb;SAO 38787 HD 20902;Alpha Persei;HR 1017;HIP 15863;33 Persei;Algenib;Marfak (arabisch)
-Cetus;Ketos;Keto
-sanfter Riese;(wie) Benjamin Blümchen;grauer Riese;(wie) Dumbo
-Erdzeit;Weltzeit
-erreicht werden (können);zu dem Ergebnis kommen (dass);es kommt zu;zustande kommen;erzielt werden (können);kommen zu;zu dem Ergebnis gelangen (dass)
-Klientelpartei (abwertend);Interessenpartei
-Freiheitliche Partei Österreichs;FPÖ
-krummer Fuß;Pes varus (lat.);Klumpfuß;Pes equinovarus (lat.)
-Triticum aestivum (fachspr., lat.);Brotweizen;Weichweizen;Saatweizen
-Hartweizen (Hauptform);Durumweizen;Triticum durum (fachspr., lat.);Glasweizen;Durum
-Schwarze Perle;Friesenpferd;Friese;Schwarzes Puscheltier
-Pura Raza Espagnola;PRE;Spanisches Pferd;Iberer;Andalusier
-Pferderasse;Pedigree;Papiere (ugs.);Abstammung
-Fjordinger;Norweger;Norwegerpony;Fjordpferd;Norwegisches Fjordpferd (Hauptform);Fjordpony
-Tinker;Gypsy Vanner;Gipsy Horse;Gypsy Cob;Traveller Horse;Vanner;Irish Cob;Irish Tinker
-Tier mit Flecken;Schecke (fachspr.)
-Rennpferd;Araber;Vollblut
-Dressurpferd;Warmblut;Springpferd;Sportpferd
-Zylinderzicke (ugs., abwertend);Dressurreiter;Kringelreiter (ugs.)
-Bowlinghalle;Bowlingcenter (werbesprachlich);Bowlinganlage
-feststampfen;festtreten;fest eintreten;dicht einstampfen
-krämpfig (ugs., schwäbisch);steif vom (vielen) Sitzen
-wie eingeschlafene Füße schmecken;nicht (mehr) schmecken;abgestanden (schmecken);schal (Bier)
-Pomaquinte;Alhandal;Bitterkürbis;Teufelsapfel;Citrullus colocynthis (fachspr., lat.);Purgiergurke;Koloquintenkürbis
-Bufdi (ugs.);Bundesfreiwilliger (ugs.);BFDler (ugs.);Bundesfreiwilligendienstleistender
-gedeckter Güterwagen;Kastenwagen;bedeckter Güterwagen
-Güterwagen;Güterwaggon (ugs.)
-Abchasisch-Adygheisch;Zirkassisch;Westkaukasisch
-Hermetismus;Hermetik
-(jemand) war mal eine große Nummer (ugs.);(jemand) war mal wer (ugs.);abgehalftert (Person)
-Multikonzern;Konglomerat;Mischkombinat;Mischkonzern
-Elberfelder Modell;Elberfelder System
-Ordnung ist das halbe Leben. (Sprichwort);Ordnung muss sein. (sprichwörtlich)
-(sich) in Stellung bringen (fig.);(sich) warmlaufen;(sich) empfehlen (für) (geh., fig.)
-(seinen) Durst löschen;(seinen) Durst stillen
-Flüssigkeitsaufnahme;(das) Trinken;Flüssigkeitszufuhr
-Innenraum;(das) Innere;Interieur (geh., franz.)
-Zippate;Zibarte;Zibärtle (alemannisch);Zwiferl (alemannisch);Seiberl (alemannisch);Ziberli (schweiz.);Zyberli (schweiz.);Zibertle (alemannisch);Zibertl (alemannisch);Ziberl (alemannisch);Ziparte;Zibelle (schweiz.)
-Schinderei;Tortur (fig.);Überanstrengung;Schlauch (ugs.);Strapaze;(über)große Anstrengung;Mühsal;Quälerei (ugs.)
-Turmkran;Turmdrehkran
-Internationale Funkausstellung (veraltet);IFA
-Dysphonie;Stimmstörung
-Münzverruf;Münzverrufung
-Regionalgeld;Regionalwährung;Lokalwährung
-(jemanden) heftig erschrecken;(jemandem) einen großen Schreck(en) einjagen;(jemanden) zu Tode erschrecken
-allgemein akzeptiert;gesellschaftsfähig
-Nordalbingien;Nordelbien;Nordelbingen
-Dänische Mark;Mark Schleswig
-(sich) einnisten;kontaminieren;infizieren;befallen
-Huftsteak;Ochsenfetzen (österr.);Hüftsteak;Hüferscherzel (österr.);Hüferlsteak (österr.);Sirloin-Steak (franz.)
-(Beschädigung/en) abbekommen;(et)was abbekommen (ugs.);zu Schaden kommen;beschädigt werden;Schäden erleiden;in Mitleidenschaft gezogen werden
-verletzt werden;zu Schaden kommen (Menschen)
-Frankenland;Franken (Hauptform)
-nicht differenzieren (zwischen);nicht auseinanderhalten;in einen Topf werfen (fig.);keinen Unterschied machen (zwischen);nicht unterscheiden (zwischen)
-unseretwegen;unserethalben
-auf der Hand liegen;(nur allzu) natürlich sein;(nur allzu) menschlich sein;nahe liegen;(nur allzu) logisch sein;nicht weiter überraschen(d sein);(nur allzu) verständlich sein;naheliegend (sein)
-Notstromaggregat;Stromerzeugungsaggregat;Netzersatzanlage
-Wobbelsender;Wobbelgenerator;Wobbler
-mutwillig;einfach so;ohne Not
-(Daten) erheben;(per Fragebogen) ermitteln;abfragen
-(es) zu bunt treiben;zu weit gehen;(den) Bogen überspannen;(eine) rote Linie überschreiten (fig.)
-(sich) über alle Regeln hinwegsetzen;(eine) heilige Kuh schlachten;(ein) Tabu brechen
-sich angesprochen fühlen;denken, dass man (selbst) gemeint ist
-(sich) angesprochen fühlen (durch/von);(jemandem) sympathisch sein;(sofort wissen,) das ist mein Ding;(sich) offen zeigen für
-(eine) Saite zum Klingen bringen (in / bei jemandem) (poetisch);(etwas) in jemandem wecken
-Grenzüberschreitung;Tabubruch
-umgekehrter Hitlergruß;Quenelle-Gruß;französische Nazi-Geste
-Veltliner Protestantenmord;Veltliner Mord
-Dachgeschoss;Dachetage
-betonen;zur Geltung bringen;in Szene setzen (fig.);(stärker) wirken lassen;(mehr) Wirkung verleihen
-Pflanzendecke;Vegetationsdecke (fachspr.);Bewuchs (mit) (Hauptform);Bestand an Pflanzen
-Mutter Natur;(freie) Landschaft;Gottes freie Natur (fachspr., Jargon);(natürliche) Umwelt;(das) Grüne (ugs.);(unberührte) Natur (Hauptform)
-echt (ugs.);auf (gut) Deutsch (gesagt) (negativ);man kann es nicht anders (als ...) bezeichnen;ausgesprochen (vor Adj. oder Nomen) (Hauptform);richtiggehend;nun wirklich (geh.);geradezu
-(jemanden) reinreißen (ugs.);(jemanden) in die Scheiße reiten (derb, fig.);(jemanden) in die Grütze reiten (ugs., fig.);(jemanden) in Teufels Küche bringen (ugs., fig.);(jemanden) in die Grütze fahren (ugs., fig.);(jemanden) in Schwierigkeiten bringen (Subjekt = Person)
-Stadtphysicus;Stadtarzt;Stadtphysikus
-Gemeindeparlament;Gemeinderat
-Mischpult (Ton);Console (fachspr.);Mixer (fachspr.)
-Lizenz zum Gelddrucken (fig.);Goldgrube (fig.)
-(die) Kasse klingelt (fig.);sprudeln (Einnahmen, Gewinne) (fig.)
-bestgehasst;rotes Tuch (Person) (fig.);meistgehasst
-ungepflegter Bart;Zottelbart
-Sightseeing-Tour;Stadtrundfahrt
-BBQ (Abkürzung, engl.);Barbecue (engl.)
-große Datenmengen;Massendaten;Big Data (Schlagwort, engl.)
-bedrohliche Situation;bedrohliche Lage;(in) Schieflage;kritische Situation
-mit zeitlichem Abstand;zeitverzögert (Hauptform);nicht sofort;mit Zeitverzögerung;nach einer Karenzzeit (fachspr.);(erst) nach einer Wartezeit;nachträglich;(erst) später
-Ballspielhaus;Ballspielhalle
-Qualifizierung;fachliche Ausbildung;fachliche Fortbildung;fachliche Weiterbildung
-schwarz überdrucken;unleserlich machen;schwärzen
-tief in jemandes Schuld stehen (geh.);(jemandem) viel zu verdanken haben
-Verständigung im Strafverfahren (fachspr.);Absprache (Strafprozess);Deal (ugs., Jargon, engl., Hauptform)
-nichts mehr zu melden haben (ugs.);zur Bedeutungslosigkeit herabsinken;jeden Einfluss verlieren;nichts mehr zu sagen haben (ugs.);bedeutungslos werden;nicht mehr gefragt werden;(ein / zum) König ohne Land (geworden) (fig.);in (der) Bedeutungslosigkeit versinken;nur noch eine Randerscheinung (sein)
-Postengeschacher;Pöstchenschieberei
-Bevorteilung;Begünstigung (Hauptform);Protektion;Begönnerung (geh.)
-hinter den;hintern (ugs.)
-vor den;vorn (ugs.)
-unauffällig;verhuscht;(armes) Hascherl (ugs., süddt.);verdruckst;graue Maus (fig.)
-Bildungshintergrund;Lernbiographie
-(irgendwohin) verschwunden;(etwas / jemand ist irgendwo) abgeblieben (ugs.);unbekannter Verbleib (Amtsdeutsch);in dubiosen Kanälen (verschwunden) (variabel)
-Shoppingtour;Kauforgie;Kaufrausch;Großeinkauf
-Tendenzschutz;Blattlinie (österr.)
-Tendenzbetrieb;Tendenzunternehmen
-(seine) Sturm- und Drangzeit hinter sich haben (fig.);zur Vernunft kommen;(seine) wilde Zeit hinter sich haben;(seine) wilden Jahre hinter sich haben;solide werden;(sich) ausgetobt haben;vernünftig werden;erwachsen (geworden);gereift (sein) (geh.)
-ins Visier nehmen;(es) abgesehen haben auf;(jemanden) treffen wollen
-altes Gemäuer (ugs.);denkmalgeschütztes Bauwerk (fachspr.);Baudenkmal (fachspr.);historisches Bauwerk
-Wohnturm;Donjon (fachspr., franz.);Keep (fachspr., engl.)
-ablängen (fachspr., Jargon);auf Länge schneiden
-hinter sich gelassen haben;als erledigt betrachten;(etwas) abgehakt haben (ugs.);nicht weiter darüber nachdenken;ad acta gelegt haben;(mit etwas) abgeschlossen haben
-beeindrucken (durch);überzeugen (mit / durch);zu beeindrucken wissen;zu überzeugen wissen;auftrumpfen (können) mit (fig., werbesprachlich);bestechen (durch) (Hauptform);punkten (mit) (variabel);überzeugend (sein .. durch / mit);zu gefallen wissen;beeindruckend (sein ... durch)
-zu seinen Besitzungen zählen (können) (geh.);sein Eigen nennen (geh.);(der) Eigentümer sein;(der) Besitzer sein;in (seinem) Besitz haben;haben (Hauptform);besitzen (Hauptform);(etwas) in Händen haben;innehaben (geh.);verfügen über
-zu jemandes Besitzungen zählen (geh.);(jemandem) sein (ugs., salopp);(jemandem) gehören;(sich) in (jemandes) Besitz befinden;in jemandes Besitz sein;meins (deins, seins, ihrs ...) sein (ugs.)
-Krach schlagen (ugs.);(etwas) reklamieren;(sich) beschweren (über) (Hauptform);(etwas) beanstanden
-positiv zu Buche schlagen;(sich) positiv auswirken
-Vorhaltezeit;Bereithaltezeit
-Anpassungserwartung(en);Konformitätsdruck (Hauptform)
-(Einsatz-) Mehrzweckstock (fachspr.);Schlagstock;Gummiknüppel (ugs.)
-gut auszukommen versuchen (mit);freundlich bleiben;(sich) gut stellen (mit);(sich jemanden) gewogen halten
-(jemandem) keine Schwierigkeiten machen;(jemandem) keinen Ärger machen;(jemanden) in Ruhe lassen
-eigene Wege gehen (jeder, die beiden) (fig.);getrennte Wege gehen (fig.);geschiedene Leute sein (fig.)
-Nabelscheibe;Batzenscheibe;Butzenscheibe
-Ochsenauge;Oculus;Rundfenster
-Opera buffa (fachspr., ital.);komische Oper
-schießen, was das Zeug hält;aus allen Rohren feuern;draufhalten mit allem, was feuert (ugs., variabel)
-Hyperkaliämie;Kaliumüberschuss
-Hypomagnesiämie (fachspr.);Magnesiummangel
-nichtrespiratorische Alkalose;metabolische Alkalose
-saures Carbonat;Hydrogencarbonat;Bicarbonat (veraltet)
-(etwas) wird mir guttun;(etwas) brauchen;(etwas) vertragen können;(etwas) gebrauchen können
-Geschworenengericht;Schwurgericht (altertümlich)
-Metalimnial;Sprungschicht;Metalimnion
-Biosphäre;Lebensraum
-glazial;eiszeitlich
-wissenschaftlich: Chenopodium quinoa;Andenhirse;Pseudogetreide;Quinoa
-filmische Umsetzung;Verfilmung
-was für ein Glück!;das nenn' ich Glück;so ein Glück!
-Himmel, nein!;Allmächtiger! (veraltend);Nein!;Ach du Scheiße! (derb);oh je! (ugs.);Sag, dass das nicht wahr ist!;Schreck lass nach!;Das hat (mir) gerade noch gefehlt!
-vorarbeiten;im Voraus erledigen;Vorarbeit leisten
-(zeitlicher) Vorsprung;Zeitvorsprung;Zeitvorteil
-zurück hängen (mit);(sich) im Rückstand befinden;zurück liegen (mit);im Rückstand sein (mit);im Verzug sein (mit);nicht im Plan (sein) (ugs., Jargon)
-(die) Deadline reißen (fachspr., Jargon);(einen) Termin nicht halten (können) (Jargon);(einen) Termin nicht einhalten (können)
-Todesdrohung;Morddrohung
-Mia san mia. (Spruch, bayr.);Uns kann keiner was.
-meuchlings;heimtückisch;von hinten;aus dem Hinterhalt;hinterhältig
-wertlos (Hauptform);ohne (jeden) Wert;nicht werthaltig (geh.)
-Ethnobotanik;Ethnopharmakologie
-Kleiderhülle;Anzugtasche;Kleidersack;Anzughülle
-Taschenmesser;Taschenfeitl (österr.);Leatherman (Markenname);Schweizer Offiziersmesser (schweiz.);Sackmesser (schweiz.);Feitl (österr.);Schweizermesser (schweiz.)
-Dietsch;Mittelniederländisch
-Fissur (fachspr., medizinisch);Riss
-in Mitleidenschaft gezogen sein;(et)was abbekommen haben (ugs.);einen Schlag weg haben (ugs., regional);nicht mehr ganz in Ordnung sein
-(etwas) nicht zu hoch hängen (ugs.);(etwas) nicht überbewerten
-erschöpft;müde;ermattet (geh.)
-zeitgleich (mit);parallel dazu
-Entdeckergeist;Experimentierfreude;Risikofreude;Forscherdrang
-offen gezeigt;nicht zu überhören;offensichtlich;unverhohlen (Hauptform)
-kaum verhohlen;(nur) mühsam unterdrückt;kaum versteckt;kaum verborgen;kaum verhüllt;kaum zu überhören;(nur) mühsam zurückgehalten
-breites Grinsen;freches Grinsen
-Narrativ (geh., Modewort, Hauptform);Geschichte (mit Symbolgehalt);Schlüsselerzählung;(sinnstiftende) Erzählung
-Sinngebung;Sinnstiftung
-Symbolik;tiefere Bedeutung;symbolische Bedeutung;Symbolgehalt
-glanzlos (Hauptform);trostlos;unglamourös;ohne Glanz und Gloria;unspektakulär;uninteressant;ohne Höhepunkte
-Zentrale Sauganlage;Zentralhaussauger;Zentralstaubsauger;Zentralsauganlage
-weiterzappen;das nächste Programm wählen;auf den nächsten Kanal (um)schalten
-durchschalten;durchzappen
-reinzappen;landen bei
-(he)rumzappen;hin- und herschalten (Fernbedienung);hin- und herzappen
-(das) nimmt sich nicht viel (ugs.);(das) ist praktische dasselbe;(das) macht keinen großen Unterschied
-Meteorologiesatellit;Wettersatellit
-(irgendwo) nichts zu suchen haben;nicht (irgendwohin) gehören;(irgendwo) nichts verloren haben
-Chlorose;Bleichsucht (fachspr.);Gelbfärbung (der Blätter)
-Drahtseilakt (fig.);Balanceakt (fig.);schwierige Aufgabe;Spagat (fig.)
-Theatermacher (Jargon);Theaterleute (ugs.);Theaterschaffende
-von Menschenhand erschaffen;von Menschen gemacht
-jetzt aber ran! (ugs.);nun mal ran! (ugs.);(nun mal) nicht so schüchtern! (ugs.);Augen zu und durch! (ugs., Spruch)
-Warum so zögerlich?;Was gibt's da lange zu überlegen?
-Bestrahlungsstärke;Strahlungsstromdichte
-Zahlung;Leistung (fachspr., Amtsdeutsch);Geldleistung (fachspr.);Geld (für) (ugs.)
-Preiseinbruch;Preise (sind) im freien Fall (mediensprachlich);Preissturz
-sich wie ein Lauffeuer verbreiten;(sich) rasend schnell verbreiten;viral gehen (ugs., Jargon, Neologismus);(ein) viraler Hit (sein) (ugs., Jargon, Neologismus);millionenfach (an)geklickt werden (ugs.)
-Teppichmesser;Kartonmesser;Tapetenmesser;Cuttermesser (ugs., fälschlich, Hauptform);Cutter;Stanley-Messer;Stanleymesser;Abbrechklingenmesser;Japanmesser
-(irgendwo) abhängen (ugs., Hauptform);(gemeinsam) (die) Freizeit verbringen;(sich) treffen
-einbalsamieren;anstreichen;beschmieren;einschmieren;einsalben;eincremen
-(jemandes) Erbe antreten wollen (fig.);(seinen) Anspruch anmelden;(jemanden) beerben wollen (fig.)
-nicht umhinkommen, sich einzugestehen (dass);zur Kenntnis nehmen müssen;(die) Augen nicht länger vor der Tatsache verschließen können (dass);(die) Augen nicht länger verschließen können (vor);zu der Feststellung gelangen (müssen);konstatieren (müssen) (geh.)
-verblasst;verwaschen (Farbe) (Hauptform);blass;ausgewaschen;ausgeblichen;verschossen;ausgebleicht;verblichen;abgeblasst
-feingliedrig;zierlich (Hauptform);von zartem Körperbau;zartgliedrig (aufwertend);zart gebaut;schlankgliedrig;zart (aufwertend);von zierlichem Körperbau
-zerstampfen;kaputttrampeln (ugs.);zertrampeln;treten (auf);kaputttreten (ugs.);in Klump treten (ugs.);zertreten
-Einschulungsgottesdienst;Schulanfängergottesdienst
-Leuchtfarbe (ugs.);Tagesleuchtfarbe;Neonfarbe;Signalfarbe;Tageslicht-Fluoreszenzfarbe;Schockfarbe
-(farblich / typografisch) hervorheben;markieren;auszeichnen (fachspr.);kennzeichnen
-zu hell (ugs.);(die) Lichter brechen aus (fachspr., Jargon);überbelichtet (sein)
-zeichnungsfrei (auf Foto) (fachspr.);(so über-hell, dass) keine Details erkennbar (sind);ausgebrannt (fachspr., Jargon);ausgefressen (fachspr., Jargon)
-Stammeszeichen;Tribal (engl.)
-(so) nicht geplant haben;nicht auf der Rechnung (gehabt) haben (ugs., fig.)
-Sitzungssaal;Tagungsraum;Versammlungsraum
-Reden ist Silber, Schweigen ist Gold. (Sprichwort);Manchmal ist es besser, nichts zu sagen. (variabel);Einfach mal die Fresse halten. (derb);(sich) seinen Teil denken (Redensart)
-Leisetreter;Mann der leisen Töne (männl.);unauffällige Person
-glimmen;glosen;schwach glühen;schwach leuchten
-(schwach) glänzen;schimmern
-schwingen;pulsieren;schwummern (ugs.);oszillieren
-(irgendwo umher)ziehen;(um)wogen;wabern;(dahin)treiben;(herum)spuken (ugs.)
-Lipoidproteinose;Hyalinosis cutis et mucosae;Urbach-Wiethe-Syndrom
-Strandwermut;Strand-Beifuß;Strandbeifuß;Artemisia maritima
-sich (irgendwo) einfinden;(irgendwohin) kommen
-sitzen bleiben;Platz behalten;nicht aufstehen
-vor verschlossener Tür(e) stehen (Hauptform);(es ist) abgeschlossen;(es ist) keiner zu Hause;(es ist) niemand zu Hause;(jemandem) wird nicht aufgemacht
-nicht geöffnet haben;geschlossen haben;zu haben (Geschäftslokal);(es ist) zu;zu sein
-(...) Pflaster (ugs., fig.);(...) Gegend (ugs., Hauptform)
-konträr (zu) (geh.);gegenteilig;gegenläufig;entgegengesetzt;Gegen...
-Calabar-Schwellung;Loiasis;Kamerunbeule;Loaose
-(ein Buch) nicht wieder aus der Hand legen (können);(ein Buch) nicht wieder weglegen (können);(sich) festlesen (Hauptform)
-Klassiker (Hauptform);anerkannte Größe;(Werk / Künstler) von zeitloser Geltung
-unübertroffen;unvergleichlich;unerreicht;vollendet
-perfekt (ugs.);makellos;vollendet;ideal;vollkommen;in höchster Vollendung
-meisterlich;meisterhaft;Meister-;mit Bravour (erledigen);bravourös
-Muster...;beispielgebend;beispielhaft;vorbildlich (Hauptform);(ein) Muster an (...);mustergültig;beispielgebend;musterhaft
-Mellisuga helenae;Kubaelfe;Hummelkolibri;Bienenelfe
-zivile Dämmerung;bürgerliche Dämmerung
-mittlere Dämmerung;nautische Dämmerung
-verliehen;verdungen;vermietet
-zusammengerührt;zusammengekloppt (ugs., regional, salopp);zusammengepanscht;zusammengeschustert (ugs., Hauptform);zusammengewürfelt;zusammengehauen (ugs.)
-Liquidation;(gezielte) Tötung;Liquidierung;Ausschaltung
-Gans (ugs., Hauptform);Hausgans
-einrosten;schwergängig werden
-(durch lange Nichtbenutzung) unbeweglich werden;versteifen;einrosten (fig.)
-(wieder) vergessen;verlernen
-bereichern;reichlich ausstatten;wohlhabend machen;zu Wohlstand bringen;reich machen;begütern
-viel zu groß;aufgebläht;überbordend;überdimensioniert
-abwinken;(seinen) Unwillen zu erkennen geben;die Nase rümpfen (fig.);(eine) wegwerfende Handbewegung machen
-(die) Nase krausziehen;(die) Nase rümpfen
-(sich) schmuggeln in (ein Gebäude);(sich) hineinstehlen;(sich) hineinmogeln;(sich) hineinschleichen;(sich) reinschleichen (ugs., norddeutsch);(sich) reinschmuggeln (ugs., norddeutsch);(sich) hineinschmuggeln;(sich) schleichen in
-(jemanden) hineinschleusen;(jemanden) einschleusen;(jemanden /etwas irgendwo) hineinschmuggeln
-mit (großer) Vergangenheit;(dort) wurde Geschichte geschrieben (geh.);geschichtsträchtig;historisch bedeutsam
-prägendes Ereignis;Schlüsselmoment;Wendepunkt;Schicksalstag
-(ein) sicheres Gespür haben (für);(einen) untrüglichen Instinkt haben
-Bistrotisch;Stehtisch
-ohne Baugenehmigung (errichtet);Schwarzbau
-am helllichten Tag;bei Tag;bei Tageslicht;am hellen Tag;tags;während des Tages;am Tag;mitten am Tag;tagsüber;untertags (schweiz., österr.)
-melden;es heißt;durchgeben;durchsagen
-Postgut (fachspr.);Post (ugs.);Versandgut;Lieferung;Warensendung;Sendung;(versandte) Ware (Hauptform);Frachtgut (fachspr.)
-Eventualvorsatz;bedingter Vorsatz
-Koinzidenzprinzip;Simultanitätsprinzip
-Sachsenross;Westfalenpferd
-Banachraum;Banach-Raum;Banachscher Raum
-normierter Raum;normierter Vektorraum
-Hilbertnorm;Innenproduktnorm;Skalarproduktnorm
-Faktorraum;Quotientenraum;Quotientenvektorraum
-Primzahl-Spirale;Ulam-Spirale
-Gegenwert;Surrogat;Entschädigung;Gegenleistung;Ersatz;Entsprechung;Ausgleich;Abgeltung;Äquivalent
-Frauensachen;Mädelskram (ugs.)
-nachordern;nachbestellen;nachkaufen
-(sich) aus kleinen Verhältnissen hocharbeiten;es nach oben schaffen (ugs., fig.)
-mach' dich auf was gefasst (Drohung) (ugs.);das wird ein Nachspiel haben (Spruch)
-rückstandslos;restlos;vollständig;rückstandsfrei;ratzeputz (ugs.)
-Jeton;Chip;Spielmarke;Token
-Zygomyzete;Jochpilz
-Aussortieren (ugs.);Ersteinschätzung;Triage (fachspr., franz.);Einteilung;Sichtung
-Muramidase;Lysozym
-französische Nationalhymne;Marseillaise
-Landeslied;Bundeshymne (Bundesstaat);Landeshymne;Königshymne (Monarchie);Nationalhymne (Hauptform);Staatshymne
-nicht der (die/das) allerneueste;schon bessere Tage gesehen haben;schon (etwas) mitgenommen;(etwas) ramponiert;(leicht) lädiert
-kulturelles Erbe;geschichtliches Erbe;nationales Erbe
-Kriegsbegeisterung;Kriegseuphorie
-völkische Ideologie;Blut- und Boden-Ideologie;völkische Gesinnung;völkische Gedankenwelt
-Heimattümelei;Volkstümelei
-Worauf wartest du (noch)?;Brauchst du (erst) 'ne Zeichnung?;Steh hier nicht rum!;Tu irgendwas!;Mach' was! (ugs.)
-rationiert;auf Marken (zu kaufen)
-gründlich danebengehen;auf der ganzen Linie scheitern;(sich) als kompletter Fehlschlag herausstellen
-Moskau (fig.);(die) russische Regierung (Hauptform);(der) Kreml (fig.)
-(für jemanden) könnte es kaum besser laufen (ugs.);glänzend dastehen (fig.)
-anders aussehen lassen;in einem anderen Licht erscheinen (lassen);(sich) relativieren
-keine Angehörigen (mehr) haben;niemanden haben (ugs.);allein(e) dastehen;keinen familiären Rückhalt haben;ohne familiären Rückhalt (leben)
-(jemandem) nachweisen, dass er gelogen hat;der Lüge überführt werden;als Lügner entlarvt werden;als Lügner dastehen
-Etappenhengst (Hauptform);Etappenhase;Etappensau (variabel)
-Schreibstubenhengst (ugs., Jargon);Geschäftszimmersoldat
-Protegé (geh., franz.);Wunsch-Nachfolger;(jemandes) Wunschkandidat;(politischer / geistiger / ...) Ziehsohn
-Klangfarbe;Klangbild;Klangfülle
-(ein) Raub der Flammen werden (floskelhaft);abbrennen;niederbrennen;durch Feuer zerstört werden
-erst kurz (ugs.);noch nicht (so) lange;erst seit kurzer Zeit;(erst) seit kurzem
-Mal-Zeichen;Kreuzchen;Multiplikationszeichen;Kreuzerl (österr.)
-zeitversetzt (Hauptform);nicht gleichzeitig;nicht zur selben Zeit;(zeitlich) verschoben
-(die) Metropolitan Opera (Eigenname);(die) MET (ugs., Eigenname)
-ursprüngliche Bedeutung;eigentliche Bedeutung;Grundbedeutung;Urbedeutung
-Grundkraft;Elementarkraft;Urkraft
-Popeln;Nasenbohren;Nasebohren;In-der-Nase-Bohren
-mal (...), mal (...);(beliebig) abwechselnd;je nachdem;wahlweise
-(etwas) gerne (tun);(jemandem) nichts ausmachen;(für jemanden) kein Problem sein (ugs.)
-(jemandem etwas) ausmachen;(nicht) okay sein (für) (ugs.);(jemandem) Ungelegenheiten bereiten (geh.);(jemanden) stören
-(etwas) mit sich selbst ausmachen (müssen);(etwas) selbst wissen müssen (ugs.);(eine) Gewissensentscheidung (sein)
-Ränke schmieden;Intrige(n) spinnen;List(en) ersinnen;Finte(n) aushecken;(ein) Spiel abkarten
-(sich) erbötig zeigen (zu) (geh., veraltet);(sich) anheischig machen (für/zu) (geh., veraltet);(sich) erbieten;(sich) bereit erklären;(jemandem etwas) anbieten;(seine) Bereitschaft erklären
-vollgefressen (derb);bis nichts mehr reingeht (ugs.)
-Silodenken;Inseldenken;Abgrenzungsdenken
-(nur) Drohgebärde(n);leere Drohung(en)
-mit dem Hammer bearbeitet;gehämmert
-Quickinfo;Mouseover;Tooltip (Hauptform);Balloon Help;Mouse-over-Text
-Schnellkomposter;Kompostbeschleuniger
-Biber-Stoff;Flannelette;Biber;Rauhcouverture;Beaver;Beaverteen;Baumwollflanell;Rohflanell
-Tricot (schweiz.);Jersey;Jersey-Stoff
-geordnete Verhältnisse vorfinden;(sich) in ein gemachtes Nest setzen (fig.)
-(jemandem) helfen, (wieder) aufzustehen;(jemandem) aufhelfen;(jemandem) auf die Beine helfen
-(das) Familienfoto (fig.);Gruppenfoto;Foto mit allen Beteiligten
-gleich (wieder) zurück;gleich wieder da
-es drauf haben (ugs.);es bringen (ugs.);was können (ugs.)
-(jemand) kann sich einbalsamieren lassen (ugs., fig.);(jemanden) kannst du vergessen (ugs.);(mit jemandem) ist nichts anzufangen (ugs.);(mit jemandem) ist nichts los (ugs.)
-Doyen (geh., fig., franz., Hauptform);Altmeister;Nestor (geh.);Dienstältester;Vaterfigur
-Trendwende;Trendumkehr
-wieder ansteigen (lassen);(einer Sache) Auftrieb geben;wieder steigen (lassen)
-Seher;Weiser;Wissender
-in seiner Eigenschaft als ...;als solche/r/s (Attribut zu N, nachgestellt);im Grunde;schlechthin;an sich;in seinem Wesen;vermöge seines ...-Seins (geh.);(schon allein) durch sein ...-Sein
-Porzellan;Service;Sonntagsgeschirr;Essgeschirr;Geschirr;Tafelgeschirr;Tafelservice;Küchengeschirr
-auf der Flucht sein;flüchten;verschwinden;abhauen
-Passiv (auch subjektlos) (ugs.);sie (Plural);die (ugs., Plural)
-übereinanderschichten;auf einen Stapel stellen;(ordentlich) aufeinanderlegen;auf einen Stapel legen;zu einem Stapel aufschichten;aufeinanderschichten;aufeinanderstapeln;aufstapeln;hochstapeln;aufeinanderstellen;stapeln (Hauptform);übereinanderstapeln;übereinanderlegen;Schicht um Schicht aufeinander...
-Wissen Sie eigentlich, wie spät es ist? (Hauptform, variabel);Haben Sie (vielleicht) mal auf die Uhr gesehen?
-(etwas) ausprobieren;(genau) wissen wollen;die Probe aufs Exempel machen
-Gruftie;Anhänger der Gothic-Szene
-(Thema) antippen (ugs.);kurz ansprechen;flüchtig sprechen von;beiläufig erwähnen;(eine) Bemerkung fallen lassen
-(etwas Ungewöhnliches) passiert;(etwas) ist los;(etwas) ist
-(in) Hammeroptik;(mit) Hammerstruktur
-fernab der Zivilisation;in der Wildnis
-(fast) gleichauf liegen;(es ist / es gibt) ein Kopf-an-Kopf-Rennen;Kopf an Kopf liegen
-in ein (tiefes) Loch fallen (fig.);in eine reaktive Depression fallen;allen Lebensmut verlieren
-Sicherheitsrasierer;Rasierhobel
-(irgendwo) sitzen;(irgendwo) thronen (geh., fig.);(irgendwo) stehen;(irgendwo) zu finden sein;(irgendwo) stecken;(irgendwo) liegen;(irgendwo) sein;(sich) befinden
-Rechtsgrundlage;rechtliches Mittel;rechtliche Handhabe
-als Gesetz;in Gesetzesform
-Gesetzesform haben;(ein) Gesetz sein
-nachmittags;jeden Nachmittag;am Nachmittag
-vormittags;jeden Vormittag;am Vormittag
-Korsakow-Symptomenkomplex;Amnestisches Syndrom;Korsakow-Syndrom;Korsakow-Symptomenkreis;Morbus Korsakow
-nett rüberkommen (ugs.);sympathisch wirken (Hauptform);für sich einzunehmen wissen (geh.);(ein) einnehmendes Wesen haben
-Formulierungsproblem;Formulierungsschwierigkeit
-Formulierungsalternative;Formulierungsvorschlag;Formulierungshilfe
-Schwiegermutters Liebling;(ein) idealer Schwiegersohn;(der) Traum aller Schwiegermütter;Wunsch-Schwiegersohn
-in Erfahrung bringen (ugs.);darauf kommen (ugs.);aufdecken;hinter etwas kommen;dahinterkommen;spitzkriegen (ugs.);eruieren (geh.);auf etwas kommen (ugs.);rauskriegen (ugs.);herausbekommen;(von etwas) Wind bekommen (ugs., fig.);spitzbekommen (ugs.);durchschauen;draufkommen (ugs.);Kenntnis erlangen (von) (Amtsdeutsch);herausfinden
-Tumorkonferenz (fachspr.);Tumorboard (fachspr.)
-Einblick geben;offenlegen;preisgeben;offenbaren;verraten
-ausgeführt;(in einem Stil, einer bestimmten Ausführung) gehalten;gestaltet
-farbliche Gestaltung;Farbgebung;Färbung;Kolorierung;Farbgestaltung
-farbliche Veränderung;Verfärbung
-Weide;Salix (fachspr., botanisch)
-(ein Kind) behalten;(ein Kind) austragen
-bringen;austragen;zustellen;herumbringen;(an die Haushalte) verteilen
-(das ist) alles, was ich habe;ich habe (doch) sonst nichts;(das ist) alles, was mir bleibt
-wenig Sympathien zeigen (für);(etwas) ablehnen;nicht gut finden;(etwas) nicht mögen (Hauptform);(einer Sache) ablehnend gegenüberstehen (geh.);(einer Sache) nichts abgewinnen können;(etwas) schlecht finden
-(jemanden) nicht gerade in Begeisterung versetzen (variabel);(einer Sache) wenig abgewinnen können;(etwas) nicht so toll finden (ugs.);(etwas) nicht besonders gut finden;(etwas) nicht besonders mögen;(etwas ist) nicht gerade mein(e) Lieblings... (ugs.)
-kurzsichtig (Handlungsweise, Entscheidung) (fig.);(zu) kurz gegriffen;ohne Zukunftsorientierung;wenig zukunftsorientiert (Politik);auf den schnellen Effekt aus
-Grasebene;Grassavanne;Grassteppe;Prärie
-Immerwurzel;Ingwerwurzel;Ingwer;Ingber;Imber;Zingiber officinale
-Rhizom (fachspr., griechisch);Wurzelstock
-Kleiner Galgant;Galgant;Echter Galgant;Siam-Galgant;Galgantwurzel;Alpinia officinarum (fachspr.)
-Nachfolger (im Amt);Nachrücker;Neubesetzung
-Juniorin (weibl.);Juniorchefin (weibl.);Junior (männl.);Juniorchef (männl.)
-(jemanden) loswerden;(jemanden) wegloben;auf einen anderen Posten verfrachten (ugs.);anderweitig unterbringen;(jemandem) eine andere Stelle andrehen (ugs.)
-(jemanden) entsorgen (derb);(sich jemandes) entledigen;(jemanden) abwimmeln;(jemanden) loswerden;(sich jemanden) vom Halse schaffen
-nicht genau wissen, was man sucht;keinen (klaren) Anhaltspunkt haben;im Nebel (herum)stochern;im Trüben fischen;versuchen (etwas) herauszufinden
-(jemanden) mit nach Hause nehmen;(einen Typen) abschleppen
-(sich) für den Mittelpunkt der Welt halten (fig.);(sich) für Gott weiß wen halten (ugs.);denken man ist der Größte (ugs., variabel);Starallüren haben;(für jemanden) dreht sich alles nur um ihn selbst (ugs.);(sich) für wichtig halten;(sich) für den Nabel der Welt halten (fig.);(sehr) von sich eingenommen sein
-jede(r/s);jede(r/s) einzelne
-Balneologie;Bäderwesen;Bäderheilkunde
-im Hellen (ugs.);bei Tageslicht
-nichts halten von;(etwas) für keine gute Idee halten
-nichts halten von;für Quatsch halten;für dummes Zeug halten;nichts geben auf
-(jemandes) Wünschen gerecht zu werden versuchen;(jemandes) Wünschen nachzukommen versuchen;(jemandem) zu Gefallen sein (geh., veraltet);(jemandem etwas) recht machen wollen;(jemandes) Erwartungen zu entsprechen versuchen
-jedermann;ein jeglicher;jeder (pronominal) (Hauptform);jede(r) einzelne;eine jegliche;ein jeder (geh.);eine jede (geh.)
-Krapp;Färberkrapp;Echte Färberröte
-Krappgewächs;Rötegewächs;Kaffeegewächs
-Wanderungssaldo;Migrationssaldo;Wanderungsbilanz
-Giggle (ugs., schwäbisch);kleine Tüte;Tütchen
-Flugrost (ugs.);Fremdrost (ugs.)
-Dame des Hauses;(die) Herrschaft (geh., veraltet);Hausherr;Hausherrin;Herr des Hauses
-Nennspannung;Nominalspannung
-Liebenswürdigkeit(en);nette Dinge (ugs.);Herzlichkeit(en);Nettigkeit(en)
-Krümchen;Stückchen;Körnchen;Bröckelchen;Bisschen
-kann nicht jeder (ugs.);will gelernt sein (Hauptform);muss man (erst mal) können (ugs.)
-soldatisch;militärisch;nach Soldatenart;diszipliniert
-ich könnte Bäume ausreißen;besser kann's mir gar nicht gehen;(sich) fühlen wie neugeboren;mir geht's blendend
-informiert (sein);orientiert (sein);wissen, wovon die Rede ist;(sich) auskennen;auf dem Laufenden (sein);Bescheid wissen;mitreden können;eingearbeitet (sein);gutunterrichtet;gebrieft;im Thema (sein) (ugs., Hauptform);(bereits) im Bilde (sein);wissen, worum es geht;gut unterrichtet
-Reaktion;Response (fachspr.)
-Reiz;Stimulus (fachspr.);Sinnesreiz
-(jemandem) gut tun;(eine) Wohltat sein
-Cloisonné;Zellenemail
-divisionale Organisation;Geschäftsbereichsorganisation;Spartenorganisation
-Geschicklichkeitsturnier;Geschicklichkeitswettbewerb
-Darwinsches Aussterben;evolutionäre Selbsttötung;Darwin'sches Aussterben;Evolutionary Suicide (engl.)
-in einer höheren Wirklichkeit;entrückt;jenseits aller Erdenschwere (geh.);weltenfern (geh.)
-mitdenken;(jemandem) geistig folgen
-mitdenken;(das) Gehirn einschalten (ugs., scherzhaft-ironisch);überlegt vorgehen;(das) Gehirn benutzen;(etwas) mit Verstand tun
-aufwertend;meliorativ (fachspr., linguistisch)
-Herabsetzung;Abqualifizierung;Abwertung (Hauptform);Verächtlichmachung
-(jemandem) zu schnell gehen;noch Zeit brauchen
-(das ist) nicht mein Problem;du musst alleine sehen, wie du da (wieder) rauskommst (ugs.);(das ist) deine Sache;(das ist) nicht mein Bier (ugs.)
-Kontakt halten;in Verbindung bleiben
-(etwas) nicht können;(etwas) nicht fertigbringen (ugs.);(etwas) nicht übers Herz bringen;(sich) nicht überwinden (können) (zu);(etwas) nicht über sich bringen (geh.)
-der Spaß kostet (jemanden) (...) Euro (ugs., salopp);(be)zahlen müssen;zu zahlen haben;mit (...) Euro dabei sein (ugs.);berappen müssen (ugs.)
-wieviel;was (ugs.)
-angehen;(sich) entzünden
-angehen (Elektrogerät);eingeschaltet werden;(sich) einschalten;angestellt werden
-starten;(sich) in Gang setzen;anspringen;ans Laufen kommen;angehen;anfangen zu laufen
-(jemandem) auf den Magen schlagen (fig.);(jemanden) abtörnen (ugs.);(jemandem) die Stimmung vermiesen (ugs.);(jemandem) die Laune nehmen;(jemandem) die Laune verderben
-(für jemanden) interessant sein;(etwas) interessant finden;(für jemanden) von Interesse sein;(jemanden) interessieren;(etwas) spannend finden
-Lawinenrettung;Lawinenverschüttetensuche
-(zeigt / hat / mit) Unternehmergeist;(zeigt / beweist / mit) Mut zur Selbständigkeit;unternehmenslustig (selten)
-offen haben (ugs.);geöffnet haben;auf sein (ugs.);geöffnet sein;Sprechstunde haben (Arztpraxis);auf haben (ugs.)
-aus Jugendtagen;aus jemandes Jugendzeit
-in jemandes wilder Zeit;als Heranwachsende(r);in jemandes Jünglingsjahren (männl., veraltet);in jemandes Jugendzeit;in (jemandes) jungen Jahren;in jemandes Jugend;als junger Mensch;in jemandes Jahren als Jugendlicher;in jemandes wilden Jahren;in jemandes Backfischzeit (veraltet, weibl.);als Jugendliche(r)
-(sich) kleiner setzen (ugs.);(sich) verkleinern (ugs.);in eine kleinere Wohnung ziehen
-Vergnügungsstätte;Amüsieretablissement;Amüsierlokal
-Rotlicht-Lokal;Striplokal;Stripbar;Nachtclub;Rotlicht-Bar
-niedermähen (fig.);reihenweise erschießen
-(sich) bereit machen;(sich) fertig machen (für) (ugs.);(sich) wappnen;(sich) rüsten;(sich) einrichten (auf);(sich) vorbereiten (auf)
-(sich) präparieren (geh.);asten (jugendsprachlich);in die Bücher schauen (ugs., süddt.);(sich) vorbereiten (auf);sich auf den Hosenboden setzen und lernen (ugs.);strebern (österr.);sich auf den Hintern setzen und lernen (ugs., salopp);büffeln (für) (ugs.);intensiv lernen (für) (Hauptform);stucken (bayr., österr.);studieren;pauken (für) (ugs.);in die Bücher kucken (ugs., fig., norddeutsch)
-wieder erzählen;wieder aufwärmen (ugs., fig.);noch einmal bringen (Fernsehen);wiederholen
-Mitbringsel;kleines Geschenk (Hauptform);Gastgeschenk;Geschenkle;(ein) Dankeschön;(eine) Aufmerksamkeit
-(jemandem) zu Kopf(e) gestiegen sein (Erfolg, Lob, Auszeichnung) (fig., Hauptform);(sich etwas) einbilden (auf);(sich) jetzt für den Größten halten;(sich) jetzt für Gott weiß wen halten
-leichtsinnig;allzu selbstsicher;übermütig
-Leute zu Besuch haben (ugs.);Gäste haben;(jemanden) zu Gast haben;Besuch haben
-geriatrisch (fachspr., medizinisch);altersheilkundlich (medizinisch)
-Megalopolis;Megaregion
-Nebenkosten (ugs.);zweite Miete (fig.);Wohnnebenkosten
-(die) Lippen spitzen;(die) Lippen aufwerfen;(eine Art) Kussmund machen;(den) Mund spitzen;(die) Lippen schürzen (selten);(die) Lippen vorstülpen
-Eiswürfel;Würfeleis;gewürfeltes Eis
-Priestergewand;Soutane
-Fahrkarte (ugs., Jargon, fig.);Fehlschuss
-Fehlwurf;Pudel (Kegeln) (ugs., Jargon)
-(sich) zu schade sein (für) (ugs.);(etwas) für unter seiner Würde halten;(schließlich) auch seinen Stolz haben (ugs.)
-(jemandes) Fußabtreter sein (ugs.);(für jemanden) Dreck sein (derb);(jemanden) wie Dreck behandeln (derb);(jemanden) wie den letzten Dreck behandeln (derb);(jemandes) Würde verletzen;(für jemanden) nur der Bimbo sein (derb)
-respektlos behandeln;(jemandem) respektlos begegnen;es an Respekt fehlen lassen (jemandem gegenüber)
-(etwas) für sich haben;nicht nur schlecht sein;(auch) sein Gutes haben
-verbrannt sein (Neologismus, fig.);(etwas) gar nicht erst zu versuchen brauchen;(sich) nirgendwo mehr blicken lassen können (ugs.);kein Bein mehr an die Erde kriegen (fig.)
-y-Achsenabschnitt;Ordinatenabschnitt
-Menschen;(die) Sterbliche(n);Menschenkinder
-(klar) gehen;klappen (mit);in Ordnung gehen;(den) Termin halten (Jargon, Hauptform);dabei bleiben (es)
-alleine rausfinden (ugs.);selbst rausfinden (ugs.);(alleine) herausfinden;wissen, wo es rausgeht;(den) Ausgang alleine finden
-Niederpannonien;Unterpannonien
-ich habe nichts dagegen;dem steht nichts entgegen (geh.);meinen Segen hast du (Spruch, fig.);(das) geht in Ordnung (ugs.);ich wüsste nicht(s), was dagegen spräche (geh., floskelhaft);da sehe ich keine Probleme (ugs.);ich habe keine Einwände;dem steht nichts im Weg(e);das ist ohne weiteres möglich;ich wüsste nicht(s), was dagegen spricht (floskelhaft);ich wüsste nicht(s), was dem entgegenstehen sollte (geh., floskelhaft)
-als Bemerkung vorab;zum Geleit;als Geleitwort;(ein paar) einführende Worte;ein Wort zuvor;als Vorbemerkung
-gleich nach;kaum (+ Partizip Perfekt);sofort nach;Minuten nach;schon am Tag (des/der ...);unmittelbar nach;kaum ... da
-(jemandes) Erfolg hängt davon ab;(jemand) wird gemessen an
-Vorgeschmack (fig.);Kostprobe (fig.)
-Anschauungsunterricht (in / in Sachen) (fig.);(warnendes) Beispiel;Lehrstück (in / darin, wie) (fig.)
-Geschmacksprobe;Kostprobe;Probierhäppchen
-Mundvoll;Häppchen;Miniportion;Bissen
-auf Einkaufstour (gehen);losziehen shoppen (ugs.);auf Shoppingtour (sein);shoppen sein (ugs.);shoppen gehen (ugs.);eine Shoppingtour machen;durch die Geschäfte ziehen (ugs.)
-(seine) Kontakte spielen lassen;(seine) Beziehungen spielen lassen;(seine) Verbindungen spielen lassen;(seinen) Einfluss geltend machen
-Kompromissbereitschaft signalisieren;auf jemanden zugehen;(das) Gespräch suchen
-(jemanden) aus dem Amt jagen (ugs.);(jemanden) aus dem Amt vertreiben;(jemanden) seines Amtes entheben
-(jemandem) nichts schulden;quitt sein (mit);(einander / jemandem) nichts mehr schuldig
-(etwas) los sein (ugs.);(etwas) eingebüßt haben;(etwas) quitt sein (ugs.);(einer Sache) quitt sein (geh., veraltet);(etwas) verloren haben
-(einer Sache) quitt sein (geh., veraltet);(einer Sache) ledig sein (geh., veraltet);frei von etwas sein;(von etwas) befreit sein
-joggen gehen;laufen gehen (ugs.);sein Lauftraining machen (ugs.)
-Hamam (arabisch, türkisch);Hammam (arabisch, türkisch);Orientalisches Bad;Türkisches Bad
-als wahrscheinlich geltend;mutmaßlich (Adjektiv) (Hauptform);präsumtiv (geh., bildungssprachlich);von dem man vermutet, dass
-(jemandem etwas) verzeihen;(jemandem etwas) nachsehen;(etwas) entschuldigen (Hauptform);Verständnis haben (für);Nachsicht üben (geh.);Verständnis aufbringen (für);(jemandem etwas) vergeben;(sich) nachsichtig zeigen
-(etwas ist für jemanden) erledigt;(jemandem) verziehen haben;vergeben und vergessen (sein)
-Projektant (fachspr.);Planer (Hauptform);Organisator
-Motorrad mit Beiwagen;Motorradgespann
-Knappe;Armiger;Wepeling;Edelknecht;Edelknabe;Wappner;Wäpeling
-einsegnen (veraltend);konfirmieren
-Bat Mitzwa (weibl.);Bar Mitzwa (männl.)
-(jemandem) die Firmung spenden;(jemanden) firmen
-gefirmt werden;(die) Firmung bekommen
-ein altes chinesisches Sprichwort sagt (ugs., scherzhaft);es heißt nicht umsonst;es heißt;man sagt
-die Party ist vorbei;(es kommen) schlecht(er)e Zeiten;(es folgen) magere Zeiten
-es geht (wirtschaftlich) abwärts;die Party ist vorbei (fig.);(es kommen) schlecht(er)e Zeiten;(es folgen) magere Zeiten
-Exodus (Eigenname, biblisch);Auszug aus Ägypten
-Fechtfeder;Federschwert
-Mordhau;Mordstreich;Mordschlag
-Versuchsaufbau;Versuchsanordnung
-(etwas) nicht aus den Augen lassen;seine Augen nicht lassen können (von);seine Augen keine zwei Sekunden lassen können (von) (ugs.);wie gebannt starren (auf)
-(die) (anfängliche) Begeisterung ist verflogen;(es) zeigen sich Ermüdungserscheinungen;(die) Luft ist raus (ugs., fig.);(der) (erste) Schwung ist weg (ugs.)
-(jemanden) unter Verschluss halten;(jemanden) dabehalten (ugs., Hauptform);(jemanden) in Gewahrsam (be)halten;(jemanden) nicht laufen lassen
-Mucks;Geräusch;Laut;Ton
-Knippchen (ugs., regional);Pittermesschen (ugs., rheinisch, ruhrdt.);Aberrämmchen (ugs., nordhessisch);Kartoffelschälmesser;Schneiddeiferl (ugs., bayr., fränk.);Pittermesser (ugs., rheinisch, ruhrdt.);Zöppken (ugs., Solinger Platt);Hipken (ugs., niederrheinisch);Kneipchen (ugs., hessisch);Hümmelken (ugs., westfälisch);Schälmesser;Hümmchen (ugs., westfälisch);Tourniermesser (fachspr.);Hölzestielchen (ugs., regional);Pitter (ugs., ruhrdt.);Hipkesmess (ugs., niederrheinisch)
-Küchenarbeit(en);(die) Kocherei (ugs., abwertend);(das) Kochen
-Eckpunkte;Richtgrößen;Rahmenbedingungen
-(einer Sache) abschwören (geh.);(auf) Distanz gehen (zu);(sich) lossagen (von) (Hauptform);(sich) distanzieren;brechen mit;(seine) Verbindungen kappen (zu) (fig.)
-im Alter von (Hauptform);als ...jährige(r);mit
-im Gespräch bleiben;weiter verhandeln;(die) Verhandlungen fortsetzen;im Dialog bleiben;(die) Gespräche fortsetzen
-abseits (einer Sache);außerhalb (einer Sache);unabhängig von;außerhalb von;jenseits von;jenseits (einer Sache);abseits von
-(jemandem) die Freundschaft (auf)kündigen;(sich) abwenden (von jemandem);(den) Kontakt abbrechen (zu);mit jemandem brechen;(den) Kontakt beenden (zu)
-(es) versuchen mit;greifen zu (fig.);(sich) verlegen auf (geh.)
-zurückrufen (Telefon);(sich) melden (ugs.);telefonisch(e) Rücksprache (halten) (Amtsdeutsch)
-relative Permeabilität;Permeabilitätszahl
-überlanger Satz;Bandwurmsatz (fig.);Satzgirlande (fig.);Endlossatz
-komplexes Satzgefüge;Schachtelsatz (Hauptform);Satzlabyrinth (fig.)
-Gliedsatz (fachspr.);eingebetteter Satz (fachspr.);Nebensatz (Hauptform);Teilsatz (fachspr.);untergeordneter Satz (fachspr.)
-Obersatz (fachspr.);Matrixsatz (fachspr.);Hauptsatz;übergeordneter Satz (fachspr.)
-Satzgefüge (fachspr.);Nebensatz-Konstruktion;Hypotaxe (fachspr., vereinfachend)
-Konsekutivsatz;Folgesatz
-Späthelladikum;späthelladische Periode
-mykenische Zeit;mykenische Kultur;mykenische Periode
-Trassant;Wechselgeber
-(sich) geschickt anstellen (ugs.);einen guten Eindruck hinterlassen;positiv auffallen;(sich) gut machen (ugs.);(sich) gut schlagen (fig.);eine gute Figur machen (fig.)
-beeindrucken;gut aussehen;Eindruck machen;(eine) gute Figur machen
-Do Khyi;Tibetdogge;Tibetmastiff;Tibetanische Dogge
-Küchenhilfe;Hilfskraft für Küchenarbeiten;Küchenhelfer
-große Wäsche haben (veraltet);(ihren) Waschtag haben (veraltet);(ihren) Großwaschtag haben (veraltet);(bei ihr war) Großwaschtag (veraltet);große Wäsche machen (veraltet)
-waschen (ugs.);(die) Wäsche machen;(bei jemandem) ist Waschtag (ugs., fig.);(seinen) Waschtag haben (fig.);(die) Wäsche waschen
-Hausarbeit(en);Haushalt
-Kolossalismus (selten);Gigantismus;Gigantomanie;Monumentalismus
-(jemandem) eine Abmagerungskur verordnen;(jemanden) auf schmale Kost setzen (veraltet);(jemanden) auf Diät setzen
-während der ganzen Woche;die ganze Woche (ugs.);die ganze Woche hindurch
-in der nächsten Woche;nächste Woche;Im Lauf(e) der nächsten Woche
-in der vorigen Woche;vorige Woche (ugs.);letzte Woche (ugs.);in der letzten Woche
-zwei Wochen;vierzehn Tage
-in vierzehn Tagen;in zwei Wochen
-vor vierzehn Tagen;vor zwei Wochen
-vor einer Woche;vor acht Tagen;(von heute) eine Woche zurück (ugs.)
-Stützverbgefüge (fachspr.);FVG (fachspr.);Funktionsverbgefüge (fachspr.)
-(etwas) verschmähen;(sich) zu gut sein (für);(sich) zu schade sein (für);(jemandem) nicht gut genug sein (ugs.)
-Feindkontakt;Feindberührung
-gütlich;im Guten;ohne Streit
-kommen;eingeführt werden
-(von irgendwoher) kommen (ugs.);(von irgendwoher) zu hören sein
-jetzt komm! (ugs.);jetzt lass (aber mal) gut sein! (ugs.)
-komm!;los!
-in Massen kommen;herbeiströmen;in (hellen) Scharen kommen;in hellen Haufen kommen
-nichts anzubieten haben;mit leeren Händen kommen (fig.)
-(jemanden) zu sich bestellen;(jemanden) kommen lassen;(jemanden) ins Haus bestellen
-(an etwas) ist nicht mehr zu denken;es gibt nicht mehr (Möglichkeit);es gibt nicht länger (Möglichkeit);nicht mehr bestehen (Möglichkeit);(etwas) geht nicht mehr;ausscheiden (Möglichkeit, Option, diese Lösung ...);nicht (länger) in Frage kommen;nicht mehr die Möglichkeit haben;nicht mehr können;(sich) erledigt haben (ugs.);nicht mehr bleiben (Möglichkeit)
-Wo gibt es hier einen (eine / ein ...)?;Wo ist (hier) ...?;Wo finde ich hier ...?;Wie komme ich zu ...? (Hauptform);Wo geht's hier zu ...? (ugs.);(Können Sie mir helfen?) Ich suche (den Weg zu) ...;Wo ist hier der (die / das ...)?
-(jemanden) durchfährt der Gedanke (dass ...);zündende Idee;genialer Einfall;Geistesblitz (Hauptform);Erleuchtung;plötzliche Eingebung
-Speicher-Engine;Speichersubsystem
-nicht vollwertig (Mensch, Bürger);mit minderem Status;(Mensch) mit eingeschränkten Rechten;(Mensch, Kollege) zweiter Klasse (fig., Hauptform);(eines) minderen Status' (geh.)
-misstrauisch sein;(einer Sache) nicht trauen;(sich) nicht verlassen wollen (auf);mit einer unangenehmen Überraschung rechnen;dem Braten nicht trauen (ugs., fig.)
-(jemandes Frau) bekommt ein Kind;Vater werden
-stramm katholisch (ugs.);stockkatholisch;erzkatholisch;tiefschwarz (fig.);überzeugt katholisch
-ereignisgetriebene Programmierung;ereignisorientierte Programmierung;ereignisgesteuerte Programmierung
-sequentielle Programmierung;serielle Programmierung
-(jemandes) Aufsicht unterliegen (formell);unter Kontrolle stehen;(ständig) überwacht werden
-(die) Kontrolle ausüben;(jemandes) Aufsicht unterstehen
-Fascia mamilla;Strophium;Fascia pectoralis;Brustbinde
-Stöckchenspiel;Hägars Wikingerschach;Wikingerkegeln;Wikingerspiel;Bauernkegeln;Schwedenschach;Kubb;Wikingerschach
-Bayer Leverkusen;Werkself
-Sinneswandel;Distanzierung;Abkehr;Kurswechsel (Politik) (fig.)
-gehörig;kräftig;gründlich;ordentlich (Adverb)
-der wird Augen machen!;(na) der wird sich (aber) wundern!
-gesatztes Recht;positives Recht
-in Arbeit verstrickt sein (scherzhaft-ironisch);(zeitlich) stark eingebunden (Hauptform, verhüllend);viele Verpflichtungen haben
-Neurosyphilis;Neurolues
-Lisene;Mauerblende
-da hab' ich keine Hemmungen;kein Problem haben (mit) (ugs.);da kenn(e) ich nichts (ugs., Redensart);da kenn' ich nix (ugs., Redensart, salopp);da pack ich mich nicht für (ugs., Redensart, ruhrdt.)
-Defensio (österr.);Disputation;Verteidigung (einer wissenschaftlichen These)
-Lungenarzt;Pneumologe;Lungenfacharzt;Pulmologe
-(es) fehlte nicht viel, und (...);dass jemand/etwas nicht (...), ist alles (ugs.)
-skalares Feld;Skalarfeld
-vernichten;zerstören;einstampfen (Druckerzeugnisse);makulieren (Print-Produkte) (fachspr.)
-Nebulum;Nephelium;Nebulium
-Riechstörung;Dysosmie
-Vorfreude;freudige Erwartung
-(es) hat sich ausge... (ugs.);kein (...) mehr;(es ist) Essig (mit) (ugs.);(für jemanden) gestrichen (sein) (ugs.);(ab jetzt) verboten
-Handeln;Taten;Handlung(en)
-ich hab' da was (ugs.);ich hab etwas Interessantes gefunden (variabel)
-schief (fig.);verrutscht (fig.);unpassend (Vergleich o.ä.) (Hauptform);daneben gegangen (ugs., fig.);verunglückt (fig.)
-Ersatz;Wechsel;Austausch;(das) Austauschen;(das) Auswechseln;(das) Ersetzen;Auswechselung
-(sich) freisprechen (von einer Verantwortung);(sich) reinwaschen (von);(sich) rehabilitieren;(sich) für unschuldig erklären
-(etwas) vergessen machen;Gras wachsen lassen (über)
-Gewissensnot;Zerknirschtheit;Reuegefühl;Reue;Selbstvorwürfe;Schuldgefühl
-schmusig;verschmust;knudd(e)lig;kusch(e)lig;Schmuse...;Kuschel...
-Trautes Heim, Glück allein. (sprichwörtlich);Zu Hause ist es doch am schönsten.;Am schönsten ist es doch zu Hause.;Daheim ist es am schönsten. (Spruch)
-schlotterig (ugs.);flatterig;schlabberig (Stoff) (ugs., Hauptform);schlabbrig (ugs.);fludderig (ugs., rheinisch)
-ohne Schick;unelegant (Hauptform);unästhetisch (geh.);unwürdig
-labbrig (ugs.);dünn;wässrig;lasch;kraftlos (fig.);labberig (Kaffee, Brühe) (ugs.);lau (geh.);fade;schlabberig (Brei, Suppe) (ugs.)
-glatt;fest;steif (Stoff)
-Benannte Stelle;Notifizierte Stelle
-Augenspiegel;Stirnreflektor;Stirnspiegel
-Haremshose;Pluderhose;Pumphose
-Genesender (männl.);Rekonvaleszentin (weibl.);Genesende (weibl.);Rekonvaleszent (männl.)
-(leichter) Schlag mir der flachen Hand;Streich;Klaps;Patsch (ugs.);Patscher (ugs.)
-patschen (ugs.);klatschen;(mit der flachen Hand) schlagen
-Umsicht;Weitblick;Weitsicht
-Entblößung;Entkleidung
-eintreiben;(Geld von jemandem) kassieren (Hauptform);einziehen;(Geld) abknöpfen (ugs.);einstreichen;einkassieren;(sich) greifen (ugs.)
-Person mit abweichender Sexualpräferenz (fachspr., Hauptform);Perversling (ugs., abwertend);Abartiger (ugs., abwertend);Perverser
-Patriot;Vaterlandsliebhaber;Vaterlandsfreund
-Hempels Paradox;Rabenparadox
-Produkt;Wirtschaftsgut;handelbares Gut
-(materielles) Produkt;materielles Gut;Sachgut
-(eine) Dienstleistung;entgeltliche Tätigkeit (für einen anderen)
-(ein) Nutzungsrecht;(ein) Recht
-Gewürzysop;Hyssopus officinalis (fachspr., lat.);Eisop;Hizopf;Essigkraut;Josefskraut;Hisopo;Echter Ysop;Bienenkraut;Weinespenkraut;Duftisoppe;Eisenkraut;Isop;Heisop;Ispen;Ysop;Hyssop;Ibsche;Esope
-Heilkraut;Arzneipflanze;Heilpflanze
-Vorderschaftrepetierer;Pumpgun (ugs., engl.);Vorderschaftrepetiergewehr
-Kartause;Kartäuserkloster
-Namensvetter (männl.);Namensvetterin (weibl.);Namenskollege (männl.);Namenskollegin (weibl.)
-Demonstration;Aufzug
-zubauen;bebauen;verbauen (auch figurativ)
-große Stücke halten (auf) (ugs.);schwören (auf) (ugs.);großes Vertrauen setzen (in) (variabel);überzeugt sein (von)
-(etwas) glauben;(etwas) für wahr halten (Hauptform);davon ausgehen, dass etwas stimmt
-Yue;Guangdonghua;Südchinesisch;Kantonesisch;Kantonesische Sprache
-was genau;was (...) Schönes? (ugs., ironisierend);was (...) überhaupt?;was
-echt was (ugs., emotional);(ja) was Schönes (ugs., emotional, ironisch);echt ein Ding (ugs., emotional)
-in der Schublade verschwinden (fig.);nicht erwähnt werden;unter den Teppich fallen (fig.)
-Kleinlibelle;Wasserjungfer
-Subscriber Identity Module (engl.);SIM-Karte (Hauptform);SIM (Abkürzung)
-(jemandem) zugeschlagen werden;(an jemanden) gehen
-des Rätsels Lösung (fig.);(wahrer) Grund;Ursache
-überlaufen (Adjektiv) (Hauptform);(es gibt) zu viele Besucher;(zu) stark frequentiert
-Kreuzfahrtschiff;Ozeanriese
-Gedankengang;Überlegung(en);Erwägungen;Reflexion
-(jemandem) heimlich einen Tipp geben;(jemandem etwas) zuflüstern;(jemandem etwas) verraten;(jemandem einen) versteckten Hinweis geben;(jemandem etwas) ins Ohr flüstern;(jemandem etwas) stecken
-kein Unschuldsengel (sein) (ugs., fig.);kein Chorknabe (sein) (ugs., fig.);nicht lieb und brav sein
-Taktgeber;Schrittmacher
-das Tempo vorgeben;(den) Takt vorgeben;das Tempo machen
-(sich etwas) angelesen haben;(sein) Wissen (über etwas) aus Büchern haben;nicht aus eigener Erfahrungen kennen
-(einen) Fehler machen;(etwas) falsch machen;(einen) Fehler begehen;(sich) vertun (ugs.)
-(jemanden) bei seiner Verantwortung packen (ugs.);(jemanden) in die Pflicht nehmen;nicht aus der Verantwortung entlassen
-(einen) Bogen beschreiben;(einen) Bogen machen (Hauptform);(einen) Bogen schlagen;(sich) in einem Bogen bewegen
-(eine thematische oder zeitliche Spannbreite) behandeln;(einen) Bogen schlagen (von ... über ... bis / bis zu / zu) (Hauptform);ausgehend von (... über ... bis) auf (...) zu sprechen kommen
-streiflichtartig beleuchten;einzelne Punkte herausgreifen;(nur) Teilaspekte behandeln;(nur) auf Einzelaspekte eingehen;ausschnitthaft darstellen
-Pardune;Abspannseil
-Der Wind hat sich gedreht. (Spruch, fig.);Die Zeiten haben sich geändert. (Hauptform);Es ist nicht mehr wie früher.;Jetzt gelten andere Regeln.
-jagen;treiben;(irgendwohin/irgendwoher) wehen (starker Wind) (Hauptform);blasen (kräftiger Wind);pfeifen;fahren;fegen (fig.)
-Mottowagen;Motivwagen
-bulliger Kerl;Stiernacken (fig.)
-Blähbauch;Trommelbauch
-Erfolgsbilanz;positive Bilanz
-Gangsterbraut;Gangsterliebchen
-charmant (Auftreten);liebenswürdig;gewinnend;nett
-(irgendwie) funktionieren;(irgendwie) gehen
-unverfänglich (fragen);einfach so (ugs.);ist nur 'ne Frage (ugs.);nur so (ugs.);rein interessehalber;ohne Hintergedanken
-nicht brauchen (+ zu + Infinitiv);nicht brauchen (+ Infinitv) (ugs.);nicht müssen (+ Infinitiv);nicht nötig sein (es ... dass)
-(es) ist etwas faul (an) (ugs., fig.);(es) stimmt etwas nicht (an / mit);stinken (die Sache / die Geschichte ...) (ugs., fig.)
-(sich etwas einfach) nicht vorstellen können;(einfach) nicht glauben (können);(etwas) für ausgeschlossen halten;(das) kann (einfach) nicht sein
-Sklerotalring;Skleralring
-lobend;anerkennend;positiv;wertschätzend
-(jemanden) beiseite ziehen;(jemanden) beiseite nehmen;(jemanden) beiseiteziehen;(jemanden) beiseitenehmen;(jemanden) zur Seite ziehen;(jemanden) auf die Seite nehmen
-(sich) unter einen Hut bringen lassen (fig.);(sich miteinander) vereinbaren lassen;zusammenpassen;zusammengehen;miteinander klarkommen (ugs.)
-Gülle ausbringen;jauchen;mit Gülle düngen;odeln (regional)
-Güllekeller;Güllegrube;Güllebehälter;Jauchegrube
-(gelernter) Bergarbeiter;Hauer (historisch);Berg- und Maschinenmann (fachspr.)
-Bergmaschinenmann (ugs.);Bumser (derb);Berg- und Maschinenmann (dualer Ausbildungsberuf)
-Verantwortliche Person (ab 1980) (Amtsdeutsch);Steiger
-(gezielt) suchen;(sich) umsehen nach;auf der Suche (nach etwas) sein;(sich) umschauen nach
-also dann;in diesem Sinne (Hauptform)
-Reichweite;Strahlkraft (fig.);Bedeutung;Wirkung
-Handgepäck;Bordgepäck;Bordcase (fachspr., Jargon)
-strahlend;glanzvoll;blendend;glamourös
-Reisetasche (Hauptform);große Tasche;Sporttasche
-Transportbox;Transportbehälter;Transportkiste
-Blechkiste;Munitionskiste;Metallkiste;Munitionsbehälter
-umdrehen;wieder zurückfahren;umkehren;wenden (Auto)
-stabiler Transportbehälter;Koffer
-Kiepenkerl (ugs., regional);Wanderhändler (mit Rücken-Tragekorb)
-Benutzereingabe;Benutzerinteraktion
-mit Rädern;mit Rollen;auf Rädern;Roll...;auf Rollen;fahrbar;rollbar
-Schotterpiste;unbefestigte Straße
-Kö (ugs., Eigenname);Königsallee (Eigenname)
-(für jemanden) nicht neu sein;(jemandem) nicht neu sein;(von etwas) gehört haben;(von etwas) erfahren haben;(jemandem) nicht unbekannt sein
-(von etwas) gehört haben;Nichts Genaues weiß man nicht, (Spruch);nichts Genaueres wissen (über);(etwas) läuten hören haben (von) (fig.)
-(von etwas) keine Kenntnis haben (Amtsdeutsch);(etwas) nicht wissen;(zu etwas) nichts sagen können (ugs.);Da fragen Sie den Falschen. (ugs., Spruch);keine (genaueren) Informationen haben (zu);(jemandem) liegen (zu etwas) keine Erkenntnisse vor (Amtsdeutsch);(über / von etwas) nichts wissen (ugs.)
-keine Informationen haben (über / zu);es gibt keine Erkenntnisse;(jemandem) liegen keine Erkenntnisse vor
-abschalten (V-Mann);abziehen;aus dem Verkehr ziehen;deaktivieren
-Tagesgeschehen;Tagesaktualität
-ein Kurzer (ugs.);ein Schnaps
-ein Bier und ein Schnaps;Lüttje Lage (regional);Herrengedeck (Hauptform)
-im ...takt;jede ... (+ Zahlwort + Zeiteinheit);...lich (von Zeiteinheit abgeleitet);alle ... (+ Zahlwort + Zeiteinheit)
-(ein Fahrzeug) besteigen;aufsitzen (fachspr., Jargon, militärisch);an Bord gehen (Schiff, Flugzeug);zusteigen;einsteigen (Hauptform);in ein Fahrzeug (ein)steigen;entern (als Gruppe) (ugs., fig., scherzhaft);boarden (Flugzeug, manchmal auch Schiff / Fähre) (fachspr., Jargon)
-Coryphaena hippurus (fachspr., griechisch, lat.);Goldmakrele;Gemeine Goldmakrele;Mahi-Mahi;Große Goldmakrele
-Weidenblattlarve;Leptocephalus (fachspr., griechisch);Aal-Larve
-Sargassum (fachspr., lat.);Golf-Tang;Golftang
-Funkstellenkennung;Kennung;Rufzeichen;Stationskennung
-Leichterschiff;Bording;Prähm;Schute;Leichter;Barge;Lichterschiff
-Larmoyanz;Selbstmitleid
-(sich) für den bedauerswertesten Menschen auf der Erde halten;in Selbstmitleid zerfließen
-Ährige Minze;Mentha spicata (fachspr., griechisch, lat.);Krause Minze;Speer-Minze;Grüne Minze;Spearmint (engl.)
-Mastix (griechisch);Chicle;Kaugummi
-nicht sehen, was man direkt vor der Nase hat;den Überblick verlieren;vor lauter Bäumen den Wald nicht (mehr) sehen (Redensart)
-Schienenkanone;Schienengewehr;Railgun (engl.)
-gern zitiert;beliebt;oft genannt;populär;häufig herangezogen
-hochgelobt;in den Himmel gehoben;hoch geschätzt;vielfach ausgezeichnet;(begeistert) gefeiert;hoch gerühmt;in den höchsten Tönen gelobt;bejubelt;gepriesen;mit Preisen überhäuft
-hochjagen (ugs., fig.);hochjubeln (ugs., fig.);auf eine hohe Drehzahl bringen;auf Touren bringen (Motor)
-hochtourig;mit hoher Drehzahl
-überdrehen;übertakten;mit zu hoher Drehzahl (fahren / arbeiten lassen)
-Kalziumkarbonat;Calciumkarbonat;kohlensaurer Kalk;CaCO3 (fachspr., Summenformel, chemisch);Kalk;E 170 (fachspr., E-Nummer);Calciumcarbonat
-Albit;Natronfeldspat
-Aluminit;hallische Erde;Websterit
-Lœwigit;Lœvigit;Alunit;Alaunspat;Alaunstein
-(etwas ist) wirklich (so) passiert;(etwas) hat es wirklich gegeben
-ohne die anderen;nicht mit anderen zusammen (Hauptform);in trauter Zweisamkeit;unter sich
-(etwas) in die Hand nehmen;(etwas) klären;in Ordnung bringen;(etwas) regeln
-(als) Freundlichkeit;(als) Morgengabe (fig.);(als) Gunstbeweis;(als) Freundschaftszeichen
-Wählton (fachspr.);Amtszeichen (fachspr.);Freizeichen (Hauptform);Amtsfreizeichen (fachspr.);Amt (ugs.)
-Freiton (fachspr.);Rufzeichen
-Besetzton;Besetzeichen
-reagiert nicht;(es gibt) kein Freizeichen;(es ist) nichts zu hören;(die Leitung ist) tot (Telefon)
-früher als gedacht;früher als geplant;früher als erwartet;vorzeitig;vor der Zeit
-im nicht-urbanen Raum;in der freien Landschaft
-im nicht-urbanen Raum;in der Fläche;in der freien Landschaft;abseits der (großen) Städte
-auf den Tag genau;taggenau
-angepeilte Größenordnung;angestrebte Zielgröße;Eckwert (Hauptform);(Zahl als) Zielvorgabe
-nicht können;vergeben sein (fig., scherzhaft);ausgebucht sein (ugs., fig.);verplant sein;schlecht sein (ugs., salopp);(etwas) vorhaben (terminlich) (ugs., Hauptform)
-außer Betrieb;nicht in Betrieb;abgeschaltet;down (ugs., Jargon);offline (engl.);nicht laufen (ugs.)
-Closed Shop (Jargon, engl., fig.);(ein) elitärer Zirkel;(eine) geschlossene Gesellschaft (fig.);exklusiver Club
-zum Greifen nah(e);(nur) eine Armlänge entfernt;keine Armlänge weit weg;direkt vor deiner Nase
-Runde;Tour;Rundgang
-(na) du bist mir (aber) eine! (ugs., weibl.);du bist mir ein Herzchen! (ugs.);(na) du bist mir vielleicht 'ne Marke! (ugs.);(na) du bist mir (aber) einer! (ugs., männl.)
-Vordereingang;Vordertür
-Hintertür(e);Hintereingang;Zugang von hinten
-Seiteneingang (Hauptform);Zugang von der Seite (her);Nebeneingang;seitlicher Eingang;Dienstboteneingang (auch figurativ)
-hintenrum;von hinten;von der Rückseite her
-an der (linken / rechten) Seite;seitlich;auf der (linken / rechten) Seite
-auf Kipp (gestellt / geöffnet) (Fenster);schräggestellt (Fenster);(senkrecht) gekippt
-(nur) angelehnt;einen Spalt (breit) geöffnet;nicht im Schloss (ugs.);nicht ganz zu (ugs.);einen Spaltbreit geöffnet;einen Spaltbreit offen;einen Spalt (breit) offen (stehen / sein);nicht ins Schloss gefallen
-halb geöffnet;halb offen
-sperrangelweit auf(stehen);weit auf (haben / sein / stehen) (ugs.);weit offen (stehen);sperrangelweit geöffnet
-nicht ungetrübt (sein / bleiben);überschatten (fig.);in Mitleidenschaft ziehen;eintrüben (Freude, Zuversicht, Aussichten) (fig.);verhalten ausfallen (Freude);(einen) Schatten werfen auf (fig.);auf die Stimmung drücken (fig.);dämpfen (Freude);beeinträchtigen
-(jemandes) Täterschaft beweisen können;(jemandem) eine Straftat nachweisen;(jemanden eines Vergehens) überführen
-schnappen;auffangen;fangen
-(jemanden) ertappen, als er gerade dabei ist, zu (...);auf frischer Tat ertappen;(jemanden) erwischen, wie er gerade (...);in flagranti erwischen;(jemanden) ertappen (bei)
-Meiner braucht sich nicht zu verstecken. (ugs., fig., verhüllend);(untenrum) gut bestückt (verhüllend);ordentlich was in der Hose haben (ugs., fig., verhüllend);von der Natur großzügig bedacht (geh., verhüllend)
-Tanzkaschemme (ugs., abwertend);Tanzbar (Hauptform);Budike (ugs., berlinerisch);Bumslokal (veraltet);Bumskneipe (veraltet)
-dekorativ (Hauptform);zieren(d);verzieren(d);sich gut machen(d) (ugs.);schmücken(d);verschönern(d)
-Wandtisch;Konsole
-Beistelltisch (Hauptform);Guéridon (historisch);Abstelltisch(chen);Nipptisch (historisch, selten);zusätzlicher (kleiner) Tisch (zum Anrichten, Servieren ...) (ugs.)
-Klapptisch (Hauptform);Falttisch
-Qadscharen;Kadscharen
-Mung Dal;Mungobohne;Lunjabohne;Mung Daal;Mungbohne;Jerusalembohne;Vigna radiata (fachspr., griechisch, lat.)
-(jemandem) Einlass gewähren;hereinkommen lassen;eintreten lassen;(jemandem) Zutritt gewähren;(jemanden) hereinlassen;(jemanden) eintreten lassen;(jemanden) vorlassen;(jemanden) einlassen
-(jemandem) den Vortritt lassen;(jemanden) vorlassen (ugs.);(jemanden) vorher drankommen lassen (ugs.)
-(jemanden bei ...) vorsprechen lassen;(in einer Angelegenheit) empfangen;(jemanden) vorlassen
-(jemanden) vorbeilassen;(jemanden) vorlassen;(jemanden) überholen lassen
-(jemandem) zuarbeiten;Vorarbeiten erledigen (für);unterstützend tätig werden (für)
-Antoniterorden;Antoniusorden
-Rollgerste;Kochgerste;Graupen;Gräupchen;Kälberzähne
-Beri-Beri;Thiaminmangelerkrankung;Kakke (japanisch);Beriberi
-auf den persönlichen Bedarf zugeschnitten;nicht vertretbar (fachspr., juristisch);nicht fungibel (fachspr., ökonomisch);auf den Einzelfall zugeschnitten;Sonderanfertigung;eigens (hierfür) entwickelt;nach Kundenwünschen gefertigt;(eine) individuelle Lösung;individuell angepasst
-(nur) schwer zu drehen;schwergängig (Hauptform);zäh (fig.);schwer zu bedienen;schwer zu bewegen;eingerostet;umständlich (zu bedienen)
-nicht abbiegen;dem Straßenverlauf folgen;auf der Straße bleiben;geradeaus weiterfahren;weiter geradeaus fahren
-internationales Recht;Völkerrecht;Internationales Öffentliches Recht
-die Erfahrung machen, dass;am eigenen Leib erfahren;(eine) Erfahrung machen;selbst erleben (dass);durch eigenes Erleben erfahren;(jemandem) eine Erfahrung (fürs Leben);(ein) Erlebnis haben;Erfahrungen machen
-(bei / aus etwas etwas anderes) lernen;(eine) Lehre ziehen (aus);(etwas) lehrt jemanden etwas (geh.);(die) Erfahrung gewinnen (dass);(in jemandem) reift die Erkenntnis (dass) (geh.);(etwas) mitnehmen aus (fig.)
-Fieseler Fi 103;Flügelbombe;V1;FZG 76
-Bankul-Nussbaum;Candlenut (engl.);Lumbangbaum;Lichtnussbaum;Kukuinuss;Kemirinuss;Kerzennuss;Aleurites moluccanus (fachspr., griechisch, lat.);Indische Walnuss
-alle zwei Jahre;im 2-Jahres-Abstand;biennal (geh.)
-Biennale;in zweijährigem Rhythmus stattfinden(d) (meist ein Kulturfestival)
-bienn (fachspr.);zweijährig (Pflanze) (fachspr., Hauptform);winterannuell (fachspr.)
-(bei der Post) aufgegeben;abgesendet;auf dem Postweg;raus(gegangen) (ugs.);verschickt;abgeschickt;versendet
-Musterklage;Musterfestellungsklage
-privates Beteiligungskapital;Private Equity (engl.);außerbörsliches Eigenkapital;Beteiligungsgesellschaft;Private-Equity-Gesellschaft (engl.);PEG (Abkürzung, engl.)
-Pauschalbetrag;Flatrate;Pauschalpreis;Pauschalsumme;Pauschale;Pauschaltarif;Preispauschale
-Trapezkünstler;Trapezakrobat
-Unschlittlicht (historisch);Unschlittkerze (historisch)
-ungebundener Lunarkalender;freier Lunarkalender
-(etwas ist) nicht zu toppen;Besser kann man es (einfach) nicht haben.;Es geht doch nichts über (...) (auch ironisch);Besser kann man es nicht treffen.
-(jemanden) behandeln wie ein rohes Ei (fig.);(jemanden) in Watte packen (fig.)
-anspruchsloser Film;(lahmer / lieblos gemachter / belangloser ...) Streifen;unbedeutender Film;Filmchen (abwertend, Hauptform)
-Umkehrrelation;inverse Relation
-auf seine Chance warten;auf einen günstigen Moment warten;auf eine günstige Gelegenheit warten;auf den Moment warten (wo / in dem / dass ...)
-erst (mit etwas) anfangen, wenn (jemand da ist);warten, bis (jemand da ist, und) dann;nicht anfangen, bevor (jemand da ist);(mit etwas auf jemanden) warten (Hauptform)
-(für etwas) keine Antenne haben (ugs., fig.);(mit etwas) nichts anfangen können (ugs.);(für etwas) keinen Sinn haben;nicht empfänglich (sein für) (geh.);(überhaupt) nicht wissen, was das (Ganze) soll (ugs., salopp)
-(jemanden) nicht berühren (fig.);(jemanden) unberührt lassen (fig.);(jemanden) kalt lassen (fig.);(an jemandem) abprallen (fig.);(jemanden) nicht (weiter) tangieren (fig.);(an jemandem) vorbeigehen (fig.);(jemanden) kaltlassen (fig.);nicht den Nerv (von jemandem) treffen (fig.);(jemanden) nicht (weiter) beeindrucken
-nicht die Richtige (für sich) gefunden haben;nicht den Richtigen (für sich) gefunden haben;(einfach) nicht zusammenpassen
-nicht als jemand gelten wollen (der);nicht als jemand dastehen wollen (der) (ugs.);(es/da) soll keiner nachher sagen (ugs., variabel);(sich) nicht(s) nachsagen lassen (wollen)
-Limes;Grenzwert
-Folge;Sequenz
-Geltendmachung;(rechtliche) Durchsetzung
-(etwas) fertigstellen;(eine Sache) durchziehen (ugs.);(etwas) zu Ende führen;(etwas) zu Ende bringen
-dranbleiben (mit/bei) (ugs.);(etwas) durchziehen (ugs., Hauptform);nicht lockerlassen (ugs.);dabeibleiben
-(etwas) als erledigt betrachten;(etwas) als erledigt ansehen;(eine) Sache ist (mit etwas für jemanden) erledigt
-(etwas) besiegeln;(etwas) formell bekräftigen;(sich etwas) feierlich versichern
-(etwas) beschwören;(sich) etwas schwören
-Hubzug;Seilzug;Greifzug;Mehrzweckzug;Luxemburger (landschaftlich);Habegger
-Zahnstangengewinde;Steckwinde
-kosmisch;galaktisch;astronomisch
-(das) Schweigen;Auskunftsverweigerung;(das) Verschweigen
-auferstanden aus Ruinen (fig.);wie Phoenix aus der Asche
-nicht liegenlassen;(vom Boden / Gehsteig ...) aufheben
-auf den Boden werfen;auf den Boden schmeißen (ugs., regional)
-(die) Mahlzeit beenden;(die) Tafel aufheben (geh.)
-beenden (Veranstaltung);aufheben (Sitzung);(förmlich) beenden;schließen (Versammlung)
-für eröffnet erklären;einleitende Worte sprechen;eröffnen (Diskussion, Sitzung ...)
-Van-Allen-Strahlungsgürtel;Van-Allen-Gürtel
-Sternenwind-Blase;Astrosphäre (griechisch)
-Sonnenwind-Blase;Heliosphäre (griechisch)
-Terminationsschock;Randstoßwelle
-die Leute hochscheuchen (ugs.);(das Ganze / die Leute) aufmischen (ugs.);(da ein bisschen) Leben reinbringen (ugs.);(das Ganze) mit Leben füllen (ironisierend);etwas Bewegung reinbringen (ugs.);Bewegung in eine Sache bringen
-Hallo Leute!;Hallo in die Runde!;Grüezi mitenand! (ugs., schweiz.);Tag zusammen! (ugs.);Hi, Folks! (ugs., Jargon, engl.)
-(und) grüß schön! (ugs.);(und) bestell' (Lea / ...) schöne Grüße (von mir)!;(und) schönen Gruß an (Lea / ...)!;(und) grüß (Lea / ...) von mir!
-(jemandes) Wege kreuzen sich (fig.);(jemandem) zufällig begegnen;(jemanden) zufällig treffen (Hauptform);(jemandem) vor die Füße laufen (fig.);(jemandem) über den Weg laufen;aufeinandertreffen;(jemandem) in die Arme laufen (ungewollt) (fig.)
-freitragend;ungestützt;selbsttragend (auch figurativ)
-verbaut;zugestellt;verstellt;zugebaut
-einigermaßen ansprechend;ganz okay (ugs.);keine Begeisterungsstürme auslösen(d) (variabel);nicht unbedingt hässlich;mäßig schön;schön ist anders (ugs., salopp);nicht schön, aber selten (ugs., ironisch);leidlich schön (geh.)
-Kinonacht;(lange) Filmnacht;lange Nacht des/der (...)
-Tonaufnahme;Bandaufnahme;Mitschnitt;Tonaufzeichnung;Aufzeichnung;Tonbandaufnahme;Phonogramm (fachspr.)
-handwerklich ungeschickt sein;keinen Nagel in die Wand schlagen können (ugs., fig.);zwei linke Hände haben (fig.);nicht zum Handwerker taugen
-nach wie vor aktiv;(im) Unruhestand (scherzhaft);noch aktiv
-Seelenlage;psychische Verfassung;seelischer Zustand
-(sich) mächtig ins Zeug legen (für);(sich) aufopfern (für);(sich) abrackern (für);seine Knochen hinhalten (für)
-Manhattan-Distanz;Taxi-Metrik;Mannheimer Metrik;Manhattan-Metrik
-klemmen;(sich) kaum bewegen lassen;kein (freies) Spiel haben;(sich) kaum schließen lassen;festhängen;schwergängig sein;kaum aufzubekommen sein
-festsitzen;(sich) verkeilt haben;(sich) verklemmt haben
-(etwas irgendwo) festmachen;(etwas irgendwohin) stecken;(etwas irgendwo) festklemmen;(etwas irgendwohin) klemmen
-Anarchistischer Kommunismus;libertärer Kommunismus;kommunistischer Anarchismus;Anarchokommunismus;freiheitlicher Kommunismus
-Bestand;Besatz
-(der) Wettex (Warenzeichen) (ugs., österr.);Schwammtuch;Spontextuch (Warenzeichen)
-Totenstille;Grabesruhe
-Chlormethan;Methylchlorid;R-40;Monochlormethan
-Benzidam;Benzenamin;Phenylamin;Benzamin;Aminobenzol;Anilin;Aminobenzen
-Nitrobenzen;Benzalin;Mirbanessenz;Nitrobenzol;Mononitrobenzol;Mirbanöl
-Razemat;Racemat
-2,3-Dihydroxybernsteinsäure;2,3-Dihydroxybutandisäure;Weinsteinsäure;Threarsäure;Acidum tartaricum (lat.);E 334 (fachspr., E-Nummer);Tartarsäure (veraltet);Weinsäure
-Wittling;Merlan;Weißling;Gadden
-(ein / der) Vorteil sein bei;gut sein an;das Gute sein an;sprechen für (Hauptform);ein Argument sein für
-Verständigung (fachspr.);Metakommunikation;Verständigung über die Verständigung als solche (geh.)
-Theben;Luxor
-Uräusschlange;Naja haje;Ägyptische Kobra
-übereinanderlegen;überschlagen (Beine);übereinanderschlagen (Hauptform);kreuzen (Beine);ein Bein über das andere legen
-(etwas) überschlagen (Hauptform);(grob) schätzen;(schnell) abschätzen;(schnell) zusammenrechnen (ugs.)
-(etwas) im großen Stil verkaufen;(einen) schwunghaften Handel (mit etwas) betreiben
-drücken (ugs., Jargon);(im Türverkauf) aufdringlich werben;aggressive Verkaufsmethoden anwenden;keilen (fachspr., Jargon)
-(sich) in bester Gesellschaft befinden (fig.);(mit etwas) wahrlich nicht allein dastehen (fig.)
-Autodafé (geh., selten);Bücherverbrennung
-Hinrichtung auf dem Scheiterhaufen;Ketzerverbrennung;Autodafé (geh., selten)
-an etwas ist zu viel Salz (ugs.);versalzen (Partizip/Adjektiv);zu stark gesalzen;zu viel Salz enthalten(d);es gibt zu viel Salz (an) (ugs.)
-Verschmitztheit;Bauernschläue;Pfiffigkeit;Schlitzohrigkeit;Gewieftheit
-Falle;Hindernis;dickes Brett, das gebohrt werden muss (ugs., sprichwörtlich);Schwierigkeit;Fußangel;harte Nuss (ugs., fig., sprichwörtlich)
-wetteifern (um);gewinnen wollen;(etwas) zu gewinnen suchen;buhlen (um) (geh., Hauptform);(sich) bemühen, etwas (für sich) zu gewinnen;(sich) bemühen (um);(etwas) zu gewinnen versuchen (variabel);konkurrieren (um)
-(sich) über Wasser halten (fig.);mehr schlecht als recht (s)ein Auskommen finden;(sich) durch sein Leben kämpfen;(sich) durchs Leben schlagen;(sich) recht und schlecht durchschlagen;(sich) durchschlagen;(sich) durchs Leben boxen
-(es) zu nichts bringen;(im Leben) nicht weiterkommen (fig., variabel);auf keinen grünen Zweig kommen (fig.);herumkrebsen (fig.);kein Bein auf die Erde kriegen (ugs., fig., variabel);(es) zu wenig bringen;nicht vorwärtskommen (fig., variabel)
-an nichts Anteil nehmen;im Dämmerzustand dahinleben;(sein) Leben in Passivität verbringen;dahindämmern (Hauptform);(seine Zeit) verdämmern;zu einem Leben in ... verdammt sein
-(Zeit) im Halbschlaf verbringen;dösen;dahindämmern;(Zeit) im Dämmerzustand verbringen
-freudestrahlend;hocherfreut;freudig strahlen(d);über das ganze Gesicht lachen(d)
-(sich) finden (fig.);herausfinden, was man (eigentlich) will;zu sich (selbst) finden
-vollendet sein (Bauwerk);abgeschlossen sein (Arbeiten, Ausbildung);vollständig ausgeführt;fertig vom Band rollen;fertig geworden;fertiggestellt (sein);abgedreht (Film) (fachspr., Jargon);fertig (sein);zu Ende geführt (sein);vollständig durchgeführt;beendet (sein)
-sofort (be)nutzbar;pfannenfertig (schweiz.);gebrauchsfertig;einsatzbereit;anwendungsbereit;betriebsfertig
-serienmäßig hergestellt;Standardprodukt;marktüblich;handelsüblich
-Verzwergung;Nanismus;Nanosomie
-Deszendenztheorie;Abstammungstheorie
-Mietskaserne (abwertend);Wohnkaserne;Mietkaserne (abwertend);Zinskaserne (österr.);Wohnblock
-Mietshaus;Zinshaus (österr.);Miethaus
-Chymiatrie;Iatrochemie;Chemiatrie;Chemiatrik
-temperieren;auf eine bestimmte Temperatur bringen
-Dexamethason-Hemmtest;Dexamethason-Suppressionstest
-Hyperinsulinismus;Hyperinsulinämie
-lau;schwach (Hauptform);leicht
-Bauchschmerzen haben (bei) (fig.);(sich) nicht ganz wohlfühlen (bei);ein ungutes Gefühl haben (bei);(jemandem) ist nicht ganz wohl bei (fig.)
-Winterkleid;Schlichtkleid;Ruhekleid
-neuartige Waldschäden;Waldsterben
-Lebensabschnitt;Kapitel (ugs.)
-Schwäbisches Meer (ugs.);Bodensee
-alles dies;all solches;dies alles (Hauptform);all dergleichen (geh.);all dieses (pronominal);all dies
-eingerostet (fig.);aus der Übung (gekommen) (Hauptform);ungeübt;nicht (mehr) im Training (auch figurativ)
-im Training bleiben (auch figurativ);in Form bleiben;in Übung bleiben
-im Training sein;(gut) in Form;(gut) trainiert
-Faunenprovinz (fachspr., zoologisch);Faunenreich (fachspr., zoologisch);biogeographische Großregion (kontinental);Florenreich (fachspr., botanisch)
-abgewirtschaftet haben;(von jemandem) ist nichts mehr zu erwarten (ugs.);ohne Rückhalt dastehen;(von jemandem) kommt nichts mehr (ugs.);nicht mehr handlungsfähig;am Ende sein
-Liegewagen;Couchette (schweiz.)
-Schlafwagen;WL
-Föttinger-Kupplung;Strömungskupplung
-Kommandozentrale;Headquarter (ugs., auch figurativ);Headquarters (fachspr., engl.);Hauptquartier
-Führungseinheit;Einsatzleitung;Führungsstab
-Hucke (ugs., ruhrdt.);Kate;Klause;kleines Haus;Kotten
-Schrottimmobilie;heruntergekommenes Haus;Loch;Bruchbude (abwertend, Hauptform);baufälliges Haus;armselige Behausung
-Kontrolllämpchen;Kontrolldiode;Leuchtsymbol;Kontrollleuchte
-Leuchtsymbol;Warnleuchte;Warnlämpchen (Hauptform)
-muffeln (ugs.);miefen (ugs., Hauptform);modrig riechen;riechen wie ein nasser Hund;müffeln (ugs., regional);abgestanden riechen
-(jemandem) einen Klaps geben;(jemandem) einen Schlag mit der flachen Hand geben
-aus unzuverlässiger Quelle;nicht überprüfbar;nicht belastbar
-Kadavermehl;Tiermehl;Tierkörpermehl
-Glykation;Glykierung
-von Haus zu Haus gehen;die Häuser abklappern;an jeder Tür klingeln
-um Einlass bitten;eintreten wollen
-Eigener Herd ist Goldes wert. (Sprichwort, veraltend);Dahoam is dahoam. (ugs., bayr.)
-Chikungunya;Gebeugter-Mann-Krankheit
-Ninpo;Ninjutsu
-Schattenkrieger;Ninja (japanisch);Shinobi (japanisch)
-chirurgische Klammer;Clip;Wundklammer;Drahtklipp;Klipp;Hautklammer
-ein unschönes Bild abgeben;(bei jemandem) nicht den besten Eindruck hinterlassen (variabel);unschön aussehen;sich nicht gut machen
-nicht dazu in der Lage scheinen (zu);ein desolates Bild abgeben;unfähig wirken;(sich) in einem desolaten Zustand präsentieren (variabel)
-Vorwort (Zeitschrift);Editorial (fachspr.)
-(sich) auf halbem Weg(e) treffen (fig.);(sich) auf halbem Weg entgegenkommen (fig.);(sich) entgegenkommen (fig.);(einen) Kompromiss finden
-für schlichte Gemüter (ugs.);platt (abwertend);simplifiziert;versimpelt;unterkomplex (geh.)
-Kryotechnik;Tieftemperaturtechnik;Kryogenik
-aussagen;zu Protokoll geben
-absolvieren;(längere Zeit irgendwo) sein (in einem Unternehmen, einer Institution...);(Dienst) ableisten;(Dienstzeit) abreißen (ugs., Jargon, negativ)
-was hat dich (denn) hierher verschlagen?;wie kommst du denn hierher?;was machst du denn hier?;du hier?
-nach dieser langen Zeit;nach so langer Zeit;nach dieser ganzen (langen) Zeit;nach all den Jahren (ugs.);nach all dieser Zeit (ugs.)
-i. H. v. (Abkürzung);in Höhe von
-ohne mich (selbst) allzu sehr loben zu wollen (variabel);ohne in Eigenlob zu verfallen;in aller Bescheidenheit
-vollgeparkt (sein);(es sind) alle Parkplätze belegt;mit Autos vollstehen (ugs.);zugeparkt (sein)
-(das) große Los ziehen;(einen) Glückstreffer landen (ugs.);(ein) Sechser im Lotto (fig.);sechs Richtige im Lotto (fig.);(richtig) Schwein haben (ugs.)
-(Preis) gewinnen (Hauptform);(Preise) abräumen;(Preis / ersten Platz) holen;(Pokal) nach Hause bringen (Jargon, Sportsprache, journalistisch)
-Hieroglyphen (ugs., fig.);nicht zu entziffern;nicht lesbar;unleserlich;unlesbar;nicht entzifferbar
-wird nicht erkannt;nicht lesbar (Datenträger, EC-Karte...)
-Umlaufsinn;Drehrichtung;Umlaufrichtung;Drehsinn
-rechtsdrehend;im Uhrzeigersinn;geodätisch positiver Drehsinn;mathematisch negativer Drehsinn
-mathematisch positiver Drehsinn;linksdrehend;gegen den Uhrzeigersinn;geodätisch negativer Drehsinn
-Karborund;Siliciumcarbid;Karborundum;Siliziumcarbid;Siliziumkarbid
-ungelöschter Kalk;Kalkerde;gebrannter Kalk;Freikalk;Branntkalk;Ätzkalk;CaO (chemisch);Calciumoxid
-Kalkwasser;Calciumhydroxid;Löschkalk;gelöschter Kalk;Ca(OH)2;Kalkhydrat;Weißkalkhydrat;Hydratkalk
-Kalkung;Kalkdüngung
-Gekrösstein;Calciumsulfat;Anhydritspat;Muriacit;Karstenit;Ca[SO4];Anhydrit
-Kontamination;Verschmutzung;Verseuchung;Verunreinigung
-vorsortieren;eine Vorauswahl treffen;(vorab) grob einteilen
-(sich) wacker geschlagen haben;mit Anstand verlieren
-Spott (Hauptform);Hohn und Spott;spöttische Bemerkung(en);Spöttelei(en);Hohn
-dann mal los! (ugs.);also dann ...! (auffordernd) (ugs.);na denn ...! (auffordernd) (ugs., norddeutsch);denn wollen wir mal! (ugs., norddeutsch);na dann ...! (auffordernd) (ugs.);dann wollen wir mal! (ugs.)
-Sandmeer;Sandwüste (Hauptform);Dünenwüste;Dünenmeer;Erg;Edeyen
-Hammada;Felswüste;Steinwüste
-(jemandem) nicht von der Seite weichen;(jemanden) keinen Schritt ohne Begleitung tun lassen;(jemanden) auf Schritt und Tritt begleiten
-Bungula;Rigilkent;Alphi Centauri;Rigil Kentaurus;Toliman
-Bauchbinde;Banderole
-dafür sorgen, dass (etwas) ein Ende hat;(einer Sache) ein Ende setzen;(mit etwas) Schluss machen
-(etwas) hinter sich lassen;(...) war(en) gestern;Schluss machen mit
-Zähigkeitskoeffizient;Volumenviskosität;zweite Viskosität
-Stauwasserboden;Staunässeboden
-nasser Waldboden;Staunässegley;gleyartiger Boden;Pseudogley;Staugley
-Silt;Schluff
-Alantin;Inulin;Alantstärke;Dahlin;Polyfructose
-wenig begeistert (über);nicht angetan (von);(jemandes) Begeisterung hält sich in Grenzen;wenig erfreut (Understatement)
-keine Substanz haben;nicht tragfähig (sein);(da ist) nichts dahinter (ugs.)
-unbestätigt;nicht belastbar (sein);(einer) Überprüfung nicht standhalten;haltlos
-Verschriftlichung;schriftliche Niederlegung;Textfassung
-Alphabetisierung (einer Sprache);Verschriftlichung;Verschriftung
-(das) Erlernen eines fremden Alphabets;Alphabetisierung;(das) Lesen- und Schreibenlernen
-(jemanden) alphabetisieren;(jemandem) Lesen und Schreiben vermitteln;(jemandem) Lesen und Schreiben beibringen
-die Schrift(sprache) beherrschen;lesen und schreiben können (ugs.);alphabetisiert sein
-Anteil von Personen (an einer Bevölkerung), die lesen und schreiben können;Alphabetisierungsrate;Alphabetisierungsgrad
-Anteil an Analphabeten (in einer Bevölkerung);Analphabetenquote
-(seine) Zeit opfern;(sich Zeit) um die Ohren schlagen
-Wahlschlappe;verlorene Wahl;Wahlniederlage;Wahldebakel
-Bienentrachtpflanze;Bienenweide
-Gyropter;Monocopter
-Unterwerfer;Bezwinger;Bezähmer;Besieger;Überwältiger
-breitenloser Nichtverbinder;Bindehemmer;Ligaturtrenner
-Strandräuber;Strandpirat
-enges Zeitfenster (Jargon);ohne Luft nach hinten (ugs., fig., variabel);ohne Puffer;äußerst knapp kalkuliert;ohne (zeitlichen / finanziellen) Spielraum;sehr knapp bemessen;terminlich sehr eng;auf Kante genäht (ugs., fig.);ohne (finanzielle / zeitliche) Reserven
-Mongolenfalte;Oberlidfalte;Epikanthus medialis (fachspr.);Epikanthus-Falte
-Ich muss gestehen (dass / ...) (floskelhaft);wenn Sie mich so fragen;wenn du mich so fragst;Ich muss ganz ehrlich sagen (dass / ...) (ugs., floskelhaft);da Sie es (ja) wissen wollen
-Arbeitsanfall;Arbeitsfülle (geh.);(die) Menge an Arbeit;Arbeitsaufkommen;viel(e) Arbeit (ugs.)
-(es gibt ein) freudiges Ereignis;(ein) gesundes Kind zur Welt bringen
-(sich) überlegen;(etwas) erwägen;(etwas) in Erwägung ziehen;denken (an);nachdenken (über);Überlegungen anstellen (+ indirekte Frage / + zu + Infinitiv)
-eigene Recherchen anstellen;eigene Untersuchungen in Auftrag geben;eigene Ermittlungen anstellen;selbst ermitteln;eigene Untersuchungen veranlassen;eigene Nachforschungen anstellen;selbst recherchieren;(einer Sache) selbst nachgehen
-Beanspruchung;Auslastung;Nutzungsgrad (fachspr.)
-Verkehrsschild;Verkehrszeichen (amtlich, offiziell);Straßensignal (schweiz.)
-(sich) nicht reißen (um) (ugs.);(etwas) nicht haben wollen (ugs.);nicht Schlange stehen (für / um zu) (fig.);nicht scharf sein (auf) (ugs.)
-Quarzporphyr;Rhyolith;Liparit
-Zündstein;Feuerstein (ugs.)
-(et)was von der Welt sehen;mal (richtig) rauskommen;(sich) den Wind ins Gesicht wehen lassen (fig.);(et)was erleben
-Freischiessen (schweiz.);Freischießen (regional);Schützenfest (Hauptform);Adlerschießen (regional);Vogelschießen (regional)
-(persönlich) wachsen;reifen;hinzulernen;an Statur gewinnen;reifer werden
-(sich) etwas nicht zweimal sagen lassen;(sich) nicht lange bitten lassen;(sich) nicht lumpen lassen;(sich) aufgerufen fühlen;(sich) nicht in Zurückhaltung üben
-Leitmedium;führende Zeitung;(eine) Referenz (fachspr.);meistzitiertes Printmedium
-(es wurde) lange nichts dran gemacht (ugs.);schlecht unterhalten;könnte mal einen neuen Anstrich vertragen (ugs., variabel);abgewohnt;reparaturbedürftig;verwohnt;renovierungsbedürftig;schlecht instandgehalten
-untereinander;im Vertrauen;unter sich (ugs.)
-man wird aufmerksam (auf) (floskelhaft);Beachtung finden (Hauptform);beachtet werden;auf sich aufmerksam machen (mit)
-Wassermokassinotter;Wassermokassinschlange;Agkistrodon piscivorus (fachspr., griechisch, lat.)
-Agkistrodon contortrix (fachspr., griechisch, lat.);Nordamerikanischer Kupferkopf
-(seinen) Blick nicht lassen können (von) (Hauptform);nur noch Augen haben für;(einfach immer) hinsehen müssen (zu) (ugs.);ständig herübersehen (zu);nicht aus den Augen lassen;äugeln (ugs.)
-zum Team gehören;mitmachen;mit dabei sein;zur Mannschaft gehören
-retten;zurückbekommen (ugs.);wiederherstellen (Daten, Dateien...) (Hauptform);wiederbekommen (ugs.)
-als letzter drankommen (ugs.);warten müssen, bis man an der Reihe ist;als letzter bedient werden;noch lange nicht dran sein (ugs.);(sich) hinten anstellen müssen (auch figurativ)
-(seinen) Blick geheftet haben (auf);nicht aus den Augen lassen;(jemandem / einer Sache) mit den Blicken folgen
-Korso;Autokorso
-leerräumen;nichts dalassen;ausräubern;räubern;ausräumen;ausplündern;plündern;alles mitnehmen (was nicht niet- und nagelfest ist)
-illustriert;mit Illustrationen;bebildert
-karrierebewusst;aufstrebend;will nach oben (ugs., fig.);strebsam;ambitioniert;zielstrebig;erfolgshungrig;karrieregeil (ugs., abwertend);ehrgeizig (Person) (Hauptform)
-Ghettofaust (ugs., Hauptform);Faustcheck (ugs.);Faustgruß
-High five (engl.);Einklatschen;Abklatschen
-Gib mir (die) 5! (ugs.);(Los,) High five! (ugs.)
-unterstützenswert;unterstützungswürdig
-gehen (in / auf) (ugs.);anstrengend sein (für);(eine hohe / erhebliche / große / ...) Belastung darstellen (für);ermüden lassen;belasten
-(jemandem) schlapp werden (ugs.);(jemandem) geht die Kraft aus;(jemanden) verlässt die Kraft (in);schlapp machen (ugs.);keine Kraft mehr haben (in)
-nichts in den Armen haben;Pudding in den Armen haben (ugs., fig.);nix inne Mauen haben (ugs., rheinisch, ruhrdt., veraltend)
-Gemeinschaftlichkeit;Miteinander;Zusammenleben;Miteinander-Klarkommen (ugs.)
-darauf warten, (wieder) zum Leben erweckt zu werden (fig.);im Dornröschenschlaf (liegen) (fig.);(irgendwo) ungenutzt verstreichen (Zeit);nicht genutzt werden;nichts passiert (bei / mit)
-(sich irgendwo) niedergelassen haben;lagern (Person) (Hauptform);(sich irgendwohin) gelegt haben;es sich gemütlich gemacht haben (ugs., ironisierend)
-...freundlich;(jemandem) entgegenkommend
-nach jemandes Bedürfnissen gestaltet;angepasst (an);zugeschnitten (auf);...gerecht;(gut) geeignet (für)
-...affin;...orientiert (Person);(...) angehaucht (Person);aufgeschlossen (für)
-das Wichtigste (im Leben) sein (für);nur für eins Interesse haben;die Hauptsache sein (für);jemandes einziges Interesse gilt (einer Sache);alles dreht sich (nur) um (bei jemandem) (ugs.)
-städtischer Bus;Linienbus;Stadtbus
-Überlandbus;Regionalbus
-Elektrobus;E-Bus;Akkubus;Batteriebus
-Strahlengleis;Fächergleis
-Schleuder;Blide;Tribok;Tribock;Trebuchet (franz.)
-Wasserpol;Pazifischer Pol der Unzugänglichkeit;Point Nemo
-(jemandem) auffallen (aufgrund von Erfahrung);einen Blick haben (für)
-Wählscheibe;Fingerlochscheibe (amtlich);Nummernscheibe
-Anschauungsmodell;Demonstrationsmodell;Vorführmodell
-Letzte Ölung (veraltet);Krankensalbung
-al dente (ital.);(noch) knackig (ugs.);bissfest
-zerkocht (negativ);breiig;weichgekocht
-ohne Rücksicht auf Verluste (fig.);mit der Abrissbirne (fig.);verbrannte Erde zurücklassen (fig.);radikal (vorgehen) (Hauptform)
-verpestet;verseucht
-(jemanden/etwas) zu sehen bekommen;(jemanden/etwas) zu Gesicht bekommen (Hauptform);(jemandes/einer Sache) ansichtig werden (geh.)
-zu erkennen sein;auszumachen sein;(jemanden/etwas) erkennen können;(jemanden/etwas) ausmachen können
-Goldblattpalme;Goldfruchtpalme;Areca-Palme;Areca lutescens (fachspr., veraltet);Dypsis lutescens (fachspr.);Chrysalidocarpus lutescens (fachspr., veraltet)
-Geschäftsessen;Arbeitsessen
-Standardrumpfflugzeug;Schmalrumpfflugzeug;narrow body airplane (engl.)
-wide-body airplane (engl.);Großraumflugzeug
-Einschüchterungsversuch;Abschreckungsversuch
-Einschüchterung;Abschreckung
-Komplexauge (fachspr.);Facettenauge
-planetarische Wellen;Rossbywellen
-symptomatisch (behandeln) (fachspr., medizinisch);nicht ursächlich (fachspr., medizinisch);kosmetisch (behandeln)
-Kolonienbildung;Kolonialisierung (eines Territoriums) (Hauptform, politisch);Kolonisierung
-nicht mehr kontrollierbar;nicht mehr beherrschbar;überhitzt (Markt, Konjunktur) (fig.);aus dem Ruder gelaufen (fig.)
-lässt sich Kritik gefallen;kritisierbar (Person);kritikfähig;aufgeschlossen für Kritik
-retuschieren;(Teile eines Bildes) löschen/überdecken/ändern
-Was war das (grade) für 'ne Nummer? (ugs.);Was sollte das (da) eben? (ugs.);Ich muss mich doch sehr wundern! (ugs.);Das war hoffentlich nicht dein Ernst! (ugs.)
-dran (sein) (ugs.);am Telefon (sein)
-falsch verbunden sein;(sich) verwählt haben
-nähertreten;näher herangehen
-erst (mal) ankommen;(sich) nicht sofort in die Arbeit stürzen
-(sich) hineinfinden (in);(sich) vertraut machen (mit);(etwas) kennenlernen
-Schnellstart-Leiste;Quick Launch (Bar) (fachspr., Jargon, engl.);Schnellstartleiste
-Schaltfläche (Hauptform);Button (Jargon, engl.)
-Startleiste;Task Bar (fachspr., Jargon, engl.);Taskleiste
-(etwas) anklicken;klicken auf
-Minenhund;Panzerabwehrhund (fachspr.)
-neue Freundin (weibl.);(neue) Eroberung (fig.);neuer Freund (männl.);(jemandes) neue Flamme (ugs., auch ironisch, fig.)
-frisch verliebt;neu verliebt
-Windfang;Vorraum
-(etwas) hinstellen;(etwas) aufrecht (hin)stellen;(jemanden) auf die Füße stellen;(etwas) stellen
-(etwas) legen;(etwas) flach hinlegen;(etwas) hinlegen
-Abspaltung;organisatorische Trennung;Ausgliederung;Weiterführung als eigenständige Firma;Auslagerung;Ableger;Ausgründung
-Halsbandsittich;Psittacula krameri (fachspr.);Kleiner Alexandersittich
-Großer Soldatenara;Ara ambiguus (fachspr.);Bechsteinara
-Ara militaris (fachspr., lat.);Kleiner Soldatenara
-Präsentator;Vortragender;Berichterstatter;Referent (ugs.)
-auf jemandes Bitten hin;auf Ersuchen von (geh.);auf Wunsch von;auf jemandes Ersuchen hin (geh.)
-getrennt leben(d);in Trennung leben(d);Noch-Ehemann (männl.);Noch-Ehefrau (weibl.);im Trenungsjahr (sein)
-große Leistung;bewundernswerter Akt (von/der/des ...)
-das Gute an etwas sehen;das Positive in etwas sehen;(etwas) positiv sehen;optimistisch herangehen (an)
-(jemandem) gewachsen sein;es aufnehmen können (mit);(gegen jemanden) ankommen (ugs.);(jemandem) beikommen (geh., veraltend);(mit jemandem) fertig werden (ugs.)
-(den) haben sich schon (...) erzählt;(der) Witz hat einen (sehr) langen Bart (variabel);Witz mit (soo einem langen) Bart (ugs.);alter Witz;abgedroschen (Witz);olle Kamelle (ugs.);Uralt-Witz
-Wirkung haben;Wirkung zeigen;ziehen (ugs.);funktionieren (ugs.);wirken;verfangen;anschlagen (Therapie);(den) gewünschten Effekt haben
-(jemandem/einer Sache) vertrauen können;(jemand/etwas ist) vertrauenswürdig (Hauptform);(jemandem/einer Sache) ist zu trauen;Vertrauen verdienen;(jemandem/einer Sache) trauen können
-nicht behalten;weggeben;(sich) trennen (von)
-(jemandem) ein Kind unterjubeln (ugs., negativ);(jemandem) ein Kind anhängen (ugs., negativ);(jemandem) ein Kind unterschieben (negativ);ungewollt zum Vater machen
-Natursprung;natürliche Besamung
-in (der) Pause sein;eine Pause machen;Pause haben (ugs.);Pause machen (ugs., Hauptform)
-(sich) aussprechen (gegen);(einen) gegenteiligen Standpunkt vertreten;gegen etwas seine Stimme erheben;gegen etwas Position beziehen;gegen etwas reden;gegen etwas Stellung beziehen;gegen etwas sprechen
-trinkfest (sein) (Hauptform);viel Alkohol vertragen können;einiges (an Alkohol) vertragen können
-leiden (Vertrauen);zweifeln (an);Schaden nehmen;Vertrauen verspielt haben (mediensprachlich, variabel);nicht mehr vertrauen (auf)
-toppen (ugs., Hauptform);die Krönung sein (auch ironisch);(noch) einen draufsetzen;krönen (fig.)
-(jemanden) um Haupteslänge überragen;einen Kopf größer sein
-angekündigt;von vornherein (feststehen, dass);vorausgesagt;prognostiziert;(bereits) im Vorhinein klar (ugs.);mit Ansage (ugs.)
-bereits vorab;von vornherein;im Vorhinein;schon vorher;bereits im Voraus
-davon ausgehen können;(sich etwas) an einer Hand abzählen können (ugs., fig.);nicht schwer vorauszusagen (sein);nicht schwer zu erraten (sein);(sich etwas) denken können
-Balance-Board;E-Balance Scooter;Mini-Segway;E-Board;Hoverboard
-gedämpft (Freude, Applaus);verhalten
-Treiber;Schallwandler;Wandler
-Parcours;Kurs
-Traumschlaf;REM-Schlaf
-teile und herrsche;divide et impera (lat.)
-rumstressen;stressen;Stress machen;Stress verursachen
-gendern;gendergerecht formulieren
-Keuschheitsgürtel;Florentiner Gürtel
-Musiklabel;Plattenlabel
-Fünfstern;Pentagramm (griechisch, Hauptform);Drudenstern;Drudenfuß;Pentakel;Pentalpha
-im Auge behalten;(mit)verfolgen;monitoren (Jargon)
-Artbildung durch räumliche Trennung;allopatrische Artentstehung;allopatrische Artbildung
-Artbildung;Speziation
-Pontischer Beifuß;Artemisia pontica (fachspr., griechisch, lat.);Römischer Beifuß
-Illicium verum (fachspr., botanisch, lat.);Sternanis;Echter Sternanis
-Sonnenwendegebiete;Tropen (griechisch)
-Fenchel (Hauptform);Frauenfenchel;Femis;Fenichil (althochdeutsch);Venekol (mittelniederdeutsch);Fenichal (mittelhochdeutsch);Wenchil (mittelniederdeutsch);Fenikl (österr.);Venecol (mittelniederdeutsch);Femkel (mittelhochdeutsch);Vencol (mittelniederdeutsch);Fenckel (mittelhochdeutsch);Fenchil (althochdeutsch);Venkel (mittelniederdeutsch);Enis (schweiz.);Fencol (mittelhochdeutsch);Brodsamen;Venichel;Foeniculum vulgare (fachspr., botanisch, lat.);Fengel (mittelhochdeutsch)
-Zitronenmelisse;Melissa officinalis (fachspr., botanisch, lat.);Melisse
-pflegebedürftig (sein) (Hauptform);(im Alltag) nicht (mehr) alleine klarkommen (ugs.);gepflegt werden müssen;auf Pflege angewiesen (sein);auf Hilfe angewiesen (sein)
-streng verboten;Ausgeburt des Bösen;Teufelszeug;des Teufels (sein) (geh., religiös, veraltend);Ausgeburt des Teufels;(eine) schwere Sünde;(für jemanden) tabu
-(jemanden) anloben (österr.);durch Eid verpflichten;(jemanden) angeloben (österr.);durch Eid binden;(jemanden) vereidigen
-(feierliche) Vereidigung;Fahneneid;(feierliche) Angelobung (österr.);Gelöbnis
-Propan-1,2,3-triol;E 422 (fachspr., E-Nummer);Glyzerin;Glycerol;1,2,3-Propantriol;Glycerinum;Propantriol;Glycerin
-(das) Funktionieren;Regelsystem;Grammatik (geh., fig.)
-Dama dama (fachspr., lat., zoologisch);Damhirsch;Damwild
-Tigerspinne;Zebraspinne;Seidenbandspinne;Argiope bruennichi (fachspr., griechisch, lat.);Wespenspinne
-neustarten;(einen) Neustart machen;herunter- und wieder hochfahren
-ausschalten;herunterfahren (Computer, Anlage);abschalten
-Drei Mächte (historisch);(die) Alliierten (historisch);Siegermächte (historisch);Vier Mächte (historisch);Besatzungsmächte (historisch)
-Achsenmächte (historisch);Achse Berlin-Rom-Tokio (historisch);Berlin, Rom und Tokio (historisch)
-Austritt Großbritanniens aus der EU;Austritt des Vereinigten Königreichs aus der europäischen Union;Brexit (Hauptform)
-Befürworter des Austritts (Großbritanniens aus der EU);Brexiteer;Brexit-Befürworter
-(sich) entwickeln;auftreten;aufkommen (Wind, Regen; Verdacht, Gerücht, Zweifel; Stimmung);entstehen;es kommt zu
-Bayreuther Festspiele;Grüner Hügel (fig.)
-Bayreuther Festspielhaus;Grüner Hügel (fig.)
-Schadstoffeintrag;Deposition (fachspr.)
-reich heiraten;(eine) gute Partie machen;Geld heiraten (selten);ins Geld heiraten (selten)
-verzehrfertig;mundfertig
-mundfertig;in Häppchengröße
-mit drin (ugs.);einbegriffen;inbegriffen;inklusive (sein);eingeschlossen;mit enthalten;mit erfasst;mit dabei
-äußerlich (betrachtet);von außen (gesehen) (variabel)
-Kombinationsvermögen;Kombinationsgabe;Kombinationsfähigkeit
-Liebesfrucht;Litsch;Chinesische Haselnuss;Litschi;Litschipflaume;Lychee (engl.);Litchi chinensis (fachspr., lat.)
-Erfahrung haben (mit);(jemand) muss es wissen (schließlich ...);(jemand) weiß, wovon er spricht
-ich hab da so meine Vermutungen (ugs.);man kann sich (schon) denken (+ indirekte Frage);ich will nicht wissen (+ indirekte Frage...)
-nach vorne;vor...
-ohne Vorabfestlegung(en);ergebnisoffen
-johlen;in (schallendes) Gelächter ausbrechen;(los)prusten;schallend (auf)lachen
-unbenutzbar;verbrannt (Wort, Begriff, Redewendung) (Neologismus, fig.);tabu;kompromittiert;belastet
-(mit etwas) lässt sich kein Hund hinter dem Ofen hervorlocken (fig., sprichwörtlich);auf kein Interesse stoßen;(einer Sache) nichts abgewinnen können (geh., variabel);(etwas) lockt keinen Hund hinter dem Ofen hervor (fig., sprichwörtlich);uninteressant sein (für);(jemand) kann (mit etwas) keinen Hund hinter dem Ofen hervorlocken (fig., sprichwörtlich)
-keinen Blumentopf gewinnen können (mit) (sprichwörtlich);wenig Aussicht auf Erfolg haben;wenig aussichtsreich (sein);(mit etwas ist) kein Blumentopf zu gewinnen (sprichwörtlich);nicht weit kommen (mit);nichts erreichen (werden)
-Oberschüler (ugs., veraltend);Schüler der gymnasialen Oberstufe;Oberstufenschüler (Gymnasium);Sek2ler (Gymnasium) (ugs., selten);Schüler der Sek II (am Gymnasium)
-Schüler der Sek I/Sek II;Schüler (an) einer weiterführenden Schule;Sekundarstufen-Schüler
-seiner Pflicht nachkommen;seiner Pflicht genügen (geh.);tun, was seines Amtes ist (geh.);seine Pflicht erfüllen;seinen Pflichten genügen (geh.);seinen Pflichten Genüge tun (geh.);seines Amtes walten (geh., auch ironisch);seine Pflicht tun
-(irgendwohin) sortiert werden;(irgendwohin) geraten;(irgendwo) landen (ugs.);(irgendwohin) geworfen werden;(irgendwohin) kommen;(irgendwohin) wandern (ugs.);(irgendwohin) gesteckt werden;(irgendwohin) befördert werden;(irgendwohin) gelangen
-(sich) geistig abmelden;(innerlich) aussteigen (ugs., fig.);nicht bei der Sache bleiben;nicht mehr bei der Sache sein
-wieder abbestellen;(wieder) aussteigen (ugs., fig.);stornieren;canceln (Abo, Vertrag) (engl.)
-wandeln (Kaufvertrag) (fachspr., juristisch, veraltet);widerrufen;zurücktreten (von einem Vertrag) (Hauptform);aussteigen (aus) (ugs., fig.);(wieder) canceln (ugs., engl.);rückabwickeln;annullieren
-nicht wieder aufführen;aus dem Programm nehmen;absetzen (Theaterstück, Sendung, Veranstaltung);canceln (ugs., engl.)
-aus dem Programm nehmen;absetzen (TV-Serie);einstellen;nicht weiter produzieren;nicht weiterführen
-denk nicht weiter darüber nach (ugs.);vergiss es (gleich wieder) (ugs.);(etwas ist / war) nur so'ne Idee (ugs.);nur laut gedacht haben (ugs.)
-Klafter;Nautischer Faden;fathom (engl.);Faden
-sei dabei! (werbesprachlich);bring dich ein!;beteilige dich!;mach mit! (Hauptform);komm du auch!
-Lobbyarbeit;Lobbyismus;Einflussnahme (durch Lobbyarbeit)
-Was machst du (zur Zeit)?;Was treibst du so? (ugs., salopp)
-Was machst du so? (ugs.);Womit verdienst du deine Brötchen? (ugs., Redensart);Womit verdienen Sie (so) Ihre Brötchen? (ugs.);(Und,) was machen Sie so? (ugs.);Was arbeitest du? (ugs.);Was machen Sie beruflich?
-(jemandem etwas) auftischen (unwahre Geschichte);präsentieren;ankommen (mit) (ugs.);(jemandem) kommen mit (ugs.)
-überwinden;in die Knie zwingen (Gegner) (fig.);bezwingen;stärker (gewesen) sein;besiegen (Krankheit);zum Aufgeben zwingen
-Lloyd (LP 300);Leukoplastbomber (ugs., scherzhaft)
-mit quietschenden Reifen anfahren (variabel);(einen) Kavaliersstart hinlegen (ugs., Hauptform, variabel);mit qualmenden Socken losdüsen (ugs., variabel)
-blau (aus dem Auspuff) qualmen;blau (hinten raus-) schmeißen (ugs., Jargon, fig., variabel)
-eine Herausforderung annehmen;(in einer Sache) Verantwortung übernehmen;versuchen, (einer Aufgabe) gerecht zu werden;sich (einer Sache) stellen
-(vor etwas) wegrennen (fig.);kneifen (vor) (Hauptform);(vor etwas) davonlaufen (fig.);(sich einem Problem) nicht stellen
-rausschmeißen (ugs.);ausstoßen (Qualm, Rauch, Gas);(aus)spucken (fig.);emittieren (fachspr.);speien (geh.)
-Rauch absondern;qualmen;Qualm machen;rauchen
-Ruß absondern;qualmen (ugs.);Ruß erzeugen;Ruß abgeben;rußen (Hauptform)
-(eine) Rechnung aufstellen (variabel);(jemandem etwas) vorrechnen;(etwas) mit Zahlen belegen;(etwas) zahlenmäßig untermauern
-mit (...);(...) enthaltend;...haltig
-ohne (...);...frei
-...frei;...los;ohne (...)
-Bein zeigen (ugs.);einen kurzen Rock tragen;ein kurzes Kleid tragen
-Folterer;Folterspezialist;Folterknecht
-höllische Schmerzen;Höllenpein;unerträgliche Leiden;unerträgliche Schmerzen;Höllenqual(en)
-Frontkamera (Smartphone);Selfie-Kamera (ugs.)
-Hauptkamera (Smartphone);rückseitige Kamera;Rückkamera
-keilförmiger Einschnitt;Scharte;(der) Kerb (fachspr.);Kerbe (Hauptform);v-förmige Aussparung
-zu jemandem halten;(jemanden) nicht fallen lassen;(jemanden) nicht vergessen;(jemandem / einer Sache) die Treue halten;(eine) treue Seele (sein);(jemandem / einer Sache) treu ergeben bleiben;bleiben (bei);(jemandem / einer Sache) treu bleiben
-Steckschlüssel;Nuss (ugs.)
-Knarre;Ratsche
-Pass gefälligst auf! (ugs.);Hier spielt die Musik! (ugs.)
-Elettaria cardamomum (lat.);Grüner Kardamom
-Blitzbefragung;Blitzumfrage
-die Meinung vertreten (dass);(sich) auf den Standpunkt stellen (dass);die Auffassung vertreten (dass)
-Speise der Götter;Ambrosia
-(die) Leitungsfunktion (innehaben);Leiterin (Hauptform);Dienstherrin;Chefin (ugs., auch figurativ);Vorsteherin;(die) Alte (derb);(die) Vorsitzende;Direktorin;(dienstliche) Vorgesetzte;(die) Nummer 1
-prinzipientreu (Hauptform);mit Rückgrat (fig.);prinzipienfest;gesinnungsfest (geh.)
-in Serie (fig.);jeden Tag neue(n ...);immer neue(r/s ...);(...) folgt auf (...);ein ... nach dem anderen;(...) auf (...) aneinanderreihen;eine ... nach der anderen
-es ist immer etwas los;es wird nicht langweilig
-Immobiliensachverständiger;Immobiliengutachter
-aus Prinzip;aus prinzipiellen Motiven;prinzipiell;aus prinzipiellen Gründen;ohne das (weiter) zu begründen (variabel);grundsätzlich
-Parlamentärflagge;Weiße Flagge;Weiße Fahne;Parlamentärsflagge
-(sich an einem Ort) gut auskennen;(einen Ort) kennen wie seine Westentasche;jede(n/s) (...) beim Vornamen kennen (fig., variabel);jeden Stein kennen
-Existenzialismus;Existentialismus
-Fluchtmigration (Amtsdeutsch);Flüchtlingskrise;Fluchtbewegung
-Raumspray (Hauptform);Lufterfrischer;Raumbedufter;Geruchsneutralisator;Raumdeo;Luftverbesserer;Raumlüfter
-nichts brauchen;alles haben (was man braucht);versorgt sein;(gut) eingedeckt sein
-Lichtverschmutzung;Lichtsmog
-Eselsohr (fig.);umgeknickte Ecke (Buchseite) (variabel)
-Absentismus (fachspr., lat.);gewohnheitsmäßiges Fernbleiben
-(in den Bahnhof) einlaufen;(in den Bahnhof / die U-Bahnstation) einfahren;(in den Hafen) einlaufen;(einen Ort) erreichen;ankommen
-Badearzt;Kurarzt
-Zwergpinscher;Rehpinscher
-beobachtet werden;unter Beobachtung sein (ugs.);(jemanden) unter Beobachtung haben;überwacht werden;unter Beobachtung stehen (Hauptform)
-unter Denkmalschutz stehen;unter Denkmalschutz gestellt sein
-unter Hausarrest stehen;das Haus nicht verlassen dürfen;Hausarrest haben (ugs.)
-(jemandem) verboten sein;(jemandem) untersagt sein;(etwas) nicht dürfen;(jemandem) nicht gestattet sein
-entgegen den Anweisungen;unerlaubterweise;widerrechtlich;illegalerweise;verbotenerweise;entgegen den Vorschriften;vorschriftswidrig
-nach (jemandes) Anweisung;(jemandes) Anweisung(en) folgend;weisungsgemäß (Hauptform);vorschriftsmäßig;vorschriftsgemäß
-erwachsen geworden (sein);reifer geworden (sein);kein Kind mehr (sein);aus dem Alter raus sein (ugs.);aus dem Alter heraus sein
-Trash-Film;Schundfilm (veraltend);Exploitationfilm (fachspr.);B-Picture (Jargon);B-Movie (Jargon);Trashfilm
-herumdeuteln (an);deuteln;heruminterpretieren (an);sinnverfälschend auslegen
-dementgegen;demgegenüber
-A.M. (Abkürzung);ab orbis conditi initio (lat.);orbis conditi (lat.);Jahr seit der Erschaffung der Welt;annus mundi (lat.);ab creatione mundi (lat.);anno mundi (lat.);Weltjahr;ab origine mundi (lat.);AM (Abkürzung)
-(eine) Schutzwehr;(ein) Bollwerk gegen (auch figurativ);(ein) Schutzwall gegen
-Schorf;Grind;Wundschorf
-(die) Mehrheit erreichen;(jemanden) überstimmen
-Quie;Beijst (norddeutsch);Kalbin;Guschti (schweiz.);Starke;Meis;Sterke;Quiene;Schumpe;Mänsche;Queen (norddeutsch);Beijste (norddeutsch);Manse;Schump;Queene (norddeutsch);Galtlig (schweiz.);Färse
-(jemandem) dicht folgen;(sich an jemanden) (d)ranhängen (ugs.)
-... aber schnell (jetzt) (Hauptform);... aber subito (ugs.);... aber pronto (ugs.);... aber flotti (ugs.);... aber zügig (ugs.);... aber zackig (ugs.);... aber schleunigst (ugs.);... aber dalli (ugs.);... und zwar (ein bisschen) plötzlich (ugs.);... und zwar (ganz) schnell
-Bahncard 100;Schwarze Mamba (ugs., Jargon, fig.)
-unter Wasser;unter der Wasseroberfläche
-ABC-Trieb;Hirschhornsalz;E 503 (fachspr., E-Nummer)
-Ammoniumcarbonat;E 503i (fachspr., E-Nummer);kohlensaures Ammonium;Diammoniumcarbonat;Englisches Riechsalz
-keine Chance haben;gar nicht erst anzutreten brauchen;auf verlorenem Posten stehen (fig.);die Arschkarte haben (ugs., salopp);es gar nicht erst zu versuchen brauchen;einpacken können (ugs., fig.);(schon) verloren haben (ugs.)
-einschlagen wie ein Blitz (sprichwörtlich);damit hatte niemand gerechnet;die Sensation des Jahres sein (variabel);ein Paukenschlag (sein) (fig.)
-zeitaufwendig;zeitintensiv;zeitaufwändig
-(das) kann so nicht bleiben;(etwas ist) kein Zustand (ugs.);etwas muss passieren;da muss (et)was passieren;es muss (et)was passieren;(es) kann nicht so bleiben (wie es ist);(es) besteht (dringender) Handlungsbedarf
-kommunale Leitungsebene(n);Stadtregierung;Führungsetage(n) der Stadtverwaltung;(die) Stadtoberen;Stadtväter (fig.)
-(sich an jemanden) dranhängen;(sich) an jemandes Hacken hängen;(sich) an jemandes Fersen klemmen;(die) Verfolgung aufnehmen (Hauptform);(sich) an jemandes Fersen heften;(sich) an die Fersen (von jemandem) hängen
-(etwas) kontrollieren;sagen, wie es zu laufen hat (ugs.);(etwas) beherrschen;am Drücker sein (ugs., fig.);kontrolliert werden von;(etwas) unter Kontrolle haben;(irgendwo) das Sagen haben (ugs.);unter jemandes Kontrolle stehen
-zurückfragen;(eine) Gegenfrage stellen
-Überalterung;Vergreisung
-Richtantenne;Richtstrahler;Richtstrahlantenne
-Küchensalbei;Heilsalbei;Garten-Salbei;Echter Salbei;Salvia Officinalis (fachspr., lat.)
-Christrose;Schneerose;Helleborus niger (fachspr., lat.);Schwarzer Nieswurz
-Ranunculaceum;Hahnenfußgewächs
-Oleum Cacao (fachspr., lat.);Kakaofett;Kakaobutter
-traumtänzerisch;tagträumerisch
-(etwas) allen Ernstes (tun);(etwas) in der ehrlichen Überzeugung tun
-nach allem, was passiert ist;nach alldem (ugs.)
-unausgesprochen;stumm (fig.);ohne Worte;ungesagt;stillschweigend;wortlos
-Gelegenheiten;Ausverkauf;Totalausverkauf;Räumungsverkauf;Sonderangebote;Schlussverkauf;Verkauf
-Rückschluss;Umkehrschluss;Gegenschluss
-Tor der Tränen;Bab al-Mandab (Hauptform)
-Kinderschänder;Kinderverzahrer (ugs., österr.)
-geeignet (zu / für);verwendbar;taugen (zu / für);einsetzbar
-gangränös (fachspr.);faulig;brandig
-Ich stehe zu Ihrer Verfügung.;Zu Diensten! (veraltet)
-kann ich Sie kurz sprechen?;hätten Sie kurz Zeit?;auf ein Wort (geh., veraltend);haben Sie einen Moment (Zeit)?;nur kurz:
-stimmt was nicht?;möchtest du (et)was sagen? (ugs.);ist was? (ugs.)
-sind Sie okay?;was haben Sie? (ugs.);was ist mit Ihnen?
-(jemandem) keine Steine in den Weg legen (Redensart);(jemandem) nicht im Weg(e) stehen (wollen) (Redensart)
-(sich) nichts Böses denken (bei);nichts Böses im Sinn haben (bei);keine bösen Absichten verfolgen (bei / mit)
-(es) fliegen die Fetzen;(sich) nichts schenken;(es) geht heftig zur Sache
-in Handgreiflichkeiten ausarten;(etwas) mit den Fäusten austragen;(es) kommt zu Handgreiflichkeiten
-(ich bin) derjenige, welcher ... (ugs.);(etwas) offen zugeben;(die) volle Verantwortung übernehmen;kein Geheimnis machen (aus);ich war's;(sich) schuldig bekennen (fig., scherzhaft-ironisch)
-ich über lasse ihn (jetzt) dir;er gehört (jetzt) dir (ugs.);du kannst jetzt. (ugs.)
-herbeibringen lassen;herbeiholen;einfliegen lassen;(jemanden) zu Hilfe holen (Hauptform)
-schon (einmal) gearbeitet haben (mit);(etwas) nicht zum ersten Mal machen;Erfahrung haben (mit);für jemanden kein Neuland sein;(sich) auskennen (mit);Ahnung haben (ugs.)
-in- und auswendig kennen;auf Du und Du (mit) (fig.);jedes Detail kennen;alles wissen (über);bestens kennen (Hauptform);von A bis Z kennen;kennen wie seine Westentasche;jedes Schräubchen (an / von etwas) kennen (ugs.);(sich) bestens auskennen (mit / in);in allen Einzelheiten kennen;perfekt beherrschen
-(eine) Lücke hinterlassen (fig.);(jemandem) fehlen;ohne jemanden auskommen müssen;(jemand) wurde gebraucht
-reicher Fischzug (fig.);fette Beute (fig.)
-Europäische Organisation für astronomische Forschung in der südlichen Hemisphäre;Europäische Südsternwarte;ESO (Abkürzung)
-Markenkern (Hauptform);(die) eigentlichen Inhalte;(das,) wofür jemand steht;Kernkompetenz (fig., Hauptform);(die) originären Aufgaben;(das,) wofür jemand angetreten ist
-Kernkompetenz;wichtigste Anforderung;essentielle Fähigkeit;(das,) was jemand können muss (ugs.)
-(das,) was jemand am besten kann;Hauptaufgabe;wichtigstes Tätigkeitsfeld;Kernkompetenz
-Hilfe ist unterwegs;(die) Rettung naht (scherzhaft-ironisch);es kommt Hilfe
-Milliarden werden versenkt (fig., variabel);Milliardengrab (Hauptform)
-Mürde;Hautwurm;Rotz;Malleus (lat.)
-(auf Menschen übertragbare) Tierkrankheit (fachspr.);(auf Menschen übertragene, ursprüngliche) Tierinfektion;Zoonose (fachspr., griechisch)
-Pflanzenwasser;Blütenwasser;aromatisches Wasser;Hydrolat
-Schichtsilikat;Blattsilikat;Phyllosilikat
-Kieselsäurensalz;Silikat
-Diatomeenerde;Kieselmehl;Tripolit;Tripel;Kieselguhr (veraltet);Novaculit;Bergmehl;Kieselgur;Diatomeenpelit;Diatomit;Celit;Infusorienerde
-Rootspumpe;Wälzkolbenpumpe
-Flüssigkeitsförderer;Pumpe
-Landfrieden;Constitutio pacis (lat.);Landfriede;Pax jurata (lat.);Pax instituta (lat.)
-wehmütig;sehnsuchtsvoll;wehmutsvoll;mit Wehmut;voller Sehnsucht
-(etwas ist) nur ein Gerücht;Nichts Genaues weiß man nicht. (ugs., Spruch);nur, was die Leute erzählen
-(die) Säle füllen (variabel);gut besucht (sein);(sein / ihr) Publikum finden
-auftrennen;(alte Stricksachen) aufziehen;aufribbeln (ugs., ruhrdt., veraltend);(Pullover) aufräufeln (ugs., regional);aufrebbeln (ugs., regional)
-wieder schwanger sein;(ein) Schwesterchen bekommen (Kindersprache);Zuwachs bekommen;(es gibt) Familienzuwachs;(ein) Brüderchen bekommen (Kindersprache)
-(jemandes) Größe (sein / haben);(jemandem) passen (Kleidung)
-(jemanden) anfeuern;(jemandem/einer Gruppe) einheizen;(jemandem) zujubeln;(Stimmung) anheizen;(jemanden) antreiben
-(sich etwas) zusammenfummeln (ugs., auch figurativ);(sich etwas) zurechtfummeln (ugs., auch figurativ);(sich etwas) hinbiegen (ugs., auch figurativ);(sich etwas) zurechtbiegen (ugs., auch figurativ);(sich etwas) zusammenbasteln (auch figurativ);(sich etwas) zusammenfriemeln (ugs., auch figurativ, regional)
-(eine) Stimmprobe machen;(sich) warmsingen;(sich) einsingen
-mit hohem ...bedarf;...hungrig (fig.);mit hohem ...verbrauch
-knapp daneben;beinahe getroffen;fast getroffen
-es geht (jemandem bei etwas) ums Prinzip;(etwas) ist (für jemanden) eine Frage des Prinzips
-abklatschen;(jemandem / sich) ein High Five geben (ugs., Jargon)
-nichts miteinander zu tun haben;voneinander unabhängig sein;es gibt (da) keinen Zusammenhang;in keiner Verbindung stehen
-Schmetterlingskind;Sternenkind;Engelskind
-kitschig gestaltet;zu Kitsch verarbeitet (variabel);verkitscht
-nie zu Ende (sein);immer wieder von vorn(e) anfangen (können / müssen);nie aufhören;Drehtüreffekt (fig.);(sich) im Kreis drehen (fig.);(in) Endlosschleife (fig.);immer (so) weitergehen;Sisyphusarbeit
-auf Troll-Kommentare antworten;auf Trollbeiträge eingehen;(einen) Troll füttern (ugs., Jargon, fig., Hauptform)
-Abend (geh., poetisch, veraltet);Westen (Himmelsrichtung);West (fachspr., meteorologisch, seemännisch)
-Fensterklammer;Fensterkeil;Fensterstopper
-(mit etwas) den Nagel auf den Kopf getroffen (haben) (Redensart);einen Volltreffer gelandet (haben) (fig.);(mit etwas) ins Schwarze getroffen (haben) (fig.);auf den Punkt genau das Richtige getroffen (haben);genau das, was jemand gesucht hat, gefunden (haben) (Hauptform);punktgenau das Richtige getroffen (haben)
-Facettenreichtum;Vielseitigkeit
-Limisso (türkisch, veraltet);Lemesos (griechisch);Limasol (türkisch);Theodosiana (griechisch, veraltet);Neapolis (griechisch, veraltet);Limassol (engl.);Leymosun (türkisch);Theodosias (griechisch, veraltet)
-Dannebrog (dänisch);dänische Nationalflagge;Danebrog (dänisch);Flagge Dänemarks
-Sauerkrauthaare (ugs., scherzhaft-ironisch);Minipli-Frisur
-seinen letzten Kampf kämpfen;mit dem Tod(e) kämpfen;im Sterben liegen;mit dem Tod(e) ringen
-pralle Sonne;volle Sonne
-jetzt geh schon!;ab durch die Mitte (mit dir / mit euch)! (ugs.);jetzt geh endlich!;raus mit dir (/ mit euch)! (ugs.);ab (irgendwohin) mit dir! (ugs.);Geh mit Gott, aber geh! (scherzhaft)
-(jemanden) hinterlassen (Todesfall);(jemanden) zurücklassen
-(was) in jedem Haushalt zu finden (ist);(was) in jedem Haushalt vorhanden (ist);Bordmittel (fig.);was (wohl) jeder (so) dahat
-Notfallwerkzeug;Notfallkoffer (Werkzeug);Bordwerkzeug;Bordmittel (auch figurativ)
-(jemandem) auf den Zahn fühlen (ugs., fig.);(jemanden) befragen;(jemanden) fragen;(bei jemandem) nachhören
-Chantalismus;Kevinismus
-Südkurdisch;Sorani;Zentralkurdisch
-(einigermaßen) fest sitzen (variabel);(sitzt,) passt, wackelt und hat Luft (Spruch, scherzhaft);halten (ugs.)
-nicht wiederkommen;wegbleiben;ausbleiben;(einen Ort) meiden;(jemandem) davonlaufen (Kunden);nicht mehr kommen
-Bio-Deutscher (Jargon, Neologismus);Deutscher ohne Migrationshintergrund;Biodeutscher (Jargon, Neologismus);kein Ausländer (ugs.);Urdeutscher;Altgermane (ugs., scherzhaft)
-(sich jemandem) in feindlicher Absicht nähern;(etwas) von jemandem wollen (ugs.)
-Böses im Schilde führen;(jemandem) Böses wollen;(etwas) mit böser Absicht tun;nichts Gutes im Schilde führen;(etwas) in böswilliger Absicht tun;(etwas) in böser Absicht tun
-(sich) bedrohlich (vor jemandem) aufbauen;(jemanden) bedrohen;(jemanden) einzuschüchtern versuchen;(eine) drohende Haltung einnehmen
-(sich) wehren;zurückschlagen
-(jemandem) (ein) Leid zufügen (veraltend);(jemandem etwas) zuleide tun;(jemandem etwas) antun (negativ);(jemandem) ein Leid(s) (an)tun (geh., veraltet);(jemandem) schaden;(jemanden) verletzen (auch figurativ);(jemanden) schädigen;(jemandem) einen Schaden zufügen
-Polaroid(-Kamera) (R) (Markenname);Sofortbildkamera
-AB-Nachricht (ugs.);auf Band gesprochene Nachricht (ugs.);Nachricht auf dem Anrufbeantowrter
-abgehen (Theater);abtreten (Theater)
-ablegen;den Hafen verlassen
-festmachen;andocken (Schiff)
-andocken;verkoppeln (mit);ankoppeln
-nicht Halt machen;nicht anhalten;vorbeifahren (an)
-landen;ankommen (Flugzeug)
-(sein) Ziel erreichen;ankommen
-(sich) verbinden (mit);(sich) anbinden;(sich) anheften (an) (fig.);(sich) ankoppeln (fig.);andocken (Virus) (fig., Hauptform);(sich) verkoppeln (mit) (fig.)
-(das) Musterexemplar (eines / einer guten z.B. Führungspersönlichkeit);ein Muster an (z.B. Gewissenhaftigkeit);ein Muster von einem (z.B. hilfsbereiten Schüler);(ein) leuchtendes Beispiel;die (ideale) Verkörperung eines (z.B. Naturwissenschaftlers);Leitfigur;der ideale (z.B. Teamchef);das Idealbild (eines / des z.B. perfekten Ehemanns);Vorbild (Person) (Hauptform)
-Falsifikationismus;Kritischer Empirismus
-Münzmeisterpfennig;Raitpfennig (süddt.);Rechenpfennig;Zahlpfennig
-rechtsläufig;dextrograd (lat.)
-(aus einem Raum / Gebäude) gehen;(einen Raum / ein Gebäude) verlassen
-niedrig;nichtswürdig (Gesinnung);verachtenswert
-Unschärfekreis (fachspr.);Zerstreuungskreis (fachspr.)
-(jemandem jemanden) empfehlen;(jemanden) weiterempfehlen;(jemandem von jemandem) empfohlen werden;weiterempfohlen werden
-der wird (schon) wieder;der wird sich (schon) wieder berappeln;der wird (schon) wieder zu sich kommen
-überlegen Sie doch mal;schauen Sie (mal) (süddt.);überleg doch mal;sieh mal (nachsichtig erklärend);sehen Sie;versteh doch;(so) verstehen Sie doch;schau mal (süddt.)
-Pastille;Schmelztablette (fachspr.);Lutschtablette
-Dragee;Filmtablette
-Wir melden uns.;Sie hören von mir.
-kein schlechtes Gewissen haben (bei);ruhigen Gewissens (tun);mit gutem Gewissen (tun)
-grellrot;leuchtend rot;blutrot;feuerrot;knallrot
-feuerwehrrot (ugs.);signalrot (fachspr.);leuchtrot (fachspr.);neonrot
-herausgreifen;aus dem Zusammenhang lösen;isoliert betrachten
-herausgreifen;exemplarisch beleuchten;im Einzelnen näher betrachten
-zweckorientiert;zielgerichtet;zweckgerichtet;nutzenorientiert
-Man merkt die Absicht und (man) ist verstimmt.;(nur) allzu offensichtlich (sein);Man fühlt die Absicht und (man) ist verstimmt. (Zitat, variabel)
-Quoten...;Kontingent...
-Königsmacher (fig.);Zünglein an der Waage (der Macht) (fig.)
-wahlentscheidend (sein);(bei einer Wahl) den Ausschlag geben
-vorläufig (Adjektiv);einstweilig (Amtsdeutsch)
-Silberbesteck;Tafelsilber (auch figurativ);Familiensilber
-Flugboot;Wasserflugzeug
-(die Leute) machen lassen (ugs.);(etwas) einreißen lassen;nicht einschreiten (bei);(jemandem / einer Sache) nicht Einhalt gebieten (geh.);nichts sagen (gegen) (ugs.);(etwas) nicht gleich verbieten (ugs.);(die Leute) gewähren lassen (ugs.);(etwas) nicht unterbinden;nicht sofort etwas unternehmen (gegen) (ugs.)
-Es kreißte der Berg und gebar eine Maus. (Zitat, sprichwörtlich);Viel Geschrei und wenig Wolle. (Redensart);gemessen am Aufwand (...) enttäuschen(d)
-(Recht auf) Anhörung;(Anspruch auf) rechtliches Gehör
-Anhörung;Hearing (engl.)
-regionale Spracheigentümlichkeit;Regionalismus;regionaler Sprachgebrauch
-Fingerabdruck;Papillarleistenmuster;Dactylogramm (fachspr.)
-Veranstaltungskalender;Veranstaltungsprogramm
-ich finde allein(e) raus;ich kenne den Weg
-großen Respekt haben (vor) (variabel);die Hacken zusammenschlagen (vor) (fig.);nicht aufmucken;strammstehen (vor)
-Tankkarte;Flottenkarte
-mit Feuer und Flamme dabei sein (Redensart);(jemandes) größte Leidenschaft (sein);(sich) leidenschaftlich engagieren (für);brennen (für) (fig., floskelhaft)
-begeisterungsfähig;(leicht) zu begeistern
-ISO 639;Language Code (engl.);Sprachkürzel;Sprachencode;Sprachcode
-Deal! (Jargon, engl.);Abgemacht! (Handel);Es bleibt dabei!;Es gilt!;Die Sache gilt!;Einverstanden!
-in (z.B. Rot) gehalten;in (z.B. roten) Farbtönen (gehalten)
-die hier lebenden ... (z.B. Japaner);Gemeinde;die dort lebenden ... (z.B. Marokkaner);(ausländische / ethnische) Community (engl.);Bevölkerungsanteil (statistisch);(ausländische) Diaspora
-Vorspann;Intro
-Cold open (Fernsehserie) (fachspr., engl.);Prolog (Fernsehserie)
-(so) jemand wie ich (ugs.);Leute wie ich;Menschen wie ich;Leute meines Schlages;so welche wie ich (ugs.);(so) einer wie ich (ugs.);meinesgleichen
-Menschen wie er;Leute wie er;Leute seines Schlages;so welche wie er (ugs.);(so) jemand wie er (ugs.);(so) einer wie er (ugs.);seinesgleichen
-(jemanden) zu überzeugen versuchen;versuchen, (jemanden) zu überzeugen;Überzeugungsarbeit leisten
-Zahnlücke der (oberen) Schneidezähne;Diastema (mediale) (fachspr.);Margo interalveolaris (fachspr.);Affenlücke (derb, stark abwertend)
-Mehrfunktionalität (fachspr.);Synkretismus (fachspr., Hauptform);Formengleichheit (fachspr.);morphologische Unterspezifikation (fachspr.);Formenzusammenfall (fachspr.)
-wo denken Sie hin!;Blödsinn! (ugs., salopp);erzählen Sie mir nichts!;geh mir doch weg! (ugs., regional);Unsinn! (ugs.);wie kommen Sie denn darauf!;wer hat dir denn den Blödsinn erzählt? (ugs., variabel);red doch ned so saublöd daher! (derb, süddt.);ach woher! (ugs.);ah geh! (ugs., bayr.);das glauben Sie doch selbst nicht!;Quatsch mit Soße! (ugs., berlinerisch);totaler Quatsch! (ugs.);aber geh! (ugs., süddt.);wer hat dir denn sowas erzählt! (ugs.);Reden Sie keinen Unsinn! (ugs.);i wo! (ugs., bayr.);das wüsste ich aber! (ugs., Spruch);wer hat Ihnen denn das erzählt!;Red keinen Unsinn! (ugs.);das glaubst du doch selbst nicht!;erzähl mir nichts! (ugs.);wie kommst du denn darauf!;ach was! (ugs.);wo denkst du hin!
-hinüber (derb);tot (sein);(jemand) hat es hinter sich (derb, Spruch);mausetot (ugs.);(jemand) hat's nicht geschafft (ugs., Spruch)
-noch leben;noch Lebenszeichen von sich geben;(noch) am leben sein
-(etwas) in den Mittelpunkt rücken;(etwas) in den Mittelpunkt stellen;ausführlich eingehen (auf)
-Hauptanliegen;wichtigste Botschaft
-(kurz) reinsehen (in) (ugs., norddeutsch);(sich etwas) kurz ansehen;(mal) reinschauen (ugs., norddeutsch);(ein paar) Seiten lesen;(kurz) die Nase reinstecken (ugs., fig., norddeutsch);(kurz) hineinschauen;(ein Buch) anlesen;(mal) reinblättern (in) (ugs., norddeutsch);(kurz) die Nase hineinstecken (fig.)
-überfliegen;verschlingen;(durch etwas) jagen (ugs., fig.);schnell lesen
-keinen praktischen Bezug haben (zu);(sich etwas) anlesen;(etwas) nicht aus der Praxis kennen;sein Wissen nur (aus) Büchern beziehen
-es ist Land in Sicht (fig.);es bald geschafft haben;bald durch sein (mit) (ugs.);das Ende ist abzusehen
-Bewusstsein von Recht und Unrecht;moralischer Kompass (fig.);Unrechtsbewusstsein;Gewissen (Hauptform)
-wissen, wie's gemacht wird;den Dreh raushaben (ugs.);ein Profi sein;wissen, worauf es ankommt;Profis sein;dem brauchst du nichts (zu) erzählen (ugs.);denen brauchst du nichts (zu) erzählen (ugs.)
-zum Ende hin;gegen Ende
-(jemandes) verlängerter Arm (fig.);(jemandes) Weisungsempfänger;(lediglich jemandes) ausführendes Organ
-(ich denke,) wir sind hier (jetzt) fertig.;Ist gut jetzt!;(Das) Gespräch ist beendet.;Schluss jetzt!;Es reicht jetzt.;Lass (es) gut sein.
-wallah (ugs.);ich schwör' (ugs., jugendsprachlich);vallah (ugs.);echt (ugs.);..., (also) ich sag' dir ... (ugs., floskelhaft);wirklich
-miteinander warm werden (fig.);das Eis brechen (fig.);die Anfangsscheu verlieren
-(die) anfängliche Ängstlichkeit ist verflogen;(die) anfängliche Zurückhaltung ist überwunden;(die) anfängliche Scheu verloren haben;(das) Eis ist gebrochen (fig.);(alle) anfängliche Schüchternheit ist abgelegt
-(das) Kennenlernen;erster Kontakt;erstes Kennenlernen;Erstkontakt
-Efeutute;Goldene Efeutute;Epipremnum aureum (fachspr., botanisch, griechisch, lat.)
-Bogenhanf;Sansevieria trifasciata (fachspr., botanisch, griechisch, lat.);Schwiegermutterzunge (ugs., scherzhaft);Beamtenspargel (ugs., scherzhaft)
-Spathiphyllum (wallisii) (fachspr., botanisch, griechisch, lat.);Scheidenblatt;Blattfahne;Friedenslilie;Einblatt
-vergessen machen;hinwegtrösten (über);entschädigen (für)
-(schon) mittendrin;mit Feuereifer dabei;schwer zugange (mit) (ugs., ruhrdt.);fleißig dabei;voll in Action (ugs., engl.)
-(auf jemandes) Namen laufen (ugs.);(auf jemanden) laufen (ugs.);(auf jemandes) Namen registriert sein;(auf jemanden) angemeldet sein
-Programmankündiger (ugs., selten);Fernsehansager;Programmsprecher
-wenig beachtet;unauffällig;unbeachtet;unscheinbar
-Marktnische;Marktlücke
-nicht marktgängig;Nischenprodukt;wenig nachgefragt
-nur von wenigen (z.B. benutzt) werden (variabel);(ein) Nischenphänomen bleiben;(sich) nicht durchsetzen
-(sich) belasten (mit);(sich etwas) an den Hals hängen (ugs., fig.);(etwas) (zusätzlich) übernehmen (ugs.);(sich etwas) ans Bein binden (ugs., fig.);(sich etwas) aufbürden (fig.);(sich etwas) aufhalsen (fig.);(etwas) auf sich nehmen
-Erichs Dröhnung (ugs., historisch);Edescho (ugs., historisch);Kaffee-Mix (historisch);Erichs Devisenschoner (ugs., historisch)
-(auf jemandes) Mist gewachsen (sein) (ugs., fig.);auf jemandes Kappe gehen (ugs.);(etwas) zu verantworten haben;(etwas) verzapft haben (ugs.);Schuld sein (an)
-das Feuer erwidern;zurückschießen
-Kazoku-neko (japanisch);japanische Stummelschwanzkatze;Japanese Bobtail (engl.)
-klare Kiste! (ugs., regional);(Das ist eine ganz) klare Sache.;(Da gibt's) kein Vertun. (ugs.);eindeutig (sein);Da gibt's nichts zu diskutieren.
-(das) Kopfballungeheuer (ugs.);Schädel;Horst Hrubesch (Eigenname)
-empirische Standardabweichung;Stichprobenstreuung;Stichprobenstandardabweichung
-empirisches Streuungsquadrat (veraltet);Stichprobenvarianz;empirische Varianz
-Quartilsabstand;Interquartilsabstand
-Dispersionsmaß;Streuungsparameter;Streuungsmaß
-Hoover-Koeffizient;Segregations- und Dissimilaritätsindex;Balassa-Hoover-Index;Hoover-Index;Hoover-Ungleichverteilung
-Herfindahl-Hirschman-Index;Hirschman-Index;Herfindahl-Index
-Konzentrationskoeffizient nach Rosenbluth;Rosenbluth-Index
-(das) Klicken;klick;Klickgeräusch;(ein) Klick
-Lagemaß;Lageparameter
-Variationsfaktor;Dispersionsindex
-Verteilungstest;Anpassungstest
-Holzriss;Holzstich
-Xylografie;Xylographie
-Abgeschiedenheit;Sich-Zurückziehen;Zurückgezogenheit
-unter Spannung;angespannt;unter Dampf (stehend) (fig.);angestrengt;belastet;unter Druck (stehend);mit vollem Einsatz;unter Belastung
-heliozentrisch;mit der Sonne im Mittelpunkt
-mit der Erde im Mittelpunkt;geozentrisch
-auf ein geteiltes Echo stoßen;(die) Reaktionen (auf etwas) fallen unterschiedlich aus
-an das Kopfende;am Kopfende;vorn(e);vor Kopf (fachspr., Jargon);an die Stirnseite;an der Stirnseite
-an die Wand fahren (Unternehmen) (fig.);(ein Unternehmen) herunterwirtschaften;in den Ruin führen;zugrunde richten;in die Insolvenz führen;(wirtschaftlich) ruinieren;schlecht führen;in die Pleite führen
-(ein Gut) herunterwirtschaften;verkommen lassen;verwahrlosen lassen;schlecht unterhalten
-empfängnisbereit;östrisch (fachspr.)
-Trächtigkeit (zoologisch);(das) Trächtigsein
-Tragzeit;Dauer der Trächtigkeit;Tragezeit
-Rausche (Schwarzwild) (fachspr., Jägersprache);Rauschzeit (Schwarzwild) (fachspr., Jägersprache);Brunft;Brunst;Paarungszeit (Hauptform);Balz (Vögel);Blattzeit (Rehwild) (fachspr., Jägersprache)
-Kuder (Wildkatze) (fachspr., Jägersprache);Kater (Hauptform);männliche Katze
-(Konkurrenten) verbeißen (auch figurativ);wegbeißen (auch figurativ);(aggressiv) vertreiben
-Frage nach der Verantwortlichkeit;Schuldfrage
-Schuldgeständnis;Schuldbekenntnis;Schuldanerkenntnis;Schuldeingeständnis
-(jemandem gut /arg / übel ...) ergehen;(positive / schlechte / unerfreuliche ...) Erfahrungen machen;(Gutes / Schönes / Schlechtes ...) erleben
-eine gute (schöne / schlechte / ...) Zeit haben;(es ... jemandem gut / schlecht ...) (er)gehen;es gut (schlecht / ...) haben
-Unschuldiger;Unbeteiligter
-Vorzeichen (Hauptform);Vorbote;Alarmsignal;Warnzeichen
-Schwarz-Nachtschatten;Solanum nigrum (fachspr., lat.);Schwarzer Nachtschatten
-Satz von Bernoulli;Bernoulli-Gleichung;Gesetz von Bernoulli;Strömungen nach Bernoulli und Venturi
-Alpinenhaus;Alpinhaus
-Troparium;Tropikarium;Tropenhaus
-Orientalis (lat.);Orientalische Region
-Riesengleiter;Gleitflieger;Flattermaki;Pelzflatterer;Colugo
-Adiabatenexponent;Wärmekapazitätsverhältnis;Isentropenexponent
-Südlicher Glattwal;Südkaperwal;Eubalaena australis (fachspr., griechisch, lat.);Südkaper
-(sich etwas) sagen lassen;auf jemanden hören;Lehre annehmen (ugs., selten, veraltend);auf andere hören
-Torx;Innensechsrund
-Robertson-Schraube;quadratische Innenvierkant;Scrulox
-Innensechskant;Inbus;Imbus (fälschlich);Allen key (engl.);Hex key (engl.)
-Radsicherung;Radschraubensicherung;Sternschraube;Radsicherungsbolzen;Felgensicherung;Felgenschloss
-Lämmergeburt;Ablammen
-Beleuchtungsstärke;Lichtstromdichte
-töten;abkrageln (Huhn etc.) (ugs., österr.);umbringen;den Hals umdrehen (ugs.)
-Kugelsektor;Kugelausschnitt
-Kugelschicht;Kugelzone
-(sich) nicht (groß) bemerkbar machen;(sich) nichts anmerken lassen;nicht hervortreten;nicht bemerkt werden;keine Aufmerksamkeit auf sich ziehen;die Füße stillhalten (ugs., fig.);kein Aufsehen erregen;nicht auffallen;(sich) unauffällig verhalten
-Reibeisenstimme (fig.);raue Stimme
-Irisch;irische Sprache;Irisch-Gälisch
-Bauchspeicheldrüsenkrebs;Pankreaskarzinom (fachspr.)
-Gallengangskarzinom;Cholangiokarzinom (fachspr.);cholangiozelluläres Karzinom (fachspr.)
-Gallengang;Gallenweg
-Lebermetastase;Leberfilia (fachspr.)
-Darm-Leber-Kreislauf;enterohepatischer Kreislauf
-Gerinnungsstörung;Koagulopathie (fachspr.)
-Luser (fachspr., Jägersprache);Lauscher (fachspr., Jägersprache);Ohrmuschel
-(jemandem) einen begeisterten Empfang bereiten;(jemanden) begeistert empfangen;(jemandem) den roten Teppich ausrollen (fig.)
-(es) sich aussuchen können;(sich) vor Angeboten nicht retten können
-freier Blick (auf);nicht zugebaut;unverbaut
-Krematorium;Feuerbestattungsanlage
-Sprunginnovation;disruptive Innovation
-Gullyfliege;Mottenmücke;Herzmücke;Schmetterlingsmücke;Abortfliege
-Poller;Pömpel;Pfosten;Hafenpoller
-Traumdeutung;Oneirologie (griechisch)
-Mankei (bayr., österr.);Murmeltier;Munggen (schweiz.)
-den Zeitpunkt verpassen (fig.);(etwas) verschlafen (fig.);(etwas) verpennen (ugs., salopp)
-Clownfisch;Clownsfisch (fälschlich);Anemonenfisch
-(sich) in Lobeshymnen ergehen;(sich) begeistert äußern;schwärmen (von)
-(einen) (zu) niedrigen Wert ansetzen;herunterrechnen;schönen (Zahlen) (Jargon);(künstlich) niedrig bewerten;kleinrechnen (Bilanz, Statistik);schönrechnen;runterrechnen (ugs.)
-Kleinkrieg (fig.);Zermürbungskampf;dauernder Streit;endlose Auseinandersetzungen
-sofort einsatzbereit;out of the box (IT-Technik, engl.);gebrauchsfertig enthalten
-(jemanden) vorantreiben;zur Eile treiben;(jemanden) treiben;(jemanden) antreiben;aufs Tempo drücken (bei);(jemanden) vorwärtstreiben
-tiefsitzend;tief verwurzelt
-(sich) hartnäckig halten;tief sitzen (Gefühl)
-(sich jemandem) (fest) eingebrannt haben;(sich) (tief) in jemandes Gedächtnis gebrannt haben;(sich jemandem) tief eingeprägt haben
-Schmiedeeisen;Frischeisen;schmiedbares Eisen;Schweißeisen
-(einer Sache) weichen;Platz machen (für)
-ausgeflogen (sein);(das) Nest verlassen haben
-(noch) unerwachsen;(noch) nicht geschlechtsreif;(noch) nicht paarungsreif
-einjährig (ugs.);im letzten Jahr geboren;noch kein Jahr alt (ugs.)
-im Jahr davor geboren (ugs.);im zweiten Lebensjahr;Jährling (Tier, meist Huftier);im letzten Jahr geboren (fachspr.);aus dem Jahr davor (sein) (ugs.);ein Jahr alt
-nicht meine Welt (sein) (ugs.);nicht warm werden (mit) (ugs.);nicht geschaffen sein (für);(jemandem) fremd bleiben
-Sagarmatha (nepalesisch);Tschomolangma (tibetisch);Mount Everest (engl.);Chomolungma (engl., tibetisch);Mt. Everest (engl.)
-völlig Fremder;wildfremde Person;Wildfremder (Hauptform);irgendeine dahergelaufene Person;irgendwer;völlig Unbekannter
-neue(/r/s) ...;Neuer;Neuzugang;Neuankömmling
-uneingeweiht;nicht eingeführt;außenstehend;nicht vorgestellt
-schlüsselfertig;bezugsfertig;sofort beziehbar
-angestrengt (fig.);bemüht
-Komplettpaket;Out-of-the-box-Lösung (fachspr., Jargon, engl., fig.);schlüsselfertige Lösung;Auspacken und loslegen! (ugs., werbesprachlich);Fertigprodukt (fig.)
-erster Fronteinsatz;Feuertaufe (fig., Hauptform);erste Frontbewährung;erster Kampfeinsatz
-Aufschieber;Prokrastinierer
-an die Regierung kommen;die Regierung übernehmen;an die Macht kommen;die Macht ergreifen;die Führung übernehmen;an die Macht gelangen;ans Ruder kommen
-(die) Macht innehaben;an der Macht sein (Hauptform);regieren;(die) Macht ausüben;am Ruder sein (fig.);an den Schalthebeln der Macht sein
-(die) Macht ergreifen;(die) Macht usurpieren;(die) Macht an sich reißen
-(etwas) greifen (können);(etwas) packen (können);(etwas) zu packen bekommen;(etwas) zu fassen bekommen
-(den) Rest besorgen (fig.);(einer Sache) den Todesstoß versetzen;(einer Sache) den letzten Rest geben
-Fahrkartenschalter (ugs.);Schalteranlage;Reisezentrum (fachspr., Jargon, werbesprachlich);Fahrkartenverkauf
-Medium;(eine) Brücke (fig.);(das) Band (fig.);(das) Verbindende;verbindendes Element
-Massenmedium;Medium mit großer Verbreitung
-Kofferkuli;Gepäckwagen
-Einkaufsrolli;Hackenporsche (ugs., scherzhaft);Einkaufsroller;fahrbarer Warenkorb;Einkaufswagen (Hauptform)
-Klient (Psychotherapie, Rechts- u.a. -beratung);Mandant (eines Rechtsvertreters);Patient (Gesundheitswesen);Auftraggeber (Handwerk, Dienstleistung);Gast (Beherbergung, Gastronomie);Kunde (Handel, Dienstleistung, Wirtschaft allg.);Besucher (öffentliche oder kulturelle Einrichtung)
-Kontaktmöglichkeit;Anlaufstelle
-(jemandem) zu nahe treten (Hauptform);zu privat werden;(jemandes) Grenzen verletzen;übergriffig (sein)
-(jemanden) nicht fallen lassen;(jemandem) eine zweite Chance geben;(jemand) hat eine zweite Chance verdient
-(bei jemandem) an jemanden (anderen) denken müssen;(jemanden) an jemanden erinnern
-du redest wie (z.B. deine Mutter);aus dir spricht (z.B. deine Mutter)
-Pathologe;Facharzt für Pathologie
-in Aufruhr (sein) (fig.);es herrscht Tumult
-was unterstehen Sie sich!;was fällt Ihnen ein (zu + Infinitiv);was erlauben Sie sich, (einfach zu ...) (ugs.);Sie haben echt Nerven (einfach zu ...) (ugs.);wer bist du, dass du (...) (geh.);wer sind Sie, dass Sie (...);wie konnten Sie nur!;wie konntest du nur!;wie kannst du es wagen (zu + Infinitiv);wer bist du (zu + Infinitiv) (geh.);wer sind Sie (zu + Infinitiv) (geh.);wie kommst du dazu (zu + Infinitiv);wie kommen Sie dazu (zu + Infinitiv);was fällt dir ein (zu + Infinitiv);wie kannst du nur!;wie können Sie es wagen (zu + Infinitiv);was unterstehst du dich!;du hast vielleicht Nerven (einfach zu ...)! (ugs.)
-unverschämt genug sein (zu);so schamlos sein (zu) (variabel);(sich) nicht genieren (zu);(etwas) dreist (tun);(sich) erdreisten (zu + Infinitiv);die Unverfrorenheit besitzen (zu);frech genug sein (zu)
-schöner Schein;Äußerlichkeiten;Oberfläche;Äußerlichkeit;(äußerer) Anschein
-Kult um (die) Marke(n) (variabel);Markenfetischismus;Warenfetischismus (fachspr.)
-Routine;Alltag;Trott;Tagesgeschehen;Arbeitsalltag
-Haste was, biste was. (Slogan);'Mein Haus, mein Auto, mein Boot'-Mentalität (fig., variabel)
-Statussymbol;Prestigeobjekt
-Ruf mal an!;Lass (was) von dir hören!;Melde dich!;Meld(e) dich mal!
-Provokation;Herausforderung
-(sich) herumsprechen;(von etwas) erfahren;bekannt werden
-(sich) ein grünes Image zulegen;(sich) umweltbewusst präsentieren;(sich / etwas) auf grün trimmen;Greenwashing betreiben (Neologismus, Hauptform);(einem Produkt, Unternehmen ...) ein umweltfreundliches Mäntelchen umhängen (fig.);(sich) umweltfreundlich darstellen
-Breadboard (engl.);Steckbrett;Protoboard (engl.);Steckplatine
-zwangsrekrutieren;zwangsweise (zum Militärdienst) einziehen
-(durch / unter) Anwendung von unmittelbarem Zwang (fachspr., juristisch);(durch / unter) Anwendung unmittelbaren Zwangs (fachspr., juristisch);gewaltsam;durch unmittelbaren Zwang (fachspr., juristisch);zwangsweise;durch Anwendung von Gewalt;unter Anwendung von Gewalt
-(etwas) nicht abschütteln können;nicht mehr herauskommen (aus);gefangen sein (in);(sich) nicht befreien können (von)
-(das) Joch (einer Sache) abschütteln (fig.);(sich) aus den Zwängen (einer Sache) befreien;(sich) vom Korsett (einer Sache) befreien;(sich) befreien (von / aus) (Hauptform);(die) Fesseln (einer Sache) abstreifen (fig.);(sich) aus den Fesseln (einer Sache) befreien (fig.);(das) Joch (einer Sache) abwerfen (fig.)
-Mauerfall;Maueröffnung
-Wegfall der Reisebeschränkungen;Grenzöffnung
-in Gesetzesform gießen;zum Gesetz erheben;gesetzlich festlegen;gesetzlich bestimmen
-(jemandem) ergeben;(jemandem) treu;(jemandem gegenüber) loyal
-in Handschellen;fixiert (fachspr.);gefesselt;in Ketten
-(jemandem) den Mund zustopfen;(jemandem) den Mund verbinden;(jemanden) knebeln (Hauptform);(jemandem) einen Knebel anlegen
-Fesselung;Anlegen von Fesseln;Fixierung
-Spiritismus;spiritistische Lehre
-abkuppeln;vom Zug(fahrzeug) trennen;abkoppeln;abhängen (ugs.)
-(sich etwas) umbinden (Kleidung) (Hauptform);(etwas) anziehen (ugs.);(etwas) anlegen (Kleidung)
-aufschnüren;aufknoten;aufbinden;aufdröseln
-einbrechen;(sich) gewaltsam Zugang verschaffen;eindringen (in)
-zur Feier des Tages (auch ironisch, Hauptform);aus besonderem Anlass;aus diesem besonderen Anlass;zu diesem besonderen Anlass
-(sich / jemanden) anziehen;(sich / jemandem) Kleidung anlegen;(Kleidung) anlegen;(sich) schmeißen in (ugs.);(sich) werfen (in);(sich) werfen in (ugs.);(ein Kleidungsstück) anziehen (Hauptform);antun (geh.);(hinein)schlüpfen (in);(sich / jemanden) ankleiden;steigen (in);(sich / jemanden) bekleiden
-anziehen;auftun;aufsetzen (Hut, Mütze) (Hauptform)
-auf die Nase setzen;aufsetzen (Brille)
-absetzen;(he)runternehmen;abnehmen (Brille);von der Nase nehmen
-aufgesetzt haben;tragen (Brille);auf der Nase haben
-(den) Boiler anstellen;im Wasserkocher erhitzen;(Wasser) aufsetzen (ugs., Hauptform);(zum Erhitzen) auf den Herd stellen
-dasitzen wie ein Häufchen Elend;zusammengesunken dasitzen;dasitzen wie ein nasser Sack
-(sich) gerade halten (auch figurativ);Haltung bewahren (auch figurativ)
-(etwas) d(a)rüber ziehen;(Kleidung) ziehen (über);(sich etwas) überstreifen;(sich etwas) überziehen (Kleidung) (Hauptform)
-in Samt und Seide (gehen) (fig., übertreibend);(schwer) in Schale (sein) (ugs.);sehr elegant gekleidet (sein);sehr vornehm gekleidet (sein)
-(jemandem) (neue) Kleidung geben;(jemanden) mit Kleidung versorgen;sich eine (neue) Garderobe zulegen;(jemanden / sich) einkleiden
-(sich) schnell anziehen;in die Kleider fahren;in die Kleider springen
-mit Schrauben befestigen;(etwas irgendwohin) schrauben;festschrauben;anschrauben
-aufschrauben;(drehend) öffnen
-zuschrauben;(drehend) schließen
-mit Schrauben befestigen (auf);(etwas) schrauben (auf);(etwas) aufschrauben
-(der Bus, Zug ...) war weg (ugs.);verpassen (Bus, Zug ...) (Hauptform);nicht schaffen;nicht erwischen (ugs.);nicht erreichen
-durchstellen (zu);(jemanden am Telefon) verbinden (mit) (Hauptform)
-Merkurtransit;Merkurdurchgang;Merkurpassage
-Venustransit;Venusdurchgang;Venuspassage
-Planespotter;Flugzeugbeobachter
-Antipode;Gegenfüßler
-wechselseitige Entsprechung;Komplementarität
-Stable (fachspr., IT-Technik, engl.);Produktivversion
-veralteter Ausdruck;Archaismus (fachspr.);veralteter Sprachgebrauch;veraltete Redeweise
-Vygonüle;PVVK (Abkürzung);periphervenöser Katheter;peripher-venöser Zugang;PVK (Abkürzung);Flexüle;peripherer Venenverweilkatheter;Braunüle;Venflon;peripherer Venenkatheter;periphere Venenverweilkanüle;Abbokath
-Katheter (fachspr., griechisch);Sonde;Zugang (ugs.)
-erfolgreich starten;gut einschlagen (ugs.)
-Geschäftsfeld (Hauptform);Geschäftssparte;Geschäftszweig;Geschäftsbereich;(Bereich) wirtschaftliche(r) Aktivitäten
-(den/die) passende(n) Partner(in) gefunden haben;(mit jemandem) glücklich werden;(sein/ihr) Glück gefunden haben;(mit jemandem) den/die Richtige(n) gefunden haben
-ab mit euch! (ugs.);jetzt aber los!;nu aber hopp hopp! (ugs.);ab mit dir! (ugs.)
-so gut wie unmöglich;praktisch ausgeschlossen;es müsste (schon) mit dem Teufel zugehen (wenn) (ugs., Redensart)
-als ausgemacht gelten;man geht (allgemein) davon aus (dass);so gut wie sicher (sein)
-Filmvorführer;Operateur (franz., veraltet)
-Kajüte;Kabine (Schiff)
-Stupsnase;Himmelfahrtsnase
-Du merkst aber auch alles! (ironisch);Du bist ja ein ganz Schlauer! (ironisch);Sie merken aber auch alles! (ironisch);Wie sind Sie nur darauf gekommen!? (ironisch);Sie sind ja ein ganz Schlauer! (ironisch);Wie bist du nur darauf gekommen!? (ironisch)
-OP (fachspr., Jargon);Ausgangsfrage
-(ursprünglicher) Fragesteller;OP (fachspr., Jargon)
-(eine) Diskussion beginnen;(eine) Diskussion auslösen;(eine) Diskussion eröffnen
-(etwas) schlechtreden;(sich) auf das Negative konzentrieren;nur das Negative (bei/an etwas) sehen (ugs.);herumnörgeln (an);(jemandem etwas) miesmachen
-Natternhemd;Schlangenbalg;Schlangenhaut
-Fahrgastzelle (fachspr., technisch);(das) Fahrzeuginnere;Fahrzeuginnenraum;Innenraum
-Editierdistanz;Levenshtein-Distanz
-autofrei;(es gibt) keine Autos;ohne Autos
-Augenoptiker;Optometrist
-Unternehmenssprache;Corporate Wording (engl.)
-regelnd;den Regeln entsprechend;regulatorisch
-Herrenausstatter;Herrenbekleidungsgeschäft
-Deutsch (Schul-/Lehrfach);Deutschunterricht;(das Fach) Deutsch
-(sich) entschuldigen (mit);zur Entschuldigung anführen;(sich) berufen (auf);als Entschuldigung vortragen;(sich) herauszureden versuchen (mit);als Entschuldigung vorbringen;zur Entschuldigung vorbringen
-superschwerer Wasserstoff;Tritium (Hauptform);überschwerer Wasserstoff
-Deuterium;schwerer Wasserstoff
-Schokocrossies;Schokoladenhäufchen
-Schrittchen für Schrittchen (fig.);in Trippelschritten (zum Ziel) (fig.);kleinschrittig (fig.);mit Trippelschritten (fig.)
-(es) muss eine andere Lösung her (ugs.);(das) muss anders laufen (ugs.);so wird das nichts (ugs., Hauptform);so kann das nicht klappen;so wird das nie was (ugs.)
-(es) sieht nicht gut aus (für/mit);(die) Prognose ist infaust (fachspr., medizinisch);ich sehe schwarz (für) (ugs.);es müsste schon ein Wunder geschehen (ugs.);wenn nicht (bald) ein Wunder geschieht (...) (ugs.);(die) Prognose ist ungünstig;(es) sieht schlecht aus (mit/für) (ugs.)
-Vervielfältigungsapparat;Vervielfältigungsgerät
-nicht gut gelernt haben (ugs.);Lücken haben (Kenntnisse);unzureichend vorbereitet (sein);lückenhaft (sein)
-Irrtum;Fehleinschätzung;Verkennung
-Mindfulness (fachspr., engl.);Achtsamkeit;passive Geistesgegenwärtigkeit;wertneutrale (Selbst-)Beobachtung;Gegenwärtigkeit;Leben im Hier und Jetzt
-Geistigkeit;Spiritualität
-produziert;gefertigt;angefertigt;erstellt
-Fertigungsteil;Werkstück;Arbeitsstück
-Produktionsgegenstand;Fertigungsgegenstand
-Stechpalme (ugs.);Europäische Stechpalme (fachspr.);Ilex aquifolium (fachspr.)
-Vergegenständlichung;Manifestation;Konkretion;Manifestierung
-Konkretisierung;Konkretion
-Manifestierung;Realisation;Durchsetzung;Konkretion;Verwirklichung;Manifestation
-auf eine gewisse Art und Weise;gewissermaßen;in gewissem Grade;in gewisser Weise;auf eine gewisse Art;in einem gewissen Sinne;auf gewisse Weise;in gewissem Sinne;in gewisser Hinsicht
-abwählen;Option entfernen;Selektion aufheben;deaktivieren;deselektieren;Auswahl entfernen
-(ganz) bewusst so angelegt (sein) (variabel);kalkuliert (sein);(es ist) kein Zufall, dass ...;(es) steckt System (hinter etwas);(so) gewollt sein;Methode haben (Hauptform);(etwas ist) kein Zufall (ugs.)
-handlungsfähig werden (schweiz.);18 werden (ugs.);achtzehn werden (ugs.);die volle rechtliche Handlungsfähigkeit erlangen;das Erwachsenenalter erreichen;volljährig werden;(seinen / ihren) 18. Geburtstag feiern;erwachsen werden
-(etwas) in den Sand setzen (fig., sprichwörtlich);scheitern (mit)
-(jemandem) läuft die Nase;(eine) Triefnase (haben);Schnupfen (haben);(eine) Schniefnase (haben) (ugs.)
-Hinderniswand;Eskaladierwand;Holzwand
-Sturmbahn;Hindernisbahn;HiBa (Kurzform);CISM-Bahn;H-Bahn (Kurzform)
-runterziehen (ugs.);herunterziehen (Hauptform);herunterlassen;nach unten ziehen;runterlassen (ugs.)
-so anlegen, dass es bis (weiter nach) unten reicht;(etwas) herunterziehen (bis)
-Traverse;Querträger
-Neuerstellung;Ersterstellung
-besoffen machen (derb);betrunken machen (Hauptform);(jemanden) unter Alkohol setzen;(jemanden) abfüllen (ugs.);trunken machen (geh.);(jemanden) unter den Tisch trinken (ugs.);alkoholisieren (fachspr., bildungssprachlich)
-abgemacht? (ugs.);Deal? (ugs., Jargon, engl.);okay? (ugs.);sind wir im Geschäft?;sind wir uns einig?
-(ein) harter Brocken (ugs.);hart drauf (sein) (ugs.);(mit jemandem) ist nicht zu spaßen (ugs.);(mit jemandem) ist nicht gut Kirschen essen (ugs., veraltend)
-(die Dinge) nicht so eng sehen (ugs., fig.);locker drauf (sein) (ugs.)
-(sein) Verständnis vertiefen;besser verstehen
-Wiener Schmäh;typischer Wiener Humor
-bis in die Puppen schlafen (sprichwörtlich);erst Mittags aus dem Bett kommen
-Texterstellung;Textgestaltung
-leichtes Fieber haben;leicht erhöhte Temperatur haben;(etwas) Temperatur haben (ugs.)
-gemeinsam;miteinander;gegenseitig;zusammen;untereinander;kollektiv (fachspr.)
-Begrüßungsabordnung;Begrüßungsverantwortliche;Begrüßungskomitee
-Gesichtspflege (betreiben) (fig.);in Sachen Selbstvermarktung unterwegs (sein)
-provokant (fragen / sagen ..);ketzerisch (fragen / sagen / denken) (fig.);den Advocatus Diaboli spielen (geh., bildungssprachlich)
-es ist (noch) Zeit genug;wir haben genug Zeit;wir haben Zeit genug;(es ist) noch Zeit;wir haben noch Zeit
-(sofort) weitermüssen;nicht (länger) bleiben können
-(die) Zeit ist abgelaufen (Hauptform);nichts geht mehr;(jemandes) Zeit ist vorbei;(die) Zeit ist rum;(die) Uhr ist abgelaufen
-keine Zeit mehr haben;nicht mehr die Zeit haben (um ... zu);(jemandem) bleibt nicht mehr die Zeit (um ... zu);(jemandem) bleibt keine Zeit
-(einen Termin / Zeitplan) nicht einhalten können;(jemandem) bleibt zu wenig Zeit;zu wenig Zeit haben;in Verzug geraten (mit);(zu) spät dran sein (mit) (ugs.);(zeitlich) nicht (mehr) schaffen
-skinny (fachspr., Jargon, engl.);hauteng;knackeng;knalleng
-figurbetont;körperbetont;körpernah (geschnitten);körpereng
-herausgehen (aus);nach draußen gehen;hinausgehen;rausgehen;verlassen (Zimmer, Haus, Geschäft ...)
-rauskommen (ugs.);verlassen (Raum, Gebäude);herauskommen;nach draußen kommen
-ein gewisser (eine gewisse, ein gewisses);ein bestimmter (eine bestimmte, ein bestimmtes);ein spezieller (eine spezielle, ein spezielles)
-ein gewisser (Meier) (ugs.);ein Herr (Meier);ein mir bis dahin nicht bekannter Herr (Meier);jemand, der sich als Herr (Meier) vorgestellt hat;ein gewisser Herr (Meier)
-eine Frau (Meier);eine gewisse Frau (Meier);eine Person, die sich als Frau (Meier) vorgestellt hat;eine mir bis dahin nicht bekannte Frau (Meier)
-Mitchen;Henkelmann;Döppen;Menagereindl (bayr.);Kimmel;Düppe;Bitscherl (bayr.);Knibbel
-Werkzeughalter;Werkzeugwand;Lochwand
-Panthera leo persica (fachspr., lat.);Indischer Löwe;Persischer Löwe;Asiatischer Löwe
-im luftleeren Raum (fig.);ohne praktischen Bezug
-in den letzten Tagen;in allerletzter Zeit;in den zurückliegenden Tagen und Wochen;jüngst;in jüngster Vergangenheit;in den letzten Wochen;in den letzten Monaten;in jüngster Zeit (Hauptform);zuletzt
-luftleerer Raum;Vakuum (Hauptform);Leerraum
-dreiviertel (eins) (süddt., österr.);viertel vor (eins);viertel auf (eins)
-antiislamische Einstellung;antimuslimische Haltung;Ablehnung des Islam
-Antipathie (gegen);Abneigung (gegen);ablehnende Haltung (gegenüber);Unwille;Aversion(en)
-Freundschaftlichkeit;Wohlwollen;freundschaftlicher Umgang
-viertel ab (zwölf) (schweiz.);viertel über (zwölf) (österr.);(zwölf) Uhr fünfzehn (Hauptform);viertel (eins) (fränk., kärntnerisch, ostdeutsch, ostösterreichisch, schwäbisch);viertel nach (zwölf) (westdeutsch, österr.)
-Tarabit;Strickbrücke;Seilbrücke
-Wandbild;Fresko;Wandgemälde
-(Zeit) hinter sich bringen (Hauptform);(Zeit) herumbringen (ugs.);(Zeit) herumkriegen (ugs.);(Zeit) rumkriegen (ugs.);darauf warten, dass die Zeit vergeht;darauf warten, dass etwas vorbei ist
-Groko (Abkürzung);große Koalition
-für wahr halten, was jemand sagt;(jemandem) Vertrauen schenken;von jemandes ehrlichen Absichten überzeugt sein;(jemandem etwas) abnehmen (ugs.);(jemanden) für vertrauenswürdig halten;(jemandem) trauen (Hauptform);nicht an jemandes ehrlichen Absichten zweifeln;nichts Böses vermuten hinter;von jemandes Loyalität ausgehen
-(etwas) nicht unbesehen glauben (wollen);(jemandem / einer Sache) nicht blind vertrauen (wollen);(eine) zweite Meinung (hören) wollen
-Ich traue dem Frieden nicht. (fig.);Das wär(e) zu schön, um wahr zu sein.
-blendnerisch (geh.);verführerisch;die Sinne betören(d) (geh.);gleisnerisch (geh.)
-Ist grad schlecht. (ugs., floskelhaft);(es) passt gerade nicht (besonders);(es ist) nicht der günstigste Moment;(es) ist gerade ungünstig
-Gewicht;(jemandes) Kampfgewicht (ironisierend);Körpergewicht (Hauptform)
-Konversation machen;Smalltalk machen;(sich) gepflegt unterhalten (ugs.)
-(kurze) Unterhaltung;Klönschnack (ugs., norddeutsch);Plausch;Schwatz;Quätschchen (ugs., regional);Schnack (ugs., norddeutsch)
-durcheinanderreden;herumpalavern (ugs., abwertend);(ein) Palaver veranstalten;palavern (ugs., abwertend)
-Isotopenkarte;Nuklidkarte;Isotopentafel
-primordiales Nuklid (ugs.);primordiales Radionuklid (fachspr.);Radionuklid erster Ordnung;Nuklid erster Ordnung
-Leitvorstellung (Hauptform);Leitbild;leitende Idee;Leitidee;leitendes Prinzip
-genannt werden;zu finden sein;aufgeführt sein;Erwähnung finden;aufgeführt werden;erwähnt werden
-dick im Geschäft (ugs., Hauptform);alle Hände voll zu tun haben;(geschäftlich) viel zu tun haben;(geschäftlich) vorne mit dabei
-das wirst du bereuen!;das wird dir noch leidtun! (ugs., Spruch)
-den Mund halten;aufhören zu reden;den Rand halten (ugs.);die Klappe halten (ugs.)
-mit dem Krach aufhören;aufhören, Krach zu machen;(endlich) Ruhe geben
-Security (engl.);Sicherheitsdienst;Ordnungsdienst;Rausschmeißer (ugs., veraltend)
-unverrichteter Dinge (zurückkommen / abreisen);ohne Ergebnis (zurückkommen / abreisen);mit leeren Händen (zurückkommen / abreisen);ohne etwas erreicht zu haben (zurückkommen / abreisen)
-zurückkehren;die Heimreise antreten;die Rückreise antreten;heimreisen;heimkehren
-heimfliegen;zurückfliegen;den Rückflug antreten;nach Hause fliegen
-heimgehen;(sich) heimbegeben (geh.);(sich) nach Hause begeben (geh.);(sich) auf den Rückweg machen;nach Hause gehen;heimlaufen (regional);(sich) auf den Heimweg machen;zurücklaufen (regional);nach Hause laufen;den Rückweg antreten
-zurückkommen;heimkommen;(zurück) nach Hause kommen
-praktisch umsetzen;den Worten Taten folgen lassen;in (die) Praxis umsetzen;mit Leben (er)füllen (fig.);konkret ausgestalten
-(rein) praktisch bedeutet das;das heißt konkret;für die Praxis heißt das
-dahinterstecken;(das) waren (Täterschaft);(jemand) steckt hinter;(das) war (Täterschaft);(jemandem) anzulasten sein;verantwortlich sein (für);auf jemandes Konto gehen (fig.)
-in Zusammenarbeit (mit) (Hauptform);zusammen arbeiten(d);in einem gemeinsamen Prozess;kollaborativ;in gemeinsamer Anstrengung;in Teamarbeit
-Iuppiter Optimus Maximus (lat.);Jupiter;Diespiter (veraltet);IOM (Abkürzung, lat.);Iupiter (lat., selten);Juppiter (selten);Iuppiter (lat.)
-Imperium Romanum (lat.);Römisches Reich
-pauschalieren;Pauschale(n) ansetzen (für)
-alle bekommen dasselbe (ugs.);niemanden bevorzugen;alle gleichbehandeln;jeder bekommt gleich viel (ugs.)
-Karenz (Österreich);Elternzeit (Deutschland)
-Kinderbetreuungsgeld (Österreich);Elterngeld (Deutschland);Erziehungsgeld (Deutschland) (fachspr., veraltet);Karenzgeld (Österreich) (fachspr., veraltet)
-Einkommensunterbrechung;Entfall der Bezüge (fachspr., Amtsdeutsch, österr.);Verdienstausfall
-Schneeblindheit;Niphablepsie (fachspr., griechisch, lat.)
-kulturindifferent;hemeradiaphor (griechisch)
-hemerophil (fachspr., griechisch);kulturliebend
-kulturmeidend;hemerophob (fachspr., griechisch)
-(jemandem) einen Posten geben;(jemandem) zu einem Amt verhelfen;(jemanden) in ein Amt heben;(jemandem) einen Posten zuschanzen (ugs.);(eine) Position mit jemandem besetzen;(jemanden) in eine Position bringen;(jemanden) auf einen Posten hieven (ugs.);(jemandem) einen Posten zuschieben (ugs.)
-(eine) Politik in jemandes Interesse machen;(eine) Politik für jemanden machen (ugs.);(jemandes) Interesse(n) bedienen
-an der Kapazitätsgrenze arbeiten;an die Kapazitätsgrenze stoßen;(die) Kapazitätsgrenze erreichen;maximal ausgelastet (sein)
-Venenpumpe;Muskelpumpe
-der Malerei frönen (geh.);(Bilder) malen;den Pinsel schwingen (ugs., scherzhaft-ironisch)
-Dashcam;Fahrzeugrekorder;Autokamera;Frontscheibenkamera
-Filmkamera;Bewegtbildkamera
-Finanzierung;Mittelbeschaffung
-mach ihn fertig!;gib's ihnen!;macht sie fertig!;zeig's ihm!;zeigen Sie's ihm!;zeigen Sie's denen!;gib's ihm!;mach sie fertig!;mach sie alle! (ugs.);macht sie alle! (ugs.);zeig's ihnen!
-viel nachgefragt werden;viel gekauft werden;gefragt sein;(sich) gut verkaufen
-Cashcow (fachspr., Jargon, engl.);Dauerseller (fachspr.);Milchkuh (fachspr., Jargon);Melkkuh (fachspr., Jargon);Steadyseller (fachspr., engl.);Dauerbrenner (ugs., fig.)
-thanatophil;den Tod wünschend
-malgenommen (mit);mal;multipliziert (mit)
-(hinzu)addiert zu;plus (Hauptform);und
-weniger (Hauptform);subtrahiert (von);abgezogen (von);abgerechnet (von);minus (Hauptform)
-durch (Rechnen);geteilt durch (Hauptform);dividiert durch
-(a) hoch (n);(die) n-te Potenz von (a);(a) potenziert mit (n);(a) zur n-ten Potenz
-Kubikwurzel;dritte Wurzel
-wenn man nach (...) geht;(...) nach;(...) nach zu urteilen;soweit man es (...) entnehmen kann;soweit man es (aus ...) schließen kann (variabel);soweit man es (nach / auf der Grundlage von ...) beurteilen kann;(...) nach zu schließen
-gedrückter Bogen;Ratebogen;Korbbogen;Korbhenkelbogen
-Vielpassbogen;Zackenbogen
-Schwibbogen;Schwebebogen
-Pfahlbrücke;Jochbrücke;Pfahljochbrücke
-Freiluft...;Open-Air-... (engl.)
-Ist dir was?;Bist du okay? (ugs.);Ist irgendwas? (ugs.);Alles okay bei dir? (ugs.);Ist was? (ugs.);Hast du was?
-richtungsweisend (sein);Signalwirkung haben (fig., floskelhaft, variabel);(eine) Orientierungsmarke darstellen (fig.);(eine) Tendenz zeigen
-(jemandes) stehende Redewendung;(jemandes) Standardspruch;(jemandes) stehende Redensart
-Grubenfahrt;Seilfahrt
-Das ist ein Wort! (ugs.);Da sag ich nicht nein! (ugs.);Das hört sich (doch) gut an!
-(mit jemandem) rummachen (ugs.);(mit jemandem) eine intime Beziehung haben
-systeminterne Funktion (selten);intrinsische Funktion
-(sich) zusammenreißen;da durchmüsssen (ugs., fig.);(die) Zähne zusammenbeißen;(etwas) aushalten
-(die) Zähne zusammenbeißen (fig.);Indianer kennt keinen Schmerz. (ugs., Spruch);mannhaft ertragen
-Kinoformat;Cinemascope (engl.);Panavision (engl.)
-Denkakt;Denkvorgang;Überlegung;Denken;Gedanke (Hauptform);Denkprozess
-Denkinhalt;Gedankeninhalt;Gedanke (Hauptform)
-Konsumentenschutz (schweiz., österr.);Verbraucherschutz
-(jemandem) seine Position streitig machen wollen;(jemandes) Job haben wollen (ugs.);an jemandes Stuhl sägen (fig.);auf jemandes Posten scharf sein (ugs.);konkurrieren (mit)
-glücklich und zufrieden (sein);keinen Grund zum Klagen haben;wunschlos glücklich (sein) (floskelhaft);(sich) nicht beklagen können;(alles) haben, was man braucht;(alles erreicht) haben, was man will
-jemandes Entlassung betreiben;(sich) auf jemandes Kosten nach oben arbeiten;an jemandes Stuhl sägen (fig.);jemandes Stellung untergraben;auf jemandes Entlassung hinarbeiten
-rütteln (an) (fig.);in Frage stellen;infrage stellen
-zu (+ Adjektiv);zu viel auf einmal;vor lauter;zu viel (... als dass)
-Alles muss man selber machen!;Wenn man nicht alles selber macht ...
-Bumskopf (ugs.);Bollerkopp (ugs., norddeutsch);Bollerkopf (ugs.)
-Mittagstief;Suppenkoma (fig.);Zeit der toten Augen (fig.);Tief nach der Mittagspause
-Ermattung;Müdewerden;Ermüdung;Defatigation (fachspr., selten, veraltet)
-oha! (ugs.);(jetzt) sag bloß ...! (ugs.);holla! (ugs.);wie jetzt!? (ugs.);nanu! (Hauptform);ach!;wie (Interjektion) (ugs.)
-angespannte Finanzlage;klamme Kassen (mediensprachlich)
-zu hoher Schuldenstand;Überschuldung
-Krafttraining machen;Bankdrücken;pumpen (ugs.);Muskelaufbau betreiben
-krankhaft misstrauisch;paranoid (fachspr.)
-Dreck;Unflat;(der) Siff (ugs.);Unrat;Schmutz;(der) Schmuddel (ugs.)
-Berge (fachspr., Bergbau);Aushub;Abraum
-Linienzugfeder;Gleichzugfeder;Kugelspitzfeder
-Breitfeder;Bandzugfeder;Wechselzugfeder
-Spitzfeder;Schwellzugfeder
-Schnurzugfeder;Redisfeder
-Doppelstrichfeder;Spaltfeder
-unvorhersehbar (Hauptform);unvorhersagbar;unkalkulierbar;unberechenbar;erratisch (geh.);dem Zufall überlassen;aleatorisch (geh.)
-vermutet;vorausgesehen;erwartet;vorhergesehen
-Kohlechemie;Kohlenchemie;Carbochemie
-grüner Salat;Kopfsalat;Blattsalat
-Bratkartoffelverhältnis (ugs., historisch);Onkelehe (ugs., historisch)
-dafür sorgen, dass jemand bei der Stange bleibt (fig.);verhindern, dass jemand sich abwendet (fig.);(jemanden) bei der Stange halten (fig., Hauptform);dafür sorgen, dass jemand nicht von der Fahne geht (fig.);verhindern, dass jemand jemandem den Rücken kehrt (fig.)
-in Serie hergestellt;(z.B. Kleidung) von der Stange;fabrikmäßig produziert;Konfektionsware;fertig konfektioniert;prêt-à-porter
-Haute Couture (franz.);Schneiderkunst;Modeschöpfung
-Kaltblüter (veraltet);poikilothermes Tier;wechselwarmes Tier;ektothermes Tier
-(den) Fokus der Diskussion (gezielt) verschieben;Derailing (betreiben) (Neologismus, engl.)
-(ein) Thema setzen;(Diskussion) dominieren;(Diskussion) an sich reißen
-(Antwort mit einer) Gegenfrage;Relativierung;Whataboutism (engl.);Tu-quoque-Argument
-Spritzenpumpe;Perfusor (Markenname)
-Infusomat (Markenname);Infusionspumpe
-patientenkontrollierte Schmerztherapie;patientengesteuerte Analgesie;patientengesteuerte Schmerztherapie
-testikuläre Spermienextraktion;testikuläre Spermatozoenextraktion
-kleiner Unterschied;Winzigkeit;geringe Differenz;Wimpernschlag;Geringfügigkeit;Kleinigkeit (Hauptform)
-bizarres Naturgebilde;Laune der Natur
-höchstrichterlicher Spruchkörper;Senat (Deutschland)
-Spruchkörper (fachspr.);Kammer (eines Gerichts) (fachspr.)
-gesichert (sein);gegeben (sein);gewährleistet (sein)
-ein Witz;ein Lacher;nicht ernst zu nehmen;lachhaft (Hauptform)
-zögerlich;zurückhaltend;nur zögernd
-wachsam;vorsichtig;auf der Hut
-vorgeschobenes Argument;Schutzbehauptung;Scheinargument
-Raubbau (an);Übernutzung
-Niedrigenergiehaus (ugs.);Nullenergiehaus (ugs.);Passivhaus (ugs.);Passivenergiehaus
-wieder zu Hause;zurück (sein);wieder da (ugs.)
-nachfragen;in Erfahrung bringen;erfragen;anfragen;einholen
-(jemandem) wird schwer ums Herz;in Traurigkeit fallen;(das) Elend bekommen (ugs., fig.);traurig werden
-(etwas) kaum mitansehen können;Mitleid bekommen;Mitleid empfinden;(jemandem) wird das Herz schwer;Mitleid verspüren;(jemanden) erfasst Mitleid (mit / für);(jemandem) wird (es) schwer ums Herz
-(jemanden) duzen;Du sagen (zu)
-aufspannen (Schirm) (Hauptform);aufmachen (ugs.);aufklappen;öffnen
-hochklappen;aufmachen (ugs.);aufklappen (Deckel, Notebook, Fenster ...)
-(Deckel) abziehen (Joghurtbecher o.ä.);entfernen;aufmachen (ugs.)
-(jemanden) ausquartieren;woanders unterbringen;zum Verlassen der Wohnung veranlassen
-einkaufen fahren;einkaufen gehen;einkaufen (Hauptform);einholen (ugs.)
-Abmagnetisierung;Entmagnetisierung
-mehlig;mit Mehl bestäubt;bemehlt
-(die) Beweislast tragen;(etwas) beweisen müssen
-Milie;Hautmilie;Hautgrieß;Grießkorn;Milium
-Warze;Akrochordon (fachspr., griechisch)
-(sich) Angebote (zu)schicken lassen;Angebote einholen;(ein) Angebot anfordern;(ein) Angebot einholen;(sich) ein Angebot geben lassen;Angebote anfordern;um ein Angebot bitten;(sich) Angebote machen lassen
-unbedingt (Hauptform);unter allen Umständen;durchaus (geh.);um jeden Preis;koste es, was es wolle (geh.);partout (geh., franz.);egal, was ist;auf jeden Fall
-Genaueres in Erfahrung bringen (wollen);sich außerdem erkundigen;nachfragen;(eine) Zusatzfrage stellen;(später) fragen;(es) genauer wissen wollen;noch einmal fragen
-herabnehmen;abhängen;einholen (Flagge);herunternehmen;runterholen;abnehmen;runternehmen
-abnehmen (Mütze, Hut);vom Kopf nehmen;absetzen
-Desideratum (fachspr., lat.);Desiderat (geh.);Wunschliste
-Wolfsbeere;Goji-Beere;Goji;Chinesische Wolfsbeere;Gouqi (Pinyin, chinesisch)
-es kann ja immer (mal) was sein (ugs.);falls (mal) was ist (ugs.);falls (mal) was passiert (ugs.);für den Fall dass. (ugs.)
-Jagdfrevel;Wilddieberei;Wilderei (Hauptform);(das) Wildern
-(sich) Zeit freischaufeln (fig.);(sich) Zeit verschaffen
-Fleischermesser;Schlachtermesser;Metzgermesser;Ausbeiner;Ausbeinmesser
-(S. ... und) folgende;(S. ...) f. (Seitenangabe)
-zu Mittag essen (Hauptform);Mittag essen (ugs.);mittagessen (österr.);zu Mittag speisen;mittags was essen (ugs.);(die) Mittagsmahlzeit zu sich nehmen
-Speckkuchen;Gemüsekuchen;Quiche (franz.)
-Kultstätte;geweihter Ort;heilige Stätte
-Klosterkirche;Abteikirche;Katholikon (fachspr.);Prioratskirche (fachspr.)
-Kirchengebäude;Kichenbauwerk;Kirchenbau
-dämmrig;schummrig;schwach (Licht);fahl (Licht);lichtarm (fachspr.);schlecht (Licht);trüb (Licht)
-Dämmerlicht;Halblicht;Funzellicht (ugs.);Halbdunkel;Schimmerlicht;Zwielicht;Schummerlicht
-Mondlicht;Mondenschein (geh., dichterisch);Mondeslicht (geh., dichterisch);Mondschein
-Transportband;Förderband
-Veloparkplatz (schweiz.);Fahrradstand;Fahrradstellplatz;Fahrrad-Abstellplatz;Fahrradabstellanlage;Velostellplatz (schweiz.);Velostand (schweiz.);Fahrradständer;Fahrrad-Stellplatz;Fahrradabstellplatz;Veloständer (schweiz.);Velo-Abstellplatz (schweiz.);Fahrradparkplatz;Velo-Stellplatz (schweiz.)
-Kreuzberger Bügel (fachspr.);Kölner Haarnadel (fachspr.);Rhein-Ruhr-Bügel (fachspr.);Wiener Bügel (fachspr.);Fahrradbügel;Anlehnbügel
-Abstellmöglichkeit;Parkmöglichkeit
-Bezug (Wohnung);Einzug (Hauptform)
-Einweihungsparty;Einzugsparty;Einzugsfeier;Einweihungsfeier;Einweihungsfete
-Elbphilharmonie;Elphi (ugs.)
-ins Blickfeld geraten;in den Brennpunkt des Interesses rücken;in den Fokus rücken;den Brennpunkt der Aufmerksamkeit bilden;(sein) Hauptaugenmerk richten (auf)
-an den Füßen frieren;Eisfüße haben;kalte Füße haben (Hauptform)
-laufen so schnell man kann;so schnell die Füße tragen (literarisch)
-(sich) den Fuß verrenken;mit dem Fuß umknicken;(sich) den Fuß verknacksen;(sich) den Knöchel verdrehen;(sich) den Fuß verstauchen
-(sich) nicht (einfach) abwimmeln lassen;so leicht nicht wieder loszuwerden (sein);(einen) Fuß in die Tür bekommen (fig.)
-(den) ersten Schritt geschafft haben;(den) Fuß in der Tür haben (fig.);(einen) Fuß in die Tür bekommen (fig.)
-(jemandem den) Zugang ermöglichen;Türöffner (sein) (fig.)
-(jemandem) die Tür vor der Nase zuschlagen;(sich) auf kein Gespräch einlassen;(jemandem) die Tür vor der Nase zuknallen;(für jemanden) nicht zu sprechen sein
-(über etwas) reden wollen;(das) Gespräch suchen;versuchen, im Gespräch eine Lösung zu finden
-ohne nasse Füße zu bekommen;trockenen Fußes
-ohne Schuhe (an den Füßen);mit nackten Füßen;barfüßig;mit bloßen Füßen;unbeschuht;barfuß
-weder Schuhe noch Strümpfe tragen;keine Schuhe anhaben;ohne Schuhe laufen;barfuß sein;keine Schuhe tragen
-(dort) kann man gut zu Fuß hinkommen (ugs.);gut zu Fuß erreichbar;gut zu Fuß zu erreichen
-gut zu Fuß (sein) (Hauptform);laufen wie ein Döppken (ugs., ruhrdt., veraltet);(wieder) laufen wie ein junges Reh (ugs.);(jemandem) davonlaufen (fig.);gut laufen können
-(das) Laufen fällt jemandem schwer;Mühe mit dem Laufen haben;nicht (mehr so) gut laufen können;schlecht zu Fuß (sein);(das) Gehen fällt jemandem schwer;Probleme beim Laufen haben;mühsam gehen
-(jemandem) zu Füßen;unterhalb von (jemandem)
-am Fuß des (Berges);zu Füßen des (Berges) (literarisch);unten am Hang (des)
-nicht dem Vergessen anheimfallen lassen;(jemandem eine) ständige Mahnung sein (geh.);gemahnen (an) (geh.);erinnern (an);nicht in Vergessenheit geraten lassen;mahnen (an);(die) Erinnerung wach halten (an)
-(die) Füße hochziehen;(die) Füße anheben;(die) Füße hochnehmen
-noch einmal anziehen;noch einmal festziehen;weiter anziehen;nachziehen (Schraube)
-(jemand) weiß, was er zu tun hat;wissen, was man zu tun hat;wissen, was zu tun ist;(jemandem) nichts erklären müssen
-tun, was man tun muss;tun, was getan werden muss;alles Notwendige tun;das Notwendige tun;tun, was man nicht lassen kann;das Nötige tun
-am Fuß (des/der);unten an (dem/der);unten vor (dem/der)
-am weitesten von der Körpermitte entfernte Körperteile;Akren (nur im Plural) (fachspr., Hauptform)
-USSF (Abkürzung, engl.);Special Forces (engl.);United States Army 1st Special Operations Command (fachspr., engl., veraltet);Green Berets (ugs., engl.);United States Army Special Forces Command (Airborne) (fachspr., engl.)
-einkehren (Ruhe);herrschen (Ruhe);sein (Ruhe);eintreten (Ruhe);(sich) beruhigt haben (Situation, Leute ...)
-nicht gestört werden;seine Ruhe haben
-mit 'Ihr' ansprechen;ihrzen;'Ihr' als Höflichkeitsform gebrauchen
-(jemanden) mit 'Er' ansprechen;'Er' sagen (zu);(jemanden) erzen
-Swasiland (ugs.);Eswatini;Königreich Eswatini (offiziell)
-exerzieren;(jemanden) drillen;(jemanden) schinden;(jemanden) bimsen (ugs.);(jemanden auf etwas) hintrimmen;(jemanden) schleifen (Hauptform, militärisch)
-(etwas von jemandem) verlangen;(jemanden) fordern;(jemandem etwas) abfordern;(etwas) fordern;(jemandem etwas) abverlangen
-(Leute) gegeneinander ausspielen;seine Fäden spinnen;(Leute) gegeneinander aufbringen;(Leute) gegeneinander aufhetzen;intrigieren (gegen);Ränke schmieden (geh., veraltet);mobben
-etwas hat seinen Grund;etwas hat seine Bewandtnis;ich habe meine Gründe
-Modetorheit;zeitgeistbedingte Geschmacksverirrung
-Gimmick;(technische) Spielerei;Gadget
-Grundsatzurteil;Grundsatzentscheidung
-(jemandes) Glaubwürdigkeit erschüttern;(jemanden) auseinandernehmen (ugs., fig.);(jemandes) Ansehen beschädigen;(jemanden) demontieren (fig.)
-(jemanden) um sein Ansehen bringen;(jemanden) unmöglich machen;(jemandes) Ruf zerstören
-gemeinwohlorientiert arbeiten(d);bürgerschaftlich engagiert;in der Freiwilligenarbeit engagiert;ehrenamtlich (tätig)
-(sich) anständig benehmen;(sich) ordentlich aufführen;(sich) benehmen;(sich) vernünftig benehmen;(sich) gut benehmen;(sich) gut betragen
-reduzieren (auf) (ugs.);auf Teilzeit gehen
-(der) Genius loci (geh., lat.);(die) Aura einer Stadt;(die) Magie eines Ortes;(die) besondere Atmosphäre eines Ortes
-(die) weit überwiegende Mehrzahl;(die) allermeisten;(die) weitaus meisten;(die) weit überwiegende Mehrheit;(die) mit Abstand meisten
-besseres zu tun haben;seine Zeit nicht gestohlen haben (ugs., fig.);keine Zeit haben (für);(jemandem ist seine) Zeit zu schade (für) (ugs.)
-einer der unseren (sein) (geh.);(den richtigen) Stallgeruch (haben) (Hauptform);zu uns gehören;einer von uns (sein);ein richtiger ... sein
-(einer Idee) verpflichtet;in einer Tradition stehen;(einer Sache) verhaftet
-(als) weder männlich noch weiblich (bezeichnet);divers (Neologismus, Hauptform);(als) nicht männlich und nicht weiblich (bezeichnet);d (Abkürzung)
-falscher Bruder (von) (fig.);Paronym (von);(ein mit ...) leicht verwechselbares Wort
-(klanglich/lautlich) ähnlich;paronym (zu) (fachspr.);leicht verwechselbar (mit)
-nicht laufen (ugs.);will nicht (ugs.);tut's nicht (ugs.);nicht funktionieren
-nicht(s) (hin)durchgehen (ugs.);verstopfen;(sich) verstopfen;(sich) zusetzen;nicht(s) (hin)durchkommen (ugs.)
-verstopft sein;zusitzen
-murmeln (fig.);(sich) schlängeln (fig.);(sich) winden;plätschern;dahinplätschern (Bach);sanft ziehen (Bach)
-Flussstein;großer Kiesel
-Kiesbank;Kiesinsel;Schotterinsel;Schotterbank
-Sandbank;Sandinsel
-(aus dem Wasser) zum Vorschein kommen;trockenfallen (fachspr., Hauptform);nicht (mehr) von Wasser überspült werden;(aus dem Wasser) auftauchen
-dahinplätschern (fig.);ohne Höhen und Tiefen verlaufen
-nichts Neues (bieten);(alles) schon tausend mal (so oder so ähnlich) gesehen;schon tausend(e) Mal(e) gehört
-Lampenöl;Petroleum (ugs.)
-(jemandem) das Wort erteilen;das Wort weitergeben (an);übergeben (an)
-das Wort haben;(jetzt) sprechen dürfen;(jetzt) sprechen können
-(jemandem) das Wort entziehen (Hauptform);(jemanden) auffordern zu schweigen
-(jemandes) Steigbügelhalter (abwertend, fig.);(jemandem) zur Macht verhelfen;von jemandes Gnaden (an die Macht kommen)
-Hissflagge;Querflagge
-Knatterflagge;Hochformatflagge
-Galgenflagge;Auslegerflagge
-Hausfahne;Schrägfahne;Hängeflagge
-einrasten;einschnappen
-(etwas) selbst machen (Hauptform);in Eigenarbeit;im Do-it-yourself-Verfahren machen;in Eigenregie machen;(sich) selbst helfen
-(sich) mit Blicken verständigen;nonverbal kommunizieren (fachspr.);(sich) ohne Worte verstehen
-Kollateralschaden (Hauptform, militärisch, verhüllend);Der Zweck heiligt die Mittel. (Sprichwort);Wo gehobelt wird, da fallen Späne. (Sprichwort, zynisch)
-Warbonnet (engl., franz.);Federhaube
-großer Tag (heute)!;(jetzt) kommt es drauf an!;wichtiger Tag;(seinen) großen Tag haben;(jetzt) gilt's!
-(die) Leitung (haben);Weisungsbefugnis;Befehlsgewalt;Anordnungsberechtigung (fachspr., Amtsdeutsch);(das) Kommando (haben)
-(jemandes) Herz schlägt schnell;(jemandem) geht die Pumpe (ugs.);(jemandem) schlägt das Herz bis zum Hals
-dadurch ist nichts gewonnen (ugs.);es kommt nichts dabei heraus (ugs.);Nullsummenspiel (ugs., Hauptform);niemand hat etwas davon (ugs.);Außer Spesen nichts gewesen. (ugs., Spruch)
-es klingelt;(die) Klingel geht;(jemand) will rein (ugs.);(jemand) klingelt;es läutet
-(das) Telefon geht;(das) Telefon klingelt
-Sturm läuten (Hauptform);(den) Finger nicht vom Klingelknopf nehmen;ununterbrochen klingeln;ununterbrochen läuten
-Laubengang (außen am Haus) (Hauptform);Galerie;Pawlatsche (ostösterreichisch);nach außen offener Gang
-Pergola (ital.);Laubengang (berankt);Treillage (fachspr., veraltet)
-Kletterhilfe (fachspr.);Rankhilfe;Pergola (ital.);(freistehendes) Rankgerüst;Rosenbogen (fachspr., Handelsname)
-(sich etwas) noch einmal überlegen (müssen);darüber nachdenken (müssen) (ugs., Hauptform);noch einmal darüber schlafen (müssen);nicht sofort zusagen (können);noch nicht entschieden sein;(sich) noch nicht entschieden haben
-(jemandem ein) Zeichen geben (Hauptform);signalisieren;(ein) Signal geben;(ein) Zeichen machen;winken;(jemandem) einen Wink geben
-zum / zur ... singen (geh.);mit ...begleitung singen;von der / vom ... begleitet singen
-einkalkuliert;(schon) eingepreist;(im Vorfeld) berücksichtigt
-Zeugenstand;Zeugenbank
-(jemanden) in den Zeugenstand rufen;(jemanden) als Zeugen aufrufen
-(etwas) bezeugen;(etwas) als Zeuge aussagen
-Belastungszeugin;Zeugin der Anklage;Belastungszeuge;Zeuge der Anklage
-wichtigster Zeuge der Anklage;Hauptbelastungszeuge;wichtigste Zeugin der Anklage;Hauptbelastungszeugin
-mit Verfallsdatum (fig.);mit begrenzter Restlaufzeit;befristet;auf Zeit (nachgestellt);vorübergehend
-Untergrundstraßenbahn;Tunnelstraßenbahn;U-Straßenbahn;Unterpflasterstraßenbahn;unterirdische Straßenbahn
-zu Lande (erreichbar);auf dem Landweg
-Pionierleistung;Pioniertat
-Neuerwerbung;Neukauf;Hinzukauf;Zukauf;(neue) Errungenschaft
-zusätzlich erwerben;hinzukaufen;zusätzlich kaufen;dazukaufen
-(etwas) zugestehen;(etwas) anerkennen;(etwas) konzedieren (geh.);(etwas) zugeben;(etwas) einräumen;(sich etwas) eingestehen
-(etwas) gestatten (geh.);(jemanden etwas) tun lassen;(etwas) genehmigen (Amtsdeutsch);(etwas) erlauben
-(jemandem etwas) lassen;(jemandem etwas) einräumen;(jemandem etwas) geben;(jemandem etwas) gewähren
-(jemandem etwas) zubilligen;anerkennen, dass;berücksichtigen, dass;(jemandem etwas) zugute halten
-(jemandem etwas) zusprechen;(jemandem etwas) zuerkennen
-kodikologisch;handschriftenkundlich
-Barockengel (fig., scherzhaft-ironisch);BMW 501 (auch für 'BMW 502') (Hauptform)
-Was du heute kannst besorgen, das verschiebe ruhig auf morgen. (ironisch);Kommst du heut' nicht, kommst du morgen. (ironisierend);Morgen ist auch noch ein Tag.
-(sich) eines Besseren belehren lassen (müssen);(seine) Ansichten revidieren (müssen);eines Besseren belehrt werden
-zugeben müssen, dass man sich geirrt hat;eines Besseren belehrt werden
-(jemandem) die Augen öffnen (fig.);(jemanden) aufklären (über);(jemandem) ein Licht aufstecken (fig.);(jemandem) erzählen, was (da) eigentlich los ist (ugs.)
-unzertrennlich sein;zusammen sein;(immer) zusammenstecken (mit)
-weiter geht's nicht;(da ist) Endstation (fig.);(da ist) Ende
-Mushing;Hundeschlitten fahren (engl.)
-Schlitten;Kufenfahrzeug
-Pulka;Nansenschlitten
-ziellos;kreuz und quer;ohne (rechtes) Ziel;in verschiedene(n) Richtungen
-Stagehand (engl.);Bühnenhelfer;Aufbauhelfer
-eingehen (auf);über jedes Stöckchen springen (das einem hingehalten wird) (fig.);einsteigen (auf);(sich) aus der Reserve locken lassen;(sich) provozieren lassen;hüppen (auf) (ugs., norddeutsch, ruhrdt.)
-rührend (hilflos) (ironisch);(von) mitleiderregend(er Blauäugigkeit) (ironisch)
-vordeuten;vorausweisen;präfigurieren
-Ziergiebel;Wimperge;Wimberg;Wimperg
-McDoof (derb, abwertend);McDonalds;Mäckes (ugs.)
-(sich) massiv auswirken (auf);(voll) reinhauen (ugs., jugendsprachlich)
-reinhauen (ugs.);(eine) starke Wirkung haben;stark wirken
-Knatterkiste (ugs., scherzhaft);Zwiebacksäge (ugs., scherzhaft)
-(es gibt) harte Auseinandersetzungen (über);heftig umkämpft (sein) (fig., variabel)
-Neptunium;Np (Abkürzung)
-nach Maß anfertigen;nach Maß arbeiten
-in Ordnung gehen (ugs.);(bei jemandem / für jemanden) gehen (Termin) (ugs., Hauptform);okay sein (ugs., salopp);passen (mit) (ugs.);(jemandem / für jemanden) passen;(jemandem) zusagen (geh.);(jemandem) recht sein;zeitlich passen(d);(sich) einrichten lassen;(sich etwas) einrichten können (geh.);(jemandem) konvenieren (geh.)
-(einer Sache) entsagen (geh.);verzichten (auf) (Hauptform);Verzicht üben (geh.);(sich einer Sache) begeben (geh., veraltet);(sich einer Sache) entschlagen (geh., veraltet);(sich einer Sache) enthalten (geh.);Verzicht leisten (geh.);(etwas) ausschlagen (Erbe)
-Namengebung (selten);Namenserteilung (Amtsdeutsch);Taufe (auf den Namen);Namensgebung (Hauptform)
-dick(er) werden;anschwellen;(sich) verdicken;schwellen
-(sich) angesprochen fühlen;(sich) den Schuh anziehen (fig.);(etwas) auf sich (selbst) beziehen
-Anbaugebiet;Kultivierungsgebiet
-alle verschiedenen ... dort (variabel);die Vielfalt der ... (in ihrer Gesamtheit);...landschaft (fig.)
-Bierleiche;Schnapsleiche
-im Rausch;unter Alkoholeinfluss (stehen);im Suff (ugs.);unter Alkohol (ugs.);im Vollrausch;sinnlos betrunken;betrunken, wie er war;in angetrunkenem Zustand;im Tran (ugs.);in seinem besoffenen Zustand (ugs.);(stark) alkoholisiert
-(...)? Schön wär's! (ugs., metasprachlich);immer (so schön) reden (von) (ugs., metasprachlich);Von (...) kann (überhaupt) keine Rede sein! (metasprachlich);Was heißt (denn) hier (...) !? (ugs., metasprachlich)
-linear;kontinuierlich
-es drunter nicht machen (ugs.);auf Sieg setzen (auch figurativ);auf Sieg spielen (fig.);den Sieg holen wollen;(sich) nur mit dem ersten Platz zufriedengeben;unbedingt gewinnen wollen;alles oder nichts wollen
-(die) Konflikte (zwischen ...) wurden ausgeräumt;Konflikte ausgeräumt haben;nicht im Streit gehen;(mit jemandem) im Reinen (fig.)
-auf Platz setzen;davon ausgehen, unter den ersten (drei) zu sein;auf Platz spielen (auch figurativ)
-(seine) Risiken begrenzen;nicht alles riskieren
-Pfeilschwanzkrebs (Hauptform);Hufeisenkrebs;Königskrabbe;Molukkenkrebs;Limulus (fachspr., lat.)
-ASP (Abkürzung);Pestis Africana Suum (lat.);Afrikanische Schweinepest (Hauptform);African Swine Fever (engl.)
-Virusinfektion;Viruserkrankung;Virus (ugs.);einen Virus haben (ugs.)
-Konsonantenschrift;Abdschad (fachspr.);Abjad (fachspr.)
-Adamsapfel;Pomum Adami (lat.);Prominentia laryngea (fachspr., griechisch, lat.)
-Knorpel;Cartilago (fachspr., lat.)
-Gentest;DNS-Test;Genanalyse;DNA-Test;DNA-Analyse;DNS-Analyse
-neuartiges Coronavirus 2019;SARS-CoV-2;Wuhan-Virus
-Schweres Akutes Respiratorisches Syndrom;SARS
-geklaut (derb);plagiiert (fachspr.);(ohne Kenntlichmachung) übernommen;abgekupfert (ugs., negativ);(woanders) abgeschrieben (ugs.)
-Verstoß gegen das Urheberrechtsgesetz;Urheberrechtsverletzung
-(bereits) verbraucht worden sein;nicht mehr benutzt werden können;verbrannt sein (ugs., Neologismus, fig.);(schon) verbraten haben (ugs.);(schon) benutzt worden sein
-ABC-Buch;Anfängerlesebuch;Fibel;Leselernbuch (Hauptform);Kinderfibel
-Dialogregie;Synchronregie
-Dialogregisseur;Synchronregisseur
-Kinderschar;Rasselbande
-so schnell nicht aufgeben;Ausdauer haben;(einen) langen Atem haben;Durchhaltevermögen haben;nicht (so) schnell aufgeben;Stehvermögen zeigen
-(etwas / jemand) verträgt nicht;...intolerant
-an (+ Substantiv) kaum zu überbieten;in höchstem Maße (+ Adjektiv);seinesgleichen (/ ihresgleichen) suchen (geh.);von äußerster (/ von äußerstem + Substantiv);äußerst (+ Adjektiv);unschlagbar (+ Adjektiv)
-(sich) einer Sache schämen (geh.);(sich) schämen (für etwas) (Hauptform);(jemandem) peinlich sein;nicht stolz sein (auf) (ugs., verhüllend);(vor Scham) die Augen niederschlagen;(jemandem) unangenehm sein (ugs., verhüllend);(sich) genieren;Scham empfinden (geh.)
-mit Schamgefühlen verbunden (sein);schambesetzt (sein);Schamgefühle auslösen
-(einen) Antrag stellen (auf);einkommen (um) (geh., veraltend);(ein) schriftliches Ersuchen richten an (geh.);(etwas) beantragen;(ein) Gesuch einreichen;(ein) Gesuch stellen (auf)
-(jemanden) zu einer unbedachten Äußerung verleiten (wollen);(eine) Fangfrage stellen (Hauptform);(jemanden) dazu bringen, etwas zu sagen, das er später bereut;(jemanden) aufs Glatteis führen (wollen) (fig.)
-(jemanden) hereinlegen (wollen);(jemanden) linken (wollen)
-(sich) genieren;(jemanden) verlegen machen;(jemandem) unangenehm (sein);(sich) peinlich berührt fühlen;(jemandem) peinlich (sein);(jemanden) in Verlegenheit bringen
-(jemandem) unangenehm sein (etwas zu tun);(sich) genieren (etwas zu tun);Hemmungen haben (etwas zu tun)
-keine Hemmungen haben (etwas zu tun);da kennt (d)er nichts (ugs.);(etwas) (ganz) ungeniert tun;da ist (d)ie ganz ungeniert (ugs.)
-(ist jedenfalls) meine Meinung! (ugs.);Ist einfach so! (ugs.);Ist so! (ugs.)
-kreatives Chaos (floskelhaft, ironisierend);Chaos;Durcheinander;Unordnung;Unaufgeräumtheit
-konsolidierte Bilanz;konsolidierter Abschluss;Konzernabschluss;Konzernbilanz
-auschecken (Hotel);(die) Abreiseformalitäten erledigen
-(das) Auschecken;Check-out
-Brotbüchse;Lunchbox;Frühstücksbox;Brotbox;Butterbrotdose;Brotdose
-Kerzenhalter;Kerzenständer
-Vorratskauf;Hamsterkauf;Kauf auf Vorrat;Bevorratung (fachspr.)
-Frequenz;Häufigkeit
-in bestimmten zeitlichen Abständen;in einem bestimmten Rhythmus
-(das) Endergebnis ist;(das) Ergebnis ist;(jemandes) Berechnung ergibt;kommen (auf);am Ende haben (beim Rechnen) (ugs.)
-diese Anzahl (von);so viele
-Caput Mauri (lat.);Destillierhelm;Helm;Galea;Alambik;Alambic;Alembicus (lat.);Alembik;Alambique;Alembic;Brennhut;Capitellum (lat.)
-Amylum Maydis (lat.);Maisstärke
-Weizenstärke;Amylum Tritici (lat.)
-Amylum Oryzae (lat.);Reisstärke
-Kuse;Breschmesser
-Gysarme;Guisarme;Gisarme;Jasarme;Gesa
-Kataphrakt (griechisch);Clibanarius (lat.);Panzerreiter
-Bluechip (engl.);Blue Chip (engl.);Standardwert
-Zombieunternehmen;Zombiefirma
-Voice-over;Stimme aus dem Off;Voiceover;Off-Stimme;darübergelegte Stimme
-Parameter;Übergabewert
-Frauenkränzchen;Kaffeekränzchen;Damenkränzchen;Weiberrunde (derb);Kaffeeklatsch
-Versorgungsengpass;Beschaffungsstau (fachspr., Jargon);(der) Markt ist leergefegt (ugs., fig.);Lieferengpass;Nachschubprobleme;Lieferschwierigkeit(en)
-Spinner-Delfin;Ostpazifischer Delfin (fachspr.);Stenella longirostris (fachspr., griechisch, lat.)
-Trompetentierchen;Stentor
-Ciliophora (fachspr.);Wimperntierchen (fachspr.);Ciliata (fachspr., veraltet)
-Zellmund;Mundöffnung;Cytostom (fachspr., griechisch, lat.)
-kein Bedarf (ugs.);kein Interesse (ugs.);(den/die/das) will ich nicht (ugs.);(den/die/das) will ich nicht geschenkt haben (ugs.)
-Sachstand;Status (fachspr.);(aktueller) Stand der Dinge
-Mundart sprechen;Dialekt sprechen;(Dialektbezeichnung) sprechen;kein Hochdeutsch sprechen
-Platt(deutsch) küren;Platt praten
-(Hamburger) Platt schnacken;(Hamburger) Platt snacken
-aufzeichnen (Tonbandmitschnitt);auf Band aufnehmen;mitschneiden (Ton);aufnehmen
-(jemanden als ...) akzeptieren;(irgendwo freundlich / herzlich ...) aufgenommen werden;(jemanden) aufnehmen (in)
-Mitglied werden (bei);aufgenommen werden (bei);(jemanden als Mitglied) aufnehmen
-(jemandem) seine Rechte nehmen;(jemanden) entrechten;(jemanden) in seinen Rechten beschneiden;(jemanden) rechtlich schlechter stellen
-Entrechtung;rechtliche Schlechterstellung
-unterschreiben (bei);wechseln (zu) (Verein)
-Nachmittagstee;Nachmittagskaffee;Fünfuhrtee
-Schwarmlinie;Schützenlinie
-Truppenkörper;Truppenteil;militärische Formation
-Südliche Anakonda;Gelbe Anakonda;Paraguay-Anakonda;Eunectes notaeus (fachspr., griechisch, lat.)
-Grüne Anakonda;Eunectes murinus (fachspr., griechisch, lat.);Große Anakonda
-Reprise (Theater) (franz.);Wiederaufnahme;Wiederaufführung
-Wiederholung (ugs.);Wiederholungssendung
-noch einmal tun;wiederholen;noch einmal machen
-erneute Durchführung;nochmaliger Durchlauf;Wiederholung
-abfahren (Profil);runterfahren (ugs.);runterschruppen (ugs., Jargon, salopp)
-(jemanden) testen;examinieren;(jemanden) einen Test machen lassen;einem Test unterziehen;(jemanden) prüfen (Hauptform)
-(jemanden) probearbeiten lassen;(jemanden) antesten (ugs.);(jemanden) probehalber einsetzen;(jemanden) zur Probe arbeiten lassen;(jemanden) auf Probe beschäftigen
-Schnupperpraktikum;Probearbeit;Arbeit auf Probe;Einfühlungsverhältnis (fachspr., juristisch)
-Praktikum;Referendariat;Famulatur (fachspr., medizinisch);Voluntariat;Vikariat;Stage (franz., schweiz.);Traineeprogramm
-Beamtenverhältnis auf Widerruf;Referendariat (Hauptform);Vorbereitungsdienst
-Suche nach einer passenden Formulierung;Ausdrucksbedürfnis;angestrebte Bedeutung;Aussageabsicht
-Tunica conjunctiva (lat.);Konjunktiva (lat.);Bindehaut
-im Rennen bleiben;nicht aufgeben;seine Kandidatur aufrechterhalten;seine Kandidatur nicht zurückziehen
-konkurrieren (um);im Rennen sein (fig.);Mitbewerber sein;im Wettbewerb stehen
-(einer) Auseinandersetzung nicht aus dem Weg gehen;(sich) der Kritik stellen;(sich) stellen;(sich) der Auseinandersetzung stellen
-(jemanden) umhauen (ugs., fig.);abrutschen (fig.);(jemanden) aus dem Gleichgewicht bringen (fig.);(jemandem) den Boden unter den Füßen wegziehen (fig.);in eine Krise rutschen;in eine (tiefe) Krise geraten;(jemanden) aus der Bahn werfen (fig.);jeden Halt verlieren (fig.)
-(das) Handtuch noch nicht geworfen haben (fig.);nicht aufgeben;(sich) nicht geschlagen geben;noch nicht am Ende sein;weiterkämpfen;noch nicht aus dem Rennen sein (fig.);noch nicht aufgegeben haben
-(es ist) noch nicht gelaufen (für) (fig.);noch Chancen haben;noch nicht aus dem Rennen sein (fig.);das Rennen ist (für jemanden) noch nicht gelaufen (fig.);(sich) noch Chancen ausrechnen (können)
-Gefährdungslage;Bedrohungslage
-halbkugelförmig;halbkugelig;hemisphärisch (fachspr.)
-per Videoschalte (bei jemandem) (Jargon);(jemandem) zugeschaltet sein (Jargon)
-Kernarbeitszeit;Kernzeit
-Schwelgerei;Schlemmerei
-(Grenzen von) Tabus überschreiten;Grenze(n) des Sagbaren (erweitern)
-Hauptakteur (fig.);(wichtiger) Player (engl., fig.);(großer) Player (engl., fig.)
-Wer hat dir (denn) diesen Floh ins Ohr gesetzt?;wie kommst du auf (...)?;(von ...) war nie die Rede!
-du kannst Fragen stellen! (ugs.);was fragst du so blöd! (ugs.);(ja) was denn sonst! (ugs.);frag nicht so blöd! (ugs.)
-nach Kundenvorgabe (Hauptform);nach Kundendefinition;nach Kundenspezifikation;nach Kundenwunsch;nach Lastenheft (fachspr., technisch)
-(einen Rat) beherzigen;(sich etwas) sagen lassen;(sich etwas) zu Herzen nehmen;(einen Rat) befolgen;(einem Rat) folgen;(auf jemanden) hören
-kilometerweit danebenliegen (mit) (ugs., fig.);(sich) gewaltig täuschen;weit gefehlt (sein) (geh.);(sich) gewaltig irren;total danebenliegen (ugs., variabel)
-Rekrutierung;Aushebung
-Einberufungsbefehl (ugs.);Einberufungsbescheid
-(jemanden) unter Hausarrest stellen;Hausarrest verhängen (über);(jemandem) verbieten, das Haus zu verlassen;(jemandem) Hausarrest geben (ugs.);Hausarrest bekommen (ugs.)
-(jemanden) nicht nach draußen lassen (ugs.);(jemanden) zu Hause festhalten
-anordnen, dass die Menschen ihre Wohnung nicht verlassen dürfen;(eine) Ausgangssperre verhängen (Hauptform)
-Spökenkieker (ugs., westfälisch);Geisterseher;Medium
-Séance;(spiritistische) Sitzung;Geisterbeschwörung
-trockener Husten;nicht abhusten können;Reizhusten;Husten ohne Auswurf;unproduktiver Husten (fachspr.)
-das lasse ich nicht mit mir machen!;das lassen wir uns nicht gefallen;das wird Folgen haben;so lasse ich mich nicht behandeln;das hat Konsequenzen
-(etwas) unternehmen (gegen);(etwas) nicht unwidersprochen hinnehmen;(sich) etwas nicht bieten lassen
-(dann ist) (aber) Panhas am Schwenkmast (ugs., ruhrdt.);(es gibt) Kasalla (ugs., rheinisch, salopp);(dann gibt es) Stress (ugs.);(da ist) (aber) die Kacke am Dampfen (derb);dann ist Stress angesagt (ugs.);(es) setzt was (ugs., veraltend);(das gibt) Ärger! (ugs.)
-Knallcharge (geh.);Pflaume (ugs.);Knalltüte (ugs., fig.)
-standesgemäß;standesgerecht
-Herrenfußball;Männerfußball
-eher unter dem Namen (...) bekannt;eher unter dem Namen (...) geläufig;besser bekannt als;eher bekannt als
-von Tag zu Tag (+ Komparativ, z.B. 'besser');jeden Tag (+ Komparativ) (ugs.);zusehends (Hauptform);mit jedem Tag
-(der / die) kann ganz ruhig sein! (ugs.);(der / die) kann sich nicht beklagen! (ugs.);was soll(en) erst (...) sagen! (ugs.);Was soll ich denn sagen! (ugs.)
-verhältnismäßig flott (ugs.);zusehends (+ Komparativ);unerwartet schnell;dann doch recht schnell (ugs.);recht zügig (ugs.);relativ schnell
-(etwas) riskieren;(es) ankommen lassen (auf);(etwas) in Kauf nehmen
-kampfentschlossen;kampfbereit;zum Kampf entschlossen
-(sich) nicht einschüchtern lassen;(jemanden) nicht schrecken (geh.);keine Angst haben (vor)
-sogar bis (zu);bis hin zu
-schimmernde Wehr (auch figurativ, auch ironisch);militärischer Pomp
-Geschichte(n) von Heldentaten;Heldenmythos (Hauptform);Heldengeschichte;ruhmreiche Vergangenheit (floskelhaft);Geschichte(n) aus großer Zeit
-Paradeuniform;Gardeuniform;Galauniform
-kampfbereit;waffentragend;gerüstet;gewappnet;unter Waffen (stehen);in Waffen (stehen);bewaffnet;(voll) ausgerüstet
-umschlagen (Stimmung, Wetter);(sich) verschlechtern;kippen (ugs., fig.)
-einsacken;Profit schlagen aus;(jemanden) abkassieren;Gewinn schlagen aus;(jemanden) abcashen (ugs., jugendsprachlich);absahnen;Kasse machen
-(jemandem) ans Geld gehen;(jemandem) an sein Geld gehen;(jemandem) das Geld aus der Tasche ziehen
-Kafi fertig (ugs., schweiz.);Espresso mit Schuss;Caffè corretto (ital.);Kaffee mit Schuss
-jeden Werktag wiederkehrend;werktäglich;montags bis freitags
-(da) erweist sich der Meister;(da) zeigt sich wahre Könnerschaft
-(etwas) gut (/ schlecht) finden;(jemandem) gefallen;(jemandem) behagen (geh.);(jemandem) schmecken (ugs., fig.);(etwas) goutieren;(nicht / ganz) nach jemandes Geschmack sein
-(jemandem) konvenieren;jemandes Vorstellungen entsprechen;(jemanden) zufrieden stellen (Hauptform);(es) jemandem recht machen
-lugen;einen Blick riskieren;(einen) verstohlenen Blick werfen (auf);lucki-lucki machen (ugs., veraltet);aus den Augenwinkeln beobachten;(verbotenerweise) gucken;ein Auge riskieren;(jemanden) belauern;(als Voyeur) spannen;spionieren;lünkern (ugs., ruhrdt.);lauernd mit Blicken verfolgen;lauern;linsen (ugs., regional);heimlich beobachten;(heimlich) spähen;ausspähen
-Amarant (Hauptform);Amaranthus;Fuchsschwanz;Amaranth
-therapieresistent;austherapiert
-Stabsquartier (fachspr., veraltet);Kommandozentrale (ugs., auch figurativ);Gefechtsstand
-einem Risiko aussetzen;einer Gefährdung aussetzen;gefährden;in Gefahr bringen
-auf der Bühne;im Theater
-unter Laborbedingungen;in einer künstlich geschaffenen Umgebung
-auf den Effekt zielen (geh.);Eindruck machen wollen;beeindrucken wollen
-Homeoffice machen;im Homeoffice arbeiten;von zu Hause aus arbeiten;zu Hause bleiben und von dort aus arbeiten
-im privaten Umfeld;im Privatleben
-an jemandes Arbeitsplatz;an jemandes Arbeitsstelle;(bei jemandem) auf der Arbeit
-(irgendwo) seine Heimat haben;(irgendwo) zu Hause sein;(jemandes) Heimat sein;(irgendwo) sein Zuhause haben
-Ebola-Check;Heinsberger Gruß
-Eins-zu-eins-...;vollständig;hundertprozentig
-ein Betreuer, der nur für eine(n) ... zuständig ist;ein Betreuer pro (Fall / Patient / Kind ... o.ä.);Eins-zu-eins-Betreuung (Hauptform)
-Lockheed F-104 'Starfighter';Witwenmacher (derb, Jargon);Starfighter (ugs.)
-zelotisch;eifernd (gegen);wie besessen;fanatisch;blindgläubig
-Notabschaltung;(das) Not-Aus
-automatische Abschaltvorrichtung;Totmannknopf;Totmannschalter
-INCI (fachspr., Abkürzung, engl.);Internationale Nomenklatur für kosmetische Inhaltsstoffe;International Nomenclature of Cosmetic Ingredients (fachspr., engl.)
-Pinne (ugs.);Pinnnadel;Pinnwandnadel
-Fähnchen (zum Anpinnen);Markiernadel;Landkartennadel
-auflaufen;auffahren (auf);(auf etwas) fahren;auf Grund laufen;stranden
-steckenbleiben;(sich) festfahren (Hauptform);durchdrehen (Räder);(sich) festlaufen;stecken bleiben
-Kolonne;Tross;Pulk;Mannschaft;Trupp
-Staubschutzmaske;Mundschutz;Atemschutzmaske
-Reginaventil;italienisches Ventil
-durchatmen können (fig.);nicht (zu) befürchten brauchen, dass;nicht befürchten müssen, dass;keine Angst haben müssen;keine Angst (zu) haben brauchen
-ICBN (fachspr., Abkürzung, veraltet);International Code of Botanical Nomenclature (fachspr., engl., veraltet);International Code of Nomenclature for algae, fungi, and plants (fachspr., engl., Hauptform);ICNafp (fachspr., Abkürzung, Hauptform);Internationaler Code der Nomenklatur für Algen, Pilze und Pflanzen (fachspr., Hauptform);Internationaler Code der Botanischen Nomenklatur (fachspr., veraltet)
-ICNCP (fachspr., Abkürzung, engl.);International Code of Nomenclature for Cultivated Plants (fachspr., engl.);Internationaler Code der Nomenklatur der Kulturpflanzen
-Internationale Regeln für die Zoologische Nomenklatur;ICZN (fachspr., Abkürzung, engl.);International Code of Zoological Nomenclature (fachspr., engl.)
-dahin stellen, wo man es hergenommen hat (ugs.);wieder an den alten Platz stellen;zurückstellen (Hauptform)
-Stümper (abwertend);Murkser (ugs., abwertend);Nichtskönner;Pfuscher (ugs., abwertend)
-Barbier (fachspr., historisch);Feldscher (fachspr., militärisch);Wundarzt;Bader (fachspr., historisch);Heilgehilfe
-Vorbereitungen treffen;Maßnahmen vorsehen;Vorkehrungen treffen;Anstalten treffen;Vorsichtsmaßnahmen ergreifen
-bestätigen;(eine These) stützen
-die Farbe wechseln;erst blass (, und) dann rot werden
-(jemanden) rot anlaufen lassen;(jemanden) rot werden lassen;(jemandem) die Schamröte ins Gesicht treiben;(jemanden) zum Erröten bringen
-(sich etwas) spendieren;(sich etwas) gönnen (auch ironisch);(sich etwas) leisten;(sich etwas) erlauben;(sich etwas) genehmigen
-langwieriges Verfahren;Prozedur (Hauptform);formaler Ablauf
-Keimreduktion;Desinfektion;(das) Desinfizieren
-(Geld) umsetzen;(Geld) einnehmen;Erlöse erzielen;verkaufen;Umsatz machen
-so und soviel (veraltet);beispielsweise (vor Zahl);soundsoviel (veraltet);x (Platzhalter-Zahl);so und so viel (Hauptform)
-weil dafür (hier) nicht genug Platz ist;aus Platzgründen;aus Platzmangel
-schamrot (werden);erröten;rot werden;einen roten Kopf bekommen
-aschfahl (im Gesicht) werden;käseweiß werden;erbleichen;leichenblass werden;das Blut weicht aus jemandes Gesicht (geh., literarisch);alle Farbe verlieren (Gesicht);kreidebleich werden
-Pflanzenwurzel;Wurzel
-vor lauter Verlegenheit nicht wissen, wohin (man) schauen (soll) (variabel);(jemandem) außerordentlich peinlich sein;(sich) in Grund und Boden schämen;vor Scham im Erdboden versinken (wollen)
-hektische Flecken (bekommen);rote Flecken (an Hals und Dekolleté);Stressflecken;nervöse Flecken
-Wortzusammensetzung;Komposition
-zusammengesetztes Wort (Hauptform);Zusammensetzung;Kompositum (fachspr., Hauptform);Doppelwort
-keinen Unterricht haben;unterrichtsfrei bekommen;(Schülern) freigeben;unterrichtsfrei haben;vom Unterricht beurlauben
-(eine Zeitlang) frei haben (ugs., Hauptform);nicht arbeiten müssen;(von der Arbeit / vom Dienst) freigestellt sein / werden;(von der Arbeit / vom Dienst) beurlaubt sein / werden;(von der Arbeit / vom Dienst) befreit sein;Urlaub (bekommen) haben;nicht zu arbeiten brauchen
-(jemandem) Urlaub gewähren;(jemandem) Urlaub geben;(jemanden) beurlauben
-Einkommensverlust(e);Lohneinbuße(n);Verdienstausfall;Gehaltskürzung(en)
-Überlebenskampf;(es geht um die) nackte Existenz
-um sein (finanzielles / wirtschaftliches / politisches / nacktes) Überleben kämpfen;ums Überleben kämpfen;versuchen zu überleben;versuchen, (irgendwie) durchzukommen;Nur die Starken überleben. (ugs., Gemeinplatz)
-(es geht um ) Leben und Tod (für jemanden);um sein Leben kämpfen
-Location Tracking (fachspr., Jargon);Verfolgen eines Bewegungsprofils;Verfolgen eines Bewegungsmusters;Mitverfolgen des Standortverlaufs
-nackte Existenz;physisches Überleben
-Titelliste (Hauptform);Tracklist (Musik-CD) (engl.);Musiklaufplan (Radio);Setlist (Konzert) (engl.)
-die Vorauswahl bestehen;es in die engere Wahl schaffen;die Vorauswahl überstehen;in die engere Wahl kommen;in die engere Auswahl kommen
-Aufstiegsrunde;Aufstiegsspiel(e);Qualifikationsspiel(e)
-Relegationsrunde;Entscheidungsspiel(e);Relegationsspiel(e)
-forttragen;davontragen;wegtragen
-Längenmaßeinheit;Längenmaß;Längeneinheit
-noch nicht ausgeschieden (sein);noch dabei (sein) (ugs.);noch im Rennen (sein) (fig.);nicht nicht rausgeflogen (sein) (ugs., salopp);(sich) halten können (ugs.);noch im Spiel (sein) (auch figurativ)
-Lautwegfall im Wortinnern;Synkope (fachspr.)
-Apokope;Lautwegfall am Wortende
-Epheu (veraltet);Efeu;Hedera helix (fachspr.)
-Rebsorte;Traubensorte
-Primitivo;Zinfandel (amerikanisch)
-aus (reiner) Gewohnheit;gewohnheitsmäßig;routinemäßig;ohne nachzudenken;ganz automatisch
-(der) Ernst des Lebens;(das) tägliche Kleinklein (ugs.);Hamsterrad (fig.);(die) Mühen der Ebene(n) (geh., Zitat);tägliche Plackerei;Tretmühle (fig.);das tägliche Klein-Klein (ugs.)
-(ein) Leben ohne Verpflichtungen;(die) ganz große Freiheit;(der) Geschmack von Freiheit und Abenteuer (Spruch, ironisierend)
-Vorbestellung;Subskription (fachspr.);Vorabbestellung;Subskribierung (fachspr.)
-Das hast *du* (aber jetzt) gesagt! (ugs., ironisierend);Wie recht du hast! (auch ironisch);Da hast du völlig recht!;Allerdings! (Antwortpartikel) (ironisierend);Schön, dass du es einsiehst! (auch ironisch)
-ich hab (doch) Augen im Kopf (ugs.);versuch gar nicht erst, das abzustreiten;mir machst du nichts vor (ugs.)
-verstellen;falsch einstellen
-(die) Arbeitsgemeinschaft der öffentlich-rechtlichen Rundfunkanstalten der Bundesrepublik Deutschland;(die) ARD
-vorstellen (Uhr);auf eine spätere Zeit (ein)stellen
-zu früh dran sein (ugs.);eine zu späte Zeit anzeigen;vorgehen (Uhr) (Hauptform);ihrer Zeit voraus sein (ironisierend)
-epidemisch anwachsen;epidemische Ausmaße annehmen;zur Epidemie werden
-(sich) epidemisch ausbreiten (fig.);zur Landplage werden (negativ);(sich) epidemisch verbreiten (fig.);grassieren;(sich) massenhaft verbreiten (negativ)
-...herd (fig.);Brennpunkt;Hort (des / der ...);Epizentrum (fig.);Hotspot
-Infektionscluster;gehäuftes Auftreten von Infektionen
-wieviel Uhr ist es?;was sagt die Uhr? (ugs., Spruch);wie spät ist es?;wie spät ha'm wer's? (ugs.)
-auf meiner Uhr (ist es ...);wenn meine Uhr richtig geht (dann ...);nach meiner Uhr (ist es ...)
-es ist (jetzt genau) ... Uhr;wir haben ... Uhr
-eine zu frühe Zeit anzeigen;zu langsam gehen;(der) Zeit hinterherhinken;nachgehen (Uhr) (Hauptform)
-falsch gehen (Uhr);nicht die richtige (korrekte / wirkliche) Zeit anzeigen;nach dem Mond gehen (ugs., fig.)
-Spitzer;Anspitzer;Bleistiftspitzer
-Collegeblock;Schreibblock (Bindung links);Spiralblock;Seminarblock
-(die) Anlaufschwierigkeiten überwinden;sich einspielen;(sich) zurechtruckeln (Neologismus, fig.)
-Riesen-Taro;Riesenblättriges Pfeilblatt;Alokasie
-Irisches Moos;Graupen (österr.);Islandmoos;Fiebermoos;Cetraria islandica (fachspr., griechisch, lat.);Lichen Islandicus;Isländisches Moos;Blutlungenmoos;Hirschhornflechte
-Irländisches Moos;Carrageen-Moos;Carrageen-Alge;irländisches Perlmoos;Gemeiner Knorpeltang;Knorpelmoos;Perlmoos;Irisch Moos;Carragheen-Moos;Chondrus crispus (fachspr., griechisch, lat.);Carragheen-Alge;Knorpeltang
-beruflich veranlasst (sein);zu jemandes Aufgaben gehören;berufsbedingt (sein);zur Arbeit gehören;beruflich bedingt (sein)
-Fundus (Museum);Magazin (z.B. Bibliothek);Depot
-Eigenkreation;Eigenschöpfung
-Schneckenlinie;Spirale
-nachstellen (Uhr);auf eine frühere Zeit einstellen
-das tägliche Einerlei;der graue Alltag
-(es sind) alle Tage gleich;(da ist) ein Tag wie der andere
-(ewas) über sich ergehen lassen müssen (fig.);(einer Sache) schutzlos ausgeliefert sein;(etwas) abbekommen (ugs.);(einer Sache) ausgesetzt sein (Strahlung, Regen ...)
-Stellung vor der linken Satzklammer;Vorfeldbesetzung
-große Zahl von Neuinfektionen;Infektionsschub;Infektionswelle;Epidemie
-die Klingen kreuzen;gegeneinander fechten;gegeneinander mit dem Degen (Schwert / Säbel) kämpfen
-die Klingen kreuzen (fig.);gegeneinander antreten
-vor der Brust verschränken;kreuzen (Arme);übereinanderschlagen (Arme)
-(jemanden) nicht beachten;so tun, als wenn jemand nicht da wäre;(jemanden) ignorieren
-zu(m) Sklaven machen;unterjochen;(ver)knechten;versklaven
-(jemandem) einen guten Preis machen;(jemandem) mit dem Preis entgegenkommen
-(sich) offen zeigen;(sich) zur Geltung bringen (Hauptform);sein Licht nicht unter den Scheffel stellen (ugs., fig.);(sich) präsentieren;(sich) in Szene setzen;(sich) nicht verstecken;Präsenz zeigen;öffentlich auftreten
-(Sitz der) Stadtverwaltung;Rathaus (Hauptform);Bürgermeisteramt;(Sitz der) Gemeindeverwaltung
-Magistrat;Verwaltungsspitze
-weitergehen;durchgehen (trennbar);nicht warten
-glibberig (ugs.);gallertartig;gelantineartig
-(...) schon (Aufforderung);(...) endlich (Aufforderung)
-windig;böig;stürmisch
-lausig (ugs.);mick(e)rig (ugs.);armselig;kümmerlich;popelig (ugs.);piselig (ugs., rheinisch);pupsig (ugs.)
-(die) Frankfurter Schule;(die) Kritische Theorie
-von geringem Prestige;inferior (geh.);wenig angesehen;geringwertig;klein (ugs.);einfach (ugs.);niedrig;nieder;unbedeutend
-Seligkeit;Glückseligkeit
-auf den;aufn (ugs.)
-(irgendwo) herausspazieren;(unbehelligt) weggehen
-alles ist erlaubt (bei);Anything goes. (Jargon, Spruch, engl.);Alles kann, nichts muss. (Spruch);offen für alles (sein);alles geht (bei jemandem)
-Doppelmoral;Doppelstandard;mit zweierlei Maß messen
-nach alter Auffassung;so dachte man seinerzeit;nach damaliger Ansicht;aus damaliger Sicht
-Kontaktverbot;Kontaktsperre
-Ausgangsbeschränkung(en);Einkränkung(en) der Bewegungsfreiheit
-Verständnis;(ein) Einsehen;Einverständnis;Einsicht
-Alkoholverzicht;Alkoholabstinenz
-absetzen (Medikament, Alkoholkonsum);weglassen (ugs.);aufhören (mit) (ugs.);nicht mehr (ein)nehmen
-Verfassungstheorie;Verfassungslehre
-Halbleiterwerk;Chipfabrik;Fab (Kurzform, engl.);Halbleiterfabrik
-Sadomasochismus;Sado-Maso (ugs.);SM;BDSM
-Top;Dom
-Sub;Bottom
-Herr;Sado (Hauptform, männl.);Meister
-submissiv;submiss;untertänig;sklavisch
-Paritätsgesetz;Parité-Gesetz
-Happy End (Hauptform);glücklicher Ausgang;gutes Ende;Happyend
-die Potenz anregen;die Manneskraft stärken;(ordentlich) Tinte auf den Füller geben (ugs., fig.)
-(sich das) Geld zusammensparen (für);sparen (auf)
-in einen stationären Aufenthalt überstellen (Amtsdeutsch, verhüllend);hospitalisieren;ins Krankenhaus einweisen;in eine stationäre Behandlung überstellen (Amtsdeutsch)
-woher soll ich das wissen?;und da fragst du (ausgerechnet) mich? (ugs.);wieso fragst du mich? (ugs.);(ja) was weiß denn ich!? (ugs.)
-denk mal an! (ugs.);nein sowas! (ugs.);wer hätte das gedacht!
-an wechselnden Orten;bald hier, bald da;mal hier, mal da;hier mal und da mal ...
-nicht schlau werden (aus);nicht wissen, woran man ist (bei)
-mit mir nicht! (ugs.);(etwas) kommt für mich nicht in Frage;ich bin raus (ugs., Neologismus);was mich angeht: nein;ohne mich! (ugs.);da bin ich raus (ugs., Neologismus)
-(sich) auf dünnem Eis bewegen (fig.);(sich) angreifbar machen;(die) Kritik herausfordern
-muscae volitantes (lat.);fliegende Mücken;Mouches volantes (franz.);Glaskörperflocken
-(bitte) nicht schon wieder! (ugs.);fängst du schon wieder damit an?;geht das (jetzt) wieder los?;jetzt geht das (schon) wieder los ... (ugs.)
-hat's dir die Sprache verschlagen? (ugs.);warum sagst *du* eigentlich nichts? (ugs.);sag sag du doch (auch) mal was! (ugs.)
-Stimmverlust;Stimmlosigkeit;Aphonie (fachspr.)
-Einnahmeverlust(e);Umsatzausfall;Umsatzeinbuße(n);Mindereinnahme(n)
-prä-;vor-
-post-;nach-
-(gut) erzogen werden;(eine) gute Erziehung genießen;(eine) gute Kinderstube abbekommen;lernen, wie man sich zu benehmen hat;gutes Benehmen lernen;sozialisiert werden;zu einem ... herangezogen werden
-(jemandem) keine große Hilfe sein (floskelhaft);nicht helfen können;nichts für jemanden tun können
-(sich) zeigen;zu sehen sein;zum Vorschein kommen;herauskommen;rauskommen (ugs.)
-einen Schlag kriegen (wenn) (übertreibend);vom Hocker fallen (wenn) (übertreibend);tot umfallen (wenn) (übertreibend)
-nicht zurückhalten können;(aus jemandem) herausplatzen (es; Gefühl; Verborgenes);(aus jemandem) hervorbrechen (es; Gefühl; Verborgenes);(aus jemandem) herausbrechen (es; Gefühl; Verborgenes);nicht länger an sich halten können
-kein Klopapier abbekommen (haben);von der Rolle sein (scherzhaft-ironisch)
-(den) Rechner ausbremsen;(eine) Systembremse (sein);(den) Rechner langsam machen;(den) Rechner verlangsamen
-geschönt (Hauptform);verbrämt;schmeichelhaft;besser als es (in Wirklichkeit) ist;gefiltert;frisiert (ugs.)
-(die) ungeschminkte Wahrheit erfahren;hinter die Fassade(n) blicken (fig.)
-drastisch zurückgehen;massiver Einbruch (bei);(praktisch) auf Null sinken;massiv einbrechen;Totalausfall (bei);drastischer Rückgang (bei);wegbrechen (Jargon, fig.);ausfallen;(plötzlich stark) zurückgehen;(plötzlich) wegfallen (Aufträge, Kunden, Einnahmen ...) (Hauptform)
-Auftragsflaute;Auftragseinbruch;Auftragsrückgang
-Sammlung;Bibliothek
-es (im Leben, mit etwas ...) nicht leicht haben;(sein) Päckchen zu tragen haben (fig.)
-Base (aus väterlicher Linie) (fachspr., veraltet);Muhme (aus mütterlicher Linie) (fachspr., veraltet);Tante (Hauptform);Tantchen (ugs.)
-Sauberkeit;Reinheit;Hygiene
-schonungslose Abrechnung (mit) (fig.);Scherbengericht (fig.);(ein) vernichtendes Urteil (über);Ostrakismos (geh., bildungssprachlich, griechisch);Ostrazismus (geh., bildungssprachlich, griechisch, lat.)
-(sich) krallen (ugs., salopp);glücklich einen der letzten ... bekommen (geh., variabel);(sich) greifen (ugs., salopp);(sich) schnappen (ugs., salopp);ergattern (knappe Ware / letztes vorhandenes) (Hauptform);(sich) grabschen (ugs., salopp);(noch) erhaschen (poetisch, regional);(sich) an Land ziehen (ugs., salopp);(mit Glück noch) bekommen;abbekommen (ugs.);(noch) erwischen (ugs.)
-(einen) Fitsch machen (ugs.);(ein) Super-Schnäppchen ergattern (ugs.);(einen guten) Fang machen (fig.)
-Voltumna;Vertumnus
-Porzellanblume;Hoya (fachspr.);Wachsblume
-Aufsitzerpflanze;Überpflanze;Epiphyt
-Ruhmeslied;Siegeslied;Epinikion (fachspr., griechisch)
-Bazillenschleuder (derb);Infektionsüberträger;Virenschleuder (derb);Bazillenmutterschiff (ugs., veraltend);Überträger
-Strass;Flitter
-Lötmittel;Lötmetall;Lot
-Hermelinfell;Hermelin
-Lehm;Tonerde;Mergel;Ton
-Korkeiche;Quercus suber (fachspr.)
-Abgas;Verbrennungsabgas
-Rückenschwimmen;Rücken (ugs., Jargon)
-Chef de rang (fachspr., Jargon, franz.);Stationskellner
-Serviceteam;(alle) Servicemitarbeiter;Servicebrigade (fachspr., Jargon)
-Commis de rang (fachspr., Jargon, Hauptform);Jungkellner;Servierer;Servierkraft
-Pikkolo (Jargon, veraltet);Kellner-Azubi (ugs.);Piccolo (Jargon, veraltet);Kellner-Lehrling
-Demichef de rang (fachspr., Jargon, franz.);stellvertretender Stationskellner
-im Giftschrank (fig.);unter Verschluss
-auf dem Index stehen(d);nicht erscheinen dürfen;indiziert sein;nicht verlegt werden dürfen
-Depressionstrichter;Absenktrichter;Entnahmetrichter;Absenkungstrichter
-(ein) Feuerwerk (der guten Laune) (Jargon, fig., floskelhaft, variabel, werbesprachlich);Höhepunkt folgt auf Höhepunkt
-ein Witz jagt denselben (ugs., ironisch);(ein) Feuerwerk des Humors (werbesprachlich)
-Unterhaltungsindustrie;Unterhaltungsbranche
-ob es dir passt oder nicht (ugs.);auch wenn es dir nicht gefällt;es mag dir gegen den Strich gehen, aber (ugs.);egal was du denkst (ugs.)
-gerichtliche Auseinandersetzung;juristische Auseinandersetzung;Rechtsstreitigkeit
-Kaffeeservice;Kaffeegeschirr
-Kaufhaus;Warenhaus
-Verpackungsmittel;Packmaterial;Verpackungsmaterial
-(Das) ist mir klar. (ugs.);Schon klar. (ugs.);(Das) weiß ich doch! (ugs.)
-sinnstiftend (geh.);sinnerfüllt (geh.);als sinnvoll erlebt;Sinn stiftend (geh.)
-anschließend aufgeführt(e);nachstehend genannt(e);die folgenden;folgend (artikelartig)
-(mit etwas) Sinn verbinden;etwas Sinnvolles tun;einen Sinn sehen (in);mit Sinn erfüllen
-Verdickungsmittel;Bindemittel
-für die Kleinen (ugs.);kindgerecht;für Kinder verständlich
-kindgerecht;an die Bedürfnisse von Kindern angepasst;auf Kinder zugeschnitten;auf die Bedürfnisse von Kindern zugeschnitten;kinderfreundlich
-etwas für Kinder (ugs.);gut für Kinder (geeignet) (ugs.);(sich) für Kinder eignen;für Kinder gedacht;kindertauglich
-nichts für Kinder (ugs.);nicht kindgerecht;nicht gut für Kinder (geeignet) (ugs.)
-rauschhaft;dionysisch (bildungssprachlich)
-Essen aus der Dose;Dosennahrung;Dosenfraß (derb)
-nicht den leisesten Zweifel haben (an);volles Vertrauen haben (in);völlig überzeugt sein (von)
-So viel Verstand hätte ich dir gar nicht zugetraut!;Du bist mir ja ein pfiffiges Kerlchen! (ugs.);(doch) nicht so dumm wie du aussiehst! (derb);(du bist ja) schlauer als ich dachte!
-Gezücht;Brut
-Anpassung;Überarbeitung;Aktualisierung
-Anpassungen vornehmen;abstimmen (auf);adaptieren (an / für) (fachspr.);harmonisieren;in Einklang bringen (mit);anpassen (an)
-nicht aktiv werden müssen;nicht tätig werden müssen;nichts tun müssen;nichts veranlassen müssen;(es sind) keine (weiteren) Aktivitäten erforderlich;nichts (zu) tun brauchen (ugs.);nicht eingreifen müssen;(da ist / es gibt) kein(en) Handlungsbedarf
-(sich) versuchen (an / als) (Hauptform);sein Glück als (...) versuchen;herausfinden, ob eine Sache etwas für einen ist (variabel)
-(he)rumjammern (über) (ugs.);(he)rummaulen (ugs.);(he)rummäkeln (an) (ugs.);(he)rummeckern (an) (ugs.);(he)rumnörgeln (an) (ugs.);(he)rumnölen (ugs.);(he)rumjanken (ugs., regional);(he)rummosern (ugs.);(he)rummotzen (ugs.);(he)rumjaulen (ugs., fig., salopp)
-Drehsperre;Drehkreuz
-Rahmenbedingung(en);Bestimmung(en);Rahmen;Anforderung(en);Gegebenheit(en);Vorschrift(en);Voraussetzung(en);Umfeld;Vorgabe(n);Regelung(en)
-Kontext (geh., bildungssprachlich);Verhältnisse;Lage;Umstände;Situation
-(mit etwas) verhält es sich so;(die) Erklärung für etwas (ist);(der) Hintergrund (ist);es hat folgende Bewandtnis (mit etwas);(so) zu erklären sein
-Gendergetue (ugs., abwertend);gendergerechter Sprachgebrauch;Gendergedöns (ugs., abwertend);Genderei (ugs., abwertend);gendersensibles Formulieren;Gender-Gaga (derb, stark abwertend)
-Pölzung (fachspr., österr.);Spriessung (fachspr., schweiz.);Verbau (fachspr., bundesdeutsch)
-Blick auf die aktuelle Lage;Lagebeurteilung;Analyse der Lage;Situationsdarstellung;Lagebild (Hauptform);Lagebewertung;Einschätzung der Lage;Bestandsaufnahme
-Tatbestand (fachspr., juristisch);Syllabus (fachspr., juristisch);Falldarstellung
-(sich) irritieren lassen (durch);(sich) ablenken lassen (durch);(sich) stören (an) (ugs.)
-(eine) kritische Haltung entwickeln (zu);ins Nachdenken kommen (auch figurativ);anfangen nachzudenken (auch figurativ);(einen) Bewusstseinsprozess in Gang setzen (bei) (auch figurativ, variabel)
-Begrüßungsgemüse (ugs., salopp);(mitgebrachte) Blumen
-Tamazight-Sprachen;Tamazight-Dialekte;Mazirisch
-(nur) dazu dienen, dass;(mit etwas) die Absicht verfolgen (dass);bloßes Mittel zum Zweck (sein) (Hauptform);(nur ein) Mittel zum Zweck (sein) (Hauptform);jemand will (mit etwas) erreichen, dass
-zu etwas gut (sein);(einen) Sinn und Zweck haben;kein Selbstzweck (sein)
-Coping (fachspr., engl.);Bewältigungsstrategie;Copingstrategie (fachspr.)
-Musik für Kammerensemble(s);Kammermusik;Musik für Kammerorchester
-Reparaturknowhow;Reparaturkompetenz;Reparierfähigkeit;Reparaturfähigkeit;Reparaturkenntnis;Reparaturvermögen;Reparaturbefähigung
-Reparaturmöglichkeit;Reparatureigenschaft;Reparabilität;Reparierbarkeit;Revisionsfähigkeit (fachspr.)
-bei jeder sich bietenden Gelegenheit;so oft wie möglich;wann immer möglich
-reparaturfreundlich;einfach zu reparieren (sein);leicht reparierbar sein
-Kompetenzniveau;Fähigkeitsniveau;Befähigungsgrad
-Eigenreparatur;DIY-Reparatur (fachspr., Jargon);self repair (engl);Selbstreparatur;Reparatur in Eigenregie;Do-it-yourself-Reparatur
-Anzahl der Demontageschritte;Demontagetiefe
-Einzelschritt einer Demontageabfolge;Arbeitsgang bei der Demontage;Demontageschritt
-bevorzugtes Bauteil;kritische Komponente;vorrangiges Teil
-Ersatzkomponente;Ersatzmodul;Ersatzteil
-Ersatzteillieferbarkeit;Ersatzteilerhältlichkeit;Ersatzteilzugänglichkeit;Ersatzteilverfügbarkeit
-Menge verschiedener Werkzeuge;Werkzeugaufwand;Werkzeugintensität
-Demontageabfolge;Demontageablauf;Demontagereihenfolge;Demontagesequenz
-Repaircafé;Reparaturcafé;Reparaturinitiative;Reparaturverein
-Reparaturrecht;R2R (Abkürzung, engl);Recht auf Reparatur;Right to Repair (engl)
-Reparaturverbot;Verbot der Reparatur
-Klassenausflug;Wandertag;Tagesausflug mit der (ganzen) Klasse
-Ressourcenschonung;Abfallvermeidung;Ressourcenschutz;Ressourceneinsparung;waste prevention (engl.)
-CE (Abkürzung, engl.);Circular Economy (engl.);Kreislaufwirtschaft;Kreislaufgesellschaft
-Reparaturinformation;Reparaturanleitung
-Reparaturpreis;Reparaturaufwand;Reparaturkosten
-Ersatzteilpreis;Ersatzteilkosten
-DFR (Abkürzung, engl.);design for repair (engl.);reparaturfreundliches Design (ugs.);reparaturfreundliche Konstruktion;D4R (Abkürzung, engl.)
-Werkzeugerhältlichkeit;Werkzeuglieferbarkeit;Werkzeugverfügbarkeit;Werkzeugzugänglichkeit
-Verkauf (direkt) beim Erzeuger;Verkauf ab Hof
-Upcycling (engl.);Weiterverwendung
-KrWG (Abkürzung);Kreislaufwirtschafts- und Abfallgesetz (fachspr., veraltet);Gesetz zur Förderung der Kreislaufwirtschaft und Sicherung der umweltverträglichen Bewirtschaftung von Abfällen (fachspr.);Kreislaufwirtschaftsgesetz (Kurzform)
-Gesetz über das Inverkehrbringen, die Rücknahme und die umweltverträgliche Entsorgung von Elektro- und Elektronikgeräten (fachspr.);Elektro- und Elektronikgerätegesetz (Kurzform);ElektroG (Abkürzung)
-Ecodesign (engl.);Ökodesign
-örtlich;auf lokaler Ebene;lokal
-Darf ich wissen, (...)? (geh.);Verraten Sie mir, (...)?;(...,) wenn man fragen darf (ugs.);Magst du (mir) sagen, (...)? (geh.);Würden sie mir sagen, (...)?;Darf ich erfahren, (...)? (geh.)
-wohl;ich frage mich (schon lange);ich wundere mich;wie kann es sein, (dass ...) (ugs.);wie ist es möglich, (dass ...);nur;ich würde zu gern wissen;ich verstehe einfach nicht, (...) (ugs.)
-sorgenzerfurcht (Stirn);von Sorgen gezeichnet
-von Sorgen gequält;von Sorgen geplagt;sorgengeplagt;von Sorgen zerfressen
-Postulation (lat.);Benennung (für ein hohes katholisches Kirchenamt)
-Spätgeborener;Posthumus (fachspr., veraltet);Postumus (fachspr., veraltet);Nachgeborener
-Nachsorge;Nachfürsorge (schweiz.);Postvention (fachspr., lat., neulateinisch)
-Krokette (franz.);Croquette (franz.);Krustel (landschaftlich)
-Krabbenbrot;Krupuk;Kroepoek (niederländisch);Krabbenchips
-Kaisergranat;Norwegischer Hummer;Kaiserhummer;Nephrops norvegicus (fachspr., griechisch, lat.)
-Hippokamp (griechisch);(fischschwänziges) Seepferd
-Vatersche Ampulle;Vater-Ampulle;Ampulla hepatopancreatica (fachspr., griechisch, lat.)
-Selbstrechtfertigung;Rationalisierung (fachspr., psychologisch)
-nicht wiederherzustellen;kann nicht (mehr) repariert werden;nicht (mehr) zu retten;irreparabel (geh.);rettungslos zerstört
-dagegen sein (ugs.);seine Stimme abgeben (gegen);gegen etwas sein (ugs.);(einer Sache) die Zustimmung verweigern;(etwas) ablehnen;(sich) entscheiden (gegen);stimmen (gegen) (Hauptform);mit Nein stimmen;votieren (gegen)
-stimmen (für) (Hauptform);für etwas sein (ugs.);seine Stimme abgeben (für);(einer Sache) zustimmen;(sich) entscheiden (für);mit Ja stimmen;votieren (für) (geh.);dafür sein (ugs.)
-zu früh geboren;vor der Zeit geboren;zu früh gekommen (ugs.)
-Spätgeborener (männl.);Spätgeburt;Spätgeborenes;Spätgeborene (weibl.)
-(die) Krux (Hauptform);(der) Pferdefuß (fig.);(der) Haken (an der Sache) (fig.);(der) kritische Punkt
-Da liegt der Hund begraben. (sprichwörtlich);(des) Pudels Kern (sein) (geh., Zitat);(das) eigentliche Problem (sein);(die) eigentliche Ursache (sein);Da liegt der Hase im Pfeffer. (sprichwörtlich)
-den Fahrstuhl nehmen;mit dem Fahrstuhl (hoch)fahren
-(irgendwo) abgespeichert;(irgendwo) hinterlegt (Information)
-Krankenkassenbeitrag;Kassenbeitrag (ugs.)
-Totenlade;Begräbniskasse;Sterbelade;Sterbekasse;Leichenkasse;Grabekasse
-symphonische Musik;Sinfonik (fachspr.);Symphonik (fachspr.);Konzertmusik;Musik für großes Orchester;sinfonische Musik
-Cis-Person;Cisgender-Person;Biofrau (ugs., Jargon, weibl.);Biomann (ugs., Jargon, männl.)
-Transfrau (Hauptform);Transe (derb);Frau im falschen Körper
-Mann im falschen Körper;Transmann (Hauptform)
-Transsexuelle(r);transsexuelle Person
-(an etwas ist) nicht zu denken;(es) ist nichts (mit);kann man vergessen (ugs.);nicht (mehr) gehen;(es ist) Essig (mit) (ugs.);unmöglich (sein)
-Zucht;Edukation (fachspr.);Erziehung
-Schule (ugs.);Unterricht;Schulunterricht (Hauptform)
-Fortnahme;Wegnahme;Entzug;Entziehung (fachspr., juristisch);Entwendung
-(jemandem) Bescheid geben;(eine Information)(an jemanden) weiterleiten;(eine Information)(an jemanden) weitergeben;(jemanden) in Kenntnis setzen;(jemanden) verständigen;(jemandem) Bescheid sagen (ugs.);(jemanden) benachrichtigen
-auf Sicht fahren (Neologismus, fig.);vorsichtig agieren;Veränderungen schrittweise vornehmen
-Spitzenkandidat;Kronfavorit (schweiz.)
-Alltagsmaske;Mund-Nasen-Bedeckung;Lappen (ugs., abwertend);Mund-Nasen-Maske;Mund-Nasen-Schutz;Maulkorb (derb, abwertend);Gesichtsvorhang (scherzhaft);Maske;Gesichtsfetzen (derb, abwertend)
-Neubürger werden;zuziehen
-Wegwerfgesellschaft;Überflussgesellschaft;Konsumgesellschaft
-kajolieren;liebkosen
-liebkosen;karessieren (veraltet);kajolieren (veraltet)
-DFD (Abkürzung, engl.);demontagefreundliches Design (ugs.);demontagefreundliche Konstruktion;design for disassembly (engl.);D4D (Abkürzung, engl.)
-Kreislauf...;Mehrweg...
-stehenbleiben (bei);es nicht weiter schaffen (als bis);nicht hinausgelangen (über);nicht weiter kommen (als)
-Dressboy (Pseudoanglizismus);stummer Diener;Herrendiener;Kleiderboy;Kleiderablage;stummer Butler;Anzugständer (Hauptform)
-Umstieg (auf);Wechsel (zu)
-verfügen (über);(heran)kommen (an) (ugs.);Zugang haben (zu) (Hauptform);haben (ugs.)
-weil ... fehlen;wegen ...mangel;weil ... fehlt;in Ermangelung (von / Genitiv);weil es an ... fehlt;aus Mangel an;mangels (+ Genitiv);wegen Nicht...
-Dem Mann(e) kann geholfen werden. (Spruch, Zitat);Wir haben die Lösung. (werbesprachlich);wir hätten da was (für dich / für Sie ...) (ugs.);ich hätte da was (für dich / für Sie ...) (ugs.)
-beschaffen;(etwas) organisieren (ugs.);besorgen;(etwas) holen (ugs.)
-verklappen (Hauptform);(im Meer) versenken;ins Meer kippen
-ab...;frei...;weg...;fort...;los...
-Umweltskandal;Umweltvergehen;Umweltfrevel;Umweltverbrechen;Umweltdelikt
-Müllentsorgung in der freien Landschaft;wilde Müllkippe;wilder Müll;wilde Müllablagerung
-illegale Abfallbeseitigung;unzulässige Müll-"Entsorgung"
-darben (geh.);(etwas) entbehren;Mangel haben (an) (geh., veraltet);Mangel leiden (an);Not leiden (an)
-aktive Sterbehilfe;Tötung auf Verlangen (fachspr., juristisch)
-Ehebrecher;Fremdgänger
-(sich) durch die Betten schlafen;durch die Betten hüpfen;auf (sexuelle) Abenteuer aus sein;herumhuren;Unzucht treiben;jede Menge Sex haben;durch Bars und Bordelle streifen
-(jemandem) unverständlich sein;(sich) jemandem nicht erschließen (geh., floskelhaft);nicht plausibel finden;für jemanden nicht nachvollziehbar (sein);(etwas) nicht nachvollziehen können
-(das) kleine Einmaleins (des/der ...) (ugs., fig.);(das) Grundsätzliche;(das) lernt man im ersten Semester (ugs., fig., variabel);(das) tägliche Brot (einer Tätigkeit);(die) Basics (ugs., Jargon, engl.);(das) Basiswissen (eines Fachgebiets)
-Kreditfazilität;Kreditlinie;Kreditrahmen
-(sich) bemüßigt fühlen (zu) (geh.);(sich) aufgefordert fühlen (zu);(sich) verpflichtet fühlen (zu);(es) für angezeigt halten (dass);(sich) veranlasst sehen (zu) (geh.);meinen, (dass) man müsse;(es) für nötig halten (zu);(sich) veranlasst fühlen (zu) (geh.);(sich) gehalten fühlen (zu) (geh.)
-prägende Figur;Diva;(die) Grande Dame (des / der)
-seinen geordneten Gang gehen;seinen geregelten Gang gehen
-(ein) Bürokratenherz höher schlagen lassen (fig., ironisch);Bürokratenposse;der Amtsschimmel wiehert (fig., ironisierend);da lacht das Bürokratenherz (fig., ironisch, variabel);Kaum zu glauben, aber amtlich. (ugs.);Realsatire
-tun, was von einem erwartet wird;(sich) an die Vorschriften halten;(die) Regeln respektieren
-verblühlt;abgeblühlt;ausgeblüht
-verbräunt;braun geworden
-nicht mehr getragen (Kleidung);alt;nicht mehr in Benutzung;abgelegt (Bekleidung) (auch figurativ);ausrangiert
-Second-Hand-Bücher;Antiquariat;Gebrauchtbücher
-schlimmer kann es nicht mehr kommen;perfekter Sturm (fig.);Maximum an Verwüstung;alles verschlingende Katastrophe
-Prüfung haben (ugs.);(sich) prüfen lassen;geprüft werden;(eine) Prüfung machen;(eine) Prüfung ablegen
-(die) Beichte ablegen;beichten;zur Beichte gehen
-Wohlwollen signalisieren;(einer Sache) aufgeschlossen gegenüberstehen;(sich) wohlwollend äußern;(etwas) positiv aufnehmen;sich offen zeigen (für)
-nicht essbar;bäh! (ugs., Babysprache);nicht zum Verzehr geeignet
-verwandtes Wort;(etymologischer) Verwandter;(der) Kognat (fachspr.)
-(etymologisch) verwandt;kognat (fachspr.);urverwandt (fachspr.)
-Wortwurzel;Etymon (fachspr.);(sprachliche) Wurzel
-Firmenwagen;Dienstwagen
-Privat-Pkw;Privatwagen
-(jemanden) beneiden (um);jemand hätte gerne auch (...) (ugs.);neidisch werden (bei)
-von Neid zerfressen werden (fig.);grün vor Neid werden (fig.);vor Neid platzen (fig.)
-Vorgänger im Amt;(der) letzte Amtsinhaber;(der) Amtsinhaber vor jemandem
-in einen Wettstreit treten (um);einander überbieten (in / mit);(sich) gegenseitig überbieten (mit);(miteinander) wetteifern (um)
-weiter gehen als (fig.);mehr tun als
-Bietergefecht;Bieterkampf;Bieterschlacht
-Dampfradio (fig., scherzhaft);Röhrenradio;altes Radio
-funktioniert noch;tut's noch (ugs.);geht noch (ugs.);läuft noch (ugs.);(ist) noch funktionsfähig
-Gourmet-Tempel (fig.);Feinschmeckerrestaurant
-Überbietungskonkurrenz;Überbietungswettbewerb
-eiserner Bestand;Grundbestand;Kernbestand
-(ein) Kernelement;(ein) Eckpfeiler (einer Sache);unverzichtbarer Bestandteil;tragendes Element
-(etwas) lieb gewonnen haben;(etwas) liebgewonnen haben;nicht mehr lassen wollen (von);(jemandem) lieb geworden (sein);(jemandem) liebgeworden (sein);nicht mehr verzichten wollen (auf);(etwas) nicht mehr missen wollen
-sehr hoch (Zahl, Wert);rekordverdächtig (auch ironisch)
-minimal;minim (schweiz.);(äußerst) kärglich;(sehr) karg;sehr niedrig (Hauptform);niedrigst;Niedrigst...;sehr gering
-Gefahr laufen (zu / dass);(jemand / etwas) könnte;riskieren (zu / dass)
-Hirtenwort;Hirtenbrief
-vernünftig (Preis);akzeptabel (Preis);fair (Preis);okay (Preis);angemessen (Preis)
-durchschnittlich;marktüblich (Preis);normal;im Rahmen
-viel Geld bezahlen müssen;(sich) bis aufs (letzte) Hemd ausziehen müssen;bluten müssen (für) (ugs., fig.)
-(sein) ganzes Geld ausgeben (für);(sein) letztes Geld zusammenkratzen (für);(sich) bis aufs (letzte) Hemd ausziehen (ugs., fig.)
-(die) Rufe nach (...) werden lauter;(es) mehren sich die Stimmen (die)
-unterteilt;gegliedert
-nicht der Sinn (und Zweck) der Sache;nicht (der) Zweck der Übung
-dabei soll herauskommen (dass) (ugs.);(der) Sinn der Sache ist (dass);(die) Zielvorstellung (dabei) ist (dass);dahinter steckt die Idee (dass);dahinter steht der Gedanke (dass)
-Likörwein;Süßwein;Südwein;gespriteter Wein;verstärkter Wein;Dessertwein
-Port;Portwein (Hauptform)
-Vino di Marsala;Vino Marsala;Marsala DOC;Marsala
-Bleiblockausbauchung;Trauzl-Test
-(etwas) einer Sammlung hinzufügen;(etwas) einer Sammlung einverleiben;(etwas) in eine Sammlung aufnehmen
-beifügen;hinzutun;noch dazutun;noch hineingeben;dazugeben;noch hineintun;zugeben;hinzufügen;hinzugeben;zusetzen
-Wuschelkopf;Strubbelkopf
-Krauskopf (Frisur) (auch figurativ);Krüssel(s)kopp (ugs., norddeutsch)
-(jemanden) wuschig machen (ugs.);(jemanden) verrückt machen (ugs.);(jemanden) nervös machen;(jemanden) konfus machen;(jemanden) kribbelig machen (ugs.);(jemanden) kirre machen (ugs.)
-glattes Haar (haben);glatthaarig (sein)
-Poposcheitel (ugs., scherzhaft);Mittelscheitel
-Stimmlippe;Stimmfalte
-schnurgerader Scheitel;Scheitel wie mit dem Lineal gezogen;Scheitel wie mit dem Messer gezogen;akkurater Scheitel;akkurat gescheitelt
-Übersterblichkeit (fachspr.);Exzessmortalität (fachspr.)
-Fühlhaar;Schnurrhaar;Tasthaar;Vibrisse;Sinushaar
-Tariergewicht;Eichgewicht;Kalibriergewicht
-Notebooktasche;Laptoptasche
-finanziell austrocknen (fig.);nicht die erforderlichen (finanziellen) Mittel bereitstellen;auf Sparflamme setzen (fig.);kaputtsparen (Jargon, Hauptform);(einen) Sparkurs verordnen;verschlanken (fig., verhüllend)
-(wirtschaftlich) strangulieren;(ein Unternehmen) in die Insolvenz führen;in den Ruin treiben;zugrunderichten
-Dooring-Unfall (fachspr., Hauptform);Türöffner-Unfall;Unfall beim Türöffnen
-Rima glottidis (fachspr., anatomisch);Glottis (fachspr., linguistisch);Stimmritze (fachspr., linguistisch)
-Stimmritzenapparat (fachspr., anatomisch);Glottis (fachspr., anatomisch)
-Scheitel (Haar);Scheitellinie
-Zickzackscheitel;unordentlicher Scheitel
-...freudig;...lustig;...lieb;...liebend
-Du machst dir keine Vorstellung! (ugs.);Du machst dir kein Bild davon! (ugs.);Du wirst es nicht glauben! (ugs.);Du ahnst es nicht! (ugs.);Du wirst es nicht für möglich halten! (ugs.)
-(eine schwierige) Situation meistern (variabel);(die) Sache im Griff haben;(der) Situation gewachsen (sein);Herr der Lage (sein / bleiben);(sich) das Heft (des Handelns) nicht aus der Hand nehmen lassen (fig.);(das) Heft nicht aus der Hand geben (fig.)
-(jetzt) aus einer anderen Richtung kommen;(die) Richtung wechseln;(die) Richtung ändern;(sich) drehen;umschlagen (Wind);abdrehen (Wind) (seemännisch)
-(sich) im Uhrzeigersinn drehen;rechtdrehen(d) (Wind) (fachspr., seemännisch)
-(sich) entgegen dem Uhrzeigersinn drehen;rückdrehen (Wind) (fachspr., seemännisch)
-mit der Sonne (Drehrichtung);nach rechts (Drehrichtung);rechtsrum (Drehrichtung) (ugs.);rechtsherum (Drehrichtung);rechts herum (Drehrichtung);im Uhrzeigersinn (Drehrichtung);in Uhrzeigerrichtung (Drehrichtung)
-nach links (Drehrichtung);gegen die Uhrzeigerrichtung (Drehrichtung);linksherum (Drehrichtung);linksrum (Drehrichtung) (ugs.);gegen die Sonne (Drehrichtung);gegen den Uhrzeigersinn (Drehrichtung) (Hauptform);links herum (Drehrichtung);entgegen dem Uhrzeigersinn (Drehrichtung);dem Uhrzeigersinn entgegen (Drehrichtung);der Sonne entgegen (Drehrichtung)
-(der) Wind hat sich gedreht (fig.);(die) Zeichen stehen (jetzt) auf;(es) weht ein anderer Wind (fig.);(es) herrscht ein anderes Klima (fig.)
-das muss nichts heißen;das hat nichts zu sagen;das hat nicht viel zu sagen;das hat keine große Bedeutung;das muss nicht viel heißen
-mit Blaulicht;notfallmäßig (ugs.)
-Vervielfältigungszahlwort;Multiplikativzahl;Multiplikativum (lat.);Vervielfältigungszahl
-Wiederholungszahlwort;Wiederholungszahl;Quotientivum (lat.);Iterativzahl;Iterativum (lat.)
-in Stücke schlagen;in Kleinholz verwandeln (ugs., fig.);kurz und klein schlagen (fig.);zu Kleinholz verarbeiten (ugs., fig., ironisch);Kleinholz machen (aus) (ugs., fig.);in seine Einzelteile zerlegen (ugs., ironisch, verhüllend);in Stücke hauen (ugs.);(etwas) kleinschlagen;entzweischlagen;kaputtschlagen (ugs.);(etwas) zerschlagen;zu Kleinholz machen (ugs., fig.);kaputthauen (ugs.)
-Dreadlocks;Rastalocken
-Rastazöpfe;Rastalocken;Braids
-Service;Kundenbetreuung;Kundendienst;Betreuung
-zum Anfassen (ugs., fig.);wie du und ich (ugs.);einer von uns (ugs.);nahbar (geh.)
-platzsparend;(den) Raum (optimal) ausnutzen(d);raumsparend
-(viel) Raum verschwenden(d);Platz verschenken(d);raumverschwendend
-haushälterisch umgehen (mit);(bei / an etwas) sparen;sparsam sein (mit);haushalten (mit);(etwas) sparen (ugs., Hauptform);(möglichst) wenig verbrauchen
-etliche;viele (Hauptform)
-Postboje;Posttonne
-Schwimmkörper;Auftriebskörper
-(jemandem wird) kodd(e)rig (ugs., norddeutsch);(jemandem wird) schlecht;(jemandem wird) übel;(jemandem wird) kotzübel (ugs.);(jemandem wird) speiübel;(jemandem wird) flau (ugs.);(gleich) kotzen müssen (derb);(sich gleich) übergeben müssen
-mit einer Gabel (schlagend) verrühren;verkleppern
-(Eiweiß zu Eischnee) schlagen;(Eiweiß zu Eischnee) verkleppern
-Auslöser (Kamera) (Hauptform);Aufnahmeknopf
-Trigger;Triggerereignis;Auslöseimpuls;Auslöseereignis
-Drücker;Abzug (Waffe)
-Ein-/Ausknopf;Ein-Aus-Schalter;Startknopf;On-/Off-Schalter;An-/Aus-Schalter
-vortreiben (Gärtnerei);vorziehen (Gärtnerei);vorkultivieren
-diuretisch (fachspr.);harntreibend
-Harndrang auslösen;von etwas zum Klo rennen müssen (ugs.);harntreibend wirken (fachspr.);Harndrang verursachen;von etwas pinkeln müssen (ugs.);treiben (Getränk) (ugs.)
-(schnell) erledigt werden müssen;rausgehen müssen (Post);rausmüssen (Post) (ugs.)
-(schnell) loswerden müssen (ugs.);(schnell) verkauft werden müssen;rausmüssen (Ware) (ugs.);(die Lager) räumen müssen
-(die) Kündigung bekommen haben;rausmüssen (Wohnung) (ugs.);gekündigt worden sein;ausziehen müssen
-ins Freie (gehen) müssen;(das) Gebäude verlassen müssen;auf die Straße (gehen) müssen;rausmüssen (ugs.);nach draußen (gehen / laufen) müssen
-Almabtrieb (bayr.);Alpabzug (schweiz.);(der) Viehscheid (Allgäu);Alpabfahrt (alemannisch)
-Alpauffahrt (alemannisch);Alpaufzug (schweiz.);Alpfahrt (regional);Almauftrieb;Auftrieb
-Topik (fachspr., griechisch, neulateinisch);Körperbereich
-ganz vorne mit dabei sein;(ganz) vorne liegen;(die) Bestenliste anführen;auf den vorderen Plätzen (liegen / rangieren)
-(ein) ganz großes Rad drehen wollen (fig.);groß herauskommen wollen (mit);(das) ganz große Rad drehen wollen (fig.);(sich) sehr viel vorgenommen haben;(sich) nicht mit Kleinigkeiten zufriedengeben
-(jemandem) zu wenig sein;(jemandem) nicht genug sein;mehr wollen;(jemandem) nicht reichen
-kein Stress! (ugs.);lassen Sie sich Zeit;lass dir Zeit;nur die Ruhe;immer mit der Ruhe
-Pyromantie;Pyromantik
-Gammler (historisch);Langhaariger;Protestler
-(sich) messen lassen können (mit);bestehen (gegen);(es herrscht) Waffengleichheit (mediensprachlich);(jemandem / einer Sache) etwas entgegensetzen können;es aufnehmen können (mit);(ein) ernst zu nehmender Gegner (sein);(ein) ernst zu nehmender Konkurrent (sein);(sich) behaupten (gegen/über);(sich) messen können (mit);(jemandem / einer Sache) etwas entgegenzusetzen haben;(jemandem / einer Sache) Paroli bieten können;(jemandem / einer Sache) gewachsen sein
-(die) Hürde (des/der ...) nicht überwinden;(jemandem) zum Verhängnis werden;(ein Ziel) nicht erreichen;(etwas) nicht schaffen;nicht über die ...hürde kommen;versagen (bei);scheitern (an) (Hauptform)
-aus der Deckung kommen (auch figurativ);sich aus der Deckung wagen (auch figurativ);aus dem Busch kommen (ugs., auch figurativ);(sich) vorwagen;(sich) zeigen;(sich) hervorwagen
-die Katze aus dem Sack lassen (fig.);sagen, was Sache ist;aus dem Busch kommen (mit) (fig.);sagen, was man vorhat
-es gibt (auf der ganzen Welt) niemand besseren;weltbester (weltbeste);der (die) Beste der Welt;es gibt (auf der ganzen Welt) keinen besseren (keine bessere)
-Top...;bester (beste / bestes);einer (eine / eines) der besten
-Telekommunikationsvertrag;Mobilfunkvertrag;Handyvertrag (ugs.)
-niederländischer Nougat;Nougat Montelimar (franz.);Turron (spanisch);Nougat Montélimar (franz.);Madolato (griechisch);Türkischer Honig;orientalischer Honig;weißer Nougat;Gaz (persisch);weißer Nugat;Torrone (ital., schweiz.);Turrón (spanisch)
-(jemandem) bekannt vorkommen;(jemanden / etwas) schon einmal gesehen (gehört) zu haben glauben (geh.);(jemanden / etwas) zu kennen glauben
-Mir ist das hier zu (...).;So kann ich nicht arbeiten. (Spruch)
-ich lach später (ugs., ironisch);Witz komm raus, du bist umzingelt! (ugs., veraltet);Ich lach mich neukrank! (ugs., Jargon, ironisch);sehr witzig!
-Dir wird das blöde Grinsen noch vergehen! (derb);Wer zuletzt lacht, lacht am besten. (Sprichwort);Dir wird das Lachen noch (früh genug) vergehen!;Sie finden das wohl komisch!? (ugs.);Freu dich (besser) nicht zu früh! (ugs.);Sie sollten sich nicht zu früh freuen!;Ihnen wird das Lachen (schon) noch vergehen!;Du findest das wohl komisch!? (ugs.)
-verbeult;zerdötscht (ugs., rheinisch, ruhrdt.);verblötscht (ugs., kölsch, rheinisch)
-schräggestellt (Buchstaben) (ugs.);in Kursivschrift;in kursiver Schrift;kursiv gesetzt;kursiv (Hauptform);in Schrägschrift (ugs.)
-recte (fachspr., Hauptform);gerade (ugs.);nicht kursiv;in normaler Schrift (ugs.)
-recte (fachspr., Hauptform);richtig (muss es heißen)
-Fangen wir an!;dann wollen wir mal! (ugs.);Ich würde sagen ... (als Markierung eines Situationswechsels) (ugs.);lass(t) uns anfangen!;worauf warten wir!?;dann lass uns (jetzt auch)! (ugs.)
-vom Markt nehmen (Produkt);nicht weiterproduzieren;nicht mehr vertreiben;nicht mehr produzieren;die Produktion (von etwas) einstellen
-(eine) Sortimentsbereinigung vornehmen;(Ware) aus dem Sortiment nehmen;(Artikel) auslisten (fachspr.)
-Delisting (fachspr.);Sortimentsbereinigung;(das) Auslisten (fachspr.)
-(bei etwas) springt zu wenig heraus (ugs.);nicht seinen Schnitt machen können (mit / bei) (ugs.);bringt (finanziell) nichts (ugs.);(mit etwas) lässt sich kein Geld verdienen (ugs.);nicht genug Ertrag abwerfen;(bei etwas) kommt nichts (he)rum (ugs.);finanziell unattraktiv (sein);(sich) nicht lohnen
-nicht mehr im Sortiment haben;nicht mehr führen
-Lohndrückerei;Lohndumping
-Mietwucherer;Wucherer;Immobilienhai;Miethai
-stark überhöhte Miete;Wuchermiete;Mietwucher
-eigentlich gemeint haben (wollen);etwas als ... verstanden wissen wollen;(jemand) hatte sagen wollen
-(seine) Hoffnung setzen (auf);(seine) Hoffnung knüpfen (an)
-quantitierendes Versprinzip;silbenmessendes Versprinzip
-syllabisches Versprinzip;silbenzählendes Versprinzip
-silbenwägendes Versprinzip;akzentuierendes Versprinzip
-Taktmetrik;taktierendes Versprinzip
-Coronakrise (ugs., Hauptform);Corona-Pandemie;Coronavirus-Krise;COVID-19-Pandemie;Coronavirus-Pandemie
-schwarz-amerikanisch;schwarzamerikanisch;afroamerikanisch
-Manöverpatronengerät;Knallpatronengerät
-Verschwörungstheoretiker;Verschwörungsanhänger;Aluhutleute (ugs., Pluraletantum, abwertend, fig.);Aluhutträger (ugs., abwertend, fig.);Verschwörungsschwurbler (ugs., abwertend);Anhänger von Verschwörungstheorien;Verschwörungs-"Theoretiker"
-Schlaggitarre;Flatpicking (engl.)
-Orlean;Ruku;Achote;Urucum;Roucou;Achiote;Bixin;Anatto;Annatto;Achote
-ohne Konsequenzen fürchten zu müssen;ohne (weitere) Konsequenzen;ungestraft
-Arzt mit eigener Praxis;niedergelassener Arzt
-(sich) klein machen;(sich) ducken;den Kopf einziehen
-Du musst jetzt die Zähne zusammenbeißen!;Du musst jetzt ganz stark sein! (Spruch);Beiß die Zähne zusammen!
-Tatzlagerfahrmotor;Tatzlagermotor;Tatzlagerantrieb
-Tandemantrieb;Längsmotorantrieb
-Finanzdienstleister;Finanzdienstleistungsunternehmen
-Taskforce (auch figurativ);Katastrophenschutzstab;Krisenstab (Hauptform);Task-Force (fig.)
-Fußballfan;Zwölfter Mann (ugs.)
-drunter und drüber gehen;(irgendwo) herrscht Chaos;durcheinandergehen;es herrscht (ein großes) Durcheinander (bei)
-bloße Vermutung(en);unbewiesene Behauptung(en);These;(reine) Theorie
-Trabant P70 Coupé (ugs., fälschlich);P 70 Coupé (ugs., Hauptform);AWZ P 70 Coupé;Zonenporsche (ugs., scherzhaft-ironisch)
-mal sehen (nach) (ugs.);mal gucken (nach) (ugs.);einen Blick werfen (auf);mal schauen (nach) (ugs.);(sich etwas) kurz ansehen
-ermöglichen;möglich machen;Nahrung geben;ermuntern (zu);Raum geben (für);Raum lassen (für);Gelegenheit bieten (für / zu);erlauben;nähren;begünstigen
-(jemandem) behagen;(sich) wohlfühlen (mit / bei)
-Schikane;Niederträchtigkeit;(eine) Biestigkeit;Gehässigkeit;Teufelei;(eine) Gemeinheit;(eine) Bosheit;Schweinerei (ugs.);(eine) Boshaftigkeit (Hauptform)
-die Kontrolle verlieren (über);(jemandem) aus der Hand gleiten;(etwas) nicht mehr unter Kontrolle haben
-es gibt kein Halten mehr;nicht mehr beherrschbar sein;einen chaotischen Verlauf nehmen;nicht mehr zu beherrschen sein;es kommt zu Übergriffen;aus dem Ruder laufen;außer Kontrolle geraten;chaotisch werden
-es gibt kein Halten mehr;(etwas / jemand) ist nicht mehr aufzuhalten;(etwas) kann nicht mehr gestoppt werden;(jemand) ist nicht mehr zu bremsen
-(sich) ungehindert ausbreiten;unaufhaltsam voranschreiten
-Königsfrieden;Königsbann
-Gamswild (Hauptform);Gämsen;Gams (Jägersprache);Gämse;Gamsen
-digitaler Nomade;Internet-Nomade;Büronomade
-es gibt nichts, was dagegen (wirklich) hilft;damit leben müssen (ugs.);da hilft nur noch beten (ugs., Redensart);(da ist) nichts zu machen;(es) ist kein Kraut gewachsen (gegen);da(gegen) hilft auch kein (...) (ugs.);(dagegen) kann man nichts tun (Hauptform);nichts hilft (gegen);(dagegen) ist kein Kraut gewachsen (fig.)
-Mit der Dummheit kämpfen selbst (die) Götter vergebens. (geh.);Mit der Dummheit kämpfen Götter selbst vergebens. (geh., Zitat);Gegen Dummheit kämpfen selbst (die) Götter vergebens. (geh.);Doof bleibt doof, da helfen keine Pillen. (ugs., salopp);Gegen (die) Dummheit ist kein Kraut gewachsen. (ugs., fig., variabel)
-(sich) verkehren (in);umschlagen (in);(sich) plötzlich ändern (zu)
-(ungewollt) einschlafen;wegpennen
-nichts dagegen tun können;nicht anders können;übermächtig (sein)
-irrational;nicht nachvollziehbar;unvernünftig;vernunftwidrig;unlogisch;gegen die Vernunft
-Bundesstaatsprinzip;Föderalismus
-Chorbischof;Chorepiskopos
-Partyhengst (ugs.);Partyluder (ugs., abwertend, weibl.);Partygänger;Partymaus (ugs., weibl.);Partymensch;Partygirl (ugs., engl.);Partyhase (ugs.)
-nicht investieren (Kapital);(sein) Geld parken (fig.)
-belächelt werden;(ein) mitleidiges Lächeln ernten
-verspottet werden;(viel) Spott ernten
-(sich) stürzen (in);(sich) stürzen (auf)
-(etwas tun) mit dem Hintergedanken, dass;(sich) Chancen ausrechnen (auf);setzen (auf);spekulieren (auf);(sich) erhoffen
-Da müsste ich (ja) ganz schön dämlich sein. (ugs., variabel);Seh' ich (etwa) so aus? (ugs.);Für wie dumm halten Sie mich!? (variabel);Für wie bescheuert hältst du mich!? (ugs., salopp, variabel)
-Selbstdiffusion;Intradiffusion
-Gerade, dass jemand nicht noch (...) (ugs.);Das Einzige, was fehlte, (wäre);(es) fehlte nur noch, dass (...)
-Bildungssystem;Bildungswesen
-Rundungseinheit;Maschinenepsilon;Maschinengenauigkeit
-Rundungsfehler;Rundungsdifferenz
-Es ist an der Zeit, zu gehen. (geh.);Ich glaube, wir sind hier (jetzt) überflüssig. (ugs., Spruch);(es ist) Zeit zu gehen;(ich denke) ich sollte jetzt besser gehen (ugs.)
-Band;Fassreifen (Hauptform)
-(das ist ja wohl) nicht zu viel verlangt!;das kann man (ja wohl) erwarten!;so gehört sich das (auch)!
-Lernerfolgskontrolle;Lernkontrolle
-Thriller (Hauptform);Film, der von der Spannung lebt;spannender Film
-Kurzfilm;Vorfilm
-Hauptfilm;(Film im) Hauptprogramm
-Film in Schwarzweiß;Schwarzweißfilm;Schwarz-Weiß-Film
-Filmstil;Filmsprache;Filmepoche
-Komödie;Filmkomödie;lustiger Film (ugs.);Filmlustspiel
-Filmdrama;Drama
-(Ich habe heute) nicht umsonst gelebt.;(Mein) Tag ist gerettet!;Da hat sich das Aufstehen heute (ja wieder) gelohnt! (ugs., Spruch, variabel)
-(jemanden) unfair behandeln;(jemandem) bitter Unrecht tun;(jemanden) ungerecht behandeln
-falsch einschätzen;(fälschlicherweise) halten (für);eine falsche Meinung haben (von);(sich) täuschen (in);seine Meinung korrigieren müssen (über)
-Szenario;angenommene Situation;Ausgangsvoraussetzung(en)
-Modellrechnung;Projektion in die Zukunft
-(etwas) nachvollziehen;(etwas) zurückverfolgen;(etwas) nachverfolgen;(etwas) nachträglich ermitteln
-Autobumser (ugs.);Schussfahrer (österr.);Autocrasher (Jargon);Unfallbetrüger (Hauptform)
-eierlegende Wollmilchsau;eierlegendes Wollmilchschwein
-Regenfront;(heranziehendes) Regengebiet
-nicht noch gutes Geld schlechtem hinterherwerfen (fig.);(seinen) Verlust akzeptieren;es nicht auf eine gerichtliche Auseinandersetzung ankommen lassen (variabel)
-(ein) geschultes Auge haben;(einen) geübten Blick haben (für)
-mit einem Blick erfassen;sofort sehen;(etwas) auf einen Blick sehen;auf den ersten Blick sehen;nicht lange überlegen (müssen);sofort erkennen
-Festgeld;Termineinlage;Termingeld
-arrangieren;inszenieren;(etwas) stellen (Szene, Unfall ...);(etwas) in Szene setzen;(etwas) so aussehen lassen, als ob (...);fingieren
-(sich etwas) bildlich vorstellen;(sich) etwas ausmalen;(mit jemandem) geht die Phantasie durch;das Kopfkino geht los (bei jemandem) (variabel)
-Phantasien;Kopfkino (fig.);Tagträume
-Wunschtraum;Wunschvorstellung;(sehnlicher) Wunsch
-Vertragsdokument;Vertrag (ugs., Hauptform);(schriftliche) Vereinbarung;schriftlicher Vertrag
-Vertragsexemplar;Ausfertigung (eines Vertrages);Vertrag (ugs.)
-Geld verdienen (mit);(etwas) verdienen (an);(einen) finanziellen Vorteil haben (durch)
-Semifreddo (ital.);Eisparfait (franz.);Halbgefrorenes;Parfait (franz.)
-Läuterzucker;Zuckersirup
-Jigger (engl.);Barmaß
-Messzylinder;Litermaß;Messbecher
-Opportunitätsprinzip;Entschließungsprinzip
-Dateimanager;Dateiverwaltung;Dateiverwaltungs-Tool;Dateiverwaltungs-Programm;Dateiverwaltungs-App
-Gamswild (Hauptform);Gamsen;Gämsen
-Ewigkeitsentscheidung;Ewigkeitsklausel;Ewigkeitsgarantie
-Dichlormethan;DCM;Methylenchlorid;Methylendichlorid;R-30
-PU (ugs.);Polyurethan;PUR (Abkürzung)
-Schwefelkohlenstoff;Kohlenstoffdisulfid
-nicht loslassen können;(sich) verbissen haben (in);(sich) festgebissen haben;nicht (mehr) loskommen (von)
-(eine) Anmaßung;unberechtigte Inanspruchnahme
-(sich selbst) ernennen zu;(sich selbst) den Titel eines (...) geben;(sich selbst) den Titel eines (...) zuerkennen;(sich selbst) machen (zu)
-(sich selbst etwas) attestieren;(sich selbst etwas) zusprechen;(sich selbst etwas) zuerkennen;(sich selbst etwas) zuschreiben
-Geologenhammer;Schürfhammer
-Klopfholz;Schreinerklüpfel
-Gefahrenraum;Gefahrenbereich;Gefährdungszone;gefährliches Terrain (auch figurativ);Risikobereich;Gefahrenzone
-Klauenhammer (fachspr.);Zimmermannshammer
-die Fremde;(die) große weite Welt;ferne Länder;(die) weite Welt;(die) Ferne
-Marschkapelle;Musikzug;Fanfarenzug;Spielmannszug;Tambourkorps
-Bläser-Formation;Blaskapelle;Brass Band (engl.);Blasorchester;Bläserensemble
-Schusterhammer;Schuhmacherhammer
-Finne (fachspr.);Schmalbahn (fachspr.);Pinne (fachspr.);spitzes Ende (eines Hammers)
-flaches Ende (eines Hammerkopfes);Bahn
-Alte Synagoge (Dresden);Semper-Synagoge;Dresdner Synagoge
-die Nase hochziehen;schniefen
-(eine) Braue hochziehen;(eine) Braue heben
-Expansionsdüse;Lavaldüse
-Kältekopfschmerz;Gehirnfrost
-verhindern wollen;zu verhindern suchen;zu verhindern versuchen
-(sich) dem Diktat der Mode unterwerfen;der Mode folgen;mit der Mode gehen;(eine) Mode mitmachen (ugs.)
-Modepüppchen;Modepuppe
-abseits befestigter Wege (und Straßen);offroad (ugs., Jargon, engl.);im (freien) Gelände;abseits der Straßen
-schellen (regional);klingeln;läuten;bimmeln;gehen (Klingel, Telefon) (ugs.)
-Lenkungsabgabe;Lenkungssteuer
-schwer zu tragen haben (an);(etwas) mühsam schleppen;(sich) abquälen (mit);schwer tragen (an) (auch figurativ);kämpfen (mit) (fig.);(sich) abschleppen (mit) (ugs., Hauptform);(sich) abmühen (mit)
-Schlaglicht (fachspr.);Lichter (fachspr.);Spitzlicht (fachspr.);(Darstellung von) Glänzen
-Geteiltzeichen (fachspr.);Zeichen für "geteilt (durch)";Geteilt-Zeichen (fachspr.);Bruchzeichen (fachspr.);Slash (Jargon, engl.);Schrägstrich
-Minuszeichen;minus;negatives Vorzeichen;Subtraktionszeichen;Kurzstrich (fachspr.);Minusstrich (fachspr.)
-nicht-trennbarer Bindestrich;geschützter Bindestrich;nicht umbrechender Bindestrich (fachspr.)
-Preisaufschlag;Aufzahlung (schweiz., süddt., österr.);Erhöhung;Mehrbetrag;Preiserhöhung;Zuschlag;Aufschlag;Aufgeld
-zusätzliche Kosten;Aufpreis;Mehrkosten
-hinzukommen(d) (zu);zuzüglich (kaufmännisch);dazukommen (ugs.);plus;zzgl. (Abkürzung)
-ohne;nicht enthalten(d) (in);(noch) nicht inbegriffen;(noch) nicht mitgerechnet;(noch) nicht (mit) drin (ugs.);exklusive (geh.)
-Gleisträger;Eisenbahnschwelle;Schwelle
-Hatschek;Häkchen (über / auf)
-Komma (unter);Cédille
-ist mit (einem / einer ...) (ugs.);mit (einem / einer ...) geschrieben werden;hinzugefügt (sein);haben (auf / über / unter / quer durch ...) (ugs.);kommt mit (ugs.);hinzugefügt werden
-Eckkneipe;Quartierbeiz (schweiz.);Kneipe um die Ecke
-Leutgebschank (österr.);Besenbeiz (schweiz.);Häckenwirtschaft (fränk.);Buschenschank (österr.);Kranzwirtschaft (badisch);Buschenschenke (schweiz.);Besenwirtschaft (pfälzisch, rheinhessisch, rheinisch);Häcke (fränk.);Maienwirtschaft (fränk.);Rädle;Häckerwirtschaft (fränk.);Heuriger (ugs., österr.);Straußwirtschaft (rheinhessisch, rheinisch);Kränzle (badisch);Heckenwirtschaft (fränk.);saisonal geöffnete Wirtschaft;Rädlewirtschaft;Besen (schweiz., württembergisch)
-genüsslich trinken (Hauptform);(langsam) die Kehle hinunterlaufen lassen;schlotzen (schwäbisch);genießen (Getränke)
-achselzuckend dastehen;nicht wissen, wie es weitergehen soll (ugs.);(sich) keinen Rat wissen;ratlos;hilflos (sein);keine Idee haben, wie es weitergehen soll (ugs.);mit den Achseln zucken
-hochgehen (auf ... Fuß);steigen (mit ... auf);(auf)steigen lassen;hochziehen (Flugzeug) (ugs.);in den Steigflug (über)gehen;zum Steigflug ansetzen
-auf einem der vorderen (/ hinteren ...) Plätzen gelandet sein;auf den vorderen (/ hinteren ...) Plätzen liegen;(vorne / hinten ... ) liegen;(gut / schlecht ...) abschneiden;(gut / schlecht ...) bewertet werden (Hauptform);auf den vorderen (/ hinteren ...) Plätzen rangieren;(gut / schlecht ...) dastehen
-(sich) entschuldigen;(sich) entschuldigen lassen;absagen;Bescheid sagen, dass man nicht kommt (ugs.)
-Verborgenheit;Verstecktheit;Unauffindbarkeit;Verdecktheit
-(ich bin) nicht zum Spaß hier! (ugs.);(ich bin) gekommen, um zu arbeiten! (und nicht, um Kaffee zu trinken);(hier) einen Job zu erledigen haben (ugs.);(ich bin) hier, um zu arbeiten.
-(etwas) nicht (allzu) ernst nehmen;(einer Sache) keine (allzu) große Bedeutung beimessen;(etwas) nicht (allzu) wichtig nehmen;für nicht so wichtig halten (ugs.)
-Mehrforderung;Zusatzforderung;Nachforderung
-gut in der Hand liegen;vom Handling her okay (sein) (ugs.)
-Parallelanschlag (fachspr.);Führungsleiste (fachspr.);Seitenanschlag (fachspr.);Führung (ugs.);Führungsschiene (fachspr.)
-Plateaus (ugs.);Plateauschuhe
-(sich) um seine eigenen Angelegenheiten kümmern;(sich) nicht in anderer Leute Angelegenheiten mischen;(sich) mit sich selbst beschäftigen;genug mit sich selbst zu tun haben;*sein* Ding machen (ugs.);guten Tag und guten Weg sagen (ugs., Redensart)
-So möchte ich nicht leben! (ugs., kommentierend);dahinvegetieren;unter schrecklichen Bedingungen leben (müssen);Das ist (doch) kein Leben! (ugs., kommentierend);(ein) Hundeleben führen;(ein) Hundeleben haben;vegetieren
-elendes Leben;Scheißleben (derb);Leben in (Not und) Elend;Hundeleben
-(sich) vorwerfen, dass;(sich selbst) die Schuld geben;(sich) schuldig fühlen;(ein) schlechtes Gewissen haben;(sich) Vorwürfe machen;Schuldgefühle haben
-mit sich selbst im Hader sein;keine innere Ruhe finden;mit sich selbst nicht im Reinen sein;mit sich selbst hadern
-reflektiertes Licht;Spiegelung;Reflexion
-Gefährdungssituation;riskante Situation;gefährliche Situation
-in all den letzten Jahren;in den ganzen letzten Jahren (ugs.);die ganzen letzten Jahre (ugs.);in den letzten Jahren;die letzten Jahre (ugs.);in den zurückliegenden Jahren;in den vergangenen Jahren;all die letzten Jahre (ugs.)
-näherrücken(d);dringend zu erledigen(d);(dringend / vorrangig / umgehend) anzugehen(d) (variabel);nicht länger warten können;drängend (Hauptform)
-Heidenspaß (Hauptform);Wahnsinnsspaß;diebischer Spaß;Riesenspaß;Mordsgaudi;diebisches Vergnügen;Mordsspaß
-gar nicht merken, wie die Zeit vergeht;Die Zeit vergeht (jemandem) wie im Fluge.
-zu jemandes Rechtfertigung;zu jemandes Ehrenrettung;zu jemandes Verteidigung
-(sich) in edlem Look präsentieren;aufwendig gestaltet;Hochglanz...
-Halt dir mal kurz die Ohren zu! (ugs.);Spoileralarm! (ugs.);Achtung, Spoiler! (ugs.);Hör mal kurz weg! (ugs.);(Für die, die das Ende jetzt nicht wissen wollen:) Mal kurz weghören! (ugs.)
-(das) entscheide ich!;(das) ist meine Angelegenheit!;lass das mal meine Sorge sein! (ugs.);(das) ist meine Sache;(das) ist mein Bier! (ugs.);(das) musst du (schon) mir überlassen! (ugs.);(das) hast nicht du zu entscheiden
-spoilern (ugs.);verraten, wie etwas ausgeht (variabel);das Ende verraten
-(sich etwas) genehmigen lassen;(sich jemandes) Einwilligung geben lassen (zu);(die) Zustimmung einholen (zu)
-(jemanden) um Erlaubnis fragen;(jemanden) um die Erlaubnis bitten (dass / zu + Infinitiv);fragen, ob man (etwas) kann (ugs.);fragen, ob man (etwas) darf
-Einverständniserklärung (Amtsdeutsch);Bewilligung (Amtsdeutsch);Zulassungsverfahren;Einwilligung;Erlaubniserteilung (Amtsdeutsch, Hauptform);Zulassung;Erlaubnis;Zustimmung;Genehmigung (Amtsdeutsch);Genehmigungsverfahren;(das) Erlauben;Gestattung (Amtsdeutsch, juristisch)
-...gestattung (Amtsdeutsch, juristisch);...genehmigung;(schriftliche) Genehmigung (zu)
-Bitten Sie den Besuch(er) herein. (formell);Bringen Sie den Besuch(er) herein.;Führen Sie den Besuch herein.;Ich lasse bitten. (formell);(Sagen Sie ihm,) er kann reinkommen. (ugs.)
-un...lich sein;nicht zu (tun) sein (variabel);un...bar sein;sich nicht (tun) lassen (variabel);man kann (etwas) nicht (tun) (variabel)
-leuchtend rot;rot (Hauptform);kräftig rot;(in der) Farbe der Liebe (ugs.);sattrot;mohnrot
-dunkelrot;blutrot;tiefrot
-tiefrot;blutrot;dunkelrot;rubinrot
-Ziereis;Eisskulptur
-Nennwertaktie;Nennbetragsaktie
-Elektrowerkzeug;Heimwerkergerät;Heimwerker-Gerät
-(eine) Hilti (Markenname);Bohrhammer
-Brustleier;Bohrkurbel;Handbohrer;Bohrwinde;Handbohrmaschine;Handbohrgerät (Hauptform)
-Akku-Bohrmaschine;Akkubohrer
-Akkuschrauber;Akku-Schlagschrauber
-Dreimaster;Dreimastschiff
-Bohrer (Hauptform);Bohreinsatz;Bohrwerkzeug (fachspr.)
-Bohrfutter;Spannfutter
-Immunantwort;Abwehrreaktion des Immunsystems;Immunreaktion
-Immunisation;Immunisierung
-Marterinstrument;Folterwerkzeug
-Wieder was gelernt! (ugs.);Man lernt nie aus. (Gemeinplatz)
-extra kommen (ugs.);nicht im Preis mit drin (sein) (ugs.);separat bezahlt werden müssen;nicht im Preis inbegriffen (sein);(nur) gegen Aufpreis zu haben (ugs.);extra kosten (ugs.);hinzukommen;zusätzlich bezahlt werden müssen;separat berechnet werden (kaufmännisch)
-Standard sein (ugs.);zur Grundausstattung gehören(d);zur Serienausstattung gehören(d);serienmäßig (eingebaut) (Auto);zur Standardausstattung gehören(d)
-gegen gesonderte Berechnung;gegen Aufpreis;gegen Zuschlag
-(sich) missbrauchen lassen (für) (negativ);(sich) einspannen lassen (für);(sich) instrumentalisieren lassen
-(Zeitausdruck in adverbialem Akkusativ) (ugs.);... über (Zeitdauer);... hindurch (Zeitdauer);für (Zeitdauer);... lang (zeitlich)
-Pfarrverband;Pfarreiengemeinschaft;Pastoralverbund;Kooperationseinheit;Seelsorgeeinheit;Seelsorgebereich;Seelsorgebezirk
-Anschlussverwendung (fachspr., auch figurativ);neue Arbeit;neue Stelle (Hauptform);neue Position;neue Aufgabe;neuer Job (ugs.)
-anfunkeln;mit funkelnden Augen ansehen;mit funkelnden Blicken ansehen
-was fällt dem ein!? (ugs.);wie kommt der dazu!? (ugs.);was denkt der sich (überhaupt)!? (ugs.)
-du bist ein Held!;(das hast du) gut gemacht!;ich bin begeistert!
-Celebessee;Sulawesisee
-Französisch-Siamesischer Krieg;Siamkrise;französisch-siamesischer Konflikt
-für mich wär' das nichts (ugs.);wer's mag ... (ugs.);manchen soll das ja gefallen;manchen soll sowas ja reichen (ugs.)
-(das) wollte ich nur mal gesagt haben (ugs.);von wegen ... (ugs.);so viel zum Thema ... (ugs.)
-an den Falschen geraten (männl.);(bei jemandem) an der falschen Adresse (warnend);(sich) die Falsche aussuchen (weibl.);(sich) den Falschen aussuchen (männl.);an die Falsche geraten (weibl.)
-(sich) gesetzt haben;sitzen (Hauptform)
-hocken;kauern;in der Hocke sitzen
-unbequem sitzen;hocken
-(sich) zusammenkauern;(sich) irgendwohin drücken;(sich) irgendwohin kauern;(sich) irgendwohin hocken
-Schängelche (Koblenz);Wehrmachtskind;Besatzungskind (Hauptform);Brown Baby (abwertend)
-aussehen wie Buttermilch und Spucke (ugs., veraltend);keine Farbe haben;(ganz) blass aussehen (ugs.);kränklich wirken
-kommend;bevorstehend;anstehend;nächster (nächste, nächstes);demnächst stattfindend
-(es) besteht Anlass (zu);(sich) verlasst sehen (zu);aus gegebenem Anlass;aus aktuellem Anlass;(jemanden) veranlassen (zu);aufgrund entsprechender Vorfälle
-Pangolin;Tannenzapfentier;Schuppentier
-Käfigläufer;Kurzschlussläufer
-(durch unsachgemäßen Umgang) zum Stehen bringen (Motor);abfrecken (ugs., regional);abwürgen (Motor) (ugs., Hauptform);brutal stoppen
-Solidaritätsadresse;Solidaritätserklärung;Solidaritätsbekundung
-(jemanden) bei sich hereinlassen (ugs.);Besuch empfangen;empfangen (geh.)
-Influencer(in);Social-Media-Werbetreibende(r)
-(ein bisschen) Geld;(ein bisschen) Klimpergeld (ugs.);kleiner Betrag;Kleckerbetrag (ugs.);(nur) Kleingeld (ugs., auch figurativ);(nur) Centbeträge (ugs., auch figurativ);Peanuts (ugs., engl., fig.)
-keinen Pfifferling wert sein (ugs.);keinen Wert haben;wertlos (sein);nur Schrottwert (haben) (derb);keinen Schuss Pulver wert sein (ugs.);nichts wert sein (Hauptform);keinen roten Heller wert sein (veraltend)
-nächster Versuch!;(jetzt) das Ganze noch einmal!;auf ein Neues! (ugs.);(Und jetzt) das Ganze nochmal (von vorn)! (ugs.)
-Entschuldigung;Pardon;Verzeihung;Vergebung
-Ich möchte mich (für ...) entschuldigen.;Ich bitte vielmals um Entschuldigung! (geh.);Bitte entschuldigen Sie (das).;Tschuldigung! (ugs.);Bitte entschuldigen Sie.;Entschuldigung! (Hauptform);Entschuldigen Sie bitte!;Ich möchte mich in aller Form (für ...) entschuldigen.;Können Sie mir noch einmal verzeihen? (geh.);Tut mir leid.;(Es) tut mir ehrlich leid.;Kannst du mir nochmal verzeihen? (auch ironisch)
-Goldgrube;Goldader;Goldbergwerk;Goldmine
-fettverschmiert;fettig;schmierig
-Atlasbindung;Satinbindung
-Köperbindung;Köper;Twill
-Eintrag;Einschlag;Schussfaden;Schuss
-Kette;Zettel;Kettfaden;Werft (altertümlich);Aufzug
-Rapport (fachspr.);Dessin;Muster
-Spelunke;Winkelschenke (veraltet);Heckenwirtschaft;Hinterhofkneipe;Kaschemme;Winkelschänke
-Spelunkier (ugs., selten);Heckenwirt
-Gaststättenerlaubnis;Gastgewerbeberechtigung (fachspr., Amtsdeutsch, österr.);Wirtepatent (schweiz.);Konzession (ugs.);Schankerlaubnis;Gaststättenkonzession
-wie bestellt;aufs Stichwort (fig.);besser geht's (zeitlich) nicht;der Zeitpunkt hätte nicht besser (gewählt) sein können;genau im richtigen Moment (Hauptform)
-(das) große Ganze;(der) Gesamtzusammenhang;(das) Gesamtbild;(die) übergeordneten Zusammenhänge;(der) Überblick;(der) Gesamtüberblick;(die) großen Zusammenhänge
-Schlüsselzange;Chromzange;Zangenschlüssel (Hauptform);Armaturenzange
-Wasserpumpenzange (Hauptform);verstellbare Zange
-Bezugsschein (für Lebensmittel);Lebensmittelkarte;Bezugskarte
-(das) große Ganze;übergeordnete Interesse(n)
-(nur) im engsten Kreis;unter vier Augen;ohne Zeugen
-grob umrissen;grob skizziert;ins Unreine gesprochen (fig.);vorläufig
-letzte Warnung;noch so ein(e) ... und ... (ugs.);ich sag' es dir (jetzt) zum letzten Mal (ugs.);wenn du nicht sofort (mit ...) aufhörst, dann ... (ugs.)
-(es war) das (/ der / die) eine zu viel;(das eine ....), auf das jemand hätte besser verzichten sollen
-dafür sorgen, dass etwas nicht den Bach runtergeht (ugs., fig.);in Gang halten;am Laufen halten (fig.);dafür sorgen, dass etwas weiterläuft
-nicht ausgehen lassen (Maschine, Feuer/Heizung);am Laufen halten (Motor / Betrieb) (auch figurativ);nicht versiegen lassen (Unterhaltung);unterhalten (Feuer);wachhalten (Gedenken);aufrechterhalten (den Betrieb einer Anlage z.B.);dafür sorgen, dass etwas nicht ins Stocken gerät;in Gang halten (Gespräch)
-(...) kann sich nicht beklagen (ugs.);gut über die Runden kommen (ugs., salopp);(...) kann sich nicht beschweren (ugs.);(es) läuft nicht schlecht (für) (ugs., salopp)
-Filmkunsttheater;Arthouse-Kino;Programmkino (Hauptform);Filmkunst-Kino
-Multiplex (ugs.);Multiplex-Kino (Hauptform);Megaplex-Kino;Großkino (mit vielen Sälen);Kinocenter
-Volle Deckung!;Geh(t) in Deckung!
-Stimmnerv;rückläufiger Kehlkopfnerv
-(sich) beraten lassen;(jemanden) um Rat bitten;(jemanden) um Rat fragen;(sich) Rat holen (bei);(jemandes) Rat einholen;konsultieren;Rat suchen (bei);um (jemandes) Rat bitten
-(das Ziel) verfehlen;danebengehen (Schuss);nicht treffen;danebenzielen;den Falschen treffen (die / das Falsche treffen);Knapp daneben ist auch vorbei. (scherzhaft-ironisch, sprichwörtlich);danebenschießen (auch figurativ)
-ins Schwarze treffen;ins Schwarze gehen (Schuss);optimal treffen
-(mit dem Hammer) nicht treffen;danebengehen (Schlag);danebenhauen (auch figurativ);danebenschlagen
-vorgetäuschtes Foul;Schwalbe (Fußball) (fig.)
-Elfmeterschinder;Freistoßschinder;Schwalbenkönig (Hauptform)
-(sich) absichtlich fallen lassen;(den) sterbenden Schwan spielen (Fußball) (fig., variabel)
-(etwas) nicht ernst meinen;soll(te) ein Scherz sein;(etwas) lustig meinen;soll(te) ein Spaß sein
-Sonnenanbeter (fig.);Hautkrebswilliger (derb);Sonnenfreund;Sonnenfetischist (ugs., salopp)
-leicht entzündlich (sein);brennen wie Gift;brennen wie Zunder;schnell entflammbar (sein)
-rasch um sich greifen;(sich) (rasend) schnell ausbreiten (Feuer, Infektion)
-es übertreiben (mit...) (ugs.);Man kann alles übertreiben, (Gemeinplatz);Was zu viel ist, ist zu viel. (Spruch);Man kann's auch übertreiben. (ugs., kommentierend);Allzu viel ist ungesund. (Sprichwort);Zu viel ist (einfach) zu viel. (Spruch)
-im Einsatz (sein);eingesetzt werden;zum Einsatz kommen
-drei Punkte;Ellipse (Satztechnik / Typographie) (fachspr.);Auslassungspunkte;Dreipunkt (fachspr.);horizontal ellipsis (Unicode) (fachspr., engl.)
-als wenn das nicht gereicht hätte!;wie soll das nur weitergehen (mit ...)!? (ugs.);das wird ja immer schöner! (ugs., Spruch, ironisch);als wenn das nicht (schon) reichen würde!;das wird ja immer besser! (Spruch, ironisch);(und) was kommt als nächstes? (ugs., Spruch);als wenn das nicht genug (gewesen) wäre!
-aufgetakelt (negativ);aufgebrezelt;wie ein Zirkuspferd;(herausgeputzt / aufgemacht ...) wie ein Pfingstochse;aufgedonnert;aufgebitched (ugs., salopp)
-(das) Grau in Grau (von);Trostlosigkeit;Freudlosigkeit;Tristesse;Tristheit
-Grundübel (Hauptform);Quelle allen Übels;Wurzel allen Übels;Grundproblem;Ausgangsproblem;Erzübel;der allem zugrunde liegende Fehler;Ausgangspunkt aller Schwierigkeiten
-auftupfen;auftrocknen;aufsaugen
-es nicht mit Worten bewenden lassen (wollen) (fig., variabel);schwere Geschütze auffahren;gerichtliche Schritte androhen
-Nachrichtensperre;Pressesperre;Redeverbot;Maulkorberlass
-draufzahlen;drauflegen (müssen);zuzahlen (müssen);mehr zahlen (müssen);zusätzlich bezahlen (müssen)
-nachzahlen;nachträglich (be)zahlen;(Geld) nachlegen
-(einen) Verlust machen;Verluste machen;draufzahlen (bei);minus machen;Geld verlieren
-Individualreise;selbst organisierte Reise
-Individualtourist;Individualreisender
-Nett haben Sie's hier! (floskelhaft);Hier kann man's aushalten. (floskelhaft)
-Erste Fußball-Bundesliga;Fußball-Oberhaus (ugs.);1. Fußball-Bundesliga
-Vervielfältigungslehre;Konturlehre
-Parkuhr;Parkometer (selten)
-bevorzugte Option;Favorit;erste Wahl;Präferenz;bevorzugte Alternative
-Strategie;Lösungsweg
-Doktorfisch;Rötliche Saugbarbe;Knabberfisch;Garra rufa;Kangalfisch;Discognathus rufus (fachspr.)
-Marksteinzeuge;Grenzsteinzeuge;Grenzzeuge
-Phase;Aggregatzustand
-Verdünnungslüftung;Mischlüftung
-Parteiantrag;Subsidiarantrag
-mesenchymales Bindegewebe;Mesenchym
-Gewebe;Zellverband;Zellgewebe
-Endgegner;Endboss
-(hervorschießender) Wasserstrahl;Fontäne
-Pumpenanlage;Hebewerk (fachspr.);Pumpwerk;Schöpfwerk (fachspr.)
-Wo soll das (alles) enden!? (Spruch);wenn das so weitergeht ...;Wo soll das noch enden!? (Spruch)
-sagen, was jemand denkt;dieselbe Sprache sprechen (wie);(jemandes) Sprache sprechen;denken wie;die Welt mit den Augen der (... / eines/einer ...) sehen (variabel)
-(etwas) laut sagen;(etwas) aussprechen;(etwas) offen aussprechen
-(sich) (mit jemandem) verstehen (in einem Punkt / was ... angeht);die gleiche Einstellung haben (zu)
-in rascher Folge;eng getaktet (fachspr.);in schneller Folge;in dichter Folge;kurz hintereinander (ugs.);dichtauf
-Hellespont;Dardanellen
-Marmara-Insel;Prokonnesos (altertümlich, griechisch)
-Straße von Konstantinopel (historisch);Bosporus
-Pontus Euxinus (historisch, lat.);Schwarzes Meer (Hauptform);Pontos Euxeinos (geh., bildungssprachlich, griechisch)
-Goldenes Horn;Chrysokeras (griechisch)
-blockieren;besetzt halten
-(ein) Karussell im Kopf (ugs., fig., variabel);Drehwurm (ugs.);Drehschwindel (fachspr.);(jemandem) dreht sich der Kopf;(jemandem) dreht sich alles;(jemandem) dreht sich alles im Kopf
-Gangunsicherheit;Gleichgewichtsstörung(en)
-Schwindelattacke;Schwindelanfall
-Balkonkasten;Pflanzkasten;Blumenkasten
-Gast (Beherbergung, Gastronomie, Veranstaltung) (Hauptform);...besucher;...gast (Beherbergung);Besucher
-Tagesgast;Ausflügler
-keinen längeren Aufenthalt geplant haben;(sich) nicht (länger) aufhalten;(irgendwo) Zwischenstation machen;auf der Durchreise (sein)
-Durchgangsgast;Kurzurlauber (Hauptform)
-Hochsitz (Jägersprache);Ansitz (Jägersprache);Hochstand (Jägersprache)
-Luderplatz (Fleisch) (fachspr., Jägersprache);Futterplatz;Kirrung (Getreide) (fachspr., Jägersprache);Futterstelle
-Schlag auf den Hinterkopf;Kopfnuss
-Denksportaufgabe;Kopfnuss (fig.);Rätsel
-Kopfstoß;Kopfstoßen
-Unternehmenskonstrukt;Unternehmensgeflecht;Firmengeflecht
-gegenseitige Beteiligung(en);gegenseitige Kapitaleinlage(n);gegenseitige Eigentumsanteile;gegenseitige Kapitalanteile
-(irgendwohin) langen (ugs., regional);(irgendwohin) fassen;(irgendwohin) greifen
-Kollegenschwein (ugs.);Verräter;Kameradenschwein (ugs.)
-niemandem allein die Schuld geben;niemandem die Hauptschuld geben wollen;ich will jetzt keinen angucken (ugs., floskelhaft, variabel);ich will hier niemanden angucken (ugs., floskelhaft, variabel);niemanden allein verantwortlich machen
-Willst du etwas sagen ,dass ich ...?;Was guckst du mich jetzt so an? (ugs.)
-der Weisheit letzter Schluss (ugs., fig.);Dauerlösung;Definitivum;ultimative Antwort (fig.);Endlösung (derb, NS-Jargon, Tabuwort, euphemistisch)
-(den anderen) den Akkord kaputtmachen (ugs.);(den Kollegen) das Gedinge kaputtmachen (ugs., Bergbau, Jargon, fig., veraltend)
-(sich) illoyal verhalten;(die) gemeinsame Linie verlassen (fig.);(jemandem) in den Rücken fallen (fig.);(jemandem) die (weitere) Unterstützung versagen
-(jemand) weiß noch nichts von seinem Glück (ugs., Spruch, ironisch);(jemandem etwas Unliebsames) noch sagen müssen (ugs.);(etwas Ärgerliches) noch gesagt bekommen müssen;(jemand) weiß noch nicht, was los ist (ugs.);(etwas Unerwünschtes) noch erfahren müssen;noch nicht informiert sein (über etwas Unerfreuliches)
-Zeit der Untätigkeit;Ruhezeit;Pause;Zeit der inneren Einkehr;Zeit des süßen Nichtstuns;Mußestunde (geh., auch ironisch)
-Donnergueg;Feuerschröter;Hirschkäfer (Hauptform);Hornschröter;Schröter;Donnergugi
-Superior (fachspr.);Ordensoberer
-Leibchen (historisch);Mieder (Oberteil)
-Top (engl.);(ärmelloses) Oberteil
-Trainingsleibchen;Leibchen (Sport);Markierungshemd (fachspr., Handelsname, Jargon)
-Invagination (fachspr., lat.);Einstülpung
-Intussuszeption (fachspr., lat.);Darmeinstülpung
-Saturationsarithmetik;Sättigungsarithmetik
-guten Flug!;angenehmen Flug!
-Inhaber des (Großen) Latinums;alter Lateiner (ugs., scherzhaft);altsprachlich Gebildeter
-Lateinschüler;Lateiner
-Altsprachliches Gymnasium;Humanistisches Gymnasium
-seinem Wesen nach;seinem Ursprung nach;seiner Natur nach;von Natur aus;ursprünglich
-kraft Geburt;von Geburt an;von Geburt;durch Geburt
-gebürtige(r);(dort) geboren;(dorther) gebürtig
-in den Beichtstuhl müssen (fig.);zu Einzelgesprächen gebeten werden (geh., Hauptform, variabel);einzeln antreten müssen (ugs.);(sich mehrere) einzeln vorknöpfen (ugs.);in die Mangel genommen werden
-seine positive Seite entdecken (variabel);Kreide gefressen haben (fig.);(plötzlich) den Sanftmütigen geben (variabel);(sich) plötzlich von seiner sanften Seite zeigen (variabel)
-(ein) Wolf im Schafspelz (sein) (fig.);(jemandem) ist nicht zu trauen
-(die) eigene Scholle (fig.);Grundeigentum;eigener Grund und Boden;Grundstückseigentum;(ein) eigenes Stück Land
-(jemandes) heimische Scholle (auch ironisch);(jemandes) Heimat;(jemandes) Zuhause
-Liebe zur Heimat;Heimatverbundenheit
-(auf jemanden / etwas) kann man sich verlassen;(auf jemanden / etwas) kann man bauen (fig.);(auf jemanden / etwas) ist Verlass
-(sich) entfalten (Blüte, Fallschirm) (Hauptform);(sich) öffnen;aufklappen;entfalten (Blüte);aufgehen
-Lautenspieler (Hauptform);Lautenmusikant;Lautenist
-Pus (fachspr., lat.);Pyon (fachspr., griechisch);Eiter
-entzündlich bedingte Absonderung;Exsudat;Wundsekret
-Cavitas pleuralis (fachspr., lat.);Brusthöhle
-Bauchfellhöhle;Cavitas peritonealis (fachspr., lat.)
-Frustjob (ugs.);mieser kleiner Job (derb);Hungerleiderjob (ugs., fig.)
-vorübergehende Beschäftigung (Amtsdeutsch);Gelegenheitsjob
-Wie war's? (ugs.);Wie ist es abgelaufen?;Und? (auffordernd) (ugs.);Wie ist es verlaufen?;Wie ist es gelaufen? (ugs.)
-Japanstrom;Kuroshio (japanisch)
-Antifaltencreme;Schönheitscreme;Anti-aging-creme
-So langsam reicht's. (ugs.);Irgendwann ist auch mal gut! (ugs.);Einmal muss (ja) Schluss sein. (ugs., variabel)
-Mooskugel;Algenball;Marimo (japanisch)
-kein Ende abzusehen;Dauerproblem;Dauerbaustelle (ugs., fig.);never ending story (ugs., Jargon, engl., fig.);kein Land in Sicht (ugs., fig.);kein Ende in Sicht;(eine) unendliche Geschichte (ugs., fig.)
-Freizeitaktivitäten;Freizeitgestaltung
-Freizeitgestaltung;Verplanung der Freizeit;Freizeitverwendung;Freizeitnutzung;Planung seiner Freizeit;Freizeitorganisation
-Freizeitangebot;Freizeitmöglichkeit
-Freizeiteinrichtung;Freizeitangebot
-(wieder) in sein Recht treten (geh.);das tun, was etwas (/jemand) immer getan hat (ugs.);es gelten wieder die alten Regeln (ugs., variabel);(wieder) seinen angestammten Platz einnehmen;(wieder) zur Geltung kommen;(wieder) in seine Rechte treten (geh., veraltend)
-Parteindifferenzthese;Parteiendifferenzhypothese;Parteiendifferenztheorie
-Schönen Dank auch! (ugs., ironisch);(na) da hab' ich ja richtig Glück! (ugs., ironisch);(na) da bin ich aber froh! (ugs., ironisch);Na besten Dank! (ironisch);Danke für die Blumen! (ironisch)
-Wir danken für Ihr Verständnis. (floskelhaft);Vielen Dank für Ihr Verständnis. (floskelhaft);Danke für Ihr Verständnis. (floskelhaft)
-er oder ich;Es kann nur einen geben. (Spruch)
-(machen) jetzt;dazu übergegangen sein (zu) (floskelhaft);(sich) angewöhnt haben (zu)
-Kehrwoche haben (schwäbisch);dran sein mit Treppe-Putzen (ugs., ruhrdt.)
-Reinigungsdienst;Reinigungspflicht
-Putzfirma (ugs.);Reinigungsunternehmen;Putzdienst;Reinigungsdienst;Reinigungsservice
-nach oben gehen;hinaufgehen (Schriftsprache);raufgehen (ugs., norddeutsch, westdeutsch);(sich) nach oben begeben (geh.);(hoch) in die ...te Etage gehen;(sich) hinaufbegeben (geh.);hochlaufen (ugs., bundesdeutsch);hochgehen;(die) Treppe hochgehen;(sich) in die ...te Etage begeben (geh.)
-genau befolgen;buchstabengetreu befolgen;genau nach Vorschrift handeln;(sich) genau an die Vorschrift(en) halten
-Schlussfolgerungsmaschine (selten);Regelinterpreter;Inferenzmaschine
-weiterhin (zukunftsbezogen) (Hauptform);weiter (weiter...);noch;noch weiter (noch weiter...);noch länger
-träumerisch;idealisierend;blauäugig;romantisierend;verklärend
-Wetterkerze;Wollblume;Kunkel;Verbascum (fachspr., botanisch, lat.);Winterblom;Himmelsbrand;Unholdskerze;Königskerze (Hauptform);Wollkraut
-Schachtelbeteiligung;Schachtel (Kurzform)
-Kapitalbeteiligung;Beteiligung (Kurzform);Unternehmensbeteiligung
-Bankansturm;Schaltersturm
-Tulpenmanie;Tulpenfieber;Tulpenblase;Tulpenwahn;Tulipomanie (fachspr.);Tulpenhysterie
-(einen) hohen Aufmerksamkeitswert genießen;niemandem verborgen bleiben (fig.)
-(auch) das Positive sehen;(etwas) gut finden (an);(einer Sache) etwas Positives abgewinnen (können) (variabel);nicht nur (die) Nachteile sehen;(auch) die Vorteile sehen (in)
-Präsenzpflicht;Anwesenheitspflicht
-(sich) schlecht machen (ugs.);(ein) Imageproblem darstellen;(an jemandes) Image kratzen (ugs., fig.);schlecht dastehen lassen;(ein) schlechtes Bild abgeben
-Spritzloch;Spiraculum (fachspr., lat.);Saugloch
-Great White (engl.);Weißer Hai (Hauptform);Carcharodon carcharias (fachspr., griechisch, lat.);Weißhai;Menschenhai
-Undulation (fachspr., lat.);Wellenbewegung
-voll;ganz;vollständig;komplett;gesamt
-spätabends;in den späten Abendstunden
-in Stücken;stückweise;vereinzelt;Stück für Stück;fragmentiert;scherbenweise;brockenweise
-Hagelkorn;Chalazion (fachspr., griechisch)
-Furunkel (fachspr., lat.);Blutschwär (ugs.)
-Haarfollikel;Haarbalg
-Napierscher Logarithmus;Natürlicher Logarithmus;Neperscher Logarithmus
-Clustermunition;Streumunition
-gottgleich;gottähnlich
-wegkommen (ugs.);auf den Müll wandern (ugs., variabel);entsorgt werden;ausgemustert werden
-(sich) ranschmeißen (an) (ugs.);(sich jemandem) an den Hals werfen;(sich jemandem) aufdrängen
-auftragen;auflegen;draufhauen (ugs., salopp);drauftun (ugs.);nehmen (ugs.)
-wissen, was sich gehört;Anstand (haben);Anstandsgefühl (haben);wissen, was sich schickt;wissen, was man sich schuldig ist
-übermüdet aussehen;Ringe unter den Augen haben (fig.);verpennt aussehen (ugs., salopp);verschlafen aussehen
-Ich lasse euch jetzt (wohl) besser allein.;Ich geh' dann mal. (ugs.)
-(sich) nicht ausschlafen können;nicht genug Schlaf bekommen
-Dörfchen;Marktflecken;Örtchen;(kleines) Dorf;Weiler;Nest
-nicht einsehbarer Bereich;toter Winkel
-Ort;Örtlichkeit;Location (fachspr., Jargon);Winkel
-Steatopygie;Fettsteiß
-totgeglaubt;für tot gehalten;mutmaßlich tot
-Schlupfschuh;Slipper (engl.)
-totgesagt;für tot erklärt
-Kampfhähne (fig.);(zwei) Streitende;Streithähne (fig.)
-fatale Konsequenzen haben;(jemandem) zum Verhängnis werden;zum Tode führen
-Läuft doch! (ugs., Neologismus);Ich weiß gar nicht, was du willst! (ugs.);Ich weiß nicht, was du (immer) hast! (ugs.)
-nicht mehr lustig (sein) (ugs.);(da) vergeht einem das Lachen (ugs.);(etwas) nicht zum Lachen finden (ugs.);(jemandem) ist der Humor vergangen (ugs.);(etwas) gar nicht lustig finden (ugs.)
-mit Humor nehmen;von der lustigen Seite sehen
-Barbel;Barbe;Pigge;Flussbarbe
-Üblichkeit;Umgangsregel
-von untergeordneter Bedeutung;akzessorisch (fachspr.);nebensächlich;zweitrangig;sekundär
-darauf stehen (5 Jahre Gefängnis) (ugs.);darauf steht (eine Geldstrafe) (ugs., variabel);geahndet werden (mit);bestraft werden (mit)
-(jemanden) faszinieren;(sich) angezogen fühlen (von);fasziniert sein (von)
-mir fehlen die Worte!;wow!;ich bin sprachlos!;Wahnsinn!
-Corona-Maßnahmen-Gegner;Covidiot (derb);von einer (großen) Corona-Verschwörung Überzeugte;Corona-Leugner
-Impfgegner;Impf-Verweigerer
-Chemmie (ugs., Jargon);Anhänger der Chemtrails-Theorie(n);Chemtrail-Gläubige;von der Chemtrails-Verschwörung Überzeugte
-Reptiloidgläubiger;Anhänger der Reptiloidentheorie
-Flacherde-Anhänger;Anhänger der Überzeugung, dass die Erde eine Scheibe ist;Flacherdler (ugs.);Flacherde-Gläubiger
-Paranoiker;in einer Wahnwelt Lebender
-(sich) bedroht fühlen;(sich) verfolgt fühlen
-eruptives Hämangiom (fachspr., griechisch);lobuläres kapilläres Hämangiom (fachspr.);Granuloma pediculatum (fachspr., lat.);Teleangiectaticum (fachspr., lat.);Stielknollen;eruptives Angiom (fachspr., griechisch);Granuloma pyogenicum (fachspr., Hauptform, lat.);Granuloma teleangiectaticum (fachspr., griechisch);proliferierendes Angiom (fachspr.);teleangiektatisches Wundgranulom (fachspr., griechisch);Epulis granulomatosa (fachspr., lat.);Wundgranulom;Epulis angiomatosa (fachspr., lat.);Pseudobotryomykom (fachspr., griechisch);pyogenes Granulom (fachspr., Hauptform);Pediculatum (fachspr., lat.)
-Funktionsgewebe;Parenchym
-(kühl kalkulierender) Rationalist;(kalter) Verstandesmensch
-Gefühlsdusel (ugs.);Schwärmer;Gefühlsmensch;sentimentaler Knochen (ugs.);(jemand, der noch) ein fühlend Herz in seiner Brust hat (geh., altertümelnd, scherzhaft-ironisch);Weichei (ugs.);Weichheini (ugs.)
-Gratulationscour (Hauptform);Reigen der Gratulierenden;Chor der Gratulanten
-am längsten im Amt;schon ewig dabei (ugs.);dienstältest
-(nach) Klicks fischen;Clickbaits einsetzen;Clickbaiting betreiben;Klicks ködern
-Gläserspiel;Glasharfe
-Eignungskriterium;Einstellungsvoraussetzung;Einstellungskriterium
-mutieren (zu);(sich) verändern (zu / in);(sich) verwandeln (in);(sich) wandeln (zu)
-es nicht (so) haben mit (ugs.);nicht jemandes Ding (sein) (ugs.);nicht (gerade) bekannt sein für;nicht jemandes Sache (sein) (ugs.);nicht zu jemandes Stärken gehören
-Lizenzjagdsystem;Patentjagdsystem
-eins steht fest: ...;soviel ist sicher (ugs.);davon kann man (mit Sicherheit) ausgehen;eins ist sicher: ...
-nur noch das Ziel im Blick haben;aufs Ergebnis fixiert;sich voll auf eine Sache konzentrieren;aufs Ziel fixiert;nur noch eine Sache im Blick haben;(einen / den) Tunnelblick haben (fig.)
-Schornsteinbrand;Kaminbrand
-was denn? (ugs.);was! (aggressiv) (ugs.);ja? (ugs.);ja was!? (ugs.);ja bitte? (ugs.);was ist denn?
-ein Auge drauf werfen (ugs., fig.);(sich etwas) flüchtig ansehen
-kontrollieren;(sich etwas) ansehen (ugs.);(sich etwas) anschauen (ugs.);revidieren (fachspr.);abchecken;überprüfen;(etwas) checken;prüfen
-Rudelkucken (ugs.);Rudelgucken (ugs.);Public Viewing
-es ist still geworden (um);nicht mehr im Rampenlicht der Öffentlichkeit stehen;(jetzt) unbemerkt von der Öffentlichkeit leben
-Basislinie;Grundlinie
-Einstimmung (auf);(mentale) Vorbereitung (auf);Hinführung (zu)
-(sich) verselbst(st)ändigt haben;(ein) Eigenleben führen;(sich) der Kontrolle entziehen
-Elbmark;Sächsische Ostmark;Sorbenmark;Geromark
-altersschwach (Fahrzeug);klapprig;reif für den Schrottplatz (derb);(eine) Klapperkiste von (einem Fahrzeug) (ugs.);gammlig (derb);reif für die Schrottpresse (derb);fällt bald auseinander (ugs.);schrottig (ugs.);abgewrackt (derb)
-Reisschüssel (abwertend);japanisches Auto
-Wohltätigkeitsclub;Gesellschaftsclub
-Interdependenzgeflecht;Figuration
-direkt (Adjektiv);augenblicklich (Adjektiv);sofortig;alsbaldig (Papierdeutsch);prompt (Adjektiv);unverzüglich (Adjektiv);umgehend (Adjektiv);unmittelbar (Adjektiv)
-Vertrauenskrise;Vertrauensschwund;Vertrauensverlust
-Kaputt ist kaputt. (ugs.);Futsch ist futsch. (ugs., regional);Da ist nichts (mehr) zu machen.;Hin ist hin. (ugs.)
-vor die Aufgabe gestellt sein;(es ist jemandes) Aufgabe (zu);(sich) mit der Aufgabe konfrontiert sehen;(jemandem) aufgegeben sein (zu) (geh.);(die) Aufgabe bekommen haben (zu);vor der Aufgabe stehen (zu);sollen;mit der Aufgabe konfrontiert sein;(jemandes) Job ist es, dass (/zu);(die) Aufgabe haben (zu)
-Aufgabe;Auftrag;Betrauung (mit);(zu erledigende) Sache;(zu erledigende) Arbeit;Mission
-Glaubenskrieg (fig.);erbitterter Meinungsstreit;ideologisch geführte Debatte;ideologisch überlagerte Diskussion
-Erklärfilm;Lehrvideo (Hauptform);visuelles Lehrmaterial;Schulungsfilm;Instruktionsfilm;Unterrichtsfilm;Schulfilm;Unterrichtsvideo;Lehrfilm (Hauptform)
-Höckerlinie;Hitlerzähne;Drachenzähne
-Siegfried Line (engl.);Siegfried-Linie;Ligne Siegfried (franz.);Westwall (Hauptform)
-Königsklasse (ugs.);Champions League
-nicht abkönnen;nicht darüber hinwegkommen (dass);nicht verknusen können;nicht ertragen (können)
-Allometrie;dysproportionales Gliedmaßenwachstum
-nachsteuern;nachträglich präzisieren;weitere Maßnahmen ergreifen;nachjustieren;zusätzliche Maßnahmen ergreifen;nachbessern;korrigierend eingreifen
-mehr tun;(noch) weiter gehen;nicht stehenbleiben (bei)
-Begünstigter;Bevorrechtigter;Privilegienreiter;Bevorzugter;Privilegierter
-umsteuern (fig.);(einen) Kurswechsel vornehmen (auch figurativ);(einen) anderen Kurs einschlagen (auch figurativ)
-Entscheidung über die grundsätzliche Ausrichtung;Richtungsentscheidung (fig.)
-Bezirk;Landkreis;Grafschaft;Kreis (regional);County
-Vorschlaghammer;Abbruchhammer;Mottek (ugs., Bergbau, Jargon, polnisch)
-Schwungbalken;Schaukelbrett;Schwenkbalken;Wippe;Wippschaukel
-(jemandem) die Reverenz erweisen (veraltend);(jemandem) seine Aufwartung machen (geh.);(jemanden) (mit seinem Besuch) beehren (geh., ironisierend);(sich) sehen lassen (bei) (ugs., salopp);(jemandem einen) Höflichkeitsbesuch abstatten
-(Loch / Grube / Graben) machen (ugs.);(Loch / Grube / Graben) schaufeln;(Loch / Grube / Graben) graben;(Loch / Grube / Graben) ausheben;(Loch / Grube / Graben) ausschachten
-Polarität;Polung
-Luftpumpentaler;Trennungstaler;Zwietrachttaler
-Intermediat;Zwischenprodukt
-(jemanden) besiegen;(jemanden) schlagen (Wettkampf)
-Achtungserfolg (variabel);(sich) gut behaupten;(eine) respektable Leistung ...;(sich) wacker schlagen (auch figurativ, variabel)
-haushoch gewinnen;(den Gegner) vom Platz fegen (Sportsprache, fig.);(den Gegner) zerlegen (ugs., Sportsprache, fig.);an die Wand spielen (ugs., fig.);(jemanden) vernichtend schlagen;(jemandem) eine vernichtende Niederlage bereiten (geh.)
-(Boden) abtragen;(eine Fläche) auskoffern (fachspr.);(Boden / Erde) ausheben
-Teildisziplin;Wissenzweig;Teilgebiet;Spezialdisziplin;Fachrichtung;Spezialgebiet (Hauptform);Wissenschaftszweig;Forschungszweig
-Topf (ugs.);Pflanztopf;Blumentopf
-BAG (Abkürzung);Bundesarbeitsgericht
-lose (ugs.);unverpackt;nicht abgepackt
-(sich) politisch inkorrekt (äußern);lose Reden (führen)
-Neubesetzung (einer Funktion);Umbesetzung (einer Position, Rolle ...)
-(eine Stelle / Funktion) umbesetzen (Hauptform);eine Umbesetzung / Umbesetzungen vornehmen;neu besetzen (mit);eine Neubesetzung / Neubesetzungen vornehmen;(die) Karten neu mischen (ugs., fig.);(neu) vergeben (an)
-wie bei einem Wolf;wolfsartig;wölfisch;wie ein Wolf
-wölfisches Lächeln;maliziös lächeln;wölfisch lächeln;scheinfreundlich lächeln;maliziöses Lächeln;Haifischlächeln
-(sich) diebisch freuen;seine Belustigung kaum verbergen können;seine diebische Freude haben (an);(ein) Grinsen mühsam unterdrücken (müssen);innerlich lachen müssen;hinter seinen Stockzähnen lächeln (/lachen / grinsen)
-angepeilt (ugs.);angestrebt;anvisiert;geplant;beabsichtigt
-Massensport;Volkssport
-Bezahlung mit Cash (ugs.);Bezahlung bar auf die Hand (ugs.);Bezahlung mit Münzen und Scheinen;Bezahlung mit Bargeld (selten);Barzahlung;Bezahlung in Cash (ugs.);Bezahlung in bar;Zahlung in bar
-Zahlungsart;Bezahlmöglichkeit;Zahlungsabwicklung;Zahlungsweise (Hauptform);Abwicklung des Bezahlvorgangs
-auf Rechnung;gegen Rechnung
-mit Plastikgeld (be)zahlen;mit Karte bezahlen;mit Karte zahlen
-mit EC-Karte (ugs., fälschlich);mit Bankkarte;mit Debitkarte;mit Girocard
-mit E-Banking (be)zahlen;per Internet bezahlen;(einen) Online-Bezahldienst nutzen;mit einem Online-Bezahldienst (be)zahlen;mit einem Internet-Bezahldienst bezahlen;über einen Internet-Bezahldienst zahlen;online bezahlen
-(jemandes) Barschaft (geh.);(das) Geld in jemandes Portmonee;(das) Geld in jemandes Tasche;Geld, das jemand dabei hat
-mit sich rumschleppen (ugs.);mit sich herumtragen;mithaben (ugs.);(mit) beihaben (ugs., ruhrdt.);mit sich führen;dabeihaben (Hauptform);bei sich tragen;mitführen (Amtsdeutsch)
-(jemandes) Barschaft (geh.);alles Bargeld in jemandes Besitz;alles Bargeld, das jemand hat;alles Bargeld, das jemandem gehört;(jemandes) Barvermögen (Hauptform);(jemandes gesamtes) Bargeld
-Zielkauf (fachspr., kaufmännisch);Kauf auf Ziel (fachspr., kaufmännisch)
-danebenhauen;danebentippen;sich vertippen;(beim Tippen) die falsche Taste erwischen
-dissoziale Persönlichkeit (fachspr.);Psycho (ugs., abwertend);kranker Typ (ugs.);Person mit antisozialer Persönlichkeitsstörung (fachspr.);Person mit dissozialer Persönlichkeitsstörung (fachspr.);antisoziale Persönlichkeit (fachspr.);Soziopath;Psychopath;krankes Schwein (derb)
-falsch spielen;beim (Karten-) Spiel betrügen;mit gezinkten Karten spielen
-(ein) Doppelspiel (be)treiben;nicht sein wahres Gesicht zeigen;(jemanden) hintergehen;(ein) doppeltes Spiel spielen;(ein) falsches Spiel spielen
-falsche Fährten legen (fig.);Nebelkerzen werfen (fig.);(eine) falsche Fährte legen (fig.)
-Maskenverweigerer;Maskenmuffel
-Lockerungsübung(en) (fig.);Entspannungsbemühung(en) (fig.)
-Bilderstürmer;Ikonoklast
-unangepasst (sein);in keine Schublade passen (fig.);(sich) nicht vereinnahmen lassen;nonkonformistisch;sein eigenes Ding durchziehen (ugs.)
-Krawallbiene (ugs.);Krawallschachtel (ugs.);Krawalltante (ugs.);Krawallnudel (ugs.);Krawallschwester (ugs.);Krawallbürste (ugs.)
-rattern (fahren);unruhig fahren (Hauptform);holpern;rumpeln;ruckeln (fahren)
-Schuhlöffel;Schuhanzieher
-Spannleisten;Schuhstrecker;Schuhspanner
-Blümchenkaffee (ugs., scherzhaft-ironisch);dünner Kaffee;Bodenseekaffee (ugs., scherzhaft-ironisch)
-Nordpersischer Leopard;Kaukasusleopard;Panthera pardus saxicolor;Persischer Leopard
-Nordwald (historisch);Böhmerwald;Sumava (tschechisch)
-triefend vor Selbstmitleid;selbstmitleidig;von Selbstmitleid geprägt;voller Selbstmitleid;von Selbstmitleid erfüllt;von Selbstmitleid durchtränkt;tut sich selbst leid
-versuchen, wieder auf die Beine zu kommen;(sich) von einem Misserfolg wieder zu erholen versuchen;(sich) die Wunden lecken (fig.);eine Niederlage (erst) verarbeiten (müssen);seine Wunden lecken (fig.);versuchen, sich wieder zu berappeln
-flaumig;luftig;flockig;schaumig;locker
-braunfleckig (Papier);stockfleckig (Hauptform);mit Stockflecken
-gelten können (als);durchgehen können (als);anzusehen sein (als);gesehen werden können (als)
-Kultiviertheit;Raffinesse;Eleganz;Klasse
-Meinungsführer;Werbebotschafter;Markenbotschafter;Meinungsmacher;Meinungsbildner;Influencer (engl.);Meinungselite
-auf gut Deutsch;auf eine einfache Formel gebracht;einfach gesagt;allgemeinverständlich ausgedrückt;im Klartext
-Produktivitätsschub;Betätigungsdrang;Anfall von Arbeitswut
-offen gesagt;um es deutlich auszusprechen;ich sage (das), wie es ist (Einschub);um es klar zu sagen;auf gut Deutsch (gesagt) (ugs., fig.)
-auf einen einfachen Nenner bringen;vereinfacht darstellen;vereinfachen
-verabsolutieren;stilisieren (zu)
-schnell fertig werden (mit);(jemanden) hinauskomplimentieren (geh.);(jemanden) abwimmeln;schnell fertig sein (mit) (ugs.);(jemanden) noch an der Tür abfertigen;(jemanden) kurz auf der Treppe abfertigen
-Personenregister;Personenindex;Namensregister
-Sachverzeichnis;Sachregister
-Schriftgutverzeichnis;Schriftgutkatalog
-Tonträgerverzeichnis;Tonträgerkatalog
-vollkommene Information;vollständige Information
-Luftröhrenkrebs;Trachealkarzinom (fachspr., selten);Tracheakarzinom (fachspr.)
-Operateur;Chirurg
-mit jemandem nach Belieben verfahren;(jemanden) herumschubsen (ugs., fig., Hauptform);(mit jemandem) Ping-Pong spielen (ugs., fig.);(über jemanden) nach Bedarf verfügen;(jemanden) als Notstopfen benutzen (ugs.)
-(beim / am) Eingang (ugs.);(im / am) Eingangsbereich;an der Pforte
-Kampfkandidatur;Sprengkandidatur (schweiz.)
-Kampfabstimmung;Alternativabstimmung
-Wartezone;Wartebereich;Wartefläche
-verunsichern;aus der Ruhe bringen;aus der Fassung bringen;nervös machen;in Unruhe versetzen (geh.);unruhig machen
-lange Wege;Gelatsche (ugs.);Rennerei;Lauferei
-(jemandem etwas) verabreichen (Papierdeutsch);(jemandem etwas) geben (ugs.);(jemandem etwas) zum Einnehmen geben
-gegeben sein (z.B. Voraussetzung/en);erfüllt sein;vorliegen;bestehen
-revertieren (fachspr.);rückgängig machen (in einem Wiki);zurückändern (ugs.)
-(etwas) gründlich trainieren (mit);(etwas) einüben;(etwas) intensiv üben (mit);(etwas) einexerzieren (auch figurativ, militärisch);(etwas mit jemandem) einstudieren
-Verstrickung(en);Verwicklung(en);Komplikationen
-in der Situation (ugs.);da (ugs.);in diesem Augenblick;in dem Moment (ugs.);in dieser Situation;in dem Augenblick (ugs.);in diesem Moment
-modern;im Stil der Zeit;... von heute;aktuell (Adjektiv);... der Gegenwart;... der Zeit;... unserer Zeit;heutig (Adjektiv);zeitgenössisch (geh.);kontemporär (geh., bildungssprachlich)
-(damals / heute ...) angebracht;in die (jeweilige) Zeit passend;zeitgemäß (Hauptform)
-Sozial-kognitive Lerntheorie;Sozialkognitive Lerntheorie;Modelllernen;Lernen am Modell
-just in diesem Moment;in genau diesem Moment;ausgerechnet in diesem Moment (ugs., emotional);gerade (in dem Moment) als ...;ausgerechnet da (ugs., emotional);genau in diesem Augenblick;genau da (ugs.);ausgerechnet (in dem Augenblick) als ... (ugs., emotional)
-Heizpilz;Bürgersteigheizung (ugs.)
-Hat (hier) noch jemand einen Wunsch?;Wer will noch mal, wer hat noch nicht? (ugs., Spruch);Sind alle versorgt?;Noch jemand ohne Fahrschein? (ugs., Spruch, scherzhaft, veraltet)
-mit dem Kopf (gegen etwas) knallen (ugs.);mit dem Kopf stoßen (gegen);(sich) den Kopf stoßen
-(jemanden) abknutschen (ugs.);(jemanden) mit Küssen bedecken;(jemanden) abküssen
-Kuss-Forschung;Philematologie (fachspr.)
-Wangenküsschen (verteilen);(jemanden / sich) mit Bussi links, Bussi rechts (begrüßen);Küsschen rechts, Küsschen links;Bussi-Bussi (machen) (Kindersprache);Begrüßungsküsschen;Bussis (verteilen)
-Angst vor Erdnussbutter;Arachibutyrophobie (fachspr.)
-Koumpounophobie (fachspr.);Angst vor Knöpfen
-Nomophobie (fachspr.);Angst, ohne Handy zu sein
-Angst vor Clowns;Coulrophobie (fachspr.)
-Bambakomallophobie (fachspr.);Angst vor Watte;(starker) Ekel beim Anfassen vor Watte
-herumknutschen (ugs.);knutschen (ugs.);(sich) die Zeit mit Knutschereien vertreiben (ugs.);rumknutschen (ugs., norddeutsch)
-(sich) fortsetzen;fortschreiten (geh.);(sich) weiterentwickeln;voranschreiten (geh.);weitergehen
-mit Kratzern;verkratzt (Hauptform);verschrammt;zerkratzt
-krankmachende Wirkung;Virulenz
-überzogene Leistungserwartung(en) (fachspr., pädagogisch);zu hohe Erwartung(en) (variabel);Überforderung;Zumutung (geh., fig., ironisierend);zu hoch gestecktes Ziel (zu hoch gesteckte Ziele) (variabel)
-Work-Life-Balance (engl.);Vereinbarkeit von Familie, Privatleben und Beruf
-Lokalheld;lokale Berühmtheit;Lokalmatador
-Beutepreußen;Musspreußen
-Zweitmeinung;Zweitdiagnose;zweite Meinung;Gegengutachten
-Geh einfach weg. (ugs.);Quatsch mich nicht von der Seite an! (ugs., Hauptform);Willst du mir ein Gespräch aufzwingen? (ugs.);Lass mich in Ruhe! (ugs.)
-was hast du jetzt schon wieder? (ugs.);was hast du jetzt schon wieder angestellt?;was ist jetzt schon wieder? (ugs.)
-war's das nicht (mal) langsam? (ugs.);was denn noch? (ungeduldig) (ugs.)
-für ein Quartier sorgen;für eine Übernachtungsmöglichkeit sorgen;(jemanden irgendwo) einquartieren;für eine Unterbringung sorgen;dafür sorgen, dass jemand (irgendwo) unterkommt (ugs.);(jemanden irgendwo) unterbringen;(jemandem) eine Übernachtungsmöglichkeit besorgen
-(die) Maschen anschlagen (fachspr., Hauptform);(die) Maschen aufnehmen
-Maschen (neu) aufnehmen;(die) Maschen aufheben
-(jemanden) zu Gast haben;(jemanden) bei sich einquartiert haben;(jemandem) Unterkunft geboten haben (geh.);(jemanden) bei sich wohnen haben (ugs.);(jemanden) bei sich untergebracht haben
-(jemanden) zur stationären Behandlung aufnehmen;(jemanden) ins Krankenhaus aufnehmen
-(sich) (ins Krankenhaus) einweisen lassen;ins Krankenhaus gehen;(sich) zur stationären Behandlung einweisen lassen
-stationär behandelt werden müssen;ins Krankenhaus kommen (ugs.);ins Krankenhaus müssen (ugs.);im Krankenhaus behandelt werden müssen;(sich) stationär behandeln lassen müssen
-ins Krankenhaus kommen;ins Krankenhaus gebracht werden
-demonstrieren;darbieten
-Terminvergabe (Hauptform);Terminmanagement
-Terminvereinbarung;Terminabsprache
-(einen) Termin machen (mit);(sich) einen Termin holen;(einen) Termin vereinbaren;(einen) Termin ausmachen (mit);(einen) Termin absprechen;(sich) einen Termin geben lassen;(einen) Termin verabreden
-(das ist) Ihre Entscheidung (Hauptform);Das entscheidest du.;Das müssen Sie wissen. (ugs.);Das entscheiden Sie. (ugs.);Das liegt in Ihrem Ermessen. (geh.);Da halte ich mich (he)raus. (ugs.);Das musst du selbst wissen. (ugs.);Das liegt ganz bei Ihnen.;(das ist) deine Entscheidung (Hauptform);Das musst du wissen. (ugs.);Das liegt ganz bei Dir.
-Pektolith;Pecktolit;Alaska Jade;Gonsogolit;Stellite
-Erzgauner;Erzhalunke;Erzschurke;Oberbösewicht
-Flur (Durchgang im Gebäudeinneren);Korridor (im Gebäudeinneren);Gang (im Gebäudeinneren)
-Sünder (Hauptform);lasterhafter Mensch;Frevler;lasterhaftes Subjekt
-etwas, das gegen ... hilft;etwas, das bei ... hilft;ein Mittel gegen;etwas gegen;etwas für (ugs., fälschlich)
-zweifelnd;kleingläubig (religiös);von Zweifeln geplagt
-Aufruhr;Unruhen;Spannungen
-Mittel und Wege zur Lösung;Lösungsmöglichkeit
-(einen) Weg finden (um zu);(es) hinbekommen (zu) (ugs.);Wege finden (um zu);(es) fertigbringen (zu) (ugs.);(eine) Möglichkeit finden (um zu);Mittel und Wege finden (um zu)
-(so seine) Möglichkeiten haben (um zu) (ugs.);Mittel und Wege haben (um zu)
-ich würde (doch) niemals ... (ugs.);niemand weniger als ich (würde / wäre ...) (geh.);Ich bin der Letzte, der ... (ugs.);Ich wäre der Letze, der ...
-schmucklos;ohne Schnickschnack (ugs., positiv);anregungsarm (fachspr., psychologisch);karg;nüchtern;schlicht
-gleichmütig hinnehmen;gutmütig mit sich machen lassen;widerstandslos geschehen lassen;klaglos über sich ergehen lassen;(sich) widerspruchslos fügen (in);geduldig ertragen
-Brioche (franz.);Apostelkuchen
-Ofennudel;Stössla (fränk.);Stösser (fränk.);Rohrnudel (bayr.);Wuchtel;Buchtel (österr.)
-Germknödel (süddt.);süßer Kloß
-erste Phase;Eröffnung (Schach);Anfangsphase
-(es geht um) alles oder nichts;(es) geht ums Ganze;(es geht um) die heiligsten Güter (geh., auch ironisch, variabel);(eine) Frage von Sein oder Nicht-Sein
-Otto;Otto der Große;Sachsenkönig;Ottonenherrscher;Sachsenkaiser;Otto I.
-Trypophobie;Angst vor (unregelmäßig angeordneten) kleinen Löchern
-Gut gemeint ist (noch lange nicht) gut gemacht. (ugs., Spruch);Das Bessere ist der Feind des Guten. (Zitat, sprichwörtlich)
-ins Leere laufen (fig.);(den) Empfänger nicht erreichen;(ihren) Adressaten nicht erreichen
-wachsen oder weichen;Fressen oder gefressen werden. (fig., sprichwörtlich)
-freudlos;unfroh;ohne (rechte) Lebensfreude;ohne Freude (an)
-(sich) nicht für Politik interessieren;unpolitsch (sein);apolitisch (sein) (geh.)
-das Tief überwunden haben;wieder mitreden können;wieder mit am Tisch sitzen (dürfen) (fig.);wieder dazugehören;wieder ernst zu nehmen sein;aus der Krise herausgefunden haben;wieder respektiert werden;rehabilitiert sein;Wir sind wieder wer. (Gemeinplatz, Hauptform)
-Hast du gedacht! (ugs.);Da siehst du mal, wie man sich irren kann!;Das hast du auch nur gedacht! (ugs., Spruch);Falsch gedacht! (ugs.);So kann man sich irren. (geh., ironisch);Denkste! (ugs.);Denkste, Puppe! (ugs.);Pustekuchen! (ugs.);Flötepiepen! (ugs., westfälisch);(ja) von wegen! (ugs.);Nichts da! (ugs.);Irrtum!
-(sich) vertschüssen (ugs.);sich verkrümeln (ugs., bundesdeutsch, schweiz.);(sich) schleichen (ugs., süddt., österr.);abschleichen (ugs., schweiz.);(sich) rausscheren (ugs.);die Finken klopfen (ugs., schweiz.);sich dünnemachen (ugs.);sich über die Häuser hauen (ugs., österr.);(sich) dünnemachen (ugs., bundesdeutsch);abfahren (schweiz.);(die / eine) Mücke machen (ugs., bundesdeutsch);(die / eine) Fliege machen (ugs., bundesdeutsch);sich trollen (ugs.);(sich) verzupfen (ugs., bayr., österr.);Leine ziehen (ugs., bundesdeutsch, schweiz.);sich putzen (ugs., österr.);abschieben (ugs., bundesdeutsch);die Platte putzen (ugs., bundesdeutsch)
-abrücken (militärisch);abziehen (Gruppe, Kolonne, Trupp ...);abmarschieren (fachspr., militärisch)
-dazu besteht kein Grund;dafür gibt es keinen Grund;kein Grund, (um) zu ...
-auf Intensiv (ugs., Jargon);an den Schläuchen hängen (ugs.);auf die / der Intensivstation
-(etwas) mit Nährsstoffen versorgen;(etwas) mit Nährstoffen anreichern;(jemanden / etwas) nähren (Hauptform);(jemandem) Nahrung zuführen;(jemanden) mit Nahrung versorgen
-Deutsche Fußballnationalmannschaft;Deutsche Elf (ugs.);DFB-Auswahl (ugs.);DFB-Elf (ugs.);Auswahl des Deutschen Fußballbundes
-es ist mir peinlich, das zuzugeben (aber) (variabel);ich schäme mich, das zuzugeben (aber);leider muss ich zugeben (dass) (Hauptform);ich muss zu meiner Schande gestehen (dass) (floskelhaft);ehrlicherweise muss ich zugeben (/ sagen) (floskelhaft)
-Regierungswechsel;Thronwechsel;Übergang der Macht;Machtwechsel
-Informatisation (selten);Informatisierung
-(da) brennt die Luft (ugs., fig.);(die) Emotionen kochen über (fig.);(es) herrscht explosive Stimmung
-durchchecken;von A bis Z überprüfen;alles kontrollieren
-(sich) durchchecken lassen;(sich) routinemäßig untersuchen lassen
-(etwas) äußern;(etwas) sagen (Hauptform)
-(jemandes) Kehle ist wie zugeschnürt;keinen Ton herausbekommen (ugs.);(die) Zähne nicht auseinanderbekommen (ugs.);(jemandem) versagt die Stimme (geh.);(das) Sprechen verlernt haben (ugs., ironisch);kein Wort herausbekommen;(das) Maul nicht aufkriegen (derb)
-gesetzliche Rentenversicherung (Deutschland) (Hauptform);erste Säule (fig.)
-dritte Säule (ugs., fig.);private Alterssicherung;private Altersvorsorge
-Steckgitter;Steckmetall
-zu (einem Amt gehen);auf (ein Amt müssen, zur Regelung amtlicher Angelegenheiten) (veraltend)
-Balkanblock (selten);Balkanbund
-Eppaner Stil;Überetscher Stil
-nicht ins Internet kommen (ugs.);keine Verbindung zum Internet bekommen;kein Netz haben (Smartphone) (ugs.);kein Internet haben (ugs.)
-unzeitgemäß;nicht in die Zeit passen(d)
-Trödeln (Hauptform);Trödelei;Bummelei;Herumtrödeln
-solch (undekliniert) (geh., veraltet);ein solcher;solcher;so'n (ugs., salopp);solch ein;so ein (ugs., Hauptform);ein derartiger
-leere Ränge (bei);leere Zuschauerbänke;vor leeren Rängen;ohne Zuschauer
-zu Ehren von (Hauptform);als Geste der Ehrung;(jemandem) zu Ehren;als Ehrbezeugung (für);zu jemandes Ehren;zum Ausdruck der Ehrerbietung (für jemanden)
-stechen;tätowieren
-(das) Einanderbegegnen;(das) Sichbegegnen;Treffen;Begegnung (von 2 Personen);persönlicher Kontakt;Zusammentreffen
-abscheulich (Verbrechen);verabscheuungswürdig;verachtenswert
-(...) am Arsch! (derb);Von wegen (...): du kannst mich mal! (derb);Von wegen (...): Sie können mich mal! (derb);(der) kann mich mal mit ... (derb)
-und das war erst der Anfang!;und es kommt noch besser!
-misshandelt;geknechtet;geschunden;malträtiert
-angekratztes Ego;(jemandes) verletzter Stolz;angeschlagenes Selbstbewusstsein;(jemandes) geschundene Seele (fig.)
-ihmchen (ugs., berlinerisch, scherzhaft, veraltet);der da (ugs.);der (ugs.);er (Hauptform)
-die da (ugs.);sie;ette (ugs., rheinisch, ruhrdt.);die (ugs.)
-Lotsaugpumpe;Entlötpumpe;Entlötsaugpumpe
-(nur) in (Unterwäsche / Unterhose / Schlafanzug / ...);(nur) mit (...) bekleidet;nicht fertig angezogen;(nur) halb angezogen;unangezogen
-beste Behandlungsmethode;Goldstandard (Medizin)
-Recht haben und Recht bekommen sind zweierlei. (sprichwörtlich, variabel);Vor Gericht und auf hoher See ist man in Gottes Hand. (sprichwörtlich, variabel)
-nachverfolgbar;zurückverfolgbar;nachvollziehbar
-(auf jemanden) keinen Zugriff haben;(jemandes) Kontrolle entzogen sein;(jemanden) nicht erreichen
-(auf etwas) nicht zugreifen können;keinen Zugriff haben (auf);nicht herankommen (an);(jemandes) Zugriff entzogen sein;abgeschnitten sein (von)
-ausgesperrt;ausgeschlossen
-(an jemanden) nicht herankommen (ugs., fig., psychologisch);(jemanden) nicht erreichen (ugs., fig., psychologisch)
-online;übers Internet (variabel)
-schnell an Aktualität verlieren;(eine) geringe Halbwertzeit (haben) (fig.);zusehends an Aktualität einbüßen;schnell veralten
-Nachrichtenwert;Neuigkeitswert
-unmittelbar verständlich;gefällig (geh.);eingängig
-Dampfwagen (veraltet);Dampfomnibus (veraltet);Dampfwaggon (veraltet);Dampftriebwagen
-(etwas) gelten lassen;(vor jemandes Augen) Gnade finden (geh.)
-Praxisanleitung;Unterweisung
-dreifältig;dreifach;dreierlei
-Rankgerüst (Hauptform);Spalier;Treillage (fachspr.);Lattengerüst;Gerüst;Drahtgerüst
-Menschengasse (Hauptform);Gasse (ugs.);Spalier
-(etwas) in Aussicht haben;(sich) Hoffnungen machen (auf)
-dazu führen, dass (...) (sich) enger zusammenschließen (gegen) (variabel);(jemanden jemandem) in die Arme treiben
-(jedenfalls / zumindest / nur) auf dem Papier (fig.);pro forma;offiziell
-Habitus (fachspr.);Wuchsform (Pflanze)
-Zahlwort (verschiedene) (ugs.);... Arten (von);...erlei (Zahlwort in Artikelposition);... Sorten (von)
-Aussichts...;Belvedere (fachspr., Hauptform, ital.)
-Ehrenformation;Ehrengarde
-(etwas) abschreiten;(feierlich) die Front der Soldaten abgehen
-Exspektanz;Anwartschaft auf eine noch besetzte Stelle
-multifaktoriell (zu erklären) (fachspr.);nicht nur auf eine Ursache zurückzuführen
-es gibt keinen Gewinner;(es ist ein) Unentschieden (Sport, Wettkampf) (auch figurativ);Situation ohne Sieger (und Besiegten);Pattsituation;Remis (Schach)
-auf Betriebstemperatur sein (ugs., fig.);sich warmgeredet haben
-den Worten Taten folgen lassen;(seine) Ankündigungen wahrmachen;Ernst machen
-Eingangstür;Haustür;Eingang;Hauseingang
-ein bisschen (vor Komparativ);geringfügig (vor Komparativ) (fachspr.);ein klein wenig (vor Komparativ);etwas (vor Komparativ);ein wenig (vor Komparativ)
-nicht ins Gewicht fallen(d);(sich) kaum auswirken;unerheblich (sein);Das macht den Kohl (auch) nicht fett. (ugs., sprichwörtlich);kaum was bringen (ugs.)
-paradiesisch;wie im Paradies
-zusehends weniger werden;rapide abnehmen;(schmelzen) wie Schnee an der Sonne
-Peoplemover (fachspr., engl.);Kabinenbahn
-ungeschnürt (fachspr.);ohne Schnürung (fachspr.)
-biologische Pause (ugs.);Pinkelpause;Toilettenpause
-Münsterstadt (ugs.);Ulm
-Sieg;Dreier (ugs.)
-Haupteisenbahnstrecke;Hauptbahn
-(täglicher) Toilettengang;Toilettenbesuch;Sitzung (für ein längeres Geschäft) (ugs., verhüllend)
-könnte schlimmer schmecken;(ich) hab schon Schlimmeres gegessen;Der Hunger treibt's rein. (ugs., Spruch)
-Feinoptiker;Feinwerkoptiker (schweiz.)
-berufliche Bildung;Berufsbildung
-Beruf;Metier (franz.);Tätigkeitsfeld
-Anlerntätigkeit;Anlernberuf
-Arbeit in Kleingruppen;Gruppenarbeit (Hauptform)
-Stillarbeit;Einzelarbeit
-Partnerarbeit (Hauptform);Arbeit in Tandems
-unaufgefordert;selbsttätig;unverlangt;automatisch;ungefragt
-mit Blindheit geschlagen sein (fig.);(etwas) einfach nicht sehen (ugs., fig.);das Offensichtliche nicht erkennen;wie verblendet (sein)
-nichts sagen (ugs.);nicht aufmucken (ugs.);(sich) nicht trauen, etwas zu sagen;kuschen (vor) (ugs., Hauptform);(sich) alles gefallen lassen;(den) Schwanz einziehen (ugs., fig.)
-Ägisth;Aegisthus (lat.);Aigisth;Aigisthos (griechisch)
-(irgendwohin) (ein)sperren;(irgendwo) (ein)sperren;einsperren;einschließen
-Klang;Tonfall (Stimme) (Hauptform);Ton;Tonart
-tatsächliche Zeit;Echtzeit;Realzeit
-Echtzeit,;Gegenwärtige Zeit
-schändlich sein;schänden;Schande bereiten;Schande bringen;unehrenhaft sein
-ausgesucht;(zu etwas) erkoren (geh.);auserlesen;auserkoren (geh.);ausgewählt;(zu etwas) auserwählt (geh.);erwählt (geh.);(dazu) gewählt
-dazu vorgesehen;dazu bestimmt;dazu ausersehen;dazu gedacht (ugs.)
-(auf den Punkt) gezielt;ausgesucht (geh., fig.);punktgenau platziert
-exquisit;handverlesen;besondere(r/s);ausgesucht (Adjektiv)
-wiederum;im Rückschluss
-Gepräge;Note;Aussehen;Anstrich (fig.)
-Bahnhofskategorie (veraltet);Bahnhofsklasse (veraltet);Preisklasse
-Karawane;Reisegesellschaft;Kamelzug
-allen Ernstes;ernsthaft;(nicht) etwa (in Fragen)
-Unterrichtseinheit;Lektion;Lehrbuchkapitel
-(jemandes) spezifische(r/s);(jemandes) eigene(r/s);(jemandes) besondere(r/s);(jemandes) spezielle(r/s)
-um ... zu (bekommen / erhalten / haben ...);für
-Bautrennfuge;Bauwerksfuge
-Jünger der schwarzen Kunst (geh., fig.);Schwarzkünstler (scherzhaft);Drucker (Beruf)
-Vibrio comma (fachspr., veraltet);Kommabakterium (historisch);Vibrio cholerae (fachspr., Hauptform)
-(Leute miteinander) ins Gespräch bringen;(Leute) zusammenbringen;(Leute) an einen Tisch bringen (fig.);(Leute) an einen Tisch bekommen (fig.)
-(jemanden) bekommen (zu);(jemanden) bringen (zu) (Hauptform);(jemanden) bewegen (zu)
-Mittelöl;Blauöl;Grünöl;Straight-Run (engl.);Gasöl (Hauptform)
-die (/ ihre) Periode haben;ihre Tage haben (ugs.)
-schließlich auch;sicherlich auch;nicht zuletzt (auch)
-alles zusammengenommen;alles in allem;mit allem Drum und Dran (ugs.)
-metaphorischer Stil;tropischer Stil;bildliche Redeweise;figurative Sprechweise;(eine) Tropologie
-Karité;Shea;Shea-Nuss;Sheanuss
-Butterreinfett (fachspr.);Milchfett;Bratbutter (schweiz.);Milchschmalz;geläuterte Butter;Butterschmalz (österr.);Schmalzbutter;geklärte Butter;eingesottene Butter
-heraufstufen (Hauptform);in eine höhere Stufe (/ Kategorie) einordnen;(jemandem / einer Sache) eine höhere Stufe zuerkennen;hochstufen (Hauptform);(jemanden / etwas) einer höheren Stufe zuordnen
-widerspruchsvoll;voller Widersprüche;reich an Widersprüchlichkeiten
-Sabayon (franz.);Zabaione (ital.);Zabaglione (ital.)
-Vanillecreme;Konditorcreme;Creme patissiere (franz.)
-mexikanische Vanille;Bourbon-Vanille (französierend);Echte Vanille;Vanilla planifolia (fachspr.);Gewürzvanille
-abfließende Wassermenge;Abfluss;Abflussmenge
-grundlos beleidigt sein;etwas in den falschen Hals gekriegt haben
-das erste, wohin jemand geht;erster Anlaufpunkt
-kompatibel sein (IT-Technik);interoperabel sein (IT-Technik);zusammenspielen;kombinierbar sein;zusammenwirken
-Druck aus dem Kessel nehmen (fig.);Druck aus dem Kessel lassen (fig.);(der) Wut ein Ventil geben (fig.)
-(der Gegenseite) teilweise entgegenkommen;(ein) Teilzugeständnis (machen);Teilzugeständnisse machen;(ein) teilweises Entgegenkommen
-Unberührbare;Harijan;Paria;Dalit
-im Grenzschutz eingesetzte Kräfte;Grenzschützer;im Grenzschutz eingesetzte Person(en)
-zurückweichen;einen Schritt zurück tun;zurücktreten;einen Schritt (/ Schritte) rückwärts machen;einen Schritt nach hinten machen
-Was ist denn jetzt?;Was soll denn jetzt passieren?;Was passiert denn jetzt?
-(einen Raum) vollquarzen;(jemanden) zuqualmen;(jemandem die Bude) vollqualmen
-Haltung bewahren;(die) Arschbacken zusammenkneifen (derb);sich zusammenreißen;(die) Contenance wahren (geh.)
-von Gefühlen überwältigt (werden);von Gefühlen übermannt (werden);(sich) von Gefühlen hinreißen lassen
-Grenzübertrittstelle (fachspr.);GÜST (fachspr., Amtsdeutsch, DDR, historisch);Checkpoint (fachspr., historisch);Grenzübergang;Grenzübergangsstelle (fachspr.)
-Ansturm (von Menschen);Zulauf (an Menschen);(ein Platz) schwarz vor (/ von) Menschen (fig.);Menschenandrang;Besucherandrang;Besucheransturm
-Hochbetrieb;Betrieb wie auf dem Rummelplatz (ugs.);Betrieb wie auf der Kirmes (ugs.);Publikumsandrang
-im Beruf angekommen sein;wissen, das man das Richtige (für sich) gefunden hat
-(da) stellt sich (natürlich) die Frage;(sich) die Frage gefallen lassen müssen;(sich) mit der Frage konfrontiert sehen;(jemand) wird (natürlich) gefragt ...;(jemandem) wird (natürlich) die Frage gestellt ...
-Besucher hereinlassen (ugs.);(etwas) zur Besichtigung freigeben
-Kontrollstelle;Checkpoint (fachspr., Jargon, engl.);Kontrollpunkt
-Standkontrolle (fachspr.);allgemeine Verkehrskontrolle
-Grenzposten;Grenzwache (schweiz.);Zollwache (historisch, österr.)
-(ein) Land verlassen;ausreisen
-einreisen;zureisen;(ein fremdes) Staatsgebiet betreten
-(irgendwie) anders;auf andere Weise;anderswie;auf andere Art
-abweichend (Adjektiv);sich unterscheidend (Adjektiv);andere(/r/s) (Substantiv-Begleiter) (Hauptform);weitere(/r/s) (Substantiv-Begleiter);alternativ (Adjektiv)
-Kopfnote;Betragensnote (österr.)
-Republikflucht (Amtsdeutsch, DDR);Flucht aus der DDR;ungesetzlicher Grenzübertritt (DDR, juristisch)
-Klotz (ugs.);Fettnäpfchen-Suchgerät (ugs., scherzhaft-ironisch);Primitivling (ugs.);unsensibler Mensch
-Punkt für Punkt abarbeiten;kleinarbeiten
-(jemandem) vorgetragen werden;(jemandem) zu Gehör gebracht werden;(etwas) zu Gehör gebracht bekommen;(jemandem) vorgeführt werden;(etwas) zu Gehör bekommen (Hauptform);(jemandem) vorgespielt werden
-(jemanden) ins Bild setzen;(jemandem) einen Überblick geben (über);(jemanden) auf den neuesten Stand bringen (ugs.);(jemanden) auf den neuesten Stand setzen
-(jemandem etwas) verraten;(jemanden) ins Vertrauen ziehen;(jemanden) einweihen;(jemandem etwas) anvertrauen;sich vertraulich an jemanden wenden
-(einander) unähnlich;sich nicht ähneln(d)
-unregelmäßig;uneinheitlich;ungleichmäßig;unegal (ugs., salopp)
-unmittelbar einleuchten(d);sehr überzeugend;schlagend (Beweis, Argument, Beispiel ...) (fig.);treffend (Vergleich, Beispiel);sehr gut (ugs.)
-die Gunst der Stunde nutzen;das Eisen schmieden (müssen), solange es heiß ist (sprichwörtlich);zügig zur Tat schreiten;die Gelegenheit nutzen, solange sie da ist
-Ich wollte meinen Ohren nicht trauen. (floskelhaft);ich wollte es (erst) nicht glauben;ich musste mich da wohl verhört haben;Ich dachte, ich hör' nicht richtig. (ugs., floskelhaft)
-Sperrstunde;Polizeistunde
-Frau mit Kampfgeist (weibl.);Kämpfernatur;Mann mit Kampfgeist (männl.)
-Palmfaser;Afrik
-Ich brauche keinen Babysitter. (Spruch);Ich kann (ganz gut) alleine auf mich aufpassen. (ugs.);Ich kann selbst auf mich aufpassen.
-zeitkritisch;zeitabhängig;zeitgebunden;zeitgesteuert
-Gelegenheitsengagement;Gelegenheitsgeschäft von Musikern
-sein;es (bei etwas) zu tun haben (mit);es handelt sich (bei etwas) um
-beruhigt;befriedet
-ohne Bedenken;unbesehen (Hauptform);keine Bedenken haben (zu);ohne weiteres;im Vertrauen auf jemandes Redlichkeit
-Verlässlichkeit;Zuverlässigkeit
-im guten Glauben an jemandes Vertrauenswürdigkeit;nach Treu und Glauben;im Vertrauen auf jemandes Redlichkeit;nach dem Prinzip von Treu und Glauben;gemäß dem Grundsatz von Treu und Glauben
-Eigenkontrolle;Selbstbeherrschung;Selbstkontrolle
-Arachnide (fachspr., zoologisch);Arachnoide (fachspr., zoologisch);Spinnentier (fachspr., Hauptform, zoologisch)
-(etwas) nicht getan haben wollen (variabel);behaupten, (etwas) nicht getan zu haben
-so nicht;anders;nicht so
-heilbringend;heilsbringerisch;messianisch (Hauptform)
-Erlösungsverheißung;Heilsversprechen
-Befreiungssehnsucht;Erlösungswunsch;Heilserwartung
-(die) Erwerbtätige(n);(die) Werktätige(n);die arbeitende Bevölkerung
-angeblich (negativ);sogenannt (negativ);so genannt (negativ);will ... sein (negativ)
-Rotifera (fachspr., lat.);Rädertierchen;Rotatoria (fachspr., lat.)
-Acanthocephala;Kratzer;Kratzwürmer
-nun ja ...;ach ja ...;tja ...;naja ...
-nicht hinhören;(jemanden) reden lassen;gar nicht erst hinhören
-zugucken (ugs.);Zaungast sein;zusehen (Hauptform);zuschauen
-Tyrannenadler;Spizaetus tyrannus (fachspr., griechisch, lat.);Tyrannenhaubenadler
-Aquila pomarina (fachspr., griechisch, lat.);Schreiadler (Hauptform);Pommernadler (veraltet);Clanga pomarina (fachspr., griechisch, lat.)
-Stellersche Seekuh;Stellers Seekuh;Borkentier (veraltet);Riesenseekuh;Hydrodamalis gigas (fachspr., griechisch, lat.)
-Takeshima;Dokdo;Hornet Islands (engl.);Liancourt Rocks (engl.);Liancourt-Felsen
-Regenhose;Nässeschutzhose (fachspr., militärisch)
-kulturverachtend;kulturbanausisch
-Babyschühchen;Schühchen;Babyschuhe;Schuhchen
-sauerstoffpflichtig;beatmungspflichtig;beatmet
-Kairos (griechisch);günstiger Entscheidungszeitpunkt
-isolierte Betrachtung von Teilen;Reduktionismus
-Phiole (geh.);Fläschchen
-rechtlicher Status;Rechtsstellung;rechtliche Stellung
-Richtungsstreit;Flügelkampf (in einer Partei)
-Diskussion über die programmatische Ausrichtung;Programmdebatte;Programmdiskussion
-gnadenlos vorgehen;kein Erbarmen kennen;kein Mitleid kennen;brutal vorgehen
-keine Gefangenen machen (ugs., fig., übertreibend);(etwas) gnadenlos durchziehen (ugs.);keine Kompromisse kennen
-(für jemanden) ein Fremdwort sein;(etwas) nicht kennen;kein(/e/n) ... kennen
-Diktum (geh.);Ausspruch;berühmtes Wort;Sager (geh., österr.);denkwürdiger Satz
-cornern (Neologismus);(zwanglose) Outdoor-Party feiern
-ohne Hindernisse;zugänglich;begehbar;unverstellt;befahrbar;betretbar
-(etwas + zu + Infinitiv) behaupten;(etwas sein / getan haben / irgendwo gewesen sein / ...) wollen
-Lohnabschlag;Lohnabschlagszahlung;Vorschuss;Abschlagszahlung;Lohnvorauszahlung
-am Untergehen sein (ugs.);versinken (poetisch);untergehen (Sonne, Mond; Stern) (Hauptform);im Untergang begriffen (sein) (geh.);(schon) tief stehen;hinter dem Horizont verschwinden
-weniger verlangen;reduzieren (Preis);senken (Preis);herabsetzen (Preis/e);(den) Preis nachlassen;(jemandem etwas) billiger lassen (ugs.);mit dem Preis (he)runtergehen
-(Preis/e) hochsetzen;(Preis/e) anheben;mit dem Preis hochgehen;(Preis/e) erhöhen (Hauptform);mit dem Preis (he)raufgehen;heraufsetzen (Preis/e);auf den Preis aufschlagen;(Ware/n) verteuern
-Augenschatten;Augenring
-heikles Thema (bei jemandem);Reizthema (für jemanden);wunder Punkt (bei jemandem) (fig.)
-Plakatständer;Werbetafel;Reklametafel;Kundenstopper;Gehwegaufsteller
-Billboard (fachspr., engl.);Plakatwand
-(eingeblendete) Werbung auf einer Internetseite;Werbebanner (fachspr., Hauptform)
-Bandenwerbung;Stadionwerbung;Werbebanden
-Uranos (griechisch);Uranus (lat.);Caelum (lat.);Ouranos (griechisch);Coelus (lat.)
-Charon (griechisch);Charopos (griechisch)
-Fruchtbarkeitsgott;Sucellus;Sucelus;Sucaelus;Waldgott
-Silvanus Litoralis (lat., römisch);Silvanus (lat., römisch);Waldgott;Küstengott;Hirtengott
-Rückenflosse;Finne (fachspr.)
-vorgebildet (Hauptform);mit Vorerfahrung;mit Vorwissen
-Hastorang;α Piscis Austrini (fachspr., lat.);Fomalhaut (fachspr., arabisch, Hauptform);Difda al Auwel (arabisch);Os Piscis Meridiani (lat.)
-(der) erste Punkt ist;am Anfang (von etwas) stehen;den Einstieg bilden;beginnen mit;einsteigen mit;(der) Einstieg ist;anfangen mit
-in den ersten Wochen (des/der ...);in der ersten Zeit;in der Frühgeschichte (des/des ...);anfänglich;anfangs;in den (/ seinen / ihren) ersten Jahren;in seinen (/ ihren) Anfängen;in den (/ seinen / ihren) frühen Jahren;in seinen (/ihren) Anfangsjahren;in den (/ seinen / ihren) Anfangsjahren;in der (/ seiner / ihrer) Frühphase (/ Anfangsphase);in der Anfangszeit;in seinen (/ihren) ersten Jahren (/ Monaten / Anfangsjahren ...);in den ersten Monaten (des/der ...)
-lügen, ohne rot zu werden;schamlos lügen;(jemandem) frech ins Gesicht lügen;(jemanden) frech anlügen;(jemandem) mitten ins Gesicht lügen;hemmungslos lügen;(jemandem) dreist ins Gesicht lügen
-(normalerweise) ... heißen (ugs.);üblicherweise als ... bezeichnet;unter ... laufen (ugs.);(volkstümlich) als ... bezeichnet;(jemandem) unter dem Namen ... geläufig;(volkstümlich) als ... bekannt;(etwas) als ... kennen (ugs.);üblicherweise unter dem Namen ... bekannt;unter dem Namen ... geführt (werden)
-Das darf ich Ihnen nicht sagen.;Ich habe meine Anweisungen.;(das) machen wir nicht (salopp);(das) geht nicht wegen Datenschutz (ugs.)
-eingeweiht;informiert;unterrichtet
-die Macht des Wortes (besitzen) (geh.);wortgewaltig;wortstark;sprachgewaltig;redegewaltig;sprachmächtig
-studierte Leute (ugs.);Bildungsbürgertum;die gebildeten Schichten;die gebildeten Stände;Akademiker (Plural)
-Monument;Zeitzeuge;Kulturdenkmal
-bezeugen;Kunde ablegen (von) (geh., veraltet);künden (von) (geh.);Zeugnis ablegen (von);als Zeichen stehen (für)
-(kollegiale) Kumpanei;Kameraderie (abwertend);falsch verstandene Kollegialität
-geheimes Einverständnis (mit);stillschweigende Duldung
-gestisch;mimisch;ohne Worte;pantomimisch;(nur) mit Gesten
-an nachkommende Generationen weitergeben;der Nachwelt hinterlassen;(den Nachkommen) vererben (fig.);den Nachgeborenen überlassen
-eine Verwendung haben (für);(etwas) nicht gebrauchen können;(etwas) nicht brauchen (können)
-sich von seiner Schokoladenseite präsentieren (fig.);sich von seiner Schokoladenseite zeigen (fig.);sich von seiner besten Seite zeigen (fig.)
-(jemanden) beeindrucken (wollen);(bei jemandem) Eindruck schinden (wollen)
-Gesamtdarstellung des Schaffens (in der Kunst);Werkschau
-(sich etwas) nicht vorzustellen wagen;(sich etwas) lieber nicht vorstellen (ugs.);(sich etwas) nicht auszudenken wagen
-austrocknen;trockenfallen (Wasserlauf, Brunnen) (Hauptform);versiegen (auch figurativ)
-heraussprudeln;hervorschießen;schießen (aus);übersprudeln;sprudeln
-Portalstapler (fachspr.);Straddle Carrier (fachspr., engl.);Portalhubwagen (fachspr., Hauptform)
-unterprivilegiert;diskriminiert;benachteiligt
-ein Unikum (sein / darstellen / geblieben sein);nur einmal vorkommen(d);singuläre Erscheinung;gibt es nur einmal
-Dubbel (ugs., niederrheinisch, ruhrdt.);Klappbrot;Klappstulle;Knifte (/ Kniffte) (ugs., ruhrdt.)
-erfolgreich zu Ende führen;zu einem guten Ende bringen;einem guten Ende zuführen (geh., variabel);erfolgreich abschließen
-besorgter Bürger (Schlagwort, verhüllend);Wutbürger (Schlagwort, negativ);Querdenker (Schlagwort, verhüllend)
-Selbst-Rehabilitation (geh.);(eigene) Reinwaschung (geh., fig.);Selbstentlastung (geh.)
-Vermittler;Mediator;Moderator
-Anthocyan (fachspr., botanisch);roter Blattfarbstoff
-durch (eine) Konjunktion verbunden;syndetisch (fachspr., sehr selten)
-nicht durchdringen;(sich) nicht durchsetzen können (bei)
-Phalera bucephala (fachspr., griechisch, lat.);Mondvogel;Mondfleck
-Haltverbot (offiziell);Halteverbot (ugs.)
-Eispiegel (fachspr.);Insektengelege
-Euphydryas maturna (fachspr., griechisch, lat.);Hypodryas maturna (fachspr., griechisch, lat.);Eschen-Schneckenfalter;Maivogel (Hauptform);Kleiner Maivogel
-(sich) Aug' in Aug' gegenüberstehen (geh., literarisch, veraltet);einander gegenüberstehen;(sich) Auge in Auge gegenüberstehen
-Maiwein;Maitrank;Maibowle;Waldmeisterbowle
-Meiserich;Zehrkraut;Wohlriechendes Labkraut;Gliederzunge;Meusch (mecklenburgisch);Leberkraut;Möschen (holsteinisch, ostpreußisch);Wohlriechend Megerkraut;Wooldmester;Herfreudeli (schweiz.);Mariengras;Maienkraut;Massle;Mentzel;Waldmännlein;Maikraut;Mäserich;Möseke;Halskräutlein (elsässisch);Waldmeister (Hauptform);Mösch;Meserich (schlesisch);Gliedekraut (schlesisch);Schumarkel;Gliedzwenge;Mäsch (mecklenburgisch);Galium odoratum (fachspr., lat.);Sternleberkraut (schweiz.);Theekraut (schweiz.);Herzfreud;Meesske (ostpreußisch);Gliedegenge (schlesisch)
-o-Cumarsäurelacton;Kumarin (Hauptform);Chromen-2-on;1,2-Benzopyron;Tonkabohnencampher;α-Benzopyron;Cumarin (Hauptform);2H-1-Benzopyran-2-on
-(sich) von der Idee leiten lassen (dass);(sich) von dem Gedanken leiten lassen (dass);(jemandes) Leitvorstellung sein;(jemandes) Leitidee sein;(sich) von der Vorstellung leiten lassen (dass)
-Orientierungsbasis;Leitstern (geh., fig.);Bezugspunkt;Orientierungspunkt
-(irgendwo seinen) Anfang nehmen;ausgehen (von);(irgendwo) seinen Ursprung haben;(irgendwo) anfangen
-(etwas) ankurbeln (Nachfrage, Wirtschaft);auf Trab bringen (fig.);in Schwung bringen;auf Touren bringen (fig.)
-(jemanden) grillen (fig., übertreibend);(jemanden) auseinandernehmen (fig., übertreibend);(durch Fragen) in die Enge treiben (fig.);(jemanden) scharf befragen;(jemanden) in die Zange nehmen (fig.);(jemanden) ins Kreuzverhör nehmen (auch figurativ, Hauptform);(jemanden) stellen;(jemandem) mit Fragen hart zusetzen (Hauptform)
-(sich) rechtfertigen müssen (für / angesichts);(sich) verantworten müssen (vor jemandes Augen / vor jemandem / für etwas);(sich) erklären müssen (zu)
-noch ein Satz;wenn ich das eben noch zu Ende führen darf;erlauben Sie noch (den) einen Satz;ganz kurz (dies) noch
-beitragsfrei stellen;ruhend stellen
-Liebe gegen alle Vernunft;Amour fou (geh., bildungssprachlich, franz.)
-(sich) nicht nahestehen;(sich) nichts zu sagen haben;(sich) fremd bleiben
-(eine) Klamotte;Anarcho-Komödie (fachspr.);Slapstick-Film;Klamaukfilm
-polarisierend;spalterisch;spaltend
-zu(m) ... geben (es);es gibt ... zu essen;es gibt ...;auf den Tisch kommen;zu essen geben (es)
-Viererschnapsen;Bauernschnapsen
-Dachpfette;Pfette
-Mittelpfette;Zwischenpfette
-Wandpfette;Fußpfette
-Dachtragwerk;Dachgerüst;Dachwerk;Dachkonstruktion;Dachstuhl
-Klosterziegel;Mönch und Nonne;Priependach
-Dachpfanne;Dachziegel
-(jemandes) Gespräche mitschneiden;(jemandes) Telefon überwachen;(jemandes) Telefon abhören;(bei jemandem) mitlauschen;(jemandes) Gespräche mithören;(bei jemandem) mithören
-versuchen, an (vertrauliche) Informationen zu kommen;(jemanden / ein Unternehmen) aushorchen;an (private) Informationen gelangen wollen
-Wie ich (ja) bereits sagte.;Dito. (geh., bildungssprachlich, Hauptform, lat.);Dafür gilt dasselbe / das gleiche.;Wie gesagt.;Ich sagte es bereits.;Ebenso.
-Einheitlichkeit;Einförmigkeit;Gleichförmigkeit;Uniformität
-zur Verfügung stehen;zu haben (sein);zu bekommen (sein);zu erhalten sein;verfügbar (sein);erhältlich (sein);auf dem Markt (sein)
-neu auf dem Markt;frisch eingeführt;neues Produkt
-(jemandem) falsche Hoffnungen machen;Erwartungen wecken, die man nicht einlösen kann;falsche Hoffnungen wecken
-Souvenir-Medaille (Hauptform);Souvenir-Prägung (Hauptform);Elongated Coin (engl.);Prägemünze;Quetschmünze;Andenkenmünze
-Angeberstart;Kavaliers(s)tart;Ampelstart
-Archivmaterial (Film, Radio, TV);Archivaufnahme(n)
-Einraumwohnung;Ein-Zimmer-Wohnung;Einzimmerwohnung
-Gegenstand der Diskussion;Verhandlungsgegenstand;Diskussionsthema
-Dokumentenkamera (fachspr.);Visualizer (fachspr., engl.)
-nur natürlich sein (floskelhaft);logischerweise;wie Sie sich (sicher) denken können;verständlicherweise;naturgemäß (Hauptform);in der Natur der Sache liegen (Redensart);wie du dir (sicher) denken kannst (ugs.)
-Milchdosenöffner;Milchdosenlocher;Dosenstecher;Dosenmilchöffner;Dosenlocher
-Pfriem;Ahle;Vorstecher;Ort
-Trauerbrief;Todesanzeige;Trauerkarte (Hauptform);Einladung zur Beerdigung
-Traueranzeige;Todesanzeige (Inserat)
-auf dem Feld der Ehre sein Leben lassen (veraltet);fallen (Hauptform, militärisch);als Held sterben;auf dem Feld der Ehre sterben (veraltet);draußen bleiben (veraltet, verhüllend);für das Vaterland sterben
-Quartiermeister (militärisch);Versorgungsoffizier
-Besetzt;Aufgeladen;Bewertet;Konnotiert
-unterdrücken (emotionalen Impuls);(die) Faust in der Tasche ballen (fig.);(z.B. seinen Frust) runterschlucken (ugs.);(z.B. seine Wut) herunterschlucken;(die) Faust im Sack machen (ugs., fig., schweiz.);(z.B. seinen Ärger) hinunterschlucken
-(sich / einen Impuls) nicht zügeln;(seinem inneren Antrieb) die Zügel schießen lassen (fig.);(eine Regung) nicht kontrollieren;(einem Drang) nachgeben;(seinen Gefühlen) freien Lauf lassen
-offen zeigen;(etwas) herausschreien (Hauptform);Jeder soll(te) es wissen. (kommentierend);Alle soll(t)en es hören. (kommentierend)
-Galois-Feld;endlicher Körper;Galois-Körper
-(die) beste Lösung;(das) Nonplusultra (sein) (geh.);Etwas Besseres gibt es nicht.;einfach das Beste (sein)
-(etwas) als selbstverständlich voraussetzen;(etwas) voraussetzen;(etwas von jemandem) erwarten (Hauptform);(etwas) erwarten
-(gegen jemanden ein) Waisenknabe (sein) (ugs., fig.);(ein) Chorknabe (ugs., fig.);(ein) harmloser Bursche;harmlos (sein)
-keiner Fliege etwas zuleide tun (können) (fig.);harmlos (sein);niemandem etwas Böses (an)tun (können);friedlich;sanftmütig
-Triticum aestivum spelta (griechisch, lat.);Dinkel (Hauptform);Schwabenkorn;Spelz;Fesen;Vesen;Spelt
-Bulgur (Hauptform);Bulghur;Burghul;Boulghour;Bulgurweizen
-Hordeum vulgare (fachspr., lat.);Gerste
-Passer arboreus (fachspr., lat.);Waldsperling;Gerstendieb;Baumsperling
-Maniok (Hauptform);Kassave;Manihot esculenta (fachspr., griechisch, lat.);Cassava;Yuca;Mandioca;Mandi'o
-Tapioka;Tapiokastärke
-Polaco;Yacuma;Jícama;Yacumpi;Arboloco;Smallanthus sonchifolius (fachspr., griechisch, lat.);Jíquima;Llacoma;Yacón (Hauptform);Polymnia sonchifolia (fachspr., griechisch, lat.);mexikanische Kartoffel;Jacón;Taraca;Arikuma;Chiriguano;Polymnia edulis (fachspr., griechisch, lat.);Aricona;Llacon;Kartoffelbohne;Puhe,;Shicama;Ipio;Jiquimilla;Aricoma;Colla;Inkawurzel;Jikima
-Ich sag' es jetzt zum (aller)letzten Mal! (ugs., Elternspruch);Muss ich mich (erst) wieder aufregen? (ugs., Elternspruch);Tu's einfach. (Hauptform);Ich zähle jetzt bis drei ... (ugs., Elternspruch);Muss ich erst (wieder) mit dir schimpfen? (ugs., Elternspruch)
-es wäre von Vorteil (wenn);es wäre gut, wenn;es wäre viel gewonnen (wenn);uns wäre (schon) geholfen, wenn;es würde uns weiterbringen (wenn)
-(plötzlich) an Höhe verlieren;durchsacken (Jargon);absacken;abschmieren (Jargon);abkippen
-Kondiment;Würzsauce
-Abschlag;Abschlagszahlung;Vorauszahlung;Vorschuss
-Teilzahlungsbetrag (regelmäßig zu leisten) (fachspr.);Rate
-süchtig machen(d);mit Suchtpotential
-vielbesungen (geh., literarisch);viel besungen (geh., literarisch);oft erzählt;häufig beschrieben
-Mitfahrer;Fahrzeuginsasse;Sozius (Motorrad);Beifahrer
-Telekomiker (ugs., Jargon, scherzhaft-ironisch);Telekomer (ugs., Jargon);Telekom-Mitarbeiter
-(eine) Feststellung treffen;(eine) Aussage treffen (zu / über);(etwas) festhalten;(etwas) feststellen
-(etwas) schleifen lassen (ugs.);(die Dinge / alles / ...) laufen lassen (ugs.);(sich) nicht richtig kümmern (um) (ugs.)
-(etwas) gelassen aufnehmen;(jemandes) Enttäuschung (über etwas) hält sich in Grenzen (ironisch);(etwas) so gerade noch verkraften (können) (ugs., ironisch);nicht allzu enttäuscht sein (Hauptform)
-(etwas) nicht auf die leichte Schulter nehmen (fig.);(etwas) ernst nehmen
-In Ordnung.;Geht klar. (ugs.);Mach ich. (Hauptform);Schon unterwegs. (ugs.);Machen wir.;Ist gebongt. (ugs.);Verstanden.;Wird erledigt.;Okay.
-Partyleben;Nachtleben;Kneipenleben
-Mitarbeiter im technischen Kundendienst;Techniker (ugs.);Mitarbeiter im technischen Außendienst
-Sache;Angelegenheit;Geschichte
-a gmahde Wiesn (ugs., bairisch);(da) kann nichts schiefgehen (ugs.);(es gibt überhaupt) kein Risiko;sichere Sache (ugs.)
-(sich) klar machen müssen;Dazu muss man wissen ... (floskelhaft)
-Hintergrundinformation;ergänzende Information;Information zur Einordnung
-Komfortzone;Wohlfühlzone
-Bitte um eine Spende;Spendenaufruf (Hauptform);Bitte um finanzielle Unterstützung;Bitte um Spenden;Bettelbrief (abwertend)
-Ziehbutter;Ziehfett
-Lothringer Specktorte;Quiche lorraine;Quiche à la lorraine;Tarte à la crème;Speckkuchen
-Restaurant-Terrasse (vor dem Lokal);Außengastronomie;Straßencafè;Schanigarten (österr.);Außenbewirtung (vor dem Lokal);Freischankfläche (fachspr., Amtsdeutsch)
-Neudeutsche Schule;Logische Schule
-Schachkomposition;Schachproblem;Schachaufgabe
-Arztschild;Praxisschild
-Kreditzinsen;Interessen;Zinsen
-Combined Combustion Engines (engl.);Diesotto;Combined Combustion System (engl.);Benzinselbstzünder
-Drahtkörbchen;Agraffe (fachspr., franz.);Vierdrahtverschluss (fachspr.);Drahtkorb;Drahtklammer (des Sektkorkens) (ugs.)
-Zamboni (Markenname);Eisbearbeitungsmaschine;Eishobel
-(jemanden) umsetzen;(jemandem) einen anderen Platz zuweisen;(jemanden) auf einen anderen Platz setzen
-Bremsenreiniger;Teilereiniger
-Grabmilbe;Krätzmilbe
-Acarus (fachspr., lat.);Milbe
-Rote Spinne;Obstbaumspinnmilbe;Panonychus ulmi (fachspr., griechisch, lat.)
-Trombidium holosericeum (fachspr., griechisch, lat.);Rote Samtmilbe
-Karpfenlaus;Fischzecke;Fischlaus
-(danke) gleichfalls;Du mich auch! (/ Der / Die mich auch!) (derb, ironisch);dir auch (/ du auch - als Antwort) (ugs.);Ihnen auch. (/ Sie auch!) (ugs.);Auch so! (Antwort) (ugs.)
-in einer stillen Stunde (auch ironisch, fig.);gelegentlich (mal);bei Gelegenheit;irgendwann (mal) (ugs.)
-(etwas Unangenehmes) beinahe erleben (Konjunktiv);(hart) vorbeischrammen (an);(einer Sache) knapp entgehen;fast (irgendwo) landen (Konjunktiv)
-den Pfad der Tugend verlassen (fig.);sündigen;Böses tun;sündhaft handeln
-brav sein (ugs.);anständig bleiben;auf dem Pfad der Tugend wandeln;sauber bleiben (ugs.)
-Ökosozialist (historisch);Radikalökologe;Fundi;Vertreter der Fundamentalopposition
-Grünen-Vertreter;Grünen-Sympathisant;Grüner (ugs., Hauptform);Parteimitglied bei den Grünen
-Wollmaus (ugs.);Chinchilla
-die wahre (z.B. Angela Merkel);ganz bei sich selbst;der wahre (z.B. Donald Trump);authentisch (Person oder ihr Handeln)
-plausibilisieren;auf Plausibilität überprüfen
-participium necessitatis (lat.);Partzip der Notwendigkeit;Gerundiv;Gerundivum (lat.);zu-Partizip
-(Bezeichnung für) etwas Auszuführendes;Gerund;Gerundium
-(da kannst du) ein Ei drüber schlagen (ugs.);vergiss es einfach (ugs.);(da kannst du) ein Ei drüber hauen (ugs., salopp, variabel)
-Handelsbücher führen (fachspr., juristisch);Bücher führen;(eine) Buchführung vorweisen können;(eine) Buchführen haben (ugs.);(eine) Buchführung betreiben
-(sich) um die Buchführung kümmern (ugs.);(jemandem / irgendwo) die Bücher führen (Hauptform);die Buchführung erledigen (ugs.);die Buchführung machen (ugs.);für die Buchführung zuständig sein
-über jemandes Barbestände Buch führen;(das / ein) Kassenbuch führen (Hauptform);Bestandsveränderungen der Barkasse (ver)buchen (fachspr.)
-es zieht jemanden (irgendwohin);(etwas) treibt jemanden (irgendwohin);(irgendwohin) wollen
-leichte(r) Zweifel (Hauptform);leise(r) Zweifel;gelinde(r) Zweifel (geh.);vorsichtige(r) Zweifel
-starke(r) Zweifel (Hauptform);erhebliche(r) Zweifel;beträchtliche(r) Zweifel;massive(r) Zweifel
-(die) Stätten seines Wirkens;(die) Stätten ihres Wirkens;(die) Stationen seines Lebens;(die) Stationen ihres Lebens
-Schon. (als Antwort) (ugs.);Ja, schon. (ugs.);Da erzählst du mir nichts Neues.;Ja sicher. (ugs.);Naja und? (ugs.);Ja und? (ugs.)
-War das (schon) alles?;Und weiter? (ugs.);Kommt da (jetzt) noch was? (ugs.);Und? (ugs.)
-Man kann nie wissen. (ugs., floskelhaft);Vorsicht ist die Mutter der Porzellankiste. (kommentierend, sprichwörtlich);Man weiß (ja) nie. (ugs., floskelhaft);Man kann nicht vorsichtig genug sein.
-Wagenreihungsplan;Wagenstandsanzeiger
-es auf einen Streit ankommen lassen;(sich) einer Auseinandersetzung stellen;einem Konflikt nicht ausweichen;in den Konflikt gehen;(einen) Fehdehandschuh aufnehmen (fig.)
-(jetzt) im Amt;regierend;derzeitig;(derzeit) amtierend;gegenwärtig (adverbial)
-die Amtsgeschäfte weiter führen;im Amt bleiben;weiterregieren
-Hexenbuckel (volksmundlich);Witwenbuckel (volksmundlich);Kyphose
-zugeben, etwas falsch gemacht zu haben;zugeben, einen Fehler gemacht zu haben;zu einem Fehler stehen
-möchtest du mir etwas sagen?;kann ich etwas für dich tun?;was liegt dir auf dem Herzen?
-Mehr weiß ich (auch) nicht.;Mehr ist (/ war) nicht zu erfahren.;Der Rest ist Schweigen. (Zitat)
-Darüber reden wir (besser) nicht. (ugs.);Der Rest ist Schweigen. (Zitat);Da(rüber) schweigt des Sängers Höflichkeit. (geh., Redensart);Lass(t) uns (lieber) nicht darüber reden. (ugs.)
-einparken;(Fahrzeug) in eine Parklücke bugsieren (variabel)
-aus der Parklücke herausfahren (variabel);ausparken
-Plus Code;Open Location Code (engl.);OLC (Abkürzung, engl.)
-abtöten;unschädlich machen
-strubbelig machen (ugs., fig., norddeutsch);(etwas) durcheinanderwerfen;in Unordnung bringen;(jemandem etwas) durcheinanderbringen (ugs.);in Unordnung versetzen;(etwas) durcheinanderbringen
-erleuchtet sein (Person);(ein) höheres Wissen haben;auf den Grund der Dinge blicken;erkennen, was die Welt im Innersten zusammenhält (geh., Zitat, bildungssprachlich, variabel);die letzten Seinsgründe erkennen (geh., variabel);zu tiefen Einsichten gelangt (sein)
-Waffensystem;komplexe Waffe
-Solanaceae;Nachtschattengewächse
-pädagogische Maßnahme;Erziehungsmaßnahme
-Happy Hour;Nachsitzen;Extrastunde nach der Schule
-Blick aus dem Fenster;Fensterblick
-jahreszeitliche Pflanzenentwicklungsstadien;Jahreseinteilung nach Erscheinungen in der Pflanzenwelt;Phänologie;10 Jahreszeiten der Pflanzen
-Obstbaum;Obstgehölz
-Kirschbaum;Kirsche
-Winterlinde;Tilia cordata (fachspr.)
-Tilia platyphyllos (fachspr.);Sommerlinde
-Wohngebiet;Wohnanlage;Wohnviertel;Wohnsiedlung
-Beimssiedlung;Hermann-Beims-Siedlung
-Neues Bauen;Neue Sachlichkeit
-Städtebau;(sichtbare und gestalterischen Aspekte der) Stadtplanung
-(jemanden) durcheinanderbringen;(jemanden) nervös machen;(jemanden) aus dem Konzept bringen (fig.);(jemanden) verwirren
-Magdeburger Dom;Dom zu Magdeburg St. Mauritius und Katharina
-Arbeitgeber;Brotherr (ugs.);Brötchengeber (ugs.);Sklaventreiber (derb)
-Bimmel (ugs.);historischer Straßenbahntriebwagen;Oldtimer
-Elv;Elbe;Labe;Albis (lat.)
-nervös werden;(sich) irritieren lassen;aus der Fassung geraten;(sich) aus dem Konzept bringen lassen
-(sich) verheddern (ugs., norddeutsch);(sich ineinander) verwickeln;(sich) verknäueln;(sich) verknoten;(sich) ineinander verschlingen
-(sich irgendwohin) flüchten;(sich) in Sicherheit bringen;(irgendwo) Schutz suchen
-ungern zurückdenken (an);nicht erinnert werden mögen (an);mit Schauder(n) zurückdenken (an) (auch ironisch, fig., floskelhaft)
-per Brief;auf dem Postweg(e);brieflich
-Tötung (Wildtier);Abschuss;letale Entnahme (fachspr., Amtsdeutsch, juristisch, verhüllend)
-(sich) unerwünscht verhalten;(ein) Problem darstellen (distanzsprachlich);Problem... (verhüllend);für Ärger sorgen (ugs.);(viel) Ärger haben (mit) (ugs.);Ärger machen (ugs.);(sich) unangepasst verhalten
-Anglo-Pariser Becken;Pariser Becken
-viel Platz bieten;großzügig bemessen;großzügig (ausgelegt / angelegt);geräumig (Wohnung)
-es ist (mit / um etwas) gut (/ schlecht / nicht optimal ...) bestellt;es steht gut (/ schlecht / bestens ... mit)
-Deep State (Schlagwort, engl.);Staat im Staate
-Das musste mal gesagt werden!;Das musste (einfach) mal raus! (ugs.)
-miesmacherisch;wenig optimistisch;schwarzseherisch;spielverderberisch;negativ;mutlos;deprimierend;schwarzmalerisch
-in solcher Weise, dass;auf eine Weise, dass;dergestalt, dass;solchermaßen, dass;in einer Weise, dass;derartig (...), dass;(und zwar) so, dass
-Erbunwürdigkeit;Indignität (veraltet)
-Kennenlernen;Einarbeitung;Vertrautwerden
-(sich) aufrichten;gerade stehen;Haltung annehmen
-umwölkt;wolkenverhangen;von Wolken umgeben;nebelverhangen
-besonders gefährdete Gruppe;vulnerable Gruppe (fachspr.);Risikogruppe
-elektromagnetische Welle;elektromagnetische Strahlung;Strahlung (Kurzform)
-Radiowelle;Hertzsche Welle;Funkwelle
-Verpolung (veraltet);Polonisierung
-Kassuben;Kaschuben
-Vorsicht (Hauptform);Achtsamkeit;Zurückhaltung
-Republik Florenz;Florentiner Republik (offiziell)
-Reichsmarschall;Erzmarschall
-Schedelsche Weltchronik;Nürnberger Chronik
-Stotterbremse (fig.);Stop and Go (fig.)
-Tortenheber (Hauptform);Tortenschaufel;Kuchenschaufel;Kuchenheber
-leidtragend;hinterblieben;trauernd
-Verblendschale;Veneer (engl.)
-Beeinflussungsmöglichkeit;Stellschraube (fig.)
-besorgter Bürger (Schlagwort);Rechtspopulist
-Empörungspotential;Erregungspotenzial (fig.)
-rotes Tuch (für jemanden) (fig., Hauptform);Reizthema (für jemanden)
-hochgehen wie ein HB-Männchen (fig., veraltet);hochgehen wie ein Rakete (ugs., fig.);hochgehen (fig.);abgehen (ugs., jugendsprachlich);auf 180 sein (ugs., fig.);an die Decke gehen (ugs., fig.);aufbrausen (fig.)
-schnell wütend;aufbrausend;sofort auf 180 (fig.)
-handgemacht (ugs.);handgearbeitet (ugs.);manuell gefertigt (fachspr.);handgefertigt
-(bei jemandem) zur Grundaustattung gehören;hat er (/sie) immer dabei (ugs.)
-im Eck (ugs.);im Winkerl (ugs., süddt., österr.);in der Ecke
-(für ein Kind) verantwortlich (ugs.);sorgeberechtigt (juristisch);verantwortlich für das Kindeswohl (juristisch)
-an Wertschätzung einbüßen;an Glanz verlieren;an Ansehen verlieren;in jemandes Ansehen sinken;(sich etwas) vergeben (ugs., veraltend)
-rechtlich geschütztes Gut;Rechtsgut
-allgemeine Aufmerksamkeit;allgemeine Wahrnehmung;öffentliche Wahrnehmung
-Furor (gegen) (geh.);Eifer (gegen);Wüten (gegen) (Hauptform)
-stilbildend;stilprägend
-Maßstäbe setzen;(einen) neuen Standard definieren;(die) Messlatte (für Mitbewerber) hoch hängen (fig.)
-Ersatz finden;(jemanden) ausplanen (ugs.);(eine) Personallücke stopfen (fig.);(eine) Vertretung finden;(jemanden) vertreten lassen (durch jemand anderen)
-(jemanden) vorher informieren (ugs.);(jemanden) vorwarnen (fig.);(etwas) ankündigen
-(ein) Schlag ins Kontor;nicht mal eben zu schaffen (ugs.);kein Papppenstiel (ugs.);nicht (gerade) wenig (negativ);schon heftig (ugs.)
-den Rahmen unserer Möglichkeiten sprengen;kaum zu stemmen (ugs., fig., floskelhaft);kaum zu bewältigen;kaum zu schaffen
-Mitteilungsbedürfnis;Gesprächsbedarf;Redebedarf
-das Letzte (sein), was jemand (jetzt) braucht;gut verzichten können (auf);das Letzte (sein), was jemand brauchen könnte;das Letzte (sein), was jemandem (jetzt) fehlt;das Letzte (sein), was jemandem fehlen würde
-(ein) eigener Kopf (sein);seine eigene Agenda haben (fig.);seiner eigenen Agenda folgen (fig.)
-(sich) nichts vorschreiben lassen;das tun, was man für richtig hält;autonom agieren (fachspr.);(sich) keine Vorschriften machen lassen;(jemandem) nichts vorschreiben können;nach eigenem Ermessen handeln
-Alte Dame;Hohe Dame
-Es ist genehmigt.;Es gefällt.;Placet. (bildungssprachlich, veraltet)
-lebenssatt (sein);sein Leben gelebt haben;ein erfülltes Leben gehabt haben;auf ein bewegtes Leben zurückblicken (können) (variabel)
-lebensvoll;voller Leben;lebensprall (geh.);urlebendig (geh.)
-(es ist) immer was los (ugs.);es wird nicht langweilig;(es ist) Leben in der Bude (ugs.)
-Ausstattung mit Waffen;Ausrüstung mit Waffen;Bewaffnung;(seine / ihre) Waffen (ugs.)
-Taucherausrüstung;Tauchausrüstung
-Rücksprung;Rückfall;(ein) Zurückfallen;Regression (fachspr., psychologisch);Rücksturz
-(sich) zusammensetzen (mit) (fig.);(sich) Zeit nehmen (für)
-unter ... macht jemand es nicht (ugs., Spruch, variabel);ohne Aussicht auf (mindestens) ... macht jemand es (erst gar) nicht (variabel);mindestens ... (erreichen) wollen
-Katjuscha;Stalinorgel (Jargon, militärisch)
-Gerberträger;Gelenkträger
-Einhängeträger;Schwebeträger (veraltet)
-(sich) verkalkuliert haben;nichts ausgerichtet haben;mit Zitronen gehandelt haben (fig.);(am Ende) nichts erreicht haben (Hauptform);aufs falsche Pferd gesetzt haben (fig.)
-(sich) frei entscheiden können;(sich etwas) aussuchen können;die freie Wahl haben;(etwas) tun oder lassen können
-herausspringen;aus der Gelenkkapsel springen
-springen (aus);herausspringen;schnell verlassen;rausspringen (ugs.)
-herausspringen;rausspringen (ugs.);aus der Führung (/ Halterung / Einrastposition ...) springen
-beim Backen aufbrauchen;verbacken;beim Backen verarbeiten;beim Backen verbrauchen
-anbacken;vorbacken
-zusammengebacken sein;ineinandergebacken sein
-überkrusten;gratinieren;überbacken
-wieder knusprig machen;aufbacken (Brot)
-blindbacken (fachspr.);hohlbacken (fachspr.)
-Töpfchen;Näpfchen
-Stangenweißbrot;Pariser Brot;Baguette (franz.);Stangenbrot;Parisette (schweiz.)
-in den Toaster schieben;toasten (Hauptform)
-überbacken (Partizip Perfekt);au gratin (fachspr., franz.);gratiniert
-gratiniertes Gericht;Gratin;überbackene Speise
-auffliegen;aufpoppen (ugs., IT-Technik);(ruckartig) aufgehen (Hauptform);(sich) plötzlich öffnen;aufschlagen;aufspringen (Deckel, Schloss, Klappe ...)
-zuknallen;zufliegen;zuschlagen (Subjekt = Tür, Klappe ...) (Hauptform)
-Endozytose (fachspr., griechisch);Endocytose (fachspr., griechisch)
-Phagosom (fachspr., griechisch);Fresskörperchen
-Makropinozytose (fachspr., griechisch);Flüssigkeitsaufnahme;Pinozytose (fachspr., griechisch)
-mit lautem Schlag schließen;(etwas) zuwerfen;(etwas) zuhauen;(etwas) zuschlagen;(etwas) zuknallen (Tür);schwungvoll schließen
-(die) Hände voll haben;keine Hand frei haben
-Opsonisierung;Opsonierung
-ins Schloss fallen (Tür);zufallen (Tür);zufliegen;plötzlich zugehen
-(sich) schließen;zugehen
-Eisosom (fachspr., griechisch);Einschleusungskörperchen
-inneres Membransystem;Endomembransystem (fachspr., griechisch)
-Lysosom (fachspr., griechisch);Abbaukörperchen
-Rückenmark;Medulla spinalis (fachspr., griechisch, lat.)
-nicht verstehen, was der andere sagen will;aneinander vorbeireden;(sich) gegenseitig missverstehen;nicht verstehen, was der (jeweils) andere meint
-erhöht;gesteigert;größer;überdurchschnittlich
-Finnmark;Finnische Mark
-TEUR (Abkürzung);tausend Euro
-Speciestaler;Speziestaler
-mit Festanstellung;unbefristet (beschäftigt);in ungekündigter Position;festangestellt;in gesicherter Stellung
-kurz vor (Uhrzeit) (ugs.);gleich (Uhrzeit) (ugs.)
-ich habe die Erfahrung gemacht (dass);meiner Erfahrung nach;nach meinen Erfahrungen;nach meiner persönlichen Erfahrung;nach meiner Erfahrung (Hauptform)
-aus eigener Erfahrung (wissen);(etwas) selbst erfahren haben (müssen);aus eigener leidvoller Erfahrung (kennen) (ironisierend);(jemandes) eigene Erfahrung sein;selbst die Erfahrung gemacht haben (dass)
-(der) Rückversand;(das) Retournieren (fachspr.);(das) Zurücksenden;(das) Zurückschicken;Rücksendung
-verwickelt (in) (negativ);seine Finger im Spiel haben (bei) (ugs., fig.);mit verantwortlich (für);(etwas) zu tun haben (mit) (ugs., negativ);beteiligt (an);mit drin hängen (ugs., abwertend, salopp)
-nicht in den Chor derer einstimmen (wollen, die ...) (geh., fig.);(sich) nicht beteiligen;nicht dabei (bei) (ugs.);nicht mitmachen;nicht beteiligt sein (an)
-wieder da sein;(seine) Auszeit beenden;(sich) zurückmelden (fig.)
-einbauen (bis der Vorrat erschöpft ist);(bei Bau oder Geräteausstattung) einsetzen;verbauen
-auf alt getrimmt;alt aussehen(d);Vintage-... (engl.);im Stil der ...er Jahre;im Vintage-Stil;vintage (engl.);Retro...;im Vintage-Look (engl.);retro
-abstimmen (über);(per Abstimmung) entscheiden (über)
-ohne Ansehen der Person (Hauptform, juristisch);egal, wen es betrifft;gleich, wer es ist;egal, wer es ist;egal (/gleich), um wen es sich handelt
-durch ein Sieb streichen;passieren;durchstreichen
-in Trümmern liegen;völlig zerstört sein;in Schutt und Asche liegen
-(seinen) eigenen Kopf haben (fig.);nicht alles mit sich machen lassen;(einen) eigenen Willen haben
-verschärft;intensiver;verstärkt
-verstärkt;intensiver;verschärft
-eingehender;gründlicher;genauer
-Fetzen;(ein) Fetzen von (einem Kleid / Anzug ...) (variabel);Lumpen
-champagner(farben);elfenbein(farben);hellbeige
-Äquivalenzschalldruckpegel (fachspr.);Ersatzgeräuschpegel (fachspr.);Eigenrauschen
-schalldichter Behälter;Rauschbombe (fachspr., Jargon)
-Synthese verschiedenster Künste;Gesamtkunstwerk;Vereinigung verschiedener Künste
-Zedlerei;Zeidlerei
-Waldimker;Zeidler (veraltet)
-Krainer Biene;Banater Biene;Karpatenbiene;Kärntner Biene;Karstbiene;Niederösterreichische Biene
-denken (dass);(jemandes) Meinung (sein);finden (dass)
-davon ausgehen (dass);gedacht haben (dass)
-Lieber sich den Bauch verrenken als den andern etwas schenken. (sprichwörtlich);Futterneid;Selber essen macht fett. (sprichwörtlich)
-Vigna angularis (fachspr., lat.);Azukibohne;Adzukibohne
-Unterstützung leisten;Hilfe leisten;unter die Arme greifen;unterstützen;Unterstützung geben;über die Runden helfen;Vorschub leisten;Hilfestellung geben
-elektrische Last (fachspr.);elektrischer Verbraucher;elektrischer Widerstand
-Endodontologie (fachspr., griechisch);Endodontie (fachspr., griechisch)
-Panzerbeere;Hesperidium;Endokarpbeere
-kostenmäßig;mit dem Preis;was den Preis angeht;im Preis;preislich (Hauptform)
-Non-Food (fachspr., Hauptform);Nicht-Lebensmittel
-es hagelt(e) ... (fig., negativ);erschlagen werden (von) (fig.);einfach zu viel sein (ugs.);nicht wissen, wohin mit;kaum (/ nicht) zu bewältigen (sein);(sich) nicht (/ kaum) retten können (vor);(einer Sache) nicht Herr werden;nicht (/ kaum) hinterherkommen (mit) (ugs.)
-ohne Gespür (für);unsensibel;instinktlos
-was soll die Frage!? (ugs.);warum willst du das wissen?;warum fragst du?
-das weißt du sehr gut!;du weißt es doch!;was soll (überhaupt) die Frage!;wozu die Frage?;das weißt du besser als ich!;das weißt du selbst am besten!
-Kauffahrteischiff;Handelsschiff
-Innenhof;Hinterhof
-Primärkasse;primärer Träger
-hetzen (gegen);Stimmung machen (gegen);Stimmungsmache betreiben (gegen);(Leute) aufstacheln (gegen);(Leute) aufwiegeln (gegen);(Leute) aufbringen (gegen)
-(sich) das Maul zerreißen (über) (ugs.);herziehen (über);vom Leder ziehen (gegen);(Leuten etwas) miesmachen;(etwas) in Bausch und Bogen verteufeln;(etwas) schlechtmachen;(etwas) schlecht dastehen lassen;(etwas) in ein schlechtes Licht rücken (fig.)
-wie nicht von dieser Welt;wie von einem anderen Stern
-Einzelmensch;Einzelpersönlichkeit;einzelne Person;Individuum;einzelne Persönlichkeit;Einzelwesen
-Lebensmittelbehälter;Frischhaltedose;Vorratsbehälter;Frischhaltebox;Vorratsgefäß
-vor Erfolg zu Erfolg jagen(d) (variabel);von einem Erfolg zum nächsten eilen(d);dauer-erfolgreich;erfolgsverwöhnt
-Luftbrust;Pneu (ugs.);Pneumothorax (fachspr., griechisch)
-Histiozytose X;Langerhanszell-Granulomatose;Langerhans-Zell-Histiozytose
-Sjögren-Syndrom;Dacryo-Sialo-Adenopathia atrophicans
-(auf dem Bildschirm) erscheinen (IT-Technik);sich (automatisch) öffnen;aufgehen (Hauptform);aufklappen;auf einmal da sein (ugs.)
-wieder auftauchen;(wieder)gefunden werden;wieder da sein;(etwas) wiederfinden (ugs.);(sich) wieder finden;(etwas) wieder finden (ugs.)
-Wer zu spät kommt, den bestraft das Leben. (kommentierend, sprichwörtlich);(sich) nicht so viel Zeit lassen (dürfen);nicht zu lange warten (dürfen);(etwas) früher tun müssen (Konjunktiv) (ugs.)
-Reprofotografie;Reproduktionsfotografie
-Reprofotograf;Reproduktionsfotograf;Reprograf
-Fotojournalismus;Pressefotografie;Bildberichterstattung
-Produktfotografie;Gegenstandsfotografie;Objektfotografie
-Fotokunst;künstlerische Fotografie;Kunstfotografie
-Pseudo-Solarisation;Sabattier-Effekt
-Analogfotografie;analoge Fotografie
-digitale Fotografie;Digitalfotografie
-Nitrilkautschuk (Kurzform);Acrylnitril-Butadien-Kautschuk
-periodische Faltung;zirkulare Faltung;zyklische Faltung
-(eine Klinge) abziehen;scharf machen (ugs.);schleifen;schärfen;wetzen
-glattklopfen;scharf klopfen (/ scharfklopfen);dengeln
-schneidend;scharfkantig
-extrem scharf;höllisch scharf;rasiermesserscharf;superscharf;sehr scharf;scharf wie eine Rasierklinge
-Mittagsläuten;Zwölfuhrläuten
-in zwei Hälften schneiden;mitten durchschneiden
-auseinanderbauen;(in seine Einzelteile) zerlegen;(etwas) auseinandernehmen (Hauptform)
-(sich etwas) herunterschneiden;absäbeln (ugs., fig.);abschneiden;(sich etwas) abschneiden;herunterschneiden
-(ein Fahrzeug) ausschlachten;alle verwertbaren Teile ausbauen
-herausnehmen (ugs.);ausbauen;entfernen
-Ultracain (Markenname);Articain;Carticain (veraltet)
-(jemanden / etwas) integrieren (in);Teil werden (lassen) von
-nicht mehr rückgängig zu machen (sein) (Hauptform);Es gibt kein Zurück (in einer Sache). (Spruch);nicht mehr zurück können
-(eine) Schicksalsgemeinschaft;auf Gedeih und Verderb aufeinander angewiesen;aneinander gekettet (sein) (fig.)
-...gläubige (fig.);Gefolgsleute;Anhängerschaft;Fangemeinde;(die) Anhänger (von)
-bedingungslose Gefolgstreue;unbedingte Loyalität;Untertanentreue (abwertend, fig.)
-(einen) heimlichen Groll auf jemanden haben;(einen) Pik auf jemanden haben;(jemandem etwas) grollen (veraltet);(einen) Groll gegen jemanden hegen
-(den) Blick schweifen lassen;(sich irgendwo) umschauen;schauen, was es (so alles) gibt (ugs.);(das) Auge schweifen lassen;(sich irgendwo) umsehen
-Glattnatter;Coronella austriaca (fachspr., lat.);Schlingnatter
-Dichroskop;Haidingerlupe
-Temperamentsbündel;Temperamentsbolzen
-Hektiker;nervöses Hemd (ugs., veraltend)
-40 (/ 39 / 38 ...) Stunden die Woche (ugs.);in Vollzeit (arbeitend);auf Teilzeit(basis) (fachspr., Jargon)
-in Teilzeit (arbeiten / beschäftigt sein);keine volle Stelle haben;stundenweise arbeiten
-Rot-Kreuz-Kasten;Verbandskasten;Verbandkasten;Erste-Hilfe-Kasten;Erste-Hilfe-Koffer;Sanitätskasten
-Verbandspäckchen;Momentverband;Verbandpäckchen
-Aderpresse;Tourniquet (fachspr., franz.);Knebelverband (ugs.)
-Russischer Waschbär;Amur-Waschbär;Ussurischer Waschbär;Japanfuchs;Enok;Chinesischer Waschbär;Japanischer Fuchs;Japanischer Marderhund;Japanischer Kreuzfuchs;Japanischer Waschbär;Obstfuchs (selten);Mukden-Waschbär;Waschbärfuchs;Sibirischer Waschbär;Asiatischer Waschbär;Asiatischer Kreuzfuchs;Seefuchs;Marderhund (Hauptform);Chinesischer Japanwolf;Chinesischer Kreuzfuchs;Chinesischer Wolf;Viverrenhund;Tanuki (japanisch);Nyctereutes procyonoides (fachspr., griechisch, lat.);Waschbärhund;Enot;Amur-Wolf;Japanischer Wolf
-Marderhundfell;Seefuchsfell
-Großohrfuchs;Löffelfuchs;Löffelhund (Hauptform);Otocyon megalotis (fachspr., griechisch, lat.)
-zur Geltung bringen;ins rechte Licht rücken;positiv(er) darstellen
-(sich) ziehen;zäh (sein) (fig.);(seine) Längen haben
-Cholecalciferol (fachspr.);Calciol;Vitamin D3 (Hauptform);Colecalciferol
-Pantothenol;D-Panthenol;Dexpanthenol;Panthenol;Provitamin B5
-Vitamin B6 Hydrochlorid;Vitamin B6 (ugs., Hauptform);Pyridoxal (fachspr., Hauptform);Pyridoxaldehyd
-4-(Aminomethyl)-5-(hydroxymethyl)-2-methylpyridin-3-ol (fachspr.);Vitamin B6 (ugs., Hauptform);Pyridoxamin (fachspr., Hauptform)
-Fließbandarbeiter;Bandarbeiter (ugs.)
-ich bin doch nicht blöd!;ich müsste ja verrückt sein (wenn ...)
-empfindlich machen;sensibilisieren (für);anfällig machen
-Machtelite;herrschende Klasse;herrschende Kreise
-zum Establishment gehören;es (im Leben) zu etwas bringen;gesellschaftlich erfolgreich (sein)
-Oberklasse;höhere Kreise;die oberen Zehntausend;Establishment;(die) gehobenen Stände (geh.);Oberschicht
-alarmierend;bedenklich;gibt Anlass zu Befürchtungen (dass);besorgniserregend (Hauptform);kritisch;beunruhigend (Situation, Entwicklung ...);ernst (Lage);Besorgnis erregend
-Vitamin K3 (ugs., Hauptform);2-Methyl-1,4-naphthochinon (fachspr.);Menadion (fachspr., Hauptform)
-Stauungsleber;Cirrhose cardiaque
-tägliche Abläufe;Tagesprogramm;Tagesstruktur
-...appell;(morgendliches / abendliches) Antreten;Appell;Zählappell
-hier!;(ist) da (/ bin da);(körperlich) anwesend
-Anwesenheitsüberprüfung;Anwesenheitskontrolle
-Anmeldung zur Eheschließung (fachspr., Amtsdeutsch);(Gesuch um) Durchführung des Vorbereitungsverfahrens (fachspr., Amtsdeutsch, schweiz.);Eheverkünd(ig)ung (schweiz.);(das) Aufgebot (bestellen) (veraltend)
-Verseifung;Saponifikation (lat.)
-Grüne Seife;Kaliseife;Schmierseife (Hauptform);Kaliumseife
-Seife (Hauptform);Toilettenseife;Feinseife
-Adeps lanae (lat.);Lanolin (fachspr., Hauptform);Wollwachs (ugs., Hauptform);Lanolinum (lat.);Wollfett
-Natriumseife;Kernseife;Natronseife (veraltet)
-Weichseife;Neutralseife
-Bürstling;Hirschhaar;Fachs;Borstgras;Narde
-Montessori-Phänomen;Polarisation der Aufmerksamkeit
-etwas (Bestimmtes) von jemandem wollen;(sich) mit einem (überraschenden) Anliegen an jemanden wenden;einen Anschlag (auf jemanden) vorhaben (ugs., fig., scherzhaft);ein Attentat (auf jemanden) vorhaben (ugs., fig., scherzhaft);wollen, dass (jemand etwas tut)
-aderreich;voll(er) Adern;aderig
-schlecht ausgehen (für);nicht gut laufen (für)
-Schweinslunge (österr.);Jungfernbraten
-Chateaustück;Filetkopf
-Filet mignon (franz.);Filetspitze
-Unterschale;Beinscherzel;Bodenschlegel;Semer
-Rinderfleisch;Rindsfleisch;Rindfleisch
-Entrecôte (franz.);Rumpsteak
-Judenlummer;Bugfilet;Judenfilet;Schulterfilet;Judenlende;Buglende;Buglummer;Falsche Lende;Flasches Filet;Mageres Meisel;Linchen
-Kansas City Steak (engl.);Club-Steak (Hauptform);Boneless Club Steak (engl.);Hotel-Style Steak (engl.);Top Loin Steak (engl.);Strip-Steak;Ambassador Steak (engl.);Veiny Steak;New York Steak (engl.)
-kurzgebratene Rindfleischscheibe;Beefsteak (engl.);kurzgegrillte Rindfleischscheibe;Steak (engl., Hauptform)
-Oberschale;Kluftschale
-Tartar;Beefsteak Tartar;Hacksteak Tartar;Steak tartare (engl., franz.)
-Stotzen (schweiz.);Keule;Biegel (österr.);Schlegel
-Hammelfleisch;Schaffleisch;Schöpsernes (regional);Lämmernes (regional);Lammfleisch (Hauptform)
-Porterhouse-Steak;T-Bone-Steak
-Delmonico-Steak;Rib-Eye-Steak (engl.)
-Hochrippenkotelett;Rib-Steak
-CIP-Konvention;(RS)-System;Cahn-Ingold-Prelog-Konvention;R-S-Nomenklatur
-Beta-Rezeptorenblocker;Betarezeptorenblocker;β-Blocker;Betablocker;Beta-Adrenozeptor-Antagonisten
-Hast du 'ne Sekunde? (ugs., fig.);Hast du 'en Moment? (ugs.);Hast du kurz Zeit?
-(etwas) so an sich haben (ugs.);typischerweise ... sein;zu den Eigenheiten (einer Sache) gehören (dass);nun mal ... sein (ugs.);zu den Eigentümlichkeiten (einer Sache) gehören (dass);(für etwas) charakteristisch sein
-kusch(e)lig;anheimelnd;Kuschel... (auch figurativ);Wohlfühl... (auch figurativ);heimelig
-Rückzug ins (gemütlich) Private;Cocooning (Modewort, engl.)
-(sich) verführen lassen (von);(ihren) Reizen erliegen (geh., männl.)
-einen anderen Ton anschlagen (fig.);die Stimmlage wechseln (fig.);(es) sind neue Töne zu hören (fig.);andere Töne anschlagen (fig.)
-(jemandem) zuzutrauen sein;für etwas gut sein (ugs.)
-anwendungsspezifische Sprache;domänenspezifische Sprache
-Fußeisen;Tellerfalle;Fangeisen;Tellereisen
-Acetatfilm;Sicherheitsfilm
-Nitrofilm;Zelluloidfilm
-Ist das nicht ein bisschen übertrieben?;Findest du das nicht ein bisschen übertrieben?
-Was machst du für Sachen!? (ugs., Spruch, ironisch, kommentierend, variabel);Du machst vielleicht Sachen! (ugs., ironisch);Du machst aber Sachen! (ugs., ironisch);Was hast du da wieder angestellt!? (ugs.)
-Übel;Malum (sehr selten);(das) Schlechte
-(das) Gute;Bonum (sehr selten)
-Indulgenzbrief;Ablassbrief;Ablassblatt
-den Weg kennen;wissen, wohin man laufen muss (ugs.);mit den Örtlichkeiten vertraut (sein);(sich) (dort) auskennen;wissen, wo man hinlaufen muss (ugs.)
-Kleidungsstil;Stil;Style (Jargon, engl.);Modestil;Look (Jargon, engl.)
-Stilisierung;Styling (Jargon, engl.);Aufmachung
-Stilpräferenz;Geschmackspräferenz (fachspr.);(ausgeprägtes) Stilbewusstsein;Stilwille
-(sich) herausheben wollen;(sich) unterscheiden wollen;erkennbar sein wollen;(sich) abheben wollen
-auf dem Silbertablett (fig.);Einladung zum Zugreifen
-(alles) gut gelaufen (ugs., variabel);alle waren glücklich (am Ende) (fig.);es gab ein Happyend (fig.)
-fremdficken (derb);(he)rumvögeln (ugs.);(sich) was zur Abwechslung suchen (ugs.);herumhuren
-auf sich achten;Wert auf ein gepflegtes Äußeres legen;Wert auf (s)eine gepflegte Erscheinung legen
-agitatorisch;hetzerisch;demagogisch
-Verwarnungsgeld;Verwarngeld
-ausgelöst werden;Signal geben;losgehen (Alarmanlage) (variabel);(sich) bemerkbar machen;anschlagen (z.B. Rauchmelder);ertönen
-Schoßhündchen;Punzenlecker (derb, veraltet);Schoßhund
-Festgehalt;festes Gehalt
-(es) ist zu viel (...) auf dem Markt;(es gibt ein) Überangebot (an);(es) sind zu viele (...) auf dem Markt;der Markt ist (/ wird) überschwemmt (mit)
-fernab des Weltgetriebes (geh., sehr selten);in Waldeseinsamkeit;allein im Wald (ugs.);in Waldeinsamkeit
-es ist nicht damit getan (zu + Infinitiv);es genügt nicht (zu + Infinitiv);es reicht nicht (aus, zu + Infinitiv)
-genetische Variante;Mutante (Hauptform);Mutant;Mutation;Mutationsprodukt (geh.)
-genetisch verändert;(spontan) mutiert (Adjektiv)
-(partielle) Lichtdurchlässigkeit;Transluzenz
-(jemanden etwas tun) heißen (geh., veraltet);(jemandem etwas) befehlen (Hauptform);(jemandem etwas) gebieten (geh.);(jemanden) anweisen (etwas zu tun);(jemandem) sagen, er soll(e) ... (ugs.)
-oberpeinlich;(jemandem) ausgesprochen unangenehm;megapeinlich (ugs.)
-Marktlagengewinn;Q-Gewinn
-(herum)scheuchen;hin- und herscheuchen;hin- und herschicken;herumkommandieren
-den Chef (he)raushängen lassen (ugs.);auf Chef machen (ugs.);klar machen, wer das Sagen hat (ugs.)
-Monopolalkohol;Monopolsprit
-Akkordblatt;Notenblatt;Leadsheet (engl.)
-Gänsehautmoment (ugs.);große Gefühle;bewegender Moment
-(den / einen) Hut (he)rumgehen lassen (ugs., fig.);Geld (ein)sammeln (für);(eine) Sammlung machen (ugs., variabel)
-Lewat;Reps;Raps
-Kolzaöl;Rüböl;Rübsenöl;Rapsöl;Kohlsaatöl
-pflanzliches Öl;Pflanzenöl
-Spielwiese;Experimentier... (fig.);Übungsfeld
-(ein) Schlaraffenland (für);(ein) Mekka (für) (fig., negativ, variabel);(ein) Eldorado (für) (fig., negativ);(ein) Paradies (für) (fig., negativ);(ein) Dorado (für) (fig., negativ);(ein) El Dorado (für) (fig., negativ)
-(eine) Einladung (für) (fig., negativ);(ein) gedeckter Tisch (für) (fig., negativ);Selbstbedienungsladen (fig., negativ)
-Lagebewusstsein;Situationsbewusstsein
-Hyperwürfel;Maßpolytop
-Hyperoktaeder;Kreuzpolytop
-Wechselbühne;Wandelbühne;Drehbühne
-aus der Leitung fliegen (ugs.);(die) Verbindung wird unterbrochen
-Jumpsuit (engl.);Springerkombi;Springeranzug
-Pinienkern;Pignolie (österr.);Pignole
-Gesellschaftsdame (veraltet);Gesellschafterin (veraltet)
-materiale Äquivalenz;Bisubjunktion;Bikonditional
-inklusives Oder;nicht-ausschließende Disjunktion;Alternative;Adjunktion
-Schlussfolgerungslehre;Denklehre
-Logizismus;Logismus
-Töchterinstitut;Mädchenpensionat;Töchterpensionat
-(eine / die) Laudatio halten (auf) (geh.);(jemanden) laudieren (geh., bildungssprachlich)
-Rettungsassistent;Paramedic;Sanitäter
-Trondheimit (selten);Trondhjemit
-(sehr) kompliziert (zu handhaben, zu bewerkstelligen o.ä.);(es gibt) viel zu beachten;(eine) Wissenschaft für sich (sein) (ugs.);(es gibt) viel zu bedenken
-Staub;Staubpartikel
-Macisblüte;Muskatblüte;Macis;Macis-Blüte;Mazis
-Arillus (fachspr., lat.);Samenmantel
-Mangostanfrucht;Mangostan
-Stereostatik;Starrkörperstatik;Statik starrer Körper;Stereo-Statik
-Mechanik starrer Körper;Stereomechanik
-klassische Mechanik;Newtonsche Mechanik
-Ehrendame;Palastdame;Hofdame
-Sippenforschung (historisch);Sippenkunde (historisch)
-Pescadoren;Pescadores (portugiesisch);Penghu-Inseln (chinesisch)
-Campanile (ital.);Kampanile
-Altermann;Eldermann;Oldermann;Aldermann;Ältermann
-Fuxmajor;Fuchsmajor
-Kontor;Contor
-(etwas) nachplappern;(wortgleich) wiederholen;(jemandem etwas) nachsprechen
-Methenylchlorid;Chloroform (ugs., Hauptform);Chloretherid;Methinchlorid;TCM (Abkürzung);Trichlormethan (fachspr.)
-Blase;abgeschotteter Raum
-Aragon;Aragonien
-Vesicula (fachspr.);Hautbläschen
-Bulla (fachspr., lat.);Hautblase
-entspitzen;pinzieren
-Gemma;Knospe;Auge
-Verlaufsstudie;Longitudinalstudie;Längsschnitterhebung;Längsschnittstudie;Längsschnittuntersuchung
-Querschnittsstudie;Querschnittsanalyse;Querschnittstudie;Querschnittsuntersuchung
-Hiranin;Pantelleria;Cossyra
-Mahnmal der Schande;Schandmal (fig.)
-nachwirken (Hauptform);seinen (/ ihren) Widerhall finden;nachklingen (fig.);widerhallen (fig.);nachhallen (fig.);seinen (/ ihren) Nachhall finden
-Werkzeugstörung;Apraxie
-Sensibilitätsstörung;Missempfindung;Empfindungsstörung;Empfindungsfähigkeitsstörung
-klinisches Zeichen;objektives Symptom
-Olsagebiet;Olsaland
-ideomotorische Apraxie;ideokinetische Apraxie
-Interlinearübersetzung;Interlinearversion
-(etwas) tatenlos mitansehen müssen;nichts tun können (gegen);(einer Sache) hilflos ausgeliefert sein
-Skin (Jargon, engl.);(andere) Oberfläche (ugs.);Design (engl.);(anderes) Erscheinungsbild;Theme (Jargon, engl.)
-superkritisches Wasser;überkritisches Wasser
-Ansicht von oben;Draufsicht
-Gähnaffe;Kienspanhalter;Maulaffe;Affenmaul;Gähnmaul
-bengalisches Feuer;Bengalo;bengalisches Licht;bengalische Flamme
-Seenotfackel;Handfackel
-Kienspan;Kienholz
-Schnuppe;verkohltes Dochtende
-Erlenmeyerkolben;Schüttelkolben
-Lacus Larius (lat.);Lago di Como (ital.);Chumer See (veraltet);Comer See (Hauptform);Comosee (selten);Comersee (schweiz.);Lario (ugs., ital., regional)
-Crux decussata (lat.);Andreaskreuz (Hauptform);Schragenkreuz;Schrägkreuz
-okzitanisches Kreuz;Schlüsselbordkreuz;Tolosanerkreuz (Hauptform);Schlüsselkreuz
-Sonnenrad;Radkreuz;Sonnenkreuz
-Deutsches Kreuz;Wiederkreuz
-Kleeblattkreuz;Brabanterkreuz;Lazaruskreuz;Kleekreuz
-Lateinisches Kreuz (Hauptform);Passionskreuz;Langkreuz
-Versehgarnitur;Versehbesteck
-Jerusalemer Kreuz;Jerusalemkreuz
-Lebensschleife;Henkelkreuz;Nilschlüssel;Anch;Ankh (engl.);koptisches Kreuz;Anch-Symbol;ägyptisches Kreuz;Anch-Kreuz;Crux ansata (lat.)
-Croix de Lorraine (franz.);Croix d'Anjou (franz.);Lothringerkreuz;Lothringer Kreuz
-umgekehrtes Kreuz;Petruskreuz
-Russisches Kreuz;Russisch-Orthodoxes Kreuz
-Jakobskreuz;Santiagokreuz
-Weinrebenkreuz;Kreuz der Heiligen Nino;Georgisches Kreuz
-(der/die) Noch-...;scheidend;zur Ablösung anstehend;noch im Amt
-(das) Aussprechen;Wort (Plural = Worte);Äußerung
-fallen (Wort/e, Ausssage/n, ...);(es) ist die Rede von;ausgesprochen werden;gesagt werden;man spricht von
-Kernfamilie;engster Familienkreis
-Zuteiler;Disponent
-Hinterher ist man immer schlauer. (Gemeinplatz, variabel);Wenn man vom Rathaus kommt, ist man klüger. (sprichwörtlich);nachher alles besser wissen (wollen)
-Dann mach! (ugs.);Worauf wartest du (dann noch)!? (ugs.);Dann aber zügig! (ugs.);Dann los! (ugs.)
-Gericht;Gerichtsgebäude
-Ausnahmegericht;Standgericht
-Missernte;Ernteausfall
-syndizierter Kredit;Metakredit;Konsortialkredit
-Verbraucherdarlehen;Verbraucherkredit
-Kernstrecke;Stammstrecke;Ursprungsstrecke
-Sachsicherheit;Realsicherheit
-Sicherungsabrede;Zweckerklärung;Sicherungsvertrag
-Streckgitter;Streckmetall
-Klarnamenspflicht;Klarnamenszwang
-(nach jemandem) fahnden;(jemanden) polizeilich suchen;(jemanden) zur Fahndung ausschreiben
-bis jetzt bekannte Daten;aktuelle Zahlen;vorliegende Erkenntnisse;(derzeitige) Datenlage;jetziger Informationsstand
-Achtgeben;Achtsamkeit;Wachsamkeit
-(ganz) bestimmt;sicherlich (Hauptform);vermutlich;gewiss;mit ziemlicher Sicherheit;mit einiger Sicherheit (geh.);sicher (ugs.)
-Stelle;Instanz;Gremium;Organ;Stab;Einrichtung
-beiläufig angesprochen (variabel);angedacht;in Betracht gezogen;(mal) überlegt;vage in Aussicht gestellt
-Fehlinvestition;unsinnige Geldausgabe;Schade um das schöne Geld! (ugs., kommentierend);rausgeschmissenes Geld (sein) (ugs.)
-(ein) ruhiges Gewissen haben;gut schlafen können (ugs., fig.);(ein) gutes Gewissen haben
-präsentieren;ausstellen;(der Allgemeinheit) zugänglich machen (variabel);zeigen
-man kann (dort etwas) sehen (ugs.);präsentiert werden;gezeigt werden;zu sehen sein
-erwiesenermaßen gelogen (sein);als Lüge entlarvt werden;sich als Lüge herausstellen
-(noch) nicht abschließend geklärt;(noch) nicht entschieden;auf Wiedervorlage (fachspr.);(noch) in der Diskussion
-Zahltag (fig.);Tag der Abrechnung
-Genugtuung;Satisfaktion;Zufriedenstellung
-Wahl zum Parteivorsitzenden (Hauptform);Krönungsmesse (fig.)
-(für jemanden) übernehmen;(jemanden) ablösen (bei);weitermachen
-(Dienst) tauschen;(Schicht / Dienst) übernehmen
-lasch (ugs., negativ);mild(e);nachgiebig;sanft;locker
-Fußballverein;Fußballclub
-schlecht schlafen (ugs.);(einen) unruhigen Schlaf haben;unruhig schlafen
-kaum in den Schlaf finden;Einschlafstörungen haben (variabel);schlecht einschlafen (ugs.)
-aus dem Schlaf hochschrecken;schweißgebadet aufwachen (floskelhaft)
-optimal passend;maßgeschneidert (fig.)
-(innerlich) Abstand halten;(sich) emotional nicht vereinnahmen lassen (von);(die) emotionale Distanz wahren;(innerlich) auf Distanz bleiben
-um dieselbe Zeit;ungefähr gleichzeitig (variabel)
-im selben Moment;im gleichen Augenblick;genau da (ugs.);in demselben Moment;in diesem Moment;just in diesem Augenblick (/ Moment);ausgerechnet da (ugs.);im gleichen Moment;im selben Augenblick;in diesem Augenblick;in dem gleichen Augenblick;in demselben Augenblick
-Gefälligkeit (verhüllend);Freundschaftsdienst (verhüllend)
-Entmarkung;Demyelinisation
-in seiner Sammlung haben;(etwas) im Angebot haben;dienen können (mit) (geh.);zu jemandes Repertoire gehören;im Repertoire haben
-Vaterpflichten;Unterhaltspflichten
-(das) kommt gar nicht in Frage!;so weit kommt's noch! (ugs.);das wär(e) ja noch schöner (, wenn / dass ...)! (ugs., ironisch);das fehlte noch (, dass ...);(das) kommt überhaupt nicht in Frage! (Hauptform)
-(sich) insgeheim freuen;(sich) nach innen freuen (ironisch);(sich seine) Freude nicht anmerken lassen;(seine) Freude nicht zeigen
-keine Miene verziehen;keine Regung zeigen;keine Emotionen zeigen;(jemandem) nicht anzusehen sein (, was in ihm vorgeht)
-mit deutlichem Abstand;mit deutlichem Vorsprung;haushoch (siegen)
-überrennen;überrollen
-(sich) gut schlagen (bei) (ugs., fig.);beim Test gut abschneiden;(den) Test mit Erfolg meistern (variabel);(die) Probe bestehen;(sich) im Test bewähren;(beim Probelauf / in der Erprobung o.ä.) überzeugen
-Positionspapier;schriftliche Stellungnahme;Eckpunktepapier;Grundsatzpapier
-Entwurf (Arbeitspapier);Vorlage
-Kompilation (fachspr.);Musikzusammenstellung;Sammelalbum;Sampler;Sammel-CD
-Totalstation;Tachymeter
-Diskussion über eine Neuausrichtung;Strategiediedebatte;Diskussion über den künftigen Kurs
-außer Landes;ins Ausland
-außerhalb (ugs.);nicht bei uns;nicht hier;auswärtig;auswärts
-nicht weglaufen!;hiergeblieben!;(jetzt) bleib mal schön hier! (ugs.);schön hierbleiben!
-Halli-Galli (Halli Galli, Halligalli, Hully Gally) (ugs.);High Life (Highlife);(es ist) schwer was los (ugs.);Partystimmung;es geht hoch her;Rambazamba (Ramba-Zamba) (ugs.)
-Rücken;(die) Hucke (ugs., regional);Rückenpartie
-rückseitige Partie;Rückenpartie;Rücken (Kleidung)
-sonnenabgewandte Seite;Nachtseite (Planet)
-sonnenzugewandte Seite;Tagseite (Planet)
-Männlichkeitsprotz;Mannsprotz
-(ein) Casanova (fig.);Gigolo;Latin Lover;Papagallo
-Glückssträhne;(auf der) Siegerstraße;(eine) Serie von Erfolgen (variabel);Gewinnerserie;Erfolgsserie
-im hohen Alter;im biblischen Alter von;im gesegneten Alter von;in hohem Alter;im ehrwürdigen Alter von;im Greisenalter
-Witmann (veraltet);Witwer (Hauptform);Wittiber (bayr., österr.)
-Witwe (Hauptform);Witfrau (veraltet);Wittib (bayr., österr.)
-Willibecher (fachspr.);Standard-Bierglas;Standardglas
-Eichstrich;Füllstrich
-allgemein übliche Bezeichnung;Verkehrsbezeichnung (Amtsdeutsch);amtliche Bezeichnung (eines Lebensmittels);gesetzlich vorgeschriebene Bezeichnung
-Herzinnenhaut;Endokard
-Atherosklerose;Arteriosklerose
-(jemandem) Grüße bestellen (von);- schönen Gruß übrigens (von ...) - (ugs.);(jemanden) grüßen (von) (ugs., Hauptform);(jemandem) Grüße überbringen;(jemandem) einen schönen Gruß bestellen (von) (ugs.);Grüße übermitteln;(jemandem) Grüße ausrichten (von)
-(jemanden) einbeziehen;(jemanden) akzeptieren;(jemanden) integrieren
-Popularität;(die) öffentliche Aufmerksamkeit (genießen);Bekanntheitsgrad;Bekanntheit
-das Nötigste entbehren;es fehlt am Notwendigsten;es fehlt an allem
-in der Filmbranche;beim Film;im Filmgeschäft
-Urgewalt;Naturgewalt(en);Kraft der Elemente;elementare Gewalt;Elementargewalt
-manipulierbar;leicht zu beeinflussen;suggestibel (geh.);beeinflussbar
-Namedropping (Neologismus, engl.);Namen beiläufig erwähnen;mit (prominenten) Namen um sich werfen
-Fachartikel;Fachaufsatz;Veröffentlichung in einem Fachmagazin
-Nationalliberalismus;Rechtsliberalismus
-überraschend schnell;unverhofft schnell;ungewöhnlich schnell;erstaunlich schnell;unerwartet schnell
-zeitökonomisch;Zeit sparend;zeiteffizient;ohne Zeitverlust;ohne Zeitverschwendung;zeitsparend;in möglichst kurzer Zeit
-Setzung;Axiom;Dogma;Prinzip
-da kommt noch was (ugs.);es kommt noch etwas;(das ist / war) noch nicht alles
-mit Scheuklappen herumlaufen (fig.);(ideologische) Scheuklappen tragen (fig.);mit Scheuklappen durch die Welt laufen (fig.);Scheuklappen aufhaben (ugs., fig.)
-(einem Gedankengang) nachgehen;(Gedankengang) nachzeichnen;(Gedankengang) darstellen;(Gedankengang) verfolgen
-(etwas) nicht sehen wollen;(etwas) ausblenden;(einen) Tunnelblick haben (fig.)
-Tunnelblick (auch figurativ);eingeengtes Blickfeld;eingeschränktes Sehfeld;eingeschränktes Gesichtsfeld
-Basisrente;Rürup-Rente (ugs.)
-halbgar (fig.);krude (fig.);unausgegoren
-Konversionsrate;Umwandlungsrate;Konvertierungsrate
-pseudointellektuell;schwurbelig;schwafelig;pseudo-wissenschaftlich
-(die Leute) mitnehmen;(auf jemanden) eingehen;(die Leute) abholen, wo sie stehen;nicht überfordern
-auf Freiwilligkeit setzen;auf Einsicht (in das Notwendige) setzen
-(jemanden) mit Samthandschuhen anfassen (fig.);(jemandem) jede Zumutung ersparen;(jemandem) nichts zumuten
-Sagt wer? (ugs.);wie kommst du darauf?;woher willst du das wissen?;wer sagt das?
-Xucker (Handelsname);Erythrit;meso-1,2,3,4-Butantetrol (fachspr.);Sukrin (Handelsname);Serapur (Handelsname);E 968 (fachspr., E-Nummer);Erythritol (engl.);i-Erythritol;Sera (Handelsname);Sucolin (Handelsname)
-ausgleichen;neutralisieren;glattstellen (fachspr., kaufmännisch);für Deckung sorgen
-Potpourri (franz.);Medley (engl.)
-(ein Angebot) in die Fläche bringen;(etwas) breitflächig einführen;(in der Fläche) ausrollen (fachspr., Jargon, Marketing, Neologismus);(mit einem Angebot) in die Fläche gehen
-(jemanden) in der Pflicht sehen (zu) (mediensprachlich, politisch);denken, es sei jemandes Aufgabe (zu + Infinitiv) (weibl.)
-Brechbolzen;Scherbolzen (Kurzform);Abscherbolzen
-Sprengbolzen;Pyrobolzen
-Klobenverbinder;Quergewindekolben;Quermutterbolzen;Verbindungskloben;Rundmutter
-Drehkranz;Drehwerk
-Abscherstift;Scherstift
-Distanzbolzen;Abstandsbolzen
-Augenstabsystem;Zugstabsystem
-Rillenmanschette;Schliffmanschette
-Schliffhülse;Griffbund-Hülse
-Rohrverbindungselement;Rohrverbinder (Kurzform)
-Rohrverbindung;Rohrleitungsverbindung
-was machen lassen (ugs., verhüllend);(sich) verschönern lassen;(sich) einer kosmetischen Operation unterziehen;(sich) (kosmetisch) operieren lassen
-Ehrlich?;Stimmt das (auch) wirklich?;Ernsthaft? (ugs.);Wirklich?;Echt? (ugs.);(Ist das) wirklich wahr? (Hauptform)
-(jemandes) Herz zieht sich zusammen (fig.);(jemandem einen) Stich ins Herz geben (fig.);sehr verletzend sein (für)
-Tremazeichen;Trema (Kurzform)
-Brückentechnologie (fig.);Übergangstechnologie
-bürokratisch;beamtenhaft (fig.);unpersönlich;formalistisch
-zermahlen werden (von / in den Mühlen der ...);zerrieben werden (zwischen / von / durch) (fig.)
-Hauptüberschrift;Oberthema
-Unterthema;Zwischenüberschrift
-Unterkapitel;Unterabschnitt
-Textstelle;Stelle
-Seitenangabe;Seitennennung
-Erreichbarkeit (mit Verkehrsmitteln);Verkehrsanbindung
-Wegenetz;Straßennetz
-Aufschließung (fachspr., veraltend);Anschluss (an);Erschließung;Anbindung (an technische und soziale Infrastruktur)
-Chevron(s) (fachspr., franz.);Spitzzeichen;französische(s) Anführungszeichen;Guillemet(s) (fachspr., franz.)
-Aktenhaltung;Aktenführung;Schriftgutverwaltung
-Unternehmergeist;Gründerszene;Gründerkultur;Unternehmertum;Gründertum
-Körperlotion;Bodymilk;Bodylotion;Körpermilch
-Hautpflegemittel;Hautpflegeprodukt
-Produktingenieur;Produktentwickler
-plastisch (fachspr.);nachgebend;streichfähig (Butter) (fachspr.);formbar;nachgiebig;weich (Hauptform)
-butterweich;cremig weich
-gummielastisch (fachspr.);elastisch;gummiweich (Hauptform)
-klätschig (ugs., regional);noch nicht richtig durch (ugs.);(innen noch) feucht;kletschig (regional);(noch) teigig;klitschig (Gebäck) (ugs., Hauptform);nicht (richtig) durchgebacken
-verbiegbar;biegsam;elastisch;flexibel;verformbar
-dehnbar;elastisch;spannbar;streckbar
-um ... herum;umliegend;in der Umgebung (von)
-neben;(dicht) an;bei;nahe;unweit
-Mutter-Kind-Hormon (ugs.);Ocytocin;Kuschelhormon (ugs.);Oxitozin;Bindungshormon (ugs.);Oxytocin
-unfern (des / der ,,,) (geh.);nicht weit von;in Nähe (des / der ...);unweit (des / der / von);in der Nähe (des / der / von)
-unmittelbar neben;gleich neben;direkt neben
-Proteste;Demonstrationen;Druck der Straße (fig.)
-hart (/ haarscharf / dicht) an der Grenze (zu / des / der) (fig.);(die Grenze zu ...) streifen (fig.);vorbeischrammen (an) (fig., salopp)
-nicht mehr weit (bis);nah(e) (zeitlich);nicht mehr weit hin (bis);nicht mehr lange dauern
-Außenverpackung;zusätzliche Verpackung;Umverpackung (fachspr., Hauptform)
-(in etwas) enthaltene (Ware);Inhalt (Art) (Hauptform);Füllgut (fachspr.);(in etwas) enthaltenes (Gut)
-Einwaage (z.B. Konservendose);enthaltene Menge;Inhalt (Menge) (Hauptform)
-drin sein;darin sein;enthalten (räumlich) (Hauptform);gefüllt sein (mit);in etwas sein (/ liegen / stehen / aufgehängt sein);beinhalten
-schwitzen wie ein Schwein (ugs.);der Schweiß läuft (/ rinnt / fließt) jemandem in Strömen (...);stark schwitzen;(an jemandem) läuft die Suppe (nur so ...) runter (derb, variabel);Bäche von Schweiß (laufen / strömen / rinnen jemandem ...) (geh.);aus allen Poren schwitzen
-Barhocker;Barsitz;Barstuhl
-Nachrichtenquadrat;Kommunikationsquadrat;Vier-Seiten-Modell;Vier-Ohren-Modell
-Kommunikationsmodell;Kommunikationstheorie
-freibekommen (ugs.);(eine Straße o.ä.) räumen (Schnee, Geröll);freiräumen
-Räumfahrzeug;Schneepflug
-unzuverlässig;unpräzise;(zu) große Fehlertoleranz (fachspr.);inexakt (fachspr.);inkorrekt (fachspr.);ungenau (Messwert, Wert, Messung) (Hauptform)
-unlogisch;außerhalb des Erwartungshorizonts (fachspr.);unplausibel;nicht einleuchten(d)
-am rechten Rand fischen (fig.);bei der AfD auf Stimmenfang gehen;Wähler von der AfD abwerben (wollen);der AfD Wähler abspenstig machen (wollen);(sich) bei (den Wählern) der AfD bedienen
-wie (es) unter Kollegen üblich (ist);kollegialerweise;kollegialiter (geh., bildungssprachlich);aus kollegialen Gründen
-freundschaftlicherweise;aus (reiner) Freundschaft
-Lehr- und Versuchsanstalt;Versuchsanstalt
-(Werk-) Reihe (Hauptform);...zyklus;...reigen;...reihe;(ein) Reigen (von) (geh., Hauptform);Zyklus (geh., Hauptform)
-Kreislauf (fig.);Zyklus
-Umlauf;Kreislauf;Zirkulation
-Strohmann-Trugschluss;Strohmann-Argument
-partiarisches Darlehen;Beteiligungsdarlehen
-Eiergraupen (Plural);Eiergerstl
-Simplex (fachspr.);nicht-zusammengesetztes Wort
-querlüften;Durchzug herstellen;für Durchzug sorgen
-Be- und Entlüftung;Luftwechsel;Luftaustausch;Luftdurchsatz
-(die) Fenster auf Kipp stellen;spaltlüften (fachspr.);kipplüften (fachspr.)
-(die) Fenster (kurzzeitig) weit öffnen;(die) Fenster für eine begrenzte Zeit ganz öffnen;(die) Fenster kurz weit aufmachen (ugs.);stoßlüften (fachspr., Hauptform)
-so läuft das nicht (hier)!;so haben wir nicht gewettet! (ugs., Hauptform);so geht das (aber) nicht!;so war das (aber) nicht vereinbart!
-Eigentum der öffentlichen Hand;Gemeineigentum (fachspr., juristisch);öffentliches Eigentum
-in städtischem Besitz;städtisches Eigentum;kommunales Eigentum;in kommunalem Besitz
-viele Tausend;Tausende von;tausende;mehrere tausend;mehrere Tausend;Tausende;tausende von;viele tausend
-(mit Flatterband) absperren;abflattern (fachspr., Jargon)
-(elektronischer) Bezahlservice;Online-Bezahlsystem;(elektronischer) Bezahldienst;(elektronisches) Bezahlsystem;Online-Bezahldienst;Online-Bezahlservice
-Bezahldienstleister;Bezahldienst-Unternehmen
-(reine) Pflichtübung;muss (halt) gemacht werden (ugs.)
-(heftiger) Wintereinbruch;Schneekatastrophe (mediensprachlich);Starkschneeereignis (fachspr., Amtsdeutsch, Jargon)
-(jemanden / etwas) wörtlich nehmen;(darauf) bestehen, was jemand zugesagt hat;(jemanden) beim Wort nehmen
-Rassenideologie;Rassendiskriminierung;Rassendoktrin;Rassismus
-Kaktusgewächse;Kaktazeen (Pluraletantum)
-Krampfgift;Konvulsivum (fachspr.)
-Titelfolge;Playlist;Spielliste;Abspielliste
-Streamingdienst;Streaminganbieter;Streamingunternehmen
-(jemandes) Flamme (ugs.);(jemandes) Liebste;Dame seines Herzens;(jemandes) Auserwählte (Hauptform);(jemandes) Herzdame;(jemandes) Herzensdame;(jemandes) Angebetete
-Neubelgien-Herbstaster;Glattblatt-Aster;Neubelgische Aster
-Hüllblatt;Involucralblatt
-Leberblümchen (Kurzform);Dreilappiges Leberblümchen;Gewöhnliches Leberblümchen
-Kuhschelle;Küchenschelle
-Alpen-Kuhschelle;Alpen-Küchenschelle;Alpen-Anemone
-Gelbe Alpen-Küchenschelle;Gelbe Alpen-Kuhschelle;Schwefel-Anemone
-Stern-Kuhschelle;Finger-Kuhschelle
-Frühlings-Kuhschelle;Frühlings-Küchenschelle;Frühlings-Anemone
-Groß-Küchenschelle;Große Küchenschelle;Große Kuhschelle
-Hallers Küchenschelle;Hallers Kuhschelle
-Adula-Alpen;Westbündner und Misoxer Alpen
-Rote Küchenschelle;Rote Kuhschelle
-Berg-Küchenschelle;Berg-Kuhschelle
-Schwarz-Küchenschelle;Wiesen-Kuhschelle;Wiesen-Küchenschelle
-Strand-Grasnelke;Gewöhnliche Grasnelke
-Meerlavendel;Strandflieder;Widerstoss
-für ein Ziel arbeiten;auf etwas hinwirken (geh., Hauptform);alles tun, um zu;auf etwas hinarbeiten (Hauptform)
-die Absicht haben (zu);tun wollen;(etwas) beabsichtigen;zu tun gedenken;intendieren;gewillt sein (zu);die Absicht hegen (zu) (geh.)
-zum Herrenvolk gehören(d) (NS-Jargon, Tabuwort);Herrenmensch (NS-Jargon, Hauptform);Angehöriger der Herrenrasse (NS-Jargon, Tabuwort)
-Hypothyreoidismus;Hypothyreose
-angeborenes Jodmangelsyndrom;Kretinismus
-Jodmangel;Iodmangel
-Differentialdiagnose;Differenzialdiagnose
-Eheverbot;Heiratsverbot (ugs.)
-Wartepflicht;Trauerjahr;Wartezeit
-Sterbequartal;Sterbeüberbrückungszeit;Sterbevierteljahr
-krasse Bitch (ugs., weibl.);krasser Typ (ugs.);ausgekochtes Schlitzohr (ugs.);A Hund is a scho. (ugs., Spruch, bairisch);coole Socke (ugs.);coole Sau (derb)
-Übersäuerung des Pansens;Pansenazidose
-Gebärparese;Milchfieber;Kalbefieber
-Brusternährung;Stillen
-Hypocalcämie;Hypocalciämie;Hypokalzämie (Hauptform);Hypokalziämie
-Hyperkalzämie;Hypercalcämie
-E 605 (fachspr.);Thiophos;Parathion (Hauptform);Schwiegermuttergift (volksmundlich)
-Medizinische Statistik;Biostatistik
-Vertragsarzt;Kassenarzt
-Kassenzahnarzt;Vertragszahnarzt
-Vertragspsychotherapeut;Kassenpsychotherapeut
-Aktivlabor;Heißlabor
-Radionuklidlaboratorium;Radionuklidlabor
-...freak (engl.);Geek (engl.);Nerd (...nerd) (engl.);Fachidiot;Fachtrottel (österr.)
-(jemand) spricht von nichts anderem (als);(jemand) hat nur ein Thema;(jemand) kennt nur ein Thema
-keinen (übergreifenden) Zusammenhang erkennen;den Wald vor lauter Bäumen nicht sehen (fig.);das große Ganze nicht sehen
-Tunnelblick (ugs., fig.);verengte Perspektive;eingeengte Sichtweise
-auf Eis liegen (fig.);ausgesetzt (worden) sein;unterbrochen (worden) sein;auf Eis gelegt sein (fig.)
-nicht weiter vorantreiben;(derzeit) nicht weiterverfolgen
-ruhen (Arbeiten);vorübergehend eingestellt (worden) sein
-(die) Arbeit(en) einstellen;aufhören zu arbeiten
-jemand Unbekanntes;(ein) neues Gesicht (fig.);jemand Neues
-jemand Bekanntes;ein Bekannter;(ein) bekanntes Gesicht (fig.)
-kampferprobt (Hauptform);kampferfahren;gestählt (geh., fig.);gut gerüstet (für);durch eine harte Schule gegangen (ugs., fig.)
-wir warten (sehnlichst) auf ...!;wo bleibt ...? (ungeduldig) (ugs., Hauptform);ich warte auf ...!;wir vermissen ... schmerzlich! (geh., ironisierend);wie lange soll ich (denn) *noch* warten!? (fordernd) (ugs.);wann kommen (endlich) (die versprochenen) ,,,!?;wie lange müssen wir denn *noch* warten!? (fordernd, rhetorisch) (ugs.);wann kommt (endlich) ...?
-Permeanz (fachspr.);magnetischer Leitwert
-Thiopental-Natrium;Natriumthiopental;Thiopental
-Paramnesie (fachspr., griechisch);Gedächtnistäuschung;Gedächtnisstörung
-Gegend;Landschaft;Landstrich;Land;Kante (ugs.);Gebiet;Ecke (ugs.)
-Landschafts- und Vegetationstyp;Landschaftstyp;Landschaftsform
-Wüste (Hauptform);Wüstenlandschaft;Wüstengebiet;Wüstenregien;Wüstenei (geh., veraltet)
-Wüstenname;Wüstenbezeichnung
-urbanes Umfeld;städtisches Milieu
-gilt weiterhin;steht noch (Angebot) (ugs.)
-laufen (im / auf);zeigen;senden;übertragen;ausstrahlen [Fernseh-/Radiosendung];bringen;kommen (im / auf) (ugs.)
-Weideland;von Weidewirtschaft geprägt
-Ackerland;Bauernland (ugs.);landwirtschaftlich geprägt;agrarisch geprägt;Agrarland
-agrarisch genutzt;Kulturfläche(n);landwirtschaftlich genutzt;Kulturland;Kulturlandschaft
-bewirtschaftet;bebaut;unter Kultur stehen(d)
-unbewaldet;baumfrei;baumlos
-(es gibt nur) einzelne Bäume;baumarm;mehr oder weniger baumlos
-Obstbauer;Obstproduzent;Obstgärtner;Obsterzeuger
-fernab (des / der ...);weit weg (von);weitab (von);weit entfernt (von)
-Transphobie;Transfeindlichkeit
-(ganz) grün im Gesicht werden;grün anlaufen
-Helau! (ugs., Hauptform);Alaaf! (ugs., Hauptform, kölsch);diverse (fachspr.)
-Karnevalsgruß;Narrenruf
-Standesgruß;Zunftgruß
-Brownfield (engl.);Industriebrache (Hauptform)
-Brache;ungenutztes Grundstück
-ohne Befund (Jargon);negativ (sein) (ugs.);ohne Auffälligkeiten (Jargon)
-aufpassen, dass keine Kratzer (/ Macken / ...) an etwas kommen (ugs.);sehr sorgsam behandeln (Hauptform);wie seinen Augapfel hüten;hegen und pflegen;sehr achtgeben (auf)
-Protoindustralisierung;Protoindustrie;Proto-Industrialisierung
-Bergwerksregal;Bergregal
-(sich) viel vorgenommen haben;Großes vorhaben;zum großen Schlag ausholen (fig.);einiges vorhaben (ugs.);große Pläne haben
-...fresser;...hasser;(ein) glühender Anti...;erklärter Feind (des / der)
-(einen) Vernichtungsfeldzug führen (gegen);(einen) Kreuzzug führen (gegen)
-zutiefst verachten;aus tiefster Seele hassen
-Strom haben (ugs.);mit Strom versorgt werden;am Netz sein (Strom) (Jargon);am Stromnetz angeschlossen sein
-...situation;...lage;...geschehen
-nur damit Sie es wissen;nur dass du's weißt;(nur) zu deiner Information;(nur) zu Ihrer Information;damit wir uns nicht falsch verstehen
-nach unten bekommen (Zahlen, Werte);runterprügeln (ugs., salopp);nach unten kriegen (ugs.);runterdrücken;runterknüppeln (ugs., salopp)
-hyperbolische Paraboloidschale;HP-Schale;Hyparschale
-Landpartie;Ausflug aufs Land
-Tanksäule;Zapfsäule
-US-Machtzentrale (ugs.);Weißes Haus
-Legostein;Spielstein
-Gemäuer;(alte gemauerte) Wand
-...klimpern (Tasteninstrument);dilettieren (geh.);(stümperhaft / lieblos) spielen
-Allerseelenkuchen;Allerseelenbrot;Allerseelengebäck
-wüchsig (fachspr., Jargon);wuchsfreudig;kräftig wachsend
-Traglufthalle;Pneu
-(etwas) mit der Muttermilch aufgesogen haben (fig., variabel);von klein auf gelernt haben;von klein auf beigebracht bekommen haben
-(etwas) gar nicht anders kennen;(für jemanden) selbstverständlich sein;(für jemanden) ganz natürlich sein
-Artikulationsorgan (fachspr.);Sprechwerkzeuge;Organ(e) der Lautbildung (fachspr.);Artikulationsapparat
-Virenexpertin (weibl.);Virenexperte (männl.);Virologe (fachspr., männl.);Virologin (fachspr., weibl.)
-ungewiss;unkalkulierbar;nicht vorauszusehen;nicht vorhersehbar;unvorhersehbar;(im Vorhinein) nicht einzuschätzen;unsicher;offen
-Sedentarismus (fachspr.);Bewegungsmangel
-körperliche Aktivität;körperliche Betätigung
-Kugel (derb);Schwangerschaftsbauch (Hauptform);Babybauch
-Fraß;Schadeinwirkung;chemische Einwirkung
-zwischen Angst und Zuversicht;zwischen Hoffen und Bangen
-Fleckerlteppich (ugs., fig., süddt., österr.);Flickenteppich (ugs., fig.);Flickarbeit;Flickwerk
-Abtritt (veraltet);Abtreten
-Schonung (Hauptform);Hegewald (selten, veraltet)
-Baumschule;Gehölzproduzent
-aufschulen (fachspr., Hauptform);heranziehen (Gehölze)
-tanzen (Mücken);schwirren;schwärmen
-n den Blickpunkt der Öffentlichkeit rücken;in den Blickpunkt der öffentlichen Aufmerksamkeit geraten;die Medien interessieren sich (für);die Öffentlichkeit wurde aufmerksam (auf)
-(eine ...) Dynamik entwickeln;Dynamik entfalten;(sich) beleben (Wirtschaft, Konjunktur);in Schwung kommen
-dahinplätschern;(vor sich hin)dümpeln
-akzessorisch;nachstehend;hinzutretend;hinzukommend;nebensächlich
-Schein...;Pseudo...
-(der/die/das) echte;(der/die/das) wirkliche;(der/die/das) wahre;(der/die/das) eigentliche;(der/die/das) richtige
-es herrschen rechtlose Zustände;Bananenrepublik
-Operettendemokratie;Operettenstaat
-Musikfilm;Musical
-Backwood(s)-Film (fachspr.);Hinterwäldler-Film (fachspr.);Hixploitation-Film (fachspr.)
-in jemandes Hände geraten;in jemandes Gewalt geraten
-Umgang pflegen (mit);umgeben sein (von);(jemanden) umgeben;(jemandes) Umfeld bilden (fachspr.);verkehren (mit jemandem);Umgang haben (mit);(sich) umgeben (mit);verkehren (in ... Kreisen, in ... Milieu)
-Schienentraktor;Bautraktor
-Man kann es auch übertreiben. (ugs., Spruch);(etwas) nicht so eng sehen sollen (ugs.)
-schlechte Beliebtheitswerte;mangelnde Akzeptanz;Imageproblem
-auf Ablehnung stoßen;nicht gut ankommen (bei);abgelehnt werden;wenig Anklang finden;(etwas) haben (gegen) (ugs.);(etwas) ablehnen
-(nur) um den anderen zu ärgern (ugs.);aus (reiner) Boshaftigkeit;aus Lust an der Provokation;(nur) um andere zu ärgern (ugs.);aus Nickeligkeit (ugs.)
-Übergangsrelation;Transitionsrelation
-Tagespresse;Tageszeitungen;Tagesnachrichten
-(etwas) kritisch sehen;(sich) reserviert verhalten (gegenüber);(sich) zögerlich verhalten (bei / angesichts);Vorbehalte haben (gegen);nicht auf uneingeschränkte Zustimmung stoßen
-Kommissar Zufall (scherzhaft-ironisch);(eine) wundersame Fügung (Hauptform);Deus ex machina (geh., bildungssprachlich)
-Kadettenschüler;Kadett
-Liste von Schlüssel-Wert-Paaren;Zuordnungstabelle;assoziatives Datenfeld
-Linkseindeutigkeit;Injektivität
-Pilonidalzyste;Steißbeinfistel;Sinus pilonidalis (fachspr., lat.);Sakraldermoid
-Vokalharmonie;Synharmonismus
-Eigenleitung(en);Muskelhypothek (fig.);Eigenbeitrag
-Match (IT-Technik);Treffer (IT-Technik)
-Geruchssinn;Spürsinn (Hund)
-Abriegelung;Schließe;Schließvorrichtung;Schloss;Riegel;Verriegelung
-(jemandes) Erkennungszeichen;(jemandes) Markenzeichen (fig., scherzhaft-ironisch);Charakteristikum (geh.);(typisches) Merkmal
-Eigenheit(en) in der Aussprache;Schibboleth;Ausspracheeigentümlichkeit(en)
-Entdeckerlust;Spürsinn
-Spürnase (fig.);Trüffelschwein (fig.)
-(ein) Gamechanger (sein) (engl., fig.);Dadurch ändert sich alles. (ugs., floskelhaft);(die) Spielregeln ändern sich (fig.);Das ändert alles. (ugs., floskelhaft)
-(sich) vor (völlig) neue Herausforderungen gestellt sehen;(eine völlig) neue Ausgangssituation (haben);(eine völlig) veränderte Ausgangslage (vorfinden)
-(sich) auf die neue (/veränderte) Situation einstellen (müssen);umplanen (müssen);(etwas) neu denken (müssen) (Modewort);neu nachdenken (müssen) (floskelhaft);neue (/angepasste) Lösungen entwickeln (müssen)
-Symptom (für);Zeiger (von) (fachspr., botanisch);Erkennungszeichen (von);Anzeichen (für)
-Holzgerechtsame;Holzgerechtigkeit;Holzungsgerechtigkeit;Beholzigungsrecht
-(die) Grundbegriffe (eines Fachgebiets) (Hauptform);(die) Grundlagen;(der) Grundstock;(die) Anfangsgründe (veraltet)
-Recht am (eigenen) geistigen Eigentum;Urheberrechtsschutz;urheberrechtlicher Schutz;Urheberrecht
-Copyright-Vermerk;Hinweis auf (bestehenden) Urheberrechtsschutz
-(die) Rechte haben (an);das Copyright haben (ugs., Hauptform);Rechteinhaber sein (fachspr., juristisch);die Verwertungsrechte (an etwas) haben
-Schrittmaßformel (selten);Schrittmaßregel
-Druckentlastungsklappe;Explosionsklappe
-mit deutschen Vorfahren;biodeutsch;deutschstämmig
-primitiv;schlichtest;grobgezimmert;einfachst;kunstlos
-vom Pech verfolgt;(viel) Kummer gewohnt;vom Schicksal geschlagen;leidgeprüft
-kein Stein bleibt auf dem anderen (fig.);Stätte der Verwüstung;Schuttfeld;Ansammlung von Schutthaufen;(ein) Bild der Verwüstung bieten;Trümmerfeld (Hauptform)
-schnell aufgebaut;schnell angelegt;eilig errichtet
-Behelfsbrücke;Notbrücke;provisorische Brücke
-bar jeder Realität;außerhalb der Realität;Wo leben Sie denn!? (ugs., ironisch, kommentierend);völlig abgehoben;vollkommen lebensfremd;jeden Kontakt zur Realität verloren haben(d);fernab jeder Realität
-Durchgangsarzt;D-Arzt
-GUV (Abkürzung);Gesetzliche Unfallversicherung
-heilbehandlungsbeteiligter Arzt;H-Arzt
-Gravelbike (engl.);Querfeldeinrad
-Hornlenker;Rennradlenker;Bügellenker
-Speicherriegel;Speichermodul
-wenn Sie das sagen ...;wenn Sie meinen ...;wenn du meinst ...;wenn du das sagst ...;Dein Wort in Gottes Ohr! (ugs., sprichwörtlich)
-stimmt (auf den Cent) genau!;stimmt auffallend! (floskelhaft, ironisierend)
-weiter!;mach weiter!;weiter geht's!;weiter im Text! (fig.);nur weiter!
-Was haben wir dann?;Was kommt jetzt?;Was kommt dann?
-Nettovermögen;Reinvermögen
-großes juristisches Staatsexamen;Assessorexamen;zweites juristisches Staatsexamen
-Sachvermögen;Realvermögen
-Sachkapital;Realkapital
-Europäische Währungseinheit;ECU (Abkürzung, engl.);EWE (Abkürzung)
-Währungssymbol;Währungszeichen
-Wärmetransport;Wärmeübertragung
-Wärmestrom;Wärmefluss
-Konvektion;Wärmeströmung
-Differential-algebraische Gleichung;Algebro-Differentialgleichung;differentiell-algebraische Gleichung
-hydraulische Analogie;elektro-hydraulische Analogie
-Gravitationsfeld;Schwerkraftfeld
-Durchflussrate;Volumenstrom;Durchflussmenge
-Flugfeldüberwachungsradar;Bodenradar
-einen Arzt zu Rate ziehen;einen Arzt aufsuchen;den Arzt fragen (ugs.);sich an seinen Arzt wenden;ärztlichen Rat einholen (Papierdeutsch)
-Dioptrik;Anaklastik (veraltet)
-vorkochen;für mehrere Tage im Voraus kochen
-lebenslang halten;ein Leben lang halten
-herrschende Lehre (Jura);unter Fachleuten Konsens;Stand der Wissenschaft;Stand der Forschung;Lehrmeinung
-Kolostrum;Vormilch;Erstmilch;Kolostralmilch
-Beestmilch;Brieschmilch (schweiz.);Biestmilch;Biest
-einander in herzlicher Abneigung verbunden (sein) (geh., ironisch);sich eigentlich nicht mögen;nicht (gut) miteinander können (ugs.)
-Leerdenker (ugs., abwertend);Verquerdenker (ugs., abwertend);Quarkdenker (ugs., abwertend);Querdenker (in Sachen Corona) (Hauptform)
-Ordnungssystem;Klassifizierungssystem;Systematik;Klassifikationssystem
-(etwas) schaffen;(etwas) reißen (ugs.);(etwas) bewegen;(etwas) bewirken (können) (Hauptform)
-Leichenfledderer (auch figurativ);Aasgeier (ugs., fig.)
-Mörser (Hauptform);Reibschale;Fantaschale (fachspr., pharmazeutisch)
-Kreide;Schulkreide;Tafelkreide (Hauptform);Schreibkreide
-Talkerde;gebranntes Magnesia;Magnesia;Bittererde (veraltet);MgO (chemisch);Sintermagnesia;E 530 (chemisch);Magnesia usta;Schmelzmagnesia;Magnesiumoxid (fachspr., Hauptform);Bittersalzerde (veraltet)
-Magnesit;Magnesiumcarbonat (fachspr.);Bitterspat
-nachbearbeiten (Bildbearbeitung) (Hauptform);nachbessern;photoshoppen (Jargon);aufhübschen
-für (ein Datum) angesetzt;für (ein Datum) geplant;für (ein Datum) vorgesehen;soll(te) stattfinden (am ...)
-wieder bei ... anfangen (müssen / können) (ugs.);jemanden (um ...) zurückwerfen
-Kurzversion eines Berichts;Kurzbericht;zusammenfassender Bericht;kurzer Bericht;Zusammenfassung eines Berichts
-Kanalprotein;Tunnelprotein
-Klassenschiff;Leitschiff;Typschiff
-aufgerafft;hochgestemmt;hochgequält;aufgerappelt
-ärschlings (derb);arschlängs (derb, österr.);mit dem Hintern voran
-Konterbier (ugs.);Stützbier (ugs.);Katerbier (ugs.);(das) Bier danach (ugs.)
-Blaschwafeln (ugs.);leeres Geschwätz (ugs.);Worthülserei
-Hochstapler-Syndrom;Impostor-Syndrom (engl.)
-Wähler;Teilnehmer an der Wahl
-sprachliches Imponiergehabe (Hauptform);Wortgeklingel;Wortgetöse
-(sich) eignen (zu / für);einen guten (eine gute / ein gutes) ... hergeben;geeignet (zu / für);...tauglich
-Probierbrille;Messbrille;Probiergestell;Vorsteckbrille
-Emmetropie (fachspr., griechisch);Normalsichtigkeit
-Fehlsichtigkeit;Ametropie
-ziemlich viel (Hauptform);nicht gerade wenig;so einiges an;und das nicht zu knapp (nachgestellt) (ugs.)
-Anklicken (einer 'Internetseite') (ugs.);Seitenaufruf
-Sympathiezauber;Analogiezauber;Sympathetische Magie
-die Reste seiner Würde zusammenraffen (und ...) (geh., fig., literarisch, selten);(sich) auf seine Stärke besinnen;Krönchen richten (und weitergehen) (ugs., Spruch, fig., Hauptform, variabel)
-Münzgeselle;Münzohm
-risikolos (Hauptform);problemlos (ugs.);sicher;risikofrei;nicht riskant
-Informierung (fachspr., Papierdeutsch);Aufklärung;Information;(das) In-Kenntnis-Setzen (geh., Papierdeutsch);In-Kenntnis-Setzung (Amtsdeutsch, Hauptform);Unterrichtung
-kurz außer Haus sein (Jargon);gleich wieder da sein;gerade nicht da (sein);kurz weg (sein) (ugs.)
-Sitzstreik;Sit-in (engl.);Sitzblockade
-entschottern (Jargon);(ein Bahngleis) unbenutzbar machen;schottern (Jargon)
-linker Radikalismus;Linksradikalismus;radikale Linke
-(etwas) nicht verkaufen können;keinen Käufer finden (für);(etwas) nicht loswerden (ugs.)
-(sich) auftun;aufklaffen;gähnen (fig.);klaffen
-aufmeißeln;ein Loch in die Wand (in den Fußboden) stemmen;aufstemmen
-Bilderdeutung;Bildinterpretation
-Rattenlinie (fig.);(bevorzugte) Fluchtroute (von Naziverbrechern)
-undeutlich aussprechen;nicht richtig artikulieren;(etwas) vernuscheln
-aussprechen;artikulieren;phonetisch realisieren (fachspr.)
-Audiofile;(das) Audio;Sounddatei
-Antifa;Antifaschistische Aktion
-Strukturierung;Systembildung;Systemerstellung;Systematisierung (Hauptform);Ordnung (als Tätigkeit)
-Erstellen einer Rangfolge;Herstellen einer hierarchischen Ordnung;Bildung einer Hierarchie;Hierarchisierung (Hauptform);(das) Aufstellen eine Hierarchie
-Positionierung (fig.);Verortung (geh.);Einordnung;Zuordnung
-Einwirkung;Einfluss (ugs.)
-Offenbarung;Erleuchtung;Erweckung (zu) (geh.);(plötzliche) Erkenntnis einer tieferen Wahrheit;(plötzliche) Erkenntnis einer höheren Wahrheit
-(jemandem) zufallen;(jemandem) zuwachsen (geh., fig.)
-Bundestreue;bündische Treue;Grundsatz des bundesfreundlichen Verhaltens;bündisches Prinzip
-eingefleischte(r/s) ...;lebenslang beibehaltene Gewohnheit(en) (variabel);lebenslang geübte(r/s) ...;Lebensgewohnheit(en) (Hauptform)
-Einpersonengesellschaft;Einmanngesellschaft
-Grundsteuer;Bodenzins
-die Tatsachen nicht sehen wollen(d);realitätsverweigernd;die Fakten nicht wahrhaben wollen(d);realitätsblind
-speziell;extra (ugs.);eigens (geh., Hauptform);nur
-Fettbrünierung;Braunfirnis;Schwarzbrennen;Firnisbrand;Schmelzfirnis;Ölbräune
-Alleingang (Hauptform);eigenmächtiges Handeln;unabgestimmte Aktion;Aktion eines Einzelnen;Eigenmächtigkeit;Einzelaktion
-Nebentrakt;Seitentrakt;Seitenflügel (variabel);Flügel (fig.);Seite
-Haupttrakt;Hauptgebäude;Mittelflügel;Mitteltrakt
-(sich etwas) einfallen lassen;(einen) Ausweg finden;(sich) zu helfen wissen
-Physalis;Andenkirsche;Judenkirsche;Blasenkirsche;Peruanische Blasenkirsche;Andenbeere;Kapstachelbeere (Hauptform);Physalis peruviana (fachspr., lat.)
-Ranunkel;Hahnenfuß;Ranunculus (lat.)
-lichtundurchlässig;lichtdicht
-Arkebuse;Hakenbüchse
-Schnellfeuerkanone;Maschinenkanone
-Doktor-Ingenieur;Doktor der Ingenieurwissenschaften;Dr.-Ing. (Abkürzung);Doktoringenieur
-Bedeckung mit Wald;Bewaldung (Hauptform);Waldbestände
-Zapfpistole (ugs.);Zapfventil
-... hungrige Mäuler stopfen (veraltend);... Kinder satt bekommen
-Seitenbemerkung;Randnotiz;Anmerkung;Bemerkung am Rande;Marginalie;Ergänzung;Randbemerkung
-wichtigstes Element;Kernelement;wichtigster Baustein;Herzstück (fig.)
-Mittelpunkt;Herzstück (fig.);Hauptattraktion
-ein Charakterbild zeichnen;vorstellen;porträtieren (fig., Hauptform)
-(etwas) vergeben (an);(jemandem etwas) zuteilen;(jemandem etwas) verpassen (ugs., negativ, salopp);(jemandem etwas) zuweisen;(jemandem etwas) zuschlagen
-Goldschatz;Goldhort
-seine Sache gut machen;einen verdammt guten Job machen (ugs.);einen richtig tollen Job machen (ugs.);gut einschlagen (ugs., regional);sich bewähren (bei einer Arbeit);(eine Aufgabe) mit Bravour erledigen (geh.)
-(bei jemandem) unter der Fuchtel stehen;(von jemandem) beherrscht werden
-Vereinigung;Zusammenarbeit;Gemeinsamkeit;Symbiose (fig.);(das) Zusammengehen;Einheitlichkeit;Einheit;Gemeinschaft
-(jemanden wegen etwas) angehen;(jemanden auf etwas) ansprechen (Hauptform);(jemanden) zur Rede stellen
-nichts auf die Reihe kriegen (ugs.);nichts auf die Reihe bekommen (ugs.);nichts auf die Kette kriegen (ugs., fig.);versagen;nichts zuwege bringen (geh.);scheitern
-(einer Sache) hinterherhecheln (fig.);(einer Sache) nachherjagen;(einer Sache) hinterherjagen (auch figurativ)
-das ist (noch) gar nichts (im Vergleich zu);und erst ...;es kommt noch besser
-Modul;Durchmesserteilung
-Abstiegsbauwerk;Aufstiegsbauwerk
-Schifffahrtsschleuse;Schiffsschleuse;Schleuse
-Passgang;Pass
-(etwas tun) dürfen;(etwas tun) können;(jemandem) nicht verboten sein;(jemandem) gestattet sein
-Vorankündigung;Voranmeldung
-(einen) Anlauf nehmen;(einen) Anrand nehmen (österr.);(einen) Anrang nehmen (österr.)
-Sphygmomanometer (fachspr., griechisch);Blutdruckmesser (ugs.);Blutdruckmessgerät
-(Schnee- und) Regenhose;Matschhose (Hauptform);Buddelhose
-gefederter Kontakt;Federstift;Spring Loaded Connector (engl.);Prüfpin (engl.);Pogo Pin (engl.);Federkontaktstift (Hauptform);Prüfspitze;Federkontakt;SLC (Abkürzung, engl.);Testpin (engl.)
-Herr;Standesherr (veraltend);vornehmer Herr;Grandseigneur (geh., franz.);weltgewandter Mann
-Loseblattsammlung;Loseblattwerk
-Pharmakopöe (griechisch);Liber Medicinalis (lat.);Arzneibuch (Hauptform);Antidotarium (lat.);Rezeptar;Rezeptarium (lat.)
-Gehalt;Anteil;Mischungsanteil
-Sake (japanisch);Reiswein
-gesetzestreu;regelkonform;rechtschaffen;paragraphenreiterisch (fig., negativ);vorschriftenhörig (negativ)
-Antinutritiva;Antinährstoffe;antinutritive Substanzen
-(etwas) legalisieren;(etwas) legitimieren;(etwas) reinwaschen
-Edelreife;Edelfäule
-Silicon;Polyorganosiloxan (fachspr.);Silikon (Hauptform);Polysiloxan (fachspr.)
-befremdet;verdutzt;irritiert;konsterniert (geh.)
-ringsherum;ringsumher;darum herum;um ... herum (Hauptform);ringsum;drumrum (ugs., regional);rings um ... herum;drumherum (ugs.)
-Lösung;Auflösung
-Kullani;Colani;Kolani;Marinejacke;Marinekurzmantel;Marinejackett
-Kraftmeierei;Kraftprotzerei
-ein sorgenfreies Leben führen;es gut haben;ein komfortables Leben führen;im Warmen sitzen (ugs., fig.)
-(ein) Bad in der Menge (nehmen) (fig.);(sich) unters Volk mischen
-Stagediving (Jargon, engl.);Sprung ins Publikum
-Crowdsurfing (Jargon, engl.);Crowdsurfen;(sich) über die Köpfe der Menge (fort)tragen lassen
-Schaltwerk (fachspr., Hauptform);hintere Schaltung (ugs.)
-Sittlichkeitsverbrecher (veraltend);Sittenstrolch (veraltend)
-Triebtäter;Sexualstraftäter
-gleichgewichtige Arbeitslosenquote;natürliche Arbeitslosenquote;normale Arbeitslosenquote;strukturelle Arbeitslosenquote
-Sockelarbeitslosigkeit;Bodensatzarbeitslosigkeit
-hineinzugehen wagen;zu betreten wagen;(sich) hineintrauen;(sich) trauen (in) (ugs.)
-Cäsarenwahnsinn (geh., bildungssprachlich);Herrscherallüren;Cäsarenwahn (geh., bildungssprachlich, Hauptform)
-im Chor rufen (variabel);skandieren (Hauptform);herausschreien
-(ein Gebiet) durchkämmen (fig.);(etwas) absuchen;(systematisch) durchsuchen
-ungebetenerweise;ohne Auftrag
-(öffentlichkeitswirksame) Ächtung;Cancel Culture (engl., Hauptform)
-transsexuell;im falschen Körper leben(d)
-Bestuhlung;Ausstattung mit Stühlen
-Arbeitsleuchte;Baustrahler
-O-Ton NAME;Das waren seine Worte.;Ich zitiere: " ... ";Das waren ihre Worte.
-Sesselfahrrad;Sesselrad;Scooterbike (engl.)
-(seinen) Weg nehmen;(irgendwo/her/hin) verlaufen (Hauptform);(seinen) Verlauf nehmen;(irgendwohin / irgendwoher) führen
-(sich) zerstreuen;auseinandergehen;(sich) verlaufen (ugs.)
-Unterzentrum;Grundzentrum
-Freiformation;Freiwilligenkorps;Freikorps
-Kokosfett;Kokosnussöl;Kokosöl
-Rotbeiniger Kolbenbuntkäfer (Hauptform);Koprakäfer;Necrobia rufipes (fachspr., lat.);Rotbeiniger Schinkenkäfer
-Kokosfaser;Kopra
-INCO-Bedingungen (engl.);Incoterms (Abkürzung, engl.);Internationale Handelsklauseln;International Commercial Terms (engl.)
-Tal;Talung (fachspr.)
-Buchennüsschen (schweiz.);Buchecker;Buchel (heraldisch)
-Fagin;Trimethylamin
-Taguanuss;Corozonuss;Steinnuss
-Wassernuss;Wasserkastanie
-Landschaftsform;Geländeprofil;Landform;Reliefform
-Landform;Geländeform;Erdform;Geländeformation (Hauptform)
-aufgehen;(sich) öffnen
-nicht zubleiben;(sich) (immer wieder) lockern;(immer wieder) aufgehen;(sich) (immer wieder) losruckeln
-aufsteigen;(am Horizont) zum Vorschein kommen;(am Horizont) erscheinen;aufgehen (Mond, Sonne ...)
-Teflon-Typ (fig., variabel);alles perlt (an jemandem) ab
-(sich) öffnen lassen;aufgehen
-Paleo-Ernährung;Steinzeitdiät;Paläo-Ernährung;Steinzeiternährung;Paleo-Diät;Paläo-Diät
-(sich) in eine andere Zeit versetzt fühlen (durch einen Anblick oder eine Erfahrung);wie aus der Zeit gefallen (wirken)
-zerschmelzen;verlaufen;zerfließen;auseinanderfließen;zerlaufen
-absolute Horrorvorstellung;(jemandes) schlimmster Alptraum (fig.)
-nicht zur Nachahmung empfohlen;(etwas) besser lassen (ugs.)
-(sich etwas) verkneifen (ugs.);(sich etwas) verbieten;(sich etwas) versagen (geh.);(einer) Versuchung standhalten
-Animpfen (ugs.);Beimpfung (ugs.);Inokulation
-sei er (/sie/es) auch noch so ...;egal welcher Art (ugs.);egal wie dies(e/s) aussehen soll;wie auch immer geartet (attributiv) (Hauptform);gleich welcher Art
-egal welche(r/s);welche(r/s) ... auch immer;gleich welche(r/s)
-im Normalalltag zu schaffen;im Alltag machbar;für jeden Tag;alltagstauglich
-für (den) professionellen Bedarf;für den harten gewerblichen Einsatz;für den harten Industrieeinsatz;für den Profieinsatz
-zu ausgesuchten Anlässen;für einen festlichen Anlass;für besondere Gelegenheiten;zu feierlichen Anlässen;für festliche Anlässe;für eine besondere Gelegenheit (variabel)
-Hüttendeck;Poopdeck;Puppdeck;Poop
-1. Deck;Hauptdeck
-Hüttendeck;Kampanje (Hauptform);Kampanjedeck
-Orlopdeck;Orlop
-respektieren (Grenzen);nicht abweichen (von);(unter / über / im Rahmen von etwas) bleiben;einhalten;nicht übertreten;(sich) halten (an)
-Kevinisierung (ugs., scherzhaft-ironisch);Chantalisierung (ugs., scherzhaft-ironisch)
-wiederverwendbare Materialien;Wertstoff;wiederverwendbares Material;wiederverwendbare Stoffe
-Dolorimetrie (fachspr.);Schmerzmessung
-zu mehrmaligem Gebrauch geeignet;mehrfach verwendbar;für mehrmaligen Gebrauch;wiederverwendbar
-in modernem Outfit;in neuem Gewand;in frischer Optik;in neuem Design;in neuer Aufmachung
-(sich etwas) packen;(sich etwas) nehmen;(sich etwas) krallen (ugs.);(sich etwas) grabschen (ugs.);(sich etwas) greifen
-Eintauchtiefe (Elektrosäge) (fachspr.);Schnitttiefe (fachspr.)
-(etwas) nicht mitmachen (Gerät, Maschine) (ugs., Hauptform);nicht schaffen;aussteigen (ugs., fig.)
-(sich) abschalten;(sich) ausschalten
-(eine) Mutter Teresa (fig.);(ein) barmherziger Samariter (biblisch, fig.)
-woke (Adjektiv) (Jargon, Neologismus, aufwertend, engl., Hauptform);aktiv gegen Diskriminierung;sensibilisiert für soziale Ungerechtigkeiten
-vorgegeben;simuliert;zur Schau getragen;gekünstelt;erheuchelt;aufgesetzt (ugs.);gestellt;markiert (ugs.);in Szene gesetzt;Schein...;vorgetäuscht;nicht echt;geschauspielert;vorgespielt;vorgegaukelt;verstellt;inszeniert;fingiert
-(in eine verantwortungsvolle Aufgabe) hineinwachsen (geh., fig.);(mit der Zeit) ein guter ... werden;(in seinem Job) allmählich besser werden;(mit der Zeit) eine gute ... werden
-Maschineneinsatz;schweres Gerät (einsetzen);Einsatz aller technischen Möglichkeiten
-ohne Werkzeug;mit bloßen Händen;ohne technische Hilfsmittel
-scharf umrissen;präzise eingegrenzt;klar konturiert;eindeutig bestimmt
-Beschränktheit;Schranke;Einschränkung (= Eingeschränkt-Sein);Eingeschränktheit (Papierdeutsch);Grenze;Beschränkung (= Beschränkt-Sein)
-Parallelwelt (fig.);Welt mit eigenen Gesetzen
-Höhenplattform;Pseudosatellit
-Preprint;Vorab-Publikation
-erste Präsentation;Neuvorstellung
-Vorabversion;noch nicht die endgültige Fassung
-Bezug (zu);Berührungspunkt;Anknüpfungspunkt;Zugang (zu);Beziehung (zu)
-Wohin fahren wir?;Wo gehen wir (denn) hin? (ugs.);Wohin geht's? (ugs.);Wohin gehen wir?;Wo soll's (denn) hingehen? (ugs.)
-Ritzelpaket;Kassette;Zahnkranz;Zahnkranzpaket
-einen raushauen (ugs., salopp);(eine lustige Geschichte) erzählen;(etwas) vom Stapel lassen;Witze erzählen;(einen) Schwank aus seinem Leben zum Besten geben;einen bringen (ugs., salopp)
-Eichhörnchennest;Kobel (fachspr., Jägersprache)
-Fuchshöhle;Fuchsloch;Fuchsbau
-Tierwohnung;Tierbau
-Sasse (fachspr., Jägersprache);(Ruhe-) Mulde (eines Hasen)
-Kessel (fachspr., Jägersprache);Schlafplatz (eines Wildschweins)
-(jemandem) einen vom Pferd erzählen (ugs.);(jemandem) eine wüste Geschichte auftischen;aufschneiden;es mit der Wahrheit nicht so genau nehmen;mit der Wahrheit kreativ umgehen (geh., ironisierend, verhüllend);flunkern (Hauptform);Seemannsgarn spinnen;übertreiben;(jemanden) anflunkern;Märchen erzählen (ugs.)
-Tollwut (Hauptform);Lyssa (griechisch, lat.)
-Schäferdichtung;Schäfergedicht;Madrigal (ital.)
-Machete (spanisch);Buschmesser
-Gondel;Ballonkorb
-Jungfernfahrt (Hauptform);erste Fahrt (eines neuen Fahrzeugs)
-Zellabbau;Cytolyse (griechisch);Zellauflösung;Zytolyse (griechisch)
-(Angehöriger) ...en Glaubens;Angehöriger einer Religionsgemeinschaft;Religionsanhänger;Religionsangehöriger
-fleißiger Kirchgänger;praktizierender Katholik
-Acerra (lat.);Weihrauchkästchen;Weihrauchbüchse
-Zukunftsdeuter;Augur (bildungssprachlich);Trendscout (fachspr., Jargon, engl.);Prognostiker
-Cashewnuss;Acajounuss;Cashewkern
-Pragmatik;Pragmalinguistik
-inperformant;leistungsschwach (Hauptform)
-(als etwas) darstellen;(jemanden zu etwas) abstempeln;so tun als (ugs.);behaupten;(als etwas) hinstellen (Hauptform)
-Niederdeckerbus;Eindecker;Niederdecker;Eindeckerbus
-Fahrbibliothek (Hauptform);Büchereibus;Autobücherei;Bibliobus;Wanderbücherei;Fahrbücherei;Bücherbus;Büchermobil
-Werbefahrzeug;Promotionsfahrzeug
-Sattelomnibus;Sattelbus;Sattelzugomnibus (Hauptform);Kamelbus (kubanisch);Camello (kubanisch, spanisch)
-Hüttensand;Schlackensand
-Zement (Hauptform);Opus caementitium (lat.)
-Maurerkrätze;Zementkrätze;Chromatallergie
-Knallzündschnur;Sprengschnur (Hauptform);detonierende Zündschnur;Detonationszündschnur
-Primer (engl.);Zündkapsel;Zündelement;Anzündhütchen;Zündhütchen
-Schulitis (sehr selten);Faulfieber (scherzhaft-ironisch)
-Schulphobie;Schulangst
-Apfelbeere;Aronia
-Fahrnis;fahrende Habe;bewegliches Vermögen
-ordentlich durchpusten (ugs.);(Auto, Boot) (voll) ausfahren;(mal richtig) Vollgas geben
-Antriebskraft (fig., Hauptform);Schubkraft;Anstoß;Push-Faktor (Anglizismus)
-Erstsemester;Ersti (ugs., Kurzform)
-Westgeld;blaue Fliesen (ugs., DDR, fig.)
-Trinkbruder;Saufkumpan (derb);Bacchant (geh.)
-Einjähriges Silberblatt (fachspr.);Lunaria annua (fachspr.);Judaspfennig (ugs., fig.);Silberblatt (ugs.);Mondviole (ugs.)
-bittschön (erwartend);nach Möglichkeit;wenn ich darum bitten dürfte (fordernd);wenn's recht ist (erwartend)
-Straßenablauf (Hauptform);Dole (ugs., schweiz., schwäbisch);Gully (ugs., Hauptform);Senke (ugs., ruhrdt., veraltend)
-(sich auf die Couch / auf einen Sessel usw.) fläzen (ugs., negativ);(sich auf die Couch / auf einen Sessel usw.) lümmeln (ugs., negativ);(sich) breit machen (ugs., negativ);(sich irgendwo) hinlümmeln (ugs., negativ);(sich irgendwo) hinfläzen (ugs., negativ)
-Lotsenfisch;Pilotfisch (Hauptform);Naucrates ductor (fachspr., griechisch, lat.)
-COX-2-Inhibitoren;COX-2-Hemmer
-generischer Name;internationaler Freiname
-errichten (Testament, Patientenverfügung, ...) (fachspr., juristisch);aufsetzen (Schreiben, Kaufvertrag, ...) (fachspr.);abfassen;erstellen (Papierdeutsch);machen (ugs.)
-Ortsendeschild;Ortsausgangsschild;Ortsendetafel
-breit akzeptiert;allgemein akzeptiert;in der Mitte der Gesellschaft angekommen (floskelhaft)
-rundgedreht (z.B. Schraubenkopf);rundgelutscht (ugs., salopp);abgenudelt (ugs.);vergurkt (ugs.)
-schlaff werden;unelastisch werden;schlapp werden (ugs.);keinen Zug mehr haben (ugs.);erschlaffen (geh.);ausleiern (Gummi) (Hauptform);(sich) weiten
-ich hatte auf Sie gehofft!;ich dachte, Sie helfen mir (variabel)
-kampfunfähig machen;außer Gefecht setzen (militärisch)
-lahmlegen;gebrauchsunfähig machen;funktionsunfähig machen
-zustande bringen (Hauptform);herbeiführen;anlegen;bewerkstelligen;herstellen;aufbauen
-unzuverlässig (Hauptform);unverlässlich;unberechenbar
-Mucken machen (ugs.);Probleme machen;nicht richtig funktionieren;nicht rund laufen (Motor);bockig sein (ugs.)
-STIKO (Abkürzung);Ständige Impfkommission
-Robert Koch-Institut;RKI (Abkürzung)
-öffentliche Gesundheitsfürsorge;Öffentliche Gesundheitspflege;Öffentliche Gesundheit;Public Health (engl.)
-her mit ...! (ugs.);rück sofort ... raus!;gib mir sofort ...!;gib sofort ... heraus!;gib her! (ugs.);gib sofort ... her!;gib das her!
-Abtrennungsregel;Implikationsbeseitigung;Modus ponendo ponens (lat.)
-disjunktive Syllogismus;Modus tollendo ponens (lat.)
-Modus ponendo tollens (lat.);konjunktiver Syllogismus
-kategorische Aussage;kategorisches Urteil;kategorischer Satz
-Stiegenaufgang;Treppenaufgang
-Haferdrink;Hafermilch (Hauptform)
-omnidirektionaler Lautsprecher;Rundumstrahler;Radialstrahler
-Brüllwürfel (ugs., abwertend, scherzhaft);Box;Lautsprecherbox
-ferroelektrischer Lautsprecher;Keramiklautsprecher
-Jet-Hochtöner;Heil-Hochtöner
-die Ärmel hochkrempeln (ugs.);(sich) impfen lassen;(s)eine Spritze bekommen (ugs.);geimpft werden
-kaum aufgeklärt;nicht entschlüsselt;noch nicht enträtselt;unerforscht;ungeklärt (Hauptform)
-Dentalplatte;Kauplatte;Pulvinus dentalis (fachspr., lat.)
-Ruminantia (fachspr., lat.);Wiederkäuer
-Alpaka;Pako;Vicugna pacos (fachspr., lat.)
-Axiologie (griechisch);Timologie (griechisch);Wertelehre
-Beurkunder;Beglaubiger;Bestätiger;Attestierer;Zertifizierer;Verbriefer;Verbürger;Bezeuger
-Verbesserungsvorschlag;Optimierungsvorschlag
-Rudiment;Restorgan (Hauptform);Überbleibsel
-Artefakt;Verfälschungseffekt
-Zierrat (Hauptform);Schnickschnack;Nippsache;Nippfigur;Zierfigur
-am rechten Rand (einer Partei) stehen(d);(ein) Rechtsaußen (fig.);Rechtsausleger (einer Partei) (fig.)
-ich werde mir die (aller)größte Mühe geben;auf mich kannst du (dabei) zählen;ich tue mein Möglichstes;an mir soll's nicht liegen (ugs., Spruch)
-Cyberdevise (ugs.);Cryptowährung
-(sich) qualifizieren;ein Ticket lösen (ugs.)
-übereinander herfallen;(sich) gegenseitig angreifen;(sich) gegenseitig attackieren;aufeinander losgehen
-aneinandergeraten (mit);Zusammenstöße
-Dezimation;Dezimierung
-Hort;Nachmittagsbetreuung (Schulkinder)
-Ort;Hort;Heimstatt;Heimstätte;Stätte
-man muss klar sehen (dass ...);machen wir uns nichts vor: ...;es ist einfach so (ugs.);es ist eine Tatsache (dass ...)
-gegen die geltende Rechtsordnung verstoßen;(sich) ins Unrecht setzen;gegen geltendes Recht verstoßen
-Reizfigur;(Person, an der) sich ... reiben
-Deutschenhass;Germanophobie;Deutschenfeindlichkeit;Deutschfeindlichkeit
-Forum;Komitee;Aktionsgemeinschaft (Hauptform);Plattform;Kuratorium
-Plattform (für jemanden/etwas) (Hauptform);Forum (für jemanden/etwas);Gefäss (für jemanden/etwas) (schweiz.)
-Verstehe ich dich (da) richtig: ...? (ugs., floskelhaft);Willst du damit sagen, dass ...? (ugs., floskelhaft)
-bang(e);eingeschüchtert;(jemandem) ist der Schreck in die Glieder gefahren;verschüchtert;verängstigt;(sehr) erschrocken
-regelbewusst;regelkonform;angepasst;brav
-Hier stinkt's wie im Pumakäfig. (ugs.);Wann ist hier das letzte Mal gelüftet worden? (ugs., ironisch)
-ohne lange zu fackeln;schlankweg (ugs.);ohne langes Überlegen;kurzerhand (Hauptform);kurz entschlossen;ohne lange zu überlegen;ohne viel Federlesens (geh.);kurz und schmerzlos;ohne lange zu fragen;ohne zu zögern;ohne viel Aufhebens;ohne Umschweife;vom Fleck weg (ugs.)
-nicht in jemandes Haut stecken wollen;nicht mit jemandem tauschen wollen
-Crouton;(gerösteter) Brotwürfel
-Minusstunden (Hauptform);Minderstunden;Minderarbeit
-(etwas irgendwo) untergebracht bekommen;(etwas irgendwo) hinbringen (können);(etwas irgendwo) lassen (können) (Hauptform);(etwas irgendwohin) bringen (können)
-(für etwas) kein Geld annehmen;(für etwas) kein Geld haben wollen (ugs.);(etwas) abgeben (ugs.);(etwas) umsonst abgeben (ugs.);(etwas) verschenken (Hauptform)
-pflegen lassen;in Pflege geben (Hauptform);versorgen lassen;jemanden finden, der sich um ... kümmert
-Hundehotel (Marketing);Hundebetreuung;Hundepension (Hauptform)
-Schleierwolke;Cirrostratus
-Lokalis;Ortskasus;Lokativ (Hauptform)
-mythisch;sagenhaft;legendär
-mit der blanken Waffe;mit gezogenem Schwert (mit gezogenem Säbel)
-Lust auf Neues (haben);(gerne) Neues ausprobieren (variabel);experimentierfreudig (sein)
-erlebnishungrig;(das) Abenteuer lieben;abenteuerlustig;(etwas) erleben wollen (ugs.)
-schon einige Jährchen auf dem Buckel haben (ugs.);einiges mitgemacht haben (ugs.)
-Dreikampf;Kräftemessen zu dritt;Triell
-(seinen) Einflussbereich erweitern;(sein) Geschäft ausweiten;expandieren (Hauptform)
-(jemandes) Bestehen (auf etwas);(jemandes) Versessenheit (auf etwas);(jemandes) Erpichtheit (auf etwas)
-drankommen (ugs.);(vom Lehrer) drangenommen werden (ugs.)
-Übungsleiter (ugs.);Fußballtrainer
-Heizdecke;Wärmebett
-Impfbescheinigung;Impfnachweis;Impfzeugnis
-Heizungskeller;Heizkeller (ugs.)
-Gebäudeheizung;Heizung (Kurzform)
-Helfer bei der Schiffschaukel;Schiffschaukelbremser (ugs.);Hutschenschleuderer (ugs., wienerisch)
-Wer nichts wird, wird Wirt. (Spruch, veraltend);Eintänzer in der Fischbratküche (ugs., scherzhaft, veraltend);Schiffschaukelbremser (derb, beleidigend, veraltet)
-feierlicher Augenblick;hervorgehobener Moment;bedeutsamer Moment
-hindeuten (auf);deuten (auf) (geh.);ein Hinweis sein (auf);(etwas) anzeigen;Anlass zu der Vermutung geben (dass);ein Marker sein (für) (fachspr., medizinisch);(etwas) vermuten lassen;zu der Vermutung berechtigen (dass);einen Hinweis darstellen (auf)
-K.-o.-Kriterium;Ausschlusskriterium;Totschlagkriterium;Killerkriterium
-der Reihe nach versuchen;durchprobieren
-experimentieren (mit);einen Versuch (/Versuche) durchführen (zu);einen Versuch (/Versuche) anstellen;eine Versuchsreihe machen;einen Versuch (/Versuche) machen
-es mit jemandem versuchen (ugs., Hauptform);(jemanden) versuchsweise betrauen (mit);(jemanden) probeweise einsetzen;(jemanden) unter Vorbehalt auf eine Stelle setzen
-(jemandem etwas) hoch anrechnen (Hauptform);(jemandem etwas) hoch anerkennen;in jemandes Achtung steigen (durch)
-(bei jemandem) einen Stein im Brett haben (fig.);(bei jemandem) gut angeschrieben sein
-Demutsgeste;Eingeständnis der Unterlegenheit;Unterwerfungsgeste
-Phantomempfindung (fachspr.);Phantomgefühl (fachspr.);Amputationstäuschung (fachspr.);Phantomempfinden (fachspr.)
-milzsüchtig (veraltet);hypochondrisch (Hauptform)
-Schmerz über den Verlust;Phantomschmerz (fig., Hauptform);Leiden am Verlust (geh.)
-nach Kräften;tatkräftig;mit Rat und Tat;mit großem Einsatz
-nicht wunschgemäß verlaufen;nicht rundlaufen;es gibt Probleme;schieflaufen (fig., Hauptform);nicht gut funktionieren;nicht laufen, wie es laufen soll(te)
-eine bedrohliche Entwicklung (darstellen);drohen, abzustürzen (fig.);(sich) negativ entwickeln (variabel);ins Rutschen kommen (fig., Hauptform);einzubrechen drohen (fig.);gefährdet sein
-Karikatur (einer Sache);Spottbild;verzerrte Darstellung;Zerrbild
-Cartoon;Witzzeichnung
-(politische) Karikatur;kritischer Cartoon
-wenig einträglich;wenig lohnend;unfruchtbar;wenig ertragreich;unergiebig
-wenig hergeben (für) (fig.);wenig ... abwerfen (an / für);(sich) kaum lohnen;es kommt wenig heraus (bei) (ugs., Hauptform);seine Zeit schon sinnvoller verbracht haben (ugs., Spruch, ironisierend);(das) Ergebnis ist unbefriedigend
-schieflaufen;schieftreten
-in Übereinstimmung stehen (mit);vereinbar sein (mit);nicht verstoßen (gegen);konform gehen (mit)
-(sich) angepasst verhalten;nicht auffallen wollen;keine Aufmerksamkeit auf sich ziehen wollen
-Zwiebelröhrl;Ewige Zwiebel;Johannislauch;Schlottenzwiebel;Hohllauch;Grober Schnittlauch;Winterzwiebel (Hauptform);Weiße Florentiner;Lauchzwiebel;Winterheckenzwiebel;Zwiebelröhrchen;Schnittzwiebel;Frühlingslauch;Allium fistulosum (fachspr., lat.);Röhrenlauch;Jakobslauch;Jungzwiebel;Winterhecke;Frühzwiebel;Schnattra;Frühlingszwiebel (Hauptform);Schluppenzwiebel;Fleischlauch
-bloß;denn bloß (ugs.);denn (in Fragen) (Hauptform);denn nur (ugs.);nur
-Schmelzstopfen;Schmelzsicherungsschraube
-(militärische) Übung (Hauptform);Kriegsspiel(e) (ugs., fig.);Bundeswehrübung (bundesdeutsch);Manöver (Hauptform, militärisch);Einsatzübung (militärisch);Truppenübung;Gefechtsmanöver
-...vorgang;...manöver (auch figurativ)
-Comeback;Wiedereinstieg
-wieder da sein (ugs.);sein Comeback feiern;ein erfolgreiches Comeback geben;weitermachen (ugs.);wieder (auf der Bühne stehen o.ä.);ein Comeback haben;(auf die Bühne o.ä.) zurückgekehrt sein
-Hoheitsemblem;Hoheitszeichen;Hoheitssymbol
-raffiniert;veredelt;verfeinert
-fälschen;nachmachen;(eine) Fälschung herstellen
-für echt halten;als echt ansehen
-verfälscht;manipuliert;gezinkt;getürkt;frisiert;geschönt
-Schwäbisch sprechen;schwäbeln
-aufgeblähte Show;Staatsaffäre;Staatsaktion;Haupt- und Staatsaktion
-Vermeidungsmaßnahme;Ausweichmanöver;Vermeidungsversuch
-Fahne (fachspr.);Tellerrand
-Speiseteller;Essteller;großer (flacher) Teller (ugs.)
-Suppenteller;tiefer Teller (ugs.)
-kleiner Teller (ugs.);Kuchenteller;Dessertteller;Frühstücksteller
-Verifikation;Verifizierung
-Validation;Validierung
-Coronaprotest(-aktion);Coronademo;Hygienedemo
-Beschleuniger;Treiber
-hochjagen (ugs.);Schub verleihen;explodieren lassen (Kosten, Preise) (variabel, übertreibend);anheizen;steigern;hinauftreiben;hochjubeln (ugs., salopp);hochtreiben;erhöhen;(nach oben) pushen (ugs., Jargon);nach oben jagen (ugs.);in die Höhe treiben (Hauptform)
-(seiner Phantasie / ...) die Zügel schießen lassen;überborden lassen (negativ);ins Kraut schießen lassen (negativ);(einer Sache) (freien) Raum geben;(sich) ungehemmt entfalten lassen
-bebaut;überbaut;versiegelt (Fläche)
-(einer Pflicht, einer Norm) gerecht werden;(einer Anforderung, einer Vorschrift ...) entsprechen;(einer Voraussetzung, einem Standard ...) genügen;(eine Bedingung, einen Anspruch ...) erfüllen;(die Erwartung/en) abdecken
-(eine) Frist wahren (geh.);(eine) Frist einhalten
-Ausschöpfungsquote;Rücklaufquote
-Selbstselektivität;Selbstselektion
-Repräsentativität;Repräsentanz
-Wahrscheinlichkeitsauswahl;Zufallsstichprobe;Zufallsauswahl
-Auswahlsatz;Einschlusswahrscheinlichkeit;Inklusionswahrscheinlichkeit;Auswahlwahrscheinlichkeit;Ziehungswahrscheinlichkeit
-(sich) rückversichern (bei) (Hauptform);sichergehen wollen;nachfragen;(sich) jemandes Rückhalts versichern (geh.)
-(sich) grünes Licht holen (bei) (ugs., fig.);(sich) jemandes Einwilligung holen;(sich) das Okay holen (von) (ugs.);(sich) jemandes Plazet holen (geh.);(sich) jemandes Zustimmung holen
-Rückversicherung;Rückversicherungsunternehmen;Rückversicherer;Rückversicherungsgesellschaft
-(sich) abgesichert haben;Vorsorge getroffen haben (gegen);versichert sein (gegen / vor - bei einer Versicherung) (ugs.);(eine) Versicherung haben (ugs.);vorgesorgt haben
-Risikoabwägung;Risikobeurteilung;Risikobewertung;Risikoeinschätzung
-(es) bleiben Fragen (offen);(sich) nicht sicher (sein);unsicher sein;(noch) Fragen haben (ugs.)
-nicht einschätzen können;nicht beurteilen können
-(jemandem) fehlt die Kompetenz;(jemandem) fehlt der ... Background;(jemandem) fehlt der ... Sachverstand
-(für etwas) nicht ausgebildet sein;(etwas) steht (/ stand) nicht auf dem Lehrplan (fig.);(etwas) gehört(e) nicht zu jemandes Pensum;(etwas) nicht gelernt haben;(etwas) nicht wissen
-Schnee von gestern (sein);niemand interessiert sich (für);kein Hahn kräht (nach) (ugs.);in (der) Bedeutungslosigkeit versinken;nicht mehr relevant (sein)
-altersbedingt;altersspezifisch;altersabhängig;aufgrund des Alters
-altersgemäß;alterstypisch;altersentsprechend;dem Alter entsprechend;altersüblich
-(passionierter) Briefmarkensammler;(leidenschaftlicher) Philatelist
-Interesse an (der) Philatelie;Leidenschaft für Briefmarken
-ausrauschen (Knoten, Seil) (fachspr.);durchrutschen;(unkontrolliert) durchlaufen;rauschen (durch);durchrauschen
-Wäschepflegesymbol;Textilpflegesymbol;Pflegesymbol (ugs.)
-Pflegeetikett;Pflegekennzeichnung
-Wi-Fi-Adresse (nur Apple);MAC-Adresse;Ethernet-ID (nur Apple);Physikalische Adresse;Airport-ID (nur Apple);Hardware-Adresse;Geräte-Adresse
-Maskirowka (russisch);Ablenkungsmanöver;Täuschungsmanöver
-Fehlerlinguistik;linguistische Fehleranalyse
-(jemandem) freundlich gesinnt;pro... (eingestellt);(eine) ...freundliche Einstellung haben
-balancieren;im Gleichgewicht halten
-geschlossene Abstammungsgemeinschaft;Monophylum;monophyletische Gruppe
-Stammlinie;Stammgruppe
-Amorbogen;Kupidobogen
-(jemanden) ins Gebet nehmen (fig.);(jemanden) eindringlich ermahnen
-(jemanden) mit dem Vorwurf (/ mit Vorwürfen) konfrontieren (dass);(jemandem) Vorhaltungen machen;Anschuldigung(en) erheben (gegen)
-ein gewisser (/ eine gewisse / ein gewisses ... + unzählbares Substantiv);einiges an ...;einiger (/ einige / einiges + unzählbares Substantiv) (geh.)
-zu einem Urteil kommen;(etwas) abschließend beurteilen;zu einem Urteil gelangen;zu einem ... Urteil finden (geh.);(eine) abschließende Beurteilung vornehmen
-Beliebigkeit;Einerlei;Wahllosigkeit;Ununterscheidbarkeit
-(der/die/das) ... mit den meisten;...könig
-der (/ die / das) größte Teil (von ...);überwiegender Anteil;der (/ die / das) meiste ...;Mehrzahl (des / der)
-Lottospieler;Tipper (ugs.)
-(einen) falschen Eindruck vermitteln;(ein) falsches Bild vermitteln
-Weichbild;Stadtgebiet
-zur Geltung kommen;(in bestimmter Weise) vermittelt werden;(in bestimmter Weise) rüberkommen (ugs.);zum Ausdruck kommen
-bei(m) Benz (arbeiten) (ugs.);bei Mercedes (arbeiten);beim Daimler (arbeiten) (ugs.)
-Brabanter;Flämisches Pferd;Flamländer;Belgier;Belgisches Kaltblut
-Arbeitspferd;Zugpferd;Kaltblüter;Kaltblutpferd
-Holländisches Kaltblut;Zeeuws trekpaard (niederländisch);Niederländisches Kaltblut (Hauptform);Nederlands trekpaard (niederländisch)
-Fesselbehang;Kötenbehang
-Noriker;Pinzgauer
-Slesvigsk Koldblod (dänisch);Slesviger (dänisch);Schleswiger Kaltblut
-Russisches Kaltblut;Russischer Ardenner
-Gartenwerkzeug;Gartengerät
-Steinkorb;Mauersteinkorb;Gabione (fachspr., ital.);Schüttkorb;Drahtschotterkasten
-(jemanden) aufheitern (Hauptform);(jemanden) aufbauen;(jemandes) Stimmung heben;(jemanden) aufmuntern;(jemandem) Auftrieb geben ((Sache))
-Spitzmaulnashorn (Hauptform);Diceros bicornis (fachspr., lat.);Schwarzes Nashorn;Spitzlippennashorn
-Cayman Islands;Kaiman-Inseln;Kaimaninseln;Caymaninseln
-Schablonenkunst;Stencil (engl.)
-Unbewusstes;Unterbewusstsein
-die Verkörperung (einer Sache) sein;die Personifikation (einer Sache) sein;(der / die / das) fleischgewordene ... (sein) (fig.);(etwas) personifizieren;(etwas) verkörpern
-Frischfleischtheke;Metzgereitheke;Fleischtheke;Metzgertheke;Fleischwarentheke (fachspr.)
-russischer Präsident;Kreml-Chef (ugs.);Präsident der Russischen Föderation
-Kneipp;Wasser-Doktor (ugs.)
-beugen;anziehen;anwinkeln (Arm, Bein)
-Papakind;stark auf seinen Vater fixiert (Kind)
-stark auf seine Mutter fixiert (Kind);Mamakind
-Austernbrecher;Austernmesser;Austernöffner
-Aminoplast;Aminoharz;Amidharz
-Kunstharz;synthetisches Harz
-Baumsaft;Naturharz;Baumpech;Baumharz
-Vinylesterharz;Phenacrylatharz
-(sich) in Gebärdensprache verständigen;mit Gebärdensprache kommunizieren;gebärden
-komischerweise;witzigerweise;lustigerweise
-entlohnt;entgeltlich;bezahlt (ugs.);Erwerbs...
-(jemanden) heranlassen;(jemanden) ranlassen (ugs.);(jemanden etwas) machen lassen (ugs.)
-(einen Mann) ranlassen (ugs., salopp);(sich) auf Sex mit jemandem einlassen (ugs.);(für jemanden) die Beine breit machen (derb);(jemanden) als Sexualpartner akzeptieren
-Köttel (Hauptform);Kötel;Bemmerl (österr.);kleines Kotklümpchen
-Rektifikation (fachspr., lat.);Gegenstromdestillation
-thermische Zersetzung (griechisch);Verschwelung (veraltet);trockene Destillation (veraltet);technische Pyrolyse;Brenzen (veraltet);Entgasung (veraltet);zersetzende Destillation (veraltet)
-langer Samstag (ugs.);verkaufsoffener Samstag (fachspr., Amtsdeutsch)
-betriebsam;wirbelig;quirlig (Straßenleben o.ä.);wuselig;wirblig;trubelig
-für um ... Uhr (ugs.);auf ... Uhr
-Generationenraumschiff;Weltraumarche
-(gedanklich) abschalten (fig.);nicht zuhören;mit seinen Gedanken woanders (sein)
-quer durch alle Parteien;überparteilich;fraktionsübergreifend;über alle Parteien hinweg;parteiübergreifend (parteienübergreifend) (Hauptform)
-noch nicht verarbeitet haben;(jemandem) noch lebhaft vor Augen stehen;(jemandem) (noch) in den Knochen stecken (fig.);(jemandem) (noch) in den Knochen sitzen (fig.);(sich) noch gut erinnern (an)
-Küchenzeile (fachspr.);Einbauküche;Küchenfront (fachspr., selten)
-Erzählliteratur;Epik;erzählende Dichtung
-marmornes Lächeln (geh.);zur Maske erstarrtes Grinsen;eingefrorenes Lächeln;gefrorenes Lächeln
-Initiative;erster Schritt (fig.);Vorstoß
-Moped;Motorfahrrad (österr.)
-seine Unschuld verlieren;entjungfert werden;das erste Mal Sex haben
-heroinsüchtig sein;an der Nadel hängen (fig.)
-kämpfen wie ein Berserker;kämpfen wie ein Löwe;kämpfen wie eine Löwin;(sich einen) Kampf aufs Messer (liefern) (fig.)
-Prosatext(e);Prosaliteratur;Prosa
-Lebenslüge;Selbsttäuschung;(permanenter) Selbstbetrug
-Erdmetallgruppe (veraltet);Triele;Erdmetalle (veraltet);Borgruppe
-Stibium (lat.);Antimon (Hauptform);Sb (Elementsymbol)
-Teness;Ts (Elementsymbol)
-Succus gastricus (fachspr., lat.);Magensaft
-Vorauskommando (auch figurativ, militärisch);Vortrupp (auch figurativ, militärisch);Vorhut (auch figurativ, militärisch);Vorausabteilung;Sondierungsteam
-Zug (Hauptform);Treck;Kolonne;Tross
-griechische Doppelflöte;Aulos (griechisch)
-Unterlassungsfehler;Unterlassungseffekt
-Kücheninsel;Kochinsel;frei stehende Küche
-Sprachregelung;Wording (fachspr.)
-Wirtschaftsprüfer;Bilanzchecker (ugs.)
-Euro (ugs.);Europameisterschaft
-Orchideenthema;Nischenthema
-Sperrabfall;Sperrmüll
-Imkerei;Bienenhaltung
-Apidologie;Bienenkunde
-erzwungen;mandatorisch (fachspr.);Zwangs...
-rechtlich verpflichtend;rechtsverbindlich;rechtlich bindend
-vertraglich gebunden;rechtlich verpflichtet;vertraglich verpflichtet
-(vom Gesetz) vorgesehen;vom Gesetz bestimmt;vorgegeben;gesetzlich vorgesehen;verlangt;gesetzlich bestimmt;vorgeschrieben (Hauptform);gesetzlich vorgeschrieben (variabel);gesetzlich;geboten;festgelegt;(vom Gesetz) gefordert
-über ganz Deutschland verteilt (variabel);in alle Winde zerstreut (sein) (fig.);über halb Europa verteilt (leben) (variabel)
-eintreiben;beitreiben (fachspr., juristisch);(zwangsweise) einziehen
-(jemanden) wegsperren;aus dem Verkehr ziehen (fig., verhüllend)
-(jemanden) wegsperren;in die (geschlossene) Psychiatrie einweisen
-aus dem Verkehr ziehen (Banknoten, Münzen);dem Geldkreislauf entziehen;aus dem Umlauf nehmen
-aus dem Verkehr ziehen (fig.);von der Teilnahme ausschließen;(jemanden) sperren;(eine) Sperre verhängen (über)
-aus dem Verkehr ziehen;zurückholen;(etwas irgendwohin) zurückbeordern;zurückrufen (fehlerhaftes Produkt)
-glorreich;ruhmreich;triumphal
-(jemanden) nicht aufklären (über);(jemandem) nicht die ganze Wahrheit erzählen;(jemandem etwas) verschweigen;(jemanden) in dem Glauben lassen (dass)
-mahnen;(etwas) an die Wand malen (fig.);auf eine Gefahr aufmerksam machen;(vor einer Sache) warnen (Hauptform);(auf etwas) eindringlich hinweisen
-in der Natur des Menschen liegen;Daran ist nichts Falsches. (geh., Spruch);(Das ist) nur natürlich.
-ich wüsste nicht, was daran nicht in Ordnung sein sollte;(das ist) ganz in Ordnung (so);(das ist) völlig okay;(schon) ganz okay (so)
-praktisch veranlagt;hemdsärmelig (fig.);kein Theoretiker
-prosaisch;trocken;nüchtern
-kreativ werden;Kreativität entfalten;(sich etwas Neues) einfallen lassen (ugs.)
-Ammann (schweiz.);Amtmann
-planetarische Grenze;planetare Grenze
-solidarische Ökonomie;solidarische Wirtschaft
-(sich) mit jemandem abwechseln (bei);im Turnus wechseln;(sich) mit jemandem ablösen (bei);(sich gegenseitig) abwechseln (bei);rotieren;(sich gegenseitig) ablösen (bei)
-drohende militärische Konfrontation;drohende militärische Eskalation;Spannungsfall (Deutschland) (fachspr., juristisch);drohender militärischer Konflikt
-sonst wer (ugs., abwertend);jeder x-beliebige;Hinz und Kunz (ugs., abwertend);jeder dahergelaufene (abwertend);jeder beliebige;Krethi und Plethi
-Gott weiß wer (ugs., negativ);sonst wer (ugs., negativ)
-alles, was nicht bei drei auf den Bäumen ist (ugs., fig., scherzhaft, variabel);alle restlichen;alles, was noch da ist;alle, die nicht bei drei auf dem Baum sind (ugs., fig., scherzhaft, variabel);alle, die noch da sind;alle Übriggebliebenen
-querbeet (alles und jedes / allem und jedem / ...);unterschiedslos;wahllos
-abschleifen;abziehen (Parkett, Dielen);(die) obere(n) Schicht(en) entfernen;schleifen
-(das) Bett abziehen;(den) Bettbezug (und das Laken) abziehen
-herunterwischen;abziehen (Wasser von Fläche);(mit einem Abzieher mit Gummilippe) herunterziehen
-abziehen (Bauteil im Maschinenbau);ausbauen;(mit einem Abzieher = Spezialwerkzeug) herausziehen;rausnehmen (ugs.);lösen;abbekommen (ugs.);herunternehmen;rausziehen (ugs.)
-herunterziehen;abpellen (ugs., regional);abziehen (Schale)
-in Flaschen füllen;(auf Flaschen) abziehen (fachspr.);auf Flaschen ziehen (fachspr.);abfüllen
-abstechen (Wein) (fachspr.);in einen anderen Behälter füllen;umfüllen;abzapfen;umpumpen;abziehen (fachspr.)
-aus dem Schloss ziehen;herausziehen;abziehen (Schlüssel, USB-Stick)
-stecken lassen (Schlüssel, USB-Stick);im Schloss lassen (ugs.);am Steckplatz lassen (Stick, Jumper)
-Condimento bianco;weißer Balsamico-Essig (ugs.);weißer Balsamico (ugs.)
-Balsamessig;Balsamico-Essig;Balsamico
-Erkenntnis;Untersuchungsergebnis;Forschungsergebnis
-seinem Instinkt vertrauen;(sich) auf seine Intuition verlassen
-Hericium erinaceus (fachspr., lat.);Affenkopfpilz;Igel-Stachelbart;Löwenmähne;Yamabushitake (japanisch);Pompon blanc (franz.)
-Koprolith (fachspr., griechisch);Enterolith (fachspr., griechisch);Kotstein;Fekalom (fachspr., griechisch);Faecalith (fachspr., griechisch, lat.)
-Enteron (fachspr., griechisch);Darm;Gedärm;Intestinum (fachspr., lat.)
-Darmflora (lat.);intestinale Mikrobiota (fachspr., griechisch, lat.);intestinales Mikrobiom (fachspr., griechisch, lat.);Intestinalflora (fachspr., lat.)
-(etwas) herausschinden (negativ);(etwas) herausholen;(etwas) herausschlagen
-Nachverfolgung;Verfolgung;Tracing (fachspr., Jargon, engl.);Rückverfolgung
-in Verbindung mit (Amtsdeutsch);zusammen mit;bei gleichzeitigem/r
-Bremse(n) (Hauptform);Viehfliege(n);blinder Kuckuck (ugs., westdeutsch);Breme(n) (süddt.);Tabanidae (fachspr.);blinde Fliege (ugs., norddeutsch)
-Bankier;Bankdirektor;Bankinhaber
-Rinderbremse;Tabanus bovinus (fachspr.)
-Brautwerber;Verehrer (einer Frau) (Hauptform);Freier (altertümlich);Freiersmann (veraltet)
-von der schnellen Truppe (sein) (ugs.);(du büs mi) en schönen Musche Blix! (ugs., plattdeutsch);ein Flotter (sein) (ugs.);ein fixes Kerlchen (sein) (ugs.);ein Schneller (sein)
-Dienstleistungsempfänger;Dienstleistungsnehmer
-Erbauer (geh.);Bauträger;Bauherr
-ohne Drive;mit angezogener Handbremse (fig.);ohne Elan;mutlos;ohne Biss
-Rückzugsgefecht;Abwehrhaltung;Abwehrstrategie;Defensive;Verteidigungshaltung
-ohne Beschwerden;beschwerdefrei
-ohne Schmerzen;leidensfrei;schmerzfrei (Hauptform)
-ich kann mich nicht beklagen;ich kann nicht klagen (Hauptform);ich kann nicht meckern
-symptomfrei;ohne Krankheitszeichen
-Vorab-Gespräch;Vorab-Besprechung;vorbereitende Besprechung;Besprechung des möglichen weiteren Vorgehens;Sondierungsgespräch;Vorgespräch (Hauptform)
-Ehrengericht (veraltet);Berufsgericht
-Phaseolin;Vicilin
-Glykoprotein;Glycoprotein
-Ricinus communis (fachspr., lat.);Rizinus;Wunderbaum
-Oleum Ricini s. Castoris (lat.);Palmachristiöl;Ricini oleum (fachspr., lat.);Rizinusöl (Hauptform);Oleum Ricini virginale (lat.);Christuspalmenöl;Kastoröl
-Ricin;Rizin
-Bestattungskultur;Friedhofskultur
-nicht verfügbar;verhindert
-zeigen, was man draufhat;(sich) beweisen;zeigen, was man kann
-Abbruchunternehmen;Abrissunternehmen
-weiß, wie er seine Schäfchen ins Trockene bringt (ugs., fig.);weiß seinen Vorteil zu sichern;weiß seine Interessen zu wahren;geschäftstüchtig;weiß, wie man Geschäfte macht
-gewieft (Hauptform);ausgeschlafen (ugs., fig.);kennt alle Tricks (ugs., fig.);ausgefuchst (ugs.);macht das nicht erst seit gestern (ugs., fig.);mit allen Wassern gewaschen (fig.);erfahren (sein)
-Präsidentschaftswahl (ugs.);Kampf um die Präsidentschaft
-Pentagon-Chef (ugs.);US-Verteidigungsminister
-Nagelpistole;Druckluftnagler
-Hohlspieker;Spleißnagel
-Marlspieker;Markpfriem
-Splisshorn;Spleißhorn
-Bimetallismus;Doppelwährung
-Homöonym;Homoionym
-partielle Synonymie;Homöonymie
-kurzsichtig;zu kurz gedacht
-(etwas) einläuten (Phase, Ära ...) (fig., Hauptform, mediensprachlich);der Beginn (einer Sache);der erste Schritt (hin zu etwas);der Anfang (von etwas / einer Sache)
-(auf längere Sicht) nicht tragfähig;keine Dauerlösung;nicht nachhaltig;nicht zukunftsfähig
-Italienische Strohblume (Hauptform);Helichrysum italicum (fachspr., griechisch, lat.);Katzenpfötchen;Italienische Immortelle (Hauptform);Currykraut;Sonnengold
-Bestätigungsfehler;Bestätigungstendenz;Bestätigungsverzerrung
-konzeptioneller Konservatismus;Beharren auf Überzeugungen
-Simultankontrast;simultaner Kontrasteffekt;Kontrasttäuschung;Chevreul-Täuschung;Farbtäuschung
-Farbtonkontrast;Farbtontäuschung;farbiger Simultankontrast;simultaner Farbkontrast
-simultaner Hell-Dunkel-Kontrast;Helligkeitstäuschung;Hell-Dunkel-Simultankontrast;Helligkeitskontrast
-laterale Hemmung;Umfeldhemmung;laterale Inhibition;Lateralhemmung;Lateralinhibition
-Wahrnehmungswechsel;multistabile Wahrnehmung;Gestaltwechsel
-binokularer Wettstreit;binokulare Rivalität
-okulare Dominanz (fachspr.);Augendominanz
-Katastrophisieren;Magnifizieren des Negativen
-Tendenz zum Status quo;Status-quo-Verzerrung
-passiver Wortschatz;rezeptiver Wortschatz
-aktiver Wortschatz;produktiver Wortschatz
-(etwas) auf den Begriff bringen;das Wesentliche benennen;den Nagel auf den Kopf treffen (mit);(etwas) auf den Punkt bringen;treffend zusammenfassen (Hauptform)
-Fernalarm;Einsatzalarm
-Internalalarm;Hausalarm
-Feueralarm;Brandalarm
-Begriffsschrifft;Ideographie (griechisch)
-Universalsprache;Characteristica universalis (lat.)
-mit mehreren Angelegenheiten (gleichzeitig) befasst sein;mehrere Projekte laufen haben (ugs., variabel);vielseitig engagiert sein
-falscher Alarm (fig.);unnötigerweise alarmiert;blinder Alarm (fig.);Fehlalarm
-ungehört verhallen (Warnung);Kassandraruf(e) (geh., bildungssprachlich);Der Prophet gilt nichts im eigenen Land(e). (geh., biblisch, sprichwörtlich, variabel)
-Deutscher Idealismus;Klassische deutsche Philosophie
-Egelschnecke (veraltet);Schnegel;Großschnegel
-Schuldnerberatung;Budgetberatung
-kometenhafter Aufstieg;Blitzkarriere
-Seemannskunst;Seemannschaft (fachspr., seemännisch)
-Kelterhaus;Presshaus
-Vinifikation;Weinherstellung;Weinbereitung;Vinifizierung
-Hodometer (fachspr., griechisch, Hauptform);(mechanischer) Wegmesser;Odometer (engl.)
-Regeldifferenz;Schleppfehler
-(die) Nummer 1;Leiterin;Chefin;Anführerin
-Oberin;Priorin;Äbtissin;Schwester Oberin (Anrede)
-Jackbohne;Canavalia ensiformis (fachspr., lat.);Madagaskarbohne;Riesenbohne
-Fetischbohne;Schwertbohne;Canavalia gladiata (fachspr., lat.);Madagaskarbohne
-Kurvometer;Kurvenmesser;Linienmesser;Opisometer;Rektifizierer;Messrädchen;Rektifikator;Kurvimeter;Kurveometer;Kartometer;Arkometer;Campylometer;Kartenmesser
-Kilometerzähler;Wegstreckenzähler (amtlich)
-ASI (Abkürzung, engl.);Fahrtmesser;Airspeed Indicator (engl.)
-Fahrpreisanzeiger;Taxameter (Hauptform);Gebührenmesser
-Hubodometer (engl.);Nabenhodometer
-herumschlackern (ugs.);lose herumhängen (Hauptform);herumschlabbern (ugs., salopp);(herum)baumeln;halblebig hängen (ugs., schwäbisch);auf halb acht hängen (ugs., fig.)
-schlottern (abwertend);herumhängen (Hauptform);schlackern (negativ);schlabbern (ugs., abwertend, salopp)
-fest installiert;eingebaut;fest verbaut;Einbau...
-Filzstift mit feiner Spitze;Fineliner (engl., Hauptform)
-CD-Stift;CD-Marker
-Folienmarker;Folienschreiber;Folienstift
-Whiteboard-Marker (engl.);Whiteboardstift;Whiteboardmarker (engl.)
-Edding;Permanentmarker (Hauptform);Permanent-Marker
-Centrum semiovale (fachspr., lat.);Großhirnmark
-Corpus cerebelli (fachspr., lat.);Kleinhirnkörper
-Corpus medullare cerebelli (fachspr., lat.);Kleinhirnmark
-Archicortex (fachspr., griechisch, lat.);Archipallium (fachspr., griechisch, lat.)
-Paläopallium (fachspr., griechisch, lat.);Paläocortex (fachspr., griechisch, lat.);Palaeopallium (fachspr., griechisch, lat.)
-Cortex praefrontalis (fachspr., lat.);präfrontaler Cortex
-Mittelhirn;Mesencephalon (fachspr., griechisch)
-Diencephalon (fachspr., griechisch);Zwischenhirn;Dienzephalon (fachspr., eingedeutscht, griechisch)
-Cerebellum (fachspr., lat.);Kleinhirn
-Pons (fachspr., lat.);Brücke
-Brückenhaube;Tegmentum (fachspr., lat.)
-Truncus encephali (fachspr., griechisch, lat.);Truncus cerebri (fachspr., lat.);Hirnstamm
-Vorderhirn;Prosencephalon (fachspr., griechisch)
-Pyramidales System;Pyramidenbahn
-Alibi-Schwarzer;Vorzeigeschwarzer;Quotenschwarzer
-Bulbine frutescens (fachspr., lat.);Brenngeleepflanze;Katzenschwanzpflanze;Bulbine caulescens (fachspr., lat.);Stelzenbulbine (Hauptform)
-Myrrhe;Myrrhenharz
-Copal;Kopal
-Weihrauch (Hauptform);Boswellienharz;Thus;Olibanum (lat.);Incensum (lat.)
-Schneidebrett;Schneidbrett;Brettchen;Hackbrett
-Edelfeder (Jargon);Starschreiber
-Stuttgarter Platz (Berlin);(der) Stutti (ugs., Jargon)
-(ohne etwas / jemanden) zurechtkommen;(ohne etwas) auskommen;(jemandem) nicht fehlen;(etwas / jemanden) nicht vermissen;(ohne etwas / jemanden) klarkommen;(etwas / jemanden) nicht brauchen
-Ungelernter;Laie;Nichtfachmann;(reiner) Amateur;Dilettant;nicht vom Fach
-passioniert;aus Liebhaberei;aus Passion;aus reiner Begeisterung (für etwas)
-berufsmäßig;beruflich;als Broterwerb;um (damit) Geld zu verdienen
-fanatisch;(wie) besessen;glühend
-verblendet (sein);(sich) verrannt haben (in);besessen (sein von)
-unbändig;stürmisch;frenetisch;ungestüm;vehement (Hauptform);heftig;inbrünstig
-Völkerschau;Menschenzoo;Kolonialausstellung;Kolonialschau
-hinter dem Geld her (sein);auf Geld aus (sein)
-Deonym (fachspr.);Wort aus einem Eigennamen
-Kolonie;Überseebesitz;Überseegebiet;Auslandsterritorium;Schutzgebiet (euphemistisch);Auslandsbesitzung
-Pflanzstadt;Apoikia (fachspr., griechisch, historisch);Außensiedlung;Tochterstadt
-für interessierte Laien zugänglich;populärwissenschaftlich;wissenschaftsjournalistisch
-allgemeinverständlich aufbereiten;der Allgemeinheit schmackhaft machen;unters Volk bringen;popularisieren (Erkenntnisse)
-verheerende Schäden hinterlassen;großen Schaden anrichten;(sich) verheerend auswirken
-Wer nicht für uns ist, ist gegen uns. (Gemeinplatz);Und willst Du nicht mein Bruder sein, so schlag' ich Dir den Schädel ein. (Zitat);Freund-Feind-Denken
-Zitatenschatz;Zitat(e)sammlung;(der) Büchmann;Sammlung geflügelter Worte
-vereinfacht darstellen (in Form von);(etwas) reduzieren (auf);(etwas) herunterbrechen (auf) (bildungssprachlich, fig.)
-so leid es mir tut (, aber ...);(das) ist nicht gegen Sie (gerichtet);sorry (, aber ...);tut mir leid (, aber ...);nichts für ungut (, aber ...)
-bei Pontius und Pilatus anrufen;(sich) die Finger wund telefonieren (fig., übertreibend)
-zitrusartig;zitrisch
-scharf konkurrieren (um);erbitterte Konkurrenten sein;(sich) einen gnadenlosen Wettbewerb liefern
-Faktorallokation;Ressourcenallokation
-Allokationsproblem;Lenkungsproblem
-Eigenname;singulärer Term;Nominator
-vier Mann hoch;zu viert
-Lagunenstadt (ugs.);Venedig
-Bürokratisierung;Bürokratiewachstum
-amorpher Sprachbau;isolierender Sprachbau;analytischer Sprachbau
-polysynthetischer Sprachbau;einverleibender Sprachbau (veraltet);inkorporierender Sprachbau (veraltet)
-Basalzellschicht;Basalmembran
-geschmolzener Reaktorkern;Corium
-dippen;aufdippen;auftunken;aufstippen
-Dermis (fachspr.);Lederhaut;Corium (fachspr.)
-miteinander verwandte Sprachen;Sprachfamilie
-Impala;Schwarzfersenantilope
-Buchungssatz;Buchungsformel;Kontenanruf
-pagatorische Buchhaltung;kaufmännische Buchhaltung;Geschäftsbuchhaltung
-(sich) verrückt machen (ugs., negativ);in großer Unruhe sein;sehr beunruhigt (sein);in großer Sorge sein;hoffen und bangen (geh.)
-pressen;mosten;keltern
-Prinzipal-Agenten-Dilemma;Prinzipal-Agenten-Problem
-Meerkirsche;Westlicher Erdbeerbaum;Erdbeerbaum;Hagapfel;Arbutus unedo (fachspr., lat.)
-Averrhoa carambola (fachspr., lat.);Carambola;Karambola;Sternfrucht (Hauptform);Karambole
-Zuckerrohr;Saccharum officinarum (fachspr., lat.)
-Mascobado;Muskovade;Vollrohrzucker (Hauptform);Muscovado
-Affinade;Weißzucker
-Mehlis;Maltesischer Zucker;Melis;halbweißer Zucker
-Farin;Farinzucker
-Rohzucker;Gelbzucker;Demerara-Zucker
-immer wieder aufflackern (fig.);es kommt immer wieder zu ...
-matrilinear;matrilineal
-patrilineal;patrilinear
-periphere arterielle Verschlusskrankheit;chronische arterielle Verschlusskrankheit der Extremitäten
-Amerikanische Ulme;Weiß-Ulme
-Flatterrüster;Flatterulme
-Sibirische Ulme;Zwerg-Ulme
-Bastard-Ulme;Holländische Ulme
-Englische Ulme;Haar-Ulme
-Nichtdeskriptor;Nichtvorzugsbenennung;Verweisungsform
-Indexierungskonkordanz;Indexierungskonsistenz
-Motte;Nachtfalter
-Tineola bisselliella (fachspr.);Motte(n) (ugs.);Kleidermotte(n)
-Plodia interpunctella (fachspr.);Dörrobstmotte;Getreidemotte
-Balkenanzeige;Bandanzeige
-Leistungsanpassung;Widerstandsanpassung;Lastanpassung
-Raketenwarnsystem;Raketenwarngerät;Raketenwarner;Flugkörperwarner
-Radar-Detektor;Radarwarnanlage
-(irgendwo) einfach so reingehen (ugs.);(irgendwo) hineinspazieren (fig.);(irgendwo) reinspazieren (ugs.);(irgendwo) hineingehen, ohne aufgehalten zu werden
-Fabeldichter;Fabulist (veraltet)
-Dienstgüte;Quality of Service (engl.);QoS (Abkürzung, engl.)
-Erinnerungsverzerrung;Erinnerungseffekt
-Klimaskeptiker;Klimawandelleugner (abwertend)
-(das) dreckige Dutzend (ugs., stark abwertend);Zwölfergruppe
-übernehmen (Fall, Sache);an sich ziehen (Fall, Sache)
-zu Grund (geh., poetisch);auf den Boden;zu Boden
-Majorat;Ältestenrecht
-Chinesischer Zimtbaum;Zimtkassie;Cinnamomum cassia (fachspr., lat.)
-Gewürzrinde;Cassiazimt
-Süße Akazie;Cassia;Schwammbaum;Antillenakazie
-die Treppe hinunter;treppab;die Treppe runter (ugs.)
-die Straße hinunter;straßab (selten)
-Spritzsack;Dressiersack;Spritztüte;Dressierbeutel;Spritzbeutel
-bicolor (fachspr.);zweifarbig
-Infektion trotz Impfung;Impfdurchbruch;Erkrankung trotz Impfung
-Wasserkocher (mit Heizspirale);Tauchsieder
-Geyser (fachspr.);Durchlauferhitzer
-niederschwellig;einfach zu bekommen (ugs.);niedrigschwellig;ohne (großen) Aufwand zu haben (ugs.)
-Zeit und Mühe verwenden;Aufwand treiben
-(bis ... ist noch) ein weiter Weg (fig.);(es) bleibt viel zu tun (bis ...);(es ist noch) viel zu tun (Hauptform)
-Torero (spanisch);Stierkämpfer
-(etwas) feilbieten (geh., altertümelnd);offerieren;(jemandem ein Verkaufs-) Angebot machen;(etwas) im Angebot haben;(zum Kauf) anbieten;feilhalten (veraltet)
-Traktur;Traktatur
-Spieltraktur;Tontraktur
-Langobardisches Königreich;Königreich der Langobarden
-Umgehungsmöglichkeit;Ausweg;Schlupfloch (fig.)
-Schanzpionier;Sappeur (franz.);Belagerungspionier
-Festungsabhang;Glacis (fachspr., franz.)
-Deckungsgraben;Splittergraben;Splitterschutzgraben
-Paragraphendschungel (fig.);Regelungswirrwarr
-schwierig (ugs.);mit Fingerspitzengefühl zu behandeln;delikat;(einen) sensiblen Umgang erfordern;intrikat (geh.);heikel
-Saturei;Bohnenkraut
-Kernbohne;Trockenkochbohne
-Pintobohne;Wachtelbohne
-Viehbohne;Favabohne;Vicia faba (fachspr., lat.);Dicke Bohne;Ackerbohne (Hauptform);Vicia faba L. ssp. fába var. equína (fachspr., lat.);Saubohne;Faberbohne;Pferdebohne;Feldbohne;Schweinsbohne;Fababohne;Puffbohne
-Feuerbohne;Wollbohne;Phaseolus coccineus (fachspr., lat.);Käferbohne (österr.)
-Pisum sativum (fachspr., lat.);Gartenerbse;Speiseerbse;Erbse
-Glycine max (fachspr., lat.);Soja;Sojabohne (Hauptform);Daizu (japanisch)
-Kräutersträußchen;Bouquet garni (franz.);Kräuterstrauß
-Ammi copticum (fachspr., lat.);ägyptischer Ammei;Mohrenkümmel;Indischer Kümmel;Trachyspermum ammi (fachspr., griechisch, lat.);Ajowan;Königskümmel
-fines herbes (franz.);feine Kräuter
-Kräuter der Provence;Herbes de Provence (franz.)
-Kuttelkraut;Origanum majorana (fachspr., lat.);Wurstkraut (ugs.);Mairalkraut;Miran;Bratenkräutel;Bratekräutche;Majoran (Hauptform);Mussärol;Mairan;Kuchelkraut;Mairon;Badkraut;Meiran;Gartenmajoran
-Satureja hortensis (fachspr., lat.);Sommer-Bohnenkraut;Echtes Bohnenkraut;Pfefferkraut;Saturei;Kölle;Gartenbohnenkraut
-Herba dracunculi (fachspr., lat., pharmazeutisch);Dragun (veraltet);Estragon (Hauptform);Artemisia dracunculus (fachspr., lat.);Dragon (veraltet)
-Anis;Pimpinella anisum (fachspr., lat.)
-Basilienkraut;Basilikum (Hauptform);Königskraut;Basilie;Ocimum basilicum (fachspr., lat.)
-Kerbel;Echter Kerbel;Anthriscus cerefolium (fachspr., lat.)
-Rosmarin;Salvia rosmarinus (fachspr., lat.);Rosmarinus officinalis (fachspr., lat.)
-Bergpfeffer;Szechuanpfeffer (Hauptform);Sichuan Pepper (engl.);Chinese prickly ash (engl.);Japanischer Pfeffer;Chinesischer Pfeffer;Zanthoxylum piperitum (fachspr., griechisch, lat.);Anispfeffer
-Gewürznelke;Syzygium aromaticum (fachspr., griechisch, lat.)
-Minirechner;Kleinrechner
-Asiatische Petersilie;Stinkdill;Echter Koriander (Hauptform);Gebauter Koriander;Klanner;Gartenkoriander;Kaliander;Schwindelkraut;Arabische Petersilie;Wanzenkümmel;Gewürzkoriander;Indische Petersilie;Coriandrum sativum (fachspr., lat.);Chinesische Petersilie;Wandläusekraut;Wanzenkraut;Schwindelkorn;Wanzendill
-Petergrün;Felsensilge (veraltet);Petroselinum crispum (fachspr., lat.);Petersilie (Hauptform);Peterle;Peterli;Petersil (bairisch, österr.);Silk;Peterling;Steineppich (veraltet)
-(sich) einen Therapeuten suchen (ugs., Hauptform);(sich) Hilfe holen (verhüllend);(sich) Hilfe holen (verhüllend);(sich) einen Therapeuten nehmen (ugs.)
-...bewusst;...fixiert;...orientiert
-Fahrtrichtungsänderung;Fahrtrichtungswechsel
-voller Demut;demutsvoll;ergeben;demütig
-Ministerpräsidentenkonferenz;Bund-Länder-Gespräche
-kleines Finale;Spiel um Platz drei;Hoffnungsrunde (ugs.)
-Meskalin;Mescalin
-(sich) etwas nicht (weg)nehmen lassen;(das ist) mein Ding (ugs.);(auf etwas) Hand drauf haben (ugs., fig.)
-indirekt;durch die Hintertür (fig.);hintenrum
-Polyphonie;polyphone Chiffrierung;polyphone Verschlüsselung
-Dünung;Schwell
-fauler Frieden;Nikiasfrieden (griechisch)
-(den) Tisch abdecken;abtischen (schweiz.);abservieren;abräumen (Tisch);abbacken (fachspr., Jargon, seemännisch)
-locker mithalten (können) (ugs.);mühelos gleichziehen (mit)
-unempathisch;ohne Mitgefühl;ohne Einfühlungsvermögen
-entsperren;freischalten;Zugriff ermöglichen;Zugriff erlauben;freigeben;Zugriff geben (auf)
-(jemanden) autorisieren;(jemandem die) Berechtigung erteilen
-nichts Bestimmtes;(sich) über Gott und die Welt (unterhalten);dies und das (ugs.);dieses und jenes;alles Mögliche und Unmögliche (ugs., scherzhaft);dies und das und jenes (ugs., scherzhaft)
-nicht unter Kontrolle zu halten;nicht zu bändigen;wild;nicht im Zaum zu halten;(mit jemandem) durchgehen;unbezähmbar;unkontrollierbar
-Heldenalter;heroisches Zeitalter
-Magdalenenhochwasser;Magdalenenflut
-umschlingen;umranken;(sich) schlingen (um);(sich) winden (um);überwuchern;(sich) ranken (um);umwinden
-Tiroler Unterland;Nordtiroler Unterland
-Tiroler Oberland;Nordtiroler Oberland
-Wein ohne Herkunftsangabe;Tafelwein (veraltet)
-Qualitätswein mit Prädikat (veraltet);Prädikatswein
-Restsüße;Restzucker;Zuckerrest
-Champagnerdeckel;Muselet (franz.)
-Sammeln von Champagnerdeckeln;Placomusophilie (fachspr.)
-Sand im Getriebe (sein);Sand im Getriebe darstellen;(ein) Störfaktor sein;(den) reibungslosen Ablauf behindern;(Abläufe) stören
-Nicht-Standard-Architektur;Freiform-Architektur;Blob-Architektur
-(eine) Vergünstigung bekommen;(eine) Extrawurst bekommen;bevorzugt behandelt werden;(eine) Vorzugsbehandlung bekommen
-Clubszene;Partyvolk;Partyszene
-Nothilfekurs;Nothelferkurs
-Oxidationszustand;Oxidationsstufe;elektrochemische Wertigkeit
-Edelgaskonfiguration;Edelgaszustand
-Raststätte;Autohof;Rasthof
-Operationswerk;Rechenwerk (Hauptform)
-logische Schaltung;digitale Schaltung
-Co-Prozessor;Koprozessor
-MCU (Abkürzung, engl.);Microcontroller;Microcontroller Unit (engl.);Einchipmikrorechner;Mikrocontroller (Hauptform)
-Prozessorregister;Register
-Stackpointer (engl.);Stapelregister (Hauptform);SP (Abkürzung, engl.);Stapelzeiger
-Was hatte das (vorhin) zu bedeuten?;Was war das eben? (ugs.)
-an jeder Milchkanne halten (ugs., fig.);an jedem kleinen Bahnhof halten.
-(Fleisch) vom Knochen lösen;entbeinen;ausbeinen;(Fleisch) auslösen
-(in einem) Selbstfindungsprozess (sein);herausfinden wollen, was man im Leben will;herauszubekommen versuchen, in welche Richtung man sich entwickeln will
-(Verschiedenes) für sich antesten;(sich) ausprobieren;Erfahrungen sammeln
-Kartoffelstampfer;Kartoffelquetsche;Kartoffelpresse
-(die) Gretafrage (fig.);Wie stehst du zur Klimafrage?;Wie hältst du's mit dem Klima?
-Talentflucht;Abwanderung Hochqualifzierter;Talentabwanderung;Talentschwund;Brain-Drain (Jargon, engl.)
-Rücküberweisung;Heimatüberweisung
-Übertragungsbilanz;Bilanz der laufenden Übertragungen
-Spektralapparat;Spektralgerät
-Spektralphotometer;Spektrophotometer
-Bragg-Bedingung;Bragg-Gleichung
-Elementarzelle;Einheitszelle
-Gitterparameter;Gitterkonstante;Zellparameter
-Punktgitter;Kristallgitter
-Gitterpunkt;Gittervektor
-Inversion;Raumspiegelung
-Gleitspiegelung;Schubspiegelung
-Hintereinanderausführung;Verknüpfung;Verkettung
-surjektive Abbildung;surjektive Funktion;Surjektion
-Identitätsgleichung;Identität (Kurzform)
-Diplom-Vorprüfung;Vordiplom (ugs.)
-stetige Funktion;stetige Abbildung
-Hauptsatz der Differential- und Integralrechnung;Fundamentalsatz der Analysis
-Garniermesser;Buntmesser;Buntschneidemesser
-Kennwert;Index;Kennziffer;Maßzahl;Kenngröße;Kennzahl
-nicht (immer wieder) das Rad neu erfinden (fig.);auf Bewährtes zurückgreifen;vorhandene Erfahrungen nutzen
-nicht auf die Zeit achten;(die) Zeit vergessen;(die) Zeit nicht im Auge behalten
-verstärken;zum Auflodern bringen;auflodern lassen;anfachen (Feuer);aufflammen lassen;schüren
-Küche;Kücheneinrichtung;...küche;Küchenmöbel
-Spüler;Plongeur (fachspr., franz.);Tellerwäscher;Abwäscher;Spülkraft
-eigenberechtigt (Person) (österr.);geschäftsfähig (Person)
-intrikat (geh.);komplex;kompliziert;vielschichtig
-vigelinsch (ugs., norddeutsch, plattdeutsch);vertrackt;tricky (ugs., engl.);figelinsch (ugs., norddeutsch);verzwickt;kniff(e)lig;verwickelt
-Sonderlocke (ugs.);Extrawurst (ugs.);Sonderbehandlung;bevorzugte Behandlung
-astronomischer Turm (veraltet);mathematischer Turm (veraltet)
-Krankenhausbehandlung (ugs.);stationäre Behandlung
-schief angeguckt werden (ugs., fig.);ablehnende Kommentare ernten (variabel);(sich) manch ablehnenden Spruch anhören müssen;schief angesehen werden;(sich) missbilligende Bemerkungen gefallen lassen müssen
-Stadtschwalbe;Delichon urbica (fachspr., griechisch, lat.);Delichon urbicum (fachspr., griechisch, lat.);Kirchschwalbe;Mehlschwalbe (Hauptform)
-(das) Zeigen;Zur-Schau-Stellung;Präsentation;(das) Zur-Schau-Stellen;(die) Vorstellung;(das) Vorstellen
-Messe (Hauptform);Salon (schweiz.);Leistungsschau
-Besuchermesse;Publikumsmesse;Konsumentenmesse;Verbrauchermesse
-Fachmesse;Messe für Fachbesucher
-(sich) anschließend (Adjektiv);weiter (Adjektiv);Anschluss...;Folge...;nachfolgend;dann kommend
-taktisch unklug agieren;sich selbst im Weg stehen (fig.)
-Schützenmulde;Schützenkuhle
-permanent angegriffen werden;Trommelfeuer der Kritik (fig.);unter Dauerbeschuss stehen (fig.)
-Spuren hinterlassen (bei);(einen) nachhaltigen Eindruck hinterlassen (auf);nachhaltig beeinflussen;(jemanden) prägen (Hauptform)
-Marginalisierte(r);Benachteiligte(r);Unterprivilegierte(r);Abgehängte(r)
-Kreppe;Hohlweg (süddt.)
-Wasser Marsch! (Feuerwehr);Ring frei! (Boxen);Bühne frei (für ...)! (Show. Konzert, Theater);Film ab! (Kino);Es geht los! (Hauptform);Manege frei! (Zirkus);Leinen los! (Schifffahrt, Bootsfahrt)
-disruptiv (Neologismus);durchschlagend;umwälzend
-alles Bekannte niederreißend;drastisch (Hauptform);durchschlagend;tiefgreifend;einschneidend
-Zerstörungskraft;Vernichtungspotential
-Reichstagsdirektorium;Reichsdirektorium
-(einen) besseren Eindruck machen;(sich) besser machen (ugs.);mehr hermachen;besser aussehen;besser dastehen (mit);(sich) günstiger ausnehmen
-Sonntagsanzug;(jemandes) 'guter Anzug';(jemandes) 'gutes Kleid';Sonntagskleid;Sonntagsstaat;Sonntagskleidung
-Sonntagskleidung;Sonntagskleid;(sein) 'guter Anzug' (ugs., variabel, veraltend);Sonntagsanzug;Sonntagsstaat (veraltend);(ihr) 'gutes Kleid' (ugs., variabel, veraltend)
-Bedachtsamkeit;Geruhsamkeit;Behäbigkeit;Bedächtigkeit;Gemächlichkeit;Betulichkeit;Seelenruhe
-Langsamkeit;Schneckentempo;Schleichtempo;langsames Tempo
-(sich) häuslich einrichten;(es sich) ein bisschen nett machen (ugs.);(es sich) gemütlich machen (auch figurativ)
-Schimpfe bekommen (ugs.);ausgeschimpft werden (Kinder) (ugs., Hauptform);ausgeschumpfen werden (ugs., regional, scherzhaft);gescholten werden (geh., veraltet);(eine) Gardinenpredigt über sich ergehen lassen müssen;(sich jemandes) Gemecker anhören müssen (ugs.);die Leviten gelesen bekommen
-(sich) hierher verirren (ugs., fig., scherzhaft);(hier) landen (fig.);(hierher) kommen;herfinden
-(jemandem) ausgegangen sein;keine (...) mehr wissen
-Luftrettung;Rettung aus der Luft
-Notbesetzung;Minimalbesetzung;Rumpfbesetzung
-objektorientierte Datenbank;Objektdatenbank
-Präfixtaste;Tottaste
-Tottaste;Präfixtaste
-im Alltag;im harten Praxiseinsatz;im (harten) täglichen Einsatz;unter Real-life-Bedingungen
-ihr erster Gang führt sie (zu) (geh., literarisch);sein erster Gang ist (zu) (geh., literarisch);ihr erster ist Gang (zu) (geh., literarisch);sein erster Gang führt ihn (zu) (geh., literarisch);zuerst gehen (zu) (variabel)
-Glasrecycling;Altglasverwertung;Altglasrecycling;Altglaswiederverwertung
-(etwas) predigen (ugs., fig.);(sich) den Mund fusselig reden (ugs., Redensart);(jemandem) zureden wie einem kranken Gaul (ugs.);(auf jemanden) mit Engelszungen einreden (fig.);(sich) Fransen an den Mund reden (ugs., Redensart)
-Werbezettel;Handzettel;Reklame(zettel)
-Abschnittsbevollmächtigter (Amtsdeutsch, DDR);Kontaktbereichsbeamter (Amtsdeutsch, bundesdeutsch, westdeutsch)
-Tierversuchsgegner;Tierversuchskritiker
-(pathologischer) Narzissmus (fachspr.);narzisstische Persönlichkeitsstörung (fachspr.)
-histrionische Persönlichkeitsstörung (fachspr.);hysterische Persönlichkeitsstörung (fachspr., veraltet)
-Anwaltsgebühren;Anwaltskosten
-(es) droht eine Katastrophe;die höchste Alarmstufe (wurde ausgerufen);(es besteht) höchste Gefahr;(es besteht) Katastrophengefahr;(es herrscht) Alarmstufe Rot (fig.)
-Helmlöhr;Wulst;Helmwulst (Hauptform);Helmbinde;Türkenbund;Löhr;Pausch;Bausch
-Wappenfarbgebung;Tingierung
-Wappenbeschreibung;Blasonierung
-Kübelhelm;Helmvaz (mittelhochdeutsch);Topfhelm (Hauptform);Fasshelm
-Brillenhelm;Vendelhelm;Nordischer Kammhelm
-Nordmann;Wikinger (Hauptform)
-Schwager (Anredeform);Postkutscher;Postillon (franz.)
-Schwager;Schwäher (veraltet)
-Schwäher;Schwiegervater
-von vorne bis hinten;von A bis Z;von Kopf bis Fuß;auf der ganzen Linie;vom Scheitel bis zur Sohle
-bis es nicht mehr weiter geht;bis zum Anschlag
-Phosphorwasserstoff;Phosphin (veraltet);PH3 (Abkürzung, chemisch);Monophosphan
-Chemilumineszenz;Chemolumineszenz
-kaltes Leuchten;Lumineszenz
-angeregte kurzzeitige Lichtemission;Fluoreszenz
-Fluoreszenzfarbstoff;Fluorochrom
-Phosphoreszenz;strahlende Desaktivierung;kaltes Nachleuchten
-Grünkreuz;Grünkreuzgranate
-TNP (Abkürzung);Weltersches Bitter;Pikrinsäure (Hauptform);Trinitrophenol;2,4,6-Trinitrophenol (fachspr., chemisch)
-Bugle (engl.);Clairon (franz.);Signalhorn (Hauptform)
-sonografische Feindiagnostik;Feinultraschall;Fehlbildungsultraschall
-Serosa;Chorion
-Chordozentese;Nabelschnurpunktion
-internetbasiertes Fernsehen;Internet-Fernsehen;Smart TV (als nutzbares Medium) (Hauptform);Fernsehen über (das) Internet
-Smart TV (Fernsehgerät);internetfähiger Fernseher;internetfähiges Fernsehgerät
-den ganzen Mann (er)fordern;die ganze Frau (er)fordern;vollen Einsatz verlangen
-Beziehungsklasse;Assoziationsklasse
-Teufelszwirn;Gemeiner Bocksdorn;Gemeiner Teufelszwirn;Lycium barbarum (fachspr., griechisch, lat.);Gewöhnlicher Bocksdorn
-Chinesischer Bocksdorn;Lycium chinense (fachspr., lat.)
-Irokesenschnitt;Iro (ugs., Abkürzung)
-verschärfter Verweis;Direktoratsverweis
-Innenwelttheorie;Hohlwelttheorie;Innenweltkosmos
-geozentrisches Weltbild (Astronomie, historisch);aristotelisches Weltbild (Astronomie, historisch);ptolemäisches Weltbild (Astronomie, historisch)
-Hirschhornwegerich;Plantago coronopus (fachspr., griechisch, lat.);Schlitz-Wegerich;Ziegenbart;Krähenfuß-Wegerich (Hauptform);Schlitzblatt-Wegerich;Kapuzinerbart;Hirschhorn-Wegerich;Mönchsbart
-Breitblättriger Wegerich;Großer Wegerich;Breitwegerich (Hauptform);Wegebreit;Wegtritt;Rippenblatt;Saurüssel;Plantago major (fachspr., griechisch, lat.);Wegerich;Wegetrene;Ackerkraut;Wegeblatt;Mausöhrle;Arnoglosse
-Wegerichgewächse (Hauptform);Plantaginaceae (fachspr., griechisch, lat.);Ehrenpreisgewächse
-Spitzwegerich (Hauptform);Schlangenzunge;Spießkraut;Plantago lanceolata (fachspr., griechisch, lat.);Lungenblattl
-Blattstiefel;Ochrea (fachspr.);Tute
-Chenopodium bonus-henricus (fachspr., griechisch, lat.);Guter Heinrich (Hauptform);Blitum bonus-henricus (fachspr., griechisch, lat.);Grüner Heinrich;Wilder Spinat
-Amaranthaceae (fachspr.);Fuchsschwanzgewächse
-Knöterichgewächse;Polygonaceae
-Betelnuss (Hauptform);Arekanuss
-Spitzkohl;Spitzkraut
-Gemüsekohl;Brassica oleracea (fachspr., lat.)
-Filderkraut;Filderspitzkraut
-kopernikanische Wende (auch figurativ, Hauptform);kopernikanische Revolution;Ende des geozentristischen Weltbilds
-Kampfeinsatz (an der Front);Frontbewährung (NS-Jargon, verhüllend)
-Stachelpalme;Pfirsichpalme (Hauptform);Bactris gasipaes (fachspr., griechisch, lat.)
-Palmenherz;Palmherz;Palmito
-Kohlpalme (Hauptform);Euterpe oleracea (fachspr., griechisch, lat.);Assaipalme;Acaipalme
-Attalea speciosa (fachspr., griechisch, lat.);Cusipalme;Babacupalme;Kohlpalme;Babassupalme
-Jucarapalme;Jussarapalme;Kohlpalme;Euterpe edulis (fachspr., griechisch, lat.)
-nicht von jemandes Seite weichen;in jemandes Nähe bleiben;nahe bei jemandem bleiben
-Air;Aria;Ayr;Ayre
-Volkslied (Hauptform);Gassenhauer;Bauerngesang;Cantio rusticalis (lat.)
-Castra Vetera (lat.);Xantum;Xanten (Hauptform)
-elektrische Stromstärke;Stromintensität (veraltet)
-Staatsangehörigkeitsausweis (Hauptform);Staatsbürgerschaftsnachweis (österr.);Staatsangehörigkeitsurkunde (bayr.);Bürgerrechtsnachweis (schweiz.)
-nicht mehr zum Einsatz kommen;nicht mehr eingesetzt werden;keine Verwendung (mehr) haben (für);nicht mehr gebraucht werden;ausgedient haben
-falsch interpretiert werden (können);falsch verstanden werden (können);(ein) falsches Signal (sein) (Jargon, fig., floskelhaft)
-Das willst du (gar) nicht wissen. (ugs., Spruch);Stell keine dummen Fragen. (ugs.);frag mich nicht (woher / wie / wer ...) (ugs.);ich hab da so meine ... (ugs.)
-(jemandem seinen) Rang streitig machen;(jemandem den) Rang ablaufen (wollen)
-Kurmandschi;Nordkurdisch
-Zaza-Sprache (Hauptform);Dimli;Kirmancki;Kirmanjki;Zazaisch;Zazaki
-ausladend;vorstehend;hervorstehend;auskragend;vorgewölbt;hervortretend
-Autoreifen;Pneu (schweiz.);Pelle(n) (ugs., Jargon);Slick (Rennsport)
-behandeln wie ein rohes Ei (fig.);mit größter Sorgfalt behandeln (Hauptform);(gewissermaßen) mit Samthandschuhen anfassen (fig.)
-(jemanden) ausfliegen;auf dem Luftweg außer Landes bringen
-Brandklatsche;Waldbrandpatsche;Feuerpatsche (Hauptform);Brandpatsche
-Lebensekel;Todessehnsucht;Lebensmüdigkeit;Taedium vitae (geh., lat.);Lebensüberdruss
-Pathologie (fachspr., griechisch);Sektionsraum;Prosektur (fachspr., lat., veraltend);Sektionssaal
-Transportmaschine;Frachtmaschine;Transportflugzeug;Frachtflugzeug;Luftfrachter
-verhältnismäßig;pro rata (lat.)
-Hühnerkralle;Kleingrubber;Handgrubber;Gartenhand
-Schwarze Tollkirsche;Waldnachtschatten;Tollkirsche (Kurzform)
-komplementärer Schlupf;Komplementaritätsbedingung
-Numbat;Ameisenbeutler
-Schwebgarnele;Glaskrebs;Schwebegarnele
-Bremsrakete;Retrorakete
-Graupe (ugs., fig.);Opfer (ugs., fig., jugendsprachlich);armer Wicht (ugs., veraltend);Loser (ugs., engl.);Heini (ugs.);Pfeifenheini (ugs.);Krücke (ugs., fig.);Niete (ugs., fig.);Verlierer(typ) (abwertend);Flasche (ugs., fig.);Blindgänger (ugs., fig.);Luschi (ugs.);Pfeife (ugs., fig.);Lulli (ugs.);Wurst (ugs., fig.);Lellek (ugs.);Nichtskönner (abwertend);Null (ugs., fig.);Waserl (ugs., österr.);Versager (Hauptform);Lohle (ugs., schwäbisch);Nullnummer (ugs.);Nulpe (ugs.);(armes) Würstchen (ugs., fig.);Totalausfall (abwertend);Dulli (ugs.);Lusche (ugs.);Schwachmat (ugs.)
-Wintertarnkleidung;Schneetarnkleidung
-Aquatic-Ape-Theorie;Wasseraffentheorie
-Augenspiegel;Ophthalmoskop (griechisch)
-Sondereffekt;Sonderfaktor
-Zeilenleuchte;Linienleuchte
-Schaffnerpult;Schaffnerkanzel;Schaffnerplatz;Kondukteursitz (schweiz.);Schaffnersitz;Schaffnerarbeitsplatz;Schaffnersitzplatz;Billeteursitz (schweiz.);Schaffnerthron
-Schaffnerkabine;Kondukteurkabine (schweiz.);Billeteurkabine (schweiz.)
-Zahlteller;Zahlschale
-Schnellwechsler;Galoppwechsler
-Münzwechsler;Geldwechsler;Münzgeldwechsler
-Verzögerungsstreifen;Ausfädelungsstreifen
-BAB (Abkürzung);Bundesautobahn
-Beschleunigungsspur (fachspr., veraltet);Einfädelungsstreifen;Beschleunigungsstreifen
-Buchingerfasten;Heilfasten
-Cordierit;Dichroit (veraltet)
-Kalknatronfeldspat;Plagioklas
-Fristversäumnis (fachspr., juristisch);Fristversäumung (fachspr., juristisch)
-Pyrolyse (griechisch, Hauptform);pyrolytische Zersetzung (griechisch)
-Biomassekonversion;Biomasseumwandlung
-Flash-Vakuum-Pyrolyse;Blitz-Vakuum-Pyrolyse
-Plasma-Schmelzschneiden;Plasmaschneiden (Kurzform)
-Torrefizierung;Torrefikation
-Rettungsflugzeug;Sanitätsflugzeug;Ambulanzflugzeug
-Gruppenisolierung;Kohortenisolierung;Kohortierung (fachspr.)
-Rivier;(nur) zeitweilig wasserführender Fluss;Creek (engl.);Trockenfluss (fachspr.);Wadi (arabisch);Trockental (fachspr.)
-muss ... (Partizip Perfekt) werden;...bedürftig (Hauptform);verlangt nach ...;verlangt (ein/e) ...;(ohne etwas) nicht gehen (ugs.);braucht (ein/e) ... (ugs.);erfordert (ein/e) ...;(es) bedarf ... (Substantiv im Genitiv) (geh.)
-Namibisch-Deutsch;Namdeutsch (fachspr.);Deutsch in Namibia;Südwesterdeutsch
-semiarid (fachspr.);(mit saisonalem) Wechsel zwischen arid und humid;mit einer (jährlichen) Trockenzeit;halbwüstenartig
-Galerievegetation;Ufervegetation (entlang eines Flusses)
-(die) Ufer säumender Wald(streifen);Galeriewald
-Drehpunkt;Hypomochlion (fachspr., griechisch)
-Venenarzt;Angiologe (fachspr.);Arzt für Gefäßerkrankungen;Phlebologe (fachspr.);Gefäßarzt
-Tischgemeinschaft;Backschaft (fachspr., seemännisch)
-kräftig gebaut (Hauptform);massig;wuchtig;stramm
-vor der Küste (liegend);vorgelagert (Inseln);küstennah
-Pressetermin;Presseveranstaltung;Pressekonferenz
-(im) Zentrum der öffentlichen Aufmerksamkeit;(im) Fokus der Medienöffentlichkeit
-Einstimmigkeitsprinzip;Unanimitätsprinzip
-Richtig-negativ-Rate (fachspr.);Spezifität (fachspr.)
-namens (einer Person, eines Unternehmens, einer Institution ...);in jemandes Namen;(stellvertretend) für (ugs.)
-sprechen (für);in jemandes Auftrag sprechen
-Petroleumäther;Petroläther;Benzinum medicinale (fachspr., lat.);Petrolether (Hauptform);Wundbenzin;(niedrigstsiedendes) Leichtbenzin
-Isopropylalkohol (Hauptform);iso-Propanol;Petrohol;Dimethylcarbinol;2-Propanol (Hauptform);Propan-2-ol;IPA (Abkürzung);Petrosol;Persprit;Isopropanol (Hauptform);Propol
-Konsultation(en);Verhandlung(en);Gespräche (fig.)
-...akzent;Betonung
-(sich) einen Bart wachsen lassen;(sich) einen Bart stehen lassen;(sich) einen Bart zulegen (ugs.)
-(sich) nicht beklagen können (ugs.);(etwas) eigentlich nicht verdient haben (ugs.);gut wegkommen (bei) (ugs.)
-Kredite am Laufen haben;Schulden (bei der Bank) haben
-das Ende ist nah;es geht zu Ende
-hab ich's nicht gewusst!?;na bitte!;Bingo!;als wenn ich's nicht geahnt hätte!
-Du wirst schon sehen, was du davon hast. (ugs., Spruch);Du willst es (ja) nicht anders. (ugs.);Tu, was du nicht lassen kannst. (Spruch)
-Bauerntrick (fig.);billige Masche (ugs.)
-Luria-Delbrück-Experiment;Fluktuationstest
-(sich) beteiligen (bei);(Geld) anlegen (bei);Anteile erwerben (von);(sich) einkaufen (bei)
-Schwendtag (bairisch);verworfener Tag;Nöttelestag (elsässisch)
-Zahlensymbolik;Zahlenmystik;Numerologie
-Momentum;günstiger Zeitpunkt (für)
-Traditionalist;Bewahrer des Bestehenden
-Vergangenheitsbewältigung;Aufarbeitung der Vergangenheit
-Fleischkonsum;Fleischverzehr
-Fahr endlich!;Fahr zu!;Es ist Grün!;Grüner wird's nicht. (ugs., Spruch, scherzhaft-ironisch);Grün! (ugs.)
-Sahnefest (Markenname);Sahnestandmittel (Hauptform);Sahnesteif (Markenname);Sahnefestiger;Rahmhalter (schweiz.)
-in Mehl wenden;mehlieren (fachspr.);mit Mehl bestäuben;in Mehl wälzen;farinieren (fachspr., österr.)
-Handmixer;Handrührer;Schneeschläger;Rührstab;Handrührgerät;Rührgerät
-Protonenanlagerung;Protoneneinfang
-Sahnesiphon;Sahnespender
-durch Bomben(hagel) zerstört;kaputtgebombt (ugs.);zerbombt
-Stein der Weisen;Lapis philosophorum (lat.)
-Mutter Gottes (christlich);(heilige) Maria (christlich, Hauptform);Gottesmutter (christlich);Maria Immaculata (geh., christlich, lat.);Maria von Nazaret;Jungfrau Maria (christlich)
-Madonna (Hauptform);Mariendarstellung;Marienbild;Marienstatue
-Duckmäuser;Sklavenseele
-Gruppenintelligenz;Schwarmintelligenz (ugs., Hauptform);kollektive Intelligenz
-Brustpanzer;Plastron (franz.)
-Carapax (fachspr., griechisch);Rückenpanzer;Rückenschild
-Hautknochenplatte;Osteoderm (fachspr., griechisch)
-Os frontale (fachspr., lat.);Stirnbein
-Arcus superciliaris (fachspr., lat.);Augenbrauenbogen
-Stirnglatze;Glabella (fachspr., lat.)
-Steppenschildkröte;Testudo horsfieldii (fachspr., griechisch, lat.);Russische Landschildkröte;Agrionemys horsfieldii (fachspr., griechisch, lat.);Vierzehenschildkröte (Hauptform)
-Scampo (Singular, ital.);Scampi (Plural, ital.)
-Metanephrops japonicus (fachspr., griechisch, lat.);Japanischer Hummer
-Augenbrauenwulst (fälschlich);Überaugenwulst (Hauptform);Torus supraorbitalis (fachspr., lat.)
-Marseiller Seife;Savon de Marseille (franz.)
-Aleppo-Seife;Sabun al-Ghar (arabisch);Sabun Halabi (arabisch);syrische Lorbeerseife
-Kalziumseife;Kalkseife;Calciumseife
-Transparentseife;Glycerinseife
-die Geduld verlieren (Hauptform);mit seiner Geduld am Ende sein;(jemandem) platzt der Kragen;(jemandem) reißt der Gelduldsfaden
-Sperrschicht;Verarmungszone;Raumladungszone
-Hinterlassenschaft(en);Unerledigtes;Liegengebliebenes;unfertig Hinterlassenes
-Zurückgelassenes;Hinterlassenschaft(en);Liegengelassenes;Aufgegebenes
-R14;C;Babyzelle;C-Zelle;C-Batterie;Baby
-elektrisch laden;elektrisch aufladen;aufladen
-Transistor (engl.);Transistron (veraltet)
-D;D-Zelle;R20;D-Batterie;Mono;Monozelle
-Mignon;Mignonzelle;AA;AA-Zelle;Doppel-A-Batterie;R6
-Micro;Mikrozelle;AAA;AAA-Zelle;R03;Microzelle;Tripel-A-Batterie
-Flachbatterie (Hauptform);3R12
-Zelten;Camping (engl.)
-Caidal;Beduinenzelt
-Chaima (arabisch);Schwarzzelt;Khaima (arabisch);al-Haima (arabisch);Haima (arabisch);Berberzelt
-Zurückbleibendes;Bleibendes;Hinterlassenschaft(en)
-Kantensteckverbinder;Platinenstecker (Hauptform);Edge Connector (engl.);Randstecker
-Valenzbindungstheorie;Resonanztheorie
-Elektrodynamik;Elektrizitätslehre;klassische Elektrodynamik
-Kekulé-Formel;mesomere Grenzformel
-Retinaphtha;Methylbenzen;Anisen;Phenylmethan;Methylbenzol;Methylbenzen;Toluol (Hauptform);Toluen
-My home is my castle. (Sprichwort, engl.);Es geht nichts über ein eigenes Zuhause.
-Sphäroguss;Kugelgraphitguss
-(an der Oberfläche) entstehen;(sich oberflächlich) bilden;ansetzen (Rost, Schimmel, Moos)
-(etwas) mit ... Euro anschlagen (ugs.);(sich einen) Preis überlegen (ugs.);(für etwas) ... Euro ansetzen (ugs.);(einen Preis) anschlagen (ugs., regional);(einen) Preis ansetzen (ugs.);(eine) Preisvorstellung entwickeln
-Sonnenschirmhalter;Sonnenschirmständer;Sonnenschirmhalterung
-wie bitte?;wat? (ugs., norddeutsch);hä? (derb)
-ey! (ugs.);he! (ugs.);hey!
-vertrauliche Details;Innenansicht(en);Einblick(e)
-vertrauliche Details;Innenansicht(en);Einblick(e)
-Einblick(e);vertrauliche Details;Innenansicht(en)
-Innenansicht(en);Einblick(e);vertrauliche Details
-vertrauliche Details;Einblick(e);Innenansicht(en)
-Innenansicht(en);Einblick(e);vertrauliche Details
-Einblick(e) (fig.);vertrauliche Details;Innenansicht(en) (fig.)
-vertrauliche Information;Vertraulichkeit
-Vertraulichkeit;vertrauliche Information
-brachliegen (fig.);(im Verborgenen) schlummern (fig.);nicht abgerufen werden;auf seinen Einsatz warten
-(sich) gegenseitig beeinflussen;(sich) überschneiden;interferieren;(sich) überlagern
-Experimentum crucis (lat.);Gegenprobe (Hauptform)
-Kopfsteg (fachspr.);Seitenrand oben (ugs.);oberer Seitenrand
-unterer Seitenrand;Seitenrand unten (ugs.);Fußsteg (fachspr.)
-Innensteg;Bundsteg
-Seitenrand außen (ugs.);Außensteg (fachspr.)
-Stetigförderer;Elevator
-Dampfautomobil;Dampfkraftwagen;Dampfwagen (Kurzform)
-Automobil (geh.);Motorwagen (Amtsdeutsch, schweiz.);Auto (Kurzform);Kraftwagen
-Ansitzjäger;Lauerjäger
-Isotopeneffekt;Isotopieeffekt
-Nuklid;Isotop;Atomart
-Isomer;Kernisomer
-Oxiran;Epoxid;Epoxyd
-privat genutzte Pkw;(Nutzung von) Privatfahrzeuge(n);Individualverkehr (fachspr., Amtsdeutsch)
-Badzubehör;Badutensilien;Badaccessoires
-Funken schlagen;Funken erzeugen
-Handkreisel;Fidget Spinner (engl.)
-Trainingskugel;Qi-Kugel;Qigongkugel;Klangkugel;Qi-Gong-Kugel;Baodingkugel;Entspannungskugel;Chi-Gong-Kugel
-Gestaltwandler;Formwandler;Metamorph (griechisch)
-Kamee;Kameo;Cameo;Camée
-Befreiung;Relevation (juristisch, lat., veraltet);Entbindung
-Reliefbild;Relief
-bW (veraltet);Voltampere Reaktiv;Blindwatt (veraltet);Var (Hauptform)
-Duftreis;Jasmin-Reis;Siam-Reis
-afrikanischer Reis;Oryza glaberrima (fachspr., griechisch, lat.)
-Fahnenlehen;Fahnlehen
-Klippenadler (Hauptform);Aquila verreauxii (fachspr., lat.);Kaffernadler
-Lämmergeier;Bartgeier;Gypaetus barbatus
-Kuttengeier;Aegypius monachus (fachspr., griechisch, lat.);Mönchsgeier (Hauptform)
-Raubadler (Hauptform);Savannenadler;Aquila rapax (fachspr., griechisch, lat.)
-Haliaeetus leucocephalus (fachspr., griechisch);Weißkopfseeadler
-Seeadler;Haliaeetus albicilla (fachspr., griechisch, lat.)
-Aquila adalberti (fachspr., lat.);Spanischer Kaiseradler
-Östlicher Kaiseradler;Aquila heliaca (fachspr., lat.)
-Verwirrung stiften (Hauptform);für Durcheinander sorgen;Konfusion schaffen;für Chaos sorgen (bei);(Leute) durcheinanderbringen
-(die) Anwälte (eines Unternehmens, einer Institution) (ugs.);Fachabteilung für Rechtsfragen;Rechtsamt (Kommunalverwaltung);Justitiariat (fachspr.);Rechtsabteilung (Hauptform);Justiziariat (fachspr.)
-Rechtsgutachter;Rechtssachverständiger
-noch grün hinter den Ohren (ugs., fig.);naiv;weiß nichts vom Leben (ugs.);weiß nichts von der Welt (ugs.);unerfahren;muss (im Leben) noch viel lernen (ugs.);noch feucht hinter den Ohren (ugs., fig.)
-Milchbauer;Milchviehhalter
-die Meinen (geh.);meine Familie;meine Angehörigen
-Typoskript (fachspr.);Maschinenmanuskript
-stenografieren;in Kurzschrift schreiben;(sich) stenographisch notieren
-Fabriktran (veraltet);Lebertran
-Hypervitaminose;Vitaminüberversorgung
-in den Krieg ziehen (gegen);losziehen (gegen);(es) geht gegen;in den Kampf ziehen (gegen);in die Schlacht ziehen (gegen);zu Felde ziehen (gegen)
-Motorsense (Hauptform);Freischneider (Hauptform);Rasentrimmer;Kantentrimmer;Grastrimmer
-Rasenkantenstecher;Kantenstecher (Hauptform);Kantenschneider;Kantentrimmer
-versäubern;trimmen
-gut gerüstet (für) (fig.);gut vorbereitet (auf) (Hauptform);gut aufgestellt (für) (fig.)
-Sprachhandlung;Sprechakt (fachspr., Hauptform);performative Äußerung;performativer Akt
-Unternehmensform;Rechtsform (eines Unternehmens);Gesellschaft(sform)
-Gesellschaft bürgerlichen Rechts;GbR
-lineare Beschaffenheit;Linearität (Hauptform);Geradlinigkeit
-degenerierte Materie;entartete Materie
-variable Kopfzeile(n);lebender Kolumnentitel (fachspr.)
-Kugelhaufenreaktor;KHR (Abkürzung)
-Diorganopolysiloxan (fachspr.);Silikonöl
-Hahnfett;Schlifffett (Hauptform);Exsikkatorfett
-Schliff;Normschliff
-Schliffklammer;Schliffklemme
-Brechungsgesetz;Snellius-Gesetz;Snelliussches Gesetz;Snelliussches Brechungsgesetz
-karolingische Minuskel (Hauptform);Carolina;karlingische Minuskel
-Charlemagne (franz.);Karolus Magnus (latinisiert);Karl der Große (Hauptform);Carolus Magnus (lat.)
-Aachen (Hauptform);Aix-la-Chapelle (franz.);Oche (regional);Aken (niederländisch);Aquae Granni (lat.)
-bewegende Stunde;schwere Stunde;Stunde großer Trauer
-harter Schlag (für jemanden) (ugs.);(persönliche) Katastrophe;Schicksalsschlag
-(eine) Folge (von);(eine) Serie (von);...serie;(eine) Strecke (von);...strecke (fachspr., Jargon);(eine) Staffel (von)
-Strecke (fachspr., Jägersprache);Jagdstrecke (fachspr.);(gesamtes bei einer Jagd) erjagtes Wild
-über die ganze Stadt verteilt;stadtweit;in der ganzen Stadt;überall in der Stadt
-Deutsche Nationaltracht;Altdeutsche Tracht
-auf den Rücken nehmen;huckepack nehmen;huckepack tragen;(sich) auf den Buckel laden (ugs.);auf dem Rücken tragen
-als zusätzliche Ladung;huckepack (transportieren);(oben / hinten) aufgeladen;als Beiladung
-logarithmische Normalverteilung;Log-Normalverteilung (Kurzform)
-Bose-Einstein-Verteilung;Bose-Einstein-Statistik
-Boltzmann-Statistik;Boltzmann-Verteilung;Gibbs-Boltzmann-Verteilung
-Boole-Verteilung;Null-Eins-Verteilung;Bernoulli-Verteilung;Alternativ-Verteilung
-diskrete Verteilung;diskretes Wahrscheinlichkeitsmaß;diskrete Wahrscheinlichkeitsverteilung
-Dirac-Verteilung;Einheitsmasse;degenerierte Verteilung;Punktverteilung;deterministische Verteilung
-klassische hypergeometrische Verteilung;hypergeometrische Verteilung
-Multinomialverteilung;Polynomialverteilung
-Pascal-Verteilung;negative Binomialverteilung
-Poisson-Binomialverteilung;verallgemeinerte Binomialverteilung;Poissonsche Verallgemeinerung der Binomialverteilung
-verallgemeinerte hypergeometrische Verteilung;polyhypergeometrische Verteilung;allgemeine hypergeometrische Verteilung;multivariate hypergeometrische Verteilung
-Arcsin-Verteilung;Arkussinus-Verteilung
-Dreiecksverteilung;Simpsonverteilung
-Exponentialverteilung;negative Exponentialverteilung
-Fisher-Verteilung;F-Verteilung;Fisher-Snedecor-Verteilung
-Gumbel-Verteilung;Fisher-Tippett-Verteilung;Extremal-I-Verteilung
-Wald-Verteilung;inverse Normalverteilung;inverse Gauß-Verteilung
-Klasse von Verteilungen;Verteilungsklasse;Verteilungsfamilie;Familie von Verteilungen
-Exponentialfamilie;exponentielle Familie
-Doppelexponentialverteilung;zweiseitige Exponentialverteilung;Laplace-Verteilung
-Log-Gammaverteilung (Kurzform);Logarithmische Gammaverteilung
-Chi-Quadrat-Verteilung;Helmert-Pearson-Verteilung
-Rossi-Verteilung;gemischte Extremwertverteilung
-Rechteckverteilung;kontinuierliche Gleichverteilung;Uniformverteilung;stetige Gleichverteilung
-Lomax-Verteilung;verschobene Pareto-Verteilung
-Lorenzkurve;Lorenz-Kurve;Disparitätskurve
-Größte-Dichte-Methode;Methode der maximalen Mutmaßlichkeit;Methode der größten Dichte
-Schätzmethode;Schätzverfahren
-multivariate Normalverteilung;mehrdimensionale Normalverteilung
-bivariate Normalverteilung;zweidimensionale Normalverteilung
-ein weiterer (eine weitere / ein weiteres + Substantiv) (geh.);noch ein (noch eine + Substantiv)
-neu im Spiel (ugs., fig.);neu am Start (ugs., Jargon, fig.);neuer Mitbewerber;neu am Markt
-Einsatzmesser;Überlebensmesser;Feldmesser;Fahrtenmesser
-Fehlschärfe;Ricasso (ital.)
-Erl (fachspr.);Angel (Messer) (fachspr.)
-nicht lange bleiben (können);gleich weitermüssen (ugs.);gleich wieder wegmüssen (ugs.);(sich) nicht lange aufhalten (wollen) (ugs.)
-Körpernetz;Auffaltung;Netz
-Kohlenstoffstahl;Karbonstahl
-Zwischenstufengefüge;Bainit
-Modist;Putzmacher (veraltet)
-Gnitze;Bartmücke;Gnitte (regional)
-Blauzungenkrankheit;Maulkrankheit
-steuerlich geltend machen (fachspr.);(von der Steuer) absetzen (ugs., Hauptform)
-(jemandem) ein Rätsel sein (Hauptform);vor einem Rätsel stehen (fig.);auf magische Weise;Gute Frage! (im Dialog) (ironisierend);auf unerklärliche Weise;auf mysteriöse Weise;unerklärlicherweise;(für jemanden) ein Mysterium sein (geh.);(für etwas) keine Erklärung haben;(jemandem) schleierhaft sein;(sich etwas) nicht erklären können;mysteröserweise;auf rätselhafte Weise
-Schaumbeton;PLB (Abkürzung);Porenleichtbeton
-Enzephalozele (Hauptform);Hirnbruch;äußerer Hirnprolaps;Hirnhernie;Hernia cerebri (fachspr., lat.)
-kanzlertauglich;kanzlerabel (scherzhaft)
-taugt zur Ministerin;ministertauglich;für ein Ministeramt geeignet;ministrabel;taugt zum Minister
-Informationsflut;Informationsüberflutung
-Bockerl;Bockerlbahn
-pur;sortenrein
-Tötung eines neugeborenen Kindes;Neonatizid;Neugeborenentötung
-einfließen lassen (fig.);aufgreifen;(mit) hineinnehmen;einbeziehen;verbinden (mit)
-Verwahrgebühr;Einlagenentgelt;Negativzinsen;Verwahrentgelt;Strafzinsen
-einander vorstellen;(sich miteinander) bekannt machen;(sich gegenseitig) vorstellen
-Interessent;potentieller Kunde
-Sommerschnee;Pappelwolle;Pappelbaumwolle;Pappelschnee;Pappelflaum;heimische Baumwolle
-Pflanzendaune;Kapok;Kapuk
-(etwas) übertönen;untergehen (in) (fig.);lauter sein als
-Indianer-Seidenpflanze;Seidenpflanze;Asclepias curassavica (fachspr., griechisch, lat.);Seidenblume;Curaçao-Seidenpflanze
-emetogen;emetisch;Brechreiz erregend
-Chylus;Darmlymphe
-Moleskin (engl.);Pilotstoff;Englischleder
-beklommen;voll unguter Ahnungen;ängstlich gespannt;bedrückt
-Pechelbronner Schichten;Pechelbronn-Formation;Pechelbronn-Gruppe
-Pfälzerwald (amtlich);Pfälzer Wald
-stiefmütterlich behandelt;emotional vernachlässigt (fachspr.);ungeliebt
-(den) Mund zukneifen;(die) Lippen zusammenpressen
-Höchstalarm;Alarmstufe Rot;Code Red (engl.)
-Der ist für dich!;Da kuckst du (jetzt aber), was!? (ugs., norddeutsch);Gell do schaugst! (ugs., bairisch);Nimm das! (altertümelnd, scherzhaft)
-Kassenverein;Zentralverwahrer;Wertpapiersammelbank
-Wertpapierdepotgeschäft;Effektenverwaltung;Depotgeschäft (Kurzform)
-Wertpapierdepotkonto;Wertpapierdepot
-Arbeitswertanalyse;Leistungswertanalyse;Fertigstellungswertmethode
-Vibrato;Bebung
-Patchwork;Flickenteppich;Flickwerk;Flickarbeit
-Eingeweidekasten;Kanopenkasten;Kanopentruhe
-Spartenprogramm;Spartensender;Zielgruppenprogramm
-Unumkehrbarkeit;Irreversibilität
-Reversibilität;Umkehrbarkeit
-Serifenlose Linear-Antiqua;Grotesk
-Spurlager;Längslager;Axiallager;Drucklager
-Kugelbüchse (ugs.);Linearkugellager;Linearlager (Kurzform);Kugelbuchse (ugs.)
-atelisches Verb;imperfektives Verb
-avalentes Verb;nullwertiges Verb
-monovalentes Verb;einwertiges Verb
-Vorgangsverb;Verlaufsverb
-ingressives Verb;inchoatisches Verb;Inchoativ;Inchoativum
-Tätigkeitsverb;Handlungsverb;Aktivitätsverb
-telisches Verb;perfektives Verb;terminatives Verb
-Kanopengefäß;Kanope
-Kanopenvase;Kanopenkrug
-Geschlechtsumwandlung;Geschlechtsangleichung;geschlechtsangleichende Operation;GA-OP (Abkürzung)
-keinen anderen Gedanken haben (als);Panik schieben (ugs., Jargon, übertreibend);(sich) einen Kopf machen (ugs.);(total) in Panik (sein / geraten) (ugs., übertreibend);(sich) (viele) Gedanken machen (über) (ugs.)
-Van-Diemens-Land (veraltet);Tasmanien;Tasmania (engl.)
-Olivenkamm;Olivenrechen
-Holzplanke;Holzdiele;Holzbohle
-Badelifter;Badewannenlifter
-Kwajalein;Kwajalein-Atoll;Mentschikowinseln
-Marshallinseln;Marshall-Inseln
-Honorificum (lat.);Honorifikum (lat.);Honorativ (lat.);Honorativum (lat.);Höflichkeitsform
-im Außenbereich (technisch);indoor (engl.);in geschlossenen Räumen;drinnen (ugs.);in Innenräumen
-Zustrom;Fütterung (mit ...);Input (an) (Hauptform)
-Sicht von außen;Außensicht;fremder Blick (auf);Außenansicht;Außenwahrnehmung;Perspektive von außen;Wahrnehmung von außen
-Außenwahrnehmung;Wahrnehmung seiner Umwelt
-Blick nach innen;Innensicht;Introspektion
-Hörgerät;Hörsystem
-Farbfeldmalerei (Hauptform);Farbflächenmalerei;Color Field Painting (engl.)
-Post-Painterly Abstraction (engl.);Nachmalerische Abstraktion;Neue Abstraktion
-angewandte Kunst;Gebrauchskunst
-Schöne Künste (Pluraletantum);Die Schönen Künste (Pluraletantum)
-Freie Künste;Septem Artes Liberales (lat.);Studia Liberalia (lat., selten);Sieben freie Künste;Die sieben freien Künste
-Dreiweg;Trivium (Hauptform, lat.)
-Scholastik;mittelalterliche Beweisführung
-Vierweg;Quadrivium (Hauptform, lat.)
-Niedriglohnland;Billiglohnland (ugs.)
-Anemogeochorie (fachspr., griechisch);Chamaeanemochorie (fachspr., griechisch);Chamaechorie (fachspr., griechisch)
-Ausbreitungsstrategie;Ausbreitungsmechanismus
-Semachorie (fachspr., griechisch);Stoßausbreitung
-ein beliebiger (eine beliebige / ein beliebiges);ein aus der Luft gegriffener (eine aus der Luft gegriffene / ein aus der Luft gegriffenes);irgendein(e)
-Asienspiele;Panasiatische Spiele
-Funktionsprototyp;Funktionskopf
-Landeplatz (ugs.);Start- und Landeplatz
-letzte Ausbaustufe;Endausbau
-maschinell;mit Maschinenkraft;mit Hilfe von Maschinen;automatisiert
-maschinenartig;roboterhaft;maschinesk (geh., literarisch);mechanisch;maschinenmäßig
-monoton;immergleich;immer (wieder) gleich;gleichförmig
-fühllos (geh.);gefühllos;seelenlos
-Prozesskalkül;Prozessalgebra
-Syriakisch;syrische Sprache
-Endoprothese;Gelenkersatz
-Tower (ugs., Hauptform);Flughafentower;Kontrollturm;Flugverkehrskontrollturm (fachspr., Amtsdeutsch)
-periartikuläre Fibrositis (veraltet);Periarthritis;Fibrositis der Gelenkhüllen (veraltet)
-Fibromyalgie;Fibromyalgiesyndrom
-(jemandem) einen Streich spielen;(jemandem) eins auswischen
-(jemand kann einem) gestohlen bleiben (mit);(sich etwas) sonstwo hinstecken (können) (aggressiv, fig., variabel);(etwas) nicht haben wollen (Hauptform);(sich etwas) in die Haare schmieren können (ugs.);keinen Wert legen (auf);scheißen (auf) (derb);(auf etwas) (gut) verzichten können
-Bordlautsprecher (Fahrzeug, PC);eingebauter Lautsprecher
-Kojote (aztekisch, Hauptform);Präriewolf;Coyote (aztekisch, engl.);Canis latrans (fachspr., lat.);Steppenwolf
-nach dem Gießkannenprinzip (fig.);mit der Gießkanne (fig.);im Gießkannenverfahren (fig.)
-Antares (Hauptform);Alpha Scorpii (griechisch, lat.);Vespertilio
-nach dem Motto 'Es ist genug für alle da';nach dem Motto 'Wer will noch mal, wer hat noch nicht?'
-Toledanischer Ritus (selten);mozarabische Liturgie;westgotische Liturgie;Isidorianischer Ritus (selten);altspanische Liturgie;mozarabischer Ritus
-Würgegriff;Umklammerung;Fuchtel (ugs.);Dominanz
-(jemanden) zu Tisch rufen;(jemanden) zu Tisch bitten
-Koch oder Kellner (sein) (fig.);Hammer oder Amboss (sein) (fig., veraltend)
-Wenn der Kuchen spricht, haben die Krümel Pause. (sprichwörtlich);Hast du auch schon was zu sagen? (ugs.)
-(etwas) steht jemandem nicht zu;(da) wedelt der Schwanz mit dem Hund (fig., variabel)
-Egalstrom;Graustrom (Hauptform)
-Kastagnette (franz.);Handklapper;Krotalon (griechisch);Kastanuela (spanisch)
-(jemandes ...) kaufen (ugs.);(etwas) von jemandem kaufen;(jemandes ...) erwerben;(jemandem etwas) abkaufen
-Kegelschleppsonde;Schleppkegel
-Kannst du mir kurz ,,, leihen?;Kannst du mir mal ... geben?;Hast du mal ... (für mich)?
-Perlwein;Sternwein (schweiz.);Sternliwein (schweiz.)
-(das) Weinen (mühsam) unterdrücken;mit den Tränen kämpfen (Hauptform);(seine) Tränen zurückhalten
-Mitgeschöpf;Zeitgenosse
-lind;sacht;leicht;kaum merklich
-Konkurrenztermin;Paralleltermin
-(ein) Stoßgebet zum Himmel schicken;um göttlichen Beistand bitten
-gemäß;ausweislich (+ Genitiv) (fachspr., Amtsdeutsch, Papierdeutsch);nach;laut;zufolge
-Suchtverlagerung (fachspr., medizinisch, psychologisch);Umstieg auf anderes Suchtmittel
-Drahtverhau (Hauptform);Stacheldraht-Absperrung;(Stachel-) Drahtgeflecht;Drahtsperre (fachspr.);Stacheldrahtbarriere
-Zwischenstation;Zwischenstop;Zwischenaufenthalt;Stopover (fachspr., Jargon)
-Reiseunterbrechung;ungeplanter Aufenthalt;Fahrtunterbrechung
-Elektromotorroller;Elektroroller (Kurzform);E-Roller (Kurzform)
-Bilgepumpe;Lenzpumpe
-matt werden;blind werden (Spiegel, Fenster);trüb(e) werden;(dunkel / trüb / schwärzlich / grün ...) anlaufen;(sich) eintrüben;beschlagen;(den) Glanz verlieren;stumpf werden;(sich) trüben
-Ascotkrawatte (engl.);Plastron (franz., Hauptform);Krawattenschal (Hauptform);Tageskrawatte;Ascot (Kurzform, engl.);Day Cravat (engl.)
-Gehrock;Leibrock (veraltet)
-Stresemann;kleiner Gesellschaftsanzug des Tages;Bonner Anzug
-Cutaway (engl.);Cut (Kurzform, engl.)
-Oratorianerkragen;Guardinikragen
-Auskragung;Vorkragung;Kragen
-Gebäudevolumen;Baukörpergestalt;Kubatur (lat.);Gebäudeform;umbauter Raum
-Zingulum (lat.);Cingulum (lat.)
-Ordo Cisterciensium reformatorum (lat.);OCR (Abkürzung, lat.);Trappist (ugs.);Ordo Cisterciensis strictioris observantiae (lat.);Zisterzienser;OCSO (Abkürzung, lat.);Zisterzienser der strengeren Observanz
-Schulterkleid;Skapulier (Hauptform);Scapularium (lat.)
-Hemdkragen;Kragen
-(etwas) bestreichen;(etwas) bepinseln;(etwas) einpinseln;(mit dem Pinsel etwas) auftragen;(etwas) einstreichen
-Anlauf nehmen;anlaufen
-starten;anfahren;anlaufen;hochfahren
-Brockenstube (schweiz.);Trödelladen;Gebrauchtwarenhandel;Second-Hand-Laden
-Umsonstladen;Verschenkladen;Kost-nix-Laden
-Gib- und Nimm-Regale;Give-Box;Freebox;Tauschregal;Verschenkbox
-(öffentliche) Bücherbox;öffentlicher Bücherschrank;Bücherzelle;öffentliches Bücherregal
-Essensabgabe an Bedürftige;Armenspeisung (fachspr., christlich);Essen für Bedürftige
-Belorusse;Belarusse;Weißrusse;Belarussin (weibl.)
-Geschäftsmann;Business-Mann;Manager(typ);macht sich die Hände (bei der Arbeit) nicht schmutzig;Anzugträger;Unternehmer(typ)
-Märtyrerverzeichnis;Martyrologium
-Anpreiser;Ausrufer;Rekommandeur (franz.)
-mit der Bahn;per Bahn;mit dem Zug
-Natrium-hexakis-cyanoferrat;Natriumferrozyanid;Natriumferrocyanid (Hauptform);Gelbnatron;E 535
-herumjammern;(beredt) klagen (über) (geh.);herumnörgeln (an) (ugs.);jammern (über);herumjanken;rumjammern (ugs.)
-Agrostadt;Agrarstadt
-Wendeeisen;Windeisen
-Gewindeschablone;Gewindelehre;Gewindekamm
-Gewinderollen;Gewindewalzen
-Bengalischer Golf;Bai von Bengalen;Golf von Bengalen (Hauptform);Bengalischer Meerbusen
-umsteigen (auf) (fig.);(etwas) wechseln;übergehen (zu);wechseln (zu)
-Konkordienformel;Bergisches Buch
-Daseinsfürsorge;öffentliche Infrastruktur (schweiz.);Daseinsvorsorge;öffentliche Dienstleistungen (gemeinsprachlich)
-Proportionale;Verhältniszahl;Verhältniszahlwort
-Distributivum;Verteilungszahl;Distributivzahl;Verteilungszahlwort;Einteilungszahl
-Gattungszahlwort;Speziale;Gattungszahl
-Kollektivum;Collectivum;Sammelzahlwort (Hauptform);Sammelzahl;Kollektivzahl
-Teilungszahl;Partitivum;Bruchzahl;Partitivzahl;Bruchzahlwort (Hauptform);Teilungszahlwort
-Gesellschaftszahlwort (Hauptform);Soziativzahlwort;Soziativzahl;Gesellschaftszahl
-Folgezahl;Folgezahlwort;ordnendes Zahladverb
-Zeitzahl;Zeitzahlwort;Temporale
-Zahleigenschaftswort;Zahladjektiv;beiwörtliches Zahlwort;quantifizierendes Adjektiv;eigenschaftswörtliches Zahlwort;adjektivisches Zahlwort;Zahlbeiwort;Numeraladjektiv
-nebenwörtliches Zahlwort;umstandswörtliches Zahlwort;Zahladverb;Numeraladverb;adverbialisches Zahlwort;Zahlumstandswort
-Zahlhauptwort;Zahlsubstantiv
-Quantor;Mengenwort
-Indefinitum (lat.);unbestimmtes Fürwort;Indefinitpronomen
-belebt;animat (fachspr., lat.)
-die Wohnung für sich haben (ugs.);sturmfreie Bude (haben) (ugs., fig.)
-der Reihe nach anrufen;abtelefonieren
-(Prepaid-Guthaben) abtelefonieren;(Geld) vertelefonieren
-telefonisch absagen;abtelefonieren
-Mindest...;ein Minimum an;ein Mindestmaß an
-alle Parkplätze belegen;zuparken;mit (geparkten) Autos zustellen
-zugewachsen (mit);überwuchert (von)
-Opferhaltung;Opferrolle
-positive Zyklovergenz;Inzyklovergenz;Konklination
-negative Zyklovergenz;Disklination;Exzyklovergenz
-Torsionsvergenz;Zyklovergenz
-Serial (fachspr., historisch);Serie (ugs.);Filmreihe;Filmserie (historisch)
-Animation;Motivation;Ermutigung
-Reise ins Unbekannte;Abenteuerreise
-(sich in jemanden) hineinversetzen (ugs.);sich in jemandes Lage versetzen;sich (in jemanden) hineindenken
-(jemanden) zurückversetzen (in die Kindheit usw.);(bei jemandem) Erinnerungen wecken;(bei jemandem Erinnerungen) wach werden lassen;(jemanden in etwas) versetzen
-Ausflug ohne bestimmtes Ziel;Entdeckungstour;Fahrt ins Blaue
-(jemanden) ausschließen (von);(jemanden) verweisen (von);(jemanden einer Sache) verweisen (geh.);(jemanden) verbannen;(jemanden) relegieren (Schule, Uni)
-Kragträgerverfahren;Spannungstrapezverfahren
-Statik (ugs.);Statische Berechnung
-Balkentheorie;Biegetheorie des Balkens
-Zwängung;Zwängsspannung
-Umsatzrückgang;finanzielle Einbußen
-Frunk (engl.);vorderer Kofferraum
-Luftverschmutzung;Luftverunreinigung;Luftschadstoffe;Smog
-letzter Aufrechter;Unbeugsamer
-Lapis serpentina (lat.);Serpentin (lat.);Gemma serpentina (mittellateinisch);Schlangenstein;Lithos ophites (griechisch);Ophit (griechisch)
-Faserserpentinit;Chrysotilasbest (griechisch);Pikrosmin;Weißasbest;Serpentinasbest;Chrysotil (griechisch);Weißer Asbest
-Antigorit;Blätterserpentin
-Strahlstein;Aktinolith (griechisch)
-Bergflachs (veraltet);Amiant;Asbest (Hauptform)
-Grunerit (Hauptform);Amosit;Braunasbest;Grünerit
-Abriachanit;Osannit;Osanit;Blauasbest;Krokydolith;Riebeckit (Hauptform)
-das tun, was alle tun;mit dem Strom schwimmen (fig.)
-... Aufnahme finden;(auf etwas irgendwie) reagieren;sich (...) zeigen;(etwas irgendwie) aufnehmen;(über etwas / angesichts einer Sache) ... sein;(etwas mit ...) entgegennehmen
-(den) Ball aufnehmen (fig.);(einen Gedanken) aufgreifen;(an einen Wortbeitrag / Gedanken) anknüpfen;(einen Gedanken) weiterführen
-(das) sagen, was jemand hören will;(jemandem) nach dem Mund reden;keine eigene Meinung haben
-Schwindsucht (veraltet);Auszehrung
-unkritisch;bedenkenlos;unhinterfragt
-(jemandem) unauslöschlich im Gedächtnis bleiben;(jemandem) unvergesslich sein (positiv);(sich jemandem) ins Gedächtnis einbrennen (fig.);(sich jemandem) tief einprägen
-vorn(e) und hinten nicht reichen (ugs., fig.);nicht im entferntesten genügen (geh.);bei weitem nicht ausreichen (geh.);viel zu wenig sein
-nach der reinen Lehre (fig.);(rein) theoretisch (Adverb);nach der Theorie
-Verhandlungssaal;Gerichtssaal;Sitzungssaal
-vor Gericht;vor dem Richter
-ZFA;Zahnmedizinische(r) Fachangestellte(r) (bundesdeutsch, offiziell);Stomatologische Schwester (DDR, veraltet);Zahnarzthelfer(in) (ugs.);Dentalassistent(in) (schweiz.)
-(sich) richten (nach);(sich) bemessen (nach);abhängen (von)
-verzichten (auf);(etwas) unterlassen;(sich etwas) versagen (geh.)
-Geist;Spirit (Denglisch, Jargon);Bewusstsein;Einstellung
-Ernährungsindustrie;Lebensmittelindustrie (Hauptform)
-materielle Natur;Materialität
-Füllmaterial;Füllstoff;Füllsel
-Füllmaterial;Füllstoff;Füllgut;Füllung
-Jung und Alt;(Menschen) jeden Alters;(es gibt) keine Altersbeschränkung;(Menschen) alle(r) Altersgruppen
-kamerascheu;fotoscheu
-(jemanden) vorsehen (als);(jemanden) nominieren (als);(jemanden) designieren (zu / als);(jemanden) bestimmen (zu)
-unter der Nummer (...) erreichbar sein;(jemanden) unter der Nummer erreichen (können);(jemandes) Büronummer ist (...);(jemandes) Privatnummer ist (...);unter (...) erreichbar sein;telefonisch unter (...) zu erreichen sein
-Ozongenerator;Ozonisator
-Schmiere stehen;aufpassen, dass niemand kommt
-You can choose which license you want the data of openthesaurus.de
-to use with, LGPL or CC-BY-SA 4.0. See below for the licenses:
-
-===============================================================================
-
-		  GNU LESSER GENERAL PUBLIC LICENSE
-		       Version 2.1, February 1999
-
- Copyright (C) 1991, 1999 Free Software Foundation, Inc.
- 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- Everyone is permitted to copy and distribute verbatim copies
- of this license document, but changing it is not allowed.
-
-[This is the first released version of the Lesser GPL.  It also counts
- as the successor of the GNU Library Public License, version 2, hence
- the version number 2.1.]
-
-			    Preamble
-
-  The licenses for most software are designed to take away your
-freedom to share and change it.  By contrast, the GNU General Public
-Licenses are intended to guarantee your freedom to share and change
-free software--to make sure the software is free for all its users.
-
-  This license, the Lesser General Public License, applies to some
-specially designated software packages--typically libraries--of the
-Free Software Foundation and other authors who decide to use it.  You
-can use it too, but we suggest you first think carefully about whether
-this license or the ordinary General Public License is the better
-strategy to use in any particular case, based on the explanations below.
-
-  When we speak of free software, we are referring to freedom of use,
-not price.  Our General Public Licenses are designed to make sure that
-you have the freedom to distribute copies of free software (and charge
-for this service if you wish); that you receive source code or can get
-it if you want it; that you can change the software and use pieces of
-it in new free programs; and that you are informed that you can do
-these things.
-
-  To protect your rights, we need to make restrictions that forbid
-distributors to deny you these rights or to ask you to surrender these
-rights.  These restrictions translate to certain responsibilities for
-you if you distribute copies of the library or if you modify it.
-
-  For example, if you distribute copies of the library, whether gratis
-or for a fee, you must give the recipients all the rights that we gave
-you.  You must make sure that they, too, receive or can get the source
-code.  If you link other code with the library, you must provide
-complete object files to the recipients, so that they can relink them
-with the library after making changes to the library and recompiling
-it.  And you must show them these terms so they know their rights.
-
-  We protect your rights with a two-step method: (1) we copyright the
-library, and (2) we offer you this license, which gives you legal
-permission to copy, distribute and/or modify the library.
-
-  To protect each distributor, we want to make it very clear that
-there is no warranty for the free library.  Also, if the library is
-modified by someone else and passed on, the recipients should know
-that what they have is not the original version, so that the original
-author's reputation will not be affected by problems that might be
-introduced by others.
-
-  Finally, software patents pose a constant threat to the existence of
-any free program.  We wish to make sure that a company cannot
-effectively restrict the users of a free program by obtaining a
-restrictive license from a patent holder.  Therefore, we insist that
-any patent license obtained for a version of the library must be
-consistent with the full freedom of use specified in this license.
-
-  Most GNU software, including some libraries, is covered by the
-ordinary GNU General Public License.  This license, the GNU Lesser
-General Public License, applies to certain designated libraries, and
-is quite different from the ordinary General Public License.  We use
-this license for certain libraries in order to permit linking those
-libraries into non-free programs.
-
-  When a program is linked with a library, whether statically or using
-a shared library, the combination of the two is legally speaking a
-combined work, a derivative of the original library.  The ordinary
-General Public License therefore permits such linking only if the
-entire combination fits its criteria of freedom.  The Lesser General
-Public License permits more lax criteria for linking other code with
-the library.
-
-  We call this license the "Lesser" General Public License because it
-does Less to protect the user's freedom than the ordinary General
-Public License.  It also provides other free software developers Less
-of an advantage over competing non-free programs.  These disadvantages
-are the reason we use the ordinary General Public License for many
-libraries.  However, the Lesser license provides advantages in certain
-special circumstances.
-
-  For example, on rare occasions, there may be a special need to
-encourage the widest possible use of a certain library, so that it becomes
-a de-facto standard.  To achieve this, non-free programs must be
-allowed to use the library.  A more frequent case is that a free
-library does the same job as widely used non-free libraries.  In this
-case, there is little to gain by limiting the free library to free
-software only, so we use the Lesser General Public License.
-
-  In other cases, permission to use a particular library in non-free
-programs enables a greater number of people to use a large body of
-free software.  For example, permission to use the GNU C Library in
-non-free programs enables many more people to use the whole GNU
-operating system, as well as its variant, the GNU/Linux operating
-system.
-
-  Although the Lesser General Public License is Less protective of the
-users' freedom, it does ensure that the user of a program that is
-linked with the Library has the freedom and the wherewithal to run
-that program using a modified version of the Library.
-
-  The precise terms and conditions for copying, distribution and
-modification follow.  Pay close attention to the difference between a
-"work based on the library" and a "work that uses the library".  The
-former contains code derived from the library, whereas the latter must
-be combined with the library in order to run.
-
-		  GNU LESSER GENERAL PUBLIC LICENSE
-   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
-
-  0. This License Agreement applies to any software library or other
-program which contains a notice placed by the copyright holder or
-other authorized party saying it may be distributed under the terms of
-this Lesser General Public License (also called "this License").
-Each licensee is addressed as "you".
-
-  A "library" means a collection of software functions and/or data
-prepared so as to be conveniently linked with application programs
-(which use some of those functions and data) to form executables.
-
-  The "Library", below, refers to any such software library or work
-which has been distributed under these terms.  A "work based on the
-Library" means either the Library or any derivative work under
-copyright law: that is to say, a work containing the Library or a
-portion of it, either verbatim or with modifications and/or translated
-straightforwardly into another language.  (Hereinafter, translation is
-included without limitation in the term "modification".)
-
-  "Source code" for a work means the preferred form of the work for
-making modifications to it.  For a library, complete source code means
-all the source code for all modules it contains, plus any associated
-interface definition files, plus the scripts used to control compilation
-and installation of the library.
-
-  Activities other than copying, distribution and modification are not
-covered by this License; they are outside its scope.  The act of
-running a program using the Library is not restricted, and output from
-such a program is covered only if its contents constitute a work based
-on the Library (independent of the use of the Library in a tool for
-writing it).  Whether that is true depends on what the Library does
-and what the program that uses the Library does.
-
-  1. You may copy and distribute verbatim copies of the Library's
-complete source code as you receive it, in any medium, provided that
-you conspicuously and appropriately publish on each copy an
-appropriate copyright notice and disclaimer of warranty; keep intact
-all the notices that refer to this License and to the absence of any
-warranty; and distribute a copy of this License along with the
-Library.
-
-  You may charge a fee for the physical act of transferring a copy,
-and you may at your option offer warranty protection in exchange for a
-fee.
-
-  2. You may modify your copy or copies of the Library or any portion
-of it, thus forming a work based on the Library, and copy and
-distribute such modifications or work under the terms of Section 1
-above, provided that you also meet all of these conditions:
-
-    a) The modified work must itself be a software library.
-
-    b) You must cause the files modified to carry prominent notices
-    stating that you changed the files and the date of any change.
-
-    c) You must cause the whole of the work to be licensed at no
-    charge to all third parties under the terms of this License.
-
-    d) If a facility in the modified Library refers to a function or a
-    table of data to be supplied by an application program that uses
-    the facility, other than as an argument passed when the facility
-    is invoked, then you must make a good faith effort to ensure that,
-    in the event an application does not supply such function or
-    table, the facility still operates, and performs whatever part of
-    its purpose remains meaningful.
-
-    (For example, a function in a library to compute square roots has
-    a purpose that is entirely well-defined independent of the
-    application.  Therefore, Subsection 2d requires that any
-    application-supplied function or table used by this function must
-    be optional: if the application does not supply it, the square
-    root function must still compute square roots.)
-
-These requirements apply to the modified work as a whole.  If
-identifiable sections of that work are not derived from the Library,
-and can be reasonably considered independent and separate works in
-themselves, then this License, and its terms, do not apply to those
-sections when you distribute them as separate works.  But when you
-distribute the same sections as part of a whole which is a work based
-on the Library, the distribution of the whole must be on the terms of
-this License, whose permissions for other licensees extend to the
-entire whole, and thus to each and every part regardless of who wrote
-it.
-
-Thus, it is not the intent of this section to claim rights or contest
-your rights to work written entirely by you; rather, the intent is to
-exercise the right to control the distribution of derivative or
-collective works based on the Library.
-
-In addition, mere aggregation of another work not based on the Library
-with the Library (or with a work based on the Library) on a volume of
-a storage or distribution medium does not bring the other work under
-the scope of this License.
-
-  3. You may opt to apply the terms of the ordinary GNU General Public
-License instead of this License to a given copy of the Library.  To do
-this, you must alter all the notices that refer to this License, so
-that they refer to the ordinary GNU General Public License, version 2,
-instead of to this License.  (If a newer version than version 2 of the
-ordinary GNU General Public License has appeared, then you can specify
-that version instead if you wish.)  Do not make any other change in
-these notices.
-
-  Once this change is made in a given copy, it is irreversible for
-that copy, so the ordinary GNU General Public License applies to all
-subsequent copies and derivative works made from that copy.
-
-  This option is useful when you wish to copy part of the code of
-the Library into a program that is not a library.
-
-  4. You may copy and distribute the Library (or a portion or
-derivative of it, under Section 2) in object code or executable form
-under the terms of Sections 1 and 2 above provided that you accompany
-it with the complete corresponding machine-readable source code, which
-must be distributed under the terms of Sections 1 and 2 above on a
-medium customarily used for software interchange.
-
-  If distribution of object code is made by offering access to copy
-from a designated place, then offering equivalent access to copy the
-source code from the same place satisfies the requirement to
-distribute the source code, even though third parties are not
-compelled to copy the source along with the object code.
-
-  5. A program that contains no derivative of any portion of the
-Library, but is designed to work with the Library by being compiled or
-linked with it, is called a "work that uses the Library".  Such a
-work, in isolation, is not a derivative work of the Library, and
-therefore falls outside the scope of this License.
-
-  However, linking a "work that uses the Library" with the Library
-creates an executable that is a derivative of the Library (because it
-contains portions of the Library), rather than a "work that uses the
-library".  The executable is therefore covered by this License.
-Section 6 states terms for distribution of such executables.
-
-  When a "work that uses the Library" uses material from a header file
-that is part of the Library, the object code for the work may be a
-derivative work of the Library even though the source code is not.
-Whether this is true is especially significant if the work can be
-linked without the Library, or if the work is itself a library.  The
-threshold for this to be true is not precisely defined by law.
-
-  If such an object file uses only numerical parameters, data
-structure layouts and accessors, and small macros and small inline
-functions (ten lines or less in length), then the use of the object
-file is unrestricted, regardless of whether it is legally a derivative
-work.  (Executables containing this object code plus portions of the
-Library will still fall under Section 6.)
-
-  Otherwise, if the work is a derivative of the Library, you may
-distribute the object code for the work under the terms of Section 6.
-Any executables containing that work also fall under Section 6,
-whether or not they are linked directly with the Library itself.
-
-  6. As an exception to the Sections above, you may also combine or
-link a "work that uses the Library" with the Library to produce a
-work containing portions of the Library, and distribute that work
-under terms of your choice, provided that the terms permit
-modification of the work for the customer's own use and reverse
-engineering for debugging such modifications.
-
-  You must give prominent notice with each copy of the work that the
-Library is used in it and that the Library and its use are covered by
-this License.  You must supply a copy of this License.  If the work
-during execution displays copyright notices, you must include the
-copyright notice for the Library among them, as well as a reference
-directing the user to the copy of this License.  Also, you must do one
-of these things:
-
-    a) Accompany the work with the complete corresponding
-    machine-readable source code for the Library including whatever
-    changes were used in the work (which must be distributed under
-    Sections 1 and 2 above); and, if the work is an executable linked
-    with the Library, with the complete machine-readable "work that
-    uses the Library", as object code and/or source code, so that the
-    user can modify the Library and then relink to produce a modified
-    executable containing the modified Library.  (It is understood
-    that the user who changes the contents of definitions files in the
-    Library will not necessarily be able to recompile the application
-    to use the modified definitions.)
-
-    b) Use a suitable shared library mechanism for linking with the
-    Library.  A suitable mechanism is one that (1) uses at run time a
-    copy of the library already present on the user's computer system,
-    rather than copying library functions into the executable, and (2)
-    will operate properly with a modified version of the library, if
-    the user installs one, as long as the modified version is
-    interface-compatible with the version that the work was made with.
-
-    c) Accompany the work with a written offer, valid for at
-    least three years, to give the same user the materials
-    specified in Subsection 6a, above, for a charge no more
-    than the cost of performing this distribution.
-
-    d) If distribution of the work is made by offering access to copy
-    from a designated place, offer equivalent access to copy the above
-    specified materials from the same place.
-
-    e) Verify that the user has already received a copy of these
-    materials or that you have already sent this user a copy.
-
-  For an executable, the required form of the "work that uses the
-Library" must include any data and utility programs needed for
-reproducing the executable from it.  However, as a special exception,
-the materials to be distributed need not include anything that is
-normally distributed (in either source or binary form) with the major
-components (compiler, kernel, and so on) of the operating system on
-which the executable runs, unless that component itself accompanies
-the executable.
-
-  It may happen that this requirement contradicts the license
-restrictions of other proprietary libraries that do not normally
-accompany the operating system.  Such a contradiction means you cannot
-use both them and the Library together in an executable that you
-distribute.
-
-  7. You may place library facilities that are a work based on the
-Library side-by-side in a single library together with other library
-facilities not covered by this License, and distribute such a combined
-library, provided that the separate distribution of the work based on
-the Library and of the other library facilities is otherwise
-permitted, and provided that you do these two things:
-
-    a) Accompany the combined library with a copy of the same work
-    based on the Library, uncombined with any other library
-    facilities.  This must be distributed under the terms of the
-    Sections above.
-
-    b) Give prominent notice with the combined library of the fact
-    that part of it is a work based on the Library, and explaining
-    where to find the accompanying uncombined form of the same work.
-
-  8. You may not copy, modify, sublicense, link with, or distribute
-the Library except as expressly provided under this License.  Any
-attempt otherwise to copy, modify, sublicense, link with, or
-distribute the Library is void, and will automatically terminate your
-rights under this License.  However, parties who have received copies,
-or rights, from you under this License will not have their licenses
-terminated so long as such parties remain in full compliance.
-
-  9. You are not required to accept this License, since you have not
-signed it.  However, nothing else grants you permission to modify or
-distribute the Library or its derivative works.  These actions are
-prohibited by law if you do not accept this License.  Therefore, by
-modifying or distributing the Library (or any work based on the
-Library), you indicate your acceptance of this License to do so, and
-all its terms and conditions for copying, distributing or modifying
-the Library or works based on it.
-
-  10. Each time you redistribute the Library (or any work based on the
-Library), the recipient automatically receives a license from the
-original licensor to copy, distribute, link with or modify the Library
-subject to these terms and conditions.  You may not impose any further
-restrictions on the recipients' exercise of the rights granted herein.
-You are not responsible for enforcing compliance by third parties with
-this License.
-
-  11. If, as a consequence of a court judgment or allegation of patent
-infringement or for any other reason (not limited to patent issues),
-conditions are imposed on you (whether by court order, agreement or
-otherwise) that contradict the conditions of this License, they do not
-excuse you from the conditions of this License.  If you cannot
-distribute so as to satisfy simultaneously your obligations under this
-License and any other pertinent obligations, then as a consequence you
-may not distribute the Library at all.  For example, if a patent
-license would not permit royalty-free redistribution of the Library by
-all those who receive copies directly or indirectly through you, then
-the only way you could satisfy both it and this License would be to
-refrain entirely from distribution of the Library.
-
-If any portion of this section is held invalid or unenforceable under any
-particular circumstance, the balance of the section is intended to apply,
-and the section as a whole is intended to apply in other circumstances.
-
-It is not the purpose of this section to induce you to infringe any
-patents or other property right claims or to contest validity of any
-such claims; this section has the sole purpose of protecting the
-integrity of the free software distribution system which is
-implemented by public license practices.  Many people have made
-generous contributions to the wide range of software distributed
-through that system in reliance on consistent application of that
-system; it is up to the author/donor to decide if he or she is willing
-to distribute software through any other system and a licensee cannot
-impose that choice.
-
-This section is intended to make thoroughly clear what is believed to
-be a consequence of the rest of this License.
-
-  12. If the distribution and/or use of the Library is restricted in
-certain countries either by patents or by copyrighted interfaces, the
-original copyright holder who places the Library under this License may add
-an explicit geographical distribution limitation excluding those countries,
-so that distribution is permitted only in or among countries not thus
-excluded.  In such case, this License incorporates the limitation as if
-written in the body of this License.
-
-  13. The Free Software Foundation may publish revised and/or new
-versions of the Lesser General Public License from time to time.
-Such new versions will be similar in spirit to the present version,
-but may differ in detail to address new problems or concerns.
-
-Each version is given a distinguishing version number.  If the Library
-specifies a version number of this License which applies to it and
-"any later version", you have the option of following the terms and
-conditions either of that version or of any later version published by
-the Free Software Foundation.  If the Library does not specify a
-license version number, you may choose any version ever published by
-the Free Software Foundation.
-
-  14. If you wish to incorporate parts of the Library into other free
-programs whose distribution conditions are incompatible with these,
-write to the author to ask for permission.  For software which is
-copyrighted by the Free Software Foundation, write to the Free
-Software Foundation; we sometimes make exceptions for this.  Our
-decision will be guided by the two goals of preserving the free status
-of all derivatives of our free software and of promoting the sharing
-and reuse of software generally.
-
-			    NO WARRANTY
-
-  15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
-WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
-EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
-OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY
-KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE
-IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE
-LIBRARY IS WITH YOU.  SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
-THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
-
-  16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
-WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
-AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU
-FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR
-CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE
-LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING
-RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
-FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
-SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
-DAMAGES.
-
-		     END OF TERMS AND CONDITIONS
-
-           How to Apply These Terms to Your New Libraries
-
-  If you develop a new library, and you want it to be of the greatest
-possible use to the public, we recommend making it free software that
-everyone can redistribute and change.  You can do so by permitting
-redistribution under these terms (or, alternatively, under the terms of the
-ordinary General Public License).
-
-  To apply these terms, attach the following notices to the library.  It is
-safest to attach them to the start of each source file to most effectively
-convey the exclusion of warranty; and each file should have at least the
-"copyright" line and a pointer to where the full notice is found.
-
-    <one line to give the library's name and a brief idea of what it does.>
-    Copyright (C) <year>  <name of author>
-
-    This library is free software; you can redistribute it and/or
-    modify it under the terms of the GNU Lesser General Public
-    License as published by the Free Software Foundation; either
-    version 2.1 of the License, or (at your option) any later version.
-
-    This library is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-    Lesser General Public License for more details.
-
-    You should have received a copy of the GNU Lesser General Public
-    License along with this library; if not, write to the Free Software
-    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
-
-Also add information on how to contact you by electronic and paper mail.
-
-You should also get your employer (if you work as a programmer) or your
-school, if any, to sign a "copyright disclaimer" for the library, if
-necessary.  Here is a sample; alter the names:
-
-  Yoyodyne, Inc., hereby disclaims all copyright interest in the
-  library `Frob' (a library for tweaking knobs) written by James Random Hacker.
-
-  <signature of Ty Coon>, 1 April 1990
-  Ty Coon, President of Vice
-
-That's all there is to it!
-
-
-===============================================================================
-
-
-**** Creative Commons Namensnennung-Share Alike 4.0 International Public License ****
-
-Durch die Ausübung der lizenzierten Rechte (wie unten definiert) erklären Sie
-sich rechtsverbindlich mit den Bedingungen dieser Creative Commons
-Namensnennung – Share Alike 4.0 International Public License (“Public License”)
-einverstanden. Soweit die vorliegende Public License als Lizenzvertrag
-anzusehen ist, gewährt Ihnen der Lizenzgeber die in der Public License
-genannten lizenzierten Rechte im Gegenzug dafür, dass Sie die Lizenzbedingungen
-akzeptieren, und gewährt Ihnen die entsprechenden Rechte in Hinblick auf
-Vorteile, die der Lizenzgeber durch das Verfügbarmachen des lizenzierten
-Materials unter diesen Bedingungen hat.
-
-Abschnitt 1 – Definitionen
-
-   a. Abgewandeltes Material bezeichnet Material, welches durch Urheberrechte
-      oder ähnliche Rechte geschützt ist und vom lizenzierten Material
-      abgeleitet ist oder darauf aufbaut und in welchem das lizenzierte
-      Material übersetzt, verändert, umarrangiert, umgestaltet oder anderweitig
-      modifiziert in einer Weise enthalten ist, die aufgrund des Urheberrechts
-      oder ähnlicher Rechte des Lizenzgebers eine Zustimmung erfordert. Im
-      Sinne der vorliegenden Public License entsteht immer abgewandeltes
-      Material, wenn das lizenzierte Material ein Musikwerk, eine Darbietung
-      oder eine Tonaufnahme ist und zur Vertonung von Bewegtbildern verwendet
-      wird.
-   b. Abwandlungslizenz bezeichnet die Lizenz, die Sie in Bezug auf Ihr
-      Urheberrecht oder ähnliche Rechte an Ihren Beiträgen zum abgewandelten
-      Material in Übereinstimmng mit den Bedingungen der vorliegenden Public
-      License erteilen.
-   c. BY-SA-kompatible Lizenz bezeichnet eine unter creativecommons.org/
-      compatiblelicenses genannte Lizenz, die Creative Commons als der
-      vorliegenden Public License im Wesentlichen gleichwertig anerkannt hat.
-   d. Urheberrecht und ähnliche Rechte bezeichnet das Urheberrecht und/oder
-      ähnliche, dem Urheberrecht eng verwandte Rechte, einschließlich
-      insbesondere des Rechts des ausübenden Künstlers, des Rechts zur Sendung,
-      zur Tonaufnahme und des Sui-generis-Datenbankrechts, unabhängig davon,
-      wie diese Rechte genannt oder kategorisiert werden. Im Sinne der
-      vorliegenden Public License werden die in Abschnitt 2(b)(1)-(2)
-      aufgeführten Rechte nicht als Urheberrecht und ähnliche Rechte angesehen.
-   e. Wirksame technische Schutzmaßnahmen bezeichnet solche Maßnahmen, die
-      gemäß gesetzlichen Regelungen auf der Basis des Artikels 11 des WIPO
-      Copyright Treaty vom 20. Dezember 1996 und/oder ähnlicher internationaler
-      Vereinbarungen ohne entsprechende Erlaubnis nicht umgangen werden dürfen.
-   f. Ausnahmen und Beschränkungen bezeichnet Fair Use, Fair Dealing und/oder
-      jegliche andere Ausnahme oder Beschränkung des Urheberrechts oder
-      ähnlicher Rechte, die auf Ihre Nutzung des lizenzierten Materials
-      Anwendung findet.
-   g. Lizenzelemente bezeichnet die Lizenzeigenschaften, die in der Bezeichnung
-      einer Creative Commons Public License aufgeführt werden. Die
-      Lizenzelemente der vorliegenden Public License sind Namensnennung und
-      Share Alike.
-   h. Lizenziertes Material bezeichnet das Werk der Literatur oder Kunst, die
-      Datenbank oder das sonstige Material, welches der Lizenzgeber unter die
-      vorliegende Public License gestellt hat.
-   i. Lizenzierte Rechte bezeichnet die Ihnen unter den Bedingungen der
-      vorliegenden Public License gewährten Rechte, welche auf solche
-      Urheberrechte und ähnlichen Rechte beschränkt sind, die Ihre Nutzung des
-      lizenzierten Materials betreffen und die der Lizenzgeber zu lizenzieren
-      berechtigt ist.
-   j. Lizenzgeber bezeichnet die natürliche(n) oder juristische(n) Person(en),
-      die unter der vorliegenden Public License Rechte gewährt (oder gewähren).
-   k. Weitergabe meint, Material der Öffentlichkeit bereitzustellen durch
-      beliebige Mittel oder Verfahren, die gemäß der lizenzierten Rechte
-      Zustimmung erfordern, wie zum Beispiel Vervielfältigung, öffentliche
-      Vorführung, öffentliche Darbietung, Vertrieb, Verbreitung, Wiedergabe
-      oder Übernahme und öffentliche Zugänglichmachung bzw. Verfügbarmachung in
-      solcher Weise, dass Mitglieder der Öffentlichkeit auf das Material von
-      Orten und zu Zeiten ihrer Wahl zugreifen können.
-   l. Sui-generis Datenbankrechte bezeichnet Rechte, die keine Urheberrechte
-      sind, sondern gegründet sind auf die Richtlinie 96/9/EG des Europäischen
-      Parlaments und des Rates vom 11. März 1996 über den rechtlichen Schutz
-      von Datenbanken in der jeweils gültigen Fassung bzw. deren
-      Nachfolgeregelungen, sowie andere im Wesentlichen funktionsgleiche Rechte
-      anderswo auf der Welt.
-   m. Sie bezeichnet die natürliche oder juristische Person, die von
-      lizenzierten Rechten unter der vorliegenden Public License Gebrauch
-      macht. Ihr bzw. Ihre hat die entsprechende Bedeutung.
-
-Abschnitt 2 – Umfang
-
-   a. Lizenzgewährung
-         1. Unter den Bedingungen der vorliegenden Public License gewährt der
-            Lizenzgeber Ihnen eine weltweite, vergütungsfreie, nicht
-            unterlizenzierbare, nicht-ausschließliche, unwiderrufliche Lizenz
-            zur Ausübung der lizenzierten Rechte am lizenzierten Material, um:
-               a. das lizenzierte Material ganz oder in Teilen zu
-                  vervielfältigen und weiterzugeben; und
-               b. abgewandeltes Material zu erstellen, zu vervielfältigen und
-                  weiterzugeben.
-         2. Ausnahmen und Beschränkungen. Es sei klargestellt, dass, wo immer
-            gesetzliche Ausnahmen und Beschränkungen auf Ihre Nutzung Anwendung
-            finden, die vorliegende Public License nicht anwendbar ist und Sie
-            insoweit ihre Bedingungen nicht einhalten müssen.
-         3. Laufzeit. Die Laufzeit der vorliegenden Public License wird in
-            Abschnitt 6(a) geregelt.
-         4. Medien und Formate; Gestattung technischer Modifikationen. Der
-            Lizenzgeber erlaubt Ihnen, die lizenzierten Rechte in allen
-            bekannten und zukünftig entstehenden Medien und Formaten auszuüben
-            und die dafür notwendigen technischen Modifikationen vorzunehmen.
-            Der Lizenzgeber verzichtet auf jegliche und/oder versichert die
-            Nichtausübung jeglicher Rechte und Befugnisse, Ihnen zu verbieten,
-            technische Modifikationen vorzunehmen, die notwendig sind, um die
-            lizenzierten Rechte ausüben zu können, einschließlich solcher, die
-            zur Umgehung wirksamer technischer Schutzmaßnahmen erforderlich
-            sind. Im Sinne der vorliegenden Public License entsteht kein
-            abgewandeltes Material, soweit lediglich Modifikationen vorgenommen
-            werden, die nach diesem Abschnitt 2(a)(4) zulässig sind.
-         5. Nachfolgende Empfänger
-               a. Angebot des Lizenzgebers – Lizenziertes Material. Jeder
-                  Empfänger des lizenzierten Materials erhält automatisch ein
-                  Angebot des Lizenzgebers, die lizenzierten Rechte unter den
-                  Bedingungen der vorliegenden Public License auzuüben.
-               b. Zusätzliches Angebot des Lizenzgebers – Abgewandeltes
-                  Material. Jeder, der abgewandeltes Material von Ihnen erhält,
-                  erhält automatisch vom Lizenzgeber ein Angebot, die
-                  lizenzierten Rechte am abgewandelten Material unter den
-                  Bedingungen der durch Sie vergebenen Abwandlungslizenz
-                  auszuüben.
-               c. Keine Beschränkungen für nachfolgende Empfänger. Sie dürfen
-                  keine zusätzlichen oder abweichenden Bedingungen fordern oder
-                  das lizenzierte Material mit solchen belegen oder darauf
-                  wirksame technische Maßnahmen anwenden, sofern dadurch die
-                  Ausübung der lizenzierten Rechte durch Empfänger des
-                  lizenzierten Materials eingeschränkt wird.
-         6. Inhaltliche Indifferenz. Die vorliegende Public License begründet
-            nicht die Erlaubnis, zu behaupten oder den Eindruck zu erwecken,
-            dass Sie oder Ihre Nutzung des lizenzierten Materials mit dem
-            Lizenzgeber oder den Zuschreibungsempfängern gemäß Abschnitt 3(a)
-            (1)(A)(i) in Verbindung stehen oder durch ihn gefördert,
-            gutgeheißen oder offiziell anerkannt werden.
-   b. Sonstige Rechte
-         1. Urheberpersönlichkeitsrechte, wie etwa zum Schutz vor
-            Werkentstellungen, werden durch die vorliegende Public License
-            ebenso wenig mitlizenziert wie das Recht auf Privatheit, auf
-            Datenschutz und/oder ähnliche Persönlichkeitsrechte; gleichwohl
-            verzichtet der Lizenzgeber auf derlei Rechte bzw. ihre
-            Durchsetzung, soweit dies für Ihre Ausübung der lizenzierten Rechte
-            erforderlich und möglich ist, jedoch nicht darüber hinaus.
-         2. Patent- und Kennzeichenrechte werden durch die vorliegende Public
-            License nicht lizenziert.
-         3. Soweit wie möglich verzichtet der Lizenzgeber auf Vergütung durch
-            Sie für die Ausübung der lizenzierten Rechte, sowohl direkt als
-            auch durch eine Verwertungsgesellschaft unter welchem freiwilligen
-            oder abdingbaren gesetzlichen oder Pflichtlizenzmechanismus auch
-            immer eingezogen. In allen übrigen Fällen behält sich der
-            Lizenzgeber ausdrücklich jedes Recht vor, Vergütungen zu fordern.
-
-Abschnitt 3 – Lizenzbedingungen
-
-Ihre Ausübung der lizenzierten Rechte unterliegt ausdrücklich folgenden
-Bedingungen
-
-   a. Namensnennung
-         1. Wenn Sie das lizenzierte Material weitergeben (auch in veränderter
-            Form), müssen Sie:
-               a. die folgenden Angaben beibehalten, soweit sie vom Lizenzgeber
-                  dem lizenzierten Material beigefügt wurden:
-                     i. die Bezeichnung der/des Ersteller(s) des lizenzierten
-                        Materials und anderer, die für eine Namensnennung
-                        vorgesehen sind (auch durch Pseudonym, falls
-                        angegeben), in jeder durch den Lizenzgeber verlangten
-                        Form, die angemessen ist;
-                    ii. einen Copyright-Vermerk;
-                   iii. einen Hinweis auf die vorliegende Public License;
-                    iv. einen Hinweis auf den Haftungsausschluss;
-                     v. soweit vernünftigerweise praktikabel einen URI oder
-                        Hyperlink zum lizenzierten Material;
-               b. angeben, ob Sie das lizenzierte Material verändert haben, und
-                  alle vorherigen Änderungsangaben beibehalten; und
-               c. angeben, dass das lizenzierte Material unter der vorliegenden
-                  Public License steht, und deren Text oder URI oder einen
-                  Hyperlink darauf beifügen.
-         2. Sie dürfen die Bedingungen des Abschnitts 3(a)(1) in jeder
-            angemessenen Form erfüllen, je nach Medium, Mittel und Kontext in
-            bzw. mit dem Sie das lizenzierte Material weitergeben. Es kann zum
-            Beispiel angemessen sein, die Bedingungen durch Angabe eines URI
-            oder Hyperlinks auf eine Quelle zu erfüllen, die die erforderlichen
-            Informationen enthält.
-         3. Falls der Lizenzgeber es verlangt, müssen Sie die gemäß Abschnitt 3
-            (a)(1)(A) erforderlichen Informationen entfernen, soweit dies
-            vernünftigerweise praktikabel ist.
-   b. Share Alike
-      Zusätzlich zu den Bedingungen in Abschnitt 3(a) gelten die folgenden
-      Bedingungen, falls Sie abgewandeltes Material weitergeben, welches Sie
-      selbst erstellt haben.
-         1. Die Abwandlungslizenz, die Sie vergeben, muss eine Creative-
-            Commons-Lizenz der vorliegenden oder einer späteren Version mit den
-            gleichen Lizenzelementen oder eine BY-SA-kompatible Lizenz sein.
-         2. Sie müssen den Text oder einen URI oder Hyperlink auf die von Ihnen
-            gewählte Abwandlungslizenz beifügen. Diese Bedingung dürfen Sie in
-            jeder angemessenen Form erfüllen, je nach Medium, Mittel und
-            Kontext in bzw. mit dem Sie abgewandeltes Material weitergeben.
-         3. Sie dürfen keine zusätzlichen oder abweichenden Bedingungen
-            anbieten oder das abgewandelte Material mit solchen belegen oder
-            darauf wirksame technische Maßnahmen anwenden, sofern dadurch die
-            Ausübung der Rechte am abgewandelten Material eingeschränkt wird,
-            die Sie unter der Abwandlungslizenz gewähren.
-
-Abschnitt 4 – Sui-generis-Datenbankrechte
-
-Soweit die lizenzierten Rechte Sui-generis-Datenbankrechte beinhalten, die auf
-Ihre Nutzung des lizenzierten Materials Anwendung finden, gilt:
-   a. es sei klargestellt, dass Abschnitt 2(a)(1) Ihnen das Recht gewährt, die
-      gesamten Inhalte der Datenbank oder wesentliche Teile davon zu entnehmen,
-      weiterzuverwenden, zu vervielfältigen und weiterzugeben;
-   b. sofern Sie alle Inhalte der Datenbank oder wesentliche Teile davon in
-      eine Datenbank aufnehmen, an der Sie Sui-generis-Datenbankrechte haben,
-      dann gilt die Datenbank, an der Sie Sui-generis-Datenbankrechte haben
-      (aber nicht ihre einzelnen Inhalte) als abgewandeltes Material,
-      insbesondere in Bezug auf Abschnitt 3(b); und
-   c. Sie müssen die Bedingungen des Abschnitts 3(a) einhalten, wenn sie alle
-      Datenbankinhalte oder wesentliche Teile davon weitergeben.
-
-Es sei ferner klargestellt, dass dieser Abschnitt 4 Ihre Verpflichtungen aus
-der vorliegenden Public License nur ergänzt und nicht ersetzt, soweit die
-lizenzierten Rechte andere Urheberrechte oder ähnliche Rechte enthalten.
-
-Abschnitt 5 – Gewährleistungsausschluss und Haftungsbeschränkung
-
-   a. Sofern der Lizenzgeber nicht separat anderes erklärt und so weit wie
-      möglich, bietet der Lizenzgeber das lizenzierte Material so wie es ist
-      und verfügbar ist an und sagt in Bezug auf das lizenzierte Material keine
-      bestimmten Eigenschaften zu, weder ausdrücklich noch konkludent oder
-      anderweitig, und schließt jegliche Gewährleistung aus, einschließlich der
-      gesetzlichen. Dies umfasst insbesondere das Freisein von Rechtsmängeln,
-      Verkehrsfähigkeit, Eignung für einen bestimmten Zweck, Wahrung der Rechte
-      Dritter, Freisein von (auch verdeckten) Sachmängeln, Richtigkeit und das
-      Vorliegen oder Nichtvorliegen von Irrtümern, gleichviel ob sie bekannt,
-      unbekannt oder erkennbar sind. Dort, wo Gewährleistungsausschlüsse ganz
-      oder teilweise unzulässig sind, gilt der vorliegende Ausschluss
-      möglicherweise für Sie nicht.
-   b. Soweit wie möglich, haftet der Lizenzgeber Ihnen gegenüber nach keinem
-      rechtlichen Konstrukt (einschließlich insbesondere Fahrlässigkeit) oder
-      anderweitig für irgendwelche direkten, speziellen, indirekten,
-      zufälligen, Folge-, Straf- exemplarischen oder anderen Verluste, Kosten,
-      Aufwendungen oder Schäden, die sich aus der vorliegenden Public License
-      oder der Nutzung des lizenzierten Materials ergeben, selbst wenn der
-      Lizenzgeber auf die Möglichkeit solcher Verluste, Kosten, Aufwendungen
-      oder Schäden hingewiesen wurde. Dort, wo Haftungsbeschränkungen ganz oder
-      teilweise unzulässig sind, gilt die vorliegende Beschränkung
-      möglicherweise für Sie nicht.
-   a. Der Gewährleistungsausschluss und die Haftungsbeschränkung oben sollen so
-      ausgelegt werden, dass sie soweit wie möglich einem absoluten Haftungs-
-      und Gewährleistungsausschluss nahe kommen.
-
-Abschnitt 6 – Laufzeit und Beendigung
-
-   a. Die vorliegende Public License gilt bis zum Ablauf der Schutzfrist des
-      Urheberrechts und der ähnlichen Rechte, die hiermit lizenziert werden.
-      Gleichwohl erlöschen Ihre Rechte aus dieser Public License automatisch,
-      wenn Sie die Bestimmungen dieser Public License nicht einhalten.
-   b. Soweit Ihr Recht, das lizenzierte Material zu nutzen, gemäß Abschnitt 6
-      (a) erloschen ist, lebt es wieder auf:
-         1. automatisch zu dem Zeitpunkt, an welchem die Verletzung abgestellt
-            ist, sofern dies innerhalb von 30 Tagen seit Ihrer Kenntnis der
-            Verletzung geschieht; oder
-         2. durch ausdrückliche Wiedereinsetzung durch den Lizenzgeber.
-      Es sei klargestellt, dass dieser Abschnitt 6(b) die Rechte des
-      Lizenzgebers, Ausgleich für Ihre Verletzung der vorliegenden Public
-      License zu verlangen, nicht einschränkt.
-   c. Es sei klargestellt, dass der Lizenzgeber das lizenzierte Material auch
-      unter anderen Bedingungen anbieten oder den Vertrieb des lizenzierten
-      Materials jederzeit einstellen darf; gleichwohl erlischt dadurch die
-      vorliegende Public License nicht.
-   d. Die Abschnitte 1, 5, 6, 7 und 8 gelten auch nach Erlöschen der
-      vorliegenden Public License fort.
-
-Abschnitt 7 – Sonstige Bedingungen
-
-   a. Der Lizenzgeber ist nicht an durch Sie gestellte zusätzliche oder
-      abweichende Bedingungen gebunden, wenn diese nicht ausdrücklich
-      vereinbart wurden.
-   b. Jedwede das lizenzierte Material betreffenden und hier nicht genannten
-      Umstände, Annahmen oder Vereinbarungen sind getrennt und unabhängig von
-      den Bedingungen der vorliegenden Public License.
-
-Abschnitt 8 – Auslegung
-
-   a. Es sei klargestellt, dass die vorliegende Public License weder besagen
-      noch dahingehend ausgelegt werden soll, dass sie solche Nutzungen des
-      lizenzierten Materials verringert, begrenzt, einschränkt oder mit
-      Bedingungen belegt, die ohne eine Erlaubnis aus dieser Public License
-      zulässig sind.
-   b. Soweit wie möglich soll, falls eine Klausel der vorliegenden Public
-      License als nicht durchsetzbar anzusehen ist, diese Klausel automatisch
-      im geringst erforderlichen Maße angepasst werden, um sie durchsetzbar zu
-      machen. Falls die Klausel nicht anpassbar ist, soll sie von der
-      vorliegenden Public License abgeschieden werden, ohne dass die
-      Durchsetzbarkeit der verbleibenden Bedingungen tangiert wird.
-   c. Auf keine Bedingung der vorliegenden Public License wird verzichtet und
-      kein Verstoß dagegen soll als hingenommen gelten, außer der Lizenzgeber
-      hat sich damit ausdrücklich einverstanden erklärt.
-   d. Nichts in der vorliegenden Public License soll zu einer Beschränkung oder
-      Aufhebung von Privilegien und Immunitäten führen, die dem Lizenzgeber
-      oder Ihnen insbesondere aufgrund rechtlicher Regelungen irgendeiner
-      Rechtsordnung oder Rechtsposition zustehen, oder dahingehend
-      interpretiert werden.
diff --git a/src/main/resources/test.txt b/src/main/resources/test.txt
deleted file mode 100644
index 1ac0ded..0000000
--- a/src/main/resources/test.txt
+++ /dev/null
@@ -1,6 +0,0 @@
-Atomspaltung;Kernspaltung (fachspr., technisch);Fission;Kernfission
-Wiederaufnahme;Fortführung
-davonfahren;aufbrechen;davonbrausen;abfahren;abzischen (ugs.);abhauen (ugs.);abdüsen (ugs.);abreisen;(von etwas) fortfahren;abdampfen (ugs.);wegfliegen;abfliegen;losfahren (ugs.);wegfahren;davonmachen (ugs.)
-Deputat...;Konzessions...
-Bildungsmaßnahme;Schulung;Weiterbildung;Kurs;Training;Workshop;Kursus;Lehrgang;Seminar
-Mangelhaftigkeit;Defizienz
\ No newline at end of file
diff --git a/src/test/java/de/ids_mannheim/korap/openthesaurus/ThesaurusDictionaryTest.java b/src/test/java/de/ids_mannheim/korap/openthesaurus/ThesaurusDictionaryTest.java
new file mode 100644
index 0000000..2112e47
--- /dev/null
+++ b/src/test/java/de/ids_mannheim/korap/openthesaurus/ThesaurusDictionaryTest.java
@@ -0,0 +1,75 @@
+package de.ids_mannheim.korap.openthesaurus;
+
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+public class ThesaurusDictionaryTest {
+
+    @Test
+    @DisplayName("Regex applied to text fields should remove text in parentheses and strip whitespaces")
+    void cleanStringTest() {
+        String[][] regexStrings = new String[][] {
+                {"(some annot.)(some other) Word1 Word2 Word3    (annot.)(other)", "Word1 Word2 Word3"},
+                {"mit Füßen treten (ein Recht) (ugs., fig.)", "mit Füßen treten"},
+                {"Atomspaltung", "Atomspaltung"},
+                //{" Word ","Word"} // doesn't pass yet!
+        };
+        for (String[] pair : regexStrings) {
+            String source = pair[0];
+            String target = pair[1];
+            assertEquals(target, ThesaurusDictionary.cleanString(source));
+        }
+    }
+
+    <K, V extends List> boolean twoMapsAreEqual(Map<K, V> map1, Map<K, V> map2) {
+        for (Map.Entry<K, V> pair : map1.entrySet()) {
+            K keyTarget = pair.getKey();
+            V valuesTarget = pair.getValue();
+            if (!map2.containsKey(keyTarget)) return false;
+            else {
+                V valuesCompare = map2.get(keyTarget);
+                if (!valuesCompare.containsAll(valuesTarget)) return false;
+            }
+        }
+        return true;
+    }
+
+    @Test
+    @DisplayName("Test HashMaps created from lines")
+    void processLineTest() {
+        String source = "unhinterfragt;unkritisch;bedenkenlos";
+        Map<String, List<String>> target = new HashMap<>();
+        target.put("unhinterfragt", List.of(new String[]{
+                "unkritisch", "bedenkenlos"
+        }));
+        target.put("unkritisch", List.of(new String[]{
+                "unhinterfragt", "bedenkenlos"
+        }));
+        target.put("bedenkenlos", List.of(new String[]{
+                "unhinterfragt", "unkritisch"
+        }));
+
+        String source1 = "abhängen (von);(sich) richten (nach);(sich) bemessen (nach)";
+        Map<String, List<String>> target1 = new HashMap<>();
+        target1.put("abhängen", List.of(new String[]{
+                "richten", "bemessen"
+        }));
+        target1.put("richten", List.of(new String[]{
+                "abhängen", "bemessen"
+        }));
+        target1.put("bemessen", List.of(new String[]{
+                "abhängen", "richten"
+        }));
+
+        assertTrue(twoMapsAreEqual(target, ThesaurusDictionary.processLine(source)));
+        assertTrue(twoMapsAreEqual(target1, ThesaurusDictionary.processLine(source1)));
+
+    }
+}
