ASCII कला मजेदार है। आधुनिक पाठ संपादक पाठ में हेरफेर करने में बहुत अच्छे हैं। क्या आधुनिक प्रोग्रामिंग भाषाएं कार्य तक हैं?

ASCII कला हेरफेर में एक सामान्य कार्य पाठ को दो वर्णों के बीच एक आयत में क्रॉप करना है। यह वह कार्य है जिसे आपको इस चुनौती में लागू करना चाहिए।

विवरण

आपका कार्यक्रम 3 इनपुट लेगा:

पहला ब्लॉक का 'स्टार्ट' कैरेक्टर है - टॉप-लेफ्ट कॉर्नर पर
दूसरा ब्लॉक का 'अंत' अक्षर है - नीचे-दाएं कोने को चिह्नित करना
तीसरा बहुस्तरीय पाठ का कुछ रूप है, या तो एक तार, या तार की सूची, या फ़ाइल नाम, या जो भी हो

परिणाम बहुस्तरीय पाठ होगा (फिर से, उपरोक्त किसी भी प्रारूप में) दिए गए इनपुट के बीच आयत के लिए फसली। ध्यान दें कि पहले दो इनपुट अद्वितीय नहीं हो सकते हैं।

किनारे के मामले

बक्से में हमेशा कम से कम मात्रा होनी चाहिए 2. इस प्रकार:

()     (
       )

हैं बक्से लेकिन इन:

)(     )      (
       (     )

नहीं हैं (शुरुआत = (और अंत = के साथ ))।

इनपुट में केवल एक बॉक्स होगा। इस प्रकार प्रारंभ और अंत वर्ण केवल एक बार होने चाहिए, जब तक कि वे एक ही वर्ण न हों जिस स्थिति में उन्हें ठीक दो बार होना चाहिए।

इसके अतिरिक्त इनपुट में प्रत्येक पंक्ति कम से कम तब तक होनी चाहिए जब तक इनपुट में बॉक्स के दाहिने किनारे से लाइन के शुरू होने की दूरी हो।

आपके प्रोग्राम को अमान्य इनपुट को संभालने की आवश्यकता नहीं है; वे अपरिभाषित व्यवहार में परिणाम कर सकते हैं।

नियम

विशिष्ट कोड-गोल्फ नियम लागू होते हैं। सबसे छोटा कोड जीतता है।

उदाहरण

गर्म उजला दिन: start: ( end: ) input:

This is some text
. (but this text
  is in a box  ).
So only it is important.

आउटपुट:

(but this text
is in a box  )

क्षैतिज स्थान के स्ट्रिपिंग पर भी ध्यान दें। ASCII कला फसलें 2d हैं।

बारिश का दिन: start: ( end: ) input:

This is some text (
But is that even  )
really a box?

आउटपुट:

(
)

एक ही शुरू / अंत: start: / end: / input:

Oh, I get how this could be useful
 /----------------------------\
 | All this text is in a box! |
 \----------------------------/

आउटपुट:

/----------------------------\
| All this text is in a box! |
\----------------------------/

अमान्य निवेश: start: ( end: ) input:

Boxes are rectangular ( so this has
0 volume ) which is illegal.

अमान्य इनपुट 2: start: ( end: ) input:

(The lines must already be square 
so this line that is too short
relative to this end, is illegal)

code-golf ascii-art

— LambdaBeta
स्रोत

उस बॉक्स के बाहर वाली लाइन के साथ मान्य बॉक्स के बारे में क्या?

— seadoggie01

1

स्पष्ट, अमान्य इनपुट

— लैंबडाबेटा

अमान्य इनपुट के मामले में परिणाम क्या होना चाहिए? या वे उल्लेख कर रहे हैं तो उन्हें ध्यान नहीं दिया जाएगा?

— उरईल

1

परिणाम सी में अपरिभाषित व्यवहार की तरह है, इसके बारे में चिंता मत करो, कुछ भी हो जाता है।

— लैंबडाटा

यह एक छोटी सी चुनौती है: अच्छा काम!

— seadoggie01

15

विम, 16 , 12 बाइट्स / कीस्ट्रोक्स

#<C-v>Nj*yggVGp

इसे ऑनलाइन आज़माएं! वी दुभाषिया में

आधुनिक पाठ संपादक पाठ में हेरफेर करने में बहुत अच्छे हैं। क्या आधुनिक प्रोग्रामिंग भाषाएं कार्य तक हैं?

मुझे यकीन है कि पुराने पाठ संपादक भी बेहतर हैं! : डी

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

 rectangular (
) which is ill

तथा

(The lines must already be square
so this line that is too short
relative to this end, is illegal)

स्पष्टीकरण:

#               " Move backward to the previous occurrence of the word (or in this case, character) under the cursor
 <C-v>          " Start a visual block selection
      N         " Go to the next occurrence of the last searched term (guaranteed to be line 1)
       j        " Move down a line
        *       " Move forward to the next occurrence of the character under the cursor
         y      " Yank (copy) the whole visually selected block
          gg    " Go to line 1
            VG  " Select every line
              p " And paste what we last copied over it, deleting the whole buffer and replacing it with the block

— जेम्स
स्रोत

1

संयोग से यह वास्तव में उपयोग-मामला है जो मुझे इस चुनौती को लिखने के लिए संकेत देने के लिए कर रहा था। मेरे पास मेरा क्यू मैक्रो था /\/<cr><c-v>nygv$o0dpया ऐसा कुछ था जो बहुत लंबे समय तक था :)

