पाठ की विकर्ण रेखाएँ खींचें


46

शब्दों की एक सूची के इनपुट को देखते हुए, शब्दों को उनके अक्षरों के साथ तिरछे व्यवस्थित करें:

p
 r
  o
p  g
 u  r
  z  a
a  z  m
 n  l  m
  d  e  i
c     s  n
 o        g
  d
g  e
 o
  l
   f

(इनपुट के लिए उपरोक्त आउटपुट होना चाहिए programming puzzles and code golf।)

सटीक होने के लिए, प्रत्येक शब्द पहले कॉलम और पिछले शब्द के नीचे तीन पंक्तियों पर शुरू होता है, और प्रत्येक क्रमिक अक्षर एक कॉलम को दाईं ओर और एक पंक्ति नीचे ले जाता है।

इनपुट को शब्दों के एकल स्ट्रिंग के रूप में प्रदान किया जा सकता है, जो वास्तव में एक स्थान, या शब्दों की एक सूची / सरणी द्वारा अलग किया गया है। शब्द केवल लोअरकेस अक्षरों से बने a-zहोंगे, और हमेशा कम से कम एक वर्ण लंबे होंगे।

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

आगे के परीक्षण के मामले:

a bcd efgh i j

a


b
 c
  d
e
 f
  g
i  h


j

x

x

verylongword short

v
 e
  r
s  y
 h  l
  o  o
   r  n
    t  g
        w
         o
          r
           d

चूंकि यह , बाइट्स में सबसे छोटा कोड जीत जाएगा!


मुझे ऐसा लगता है कि मुझे 5 मिनट में इसके लिए पायथन प्रोग्राम बनाने में सक्षम होना चाहिए, लेकिन यह हमेशा विफल हो रहा है ...; _;
हाइपरन्यूट्रिनो 3

वाह, ऐसा लगता है कि Turtlèd के लिए डिजाइन किए गए चुनौतियों का एक बहुत कुछ कर रहे हैं
विनाशकारी नींबू

क्या टर्मिनल एस्केप कोड की अनुमति है? :)
क्रोमियम

जवाबों:


17

विम, 85, 76, 66 , 52 कीस्ट्रोक्स / बाइट्स

जब मैंने पहली बार इस चुनौती को देखा, तो मैंने सोचा "यह विम के लिए एकदम सही है!" और फिर जब मैंने कोशिश की तो सब गड़बड़ हो गया। यहाँ यह है, यह गंदा गड़बड़ महिमा के सभी में है:

:se ve=all|s/ /\r\r\r/g
qqGo<esc>?\<.\S
lDjP@qq@qG?.
jdG

इसे ऑनलाइन आज़माएं, (अधिकतर) बैकवर्ड कम्पेटिबल वी दुभाषिया के लिए धन्यवाद।

स्पष्टीकरण:

पहले तो मुझे लगा कि मैं इस सुंदर सरल 37 बाइट संस्करण को कर सकता हूं:

:se ve=all
qq:g/\S\S/norm ^lDjP
@qq@q

दुर्भाग्य से, यह इतना आसान नहीं है। चलो इसे लाइन से लाइन लेते हैं:

:se ve=all

यह 'वर्चुअल एडिटिंग' नामक सुविधा को सक्षम करता है। यह कर्सर को उन स्तंभों पर जाने की अनुमति देता है जो अभी तक मौजूद नहीं हैं। यह उत्तर इसके बिना मूल रूप से असंभव होगा।

अब हमें अलग-अलग लाइनों पर शब्दों को अलग करना होगा। इसलिए हम प्रत्येक स्थान को 3 नईलाइनों से बदल देंगे। चूंकि यह एक पूर्व आदेश है, हम इसे अपने अंतिम पूर्व कमांड के :se ve=allसाथ दोनों को एक बार के साथ अलग करके चला सकते हैं ।

|s/ /\r\r\r/g

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

