একটি নিয়মিত স্ট্রিং এর মতো দেখাচ্ছে:

Hello,IAmAStringSnake!

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

Hel         
  l      rin
  o,IAmASt g
           S
       !ekan

তোমার কাজ

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

বিশেষ উল্লেখ

ইনপুটটি মাল্টলাইন স্ট্রিং বা স্ট্রিংগুলির একটি অ্যারে হতে পারে।
একটি আয়তক্ষেত্রাকার গ্রিড গঠনের জন্য ইনপুটটির প্রতিটি লাইন স্পেস দিয়ে প্যাড করা হবে।
সাপের অক্ষরগুলি কেবল উপরের, নীচে, বাম বা ডানদিকে (যেমন খেলা স্নপের মতো) সংলগ্ন অক্ষরের সাথে সংযুক্ত হতে পারে। তারা তির্যক যেতে পারে না।
সাপের অক্ষরগুলি কখনই সাপের অন্য অংশের সাথে সংযুক্ত হবে না, কেবল সংযুক্ত অক্ষর।
স্ট্রিংয়ের প্রথম অক্ষরটি ইনপুট গ্রিডের উপরের-বাম কোণ থেকে সংক্ষিপ্ততম ম্যানহাটনের দূরত্ব সহ শেষ চরিত্রটি (যেমন একটি সাপের জন্য শেষ অক্ষর থেকে সরাসরি উপরের বামে যেতে সর্বনিম্ন সংখ্যাটি লাগে moves কোণ)। উভয় প্রান্তে কখনও একই দূরত্ব থাকবে না।
স্ট্রিংটিতে কোড পয়েন্ট 33 এবং 126 সমেত (কোনও স্পেস বা নিউলাইন নেই) এর মধ্যে কোনও এএসসিআইআই অক্ষর থাকতে পারে character
স্ট্রিংটি 2 থেকে 100 বর্ণের মধ্যে দীর্ঘ হবে।
বাইটস মধ্যে সংক্ষিপ্ত কোড।

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

(ইনপুট গ্রিড, আউটপুট স্ট্রিংয়ের পরে)

Hel         
  l      rin
  o,IAmASt g
           S
       !ekan

Hello,IAmAStringSnake!

----------

Python

Python

----------

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

ProgrammingPuzzlesAndCodeGolf

----------

   ~ zyx tsr XWVUTSR
   }|{ wvu q Y     Q
!          p Z `ab P
"#$ 6789:; o [ _ c O
  % 5    < n \]^ d N
('& 432  = m     e M
)     1  > lkjihgf L
*+,-./0  ?         K
         @ABCDEFGHIJ

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

----------

  tSyrep    
  r    p    
  in Sli    
   g    Sile
   Snakes  n
Ser      ylt
a eh   ilS  
fe w   t    
   emo h    
     Sre    

SlipperyStringSnakesSilentlySlitherSomewhereSafe

code-golf string ascii-art

— user81655
সূত্র

20

মজার ঘটনা: লিঙ্কযুক্ত উইকিপিডিয়া নিবন্ধ অনুসারে, ম্যানহাটনের দূরত্ব সাপের দূরত্ব হিসাবেও পরিচিত!

— ব্যবহারকারী 81655

Hastebin.com/asugoropin.vbs এর মতো একটি ইনপুট কি সঠিক হবে?

— FliiFe

@ ফ্লাইফি না, সাপের কিছু অংশ একে অপরের পাশে থাকতে পারে না কারণ এটি ঘটলে সাপটি কোথায় চলেছে তা সর্বদা বলা সম্ভব নয় (এবং এটি চ্যালেঞ্জকে আরও শক্ত করে তুলবে)। আমি এই ব্যাখ্যা করতে অনুমিত একটি লাইন যুক্ত।

— ব্যবহারকারী81655

ইনপুটটি কি দ্বি-মাত্রিক অ্যারে (অর্থাত প্রতিটি উপাদান একটি উপাদান হিসাবে) হতে পারে?

— ফ্লাইফি

29

এই ধাঁধাটির অজগরের উত্তর দরকার?

— 7'll

11

এপিএল, 55 বাইট

{⍵[1↓(⊂0 0){1<⍴⍵:⍺,∆[⊃⍋+/¨|⍺-∆]∇∆←⍵~⍺⋄⍺}(,⍵≠' ')/,⍳⍴⍵]}

এই ফাংশনটিতে স্ট্রিং সাপের সাথে একটি অক্ষর ম্যাট্রিক্স লাগে।

উদাহরণ:

      s1 s2 s3
┌────────────┬──────────────┬────────────────────┐
│Hel         │P  ngPu  Code │   ~ zyx tsr XWVUTSR│
│  l      rin│r  i  z  d  G │   }|{ wvu q Y     Q│
│  o,IAmAst g│o  m  z  n  o │!          p Z `ab P│
│           S│gram  lesA  lf│"#$ 6789;: o [ _ c O│
│       !ekan│              │  % 5    < n \]^ d N│
│            │              │('& 432  = m     e M│
│            │              │)     1  > lkjighf L│
│            │              │*+,-./0  ?         K│
│            │              │         @ABCDEFGHIJ│
└────────────┴──────────────┴────────────────────┘
      ↑ {⍵[1↓(⊂0 0){1<⍴⍵:⍺,∆[⊃⍋+/¨|⍺-∆]∇∆←⍵~⍺⋄⍺}(,⍵≠' ')/,⍳⍴⍵]} ¨ s1 s2 s3 
Hello,IAmAstringSnake!                                                                        
ProgrammingPuzzlesAndCodeGolf                                                                 
!"#$%&'()*+,-./0123456789;:<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefhgijklmnopqrstuvwxyz{|}~

ব্যাখ্যা:

(,⍵≠' ')/,⍳⍴⍵: সমস্ত ফাঁকা স্থানের স্থানাঙ্ক পান
(⊂0 0): (0,0) এ শুরু করুন (যা একটি অবৈধ সমন্বয়)
{... }: সর্প, প্রদত্ত অবস্থান এবং সাপ অনুসরণ করুন:
- 1<⍴⍵:: যদি 1 টিরও বেশি উপাদান অবশিষ্ট থাকে:
  - ∆←⍵~⍺: সাপ থেকে বর্তমান অবস্থানটি সরিয়ে এটিতে সঞ্চয় করুন ∆।
  - +/¨|⍺-∆: বর্তমান অবস্থান এবং সাপের বাকী প্রতিটি পয়েন্টের মধ্যে দূরত্ব সন্ধান করুন
  - ∆[⊃⍋...] `: সাপের সবচেয়ে কাছের পয়েন্ট পান
  - ∇: নতুন বর্তমান পয়েন্ট হিসাবে নিকটতম পয়েন্ট এবং নতুন সাপ হিসাবে সংক্ষিপ্ত সাপ দিয়ে আবার ফাংশনটি চালান।
  - ⍺,: এর ফলাফলের সাথে বর্তমান অবস্থান যুক্ত করুন
- ⋄⍺: অন্যথায়, কেবলমাত্র বর্তমান অবস্থানটি ফিরিয়ে দিন
1↓: ফলাফল থেকে প্রথম আইটেমটি ফেলে দিন (যা (0,0) অবস্থান)
⍵[... ]: elements থেকে এই উপাদানগুলি ক্রমে পান

— সামুদ্রিক
সূত্র

24

জাভাস্ক্রিপ্ট (ES6) + স্নেকএক্স , 176 বাইট

a=b=>snakeEx.run("s{A}:<+>([^ ]<P>)+",b).reduce((c,d)=>(e=c.marks.length-d.marks.length)>0?c:e?d:c.x+c.y>d.x+d.y?d:c).marks.reduce((c,d,e,f)=>e%2?c+b.split`\n`[d][f[e-1]]:c,"")

স্নেকএক্সের কথা মনে আছে? ভাল, কারণ আমি না! গল্ফিং পরামর্শ স্বাগত।

— LegionMammal978
সূত্র

19

এমএটিএল , 80 বাইট

সংশোধনের জন্য @ লেভেলরিভারস্টকে ধন্যবাদ

32>2#fJ*+X:4Mt1Y6Z+l=*2#fJ*+ttXjwYj+K#X<)wt!"tbb6#Yk2#)yw]xxvtXjwYjqGZy1)*+Gw)1e

ইনপুটটি চরের 2D অ্যারে হিসাবে সারিগুলি পৃথক করে পৃথক করা হয় ;। এই বিন্যাসে পরীক্ষার কেসগুলি হ'ল

['Hel         ';'  l      rin';'  o,IAmASt g';'           S';'       !ekan']
['Python']
['P  ngPu  Code ';'r  i  z  d  G ';'o  m  z  n  o ';'gram  lesA  lf']
['   ~ zyx tsr XWVUTSR';'   }|{ wvu q Y     Q';'!          p Z `ab P';'"#$ 6789:; o [ _ c O';'  % 5    < n \]^ d N';'(''& 432  = m     e M';')     1  > lkjihgf L';'*+,-./0  ?         K';'         @ABCDEFGHIJ']
['  tSyrep    ';'  r    p    ';'  in Sli    ';'   g    Sile';'   Snakes  n';'Ser      ylt';'a eh   ilS  ';'fe w   t    ';'   emo h    ';'     Sre    ']

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

