反向正向运行


22

输入项

您的输入是任何合理格式的一位数字列表,包括一串数字。输入将不为空。

输出量

您的输出应为输入列表,但每个最大的非零数字都将反转。

考虑输入

95883007414830
<--->  <---->

非零行程已用箭头标记的地方。反转所有这些运行,我们获得输出

38859003841470

规则和计分

您可以编写完整的程序或函数。最低字节数获胜,并且不允许出现标准漏洞。

这个挑战是相关的,但更为复杂,因为它包括其他字符串处理。

测试用例

4 -> 4
00 -> 00
123 -> 321
0010 -> 0010
12000345 -> 21000543
18161604 -> 61618104
95883007414830 -> 38859003841470
010230456078912 -> 010320654021987
357509902003550 -> 575309902005530
2492882377675046 -> 5767732882942064
03026302053000357099 -> 03036202035000753099

排行榜

这是一个堆栈片段,用于按语言生成排行榜和获奖者名单。为了确保您的答案显示出来,请以表格标题开头

## Language, N bytes

您可以使用删除线标记<s>57</s>将旧的分数保留在标题中:将显示为57

Answers:



8

IPOS,5个字节

'0!r%

%将输入字符串拆分为零,将命令r(反向)应用于每个子字符串,并将结果重新归零。


7

视网膜,15字节

S`0
O%^$`.

¶
0

在线尝试!(稍作修改即可一次运行所有测试用例。)

说明

S`0

将输入拆分为0s,即将每个非零数字(可能为空)行放在自己的行上。

O%^$`.

通过以下方式反转每一行:

  • 使用分别将舞台应用于每一行%
  • 将每个字符分别与匹配.
  • 根据替换结果($)用空字符串(第二行为空)进行排序。即它根本不排序,因为所有排序值都相同。
  • 然后颠倒排序字符的顺序。

最后:

¶
0

将换行符转回0s。


5

05AB1E,6个字节

码:

0¡€R0ý

说明:

0¡      # Split on zeros
  €R    # For each item in the array, reverse it
    0ý  # Join by zeros

使用CP-1252编码。在线尝试!


5

朱莉娅,30个字节

s->replace(s,r"[^0]+",reverse)

这是一个匿名函数,它接受一个字符串并返回一个字符串。要调用它,请将其分配给变量。

replace函数提供将正则表达式的匹配替换为应用于每个匹配的函数结果的功能。在这种情况下,我们可以使用使用非零值[^0]+并将这些运行替换为reverse应用于匹配文本的函数的结果。

在线验证所有测试用例!



4

Jolf,8个字节

RΜGi0λ_0

在这里尝试!

说明

RΜGi0λ_0
  Gi0     split input on zeroes
 Μ   λ_   map over reversal as a lambda
R      0  join by zeroes

斜视一下,代码说明看起来像是lambda。

等效的8字节答案:

RΜGi0΅O0

同样,但它使用΅O(string mirror lambda)代替。


当我斜眼看时,它看起来更像是一些有趣形状的文本。也许我应该把这架望远镜收起来。

1
@cat不,不,保留它,但是在执行时请查看lambda。
Conor O'Brien 2016年


3

Python,58 50字节

lambda x:"0".join([n[::-1] for n in x.split("0")])

接收字符串x并分割零,然后反转分割中的每个元素并添加零,并返回此减最后的零。


1
欢迎使用PPCG :)您应该能够做得到"0".join,然后删除添加物和切片。
FryAmTheEggman '16

@FryAmTheEggman感谢您的提示
1232年

没问题:)您还可以删除之间的空间]for。如果需要,您可以查看我们的提示页面以获取更多指针。
FryAmTheEggman '16

7
lambda x:"0".join(n[::-1]for n in x.split("0"))
orlp 2016年

3

Mathematica,30个字节

Join@@Reverse/@#~SplitBy~Sign&

例如Join@@Reverse/@#~SplitBy~Sign&[{1,2,3,0,0,5,9,0}]={3, 2, 1, 0, 0, 9, 5, 0}


2

PowerShell v2 +,45字节

($args-split0|%{-join$_[$_.length..0]})-join0

像没有明天一样滥用隐式转换。可能不会变得更短,因为没有内置的反向功能比该索引技巧还短。

说明

例如,123045输入是这种工作方式的一个示例$args。在-spliton之后0,管道将包含一个数组(123,45)。具有的第一个循环|%{...}的当前元素$_等于123,然后将其隐式转换为字符串,然后用[]索引反向。这使其('3','2','1')成为一个字符数组。循环-join将其放回字符串中,"321"并将其留在管道中。下一个(最后一个)循环迭代将输入反转为"54"。所以,现在我们的管道"321""54"。将其封装在parens中,()因此将其重新格式化为数组,并-join与零一起重新返回以产生结果输出字符串"321054"。这留在管道上,并且向控制台的输出是隐式的。

