74
\$\begingroup\$

...will you help me immortalize it?

enter image description here

I've had this pillow a few years now, and apparently it's time to get rid of it. Can you please write a function or program, that I can bring with me and use to recreate this pillow whenever I want to reminisce a bit.

It must work with no input arguments.

The output should look exactly like this (trailing newlines and spaces are OK).

/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////

This is code golf, so the shortest code in bytes win!


Leaderboard

var QUESTION_ID=98701,OVERRIDE_USER=31516;function answersUrl(e){return"https://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(e,s){return"https://api.stackexchange.com/2.2/answers/"+s.join(";")+"/comments?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){answers.push.apply(answers,e.items),answers_hash=[],answer_ids=[],e.items.forEach(function(e){e.comments=[];var s=+e.share_link.match(/\d+/);answer_ids.push(s),answers_hash[s]=e}),e.has_more||(more_answers=!1),comment_page=1,getComments()}})}function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){e.items.forEach(function(e){e.owner.user_id===OVERRIDE_USER&&answers_hash[e.post_id].comments.push(e)}),e.has_more?getComments():more_answers?getAnswers():process()}})}function getAuthorName(e){return e.owner.display_name}function process(){var e=[];answers.forEach(function(s){var r=s.body;s.comments.forEach(function(e){OVERRIDE_REG.test(e.body)&&(r="<h1>"+e.body.replace(OVERRIDE_REG,"")+"</h1>")});var a=r.match(SCORE_REG);a&&e.push({user:getAuthorName(s),size:+a[2],language:a[1],link:s.share_link})}),e.sort(function(e,s){var r=e.size,a=s.size;return r-a});var s={},r=1,a=null,n=1;e.forEach(function(e){e.size!=a&&(n=r),a=e.size,++r;var t=jQuery("#answer-template").html();t=t.replace("{{PLACE}}",n+".").replace("{{NAME}}",e.user).replace("{{LANGUAGE}}",e.language).replace("{{SIZE}}",e.size).replace("{{LINK}}",e.link),t=jQuery(t),jQuery("#answers").append(t);var o=e.language;/<a/.test(o)&&(o=jQuery(o).text()),s[o]=s[o]||{lang:e.language,user:e.user,size:e.size,link:e.link}});var t=[];for(var o in s)s.hasOwnProperty(o)&&t.push(s[o]);t.sort(function(e,s){return e.lang>s.lang?1:e.lang<s.lang?-1:0});for(var c=0;c<t.length;++c){var i=jQuery("#language-template").html(),o=t[c];i=i.replace("{{LANGUAGE}}",o.lang).replace("{{NAME}}",o.user).replace("{{SIZE}}",o.size).replace("{{LINK}}",o.link),i=jQuery(i),jQuery("#languages").append(i)}}var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk",answers=[],answers_hash,answer_ids,answer_page=1,more_answers=!0,comment_page;getAnswers();var SCORE_REG=/<h\d>\s*([^\n,]*[^\s,]),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/,OVERRIDE_REG=/^Override\s*header:\s*/i;
body{text-align:left!important}#answer-list,#language-list{padding:10px;width:290px;float:left}table thead{font-weight:700}table td{padding:5px}
<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script> <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"> <div id="answer-list"> <h2>Leaderboard</h2> <table class="answer-list"> <thead> <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr></thead> <tbody id="answers"> </tbody> </table> </div><div id="language-list"> <h2>Winners by Language</h2> <table class="language-list"> <thead> <tr><td>Language</td><td>User</td><td>Score</td></tr></thead> <tbody id="languages"> </tbody> </table> </div><table style="display: none"> <tbody id="answer-template"> <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table> <table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table>

\$\endgroup\$
7
  • 10
    \$\begingroup\$ I'm somewhat disappointed that the pattern isn't a little more complex, to represent the different line thicknesses of the pillow. \$\endgroup\$
    – Sparr
    Commented Nov 6, 2016 at 11:29
  • 5
    \$\begingroup\$ @Sparr I tried, but I didn't manage to make it look good using only ASCII characters. Figured this was close enough :) \$\endgroup\$ Commented Nov 6, 2016 at 11:37
  • 4
    \$\begingroup\$ I'd have just added spaces \$\endgroup\$
    – Sparr
    Commented Nov 6, 2016 at 20:37
  • 2
    \$\begingroup\$ 'apparently' :P \$\endgroup\$
    – Pysis
    Commented Nov 7, 2016 at 19:01
  • 11
    \$\begingroup\$ Now you can buy a blank pillow and print the winner snippet on it. \$\endgroup\$
    – coredump
    Commented Nov 7, 2016 at 19:46

75 Answers 75

1 2
3
1
\$\begingroup\$

Nibbles, 13 bytes

^3`<^4`:;^6`<^5"/\\"\$

explanation

^3                     # replicate 3 times
  `<                   # sort
    ^4                 # replicate 4 times
      `:               # list of two lists (for getting newlines)
        ;              # let (save value to $)
         ^6            # replicate 6 times
           `<          # sort
             ^5        # replicate 5 times
               "/\\"   # the string /\
                    \$ # reverse the saved value

Note that that last $ can't be omitted because in the binary form the sort needs to place more data after its arg

\$\endgroup\$
1
\$\begingroup\$

Charcoal, 26 bytes

UO⁵¦⁴/‖M↓→‖M↓→‖M‖BO²⁰‖BO↓⁸

Try it online! Link is to verbose version of code.

Explanation:

UO⁵¦⁴/  - drawing a 5 by 4 rectangle filled with /
‖M↓→            - reflect and mirror the canvas to the down and right direction (note that for this pattern order doesn't matter)
‖M             - reflect mirror without a argument (default is to the right, n times)
‖BO²⁰         - reflect butterfly overlap which would reflect the same thing n times to the left by default
‖BO↓⁸        - 8 characters but this time with a given direction which is down
 

Optimizing: -9, Thanks to @Neil for the help on reflects.

\$\endgroup\$
1
\$\begingroup\$

Vyxal j, 14 bytes

k/5•4ε:RJ6*3ẋf

Try it Online!

k/             # "/\"
  5•           # Repeat each char 5 times
    4ε         # Repeat 4 times
      :RJ      # Append a reversed copy
         6*    # Repeat each line six times
           3ẋf # Repeat the whole thing three times
\$\endgroup\$
1
\$\begingroup\$

Bash, 120 109 bytes

z='/ \\'
f(){ printf $1$1$1$1$2$2$2$2;}
for i in {1..144};{
f $z;((i%6))||echo
((i%24))||z=${z#* }\ ${z% *}
}

Try it online!

\$\endgroup\$
0
\$\begingroup\$

Batch, 132 bytes

@set s=/////\\\\\
@set s=%s%%s%%s%%s%%s%%s%
@set s=%s% %s:~5%/////
@for %%s in (%s% %s% %s%)do @for /l %%i in (1,1,4)do @echo %%s

Works by building up the two types of row, then looping through six rows four times per row.

\$\endgroup\$
0
\$\begingroup\$

Racket 156 bytes

(define g #t)(for((k 24))(for((i 12))(for((j 5))(display(if g "/""\\")))(set! g(if g #f #t)))
(when(= 0(modulo(add1 k)4))(set! g(if g #f #t)))(displayln""))

Ungolfed:

(define(f)
  (define g #t)
  (for ((k 24))
    (for ((i 12))
      (for ((j 5))
        (display (if g "/" "\\")))
      (set! g (if g #f #t)))
    (when (= 0 (modulo (add1 k) 4))
      (set! g (if g #f #t)))
    (displayln "")))

Testing:

(f)

Output:

/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\$\endgroup\$
0
\$\begingroup\$

Python 3, 60 bytes

Lots of multiplying strings!

print((((('/'*5+'\\'*5)*6+'\n')*4)+(('\\'*5+'/'*5)*6+'\n')*4)*3)

Output

/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\$\endgroup\$
0
\$\begingroup\$

Powershell, 77 bytes

I must say I thought this would be easier with PowerShell, but it's quite hard to create something more condense than this.

$a=@("/","\");"$(1..6|%{1..3|%{1..6|%{$a[$b]*5;$a[!$b]*5};"rn"}; $b=!$b})"

More readable:

$a=@("/","\")
"$(1..6|%{
    1..3|%{ 
     1..6|%{
     $a[$b]*5
     $a[!$b]*5
        }
     "`r`n"}
    $b=!$b})"

I'm using the index numbers of the array in order to decide whether I should put \ or / and between every loop I simply toggle the variable.

\$\endgroup\$
4
  • \$\begingroup\$ Welcome to PPCG! I get your logic, but it doesn't seem to work quite right. With the code as-is, you're going to get a bunch of Index operation failed; the array index evaluated to null. errors since $b is uninitialized on the first inner loop of 1..6. Additionally, this will join the strings you're creating with spaces, since that's the default $OutputFieldSeparator when stringifying an array (what you're doing here). \$\endgroup\$ Commented Nov 8, 2016 at 20:06
  • \$\begingroup\$ Additionally, you don't need both r and n -- just n will work for newlines. You've also got an extra space between ; and $b=. \$\endgroup\$ Commented Nov 8, 2016 at 20:08
  • \$\begingroup\$ Must be ISE messing with me again. The host retains variables between each run, that's what got me here. Dammit. \$\endgroup\$
    – Chavez
    Commented Nov 8, 2016 at 21:15
  • \$\begingroup\$ You can fix the array index by putting a + in front -- like $a[+$b] -- to force a cast to int. However, that doesn't eliminate the spaces between elements. :-/ \$\endgroup\$ Commented Nov 8, 2016 at 21:31
0
\$\begingroup\$

tcl, 97

proc r s\ n {string repe $s $n}
puts [r [r [r /////[r \\ 5] 6]\n 4][r [r [r \\ 5]///// 6]\n 4] 3]

My try to outgolf myself didn't go well :( :

tcl, 102

proc r s\ n {string repe $s $n}
proc R s\ t {r [r [r $s 5][r $t 5] 6]\n 4}
puts [r [R / \\][R \\ /] 3]

runnable on: http://rextester.com/live/HURDH99224

\$\endgroup\$
0
\$\begingroup\$

Python 2, 83 55 bytes

x=('/'*5+'\\'*5)*6;print((x+'\n')*4+(x[::-1]+'\n')*4)*3

Try it online!

-28 bytes thanks to Leaky Nun

\$\endgroup\$
3
0
\$\begingroup\$

Pyth, 21 20 bytes

J*6S*5"/\\"V6V4J)=_J

Try it online!

Python 3 translation:
J=6*sorted(5*"/\\")
for N in range(6):
    for N in range(4):
        print(J)
    J=J[::-1]
\$\endgroup\$
0
\$\begingroup\$

Add++ -i, 27 bytes

L,"/\"5€*6*b]4*d€bR+3*bUBJn

Try it online!

The -i flag simply invokes the function with a clean stack and then outputs its return value.

How it works

L,		; Anonymous function
	"/\"	; Push this string			STACK = ["/\"]
	5€*	; Repeat each character 5 times		STACK = [["/////" "\\\\\"]]
	6*	; Repeat the array 6 times		STACK = [["/////" "\\\\\" "/////" "\\\\\" "/////" "\\\\\" "/////" "\\\\\" "/////" "\\\\\" "/////" "\\\\\"]]
	b]4*	; Repeat the whole thing 4 times	STACK = [[["/////" "\\\\\" ... "/////" "\\\\\"]]]
	d	; Duplicate				STACK = [[["/////" "\\\\\" ... "/////" "\\\\\"]] [["/////" "\\\\\" ... "/////" "\\\\\"]]]
	€bR	; Reverse the second copy		STACK = [[["/////" "\\\\\" ... "/////" "\\\\\"]] [["\\\\\" "/////" ... "\\\\\" "/////"]]]
	+	; Concatenate				STACK = [[["/////" "\\\\\" ...] ... [... "\\\\\" "/////"]]]
	3*	; Repeat 3 times			STACK = [[["/////" "\\\\\" ...] ... [... "\\\\\" "/////"]]]
	bUBJn	; Concatenate and grid			STACK = ["/////\\\\\...\\\\\/////"]
\$\endgroup\$
0
\$\begingroup\$

Regenerate, 44 bytes

((((/{5})(\\{5})){6}
){4}(($5$4){6}
){4}){3}

Attempt This Online!

Pretty straightforward use of groups and repetition. Group 4 is the five forward slashes and group 5 is the five backslashes; backreferencing them in the second set of lines saves one byte.

\$\endgroup\$
0
\$\begingroup\$

05AB1E, 13 bytes

'/5׺6×4и»∊л

Try it online.

Also works in the older legacy version of 05AB1E by replacing the º with :
Try it online.

Explanation:

'/            '# Push "/"
  5×           # Repeat it 5 times as string: "/////"
    º          # Mirror it horizontally: "/////\\\\\"
     6×        # Repeat that 6 times as string
       4и      # Repeat that 4 times as list
         »     # Join this list with newline delimiter
          ∊    # Mirror it vertically
           Ð   # Triplicate this string
            »  # Join the three strings on the stack with newline delimiter
               # (after which it is output implicitly as result)
\$\endgroup\$
0
\$\begingroup\$

Java 11, 148 122 bytes

v->{String a="/////",b="\\\\\\\\\\",t=((a+b).repeat(5)+"\n").repeat(4),r=t+((b+a).repeat(5)+"\n").repeat(4);return r+r+r;}

Try it online.

Explanation:

v->{                       // Method with empty unused parameter & String return-type
  String a="/////",        //  Temp-String `a`, containing "/////"
         b="\\\\\\\\\\",   //  Temp-String `b`, containing "\\\\\"
         t=                //  Temp-String `t`, containing:
           ((a+b)          //   `a+b`
             .repeat(5)    //   Repeated 5 times
              +"\n")       //   With a newline
               .repeat(4), //   Repeated 4 times
         r=                //  Temp-String `r`, containing:
           t+              //   `t`, appended with:
             ((b+a).repeat(5)+"\n").repeat(4);
                           //    Same as above, for `b+a` instead of `a+b`
         return r+r+r;}    //  Return three `r`-Strings appended together
\$\endgroup\$
1
  • \$\begingroup\$ @ceilingcat Although smart, I'm afraid it's not allowed to use v, even static/recursive. The Void v + v-> is only a shorter alternative for ()->. Relevant meta post. PS: If it was allowed, that inner method could return directly, making it 110 bytes. \$\endgroup\$ Commented Apr 19 at 16:24
1 2
3

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Not the answer you're looking for? Browse other questions tagged or ask your own question.