मैं पीसीजी में अपनी पहली पहेली के रूप में कुछ और अधिक जटिल पोस्ट करने की उम्मीद कर रहा था, लेकिन एक विशेष, उह ... स्टैक ओवरफ्लो पर होमवर्क प्रश्न ने मुझे यह पोस्ट करने के लिए प्रेरित किया। वे चाहते हैं:

किसी भी दिए गए शब्द के लिए निम्न पैटर्न प्रिंट करें जिसमें विषम संख्या में अक्षर हों:
P           M
  R       A   
    O   R    
      G       
    O   R      
  R       A   
P           M 
c ++

ध्यान दें कि अक्षरों को एक नाइट की चाल है इसके अलावा जिस पैटर्न को आपको प्रिंट करने की आवश्यकता है। इसलिए, हर दूसरा कॉलम खाली है। - ( यह इंगित करने के लिए धन्यवाद xnor ।)

नियम

C ++ का उपयोग करना प्रतिबंधित है। जैसा कि मैं इस प्रश्न को वहां जोड़ सकता हूं।
आप stdoutस्ट्रिंग (उदाहरण alert()के लिए जावास्क्रिप्ट में) को जल्दी से आउटपुट करने के लिए उपयोग कर सकते हैं या कर सकते हैं ।
हमेशा की तरह, सबसे छोटा कोड जीतता है।

code-golf ascii-art

— sampathsris
स्रोत

2

यह स्टैक ओवरफ्लो पर संबंधित पोस्ट में है: stackoverflow.com/q/5508110

— लेवल रिवर सेंट

2

@flawr मुझे लगता है कि इसका मतलब अजीब है, जैसा कि एक समान संख्या में नहीं है।

— निन्जाबियरनॉन्की

31

भगवान मैं बेवकूफ हूं, मुझे लगा कि यह एक अस्पष्ट कंप्यूटर वैज्ञानिक संक्षिप्त नाम =) है

— दोषपूर्ण

2

@jpjacobs: बाइट्स, जब तक कि प्रश्न स्पष्ट रूप से अन्यथा न कहे।

— डेनिस

2

पूरा कार्यक्रम या सिर्फ एक समारोह? (असली स्मार्ट मुझे पहले जवाब देने के लिए और बाद में यह सवाल करने के लिए ...)

— रोडोल्फो डायस

13

अजगर , २२

Vzjdm?@zd}N,dt-lzd\ Uz

परीक्षा:

$ pyth -c 'Vzjdm?@zd}N,dt-lzd\ Uz' <<< "CODE-GOLF"
C               F
  O           L  
    D       O    
      E   G      
        -        
      E   G      
    D       O    
  O           L  
C               F

स्पष्टीकरण:

(Implicit)                  z = input()
(Implicit)                  d = ' '
Vz                          for N in range(len(z)):
  jd                            print(d.join(
    m                               map(lambda d:
     ?@zd                                        z[d] if
         }N                                      N in
           ,dt-lzd                                    (d,len(z)-d-1) else
      \                                          " ",
     Uz                                          range(len(z)))))

— isaacg
स्रोत

पायथ में कोई पूरक नहीं?

— xnor

@xnor नहीं, लेकिन यह मदद नहीं करेगा। मान लीजिए कि ~पाइथ में ऐसा नहीं था। फिर हम बदल सकता है t-lzdकरने के लिए +lz~dअभी भी 5 अक्षर -।

— २०

Vzएक साफ चाल है: मुझे नहीं पता था कि U<string>दिया range(len(<string>))।

— FryAmTheEggman

हाँ, यह एक अच्छी सुविधा है। सूचियों पर भी उस तरह से काम करता है, लेकिन जरूरी नहीं कि tuples। संपादित करें: उफ़, यह प्रलेखन से गायब है। मैं इसे जोड़ दूंगा। माफ़ कीजिये।

— isaacg

20

एपीएल ( 37 35 34) 27)

↑{∊2↑¨⍵↑¨I}¨↓(+∨⌽)∘.=⍨⍳⍴I←⍞

यह कीबोर्ड से इनपुट लेता है, जैसे:

      ↑{∊2↑¨⍵↑¨I}¨↓(+∨⌽)∘.=⍨⍳⍴I←⍞
CODE-GOLF
C               F 
  O           L   
    D       O     
      E   G       
        -         
      E   G       
    D       O     
  O           L   
C               F

— मारीनस
स्रोत

7

मेरे सभी अपवित्र एपीएल के हैं।

— नाइट

13

अजगर 2 - 94 90 89 88

s=input()
L=len(s)
R=range(L)
for i in R:print" ".join([s[j]," "][j!=i!=L+~j]for j in R)

इनपुट:

"CODE-GOLF"

आउटपुट:

C               F
  O           L  
    D       O    
      E   G      
        -        
      E   G      
    D       O    
  O           L  
C               F

— फ़ाल्को
स्रोत

मैं बस वही लिख रहा था। मेरे एक सुधार है i in[j,L+~j]।

— xnor

