L'obiettivo

Il tuo compito è quello di creare un programma o una funzione che, dato un input, produca il testo di input con lettere casuali in maiuscolo, mantenendo maiuscole in maiuscolo.

Dovrebbe essere possibile ogni combinazione di maiuscole delle lettere minuscole. Ad esempio, se l'ingresso fosse abc, ci dovrebbero essere una probabilità non nulla di emettere una qualsiasi delle seguenti combinazioni: abc, Abc, aBc, abC, ABc, AbC, aBCo ABC.

Ingresso

L'input è una stringa, contenente ad esempio un numero qualsiasi di caratteri ASCII stampabili Hello World. Le uscite per l'input includono HeLLo WoRlD, HElLO WOrldecc

punteggio

Questo è code-golf, quindi vince la risposta più breve in ogni lingua!

TI-Basic (serie 83), 137 byte

For(I,1,length(Ans
Ans+sub(sub(Ans,I,1)+"ABCDEFGHIJKLMNOPQRSTUVWXYZ",1+int(2rand)inString("abcdefghijklmnopqrstuvwxyz",sub(Ans,I,1)),1
End
sub(Ans,I,I-1

Riceve input Ans, come illustrato nello screenshot seguente:

(Se lo screenshot sembra confuso, come a volte fa per me, prova ad aprirlo in una nuova scheda ?)

TI-Basic (almeno la versione TI-83 ... forse dovrei estendermi al golf TI-89) è un linguaggio terribile in cui provare a giocare a questa sfida, dal momento che:

1. Non fornisce assolutamente alcun supporto per qualsiasi aritmetica con i personaggi, conoscendo la versione maiuscola di un carattere minuscolo o conoscendo anche l'alfabeto.
2. Ogni singolo carattere minuscolo richiede 2 byte per la memorizzazione. (In effetti, ho dovuto usare uno script di assembly solo per poter digitare le lettere minuscole.)

Il risultato è che 78 byte di questo programma (più della metà) stanno solo memorizzando l'alfabeto, due volte .

Ad ogni modo, l'idea è di passare in rassegna la stringa, con la possibilità di trasformare i caratteri minuscoli in caratteri maiuscoli mentre andiamo, e di aggiungere il risultato alla fine della stringa in modo che sia l'input che l'output siano memorizzati Ans. Quando lasciamo il For(ciclo, Iè uno in più della lunghezza della stringa originale, quindi prendere i I-1caratteri a partire da Idà l'output.

Japt , 6 byte

®m`«`ö

Provalo online!

Spiegazione

®m`«`ö   Implicit input
®        Map each char in the input by
 m         mapping each char in this char through
  `«`ö       a random character of "us". (`«` is "us" compressed)
             The u function converts to uppercase, and s is slice, which does nothing here.
         Implicit output

Python 2 , 66 65 byte

lambda s:`map(choice,zip(s.upper(),s))`[2::5]
from random import*

Provalo online!

C,  47  46 byte

Grazie a @ l4m2 per aver salvato un byte!

f(char*s){for(;*s++-=(*s-97u<26&rand())*32;);}

Provalo online!

Sarebbe 42 byte, se si potesse presumere che {|}~non compaiano nell'input:

f(char*s){for(;*s++-=(*s>96&rand())*32;);}

Provalo online!

Gelatina , 5 byte

Un altro bytes la polvere grazie a Dylnan.

żŒuX€

Provalo online!

Spiegazione

żŒuX€  main link: s = "Hello world"

żŒu    zip s with s uppercased  ["HH", "eE", "lL", "lL", "oO", "  ", ...]
   X€  map random choice        "HeLLo woRlD"

Perl 5 , 23 byte

22 byte codice + 1 per -p.

s/./rand>.5?uc$&:$&/ge

Provalo online!

JavaScript (ES6), 56 byte

s=>s.replace(/./g,x=>Math.random()<.5?x.toUpperCase():x)

Se non è richiesta una casualità uniforme, possiamo salvare 6 byte utilizzando l'ora corrente come fonte di casualità:

s=>s.replace(/./g,x=>new Date&1?x.toUpperCase():x)

Questo tende a maiuscole oa lasciare tutte le lettere in una sola volta.

R , 66 byte

for(i in el(strsplit(scan(,""),"")))cat(sample(c(i,toupper(i)),1))

Provalo online!

Un'altra risposta R.

Excel VBA, _{74 71} 64 byte

La Randomizechiamata rende sempre costoso l'output casuale in VBA :(

Funzione di finestra immediata VBE anonima che accetta input dalla gamma [A1]e output alla finestra immediata VBE. Produce UCaseun'uscita del 50% (in media) .

For i=1To[Len(A1)]:a=Mid([A1],i,1):?IIf(Rnd>.5,a,UCase(a));:Next

Carbone , 8 7 byte

⭆Ｓ‽⁺↥ιι

Provalo online! Il collegamento è alla versione dettagliata del codice. Spiegazione:

 Ｓ          Input string
      ι     Character
    ↥ι      Uppercase character
   ⁺        Concatenate
  ‽         Random element
⭆           Map over each character and join the result
            Implicitly print

Rubino, 40 byte

Funzione lambda che accetta una stringa. Salvato 1 byte grazie ad Arnauld. 5 byte salvati grazie a Snack.

->s{s.gsub(/./){|x|[x,x.upcase].sample}}

APL + WIN, 37 byte

⎕av[c-((n÷2)<n?n←⍴s)×32×s←98<c←⎕av⍳⎕]

Richiede l'inserimento dello schermo, identifica le lettere minuscole e le converte casualmente in lettere maiuscole.

R , 89 88 byte

superato da djhurio!

cat(sapply(el(strsplit(scan(,""),"")),function(x)"if"(rt(1,1)<0,toupper,`(`)(x)),sep="")

Provalo online!

Questo programma prende ogni personaggio e con probabilità 1/2 lo converte in maiuscolo o lo lascia da solo. È possibile modificare questa probabilità giocando con valori diversi di dfe 0.

rtattinge dalla distribuzione t di Student, che ha una mediana 0 con qualsiasi grado di libertà (ho selezionato 1poiché è il numero più piccolo possibile).

05AB1E , 6 5 byte

Grazie Adnan per -1 byte

uø€ΩJ

Provalo online!

Spiegazione

uø€ΩJ   
u      Upper case of top of stack. Stack: ['zzzAA','ZZZAA']
 ø     Zip(a,b). Stack: ['zZ', 'zZ', 'zZ', 'AA', 'AA']
  €    Following operator at each element of it's operand
   Ω   Random choice. Stack: ['z', 'Z', 'z', 'A', 'A']
    J  Join a by ''. Stack: 'zZzAA'
        Implicit output

Metodo preso dalla risposta di @hhhhuman

Rubino, 39 byte

->s{s.gsub(/./){[$&,$&.upcase].sample}}

In gran parte ispirato dalla risposta di displayname . (Non posso commentare per suggerire questa versione a un byte in meno per mancanza di reputazione, mi dispiace displayname )

Swift 4, 86 bytes

s.map{let s="\($0)",u=s.uppercased();return u==s ? u:arc4random()%2==0 ? u:s}.joined()

Java 8, 46 bytes

This lambda is from IntStream to IntStream (streams of code points).

s->s.map(c->c>96&c<'{'&Math.random()>0?c-32:c)

Try It Online

Capitalization distribution

Whether to capitalize a letter used to be the quite sensible condition that Math.random()<.5, which was satisfied about half the time. With the current condition of Math.random()>0 (which saves a byte), capitalization occurs virtually every time, which makes a test program kind of pointless. But it does satisfy the randomness requirement.

Acknowledgments

• -1 byte thanks to Olivier Grégoire

Funky, 55 bytes

s=>s::gsub("."c=>{0s.upper,s.lower}[math.random(2)](c))

Try it online!

Thanks to optional commas, it's one byte shorter to do 0s.upper in the table definition, which means the math.random will randomly pick either 1 or 2, than to do math.random(0,1) in the random and not have the 0.

R, 60 59 58 57 56 63 bytes

intToUtf8((s=utf8ToInt(scan(,"")))-32*rbinom(s,s%in%97:122,.5))

Try it online!

Different approach from the other two R answers here and here. Improved and fixed thanks to Giuseppe!

Ouroboros, 25 bytes

i.b*)..96>\123<*?2*>32*-o

Try it here

The only fancy part is the control flow, .b*). Let's talk about the rest first.

i..                    Get a character of input, duplicate twice
   96>                 Test if charcode greater than 96
      \                Swap with copy #2
       123<            Test if charcode less than 123
           *           Multiply the two tests (logical AND): test if it is lowercase letter
            ?          Random number between 0 and 1
             2*        Times 2
               >       Is lcase test greater? If test was 1 and rand*2 < 1, then 1, else 0
                32*-   Multiply by 32 and subtract from charcode to ucase lcase letter
                    o  Output as character

We then loop back to the beginning of the line. Control flow involves changing where the end of the line is; if it is moved to the left of the IP, execution terminates. Thus:

 .     Duplicate input charcode
  b*   Push 11 and multiply
    )  Move end of line that many characters to the right

When the charcode is positive, ) is a no-op, since the end of the line is as far right as it can go. But when all characters have been read, i gives -1. Then we move the end of the code -11 characters to the right--that is, 11 characters to the left. It takes a couple iterations, but eventually the IP is past the end of the code and the program halts.

