扭曲的话!


34

扭曲的话!

给定一个字符串和一个正整数。您必须来回扭动琴弦。

输入/输出示例

输入项

Programming Puzzles & Code Golf
4

输出量

Prog
mmar
ing 
zzuP
les 
oC &
de G
 flo

输入项

输入可以通过STDIN或函数参数接收。输入将包含一个字符串和一个正整数n。整数将确定每条双绞线的长度。

绳子来回扭动。和的输入HELLO, WORLD!将类似于:

HELLO, WORLD!

输出量

输出将是扭曲的文本。它可能没有任何尾随空格。如果输入的字符串长度不能被行长度整除,请添加空格直到行被填充:

一个例子:

输入项

Hello, World!
5

输出(请注意最后的空格)

Hello
roW ,
ld!  


它可能没有任何尾随空格。打掉一个动词?
亚当

我们可以返回行列表吗?
亚当

Answers:


10

佩斯19 15

VPc+z*dQQ_W~!ZN

预填充字符串,然后在打印时将它们彼此反向。填充等于框的大小,但切掉输入后的最后一行将被丢弃。

在这里尝试


6

CJam,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%的时间内错误退出(但仍会产生正确的输出)。(这是因为我使用ag习惯将数组元素分为两组,以便我可以彼此反向,但是我不检查最后一个元素是否同时具有两个期望的元素,因此,如果出现以下情况,它将尝试访问不存在的元素行数是奇数。)

取消/解释:

{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

python 2,60

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

n从开始到一次获取字符s,并以和d之间交替的方向打印字符。对于最后一行的间距,在切掉前在末尾填充空格,仅在剩余字符少于字符数时影响它。1-1snn

递归解决方案将保留一个char(59),但保留尾随换行符,这是不允许的。

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


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

Haskell,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 2015年

这是一个let用分号分隔的二合一语句-通常您会使用换行符和缩进,但是Haskell也允许您编写let a=b; c=d in expr
林恩

我不知道这是允许的,把putStrLn从程序中删除了!
Leif Willerts

1
@LeifWillerts,最近,这里的挑战倾向于允许您通过函数参数/结果或stdin / stdout执行I / O -在这里,我的解决方案是使用函数(%) :: String -> String -> String而不是IO ()
林恩

2

Python 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

Lua,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

Perl,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语句中的字符(从STDIN读取);在输入和输出之间添加回车符。如果不存在,则输出在技术上是正确的,但第一行将显示在输入字符串的后面。[[我使用的标准Mumps终端没有本地回显。]]   坐着,这里是测试:

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”之间有一个回车/回车键。[[本地回声。]]

如果有人感兴趣,我可以描述一下代码的状态。但我的确意识到那里并没有大量的腮腺炎爱好者... :-)


2

PowerShell,102字节

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

以前的尝试

(更长或无效)

PowerShell,110字节

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

PowerShell,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

PowerShell,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})"|?{$_}

PowerShell,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};{...}来提高可读性。

Powershell,120字节 (无效)

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

1
真高兴看到另一个PowerShell抛锚!一个简单的开始接近每一个空间,以摆脱宕param($s,$i)$s+' '*($i-$s.Length%$i)-replace'(.{4})?(.)(.)(.)(.)',"`$1`n`$5`$4`$3`$2`n"-split"`n"|?{$_-ne""}这将让你到108
AdmBorkBork

谢谢@TimmyD; 只是在我的脚本中发现了一些基本错误(它不符合要求/硬编码仅适用于4。。。正在修复)
JohnLBevan 2015年

在测试时,为了使数据流以正确的方向来回流动,我需要将最终[$r]索引与[-not$r]... 交换,否则第一行的读数与提供的示例相反(即从右到左)。否则,执行过程将非常流畅!
AdmBorkBork,2015年

1
另外,由于我们假设输入数字n为正,并且可以保证字符串的长度为非负(根据定义),这意味着(($i-$l%$i)%i)等效于($i-$l%$i)保存四个字符。
AdmBorkBork

1
糟糕,我原本是想输入错字的(-$l)%$i。不知道那是哪里来的。有趣的是,虽然应该,但它并不等效。显然,PowerShell(以及其他语言)如何实现模函数是一个怪癖,这与我(是数学专业)或Wolfram-Alpha所期望的不同。显然,您需要坚持使用更长的版本。参考 证明->((y-x%y)%y) ==> ((y%y)-(x%y%y))%y ==> ((0)-(x%y))%y ==> (-x%y)%y ==> (-x)%y
AdmBorkBork'Aug

