17

काम पर हमारी एक परियोजना में, हमने हाल ही में एक 15 चरित्र वर्णमाला से 6 चरित्र स्ट्रिंग उत्पन्न करने के लिए एक विशेष रूप से बड़ी विधि की खोज की। हम में से कुछ ने दावा किया "मुझे यकीन है कि हम इसे एक पंक्ति में प्राप्त कर सकते हैं" जिसने कोड गोल्फ का थोड़ा आंतरिक खेल शुरू किया था।

आपका काम हमें हराना है, जिसमें मुझे कोई संदेह नहीं है कि इसमें लंबा समय नहीं लगेगा!

मूल एल्गोरिथ्म में वर्णमाला 0-9A-E का उपयोग किया गया था, लेकिन हमने अन्य वर्णमालाओं के साथ प्रयोग किया है। इसलिए तीन उपप्रकार हैं।

6बेतरतीब ढंग से हार्डकोड किए गए 15वर्ण वर्ण से चुनकर एक वर्ण स्ट्रिंग उत्पन्न करें ABC123!@TPOI098। (यह केवल एक उदाहरण है, और बाइट काउंट को प्रभावित किए बिना अनुकूलन योग्य होना चाहिए।)
एक उत्पन्न 6बेतरतीब ढंग से एक से चयन चरित्र स्ट्रिंग 15चरित्र वर्णमाला 0123456789ABCDE।
अपनी पसंद के वर्ण वर्ण (केवल मुद्रण योग्य वर्ण कृपया) 6से किसी वर्ण स्ट्रिंग को यादृच्छिक रूप से चुनें 15।

प्रत्येक पात्र को चयन की समान संभावना होनी चाहिए और पुनरावृत्ति संभव होनी चाहिए।

प्रत्येक उपकेंद्र के लिए हम सबसे अच्छा प्रबंधन कर सकते हैं:

"ABC123! @ TPOI098" - 24 bytes
"- I123456789ABCDE" - 21 bytes
कस्टम वर्णमाला - 13 bytes

आपका स्कोर प्रत्येक उपमा के समाधान में बाइट्स का योग है। यानी हमारा स्कोर फिलहाल 58 है।

हमने दूसरों, सीजम और रूबी के बीच प्रयोग करने का प्रयास किया है। मूल C # में था। अपनी पसंद की किसी भी भाषा का उपयोग करें, लेकिन हम विशेष रूप से इन भाषाओं में समाधान देखने के इच्छुक होंगे

code-golf generation

— जेम्स वेबस्टर
स्रोत

5

बहु-भाग चुनौतियों के बारे में। दुर्भाग्य से, मेरे पास इस मामले में एक अच्छा समाधान नहीं है, क्योंकि ये तीन उप-प्रकार इसके लिए बहुत समान हैं, क्योंकि यह उन्हें कई चुनौतियों में विभाजित करने के लिए समझ में आता है। मैं मल्टी-पार्टन चुनौतियों के लिए उस नीति के अपवाद को प्रस्तावित करने पर भी विचार कर रहा हूं, जहां उपकेंद्र एक ही चुनौती के मामूली बदलाव हैं। (हालांकि अभी भी यह समस्या है कि उप-समाधान अन्य उत्तरों से लिया जा सकता है।) इसलिए मैं इसे मॉड-हथौड़ा नहीं करूंगा, और यह देखूंगा कि समुदाय क्या सोचता है।

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

"आपका स्कोर बाइट्स का योग है ..." इसलिए मेरा पहला उदाहरण दुर्भाग्यपूर्ण है। मैं एक और संभावित उदाहरण के लिए संशोधन करूँगा

— जेम्स वेबस्टर

2

