Vous obtenez en entrée un quart de carte symétrique sur les axes x et y. Le programme devrait imprimer la carte complète.

La carte peut contenir les caractères suivants:, -+/\|.et ils doivent être tournés comme prévu. Les données d'entrée sont toujours rectangulaires et petites.

Exemple

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

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

Le code le plus court gagne.

code-golf string
la source

Que signifie exactement petit pour les données d'entrée? C'est un peu vague à quantifier.

Joey

@Joey Disons que l'entrée est au maximum de 16 lignes et 40 caractères.

J'ai réalisé que je ne mettais aucune limite de temps, mais si quelqu'un a besoin de plus d'une seconde pour sa solution, j'aimerais vraiment le voir.

1

Golfscript - 32 caractères

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

En raison de la symétrie du problème, nous répétons deux fois {flip horizontalement, transpose ( zip)}. En prime, vous pouvez changer la valeur 2en un plus grand nombre pour répéter davantage l'image.

La transposition des caractères se fait en x^=155 if x%3==2raison de l'espace restreint des caractères. Il y a aussi {.5^3%(45+}à la même longueur.

Nabb
la source

3

Canevas , 5 4 octets

║Ｑ↷↷

Première réponse Canvas, commençons donc par une réponse simple. :)

-1 octet grâce à @dzaima .

Les barres obliques sont automatiquement converties lors de la mise en miroir ou de la rotation dans Canvas.
Cela aurait pu être 1 octet ╬( essayez-le en ligne ), mais malheureusement, il transforme également les points .en guillemets simples 'lors de la mise en miroir horizontale.

Essayez-le en ligne.

Explication:

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

Kevin Cruijssen
la source

2

Windows PowerShell, 99 103 117 126 129

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

Remarques:

Cela nécessite malheureusement deux choses sur lesquelles PowerShell est notoirement mauvais lors du golf: inverser une chaîne (ou une séquence de valeurs) et translittérer des éléments dans une chaîne. Je suis assez sûr que c'est au moins deux fois plus long qu'une solution Perl of Ruby.

Tester:

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

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

Histoire

2011-02-09 11:10 (129) - Première tentative.
2011-02-09 11:27 (126) - OFSpour enregistrer le -joinet stocké 99..0dans une variable.
2011-02-09 11:31 (117) - -replacetravaille contre les tableaux, donc je ne suis pas besoin de trois -replaces mais peut faire -split, -replace, à la -joinplace.
2011-02-09 15:03 (105) - Au lieu de faire la même chose deux fois, faites-le une fois et inversez-le. Et mettre une affectation entre parenthèses la fait cracher sa valeur dans le pipeline :-)
2011-02-09 15:08 (103) - Je n'en ai plus besoin $acar je ne l' 99..0utilise plus souvent à ce jour.
2011-02-09 15:17 (99) - Il n'est pas nécessaire d'avoir des espaces après la filterdéfinition. Supprimé $xet collectant à la place chaque ligne lors de la première exécution dans un tableau, puis la sortie pour la seconde moitié.

Joey
la source

2

Rubis - 88 87 caractères

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

Essai

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

Wile E. Coyote
la source

1

Sympa, j'aime la put-assignation.

Ah, il y a ma disparition ;-) Je savais que ça finirait par arriver

Joey

2

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

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

Essayez-le en ligne!

ngn
la source

2

Fusain , 5 4 octets

Ｓ‖Ｍ⌈

-1 octet grâce à @Neil .

Le charbon de bois gère automatiquement la réflexion des barres obliques correctement.

Essayez-le en ligne (verbeux) ou essayez-le en ligne (pur) .

Explication:

Prenez l'entrée comme une chaîne:

InputString()
Ｓ

Réfléchissez-le à la fois vers la droite et vers le bas ( :⌈est intégré :Right, :Down):

ReflectMirror(:⌈)
‖Ｍ⌈

Kevin Cruijssen
la source

