Conway 시퀀스 (일명 'look-and-say'-sequence) 에 익숙해 져야합니다 .

     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 시퀀스의 다음 요소를 계산합니다.
• 입력 문자열 길이가 짝수 인 경우 위에서 정의한대로 입력 문자열의 선행 작업을 계산합니다 .

바이트 단위의 최단 코드가 이깁니다.

모양과 순서에 따른 최근 질문 :

• 보고 말하기 순서
• 포인트없는 모양과 말 순서
• 룩앤 세이 시퀀스의 n 번째 항의 길이를 빠르게 찾습니다.

CJam, 46 45 44 43 42 바이트

l_,2%{0\{@)@@_2$=!{0\0}*;}*\)\}{2/{(~*}%}?

여기에서 테스트하십시오. STDIN의 숫자를 사용하여 결과를 STDOUT에 인쇄합니다.

루비, 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
}

프롤로그-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] .

이 시퀀스 에는 길이 가 홀수 인 하나의 길이 인 것처럼 보입니다 [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)
    ).

파이썬 : 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

하스켈 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
_#_=[]

stdin / stdout에서 가져와야하는 경우 추가 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

펄-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/^(.)(.)//
}

에를 랑, 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다음 요소를 계산하는 함수 를 호출합니다 .

하스켈, 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

도우미 기능을 사용하지 않는 것이 좋습니다. :-).

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│
└─────────┴──────┘

자바 7, 점수 = 252 235 바이트

네, 다시 자바입니다. 세계에서 최악의 골프 언어. 이 방법은 문자열을 사용합니다. 임의의 큰 정수는 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

편집 : 오류 수정.

자바 스크립트 (브라우저 내, 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 개의 문자를 줄이거 나 다른 중간 값의 글로벌이 아닌 문자를 몇 개 더 줄이면 1 분 동안 나쁜 프로그래머가 아니라고 가정 해 봅시다.

프롬프트를 사용하는 대신 인수 및 반환 값을 사용하여 ES6 짧은 구문 기능으로 전환하면 IO에 대한 경고로 더 많은 것을 절약 할 수 있습니다.

여기 JSFiddle : http://jsfiddle.net/86L1w6Lk/

파이썬 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)]]))

코브라-217

(내가 다른 곳에 존재 한다고 use진술 할 수 있다면 186 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(''))

자바 스크립트 (ES6) 85

정규식을 사용하면 함수로 대체됩니다. 입력 길이가 짝수인지 홀수인지에 따라 다른 정규 표현식과 다른 기능.

F=s=>s.replace((i=s.length&1)?/(.)(\1*)/g:/../g,x=>i?x.length+x[0]:x[1].repeat(x[0]))