31

आपकी चुनौती स्ट्रिंग को पासवर्ड करना है! आप क्या पूछ रहे हैं?

इनपुट के रूप में एक स्ट्रिंग लें। इस स्ट्रिंग में केवल बड़े अक्षर, लोअरकेस अक्षर, अंक और स्थान होंगे।

आपको सभी रिक्त स्थान को अंडरस्कोर से बदलना होगा और सभी नंबरों को स्ट्रिंग के अंत तक ले जाना होगा ताकि वे बाएं से दाएं दिखाई दें। फिर, स्ट्रिंग के प्रत्येक अक्षर के लिए, इसे बेतरतीब ढंग से अपरकेस या लोअरकेस में बदल दें।

उदाहरण (पात्रों का मामला हर बार अलग-अलग होना चाहिए):

Input
Hello world
Output
HElLo_wORld

Input
pa55 w0rd
Output
pA_Wrd550

Input
14 35
Output
_1435

Input
0971
Output
0971

Input
[space]
Output
_

बाइट्स जीत में सबसे छोटा कोड!

अगर कोई सूचना सुरक्षा एसई पर पूछता है कि क्या यह एक अच्छा हैशिंग एल्गोरिथ्म है! - एसई ओवरलोडर्स की चिंता न करें, मैं सिर्फ मजाक कर रहा हूं।

code-golf string random

— डैनियल
स्रोत

47

महान। अब आपने मेरी योजना प्रकाशित कर दी है। ठीक ही रहो, मेरे सारे पासवर्ड बदल कर ...

— Geobits

8

यह एक पासवर्ड हैशिंग एल्गोरिथ्म भी नहीं है ... यह

— जस्टिन

1

यदि केवल रेटिना में यादृच्छिकता करने का एक आसान तरीका था ...

— mbomb007

4

यह एक अच्छा हैशिंग एल्गो नहीं है क्योंकि यह यादृच्छिक है

— कैलक्यूलेटरफलाइन

6

मुझे पासवर्ड के रूप में कुछ उत्तरों का उपयोग करने के लिए

— लुभाया

12

अजगर, 15 बाइट्स

s}D`MTrRO2Xzd\_

प्रदर्शन

s}D`MTrRO2Xzd\_
                   Implicit: z = input(), d = ' '
          Xzd\_    In z, replace ' ' with '_'.
      rR           To each character, apply r-function
        O2         Randomly 0 or 1. r 0 is lowercase, r 1 is uppercase.
 }D                Order the characters based on presence in
   `MT             The strings of the numbers 0 to 9.
s                  Concatenate into a string.

— isaacg
स्रोत

27

भूलभुलैया , 76 बाइट्स

 `:_64/"32}
,`    (3  :=-{
"`{"; _v2$  ;`3
"`".:@ ; ".5(`3.
<       "" `^`;>

@ मार्टिनबटनर के साथ एक और कोलाब और लेबिरिंथ स्पेक्ट्रम के अधिक पागल पक्ष पर - पहली बार हमारे पास ^>v<एक कार्यक्रम में सभी चार हैं । इसे ऑनलाइन आज़माएं!

व्याख्या

सामान्य एल्गोरिथ्म, जो एक लूप में चलता है, इस प्रकार है:

 1.   Read a char
 2.   If EOF:
 3.     Move all digits from auxiliary stack to main
 4.     Output all digits on main stack
 5.     Halt
      Otherwise:
 6.     If char is a letter (c >= 64):
 7.       If random turns left:
 8.         Output char XOR 32
          Otherwise:
 9.         Output char
        Otherwise:
10.       Shift char to auxiliary stack
11.       If char is space (c-32 == 0):
12.         Pull char back from auxiliary stack
13.         Output underscore
          Otherwise:
14.         Continue loop

स्पष्टीकरण को कॉम्पैक्ट रखने के लिए, यहाँ मोटे तौर पर बताया गया है कि कार्यक्रम का प्रत्येक भाग ऊपर के छद्म कोड से मेल खाता है:

यहाँ दिलचस्प हिस्से हैं।

भूलभुलैया में यादृच्छिकता हो रही है

भूलभुलैया में यादृच्छिकता प्राप्त करने का केवल एक ही तरीका है, और यह तब होता है जब आईपी आगे की ओर जाने की कोशिश करता है लेकिन 1) न तो आगे और न ही पीछे की ओर एक रास्ता है और 2) बाएं और दाएं रास्ते उपलब्ध हैं। इस मामले में, आईपी बाएं और दाएं मार्गों के बीच बेतरतीब ढंग से चुनता है।

