Canvas , 5 4 Bytes

║Ｑ↷↷

Erste Canvas Antwort, fangen wir also mit einer einfachen an. :)

-1 Byte danke an @dzaima .

Die Schrägstriche werden beim Spiegeln oder Drehen in Canvas automatisch konvertiert.
Hätte 1 Byte sein können ╬( Online testen ), aber leider werden die Punkte auch .in einfache Anführungszeichen umgewandelt, 'wenn horizontal gespiegelt wird.

Probieren Sie es online aus.

Erläuterung:

         # (Take the multi-line input implicitly as canvas object)
║        # Palindromize the canvas object (without overlap)
 Ｑ      # Output it with a trailing newline (without popping)
  ↷↷    # Rotated the canvas object that's still on the stack by 90 degrees twice
         # (and output it implicitly as well at the end)

Windows PowerShell, 99 103 117 126 129

filter x{$_-split'/'-replace'\\','/'-join'\'}$input|%{$_+-join($_[40..0]|x)}|%{$_
$s=,($_|x)+$s}
$s

Anmerkungen:

• Dies erfordert leider zwei Dinge, die PowerShell beim Golfen bekanntermaßen nicht kann: das Umkehren einer Zeichenfolge (oder einer Folge von Werten) und das Transliterieren von Inhalten in einer Zeichenfolge. Ich bin mir ziemlich sicher, dass dies mindestens doppelt so lang ist wie eine Perl-Ruby-Lösung.

Prüfung:

> gc in| .\map.ps1
+------+
|./..\.|
|/....\|
|\..../|
|.\../.|
+------+

> gc in2
+\/
/\/
> gc in2| .\map.ps1
+\/\/+
/\/\/\
\/\/\/
+/\/\+

Geschichte

• 2011-02-09 11:10 (129) - Erster Versuch.
• 2011-02-09 11:27 (126) - OFSum die -joinund 99..0in einer Variablen zu speichern .
• 2011-02-09 11.31 (117) - -replacewirkt gegen Arrays, so dass ich nicht drei brauchen -replaces kann aber ein tun -split, -replace, -joinstatt.
• 2011-02-09 15:03 (105) - Anstatt zweimal dasselbe zu tun, tun Sie es einmal und kehren Sie es um. Wenn Sie eine Aufgabe in Klammern setzen, wird der Wert an die Pipeline weitergegeben :-)
• 2011-02-09 15:08 (103) - Ich brauche nicht $amehr, da 99..0es mittlerweile nicht mehr so ​​oft verwendet wird.
• 2011-02-09 15:17 (99) - Nach der filterDefinition muss kein Leerzeichen stehen . Entfernt $xund sammelt stattdessen jede Zeile während des ersten Durchlaufs in einem Array und gibt diese dann für die zweite Hälfte aus.

Ruby - 88 87 Zeichen

t=->s{s.tr'/\\\\','\\\\/'}
puts a=$<.map{|l|l.chop!+t[l.reverse]}
puts a.reverse.map &t

Testlauf

D:\tmp>ruby cg_sym_map.rb < sym_map.in.
+------+
|./..\.|
|/....\|
|\..../|
|.\../.|
+------+

APL (Dyalog Classic) , 25 23 22 21 19 Bytes

