एक सर्कल पर पाठ

Question

एक प्रोग्राम या फ़ंक्शन लिखें जो असतत सर्कल के चारों ओर एक इनपुट स्ट्रिंग प्रिंट करता है जिसमें न्यूनतम संभव त्रिज्या होता है। उदाहरण के लिए, इनपुट के लिए This is an example, आपका प्रोग्राम आउटपुट होना चाहिए:

  a si   
 n     s 
        i
e       h
x       T
a        
m        
 p       
  le     

सर्किल पीढ़ी

आप असतत सर्कल के प्रत्येक बिंदु के निर्देशांक की गणना करने के लिए मिडपॉइंट सर्कल एल्गोरिथ्म का उपयोग करेंगे । आप इस विकिपीडिया पृष्ठ पर इस एल्गोरिथ्म को कैसे लागू करें, इस पर उदाहरण पा सकते हैं ।

यहाँ एल्गोरिथ्म का छद्म कोड है (विकिपीडिया के C उदाहरण पर आधारित):

integer x = radius
integer y = 0
int decisionCriterion = 1 - x

while y <= x 
    point at coordinates (x,y) belongs to the circle   // Octant 1
    point at coordinates (y,x) belongs to the circle   // Octant 2
    point at coordinates (-x,y) belongs to the circle  // Octant 4
    point at coordinates (-y,x) belongs to the circle  // Octant 3
    point at coordinates (-x,-y) belongs to the circle // Octant 5
    point at coordinates (-y,-x) belongs to the circle // Octant 6
    point at coordinates (x,-y) belongs to the circle  // Octant 7
    point at coordinates (y,-x) belongs to the circle  // Octant 8

    y++
    if decisionCriterion <= 0
        decisionCriterion += 2 * y + 1
    else
        x--
        decisionCriterion += 2 * (y - x) + 1
end while

आप एक अलग एल्गोरिथ्म का उपयोग कर सकते हैं यदि और केवल अगर यह ठीक उसी सर्कल का उत्पादन करता है जो मिडपॉइंट सर्कल एल्गोरिदम का उत्पादन करता है, सभी त्रिज्याओं के लिए ।

सर्कल में सबसे छोटा संभव त्रिज्या होना चाहिए जो अभी भी इनपुट के सभी अक्षरों को लिखने की अनुमति देता है।

यदि सर्कल स्ट्रिंग में वर्णों की संख्या से अधिक बिंदुओं के साथ समाप्त होता है, तो अंतिम भरने वाले अक्षर रिक्त स्थान होंगे ।

निर्देशांक के साथ बिंदु पर इनपुट का पहला वर्ण मुद्रित किया जाना चाहिए (Radius,0)। बाद के पात्रों को एक एंटीकॉकवाइज फैशन में मुद्रित किया गया है।

इनपुट

इनपुट अंतरिक्ष (32) और टिल्ड ~(126) के बीच किसी भी ASCII वर्ण का एक स्ट्रिंग है ।

आप मान सकते हैं कि इनपुट हमेशा मान्य होगा, 256 वर्णों से छोटा और कम से कम 5 वर्ण लंबा होगा।

इनपुट STDIN से लिया जा सकता है, या एक फ़ंक्शन पैरामीटर के रूप में, या कुछ भी समान हो सकता है।

आउटपुट

आप परिणाम को STDOUT में आउटपुट कर सकते हैं, या इसे फ़ंक्शन से स्ट्रिंग के रूप में वापस कर सकते हैं।

आपके पास अनुगामी स्थान हो सकते हैं, बशर्ते कि वह सबसे लंबी रेखा (मध्य एक) से अधिक की रेखा का कारण न बने (जैसे, मध्य रेखा में अनुगामी स्थान नहीं हो सकते)।

अनुगामी नई लाइन की अनुमति है।

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

Input: Hello, World!
Output:
  ,ol  
     l 
W     e
o     H
r      
 l     
  d!   


Input: 4 8 15 16 23 42
Output:
  51   
     8 
1      
6     4

 2   2 
  3 4  


Input: Programming Puzzles & Code golf
Output:
     gnim    
  uP     ma  
 z         r 
 z         g 