@xnor: इससे भी छोटी स्थिति मिली। ;)

— फॉको

चतुर। आप अभी भी कर सकते हैं L+~j।

— xnor

@ xnor: आह, आप सही कह रहे हैं। मैं हमेशा +~चाल भूल जाता हूँ ...

— फाल्को

क्या आप for i in R:print" ".join([s[j]," "][j!=i!=L+~j]for j in R)एक चार को बचाने के लिए कर सकते हैं ? (मेरे पास अब परीक्षण करने के लिए पायथन 2 तक पहुंच नहीं है।)

— xnor

11

पायथन 3: 75 वर्ण

s=input()
i=n=len(s)
while i:i-=1;a=[" "]*n;a[i]=s[i];a[~i]=s[~i];print(*a)

लाइन के लिए i, हम रिक्त स्थान की सूची के साथ शुरू करते हैं और प्रविष्टियां सेट करते हैंi आगे और पीछे को इनपुट स्ट्रिंग के अक्षरों के बराबर । फिर, हम परिणाम प्रिंट करते हैं।

अजगर तार अपरिवर्तनीय हैं, इसलिए aइसके बजाय पात्रों की एक सूची होनी चाहिए। सूची aको लूप के अंदर आरंभीकृत किया जाना चाहिए या संशोधनों को लूप के बीच ले जाना होगा। हम print(*a)सूची में प्रत्येक वर्ण को अलग करने के लिए उपयोग करते हैं , स्थान अलग किया जाता है, जिसे पायथन 3 की आवश्यकता होती है।

आउटपुट लाइनें सममित हैं, इसलिए हम iथोड़ी देर के लूप का उपयोग करने के बजाय गिनती कर सकते हैं ।

>>> CODE-GOLF
C               F
  O           L  
    D       O    
      E   G      
        -        
      E   G      
    D       O    
  O           L  
C               F

यह अक्षरों की संख्या के लिए भी काम करता है।

>>> CODEGOLF
C             F
  O         L  
    D     O    
      E G      
      E G      
    D     O    
  O         L  
C             F

— XNOR
स्रोत

इसे पायथ में परिवर्तित करते हुए, मुझे VlzJ*]dlz=@JN@zN=@Jt_N@_zNjdJ29 बाइट्स मिलते हैं ... मुझे लगता है कि मुझे एपीएल को हराने के लिए कुछ और प्रयास करना होगा। इसके अलावा, +1 सबूत के लिए कि पायथन 3 आउट-गोल्फ पाइथन 2 (कभी-कभी)

— फ्राईअमईएग्गमैन

मेरे अनुभव में @fry पायथन 3 आमतौर पर आउट-गोल्फ 2 है। यहां तक कि अगर कहीं और कुछ भी नहीं बदलता है, तो ज्यादातर चुनौतियां एक इनपुट देती हैं और एक आउटपुट की उम्मीद करती हैं, और len("raw_input()") + len("print ") > len("input()") + len("print()")।

— अंडरग्राउंडोरेल

@undergroundmonorail खैर, इसके साथ परेशानी यह है कि input() अजगर 2 में भी मान्य है (यह सिर्फ कुछ अलग तरीके से काम करता है), इसलिए जब तक चुनौती के लिए इनपुट काफी सख्त नहीं होता, अजगर 2 आमतौर पर जीत जाएगा।

— FryAmTheEggman 14

वाह, पायथन 2 के साथ भी और print" ".join(a)आपका कोड मेरा (82) छोटा है।

— फाल्को

@FryAmTheEggman मेरा जवाब देखें - यह अन्य अजगर जवाब का एक अनुकूलन है, और यह एपीएल से बहुत छोटा है। पायथ वास्तव में अनुक्रमणिका को सौंपना पसंद नहीं करता है, दुर्भाग्य से।

— isaacg

8

सीजेएम, 27 25 बाइट्स

l_,S*:Sf{W):W2$tW~@tS}zN*

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

उदाहरण चलाते हैं

$ cjam <(echo 'l_,S*:Sf{W):W2$tW~@tS}zN*') <<< CROSS; echo
C       S 
  R   S   
    O     
  R   S   
C       S

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

यह काम किस प्रकार करता है

                             " N := '\n'; R := []; S = ' '; W := -1 ";
l                            " Q := input()                         ";
 _,S*:S                      " S := len(Q) * S                      ";
       f{            }       " for each C in Q:                     ";
                             "   T := S                             ";
         W):W                "   W += 1                             ";
             2$t             "   T[W] := C                          ";
                W~@t         "   T[~W] := C                         ";
                             "   R += [T]                           ";
                    S        "   R += [S]                           ";
                      z      " R := zip(R)                          ";
                       N*    " R := N.join(R)                       ";
                             " print R                              ";

— डेनिस
स्रोत

1

क्षमा करें कि यह मूल रूप से एक 'शानदार जवाब है!' टिप्पणी करें, लेकिन मेरा सिर्फ इतना कहना था कि यह मेरे लिए कभी नहीं, कभी पंक्तियों के बजाय स्तंभों द्वारा बॉक्स बनाने के लिए हुआ होगा।

