外观：重新讨论Conway

16

到现在为止，您应该都熟悉Conway序列（又名“观望”序列）：

     1
    11
    21
  1211
111221
312211
etc

您也可以以任意数字作为起点。让它f(s)成为序列的下一个元素。现在，对于每个给定的s我们都可以找到f(s)。相反的是不是微不足道的：它是不是每一个y可能找到的前身s这样f(s) = y。例如，因为y = 1我们找不到前任。但是，如果长度y是偶数，则可以将其划分为成对的数字，以描述前任的每个部分：

513211 divides in 51,32,11
so: 51 comes from 11111 
    32 comes from 222
    11 comes from 1
put together: 111112221

因此，通过这种方式，我们可以为每个偶数长度定义一个唯一的前任y。

注意：用s这种方法定义的“前任” 通常不满足f(s) = y。

目标

编写一个接受数字串作为输入的函数/程序片段

  • 如果输入字符串的长度为奇数，则计算Conway序列的下一个元素
  • 如果输入字符串长度为偶数，则按上述定义计算输入字符串的前任。

以字节为单位的最短代码获胜。

基于外观序列的最新问题：

code-golf 
— 瑕疵
source
1
我很困惑。你能解释一下如何513111分成51，32和11？
— 吱吱作响的ossifrage
1
我觉得这是一些外观和序列挑战以及行程解码挑战的组合副本（我确定我们有）。
— Martin Ender 2014年
3
的前身11111111111111是什么？根据您的规格，它将为1111111。您应该修改规范以为此定义一个合理的答案。
— TheNumberOne 2014年
1
@TheBestOne 11111111111111根本没有前任。这是非法输入。
— 凯
2
@TheBestOne是的，这是正确的，我为前任定义了一个不总是与“真实”前任匹配的规则。
— 瑕疵的

Answers:

5

红宝石， 125120119 101字节

f=->n{c=n.chars;(n.size%2>0?c.chunk{|x|x}.map{|a,b|[b.size,a]}:c.each_slice(2).map{|a,b|b*a.hex})*''}

通过函数获取的字符串输入f：

f['111221']    # => "1211"
f['513211']    # => "111112221"
f['111112221'] # => "513211"

扩展注释：

# define lambda that takes one arg
f = -> (n) {
  # store digits in c
  c = n.chars

  # n is of odd length
  if n.size % 2 > 0
    # group identical numbers
    c.chunk{ |x| x }.map do |a, b|
      # array of [digit count, digit value]
      [b.size, a]
    end
  else
    # slice array into groups of two elements
    c.each_slice(2).map do |a, b|
      # repeat the second digit in a pair
      # the first digit-times.
      b * a.hex
    end
  end * '' # join array
}
— 八月
source
4

Prolog-170字节

[]/[].
T/R:-0*_*T*R.
C*X*[X|T]*R:-(C+1)*X*T*R.
C*X*T*Y:-10*C+X+Y+R,T/R.
N+R+A:-N=:=0,A=R;D is N mod 10,N//10+R+[D|A].
F-C-R:-C/N,(N=F,R=C;F-N-R).
[1]-[1,1]. S-T:-S-[1]-T.

这段代码定义了功能(-)/2。您可以像这样调用它

?- [1,1,1,3,2,1,3,2,1,1]-T.
T = [1, 3, 1, 1, 2, 2, 2, 1] .

?- [1]-T.
T = [1, 1] .

在这个序列中似乎只有一个长度具有奇偶校验：initial [1]。

wr_len :- wr_len(1, [1]).
wr_len(N, Cur) :-
    length(Cur, Len),
    TrailingZeroes is lsb(Len),
    (TrailingZeroes > 0 -> Par = 'even'; Par = 'odd'),
    writef('%t\t%t\t%t\t%t\n', [N, Len, Par, TrailingZeroes]),
    get_next(Cur, Next),
    succ(N, O),
    !, wr_len(O, Next).

