Réflexion artistique ASCII

26

Dans ce défi, vous recevrez un bloc de texte et vous devrez effectuer une réflexion sur le texte.

Contribution:

  1. Une chaîne à refléter. Le texte ne peut pas être fourni sous la forme d'un tableau dont les éléments sont les lignes de texte. Par exemple, "ab\ncd"et ['a','b','\n','c','d']sont autorisés, mais ['ab','cd']ou [['a','b'],['c','d']]ne sont pas. Vous pouvez supposer que toutes les lignes ont le même nombre de caractères (complétées par des espaces si nécessaire).
  2. Un booléen où Trueindique la réflexion Y et Falseindique la réflexion X

Les deux entrées peuvent être passées dans n'importe quel ordre.

Sortie:

La chaîne réfléchie. Les personnages ne changent pas, seulement leur position. Le bloc d'image résultant doit être aligné en haut à gauche (la première ligne et la première colonne doivent chacune contenir un caractère non blanc). Les espaces de fin (sur l'une des lignes) sont autorisés.

Cas de test:

False
  o /
--|/
  |
 / \

/ o
 /|--
  |
 \ /

True
  o /
--|/
  |
 / \

 / \
  |
--|/
  o /

True
text

text

False
text

txet

True
P
P
C
G

G
C
P
P

False
P
P
C
G

P
P
C
G

True
abcde
fghij
kl mn
opqrs
tuvwx

tuvwx
opqrs
kl mn
fghij
abcde

Ceci est un , alors répondez avec la réponse la plus courte dans votre langue préférée!

Nathan Merrill
la source
2
Pouvons-nous prendre le booléen dans n'importe quel format (par exemple. 1Et 0) ou devons-nous utiliser Trueet False?
TuxCrafting
5
Mettre chaque ligne dans un tableau n'est pas autorisé Pour certaines langues, ce serait le seul moyen, si elles n'autorisent pas les chaînes multilignes
Luis Mendo
7
@LuisMendo Si une langue, une représentation de chaîne naturelle ne peut pas contenir un \n, j'irais jusqu'à dire que ce n'est pas une représentation de chaîne.
Fatalize
2
Pouvez-vous clarifier un peu l'entrée booléenne? Est - ce que je dois piocher les deux valeurs, dont l'un est Falsey et dont l'autre est truthy, et faire mon travail de programme avec ceux; ou mon programme doit-il gérer toutes les valeurs de falsey dans un sens et toutes les valeurs véridiques dans l'autre sens?
Lynn
2
De plus, beaucoup de réponses semblent supposer que l'entrée est rectangulaire (toutes les lignes sont remplies à la même longueur en utilisant des espaces). Cette hypothèse est-elle correcte? Quoi qu'il en soit, vous devez clarifier cela dans la question.
Lynn

Réponses:

11

C #, 168 144 141 120 120 octets

using System.Linq;i=>y=>string.Join("\n",y?i.Split('\n').Reverse():i.Split('\n').Select(x=>string.Concat(x.Reverse())));

La nouvelle version utilise la chaîne évidente. Surcharge de jointure qui prend un IEnumerable, la première solution l'utilisait par inadvertance, je pouvais juste l'utiliser aussi pour l'autre côté du ternaire.

Mise à jour:

La nouvelle version est un lambda anonyme et utilise le curry pour économiser 21 octets au total. Cela modifie l'utilisation pour que f("text")(false)f soit la fonction anonyme.

Non golfé:

using System.Linq;

//Using currying to save one byte
input => IsYReflect =>
         //Lambda makes return implicit
         string.Join("\n", IsYReflect
            //Y Reflect, just need to reverse the array
            ? input.Split('\n').Reverse()
            //X Reflect, reverse each line into an IEnumerable
            : input.Split('\n').Select(x => string.Concat(x.Reverse())));
JustinM - Rétablir Monica
la source
Scott Kaye a laissé un commentaire qui a depuis été supprimé, ce qui m'a poussé à essayer de nouvelles choses et à raser 24 octets.
JustinM
La fonction bodied d'expression C # 6 économise encore 3 octets
JustinM - Rétablir Monica
10

