46

এমন একটি প্রোগ্রাম (বা ফাংশন) লিখুন যা কোনও মুদ্রণযোগ্য ASCII অক্ষরের খালি খালি স্ট্রিংয়ের মধ্যে নেয় ।

স্ট্রিংয়ে অক্ষরগুলির একটি জিগজ্যাগিং চেইন মুদ্রণ করুন (বা প্রত্যাবর্তন করুন) এর সাথে যুক্ত প্রতিটি প্রতিবেশী জুটি অক্ষর দ্বারা যুক্ত:

/যদি প্রথম অক্ষরটি সাধারণত ASCII ক্রমে দ্বিতীয় অক্ষরের আগে ঘটে থাকে। যেমন
```
  B
 /
A
```
\যদি প্রথম অক্ষরটি সাধারণত ASCII ক্রমে দ্বিতীয় অক্ষরের পরে ঘটে। যেমন
```
B
 \
  A
```
-যদি প্রথম এবং দ্বিতীয় অক্ষর একই হয়। যেমন
```
A-A
```

সুতরাং আউটপুট Programming Puzzles & Code Golfহবে

                                                        o    
                                                       / \   
  r                         z-z               o   e   G   l  
 / \                       /   \             / \ / \ /     \ 
P   o   r   m-m   n       u     l   s   &   C   d           f
     \ / \ /   \ / \     /       \ / \ / \ /                 
      g   a     i   g   P         e                          
                     \ /

ইনপুট স্ট্রিংয়ে যদি কেবল একটি অক্ষর থাকে তবে আউটপুটটি কেবল সেই অক্ষরটিই হয়ে থাকে।

তোমার প্রোগ্রাম আচরণ করা উচিত , /, \, এবং -সব অন্যান্য অক্ষর হিসাবে ঠিক একই।

যেমন -\//-- \ //- উত্পাদন করা উচিত:

      \                      
     / \                     
    -   /-/                  
   /       \                 
 -          ---   \   /-/    
               \ / \ /   \   
                          -  
                           \

একক alচ্ছিক ট্রেলিং নিউলাইন ব্যতীত আউটপুটে কোনও বহিরাগত নিউলাইন থাকতে হবে না। (দ্রষ্টব্য যে উদাহরণের খালি রেখাটি ঠিক স্ট্রিংয়ের শেষ স্থানটি ধারণ করে এবং অতএব বহিরাগত নয়)) কোনও বিন্যাসে কোনও লাইনে পিছনের স্থান থাকতে পারে।

বাইটের মধ্যে সংক্ষিপ্ততম কোডটি জয়ী।

আরও একটি উদাহরণ - ইনপুট:

3.1415926535897932384626433832795028841971693993751058209749445923078164062862089986280348253421170679

আউটপুট:

                          9   9       8   6   6                                                                                                                                                            
                         / \ / \     / \ / \ / \                                                                                                                                                           
            9   6       8   7   3   3   4   2   4     8       9       8-8                                                                                                                                  
           / \ / \     /         \ /             \   / \     / \     /   \                                                                                                                                 
      4   5   2   5   5           2               3-3   3   7   5   2     4   9       9   9-9   7                                                                                                          
     / \ /         \ /                                   \ /     \ /       \ / \     / \ /   \ / \                                                                                                         
3   1   1           3                                     2       0         1   7   6   3     3   5       8                             8   6                                                              
 \ /                                                                             \ /               \     / \                           / \ / \                                                             
  .                                                                               1                 1   5   2   9             9   3   7   1   4   6   8                                                   9
                                                                                                     \ /     \ / \           / \ / \ /         \ / \ / \                                                 / 
                                                                                                      0       0   7   9     5   2   0           0   2   6       9-9               8   5   4             7  
                                                                                                                   \ / \   /                             \     /   \             / \ / \ / \           /   
                                                                                                                    4   4-4                               2   8     8           4   2   3   2     7   6    
                                                                                                                                                           \ /       \         /             \   / \ /     
                                                                                                                                                            0         6   8   3               1-1   0      
                                                                                                                                                                       \ / \ /                             
                                                                                                                                                                        2   0

code-golf string

— ক্যালভিনের শখ
সূত্র

8

পাইথ, 69 বাইট

aY,JhzZVtzaY,@"-\/"K-<NJ>N~JN=+ZKaY,N=+ZK;jbCmX*\ h-e=GSeMYhG-edhGhdY