ব্যাখ্যা

প্রতিটি ননস্পেসের অক্ষরের সমন্বয়গুলি একটি জটিল সংখ্যা দ্বারা প্রতিনিধিত্ব করা হয়। প্রতিটি বর্তমান চরিত্রের জন্য, পরবর্তীটি নিকটতম হিসাবে প্রাপ্ত হয় (তাদের জটিল স্থানাঙ্কের সর্বনিম্ন পরম পার্থক্য)।

প্রাথমিক চরটি নির্ধারণ করতে, দুটি প্রান্তটি খুঁজে পাওয়া দরকার। এটি নিম্নলিখিত হিসাবে করা হয়। একটি প্রান্ত পয়েন্ট হ'ল একটি ননস্পেস চর এবং এর ঠিক একটি ননস্পেস প্রতিবেশী থাকে। প্রতিবেশীর সংখ্যা একটি উপযুক্ত মুখোশ দিয়ে 2 ডি সমঝোতার মাধ্যমে প্রাপ্ত হয়। প্রাথমিক পয়েন্টটি এমন শেষ পয়েন্ট যাঁর জটিল স্থানাংকটিতে আসল এবং কাল্পনিক অংশগুলির সর্বনিম্ন যোগ থাকে; অর্থাত্ জটিল সংখ্যার 0, বা সমতুল্য 1 + 1 জে ম্যানহাটনের দূরত্বের নিকটতম, যা উপরের বাম কোণে জটিল স্থানাঙ্ক।

32>      % Take input as 2D char array. Compute 2D array with true for nonspace,
         % false for space
2#f      % Arrays of row and column indices of nonspaces
J*+      % Convert to complex array. Real part is row, imaginary part is column
X:       % Convert to column array
4Mt      % Push arrays of zeros and ones again. Duplicate
1Y6      % Push array [0 1 0; 1 0 1; 0 1 0]. Used as convolution mask to detect
         % neighbours that are nonspace
Z+       % 2D convolution with same size as the input
1=       % True for chars that have only one neighbour (endpoints)
*        % Multiply (logical and): we want nonspaces that are endpoints
2#fJ*+   % Find complex coordinates (as before)
ttXjwYj  % Duplicate. Take real and imaginary parts
+        % Add: gives Manhattan distance to (0,0)
K#X<     % Arg min. Entry with minimum absolute value has least Manhattan
         % distance to (0,0), and thus to (1,1) (top left corner)
)        % Apply as an index, to yield complex coordinate of initial endpoint
wt!      % Swap, duplicate, transpose.
         % The stack contains, bottom to top: complex coordinates of initial
         % endpoint, column array with all complex coordinates, row array of all
         % coordinates. The latter is used (and consumed) by the next "for"
         % statement to generate that many iterations
"        % For loop. Number of iterations is number of nonspaces
  tbb    %   Duplicate, bubble up twice (rearrange is stack)
  6#Yk   %   Find which of the remaining points is closest to current point. This
         %   is the next char in the string
  2#)    %   Remove the point with that index from the array of complex
         %   coordinates. Push that point and the rest of the array
  yw     %   Duplicate extracted point, swap
]        % End for
xx       % Delete top two elements of the stack
v        % Concatenate all stack contents into a column array. This array
         % contains the complex coordinates of chars sorted to form the string
tXjwYj   % Extract real part and imaginary part
GZy1)    % Number of rows of input. Needed to convert to linear index
*+       % Convert rows and columns to linear index
Gw       % Push input below that
)        % Index to get the original chars with the computed order
1e       % Force the result to be a row array (string). Implicitly display

— লুইস মেন্ডো
সূত্র

আমি ধরে নিব একটি ব্যাখ্যা আসন্ন?

— ম্যাট

@ ম্যাট শিওর ... পরে দিনের :-)

— লুইস মেন্ডো

ব্যাখ্যা যোগ করেছেন @ ম্যাট

— লুইস মেন্ডো

The initial point is the endpoint whose complex coordinate has the least absolute valueযত্নশীল: ইউক্লিডিয়ান দূরত্ব! = ম্যানহাটনের দূরত্ব। উদাহরণস্বরূপ 7 + 7j পয়েন্টের ইউক্লিডিয়ান দূরত্ব 9.8994 এবং ম্যানহাটনের দূরত্ব 14. 10j ইউক্লিডিয়ান দূরত্বের পরে কিন্তু ম্যানহাটনের দূরত্বের দ্বারা বেশ কাছাকাছি রয়েছে। তা বাদে দুর্দান্ত ধারণা!

— স্তর নদী সেন্ট

@ লেভেলরিভারস্ট ধন্যবাদ! সংশোধন করা হয়েছে

— লুইস মেন্ডো

14

সি 198 190 179 180 181 বাইট

সম্পাদনা করুন: ব্যবহারকারী 81655 দ্বারা টিপটি ব্যবহৃত হয়েছে এবং টার্নারি অপারেটরে বন্ধনী সরিয়েছে, ধন্যবাদ! আরও উপযুক্ত (এবং সংক্ষিপ্ততর!) এস% 2 এর জন্য এমনকি সমীকরণের জন্য আমি জটিল (এস ও 1) পরীক্ষাও পরিবর্তন করেছি।

সম্পাদনা 2: * সম্বোধন শৈলীটি ভারীভাবে ব্যবহার করা, এস এর সংজ্ঞায় সুস্পষ্ট অপ্টিমাইজেশনের কাছে আমাকে অন্ধ করে তোলে, অর্থাত্ * (এ + মি) দ্বারা একটি [এম] ইত্যাদি প্রতিস্থাপন করে আমি এস এর পরে নিজেকে টি দ্বারা প্রতিস্থাপন করি যা মূলত এস কি অর্ধেক। কোডটি এখন পুতচরের রিটার্ন মানটিও গ্রহণ করে।

সম্পাদনা 3: স্থির ত্রুটি যা শুরু থেকেই ছিল, ম্যানহাটান-অনুসন্ধানের স্টপিং মানদণ্ড <b + m কেবলমাত্র যদি ইতিমধ্যে হ্রাস করা হয় তবে সঠিক। এটি 2 বাইট যোগ করে, তবে একটি বিশ্বব্যাপী মি সংজ্ঞা তৈরি করে পুনরায় প্রাপ্ত হয়।

