USTED PODRÁ DARSE UNA ESCRITURA QUE CONSIDERA DE CARACTERÍSTICAS ASPIRABLES PINTABLES.

USTED ESTÁ A TRAVÉS DE ESCRIBIR EL RENDIMIENTO DE CAMBIO (UNIFORME, 50% DE CARACTERÍSTICAS DE CARGA) PARA UTILIZAR Y EXPERTAR MÁS.

Eso es.

(perdón por la puntuación, fue por el concepto de la pregunta)

Versión legible:

Se le dará una cadena que consiste en caracteres ASCII imprimibles.

Usted itera a través de la cadena y cambia las letras aleatorias (uniformes, 50% de probabilidad en mayúsculas) a mayúsculas, y todo lo demás a minúsculas.

Eso es.

EJEMPLOS

iNpuT => pOssiBle oUtPUt
Programming puzzles and Code Golf => pRogRaMMiNg pUzzlEs aNd coDe goLf
dErpity deRp derP => deRpiTy dErp DerP
CAAAPSLOOOCK => cAAapslOoocK
_#$^&^&* => _#$^&^&*

C - 65 bytes

¡Bastante bueno para un lenguaje convencional!

main(c){while((c=getchar())>0)putchar(isalpha(c)?c^rand()&32:c);}

Utiliza XOR para voltear aleatoriamente el bit en 0x20cada carácter alfabético. El programa asume el conjunto de caracteres ASCII y eso EOF < 0.

Ejecución de muestra en su propia fuente!

$ main < main.c
MaIN(c){WhILe((C=GETChAr())>0)pUtCHaR(iSALpha(C)?C^rANd()&32:C);}

Muy derpy.

JavaScript, 87 bytes

function(s){return s.replace(/./g,c=>Math.random()<.5?c.toLowerCase():c.toUpperCase())}

68 bytes en ES6:

f=
s=>s.replace(/./g,c=>c[`to${Math.random()<.5?`Low`:`Upp`}erCase`]())

<input oninput=o.textContent=f(this.value)><pre id=o>

Jalea , 6 bytes

,ŒsXµ€

Pruébalo en línea!

¿Cómo?

Poner en minúsculas todos los caracteres de la entrada y luego en mayúsculas cada uno con un 50% de probabilidad es lo mismo que elegir uno de los caracteres originales y el carácter de mayúsculas y minúsculas con la misma probabilidad ...

,ŒsXµ€ - Main link: string s
    µ  - monadic chain separation
     € - for each char c in s
,      -     pair c with
 Œs    -     swapped case of c
   X   -     choose a random item from the list (of the two chars)
       - implicit print

PowerShell , 64 60 bytes

-join([char[]]"$args".ToLower()|%{"$_".ToUpper(),$_|random})

Pruébalo en línea!(asegúrese de que "deshabilitar caché de salida" esté marcado si desea resultados aleatorios)

Traducción exacta del desafío. Toma la cadena de entrada, ToLower()la convierte, la convierte en una charmatriz, recorre cada carácter |%{...}y selecciona aleatoriamente entre el carácter existente o la variante en mayúscula. Luego -join, vuelva a juntarlos en una sola cuerda. Esto funciona porque ToUppery ToLowersolo afecta a los caracteres alfabéticos, dejando los signos de puntuación y similares sin cambios.

(Dennis arregló la lista de alias en TIO, por lo que Randomno está probando Linux randomsino correctamente alias Get-Randomcomo un comando de PowerShell, como debería ser. ¡Gracias, Dennis!)

MATL , 13 12 bytes

"@ktXkhlZr&h

Pruébalo en MATL Online

Explicación

        % Implicitly grab input as a string
"       % For each character...
  k     % Convert to lowercase
  tXk   % Make a copy and convert to uppercase
  h     % Horizontally concatenate these two characters
  lZr   % Randomly select one of them
  &h    % Horizontal concatenate the entire stack
        % Implicit end of for loop and implicit display

Japt , 10 bytes

®m"uv"gMq2

Pruébalo en línea!

Explicación

Este es un truco cursi, pero funciona. En JavaScript puedes hacer algo como

x[`to${Math.random()<.5?"Upp":"Low"}erCase`]()

convertir aleatoriamente xa mayúsculas o minúsculas. En Japt, las funciones equivalentes son upara toUpperCasey vpara toLowerCase. Pero en Japt no hay una forma directa de obtener un valor de propiedad calculado (x[expression] en JavaScript).

Una de mis características favoritas de Japt es que si tiene una función que se compone de una sola llamada a un método (por ejemplo mX{Xq}, o .m(X=>X.q())en JS), puede omitir todo excepto el nombre del método, por ejemplo mq. El compilador luego convierte esto en una cadena que se pasa al método original llamado ( .m("q")), y el método vuelve a convertir esto en una función. Entonces no hay diferencia entre mqy m"q"; ambos producen la misma salida.

Ahora, a dónde iba con esto: si bien no podemos llamar directamente a un método aleatorio en una cuerda, que podemos llamar mde esa cadena con un nombre de método aleatorio. Entonces, para la explicación:

