रीडिंग पर सवारी करें, यदि आप गो पास करते हैं, तो $ 200 जमा करें

Question

एकाधिकार मंडल

इस कोड-गोल्फ चुनौती के लिए हम बोर्ड गेम एकाधिकार का निर्माण करेंगे।

नियम:

• कोई इनपुट न लें।
• एक 11x11 बोर्ड का आउटपुट जहां बोर्ड बनाने वाला प्रत्येक ASCII चरित्र मोनोपॉली बोर्ड के यूएस संस्करण के प्रत्येक स्थान का पहला अक्षर है।
• पात्रों को रिक्त स्थान द्वारा अलग किया जाना चाहिए।
• Go नीचे दाईं ओर से शुरू होना चाहिए।

उत्पादन करने के लिए सटीक स्ट्रिंग है

F K C I I B A V W M G 
N                   P
T                   N
C                   C
S                   P
P                   S
V                   C
S                   P
E                   L
S                   B
J C V C O R I B C M G 

ध्यान दें कि नीचे दाईं ओर से नीचे बाईं ओर वर्ग निम्नानुसार हैं:

G --> Go
M --> Mediterranean Avenue
C --> Community Chest
B --> Baltic Avenue
I --> Income Tax
...
J --> Jail

संपादित वाह! तुम लोगों को यकीन है कि यह एक पसंद आया! :)

Comments

मेरा मतलब नहीं है कि मैं एक स्टिकलर हूं लेकिन ... बोर्डवॉक को आगे बढ़ाते हुए एक व्यक्ति कैसे गुजरता है?

— Sp3000

यदि आप बोर्डवॉक पर हैं :)

— जैक्सनसेक

यदि आप बोर्डवॉक पर हैं, तो आपको मौका कार्ड नहीं मिल सकता है :(

— jacksonecac

मैंने आप सभी को विफल कर दिया

— जैक्सनसेक

अनुगामी रिक्त स्थान की अनुमति है?

— अदनान

Answer 1

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

FKCIIBAVWMGN_PT_NC_CS_PP_SV_CS_PE_LS_BJCVCORIBCMG
S_`(._.)
_
9$*
\B

1

तीसरी से अंतिम और अंतिम पंक्तियों में एक एकल स्थान होना चाहिए।

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

व्याख्या

FKCIIBAVWMGN_PT_NC_CS_PP_SV_CS_PE_LS_BJCVCORIBCMG

यह दूसरी पंक्ति पर स्ट्रिंग के साथ (खाली) इनपुट को बदलता है।

S_`(._.)

यह स्प्लिट स्टेज है, जो रेगेक्स के मैचों के चारों ओर स्ट्रिंग को विभाजित करता है (._.)(यानी, _बीच में कोई भी तीन अक्षर )। पूरे रेगेक्स को एक समूह में रखने का कारण यह है कि विभाजित चरण भी कैप्चरिंग समूहों के परिणाम लौटाते हैं। जैसे abcdइधर-उधर फूटना bcदेता है [a, d], लेकिन इधर-उधर बिखरना b(c)देता है [a, c, d]। इस तरह हम सभी ._.भागों को अलग-अलग रेखाओं पर आरंभ और अंत में 11-वर्ण भागों में भी प्राप्त करते हैं। हम _व्यक्तिगत ._.मैचों के बीच खाली परिणामों को छोड़ने के लिए विकल्प का उपयोग करते हैं । परिणाम यह होगा:

FKCIIBAVWMG
N_P
T_N
C_C
S_P
P_S
V_C
S_P
E_L
S_B
JCVCORIBCMG

अगला हम अंडरस्कोर की प्रक्रिया करते हैं:

_
9$*

यह प्रत्येक अंडरस्कोर को नौ 1एस के साथ बदल देता है । 1तुरंत स्थान के बजाय हम यहाँ का उपयोग करते हैं , यह अगले पैडिंग स्पेस को सम्मिलित करना आसान बनाता है।

\B

याद रखें कि दूसरी पंक्ति में एक जगह है। यह हर स्थिति में एक स्थान सम्मिलित करता है जो एक शब्द सीमा नहीं है, अर्थात् हर जगह और शुरुआत और अंत में।

1

और अंत में, हम उन सभी 1को स्पेस के साथ बदल देते हैं ।

Comments

अच्छी नौकरी! यह तेज़ था!

— जैक्सनसेक

के लिए +1 (._.)।

— विनाशकारी नींबू

^ अभी कहने ही वाली थी कि

— आह्हा

Answer 2

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

“£ċ9NɲT⁴MỵƇñdMỊḞ*µ7Sʂɓ¢Ż}ạ¥ċwÞ’ḃ23ṣ4ịØAz⁶ṙ1G

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

विचार

यदि हम हर दूसरे कॉलम को हटाते हैं और कॉलम के साथ पंक्तियों को स्थानांतरित करते हैं, तो हमें निम्नलिखित बोर्ड मिलते हैं।

FNTCSPVSESJ
K         C
C         V
I         C
I         O
B         R
A         I
V         B
W         C
M         M
GPNCPSCPLBG

अब, हम प्रत्येक कॉलम को एक इकाई को दाईं ओर घुमा सकते हैं, शेष सभी रिक्त स्थान को दाईं ओर ले जा सकते हैं।

JFNTCSPVSES
KC         
CV         
IC         
IO         
BR         
AI         
VB         
WC         
MM         
GGPNCPSCPLB

फिर, हम शेष रिक्त स्थान को हटाते हैं और डी के साथ लाइनफीड को डी अक्षर से प्रतिस्थापित करते हैं ।

JFNTCSPVSESDCKDVCDCIDOIDRBDIADBVDCWDMMDGGPNCPSCPLB

