Draw ASCII Playing Cards

19

Considere estes 15 padrões de cartas de baralho ASCII (ás ao Joker e verso), onde Xé um espaço reservado para o símbolo do naipe : (eles ficam melhores com menos espaçamento entre linhas)

 -------------   -------------   -------------   -------------   -------------   -------------   -------------   -------------   -------------   -------------   -------------   -------------   -------------   -------------   ------------- 
|AX           | |2X           | |3X           | |4X           | |5X           | |6X           | |7X           | |8X           | |9X           | |10X          | |JX           | |QX           | |KX           | |J            | |* * * * * * *|
|   -------   | |   -------   | |   -------   | |   -------   | |   -------   | |   -------   | |   -------   | |   -------   | |   -------   | |   -------   | |   -------   | |   -------   | |   -------   | |O  -------   | | * * * * * * |
|  |       |  | |  |       |  | |  |       |  | |  |X     X|  | |  |X     X|  | |  |X     X|  | |  |X     X|  | |  |X     X|  | |  |X     X|  | |  |X     X|  | |  |X      |  | |  |X      |  | |  |X      |  | |K |       |  | |* * * * * * *|
|  |       |  | |  |   X   |  | |  |   X   |  | |  |       |  | |  |       |  | |  |       |  | |  |   X   |  | |  |   X   |  | |  |       |  | |  |   X   |  | |  |       |  | |  |       |  | |  |       |  | |E | J     |  | | * * * * * * |
|  |       |  | |  |       |  | |  |       |  | |  |       |  | |  |       |  | |  |       |  | |  |       |  | |  |       |  | |  |X     X|  | |  |X     X|  | |  |       |  | |  |       |  | |  |       |  | |R |  O    |  | |* * * * * * *|
|  |   X   |  | |  |       |  | |  |   X   |  | |  |       |  | |  |   X   |  | |  |X     X|  | |  |X     X|  | |  |X     X|  | |  |   X   |  | |  |       |  | |  |   J   |  | |  |   Q   |  | |  |   K   |  | |  |   K   |  | | * * * * * * |
|  |       |  | |  |       |  | |  |       |  | |  |       |  | |  |       |  | |  |       |  | |  |       |  | |  |       |  | |  |X     X|  | |  |X     X|  | |  |       |  | |  |       |  | |  |       |  | |  |    E  | J| |* * * * * * *|
|  |       |  | |  |   X   |  | |  |   X   |  | |  |       |  | |  |       |  | |  |       |  | |  |       |  | |  |   X   |  | |  |       |  | |  |   X   |  | |  |       |  | |  |       |  | |  |       |  | |  |     R | O| | * * * * * * |
|  |       |  | |  |       |  | |  |       |  | |  |X     X|  | |  |X     X|  | |  |X     X|  | |  |X     X|  | |  |X     X|  | |  |X     X|  | |  |X     X|  | |  |      X|  | |  |      X|  | |  |      X|  | |  |       | K| |* * * * * * *|
|   -------   | |   -------   | |   -------   | |   -------   | |   -------   | |   -------   | |   -------   | |   -------   | |   -------   | |   -------   | |   -------   | |   -------   | |   -------   | |   -------  E| | * * * * * * |
|           XA| |           X2| |           X3| |           X4| |           X5| |           X6| |           X7| |           X8| |           X9| |          X10| |           XJ| |           XQ| |           XK| |            R| |* * * * * * *|
 -------------   -------------   -------------   -------------   -------------   -------------   -------------   -------------   -------------   -------------   -------------   -------------   -------------   -------------   -------------

Escreva um programa que utilize uma sequência que denote uma sequência de cartões separada por espaço usando ...

  • A 2 3 4 5 6 7 8 9 10 J Q Kseguido de um dos C D H S(para tacos, diamantes, copas e espadas) dos 52 cartões padrão.
  • Um single Rpara um Coringa.
  • Um single Bpara o verso (um cartão com a face para baixo).

