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!
>++++++++[>++++++++<-]<++++++++[>++++<-]>>++.--------[>++>++<<-]>+.>--------------..[>+>+>+<<<-]>-----.>++++++.+++.<<<<<.>>>>+.<<.>>>>..<<-.>---.+++.<<<<<.>++++++++[>>++++++++<<-]>>++.<.>>>>..<<.>---.+++.<<<<<.>>>>+.<<.>>>>..<<-.>---.+++.<<<<<.>>>>+.<<.>>>>..<<-.>---.+++.<<<<<.>>>>+.<<.>>>>..<<-.>---.+++.<<<<<.>>>.<.>>>>..<<.>---.+++.<<<<<.>>>>+.<<.>>>>..<<-.>---.+++.
Not exactly the most optimized answer and could probably be golfed much further. Makes lots of use of copying cells, as well as repeadedly performing the same print function near the end.
Original un-minified version (sadly uncommented) can be found here.
PRINT REPLACE('B0 B0 b0 B0',0,'uffalo buffalo')
PRINT is shorter than SELECT. Using a numeral in the REPLACE eliminates a set of quotes and saves 2 bytes.
EDIT: Fixed trailing space, at the cost of 6 bytes. Saved 4 by replacing a longer phrase, thanks @Giuseppe
-2 bytes thanks to ngn!
" "/"BbBbbbBb",\:"uffalo"
echo}:,/'BbBbbbBb',"{'uffalo '
" "/)
\$\endgroup\$
join - thank you! I'll update the solution when TIO allows me (can't open it right now)
\$\endgroup\$
Commented
Feb 2, 2021 at 12:56
trim instead substring :)
\$\endgroup\$
u$="uffalo buffalo
?"B"u$" B"u$" b"u$" B"u$
Abuses a couple tricks with the autoformatter (besides the standard ? for PRINT shortcut): the missing double quote is added at the end of line 1, and semicolons are inferred in the print statement whenever a literal string is next to a variable. After expansion, the code becomes
b$ = "uffalo buffalo"
PRINT "B"; b$; " B"; b$; " b"; b$; " B"; b$
The semicolon trick, plus the fact that string variables need the $ sigil, meant that approaches using more variables to build the string ended up longer.
v->"B b B b b b B b".replaceAll("\\w","$0uffalo")
00000000: b820 09b1 e7ba 1801 cd21 d0e9 7409 7303 . .......!..t.s.
00000010: 3044 19cd 29eb f1c3 4275 6666 616c 6f24 0D..)...Buffalo$
Listing:
B8 0920 MOV AX, 0920H ; AH = 9 DOS string function, AL = ' '
B1 E7 MOV CL, 11100111b ; magic buffalo number 11100111
BA 0118 MOV DX, OFFSET BUF ; 'Buffalo' pointer for display
STAMPEDE:
CD 21 INT 21H ; write our *uffalo to screen
D0 E9 SHR CL, 1 ; LSB of magic buffalo number into CF
74 09 JZ BYE_BUFFALO ; loop until CL is 0
73 03 JNC HI_BUFFALO ; if LSB bit is a 0, don't change case
30 44 19 XOR [SI+BUF-100H], AL ; swap case on first letter
HI_BUFFALO:
CD 29 INT 29H ; if not last of the buffalo, display a space
EB F1 JMP STAMPEDE ; keep 'em coming
BYE_BUFFALO:
C3 RET ; return to DOS
BUF:
DB 'Buffalo$' ; the real Buffalo
Explanation:
Uses the byte 0xe7 (1110 0111 binary) to determine if the case should be swapped. Each [Bb]uffalo corresponds to the next least significant bit of the byte where a 1 means to change the case and a 0 means don't change.
The case of the first character can be alternated by doing an xor 0x20 on the ASCII value. Now 0x20 just happens to be the ASCII value for a space character, so we can put that in al and use for both the xor and to write the space character.
Props:
80 84 1A 00 / XOR [SI+001A], AL when doing the pre-processor math. In that case, it's a 1 byte win! Thanks!
\$\endgroup\$
I tried to refrain from doing anything too illegal like setting the costume as Buffalo buffalo Buffalo buffalo buffalo buffalo Buffalo buffalo or setting a variable as that.
Here is the scratchblocks code (102 bytes):
when gf clicked
for each[i v]in(8){set[B v]to(join(B)(join(letter(i)of[BbBbbbBb])[uffalo ])
}::control
Usually when people submit scratch, they submit Tosh (https://tosh.blob.codes/), which is Scratch but text-based or an image of the blocks compiled on scratchblocks (https://scratchblocks.github.io). I would’ve done both, but the for each [i v] in (8) block is old and removed and I can’t figure out how to do it on Tosh.
+++[>+++[>++++[>++>+++>+++>+++>+++>+++>+++>+++>+[<]>>>-]>->->+>->->-[<]<-]<-]>>>+++.>->.>+++.>+++.>--.>.>+++.>----.[<]>>[.>]<[<]>.>>[.>]<[<]+++[>>[.>]<[<]>-]>.>>[.>]<[-]<[<]>>[.>]
The ASCII codes are initialised using a similar method to my Buffalo answer, though here both b and the second f get their own cells. Printing the output requires fewer instructions in brainfuck compared with Buffalo because of a key difference in the way that loops are handled: brainfuck uses the currently active cell to decide whether a loop ends, whereas Buffalo refers back to the cell that was originally active when the loop was entered. Consequently, we can print runs of letters in successive cells with a simple [.>] loop in brainfuck, a construction that isn't possible in Buffalo.
“ƤhƤDȷ»Ḳ162ṃK
162ṃ Convert 162 to binary, and 1-index each digit into
“ƤhƤDȷ» "Buffalo buffalo"
Ḳ split on spaces.
K Join on spaces.
I was in fact doing something terribly wrong 3 (almost 4) years ago, but this still comes out two bytes shorter than title-casing dynamically:
162B“¦ȯø»Œtṛ¡ⱮK
162B Convert 162 to binary,
Ɱ and for every digit
Œt title-case
“¦ȯø» "buffalo"
ṛ¡ that many times.
K Join on spaces.
#include<random>
#include<cstdio>
int main(){std::knuth_b g(7);for(char i{},s[]=" buffalo";i-8;++i)s[1]^=*s&g(),printf(s+!i);}
Not a serious contender for shortest program — but I was inspired by the (original, now-deleted) requirement not to use a random number generator. ;)
o=['buffalo']
for x in ['B' if int(i) else 'b' for i in bin(69)[:1:-1]]:
o.insert(0,x+o[-1][1:])
print(' '.join(o))
69 is the reverse of the binary representation of the capitalization pattern.
'B' if int(i) else 'b' -> 'bB'[int(i)], and you can remove a space before for. Also, you could .append instead of .insert and use o[::-1] later, and you can then write o+=[item] in place of o.append(item).
\$\endgroup\$
Obligatory bubblegum answer generated with zopfli --deflate --i1000 -c buffalo.txt | xxd
00000000: 732a 4d4b 4bcc c957 4882 d2e8 fc24 fcf2 s*MKK..WH....$..
00000010: 00 .
Rattle just hit release today - this is my first golf with the released version! If you're interested in learning a fun and easy new language, I would highly recommend checking it out!
B&b&uffalo& |I=[b0[2b^b1]b2b3b1b2[3q]b3+]4
Try to out-golf me! You'll probably want to consult the documentation
B&b&uffalo& creates an array of hard-coded strings: ["B","b","uffalo"," "]
| syntax for taking input
I stores this data in first memory slots
= sets top of stack to 0
[ ... ]4 loops 4 times
b0 adds item in slot 0 to buffer
[2 ... ] executes statements inside if top of stack is equal to 2
b^ deletes last item from buffer
b1 adds item in slot 1 to buffer
b2b3b1b2 adds item in slot 2, 3, 1, 2 to buffer
[3 ... ] executes statement inside if top of stack is equal to 3
q ends program - buffer is implicitly printed
b3 adds item in slot 3 to buffer
+ adds 1 to top of stack
B((uffalo) b$2 B$2 b$2) b$1
Pretty simple: golf repeated substrings using capture groups.
9G*âx{ûbB§╕«Γ╢ô };
âx{ûbB§╕«Γ╢ô could alternatively be à{ENR**╦\i╛δ for the same byte-count: try it online.
Explanation:
9G* # Push 9*18=162
â # Convert it to a binary list
# (which is unfortunately in reversed order due to a bug)
x # Reverse it to the correct order
{ # Loop over each of these bits as integers:
ûbB # Push string "bB"
§ # (0-based) index the current bit into it
╕«Γ # Push compressed string "uffa"
╢ô # Push compressed string "lo"
# Push a space character " "
}; # After the loop: discard the final space
# (after which the entire stack is joined and output implicitly)
à # Convert it to a binary string (in correct order..)
{ # Loop over each of these bits as characters:
ENR** # Push 15*25*29=10875
╦ # Get the dictionary word at this index: "buffalo"
\ # Swap so the current bit is at the top of the stack
i # Convert it from a character to an integer
╛ # If it's truthy:
δ # Titlecase the string
-2 bytes thanks to user41805
s/^/BbBbbbBb/
s/./ &uffalo/g
s///
34B solution:
-1 byte thanks to user41805
s/^/B b B b b b B b/
s/\>/uffalo/g
35B solution: (The regex matches empty string at first and then is reused for the second s command)
s/b*/B b B b b b B b/i
s//&uffalo/g
$ in s/.$// is annoying, something you can do to remove its need? For the second approach, try finding an alternative to \w so you can rid the & in the substitution
\$\endgroup\$
Commented
Jan 12, 2023 at 15:08
pp![BufflotongueTwister
-2 thanks to emanresu A
-4 thanks to lyxal
Joeasus is a joke programming language "interpreted" by the Llama 3 LLM, prompted with a minimal description of itself under the name "Peq". It's often very bad at this, forgetting that it's supposed to be a programming language at all or refusing to bullshit functionality for various operators, not to mention it's virtually unusable outside Kolmogorov complexity challenges, but the bright side is that it can also hallucinate its way out of typos.
A previous solution I nearly posted was C.BufflobTongueTwisterNoPeriod for 30 bytes. Getting it to "programmatically" strip the trailing period is much harder than making it imagine the constant hardcoded that way, or at least without also surrounding the output with extraneous quotes, and one of the few "ground truths" about the language is the presence of a "library of helpful constants" named CT--which in this case I can apparently just abbreviate to C.
##<>#&//"B"~Print~#["uffalo"~#~b~#~" B",b=" b"]&
Port of TiKevin83's TI-BASIC solution.
(clojure.string/join " " (map #(str % "uffalo") "BbBbbbBb"))
using System.Linq;using System;class A{static void Main(){Console.Write($"{String.Join("uffalo ", "BbBbbbBb".ToArray())}uffalo");}}
"BbBbbbBb "/""|join("uffalo ")[:-2]
Sample run:
bash-5.0$ jq -nr '"BbBbbbBb "/""|join("uffalo ")[:-2]'
Buffalo buffalo Buffalo buffalo buffalo buffalo Buffalo buffalo
