37

काम

आपका कार्य एक प्रोग्राम या फ़ंक्शन बनाना है, जो एक इनपुट दिया गया है, पहले से ही बड़े अक्षरों को बड़े अक्षरों में रखते हुए, यादृच्छिक पाठ के साथ इनपुट टेक्स्ट को आउटपुट करता है।

लोअरकेस अक्षरों के पूंजीकरण का हर संयोजन संभव होना चाहिए। उदाहरण के लिए, यदि इनपुट था abc, वहाँ निम्नलिखित संयोजनों में से किसी outputting के एक गैर शून्य संभावना होना चाहिए: abc, Abc, aBc, abC, ABc, AbC, aBCया ABC।

इनपुट

आपका इनपुट एक स्ट्रिंग है, जिसमें मुद्रण योग्य ASCII वर्णों की संख्या होती है, उदाहरण के लिए Hello World। कि इनपुट के लिए आउटपुट शामिल हैं HeLLo WoRlD, HElLO WOrldआदि

स्कोरिंग

यह कोड-गोल्फ है, इसलिए प्रत्येक भाषा में सबसे कम उत्तर जीतता है!

code-golf string random

— Brecert
स्रोत

14

टीआई-बेसिक (83 श्रृंखला), 137 बाइट्स

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

Ansनीचे दिए गए स्क्रीनशॉट में दिखाए अनुसार इनपुट लेता है :

(यदि स्क्रीनशॉट को तराशा हुआ दिखता है, जैसा कि कभी-कभी मेरे लिए होता है, तो इसे एक नए टैब में खोलने का प्रयास करें ?)

टीआई-बेसिक (कम से कम टीआई -83 संस्करण ... शायद मुझे टीआई -89 गोल्फिंग में बाहर शाखा करनी चाहिए) इस चुनौती को गोल्फ में करने की कोशिश करने के लिए एक भयानक भाषा है, क्योंकि:

यह वर्णों के साथ किसी भी अंकगणित के लिए बिल्कुल समर्थन प्रदान नहीं करता है, किसी लोअरकेस वर्ण के अपरकेस संस्करण को जानना या वर्णमाला को जानना भी।
हर एक लोअरकेस वर्ण को स्टोर करने के लिए 2 बाइट्स लगते हैं। (वास्तव में, मुझे केवल निचले अक्षरों को टाइप करने में सक्षम होने के लिए एक विधानसभा स्क्रिप्ट का उपयोग करना पड़ा ।)

परिणाम यह है कि इस कार्यक्रम के 78 बाइट्स (आधे से अधिक) केवल दो बार वर्णमाला का भंडारण कर रहे हैं ।