সম্পাদনা 4: আমার গল্ফিং সর্বনিম্ন উত্তীর্ণ হয়েছে এবং এখন ভুল পথে চলছে। ম্যানহাটন-অনুসন্ধান সম্পর্কিত আরও একটি বাগ ফিক্স। আমি মূলত স্থানে আবদ্ধ চেকগুলি রেখেছিলাম এবং সেগুলি ছাড়াই বড় বিস্তারের ইনপুট অ্যারে (কোথাও 50x50 রাউন্ড) অ্যারের বি ছাড়িয়ে অনুসন্ধান চালিয়ে যায়। সুতরাং সেই অ্যারেটি আগের আকারের কমপক্ষে দ্বিগুণ প্রসারিত করতে হবে, যা আরও একটি বাইট যুক্ত করে।

#define T(x)+x*((a[x]>32)-(a[-x]>32))
m=103;main(){char b[m<<8],*e=b,*a=e+m;while(gets(e+=m));for(e=a;(T(1)T(m))%2**a<33;a=a<b+m?e+=m:a)a-=m-1;for(;*a;a+=T(1)T(m))*a-=putchar(*a);}

অবহেলিত এবং ব্যাখ্যা:

/* T(1)T(m) (formerly S) is used in two ways (we implicitly assume that each cell has
   one or two neighbors to begin with):
   1. (in the first for-loop) T(1)T(m) returns an odd (even) number if cell a has one (two)
      neighbors with ASCII value > 32. For this to work m must be odd.
   2. (in the second for-loop) at this stage each cell a in the array at which T(1)T(m) is
      evaluated has at most one neighboring cell with ASCII value > 32. T(1)T(m) returns the
      offset in memory to reach this cell from a or 0 if there is no such cell.
      Putting the + in front of x here saves one byte (one + here replaces two
      + in the main part)

#define T(x)+x*((a[x]>32)-(a[-x]>32))

  /* A snake of length 100 together with the newlines (replaced by 0:s in memory) fits
     an array of size 100x101, but to avoid having to perform out-of-bounds checks we
     want to have an empty line above and the array width amount of empty lines below
     the input array. Hence an array of size 202x101 would suffice. However, we save
     a (few) bytes if we express the array size as m<<8, and since m must be odd
     (see 1. above), we put m = 103. Here b and e point to the beginning of the (now)
     256x103 array and a points to the beginning of the input array therein */

m=103;
main()
{

  char b[m<<8],*e=b,*a=e+m;

  /* This reads the input array into the 256x103 array */

  while(gets(e+=m));

  /* Here we traverse the cells in the input array one
     constant-Manhattan-distance-from-top-left diagonal at a time starting at the top-left
     singleton. Each diagonal is traversed from bottom-left to top-right since the starting point
     (memory location e) is easily obtained by moving one line downwards for each diagonal
     (+m) and the stopping point is found by comparing the present location a to the input array
     starting position (b+m). The traversal is continued as long as the cell has either
     an ASCII value < 33 or it has two neighbors with ASCII value > 32 each (T(1)T(m)
     is even so that (T(1)T(m))%2=0).
     Note that the pointer e will for wide input arrays stray way outside (below) the
     input array itself, so that for a 100 cell wide (the maximum width) input array
     with only two occupied cells in the bottom-right corner, the starting cell
     will be discovered 98 lines below the bottom line of the input array.
     Note also that in these cases the traversal of the diagonals will pass through the
     right-hand side of the 103-wide array and enter on the left-hand side. This, however,
     is not a problem since the cells that the traversal then passes have a lower
     Manhattan distance and have thereby already been analyzed and found not to contain
     the starting cell. */

  for(e=a;(T(1)T(m))%2**a<33;a=a<b+m?e+=m:a)a-=m-1;

  /* We traverse the snake and output each character as we find them, beginning at the
     previously found starting point. Here we utilize the function T(1)T(m), which
     gives the offset to the next cell in the snake (or 0 if none), provided that
     the current cell has at most one neighbor. This is automatically true for the
     first cell in the snake, and to ensure it for the rest of the cells we put the
     ASCII value of the current cell to 0 (*a-=putchar(*a)), where we use the fact
     that putchar returns its argument. The value 0 is convenient, since it makes the
     stopping condition (offset = 0, we stay in place) easy to test for (*a == 0). */

  for(;*a;a+=T(1)T(m))
    *a-=putchar(*a);
}

— Zunga
সূত্র

1

এই উত্তর দুর্দান্ত।

— 6

+1 এটি দুর্দান্ত। আমি আপনার উত্তরটির সাথে একটি ব্যাখ্যা যুক্ত করতে চাই যেখানে আপনার সমাধানের তুলনায় আমি বাইটগুলি যেখানে প্রত্যাখ্যান করেছি, তা কি ঠিক?

— mIllIbyte

mIllIbyte - মন্তব্য যোগ করতে নির্দ্বিধায়, এটি নতুন ধারণার দিকে রাস্তা

— জুনাগা

user81655 - টিপটির জন্য ধন্যবাদ, এটি 6 বাইট বন্ধ শেভ প্রকৃতপক্ষে, আমি চেষ্টা করেছি যে গতকাল পাশাপাশি (এস ও 1) এর পরিবর্তে এস% 2 ব্যবহার করেছি, যা স্নেহ পরীক্ষার জন্য অন্য 2 বাইট বন্ধ করে দিয়েছে, তবে কোনও কারণে (আমার কোডটি অন্য কোথাও বগি ছিল) না তখনও যথাযথভাবে কাজ করে নি। এখন, সব ঠিক আছে বলে মনে হচ্ছে।

— Zunga

খুব সুন্দর. সঙ্গে আরো কিছু সংরক্ষণ a[1], a[-m]ইত্যাদি, এবং উপার্জন mবিশ্বব্যাপী - m=103;main()।

— ugoren

9

সি, 272 বাইট

#define E j+(p/2*i+1)*(p%2*2-1)
#define X(Y) a[Y]&&a[Y]-32
char A[999],*a=A+99;j,p,t;i;main(c){for(;gets(++j+a);j+=i)i=strlen(a+j);for(c=j;j--;){for(t=p=4;p--;)t-=X(E);t==3&&X(j)?c=c%i+c/i<j%i+j/i?c:j:0;}for(j=c;c;){putchar(a[j]),a[j]=0;for(c=0,p=4;!c*p--;)X(E)?c=j=E:0;}}

@ জঙ্গার উত্সটি দেখুন। এখন আমার দেখুন। আমি কীভাবে অতিরিক্ত 91-বাইট পেয়েছি তা জানতে চান?
Ungolfed:

#define E j+(p/2*i+1)*(p%2*2-1)
#define X(Y) a[Y]&&a[Y]-32  //can be more concise, see @Zunga's
  //and then doesn't need the define
char A[999],*a=A+99;j,p,t;i;
main(c){for(;gets(++j+a);j+=i)
i=strlen(a+j); //we don't need to know the length of a line
  //in @Zunga's solution, lines are spaced a constant distance apart
for(c=j;j--;){
for(t=p=4;p--;)t-=X(E);  //a ton of bytes can be saved with determining 
  //the neighbors, see @Zunga's source
t==3&&X(j)?
c=c%i+c/i<j%i+j/i?c:j:0;}  //we search for ends of the snake, 
  //and compute the Manhattan distance
for(j=c;c;){putchar(a[j]),a[j]=0;
for(c=0,p=4;!c*p--;)  //determining the neighbors again
X(E)?c=j=E:0;}}

— mIllIbyte
সূত্র

5

পাইথন (2 এবং 3), 640 624 604 583 575 561 546 538 বাইট

আমি এখনও একটি গল্ফ n00b তাই এটি কিছুটা বড়।

সম্পাদনা করুন: পরামর্শগুলির জন্য @ পোরগলজম্পকে ধন্যবাদ ! পাইথন 3 কে ভেঙে ফেললে আমি সমস্ত 'এবং' অপারেটর সরিয়ে ফেলিনি।

