একটি স্ট্রিং স্নাকাইফাই করুন

35

একটি snakified স্ট্রিং এর মত দেখাচ্ছে:

T AnE eOf ifi ing
h s x l A k e r
isI amp Sna dSt

তোমার কাজ

একটি স্ট্রিং sএবং একটি আকার নিন n, তারপরে স্নাকাইফাইড স্ট্রিংটি আউটপুট করুন। ইনপুট ThisIsAnExampleOfaSnakifiedStringএবং 3উপরের উদাহরণ উত্পাদন করবে।

বিশেষ উল্লেখ

  • s কোড পয়েন্ট 33 এবং 126 সহ (স্পেস বা নিউলাইন নেই) এর মধ্যে কেবল ASCII টি অক্ষর থাকবে।
  • s 1 এবং 100 বর্ণের মধ্যে দীর্ঘ হবে।
  • nপ্রতিটি আউটপুট স্ট্রিং সেগমেন্টের আকারের প্রতিনিধিত্ব করে এমন একটি পূর্ণসংখ্যা। অক্ষরের প্রতিটি লাইন (উপরে / নীচে বা বাম / ডান) যা "সাপ" তে বক্ররেখা তৈরি করে তা nঅক্ষর দীর্ঘ। উদাহরণস্বরূপ পরীক্ষার কেসগুলি দেখুন।
  • n অন্তর্ভুক্ত 3 থেকে 10 এর মধ্যে হবে।
  • আউটপুট স্ট্রিং সর্বদা নীচের দিকে পয়েন্ট করা শুরু করে।
  • প্রতিটি লাইনে ট্রেলিং স্পেস অনুমোদিত।
  • আউটপুট শেষে ট্রেলিং করা নিউলাইনগুলিও অনুমোদিত।
  • শীর্ষস্থানীয় স্থানের অনুমতি নেই।
  • কোড-গল্ফ মানে বাইট জিতে সংক্ষিপ্ততম কোড।

পরীক্ষার মামলা

a 3

a

----------

Hello,World! 3

H Wor
e , l
llo d!

----------

ProgrammingPuzzlesAndCodeGolf 4

P  ngPu  Code
r  i  z  d  G
o  m  z  n  o
gram  lesA  lf

----------

IHopeYourProgramWorksForInputStringsWhichAre100CharactersLongBecauseThisTestCaseWillFailIfItDoesNot. 5

I   gramW   tStri   100Ch   gBeca   CaseW   DoesN
H   o   o   u   n   e   a   n   u   t   i   t   o
o   r   r   p   g   r   r   o   s   s   l   I   t
p   P   k   n   s   A   a   L   e   e   l   f   .
eYour   sForI   Which   cters   ThisT   FailI

----------

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

