La tâche

Votre tâche consiste à créer un programme ou une fonction qui, à l'aide d'une entrée, génère le texte d'entrée avec des lettres aléatoires en majuscules, tout en conservant les majuscules des lettres déjà en majuscules.

Chaque combinaison de majuscules des minuscules devrait être possible. Par exemple, si l'entrée était abc, il devrait y avoir une probabilité non nulle de sortie l' une des combinaisons suivantes: abc, Abc, aBc, abC, ABc, AbC, aBCou ABC.

Contribution

Votre entrée est une chaîne, contenant un nombre quelconque de caractères ASCII imprimables, par exemple Hello World. Les sorties pour cette entrée comprennent HeLLo WoRlD, HElLO WOrldetc.

Notation

C'est du code-golf, alors la réponse la plus courte dans chaque langue gagne!

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

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

Prend les entrées Ans, comme illustré dans la capture d'écran ci-dessous:

(Si la capture d'écran semble brouillée, comme c'est parfois le cas pour moi, essayez de l' ouvrir dans un nouvel onglet ?)

TI-Basic (au moins la version TI-83 ... je devrais peut-être me lancer dans le golf TI-89) est un langage terrible pour essayer de relever ce défi, car:

1. Il ne fournit absolument aucun support pour aucune arithmétique avec des caractères, connaissant la version majuscule d'un caractère minuscule, ou même connaissant l'alphabet.
2. Chaque caractère en minuscule prend 2 octets à stocker. (En fait, je devais utiliser un script d'assemblage uniquement pour pouvoir taper les lettres minuscules.)

Le résultat est que 78 octets de ce programme (plus de la moitié) ne font que stocker l'alphabet, deux fois .

Quoi qu’il en soit, l’idée est que nous parcourions la chaîne en boucle, avec la possibilité de transformer les caractères minuscules en majuscules au fur et à mesure, et d’ajouter le résultat à la fin de la chaîne de manière à ce que l’entrée et la sortie soient stockées Ans. Lorsque nous quittons la For(boucle, Ila longueur est supérieure de un à la longueur de la chaîne d'origine. Par conséquent, le fait de I-1commencer par les caractères commençant par un Idonne la sortie.

Japt , 6 octets

®m`«`ö

Testez-le en ligne!

Explication

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

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

Essayez-le en ligne!

C,  47  46 octets

Merci à @ l4m2 d'avoir économisé un octet!

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

Essayez-le en ligne!

Serait 42 octets, si on pouvait supposer que {|}~cela n'apparaît pas dans l'entrée:

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

Essayez-le en ligne!

Gelée , 5 octets

Un autre octroie la poussière grâce à Dylnan.

żŒuX€

Essayez-le en ligne!

Explication

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

22 octets code + 1 pour -p.

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

Essayez-le en ligne!

JavaScript (ES6), 56 octets

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

Si le caractère aléatoire uniforme n'est pas requis, nous pouvons économiser 6 octets en utilisant l'heure actuelle comme source du caractère aléatoire:

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

Cela a tendance à être majuscule ou à laisser toutes les lettres en même temps.

R , 66 octets

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

Essayez-le en ligne!

Une autre réponse R.

Excel VBA, _{74 71} 64 octets

L’ Randomizeappel rend toujours la sortie aléatoire coûteuse en VBA :(

Fonction de fenêtre immédiate VBE anonyme qui prend les entrées de la plage [A1]et les envoie à la fenêtre immédiate VBE. Produit une UCasesortie de 50% (en moyenne) d.

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

Charbon de bois , 8 7 octets

⭆Ｓ‽⁺↥ιι

Essayez-le en ligne! Le lien est vers la version verbeuse du code. Explication:

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

Ruby, 40 octets

Fonction lambda qui prend une chaîne. Enregistré 1 octet grâce à Arnauld. 5 octets sauvés grâce à Snack.

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

APL + WIN, 37 octets

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

Invite à la saisie à l'écran, identifie les minuscules et les convertit de manière aléatoire en majuscules.

R , 89 88 octets

déjoué par djhurio!

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

Essayez-le en ligne!

Ce programme prend chaque caractère et avec une probabilité de 1/2 le convertit en majuscule ou le laisse tranquille. Il est possible de modifier cette probabilité en jouant avec différentes valeurs de dfet 0.

rts'inspire de la distribution t de Student, qui a la médiane 0 avec un degré de liberté quelconque (j'ai sélectionné 1car c'est le plus petit nombre possible).

05AB1E , 6 5 octets

Merci Adnan pour -1 octet

uø€ΩJ

Essayez-le en ligne!

Explication

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éthode extraite de la réponse de @ totallyhuman

Ruby, 39 octets

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

Largement inspiré de la réponse de displayname . (Je ne peux pas commenter pour suggérer cette version d'un octet en moins par manque de réputation, désolé displayname )

Swift 4, 86 octets

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

Java 8, 46 octets

Ce lambda est de IntStreamà IntStream(flux de points de code).

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

Essayez-le en ligne

Répartition de la capitalisation

Le fait de capitaliser une lettre était autrefois la condition la plus raisonnable Math.random()<.5, qui était satisfaite environ la moitié du temps. Avec la condition actuelle de Math.random()>0(qui enregistre un octet), la capitalisation se produit pratiquement à chaque fois, ce qui rend un programme de test inutile. Mais cela répond à l'exigence de caractère aléatoire.

Remerciements

• -1 octet grâce à Olivier Grégoire

Funky , 55 octets

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

Essayez-le en ligne!

Grâce aux virgules facultatives, 0s.upperla définition de la table nécessite un octet plus court , ce qui signifie que la personne math.randomchoisira aléatoirement l'un 1ou l' autre 2, que de la faire math.random(0,1)dans une liste aléatoire et de ne pas avoir le 0.

R , 60 59 58 57 56 63 octets

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

Essayez-le en ligne!

Approche différente des deux autres réponses R ici et ici . Amélioré et corrigé grâce à Giuseppe!

Ouroboros , 25 octets

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

Essayez-le ici

La seule partie de fantaisie est le flux de contrôle, .b*) . Parlons du reste d'abord.

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

Nous revenons ensuite au début de la ligne. Le contrôle du flux implique de changer l'endroit où se trouve la fin de la ligne; s'il est déplacé à gauche de l'IP, l'exécution se termine. Ainsi:

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

Lorsque le code de caractère est positif, )c'est un non-op, car la fin de la ligne est la plus à droite possible. Mais quand tous les personnages ont été lus, idonne -1. Ensuite, nous déplaçons la fin des caractères du code -11vers la droite, c’est-à-dire 11 caractères vers la gauche. Il faut plusieurs itérations, mais l’IP finit par se trouver au-delà de la fin du code et le programme s’arrête.

MATL , 12 à 11 octets

"@rEk?Xk]v!

Essayez-le en ligne!

Enregistré 1 octet grâce à @LuisMendo

Brachylog , 5 octets

ụᶻṛᵐc

Essayez-le en ligne!

Explication

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 octets

Merci à Leo pour la sauvegarde de 2 octets.

/uRUwk
\i*&o.@/

Essayez-le en ligne!

Explication

/...
\...@/

C'est le cadre habituel pour les programmes largement linéaires fonctionnant entièrement en mode 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.

J'ai d'abord essayé de le faire entièrement en mode Cardinal, mais déterminer si quelque chose était une lettre simplement basée sur un code de caractère prendrait probablement plus d'octets.

Wolfram Language (Mathematica) , 52 49 44 octets

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

Essayez-le en ligne!

Utilise le formulaire opérateur de StringReplace : en lui fournissant une règle (ou une liste de règles) mais aucune chaîne ne donne une fonction qui applique cette règle à toute chaîne que vous lui donnez en entrée.

Nous pourrions faire beaucoup mieux ( RandomChoice@{#,Capitalize@#}&/@#&c'est-à-dire 34 octets) si nous décidions de prendre en entrée (et de produire en sortie) une liste de caractères, ce qui est parfois considéré comme acceptable par Mathematica, car il s'agit du seul type de chaîne existant dans d'autres langues. Mais ce n'est pas amusant.

-5 octets grâce à M. Stern

Pyth, 10 7 6 octets

smO,r1

3 octets sauvés grâce aux ovs et 1 grâce à Steven H.

Essayez-le en ligne

Explication

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 octets

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

Géré pour réduire le code avec 10 octets de (partiellement) suivant la suggestion de Titus.

PowerShell , 57 56 octets

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

Essayez-le en ligne!

-1 octet grâce au briantist

Prend l'entrée en tant que chaîne, convertit explicitement le $argstableau en chaîne, le charconvertit en tant que -array, puis insère les caractères dans une boucle. A chaque itération, nous produisons le caractère tel $_quel ou le convertissons en majuscules "$_".ToUpper()(c'est la ("$_"|% *per)corbeille). C'est choisi en obtenant un Randomentier et en le prenant mod 2.

Ces caractères sont laissés sur le pipeline, puis -joinredirigés ensemble dans une chaîne unique, elle-même laissée sur le pipeline et la sortie est implicite.

Julia , 35 octets

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

Essayez-le en ligne!

Toujours assez facile à lire en tant qu'être humain. Dans Julia rand (A) renvoie un élément aléatoire de A.

Rebol , 61 bytes

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

Tester:

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

Gelée , 16 octets

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

Essayez-le en ligne!

Explication

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)

Je ne pouvais pas faire fonctionner cela en une seule ligne. Je ne sais pas non plus pourquoi, mais 2ḶXø³L¤Ð¡donne la liste [None,1,0,..,1]avec 0s et 1s choisis au hasard. Le Noneest la raison de la Ḋdans le premier lien.