यह केवल ^>v<ऑपरेटर्स का उपयोग करना संभव है , जो 1. द्वारा nपंक्ति / कॉलम को पॉप और शिफ्ट nकरता है। उदाहरण के लिए, प्रोग्राम ( इसे ऑनलाइन आज़माएं! )।

" 1
""v!@
  2
   !@

1 या 2 बेतरतीब ढंग से आउटपुट देता है, क्योंकि 1 से vकॉलम को ऑफसेट करता है 0 (यानी कॉलम आईपी पर है) 1 से, उपज

"
""1!@
  v
  2!@

आईपी सही का सामना कर रहा है और आगे की ओर जाने की कोशिश करता है (स्टैक के शीर्ष शून्य है) लेकिन नहीं कर सकता। यह पीछे की ओर भी नहीं जा सकता है, इसलिए यह बेतरतीब ढंग से बाएं या दाएं के बीच चुनता है।

गोल्फ की चाल

कार्यक्रम पढ़ने के क्रम में पहले चार से शुरू होता है, जिसे आप नोटिस करेंगे वास्तव में चरण 6 है। हालांकि, एक खाली भूलभुलैया स्ट्रीप से 0 की पॉपिंग होती है, इसलिए चरण 10 और 14 होते हैं, एक शून्य को सहायक स्टैक में स्थानांतरित करते हैं, जो प्रभावी रूप से होता है। एक सेशन नहीं।
मुख्य स्टैक हर पुनरावृत्ति के बाद प्रभावी रूप से खाली होता है, जो हमें कोड लेआउट का उपयोग करके >और <नीचे दिए गए निहित शून्य पर गोल्फ की अनुमति देता है । >निचली पंक्ति लपेटता के आसपास इतना है कि नीचे बाईं ओर नीचे दाएँ से आईपी चलता है, और <बदलाव पंक्ति वापस। आईपी फिर लूप को जारी रखने के लिए बाएं कॉलम को खुशी से आगे बढ़ाता है।
भूलभुलैया पॉप nऔर धक्का में अंक 10*n + <digit>। इसके अलावा, आउटपुट होने से पहले चार्ज़ को मोडुलो 256 लिया जाता है। इन दोनों को एक साथ रखने से हमें `3332 (स्पेस) तक 95 (अंडरस्कोर) आउटपुट मिलता है , जो काम करता है -3233 % 256 = 95। हालाँकि, 32 को 95 में बदलना ;95सबसे आसान तरीका है ( सबसे आसान), यहाँ एक नकारात्मक संख्या के साथ काम करने से हमें बाएँ मुड़ने के साथ कोड को थोड़ा संकुचित करने की अनुमति मिलती है।

— Sp3000
स्रोत

2

हर हमलावर मेरे पासवर्ड को खोजने के लिए इस एल्गोरिथ्म का उपयोग करने की कोशिश कर रहा है, खो जाना सुनिश्चित है ...

— J_F_B_M

3

मैं सिर्फ अपने पासवर्ड के रूप में

— ILIZTacos

8

05AB1E , 22 21 20 बाइट्स

कोड:

þ¹žh-s«ð'_:vyždÈiš}?

CP-1252 एन्कोडिंग का उपयोग करता है ।

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

— अदनान
स्रोत

2

05AB1E कोड थोड़ा सा लगता है जैसे पुरानी अंग्रेज़ी :-)

— लुइस

1

@DonMuesli Hahaha, और कुछ चेक / बोस्नियाई / स्लोवेनियाई / क्रोएशियाई / स्लोवाक भी :)

— अदनान

7

सीजेएम , 25 बाइट्स

lelS'_er{58<}${2mr{eu}&}%

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

व्याख्या

मेरे MATL उत्तर का अनुवाद।

l                            e# read line as a string
 el                          e# make lowercase
   S'_er                     e# replace spaces by underscores
        {58<}$               e# (stable) sort with key "is digit"
              {        }%    e# map block over the string
               2mr           e# generate 0 or 1 equiprobably
                  {eu}&      e# if it's 1, make uppercase

— लुइस मेंडो
स्रोत

7

सीजेएम, 23 बाइट्स

lS'_er{60<}${eu_el+mR}%

इसका परीक्षण यहां करें।

व्याख्या

l       e# Read input.
S'_er   e# Turn spaces into underscores.
{60<}$  e# Sort (stably) by whether the character is a digit or not. This moves digits
        e# to the end, without changing the relative order within digits or non-digits.
{       e# Map this block over the characters...
  eu    e#   Convert to upper case.
  _el   e#   Make a copy and convert to lower case.
  +     e#   Join them into one string.
  mR    e#   Randomly choose one of the characters. Of course, this entire block is a
        e#   no-op for non-letter characters.
}%

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

7

अजगर, 107 बाइट्स

from random import*
lambda s:''.join([choice(c+c.swapcase()),'_'][c<'!']for c in sorted(s,key=str.isdigit))

अन्य दो पायथन जवाबों पर सुधार क्योंकि:

[...,'_'][c<'!']के बजाय प्रयोग किया जाता है s.replace(' ','_'), और
choice(c+c.swapcase()) के बजाय प्रयोग किया जाता है choice([c.upper(),c.lower()])

— Sp3000
स्रोत

ओह, अच्छा सुधार। बहुत बढ़िया जवाब! मुझ से +1।

— DJMcMayhem

7

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

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

एक चरित्र के मामले को यादृच्छिक करने के लिए 47 बाइट्स ...

संपादित करें: @ edc65 के लिए एक बड़े पैमाने पर 13 बाइट्स सहेजे गए।

— नील
स्रोत

मुझे फिर से पार्टी में आने की देर है। कम / upp महान है! लेकिन बाकी आसान हो सकता है:f=s=>s.replace(/./g,x=>x>'9'?x[`to${Math.random()<.5?"Low":"Upp"}erCase`]():x>' '?(s+=x,''):'_',s='')+s

— edc65

@ edc65 वाह। यहां तक कि सिर्फ ऊपरी / निचले मामले के प्रतिस्थापन के साथ अंतरिक्ष / अंडरस्कोर प्रतिस्थापन के संयोजन से दो बाइट्स बचते हैं लेकिन यह शानदार है!

— नील

7

MATL , 27 बाइट्स

k32'_'XEt58<2$S"@rEk?Xk]]v!

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

k         % implicit input. Make lowercase. Non-lettters are not affected
32'_'XE   % replace spaces by underscores
t58<      % duplicate. Create logical index: true for digits, false otherwise
2$S       % sort first string according to second. Sort is stable
"         % for each character in that string
  @       %   push that character
  rEk     %   generate 0 or 1 with 1/2 probability each
  ?       %   if it's a 1
    Xk    %     make uppercase. Non-letters are not affected
  ]       %   end if
]         % end for each
v         % vertically concatenate all stack contents
!         % transpose into a row char array, i.e. a string. Implicit display

— लुइस मेंडो
स्रोत

5

पायथन 3, 128 122 118 वर्ण

from random import*
s=lambda x:''.join(choice(i.upper()+i.lower())for i in sorted(x.replace(' ','_'),key=str.isdigit))

6 बाइट्स बंद करने के लिए xnor का धन्यवाद।

— DJMcMayhem
स्रोत

यह छँटाई करके अंत में नंबर पाने के लिए कम दिखता है:lambda x:''.join(choice([i.upper(),i.lower()])for i in sorted(x.replace(' ','_'),key=str.isnumeric))

— xnor

@xnor धन्यवाद! मैं वास्तव में जानने के लिए और ... lambdas का उपयोग शुरू कर देना चाहिए

— DJMcMayhem

5

पर्ल 6, 77 75 61 बाइट्स

{[~] |S:g/' '/_/.comb(/\D/)».&{(.lc,.uc).pick},|.comb(/\d/)}

S///s///यह $_जगह में संशोधित नहीं करता है को छोड़कर की तरह है

— हॉटकी
स्रोत

4

पायथ, 17 बाइट्स

smrdO2o}N`UT:zd\_

