Die Aufgabe

Ihre Aufgabe ist es, ein Programm oder eine Funktion zu erstellen, die bei einer Eingabe den eingegebenen Text in zufälligen Großbuchstaben ausgibt, während bereits großgeschriebene Buchstaben großgeschrieben bleiben.

Jede Kombination von Groß- und Kleinschreibung sollte möglich sein. Zum Beispiel, wenn der Eingang ist abc, soll es eine Nicht-Null - Wahrscheinlichkeit eine der folgenden Kombinationen sein ausgibt: abc, Abc, aBc, abC, ABc, AbC, aBCoder ABC.

Eingang

Ihre Eingabe ist eine Zeichenfolge, die beispielsweise eine beliebige Anzahl druckbarer ASCII-Zeichen enthält Hello World. Die Ausgänge für diesen Eingang umfassen HeLLo WoRlD, HElLO WOrldusw.

Wertung

Das ist Code-Golf, also gewinnt die kürzeste Antwort in jeder Sprache!

TI-Basic (Serie 83), 137 Byte

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

Nimmt Eingaben auf Ans, wie im folgenden Screenshot dargestellt:

(Wenn der Screenshot verschlüsselt aussieht, wie es manchmal bei mir der Fall ist, versuchen Sie, ihn in einem neuen Tab zu öffnen ?)

TI-Basic (zumindest die TI-83-Version ... vielleicht sollte ich mich dem Golfsport mit TI-89 widmen) ist eine schreckliche Sprache, um diese Herausforderung zu meistern, da:

1. Es bietet keinerlei Unterstützung für Arithmetik mit Zeichen, wenn Sie die Großbuchstaben eines Kleinbuchstaben oder sogar das Alphabet kennen.
2. Jeder einzelne Kleinbuchstabe benötigt 2 Bytes zum Speichern. (Eigentlich musste ich ein Assembler-Skript verwenden , um die Kleinbuchstaben eingeben zu können.)

Das Ergebnis ist, dass 78 Bytes dieses Programms (mehr als die Hälfte) das Alphabet nur zweimal speichern .

Die Idee ist jedenfalls, dass wir die Zeichenfolge durchlaufen und dabei die Möglichkeit haben, Kleinbuchstaben in Großbuchstaben umzuwandeln und das Ergebnis an das Ende der Zeichenfolge anzufügen, sodass sowohl die Eingabe als auch die Ausgabe in gespeichert werden Ans. Wenn wir die For(Schleife verlassen , Iist eins mehr als die Länge der ursprünglichen Zeichenfolge. Wenn Sie also die I-1Zeichen ab verwenden, erhalten Sie Idie Ausgabe.

Japt , 6 Bytes

®m`«`ö

Online testen!

Erläuterung

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

Probieren Sie es online!

C  47  46 Bytes

Vielen Dank an @ l4m2 für das Speichern eines Bytes!

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

Probieren Sie es online!

Wäre 42 Bytes, wenn davon ausgegangen werden könnte, dass {|}~nicht in der Eingabe erscheint:

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

Probieren Sie es online!

Gelee , 5 Bytes

Ein weiterer bytes den Staub dank Dylnan.

żŒuX€

Probieren Sie es online!

Erläuterung

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

22 Byte Code + 1 für -p.

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

Probieren Sie es online!

JavaScript (ES6), 56 Byte

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

Wenn keine einheitliche Zufälligkeit erforderlich ist, können wir 6 Bytes einsparen, indem wir die aktuelle Zeit als Quelle für die Zufälligkeit verwenden:

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

Dies neigt dazu, entweder in Großbuchstaben zu schreiben oder alle Buchstaben auf einmal in Ruhe zu lassen.

R , 66 Bytes

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

Probieren Sie es online!

Noch eine R- Antwort.

Excel VBA, _{74 71} 64 Bytes

Der RandomizeAufruf verteuert immer die Zufallsausgabe in VBA :(

Anonyme VBE-Direktfensterfunktion, die Eingaben aus dem Bereich [A1]und Ausgaben in das VBE-Direktfenster übernimmt . Erzeugt eine UCaseAusgabe von durchschnittlich 50% d.

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

Kohle , 8 7 Bytes

⭆Ｓ‽⁺↥ιι

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Erläuterung:

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

Rubin, 40 Bytes

Lambda-Funktion, die eine Zeichenfolge nimmt. 1 Byte dank Arnauld gespeichert. 5 Bytes gespart dank 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⍳⎕]

Fordert zur Eingabe auf dem Bildschirm auf, identifiziert Kleinbuchstaben und konvertiert sie nach dem Zufallsprinzip in Großbuchstaben.

R , 89 88 Bytes

von djhurio überrumpelt!

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

Probieren Sie es online!

Dieses Programm nimmt jedes Zeichen und wandelt es mit der Wahrscheinlichkeit 1/2 in Großbuchstaben um oder lässt es in Ruhe. Es ist möglich, diese Wahrscheinlichkeit zu optimieren, indem Sie mit verschiedenen Werten von dfund spielen 0.

rtZeichnet sich aus der t-Verteilung des Schülers, die den Median 0 mit einem beliebigen Freiheitsgrad hat (ich habe sie ausgewählt, 1da sie die kleinstmögliche Zahl ist).

05AB1E , 6 5 Bytes

Vielen Dank, dass Sie Adnan für -1 Byte

uø€ΩJ

Probieren Sie es online!

Erläuterung

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

Methode aus der Antwort von @ totallyhuman

Ruby, 39 Bytes

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

Weitgehend inspiriert von der Antwort des Anzeigenamens . (Ich konnte keinen Kommentar abgeben , um diese One-Byte-weniger-Version wegen mangelnder Reputation vorzuschlagen. Entschuldigung, Anzeigename. )

Schnelle 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

Dieses Lambda ist von IntStreambis IntStream(Ströme von Codepunkten).

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

Probieren Sie es online

Kapitalisierungsverteilung

Ob ein Brief groß geschrieben werden sollte, war die durchaus vernünftige Bedingung Math.random()<.5, die etwa zur Hälfte erfüllt war. Bei dem aktuellen Zustand von Math.random()>0(der ein Byte spart) erfolgt die Großschreibung praktisch jedes Mal, was ein Testprogramm irgendwie sinnlos macht. Aber es erfüllt die Zufallsanforderung.

Danksagung

• -1 Byte danke an Olivier Grégoire

Funky , 55 Bytes

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

Probieren Sie es online!

Dank optionaler Kommas ist es 0s.upperin der Tabellendefinition ein Byte kürzer , was bedeutet, dass der math.randomBenutzer nach dem Zufallsprinzip entweder 1oder auswählt 2als nach math.random(0,1)dem Zufallsprinzip und nicht das hat 0.

R , 60 59 58 57 56 63 Bytes

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

Probieren Sie es online!

Unterschiedlicher Ansatz zu den beiden anderen R-Antworten hier und hier . Verbessert und behoben dank Giuseppe!

Ouroboros , 25 Bytes

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

Probieren Sie es hier aus

Das einzig ausgefallene Teil ist der Kontrollfluss .b*). Lassen Sie uns zuerst über den Rest sprechen.

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