— FryAmTheEggman 18

4

जावा - 168

एक साधारण नेस्टेड लूप, वास्तव में कुछ खास नहीं है।

class C{public static void main(String[]a){int b=-1,c=a[0].length()-1,d;for(;b++<c;)for(d=-1;d++<c;)System.out.print((b==d|b==c-d?a[0].charAt(d):" ")+(c==d?"\n":""));}}

लाइन ब्रेक के साथ:

class C{
    public static void main(String[]a){
        int b=-1,c=a[0].length()-1,d;
        for(;b++<c;)
            for(d=-1;d++<c;)
                System.out.print(
                    (b==d|b==c-d?a[0].charAt(d):" ")+
                    (c==d?"\n":""));
    }
}

— Geobits
स्रोत

4

शुद्ध बैश, 94 बाइट्स

l=${#1}
for((;t<l*l;t++));{
((x=t%l))||echo
((x-t/l&&x+t/l+1-l))&&printf \ ||printf ${1:x:1}
}

— डिजिटल आघात
स्रोत

1

बहुत सारी t%lगणनाएँ। पहले प्रयोग पर इसे एक वैरिएबल में सेव करें ((x=t%l))फिर इसे 94 वर्णों तक कम करने के लिए वैरिएबल का उपयोग करें।

— मैनटवर्क

आह हाँ, मैं के लिए किया था x=t%lऔर y=t/lहै और यह अब था ... मेरे मन उपयोग केवल x बस को पार नहीं किया

— डिजिटल ट्रामा

4

रूबी, 64

f=->w{x=w.size
x.times{|i|y=" "*x
y[i],y[~i]=w[i],w[~i]
puts y}}

व्याख्या

इनपुट को लंबोदर के तर्क के रूप में लिया जाता है। यह एक उम्मीद हैString ।
एक लूप में जो हर वर्ण को शब्द में गर्त में रखता है ( nकुल में):
- nरिक्त स्थान से मिलकर एक स्ट्रिंग बनाएं ।
- बदलें iवें और n-iवें ( ~i, धन्यवाद XNOR) के साथ अंतरिक्ष iवें औरn-iइनपुट वें चरित्र के ।
- लाइन प्रिंट करें

— britishtea
स्रोत

7

25,000 वें उत्तर को पोस्ट करने के लिए बधाई! :) (वास्तव में, मैं 100% निश्चित नहीं हूं, यह एक है, कैशिंग के कारण। लेकिन यह नवीनतम उत्तर था, जब मैंने पहली बार साइट के आंकड़ों में "25,000 उत्तर" देखे थे।)

— मार्टिन एंडर

2

आप -i-1थोड़ा पूरक के रूप में कर सकते हैं ~i।

— xnor

यह बहुत चालाक है, धन्यवाद!

— ब्रिटिश

2

इस दृष्टिकोण के साथ, यह वास्तव में एक लंबोदर के बजाय स्टडिन का उपयोग करने के लिए फायदेमंद प्रतीत होता है: gets.size.times{|x|u=?\s*~/$/;u[x]=$_[x];u[~x]=$_[~x];puts u}(माना जाता है कि इनपुट एक न्यूलाइन द्वारा समाप्त नहीं किया जाता है, जैसे echo -n CODE-GOLF)। फिर .charsकिसी अन्य पात्र को बचाने के लिए अतिरिक्त उपयोग किया जा सकता है:x=0;gets.chars{|r|u=?\s*~/$/;u[x]=r;u[~x]=$_[-x+=1];puts u}

— वेंटरो

4

जावास्क्रिप्ट (E6) 101 95 129 136

गलत पत्र रिक्ति संपादित करें । फिक्स्ड। सरल और छोटे छोरों के लिए क्लासिक का उपयोग करके
संपादित करें
एक कार्य के रूप में, पॉपअप के माध्यम से आउटपुट।

F=a=>{
  for(l=a.length+1,i=s=o='';++i<l;s='\n')
    for(j=0;++j<l;)
      o+=s+((s=' ')+a)[j==i|i+j==l&&j]
  alert(o)
}

पिछला संस्करण .map का उपयोग कर

F=a=>alert([...a].map((c,p)=>
  --q<p
  ?B(q)+a[q]+B(p-q-1)+c 
  :B(p)+c+(p-q?B(q-p-1)+a[q]:'')
,B=n=>' '.repeat(n),q=a.length).join('\n'))

फायरफॉक्स / फायरबग कंसोल में टेस्ट

F('Java-Script')

उत्पादन

J                   t
  a               p  
    v           i    
      a       r      
        -   c        
          S          
        -   c        
      a       r      
    v           i    
  a               p  
J                   t

— edc65
स्रोत

2

इसमें पर्याप्त क्षैतिज स्पेस नहीं है - अक्षरों के साथ प्रत्येक कॉलम के बीच सभी रिक्त स्थान के कॉलम होने चाहिए।

— isaacg

4

बेफुज -93, 68 71