वैसे भी, विचार यह है कि हम स्ट्रिंग के माध्यम से लूप करते हैं, जैसे कि हम ऊपर जाते हुए लोअरकेस वर्णों को मोड़ते हैं, और स्ट्रिंग के अंत में परिणाम जोड़ते हैं ताकि इनपुट और आउटपुट दोनों जमा हो जाएं Ans। जब हम For(लूप छोड़ते हैं I, तो मूल स्ट्रिंग की लंबाई से एक अधिक होती है, इसलिए I-1शुरू होने वाले पात्रों को लेने Iसे आउटपुट मिलता है।

— मिशा लावरोव
स्रोत

"मिराजोस" और "ओमनीसेल" दोनों ऐप आपको केवल दो बार अल्फा दबाकर लोअरकेस अक्षर टाइप करने की अनुमति देते हैं। और उनके पास अन्य अच्छी विशेषताएं भी हैं।

— फाबियान रोलिंग

@ फैबियन असेंबली स्क्रिप्ट, और आपके द्वारा उल्लिखित ऐप, दोनों अनिवार्य रूप से उसी तरह काम करते हैं: वे ऑपरेटिंग सिस्टम में एक झंडा सेट करते हैं जो "लोअरकेस के लिए अल्फा को दो बार दबाएं" सक्षम करता है।

— मिशा लावरोव

11

जाप , 6 बाइट्स

®m`«`ö

इसे ऑनलाइन टेस्ट करें!

व्याख्या

®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
स्रोत

11

पायथन 2 , 66 65 बाइट्स

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

इसे ऑनलाइन आज़माएं!

— notjagan
स्रोत

10

सी, 47 46 बाइट्स

एक बाइट को बचाने के लिए @ l4m2 के लिए धन्यवाद!

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

इसे ऑनलाइन आज़माएं!

42 बाइट्स होंगे, यदि यह माना जा सकता है कि {|}~इनपुट में दिखाई नहीं देता है:

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

इसे ऑनलाइन आज़माएं!

— Steadybox
स्रोत

इस बात पर ध्यान देने के कि, किसी विशेष कार्यान्वयन को देखते हुए, कैपिटलाइज़ेशन पूरी तरह से नियतात्मक है (सी मानक srand(1)कार्यक्रम की शुरुआत में एक निहितार्थ प्रदान करता है , इसलिए प्रत्येक निष्पादन में मूल्यों द्वारा rand()दिए गए अनुक्रम का क्रम समान होगा)।

— मट्टियो इतालिया

f(char*s){for(;*s++-=(*s-'a'<26&rand())*32;);}कुछ संकलक (डीईएफ -funsigned-char) काम के लिए

— l4m2

@ l4m2 धन्यवाद! यह किसी कारण के लिए काम नहीं करता है। बदलने 'a'के लिए 97uकाम करता है और यहां तक कि आवश्यकता नहीं है -funsigned-charझंडा।

— Steadybox

ऐसा लगता है कि जब आप घटाना 'a'(जो signed int, नहीं unsigned charसे) *s(जो unsigned char), *sके लिए प्रोत्साहित किया जाता है signed intके बजाय unsigned int, इसलिए ऋणात्मक मानों संभव किया जा रहा है और के रूप में इरादा तुलना काम नहीं कर रहा।

— स्टेडीबॉक्स

8

जेली , 5 बाइट्स

एक और एक धूल dylnan के लिए धन्यवाद बाइट्स।

żŒuX€

इसे ऑनलाइन आज़माएं!

व्याख्या

żŒuX€  main link: s = "Hello world"

żŒu    zip s with s uppercased  ["HH", "eE", "lL", "lL", "oO", "  ", ...]
   X€  map random choice        "HeLLo woRlD"

— totallyhuman
स्रोत

1

मुझे ŒṘयह देखने के लिए अधिक बार उपयोग करने की आवश्यकता है कि कैसे चीजों को हुड के नीचे

— दर्शाया

7

पर्ल 5 , 23 बाइट्स

22 बाइट्स कोड + 1 के लिए -p।

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

इसे ऑनलाइन आज़माएं!

— डोम हेस्टिंग्स
स्रोत

7

जावास्क्रिप्ट (ईएस 6), 56 बाइट्स

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

यदि एकरूप यादृच्छिकता की आवश्यकता नहीं है, तो हम यादृच्छिकता के स्रोत के रूप में वर्तमान समय का उपयोग करके 6 बाइट बचा सकते हैं:

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

यह या तो अपरकेस के लिए जाता है या एक ही बार में सभी अक्षरों को छोड़ देता है।

— ETHproductions
स्रोत

"एबीसी, एबीसी, एबीसी, एबीसी, एबीसी, एबीसी या एबीसी: निम्न में से किसी भी संयोजन को आउटपुट करने की एक गैर-शून्य संभावना होनी चाहिए", जबकि आपका उत्पादन नहीं हो सकता AbCक्योंकि समय इतनी तेजी से नहीं बदलेगा

— l4m2

@ l4m2 अगर आपके पास वास्तव में धीमी मशीन है, तो हो सकता है; ;-) शायद मुझे बस उस हिस्से को हटा देना चाहिए ...

— ETHproductions 28'18

6

आर , 66 बाइट्स

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

इसे ऑनलाइन आज़माएं!

एक और आर जवाब।

— djhurio
स्रोत

मैं बहुत अधिक "नियमित" आर कोड लिख रहा हूं और for-लूप की कोशिश करने के लिए भी नहीं सोचा था ! अच्छा है।

— Giuseppe

6

एक्सेल VBA, _{74 71} 64 बाइट्स

~~Randomizeकॉल हमेशा यादृच्छिक उत्पादन VBA में महंगा बना देता है :(~~

बेनामी VBE तत्काल विंडो फ़ंक्शन जो रेंज से इनपुट लेता है [A1]और VBE तत्काल विंडो में आउटपुट करता है। 50% (औसतन) UCaseडी आउटपुट का उत्पादन करता है।

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

— टेलर स्कॉट
स्रोत

प्रणाम सर। आप को हटाने के द्वारा 2 बाइट्स बचा सकता है Randomize:और बदल रहा है Rndके साथ [RAND()>.5]। या बस इसे अनदेखा करें। :)