সম্পাদনা 2: ইস্পেস () সম্পর্কে মন্তব্য করার জন্য @ আলেকসি তোড়হামোকে ধন্যবাদ । ফলস্বরূপ হ্রাস আমি যে বগফিক্স রেখেছি তার জন্য ক্ষতিপূরণ দেয় Also এছাড়াও সিনট্যাক্স হাইলাইট করার জন্য বেনামে ধন্যবাদ!

সম্পাদনা 3: কয়েকটি অতিরিক্ত বাইটের জন্য @ mbomb007 কে ধন্যবাদ ।

import sys;s=sys.stdin.read().split('\n');m={};q=[];o=len;j=o(s);r=range;g='!'
for y in r(j):
 v=s[y];f=o(v);d=y+1
 for x in r(f):
  n=[];a=n.append;U=s[y-1]
  if v[x]>=g:j>=y>0==(U[x]<g)<=x<o(U)and a((x,y-1));j>y>=0==(v[x-1]<g)<x<=f and a((x-1,y));j>y>-1<x+1<f>(v[x+1]<g)<1and a((x+1,y));j>d>-1<x<o(s[d])>(s[d][x]<g)<1and a((x,d));m[x,y]=[v[x],n];o(n)-1or q.append((x,y))
t=min(q,key=sum);w=sys.stdout.write;w(m[t][0]);c=m[t][1][0]
while o(m[c][1])>1:
 b=m[c][1];w(m[c][0])
 for k in r(o(b)):
  if b[k]!=t:t=c;c=b[k];break
print(m[c][0])

এবং এখানে আমার প্রাক-গল্ফ সংস্করণ

import sys

lines = sys.stdin.read().split('\n')
startend = []
mydict = {}
for y in range( 0, len(lines)):
  for x in range( 0, len(lines[y])):
    if not lines[y][x].isspace():
      neighbors = []
      if x>=0 and x<len(lines[y-1]) and y-1>=0 and y-1<len(lines):
        if not lines[y-1][x].isspace():
          neighbors.append( (x,y-1) )
      if x-1>=0 and x-1<len(lines[y]) and y>=0 and y<len(lines):
        if not lines[y][x-1].isspace():
          neighbors.append( (x-1,y) )
      if x+1>=0 and x+1<len(lines[y]) and y>=0 and y<len(lines):
        if not lines[y][x+1].isspace():
          neighbors.append( (x+1,y) )
      if x>=0 and x<len(lines[y+1]) and y+1>=0 and y+1<len(lines):
        if not lines[y+1][x].isspace():
          neighbors.append( (x,y+1) )
      mydict[(x,y)] = [ lines[y][x], neighbors ]

      if len( neighbors ) == 1:
        startend.append( (x,y) )

startend.sort( key=lambda x : x[0]*x[0] + x[1]*x[1] )

last = startend[0]
sys.stdout.write( mydict[ last ][0] )
current = mydict[last][1][0]
while len( mydict[current][1] ) > 1:
  sys.stdout.write( mydict[current][0] )
  for k in range( 0, len( mydict[current][1] ) ):
    if mydict[current][1][k] != last:
      last = current
      current = mydict[current][1][k]
      break

print(mydict[current][0])

— ceilingcat
সূত্র

1

আমি প্রবর্তন করে S=lambda s:s.isspace()এবং তার S(s)পরিবর্তে না করে 12 বাইট সংরক্ষণ করেছি s.isspace()।

— পোরগলজম্প

1

আমার মনে হয় আপনি আপনার সব পরিবর্তন করতে পারেন and থেকে <, যেহেতু f() < g() < h()হিসাবে একই g = g(); f() < g and g < h()পার্শ্ব প্রতিক্রিয়া পদ (তুলনা চেইন শর্ট সার্কিট) এ, এবং আপনি তুলনা ফল যাহাই হউক না কেন উপেক্ষা করছি।

— পোরগলজম্প

1

m[(x,y)]=সংক্ষিপ্ত হিসাবে একইm[x,y]=

— পোরগলজম্প

2

@ পোরগলজম্প: এটি বলা আরও ছোটS=str.isspace

— আলেকসি তোড়হামো

1

মুছে ফেলা Sএবং পরিবর্তে <'!'প্রতিটি ঘটনায় ব্যবহার একই দৈর্ঘ্য হতে পারে, সম্ভবত আরও সংরক্ষণের সুযোগ খোলার। উদাহরণস্বরূপ, এ পরিবর্তন if 1-S(v[x]):করা if(v[x]<'!')<1:। এবং সম্ভবত আপনি পরবর্তী উপাখাগুলি সেভাবেই করে কিছু অপসারণ করতে পারেন।

— mbomb007

4

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

পরীক্ষার স্নিপেটের ভিতরে ব্যাখ্যা দেখুন

s=>[...s].map((c,i)=>{if(c>' '&([n=-1,1,o=-~s.search('\n'),-o].map(d=>n+=s[i+d]>' '&&!!(e=d)),n<1)&m>(w=i/o+i%o|0))for(m=w,r=c,p=i+e;r+=s[i=p],[e,o/e,-o/e].some(d=>s[p=i+(e=d)]>' '););},m=1/0)&&r

পরীক্ষা

f=s=>[...s].map((c,i)=>{if(c>' '&([n=-1,1,o=-~s.search('\n'),-o].map(d=>n+=s[i+d]>' '&&!!(e=d)),n<1)&m>(w=i/o+i%o|0))for(m=w,r=c,p=i+e;r+=s[i=p],[e,o/e,-o/e].some(d=>s[p=i+(e=d)]>' '););},m=1/0)&&r

// Less golfed

u=s=>(
  o = -~s.search('\n'), // offset between lines
  m = 1/0, // current min manhattan distance, init at infinity
  // scan input looking for the 2 ends of the string
  [...s].map((c,i)=>{ // for each char c at position i
     if(c > ' ' // check if part of the string
        & ( [-1,1,o,-o] // scan in 4 directions and count neighbors
             .map(d=> n+=s[i+d]>' '&&!!(e=d), n=0), // remember direction in e
          n < 2) // if at end of string will have exactly 1 neighbor
        & (w = i/o + i%o |0) < m) // manhattan distance in w, must be less than current min
       // found one of the ends, follow the path and build the string in r
       for(m = w, r = c, p = i+e; 
           r += s[i=p], 
           [e,o/e,-o/e] // check 3 directions, avoiding to go back
           .some(d=>s[p=i+(e=d)]>' '); // save candidate position and direction in p and e
          ); // empty for body, all the work is inside the condition
  }),
  r
)  

console.log=x=>O.textContent+=x+'\n'

;[`Hel         
  l      rin
  o,IAmASt g
           S
       !ekan`,
 `   ~ zyx tsr XWVUTSR
   }|{ wvu q Y     Q
!          p Z \`ab P
"#$ 6789:; o [ _ c O
  % 5    < n \\]^ d N
('& 432  = m     e M
)     1  > lkjihgf L
*+,-./0  ?         K
         @ABCDEFGHIJ`].forEach(t=>{
  console.log(t+'\n\n'+f(t)+'\n')
  })

<pre id=O></pre>

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

— edc65
সূত্র

সেমিকোলনগুলি কি ););}প্রয়োজনীয়?

— সিস টিমারম্যান

1

পছন্দ করুন প্রথমটি forহেডারের ভিতরে যেখানে 2 টি কলোন প্রয়োজন needed দ্বিতীয়টি হ'ল forদেহের

— ডিলিমিটার

3

লুয়া, 562 535 529 513 507 504 466 458 বাইট

এই মুহুর্তে আমার সবচেয়ে বড় গল্ফ, আমি মনে করি আমি এখনও 100 বাইট কেটে ফেলতে পারি, যার দিকে আমি কাজ করব, তবে এটি ইতিমধ্যে কিছুটা সময় নিয়েছে বলে উত্তর হিসাবে পোস্ট করছি :)। আমি ঠিক বলেছি, আমি 100 টিরও বেশি বাইট কেটে ফেলেছি! আমি মনে করি না উন্নতির অনেক জায়গা আছে।