@MartinEnder मेरे 2 सेंट: मुझे लगता है कि यह ठीक है और VTC नहीं होगा। निश्चित रूप से, मुझे लगता है कि एक एकल दिलचस्प कार्य के साथ एक चुनौती बेहतर है, लेकिन चूंकि ये कार्य बहुत समान हैं, इसलिए यह "गोल्फ-कोर्स" की तुलना में बहुत बेहतर है जो कहता है "इन 8 यादृच्छिक असंबंधित कार्यों को करें।" भले ही कार्यों के बीच कोई बातचीत नहीं है, मेरी नजर में यह चुनौती गोल्फ के सभी 16 लॉजिक गेट्स से बहुत अलग नहीं है ।

— डीजेएमकेम

क्या कोई समय या स्मृति सीमाएं हैं? क्या उप-मुखियों को स्वतंत्र होना है या उन्हें कोड साझा करने की अनुमति है?

— डेनिस

2

क्या "एक स्ट्रिंग उत्पन्न करता है" का अर्थ है कि कोड को वास्तव में उसमें उपयुक्त वर्णों के साथ एक स्ट्रिंग मान उत्पन्न करना है, या छह वर्णों को आउटपुट करना है (स्थान या न्यूलाइन्स द्वारा अलग नहीं किया गया है) स्वीकार्य है?

— DLosc

6

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

TryItOnline लिंक एक , बी , और सी ।

एक :ABC123!@£POI09822 बाइट्स

“ABC123!@£POI098”Wẋ6X€

(यह कम करने के लिए एक संपीड़न के बारे में सोच)

बी :0123456789ABCDE8 बाइट्स:

ØHṖWẋ6X€

सी :123456789ABCDEF(पसंद), 8 बाइट्स:

ØHḊWẋ6X€

कैसे?

...Wẋ6X€ - common theme
   W     - wrap (string) in a list
    ẋ6   - repeat six times
      X€ - random choice from €ach

ØH...... - hexadecimal digit yield: "0123456789ABCDEF"

..Ṗ..... - pop: z[:-1] (B)

..Ḋ..... - dequeue: z[1:] (C)

— जोनाथन एलन
स्रोत

8

सीजाम (23 + 14 + 10 = 47 बाइट्स)

मनमाना वर्णमाला: 23 बाइट्स ( ऑनलाइन डेमो )

{"ABC123!@TPOI098"mR}6*

हेक्साडेसिमल वर्णमाला: 14 बाइट्स ( ऑनलाइन डेमो )

{FmrAbHb'0+}6*

कस्टम वर्णमाला: ABCDEFGHIJKLMNO10 बाइट्स ( ऑनलाइन डेमो )

{Fmr'A+}6*

विच्छेदन

हेक्साडेसिमल एक दिलचस्प है:

{      e# Loop...
  Fmr  e#   Select a random number from 0 to 14
  AbHb e#   Convert to base 10 and then to base 17
       e#   (i.e. add 7 if the number is greater than 9)
  '0+  e#   Add character '0' (i.e. add 48 and convert from integer to character)
       e#   Note that 'A' - '0' = 17
}6*    e# ...six times

छह पात्रों को ढेर पर छोड़ दिया जाता है और स्वचालित रूप से मुद्रित किया जाता है।

— पीटर टेलर
स्रोत

2

AbHbशानदार है। मैंने उस सामान्य दृष्टिकोण के बारे में सोचा लेकिन _9>7*+वह बहुत लंबा था।

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

6

पर्ल, 46 + 26 + 26 = 98 बाइट्स

13 बाइट बचाने के लिए @Dom हेस्टिंग्स को बहुत सारा श्रेय जाता है !

परिवर्तन के वर्णमाला को छोड़कर 3 कार्यक्रम बहुत अधिक समान हैं।

हार्डकोड वर्णमाला ( ABC123!@)POI098इस उदाहरण में) -> 46 बाइट्स:

say map{substr"ABC123!@)POI098",15*rand,1}1..6
निश्चित वर्णमाला 0123456789ABCDE-> 26 बाइट्स:

printf"%X",rand 15for 1..6
0123456789ABCDEउस मामले में कस्टम वर्णमाला -> 26 बाइट्स:

printf"%X",rand 15for 1..6

आप उन्हें चलाने के लिए एक फ़ाइल में रख सकते हैं:

$ cat 6chr_strings.pl
say map{substr"ABC123!@)POI098",15*rand,1}1..6;
say "";
printf"%X",rand 15for 1..6;
say "";
printf"%X",rand 15for 1..6;
say "";
$ perl -M5.010 6chr_string.pl
CB8!8!
24D582
9ED58C

( say "";आउटपुट फॉर्मेट को बेहतर बनाने के लिए यहां हैं)

— बापू
स्रोत

2

अच्छा जवाब! मेरे पास पहले और आखिरी के लिए बहुत समान था, लेकिन आप एक बाइट का उपयोग करके बचा सकते हैं say: say map{("ABC123!@)POI098"=~/./g)[rand 15]}1..6और say map{(A..O)[rand 15]}1..6। दूसरे के लिए आप उपयोग कर सकते हैं printf: printf"%X",rand 15for 1..611 को बचाने के लिए! मुझे यकीन है कि टन कुछ रहस्यमय जादू पर सलाह दे सकता है ताकि अधिक भी बचा सके!

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

1

वास्तव में कस्टम वर्णमाला के साथ substrएक और बचाता है:say map{substr"ABC123!@)POI098",15*rand,1}1..6

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

1

@DomHastings हम्म, वास्तव में, यह अच्छा है, अच्छी तरह से खेला जाता है! धन्यवाद :-)