(⌽⍪⊖){⊃3⌽⍵∪'/\'}¨,⌽

Probieren Sie es online!

Kohle , 5 4 Bytes

Ｓ‖Ｍ⌈

-1 Byte dank @Neil .

Holzkohle behandelt die Schrägstriche automatisch richtig.

Probieren Sie es online (ausführlich) oder online (rein) .

Erläuterung:

Nehmen Sie die Eingabe als Zeichenfolge:

InputString()
Ｓ

Spiegel es sowohl nach rechts als auch nach unten ( :⌈ist eingebaut für :Right, :Down):

ReflectMirror(:⌈)
‖Ｍ⌈

Perl, 80 Zeichen

print reverse map{s@.*@($b=$&)=~y:/\\:\\/:,$&.reverse$b@e;print;y@/\\@\\/@;$_}<>

Shell Scripting !!

#!/bin/sh

rm temp
touch temp
file=$1
for STRING in `cat $1`
do
   printf $STRING >> temp
   for ((COUNT=0; COUNT<${#STRING}; COUNT++))
   do
      RECORD[$COUNT]=${STRING:$COUNT:1}
   done
   for ((REV_COUNT=${#STRING}; REV_COUNT>=0; REV_COUNT--))
      do
        if [ "${RECORD[$REV_COUNT]}" = "\\" ]; then
            printf "/" >> temp
        elif [ "${RECORD[$REV_COUNT]}" = "/" ]; then
            printf "\\" >> temp
        else
           printf "${RECORD[$REV_COUNT]}" >> temp
        fi
      done
   echo >> temp
done
cat temp
tac temp > temp2
for STRING in `cat temp2`
do
   for ((COUNT=0; COUNT<${#STRING}; COUNT++))
   do
      RECORD[$COUNT]=${STRING:$COUNT:1}
   if [ "${RECORD[$COUNT]}" = "\\" ]; then
            printf "/"
   elif [ "${RECORD[$COUNT]}" = "/" ]; then
            printf "\\"
   else
           printf "${RECORD[$COUNT]}"
   fi
   done
echo
done

I / O

./solution in

+------+
|./..\.|
|/....\|
|\..../|
|.\../.|
+------+

CJam, 26 Bytes

CJam ist neuer als diese Herausforderung, daher ist diese Antwort nicht für das grüne Häkchen geeignet, aber es hat trotzdem Spaß gemacht

qN/{{_W%"\/"_W%er+}%z}2*N*

Teste es hier.

Erläuterung

qN/{{_W%"\/"_W%er+}%z}2*N*
qN/                        "Read STDIN and split on newlines.";
   {                 }2*   "Execute this block twice.";
    {             }%       "Map this block onto each line.";
     _W%                   "Duplicate and reverse.";
        "\/"               "Push the string '\/'.";
            _W%            "Duplicate and reverse.";
               er          "Character transliteration, swaps slashes and backslashes.";
                 +         "Append to first half of the line.";
                    z      "Zip, i.e. transpose the map.";
                        N* "Join with newlines.";

Das Vertauschen am Ende führt zum zweiten Umblättern entlang der Spalten. Am Ende transponieren wir die Karte erneut, sodass wir die ursprüngliche Ausrichtung erhalten.

Powershell, 95 Bytes

Inspiriert von Joeys Antwort .

filter x{$_;$_[40..0]|%{$_-split'/'-replace'\\','/'-join'\'}},($args|%{-join(,($_|% t*y)|x)})|x

Hinweis: 40Weil der Autor den Kommentar veröffentlichtLet's say the input is at most 16 rows and 40 characters .

Testskript:

$f = {

filter x{$_;$_[40..0]|%{$_-split'/'-replace'\\','/'-join'\'}}
,($args|%{-join(,($_|% t*y)|x)})|x

}

@(
    ,( ("+---",
        "|./.",
        "|/.."),
        "+------+",
        "|./..\.|",
        "|/....\|",
        "|\..../|",
        "|.\../.|",
        "+------+")
    ,( ("+\/",
        "/\/"),
        "+\/\/+",
        "/\/\/\",
        "\/\/\/",
        "+/\/\+")
    ,( ("+---",
        "|...",
        "|..\"),
        "+------+",
        "|......|",
        "|..\/..|",
        "|../\..|",
        "|......|",
        "+------+")
) | % {
    $m,$expected = $_
    $result = &$f @m
    "$result"-eq"$expected"
    $result
}

Ausgabe:

True
+------+
|./..\.|
|/....\|
|\..../|
|.\../.|
+------+
True
+\/\/+
/\/\/\
\/\/\/
+/\/\+
True
+------+
|......|
|..\/..|
|../\..|
|......|
+------+

Rubin - 105

t=->s{s.tr '/\\\\','\\\\/'}
$<.read.split.map{|l|print l+=t[l.reverse]+"
"
l}.reverse.map{|l|print t[l]}

Golfscript - 44 Zeichen

n%{.-1%'/'/{'\\'/'/'*}%'\\'*+}%.-1%{-1%}%+n*

Ergebnis

$ cat in2
+-/|/\
/\|//-
$ cat in2 | golfscript codegolf-761.gs 
+-/|/\/\|\-+
/\|//--\\|/\
\/|\\--//|\/
+-\|\/\/|/-+

Ein weiteres Skript, das nur zum Beispiel funktioniert und bei '\' - 32 Zeichen nicht kippt

n%{.-1%'/'/'\\'*+}%.-1%{-1%}%+n*

Ergebnis

$ cat in
+---
|./.
|/..
$ cat in | golfscript codegolf-761.gs 
+------+
|./..\.|
|/....\|
|\..../|
|.\../.|
+------+
$ 

Haskell , 76 Bytes

c '/'='\\';c '\\'='/';c x=x;i=(c<$>)
q#x=x++q(reverse x)
f=((i<$>)#).map(i#)

Probieren Sie es online!

-- Only / and \ get converted, all other chars are passed as is
c '/'='\\';c '\\'='/';c x=x

-- "Invert" the string (that is switch all / and \ in it)
-- Just map our conversion function over the string
i = (c<$>)

-- Helper: Concatenate a list with its reversed copy (with the given function applied to the copy)
q # x = x ++ q (reverse x)

-- the resulting function:
f = ((i<$>)#) . -- produce the lower half of the image by reversing the upper half and inverting slashes in each line
    map (i#) -- produce the upper half or the image (by concating each input line with its reversed, inverted version)

MS-SQL 2017, 243 Byte

Eingang :

DECLARE @s VARCHAR (100) = '+ ---' + CHAR (10) + '| ...' + CHAR (10) + '| .. \';

komprimiert :

deklarieren Sie @t TABLE (l INT IDENTITY (1,1), s CHAR (40)); INSERT INTO @t (s SELECT-Wert + TRANSLATE (REVERSE (Wert), '\ /', '/ \') FROM STRING_SPLIT (@s, char (10)); SELECT s FROM (SELECT l, s FROM @t UNION ALL SELECT 1e3-l, TRANSLATE (s, '\ /', '/ \') FROM @t) b ORDER BY l

menschenlesbar :

erkläre @t TABLE (l INT IDENTITY (1,1), s CHAR (40));
INSERT INTO @t (s)
  SELECT-Wert + TRANSLATE (REVERSE (Wert), '\ /', '/ \')
  FROM STRING_SPLIT (@ s, char (10));

SELECT s 
VON(
   SELECT l, s FROM @t 
   UNION ALL 
   SELECT 1e3-l, TRANSLATE (s, '\ /', '/ \') FROM @t
  ) b 
BESTELLEN NACH l

Ausgabe (als Text in ex.management studio):

+ ------ +                                
| ...... |                                
| .. \ / .. |                                
| ../ \ .. |                                
| ...... |                                
+ ------ +                                

(6 Zeilen betroffen)