মোচড় শব্দ!


34

মোচড় শব্দ!

একটি স্ট্রিং এবং ধনাত্মক পূর্ণসংখ্যা দেওয়া হয়েছে। আপনার অবশ্যই স্ট্রিংটি পিছনে পিছনে মুচতে হবে।

উদাহরণ ইনপুট / আউটপুট

ইনপুট

Programming Puzzles & Code Golf
4

আউটপুট

Prog
mmar
ing 
zzuP
les 
oC &
de G
 flo

ইনপুট

ইনপুটটি STDIN বা ফাংশন আর্গুমেন্টের মাধ্যমে নেওয়া যেতে পারে। ইনপুটটিতে একটি স্ট্রিং এবং ধনাত্মক পূর্ণসংখ্যা থাকবে, এন । পূর্ণসংখ্যা প্রতিটি বাঁকানো লাইনের দৈর্ঘ্য নির্ধারণ করবে।

স্ট্রিং পিছনে এবং পিছনে পাকানো হয়। HELLO, WORLD!এবং 5 এর একটি ইনপুট দেখতে পাবেন:

ওহে বিশ্ব!

আউটপুট

আউটপুটটি মোচড়ানো পাঠ্য হবে। এটি কোনও পেছনের সাদা জায়গা নাও থাকতে পারে। যদি ইনপুট স্ট্রিংয়ের দৈর্ঘ্যটি লাইন দৈর্ঘ্য হিসাবে বিভাজ্য না হয়, লাইনটি পূরণ না হওয়া পর্যন্ত একটি স্থান যুক্ত করুন:

এর একটি উদাহরণ:

ইনপুট

Hello, World!
5

আউটপুট (পুরো শেষে সাদা স্থানটি দ্রষ্টব্য)

Hello
roW ,
ld!  

সম্পর্কিত:
কোডআরভিউতে

এটি কোনও পেছনের সাদা জায়গা নাও থাকতে পারে। একটি ক্রিয়া দূরে গল্ফ?
অ্যাডম

আমরা কি লাইনের একটি তালিকা ফিরিয়ে দিতে পারি?
অ্যাডম

উত্তর:


10

পাইথ, 19 15

VPc+z*dQQ_W~!ZN

স্ট্রিংটি প্রাক-প্যাড করে, তারপরে একে একে একে একে একে একে একে একে উল্টে দেয়। প্যাডিং বাক্সের আকারের সমান, তবে ইনপুট কেটে নেওয়ার পরে শেষ লাইনটি বাতিল করা হয়।

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


6

সিজেম, 19 বাইট

