स्वचालित बॉक्स विस्तारक


16

परिचय

कभी-कभी, इसमें कुछ भी फिट करने के लिए मेरे बॉक्स बहुत छोटे होते हैं। मुझे आपको बॉक्स विस्तारक बनाने की आवश्यकता है! तो, क्या इस चुनौती में एक बॉक्स एक बॉक्स बनाता है।

 OOOO
O    O
O    O
O    O
 OOOO

बॉक्स के कोने हमेशा रिक्त स्थान होते हैं । बॉक्स को उसी पात्र से बाहर किया जा सकता है। वह पात्र किसी भी मुद्रण योग्य ASCII वर्ण का हो सकता है , एक स्थान को छोड़कर। तो, ये वर्ण हैं:

!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~

ऊपर बॉक्स की साइड की लंबाई 4, 3 है । आप मान सकते हैं कि पक्ष की लंबाई हमेशा सकारात्मक होती है । इसका मतलब है कि यह सबसे छोटा बॉक्स है जिसे आपको संभालना है:

 #
# #
 #

एक बॉक्स का विस्तार करने के लिए, आपको प्रत्येक पक्ष की लंबाई बढ़ाना होगा। उपरोक्त उदाहरण के साथ, चरण दर चरण इस के माध्यम से चलते हैं। हम पहले बॉक्स के ऊपरी हिस्से को लेते हैं, जो है:

 OOOO

हम एक-एक करके इसका विस्तार करते हैं, इसलिए हम प्राप्त करते हैं:

 OOOOO

यह बॉक्स का ऊपरी और निचला हिस्सा है। उसके बाद, हम बाईं और दाईं ओर के पक्षों के साथ भी ऐसा ही करते हैं:

O
O
O

हो जाता है:

O
O
O
O

अब हम बॉक्स को फिर से इकट्ठा करते हैं, जिसके परिणामस्वरूप:

 OOOOO
O     O
O     O
O     O
O     O
 OOOOO

काम

एक बॉक्स को देखते हुए, इसे 1 से विस्तृत करें। बॉक्स को कई लाइनों में, या एक सरणी में दिया जा सकता है।

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

 OOOO          OOOOO
O    O    >   O     O
 OOOO         O     O
               OOOOO

 XXXXXX        XXXXXXX
X      X  >   X       X
X      X      X       X
 XXXXXX       X       X
               XXXXXXX

 ~             ~~
~ ~       >   ~  ~
 ~            ~  ~
               ~~

यह , इसलिए कम से कम बाइट्स जीत के साथ सबमिशन!


1
क्या इससे पहले बॉक्स में एक नई लाइन हो सकती है?
रिले

@ रिले हां, इसकी अनुमति है :)।
अदनान

1
क्या बॉक्स रिक्त स्थान के साथ गद्देदार हो सकता है?
लीक

@LeakyNun हां, आप ऐसा कर सकते हैं।
अदनान

जवाबों:


4

वी , 6 5 बाइट्स

yêpjÄ

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

यह वास्तव में यह होना चाहिए की तुलना में एक बाइट है। इसे होना चाहिए था:

äêjÄ

