চেহারা এবং বলুন: কনওয়ে পুনরায় দেখা হয়েছে

Question

আপনার এখনই কনওয়ের সিকোয়েন্স (ওরফে 'চেহারা-এবং-বলুন'-সিকোয়েন্স) এর সাথে পরিচিত হওয়া উচিত :

     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।

লক্ষ্য

একটি ফাংশন / প্রোগ্রাম স্নিপেট লিখুন যা অঙ্কের একটি স্ট্রিংটিকে ইনপুট হিসাবে স্বীকার করে

• যদি ইনপুট স্ট্রিংয়ের দৈর্ঘ্য হয় তবে কনওয়ে ক্রমের পরবর্তী উপাদান গণনা করে element বিজোড়
• উপরের হিসাবে সংজ্ঞায়িত যদি ইনপুট স্ট্রিং দৈর্ঘ্য হল ইনপুট স্ট্রিং এর পূর্বসুরী হিসাব এমনকি ।

বাইটস মধ্যে সংক্ষিপ্ত কোড।

চেহারা এবং বলার ক্রমগুলির উপর ভিত্তি করে সাম্প্রতিক প্রশ্নগুলি:

• ক্রম দেখুন এবং বলুন
• বিন্দু মুক্ত চেহারা এবং ক্রম বলুন
• তাত্ক্ষণিকভাবে বর্ণন এবং বলার অনুক্রমের n-th পদের দৈর্ঘ্যের সন্ধান করুন

Comments

আমি বিভ্রান্ত তুমি কেমন ব্যাখ্যা করতে পারবেন 513111মধ্যে ভাগ 51, 32এবং 11?

— চটজলদি ossifrage

আমি মনে করি এটি কিছু চেহারা এবং সম্মিলিত চ্যালেঞ্জ এবং একটি রান-দৈর্ঘ্যের ডিকোডিং চ্যালেঞ্জের সম্মিলিত সদৃশ (আমি নিশ্চিত যে আমাদের সেগুলি ছিল)।

— মার্টিন ইন্ডার

পূর্বসূরীর কি হবে 11111111111111? আপনার অনুমান অনুসারে, এটি হবে 1111111। এর জন্য যুক্তিসঙ্গত উত্তর সংজ্ঞায়িত করার জন্য আপনার স্পেসিফিকেশনটি পরিবর্তন করতে হবে।

— TheNumberOne

@সেরাটা 11111111111111 কেবলমাত্র পূর্বসূরী নেই। এটি একটি অবৈধ ইনপুট।

— কে ই

@ দ্য বেস্টওন হ্যাঁ এটি সঠিক, আমি পূর্বসূরির জন্য একটি স্বেচ্ছাচারিত নিয়ম সংজ্ঞায়িত করেছি যা সর্বদা 'আসল' পূর্বসূরীর সাথে মেলে না।

— flawr

Answer 1

সিজেম, 46 45 44 43 42 বাইট

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

এটি এখানে পরীক্ষা করুন। এটি STDIN- তে নম্বর নেয় এবং ফলাফলটি STDOUT এ মুদ্রণ করে।

Comments

si-> ~= 45

— অপ্টিমাইজার

@ অপ্টিমাইজার ধন্যবাদ, আমি ভুলে গেছি আপনি একটি চরিত্র আবিষ্কার করতে পারেন।

— মার্টিন ইন্ডার

Answer 2

রুবি, 125 120 119 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
}

Answer 3

প্রোলোগ - 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)
    ).

Answer 4

পাইথন: ১৩৯ টি চর

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

Comments

আপনি স্থানটি সরিয়ে নিতে s)] ifপারেন s)]if।

— বাকুরিউ

আপনি এর মধ্যে থাকা 2 else

— বিটা ডেকাই

Answer 5

হাস্কেল, 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

Comments

আপনি দয়া করে ব্যবহারের উদাহরণ প্রদান করতে পারেন? আমি যখন l "11"কাজ করতে গিয়েছিলাম তখন আমি এর সাথে l "111"বাl "1111111111111"

— পল গিয়ট

@ পলগুইট, আমার স্কোর থেকে কয়েক অক্ষর কেটে ফিক্সিংয়ের মতো মনে হচ্ছে। ধন্যবাদ :-)

— Zaq

Answer 6

পার্ল - 98 বাইট

এই সমস্ত কন্ট্রোল স্টেটমেন্টের আকার আমাকে বাগড করে, কিন্তু রেজিক্সগুলি কীভাবে কাজ করেছিল তাতে আমি খুব খুশি।

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

uncompressed:

