A tarefa

Sua tarefa é criar um programa ou uma função que, dada uma entrada, produza o texto de entrada com letras aleatórias maiúsculas, mantendo as letras maiúsculas já maiúsculas.

Toda combinação de maiúsculas e minúsculas deve ser possível. Por exemplo, se a entrada foi abc, deve haver uma probabilidade não nula de saída de qualquer uma das seguintes combinações: abc, Abc, aBc, abC, ABc, AbC, aBCou ABC.

Entrada

Sua entrada é uma sequência que contém qualquer número de caracteres ASCII imprimíveis, por exemplo Hello World. As saídas para que a entrada incluem HeLLo WoRlD, HElLO WOrldetc.

Pontuação

Isso é código-golfe, então a resposta mais curta em cada idioma vence!

TI-Basic (série 83), 137 bytes

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

Recebe entrada Ans, conforme ilustrado na captura de tela abaixo:

(Se a captura de tela parecer embaralhada, como às vezes acontece comigo, tente abri-la em uma nova guia ?)

A TI-Basic (pelo menos a versão da TI-83 ... talvez eu deva me dedicar ao golfe da TI-89) é uma linguagem terrível para tentar superar esse desafio, pois:

1. Ele não oferece absolutamente nenhum suporte para qualquer aritmética com caracteres, sabendo a versão em maiúscula de um caractere em minúscula ou mesmo o alfabeto.
2. Cada caractere minúsculo leva 2 bytes para armazenar. (Na verdade, eu tive que usar um script de montagem apenas para poder digitar as letras minúsculas.)

O resultado é que 78 bytes deste programa (mais da metade) estão apenas armazenando o alfabeto duas vezes .

De qualquer forma, a ideia é que passemos pela string, com a chance de transformar caracteres minúsculos em maiúsculos à medida que avançamos, e adicionando o resultado ao final da string para que a entrada e a saída sejam armazenadas Ans. Quando deixamos o For(loop, Ié um a mais que o comprimento da string original, portanto, pegar os I-1caracteres começando em Ifornece a saída.

Japonês , 6 bytes

®m`«`ö

Teste online!

Explicação

®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 bytes

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

Experimente online!

C,  47  46 bytes

Obrigado a @ l4m2 por salvar um byte!

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

Experimente online!

Seriam 42 bytes, se for possível supor que {|}~não apareçam na entrada:

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

Experimente online!

Gelatina , 5 bytes

Outro bytes a poeira graças a dylnan.

żŒuX€

Experimente online!

Explicação

żŒ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 bytes

Código de 22 bytes + 1 para -p.

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

Experimente online!

JavaScript (ES6), 56 bytes

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

Se a aleatoriedade uniforme não for necessária, podemos salvar 6 bytes usando o tempo atual como fonte de aleatoriedade:

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

Isso tende a maiúsculas ou a deixar todas as letras de uma só vez.

R , 66 bytes

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

Experimente online!

Outra resposta R.

Excel VBA, _{74 71} 64 bytes

A Randomizechamada sempre torna a saída aleatória cara no VBA :(

Função de janela imediata VBE anônima que leva a entrada do intervalo [A1]e sai para a janela imediata VBE. Produz uma UCasesaída de 50% (em média) d.

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

Carvão , 8 7 bytes

⭆Ｓ‽⁺↥ιι

Experimente online! Link é a versão detalhada do código. Explicação:

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

Ruby, 40 bytes

Função Lambda que aceita uma string. Guardado 1 byte graças a Arnauld. Economizou 5 bytes graças ao Snack.

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

APL + WIN, 37 bytes

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

Solicita a entrada na tela, identifica letras minúsculas e as converte aleatoriamente em maiúsculas.

R , 89 88 bytes

superado por djhurio!

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

Experimente online!

Este programa pega cada caractere e, com probabilidade 1/2, o converte para maiúsculas ou o deixa em paz. É possível ajustar essa probabilidade jogando com diferentes valores de dfe 0.

rtextrai da distribuição t do aluno, que tem mediana 0 com qualquer grau de liberdade (eu selecionei 1porque é o menor número possível).

05AB1E , 6 5 bytes

Obrigado Adnan por -1 byte

uø€ΩJ

Experimente online!

Explicação

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

Método retirado da resposta de totallyhuman

Ruby, 39 bytes

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

Em grande parte inspirado na resposta do nome de exibição . (Não pude comentar para sugerir esta versão de um byte-less por falta de reputação, desculpe nome de exibição )

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

Este lambda é de IntStreama IntStream(fluxos de pontos de código).

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

Experimente Online

Distribuição de capitalização

A capitalização de uma letra costumava ser a condição bastante sensata que Math.random()<.5, satisfeita na metade do tempo. Com a condição atual deMath.random()>0 (que economiza um byte), a capitalização ocorre virtualmente toda vez, o que torna um programa de teste meio inútil. Mas satisfaz o requisito de aleatoriedade.

Agradecimentos

• -1 byte graças a Olivier Grégoire

Funky , 55 bytes

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

Experimente online!

Graças às vírgulas opcionais, é um byte mais curto para fazer 0s.upperna definição da tabela, o que significa que math.randomele escolherá aleatoriamente um 1ou outro 2do que fazer math.random(0,1)no aleatório e não possuir o 0.

R , 60 59 58 57 56 63 bytes

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

Experimente online!

Abordagem diferente das outras duas respostas R aqui e aqui . Melhorado e corrigido graças a Giuseppe!

Ouroboros , 25 bytes

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

Experimente aqui

A única parte sofisticada é o fluxo de controle .b*),. Vamos falar sobre o resto primeiro.

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

Em seguida, retornamos ao início da linha. O fluxo de controle envolve mudar onde está o final da linha; se for movido para a esquerda do IP, a execução será encerrada. Portanto:

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

Quando o código é positivo, )é um no-op, já que o final da linha é o mais correto possível. Mas quando todos os personagens foram lidos, idá -1. Em seguida, movemos o final dos -11caracteres de código para a direita - ou seja, 11 caracteres para a esquerda. São necessárias algumas iterações, mas, eventualmente, o IP já passou do final do código e o programa é interrompido.