Portanto, a corda B AS KH 10C R JDdenota uma carta virada para baixo, seguida por um ás de espadas, seguida por um rei de copas, seguido por um dez de paus, seguido por um Coringa, seguido por um valete de diamantes.

Seu programa precisa imprimir as cartas de baralho ASCII correspondentes em stdout, substituindo Xpelo símbolo do naipe apropriado.

Por exemplo, a saída para B AS KH 10C R JDseria

 -------------   -------------   -------------   -------------   -------------   ------------- 
|* * * * * * *| |AS           | |KH           | |10C          | |J            | |JD           |
| * * * * * * | |   -------   | |   -------   | |   -------   | |O  -------   | |   -------   |
|* * * * * * *| |  |       |  | |  |H      |  | |  |C     C|  | |K |       |  | |  |D      |  |
| * * * * * * | |  |       |  | |  |       |  | |  |   C   |  | |E | J     |  | |  |       |  |
|* * * * * * *| |  |       |  | |  |       |  | |  |C     C|  | |R |  O    |  | |  |       |  |
| * * * * * * | |  |   S   |  | |  |   K   |  | |  |       |  | |  |   K   |  | |  |   J   |  |
|* * * * * * *| |  |       |  | |  |       |  | |  |C     C|  | |  |    E  | J| |  |       |  |
| * * * * * * | |  |       |  | |  |       |  | |  |   C   |  | |  |     R | O| |  |       |  |
|* * * * * * *| |  |       |  | |  |      H|  | |  |C     C|  | |  |       | K| |  |      D|  |
| * * * * * * | |   -------   | |   -------   | |   -------   | |   -------  E| |   -------   |
|* * * * * * *| |           SA| |           HK| |          C10| |            R| |           DJ|
 -------------   -------------   -------------   -------------   -------------   -------------

Você pode pegar a entrada do stdin ou escrever uma função que aceita uma string.

A submissão com o menor número de caracteres vence.

Bônus: subtraia 30 da sua contagem de caracteres se você usar os símbolos pretos de naipe Unicode em♣ ♦ ♥ ♠ vez de C D H Sem sua saída. (A entrada sempre usa C D H S.)

Notas

  • Pode haver mais de 54 cartões na sequência de entrada e pode haver duplicatas de qualquer cartão.
  • Não deve haver saída se a entrada for a sequência vazia.
  • Não deve haver espaços à direita além dos (opcionalmente) os dois que compõem os cantos direitos da última carta.
  • Você pode assumir que a entrada é válida.
  • Atualização: a etiqueta inferior direita nos cartões padrão foi revertida para que o valor esteja no canto. O rótulo Joker no canto inferior direito não mudou.
code-golf ascii-art kolmogorov-complexity Passatempos de Calvin
fonte
11
Podemos assumir que a string de entrada é válida?
Michael M.
11
@VisualMelon Eu tentei isso, mas parece engraçado. Ele ficará na posição vertical.
Hobbies de Calvin
3
@Optimizer Eu faria isso se houvesse personagens designados de cabeça para baixo para o que eu preciso, mas acho que não existem e não quero tudo instável.
Hobbies de Calvin
2
@VisualMelon Eu sei que, realisticamente, metade dos rótulos estaria de cabeça para baixo, mas como não há caracteres de cabeça para baixo, estou ignorando esse fato (além de que eu queria os valores no canto).
Hobbies de Calvin
11
Se você apenas subtrair 10 pontos para a codificação correta dos símbolos, nunca valerá a pena, porque você precisará mais do que isso apenas para escrevê-los (6 caracteres por símbolo, 24 no total). Mesmo se você tiver um idioma compatível com unicode, os símbolos unicode estarão na ordem inversa da sua entrada quando alfabéticos. Eu acho que apenas algo como CJAM, APL ou Golfscript seria capaz de fazer isso.
Nzall

Respostas:

9

JavaScript (E6) 542 (572 - bônus 30) 553 564 576