— लैम्ब्डाबेटा

2

हाँ, आयताकार सबसे बीमार है !

— AdmBorkBork

6

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

=€SŒṪr/,þ/Zœị

बाईं ओर वर्णों की सूची और अंत की सूची और वर्णों की सूची (वर्णों की सूची के रूप में) के दाईं ओर एक डायैडिक लिंक, जो रेखाओं की एक सूची देता है (वर्णों की सूची के रूप में)।

इसे ऑनलाइन आज़माएं! (पूर्ण कार्यक्रम - यदि इनपुट वैध पायथन हैं तो उन्हें पायथन-स्ट्रिंग-कोटिंग की आवश्यकता होगी।)

कैसे?

=€SŒṪr/,þ/Zœị - Link: [start, stop], lines
 €            - for each (of [start, stop]):
=             -   equals? (vectorises across the lines)
  S           - sum (vectorises)
   ŒṪ         - multi-dimensional truthy (i.e. non-zero) indices
      /       - reduce by:
     r        -   inclusive range (vectorises)
         /    - reduce by:
        þ     -    outer product with:
       ,      -       pair
          Z   - transpose
           œị - multi-dimensional index-into (the lines)

एक उदाहरण के रूप में, बाएं = ['a', 'b']दाएं और (पात्रों की सूची की एक सूची के रूप में - रेखाएं):

--------
--a+++--
--++++--
--+++b--
--------

=€दो सूचियों की सूची की सूची देता है (पहला प्रदर्शन 'a'=, दूसरा 'b'=):

00000000         00000000
00100000         00000000
00000000    ,    00000000
00000000         00000100
00000000         00000000

इस सूची में से एक सूची का योग करें (तत्व-वार को संक्षेप करें):

ŒṪतब हमें गैर-शून्य के बहु-आयामी सूचक देता है, [[2,3],[4,6]]- अर्थात [[top,left],[bottom,right]]।

r/तब वह कार्य करता है [2,3]r[4,6], जो कि rवेक्टराइज़ के बाद से , जैसे - से [2r4, 3r6]मूल्यांकन करता है ।[[2,3,4],[3,4,5,6]][rows,columns]

,þ/फिर एक बाहरी पॉडक्ट अनुदेश है और जोड़ी है [2,3,4],þ[3,4,5,6]जहां प्रदर्शन करता है। यह स्तंभ के सभी मानों को इस मामले में देता है:þ,[row,column]