2

Clojure,83个字节,87个字节79个字节

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

下面的评论经过了几次更正,谢谢Ørjan

在线尝试!

令人遗憾的是,Clojure似乎常常没有代码打高尔夫的答案。它当然不能在字节长度上与高尔夫语言竞争,但是我认为完全缺席是没有必要的。

说明:

  • 数据中,两个参数分别是数字和字符串
  • 通过运行clojure内置功能开始 在字符串上分区,将其s分块为一系列字符列表,其中列表具有长度n。最后一块将n使用返回的“ pad collection” 填充一定长度的空格,(repeat " ")从中返回无限的懒惰序列
  • 然后,我们使用三个参数调用map
    • 匿名函数(#(..)
    • 函数的无限交替的惰性序列,#(or %)其功能类似于恒等函数和函数[#(or %) reverse #(or %) reverse ...]循环返回的(即)
    • 分区返回的列表的分块懒惰序列。
  • 终于 匿名函数 #(apply ...)
    • 调用identityreverse交替调用一个块。这是通过(% %2)表达式完成的,该表达式调用匿名函数的第二个参数(即“块”)作为匿名函数的第一个参数发送给匿名函数[即identityreverse]。
    • 调用(apply str ...)以将字符列表转换为字符串
  • 外部函数返回字符串的惰性序列

我们在这里使用的一个技巧是,许多clojure函数喜欢map将任意数量的集合作为args,即(map f coll1 coll2 coll3 ...)函数f只需接受与集合一样多的参数。在这种情况下,我们发送两个集合,一个是交替函数引用的集合,另一个是分块的字符串。


1
很好,但似乎在末尾没有必需的空格ld!
与Orjan约翰森

你是最正确的。添加了一个便笺本集合,应该可以解决此问题...并且花了我8个字节...
Matias Bjarland

我对打高尔夫球规则有疑问:如果您使用的内置函数需要导入或类似的语句(在clojure中需要,在Java中导入等),则该内置函数的导入是否需要成为一部分高尔夫解决方案字节数?我认为是的,但是有点像灰色区域。
Matias Bjarland '18

是的,已计入进口。
与Orjan约翰森

哦,但是还有另外一条规则要打破:您不能在预定义变量中输入内容,需要使解决方案成为整个程序或函数。(使用fndefn可以。)另一方面,允许您的函数仅返回结果而不是打印结果。
与Orjan约翰森


2

Python 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)]))

(查看其他答案), rjust95 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)]))

您输出的最后一行是错误的。在这里运行。这是一篇很棒的第一篇文章,一旦修复,我将建议一些减少一些字节的方法,第一个是您可以从答案中删除所有空格/制表符。
mbomb007 '18

哈哈,你说得对。解决这个问题会花很多钱,但我正在努力。谢谢
bobrobbob


另外,您早就
mbomb007 '18

阅读提示。再次感谢
bobrobbob

1

PHP,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

CoffeeScript,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)

取消高尔夫:

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

q,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

Q,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的其他q答案所启发


1

Python 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

我无法评论@willem,但我使他的代码更小了。

尝试在这里 尝试在这里


嗨,AlexN,很好。我认为您在“尝试这里”示例中的最后一行是不正确的。应该证明是正确的。我也算86个字符吗?请参阅的更新条目
威廉2015年

嗨,威廉姆,您是对的,我更正了代码,发现您的错误:ideone.com/GOmMrE 右侧应该有。
2015年

1

Perl,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!  $

请注意,从STDIN读取的输入不能以换行符结尾(这将花费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

JavaScript 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),返回输出字符串。


1
抱歉,发布太快了。它是固定的。
DankMemes



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,然后取它的模数,以确定奇VS连,其决定是否要使用rev
  • ${1:i:$2}(从的子字符串$1开始,$i长度为$2)。

嗯,我这样做是独立于其他bash答案的,而我刚才才看到。我们实际上有相同的逻辑。...实际上,viktorahlström的回答只是让我剃掉了另外9个字符。
亚当·卡兹

0

JavaScript 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`
`
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.