3 tipos de formas:

  1. Costas e Coringa: mais ou menos literal
  2. JQK: marca na parte inferior esquerda e direita, estrutura interna e 3 tipos de linhas no interior, sempre com a mesma estrutura
  3. A ... 10: marca à esquerda e à direita, quadro interno com 3 tipos de linhas no interior, variável com o valor numérico. Cuidado com a pesquisa usando array e variável q

A zsequência (compactada) contém os blocos de construção básicos para

  • cartões numéricos - 3 blocos, 7 caracteres cada
  • Coringa - 11 blocos, 13 caracteres cada, usados ​​simplesmente em sequência

Nota do bônus O código para ganhar o bônus de 30 pontos é de 29 caracteres.

F=c=>(
  p='|',b=' ',d=b+b,t=d+b,
  S='substr',
  z="9J2J4J55O102K |6|1E | J4|1R |1O3|3|2K2|3|3E1| J1|4R | O1|6| K201E55R".replace(/\d/g,n=>n++?b.repeat(n):l='-------'),
  i=7,
  console.log([c.split(b).map(c=>
    m<d
      ?b+l+l[S](1)+b 
      :p+(c=='B'
        ?'* '.repeat(i)[S](i,13)
        :c=='R'
          ?z[S](i,13)
          :(
             [,h,k]=c.match(/(.+)(.)/),
             k='♣♦♥♠'['CDHS'.search(k)], //comment to avoid the unicode symbols 
             n=h-1|0,
             s=t+t+t+(n>8?b:d),
             m-7
              ?m-8
                ?m-9
                  ?d+p+(h>'A'
                     ?-m?m-6?m-3?t+b+t:t+h+t:t+t+k:k+t+t
                     :z[S](([64,1028,1092,8194,8258,8322,8326,9350,8802,9766][n]>>m*2&3)*7,7).replace(/J/g,k)
                   )+p+d
                  :t+l+t
                :s+k+h
              :h+k+s
            )
       )+p
    ).join(b,i+=13)
  for(m of ' 79012345698 ')].join('\n'))
)

Teste no console do FireFox / FireBug

F('10C JD QH KS AC B R')

F('2C 3D 4H 5S 6C 7D 8H 9S')

Resultado

 -------------   -------------   -------------   -------------   -------------   -------------   ------------- 
|10♣          | |J♦           | |Q♥           | |K♠           | |A♣           | |* * * * * * *| |J            |
|   -------   | |   -------   | |   -------   | |   -------   | |   -------   | | * * * * * * | |O  -------   |
|  |♣     ♣|  | |  |♦      |  | |  |♥      |  | |  |♠      |  | |  |       |  | |* * * * * * *| |K |       |  |
|  |   ♣   |  | |  |       |  | |  |       |  | |  |       |  | |  |       |  | | * * * * * * | |E | J     |  |
|  |♣     ♣|  | |  |       |  | |  |       |  | |  |       |  | |  |       |  | |* * * * * * *| |R |  O    |  |
|  |       |  | |  |   J   |  | |  |   Q   |  | |  |   K   |  | |  |   ♣   |  | | * * * * * * | |  |   K   |  |
|  |♣     ♣|  | |  |       |  | |  |       |  | |  |       |  | |  |       |  | |* * * * * * *| |  |    E  | J|
|  |   ♣   |  | |  |       |  | |  |       |  | |  |       |  | |  |       |  | | * * * * * * | |  |     R | O|
|  |♣     ♣|  | |  |      ♦|  | |  |      ♥|  | |  |      ♠|  | |  |       |  | |* * * * * * *| |  |       | K|
|   -------   | |   -------   | |   -------   | |   -------   | |   -------   | | * * * * * * | |   -------  E|
|          ♣10| |           ♦J| |           ♥Q| |           ♠K| |           ♣A| |* * * * * * *| |            R|
 -------------   -------------   -------------   -------------   -------------   -------------   ------------- 

 -------------   -------------   -------------   -------------   -------------   -------------   -------------   ------------- 
