Meydan okuma

Bu soru için göreviniz, bir tamsayı girdi dizisini, o dizideki her tamsayı ikinci oluşumunda bölmektir.

Yeterince net değil misiniz? İşte size yardımcı olacak bir örnek

Giriş dizisi:

[2 1 1 2 3 2 2 4 5 6 7 3 7 0 5]

Çıktı:

[[2 1] [] [3 2 2 4 5 6 7] [] [0] []]

Açıklama:

Aşağıda, ikinci öğenin kalın olarak vurgulandığı dizi verilmiştir:

[2 1 1 2 3 2 2 4 5 6 7 3 7 0 5 ]

Şimdi bölme dizi bloklarını şu kalın ikinci olayların etrafına koyduk:

[2 1] 1 [] 2 [3 2 2 4 5 6 7] 3 [] 7 [0] 5 []

ve finali elde etmek için bu bölünmüş dizileri bir diziye sarın

[[2 1] [] [3 2 2 4 5 6 7] [] [0] []]

Bitişik ikinci oluşumlar gerçekleştiğinde boş diziler olacağını unutmayın.

kurallar

Her zamanki gibi, tam bir program veya girdi dizisini STDIN, ARGV veya işlev argümanı aracılığıyla alan bir işlev yazmanız gerekir.

Giriş

Giriş, herhangi bir uygun dizi (veya dizi benzeri) formatından oluşur.

Örneğin, aşağıdakilerden herhangi biri kabul edilebilir:

2 1 1 1 4 5 6
[2 1 1 1 4 5 6]
[2, 1, 1, 1, 4, 5, 6]

Çıktı

STDOUT'a çıkış yaparken diziniz herhangi bir uygun (iç içe) dizi biçiminde de yazdırılabilir, örn.

[[2 1] [1 4 5 6]]
[[2, 1], [1, 4, 5, 6]]
{{2, 1}, {1, 4, 5, 6}}

(Bu genellikle dizilerinizdeki dizilerin yerel dize temsili olacaktır.)

Ayrıca, boş dizilerin dizinin parçası olarak yazdırılması gerektiğini unutmayın.

puanlama

Bu kod golf bayt kazanmak çok kısa kod!

25 APL

1↓¨(1,∨⌿<\2=+\∘.=⍨a)⊂1,a←

Misal:

]display 1↓¨(1,∨⌿<\2=+\∘.=⍨a)⊂1,a←2 1 1 2 3 2 2 4 5 6 7 3 7 0 5
┌→──────────────────────────────────────┐
│ ┌→──┐ ┌⊖┐ ┌→────────────┐ ┌⊖┐ ┌→┐ ┌⊖┐ │
│ │2 1│ │0│ │3 2 2 4 5 6 7│ │0│ │0│ │0│ │
│ └~──┘ └~┘ └~────────────┘ └~┘ └~┘ └~┘ │
└∊──────────────────────────────────────┘

Eski olan:

{1↓¨(1,(⍳⍴⍵)∊,{1↑1↓⍵}⌸⍵)⊂1,⍵}

Bu, Dyalog APL v14 ile tanıtılan ana operatör (⌸) için güzel bir soru. Sol bağımsız değişken işlevini ({1 ↑ 1 ↓ ⍵}) alır ve her benzersiz bağımsız değişken için bu bağımsız değişken için vektördeki indeksleri verir. Burada ikinci indeks alıyorum, o zaman ben bu listede ((⍳⍴⍵) ∊) hangi indeksleri kontrol ve orijinal vektör bölmek için ortaya çıkan boole kullanın.

Buradan çevrimiçi olarak denenebilir:

http://tryapl.org

APL (Dyalog 14) (31)

{1↓¨(1,(⍳⍴⍵)∊2⍳⍨¨↓+\∘.=⍨⍵)⊂0,⍵}

Bu, bir dizi alan ve iç içe bir dizi döndüren bir işlevdir.

