1桁の最長の繰り返し部分シーケンス


17

チャレンジ:

正の整数を指定すると、少なくとも2回発生する最長の1桁のサブシーケンスを出力し、ANDには別の桁(または整数の開始/終了)の境界があります。

例:

入力:7888885466662716666
1桁の最長サブシーケンスは、長さが5の888887[88888]5466662716666)になります。ただし、このサブシーケンスは整数で1回しか発生しません。
代わりに、入力のために結果が7888885466662716666あるべきである666678888854[6666]271[6666]それは二倍(少なくとも)が発生するので、)。

チャレンジルール:

  • サブシーケンスの長さは、発生する回数よりも優先されます。(つまり、入力の8888858888866656665666場合、出力88888[88888]5[88888]66656665666;長さ5、2回発生します)ではなく、66688888588888[666]5[666]5[666];長さ3、3回発生します)。
  • 複数のサブシーケンスの長さが等しい場合、発生回数が最大のサブシーケンスを出力します。入力に、即ち3331113331119111、我々出力111333[111]333[111]9[111];長さ3は、3回発生する)、およびいない333[333]111[333]1119111;ならびに長さ3が、2回出現)
  • 複数のサブシーケンスの出現回数と長さが等しい場合、それらのいずれか、またはすべてを(任意の順序で)出力できます。777333777333つまり、inputの場合、可能な出力は次のとおり777です。333; [777, 333]; または[333, 777]
  • サブシーケンスには、他の数字(または整数の開始/終了)の境界が必要です。すなわち、入力の場合122222233433、結果は331222222[33]4[33];長さ2、2回発生します)ではなく2221[222][222]33433、長さ3、両方とも無効で2回発生します)。
    • これは、オカレンスカウンターにカウントされるすべての数値に適用されます。811774177781382つまり、入力の場合、結果は8[8]117741777[8]13[8]2;長さ1、3回発生します)ではなく77811[77]41[77]781382/ 811[77]417[77]81382;長さ2、無効な1回で2回発生)、18[1][1]774[1]7778[1]382;長さ1、無効な2回で4回発生)です。
  • 入力に数字が含まれないと想定できます0(一致します[1-9]+)。(これは、ほとんどの言語がデフォルトで出力する10002000outputのようなテストケースを処理する必要を避けるためです。)0000
  • 入力には常に少なくとも1つの有効な出力が含まれると想定できます。
  • I / Oは両方とも柔軟です。リスト/配列/数字/バイト/文字のストリーム、または単一の整数ではなく文字列として指定できます。

一般的なルール:

  • これはであるため、バイト単位の最短回答が優先されます。
    コードゴルフ言語では、非コードゴルフ言語で回答を投稿しないようにしてください。「任意の」プログラミング言語の可能な限り短い答えを考えてみてください。
  • 回答には標準的な規則が適用されるため、STDIN / STDOUT、適切なパラメーターと戻り値型、完全なプログラムを備えた関数/メソッドを使用できます。あなたの電話。
  • デフォルトの抜け穴は禁止されています。
  • 可能であれば、コードのテストへのリンクを追加してください。
  • また、回答の説明を追加することを強くお勧めします。

テストケース:

Input:  7888885466662716666 / [7,8,8,8,8,8,5,4,6,6,6,6,2,7,1,6,6,6,6]
Output: 6666                / [6,6,6,6]

Input:  3331113331119111 / [3,3,3,1,1,1,3,3,3,1,1,1,9,1,1,1]
Output: 111              / [1,1,1]

Input:            777333777333                   / [7,7,7,3,3,3,7,7,7,3,3,3]
Possible outputs: 777; 333; [777,333]; [333;777] / [7,7,7]; [3,3,3]; [[7,7,7],[3,3,3]]; [[3,3,3],[7,7,7]]

Input:  122222233433 / [1,2,2,2,2,2,2,3,3,4,3,3]
Output: 33           / [3,3]

Input:  811774177781382 / [8,1,1,7,7,4,1,7,7,7,8,1,3,8,2] 
Output: 8               / [8]