Programming


Puzzles


and


code-golf

यहीं से शुरू होती है मस्ती। हमने पारंपरिक पुनरावर्ती मैक्रो को इसके साथ सेट किया: qqऔर फिर इसे कॉल करें:

G               " Move to the last line
 o<esc>         " Append an extra newline

?               " Search backwards for
 \<.            " Any character at the beginning of a word
    \S          " Followed by a non-space character
l               " Move one character to the right
 D              " Delete eveything until the end of this line
  j             " Move down one line
   P            " Paste what we just deleted

फिर हम पुनरावर्ती मैक्रो के साथ समाप्त करते हैं @qq@q। इस बिंदु पर, हमारे पास सभी विकर्ण हैं, हमें बस थोड़ा साफ करने की आवश्यकता है।

G                   " Move to the last line
 ?.                 " Search backwards for any character
j                   " Move down one line
 dG                 " Delete until the end of the buffer

वाह, जावास्क्रिप्ट विम के मुकाबले (वर्तमान में) छोटा है। इन दिनों यह काफी दुर्लभ घटना है ...
ETHproductions

@ETHproductions कोई और नहीं। :)
DJMcMayhem

6

टर्टल , 28 26 बाइट्स

ओह माय, मैं विशेष रूप से गोल्फिंग के लिए डिज़ाइन की गई भाषा को पीटता हुआ प्रतीत होता हूं। यह एक महान दिन है।

!_4[*.[ rd+.]ul[ ul]r;_+]_

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

व्याख्या

(राइट का मतलब ग्रिड पर सेल को लिखने से है, नुकीले चार का अर्थ है इनपुट इन द स्ट्रिंग पॉइंटर पॉइंट्स)

!                         Take string input into variable
 _                        Normally conditional, with >1 input (there will be), write ' '
  4                       set register to 4
   [*                   ] until the current cell is *
     .                    Write pointed char, initially first char
      [     ]             Until space is written on cell
        rd+.              move right, down, string pointer++, write pointed char
             ul[ ul]      Move back up to the top of the word
                    r;    Move right, down 4 (because this is register value)
                      _+  write * if end of input, else ' ', increment string pointer
                        _ will always write ' ', since it will always point at start char

ध्यान देने की जगह।

इनपुट के लिए जगह भी चाहिए। अजगर के रूप में देखना एक सूची ले सकता है, यह टर्टल में एक सूची लेने जैसा है


5

MATL , 28 बाइट्स