!        <=>?@ABCDE        `abcdefghi
"        ;        F        _        j
#        :        G        ^        k
$        9        H        ]        l
%        8        I        \        m
&        7        J        [        n
'        6        K        Z        o        ~
(        5        L        Y        p        }
)        4        M        X        q        |
*+,-./0123        NOPQRSTUVW        rstuvwxyz{
code-golf  string  ascii-art  code-golf  code-golf  string  balanced-string  decision-problem  code-golf  string  geometry  grid  code-golf  tips  lisp  code-golf  quine  tips  king-of-the-hill  code-challenge  math  code-golf  string  palindrome  math  fastest-code  code-golf  string  counting  code-golf  code-golf  internet  code-golf  quine  source-layout  hello-world  code-golf  math  number  sequence  arithmetic  code-golf  ascii-art  grid  code-golf  number  grid  code-golf  string  crossword  code-golf  code-golf  ascii-art  grid  counting  code-golf  code-golf  math  sequence  arithmetic  number-theory  code-golf  code-golf  graphical-output  geometry  random  code-golf  ascii-art  grid  counting  code-golf  string  ascii-art  code-challenge  test-battery  code-golf  string  code-golf  ascii-art  kolmogorov-complexity  code-golf  interpreter  code-golf  math  sequence  code-golf  math  primes  set-partitions  code-golf 
— user81655
সূত্র
আমি অনুমান করছি যে পরবর্তী চ্যালেঞ্জটি হ'ল স্নাকাইফাইড স্ট্রিংটিকে মূল 2 পরামিতিগুলিতে রূপান্তর করা ...
— 7:48
@ অলবিতে আমার আর কোনও পরিকল্পনা ছিল না, তবে এটি আসলে একটি শালীন ধারণা বলে মনে হচ্ছে। এখানে সদৃশ কিছু ফর্ম থাকতে পারে, তাই আমি প্রথমে এটি পরীক্ষা করা প্রয়োজন। সাথে থাকুন!
— ব্যবহারকারী 81655
বিপরীত চ্যালেঞ্জটি আরও মজাদার হতে পারে যদি সাপটি একটি স্বেচ্ছাসেবী আকারে পরিণত হতে পারে ...
— Abligh
@ অবলিগ ঠিক সেটাই হাহা করার পরিকল্পনা করছিলাম!
— ব্যবহারকারী81655
@ অলিগ হয়েছে !
— ব্যবহারকারী81655

উত্তর:

9

পাইথ, 48 45 44 43 42 বাইট

=Y0juXGZX@G~+Z-!J%/HtQ4q2J~+Y%J2@zHlzm*;lz

এটি অনলাইনে চেষ্টা করুন।

এই পদ্ধতিটি রুবির উত্তরের মতো একইভাবে চলমান সাদা স্থানের অপব্যবহার করে।

— PurkkaKoodari
সূত্র
3
ক্রস করা হয়েছে 44 এখনও 44 ... এখনও রয়েছে।
— আর্কটরাস
12

রুবি, 87 বাইট

->s,n{p=0
a=(' '*(w=s.size)+$/)*n
w.times{|i|a[p]=s[i];p+=[w+1,1,-w-1,1][i/(n-1)%4]}
a}

নিয়মের কিছুটা অপব্যবহারের Trailing spaces on each line are allowed.আউটপুট প্রতিটি লাইন wঅক্ষর দীর্ঘ, প্লাস একটি নতুন লাইন, যেখানে wমূল স্ট্রিংয়ের দৈর্ঘ্য, অর্থাৎ পুরো ইনপুট ধরে রাখার জন্য যথেষ্ট দীর্ঘ long অতএব বৃহত্তর জন্য ডানদিকে অনেকগুলি অপ্রয়োজনীয় সাদা স্থান রয়েছে n।

পরীক্ষা প্রোগ্রামে অসম্পূর্ণ

f=->s,n{
  p=0                            #pointer to where the next character must be plotted to
  a=(' '*(w=s.size)+$/)*n        #w=length of input. make a string of n lines of w spaces, newline terminated
  w.times{|i|                    #for each character in the input (index i)
    a[p]=s[i]                    #copy the character to the position of the pointer
    p+=[w+1,1,-w-1,1][i/(n-1)%4] #move down,right,up,right and repeat. change direction every n-1 characters
  }
a}                               #return a

puts $/,f['a',3]

puts $/,f['Hello,World!',3]

puts $/,f['ProgrammingPuzzlesAndCodeGolf',4]

puts $/,f['IHopeYourProgramWorksForInputStringsWhichAre100CharactersLongBecauseThisTestCaseWillFailIfItDoesNot.',5]

puts $/,f['!"#$%&\'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~',10]
— স্তর নদী সেন্ট
সূত্র
7

জাভাস্ক্রিপ্ট (ES6), 143 বাইট

(s,n)=>[...s].map((c,i)=>(a[x][y]=c,i/=n)&1?y++:i&2?x--:x++,a=[...Array(n--)].map(_=>[]),x=y=0)&&a.map(b=>[...b].map(c=>c||' ').join``).join`\n`

যেখানে \nএকটি আক্ষরিক নিউলাইন প্রতিনিধিত্ব করে। Ungolfed:

function snakify(string, width) {
    var i;
    var result = new Array(width);
    for (i = 0; i < width; i++) result[i] = [];
    var x = 0;
    var y = 0;
    for (i = 0; i < string.length; i++) {
       result[x][y] = string[i];
       switch (i / (width - 1) & 3) {
       case 0: x++; break;
       case 1: y++; break;
       case 2: x--; break;
       case 3: y++; break;
    }
    for (i = 0; i < width; i++) {
        for (j = 0; j < r[i].length; j++) {
            if (!r[i][j]) r[i][j] = " ";
        }
        r[i] = r[i].join("");
    }
    return r.join("\n");
}
— নিল
সূত্র
7

পাইথ, 85 74 59 বাইট

Kl@Q0J0=Y*]d-+*@Q1K@Q1 1FNr1@Q1=XY-+*KNN1b;VK=XYJ@@Q0N=+J@[+K1 1-_K1 1).&3/N-@Q1 1;sY

=G@Q1=H@Q0KlHJ0=Y*]dt+*GKGFNr1G=XYt+*KNNb;VK=XYJ@HN=+J@[hK1t_K1).&3/NtG;sY

Klz=Ym;+*QKQVQ=XYt+*KhNhNb;VK=XYZ@zN=+Z@[hK1_hK1).&3/NtQ;sY

আমাকে প্রচুর সাহায্য করার জন্য @ ফ্রিআমএইটিজিমনকে ধন্যবাদ!

আমি যতটা পারি গল্ফ এখানে চেষ্টা করুন! কোনও কারণে, লাইন মোড়ানো আউটপুটটিকে অদ্ভুত করে তোলে। আপনি পুরো পৃষ্ঠায় আউটপুটটি একবার দেখতে চান

ব্যাখ্যা

একটি দ্বিতীয় শ্বাস নিন এবং ফোকাস করুন। এটি প্রায় কোনও "ক্লাসিক" অ্যালগরিদমের মতো তিন ভাগে বিভক্ত হতে পারে।

প্রথম বিভাগ

এটি যেখানে ভেরিয়েবল সূচনা হয়। এটি দুটি ভাগে বিভক্ত করা যেতে পারে:

Klz=Ym;+*QKQ
Klz                Assign len(input[0]) to K. (length of input String)
   =Ym;+*QKQ       Assign an empty list to Y of length K*input[1]-input[1]-1, where input[1] is the size of the snake 
                   (thus the height of the final string)

দ্বিতীয় অংশ :

VQ=XYt+*KhNhNb;
VQ                       For N in range(0, input[1]), where input[1] is the size of the snake 
  =                        Assign to Y. Y is implicit, it is the last variable we used.
   XYt+*KhNhNb               Y[K*N+N-1]="\n". Can be broken down in four parts :
   X                           Replace function. X <A: list> <B: int> <C: any> is A[B]=C
    Y                          A: The array we initialized in the first section.
     t+*KhNhN                  B: K*(N+1)+N+1 (N is the for loop variable)
             b                 C: Newline character ("\n")
              ;          End the loop.

দ্বিতীয় বিভাগ

এটিতে আসল যুক্তি রয়েছে।

VK=XYZ@zN=+Z@[hK1_hK1).&3/NtQ;
VK                                         For N in range(0, K), where K is the length of the input string (see first section)
  =                                          Assign to Y. Y is implicit, it is the last variable we used.
   XYZ@zN                                    Same as in section 2. This is a replacement function. Y[Z] = input[0][N]. Z is initially 0.
         =+Z@[hK1_hK1).&3/NtQ                Again this can be broken down :
         =+Z                                   Add to Z
             [hK1_hK1)                         Array containing directions. Respectively [K+1, 1, -K-1, 1]
            @         .&3/NtQ                  Lookup in the array, on index .&3/N-@Q1 1:
                      .&3                        Bitwise AND. .& <int> <int>
                         /NtQ                    (input[1]-1)/N, where input[1] is the size of the snake
                             ;             End the loop

তৃতীয় বিভাগ

এটি আউটপুট অংশ। সত্যিই আকর্ষণীয় নয় ...

sY    Join the array Y. Implicitly print.

বোনাস

আমি পাইথ প্রোগ্রামটি লিখেছিলাম এই অজগর স্ক্রিপ্ট থেকে। 

input=["ThisIsAnExampleOfASnakifiedString", 4];
width=len(input[0]);
height=input[1];
pointer=0;
directions = [width+1,1,-width-1,1] #Respectively Down, right, up, right (left is replaced by right because of snake's nature. Doesn't go left).
output=[' ' for i in range(0, width*height+height-1)];
for N in range(1, height):
    output[width*N+N-1]="\n";
for N in range(0, len(input[0])):  
    output[pointer]=input[0][N];
    pointer+=directions[3&(N/(height-1))];
print "".join(output);
— FliiFe
সূত্র
5

জাভাস্ক্রিপ্ট (ES6), 122 বাইট

document.write("<pre>"+(

// --- Solution ---
s=>n=>[...s].map((c,i)=>(a[p]=c,p+=[l+1,1,-l-1,1][i/n%4|0]),p=0,a=[...(" ".repeat(l=s.length)+`
`).repeat(n--)])&&a.join``
// ----------------

)("IHopeYourProgramWorksForInputStringsWhichAre100CharactersLongBecauseThisTestCaseWillFailIfItDoesNot.")(5))
স্নিপেট প্রসারিত করুন

@ লেভেলরিভারস্টের উত্তর হিসাবে একই অ্যালগরিদম।

— user81655
সূত্র
4

সি, 138 বাইট

char*h[]={"\e[B\e[D","","\e[A\e[D",""},t[999];i;main(n){system("clear");for(scanf("%s%d",t,&n),--n;t[i];++i)printf("%c%s",t[i],h[i/n%4]);}

এটি এএনএসআই পলায়ন ব্যবহার করে। লিনাক্স টার্মিনালে কাজ করে।

Ungolfed:

char*h[]={"\e[B\e[D","","\e[A\e[D",""},
    /* cursor movement - h[0] moves the cursor one down and one left,
    h[2] moves the cursor one up and one left. */
t[999];i;
main(n){
    system("clear");
    for(scanf("%s%d",t,&n),--n;t[i];++i)
        printf("%c%s",t[i],h[i/n%4]);
}
— mIllIbyte
সূত্র
1

জাভাস্ক্রিপ্ট (ES6), 131

অ্যালগরিদম: অবস্থান ম্যাপিং x,yইনপুট স্ট্রিং সূচক আউটপুটে, একরকম মত এই (সম্পর্কহীন) উত্তর।

আমি @ লেভেলরিভারস্টের কাছ থেকে অনুভূমিক প্রস্থকে ইনপুট দৈর্ঘ্যের সমান রাখার কৌশলটি ধার করেছি।

a=>m=>eval('for(--m,t=y=``;y<=m;++y,t+=`\n`)for(x=0;a[x];)t+=a[2*(x-x%m)+((h=x++%(2*m))?h-m?!y&h>m?h:y<m|h>m?NaN:m+h:m-y:y)]||`.`')

কম গল্ফড

গল্ফের আগে এটিই প্রথম কার্যকরী খসড়া ছিল

f=(a,n)=>{
  l=a.length
  m=n-1
  s=m*2 // horizontal period

  b=-~(~-l/s)*m // total horizontal len, useless in golfed version
  t=''
  for(y=0;y<n;y++)
  {
    for(x=0;x<b;x++)
    {
      k = x / m | 0
      h = x % s
      if (h ==0 )
        c=k*s+y
      else if (h == m)
        c=k*s+m-y
      else if (y == 0 && h>m)
        c=k*s+h
      else if (y == m && h<m)
        c=k*s+m+h
      else
        c=-1
      t+=a[c]||' '
    }
    t+='\n'
  }
  return t
}

পরীক্ষা

F=a=>m=>eval('for(--m,t=y=``;y<=m;++y,t+=`\n`)for(x=0;a[x];)t+=a[2*(x-x%m)+((h=x++%(2*m))?h-m?!y&h>m?h:y<m|h>m?NaN:m+h:m-y:y)]||` `')

function test()
{
  var n=+N.value
  var s=S.value
  O.textContent=F(s)(n)
}  

test()
#S {width:80%}
#N {width:5%}
<input id=N value=5 type=number oninput='test()'>
<input id=S 5 oninput='test()'
value='IHopeYourProgramWorksForInputStringsWhichAre100CharactersLongBecauseThisTestCaseWillFailIfItDoesNot.'>
<pre id=O></pre>
স্নিপেট প্রসারিত করুন

— edc65
সূত্র
0

পাইথ, 122 বাইট

=k@Q0J-@Q1 1K*4J=T*@Q1[*lkd;Vlk=Z+*%NJ/%N*J2J*/N*J2J=Y.a-+**/%N*J2J!/%NK*J2J*%NJ!/%N*J2J**!/%N*J2J/%NK*J2J XTYX@TYZ@kN;jbT

আমি বিভাগের আকার / মডুলোর উপর ভিত্তি করে প্রতিটি অক্ষরের x, y অবস্থান গণনা করার জন্য একটি সূত্র তৈরি করেছি, তবে তারা আমার প্রত্যাশার চেয়ে বড় হয়েছে: সি

ব্যাখ্যা:

=k@Q0                                                                                                                     # Initialize var with the text
     J-@Q1 1                                                                                                              # Initialize var with the segment size (minus 1)
            K*4J                                                                                                          # Initialize var with the "block" size (where the pattern start to repeat)
                =T*@Q1[*lkd;                                                                                              # Initialize output var with an empty array of strings
                            Vlk                                                                                           # Interate over the text
                               =Z+*%NJ/%N*J2J*/N*J2J                                                                      # Matemagics to calculate X position
                                                    =Y.a-+**/%N*J2J!/%NK*J2J*%NJ!/%N*J2J**!/%N*J2J/%NK*J2J                # Matemagics to calculate Y position
                                                                                                          XTYX@TYZ@kN;    # Assign the letter being iterated at x,y in the output
                                                                                                                      jbT # Join with newlines and print the output

পরীক্ষা এখানে

গণিত সূত্রগুলির জন্য, আমি 0/1 পতাকা উত্পন্ন করতে মোড ব্যবহার করেছিলাম এবং তারপরে ইনপুটের উপর ভিত্তি করে একটি ফ্যাক্টর দ্বারা গুণিত করে nস্নিপেট বেলোতে প্রতিটি পদক্ষেপ সহ স্প্রেডশিট যুক্ত করেছি

কোড স্নিপেট দেখান

— যষ্টি
সূত্র
আপনি মেটাম্যাগিক্স ব্যাখ্যা করতে পারেন? অর্থাত এগুলিকে আরও মানব-ফ্যাশন পদ্ধতিতে লিখবেন?
— ফ্লাইফি
@ ফ্লাইফি সি করেছেন:
— রড
0

পিএইচপি, 127 126 124 120 119 118 117 110 106 বাইট

আইএসও -8859-1 এনকোডিং ব্যবহার করে।

for(;($q=&$o[$y+=$d]||$q=~ÿ)&&~Ï^$q[$x+=!$d]=$argv[1][$a];$a++%($argv[2]-1)?:$d-=-!$y?:1)?><?=join(~õ,$o);

এটি চালান ( -dকেবল নান্দনিকতার জন্য যুক্ত):

php -r 'for(;($q=&$o[$y+=$d]||$q=~ÿ)&&~Ï^$q[$x+=!$d]=$argv[1][$a];$a++%($argv[2]-1)?:$d-=-!$y?:1)?><?=join(~õ,$o);' "Hello W0rld!" 3 2>/dev/null;echo

Ungolfed:

// Iterate over ...
for (
    ;
    // ... the characters of the input string. Prepend `0` so a 0 in the input
    // becomes truthy.
    0 . $char = $argv[1][$a];

    // Use modulo to determine the end of a stretch (where direction is
    // changed).
    // Change direction (`0` is right, `-1` is up and `1` is down). When
    // y coordinate is `0`, increment the direction, else decrement.
    $a++ % ($argv[2] - 1) ?: $direction += $y ? -1 : 1
)

    (
        // Increase or decrease y coordinate for direction -1 or 1 respectively.
        // Check whether the array index at new y coordinate is already set.
        $reference =& $output[$y += $direction] ||
        // If not, create it as a string (otherwise would be array of chars).
        // Null byte, won't be printed to prevent leading char.
        $reference = ~ÿ;

        // Increment x coordinate for direction 0. Set the output char at the
        // current coordinates to the char of the current iteration.
    ) & $reference[$x += !$direction] = $char;

// Output all lines, separated by a newline.
echo join(~õ, $output);

বদলান

  • এর <পরিবর্তে ব্যবহার করে একটি বাইট সংরক্ষণ করা হয়েছে!=
  • 0প্রথমে স্ট্রিং সেট করে 2 বাইট সংরক্ষণ করা হয়েছে , সুতরাং সত্যের ফলন দিয়ে 0আমাকে আর একটি 0প্রেন্ডেন্ড করতে হবে না (যদি কোনও লাইনে প্রথম আউটপুট ছিল একটি ) 00।
  • পুনরাবৃত্তি করার পরিবর্তে একটি রেফারেন্স ব্যবহার করে 4 বাইট সংরক্ষণ করা হয়েছে $o[$y]
  • ==এক্স স্থানাঙ্ক পরিবর্তন করতে 1 এর সাথে দিকের তুলনা করার পরিবর্তে মডুলো ব্যবহার করে একটি বাইট সংরক্ষণ করা হয়েছে
  • টাইপ কাস্ট সরিয়ে একটি বাইট সংরক্ষিত nullকরার int, স্ট্রিং অফসেট জন্য অফসেট যাহাই হউক না কেন int- এ নিক্ষেপ করা হয় স্ট্রিং হিসেবে
  • সংক্ষিপ্ত প্রিন্ট ট্যাগ ব্যবহার করে একটি বাইট সংরক্ষণ করা হয়েছে
  • দিকের যুক্তি উন্নত করে 7 বাইট সংরক্ষণ করা হয়েছে
  • ইন্টারমিডিয়েট প্রতিরোধের জন্য সরাসরি চর নির্ধারণ করে 4 বাইট সংরক্ষণ করা Sa $c
— aross
সূত্র
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.