[[[2,3],[3,3],[4,3]],
 [[2,4],[3,4],[4,4]],
 [[2,5],[3,5],[4,5]],
 [[2,6],[3,6],[4,6]]]

हम इन्हें पंक्ति द्वारा चाहते हैं, इसलिए Zइसका उपयोग इसके लिए किया जाता है:

[[[2,3],[2,4],[2,5],[2,6]],
 [[3,3],[3,4],[3,5],[3,6]],
 [[4,3],[4,4],[4,5],[4,6]]]

अंत œịमें इनपुट लाइनों में वापस अनुक्रमित करें:

a+++
++++
+++b

यह ध्यान देने योग्य है कि जब दोनों बाउंडिंग वर्ण समान होते हैं तो =€दोनों की पहचान दो बार होती है लेकिन SŒṪसही काम करना समाप्त होता है, क्योंकि 2सत्य है, जैसे ['a','a']:

--------         00000000   00000000        00000000
--a+++--         00100000   00100000        00200000
--++++--  =€ ->  00000000 , 00000000  S ->  00000000  ŒṪ ->  [[2,3],[4,6]]
--+++a--         00000100   00000100        00000020
--------         00000000   00000000        00000000

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

... मैं स्पष्टीकरण पढ़ता हूं, लेकिन मैं अभी भी इसे नहीं समझता हूं। o_o क्या आप एक काम किया उदाहरण जोड़ सकते हैं, शायद?

— DLosc

प्रोत्साहन: यदि यह पूरी तरह से समझाया गया है तो मैं आपके उत्तर को स्वीकार करूँगा। :)

— लैम्ब्डाबेटा

1

@DLosc - किया, आशा है कि यह मदद करता है।

— जोनाथन एलन

@LambdaBeta - V का उत्तर छोटा है।

— जोनाथन एलन

... विम जवाब तक भी।

— जोनाथन एलन

5

APL (Dyalog) , 38 30 बाइट्स

4 बाइट्स ने @EriktheOutgolfer को धन्यवाद दिया

(1-⍨w-⍨⊃⍸⎕=s)↑(w←∊⊃⌽⍸⎕=s)↑s←↑⎕

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

— Uriel
स्रोत

बहुत जटिल। आप वैक्टर के वेक्टर के बजाय एक मैट्रिक्स को स्वीकार कर सकते हैं, दो पदों के साथ मिल सकते हैं ⍸matrix∊separators, और उनके साथ ले / ड्रॉप कर सकते हैं

— ngn

(⍸a=⎕)↓(1+⍸a=⎕)↑a←⎕साथ⎕io←0

— ngn

@ ओएनजी ने कहा कि वर्णों की संख्या लाइनों के बीच भिन्न होती है इसलिए मैंने माना कि प्रसंस्करण से पहले इनपुट वेक्टर होना चाहिए। फिर भी, मुझे चयन भागों (पहले और बारी बारी से) की आवश्यकता है, यदि सीमांकक कुछ समय दिखाता है (तीसरा परीक्षण मामला देखें), लेकिन मुझे लगता है कि बूंद कुछ बाइट्स काटती है, इसलिए धन्यवाद! एक बार मैं पीसी

— Uriel

उफ़ ... मैं तीसरे मामले के बारे में भूल गया, क्षमा करें। तब हो सकता है: ⊃{⌽⊖⍵↓⍨⊃⍸⍺=⍵}/⎕⎕⎕(sic, 3 अनुगामी क्वैड के साथ) जो और भी छोटा है। या ... ⎕⎕(↑⎕)अगर एक पूर्व मिश्रित मैट्रिक्स की अनुमति नहीं है।

— ngn

3

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

œẹⱮẎQr/Ṛṭþ/œị⁸

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

— आउटगोल्फ को एरिक करें
स्रोत

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

— इल्मरी करोनें