Ölçek:

      +V← {1↓¨(1,(⍳⍴⍵)∊2⍳⍨¨↓+\∘.=⍨⍵)⊂0,⍵} 2 1 1 2 3 2 2 4 5 6 7 3 7 0 5
┌───┬┬─────────────┬┬─┬┐
│2 1││3 2 2 4 5 6 7││0││
└───┴┴─────────────┴┴─┴┘
      ⍝ this return value is a real nested array:
      ⎕←'Length: ',⍴V ⋄ (⍳⍴V){⎕←'Array #',⍺,': (', ⍵, ')'}¨V 
Length:  6
Array # 1 : ( 2 1 )
Array # 2 : ()
Array # 3 : ( 3 2 2 4 5 6 7 )
Array # 4 : ()
Array # 5 : ( 0 )
Array # 6 : ()

Açıklama:

• 0,⍵: Daha kolay işlem için 0ön tarafına bir ekleyin ⍵. (Bir olay olarak sayılmaz.)
• (... )⊂: Diziyi verilen bit maskesine göre bölün. 1Bitmaskinde her birinden yeni bir grup başlar .
  • +\∘.=⍨⍵: (orijinal) içindeki her değer için ⍵, içindeki tüm oluşumları bulun ⍵. Ardından, her bir değer için bir koşu toplamı yapın ve her bir konum için ⍵her bir değerin kaçının zaten meydana geldiğini gösteren bir kare matris verin .
  • ↓: Matrisi satırlarına göre bölün ve her bir değere, her bir konumun kaç kez meydana geldiğini gösteren bir dizi verin.
  • 2⍳⍨¨: Bu dizilerin her birinde birincinin dizinini bulun 2.
  • (⍳⍴⍵)∊: İçine olası her dizin için ⍵, ikinci olayların endeksleri listesinde bulunup bulunmadığına bakın. (Bunlar ilk grup hariç her grubu başlatır.)
  • 1,: 1İlk grubun başlangıcını işaretleyerek öne bir tane ekleyin .
• 1↓¨: Her gruptan ilk elemanı kaldırın. (Bunlar katma 0değer ve her bir değerin ikinci oluşumudur.)

J, 28 24 karakter

Randomra'ya özel teşekkürler .

