Code Golf Stack Exchange is a question and answer site for programming puzzle enthusiasts and code golfers. It only takes a minute to sign up.
Sign up to join this community
Given string s of even length as input, randomly capitalize exactly half of the letters.
[a-z])This is code-golf so fewest bytes in each language wins!
Uses the 05AB1E codepage.
ā.rÈÅÏu
# example input: "abcdefgh"
ā # Indices of the input -> ex. [1, 2, 3, 4, 5, 6, 7, 8]
.r # Randomly shuffle this list -> ex. [5, 4, 6, 3, 2, 8, 1, 7]
È # Map (x % 2 == 0) on each element -> ex. [0, 1, 1, 0, 1, 1, 0, 0]
ÅÏ # Apply the following on truthy indices:
u # Convert to uppercase -> ex. "aBCdEFgh"
Or R>=4.1, 25 bytes by replacing the word function with \.
function(s)s-sample(seq(s))%%2*32
Inputs and outputs through vector of character codes.
Inspired by @Adnan's solution.
i,r;f(*s,z){for(i=z;s[r=rand()%z]>96?s[r]-=32,i-=2:i;);}
lambda s:bytes(map(int.__xor__,s,sample(len(s)//2*[0,32],len(s)))) from random import*
Uses Rɪᴋᴇʀ's idea to toggle case using ^32, but taken a bit further.
-1 byte thanks to @ovs.
ŒuJḂẊTƲ¦Using the mod-2 trick from Adnan's 05AB1E answer.
Explanation:
ŒuJḂẊTƲ¦
Œu TƲ¦ uppercase at truthy indices:
J range [1..length(input()]
Ḃ each modulo 2
Ẋ random permutation
JḂ essentially creates [0, 1, 0, 1, ..., 0, 1] up to the length of the input.
ŒuJẊŒHḢƲ¦Explanation:
ŒuJẊŒHḢƲ¦
Œu Ʋ¦ uppercase at indices:
JẊ random permutation of [1..length(input)]
ŒH split that list into two halves
Ḣ take the first of those two halves
I think there ought to be a shorter way of doing the JẊŒHḢ, perhaps by picking a random combinationnope. Or, at least, a shorter version of ŒHḢ.
−5 bytes thanks to ovs.
Anonymous tacit prefix function
⌈@(2|≢?≢)
⌈ uppercase
@(…) at the positions indicated by the following mask:
≢?≢ shuffle the indices 1 through the tally of elements in the argument (lit. take n random elements from 1…n, without replacement)
2| division remainders when divided by 2
f=s=>(S=Buffer(s).map(c=>c^=Math.random(n++)<.5?32:--n-n--,n=0),n?f(s):S)+''
f = s => // s = input string
( S = // S = output
Buffer(s) // turn s into a buffer
.map(c => // for each ASCII code c in s:
c ^= // update c:
Math.random(n++) // increment n
< .5 ? // with 1/2 probability:
32 // turn c into uppercase
: // or:
--n - n--, // leave c unchanged and decrement n twice
n = 0 // start with n = 0
), // end of map()
n ? f(s) // try again if we haven't capitalized exactly
// half of the letters
: S // otherwise, stop and return S
) //
+ '' // coerce the output buffer back to a string
--n-n-- haha this part is clever, but a nightmare to read, dont forget your priorities!
\$\endgroup\$
toupper@{~`]`[}-:@#?#
-:@#?# Randomly "Deal" ? half-the-length -:@# number of indices from all possible indices.toupper@{~][} And Amend } just those indices with their uppercased versions toupper@{~.-1 thanks to emanresu A, with their v<{} trick
s=>(t=(f=x=>x?f(x.slice(1)).flatMap(y=>[x[0]+y,x[0].toUpperCase()+y]):[""])(s).filter(w=>![...w].reduce((u,v)=>u+(v<{})*2-1,0)))[Math.random()*t.length|0]
Explanation:
(f=x=>x?f(x.slice(1)).flatMap(y=>[x[0]+y,x[0].toUpperCase()+y]):[""])(s): Recursively finds all ways to capitalize the string.filter(w=>![...w].reduce((u,v)=>u+(v<{})*2-1,0)): Filters out items which don't have the correct number of capitalized letters, by checking if the sum of -1 (for capitalized) and 1 (for lowercase) is 0[Math.random()*t.length|0]: Choose a random item
JẊị"żŒu$
-2 bytes thanks to a clever trick from Adnan using cyclical indexing, thus tying pxeger's answer
JẊị"żŒu$ Main Link
J [1, 2, ..., len(input)]
Ẋ random permutation of that
ị" vectorize - index (half of them are even, half are odd, and it wraps)
żŒu$ the input zipped with itself capitalized
Ø. ... Ẋ but had something longer than ṁ; I wonder if I can combine it to get something shorter.
\$\endgroup\$
ị"żŒu$ with Œu ... TƲ¦ you get 9 bytes: ato.pxeger.com/…
\$\endgroup\$
Ø.ṁ can be JḂ as in my second answer (which was taken from @Adnan's 05AB1E answer)
\$\endgroup\$
sequences.repeating, [ "\0 "over length cycle randomize v- ]
! "hamburgers"
"\0 " ! "hamburgers" "\0 "
over ! "hamburgers" "\0 " "hamburgers"
length ! "hamburgers" "\0 " 10
cycle ! "hamburgers" "\0 \0 \0 \0 \0 "
randomize ! "hamburgers" "\0\0\0 \0 \0"
v- ! "hamBURGeRs"
-1 thanks to AZTECCO
-6 with wide string and clang
i;f(*s,l){for(i=l/2;rand()%l--<i?s[l]^=32,--i:i;);}
Outputs by modifying the input string.
Each letter has a \$\frac in\$ chance of being capitalized, where \$i\$ is the number of remaining capital letters and \$n\$ is the number of remaining letters (including this one).
!s=(E=length(s);v=rand(E);prod(i->s[i]-32*(i∈sortperm(v)[1:E÷2]),1:E))
/^((?<-2>[a-z])|(?<-3>[A-Z])|([A-Z])|([a-z]))*(?(2)^)(?(3)^)$/^+/./_?(T`l`L
T`L`l
Try it online! Explanation:
/^((?<-2>[a-z])|(?<-3>[A-Z])|([A-Z])|([a-z]))*(?(2)^)(?(3)^)$/
Check whether the input contains equal numbers of lower and upper case letters. Groups 2 and 3 contain any excess upper and lower case letters respectively; if they are non-empty then the letter of the opposite case decrements the group, otherwise the letter increments the group appropriately. At the end both groups are required to be empty.
^+
Repeat while it does not.
/./_
Loop over each letter.
?(
Random choice between one of the following.
T`l`L
Uppercase.
T`L`l
Lowercase.
MapAt[Capitalize,#,RandomSample[i=0;{++i}&/@#,i/2]]&
-16 bytes thanks to @att
Hey! I'm completely new to this and my answer will make that apparent. I thought I'd post so that I can refer back to later to see my progress. Let me know if I anything is incorrect involving my answer.
didn't include logging, output is the t string
string t="";int p=0;while(p!=s.Length/2){t="";p=0;foreach(char c in s){char l=c;if(new Random().Next(2)==0){l=char.ToUpper(l);p++;}t=$"{t}{l}";}}
s as an argument and returns t, which would be permitted by the default policy. This is a great first answer though, and I look forward to seeing your progress too :)
\$\endgroup\$
s and t here) isn't an acceptable method of I/O. I suggest either turning this into a function or a full program
\$\endgroup\$
Dec 2, 2021 at 17:07
Not super happy with this, I'll probably come back to it after class (or not, we'll see). Takes input from stdin using Python 2 input() rules - aka "test" rather than test.
Requires Python 2 for range returning a list, since that would require *x, instead of x otherwise, and would lose a byte on the print statement and I don't think you can gain more than 2 from inline variable assignments.
Using chr/ord is shorter than [s[i],s[i].upper()][i in x[::2]], I think that's optimal as well.
Thanks to enzo for -8, from switching from using a while loop to just str.join.
from random import*
s=input()
n=len(s)
r=range(n)
x=sample(r,n)
print''.join(chr(ord(s[i])-32*(i in x[::2]))for i in r)
ẏṖ℅Ih⁽N¨M
Explanation:
ẏ # List of [0..len(input))
Ṗ℅ # Random permutation
Ih # First half of the list
⁽N¨M # Toggle case of the indexes in the list
There is actually a dedicated builtin for Random Permutation, which is faster, but there is a bug in it, so we have to get every permutation and choose a random one.
lambda s:''.join([x,x.upper()][y%2]for x,y in zip(s,sample([*range(len(s))],len(s))))
from random import*
range() iterable is enough for sample(), no need to convert it to list: sample(range(len(s)),len(s))
\$\endgroup\$
=LET(x,LEN(A1),y,RANDARRAY(x),CONCAT(CHAR(CODE(MID(A1,SEQUENCE(x),1))-(y>MEDIAN(y))*32)))
This breaks the string into an array of characters. Then generates an array of random numbers of the same length. For each number in the random array that is greater that the median of the array, the corresponding letter is changed to upper case (ASCII value reduced by 32). Then all of the characters are concatenated.
-pF, 43 bytes1 byte saved thanks to @Kjetil S!
$F[rand@F]&=_,$_=join"",@F
while@F/2>y;A-Z;
-pa, 38 bytes-5 bytes using a space separates string (Thanks @Kjetil S!)
$F[rand@F]&=_,$_="@F"
while@F/2>y;A-Z;
@F*rand can be replaced by rand@F. Also, if you agree, since nothing in the challenge clearly forbids adding a space between the letters in the output join"",@F can be replaced by $_="@F" to save 5 extra bytes.
\$\endgroup\$
rand@F which didn't work for some reason and stopped using it, but I probably just messed it up somehow! Thank you! The list of chars might be pushing it a little but I've added it too. Thanks!
\$\endgroup\$
Dec 2, 2021 at 22:04
(];-){:2|#?.#
#?.# Roll N-sided die N times, where N is len of y
2| Convert this to a length-N boolean vector (half 1s, half 0s)
{: Use this to catalogue..
];- A matrix of the string and the string with inverted caps
{[~] {@_[pick @_/2,^@_]».=uc;@_}(.comb)}
.comb splits the input string into a list of characters, which is then fed to the brace-delimited anonymous function, which takes the list in the @_ array. This is just a short way to get an array with writeable elements without having to declare one explicitly.pick @_ / 2, ^@_ randomly selects half of the indices in the character array.@_[...]».=uc slices into the array of characters with the random selection of indices, and uppercases the characters at those indices. The original array is then returned.[~] concatenates the characters into a single string.
Ｗ⁻⊗ＬΦＫＡ№ακＬθＰ⭆θ‽⁺κ↥κ
Try it online! Link is to verbose version of code. Explanation:
Ｗ⁻⊗ＬΦＫＡ№ακＬθ
Repeat until uppercase letters make up exactly half of the canvas...
Ｐ⭆θ‽⁺κ↥κ
... output the input string but randomly uppercase each letter.
Prompts for string
s[i]←s[i←(.5×⍴s)?⍴s←⎕av⍳⎕]+48⋄⎕av[s]
import random as r
j=range
f=lambda s:(lambda v:''.join(chr(ord(s[i])-32*(i in v))for i in j(l)))(r.sample(j(l:=len(s)),l//2))
(new Array(s.length)).fill(0).map((i,j)=> j % 2).sort(() => Math.random() - 0.5).map((i, j) => (i ? s[j].toUpperCase() : s[j])).join("")
.sort(() => Math.random() - 0.5) is a biased way to shuffle.
\$\endgroup\$
Dec 2, 2021 at 14:29
irysp>l[0f1f,,]p<[>sprl0y?[,sprl]psp<l' *-o]
This one works by generating a list of 0 1 pairs on a list the size of the input string. Then for each input character it reverses the list of 0 1 pairs a random number of times, then pops the top off the resulting stack. That value is used to decide whether or not to capitalize the character before printing it out.
ir - read input codepoints into the stack, reverse the stack
ysp - save the number of char, delete that from the stack
> - switch to an empty stack
0 1 pairs l[0f1f,,]p
l[ ,,]p - loop "n/2" times adding "0,1" pairs to the stack
0f - add a "0" to the stack, pull the iterating var forward
1f - add a "1" to the stack and pull the iterator forward again
<[ ] - loop until the input stack is empty
*3.1* - get a random 0/1 from the boolean stack
<l - back to input stack, load boolean 0/1 capitalization choice
' * - multiple " " by the boolean
- - subtract to capitalize (of boolean was true)
o - print the current input char
3.1 Pull a random boolean off the list
> - switch to the boolean stack
sprl - disrupt pattern on list, move top entry to the bottom
0y? - pick a random number between 0 and the stack size
[,sp l]p - loop that number of time, using backup cell for iterator val
r - reverse the stack
sp - save the random boolean to the backup cell