如果原始输入中有后续的零,则将使用空元素填充该数组,因此输出中存在正确数目的零。例如,1230045-split0变成(123,,45),事物继续如上。



2

因子,35字节

击败Pyfon和Clojure,Booyah!

[ "0"split [ reverse ] map "0"join ]

此匿名函数是此Python答案的字面翻译。

这非常简单,只需将字符串拆分为零,将结果数组中的每个元素反转,然后将所有元素(包括长度为零的字符串)连接在一起"0"

这是在所有测试用例上运行的示例:

IN: scratchpad auto-use {
        "4"
        "00"
        "123"
        "0010"
        "12000345"
        "18161604"
        "95883007414830"
        "010230456078912"
        "357509902003550"
        "2492882377675046"
        "03026302053000357099"
        }
        [ 
          "0" split [ reverse ] map "0" join
        ]
        map .

{
    "4"
    "00"
    "321"
    "0010"
    "21000543"
    "61618104"
    "38859003841470"
    "010320654021987"
    "575309902005530"
    "5767732882942064"
    "03036202035000753099"
}

"00120"-> { "" "" "12" "" }-> { "" "" "21" "" }->"00210"


2

Haskell,45个字节

r%(0:t)=r++0:[]%t
r%(h:t)=(h:r)%t
r%_=r
([]%)

递归累积到目前为止的反向块,在到达ra时将其放在前面0。当其余的弦为空时,它也会放电r

前两个重复了一些代码,但是我没有找到组合它们的更短方法(45和47字节):

r%(h:t)|h<1=r++h:[]%t|1>0=(h:r)%t
r%_=r
([]%)

r%l|0:t<-l=r++0:[]%t|h:t<-l=(h:r)%t
r%_=r
([]%)

我认为您需要在第2行中r%(h:t)=(h:r)%t
再加上


1

JavaScript(ES6),50 49字节

字符串版本:

s=>s.replace(/[^0]+/g,r=>[...r].reverse().join``)

感谢@Kevin Lau保存了一个字节!

数组版本(60字节):

a=>a.map((n,i)=>n?a[z-i+[...a,0].indexOf(0,i)]:(z=i,0),z=-1)

1

J,20 18字节

0}:@;@(<@|.;.1)@,]

感谢Zgarb的帮助!将以空格分隔的列表作为正确的参数。

-2个字节,感谢Zgarb!


1

Clojure / ClojureScript,44个字符

#(flatten(map reverse(partition-by pos? %)))

与其他解决方案相同,但由于函数名较长,因此更加冗长。不会因为这个原因将其发布,但是它击败了其他一些答案,所以为什么不呢?

适用于任何序列类型。在ClojureScript中,这也适用于字符串,因为字符串可作为字符列表处理,实际上只是1个长度的字符串,对于诸如之类的内容,其会强制转换为数字pos?


1

Haskell,46个字节

import Data.Lists
(reverse=<<).split(oneOf"0")

用法示例:(reverse=<<).split(oneOf"0") $ "0123004500678090"-> "0321005400876090"

可悲的是,该split功能需要昂贵的导入。在每个位置分割输入列表0,例如split(oneOf"0") "0120030"-> ["","0","12","0","","0","3","0",""],反转每个块并将其连接成单个字符串。


1

F#,103个字节

let f x=x="";x.Split '0'|>Array.map(fun s->System.String(s|>Seq.toArray|>Array.rev))|>String.concat "0"

1

Java,179个字节(带导入)

import java.util.*;static void r(String s){StringJoiner x= new StringJoiner("0");for(String a:s.split("0",s.length())){x.add(new StringBuilder(a).reverse());}System.out.print(x);}

接收字符串输入并将字符除以零,然后通过调用StringJoiner类的add方法将其添加回去。


1

的Oracle SQL 11.2 131个 123字节

滥用XML函数。

SELECT LISTAGG(REVERSE(COLUMN_VALUE||''))WITHIN GROUP(ORDER BY rownum)FROM XMLTABLE(('"'||REPLACE(:1,'0','","0","')||'"'));

1

Perl,22个字节

其中包括+1作为-p选项:

s/[^0]+/reverse$&/eg

这是一个微不足道的替代品-很无聊。请注意,如果您输入的内容以换行符结尾(例如,perl -pe 's/[^0]+/reverse$&/eg' <<<21000543在Bash中使用),它将用数字捕获换行符-使用echo -nprintf避免这种情况。或者,以一个额外的字节为代价,将字符类更改为[1-9],您可以提供许多输入,每行一个。


1

C,105字节

#define x(o)for(p=s;*s&&'0'o*s;++s);for(r=s;r-->p;putchar(*r));
f(s,p,r)char*s,*p,*r;{x(^)x(==)*s&&f(s);}

f用数字列表作为以N终止的字符串进行调用,它将输出正确的输出。

脱节并解释:

f(s,p,r)
char*s,*p,*r; // K&R style to avoid repeating `char`
{

    // x(^)x(==) expands to...

    // Find the next zero digit
    for(p = s; *s && '0' ^ *s; ++s)
        ;

    // Print that run backwards
    for(r = s; r-- > p; putchar(*r))
        ;

    // Find the next non-zero digit
    for(p = s; *s && '0' == *s; ++s)
        ;

    // Print that run backwards (no difference, it's all zeros)
    for(r = s; r-- > p; putchar(*r))
        ;

    // If there's more string, recurse
    *s && f(s);
}

在Coliru上实时观看


0

Perl 5,52个字节

子程序:

{$_=pop;y/0/ /;map$i.=reverse,split/\b/;$i=~y/ /0/r}

-a当输入字符串以结尾时0,它不起作用(至少在Strawberry中),因为split/\b/包括$/0
msh210 '16

0

其实是22个位元组

k"a%sa"%'0@s♂R'0j#pXdX

实际上,这使我注意到split命令中存在一个错误-它不会保留空的拆分。解决方法是,a在进行拆分,反向和联接之前,将输入字符串用s 包围,然后a在最后将s 删除。输入为字符串,输出为单字符字符串列表。

在线尝试

说明:

k"a%sa"%'0@s♂R'0j#pXdX
k"a%sa"%                surround input with "a" characters
        '0@s            split on 0
            ♂R          reverse each piece
              '0j       join on 0
                 #pXdX  listify, remove first and last element (the "a"s)

0

C#,131个字节##

解决方案有缺陷!

string j(string i){foreach(var s in i.Split('0'))if(s!="")i=i.Replace(s,new string(s.ToCharArray().Reverse().ToArray()));return i;}

松散:

string j(string input)
    {

        string[] a = input.Split('0');

        foreach (string s in a)
        {
            if (s!="")
            input=input.Replace(s, new string(s.ToCharArray().Reverse().ToArray()));
        }

        return input;
    }

1
我相信当一个要反转的字符串是另一个字符串的子集时,此方法会有一个错误。如果给出输入01201230,则将返回02102130。这是因为String.Replace方法将所有出现的第一个字符串替换为第二个字符串。如果在反转时显示一个模式(0120210将返回0120120),也会引起此错误。
Xynariz '16

我什至没有想到..
downrep_nation

0

C#,133个字节


打高尔夫球

String m(String s){for(int i=0,p=i;i<s.Length;i++){if(s[i]=='0'){p=i+1;}else{s=s.Insert(p,s[i].ToString()).Remove(i+1,1);}}return s;}

不打高尔夫球

String m( String s ) {
    // i = Index on the String
    // p = Pointer of the last '0' found
    for (int i = 0, p = i; i < s.Length; i++) {
        if (s[ i ] == '0') {
            // Move the 'p' pointer to the index after this '0'
            p = i + 1;
        } else {
            // Insert the Char at the Index location to the Pointer location 
            //    and remove the one at the Index Location + 1,
            //    since the String was incremented by one char due to the 'Insert()'.
            s = s.Insert( p, s[ i ].ToString() )
                 .Remove( i + 1, 1 );
        }
    }

    return s;
}

完整代码

using System;
using System.Collections.Generic;

namespace Namespace {
    class Program {
        static void Main( String[] args ) {
            List<String> ls = new List<String>() {
                "4",
                "00",
                "123",
                "0010",
                "12000345",
                "18161604",
                "95883007414830",
                "010230456078912",
                "357509902003550",
                "2492882377675046",
                "03026302053000357099"
            };

            foreach (String s in ls) {
                String f = m( s );

                Console.WriteLine( String.Format( "{0,30}", s.Replace( "0", "0 " ) ) );
                Console.WriteLine( String.Format( "{0,30}", f.Replace( "0", "0 " ) ) );
                Console.WriteLine( "" );
            }

            Console.ReadLine();
        }

        static String m( String s ) {
            for (Int32 i = 0, p = i; i < s.Length; i++) {
                if (s[ i ] == '0') {
                    p = i + 1;
                } else {
                    s = s.Insert( p, s[ i ].ToString() ).Remove( i + 1, 1 );
                }
            }

            return s;
        }
    }
}

现在刚刚注意到,@downrep_nation已经在这里发布了C#解决方案,比我的代码

0

爪哇126

a->{String r="",t[]=a.split("0");for(String s:t){r+=new StringBuilder(s).reverse()+"0";}return r.substring(0, r.length()-1);}

如果s使用r和在前面声明变量t[],可以省略sfor循环中的type声明吗?
Cyoce '16

不,我检查过,增强后的循环需要一个新声明的变量。
HopefulHelpful

嗯 这很奇怪。很好
Cyoce '16

0

Clojure,37个字节

#(mapcat reverse(partition-by #{0}%))

使用#{0}而不是pos?(通过与串联节省1个字节%)并使用mapcat代替(flatten(map。仍然比Factor长

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.