लेकिन यह एक अज्ञात बग है। :(

स्पष्टीकरण:

yê     "yank this colum
  p    "paste what we just yanked
   j   "move down to line 2
    Ä  "and duplicate this line

दूसरा क्या करता है?
कॉनर ओ'ब्रायन

@ ConorO'Brien äएक डुप्लीकेट ऑपरेटर (अनिवार्य रूप से "y" और "p" एक बाइट में एक साथ है) तो äê"डुप्लिकेट कॉलम" है
DJMcMayhem

11

विम, 7 बाइट्स

♥GYPjYp

जहां ♥ नियंत्रण-वी है।

           The cursor starts on the first non-whitespace character of the first line.
♥G         Enter visual block mode and go to bottom of document.
  YP       Duplicate this column.
    j      Move down to the second line of the file.
     Yp    Duplicate this line.

यहाँ छवि विवरण दर्ज करें


YPनिरंतरता के लिए दोनों समय का उपयोग क्यों नहीं किया जाता है ?
नील

pएनीमेशन रिकॉर्ड करते समय मैं गलती से हिट हो गया, इसलिए मैं उत्तर को ट्रांसक्रिप्ट करते समय इसके साथ चिपक गया। फर्क पड़ता है क्या? > _>;
लिन

मुझे सिर्फ असंगतता अजीब लगी, लेकिन मुझे आपका स्पष्टीकरण पसंद है।
नील

यह ठीक मेरे वी उत्तर के समान है, बस मैं एक-बाइट मैपिंग बनाने के लिए हुआ था <C-v> Gऔर YP। यह थोड़े मेरी भाषा को सस्ता लगता है। : /
DJMcMayhem

एचएम, कंट्रोल-वी मेरे फोन पर दिल के रूप में दिखता है ... Dec
बीटा डेके

6

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

s=>s.replace(/^.(.)/gm,s="$&$1").replace(/(\n.*)/,s)

स्पष्टीकरण: पहला regexp दूसरे कॉलम को डुप्लिकेट करता है और दूसरा regexp दूसरी पंक्ति को डुप्लिकेट करता है, इस प्रकार बॉक्स को वांछित के रूप में बड़ा करता है। संपादित करें: मार्टिनएंडर के लिए धन्यवाद 4 बाइट्स सहेजे गए by


6

पायथन, 49 42 बाइट्स

अनाम लंबोदर:

-7 xnor से

lambda s:[t[:2]+t[1:]for t in s[:2]+s[1:]]

पुराना वर्जन:

D=lambda s:s[:2]+s[1:]
lambda s:D(list(map(D,s)))

D एक ऐसा फंक्शन है जो एक सीक्वेंस के दूसरे आइटम को डुप्लिकेट करता है।


1
फ़ंक्शन को फिर से उपयोग करने का विचार चतुर है, लेकिन यह कोड को दोहराने के लिए छोटा लगता है lambda L:[s[:2]+s[1:]for s in L[:2]+L[1:]]:।
xnor

पिछले संस्करण के लिए साइड नोट: मुझे लगता है कि map(D,D(s))इसके बजाय 43 देंगे
Sp3000

5

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

बाइट गिनती आईएसओ 8859-1 एन्कोडिंग मानती है।

1`¶
¶$%'¶
%2=`.
$&$&

इसे ऑनलाइन आज़माएं! (कई अतिरिक्त लाइनें हैं जो एक परीक्षण सूट को सक्षम करती हैं जहां परीक्षण मामलों को दो लाइनफीड द्वारा अलग किया जाता है।)

व्याख्या

1`¶
¶$%'¶

1एक सीमा है जो रेटिना को केवल पहले मैच के लिए प्रतिस्थापन को लागू करने के लिए प्रतिबंधित करती है। एकल लाइनफ़ीड से मेल खाता है, इसलिए हमें केवल पहली पंक्ति के अंत में लाइनफ़ीड को बदलने पर विचार करने की आवश्यकता है। इसे बदल दिया जाता है ¶$%'¶, जहां $%'मैच (एक रेटिना-विशिष्ट प्रतिस्थापन तत्व) के बाद पूरी लाइन सम्मिलित होती है। इसलिए, यह दूसरी पंक्ति को डुप्लिकेट करता है।

%2=`.
$&$&

यहां, %प्रति-पंक्ति मोड है, इसलिए प्रत्येक पंक्ति को व्यक्तिगत रूप से संसाधित किया जाता है, और लाइनों को बाद में फिर से जोड़ा जाता है। 2=यह भी एक सीमा है। इसका मतलब है "केवल दूसरे मैच के लिए प्रतिस्थापन लागू करें"। मैच अपने आप में सरल एकल चरित्र है और प्रतिस्थापन इसे डुप्लिकेट करता है। इसलिए, यह चरण दूसरे कॉलम को डुप्लिकेट करता है।


5

हास्केल, 24 बाइट्स

f(a:b:c)=a:b:b:c
f.map f

दूसरी पंक्ति और कॉलम को डुप्लिकेट करने के लिए RootTwo के विचार का उपयोग करता है । map fप्रत्येक पंक्ति को यह करता है, और f.उसके बाद पंक्तियों को यह नहीं करता है।


4

PowerShell v2 +, 57 53 52 बाइट्स

param($n)($n-replace'^.(.)','$&$1')[0,1+1..$n.count]

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

मार्टिन को धन्यवाद के लिए 4 बाइट्स बचाए।

कुछ उदाहरण:

PS C:\Tools\Scripts\golfing> .\automatic-box-expander.ps1 ' oooo ','o    o',' oooo '
 ooooo 
o     o
o     o
 ooooo 

PS C:\Tools\Scripts\golfing> .\automatic-box-expander.ps1 ' # ','# #',' # '
 ## 
#  #
#  #
 ## 

2
@MartinEnder हां, धन्यवाद, हे वाइज़ रेगेक्स-सेंसि।
AdmBorkBork


3

MATL , 12 बाइट्स

tZy"@:2hSY)!

इनपुट एक 2 डी चार सरणी है, जिसमें अर्धविराम पंक्ति विभाजक के रूप में है। उदाहरण के लिए, पहले परीक्षण मामले में इनपुट है

[' OOOO ';'O    O';' OOOO ']

इसे ऑनलाइन आज़माएं! परीक्षण के मामलों 1 , 2 , 3

व्याख्या

कोड निम्न दो बार करता है: सरणी की दूसरी पंक्ति को दोहराएं और स्थानांतरित करें।

m× nसरणी की दूसरी पंक्ति को दोहराने के लिए , वेक्टर [1 2 2 3 ... m]का उपयोग पंक्ति सूचकांक के रूप में किया जाता है। यह वेक्टर निम्नानुसार उत्पन्न होता है: रेंज [1 2 3 ... m], एक और संलग्न करें 2, सॉर्ट करें।

t       % Take input implicitly. Duplicate
Zy      % Size of input as a two-element array [r, c]
"       % For each of r and c
  @     %   Push r in first iteration (or c in the second)
  :     %   Generate range [1 2 3 ... r] (or [1 2 3 ... c])
  2hS   %   Append another 2 and sort
  Y)    %   Apply as row index
  !     %   Transpose
        % End for. Display implicitly


