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!
Save a byte thanks to @Scott!
V"BbBbbbBb"p+N"uffalo
I wanted to be smart and encode the state of the upper- and lowercase letters as bits, but that ended up taking a byte more. Here's the code and explanation anyway!
FNj162 2p+?N\B\b"uffalo
FN # loop with N
j162 2 # convert 162 into binary as list of bits
p # print without newlines
+ # concatinate strings
?N\B\b # ternary operator, checks if the bit is falsey (0)
"ufallo # note the trailing space
join("BbBbbbBb ","uffalo ")[1:63]
print(join("BbBbbbBb ","uffalo ")[1:63])
--[++>+[<]>+]<++++[>++++++++<-]>>>---->-[<++>>++>++<<-----]->>>----[<<<+++++>>>--]----->++++++>+++++++++>-[<<<++>++>++>-----]<[<]>>.>>[.>]<[<]>.>>[.>]<[<]>.>.>>[.>]<[<]>.>>[.>]<[<]>.>>[.>]<[<]>.>>[.>]<[<]>.>.>>[.>]<[<]>.>>[.>]
The cells are set to <space>Bbuffalo
<[<]> Goto the space cell
. (dot = print a space)
>. (dot = print B)
>. (dot = print b)
>[.>] print uffalo
Buffalo is printed using <[<]>.>.> >[.>] but is this if it is the first time, we use <[<]> >.> >[.>]
buffalo is printed using <[<]>.> >.>[.>] but we can golf this to <[<]>.> > [.>]
The only thing that I can think of that could probably be better golfed is the preparation part.
If you put the B before the space you might be able to save some bytes.
Machine code (little endian pairs):
a005 22ba 0852 bf2c 2162 2142 de11 de00
d001 de3b d1f6 4770 6675 6166 6f6c 00
Commented assembly:
// Include ThumbGolf wrapper macros
.include "thumbgolf.inc"
.globl main
.thumb_func
main:
// r0 = "uffalo"
adr r0, .Luffalo
// Bitmask representing the case of the B.
// 0 = B, 1 = b, little endian bit order.
// Also allows us to determine the length.
// This fits perfectly into a narrow movs.
// bBbbbBbB
movs r2, #0b10111010
.Lloop:
// Read a bit from the bitmask into the carry flag by shifting right.
// Also detects when we have read all of the bits: lsrs will set the
// zero flag.
lsrs r2, r2, #1
// r1 = (r2 & 1) ? 'b' : 'B'
ite cs
movcs r1, #'b'
movcc r1, #'B'
// print either 'b' or 'B'
putc r1 // udf #0021
// print "uffalo" (w/o newline)
puts r0 // udf #0000
// Yes, none of the output instructions affect the flags despite using
// stdio AND executing the stdio call on the main thread (since stdio in
// signal handlers is unsafe), and this is proof.
//
// If the bitmask is zero, exit.
it eq
bxeq lr
// Use the "put special" instruction to print a space.
putspc ' ' // udf #0073
// More flexing that the flags are preserved, it is just as good to do
// `b .Lloop`.
// The proof is that this won't crash, since the ASCII as code will store
// random garbage to uninitialized registers.
bne .Lloop
// string literal
.Luffalo:
.asciz "uffalo"
Mostly a demo to show how ThumbGolf preserves the condition flags on output instructions.
I could do the same thing with cbz and an unconditional b, but this is a nice party trick.
As I explained in the code, I use a bitmask to control whether Buffalo or buffalo is printed. It just happens to be a perfect 8-bit constant for movs.
console.log('BbBbbbBb'.replace(/./g, '$&uffalo ').trim())
If a trailing space is allowed, it can be 50 bytes:
console.log('BbBbbbBb'.replace(/./g, '$&uffalo '))
fun main(){"BbBbbbB".map{print(it+"uffalo ")};print("buffalo")}
I used the fairly common strategy of concatenating the first letter to "uffalo", but I had to print the last one to avoid trailing white space, I'm yet to find a better solution.
BEGIN{B="Buffalo";b="buffalo";print B,b,B,b,b,b,B,b}
I could not come up with a shorter example.
BEGIN{for(u="uffalo ";++a<5;)b=b"B"u"b"u;print b}
\$\endgroup\$
BEGIN{print (C="B"(_="uffalo ")"b"_)C"b"_"b"_ C}
\$\endgroup\$
Commented
Nov 3, 2022 at 22:01
> "BbBbbbBb"
> "uffalo "
> -1
>> L+2
>> Each 4 1
>> 5ᶠ3
>> Output 6
{{i}dddd}iiiiiic{{i}ddddd}ic{d}dddddccdddddc{i}iciiic{{d}ii}ic{{i}dddd}iiiiiic{i}{i}dc{d}dddddccdddddc{i}iciiic{{d}ii}ic{i}{i}{i}iiiic{{i}ddddd}ic{d}dddddccdddddc{i}iciiic{{d}ii}ic{{i}dddd}iiiiiic{i}{i}dc{d}dddddccdddddc{i}iciiic{{d}ii}ic{{i}dddd}iiiiiic{i}{i}dc{d}dddddccdddddc{i}iciiic{{d}ii}ic{{i}dddd}iiiiiic{i}{i}dc{d}dddddccdddddc{i}iciiic{{d}ii}ic{i}{i}{i}iiiic{{i}ddddd}ic{d}dddddccdddddc{i}iciiic{{d}ii}ic{{i}dddd}iiiiiic{i}{i}dc{d}dddddccdddddc{i}iciiic
a='uffalo';b='B'+a+' b'+a;c='b'+a;print(b,b,c,c,b)
You have to run these at Try it online! because running it in a browser console will try to print this webpage
57 bytes:
a='uffalo ';b='B'+a+'b'+a;c='b'+a;print(b+b+c+c+b.trim())
47 bytes but Try it online! doesn't understand String.replaceAll and it outputs a trailing space:
print('B'+('bBbbbBb'.replaceAll('','uffalo ')))
46 bytes but it outputs a trailing space (thanks to @lm42):
print('B'+('bBbbbBb'.replace(/|/g,'uffalo ')))
This is my first golf.
print('B'+('bBbbbBb'.replace(/|/g,'uffalo '))) for last of your
\$\endgroup\$
Similar to Dominic van Essen's recycling solution, but with paste0.
cat(paste0(scan(,''),'uffalo'))
B
b
B
b
b
b
B
b
Same idea, also 48 bytes
cat(paste0(scan(,''),'uffalo buffalo'))
B
B
b
B
This program complies to ISO standard 7185 “Pascal” (level 0 sufficient):
program p(output);const s='uffalo buffalo B';begin write('B',s,s:15,'b',s,s:14)end.
BbBbbbBb), and includes a leading space in the output
\$\endgroup\$
S, ⁺=bƛ‛ḋ¤nßǐ
-1 byte thanks to pacman256
⁺>bƛḃ‛ḋ¤$ßǐ
⁺> # Push 163
b # and convert it to binary
ƛ # for each digit:
ḃ # push whether the digit is "truthy"
‛ḋ¤ # and push the string "buffalo"
$ # swap those two values
ßǐ # and if the digit actually is truth, title case it
S flag after I posted my answer. You also slightly modified the behavior of Ɓ (seems to be virtually identical to me, but who knows). So sorry, no brownie points.
\$\endgroup\$
Ɓ was changed to act like 05ab1e does (i.e. Handle the string "0" as falsey). It acts as a shortening of 0=0=
\$\endgroup\$
S flag.
\$\endgroup\$
(c=n=>n?c(n>>1)+'bB'[n&1]+'uffalo ':'')(162).trim()
Made sure to trim a trailing space. If we don't trim it, we get 44 bytes (but of course that violates the problem description).
n=8;f(){while(n--)printf("%cuffalo%c",98^(n==3^n&1)<<5,9+!n);}
Explanations:
1<<5 (32) from 'b' we obtain 'B': 'b' ^ (1 << 5) = 'B'). This property is true for all letters.n&1 with the exception iteration: 3 n==3^9+!n allows to have spaces (horizontal tab) except when n == 0: !n, then this expression will equal to 10 which is a new line return '\n'.while(n--) loop will automatically stops.Thanks to caird coinheringaahing for catching the superfluous extra newline ;)
n = 8 inside the function f and add int in front of it. It's purposely outside of the function to save 4 bytes (int + space).
\$\endgroup\$
Commented
Mar 17, 2021 at 14:37
avvqmddlblbqaviqvmlblblqqqaviqvmlblblaviqvmlblbtfavvdqvdmfwwwffwfvvifiiifbvvvvdfbbbu
s="'BbBbbbBb'":k=""
For i=1 To Len(s)
k=k&Mid(s,i,1)&"uffalo "
Next
k="Buffalo buffalo Buffalo buffalo buffalo buffalo Buffalo buffalo"
\$\endgroup\$
`bBbbbBbB`[o` olaffu`7[aoA{]x]
`bBbbbBbB` - Push the first letters of each [Bb]uffalo
[ ] - While non-zero:
o - Output the b/B
` olaffu` - Push "uffalo "
7[aoA{]x - Output it and clean up the counter
=TEXTJOIN(" ",,CHAR(98-{4;4;0;4}*{8,0})&"uffalo")
98-{4;4;0;4}*{8,0} => 66 98 CHAR()=> B b
66 98 B b
98 98 b b
66 98 B b
=TEXTJOIN(" ",,MID("BbBbbbBb",ROW(1:8),1)&"uffalo")
↘2/$"_ _uffalo"⍥¯⋯372@B
Take the binary digits of 372, making a B lowercase where there are ones. Reduce by inserting a space between and appending "uffalo", then drop the first two characters.
⋯ uses little-endian binary, so instead of using 162, I'd use 186. However because I combined steps of the joining by spaces and appending "uffalo" into one step, the first character ends up without the "uffalo" and just has to be removed. To fix this, I prepended an extra 0 to the binary representation to get 372, and just drop the first two characters of the result.
8+iBuffalo <esc>b)<a-,>)<a-,>3)<a-,>`gld
basically we write Buffalo with 8 cursors then remove the selections we want to keep capitalized, then lowercase the rest
<a-,> = alt+comma
8+ duplicate cursor 8 timesiBuffalo <esc> write Buffalo with each of the cursorsb move back and select words)<a-,>)<a-,> rotate main selection forwards then remove main selection (repeated twice)3)<a-,> rotate main selection 3 times forwards then remove main selection` lowercase remaining selectionsgld go to end and delete trailing space