简单的字符串反射

26

让我们从定义字符串中字符的反射开始：

给定一个字符串，该字符串具有不同的小写字母字母，且不带空格，例如abcdefg，则将字符串中的字母反射c（不更改任何其他字母的顺序）定义为字符串中的新位置，以使字母的数量最初现在，它右边的字母是它左边的字母数。

因此，信的反射c中abcdefg会abdecfg。说明：的右边有4个字母c，现在，的左边有4个字母c。

其他示例：

反映性格e中myfriend就会形成串myefrind

反映性格a中axyz会形成串xyza。

反映性格b中abc会形成串abc。

反映性格d中d会形成串d。

反映性格e中ef会形成串fe。

有关更多信息或尝试一些测试用例，这是我用C ++编写的（有点长）程序。

挑战

给定一个带有不同小写字母的字符串，请按字母顺序遍历每个字符，然后将其“反映”在字符串中。

说明：字符串中的字母来自a-z，没有空格，字母是唯一的，字符串的长度至少为1个字母，最长为26个字母。

例子

输入：dcba。输出：dcba。

原因：首先，应反映a字母，因为它是字母中最早出现的字符串中的字符。你会得到adcb。然后，反映b字母中紧随其后的以获得badc。然后，反映c得到cbad，然后d得到dcba。

输入：myface。输出：fyecma。

提示：按顺序浏览字母a, c, e, f, m, y。

输入：a。输出：a。

输入：acb。输出：bac。

输入：cwmfjordbankglyphsvextquiz。输出：ieabhqzugdltkfnvpjxsormycw。

计分

  • 输入和输出可以通过任何方便的方法给出。
  • 完整的程序或功能都是可以接受的。如果是函数，则可以返回输出而不是打印输出。
  • 禁止出现标准漏洞。
  • 这是代码高尔夫球，因此所有常见的高​​尔夫规则都适用，并且最短的代码（以字节为单位）获胜。
  • 发布后约100小时接受。

现任优胜者

显示代码段

code-golf  string 
— NL628
source
2
谁能给我关于这个难题是否还可以的见解？这是我在这里的第二个（我的第一个被关闭，因为题外话......！）我试图使它真正完成，但是不确定是否丢失任何东西。我真的很想改善这个SE，并从中获得乐趣！谢谢大家：D
— NL628
6
看起来不错 我可能会给出一些更长的示例（特别是，第一个示例部分提供的内容可能多于看似边缘的情况）。
— Esolanging Fruit '18
1
澄清要求：“ 字母是唯一的 ”意味着每个字母在输入中仅出现一次，对吗？
— GPS
4
我们可以使用大写而不是小写的输入和输出吗？
— 凯文·克鲁伊森
5
@ NL628顺便说一句，如果您想在将挑战发布到此处之前先了解一下挑战，则可以将其发布在Sandbox中。
— 暴民埃里克（Erik the Outgolfer）'18年

Answers:

8

Brain-Flak，188字节

<>((((()()()){}){}()){}){(({}[()])<({}[(((((()()()()()){}){}){})()){}{}])<>{<>(({})<({}<>({}<>))((){[()](<{}>)}{}){{}(<({}<([]<<>{({}<>)<>}<>>){({}[()]<({}<>)<>>)}{}>)>)}{}>)<>}<>{}<>>)}<>

在线尝试！

除了挑战说明中描述的反射之外，此代码还将字符串正确反转26次。这对最终输出没有影响。

# Push 26
<>((((()()()){}){}()){})

# Do 26 times:
{(({}[()])<

  # Subtract 122 from counter to get negative lowercase letter
  ({}[(((((()()()()()){}){}){})()){}{}])

  # For each character in string:
  <>{

    # Keep a copy of pivot letter on the third stack
    <>(({})<

    # Move next letter to other stack and compare to pivot
    ({}<>({}<>))

    # If letters are equal:
    ((){[()](<{}>)}{}){

      # Keep current letter separate from this transformation
      {}(<({}<

      # While keeping a copy of current stack height:
      ([]<

        # Move all letters to one stack
        <>{({}<>)<>}<>

      >)

      # Move a number of letters equal to old stack height back
      {({}[()]<({}<>)<>>)}{}

      >)>)

    }{}>)<>

  }

  # Destroy pivot letter
  <>{}<>

>)}

# Switch stack for output
<>
— 硝化龙
source
1
哇，真是太神奇了。我什至不明白：O +1
— NL628
7

05AB1E，20 17字节