|2♣           | |3♦           | |4♥           | |5♠           | |6♣           | |7♦           | |8♥           | |9♠           |
|   -------   | |   -------   | |   -------   | |   -------   | |   -------   | |   -------   | |   -------   | |   -------   |
|  |       |  | |  |       |  | |  |♥     ♥|  | |  |♠     ♠|  | |  |♣     ♣|  | |  |♦     ♦|  | |  |♥     ♥|  | |  |♠     ♠|  |
|  |   ♣   |  | |  |   ♦   |  | |  |       |  | |  |       |  | |  |       |  | |  |   ♦   |  | |  |   ♥   |  | |  |       |  |
|  |       |  | |  |       |  | |  |       |  | |  |       |  | |  |       |  | |  |       |  | |  |       |  | |  |♠     ♠|  |
|  |       |  | |  |   ♦   |  | |  |       |  | |  |   ♠   |  | |  |♣     ♣|  | |  |♦     ♦|  | |  |♥     ♥|  | |  |   ♠   |  |
|  |       |  | |  |       |  | |  |       |  | |  |       |  | |  |       |  | |  |       |  | |  |       |  | |  |♠     ♠|  |
|  |   ♣   |  | |  |   ♦   |  | |  |       |  | |  |       |  | |  |       |  | |  |       |  | |  |   ♥   |  | |  |       |  |
|  |       |  | |  |       |  | |  |♥     ♥|  | |  |♠     ♠|  | |  |♣     ♣|  | |  |♦     ♦|  | |  |♥     ♥|  | |  |♠     ♠|  |
|   -------   | |   -------   | |   -------   | |   -------   | |   -------   | |   -------   | |   -------   | |   -------   |
|           ♣2| |           ♦3| |           ♥4| |           ♠5| |           ♣6| |           ♦7| |           ♥8| |           ♠9|
 -------------   -------------   -------------   -------------   -------------   -------------   -------------   -------------

Código não jogado

F=c=>
{
  p='|',b=' ',d=b+b,t=d+b;
  l='------';
  z="9X2X4XJ55O10-2K |6|1E | J4|1R |1O3|3|2K2|3|3E1| J1|4R | O1|6| K20-1E55R".replace(/\d/g,n=>-n?b.repeat(-~n):l);
  c=c.split(b);
  for(o=i=''; c[0]&&i<13; i++)
  {
    o+=c.map(c => {
      if (i==0 || i==12) r=' -'+l+l+b;
      else
      {
        if (c=='B') r=' *'.repeat(7).substr(i&1,13);
        else if (c=='R') r=z.substr(i*13+8,13);
        else {
          [,h,k]=c.match(/(.+)(.)/),n=h-1|0,
          k='♣♦♥♠'[{C:0,D:1,H:2,S:3}[k]],
          r=t+t+t+(n>8?b:d);
          if(i==1)r=h+k+r;
          else if(i==11)r+=k+h;
          else if(i==2||i==10)r=t+'-'+l+t;
          else {
            if (h>'A')
            {
              if(i==3)r=k+t+t;
              else if(i==9)r=t+t+k;
              else if(i==6)r=t+h+t;
              else r=t+b+t
            }
            else 
            { 
              q=[64,1028,1092,8194,8258,8322,8326,9350,8802,9766][n]>>(i+i-6)&3,
              r=z.substr(q*7,7).replace(/X/g,k)
            }
            r=d+p+r+p+d
          }
        }
        r=p+r+p
      }
      return r
    }).join(' ')+'\n'
  }  
  console.log(o);
}
edc65
fonte
Eu acho que você trocou corações e diamantes (no seu exemplo, de qualquer forma, não consegui encontrar o erro no seu código ...).
FryAmTheEggman
@FryAmTheEggman obrigado, corrigido no código e nos exemplos de
golfe
ótimo código! Você pode reduzir sua contagem de char com esta ferramenta: xem.github.io/obfuscatweet (ele só aceita ASCII, porém, assim você tem que escapar os caracteres Unicode antes de embalagem)
xem
(Seu resultado final será em torno de 328!)
xem 29/09
@xem A contagem de caracteres é baixa (337), mas a contagem de bytes é alta (1213) mothereff.in/byte-counter . A menos que seja especificado, você deve contar bytes no código golf.
Edc65
4

