क्या आप अपने 'केवीजेड' को जानते हैं?

Question

संकल्पना

किन तरीकों से आप अंग्रेजी वर्णमाला को स्क्रैम्बल कर सकते हैं ताकि धुन को बर्बाद किए बिना ट्विंकल ट्विंकल लिटिल स्टार को अभी भी गाया जा सके?

नियम

अदला-बदली

चलिए मान लेते हैं कि निम्नलिखित में से प्रत्येक सेट में निहित अक्षरों को बिना धुन के डिफ़ॉल्ट रूप से डिफ़ॉल्ट रूप से स्वैप किया जा सकता है:

• {, जे, के, के}
• {बी, सी, डी, ई, जी, पी, टी, वी, जेड}
• {, Y, Y}
• {क्यू, यू}
• {एस, एक्स, एफ}
• {M, N}
• इसलिए एच, एल, ओ, आर, और डब्ल्यू जगह में बंद हैं

उत्पादन

कार्यक्रम को किसी भी क्रम में पूर्ण अंग्रेजी वर्णमाला वाले एक रैंडम स्ट्रिंग (या वर्णों की सूची) को आउटपुट करने की आवश्यकता है बशर्ते कि आदेश ऊपर की स्थितियों को संतुष्ट करता है। आपके लिए यह अनुमान लगाने का कोई तरीका नहीं होना चाहिए कि आपका प्रोग्राम कौन सा स्ट्रिंग आउटपुट करेगा (यदि हम सीडिंग को अनदेखा करते हैं), जिसका अर्थ है कि आप इसे केवल हार्डकोड नहीं कर सकते।

आपके कार्यक्रम में $9! \cdot 3! \cdot 3! \cdot 2! \cdot 2! \cdot 2! = 104509440$ प्रत्येक को उत्पन्न करने के लिए कुछ सकारात्मक संभावना (जरूरी नहीं कि एक समान) होनी चाहिए ! ⋅ ३ ! ⋅ ३ ! ⋅ २ ! ⋅ २ ! ⋅ २ ! = 104509440 आउटपुट।

रिक्ति, सीमांकक या मामले के संबंध में कोई विशेष प्रारूपण प्रतिबंध नहीं हैं, बस सुसंगत रहें।

लक्ष्य

सबसे शानदार बाइट्स जीतता है!

उदाहरण:

• KCDBPSVHIAJLMNOZQRXGUEWFYT
• एक, जी, जेड, वी, पी, एक्स, सी, एच, वाई, कश्मीर, जम्मू, एल, एन, एम, ओ, टी, यू, आर, एस, डी, क्यू, बी, डब्ल्यू, एफ, मैं, ए
• KVTDCFBHIJALNMOPURSZQGWXYE
• jcdebxthikalnmogursvq pwfyz
• ABCDEFGHIJKLMNOPQRSTUVWXYZ

Nonexample:

• HLWROABCDEFZXYGIJKMNPQTSVU

अवधारणा का प्रमाण: (पायथन 3, 529 बाइट्स)

import random
g1 = ['A', 'J', 'K']
g2 = ['B', 'C', 'D', 'E', 'G', 'P', 'T', 'V', 'Z']
g3 = ['I', 'Y']
g4 = ['Q', 'U']
g5 = ['S', 'X', 'F']
g6 = ['M', 'N']
random.shuffle(g1)
random.shuffle(g2)
random.shuffle(g3)
random.shuffle(g4)
random.shuffle(g5)
random.shuffle(g6)
print(g1[0] + g2[0] + g2[1] + g2[2] + g2[3] + g5[0] + g2[4] + 'H' + g3[0] + g1[1] + g1[2] + 'L' + g6[0] + g6[1] + 'O' + g2[5] + g4[0] + 'R' + g5[1] + g2[6] + g4[1] + g2[7] + 'W' + g5[2] + g3[1] + g2[8])

Comments

Z"जगह में बंद" नहीं होना चाहिए , यह दूसरों के साथ तुकबंदी नहीं करता है?

— झबरा

इस पर निर्भर करता है कि आप कहां से हैं जो मुझे लगता है। यदि आप 'जेड' कहते हैं, तो इसे बाहर निकालने का कोई मतलब होगा, लेकिन अगर आप कहते हैं कि 'ज़ी' है, तो इसे छोड़ दें। अंततः यह आपके ऊपर है, जैसा कि बाकी सेट हैं। वे दिशा-निर्देश

— मानने लगे हैं

समान रूप से यादृच्छिक या हर संभावना एक गैर-शून्य संभावना, या कुछ और?