Pyke, 7 octets

!I_)ncX

Essayez-le ici!

!I )    - if not boolean:
  _     -  input = reversed(input)
    nc  - input.split("\n")
      X - splat(input)
        -  (print lines backwards)
Bleu
la source
9

Brainfuck, 143 140 131 octets

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

Beat s C #.

Le défi était assez facile pour Brainfuck, et j'étais apparemment assez fatigué pour avoir à le faire.

Prend le booléen comme un 0x00(faux) ou tout autre octet (véridique) au début de l'entrée, puis une chaîne remplie de rectangle.

Génère une nouvelle ligne de fin pour le flip Y et aucune pour le flip X.

Nécessite un interpréteur qui prend en charge les emplacements de mémoire à gauche du début (incertain si toujours requis) et donne EOF comme 0x00. Un tel interprète est ici . Évidemment, ne prend pas en charge les octets nuls dans l'entrée à cause de cela.

Le code a beaucoup de blocs avec 10 +ou -; ceux-ci peuvent probablement être réduits.

Version commentée

, get mode
[ check truthy input
    ,[ loop thru input
        ---------- subtract newline
        >+ set flag
        < go back to char
        [ was not newline
            > move to flag
            - reset flag
        ]
        > move to flag or one past flag
        [ hit flag; was newline
            - reset flag
            > skip a cell
        ]
        < go to next position
        , read next input
    ]
    < find end of line
    [ loop thru lines
        [<]> find start of line
        [ loop thru line
            ++++++++++ add newline back
            . print this cell
            > go to next cell
        ]
        ++++++++++ change to newline
        . print newline
        <[<]< find end of previous line
    ]
]
,[ loop thru any input left
    ---------- subtract newline
    >+ set flag
    < go back to char
    [ was not newline
        ++++++++++ add newline back
        > move to flag
        - reset flag
    ]
    > move to flag or one past flag
    [ hit flag; was newline
        - clear flag
        < go back to char
        < go back to line chars
        [ loop thru line
            . print this cell
            < go to previous cell
        ]
        ++++++++++. print newline
        [>]>> find empty cell
    ]
    < go to next position
    , read next input
]
< go to line
[ loop thru line
    . print this cell
    < go to previous cell
]
PurkkaKoodari
la source
6

Code machine x86 32 bits, 76 octets

En hex:

31c031c9495789f7fcf2aef7d15192b00a89f7f2ae5829f7f7f787f95f4b89c3741287d94b534b8a041eaa75f95b01dea4e2f2c348f7e101c6b00a5651f3a4595e29ce4f4b0f44c3aa75f0c3

Entrée:: EBXindicateur de direction (0/1),: ESIchaîne d'entrée,: EDItampon de sortie. L'entrée doit être rectangulaire.