C # - 906

Programa C # bastante grande e simples que leva as entradas e saídas da linha de comando para a saída padrão. Provavelmente ainda há muito que pode ser jogado no golfe, eu descobri alguns bytes chatos enquanto escrevia isso, mas isso terá que esperar. Eu não acho que vou optar pelo bônus de personagem do terno Unicode.

Código de golfe:

class P{static void Main(string[]A){int O,i=0,L,n;for(;i<13;i++){var k="";foreach(var a in A){var R=new char[208];System.Action<int,int,string,int>P=(s,l,g,w)=>{for(O=0;O<l;s+=O%w<1?17-w:1)R[s]=g[O++%g.Length];};P(0,208," ",16);P(1,13,"-",13);P(193,13,"-",13);P(16,11,"|",1);P(30,11,"|",1);if(a=="B")P(17,143,"* ",13);else{P(36,7,"-",7);P(164,7,"-",7);P(51,7,"|",1);P(59,7,"|",1);if(a=="R"){P(17,5,"JOKER",1);P(125,5,"JOKER",1);P(69,25,"J     O     K     E     R",5);}else{L=a.Length;var S=a.Substring(L-1);var v=a.Substring(0,L-1);P(17,L,a,L);P(190-L,L,S+v,L);if(int.TryParse(v,out n)){var f=new string[]{S="HEHI",S+"HG",S="EDKDEJKJ",S+"HG",v=S+"EGKG",v+="HE",v+"HI",(S+="EFEHKFKH")+"HG",S+"HEHI",}[n-2];for(O=0;O<f.Length;)R[f[O++]+f[O++]*16-1105]=a[L-1];}else{if(v=="A"){P(103,1,S,1);}else{P(52,1,S,1);P(154,1,S,1);P(103,1,v,1);}}}}for(O=0;O<16;)k+=R[i*16+O++];}System.Console.WriteLine(k.TrimEnd());}}}

Exemplo de saída para cardGolf.exe 7H QH 3S B R

 -------------   -------------   -------------   -------------   -------------
|7H           | |QH           | |3S           | |* * * * * * *| |J            |
|   -------   | |   -------   | |   -------   | | * * * * * * | |O  -------   |
|  |H     H|  | |  |H      |  | |  |       |  | |* * * * * * *| |K |       |  |
|  |   H   |  | |  |       |  | |  |   S   |  | | * * * * * * | |E | J     |  |
|  |       |  | |  |       |  | |  |       |  | |* * * * * * *| |R |  O    |  |
|  |H     H|  | |  |   Q   |  | |  |   S   |  | | * * * * * * | |  |   K   |  |
|  |       |  | |  |       |  | |  |       |  | |* * * * * * *| |  |    E  | J|
|  |       |  | |  |       |  | |  |   S   |  | | * * * * * * | |  |     R | O|
|  |H     H|  | |  |      H|  | |  |       |  | |* * * * * * *| |  |       | K|
|   -------   | |   -------   | |   -------   | | * * * * * * | |   -------  E|
|           H7| |           HQ| |           S3| |* * * * * * *| |            R|
 -------------   -------------   -------------   -------------   -------------

A maior parte da renderização é feita pelo Pmétodo anônimo, que assume uma posição, comprimento, sequência e largura e renderiza um retângulo da sequência. Por exemplo, a parte de trás do cartão é apenas "* "repetida. O Tmétodo anônimo é uma versão modificada de uma que usei para uma tarefa anterior, que renderiza muitos retângulos. É, no entanto, bastante volumoso e só me permite renderizar as bordas e o fundo em menos bytes, o que provavelmente não vale a pena. Uma versão listrada Té a Wque renderiza células em vez de retângulos, e também não é usada, mas uma versão embutida é usada para renderizar cartões de valor de 2 a 10. Observe que o código não utilizado foi removido para a contagem de bytes, deixo-o porque posso acabar usando-o e os uso para teste.