अब, हम प्रत्येक अक्षर को उसके 1-आधारित सूचकांक के साथ वर्णमाला में बदल देते हैं।

10  6 14 20  3 19 16 22 19  5 19  4  3 11  4 22  3  4  3  9  4 15  9  4 18
 2  4  9  1  4  2 22  4  3 23  4 13 13  4  7  7 16 14  3 16 19  3 16 12  2

फिर, हम इस अंक सरणी को विशेषण आधार 23 से पूर्णांक में परिवर्तित करते हैं ।

54580410997367796180315467139871590480817875551696951051609467717521

अब, हम इस पूर्णांक को विशेषण आधार 250 में बदल देते हैं ।

  2 232  57  78 163  84 132  77 228 144  27 100  77 176 195
 42   9  55  83 167 155   1 210 125 211   4 232 119  20

अंत में, हम इन अंकों का उपयोग जेली के कोड पृष्ठ में अनुक्रमित करने के लिए करते हैं ।

£ċ9NɲT⁴MỵƇñdMỊḞ*µ7Sʂɓ¢Ż}ạ¥ċwÞ

यह एन्कोडेड डेटा है जिसे हम प्रोग्राम ( 29 बाइट्स ) में शामिल करेंगे । वांछित आउटपुट का उत्पादन करने के लिए, हमें बस ऊपर दिए गए चरणों को उल्टा करना होगा।

कोड

“£ċ9NɲT⁴MỵƇñdMỊḞ*µ7Sʂɓ¢Ż}ạ¥ċwÞ’ḃ23ṣ4ịØAz⁶ṙ1G  Main link. No arguments.

“£ċ9NɲT⁴MỵƇñdMỊḞ*µ7Sʂɓ¢Ż}ạ¥ċwÞ’               Convert the string from bijective
                                              base 250 (using the indices in
                                              Jelly's code page) to integer.
                               ḃ23            Convert that integer to bijective
                                              base 23.
                                  ṣ4          Split the resulting array at
                                              occurrences of 4.
                                    ịØA       Replace the remaining digits in the
                                              resulting 2D array with the
                                              corresponding uppercase letters.
                                       z⁶     Zip/transpose rows and columns,
                                              padding shorter rows with spaces.
                                         ṙ1   Rotate the rows one unit down.
                                           G  Grid; join rows by spaces, columns
                                              by linefeeds.

Comments

विस्तृत विवरण के लिए धन्यवाद। गोल्फ सवालों के जवाब के पीछे की प्रक्रिया को देखना हमेशा दिलचस्प होता है। :)

— XtraSimplicity

कोड गोल्फ - जहां आधार 250 और आधार 23 में एक संख्या को देखना पूरी तरह से सामान्य है।

— corsiKa

अच्छा संपीड़न तकनीक। ट्रांसपोज़िंग क्यों ज़रूरी है?

— ETHproductions

@ETHproductions जेली में पैडिंग एटम नहीं होता है, इसलिए मैं या तो सभी पंक्तियों को एक ही लंबाई के रिक्त स्थान के साथ मैन्युअल रूप से पैड कर सकता हूं या zएक भराव के साथ डाइएडिक जिप ( ) का उपयोग कर सकता हूं ।

— डेनिस

Answer 3

05AB1E , 48 47 बाइट्स

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

