The goal is to output Buffalo buffalo Buffalo buffalo buffalo buffalo Buffalo buffalo.
Context. (Maybe another interesting challenge could be printing all of the other examples? This would probably use similar logic but involve either a function or just a for loop.)
This is code-golf, so fewest bytes win!
It takes 304 buffalo to produce 8 buffalo?! Yep, you herd that right.
BuffaloBuffaloBuffaloBuffaloBuffaloBuffalo(buffaloBuffaloBuffaloBuffaloBuffaloBuffaloBuffaloBuffalo(buffaloBuffaloBuffaloBuffaloBuffaloBuffaloBuffaloBuffaloBuffaloBuffalo(buffaloBuffaloBuffaloBuffaloBuffaloBuffalobuffaloBuffaloBuffaloBuffaloBuffaloBuffaloBuffaloBuffalobuffaloBuffaloBuffaloBuffaloBuffaloBuffaloBuffaloBuffalobuffaloBuffaloBuffaloBuffaloBuffaloBuffaloBuffaloBuffalobuffaloBuffaloBuffaloBuffaloBuffaloBuffaloBuffaloBuffalobuffaloBuffaloBuffaloBuffaloBuffaloBuffaloBuffaloBuffalobuffaloBuffaloBuffaloBuffaloBuffalobuffaloBuffalobuffaloBuffalobuffaloBuffalobuffaloBuffalobuffaloBuffalobuffaloBuffalobuffalobuffalobuffalo)buffaloBuffalobuffalobuffalobuffaloBuffaloBuffaloBuffalobuffaloBuffalobuffalobuffalobuffaloBuffalobuffalobuffaloBuffalobuffaloBuffalobuffaloBuffalobuffaloBuffalobuffaloBuffalobuffalobuffalobuffalo)Buffalobuffalobuffalobuffalo)buffaloBuffalobuffaloBuffalobuffaloBuffaloBuffaloBuffaloBuffaloBuffaloBuffaloBuffalo.buffaloBuffalo.buffaloBuffaloBuffaloBuffaloBuffaloBuffaloBuffaloBuffalo..buffaloBuffalobuffalobuffalobuffalobuffalo.buffaloBuffalo.buffaloBuffaloBuffaloBuffaloBuffaloBuffaloBuffaloBuffalo.buffaloBuffalobuffalobuffalobuffalobuffalobuffalobuffalobuffalobuffalo.BuffalobuffaloBuffalobuffaloBuffalobuffaloBuffaloBuffalo.BuffalobuffaloBuffalobuffalo.buffaloBuffalo..buffaloBuffalobuffalobuffalo.buffaloBuffalo.buffaloBuffalo.buffaloBuffalo.BuffalobuffaloBuffalobuffaloBuffalobuffaloBuffalobuffaloBuffalobuffaloBuffalobuffalo.buffaloBuffalo.buffaloBuffalo..buffaloBuffalo.buffaloBuffalo.buffaloBuffalo.buffaloBuffalo.buffaloBuffaloBuffaloBuffaloBuffaloBuffaloBuffaloBuffalo(BuffalobuffaloBuffalobuffaloBuffalobuffaloBuffalobuffaloBuffaloBuffalo.BuffalobuffaloBuffalobuffalo.buffaloBuffalo..buffaloBuffalobuffalobuffalo.buffaloBuffalo.buffaloBuffalo.buffaloBuffalo.buffaloBuffalobuffalobuffalo)BuffalobuffaloBuffalobuffaloBuffalobuffaloBuffalobuffaloBuffalobuffaloBuffalobuffaloBuffalobuffalo.buffaloBuffalo.buffaloBuffalo..buffaloBuffalo.buffaloBuffalo.buffaloBuffalo.buffaloBuffalo.BuffalobuffaloBuffalobuffaloBuffalobuffaloBuffaloBuffalo.BuffalobuffaloBuffalobuffalo.buffaloBuffalo..buffaloBuffalobuffalobuffalo.buffaloBuffalo.buffaloBuffalo.
Try it online! Link is to a Buffalo interpreter written in PHP (the header is copied from GitHub). You can also copy-and-paste the code above into the official online interpreter.
Buffalo is a cell-based language like brainfuck or COW. It has seven instructions:
Buffalobuffalo and buffaloBuffalo move the pointer to the left and right, respectively,BuffaloBuffalo and buffalobuffalo increment and decrement the current cell value, respectively,( and ) begin and end loops, and. outputs the ASCII character corresponding to the current cell value.Aiming to get the ASCII codes of Bufalo into successive cells, we first do a coarse initialisation using three nested loops. A correction is then applied to each cell (outside the loops) as necessary. The selected iteration counts (3 for the outer and middle loops and 4 for the inner loop) are apparently optimal. The ASCII code for the lowercase b does not get its own cell; rather, we generate it on the fly in the a cell.
Once the ASCII codes have been generated, the output is printed character-by-character as Buffalo buffalo Buffalo (buffalo )Buffalo buffalo, where the segment in parentheses represents a loop that runs 3 times.
echo {B,b,B,b,b,b,B,b}uffalo
Brace expansion (Bash Reference Manual)
Same length, slightly more interesting:
echo {B,b,B,b{,,},B,b}uffalo
echo foo is the same as 'echo' 'foo' is the same as "echo" "foo" is the same as x=echo y=foo; $x $y. Quoting just changes whether splitting or globbing happens.
\$\endgroup\$
Commented
Feb 1, 2021 at 13:47
for c in'BbBbbbBb':print c+'uffalo',
Relies on the Python 2 print magic that automagically adds a space before a printed object if it thinks it's not at the beginning of a line.
print'uffalo '.join('BbBbbb'*2)[:63]
A trivial modification of the anagol solution is the same length.
print(*[x+'uffalo'for x in'BbBbbbBb'])
print(*map("{}uffalo".format,'BbBbbbBb'))
x and c for variable names instead of b 😛
\$\endgroup\$
wM?Im_ḋ162¨Ḃ=F
This was a simple challenge but fun :)
wM?Im_ḋ162¨Ḃ=F
¨Ḃ=F Taking the compressed string "Buffalo" (uppercase B)
M For each digit in
ḋ162 the binary digits of 162 ([1,0,1,0,0,0,1,0]):
? if the digit is 1
I return the string itself
if the digit is 0
m_ convert each character to lowercase
w Join all strings with spaces
Inspired by @Leo's answer, so make sure to upvote him! and me too please ;)
Ƶzbε'±ˆsi™]ðý
Ƶzbε'±ˆsi™]ðý # full program
ý # join...
'±ˆ # "buffalo"...
ε # for map over all digits of...
Ƶz # 162...
b # in binary...
™ # in title case...
i # if...
s # current digit in...
ε # map over all digits of...
Ƶz # 162...
b # in binary...
i # is 1...
ð # by spaces
] # exit if statement and map
# implicit output
"Buffalo buffalo Buffalo buffalo buffalo buffalo Buffalo buffalo
"... # full program
"... # literal
# implicit output
EDIT: I have stood unbeaten for three months... Brownie points to anyone who outgolfs me.* Oh, and possibly some rep if I like your answer. ;)
*Just to clarify, outgolfs in any language will be accepted. It doesn't have to be 05AB1E.
'±ˆ
\$\endgroup\$
Commented
Feb 2, 2021 at 13:06
@_=<{,b,B,b}uffalo>;say"B@_ b@_"
Beats the best anagol answer by one byte:
@_=($_=Buffalo,lc)x2,print"@_ \l@_." # Mithran
@_=<{,b,B,b}uffalo>;print"B@_ b@_." # Sisyphus
8ibuffalo <esc>xbb~5b~0~
8ibuffalo <esc>, write "buffalo " 8 times. cursor at end of line.x remove current character (the space at end of line).bb move to the 2nd words beginning from cursor (move left).~ toggle letter case, and also move cursor 1 char right.5b~ move to the 5th words beginning from cursor (move left). And toggle case.0~ move to line beginning. And toggle case.
BbBbbbBb
.
$&uffalo
$
Try it online! Explanation:
BbBbbbBb
Insert the bs in the correct capitalisation.
.
$&uffalo
Expand the buffalo (buffaloes?).
$
Remove the trailing space.
Edit: -1 byte thanks to Dingus
cat(c('buffalo','Buffalo')[1+!21%%1:8])
Chooses whether to output 'buffalo' or 'Buffalo' by indexing with the vector 2 1 2 1 1 1 2 1, which is constructed as the zero values of 21 modulo each of 1...8, plus one.
Sadly, trying to recycle the 'uffalo' is significantly longer (54 bytes) due to R's somewhat cumbersome string-manipulation functions (Edit after reading the 'Anarchy Golf' link: still longer, but can be done in 46 bytes)
"uffalo
Ans+" b"+Ans
Ans+" B"+Ans
"B"+Ans+" b"+Ans
Builds the sentence up in chunks to eliminate the need for string variables which are two byte tokens; Ans is always a single byte even when it holds a string. The strategy also minimizes use of the lowercase letters as they are two byte tokens. The final line is automatically output and you can scroll left-right for the full sentence.
@set s=B_b_B_b_b_b_B_buffalo
@echo %s:_=uffalo %
Batch's string handling is so poor it's golfier to explicitly include the last "buffalo" rather than trying to trim the trailing space at the end.
Graphical languages are harder to count, so here's my attempt:
And yes, how'd you know about my EE degree?
"uffalo" as 6 bytes. Of course the underlying implementation uses more bytes, but for the purposes of counting bytes in code golf, graphical languages are counted differently. If we're talking purely memory usage, it's more like 240k bytes, but that's not how any other languages are counted.
\$\endgroup\$
Commented
Feb 2, 2021 at 19:09
Builds the string recursively and in reverse order.
f=n=>(n>6?'':f(-~n)+' ')+"bB"[n&n!=3]+'uffalo'
f=n=>(n>6?'':f(-~n)+' ')+"bB"[25/n&1]+'uffalo'
f = n => // f is a recursive function taking a counter n,
// which is initially undefined (zero'ish)
( n > 6 ? // if n is greater than 6 (last iteration):
'' // append nothing
: // else:
f(-~n) // append the result of a recursive call with n + 1
+ ' ' // followed by a space
) //
+ "bB"[n & n != 3] // append "B" if n is odd and not equal to 3,
// or "b" otherwise
+ 'uffalo' // append "uffalo"
' Buffalo buffalo'.repeat(4).slice(1) saves a few bytes
\$\endgroup\$
Commented
Feb 1, 2021 at 10:21
Buffalo buffalo repeated 4 times. The 5th word is in lower case.
\$\endgroup\$
-1 byte thanks to @CodyGray.
-1 byte thanks to @640KB.
0BED:0100 BA 19 01 BE 22 01 B4 09-B1 07 CD 21 AC A2 19 01 ...."......!....
0BED:0110 E2 F8 C6 44 F7 24 CD 21-C3 42 75 66 66 61 6C 6F ...D.$.!.Buffalo
0BED:0120 20 24 62 42 62 62 62 42-62 $bBbbbBb
Instruction listing (nasm syntax):
org 100h ; | Execution of .COM files start at CS:0100
mov dx, msg ; BA 1B 01 | DX = offset of "Buffalo $" (for INT 21H)
mov si, buf ; BE 24 01 | SI = Address of "bBbbbBb" (for LODSB)
mov ah, 09h ; B4 09 | AH = Opcode code INT 21H (Output string up to '$')
mov cl, 7 ; B1 07 | CX = 7 (we want to iterate 7 times before the last 'Buffalo')
loop:
int 21h ; CD 21 | Output string at msg
lodsb ; AC | AX = [SI], ++SI
mov byte [msg], al
; A2 1B 01 | Set the first character of msg as the current character at buf
loop loop ; E2 F8 | Jump to tag 'loop' while CX >= 0
mov byte [si - 9], "$"
; C6 44 F7 24 | (After loop) Replace the last space with a '$'
int 21h ; CD 21 | Print the last 'buffalo'
ret ; C3 | Exit to DOS
msg: db "Buffalo $"
buf: db "bBbbbBb"
C:\test>debug code.com
-g
Buffalo buffalo Buffalo buffalo buffalo buffalo Buffalo buffalo
Program terminated normally
int 20h down to a 1-byte ret. (The return will return to address 0000h, which already contains an int 20h. See also: Why does MS-DOS put an int 20h at byte 0 of the COM file program segment?)
\$\endgroup\$
Commented
Feb 2, 2021 at 0:49
mov byte [msg + 7], "$" (C6 06 22 01 24) with mov byte [si - 9], "$" (C6 44 F7 24).
\$\endgroup\$
Realised the 61 byte version was not compliant (outputted a space at the end). Reverted and updated it to be.
-1 byte thanks to Arnauld
f(n){for(n=8;n--;)printf("%cuffalo%s","bBbbbBbB"[n]," "+!n);}
0 (that is the right character to use) in place of 10, so to regain the byte lost, I checked for a substitute of 32 and found that 9 works.
\$\endgroup\$
Commented
Jan 31, 2021 at 3:05
0 bytes", so you're not allowed to print garbage bytes like ASCII 0 at the end. That would be noticeable piping into hexdump -C, or redirecting to a file. Tabs instead of spaces is maybe justifiable, especially since standard tab-stops are 8 spaces, and "buffalo" is 7 letters long.
\$\endgroup\$
Commented
Feb 1, 2021 at 6:38
init$"BbBbbbBb">>=(:"uffalo ")
Ｆ⍘¹⁶²bB«ιuffalo→
Try it online! Link is to verbose version of code. Explanation:
Ｆ⍘¹⁶²bB«
Convert 162 to base 2, but use b for 0 and B for 1, and loop over the "digits".
ι
Print the b or B.
uffalo
Print the rest of the buffalo.
→
Prepare to leave a space before the next b, if any.
lambda: CODE. For something that requires input, it would make sense, but this challenge is to just output the Buffalo string, and an evaluation of [...'BbBbbbBb'].map(x=>x+'uffalo').join` ` works fine
\$\endgroup\$
Commented
Feb 1, 2021 at 6:54
_=>, an alert(...) may be required to print it out.
\$\endgroup\$
f= be counted too?
\$\endgroup\$
Commented
Feb 1, 2021 at 10:26
-2 bytes thanks to @Arnauld
n=7;f(){printf("%cuffalo%c","bBbbbBbB"[n],9+!n),n--?f():(n=7);}
Could have been shorter if it wasn't for the reusability rule killing recursive functions.
n=7 by calling this as f(7). It has to be called as f(7) or it doesn't work.
\$\endgroup\$
f(char*s){printf(s);} and pass in the output string? T_T
\$\endgroup\$
7 based on the internal implementation details is not ok. Generalizing the task to print some pattern of buffalos and requiring the caller to pass a 7 is solving a different question (and very hard to justify when only numbers <=7 work because you hard-coded a lookup table of that length.) TL:DR: I would have downvoted the first version of this answer regardless of tags, but this is good. I'm not sure tabs are allowed instead of spaces, but I like that 9+!n enough to upvote anyway :P
\$\endgroup\$
Commented
Feb 1, 2021 at 6:33
9+!n is @Arnauld's contribution
\$\endgroup\$
Commented
Feb 1, 2021 at 12:18
join(collect("BbBbbbBb").*"uffalo ")[1:63]
Very similar to what was done with Python above.
print('uffalo '.join('BbBbbbBb ')[:-2])
print('uffalo '.join('BbBbbbBb\b'))
> "Buffalo buffalo Buffalo buffalo buffalo buffalo Buffalo buffalo"
>> Output 1
Well, this is embarrassing...
The first line alone could even be enough, as a function returning the string
For something a bit more interesting, here's my previous solution:
> "Buffalo "
> "buffalo "
>> 1+2
>> 3+3
>> 2+2
>> 5+3
>> 4+6
> 63
>> 7ᶠ8
>> Output 9
First approach to the language of the month for me :) It looks like building the string by manually concatenating pieces is the best approach in Whispers.
Whispers starts the execution from the last line of the program, and then follows references from there. Any number in a line starting with >> refers to the result of the corresponding line, while numbers in lines starting with > have their normal value. We can only have a single operation per line (hence why so many lines).
Most lines here simply concatenate two strings, while line 9 takes the first 63 characters from the string in line 7, which is all except for the trailing space. It should be pretty easy to read, but here's the value computed by each line:
> "Buffalo " 1:"Buffalo "
> "buffalo " 2:"buffalo "
>> 1+2 3:"Buffalo buffalo "
>> 3+3 4:"Buffalo buffalo Buffalo buffalo "
>> 2+2 5:"buffalo buffalo "
>> 5+3 6:"buffalo buffalo Buffalo buffalo "
>> 4+6 7:"Buffalo buffalo Buffalo buffalo buffalo buffalo Buffalo buffalo "
> 63 8:63
>> 7ᶠ8 9:"Buffalo buffalo Buffalo buffalo buffalo buffalo Buffalo buffalo"
>> Output 9 10:prints out line 9
\def~{uffalo }B~b~B~b~b~b~B~b~\bye
awk, 22- or 41-bytes. basic approach is 41-bytes:echo Buffalo |
mawk 'NF+=sub(" ",OFS=" "tolower($2=$4=$1)" ")'
Buffalo buffalo Buffalo buffalo buffalo buffalo Buffalo buffalo
but if we're going with the entirely hard-coded approach, that can massively cut it down to just 22-bytes (and that's already inclusive of the single quotes for OFS) :
echo BbBbbbBb |
mawk NF++ FS= OFS='uffalo '
Buffalo buffalo Buffalo buffalo buffalo buffalo Buffalo buffalo
Trivia tidbit - if we view "B"'s as "1"'s and "b"'s as "0"'s,
then the requirement would appear 10100010, while its decimal form can be reached via either
2 * ( 3 ^ 4 ) or 3 * 6 * 9
echo in the byte count like this...
\$\endgroup\$
Commented
Nov 1, 2022 at 15:27
awk entries are instantly pre-penalized with having to either (1) invoke a BEGIN { } block, (2) use echo/printf, or (3) do <<< at the shell level, and that's before any of the code logic even began, with all options being rather costly, golfing-wise. if you're willing to use the byte-count only for the logic inside the BEGIN { } block itself instead of end-to-end, then i can write it with birdies and eagles
\$\endgroup\$
Commented
Nov 1, 2022 at 20:33
BEGIN or echo or other costly code, but that's how it's scored. Everyone should play by the same rules. Other languages have seemingly-wasteful boilerplate too. In the case of your mawk NF++ FS= OFS='uffalo ' code as it is now (which is 27 bytes, not 22), you're not even counting the 'BbBbbbBb' string, which is a fundamental part of the code logic.
\$\endgroup\$
Commented
Nov 2, 2022 at 10:21
echo for 40 bytes. Your approach is really nice, and shorter than the pure-awk one
\$\endgroup\$
Commented
Nov 3, 2022 at 14:29
'BbBbbbBb',¨⊂'uffalo'
Try it online! Thanks to Dyalog Classic
This could be shortened to 5 bytes if the two strings were given as input rather than being hard coded.
> 81
> 2
>> 1⊥2
> "Buffalo "
> "buffalo "
> "buffalo"
>> If L 4 5
>> Each 7 3
>> 8+6
>> Output 9