O programa simplesmente percorre cada linha de saída (13 delas) e, em seguida, renderiza cada cartão por vez e extrai 1 fatia dele, para que cada cartão seja renderizado na sua totalidade 13 vezes. Com o objetivo de espaçá-los, cada cartão é tratado como um bloco de 16 por 13, e eu apodo cada linha de saída para remover os espaços finais (os espaços dos cantos são removidos).

Código formatado, com comentários e código de conceito / teste:

class P
{
    static void Main(string[]A)
    {
        int O,J,i=0,L,n,r,z;

        for(;i<13;i++)
        {
            var k="";
            foreach(var a in A)
            {
                // got card a and line i

                var R=new char[208];

                System.Action<int,int,string,int>P=(s,l,g,w)=>
                {
                    for(O=0;O<l;s+=O%w<1?17-w:1)
                        R[s]=g[O++%g.Length];
                };

                // not used
                System.Action<string>T=f=>
                {
                    f+="AAPM!";
                    for(J=64;J++<77;)
                        for(O=64;O++<80;R[z=O+J*16-1105]=f[r]=='!'?R[z]:f[r])
                            for(r=0;f[r++]>O|f[r++]>J|O>f[r++]|J>f[r++];r++);
                };

                // not used (derivative below)
                System.Action<string>W=f=>
                {
                    for(O=0;O<f.Length;)
                        R[f[O++]+f[O++]*16-1105]=f[O++];
                };

                // render

                // outer

                P(0,208," ",16); // fill 
                P(1,13,"-",13); // top
                P(193,13,"-",13); // bottom
                P(16,11,"|",1); // left
                P(30,11,"|",1); // left

                //T("BBNL BANM-ABOL|AAPM ");

                if(a=="B") // back
                    P(17,143,"* ",13);
                else
                {
                    // inner

                    P(36,7,"-",7); // top
                    P(164,7,"-",7); // bottom
                    P(51,7,"|",1); // left
                    P(59,7,"|",1); // left

                    //T("EDKJ ECKK-DDLJ|");

                    // joker
                    if(a=="R")
                    {
                        P(17,5,"JOKER",1);
                        P(125,5,"JOKER",1);
                        P(69,25,"J     O     K     E     R",5);
                        //T("FEFEJGFGFOHGHGKIHIHEJIJIR");
                    }
                    else
                    {
                        L=a.Length;

                        // card
                        var S=a.Substring(L-1);
                        var v=a.Substring(0,L-1);

                        P(17,L,a,L);
                        P(190-L,L,S+v,L);

                        if(int.TryParse(v,out n))
                        {
                            // number card
                            var f=new string[]
                            {
                                S="HEHI",
                                S+"HG",
                                S="EDKDEJKJ",
                                S+"HG",
                                v=S+"EGKG",
                                v+="HE",
                                v+"HI",
                                (S+="EFEHKFKH")+"HG",
                                S+"HEHI",
                            }[n-2];
                            for(O=0;O<f.Length;)
                                R[f[O++]+f[O++]*16-1105]=a[L-1];
                        }
                        else
                        {
                            if(v=="A")
                            {
                                // ace
                                P(103,1,S,1);
                            }
                            else
                            {
                                // face card
                                P(52,1,S,1);
                                P(154,1,S,1);
                                P(103,1,v,1);
                            }
                        }
                    }
                }

                // write

                for(O=0;O<16;)
                    k+=R[i*16+O++];
            }
            System.Console.WriteLine(k.TrimEnd());
        }
    }
}
VisualMelon
fonte
1

PowerShell , pontuação 442 = ( 509 495 472 bytes = (156 script + arquivo 316) - 30 bônus)