— रेमोएल

@remoel, दुर्भाग्य से, [Rand()]कॉल केवल psuedo-random है और इसकी अवधि लगभग 10 ^ 13 है, जो इसे कार्यात्मक रूप से Randomized d Rndकॉल के समान बनाता है , वास्तव में दोनों एक ही बीज का उपयोग करते हैं (जो फ़ंक्शन का उपयोग करके Randomizeकॉल सेटtimer करता है) उत्पादन)।

— टेलर स्कॉट

@romoel, लेकिन मुझे लगता है कि मैं शीघ्रता से स्पष्टीकरण दे सकता हूं कि मैं Randomizeकॉल को हटा सकता हूं और इसके बजाय उपयोग कर सकता हूंRnd>.5

— टेलर स्कॉट

6

चारकोल , 8 7 बाइट्स

⭆Ｓ‽⁺↥ιι

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। स्पष्टीकरण:

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

— नील
स्रोत

4

रूबी, 40 बाइट्स

लैम्ब्डा फ़ंक्शन जो एक स्ट्रिंग लेता है। 1 बाइट अरनौल्ड की बदौलत बचा। स्नैक के लिए 5 बाइट्स सहेजे गए।

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

— प्रदर्शित होने वाला नाम
स्रोत

1

PPCG में आपका स्वागत है! आप के <1बजाय के साथ एक बाइट बचा सकता है ==1?

— अरनौलद

1

40 बाइट्स

— स्नैक

अच्छा काम @displayname। FWIW जब उपयोगकर्ता अपने स्कोर में सुधार करते हैं, तो कई <s>टैग के साथ पुराने स्कोर को "क्रॉस आउट" करना पसंद करते हैं , जैसे " रूबी, <s> 46 </ s> 40 बाइट्स ।" बेशक इसकी आवश्यकता नहीं है।

— जॉर्डन

3

एपीएल + विन, 37 बाइट्स

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

स्क्रीन इनपुट के लिए संकेत, निचले मामले के अक्षरों की पहचान करता है और अनियमित रूप से ऊपरी मामले में परिवर्तित करता है।

— ग्राहम
स्रोत

3

आर , 89 88 बाइट्स

djhurio द्वारा बहिष्कृत!

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

इसे ऑनलाइन आज़माएं!

यह प्रोग्राम प्रत्येक वर्ण को लेता है, और प्रायिकता के साथ 1/2 इसे अपरकेस या अकेले छोड़ देता है। dfऔर के विभिन्न मूल्यों के साथ खेलकर इस संभावना को मोड़ना संभव है 0।

rtस्टूडेंट के टी-डिस्ट्रीब्यूशन से ड्रॉ होता है, जिसमें किसी भी डिग्री की स्वतंत्रता के साथ माध्य 0 होता है (मैंने चुना है 1क्योंकि यह सबसे छोटी संख्या संभव है)।

— ग्यूसेप
स्रोत

1

यह यादृच्छिक पर कुछ करने का एक बहुत ही आर तरीका है।

— मीशा लावरोव

1

66 बाइट्स कोडगॉल्फ.स्टैकएक्सचेंज.com

— 149518/

@djhurio यह शानदार है।

— ग्यूसेप

3

05AB1E , 6 5 बाइट्स

शुक्रिया अदनान -1 बाइट के लिए

uø€ΩJ

इसे ऑनलाइन आज़माएं!

व्याख्या

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

विधि पूरी तरह से @ अमानवीय उत्तर से ली गई है

— dylnan
स्रोत

1

क्या कोई कभी 6 को हरा पाएगा? : P

— ETHproductions

1

@ETHproductions यदि ऊपरी स्तर के लिए जेली के पास एक एकल बाइट ऑपरेटर होता है जैसे 05AB1E!

— dylnan

Ooo ... random_pick एह के लिए नया आदेश? ε„luΩ.Vमेरा प्रयास था, अच्छा!

— मैजिक ऑक्टोपस Urn

3

आप डुप्लिकेट को बाहर छोड़ सकते हैं :)

— अदनान

1

क्या कोई 5 को हराएगा? : पी

— बिलकुल अमानवीय

3

रूबी, 39 बाइट्स

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

बड़े पैमाने पर Displayname के जवाब से प्रेरित है । (मैं प्रतिष्ठा की कमी के लिए इस एक-बाइट-कम संस्करण का सुझाव देने के लिए टिप्पणी नहीं कर सकता, खेद प्रदर्शितनाम )

