एक साधारण पैटनर

17

इनपुट:

दो एकल अंक (हम उन्हें कॉल mऔर n) और दो वर्ण (चलो उन्हें फोन aऔरb अपनी पसंद के इस प्रारूप में)।

आउटपुट:

पूर्वाभ्यास के लिए, दिखावा करें m=2, n=5, a='a', b='b' ।

आपका आउटपुट आपके चार इनपुट से निर्मित एक स्ट्रिंग होगा। मान के resultसाथ, स्ट्रिंग को कॉल करते हैं ""। सबसे पहले, समय aपर समाप्‍त करें result m, इसलिए समय aपर सम्‍मिलित करें result 2। resultअब बराबर है aa। दूसरा, समय bपर समाप्‍त करना result m, इसलिए समय bपर सम्‍मिलित करना result 2। resultअब बराबर है aabb। अंत में, यदि परिणाम पहले से अधिक लंबा है n, resultतो छोटा करें ताकि उसकी लंबाई हो n। अन्यथा, mलंबाई के रन के साथ बारी-बारी से जारी रखें aऔर bजब तक resultलंबाई न हो n। अंतिम resultहै aabba, जिसकी लंबाई है 5।

परीक्षण के मामलों:

Input: m = 2, n = 4, a = A, b = B

Output: AABB

Input: m = 3, n = 8, a = A, b = B

Output: AAABBBAA

Input: m = 4, n = 3, a = A, b = B

Output: AAA

Input: m = 2, n = 10, a = A, b = B

Output: AABBAABBAA

जैसा कि सभी जानते हैं, दुनिया में सबसे कम कार्यक्रम, सबसे छोटे कार्यक्रम, बाइट्स में, जीतेंगे! :)

code-golf  string  code-golf  arithmetic  code-golf  string  array-manipulation  rubiks-cube  code-golf  math  number  code-golf  tips  bash  code-golf  ascii-art  music  code-golf  arithmetic  code-golf  math  number  arithmetic  integer  code-golf  number  array-manipulation  code-golf  geometry  grid  set-partitions  code-golf  math  number  code-golf  combinatorics  code-golf  regular-expression  code-golf  permutations  code-golf  ascii-art  code-golf  number  array-manipulation  matrix  code-golf  kolmogorov-complexity  compile-time  cops-and-robbers  polyglot  cops-and-robbers  polyglot  code-golf  string  code-golf  string  ascii-art  matrix  animation  code-golf  ascii-art  code-golf  string  balanced-string  code-golf  integer  integer-partitions  expression-building 
— दुर्गा
स्रोत
"आउटपुट में कुल चार '' एन" का क्या अर्थ होगा और "कम दुनिया पर शासन करेगा"?
— निकोलस
मैंने मूल रूप से चुनौती को फिर से लिखा है, जो मुझे विश्वास है कि आपके मूल इरादे थे। आप चाहें तो रोलबैक कर सकते हैं, लेकिन इसकी मूल स्थिति में इसे फिर से खोलना नहीं है।
— स्टीफन
@ स्टेफेन आपने मेरा दिन बचाया: p gracias :)
— दुर्गा
@ दुर्गा कोई बात नहीं :) मुझे खुशी है कि यह अभी भी वही कहती है जो आप चाहते थे।
— स्टीफन
2
@ दुर्गा ने टेस्ट केस प्रस्तावित किया:m=2,n=10,a=A,b=B
— रॉड

जवाबों:

8

पायथन , 32 बाइट्स

lambda m,n,a,b:((a*m+b*m)*n)[:n]

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