প্রদর্শন. দীর্ঘতর ইনপুটগুলি এখনও কাজ করে তবে তারা স্থির-প্রস্থের আউটপুট বাক্সে খুব ভাল দেখাচ্ছে না।

আমি Y[চরিত্র, উচ্চতা] টিপলগুলির একটি তালিকা তৈরি করে শুরু করি । এটা [['P', 0], ['/', -1], ['r', -2], ['\\', -1], ['o', 0], ['\\', 1], ['g', 2]]উপর গোড়ার দিকে Programming Puzzles & Code Golfউদাহরণ।

আমি তারপরে যথাযথ দৈর্ঘ্যের স্পেসগুলির স্ট্রিং তৈরি করি, উপযুক্ত স্থানে অক্ষরটি সন্নিবেশ করি, স্থানান্তর করি, নতুন লাইনে যোগ করি এবং মুদ্রণ করি।

— isaacg
সূত্র

7

জুলিয়া, 297 বাইট

s->(l=length;d=sign(diff([i for i=s]));J=join([[string(s[i],d[i]>0?:'/':d[i]<0?:'\\':'-')for i=1:l(d)],s[end]]);D=reshape([d d]',2l(d));L=l(J);E=extrema(cumsum(d));b=2sumabs(E)+1;A=fill(" ",L,b);c=b-2E[2];for (i,v)=enumerate(J) A[i,c]="$v";i<l(D)&&(c-=D[i])end;for k=1:b println(join(A'[k,:]))end)

Ungolfed:

function f(s::String)
    # Get the direction for each slash or dash
    # +1 : /, -1 : \, 0 : -
    d = sign(diff([i for i in s]))

    # Interleave the string with the slashes as an array
    t = [string(s[i], d[i] > 0 ? '/' : d[i] < 0 ? '\\' : '-') for i = 1:length(d)]

    # Join the aforementioned array into a string
    J = join([t, s[end]])

    # Interleave D with itself to duplicate each element
    D = reshape(transpose([d d]), 2*length(d))

    # Get the length of the joined string
    L = length(J)

    # Get the maximum and minimum cumulative sum of the differences
    # This determines the upper and lower bounds for the curve
    E = extrema(cumsum(d))

    # Get the total required vertical size for the output curve
    b = 2*sumabs(E) + 1

    # Get the beginning vertical position for the curve
    c = b - 2*E[2]

    # Construct an array of spaces with dimensions corresponding
    # to the curve rotated 90 degrees clockwise
    A = fill(" ", L, b)

    # Fill the array with the curve from top to bottom
    for (i,v) = enumerate(J)
        A[i,c] = "$v"
        i < length(D) && (c -= D[i])
    end

    # Print out the transposed matrix
    for k = 1:b
        println(join(transpose(A)[k,:]))
    end
end

— অ্যালেক্স এ।
সূত্র

5

জাভাস্ক্রিপ্ট (ES6), 360 331 316 302 বাইট

এখানে আমার চতুর্থ প্রচেষ্টা:

s=>{r=[],c=s[m=w=n=0];for(i in s)(i?(d=s[++i])>c?++n:c>d?--n:n:n)<m&&m--,n>w&&w++,c=d;for(i=0,n=w*2;i<(w-m)*2+1;r[i++]=[...' '.repeat(l=s.length*2-1)]);for(i=0;i<l;i++)i%2?(A=s[C=(i-1)/2])<(B=s[C+1])?r[--n,n--][i]='/':A>B?r[++n,n++][i]='\\':r[n][i]='-':r[n][i]=s[i/2];return r.map(x=>x.join``).join`
`}

অন্য কারওর মতো সংক্ষিপ্ত নয়, তবে আমি আপাতত সন্তুষ্ট।

ওহ, তাই আপনি এটি পরীক্ষা করতে চান? ঠিক আছে, আপনি এখানে যান:

z=s=>{r=[],c=s[m=w=n=0];for(i in s)(i?(d=s[++i])>c?++n:c>d?--n:n:n)<m&&m--,n>w&&w++,c=d;for(i=0,n=w*2;i<(w-m)*2+1;r[i++]=[...' '.repeat(l=s.length*2-1)]);for(i=0;i<l;i++)i%2?(A=s[C=(i-1)/2])<(B=s[C+1])?r[--n,n--][i]='/':A>B?r[++n,n++][i]='\\':r[n][i]='-':r[n][i]=s[i/2];return r.map(x=>x.join``).join('<br>')};

input=document.getElementById("input");
p=document.getElementById("a");
input.addEventListener("keydown", function(){
  setTimeout(function(){p.innerHTML = "<pre>"+z(input.value)+"</pre>";},10);
})