($_)=@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/^(.)(.)//
}

Answer 7

এরলং, 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("11"). % returns "1"
f("111"). % returns "31"
f("1111111111111"). % returns "131"

9 টিরও বেশি অভিন্ন অক্ষরের ক্ষেত্রে প্রয়োজনীয়তা বাদ দিয়ে ফাংশনটি 15 বাইট সংক্ষিপ্ত (190) করা যায়। পূর্ববর্তী পূর্ববর্তীকে পুনরাবৃত্তির সাথে গণনা করে এমন fকলগুলি gএবং যদি অক্ষরের সংখ্যা বিজোড় হয় (গণনা শেষ হয় তখন পাওয়া যায়), এটি ফাংশনটিকে কল করে iযা জোড় করা হয়েছে h, পরবর্তী উপাদানটির গণনা করে।

Answer 8

হাস্কেল, 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

আমি মনে করি এটির কোনও দুর্দান্ত সহায়ক :-) ব্যবহার না করে এটি চমৎকার হয়েছে out

Comments

|x:y:z<-r- আমি পুরোপুরি জানতাম না যে আপনি এটি করতে পারবেন। এটা খুব উপভোগ্য!

— ফ্লোন্ক

@ ফ্লোনক এটিকে "প্যাটার্ন গার্ড" বলা হয়। এটি একটি এক্সটেনশন হিসাবে ব্যবহৃত হত এবং

— হাসকলের

এটি অনেক কিছুই এত সহজ করে তোলে। প্রতিদিনই আপনি কিছু নতুন শিখছেন! :)

— ফ্লোন্ক

Answer 9

এপিএল (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│
└─────────┴──────┘

Answer 10

জাভা 7, স্কোর = 252 235 বাইট

হ্যাঁ, এটি আবার জাভা; বিশ্বের সবচেয়ে খারাপ গল্ফিং ভাষা। এই পদ্ধতির স্ট্রিং ব্যবহার করে। যথেচ্ছভাবে বড় পূর্ণসংখ্যার সমর্থন করা হয় তবে কোডে আরও অনেক বেশি জায়গা লাগবে take

সাথে কল f(intputString)। সংশ্লিষ্ট স্ট্রিং প্রদান করে।

Golfed:

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

সম্পাদনা: স্থির ত্রুটি।

Comments

আমার জন্য কাজ করে না,Exception in thread "main" java.lang.StringIndexOutOfBoundsException: String index out of range: 4 at java.lang.String.charAt(String.java:658)

— অক্টোবিয়া টোগামি

পুনঃটুইট

— TheNumberOne

আমার মনে হয় না, এমনটা --1হওয়ার কথা --i?

— অষ্টাভিয়া তোগামি

@ কেনজি টোগামি হ্যাঁ, এটি। এটি এখন স্থির।

— TheNumberOne

শীতল, যে কাজ করে। বিপরীতে ব্যর্থ, তবে। 513211-> 11111।

— অষ্টাভিয়া তোগামী

Answer 11

জাভাস্ক্রিপ্ট (ইন-ব্রাউজার, 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)

আপনি চারটি বাদ দিয়ে 4 অক্ষর দ্বারা সংক্ষিপ্ত হতে পারে, বা অন্যান্য মধ্যবর্তী অবিশ্বাস্য গ্লোবালগুলি সহ আরও কয়েকটি অক্ষর, তবে ভান করা যাক আমরা এক মিনিটের জন্য খারাপ প্রোগ্রামার নই।

প্রম্পট ব্যবহারের পরিবর্তে আর্গুমেন্ট এবং রিটার্ন মান সহ ES6 সংক্ষিপ্ত-সিনট্যাক্স ফাংশনে স্যুইচ করা আইও-এর সতর্কতা আরও বাঁচাতে পারে।

জেএসফিডেল এখানে: http://jsfiddle.net/86L1w6Lk/

Comments

এইগুলি নিয়ে চিন্তা করবেন না var... আমরা সবাই এখানে "খারাপ প্রোগ্রামার"। ;)

— মার্টিন এন্ডার

Answer 12

পাইথন 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)]]))

Answer 13

কোবরা - 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(''))

Answer 14

জাভাস্ক্রিপ্ট (ES6) 85

নিয়মিত অভিব্যক্তি ব্যবহার করে ফাংশনটি প্রতিস্থাপন করুন। ইনপুট দৈর্ঘ্য সমান বা বিজোড়ের উপর নির্ভর করে আলাদা আলাদা রেজিপ্স এবং বিভিন্ন ফাংশন।

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