0:  31 c0               xor eax,eax         ;EAX=0
2:  31 c9               xor ecx,ecx         
4:  49                  dec ecx             ;ECX=(uint)-1
5:  57                  push edi            
6:  89 f7               mov edi,esi         
8:  fc                  cld                 
9:  f2 ae               repne scasb         ;Scan input string for terminating NULL
b:  f7 d1               not ecx             ;ECX==<input string length (including NULL)>
d:  51                  push ecx            
e:  92                  xchg edx,eax        ;EDX=0
f:  b0 0a               mov al,0x0a         ;'\n'
11: 89 f7               mov edi,esi         
13: f2 ae               repne scasb         ;Scan input string for the first newline
15: 58                  pop eax             ;EAX==<input string length (including NULL)>
16: 29 f7               sub edi,esi         ;EDI==<single line length (including '\n')>
18: f7 f7               div edi             ;EAX==<# of lines>
1a: 87 f9               xchg ecx,edi        ;ECX=EDI
1c: 5f                  pop edi             ;EDI=<dest buffer>
1d: 4b                  dec ebx             ;Test input flag (0/1)
1e: 89 c3               mov ebx,eax         ;EBX=<# of lines>
20: 74 12               je _vertical        
22: 87 d9               xchg ecx,ebx        ;Horisontal flip, exchange ECX & EBX so we can use LOOP
24: 4b                  dec ebx             ;EBX=<single line length (excluding '\n')>
_hfouter:
25: 53                  push ebx            
_hfinner:
26: 4b                  dec ebx             ;Decrement inner loop counter
27: 8a 04 1e            mov al,[esi+ebx]    ;AL=ESI[EBX]
2a: aa                  stosb               ;*EDI++=AL
2b: 75 f9               jne _hfinner        ;EBX==0 => break
2d: 5b                  pop ebx             
2e: 01 de               add esi,ebx         ;*ESI=='\n' (\0 on the last line)
30: a4                  movsb               ;*EDI++=*ESI++, ESI now points to the next line
31: e2 f2               loop _hfouter       ;--ECX==0 => break
33: c3                  ret                 ;Nothing more to do here
_vertical:
34: 48                  dec eax             ;# of strings less one
35: f7 e1               mul ecx             ;Line length (including '\n')
37: 01 c6               add esi,eax         ;ESI+=ECX*(EAX-1), ESI now points to the beginning of the last line
39: b0 0a               mov al,0x0a         ;'\n'
_vfloop:
3b: 56                  push esi            
3c: 51                  push ecx            
3d: f3 a4               rep movsb           ;Copy the whole line to the output including newline/NULL at the end
3f: 59                  pop ecx             
40: 5e                  pop esi             
41: 29 ce               sub esi,ecx         ;Set ESI to the beginning of the previous line
43: 4f                  dec edi             ;*EDI=='\n' (0 on the first iteration), should overwrite it with correct value
44: 4b                  dec ebx             ;Decrement loop counter
45: 0f 44 c3            cmove eax,ebx       ;if (EBX==0) EAX=EBX, this clears EAX on the last iteration
48: aa                  stosb               ;*EDI++=EBX?'\n':0
49: 75 f0               jne _vfloop         ;EBX==0 => break
4b: c3                  ret                 
meden
la source
5

Haskell, 51 49 45 octets

r=reverse
f b=unlines.last(map r:[r|b]).lines

Exemple d'utilisation:

f True "abc\ndef\nghi\njkl"
"jkl\nghi\ndef\nabc\n"

f False "abc\ndef\nghi\njkl"
"cba\nfed\nihg\nlkj\n"

Divisez-vous en lignes, inversez les lignes (Vrai) ou inversez chaque ligne (Faux) et joignez à nouveau une seule chaîne. Dans le cas d'une Trueentrée, map r:[r|b]est une liste de deux fonctions [<reverse each line>, <reverse lines>]et pour une Falseentrée une liste avec une fonction [<reverse each line>]. lastsélectionne le dernier élément de cette liste.

nimi
la source
5

Gelée , 8 octets

ṣ⁷ṚU⁴?j⁷

Essayez-le ici.

ṣ⁷         Split over newlines.
  ṚU⁴?     If ⁴ (2nd argument), then Ṛ (reverse rank ∞), else U (reverse rank 1).
      j⁷   Join with newlines.
Lynn
la source
4

Python, 56 octets

lambda s,r:'\n'.join(s[::2*bool(r)-1].split('\n')[::-1])

Appelez avec une chaîne set n'importe quelle valeur truey / falsey r.

Lynn
la source
Cela ne fonctionne pas de cette façon. Votre programme doit soit prendre toute valeur véridique, soit prendre seulement True, ce qui pourrait également l'être 1. Vous ne pouvez pas restreindre la saisie à seulement 0ou 2.
mbomb007
Ouais, je n'ai pas réfléchi à ma réponse. @ mbomb007 est correct ici, il doit fonctionner pour toute valeur de vérité / fausse pour votre langue.
Nathan Merrill
@NathanMerrill Juste un FYI, vous pouvez éviter des trucs comme la réponse à 3 octets en disant que l'entrée ne doit pas coder d'informations supplémentaires. Cela aurait permis la deuxième réponse (que je trouvais plutôt intelligente), mais bien sûr ce que vous aimeriez voir dépend de vous.
FryAmTheEggman
Cette réponse est invalide selon OP comme il sort ce pour le cas de test # 1 quand il devrait plutôt être fournir en sortie ce qui est donné dans le poste pour ce cas d'essai (espace rembourré à la longueur de la première ligne).
R. Kap
4