— jimmy23013

@PeterTaylor मुझे लगता है कि इरादा यह है कि समूह के सदस्यों को मूल के धुन और लय को बनाए रखते हुए आसानी से गीत के बीच में स्वैप किया जा सकता है - इसलिए जब वे तुकबंदी करते हैं, तो डब्ल्यू 3 शब्दांश तब होता है जब तक यू केवल 1 है, जिससे गाने की लय बदल जाएगी।

— सोक

उन लोगों के लिए जिनके (मेरे जैसे) को पता नहीं था कि सवाल किस बारे में बात कर रहा था: en.wikipedia.org/wiki/Alphabet_song

— anatolyg

Answer 1

05AB1E , 28 बाइट्स

A.•¬=©ƶÓÄûkTVã”ØζÞ•Dás#€.rJ‡

एकल लोअरकेस स्ट्रिंग के रूप में आउटपुट।

$n$

स्पष्टीकरण:

A                    # (a) Push the lowercase alphabet
 .•¬=©ƶÓÄûkTVã”ØζÞ•  # Push compressed string "ajk bcdegptvz iy qu sxf mn"
  Dá                 # (b) Duplicate it, and only keep the letters (removing the spaces)
    s#               # Swap to get the string again, and split it by spaces
      €.r            # Shuffle each substring randomly
         J           # (c) Join it back together to a single string
          ‡          # Transliterate all characters from (b) to (c) in string (a)
                     # (and output the result implicitly)

मेरा यह 05AB1E टिप देखें (अनुभाग संपीड़ित तार शब्दकोश का हिस्सा नहीं कैसे? ) को समझने के लिए क्यों .•¬=©ƶÓÄûkTVã”ØζÞ•है "ajk bcdegptvz iy qu sxf mn"।

Answer 2

पायथन 3 , 140 133 124 123 बाइट्स

d=*map(set,'AJK BCDEGPTVZ IY QU SXF MN H L O R W'.split()),
print([d[int(c,16)].pop()for c in'0111141620075581394131a421'])

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

_{-1 बाइट, जो किंग के लिए धन्यवाद}

---

पायथन 2 , 174 170 158 बाइट्स

from random import*
s=''
for c in'abbbbebHcaaLffObdRebdbWecb':s+=choice(list(set(('AJK BCDEGPTVZ IY QU SXF MN '+c).split()['abcdef'.find(c)])-set(s)))
print s

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

Answer 3

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

