Print the Flag of the Arab Revolt!

Question

It seems flags are a trend now, so what better place to start an account? I thought bars could use a twist to them, so I found this flag.

Produce the following in the console output the fewest possible bytes:

+----------------------------------+
|XXXXX                             |
|XXXXXXXX                          |
|XXXXXXXXX-------------------------+
|XXXXXXXXXXX                       |
|XXXXXXXXXXX                       |
|XXXXXXXXX-------------------------+
|XXXXXXXX                          |
|XXXXX                             |
+----------------------------------+

This crude rendition of the flag is 36 x 10 characters. A trailing newline on the last line is optional. You may use any language you choose. If it is an obscure language, please post a link to the language in your answer.

Answer 1

SQL (PostgreSQL flavour), 284 244 232 210 175 bytes

A HUGE Thank You to @manatwork for essentially the whole thing now.

A nice verbose language that still came in under the byte size of the flag, with a bit of a margin :)

Basically builds the half of the flag with using parameters. This is cross joined with 1 and -1 giving us both halfs of the flag and a means to order it by negating the number of #'s in the row.

SELECT rpad(rpad(L,X,'X'),35,P)||R FROM(VALUES('|',12,' ','|'),('|',10,'-','+'),('|',9,' ','|'),('|',6,' ','|'),('+',1,'-','+'))F(L,X,P,R),(values(-1),(1))G(O)ORDER BY(12-X)*O

Formatted and commented

SELECT rpad(rpad(L,X,'X'),35,P)||R --Build each row from parameters
FROM(VALUES           -- Parameters for each row
    ('|',12,' ','|'), -- Start Char, Num of #, Pad Char, End Char
    ('|',10,'-','+'),
    ('|',9,' ','|'),
    ('|',6,' ','|'),
    ('+',1,'-','+')
    )F(L,X,P,R),
    (values(-1),(1))G(O) -- Cross join with order modifier
ORDER BY(12-X)*O -- Order by modified number of #

Answer 2

CJam, 44 bytes

8T5@9B]_W%+{I'|'+?'XI*34"-  "I=e]"+||"I=N}fI

(Thanks to @Dennis, @Jakube and @Optimizer for -1 byte each)

8T5@9B]        Push [0 5 8 9 11]
_W%+           Add its reverse, to give [0 5 8 9 11 11 9 8 5 0]
{...}fI        For each I in the above array...
  I'|'+?         Push "+" if I == 0 else "|"
  'XI*             Push I "X"s
  34"-  "I=e]      Pad the "X"s to length 34 with "-" if I%3 == 0 else " "
  "+||"I=          Push "+" if I%3 == 0 else "|"
  N                Push a newline

Answer 3

Python 2, 80

for n in 0,5,8,9,11,11,9,8,5,0:print'|+'[n<1]+'X'*n+'-  '[n%3]*(34-n)+'+||'[n%3]

Instead of iterating over the row numbers, iterate over the number of X-symbols directly. The stripes happen where n is 0 or 9, which are the only multiples of 3, and so can be checked by the value n%3 (thanks Sp3000).

This can surely be shortened in Python 3 by converting the list of numbers to a bytes object.

Answer 4

CJam, 52 51 50 bytes

8U5@9B]34X$f-]z87Zb"X ||X-++X-+|"4/f=..*1fm>_W%+N*

Thanks to @Sp3000 for golfing off 1 byte!

Try it online in the CJam interpreter.

How it works

8U5@9B] e# Push [0 5 8 9 11] (`@` rotates on top).
34X$f-  e# Subtract each integer from 34.
]z      e# Wrap and zip. This pushes [[0 34] [5 29] [8 26] [9 25] [11 23]].
87Zb    e# Push [1 0 0 2 0] (87 in base 3).

"X ||X-++X-+|"4/

        e# Push ["X ||" "X-++" "X-+|"].

f=      e# Select for each. This pushes ["X-++" "X ||" "X ||" "X-+|" "X ||"].

..*     e# Twofold vectorized repetition.
        e# EXAMPLE: [9 25]"X-+|".* -> "XXXXXXXXX-------------------------+|"

1fm>    e# Rotate each string one character to the right.  
_W%     e# Copy the resulting array and reverse the order of its lines.
+N*     e# Concatenate and join by linefeeds.

Answer 5

JavaScript (ES6), 147 132 127 111 106 bytes