MATL , 12 11 bytes

"@rEk?Xk]v!

Experimente online!

Guardado 1 byte graças a @LuisMendo

Braquilog , 5 bytes

ụᶻṛᵐc

Experimente online!

Explicação

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

Agradecemos a Leo por salvar 2 bytes.

/uRUwk
\i*&o.@/

Experimente online!

Explicação

/...
\...@/

Essa é a estrutura usual para programas amplamente lineares que operam inteiramente no modo Ordinal.

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.

Tentei fazer isso inteiramente no modo Cardinal, mas determinar se algo é uma letra apenas com base no código de caracteres provavelmente levaria mais bytes.

Wolfram Language (Mathematica) , 52 49 44 bytes

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

Experimente online!

Usa a forma de operador StringReplace : fornecendo uma regra (ou uma lista de regras), mas nenhuma string fornece uma função que aplica essa regra a qualquer string fornecida como entrada.

Poderíamos ter um desempenho muito melhor ( RandomChoice@{#,Capitalize@#}&/@#&são 34 bytes) se decidíssemos usar como entrada (e produzir como saída) uma lista de caracteres, que as pessoas às vezes argumentam que estão bem no Mathematica, porque é o único tipo de string existente em outros idiomas. Mas isso não é divertido.

-5 bytes graças a M. Stern

Pitão, 10 7 6 bytes

smO,r1

Economizou 3 bytes graças a ovs e 1 graças a Steven H.

Experimente online

Explicação

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;

Conseguiu reduzir o código com 10 bytes (parcialmente) seguindo a sugestão de Titus.

PowerShell , 57 56 bytes

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

Experimente online!

-1 byte graças ao briantist

Pega a entrada como uma string, lança explicitamente a $argsmatriz em uma string, lança como uma charmatriz e, em seguida, alimenta os caracteres por um loop. A cada iteração, 50-50 produzimos o caractere como ele é $_ou o convertemos para maiúsculas "$_".ToUpper()(esse é o ("$_"|% *per)lixo). É escolhido obtendo um Randomnúmero inteiro e modificando-o 2.

Esses caracteres são deixados no pipeline e -joinreunidos novamente em uma única sequência, que é deixada no pipeline e a saída é implícita.

Julia , 35 bytes

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

Experimente online!

Ainda é muito fácil de ler como humano. Em Julia rand (A) retorna um elemento aleatório de A.

Rebol , 61 bytes

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

Teste:

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

Gelatina , 16 bytes

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

Experimente online!

Explicação

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)

Não consegui fazer isso funcionar em uma única linha. Eu também não sei porque, mas 2ḶXø³L¤Ð¡dá a lista [None,1,0,..,1]com 0s e 1s escolhidos aleatoriamente. Esse Noneé o motivo Ḋdo primeiro link.