— जूलियन वुल्फ
स्रोत
अनाम फ़ंक्शंस की अनुमति दी जाती है अंतिम मैंने चेक किया ताकि आप f=-2 बाइट निकाल सकें ।
— कॉमरेड स्पार्कलेपनी
@ कॉमरेडस्पार्कलेपनी: हेड्स अप के लिए धन्यवाद। वह तिवारी से बचा हुआ था; मैं वास्तव में पहले से ही इसे बाइट की गिनती से हटा दिया था।
— जूलियन वुल्फ
2
आप f=TIO के हेडर सेक्शन में डाल सकते हैं , इसलिए आपको इसे मैन्युअल रूप से निकालने की आवश्यकता नहीं है। TIO
— OVS
आह, मैं हमेशा बैकस्लैश के बारे में भूल जाता हूं। धन्यवाद।
— जूलियन वुल्फ
1
जिसने भी संपादन का सुझाव दिया है (a*m+b*m)-> (a+b)*m: यह काम नहीं करता है।
— जूलियन वुल्फ
6

MATL , 5 बाइट्स

Y"i:)

इनपुट दो वर्णों के साथ एक स्ट्रिंग है, फिर m, फिर n।

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

व्याख्या

Y"   % Implicit inputs: string and number m. Apply run-length decoding.
     % The second input is reused for each char in the first. Gives a
     % string
i    % Input number n
:    % Push vector [1 2 ... n]
)    % Index the string with the numbers in that vector. Indexing is
     % modular, so the chars are reused if necessary. Implicit display
— लुइस मेंडो
स्रोत
5

जाप , 10 बाइट्स

VîUçW +UçX

पहले एक गोल्फ भाषा का उपयोग करने का प्रयास करें। इसे ऑनलाइन आज़माएं!

व्याख्या

Vî          // repeat the following until it reaches length V (second input)
  UçW       // third input repeated U (first input) times
      +UçX  // plus the fourth input, repeated U times
— जस्टिन मेरिनर
स्रोत
Japt का उपयोग करने के लिए धन्यवाद, और अच्छी तरह से किया :-) आप VîWpU +XpUभी कर सकते हैं , लेकिन दोनों एक ही काम करते हैं। Vîइस चुनौती के लिए एकदम सही है।
— ETHproductions
@ETHproductions धन्यवाद, और इसे बनाने के लिए धन्यवाद! मैं वास्तव में आनंद लेता हूं कि कैसे सब कुछ जेएस कोड को अच्छी तरह से स्थानांतरित करता है।
— जस्टिन मेरिनर
3

जेली , 6 4 बाइट्स

xFṁ⁵

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

बेहतर इनपुट प्रारूप (-2) के लिए जोनाथन एलन को धन्यवाद ।

— आउटगोल्फ को एरिक करें
स्रोत
— जोनाथन एलन
@JonathanAllan हेह मैं आमतौर पर तीसरे तर्क का उपयोग करने से बचने की कोशिश करता हूं, लेकिन इस बार यह मेरे जवाब को कम कर देता है।
— एरिक आउटगॉल्फ
3

वी , 13 बाइट्स

ÀäjÀäêÍî
À|lD

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

aऔर bइनपुट में अलग-अलग लाइनों पर लिया जाता है , mऔर nतर्क के रूप में लिया जाता है, उलटा (इसलिए)n पहला तर्क है और mदूसरा है)

व्याख्या

Àäj      ' duplicate the inputs [arg 1] times
a -> a
b    b
     a
     b
     ...
   Àäê   ' duplicate everything straight down [arg 2] times - À cycles arguments
a -> aaa
b    bbb
a    aaa
b    bbb
...  ...
      Íî ' remove all newlines
-> aaabbbaaabbb...
À|lD     ' delete from the [arg 1] + 1 column onwards
-> aaabbbaa
— nmjcman101
स्रोत
3

हास्केल , ३६ ३५ 29 बाइट्स

फिर भी एक और हास्केल समाधान (सूची के रूप में दिए गए पात्रों की अपेक्षा करता है):