Input:  555153333551 / [5,5,5,1,5,3,3,3,3,5,5,1] 
Output: 1            / [1]

Input:            12321              / [1,2,3,2,1]
Possible outputs: 1; 2; [1,2]; [2,1] / [1]; [2]; [[1],[2]]; [[2],[1]]

Input:  944949949494999494 / [9,4,4,9,4,9,9,4,9,4,9,4,9,9,9,4,9,4]
Output: 4                  / [4]

Input:  8888858888866656665666 / [8,8,8,8,8,5,8,8,8,8,8,6,6,6,5,6,6,6,5,6,6,6]
Output: 88888                  / [8,8,8,8,8]

Input:  1112221112221111               / [1,1,1,2,2,2,1,1,1,2,2,2,1,1,1,1]
Output: 111; 222; [111,222]; [222,111] / [1,1,1]; [2,2,2]; [[1,1,1],[2,2,2]]; [[2,2,2],[1,1,1]]

Input:  911133111339339339339339 / [9,1,1,1,3,3,1,1,1,3,3,9,3,3,9,3,3,9,3,3,9,3,3,9]
Output: 111                      / [1,1,1]

1
推奨されるテストケース:8888858888866656665666。チャレンジを正しく解釈すると、Brachylogと05AB1Eの両方のソリューションが失敗します。
Xcoder氏18

@ Mr.Xcoder追加、ありがとう。
ケビンクルーイッセン

@Arnauldうーん、とにかく勝者の1人になり222ます。他の整数で区切られている場合と同じくらいの頻度で発生するからです。の部分文字列であるオカレンスを数えるべきではないと思い1111ます。確かに、OPを待つ方がましです。
Xcoder氏18

2
@Arnauld 1112221112221111これらはサブとその数は次のとおりです。1111 (1)111 (2)222 (2)。我々は唯一の二回、少なくとも存在する配列を出力するので、出力はのいずれかになります111222[111,222][222,111]。(いくつかの詳細については、第四のルールを参照してください。)基本的に1111しかとしてカウントされます1111、そしてないと11111111。私はあなたのテストケースを追加しますが、出力はいずれか、または両方である111とします222
ケビンクルーイッセン

回答:


6

05AB1E、14バイト

γТ1›ÏD€gZQÏ.M

オンラインでお試しください!

説明

γ                # group consecutive equal elements
 Т              # count the occurrence of each group among the list of groups
   1›Ï           # keep only groups with a count greater than 1
      D€gZQÏ     # keep only those with a length equal to the greatest length
            .M   # get the most common item

@Riley:残念ながら、必ずしも最も一般的な要素ではない最初の要素が取得されます。
エミグナ

おっと..その弾丸を逃した。
ライリー

5

ゼリー、12バイト

Œgœ-Q$LÐṀÆṃ'

オンラインでお試しください!

以前のバージョン-14バイト

ŒgŒQ¬TịƲLÐṀÆṃ'

オンラインでお試しください!

使い方?

Œgœ-Q$LÐṀÆṃ' – Full program. Receives a list of digits as input.
Œg           – Group equal adjacent values.
  œ-Q$       – Multiset difference with itself deduplicate.
      LÐṀ    – Keep those that are maximal by length.
         Æṃ' – Mode. Returns the most common element(s).
-------------------------------------------------------------------------
ŒgŒQ¬TịƲLÐṀÆṃ' – Full program. Receives a list of digits as input.
Œg             – Group equal adjacent values.
  ŒQ           – Distinct sieve. Replace the first occurrences of each value by 1.
                 and the rest by 0. [1,2,3,2,3,2,5]ŒQ -> [1,1,1,0,0,0,1]       
    ¬T         – Negate and find the truthy indices.
      ịƲ       – Then index in the initial list of groups.
               – This discards the groups that only occur once.
        LÐṀ    – Find all those which are maximal by length.
           Æṃ' – And take the mode.

5

JavaScript(ES6)、79 73 68バイト

入力を文字列として受け取ります。整数を返します。

s=>[...s,r=q=0].map(o=d=>q=s^d?o[!o[q]|r[q.length]?q:r=q]=s=d:q+d)|r

