Viene fornito un quarto di una mappa simmetrica rispetto agli assi X e Y come input. Il programma dovrebbe stampare la mappa completa.

La mappa può contenere i seguenti caratteri:, -+/\|.e devono essere ruotati come previsto. I dati in sono sempre rettangolari e piccoli.

Esempio

$ cat in
+---
|./.
|/..

$ ./solution < in
+------+
|./..\.|
|/....\|
|\..../|
|.\../.|
+------+

Il codice più corto vince.

Golfscript - 32 caratteri

n%{{.-1%{.3%2=115*^}%+}%zip}2*n*

A causa della simmetria del problema, ripetiamo due volte {capovolgi orizzontalmente, trasponi ( zip)}. Come bonus, puoi cambiare il valore 2in un numero più grande per ripetere l'immagine di più.

La trasposizione del personaggio viene effettuata come x^=155 if x%3==2, a causa dello spazio limitato del personaggio. C'è anche {.5^3%(45+}della stessa lunghezza.

Tela , 5 4 byte

║Ｑ↷↷

Prima risposta di Canvas, quindi cominciamo con una semplice. :)

-1 byte grazie a @dzaima .

Le barre vengono convertite automaticamente durante il mirroring o la rotazione in Canvas.
Avrebbe potuto essere 1 byte ╬( provalo online ), ma sfortunatamente trasforma anche i punti .in virgolette singole 'quando si esegue il mirroring in orizzontale.

Provalo online.

Spiegazione:

         # (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

Appunti:

• Questo purtroppo ha bisogno di due cose in cui PowerShell è notoriamente cattivo mentre gioca a golf: invertire una stringa (o sequenza di valori) e traslitterare cose in una stringa. Sono abbastanza sicuro che questa sia almeno il doppio di una soluzione Perl di Ruby.

Test:

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

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

Storia

• 2011-02-09 11:10 (129) - Primo tentativo.
• 2011-02-09 11:27 (126) - OFSper salvare -joine archiviato 99..0in una variabile.
• 2011-02-09 11:31 (117) - -replacelavora contro gli array, quindi non ho bisogno di tre -replaces, ma posso fare un -split, -replace, -joininvece.
• 2011-02-09 15:03 (105) - Invece di fare la stessa cosa due volte, fallo una volta e invertila. E mettere un compito tra parentesi fa sì che sputi il ​​suo valore alla pipeline :-)
• 2011-02-09 15:08 (103) - Non ne ho $apiù bisogno dato 99..0che ormai non è usato così spesso.
• 2011-02-09 15:17 (99) - Non è necessario spazi bianchi dopo la filterdefinizione. Rimosso $xe invece raccogliendo tutte le righe durante la prima esecuzione in un array e quindi emettendole per la seconda metà.

Rubino - 88 87 caratteri

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

Prova

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

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

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

Provalo online!

Carbone , 5 4 byte

Ｓ‖Ｍ⌈

-1 byte grazie a @Neil .

Il carbone si gestisce automaticamente riflettendo correttamente le barre.

Provalo online (dettagliato) o Provalo online (puro) .

Spiegazione:

Prendi l'input come una stringa:

InputString()
Ｓ

Rifletti specchiandolo sia verso destra che verso il basso ( :⌈è incorporato per :Right, :Down):

ReflectMirror(:⌈)
‖Ｍ⌈

Perl, 80 caratteri

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 byte

CJam è più recente di questa sfida, quindi questa risposta non è ammissibile per il segno di spunta verde, ma è stato comunque un esercizio divertente

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

Provalo qui.

Spiegazione

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.";

La trasposizione alla fine porta il secondo lancio da eseguire lungo le colonne. Alla fine trasponiamo di nuovo la mappa, quindi finiamo con l'orientamento originale.

Powershell, 95 byte

Ispirato dalla risposta di Joey .

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

Nota: 40perché l'autore pubblica il commento Let's say the input is at most 16 rows and 40 characters.

Script di prova:

$f = {

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

}

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

Produzione:

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

Rubino - 105

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

Golfscript - 44 caratteri

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

risultato

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

Un altro script che funziona solo per esempio e non capovolge per "\" - 32 caratteri

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

risultato

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

Haskell , 76 byte

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

Provalo 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

input :

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

compresso :

dichiarare @t TABELLA (l INT IDENTITY (1,1), s CHAR (40)); INSERISCI IN @t (s) SELEZIONA valore + TRANSLATE (INVERSIONE (valore), '\ /', '/ \') DA STRING_SPLIT (@ s, char (10)); SELECT s FROM (SELECT l, s FROM @t UNION ALL SELECT 1e3-l, TRANSLATE (s, '\ /', '/ \') FROM @t) b ORDINA PER l

leggibile dall'uomo :

dichiarare @t TABLE (l INT IDENTITY (1,1), s CHAR (40));
INSERISCI IN @t (s)
  SELEZIONA valore + TRANSLATE (INVERSIONE (valore), '\ /', '/ \')
  FROM STRING_SPLIT (@ s, char (10));

SELEZIONA s 
A PARTIRE DAL(
   SELEZIONA l, s FROM @t 
   UNION ALL 
   SELEZIONA 1e3-l, TRANSLATE (s, '\ /', '/ \') FROM @t
  ) b 
ORDINA PER l

output (come testo in ex.management studio):

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

(6 file interessate)