এই ফাংশনটিতে প্রতি ঘরের মধ্যে একটি অক্ষর সমন্বিত 2D অ্যারে যুক্ত করতে হবে।

@ কেনি লাউয়ের সাথে কাজ করার সময় 40 বাইট সংরক্ষণ করা হয়েছে , তাকে ধন্যবাদ!

সাব্বাস! 500 বছরের নিচে!

function f(m)t=2u=1i=1j=1s=" "::a::if s~=m[i][j]and(i<#m and m[i+1][j]~=s)~=(j<#m[i]and m[i][j+1]~=s)~=(i>1 and m[i-1][j]~=s)~=(j>1 and m[i][j-1]~=s)then goto b end
i,t=i%t+1,#m>t and t==i and t+1or t j=j>1 and j-1or u u=u<#m[1]and j==1 and u+1or u goto a::b::io.write(m[i][j])m[i][j]=s
i,j=i<#m and s~=m[i+1][j]and i+1or i>1 and s~=m[i-1][j]and i-1or i,j<#m[i]and s~=m[i][j+1]and j+1or j>1 and s~=m[i][j-1]and j-1or j
if s==m[i][j]then return end goto b end

Ungolfed

আমি একবার এই গল্ফিং সম্পন্ন করার পরে ব্যাখ্যাগুলি আসবে, মুহুর্তের জন্য, আমি আপনাকে এই উত্স কোডটির একটি পঠনযোগ্য সংস্করণ দেব: ডি এখানে ব্যাখ্যা আসে!

সম্পাদনা করুন: সর্বশেষ পরিবর্তন সহ আপডেট করা হয়নি, আপডেট করার আগেও গল্ফ করছে। একই ব্যাখ্যা জন্য যায়

function f(m)                    -- declare the function f which takes a matrix of characters
  t=2                            -- initialise the treshold for i
                                 -- when looking for the first end of the snake
  u=1                            -- same thing for j
  i,j=1,1                        -- initialise i and j,our position in the matrix
  s=" "                          -- shorthand for a space
  ::a::                          -- label a, start of an infinite loop
    if m[i][j]~=s                -- check if the current character isn't a space
      and(i<#m                   -- and weither it is surrounded by exactly
          and m[i+1][j]~=s)      -- 3 spaces or not
      ~=(j<#m[i]
          and m[i][j+1]~=s)      -- (more explanations below)
      ~=(i>1 
          and m[i-1][j]~=s)
      ~=(j>1
          and m[i][j-1]~=s)
      then goto b end            -- if it is, go to the label b, we found the head
    i,t=                         -- at the same time
      i%t+1,                     -- increment i
      #m>t and t==i and t+1or t  -- if we checked all chars in the current range, t++
    j=j>1 and j-1or u            -- decrement j
    u=u>#m[1]and j==1 and u+1or u-- if we checked all chars in the current range, u++
  goto a                         -- loop back to label a

  ::b::                          -- label b, start of infinite loop
  io.write(m[i][j])                    -- output the current char
    m[i][j]=s                    -- and set it to a space
    i,j=i<#m                     -- change i and j to find the next character in the snake
          and m[i+1][j]~=s       -- this nested ternary is also explained below
            and i+1              -- as it takes a lot of lines in comment ^^'
          or i>1 
            and m[i-1][j]~=s
            and i-1
          or i,
       j<#m[i] 
         and m[i][j+1]~=s
           and j+1
         or j>1 
           and m[i][j-1]~=s 
           and j-1
         or j
    if m[i][j]==s                -- if the new char is a space
    then                         -- it means we finished
      return                  -- exit properly to avoid infinite
    end                          -- printing of spaces
  goto b                         -- else, loop back to label b
end

সুতরাং এখানে এই প্রোগ্রামটি কীভাবে কাজ করে সে সম্পর্কে কিছু বিশদ বিবরণ আসে।

প্রথমত, লেবেলযুক্ত লুপটি বিবেচনা করুন a, এটি আমাদের উপরের-বাম কোণার নিকটতম প্রান্তটি সন্ধান করতে দেয়। এটি শেষ না হলে চিরতরে লুপ হয়ে যাবে, তবে এটি কোনও সমস্যা নয়: ডি।

একটি 4x4 গ্রিডে এটি এখানে সাপের দূরত্ব (বাম) এবং তাদের ক্রমটি (ডানদিকে) দেখানো হয়

1  2  3  4    |     1  2  4  7
2  3  4  5    |     3  5  8 11
3  4  5  6    |     6  9 12 14
4  5  6  7    |    10 13 15 16

এই চরিত্রটির প্রতিটিটির জন্য, শেষ হতে, এটি দুটি শর্ত পরীক্ষা করতে হবে: - কোনও স্থান নয় - প্রায় 3 স্পেস দ্বারা ঘিরে থাকা (বা ঠিক 1 অ-স্থান)

এই শর্তাদি নীচের কোডের টুকরাটি পরীক্ষা করা হয়

r=m[i][j]~=s
    and(i<#m and m[i+1][j]~=s)
    ==not(j<#m[i] and m[i][j+1]~=s)
    ==not(i-1>0 and m[i-1][j]~=s)
    ==not(j-1>0 and m[i][j-1]~=s)
    and m[i][j]
    or r
  -- special note: "==not" is used as an equivalent to xor
  -- as Lua doesn't know what is a xor...

চরটি কোনও স্থান নয় কিনা তা পরীক্ষা করা এক্সপ্রেশন দ্বারা অর্জিত হয় m[i][j]~=s।

আমাদের আশেপাশের জন্য উপরোক্ত শর্তগুলিতে কেবলমাত্র 1 অ-স্থান দিয়ে ঘেরাও করা হয়েছে কিনা তা পরীক্ষা করা হচ্ছে, এটি লিখিত হতে পারে

m[i+1][j]~=" " ⊕ m[i][j+1]~=" " ⊕ m[i-1][j]~=" " ⊕ m[i][j-1]~=" "

এবং পরিশেষে, উপরের সমস্তটি যদি সত্য হিসাবে মূল্যায়ন করা হয়, তবে তার্নারি শেষ and-> এ ফিরে আসবে m[i][j]। অন্যথায়, আমরা rআনসেট করতে দিন :)

এখন যেহেতু আমাদের সাপের মাথা আছে, আসুন আমরা অন্য প্রান্তে আসি! সাপটি আটকানো প্রধানত নিম্নলিখিত নীড়যুক্ত অঞ্চলগুলি দ্বারা অর্জন করা হয়:

i,j=i<#m and m[i+1][j]~=s and i+1or i-1>0 and m[i-1][j]~=s and i-1or i,
    j<#m[i]and m[i][j+1]~=s and j+1or j-1>0 and m[i][j-1]~=s and j-1or j

আমরা পুনরায় সেট করেছি iএবং jএকই সাথে পুরাতন মানগুলি সংরক্ষণের জন্য ডামিগুলির প্রয়োজনীয়তা এড়াতে তাদের উভয়েরই সঠিক কাঠামো রয়েছে এবং সহজ শর্তাদি ব্যবহার করা হয়, তাই আমি এগুলি নেস্ট আকারে উপস্থাপন করব if, এটি আপনাকে সেগুলি পড়ার অনুমতি দেবে আরও সহজে। :)

i=i<#m and m[i+1][j]~=s and i+1or i-1>0 and m[i-1][j]~=s and i-1or i

অনুবাদ করা যেতে পারে:

if(i<#m)
then
  if(m[i+1][j]~=" ")
  then
    i=i+1
  end
elseif(i-1>0)
then
  if(m[i-1][j]~=" ")
  then
    i=i-1
  end
end

এটা পরীক্ষা করো!

এটি চালানোর জন্য আমি যে কোডটি ব্যবহার করি তা এখানে, আপনি এটি অনুলিপি-পেস্ট করে অনলাইনে পরীক্ষা করতে পারেন ।

function f(m)t=2u=1i=1j=1s=" "::a::if s~=m[i][j]and(i<#m and m[i+1][j]~=s)~=(j<#m[i]and m[i][j+1]~=s)~=(i>1 and m[i-1][j]~=s)~=(j>1 and m[i][j-1]~=s)then goto b end
i,t=i%t+1,#m>t and t==i and t+1or t j=j>1 and j-1or u u=u<#m[1]and j==1 and u+1or u goto a::b::io.write(m[i][j])m[i][j]=s
i,j=i<#m and s~=m[i+1][j]and i+1or i>1 and s~=m[i-1][j]and i-1or i,j<#m[i]and s~=m[i][j+1]and j+1or j>1 and s~=m[i][j-1]and j-1or j
if s==m[i][j]then return end goto b end


test1={}
s1={
"  tSyrep    ",
"  r    p    ",
"  in Sli    ",
"   g    Sile",
"   Snakes  n",
"Ser      ylt",
"a eh   ilS  ",
"fe w   t    ",
"   emo h    ",
"     Sre    ",
     }
for i=1,#s1
do
  test1[i]={}
  s1[i]:gsub(".",function(c)test1[i][#test1[i]+1]=c end)
end
f(test1)

— Katenkyo
সূত্র

1

ভাষার উত্তর পছন্দ হওয়ায় এগুলির পক্ষে আর উত্তরগুলির পক্ষে একটি নরম স্পট রয়েছে।

— ম্যাট

@ ম্যাট সমর্থনের জন্য অনেক ধন্যবাদ! আসলে, আমি এখনও এটিকে গল্ফ করার উপায়গুলি খুঁজে পাচ্ছি, তবে এটি আরও শক্ত এবং শক্ত হচ্ছে!

— কাটেনকিও

2

লুয়া, 267 বাইট

লুয়া 5.3 প্রয়োজনীয়।

e=" "w=#arg[1]+1i=1/0q=0s=table.concat(arg,e)s=e:rep(#s)..s
m,n=i,{}for p in s:gmatch"()%g"do u=-1
for _,d in ipairs{-1,1,-w,w}do u=u+(s:find("^%S",d+p)or 0)end
n[p]=u+1m=math.min(m,p*i^(u//#s)+(p%w*w+p)*#s)end
p=m%#s repeat q,p=p,n[p]-q io.write(s:sub(q,q))until p<1

ব্যবহার:

$ lua desnakify.lua \
>    "  tSyrep    " \
>    "  r    p    " \
>    "  in Sli    " \
>    "   g    Sile" \
>    "   Snakes  n" \
>    "Ser      ylt" \
>    "a eh   ilS  " \
>    "fe w   t    " \
>    "   emo h    " \
>    "     Sre    "
SlipperyStringSnakesSilentlySlitherSomewhereSafe

— ডিম স্ক্রিপ্টুনফ
সূত্র

2

পাইথন 3, 245 243 241 236 বাইট

sইনপুট স্ট্রিং, nস্টপআউট এ মুদ্রিত আউটপুট হয়:

f=s.find
w,l=f('\n')+1,len(s)
t=1,w,-1,-w
y=z=f(s.strip()[0]);n=s[y];v={y}
for i in range(l*l):
 i%=l;c=s[i]
 if c>' 'and i not in v:
  if i-y in t:y=i;n=c+n;v|={i}
  elif i-z in t:z=i;n+=c;v|={i}
if y%w+y//w>z%w+z//w:n=n[::-1]
print(n)

সম্পাদনা: 5 বাইট বাঁচানোর জন্য @ সিজ টিমারম্যানকে ধন্যবাদ!

— pgks
সূত্র

c>' 'andএবং print nপাইথন 2 এ

— সিস টিমারম্যান

আপনি কি এর ifবদলে করতে পারবেন না elif?

— ক্লিস্টিক

@ কিওয়ার্প-ডের্প দুর্ভাগ্যক্রমে নয়, আমি এর আগেও চেষ্টা করে দেখেছি, তবে এটি মুদ্রণ করে, উদাহরণস্বরূপ "!" এবং "স্লিপ্পিরিস্টিরিপিলস"।

— pgks

ইনপুট ফর্ম্যাট কি?

— ক্লিমেমিক

@ কিউয়ারপ-ডের্প sভেরিয়েবল একটি মাল্টলাইন স্ট্রিং; স্ট্রিংয়ের শেষ চরিত্রটি অবশ্যই একটি নতুন লাইন হতে হবে ( Pythonপরীক্ষার

— কেসটি

1

পাইথন, 537

আমার প্রাথমিক সমাধান:

from itertools import chain, product, ifilter
from operator import add
moves = ((1,0),(0,1),(-1,0),(0,-1))
h = dict(ifilter(lambda (p,v):not v.isspace(),chain(*map(lambda (i,r):map(lambda (j,c):((i,j),c),enumerate(r)),enumerate(s)))))
n = defaultdict(list)
for m,p in product(moves, h):
    np = tuple(map(add,m,p))
    if np in h:
        n[p].append(np)
def pr(nx):
    return(lambda l:(h[l[0]], h.pop(l[0]))[0] + pr(l[0]) if l else '')([x for x in n[nx] if x in h])
(lambda y: h[y]+ pr(y))(next(x for x in n if len(n[x])==1))

কিছুটা কম্প্যাক্ট করেছেন, তবে একটি পদ্ধতি হিসাবে রেখে দিয়েছেন:

from itertools import chain, product
from operator import add
def unsnake(s):
    (h,n) = (dict(filter(lambda (p,v):not v.isspace(),chain(*map(lambda (i,r):map(lambda (j,c):((i,j),c),enumerate(r)),enumerate(s))))),defaultdict(list))
    for m,p in product(((1,0),(0,1),(-1,0),(0,-1)), h):(lambda np: n[p].append(np) if np in h else 0)(tuple(map(add,m,p)))
    def pr(nx):return(lambda l:(h[l[0]], h.pop(l[0]))[0] + pr(l[0]) if l else '')([x for x in n[nx] if x in h])
    return(lambda y: h[y]+ pr(y))(next(x for x in n if len(n[x])==1))

— topkara
সূত্র

1

জাভা 7, 927 924 923 বাইট

import java.util.*;int l,k;char[][]z;Set p=new HashSet();String c(String[]a){int x=0,y=0,n,t,u,v,w=t=u=v=-1;l=a.length;k=a[0].length();z=new char[l][k];for(String s:a){for(char c:s.toCharArray())z[x][y++]=c;}x++;y=0;}for(x=0;x<l;x++)for(y=0;y<k;y++){n=0;if(z[x][y]>32){if(x<1|(x>0&&z[x-1][y]<33))n++;if(y<1|(y>0&&z[x][y-1]<33))n++;if(x>l-2|(x<l-1&&z[x+1][y]<33))n++;if(y>k-2|(y<k-1&&z[x][y+1]<33))n++;}if(n>2&t<0){t=x;u=y;}if(n>2&t>v){v=x;w=y;}}if(v+w>t+u){p(t,u);return n(""+z[t][u],t,u);}p(v,w);return n(""+z[v][w],v,w);}String n(String r,int x,int y){int a,b;if(x>0&&z[a=x-1][b=y]>32&q(a,b)){p(a,b);return n(r+z[a][b],a,b);}if(y>0&&z[a=x][b=y-1]>32&q(a,b)){p(a,b);return n(r+z[a][b],a,b);}if(x<l-1&&z[a=x+1][b=y]>32&q(a,b)){p(a,b);return n(r+z[a][b],a,b);}if(y<k-1&&z[a=x][b=y+1]>32&q(a,b)){p(a,b);return n(r+z[a][b],a,b);}return r;}boolean q(int x,int y){return!p.contains(x+","+y);}void p(int x,int y){p.add(x+","+y);}

ঠিক আছে, এটি কিছুটা সময় নিয়েছে .. কিছু প্রোগ্রামিং ভাষায় আপনার অ্যারে x এবং y 2D-অ্যারের সীমানার বাইরে থাকলে কিছু যায় আসে না, তবে জাভা দিয়ে এটি ছুঁড়ে ফেলা হয় ArrayIndexOutOfBoundsExceptions, তাই সবকিছু পরীক্ষা করে দেখতে হবে ..

আমি প্রথমে প্রারম্ভিক অবস্থানটি নির্ধারণ করি এবং তারপরে সেখান থেকে স্ট্রিং তৈরি করতে পুনরাবৃত্ত পদ্ধতিটি ব্যবহার করি। তদতিরিক্ত, আমি ইতিমধ্যে যে সমন্বয়গুলির মুখোমুখি হয়েছি সেগুলি নজর রাখার জন্য আমি একটি তালিকা ব্যবহার করি, সুতরাং এটি পিছনে পিছনে পিছনে পিছনে যাবে না (ফলস্বরূপ স্ট্যাকওভারফ্লো এক্সেক্সেশন)।

এটি সম্ভবত আমি এ পর্যন্ত পোস্ট করা দীর্ঘতম উত্তর, তবে যদিও কিছু অংশ গল্ফ করা যেতে পারে তবে আমি মনে করি না যে এই চ্যালেঞ্জটি জাভাতে এত কম হতে পারে। জাভা কেবল গ্রিডে পাথ অনুসরণ করার জন্য উপযুক্ত নয় .. তবে এটি খুঁজে বের করা মজাদার চ্যালেঞ্জ ছিল। :)

অবহেলিত ও পরীক্ষার কেস:

এখানে চেষ্টা করুন।

import java.util.*;
class M{
  static int l,
             k;
  static char[][] z;
  static Set p = new HashSet();

  static String c(String[] a){
    int x=0,
        y=0,
        n,
        t,
        u,
        v,
        w = t = u = v = -1;
    l = a.length;
    k = a[0].length();
    z = new char[l][k];
    for(String s:a){
      for(char c:s.toCharArray()){
        z[x][y++] = c;
      }
      x++;
      y = 0;
    }
    for(x=0; x<l; x++){
      for(y=0; y<k; y++){
        n = 0;
        if(z[x][y] > 32){ // [x,y] is not a space
          if(x < 1 | (x > 0 && z[x-1][y] < 33)){
            n++;
          }
          if(y < 1 | (y > 0 && z[x][y-1] < 33)){
            n++;
          }
          if(x > l-2 | (x < l-1 && z[x+1][y] < 33)){
            n++;
          }
          if(y > k-2 | (y < k-1 && z[x][y+1] < 33)){
            n++;
          }
        }
        if(n > 2 & t < 0){
          t = x;
          u = y;
        }
        if(n > 2 & t > v){
          v = x;
          w = y;
        }
      }
    }
    if(v+w > t+u){
      p(t, u);
      return n(""+z[t][u], t, u);
    }
    p(v, w);
    return n(""+z[v][w], v, w);
  }

  static String n(String r, int x, int y){
    int a,b;
    if(x > 0 && z[a=x-1][b=y] > 32 & q(a,b)){
      p(a, b);
      return n(r+z[a][b], a, b);
    }
    if(y > 0 && z[a=x][b=y-1] > 32 & q(a,b)){
      p(a, b);
      return n(r+z[a][b], a, b);
    }
    if(x < l-1 && z[a=x+1][b=y] > 32 & q(a,b)){
      p(a, b);
      return n(r+z[a][b], a, b);
    }
    if(y < k-1 && z[a=x][b=y+1] > 32 & q(a, b)){
      p(a, b);
      return n(r+z[a][b], a, b);
    }
    return r;
  }

  static boolean q(int x, int y){
    return !p.contains(x+","+y);
  }

  static void p(int x, int y){
    p.add(x+","+y);
  }

  public static void main(String[] a){
    System.out.println(c(new String[]{ "Hel         ",
      "  l      rin",
      "  o,IAmASt g",
      "           S",
      "       !ekan" }));
    p = new HashSet();
    System.out.println(c(new String[]{ "Python" }));
    p = new HashSet();
    System.out.println(c(new String[]{ "P  ngPu  Code ",
      "r  i  z  d  G",
      "o  m  z  n  o",
      "gram  lesA  lf" }));
    p = new HashSet();
    System.out.println(c(new String[]{ "   ~ zyx tsr XWVUTSR",
      "   }|{ wvu q Y     Q",
      "!          p Z `ab P",
      "\"#$ 6789:; o [ _ c O",
      "  % 5    < n \\]^ d N",
      "('& 432  = m     e M",
      ")     1  > lkjihgf L",
      "*+,-./0  ?         K",
      "         @ABCDEFGHIJ" }));
    p = new HashSet();
    System.out.println(c(new String[]{ "  tSyrep    ",
      "  r    p   ",
      "  in Sli   ",
      "   g    Sile",
      "   Snakes  n",
      "Ser      ylt",
      "a eh   ilS ",
      "fe w   t   ",
      "   emo h   ",
      "     Sre    " }));
  }
}

আউটপুট:

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

— কেভিন ক্রুইজসেন
সূত্র

924 বাইট, যীশু খ্রিস্ট ... lol

— শন ওয়াইল্ড

পুনঃটুইট আমি কেবল চ্যালেঞ্জটি করেছি, কোড গল্ফ করেছে এবং তারপরে বাইট-কাউন্টের দিকে তাকিয়েছি। প্রকৃতপক্ষে প্রত্যাশার চেয়ে অনেক বেশি ছিল, তবে আহ্ ভাল, কমপক্ষে এটি 1 কে এর নীচে রয়েছে ... আপনি যদি উন্নতির জন্য কিছু দেখেন তবে আমাকে জানান, এবং যদি আপনার কাছে (প্রচুর) বিকল্প বয়সের সাথে কিছু কম বাইট থাকে তবে আলাদা মনে করতে পারেন পোস্ট; আমি এটি দেখতে আগ্রহী। পিএস: এখন 923 বাইট এক্সডি

— কেভিন ক্রুইজসেন

Everythig পরীক্ষা করার দরকার নেই , কেবল আপনার স্ট্রিংয়ে কিছু প্যাডিং যুক্ত করুন। সম্ভবত একটি একক মাল্টলাইন স্ট্রিং ব্যবহার করা আরও সহজ করে তোলে। জাভাস্ক্রিপ্ট থেকে পোর্ট করা আমার সি # উত্তরটি দেখুন

— edc65

1

পিএইচপি, 199 184 182 বাইট

এখনও কিছুটা গল্ফ করার সম্ভাবনা থাকতে পারে

for($w=strpos($i=$argv[1],"
");;)for($y=++$n;$y--;)if($i[$p=$y*$w+$n-1]>" ")break 2;for($p-=$d=$w++;$d&&print$i[$p+=$e=$d];)foreach([-$w,-1,1,$w,0]as$d)if($d+$e&&" "<$i[$d+$p])break;

কমান্ড লাইন থেকে মাল্টলাইন স্ট্রিং হিসাবে ইনপুট নেয়, লিনাক্স স্টাইলের লাইনব্রেকগুলি প্রত্যাশা করে।
চালান php -r '<code>' '<string>'; রক্ষা লাইন ব্রেক।

ভাঙ্গন

for(
    // find width
    $w=strpos($i=$argv[1],"\n")
    ;
    // find first character: initialize $p(osition)
    ;
)
    for($y=++$n             // increase distance
        ;$y--;)             // loop $y from (old)$n to 0
        if(" "<$i[$p=$y*$w+$n   // if character at $y*($width+1)+$x(=$d-$y) is no space
            -1                  // (adjust for the premature increment)
        ])
            break 2;                    // break loops

for(
    $p-=            // b) reverse the increment that follows in the pre-condition
    $d=             // a) initialize $d to anything!=0 to enable the first iteration
    $w++;           // c) increase $w for easier directions
    $d              // loop while direction is not 0 (cursor has moved)
    &&
    print$i[$p+=$e=$d]              // remember direction, move cursor, print character
    ;
)
    foreach([-$w,-1,1,$w,0]as$d)// loop through directions
        if($d+$e                    // if not opposite previous direction
            &&" "<$i[$d+$p]         // and character in that direction is not space
        )break;                     // break this loop

— তিতাস
সূত্র

1

সি #, 310

(সম্পাদনা করুন: বাগ ফিক্স)

মাল্টিলাইন স্ট্রিং প্যারামিটার সহ একটি ফাংশন, একটি স্ট্রিং ফিরে।

usingবাইট গণনায় অনুরোধ সহ ।

এটি আমার জাভাস্ক্রিপ্ট উত্তরের একটি পোর্টিং।

using System.Linq;
string f(string s){int o=-~s.IndexOf('\n'),m=99;var r=new string(' ',o);(s=r+s+r).Select((c,i)=>{int n=2,e=0,p,w=i%o+i/o;if(c>' '&w<m&&new[]{-1,1,o,-o}.All(d=>(s[i+d]>' '?(e=d)*--n:n)>0))for(m=w,r=""+c+s[p=i+e];new[]{e,o/e,-o/e}.Any(d=>s[p+(e=d)]>' ');)r+=s[p+=e];return i;}).Max();return r;}

টেস্ট ideone উপর

স্থান সহ

    string f(string s)
    {
        int o = -~s.IndexOf('\n');
        var r = new string(' ', o);
        var m = 99;
        (s = r + s + r).Select((c, i) =>
        {
            int n = 2, e = 0, p, w = i % o + i / o;
            if (c > ' ' & w < m & new[] { -1, 1, o, -o }.All(d => (s[i + d] > ' ' ? (e = d) * --n : n) > 0))
                for (m = w, r = "" + c + s[p = i + e]; 
                     new[] { e, o / e, -o / e }.Any(d => s[p + (e = d)] > ' '); 
                     ) 
                   r += s[p += e];
            return i;
        }
        ).Max();
        return r;
    }

— edc65
সূত্র

1

পাইথন 2, 251 বাইট

w=s.find('\n')+1;q=' ';p=q*w+'\n';s=list(p+s+p);d=-w,1,w,-1
def r(x):c=s[x];s[x]=q;v=[c+r(x+o)for o in d if s[x+o]>q];return v[0]if v else c
e=[x for x in range(len(s))if s[x]>q and sum([s[x+o]>q for o in d])<2]
print r(e[e[0]/w+e[0]%w>e[1]/w+e[1]%w])

অথবা, আপনি যদি নিজের টেস্টকেসগুলিতে শীর্ষস্থানীয় নিউলাইনগুলি চান, 257 বাইট:

w=s.find('\n',1);q=' ';p=q*-~w+'\n';s=list(p+s[1:]+p);d=-w,1,w,-1
def r(x):c=s[x];s[x]=q;v=[c+r(x+o)for o in d if s[x+o]>q];return v[0]if v else c
e=[x for x in range(len(s))if s[x]>q and sum([s[x+o]>q for o in d])<2]
print r(e[e[0]/w+e[0]%w>e[1]/w+e[1]%w])

সমস্ত টেস্টকেস পাস করে।

s="""
  tSyrep    
  r    p    
  in Sli    
   g    Sile
   Snakes  n
Ser      ylt
a eh   ilS  
fe w   t    
   emo h    
     Sre    
"""

ফলাফল স্বরূপ:

SlipperyStringSnakesSilentlySlitherSomewhereSafe

— সিইস টিমারম্যান
সূত্র

3

আমার মনে হয় আপনি প্রতিস্থাপন করতে পারেন b.append(...)সঙ্গে b+=[...]এবং def n(x,y):return ...সঙ্গেn=lambda x,y:...

— acrolith

1

এর জন্য একটি ভেরিয়েবল তৈরি করুন ' '।

— পাচোলিক

1

এবং ~-xপরিবর্তে ব্যবহার করুন x-1, আপনাকে প্রথম বন্ধনী ব্যবহার করতে হবে না।

— পাচোলিক

0

জাপট `-P` , 106 বাইট

K=U·ÌÊÄ ç iU ¬mx T=[-KJ1K]
ËÊ*Tm+E è@gX
[]V£YÃf@gXÃrQ@WpQ Tm+Q kW fZ Ì}V£[XYuK YzK]ÃkÈv ÉÃñx v rÈ+Y*K
W£gX

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

এটা ... ওম ... একটি ঘৃণা

আনপ্যাকড এবং কীভাবে এটি কাজ করে

K=UqR gJ l +1 ç iU q mx
  UqR gJ l +1            Split the input by newline, take last item's length +1
K=                       Assign to K
              ç iU       Generate a string of K spaces, and append to U
                   q mx  Split into chars, and trim whitespaces on each item
                         Implicit assign to U

T=[-KJ1K]  Assign an array [-K, -1, 1, K] to T (this represents 4-way movement)
           I could use implicit assignment, but then 4-argument function below is broken

UmDEF{Dl *Tm+E èXYZ{UgX
UmDEF{                   Map over the list of one- or zero-length strings...
      Dl *                 If the length is zero, return zero
          Tm+E             Add the index to each element of T
               èXYZ{UgX    Count truthy elements at these indices
                         The result is an array of 0(space/newline), 1(start/end), or 2(body)
                         Implicit assign to V

[]  Implicit assign to W

VmXYZ{Y} fXYZ{UgX} rQXYZ{WpQ Tm+Q kW fZ gJ }
VmXYZ{Y}                                      Map V into indices
         fXYZ{UgX}                            Filter the indices by truthiness of U's element
                   rQXYZ{                     Reduce on the indices... (Q=last item, Z=array)
                         WpQ                    Push Q to W
                             Tm+Q               Take 4-way movements from Q
                                  kW fZ gJ }    Exclude visited ones, take last one in Z

VmXYZ{[XYuK YzK]} kXYZ{Xv -1} ñx v rXYZ{X+Y*K  Starting point of reduce
VmXYZ{[XYuK YzK]}                              Convert elements of V to [elem, col, row]
                  kXYZ{Xv -1}                  Take the ones where elem(popped)=1
                              ñx v             Sort by row+col and take first one
                                   rXYZ{X+Y*K  Convert [row,col] back to the index

WmXYZ{UgX  Map indices back to chars

-P  Join with empty string

এক উল্লেখযোগ্য বিন্দু যে আমি জাতীয় মধ্যে নিয়োগ এবং কমা অপারেটার মধ্যে অপারেটর প্রাধান্য ব্যবহৃত অর্ডার কিছু লাইন প্যাক এবং শর্টকাট রাখতে হয় @( XYZ{) ব্যবহারযোগ্য।

— Bubbler
সূত্র

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

তোমার কাজ

বিশেষ উল্লেখ

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

এপিএল, 55 বাইট

জাভাস্ক্রিপ্ট (ES6) + স্নেকএক্স , 176 বাইট

এমএটিএল , 80 বাইট

ব্যাখ্যা

সি 198 190 179 180 181 বাইট

সি, 272 বাইট

পাইথন (2 এবং 3), 640 624 604 583 575 561 546 538 বাইট

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

লুয়া, 562 535 529 513 507 504 466 458 বাইট

Ungolfed

এটা পরীক্ষা করো!

লুয়া, 267 বাইট

পাইথন 3, 245 243 241 236 বাইট

পাইথন, 537

জাভা 7, 927 924 923 বাইট

পিএইচপি, 199 184 182 বাইট

সি #, 310

পাইথন 2, 251 বাইট

জাপট -P , 106 বাইট

আনপ্যাকড এবং কীভাবে এটি কাজ করে

জাপট `-P` , 106 বাইট