@ ASCII uniquement a depuis ajouté quelques multidirectionnelles, y compris ⌈ce qui vous donne droit et bas dans un seul octet.

Neil

@Neil Comment utilisez-vous ⌈le code verbeux? :RightDownne sera bien sûr pas le résultat souhaité.

Kevin Cruijssen

Les multidirectionnels prennent simplement un :préfixe en mode verbeux.

Neil

@Neil Alors :Right:Down, ou ::RightDown, ou autre chose? Cependant, aucun de ces deux résultats ne donnera un ⌈dans la version codée avec l' -vlargument. Que deviendrait le code détaillé pour obtenir Ｓ‖Ｍ⌈en utilisant l' -vlargument?

Kevin Cruijssen

ReflectMirror(:⌈)

Neil

1

Perl, 80 caractères

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

ninjalj
la source

1

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

E / S

./solution in

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

Aman ZeeK Verma
la source

1

CJam, 26 octets

CJam est plus récent que ce défi, donc cette réponse n'est pas éligible pour la coche verte, mais c'était quand même un exercice amusant

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

Testez-le ici.

Explication

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 transposition à la fin entraîne le deuxième retournement à effectuer le long des colonnes. À la fin, nous transposons à nouveau la carte, nous nous retrouvons donc avec l'orientation d'origine.

Martin Ender
la source

1

Powershell, 95 octets

Inspiré par la réponse de Joey .

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

Remarque: 40parce que l'auteur poste le commentaire Let's say the input is at most 16 rows and 40 characters.

Script de test:

$f = {

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

}

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

Production:

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

mazzy
la source

0

Rubis - 105

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

Arnaud Le Blanc
la source

0

Golfscript - 44 caractères

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

résultat

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

Un autre script qui ne fonctionne que par exemple et ne retourne pas pour '\' - 32 caractères

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

résultat

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

VOUS
la source

`\` doit également être retourné.

Nabb

@Nabb, merci, cela a rendu mon code énorme: P

YOU

Mark: Utilisez des variables pour les chaînes répétées si cela les raccourcit. Bien qu'il existe quelques autres astuces que vous pouvez essayer de comprendre avant de poster ma réponse plus tard.

Nabb

@Nabb, merci, je vais essayer de comprendre et laissez-moi 30 minutes: D

YOU

@Nabb, je n'arrivais toujours pas à comprendre, vous pouvez poster le vôtre.

VOUS le

0

Haskell , 76 octets

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

Essayez-le en ligne!

-- 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)

Max Yekhlakov
la source

0

MS-SQL 2017, 243 octets

entrée :

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

compressé :

declare @t TABLE (l INT IDENTITY (1,1), s CHAR (40)); INSERT INTO @t (s) SELECT value + TRANSLATE (REVERSE (value), '\ /', '/ \') 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

lisible par l'homme :

déclarer @t TABLE (l INT IDENTITY (1,1), s CHAR (40));
INSÉRER DANS @t (s)
  SELECT valeur + TRADUIRE (REVERSE (valeur), '\ /', '/ \')
  DE STRING_SPLIT (@ s, char (10));

SELECT s 
DE(
   SÉLECTIONNEZ l, s DE @t 
   UNION ALL 
   SELECT 1e3-l, TRADUIRE (s, '\ /', '/ \') FROM @t
  ) b 
COMMANDER PAR l

sortie (sous forme de texte dans ex.management studio):

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

(6 lignes affectées)

marcin f
la source

Terminer une carte symétrique

Exemple

Réponses:

Golfscript - 32 caractères

Canevas , 5 4 octets

Windows PowerShell, 99 103 117 126 129

Rubis - 88 87 caractères

Essai

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

Fusain , 5 4 octets

Perl, 80 caractères

CJam, 26 octets

Explication

Powershell, 95 octets

Rubis - 105

Golfscript - 44 caractères

Un autre script qui ne fonctionne que par exemple et ne retourne pas pour '\' - 32 caractères

Haskell , 76 octets

MS-SQL 2017, 243 octets