Biz bir dize olduğunu söylemek -olmayan ayrımcı dize ait karakterlerin her biri en az iki kez aynı sayıda görünür ve eğer.

Örnekler

• "aa!1 1 !a !1"edilir olmayan ayrımcı karakterlerin her çünkü , !, ave 1üç kez görünür.
• "abbaabb"ayrım gözetmeyen bir şey değildir , çünkü daha sık görülür .ba
• "abc"ayrıca değil ayrımcı olmayan karakterler en az iki kez görünmüyor çünkü.

Görev

Belirli bir dize ayırt edici değilse , aksi takdirde sahte bir değer varsa, ayrımcı olmayan bir program veya işlev yazın .

Diğer bir deyişle, kendi kaynak koduyla çalışan program bir gerçeği döndürmelidir.

Her gönderim, yazdırılabilir ASCII içeren boş olmayan dizelerin yanı sıra gönderimin kaynak kodunda görünen tüm karakterleri de kullanabilmelidir.

Test Kılıfları

Doğru:

<your program's source code>
"aaaa"
"aa!1 1 !a !1"
"aabbccddeeffgg"
"1Q!V_fSiA6Bri{|}tkDM]VjNJ=^_4(a&=?5oYa,1wh|R4YKU #9c!#Q T&f`:sm$@Xv-ugW<P)l}WP>F'jl3xmd'9Ie$MN;TrCBC/tZIL*G27byEn.g0kKhbR%>G-.5pHcL0)JZ`s:*[x2Sz68%v^Ho8+[e,{OAqn?3E<OFwX(;@yu]+z7/pdqUD"

Falsy:

"a"
"abbaabb"
"abc"
"bQf6ScA5d:4_aJ)D]2*^Mv(E}Kb7o@]krevW?eT0FW;I|J:ix %9!3Fwm;*UZGH`8tV>gy1xX<S/OA7NtB'}c u'V$L,YlYp{#[..j&gTk8jp-6RlGUL#_<^0CCZKPQfD2%s)he-BMRu1n?qdi/!5q=wn$ora+X,POzzHNh=(4{m`39I|s[+E@&y>"

Brachylog , 10 bayt

=ᵍbᵐbᵐlᵍ=l

Çevrimiçi deneyin!

açıklama

=ᵍ                Group all equal elements together
  bᵐbᵐ            Remove the first element of each group twice. This fails if
                  there are fewer than 2 elements
      lᵍ          Group elements together that have the same length
        =         Are all elements of that list equal? This only succeeds if the
                  list has one element
         l        Length. This will always succeed

Java 8, 198 192 186 174 168 165 160 bayt (karakter sayısı 6 5)

o->{byte x[]=new byte[+333-3|2],u=-0,i,fe,fi,w; s:w:no0r3sswwyyy:for(int s:o){{u=++x[s];}};for(int b:x){if(!!!(2>b||u==b)|2>u|2>2){x[0]++;}}return!!(0>--x[0]);}

Çevrimiçi deneyin. Bu zorluğun cevabı olan
karakterlerin oluşumunu doğrulamak için kullanılan kod .

-5 byte @ OlivierGrégoire'a yorumlardan kurtularak ve bir karışıklık yaparak tekrar teşekkürler . ;)

Eski 168 bayt (karakter sayısı 6) cevabı :

o->{int w[]=new int[2222],u=0,f=0;for(int r:o)u=++w[r];for(int e:w)if(!(2>e|u==e)|2>u)f++;return!(f>0);}//[[[]]]  !!!!e(i)++,,,,-----oo////000tuww::::{{{{{;;||||}}}}}>>

Çevrimiçi deneyin.
Kod açıklama hariç karakterlerin oluşumlarını doğrulamak için kullanılan benim cevap oldu, bu meydan .

-6 bayt @ OliverGrégoire sayesinde <çekleri değiştirerek çıkarmadan >.

Temel golf programının açıklaması (98 bytes):
Çevrimiçi deneyin.

s->{                     // Method with character-array parameter and boolean return-type
  int a[]=new int[256],  //  Occurrences integer-array containing 256 zeroes
      t=0,               //  Temp integer, starting at 0
      f=0;               //  Flag integer, starting at 0
  for(int c:s)           //  Loop over the input
    t=++a[c];            //   Increase the occurrence-counter of the current character
                         //   And set the temp integer to this value
  for(int i:a)           //  Loop over the integer-array
    if(i>1               //   If the value is filled (not 0) and at least 2,
       &i!=t             //   and it's not equal to the temp integer
       |t<2)             //   Or the temp integer is lower than 2
      f++;               //    Increase the flag-integer by 1
  return f<1;}           //  Return whether the flag integer is still 0