% index, length, parity of length, num of trailing 0 in bin presentation of length
?- wr_len.
1       1       odd     0
2       2       even    1
3       2       even    1
4       4       even    2
5       6       even    1
6       6       even    1
7       8       even    3
8       10      even    1
9       14      even    1
10      20      even    2
11      26      even    1
12      34      even    1
13      46      even    1
14      62      even    1
15      78      even    1
16      102     even    1
17      134     even    1
18      176     even    4
19      226     even    1
20      302     even    1
21      408     even    3
22      528     even    4
23      678     even    1
24      904     even    3
25      1182    even    1
26      1540    even    2
27      2012    even    2
28      2606    even    1
29      3410    even    1
30      4462    even    1
31      5808    even    4
32      7586    even    1
33      9898    even    1
34      12884   even    2
35      16774   even    1
36      21890   even    1
37      28528   even    4
38      37158   even    1
39      48410   even    1
40      63138   even    1
41      82350   even    1
42      107312  even    4
43      139984  even    4
44      182376  even    3
45      237746  even    1
46      310036  even    2
47      403966  even    1
48      526646  even    1
49      686646  even    1
50      894810  even    1
51      1166642 even    1
52      1520986 even    1
53      1982710 even    1
54      2584304 even    4
55      3369156 even    2
56      4391702 even    1
57      5724486 even    1
58      7462860 even    2
59      9727930 even    1
ERROR: Out of global stack
% I added a few "strategic" cuts (`!`) to get so far.

可读性：

get_next([], []).
get_next(Current, Next) :-
    get_next_sub(0, _, Current, Next).

get_next_sub(Length, Digit, [Digit|Tail], Result) :-
    get_next_sub(Length+1, Digit, Tail, Result).
get_next_sub(Length, Digit, Further, Result) :-
    number_to_list(10*Length+Digit, Result, ResultTail),
    get_next(Further, ResultTail).

number_to_list(Number, Result, Accumulator) :-
    0 is Number -> Result = Accumulator;
    Digit is Number mod 10,
    number_to_list(Number // 10, Result, [Digit|Accumulator]).

get_previous(Stop, Current, Result) :-
    get_next(Current, Next),
    (   Next = Stop
    ->  Result = Current
    ;   get_previous(Stop, Next, Result)
    ).

get_prev_or_next(Input, Result) :-
    length(Input, Length),
    (   1 is Length mod 2
    ->  get_next(Input, Result)
    ;   get_previous(Input, [1], Result)
    ).
— 凯对SE感到失望
source
3

Python：139个字符

import re
f=lambda s:''.join(['len(b)'+a for a,b in re.findall(r'((\d)\2*)',s)] if len(s)%2 else map(lambda a,b:b*int(a),s[::2],s[1::2]))

单个测试用例

print f('1111122221111222112')
>>> 514241322112
print f('514241322112')
>>> 1111122221111222112
— Averykhoo
source
您可以从删除的空间s)] if来s)]if。
— Bakuriu 2014年
您也可以删除两者之间的空间2 else
— Beta Decay，2014年
3

Haskell中，134 128 115

n=length
l x=x#mod(n x)2
(a:b:c)#0=replicate(read[a])b++c#0
(a:b)#1=(\(c,d)->show(1+n c)++a:d#1)$span(==a)b
_#_=[]

如果需要从标准输入/输出，添加main=interact l于150个144 131总字符。该函数称为l。

*Main> putStr . unlines $ map (\x->x++":\t"++l x) ([replicate n '1'|n<-[5..10]]++map show [0,6..30]++map show [n*n+n|n<-[2..10]])
11111:  51
111111: 111
1111111:    71
11111111:   1111
111111111:  91
1111111111: 11111
0:  10
6:  16
12: 2
18: 8
24: 44
30: 000
6:  16
12: 2
20: 00
30: 000
42: 2222
56: 66666
72: 2222222
90: 000000000
110:    2110
— 扎克
source
您能否提供用法示例？在l "11"上班时，我遇到了一个例外l "111"l "1111111111111"
— Paul Guyot
@PaulGuyot，似乎要解决的问题是减少了我的成绩。谢谢:-)
— Zaq 2014年
3

Perl-98字节

所有这些控制语句的大小使我感到烦恼，但我对正则表达式的工作方式感到非常满意。