c!t&n:q3_*ts_b+5M4$XdZ!cZ{Zv

इनपुट स्ट्रिंग्स का एक सेल एरे है, जिसमें वैकल्पिक विभाजक के रूप में अल्पविराम होते हैं:

{'programming' 'puzzles' 'and' 'code' 'golf'}

या

{'programming', 'puzzles', 'and', 'code', 'golf'}

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

व्याख्या

एक उदाहरण के रूप में निम्नलिखित इनपुट पर विचार करें:

{'aaaa' 'bb' 'ccc'}

आप %कोड में किसी भी बिंदु पर टिप्पणी चिह्न डालने वाले आंशिक परिणाम (स्टैक सामग्री) देख सकते हैं । उदाहरण के लिए, चौथे फ़ंक्शन के बाद स्टैक सामग्री देखें ( &n)।

c        % Input cell array of strings implicitly. Convert to 2D char array,
         % right-padding with spaces
         % STACK: ['aaaa'; 'bb  '; 'ccc']
!        % Transpose
         % STACK: ['abc'
                   'abc'
                   'a c'
                   'a  ']
t        % Duplicate
         % STACK: ['abc'
                   'abc'
                   'a c'
                   'a  '],
                  ['abc'
                   'abc'
                   'a c'
                   'a  '],
&n       % Number of rows and of columns
         % STACK: ['abc'
                   'abc'
                   'a c'
                   'a  '], 4, 3
:q       % Range, subtract 1
         % STACK: ['abc'
                   'abc'
                   'a c'
                   'a  '], 4, [0 1 2]
3_*      % Multiply by -3
         % STACK: ['abc'
                   'abc'
                   'a c'
                   'a  '], 4, [0 -3 -6]
ts_      % Duplicate, sum, negate
         % STACK: ['abc'
                   'abc'
                   'a c'
                   'a  '], 4, [0 -3 -6], 9
b        % Bubble up in stack
         % STACK: ['abc'
                   'abc'
                   'a c'
                   'a  '], [0 -3 -6], 9, 4
+        % Add
         % STACK: ['abc'
                   'abc'
                   'a c'
                   'a  '], [0 -3 -6], 13
5M       % Push second input of last function again
         % STACK: ['abc'
                   'abc'
                   'a c'
                   'a  '], [0 -3 -6], 13, 4
4$Xd     % Buld numerical sparse matrix from the above four arguments. The
         % columns of the first input argument will be the diagonals of the
         % result, with indices given bu the second input (negative is below
         % main diagonal). The matrix size is the third and fourth arguments
         % STACK: [97  0  0  0
                    0 97  0  0
                    0  0 97  0
                   98  0  0 97
                    0 98  0  0
                    0  0 32  0
                   99  0  0 32
                    0 99  0  0
                    0  0 99  0
                    0  0  0 32
                    0  0  0  0
                    0  0  0  0
                    0  0  0  0]
Z!c      % Convert from sparse to full, and then to char. Character 0 is
         % displayed as space
         % STACK: ['a   '
                   ' a  '
                   '  a '
                   'b  a'
                   ' b  '
                   '    '
                   'c   '
                   ' c  '
                   '  c '
                   '    '
                   '    '
                   '    '
                   '    ']
Z{       % Split into cell array, with each row in a cell
         % STACK: {'a   ', ' a  ', '  a ', 'b  a', ' b  ', '    ', 'c   ', ' c  ', '  c ', '   ', '   ', '   ', '   '}
Zv       % Deblank: remove trailing space from each string. Implicitly display,
         % each string on a different line. Empty strings do not generate
         % a newline
         % STACK: {'a   ', ' a', '  a', 'b  a', ' b', '', 'c', ' c', '  c', '', '', '', ''}

4

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

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

s=>s.map((w,y)=>[...w].map((c,x)=>(a[p=y*3+x]=a[p]||Array(x).fill(' '))[x]=c),a=[])&&a

वैकल्पिक संस्करण, 109 बाइट्स

एक स्ट्रिंग लौटाता है।


2

आम लिस्प, 673 668 597 बाइट्स

भयानक समाधान, मुझे पता है। मैं शायद कुछ नींद के बाद इसे और अधिक संपादित करूँगा।

(defun f(&rest z)(let((l)(a 0)(s)(o)(b)(c 0))(loop(setf b(length l))(setf l"")(loop for w in z for i from 0 do(if(>(+(length w)(* i 3))c)(setf c(+(length w)(* i 3))))(setf s(+(* i -3)a))(when(and(>= s 0)(< s(length w)))(setf o(format nil"~v@{~a~:*~}"s" "))(if(and(>=(- s 3)0)(not(equal i(-(length z)1))))(setf o(subseq o(- s 2))))(setf l(concatenate'string o(string(char w s))l)))(when(>= s(length w))(setf l(concatenate'string"   "l))))(if(<=(length l)b)(setf l(concatenate'string(format nil"~v@{~a~:*~}"(- b(length l)-1)" ")l)))(print(string-right-trim" "l))(if(>= b c)(return))(setf a(1+ a)))))

उपयोग:

* (f "ppcg" "is" "pretty" "ok")

"p" 
" p" 
"  c" 
"i  g" 
" s" 
"" 
"p" 
" r" 
"  e" 
"o  t" 
" k  t" 
"     y" 
""
NIL

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

नोट: मैं आम लिस्प में नया हूं, लेकिन मुझे यह महसूस करना काफी है कि यह बहुत सुधार का उपयोग कर सकता है।


2
> :( "पीपीपीसीजी ... ठीक है!"!
विनाशकारी नींबू

2

सी #, 336 बाइट्स:

golfed:

string D(string[]s){int x=0,y=0,r=0,q=2*(s.Max().Length+s.Length)+1;var a=new char[q, q];for(int i=0;i<s.Length;i++){y=r;for(int j=0;j<s[i].Length;j++){a[y,x]=s[i][j];x+=1;y+=1;}x=0;r+=3;}var o="";for(x=0;x<q;x++){var t="";for(y=0;y<q;y++)t+=a[x,y];o+=t==string.Join("",Enumerable.Repeat('\0',q))?"":(t.TrimEnd('\0')+"\r\n");}return o;}

Ungolfed:

public string D(string[] s)
{
  int x = 0, y = 0, r = 0, q = 2 * (s.Max().Length + s.Length) + 1;
  var a = new char[q, q];
  for (int i = 0; i < s.Length; i++)
  {
    y = r;
    for (int j = 0; j < s[i].Length; j++)
    {
      a[y, x] = s[i][j];
      x += 1;
      y += 1;
    }
    x = 0;
    r +=3;
  }
  var o = "";
  for (x = 0; x < q; x++)
  {
    var t = "";
    for (y = 0; y < q; y++)
      t += a[x, y];
    o += t == string.Join("", Enumerable.Repeat('\0', q)) ? "" : (t.TrimEnd('\0') + "\r\n");
  }
  return o;
}

परिक्षण:

  var codeGolf = new DrawDiagonalLinesOfText();
  Console.WriteLine(codeGolf.E(new string[] { "programming", "puzzles", "and", "code", "golf" }));
  Console.WriteLine(codeGolf.E(new string[] { "a", "bcd", "efgh", "i", "j" }));
  Console.WriteLine(codeGolf.E(new string[] { "verylongword", "short" }));

p
 r
  o
p  g
 u  r
  z  a
a  z  m
 n  l  m
  d  e  i
c     s  n
 o        g
  d
g  e
 o
  l
   f


a
b
 c
  d
e
 f
  g
i  h
j


v
 e
  r
s  y
 h  l
  o  o
   r  n
    t  g
        w
         o
          r
           d

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

@Doorknob उफ़, क्षमा करें ... फिक्स्ड, केवल मेरी लागत 2 बाइट्स :)
पीट आर्डेन

1
के लिए संकलन करें Func<string[], string>और 297 बाइट्स के लिए कई अन्य बदलाव करें, s=>{int i=0,x=0,y=0,r=0,l=s.Length,q=2*(s.Max().Length+l)+1,j;var a=new char[q,q];for(;i<l;i++){y=r;for(j=0;j<s[i].Length;)a[y++,x++]=s[i][j++];x=0;r+=3;}var o="";for(;x<q;x++){var t="";for(y=0;y<q;)t+=a[x,y++];o+=t==string.Join("",Enumerable.Repeat('\0',q))?"":(t.TrimEnd('\0')+"\n");}return o;};लेकिन इसके लिए आपको 18 बाइट्स जोड़ने की जरूरत हैusing System.Linq;
TheLethalCoder

@ TheLethalCoder धन्यवाद, लेकिन मैं वास्तव में आपका संपूर्ण समाधान नहीं लेना चाहता हूं :)
पीट आर्डेन

यह मेरा तुम्हारा नहीं है मैं बस कुछ सामान को दूर फेंक रहा हूं अर्थात चलती हुई घुमक्कड़ी iऔर jशीर्ष पर int की घोषणा और कुछ को स्थानांतरित करना ++ताकि वे चर के अंतिम उपयोग पर उपयोग किए
जाएं

2

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

s=input()
k=max(map(len,s))
a=[k*[' ']for x in range(k+len(s)*3+3)]
for x in range(len(s)):
 for y in range(len(s[x])):a[x*3+y][y]=s[x][y]
print a

नोट: अंतिम दो लाइनों के लिए इंडेंटेशन हैं <space>और <tab>जो एक बाइट बचाता है क्योंकि मुझे डबल-इंडेंट करने की आवश्यकता नहीं है।

इनपुट को स्ट्रिंग की एक सरणी के रूप में दर्ज किया जाना है: ["hello", "world"]या ['hello', 'world']। आउटपुट वर्णों के सरणियों का एक सरणी है।

शायद ऐसा करने का एक बेहतर तरीका है ...

EDIT एक लापता नज़दीकी चौकोर कोष्ठक की ओर इशारा करने के लिए Doorknob को धन्यवाद देता है। मैंने इसे *k...तीसरी पंक्ति में रखा ।


तीसरी पंक्ति में आपके कोड में एक सिंटैक्स त्रुटि है; दो खुले ब्रैकेट हैं लेकिन केवल एक करीबी ब्रैकेट। हालाँकि, मैं इसे ठीक करता हूं (या तो अतिरिक्त क्लोजिंग ब्रैकेट जोड़कर या अतिरिक्त ओपनिंग ब्रैकेट हटाकर), प्रोग्राम रन होने पर एक त्रुटि देता है।
दरवाज़े

यह अब लाइनों के अंत में और आउटपुट के अंत में व्हॉट्सएप के आउटपुट के लिए प्रतीत होता है, जिसे चुनौती विनिर्देश द्वारा अनुमति नहीं है।
दरवाज़े


@LeakyNun धन्यवाद। क्या आप अभी-अभी जा रहे हैं और मेरे सारे जवाबों को टटोल रहे हैं : पी
हाइपरएनुट्रिनो

1

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

P=PadRight;T=Transpose;R=Riffle;Select[Rest@T@P@MapIndexed[""~Table~#2~Join~#1&,T@P@R[Characters/@#~R~{},{},3]]//.{0->"",{x__,""}->{x}},#!={""}&]&

मैं इस बायटेकाउंट से निराश हूं, लेकिन ओह ठीक है।

एक अनाम फ़ंक्शन को परिभाषित करता है जो शब्दों की सूची (जैसे {"this","that","these"}) लेता है और दो-आयामी वर्णों को लौटाता है। ग्रिड रूप में देखने के लिए, //Gridअंत में जोड़ें ।

तारों को एक सरणी में परिवर्तित करता है, अतिरिक्त लाइनें जोड़ता है, सरणी को स्थानांतरित करता है, आवश्यक बदलावों को प्रस्तुत करता है, फिर फिर से स्थानांतरित करता है।

उदाहरण परिणाम (ग्रिड के रूप में स्वरूपित): उदाहरण परिणाम


1

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

z⁶j€⁾  µJ’⁶ẋ;"z⁶œr€⁶Yœr⁷

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

कैसे?

z⁶j€⁾  µJ’⁶ẋ;"z⁶œr€⁶Yœr⁷ - Main link: a list of strings
z                        - transpose with filler...
 ⁶                       -     space character
  j€                     - join €ach with
    ⁾                    -     two spaces
       µ                 - monadic chain separation, call the result x
        J                - range(length(x)) [1,2,...,x]
         ’               - decrement (vectorises) [0,1,...x-1]
           ẋ             - repeat (vectorises)
          ⁶              - a space ['', ' ',...,'x spaces']
             "           - zip with
            ;            - concatenation (prefixes with the space strings)
              z          - transpose with filler...
               ⁶         -     space character
                œr€⁶     - trim spaces from the right of €ach
                    Y    - join with line feeds
                     œr⁷ - trim line feeds from the right
                         - implicit print

1

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

def f(s):
 M=max(map(len,s));p=' '*M;L=[p]+s+M*[p];r='';k=0
 while k/M<len(s)*3+M:
  i=k%M;w=k/M-i+1;r+=(L[(w/3+1)*(w%3==1)]+p)[i];k+=1
  if i==M-1:r=r.rstrip()+'\n'
 return r.strip()

थोड़ा लंबा, लेकिन सकारात्मक पक्ष पर, यह प्रत्येक पंक्ति पर कोई अनुगामी श्वेत स्थान के साथ एक स्ट्रिंग लौटाता है, और अंत में कोई अनुगामी श्वेत स्थान या रिटर्न नहीं देता है; कुछ अन्य प्रविष्टियाँ नहीं मानती हैं।

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

यदि हम अंतिम को छोड़कर सभी लाइनों पर सफेद स्थान को पीछे छोड़ते हैं, तो हम थोड़ा बेहतर कर सकते हैं (163 बाइट्स):

def f(s):
 M=max(map(len,s));p=' '*M;L=[p]+s+M*[p];r='';k=0
 while k/M<len(s)*3+M:i=k%M;w=k/M-i+1;r+=(L[(w/3+1)*(w%3==1)]+p)[i]+'\n'*(i==M-1);k+=1
 return r.strip()

1

q / kdb +, 130 109 94 90 86 84 बाइट्स

उपाय:

f:{-1(+)a rtrim(til(#)E){raze(x#" "),y,\:"  "}'E:(+)(a:{(max(#:)each x)$x})" "vs x;}

उदाहरण:

q)f "programming puzzles and code golf"
p          
 r         
  o        
p  g       
 u  r      
  z  a     
a  z  m    
 n  l  m   
  d  e  i  
c     s  n 
 o        g
  d        
g  e       
 o         
  l        
   f 
q)f "a bcd efgh i j"
a   


b   
 c  
  d 
e   
 f  
  g 
i  h


j  
q)f (),"x"
x
q)f "verylongword short"
v           
 e          
  r         
s  y        
 h  l       
  o  o      
   r  n     
    t  g    
        w   
         o  
          r 
           d

स्पष्टीकरण (अपुष्ट):

बेसिक जिप इनपुट स्ट्रिंग से समान लंबाई के स्ट्रिंग्स का एक गुच्छा बनाने के लिए है, उन्हें फ्लिप (घुमाएं), फिर कुछ ऐसा पाने के लिए उपयुक्त व्हाट्सएप जोड़ें:

"p  p  a  c  g   "
" r  u  n  o  o  "
"  o  z  d  d  l "
"   g  z     e  f"
"    r  l        "
"     a  e       "
"      m  s      "
"       m        "
"        i       "
"         n      "
"          g     "

जो फिर से फ़्लिप किया जाता है, और stdout में मुद्रित किया जाता है।

यहाँ अवधारणा का एक लाइन-बाय-लाइन ब्रेकडाउन है:

A:"programming puzzles and code golf"; // original input
B:" " vs A;                            // split on " "
C:max count each B;                    // find length of the longest string
D:C$B;                                 // pad each string to this length
E:flip D;                              // flip (rotate) string
F:{raze(x#" "),y,\:"  "};              // appends each char with "  " and prepends an increasing number of " "
G:(til count E)F'E;                    // execute function F with each pair of 0..n and item in list E
H:max count each rtrim G;              // find longest string (ignoring right whitespace)
I:H$G;                                 // pad each of the strings to this length
J:flip I;                              // flip to get result
-1 J;                                  // print to stdout, swallow return value

टिप्पणियाँ:

अगर हम वास्तव में करना चाहते हैं तो कुछ (11) आसान बाइट्स से दाढ़ी बनाने के कुछ तरीके :

  • f:अनाम फ़ंक्शन के रूप में छोड़ने और छोड़ने के द्वारा 2 बाइट्स बचा सकता है
  • -1और छोड़ने के द्वारा 3 बाइट्स बचा सकता है और ;स्टडआउट के लिए मुद्रण के बजाय तार की एक सूची वापस कर सकता है
  • यदि हम अलग-अलग स्ट्रिंग के बजाय स्ट्रिंग्स की सूची में पास हुए तो 6 बाइट्स बचा सकते हैं

संपादन:

  • -11 बाइट्स, rtrimपैड की अधिकतम लंबाई खोजने के लिए उपयोग , भंडारण की आवश्यकता को हटा दियाC चर
  • -15 बाइट्स, max count eachएक लंबो फ़ंक्शन के लिए स्विच करना aजो एक बार बनाया जाता है और दो बार उपयोग किया जाता है
  • -4 बाइट्स, razeएक बचाने के लिए लंबो फंक्शन में जा रहे हैंraze each
  • -4 बाइट्स, कोर लैम्ब्डा फ़ंक्शन को सरल करता है जो व्हाट्सएप को जोड़ता है
  • -2 बाइट्स, के लिए (+)शॉर्टहैंड के रूप में उपयोग करेंflip

1

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

WS«P↘ιM³↓

मेरा पहला चारकोल जवाब। सुझाव के लिए और उपयोग करने के बजाय @DLosc का धन्यवाद करें और (कूद) लाइन की शुरुआत (और तीन नीचे) के लिए वापस जाना।

इसे ऑनलाइन (क्रिया) आज़माएँ या इसे ऑनलाइन (शुद्ध) आज़माएँ

स्पष्टीकरण:

लूप जबकि अभी भी एक अगली इनपुट-स्ट्रिंग है:

While(InputString()){ ... }
WS« ...

कर्सर को बिना दाएं दिशा में घुमाए इस स्ट्रिंग को प्रिंट करें:

Multiprint(:DownRight, i);
P↘ι

और फिर अगले पुनरावृत्ति के लिए तीन स्थान नीचे ले जाएँ:

Move(3, :Down);
M³↓

जब एक सरणी से मिलकर एकल इनपुट की आवश्यकता होती है, तो चारकोल विफल हो जाता है क्योंकि यह इनपुट स्ट्रिंग को अलग-अलग इनपुट के रूप में प्रत्येक एकल शब्द को विभाजित करता है। लेकिन चारकोल में θचर पहले इनपुट का प्रतिनिधित्व करता है, इसलिए मैं सिर्फ हेडर में उस चर के लिए परीक्षण इनपुट असाइन करता हूं और फिर बाकी कोड लिखता हूं, जिससे आप αचर से छुटकारा पा सकते हैं और विभाजित वस्तुओं पर पुनरावृत्ति कर सकते हैं θइसे ऑनलाइन आज़माएं! (अग्रणी स्थानों के कारण गैर-प्रतिस्पर्धात्मक।)
चार्ली

कम से कम, किसी ने शिकायत नहीं की जब मैंने उस चाल को यहाँ इस्तेमाल किया । :-)
चार्ली

@CarlosAlejo मैं वास्तव में आपके जवाब पर आया था जब मैं मौजूदा चारकोल उत्तरों पर प्रेरणा की तलाश कर रहा था। :)
केविन क्रूज़सेन

आईडीके, जिस विधि का मैं आमतौर पर उपयोग करता हूं वह अंत में केवल तार + खाली स्ट्रिंग है, अगर कोई बहुराष्ट्रीय है तो एक अजगर सरणी के रूप में इनपुट
केवल

@CarlosAlejo यह एक समय हो गया है, लेकिन मैंने अभी थोड़ी देर के लिए एक खाली लाइन के साथ कई लाइनों का उपयोग किया है (और एक ही समय में 7 बाइट्स पर गोल्फ किया जाता है)। देखा यह एक नील के जवाब में इस्तेमाल किया जा रहा है, और मैं अब ASCII- केवल एक ही बात का सुझाव दिया है (किसी भी तरह उस टिप्पणी याद किया)।
केविन क्रूज़सेन

1

जाप -Rx, 17 16 13 बाइट्स

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

yÈmú3)iYçÃmx1

इसे आज़माएं या सभी परीक्षण मामलों को चलाएं


व्याख्या

y                 :Transpose
 È                :Map each word at 0-based index Y
  m               :  Map each character
   ú3             :    Right pad with spaces to length 3
     )            :  End mapping
      i           :  Prepend
       Yç         :   Space repeated Y times
         Ã        :End mapping and transpose
          m       :Map
           x1     :  Trim right
                  :Implicitly join with newlines, trim and output

1

K4 , 58 बाइट्स

उपाय:

+(|/{0+/|\|~^x}@'x)$x:(2-(!c)+3*#x)$"  "/:'$+(c:|/#:'x)$x:

उदाहरण:

q)k)+(|/{0+/|\|~^x}@'x)$x:(2-(!c)+3*#x)$"  "/:'$+(c:|/#:'x)$x:("programming";"puzzles";"and";"code";"golf")
"p          "
" r         "
"  o        "
"p  g       "
" u  r      "
"  z  a     "
"a  z  m    "
" n  l  m   "
"  d  e  i  "
"c     s  n "
" o        g"
"  d        "
"g  e       "
" o         "
"  l        "
"   f       "
q)k)+(|/{0+/|\|~^x}@'x)$x:(2-(!c)+3*#x)$"  "/:'$+(c:|/#:'x)$x:(,"a";"bcd";"efgh";,"i";,"j")
"a   "
"    "
"    "
"b   "
" c  "
"  d "
"e   "
" f  "
"  g "
"i  h"
"    "
"    "
"j   "
q)k)+(|/{0+/|\|~^x}@'x)$x:(2-(!c)+3*#x)$"  "/:'$+(c:|/#:'x)$x:("verylongword";"short")
"v           "
" e          "
"  r         "
"s  y        "
" h  l       "
"  o  o      "
"   r  n     "
"    t  g    "
"        w   "
"         o  "
"          r "
"           d"

स्पष्टीकरण:

दाएं-पैड के तार इसलिए वे समान लंबाई के हैं, स्थानांतरित " "करते हैं, विकर्ण उत्पन्न करने के लिए बाएं-पैड के साथ जुड़ते हैं , फिर दाएं-पैड को लंबाई को सही करने और वापस स्थानांतरित करने के लिए। तार की एक सूची लेता है और तार की एक सूची देता है। शायद मेरी q / kdb + समाधान की तुलना में गोल्फ योग्य लेकिन अभी भी कम है।

+(|/{0+/|\|~^x}@'x)$x:(2-(!c)+3*#x)$"  "/:'$+(c:|/#:'x)$x:
                                                        x:      / save as variable x
                                                       $        / pad
                                             (        )         / do this together
                                                  #:'x          / count (#:) each (') x
                                                |/              / max
                                              c:                / save as variable c
                                            +                   / flip / transpose
                                           $                    / string ($)
                                    "  "/:'                     / join each with "  "
                                   $                            / pad
                      (           )                             / do this together
                                #x                              / count (#) x
                              3*                                / multiply by 3
                             +                                  / add to
                         (  )                                   / do this together
                          !c                                    / range 0..c
                       2-                                       / subtract from 2
                    x:                                          / save as x:
                   $                                            / pad
 (                )                                             / do all this together
    {         }@'x                                              / apply (@) lambda {} to each x
            ^x                                                  / null (^) x (" " is considered null)
           ~                                                    / not
          |                                                     / reverse
        |\                                                      / max (|) scan (\), maxs
     0+/                                                        / sum (+) over (/) starting with 0
  |/                                                            / max (|) over (/), max
+                                                               / transpose


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