@IlmariKaronen आपने दूसरे तर्क को ठीक से उद्धृत नहीं किया है (पोस्ट में इसका उल्लेख नहीं किया गया है); इसे सिंगल या डबल कोट्स में लपेटें। जिस तरह से आपने इसे लागू किया है, दूसरा तर्क एक खाली (पायथन) ट्यूपल ( ()) है, नहीं '()'। यदि यह पार्स-सक्षम है, तो इसे उद्धृत करने की आवश्यकता है, हालांकि, मुझे //उद्धृत करने की आवश्यकता नहीं है (बिना ऑपरेंड के पूर्णांक विभाजन? Hm ...)।

— आउटगॉल्फ

@ इल्मारिकारोन I "लगता है" कि ()सिर्फ कुछ खास तरह के चरित्र के रूप में जेली द्वारा व्याख्या की जा रही है। मैं जिन पात्रों की कोशिश करता हूं उनमें से अधिकांश जोड़े। मुझे यह सुनना अच्छा लगेगा कि लोग जेली के बारे में क्या सोचते हैं। संपादित करें: निंजा-एड ने एग्जीकलर को मिटा दिया

— लैम्ब्डाबेटा

ठीक है, हाँ, यह काम करता है।

— इल्मरी करोनें

3

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

def f(s,e,t):
 a=[(i,l.find(c))for i,l in enumerate(t)for c in s+e if c in l];r,c,R,C=a[0]+a[-1]
 for l in t[r:R+1]:print l[c:C+1]

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

— TFeld
स्रोत

2

कैनवस , 37 बाइट्स

｛³⁴⁰；ｘ≡‽┐
Ｘ⁸）Ｊ╵⁶；┤ω┤⁵Ｘ⁶⁸⁰Ｋ├；┐┤└∔┘┘∔；＠

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

पात्रों के निर्देशांक प्राप्त करने के लिए 36 बाइट्स (और उन्हें x, y, w, h में परिवर्तित करना क्योंकि यही ＠लगता है) और 1 बाइट के लिए उपधारा प्राप्त करना .. एक बेहतर दृष्टिकोण होना चाहिए

— dzaima
स्रोत

2

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

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

(x,y,a,X=Y=0)=>a.filter(s=>!Y&&(Y=-~s.indexOf(y,X?X-1:X=-~s.indexOf(x)),X)).map(s=>s.slice(X-1,Y))

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

टिप्पणी की गई

( x,                          // x = start character
  y,                          // y = end character
  a,                          // a[] = array of strings
  X =                         // X = position of x, plus 1
  Y = 0                       // Y = position of y, plus 1
) =>                          //
  a.filter(s =>               // for each string s in a[]:
    !Y &&                     //   reject this string if Y is non-zero
    (                         //   otherwise, use the 2nd condition:
      Y = -~s.indexOf(        //     update Y:
        y,                    //       by looking for y in s
        X ?                   //       if X is non-zero:
          X - 1               //         start the search at X - 1
        :                     //       else:
          X = -~s.indexOf(x)  //         update X and start the search at X
      ),                      //     end of Y update
      X                       //     keep this string if X is non-zero
    )                         //   end of 2nd condition
  )                           // end of filter()
  .map(s =>                   // for each remaining string s:
    s.slice(X - 1, Y)         //   remove left and right characters outside the box
  )                           // end of map()

— Arnauld
स्रोत

filter और map ! के साथ एक नया सरणी का निर्माण reduceया एक पुनरावर्ती समाधान कम काम नहीं करेगा? मेरे फोन पर, पब के नीचे या मैं इसे खुद जाने देता हूं।

— झबरा

@Shaggy शायद वास्तव में एक छोटा रास्ता नहीं है, लेकिन मुझे लगता है कि इस विधि 2 गुजरता उपयोग करने के लिए बर्बाद है: 2 पाश 1 से पहले एक समाप्त होता है और दोनों शुरू नहीं कर सकते Xऔर Yयकीन है कि के लिए जाना जाता है।