2

एसईडी ६ ९ (१४ + १ फॉर-आर) १५

s/.(.)/&\1/;2p   

1
तुम सिर्फ ऐसा नहीं कर सकते /.\(.\)/\0\1;2p?
नील

@ नील मैंने उसके लिए सब कुछ देखा 2p, मुझे लगा कि इसे करने का एक तरीका है, लेकिन मुझे यह नहीं मिला। धन्यवाद!
रिले

जब तक आप r ध्वज के लिए 1 बाइट जोड़ते हैं, तब तक -r '' भाग की आवश्यकता नहीं होती है, इस प्रकार 3 बाइट की बचत होती है। इसके अलावा, चूंकि आपने कोड का अपना पहला संस्करण संपादित किया है, इसलिए अंत में स्पष्टीकरण मान्य नहीं है।
शेषमारा

@Neil को मेरी आँखों पर विश्वास नहीं हो रहा था जब मैंने पीछे की तरफ देखा \0, क्योंकि वे 1 से शुरू करते हैं। GNU सेड का ऑनलाइन मैनुअल इसके बारे में कुछ नहीं बोलता है। हालाँकि, का उपयोग कर &मुझे लगता है कि समकक्ष और कम है।
शेषमारा

@seshoumara आह, उन regexp संस्करण सूक्ष्मता ... जो एक \0तो उपयोग करता है ?
नील

1

CJam , 14 बाइट्स

q~{~\_@]z}2*N*

मेरे MATL उत्तर के समान , लेकिन दूसरी के बजाय दूसरी-अंतिम पंक्ति दोहराता है।

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

व्याख्या

q                e# Read input
 ~               e# Interpret as an array
  {      }2*     e# Do this twice
   ~             e# Dump array contents onto the stack
    \            e# Swap top two elements
     _           e# Duplicate
      @          e# Rotate
       ]         e# Pack into an array again
        z        e# Zip
            N*   e# Join by newlines. Implicitly display

1

के, 15 बाइट्स