— जेरेमी बोनाल
स्रोत

3

PPCG में आपका स्वागत है!

— मार्टिन एंडर

मैं अभिवादन की उम्मीद नहीं कर रहा था, कितना अच्छा था! धन्यवाद!

— जेरेमी बोनाल

3

स्विफ्ट 4, 86 बाइट्स

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

— अउ रिस
स्रोत

3

PPCG में आपका स्वागत है!

— मार्टिन एंडर

3

जावा 8, 46 बाइट्स

यह लैम्ब्डा से है IntStreamकरने के लिए IntStream(कोड अंक की धाराओं)।

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

यह ऑनलाइन की कोशिश करो

पूंजीकरण वितरण

चाहे एक पत्र को भुनाने के लिए काफी समझदार स्थिति का उपयोग किया जाता Math.random()<.5था, जो कि आधे समय के बारे में संतुष्ट था। की मौजूदा स्थिति के साथ Math.random()>0(जो बाइट बचाता है), पूंजीकरण लगभग हर बार होता है, जो एक परीक्षण कार्यक्रम को व्यर्थ बनाता है। लेकिन यह यादृच्छिकता की आवश्यकता को पूरा करता है।

स्वीकृतियाँ

ओलिवियर ग्रेजायर के लिए -1 बाइट

— जेकब
स्रोत

यदि आप स्ट्रीम रूट पर जाते हैं, तो आप कोड पॉइंट्स का उपयोग कर सकते हैं और 41 बाइट्स कर सकते हैं ।

— ओलिवियर ग्रेजायर 12

यदि इनपुट ASCII वर्णों से ऊपर है तो ठीक है z। मैं इसे योग्यता के साथ फेंक सकता था।

— जेकब

1

6 और बाइट्स के लिए ठीक करें ।

— ओलिवियर ग्राएगेयर 16

3

फंकी , 55 बाइट्स

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

इसे ऑनलाइन आज़माएं!

वैकल्पिक अल्पविराम के लिए धन्यवाद, यह एक बाइट कम करने के लिए 0s.upperतालिका परिभाषा है, जिसका अर्थ में math.randomबेतरतीब ढंग से या तो ले जाएगा 1या 2की तुलना में ऐसा करने के लिए, math.random(0,1)यादृच्छिक में और नहीं 0।

— Ataco
स्रोत

3

आर , 60 59 58 57 56 63 बाइट्स

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

इसे ऑनलाइन आज़माएं!

अन्य दो आर उत्तर से अलग दृष्टिकोण यहाँ और यहाँ । Giuseppe के लिए बेहतर और निश्चित धन्यवाद!

— Jayce
स्रोत

मुझे नहीं पता था कि नमूने के कार्य इस तरह से व्यवहार करते हैं!

— ग्यूसेप

@Giuseppe जब मैंने सोचा कि यह नीचे नहीं हो सकता ...

— JayCe

57 बाइट्स

— Giuseppe

@Giuseppe न केवल यह गोल्फर है, बल्कि अधिक सुरुचिपूर्ण भी है! इसे प्यार करना!

— JayCe

दूसरे दृश्य में, जब यह ऊपर की 90तरह प्रिंट करने योग्य अस्की पात्रों पर काम नहीं करेगा [, लेकिन यह इसे +7 बाइट्स के लिए ठीक करता है जो अभी भी djhurio के जवाब की तुलना में गोल्फर है

— Giuseppe

2

ऑरोबोरोस , 25 बाइट्स

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

इसे यहाँ आज़माएँ

केवल फैंसी हिस्सा नियंत्रण प्रवाह है .b*),। पहले बाकी के बारे में बात करते हैं।

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

हम फिर लाइन की शुरुआत में वापस लूप करते हैं। नियंत्रण प्रवाह में परिवर्तन शामिल है जहां लाइन का अंत होता है; यदि इसे IP के बाईं ओर ले जाया जाता है, तो निष्पादन समाप्त हो जाता है। इस प्रकार:

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

जब चारकोड पॉजिटिव होता है, )तो नो-ऑप होता है, क्योंकि लाइन का अंत उतना ही सही होता है जितना कि यह जा सकता है। लेकिन जब सभी पात्रों को पढ़ा गया है, iदेता है -1। फिर हम कोड -11वर्णों के अंत को दाईं ओर - यानी 11 वर्णों को बाईं ओर ले जाते हैं। यह एक जोड़ी पुनरावृत्तियों लेता है, लेकिन अंततः आईपी कोड के अंत में पिछले है और कार्यक्रम को रोक देता है।