Wir kehren dann zum Zeilenanfang zurück. Der Kontrollfluss beinhaltet das Ändern der Position am Ende der Linie. Wenn es nach links von der IP verschoben wird, wird die Ausführung abgebrochen. Somit:

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

Wenn der Zeichencode positiv ist, )ist dies ein No-Op, da das Ende der Zeile so weit wie möglich rechts liegt. Aber wenn alle Zeichen gelesen wurden, igibt -1. Dann verschieben wir das Ende der Codezeichen -11nach rechts, dh 11 Zeichen nach links. Es dauert einige Iterationen, aber irgendwann ist die IP hinter dem Ende des Codes und das Programm wird angehalten.

MATL , 12 11 Bytes

"@rEk?Xk]v!

Probieren Sie es online!

1 Byte dank @LuisMendo gespeichert

Brachylog , 5 Bytes

ụᶻṛᵐc

Probieren Sie es online!

Erläuterung

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

Danke an Leo für das Speichern von 2 Bytes.

/uRUwk
\i*&o.@/

Probieren Sie es online!

Erläuterung

/...
\...@/

Dies ist der übliche Rahmen für weitgehend lineare Programme, die vollständig im Ordinalmodus arbeiten.

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.

Ich habe zuerst versucht, dies vollständig im Kardinal-Modus zu tun, aber um festzustellen, ob es sich bei einem Buchstaben nur um einen Zeichencode handelt, werden wahrscheinlich mehr Bytes benötigt.

Wolfram Language (Mathematica) , 52 49 44 Bytes

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

Probieren Sie es online!

Verwendet die Operatorform StringReplace: Bereitstellen einer Regel (oder einer Liste von Regeln), aber keine Zeichenfolge gibt eine Funktion an, die diese Regel auf jede Zeichenfolge anwendet, die Sie als Eingabe angeben.

Wir könnten es viel besser machen ( RandomChoice@{#,Capitalize@#}&/@#&ist 34 Bytes), wenn wir uns dazu entschließen, eine Liste von Zeichen als Eingabe zu nehmen (und als Ausgabe zu erzeugen), von denen die Leute manchmal behaupten, dass sie in Mathematica in Ordnung ist, weil es die einzige Art von Zeichenkette in anderen Sprachen gibt. Aber das macht keinen Spaß.

-5 Bytes dank M. Stern

Pyth, 10 7 6 Bytes

smO,r1

3 Bytes dank ovs und 1 dank Steven H. gespart

Probieren Sie es online aus

Erläuterung

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;

Es ist gelungen, den Code um 10 Bytes zu reduzieren, indem (teilweise) Titus 'Vorschlag gefolgt wurde.

PowerShell , 57 56 Bytes

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

Probieren Sie es online!

-1 Byte dank Briantist

Nimmt Eingaben als Zeichenfolge an, wandelt das $argsArray explizit in eine Zeichenfolge um, charwandelt es als -array um und führt die Zeichen dann durch eine Schleife. Bei jeder Iteration geben wir das Zeichen 50-50 entweder so aus, wie es ist, $_oder konvertieren es in Großbuchstaben "$_".ToUpper()(das ist der ("$_"|% *per)Müll). Das wird gewählt, indem man eine Randomganze Zahl erhält und sie modifiziert 2.

Diese Zeichen verbleiben in der Pipeline und werden dann -joinzu einer einzelnen Zeichenfolge zusammengefasst, die in der Pipeline verbleibt und deren Ausgabe implizit erfolgt.

Julia , 35 Bytes

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

Probieren Sie es online!

Als Mensch noch recht einfach zu lesen. In Julia rand (A) gibt A ein zufälliges Element zurück.

Rebol , 61 Bytes

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

Prüfung:

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

Gelee , 16 Bytes

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

Probieren Sie es online!

Erläuterung

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)

Ich konnte das nicht in einer einzigen Zeile zum Laufen bringen. Ich weiß auch nicht warum, aber 2ḶXø³L¤Ð¡gibt die Liste [None,1,0,..,1]mit 0s und 1s zufällig ausgewählt. Das Noneist der Grund für den Ḋim ersten Link.