オンラインでお試しください!

コメント済み

s =>                      // s = input string, also used as the current digit
  [ ...s,                 // split s into a list of digit characters
    r =                   // r is the final result
    q =                   // q is the current digit sequence
    0                     // append a final dummy entry to force the processing of the last
  ]                       // sequence
  .map(o =                // o is an object used to keep track of encountered sequences
       d =>               // for each digit d in the array defined above:
    q =                   //   update q:
      s ^ d ?             //     if d is not equal to the current digit:
        o[                //       this statement will ultimately update o[q]
          !o[q] |         //         if q has not been previously seen
          r[q.length] ?   //         or the best result is longer than q:
            q             //           leave r unchanged
          :               //         else:
            r = q         //           set r to q
        ] = s = d         //       reset q to d, set the current digit to d
                          //       and mark q as encountered by setting o[q]
      :                   //     else:
        q + d             //       append d to q
  ) | r                   // end of map(); return r, coerced to an integer

ここで何か間違っていると言っているかもしれませんが...s、入力を数字文字のリストに変換するので、文字列ではなく、入力を数字文字のリストとして取得する方が短くありませんか?柔軟なI / Oを許可しました。(しかし、それはあなたのコードの別の部分と干渉すると仮定していますか?)
ケビンCruijssen

2
@KevinCruijssen問題は、最後のシーケンスを処理するために追加の反復が必要なことです。既にリストになっ[...s,0]ている場合でも、そうする必要sがあります。
アーナルド

4

網膜、56バイト

L`(.)\1*
O`
L$m`^(.+)(¶\1)+$
$#2;$1
N`
.+;

N$`
$.&
-1G`

オンラインでお試しください!リンクにはテストケースが含まれます。説明:

L`(.)\1*

最大限に繰り返される数字サブシーケンスをすべてリストします。

O`

リストを順番に並べ替えます。

L$m`^(.+)(¶\1)+$
$#2;$1

すべての複数のサブシーケンスを「カウント」とともにリストします。

N`

カウントの昇順で並べ替えます。

.+;

カウントを削除します。

N$`
$.&

長さの昇順で並べ替えます。(長さが等しい場合、カウントによる以前の順序は保持されます。)

-1G`

最後の、つまり最長の値を保持します。


4

R、102バイト

function(i)rep(names(sort(-(x=(x=table(rle(i)))[rowSums(x>1)>0,,drop=F])[m<-max(rownames(x)),])[1]),m)

オンラインでお試しください!

Rの回答がまだなかったので、試してみることにしました。それが良いアプローチであるかどうかは本当にわかりませんが、ここではそれを行います。

文字のベクトルを入力および出力します。


このチャレンジでは、Rには100バイト近くがかなり適しています。
ngm



3

Powershell、101バイト

($args|sls '(.)\1*'-a|%{$_.Matches}|group|?{$_.Count-1}|sort @{e={$_.Name.Length,$_.Count}})[-1].Name

説明されたテストスクリプト:

$f = {

(
    $args|          # for each argument (stings)
    sls '(.)\1*'-a| # searches all
    %{$_.Matches}|  # regex matches
    group|          # group it (Note: Count of each group > 0 by design)
    ?{$_.Count-1}|  # passthru groups with Count not equal 1
    sort @{         # sort all groups by 2 values
        e={$_.Name.Length,$_.Count}
    }
)[-1].Name          # returns name of last group (group with max values)

}

@(
    ,('7888885466662716666', '6666')
    ,('3331113331119111', '111')
    ,('777333777333', '777','333')
    ,('122222233433', '33')
    ,('811774177781382', '8')
    ,('555153333551','1')
    ,('12321', '1','2')
    ,('944949949494999494','4')
    ,('8888858888866656665666','88888')
    ,('1112221112221111','111','222')
) | % {
    $s,$e = $_
    $r = &$f $s
    "$($r-in$e): $r"
}

出力:

True: 6666
True: 111
True: 777
True: 33
True: 8
True: 1
True: 1
True: 4
True: 88888
True: 111