— अरनुलद

2

जावा 10, 204 बाइट्स

(s,e,a)->{int b=-1,i=0;for(;i<a.length;i++)a[i]=(b=b<0?a[i].indexOf(s):b)<0|a[i].length()<b?"":a[i].substring(b);for(b=-1;i-->0;)a[i]=(b=b<0?a[i].indexOf(e):b)<0|a[i].length()<b?"":a[i].substring(0,b+1);}

बाइट को बचाने के लिए एक नया वापस करने के बजाय इनपुट-सरणी को संशोधित करता है। इसका मतलब यह है कि हटाए गए लाइनों के ""बजाय हो जाते हैं, हालांकि। अगर इसकी अनुमति नहीं है तो मैं इसे बदल दूंगा।

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

स्पष्टीकरण:

(s,e,a)->{                 // Method with 2 Strings & String-array parameters and no return
  int b=-1,                //  Boundaries-integer, starting at -1
  i=0;for(;i<a.length;i++) //  Loop `i` in the range [0, amountOfLines)
    a[i]=                  //   Change the `i`th line in the array to:
      (b=b<0?              //    If `b` is -1:
          a[i].indexOf(s)  //     Set `b` to the index of `s` in the current line
                           //     (which is still -1 if it's not found)
         :                 //    Else (starting index already found)
          b                //     Leave `b` unchanged
      )<0                  //    Then, if `b` is -1,
         |a[i].length()<b? //    or the current line-length is too short:
       ""                  //     Remove the current line
      :                    //    Else:
       a[i].substring(b);  //     Shorten the line by removing every character before `b`
  for(b=-1;                //  Reset `b` to -1
      i-->0;)              //  Loop `i` in the range (amountOfLines, 0]
    a[i]=                  //  Change the `i`th line in the array to:
       (b=b<0?a[i].indexOf(e):b)<0|a[i].length()<b?"":
                           //   Similar as above (with end `e` instead of start `s`),
         a[i].substring(0,b+1);}
                           //   except we remove every character after `b` this time

उदाहरण के लिए:

इनपुट्स के साथ start = "(", end = ")"औरlines =

["This is some text",
 ". (but this text",
 "  is in a box  ).",
 "So only it is important."]

पहला लूप इसे शीर्ष और बाईं ओर क्रॉप करेगा, इसे इसे बदलकर:

["",
 "(but this text",
 "is in a box  ).",
 " only it is important."]

दूसरा लूप इसे नीचे और दाएं पर क्रॉप करेगा, इसे इसे बदलकर:

["",
 "(but this text",
 "is in a box  )",
 ""]

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

1

रेटिना 0.8.2 , 110 बाइट्स

^((.)¶.)(.*¶)+(.*\2)
$1¶$4
^(.)(¶.¶\1)
$2
}s`(?<=^.¶.+)¶.
¶
s`^¶(.)¶(.*\1).*
$2
+m`^((.)+).¶((?<-2>.)+)$
$1¶$3

इसे ऑनलाइन आज़माएं! स्पष्टीकरण:

^((.)¶.)(.*¶)+(.*\2)
$1¶$4

बॉक्स की पहली पंक्ति से पहले इनपुट लाइनों को हटा दें।

^(.)(¶.¶\1)
$2

यदि प्रारंभ वर्ण इनपुट के बाएं स्तंभ में है, तो उसे हटा दें।

}s`(?<=^.¶.+)¶.
¶

यदि प्रारंभ वर्ण अभी तक हटाया नहीं गया है, तो सभी इनपुट कॉलम एक-एक करके छोड़ दें और शुरुआत से दोहराएं।

s`^¶(.)¶(.*\1).*
$2

अंत वर्ण और अंत वर्ण के बाद इनपुट में सब कुछ हटा दें।

+m`^((.)+).¶((?<-2>.)+)$
$1¶$3