($_)=@ARGV;if(length()%2){$\=$&,s/^$&+//,print length$&while/^./}else{print$2x$1while s/^(.)(.)//}

未压缩：

($_)=@ARGV;
if(length()%2)
{
$\=$&, #Assigning the character to $\ causes it to be appended to the print (thanks, tips thread!)
s/^$&+//, #Extract the string of characters
print length$& #Print its length
while/^./ #Get next character into $&
}else{
print$2x$1
while s/^(.)(.)//
}
— 宝马
source
2

埃尔朗（205）

f(L)->g(L,L,[]).
g([A,B|T],L,C)->g(T,L,lists:duplicate(A-$0,B)++C);g([],_,R)->R;g(_,L,_)->i(L,[]).
h([A|T],A,N,B)->h(T,A,N+1,B);h(L,B,N,C)->i(L,integer_to_list(N)++[B|C]).
i([H|T],A)->h(T,H,1,A);i(_,R)->R.

主要功能是f，将输入作为Erlang字符串，并将输出也作为字符串返回。

f("11"). % returns "1"
f("111"). % returns "31"
f("1111111111111"). % returns "131"

通过删除9个以上相同字符的大小写要求，可以使该函数缩短15个字节（190）。f调用g递归计算前任元素，并且如果字符数为奇数（在计算结束时找到），则调用i与配对的函数h，计算下一个元素。

— 保罗·盖奥特
source
2

哈斯克尔（105）

import Data.List
l=length
c r|odd$l r=group r>>=(l>>=(.take 1).shows)|x:y:z<-r=[y|_<-['1'..x]]++c z|0<1=r

我认为这很好，事实证明它不使用任何辅助功能:-)。

— 骄傲的哈斯克勒
source
|x:y:z<-r-我完全不知道你能做到。这太酷了！
— Flonk 2014年
@Flonk它称为“图案卫士”。它曾经是扩展，在Haskell的一个版本中添加了:-)
— 骄傲的haskeller 2014年
这使很多事情变得容易得多。你每天学习新的东西！:)
— Flonk
2

APL（45）

∊{2|⍴⍵:(⊃,⍨⍕∘⍴)¨⍵⊂⍨1,2≠/⍵⋄/⍨∘⍎/¨⌽¨⍵⊂⍨1 0⍴⍨⍴⍵}

是的，即使∊在外部，这也是有效的函数定义。

      ∊{2|⍴⍵:(⊃,⍨⍕∘⍴)¨⍵⊂⍨1,2≠/⍵⋄/⍨∘⍎/¨⌽¨⍵⊂⍨1 0⍴⍨⍴⍵}'513211'
111112221
      ∊{2|⍴⍵:(⊃,⍨⍕∘⍴)¨⍵⊂⍨1,2≠/⍵⋄/⍨∘⍎/¨⌽¨⍵⊂⍨1 0⍴⍨⍴⍵}'111112221'
513211
      f←∊{2|⍴⍵:(⊃,⍨⍕∘⍴)¨⍵⊂⍨1,2≠/⍵⋄/⍨∘⍎/¨⌽¨⍵⊂⍨1 0⍴⍨⍴⍵}
      f ¨ '513211' '111112221'
┌─────────┬──────┐
│111112221│513211│
└─────────┴──────┘
— 马里纳斯
source
2

Java 7，分数= 252 235字节

是的，它又是java。世界上最糟糕的高尔夫语言。这种方法使用字符串。Java支持任意大的整数，但是将需要更多的空间来编写代码。

致电f(intputString)。返回相应的字符串。

打高尔夫球：

String f(String a){char[]b=a.toCharArray();a="";int i=0,j=0,d=0,e=b.length;if(e%2==0)for(;i<e;i+=2)for(j=0;j<b[i]-48;j++)a+=b[i+1];else{for(;i<e;i++)d=d==0?(j=b[i]-48)*0+1:b[i]-48!=j?(a+=d+""+j).length()*--i*0:d+1;a+=d;a+=j;}return a;}

高尔夫扩展了结构代码：

public class LookAndSayExpandedGolfed{

    public static void main(String[] args){
        System.out.println(new LookAndSayExpandedGolfed().f(args[0]));
    }

    String f(String a){
        char[]b=a.toCharArray();
        a="";
        int i=0,j=0,d=0,e=b.length;
        if(e%2==0)
            for(;i<e;i+=2)
                for(j=0;j<b[i]-48;j++)
                    a+=b[i+1];
        else{
            for(;i<e;i++)
                d=d==0?(j=b[i]-48)*0+1:b[i]-48!=j?(a+=d+""+j).length()*--i*0:d+1;
            a+=d;
            a+=j;
        }
        return a;
    }

}

部分打高尔夫球：

public class LookAndSayPartiallyGolfed{