®m"uv"gMq2
®           // Replace each char in the input by this function:
 m          //   Replace each char in this char by this function:
      g     //     the char at index
       Mq2  //       random integer in [0,2)
  "uv"      //     in "uv".
            //   This randomly calls either .u() or .v() on the char.
            // Implicit: output result of last expression

PHP, 53 bytes

for(;a&$c=$argn[$i++];)echo(lu[rand()&1].cfirst)($c);

Perl 5 , 26 bytes

25 bytes + -pbandera.

s/./rand 2&1?uc$&:lc$&/ge

Pruébalo en línea!

Perl 6 ,  32  29 bytes

{[~] .comb.map:{(.lc,.uc).pick}}

Intentalo

{S:g/./{($/.uc,$/.lc).pick}/}

Intentalo

Python 2 , 77 74 bytes

lambda s:"".join(map(choice,zip(s.upper(),s.lower())))
from random import*

Pruébalo en línea!

Japt , 12 10 bytes

£M¬?Xv :Xu

Explicación:

£M¬?Xv :Xu
£             // Iterate through the input. X becomes the iterative item
 M¬           // Return a random number, 0 or 1
    ?         // If 1:
     Xv       //   X becomes lowercase
        :     // Else:
         Xu   //   X becomes uppercase 

Pruébalo en línea!

05AB1E , 8 bytes

vyDš‚.RJ

Pruébalo en línea!

Explicación

v          # for each char y in input
 yDš‚      # pair lower-case y with upper-case y
     .R    # pick one at random
       J   # join to string

JavaScript, 77 bytes

x=>x.toLowerCase().split``.map(y=>Math.random()*2|0?y:y.toUpperCase()).join``

Pruébalo en línea!

CJam , 14 bytes

qel{2mr{eu}&}%

Pruébalo en línea!

Explicación

q               e# Read the input
 el             e# Make it lowercase
   {            e# For each character in it
    2mr         e#  Randomly choose 0 or 1
       {eu}&    e#  If 1, make the character uppercase
            }%  e# (end of block)

MATL , 12 11 bytes

1 byte eliminado usando la idea de Jonathan Allan de cambiar directamente el caso.

"@rEk?Yo]&h

Probar en MATL en línea!

Explicación

"         % Implicit input. For each
  @       %   Push current char
  r       %   Random number uniformly distributed on (0,1)
  Ek      %   Duplicate, floor: gives 0 or 1 with the same probability
  ?       %   If nonzero
    Yo    %     Change case. Leaves non-letters unaffected
  ]       %   End
  &h      %   Horizontally concatenate evverything so far
          % Implicit end and display

Pyth, 5 bytes

srLO2

Banco de pruebas

srLO2
srLO2Q    Variable introduction
  L  Q    Map over the input
 r        Set the case of each character to 
   O2     Random number from [0, 1]. 0 means lowercase, 1 means uppercase.
s         Concatenate

Befunge , 136 bytes

>~:0`!#@_:"@"`!#v_:"Z"`!#v_:"`"`!#v_:"z"`!#v_,
^,<    <        <                 <
 >?<                     <             -*84<
  >84*+^

Pruébalo en línea!

Hay muchos espacios en blanco de los que creo que es posible deshacerse. Befunge no tiene una manera de averiguar qué es una carta y qué no, así que esto es lo que estoy haciendo en la primera fila.

Golpetazo , 64 bytes

primer intento

a=$(shuf -e -n 13 {A..Z}|tr -d "\n");b=${a,,};tr $b $a <<<${1,,}

Pruébalo en línea!

baraja mayúsculas, toma los primeros 13, elimina las nuevas líneas y se guarda en $ a. $ b contiene $ a en minúsculas. La entrada se establece en minúsculas por $ {1 ,,} y se pasa como heredoc a tr, que reemplaza cada aparición de $ b por $ a

Esto no es competitivo porque la misma letra siempre está en mayúscula.

JavaScript + HTML, 115 bytes

<input oninput="this.value=this.value.toLowerCase().split('').map(v=>Math.random()<.5?v.toUpperCase():v).join('')">

Bash, 162 bytes

a=$1
b=1
c="echo $a|head -c$b|tail -c1"
while(($b<=${#a}))
do
r=$[RANDOM%2]
if [ $r = 1 ]
then d=$(eval $c);echo -n ${d^}
else echo -n $(eval $c)
fi
b=$[b+1]
done

Bastante autoexplicativo. Toma información de la línea de comando arg, escribe en stdout.

Corre como derpifier.sh "Derp this"

Hombre, una vez que empiezo a aplicar los consejos, el código se reduce rápidamente.

Swift: demasiados bytes ( 176 167)

uppercased(),lowercased() , arc4random_uniform()Realmente matar a la puntuación, además de para mí tener que agregar una función ya que Swift no tiene un método de entrada estándar!

import Foundation
func g(x:String){var result="";for i in x.characters{let e=String(i);result+=(arc4random_uniform(2)>0 ?e.uppercased():e.lowercased())};print(result)}

Función con uso: print(g(x: "Your String Here"))