q~1$S*+/W<{(N@Wf%}h

ইনপুট উদাহরণ:

5 "Hello, World!"

ব্যাখ্যা

q~         e# Input n and the string.
1$S*+      e# Append n spaces to the string.
/W<        e# Split by each n characters, and remove the last chunk.
{          e# While the array of chunks isn't empty:
    (N     e# Extract the first chunk and push a newline.
    @Wf%   e# Reverse every chunk left in the array.
}h

5

স্নোম্যান 1.0.1 , 91 বাইট

{vg10vg|sB*#.'aGal'NdE'aaAaL|al!*+#5nS" "'aR'!#aCwR|.aC2aG:0aa|sP"
"sP'NdE|1aA.aNsP"
"sP;aE

বা সমস্ত একটি লাইনে (নান্দনিকতার জন্য, বা আরও সুনির্দিষ্টভাবে, অ্যান্টি-নান্দনিকতার জন্য), 2 বাইট ব্যয়ে:

{vg10vg|sB*#.'aGal'NdE'aaAaL|al!*+#5nS" "'aR'!#aCwR|.aC2aG:0aa|sP10wRsP'NdE|1aA.aNsP10wRsP;aE

এটি স্নোম্যানের পক্ষে খুব ছোট। (এটি সম্ভবত এটি সবচেয়ে সংক্ষিপ্ততম হতে পারে, যদিও আমি এটি বেশ দীর্ঘ সময় ধরে গল্ফ করার কাজ করেছি))

এটিতে একটি সতর্কতা রয়েছে: শেষ লাইনটি বিপরীত না হলে এটি 50% সময় ত্রুটি সহ প্রস্থান করবে (তবে এখনও সঠিক ফলাফল দেয়) produce (এটি কারণ আমি agদুটি গ্রুপে অ্যারের উপাদানগুলি গোষ্ঠী হিসাবে ব্যবহার করি যাতে আমি প্রত্যেকে একে অপরকে বিপরীত করতে পারি, তবে শেষ উপাদানটিতে উভয় প্রত্যাশিত উপাদান রয়েছে কিনা তা আমি যাচাই করি না, তাই এটি অস্তিত্বের উপাদানটি অ্যাক্সেস করার চেষ্টা করব যদি বিজোড় সংখ্যা রয়েছে lines

অবরুদ্ধ / ব্যাখ্যা:

{vg10vg|sB*#      // get input, convert second string to number and store
.'aG              // split string into groups of n chars
al'NdE'aaAaL      // take out the last element of the array
|al!*+#5nS" "'aR  // subtract its length from 5, repeat that many spaces
'!#aCwR|.aC       // concat spaces to last el. and that back to the array
2aG               // split in groups of 2, so we can reverse every other string
// for each sub-group in the array of groups...
:
    0aa|sP10wRsP         // print the first element as is
    'NdE|1aA.aNsP10wRsP  // print the second element, reversed
;aE

5

পাইথন 2, 60

s,n=input()
d=1
while s:print(s+n*' ')[:n][::d];s=s[n:];d=-d

nএর মধ্য থেকে একবারে অক্ষর নেয় s, সেগুলি মুদ্রণ করে এমন দিক দিয়ে প্রিন্ট করে যা dমাঝখানে 1এবং পরিবর্তিত হয় -1। শেষ লাইনে ব্যবধানের জন্য, কাটা হওয়ার আগে শেষে ফাঁকা স্থানগুলি sদিয়ে প্যাড করা হয় n, যা কেবলমাত্র তখনই প্রভাবিত করে যখন এটির চেয়ে কম nঅক্ষর থাকবে।

পুনরাবৃত্তির সমাধানটি একটি চরটি সংরক্ষণ করবে (59) ব্যতীত এটি একটি অনুবর্তনযোগ্য নতুন লাইন ছেড়ে যায়, যা অনুমোদিত নয়।

f=lambda s,n,d=1:s and(s+n*' ')[:n][::d]+"\n"+f(s[n:],n,-d) 

4

হাস্কেল , 83 75 বাইট

(id!)
(f![])_=[]
(f!l)n=f(take n$l++cycle" ")++'\n':((f.reverse)!drop n l)n

সহজ chunksOfটেক অ্যান্ড ড্রপ সহ বাস্তবায়ন, আমরা যেতে যেতে আউটপুটে বিপরীত সংখ্যক বা বিজোড় সংখ্যক প্রয়োগ করে।

পাঁচটি বাইটের জন্য @ বিএমও এবং তিন বাইটের জন্য @ janrjanJohansen কে ধন্যবাদ!

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


2
cycle5 টি বাইট সেভ ব্যবহার করে অনলাইনে চেষ্টা করুন!
5

অপসারণ gএবং অদলবদল করে আরও তিনটি বাইট সংরক্ষণ করুন nএবং l: অনলাইনে চেষ্টা করে দেখুন!
janর্জন জোহেনসেন

3

আটকে , 42 41 40 38 বাইট

এটি একটি খুব সামান্য দীর্ঘ, সম্ভবত আরও গল্ফ চেষ্টা করবে!

tg;_lu_@%u;-_0G<*' *+0GKE"];2%;Y_Y?p":

ইনপুট মত হওয়া উচিত "string"|n

ব্যাখ্যা:

tg                 # Take input, place each item on stack, save the int to variable stack                                        
;_l                # Swap the top two items, duplicate the string and obtain length
u_@%               # Rotate to the left, duplicate, rotate right and take mod
u;-                # Rotate left, swap the top two and subtract from each other
_0G<*              # duplicate this value, check if less than stored int and multiply
' *+               # Push space onto stack n times, append to starting string
0GKE               # Split this string into segments, and enumerate
"];2%;Y_Y?p":      # For each segment, determine if should be reversed, and print

2

হাস্কেল, 108 বাইট

(#)=splitAt
s!n=let(a,t)=n#s;(b,u)=n#t in a:reverse b:(u!n)
s%n=unlines$takeWhile(any(>' '))$(s++cycle" ")!n

এটাই লম্বা, জীজ। এখানে এটি কার্যকর হয়:

*Main> putStrLn $ "Programming Puzzles & Code Golf" % 4
Prog
mmar
ing
zzuP
les
oC &
de G
 flo

বাঁধাই কীভাবে letকাজ করে?
xnor

এটি একটি দ্বিমুখী letবিবৃতি একটি সেমিকোলন দ্বারা পৃথক - সাধারণত আপনি নিউলাইন এবং ইন্ডেন্টেশন ব্যবহার করতেন তবে হাস্কেল আপনাকে লেখার অনুমতিও দেয় let a=b; c=d in expr
লিন

আমি জানতাম না যে এটির অনুমতি দেওয়া হয়েছে, putStrLn কে প্রোগ্রাম থেকে বের করে!
21if15

1
@ লিফওয়িলার্টস, সম্প্রতি, এখানে চ্যালেঞ্জগুলি আপনাকে ফাংশন আর্গুমেন্ট / ফলাফল বা স্টিডিন / স্টাডাউটের মাধ্যমে আই / ও সঞ্চালনের অনুমতি দেয় - এখানে, আমার সমাধানটি (%) :: String -> String -> Stringপরিবর্তে একটি ফাংশন IO ()
লিন

2

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

শেষ লাইনটি সঠিক হওয়ার জন্য খালি জায়গাগুলির সাথে প্যাডিং যুক্ত করতে হয়েছিল।

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

I,c=input()
I+=(c-len(I)%c)*" "
L=[]
i=0
while I:s=I[:c];L+=[[s,s[::-1]][i%2]];i+=1;I=I[c:]
print"\n".join(L)

2

লুয়া, 91 88 88 84 83 82 বাইট

পুরনো সংস্করণ:

a=arg for i=1,#a[1],a[2]do s=a[1]:sub(i,i+a[2]-1)print(d and s:reverse()or s)d=not d end

নতুন সংস্করণ:

arg[1]:gsub((".?"):rep(arg[2]),function(s)print(d and s:reverse()or s)d=not d end)


2

পার্ল, 87 বাইট

sub f{$_=@_[0].$"x(@_[1]-1);$a.=(($i++&1?reverse$1:$1).$/)while/(.{@_[1]})/g;chop$a;$a}

পুরানো সংস্করণ (একটি পেছনের নতুন লাইন প্রিন্ট করে):

sub f{$_=@_[0].$"x(@_[1]-1);print(($i++&1?reverse$1:$1).$/)while/(.{@_[1]})/g}

স্ট্রিং কোনও ফাংশন আর্গুমেন্ট হিসাবে পাস করা হয় না কোনও পেছনের নতুন লাইন। এভাবে কল করুন:

$_=<>;chomp;print f($_,5);

2

মাম্পস, 86 বাইট

R I,S,! S P=$L(I),$P(I," ",P)=P F Q=1:S:P S F=$E(I,Q,Q+S-1),P='P W $S('P:F,1:$RE(F)),!

যদিও আপনি প্রথমটি সরিয়ে ফেললে এটি 2 বাইট সংক্ষিপ্ত হতে পারে '!' আর স্টেটমেন্টের অক্ষর (এসটিডিএন থেকে পড়ুন); যা ইনপুট এবং আউটপুটটির মধ্যে একটি ক্যারেজ রিটার্ন যুক্ত করে। যদি তা না থাকে তবে আউটপুট প্রযুক্তিগতভাবে সঠিক, তবে প্রথম লাইনটি ইনপুট স্ট্রিংয়ে সংযুক্ত হবে। [[আমি যে স্ট্যান্ডার্ড ম্যাম্পস টার্মিনালটি ব্যবহার করি তার কোনও স্থানীয় প্রতিধ্বনি নেই। ]]   এটি বসার সাথে সাথে এখানে পরীক্ষাটি করা হচ্ছে:

R I,S,! S P=$L(I),$P(I," ",P)=P F Q=1:S:P S F=$E(I,Q,Q+S-1),P='P W $S('P:F,1:$RE(F)),!
ABCDEFGHIJKLMNOPQRSTUVWXYZ1236
ABCDEF
LKJIHG
MNOPQR
XWVUTS
YZ123 

আরও মনে রাখবেন, ইনপুটটির শেষে '123' এবং '6' এর মধ্যে একটি ক্যারেজ রিটার্ন / প্রবেশের কী রয়েছে actually [[স্থানীয় প্রতিধ্বনি আবার। ]]

যদি কারও আগ্রহী আমি কোড সহ কী চলছে তা বর্ণনা করতে পারি; তবে আমি বুঝতে পারি যে সেখানে একগাদা ম্যাম্পস উত্সাহী নেই ... :-)


2

পাওয়ারশেল, ১০২ বাইট

param($s,$i)$l=$s.Length;$s+' '*($i%$l)-split"(.{$i})"|?{$_}|%{$r=-not$r;@($_,($_[$l..0]-join''))[$r]}

নিম্নলিখিত হিসাবে অনুরোধ করা হয়েছে (যদি ফাইলটিতে সংরক্ষণ করা হয় CodeGolf55051.ps1)

.\CodeGolf55051.ps1 -s '1234567890' -i 4

পূর্ববর্তী প্রচেষ্টা

(দীর্ঘ বা অবৈধ)

পাওয়ারশেল, 110 বাইট

param($s,$i)$l=$s.Length;$s+' '*(($i-$l%$i)%$i)-split"(.{$i})"|?{$_}|%{$r=-not$r;@($_,($_[$l..0]-join''))[$r]}

পাওয়ারশেল, 111 বাইট

param($s,$i)$s+' '*(($i-$s.Length%$i)%$i)-split"(.{$i})"|?{$_}|%{$r=-not$r;@($_,($_[$_.length..0]-join''))[$r]}

ব্যাখ্যা

param($s,$i)                         #Take input text (s) and column width (i)
$s                                   #take the user entered string
+ ' ' * (($i - $s.Length % $i) % $i) #add the least number of spaces required to make its length divisible by i
-split"(.{$i})"                      #break it into chunks of i characters in length
| ?{$_}                              #skip any blank lines created in the process
| %{                                 #for each line
    $r = -not $r;                    #    toggle a boolean value
    @(                               #    define an array
        $_                           #    index 0 = the string going forwards
        ,($_[$_.length..0] -join '') #    index 1 = the string reversed (by taking each character from the last to the first, then joining them)
    )[$r]                            #    if our boolean value is false take the forward string (index 0), if true take the backwards one (index 1)
}                                    #next

পাওয়ারশেল, 180 বাইট

param($s,$i)$x="`${0}|{1}|`${2}";$w=$x;1..$i|%{$w=$w-f$_,$x,($i+$_)};$w=$w-replace'\||\${.*}';$r=$w-replace'\$\d+','(.)?';$s+' '*($i-$s.Length%$i)-replace$r,$w-split"(.{$i})"|?{$_}

পাওয়ারশেল, 196 বাইট

param($s,$i)$x="{0}|{1}|{2}";$w=$x;1..$i|%{$w=$w-f$_,$x,($i+$_)};$w=$w-replace'(\d+)','$$$1'-replace'\||{.*}';$r=$w-replace'\$\d+','(.)?';$s+' '*($i-$s.Length%$i)-replace$r,$w-split"(.{$i})"|?{$_}

ব্যাখ্যা

param ($s, $i)                      #Take input text (s) and column width (i)

$x = "{0}|{1}|{2}"                  #Define string format which takes 3 entries and pipe delimits them

$w = $x                             #initialise our replacement regex with this format
1..$i | %{                          #for 1 to the specified column width
    $w = $w -f $_, $x, ($i + $_)    #update the regex 1|{...}|5, 1|2|{...}|6|5, etc
}                                   #resulting in w = 1|2|3|4|{...}|8|7|6|5
$w = $w -replace '(\d+)', '$$$1'    #now prefix the numbers with a dollar (so they're regex replacement variables)
        -replace '\||{.*}'          #and remove the delimiters and superfluous `{...}` left from our middle insertion routine

$r = $w -replace '\$\d+', '(.)?'    #then create the match pattern by replacing the variables with optional single character captures

$s                                  #now take the user entered string
    + ' ' * ($i - $s.Length % $i)   #add the least number of spaces required to make its length divisible by i
    -replace $r, $w                 #perform a replacement using the regex match and replace patterns created above
    -split "(.{$i})"                #then split the string into blocks of length i
    | ?{$_}                         #removing any blank lines created in the process

( {...}উপরের মন্তব্যগুলিতে আসলে {0}|{1}|{2}; আমি {...}উন্নত পাঠযোগ্যতার জন্য রেখেছি)

পাওয়ারশেল, 120 বাইট (অবৈধ)

param($s,$i)$s + ' ' * ($i-$s.Length%$i) -replace '(.{4})?(.)(.)(.)(.)',"`$1`n`$5`$4`$3`$2`n" -split "`n" | ?{$_ -ne ""}

1
আর একটি পাওয়ারশেল স্লিংগার দেখে আশ্চর্য! একটি সহজ শুরু যে স্থান কাছাকাছি Dang পরিত্রাণ পেতে হয় param($s,$i)$s+' '*($i-$s.Length%$i)-replace'(.{4})?(.)(.)(.)(.)',"`$1`n`$5`$4`$3`$2`n"-split"`n"|?{$_-ne""}যা আপনি নিচে থেকে 108. পাবেন
AdmBorkBork

ধন্যবাদ @ টিমমিডি; আমার স্ক্রিপ্টের সাথে সবেমাত্র কয়েকটি মৌলিক ত্রুটিগুলি চিহ্নিত করেছে (এটি প্রয়োজনীয়তাগুলি পূরণ করে না / কেবল 4 এর জন্য কাজ করা কঠিন ... এখনই ঠিক করা)
জনএলবেভান

পরীক্ষার সময়, সঠিক দিক থেকে শুরু করার জন্য প্রবাহকে সামনে এবং পিছনে পেতে, আমাকে চূড়ান্ত [$r]সূচকটি অদলবদল করা দরকার [-not$r]... অন্যথায় প্রথম লাইন প্রদত্ত উদাহরণগুলির চেয়ে বিপরীত (অর্থাত্ ডান থেকে বাম) পড়বে। অন্যথায়, সত্যিই চটজল কার্যকর!
অ্যাডমবার্কবার্ক

1
এছাড়াও, যেহেতু আমাদের দেওয়া হয়েছে যে ইনপুট নম্বরটি nইতিবাচক, এবং আমাদের গ্যারান্টি দেওয়া হয়েছে যে স্ট্রিংয়ের দৈর্ঘ্য অ-নেতিবাচক (সংজ্ঞা অনুসারে), এর অর্থ এটি চারটি অক্ষর সংরক্ষণ (($i-$l%$i)%i)করার সমতুল্য ($i-$l%$i)
অ্যাডমবর্কবার্ক

1
ওফস, আমি কোনওভাবে এটি টাইপ করেছি, আমি মূলত বলতে চাইছিলাম (-$l)%$i। কোথা থেকে এসেছে জানি না। আকর্ষণীয়, তবে এটি সমতুল্য নয় যদিও এটি হওয়া উচিত। এটি স্পষ্টতই পাওয়ারশেল (অন্যান্য ভাষাগুলির মধ্যে) মডুলো ফাংশনটি কীভাবে বাস্তবায়িত করে তার একটি স্পর্শ, যা আমি (গণিতের মেজর হিসাবে) বা ওল্ফ্রাম-আলফা প্রত্যাশার চেয়ে আলাদা। স্পষ্টতই, আপনাকে আরও দীর্ঘ সংস্করণে আটকাতে হবে। রেফারেন্স প্রুফ ->((y-x%y)%y) ==> ((y%y)-(x%y%y))%y ==> ((0)-(x%y))%y ==> (-x%y)%y ==> (-x)%y
অ্যাডমবর্কবার্ক

2

ক্লোজার, 83 বাইট, 87 বাইট , 79 বাইট

(fn[n s](map #(apply str(% %2))(cycle[#(or %)reverse])(partition n n(repeat\ )s))))

নীচে মন্তব্য করার পরে বিভিন্ন সংশোধন, আপনাকে ধন্যবাদ অর্জান

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

ক্লজ্যুর প্রায়শই কোড গল্ফিং উত্তরগুলি থেকে দুঃখজনকভাবে অনুপস্থিত বলে মনে হয়। এটি অবশ্যই গল্ফ ভাষাগুলির সাথে বাইট দৈর্ঘ্যের সাথে প্রতিযোগিতা করতে পারে না, তবে আমার মনে হয় মোট অনুপস্থিতি কিছুটা অযৌক্তিক।

ব্যাখ্যা:

  • ইন-ডেটা, দুটি আর্গুমেন্ট একটি সংখ্যা এবং একটি স্ট্রিং
  • স্ট্রিংয়ের উপর ক্লোজার বিল্ট-ইন ফাংশন পার্টিশনটি চালিয়ে শুরু করুন sযেখানে তালিকাটির দৈর্ঘ্য রয়েছে এমন অক্ষরের তালিকাগুলির ক্রম হিসাবে এটি n। শেষ অংশটি n"প্যাড সংগ্রহ" ব্যবহার করে ফিরে এসে স্পেস দিয়ে প্যাড করা হবে(repeat " ") যা স্পেসগুলির অসীম অলস অনুক্রমটি ফিরে আসে
  • আমরা তারপর কল তিনটি যুক্তি সহ মানচিত্রকে :
    • একটি বেনামে ফাংশন (the #(..) )
    • ফাংশনগুলির একটি অসীম বিকল্প আলস্য ক্রম #(or %)যা পরিচয় ফাংশন এবং বিপরীত (যেমন [#(or %) reverse #(or %) reverse ...]) দ্বারা ফিরে আসার মতো কাজ করে চক্র
    • বিভাজন দ্বারা ফিরে তালিকার অবিচ্ছিন্ন ক্রমগুলি ফিরে আসে।
  • অবশেষে বেনামে ফাংশন #(apply ...) :
    • হয় identityবা reverseপর্যায়ক্রমে একটি অংশে কল । এটি (% %2)প্রকাশের মাধ্যমে সম্পন্ন হয় যা বেনামে ফাংশনটির প্রথম যুক্তি হিসাবে প্রেরিত ফাংশনটিকে কল করে [যেমন identityবাreverse ] দ্বিতীয় আর্গুমেন্টটি [অর্থাত্] অজ্ঞাতনামা ফাংশনে কলটির আর্গুমেন্ট হিসাবে।
    • (apply str ...)অক্ষরের তালিকাকে স্ট্রিংয়ে রূপান্তর করতে কল
  • বাইরের ফাংশনটি স্ট্রিংগুলির একটি অলস ক্রমটি প্রদান করে

একটি কৌশল যা আমরা এখানে ব্যবহার করি তা হ'ল ক্লোজার ফাংশনগুলি mapঅনেকগুলি সংগ্রহ হিসাবে একটি স্বেচ্ছাসেবী সংগ্রহকে আর্গ (map f coll1 coll2 coll3 ...)হিসাবে গ্রহণ করে , অর্থাৎ যেখানে ফাংশন চ কেবল সংগ্রহ হিসাবে রয়েছে তত যুক্তি গ্রহণ করতে পারে। এই ক্ষেত্রে আমরা দুটি সংগ্রহ প্রেরণ করি, বিকল্প ফাংশন রেফারেন্সের একটি সংগ্রহ এবং মজাদার স্ট্রিং।


1
এটি দুর্দান্ত তবে এটির শেষে প্রয়োজনীয় সাদা অংশ নেই বলে মনে হচ্ছে ld!
janrjan জোহানসেন

আপনি সবচেয়ে সঠিক। সমস্যাটি সমাধান করা উচিত এমন একটি প্যাড সংগ্রহ যুক্ত করা হয়েছে ... এবং আমার জন্য 8 বাইট খরচ
পড়ছে

গল্ফিংয়ের নিয়মগুলির বিষয়ে আমার একটি প্রশ্ন রয়েছে: আপনি যদি কোনও অন্তর্নির্মিত ফাংশন ব্যবহার করছেন যা আমদানি বা অনুরূপ বিবৃতি প্রয়োজন (ক্লোজারে প্রয়োজন, জাভাতে আমদানি করা ইত্যাদি), সেই বিল্ট-ইনটি আমদানির অংশ হওয়ার দরকার নেই? গল্ফিং সমাধান বাইট গণনা? আমি হ্যাঁ ধরে নিলাম, তবে এটি ধূসর অঞ্চলের মতো একটি বাচ্চা অনুভব করে।
মাতিয়াস বজরল্যান্ড

হ্যাঁ, আমদানি গণনা করা হয়।
janর্জন জোহানসেন

ওহ তবে আপনি যে অন্য নিয়ম ভঙ্গ করছেন তা রয়েছে: আপনি পূর্বনির্ধারিত ভেরিয়েবলগুলিতে ইনপুট নিতে পারবেন না, আপনাকে সমাধানটি পুরো প্রোগ্রাম বা কোনও ফাংশন তৈরি করতে হবে। (উভয়ই ব্যবহার করুন fnবা defnঠিক আছে)) ফ্লিপ সাইডে আপনার ফাংশনটি ফলাফল প্রিন্ট না করে কেবল ফলাফলটি ফেরত দেওয়ার অনুমতি দেয়।
janর্জন জোহানসেন

2

এপিএল (ডায়ালগ ইউনিকোড) , 19 বাইট

{↑⊢∘⌽\↓↑⍵⊆⍨⌈⍺÷⍨⍳≢⍵}

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

টুক ⊢∘⌽\থেকে কৌতুক boustrophedonise চ্যালেঞ্জ ngn এর উজ্জ্বল উত্তর

শীর্ষস্থানীয় নিউলাইনগুলি সহ আমার জমাটি লাইনগুলি ভেঙে গেছে বুঝতে পেরে, আমি আরও দুটি বাইট যুক্ত করেছি। নীচে পুরানো জমা দেওয়া আছে।

এপিএল (ডায়ালগ ইউনিকোড) , 17 বাইট

{↑⊢∘⌽\⍵⊆⍨⌈⍺÷⍨⍳≢⍵}

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


2

পাইথন 3, 110 108 107 103 বাইট

def a(s,n):l=len(s)//n+1;s+=' '*(len(s)-l);print('\n'.join([s[x*n:n*x+n][::(-1)**x]for x in range(l)]))

(অন্যান্য উত্তরের দিকে তাকানো), সহ rjust :95 93 92 90 বাইট

def a(s,n):print('\n'.join([s[x*n:n*x+n][::(-1)**x].rjust(n)for x in range(len(s)//n+1)]))

আপনার ফলাফলের শেষ লাইনটি ভুল wrong এটি এখানে চালান। এটি একটি দুর্দান্ত প্রথম পোস্ট, এবং একবার আপনি ঠিক করেন যে আমি কিছু বাইট বন্ধ করে গল্ফ করার কিছু উপায়ের পরামর্শ দেব, প্রথমটি হচ্ছে আপনি নিজের উত্তর থেকে সমস্ত স্পেস / ট্যাব সরিয়ে ফেলতে পারেন।
mbomb007

হাহাহ, আপনি ঠিক বলেছেন। এটি ঠিক করার জন্য অনেক ব্যয় করতে হবে তবে আমি এটি করছি। ধন্যবাদ
বব্রোববব


এছাড়াও, আপনি আমার উত্তরটি বেশ কিছুক্ষণ আগেই পরাজিত করেছেন: কোড golf.stackexchange.com/a/55082/34718
mbomb007

টিপস পড়া। আবারও ধন্যবাদ
বব্রোববব

1

পিএইচপি, 135 বাইট

প্রদর্শিত হিসাবে দুটি কমান্ড-লাইন আর্গুমেন্ট নেয় $argv

<? foreach($a=str_split($s=$argv[1],$n=$argv[2])as$k=>&$v)$v=$k%2?$v:strrev($v);echo implode("\n",$a).str_repeat(' ',$n-strlen($s)%$n);

1

কফিস্ক্রিপ্ট, 131 বাইট

এটি অনেক দীর্ঘ বলে মনে হচ্ছে।

f=(s,n,r=l=s.length,i=0,z='')->(t=s[i...i+=n].split '';t=t.reverse()if r=!r;z+=t.join('')+(i<l&&'\n'||' '.repeat n-l%n))while i<l;z

1

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

f(s,n)=(L=length(s);L+=L÷n;j=0;for i=1:n:L-n+1 x=rpad(s,L)[i:i+n-1];println(j%2<1?x:reverse(x));j+=1end)

Ungolfed:

function f(s::String, n::Int)
    L = length(s) + length(s) ÷ n
    j = 0
    for i = 1:n:L-n+1
        x = rpad(s, L)[i:i+n-1]
        println(j % 2 == 0 ? x : reverse(x))
        j += 1
    end
end


1

প্রশ্ন, 46

{-1@neg[y]$@[a;(&)(til(#)a:y cut x)mod 2;|:];}

q){-1@neg[y]$@[a;(&)(til(#)a:y cut x)mod 2;|:];}["Programming Puzzles & Code Golf";4]
Prog
mmar
ing
zzuP
les
oC &
de G
 flo

এটি যখন ভুল হয় যখন শেষ লাইনটি সংক্ষিপ্ত হয় এবং বাঁক না দেওয়া হয়, আমি আমার উত্তরে বাগ ফিক্স পোস্ট করতে চেয়েছিলাম তবে আমি মনে করি আপনি পরিবর্তে আপনার আপডেট করতে পারলে এটি আরও ভাল হবে: {-1@[l;(&)(til(#)l:y cut x)mod 2;'[neg[y]$;|:]];}(49 বাইট)। অনুপ্রেরণার জন্য ধন্যবাদ! :)
hjk

1

প্রশ্ন, 64 56 বাইট

{c::neg y;-1(til(#)l){$[x mod 2;c$(|:)y;y]}'l:y cut x;}
  • {}হিসাবে পরিচিত করা উচিত যে একটি ফাংশন {}[x;y]
    • x স্ট্রিং হবে।
    • y ফলাফল লাইন দৈর্ঘ্য হবে।

টেস্ট:

{c::neg y;-1(til(#)l){$[x mod 2;c$(|:)y;y]}'l:y cut x;}["Programming Puzzles & Code Golf";4]
Prog
mmar
ing
zzuP
les
oC &
de G
 flo

সম্পাদনা : @tmartin দ্বারা অন্য কিউ উত্তর দ্বারা অনুপ্রাণিত হিসাবে সংক্ষিপ্ত ফাংশন ব্যবহৃত


1

পাইথন 2, 82 75 বাইট

s,n=input()
k=0
while k<=len(s):print s[k:k+n].ljust(n)[::1-2*(k/n%2)];k+=n

আমি @ উইলেমে মন্তব্য করতে পারিনি তবে আমি তার কোডটি আরও ছোট করেছি।

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


হাই অ্যালেক্সএন, খুব সুন্দর আমি মনে করি যে 'এখানে চেষ্টা করুন' উদাহরণে আপনার শেষ লাইনটি সঠিক নয়। এটা ঠিক ন্যায়সঙ্গত করা উচিত। এছাড়াও আমি 86 টি চর গণনা করি? আপডেটের জন্য আমার এন্ট্রি দেখুন ।
উইলেম

হাই উইলেম, আপনি ঠিক বলেছেন, আমি কোডটি সংশোধন করেছি এবং দেখতে পেয়েছি যে আপনার নিজের মধ্যে একটি ত্রুটি রয়েছে: আদর্শ one.com / এমএমএমআর ডানদিকে থাকা উচিত।
আলেকজান্ডার নিগল

1

পার্ল, 72 বাইট

perl -p0e's/\n(.*)/$"x($1-$-[0]%$1)/e;s/.{$1}/($i++%2?reverse$&:$&)."\n"/ge;chop'

70 বাইট, আরও 2 বাইট জন্য -p0

ডেমো:

$ echo -en 'Hello, World!\n5' | perl -p0e's/\n(.*)/$"x($1-$-[0]%$1)/e;s/.{$1}/($i++%2?reverse$&:$&)."\n"/ge;chop'
Hello
roW ,
ld!  $

নোট করুন যে এসটিডিআইএন থেকে পঠিত ইনপুটটি কোনও নতুন লাইনের সাথে শেষ হতে পারে না (যার জন্য 2 অতিরিক্ত বাইট লাগবে))

ব্যাখ্যা:

perl -p0e'  # Read from STDIN, splitting on null bytes,
            # and print $_ automatically at the end

    s/
        \n(.*)  # Replace everything after first newline,
                # capturing wrap length in $1...
     /
        $"x($1-$-[0]%$1)  # ...with spaces until the total length of $_ is
                          # a multiple of $1 (i.e. right-pad with spaces)
     /e;

    s/
        .{$1}  # Replace series of $1 contiguous chars...
     /
        ($i++%2?reverse$&:$&)."\n"  # ...alternately with themselves or in
                                    # reverse, with a trailing newline
     /ge;

    chop'  # Remove final newline

1

জাভাস্ক্রিপ্ট ES6, 123 বাইট

var t=(s,n)=>{for(var d=1,i=0,o='',l=s.length;i<l;i++){o+=d?s[i]:s[i-i%n+n-1-i%n]||' ';if(i%n==n-1){d=!d;o+='\n'}}return o}

সাথে কল করুন t(input_string, twist_length)যা আউটপুট স্ট্রিং দেয় returns


1
দুঃখিত, কিছুটা দ্রুত পোস্ট করা হয়েছে। এটা ঠিক আছে।
ড্যাঙ্কমেস



0

Coffeescript, 151 বাইট

f=(s,n)->r="";d=n;i=0;_="\n";u=" ";l=s.length;(d--and(r+=s[i]or u;++i)or(r+=_;r+=s[c]or u for c in[i+n-1..i];i+=d=n;r+=_ if i<l))while i<(l/n+1>>0)*n;r

খুব বেশি = (


0

বাশ, 83 74

for((i=0;i<${#1};i+=$2));do b=cat;((i/$2%2))&&b=rev;echo ${1:i:$2}|$b;done

দ্বিতীয় আর্গুমেন্টের দৈর্ঘ্য সহ প্রথম আর্গুমেন্টের সাবস্ট্রিংগুলির মধ্যে catএবং এর revজন্য এটি বিকল্প হয় ।

ব্যবহৃত বিশেষ ভেরিয়েবল অন্তর্ভুক্ত

  • ${#1}(স্ট্রিংয়ের দৈর্ঘ্য $1)
  • ((i/$2%2))(একটি গাণিতিক অভিব্যক্তি $iদ্বারা ইনক্রিমেন্টারকে বিভাজন করে $2এবং তারপরে বিজোড় বনাম এমনকি নির্ধারণের জন্য এটির মডুলো গ্রহণ করে, যা ব্যবহার করতে হবে বা না তা নির্ধারণ করেrev )
  • ${1:i:$2}( দৈর্ঘ্যের সাথে $1অবস্থানে শুরু করার স্তর ))$i$2

এইচএম, আমি অন্য bashউত্তরটি থেকে এই স্বাধীন করেছি, যা আমি কেবল এখনই দেখেছি। আমরা কার্যকরভাবে একই যুক্তি আছে। ... আসলে, ভিক্টোরিহ্লাস্ট্রমের উত্তরটি আমাকে আরও 9 টি চরিত্রের শেভ করতে দেয় ve
অ্যাডাম কাটজ

0

জাভাস্ক্রিপ্ট ES6, 113 বাইট

আমার নিজের প্রশ্নে আমার নিজস্ব ক্র্যাক। এটি স্পেস যুক্ত করবে যাতে এটি দ্বারা বিভাজ্য n, সেভাবে এটি কেবল বিভাজন এবং বিপরীত।

(s,n)=>(s+' '.repeat(n-s.length%n)).match(eval(`/.{1,${n}}/g`)).map((l,i)=>i%2?[...l].reverse().join``:l).join`
`
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.