l           o
e           r
s           P

&            

 C           
  od     f   
    e Gol    


Input: Ash nazg durbatuluk, ash nazg gimbatul, ash nazg thrakatuluk agh burzum-ishi krimpatul.
Output:
            zan hsa ,           
           g         ku          
        ig             lu        
      bm                 ta      
     a                     b     
    t                       r    
   u                         u   
   l                         d   
  ,                              
                              g  
 a                             z 
 s                             a 
h                               n

n                               h
a                               s
z                               A
g                                

t                                
h                                
 r                               
 a                             . 
  k                           l  
  a                           u  
   t                         t   
   u                         a   
    l                       p    
     u                     m     
      k                  ri      
        ag              k        
          h          hi          
            burzum-is            

स्कोरिंग

यह कोड-गोल्फ है , इसलिए बाइट्स में सबसे कम जवाब जीतता है।

Answer 1

गणितज्ञ, 359 357 354

(L=Length;T=Tuples;c=Characters@#;For[r=1,L[p=RotateRight[SortBy[#,ArcTan@@N@#&]+r+1,L@#/4+1]&@(f=1-r;X=1;Y=-2r;x=0;y=r;q={{0,r},{0,-r},{r,0},{-r,0}};While[x<y,If[f>0,y--;f+=Y+=2];x++;f+=X+=2;q=Join[q,T@{{x,-x},{y,-y}},T@{{y,-y},{x,-x}}]];Union@q)]<L@c,r++];R=2r+1;s="";Do[s=s<>({u,v}/.Thread[p~Take~L@c->c]/.{_,_}->" ")<>If[v==R,"\n",""],{u,R},{v,R}];s)&

Ungolfed:

(
  L = Length;
  T = Tuples;
  c = Characters@#;
  For[r = 1,
   L[
     p = RotateRight[
         SortBy[#, ArcTan @@ N@# &] + r + 1, L@#/4 + 1
         ] &@(
        f = 1 - r;
        X = 1;
        Y = -2 r;
        x = 0;
        y = r;
        q = {{0, r}, {0, -r}, {r, 0}, {-r, 0}};
        While[x < y,
         If[f > 0,
          y--;
          f += Y += 2
          ];
         x++;
         f += X += 2;
         q = Join[q, T@{{x, -x}, {y, -y}}, T@{{y, -y}, {x, -x}}]
         ];
        Union@q
        )] < L@c,
   r++];
  R = 2 r + 1;
  s = "";
  Do[s = s <> ({u, v} /. Thread[p ~ Take ~ L@c -> c] /. {_, _} -> " ") <>
      If[v == R, "\n", ""],
   {u, R}, {v, R}];
  s
  ) &

Answer 2

सी, 367 बाइट्स

#include<math.h>
main(){char*m="12345678",b[9999];int p,i,n,q,c,l=strlen(m),r=1,d,f=0;float o,s;for(;!f;r++){f=0;q=r*r;c=r/4;o=6.3,s=o/99.;memset(b,0,q);for(i=0;i<l;i++){p=1;f=0;while(p&&o>0){d=(c-1+(int)(sin(o)*c))*r+c-1+(int)(cos(o)*c);f+=p=b[d];if(!p)b[d]=m[i];o-=s;}}if(f){for(n=p=0;n<q;n++){p+=c=b[n];putchar(c?c:32);if(n%r==r-1){if(!p)n=q;putchar(10);p=0;}}}}}

यहाँ टेस्ट करें

मुझे यकीन है कि इसे बहुत आगे बढ़ाया जा सकता है लेकिन यह मुझे सिरदर्द देने लगा है।

सी, 324 बाइट्स

छोटे कोड लेकिन परिणाम ओपी के समान नहीं हैं

#include<math.h>
main(){char*m="12345678",b[9999];int q,c,l=strlen(m),r=1,d,i=0;float o;for(;i<l;r++){i=0;c=r/2;q=r*r;memset(b,0,q);for(o=6.28;o>=0&&i<l;o-=0.001){d=(c-1+(int)(sin(o)*c))*r+c-1+(int)(cos(o)*c);if(!b[d]){b[d]=m[i++];}}}for(d=i=0,--r;d<q;d++){i+=c=b[d];putchar(c?c:32);if(d%r==r-1){putchar(10);d=i?d:q;i=0;}}}

       an hsa ,k
      gz       ulu
    ig           ta
   bm             br
  ta               ud
 lu                  g
 ,                   z
a                    an
s
h                     h
                      s
n                     A
a
z
g                     l
 t                   tu
 h                   a
 ra                 mp
  ka               ri
   tu              k
    lu           hi
     k a       -is
       gh burzum

Comments

आप void5 बाइट्स के लिए ड्रॉप कर सकते हैं , और कुछ और बाइट्स के लिए वैश्विक स्कोप में कुछ पूर्णांक घोषित कर सकते हैं , क्योंकि एक प्रकार के बिना वैश्विक स्कोप में चर ग्रहण intकिए जाते हैं और स्वचालित रूप से आरंभिक होते हैं 0।

— मेरागो

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

— एलेक्स ए।

Answer 3

सी, 494 बाइट्स

यह वास्तविक मिडपॉइंट सर्कल एल्गोरिथ्म का उपयोग करता है:

void main(){char s[]="12345678";int a[9999],b[9999],f=0,c,h,x,y,e,q,t,u,v,g,i,d,l,r=0,k=strlen(s);for(;f<k;r++){c=r;e=r*2+1;q=e*e;memset(b,0,q*4);f=0;l=0;for(i=0;i<8;i++){x=r;y=0;d=1-x;for(x=r,y=0,d=1-x;y<=x;y++,d+=2*d>0?y- --x:y+1){t=(i+1)%4>1;u=t?y:x;v=t?x:y;h=(c+v*(i>3?1:-1))*e+(c+u*(i>1&&i<6?-1:1));if(!b[h])b[h]=f<k?s[f]:0,a[f]=h,f++;}if(i%2){for(g=0;g<(f-l)/2;g++)t=b[a[l+g]],b[a[l+g]]=b[a[f-1-g]],b[a[f-1-g]]=t;}l=f;}}for(i=0;i<q;i++){c=b[i];putchar(c?c:32);if(i%e==e-1)putchar(10);}}

डी-गोल्फ कोड:

void main() {
    char text[]="Ash nazg durbatuluk, ash nazg gimbatul, ash nazg thrakatuluk agh burzum-ishi krimpatul.";

    char points[9999];
    int pos[9999];

    int sl = strlen(text);
    int r = 0;
    int pc = 0; // point count
    int lc = 0; // last count

    int c, h, x, y, e, q, t, u, v, g, i, d;

    // increase radius until number of points => strlen(text)
    for(; pc<sl; r++) {
        c = r;
        e = r * 2 + 1;
        q = e * e;
        memset(points,0,q);
        pc = 0;
        lc = 0;

        // loop through the octants
        for(i=0; i<8; i++) {

            // midpoint loop
            x = r;
            y = 0;
            d = 1 - x;
            while (y <= x) {

                // calc index of point
                t = (i + 1) % 4 > 1;
                u = t ? y : x;
                v = t ? x : y;
                h = (c + v * (i > 3 ? 1 : -1)) * e + (c + u * (i > 1 && i < 6 ? -1 : 1)); 

                // add point if space is empty
                if(!points[h]) { 
                    points[h] = pc < sl ? text[pc] : 0;
                    pos[pc] = h;
                    pc++;
                }

                y++;
                d += 2 * d > 0 ? y- --x : y + 1;
            }

            if(i % 2) {
                // reverse point order for odd octants
                for(g=0; g<(pc-lc)/2; g++)
                {
                    t = points[pos[lc + g]];
                    points[pos[lc + g]] = points[pos[pc - 1 - g]];
                    points[pos[pc - 1 - g]] = t;
                }
            }
            lc = pc;
        }
    }

    // write output
    for(i=0;i<q;i++)
    {
        c = points[i];
        putchar(c ? c : 32);
        if(i % e == e - 1)
            putchar(10);
    }
}