— दादा १ '

2

मुझे यह पसंद है कि आपने कोड को सीधा होने के बारे में नोट हटा दिया: D

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

@DomHastings के साथ printf"%X", substr..randऔर map, यह थोड़ा कम स्पष्ट है, इसलिए मैंने लोगों को बिना किसी बिगाड़ने वाले जादू का आनंद लेने दिया! :

— दादा

4

आर, 33 + 43 + 59 = 135 बाइट्स

मनमाने ढंग से कोडित वर्णमाला (वर्णमाला बदलने के लिए स्ट्रिंग बदलें):

cat(sample(strsplit("ABC123!@TPOI098","")[[1]],6,1),sep="")

की वर्णमाला [0-9A-E]:

cat(sample(c(0:9,LETTERS[1:6]),6,1),sep="")

स्टड से उपयोगकर्ता-परिभाषित वर्णमाला:

cat(sample(scan(,''),6,1),sep="")

सभी मामले आउटपुट शब्द को stdout में प्रिंट करते हैं।

— rturnbull
स्रोत

4

जावास्क्रिप्ट (ईएस 6), 167 166 164 163 बाइट्स

नील
बचे 2 बाइट की बदौलत
1 बाइट की बचत

हार्डकोड: "ABC123!@TPOI098" (58 बाइट्स)

f=(n=6)=>n?"ABC123!@TPOI098"[Math.random()*15|0]+f(n-1):''

फिक्स्ड: "0123456789ABCDE" ( 58 57 बाइट्स)

f=(n=6)=>n?f(n-1)+("ABCDE"[n=Math.random()*15|0]||n-5):''

कस्टम: "()+.1=>?M[afhnt" ( ५१ ४ ९ ४ : बाइट्स)

f=(n=6)=>n?(f+1)[Math.random()*15|0+5]+f(n-1):''

— Arnauld
स्रोत

1

(n=6)=>n?f(n-1)+("ABCDE"[n=Math.random()*15|0]||n-5):''आपको एक बाइट बचाता है।

— नील

1/8+Mathमहान है :)

— ETHproductions

लेकिन .1+JSONबेहतर है;)

— ETHproductions

1

या JSON+f( [object JSON](n=> " (JNOS[]bcejnot")

— ETHproductions

@ETHproductions अच्छा लगा। :)

— अरनौलड

3

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

कस्टम वर्णमाला: 66 बाइट्स

_=>"......".replace(/./g,c=>"ABC123!@TPOI098"[Math.random()*15|0])

0-9 ए-ई: 63 बाइट्स

_=>"......".replace(/./g,c=>"ABCDE"[n=Math.random()*15|0]||n-5)