MATL, 12 11 bytes

"@rEk?Xk]v!

Try it online!

Saved 1 byte thanks to @LuisMendo

Brachylog, 5 bytes

ụᶻṛᵐc

Try it online!

Explanation

Example input: "Test"

ụᶻ        Zip uppercase:      [["T","T"],["e","E"],["s","S"],["t","T"]]
  ṛᵐ      Map random element: ["T","e","S","T"]
    c     Concatenate:        "TeST"

Alice, 17 15 bytes

Thanks to Leo for saving 2 bytes.

/uRUwk
\i*&o.@/

Try it online!

Explanation

/...
\...@/

This is the usual framework for largely linear programs operating entirely in Ordinal mode.

i    Read all input as a string.
R    Reverse the input.
&w   Fold w over the characters of the string. w is nullary which means it
     doesn't actually use the individual characters. So what this does is that
     a) it just splits the string into individual characters and b) it invokes
     w once for each character in the string. w itself stores the current 
     IP position on the return address stack to begin the main loop which
     will then run N+1 times where N is the length of the string. The one
     additional iteration at the end doesn't matter because it will just
     output an empty string.
.    Duplicate the current character.
u    Convert it to upper case (does nothing for characters that aren't
     lower case letters).
*    Join the original character to the upper case variant.
U    Choose a character at random (uniformly).
o    Print the character.
k    If the return address stack is not empty yet, pop an address from it
     and jump back to the w.