(1&,<;._1~1,2=+/@(={:)\)

Bu şekilde çalışır. \Giriş dizisinin tüm öneklerinde ( ) +/@, önekin kaç ( ) öğesinin o önekin son öğesine ( ={:) eşit olduğuna bakarız . Bu sayı 2 olduğunda, bunun dizideki öğenin ikinci tekrarlanması olduğunu biliyoruz, bu nedenle diziyi orada kullanarak ayırıyoruz <;._1.

   a=.2 1 1 2 3 2 2 4 5 6 7 3 7 0 5
   (={:)\ a
1 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 1 0 0 0 0 0 0 0 0 0 0 0 0 0
0 1 1 0 0 0 0 0 0 0 0 0 0 0 0
1 0 0 1 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 1 0 0 0 0 0 0 0 0 0 0
1 0 0 1 0 1 0 0 0 0 0 0 0 0 0
1 0 0 1 0 1 1 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 1 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 1 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 1 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 1 0 0 0 0
0 0 0 0 1 0 0 0 0 0 0 1 0 0 0
0 0 0 0 0 0 0 0 0 0 1 0 1 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 1 0
0 0 0 0 0 0 0 0 1 0 0 0 0 0 1
   +/@(={:)\ a
1 1 2 2 1 3 4 1 1 1 1 2 2 1 2

Sıralama hileler kullanılarak Eski şey: (1&,<;._1~1,1=i.~(]-{)/:@/:).

Mathematica, 58 51 49 bayt

Rest/@SplitBy[(f@#=0;#)&/@{a}~Join~#,++f[#]==3&]&

Bu isimsiz bir işlevdir.

Rest/@SplitBy[(f@#=0;#)&/@{a}~Join~#,++f[#]==3&]&[{2,1,1,2,3,2,2,4,5,6,7,3,7,0,5}]

gibi bir iç içe liste döndürür

{{2, 1}, {}, {3, 2, 2, 4, 5, 6, 7}, {}, {0}, {}}

Nasıl çalışır

Bu biraz belirsiz bir sihir kullanır SplitBy.

Bir fonksiyondaki her sayının oluşumlarını takip ediyorum f. Mathematica'da, her giriş için bir fonksiyonun değerini ayrı ayrı tanımlayabilirsiniz ve olası tüm girişler için değer belirtmeniz gerekmez (daha çok steroidlerdeki bir karma tablo gibi).

Bu yüzden fgirişte bulunan değerler için 0'a başlayarak başladım (f@#=0;#)&/@.

Şimdi SplitBy"aynı değeri vermek ardışık elemanlarının çalışır oluşan alt listelere böler listesini bir liste ve bir işlevi ve alır f(not uygulanır" SplitBydeğil kaldırmak herhangi elemanları). Ancak (belgesiz) yakalama, her bir öğe üzerinde iki kezf denir - selefi ve halefi ile karşılaştırıldığında. Yani eğer yaparsak

 SplitBy[{1,2,3,4},Print]

her sayıyı bir kez almıyoruz, bunun yerine bu baskı

 1
 2
 2
 3
 3
 4

ki bu 3 karşılaştırma için 6 çağrıdır.

Eğer her zaman geri dönen ancak ikinci bir olay önceki öğeyle karşılaştırıldığında dönen bir işlev yazarsak, listeyi her ikinci olaydan önce bölebiliriz . Bu, o öğe üzerindeki üçüncü kontroldür (ilk olayda iki kontrol, artı ikinci olayda ilk kontrol). Dolayısıyla kullanıyoruz . Güzel şey, bu art arda ikinci oluşumun ikinci kontrolünde tekrar dönüyor , böylece art arda ikinci oluşumlar için geri dönebiliyorum , ancak yine de aralarında bölünüyor . Aynı şekilde, bu olmaz bölünmüş sonra işlev zaten döndürdüğü için, ikinci geçtiği ikinci çeke tekrar.FalseTrue++f[#]==3&FalseTrueFalse

Şimdi, soru bu ikinci olayları da kaldırmamızı istiyor, bu yüzden ilk öğeyi her listeden bırakıyoruz Rest/@. Ancak elbette, girişteki ilk öğeyi kaldırmak istemiyoruz, bu yüzden alistenin başına bir öğe ekleyerek aslında başlıyoruz {a}~Join~#. aMathematica'nın bilinmeyen olarak davrandığı tanımsız bir değişkendir, bu nedenle diğer değerlerini etkilemez f. Bu aynı zamanda girişteki ilk gerçek elemanın diğer kontroller gibi iki kontrolünü almasını sağlar .

Python, 148 bayt

def s(a):z=len(a);x=[-1]+sorted({[i for i in range(z)if a[i]==n][1]for n in a if a.count(n)>1})+[z];return[a[x[i]+1:x[i+1]]for i in range(len(x)-1)]

Oldukça korkunç bir çözüm. Daha iyi bir yol olmalı ...

İle arayın s([2, 1, 1, 1, 4, 5, 6]).

Ungolfed sürümü

def split(array):
  indices = [-1]
  second_occurrences = set()

  for n in array:
      if array.count(n) > 1:
          occurrences = [i for i in range(len(array)) if array[i] == n]
          second_occurrences.add(occurrences[1])

  indices += sorted(second_occurrences)
  indices += [len(array)]

  return [array[indices[i]+1:indices[i+1]] for i in range(len(indices)-1)]

Haskell, 115 113 106 88

f?(x:s)|1<-f x=[]:x%f?s|a:b<-x%f?s=(x:a):b
f?x=[x]
(x%f)h=sum$f h:[1|x==h]
r s=(\_->0)?s

bu, her elementin bir fonksiyon olarak ortaya çıktığı miktarı, ilgili miktarlarına kadar saklar, bu da ilginç bir numaradır.

bu %, f işlevi ve bağımsız değişken veren xbir işlev f, farklıysa bağımsız değişkenine uygulanan döndüren yeni bir işlev döndürür xve1 + f x döndürerek çalışır.

örneğin, 3 % const 0bu 1. döndürdüğü 3 hariç her değişken için, 0 döndüren bir işlevdir : güncelleme kaynaşık foldlçok daha küçük bir programı almak için.

Ruby 66 demosu

f=->a{c=Hash.new 0
r=[[]]
a.map{|e|2==(c[e]+=1)?r<<[]:r[-1]<<e}
r}

Bir diziyi parametre olarak alan ve bir dizi dizi döndüren Ruby stabby lambda.

Python: 100 bayt

def g(l):
 i=j=0;o=[]
 for e in l:
  if l[:i].count(e)==1:o+=[l[j:i]];j=i+1
  i+=1
 return o+[l[j:]]

Kolay çözüm. Liste üzerinde tekrar ediyorum, bir karakterin daha önce kaç kez göründüğünü sayıyorum ve son kontrolden bu yana parçayı çıktı listesine ekliyorum.

Yakut, 66

f=->a{s=Hash.new 0
r=[[]]
a.map{|e|(s[e]+=1)==2?r<<[]:r[-1]<<e}
r}

açıklama

• eher öğe için bir yineleme sayım rkarmasıdır, sonucun saklandığı bir Dizi'dir.
• Girdi boyunca döngü yapın, her eleman için oluşum sayısını artırın 1.
  • Oluşma sayısı ise 2, bölünmemiz gerekir. ArraySonuca bir boşluk ekleyin .
  • Aksi takdirde, öğeyi sonuçtaki sonuncuya eklemeniz Arrayyeterlidir.

CJam, 25 24 bayt

q~{_L+:L1$a/,3=S@?}%Sa/p

STDIN'den girdi alır

[ 2 1 2 1 0 2 2 1 1 3 4 3]

ve çıktılar

[[2 1] "" [0 2 2 1 1 3 4] ""]

Temelde dizinin tüm elemanları üzerinde teker teker onları başka bir diziye koyarak iterating. Sonra diğer dizideki geçerli öğenin sayısını alıyorum. 2 ise, o yerden başka bir dizi başlatmak. Bu tür rastgele dizi başlangıcı yalnızca yığın tabanlı bir dilde gerçekleştirilebilir.

Kod genişletme :

q~{_L+:L1$a/,3=S@?}%Sa/p
q~{               }%             "Evaluate the input array and map it on this block";
   _                             "Copy the current element in iteration";
    L+:L                         "Add the copy to an initially blank array L and update L";
        1$a/                     "Make another copy of the element and split L on it";
            ,3=                  "This checks if the splitted array is of length 3";
                                 "which indirectly means that L contains the element twice";
               S@?               "If the above is true, replace the element by space";
                    Sa/          "Split the final array on space. This final array contains";
                                 "second occurrence of every integer replaced by a space";
                       p         "Print the stringified version of the final nested array";

Buradan çevrimiçi deneyin

Martin sohbetinin ucundan 1 bayt kaydedildi

Ruby, 64 bayt

s=->a{x=[];b=[[]];a.map{|e|x<<e;x.count(e)==2?b<<[]:b[-1]<<e};b}

Perl 5: 36

Burada gerçek bir bölünme olmadığı için bunun kabul edilebilir olup olmadığından emin değilim.

#!perl -pa
$x{$_}++-1or$_=']['for@F;$_="[[@F]]"

Misal:

$ perl spl.pl <<<"2 1 1 2 3 2 2 4 5 6 7 3 7 0 5"
[[2 1 ][ ][ 3 2 2 4 5 6 7 ][ ][ 0 ][]]

CJam, 28 bayt

Lq~{1$1$a/,3=S2$?@++}/-2%S/`

STDIN gibi girişi alır

[2 1 1 2 3 2 2 4 5 6 7 3 7 0 5]

ve çıktıyı STDOUT'a benzer şekilde yazdırır

[[2 1] "" [3 2 2 4 5 6 7] "" [0] ""]

Boş dizelerin ve boş dizilerin CJam'de aynı şey olduğunu ve ""varsayılan olarak görüntülendiklerini unutmayın (bu , boş dizilerin yerel temsilidir).

(Zorluk gönderilmeden önce bunun üzerinde çalışmaya başladım, çünkü zorluğun ne kadar zor olacağını tartışıyorduk.)

açıklama

Temel olarak, ikinci olay olmadığı sürece dizideki her öğeyi çoğaltırım, bu durumda ilk kopyayı bir boşlukla değiştiririm. Golf nedeniyle, bu değiştirilmiş dizi tersine inşa edilmiştir. Böylece [2 1 1 2 3 2 3]olur

[3 S 2 2 3 3 2 S 1 S 1 1 2 2]

Daha sonra orijinal dizisi olan her ikinci öğeyi seçiyorum, ancak ikinci oluşumlar boşluklarla değiştirildi, yani

[2 1 S S 3 2 S]

Sonunda diziyi boşluklara ayırdım. İşte kodun dökümü:

L                            "Push empty array.";
 q~                          "Read STDIN an evaluate.";
   {                }/       "For each element of the input.";
    1$1$                     "Copy the array and the element.";
        a/                   "Split the array by that element.";
          ,3=                "Check that it's split into 3 parts.";
             S2$?            "If so, push a space, else, copy the current number.";
                 @++         "Pull up the array from the bottom and add both to the beginning.";
                      -2%    "Pick every second element from the end.";
                         S/  "Split on spaces.";
                           ` "Get the string representation.";

Unix araçları, 100 bayt

grep -o '[-0-9]*'|awk '{print(++A[$0]-2)?$0:"] ["}'|paste -sd' '|sed -e '/]/s/.*/[\0]/' -e's//[\0]/'

Stdin ile girişi hariç tutar. Temel olarak sadece her ikinci olayın yerine geçer "] [". Boş dizeleri ile çalışmaz, boş []bir dizinin uygun bir temsili olduğunu düşünüyorum boş bir dize verecektir :)

APL, 42 karakter

{'(',')',⍨⍵[(2=+/¨(↑=↓)¨⌽¨,\⍵)/⍳⍴⍵]←⊂')('}

Misal:

{'(',')',⍨⍵[(2=+/¨(↑=↓)¨⌽¨,\⍵)/⍳⍴⍵]←⊂')('}2 1 1 2 3 2 2 4 5 6 7 3 7 0 5

Çıktı:

( 2 1  )(   )(  3 2 2 4 5 6 7  )(   )(  0  )(  )

Burada test edildi.

APL'de tam olarak doğru yapı olarak yorumlanan bir dize çıkarmam gerekirse ... 49 karakter

{'1↓1(',',⍬)',⍨⍵[(2=+/¨(↑=↓)¨⌽¨,\⍵)/⍳⍴⍵]←⊂',⍬)('}

Java, 223

Bu yalnızca Oracle veya OpenJDK JRE'de çalışır, çünkü bu uzunluğun değişken uzunluklu arkasını uygulamak için arkada nicelik belirleyici ve uzunluk kontrolü uygulamalarında kullanıyorum.

class W{public static void main(String a[]){System.out.print("["+new java.util.Scanner(System.in).nextLine().replaceAll(" *\\b(\\d+)\\b(?=(.*))(?<=^(?=(.*\\b\\1\\b){2}\\2).*)(?<!^(?=(.*\\b\\1\\b){3}\\2).*) *","] [")+"]");}}

İşin çoğu, aşağıda ham formda gösterilen normal ifade ile yapılır:

 *\b(\d+)\b(?=(.*))(?<=^(?=(.*\b\1\b){2}\2).*)(?<!^(?=(.*\b\1\b){3}\2).*) *

Yukarıdaki regex'e bakmadan önce, değişken uzunluktaki geriye bakmayı doğrudan desteklediğinden, daha basit olan eşdeğer .NET regex'e bakalım (.NET arkası büyük olasılıkla sağdan sola eşleme modu tarafından yapılır) :

 *\b(\d+)\b(?<=(.*\b\1\b){2})(?<!(.*\b\1\b){3}) *

•  *\b(\d+)\bve  *sonunda bir sayı ve çevresindeki boşluklarla (varsa) eşleşir. Bağlı kontroller, her iki taraftaki boşluklar isteğe bağlı olduğundan kısmi sayının eşleşmesini önlemek içindir. Ayrıca, dizideki 2. görünüm olup olmadığını kontrol etmek için sayıyı yakalar.

• (?<=(.*\b\1\b){2})yukarıda yakalanan sayının 2 örneğinin bulunup bulunmadığını kontrol eder. (?<!(.*\b\1\b){3})yakalanan numaranın 3 örneğinin bulunup bulunmadığını kontrol eder. Her iki koşul da bir araya getirildiğinde, sayının şu ana kadar sadece 2 örneği olduğunu ileri sürmektedir. Sınırlı kontroller, tam sayının test edildiğinden emin olmak için vardır.

Java sürümüne geri dönün. Değişken uzunlukta bir görünüm uygulamak için,

(?<=var-length-pattern)

için

(?<=^(?=.*var-length-pattern).*)

^{.Çizgi ayırıcıları hariç tutan gerçeğiyle ilgili biraz el sallıyorum , ancak kolayca düzeltilebilir ve sözdizimini daha da karmaşıklaştırmak istemiyorum.}

İleriye bakma her zaman 0 uzunluktadır ve *nicelik belirleyicinin uygulanması nedeniyle uzunluk kontrolü geçer .

^O iş yapmak için gerekli değildir, ancak başarısız vaka daha hızlı başarısız yapmak yoktur. Oracle / OpenJDK uygulamasında geriye bakma, desenin minimum uzunluğunun geri çekilmesiyle yapılır, daha sonra eşleştirilir, daha sonra bir eşleşme bulunana kadar veya en kötü durumda desenin maksimum uzunluğuna kadar uzunluk artırılarak durulanır ve tekrarlanır. . İle ^, önek dizesinin yalnızca bir kez eşleştiğinden emin olurum.

Ancak, geriye bakmanın içindeki ileriye bakma, geriye bakmanın sağ sınırı ile sınırlı değildir, bu nedenle dizenin sonuna kadar eşleşebilir. Sınırı iddia etmek için, dizenin geri kalanını ileriye baktığınız bir başka yakalama grubuna yakalarım ve değişken uzunluk deseninin saltanatını sınırlamak için kullanıyorum.

(?=(.*))(?<=^(?=.*var-length-pattern\m).*)
   ^--^                              ^
   mth capturing group               m is the number of the capturing group marked

Desenim zaten başladığından .*, .*önüne başka bir şey eklemem gerekmiyor .

Perl 108

map{$e[$_]==1?do{push@a,[@b];@b=();}:push@b,$_;$e[$_]++}split" ";push@a,[@b];s/.*/Data::Dumper->Dump(\@a)/e;

Eylemde:

perl -MData::Dumper -pe '
    $Data::Dumper::Terse = 1;
    $Data::Dumper::Indent = 0;
    @a=@b=@e=();
    map{$e[$_]==1?do{push@a,[@b];@b=();}:push@b,$_;$e[$_]++}split" ";
    push@a,[@b];
    s/.*/Data::Dumper->Dump(\@a)/e;
' <<<$'2 1 1 2 3 2 2 4 5 6 7 3 7 0 5\n2 1 1 1 4 5 6\n'"$(
    sed 's/./& /g;w/dev/stderr' <<< ${RANDOM}${RANDOM}${RANDOM}$'\n'${RANDOM}${RANDOM})"
2 4 4 7 7 2 9 8 8 4 6 0 1 8 
1 0 3 9 3 7 9 
[2,1][][3,2,2,4,5,6,7][][0][]
[2,1][1,4,5,6]
[2,4][7][][9,8][4,6,0,1,8]
[1,0,3,9][7][]

Not: İki ilk satır $Data::...sadece daha güzel sunum için ve üçüncü satır @a=@b=@e=();ise aracın birden çok satır üzerinde çalışmasını sağlamak için var.

R, 76

y=scan();r=split(y,cumsum(ave(y,y,FUN=seq)==2));c(r[1],lapply(r[-1],"[",-1))

Örnek için çıktı: Üç boş vektör içeren beş öğeden oluşan bir liste. ( numeric(0)).

$`0`
[1] 2 1

$`1`
numeric(0)

$`2`
[1] 3 2 2 4 5 6 7

$`3`
numeric(0)

$`4`
[1] 0

$`5`
numeric(0)

Bu arada: Kod, yok sayılabilecek bir uyarı iletisi oluşturur.

awk 29

a[$1]++==1{print"-";next}1

Bu, girdi ve çıktı biçimleriyle biraz özgürlük gerektirir. "Dizi" girişi dikeydir, her satıra bir sayı. Çıktı ayrıca, satırları ayıran kesik çizgilerle satır başına bir sayı olmak üzere dikeydir.

Giriş:

2
1
1
2
3
2
2
4
5
6
7
3
7
0
5

Çıktı:

2
1
–
–
3
2
2
4
5
6
7
–
–
0
–

Pyth 30 32

Bu benim ilk kez Pyth'i deniyor. Python çözümümle aynı çözüm.

VQIq/<QN@QN1~Y]:QZN=ZhN;+Y]>QZ

Çevrimiçi deneyebilirsiniz: Pyth Compiler / Executor

Örneğin girdi

[2,1,1,2,3,2,2,4,5,6,7,3,7,0,5]

yazdıracak

[[2, 1], [], [3, 2, 2, 4, 5, 6, 7], [], [0], []]

Açıklama:

                                 # Q = input(), Y = [], Z = 0
VQ                               # for loop: N iterates over the indices of Q
  I                              # if 
   q\<QN@QN1                     #    Q[N] appears exactly once in Q[:N]
            ~Y]:QZN              #         append the list [Q[Z:N]] to Y
                   =ZhN          #         and assign Z = N + 1
                       ;         # end if and for loop
                        +Y]>QZ   # print Y + [Q[Z:]]

Python 2, 84

l=[[]];p=[]
for x in input():p+=[x];b=p.count(x)==2;l+=[[]]*b;l[-1]+=[x][b:]
print l

Liste lşu ana kadar çıktıdır. Elemanlar üzerinde tekrarlıyoruz. Geçerli olan ikinci görünümse, yeni bir boş alt liste başlatırız; aksi takdirde en son alt listeye ekleriz. Şimdiye kadar görülen öğelerin listesi içinde saklanıyor p. Garip bir şekilde, listeyi yeniden yapılandırmak girdiyi dilimlemekten daha kısa görünüyor.

Saf bash 111 94

81 sadece bölme için:

for i;do [ "${b[i]}" == 7 ]&&c+=("${d# }") d=||d+=\ $i;b[i]+=7;done;c+=("${d# }")
declare -p c

İkinci satır declare -p csadece değişken

Örneklem:

splitIntFunc() {
    local b c d i
    for i;do
        [ "${b[i]}" == 7 ]&&c+=("${d# }") d=||d+=\ $i
        b[i]+=7
      done
    c+=("${d# }")
    declare -p c
}

Not: hat local b c d isadece işlevi birkaç kez çalıştırmak için gereklidir.

splitIntFunc 2 1 1 2 3 2 2 4 5 6 7 3 7 0 5
declare -a c='([0]="2 1" [1]="" [2]="3 2 2 4 5 6 7" [3]="" [4]="0" [5]="")'

splitIntFunc 2 1 1 1 4 5 6
declare -a c='([0]="2 1" [1]="1 4 5 6")'

splitIntFunc $(sed 's/./& /g;w/dev/stderr' <<<${RANDOM}${RANDOM}${RANDOM})
1 6 5 3 2 2 4 3 9 4 2 9 7 7 4 
declare -a c='([0]="1 6 5 3 2" [1]="4" [2]="9" [3]="2" [4]="7" [5]="4")'

splitIntFunc $(sed 's/./& /g;w/dev/stderr' <<<${RANDOM}${RANDOM}${RANDOM})
2 4 5 2 9 1 1 4 8 7 8 1 0 3 
declare -a c='([0]="2 4 5" [1]="9 1" [2]="" [3]="8 7" [4]="1 0 3")'

En seksi sunum için (+26)

splitIntFunc() {
    local b c d i
    for i;do
        [ "${b[i]}" == 7 ]&&c+=("${d# }") d=||d+=\ $i
        b[i]+=7
      done
    c+=("${d# }")
    printf -v l "(%s) " "${c[@]}"
    echo "<$l>"

Şunun gibi bir şey oluşturur:

splitIntFunc 2 1 1 2 3 2 2 4 5 6 7 3 7 0 5
<(2 1) () (3 2 2 4 5 6 7) () (0) () >

splitIntFunc $(sed 's/./& /g;w/dev/stderr' <<<${RANDOM}${RANDOM}${RANDOM})
4 3 8 1 4 5 7 9 2 7 8 4 0 
<(4 3 8 1) (5 7 9 2) () (4 0) >

splitIntFunc $(sed 's/./& /g;w/dev/stderr' <<<${RANDOM}${RANDOM}${RANDOM})
3 1 3 0 2 5 3 6 6 9 2 5 5 
<(3 1) (0 2 5 3 6) (9) () (5) >

splitIntFunc $(sed 's/./& /g;w/dev/stderr' <<<${RANDOM}${RANDOM}${RANDOM})
2 2 2 9 1 9 5 0 2 2 7 6 5 4 
<(2) (2 9 1) (5 0 2 2 7 6) (4) >


}

Scala, 122 111

Karakter koleksiyonunu alın [21][][3224567][][0][], 122 111 biçiminde yazdırın :

def s(a:Any*)=print((("[","")/:a){case((b,c),d)=>if(b.indexOf(d)==c.indexOf(d))(b+d,c)else(b+"][",c+d)}._1+"]")

... ya da bir karakter koleksiyonu alın ve iç içe listeler döndürün, 135 129:

def s(a:Char*)=(("",List(List[Any]()))/:a){case((b,c),d)=>b+d->(if(b.count(d==)==1)List()::c else(c.head:+d)::c.tail)}._2.reverse

Eminim alabileceğim bazı tasarruflar var, çok fazla bakmadım.

Python 220 bayt

Aşağıda 220 bayt, diğerlerine kıyasla büyük değil, ancak daha büyük tamsayılarla yeterince hızlı çalışıyor!

xlist = list(input()); result = []; x = 0
for i in range(len(xlist)):
    if xlist[0:i+1].count(xlist[i]) == 2: result.append(xlist[x:i]);x = i+1
    elif i == len(xlist)-1: result.append(xlist[x:])
print(result)

Java: 563 bayt

Bu Java 8 kullanır, ön-JDK8 foreach nedeniyle birkaç bayt daha uzun olacağını unutmayın.

import java.util.*;public class a{static String c(String[]b){List<String>d=new ArrayList<>(Arrays.asList(b));Set<String>e=new HashSet<>();Set<String>f=new HashSet<>();for(int i=0;i<Integer.MAX_VALUE;i++){String g;try{g=d.get(i);}catch(IndexOutOfBoundsException ex){break;}
if(e.contains(g)&&!f.contains(g)){d.remove(i);d.add(i,"]");d.add(i+1,"[");f.add(g);i++;}else{e.add(g);}}
d.add(0,"[[");d.add(d.size(),"]]");StringBuilder sb=new StringBuilder();d.forEach(sb::append);return sb.toString();}
public static void main(String[]args){System.out.println(c(args));}}