{vð.øy¡€á€gsJ£yý

在线尝试！

说明

带有第一个迭代的示例 myface

{v                  # for each char y in sorted input
  ð.ø               # surround current string with spaces
                    # STACK: ' myface '
     y¡             # split at current letter
                    # STACK: [' myf', 'ce ']
       ۇ           # remove non-letters
                    # STACK: ['myf','ce']
         €g        # get the length of each string in the pair, reversed
                    # STACK: ['myf','ce'], [2,3]
            sJ      # join the pair back to a string
              £     # split into 2 pieces of the calculated sizes
                    # STACK: ['my','fce']
               yý   # join on the current char y
                    # STACK: 'myafce'

字符串在每次迭代时都用空格包围，因为在字符串的第一个或最后一个字母上分割会导致长度为1的列表，否则合并将不包含该字母。

— 艾米尼亚
source
1
17个字节？！?? !! 令人惊奇的..助记符仅击败您一个字节：P
— NL628
1
嗯...哇，我唯一能看到的就是拆除周围的空格。似乎很奇怪，我们找不到其他替代方法。
— 魔术章鱼缸
1
@MagicOctopusUrn：这是我发现的处理第一个或最后一个字符的最短方法。确实确实为此感到很多字节
— Emigna '18
5

Pyth，18 16 19 16字节

VSQ=QXx_QN-QNN)Q

在这里尝试

说明

VSQ=QXx_QN-QNN)Q
VSQ           )       For each character (N) in the sorted input (Q)...
          -QN         ... remove the character from Q...
      x_QN            ... get the reflected position...
     X       N        ... insert N...
   =Q                 ... and save the result into Q.
               Q      Output the final result.
哇16个字节？我会投票赞成，但可悲的是我已达到每日投票上限。将在6个小时内完成：P
— NL628 '18 -4-20
4

Python 3中，80 73个字节

感谢Esolanging Fruit提醒我，函数可以通过修改参数来返回。 

lambda x:[x.insert(len(x)+~x.index(i),x.remove(i)or i)for i in sorted(x)]

在线尝试！

将输入作为字符列表。

— 乔·金
source
3
哇，我也在C ++和Python 3中写了一个答案。我的Python 3答案正好是您答案的两倍... +1
— NL628 '18
3

视网膜0.8.2，61字节

$
a
{`(.)(.*)\1$
$2$.`$*_$1$1
+`(.)_(_*.)
$2$1
}T`_l`l!`.$
!

在线尝试！链接包括测试用例。说明：

$
a

从开始循环a。

{`(.)(.*)\1$
$2$.`$*_$1$1

如果输入包含当前字母，则将其移动到末尾，并使用_s 字符串表示其原始位置。

+`(.)_(_*.)
$2$1

每次_移动字母后退一个字符。

}T`_l`l!`.$

增加字母。之后z将其更改为一个!，因此不匹配任何东西，循环结束。

!

删除!。

— 尼尔
source
3

Java 8，140 96 92 88 87 85字节

s->{for(char c=9;++c>0;){int i=s.indexOf(c);if(i>=0)s.add(s.size()+~i,s.remove(i));}}

-44字节创建@TFeld的Python 2 Answer的端口。
-6个字节，感谢@OlivierGrégoire。

修改输入列表，而不是创建一个新列表。

说明：

在线尝试。

s->{                     // Method with ArrayList<Character> parameter and no return-type
  for(char c=9;++c>0;){  //  Loop over all characters known
                         //  (except for the first 9 unprintables)
    int i=s.indexOf(c);  //   Index of the character, or -1 of it isn't present
    if(i>=0)             //   If the current character is present in the List
      s.add(s.size()+~i,s.remove(i));}}
                         //    Change the position of this character to index `l-i-1`,
                         //    (where `l` is the size of the input-List)
— 凯文·克鲁伊森
source
1
— 奥利维尔·格雷戈尔
1
@OlivierGrégoire谢谢。还有1个循环，而不仅仅是字母字符。:)
— Kevin Cruijssen
2
好吧，如果您走那条路，for(char c=9;++c>1;)那就更好了;-)
— OlivierGrégoire18年
@OlivierGrégoire当然，char也像..smart 一样环绕Integer.MAX_VALUE + 1 == Integer.MIN_VALUE！
— 凯文·克鲁伊森
@OlivierGrégoire s是一个ArrayList，因此indexOf将具有通用类型T（Character适用于此输入列表）。
— 凯文·克鲁伊森
3

JavaScript，85 80 79字节

-6个字节，感谢@DanielIndie

a=>[...a].sort().map(i=>a.splice(s=a.indexOf(i),1)&&a.splice(a.length-s,0,i))&&a