यहाँ कोशिश करो!

व्याख्या

smrdO2o} N`UT: zd \ _ # z = इनपुट

            : zd \ _ # स्थान को अंडरस्कोर से बदलें
      ओ # क्रमबद्ध ^ प्रमुख समारोह (एन) के साथ
       } "0123456789" में # N`UT, # संख्या के लिए 1 देता है ताकि वे दाईं ओर क्रमबद्ध हो जाएं
 m # ^ के प्रत्येक वर्ण का मानचित्र
  rdO2 # कन्वर्ट d randoms को ऊपरी या निचले हिस्से में
s # सूची को वापस एक स्ट्रिंग में शामिल करें

— Denker
स्रोत

4

गणितज्ञ, 86 बाइट्स

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

RandomChoice[{ToLowerCase,Capitalize}]@#/." "->"_"&/@Characters@#~SortBy~{DigitQ}<>""&

आह, स्ट्रिंग प्रोसेसिंग मैथमेटिका ... यह प्यारा नहीं है। यह एक अनाम फ़ंक्शन है जो एक स्ट्रिंग लेता है और लौटाता है।

सभी संश्लिष्ट चीनी के कारण, पढ़ने का क्रम थोड़ा मज़ेदार है:

Characters@#

स्ट्रिंग को वर्णों में विभाजित करें, अन्यथा हम वास्तव में इसके साथ कुछ भी नहीं कर सकते हैं।