s=[*?A..?Z]*''
%w(AJK BCDEGPTVZ IY QU SXF MN).map{|e|a=e.chars.shuffle;s.gsub!(/[#{e}]/){a.pop}}
$><<s

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

Answer 4

पायथ , 59 57 56 बाइट्स

hMeD,Vs.SMJc"ajk bcdegptvz iy qu fsx mn h l o r w"dxLGsJ

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

आउटपुट लोअर केस लेटर्स की एक सरणी है।

hMeD,Vs.SMJc"ajk bcdegptvz iy qu fsx mn h l o r w"dxLGsJ   Implicit: d=" ", G=<lowercase alphabet>
          Jc"ajk bcdegptvz iy qu fsx mn h l o r w"d        Chop the grouping string on spaces, store in J
                                                      sJ   Concatenate J into single string
                                                   xLG     Find the index of each letter in grouping string in the unaltered alphabet
       .SMJ                                                Shuffle each group in J
      s                                                    Concatenate into a single string
    ,V                                                     Pair the shuffled string with their 'correct' positions in the alphabet
  eD                                                       Order the pairs by the derived positions (last element of each pair)
hM                                                         Keep the letter from each pair (the first element)
                                                           Implicit print

Answer 5

आर , 93 91 बाइट्स

`^`=strsplit
L=LETTERS
for(s in el('AJK7BCDEGPTVZ7IY7QU7FSX7MN'^7)^'')L[L%in%s]=sample(s)
L

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

Answer 6

पर्ल 6 , 76 बाइट्स

{my@a='A'..'Z';<AJK BCDEGPTVZ IY QU SXF MN>>>.&{@a[.ords X-65].=pick(*)};@a}

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

अनाम कोड ब्लॉक में कोई तर्क नहीं है और वर्णों की सूची लौटाता है।

स्पष्टीकरण:

{                                                                          } # Anonymous code block
 my@a='A'..'Z';      # Initialise @a as a list of the alphabet
               <AJK BCDEGPTVZ IY QU SXF MN>   # For each of the sets of letters
                                           >>.&{@a[.ords X-65].=       }  # Set those indexes
                                                                pick(*)   # To a random order
                                                                        ;@a  # And return

Answer 7

जावास्क्रिप्ट - 421 344 328 320 306 280 277 276 ... 176 बाइट्स

-77 बाइट्स - अपने दम पर

-18 बाइट - धन्यवाद करने के लिए @tsh और @Geza Kerecsenyi जो मुझे देखते हैं कि क्या बनाया @tsh शुरू में बताया भी

-8 बाइट्स - करने के लिए धन्यवाद @Geza Kerecsenyi

-14 बाइट्स - की मदद से @Geza Kerecsenyi

- 28 बाइट्स - मेरे अपने

-3 बाइट्स पर - फिर से @Geza Kerecsenyi

-1 बाइट्स की मदद से - यह कैसे हो सकता है ...

...

-100 बाइट्स - @ कैइडो ने इसे मार दिया और कुछ कदमों से पहले यह पूरी चीज नीचे उतर गई। करने के लिए 176 बाइट्स

golfed:

c=[,'AJK','BCDEGPTVZ','IY','QU','SXF','MN'].map(s=>[...s]);alert([...'1222252H311L66O24R5242W532'].reduce((o,v)=>o+(+v?(p=>p.splice((Math.random()*p.length)|0,1))(c[v]):v),""))

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

Comments

आप कम से कम "BCDEGPTVZ'.split`` द्वारा '' B ',' C ',' D ',' E ',' P ',' T ',' V ',' Z 'को बदल सकते हैं। कुछ बाइट्स को बचाने के लिए

— TSH

-2 के 'BCDEGPTVZ'.split``बजाय प्रयास करें .split('')।

— गेज़ा केरेसेनी

इसके अलावा, आप y=q=>q.split``अपने कोड के शीर्ष पर परिभाषित कर सकते हैं , और सभी ऐरे स्ट्रिंग्स बना सकते हैं जिन्हें आप पास करते हैं y()- जैसे a=['A','J','K']बन जाता हैa=y("AJK")

— Geza Kerecsenyi

और के 'BCDEGPTVZ'.split('')साथ बदलेंy('BCDEGPTVZ')

— Geza Kerecsenyi

'abcdef'.includes(s)?r(eval(s)):l[i]

— गीज़ा केर्केसेनी

Answer 8

रूनिक एनचेंमेंट्स , 210 बाइट्स

>yy `AJK`06B$̤$@
>`BCDEGPTVZ`06B$$$$ $̤$y $ $y @
>̤`IY`06Byyy$yyy̤ @
> ̤`QU`06Byy̤ $y @
> ̤`FSX`06B $yy̤$yy@
>y̤ `MN`06Byyy $@
}}f}l3-[r\
3-[2'RA?rR1Kl'RAs]{1-:0)?\}l
> ̤`HLORW`06Bo$y $y$y$yy@ \~{{B͍

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

रैंडमाइजेशन एक समान नहीं है क्योंकि रुनिक में ऐसा करने का अच्छा तरीका नहीं है। इसके बजाय यह अनियमित रूप से अक्षरों के प्रत्येक संग्रह (जैसे [BCDEGPTVZ]एक समूहन) को कुछ मात्रा में घुमाता है (उदाहरण के लिए 4 से ऊपर सेट को घुमाता है , जहां स्टैक के शीर्ष दाईं ओर है, परिणाम होगा [BCDEGZPTV]) और फिर बेतरतीब ढंग से फैसला करता है कि नहीं या नहीं स्टैक उल्टा करें। यह इन ऑपरेशनों को 15 बार करता है। नतीजतन, सभी संभव आदेश संभव हैं लेकिन समान रूप से संभव नहीं हैं । (इस घटना में कि यह पर्याप्त नहीं है, इसे बढ़ाने पर शून्य बाइट्स की लागत बढ़ जाती है , 15000 तक फेरबदल छोरों)।

यह कोड का वह भाग है जो फेरबदल को संभालता है:

  v              vvvv           Loop counter

}}f}l3-[r\                      < Loop entry
[2'RA?r1KRl'RAs]{1-:0)?\}l3-
                       \~{{B͍    < loop exit

 ^^^^^^                         Randomly reverse
          ^^^^^                 Rotate by a random an amount

कोड के बाकी इस में अनियंत्रित:

                     ABCDEFGHIJKLMNOPQRSTUVWXYZ
>      `AJK`08B      $        $$;
> `BCDEGPTVZ`08B      $$$$ $        $   $ $   $;
>         `IY`08B            $               $;
>          `QU`08B                   $   $;
>          `FSX`08B       $            $    $;
>            `MN`08B             $$;
>          `HLORW`08Bo      $   $  $  $    $;

^                                                   Create IPs
 ^^^^^^^^^^^^^^^^                                   Set letter groupings
                  ^^^                               Call shuffle function
                      ^^^^^^^^^^^^^^^^^^^^^^^^^^    Print letters
                     ^                              Last letter group needs to be sorted

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

गोल्फ के लिए, पहले सभी लाइनों पर हटाए जा सकने वाले किसी भी स्थान को छंटनी की गई थी, फिर प्रत्येक दो रिक्त स्थान को एक में बदल दिया गया था y, और प्रत्येक अनुक्रम yyyyको इस ̤वजह से परिवर्तित किया गया था ̤और yyyyविलंब की समान मात्रा है, लेकिन 2 बाइट्स सस्ता है। HLORWरिक्ति बाइट्स (12 बाइट्स) को बचाने के लिए लूप से बाहर निकलने को भी मुख्य प्रोग्राम सेगमेंट के साथ जोड़ा गया था ।

Answer 9

पर्ल 5 , 103 91 85 बाइट्स

map{my%l;@l{/./g}++;@k{/./g}=keys%l}AJK,BCDEGPTVZ,SXF,IY,QU,MN;say map$k{$_}||$_,A..Z

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

यह कोड (एब) इस तथ्य का उपयोग करता है कि पर्ल की हैश कीज़ ( %l) का आउटपुट %kउनके सभी संभावित समकक्षों के सभी संशोधित अक्षरों के मानचित्रण ( ) बनाने के लिए यादृच्छिक है । आउटपुट समय पर, कोई भी कुंजी जो मौजूद नहीं है, को अपरिवर्तित माना जाता है।

Comments

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

— जॉन बोलिंजर

@ जॉनबोलिंगर यह केवल एक कार्यक्रम के एक रन के भीतर सच है। एक एकल रन के भीतर, हैश आदेश समान होगा यदि हैश अनमॉडिफाइड है। दो रन के पार या एक संशोधन के साथ, पर्ल के प्रत्येक आह्वान के दौरान एक यादृच्छिक बीज बनाया जाता है। संदर्भ

— ११:२३

ठीक है, @ Xcali, मैं सही खड़ा हूँ। मुझे कम से कम आंशिक रूप से गुमराह किया गया है, हालांकि, आपके "यह ऑनलाइन प्रयास करें!" लिंक, जो बार-बार मेरे लिए एक ही आउटपुट उत्पन्न करता है। यह कैशिंग, या कुछ और होना चाहिए।

— जॉन बोलिंगर

का उपयोग करना keysनिश्चित रूप से एक अच्छा तरीका है, लेकिन आप sort rand 2,...इसके बजाय 6 बाइट्स बचा सकते हैं :( इसे ऑनलाइन आज़माएं!

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

Answer 10

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

ØA“wẸXWỵḲ⁻ȦƙṄṇ’œ?µ“ĠQ’ḃ3ÄœṖ⁸Ẋ€Ẏị@Ụ

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

Answer 11

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

a,b,i,q,s,m,h,l,o,r,w=(set(s)for s in["AJK","BCDEGPTVZ","IY","QU","SXF","MN",*"HLORW"])
print([eval(c).pop()for c in[*"abbbbsbhiaalmmobqrsbqbwsib"]])

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

पत्र सेट के लिए पॉप () का उपयोग करके यादृच्छिककरण

Answer 12

एपीएल (डायलॉग एक्सटेंडेड) , 55 बाइट्स

पूरा कार्यक्रम। एक प्रमुख और अनुगामी स्थान के साथ प्रिंट अपरकेस, लेकिन कोई मध्यस्थ स्थान नहीं।

{(?⍨∘≢⊇⊢)@(∊∘⍺)⊢⍵}/⌈'AjkBcdegptvzIyQuSxfMn'(⊂⍤⊢,⍨∊⊂⊣)⎕A

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

⎕A अपरकेस वर्णमाला

'AjkBcdegptvzIyQuSxfMn'(… ) निम्नलिखित अनाम टास्किट फ़ंक्शन को उस सही तर्क के साथ लागू करें और बाएं स्ट्रिंग के रूप में संकेतित स्ट्रिंग:

⊣ बाएं तर्क के लिए,

⊂ यह विभाजन, एक नए खंड की शुरुआत जहां

∊ बाएं तर्क वर्ण सही तर्क के सदस्य हैं (यानी अपरकेस अक्षरों पर)

,⍨ संलग्न

⊂ संलग्न (एक तत्व के रूप में यह इलाज के लिए)  सही तर्क
⍤
⊢

⌈ सब कुछ बड़ा

{... }/ निम्नलिखित गुमनाम लैम्ब्डा द्वारा कम करने, दे रही है ... "QU"λ("SXF"λ("MN"λ"A-Z")):

 ⊢⍵ सही तर्क पर (स्क्रैचिंग-इन-प्रोग्रेस अल्फाबेट)

 (… )@(∊∘⍺) निम्नलिखित अनाम टास्क फ़ंक्शन को उपसमूह पर लागू करें जो बाएं तर्क (एक तुकबंदी समूह) का सदस्य है

  ⊢ उस सबसेट पर

  ⊇ यह होना चाहिए

  ?⍨ सबसेट में अक्षरों
  ∘ की लंबाई
  ≢टैली का  एक यादृच्छिक क्रमचय

Answer 13

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

ＦαＦ⪪”＆↖(vＪf#Ｓ»↖ιηa↷Ｎ↖⪪νＰ´↑x‖υ” Ｆ№κι‽Φκ¬№ＫＡμ

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। चारकोल के पास कोई फेरबदल करने वाले ऑपरेटर नहीं हैं, लेकिन मैं प्रतिस्थापन के बिना नमूना लेने की एक विधि के साथ आया था। स्पष्टीकरण:

Ｆα

वर्णमाला के प्रत्येक अक्षर पर लूप।

Ｆ⪪”＆↖(vＪf#Ｓ»↖ιηa↷Ｎ↖⪪νＰ´↑x‖υ” 

AJK BCDEGPTVZ IY QU SXF MN H L O R Wरिक्त स्थान पर स्ट्रिंग को विभाजित करें और सबस्ट्रिंग पर लूप करें।

Ｆ№κι

घटस्थापना में वर्तमान अक्षर की संख्या से अधिक लूप। (मैं एक लूप का उपयोग करता हूं क्योंकि एक सशर्त को elseकैल्यूज़ की आवश्यकता होगी । वैकल्पिक रूप से मैं उसी बाइट की गिनती के लिए वर्तमान पत्र वाले प्रतिस्थापन पर फ़िल्टर कर सकता था।)

‽Φκ¬№ＫＡμ

एक यादृच्छिक चरित्र प्रिंट करें, लेकिन उन लोगों को बाहर करें जिन्हें पहले से ही मुद्रित किया गया है।

Answer 14

रेटिना , 80 बाइट्स

K`1A2B2C2D2E5F2GH3I1J1KL6M6NO2P4QR5S2T4U2VW5X3Y2Z
~(K`123456
.
?O`$&.¶
)`¶$
[blank line]
\d
[blank line]

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

शायद सबसे गोल्फ पद्धति नहीं है, लेकिन मैं इसे वैसे भी जमा करूंगा।

स्पष्टीकरण:

K`1A2B2C2D2E5F2GH3I1J1KL6M6NO2P4QR5S2T4U2VW5X3Y2Z

कार्य स्ट्रिंग सेट करें 1A2B2C2D2E5F2GH3I1J1KL6M6NO2P4QR5S2T4U2VW5X3Y2Z। एक समूह में प्रत्येक अक्षर से पहले एक संख्या है, उदाहरण के लिए A, Jऔर Kसभी उनके 1सामने हैं।

~(

कोड का एक भाग चिह्नित करें जो कुछ रेटिना कोड का उत्पादन करेगा, फिर इसे बाद में चलाएं।

K`123456

कार्य स्ट्रिंग सेट करें 123456

.
?O`$&.¶

प्रत्येक वर्ण को बदलें ?O`{character}.¶

)`¶$
[blank line]

अनुगामी न्यूलाइन निकालें और कोड उत्पन्न करने के लिए समूह को समाप्त करें। समूह कोड उत्पन्न करेगा:

?O`1.
?O`2.
?O`3.
?O`4.
?O`5.
?O`6.

{n}.एक वर्ण के बाद नंबर n के सभी उदाहरणों से मेल खाता है । ?Oप्रत्येक उदाहरण को बेतरतीब ढंग से क्रमबद्ध करें, और यह सभी वर्ण सेटों के लिए किया जाता है।

\d
[blank line]

अंत में, सभी नंबरों को हटा दें और उत्पन्न स्ट्रिंग को स्पष्ट रूप से आउटपुट करें।