<form>Type or paste your text here: <input type="text" id="input"/></form>

<h3>Output:</h3>
<p id="a"></p>

স্নিপেট প্রসারিত করুন

আনন্দ কর!

আপডেট:

আপডেট 1: বিভিন্ন সাধারণ কৌশল সহ 29 বাইট গল্ফড।

আপডেট 2: উল্লম্ব স্ট্রিংগুলির একটি অ্যারে তৈরি করে এবং তাদের চারপাশে স্যুইচ করার বিপরীতে, শুরু থেকে অনুভূমিকভাবে স্ট্রিং তৈরি করে আরও 15 বাইট গল্ফড হয়েছে যা এটি আগে যা করেছিল।

আপডেট 3: আরও 14 টি বাইট সংরক্ষণ করা হয়েছে।

আরও গল্ফনেস শীঘ্রই আসছে!

— ETHproductions
সূত্র

আপনি এই জাতীয়'\n' টেম্পলেট স্ট্রিংয়ের পরিবর্তে একটি বাইট সংরক্ষণ করতে পারেন

— ই

@ সংজ্ঞায়িত ফাংশন হ্যাঁ, আমি আগে এই কৌশলটি ব্যবহার করেছি, তবে গত রাতে এটি প্রয়োগ করতে ভুলে গেছি। অনুস্মারকটির জন্য ধন্যবাদ!

— ETH প্রোডাকশনগুলি

আপনার forলুপগুলি প্রচুর পরিমাণে স্কুয়েড করা যায়। এর সাথে প্রয়োজনীয় কোডের পুরো ব্লকটি অপচয় করবেন না i++। পরিবর্তে, আপনার forকোডটি বেশিরভাগটিতে চালান । এছাড়াও, কোডের একক লাইনের চারপাশে আপনার ধনুর্বন্ধনী প্রয়োজন হয় না।

— চার্লস

দেখে মনে হচ্ছে আপনি একমাত্র lউপায়টি গণনা করা s.length*2-1এবং আপনি এটি দুটিবার করেন। পরিবর্তে সেই মানটি কেন সংরক্ষণ করবেন না?

— যে চার্লস

1

টিপসটির জন্য ধন্যবাদ! আমি কেবল পরিবর্তিত অ্যালগরিদম চেষ্টা করেছি এবং এখনও এটি গল্ফ বিরক্ত করা হয়নি। <br>সেখানে তাই এটি HTML সংস্করণে দেখানো মাত্র হয়; আপনি যদি ঘনিষ্ঠভাবে তাকান তবে আমি প্রকৃত প্রবেশের পরিবর্তে একটি টেম্পলেট স্ট্রিং ব্যবহার করি। এছাড়াও, এটির কোনও প্রয়োজন নেই: "মুদ্রণ করুন (বা ফিরে) ..."

— ETH প্রোডাকশনগুলি

3

পাইথন, 393 বাইট

def z(n,h=[]):
 for j in range(len(n)):h.append(sum(cmp(ord(n[i]),ord(n[i+1]))for i in range(j)))
 h=[j-min(h)for j in h]
 for y in range(max(h)*2+2):
  s=""
  for x in range(len(n)):
   if h[x]*2==y:s+=n[x]
   else:s+=" "
   if x==len(n)-1:continue
   c=" "
   if h[x]<h[x+1]and h[x]*2==y-1:c="\\"
   if h[x]>h[x+1]and h[x]*2==y+1:c="/"
   if h[x]==h[x+1]and h[x]*2==y:c="-"
   s+=c
  print s

হিসাবে চালান: z("Zigzag")

— Loovjo
সূত্র

3

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

টেমপ্লেট স্ট্রিং ব্যবহার করে। ব্যাকটিক্সের অভ্যন্তরীণ শেষ নিউলাইন ব্যতীত উল্লেখযোগ্য এবং গণনা করা ছাড়া খালি স্থান এবং নিউলাইনগুলি গণনা করা হয় না।

সাধারণ নোট: যে কোনও ইকামাস্ক্রিপ্ট comp অনুবর্তী ব্রাউজারে স্নিপেট চলমান পরীক্ষা করুন (উল্লেখযোগ্যভাবে ক্রোম এমএসআইই নয়, আমি ফায়ারফক্সে পরীক্ষা করেছি, সাফারি 9 যেতে পারে)