अगली पंक्ति की लंबाई तक सभी पंक्तियों को काटें। यह प्रत्येक पंक्ति पर सभी लेकिन एक वर्ण की गणना करके काम करता है, फिर अगली पंक्ति में उस कई वर्णों से मेल खाने का प्रयास करता है; यदि यह सफल होता है तो दूसरी पंक्ति कम थी, इसलिए अंतिम वर्ण हटा दिया जाता है और लूप दोहराता है।

— नील
स्रोत

0

सी (जीसीसी) , 237 बाइट्स

f(c,r,o,p)char*p,*c;{char*_=strchr(p,r),*a,b;*_=0;a=strrchr(p,10);a=(a?a:p);*_=r;r=_-a;p=a;_=strrchr(p,o);*_=0;a=strrchr(p,10);a=(a?a:p);*_=o;o=_-a+1;_[1]=0;for(_=p;_;_=strchr(_+1,10)){b=_[o];_[o]=0;strcat(c,_+r);strcat(c,"\n");_[o]=b;}}

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

मुझे यकीन है कि 99% यह एक चरित्र के क्षैतिज सूचकांक और सूचक को खोजने के लिए कुछ प्रकार के सहायक फ़ंक्शन का उपयोग करके छोटा किया जा सकता है, क्योंकि इसे दो बार दोहराया जाता है। काश मुझे ऐसा करने के लिए एक छोटा सा रास्ता नहीं मिल रहा था, अगर मुझे समय मिल जाए तो मैं फिर से कोशिश कर सकता हूं।

विवरण

f(c,r,o,p)char*p,*c;{
    char*_=strchr(p,r),*a,b;         // find opening char (and declare vars)
    *_=0;a=strrchr(p,10);            // find \n before it
    a=(a?a:p);                       // deal with single line inputs
    *_=r;r=_-a;                      // save left margin width in r
    p=a;                             // crop everything before opening line

    _=strchr(p,o);                   // find closing char
    *_=0;a=strrchr(p,10);            // find \n before it
    a=(a?a:p);                       // deal with single line inputs
    *_=o;o=_-a+1;                    // save width in o
    _[1]=0;                          // crop everything after closing char
    for(_=p;_;_=strchr(_+1,10)){       // for each line
        b=_[o];_[o]=0;
        strcat(c,_+r);
        strcat(c,"\n");
        _[o]=b;
    }
}

— LambdaBeta
स्रोत

1

इससे भी बेहतर: 219 बाइट्स

— Zacharý

0

स्टैक्स , 15 बाइट्स

╛↨½╝v∞░W╧)╗Ö≈☼k

इसे चलाएं और डीबग करें

यह इनपुट की पहली पंक्ति पर बॉक्स परिसीमन वर्ण (1 या 2) का सेट लेता है। बाकी लाइनें इनपुट बॉडी हैं।

अनपैक्ड, अनगुल्फेड और टिप्पणी की गई, यह इस तरह दिखता है।

            first line of input is the delimiter characters
dL          discard the first line of input and listify the rest into an array
{           begin block for iteration
  Mr        rotate matrix 90 degrees
  {         begin block for while loop
    ch      copy first row of block
    y|&C    if it insersects with the first line of input, break iteration
    D       drop the first line
  W         do-while loop until break
}4*         execute block 4 times
m           display result lines

इसको चलाओ

— पुनरावर्ती
स्रोत

फसल ASCII कला चुनौती

विवरण

किनारे के मामले

नियम

उदाहरण

विम, 16 , 12 बाइट्स / कीस्ट्रोक्स

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

कैसे?

APL (Dyalog) , 38 30 बाइट्स

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

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

कैनवस , 37 बाइट्स

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

टिप्पणी की गई

जावा 10, 204 बाइट्स

रेटिना 0.8.2 , 110 बाइट्स

सी (जीसीसी) , 237 बाइट्स

विवरण

स्टैक्स , 15 बाइट्स