(m#n)c=take n$cycle$c<*[1..m]

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

धन्यवाद @ लाईकोनी -1 बाइट के लिए।

— ბიმო
स्रोत
1
आप के साथ एक बाइट बचा सकते हैं (m#n)a b=।
— लकोनी
3

आर , 41 39 बाइट्स

function(d,m,n)cat(d[gl(2,m,n)],sep='')

एक अनाम फ़ंक्शन; परिणाम को प्रिंट करने के लिए प्रिंट करता है। एक वेक्टर के रूप में वर्ण लेता है d=c(a,b)। कुल लंबाई के साथ रन लंबाई के स्तर gl(इस मामले में) के कारक (पूर्णांक) उत्पन्न करता है ! संघनक और उन्हें एक स्ट्रिंग के रूप में प्रिंट करता है।2mncat

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

— ग्यूसेप
स्रोत
मुझे लगता है function(d,m,n)rep(d,e=m,l=n)कि एक वैध प्रस्तुत करना होगा।
— अंडा
@ovs दुर्भाग्य repसे एक स्ट्रिंग के बजाय वर्णों के एक वेक्टर में परिणाम होगा
— Giuseppe
2

जावास्क्रिप्ट, 55 बाइट्स

(m,n,a,b)=>(a[r='repeat'](m)+b[r](m))[r](n).substr(0,n)

उदाहरण कोड स्निपेट:

f=

(m,n,a,b)=>(a[r='repeat'](m)+b[r](m))[r](n).substr(0,n)

console.log(f(2, 4, 'A', 'B'))
console.log(f(3, 8, 'A', 'B'))
console.log(f(4, 3, 'A', 'B'))
console.log(f(2, 9, 'A', 'B'))
स्निपेट का विस्तार करें

— हरमन एल
स्रोत
2

जावास्क्रिप्ट, 53 बाइट्स

(m,n,a,b)=>a.repeat(n).replace(/./g,(i,j)=>j/m&1?b:i)
— Ra8
स्रोत
1

QBIC , 37 27 बाइट्स

[:|G=;+G+;][:|G=G+G]?_sG,d

व्याख्या

          This takes its arguments as frequency m, A, B, length n
          For example: 2, A, B, 8
 :        Read a cmd line arg as number 'b' ('a' is used by the FOR declaration as loop counter)
[ |       Start a FOR loop, from 1 to b
G=  G     Set G to hold itself
  ;+      prepended by a cmd line arg read as strig and assigned to A$
     +;   and followed by a cmd line arg read as strig and assigned to B$
]         At the end of the FOR loop, G has had A added to the front twice, and B t the end x2: G$ = AABB
[:|       FOR c = 1 to n
G=G+G]      Add G to itself          G$ = AABBAABBAABBAABBAABBAABBAABBAABB
?_sG,d    PRINT the first n chars of G$   AABBAABB

पिछला प्रयास:

(37b)  {Z=Z+;┘_LZ|~a=:|_X]~a%:|\C=A┘A=;┘B=C
Takes its arguments as `A, length n, frequency m, B`.
Basically adds A to Z until length % freq = 0, then swaps A for B. Loops until lengtn = n
— steenbergh
स्रोत
1

क्यूबिक्स , 63 58 बाइट्स

.rr.@u:s?.\.sw).i|>v:.\nB;?(q:Is...;rr/s.uw/....sIB/\/?(qo

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

दुभाषिया देखें

जैसे इनपुट लेता है ab*m*n जहां *कोई भी गैर-अंक चरित्र हो सकता है।

घन संस्करण:

        . r r .
        @ u : s
        ? . \ .
        s w ) .
i | > v : . \ n B ; ? ( q : I s
. . . ; r r / s . u w / . . . .
s I B / \ / ? ( q o . . . . . .
. . . . . . . . . . . . . . . .
        . . . .
        . . . .
        . . . .
        . . . .
  • i|is: चार्ट में पढ़ें, और उन्हें स्वैप करें (ऐसा aशीर्ष पर है)
  • I:q: में पढ़ा m, डुबकी, और धक्का नीचे (ढेर अब है m,b,a,m)
  • ) : क्षय
  • ? : सकारात्मक होने पर दाएं मुड़ें, शून्य (डुप्लिकेट) होने पर सीधे जाएं a ) होने पर
  • सकारात्मक शाखा (लूप)
    • s:rur(/w: स्वैप, डुबकी, m-iस्टैक के शीर्ष पर जाएं, क्षरणm-i
  • शून्य शाखा
    • B: रिवर्स ढेर (अब है जो mकी प्रतियां a: a... b m)
    • n: नकारात्मक m(इसलिए हम ?बाईं ओर मुड़ने के लिए उपयोग कर सकते हैं )
    • ) : वेतन वृद्धि
    • ? : यदि शून्य हो तो सीधे जाएं, यदि नकारात्मक हो तो बाएं मुड़ें
  • नकारात्मक शाखा (डुप्लिकेट b)
    • s:r\/rw)\ मूल रूप से सकारात्मक शाखा के समान है लेकिन वृद्धि और बाएं मुड़ता है।
  • शून्य शाखा (आउटपुट को प्रिंट करती है)
    • >v;: 0स्टैक बंद पॉप (जैसा दिखता है)a...b... )
    • /B : स्टैक को उल्टा करें
    • I : पढ़ो n
    • s : स्वैप प्रिंट लूप:
  • oq : प्रिंट और स्टैक के निचले भाग पर अब जैसे दिखता है: ab...a...n
  • ( घटती n
  • ? : सकारात्मक होने पर दाएं मुड़ें, शून्य होने पर सीधे जाएं
  • यदि सही है: /su ढेर के ऊपर स्वैप करें और लूप जारी रखें
  • यदि शून्य, /नीचे दर्शाया गया है और मूल्यांकन किया गया कोड है Iru@; @कार्यक्रम को समाप्त करता है।
— ग्यूसेप
स्रोत
0

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

…⁺×ζＩθ×εＮＮ

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है और इसमें चौथा उदाहरण भी शामिल है। (यदि मैं अंतिम से पहले एक जोड़ दूं तो deverbosifer विभाजक को नहीं हटाएगा InputNumber()।)

— नील
स्रोत
आपको विभाजक से क्या मतलब है? (क्या आप एक उदाहरण दे सकते हैं)
— केवल
@ ASCII- केवल अंतिम InputNumber () से पहले अल्पविराम के साथ, ध्यान दें कि उत्पन्न कोड में एक अनावश्यक विभाजक है: ऑनलाइन प्रयास करें!
— नील
0

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

T=Table;StringTake[""<>Flatten@T[{#3~T~#,#4~T~#},⌈#2/#⌉],#2]&

इनपुट

[2,10, 'ए', 'बी']

— J42161217
स्रोत
0

मैथेमेटिका, 44 बाइट्स

StringPadRight[x={##3}~Table~#<>"",#2,x]&

व्याख्या

तीन बाइट निजी उपयोग का पात्र है U+F3C7, जो कि \[Transpose]मैथमेटिका में पोस्टफिक्स ऑपरेटर का प्रतिनिधित्व करता है । कोई TIO लिंक नहीं है क्योंकि मैथिक्स समर्थन नहीं करता है , \[Transpose]गलत ऑपरेटर पूर्वता है, Tableएक सूची होने के लिए दूसरे तर्क की आवश्यकता होती है, और सबसे महत्वपूर्ण बात, StringPadRightइसे लागू नहीं किया जाता है।

                                         & (* Function *)
                 {##3}                     (* which takes the third and fourth arguments *)
                      ~Table~#             (* repeats them a number of times equal to the first argument *)
                                          (* takes the tranpose *)
                               <>""        (* then joins the strings with the empty string *)
               x=                          (* sets x equal to that string *)
StringPadRight[                            (* then pads x *)
                                   ,#2     (* to a length equal to the second argument *)
                                      ,x]  (* with x. *)
— ngenisis
स्रोत
0

एपीएल (डायलॉग) , 5 बाइट्स

⎕⍴⎕/⎕

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

इसके बाद mऔर फिर पहले इनपुट के रूप में एक स्ट्रिंग में दो वर्ण लेता हैn ।

व्याख्या

उदाहरण के इनपुट होने दो 'ab', 2, 10।

⎕/⎕                 Replicate the two-char string `m` times
                    2/'ab' => 'aabb'
⎕⍴                  Shape it so that its length is `n`
                    10⍴'aabb' => 'aabbaabbaa'
— क्रिक्टी लिथोस
स्रोत
0

चिप , 588 बाइट्स

*Z~vZ.*ZZZs  z. z. z. z. z. z. z. z.
  ,'|`-. ZZ--#<,#<,#<,#<,#<,#<,#<,#<
a/mAM/a| `~S `x'`x'`x'`x'`x'`x'`x'`x.
b/mBM/b|  *.)/')/')/')/')/')/')/')/'|
c/mCM/cZv--x^x-^x-^x-^x-^x-^x-^x-^x-'
d/mDM/d||A~#M',-',-',-',-',-',-',-'
e/mEM/e||B~#M-',-',-',-',-',-',-'
f/mFM/f||C~#M--',-',-',-',-',-'
g/mGM/g||D~#M---',-',-',-',-'
h/mHM/h||E~#M----',-',-',-'
 `v~v' ||F~#M-----',-',-'
* `mz  ||G~#M------',-'
Z  `---x'H~#M-------'
Z,--z--^----'
Z|z. z. z. z. z. z. z. z.
Zx#<,#<,#<,#<,#<,#<,#<,#<
 |`x'`x'`x'`x'`x'`x'`x'`xT
 |A| B| C| D| E| F| G| H|
 )\')\')\')\')\')\')\')\'
 `--^--^--^--^--^--^--'

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

4-वर्ण स्ट्रिंग के रूप में इनपुट लेता है। पहले दो अक्षर a और b हैं , उसके बाद बाइट मान m और फिर बाइट मान n है । उदाहरण के लिए, TIO इनपुट शामिल ab<tab>2, 'एक', 'बी', 9, 50 को यह मेल खाती है (के लिए कोड के बाद से <tab>और 29 और 50 हैं।

कैसे?

यह उत्तर एक सा है, लेकिन यहाँ पर प्रकाश डाला गया है:

ऊपरी बाएँ ब्लॉक, लोअरकेस के साथ a- h, वर्णों के लिए भंडारण तंत्र है a और b , बिट प्रति एक लाइन। इसके निचले भाग में, के साथ v~vऔर mzदोनों के बीच स्वैप करने के लिए, स्विचिंग तंत्र है।

बीच में एक स्तंभ है जिसमें एक गुच्छा है ~#M। यह मीटर में पढ़ता है और अपने नकारात्मक को संग्रहीत करता है। दाईं ओर बड़ा त्रिभुज इस मान को ऊपरी संचयकर्ता में लाने के लिए सिर्फ तार है।

ऊपरी दायां ब्लॉक मी के लिए संचायक है । यह हर चक्र (शुरुआत से -m ) को बढ़ाता है जब तक कि यह शून्य तक नहीं पहुंचता। जब ऐसा होता है, आउटपुट वर्ण स्वैप किया जाता है, और -m से पुनरारंभ गिनती होती है ।

इस बीच, निचला ब्लॉक है, जो कि एन संचायक है। चूंकि n केवल एक बार पढ़ा जाता है, इसलिए हमें इस मान को संग्रहीत करने के लिए मेमोरी ( Mऔर m) के बैंक की आवश्यकता नहीं है । हम बस इसे नकारते हैं और गिनना शुरू करते हैं। जब यह मान शून्य पर पहुंच जाता है, तो पूरे शेबंग को समाप्त कर दिया जाता है।

अन्य सभी बक देरी (है Zऔर z), तारों ( -, |, ...), और अन्य विविधतापूर्ण संग्रह।

— Phlarx
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.