在线尝试！

— 硕果累累
source
这不“编译”一个是字符串，并且您使用拼接
— DanielIndie '18
@DanielIndie Input应该作为字符数组传递，就像Jo King的Python解决方案一样。
— Esolanging Fruit '18
— DanielIndie
您不会从该函数返回任何内容，也不会打印它
— DanielIndie
@DanielIndie函数可以通过修改其参数来返回。
— Esolanging Fruit '18
2

红色，96 94字节

多亏了Kevin Cruijssen，节省了2个字节 

func[x][foreach c sort copy x[i:(length? x)+ 1 - index? find x c insert at replace x c""i c]x]

在线尝试！

更具可读性：

f: func[x][
    foreach c sort copy x[                  ; for each symbol in the sorted input
       i: (length? x) + 1 - index? find x c ; find its index and reflect it 
       insert at replace x c "" i c         ; remove it by replacing it with an empty char 
                                            ; and insert the symbol at its new index   
    ]
    x                                       ; return the transformed string
]
— 加伦·伊万诺夫（Galen Ivanov）
source
1
您可以更改find x c replace x c""insert at x i c为find x c insert at replace x c""i c来节省2个字节，以消除x和空间。
— 凯文·克鲁伊森
@Kevin Cruijssen谢谢，凯文，现在好多了！
— Galen Ivanov '18
2

R，73 72 69字节

function(s){for(x in sort(s))s=append(s[x!=s],x,match(x,rev(s))-1);s}

在线尝试！

输入和输出字符向量。

— 基里尔
source
ew，c用作变量名？即使是代码高尔夫，也太糟糕了！
— 朱塞佩
好吧，我显然可以更改它，但是我很惊讶地看到它可以打扰任何人。事实上，我倾向于为维护在变量名某种意义上（如优先c用于char），而不是未使用的内置插件。
— Kirill L.
好吧，当寻找改进时（我没有），我发现自己试图使用c，当我不知道正在发生什么时，这太糟糕了。我通常使用K或k什C至只是避免此类问题，但我完全理解。append是完成这项工作的正确工具。
— 朱塞佩
哦，我知道，对此感到抱歉，将来会尽量避免设置此类“陷阱”。
— Kirill L.
2

Japt，23 22字节

¬n rÈ+S kY iYJ-XbY)x}U
¬n                     // Split the input into chars and sort it.
   r                }U // Then reduce the result with initial value of the input.
    È+S                // Append a space for replacing edge cases and
        kY             // remove the current char from the string.
           iY          // Insert it back
             J-XbY     // at the calculated index,
                  )x   // and remove the unnecessary space once we're done.

感谢Oliver节省了一个字节。
在线尝试！

— 尼特
source
1
好东西。您可以替换,É为J
— Oliver
@Oliver非常感谢，我仍然忘记时不时使用默认变量，这非常方便。
— Nit
1

Haskell，87个字节