Kullanılan karakter miktarını azaltmak için yaptığım bazı şeyler:

• Değişken adları o, w, u, f, r, ve ebiz zaten vardı yeniden kullanım karakterler kasten seçildi (ancak 6 aşmayan).
• 2222yerine kullanılır 256.
• 6x kaldırmak için if-check e>0&u!=e|u<2değiştirildi .!(e<2|u==e)|u<2&
• İki ayrı döner çıkarılır ve bir bayrak kullanılır fve bunun (bu, 6x kaldırmak anlamına geliyordu sonunda halen 0 olup olmadığı geri bygelen bytesadece kullanmak artık niçinde intyerine 8 6 kat).
• e<2ve 6x kaldırmak u<2için 2>eve 2>uolarak değiştirildi <.

6 - 5 karakter sayısını azaltmak için ne yaptım:

• 2x intiçin byteçok miktarı nkullanılabilir 4 yerine 6'dır.
• Kullanılan x[0]yerine yeni bir değişkenin f=0miktarı böylece =Kullanılan 5 yerine 6 olduğunu.
• Değiştirildi 2222için 3333çok miktarı 2Kullanılan 2 yerine 6'dır.
• Değişen değişkenler fve ryine de artık 6 değillerdi.

@ OlivierGrégoire bu yorumdan ve dolayısıyla 5x'ten kurtulmak için ne yaptı /:

• Kullanılmayan değişkenleri ekleme ,i,fe,fi,w;.
• Kullanılmayan etiketleri ekleme: s:w:no0r3sswwyyy:.
• Kullanılmayan ekleme |2>2
• Ekleme {}için döngüler ve IFS çevresinde ve kullanılmamış bir ilave {}-blok.
• Değişen !için !!!.
• Değişen |için ||.
• Değişen 333için +333-3|2artık aritmetik operatörler kurtulmak +-|ve 2.
• Değişen !(x[0]>0)için !!(0>--x[0]).

Jöle , 18 16 12 10 bayt

Ġ¬zḊḊ¬zĠȦȦ

Çevrimiçi deneyin!

Nasıl çalışır

Ġ¬zḊḊ¬zĠȦȦ  Main link. Argument: s (string)

