La tarea

Su tarea es crear un programa o una función que, dada una entrada, emite el texto de entrada con letras al azar en mayúscula, mientras mantiene las letras ya en mayúscula en mayúscula.

Toda combinación de mayúsculas y minúsculas debería ser posible. Por ejemplo, si la entrada era abc, no debe haber una probabilidad no cero de la salida de cualquiera de las siguientes combinaciones: abc, Abc, aBc, abC, ABc, AbC, aBCo ABC.

Entrada

Su entrada es una cadena, que contiene cualquier número de caracteres ASCII imprimibles, por ejemplo Hello World. Las salidas para que la entrada incluyen HeLLo WoRlD, HElLO WOrld, etc.

Tanteo

Este es el código de golf, por lo que gana la respuesta más corta en cada idioma.

TI-Basic (serie 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

Toma entrada Ans, como se ilustra en la siguiente captura de pantalla:

(Si la captura de pantalla parece codificada, como a veces lo hace para mí, ¿intentas abrirla en una nueva pestaña ?)

TI-Basic (al menos la versión TI-83 ... tal vez debería diversificarme en el golf TI-89) es un lenguaje terrible para intentar jugar este desafío, ya que:

1. No proporciona absolutamente ningún soporte para ninguna aritmética con caracteres, conociendo la versión en mayúscula de un carácter en minúscula, o incluso conociendo el alfabeto.
2. Cada carácter en minúscula toma 2 bytes para almacenar. (De hecho, tuve que usar un script de ensamblaje solo para poder escribir las letras minúsculas).

El resultado es que 78 bytes de este programa (más de la mitad) solo almacenan el alfabeto, dos veces .

De todos modos, la idea es que recorramos la cadena, con la posibilidad de convertir caracteres en minúsculas en mayúsculas a medida que avanzamos, y agregar el resultado al final de la cadena para que tanto la entrada como la salida se almacenen Ans. Cuando dejamos el For(bucle, Ies uno más que la longitud de la cadena original, por lo que tomar los I-1caracteres que comienzan en Ida la salida.

Japt , 6 bytes

®m`«`ö

¡Pruébelo en línea!

Explicación

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

Pruébalo en línea!

C,  47  46 bytes

¡Gracias a @ l4m2 por guardar un byte!

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

Pruébalo en línea!

Sería 42 bytes, si se puede suponer que {|}~no aparecen en la entrada:

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

Pruébalo en línea!

Jalea , 5 bytes

Otro bytes el polvo gracias a dylnan.

żŒuX€

Pruébalo en línea!

Explicación

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

Pruébalo en línea!

JavaScript (ES6), 56 bytes

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

Si no se requiere una aleatoriedad uniforme, podemos ahorrar 6 bytes utilizando la hora actual como fuente de aleatoriedad:

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

Esto tiende a mayúsculas o dejar solo todas las letras a la vez.

R , 66 bytes

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

Pruébalo en línea!

Otra respuesta de R.

Excel VBA, _{74 71} 64 Bytes

La Randomizellamada siempre hace que la salida aleatoria sea costosa en VBA :(

Función de ventana inmediata anónima de VBE que toma entrada del rango [A1]y salidas a la ventana inmediata de VBE. Produce un 50% (en promedio) de UCasesalida d.

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

Carbón , 8 7 bytes

⭆Ｓ‽⁺↥ιι

Pruébalo en línea! El enlace es a la versión detallada del código. Explicación:

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

Rubí, 40 bytes

Función lambda que toma una cadena. Guardado 1 byte gracias a Arnauld. Guardado 5 bytes gracias a 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 entrada de pantalla, identifica letras minúsculas y las convierte aleatoriamente a mayúsculas.

R , 89 88 bytes

superado por djhurio!

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

Pruébalo en línea!

Este programa toma cada carácter y, con probabilidad, 1/2 lo convierte a mayúsculas o lo deja solo. Es posible ajustar esta probabilidad jugando con diferentes valores de dfy 0.

rtse basa en la distribución t de Student, que tiene una mediana de 0 con cualquier grado de libertad (seleccioné 1ya que es el número más pequeño posible).

05AB1E , 6 5 bytes

Gracias Adnan por -1 byte

uø€ΩJ

Pruébalo en línea!

Explicación

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 tomado de la respuesta de @ totallyhuman

Ruby, 39 bytes

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

En gran parte inspirado de la respuesta de displayname . (No pude comentar para sugerir esta versión de un byte por falta de reputación, lo siento, nombre para mostrar )

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

Esta lambda es de IntStreama IntStream(secuencias de puntos de código).

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

Pruébalo en línea

Distribución de capitalización

Solía ​​ser mayúscula o minúscula una condición bastante sensata Math.random()<.5, que se cumplía la mitad del tiempo. Con la condición actual de Math.random()>0(que ahorra un byte), las mayúsculas se producen prácticamente todo el tiempo, lo que hace que un programa de prueba sea inútil. Pero sí satisface el requisito de aleatoriedad.

Expresiones de gratitud

• -1 byte gracias a Olivier Grégoire

Funky , 55 bytes

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

Pruébalo en línea!

Gracias a las comas opcionales, es un byte más corto para hacer 0s.upperen la definición de la tabla, lo que significa que math.randomelegirá aleatoriamente 1o 2, que hacer math.random(0,1)en el azar y no tener el 0.

R , 60 59 58 57 56 63 bytes

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

Pruébalo en línea!

Enfoque diferente de las otras dos respuestas R aquí y aquí . ¡Mejorado y reparado gracias a Giuseppe!

Ouroboros , 25 bytes

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

Pruébalo aquí

La única parte de fantasía es el flujo de control, .b*). Hablemos primero del resto.

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

Luego volvemos al principio de la línea. El flujo de control implica cambiar dónde está el final de la línea; Si se mueve a la izquierda de la IP, la ejecución termina. Así:

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

Cuando el código de char es positivo, )no funciona, ya que el final de la línea está lo más a la derecha posible. Pero cuando todos los personajes han sido leídos, ida -1. Luego, movemos el final de los -11caracteres del código a la derecha, es decir, 11 caracteres a la izquierda. Toma un par de iteraciones, pero finalmente la IP ha pasado el final del código y el programa se detiene.

MATL , 12 11 bytes

"@rEk?Xk]v!

Pruébalo en línea!

Guardado 1 byte gracias a @LuisMendo

Brachylog , 5 bytes

ụᶻṛᵐc

Pruébalo en línea!

Explicación

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

Gracias a Leo por guardar 2 bytes.

/uRUwk
\i*&o.@/

Pruébalo en línea!

Explicación

/...
\...@/

Este es el marco habitual para programas en gran medida lineales que operan completamente en 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.

Primero intenté hacer esto completamente en modo Cardinal, pero determinar si algo es una letra basada en el código de caracteres probablemente tomaría más bytes.

Wolfram Language (Mathematica) , 52 49 44 bytes

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

Pruébalo en línea!

Utiliza la forma del operador de StringReplace : proporcionándole una regla (o una lista de reglas) pero ninguna cadena proporciona una función que aplica esa regla a cualquier cadena que le dé como entrada.

Podríamos hacerlo mucho mejor ( RandomChoice@{#,Capitalize@#}&/@#&es 34 bytes) si decidiéramos tomar como entrada (y producir como salida) una lista de caracteres, que la gente a veces argumenta que está bien en Mathematica porque es el único tipo de cadena que hay en otros idiomas. Pero eso no es divertido.

-5 bytes gracias a M. Stern

Pyth, 10 7 6 bytes

smO,r1

Guardado 3 bytes gracias a ovs y 1 gracias a Steven H.

Pruébalo en línea

Explicación

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;

Logramos reducir el código con 10 bytes siguiendo (parcialmente) siguiendo la sugerencia de Titus.

PowerShell , 57 56 bytes

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

Pruébalo en línea!

-1 byte gracias a briantist

Toma la entrada como una cadena, convierte explícitamente la $argsmatriz en una cadena, la charconvierte como una matriz y luego alimenta los caracteres a través de un bucle. En cada iteración, 50-50 da como resultado el carácter tal cual $_o lo convertimos a mayúsculas "$_".ToUpper()(esa es la ("$_"|% *per)basura). Eso se elige al obtener un Randomnúmero entero y tomarlo mod 2.

Esos caracteres se dejan en la tubería y luego se -joinvuelven a unir en una sola cadena, que se deja en la tubería y la salida es implícita.

Julia , 35 bytes

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

Pruébalo en línea!

Todavía es bastante fácil de leer como humano. En Julia rand (A) devuelve un elemento aleatorio de A.

Rebol , 61 bytes

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

Prueba:

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

Jalea , 16 bytes

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

Pruébalo en línea!

Explicación

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)

No pude hacer que esto funcione en una sola línea. Asimismo, no sé por qué, pero 2ḶXø³L¤Ð¡da la lista [None,1,0,..,1]con 0s y 1S elegido al azar. El Nonees el motivo de la Ḋen el primer enlace.