Python 3.5, 61 octets:

lambda f,j:[print(r[::-1])for r in j[::[1,-1][f]].split('\n')]

Une simple fonction lambda anonyme qui suppose une entrée rectangulaire. Appelez-la en nommant d'abord la fonction, puis en l'appelant enveloppée à l'intérieur print(). En d'autres termes, si la fonction a été nommée H, appelez-la comme print(H(<Bool value>, <String>)), où <Bool Value>est toute valeur vraie ou fausse (c'est 0/1-à- dire true/false, etc.) et <String>est la chaîne d'entrée.

Voyez-le en action! (repl.it)

Voici une autre version de la même longueur qui suppose également une entrée rectangulaire, mais cette fois une fonction nommée , c'est-à-dire que vous n'avez pas besoin de la nommer d'abord ni de l'envelopper à l'intérieur print():

def J(f,j):[print(r[::-1])for r in j[::[1,-1][f]].split('\n')]

Appelez simplement celui-ci comme J(<Bool Value>,<String>).

Voyez cela en action! (repl.it)

Mais ce n'est pas moi qui m'arrête là. Bien que nous soyons autorisés à assumer une entrée rectangulaire, j'ai également créé une version qui n'assume pas ce type d'entrée. Par conséquent, il remplira toutes les lignes à la même longueur sur la base de la ligne avec la longueur maximale si et seulement si l' <Bool>entrée est False, car seule une réflexion X entraînera le "retournement" de la chaîne. Maintenant, sans plus tarder, voici la version hypothétique non rectangulaire avec une longueur de 134 129 octets sous la forme d'une fonction normale:

def J(f,j):print('\n'.join([' '*((max([len(i)for i in j.split('\n')])-len(r))*(not f))+r[::-1]for r in j[::[1,-1][f]].split('\n')]))

Voir ce dernier en action! (repl.it)

R. Kap
la source
3

MATL , 11 octets

10&Ybc2i-&P

Essayez-le en ligne!

La première entrée est la chaîne multiligne. Étant donné que MATL ne reconnaît pas \ncomme saut de ligne, la chaîne multiligne doit être définie comme une concaténation de sous-chaînes, ou des caractères individuels, et 10(ASCII pour le saut de ligne, qui est interprété comme un caractère). La concaténation dans MATL est [... ...]ou [..., ...](les virgules sont facultatives). Ainsi, par exemple, l'entrée peut être la suivante (concaténation d'une chaîne, d'un saut de ligne et d'une autre chaîne):

['first line' 10 'second']

ou de manière équivalente (concaténation de caractères individuels)

['f' 'i' 'r' 's' 't' ' ' 'l' 'i' 'n' 'e' 10 's' 'e' 'c' 'o' 'n' 'd']

ou (même avec des virgules)

['f', 'i', 'r', 's', 't', ' ', 'l', 'i', 'n', 'e', 10, 's', 'e', 'c', 'o', 'n', 'd']

La deuxième entrée peut être entrée comme 1/ 0ou de manière équivalente comme T/ Fpour true/ falserespectivement.

Explication

10     % Push 10 (ASCII for linefeed)
&Yb    % Take input string implicitly. Split at linefeeds. Gives a cell array
c      % Convert to a 2D char array, right-padding with spaces
i~Q    % Input Boolean value. Negate and add 1. Gives 1/2 for true/false resp.
&P     % Flip along that dimension (1: vertically; 2: horizontally). Display implicitly
Luis Mendo
la source
1
@Fatalize C'est à cause de la façon dont MATL et MATLAB lisent l'entrée. Chaque ligne est une entrée différente
Luis Mendo
2