param($s)tar xOf t|%{$l=$_
($s-split'1| '-ne''|%{($l|% s*g(14*('A234567890JQKRB'|% i*f $_[0]))15)-replace'X','♣♦♥♠'[('CDHS'|% i*f $_[1])]})-join' '}

Experimente online!

Desenrolado:

# # the tar archive t should be in default folder
param($s)
tar xOf t|%{ $line=$_
    ($s-split'1| '-ne''|%{
        $pos = 14*('A234567890JQKRB'|% indexOf $_[0])
        $x=$line|% SubString $pos 15

        $suit = 'CDHS'|% indexOf $_[1]
        $x-replace'X','♣♦♥♠'[$suit]
    })-join' '                                          # implicit output
}

Script do Powershell para criar o arquivo tar t(consulte TIO):

(
' ------------- ------------- ------------- ------------- ------------- ------------- ------------- ------------- ------------- ------------- ------------- ------------- ------------- ------------- ------------- ',
'|AX           |2X           |3X           |4X           |5X           |6X           |7X           |8X           |9X           |10X          |JX           |QX           |KX           |J            |* * * * * * *|',
'|   -------   |   -------   |   -------   |   -------   |   -------   |   -------   |   -------   |   -------   |   -------   |   -------   |   -------   |   -------   |   -------   |O  -------   | * * * * * * |',
'|  |       |  |  |       |  |  |       |  |  |X     X|  |  |X     X|  |  |X     X|  |  |X     X|  |  |X     X|  |  |X     X|  |  |X     X|  |  |X      |  |  |X      |  |  |X      |  |K |       |  |* * * * * * *|',
'|  |       |  |  |   X   |  |  |   X   |  |  |       |  |  |       |  |  |       |  |  |   X   |  |  |   X   |  |  |       |  |  |   X   |  |  |       |  |  |       |  |  |       |  |E | J     |  | * * * * * * |',
'|  |       |  |  |       |  |  |       |  |  |       |  |  |       |  |  |       |  |  |       |  |  |       |  |  |X     X|  |  |X     X|  |  |       |  |  |       |  |  |       |  |R |  O    |  |* * * * * * *|',
'|  |   X   |  |  |       |  |  |   X   |  |  |       |  |  |   X   |  |  |X     X|  |  |X     X|  |  |X     X|  |  |   X   |  |  |       |  |  |   J   |  |  |   Q   |  |  |   K   |  |  |   K   |  | * * * * * * |',
'|  |       |  |  |       |  |  |       |  |  |       |  |  |       |  |  |       |  |  |       |  |  |       |  |  |X     X|  |  |X     X|  |  |       |  |  |       |  |  |       |  |  |    E  | J|* * * * * * *|',
'|  |       |  |  |   X   |  |  |   X   |  |  |       |  |  |       |  |  |       |  |  |       |  |  |   X   |  |  |       |  |  |   X   |  |  |       |  |  |       |  |  |       |  |  |     R | O| * * * * * * |',
'|  |       |  |  |       |  |  |       |  |  |X     X|  |  |X     X|  |  |X     X|  |  |X     X|  |  |X     X|  |  |X     X|  |  |X     X|  |  |      X|  |  |      X|  |  |      X|  |  |       | K|* * * * * * *|',
'|   -------   |   -------   |   -------   |   -------   |   -------   |   -------   |   -------   |   -------   |   -------   |   -------   |   -------   |   -------   |   -------   |   -------  E| * * * * * * |',
'|           XA|           X2|           X3|           X4|           X5|           X6|           X7|           X8|           X9|          X10|           XJ|           XQ|           XK|            R|* * * * * * *|',
' ------------- ------------- ------------- ------------- ------------- ------------- ------------- ------------- ------------- ------------- ------------- ------------- ------------- ------------- ------------- '
) | Set-Content f -Force
tar zcf t f -o
Get-ChildItem t # output info about archive size
confuso
fonte