[0,5,8,9,11,11,9,8,5,0].map(v=>console.log('|+'[+!v]+'X'.repeat(v)+' -'[z=+!(v%3)].repeat(36-v)+'|+'[z]))

Demo

As it is ES6, it only works in Firefox at the moment.

// DEMO: redefine console.log to have output inside the snippet
// Taken from https://codegolf.stackexchange.com/a/52411/22867
console.log = (...x) => O.innerHTML += x + '\n';

// Actual program
[0,5,8,9,11,11,9,8,5,0].map(v=>console.log('|+'[+!v]+'X'.repeat(v)+' -'[z=+!(v%3)].repeat(36-v)+'|+'[z]))

<pre><output id=O></output></pre>

Answer 6

C, 157 155 151 146 bytes

i;f(){for(char b[36];i<10;printf("%c%.34s%c\n",i++%9?124:43,b,i%3?124:43))memset(b,i%3?32:45,34),i%9?memset(b,120,35253>>((i<5?5-i:i)%4*4)&15):0;}

edit: I moved the string length inside of the format string and found two bytes.

edit: Added Cool Guy's recommendation and found four bytes.

edit: Removed the array and replaced it with a 4-bit packed short that's shifted to get the 'x' lengths

Answer 7

CJam, 60 54 50 48 45 bytes

Compared to the previous version, I realized that one of the 5 entries in my descriptors was always the same, which was kind of pointless. Using a fixed value for it:

"++-0|| 5|| 8|+-9|| B"4/_W%+{1/~~'X*34@e]\N}/

Try it online

Thanks to @aditsu and @Sp3000 for some related help in chat this morning.

The basic approach here is that I have 4 character descriptors for the pattern of each line, where the characters in the descriptor are:

• First character.
• Last character.
• Right fill character.
• Repeat count for left fill character.

The left fill character, which was part of the descriptor in earlier versions of this solution, is always X, so it is now not part of the descriptor anymore.

These descriptors are specified for the top 5 lines, and repeated for the bottom 5 lines in reverse order.

Explanation:

"++-0|| 5|| 8|+-9|| B"
        Descriptors for top 5 lines, as described above.
4/      Split into 5 descriptors of 4 characters each.
_W%     Repeat the 5 descriptors in reverse order.
{       Loop over lines/descriptors.
    1/    Split descriptor string into array with 5 one-character strings.
    ~     Unwrap the array.
    ~     Evaluate last entry in descriptor, which is the count.
    'X    Left fill character.
    *     Repeat left fill character by given count.
    34@e] Pad to 34 characters using right fill character.
    \     Swap last character to top.
    N     Add a newline.
}/    End loop over lines/descriptors.

Answer 8

Python 3, 282 bytes/characters

f,l,h=lambda a:a in{0,35}and '+'or'-',lambda a:a%3 and'|'or'+',lambda a:a and(a<10 and 'X'or'-')or'|';print("\n".join("".join(x)for x in[[k in{0,9}and f(j)or j==35 and l(k)or k%3 and(j==0 and'|'or j<[0,6,9,0,12,12,0,9,6][k]and'X'or' ')or h(j)for j in range(36)]for k in range(10)]))

Output is, of course:

+----------------------------------+
|XXXXX                             |
|XXXXXXXX                          |
|XXXXXXXXX-------------------------+
|XXXXXXXXXXX                       |
|XXXXXXXXXXX                       |
|XXXXXXXXX-------------------------+
|XXXXXXXX                          |
|XXXXX                             |
+----------------------------------+

I'm sure there's a much shorter way to do this in Python.

Answer 9

Ruby, 78

"@EHIKKIHE@".each_byte{|i|puts"+|"[i/65]+?X*(i-64)+" -"[i%3]*(98-i)+"|+"[i%3]}

A copy of Rinkattendant's / Xnor's idea of iterating over the lengths of the strings of X's. Except instead of using an array, I have compressed them into a string.

Ruby, 96

Original plain vanilla approach

(0..9).each{|i|puts (i%9<1??+:?|)+(?X*("@EHIKKIHE@"[i].ord-64)).ljust(34,"-  "[i%3])+"+||"[i%3]}

Ungolfed

(0..9).each{|i|
   puts (i%9<1??+:?|)                                          #first character + or |
   +(?X*("@EHIKKIHE@"[i].ord-64)).ljust(34,"-  "[i%3])         #print quantity of X's according to string, then right justify with - or space
   +"+||"[i%3]}                                                #last character + or |

Answer 10

Ruby, 156 155 chars