:~:84*-!#@#v_\:2*\4+p1+
::+\4+g:!| >$1+0:>p1-::
00+4\*2:\<>0p#:- ^#2g

आप इसे यहाँ परीक्षण कर सकते हैं । यह प्रत्येक पास पर एक इनपुट डायलॉग बॉक्स के साथ आएगा~ ; एक समय में अपना शब्द एक वर्ण दर्ज करें (यह कहता है कि इनपुट 'कलंकी' है), एक स्थान के साथ समाप्त होता है।

यह कंसोल पर प्रिंट नहीं होगा; यह सब के बाद, आत्म-संशोधन के संकेत के बिना Befunge नहीं होगा! इसके बजाय यह संदेश प्रदर्शित करने के लिए अपने स्वयं के ग्रिड को संशोधित करेगा। ऐसा होने के बाद, ग्रिड कुछ इस तरह दिखाई देगा:

 ~:84*-!#@#v_\:2*\4+p1+
::+\4+g:!| >$1+0:>p1-::
00+4\*2:\<>0p#:- ^#2g

c               f      
  o           l        
    d       o          
      e   g            
        -              
      e   g            
    d       o          
  o           l        
c               f

(0,0 पर सेल के नेक बलिदान पर ध्यान दें, क्योंकि हमें पता है कि सूचक अब और नहीं जाएगा, डेटा के एक टुकड़े को संग्रहीत करने के उद्देश्य से।)

यह सम लंबाई के इनपुट के साथ भी काम करता है। ध्यान दें कि, चूंकि Befunge-93 एक 80x25 ग्रिड तक सीमित है, इनपुट आकार 21 वर्णों तक सीमित है यदि आप इसे Befunge-93 दुभाषिया में चलाते हैं। इसे Befunge-98 के रूप में चलाकर इस सीमा को हटा देना चाहिए।

संपादित करें - अब यह लंबाई के केवल तीन वर्णों की कीमत पर, इच्छित आउटपुट की तर्ज पर अधिक काम करता है।

— Kasran
स्रोत

ध्यान दें कि अक्षरों को एक खाली कॉलम के साथ अलग किया गया है। अक्षर अपेक्षाकृत L आकार में हैं।

— संपतश्री

Drats! यह जटिल चीजों के बजाय काफी है। मुझे लगता है कि मैं इसे उबार सकता हूं, लेकिन यह अंतिम आकार में जोड़ देगा ... ओह अच्छी तरह से।

— कासरान

4

जावास्क्रिप्ट 102 84 85

संपादित करें: रिक्ति को ठीक करना था। अब इतना छोटा नहीं है।

function p(s){for(i in s){o='';for(n in s)o+=(n==i?s[n]:n==s.length-1-i?s[n]:' ')+' ';console.log(o)}}

p('Thanks-Dennis')

T                       s
  h                   i
    a               n
      n           n
        k       e
          s   D
            -
          s   D
        k       e
      n           n
    a               n
  h                   i
T                       s

— चीर लीब
स्रोत

इसमें पर्याप्त क्षैतिज स्पेस नहीं है।

— डेनिस

1

वाह, मेरी तुलना में कम और ES6 का उपयोग भी नहीं। +1

— शिमोनस्टर

बेहतर है, लेकिन रिक्ति अभी भी गलत है (एक्स को देखें)। इसके अलावा, जब तक कि प्रश्न अन्यथा नहीं कहता है, आपको एक कार्यक्रम या एक फ़ंक्शन लिखना चाहिए। हार्डकोडेड वेरिएबल्स वाले स्निपेट आमतौर पर फबते हैं।

— डेनिस

1

और आप इसे नहीं बना सकते हैं function(s)क्योंकि आप पुनरावृत्ति नहीं करते हैं?

— ज़ाचरी

3

CJam, 38 36 35 34 32 बाइट्स