Brachylog , 26 24 16 octets

t1,?h@nr~@nw|hrw

Attend une liste contenant la chaîne et le booléen 1ou 0, par exemple

run_from_file('code.bl',["P
|    P
|    C
|    G":1]).

Explication

t1,              If the tail of the input is 1
   ?h@n              Split the string on \n
       r             Reverse the resulting list
        ~@n          Join the list of strings with \n
           w         Write to STDOUT
|                Or
hr                   Reverse the string
  w                  Write to STDOUT
Fatalize
la source
2

Pyth, 10 octets

j?Q_.z_M.z

Suite de tests.

j?Q_.z_M.z  first line evaluated as Q, all other lines as .z
 ?Q         if Q:
   _.z         yield reverse(.z)
      _M.z  else: yield map(reverse, .z)
j           join by newlines
Leaky Nun
la source
1

Bash + utilitaires Linux courants, 16

(($1))&&tac||rev

Valeur booléenne (zéro ou non nulle) passée en tant que paramètre de ligne de commande. E / S du bloc de texte via STDIN / STDOUT. Suppose que toutes les lignes ont la même longueur que indiqué dans les commentaires .

Traumatisme numérique
la source
1

C (Ansi), 193 octets

Golfé:

i,y,x;main(g,o,p)char**o;{p=(o[1][0]=='t');while(o[2][++i]!='\n');p?y=(strlen(o[2])-1)/i:(x=i);do do printf("%c",o[2][x+y*i]);while(p?++x<i:x-->0);while(p?x=0,y--:++y<(x=i-1,strlen(o[2])/i));}

Non golfé:

i,y,x;
main(g,o,p)char**o;{
    p=(o[1][0]=='t');
    while(o[2][++i]!='\n'); 
    p?y=(strlen(o[2])-1)/i:(x=i);
    do{
        do{
            printf("%c",o[2][x+y*i]);
        }while(p?++x<i:x-->0);
    }while(p?x=0,y--:++y<(x=i-1,strlen(o[2])/i));
}

Usage:

Arguments de compilation:

gcc -O3 -ansi

Exemple d'entrée:

L'entrée est à ou pas t pour vrai ou faux, suivie d'une piste d'espace de news et d'une chaîne de fin.

./reverseString t "
truck
ducky
quack
moose
"

Exemple de sortie:

moose
quack
ducky
truck
dj0wns
la source
1

JavaScript (ES 6) 83 octets

(c,b)=>(p=c.split`
`)&&(b?p.reverse():p.map(a=>a.split``.reverse().join``)).join`
`

f=(c,b)=>(p=c.split`
`)&&(b?p.reverse():p.map(a=>a.split``.reverse().join``)).join`
`

f("abcde\nfghij\nkl mn\nopqrs\ntuvwx",1)

c="
  o / 
--|/
  | 
 / \
";

f(c,1)
" / \
   | 
 --|/
   o / "

f(c,0)
"/ o  
  /|--
   |  
  \ / "
Charlie Wynn
la source
Je vois une sortie différente pour f(c,0)quand j'essaye - peut-être que votre cn'a pas tous les espaces aux bons endroits.
Neil
L'espace blanc arrière après le premier "o /" est-il significatif?
Peter Mortensen
@PeterMortensen & Neil: Je suis presque sûr que cela vient de mon copier-coller. La console javascript place votre début "sur la première ligne et rend tout terrible, alors je l'ai un peu formaté quand je l'ai collé ici. J'ai très probablement un bug aussi.
Charlie Wynn
1

J, 29 octets

}:@,@(,.&LF@{|."1,:|.)>@cutLF

L'entrée LHS est le booléen où 0 est faux et 1 est vrai. RHS est l'entrée de chaîne.

miles
la source
1

JavaScript (ES6), 76

s=>b=>(s=s.split`
`,b?s.reverse():s.map(r=>[...r].reverse().join``)).join`
`

F=s=>b=>(s=s.split`
`,b?s.reverse():s.map(r=>[...r].reverse().join``)).join`
`

function test()
{
  var rows=I.value, r
  
  // Trim trailing newlines, pad to blank
  rows=rows.split('\n')
  while(!(r=rows.pop()));
  rows.push(r)
  var maxlen=Math.max(...rows.map(r=>r.length))
  rows=rows.map(r=>r+' '.repeat(maxlen-r.length)).join`\n`

  var t1=F(rows)(false)
  var t2=F(rows)(true)
  
  O.textContent = 'False\n'+t1+'\n\nTrue\n'+t2
}

test()
#I { width:50%; height:10em }
<textarea id=I>
  o /
--|/
  |
 / \
</textarea>  
<button onclick=test()>Go</button>
<pre id=O></pre>

edc65
la source
1

Java 99 octets

public String[] reverse(String[]a){
  int i=-1,j=a.length;
  for(;++i<--j;){
    String b=a[i];
    a[i]=a[j];
    a[j]=b;
  }
  return a;
}

Golfé:

String[] e(String[]a){int i=-1,j=a.length;for(;++i<--j;){String b=a[i];a[i]=a[j];a[j]=b;}return a;}
Roman Gräf
la source
1

Perl, 35 octets

Code de 34 octets + 1 pour -n.

Nécessite que les lignes d'entrée soient remplies d'espaces. 13 (!) Octets enregistrés grâce à @ Dada .

print/T/?reverse<>:map~~reverse,<>

Usage

perl -ne 'print/T/?reverse<>:map~~reverse,<>' <<< 'False
  o /
--|/ 
  |  
 / \ '

/ o  
 /|--
  |  
 \ / 

 perl -ne 'print/T/?reverse<>:map~~reverse,<>' <<< 'True
  o /
--|/ 
  |  
 / \ '
 / \ 
  |  
--|/ 
  o /
Dom Hastings
la source
1
perl -ne 'print/T/?reverse<>:map~~reverse,<>'devrait vous faire économiser 13 octets :-)
Dada
@Dada c'est en effet une grosse économie! Je ne sais pas pourquoi je n'aurais pas fait ça mais je vais mettre à jour, merci!
Dom Hastings
0

Mathematica, 70 octets

If[#,Reverse,StringReverse]@ImportString[#2,l="Lines"]~ExportString~l&

La fonction anonyme prend une valeur booléenne comme premier argument (explicitement Trueou Falsedans Mathematica) et la chaîne (multiligne) comme deuxième argument. Importe la chaîne sous forme de liste de chaînes correspondant aux lignes de la chaîne multiligne (la chaîne n'est PAS transmise à la fonction sous forme de tableau). Si True, inversez la liste. Si False StringReversela liste, qui est automatiquement appliquée à chaque élément à son tour. Exportez ensuite la liste sous forme de chaîne, où chaque élément est une nouvelle ligne.

LLlAMnYP
la source
0

05AB1E , 10 octets

U|XiRë€R}»

Explication

U          Remove the first input line and store it in variable X
 |         Aggregate the rest of the input into an array
  XiR      If x is true, revert the array
     ë€R   Else revert each element
        }  End if
         » Join everything with newlines and implicitly display

Essayez-le en ligne!

Osable
la source
0

Vim, 33 octets

Changement de la réponse V précédente à Vim. Toute réponse en V serait très différente, donc ce n'était pas vraiment juste.

DgJ:if@"
g/^/m0
el
se ri
en
cG"

Essayez-le en ligne!

Hexdump

00000000: 4467 4a3a 6966 4022 0a67 2f5e 2f6d 300a  DgJ:if@".g/^/m0.
00000010: 656c 0a73 6520 7269 0a65 6e0a 6347 1222  el.se ri.en.cG."
00000020: 08                                       .
nmjcman101
la source
Vous pourriez probablement économiser un tas d'octets avec ce mappage
DJMcMayhem