h=[5,8,9,11];l=34;t=?++(?-*l)+?+;puts t;2.times{h.each{|c|if c==9 then j='-+' else j=' |';end;print(?|,((?X*c).ljust(l,j[0])),j[1],?\n)};h.reverse!};puts t

I used an array, h, with the values [5, 8, 9, 11], so I can use 2.times { h.each { code }; h.reverse } because the flag is symmetrical horizontally. I also use 34 many times in the code, so it is assigned to l. ?x is shorthand for "x".

Answer 11

Swift 1.2, 157 bytes

Can be run in a playground, or from a file using swift file.swift in Terminal.

let z="-----",x="XXX",y="   ",g=y+y,w=z+z+z+z+"----+",e=g+g+g+y+"  |",c="|XX"+x,d=["+"+z+z+w,c+g+e,c+x+y+e,c+x+"X-"+w,c+x+x+e]
print("\n".join(d+reverse(d)))

Answer 12

PHP, 135 bytes

Lets play around with printf:

<?$A='|%-34s|
|%-34s|';$B="|%'--34s|";printf("+%'-34s+
$A
$B
$A
$B
$A
+%'-34s+",'',$a=XXXXX,$b=$a.XXX,$c=$b.X,$d=$b.XX,$d,$c,$b,$a,'');

Maybe there are some edges that I've left behind that can be cut.

But it was fun!

Answer 13

Vyxal j, 41 bytes

»'ꜝ»12τƛ\X*34↲n9=[ð\-V\+|\|]+\|p;\+17-mpm

Try it Online!

    12τ                                   # Base-12 digits of...
»'ꜝ»                                      # 9119 (so 5,8,9,11)
       ƛ                        ;         # Mapped to...
        \X*                               # That many Xs
           34↲                            # Padded to width of 34
              n9=[         ]              # If it's a 9...             
                  ð\-V\+                  # Replace all spaces with -s and append a +
                        |\|               # Else append a |
                            +\|p          # Prepend a |
                                 \+       # '+'
                                   17-    # Append 17 -s
                                      m   # Mirror the result
                                       p  # Prepend that to the rest
                                        m # Mirror the lot. 

Answer 14

Sed - 228

s/.*/eeeeee\neeeeee/
s/e/------/g
s/^-/+/
s/-$/+/
s/-\n-/+\n+/
s/\n/\nabcddcba/
s/\([a-d]\)/|XXXXX\1\1\1\1\1\1\n/g
s/\([a-d]\)/\1\1\1\1\1/g
s/Xbbb/XXXX/g
s/Xcccc/XXXXX/g
s/Xdddddd/XXXXXXX/g
y/abcd/  - /
s/ \n/|\n/g
s/-\n/+\n/g
q

Because of the way sed works, this requires a line of input to output the flag.

Answer 15

Haskell, 233 bytes

putStr$uncurry((.toEnum).replicate)=<<foldl1(++)(((++)=<<reverse)$zipWith zip[[1,11,23,1,1],[1,9,25,1,1],[1,8,26,1,1],[1,5,29,1,1],[1,34,1,1]][[124,88,32,124,10],[124,88,45,43,10],[124,88,32,124,10],[124,88,32,124,10],[43,45,43,10]])

Answer 16

Deadfish~, 558 bytes

{iiii}iiicii{ccc}ccccddc{ddd}c{{i}i}ic{ddd}ddddddccccc{dddddd}iiii{cc}ccccccccc{{i}d}iicd{{d}d}c{{i}i}ic{ddd}ddddddcccccccc{dddddd}iiii{cc}cccccc{{i}d}iicd{{d}d}c{{i}i}ic{ddd}ddddddccccccccc{dddd}ddd{cc}ccccc{{i}dd}dcd{{d}d}c{{i}i}ic{ddd}dddddd{c}c{dddddd}iiii{cc}ccc{{i}d}iicd{{d}d}c{{i}i}ic{ddd}dddddd{c}c{dddddd}iiii{cc}ccc{{i}d}iicd{{d}d}c{{i}i}ic{ddd}ddddddccccccccc{dddd}ddd{cc}ccccc{{i}dd}dcd{{d}d}c{{i}i}ic{ddd}ddddddcccccccc{dddddd}iiii{cc}cccccc{{i}d}iicd{{d}d}c{{i}i}ic{ddd}ddddddccccc{dddddd}iiii{cc}ccccccccc{{i}d}iicd{{d}d}c{iii}cii{ccc}ccccddc

Try it online!