@    Terminate the program.

I first tried doing this entirely in Cardinal mode, but determining if something is a letter just based on character code would probably take more bytes.

Wolfram Language (Mathematica), 52 49 44 bytes

StringReplace[c_/;Random[]<.5:>Capitalize@c]

Try it online!

Uses the operator form of StringReplace: providing it a rule (or a list of rules) but no string gives a function which applies that rule to any string you give it as input.

We could do a lot better (RandomChoice@{#,Capitalize@#}&/@#& is 34 bytes) if we decided to take as input (and produce as output) a list of characters, which people sometimes argue is okay in Mathematica because it's the only kind of string there is in other languages. But that's no fun.

-5 bytes thanks to M. Stern

Pyth, 10 7 6 bytes

smO,r1

Saved 3 bytes thanks to ovs and 1 thanks to Steven H.

Try it online

Explanation

smO,r1
 m      Q   For each character in the (implicit) input...
   ,r1dd    ... get the capitalized version and the (implicit) character, ...
  O         ... and pick one at random.
s           Concatenate the result.

PHP, 63 53 bytes

while($a=$argv[1][$i++])echo rand()%2?ucfirst($a):$a;

Managed to reduce the code with 10 bytes by (partialy) following Titus' suggestion.

PowerShell, 57 56 bytes

-join([char[]]"$args"|%{(("$_"|% *per),$_)[(Random)%2]})

Try it online!

-1 byte thanks to briantist

Takes input as a string, explicitly casts the $args array to a string, casts it as a char-array, then feeds the characters through a loop. Each iteration, we 50-50 either output the character as-is $_ or convert it to upper-case "$_".ToUpper() (that's the ("$_"|% *per) garbage). That's chosen by getting a Random integer and taking it mod 2.

Those characters are left on the pipeline and then -joined back together into a single string, which is itself left on the pipeline and output is implicit.

Julia, 35 bytes

s->map(c->rand([c,uppercase(c)]),s)

Try it online!

Still pretty easy to read as a human. In Julia rand(A) returns a random element from A.

Rebol, 61 bytes

u:func[t][n: random length? t t/(n): uppercase t/(n) print t]

Test:

>>c: "Test sTring"
>>u c
Test sTriNg

Jelly, 16 bytes

2ḶXø³L¤Ð¡ḊT
Œu¢¦

Try it online!

Explanation

2ḶXø³L¤Ð¡ḊT    First Link
2Ḷ             The list [0,1]
  X            Random element (1 is truthy, 0 is falsy)
   ø           Begin nilad
    ³L         Length of first input (the string)
      ¤        End nilad
       С      Random([0,1]) for each character in the input string and collect.
         Ḋ     The list had an extra None at the beginning. Don't know why. This removes it (the first element of the list)
          T    Get indices of all truthy 

Œu¢¦           Main Link
Œu             Capitalize
   ¦           At the indices in the list:
  ¢            The first link as a nilad (list of indices)

I couldn't get this to work in a single line. I also don't know why, but 2ḶXø³L¤Ð¡ gives the list [None,1,0,..,1] with 0s and 1s chosen randomly. The None is the reason for the Ḋ in the first link.