0-9 ए-ई: 55 बाइट्स

_=>(Math.random()*11390625+1e8|0).toString(15).slice(1)

(दिनांक-आधारित यादृच्छिकता अनुमेय होने पर 6 बाइट घटाएं।)

— नील
स्रोत

आप एक बाइट को अंतिम एक पर बचा सकते हैं **:_=>((Math.random()+1)*15**6|0).toString(15).slice(1)

— ETHproductions

@ETHproductions निश्चित रूप से यह ES6 के बजाय ES7 बना देगा? (इसके अलावा, यह मेरे लिए एक 3-बाइट की बचत की तरह दिखता है।)

— नील

हां, और यह 3 बाइट्स को बचाने के लिए प्रकट होता है। मैंने f=बाइट काउंट में शामिल किया होगा

— ETHproductions

3

क्यू, 42 बाइट्स

ए

19 बाइट्स

6?"ABC123!@TPOI098"

बी

14 बाइट्स

6?15#.Q.n,.Q.A

सी

9 बाइट्स

6?15#.Q.a

(वर्णमाला के पहले पंद्रह अक्षरों का उपयोग करता है)

— skeevey
स्रोत

3

जूलिया (36 + 26 + 21 = 83)

join(rand(["ABC123!@TPOI098"...],6))

base(15,rand(15^6:15^7-1))

join(rand('a':'o',6))

— लिंडन व्हाइट
स्रोत

2

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

मनमाना वर्णमाला, 23 बाइट्स:

{"ABC123!@TPOI098"mR}6*

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

हेक्स अंक, 15 बाइट्स:

{A,'F,65>+mR}6*

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

वर्णमाला ABCDEFGHIJKLMNO, 10 बाइट्स:

{Fmr'A+}6*

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

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

मेरा बुरा विचार था। अगर हम U + FFFE को एक चरित्र मानते हैं, तो ~cबदले में 'A+तकनीकी रूप से कुछ प्रिंट करने योग्य है।

— jimmy23013

शायद मैं गलत हूँ। मुझे मुद्रण योग्य यूनिकोड वर्णों की परिभाषा नहीं मिली।

— jimmy23013

2

रूबी 47 + 37 + 31 = 115

हार्डकोड: "ABC123! @ TPOI098" (47)

(1..6).map{"5CABC123!@TPOI098".chars.sample}*''

फिक्स्ड: "0123456789ABCDE" (37)

(1..6).map{[*0..9,*?A..?E].sample}*''

कस्टम: "ABCDEFGHIJKLMNO" (31)

(1..6).map{[*?A..?O].sample}*''

— माइकल कोहल
स्रोत

1

05AB1E , 43 बाइट्स

पंचाट वर्णमाला ( ABC123!@TPOI098), 23 बाइट्स इसे ऑनलाइन आज़माएं

"ABC123!@TPOI098"6F.r¬?

लगभग हेक्साडेसिमल वर्णमाला ( 0123456789ABCDE), 10 बाइट्स इसे ऑनलाइन आज़माएं

14Ýh6F.r¬?

कस्टम वर्णमाला ( abcdefghijklmno), 10 बाइट्स इसे ऑनलाइन आज़माएं

A15£6F.r¬?

— Emigna
स्रोत

1

पायथन 2, 70 + 70 + 64 = 204 बाइट्स

from random import*
s=""
exec"s+=choice('ABC123!@TPOI098');"*6
print s

from random import*
s=""
exec"s+=choice('0123456789ABCDE');"*6
print s

from random import*
s=""
exec"s+=chr(randint(65,80));"*6
print s

दुर्भाग्य से, दूसरा उदाहरण पहली विधि के साथ कुछ की तुलना में आसान है choice([randint(48,57)),choice(65,69)])

— कार्ल नेफ
स्रोत

आप क्यों इस्तेमाल करते हैं from random import*? मुझे लगता है कि आप उपयोग कर सकते हैं import randomऔर random.choiceकम से कम पहले दो उदाहरणों में।

— रोमन गार्फ

import random random.choice27 है, लेकिन from random import* choice26 है, यह भी import random as r r.choice27 है

— कार्ल नेपफ

हेक्स मामले के लिए, हम उपयोग करके थोड़ा बेहतर कर सकते हैं format(randrange(8**8),'X'), मुझे लगता है।

— DSM

@DSM समस्या है, वहाँ नहीं होना चाहिएF

— कार्ल Napf

1

विटसी, 27 + 24 22 + 13 10 = 64 62 59 बाइट्स

# 1:

"ABC123!@TPOI098"6\[eR2+@O]

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

# 2:

aH7+D4+H6\[eR2+@68*+O]

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

# 3:

6\[eR5F-O]

जहां उपलब्ध वर्ण हैं:

ﾖﾕﾔﾓﾒﾑﾐﾏﾎﾍﾌﾋﾊﾉﾈ

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

— एडिसन क्रम्प
स्रोत

1

जे, 24 + 24 + 18 10 = 58 बाइट्स

8 बाइट्स मीलों की बदौलत बच गए!

'ABC123!@TPOI098'{~?6#15
'0123456789ABCDE'{~?6#15
u:65+?6#15

हाँ, दूसरा तार आसानी से J में संपीड़ित नहीं है:

u:47+23#.inv 12670682677028904639x
u:47+;(+i.@])/"1&.>1 10;18 5
('ABCDE',~1":i.10)
(toupper,hfd?6#15)
'0123456789ABCDE'

अगर एक लोअरकेस हेक्स वर्णमाला ठीक है, तो वहां है ,hfd?6#15 9 बाइट्स लिए @miles के रूप में उल्लेख किया गया है।

किसी भी तरह, ?6#150 और 15 के बीच 6 यादृच्छिक संख्या है; {~से है।u:संख्या को चार्ट में परिवर्तित करता है। अंतिम उदाहरण एनकोड करता हैABCDEFGHIJKLMNOP ।

बोनस: सामान्य मामला

{~6?@##

{~6?@## लगभग है:

{~6?@##  input: y
      #  length of y
  6  #   six copies of the length
   ?@    random numbers between 0 and the length
{~       taken from y

— कोनोर ओ ब्रायन
स्रोत

दूसरे मामले पर, वहाँ नामित अंतर्निहित है hfdजो करने के लिए धर्मान्तरित ज पूर्व च रॉम घ ecimal। आप एक 9 बाइट समाधान का उपयोग करके प्राप्त कर सकते हैं ,hfd?6#15। आखिरी मामला, बस कुछ आसानी से पढ़ने के लिए, 'A'10 बाइट समाधान के लिए वर्णमाला का उपयोग करता है u:65+?6#15, जिससे कुल 24 + 9 + 10 = 45 होता है।

— मीलों

@ मीलों मुझे लगता है कि दूसरे मामले में बड़े अक्षरों की आवश्यकता है। पिछले मामले के रूप में ... हाहा, उफ़। मैं पूरी तरह से वेक्टराइज्ड जोड़ के बारे में भूल गया।

— कॉनर ओ'ब्रायन

1

PHP, 46 + 36 + 35 = 117 बाइट्स

हार्डकोड (46 बाइट्स)

for(;$i++<6;)echo"ABC123!@TPOI098"[rand()%15];

~~(47 बाइट्स)~~

~~for(;$i++<6;)echo"ABC123!@TPOI098"[rand(0,14)];~~

हेक्साडेसिमल (लोअरकेस) (36 बाइट्स)

for(;$j++<6;)echo dechex(rand()%15);

अपरकेस के लिए, हार्डकोड संस्करण के साथ 46 बाइट्स।

कस्टम (AO) (35 बाइट्स)

for(;$k++<6;)echo chr(rand(65,79));

— क्रिप्टो
स्रोत

मुझे नहीं लगता कि मैं आपका दूसरा भाग स्वीकार कर सकता हूं। AE AE के समान नहीं है

— जेम्स वेबस्टर

0

स्काला, 154 बाइट्स

हार्डकोड वर्णमाला (54 बाइट्स):

Seq.fill(6)("ABC123!@TPOI098"((math.random*14).toInt))

हेक्स वर्णमाला (54 बाइट्स):

Seq.fill(6)("0123456789ABCDE"((math.random*14).toInt))

कस्टम वर्णमाला ABCDEFGHIJKLMNO(47 बाइट्स):

Seq.fill(6)(('A'to'O')((math.random*14).toInt))

स्पष्टीकरण:

Seq.fill(6)(               //build a sequence of 6 elements, where each element is...
  "ABC123!@TPOI098"(         //from the string
    (math.random*14).toInt   //take a random char
  )
)

'A'to'O' 15 वर्णों का अनुक्रम बनाता है, ए से ओ

— corvus_192
स्रोत

0

पिप , 42 बाइट्स

हार्डकोड वर्णमाला, 22 बाइट्स:

L6ORC"ABC123!@TPOI098"

हेक्स अंक, 11 बाइट्स:

L6ORR15TB16

पहले 15 लोअरकेस अक्षर, 9 बाइट्स:

L6Oz@RR15

व्याख्या

सभी तीन कार्यक्रम L6O6 बार लूप के साथ शुरू होते हैं और दिए गए एक्सप्रेशन को आउटपुट करते हैं।

RC"...": हार्ड-कोडेड स्ट्रिंग से एक वर्ण का यादृच्छिक विकल्प
RR15TB16: RandRange (15), बेस 16 में परिवर्तित
z@RR15: लोअरकेस वर्णमाला z, RandRange के साथ अनुक्रमित (15)

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

— DLosc
स्रोत

0

स्क्रीप्ट / स्काइक , 108 बाइट्स

हार्डकोड (43 बाइट्स):

random 6 char string from `A@cD%F3h9JK{mN!`

0123456789ABCDE (34 बाइट्स):

random 6 char string from `0-9A-E`

विकल्प (31 बाइट्स):

random 6 char string from `A-M`

— ओलिवर नी
स्रोत

क्या आप उद्घाटन `को बाईं ओर ले जा सकते हैं ?

— एडिसन क्रम्प

@VTCAKAVSMoACE नहीं, यह आपको

— ओलिवर नी

0

जोल्फ, 26 + 14 + 13 = 51 बाइट्स

Μ*S6d rG"ABC123!@TPOI098"E

कस्टम वर्णमाला, 24 बाइट्स। यहाँ यह कोशिश करो!

Μ*S6d r lp^0wά

0-9 ए-ई वर्णमाला, 14 बाइट्स। यहाँ यह कोशिश करो! lp^0wάहै lp(0-जेड) कटा हुआ ( l) से 0करने के लिए 15( wά)।

Μ*S6d r lp^1ά

1-9 ए-एफ वर्णमाला, 13 बाइट्स। यहाँ यह कोशिश करो! lp^1άसे छोड़कर, ऊपर के रूप में ही है 1करने के लिए 16।

सामान्य विधि:

Μ*S6d r
M*S6d      map six newlines over this function:
      r    select random element from array.

अन्य प्रयास (स्ट्रिंग संपीड़न का उपयोग करके):

Μ*S6d rGμpwΞ $AE

— कोनोर ओ ब्रायन
स्रोत

0

PowerShell v2 +, 45 + 44 + 37 = 126 बाइट्स

निश्चित वर्णमाला, 45 बाइट्स

-join(0..5|%{'ABC123!@TPOI098'[(Random)%15]})

लगभग हेक्साडेसिमल वर्णमाला, 44 बाइट्स

-join[char[]](0..5|%{Random(48..57+65..69)})

कस्टम वर्णमाला (ए से ओ), 37 बाइट्स

-join[char[]](0..5|%{Random(65..79)})

ये सभी एक ही पैटर्न का पालन करते हैं - पाश से 0लेकर 5, प्रत्येक पुनरावृत्ति एक Randomचरित्र या ASCII मान का चयन करते हुए , कि charयदि आवश्यक हो, तो एक- सरणी के रूप में कास्टिंग करें और -joinइसे एक स्ट्रिंग में एक साथ सम्मिलित करें । उस तार को पाइप लाइन पर छोड़ दिया गया है, और आउटपुट निहित है।

उदाहरण

PS C:\Tools\Scripts\golfing> -join(0..5|%{'ABC123!@TPOI098'[(Random)%15]})
32ATB3

PS C:\Tools\Scripts\golfing> -join(0..5|%{'ABC123!@TPOI098'[(Random)%15]})
III@B2

PS C:\Tools\Scripts\golfing> -join(0..5|%{'ABC123!@TPOI098'[(Random)%15]})
@302O@

PS C:\Tools\Scripts\golfing> -join[char[]](0..5|%{Random(48..57+65..69)})
74E117

PS C:\Tools\Scripts\golfing> -join[char[]](0..5|%{Random(48..57+65..69)})
09D7DD

PS C:\Tools\Scripts\golfing> -join[char[]](0..5|%{Random(65..79)})
COJDFI

PS C:\Tools\Scripts\golfing> -join[char[]](0..5|%{Random(65..79)})
EAKCNJ

— AdmBorkBork
स्रोत

-1

पाइके, 35 बाइट्स

आर्बिटरी वर्णमाला, 20 बाइट्स

6V"ABC123!@TPOI098"H

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

हेक्स वर्णमाला, 8 बाइट्स

6V~J15<H

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

~J15< - "0123456789abcdefghijklmno..."[:15]

कस्टम वर्णमाला, 7 बाइट्स

6VG15<H

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

G15< - alphabet[:15]

वर्णमाला चुना गया: abcdefghijklmno

6V     - repeat 6 times:
  ...  -   get alphabet
     H -  choose_random(^)

— नीला
स्रोत

ऐसा लगता है कि 6-लाइन स्ट्रिंग के बजाय न्यूलाइन द्वारा अलग किए गए 6 वर्णों को आउटपुट करना है।

— एमिग्ना

प्रश्न आउटपुट फॉर्मेट को नहीं बताता है।

— ब्लू

मैं शब्दों को देखता हूं कि विनिर्देश में 4 स्थानों में एक 6 चरित्र स्ट्रिंग उत्पन्न करें ।

— एमिग्ना

15 वर्ण वर्णमाला से 6 वर्ण स्ट्रिंग उत्पन्न करें

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

कैसे?

सीजाम (23 + 14 + 10 = 47 बाइट्स)

विच्छेदन

पर्ल, 46 + 26 + 26 = 98 बाइट्स

आर, 33 + 43 + 59 = 135 बाइट्स

जावास्क्रिप्ट (ईएस 6), 167 166 164 163 बाइट्स

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

क्यू, 42 बाइट्स

जूलिया (36 + 26 + 21 = 83)

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

05AB1E , 43 बाइट्स

पायथन 2, 70 + 70 + 64 = 204 बाइट्स

विटसी, 27 + 24 22 + 13 10 = 64 62 59 बाइट्स

जे, 24 + 24 + 18 10 = 58 बाइट्स

बोनस: सामान्य मामला

PHP, 46 + 36 + 35 = 117 बाइट्स

हार्डकोड (46 बाइट्स)

हेक्साडेसिमल (लोअरकेस) (36 बाइट्स)

कस्टम (AO) (35 बाइट्स)

स्काला, 154 बाइट्स

पिप , 42 बाइट्स

व्याख्या

स्क्रीप्ट / स्काइक , 108 बाइट्स

जोल्फ, 26 + 14 + 13 = 51 बाइट्स

PowerShell v2 +, 45 + 44 + 37 = 126 बाइट्स

उदाहरण

पाइके, 35 बाइट्स

आर्बिटरी वर्णमाला, 20 बाइट्स

हेक्स वर्णमाला, 8 बाइट्स

कस्टम वर्णमाला, 7 बाइट्स