l:I,,_f{f{_2$=@2$+I,(=|\I=S?S}N}

इसका परीक्षण यहां करें।यह STDIN से इनपुट शब्द पढ़ता है। यह वर्णों की एक समान संख्या के लिए भी काम करता है। यह रिक्त स्थान के एक अनुगामी स्तंभ को प्रिंट करता है, लेकिन मुझे उसके विरुद्ध नियमों में कुछ भी दिखाई नहीं देता है।

व्याख्या

l:I,,_f{f{_2$=@2$+I,(=|\I=S?S}N}
l:I                              "Read input and store it in I.";
   ,                             "Get string length.";
    ,_                           "Turn into range and duplicate.";
      f{                       } "Map block onto first range, with second range on the stack.";
        f{                   }   "Map block onto second range, with first iterator in stack.
                                  Each invocation of this block will start with grid coordinates
                                  y and x on the stack (x on top).";
          _2$=                   "Duplicate x, duplicate y, check for equality.";
              @2$+               "Pull up y, duplucate x, add,";
                  I,(=           "Check if that's one less than the string length.";
                      |          "Bitwise or between conditions.";
                       \         "Swap condition and x.";
                        I=       "Take x'th character from the string.";
                          S?     "Push a space and select character depending on condition.";
                            S    "Push another space.";
                              N  "Push a line feed.";

कार्यक्रम के अंत में स्टैक की सामग्री स्वचालित रूप से मुद्रित की जाती है।

— मार्टिन एंडर
स्रोत

मेरे प्यारे सीजेएम, आपको एपीएल ने हरा दिया है। ^ _ ^

— vaxquis

@vaxquis मैं हैरान था मैं इसे पहले स्थान पर दो बार हरा सकता था। यह समस्या एपीएल और सह-आधारित भाषाओं की तुलना में अधिक अनुकूल लगती है।

— मार्टिन एंडर

2

ठीक है, कम से कम यह लिखने के लिए आसान है l:I,,_f{f{_2$=@2$+I,(=|\I=S?S}N}की तुलना में एक नैपकिन पर ↑{∊2↑¨⍵↑¨I}¨↓(+∨⌽)∘.=⍨⍳⍴I←⍞... व्यंग्य

— vaxquis

खैर, कोई और मुझे CJam का उपयोग करके हरा सकता है, और मैं अपने कार्यक्रम को कमतर नहीं कर सकता, इसलिए CJam ने अंततः मुझे हराया। (लेकिन पायथ को मुकुट मिलता है।) (उस ने कहा, @vaxquis, APL यहाँ पर उपयोग की जाने वाली अन्य भाषाओं की तुलना में पढ़ने में बहुत आसान है, निश्चित रूप से एक बार जब आप 60 या इतने वर्णों को जानते हैं, और निश्चित रूप से जब Pyth या CJI की तुलना में यहां तक कि जे।)

— मारिनस

3

सी, 105

इसे करने के दो अलग तरीके।

c,i,j;main(int l,char**v){for(l=strlen(v[1]);j-l;)putchar((c=v[1][i++])?i-1-j&&l-i-j?32:c:(i=0,j++,10));}

i,j;main(int l,char**v){for(l=strlen(v[1]);j-l;i++)putchar((l-i)?i-j&&l-i-j-1?32:v[1][i]:(i=-1,j++,10));}

यदि आप अतिरिक्त स्थान जोड़ना चाहते हैं, तो अतिरिक्त 5 वर्णों के putchar(साथ बदलें printf(" %c",।

— स्तर नदी सेंट
स्रोत

3

जे - 36 ३० बाइट्स:

संपादित करें: 6 वर्ण छोटे, क्रेडिट @algorithmshark पर जाते हैं ।

(1j1#"1' '&,({~](*>.*&|.)=)#\)

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

   (1j1#"1' '&,({~](*>.*&|.)=)#\) 'Code-Golf'
C               f
  o           l  
    d       o    
      e   G      
        -        
      e   G      
    d       o    
  o           l  
C               f

बोनस: लंबाई के साथ भी काम करता है:

   (1j1#"1' '&,({~](*>.*&|.)=)#\) 'CodeGolf'
C             f
  o         l  
    d     o    
      e G      
      e G      
    d     o    
  o         l  
C             f

— jpjacobs
स्रोत

3

प्रोलॉग - 240 बाइट्स

:-initialization m.
+[]. +[H|T]:-(H=' ';!),+T.
+[H|T]+I+X:-0=:=I,X=H;+T+(I-1)+X.
+L+I+C+S:-L=:=I;S=[D|E],+C+I+B,+C+(L-I-1)+B,+B+2*I+D,+L+(I+1)+C+E,+B,writef('%s\n',[B]).
-X:-get_char(C),(C='\n',X=[];X=[C|Y],-Y).
m:- -X,length(X,L),+L+0+_+X.

मंगलाचरण:

$ echo "Code-Golf" | swipl -qf c.pl
C               f
  o           l
    d       o
      e   G
        -
      e   G
    d       o
  o           l
C               f

पठनीय:

:- initialization(main).

vars_to_spaces([]).
vars_to_spaces([' '|T]) :- vars_to_spaces(T).
vars_to_spaces([_|T]) :- vars_to_spaces(T).

get_index([Head|_], Index, Result) :-
    0 =:= Index,
    Result = Head.
get_index([_|Tail], Index, Result) :-
    get_index(Tail, Index-1, Result).

print_loop(Length, Index, Board, String) :-
    Length =:= Index;
    String = [FirstChar|RestString],
    get_index(Board, Index, Line),
    get_index(Board, Length-Index-1, Line),
    get_index(Line, 2*Index, FirstChar),
    print_loop(Length, Index+1, Board, RestString),
    vars_to_spaces(Line),
    writef('%s\n', [Line]).

get_line(Line) :-
    get_char(C),
    (   C = '\n', Line = [];
        Line = [C|More], get_line(More)).

main :-
    get_line(String),
    length(String, Length),
    print_loop(Length, 0, _, String).

— Kay
स्रोत

3

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

＼＼：⇵ｎ

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

स्पष्टीकरण:

\      create a diagonal of the input
 \     create an even steeper diagonal of that
  :⇵   reverse a copy of it vertically
    n  overlap the two

— dzaima
स्रोत

3

आर , 99 98 93 89 बाइट्स

m=ifelse(diag(l<-length(w<-el(strsplit(scan(,''),'')))),w,' ')
write(pmax(m,m[,l:1]),1,l)

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

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

पंक्ति 2 किसी भी मैट्रिक्स को विकर्ण मैट्रिक्स या इसके क्षैतिज रूप से प्रतिबिंबित संस्करण के तत्वों से निर्मित करती है, जो भी अधिक हो।

.2 + 1 = by1 बाइट जेसीई के लिए धन्यवाद

Giuseppe के लिए pp4 बाइट्स धन्यवाद

— रॉबर्ट हैकेन
स्रोत

1

मिठाई! और अच्छी व्याख्या। आप 2 बाइट्स बचा

— JayCe

1

वह अन्य उत्तरों और प्रश्न को देखते हुए - ऐसा लगता है कि मैट्रिक्स बड़ा होना चाहिए (अतिरिक्त स्थान) - उत्पादन एक वर्ग मैट्रिक्स नहीं होना चाहिए ..

— JayCe

@JayCe 2 बाइट्स के लिए धन्यवाद! और प्रारूपण के बारे में टिप्पणी के लिए धन्यवाद, आप शायद सही हैं (हालांकि इस बारे में नियम अधिक स्पष्ट हो सकते हैं)। सौभाग्य से सभी को इसकी आवश्यकता थी कि छपाई करते समय विभाजक में एक स्थान रखा जाए।

— रॉबर्ट हैकेन

89 बाइट्सpmax कुछ और असाइनमेंट का उपयोग और इनलाइनिंग।

— Giuseppe

@Giuseppe धन्यवाद! अफसोस की बात है, अभी भी जे । डो के समाधान

— रॉबर्ट

2

सी # ( 214 212)

(निश्चित रूप से बुरी तरह से) गोल्फ संस्करण:

using System;class A{static void Main(){char[]a,w=Console.ReadLine().ToCharArray();int l=w.Length,i=0;for(;i<l;i++){a=new string(' ',2*l-1).ToCharArray();a[2*i]=w[i];a[2*l-2*i-2]=w[l-i-1];Console.WriteLine(a);}}}

Ungolfed संस्करण:

using System;

class A
{
  static void Main()
  {
    char[] a, w = Console.ReadLine().ToCharArray();
    int l = w.Length, i = 0;
    for (; i < l; i++)
    {
      a = new string(' ', 2 * l - 1).ToCharArray();
      a[2 * i] = w[i];
      a[2 * l - 2 * i - 2] = w[l - i - 1];
      Console.WriteLine(a);
    }
  }
}

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

और आप लोग अपनी बाइट्स कैसे गिनते हैं? मैं बस एक त्वरित घड़ी खिड़की में ऊपर पोस्ट किया था और किया था .Length। मैं मेरे लिए बाइट्स गिनने के लिए एक छोटा प्रोग्राम लिख सकता था, लेकिन मुझे यकीन है कि एक आसान तरीका है जो मुझे अभी तक नहीं पता है।

— अविष्कारपांडा
स्रोत

आप रिक्त स्थान हटाकर दो बाइट्स बचा सकते हैं for(;i < l;i++)।

— बीटा डेके

इसके अलावा, मैं का उपयोग इस मेरी बाइट गिनती के लिए।

— बीटा डेके

@BetaDecay आह महान, मैं उन लोगों को नजरअंदाज करना चाहिए था। और लिंक के लिए धन्यवाद!

— अदृश्यपर्व

2

जावास्क्रिप्ट (ईएस 6) - 185 177 175 170 बाइट्स

f=n=>{return s='  ',r='repeat',n=[...n],l=n.length,j=l/2-.5,[...h=n.slice(0,j).map((c,i)=>s[r](i)+c+s[r](l-2-(i*2))+' '+n[l-i-1]),s[r](j)+n[j],...h.reverse()].join('\n')}

इसे फ़ायरफ़ॉक्स कंसोल में रखें और निम्नानुसार चलाएं f('PROGRAM'):

P           M
  R       A
    O   R
      G
    O   R
  R       A
P           M

f("CODE-GOLF"):

C               F
  O           L
    D       O
      E   G
        -
      E   G
    D       O
  O           L
C               F

— Scimonster
स्रोत

codegolf.stackexchange.com/a/40594/26974

— सम्पतिस

मैंने वह भी देखा।

— शिमोनस्टर

2

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

FromCharacterCode@Flatten[Append[Riffle[#,32],10]&/@MapThread[Max,{#,Reverse@#,ConstantArray[32,Dimensions@#]},2]&@DiagonalMatrix@ToCharacterCode@#]&

इनपुट फ़ंक्शन के पैरामीटर के रूप में पारित हुआ; फ़ंक्शन आउटपुट स्ट्रिंग देता है। आउटपुट के अंत में एक अनुगामी न्यूलाइन है।

स्पष्टीकरण: हम स्ट्रिंग के साथ एक विकर्ण मैट्रिक्स बनाते हैं, फिर हम Reverse@#पंक्तियों को उलटने के लिए लंबवत रूप से फ़्लिप करते हैं। फिर हमारे पास समान आयामों का एक तीसरा मैट्रिक्स है जिसमें केवल 32 (एससीआई स्पेस) हैं। हम MapThreadइन 3 मैट्रिस के तत्व-वार अधिकतम लेने के लिए उपयोग करते हैं। अंत में, हम Riffleप्रत्येक पंक्ति में स्थान Appendबनाते हैं, अंत में एक नई रेखा और Flattenपरिणाम।

— jcai
स्रोत

2

सी , 119

i,j;main(int l,char**v){l=strlen(v[1]);for(i=0;i<l;i++){for(j=0;j<l;j++)putchar((i-j)*(j-l+i+1)?32:v[1][j]);puts("");}}

इसे C ++ के रूप में संकलित नहीं किया जा सकता है, इस प्रकार मुझे आशा है, मैंने नियमों का उल्लंघन नहीं किया है :)

— वीएक्स
स्रोत

1. वर्तमान में आउटपुट गलत है। अक्षरों के बीच एक जगह होनी चाहिए। 2. i=0और j=0इसकी जरूरत नहीं है, क्योंकि वैश्विक चर शून्य से आरंभिक हैं। 3. आप main(l,v)char**v;इसके बजाय उपयोग कर सकते हैं main(int l,char**v)। 4. यदि आप अपडेट iकरते हैं i+=puts(""), तो आप बाहरी लूप के घुंघराले कोष्ठक से छुटकारा पा सकते हैं।

— डेनिस

2

पर्ल - 90

इसमें से कुछ और पात्रों को निचोड़ना संभव हो सकता है:

($j=$i++%8)==7?++$k&&print"\n":print$j+1==$k||7-$j==$k?"$_ ":"  "for split//,($_ x y///c)

89+ के 1लिए -n।

साथ दौड़ो:

echo "program" | perl -nE'($j=$i++%8)==7?++$k&&print"\n":print$j+1==$k||7-$j==$k?"$_ ":"  "for split//,($_ x y///c)'

आउटपुट:

p           m
  r       a
    o   r
      g
    o   r
  r       a
p           m

— hmatt1
स्रोत

2

टी-एसक्यूएल: 180

चर @i से इनपुट लेना

DECLARE @s VARCHAR(MAX)=REPLICATE('  ',LEN(@i)),@ INT=1a:PRINT STUFF(STUFF(@s,@*2-1,1,SUBSTRING(@i,@,1)),LEN(@i)*2-(@*2)+1,1,SUBSTRING(@i,LEN(@i)-@+1,1))SET @+=1IF @<=LEN(@i)GOTO A

यह एकल वर्णों को शुरू / अंत से रिक्त स्थान के एक स्ट्रिंग में / भरता है।

परीक्षा परिणाम

DECLARE @i VARCHAR(MAX)='Super Large'
DECLARE @s VARCHAR(MAX)=REPLICATE('  ',LEN(@i)),@ INT=1a:PRINT STUFF(STUFF(@s,@*2-1,1,SUBSTRING(@i,@,1)),LEN(@i)*2-(@*2)+1,1,SUBSTRING(@i,LEN(@i)-@+1,1))SET @+=1IF @<=LEN(@i)GOTO A
S                   e 
  u               g   
    p           r     
      e       a       
        r   L         

        r   L         
      e       a       
    p           r     
  u               g   
S                   e

— MickyT
स्रोत

2

पॉवरशेल 118 102 97

($x=[char[]]"$args")|%{$i++;$y=[char[]]" "*$x.Count;$y[$i-1]=$x[$i-1];$y[-$i]=$x[-$i];$y-join' '}

आउटपुट:

PS C:\PowerShell> .\cross.ps1 SWORD
S       D
  W   R
    O
  W   R
S       D

— डार्कअजैक्स
स्रोत

2

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

LḶḤ⁶ẋ;"µ»ṚY

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

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

2

जावास्क्रिप्ट (Node.js) , 81 बाइट्स

f=s=>[...s].map((_,i,a)=>a.map((c,j)=>j==i|j==s.length+~i?c:' ').join` `).join`
`

संपादित करें : -1 धन्यवाद जो राजा। मैंने नहीं देखा कि टीआईओ सीजी के लिए पूर्वनिर्मित प्रत्यक्ष पेस्ट देता है।

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

btw, TIO में कोड निष्पादित करने के लिए अतिरिक्त कोड प्रोग्राम पाद लेख में जा सकता है। यह सही बाइट काउंट को निर्धारित करने में मदद करता है और स्वचालित पीपीसीजी उत्तर प्रारूप का अधिक आसानी से उपयोग करता है। जैसे ऑनलाइन कोशिश करो!

— जो किंग

-i-1हो सकता है+~i

— Jo King

1

सी # 208

static void Main()
{
string s=Console.ReadLine(),t="";
int n=s.Length;
for(int i=0;i<n;i++)
{
for(int j=0;j<n;j++)
{
if(i==j)t+=s[i];
else if(i==n-j-1)t+=s[n-i-1];
t+=" ";
}
t+="\n";
}
Console.WriteLine(t);
}

— bacchusbeale
स्रोत

के साथ 11 कीमती पात्रों को बचाओ t+=i==j?s[i]:i==n-j-1?s[n-i-1]:"";।

— संपतश्री

आप उन newlines निकाल सकते हैं?

— ज़ाचरी

1

GolfScript 46 ( डेमो )

:w,:l,{l,{.[.l(\-]2$?)!w@[=32]=}%\;''+' '*}%n*

— क्रिस्टियन लुपस्कू
स्रोत

1

कोई बात नहीं कब तक, वहाँ हमेशा में एक जवाब होगा ...

जावा - 289 234 बाइट्स

public static void main(String[]a){int l=a.length-1,i=0,j;for(;i<=l;i++){for(j=0;j<=l;j++){if(j==i)System.out.print(a[i]);else if(i==l-j)System.out.print(a[j]);else System.out.print(" ");System.out.print(" ");}System.out.println();}}}

Ungolfed:

    class A {

    public static void main(String[] a) {
        int l = a.length - 1, i = 0, j;
        for (; i <= l; i++) {
            for (j=0; j <= l;j++) {
                if (j == i)
                    System.out.print(a[i]);
                else if (i == l-j)
                    System.out.print(a[j]);
                else
                    System.out.print(" ");
                System.out.print(" ");
                }            
            System.out.println();
        }
    }
}

आउटपुट, घटिया तरीके से किया जाता है:

P           M 
  R       A   
    O   R     
      G       
    O   R     
  R       A   
P           M

import java.util.Scannerकोड के अंदर जोड़ा गया क्योंकि मुझे याद नहीं है कि क्या आयात बाइट गिनती की ओर गिना जाता है ... धिक्कार है, मैं वास्तव में इस पर चूसता हूं।

— रोडोल्फो डायस
स्रोत

2

आयात करते हैं। यह आंशिक रूप से पायथन के आयात-और-अन्य उपनाम वाक्य-विन्यास के कारण है: from math import floor as fजो थोड़ा धोखा है

आपको कुछ System.out.printकॉल को आपस में जोड़कर वर्णों के एक समूह को सहेजने में सक्षम होना चाहिए , कुछ टर्नरी ऑपरेटरों का उपयोग करके।

— DLosc

@DLosc क्या आप मुझे कुछ उदाहरण दे सकते हैं?

— रोडोल्फो डायस

1

हां, वास्तव में जियोबिट्स का जवाब एक आदर्श उदाहरण है - System.out.printकॉल की सामग्री को अंत में देखें।

— DLosc

1

@RodolfoDias ऐसा महसूस नहीं करते। जावा में मेरे पहले कुछ गोल्फ भयानक थे , और मैं अभी भी सामान्य रूप से अपने "पहले संशोधनों" से एक अच्छा हिस्सा काट सकता हूं, अगर मैं काफी मुश्किल दिख रहा हूं;)

— ज्योबिट्स

1

सी # (192/170)

using System;class P{static void Main(){var s=Console.ReadLine();int x,y,l=s.Length;for(x=0;x<l;x++){for(y=0;y<l;y++)Console.Write(x==y||l-x==y+1?s.Substring(x,1):" ");Console.Write("\n");};}}

या, "मुख्य () केवल":

static void Main(){var s=Console.ReadLine();int x,y,l=s.Length;for(x=0;x<l;x++){for(y=0;y<l;y++)Console.Write(x==y||l-x==y+1?s.Substring(x,1):" ");Console.Write("\n");};}

— RobIII
स्रोत

चरित्र पार

नियम

अजगर , २२

एपीएल ( 37 35 34) 27)

अजगर 2 - 94 90 89 88

पायथन 3: 75 वर्ण

सीजेएम, 27 25 बाइट्स

उदाहरण चलाते हैं

यह काम किस प्रकार करता है

जावा - 168

शुद्ध बैश, 94 बाइट्स

रूबी, 64

व्याख्या

जावास्क्रिप्ट (E6) 101 95 129 136

बेफुज -93, 68 71

जावास्क्रिप्ट 102 84 85

CJam, 38 36 35 34 32 बाइट्स

सी, 105

जे - 36 ३० बाइट्स:

प्रोलॉग - 240 बाइट्स

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

आर , 99 98 93 89 बाइट्स

सी # ( 214 212)

जावास्क्रिप्ट (ईएस 6) - 185 177 175 170 बाइट्स

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

पर्ल - 90

टी-एसक्यूएल: 180

पॉवरशेल 118 102 97

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

जावास्क्रिप्ट (Node.js) , 81 बाइट्स

सी # 208

GolfScript 46 ( डेमो )

जावा - 289 234 बाइट्स

सी # (192/170)