Capitalização aleatória

37

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!

code-golf  string  random 
— Brecert
fonte

Respostas:

14

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:

insira a descrição da imagem aqui

(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.

— Misha Lavrov
fonte
Os aplicativos "MirageOS" e "OmniCalc" permitem digitar letras minúsculas pressionando alfa duas vezes. E eles também têm outros recursos interessantes.
— Fabian Röling 01/12/19
@Fabian O script de montagem e os aplicativos que você mencionou funcionam essencialmente da mesma maneira: eles definem um sinalizador no sistema operacional que permite "pressionar alfa duas vezes para minúsculas".
— Misha Lavrov
11

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
— ETHproductions
fonte
10

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!

— Steadybox
fonte
Vale ressaltar que, dada uma implementação específica, a capitalização é perfeitamente determinística (o padrão C fornece um implícito srand(1)no início do programa, portanto, em cada execução, a sequência de valores retornada por rand()será a mesma).
— Matteo Italia
f(char*s){for(;*s++-=(*s-'a'<26&rand())*32;);}por algum compilador (def. -funsigned-char) trabalho
— l4m2
@ l4m2 Obrigado! Isso não funciona, por algum motivo. Mudar 'a'para 97uobras e nem exige a -funsigned-charbandeira.
— Steadybox
Parece que quando você subtrai 'a'(o que é signed int, não unsigned char) de *s(o que é unsigned char), *sé promovido para, e signed intnão unsigned int, portanto, valores negativos são possíveis e a comparação não funciona como pretendido.
— Steadybox
8

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"
— totalmente humano
fonte
11
Eu preciso usar ŒṘmais frequentemente para ver como as coisas são representados sob o capô
— dylnan
7

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.

— ETHproductions
fonte
"deve haver uma probabilidade diferente de zero de produzir qualquer uma das seguintes combinações: abc, Abc, aBc, abC, ABc, AbC, aBC ou ABC", enquanto o seu não pode ser exibido AbCporque o tempo não muda tão rápido
— l4m2 27/05
@ l4m2 se você tem uma máquina muito lenta, ela pode ;-) Talvez eu deva remover essa parte ...
— ETHproductions
6

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
— Taylor Scott
fonte
Olá senhor. você pode salvar 2 bytes removendo Randomize:e alterando Rndcom [RAND()>.5]. Ou apenas ignore. :)
— remoel
@remoel, infelizmente, a [Rand()]chamada é apenas psuedo-random e tem um período de aproximadamente 10 ^ 13, tornando-a funcionalmente idêntica à chamada un Randomized Rnd; de fato, os dois usam a mesma semente (que a Randomizechamada define usando a timerfunção saída).
— Taylor Scott
@romoel, I no entanto não suponha que dados os esclarecimentos sobre o pedido que eu poderia remover a Randomizechamada e passar a usarRnd>.5
— Taylor Scott
6

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
— Neil
fonte
4

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}}
— Mostrar nome
fonte
11
Bem-vindo ao PPCG! Você poderia salvar um byte em <1vez de ==1?
— Arnauld
11
— Snack
Bom trabalho @displayname. Quando os usuários melhoram sua pontuação, muitos gostam de "riscar" a pontuação antiga com a <s>tag, por exemplo, " Ruby, <s> 46 </s> 40 bytes ". Claro que não é necessário.
— Jordan
3

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.

— Graham
fonte
3

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).

— Giuseppe
fonte
11
Essa é uma maneira muito R de fazer algo aleatoriamente.
— Misha Lavrov
11
— djhurio
@djhurio que é brilhante.
— 31717 Giuseppe
3

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

— dylnan
fonte
11
Alguém já venceu 6? : P
— ETHproductions
11
@ETHproductions Se a Jelly tivesse um operador de byte único para maiúsculas como 05AB1E, teríamos!
— dylnan
Ooo ... Novo comando para random_pick eh? ε„luΩ.Vfoi minha tentativa, boa!
— Magic Octopus Urn
3
Você pode deixar o fora duplicado :)
— Adnan
11
Alguém vai bater 5? : P
— totallyhuman
3

Swift 4, 86 bytes

s.map{let s="\($0)",u=s.uppercased();return u==s ? u:arc4random()%2==0 ? u:s}.joined()
— Au Ris
fonte
3
Bem-vindo ao PPCG!
— Martin Ender
3

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
— Jakob
fonte
Se você seguir a rota do fluxo, poderá usar pontos de código e fazer 41 bytes .
— Olivier Grégoire 30/11
Bem, isso é interrompido se a entrada contiver caracteres ASCII acima z. Eu poderia jogar com uma qualificação.
— 21417 Jakob
11
— Olivier Grégoire 30/11
3

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.

— ATaco
fonte
3

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!

— JayCe
fonte
Eu não sabia que as funções de amostragem se comportavam assim!
— Giuseppe
@Giuseppe Apenas quando eu pensei que este não poderia ser golfed baixo ...
— Jayce
— Giuseppe
@ Giuseppe Não é só este jogador de golfe, mas também mais elegante! Adoro!
— 21418 JayCe
em segunda vista, isso não vai funcionar caracteres ASCII quando imprimíveis acima 90como [, mas corrige este lo para +7 bytes que ainda Golfier é que a resposta de djhurio
— Giuseppe
2

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.

— DLosc
fonte
2

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"
— Fatalizar
fonte
2

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.

— Martin Ender
fonte
2

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

— Misha Lavrov
fonte
Salve um byte usando #Capitalize
— S.S M.
Se você ignorar que Randomestá obsoleta você poderia economizar mais quatro bytes através da implementação de seu próprio RandomChoice: StringReplace[c_/;Random[]<.5:>Capitalize@c],
— M. Stern
@ M.Stern Eu estava tentando começar Randoma trabalhar em um ponto, mas esqueci o /;que estava tentando fazer em uma Ifdeclaração. Obrigado!
— Misha Lavrov
2

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.
— Mnemônico
fonte
r1d= rd1, permitindo que você introduza implicitamente outro byte de saída.
— Steven H.
2

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.

— RFSnake
fonte
11
Agradável! Não há necessidade de um espaço antes $a. Tente em while(~$a=$argn[$i++])vez de foreach(execute como tubo).
— Titus
Usando esse código, recebi o erro "Erro não capturado: tipos de operandos não suportados". E eu não consigo entender por que isso acontece, mas suspeito que o ~. (e talvez porque eu uso PHP7 eo método só funciona para 5,6)
— RFSnake
2

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.

— AdmBorkBork
fonte
Você pode salvar um único byte mudando "$_".ToUpper()para ("$_"|% *per): - /
— briantist
11
@ briantist Ainda bem que não nos importamos com legibilidade. ;-) Obrigado!
— AdmBorkBork
1

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
— Galen Ivanov
fonte
1

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.

— dylnan
fonte
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.