3

Haskell、72バイト

import Data.Lists
g!x|y<-countElem x g=(y>1,1<$x,y)
(argmax=<<(!)).group

使い方

(argmax=<<(!)).group       -- expands to: f i = argmax (group i !) (group i)
    group                  -- split the input list into subsequences of equal digits
                           -- e.g. "1112211" -> ["111","22","11"]

                           -- find the element of this list where the function !
                           -- returns the maximum value. First parameter to !
                           -- is the grouped input list, second parameter the
                           -- the element to look at 

g!x|
    y<-countElem x g       -- let y be the number of occurrences of x in g
  = (  ,   ,  )            -- return a triple of
     y>1                   -- a boolean y>1  (remember: True > False)  
        1<$x               -- length of x (to be exact: all elements in x
                           -- replaced by 1. This sorts the same way as the
                           -- length of x)
             y             -- y
                           -- a triples sorts lexicographical

Data.Listsはベースの一部ではないため、Haskell +リストを言語として使用する必要はありませんか?
ბიმო

@BWO:わからない。エキゾチックなライブラリをインポートしたときでも(たとえばGloss、グラフィカルな出力やMatrix)、私はいつもプレーンな「Haskell」を使用していました。インポートのバイトカウントを含めたくない場合は、「Haskell + something」を使用します。メタに関するこのトピックはあったと思いますが、もう見つけられません。正しく覚えていれば、「標準ライブラリ」の一般的な定義はありませんでした。Haskellのリファレンスは何ですか?Haskell Report、GHCのベース、Haskell Plattform、他に何かありますか?
nimi

IMOは、C / JavaScript /のようになります。実装がPPCGの言語を指定するため、Haskell(GHC)またはHaskell(Hugs)などを使用する必要があること重要な場合)。だから、のためのGHCのベースが含まれるであろうし、他のすべてのもののために私が知っているだろう答え:D
ბიმო

おそらくテストできるようにTIOリンクを持っていますか?またはData.Lists、TIOまたは別のオンラインHaskellコンパイラでライブラリを利用できませんか?
ケビンクルーッセン

1
@KevinCruijssen:Data.ListsTIOにはyes がありません。このバージョンでテストできます。
nimi

3

R、85バイト

function(x,R=rle(x),a=ave(R$v,R,FUN=length))rep(R$v[o<-order(a<2,-R$l,-a)[1]],R$l[o])

オンラインでお試しください!

  • 入力:分離された整数桁のベクトルc(1,8,8...)

  • 出力:分離された整数桁のベクトル

説明付きの展開されていないコード:

function(x){                # x is a vector of digits : e.g. c(1,1,8,8,1,1)

R = rle(x)                  # Get the sequences of consecutive repeating digits
                            # doing run length encoding on x, i.e. : R is a list
                            # with the digits (R$values) and the number of their
                            # consecutive occurrencies (R$lengths)
                            # N.B. you can use R$v for R$values and R$l for R$lenghts

a=ave(R$v,R,FUN=length)     # Group R$v by R$l AND R$v, count the occurrencies 
                            # for each group and "unroll" the value of each 
                            # group to the original R$v length.
                            # Here basically we count the occurrencies of the same 
                            # sequence.

o<-order(a<2,-R$l,-a)[1]    # Get the indexes used to order by a < 2 then by -R$l and
                            # finally by -a; store the first index in "o".
                            # Here basically we use order to select the first sequence 
                            # repeated at least twice, in case of ties the sequence 
                            # with the greatest length and in case of ties the most 
                            # repeated sequence.

rep(R$v[o],R$v[o])          # Using the index "o", we reconstruct the sequence repeating
                            # R$l[o] times R$v[o]
}

整数または文字数字のベクトルを受け入れる代替バージョン:

R、88バイト

function(x,R=rle(x),a=ave(R$v,R,FUN=length))rep(R$v[o<-tail(order(a>1,R$l,a),1)],R$l[o])