...~SortBy~{DigitQ}

अंकों को अंत तक भेजता है। सूची में परीक्षण फ़ंक्शन को लपेटकर, हम छंटाई को स्थिर बनाते हैं।

...&/@...

सूची में प्रत्येक वर्ण पर बाएं हाथ के कार्य को मैप करता है।

RandomChoice[{ToLowerCase,Capitalize}]

करंट कैरेक्टर के लिए एक रैंडम केस-चेंजिंग फंक्शन को चुनता है।

...@#...

इसे वर्तमान चरित्र पर लागू करता है।

.../." "->"_"

अंडरस्कोर के साथ रिक्त स्थान की जगह।

...<>""

अंत में सभी पात्रों को एक साथ एक स्ट्रिंग में वापस जोड़ देता है।

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

3

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

-join([char[]]$args[0]-replace" ","_"|%{if($_-match"\d"){$d+=$_}else{"'$_'.To$("Low","Upp"|random)er()"|iex}})+$d

पॉवरशेल भयानक गोल्फ भाषा के लिए खड़ा है। चार्ट में विभाजित करें और अंडरस्कोर के साथ रिक्त स्थान बदलें। प्रत्येक चरित्र और प्रक्रिया को लें। बाद के आउटपुट के लिए चर $ d में संख्याएं एकत्र करें। एक दूसरे का चरित्र बेतरतीब ढंग से अपरकेस या लोअरकेस में एक अभिव्यक्ति का उपयोग करके बना है 'char'.ToLower()या 'char'.ToUpper()। यदि कोई अंक एकत्र किए गए थे, तो उन्हें अंत में संलग्न करें।

— मैट
स्रोत

PowerShell महान है और सभी चीजें करता है। : D का उपयोग करके आप कुछ बाइट्स बचा सकते हैं $_-in0..9और -inऑपरेटर रेगेक्स के बजाय पावरशेल v3 में पेश किया गया है -match।

— AdmBorkBork

3

जूलिया, 88 87 78 बाइट्स

s->join([c<33?'_':rand([ucfirst,lcfirst])("$c")for c=sort([s...],by=isdigit)])

यह एक अनाम फ़ंक्शन है जो एक स्ट्रिंग को स्वीकार करता है और एक स्ट्रिंग लौटाता है। इसे कॉल करने के लिए, इसे एक वैरिएबल पर असाइन करें।

पहले हम इनपुट स्ट्रिंग को उसके वर्णों के एक सरणी में तोड़ते हैं, और प्रत्येक वर्ण को एक अंक के अनुसार सरणी को सॉर्ट करते हैं। यह पाठ और अंकों में क्रम बनाए रखता है लेकिन अंकों को अंत तक धकेलता है। फिर, सरणी में प्रत्येक वर्ण के लिए, हम जाँचते हैं कि क्या यह एक स्थान है। यदि हां, तो एक अंडरस्कोर के साथ बदलें, अन्यथा बेतरतीब ढंग से एक का चयन ucfirstया lcfirstचरित्र को लागू करने के लिए, जिससे यह ऊपरी या लोअरकेस क्रमशः परिवर्तित। सरणी को स्ट्रिंग में शामिल करें और हम कर रहे हैं!

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