s#c|(h,_:t)<-span(/=c)s,(v,w)<-splitAt(length t)$h++t=v++c:w|1<2=s
f s=foldl(#)s['a'..]

在线尝试！

f s=foldl(#)s['a'..]         -- fold the function '#' into all characters from 'a'
                              -- with the starting value of the input string s
s#c=                          -- in each step (s: result so far, c: next char)
   (h,_:t)<-span(/=c)s        -- let 'h' be the substring before 'c' and
                              -- 't' the substring after 'c'. the pattern match
                              -- fails if there's no 'c' in 's'
   (v,w)<-splitAt(length t)$h++t
                              -- split the string 'h++t' at index length of t
   =v++c:w                    -- return 'v' followed by 'c' followed by 'w'
   |1<2=s                     -- if there's no 'c' in 's', return 's' unchanged
— 妮米
source
为什么会停止？折叠一个无限列表是否会导致一个无限循环？不是f s=foldl(#)s['a'..'z']吗？
— user1472751 '18
1
@ user1472751：['a'..]不是无限的，因为它Char属于class Bounded。包含值的列表在..]处Bounded停止maxBound。试试：print [False ..]。
— nimi
1

SNOBOL4（CSNOBOL4） ，132个 128字节

	DEFINE('I(I)')
I	U =&LCASE
N	U LEN(1) . K REM . U	:F(RETURN)
	I ARB @S K	:F(N)
	I K =
	I ARB . L RPOS(S) REM . R
	I =L K R	:(N)

在线尝试！

所需算法的简单实现。通过切换到函数而不是完整程序来节省一些字节；解释大致相同。

	I =INPUT			;* read input
	U =&LCASE			;* alias for lowercase letters (it started out as uppercase)
N	U LEN(1) . K REM . U	:F(O)	;* set K to the next lowercase letter, and when empty, goto O
	I ARB @S K	:F(N)		;* set S to the number of letters before K, or goto N
	I K =				;* remove K
	I ARB . L RPOS(S) REM . R	;* set R to the last S characters of I and L to the others
	I =L K R	:(N)		;* recombine the string and goto N
O	OUTPUT =I			;* print new string
END
— 朱塞佩
source
1

果冻， 12  11 字节

W;ṢḟṁUṣ¥jʋ/

接受字符列表并返回字符列表的单子链接。

在线尝试！

怎么样？

W;ṢḟṁUṣ¥jʋ/ - Link: list of characters V  e.g. "myface"  ...i.e. ['m','y','f','a','c','e']
W           - wrap V in a list                 ["myface"]
  Ṣ         - sort V                           ['a','c','e','f','m','y']
 ;          - concatenate                      ["myface",'a','c','e','f','m','y']
          / - reduce with:
         ʋ  -   last four links as a dyad:
            -   (i.e. start with "myface" on the left and 'a' on the right 
            -         2nd iteration has that result on the left and 'c' on the right
            -         and so-forth)            e.g. left = myface, right = 'a'
   ḟ        -     filter out (right from left)      "myfce"
       ¥    -     last two links as a dyad:
     U      -       upend left                      "ecafym"
      ṣ     -       split at occurrences of right   ["ec","fym"]
    ṁ       -     mould (ḟ(x,y)) like (Uṣ¥(x,y))    ["my","fce"] 
         j  -   join with right                   "myafce"
— 乔纳森·艾伦
source
好的，这几乎
— 毁了
1
好吧，我认为这就是Jelly的目的-我一半希望Dennis（Jelly的创造者）提交更短的一个！
— 乔纳森·艾伦
大声笑那真是太不可思议了：P但我不能投票赞成b / c我用完了我的每日投票数。.rip–
— NL628
1
...我认为可能存在一种通过使用ḟ（过滤出）来保存字节的方法，但我尚未对其进行管理。
— 乔纳森·艾伦
1
从时间上看，它的输入长度为O（n log n），因为它首先使用Python sorted，然后经过n次迭代，执行似乎不太复杂的操作（展平，在找到的索引处拆分，合并，反转） ）。-并且Python sorted是O（n log n）。
— 乔纳森·艾伦
1

C（clang），164162字节

y,n,a,b,c,p,i;f(char*s,l){for(i=0;p=0,++i<123;p<l&&(y=s[p],n=l+~p,a=p+1,b=p,n<p&&(a=n,b=n+1),c=l+~(2*(n<p?n:p)),memmove(s+b,s+a,c),s[n]=y))while(s[p]^i&&p<l)p++;}

在线尝试！

f() 将包含输入字符串和此数组长度的char数组作为参数，并执行所需的反射。

callf() 做漂亮的印刷。

学分

-2个字节。@凯文 谢谢

— 全球定位系统
source
1
您可以删除的空间char *s变化，i=96到i=9到节省2个字节。
— 凯文·克鲁伊森
好的收获..我们不必从头开始a。谢谢
— GPS
— ceilingcat
1

APL + WIN，63个字节

提示输入字符串

l←s[⍋⎕av⍳s←,⎕]⋄⍎∊(⍴s)⍴⊂'s←(n←⌽~s=↑l)\s~↑l⋄((~n)/s)←↑l⋄l←1↓l⋄'⋄s

说明：

l←s[⍋⎕av⍳s←,⎕] sort characters into alphabetical order

⍎∊(⍴s)⍴⊂'....' create an implicit loop for each character

s←(n←⌽~s=↑l)\s~↑l⋄((~n)/s)←↑l do the relection for first character in l

l←1↓l drop the first character in l

s display the result

⋄ statement separator
— 格雷厄姆
source
1

Perl中，74 70个字节

84 80字节，包括作为unix过滤器的调用

for$c(a..z){if($p=1+index$_,$c){substr$_,$p-1,1,"";substr$_,-$p,0,$c}}

$ echo -e 'dcba\nmyface\na\nacb\ncwmfjordbankglyphsvextquiz' |
> perl -pE'for$c(a..z){if($p=1+index$_,$c){substr$_,$p-1,1,"";substr$_,-$p,0,$c}}'
dcba
fyecma
a
bac
ieabhqzugdltkfnvpjxsormycw
— 海尼克-比奇-维乔迪尔
source
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.