オンラインでお試しください!

  • 入力:分離された文字または数字のベクトル例c("1","8","8"...)またはc(1,8,8...)

  • 出力:入力が文字のベクトルである場合は分離された文字のベクトル、入力が数字のベクトルである場合は数字のベクトル


説明を追加できますか?私はそれがどのように機能しているか理解していません。
JayCe

@JayCe:できました!(私はあなたがよく知っている詳細を追加しました、非Rユーザーのためだけです;))
digEmAll

ty!今では理にかなっています。
JayCe

2

256 250バイト

func[s][p: func[b][sort parse b[collect[any keep[copy a skip thru any a]]]]first
last sort/compare collect[foreach d p p s[if 1 < k: length? to-block d[keep/only
reduce[form unique d k]]]]func[x y][(reduce[length? x/1 x/2])< reduce[length? y/1 y/2]]]

オンラインでお試しください!

今回は本当に長い解決策です...(ため息)

入力を文字列として受け取ります。

説明:

f: func [ s ] [
    p: func [ b ] [                        ; groups and sorts the adjacent repeating items
        sort parse b [ 
            collect [                      
                any keep[
                    copy a skip thru any a ; gather any item, optionally followed by itself  
                ]
            ]
        ]
    ]
    t: copy []
    foreach d p p s [                     ; p p s transforms the input string into a block of sorted blocks of repeating digits
        if 1 < k: length? to-block d [    ; filters only the blocks that occur more than once
            insert/only t reduce [ form unique d k ] ; stores the digits and the number of occurences
                                          ; "8888858888866656665666" -> [["5" 3] ["666" 3] ["88888" 2]]
        ]
    ]
    first last sort/compare t func [ x y ] ; takes the first element (the digits) of the last block of the sorted block of items
        [ (reduce [ length? x/1 x/2 ]) < reduce [ length? y/1 y/2 ] ] ; direct comparison of the blocks
]

2

Java(JDK 10)、213バイト

s->{int l=99,X[][]=new int[10][l],d,D=0,m=0,M=0;for(var x:s.split("(?<=(.))(?!\\1)"))X[x.charAt(0)-48][x.length()]++;for(;M<1&&l-->1;)for(d=0;d++<9;)if((m=X[d][l])>1&m>M){M=m;D=d;}for(;l-->0;)System.out.print(D);}

オンラインでお試しください!

説明(古い)

s->{                                    // Lambda for Consumer<String>
 int l=99,                              //  Length of token, max is 99.
     X[][]=new int[10][l],              //  Array containing the occurrences per token
     d,                                 //  digit value
     D=0,                               //  digit holder for best sequence candidate
     m=0,                               //  holder of the current candidate
     M=0;                               //  best candidate for the current length of token.
 for(var x:s.split("(?<=(.))(?!\\1)"))  //  Tokenize the string into digit-repeating sequences
  X[x.charAt(0)-48][x.length()]++;      //   Add one occurrence for the token
 for(;M<1&&l-->1;)                      //  While no value has been found and for each length, descending. Do not decrease length if a value has been found.
  for(d=0;d++<9;)                       //   for each digit
   if((m=X[d][l])>1&m>M){               //    if the current occurrence count is at least 2 and that count is the current greatest for the length
    M=m;D=d;                            //     mark it as the current best
   }                                    //
 for(;l-->0;)System.out.print(D);       //  Output the best-fitting subsequence.
}                                       // 

クレジット


1
j*o>M小切手に小さな欠陥があると思います。私が正しく理解している場合、最大値を取りますlength * occurrence-count。しかし、1113311133933933933933たとえば、テストケースの場合111は、(3 * 2 = 6)となり、33(2 * 6 = 12)となります。したがって、少なくとも2回発生するのでは33なく、最高の発生を出力します111。また、Java 10でvar r="";for(;O-->0;)r+=D;return r;ゴルフすることfor(;O-->0;)System.out.print(D);も、Java 11でさらに短くすることもできますreturn(D+"").repeat(O);
ケビンクルーッセン

@KevinCruijssen私はそれを修正したと思う。
オリヴィエグレゴワール