Sp3000 के लिए 9 बाइट्स बचाए गए!

— एलेक्स ए।
स्रोत

2

पर्ल, 51 48 बाइट्स

के लिए +2 शामिल है -lp

STDIN पर इनपुट के साथ चलाएँ:

perl -lp passwordify.pl <<< "Hel1lo wo4rld"

passwordify.pl:

s%\pL%$&^$"x rand 2%eg;$_=y/ 0-9/_/dr.s/\D//gr

— टन हास्पेल
स्रोत

1

फैक्टर, 154 बाइट्स

या आयात के साथ 222 kernel splitting sequences ascii combinators.random regexp

: f ( x -- y ) R/ \d/ R/ \D/ [ all-matching-subseqs ] bi-curry@ bi [ { [ >upper ] [ >lower ] } call-random ] map [ "" join ] bi@ " " "_" replace prepend ;

मैं फैक्टर में गोल्फिंग में बहुत अच्छा नहीं हूं, और मुझे यकीन नहीं है कि अगर मैंने यहां सबसे अच्छा तरीका अपनाया, लेकिन मुझे लगा कि मैं इसे छोड़ दूंगा

— हॉटकी
स्रोत

1

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

अनाम फ़ंक्शन। c.downcaseकिसी कारण से वाक्य रचना त्रुटि का कारण बनने से पहले स्थान को हटाना और मुझे यकीन नहीं है कि क्यों।

->s{q="";s.gsub(/./){|c|c=~/\d/?(q+=c;p):c==" "??_:rand<0.5?c.upcase: c.downcase}+q}

— मूल्य स्याही
स्रोत

1

लुआ, 125 बाइट्स

जब वस्तु कार्यात्मक रूप से मिलती है, तो आप कुछ सुंदर चीजें कर सकते हैं, यहां तक कि लू में भी! मुझे नहीं लगता कि मैं इसे नीचे कर सकता हूं, यह पहले से ही काफी गड़बड़ है, और मैं पहले से ही अजगर के जवाबों को हराकर खुश हूं: डी।

s=""print((...):gsub("%d",function(d)s=s..d return""end):gsub("%s","_"):gsub("%a",1<math.random(2)and s.upper or s.lower)..s)

अपुष्ट और स्पष्टीकरण

s=""                       -- Initialise the string that will contains the digits
print((...)                -- apply the following to the argument then print it
  :gsub("%d",function(d)   -- iterate over the digits
    s=s..d                 -- concatenate them in s
    return""               -- remove them from the arg
   end)
  :gsub("%s","_")          -- replace spaces by underscores
  :gsub("%a",              -- iterate over letters
    1<math.random(2)       -- pick a random integer between 1 and 2
      and s.upper          -- if it is 2, use the function upper() of object s
      or s.lower)          -- else, use the function lower() of object s
  ..s)                     -- concatenate with s

— Katenkyo
स्रोत

1

गंभीरता से, 25 बाइट्स