— DLosc
स्रोत

2

MATL , 12 11 बाइट्स

"@rEk?Xk]v!

इसे ऑनलाइन आज़माएं!

@LuisMendo को 1 बाइट धन्यवाद दिया

— Cinaski
स्रोत

2

ब्रेकीलॉग , 5 बाइट्स

ụᶻṛᵐc

इसे ऑनलाइन आज़माएं!

व्याख्या

Example input: "Test"

ụᶻ        Zip uppercase:      [["T","T"],["e","E"],["s","S"],["t","T"]]
  ṛᵐ      Map random element: ["T","e","S","T"]
    c     Concatenate:        "TeST"

— Fatalize
स्रोत

2

ऐलिस , 17 15 बाइट्स

2 बाइट बचाने के लिए लियो को धन्यवाद।

/uRUwk
\i*&o.@/

इसे ऑनलाइन आज़माएं!

व्याख्या

/...
\...@/

यह ऑर्डिनल मोड में पूरी तरह से संचालित होने वाले बड़े पैमाने पर रैखिक कार्यक्रमों के लिए सामान्य रूपरेखा है।

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.

मैंने पहली बार यह पूरी तरह से कार्डिनल मोड में करने की कोशिश की, लेकिन यह निर्धारित करना कि अगर कोई अक्षर सिर्फ वर्ण कोड पर आधारित है तो संभवतः अधिक बाइट्स लेगा।

— मार्टिन एंडर
स्रोत

2

वोल्फ्राम लैंग्वेज (गणितज्ञ) , 52 49 44 बाइट्स

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

इसे ऑनलाइन आज़माएं!

के ऑपरेटर रूप का उपयोग करता है StringReplace: इसे एक नियम (या नियमों की एक सूची) प्रदान करता है, लेकिन कोई स्ट्रिंग एक फ़ंक्शन नहीं देता है जो उस नियम को किसी भी स्ट्रिंग पर लागू करता है जिसे आप इनपुट के रूप में देते हैं।

RandomChoice@{#,Capitalize@#}&/@#&यदि हम इनपुट के रूप में लेने (और आउटपुट के रूप में उत्पादन करने) का वर्णन करते हैं, तो हम बहुत बेहतर कर सकते हैं ( पात्रों के रूप में उत्पादन), जो लोग कभी-कभी तर्क देते हैं कि मैथेमेटिका में ठीक है क्योंकि यह अन्य भाषाओं में एकमात्र प्रकार का स्ट्रिंग है। लेकिन यह कोई मजेदार बात नहीं है।

-5 बाइट्स एम स्टर्न के लिए धन्यवाद

— मिशा लावरोव
स्रोत

एक बाइट का उपयोग करके सहेजेंCapitalize

— एम। स्टर्न

आपको लगता है कि उपेक्षा करेंगे, तो Randomहटा दिया गया है आप अपने खुद के लागू करने से एक और चार बाइट्स बचा सकता है RandomChoice: StringReplace[c_/;Random[]<.5:>Capitalize@c],

— एम स्टर्न

@ M.Stern मैं Randomएक बिंदु पर काम करने की कोशिश कर रहा था , लेकिन मैं /;एक Ifबयान में डालने की कोशिश कर रहा था इसलिए मैं भूल गया । धन्यवाद!

— मिशा लावरोव

2

अजगर, 10 7 6 बाइट्स

smO,r1

3 बाइट्स ओव्स के लिए धन्यवाद और 1 स्टीवन एच के लिए धन्यवाद।

इसे ऑनलाइन आज़माएं

व्याख्या

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.

— स्मृति सहायक
स्रोत

r1d= rd1, आप एक और बाइट बाहर गोल्फ-इनपुट करने के लिए अनुमति देता है।

— स्टीवन एच।

2

पीएचपी, 63 53 बाइट्स

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

टाइटस के सुझाव के बाद (आंशिक रूप से) 10 बाइट्स के साथ कोड को कम करने का प्रबंधन।

— RFSnake
स्रोत

1

अच्छा है! पहले एक जगह की जरूरत नहीं $a। while(~$a=$argn[$i++])इसके बजाय प्रयास करें foreach(पाइप के रूप में चलाएँ)।

— टाइटस

उस कोड का उपयोग करके मुझे "अनकैप्ड एरर: अनएप्टेड ऑपरेंड टाइप्स" एरर मिला। और मैं नहीं देख सकता कि ऐसा क्यों होता है, लेकिन मुझे संदेह है ~। (और शायद इसलिए कि मैं PHP7 का उपयोग करता हूं और विधि केवल 5.6 के लिए काम करती है)

— RFSnake

2

पॉवरशेल , 57 56 बाइट्स

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

इसे ऑनलाइन आज़माएं!

-1 बाइट के लिए धन्यवाद

एक स्ट्रिंग के रूप में इनपुट लेता है, स्पष्ट रूप से एक स्ट्रिंग को $argsसरणी देता है, इसे char-यरे के रूप में डालता है, फिर एक लूप के माध्यम से वर्णों को खिलाता है। प्रत्येक पुनरावृत्ति, हम 50-50 या तो चरित्र का उत्पादन करते हैं $_या इसे ऊपरी-मामले में बदल देते हैं "$_".ToUpper()(यह ("$_"|% *per)कचरा है)। यह एक Randomपूर्णांक प्राप्त करने और इसे मॉड लेने के द्वारा चुना गया है 2।

उन पात्रों को पाइप लाइन पर छोड़ दिया जाता है और फिर -joinएक साथ एक स्ट्रिंग में एड किया जाता है, जो कि पाइप लाइन पर ही छोड़ दिया जाता है और आउटपुट निहित होता है।

— AdmBorkBork
स्रोत

आप को बदलने के लिए एक एकल बाइट बचा सकते हैं "$_".ToUpper()करने के लिए ("$_"|% *per)/ -:

— briantist

1

@briantist अच्छी बात है कि हम पठनीयता की परवाह नहीं करते हैं। ;-) धन्यवाद!