f=z=>
  [...z].map(c=>
    (d=0,x=w+c,p&&(
      c<p?o[d=1,g='\\ ',r+=2]||o.push(v,v)
      :c>p?(d=-1,g='/ ',r?r-=2:o=[v,v,...o]):x='-'+c,
      o=o.map((o,i)=>o+(i-r?i-r+d?b:g:x),v+=b)
    ),p=c)
  ,v=w=' ',o=[z[p=r=0]],b=w+w)&&o.join`
`

Ungolfed=z=>
(
  v=' ',o=[z[0]],r=0,p='',
  [...z].map(c=>{
    if (p) {
      if (c < p) {
        if (! o[r+=2])
          o.push(v,v)
        o = o.map((o,i)=>o+(i==r ? ' '+c : i==r-1 ? '\\ ' : '  '))
      } else if (c > p) {
        if (r == 0)
          o = [v,v,...o]
        else
          r -= 2
        o = o.map((o,i)=>o+(i==r ? ' '+c : i==r+1 ? '/ ' : '  '))
      } else {
        o = o.map((o,i)=>o+(i==r ? '-'+c : '  '))
      }
      v += '  '
    }
    p = c
  }),
  o.join`\n`
)

out=x=>O.innerHTML+=x+'\n'

test = [
"Programming Puzzles & Code Golf",  
"-\\//-- \\ //- ",  
"3.1415926535897932384626433832795028841971693993751058209749445923078164062862089986280348253421170679"]

test.forEach(t=>out(t+"\n"+f(t)))

<pre id=O></pre>

স্নিপেট প্রসারিত করুন

— edc65
সূত্র

2

সিজেম, 79 বাইট

l__0=\+2ew::-:g_0\{+_}%);_$0=fm2f*_$W=)S*:E;]z{~\_)"/-\\"=2$@-E\@t@@E\@t}%(;zN*

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

এটি কলাম অনুসারে আউটপুট কলাম তৈরি করে এবং ফলাফলটিকে সারিবদ্ধভাবে আউটপুট সারি পেতে শেষে স্থানান্তর করে। এটি সামগ্রিকভাবে বেশ বেদনাদায়ক ছিল।

ব্যাখ্যা:

l__   Get input and create a couple of copies.
0=\+  Prepend copy of first letter, since the following code works only with
      at least two letters.
2ew   Make list with pairs of letters.
::-   Calculate differences between pairs...
:g    ... and the sign of the differences.
_0\   Prepare for calculating partial sums of signs by copying list and
      pushing start value 0.
{     Loop for calculating partial sums.
  +_    Add value to sum, and copy for next iteration.
}%    End of loop for partial sums. We got a list of all positions now.
);    Pop off extra copy of last value.
_$0=  Get smallest value.
fm    Subtract smallest value to get 0-based positions for letters.
2f*   Multiply them by 2, since the offsets between letters are 2.
_$W=  Get largest position.
)     Increment by 1 to get height of result.
S*    Build an empty column.
:E;   Store it in variable E.
]     We got the input string, list of relative offsets, and list of
      absolute positions now. Wrap these 3 lists...