    public static void main(String[] args){
        System.out.println(new LookAndSayPartiallyGolfed().f(args[0]));
    }

    String f(String a){
        char[] number = a.toCharArray();
        String answer = "";
        int i, j, longestStreakLength = 0;
        if (number.length % 2 == 0){
            for (i = 0; i < number.length; i += 2)
                for (j = 0; j < number[i] - 48; j++)
                    answer += number[i+1];
        } else{
            j = 0;
            for (i = 0; i < number.length; i++)
                longestStreakLength = longestStreakLength == 0 ? (j = number[i] - 48) * 0 + 1 : number[i] - 48 != j ? (answer += longestStreakLength + "" + j).length()*--i*0 : longestStreakLength + 1;
            answer += longestStreakLength;
            answer += j;
        }
        return answer;
    }

}

完全扩展：

public class LookAndSay{

    public static void main(String[] args){
        System.out.println(new LookAndSay().function(args[0]));
    }

    String function(String a){
        char[] number = a.toCharArray();
        if (number.length % 2 == 0){
            String answer = "";
            for (int i = 0; i < number.length; i += 2){
                for (int j = 0; j < number[i] - '0'; j++){
                    answer += number[i+1];
                }
            }
            return answer;
        }
        String answer = "";
        int longestStreakLength = 0;
        int longestStreakNum = 0;
        for (int i = 0; i < number.length; i++){
            if (longestStreakLength == 0){
                longestStreakNum = number[i] - '0';
                longestStreakLength = 1;
                continue;
            }
            if (number[i] - '0' != longestStreakNum){
                answer += longestStreakLength;
                answer += longestStreakNum;
                longestStreakLength = 0;
                i--;
            } else {
                longestStreakLength++;
            }
        }
        answer += longestStreakLength;
        answer += longestStreakNum;
        return answer;
    }

}

要运行，请首先使用以下命令编译第二个条目： javac LookAndSayExpandedGolfed.java

然后运行： java LookAndSayExpandedGolfed

编辑：修复错误。

— 头号
source
不适用于我Exception in thread "main" java.lang.StringIndexOutOfBoundsException: String index out of range: 4 at java.lang.String.charAt(String.java:658)
— Octavia Togami
@KenzieTogami固定。
— TheNumberOne
我不这么认为，--1应该是--i吗？
— Octavia Togami 2014年
@KenzieTogamie是的。现在已修复。
— TheNumberOne 2014年
太好了，那行得通。但是，反向器失败。513211-> 11111。
— Octavia Togami 2014年
1

Javascript（浏览器，ES5，IE8 +），152

var s=prompt(),r='',n=r,c=r,i=0;do{c!=s[i]?(r+=n+c,n=1,c=s[i]):n++;i++}while(c)n='';i=0;while(s[i]){n+=Array(1*s[i]+1).join(c=s[i+1]);i+=2}alert(c?n:r)

如果您跳过var，可以缩短4个字符，或者与其他中间无变量的全局变量一起再缩短几个字符，但是让我们假装一分钟我们还不错。

使用参数和返回值切换到ES6短语法功能，而不是使用提示，IO警报可以节省更多。

JSFiddle在这里：http : //jsfiddle.net/86L1w6Lk/

— 用户名
source
5
不用担心那些var...我们都是“坏程序员”。;）
— Martin Ender 2014年
1

Python 3-159字节

import re;l=input();x=len;print(''.join([str(x(i))+j for i,j in re.findall('((.)\2*)',l)]if x(l)%2 else[j*int(i)for i,j in[l[i:i+2]for i in range(0,x(l),2)]]))
— Beta衰变
source
1

眼镜蛇-217

（186，如果我可以假设其他地方存在的use声明System.Text.RegularExpressions）

do(s='')=if((l=s.length)%2,System.Text.RegularExpressions.Regex.replace(s,(for x in 10 get'[x]+|').join(''),do(m=Match())="['[m]'.length]"+'[m]'[:1]),(for x in 0:l:2get'[s[x+1]]'.repeat(int.parse('[s[x]]'))).join(''))
— 巨大
source
1

JavaScript（ES6）85

使用正则表达式替换为函数。根据输入长度是偶数还是奇数，不同的正则表达式和不同的功能。

F=s=>s.replace((i=s.length&1)?/(.)(\1*)/g:/../g,x=>i?x.length+x[0]:x[1].repeat(x[0]))
— edc65
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.