,`'_' (Æ≈"ûù"J£ƒ`M;ì;(-+Σ

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

स्पष्टीकरण:

,`'_' (Æ≈"ûù"J£ƒ`M;ì;(-+Σ
,`              `M         map over input:
  '_' (Æ                     replace spaces with underscores
        ≈                    cast to int (does nothing if cast fails)
         "ûù"J£ƒ             randomly upper- or lowercase it (does nothing if not letter)
                  ;ì;(-+   move ints to back
                        Σ  join

— मेगो
स्रोत

1

आईपीओएस - गैर प्रतिस्पर्धा, 14 बाइट्स

S'_RE`N-`dE!k?

हां, मैंने इस चुनौती के लिए बिल्डरों को जोड़ा है, लेकिन वे विशेष रूप से इस समस्या पर लक्षित नहीं हैं।

यह दुभाषिया के संस्करण 0.1 के साथ काम करता है ।

उदाहरण चलाते हैं

> अजगर IPOS.py S'_RE`N-`dE! k -आई "पा55 w0rd"
Pa_WrD550

व्याख्या

     # लागू: स्टैक पर जगह इनपुट (सी)
S # स्टैक (B) के लिए एक स्थान पुश करें
'_ # स्टैक (ए) के लिए एक अंडरस्कोर दबाएं
R # C में B को A -> के साथ अंडरस्कोर को स्पेस से बदलें
     # स्टैक में अब केवल प्रतिस्थापित स्ट्रिंग (C) होता है
E # एक रिक्त स्ट्रिंग पुश करें (B)
`# एक कमांड शाब्दिक प्रारंभ करें,
     # इसके लिए स्टैक को बाद में किसी एकल वर्ण (B) से आरंभ किया जाता है
N # स्टैक के लिए अंक के रूप में अंक 0-9 पुश (ए)
- # B का प्रत्येक वर्ण A में है
`# अंतिम आदेश शाब्दिक (ए)
d # B पर विभाजित C, कुंजी A के साथ नीचे उतरने वाले भागों को क्रमबद्ध करें और B पर वापस शामिल हों।
     # कुंजी फ़ंक्शन A स्ट्रिंग का प्रत्येक वर्ण एक रिक्त स्ट्रिंग में बदल देता है यदि यह एक अंक है।
     # चूँकि परिणामी चार में अंक नहीं है, इसलिए यह महत्वपूर्ण है कि यह लंबाई है।
     # यह कुंजी को अंकों के लिए और गैर-अंकों के लिए कुंजी 1 को मैप करता है। उतरते में यह छँटाई
     # ऑर्डर अंकों को दाईं ओर ले जाता है और गैर-अंकों को उस क्रम में छोड़ देता है, जिस क्रम में वे पहले थे।
ई # एक खाली स्ट्रिंग पुश
? k # कमांड k पुश करें (= स्वैपपैक)
? # हर वर्ण में बेतरतीब ढंग से ^ लागू करें
     # निहित: आउटपुट स्टैक सामग्री

— Denker
स्रोत

1

PHP, 368 बाइट्स

$str = "pa55 w0rd";
$str = str_replace(" ","_",$str);
$output AND $numStr = "";
$numArray = ['0','1','2','3','4','5','6','7','8','9'];
for($i=0;$i<strlen($str);$i++){
    in_array($str[$i],$numArray)?($numStr = $numStr.$str[$i]):((rand(10,100)%2==0)?$str[$i] = strtoupper($str[$i]) AND $output = $output.$str[$i]:$output = $output.$str[$i]);
}
echo $output = $output.$numStr;

असिंचित कोड:

$str = "pa55 w0rd";
$str = str_replace(" ","_",$str);
$len = strlen($str);
$output = "";
$numStr = "";
$numArray = ['0','1','2','3','4','5','6','7','8','9'];
for($i=0;$i<$len;$i++){
  if(in_array($str[$i],$numArray)){
    $numStr = $numStr.$str[$i];
  }else {
      if(rand(10,100)%2==0)
      {
        $str[$i] = strtoupper($str[$i]);
      }
      $output = $output.$str[$i];
  }
}
$output = $output.$numStr;
echo $output;

— सिद्धराजसिंह जाला
स्रोत

यह एक शानदार शुरुआत है, लेकिन आप इसे बहुत अधिक बढ़ा सकते हैं। कृपया सभी चर को 1-चार नामों में बदलें, और अतिरिक्त व्हाट्सएप को हटा दें। जब आप ऐसा करेंगे, तो यह एक प्रथम श्रेणी का गोल्फ होगा!

— NoOneIsHere

0

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

from random import*
f=lambda s,a=[str.upper,str.lower],n='0123456789':''.join(map(lambda x:choice(a)(x),filter(lambda x:x not in n,s).replace(' ','_')))+filter(lambda x:x in n,s)

यहाँ सुधार के लिए शायद बहुत जगह है जिसे मैं बाद में काम करूँगा।

— मेगो
स्रोत

0

AWK, 128 बाइट्स

{srand();for(;++i<=split($0,a,"");){s=a[i];if(s!=s+0){o=s==" "?"_":rand()>0.5?tolower(s):toupper(s);A=A o}else{N=N s}}print A N}

srand()हमें अलग यादृच्छिक संख्या हर बार इसे चलाता देने के लिए की जरूरत है।
इसके लिए मल्टी-लाइन इनपुट के साथ ठीक से काम करने के लिए, हमें लूप A=N=""से पहले कुछ डालने की आवश्यकता होगी for।

— रॉबर्ट बेन्सन
स्रोत

0

पायथन 3.5 - 118 बाइट्स:

from random import*
lambda y:''.join(choice([q.upper(),q.lower()])for q in sorted(y.replace(' ','_'),key=str.isdigit))

जैसा कि आप देख सकते हैं, मैं मूल रूप से choiceदिए गए स्ट्रिंग के सॉर्ट किए गए संस्करण में प्रत्येक अक्षर के लिए एक यादृच्छिक फ़ंक्शन (या तो .upper () .lower ()) चुनने के लिए यादृच्छिक मॉड्यूल के फ़ंक्शन का उपयोग कर रहा हूं , जिसमें सभी अंक जाते हैं। समाप्त। इसके अलावा, हर जगह को सॉर्ट किए गए स्ट्रिंग में एक अंडरस्कोर के साथ बदल दिया जाता है।

— आर। कप
स्रोत

0

PHP, 164 158 chars / बाइट्स

यह अन्य PHP गोल्फ की तुलना में बेहतर है , क्योंकि:

यह इनपुट्स लेता है
यह छोटा है

लिपि

<?$a=$b='';foreach(str_split(strtolower($argv[1]))as$c){if($c==' ')$c='_';if(preg_match("/[0-9]/",$c))$a.=$c;else$b.=(rand(0,1)?$c:strtoupper($c));}echo$b.$a;

उदाहरण

php password.php 'thats some 1337 shit'

ThATs_Some__sHiT1337

— timmyRS
स्रोत

0

> <> , 73 बाइट्स

 i:"@")?v:" ")?v0) ?\rl?!;o01!.<
 v8<    8>00.! <o"_"/
8<>x<%*4/^o+*
 ^c<

कुछ भी नहीं यहाँ पागल, यह:

_जब यह सामना करता है तो प्रिंट करता है
अक्षरों के मॉड को 32 लेता है, फिर उन्हें प्रिंट करने से पहले 8 * 8 या 12 * 8 जोड़ देता है
नंबर को ढेर कर देता है और इनपुट समाप्त होने के बाद उन्हें प्रिंट कर लेता है

आप इसे यहाँ आज़मा सकते हैं !

— हारून
स्रोत

-1

पायथन 3, 151 बाइट्स

import random as r
x=input();s="";n=""
for c in x:
 if c.isdigit():n+=c
 else:s+=c.upper() if r.randint(0,1) else c.lower()
print(s.replace(" ","_")+n)

— आर्गेनिस गार्सिया
स्रोत

स्ट्रिंग को पासवर्ड दें

बाइट्स जीत में सबसे छोटा कोड!

अजगर, 15 बाइट्स

भूलभुलैया , 76 बाइट्स

व्याख्या

भूलभुलैया में यादृच्छिकता हो रही है

गोल्फ की चाल

05AB1E , 22 21 20 बाइट्स

सीजेएम , 25 बाइट्स

व्याख्या

सीजेएम, 23 बाइट्स

व्याख्या

अजगर, 107 बाइट्स

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

MATL , 27 बाइट्स

पायथन 3, 128 122 118 वर्ण

पर्ल 6, 77 75 61 बाइट्स

पायथ, 17 बाइट्स

व्याख्या

गणितज्ञ, 86 बाइट्स

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

जूलिया, 88 87 78 बाइट्स

पर्ल, 51 48 बाइट्स

फैक्टर, 154 बाइट्स

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

लुआ, 125 बाइट्स

अपुष्ट और स्पष्टीकरण

गंभीरता से, 25 बाइट्स

आईपीओएस - गैर प्रतिस्पर्धा, 14 बाइट्स

उदाहरण चलाते हैं

व्याख्या

PHP, 368 बाइट्स

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

AWK, 128 बाइट्स

पायथन 3.5 - 118 बाइट्स:

PHP, 164 158 chars / बाइट्स

लिपि

उदाहरण

> <> , 73 बाइट्स

पायथन 3, 151 बाइट्स