z     ... and transpose to get triplets of [letter offset position].
{     Loop over triplets.
  ~     Unwrap triplet.
  \     Swap offset to front.
  _)    Copy and increment so that offset is in range 0-2.
  "/-\\"  List of connection characters ordered by offset.
  =     Pick out connection character for offset.
  2$@   Get position and copy of offset to top.
  -     Subtract to get position of connection character.
  E     Empty column.
  \@    Shuffle position and character back to top. Yes, this is awkward.
  t     Place connection character in empty line. Done with first column.
  @@    Shuffle letter and position to top.
  E     Empty column.
  \@    Stack shuffling again to get things in the right order.
  t     Place letter in empty line. Done with second column.
}%    End of main loop for triplets.
(;    Pop off first column, which is an extra connector.
z     Transpose the whole thing for output by row.
N*    Join with newlines.

— রেটো কোরাদি
সূত্র

1

পার্ল 5, 230 214

@A=split(//,pop);$y=$m=256;map{$c=ord$_;$d=$c<=>$p;$t=$d>0?'/':$d<0?'\\':'-';$B[$x++][$y-=$d]=$t;$B[$x++][$y-=$d]=$_;$m=$y,if$m>$y;$M=$y,if$M<$y;$p=$c}@A;for$j($m..$M){for$i(1..$x){$s.=$B[$i][$j]||$"}$s.=$/}print$s

পরীক্ষা

$ perl zigzag.pl "zigge zagge hoi hoi hoi"
z
 \
  i
   \
    g-g
       \
        e   z   g-g       o       o       o
         \ / \ /   \     / \     / \     / \
              a     e   h   i   h   i   h   i
                     \ /     \ /     \ /


$

— LukStorms
সূত্র

1

কে, 86

{-1@+((d#\:" "),'1_,/("\\-/"1+e),'x)@\:!|/d:(|/b)+-:b:1_+\,/2#'e:{(x>0)-x<0}@-':6h$x;}

।

k){-1@+((d#\:" "),'1_,/("\\-/"1+e),'x)@\:!|/d:(|/b)+-:b:1_+\,/2#'e:{(x>0)-x<0}@-':6h$x;} "Programming Puzzles & Code Golf"
                                                        o
                                                       / \
  r                         z-z               o   e   G   l
 / \                       /   \             / \ / \ /     \
P   o   r   m-m   n       u     l   s   &   C   d           f
     \ / \ /   \ / \     /       \ / \ / \ /
      g   a     i   g   P         e
                     \ /

Ungolfed:

f:{
    dir:{(x>0)-x<0}-':[*a;a:"i"$x];          //directional moves (-1, 0, 1)
    chars:1_,/("\\-/"1+dir),'x;              //array of input string combined with directional indicators
    depths:(|/b)+-:b:1_+\,/2#'dir;           //depth for each char, normalised to start at 0
    -1@+((depths#\:" "),'chars)@\:!|/depths; //Pad each character by the calculated depths, extend each string to a uniform length and transpose
    }

— tmartin
সূত্র

1

রুবি, 158

হিস্টোক্র্যাটকে ধন্যবাদ 6 বাইট সংরক্ষণ করা হয়েছে । ধন্যবাদ!

->s,*i{i[x=n=k=(4*m=s=~/$/).times{i<<'  '*m}/2][j=0]=l=s[/./]
$'.chars{|c|i[k-=d=c<=>l][j+1]=%w{- / \\}[d]
i[k-=d][j+=2]=l=c
n,x=[x,n,k].minmax}
puts i[n..x]}

— চার্লস না
সূত্র

1

আপনি একটি খালি অ্যারে ব্যবহার করে সেট করতে পারেন ->s,*i{। এবং যদি আপনি প্রতিস্থাপন s[0]সঙ্গে s[/./], আমার মনে হয় আপনি প্রতিস্থাপন করতে পারেন s[1..-1]সঙ্গে $'।

— হিস্টোক্র্যাট

@ হিস্টোরোকট গ্রেট! ধন্যবাদ! আমি ভেবেছিলাম মাল্টি-প্যারাম ল্যাম্বদা ঘোষণার জন্য আপনার প্যারেন দরকার, তবে দৃশ্যত এটি কেবল জেএস।

— চার্লস

0

নিম্পি সহ পাইথন: 218 বাইট

নম্পি আমদানি করার জন্য 19 বাইট নষ্ট করা এটি মূল্যবান।

Golfed:

from numpy import*
z=zip
r=raw_input()
s=sign(diff(map(ord,r[0]+r)))
c=cumsum(s)
p=2*(max(c)-c)+1
for L in z(*[c.rjust(i).ljust(max(p))for _ in z(z(p+s,array(list('-/\\'))[s]),z(p,r))for i,c in _][1:]):print''.join(L)

Ungolfed:

from numpy import *

letters = raw_input()
#letters = 'Programming Puzzles & Code Golf'
s = sign(diff(map(ord, letters[0] + letters)))
c = cumsum(s)
lines = array(list('-/\\'))[s]

letter_heights = 2 * (max(c) - c) + 1
line_heights = letter_heights + s

columns = [symbol.rjust(height).ljust(max(letter_heights))
    for pair in zip(                    # interleave two lists of (height, symbol) pairs...
        zip(line_heights,   lines),
        zip(letter_heights, letters)
    )
    for height, symbol in pair          # ... and flatten.
][1:]                                   # leave dummy '-' out
for row in zip(*columns):
    print ''.join(row)

— রবার্তো বনভোলেট
সূত্র

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

পাইথ, 69 বাইট

জুলিয়া, 297 বাইট

জাভাস্ক্রিপ্ট (ES6), 360 331 316 302 বাইট

আপডেট:

পাইথন, 393 বাইট

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

সিজেম, 79 বাইট

পার্ল 5, 230 214

পরীক্ষা

কে, 86

রুবি, 158

নিম্পি সহ পাইথন: 218 বাইট