2{+x@&1+1=!#x}/

वर्णों के मैट्रिक्स के रूप में इनपुट लेता है:

  b: (" OOOO ";"O    O";" OOOO ")
(" OOOO "
 "O    O"
 " OOOO ")

एक फ़ंक्शन को दो बार लागू करें ( 2{…}/) जो +सही तर्क के अनुक्रमित ( ) को एक प्लस x@के वृद्धिशील रन-लंबाई डिकोड ( &) से जोड़कर ( 1+1 के बराबर स्थानों की सूची 1=) ( 0) से सीमा तक देता है। (! ) सही तर्क के बाहरी आयाम का आकार ( #x)।

क्रमशः,

  #b
3
  !#b
0 1 2
  1=!#b
0 1 0
  1+1=!#b
1 2 1
  &1+1=!#b
0 1 1 2
  b@&1+1=!#b
(" OOOO "
 "O    O"
 "O    O"
 " OOOO ")
  +b@&1+1=!#b
(" OO "
 "O  O"
 "O  O"
 "O  O"
 "O  O"
 " OO ")
  2{+x@&1+1=!#x}/b
(" OOOOO "
 "O     O"
 "O     O"
 " OOOOO ")

इसे यहां ओके के साथ आजमाएं ।


1

एपीएल, 17 15 बाइट्स

{⍉⍵⌿⍨1+2=⍳≢⍵}⍣2

परीक्षा:

      smallbox largebox
┌───┬──────┐
│ # │ OOOO │
│# #│O    O│
│ # │O    O│
│   │O    O│
│   │ OOOO │
└───┴──────┘
      {⍉⍵⌿⍨1+2=⍳≢⍵}⍣2 ¨ smallbox largebox
┌────┬───────┐
│ ## │ OOOOO │
│#  #│O     O│
│#  #│O     O│
│ ## │O     O│
│    │O     O│
│    │ OOOOO │
└────┴───────┘

स्पष्टीकरण:

             ⍣2   run the following function 2 times:
{           }     stretch the box vertically and transpose
         ⍳≢⍵      indices of rows of box
       2=         bit-vector marking the 2nd row
  ⍵/⍨1+           replicate the 2nd row twice, all other rows once
 ⍉                transpose

APL प्रतीक मोनैडिक matrix मैट्रिक्स ट्रांसपोज़ है, जो 90 डिग्री तक घूमने जैसा नहीं है।
जॉन

1
@ जॉन: बिल्कुल। मैंने जितना सोचा था उससे अधिक थक गया हूँ। वास्तव में 90 डिग्री तक घूमना ⌽⍉या होगा ⊖⍉, लेकिन इस मामले में कोई फर्क नहीं पड़ता।
मारिनस

0

लिस्टशेयर , 326 बाइट्स

STRG a=READ[<here>+"\\a.txt"]
ROWS p=ROWSPLIT a BY ["\r\n"]
ROWS p=GETLINES p [1 TO p LENGTH-1]
ROWS p=p+p[1]+p[0]
STRG o=p[0]
ROWS y=EXTRACT COLLUM[2] FROM p SPLIT BY [""]
ROWS x=EXTRACT COLLUM[3] FROM p SPLIT BY [""]
[FOREACH NUMB IN 1 TO o LENGTH-1 AS i]
ROWS m=COMBINE[m,x] WITH [""]
ROWS m=COMBINE[y,m,y] WITH [""]
SHOW=m

मैं निश्चित रूप से से कार्यों के घोंसले को जोड़ने की आवश्यकता है, लेकिन यह बहुत अच्छी तरह से काम करता है

यदि आप स्पष्टीकरण चाहते हैं तो टिप्पणी करें


0

जावास्क्रिप्ट, 160 146 141 बाइट्स

s=>{a=s[1];r="";l=s.split("\n");m=l.length;n=l[0].length;for(i=0;i<=m;i++){for(j=0;j<=n;j++)r+=!(i%m)&&j%n||i%m&&!(j%n)?a:" ";r+="\n"}return r}

0

दिल्लोग एपीएल , 14 बाइट्स

(1 2,1↓⍳)¨∘⍴⌷⊢

(

1 2, {, 2,} को पूर्व निर्धारित

1↓ एक तत्व से गिरा

सूचकांकों

प्रत्येक की

का

{पंक्ति-गणना, स्तंभ-गणना}

में अनुक्रमित करता है

बहस

जैसे के लिए

 XX
X  X
 XX

हम सूचकांक पाते हैं; {पंक्तियों के लिए, और कॉलमों के लिए {1, 2, 3, 4}। अब हम {2, 3} और {2, 3, 4} पाने के लिए प्रारंभिक तत्वों को छोड़ देते हैं, और फिर {1, 2}, 2, 3} और {1, 2, 2, को देते हुए {1, 2} के साथ शुरू करते हैं। 3, 4}। अंत में, हम पंक्तियों और स्तंभों का चयन करने के लिए इसका उपयोग करते हैं, साथ ही साथ पंक्ति 2 और स्तंभ 2 को दोगुना करते हैं।

TryAPL ऑनलाइन!


0

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

->a{a.map{|r|r.insert(2,r[1])}.insert(2,a[1])}

लाइनों के सरणी के रूप में इनपुट लेते हुए बहुत स्ट्रेघफोरवर्ड सॉल्यूशन। मुझे डुप्लिकेट inserts पसंद नहीं है , इसलिए इसे गोल्फ करने की कोशिश करूंगा।


0

सी #, 127 124 बाइट्स

s=>{int n=s.Count-1,i=0;s[0]=s[n]=s[0].Insert(1,s[0][1]+"");s.Insert(1,s[1]);for(;i++<n;)s[i]=s[i].Insert(1," ");return s;};

के संकलन करता है Func<List<string>, List<string>>

प्रारूपित संस्करण:

s =>
{
    int n = s.Count - 1, i = 0;

    s[0] = s[n] = s[0].Insert(1, s[0][1] + "");

    s.Insert(1, s[1]);

    for (; i++ < n;)
        s[i] = s[i].Insert(1, " ");

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