1
それは確かに良く見え、同時にバイトをゴルフする素晴らしい方法です。説明を更新するのを忘れました。そして、さらに1バイト変更int X[][]=new int[10][99],d,l=99,してゴルフすることができますint l=99,X[][]=new int[10][l],d,
ケビンクルーッセン

1
@KevinCruijssenありがとう!また、のd++<9代わりに書くことでもう1バイトバイトしました++d<10。残りはごめんなさい:今日はかなり疲れています= _ =
オリビエグレゴワール

2

ルビー68 67バイト

->a{(b=a.chunk &:+@).max_by{|x|[(c=b.count x)<2?0:x[1].size,c]}[1]}

オンラインでお試しください!

文字の配列を入出力します。

アプローチは非常に簡単です:連続した数字の実行を識別し(単位関数としてchunk単項+を使用)、最大値を取得します-最初に実行のサイズ(発生回数が2未満の場合はゼロにリセット)、次にカウント自体によって。


2

PCRE、152バイト

(\d)(?<!(?=\1)..)(?=(\1*)(?!\1).*(?!\1).\1\2(?!\1))(?!(?:(?=\2((\3?+)(\d)(\5*)))){1,592}?(?=\2\3.*(?!\5).\5\6(?!\5))(?:\1(?=\1*\4\5(\7?+\5)))*+(?!\1))\2

https://regex101.com/r/0U0dEp/1の実際の動作を参照してください(各テストケースの最初の一致を確認してください

正規表現はそれ自体では実際のプログラミング言語ではなく、ソリューションは制限されているため、これは単なる楽しみのためです:P

幅がゼロのグループ(?:)+は1回だけ一致し、無期限に繰り返されないため、PCREは制限付きで定量化されたグループのコピーを内部で作成するため、そこにマジックナンバー( "{1,592}")を使用する必要がありました。つまり、最大592個の連続する数字セットを先に見て、現在検査中のものよりも長くなる可能性がある競合セットを見つけることができます。このコンセプトの詳細はこちら


1

Perl 5、88バイト

my($m,%s);++$i%2*$s{$_}++&&($n=$s{$_}/9+length)>$m&&($a=$_,$m=$n)for pop=~/((.)\2*)/g;$a

オンラインでお試しください!

テストを少し行った:

sub f {
  my($m,%s);
  my($i,$n,$a);           #not needed in golfed version
  ++$i % 2  *  $s{$_}++
  && ($n=$s{$_}/9+length) > $m
  && ($a=$_, $m=$n)
    for pop=~/((.)\2*)/g; #i.e. 7888885466662716666 => 7 88888 5 4 6666 2 7 1 6666
  $a
}
for(map[/\d+/g],split/\n/,join"",<DATA>){ #tests
  my($i,@e)=@$_;
  printf "%-6s   input %-24s   expected %-10s   got %s\n",
    (grep f($i) eq $_, @e) ? "Ok" : "Not ok", $i, join('|',@e), f($i);
}
__DATA__
Input:  7888885466662716666     Output: 6666
Input:  3331113331119111        Output: 111
Input:  777333777333            Output: 777|333
Input:  122222233433            Output: 33
Input:  811774177781382         Output: 8
Input:  555153333551            Output: 1
Input:  12321                   Output: 1|2
Input:  944949949494999494      Output: 4
Input:  8888858888866656665666  Output: 88888
Input:  1112221112221111        Output: 111|222

1

Wolfram言語(Mathematica)、67バイト

#&@@@MaximalBy[Select[Tally@Split@#,Last@#>1&],{Length@#,#2}&@@#&]&

純粋な機能。入力として数字のリストを受け取り、出力としてサブシーケンスのリストを(順不同で)返します。「少なくとも2回出現する必要があります」句をよりきれいに処理できるかどうかは不明 オンラインでお試しください!


1
おそらくTIOリンクを追加できますか?
ケビンクルーイッセン

本当に主張する場合...
LegionMammal978

弊社のサイトを使用することにより、あなたは弊社のクッキーポリシーおよびプライバシーポリシーを読み、理解したものとみなされます。
Licensed under cc by-sa 3.0 with attribution required.