— AdmBorkBork

2

जूलिया , 35 बाइट्स

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

इसे ऑनलाइन आज़माएं!

अभी भी मानव के रूप में पढ़ने में बहुत आसान है। जूलिया रैंड (ए) में ए से एक यादृच्छिक तत्व देता है।

— Lukes
स्रोत

PPCG में आपका स्वागत है!

— स्टेयडबॉक्स

1

रेबोल , 61 बाइट्स

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

परीक्षा:

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

— गैलेन इवानोव
स्रोत

1

जेली , 16 बाइट्स

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

इसे ऑनलाइन आज़माएं!

व्याख्या

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)

मुझे यह एक पंक्ति में काम करने के लिए नहीं मिला। मुझे यह भी नहीं पता कि क्यों, लेकिन 2ḶXø³L¤Ð¡सूची [None,1,0,..,1]को 0s और 1s के साथ यादृच्छिक रूप से चुना गया है। Noneकारण है Ḋपहली कड़ी में।

— dylnan
स्रोत

रैंडम कैपिटलाइज़ेशन

टीआई-बेसिक (83 श्रृंखला), 137 बाइट्स

जाप , 6 बाइट्स

व्याख्या

पायथन 2 , 66 65 बाइट्स

सी, 47 46 बाइट्स

जेली , 5 बाइट्स

व्याख्या

पर्ल 5 , 23 बाइट्स

जावास्क्रिप्ट (ईएस 6), 56 बाइट्स

आर , 66 बाइट्स

एक्सेल VBA, 74 71 64 बाइट्स

चारकोल , 8 7 बाइट्स

रूबी, 40 बाइट्स

एपीएल + विन, 37 बाइट्स

आर , 89 88 बाइट्स

05AB1E , 6 5 बाइट्स

रूबी, 39 बाइट्स

स्विफ्ट 4, 86 बाइट्स

जावा 8, 46 बाइट्स

पूंजीकरण वितरण

स्वीकृतियाँ

फंकी , 55 बाइट्स

आर , 60 59 58 57 56 63 बाइट्स

ऑरोबोरोस , 25 बाइट्स

MATL , 12 11 बाइट्स

ब्रेकीलॉग , 5 बाइट्स

व्याख्या

ऐलिस , 17 15 बाइट्स

व्याख्या

वोल्फ्राम लैंग्वेज (गणितज्ञ) , 52 49 44 बाइट्स

अजगर, 10 7 6 बाइट्स

व्याख्या

पीएचपी, 63 53 बाइट्स

पॉवरशेल , 57 56 बाइट्स

जूलिया , 35 बाइट्स

रेबोल , 61 बाइट्स

जेली , 16 बाइट्स

एक्सेल VBA, _{74 71} 64 बाइट्स