Ġ           Group the indices of s by their corresponding elements.
            "abcba" -> [[1, 5], [2, 4], [3]]

 ¬          Take the logical NOT of each 1-based(!) index.
            [[1, 5], [2, 4], [3]] -> [[0, 0], [0, 0], [0]]

   Ḋ        Dequeue; yield s without its fist element.
            "abcba" -> "bcba"

  z         Zip-longest; zip the elements of the array to the left, using the
            string to the right as filler.
            ([[0, 0], [0, 0], [0]], "bcba") -> [[0, 0, 0], [0, 0, "bcba"]]

    Ḋ       Dequeue; remove the first array of the result.
            This yields an empty array if s does not contain duplicates.
            [[0, 0, 0], [0, 0, "bcba"]] -> [[0, 0, "bcba"]]

    ¬       Take the logical NOT of all zeros and characters.
            [[0, 0, "bcba"]] -> [[1, 1, [0, 0, 0, 0]]]

      Ġ     Group.

     z      Zip-longest. Since all arrays in the result to the left have the same
            number of elements, this is just a regular zip.
            [[1, 1, [0, 0, 0, 0]]] -> [[1], [1], [[0, 0, 0, 0]]

       Ȧ    Any and all; test if the result is non-empty and contains no zeroes,
            at any depth. Yield 1 if so, 0 if not.
            [[1], [1], [[0, 0, 0, 0]] -> 0

        Ȧ   Any and all.
            0 -> 0

Brachylog , 14 12 bayt

ọtᵐℕ₂ᵐ==tℕ₂ọ

Çevrimiçi deneyin!

açıklama

ọ   Occurrences. Gives a list of [char, count] pairs for the entire input.
tᵐ  Map "tail" over this list, giving each character count.
ℕ₂ᵐ Make sure that each count is at least 2.
=   Make sure that all counts are equal.
    At this point we're done with the actual code, but we need another copy
    of each character (except ᵐ). We can just put them after this, as long as
    we make sure that they can never cause the predicate to fail.
=   Make sure that all counts are equal, again...
t   Extract the last count.
ℕ₂  Make sure that it's at least 2, again...
ọ   Get the digit occurrences in that count, this can't fail.

Yeniden tyerine alternatif 12 baytlık çözüm ᵐ:

ọtᵐ==tℕ₂ℕ₂ọᵐ

T-SQL, 320 bayt (her biri 32 karakter x 10)

Girdi önceden mevcut tablonun yoluyladır FILLvarchar alan ile STEW, bizim IO standartlarına göre .

WITH BUMPF AS(SeLeCT GYP=1
UNION ALL
SeLeCT GYP+1FROM BUMPF
WHeRe GYP<=1000)SeLeCT
IIF(MIN(WAXBY)<MAX(WAXBY)OR
MAX(WAXBY)<=1,+0,+1)FROM(SeLeCT
WAXBY=COUNT(1),WHICH=+1+0,HEXCHANGE=+01,HUNG=+0+1,CHLUB=+0,GEFF=+0FROM
BUMPF,FILL WHERE
GYP<=LEN(STEW)GROUP BY
SUBSTRING(STEW,GYP,1))CHEXX
OPTION(MAXRECURSION 0)----------<<<<<<

Daha önce hiç bir zaman bir kod parçasından daha fazla memnun olmadım, daha çok korkmadım.

Büyük / küçük harfe duyarlı bir harmanlamaya ayarlanmış bir sunucuda veya veritabanında çalıştırılmalıdır. Büyük ve küçük Eharfler (SQL komutları büyük / küçük harfe duyarsızdır, bu yüzden gerektiği kadar az sayılır), boşluklar ve sekmeler (sekmeler okunabilirlik için yukarıdaki kodda satır sonları olarak gösterilir) dahil olmak üzere 32 farklı karakterden 10'undan oluşur .

Koddaki diğer simgelerden 10 tanesini dahil etmenin yollarını buldum + = ,, ancak ne yazık ki bunu yapmanın bir yolunu bulamadım <, bu yüzden yorum karakterini eklemek zorunda kaldım -.

İşte tüm ekstra dolguya tıkılmadan önce biçimlendirilmiş kod:

WITH b AS (SELECT g=1 UNION ALL SELECT g+1 FROM b WHERE g<1000)
SELECT IIF(MIN(w)<MAX(w) OR MAX(w)<1+1,0,1)
FROM(
    SELECT w=COUNT(1), --extra constant fields here are ignored
    FROM b, fill
    WHERE g < 1+LEN(stew)
    GROUP BY SUBSTRING(stew,g,1)
)a OPTION(MAXRECURSION 0)

Üst satır, bkaraktere göre ayırmak için kaynak dizgiye eklediğimiz sayı tablosunu üreten özyinelemeli bir CTE'dir . Bu karakterler gruplanır ve sayılır ve IIFgiriş dizesinin ayrımcı olmamasına bağlı olarak ifade 0 veya 1 değerini döndürür.

C (gcc) ,  333  168 bayt

9 byte tasarruf için @Kevin Cruijssen'e ve 45 byte tasarruf için @Laikoni'ye teşekkürler!

f(r,h,a){char*o=r,c[222]={!o};for(a=!o;*o;)++c[*o++];for(h=!o;222/++h;c[h]&&c[h]!=a&&(a=!*c))!a&&c[h]&&(a=c[h]);r=!(2/2/a);}/////!(())****++,,,,,[[]]fffffrr{{{{{{}}}}}}

Çevrimiçi deneyin!

C, 333 bayt

i,v;f(S){char*s=S,L[128]={0};for(v=0;*s;)++L[*s++];for(i=-1;++i<128;L[i]&&L[i]-v?v=-1:0)!v&&L[i]?v=L[i]:0;return-v<-1;}/////////!!!!!!!!&&&&&(((((())))))******+++,,,,,,,----00000111122222228888888:::::::<<<<<<<===???????LLLSSSSSSS[[[]]]aaaaaaaacccccccceeeeeeeeffffffhhhhhhhhiinnnnnnnnooooooorrrrssssssttttttttuuuuuuuuvv{{{{{{{}}}}}}}

Hatta bytecount bile ayrım gözetmez!

Çevrimiçi deneyin!

05AB1E , 20 18 16 14 bayt

S¢Z≠sË*sZ¢≠SË*

Çevrimiçi deneyin!

Program esas olarak birinci bölümün amacının asıl görevi yapmak olduğu ve ikinci bölümün amacının sonucu değiştirmeden ilk kısım ile aynı fonksiyonları kullanmak olduğu 2 kısma ayrılmıştır.

Açıklama (ilk bölüm)

S          # push input split into list of chars
 ¢         # count the occurrence of each char in input
  Z≠       # check that the max count is not 1
    sË     # check if all counts are equal
      *    # multiply

Açıklama (ikinci bölüm)

s          # swap input to top of stack
 Z¢        # count the number of occurrences of the largest element
   ≠       # check that the count isn't 1
    SË     # split into list and check that each element are equal (always true)
      *    # multiply (as it is with 1, the original result is left unchanged)

Kabuğu , 14 bayt

§<ε#εu§m#u
m
<

Çevrimiçi deneyin!

açıklama

İki kısa hat işlem dışıdır, çünkü ana işlev asla çağırmaz.

§<ε#εu§m#u  Implicit input, say S = "asasdd"
         u  Remove duplicates: "asd"
      §m#   For each, get number of occurrences in S: [2,2,2]
     u      Remove duplicates: L = [2]
   #ε       Number of elements in L that are at most 1: 0
  ε         1 if L is a singleton, 0 otherwise: 1
§<          Is the former value smaller than the latter?

Python 2 , 75 69 bayt

def f(s):len({2<<s.count(c)-2for c,in s})<2or{{e.dil:-tu,r.dil:-tu,}}

Çıktı, bir hatanın varlığı veya yokluğu yoluyladır. Hata bir ValueError (bir veya daha fazla karakter yalnızca bir kez gerçekleşir) veya bir NameError (karakter sayıları eşit değildir) şeklindedir.

Çevrimiçi deneyin!

Brachylog v2, 8 bayt (Brachylog karakter kümesinde)

oḅ\k\koḅ

Çevrimiçi deneyin!

Brachylog'da bu soruya devam eden bir golf savaşı var gibi gözüküyor, bu yüzden bir sonraki en iyi cevaba göre birkaç byte tasarruf ederek katılacağımı düşündüm.

Bu, karakter kodlarının bir listesi olarak girdi alan tam bir programdır. (Bu kısmen Brachylog'un dizelerde ters eğik çizgiyle ilgili çok tuhaf hatalara sahip olduğu ve kısmen \komutun dizelerin listelerinde çalışmadığı için olduğu içindir.)

açıklama

oḅ\k\koḅ
o          Sort {standard input}
 ḅ         Group identical adjacent values
  \        Assert rectangular; if it is, swap rows and columns
   k       Delete last element
    \      Assert rectangular; (rest of the program is irrelevant)

koḅSonunda önemsizdir; kHer zaman hareket ve bir öğe olacak ove ḅgiriş olarak bir liste verilirse başarılı olamaz.

Başlangıç ​​sebebi oḅaçık olmalıdır; giriş listesini değere göre böler, örneğin [1,2,1,2,4,1]olur [[1,1,1],[2,2],[4]]. Her karakterin aynı sayıda görünmesi için, bu listelerden her birinin aynı uzunlukta olması gerekir, yani sonuçta elde edilen liste bir dikdörtgendir. Bu dikdörtgeni \, aynı zamanda yanları olarak satırları ve sütunları çeviren kullanarak da söyleyebiliriz .

Şimdi karakter setinin çoklu kopyalarından oluşan bir akım değerine sahibiz, örneğin eğer giriş [4,2,1,2,4,1]geçerli değer ise [[1,2,4],[1,2,4]]. Bir kopyasını silersek, sonuçta elde edilen matris hala dikdörtgendir, bu yüzden kullanarak tekrar açabiliriz \. Matris dikdörtgen olduğu nedeni, her girdi karakterleri ayrı idi, ancak elde edilen matris kalan herhangi bir öğe olacaktır ve \yok değil dikdörtgen (tercihan, başarısız) gibi bir "0 x 0" matris tedavi. Dolayısıyla oḅ\k\, girdide görünen her karakterin aynı sayıda göründüğünü ve bu sayıların 1 olmadığını gösterir.

Programımızın tüm işlevselliği budur (tam bir program olarak, bazılarının trueyapması durumunda herhangi bir iddia hatası oluşmazsa alırız false). Gerçi kaynak düzeni kısıtlama uymak zorundadır, bu yüzden ben ek bir katma koḅhiçbir amaca sahip olduğunu ancak başarısız (aksine olamaz ki \, ove ḅboş listelerine hareket etmeye mutluyuz).

Python 2 , 84 80 bayt

x=input()
c=map(x.count,x)
print max(c)==min(c)>1
1. or our>ram>>utopia,
1., 1.,

Çevrimiçi deneyin!

JavaScript (Node.js) , 144 ... 100 96 bayt

o=>!(a=o.split``.map(i=>o.split(i||aeehhhlmmnnnpst)[`length`]-1)).some(g=>![g>1][-!1]||a[-!1]-g)

Çevrimiçi deneyin!

24 farklı karakter * her biri 6 kez

28 farklı karakter * her biri 5 kez

27 farklı karakter * her biri 5 kez

27 farklı karakter * her biri 4 kez

26 farklı karakter * her biri 4 kez

25 farklı karakter * her biri 4 kez

24 farklı karakter * her biri 4 kez

açıklama

o=>!(
 a=o.split``.map(                            // Split the input into character array and
  i=>o.split(i||aeehhhlmmnnnpst)[`length`]-1 // count the occurrences of each character.
 )
).some(                                      // Then check
 g=>![g>1][-!1]                              // If each character appears at least twice
 ||a[-!1]-g                                  // and the counts are all the same number.
)                                            

More to add:
1. Using {s.split``} instead of {[...s]} is to reduce the number of {.} that dominates
   the count.
2. Using {!c.some} instead of {c.every} to reduce the number of inefficient characters 
   (v,r,y in every)
3. Still one unavoidable inefficient character left ({h}).

Update:
1. Got rid of one {.} by replacing {.length} by {["length"]}.
2. Got rid of one {=} by replacing {c[-!1]!=g} by {c[-!1]-g}.
3. Got rid of one {()} by replacing {!(g>1)} by {![g>1][-!1]}.
4. Finally, because count per character is now 4, the backslashes can be taken out.

Update:
1. Got rid of all {"} by replacing {"length"} by {`length`} and exploiting shortcut
   evaluation. 
   {aaaeehhhlmmnnnpst} is not defined but is not evaluated either because of {c} which
   must be evaluated to true.

Update:
1. Got rid of all {c} by shortcutting the undefined variable at {split(i)} and replacing 
   all {c} by {a}.
   Since {i} is never an empty string, it is always evaluated true (except compared 
   directly to true).

Update:
1. Got rid of all {,} by moving the assignment after the argument list. The {()} at the
   front can therefore be moved to the assignment, retaining same number of {()}s.

PowerShell , 104 bayt

($qe=$args[0]| group |sort count|% count)[0]-eq$qe[-1]-and$qe[0]-gt1####((()))%%%pppddd===aaccss11nu|0gr

Çevrimiçi deneyin!

Bu golf için çok eğlenceliydi. Sınırlama, $en az dördüne ihtiyacımız olan (biri giriş için $args, biri hesaplama sonucunu belirlemek için $qe, biri son karakteri $qe[-1]kontrol etmek için diğeri ilk karakteri kontrol etmek için) $qe[0], böylece maksimum çalışma karakter sayısıydı.

Oradan, programın dörde bölünmüş bir şekilde ayrılması için golf oynamak (ve iki harfli değişken isminde olduğu gibi golf oynamak değil) meselesiydi. #Bazı eksik unsurları hesaba katan küçük bir yorum (aşağıdakileri takip eden her şey ) olduğuna dikkat edin, ancak yorumu olabildiğince küçük tutmaya çalıştım.

Haskell, 90 75 72 bayt

a[i]|d:n<-[[i|n<-i,n==a]|a<-i]=and[[i]<d,[d|i<-n]==n]--aadd,,,,:::::<=||

Her karakter 6 kez görünür. Giriş dizesi tekil bir liste olarak alınır .

Çevrimiçi deneyin!

Referans için eski versiyonlar:

75 bayt, her karakter 5 kez

n(l)|d<-[[0|n<-l,n==a]|a<-l]=and[[0]<d!!0,all(==d!!0)d]--an!((())),,,0<[]||

Çevrimiçi deneyin!

90 bayt, her karakter 3 kez:

a x|h:u<-[sum[1|d<-x,not(d/=c)]|c<-x],"  \"\\&,../1::>acdlmmnosst">[]=h>1&&all(not.(/=h))u

Çevrimiçi deneyin!

Python 2 , 108 104 92 88 bayt

Çubuk
-4 bayt sayesinde -12 bayt Kevin Cruijssen sayesinde

s=input();c=s.count;print[all(c(s[[]>[1]])==c(o)>1. for o in s)];aaafffillpprrtuu>1.>1.;

Çevrimiçi deneyin!

MATL , 12 bayt

q&=sqt&=tsvv

Giriş, tek tırnak içine alınmış bir dizedir. Dizedeki tek tırnak işaretleri çoğaltılarak çıkarılır.

Çıktı, sıfır içermiyorsa kaba olan ve en az sıfır içeriyorsa sahte olan boş olmayan bir matristir .

Çevrimiçi deneyin! Veya , kolaylık sağlamak için standart doğruluk / yanlışlık testi de dahil olmak üzere tüm test durumlarını doğrulayın .

Nasıl çalışır

İle işaretlenmiş (*)ifadeler ne gerekli ne de zararlıdır ve kaynak kodun ayrım gözetmemesi için yalnızca eklenmiştir.

q     % Implicit input. Convert chars to code points and subtract 1 from each (*)
&=    % Square matrix of all pairwise equality comparisons
s     % Sum of each column. Gives a row vector
q     % Subtract 1 from each value. An entry equal to 0 indicates the input string
      % is discriminating because some character appears only once
t     % Duplicate
&=    % Square matrix of all pairwise equality comparisons. An entry equal to 0
      % indicates the input string is discriminating because some character is
      % more repeated than some other
t     % Duplicate (*)
s     % Sum of each column (*) (all those sums will be positive if the previous
      % matrix doesn't contain zeros)
v     % Vertically concatenate the matrix and the vector of its column sums
v     % Vertically concatenate the resulting matrix with nothing (*)
      % Implicit display

Perl 5 , -p57 bayt

Her karakter 3 kez görünür. Sadece bir kişi 1hiçbir şey yapmaz

Ayrımcılık yapmayan bir temel 45 karakterlik çözüm için 12 bayt eklendi

s{.}[@m[@1{$&}+=$.].=g]eg;$\=s()(e@m;1)&&m[e(\sg+)\1+;]}{

Çevrimiçi deneyin!

R , 90 bayt

"?"=`u\164f8ToI\x6Et`;'!'=prod;!{y<-xtabs(~?readLines())}%in%{z<-y[1]}&z>T##&[]>~48bEfILpu

Çevrimiçi deneyin!

TRUEAyırt edici olmayan bir dize ve ayırımcı bir dize için çıktılar FALSE. Bu sitedeki zorluklar için çok çirkin bir kod yazdım, ancak bunun en çirkin olduğunu düşünüyorum.

Her biri iki kez kullanılan 45 yorum (bir yorumda birkaçı dahil). Önceki en iyi R cevabı 116 bayttı , her biri 4 kez 29 karakter kullanılmış; Bunu büyük ölçüde farklı olduğu için ayrı olarak gönderiyorum.

Kod eşdeğerdir

y = table(utf8ToInt(readLines()))
z = y[1]
all(y == z) & (z > 1)

bu girdiyi bir tamsayı vektörüne dönüştüren, ydeğerlerin bir beklenmedik durum tablosunu hesaplar , ardından bu tablodaki tüm sayımların ilk sayıma eşit olduğunu ve ilk sayımın 1'den büyük olduğunu kontrol eder.

İlk zorluk sadece 2 çift parantez kullanmaktı. Bu, unary fonksiyonlarının yeniden tanımlanması ve sırasıyla !ve ?olması ile başarılır . (Kullanamam çünkü ihtiyacım var ). Dört atama vardır: iki ve iki ile . Bu, eşitlik testinin kullandığı ve kullanamadığı ve ; kurtarmaya gelir.utf8ToIntprodalla=<-yzy==zy-zy%in%z

Bu işlevleri tanımlamak mümkün olan tüm teklifleri kullanır: iki çift tırnak, iki tek tırnak ve bir sonraki paragrafta iki geri dönüşe ihtiyacım olacak, bu yüzden readLines()yerine başvurmak zorunda kaldım scan(,""). (Gibi scan(,letters)veya scan(,month.abb)tümü gibi diğer seçenekler, yedekleyemediğim bir kıymetli kullandı t .)

Bu noktada, yapı taşları oldu utf8ToInt, prod, table, readLines, %in%. Üç karakter o adlarında üç kez görünür: ent. Birincisi, keşfetti table(foo)eşdeğerdir xtabs(~foo)tasarruf e. Onaltılık / sekizli kod hile ile nve kurtarma ; golfi çözüm (backticks içinde) için kullanmaktır .tu\164f8ToI\x6Etutf8ToInt

Brachylog , 18 bayt

oḅlᵐ=h≥2
oḅlᵐ=h≥2

Çevrimiçi deneyin!

Ne yazık ki, ḅhatalı beslemeleri kaldıramam, çünkü bir sayı başarısız oluyor.

Ruby , 87 78 bayt

c=->m{y=m.chars;x=y.map{|d|y.count d}|[];x[-1]>1and not x[1]};->{pushrortpush}

26 karakter her biri 3 kez tekrarlandı

Çevrimiçi deneyin!

R, 132 116 bayt

crudcardounenforceableuploads<-function(b){{pi&&pi[[1-!1]];;;"";{1<{f<<-table(strsplit(b,"",,,)[[1]])}}&&!!!sd(-f)}}

Herhangi bir yorum veya gereksiz dizgi içermiyor, ancak bu muhtemelen kod golfde bir işlev çağırmak için tek zamanım olacak crudcardounenforceableuploads. İşlev adı için orada bir yerde büyük bir anagram var! John Dvorak'a, adını kullandığım güzel bir anagram çözücüsünü işaret ettiği için teşekkür ederiz.

Karakter tablosu:

- , ; ! " ( ) [ ] { } & < 1 a b c d e f i l n o p r s t u 
4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4

örnekler:

> crudcardounenforceableuploads("aaabbbccc")
[1] TRUE
> crudcardounenforceableuploads("aaabbbcc")
[1] FALSE
> crudcardounenforceableuploads("abc")
[1] FALSE
> crudcardounenforceableuploads("crudcardounenforceableuploads<-function(b){{pi&&pi[[1-!1]];;;\"\";{1<{f<<-table(strsplit(b,\"\",,,)[[1]])}}&&!!!sd(-f)}}")
[1] TRUE

BASH 144 bayt

grep -o .|sort|uniq -c|awk '{s=$1}{e[s]=1}END{print((s>1)*(length(e)==1))}##>>>#|'#wwwuuutrqqqppooNNNnlllkkkiihhhggEEEDDDcccaaa1***{}[[[]]]...--''

Bu kod satırı girdi olarak stdin dizesini alır. "grep -o" her karakteri yeni bir satıra yerleştirir. "uniq -c", her bölümün kullanımını sayar. Awk betiği, her kullanımda farklı bir öğe olarak bir dizi oluşturur ve yalnızca 1 dizi dizini olduğunda ve değer en az 2 olduğunda doğru çıktılar. Her karakter 4 kez kullanılır, bu nedenle bu kaynak true döndürür

Stax , 26 24 18 bayt

:u{m*_{y#m:u_hy#h*

Çevrimiçi deneyin!

Bugüne kadarki en kısa çözüm, yalnızca MATL tarafından dövülmüş yazdırılabilir ASCII'ler kullanır .

Sanırım soruna yanlış yoldan yaklaşıyordum. Bir çalışma bloğunu tekrarlamak ne golf ne de ilginç. Şimdi en azından daha iyi görünüyor ...

açıklama

:u{m* çıktıyı etkilemeyen bazı çöpler üretir.

_{y#m:u_hy#h*
_{y#m           map each character to its number of occurences in the string
     :u         all counts are equal (result 1)
       _hy#     get the count of appearance for the first character
           h    halve it and take the floor, so that 1 becomes 0(result 2)
            *   multiply the two results

Pip , 22 bayt

I1&MY$=_Y_NaMa$=y&1NIy

Çevrimiçi deneyin!

açıklama

Her karakter iki kere oluşur.

                        a is first command-line argument
I1&MY$=_                No-ops to make the program non-discriminating
            Ma          Map this function to the characters of a:
         _Na             Count occurrences of each character in a
        Y               Yank the result into y
              $=y       Fold y on equals: truthy if all elements are equal
                 &      Logical and
                  1NIy  1 is not in y
                        Autoprint the result of the last expression

Daha az no-op'lu alternatif 22 baytlık sürüm:

$&MY_Y_NaMa$=y&--1=1Ny

SmileBASIC, 164 152 148 140 bayt

DeF M(X)DIM W[#R]WHILE""<X
INC w[ASC(x)]X[n]=""wEND
FOR F=e#TO--nOT-LEN(W)U=w[F]H=H||U&&U<MAx(W)neXT-!!!AASSS#&&Oxx||CCLL<<wIM#
RETURN!H
enD

Her biri 4 kez tekrarlanan 35 farklı karakter.

Hiçbir yorum kullanılmamıştır (ancak sonraki ifade neXThiçbir zaman gerçekten değerlendirilmez)

Cevapları kontrol etmek için komut dosyası:

//javascript is a convenient language that I love using!
var input=document.getElementById("input");
var button=document.getElementById("button");
var output=document.getElementById("output");

button.onclick=function(){
  var text=input.value;
  var freqs={};
  for(var i=0;i<text.length;i++){
    var letter=text.charAt(i);
    if (freqs[letter]==undefined) freqs[letter]=0
    freqs[letter]++
  }
  sorted=Object.keys(freqs).sort(function(a,b){return freqs[b]-freqs[a]})
  var out="";
  var min=Infinity,max=0;
  for (var i in sorted) {
    var letter=sorted[i];
    var count=freqs[letter];
    if(count<min)min=count;
    if(count>max)max=count;
    out+="\n"+letter+":"+count;
  }
  output.textContent="min:"+min+"\nmax:"+max+"\nunique:"+sorted.length+"\nlength:"+text.length+out;
}

<textarea id="input" placeholder="code here"></textarea>
<button id="button"butt>count</button>
<pre id="output">...</pre>

Retina 0.8.2 , 168 90 bayt

Çıktı yanlışsa boş, doğru değilse boş olacaktır.

***???;;;;```!!$$$$MMMMOOOO..1111ssss222{{{{\^^^^

s;{O`.
M!*\`^((.)\2(?!\2))*$
(.)(?!\1)

Çevrimiçi deneyin

Çekirdek program (39 bayt)

s;{O`.
M!*\`^((.)\2(?!\2))*$
(.)(?!\1)

açıklama

Tüm çekirdek program sessiz bir döngüdedir. İlk aşama girişi sıralar. İkinci aşama, ardışık farklı karakter çiftlerinden oluşuyorsa, geçerli dizgeyi basacaktır. Üçüncü aşama, her karakterin son oluşumunu kaldırır (dizedeki her karakterden birini kaldırarak).

Üstteki önemsiz hakkında: sipariş önemlidir. Sözdizimsel olarak geçerli olması gerekmesine ek olarak, bir noktalı virgül, yıldızların peşinden ve geri tepmelerden önce *, yapılandırılmaması için yapılandırma dizesinde olduğu sürece olmalıdır .

CoffeeScript 1 , 96 93 90 bayt

(q,a=q.split(h).length-1for h in[q][0])->a.every (w,s,pplitnggffoorsvvyy)->w>1&&a[0&10]==w

Çevrimiçi deneyin!

ES6 cevabımdan başladı, fakat tekrar kullanmak için yürüdüm Array.every. Her biri 3'er adet 32 31 30 jeton

Pyth, 30 bayt

  "&8<MQSlqr{"&q1lJ{hMrSz8<1hJ

Lider boşluklar gerekli.

Çevrimiçi deneyin!

Gerçek program sadece &q1lJ{hMrSz8<1hJ. Sadece dizeyi "&8<MQSlqr{"ayrım gözetmemesi için hazırladım. Ancak dizginin kendisini yazdırmaması için bir boşluk eklemek zorunda kaldım, bu yüzden 2 boşluk ekledim.

&q1lJ{hMrSz8<1hJ

 q1l                (1 == len(
    J{                  J = deduplicate(
      hM                  map(lambda a: a[0],
        r  8                length_encode(
         Sz                   sorted(input())
                            )
                          )
                        )
                    )
&                     and
            <1hJ    (1 < J[0])

length_encodehere ( r <any> 8) bir diziyi alır ve aynı karakterdeki her işlemin uzunluğunu verir, örn. "aaabbcc"olur [[3, "a"], [2, "b"], [2, "c"]].

Dolayısıyla bu girdiyi alır, uzunluğu kodlamak için sıralar ve sonuçtaki listedeki her listenin ilk öğesini alır (örneğin önceki örnek olur [3, 2, 2]). Bu, karakterlerin kaç kez gerçekleştiğini gösterir. Sonra tekilleştirildi (önceki örnek olacaktı [3, 2]) ve J buna ayarlandı.

Daha sonra uzunluk 1 olup olmadığını kontrol eder, yani bir karakterin yalnızca 1 benzersiz sayısı olduğunu ve bunun> 1, yani> = 2 olup olmadığını kontrol eder.

Değiştirmek için bir yerleşik olabilir rSz8veya hMrSz8bir tane bulamıyorum.

C (gcc) , 153 bayt

f(h,a,c,f){{{{{{{char*o=f=h,*r;for(a=!h;*o;o++){for(c=!h,r=h;*r;c+=!(*r++^*o)){}f*=!!(c^!!h)*(!a+!(a^c));a=c;}(a^c^c^f^f^h)+o,a+r,o,o,+h^*r;(a=f);}}}}}}}

Çevrimiçi deneyin!

Dize adresini truthy value, sıfır olarak da falsy döndürür.

f(
h,                              Address of string.
a,                              # instances of previous character
c,                              # instances of current character
f                               Return value
){{{{{{{                        
char*o=f=h,*r;                  Point o to string, while giving f a non-zero value.
for(a=!h;*o;o++){               Set previous char count to 0, and then traverse the string.
for(c=!h,r=h;*r;                Set current char count to 0 and r to string,
                                and start counting instances of current character.
c+=!(*r++^*o))                  Add to counter if current character matches.
{}                              Lower the amount of semi-colons
f*=                             Multiply (AND) return value with:
   !!(c^!!h)                    Is current count not 1? (Must be 2 or above.)
            *(!a+!(a^c));       AND, is previous count valid (meaning this is not the first
                                character counted), and matches current count?
a=c;}                           Previous count = current count.
(a^c^c^f^f^h)+o,a+r,o,o,+h^*r;  Spend surplus characters to make source code valid.
(a=f);}}}}}}}                   Return value.

Perl 6 , 58 57 bayt

{.max==.min>()**()}o{(bag .comb){*}}###=>>abccggiinnoxx  

Çevrimiçi deneyin!

Üç karakter sürümünün iki karakterden biraz daha kısa olduğu ortaya çıktı.