•(K·;“…¬È¦z"9äuŸé;TÞîÕs‡ÓÐV9XÒt\<•33B¾9ð×:S11ô»

स्पष्टीकरण:

पहले कुछ संपीड़न। •(K·;“…¬È¦z"9äuŸé;TÞîÕs‡ÓÐV9XÒt\<•निम्नलिखित संख्या का एक संकुचित संस्करण है:

120860198958186421497710412212513392855208073968557051584380118734764403017

उसके बाद, इसे आधार 33 में बदल दिया जाता है , जिसके परिणामस्वरूप निम्न स्ट्रिंग होती है:

FKCIIBAVWMGN0PT0NC0CS0PP0SV0CS0PE0LS0BJCVCORIBCMG

निम्न कोड का उपयोग करके शून्य को 9 स्थानों से बदल दिया जाता है ¾9ð×:। उसके बाद, हम Sस्ट्रिंग को पात्रों में बांधते हैं और उन्हें 11 तत्वों के टुकड़ों में काटते हैं (साथ किया जाता है 11ô)। हमें निम्न 2-आयामी सरणी मिलती है:

[['F', 'K', 'C', 'I', 'I', 'B', 'A', 'V', 'W', 'M', 'G'], 
 ['N', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', 'P'], 
 ['T', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', 'N'], 
 ['C', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', 'C'], 
 ['S', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', 'P'], 
 ['P', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', 'S'], 
 ['V', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', 'C'], 
 ['S', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', 'P'], 
 ['E', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', 'L'], 
 ['S', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', 'B'], 
 ['J', 'C', 'V', 'C', 'O', 'R', 'I', 'B', 'C', 'M', 'G']]

हम इस एरे को ग्रिड से जोड़ते हैं» और इसे अनुमानित रूप से आउटपुट करते हैं।

CP-1252 एन्कोडिंग का उपयोग करता है । इसे ऑनलाइन आज़माएं!

Comments

D के बजाए 0 के साथ तुलना करने पर बाइट •(K·;“…¬È¦z"9äuŸé;TÞîÕs‡ÓÐV9XÒt\<•33B¾9ð×:S11ô»

— बचती है

@Eigna आह, यह चतुर है! धन्यवाद :)।

— अदनान

Answer 4

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

l='%s '*11+'\n'
print(l+'%s%20s\n'*9+l)%tuple("FKCIIBAVWMGNPTNCCSPPSVCSPELSBJCVCORIBCMG")

टेम्पलेट बनाता है

? ? ? ? ? ? ? ? ? ? ? 
?                   ?
?                   ?
?                   ?
?                   ?
?                   ?
?                   ?
?                   ?
?                   ?
?                   ?
? ? ? ? ? ? ? ? ? ? ? 

स्ट्रिंग स्वरूपण के माध्यम से अक्षरों में स्थानापन्न करना। टेम्पलेट दो प्रकार की लाइनों का उपयोग करता है:

• lपत्र-प्लस-स्पेस की 11 प्रतियों की बाहरी रेखा , फिर एक नई रेखा । इसका उपयोग पहली और अंतिम पंक्ति के लिए भी किया जाता है। इसमें एक अनुगामी स्थान है।
• एक चरित्र की आंतरिक रेखा, फिर एक चरित्र गद्दी स्थानों के 19 पात्रों से पहले, फिर एक नई रेखा। इसे केंद्र की रेखाओं के लिए 9 बार कॉपी किया गया है।

पायथन 3.5 टपल अनपैकिंग के साथ एक बाइट बचा सकता है (*'...',)।

Comments

पायथन 3.5 पर स्विच करने से एक बाइट बचनी चाहिए।

— डेनिस

Answer 5

PowerShell v2 +, 131 123 114 110 99 बाइट्स

'F K C I I B A V W M G
N0P
T0N
C0C
S0P
P0S
V0C
S0P
E0L
S0B
J C V C O R I B C M G'-replace0,(" "*19)

यह सिर्फ एक छोटे से साथ, पाइप लाइन पर रखा नई-पंक्तियों के साथ एक शाब्दिक स्ट्रिंग है -replaceअंत में चालू करने के लिए 0में 19रिक्त स्थान। पहली और आखिरी पंक्तियाँ सिर्फ शब्दशः हैं। केवल 10 रिक्त स्थान और थोड़े से पुनरावृत्ति के साथ, उन्हें गोल्फ के लिए पर्याप्त जगह नहीं मिली। इस स्ट्रिंग को पाइपलाइन पर छोड़ दिया गया है, और निहितार्थ के माध्यम से आउटपुट Write-Outputकार्यक्रम पूरा होने पर होता है।

PS C:\Tools\Scripts\golfing> .\take-a-ride-on-reading.ps1
F K C I I B A V W M G
N                   P
T                   N
C                   C
S                   P
P                   S
V                   C
S                   P
E                   L
S                   B
J C V C O R I B C M G

Answer 6

जावास्क्रिप्ट ईएस 6 आरईपीएल , 105 102 101 बाइट्स

यहाँ बहुत दिलचस्प नहीं हो रहा है। वांछित परिणाम देखने के लिए कंसोल में पेस्ट करें

@ बर्न के लिए 3 बाइट्स धन्यवाद @Arnauld
सहेजे गए 1 अधिक बाइट धन्यवाद

`FKCIIBAVWMG
N P
T N
C C
S P
P S
V C
S P
E L
S B
JCVCORIBCMG`.replace(/.( ?)/g,`$& `+`$1`.repeat(17))

a.innerHTML = 

`FKCIIBAVWMG
N P
T N
C C
S P
P S
V C
S P
E L
S B
JCVCORIBCMG`.replace(/.( ?)/g,`$& `+`$1`.repeat(17))

<pre id=a>

Comments

मुझे नहीं लगता कि REPL की अनुमति है।

— NoOneIsHere

@NoOneIsHere meta.codegolf.stackexchange.com/a/7844/8478

— मार्टिन

मैं एक और बाइट दाढ़ी बनाने में कामयाब रहा। 1एस को रिक्त स्थान के साथ बदलें और इसके बजाय इस regexp का उपयोग करें:.replace(/.( ?)/g,`$& `+`$1`.repeat(17))

— नील

एक और बाइट को शेव करने का एक अलग तरीका यह है कि 1एस को रिक्त स्थान के साथ बदलें और इस फ़ंक्शन का उपयोग करें:a=>a-1?a.repeat(18):a+' '

— ETHproductions

@ धन्यवाद, अपने दृष्टिकोण से प्यार है!

— बैसड्रॉप कंबरवुबवबूब

Answer 7

/// , 100 98 बाइट्स

/s/    //p/ssss   //q/pC
SpP
//!/ C /F K!I I B A V W M G 
NpP
TpN
CqPpS
VqEpL
SpB
J!V!O R I B!M G 

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

कुछ रहस्यमय कारणों से, Gएस के बाद रिक्त स्थान होने लगते हैं । उनके बिना, मेरा कोड 96 बाइट्स होता।

1 बाइट कम करने के लिए 42545 (ETHproductions) और 56258 (daHugLenny) को धन्यवाद !

Comments

@ETHproductions गलत लिंक हो सकता है? मैं उस तरह से किसी भी बाइट को नहीं बचा सकता।

— एरिक Outgolfer

क्या यह 98 बाइट्स नहीं है यदि आप Gपहली और आखिरी लाइन पर s के बाद स्पेस हटाते हैं ?

— एमिग्ना

@ अतिरिक्त स्थानों के बारे में पूरी चर्चा।

— आउटगॉल्फ

@Emigna मुझे पता है, लेकिन सटीक आउटपुट में उन्हें शामिल किया गया है, इसलिए मैं उन्हें नहीं हटाऊंगा।

— आउटगॉल्फ

मेरी बुरी, यह कोशिश करो ।

— ETHproductions

Answer 8

टर्टल , 72 बाइट्स

"K C I I B A V W M G">"GPNCPSCPLBG">"G M C B I R O C V C J">"JSESVPSCTNF

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

>कछुए को घुमाता है, "foo"ग्रिड पर तार लिखता है। अंतिम योग्य "था

Answer 9

वी , 75, 62 , 59 बाइट्स

iFKCIIBAVWMG
NPTNCCSPPSVCSPELSB
JCVCORIBCMG-ò9á lli
òÍ./& 

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

चूंकि इस कोडेल में गैर- ASCII वर्ण हैं, यहाँ एक हेक्सडंप है:

0000000: 6946 4b43 4949 4241 5657 4d47 0a4e 5054  iFKCIIBAVWMG.NPT
0000010: 4e43 4353 5050 5356 4353 5045 4c53 420a  NCCSPPSVCSPELSB.
0000020: 4a43 5643 4f52 4942 434d 471b 2df2 39e1  JCVCORIBCMG.-.9.
0000030: 206c 6c69 0af2 cd2e 2f26 20               lli..../& 

स्पष्टीकरण। सबसे पहले, हम निम्नलिखित पाठ दर्ज करते हैं:

FKCIIBAVWMG
NPTNCCSPPSVCSPELSB
JCVCORIBCMG

फिर, हम <esc>सामान्य मोड पर वापस आ गए। इस बिंदु पर, कर्सर अंतिम पर तीसरी पंक्ति पर है G। आसानी से, कर्सर के ठीक ऊपर हमें लाइन के पहले कॉलम पर रखने की आज्ञा है। वह आज्ञा है -। फिर, एक बार जब हम दूसरी पंक्ति ( N) पर समाप्त होते हैं , तो हम निम्नलिखित लूप चलाते हैं:

ò9á lli
ò

स्पष्टीकरण:

ò           " Recursively:
 9á         "   Append 9 spaces
    ll      "   Move to the right twice. This will fail on the last time because there isn't a space to move into
      i     "   Enter a newline
ò           " End

अब, बफर इस तरह दिखता है:

FKCIIBAVWMG
N         P
T         N
C         C
S         P
P         S
V         C
S         P
E         L
S         B
JCVCORIBCMG

अब हम प्रत्येक कैरेक्टर को उस कैरेक्टर और स्पेस से रिप्लेस करने के लिए कंप्रेस्ड रेगेक्स का इस्तेमाल करते हैं। वह Í./&हिस्सा है। यह निम्नलिखित विम रेगेक्स का अनुवाद करता है:

:%s/./& /g

जिसका मतलब है:

:%          " On any line
  s/        " Substitute
    ./      " Any character with
      & /   " That same character and a space
         g  " Allow for multiple substitutions on the same line

Answer 10

आर, 149 146 बाइट्स

इतना प्रभावशाली नहीं है लेकिन यह भी सुनिश्चित नहीं है कि यह कैसे गोल्फ होगा। pasteकिसी तरह शोषण करना मेरा पहला अनुमान है। 241 बाइट्स के कच्चे पाठ की तुलना करें।

x=strsplit("NTCSPVSESPNCPSCPLB","")[[1]];cat("F K C I I B A V W M G\n");for(i in 1:9)cat(x[i],rep("",18),x[i+9],"\n");cat("J C V C O R I B C M G")

आर-बेला

Answer 11

अजगर 2, 108 बाइट्स

अन्य अजगर जवाब की तुलना में थोड़ा अलग है, कोई जगह नहीं का उपयोग करके, केवल स्ट्रिंग जुड़ता है।

print'\n'.join(map(' '.join,['FKCIIBAVWMG']+map((' '*9).join,zip('NTCSPVSES','PNCPSCPLB'))+['JCVCORIBCMG']))

Comments

मुझे पता था कि ज़िप आगे का रास्ता था! बहुत पहले से ही नीचे एक ही समाधान 118 था और आज शाम इसे गोल्फ जा रहा था। मुझे नक्शा याद आ रहा था। तुम मुझे यह करने के लिए हराया लगता है। +1

— एलपेड्रो

Answer 12

पर्ल, 90 बाइट्स

सुंदर उबाऊ दृष्टिकोण, कम करने के लिए एक बेहतर तरीका के बारे में नहीं सोच सकता है ... -Eकोई अतिरिक्त लागत की आवश्यकता नहीं है। हर पंक्ति के अंत में एक अतिरिक्त स्थान आउटपुट करता है। -2 बाइट्स @ दादा को धन्यवाद !

say"FKCIIBAVWMG
NZP
TZN
CZC
SZP
PZS
VZC
SZP
EZL
SZB
JCVCORIBCMG"=~s/Z/$"x9/ger=~s/./$& /gr

प्रयोग

perl -E 'say"FKCIIBAVWMG
NZP
TZN
CZC
SZP
PZS
VZC
SZP
EZL
SZB
JCVCORIBCMG"=~s/Z/$"x9/ger=~s/./$& /gr'

Comments

2 बाइट्स कम (लेकिन मूल रूप से आपके समान कोड) perl -E 'say"FKCIIBAVWMG\nNZP\nTZN\nCZC\nSZP\nPZS\nVZC\nSZP\nEZL\nSZB\nJCVCORIBCMG"=~s/Z/$"x9/ger=~s/./$& /gr':। ( \n90 को पाने के लिए शाब्दिक नई कहानियों से प्रतिस्थापित करें )।

— दादा

@ दादा आह, बहुत अच्छे! धन्यवाद!

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

"बहुत अच्छा" 40 बाइट्स का समाधान ढूंढ रहा होगा, लेकिन धन्यवाद: D

— Dada

Answer 13

जोल्फ, 72 बाइट्स

Ζ0ρ,ahtht"111"'.d?=H♣Q♣+."FKCIIBAVWMGNPTNCCSPPSVCSPELSBJCVCORIBCMG"wΖhζ♣

सभी के ♣साथ बदलें \x05, या इसे यहां आज़माएं!

Ζ0ρ,ahtht"111"'.d?=H♣Q♣+."..."wΖhζ♣
Ζ0                                   ζ = 0
   ,ahtht"111"                       a box of width&height 11, with borders "1"
  ρ           '.d                    replace each char in that string with...
                 ?=H♣                 is it a space?
                     Q♣                if so, return two spaces.
                                      otherwise
                        ."..."         get the Nth member of this string
                              wΖhζ      where N = (++ζ) - 1
                       +          ♣      and add a space to the end

यह वांछित स्ट्रिंग देता है।

Answer 14

जावा 7, 177 165 142 131 बाइट्स

String c(){return"FKCIIBAVWMG\nN_P\nT_N\nC_C\nS_P\nP_S\nV_C\nS_P\nE_L\nS_B\nJCVCORIBCGM".replace("_","         ").replace(""," ");}

-15 बाइट्स @BassdropCumberwubwubwub को धन्यवाद ।
-11 बाइट्स के लिए @Numberknot का धन्यवाद ।

Ungolfed और परीक्षण कोड:

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

class M{
  static String c(){
    return "FKCIIBAVWMG\nN_P\nT_N\nC_C\nS_P\nP_S\nV_C\nS_P\nE_L\nS_B\nJCVCORIBCGM"
      .replace("_","         ").replace(""," ");
  }

  public static void main(String[] a){
    System.out.print(c());
  }
}

आउटपुट:

F K C I I B A V W M G
N                   P
T                   N
C                   C
S                   P
P                   S
V                   C
S                   P
E                   L
S                   B
J C V C O R I B C M G

Comments

String c(){String s=" ";return"FKCIIBAVWMG\nN_P\nT_N\nC_C\nS_P\nP_S\nV_C\nS_P\nE_L\nS_B\nJCVCORIBCMG".replace(""," ").replace("_",s);}150 के लिए (ध्यान दें कि

— स्टैकएक्सचेंज

@BassdropCumberwubwubwub उम्म .. यह 19 के बजाय 'वर्टिकल दीवारों' के बीच केवल 3 स्थान का आउटपुट देता है। यहां आपके कोड का एक आइडोन है।

— केविन क्रूज़सेन

इसलिए मेरा ध्यान दें, इसमें अधिक स्थान होना चाहिए, sलेकिन स्टैकएक्सचेंज ने उन्हें हटा दिया। यहां बताया गया है ideone , अब भी पर 142 बाइट्स

— Bassdrop Cumberwubwubwub

@BassdropCumberwubwubwub आह ठीक है। पता नहीं था कि आप के बीच में है s=" "। उस मामले में यह वास्तव में कम है। और इसके बजाय एक अतिरिक्त -8 बाइट्स के लिए .‌​replace(""," ").replace("_",s);हो सकता है.replace("_",s).‌​replace(""," ");

— केविन क्रूज़सेन

String c(){return"FKCIIBAVWMG\nN_P\nT_N\nC_C\nS_P\nP_S\nV_C\nS_P\nE_L\nS_B\nJCVCORIBCMG".replace("_","         ").replace(""," ");}( 131 बाइट्स )

— 11

Answer 15

Befunge, 120 बाइट्स

<v"FKCIIBAVWMG NPTNCCSPPSVCSPELSB $JCVCORIBCMG "
:<,*48 ,_v#-*48<
>1-:#v_\,>$52*, :48*-!#v_,54*
^,*84<         ^p19*88$<

पहली पंक्ति में स्ट्रिंग को रिवर्स में प्रिंट किया जाना है (ऐसा लगता है कि यह नहीं है, लेकिन कोड उस रेखा पर पीछे जा रहा है)। दूसरी पंक्ति ऊपर और नीचे की पंक्तियों को प्रिंट करती है। तीसरी पंक्ति और चौथी पंक्ति के बाईं ओर मध्य पंक्तियों को प्रिंट करें, और नीचे दाईं ओर छोटा हिस्सा एक दिलचस्प काम करता है: यह कर्सर को दूसरी पंक्ति में अंतिम पंक्ति को प्रिंट करने के लिए वापस ले जाता है, लेकिन इसे खत्म करने के बाद, इस्तीफा।

जैसा कि आप पहली पंक्ति में देख सकते हैं, पहली, मध्य और अंतिम पंक्तियों के बीच अंतर करने के लिए स्ट्रिंग्स को रिक्त स्थान द्वारा अलग किया जाता है। रिक्त स्थान कुछ और हो सकते हैं, और अगर मैंने ASCII वर्ण 0-9 का उपयोग किया है, तो मैं आसानी से 4 बाइट बचा सकता था। आपके द्वारा देखा जाने वाला $ केवल एक कचरा पात्र है जिसे वहां होना है और इसे एक स्थान के साथ कुछ भी बदला जा सकता है।

Answer 16

जे, 77 73 बाइट्स

' FKCIIBAVWMGNPTNCCSPPSVCSPELSBJCVCORIBCMG'{~_22}.\,0,.(*+/\),0=*/~5-|i:5

ध्यान दें कि 43 बाइट्स, आधे से अधिक कुल, केवल स्ट्रिंग के लिए उपयोग किए जाते हैं ' FKCIIBAVWMGNPTNCCSPPSVCSPELSBJCVCORIBCMG'।

व्याख्या

सबसे पहले, एक सूची बनाएं

   |i:5
5 4 3 2 1 0 1 2 3 4 5
   5-|i:5
0 1 2 3 4 5 4 3 2 1 0

फिर इसकी टाइम टेबल बनाएं

   */~5-|i:5
0 0  0  0  0  0  0  0  0 0 0
0 1  2  3  4  5  4  3  2 1 0
0 2  4  6  8 10  8  6  4 2 0
0 3  6  9 12 15 12  9  6 3 0
0 4  8 12 16 20 16 12  8 4 0
0 5 10 15 20 25 20 15 10 5 0
0 4  8 12 16 20 16 12  8 4 0
0 3  6  9 12 15 12  9  6 3 0
0 2  4  6  8 10  8  6  4 2 0
0 1  2  3  4  5  4  3  2 1 0
0 0  0  0  0  0  0  0  0 0 0

फिर शून्य के साथ समानता के लिए परीक्षण करें

   0=*/~5-|i:5
1 1 1 1 1 1 1 1 1 1 1
1 0 0 0 0 0 0 0 0 0 1
1 0 0 0 0 0 0 0 0 0 1
1 0 0 0 0 0 0 0 0 0 1
1 0 0 0 0 0 0 0 0 0 1
1 0 0 0 0 0 0 0 0 0 1
1 0 0 0 0 0 0 0 0 0 1
1 0 0 0 0 0 0 0 0 0 1
1 0 0 0 0 0 0 0 0 0 1
1 0 0 0 0 0 0 0 0 0 1
1 1 1 1 1 1 1 1 1 1 1

इसे समतल करें, संचयी योगों को खोजें, और तत्व को गुणा करें

   ,0=*/~5-|i:5
1 1 1 1 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1
   +/\,0=*/~5-|i:5
1 2 3 4 5 6 7 8 9 10 11 12 12 12 12 12 12 12 12 12 12 13 14 14 14 14 14 14 14 14 14 14 15 16 16 16 16 16 16 16 16 16 16 17 18 18 18 18 18 18 18 18 18 18 19 20 20 20 20 20 20 20 20 20 20 21 22 22 22 22 22 22 22 22 22 22 23 24 24 24 24 24 24 24 24 24 24 25 26 26 26 26 26 26 26 26 26 26 27 28 28 28 28 28 28 28 28 28 28 29 30 31 32 33 34 35 36 37 38 39 40
   (*+/\),0=*/~5-|i:5
1 2 3 4 5 6 7 8 9 10 11 12 0 0 0 0 0 0 0 0 0 13 14 0 0 0 0 0 0 0 0 0 15 16 0 0 0 0 0 0 0 0 0 17 18 0 0 0 0 0 0 0 0 0 19 20 0 0 0 0 0 0 0 0 0 21 22 0 0 0 0 0 0 0 0 0 23 24 0 0 0 0 0 0 0 0 0 25 26 0 0 0 0 0 0 0 0 0 27 28 0 0 0 0 0 0 0 0 0 29 30 31 32 33 34 35 36 37 38 39 40

फिर शून्य के साथ जुड़ें, इसे लंबाई 22 के सब्लिस्ट में विभाजित करें, प्रत्येक सबलिस्ट के सिर को छोड़ दें, और स्ट्रिंग में सूचक के रूप में मूल्यों का उपयोग करें ' FKCIIBAVWMGNPTNCCSPPSVCSPELSBJCVCORIBCMG'

   ' FKCIIBAVWMGNPTNCCSPPSVCSPELSBJCVCORIBCMG'{~_22}.\,0,.(*+/\),0=*/~5-|i:5
F K C I I B A V W M G
N                   P
T                   N
C                   C
S                   P
P                   S
V                   C
S                   P
E                   L
S                   B
J C V C O R I B C M G

Comments

जेनेरिक स्ट्रिंग कम्प्रेशन का उपयोग करके मुझे सबसे अच्छा 90 बाइट्स मिल सकता है:(' ',@,.~]);._1';FKCIIBAVWMG;N_P;T_N;C_C;S_P;P_S;V_C;S_P;E_L;S_B;JCVCORIBCMG'rplc'_';9#' '

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

@ ConorO'Brien हाँ, यह J में गोल्फ स्ट्रिंग कंप्रेशन के लिए कठिन है जब अन्य भाषाओं में डिक्शनरी और बिलिन कंप्रेशन है।

— मीलों

@ ConorO'Brien मैंने आपके विचार को थोड़ा और गोल करने की कोशिश की और इसे 76 बाइट्स तक पहुंचा दिया_11,@,.&' '\'FKCIIBAVWMGN_PT_NC_CS_PP_SV_CS_PE_LS_BJCVCORIBCMG'rplc'_';9#' '

— मील

Answer 17

दरअसल , 74 बाइट्स

"%s"9⌐α' j;"%s%20s"9α'
j(k'
j"FKCIIBAVWMGNPTNCCSPPSVCSPELSBJCVCORIBCMG"#@%

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

यह कार्यक्रम xnor के पायथन 2 उत्तर के समान मूल सिद्धांत से हटकर काम करता है ।

स्पष्टीकरण ( \nस्पष्टता के लिए नए सिरे से प्रतिस्थापित ):

"%s"9⌐α' j                                       ' '.join(["%s"]*11)
;                                                duplicate
"%s%20s"9α'\nj                                   '\n'.join(["%s%20s"]*9)
(                                                move bottom of stack to top
k'\nj                                            '\n'.join(stack)
"FKCIIBAVWMGNPTNCCSPPSVCSPELSBJCVCORIBCMG"#@%                    %tuple(longstring)

Answer 18

सी # 6, 192 190 बाइट्स

using System.Linq;
string f()=>string.Join("\n","FKCIIBAVWMG~N!P~T!N~C!C~S!P~P!S~V!C~S!P~E!L~S!B~JCVCORIBCMG".Replace("!","         ").Split('~').Select(s=>string.Join(" ",s.Select(c=>c))));

पीछे की जगह के बिना; अनुगामी newline के बिना।

एक सीधा हल। शाब्दिक स्ट्रिंग से शुरू करें। Replace !9 स्थानों से। फिर Split11 तार में ~, और आगे char(आंतरिक Select) के लिए। प्रत्येक वर्ण के लिए एक स्थान जोड़ें, फिर Join११ तारों पर वापस जाएँ। अंत Joinमें newline वर्ण द्वारा एक और ।

Answer 19

रूबी, 92

पूर्ण कार्यक्रम, प्रिंट का उपयोग करने के लिए प्रिंट $> <<

40.times{|i|$><<"FKCIIBAVWMGNPTNCCSPPSVCSPELSBJCVCORIBCMG"[i]+(i%29>9?[$/,' '*19][i%2]:' ')}

प्लॉट करने के लिए कुल 40 पत्र हैं। 10 से 28 के बीच के अक्षर एक नई पंक्ति या उसके बाद वैकल्पिक किए जा रहे हैं ' '*19। पहले और बाद के अक्षरों को एकल रिक्त स्थान द्वारा अलग किया जाता है।

Answer 20

पर्ल, 115 112 बाइट्स

print FKCIIBAVWMG=~s/(.)/\1 /gr.NPTNCCSPPSVCSPELSB=~s/(.)(.)/"\n$1".$"x19 .$2/gre."\nJCVCORIBCMG"=~s/(.)/\1 /gr;

निम्नलिखित उत्पादन करता है:

F K C I I B A V W M G 
N                   P
T                   N
C                   C
S                   P
P                   S
V                   C
S                   P
E                   L
S                   B
J C V C O R I B C M G 

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

संपादित करें 1: सहेजी गयी 3 बाइट्स की जगह " "के साथ $", बाहरी कोष्ठकों को दूर करने और प्रिंट के बाद एक अंतरिक्ष डालने, और चारों ओर कोष्ठकों को दूर करने $"x19और एक अंतरिक्ष बाद में जोड़ने (ताकि .एक दशमलव के रूप में व्याख्या नहीं किया जाएगा)

Comments

आप अभी भी कुछ बाइट्स बचा s/(.)/\1 /सकते हैं : द्वारा प्रतिस्थापित किया जा सकता है s/./$& /। अंतिम अर्धविराम ड्रॉप करें। sayइसके बजाय का उपयोग करें print( इसके लिए आपको इसके बजाय जोड़ने -M5.010या उपयोग -Eकरने की आवश्यकता होगी -e, लेकिन दोनों मुफ़्त हैं ( यहाँ देखें ))। के बजाय शाब्दिक नए समाचार \n।

— दादा

Answer 21

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

Ｂ²¹¦¹¹F K C I I B A V W M GPNCPSCPLBG M C B I R O C V C JSESVPSCTN

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

Box(21, 11, 'F K C I I B A V W M GPNCPSCPLBG M C B I R O C V C JSESVPSCTN')।

नॉनकंपेटिंग, 36 बाइट्स

Answer 22

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

बहुत सरल, जो भी कारण के लिए भले ही स्ट्रिंग की जगह इतनी क्रिया है, यह सबसे अच्छी बात थी जिसके साथ मैं आ सकता था। संभवतः इसका उपयोग reकम हो सकता है।

print' '.join('FKCIIBAVWMG!N@P!T@N!C@C!S@P!P@S!V@C!S@P!E@L!S@B!JCVCORIBCMG').replace(' ! ','\n').replace('@',' '*17)

Comments

print'F K C I I B A V W M G\nN@P\nT@N\nC@C\nS@P\nP@S\nV@C\nS@P\nE@L\nS@B\nJ C V C O R I B C M G'.replace('@',' '*19)यदि आप सीधे सीधे आगे रहना चाहते हैं, तो बिना ज्वाइन के भी 116 बाइट्स का उपयोग करें। वैकल्पिक रूप से, print' '.join('FKCIIBAVWMG!N@P!T@N!C@C!S@P!P@S!V@C!S@P!E@L!S@B!JCVCORIBCMG').replace('! ','\n').replace('@',' '*17)115 बाइट्स है यदि अनुगामी व्हाट्सएप की अनुमति है। ('की जगह तर्क' है! ',' की जगह '!')

— माइकल एसस

Answer 23

बैच, 171 बाइट्स

@echo F K C I I B A V W M G
@set s=NPTNCCSPPSVCSPELSB
:l
@echo %s:~0,1%                   %s:~1,1%
@set s=%s:~2%
@if not "%s%"=="" goto l
@echo J C V C O R I B C M G

Answer 24

गेममेकर लैंग्वेज, 148 बाइट्स

मुझे पता है कि यह बहुत बुनियादी है, लेकिन मुझे नहीं लगता कि इसे GML में हराया जा सकता है ...

a="                   "return"F K C I I B A V W M G #N"+a+"P#T"+a+"N#C"+a+"C#S"+a+"P#P"+a+"S#V"+a+"C#S"+a+"P#E"+a+"L#S"+a+"B#J C V C O R I B C M G "

Comments

धन्यवाद @NiCkNewman, लेकिन मैंने वास्तव में इसे इस साइट पर काफी पहले इस्तेमाल किया है - codegolf.stackexchange.com/search?q=GameMaker

— Timtech

मैं देख रहा हूँ, मैं खेल इंजन GDScriptसे भाषा में कुछ करने की सोच रहा था Godot। लेकिन, निश्चित नहीं है कि यह ठीक होगा :)

— नीक न्यूमैन

आह, अगर केवल बोर्ड बड़ा था; string_repeat(" ",19)के रूप में ही लंबाई है " "।

— u54112 10

@NiCkNewman यह ठीक होना चाहिए, अगर आप कुछ लिखते हैं तो मुझे बताएं :)

— टाइमटेक

@lastresort मुझे पता है ... GML एक साथ चीजों को नष्ट करने के साथ चाल की अनुमति देता है, लेकिन इसके आदेश बहुत

— क्रियाशील

Answer 25

पिप , 64 बाइट्स

-Sध्वज के लिए कोड के 63 बाइट्स, +1 ।

.*"NTCSPVSES".sX19.^"PNCPSCPLB"PE^"FKCIIBAVWMG"AE^"JCVCORIBCMG"

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

व्याख्या

ऑपरेटरों का इस्तेमाल किया:

• . (बाइनरी) कॉनैटेटनेट (सूचियों पर आइटम-वार संचालित करता है)।
• X(बाइनरी) स्ट्रिंग-गुणक। ( sएक वैरिएबल प्रीइंस्ट्रिचुअलाइज्ड टू है " "।)
• ^ (unary) एक स्ट्रिंग को वर्णों की सूची में विभाजित करता है।
• .*एक स्ट्रिंग को वर्णों में विभाजित करने का एक और तरीका है। इसमें एकरी शामिल है ., जो स्ट्रिंग्स पर एक नो-ऑप है *, जिसे मेटा-ऑपरेटर के साथ जोड़ा गया है , जो इसके (iterable) ऑपरेंड में प्रत्येक आइटम के लिए एक अपर ऑपरेटर को मैप करता है। उपयोग .*"..."करने से हमें बाइट को बचाने में मदद मिलेगी (^"...")- कोष्ठक की आवश्यकता होगी क्योंकि .इसकी तुलना में अधिक पूर्वता है ^।
• PEकिसी सूची में एक तत्व को प्रस्तुत करता है। AEएक तत्व को एक सूची में जोड़ता है।

उस पृष्ठभूमि के साथ, यहाँ कदम से कदम कदम है:

.*"NTCSPVSES"

['N 'T 'C 'S 'P 'V 'S 'E 'S]

.sX19

["N                   "
 "T                   "
 "C                   "
 "S                   "
 "P                   "
 "V                   "
 "S                   "
 "E                   "
 "S                   "]

.^"PNCPSCPLB"

["N                   P"
 "T                   N"
 "C                   C"
 "S                   P"
 "P                   S"
 "V                   C"
 "S                   P"
 "E                   L"
 "S                   B"]

PE^"FKCIIBAVWMG"

[['F 'K 'C 'I 'I 'B 'A 'V 'W 'M 'G]
 "N                   P"
 "T                   N"
 "C                   C"
 "S                   P"
 "P                   S"
 "V                   C"
 "S                   P"
 "E                   L"
 "S                   B"]

AE^"JCVCORIBCMG"

[['F 'K 'C 'I 'I 'B 'A 'V 'W 'M 'G]
 "N                   P"
 "T                   N"
 "C                   C"
 "S                   P"
 "P                   S"
 "V                   C"
 "S                   P"
 "E                   L"
 "S                   B"
 ['J 'C 'V 'C 'O 'R 'I 'B 'C 'M 'G]]

जब इस परिणाम को स्वत: स्फूर्त किया जाता है, तो -Sध्वज रिक्त स्थान पर उपनलियों से जुड़ जाता है और वांछित परिणाम देते हुए, नई सूची में मुख्य सूची में शामिल हो जाता है।

Answer 26

सी, 171 156 बाइट्स

i,j;char*b="FKCIIBAVWMGNPTNCCSPPSVCSPELSBJCVCORIBCMG ";f(){for(i=1;*b;j=i%21==0?putchar(*b++),puts(""),i++,*b++:i<21||i>210?i&1?*b++:32:32,putchar(j),i++);}

एक अनुगामी न्यूलाइन चरित्र को भी आउटपुट करता है ... शायद थोड़ा और नीचे गोल्फ हो सकता है।

Answer 27

पर्ल 5, 92 86 बाइट्स

• दादा की बदौलत 6 बाइट बचाईं

$a="%s "x11;printf"$a
"."%s%20s
"x9 .$a,FKCIIBAVWMGNPTNCCSPPSVCSPELSBJCVCORIBCMG=~/./g

उपयोग sprintf, पैडिंग और स्ट्रिंग रिपीट ऑपरेटर x।

Comments

अच्छा समाधान है। आप हालांकि कुछ बाइट्स बचा सकते हैं: \nशाब्दिक नई सूचियों के साथ प्रतिस्थापित करते हैं, आपको xऑपरेटर और संख्या के बीच रिक्त स्थान की आवश्यकता नहीं होती है, और अंत में इसके split//,xxxसाथ प्रतिस्थापित करते हैं xxx=~/./g।

— दादा

Answer 28

हास्केल, 128 125 114 बाइट्स

mapM(putStrLn.((:" ")=<<))$"FKCIIBAVWMG":zipWith(\a b->a:"         "++[b])"NTCSPVSES""PNCPSCPLB"++["JCVCORIBCMG"]

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

• ((:" ")=<<)है concatMap (\a -> [a,' '])- इसके इनपुट में हर अक्षर के पीछे एक स्थान जोड़कर पैड

Answer 29

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

@ AdmBorkBork के जवाब से प्रेरित ।

'FKCIIBAVWMG
N0P
T0N
C0C
S0P
P0S
V0C
S0P
E0L
S0B
JCVCORIBCMG'-replace0,(' '*9)-replace'.','$0 '

व्याख्या

पहला प्रतिस्थापन ऑपरेटर आयत बनाता है 11x11।

FKCIIBAVWMG
N         P
T         N
C         C
S         P
P         S
V         C
S         P
E         L
S         B
JCVCORIBCMG

दूसरा प्रतिस्थापित करने वाला ऑपरेटर प्रत्येक वर्ण के बाद एक स्थान सम्मिलित करता है। परिणाम में अनुगामी स्थान होते हैं।

F K C I I B A V W M G
N                   P
T                   N
C                   C
S                   P
P                   S
V                   C
S                   P
E                   L
S                   B
J C V C O R I B C M G